pax_global_header00006660000000000000000000000064126635237530014526gustar00rootroot0000000000000052 comment=2cb606587b4a0db17abe1317877c6a340912077b ecl-16.1.2/000077500000000000000000000000001266352375300123605ustar00rootroot00000000000000ecl-16.1.2/.gitignore000066400000000000000000000007621266352375300143550ustar00rootroot00000000000000*.tgz *~ .*.swp \#* build cov-int *.data *.dll *.exe *.exp *.fas *.ilk *.implib *.lib *.manifest *.obj *.pdb msvc/help.doc msvc/*.bat msvc/*.lsp msvc/c/*.[ch] msvc/clos/*.lsp msvc/clos/*.[ch] msvc/cmp/*.lsp msvc/cmp/*.[ch] msvc/ecl/*.h msvc/ecl/gc/*.h msvc/ecl/gc/private/*.h msvc/ext/*.[ch] msvc/gc/gc_cpp.cpp msvc/gmp/msvc-build msvc/gmp/*.[ch] msvc/lsp/*.lsp msvc/lsp/*.[ch] BUILD-STAMP MODULES Makefile src/autom4te.cache src/config.log regressions/*.lsp regressions/eformat-tests/*.txt ecl-16.1.2/CHANGELOG000066400000000000000000000326361266352375300136040ustar00rootroot00000000000000* Announcement of ECL ECL stands for Embeddable Common-Lisp. The ECL project aims to produce an implementation of the Common-Lisp language which complies to the ANSI X3J13 definition of the language. The term embeddable refers to the fact that ECL includes a lisp to C compiler, which produces libraries (static or dynamic) that can be called from C programs. Furthermore, ECL can produce standalone executables from your lisp code and can itself be linked to your programs as a shared library. ECL supports the operating systems Linux, FreeBSD, NetBSD, OpenBSD, Solaris (at least v. 9), Microsoft Windows and OSX, running on top of the Intel, Sparc, Alpha, ARM and PowerPC processors. Porting to other architectures should be rather easy. * Known issues - In Windows ECL comes with bytecodes compiler by default, because C compilers are normally not available. Unfortunately several libraries out there are not prepared for this. If you plan to use quicklisp and have a C compiler accessible to ECL, you may use (ext:install-c-compiler) to switch back to the Lisp-to-C compiler. - In order to test package programmer has to install ECL on desired destination (specified with "--prefix" parameter given to configure script). * Pending changes since 16.0.0 ** API changes - si:do-setf accepts optional parameter stores. New lambda-list: =(access-fn function &optional (stores `(,(gensym))))= This change is backward compatible. - New MP functions: mp:with-rwlock mp:try-get-semaphore (non-blocking) mp:mailbox-try-read (non-blocking) mp:mailbox-try-send (non-blocking) - Added back removed C interfaces ecl_import_current_thread ecl_release_current_thread - When cl-truename encounters a broken symlink, it returns its path instead of signalling a file-error - Deprecated variables has been removed c::*suppress-compiler-warnings*, c::*suppress-compiler-notes* - Random state might be initialized by a random seed (truncated to 32bit value) or by a precomputed array. Latter is designed to allow reading back the printed random state (when printed readably), not as an array to initialize the random state. - C99 supporting compiler is mandatory for C backend. - COMPILER::*cc_is_cxx*: New variable to switch the output extension of emitted compiler code to ".cxx" when configured with "--with-c++". This eliminates compiler warnings that compiling C++ with a ".c" extension is deprecated; this is seen mostly with Clang++. - Added Clang-specific pragmas to disable return type, unused value and excessive parentheses warnings, which are fairly harmless, but annoying and clutter user output. - GRAY:CLOSE isn't specialized on T to preserve compatibility with some libraries. ** Enhancements: - Added code walker (present as *feature* :walker) - Testing framework cleanup - Format fallbacks to prin1 if infinity or NaN are passed to it - Annotations are added at runtime (better integration with SLIME) - Mersenne-Twister RNG has new 64 bit implementation for appropriate machines - Add sockets implementation for android platform - Add android build target (official android support) ** Issues fixed: - si:open-unix-socket-stream accepts both string and base-string (automatic coercion is performed) - Long form of DEFSETF accepts multiple-values as a store forms: (defsetf gah (x) (y z) `(list ,x ,y ,z)) (setf (gah 3) (values 3 4)) - Building with single-threaded boehm works if ECL threads are disabled - Using labels works with sharp-S-reader (read-from-string "(#1=\"Hello\" #S(sharp-s-reader.1.example-struct :A #1#))") - Generated C code works well with IEEE 754 infinities (regression tests created) - User-defined heap sizes can now exceed the size of a fixnum on 32-bit - The heap size limit was intended to be 1GB on 32-bit or 4GB on 64-bit but inconsistency between ECL_FIXNUM_BITS and FIXNUM_BITS in the code prevented the heap to grow for 64-bit. This now occurs, and a few other less visible bugs were fixed by restoring consistency to ECL_FIXNUM_BITS. - EXT:EXTERNAL-PROCESS-WAIT potential race condition fix - Building with object files not created by ECL works (CFFI wrappers) - Regression regarding initialization of build by ECL libraries from external code fixed. Static and shared libraries initialization funcitons has predetermined name while object files has randomized names. - Random state initial state generation was buggy and insecure (entropy from urandom was rejected) - Fix `listen' on streams when FILE_CNT isn't available (use read instad of fread) - `FIND' compiled with C compiler didn't respect `START' nor `END' arguments. Compiler macro is fixed now and should work as expected - `compute-applicable-methods-using-classes` bugfix * 16.0.0 changes since 15.3.7 ** API changes - There is no UFFI nickname for FFI package - we piggyback on cffi-uffi-compat for UFFI dependent systems (our UFFI wasn't version 2.0 compatible and there were problems with ADSF dependencies on UFFI - it wasn't a system) - CLOS has the new nickname "MOP" - The new ext:run-program :error argument can automatically create a separate stream if provided with the :stream keyword. The external-process structure also has a new field to hold that stream. - ext:run-program accepts new arguments - :if-input-does-not-exist, :if-error-exists and :external-format - ext:system no longer binds *standard-input* and *standard-output* and now ignores input and output (use ext:run-program for more control) - methods can be specialized on both single-float and double-float (built-in classes were added for them) - LET/FLET/LABELS will signal error if parameter of the same name will appear multiple times - lambda lists with repeated required parameter name are considered invalid - deprecated configure options "--with-system-boehm=x" and "--enable-slow-config" removed ** Enhancements: - Verification if manual is up-to-date, providing corrections for outdated parts - Documentation is now included in the main repository under the toplevel directory `doc' - Update libffi to version 3.2.1 - Update asdf to version 3.1.5.4 - Update Boehm-Demers-Weiser garbage collector to version 7.4.2 - Pathname string-parts internal representation is now character, not base-char - Dead code removal, tabulators were replaced by spaces - Better quality of generated code (explicit casting when necessary) ** Issues fixed: - Various fixes of bogus declarations - Remove deprecated GC calls - ROTATEF, SHIFTF, PSETF reworked to conform to the ANSI standard. Places were handled improperly in regard of multiple values. - Improved unicode support in character handling - Format handles floats and exponentials correctly (major format rework) - Stack limits refinements and cleanup, inconsistency and bug fixes - Duplicate large block deallocation with GMP 6.0.0a fixed - ECL builds on OpenBSD with threads enabled - Closures put in mapcar work as expected in both compiled and interpreted code - Improved readtable-case handling (:invert and character literals now conform) - Library initialization functions have unique names - no risk of clashing symbol names in object files - Format float bug fixed, when width and fdigits were not set, but k was - `logical-pathname-translations' now throws an error if logical pathname wasn't defined yet, to conform with ANSI (it used to return NIL) - Wildcards in logical pathname translations are replaced correctly - Regression testing framework and unit tests cleanup - deftype ANSI conformity fix (deftype accepts macro labda-lists) - ECL built with MSVC doesn't crash when Control-C is pressed - Other minor tweaks * 15.3.7 changes since 15.2.21 ** Issues fixed: - DEFUN functions not defined as toplevel forms were also directly referenced by other code in the same file. - STABLE-SORT works as desired (bogus optimization for strings fixed). - broken --with-sse=yes configure flag works once again. ** Enhancements: - autoconf scripts are rewritten to support version 2.69 stack. - stack direction is now correctly determined, fixing gcc 5.x builds. - compilation of ECL under MSVC (2008/2010/2012) even with custom code pages. - In compiled code it is possible to declare variables to have a C type such as in (declare (:double a)) and then the variable is enforced to be unboxed to such type. - New form FFI:C-PROGN used to interleave C statements with lisp code, where the lisp code may refer to any number of variables. Example: #+BEGIN_SRC lisp (lambda (i) (let* ((limit i) (iterator 0)) (declare (:int limit iterator)) (ffi:c-progn (limit iterator) "for (#1 = 0; #1 < #0; #1++) {" (print iterator) "}"))) #+END_SRC * 15.2.21 changes since 13.5.1 - Features coverity scan model, ffi-unload-module implementation, probably more. - Build system enhancements, parallel builds, fixes, simplifications, cleanups, maintenance. minor cleanup, maintenance. - Numerous fixes. * 13.5.1 changes since 12.7.1 ** Visible changes: - ECL now reports #+UNIX for all compatible systems, including *BSD ones. ** Compiler fixes: - Minor readability improvements in the C code. - MULTIPLE-VALUE-BIND compiles using MULTIPLE-VALUE-SETQ and now both are better optimized, generating simpler C code. - The type checking routine for LOGAND was producing spurious warnings. - (LDB (BYTE ...) ...) no longer conses a BYTE object. - Added optimizations for MASK-FIELD, DPB, DEPOSIT-FIELD, LDB-TEST and LDB. - CONSTANT-VALUE-P and friends now use the (compiler) environment. - No optional type check generated for constant values. - Declare the temporary variables in DEFMACRO/DESTRUCTURING-BIND as IGNORABLE - ECL now accepts WHILE/IF before FOR/AS, a construct that is not ANSI An example: (LOOP FOR I IN LIST WHILE (SOME-TEST I) FOR X = (F I) ... ) ** Common Lisp fixes: - CONSTANTP now performs a bit more work, macroexpanding forms. - ENSURE-DIRECTORIES-EXIST ignores the host and device from the original pathname when creating the directories. - In FORMAT, printing of floating point numbers could lead to an infinite loop. - ROUND, FLOOR, CEILING and TRUNCATE have been reorganized and work faster with rational numbers. - (CONCATENATE 'SIMPLE-BASE-STRING ...) returned an ordinary string. - MAKE-ARRAY did not terminate strings with #\Null (needed internally by the C code). - (SETF DOCUMENTATION) did not operate on functions because the function object documentation had precedence over the annotation. - Added the whole Unicode character database to the C library. This means ECL can now interpret all Unicode character names properly, and print them as well. ECL now also recognizes all ASCII control-character abbreviations - Print integers using upcase letters for radix > 10 - New functions RATIOP, {SINGLE,SHORT,DOUBLE,LONG}-FLOAT-P help avoid consing in TYPEP - HASH-TABLE-COUNT did not work with weak hashes: it did not update the count of live cells (Note, however, that this function is by definition not reliable, just a hint, since a garbage collection may happen while the count is being computed) - ECL no longer uses :READ-ONLY declarations in the SETF expansions because there is code out there that modifies the values variables. - PROGV can now 'unbind' variables when the list of variables is longer than the list of values. ** CLOS: - Added built in classes FIXNUM and BIGNUM. - Eliminated code for accessing slots that was no longer used. Removed also redundant code. - Updating a class (due to a change in metaclass) now forces updating its children - UPDATE-INSTANCE-FOR-REDEFINED-CLASS received an alist instead of a propertly-list as last argument - PRINT-OBJECT did not have a working default for built in classes. ** Extensions: - SYSTEM must use the POSIX shell, which usually lives in /bin/sh. - CLX now uses recursive locks. - ASDF upgraded to version 2.32, including the ASDF-BUNDLE facility, which supersedes ECL's own implementation of precompiled libraries. - MAKE-INSTANCE, SHARED-INITIALIZE, REINITIALIZE-INSTANCE now work on structures as well. * 12.7.1 changes Some highlights of this release are: - ECL now ships with the whole of the Unicode names database, optimally compressed using constant C tables. This means ECL now recognizes all valid Unicode (and ASCII) names for the whole range of characters, and can print them as well. - ECL has changed the way it stores compiled data in the C files, so that it works around the limit of 65k characters per string. - ECL now builds with Microsoft Visual Studio C++ 2012. - We bend the knee and accepted WHILE/IF statements intertwined with FOR/AS, though this is still not valid ANSI Common Lisp. * Settings ;;; Local Variables: *** ;;; mode:org *** ;;; fill-column:75 *** ;;; End: *** ecl-16.1.2/INSTALL000066400000000000000000000045031266352375300134130ustar00rootroot00000000000000You will find detailed installation instructions in the ECL manual https://common-lisp.net/project/ecl/manual/pr01s06.html If you do not have access to the online version, follow the following recipies. * Unix and similar platforms. 1. Type ./configure --help to get a list of the flags with which ECL can be configured. 2. Enter ./configure ... where "..." is the set of flags you have chosen. 3. Use "make" followed by "make install" to build and install ECL. * Windows with Visual Studio C++ 2008 1. Enter the msvc directory 2. Read the file Makefile to find the configuration options. They typically have the form ECL_UNICODE=1, ECL_THREADS=1, etc 3. Enter nmake ... followed by zero or more of those options 4. Use "nmake install" to create a directory called "package" with ECL in it. 5. Move that directory wherever you need. * Cross-compile for the android platform (from the UNIX machine) 1. Build the host ECL #+BEGIN_SRC shell-script ./configure ABI=32 CFLAGS="-m32 -g -O2" LDFLAGS="-m32 -g -O2" \ --prefix=`pwd`/ecl-android-host \ --disable-longdouble \ --enable-libatomic=included make -j9 make install rm -r build export ECL_TO_RUN=`pwd`/ecl-android-host/bin/ecl #+END_SRC 2. Build the toolchain (requires android-ndk) and export the necessary paths - if you have a toolchain for the android just export it's bin/ directory #+BEGIN_SRC shell-script export PLATFORM_PREFIX=/opt/toolchains/android-ndk/ export NDK_PATH=/opt/android-ndk/ export NDK_PLATFORM=android-4 mkdir ${PLATFORM_PREFIX} ${NDK_PATH}/build/tools/make-standalone-toolchain.sh \ --platform=${NDK_PLATFORM} \ --install-dir=${PLATFORM_PREFIX} \ --arch=arm export PATH=${PLATFORM_PREFIX}/bin:${PATH} #+END_SRC 3. Build and install the target library #+BEGIN_SRC shell-script ./configure --host=arm-linux-androideabi \ --prefix=`pwd`/ecl-android \ --with-cross-config=`pwd`src/util/android.cross_config \ --disable-soname make -j9 make install #+END_SRC 4. Library and assets in the ecl-android directory are ready to run on the Android system. ecl-16.1.2/LGPL000066400000000000000000000612611266352375300130470ustar00rootroot00000000000000 GNU LIBRARY GENERAL PUBLIC LICENSE Version 2, June 1991 Copyright (C) 1991 Free Software Foundation, Inc. 675 Mass Ave, Cambridge, MA 02139, USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. [This is the first released version of the library GPL. It is numbered 2 because it goes with version 2 of the ordinary GPL.] Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public Licenses are intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This license, the Library General Public License, applies to some specially designated Free Software Foundation software, and to any other libraries whose authors decide to use it. You can use it for your libraries, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things. To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the library, or if you modify it. For example, if you distribute copies of the library, whether gratis or for a fee, you must give the recipients all the rights that we gave you. You must make sure that they, too, receive or can get the source code. If you link a program with the library, you must provide complete object files to the recipients so that they can relink them with the library, after making changes to the library and recompiling it. And you must show them these terms so they know their rights. Our method of protecting your rights has two steps: (1) copyright the library, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the library. Also, for each distributor's protection, we want to make certain that everyone understands that there is no warranty for this free library. If the library is modified by someone else and passed on, we want its recipients to know that what they have is not the original version, so that any problems introduced by others will not reflect on the original authors' reputations. Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that companies distributing free software will individually obtain patent licenses, thus in effect transforming the program into proprietary software. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all. Most GNU software, including some libraries, is covered by the ordinary GNU General Public License, which was designed for utility programs. This license, the GNU Library General Public License, applies to certain designated libraries. This license is quite different from the ordinary one; be sure to read it in full, and don't assume that anything in it is the same as in the ordinary license. The reason we have a separate public license for some libraries is that they blur the distinction we usually make between modifying or adding to a program and simply using it. Linking a program with a library, without changing the library, is in some sense simply using the library, and is analogous to running a utility program or application program. However, in a textual and legal sense, the linked executable is a combined work, a derivative of the original library, and the ordinary General Public License treats it as such. Because of this blurred distinction, using the ordinary General Public License for libraries did not effectively promote software sharing, because most developers did not use the libraries. We concluded that weaker conditions might promote sharing better. However, unrestricted linking of non-free programs would deprive the users of those programs of all benefit from the free status of the libraries themselves. This Library General Public License is intended to permit developers of non-free programs to use free libraries, while preserving your freedom as a user of such programs to change the free libraries that are incorporated in them. (We have not seen how to achieve this as regards changes in header files, but we have achieved it as regards changes in the actual functions of the Library.) The hope is that this will lead to faster development of free libraries. The precise terms and conditions for copying, distribution and modification follow. Pay close attention to the difference between a "work based on the library" and a "work that uses the library". The former contains code derived from the library, while the latter only works together with the library. Note that it is possible for a library to be covered by the ordinary General Public License rather than by this special one. GNU LIBRARY GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License Agreement applies to any software library which contains a notice placed by the copyright holder or other authorized party saying it may be distributed under the terms of this Library General Public License (also called "this License"). Each licensee is addressed as "you". A "library" means a collection of software functions and/or data prepared so as to be conveniently linked with application programs (which use some of those functions and data) to form executables. The "Library", below, refers to any such software library or work which has been distributed under these terms. A "work based on the Library" means either the Library or any derivative work under copyright law: that is to say, a work containing the Library or a portion of it, either verbatim or with modifications and/or translated straightforwardly into another language. (Hereinafter, translation is included without limitation in the term "modification".) "Source code" for a work means the preferred form of the work for making modifications to it. For a library, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the library. Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running a program using the Library is not restricted, and output from such a program is covered only if its contents constitute a work based on the Library (independent of the use of the Library in a tool for writing it). Whether that is true depends on what the Library does and what the program that uses the Library does. 1. You may copy and distribute verbatim copies of the Library's complete source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and distribute a copy of this License along with the Library. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Library or any portion of it, thus forming a work based on the Library, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) The modified work must itself be a software library. b) You must cause the files modified to carry prominent notices stating that you changed the files and the date of any change. c) You must cause the whole of the work to be licensed at no charge to all third parties under the terms of this License. d) If a facility in the modified Library refers to a function or a table of data to be supplied by an application program that uses the facility, other than as an argument passed when the facility is invoked, then you must make a good faith effort to ensure that, in the event an application does not supply such function or table, the facility still operates, and performs whatever part of its purpose remains meaningful. (For example, a function in a library to compute square roots has a purpose that is entirely well-defined independent of the application. Therefore, Subsection 2d requires that any application-supplied function or table used by this function must be optional: if the application does not supply it, the square root function must still compute square roots.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Library, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Library, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Library. In addition, mere aggregation of another work not based on the Library with the Library (or with a work based on the Library) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may opt to apply the terms of the ordinary GNU General Public License instead of this License to a given copy of the Library. To do this, you must alter all the notices that refer to this License, so that they refer to the ordinary GNU General Public License, version 2, instead of to this License. (If a newer version than version 2 of the ordinary GNU General Public License has appeared, then you can specify that version instead if you wish.) Do not make any other change in these notices. Once this change is made in a given copy, it is irreversible for that copy, so the ordinary GNU General Public License applies to all subsequent copies and derivative works made from that copy. This option is useful when you wish to copy part of the code of the Library into a program that is not a library. 4. You may copy and distribute the Library (or a portion or derivative of it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange. If distribution of object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place satisfies the requirement to distribute the source code, even though third parties are not compelled to copy the source along with the object code. 5. A program that contains no derivative of any portion of the Library, but is designed to work with the Library by being compiled or linked with it, is called a "work that uses the Library". Such a work, in isolation, is not a derivative work of the Library, and therefore falls outside the scope of this License. However, linking a "work that uses the Library" with the Library creates an executable that is a derivative of the Library (because it contains portions of the Library), rather than a "work that uses the library". The executable is therefore covered by this License. Section 6 states terms for distribution of such executables. When a "work that uses the Library" uses material from a header file that is part of the Library, the object code for the work may be a derivative work of the Library even though the source code is not. Whether this is true is especially significant if the work can be linked without the Library, or if the work is itself a library. The threshold for this to be true is not precisely defined by law. If such an object file uses only numerical parameters, data structure layouts and accessors, and small macros and small inline functions (ten lines or less in length), then the use of the object file is unrestricted, regardless of whether it is legally a derivative work. (Executables containing this object code plus portions of the Library will still fall under Section 6.) Otherwise, if the work is a derivative of the Library, you may distribute the object code for the work under the terms of Section 6. Any executables containing that work also fall under Section 6, whether or not they are linked directly with the Library itself. 6. As an exception to the Sections above, you may also compile or link a "work that uses the Library" with the Library to produce a work containing portions of the Library, and distribute that work under terms of your choice, provided that the terms permit modification of the work for the customer's own use and reverse engineering for debugging such modifications. You must give prominent notice with each copy of the work that the Library is used in it and that the Library and its use are covered by this License. You must supply a copy of this License. If the work during execution displays copyright notices, you must include the copyright notice for the Library among them, as well as a reference directing the user to the copy of this License. Also, you must do one of these things: a) Accompany the work with the complete corresponding machine-readable source code for the Library including whatever changes were used in the work (which must be distributed under Sections 1 and 2 above); and, if the work is an executable linked with the Library, with the complete machine-readable "work that uses the Library", as object code and/or source code, so that the user can modify the Library and then relink to produce a modified executable containing the modified Library. (It is understood that the user who changes the contents of definitions files in the Library will not necessarily be able to recompile the application to use the modified definitions.) b) Accompany the work with a written offer, valid for at least three years, to give the same user the materials specified in Subsection 6a, above, for a charge no more than the cost of performing this distribution. c) If distribution of the work is made by offering access to copy from a designated place, offer equivalent access to copy the above specified materials from the same place. d) Verify that the user has already received a copy of these materials or that you have already sent this user a copy. For an executable, the required form of the "work that uses the Library" must include any data and utility programs needed for reproducing the executable from it. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. It may happen that this requirement contradicts the license restrictions of other proprietary libraries that do not normally accompany the operating system. Such a contradiction means you cannot use both them and the Library together in an executable that you distribute. 7. You may place library facilities that are a work based on the Library side-by-side in a single library together with other library facilities not covered by this License, and distribute such a combined library, provided that the separate distribution of the work based on the Library and of the other library facilities is otherwise permitted, and provided that you do these two things: a) Accompany the combined library with a copy of the same work based on the Library, uncombined with any other library facilities. This must be distributed under the terms of the Sections above. b) Give prominent notice with the combined library of the fact that part of it is a work based on the Library, and explaining where to find the accompanying uncombined form of the same work. 8. You may not copy, modify, sublicense, link with, or distribute the Library except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense, link with, or distribute the Library is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 9. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Library or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Library (or any work based on the Library), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Library or works based on it. 10. Each time you redistribute the Library (or any work based on the Library), the recipient automatically receives a license from the original licensor to copy, distribute, link with or modify the Library subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License. 11. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Library at all. For example, if a patent license would not permit royalty-free redistribution of the Library by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Library. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply, and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 12. If the distribution and/or use of the Library is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Library under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 13. The Free Software Foundation may publish revised and/or new versions of the Library General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Library specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Library does not specify a license version number, you may choose any version ever published by the Free Software Foundation. 14. If you wish to incorporate parts of the Library into other free programs whose distribution conditions are incompatible with these, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS Appendix: How to Apply These Terms to Your New Libraries If you develop a new library, and you want it to be of the greatest possible use to the public, we recommend making it free software that everyone can redistribute and change. You can do so by permitting redistribution under these terms (or, alternatively, under the terms of the ordinary General Public License). To apply these terms, attach the following notices to the library. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This library is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public License for more details. You should have received a copy of the GNU Library General Public License along with this library; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. Also add information on how to contact you by electronic and paper mail. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the library, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the library `Frob' (a library for tweaking knobs) written by James Random Hacker. , 1 April 1990 Ty Coon, President of Vice That's all there is to it! ecl-16.1.2/LICENSE000066400000000000000000000032461266352375300133720ustar00rootroot00000000000000---- BEGINNING OF COPYRIGHT FOR THE ECL CORE ENVIRONMENT ------------ Copyright (c) 2015, Daniel KochmaХ„ski Copyright (c) 2000, Juan Jose Garcia Ripoll Copyright (c) 1990, 1991, 1993 Giuseppe Attardi Copyright (c) 1984 Taiichi Yuasa and Masami Hagiya All Rights Reserved ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version; see file 'Copying'. 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 Library General Public License for more details. You should have received a copy of the GNU Library General Public License along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. PLEASE NOTE THAT: This license covers all of the ECL program except for the files src/lsp/loop2.lsp ; Symbolic's LOOP macro src/lsp/pprint.lsp ; CMUCL's pretty printer src/lsp/format.lsp ; CMUCL's format and the directories contrib/ ; User contributed extensions examples/ ; Examples for the ECL usage src/clx/ ; portable CLX library from Telent Look the precise copyright of these extensions in the corresponding files. Examples are licensed under: (SPDX-License-Identifier) BSD-2-Clause Report bugs, comments, suggestions to the ecl mailing list: ecl-devel@common-lisp.net. ---- END OF COPYRIGHT FOR THE ECL CORE ENVIRONMENT ------------------ ecl-16.1.2/Makefile.in000066400000000000000000000132071266352375300144300ustar00rootroot00000000000000# DIST: This is the distribution Makefile for ECL. configure can # DIST: make most of the changes to this file you might want, so try # DIST: that first. # make all to compile and build Emacs. # make install to install it. # make TAGS to update tags tables. # # make clean or make mostlyclean # Delete all files from the current directory that are normally # created by building the program. Don't delete the files that # record the configuration. Also preserve files that could be made # by building, but normally aren't because the distribution comes # with them. # # Delete `.dvi' files here if they are not part of the distribution. # # make distclean # Delete all files from the current directory that are created by # configuring or building the program. If you have unpacked the # source and built the program without creating any other files, # `make distclean' should leave only the files that were in the # distribution. # # make realclean # Delete everything from the current directory that can be # reconstructed with this Makefile. This typically includes # everything deleted by distclean. SHELL = /bin/sh MACHINE = @MACHINE_VERSION@ # ========================= Last release ================================ VERSION=@PACKAGE_VERSION@ WWW=https://common-lisp.net/project/ecl/ ADDRESS=https://gitlab.com/embeddable-common-lisp/ecl # ==================== Things `configure' Might Edit ==================== # Where to find the source code. # This is set by the configure script's `--srcdir' option. srcdir=@srcdir@ prefix=@prefix@ exec_prefix=@exec_prefix@ bindir=@bindir@ infodir=@infodir@ mandir=@mandir@ libdir=@libdir@ # What to release TAR_CONTENTS=Makefile.in README.1st LGPL ANNOUNCEMENT Copyright doc \ configure src/c src/cmp src/clos src/CHANGELOG src/lsp src/doc \ src/h src/gmp src/config* src/install.sh src/Makefile.in \ src/util contrib/ src/clx src/gc src/*.in src/*.m4 src/gabriel \ src/tests/Makefile.in msvc examples # ==================== Utility Programs for the Build ==================== # Allow the user to specify the install program. @SET_MAKE@ INSTALL = @INSTALL@ INSTALL_PROGRAM = @INSTALL_PROGRAM@ INSTALL_DATA = @INSTALL_DATA@ # ============================= Build ============================== all: build/Makefile cd build; $(MAKE) .PHONY: all Makefile: Makefile.in build/config.status (cd build; ./config.status) # ==================== Installation ==================== INSTALL_TARGET = @INSTALL_TARGET@ install: build/Makefile cd build; $(MAKE) $(INSTALL_TARGET) uninstall: cd build; $(MAKE) uninstall # ==================== Cleaning up and miscellanea ==================== # `clean' # Delete all files from the current directory that are normally # created by building the program. Don't delete the files that # record the configuration. Also preserve files that could be made # by building, but normally aren't because the distribution comes # with them. # clean: cd build; $(MAKE) clean # `distclean' # Delete all files from the current directory that are created by # configuring or building the program. If you have unpacked the # source and built the program without creating any other files, # `make distclean' should leave only the files that were in the # distribution. distclean: clean rm -rf build Makefile # `realclean' # Delete everything from the current directory that can be # reconstructed with this Makefile. # One exception, however: `make realclean' should not delete # `configure' even if `configure' can be remade using a rule in the # Makefile. More generally, `make realclean' should not delete # anything that needs to exist in order to run `configure' and then # begin to build the program. realclean: distclean check: cd build && $(MAKE) check recheck: cd build && $(MAKE) recheck # ==================== Various means of distribution ==================== TAR_DIR=ecl-$(VERSION) doc: build/doc/index.html -mkdir doc (cd build/doc; make html); cp build/doc/*.html doc build/doc/index.html: cd build/doc; $(MAKE) source-dist: $(TAR_DIR).tgz rpmdir=$(shell rpm --showrc | grep '^-[0-9]*:.*[^{]_topdir' | sed 's,^.*topdir[ ]*\(.*\)[ ]*,\1,') rpmbuild=$(shell if [ -z `which rpmbuild` ]; then echo "rpm"; else echo "rpmbuild"; fi) $(TAR_DIR).tgz: git archive --format=tar.gz --prefix=$(TAR_DIR)/ HEAD > $@ binary-dist: all su -c "rm -rf tmp" mkdir tmp for i in tmp$(bindir) tmp$(infodir) tmp$(mandir) tmp$(libdir); do \ (echo $$i; IFS="/"; \for k in $$i; do echo $$k; (test -d $$k || mkdir $$k); chmod 755 $$k; cd $$k; done); \ done prefix=`pwd`/tmp; cd build; $(MAKE) install prefix=$(prefix) su -c "chown -R root.root tmp && cd tmp; tar czf ../ecl-$(VERSION)-$(MACHINE).tgz * && cd .. && rm -rf tmp" # This creates a ZIP file with a flattened directory structure windows-dist: all cd build; rm -rf $(TAR_DIR); mkdir $(TAR_DIR); \ $(MAKE) flatinstall prefix=`pwd`/$(TAR_DIR); \ zip -r $(TAR_DIR).zip $(TAR_DIR) windows-nsi: all cd build; rm -rf $(TAR_DIR); mkdir $(TAR_DIR); \ $(MAKE) flatinstall prefix=`pwd`/$(TAR_DIR) `pwd`/src/util/ecl_nsi.sh `pwd`/src/util/ecl.nsi build/$(TAR_DIR) makensis.exe build/$(TAR_DIR)/ecl.nsi mv build/$(TAR_DIR)/Setup.exe ecl-$(VERSION).exe upload-frs: ecldir=`echo $(VERSION) | sed -e 's,\([0-9]*\.[0-9]*\)\.[0-9]*,\1,'` && \ destdir=jjgarcia,ecls@frs.sourceforge.net:/home/frs/project/e/ec/ecls/ecls/ && \ test -d frs || mkdir frs && \ test -d frs/$$ecldir || mkdir frs/$$ecldir && \ cp $(TAR_DIR).tgz src/CHANGELOG frs/$$ecldir && \ cd frs && scp -rC $$ecldir $$destdir rm -rf frs ecl-16.1.2/README.md000066400000000000000000000015051266352375300136400ustar00rootroot00000000000000ECL stands for Embeddable Common-Lisp. The ECL project aims to produce an implementation of the Common-Lisp language which complies to the ANSI X3J13 definition of the language. The term embeddable refers to the fact that ECL includes a Lisp to C compiler, which produces libraries (static or dynamic) that can be called from C programs. Furthermore, ECL can produce standalone executables from Lisp code and can itself be linked to your programs as a shared library. It also features an interpreter for situations when a C compiler isn't available. ECL supports the operating systems Linux, FreeBSD, NetBSD, DragonFly BSD, OpenBSD, Solaris (at least v. 9), Microsoft Windows (MSVC, MinGW and Cygwin) and OSX, running on top of the Intel, Sparc, Alpha, ARM and PowerPC processors. Porting to other architectures should be rather easy.ecl-16.1.2/configure000077500000000000000000000020141266352375300142640ustar00rootroot00000000000000#!/bin/sh # # This is just a driver for configure, the real configure is in src. # This script identifies the machine, and creates a directory for # the installation, where it runs ${srcdir}/configure. set -e #if uname -a | grep -i 'mingw32' > /dev/null; then # srcdir=`pwd -W`/src; #else # srcdir=`pwd`/src #fi srcdir=`pwd`/src [ "x$buildir" = "x" ] && buildir=build export buildir if [ ! -d ${buildir} ] ; then echo Creating directory "\`${buildir}'" mkdir ${buildir} fi echo Switching to directory "\`${buildir}'" to continue configuration. # # There are two ways to configure ECL. If we use our own version of GMP, # we let it configure itself and later on retrieve the appropiate flags # if ( echo $* | grep guess-host-cflags ); then echo **** echo **** The flag --enable-guest-host-cflags has been removed. Instead try echo **** $* --enable-slow-conf echo **** exit 1 fi cd ${buildir} ${srcdir}/configure --srcdir=${srcdir} "$@" echo Configuration complete. To build ECL, issue 'make' in this directory. ecl-16.1.2/contrib/000077500000000000000000000000001266352375300140205ustar00rootroot00000000000000ecl-16.1.2/contrib/asdf/000077500000000000000000000000001266352375300147355ustar00rootroot00000000000000ecl-16.1.2/contrib/asdf/README.ECL000066400000000000000000000001771266352375300162240ustar00rootroot00000000000000The copies of asdf.lisp and README in this directory are complete and unchanged from the canonical common-lisp.net repository. ecl-16.1.2/contrib/asdf/README.md000066400000000000000000000144101266352375300162140ustar00rootroot00000000000000ASDF: Another System Definition Facility ======================================== What is ASDF? ------------- ASDF is the de facto standard build facility for Common Lisp. Your Lisp implementation probably contains a copy of ASDF, which you can load using `(require "asdf")`. If you come from the C/C++ world, the function ASDF covers a bit of what each of make, autoconf, dlopen and libc do for C programs: it orchestrates the compilation and dependency management, handles some of the portability issues, dynamically finds and loads code, and offers some portable system access. Except everything is different in Common Lisp, and ultimately much simpler, though it requires acquiring some basic concepts. Importantly, ASDF builds all software in the current Lisp image. To use ASDF, read our manual: http://common-lisp.net/project/asdf/asdf.html The first few sections, Loading ASDF, Configuring ASDF and Using ASDF, will get you started as a simple user. If you want to define your own systems, further read the section Defining systems with defsystem. The manual is also in the doc/ subdirectory, and can be prepared with: make doc ASDF 3 now includes an extensive runtime support library: UIOP, the Utilities for Implementation- and OS- Portability. Its documentation unhappily lies mainly in the source code and docstrings. See [`uiop/README.md`](uiop/README.md) for an introduction. More information and additional links can be found on ASDF's home page at: http://common-lisp.net/project/asdf/ Quick Start ----------- Just use `(require "asdf")` to load your implementation-provided ASDF. If it is recent enough (3.0 or later, check its `(asdf:asdf-version)`), then it will automatically upgrade to the ASDF provided as source code, assuming the source code in under a path registered by the source-registry. Building and testing it ----------------------- First, make sure ASDF is checked out under a path registered by the source-registry, if that isn't the case yet (see the manual). One place would be: ~/.local/share/common-lisp/source/asdf/ or, assuming your implementation provides ASDF 3.1 or later: ~/common-lisp/asdf/ If you cloned our git repository, bootstrap a copy of build/asdf.lisp with: make Before you may run tests, you need a few CL libraries. The simplest way to get them is as follows, but read below: make ext The above make target uses `git submodule update --init` to download all these libraries using git. If you don't otherwise maintain your own set of carefully controlled CL libraries, that's what you want to use. However, if you do maintain your own set of carefully controlled CL libraries then you will want to use whichever tools you use (e.g. quicklisp, clbuild, or your own scripts around git) to download these libraries: alexandria, closer-mop, cl-ppcre, fare-mop, fare-quasiquote, fare-utils, inferior-shell, lisp-invocation, named-readtables, optima. If you are a CL developer, you may already have them, or may want to use your own tools to download a version of them you control. If you use Quicklisp, you may let Quicklisp download those you don't have. In these cases, you do NOT want to use However, if you want to let ASDF download known-working versions of its dependencies, you can do it with: make ext To run all the tests on your favorite Lisp implementation $L, choose your most elaborate installed system $S, and try: make t u l=$L s=$S Debugging tip ------------- To load ASDF in such a way that M-. will work, install the source code, and run: (asdf:load-system :uiop) ;; loading uiop is simple (map () 'load ;; loading asdf/defsystem is tricky (mapcar 'asdf:component-pathname (asdf::required-components :asdf/defsystem :keep-component 'asdf:cl-source-file))) What has changed? ----------------- You can consult the `debian/changelog` for an overview of the significant changes in each release, and the `git log` for a detailed description of each commit. How do I navigate this source directory? ---------------------------------------- * `asdf.asd` * The system definition for building ASDF with ASDF. * `*.lisp` * The source code files for asdf/defsystem. See asdf.asd for the order in which they are loaded. * `uiop/` * Utilities of Implementation- and OS- Portability, the portability layer of ASDF. It has its own `README`, and functions all have docstrings. * `Makefile` * a minimal Makefile for bootstrapping purposes. Most of the logic is in the asdf-tools system * `tools/` * Some scripts to help ASDF users * `load-asdf.lisp` -- a build script to load, configure and use ASDF * `install-asdf.lisp` -- replace and update an implementation's ASDF * `cl-source-registry-cache.lisp` -- update a cache for the source-registry * `build.xcvb` * The system definition for building ASDF with XCVB. It hasn't been tested or maintained for years and has bitrotten. * `version.lisp-expr` * The current version. Bumped up every time the code changes, using: ./tools/asdf-builder bump * `doc/` * documentation for ASDF, including: * `index.html` -- the web page for http://common-lisp.net/project/asdf/ * `asdf.texinfo` -- our manual * `Makefile` -- how to build the manual * `cclan.png` `lisp-logo120x80.png` `style.css` `favicon.ico` -- auxiliaries of `index.html` * `test/` * regression test scripts (and ancillary files) for developers to check that they don't unintentionally break any of the functionality of ASDF. Far from covering all of ASDF. * `contrib/` * a few contributed files that show case how to use ASDF. * `debian/` files for packaging on debian, ubuntu, etc. * `build/` * where the Makefile and asdf-tools store their output files, including * `asdf.lisp` -- the current one-file deliverable of ASDF * `asdf-XXX.lisp` -- for upgrade test purposes, old versions * `results/` -- logs of tests that have been run * `fasls/` -- output files while running tests. * `ext/` * external dependencies, that can be populated with `make ext` or equivalently with `git submodule update --init`. * `README` * this file * `TODO` * plenty of ideas for how to further improve ASDF. Last updated Thursday, September 11th, 2014. ecl-16.1.2/contrib/asdf/asdf.lisp000066400000000000000000021370371266352375300165600ustar00rootroot00000000000000;;; -*- mode: Common-Lisp; Base: 10 ; Syntax: ANSI-Common-Lisp ; buffer-read-only: t; -*- ;;; This is ASDF 3.1.5.4: Another System Definition Facility. ;;; ;;; Feedback, bug reports, and patches are all welcome: ;;; please mail to . ;;; Note first that the canonical source for ASDF is presently ;;; . ;;; ;;; If you obtained this copy from anywhere else, and you experience ;;; trouble using it, or find bugs, you may want to check at the ;;; location above for a more recent version (and for documentation ;;; and test files, if your copy came without them) before reporting ;;; bugs. There are usually two "supported" revisions - the git master ;;; branch is the latest development version, whereas the git release ;;; branch may be slightly older but is considered `stable' ;;; -- LICENSE START ;;; (This is the MIT / X Consortium license as taken from ;;; http://www.opensource.org/licenses/mit-license.html on or about ;;; Monday; July 13, 2009) ;;; ;;; Copyright (c) 2001-2015 Daniel Barlow and contributors ;;; ;;; Permission is hereby granted, free of charge, to any person obtaining ;;; a copy of this software and associated documentation files (the ;;; "Software"), to deal in the Software without restriction, including ;;; without limitation the rights to use, copy, modify, merge, publish, ;;; distribute, sublicense, and/or sell copies of the Software, and to ;;; permit persons to whom the Software is furnished to do so, subject to ;;; the following conditions: ;;; ;;; The above copyright notice and this permission notice shall be ;;; included in all copies or substantial portions of the Software. ;;; ;;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, ;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ;;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND ;;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE ;;; LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION ;;; OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION ;;; WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ;;; ;;; -- LICENSE END ;;; The problem with writing a defsystem replacement is bootstrapping: ;;; we can't use defsystem to compile it. Hence, all in one file. #+xcvb (module ()) (in-package :cl-user) #+cmu (eval-when (:load-toplevel :compile-toplevel :execute) (setf ext:*gc-verbose* nil)) ;;; pre 1.3.0 ABCL versions do not support the bundle-op on Mac OS X #+abcl (eval-when (:load-toplevel :compile-toplevel :execute) (unless (and (member :darwin *features*) (second (third (sys::arglist 'directory)))) (push :abcl-bundle-op-supported *features*))) ;; Punt on hard package upgrade: from ASDF1 always, and even from ASDF2 on most implementations. (eval-when (:load-toplevel :compile-toplevel :execute) (unless (member :asdf3 *features*) (let* ((existing-version (when (find-package :asdf) (or (symbol-value (find-symbol (string :*asdf-version*) :asdf)) (let ((ver (symbol-value (find-symbol (string :*asdf-revision*) :asdf)))) (etypecase ver (string ver) (cons (format nil "~{~D~^.~}" ver)) (null "1.0")))))) (first-dot (when existing-version (position #\. existing-version))) (second-dot (when first-dot (position #\. existing-version :start (1+ first-dot)))) (existing-major-minor (subseq existing-version 0 second-dot)) (existing-version-number (and existing-version (read-from-string existing-major-minor))) (away (format nil "~A-~A" :asdf existing-version))) (when (and existing-version (< existing-version-number #+(or allegro clisp lispworks sbcl) 2.0 #-(or allegro clisp lispworks sbcl) 2.27)) (rename-package :asdf away) (when *load-verbose* (format t "~&; Renamed old ~A package away to ~A~%" :asdf away)))))) ;;;; --------------------------------------------------------------------------- ;;;; Handle ASDF package upgrade, including implementation-dependent magic. ;; ;; See https://bugs.launchpad.net/asdf/+bug/485687 ;; (defpackage :uiop/package ;; CAUTION: we must handle the first few packages specially for hot-upgrade. ;; This package definition MUST NOT change unless its name too changes; ;; if/when it changes, don't forget to add new functions missing from below. ;; Until then, uiop/package is frozen to forever ;; import and export the same exact symbols as for ASDF 2.27. ;; Any other symbol must be import-from'ed and re-export'ed in a different package. (:use :common-lisp) (:export #:find-package* #:find-symbol* #:symbol-call #:intern* #:export* #:import* #:shadowing-import* #:shadow* #:make-symbol* #:unintern* #:symbol-shadowing-p #:home-package-p #:symbol-package-name #:standard-common-lisp-symbol-p #:reify-package #:unreify-package #:reify-symbol #:unreify-symbol #:nuke-symbol-in-package #:nuke-symbol #:rehome-symbol #:ensure-package-unused #:delete-package* #:package-names #:packages-from-names #:fresh-package-name #:rename-package-away #:package-definition-form #:parse-define-package-form #:ensure-package #:define-package)) (in-package :uiop/package) ;;;; General purpose package utilities (eval-when (:load-toplevel :compile-toplevel :execute) (defun find-package* (package-designator &optional (error t)) (let ((package (find-package package-designator))) (cond (package package) (error (error "No package named ~S" (string package-designator))) (t nil)))) (defun find-symbol* (name package-designator &optional (error t)) "Find a symbol in a package of given string'ified NAME; unlike CL:FIND-SYMBOL, work well with 'modern' case sensitive syntax by letting you supply a symbol or keyword for the name; also works well when the package is not present. If optional ERROR argument is NIL, return NIL instead of an error when the symbol is not found." (block nil (let ((package (find-package* package-designator error))) (when package ;; package error handled by find-package* already (multiple-value-bind (symbol status) (find-symbol (string name) package) (cond (status (return (values symbol status))) (error (error "There is no symbol ~S in package ~S" name (package-name package)))))) (values nil nil)))) (defun symbol-call (package name &rest args) "Call a function associated with symbol of given name in given package, with given ARGS. Useful when the call is read before the package is loaded, or when loading the package is optional." (apply (find-symbol* name package) args)) (defun intern* (name package-designator &optional (error t)) (intern (string name) (find-package* package-designator error))) (defun export* (name package-designator) (let* ((package (find-package* package-designator)) (symbol (intern* name package))) (export (or symbol (list symbol)) package))) (defun import* (symbol package-designator) (import (or symbol (list symbol)) (find-package* package-designator))) (defun shadowing-import* (symbol package-designator) (shadowing-import (or symbol (list symbol)) (find-package* package-designator))) (defun shadow* (name package-designator) (shadow (list (string name)) (find-package* package-designator))) (defun make-symbol* (name) (etypecase name (string (make-symbol name)) (symbol (copy-symbol name)))) (defun unintern* (name package-designator &optional (error t)) (block nil (let ((package (find-package* package-designator error))) (when package (multiple-value-bind (symbol status) (find-symbol* name package error) (cond (status (unintern symbol package) (return (values symbol status))) (error (error "symbol ~A not present in package ~A" (string symbol) (package-name package)))))) (values nil nil)))) (defun symbol-shadowing-p (symbol package) (and (member symbol (package-shadowing-symbols package)) t)) (defun home-package-p (symbol package) (and package (let ((sp (symbol-package symbol))) (and sp (let ((pp (find-package* package))) (and pp (eq sp pp)))))))) (eval-when (:load-toplevel :compile-toplevel :execute) (defun symbol-package-name (symbol) (let ((package (symbol-package symbol))) (and package (package-name package)))) (defun standard-common-lisp-symbol-p (symbol) (multiple-value-bind (sym status) (find-symbol* symbol :common-lisp nil) (and (eq sym symbol) (eq status :external)))) (defun reify-package (package &optional package-context) (if (eq package package-context) t (etypecase package (null nil) ((eql (find-package :cl)) :cl) (package (package-name package))))) (defun unreify-package (package &optional package-context) (etypecase package (null nil) ((eql t) package-context) ((or symbol string) (find-package package)))) (defun reify-symbol (symbol &optional package-context) (etypecase symbol ((or keyword (satisfies standard-common-lisp-symbol-p)) symbol) (symbol (vector (symbol-name symbol) (reify-package (symbol-package symbol) package-context))))) (defun unreify-symbol (symbol &optional package-context) (etypecase symbol (symbol symbol) ((simple-vector 2) (let* ((symbol-name (svref symbol 0)) (package-foo (svref symbol 1)) (package (unreify-package package-foo package-context))) (if package (intern* symbol-name package) (make-symbol* symbol-name))))))) (eval-when (:load-toplevel :compile-toplevel :execute) (defvar *all-package-happiness* '()) (defvar *all-package-fishiness* (list t)) (defun record-fishy (info) ;;(format t "~&FISHY: ~S~%" info) (push info *all-package-fishiness*)) (defmacro when-package-fishiness (&body body) `(when *all-package-fishiness* ,@body)) (defmacro note-package-fishiness (&rest info) `(when-package-fishiness (record-fishy (list ,@info))))) (eval-when (:load-toplevel :compile-toplevel :execute) #+(or clisp clozure) (defun get-setf-function-symbol (symbol) #+clisp (let ((sym (get symbol 'system::setf-function))) (if sym (values sym :setf-function) (let ((sym (get symbol 'system::setf-expander))) (if sym (values sym :setf-expander) (values nil nil))))) #+clozure (gethash symbol ccl::%setf-function-names%)) #+(or clisp clozure) (defun set-setf-function-symbol (new-setf-symbol symbol &optional kind) #+clisp (assert (member kind '(:setf-function :setf-expander))) #+clozure (assert (eq kind t)) #+clisp (cond ((null new-setf-symbol) (remprop symbol 'system::setf-function) (remprop symbol 'system::setf-expander)) ((eq kind :setf-function) (setf (get symbol 'system::setf-function) new-setf-symbol)) ((eq kind :setf-expander) (setf (get symbol 'system::setf-expander) new-setf-symbol)) (t (error "invalid kind of setf-function ~S for ~S to be set to ~S" kind symbol new-setf-symbol))) #+clozure (progn (gethash symbol ccl::%setf-function-names%) new-setf-symbol (gethash new-setf-symbol ccl::%setf-function-name-inverses%) symbol)) #+(or clisp clozure) (defun create-setf-function-symbol (symbol) #+clisp (system::setf-symbol symbol) #+clozure (ccl::construct-setf-function-name symbol)) (defun set-dummy-symbol (symbol reason other-symbol) (setf (get symbol 'dummy-symbol) (cons reason other-symbol))) (defun make-dummy-symbol (symbol) (let ((dummy (copy-symbol symbol))) (set-dummy-symbol dummy 'replacing symbol) (set-dummy-symbol symbol 'replaced-by dummy) dummy)) (defun dummy-symbol (symbol) (get symbol 'dummy-symbol)) (defun get-dummy-symbol (symbol) (let ((existing (dummy-symbol symbol))) (if existing (values (cdr existing) (car existing)) (make-dummy-symbol symbol)))) (defun nuke-symbol-in-package (symbol package-designator) (let ((package (find-package* package-designator)) (name (symbol-name symbol))) (multiple-value-bind (sym stat) (find-symbol name package) (when (and (member stat '(:internal :external)) (eq symbol sym)) (if (symbol-shadowing-p symbol package) (shadowing-import* (get-dummy-symbol symbol) package) (unintern* symbol package)))))) (defun nuke-symbol (symbol &optional (packages (list-all-packages))) #+(or clisp clozure) (multiple-value-bind (setf-symbol kind) (get-setf-function-symbol symbol) (when kind (nuke-symbol setf-symbol))) (loop :for p :in packages :do (nuke-symbol-in-package symbol p))) (defun rehome-symbol (symbol package-designator) "Changes the home package of a symbol, also leaving it present in its old home if any" (let* ((name (symbol-name symbol)) (package (find-package* package-designator)) (old-package (symbol-package symbol)) (old-status (and old-package (nth-value 1 (find-symbol name old-package)))) (shadowing (and old-package (symbol-shadowing-p symbol old-package) (make-symbol name)))) (multiple-value-bind (overwritten-symbol overwritten-symbol-status) (find-symbol name package) (unless (eq package old-package) (let ((overwritten-symbol-shadowing-p (and overwritten-symbol-status (symbol-shadowing-p overwritten-symbol package)))) (note-package-fishiness :rehome-symbol name (when old-package (package-name old-package)) old-status (and shadowing t) (package-name package) overwritten-symbol-status overwritten-symbol-shadowing-p) (when old-package (if shadowing (shadowing-import* shadowing old-package)) (unintern* symbol old-package)) (cond (overwritten-symbol-shadowing-p (shadowing-import* symbol package)) (t (when overwritten-symbol-status (unintern* overwritten-symbol package)) (import* symbol package))) (if shadowing (shadowing-import* symbol old-package) (import* symbol old-package)) #+(or clisp clozure) (multiple-value-bind (setf-symbol kind) (get-setf-function-symbol symbol) (when kind (let* ((setf-function (fdefinition setf-symbol)) (new-setf-symbol (create-setf-function-symbol symbol))) (note-package-fishiness :setf-function name (package-name package) (symbol-name setf-symbol) (symbol-package-name setf-symbol) (symbol-name new-setf-symbol) (symbol-package-name new-setf-symbol)) (when (symbol-package setf-symbol) (unintern* setf-symbol (symbol-package setf-symbol))) (setf (fdefinition new-setf-symbol) setf-function) (set-setf-function-symbol new-setf-symbol symbol kind)))) #+(or clisp clozure) (multiple-value-bind (overwritten-setf foundp) (get-setf-function-symbol overwritten-symbol) (when foundp (unintern overwritten-setf))) (when (eq old-status :external) (export* symbol old-package)) (when (eq overwritten-symbol-status :external) (export* symbol package)))) (values overwritten-symbol overwritten-symbol-status)))) (defun ensure-package-unused (package) (loop :for p :in (package-used-by-list package) :do (unuse-package package p))) (defun delete-package* (package &key nuke) (let ((p (find-package package))) (when p (when nuke (do-symbols (s p) (when (home-package-p s p) (nuke-symbol s)))) (ensure-package-unused p) (delete-package package)))) (defun package-names (package) (cons (package-name package) (package-nicknames package))) (defun packages-from-names (names) (remove-duplicates (remove nil (mapcar #'find-package names)) :from-end t)) (defun fresh-package-name (&key (prefix :%TO-BE-DELETED) separator (index (random most-positive-fixnum))) (loop :for i :from index :for n = (format nil "~A~@[~A~D~]" prefix (and (plusp i) (or separator "")) i) :thereis (and (not (find-package n)) n))) (defun rename-package-away (p &rest keys &key prefix &allow-other-keys) (let ((new-name (apply 'fresh-package-name :prefix (or prefix (format nil "__~A__" (package-name p))) keys))) (record-fishy (list :rename-away (package-names p) new-name)) (rename-package p new-name)))) ;;; Communicable representation of symbol and package information (eval-when (:load-toplevel :compile-toplevel :execute) (defun package-definition-form (package-designator &key (nicknamesp t) (usep t) (shadowp t) (shadowing-import-p t) (exportp t) (importp t) internp (error t)) (let* ((package (or (find-package* package-designator error) (return-from package-definition-form nil))) (name (package-name package)) (nicknames (package-nicknames package)) (use (mapcar #'package-name (package-use-list package))) (shadow ()) (shadowing-import (make-hash-table :test 'equal)) (import (make-hash-table :test 'equal)) (export ()) (intern ())) (when package (loop :for sym :being :the :symbols :in package :for status = (nth-value 1 (find-symbol* sym package)) :do (ecase status ((nil :inherited)) ((:internal :external) (let* ((name (symbol-name sym)) (external (eq status :external)) (home (symbol-package sym)) (home-name (package-name home)) (imported (not (eq home package))) (shadowing (symbol-shadowing-p sym package))) (cond ((and shadowing imported) (push name (gethash home-name shadowing-import))) (shadowing (push name shadow)) (imported (push name (gethash home-name import)))) (cond (external (push name export)) (imported) (t (push name intern))))))) (labels ((sort-names (names) (sort (copy-list names) #'string<)) (table-keys (table) (loop :for k :being :the :hash-keys :of table :collect k)) (when-relevant (key value) (when value (list (cons key value)))) (import-options (key table) (loop :for i :in (sort-names (table-keys table)) :collect `(,key ,i ,@(sort-names (gethash i table)))))) `(defpackage ,name ,@(when-relevant :nicknames (and nicknamesp (sort-names nicknames))) (:use ,@(and usep (sort-names use))) ,@(when-relevant :shadow (and shadowp (sort-names shadow))) ,@(import-options :shadowing-import-from (and shadowing-import-p shadowing-import)) ,@(import-options :import-from (and importp import)) ,@(when-relevant :export (and exportp (sort-names export))) ,@(when-relevant :intern (and internp (sort-names intern))))))))) ;;; ensure-package, define-package (eval-when (:load-toplevel :compile-toplevel :execute) (defun ensure-shadowing-import (name to-package from-package shadowed imported) (check-type name string) (check-type to-package package) (check-type from-package package) (check-type shadowed hash-table) (check-type imported hash-table) (let ((import-me (find-symbol* name from-package))) (multiple-value-bind (existing status) (find-symbol name to-package) (cond ((gethash name shadowed) (unless (eq import-me existing) (error "Conflicting shadowings for ~A" name))) (t (setf (gethash name shadowed) t) (setf (gethash name imported) t) (unless (or (null status) (and (member status '(:internal :external)) (eq existing import-me) (symbol-shadowing-p existing to-package))) (note-package-fishiness :shadowing-import name (package-name from-package) (or (home-package-p import-me from-package) (symbol-package-name import-me)) (package-name to-package) status (and status (or (home-package-p existing to-package) (symbol-package-name existing))))) (shadowing-import* import-me to-package)))))) (defun ensure-imported (import-me into-package &optional from-package) (check-type import-me symbol) (check-type into-package package) (check-type from-package (or null package)) (let ((name (symbol-name import-me))) (multiple-value-bind (existing status) (find-symbol name into-package) (cond ((not status) (import* import-me into-package)) ((eq import-me existing)) (t (let ((shadowing-p (symbol-shadowing-p existing into-package))) (note-package-fishiness :ensure-imported name (and from-package (package-name from-package)) (or (home-package-p import-me from-package) (symbol-package-name import-me)) (package-name into-package) status (and status (or (home-package-p existing into-package) (symbol-package-name existing))) shadowing-p) (cond ((or shadowing-p (eq status :inherited)) (shadowing-import* import-me into-package)) (t (unintern* existing into-package) (import* import-me into-package)))))))) (values)) (defun ensure-import (name to-package from-package shadowed imported) (check-type name string) (check-type to-package package) (check-type from-package package) (check-type shadowed hash-table) (check-type imported hash-table) (multiple-value-bind (import-me import-status) (find-symbol name from-package) (when (null import-status) (note-package-fishiness :import-uninterned name (package-name from-package) (package-name to-package)) (setf import-me (intern* name from-package))) (multiple-value-bind (existing status) (find-symbol name to-package) (cond ((and imported (gethash name imported)) (unless (and status (eq import-me existing)) (error "Can't import ~S from both ~S and ~S" name (package-name (symbol-package existing)) (package-name from-package)))) ((gethash name shadowed) (error "Can't both shadow ~S and import it from ~S" name (package-name from-package))) (t (setf (gethash name imported) t)))) (ensure-imported import-me to-package from-package))) (defun ensure-inherited (name symbol to-package from-package mixp shadowed imported inherited) (check-type name string) (check-type symbol symbol) (check-type to-package package) (check-type from-package package) (check-type mixp (member nil t)) ; no cl:boolean on Genera (check-type shadowed hash-table) (check-type imported hash-table) (check-type inherited hash-table) (multiple-value-bind (existing status) (find-symbol name to-package) (let* ((sp (symbol-package symbol)) (in (gethash name inherited)) (xp (and status (symbol-package existing)))) (when (null sp) (note-package-fishiness :import-uninterned name (package-name from-package) (package-name to-package) mixp) (import* symbol from-package) (setf sp (package-name from-package))) (cond ((gethash name shadowed)) (in (unless (equal sp (first in)) (if mixp (ensure-shadowing-import name to-package (second in) shadowed imported) (error "Can't inherit ~S from ~S, it is inherited from ~S" name (package-name sp) (package-name (first in)))))) ((gethash name imported) (unless (eq symbol existing) (error "Can't inherit ~S from ~S, it is imported from ~S" name (package-name sp) (package-name xp)))) (t (setf (gethash name inherited) (list sp from-package)) (when (and status (not (eq sp xp))) (let ((shadowing (symbol-shadowing-p existing to-package))) (note-package-fishiness :inherited name (package-name from-package) (or (home-package-p symbol from-package) (symbol-package-name symbol)) (package-name to-package) (or (home-package-p existing to-package) (symbol-package-name existing))) (if shadowing (ensure-shadowing-import name to-package from-package shadowed imported) (unintern* existing to-package))))))))) (defun ensure-mix (name symbol to-package from-package shadowed imported inherited) (check-type name string) (check-type symbol symbol) (check-type to-package package) (check-type from-package package) (check-type shadowed hash-table) (check-type imported hash-table) (check-type inherited hash-table) (unless (gethash name shadowed) (multiple-value-bind (existing status) (find-symbol name to-package) (let* ((sp (symbol-package symbol)) (im (gethash name imported)) (in (gethash name inherited))) (cond ((or (null status) (and status (eq symbol existing)) (and in (eq sp (first in)))) (ensure-inherited name symbol to-package from-package t shadowed imported inherited)) (in (remhash name inherited) (ensure-shadowing-import name to-package (second in) shadowed imported)) (im (error "Symbol ~S import from ~S~:[~; actually ~:[uninterned~;~:*from ~S~]~] conflicts with existing symbol in ~S~:[~; actually ~:[uninterned~;from ~:*~S~]~]" name (package-name from-package) (home-package-p symbol from-package) (symbol-package-name symbol) (package-name to-package) (home-package-p existing to-package) (symbol-package-name existing))) (t (ensure-inherited name symbol to-package from-package t shadowed imported inherited))))))) (defun recycle-symbol (name recycle exported) ;; Takes a symbol NAME (a string), a list of package designators for RECYCLE ;; packages, and a hash-table of names (strings) of symbols scheduled to be ;; EXPORTED from the package being defined. It returns two values, the ;; symbol found (if any, or else NIL), and a boolean flag indicating whether ;; a symbol was found. The caller (DEFINE-PACKAGE) will then do the ;; re-homing of the symbol, etc. (check-type name string) (check-type recycle list) (check-type exported hash-table) (when (gethash name exported) ;; don't bother recycling private symbols (let (recycled foundp) (dolist (r recycle (values recycled foundp)) (multiple-value-bind (symbol status) (find-symbol name r) (when (and status (home-package-p symbol r)) (cond (foundp ;; (nuke-symbol symbol)) -- even simple variable names like O or C will do that. (note-package-fishiness :recycled-duplicate name (package-name foundp) (package-name r))) (t (setf recycled symbol foundp r))))))))) (defun symbol-recycled-p (sym recycle) (check-type sym symbol) (check-type recycle list) (and (member (symbol-package sym) recycle) t)) (defun ensure-symbol (name package intern recycle shadowed imported inherited exported) (check-type name string) (check-type package package) (check-type intern (member nil t)) ; no cl:boolean on Genera (check-type shadowed hash-table) (check-type imported hash-table) (check-type inherited hash-table) (unless (or (gethash name shadowed) (gethash name imported) (gethash name inherited)) (multiple-value-bind (existing status) (find-symbol name package) (multiple-value-bind (recycled previous) (recycle-symbol name recycle exported) (cond ((and status (eq existing recycled) (eq previous package))) (previous (rehome-symbol recycled package)) ((and status (eq package (symbol-package existing)))) (t (when status (note-package-fishiness :ensure-symbol name (reify-package (symbol-package existing) package) status intern) (unintern existing)) (when intern (intern* name package)))))))) (declaim (ftype (function (t t t &optional t) t) ensure-exported)) (defun ensure-exported-to-user (name symbol to-package &optional recycle) (check-type name string) (check-type symbol symbol) (check-type to-package package) (check-type recycle list) (assert (equal name (symbol-name symbol))) (multiple-value-bind (existing status) (find-symbol name to-package) (unless (and status (eq symbol existing)) (let ((accessible (or (null status) (let ((shadowing (symbol-shadowing-p existing to-package)) (recycled (symbol-recycled-p existing recycle))) (unless (and shadowing (not recycled)) (note-package-fishiness :ensure-export name (symbol-package-name symbol) (package-name to-package) (or (home-package-p existing to-package) (symbol-package-name existing)) status shadowing) (if (or (eq status :inherited) shadowing) (shadowing-import* symbol to-package) (unintern existing to-package)) t))))) (when (and accessible (eq status :external)) (ensure-exported name symbol to-package recycle)))))) (defun ensure-exported (name symbol from-package &optional recycle) (dolist (to-package (package-used-by-list from-package)) (ensure-exported-to-user name symbol to-package recycle)) (unless (eq from-package (symbol-package symbol)) (ensure-imported symbol from-package)) (export* name from-package)) (defun ensure-export (name from-package &optional recycle) (multiple-value-bind (symbol status) (find-symbol* name from-package) (unless (eq status :external) (ensure-exported name symbol from-package recycle)))) (defun ensure-package (name &key nicknames documentation use shadow shadowing-import-from import-from export intern recycle mix reexport unintern) #+genera (declare (ignore documentation)) (let* ((package-name (string name)) (nicknames (mapcar #'string nicknames)) (names (cons package-name nicknames)) (previous (packages-from-names names)) (discarded (cdr previous)) (to-delete ()) (package (or (first previous) (make-package package-name :nicknames nicknames))) (recycle (packages-from-names recycle)) (use (mapcar 'find-package* use)) (mix (mapcar 'find-package* mix)) (reexport (mapcar 'find-package* reexport)) (shadow (mapcar 'string shadow)) (export (mapcar 'string export)) (intern (mapcar 'string intern)) (unintern (mapcar 'string unintern)) (shadowed (make-hash-table :test 'equal)) ; string to bool (imported (make-hash-table :test 'equal)) ; string to bool (exported (make-hash-table :test 'equal)) ; string to bool ;; string to list home package and use package: (inherited (make-hash-table :test 'equal))) (when-package-fishiness (record-fishy package-name)) #-genera (when documentation (setf (documentation package t) documentation)) (loop :for p :in (set-difference (package-use-list package) (append mix use)) :do (note-package-fishiness :over-use name (package-names p)) (unuse-package p package)) (loop :for p :in discarded :for n = (remove-if #'(lambda (x) (member x names :test 'equal)) (package-names p)) :do (note-package-fishiness :nickname name (package-names p)) (cond (n (rename-package p (first n) (rest n))) (t (rename-package-away p) (push p to-delete)))) (rename-package package package-name nicknames) (dolist (name unintern) (multiple-value-bind (existing status) (find-symbol name package) (when status (unless (eq status :inherited) (note-package-fishiness :unintern (package-name package) name (symbol-package-name existing) status) (unintern* name package nil))))) (dolist (name export) (setf (gethash name exported) t)) (dolist (p reexport) (do-external-symbols (sym p) (setf (gethash (string sym) exported) t))) (do-external-symbols (sym package) (let ((name (symbol-name sym))) (unless (gethash name exported) (note-package-fishiness :over-export (package-name package) name (or (home-package-p sym package) (symbol-package-name sym))) (unexport sym package)))) (dolist (name shadow) (setf (gethash name shadowed) t) (multiple-value-bind (existing status) (find-symbol name package) (multiple-value-bind (recycled previous) (recycle-symbol name recycle exported) (let ((shadowing (and status (symbol-shadowing-p existing package)))) (cond ((eq previous package)) (previous (rehome-symbol recycled package)) ((or (member status '(nil :inherited)) (home-package-p existing package))) (t (let ((dummy (make-symbol name))) (note-package-fishiness :shadow-imported (package-name package) name (symbol-package-name existing) status shadowing) (shadowing-import* dummy package) (import* dummy package))))))) (shadow* name package)) (loop :for (p . syms) :in shadowing-import-from :for pp = (find-package* p) :do (dolist (sym syms) (ensure-shadowing-import (string sym) package pp shadowed imported))) (loop :for p :in mix :for pp = (find-package* p) :do (do-external-symbols (sym pp) (ensure-mix (symbol-name sym) sym package pp shadowed imported inherited))) (loop :for (p . syms) :in import-from :for pp = (find-package p) :do (dolist (sym syms) (ensure-import (symbol-name sym) package pp shadowed imported))) (dolist (p (append use mix)) (do-external-symbols (sym p) (ensure-inherited (string sym) sym package p nil shadowed imported inherited)) (use-package p package)) (loop :for name :being :the :hash-keys :of exported :do (ensure-symbol name package t recycle shadowed imported inherited exported) (ensure-export name package recycle)) (dolist (name intern) (ensure-symbol name package t recycle shadowed imported inherited exported)) (do-symbols (sym package) (ensure-symbol (symbol-name sym) package nil recycle shadowed imported inherited exported)) (map () 'delete-package* to-delete) package))) (eval-when (:load-toplevel :compile-toplevel :execute) (defun parse-define-package-form (package clauses) (loop :with use-p = nil :with recycle-p = nil :with documentation = nil :for (kw . args) :in clauses :when (eq kw :nicknames) :append args :into nicknames :else :when (eq kw :documentation) :do (cond (documentation (error "define-package: can't define documentation twice")) ((or (atom args) (cdr args)) (error "define-package: bad documentation")) (t (setf documentation (car args)))) :else :when (eq kw :use) :append args :into use :and :do (setf use-p t) :else :when (eq kw :shadow) :append args :into shadow :else :when (eq kw :shadowing-import-from) :collect args :into shadowing-import-from :else :when (eq kw :import-from) :collect args :into import-from :else :when (eq kw :export) :append args :into export :else :when (eq kw :intern) :append args :into intern :else :when (eq kw :recycle) :append args :into recycle :and :do (setf recycle-p t) :else :when (eq kw :mix) :append args :into mix :else :when (eq kw :reexport) :append args :into reexport :else :when (eq kw :use-reexport) :append args :into use :and :append args :into reexport :and :do (setf use-p t) :else :when (eq kw :mix-reexport) :append args :into mix :and :append args :into reexport :and :do (setf use-p t) :else :when (eq kw :unintern) :append args :into unintern :else :do (error "unrecognized define-package keyword ~S" kw) :finally (return `(,package :nicknames ,nicknames :documentation ,documentation :use ,(if use-p use '(:common-lisp)) :shadow ,shadow :shadowing-import-from ,shadowing-import-from :import-from ,import-from :export ,export :intern ,intern :recycle ,(if recycle-p recycle (cons package nicknames)) :mix ,mix :reexport ,reexport :unintern ,unintern))))) (defmacro define-package (package &rest clauses) "DEFINE-PACKAGE takes a PACKAGE and a number of CLAUSES, of the form \(KEYWORD . ARGS\). DEFINE-PACKAGE supports the following keywords: USE, SHADOW, SHADOWING-IMPORT-FROM, IMPORT-FROM, EXPORT, INTERN -- as per CL:DEFPACKAGE. RECYCLE -- Recycle the package's exported symbols from the specified packages, in order. For every symbol scheduled to be exported by the DEFINE-PACKAGE, either through an :EXPORT option or a :REEXPORT option, if the symbol exists in one of the :RECYCLE packages, the first such symbol is re-homed to the package being defined. For the sake of idempotence, it is important that the package being defined should appear in first position if it already exists, and even if it doesn't, ahead of any package that is not going to be deleted afterwards and never created again. In short, except for special cases, always make it the first package on the list if the list is not empty. MIX -- Takes a list of package designators. MIX behaves like \(:USE PKG1 PKG2 ... PKGn\) but additionally uses :SHADOWING-IMPORT-FROM to resolve conflicts in favor of the first found symbol. It may still yield an error if there is a conflict with an explicitly :IMPORT-FROM symbol. REEXPORT -- Takes a list of package designators. For each package, p, in the list, export symbols with the same name as those exported from p. Note that in the case of shadowing, etc. the symbols with the same name may not be the same symbols. UNINTERN -- Remove symbols here from PACKAGE." (let ((ensure-form `(apply 'ensure-package ',(parse-define-package-form package clauses)))) `(progn #+(or clasp ecl gcl mkcl) (defpackage ,package (:use)) (eval-when (:compile-toplevel :load-toplevel :execute) ,ensure-form)))) ;;;; Final tricks to keep various implementations happy. ;; We want most such tricks in common-lisp.lisp, ;; but these need to be done before the define-package form there, ;; that we nevertheless want to be the very first form. (eval-when (:load-toplevel :compile-toplevel :execute) #+allegro ;; We need to disable autoloading BEFORE any mention of package ASDF. (setf excl::*autoload-package-name-alist* (remove "asdf" excl::*autoload-package-name-alist* :test 'equalp :key 'car))) ;; Compatibility with whoever calls asdf/package (define-package :asdf/package (:use :cl :uiop/package) (:reexport :uiop/package)) ;;;; ------------------------------------------------------------------------- ;;;; Handle compatibility with multiple implementations. ;;; This file is for papering over the deficiencies and peculiarities ;;; of various Common Lisp implementations. ;;; For implementation-specific access to the system, see os.lisp instead. ;;; A few functions are defined here, but actually exported from utility; ;;; from this package only common-lisp symbols are exported. (uiop/package:define-package :uiop/common-lisp (:nicknames :uoip/cl :asdf/common-lisp :asdf/cl) (:use :uiop/package) (:use-reexport #-genera :common-lisp #+genera :future-common-lisp) (:recycle :uiop/common-lisp :uoip/cl :asdf/common-lisp :asdf/cl :asdf) #+allegro (:intern #:*acl-warn-save*) #+cormanlisp (:shadow #:user-homedir-pathname) #+cormanlisp (:export #:logical-pathname #:translate-logical-pathname #:make-broadcast-stream #:file-namestring) #+genera (:shadowing-import-from :scl #:boolean) #+genera (:export #:boolean #:ensure-directories-exist #:read-sequence #:write-sequence) #+mcl (:shadow #:user-homedir-pathname)) (in-package :uiop/common-lisp) #-(or abcl allegro clasp clisp clozure cmu cormanlisp ecl gcl genera lispworks mcl mkcl sbcl scl xcl) (error "ASDF is not supported on your implementation. Please help us port it.") ;; (declaim (optimize (speed 1) (debug 3) (safety 3))) ; DON'T: trust implementation defaults. ;;;; Early meta-level tweaks #+(or abcl allegro clasp clisp cmu ecl mkcl clozure lispworks mkcl sbcl scl) (eval-when (:load-toplevel :compile-toplevel :execute) ;; Check for unicode at runtime, so that a hypothetical FASL compiled with unicode ;; but loaded in a non-unicode setting (e.g. on Allegro) won't tell a lie. (when (and #+allegro (member :ics *features*) #+(or clasp clisp cmu ecl mkcl) (member :unicode *features*) #+sbcl (member :sb-unicode *features*)) (pushnew :asdf-unicode *features*))) #+allegro (eval-when (:load-toplevel :compile-toplevel :execute) (defparameter *acl-warn-save* (when (boundp 'excl:*warn-on-nested-reader-conditionals*) excl:*warn-on-nested-reader-conditionals*)) (when (boundp 'excl:*warn-on-nested-reader-conditionals*) (setf excl:*warn-on-nested-reader-conditionals* nil)) (setf *print-readably* nil)) #+clasp (eval-when (:load-toplevel :compile-toplevel :execute) (setf *load-verbose* nil) (defun use-ecl-byte-compiler-p () nil)) #+clozure (in-package :ccl) #+(and clozure windows-target) ;; See http://trac.clozure.com/ccl/ticket/1117 (eval-when (:load-toplevel :compile-toplevel :execute) (unless (fboundp 'external-process-wait) (in-development-mode (defun external-process-wait (proc) (when (and (external-process-pid proc) (eq (external-process-%status proc) :running)) (with-interrupts-enabled (wait-on-semaphore (external-process-completed proc)))) (values (external-process-%exit-code proc) (external-process-%status proc)))))) #+clozure (in-package :uiop/common-lisp) #+cormanlisp (eval-when (:load-toplevel :compile-toplevel :execute) (deftype logical-pathname () nil) (defun make-broadcast-stream () *error-output*) (defun translate-logical-pathname (x) x) (defun user-homedir-pathname (&optional host) (declare (ignore host)) (parse-namestring (format nil "~A\\" (cl:user-homedir-pathname)))) (defun file-namestring (p) (setf p (pathname p)) (format nil "~@[~A~]~@[.~A~]" (pathname-name p) (pathname-type p)))) #+(and ecl (not clasp)) (eval-when (:load-toplevel :compile-toplevel :execute) (setf *load-verbose* nil) (defun use-ecl-byte-compiler-p () (and (member :ecl-bytecmp *features*) t)) (unless (use-ecl-byte-compiler-p) (require :cmp))) #+gcl (eval-when (:load-toplevel :compile-toplevel :execute) (unless (member :ansi-cl *features*) (error "ASDF only supports GCL in ANSI mode. Aborting.~%")) (setf compiler::*compiler-default-type* (pathname "") compiler::*lsp-ext* "") #.(let ((code ;; Only support very recent GCL 2.7.0 from November 2013 or later. (cond #+gcl ((or (< system::*gcl-major-version* 2) (and (= system::*gcl-major-version* 2) (< system::*gcl-minor-version* 7))) '(error "GCL 2.7 or later required to use ASDF"))))) (eval code) code)) #+genera (eval-when (:load-toplevel :compile-toplevel :execute) (unless (fboundp 'lambda) (defmacro lambda (&whole form &rest bvl-decls-and-body) (declare (ignore bvl-decls-and-body)(zwei::indentation 1 1)) `#',(cons 'lisp::lambda (cdr form)))) (unless (fboundp 'ensure-directories-exist) (defun ensure-directories-exist (path) (fs:create-directories-recursively (pathname path)))) (unless (fboundp 'read-sequence) (defun read-sequence (sequence stream &key (start 0) end) (scl:send stream :string-in nil sequence start end))) (unless (fboundp 'write-sequence) (defun write-sequence (sequence stream &key (start 0) end) (scl:send stream :string-out sequence start end) sequence))) #.(or #+mcl ;; the #$ doesn't work on other lisps, even protected by #+mcl, so we use this trick (read-from-string "(eval-when (:load-toplevel :compile-toplevel :execute) (ccl:define-entry-point (_getenv \"getenv\") ((name :string)) :string) (ccl:define-entry-point (_system \"system\") ((name :string)) :int) ;; Note: ASDF may expect user-homedir-pathname to provide ;; the pathname of the current user's home directory, whereas ;; MCL by default provides the directory from which MCL was started. ;; See http://code.google.com/p/mcl/wiki/Portability (defun user-homedir-pathname () (ccl::findfolder #$kuserdomain #$kCurrentUserFolderType)) (defun probe-posix (posix-namestring) \"If a file exists for the posix namestring, return the pathname\" (ccl::with-cstrs ((cpath posix-namestring)) (ccl::rlet ((is-dir :boolean) (fsref :fsref)) (when (eq #$noerr (#_fspathmakeref cpath fsref is-dir)) (ccl::%path-from-fsref fsref is-dir))))))")) #+mkcl (eval-when (:load-toplevel :compile-toplevel :execute) (require :cmp) (setq clos::*redefine-class-in-place* t)) ;; Make sure we have strict ANSI class redefinition semantics ;;;; Looping (eval-when (:load-toplevel :compile-toplevel :execute) (defmacro loop* (&rest rest) #-genera `(loop ,@rest) #+genera `(lisp:loop ,@rest))) ;; In genera, CL:LOOP can't destructure, so we use LOOP*. Sigh. ;;;; compatfmt: avoid fancy format directives when unsupported (eval-when (:load-toplevel :compile-toplevel :execute) (defun frob-substrings (string substrings &optional frob) "for each substring in SUBSTRINGS, find occurrences of it within STRING that don't use parts of matched occurrences of previous strings, and FROB them, that is to say, remove them if FROB is NIL, replace by FROB if FROB is a STRING, or if FROB is a FUNCTION, call FROB with the match and a function that emits a string in the output. Return a string made of the parts not omitted or emitted by FROB." (declare (optimize (speed 0) (safety #-gcl 3 #+gcl 0) (debug 3))) (let ((length (length string)) (stream nil)) (labels ((emit-string (x &optional (start 0) (end (length x))) (when (< start end) (unless stream (setf stream (make-string-output-stream))) (write-string x stream :start start :end end))) (emit-substring (start end) (when (and (zerop start) (= end length)) (return-from frob-substrings string)) (emit-string string start end)) (recurse (substrings start end) (cond ((>= start end)) ((null substrings) (emit-substring start end)) (t (let* ((sub-spec (first substrings)) (sub (if (consp sub-spec) (car sub-spec) sub-spec)) (fun (if (consp sub-spec) (cdr sub-spec) frob)) (found (search sub string :start2 start :end2 end)) (more (rest substrings))) (cond (found (recurse more start found) (etypecase fun (null) (string (emit-string fun)) (function (funcall fun sub #'emit-string))) (recurse substrings (+ found (length sub)) end)) (t (recurse more start end)))))))) (recurse substrings 0 length)) (if stream (get-output-stream-string stream) ""))) (defmacro compatfmt (format) #+(or gcl genera) (frob-substrings format `("~3i~_" #+genera ,@'("~@<" "~@;" "~@:>" "~:>"))) #-(or gcl genera) format)) ;;;; ------------------------------------------------------------------------- ;;;; General Purpose Utilities for ASDF (uiop/package:define-package :uiop/utility (:nicknames :asdf/utility) (:recycle :uiop/utility :asdf/utility :asdf) (:use :uiop/common-lisp :uiop/package) ;; import and reexport a few things defined in :uiop/common-lisp (:import-from :uiop/common-lisp #:compatfmt #:loop* #:frob-substrings #+(or clasp ecl) #:use-ecl-byte-compiler-p #+mcl #:probe-posix) (:export #:compatfmt #:loop* #:frob-substrings #:compatfmt #+(or clasp ecl) #:use-ecl-byte-compiler-p #+mcl #:probe-posix) (:export ;; magic helper to define debugging functions: #:uiop-debug #:load-uiop-debug-utility #:*uiop-debug-utility* #:with-upgradability ;; (un)defining functions in an upgrade-friendly way #:undefine-function #:undefine-functions #:defun* #:defgeneric* #:nest #:if-let ;; basic flow control #:while-collecting #:appendf #:length=n-p #:ensure-list ;; lists #:remove-plist-keys #:remove-plist-key ;; plists #:emptyp ;; sequences #:+non-base-chars-exist-p+ ;; characters #:+max-character-type-index+ #:character-type-index #:+character-types+ #:base-string-p #:strings-common-element-type #:reduce/strcat #:strcat ;; strings #:first-char #:last-char #:split-string #:stripln #:+cr+ #:+lf+ #:+crlf+ #:string-prefix-p #:string-enclosed-p #:string-suffix-p #:standard-case-symbol-name #:find-standard-case-symbol #:coerce-class ;; CLOS #:stamp< #:stamps< #:stamp*< #:stamp<= ;; stamps #:earlier-stamp #:stamps-earliest #:earliest-stamp #:later-stamp #:stamps-latest #:latest-stamp #:latest-stamp-f #:list-to-hash-set #:ensure-gethash ;; hash-table #:ensure-function #:access-at #:access-at-count ;; functions #:call-function #:call-functions #:register-hook-function #:match-condition-p #:match-any-condition-p ;; conditions #:call-with-muffled-conditions #:with-muffled-conditions #:lexicographic< #:lexicographic<= #:parse-version #:unparse-version #:version< #:version<= #:version-compatible-p)) ;; version (in-package :uiop/utility) ;;;; Defining functions in a way compatible with hot-upgrade: ;; DEFUN* and DEFGENERIC* use FMAKUNBOUND to delete any previous fdefinition, ;; thus replacing the function without warning or error ;; even if the signature and/or generic-ness of the function has changed. ;; For a generic function, this invalidates any previous DEFMETHOD. (eval-when (:load-toplevel :compile-toplevel :execute) (defun undefine-function (function-spec) (cond ((symbolp function-spec) ;; undefining the previous function is the portable way ;; of overriding any incompatible previous gf, ;; but CLISP needs extra help with getting rid of previous methods. #+clisp (let ((f (and (fboundp function-spec) (fdefinition function-spec)))) (when (typep f 'clos:standard-generic-function) (loop :for m :in (clos:generic-function-methods f) :do (remove-method f m)))) (fmakunbound function-spec)) ((and (consp function-spec) (eq (car function-spec) 'setf) (consp (cdr function-spec)) (null (cddr function-spec))) (fmakunbound function-spec)) (t (error "bad function spec ~S" function-spec)))) (defun undefine-functions (function-spec-list) (map () 'undefine-function function-spec-list)) (macrolet ((defdef (def* def) `(defmacro ,def* (name formals &rest rest) (destructuring-bind (name &key (supersede t)) (if (or (atom name) (eq (car name) 'setf)) (list name :supersede nil) name) (declare (ignorable supersede)) `(progn ;; We usually try to do it only for the functions that need it, ;; which happens in asdf/upgrade - however, for ECL, we need this hammer. ,@(when (or supersede #+(or clasp ecl) t) `((undefine-function ',name))) ,@(when (and #+(or clasp ecl) (symbolp name)) ; fails for setf functions on ecl `((declaim (notinline ,name)))) (,',def ,name ,formals ,@rest)))))) (defdef defgeneric* defgeneric) (defdef defun* defun)) (defmacro with-upgradability ((&optional) &body body) "Evaluate BODY at compile- load- and run- times, with DEFUN and DEFGENERIC modified to also declare the functions NOTINLINE and to accept a wrapping the function name specification into a list with keyword argument SUPERSEDE (which defaults to T if the name is not wrapped, and NIL if it is wrapped). If SUPERSEDE is true, call UNDEFINE-FUNCTION to supersede any previous definition." `(eval-when (:compile-toplevel :load-toplevel :execute) ,@(loop :for form :in body :collect (if (consp form) (destructuring-bind (car . cdr) form (case car ((defun) `(defun* ,@cdr)) ((defgeneric) `(defgeneric* ,@cdr)) (otherwise form))) form))))) ;;; Magic debugging help. See contrib/debug.lisp (with-upgradability () (defvar *uiop-debug-utility* '(or (ignore-errors (symbol-call :asdf :system-relative-pathname :uiop "contrib/debug.lisp")) (symbol-call :uiop/pathname :subpathname (user-homedir-pathname) "cl/asdf/uiop/contrib/debug.lisp")) "form that evaluates to the pathname to your favorite debugging utilities") (defmacro uiop-debug (&rest keys) `(eval-when (:compile-toplevel :load-toplevel :execute) (load-uiop-debug-utility ,@keys))) (defun load-uiop-debug-utility (&key package utility-file) (let* ((*package* (if package (find-package package) *package*)) (keyword (read-from-string (format nil ":DBG-~:@(~A~)" (package-name *package*))))) (unless (member keyword *features*) (let* ((utility-file (or utility-file *uiop-debug-utility*)) (file (ignore-errors (probe-file (eval utility-file))))) (if file (load file) (error "Failed to locate debug utility file: ~S" utility-file))))))) ;;; Flow control (with-upgradability () (defmacro nest (&rest things) "Macro to do keep code nesting and indentation under control." ;; Thanks to mbaringer (reduce #'(lambda (outer inner) `(,@outer ,inner)) things :from-end t)) (defmacro if-let (bindings &body (then-form &optional else-form)) ;; from alexandria ;; bindings can be (var form) or ((var1 form1) ...) (let* ((binding-list (if (and (consp bindings) (symbolp (car bindings))) (list bindings) bindings)) (variables (mapcar #'car binding-list))) `(let ,binding-list (if (and ,@variables) ,then-form ,else-form))))) ;;; List manipulation (with-upgradability () (defmacro while-collecting ((&rest collectors) &body body) "COLLECTORS should be a list of names for collections. A collector defines a function that, when applied to an argument inside BODY, will add its argument to the corresponding collection. Returns multiple values, a list for each collection, in order. E.g., \(while-collecting \(foo bar\) \(dolist \(x '\(\(a 1\) \(b 2\) \(c 3\)\)\) \(foo \(first x\)\) \(bar \(second x\)\)\)\) Returns two values: \(A B C\) and \(1 2 3\)." (let ((vars (mapcar #'(lambda (x) (gensym (symbol-name x))) collectors)) (initial-values (mapcar (constantly nil) collectors))) `(let ,(mapcar #'list vars initial-values) (flet ,(mapcar #'(lambda (c v) `(,c (x) (push x ,v) (values))) collectors vars) ,@body (values ,@(mapcar #'(lambda (v) `(reverse ,v)) vars)))))) (define-modify-macro appendf (&rest args) append "Append onto list") ;; only to be used on short lists. (defun length=n-p (x n) ;is it that (= (length x) n) ? (check-type n (integer 0 *)) (loop :for l = x :then (cdr l) :for i :downfrom n :do (cond ((zerop i) (return (null l))) ((not (consp l)) (return nil))))) (defun ensure-list (x) (if (listp x) x (list x)))) ;;; remove a key from a plist, i.e. for keyword argument cleanup (with-upgradability () (defun remove-plist-key (key plist) "Remove a single key from a plist" (loop* :for (k v) :on plist :by #'cddr :unless (eq k key) :append (list k v))) (defun remove-plist-keys (keys plist) "Remove a list of keys from a plist" (loop* :for (k v) :on plist :by #'cddr :unless (member k keys) :append (list k v)))) ;;; Sequences (with-upgradability () (defun emptyp (x) "Predicate that is true for an empty sequence" (or (null x) (and (vectorp x) (zerop (length x)))))) ;;; Characters (with-upgradability () ;; base-char != character on ECL, LW, SBCL, Genera. ;; NB: We assume a total order on character types. ;; If that's not true... this code will need to be updated. (defparameter +character-types+ ;; assuming a simple hierarchy #.(coerce (loop* :for (type next) :on '(;; In SCL, all characters seem to be 16-bit base-char ;; Yet somehow character fails to be a subtype of base-char #-scl base-char ;; LW6 has BASE-CHAR < SIMPLE-CHAR < CHARACTER ;; LW7 has BASE-CHAR < BMP-CHAR < SIMPLE-CHAR = CHARACTER #+(and lispworks (not (or lispworks4 lispworks5 lispworks6))) lw:bmp-char #+lispworks lw:simple-char character) :unless (and next (subtypep next type)) :collect type) 'vector)) (defparameter +max-character-type-index+ (1- (length +character-types+))) (defconstant +non-base-chars-exist-p+ (plusp +max-character-type-index+)) (when +non-base-chars-exist-p+ (pushnew :non-base-chars-exist-p *features*))) (with-upgradability () (defun character-type-index (x) (declare (ignorable x)) #.(case +max-character-type-index+ (0 0) (1 '(etypecase x (character (if (typep x 'base-char) 0 1)) (symbol (if (subtypep x 'base-char) 0 1)))) (otherwise '(or (position-if (etypecase x (character #'(lambda (type) (typep x type))) (symbol #'(lambda (type) (subtypep x type)))) +character-types+) (error "Not a character or character type: ~S" x)))))) ;;; Strings (with-upgradability () (defun base-string-p (string) "Does the STRING only contain BASE-CHARs?" (declare (ignorable string)) (and #+non-base-chars-exist-p (eq 'base-char (array-element-type string)))) (defun strings-common-element-type (strings) "What least subtype of CHARACTER can contain all the elements of all the STRINGS?" (declare (ignorable strings)) #.(if +non-base-chars-exist-p+ `(aref +character-types+ (loop :with index = 0 :for s :in strings :do (flet ((consider (i) (cond ((= i ,+max-character-type-index+) (return i)) ,@(when (> +max-character-type-index+ 1) `(((> i index) (setf index i))))))) (cond ((emptyp s)) ;; NIL or empty string ((characterp s) (consider (character-type-index s))) ((stringp s) (let ((string-type-index (character-type-index (array-element-type s)))) (unless (>= index string-type-index) (loop :for c :across s :for i = (character-type-index c) :do (consider i) ,@(when (> +max-character-type-index+ 1) `((when (= i string-type-index) (return)))))))) (t (error "Invalid string designator ~S for ~S" s 'strings-common-element-type)))) :finally (return index))) ''character)) (defun reduce/strcat (strings &key key start end) "Reduce a list as if by STRCAT, accepting KEY START and END keywords like REDUCE. NIL is interpreted as an empty string. A character is interpreted as a string of length one." (when (or start end) (setf strings (subseq strings start end))) (when key (setf strings (mapcar key strings))) (loop :with output = (make-string (loop :for s :in strings :sum (if (characterp s) 1 (length s))) :element-type (strings-common-element-type strings)) :with pos = 0 :for input :in strings :do (etypecase input (null) (character (setf (char output pos) input) (incf pos)) (string (replace output input :start1 pos) (incf pos (length input)))) :finally (return output))) (defun strcat (&rest strings) "Concatenate strings. NIL is interpreted as an empty string, a character as a string of length one." (reduce/strcat strings)) (defun first-char (s) "Return the first character of a non-empty string S, or NIL" (and (stringp s) (plusp (length s)) (char s 0))) (defun last-char (s) "Return the last character of a non-empty string S, or NIL" (and (stringp s) (plusp (length s)) (char s (1- (length s))))) (defun split-string (string &key max (separator '(#\Space #\Tab))) "Split STRING into a list of components separated by any of the characters in the sequence SEPARATOR. If MAX is specified, then no more than max(1,MAX) components will be returned, starting the separation from the end, e.g. when called with arguments \"a.b.c.d.e\" :max 3 :separator \".\" it will return (\"a.b.c\" \"d\" \"e\")." (block () (let ((list nil) (words 0) (end (length string))) (when (zerop end) (return nil)) (flet ((separatorp (char) (find char separator)) (done () (return (cons (subseq string 0 end) list)))) (loop :for start = (if (and max (>= words (1- max))) (done) (position-if #'separatorp string :end end :from-end t)) :do (when (null start) (done)) (push (subseq string (1+ start) end) list) (incf words) (setf end start)))))) (defun string-prefix-p (prefix string) "Does STRING begin with PREFIX?" (let* ((x (string prefix)) (y (string string)) (lx (length x)) (ly (length y))) (and (<= lx ly) (string= x y :end2 lx)))) (defun string-suffix-p (string suffix) "Does STRING end with SUFFIX?" (let* ((x (string string)) (y (string suffix)) (lx (length x)) (ly (length y))) (and (<= ly lx) (string= x y :start1 (- lx ly))))) (defun string-enclosed-p (prefix string suffix) "Does STRING begin with PREFIX and end with SUFFIX?" (and (string-prefix-p prefix string) (string-suffix-p string suffix))) (defvar +cr+ (coerce #(#\Return) 'string)) (defvar +lf+ (coerce #(#\Linefeed) 'string)) (defvar +crlf+ (coerce #(#\Return #\Linefeed) 'string)) (defun stripln (x) "Strip a string X from any ending CR, LF or CRLF. Return two values, the stripped string and the ending that was stripped, or the original value and NIL if no stripping took place. Since our STRCAT accepts NIL as empty string designator, the two results passed to STRCAT always reconstitute the original string" (check-type x string) (block nil (flet ((c (end) (when (string-suffix-p x end) (return (values (subseq x 0 (- (length x) (length end))) end))))) (when x (c +crlf+) (c +lf+) (c +cr+) (values x nil))))) (defun standard-case-symbol-name (name-designator) "Given a NAME-DESIGNATOR for a symbol, if it is a symbol, convert it to a string using STRING; if it is a string, use STRING-UPCASE on an ANSI CL platform, or STRING on a so-called \"modern\" platform such as Allegro with modern syntax." (check-type name-designator (or string symbol)) (cond ((or (symbolp name-designator) #+allegro (eq excl:*current-case-mode* :case-sensitive-lower)) (string name-designator)) ;; Should we be doing something on CLISP? (t (string-upcase name-designator)))) (defun find-standard-case-symbol (name-designator package-designator &optional (error t)) "Find a symbol designated by NAME-DESIGNATOR in a package designated by PACKAGE-DESIGNATOR, where STANDARD-CASE-SYMBOL-NAME is used to transform them if these designators are strings. If optional ERROR argument is NIL, return NIL instead of an error when the symbol is not found." (find-symbol* (standard-case-symbol-name name-designator) (etypecase package-designator ((or package symbol) package-designator) (string (standard-case-symbol-name package-designator))) error))) ;;; stamps: a REAL or a boolean where NIL=-infinity, T=+infinity (eval-when (#-lispworks :compile-toplevel :load-toplevel :execute) (deftype stamp () '(or real boolean))) (with-upgradability () (defun stamp< (x y) (etypecase x (null (and y t)) ((eql t) nil) (real (etypecase y (null nil) ((eql t) t) (real (< x y)))))) (defun stamps< (list) (loop :for y :in list :for x = nil :then y :always (stamp< x y))) (defun stamp*< (&rest list) (stamps< list)) (defun stamp<= (x y) (not (stamp< y x))) (defun earlier-stamp (x y) (if (stamp< x y) x y)) (defun stamps-earliest (list) (reduce 'earlier-stamp list :initial-value t)) (defun earliest-stamp (&rest list) (stamps-earliest list)) (defun later-stamp (x y) (if (stamp< x y) y x)) (defun stamps-latest (list) (reduce 'later-stamp list :initial-value nil)) (defun latest-stamp (&rest list) (stamps-latest list)) (define-modify-macro latest-stamp-f (&rest stamps) latest-stamp)) ;;; Function designators (with-upgradability () (defun ensure-function (fun &key (package :cl)) "Coerce the object FUN into a function. If FUN is a FUNCTION, return it. If the FUN is a non-sequence literal constant, return constantly that, i.e. for a boolean keyword character number or pathname. Otherwise if FUN is a non-literally constant symbol, return its FDEFINITION. If FUN is a CONS, return the function that applies its CAR to the appended list of the rest of its CDR and the arguments, unless the CAR is LAMBDA, in which case the expression is evaluated. If FUN is a string, READ a form from it in the specified PACKAGE (default: CL) and EVAL that in a (FUNCTION ...) context." (etypecase fun (function fun) ((or boolean keyword character number pathname) (constantly fun)) (hash-table #'(lambda (x) (gethash x fun))) (symbol (fdefinition fun)) (cons (if (eq 'lambda (car fun)) (eval fun) #'(lambda (&rest args) (apply (car fun) (append (cdr fun) args))))) (string (eval `(function ,(with-standard-io-syntax (let ((*package* (find-package package))) (read-from-string fun)))))))) (defun access-at (object at) "Given an OBJECT and an AT specifier, list of successive accessors, call each accessor on the result of the previous calls. An accessor may be an integer, meaning a call to ELT, a keyword, meaning a call to GETF, NIL, meaning identity, a function or other symbol, meaning itself, or a list of a function designator and arguments, interpreted as per ENSURE-FUNCTION. As a degenerate case, the AT specifier may be an atom of a single such accessor instead of a list." (flet ((access (object accessor) (etypecase accessor (function (funcall accessor object)) (integer (elt object accessor)) (keyword (getf object accessor)) (null object) (symbol (funcall accessor object)) (cons (funcall (ensure-function accessor) object))))) (if (listp at) (dolist (accessor at object) (setf object (access object accessor))) (access object at)))) (defun access-at-count (at) "From an AT specification, extract a COUNT of maximum number of sub-objects to read as per ACCESS-AT" (cond ((integerp at) (1+ at)) ((and (consp at) (integerp (first at))) (1+ (first at))))) (defun call-function (function-spec &rest arguments) "Call the function designated by FUNCTION-SPEC as per ENSURE-FUNCTION, with the given ARGUMENTS" (apply (ensure-function function-spec) arguments)) (defun call-functions (function-specs) "For each function in the list FUNCTION-SPECS, in order, call the function as per CALL-FUNCTION" (map () 'call-function function-specs)) (defun register-hook-function (variable hook &optional call-now-p) "Push the HOOK function (a designator as per ENSURE-FUNCTION) onto the hook VARIABLE. When CALL-NOW-P is true, also call the function immediately." (pushnew hook (symbol-value variable) :test 'equal) (when call-now-p (call-function hook)))) ;;; CLOS (with-upgradability () (defun coerce-class (class &key (package :cl) (super t) (error 'error)) "Coerce CLASS to a class that is subclass of SUPER if specified, or invoke ERROR handler as per CALL-FUNCTION. A keyword designates the name a symbol, which when found in either PACKAGE, designates a class. -- for backward compatibility, *PACKAGE* is also accepted for now, but this may go in the future. A string is read as a symbol while in PACKAGE, the symbol designates a class. A class object designates itself. NIL designates itself (no class). A symbol otherwise designates a class by name." (let* ((normalized (typecase class (keyword (or (find-symbol* class package nil) (find-symbol* class *package* nil))) (string (symbol-call :uiop :safe-read-from-string class :package package)) (t class))) (found (etypecase normalized ((or standard-class built-in-class) normalized) ((or null keyword) nil) (symbol (find-class normalized nil nil))))) (or (and found (or (eq super t) (#-cormanlisp subtypep #+cormanlisp cl::subclassp found super)) found) (call-function error "Can't coerce ~S to a ~:[class~;subclass of ~:*~S~]" class super))))) ;;; Hash-tables (with-upgradability () (defun ensure-gethash (key table default) "Lookup the TABLE for a KEY as by GETHASH, but if not present, call the (possibly constant) function designated by DEFAULT as per CALL-FUNCTION, set the corresponding entry to the result in the table. Return two values: the entry after its optional computation, and whether it was found" (multiple-value-bind (value foundp) (gethash key table) (values (if foundp value (setf (gethash key table) (call-function default))) foundp))) (defun list-to-hash-set (list &aux (h (make-hash-table :test 'equal))) "Convert a LIST into hash-table that has the same elements when viewed as a set, up to the given equality TEST" (dolist (x list h) (setf (gethash x h) t)))) ;;; Version handling (with-upgradability () (defun unparse-version (version-list) (format nil "~{~D~^.~}" version-list)) (defun parse-version (version-string &optional on-error) "Parse a VERSION-STRING as a series of natural integers separated by dots. Return a (non-null) list of integers if the string is valid; otherwise return NIL. When invalid, ON-ERROR is called as per CALL-FUNCTION before to return NIL, with format arguments explaining why the version is invalid. ON-ERROR is also called if the version is not canonical in that it doesn't print back to itself, but the list is returned anyway." (block nil (unless (stringp version-string) (call-function on-error "~S: ~S is not a string" 'parse-version version-string) (return)) (unless (loop :for prev = nil :then c :for c :across version-string :always (or (digit-char-p c) (and (eql c #\.) prev (not (eql prev #\.)))) :finally (return (and c (digit-char-p c)))) (call-function on-error "~S: ~S doesn't follow asdf version numbering convention" 'parse-version version-string) (return)) (let* ((version-list (mapcar #'parse-integer (split-string version-string :separator "."))) (normalized-version (unparse-version version-list))) (unless (equal version-string normalized-version) (call-function on-error "~S: ~S contains leading zeros" 'parse-version version-string)) version-list))) (defun lexicographic< (< x y) (cond ((null y) nil) ((null x) t) ((funcall < (car x) (car y)) t) ((funcall < (car y) (car x)) nil) (t (lexicographic< < (cdr x) (cdr y))))) (defun lexicographic<= (< x y) (not (lexicographic< < y x))) (defun version< (version1 version2) (let ((v1 (parse-version version1 nil)) (v2 (parse-version version2 nil))) (lexicographic< '< v1 v2))) (defun version<= (version1 version2) (not (version< version2 version1))) (defun version-compatible-p (provided-version required-version) "Is the provided version a compatible substitution for the required-version? If major versions differ, it's not compatible. If they are equal, then any later version is compatible, with later being determined by a lexicographical comparison of minor numbers." (let ((x (parse-version provided-version nil)) (y (parse-version required-version nil))) (and x y (= (car x) (car y)) (lexicographic<= '< (cdr y) (cdr x)))))) ;;; Condition control (with-upgradability () (defparameter +simple-condition-format-control-slot+ #+abcl 'system::format-control #+allegro 'excl::format-control #+clisp 'system::$format-control #+clozure 'ccl::format-control #+(or cmu scl) 'conditions::format-control #+(or clasp ecl mkcl) 'si::format-control #+(or gcl lispworks) 'conditions::format-string #+sbcl 'sb-kernel:format-control #-(or abcl allegro clasp clisp clozure cmu ecl gcl lispworks mkcl sbcl scl) nil "Name of the slot for FORMAT-CONTROL in simple-condition") (defun match-condition-p (x condition) "Compare received CONDITION to some pattern X: a symbol naming a condition class, a simple vector of length 2, arguments to find-symbol* with result as above, or a string describing the format-control of a simple-condition." (etypecase x (symbol (typep condition x)) ((simple-vector 2) (ignore-errors (typep condition (find-symbol* (svref x 0) (svref x 1) nil)))) (function (funcall x condition)) (string (and (typep condition 'simple-condition) ;; On SBCL, it's always set and the check triggers a warning #+(or allegro clozure cmu lispworks scl) (slot-boundp condition +simple-condition-format-control-slot+) (ignore-errors (equal (simple-condition-format-control condition) x)))))) (defun match-any-condition-p (condition conditions) "match CONDITION against any of the patterns of CONDITIONS supplied" (loop :for x :in conditions :thereis (match-condition-p x condition))) (defun call-with-muffled-conditions (thunk conditions) "calls the THUNK in a context where the CONDITIONS are muffled" (handler-bind ((t #'(lambda (c) (when (match-any-condition-p c conditions) (muffle-warning c))))) (funcall thunk))) (defmacro with-muffled-conditions ((conditions) &body body) "Shorthand syntax for CALL-WITH-MUFFLED-CONDITIONS" `(call-with-muffled-conditions #'(lambda () ,@body) ,conditions))) ;;;; --------------------------------------------------------------------------- ;;;; Access to the Operating System (uiop/package:define-package :uiop/os (:nicknames :asdf/os) (:recycle :uiop/os :asdf/os :asdf) (:use :uiop/common-lisp :uiop/package :uiop/utility) (:export #:featurep #:os-unix-p #:os-macosx-p #:os-windows-p #:os-genera-p #:detect-os ;; features #:os-cond #:getenv #:getenvp ;; environment variables #:implementation-identifier ;; implementation identifier #:implementation-type #:*implementation-type* #:operating-system #:architecture #:lisp-version-string #:hostname #:getcwd #:chdir ;; Windows shortcut support #:read-null-terminated-string #:read-little-endian #:parse-file-location-info #:parse-windows-shortcut)) (in-package :uiop/os) ;;; Features (with-upgradability () (defun featurep (x &optional (*features* *features*)) "Checks whether a feature expression X is true with respect to the *FEATURES* set, as per the CLHS standard for #+ and #-. Beware that just like the CLHS, we assume symbols from the KEYWORD package are used, but that unless you're using #+/#- your reader will not have magically used the KEYWORD package, so you need specify keywords explicitly." (cond ((atom x) (and (member x *features*) t)) ((eq :not (car x)) (assert (null (cddr x))) (not (featurep (cadr x)))) ((eq :or (car x)) (some #'featurep (cdr x))) ((eq :and (car x)) (every #'featurep (cdr x))) (t (error "Malformed feature specification ~S" x)))) ;; Starting with UIOP 3.1.5, these are runtime tests. ;; You may bind *features* with a copy of what your target system offers to test its properties. (defun os-macosx-p () "Is the underlying operating system MacOS X?" ;; OS-MACOSX is not mutually exclusive with OS-UNIX, ;; in fact the former implies the latter. (featurep '(:or :darwin (:and :allegro :macosx) (:and :clisp :macos)))) (defun os-unix-p () "Is the underlying operating system some Unix variant?" (or (featurep '(:or :unix :cygwin)) (os-macosx-p))) (defun os-windows-p () "Is the underlying operating system Microsoft Windows?" (and (not (os-unix-p)) (featurep '(:or :win32 :windows :mswindows :mingw32 :mingw64)))) (defun os-genera-p () "Is the underlying operating system Genera (running on a Symbolics Lisp Machine)?" (featurep :genera)) (defun os-oldmac-p () "Is the underlying operating system an (emulated?) MacOS 9 or earlier?" (featurep :mcl)) (defun detect-os () "Detects the current operating system. Only needs be run at compile-time, except on ABCL where it might change between FASL compilation and runtime." (loop* :with o :for (feature . detect) :in '((:os-unix . os-unix-p) (:os-macosx . os-macosx-p) (:os-windows . os-windows-p) (:genera . os-genera-p) (:os-oldmac . os-oldmac-p)) :when (and (or (not o) (eq feature :os-macosx)) (funcall detect)) :do (setf o feature) (pushnew feature *features*) :else :do (setf *features* (remove feature *features*)) :finally (return (or o (error "Congratulations for trying ASDF on an operating system~%~ that is neither Unix, nor Windows, nor Genera, nor even old MacOS.~%Now you port it."))))) (defmacro os-cond (&rest clauses) #+abcl `(cond ,@clauses) #-abcl (loop* :for (test . body) :in clauses :when (eval test) :return `(progn ,@body))) (detect-os)) ;;;; Environment variables: getting them, and parsing them. (with-upgradability () (defun getenv (x) "Query the environment, as in C getenv. Beware: may return empty string if a variable is present but empty; use getenvp to return NIL in such a case." (declare (ignorable x)) #+(or abcl clasp clisp ecl xcl) (ext:getenv x) #+allegro (sys:getenv x) #+clozure (ccl:getenv x) #+cmu (unix:unix-getenv x) #+scl (cdr (assoc x ext:*environment-list* :test #'string=)) #+cormanlisp (let* ((buffer (ct:malloc 1)) (cname (ct:lisp-string-to-c-string x)) (needed-size (win:getenvironmentvariable cname buffer 0)) (buffer1 (ct:malloc (1+ needed-size)))) (prog1 (if (zerop (win:getenvironmentvariable cname buffer1 needed-size)) nil (ct:c-string-to-lisp-string buffer1)) (ct:free buffer) (ct:free buffer1))) #+gcl (system:getenv x) #+genera nil #+lispworks (lispworks:environment-variable x) #+mcl (ccl:with-cstrs ((name x)) (let ((value (_getenv name))) (unless (ccl:%null-ptr-p value) (ccl:%get-cstring value)))) #+mkcl (#.(or (find-symbol* 'getenv :si nil) (find-symbol* 'getenv :mk-ext nil)) x) #+sbcl (sb-ext:posix-getenv x) #-(or abcl allegro clasp clisp clozure cmu cormanlisp ecl gcl genera lispworks mcl mkcl sbcl scl xcl) (error "~S is not supported on your implementation" 'getenv)) (defsetf getenv (x) (val) "Set an environment variable." (declare (ignorable x val)) #+allegro `(setf (sys:getenv ,x) ,val) #+clisp `(system::setenv ,x ,val) #+clozure `(ccl:setenv ,x ,val) #+cmu `(unix:unix-setenv ,x ,val 1) #+ecl `(ext:setenv ,x ,val) #+lispworks `(hcl:setenv ,x ,val) #+mkcl `(mkcl:setenv ,x ,val) #+sbcl `(progn (require :sb-posix) (symbol-call :sb-posix :setenv ,x ,val 1)) #-(or allegro clisp clozure cmu ecl lispworks mkcl sbcl) '(error "~S ~S is not supported on your implementation" 'setf 'getenv)) (defun getenvp (x) "Predicate that is true if the named variable is present in the libc environment, then returning the non-empty string value of the variable" (let ((g (getenv x))) (and (not (emptyp g)) g)))) ;;;; implementation-identifier ;; ;; produce a string to identify current implementation. ;; Initially stolen from SLIME's SWANK, completely rewritten since. ;; We're back to runtime checking, for the sake of e.g. ABCL. (with-upgradability () (defun first-feature (feature-sets) "A helper for various feature detection functions" (dolist (x feature-sets) (multiple-value-bind (short long feature-expr) (if (consp x) (values (first x) (second x) (cons :or (rest x))) (values x x x)) (when (featurep feature-expr) (return (values short long)))))) (defun implementation-type () "The type of Lisp implementation used, as a short UIOP-standardized keyword" (first-feature '(:abcl (:acl :allegro) (:ccl :clozure) :clisp (:corman :cormanlisp) (:cmu :cmucl :cmu) :clasp :ecl :gcl (:lwpe :lispworks-personal-edition) (:lw :lispworks) :mcl :mkcl :sbcl :scl (:smbx :symbolics) :xcl))) (defvar *implementation-type* (implementation-type) "The type of Lisp implementation used, as a short UIOP-standardized keyword") (defun operating-system () "The operating system of the current host" (first-feature '(:cygwin (:win :windows :mswindows :win32 :mingw32) ;; try cygwin first! (:linux :linux :linux-target) ;; for GCL at least, must appear before :bsd (:macosx :macosx :darwin :darwin-target :apple) ; also before :bsd (:solaris :solaris :sunos) (:bsd :bsd :freebsd :netbsd :openbsd :dragonfly) :unix :genera))) (defun architecture () "The CPU architecture of the current host" (first-feature '((:x64 :x86-64 :x86_64 :x8664-target :amd64 (:and :word-size=64 :pc386)) (:x86 :x86 :i386 :i486 :i586 :i686 :pentium3 :pentium4 :pc386 :iapx386 :x8632-target) (:ppc64 :ppc64 :ppc64-target) (:ppc32 :ppc32 :ppc32-target :ppc :powerpc) :hppa64 :hppa :sparc64 (:sparc32 :sparc32 :sparc) :mipsel :mipseb :mips :alpha (:arm :arm :arm-target) :imach ;; Java comes last: if someone uses C via CFFI or otherwise JNA or JNI, ;; we may have to segregate the code still by architecture. (:java :java :java-1.4 :java-1.5 :java-1.6 :java-1.7)))) #+clozure (defun ccl-fasl-version () ;; the fasl version is target-dependent from CCL 1.8 on. (or (let ((s 'ccl::target-fasl-version)) (and (fboundp s) (funcall s))) (and (boundp 'ccl::fasl-version) (symbol-value 'ccl::fasl-version)) (error "Can't determine fasl version."))) (defun lisp-version-string () "return a string that identifies the current Lisp implementation version" (let ((s (lisp-implementation-version))) (car ; as opposed to OR, this idiom prevents some unreachable code warning (list #+allegro (format nil "~A~@[~A~]~@[~A~]~@[~A~]" excl::*common-lisp-version-number* ;; M means "modern", as opposed to ANSI-compatible mode (which I consider default) (and (eq excl:*current-case-mode* :case-sensitive-lower) "M") ;; Note if not using International ACL ;; see http://www.franz.com/support/documentation/8.1/doc/operators/excl/ics-target-case.htm (excl:ics-target-case (:-ics "8")) (and (member :smp *features*) "S")) #+armedbear (format nil "~a-fasl~a" s system::*fasl-version*) #+clisp (subseq s 0 (position #\space s)) ; strip build information (date, etc.) #+clozure (format nil "~d.~d-f~d" ; shorten for windows ccl::*openmcl-major-version* ccl::*openmcl-minor-version* (logand (ccl-fasl-version) #xFF)) #+cmu (substitute #\- #\/ s) #+scl (format nil "~A~A" s ;; ANSI upper case vs lower case. (ecase ext:*case-mode* (:upper "") (:lower "l"))) #+clasp (format nil "~A-~A" s (core:lisp-implementation-id)) #+(and ecl (not clasp)) (format nil "~A~@[-~A~]" s (let ((vcs-id (ext:lisp-implementation-vcs-id))) (subseq vcs-id 0 (min (length vcs-id) 8)))) #+gcl (subseq s (1+ (position #\space s))) #+genera (multiple-value-bind (major minor) (sct:get-system-version "System") (format nil "~D.~D" major minor)) #+mcl (subseq s 8) ; strip the leading "Version " s)))) (defun implementation-identifier () "Return a string that identifies the ABI of the current implementation, suitable for use as a directory name to segregate Lisp FASLs, C dynamic libraries, etc." (substitute-if #\_ #'(lambda (x) (find x " /:;&^\\|?<>(){}[]$#`'\"")) (format nil "~(~a~@{~@[-~a~]~}~)" (or (implementation-type) (lisp-implementation-type)) (or (lisp-version-string) (lisp-implementation-version)) (or (operating-system) (software-type)) (or (architecture) (machine-type)))))) ;;;; Other system information (with-upgradability () (defun hostname () "return the hostname of the current host" ;; Note: untested on RMCL #+(or abcl clasp clozure cmu ecl genera lispworks mcl mkcl sbcl scl xcl) (machine-instance) #+cormanlisp "localhost" ;; is there a better way? Does it matter? #+allegro (symbol-call :excl.osi :gethostname) #+clisp (first (split-string (machine-instance) :separator " ")) #+gcl (system:gethostname))) ;;; Current directory (with-upgradability () #+cmu (defun parse-unix-namestring* (unix-namestring) "variant of LISP::PARSE-UNIX-NAMESTRING that returns a pathname object" (multiple-value-bind (host device directory name type version) (lisp::parse-unix-namestring unix-namestring 0 (length unix-namestring)) (make-pathname :host (or host lisp::*unix-host*) :device device :directory directory :name name :type type :version version))) (defun getcwd () "Get the current working directory as per POSIX getcwd(3), as a pathname object" (or #+(or abcl genera xcl) (truename *default-pathname-defaults*) ;; d-p-d is canonical! #+allegro (excl::current-directory) #+clisp (ext:default-directory) #+clozure (ccl:current-directory) #+(or cmu scl) (#+cmu parse-unix-namestring* #+scl lisp::parse-unix-namestring (strcat (nth-value 1 (unix:unix-current-directory)) "/")) #+cormanlisp (pathname (pl::get-current-directory)) ;; Q: what type does it return? #+(or clasp ecl) (ext:getcwd) #+gcl (let ((*default-pathname-defaults* #p"")) (truename #p"")) #+lispworks (hcl:get-working-directory) #+mkcl (mk-ext:getcwd) #+sbcl (sb-ext:parse-native-namestring (sb-unix:posix-getcwd/)) #+xcl (extensions:current-directory) (error "getcwd not supported on your implementation"))) (defun chdir (x) "Change current directory, as per POSIX chdir(2), to a given pathname object" (if-let (x (pathname x)) #+(or abcl genera xcl) (setf *default-pathname-defaults* (truename x)) ;; d-p-d is canonical! #+allegro (excl:chdir x) #+clisp (ext:cd x) #+clozure (setf (ccl:current-directory) x) #+(or cmu scl) (unix:unix-chdir (ext:unix-namestring x)) #+cormanlisp (unless (zerop (win32::_chdir (namestring x))) (error "Could not set current directory to ~A" x)) #+(or clasp ecl) (ext:chdir x) #+gcl (system:chdir x) #+lispworks (hcl:change-directory x) #+mkcl (mk-ext:chdir x) #+sbcl (progn (require :sb-posix) (symbol-call :sb-posix :chdir (sb-ext:native-namestring x))) #-(or abcl allegro clasp clisp clozure cmu cormanlisp ecl gcl genera lispworks mkcl sbcl scl xcl) (error "chdir not supported on your implementation")))) ;;;; ----------------------------------------------------------------- ;;;; Windows shortcut support. Based on: ;;;; ;;;; Jesse Hager: The Windows Shortcut File Format. ;;;; http://www.wotsit.org/list.asp?fc=13 #-(or clisp genera) ; CLISP doesn't need it, and READ-SEQUENCE annoys old Genera that doesn't need it (with-upgradability () (defparameter *link-initial-dword* 76) (defparameter *link-guid* #(1 20 2 0 0 0 0 0 192 0 0 0 0 0 0 70)) (defun read-null-terminated-string (s) "Read a null-terminated string from an octet stream S" ;; note: doesn't play well with UNICODE (with-output-to-string (out) (loop :for code = (read-byte s) :until (zerop code) :do (write-char (code-char code) out)))) (defun read-little-endian (s &optional (bytes 4)) "Read a number in little-endian format from an byte (octet) stream S, the number having BYTES octets (defaulting to 4)." (loop :for i :from 0 :below bytes :sum (ash (read-byte s) (* 8 i)))) (defun parse-file-location-info (s) "helper to parse-windows-shortcut" (let ((start (file-position s)) (total-length (read-little-endian s)) (end-of-header (read-little-endian s)) (fli-flags (read-little-endian s)) (local-volume-offset (read-little-endian s)) (local-offset (read-little-endian s)) (network-volume-offset (read-little-endian s)) (remaining-offset (read-little-endian s))) (declare (ignore total-length end-of-header local-volume-offset)) (unless (zerop fli-flags) (cond ((logbitp 0 fli-flags) (file-position s (+ start local-offset))) ((logbitp 1 fli-flags) (file-position s (+ start network-volume-offset #x14)))) (strcat (read-null-terminated-string s) (progn (file-position s (+ start remaining-offset)) (read-null-terminated-string s)))))) (defun parse-windows-shortcut (pathname) "From a .lnk windows shortcut, extract the pathname linked to" ;; NB: doesn't do much checking & doesn't look like it will work well with UNICODE. (with-open-file (s pathname :element-type '(unsigned-byte 8)) (handler-case (when (and (= (read-little-endian s) *link-initial-dword*) (let ((header (make-array (length *link-guid*)))) (read-sequence header s) (equalp header *link-guid*))) (let ((flags (read-little-endian s))) (file-position s 76) ;skip rest of header (when (logbitp 0 flags) ;; skip shell item id list (let ((length (read-little-endian s 2))) (file-position s (+ length (file-position s))))) (cond ((logbitp 1 flags) (parse-file-location-info s)) (t (when (logbitp 2 flags) ;; skip description string (let ((length (read-little-endian s 2))) (file-position s (+ length (file-position s))))) (when (logbitp 3 flags) ;; finally, our pathname (let* ((length (read-little-endian s 2)) (buffer (make-array length))) (read-sequence buffer s) (map 'string #'code-char buffer))))))) (end-of-file (c) (declare (ignore c)) nil))))) ;;;; ------------------------------------------------------------------------- ;;;; Portability layer around Common Lisp pathnames ;; This layer allows for portable manipulation of pathname objects themselves, ;; which all is necessary prior to any access the filesystem or environment. (uiop/package:define-package :uiop/pathname (:nicknames :asdf/pathname) (:recycle :uiop/pathname :asdf/pathname :asdf) (:use :uiop/common-lisp :uiop/package :uiop/utility :uiop/os) (:export ;; Making and merging pathnames, portably #:normalize-pathname-directory-component #:denormalize-pathname-directory-component #:merge-pathname-directory-components #:*unspecific-pathname-type* #:make-pathname* #:make-pathname-component-logical #:make-pathname-logical #:merge-pathnames* #:nil-pathname #:*nil-pathname* #:with-pathname-defaults ;; Predicates #:pathname-equal #:logical-pathname-p #:physical-pathname-p #:physicalize-pathname #:absolute-pathname-p #:relative-pathname-p #:hidden-pathname-p #:file-pathname-p ;; Directories #:pathname-directory-pathname #:pathname-parent-directory-pathname #:directory-pathname-p #:ensure-directory-pathname ;; Parsing filenames #:component-name-to-pathname-components #:split-name-type #:parse-unix-namestring #:unix-namestring #:split-unix-namestring-directory-components ;; Absolute and relative pathnames #:subpathname #:subpathname* #:ensure-absolute-pathname #:pathname-root #:pathname-host-pathname #:subpathp #:enough-pathname #:with-enough-pathname #:call-with-enough-pathname ;; Checking constraints #:ensure-pathname ;; implemented in filesystem.lisp to accommodate for existence constraints ;; Wildcard pathnames #:*wild* #:*wild-file* #:*wild-directory* #:*wild-inferiors* #:*wild-path* #:wilden ;; Translate a pathname #:relativize-directory-component #:relativize-pathname-directory #:directory-separator-for-host #:directorize-pathname-host-device #:translate-pathname* #:*output-translation-function*)) (in-package :uiop/pathname) ;;; Normalizing pathnames across implementations (with-upgradability () (defun normalize-pathname-directory-component (directory) "Convert the DIRECTORY component from a format usable by the underlying implementation's MAKE-PATHNAME and other primitives to a CLHS-standard format that is a list and not a string." (cond #-(or cmu sbcl scl) ;; these implementations already normalize directory components. ((stringp directory) `(:absolute ,directory)) ((or (null directory) (and (consp directory) (member (first directory) '(:absolute :relative)))) directory) #+gcl ((consp directory) (cons :relative directory)) (t (error (compatfmt "~@") directory)))) (defun denormalize-pathname-directory-component (directory-component) "Convert the DIRECTORY-COMPONENT from a CLHS-standard format to a format usable by the underlying implementation's MAKE-PATHNAME and other primitives" directory-component) (defun merge-pathname-directory-components (specified defaults) "Helper for MERGE-PATHNAMES* that handles directory components" (let ((directory (normalize-pathname-directory-component specified))) (ecase (first directory) ((nil) defaults) (:absolute specified) (:relative (let ((defdir (normalize-pathname-directory-component defaults)) (reldir (cdr directory))) (cond ((null defdir) directory) ((not (eq :back (first reldir))) (append defdir reldir)) (t (loop :with defabs = (first defdir) :with defrev = (reverse (rest defdir)) :while (and (eq :back (car reldir)) (or (and (eq :absolute defabs) (null defrev)) (stringp (car defrev)))) :do (pop reldir) (pop defrev) :finally (return (cons defabs (append (reverse defrev) reldir))))))))))) ;; Giving :unspecific as :type argument to make-pathname is not portable. ;; See CLHS make-pathname and 19.2.2.2.3. ;; This will be :unspecific if supported, or NIL if not. (defparameter *unspecific-pathname-type* #+(or abcl allegro clozure cmu genera lispworks sbcl scl) :unspecific #+(or clasp clisp ecl mkcl gcl xcl #|These haven't been tested:|# cormanlisp mcl) nil "Unspecific type component to use with the underlying implementation's MAKE-PATHNAME") (defun make-pathname* (&rest keys &key (directory nil) host (device () #+allegro devicep) name type version defaults #+scl &allow-other-keys) "Takes arguments like CL:MAKE-PATHNAME in the CLHS, and tries hard to make a pathname that will actually behave as documented, despite the peculiarities of each implementation" ;; TODO: reimplement defaulting for MCL, whereby an explicit NIL should override the defaults. (declare (ignorable host device directory name type version defaults)) (apply 'make-pathname (append #+allegro (when (and devicep (null device)) `(:device :unspecific)) keys))) (defun make-pathname-component-logical (x) "Make a pathname component suitable for use in a logical-pathname" (typecase x ((eql :unspecific) nil) #+clisp (string (string-upcase x)) #+clisp (cons (mapcar 'make-pathname-component-logical x)) (t x))) (defun make-pathname-logical (pathname host) "Take a PATHNAME's directory, name, type and version components, and make a new pathname with corresponding components and specified logical HOST" (make-pathname* :host host :directory (make-pathname-component-logical (pathname-directory pathname)) :name (make-pathname-component-logical (pathname-name pathname)) :type (make-pathname-component-logical (pathname-type pathname)) :version (make-pathname-component-logical (pathname-version pathname)))) (defun merge-pathnames* (specified &optional (defaults *default-pathname-defaults*)) "MERGE-PATHNAMES* is like MERGE-PATHNAMES except that if the SPECIFIED pathname does not have an absolute directory, then the HOST and DEVICE both come from the DEFAULTS, whereas if the SPECIFIED pathname does have an absolute directory, then the HOST and DEVICE both come from the SPECIFIED pathname. This is what users want on a modern Unix or Windows operating system, unlike the MERGE-PATHNAMES behavior. Also, if either argument is NIL, then the other argument is returned unmodified; this is unlike MERGE-PATHNAMES which always merges with a pathname, by default *DEFAULT-PATHNAME-DEFAULTS*, which cannot be NIL." (when (null specified) (return-from merge-pathnames* defaults)) (when (null defaults) (return-from merge-pathnames* specified)) #+scl (ext:resolve-pathname specified defaults) #-scl (let* ((specified (pathname specified)) (defaults (pathname defaults)) (directory (normalize-pathname-directory-component (pathname-directory specified))) (name (or (pathname-name specified) (pathname-name defaults))) (type (or (pathname-type specified) (pathname-type defaults))) (version (or (pathname-version specified) (pathname-version defaults)))) (labels ((unspecific-handler (p) (if (typep p 'logical-pathname) #'make-pathname-component-logical #'identity))) (multiple-value-bind (host device directory unspecific-handler) (ecase (first directory) ((:absolute) (values (pathname-host specified) (pathname-device specified) directory (unspecific-handler specified))) ((nil :relative) (values (pathname-host defaults) (pathname-device defaults) (merge-pathname-directory-components directory (pathname-directory defaults)) (unspecific-handler defaults)))) (make-pathname* :host host :device device :directory directory :name (funcall unspecific-handler name) :type (funcall unspecific-handler type) :version (funcall unspecific-handler version)))))) (defun logical-pathname-p (x) "is X a logical-pathname?" (typep x 'logical-pathname)) (defun physical-pathname-p (x) "is X a pathname that is not a logical-pathname?" (and (pathnamep x) (not (logical-pathname-p x)))) (defun physicalize-pathname (x) "if X is a logical pathname, use translate-logical-pathname on it." ;; Ought to be the same as translate-logical-pathname, except the latter borks on CLISP (let ((p (when x (pathname x)))) (if (logical-pathname-p p) (translate-logical-pathname p) p))) (defun nil-pathname (&optional (defaults *default-pathname-defaults*)) "A pathname that is as neutral as possible for use as defaults when merging, making or parsing pathnames" ;; 19.2.2.2.1 says a NIL host can mean a default host; ;; see also "valid physical pathname host" in the CLHS glossary, that suggests ;; strings and lists of strings or :unspecific ;; But CMUCL decides to die on NIL. ;; MCL has issues with make-pathname, nil and defaulting (declare (ignorable defaults)) #.`(make-pathname* :directory nil :name nil :type nil :version nil :device (or #+(and mkcl unix) :unspecific) :host (or #+cmu lisp::*unix-host* #+(and mkcl unix) "localhost") #+scl ,@'(:scheme nil :scheme-specific-part nil :username nil :password nil :parameters nil :query nil :fragment nil) ;; the default shouldn't matter, but we really want something physical #-mcl ,@'(:defaults defaults))) (defvar *nil-pathname* (nil-pathname (physicalize-pathname (user-homedir-pathname))) "A pathname that is as neutral as possible for use as defaults when merging, making or parsing pathnames") (defmacro with-pathname-defaults ((&optional defaults) &body body) "Execute BODY in a context where the *DEFAULT-PATHNAME-DEFAULTS* is as specified, where leaving the defaults NIL or unspecified means a (NIL-PATHNAME), except on ABCL, Genera and XCL, where it remains unchanged for it doubles as current-directory." `(let ((*default-pathname-defaults* ,(or defaults #-(or abcl genera xcl) '*nil-pathname* #+(or abcl genera xcl) '*default-pathname-defaults*))) ,@body))) ;;; Some pathname predicates (with-upgradability () (defun pathname-equal (p1 p2) "Are the two pathnames P1 and P2 reasonably equal in the paths they denote?" (when (stringp p1) (setf p1 (pathname p1))) (when (stringp p2) (setf p2 (pathname p2))) (flet ((normalize-component (x) (unless (member x '(nil :unspecific :newest (:relative)) :test 'equal) x))) (macrolet ((=? (&rest accessors) (flet ((frob (x) (reduce 'list (cons 'normalize-component accessors) :initial-value x :from-end t))) `(equal ,(frob 'p1) ,(frob 'p2))))) (or (and (null p1) (null p2)) (and (pathnamep p1) (pathnamep p2) (and (=? pathname-host) #-(and mkcl unix) (=? pathname-device) (=? normalize-pathname-directory-component pathname-directory) (=? pathname-name) (=? pathname-type) #-mkcl (=? pathname-version))))))) (defun absolute-pathname-p (pathspec) "If PATHSPEC is a pathname or namestring object that parses as a pathname possessing an :ABSOLUTE directory component, return the (parsed) pathname. Otherwise return NIL" (and pathspec (typep pathspec '(or null pathname string)) (let ((pathname (pathname pathspec))) (and (eq :absolute (car (normalize-pathname-directory-component (pathname-directory pathname)))) pathname)))) (defun relative-pathname-p (pathspec) "If PATHSPEC is a pathname or namestring object that parses as a pathname possessing a :RELATIVE or NIL directory component, return the (parsed) pathname. Otherwise return NIL" (and pathspec (typep pathspec '(or null pathname string)) (let* ((pathname (pathname pathspec)) (directory (normalize-pathname-directory-component (pathname-directory pathname)))) (when (or (null directory) (eq :relative (car directory))) pathname)))) (defun hidden-pathname-p (pathname) "Return a boolean that is true if the pathname is hidden as per Unix style, i.e. its name starts with a dot." (and pathname (equal (first-char (pathname-name pathname)) #\.))) (defun file-pathname-p (pathname) "Does PATHNAME represent a file, i.e. has a non-null NAME component? Accepts NIL, a string (converted through PARSE-NAMESTRING) or a PATHNAME. Note that this does _not_ check to see that PATHNAME points to an actually-existing file. Returns the (parsed) PATHNAME when true" (when pathname (let* ((pathname (pathname pathname)) (name (pathname-name pathname))) (when (not (member name '(nil :unspecific "") :test 'equal)) pathname))))) ;;; Directory pathnames (with-upgradability () (defun pathname-directory-pathname (pathname) "Returns a new pathname with same HOST, DEVICE, DIRECTORY as PATHNAME, and NIL NAME, TYPE and VERSION components" (when pathname (make-pathname :name nil :type nil :version nil :defaults pathname))) (defun pathname-parent-directory-pathname (pathname) "Returns a new pathname that corresponds to the parent of the current pathname's directory, i.e. removing one level of depth in the DIRECTORY component. e.g. if pathname is Unix pathname /foo/bar/baz/file.type then return /foo/bar/" (when pathname (make-pathname* :name nil :type nil :version nil :directory (merge-pathname-directory-components '(:relative :back) (pathname-directory pathname)) :defaults pathname))) (defun directory-pathname-p (pathname) "Does PATHNAME represent a directory? A directory-pathname is a pathname _without_ a filename. The three ways that the filename components can be missing are for it to be NIL, :UNSPECIFIC or the empty string. Note that this does _not_ check to see that PATHNAME points to an actually-existing directory." (when pathname ;; I tried using Allegro's excl:file-directory-p, but this cannot be done, ;; because it rejects apparently legal pathnames as ;; ill-formed. [2014/02/10:rpg] (let ((pathname (pathname pathname))) (flet ((check-one (x) (member x '(nil :unspecific) :test 'equal))) (and (not (wild-pathname-p pathname)) (check-one (pathname-name pathname)) (check-one (pathname-type pathname)) t))))) (defun ensure-directory-pathname (pathspec &optional (on-error 'error)) "Converts the non-wild pathname designator PATHSPEC to directory form." (cond ((stringp pathspec) (ensure-directory-pathname (pathname pathspec))) ((not (pathnamep pathspec)) (call-function on-error (compatfmt "~@") pathspec)) ((wild-pathname-p pathspec) (call-function on-error (compatfmt "~@") pathspec)) ((directory-pathname-p pathspec) pathspec) (t (make-pathname* :directory (append (or (normalize-pathname-directory-component (pathname-directory pathspec)) (list :relative)) (list (file-namestring pathspec))) :name nil :type nil :version nil :defaults pathspec))))) ;;; Parsing filenames (with-upgradability () (defun split-unix-namestring-directory-components (unix-namestring &key ensure-directory dot-dot) "Splits the path string UNIX-NAMESTRING, returning four values: A flag that is either :absolute or :relative, indicating how the rest of the values are to be interpreted. A directory path --- a list of strings and keywords, suitable for use with MAKE-PATHNAME when prepended with the flag value. Directory components with an empty name or the name . are removed. Any directory named .. is read as DOT-DOT, or :BACK if it's NIL (not :UP). A last-component, either a file-namestring including type extension, or NIL in the case of a directory pathname. A flag that is true iff the unix-style-pathname was just a file-namestring without / path specification. ENSURE-DIRECTORY forces the namestring to be interpreted as a directory pathname: the third return value will be NIL, and final component of the namestring will be treated as part of the directory path. An empty string is thus read as meaning a pathname object with all fields nil. Note that colon characters #\: will NOT be interpreted as host specification. Absolute pathnames are only appropriate on Unix-style systems. The intention of this function is to support structured component names, e.g., \(:file \"foo/bar\"\), which will be unpacked to relative pathnames." (check-type unix-namestring string) (check-type dot-dot (member nil :back :up)) (if (and (not (find #\/ unix-namestring)) (not ensure-directory) (plusp (length unix-namestring))) (values :relative () unix-namestring t) (let* ((components (split-string unix-namestring :separator "/")) (last-comp (car (last components)))) (multiple-value-bind (relative components) (if (equal (first components) "") (if (equal (first-char unix-namestring) #\/) (values :absolute (cdr components)) (values :relative nil)) (values :relative components)) (setf components (remove-if #'(lambda (x) (member x '("" ".") :test #'equal)) components)) (setf components (substitute (or dot-dot :back) ".." components :test #'equal)) (cond ((equal last-comp "") (values relative components nil nil)) ; "" already removed from components (ensure-directory (values relative components nil nil)) (t (values relative (butlast components) last-comp nil))))))) (defun split-name-type (filename) "Split a filename into two values NAME and TYPE that are returned. We assume filename has no directory component. The last . if any separates name and type from from type, except that if there is only one . and it is in first position, the whole filename is the NAME with an empty type. NAME is always a string. For an empty type, *UNSPECIFIC-PATHNAME-TYPE* is returned." (check-type filename string) (assert (plusp (length filename))) (destructuring-bind (name &optional (type *unspecific-pathname-type*)) (split-string filename :max 2 :separator ".") (if (equal name "") (values filename *unspecific-pathname-type*) (values name type)))) (defun parse-unix-namestring (name &rest keys &key type defaults dot-dot ensure-directory &allow-other-keys) "Coerce NAME into a PATHNAME using standard Unix syntax. Unix syntax is used whether or not the underlying system is Unix; on such non-Unix systems it is reliably usable only for relative pathnames. This function is especially useful to manipulate relative pathnames portably, where it is of crucial to possess a portable pathname syntax independent of the underlying OS. This is what PARSE-UNIX-NAMESTRING provides, and why we use it in ASDF. When given a PATHNAME object, just return it untouched. When given NIL, just return NIL. When given a non-null SYMBOL, first downcase its name and treat it as a string. When given a STRING, portably decompose it into a pathname as below. #\\/ separates directory components. The last #\\/-separated substring is interpreted as follows: 1- If TYPE is :DIRECTORY or ENSURE-DIRECTORY is true, the string is made the last directory component, and NAME and TYPE are NIL. if the string is empty, it's the empty pathname with all slots NIL. 2- If TYPE is NIL, the substring is a file-namestring, and its NAME and TYPE are separated by SPLIT-NAME-TYPE. 3- If TYPE is a string, it is the given TYPE, and the whole string is the NAME. Directory components with an empty name or the name \".\" are removed. Any directory named \"..\" is read as DOT-DOT, which must be one of :BACK or :UP and defaults to :BACK. HOST, DEVICE and VERSION components are taken from DEFAULTS, which itself defaults to *NIL-PATHNAME*, also used if DEFAULTS is NIL. No host or device can be specified in the string itself, which makes it unsuitable for absolute pathnames outside Unix. For relative pathnames, these components (and hence the defaults) won't matter if you use MERGE-PATHNAMES* but will matter if you use MERGE-PATHNAMES, which is an important reason to always use MERGE-PATHNAMES*. Arbitrary keys are accepted, and the parse result is passed to ENSURE-PATHNAME with those keys, removing TYPE DEFAULTS and DOT-DOT. When you're manipulating pathnames that are supposed to make sense portably even though the OS may not be Unixish, we recommend you use :WANT-RELATIVE T to throw an error if the pathname is absolute" (block nil (check-type type (or null string (eql :directory))) (when ensure-directory (setf type :directory)) (etypecase name ((or null pathname) (return name)) (symbol (setf name (string-downcase name))) (string)) (multiple-value-bind (relative path filename file-only) (split-unix-namestring-directory-components name :dot-dot dot-dot :ensure-directory (eq type :directory)) (multiple-value-bind (name type) (cond ((or (eq type :directory) (null filename)) (values nil nil)) (type (values filename type)) (t (split-name-type filename))) (apply 'ensure-pathname (make-pathname* :directory (unless file-only (cons relative path)) :name name :type type :defaults (or #-mcl defaults *nil-pathname*)) (remove-plist-keys '(:type :dot-dot :defaults) keys)))))) (defun unix-namestring (pathname) "Given a non-wild PATHNAME, return a Unix-style namestring for it. If the PATHNAME is NIL or a STRING, return it unchanged. This only considers the DIRECTORY, NAME and TYPE components of the pathname. This is a portable solution for representing relative pathnames, But unless you are running on a Unix system, it is not a general solution to representing native pathnames. An error is signaled if the argument is not NULL, a STRING or a PATHNAME, or if it is a PATHNAME but some of its components are not recognized." (etypecase pathname ((or null string) pathname) (pathname (with-output-to-string (s) (flet ((err () #+lispworks (describe pathname) (error "Not a valid unix-namestring ~S" pathname))) (let* ((dir (normalize-pathname-directory-component (pathname-directory pathname))) (name (pathname-name pathname)) (name (and (not (eq name :unspecific)) name)) (type (pathname-type pathname)) (type (and (not (eq type :unspecific)) type))) (cond ((member dir '(nil :unspecific))) ((eq dir '(:relative)) (princ "./" s)) ((consp dir) (destructuring-bind (relabs &rest dirs) dir (or (member relabs '(:relative :absolute)) (err)) (when (eq relabs :absolute) (princ #\/ s)) (loop :for x :in dirs :do (cond ((member x '(:back :up)) (princ "../" s)) ((equal x "") (err)) ;;((member x '("." "..") :test 'equal) (err)) ((stringp x) (format s "~A/" x)) (t (err)))))) (t (err))) (cond (name (unless (and (stringp name) (or (null type) (stringp type))) (err)) (format s "~A~@[.~A~]" name type)) (t (or (null type) (err))))))))))) ;;; Absolute and relative pathnames (with-upgradability () (defun subpathname (pathname subpath &key type) "This function takes a PATHNAME and a SUBPATH and a TYPE. If SUBPATH is already a PATHNAME object (not namestring), and is an absolute pathname at that, it is returned unchanged; otherwise, SUBPATH is turned into a relative pathname with given TYPE as per PARSE-UNIX-NAMESTRING with :WANT-RELATIVE T :TYPE TYPE, then it is merged with the PATHNAME-DIRECTORY-PATHNAME of PATHNAME." (or (and (pathnamep subpath) (absolute-pathname-p subpath)) (merge-pathnames* (parse-unix-namestring subpath :type type :want-relative t) (pathname-directory-pathname pathname)))) (defun subpathname* (pathname subpath &key type) "returns NIL if the base pathname is NIL, otherwise like SUBPATHNAME." (and pathname (subpathname (ensure-directory-pathname pathname) subpath :type type))) (defun pathname-root (pathname) "return the root directory for the host and device of given PATHNAME" (make-pathname* :directory '(:absolute) :name nil :type nil :version nil :defaults pathname ;; host device, and on scl, *some* ;; scheme-specific parts: port username password, not others: . #.(or #+scl '(:parameters nil :query nil :fragment nil)))) (defun pathname-host-pathname (pathname) "return a pathname with the same host as given PATHNAME, and all other fields NIL" (make-pathname* :directory nil :name nil :type nil :version nil :device nil :defaults pathname ;; host device, and on scl, *some* ;; scheme-specific parts: port username password, not others: . #.(or #+scl '(:parameters nil :query nil :fragment nil)))) (defun ensure-absolute-pathname (path &optional defaults (on-error 'error)) "Given a pathname designator PATH, return an absolute pathname as specified by PATH considering the DEFAULTS, or, if not possible, use CALL-FUNCTION on the specified ON-ERROR behavior, with a format control-string and other arguments as arguments" (cond ((absolute-pathname-p path)) ((stringp path) (ensure-absolute-pathname (pathname path) defaults on-error)) ((not (pathnamep path)) (call-function on-error "not a valid pathname designator ~S" path)) ((let ((default-pathname (if (pathnamep defaults) defaults (call-function defaults)))) (or (if (absolute-pathname-p default-pathname) (absolute-pathname-p (merge-pathnames* path default-pathname)) (call-function on-error "Default pathname ~S is not an absolute pathname" default-pathname)) (call-function on-error "Failed to merge ~S with ~S into an absolute pathname" path default-pathname)))) (t (call-function on-error "Cannot ensure ~S is evaluated as an absolute pathname with defaults ~S" path defaults)))) (defun subpathp (maybe-subpath base-pathname) "if MAYBE-SUBPATH is a pathname that is under BASE-PATHNAME, return a pathname object that when used with MERGE-PATHNAMES* with defaults BASE-PATHNAME, returns MAYBE-SUBPATH." (and (pathnamep maybe-subpath) (pathnamep base-pathname) (absolute-pathname-p maybe-subpath) (absolute-pathname-p base-pathname) (directory-pathname-p base-pathname) (not (wild-pathname-p base-pathname)) (pathname-equal (pathname-root maybe-subpath) (pathname-root base-pathname)) (with-pathname-defaults (*nil-pathname*) (let ((enough (enough-namestring maybe-subpath base-pathname))) (and (relative-pathname-p enough) (pathname enough)))))) (defun enough-pathname (maybe-subpath base-pathname) "if MAYBE-SUBPATH is a pathname that is under BASE-PATHNAME, return a pathname object that when used with MERGE-PATHNAMES* with defaults BASE-PATHNAME, returns MAYBE-SUBPATH." (let ((sub (when maybe-subpath (pathname maybe-subpath))) (base (when base-pathname (ensure-absolute-pathname (pathname base-pathname))))) (or (and base (subpathp sub base)) sub))) (defun call-with-enough-pathname (maybe-subpath defaults-pathname thunk) "In a context where *DEFAULT-PATHNAME-DEFAULTS* is bound to DEFAULTS-PATHNAME (if not null, or else to its current value), call THUNK with ENOUGH-PATHNAME for MAYBE-SUBPATH given DEFAULTS-PATHNAME as a base pathname." (let ((enough (enough-pathname maybe-subpath defaults-pathname)) (*default-pathname-defaults* (or defaults-pathname *default-pathname-defaults*))) (funcall thunk enough))) (defmacro with-enough-pathname ((pathname-var &key (pathname pathname-var) (defaults *default-pathname-defaults*)) &body body) "Shorthand syntax for CALL-WITH-ENOUGH-PATHNAME" `(call-with-enough-pathname ,pathname ,defaults #'(lambda (,pathname-var) ,@body)))) ;;; Wildcard pathnames (with-upgradability () (defparameter *wild* (or #+cormanlisp "*" :wild) "Wild component for use with MAKE-PATHNAME") (defparameter *wild-directory-component* (or :wild) "Wild directory component for use with MAKE-PATHNAME") (defparameter *wild-inferiors-component* (or :wild-inferiors) "Wild-inferiors directory component for use with MAKE-PATHNAME") (defparameter *wild-file* (make-pathname :directory nil :name *wild* :type *wild* :version (or #-(or allegro abcl xcl) *wild*)) "A pathname object with wildcards for matching any file in a given directory") (defparameter *wild-directory* (make-pathname* :directory `(:relative ,*wild-directory-component*) :name nil :type nil :version nil) "A pathname object with wildcards for matching any subdirectory") (defparameter *wild-inferiors* (make-pathname* :directory `(:relative ,*wild-inferiors-component*) :name nil :type nil :version nil) "A pathname object with wildcards for matching any recursive subdirectory") (defparameter *wild-path* (merge-pathnames* *wild-file* *wild-inferiors*) "A pathname object with wildcards for matching any file in any recursive subdirectory") (defun wilden (path) "From a pathname, return a wildcard pathname matching any file in any subdirectory of given pathname's directory" (merge-pathnames* *wild-path* path))) ;;; Translate a pathname (with-upgradability () (defun relativize-directory-component (directory-component) "Given the DIRECTORY-COMPONENT of a pathname, return an otherwise similar relative directory component" (let ((directory (normalize-pathname-directory-component directory-component))) (cond ((stringp directory) (list :relative directory)) ((eq (car directory) :absolute) (cons :relative (cdr directory))) (t directory)))) (defun relativize-pathname-directory (pathspec) "Given a PATHNAME, return a relative pathname with otherwise the same components" (let ((p (pathname pathspec))) (make-pathname* :directory (relativize-directory-component (pathname-directory p)) :defaults p))) (defun directory-separator-for-host (&optional (pathname *default-pathname-defaults*)) "Given a PATHNAME, return the character used to delimit directory names on this host and device." (let ((foo (make-pathname* :directory '(:absolute "FOO") :defaults pathname))) (last-char (namestring foo)))) #-scl (defun directorize-pathname-host-device (pathname) "Given a PATHNAME, return a pathname that has representations of its HOST and DEVICE components added to its DIRECTORY component. This is useful for output translations." (os-cond ((os-unix-p) (when (physical-pathname-p pathname) (return-from directorize-pathname-host-device pathname)))) (let* ((root (pathname-root pathname)) (wild-root (wilden root)) (absolute-pathname (merge-pathnames* pathname root)) (separator (directory-separator-for-host root)) (root-namestring (namestring root)) (root-string (substitute-if #\/ #'(lambda (x) (or (eql x #\:) (eql x separator))) root-namestring))) (multiple-value-bind (relative path filename) (split-unix-namestring-directory-components root-string :ensure-directory t) (declare (ignore relative filename)) (let ((new-base (make-pathname* :defaults root :directory `(:absolute ,@path)))) (translate-pathname absolute-pathname wild-root (wilden new-base)))))) #+scl (defun directorize-pathname-host-device (pathname) (let ((scheme (ext:pathname-scheme pathname)) (host (pathname-host pathname)) (port (ext:pathname-port pathname)) (directory (pathname-directory pathname))) (flet ((specificp (x) (and x (not (eq x :unspecific))))) (if (or (specificp port) (and (specificp host) (plusp (length host))) (specificp scheme)) (let ((prefix "")) (when (specificp port) (setf prefix (format nil ":~D" port))) (when (and (specificp host) (plusp (length host))) (setf prefix (strcat host prefix))) (setf prefix (strcat ":" prefix)) (when (specificp scheme) (setf prefix (strcat scheme prefix))) (assert (and directory (eq (first directory) :absolute))) (make-pathname* :directory `(:absolute ,prefix ,@(rest directory)) :defaults pathname))) pathname))) (defun* (translate-pathname*) (path absolute-source destination &optional root source) "A wrapper around TRANSLATE-PATHNAME to be used by the ASDF output-translations facility. PATH is the pathname to be translated. ABSOLUTE-SOURCE is an absolute pathname to use as source for translate-pathname, DESTINATION is either a function, to be called with PATH and ABSOLUTE-SOURCE, or a relative pathname, to be merged with ROOT and used as destination for translate-pathname or an absolute pathname, to be used as destination for translate-pathname. In that last case, if ROOT is non-NIL, PATH is first transformated by DIRECTORIZE-PATHNAME-HOST-DEVICE." (declare (ignore source)) (cond ((functionp destination) (funcall destination path absolute-source)) ((eq destination t) path) ((not (pathnamep destination)) (error "Invalid destination")) ((not (absolute-pathname-p destination)) (translate-pathname path absolute-source (merge-pathnames* destination root))) (root (translate-pathname (directorize-pathname-host-device path) absolute-source destination)) (t (translate-pathname path absolute-source destination)))) (defvar *output-translation-function* 'identity "Hook for output translations. This function needs to be idempotent, so that actions can work whether their inputs were translated or not, which they will be if we are composing operations. e.g. if some create-lisp-op creates a lisp file from some higher-level input, you need to still be able to use compile-op on that lisp file.")) ;;;; ------------------------------------------------------------------------- ;;;; Portability layer around Common Lisp filesystem access (uiop/package:define-package :uiop/filesystem (:nicknames :asdf/filesystem) (:recycle :uiop/filesystem :asdf/pathname :asdf) (:use :uiop/common-lisp :uiop/package :uiop/utility :uiop/os :uiop/pathname) (:export ;; Native namestrings #:native-namestring #:parse-native-namestring ;; Probing the filesystem #:truename* #:safe-file-write-date #:probe-file* #:directory-exists-p #:file-exists-p #:directory* #:filter-logical-directory-results #:directory-files #:subdirectories #:collect-sub*directories ;; Resolving symlinks somewhat #:truenamize #:resolve-symlinks #:*resolve-symlinks* #:resolve-symlinks* ;; merging with cwd #:get-pathname-defaults #:call-with-current-directory #:with-current-directory ;; Environment pathnames #:inter-directory-separator #:split-native-pathnames-string #:getenv-pathname #:getenv-pathnames #:getenv-absolute-directory #:getenv-absolute-directories #:lisp-implementation-directory #:lisp-implementation-pathname-p ;; Simple filesystem operations #:ensure-all-directories-exist #:rename-file-overwriting-target #:delete-file-if-exists #:delete-empty-directory #:delete-directory-tree)) (in-package :uiop/filesystem) ;;; Native namestrings, as seen by the operating system calls rather than Lisp (with-upgradability () (defun native-namestring (x) "From a non-wildcard CL pathname, a return namestring suitable for passing to the operating system" (when x (let ((p (pathname x))) #+clozure (with-pathname-defaults () (ccl:native-translated-namestring p)) ; see ccl bug 978 #+(or cmu scl) (ext:unix-namestring p nil) #+sbcl (sb-ext:native-namestring p) #-(or clozure cmu sbcl scl) (os-cond ((os-unix-p) (unix-namestring p)) (t (namestring p)))))) (defun parse-native-namestring (string &rest constraints &key ensure-directory &allow-other-keys) "From a native namestring suitable for use by the operating system, return a CL pathname satisfying all the specified constraints as per ENSURE-PATHNAME" (check-type string (or string null)) (let* ((pathname (when string (with-pathname-defaults () #+clozure (ccl:native-to-pathname string) #+sbcl (sb-ext:parse-native-namestring string) #-(or clozure sbcl) (os-cond ((os-unix-p) (parse-unix-namestring string :ensure-directory ensure-directory)) (t (parse-namestring string)))))) (pathname (if ensure-directory (and pathname (ensure-directory-pathname pathname)) pathname))) (apply 'ensure-pathname pathname constraints)))) ;;; Probing the filesystem (with-upgradability () (defun truename* (p) "Nicer variant of TRUENAME that plays well with NIL, avoids logical pathname contexts, and tries both files and directories" (when p (when (stringp p) (setf p (with-pathname-defaults () (parse-namestring p)))) (values (or (ignore-errors (truename p)) ;; this is here because trying to find the truename of a directory pathname WITHOUT supplying ;; a trailing directory separator, causes an error on some lisps. #+(or clisp gcl) (if-let (d (ensure-directory-pathname p)) (ignore-errors (truename d))))))) (defun safe-file-write-date (pathname) "Safe variant of FILE-WRITE-DATE that may return NIL rather than raise an error." ;; If FILE-WRITE-DATE returns NIL, it's possible that ;; the user or some other agent has deleted an input file. ;; Also, generated files will not exist at the time planning is done ;; and calls compute-action-stamp which calls safe-file-write-date. ;; So it is very possible that we can't get a valid file-write-date, ;; and we can survive and we will continue the planning ;; as if the file were very old. ;; (or should we treat the case in a different, special way?) (and pathname (handler-case (file-write-date (physicalize-pathname pathname)) (file-error () nil)))) (defun probe-file* (p &key truename) "when given a pathname P (designated by a string as per PARSE-NAMESTRING), probes the filesystem for a file or directory with given pathname. If it exists, return its truename is ENSURE-PATHNAME is true, or the original (parsed) pathname if it is false (the default)." (values (ignore-errors (setf p (funcall 'ensure-pathname p :namestring :lisp :ensure-physical t :ensure-absolute t :defaults 'get-pathname-defaults :want-non-wild t :on-error nil)) (when p #+allegro (probe-file p :follow-symlinks truename) #+gcl (if truename (truename* p) (let ((kind (car (si::stat p)))) (when (eq kind :link) (setf kind (ignore-errors (car (si::stat (truename* p)))))) (ecase kind ((nil) nil) ((:file :link) (cond ((file-pathname-p p) p) ((directory-pathname-p p) (subpathname p (car (last (pathname-directory p))))))) (:directory (ensure-directory-pathname p))))) #+clisp #.(let* ((fs (or #-os-windows (find-symbol* '#:file-stat :posix nil))) (pp (find-symbol* '#:probe-pathname :ext nil))) `(if truename ,(if pp `(values (,pp p)) '(or (truename* p) (truename* (ignore-errors (ensure-directory-pathname p))))) ,(cond (fs `(and (,fs p) p)) (pp `(nth-value 1 (,pp p))) (t '(or (and (truename* p) p) (if-let (d (ensure-directory-pathname p)) (and (truename* d) d))))))) #-(or allegro clisp gcl) (if truename (probe-file p) (and #+(or cmu scl) (unix:unix-stat (ext:unix-namestring p)) #+(and lispworks unix) (system:get-file-stat p) #+sbcl (sb-unix:unix-stat (sb-ext:native-namestring p)) #-(or cmu (and lispworks unix) sbcl scl) (file-write-date p) p)))))) (defun directory-exists-p (x) "Is X the name of a directory that exists on the filesystem?" #+allegro (excl:probe-directory x) #+clisp (handler-case (ext:probe-directory x) (sys::simple-file-error () nil)) #-(or allegro clisp) (let ((p (probe-file* x :truename t))) (and (directory-pathname-p p) p))) (defun file-exists-p (x) "Is X the name of a file that exists on the filesystem?" (let ((p (probe-file* x :truename t))) (and (file-pathname-p p) p))) (defun directory* (pathname-spec &rest keys &key &allow-other-keys) "Return a list of the entries in a directory by calling DIRECTORY. Try to override the defaults to not resolving symlinks, if implementation allows." (apply 'directory pathname-spec (append keys '#.(or #+allegro '(:directories-are-files nil :follow-symbolic-links nil) #+(or clozure digitool) '(:follow-links nil) #+clisp '(:circle t :if-does-not-exist :ignore) #+(or cmu scl) '(:follow-links nil :truenamep nil) #+lispworks '(:link-transparency nil) #+sbcl (when (find-symbol* :resolve-symlinks '#:sb-impl nil) '(:resolve-symlinks nil)))))) (defun filter-logical-directory-results (directory entries merger) "Given ENTRIES in a DIRECTORY, remove if the directory is logical the entries which are physical yet when transformed by MERGER have a different TRUENAME. This function is used as a helper to DIRECTORY-FILES to avoid invalid entries when using logical-pathnames." (remove-duplicates ;; on CLISP, querying ~/ will return duplicates (if (logical-pathname-p directory) ;; Try hard to not resolve logical-pathname into physical pathnames; ;; otherwise logical-pathname users/lovers will be disappointed. ;; If directory* could use some implementation-dependent magic, ;; we will have logical pathnames already; otherwise, ;; we only keep pathnames for which specifying the name and ;; translating the LPN commute. (loop :for f :in entries :for p = (or (and (logical-pathname-p f) f) (let* ((u (ignore-errors (call-function merger f)))) ;; The first u avoids a cumbersome (truename u) error. ;; At this point f should already be a truename, ;; but isn't quite in CLISP, for it doesn't have :version :newest (and u (equal (truename* u) (truename* f)) u))) :when p :collect p) entries) :test 'pathname-equal)) (defun directory-files (directory &optional (pattern *wild-file*)) "Return a list of the files in a directory according to the PATTERN. Subdirectories should NOT be returned. PATTERN defaults to a pattern carefully chosen based on the implementation; override the default at your own risk. DIRECTORY-FILES tries NOT to resolve symlinks if the implementation permits this, but the behavior in presence of symlinks is not portable. Use IOlib to handle such situations." (let ((dir (pathname directory))) (when (logical-pathname-p dir) ;; Because of the filtering we do below, ;; logical pathnames have restrictions on wild patterns. ;; Not that the results are very portable when you use these patterns on physical pathnames. (when (wild-pathname-p dir) (error "Invalid wild pattern in logical directory ~S" directory)) (unless (member (pathname-directory pattern) '(() (:relative)) :test 'equal) (error "Invalid file pattern ~S for logical directory ~S" pattern directory)) (setf pattern (make-pathname-logical pattern (pathname-host dir)))) (let* ((pat (merge-pathnames* pattern dir)) (entries (append (ignore-errors (directory* pat)) #+(or clisp gcl) (when (equal :wild (pathname-type pattern)) (ignore-errors (directory* (make-pathname :type nil :defaults pat))))))) (remove-if 'directory-pathname-p (filter-logical-directory-results directory entries #'(lambda (f) (make-pathname :defaults dir :name (make-pathname-component-logical (pathname-name f)) :type (make-pathname-component-logical (pathname-type f)) :version (make-pathname-component-logical (pathname-version f))))))))) (defun subdirectories (directory) "Given a DIRECTORY pathname designator, return a list of the subdirectories under it. The behavior in presence of symlinks is not portable. Use IOlib to handle such situations." (let* ((directory (ensure-directory-pathname directory)) #-(or abcl cormanlisp genera xcl) (wild (merge-pathnames* #-(or abcl allegro cmu lispworks sbcl scl xcl) *wild-directory* #+(or abcl allegro cmu lispworks sbcl scl xcl) "*.*" directory)) (dirs #-(or abcl cormanlisp genera xcl) (ignore-errors (directory* wild . #.(or #+clozure '(:directories t :files nil) #+mcl '(:directories t)))) #+(or abcl xcl) (system:list-directory directory) #+cormanlisp (cl::directory-subdirs directory) #+genera (fs:directory-list directory)) #+(or abcl allegro cmu genera lispworks sbcl scl xcl) (dirs (loop :for x :in dirs :for d = #+(or abcl xcl) (extensions:probe-directory x) #+allegro (excl:probe-directory x) #+(or cmu sbcl scl) (directory-pathname-p x) #+genera (getf (cdr x) :directory) #+lispworks (lw:file-directory-p x) :when d :collect #+(or abcl allegro xcl) d #+genera (ensure-directory-pathname (first x)) #+(or cmu lispworks sbcl scl) x))) (filter-logical-directory-results directory dirs (let ((prefix (or (normalize-pathname-directory-component (pathname-directory directory)) '(:absolute)))) ; because allegro returns NIL for #p"FOO:" #'(lambda (d) (let ((dir (normalize-pathname-directory-component (pathname-directory d)))) (and (consp dir) (consp (cdr dir)) (make-pathname :defaults directory :name nil :type nil :version nil :directory (append prefix (make-pathname-component-logical (last dir))))))))))) (defun collect-sub*directories (directory collectp recursep collector) "Given a DIRECTORY, when COLLECTP returns true when CALL-FUNCTION'ed with the directory, call-function the COLLECTOR function designator on the directory, and recurse each of its subdirectories on which the RECURSEP returns true when CALL-FUNCTION'ed with them. This function will thus let you traverse a filesystem hierarchy, superseding the functionality of CL-FAD:WALK-DIRECTORY. The behavior in presence of symlinks is not portable. Use IOlib to handle such situations." (when (call-function collectp directory) (call-function collector directory) (dolist (subdir (subdirectories directory)) (when (call-function recursep subdir) (collect-sub*directories subdir collectp recursep collector)))))) ;;; Resolving symlinks somewhat (with-upgradability () (defun truenamize (pathname) "Resolve as much of a pathname as possible" (block nil (when (typep pathname '(or null logical-pathname)) (return pathname)) (let ((p pathname)) (unless (absolute-pathname-p p) (setf p (or (absolute-pathname-p (ensure-absolute-pathname p 'get-pathname-defaults nil)) (return p)))) (when (logical-pathname-p p) (return p)) (let ((found (probe-file* p :truename t))) (when found (return found))) (let* ((directory (normalize-pathname-directory-component (pathname-directory p))) (up-components (reverse (rest directory))) (down-components ())) (assert (eq :absolute (first directory))) (loop :while up-components :do (if-let (parent (ignore-errors (probe-file* (make-pathname* :directory `(:absolute ,@(reverse up-components)) :name nil :type nil :version nil :defaults p)))) (if-let (simplified (ignore-errors (merge-pathnames* (make-pathname* :directory `(:relative ,@down-components) :defaults p) (ensure-directory-pathname parent)))) (return simplified))) (push (pop up-components) down-components) :finally (return p)))))) (defun resolve-symlinks (path) "Do a best effort at resolving symlinks in PATH, returning a partially or totally resolved PATH." #-allegro (truenamize path) #+allegro (if (physical-pathname-p path) (or (ignore-errors (excl:pathname-resolve-symbolic-links path)) path) path)) (defvar *resolve-symlinks* t "Determine whether or not ASDF resolves symlinks when defining systems. Defaults to T.") (defun resolve-symlinks* (path) "RESOLVE-SYMLINKS in PATH iff *RESOLVE-SYMLINKS* is T (the default)." (if *resolve-symlinks* (and path (resolve-symlinks path)) path))) ;;; Check pathname constraints (with-upgradability () (defun ensure-pathname (pathname &key on-error defaults type dot-dot namestring empty-is-nil want-pathname want-logical want-physical ensure-physical want-relative want-absolute ensure-absolute ensure-subpath want-non-wild want-wild wilden want-file want-directory ensure-directory want-existing ensure-directories-exist truename resolve-symlinks truenamize &aux (p pathname)) ;; mutable working copy, preserve original "Coerces its argument into a PATHNAME, optionally doing some transformations and checking specified constraints. If the argument is NIL, then NIL is returned unless the WANT-PATHNAME constraint is specified. If the argument is a STRING, it is first converted to a pathname via PARSE-UNIX-NAMESTRING, PARSE-NAMESTRING or PARSE-NATIVE-NAMESTRING respectively depending on the NAMESTRING argument being :UNIX, :LISP or :NATIVE respectively, or else by using CALL-FUNCTION on the NAMESTRING argument; if :UNIX is specified (or NIL, the default, which specifies the same thing), then PARSE-UNIX-NAMESTRING it is called with the keywords DEFAULTS TYPE DOT-DOT ENSURE-DIRECTORY WANT-RELATIVE, and the result is optionally merged into the DEFAULTS if ENSURE-ABSOLUTE is true. The pathname passed or resulting from parsing the string is then subjected to all the checks and transformations below are run. Each non-nil constraint argument can be one of the symbols T, ERROR, CERROR or IGNORE. The boolean T is an alias for ERROR. ERROR means that an error will be raised if the constraint is not satisfied. CERROR means that an continuable error will be raised if the constraint is not satisfied. IGNORE means just return NIL instead of the pathname. The ON-ERROR argument, if not NIL, is a function designator (as per CALL-FUNCTION) that will be called with the the following arguments: a generic format string for ensure pathname, the pathname, the keyword argument corresponding to the failed check or transformation, a format string for the reason ENSURE-PATHNAME failed, and a list with arguments to that format string. If ON-ERROR is NIL, ERROR is used instead, which does the right thing. You could also pass (CERROR \"CONTINUE DESPITE FAILED CHECK\"). The transformations and constraint checks are done in this order, which is also the order in the lambda-list: EMPTY-IS-NIL returns NIL if the argument is an empty string. WANT-PATHNAME checks that pathname (after parsing if needed) is not null. Otherwise, if the pathname is NIL, ensure-pathname returns NIL. WANT-LOGICAL checks that pathname is a LOGICAL-PATHNAME WANT-PHYSICAL checks that pathname is not a LOGICAL-PATHNAME ENSURE-PHYSICAL ensures that pathname is physical via TRANSLATE-LOGICAL-PATHNAME WANT-RELATIVE checks that pathname has a relative directory component WANT-ABSOLUTE checks that pathname does have an absolute directory component ENSURE-ABSOLUTE merges with the DEFAULTS, then checks again that the result absolute is an absolute pathname indeed. ENSURE-SUBPATH checks that the pathname is a subpath of the DEFAULTS. WANT-FILE checks that pathname has a non-nil FILE component WANT-DIRECTORY checks that pathname has nil FILE and TYPE components ENSURE-DIRECTORY uses ENSURE-DIRECTORY-PATHNAME to interpret any file and type components as being actually a last directory component. WANT-NON-WILD checks that pathname is not a wild pathname WANT-WILD checks that pathname is a wild pathname WILDEN merges the pathname with **/*.*.* if it is not wild WANT-EXISTING checks that a file (or directory) exists with that pathname. ENSURE-DIRECTORIES-EXIST creates any parent directory with ENSURE-DIRECTORIES-EXIST. TRUENAME replaces the pathname by its truename, or errors if not possible. RESOLVE-SYMLINKS replaces the pathname by a variant with symlinks resolved by RESOLVE-SYMLINKS. TRUENAMIZE uses TRUENAMIZE to resolve as many symlinks as possible." (block nil (flet ((report-error (keyword description &rest arguments) (call-function (or on-error 'error) "Invalid pathname ~S: ~*~?" pathname keyword description arguments))) (macrolet ((err (constraint &rest arguments) `(report-error ',(intern* constraint :keyword) ,@arguments)) (check (constraint condition &rest arguments) `(when ,constraint (unless ,condition (err ,constraint ,@arguments)))) (transform (transform condition expr) `(when ,transform (,@(if condition `(when ,condition) '(progn)) (setf p ,expr))))) (etypecase p ((or null pathname)) (string (when (and (emptyp p) empty-is-nil) (return-from ensure-pathname nil)) (setf p (case namestring ((:unix nil) (parse-unix-namestring p :defaults defaults :type type :dot-dot dot-dot :ensure-directory ensure-directory :want-relative want-relative)) ((:native) (parse-native-namestring p)) ((:lisp) (parse-namestring p)) (t (call-function namestring p)))))) (etypecase p (pathname) (null (check want-pathname (pathnamep p) "Expected a pathname, not NIL") (return nil))) (check want-logical (logical-pathname-p p) "Expected a logical pathname") (check want-physical (physical-pathname-p p) "Expected a physical pathname") (transform ensure-physical () (physicalize-pathname p)) (check ensure-physical (physical-pathname-p p) "Could not translate to a physical pathname") (check want-relative (relative-pathname-p p) "Expected a relative pathname") (check want-absolute (absolute-pathname-p p) "Expected an absolute pathname") (transform ensure-absolute (not (absolute-pathname-p p)) (ensure-absolute-pathname p defaults (list #'report-error :ensure-absolute "~@?"))) (check ensure-absolute (absolute-pathname-p p) "Could not make into an absolute pathname even after merging with ~S" defaults) (check ensure-subpath (absolute-pathname-p defaults) "cannot be checked to be a subpath of non-absolute pathname ~S" defaults) (check ensure-subpath (subpathp p defaults) "is not a sub pathname of ~S" defaults) (check want-file (file-pathname-p p) "Expected a file pathname") (check want-directory (directory-pathname-p p) "Expected a directory pathname") (transform ensure-directory (not (directory-pathname-p p)) (ensure-directory-pathname p)) (check want-non-wild (not (wild-pathname-p p)) "Expected a non-wildcard pathname") (check want-wild (wild-pathname-p p) "Expected a wildcard pathname") (transform wilden (not (wild-pathname-p p)) (wilden p)) (when want-existing (let ((existing (probe-file* p :truename truename))) (if existing (when truename (return existing)) (err want-existing "Expected an existing pathname")))) (when ensure-directories-exist (ensure-directories-exist p)) (when truename (let ((truename (truename* p))) (if truename (return truename) (err truename "Can't get a truename for pathname")))) (transform resolve-symlinks () (resolve-symlinks p)) (transform truenamize () (truenamize p)) p))))) ;;; Pathname defaults (with-upgradability () (defun get-pathname-defaults (&optional (defaults *default-pathname-defaults*)) "Find the actual DEFAULTS to use for pathnames, including resolving them with respect to GETCWD if the DEFAULTS were relative" (or (absolute-pathname-p defaults) (merge-pathnames* defaults (getcwd)))) (defun call-with-current-directory (dir thunk) "call the THUNK in a context where the current directory was changed to DIR, if not NIL. Note that this operation is usually NOT thread-safe." (if dir (let* ((dir (resolve-symlinks* (get-pathname-defaults (pathname-directory-pathname dir)))) (cwd (getcwd)) (*default-pathname-defaults* dir)) (chdir dir) (unwind-protect (funcall thunk) (chdir cwd))) (funcall thunk))) (defmacro with-current-directory ((&optional dir) &body body) "Call BODY while the POSIX current working directory is set to DIR" `(call-with-current-directory ,dir #'(lambda () ,@body)))) ;;; Environment pathnames (with-upgradability () (defun inter-directory-separator () "What character does the current OS conventionally uses to separate directories?" (os-cond ((os-unix-p) #\:) (t #\;))) (defun split-native-pathnames-string (string &rest constraints &key &allow-other-keys) "Given a string of pathnames specified in native OS syntax, separate them in a list, check constraints and normalize each one as per ENSURE-PATHNAME, where an empty string denotes NIL." (loop :for namestring :in (split-string string :separator (string (inter-directory-separator))) :collect (unless (emptyp namestring) (apply 'parse-native-namestring namestring constraints)))) (defun getenv-pathname (x &rest constraints &key ensure-directory want-directory on-error &allow-other-keys) "Extract a pathname from a user-configured environment variable, as per native OS, check constraints and normalize as per ENSURE-PATHNAME." ;; For backward compatibility with ASDF 2, want-directory implies ensure-directory (apply 'parse-native-namestring (getenvp x) :ensure-directory (or ensure-directory want-directory) :on-error (or on-error `(error "In (~S ~S), invalid pathname ~*~S: ~*~?" getenv-pathname ,x)) constraints)) (defun getenv-pathnames (x &rest constraints &key on-error &allow-other-keys) "Extract a list of pathname from a user-configured environment variable, as per native OS, check constraints and normalize each one as per ENSURE-PATHNAME. Any empty entries in the environment variable X will be returned as NILs." (unless (getf constraints :empty-is-nil t) (error "Cannot have EMPTY-IS-NIL false for GETENV-PATHNAMES.")) (apply 'split-native-pathnames-string (getenvp x) :on-error (or on-error `(error "In (~S ~S), invalid pathname ~*~S: ~*~?" getenv-pathnames ,x)) :empty-is-nil t constraints)) (defun getenv-absolute-directory (x) "Extract an absolute directory pathname from a user-configured environment variable, as per native OS" (getenv-pathname x :want-absolute t :ensure-directory t)) (defun getenv-absolute-directories (x) "Extract a list of absolute directories from a user-configured environment variable, as per native OS. Any empty entries in the environment variable X will be returned as NILs." (getenv-pathnames x :want-absolute t :ensure-directory t)) (defun lisp-implementation-directory (&key truename) "Where are the system files of the current installation of the CL implementation?" (declare (ignorable truename)) #+(or clasp clozure ecl gcl mkcl sbcl) (let ((dir (ignore-errors #+clozure #p"ccl:" #+(or clasp ecl mkcl) #p"SYS:" #+gcl system::*system-directory* #+sbcl (if-let (it (find-symbol* :sbcl-homedir-pathname :sb-int nil)) (funcall it) (getenv-pathname "SBCL_HOME" :ensure-directory t))))) (if (and dir truename) (truename* dir) dir))) (defun lisp-implementation-pathname-p (pathname) "Is the PATHNAME under the current installation of the CL implementation?" ;; Other builtin systems are those under the implementation directory (and (when pathname (if-let (impdir (lisp-implementation-directory)) (or (subpathp pathname impdir) (when *resolve-symlinks* (if-let (truename (truename* pathname)) (if-let (trueimpdir (truename* impdir)) (subpathp truename trueimpdir))))))) t))) ;;; Simple filesystem operations (with-upgradability () (defun ensure-all-directories-exist (pathnames) "Ensure that for every pathname in PATHNAMES, we ensure its directories exist" (dolist (pathname pathnames) (when pathname (ensure-directories-exist (physicalize-pathname pathname))))) (defun delete-file-if-exists (x) "Delete a file X if it already exists" (when x (handler-case (delete-file x) (file-error () nil)))) (defun rename-file-overwriting-target (source target) "Rename a file, overwriting any previous file with the TARGET name, in an atomic way if the implementation allows." #+clisp ;; in recent enough versions of CLISP, :if-exists :overwrite would make it atomic (progn (funcall 'require "syscalls") (symbol-call :posix :copy-file source target :method :rename)) #+(and sbcl os-windows) (delete-file-if-exists target) ;; not atomic #-clisp (rename-file source target #+(or clasp clozure ecl) :if-exists #+clozure :rename-and-delete #+(or clasp ecl) t)) (defun delete-empty-directory (directory-pathname) "Delete an empty directory" #+(or abcl digitool gcl) (delete-file directory-pathname) #+allegro (excl:delete-directory directory-pathname) #+clisp (ext:delete-directory directory-pathname) #+clozure (ccl::delete-empty-directory directory-pathname) #+(or cmu scl) (multiple-value-bind (ok errno) (unix:unix-rmdir (native-namestring directory-pathname)) (unless ok #+cmu (error "Error number ~A when trying to delete directory ~A" errno directory-pathname) #+scl (error "~@" directory-pathname (unix:get-unix-error-msg errno)))) #+cormanlisp (win32:delete-directory directory-pathname) #+(or clasp ecl) (si:rmdir directory-pathname) #+genera (fs:delete-directory directory-pathname) #+lispworks (lw:delete-directory directory-pathname) #+mkcl (mkcl:rmdir directory-pathname) #+sbcl #.(if-let (dd (find-symbol* :delete-directory :sb-ext nil)) `(,dd directory-pathname) ;; requires SBCL 1.0.44 or later `(progn (require :sb-posix) (symbol-call :sb-posix :rmdir directory-pathname))) #+xcl (symbol-call :uiop :run-program `("rmdir" ,(native-namestring directory-pathname))) #-(or abcl allegro clasp clisp clozure cmu cormanlisp digitool ecl gcl genera lispworks mkcl sbcl scl xcl) (error "~S not implemented on ~S" 'delete-empty-directory (implementation-type))) ; genera (defun delete-directory-tree (directory-pathname &key (validate nil validatep) (if-does-not-exist :error)) "Delete a directory including all its recursive contents, aka rm -rf. To reduce the risk of infortunate mistakes, DIRECTORY-PATHNAME must be a physical non-wildcard directory pathname (not namestring). If the directory does not exist, the IF-DOES-NOT-EXIST argument specifies what happens: if it is :ERROR (the default), an error is signaled, whereas if it is :IGNORE, nothing is done. Furthermore, before any deletion is attempted, the DIRECTORY-PATHNAME must pass the validation function designated (as per ENSURE-FUNCTION) by the VALIDATE keyword argument which in practice is thus compulsory, and validates by returning a non-NIL result. If you're suicidal or extremely confident, just use :VALIDATE T." (check-type if-does-not-exist (member :error :ignore)) (cond ((not (and (pathnamep directory-pathname) (directory-pathname-p directory-pathname) (physical-pathname-p directory-pathname) (not (wild-pathname-p directory-pathname)))) (error "~S was asked to delete ~S but it is not a physical non-wildcard directory pathname" 'delete-directory-tree directory-pathname)) ((not validatep) (error "~S was asked to delete ~S but was not provided a validation predicate" 'delete-directory-tree directory-pathname)) ((not (call-function validate directory-pathname)) (error "~S was asked to delete ~S but it is not valid ~@[according to ~S~]" 'delete-directory-tree directory-pathname validate)) ((not (directory-exists-p directory-pathname)) (ecase if-does-not-exist (:error (error "~S was asked to delete ~S but the directory does not exist" 'delete-directory-tree directory-pathname)) (:ignore nil))) #-(or allegro cmu clozure genera sbcl scl) ((os-unix-p) ;; On Unix, don't recursively walk the directory and delete everything in Lisp, ;; except on implementations where we can prevent DIRECTORY from following symlinks; ;; instead spawn a standard external program to do the dirty work. (symbol-call :uiop :run-program `("rm" "-rf" ,(native-namestring directory-pathname)))) (t ;; On supported implementation, call supported system functions #+allegro (symbol-call :excl.osi :delete-directory-and-files directory-pathname :if-does-not-exist if-does-not-exist) #+clozure (ccl:delete-directory directory-pathname) #+genera (fs:delete-directory directory-pathname :confirm nil) #+sbcl #.(if-let (dd (find-symbol* :delete-directory :sb-ext nil)) `(,dd directory-pathname :recursive t) ;; requires SBCL 1.0.44 or later '(error "~S requires SBCL 1.0.44 or later" 'delete-directory-tree)) ;; Outside Unix or on CMUCL and SCL that can avoid following symlinks, ;; do things the hard way. #-(or allegro clozure genera sbcl) (let ((sub*directories (while-collecting (c) (collect-sub*directories directory-pathname t t #'c)))) (dolist (d (nreverse sub*directories)) (map () 'delete-file (directory-files d)) (delete-empty-directory d))))))) ;;;; --------------------------------------------------------------------------- ;;;; Utilities related to streams (uiop/package:define-package :uiop/stream (:nicknames :asdf/stream) (:recycle :uiop/stream :asdf/stream :asdf) (:use :uiop/common-lisp :uiop/package :uiop/utility :uiop/os :uiop/pathname :uiop/filesystem) (:export #:*default-stream-element-type* #:*stdin* #:setup-stdin #:*stdout* #:setup-stdout #:*stderr* #:setup-stderr #:detect-encoding #:*encoding-detection-hook* #:always-default-encoding #:encoding-external-format #:*encoding-external-format-hook* #:default-encoding-external-format #:*default-encoding* #:*utf-8-external-format* #:with-safe-io-syntax #:call-with-safe-io-syntax #:safe-read-from-string #:with-output #:output-string #:with-input #:input-string #:with-input-file #:call-with-input-file #:with-output-file #:call-with-output-file #:null-device-pathname #:call-with-null-input #:with-null-input #:call-with-null-output #:with-null-output #:finish-outputs #:format! #:safe-format! #:copy-stream-to-stream #:concatenate-files #:copy-file #:slurp-stream-string #:slurp-stream-lines #:slurp-stream-line #:slurp-stream-forms #:slurp-stream-form #:read-file-string #:read-file-line #:read-file-lines #:safe-read-file-line #:read-file-forms #:read-file-form #:safe-read-file-form #:eval-input #:eval-thunk #:standard-eval-thunk #:println #:writeln ;; Temporary files #:*temporary-directory* #:temporary-directory #:default-temporary-directory #:setup-temporary-directory #:call-with-temporary-file #:with-temporary-file #:add-pathname-suffix #:tmpize-pathname #:call-with-staging-pathname #:with-staging-pathname)) (in-package :uiop/stream) (with-upgradability () (defvar *default-stream-element-type* (or #+(or abcl cmu cormanlisp scl xcl) 'character #+lispworks 'lw:simple-char :default) "default element-type for open (depends on the current CL implementation)") (defvar *stdin* *standard-input* "the original standard input stream at startup") (defun setup-stdin () (setf *stdin* #.(or #+clozure 'ccl::*stdin* #+(or cmu scl) 'system:*stdin* #+(or clasp ecl) 'ext::+process-standard-input+ #+sbcl 'sb-sys:*stdin* '*standard-input*))) (defvar *stdout* *standard-output* "the original standard output stream at startup") (defun setup-stdout () (setf *stdout* #.(or #+clozure 'ccl::*stdout* #+(or cmu scl) 'system:*stdout* #+(or clasp ecl) 'ext::+process-standard-output+ #+sbcl 'sb-sys:*stdout* '*standard-output*))) (defvar *stderr* *error-output* "the original error output stream at startup") (defun setup-stderr () (setf *stderr* #.(or #+allegro 'excl::*stderr* #+clozure 'ccl::*stderr* #+(or cmu scl) 'system:*stderr* #+(or clasp ecl) 'ext::+process-error-output+ #+sbcl 'sb-sys:*stderr* '*error-output*))) ;; Run them now. In image.lisp, we'll register them to be run at image restart. (setup-stdin) (setup-stdout) (setup-stderr)) ;;; Encodings (mostly hooks only; full support requires asdf-encodings) (with-upgradability () (defparameter *default-encoding* ;; preserve explicit user changes to something other than the legacy default :default (or (if-let (previous (and (boundp '*default-encoding*) (symbol-value '*default-encoding*))) (unless (eq previous :default) previous)) :utf-8) "Default encoding for source files. The default value :utf-8 is the portable thing. The legacy behavior was :default. If you (asdf:load-system :asdf-encodings) then you will have autodetection via *encoding-detection-hook* below, reading emacs-style -*- coding: utf-8 -*- specifications, and falling back to utf-8 or latin1 if nothing is specified.") (defparameter *utf-8-external-format* (if (featurep :asdf-unicode) (or #+clisp charset:utf-8 :utf-8) :default) "Default :external-format argument to pass to CL:OPEN and also CL:LOAD or CL:COMPILE-FILE to best process a UTF-8 encoded file. On modern implementations, this will decode UTF-8 code points as CL characters. On legacy implementations, it may fall back on some 8-bit encoding, with non-ASCII code points being read as several CL characters; hopefully, if done consistently, that won't affect program behavior too much.") (defun always-default-encoding (pathname) "Trivial function to use as *encoding-detection-hook*, always 'detects' the *default-encoding*" (declare (ignore pathname)) *default-encoding*) (defvar *encoding-detection-hook* #'always-default-encoding "Hook for an extension to define a function to automatically detect a file's encoding") (defun detect-encoding (pathname) "Detects the encoding of a specified file, going through user-configurable hooks" (if (and pathname (not (directory-pathname-p pathname)) (probe-file* pathname)) (funcall *encoding-detection-hook* pathname) *default-encoding*)) (defun default-encoding-external-format (encoding) "Default, ignorant, function to transform a character ENCODING as a portable keyword to an implementation-dependent EXTERNAL-FORMAT specification. Load system ASDF-ENCODINGS to hook in a better one." (case encoding (:default :default) ;; for backward-compatibility only. Explicit usage discouraged. (:utf-8 *utf-8-external-format*) (otherwise (cerror "Continue using :external-format :default" (compatfmt "~@") encoding) :default))) (defvar *encoding-external-format-hook* #'default-encoding-external-format "Hook for an extension (e.g. ASDF-ENCODINGS) to define a better mapping from non-default encodings to and implementation-defined external-format's") (defun encoding-external-format (encoding) "Transform a portable ENCODING keyword to an implementation-dependent EXTERNAL-FORMAT, going through all the proper hooks." (funcall *encoding-external-format-hook* (or encoding *default-encoding*)))) ;;; Safe syntax (with-upgradability () (defvar *standard-readtable* (with-standard-io-syntax *readtable*) "The standard readtable, implementing the syntax specified by the CLHS. It must never be modified, though only good implementations will even enforce that.") (defmacro with-safe-io-syntax ((&key (package :cl)) &body body) "Establish safe CL reader options around the evaluation of BODY" `(call-with-safe-io-syntax #'(lambda () (let ((*package* (find-package ,package))) ,@body)))) (defun call-with-safe-io-syntax (thunk &key (package :cl)) (with-standard-io-syntax (let ((*package* (find-package package)) (*read-default-float-format* 'double-float) (*print-readably* nil) (*read-eval* nil)) (funcall thunk)))) (defun safe-read-from-string (string &key (package :cl) (eof-error-p t) eof-value (start 0) end preserve-whitespace) "Read from STRING using a safe syntax, as per WITH-SAFE-IO-SYNTAX" (with-safe-io-syntax (:package package) (read-from-string string eof-error-p eof-value :start start :end end :preserve-whitespace preserve-whitespace)))) ;;; Output helpers (with-upgradability () (defun call-with-output-file (pathname thunk &key (element-type *default-stream-element-type*) (external-format *utf-8-external-format*) (if-exists :error) (if-does-not-exist :create)) "Open FILE for input with given recognizes options, call THUNK with the resulting stream. Other keys are accepted but discarded." (with-open-file (s pathname :direction :output :element-type element-type :external-format external-format :if-exists if-exists :if-does-not-exist if-does-not-exist) (funcall thunk s))) (defmacro with-output-file ((var pathname &rest keys &key element-type external-format if-exists if-does-not-exist) &body body) (declare (ignore element-type external-format if-exists if-does-not-exist)) `(call-with-output-file ,pathname #'(lambda (,var) ,@body) ,@keys)) (defun call-with-output (output function &key keys) "Calls FUNCTION with an actual stream argument, behaving like FORMAT with respect to how stream designators are interpreted: If OUTPUT is a STREAM, use it as the stream. If OUTPUT is NIL, use a STRING-OUTPUT-STREAM as the stream, and return the resulting string. If OUTPUT is T, use *STANDARD-OUTPUT* as the stream. If OUTPUT is a STRING with a fill-pointer, use it as a string-output-stream. If OUTPUT is a PATHNAME, open the file and write to it, passing KEYS to WITH-OUTPUT-FILE -- this latter as an extension since ASDF 3.1. Otherwise, signal an error." (etypecase output (null (with-output-to-string (stream) (funcall function stream))) ((eql t) (funcall function *standard-output*)) (stream (funcall function output)) (string (assert (fill-pointer output)) (with-output-to-string (stream output) (funcall function stream))) (pathname (apply 'call-with-output-file output function keys)))) (defmacro with-output ((output-var &optional (value output-var)) &body body) "Bind OUTPUT-VAR to an output stream, coercing VALUE (default: previous binding of OUTPUT-VAR) as per FORMAT, and evaluate BODY within the scope of this binding." `(call-with-output ,value #'(lambda (,output-var) ,@body))) (defun output-string (string &optional output) "If the desired OUTPUT is not NIL, print the string to the output; otherwise return the string" (if output (with-output (output) (princ string output)) string))) ;;; Input helpers (with-upgradability () (defun call-with-input-file (pathname thunk &key (element-type *default-stream-element-type*) (external-format *utf-8-external-format*) (if-does-not-exist :error)) "Open FILE for input with given recognizes options, call THUNK with the resulting stream. Other keys are accepted but discarded." (with-open-file (s pathname :direction :input :element-type element-type :external-format external-format :if-does-not-exist if-does-not-exist) (funcall thunk s))) (defmacro with-input-file ((var pathname &rest keys &key element-type external-format if-does-not-exist) &body body) (declare (ignore element-type external-format if-does-not-exist)) `(call-with-input-file ,pathname #'(lambda (,var) ,@body) ,@keys)) (defun call-with-input (input function &key keys) "Calls FUNCTION with an actual stream argument, interpreting stream designators like READ, but also coercing strings to STRING-INPUT-STREAM, and PATHNAME to FILE-STREAM. If INPUT is a STREAM, use it as the stream. If INPUT is NIL, use a *STANDARD-INPUT* as the stream. If INPUT is T, use *TERMINAL-IO* as the stream. If INPUT is a STRING, use it as a string-input-stream. If INPUT is a PATHNAME, open it, passing KEYS to WITH-INPUT-FILE -- the latter is an extension since ASDF 3.1. Otherwise, signal an error." (etypecase input (null (funcall function *standard-input*)) ((eql t) (funcall function *terminal-io*)) (stream (funcall function input)) (string (with-input-from-string (stream input) (funcall function stream))) (pathname (apply 'call-with-input-file input function keys)))) (defmacro with-input ((input-var &optional (value input-var)) &body body) "Bind INPUT-VAR to an input stream, coercing VALUE (default: previous binding of INPUT-VAR) as per CALL-WITH-INPUT, and evaluate BODY within the scope of this binding." `(call-with-input ,value #'(lambda (,input-var) ,@body))) (defun input-string (&optional input) "If the desired INPUT is a string, return that string; otherwise slurp the INPUT into a string and return that" (if (stringp input) input (with-input (input) (funcall 'slurp-stream-string input))))) ;;; Null device (with-upgradability () (defun null-device-pathname () "Pathname to a bit bucket device that discards any information written to it and always returns EOF when read from" (os-cond ((os-unix-p) #p"/dev/null") ((os-windows-p) #p"NUL") ;; Q: how many Lisps accept the #p"NUL:" syntax? (t (error "No /dev/null on your OS")))) (defun call-with-null-input (fun &rest keys &key element-type external-format if-does-not-exist) "Call FUN with an input stream from the null device; pass keyword arguments to OPEN." (declare (ignore element-type external-format if-does-not-exist)) (apply 'call-with-input-file (null-device-pathname) fun keys)) (defmacro with-null-input ((var &rest keys &key element-type external-format if-does-not-exist) &body body) (declare (ignore element-type external-format if-does-not-exist)) "Evaluate BODY in a context when VAR is bound to an input stream accessing the null device. Pass keyword arguments to OPEN." `(call-with-null-input #'(lambda (,var) ,@body) ,@keys)) (defun call-with-null-output (fun &key (element-type *default-stream-element-type*) (external-format *utf-8-external-format*) (if-exists :overwrite) (if-does-not-exist :error)) "Call FUN with an output stream to the null device; pass keyword arguments to OPEN." (call-with-output-file (null-device-pathname) fun :element-type element-type :external-format external-format :if-exists if-exists :if-does-not-exist if-does-not-exist)) (defmacro with-null-output ((var &rest keys &key element-type external-format if-does-not-exist if-exists) &body body) "Evaluate BODY in a context when VAR is bound to an output stream accessing the null device. Pass keyword arguments to OPEN." (declare (ignore element-type external-format if-exists if-does-not-exist)) `(call-with-null-output #'(lambda (,var) ,@body) ,@keys))) ;;; Ensure output buffers are flushed (with-upgradability () (defun finish-outputs (&rest streams) "Finish output on the main output streams as well as any specified one. Useful for portably flushing I/O before user input or program exit." ;; CCL notably buffers its stream output by default. (dolist (s (append streams (list *stdout* *stderr* *error-output* *standard-output* *trace-output* *debug-io* *terminal-io* *query-io*))) (ignore-errors (finish-output s))) (values)) (defun format! (stream format &rest args) "Just like format, but call finish-outputs before and after the output." (finish-outputs stream) (apply 'format stream format args) (finish-outputs stream)) (defun safe-format! (stream format &rest args) "Variant of FORMAT that is safe against both dangerous syntax configuration and errors while printing." (with-safe-io-syntax () (ignore-errors (apply 'format! stream format args)) (finish-outputs stream)))) ; just in case format failed ;;; Simple Whole-Stream processing (with-upgradability () (defun copy-stream-to-stream (input output &key element-type buffer-size linewise prefix) "Copy the contents of the INPUT stream into the OUTPUT stream. If LINEWISE is true, then read and copy the stream line by line, with an optional PREFIX. Otherwise, using WRITE-SEQUENCE using a buffer of size BUFFER-SIZE." (with-open-stream (input input) (if linewise (loop* :for (line eof) = (multiple-value-list (read-line input nil nil)) :while line :do (when prefix (princ prefix output)) (princ line output) (unless eof (terpri output)) (finish-output output) (when eof (return))) (loop :with buffer-size = (or buffer-size 8192) :for buffer = (make-array (list buffer-size) :element-type (or element-type 'character)) :for end = (read-sequence buffer input) :until (zerop end) :do (write-sequence buffer output :end end) (when (< end buffer-size) (return)))))) (defun concatenate-files (inputs output) "create a new OUTPUT file the contents of which a the concatenate of the INPUTS files." (with-open-file (o output :element-type '(unsigned-byte 8) :direction :output :if-exists :rename-and-delete) (dolist (input inputs) (with-open-file (i input :element-type '(unsigned-byte 8) :direction :input :if-does-not-exist :error) (copy-stream-to-stream i o :element-type '(unsigned-byte 8)))))) (defun copy-file (input output) "Copy contents of the INPUT file to the OUTPUT file" ;; Not available on LW personal edition or LW 6.0 on Mac: (lispworks:copy-file i f) (concatenate-files (list input) output)) (defun slurp-stream-string (input &key (element-type 'character) stripped) "Read the contents of the INPUT stream as a string" (let ((string (with-open-stream (input input) (with-output-to-string (output) (copy-stream-to-stream input output :element-type element-type))))) (if stripped (stripln string) string))) (defun slurp-stream-lines (input &key count) "Read the contents of the INPUT stream as a list of lines, return those lines. Note: relies on the Lisp's READ-LINE, but additionally removes any remaining CR from the line-ending if the file or stream had CR+LF but Lisp only removed LF. Read no more than COUNT lines." (check-type count (or null integer)) (with-open-stream (input input) (loop :for n :from 0 :for l = (and (or (not count) (< n count)) (read-line input nil nil)) ;; stripln: to remove CR when the OS sends CRLF and Lisp only remove LF :while l :collect (stripln l)))) (defun slurp-stream-line (input &key (at 0)) "Read the contents of the INPUT stream as a list of lines, then return the ACCESS-AT of that list of lines using the AT specifier. PATH defaults to 0, i.e. return the first line. PATH is typically an integer, or a list of an integer and a function. If PATH is NIL, it will return all the lines in the file. The stream will not be read beyond the Nth lines, where N is the index specified by path if path is either an integer or a list that starts with an integer." (access-at (slurp-stream-lines input :count (access-at-count at)) at)) (defun slurp-stream-forms (input &key count) "Read the contents of the INPUT stream as a list of forms, and return those forms. If COUNT is null, read to the end of the stream; if COUNT is an integer, stop after COUNT forms were read. BEWARE: be sure to use WITH-SAFE-IO-SYNTAX, or some variant thereof" (check-type count (or null integer)) (loop :with eof = '#:eof :for n :from 0 :for form = (if (and count (>= n count)) eof (read-preserving-whitespace input nil eof)) :until (eq form eof) :collect form)) (defun slurp-stream-form (input &key (at 0)) "Read the contents of the INPUT stream as a list of forms, then return the ACCESS-AT of these forms following the AT. AT defaults to 0, i.e. return the first form. AT is typically a list of integers. If AT is NIL, it will return all the forms in the file. The stream will not be read beyond the Nth form, where N is the index specified by path, if path is either an integer or a list that starts with an integer. BEWARE: be sure to use WITH-SAFE-IO-SYNTAX, or some variant thereof" (access-at (slurp-stream-forms input :count (access-at-count at)) at)) (defun read-file-string (file &rest keys) "Open FILE with option KEYS, read its contents as a string" (apply 'call-with-input-file file 'slurp-stream-string keys)) (defun read-file-lines (file &rest keys) "Open FILE with option KEYS, read its contents as a list of lines BEWARE: be sure to use WITH-SAFE-IO-SYNTAX, or some variant thereof" (apply 'call-with-input-file file 'slurp-stream-lines keys)) (defun read-file-line (file &rest keys &key (at 0) &allow-other-keys) "Open input FILE with option KEYS (except AT), and read its contents as per SLURP-STREAM-LINE with given AT specifier. BEWARE: be sure to use WITH-SAFE-IO-SYNTAX, or some variant thereof" (apply 'call-with-input-file file #'(lambda (input) (slurp-stream-line input :at at)) (remove-plist-key :at keys))) (defun read-file-forms (file &rest keys &key count &allow-other-keys) "Open input FILE with option KEYS (except COUNT), and read its contents as per SLURP-STREAM-FORMS with given COUNT. BEWARE: be sure to use WITH-SAFE-IO-SYNTAX, or some variant thereof" (apply 'call-with-input-file file #'(lambda (input) (slurp-stream-forms input :count count)) (remove-plist-key :count keys))) (defun read-file-form (file &rest keys &key (at 0) &allow-other-keys) "Open input FILE with option KEYS (except AT), and read its contents as per SLURP-STREAM-FORM with given AT specifier. BEWARE: be sure to use WITH-SAFE-IO-SYNTAX, or some variant thereof" (apply 'call-with-input-file file #'(lambda (input) (slurp-stream-form input :at at)) (remove-plist-key :at keys))) (defun safe-read-file-line (pathname &rest keys &key (package :cl) &allow-other-keys) "Reads the specified line from the top of a file using a safe standardized syntax. Extracts the line using READ-FILE-LINE, within an WITH-SAFE-IO-SYNTAX using the specified PACKAGE." (with-safe-io-syntax (:package package) (apply 'read-file-line pathname (remove-plist-key :package keys)))) (defun safe-read-file-form (pathname &rest keys &key (package :cl) &allow-other-keys) "Reads the specified form from the top of a file using a safe standardized syntax. Extracts the form using READ-FILE-FORM, within an WITH-SAFE-IO-SYNTAX using the specified PACKAGE." (with-safe-io-syntax (:package package) (apply 'read-file-form pathname (remove-plist-key :package keys)))) (defun eval-input (input) "Portably read and evaluate forms from INPUT, return the last values." (with-input (input) (loop :with results :with eof ='#:eof :for form = (read input nil eof) :until (eq form eof) :do (setf results (multiple-value-list (eval form))) :finally (return (apply 'values results))))) (defun eval-thunk (thunk) "Evaluate a THUNK of code: If a function, FUNCALL it without arguments. If a constant literal and not a sequence, return it. If a cons or a symbol, EVAL it. If a string, repeatedly read and evaluate from it, returning the last values." (etypecase thunk ((or boolean keyword number character pathname) thunk) ((or cons symbol) (eval thunk)) (function (funcall thunk)) (string (eval-input thunk)))) (defun standard-eval-thunk (thunk &key (package :cl)) "Like EVAL-THUNK, but in a more standardized evaluation context." ;; Note: it's "standard-" not "safe-", because evaluation is never safe. (when thunk (with-safe-io-syntax (:package package) (let ((*read-eval* t)) (eval-thunk thunk)))))) (with-upgradability () (defun println (x &optional (stream *standard-output*)) "Variant of PRINC that also calls TERPRI afterwards" (princ x stream) (terpri stream) (finish-output stream) (values)) (defun writeln (x &rest keys &key (stream *standard-output*) &allow-other-keys) "Variant of WRITE that also calls TERPRI afterwards" (apply 'write x keys) (terpri stream) (finish-output stream) (values))) ;;; Using temporary files (with-upgradability () (defun default-temporary-directory () "Return a default directory to use for temporary files" (os-cond ((os-unix-p) (or (getenv-pathname "TMPDIR" :ensure-directory t) (parse-native-namestring "/tmp/"))) ((os-windows-p) (getenv-pathname "TEMP" :ensure-directory t)) (t (subpathname (user-homedir-pathname) "tmp/")))) (defvar *temporary-directory* nil "User-configurable location for temporary files") (defun temporary-directory () "Return a directory to use for temporary files" (or *temporary-directory* (default-temporary-directory))) (defun setup-temporary-directory () "Configure a default temporary directory to use." (setf *temporary-directory* (default-temporary-directory)) #+gcl (setf system::*tmp-dir* *temporary-directory*)) (defun call-with-temporary-file (thunk &key (want-stream-p t) (want-pathname-p t) (direction :io) keep after directory (type "tmp" typep) prefix (suffix (when typep "-tmp")) (element-type *default-stream-element-type*) (external-format *utf-8-external-format*)) "Call a THUNK with stream and/or pathname arguments identifying a temporary file. The temporary file's pathname will be based on concatenating PREFIX (defaults to \"uiop\"), a random alphanumeric string, and optional SUFFIX (defaults to \"-tmp\" if a type was provided) and TYPE (defaults to \"tmp\", using a dot as separator if not NIL), within DIRECTORY (defaulting to the TEMPORARY-DIRECTORY) if the PREFIX isn't absolute. The file will be open with specified DIRECTION (defaults to :IO), ELEMENT-TYPE (defaults to *DEFAULT-STREAM-ELEMENT-TYPE*) and EXTERNAL-FORMAT (defaults to *UTF-8-EXTERNAL-FORMAT*). If WANT-STREAM-P is true (the defaults to T), then THUNK will then be CALL-FUNCTION'ed with the stream and the pathname (if WANT-PATHNAME-P is true, defaults to T), and stream with be closed after the THUNK exits (either normally or abnormally). If WANT-STREAM-P is false, then WANT-PATHAME-P must be true, and then THUNK is only CALL-FUNCTION'ed after the stream is closed, with the pathname as argument. Upon exit of THUNK, the AFTER thunk if defined is CALL-FUNCTION'ed with the pathname as argument. If AFTER is defined, its results are returned, otherwise, the results of THUNK are returned. Finally, the file will be deleted, unless the KEEP argument when CALL-FUNCTION'ed returns true." #+xcl (declare (ignorable typep)) (check-type direction (member :output :io)) (assert (or want-stream-p want-pathname-p)) (loop :with prefix = (native-namestring (ensure-absolute-pathname (or prefix "tmp") (or (ensure-pathname directory :namestring :native :ensure-directory t) #'temporary-directory))) :with results = () :for counter :from (random (expt 36 #-gcl 8 #+gcl 5)) :for pathname = (parse-native-namestring (format nil "~A~36R~@[~A~]~@[.~A~]" prefix counter suffix (unless (eq type :unspecific) type))) :for okp = nil :do ;; TODO: on Unix, do something about umask ;; TODO: on Unix, audit the code so we make sure it uses O_CREAT|O_EXCL ;; TODO: on Unix, use CFFI and mkstemp -- ;; except UIOP is precisely meant to not depend on CFFI or on anything! Grrrr. ;; Can we at least design some hook? (unwind-protect (progn (with-open-file (stream pathname :direction direction :element-type element-type :external-format external-format :if-exists nil :if-does-not-exist :create) (when stream (setf okp pathname) (when want-stream-p ;; Note: can't return directly from within with-open-file ;; or the non-local return causes the file creation to be undone. (setf results (multiple-value-list (if want-pathname-p (funcall thunk stream pathname) (funcall thunk stream))))))) (cond ((not okp) nil) (after (return (call-function after okp))) ((and want-pathname-p (not want-stream-p)) (return (call-function thunk okp))) (t (return (apply 'values results))))) (when (and okp (not (call-function keep))) (ignore-errors (delete-file-if-exists okp)))))) (defmacro with-temporary-file ((&key (stream (gensym "STREAM") streamp) (pathname (gensym "PATHNAME") pathnamep) directory prefix suffix type keep direction element-type external-format) &body body) "Evaluate BODY where the symbols specified by keyword arguments STREAM and PATHNAME (if respectively specified) are bound corresponding to a newly created temporary file ready for I/O, as per CALL-WITH-TEMPORARY-FILE. At least one of STREAM or PATHNAME must be specified. If the STREAM is not specified, it will be closed before the BODY is evaluated. If STREAM is specified, then the :CLOSE-STREAM label if it appears in the BODY, separates forms run before and after the stream is closed. The values of the last form of the BODY (not counting the separating :CLOSE-STREAM) are returned. Upon success, the KEEP form is evaluated and the file is is deleted unless it evaluates to TRUE." (check-type stream symbol) (check-type pathname symbol) (assert (or streamp pathnamep)) (let* ((afterp (position :close-stream body)) (before (if afterp (subseq body 0 afterp) body)) (after (when afterp (subseq body (1+ afterp)))) (beforef (gensym "BEFORE")) (afterf (gensym "AFTER"))) `(flet (,@(when before `((,beforef (,@(when streamp `(,stream)) ,@(when pathnamep `(,pathname))) ,@(when after `((declare (ignorable ,pathname)))) ,@before))) ,@(when after (assert pathnamep) `((,afterf (,pathname) ,@after)))) #-gcl (declare (dynamic-extent ,@(when before `(#',beforef)) ,@(when after `(#',afterf)))) (call-with-temporary-file ,(when before `#',beforef) :want-stream-p ,streamp :want-pathname-p ,pathnamep ,@(when direction `(:direction ,direction)) ,@(when directory `(:directory ,directory)) ,@(when prefix `(:prefix ,prefix)) ,@(when suffix `(:suffix ,suffix)) ,@(when type `(:type ,type)) ,@(when keep `(:keep ,keep)) ,@(when after `(:after #',afterf)) ,@(when element-type `(:element-type ,element-type)) ,@(when external-format `(:external-format ,external-format)))))) (defun get-temporary-file (&key directory prefix suffix type) (with-temporary-file (:pathname pn :keep t :directory directory :prefix prefix :suffix suffix :type type) pn)) ;; Temporary pathnames in simple cases where no contention is assumed (defun add-pathname-suffix (pathname suffix &rest keys) "Add a SUFFIX to the name of a PATHNAME, return a new pathname. Further KEYS can be passed to MAKE-PATHNAME." (apply 'make-pathname :name (strcat (pathname-name pathname) suffix) :defaults pathname keys)) (defun tmpize-pathname (x) "Return a new pathname modified from X by adding a trivial random suffix. A new empty file with said temporary pathname is created, to ensure there is no clash with any concurrent process attempting the same thing." (let* ((px (ensure-pathname x)) (prefix (if-let (n (pathname-name px)) (strcat n "-tmp") "tmp"))) (get-temporary-file :directory (pathname-directory-pathname px) :prefix prefix :type (pathname-type px)))) (defun call-with-staging-pathname (pathname fun) "Calls FUN with a staging pathname, and atomically renames the staging pathname to the PATHNAME in the end. NB: this protects only against failure of the program, not against concurrent attempts. For the latter case, we ought pick a random suffix and atomically open it." (let* ((pathname (pathname pathname)) (staging (tmpize-pathname pathname))) (unwind-protect (multiple-value-prog1 (funcall fun staging) (rename-file-overwriting-target staging pathname)) (delete-file-if-exists staging)))) (defmacro with-staging-pathname ((pathname-var &optional (pathname-value pathname-var)) &body body) "Trivial syntax wrapper for CALL-WITH-STAGING-PATHNAME" `(call-with-staging-pathname ,pathname-value #'(lambda (,pathname-var) ,@body)))) ;;;; ------------------------------------------------------------------------- ;;;; Starting, Stopping, Dumping a Lisp image (uiop/package:define-package :uiop/image (:nicknames :asdf/image) (:recycle :uiop/image :asdf/image :xcvb-driver) (:use :uiop/common-lisp :uiop/package :uiop/utility :uiop/pathname :uiop/stream :uiop/os) (:export #:*image-dumped-p* #:raw-command-line-arguments #:*command-line-arguments* #:command-line-arguments #:raw-command-line-arguments #:setup-command-line-arguments #:argv0 #:*lisp-interaction* #:*fatal-conditions* #:fatal-condition-p #:handle-fatal-condition #:call-with-fatal-condition-handler #:with-fatal-condition-handler #:*image-restore-hook* #:*image-prelude* #:*image-entry-point* #:*image-postlude* #:*image-dump-hook* #:quit #:die #:raw-print-backtrace #:print-backtrace #:print-condition-backtrace #:shell-boolean-exit #:register-image-restore-hook #:register-image-dump-hook #:call-image-restore-hook #:call-image-dump-hook #:restore-image #:dump-image #:create-image )) (in-package :uiop/image) (with-upgradability () (defvar *lisp-interaction* t "Is this an interactive Lisp environment, or is it batch processing?") (defvar *command-line-arguments* nil "Command-line arguments") (defvar *image-dumped-p* nil ; may matter as to how to get to command-line-arguments "Is this a dumped image? As a standalone executable?") (defvar *image-restore-hook* nil "Functions to call (in reverse order) when the image is restored") (defvar *image-restored-p* nil "Has the image been restored? A boolean, or :in-progress while restoring, :in-regress while dumping") (defvar *image-prelude* nil "a form to evaluate, or string containing forms to read and evaluate when the image is restarted, but before the entry point is called.") (defvar *image-entry-point* nil "a function with which to restart the dumped image when execution is restored from it.") (defvar *image-postlude* nil "a form to evaluate, or string containing forms to read and evaluate before the image dump hooks are called and before the image is dumped.") (defvar *image-dump-hook* nil "Functions to call (in order) when before an image is dumped") (defvar *fatal-conditions* '(error) "conditions that cause the Lisp image to enter the debugger if interactive, or to die if not interactive")) ;;; Exiting properly or im- (with-upgradability () (defun quit (&optional (code 0) (finish-output t)) "Quits from the Lisp world, with the given exit status if provided. This is designed to abstract away the implementation specific quit forms." (when finish-output ;; essential, for ClozureCL, and for standard compliance. (finish-outputs)) #+(or abcl xcl) (ext:quit :status code) #+allegro (excl:exit code :quiet t) #+(or clasp ecl) (si:quit code) #+clisp (ext:quit code) #+clozure (ccl:quit code) #+cormanlisp (win32:exitprocess code) #+(or cmu scl) (unix:unix-exit code) #+gcl (system:quit code) #+genera (error "~S: You probably don't want to Halt Genera. (code: ~S)" 'quit code) #+lispworks (lispworks:quit :status code :confirm nil :return nil :ignore-errors-p t) #+mcl (progn code (ccl:quit)) ;; or should we use FFI to call libc's exit(3) ? #+mkcl (mk-ext:quit :exit-code code) #+sbcl #.(let ((exit (find-symbol* :exit :sb-ext nil)) (quit (find-symbol* :quit :sb-ext nil))) (cond (exit `(,exit :code code :abort (not finish-output))) (quit `(,quit :unix-status code :recklessly-p (not finish-output))))) #-(or abcl allegro clasp clisp clozure cmu ecl gcl genera lispworks mcl mkcl sbcl scl xcl) (error "~S called with exit code ~S but there's no quitting on this implementation" 'quit code)) (defun die (code format &rest arguments) "Die in error with some error message" (with-safe-io-syntax () (ignore-errors (format! *stderr* "~&~?~&" format arguments))) (quit code)) (defun raw-print-backtrace (&key (stream *debug-io*) count condition) "Print a backtrace, directly accessing the implementation" (declare (ignorable stream count condition)) #+abcl (loop :for i :from 0 :for frame :in (sys:backtrace (or count most-positive-fixnum)) :do (safe-format! stream "~&~D: ~A~%" i frame)) #+allegro (let ((*terminal-io* stream) (*standard-output* stream) (tpl:*zoom-print-circle* *print-circle*) (tpl:*zoom-print-level* *print-level*) (tpl:*zoom-print-length* *print-length*)) (tpl:do-command "zoom" :from-read-eval-print-loop nil :count (or count t) :all t)) #+(or clasp ecl mkcl) (let* ((top (si:ihs-top)) (repeats (if count (min top count) top)) (backtrace (loop :for ihs :from 0 :below top :collect (list (si::ihs-fun ihs) (si::ihs-env ihs))))) (loop :for i :from 0 :below repeats :for frame :in (nreverse backtrace) :do (safe-format! stream "~&~D: ~S~%" i frame))) #+clisp (system::print-backtrace :out stream :limit count) #+(or clozure mcl) (let ((*debug-io* stream)) #+clozure (ccl:print-call-history :count count :start-frame-number 1) #+mcl (ccl:print-call-history :detailed-p nil) (finish-output stream)) #+(or cmu scl) (let ((debug:*debug-print-level* *print-level*) (debug:*debug-print-length* *print-length*)) (debug:backtrace (or count most-positive-fixnum) stream)) #+gcl (let ((*debug-io* stream)) (ignore-errors (with-safe-io-syntax () (if condition (conditions::condition-backtrace condition) (system::simple-backtrace))))) #+lispworks (let ((dbg::*debugger-stack* (dbg::grab-stack nil :how-many (or count most-positive-fixnum))) (*debug-io* stream) (dbg:*debug-print-level* *print-level*) (dbg:*debug-print-length* *print-length*)) (dbg:bug-backtrace nil)) #+sbcl (sb-debug:backtrace #.(if (find-symbol* "*VERBOSITY*" "SB-DEBUG" nil) :stream '(or count most-positive-fixnum)) stream) #+xcl (loop :for i :from 0 :below (or count most-positive-fixnum) :for frame :in (extensions:backtrace-as-list) :do (safe-format! stream "~&~D: ~S~%" i frame))) (defun print-backtrace (&rest keys &key stream count condition) "Print a backtrace" (declare (ignore stream count condition)) (with-safe-io-syntax (:package :cl) (let ((*print-readably* nil) (*print-circle* t) (*print-miser-width* 75) (*print-length* nil) (*print-level* nil) (*print-pretty* t)) (ignore-errors (apply 'raw-print-backtrace keys))))) (defun print-condition-backtrace (condition &key (stream *stderr*) count) "Print a condition after a backtrace triggered by that condition" ;; We print the condition *after* the backtrace, ;; for the sake of who sees the backtrace at a terminal. ;; It is up to the caller to print the condition *before*, with some context. (print-backtrace :stream stream :count count :condition condition) (when condition (safe-format! stream "~&Above backtrace due to this condition:~%~A~&" condition))) (defun fatal-condition-p (condition) "Is the CONDITION fatal? It is if it matches any in *FATAL-CONDITIONS*" (match-any-condition-p condition *fatal-conditions*)) (defun handle-fatal-condition (condition) "Handle a fatal CONDITION: depending on whether *LISP-INTERACTION* is set, enter debugger or die" (cond (*lisp-interaction* (invoke-debugger condition)) (t (safe-format! *stderr* "~&Fatal condition:~%~A~%" condition) (print-condition-backtrace condition :stream *stderr*) (die 99 "~A" condition)))) (defun call-with-fatal-condition-handler (thunk) "Call THUNK in a context where fatal conditions are appropriately handled" (handler-bind (((satisfies fatal-condition-p) #'handle-fatal-condition)) (funcall thunk))) (defmacro with-fatal-condition-handler ((&optional) &body body) "Execute BODY in a context where fatal conditions are appropriately handled" `(call-with-fatal-condition-handler #'(lambda () ,@body))) (defun shell-boolean-exit (x) "Quit with a return code that is 0 iff argument X is true" (quit (if x 0 1)))) ;;; Using image hooks (with-upgradability () (defun register-image-restore-hook (hook &optional (call-now-p t)) "Regiter a hook function to be run when restoring a dumped image" (register-hook-function '*image-restore-hook* hook call-now-p)) (defun register-image-dump-hook (hook &optional (call-now-p nil)) "Register a the hook function to be run before to dump an image" (register-hook-function '*image-dump-hook* hook call-now-p)) (defun call-image-restore-hook () "Call the hook functions registered to be run when restoring a dumped image" (call-functions (reverse *image-restore-hook*))) (defun call-image-dump-hook () "Call the hook functions registered to be run before to dump an image" (call-functions *image-dump-hook*))) ;;; Proper command-line arguments (with-upgradability () (defun raw-command-line-arguments () "Find what the actual command line for this process was." #+abcl ext:*command-line-argument-list* ; Use 1.0.0 or later! #+allegro (sys:command-line-arguments) ; default: :application t #+(or clasp ecl) (loop :for i :from 0 :below (si:argc) :collect (si:argv i)) #+clisp (coerce (ext:argv) 'list) #+clozure ccl:*command-line-argument-list* #+(or cmu scl) extensions:*command-line-strings* #+gcl si:*command-args* #+(or genera mcl) nil #+lispworks sys:*line-arguments-list* #+mkcl (loop :for i :from 0 :below (mkcl:argc) :collect (mkcl:argv i)) #+sbcl sb-ext:*posix-argv* #+xcl system:*argv* #-(or abcl allegro clasp clisp clozure cmu ecl gcl genera lispworks mcl mkcl sbcl scl xcl) (error "raw-command-line-arguments not implemented yet")) (defun command-line-arguments (&optional (arguments (raw-command-line-arguments))) "Extract user arguments from command-line invocation of current process. Assume the calling conventions of a generated script that uses -- if we are not called from a directly executable image." (block nil #+abcl (return arguments) ;; SBCL and Allegro already separate user arguments from implementation arguments. #-(or sbcl allegro) (unless (eq *image-dumped-p* :executable) ;; LispWorks command-line processing isn't transparent to the user ;; unless you create a standalone executable; in that case, ;; we rely on cl-launch or some other script to set the arguments for us. #+lispworks (return *command-line-arguments*) ;; On other implementations, on non-standalone executables, ;; we trust cl-launch or whichever script starts the program ;; to use -- as a delimiter between implementation arguments and user arguments. #-lispworks (setf arguments (member "--" arguments :test 'string-equal))) (rest arguments))) (defun argv0 () "On supported implementations (most that matter), or when invoked by a proper wrapper script, return a string that for the name with which the program was invoked, i.e. argv[0] in C. Otherwise, return NIL." (cond ((eq *image-dumped-p* :executable) ; yes, this ARGV0 is our argv0 ! ;; NB: not currently available on ABCL, Corman, Genera, MCL (or #+(or allegro clisp clozure cmu gcl lispworks sbcl scl xcl) (first (raw-command-line-arguments)) #+(or clasp ecl) (si:argv 0) #+mkcl (mkcl:argv 0))) (t ;; argv[0] is the name of the interpreter. ;; The wrapper script can export __CL_ARGV0. cl-launch does as of 4.0.1.8. (getenvp "__CL_ARGV0")))) (defun setup-command-line-arguments () (setf *command-line-arguments* (command-line-arguments))) (defun restore-image (&key (lisp-interaction *lisp-interaction*) (restore-hook *image-restore-hook*) (prelude *image-prelude*) (entry-point *image-entry-point*) (if-already-restored '(cerror "RUN RESTORE-IMAGE ANYWAY"))) "From a freshly restarted Lisp image, restore the saved Lisp environment by setting appropriate variables, running various hooks, and calling any specified entry point. If the image has already been restored or is already being restored, as per *IMAGE-RESTORED-P*, call the IF-ALREADY-RESTORED error handler (by default, a continuable error), and do return immediately to the surrounding restore process if allowed to continue. Then, comes the restore process itself: First, call each function in the RESTORE-HOOK, in the order they were registered with REGISTER-IMAGE-RESTORE-HOOK. Second, evaluate the prelude, which is often Lisp text that is read, as per EVAL-INPUT. Third, call the ENTRY-POINT function, if any is specified, with no argument. The restore process happens in a WITH-FATAL-CONDITION-HANDLER, so that if LISP-INTERACTION is NIL, any unhandled error leads to a backtrace and an exit with an error status. If LISP-INTERACTION is NIL, the process also exits when no error occurs: if neither restart nor entry function is provided, the program will exit with status 0 (success); if a function was provided, the program will exit after the function returns (if it returns), with status 0 if and only if the primary return value of result is generalized boolean true, and with status 1 if this value is NIL. If LISP-INTERACTION is true, unhandled errors will take you to the debugger, and the result of the function will be returned rather than interpreted as a boolean designating an exit code." (when *image-restored-p* (if if-already-restored (call-function if-already-restored "Image already ~:[being ~;~]restored" (eq *image-restored-p* t)) (return-from restore-image))) (with-fatal-condition-handler () (setf *lisp-interaction* lisp-interaction) (setf *image-restore-hook* restore-hook) (setf *image-prelude* prelude) (setf *image-restored-p* :in-progress) (call-image-restore-hook) (standard-eval-thunk prelude) (setf *image-restored-p* t) (let ((results (multiple-value-list (if entry-point (call-function entry-point) t)))) (if lisp-interaction (apply 'values results) (shell-boolean-exit (first results))))))) ;;; Dumping an image (with-upgradability () (defun dump-image (filename &key output-name executable (postlude *image-postlude*) (dump-hook *image-dump-hook*) #+clozure prepend-symbols #+clozure (purify t) #+sbcl compression #+(and sbcl os-windows) application-type) "Dump an image of the current Lisp environment at pathname FILENAME, with various options. First, finalize the image, by evaluating the POSTLUDE as per EVAL-INPUT, then calling each of the functions in DUMP-HOOK, in reverse order of registration by REGISTER-DUMP-HOOK. If EXECUTABLE is true, create an standalone executable program that calls RESTORE-IMAGE on startup. Pass various implementation-defined options, such as PREPEND-SYMBOLS and PURITY on CCL, or COMPRESSION on SBCL, and APPLICATION-TYPE on SBCL/Windows." ;; Note: at least SBCL saves only global values of variables in the heap image, ;; so make sure things you want to dump are NOT just local bindings shadowing the global values. (declare (ignorable filename output-name executable)) (setf *image-dumped-p* (if executable :executable t)) (setf *image-restored-p* :in-regress) (setf *image-postlude* postlude) (standard-eval-thunk *image-postlude*) (setf *image-dump-hook* dump-hook) (call-image-dump-hook) (setf *image-restored-p* nil) #-(or clisp clozure cmu lispworks sbcl scl) (when executable (error "Dumping an executable is not supported on this implementation! Aborting.")) #+allegro (progn (sys:resize-areas :global-gc t :pack-heap t :sift-old-areas t :tenure t) ; :new 5000000 (excl:dumplisp :name filename :suppress-allegro-cl-banner t)) #+clisp (apply #'ext:saveinitmem filename :quiet t :start-package *package* :keep-global-handlers nil :executable (if executable 0 t) ;--- requires clisp 2.48 or later, still catches --clisp-x (when executable (list ;; :parse-options nil ;--- requires a non-standard patch to clisp. :norc t :script nil :init-function #'restore-image))) #+clozure (flet ((dump (prepend-kernel) (ccl:save-application filename :prepend-kernel prepend-kernel :purify purify :toplevel-function (when executable #'restore-image)))) ;;(setf ccl::*application* (make-instance 'ccl::lisp-development-system)) (if prepend-symbols (with-temporary-file (:prefix "ccl-symbols-" :direction :output :pathname path) (require 'elf) (funcall (fdefinition 'ccl::write-elf-symbols-to-file) path) (dump path)) (dump t))) #+(or cmu scl) (progn (ext:gc :full t) (setf ext:*batch-mode* nil) (setf ext::*gc-run-time* 0) (apply 'ext:save-lisp filename #+cmu :executable #+cmu t (when executable '(:init-function restore-image :process-command-line nil)))) #+gcl (progn (si::set-hole-size 500) (si::gbc nil) (si::sgc-on t) (si::save-system filename)) #+lispworks (if executable (lispworks:deliver 'restore-image filename 0 :interface nil) (hcl:save-image filename :environment nil)) #+sbcl (progn ;;(sb-pcl::precompile-random-code-segments) ;--- it is ugly slow at compile-time (!) when the initial core is a big CLOS program. If you want it, do it yourself (setf sb-ext::*gc-run-time* 0) (apply 'sb-ext:save-lisp-and-die filename :executable t ;--- always include the runtime that goes with the core (append (when compression (list :compression compression)) ;;--- only save runtime-options for standalone executables (when executable (list :toplevel #'restore-image :save-runtime-options t)) #+(and sbcl os-windows) ;; passing :application-type :gui will disable the console window. ;; the default is :console - only works with SBCL 1.1.15 or later. (when application-type (list :application-type application-type))))) #-(or allegro clisp clozure cmu gcl lispworks sbcl scl) (error "Can't ~S ~S: UIOP doesn't support image dumping with ~A.~%" 'dump-image filename (nth-value 1 (implementation-type)))) (defun create-image (destination lisp-object-files &key kind output-name prologue-code epilogue-code extra-object-files (prelude () preludep) (postlude () postludep) (entry-point () entry-point-p) build-args no-uiop) (declare (ignorable destination lisp-object-files extra-object-files kind output-name prologue-code epilogue-code prelude preludep postlude postludep entry-point entry-point-p build-args no-uiop)) "On ECL, create an executable at pathname DESTINATION from the specified OBJECT-FILES and options" ;; Is it meaningful to run these in the current environment? ;; only if we also track the object files that constitute the "current" image, ;; and otherwise simulate dump-image, including quitting at the end. #-(or clasp ecl mkcl) (error "~S not implemented for your implementation (yet)" 'create-image) #+(or clasp ecl mkcl) (let ((epilogue-code (if no-uiop epilogue-code (let ((forms (append (when epilogue-code `(,epilogue-code)) (when postludep `((setf *image-postlude* ',postlude))) (when preludep `((setf *image-prelude* ',prelude))) (when entry-point-p `((setf *image-entry-point* ',entry-point))) (case kind ((:image) (setf kind :program) ;; to ECL, it's just another program. `((setf *image-dumped-p* t) (si::top-level #+(or clasp ecl) t) (quit))) ((:program) `((setf *image-dumped-p* :executable) (shell-boolean-exit (restore-image)))))))) (when forms `(progn ,@forms)))))) #+(or clasp ecl) (check-type kind (member :dll :lib :static-library :program :object :fasl)) (apply #+clasp 'cmp:builder #+clasp kind #+(and ecl (not clasp)) 'c::builder #+(and ecl (not clasp)) kind #+mkcl (ecase kind ((:dll) 'compiler::build-shared-library) ((:lib :static-library) 'compiler::build-static-library) ((:fasl) 'compiler::build-bundle) ((:program) 'compiler::build-program)) (pathname destination) #+(or clasp ecl) :lisp-files #+mkcl :lisp-object-files (append lisp-object-files #+(or clasp ecl) extra-object-files) #+(or clasp ecl) :init-name #+(or clasp ecl) (c::compute-init-name (or output-name destination) :kind kind) (append (when prologue-code `(:prologue-code ,prologue-code)) (when epilogue-code `(:epilogue-code ,epilogue-code)) #+mkcl (when extra-object-files `(:object-files ,extra-object-files)) build-args))))) ;;; Some universal image restore hooks (with-upgradability () (map () 'register-image-restore-hook '(setup-stdin setup-stdout setup-stderr setup-command-line-arguments setup-temporary-directory #+abcl detect-os))) ;;;; ------------------------------------------------------------------------- ;;;; run-program initially from xcvb-driver. (uiop/package:define-package :uiop/run-program (:nicknames :asdf/run-program) (:recycle :uiop/run-program :asdf/run-program :xcvb-driver) (:use :uiop/common-lisp :uiop/package :uiop/utility :uiop/pathname :uiop/os :uiop/filesystem :uiop/stream) (:export ;;; Escaping the command invocation madness #:easy-sh-character-p #:escape-sh-token #:escape-sh-command #:escape-windows-token #:escape-windows-command #:escape-token #:escape-command ;;; run-program #:slurp-input-stream #:vomit-output-stream #:run-program #:subprocess-error #:subprocess-error-code #:subprocess-error-command #:subprocess-error-process )) (in-package :uiop/run-program) ;;;; ----- Escaping strings for the shell ----- (with-upgradability () (defun requires-escaping-p (token &key good-chars bad-chars) "Does this token require escaping, given the specification of either good chars that don't need escaping or bad chars that do need escaping, as either a recognizing function or a sequence of characters." (some (cond ((and good-chars bad-chars) (error "only one of good-chars and bad-chars can be provided")) ((typep good-chars 'function) (complement good-chars)) ((typep bad-chars 'function) bad-chars) ((and good-chars (typep good-chars 'sequence)) #'(lambda (c) (not (find c good-chars)))) ((and bad-chars (typep bad-chars 'sequence)) #'(lambda (c) (find c bad-chars))) (t (error "requires-escaping-p: no good-char criterion"))) token)) (defun escape-token (token &key stream quote good-chars bad-chars escaper) "Call the ESCAPER function on TOKEN string if it needs escaping as per REQUIRES-ESCAPING-P using GOOD-CHARS and BAD-CHARS, otherwise output TOKEN, using STREAM as output (or returning result as a string if NIL)" (if (requires-escaping-p token :good-chars good-chars :bad-chars bad-chars) (with-output (stream) (apply escaper token stream (when quote `(:quote ,quote)))) (output-string token stream))) (defun escape-windows-token-within-double-quotes (x &optional s) "Escape a string token X within double-quotes for use within a MS Windows command-line, outputing to S." (labels ((issue (c) (princ c s)) (issue-backslash (n) (loop :repeat n :do (issue #\\)))) (loop :initially (issue #\") :finally (issue #\") :with l = (length x) :with i = 0 :for i+1 = (1+ i) :while (< i l) :do (case (char x i) ((#\") (issue-backslash 1) (issue #\") (setf i i+1)) ((#\\) (let* ((j (and (< i+1 l) (position-if-not #'(lambda (c) (eql c #\\)) x :start i+1))) (n (- (or j l) i))) (cond ((null j) (issue-backslash (* 2 n)) (setf i l)) ((and (< j l) (eql (char x j) #\")) (issue-backslash (1+ (* 2 n))) (issue #\") (setf i (1+ j))) (t (issue-backslash n) (setf i j))))) (otherwise (issue (char x i)) (setf i i+1)))))) (defun easy-windows-character-p (x) "Is X an \"easy\" character that does not require quoting by the shell?" (or (alphanumericp x) (find x "+-_.,@:/="))) (defun escape-windows-token (token &optional s) "Escape a string TOKEN within double-quotes if needed for use within a MS Windows command-line, outputing to S." (escape-token token :stream s :good-chars #'easy-windows-character-p :quote nil :escaper 'escape-windows-token-within-double-quotes)) (defun escape-sh-token-within-double-quotes (x s &key (quote t)) "Escape a string TOKEN within double-quotes for use within a POSIX Bourne shell, outputing to S; omit the outer double-quotes if key argument :QUOTE is NIL" (when quote (princ #\" s)) (loop :for c :across x :do (when (find c "$`\\\"") (princ #\\ s)) (princ c s)) (when quote (princ #\" s))) (defun easy-sh-character-p (x) "Is X an \"easy\" character that does not require quoting by the shell?" (or (alphanumericp x) (find x "+-_.,%@:/="))) (defun escape-sh-token (token &optional s) "Escape a string TOKEN within double-quotes if needed for use within a POSIX Bourne shell, outputing to S." (escape-token token :stream s :quote #\" :good-chars #'easy-sh-character-p :escaper 'escape-sh-token-within-double-quotes)) (defun escape-shell-token (token &optional s) "Escape a token for the current operating system shell" (os-cond ((os-unix-p) (escape-sh-token token s)) ((os-windows-p) (escape-windows-token token s)))) (defun escape-command (command &optional s (escaper 'escape-shell-token)) "Given a COMMAND as a list of tokens, return a string of the spaced, escaped tokens, using ESCAPER to escape." (etypecase command (string (output-string command s)) (list (with-output (s) (loop :for first = t :then nil :for token :in command :do (unless first (princ #\space s)) (funcall escaper token s)))))) (defun escape-windows-command (command &optional s) "Escape a list of command-line arguments into a string suitable for parsing by CommandLineToArgv in MS Windows" ;; http://msdn.microsoft.com/en-us/library/bb776391(v=vs.85).aspx ;; http://msdn.microsoft.com/en-us/library/17w5ykft(v=vs.85).aspx (escape-command command s 'escape-windows-token)) (defun escape-sh-command (command &optional s) "Escape a list of command-line arguments into a string suitable for parsing by /bin/sh in POSIX" (escape-command command s 'escape-sh-token)) (defun escape-shell-command (command &optional stream) "Escape a command for the current operating system's shell" (escape-command command stream 'escape-shell-token))) ;;;; Slurping a stream, typically the output of another program (with-upgradability () (defun call-stream-processor (fun processor stream) "Given FUN (typically SLURP-INPUT-STREAM or VOMIT-OUTPUT-STREAM, a PROCESSOR specification which is either an atom or a list specifying a processor an keyword arguments, call the specified processor with the given STREAM as input" (if (consp processor) (apply fun (first processor) stream (rest processor)) (funcall fun processor stream))) (defgeneric slurp-input-stream (processor input-stream &key) (:documentation "SLURP-INPUT-STREAM is a generic function with two positional arguments PROCESSOR and INPUT-STREAM and additional keyword arguments, that consumes (slurps) the contents of the INPUT-STREAM and processes them according to a method specified by PROCESSOR. Built-in methods include the following: * if PROCESSOR is a function, it is called with the INPUT-STREAM as its argument * if PROCESSOR is a list, its first element should be a function. It will be applied to a cons of the INPUT-STREAM and the rest of the list. That is (x . y) will be treated as \(APPLY x y\) * if PROCESSOR is an output-stream, the contents of INPUT-STREAM is copied to the output-stream, per copy-stream-to-stream, with appropriate keyword arguments. * if PROCESSOR is the symbol CL:STRING or the keyword :STRING, then the contents of INPUT-STREAM are returned as a string, as per SLURP-STREAM-STRING. * if PROCESSOR is the keyword :LINES then the INPUT-STREAM will be handled by SLURP-STREAM-LINES. * if PROCESSOR is the keyword :LINE then the INPUT-STREAM will be handled by SLURP-STREAM-LINE. * if PROCESSOR is the keyword :FORMS then the INPUT-STREAM will be handled by SLURP-STREAM-FORMS. * if PROCESSOR is the keyword :FORM then the INPUT-STREAM will be handled by SLURP-STREAM-FORM. * if PROCESSOR is T, it is treated the same as *standard-output*. If it is NIL, NIL is returned. Programmers are encouraged to define their own methods for this generic function.")) #-genera (defmethod slurp-input-stream ((function function) input-stream &key) (funcall function input-stream)) (defmethod slurp-input-stream ((list cons) input-stream &key) (apply (first list) input-stream (rest list))) #-genera (defmethod slurp-input-stream ((output-stream stream) input-stream &key linewise prefix (element-type 'character) buffer-size) (copy-stream-to-stream input-stream output-stream :linewise linewise :prefix prefix :element-type element-type :buffer-size buffer-size)) (defmethod slurp-input-stream ((x (eql 'string)) stream &key stripped) (slurp-stream-string stream :stripped stripped)) (defmethod slurp-input-stream ((x (eql :string)) stream &key stripped) (slurp-stream-string stream :stripped stripped)) (defmethod slurp-input-stream ((x (eql :lines)) stream &key count) (slurp-stream-lines stream :count count)) (defmethod slurp-input-stream ((x (eql :line)) stream &key (at 0)) (slurp-stream-line stream :at at)) (defmethod slurp-input-stream ((x (eql :forms)) stream &key count) (slurp-stream-forms stream :count count)) (defmethod slurp-input-stream ((x (eql :form)) stream &key (at 0)) (slurp-stream-form stream :at at)) (defmethod slurp-input-stream ((x (eql t)) stream &rest keys &key &allow-other-keys) (apply 'slurp-input-stream *standard-output* stream keys)) (defmethod slurp-input-stream ((x null) (stream t) &key) nil) (defmethod slurp-input-stream ((pathname pathname) input &key (element-type *default-stream-element-type*) (external-format *utf-8-external-format*) (if-exists :rename-and-delete) (if-does-not-exist :create) buffer-size linewise) (with-output-file (output pathname :element-type element-type :external-format external-format :if-exists if-exists :if-does-not-exist if-does-not-exist) (copy-stream-to-stream input output :element-type element-type :buffer-size buffer-size :linewise linewise))) (defmethod slurp-input-stream (x stream &key linewise prefix (element-type 'character) buffer-size) (declare (ignorable stream linewise prefix element-type buffer-size)) (cond #+genera ((functionp x) (funcall x stream)) #+genera ((output-stream-p x) (copy-stream-to-stream stream x :linewise linewise :prefix prefix :element-type element-type :buffer-size buffer-size)) (t (error "Invalid ~S destination ~S" 'slurp-input-stream x))))) (with-upgradability () (defgeneric vomit-output-stream (processor output-stream &key) (:documentation "VOMIT-OUTPUT-STREAM is a generic function with two positional arguments PROCESSOR and OUTPUT-STREAM and additional keyword arguments, that produces (vomits) some content onto the OUTPUT-STREAM, according to a method specified by PROCESSOR. Built-in methods include the following: * if PROCESSOR is a function, it is called with the OUTPUT-STREAM as its argument * if PROCESSOR is a list, its first element should be a function. It will be applied to a cons of the OUTPUT-STREAM and the rest of the list. That is (x . y) will be treated as \(APPLY x y\) * if PROCESSOR is an input-stream, its contents will be copied the OUTPUT-STREAM, per copy-stream-to-stream, with appropriate keyword arguments. * if PROCESSOR is a string, its contents will be printed to the OUTPUT-STREAM. * if PROCESSOR is T, it is treated the same as *standard-input*. If it is NIL, nothing is done. Programmers are encouraged to define their own methods for this generic function.")) #-genera (defmethod vomit-output-stream ((function function) output-stream &key) (funcall function output-stream)) (defmethod vomit-output-stream ((list cons) output-stream &key) (apply (first list) output-stream (rest list))) #-genera (defmethod vomit-output-stream ((input-stream stream) output-stream &key linewise prefix (element-type 'character) buffer-size) (copy-stream-to-stream input-stream output-stream :linewise linewise :prefix prefix :element-type element-type :buffer-size buffer-size)) (defmethod vomit-output-stream ((x string) stream &key fresh-line terpri) (princ x stream) (when fresh-line (fresh-line stream)) (when terpri (terpri stream)) (values)) (defmethod vomit-output-stream ((x (eql t)) stream &rest keys &key &allow-other-keys) (apply 'vomit-output-stream *standard-input* stream keys)) (defmethod vomit-output-stream ((x null) (stream t) &key) (values)) (defmethod vomit-output-stream ((pathname pathname) input &key (element-type *default-stream-element-type*) (external-format *utf-8-external-format*) (if-exists :rename-and-delete) (if-does-not-exist :create) buffer-size linewise) (with-output-file (output pathname :element-type element-type :external-format external-format :if-exists if-exists :if-does-not-exist if-does-not-exist) (copy-stream-to-stream input output :element-type element-type :buffer-size buffer-size :linewise linewise))) (defmethod vomit-output-stream (x stream &key linewise prefix (element-type 'character) buffer-size) (declare (ignorable stream linewise prefix element-type buffer-size)) (cond #+genera ((functionp x) (funcall x stream)) #+genera ((input-stream-p x) (copy-stream-to-stream x stream :linewise linewise :prefix prefix :element-type element-type :buffer-size buffer-size)) (t (error "Invalid ~S source ~S" 'vomit-output-stream x))))) ;;;; ----- Running an external program ----- ;;; Simple variant of run-program with no input, and capturing output ;;; On some implementations, may output to a temporary file... (with-upgradability () (define-condition subprocess-error (error) ((code :initform nil :initarg :code :reader subprocess-error-code) (command :initform nil :initarg :command :reader subprocess-error-command) (process :initform nil :initarg :process :reader subprocess-error-process)) (:report (lambda (condition stream) (format stream "Subprocess ~@[~S~% ~]~@[with command ~S~% ~]exited with error~@[ code ~D~]" (subprocess-error-process condition) (subprocess-error-command condition) (subprocess-error-code condition))))) ;;; find CMD.exe on windows (defun %cmd-shell-pathname () (os-cond ((os-windows-p) (strcat (native-namestring (getenv-absolute-directory "WINDIR")) "System32\\cmd.exe")) (t (error "CMD.EXE is not the command shell for this OS.")))) ;;; Internal helpers for run-program (defun %normalize-command (command) "Given a COMMAND as a list or string, transform it in a format suitable for the implementation's underlying run-program function" (etypecase command #+os-unix (string `("/bin/sh" "-c" ,command)) #+os-unix (list command) #+os-windows (string #+mkcl (list "cmd" "/c" command) ;; NB: We do NOT add cmd /c here. You might want to. #+(or allegro clisp) command ;; On ClozureCL for Windows, we assume you are using ;; r15398 or later in 1.9 or later, ;; so that bug 858 is fixed http://trac.clozure.com/ccl/ticket/858 #+clozure (cons "cmd" (strcat "/c " command)) #+sbcl (list (%cmd-shell-pathname) "/c" command) ;; NB: On other Windows implementations, this is utterly bogus ;; except in the most trivial cases where no quoting is needed. ;; Use at your own risk. #-(or allegro clisp clozure mkcl sbcl) (list "cmd" "/c" command)) #+os-windows (list #+allegro (escape-windows-command command) #-allegro command))) (defun %active-io-specifier-p (specifier) "Determines whether a run-program I/O specifier requires Lisp-side processing via SLURP-INPUT-STREAM or VOMIT-OUTPUT-STREAM (return T), or whether it's already taken care of by the implementation's underlying run-program." (not (typep specifier '(or null string pathname (member :interactive :output) #+(or cmu (and sbcl os-unix) scl) (or stream (eql t)) #+lispworks file-stream)))) ;; not a type!? comm:socket-stream (defun %normalize-io-specifier (specifier &optional role) "Normalizes a portable I/O specifier for %RUN-PROGRAM into an implementation-dependent argument to pass to the internal RUN-PROGRAM" (declare (ignorable role)) (etypecase specifier (null (or #+(or allegro lispworks) (null-device-pathname))) (string (parse-native-namestring specifier)) (pathname specifier) (stream specifier) ((eql :stream) :stream) ((eql :interactive) #+allegro nil #+clisp :terminal #+(or clasp clozure cmu ecl mkcl sbcl scl) t) #+(or allegro clasp clozure cmu ecl lispworks mkcl sbcl scl) ((eql :output) (if (eq role :error-output) :output (error "Wrong specifier ~S for role ~S" specifier role))))) (defun %interactivep (input output error-output) (member :interactive (list input output error-output))) #+clisp (defun clisp-exit-code (raw-exit-code) (typecase raw-exit-code (null 0) ; no error (integer raw-exit-code) ; negative: signal (t -1))) (defun %run-program (command &rest keys &key input (if-input-does-not-exist :error) output (if-output-exists :overwrite) error-output (if-error-output-exists :overwrite) directory wait #+allegro separate-streams &allow-other-keys) "A portable abstraction of a low-level call to the implementation's run-program or equivalent. It spawns a subprocess that runs the specified COMMAND (a list of program and arguments). INPUT, OUTPUT and ERROR-OUTPUT specify a portable IO specifer, to be normalized by %NORMALIZE-IO-SPECIFIER. It returns a process-info plist with possible keys: PROCESS, EXIT-CODE, INPUT-STREAM, OUTPUT-STREAM, BIDIR-STREAM, ERROR-STREAM." ;; NB: these implementations have unix vs windows set at compile-time. (declare (ignorable directory if-input-does-not-exist if-output-exists if-error-output-exists)) (assert (not (and wait (member :stream (list input output error-output))))) #-(or allegro clasp clisp clozure cmu ecl (and lispworks os-unix) mkcl sbcl scl) (progn command keys directory (error "run-program not available")) #+(or allegro clisp clozure cmu ecl (and lispworks os-unix) mkcl sbcl scl) (let* ((%command (%normalize-command command)) (%input (%normalize-io-specifier input :input)) (%output (%normalize-io-specifier output :output)) (%error-output (%normalize-io-specifier error-output :error-output)) #+(and allegro os-windows) (interactive (%interactivep input output error-output)) (process* #+allegro (multiple-value-list (apply 'excl:run-shell-command #+os-unix (coerce (cons (first %command) %command) 'vector) #+os-windows %command :input %input :output %output :error-output %error-output :directory directory :wait wait #+os-windows :show-window #+os-windows (if interactive nil :hide) :allow-other-keys t keys)) #-allegro (with-current-directory (#-(or sbcl mkcl) directory) #+clisp (flet ((run (f x &rest args) (multiple-value-list (apply f x :input %input :output %output :allow-other-keys t `(,@args ,@keys))))) (assert (eq %error-output :terminal)) ;;; since we now always return a code, we can't use this code path, anyway! (etypecase %command #+os-windows (string (run 'ext:run-shell-command %command)) (list (run 'ext:run-program (car %command) :arguments (cdr %command))))) #+(or clasp clozure cmu ecl mkcl sbcl scl) (#-(or clasp ecl mkcl) progn #+(or clasp ecl mkcl) multiple-value-list (apply '#+(or cmu ecl scl) ext:run-program #+clozure ccl:run-program #+sbcl sb-ext:run-program #+mkcl mk-ext:run-program (car %command) (cdr %command) :input %input :output %output :error %error-output :wait wait :allow-other-keys t (append #+(or clozure cmu mkcl sbcl scl) `(:if-input-does-not-exist ,if-input-does-not-exist :if-output-exists ,if-output-exists :if-error-exists ,if-error-output-exists) #+sbcl `(:search t :if-output-does-not-exist :create :if-error-does-not-exist :create) #-sbcl keys #+sbcl (if directory keys (remove-plist-key :directory keys))))) #+(and lispworks os-unix) ;; note: only used on Unix in non-interactive case (multiple-value-list (apply 'system:run-shell-command (cons "/usr/bin/env" %command) ; lispworks wants a full path. :input %input :if-input-does-not-exist if-input-does-not-exist :output %output :if-output-exists if-output-exists :error-output %error-output :if-error-output-exists if-error-output-exists :wait wait :save-exit-status t :allow-other-keys t keys)))) (process-info-r ())) (flet ((prop (key value) (push key process-info-r) (push value process-info-r))) #+allegro (cond (wait (prop :exit-code (first process*))) (separate-streams (destructuring-bind (in out err pid) process* (prop :process pid) (when (eq input :stream) (prop :input-stream in)) (when (eq output :stream) (prop :output-stream out)) (when (eq error-output :stream) (prop :error-stream err)))) (t (prop :process (third process*)) (let ((x (first process*))) (ecase (+ (if (eq input :stream) 1 0) (if (eq output :stream) 2 0)) (0) (1 (prop :input-stream x)) (2 (prop :output-stream x)) (3 (prop :bidir-stream x)))) (when (eq error-output :stream) (prop :error-stream (second process*))))) #+clisp (cond (wait (prop :exit-code (clisp-exit-code (first process*)))) (t (ecase (+ (if (eq input :stream) 1 0) (if (eq output :stream) 2 0)) (0) (1 (prop :input-stream (first process*))) (2 (prop :output-stream (first process*))) (3 (prop :bidir-stream (pop process*)) (prop :input-stream (pop process*)) (prop :output-stream (pop process*)))))) #+(or clozure cmu sbcl scl) (progn (prop :process process*) (when (eq input :stream) (prop :input-stream #+clozure (ccl:external-process-input-stream process*) #+(or cmu scl) (ext:process-input process*) #+sbcl (sb-ext:process-input process*))) (when (eq output :stream) (prop :output-stream #+clozure (ccl:external-process-output-stream process*) #+(or cmu scl) (ext:process-output process*) #+sbcl (sb-ext:process-output process*))) (when (eq error-output :stream) (prop :error-output-stream #+clozure (ccl:external-process-error-stream process*) #+(or cmu scl) (ext:process-error process*) #+sbcl (sb-ext:process-error process*)))) #+(or clasp ecl mkcl) (destructuring-bind #+(or clasp ecl) (stream code process) #+mkcl (stream process code) process* (let ((mode (+ (if (eq input :stream) 1 0) (if (eq output :stream) 2 0)))) (cond ((zerop mode)) ((null process*) (prop :exit-code -1)) (t (prop (case mode (1 :input-stream) (2 :output-stream) (3 :bidir-stream)) stream)))) (when code (prop :exit-code code)) (when process (prop :process process))) #+lispworks (if wait (prop :exit-code (first process*)) (let ((mode (+ (if (eq input :stream) 1 0) (if (eq output :stream) 2 0)))) (if (zerop mode) (prop :process (first process*)) (destructuring-bind (x err pid) process* (prop :process pid) (prop (ecase mode (1 :input-stream) (2 :output-stream) (3 :bidir-stream)) x) (when (eq error-output :stream) (prop :error-stream err)))))) (nreverse process-info-r)))) (defun %process-info-pid (process-info) (let ((process (getf process-info :process))) (declare (ignorable process)) #+(or allegro lispworks) process #+clozure (ccl::external-process-pid process) #+(or clasp ecl) (si:external-process-pid process) #+(or cmu scl) (ext:process-pid process) #+mkcl (mkcl:process-id process) #+sbcl (sb-ext:process-pid process) #-(or allegro cmu mkcl sbcl scl) (error "~S not implemented" '%process-info-pid))) (defun %wait-process-result (process-info) (or (getf process-info :exit-code) (let ((process (getf process-info :process))) (when process ;; 1- wait #+clozure (ccl::external-process-wait process) #+(or cmu scl) (ext:process-wait process) #+sbcl (sb-ext:process-wait process) ;; 2- extract result #+allegro (sys:reap-os-subprocess :pid process :wait t) #+clozure (nth-value 1 (ccl:external-process-status process)) #+(or cmu scl) (ext:process-exit-code process) #+(or clasp ecl) (nth-value 1 (ext:external-process-wait process t)) #+lispworks (if-let ((stream (or (getf process-info :input-stream) (getf process-info :output-stream) (getf process-info :bidir-stream) (getf process-info :error-stream)))) (system:pipe-exit-status stream :wait t) (if-let ((f (find-symbol* :pid-exit-status :system nil))) (funcall f process :wait t))) #+sbcl (sb-ext:process-exit-code process) #+mkcl (mkcl:join-process process))))) (defun %check-result (exit-code &key command process ignore-error-status) (unless ignore-error-status (unless (eql exit-code 0) (cerror "IGNORE-ERROR-STATUS" 'subprocess-error :command command :code exit-code :process process))) exit-code) (defun %call-with-program-io (gf tval stream-easy-p fun direction spec activep returner &key element-type external-format &allow-other-keys) ;; handle redirection for run-program and system ;; SPEC is the specification for the subprocess's input or output or error-output ;; TVAL is the value used if the spec is T ;; GF is the generic function to call to handle arbitrary values of SPEC ;; STREAM-EASY-P is T if we're going to use a RUN-PROGRAM that copies streams in the background ;; (it's only meaningful on CMUCL, SBCL, SCL that actually do it) ;; DIRECTION is :INPUT, :OUTPUT or :ERROR-OUTPUT for the direction of this io argument ;; FUN is a function of the new reduced spec and an activity function to call with a stream ;; when the subprocess is active and communicating through that stream. ;; ACTIVEP is a boolean true if we will get to run code while the process is running ;; ELEMENT-TYPE and EXTERNAL-FORMAT control what kind of temporary file we may open. ;; RETURNER is a function called with the value of the activity. ;; --- TODO (fare@tunes.org): handle if-output-exists and such when doing it the hard way. (declare (ignorable stream-easy-p)) (let* ((actual-spec (if (eq spec t) tval spec)) (activity-spec (if (eq actual-spec :output) (ecase direction ((:input :output) (error "~S not allowed as a ~S ~S spec" :output 'run-program direction)) ((:error-output) nil)) actual-spec))) (labels ((activity (stream) (call-function returner (call-stream-processor gf activity-spec stream))) (easy-case () (funcall fun actual-spec nil)) (hard-case () (if activep (funcall fun :stream #'activity) (with-temporary-file (:pathname tmp) (ecase direction (:input (with-output-file (s tmp :if-exists :overwrite :external-format external-format :element-type element-type) (activity s)) (funcall fun tmp nil)) ((:output :error-output) (multiple-value-prog1 (funcall fun tmp nil) (with-input-file (s tmp :external-format external-format :element-type element-type) (activity s))))))))) (typecase activity-spec ((or null string pathname (eql :interactive)) (easy-case)) #+(or cmu (and sbcl os-unix) scl) ;; streams are only easy on implementations that try very hard (stream (if stream-easy-p (easy-case) (hard-case))) (t (hard-case)))))) (defmacro place-setter (place) (when place (let ((value (gensym))) `#'(lambda (,value) (setf ,place ,value))))) (defmacro with-program-input (((reduced-input-var &optional (input-activity-var (gensym) iavp)) input-form &key setf stream-easy-p active keys) &body body) `(apply '%call-with-program-io 'vomit-output-stream *standard-input* ,stream-easy-p #'(lambda (,reduced-input-var ,input-activity-var) ,@(unless iavp `((declare (ignore ,input-activity-var)))) ,@body) :input ,input-form ,active (place-setter ,setf) ,keys)) (defmacro with-program-output (((reduced-output-var &optional (output-activity-var (gensym) oavp)) output-form &key setf stream-easy-p active keys) &body body) `(apply '%call-with-program-io 'slurp-input-stream *standard-output* ,stream-easy-p #'(lambda (,reduced-output-var ,output-activity-var) ,@(unless oavp `((declare (ignore ,output-activity-var)))) ,@body) :output ,output-form ,active (place-setter ,setf) ,keys)) (defmacro with-program-error-output (((reduced-error-output-var &optional (error-output-activity-var (gensym) eoavp)) error-output-form &key setf stream-easy-p active keys) &body body) `(apply '%call-with-program-io 'slurp-input-stream *error-output* ,stream-easy-p #'(lambda (,reduced-error-output-var ,error-output-activity-var) ,@(unless eoavp `((declare (ignore ,error-output-activity-var)))) ,@body) :error-output ,error-output-form ,active (place-setter ,setf) ,keys)) (defun %use-run-program (command &rest keys &key input output error-output ignore-error-status &allow-other-keys) ;; helper for RUN-PROGRAM when using %run-program #+(or abcl cormanlisp gcl (and lispworks os-windows) mcl xcl) (progn command keys input output error-output ignore-error-status ;; ignore (error "Not implemented on this platform")) (assert (not (member :stream (list input output error-output)))) (let* ((active-input-p (%active-io-specifier-p input)) (active-output-p (%active-io-specifier-p output)) (active-error-output-p (%active-io-specifier-p error-output)) (activity (cond (active-output-p :output) (active-input-p :input) (active-error-output-p :error-output) (t nil))) (wait (not activity)) output-result error-output-result exit-code) (with-program-output ((reduced-output output-activity) output :keys keys :setf output-result :stream-easy-p t :active (eq activity :output)) (with-program-error-output ((reduced-error-output error-output-activity) error-output :keys keys :setf error-output-result :stream-easy-p t :active (eq activity :error-output)) (with-program-input ((reduced-input input-activity) input :keys keys :stream-easy-p t :active (eq activity :input)) (let ((process-info (apply '%run-program command :wait wait :input reduced-input :output reduced-output :error-output (if (eq error-output :output) :output reduced-error-output) keys))) (labels ((get-stream (stream-name &optional fallbackp) (or (getf process-info stream-name) (when fallbackp (getf process-info :bidir-stream)))) (run-activity (activity stream-name &optional fallbackp) (if-let (stream (get-stream stream-name fallbackp)) (funcall activity stream) (error 'subprocess-error :code `(:missing ,stream-name) :command command :process process-info)))) (unwind-protect (ecase activity ((nil)) (:input (run-activity input-activity :input-stream t)) (:output (run-activity output-activity :output-stream t)) (:error-output (run-activity error-output-activity :error-output-stream))) (loop :for (() val) :on process-info :by #'cddr :when (streamp val) :do (ignore-errors (close val))) (setf exit-code (%check-result (%wait-process-result process-info) :command command :process process-info :ignore-error-status ignore-error-status)))))))) (values output-result error-output-result exit-code))) (defun %normalize-system-command (command) ;; helper for %USE-SYSTEM (etypecase command (string (os-cond ((os-windows-p) #+(or allegro clisp) (strcat (%cmd-shell-pathname) " /c " command) #-(or allegro clisp) command) (t command))) (list (escape-shell-command (os-cond ((os-unix-p) (cons "exec" command)) ((os-windows-p) #+(or allegro sbcl clisp) (cons (%cmd-shell-pathname) (cons "/c" command)) #-(or allegro sbcl clisp) command) (t command)))))) (defun %redirected-system-command (command in out err directory) ;; helper for %USE-SYSTEM (flet ((redirect (spec operator) (let ((pathname (typecase spec (null (null-device-pathname)) (string (parse-native-namestring spec)) (pathname spec) ((eql :output) (assert (equal operator " 2>")) (return-from redirect '(" 2>&1")))))) (when pathname (list operator " " (escape-shell-token (native-namestring pathname))))))) (let* ((redirections (append (redirect in " <") (redirect out " >") (redirect err " 2>"))) (normalized (%normalize-system-command command)) (directory (or directory #+(or abcl xcl) (getcwd))) (chdir (when directory (let ((dir-arg (escape-shell-token (native-namestring directory)))) (os-cond ((os-unix-p) `("cd " ,dir-arg " ; ")) ((os-windows-p) `("cd /d " ,dir-arg " & "))))))) (reduce/strcat (os-cond ((os-unix-p) `(,@(when redirections `("exec " ,@redirections " ; ")) ,@chdir ,normalized)) ((os-windows-p) `(,@chdir ,@redirections " " ,normalized))))))) (defun %system (command &rest keys &key input output error-output directory &allow-other-keys) "A portable abstraction of a low-level call to libc's system()." (declare (ignorable input output error-output directory keys)) #+(or allegro clozure cmu (and lispworks os-unix) sbcl scl) (%wait-process-result (apply '%run-program (%normalize-system-command command) :wait t keys)) #+(or abcl clasp clisp cormanlisp ecl gcl genera (and lispworks os-windows) mkcl xcl) (let ((%command (%redirected-system-command command input output error-output directory))) #+(and lispworks os-windows) (system:call-system %command :current-directory directory :wait t) #+clisp (%wait-process-result (apply '%run-program %command :wait t :input :interactive :output :interactive :error-output :interactive keys)) #-(or clisp (and lispworks os-windows)) (with-current-directory ((os-cond ((not (os-unix-p)) directory))) #+abcl (ext:run-shell-command %command) #+cormanlisp (win32:system %command) #+(or clasp ecl) (let ((*standard-input* *stdin*) (*standard-output* *stdout*) (*error-output* *stderr*)) (ext:system %command)) #+gcl (system:system %command) #+genera (error "~S not supported on Genera, cannot run ~S" '%system %command) #+mcl (ccl::with-cstrs ((%%command %command)) (_system %%command)) #+mkcl (mkcl:system %command) #+xcl (system:%run-shell-command %command)))) (defun %use-system (command &rest keys &key input output error-output ignore-error-status &allow-other-keys) ;; helper for RUN-PROGRAM when using %system (let (output-result error-output-result exit-code) (with-program-output ((reduced-output) output :keys keys :setf output-result) (with-program-error-output ((reduced-error-output) error-output :keys keys :setf error-output-result) (with-program-input ((reduced-input) input :keys keys) (setf exit-code (%check-result (apply '%system command :input reduced-input :output reduced-output :error-output reduced-error-output keys) :command command :ignore-error-status ignore-error-status))))) (values output-result error-output-result exit-code))) (defun run-program (command &rest keys &key ignore-error-status (force-shell nil force-shell-suppliedp) (input nil inputp) (if-input-does-not-exist :error) output (if-output-exists :overwrite) (error-output nil error-output-p) (if-error-output-exists :overwrite) (element-type #-clozure *default-stream-element-type* #+clozure 'character) (external-format *utf-8-external-format*) &allow-other-keys) "Run program specified by COMMAND, either a list of strings specifying a program and list of arguments, or a string specifying a shell command (/bin/sh on Unix, CMD.EXE on Windows). Always call a shell (rather than directly execute the command when possible) if FORCE-SHELL is specified. Similarly, never call a shell if FORCE-SHELL is specified to be NIL. Signal a continuable SUBPROCESS-ERROR if the process wasn't successful (exit-code 0), unless IGNORE-ERROR-STATUS is specified. If OUTPUT is a pathname, a string designating a pathname, or NIL designating the null device, the file at that path is used as output. If it's :INTERACTIVE, output is inherited from the current process; beware that this may be different from your *STANDARD-OUTPUT*, and under SLIME will be on your *inferior-lisp* buffer. If it's T, output goes to your current *STANDARD-OUTPUT* stream. Otherwise, OUTPUT should be a value that is a suitable first argument to SLURP-INPUT-STREAM (qv.), or a list of such a value and keyword arguments. In this case, RUN-PROGRAM will create a temporary stream for the program output; the program output, in that stream, will be processed by a call to SLURP-INPUT-STREAM, using OUTPUT as the first argument (or the first element of OUTPUT, and the rest as keywords). The primary value resulting from that call (or NIL if no call was needed) will be the first value returned by RUN-PROGRAM. E.g., using :OUTPUT :STRING will have it return the entire output stream as a string. And using :OUTPUT '(:STRING :STRIPPED T) will have it return the same string stripped of any ending newline. ERROR-OUTPUT is similar to OUTPUT, except that the resulting value is returned as the second value of RUN-PROGRAM. T designates the *ERROR-OUTPUT*. Also :OUTPUT means redirecting the error output to the output stream, in which case NIL is returned. INPUT is similar to OUTPUT, except that VOMIT-OUTPUT-STREAM is used, no value is returned, and T designates the *STANDARD-INPUT*. Use ELEMENT-TYPE and EXTERNAL-FORMAT are passed on to your Lisp implementation, when applicable, for creation of the output stream. One and only one of the stream slurping or vomiting may or may not happen in parallel in parallel with the subprocess, depending on options and implementation, and with priority being given to output processing. Other streams are completely produced or consumed before or after the subprocess is spawned, using temporary files. RUN-PROGRAM returns 3 values: 0- the result of the OUTPUT slurping if any, or NIL 1- the result of the ERROR-OUTPUT slurping if any, or NIL 2- either 0 if the subprocess exited with success status, or an indication of failure via the EXIT-CODE of the process" (declare (ignorable ignore-error-status)) #-(or abcl allegro clasp clisp clozure cmu cormanlisp ecl gcl lispworks mcl mkcl sbcl scl xcl) (error "RUN-PROGRAM not implemented for this Lisp") ;; per doc string, set FORCE-SHELL to T if we get command as a string. But ;; don't override user's specified preference. [2015/06/29:rpg] (when (stringp command) (unless force-shell-suppliedp (setf force-shell t))) (flet ((default (x xp output) (cond (xp x) ((eq output :interactive) :interactive)))) (apply (if (or force-shell #+(or clasp clisp) (or (not ignore-error-status) t) #+clisp (member error-output '(:interactive :output)) ;; old versions of ecl <= 15.3.7 don't support non-trivial :error #+ecl (and (nth-value 1 (ignore-errors (slot-value (ext:make-external-process) 'ext::error-stream))) (not (member error-output '(:interactive :output nil)))) #+(and lispworks os-unix) (%interactivep input output error-output) #+(or abcl cormanlisp gcl (and lispworks os-windows) mcl xcl) t) '%use-system '%use-run-program) command :input (default input inputp output) :error-output (default error-output error-output-p output) :if-input-does-not-exist if-input-does-not-exist :if-output-exists if-output-exists :if-error-output-exists if-error-output-exists :element-type element-type :external-format external-format keys)))) ;;;; ------------------------------------------------------------------------- ;;;; Support to build (compile and load) Lisp files (uiop/package:define-package :uiop/lisp-build (:nicknames :asdf/lisp-build) (:recycle :uiop/lisp-build :asdf/lisp-build :asdf) (:use :uiop/common-lisp :uiop/package :uiop/utility :uiop/os :uiop/pathname :uiop/filesystem :uiop/stream :uiop/image) (:export ;; Variables #:*compile-file-warnings-behaviour* #:*compile-file-failure-behaviour* #:*output-translation-function* #:*optimization-settings* #:*previous-optimization-settings* #:*base-build-directory* #:compile-condition #:compile-file-error #:compile-warned-error #:compile-failed-error #:compile-warned-warning #:compile-failed-warning #:check-lisp-compile-results #:check-lisp-compile-warnings #:*uninteresting-conditions* #:*usual-uninteresting-conditions* #:*uninteresting-compiler-conditions* #:*uninteresting-loader-conditions* ;; Types #+sbcl #:sb-grovel-unknown-constant-condition ;; Functions & Macros #:get-optimization-settings #:proclaim-optimization-settings #:with-optimization-settings #:call-with-muffled-compiler-conditions #:with-muffled-compiler-conditions #:call-with-muffled-loader-conditions #:with-muffled-loader-conditions #:reify-simple-sexp #:unreify-simple-sexp #:reify-deferred-warnings #:unreify-deferred-warnings #:reset-deferred-warnings #:save-deferred-warnings #:check-deferred-warnings #:with-saved-deferred-warnings #:warnings-file-p #:warnings-file-type #:*warnings-file-type* #:enable-deferred-warnings-check #:disable-deferred-warnings-check #:current-lisp-file-pathname #:load-pathname #:lispize-pathname #:compile-file-type #:call-around-hook #:compile-file* #:compile-file-pathname* #:*compile-check* #:load* #:load-from-string #:combine-fasls) (:intern #:defaults #:failure-p #:warnings-p #:s #:y #:body)) (in-package :uiop/lisp-build) (with-upgradability () (defvar *compile-file-warnings-behaviour* (or #+clisp :ignore :warn) "How should ASDF react if it encounters a warning when compiling a file? Valid values are :error, :warn, and :ignore.") (defvar *compile-file-failure-behaviour* (or #+(or mkcl sbcl) :error #+clisp :ignore :warn) "How should ASDF react if it encounters a failure (per the ANSI spec of COMPILE-FILE) when compiling a file, which includes any non-style-warning warning. Valid values are :error, :warn, and :ignore. Note that ASDF ALWAYS raises an error if it fails to create an output file when compiling.") (defvar *base-build-directory* nil "When set to a non-null value, it should be an absolute directory pathname, which will serve as the *DEFAULT-PATHNAME-DEFAULTS* around a COMPILE-FILE, what more while the input-file is shortened if possible to ENOUGH-PATHNAME relative to it. This can help you produce more deterministic output for FASLs.")) ;;; Optimization settings (with-upgradability () (defvar *optimization-settings* nil "Optimization settings to be used by PROCLAIM-OPTIMIZATION-SETTINGS") (defvar *previous-optimization-settings* nil "Optimization settings saved by PROCLAIM-OPTIMIZATION-SETTINGS") (defparameter +optimization-variables+ ;; TODO: allegro genera corman mcl (or #+(or abcl xcl) '(system::*speed* system::*space* system::*safety* system::*debug*) #+clisp '() ;; system::*optimize* is a constant hash-table! (with non-constant contents) #+clozure '(ccl::*nx-speed* ccl::*nx-space* ccl::*nx-safety* ccl::*nx-debug* ccl::*nx-cspeed*) #+(or cmu scl) '(c::*default-cookie*) #+(and ecl (not clasp)) (unless (use-ecl-byte-compiler-p) '(c::*speed* c::*space* c::*safety* c::*debug*)) #+clasp '() #+gcl '(compiler::*speed* compiler::*space* compiler::*compiler-new-safety* compiler::*debug*) #+lispworks '(compiler::*optimization-level*) #+mkcl '(si::*speed* si::*space* si::*safety* si::*debug*) #+sbcl '(sb-c::*policy*))) (defun get-optimization-settings () "Get current compiler optimization settings, ready to PROCLAIM again" #-(or abcl allegro clasp clisp clozure cmu ecl lispworks mkcl sbcl scl xcl) (warn "~S does not support ~S. Please help me fix that." 'get-optimization-settings (implementation-type)) #+(or abcl allegro clasp clisp clozure cmu ecl lispworks mkcl sbcl scl xcl) (let ((settings '(speed space safety debug compilation-speed #+(or cmu scl) c::brevity))) #.`(loop #+(or allegro clozure) ,@'(:with info = #+allegro (sys:declaration-information 'optimize) #+clozure (ccl:declaration-information 'optimize nil)) :for x :in settings ,@(or #+(or abcl clasp ecl gcl mkcl xcl) '(:for v :in +optimization-variables+)) :for y = (or #+(or allegro clozure) (second (assoc x info)) ; normalize order #+clisp (gethash x system::*optimize* 1) #+(or abcl clasp ecl mkcl xcl) (symbol-value v) #+(or cmu scl) (slot-value c::*default-cookie* (case x (compilation-speed 'c::cspeed) (otherwise x))) #+lispworks (slot-value compiler::*optimization-level* x) #+sbcl (sb-c::policy-quality sb-c::*policy* x)) :when y :collect (list x y)))) (defun proclaim-optimization-settings () "Proclaim the optimization settings in *OPTIMIZATION-SETTINGS*" (proclaim `(optimize ,@*optimization-settings*)) (let ((settings (get-optimization-settings))) (unless (equal *previous-optimization-settings* settings) (setf *previous-optimization-settings* settings)))) (defmacro with-optimization-settings ((&optional (settings *optimization-settings*)) &body body) #+(or allegro clisp) (let ((previous-settings (gensym "PREVIOUS-SETTINGS"))) `(let ((,previous-settings (get-optimization-settings))) ,@(when settings `((proclaim `(optimize ,@,settings)))) (unwind-protect (progn ,@body) (proclaim `(optimize ,@,previous-settings))))) #-(or allegro clisp) `(let ,(loop :for v :in +optimization-variables+ :collect `(,v ,v)) ,@(when settings `((proclaim `(optimize ,@,settings)))) ,@body))) ;;; Condition control (with-upgradability () #+sbcl (progn (defun sb-grovel-unknown-constant-condition-p (c) "Detect SB-GROVEL unknown-constant conditions on older versions of SBCL" (and (typep c 'sb-int:simple-style-warning) (string-enclosed-p "Couldn't grovel for " (simple-condition-format-control c) " (unknown to the C compiler)."))) (deftype sb-grovel-unknown-constant-condition () '(and style-warning (satisfies sb-grovel-unknown-constant-condition-p)))) (defvar *usual-uninteresting-conditions* (append ;;#+clozure '(ccl:compiler-warning) #+cmu '("Deleting unreachable code.") #+lispworks '("~S being redefined in ~A (previously in ~A)." "~S defined more than once in ~A.") ;; lispworks gets confused by eval-when. #+sbcl '(sb-c::simple-compiler-note "&OPTIONAL and &KEY found in the same lambda list: ~S" #+sb-eval sb-kernel:lexical-environment-too-complex sb-kernel:undefined-alien-style-warning sb-grovel-unknown-constant-condition ; defined above. sb-ext:implicit-generic-function-warning ;; Controversial. sb-int:package-at-variance sb-kernel:uninteresting-redefinition ;; BEWARE: the below four are controversial to include here. sb-kernel:redefinition-with-defun sb-kernel:redefinition-with-defgeneric sb-kernel:redefinition-with-defmethod sb-kernel::redefinition-with-defmacro) ; not exported by old SBCLs '("No generic function ~S present when encountering macroexpansion of defmethod. Assuming it will be an instance of standard-generic-function.")) ;; from closer2mop "A suggested value to which to set or bind *uninteresting-conditions*.") (defvar *uninteresting-conditions* '() "Conditions that may be skipped while compiling or loading Lisp code.") (defvar *uninteresting-compiler-conditions* '() "Additional conditions that may be skipped while compiling Lisp code.") (defvar *uninteresting-loader-conditions* (append '("Overwriting already existing readtable ~S." ;; from named-readtables #(#:finalizers-off-warning :asdf-finalizers)) ;; from asdf-finalizers #+clisp '(clos::simple-gf-replacing-method-warning)) "Additional conditions that may be skipped while loading Lisp code.")) ;;;; ----- Filtering conditions while building ----- (with-upgradability () (defun call-with-muffled-compiler-conditions (thunk) "Call given THUNK in a context where uninteresting conditions and compiler conditions are muffled" (call-with-muffled-conditions thunk (append *uninteresting-conditions* *uninteresting-compiler-conditions*))) (defmacro with-muffled-compiler-conditions ((&optional) &body body) "Trivial syntax for CALL-WITH-MUFFLED-COMPILER-CONDITIONS" `(call-with-muffled-compiler-conditions #'(lambda () ,@body))) (defun call-with-muffled-loader-conditions (thunk) "Call given THUNK in a context where uninteresting conditions and loader conditions are muffled" (call-with-muffled-conditions thunk (append *uninteresting-conditions* *uninteresting-loader-conditions*))) (defmacro with-muffled-loader-conditions ((&optional) &body body) "Trivial syntax for CALL-WITH-MUFFLED-LOADER-CONDITIONS" `(call-with-muffled-loader-conditions #'(lambda () ,@body)))) ;;;; Handle warnings and failures (with-upgradability () (define-condition compile-condition (condition) ((context-format :initform nil :reader compile-condition-context-format :initarg :context-format) (context-arguments :initform nil :reader compile-condition-context-arguments :initarg :context-arguments) (description :initform nil :reader compile-condition-description :initarg :description)) (:report (lambda (c s) (format s (compatfmt "~@<~A~@[ while ~?~]~@:>") (or (compile-condition-description c) (type-of c)) (compile-condition-context-format c) (compile-condition-context-arguments c))))) (define-condition compile-file-error (compile-condition error) ()) (define-condition compile-warned-warning (compile-condition warning) ()) (define-condition compile-warned-error (compile-condition error) ()) (define-condition compile-failed-warning (compile-condition warning) ()) (define-condition compile-failed-error (compile-condition error) ()) (defun check-lisp-compile-warnings (warnings-p failure-p &optional context-format context-arguments) "Given the warnings or failures as resulted from COMPILE-FILE or checking deferred warnings, raise an error or warning as appropriate" (when failure-p (case *compile-file-failure-behaviour* (:warn (warn 'compile-failed-warning :description "Lisp compilation failed" :context-format context-format :context-arguments context-arguments)) (:error (error 'compile-failed-error :description "Lisp compilation failed" :context-format context-format :context-arguments context-arguments)) (:ignore nil))) (when warnings-p (case *compile-file-warnings-behaviour* (:warn (warn 'compile-warned-warning :description "Lisp compilation had style-warnings" :context-format context-format :context-arguments context-arguments)) (:error (error 'compile-warned-error :description "Lisp compilation had style-warnings" :context-format context-format :context-arguments context-arguments)) (:ignore nil)))) (defun check-lisp-compile-results (output warnings-p failure-p &optional context-format context-arguments) "Given the results of COMPILE-FILE, raise an error or warning as appropriate" (unless output (error 'compile-file-error :context-format context-format :context-arguments context-arguments)) (check-lisp-compile-warnings warnings-p failure-p context-format context-arguments))) ;;;; Deferred-warnings treatment, originally implemented by Douglas Katzman. ;;; ;;; To support an implementation, three functions must be implemented: ;;; reify-deferred-warnings unreify-deferred-warnings reset-deferred-warnings ;;; See their respective docstrings. (with-upgradability () (defun reify-simple-sexp (sexp) "Given a simple SEXP, return a representation of it as a portable SEXP. Simple means made of symbols, numbers, characters, simple-strings, pathnames, cons cells." (etypecase sexp (symbol (reify-symbol sexp)) ((or number character simple-string pathname) sexp) (cons (cons (reify-simple-sexp (car sexp)) (reify-simple-sexp (cdr sexp)))) (simple-vector (vector (mapcar 'reify-simple-sexp (coerce sexp 'list)))))) (defun unreify-simple-sexp (sexp) "Given the portable output of REIFY-SIMPLE-SEXP, return the simple SEXP it represents" (etypecase sexp ((or symbol number character simple-string pathname) sexp) (cons (cons (unreify-simple-sexp (car sexp)) (unreify-simple-sexp (cdr sexp)))) ((simple-vector 2) (unreify-symbol sexp)) ((simple-vector 1) (coerce (mapcar 'unreify-simple-sexp (aref sexp 0)) 'vector)))) #+clozure (progn (defun reify-source-note (source-note) (when source-note (with-accessors ((source ccl::source-note-source) (filename ccl:source-note-filename) (start-pos ccl:source-note-start-pos) (end-pos ccl:source-note-end-pos)) source-note (declare (ignorable source)) (list :filename filename :start-pos start-pos :end-pos end-pos #|:source (reify-source-note source)|#)))) (defun unreify-source-note (source-note) (when source-note (destructuring-bind (&key filename start-pos end-pos source) source-note (ccl::make-source-note :filename filename :start-pos start-pos :end-pos end-pos :source (unreify-source-note source))))) (defun unsymbolify-function-name (name) (if-let (setfed (gethash name ccl::%setf-function-name-inverses%)) `(setf ,setfed) name)) (defun symbolify-function-name (name) (if (and (consp name) (eq (first name) 'setf)) (let ((setfed (second name))) (gethash setfed ccl::%setf-function-names%)) name)) (defun reify-function-name (function-name) (let ((name (or (first function-name) ;; defun: extract the name (let ((sec (second function-name))) (or (and (atom sec) sec) ; scoped method: drop scope (first sec)))))) ; method: keep gf name, drop method specializers (list name))) (defun unreify-function-name (function-name) function-name) (defun nullify-non-literals (sexp) (typecase sexp ((or number character simple-string symbol pathname) sexp) (cons (cons (nullify-non-literals (car sexp)) (nullify-non-literals (cdr sexp)))) (t nil))) (defun reify-deferred-warning (deferred-warning) (with-accessors ((warning-type ccl::compiler-warning-warning-type) (args ccl::compiler-warning-args) (source-note ccl:compiler-warning-source-note) (function-name ccl:compiler-warning-function-name)) deferred-warning (list :warning-type warning-type :function-name (reify-function-name function-name) :source-note (reify-source-note source-note) :args (destructuring-bind (fun &rest more) args (cons (unsymbolify-function-name fun) (nullify-non-literals more)))))) (defun unreify-deferred-warning (reified-deferred-warning) (destructuring-bind (&key warning-type function-name source-note args) reified-deferred-warning (make-condition (or (cdr (ccl::assq warning-type ccl::*compiler-whining-conditions*)) 'ccl::compiler-warning) :function-name (unreify-function-name function-name) :source-note (unreify-source-note source-note) :warning-type warning-type :args (destructuring-bind (fun . more) args (cons (symbolify-function-name fun) more)))))) #+(or cmu scl) (defun reify-undefined-warning (warning) ;; Extracting undefined-warnings from the compilation-unit ;; To be passed through the above reify/unreify link, it must be a "simple-sexp" (list* (c::undefined-warning-kind warning) (c::undefined-warning-name warning) (c::undefined-warning-count warning) (mapcar #'(lambda (frob) ;; the lexenv slot can be ignored for reporting purposes `(:enclosing-source ,(c::compiler-error-context-enclosing-source frob) :source ,(c::compiler-error-context-source frob) :original-source ,(c::compiler-error-context-original-source frob) :context ,(c::compiler-error-context-context frob) :file-name ,(c::compiler-error-context-file-name frob) ; a pathname :file-position ,(c::compiler-error-context-file-position frob) ; an integer :original-source-path ,(c::compiler-error-context-original-source-path frob))) (c::undefined-warning-warnings warning)))) #+sbcl (defun reify-undefined-warning (warning) ;; Extracting undefined-warnings from the compilation-unit ;; To be passed through the above reify/unreify link, it must be a "simple-sexp" (list* (sb-c::undefined-warning-kind warning) (sb-c::undefined-warning-name warning) (sb-c::undefined-warning-count warning) (mapcar #'(lambda (frob) ;; the lexenv slot can be ignored for reporting purposes `(:enclosing-source ,(sb-c::compiler-error-context-enclosing-source frob) :source ,(sb-c::compiler-error-context-source frob) :original-source ,(sb-c::compiler-error-context-original-source frob) :context ,(sb-c::compiler-error-context-context frob) :file-name ,(sb-c::compiler-error-context-file-name frob) ; a pathname :file-position ,(sb-c::compiler-error-context-file-position frob) ; an integer :original-source-path ,(sb-c::compiler-error-context-original-source-path frob))) (sb-c::undefined-warning-warnings warning)))) (defun reify-deferred-warnings () "return a portable S-expression, portably readable and writeable in any Common Lisp implementation using READ within a WITH-SAFE-IO-SYNTAX, that represents the warnings currently deferred by WITH-COMPILATION-UNIT. One of three functions required for deferred-warnings support in ASDF." #+allegro (list :functions-defined excl::.functions-defined. :functions-called excl::.functions-called.) #+clozure (mapcar 'reify-deferred-warning (if-let (dw ccl::*outstanding-deferred-warnings*) (let ((mdw (ccl::ensure-merged-deferred-warnings dw))) (ccl::deferred-warnings.warnings mdw)))) #+(or cmu scl) (when lisp::*in-compilation-unit* ;; Try to send nothing through the pipe if nothing needs to be accumulated `(,@(when c::*undefined-warnings* `((c::*undefined-warnings* ,@(mapcar #'reify-undefined-warning c::*undefined-warnings*)))) ,@(loop :for what :in '(c::*compiler-error-count* c::*compiler-warning-count* c::*compiler-note-count*) :for value = (symbol-value what) :when (plusp value) :collect `(,what . ,value)))) #+sbcl (when sb-c::*in-compilation-unit* ;; Try to send nothing through the pipe if nothing needs to be accumulated `(,@(when sb-c::*undefined-warnings* `((sb-c::*undefined-warnings* ,@(mapcar #'reify-undefined-warning sb-c::*undefined-warnings*)))) ,@(loop :for what :in '(sb-c::*aborted-compilation-unit-count* sb-c::*compiler-error-count* sb-c::*compiler-warning-count* sb-c::*compiler-style-warning-count* sb-c::*compiler-note-count*) :for value = (symbol-value what) :when (plusp value) :collect `(,what . ,value))))) (defun unreify-deferred-warnings (reified-deferred-warnings) "given a S-expression created by REIFY-DEFERRED-WARNINGS, reinstantiate the corresponding deferred warnings as to be handled at the end of the current WITH-COMPILATION-UNIT. Handle any warning that has been resolved already, such as an undefined function that has been defined since. One of three functions required for deferred-warnings support in ASDF." (declare (ignorable reified-deferred-warnings)) #+allegro (destructuring-bind (&key functions-defined functions-called) reified-deferred-warnings (setf excl::.functions-defined. (append functions-defined excl::.functions-defined.) excl::.functions-called. (append functions-called excl::.functions-called.))) #+clozure (let ((dw (or ccl::*outstanding-deferred-warnings* (setf ccl::*outstanding-deferred-warnings* (ccl::%defer-warnings t))))) (appendf (ccl::deferred-warnings.warnings dw) (mapcar 'unreify-deferred-warning reified-deferred-warnings))) #+(or cmu scl) (dolist (item reified-deferred-warnings) ;; Each item is (symbol . adjustment) where the adjustment depends on the symbol. ;; For *undefined-warnings*, the adjustment is a list of initargs. ;; For everything else, it's an integer. (destructuring-bind (symbol . adjustment) item (case symbol ((c::*undefined-warnings*) (setf c::*undefined-warnings* (nconc (mapcan #'(lambda (stuff) (destructuring-bind (kind name count . rest) stuff (unless (case kind (:function (fboundp name))) (list (c::make-undefined-warning :name name :kind kind :count count :warnings (mapcar #'(lambda (x) (apply #'c::make-compiler-error-context x)) rest)))))) adjustment) c::*undefined-warnings*))) (otherwise (set symbol (+ (symbol-value symbol) adjustment)))))) #+sbcl (dolist (item reified-deferred-warnings) ;; Each item is (symbol . adjustment) where the adjustment depends on the symbol. ;; For *undefined-warnings*, the adjustment is a list of initargs. ;; For everything else, it's an integer. (destructuring-bind (symbol . adjustment) item (case symbol ((sb-c::*undefined-warnings*) (setf sb-c::*undefined-warnings* (nconc (mapcan #'(lambda (stuff) (destructuring-bind (kind name count . rest) stuff (unless (case kind (:function (fboundp name))) (list (sb-c::make-undefined-warning :name name :kind kind :count count :warnings (mapcar #'(lambda (x) (apply #'sb-c::make-compiler-error-context x)) rest)))))) adjustment) sb-c::*undefined-warnings*))) (otherwise (set symbol (+ (symbol-value symbol) adjustment))))))) (defun reset-deferred-warnings () "Reset the set of deferred warnings to be handled at the end of the current WITH-COMPILATION-UNIT. One of three functions required for deferred-warnings support in ASDF." #+allegro (setf excl::.functions-defined. nil excl::.functions-called. nil) #+clozure (if-let (dw ccl::*outstanding-deferred-warnings*) (let ((mdw (ccl::ensure-merged-deferred-warnings dw))) (setf (ccl::deferred-warnings.warnings mdw) nil))) #+(or cmu scl) (when lisp::*in-compilation-unit* (setf c::*undefined-warnings* nil c::*compiler-error-count* 0 c::*compiler-warning-count* 0 c::*compiler-note-count* 0)) #+sbcl (when sb-c::*in-compilation-unit* (setf sb-c::*undefined-warnings* nil sb-c::*aborted-compilation-unit-count* 0 sb-c::*compiler-error-count* 0 sb-c::*compiler-warning-count* 0 sb-c::*compiler-style-warning-count* 0 sb-c::*compiler-note-count* 0))) (defun save-deferred-warnings (warnings-file) "Save forward reference conditions so they may be issued at a latter time, possibly in a different process." (with-open-file (s warnings-file :direction :output :if-exists :supersede :element-type *default-stream-element-type* :external-format *utf-8-external-format*) (with-safe-io-syntax () (write (reify-deferred-warnings) :stream s :pretty t :readably t) (terpri s)))) (defun warnings-file-type (&optional implementation-type) "The pathname type for warnings files on given IMPLEMENTATION-TYPE, where NIL designates the current one" (case (or implementation-type *implementation-type*) ((:acl :allegro) "allegro-warnings") ;;((:clisp) "clisp-warnings") ((:cmu :cmucl) "cmucl-warnings") ((:sbcl) "sbcl-warnings") ((:clozure :ccl) "ccl-warnings") ((:scl) "scl-warnings"))) (defvar *warnings-file-type* nil "Pathname type for warnings files, or NIL if disabled") (defun enable-deferred-warnings-check () "Enable the saving of deferred warnings" (setf *warnings-file-type* (warnings-file-type))) (defun disable-deferred-warnings-check () "Disable the saving of deferred warnings" (setf *warnings-file-type* nil)) (defun warnings-file-p (file &optional implementation-type) "Is FILE a saved warnings file for the given IMPLEMENTATION-TYPE? If that given type is NIL, use the currently configured *WARNINGS-FILE-TYPE* instead." (if-let (type (if implementation-type (warnings-file-type implementation-type) *warnings-file-type*)) (equal (pathname-type file) type))) (defun check-deferred-warnings (files &optional context-format context-arguments) "Given a list of FILES containing deferred warnings saved by CALL-WITH-SAVED-DEFERRED-WARNINGS, re-intern and raise any warnings that are still meaningful." (let ((file-errors nil) (failure-p nil) (warnings-p nil)) (handler-bind ((warning #'(lambda (c) (setf warnings-p t) (unless (typep c 'style-warning) (setf failure-p t))))) (with-compilation-unit (:override t) (reset-deferred-warnings) (dolist (file files) (unreify-deferred-warnings (handler-case (safe-read-file-form file) (error (c) ;;(delete-file-if-exists file) ;; deleting forces rebuild but prevents debugging (push c file-errors) nil)))))) (dolist (error file-errors) (error error)) (check-lisp-compile-warnings (or failure-p warnings-p) failure-p context-format context-arguments))) #| Mini-guide to adding support for deferred warnings on an implementation. First, look at what such a warning looks like: (describe (handler-case (and (eval '(lambda () (some-undefined-function))) nil) (t (c) c))) Then you can grep for the condition type in your compiler sources and see how to catch those that have been deferred, and/or read, clear and restore the deferred list. Also look at (macroexpand-1 '(with-compilation-unit () foo)) |# (defun call-with-saved-deferred-warnings (thunk warnings-file &key source-namestring) "If WARNINGS-FILE is not nil, record the deferred-warnings around a call to THUNK and save those warnings to the given file for latter use, possibly in a different process. Otherwise just call THUNK." (declare (ignorable source-namestring)) (if warnings-file (with-compilation-unit (:override t #+sbcl :source-namestring #+sbcl source-namestring) (unwind-protect (let (#+sbcl (sb-c::*undefined-warnings* nil)) (multiple-value-prog1 (funcall thunk) (save-deferred-warnings warnings-file))) (reset-deferred-warnings))) (funcall thunk))) (defmacro with-saved-deferred-warnings ((warnings-file &key source-namestring) &body body) "Trivial syntax for CALL-WITH-SAVED-DEFERRED-WARNINGS" `(call-with-saved-deferred-warnings #'(lambda () ,@body) ,warnings-file :source-namestring ,source-namestring))) ;;; from ASDF (with-upgradability () (defun current-lisp-file-pathname () "Portably return the PATHNAME of the current Lisp source file being compiled or loaded" (or *compile-file-pathname* *load-pathname*)) (defun load-pathname () "Portably return the LOAD-PATHNAME of the current source file or fasl" *load-pathname*) ;; magic no longer needed for GCL. (defun lispize-pathname (input-file) "From a INPUT-FILE pathname, return a corresponding .lisp source pathname" (make-pathname :type "lisp" :defaults input-file)) (defun compile-file-type (&rest keys) "pathname TYPE for lisp FASt Loading files" (declare (ignorable keys)) #-(or clasp ecl mkcl) (load-time-value (pathname-type (compile-file-pathname "foo.lisp"))) #+(or clasp ecl mkcl) (pathname-type (apply 'compile-file-pathname "foo" keys))) (defun call-around-hook (hook function) "Call a HOOK around the execution of FUNCTION" (call-function (or hook 'funcall) function)) (defun compile-file-pathname* (input-file &rest keys &key output-file &allow-other-keys) "Variant of COMPILE-FILE-PATHNAME that works well with COMPILE-FILE*" (let* ((keys (remove-plist-keys `(#+(or (and allegro (not (version>= 8 2)))) :external-format ,@(unless output-file '(:output-file))) keys))) (if (absolute-pathname-p output-file) ;; what cfp should be doing, w/ mp* instead of mp (let* ((type (pathname-type (apply 'compile-file-type keys))) (defaults (make-pathname :type type :defaults (merge-pathnames* input-file)))) (merge-pathnames* output-file defaults)) (funcall *output-translation-function* (apply 'compile-file-pathname input-file keys))))) (defvar *compile-check* nil "A hook for user-defined compile-time invariants") (defun* (compile-file*) (input-file &rest keys &key (compile-check *compile-check*) output-file warnings-file #+clisp lib-file #+(or clasp ecl mkcl) object-file #+sbcl emit-cfasl &allow-other-keys) "This function provides a portable wrapper around COMPILE-FILE. It ensures that the OUTPUT-FILE value is only returned and the file only actually created if the compilation was successful, even though your implementation may not do that, and including an optional call to an user-provided consistency check function COMPILE-CHECK; it will call this function if not NIL at the end of the compilation with the arguments sent to COMPILE-FILE*, except with :OUTPUT-FILE TMP-FILE where TMP-FILE is the name of a temporary output-file. It also checks two flags (with legacy british spelling from ASDF1), *COMPILE-FILE-FAILURE-BEHAVIOUR* and *COMPILE-FILE-WARNINGS-BEHAVIOUR* with appropriate implementation-dependent defaults, and if a failure (respectively warnings) are reported by COMPILE-FILE with consider it an error unless the respective behaviour flag is one of :SUCCESS :WARN :IGNORE. If WARNINGS-FILE is defined, deferred warnings are saved to that file. On ECL or MKCL, it creates both the linkable object and loadable fasl files. On implementations that erroneously do not recognize standard keyword arguments, it will filter them appropriately." #+(or clasp ecl) (when (and object-file (equal (compile-file-type) (pathname object-file))) (format t "Whoa, some funky ASDF upgrade switched ~S calling convention for ~S and ~S~%" 'compile-file* output-file object-file) (rotatef output-file object-file)) (let* ((keywords (remove-plist-keys `(:output-file :compile-check :warnings-file #+clisp :lib-file #+(or clasp ecl mkcl) :object-file) keys)) (output-file (or output-file (apply 'compile-file-pathname* input-file :output-file output-file keywords))) #+(or clasp ecl) (object-file (unless (use-ecl-byte-compiler-p) (or object-file #+ecl(compile-file-pathname output-file :type :object) #+clasp (compile-file-pathname output-file :output-type :object)))) #+mkcl (object-file (or object-file (compile-file-pathname output-file :fasl-p nil))) (tmp-file (tmpize-pathname output-file)) #+sbcl (cfasl-file (etypecase emit-cfasl (null nil) ((eql t) (make-pathname :type "cfasl" :defaults output-file)) (string (parse-namestring emit-cfasl)) (pathname emit-cfasl))) #+sbcl (tmp-cfasl (when cfasl-file (make-pathname :type "cfasl" :defaults tmp-file))) #+clisp (tmp-lib (make-pathname :type "lib" :defaults tmp-file))) (multiple-value-bind (output-truename warnings-p failure-p) (with-enough-pathname (input-file :defaults *base-build-directory*) (with-saved-deferred-warnings (warnings-file :source-namestring (namestring input-file)) (with-muffled-compiler-conditions () (or #-(or clasp ecl mkcl) (apply 'compile-file input-file :output-file tmp-file #+sbcl (if emit-cfasl (list* :emit-cfasl tmp-cfasl keywords) keywords) #-sbcl keywords) #+ecl (apply 'compile-file input-file :output-file (if object-file (list* object-file :system-p t keywords) (list* tmp-file keywords))) #+clasp (apply 'compile-file input-file :output-file (if object-file (list* object-file :output-type :object #|:system-p t|# keywords) (list* tmp-file keywords))) #+mkcl (apply 'compile-file input-file :output-file object-file :fasl-p nil keywords))))) (cond ((and output-truename (flet ((check-flag (flag behaviour) (or (not flag) (member behaviour '(:success :warn :ignore))))) (and (check-flag failure-p *compile-file-failure-behaviour*) (check-flag warnings-p *compile-file-warnings-behaviour*))) (progn #+(or clasp ecl mkcl) (when (and #+(or clasp ecl) object-file) (setf output-truename (compiler::build-fasl tmp-file #+(or clasp ecl) :lisp-files #+mkcl :lisp-object-files (list object-file)))) (or (not compile-check) (apply compile-check input-file :output-file #-(or clasp ecl) output-file #+(or clasp ecl) tmp-file keywords)))) (delete-file-if-exists output-file) (when output-truename #+clasp (when output-truename (rename-file-overwriting-target tmp-file output-truename)) #+clisp (when lib-file (rename-file-overwriting-target tmp-lib lib-file)) #+sbcl (when cfasl-file (rename-file-overwriting-target tmp-cfasl cfasl-file)) (rename-file-overwriting-target output-truename output-file) (setf output-truename (truename output-file))) #+clasp (delete-file-if-exists tmp-file) #+clisp (delete-file-if-exists tmp-lib)) (t ;; error or failed check (delete-file-if-exists output-truename) #+clisp (delete-file-if-exists tmp-lib) #+sbcl (delete-file-if-exists tmp-cfasl) (setf output-truename nil))) (values output-truename warnings-p failure-p)))) (defun load* (x &rest keys &key &allow-other-keys) "Portable wrapper around LOAD that properly handles loading from a stream." (with-muffled-loader-conditions () (etypecase x ((or pathname string #-(or allegro clozure genera) stream #+clozure file-stream) (apply 'load x keys)) ;; Genera can't load from a string-input-stream ;; ClozureCL 1.6 can only load from file input stream ;; Allegro 5, I don't remember but it must have been broken when I tested. #+(or allegro clozure genera) (stream ;; make do this way (let ((*package* *package*) (*readtable* *readtable*) (*load-pathname* nil) (*load-truename* nil)) (eval-input x)))))) (defun load-from-string (string) "Portably read and evaluate forms from a STRING." (with-input-from-string (s string) (load* s)))) ;;; Links FASLs together (with-upgradability () (defun combine-fasls (inputs output) "Combine a list of FASLs INPUTS into a single FASL OUTPUT" #-(or abcl allegro clisp clozure cmu lispworks sbcl scl xcl) (error "~A does not support ~S~%inputs ~S~%output ~S" (implementation-type) 'combine-fasls inputs output) #+abcl (funcall 'sys::concatenate-fasls inputs output) ; requires ABCL 1.2.0 #+(or allegro clisp cmu sbcl scl xcl) (concatenate-files inputs output) #+clozure (ccl:fasl-concatenate output inputs :if-exists :supersede) #+lispworks (let (fasls) (unwind-protect (progn (loop :for i :in inputs :for n :from 1 :for f = (add-pathname-suffix output (format nil "-FASL~D" n)) :do (copy-file i f) (push f fasls)) (ignore-errors (lispworks:delete-system :fasls-to-concatenate)) (eval `(scm:defsystem :fasls-to-concatenate (:default-pathname ,(pathname-directory-pathname output)) :members ,(loop :for f :in (reverse fasls) :collect `(,(namestring f) :load-only t)))) (scm:concatenate-system output :fasls-to-concatenate)) (loop :for f :in fasls :do (ignore-errors (delete-file f))) (ignore-errors (lispworks:delete-system :fasls-to-concatenate)))))) ;;;; --------------------------------------------------------------------------- ;;;; Generic support for configuration files (uiop/package:define-package :uiop/configuration (:nicknames :asdf/configuration) (:recycle :uiop/configuration :asdf/configuration :asdf) (:use :uiop/common-lisp :uiop/utility :uiop/os :uiop/pathname :uiop/filesystem :uiop/stream :uiop/image :uiop/lisp-build) (:export #:user-configuration-directories #:system-configuration-directories ;; implemented in backward-driver #:in-first-directory #:in-user-configuration-directory #:in-system-configuration-directory ;; idem #:get-folder-path #:xdg-data-home #:xdg-config-home #:xdg-data-dirs #:xdg-config-dirs #:xdg-cache-home #:xdg-runtime-dir #:system-config-pathnames #:filter-pathname-set #:xdg-data-pathnames #:xdg-config-pathnames #:find-preferred-file #:xdg-data-pathname #:xdg-config-pathname #:validate-configuration-form #:validate-configuration-file #:validate-configuration-directory #:configuration-inheritance-directive-p #:report-invalid-form #:invalid-configuration #:*ignored-configuration-form* #:*user-cache* #:*clear-configuration-hook* #:clear-configuration #:register-clear-configuration-hook #:resolve-location #:location-designator-p #:location-function-p #:*here-directory* #:resolve-relative-location #:resolve-absolute-location #:upgrade-configuration)) (in-package :uiop/configuration) (with-upgradability () (define-condition invalid-configuration () ((form :reader condition-form :initarg :form) (location :reader condition-location :initarg :location) (format :reader condition-format :initarg :format) (arguments :reader condition-arguments :initarg :arguments :initform nil)) (:report (lambda (c s) (format s (compatfmt "~@<~? (will be skipped)~@:>") (condition-format c) (list* (condition-form c) (condition-location c) (condition-arguments c)))))) (defun configuration-inheritance-directive-p (x) "Is X a configuration inheritance directive?" (let ((kw '(:inherit-configuration :ignore-inherited-configuration))) (or (member x kw) (and (length=n-p x 1) (member (car x) kw))))) (defun report-invalid-form (reporter &rest args) "Report an invalid form according to REPORTER and various ARGS" (etypecase reporter (null (apply 'error 'invalid-configuration args)) (function (apply reporter args)) ((or symbol string) (apply 'error reporter args)) (cons (apply 'apply (append reporter args))))) (defvar *ignored-configuration-form* nil "Have configuration forms been ignored while parsing the configuration?") (defun validate-configuration-form (form tag directive-validator &key location invalid-form-reporter) "Validate a configuration FORM. By default it will raise an error if the FORM is not valid. Otherwise it will return the validated form. Arguments control the behavior: The configuration FORM should be of the form (TAG . ) Each element of will be checked by first seeing if it's a configuration inheritance directive (see CONFIGURATION-INHERITANCE-DIRECTIVE-P) then invoking DIRECTIVE-VALIDATOR on it. In the event of an invalid form, INVALID-FORM-REPORTER will be used to control reporting (see REPORT-INVALID-FORM) with LOCATION providing information about where the configuration form appeared." (unless (and (consp form) (eq (car form) tag)) (setf *ignored-configuration-form* t) (report-invalid-form invalid-form-reporter :form form :location location) (return-from validate-configuration-form nil)) (loop :with inherit = 0 :with ignore-invalid-p = nil :with x = (list tag) :for directive :in (cdr form) :when (cond ((configuration-inheritance-directive-p directive) (incf inherit) t) ((eq directive :ignore-invalid-entries) (setf ignore-invalid-p t) t) ((funcall directive-validator directive) t) (ignore-invalid-p nil) (t (setf *ignored-configuration-form* t) (report-invalid-form invalid-form-reporter :form directive :location location) nil)) :do (push directive x) :finally (unless (= inherit 1) (report-invalid-form invalid-form-reporter :form form :location location ;; we throw away the form and location arguments, hence the ~2* ;; this is necessary because of the report in INVALID-CONFIGURATION :format (compatfmt "~@") :arguments '(:inherit-configuration :ignore-inherited-configuration))) (return (nreverse x)))) (defun validate-configuration-file (file validator &key description) "Validate a configuration FILE. The configuration file should have only one s-expression in it, which will be checked with the VALIDATOR FORM. DESCRIPTION argument used for error reporting." (let ((forms (read-file-forms file))) (unless (length=n-p forms 1) (error (compatfmt "~@~%") description forms)) (funcall validator (car forms) :location file))) (defun validate-configuration-directory (directory tag validator &key invalid-form-reporter) "Map the VALIDATOR across the .conf files in DIRECTORY, the TAG will be applied to the results to yield a configuration form. Current values of TAG include :source-registry and :output-translations." (let ((files (sort (ignore-errors ;; SORT w/o COPY-LIST is OK: DIRECTORY returns a fresh list (remove-if 'hidden-pathname-p (directory* (make-pathname :name *wild* :type "conf" :defaults directory)))) #'string< :key #'namestring))) `(,tag ,@(loop :for file :in files :append (loop :with ignore-invalid-p = nil :for form :in (read-file-forms file) :when (eq form :ignore-invalid-entries) :do (setf ignore-invalid-p t) :else :when (funcall validator form) :collect form :else :when ignore-invalid-p :do (setf *ignored-configuration-form* t) :else :do (report-invalid-form invalid-form-reporter :form form :location file))) :inherit-configuration))) (defun resolve-relative-location (x &key ensure-directory wilden) "Given a designator X for an relative location, resolve it to a pathname." (ensure-pathname (etypecase x (null nil) (pathname x) (string (parse-unix-namestring x :ensure-directory ensure-directory)) (cons (if (null (cdr x)) (resolve-relative-location (car x) :ensure-directory ensure-directory :wilden wilden) (let* ((car (resolve-relative-location (car x) :ensure-directory t :wilden nil))) (merge-pathnames* (resolve-relative-location (cdr x) :ensure-directory ensure-directory :wilden wilden) car)))) ((eql :*/) *wild-directory*) ((eql :**/) *wild-inferiors*) ((eql :*.*.*) *wild-file*) ((eql :implementation) (parse-unix-namestring (implementation-identifier) :ensure-directory t)) ((eql :implementation-type) (parse-unix-namestring (string-downcase (implementation-type)) :ensure-directory t)) ((eql :hostname) (parse-unix-namestring (hostname) :ensure-directory t))) :wilden (and wilden (not (pathnamep x)) (not (member x '(:*/ :**/ :*.*.*)))) :want-relative t)) (defvar *here-directory* nil "This special variable is bound to the currect directory during calls to PROCESS-SOURCE-REGISTRY in order that we be able to interpret the :here directive.") (defvar *user-cache* nil "A specification as per RESOLVE-LOCATION of where the user keeps his FASL cache") (defun resolve-absolute-location (x &key ensure-directory wilden) "Given a designator X for an absolute location, resolve it to a pathname" (ensure-pathname (etypecase x (null nil) (pathname x) (string (let ((p #-mcl (parse-namestring x) #+mcl (probe-posix x))) #+mcl (unless p (error "POSIX pathname ~S does not exist" x)) (if ensure-directory (ensure-directory-pathname p) p))) (cons (return-from resolve-absolute-location (if (null (cdr x)) (resolve-absolute-location (car x) :ensure-directory ensure-directory :wilden wilden) (merge-pathnames* (resolve-relative-location (cdr x) :ensure-directory ensure-directory :wilden wilden) (resolve-absolute-location (car x) :ensure-directory t :wilden nil))))) ((eql :root) ;; special magic! we return a relative pathname, ;; but what it means to the output-translations is ;; "relative to the root of the source pathname's host and device". (return-from resolve-absolute-location (let ((p (make-pathname* :directory '(:relative)))) (if wilden (wilden p) p)))) ((eql :home) (user-homedir-pathname)) ((eql :here) (resolve-absolute-location (or *here-directory* (pathname-directory-pathname (load-pathname))) :ensure-directory t :wilden nil)) ((eql :user-cache) (resolve-absolute-location *user-cache* :ensure-directory t :wilden nil))) :wilden (and wilden (not (pathnamep x))) :resolve-symlinks *resolve-symlinks* :want-absolute t)) ;; Try to override declaration in previous versions of ASDF. (declaim (ftype (function (t &key (:directory boolean) (:wilden boolean) (:ensure-directory boolean)) t) resolve-location)) (defun* (resolve-location) (x &key ensure-directory wilden directory) "Resolve location designator X into a PATHNAME" ;; :directory backward compatibility, until 2014-01-16: accept directory as well as ensure-directory (loop* :with dirp = (or directory ensure-directory) :with (first . rest) = (if (atom x) (list x) x) :with path = (or (resolve-absolute-location first :ensure-directory (and (or dirp rest) t) :wilden (and wilden (null rest))) (return nil)) :for (element . morep) :on rest :for dir = (and (or morep dirp) t) :for wild = (and wilden (not morep)) :for sub = (merge-pathnames* (resolve-relative-location element :ensure-directory dir :wilden wild) path) :do (setf path (if (absolute-pathname-p sub) (resolve-symlinks* sub) sub)) :finally (return path))) (defun location-designator-p (x) "Is X a designator for a location?" ;; NIL means "skip this entry", or as an output translation, same as translation input. ;; T means "any input" for a translation, or as output, same as translation input. (flet ((absolute-component-p (c) (typep c '(or string pathname (member :root :home :here :user-cache)))) (relative-component-p (c) (typep c '(or string pathname (member :*/ :**/ :*.*.* :implementation :implementation-type))))) (or (typep x 'boolean) (absolute-component-p x) (and (consp x) (absolute-component-p (first x)) (every #'relative-component-p (rest x)))))) (defun location-function-p (x) "Is X the specification of a location function?" ;; Location functions are allowed in output translations, and notably used by ABCL for JAR file support. (and (length=n-p x 2) (eq (car x) :function))) (defvar *clear-configuration-hook* '()) (defun register-clear-configuration-hook (hook-function &optional call-now-p) "Register a function to be called when clearing configuration" (register-hook-function '*clear-configuration-hook* hook-function call-now-p)) (defun clear-configuration () "Call the functions in *CLEAR-CONFIGURATION-HOOK*" (call-functions *clear-configuration-hook*)) (register-image-dump-hook 'clear-configuration) (defun upgrade-configuration () "If a previous version of ASDF failed to read some configuration, try again now." (when *ignored-configuration-form* (clear-configuration) (setf *ignored-configuration-form* nil))) (defun get-folder-path (folder) "Semi-portable implementation of a subset of LispWorks' sys:get-folder-path, this function tries to locate the Windows FOLDER for one of :LOCAL-APPDATA, :APPDATA or :COMMON-APPDATA. Returns NIL when the folder is not defined (e.g., not on Windows)." (or #+(and lispworks mswindows) (sys:get-folder-path folder) ;; read-windows-registry HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\User Shell Folders\AppData (ecase folder (:local-appdata (or (getenv-absolute-directory "LOCALAPPDATA") (subpathname* (get-folder-path :appdata) "Local"))) (:appdata (getenv-absolute-directory "APPDATA")) (:common-appdata (or (getenv-absolute-directory "ALLUSERSAPPDATA") (subpathname* (getenv-absolute-directory "ALLUSERSPROFILE") "Application Data/")))))) ;; Support for the XDG Base Directory Specification (defun xdg-data-home (&rest more) "Returns an absolute pathname for the directory containing user-specific data files. MORE may contain specifications for a subpath relative to this directory: a subpathname specification and keyword arguments as per RESOLVE-LOCATION \(see also \"Configuration DSL\"\) in the ASDF manual." (resolve-absolute-location `(,(or (getenv-absolute-directory "XDG_DATA_HOME") (os-cond ((os-windows-p) (get-folder-path :local-appdata)) (t (subpathname (user-homedir-pathname) ".local/share/")))) ,more))) (defun xdg-config-home (&rest more) "Returns a pathname for the directory containing user-specific configuration files. MORE may contain specifications for a subpath relative to this directory: a subpathname specification and keyword arguments as per RESOLVE-LOCATION \(see also \"Configuration DSL\"\) in the ASDF manual." (resolve-absolute-location `(,(or (getenv-absolute-directory "XDG_CONFIG_HOME") (os-cond ((os-windows-p) (xdg-data-home "config/")) (t (subpathname (user-homedir-pathname) ".config/")))) ,more))) (defun xdg-data-dirs (&rest more) "The preference-ordered set of additional paths to search for data files. Returns a list of absolute directory pathnames. MORE may contain specifications for a subpath relative to these directories: a subpathname specification and keyword arguments as per RESOLVE-LOCATION \(see also \"Configuration DSL\"\) in the ASDF manual." (mapcar #'(lambda (d) (resolve-location `(,d ,more))) (or (getenv-absolute-directories "XDG_DATA_DIRS") (os-cond ((os-windows-p) (mapcar 'get-folder-path '(:appdata :common-appdata))) (t (mapcar 'parse-unix-namestring '("/usr/local/share/" "/usr/share/"))))))) (defun xdg-config-dirs (&rest more) "The preference-ordered set of additional base paths to search for configuration files. Returns a list of absolute directory pathnames. MORE may contain specifications for a subpath relative to these directories: subpathname specification and keyword arguments as per RESOLVE-LOCATION \(see also \"Configuration DSL\"\) in the ASDF manual." (mapcar #'(lambda (d) (resolve-location `(,d ,more))) (or (getenv-absolute-directories "XDG_CONFIG_DIRS") (os-cond ((os-windows-p) (xdg-data-dirs "config/")) (t (mapcar 'parse-unix-namestring '("/etc/xdg/"))))))) (defun xdg-cache-home (&rest more) "The base directory relative to which user specific non-essential data files should be stored. Returns an absolute directory pathname. MORE may contain specifications for a subpath relative to this directory: a subpathname specification and keyword arguments as per RESOLVE-LOCATION \(see also \"Configuration DSL\"\) in the ASDF manual." (resolve-absolute-location `(,(or (getenv-absolute-directory "XDG_CACHE_HOME") (os-cond ((os-windows-p) (xdg-data-home "cache")) (t (subpathname* (user-homedir-pathname) ".cache/")))) ,more))) (defun xdg-runtime-dir (&rest more) "Pathname for user-specific non-essential runtime files and other file objects, such as sockets, named pipes, etc. Returns an absolute directory pathname. MORE may contain specifications for a subpath relative to this directory: a subpathname specification and keyword arguments as per RESOLVE-LOCATION \(see also \"Configuration DSL\"\) in the ASDF manual." ;; The XDG spec says that if not provided by the login system, the application should ;; issue a warning and provide a replacement. UIOP is not equipped to do that and returns NIL. (resolve-absolute-location `(,(getenv-absolute-directory "XDG_RUNTIME_DIR") ,more))) ;;; NOTE: modified the docstring because "system user configuration ;;; directories" seems self-contradictory. I'm not sure my wording is right. (defun system-config-pathnames (&rest more) "Return a list of directories where are stored the system's default user configuration information. MORE may contain specifications for a subpath relative to these directories: a subpathname specification and keyword arguments as per RESOLVE-LOCATION \(see also \"Configuration DSL\"\) in the ASDF manual." (declare (ignorable more)) (os-cond ((os-unix-p) (list (resolve-absolute-location `(,(parse-unix-namestring "/etc/") ,more)))))) (defun filter-pathname-set (dirs) "Parse strings as unix namestrings and remove duplicates and non absolute-pathnames in a list." (remove-duplicates (remove-if-not #'absolute-pathname-p dirs) :from-end t :test 'equal)) (defun xdg-data-pathnames (&rest more) "Return a list of absolute pathnames for application data directories. With APP, returns directory for data for that application, without APP, returns the set of directories for storing all application configurations. MORE may contain specifications for a subpath relative to these directories: a subpathname specification and keyword arguments as per RESOLVE-LOCATION \(see also \"Configuration DSL\"\) in the ASDF manual." (filter-pathname-set `(,(xdg-data-home more) ,@(xdg-data-dirs more)))) (defun xdg-config-pathnames (&rest more) "Return a list of pathnames for application configuration. MORE may contain specifications for a subpath relative to these directories: a subpathname specification and keyword arguments as per RESOLVE-LOCATION \(see also \"Configuration DSL\"\) in the ASDF manual." (filter-pathname-set `(,(xdg-config-home more) ,@(xdg-config-dirs more)))) (defun find-preferred-file (files &key (direction :input)) "Find first file in the list of FILES that exists (for direction :input or :probe) or just the first one (for direction :output or :io). Note that when we say \"file\" here, the files in question may be directories." (find-if (ecase direction ((:probe :input) 'probe-file*) ((:output :io) 'identity)) files)) (defun xdg-data-pathname (&optional more (direction :input)) (find-preferred-file (xdg-data-pathnames more) :direction direction)) (defun xdg-config-pathname (&optional more (direction :input)) (find-preferred-file (xdg-config-pathnames more) :direction direction)) (defun compute-user-cache () "Compute (and return) the location of the default user-cache for translate-output objects. Side-effects for cached file location computation." (setf *user-cache* (xdg-cache-home "common-lisp" :implementation))) (register-image-restore-hook 'compute-user-cache)) ;;;; ------------------------------------------------------------------------- ;;; Hacks for backward-compatibility of the driver (uiop/package:define-package :uiop/backward-driver (:nicknames :asdf/backward-driver) (:recycle :uiop/backward-driver :asdf/backward-driver :asdf) (:use :uiop/common-lisp :uiop/package :uiop/utility :uiop/pathname :uiop/stream :uiop/os :uiop/image :uiop/run-program :uiop/lisp-build :uiop/configuration) (:export #:coerce-pathname #:component-name-to-pathname-components #+(or clasp ecl mkcl) #:compile-file-keeping-object #:user-configuration-directories #:system-configuration-directories #:in-first-directory #:in-user-configuration-directory #:in-system-configuration-directory )) (in-package :uiop/backward-driver) ;;;; Backward compatibility with various pathname functions. (with-upgradability () (defun coerce-pathname (name &key type defaults) ;; For backward-compatibility only, for people using internals ;; Reported users in quicklisp: hu.dwim.asdf, asdf-utils, xcvb ;; Will be removed after 2014-01-16. ;;(warn "Please don't use ASDF::COERCE-PATHNAME. Use ASDF/PATHNAME:PARSE-UNIX-NAMESTRING.") (parse-unix-namestring name :type type :defaults defaults)) (defun component-name-to-pathname-components (unix-style-namestring &key force-directory force-relative) ;; Will be removed after 2014-01-16. ;; (warn "Please don't use ASDF::COMPONENT-NAME-TO-PATHNAME-COMPONENTS, use SPLIT-UNIX-NAMESTRING-DIRECTORY-COMPONENTS") (multiple-value-bind (relabs path filename file-only) (split-unix-namestring-directory-components unix-style-namestring :ensure-directory force-directory) (declare (ignore file-only)) (when (and force-relative (not (eq relabs :relative))) (error (compatfmt "~@") unix-style-namestring)) (values relabs path filename))) #+(or clasp ecl mkcl) (defun compile-file-keeping-object (&rest args) (apply #'compile-file* args)) ;; Backward compatibility for ASDF 2.27 to 3.1.4 (defun user-configuration-directories () "Return the current user's list of user configuration directories for configuring common-lisp. DEPRECATED. Use uiop:xdg-config-pathnames instead." (xdg-config-pathnames "common-lisp")) (defun system-configuration-directories () "Return the list of system configuration directories for common-lisp. DEPRECATED. Use uiop:config-system-pathnames instead." (system-config-pathnames "common-lisp")) (defun in-first-directory (dirs x &key (direction :input)) "Finds the first appropriate file named X in the list of DIRS for I/O in DIRECTION \(which may be :INPUT, :OUTPUT, :IO, or :PROBE). If direction is :INPUT or :PROBE, will return the first extant file named X in one of the DIRS. If direction is :OUTPUT or :IO, will simply return the file named X in the first element of DIRS that exists. DEPRECATED." (find-preferred-file (mapcar #'(lambda (dir) (subpathname (ensure-directory-pathname dir) x)) dirs) :direction direction)) (defun in-user-configuration-directory (x &key (direction :input)) "Return the file named X in the user configuration directory for common-lisp. DEPRECATED." (xdg-config-pathname `("common-lisp" ,x) direction)) (defun in-system-configuration-directory (x &key (direction :input)) "Return the pathname for the file named X under the system configuration directory for common-lisp. DEPRECATED." (find-preferred-file (system-config-pathnames "common-lisp" x) :direction direction))) ;;;; --------------------------------------------------------------------------- ;;;; Re-export all the functionality in UIOP (uiop/package:define-package :uiop/driver (:nicknames :uiop :asdf/driver :asdf-driver :asdf-utils) (:use :uiop/common-lisp) ;; NB: not reexporting uiop/common-lisp ;; which include all of CL with compatibility modifications on select platforms, ;; that could cause potential conflicts for packages that would :use (cl uiop) ;; or :use (closer-common-lisp uiop), etc. (:use-reexport :uiop/package :uiop/utility :uiop/os :uiop/pathname :uiop/stream :uiop/filesystem :uiop/image :uiop/run-program :uiop/lisp-build :uiop/configuration :uiop/backward-driver)) ;; Provide both lowercase and uppercase, to satisfy more people. (provide "uiop") (provide "UIOP") ;;;; ------------------------------------------------------------------------- ;;;; Handle upgrade as forward- and backward-compatibly as possible ;; See https://bugs.launchpad.net/asdf/+bug/485687 (uiop/package:define-package :asdf/upgrade (:recycle :asdf/upgrade :asdf) (:use :uiop/common-lisp :uiop) (:export #:asdf-version #:*previous-asdf-versions* #:*asdf-version* #:asdf-message #:*verbose-out* #:upgrading-p #:when-upgrading #:upgrade-asdf #:asdf-upgrade-error #:defparameter* #:*post-upgrade-cleanup-hook* #:*post-upgrade-restart-hook* #:cleanup-upgraded-asdf ;; There will be no symbol left behind! #:intern*) (:import-from :uiop/package #:intern* #:find-symbol*)) (in-package :asdf/upgrade) ;;; Special magic to detect if this is an upgrade (with-upgradability () (defun asdf-version () "Exported interface to the version of ASDF currently installed. A string. You can compare this string with e.g.: (ASDF:VERSION-SATISFIES (ASDF:ASDF-VERSION) \"3.4.5.67\")." (when (find-package :asdf) (or (symbol-value (find-symbol (string :*asdf-version*) :asdf)) (let* ((revsym (find-symbol (string :*asdf-revision*) :asdf)) (rev (and revsym (boundp revsym) (symbol-value revsym)))) (etypecase rev (string rev) (cons (format nil "~{~D~^.~}" rev)) (null "1.0")))))) ;; Important: define *p-a-v* /before/ *a-v* so that it initializes correctly. (defvar *previous-asdf-versions* (if-let (previous (asdf-version)) (list previous))) (defvar *asdf-version* nil) ;; We need to clear systems from versions yet older than the below: (defparameter *oldest-forward-compatible-asdf-version* "2.33") ;; 2.32.13 renames a slot in component. (defvar *verbose-out* nil) (defun asdf-message (format-string &rest format-args) (when *verbose-out* (apply 'format *verbose-out* format-string format-args))) (defvar *post-upgrade-cleanup-hook* ()) (defvar *post-upgrade-restart-hook* ()) (defun upgrading-p (&optional (oldest-compatible-version *oldest-forward-compatible-asdf-version*)) (and *previous-asdf-versions* (version< (first *previous-asdf-versions*) oldest-compatible-version))) (defmacro defparameter* (var value &optional docstring (version *oldest-forward-compatible-asdf-version*)) (let* ((name (string-trim "*" var)) (valfun (intern (format nil "%~A-~A-~A" :compute name :value)))) `(progn (defun ,valfun () ,value) (defvar ,var (,valfun) ,@(ensure-list docstring)) (when (upgrading-p ,version) (setf ,var (,valfun)))))) (defmacro when-upgrading ((&key (version *oldest-forward-compatible-asdf-version*) (upgrading-p `(upgrading-p ,version)) when) &body body) "A wrapper macro for code that should only be run when upgrading a previously-loaded version of ASDF." `(with-upgradability () (when (and ,upgrading-p ,@(when when `(,when))) (handler-bind ((style-warning #'muffle-warning)) (eval '(progn ,@body)))))) (let* (;; For bug reporting sanity, please always bump this version when you modify this file. ;; Please also modify asdf.asd to reflect this change. make bump-version v=3.4.5.67.8 ;; can help you do these changes in synch (look at the source for documentation). ;; Relying on its automation, the version is now redundantly present on top of asdf.lisp. ;; "3.4" would be the general branch for major version 3, minor version 4. ;; "3.4.5" would be an official release in the 3.4 branch. ;; "3.4.5.67" would be a development version in the official branch, on top of 3.4.5. ;; "3.4.5.0.8" would be your eighth local modification of official release 3.4.5 ;; "3.4.5.67.8" would be your eighth local modification of development version 3.4.5.67 (asdf-version "3.1.5.4") (existing-version (asdf-version))) (setf *asdf-version* asdf-version) (when (and existing-version (not (equal asdf-version existing-version))) (push existing-version *previous-asdf-versions*) (when (or *verbose-out* *load-verbose*) (format (or *verbose-out* *trace-output*) (compatfmt "~&~@<; ~@;Upgrading ASDF ~@[from version ~A ~]to version ~A~@:>~%") existing-version asdf-version))))) (when-upgrading () (let ((redefined-functions ;; gf signature and/or semantics changed incompatibly. Oops. ;; NB: it's too late to do anything about functions in UIOP! ;; If you introduce some critically incompatibility there, you must change name. '(#:component-relative-pathname #:component-parent-pathname ;; component #:source-file-type #:find-system #:system-source-file #:system-relative-pathname ;; system #:find-component ;; find-component #:explain #:perform #:perform-with-restarts #:input-files #:output-files ;; action #:component-depends-on #:operation-done-p #:component-depends-on #:traverse ;; backward-interface #:map-direct-dependencies #:reduce-direct-dependencies #:direct-dependencies ;; plan #:operate ;; operate #:parse-component-form ;; defsystem #:apply-output-translations ;; output-translations #:process-output-translations-directive #:inherit-source-registry #:process-source-registry ;; source-registry #:process-source-registry-directive #:trivial-system-p)) ;; bundle (redefined-classes ;; redefining the classes causes interim circularities ;; with the old ASDF during upgrade, and many implementations bork '((#:compile-concatenated-source-op (#:operation) ())))) (loop :for name :in redefined-functions :for sym = (find-symbol* name :asdf nil) :do (when sym ;; On CLISP we seem to be unable to fmakunbound and define a function in the same fasl. Sigh. #-clisp (fmakunbound sym))) (labels ((asym (x) (multiple-value-bind (s p) (if (consp x) (values (car x) (cadr x)) (values x :asdf)) (find-symbol* s p nil))) (asyms (l) (mapcar #'asym l))) (loop* :for (name superclasses slots) :in redefined-classes :for sym = (find-symbol* name :asdf nil) :when (and sym (find-class sym)) :do (eval `(defclass ,sym ,(asyms superclasses) ,(asyms slots))))))) ;;; Self-upgrade functions (with-upgradability () (defun asdf-upgrade-error () ;; Important notice for whom it concerns. The crux of the matter is that ;; TRAVERSE can be completely refactored, and so after the find-system returns, it's too late. (error "When a system transitively depends on ASDF, it must :defsystem-depends-on (:asdf)~%~ Otherwise, when you upgrade from ASDF 2, you must do it before you operate on any system.~%")) (defun cleanup-upgraded-asdf (&optional (old-version (first *previous-asdf-versions*))) (let ((new-version (asdf-version))) (unless (equal old-version new-version) (push new-version *previous-asdf-versions*) (when old-version (if (version<= new-version old-version) (error (compatfmt "~&~@<; ~@;Downgraded ASDF from version ~A to version ~A~@:>~%") old-version new-version) (asdf-message (compatfmt "~&~@<; ~@;Upgraded ASDF from version ~A to version ~A~@:>~%") old-version new-version)) ;; In case the previous version was too old to be forward-compatible, clear systems. ;; TODO: if needed, we may have to define a separate hook to run ;; in case of forward-compatible upgrade. ;; Or to move the tests forward-compatibility test inside each hook function? (unless (version<= *oldest-forward-compatible-asdf-version* old-version) (call-functions (reverse *post-upgrade-cleanup-hook*))) t)))) (defun upgrade-asdf () "Try to upgrade of ASDF. If a different version was used, return T. We need do that before we operate on anything that may possibly depend on ASDF." (let ((*load-print* nil) (*compile-print* nil)) (handler-bind (((or style-warning) #'muffle-warning)) (symbol-call :asdf :load-system :asdf :verbose nil)))) (register-hook-function '*post-upgrade-cleanup-hook* 'upgrade-configuration)) ;;;; ------------------------------------------------------------------------- ;;;; Components (uiop/package:define-package :asdf/component (:recycle :asdf/component :asdf/defsystem :asdf/find-system :asdf) (:use :uiop/common-lisp :uiop :asdf/upgrade) (:export #:component #:component-find-path #:component-name #:component-pathname #:component-relative-pathname #:component-parent #:component-system #:component-parent-pathname #:child-component #:parent-component #:module #:file-component #:source-file #:c-source-file #:java-source-file #:static-file #:doc-file #:html-file #:file-type #:source-file-type #:source-file-explicit-type ;; backward-compatibility #:component-in-order-to #:component-sideway-dependencies #:component-if-feature #:around-compile-hook #:component-description #:component-long-description #:component-version #:version-satisfies #:component-inline-methods ;; backward-compatibility only. DO NOT USE! #:component-operation-times ;; For internal use only. ;; portable ASDF encoding and implementation-specific external-format #:component-external-format #:component-encoding #:component-children-by-name #:component-children #:compute-children-by-name #:component-build-operation #:module-default-component-class #:module-components ;; backward-compatibility. DO NOT USE. #:sub-components ;; conditions #:system-definition-error ;; top level, moved here because this is the earliest place for it. #:duplicate-names ;; Internals we'd like to share with the ASDF package, especially for upgrade purposes #:name #:version #:description #:long-description #:author #:maintainer #:licence #:components-by-name #:components #:children #:children-by-name #:default-component-class #:source-file #:defsystem-depends-on ; This symbol retained for backward compatibility. #:sideway-dependencies #:if-feature #:in-order-to #:inline-methods #:relative-pathname #:absolute-pathname #:operation-times #:around-compile #:%encoding #:properties #:component-properties #:parent)) (in-package :asdf/component) (with-upgradability () (defgeneric component-name (component) (:documentation "Name of the COMPONENT, unique relative to its parent")) (defgeneric component-system (component) (:documentation "Find the top-level system containing COMPONENT")) (defgeneric component-pathname (component) (:documentation "Extracts the pathname applicable for a particular component.")) (defgeneric (component-relative-pathname) (component) (:documentation "Returns a pathname for the component argument intended to be interpreted relative to the pathname of that component's parent. Despite the function's name, the return value may be an absolute pathname, because an absolute pathname may be interpreted relative to another pathname in a degenerate way.")) (defgeneric component-external-format (component)) (defgeneric component-encoding (component)) (defgeneric version-satisfies (component version)) (defgeneric component-version (component)) (defgeneric (setf component-version) (new-version component)) (defgeneric component-parent (component)) (defmethod component-parent ((component null)) nil) ;; Backward compatible way of computing the FILE-TYPE of a component. ;; TODO: find users, have them stop using that, remove it for ASDF4. (defgeneric (source-file-type) (component system)) (define-condition system-definition-error (error) () ;; [this use of :report should be redundant, but unfortunately it's not. ;; cmucl's lisp::output-instance prefers the kernel:slot-class-print-function ;; over print-object; this is always conditions::%print-condition for ;; condition objects, which in turn does inheritance of :report options at ;; run-time. fortunately, inheritance means we only need this kludge here in ;; order to fix all conditions that build on it. -- rgr, 28-Jul-02.] #+cmu (:report print-object)) (define-condition duplicate-names (system-definition-error) ((name :initarg :name :reader duplicate-names-name)) (:report (lambda (c s) (format s (compatfmt "~@") (duplicate-names-name c)))))) (with-upgradability () (defclass component () ((name :accessor component-name :initarg :name :type string :documentation "Component name: designator for a string composed of portable pathname characters") ;; We might want to constrain version with ;; :type (and string (satisfies parse-version)) ;; but we cannot until we fix all systems that don't use it correctly! (version :accessor component-version :initarg :version :initform nil) (description :accessor component-description :initarg :description :initform nil) (long-description :accessor component-long-description :initarg :long-description :initform nil) (sideway-dependencies :accessor component-sideway-dependencies :initform nil) (if-feature :accessor component-if-feature :initform nil :initarg :if-feature) ;; In the ASDF object model, dependencies exist between *actions*, ;; where an action is a pair of an operation and a component. ;; Dependencies are represented as alists of operations ;; to a list where each entry is a pair of an operation and a list of component specifiers. ;; Up until ASDF 2.26.9, there used to be two kinds of dependencies: ;; in-order-to and do-first, each stored in its own slot. Now there is only in-order-to. ;; in-order-to used to represent things that modify the filesystem (such as compiling a fasl) ;; and do-first things that modify the current image (such as loading a fasl). ;; These are now unified because we now correctly propagate timestamps between dependencies. ;; Happily, no one seems to have used do-first too much (especially since until ASDF 2.017, ;; anything you specified was overridden by ASDF itself anyway), but the name in-order-to remains. ;; The names are bad, but they have been the official API since Dan Barlow's ASDF 1.52! ;; LispWorks's defsystem has caused-by and requires for in-order-to and do-first respectively. ;; Maybe rename the slots in ASDF? But that's not very backward-compatible. ;; See our ASDF 2 paper for more complete explanations. (in-order-to :initform nil :initarg :in-order-to :accessor component-in-order-to) ;; methods defined using the "inline" style inside a defsystem form: ;; need to store them somewhere so we can delete them when the system ;; is re-evaluated. (inline-methods :accessor component-inline-methods :initform nil) ;; OBSOLETE! DELETE THIS IF NO ONE USES. ;; ASDF4: rename it from relative-pathname to specified-pathname. It need not be relative. ;; There is no initform and no direct accessor for this specified pathname, ;; so we only access the information through appropriate methods, after it has been processed. ;; Unhappily, some braindead systems directly access the slot. Make them stop before ASDF4. (relative-pathname :initarg :pathname) ;; The absolute-pathname is computed based on relative-pathname and parent pathname. ;; The slot is but a cache used by component-pathname. (absolute-pathname) (operation-times :initform (make-hash-table) :accessor component-operation-times) (around-compile :initarg :around-compile) ;; Properties are for backward-compatibility with ASDF2 only. DO NOT USE! (properties :accessor component-properties :initarg :properties :initform nil) (%encoding :accessor %component-encoding :initform nil :initarg :encoding) ;; For backward-compatibility, this slot is part of component rather than of child-component. ASDF4: stop it. (parent :initarg :parent :initform nil :reader component-parent) (build-operation :initarg :build-operation :initform nil :reader component-build-operation))) (defun component-find-path (component) "Return a path from a root system to the COMPONENT. The return value is a list of component NAMES; a list of strings." (check-type component (or null component)) (reverse (loop :for c = component :then (component-parent c) :while c :collect (component-name c)))) (defmethod print-object ((c component) stream) (print-unreadable-object (c stream :type t :identity nil) (format stream "~{~S~^ ~}" (component-find-path c)))) (defmethod component-system ((component component)) (if-let (system (component-parent component)) (component-system system) component))) ;;;; Component hierarchy within a system ;; The tree typically but not necessarily follows the filesystem hierarchy. (with-upgradability () (defclass child-component (component) () (:documentation "A CHILD-COMPONENT is a component that may be part of a PARENT-COMPONENT.")) (defclass file-component (child-component) ((type :accessor file-type :initarg :type))) ; no default (defclass source-file (file-component) ((type :accessor source-file-explicit-type ;; backward-compatibility :initform nil))) ;; NB: many systems have come to rely on this default. (defclass c-source-file (source-file) ((type :initform "c"))) (defclass java-source-file (source-file) ((type :initform "java"))) (defclass static-file (source-file) ((type :initform nil))) (defclass doc-file (static-file) ()) (defclass html-file (doc-file) ((type :initform "html"))) (defclass parent-component (component) ((children :initform nil :initarg :components :reader module-components ; backward-compatibility :accessor component-children) (children-by-name :reader module-components-by-name ; backward-compatibility :accessor component-children-by-name) (default-component-class :initform nil :initarg :default-component-class :accessor module-default-component-class)) (:documentation "A PARENT-COMPONENT is a component that may have children."))) (with-upgradability () (defun compute-children-by-name (parent &key only-if-needed-p) (unless (and only-if-needed-p (slot-boundp parent 'children-by-name)) (let ((hash (make-hash-table :test 'equal))) (setf (component-children-by-name parent) hash) (loop :for c :in (component-children parent) :for name = (component-name c) :for previous = (gethash name hash) :do (when previous (error 'duplicate-names :name name)) (setf (gethash name hash) c)) hash)))) (with-upgradability () (defclass module (child-component parent-component) (#+clisp (components)))) ;; backward compatibility during upgrade only ;;;; component pathnames (with-upgradability () (defgeneric* (component-parent-pathname) (component)) (defmethod component-parent-pathname (component) (component-pathname (component-parent component))) (defmethod component-pathname ((component component)) (if (slot-boundp component 'absolute-pathname) (slot-value component 'absolute-pathname) (let ((pathname (merge-pathnames* (component-relative-pathname component) (pathname-directory-pathname (component-parent-pathname component))))) (unless (or (null pathname) (absolute-pathname-p pathname)) (error (compatfmt "~@") pathname (component-find-path component))) (setf (slot-value component 'absolute-pathname) pathname) pathname))) (defmethod component-relative-pathname ((component component)) ;; SOURCE-FILE-TYPE below is strictly for backward-compatibility with ASDF1. ;; We ought to be able to extract this from the component alone with FILE-TYPE. ;; TODO: track who uses it in Quicklisp, and have them not use it anymore; ;; maybe issue a WARNING (then eventually CERROR) if the two methods diverge? (parse-unix-namestring (or (and (slot-boundp component 'relative-pathname) (slot-value component 'relative-pathname)) (component-name component)) :want-relative t :type (source-file-type component (component-system component)) :defaults (component-parent-pathname component))) (defmethod source-file-type ((component parent-component) (system parent-component)) :directory) (defmethod source-file-type ((component file-component) (system parent-component)) (file-type component))) ;;;; Encodings (with-upgradability () (defmethod component-encoding ((c component)) (or (loop :for x = c :then (component-parent x) :while x :thereis (%component-encoding x)) (detect-encoding (component-pathname c)))) (defmethod component-external-format ((c component)) (encoding-external-format (component-encoding c)))) ;;;; around-compile-hook (with-upgradability () (defgeneric around-compile-hook (component)) (defmethod around-compile-hook ((c component)) (cond ((slot-boundp c 'around-compile) (slot-value c 'around-compile)) ((component-parent c) (around-compile-hook (component-parent c)))))) ;;;; version-satisfies (with-upgradability () ;; short-circuit testing of null version specifications. ;; this is an all-pass, without warning (defmethod version-satisfies :around ((c t) (version null)) t) (defmethod version-satisfies ((c component) version) (unless (and version (slot-boundp c 'version) (component-version c)) (when version (warn "Requested version ~S but ~S has no version" version c)) (return-from version-satisfies nil)) (version-satisfies (component-version c) version)) (defmethod version-satisfies ((cver string) version) (version<= version cver))) ;;; all sub-components (of a given type) (with-upgradability () (defun sub-components (component &key (type t)) (while-collecting (c) (labels ((recurse (x) (when (if-let (it (component-if-feature x)) (featurep it) t) (when (typep x type) (c x)) (when (typep x 'parent-component) (map () #'recurse (component-children x)))))) (recurse component))))) ;;;; ------------------------------------------------------------------------- ;;;; Systems (uiop/package:define-package :asdf/system (:recycle :asdf :asdf/system) (:use :uiop/common-lisp :uiop :asdf/upgrade :asdf/component) (:export #:system #:proto-system #:system-source-file #:system-source-directory #:system-relative-pathname #:reset-system #:system-description #:system-long-description #:system-author #:system-maintainer #:system-licence #:system-license #:system-defsystem-depends-on #:system-depends-on #:system-weakly-depends-on #:component-build-pathname #:build-pathname #:component-entry-point #:entry-point #:homepage #:system-homepage #:bug-tracker #:system-bug-tracker #:mailto #:system-mailto #:long-name #:system-long-name #:source-control #:system-source-control #:find-system #:builtin-system-p)) ;; forward-reference, defined in find-system (in-package :asdf/system) (with-upgradability () (defgeneric* (find-system) (system &optional error-p)) (defgeneric* (system-source-file :supersede #-clisp t #+clisp nil) (system) (:documentation "Return the source file in which system is defined.")) (defgeneric component-build-pathname (component)) (defgeneric component-entry-point (component)) (defmethod component-entry-point ((c component)) nil)) ;;;; The system class (with-upgradability () (defclass proto-system () ; slots to keep when resetting a system ;; To preserve identity for all objects, we'd need keep the components slots ;; but also to modify parse-component-form to reset the recycled objects. ((name) (source-file) #|(children) (children-by-names)|#)) (defclass system (module proto-system) ;; Backward-compatibility: inherit from module. ASDF4: only inherit from parent-component. (;; {,long-}description is now inherited from component, but we add the legacy accessors (description :accessor system-description) (long-description :accessor system-long-description) (author :accessor system-author :initarg :author :initform nil) (maintainer :accessor system-maintainer :initarg :maintainer :initform nil) (licence :accessor system-licence :initarg :licence :accessor system-license :initarg :license :initform nil) (homepage :accessor system-homepage :initarg :homepage :initform nil) (bug-tracker :accessor system-bug-tracker :initarg :bug-tracker :initform nil) (mailto :accessor system-mailto :initarg :mailto :initform nil) (long-name :accessor system-long-name :initarg :long-name :initform nil) ;; Conventions for this slot aren't clear yet as of ASDF 2.27, but whenever they are, they will be enforced. ;; I'm introducing the slot before the conventions are set for maximum compatibility. (source-control :accessor system-source-control :initarg :source-control :initform nil) (builtin-system-p :accessor builtin-system-p :initform nil :initarg :builtin-system-p) (build-pathname :initform nil :initarg :build-pathname :accessor component-build-pathname) (entry-point :initform nil :initarg :entry-point :accessor component-entry-point) (source-file :initform nil :initarg :source-file :accessor system-source-file) (defsystem-depends-on :reader system-defsystem-depends-on :initarg :defsystem-depends-on :initform nil) ;; these two are specially set in parse-component-form, so have no :INITARGs. (depends-on :reader system-depends-on :initform nil) (weakly-depends-on :reader system-weakly-depends-on :initform nil))) (defun reset-system (system &rest keys &key &allow-other-keys) (change-class (change-class system 'proto-system) 'system) (apply 'reinitialize-instance system keys))) ;;;; Pathnames (with-upgradability () (defmethod system-source-file ((system-name string)) (system-source-file (find-system system-name))) (defmethod system-source-file ((system-name symbol)) (system-source-file (find-system system-name))) (defun system-source-directory (system-designator) "Return a pathname object corresponding to the directory in which the system specification (.asd file) is located." (pathname-directory-pathname (system-source-file system-designator))) (defun (system-relative-pathname) (system name &key type) (subpathname (system-source-directory system) name :type type)) (defmethod component-pathname ((system system)) (let ((pathname (or (call-next-method) (system-source-directory system)))) (unless (and (slot-boundp system 'relative-pathname) ;; backward-compatibility with ASDF1-age (slot-value system 'relative-pathname)) ;; systems that directly access this slot. (setf (slot-value system 'relative-pathname) pathname)) pathname)) (defmethod component-relative-pathname ((system system)) (parse-unix-namestring (and (slot-boundp system 'relative-pathname) (slot-value system 'relative-pathname)) :want-relative t :type :directory :ensure-absolute t :defaults (system-source-directory system))) (defmethod component-parent-pathname ((system system)) (system-source-directory system)) (defmethod component-build-pathname ((c component)) nil)) ;;;; ------------------------------------------------------------------------- ;;;; Stamp cache (uiop/package:define-package :asdf/cache (:use :uiop/common-lisp :uiop :asdf/upgrade) (:export #:get-file-stamp #:compute-file-stamp #:register-file-stamp #:set-asdf-cache-entry #:unset-asdf-cache-entry #:consult-asdf-cache #:do-asdf-cache #:normalize-namestring #:call-with-asdf-cache #:with-asdf-cache #:*asdf-cache* #:clear-configuration-and-retry #:retry)) (in-package :asdf/cache) ;;; This stamp cache is useful for: ;; * consistency of stamps used within a single run ;; * fewer accesses to the filesystem ;; * the ability to test with fake timestamps, without touching files (with-upgradability () (defvar *asdf-cache* nil) (defun set-asdf-cache-entry (key value-list) (apply 'values (if *asdf-cache* (setf (gethash key *asdf-cache*) value-list) value-list))) (defun unset-asdf-cache-entry (key) (when *asdf-cache* (remhash key *asdf-cache*))) (defun consult-asdf-cache (key &optional thunk) (if *asdf-cache* (multiple-value-bind (results foundp) (gethash key *asdf-cache*) (if foundp (apply 'values results) (set-asdf-cache-entry key (multiple-value-list (call-function thunk))))) (call-function thunk))) (defmacro do-asdf-cache (key &body body) `(consult-asdf-cache ,key #'(lambda () ,@body))) (defun call-with-asdf-cache (thunk &key override key) (let ((fun (if key #'(lambda () (consult-asdf-cache key thunk)) thunk))) (if (and *asdf-cache* (not override)) (funcall fun) (loop (restart-case (let ((*asdf-cache* (make-hash-table :test 'equal))) (return (funcall fun))) (retry () :report (lambda (s) (format s (compatfmt "~@")))) (clear-configuration-and-retry () :report (lambda (s) (format s (compatfmt "~@"))) (clear-configuration))))))) (defmacro with-asdf-cache ((&key key override) &body body) `(call-with-asdf-cache #'(lambda () ,@body) :override ,override :key ,key)) (defun normalize-namestring (pathname) (let ((resolved (resolve-symlinks* (ensure-absolute-pathname (physicalize-pathname pathname) 'get-pathname-defaults)))) (with-pathname-defaults () (namestring resolved)))) (defun compute-file-stamp (normalized-namestring) (with-pathname-defaults () (safe-file-write-date normalized-namestring))) (defun register-file-stamp (file &optional (stamp nil stampp)) (let* ((namestring (normalize-namestring file)) (stamp (if stampp stamp (compute-file-stamp namestring)))) (set-asdf-cache-entry `(get-file-stamp ,namestring) (list stamp)))) (defun get-file-stamp (file) (when file (let ((namestring (normalize-namestring file))) (do-asdf-cache `(get-file-stamp ,namestring) (compute-file-stamp namestring)))))) ;;;; ------------------------------------------------------------------------- ;;;; Finding systems (uiop/package:define-package :asdf/find-system (:recycle :asdf/find-system :asdf) (:use :uiop/common-lisp :uiop :asdf/upgrade :asdf/cache :asdf/component :asdf/system) (:export #:remove-entry-from-registry #:coerce-entry-to-directory #:coerce-name #:primary-system-name #:coerce-filename #:find-system #:locate-system #:load-asd #:system-registered-p #:register-system #:registered-systems #:clear-system #:map-systems #:missing-component #:missing-requires #:missing-parent #:formatted-system-definition-error #:format-control #:format-arguments #:sysdef-error #:load-system-definition-error #:error-name #:error-pathname #:error-condition #:*system-definition-search-functions* #:search-for-system-definition #:*central-registry* #:probe-asd #:sysdef-central-registry-search #:find-system-if-being-defined #:contrib-sysdef-search #:sysdef-find-asdf ;; backward compatibility symbols, functions removed #:sysdef-preloaded-system-search #:register-preloaded-system #:*preloaded-systems* #:sysdef-immutable-system-search #:register-immutable-system #:*immutable-systems* #:*defined-systems* #:clear-defined-systems ;; defined in source-registry, but specially mentioned here: #:initialize-source-registry #:sysdef-source-registry-search)) (in-package :asdf/find-system) (with-upgradability () (declaim (ftype (function (&optional t) t) initialize-source-registry)) ; forward reference (define-condition missing-component (system-definition-error) ((requires :initform "(unnamed)" :reader missing-requires :initarg :requires) (parent :initform nil :reader missing-parent :initarg :parent))) (define-condition formatted-system-definition-error (system-definition-error) ((format-control :initarg :format-control :reader format-control) (format-arguments :initarg :format-arguments :reader format-arguments)) (:report (lambda (c s) (apply 'format s (format-control c) (format-arguments c))))) (define-condition load-system-definition-error (system-definition-error) ((name :initarg :name :reader error-name) (pathname :initarg :pathname :reader error-pathname) (condition :initarg :condition :reader error-condition)) (:report (lambda (c s) (format s (compatfmt "~@") (error-name c) (error-pathname c) (error-condition c))))) (defun sysdef-error (format &rest arguments) (error 'formatted-system-definition-error :format-control format :format-arguments arguments)) (defun coerce-name (name) (typecase name (component (component-name name)) (symbol (string-downcase (symbol-name name))) (string name) (t (sysdef-error (compatfmt "~@") name)))) (defun primary-system-name (name) ;; When a system name has slashes, the file with defsystem is named by ;; the first of the slash-separated components. (first (split-string (coerce-name name) :separator "/"))) (defun coerce-filename (name) (frob-substrings (coerce-name name) '("/" ":" "\\") "--")) (defvar *defined-systems* (make-hash-table :test 'equal) "This is a hash table whose keys are strings, being the names of the systems, and whose values are pairs, the first element of which is a universal-time indicating when the system definition was last updated, and the second element of which is a system object.") (defun system-registered-p (name) (gethash (coerce-name name) *defined-systems*)) (defun registered-systems () (loop :for registered :being :the :hash-values :of *defined-systems* :collect (coerce-name (cdr registered)))) (defun register-system (system) (check-type system system) (let ((name (component-name system))) (check-type name string) (asdf-message (compatfmt "~&~@<; ~@;Registering ~3i~_~A~@:>~%") system) (unless (eq system (cdr (gethash name *defined-systems*))) (setf (gethash name *defined-systems*) (cons (if-let (file (ignore-errors (system-source-file system))) (get-file-stamp file)) system))))) (defvar *preloaded-systems* (make-hash-table :test 'equal)) (defun make-preloaded-system (name keys) (apply 'make-instance (getf keys :class 'system) :name name :source-file (getf keys :source-file) (remove-plist-keys '(:class :name :source-file) keys))) (defun sysdef-preloaded-system-search (requested) (let ((name (coerce-name requested))) (multiple-value-bind (keys foundp) (gethash name *preloaded-systems*) (when foundp (make-preloaded-system name keys))))) (defun register-preloaded-system (system-name &rest keys) (setf (gethash (coerce-name system-name) *preloaded-systems*) keys)) (dolist (s '("asdf" "uiop" "asdf-driver" "asdf-defsystem" "asdf-package-system")) ;; don't bother with these, no one relies on them: "asdf-utils" "asdf-bundle" (register-preloaded-system s :version *asdf-version*)) (defvar *immutable-systems* nil "An hash-set (equal hash-table mapping keys to T) of systems that are immutable, i.e. already loaded in memory and not to be refreshed from the filesystem. They will be treated specially by find-system, and passed as :force-not argument to make-plan. If you deliver an image with many systems precompiled, *and* do not want to check the filesystem for them every time a user loads an extension, what more risk a problematic upgrade or catastrophic downgrade, before you dump an image, use: (setf asdf::*immutable-systems* (uiop:list-to-hash-set (asdf:already-loaded-systems)))") (defun sysdef-immutable-system-search (requested) (let ((name (coerce-name requested))) (when (and *immutable-systems* (gethash name *immutable-systems*)) (or (cdr (system-registered-p requested)) (sysdef-preloaded-system-search name) (error 'formatted-system-definition-error :format-control "Requested system ~A is in the *immutable-systems* set, ~ but not loaded in memory" :format-arguments (list name)))))) (defun register-immutable-system (system-name &key (version t)) (let* ((system-name (coerce-name system-name)) (registered-system (cdr (system-registered-p system-name))) (default-version? (eql version t)) (version (cond ((and default-version? registered-system) (component-version registered-system)) (default-version? nil) (t version)))) (unless registered-system (register-system (make-preloaded-system system-name (list :version version)))) (register-preloaded-system system-name :version version) (unless *immutable-systems* (setf *immutable-systems* (list-to-hash-set nil))) (setf (gethash (coerce-name system-name) *immutable-systems*) t))) (defun clear-system (system) "Clear the entry for a SYSTEM in the database of systems previously loaded, unless the system appears in the table of *IMMUTABLE-SYSTEMS*. Note that this does NOT in any way cause the code of the system to be unloaded. Returns T if cleared or already cleared, NIL if not cleared because the system was found to be immutable." ;; There is no "unload" operation in Common Lisp, and ;; a general such operation cannot be portably written, ;; considering how much CL relies on side-effects to global data structures. (let ((name (coerce-name system))) (unless (and *immutable-systems* (gethash name *immutable-systems*)) (remhash (coerce-name name) *defined-systems*) (unset-asdf-cache-entry `(locate-system ,name)) (unset-asdf-cache-entry `(find-system ,name)) t))) (defun clear-defined-systems () ;; Invalidate all systems but ASDF itself, if registered. (loop :for name :being :the :hash-keys :of *defined-systems* :unless (equal name "asdf") :do (clear-system name))) (register-hook-function '*post-upgrade-cleanup-hook* 'clear-defined-systems nil) (defun map-systems (fn) "Apply FN to each defined system. FN should be a function of one argument. It will be called with an object of type asdf:system." (loop :for registered :being :the :hash-values :of *defined-systems* :do (funcall fn (cdr registered))))) ;;; for the sake of keeping things reasonably neat, we adopt a ;;; convention that functions in this list are prefixed SYSDEF- (with-upgradability () (defvar *system-definition-search-functions* '()) (defun cleanup-system-definition-search-functions () (setf *system-definition-search-functions* (append ;; Remove known-incompatible sysdef functions from old versions of asdf. (remove-if #'(lambda (x) (member x '(contrib-sysdef-search sysdef-find-asdf sysdef-preloaded-system-search))) *system-definition-search-functions*) ;; Tuck our defaults at the end of the list if they were absent. ;; This is imperfect, in case they were removed on purpose, ;; but then it will be the responsibility of whoever does that ;; to upgrade asdf before he does such a thing rather than after. (remove-if #'(lambda (x) (member x *system-definition-search-functions*)) '(sysdef-central-registry-search sysdef-source-registry-search))))) (cleanup-system-definition-search-functions) (defun search-for-system-definition (system) (let ((name (coerce-name system))) (flet ((try (f) (if-let ((x (funcall f name))) (return-from search-for-system-definition x)))) (try 'find-system-if-being-defined) (try 'sysdef-immutable-system-search) (map () #'try *system-definition-search-functions*) (try 'sysdef-preloaded-system-search)))) (defvar *central-registry* nil "A list of 'system directory designators' ASDF uses to find systems. A 'system directory designator' is a pathname or an expression which evaluates to a pathname. For example: (setf asdf:*central-registry* (list '*default-pathname-defaults* #p\"/home/me/cl/systems/\" #p\"/usr/share/common-lisp/systems/\")) This is for backward compatibility. Going forward, we recommend new users should be using the source-registry. ") (defun probe-asd (name defaults &key truename) (block nil (when (directory-pathname-p defaults) (if-let (file (probe-file* (ensure-absolute-pathname (parse-unix-namestring name :type "asd") #'(lambda () (ensure-absolute-pathname defaults 'get-pathname-defaults nil)) nil) :truename truename)) (return file)) #-(or clisp genera) ; clisp doesn't need it, plain genera doesn't have read-sequence(!) (os-cond ((os-windows-p) (when (physical-pathname-p defaults) (let ((shortcut (make-pathname :defaults defaults :case :local :name (strcat name ".asd") :type "lnk"))) (when (probe-file* shortcut) (ensure-pathname (parse-windows-shortcut shortcut) :namestring :native))))))))) (defun sysdef-central-registry-search (system) (let ((name (primary-system-name system)) (to-remove nil) (to-replace nil)) (block nil (unwind-protect (dolist (dir *central-registry*) (let ((defaults (eval dir)) directorized) (when defaults (cond ((directory-pathname-p defaults) (let* ((file (probe-asd name defaults :truename *resolve-symlinks*))) (when file (return file)))) (t (restart-case (let* ((*print-circle* nil) (message (format nil (compatfmt "~@") system dir defaults))) (error message)) (remove-entry-from-registry () :report "Remove entry from *central-registry* and continue" (push dir to-remove)) (coerce-entry-to-directory () :test (lambda (c) (declare (ignore c)) (and (not (directory-pathname-p defaults)) (directory-pathname-p (setf directorized (ensure-directory-pathname defaults))))) :report (lambda (s) (format s (compatfmt "~@") directorized dir)) (push (cons dir directorized) to-replace)))))))) ;; cleanup (dolist (dir to-remove) (setf *central-registry* (remove dir *central-registry*))) (dolist (pair to-replace) (let* ((current (car pair)) (new (cdr pair)) (position (position current *central-registry*))) (setf *central-registry* (append (subseq *central-registry* 0 position) (list new) (subseq *central-registry* (1+ position)))))))))) (defmethod find-system ((name null) &optional (error-p t)) (when error-p (sysdef-error (compatfmt "~@")))) (defmethod find-system (name &optional (error-p t)) (find-system (coerce-name name) error-p)) (defun find-system-if-being-defined (name) ;; notable side effect: mark the system as being defined, to avoid infinite loops (first (gethash `(find-system ,(coerce-name name)) *asdf-cache*))) (defun load-asd (pathname &key name (external-format (encoding-external-format (detect-encoding pathname))) &aux (readtable *readtable*) (print-pprint-dispatch *print-pprint-dispatch*)) ;; Tries to load system definition with canonical NAME from PATHNAME. (with-asdf-cache () (with-standard-io-syntax (let ((*package* (find-package :asdf-user)) ;; Note that our backward-compatible *readtable* is ;; a global readtable that gets globally side-effected. Ouch. ;; Same for the *print-pprint-dispatch* table. ;; We should do something about that for ASDF3 if possible, or else ASDF4. (*readtable* readtable) (*print-pprint-dispatch* print-pprint-dispatch) (*print-readably* nil) (*default-pathname-defaults* ;; resolve logical-pathnames so they won't wreak havoc in parsing namestrings. (pathname-directory-pathname (physicalize-pathname pathname)))) (handler-bind ((error #'(lambda (condition) (error 'load-system-definition-error :name name :pathname pathname :condition condition)))) (asdf-message (compatfmt "~&~@<; ~@;Loading system definition~@[ for ~A~] from ~A~@:>~%") name pathname) (load* pathname :external-format external-format)))))) (defvar *old-asdf-systems* (make-hash-table :test 'equal)) (defun check-not-old-asdf-system (name pathname) (or (not (equal name "asdf")) (null pathname) (let* ((version-pathname (subpathname pathname "version.lisp-expr")) (version (and (probe-file* version-pathname :truename nil) (read-file-form version-pathname))) (old-version (asdf-version))) (cond ((version< old-version version) t) ;; newer version: good! ((equal old-version version) nil) ;; same version: don't load, but don't warn (t ;; old version: bad (ensure-gethash (list (namestring pathname) version) *old-asdf-systems* #'(lambda () (let ((old-pathname (if-let (pair (system-registered-p "asdf")) (system-source-file (cdr pair))))) (warn "~@<~ You are using ASDF version ~A ~:[(probably from (require \"asdf\") ~ or loaded by quicklisp)~;from ~:*~S~] and have an older version of ASDF ~ ~:[(and older than 2.27 at that)~;~:*~A~] registered at ~S. ~ Having an ASDF installed and registered is the normal way of configuring ASDF to upgrade itself, ~ and having an old version registered is a configuration error. ~ ASDF will ignore this configured system rather than downgrade itself. ~ In the future, you may want to either: ~ (a) upgrade this configured ASDF to a newer version, ~ (b) install a newer ASDF and register it in front of the former in your configuration, or ~ (c) uninstall or unregister this and any other old version of ASDF from your configuration. ~ Note that the older ASDF might be registered implicitly through configuration inherited ~ from your system installation, in which case you might have to specify ~ :ignore-inherited-configuration in your in your ~~/.config/common-lisp/source-registry.conf ~ or other source-registry configuration file, environment variable or lisp parameter. ~ Indeed, a likely offender is an obsolete version of the cl-asdf debian or ubuntu package, ~ that you might want to upgrade (if a recent enough version is available) ~ or else remove altogether (since most implementations ship with a recent asdf); ~ if you lack the system administration rights to upgrade or remove this package, ~ then you might indeed want to either install and register a more recent version, ~ or use :ignore-inherited-configuration to avoid registering the old one. ~ Please consult ASDF documentation and/or experts.~@:>~%" old-version old-pathname version pathname)))) nil))))) ;; only issue the warning the first time, but always return nil (defun locate-system (name) "Given a system NAME designator, try to locate where to load the system from. Returns five values: FOUNDP FOUND-SYSTEM PATHNAME PREVIOUS PREVIOUS-TIME FOUNDP is true when a system was found, either a new unregistered one or a previously registered one. FOUND-SYSTEM when not null is a SYSTEM object that may be REGISTER-SYSTEM'ed. PATHNAME when not null is a path from which to load the system, either associated with FOUND-SYSTEM, or with the PREVIOUS system. PREVIOUS when not null is a previously loaded SYSTEM object of same name. PREVIOUS-TIME when not null is the time at which the PREVIOUS system was loaded." (let* ((name (coerce-name name)) (in-memory (system-registered-p name)) ; load from disk if absent or newer on disk (previous (cdr in-memory)) (previous (and (typep previous 'system) previous)) (previous-time (car in-memory)) (found (search-for-system-definition name)) (found-system (and (typep found 'system) found)) (pathname (ensure-pathname (or (and (typep found '(or pathname string)) (pathname found)) (and found-system (system-source-file found-system)) (and previous (system-source-file previous))) :want-absolute t :resolve-symlinks *resolve-symlinks*)) (foundp (and (or found-system pathname previous) t))) (check-type found (or null pathname system)) (unless (check-not-old-asdf-system name pathname) (cond (previous (setf found nil pathname nil)) (t (setf found (sysdef-preloaded-system-search "asdf")) (assert (typep found 'system)) (setf found-system found pathname nil)))) (values foundp found-system pathname previous previous-time))) (defmethod find-system ((name string) &optional (error-p t)) (with-asdf-cache (:key `(find-system ,name)) (let ((primary-name (primary-system-name name))) (unless (equal name primary-name) (find-system primary-name nil))) (or (and *immutable-systems* (gethash name *immutable-systems*) (or (cdr (system-registered-p name)) (sysdef-preloaded-system-search name))) (multiple-value-bind (foundp found-system pathname previous previous-time) (locate-system name) (assert (eq foundp (and (or found-system pathname previous) t))) (let ((previous-pathname (and previous (system-source-file previous))) (system (or previous found-system))) (when (and found-system (not previous)) (register-system found-system)) (when (and system pathname) (setf (system-source-file system) pathname)) (when (and pathname (let ((stamp (get-file-stamp pathname))) (and stamp (not (and previous (or (pathname-equal pathname previous-pathname) (and pathname previous-pathname (pathname-equal (physicalize-pathname pathname) (physicalize-pathname previous-pathname)))) (stamp<= stamp previous-time)))))) ;; only load when it's a pathname that is different or has newer content, and not an old asdf (load-asd pathname :name name))) (let ((in-memory (system-registered-p name))) ; try again after loading from disk if needed (cond (in-memory (when pathname (setf (car in-memory) (get-file-stamp pathname))) (cdr in-memory)) (error-p (error 'missing-component :requires name)) (t ;; not found: don't keep negative cache, see lp#1335323 (unset-asdf-cache-entry `(locate-system ,name)) (return-from find-system nil))))))))) ;;;; ------------------------------------------------------------------------- ;;;; Finding components (uiop/package:define-package :asdf/find-component (:recycle :asdf/find-component :asdf) (:use :uiop/common-lisp :uiop :asdf/upgrade :asdf/cache :asdf/component :asdf/system :asdf/find-system) (:export #:find-component #:resolve-dependency-name #:resolve-dependency-spec #:resolve-dependency-combination ;; Conditions #:missing-component #:missing-component-of-version #:retry #:missing-dependency #:missing-dependency-of-version #:missing-requires #:missing-parent #:missing-required-by #:missing-version)) (in-package :asdf/find-component) ;;;; Missing component conditions (with-upgradability () (define-condition missing-component-of-version (missing-component) ((version :initform nil :reader missing-version :initarg :version))) (define-condition missing-dependency (missing-component) ((required-by :initarg :required-by :reader missing-required-by))) (defmethod print-object ((c missing-dependency) s) (format s (compatfmt "~@<~A, required by ~A~@:>") (call-next-method c nil) (missing-required-by c))) (define-condition missing-dependency-of-version (missing-dependency missing-component-of-version) ()) (defmethod print-object ((c missing-component) s) (format s (compatfmt "~@") (missing-requires c) (when (missing-parent c) (coerce-name (missing-parent c))))) (defmethod print-object ((c missing-component-of-version) s) (format s (compatfmt "~@") (missing-requires c) (missing-version c) (when (missing-parent c) (coerce-name (missing-parent c)))))) ;;;; Finding components (with-upgradability () (defgeneric* (find-component) (base path) (:documentation "Find a component by resolving the PATH starting from BASE parent")) (defgeneric resolve-dependency-combination (component combinator arguments)) (defmethod find-component ((base string) path) (let ((s (find-system base nil))) (and s (find-component s path)))) (defmethod find-component ((base symbol) path) (cond (base (find-component (coerce-name base) path)) (path (find-component path nil)) (t nil))) (defmethod find-component ((base cons) path) (find-component (car base) (cons (cdr base) path))) (defmethod find-component ((parent parent-component) (name string)) (compute-children-by-name parent :only-if-needed-p t) ;; SBCL may miss the u-i-f-r-c method!!! (values (gethash name (component-children-by-name parent)))) (defmethod find-component (base (name symbol)) (if name (find-component base (coerce-name name)) base)) (defmethod find-component ((c component) (name cons)) (find-component (find-component c (car name)) (cdr name))) (defmethod find-component ((base t) (actual component)) actual) (defun resolve-dependency-name (component name &optional version) (loop (restart-case (return (let ((comp (find-component (component-parent component) name))) (unless comp (error 'missing-dependency :required-by component :requires name)) (when version (unless (version-satisfies comp version) (error 'missing-dependency-of-version :required-by component :version version :requires name))) comp)) (retry () :report (lambda (s) (format s (compatfmt "~@") name)) :test (lambda (c) (or (null c) (and (typep c 'missing-dependency) (eq (missing-required-by c) component) (equal (missing-requires c) name)))) (unless (component-parent component) (let ((name (coerce-name name))) (unset-asdf-cache-entry `(find-system ,name)) (unset-asdf-cache-entry `(locate-system ,name)))))))) (defun resolve-dependency-spec (component dep-spec) (let ((component (find-component () component))) (if (atom dep-spec) (resolve-dependency-name component dep-spec) (resolve-dependency-combination component (car dep-spec) (cdr dep-spec))))) (defmethod resolve-dependency-combination (component combinator arguments) (error (compatfmt "~@") (cons combinator arguments) component)) (defmethod resolve-dependency-combination (component (combinator (eql :feature)) arguments) (when (featurep (first arguments)) (resolve-dependency-spec component (second arguments)))) (defmethod resolve-dependency-combination (component (combinator (eql :version)) arguments) (resolve-dependency-name component (first arguments) (second arguments)))) ;; See lp#527788 ;;;; ------------------------------------------------------------------------- ;;;; Operations (uiop/package:define-package :asdf/operation (:recycle :asdf/operation :asdf/action :asdf) ;; asdf/action for FEATURE pre 2.31.5. (:use :uiop/common-lisp :uiop :asdf/upgrade :asdf/find-system) (:export #:operation #:operation-original-initargs #:original-initargs ;; backward-compatibility only. DO NOT USE. #:*operations* #:make-operation #:find-operation #:feature)) ;; TODO: stop exporting the deprecated FEATURE feature. (in-package :asdf/operation) ;;; Operation Classes (when-upgrading (:when (find-class 'operation nil)) ;; override any obsolete shared-initialize method when upgrading from ASDF2. (defmethod shared-initialize :after ((o operation) (slot-names t) &key) (values))) (with-upgradability () (defclass operation () ((original-initargs ;; for backward-compat -- used by GBBopen and swank (via operation-forced) :initform nil :initarg :original-initargs :accessor operation-original-initargs))) ;; Cache a copy of the INITARGS in the ORIGINAL-INITARGS slot, if that slot is not ;; already bound. (defmethod initialize-instance :after ((o operation) &rest initargs &key force force-not system verbose &allow-other-keys) (declare (ignore force force-not system verbose)) (unless (slot-boundp o 'original-initargs) (setf (operation-original-initargs o) initargs))) (defmethod print-object ((o operation) stream) (print-unreadable-object (o stream :type t :identity nil) (ignore-errors (format stream "~{~S~^ ~}" (operation-original-initargs o)))))) ;;; make-operation, find-operation (with-upgradability () (defparameter* *operations* (make-hash-table :test 'equal)) (defun make-operation (operation-class &rest initargs) (let ((class (coerce-class operation-class :package :asdf/interface :super 'operation :error 'sysdef-error))) (ensure-gethash (cons class initargs) *operations* (list* 'make-instance class initargs)))) (defgeneric find-operation (context spec) (:documentation "Find an operation by resolving the SPEC in the CONTEXT")) (defmethod find-operation ((context t) (spec operation)) spec) (defmethod find-operation (context (spec symbol)) (when spec ;; NIL designates itself, i.e. absence of operation (apply 'make-operation spec (operation-original-initargs context)))) (defmethod find-operation (context (spec string)) (apply 'make-operation spec (operation-original-initargs context))) (defmethod operation-original-initargs ((context symbol)) (declare (ignorable context)) nil)) ;;;; ------------------------------------------------------------------------- ;;;; Actions (uiop/package:define-package :asdf/action (:nicknames :asdf-action) (:recycle :asdf/action :asdf) (:use :uiop/common-lisp :uiop :asdf/upgrade :asdf/component :asdf/system #:asdf/cache :asdf/find-system :asdf/find-component :asdf/operation) (:export #:action #:define-convenience-action-methods #:explain #:action-description #:downward-operation #:upward-operation #:sideway-operation #:selfward-operation #:non-propagating-operation #:component-depends-on #:input-files #:output-files #:output-file #:operation-done-p #:action-status #:action-stamp #:action-done-p #:component-operation-time #:mark-operation-done #:compute-action-stamp #:perform #:perform-with-restarts #:retry #:accept #:traverse-actions #:traverse-sub-actions #:required-components ;; in plan #:action-path #:find-action #:stamp #:done-p #:operation-definition-warning #:operation-definition-error ;; condition )) (in-package :asdf/action) (eval-when (#-lispworks :compile-toplevel :load-toplevel :execute) ;; LispWorks issues spurious warning (deftype action () '(cons operation component)) ;; a step to be performed while building (deftype operation-designator () ;; an operation designates itself, ;; nil designates a context-dependent current operation, and ;; class-name or class designates an instance of the designated class. '(or operation null symbol class))) (with-upgradability () (defgeneric traverse-actions (actions &key &allow-other-keys)) (defgeneric traverse-sub-actions (operation component &key &allow-other-keys)) (defgeneric required-components (component &key &allow-other-keys))) ;;;; Reified representation for storage or debugging. Note: dropping original-initargs (with-upgradability () (defun action-path (action) (destructuring-bind (o . c) action (cons (type-of o) (component-find-path c)))) (defun find-action (path) (destructuring-bind (o . c) path (cons (make-operation o) (find-component () c))))) ;;;; Convenience methods (with-upgradability () (defmacro define-convenience-action-methods (function formals &key if-no-operation if-no-component operation-initargs) (let* ((rest (gensym "REST")) (found (gensym "FOUND")) (keyp (equal (last formals) '(&key))) (formals-no-key (if keyp (butlast formals) formals)) (len (length formals-no-key)) (operation 'operation) (component 'component) (opix (position operation formals)) (coix (position component formals)) (prefix (subseq formals 0 opix)) (suffix (subseq formals (1+ coix) len)) (more-args (when keyp `(&rest ,rest &key &allow-other-keys)))) (assert (and (integerp opix) (integerp coix) (= coix (1+ opix)))) (flet ((next-method (o c) (if keyp `(apply ',function ,@prefix ,o ,c ,@suffix ,rest) `(,function ,@prefix ,o ,c ,@suffix)))) `(progn (defmethod ,function (,@prefix (,operation string) ,component ,@suffix ,@more-args) (let ((,component (find-component () ,component))) ;; do it first, for defsystem-depends-on ,(next-method `(safe-read-from-string ,operation :package :asdf/interface) component))) (defmethod ,function (,@prefix (,operation symbol) ,component ,@suffix ,@more-args) (if ,operation ,(next-method (if operation-initargs ;backward-compatibility with ASDF1's operate. Yuck. `(apply 'make-operation ,operation :original-initargs ,rest ,rest) `(make-operation ,operation)) `(or (find-component () ,component) ,if-no-component)) ,if-no-operation)) (defmethod ,function (,@prefix (,operation operation) ,component ,@suffix ,@more-args) (if (typep ,component 'component) (error "No defined method for ~S on ~/asdf-action:format-action/" ',function (cons ,operation ,component)) (if-let (,found (find-component () ,component)) ,(next-method operation found) ,if-no-component)))))))) ;;;; self-description (with-upgradability () (defgeneric action-description (operation component) (:documentation "returns a phrase that describes performing this operation on this component, e.g. \"loading /a/b/c\". You can put together sentences using this phrase.")) (defmethod action-description (operation component) (format nil (compatfmt "~@<~A on ~A~@:>") (type-of operation) component)) (defgeneric* (explain) (operation component)) (defmethod explain ((o operation) (c component)) (asdf-message (compatfmt "~&~@<; ~@;~A~:>~%") (action-description o c))) (define-convenience-action-methods explain (operation component)) (defun format-action (stream action &optional colon-p at-sign-p) (assert (null colon-p)) (assert (null at-sign-p)) (destructuring-bind (operation . component) action (princ (action-description operation component) stream)))) ;;;; Dependencies (with-upgradability () (defgeneric* (component-depends-on) (operation component) ;; ASDF4: rename to component-dependencies (:documentation "Returns a list of dependencies needed by the component to perform the operation. A dependency has one of the following forms: ( *), where is an operation designator with respect to FIND-OPERATION in the context of the OPERATION argument, and each is a component designator with respect to FIND-COMPONENT in the context of the COMPONENT argument, and means that the component depends on having been performed on each ; [Note: an is an operation designator -- it can be either an operation name or an operation object. Similarly, a may be a component name or a component object. Also note that, the degenerate case of () is a no-op.] Methods specialized on subclasses of existing component types should usually append the results of CALL-NEXT-METHOD to the list.")) (define-convenience-action-methods component-depends-on (operation component)) (defmethod component-depends-on :around ((o operation) (c component)) (do-asdf-cache `(component-depends-on ,o ,c) (call-next-method)))) ;;;; upward-operation, downward-operation, sideway-operation, selfward-operation ;; These together handle actions that propagate along the component hierarchy or operation universe. (with-upgradability () (defclass downward-operation (operation) ((downward-operation :initform nil :reader downward-operation :type operation-designator :allocation :class)) (:documentation "A DOWNWARD-OPERATION's dependencies propagate down the component hierarchy. I.e., if O is a DOWNWARD-OPERATION and its DOWNWARD-OPERATION slot designates operation D, then the action (O . M) of O on module M will depends on each of (D . C) for each child C of module M. The default value for slot DOWNWARD-OPERATION is NIL, which designates the operation O itself. E.g. in order for a MODULE to be loaded with LOAD-OP (resp. compiled with COMPILE-OP), all the children of the MODULE must have been loaded with LOAD-OP (resp. compiled with COMPILE-OP.")) (defun downward-operation-depends-on (o c) `((,(or (downward-operation o) o) ,@(component-children c)))) (defmethod component-depends-on ((o downward-operation) (c parent-component)) `(,@(downward-operation-depends-on o c) ,@(call-next-method))) (defclass upward-operation (operation) ((upward-operation :initform nil :reader upward-operation :type operation-designator :allocation :class)) (:documentation "An UPWARD-OPERATION has dependencies that propagate up the component hierarchy. I.e., if O is an instance of UPWARD-OPERATION, and its UPWARD-OPERATION slot designates operation U, then the action (O . C) of O on a component C that has the parent P will depends on (U . P). The default value for slot UPWARD-OPERATION is NIL, which designates the operation O itself. E.g. in order for a COMPONENT to be prepared for loading or compiling with PREPARE-OP, its PARENT must first be prepared for loading or compiling with PREPARE-OP.")) ;; For backward-compatibility reasons, a system inherits from module and is a child-component ;; so we must guard against this case. ASDF4: remove that. (defun upward-operation-depends-on (o c) (if-let (p (component-parent c)) `((,(or (upward-operation o) o) ,p)))) (defmethod component-depends-on ((o upward-operation) (c child-component)) `(,@(upward-operation-depends-on o c) ,@(call-next-method))) (defclass sideway-operation (operation) ((sideway-operation :initform nil :reader sideway-operation :type operation-designator :allocation :class)) (:documentation "A SIDEWAY-OPERATION has dependencies that propagate \"sideway\" to siblings that a component depends on. I.e. if O is a SIDEWAY-OPERATION, and its SIDEWAY-OPERATION slot designates operation S (where NIL designates O itself), then the action (O . C) of O on component C depends on each of (S . D) where D is a declared dependency of C. E.g. in order for a COMPONENT to be prepared for loading or compiling with PREPARE-OP, each of its declared dependencies must first be loaded as by LOAD-OP.")) (defun sideway-operation-depends-on (o c) `((,(or (sideway-operation o) o) ,@(component-sideway-dependencies c)))) (defmethod component-depends-on ((o sideway-operation) (c component)) `(,@(sideway-operation-depends-on o c) ,@(call-next-method))) (defclass selfward-operation (operation) ((selfward-operation ;; NB: no :initform -- if an operation depends on others, it must explicitly specify which :type (or operation-designator list) :reader selfward-operation :allocation :class)) (:documentation "A SELFWARD-OPERATION depends on another operation on the same component. I.e., if O is a SELFWARD-OPERATION, and its SELFWARD-OPERATION designates a list of operations L, then the action (O . C) of O on component C depends on each (S . C) for S in L. E.g. before a component may be loaded by LOAD-OP, it must have been compiled by COMPILE-OP. A operation-designator designates a singleton list of the designated operation; a list of operation-designators designates the list of designated operations; NIL is not a valid operation designator in that context. Note that any dependency ordering between the operations in a list of SELFWARD-OPERATION should be specified separately in the respective operation's COMPONENT-DEPENDS-ON methods so that they be scheduled properly.")) (defun selfward-operation-depends-on (o c) (loop :for op :in (ensure-list (selfward-operation o)) :collect `(,op ,c))) (defmethod component-depends-on ((o selfward-operation) (c component)) `(,@(selfward-operation-depends-on o c) ,@(call-next-method))) (defclass non-propagating-operation (operation) () (:documentation "A NON-PROPAGATING-OPERATION is an operation that propagates no dependencies whatsoever. It is supplied in order that the programmer be able to specify that s/he is intentionally specifying an operation which invokes no dependencies."))) ;;;--------------------------------------------------------------------------- ;;; Help programmers catch obsolete OPERATION subclasses ;;;--------------------------------------------------------------------------- (with-upgradability () (define-condition operation-definition-warning (simple-warning) () (:documentation "Warning condition related to definition of obsolete OPERATION objects.")) (define-condition operation-definition-error (simple-error) () (:documentation "Error condition related to definition of incorrect OPERATION objects.")) (defmethod initialize-instance :before ((o operation) &key) (unless (typep o '(or downward-operation upward-operation sideway-operation selfward-operation non-propagating-operation)) (warn 'operation-definition-warning :format-control "No dependency propagating scheme specified for operation class ~S. The class needs to be updated for ASDF 3.1 and specify appropriate propagation mixins." :format-arguments (list (type-of o))))) (defmethod initialize-instance :before ((o non-propagating-operation) &key) (when (typep o '(or downward-operation upward-operation sideway-operation selfward-operation)) (error 'operation-definition-error :format-control "Inconsistent class: ~S NON-PROPAGATING-OPERATION is incompatible with propagating operation classes as superclasses." :format-arguments (list (type-of o))))) (defmethod component-depends-on ((o operation) (c component)) `(;; Normal behavior, to allow user-specified in-order-to dependencies ,@(cdr (assoc (type-of o) (component-in-order-to c))) ;; For backward-compatibility with ASDF2, any operation that doesn't specify propagation ;; or non-propagation through an appropriate mixin will be downward and sideway. ,@(unless (typep o '(or downward-operation upward-operation sideway-operation selfward-operation non-propagating-operation)) `(,@(sideway-operation-depends-on o c) ,@(when (typep c 'parent-component) (downward-operation-depends-on o c)))))) (defmethod downward-operation ((o operation)) nil) (defmethod sideway-operation ((o operation)) nil)) ;;;--------------------------------------------------------------------------- ;;; End of OPERATION class checking ;;;--------------------------------------------------------------------------- ;;;; Inputs, Outputs, and invisible dependencies (with-upgradability () (defgeneric* (output-files) (operation component)) (defgeneric* (input-files) (operation component)) (defgeneric* (operation-done-p) (operation component) (:documentation "Returns a boolean, which is NIL if the action is forced to be performed again")) (define-convenience-action-methods output-files (operation component)) (define-convenience-action-methods input-files (operation component)) (define-convenience-action-methods operation-done-p (operation component)) (defmethod operation-done-p ((o operation) (c component)) t) (defmethod output-files :around (operation component) "Translate output files, unless asked not to. Memoize the result." operation component ;; hush genera, not convinced by declare ignorable(!) (do-asdf-cache `(output-files ,operation ,component) (values (multiple-value-bind (pathnames fixedp) (call-next-method) ;; 1- Make sure we have absolute pathnames (let* ((directory (pathname-directory-pathname (component-pathname (find-component () component)))) (absolute-pathnames (loop :for pathname :in pathnames :collect (ensure-absolute-pathname pathname directory)))) ;; 2- Translate those pathnames as required (if fixedp absolute-pathnames (mapcar *output-translation-function* absolute-pathnames)))) t))) (defmethod output-files ((o operation) (c component)) nil) (defun output-file (operation component) "The unique output file of performing OPERATION on COMPONENT" (let ((files (output-files operation component))) (assert (length=n-p files 1)) (first files))) (defmethod input-files :around (operation component) "memoize input files." (do-asdf-cache `(input-files ,operation ,component) (call-next-method))) (defmethod input-files ((o operation) (c component)) nil) (defmethod input-files ((o selfward-operation) (c component)) `(,@(or (loop :for dep-o :in (ensure-list (selfward-operation o)) :append (or (output-files dep-o c) (input-files dep-o c))) (if-let ((pathname (component-pathname c))) (and (file-pathname-p pathname) (list pathname)))) ,@(call-next-method)))) ;;;; Done performing (with-upgradability () (defgeneric component-operation-time (operation component)) ;; ASDF4: hide it behind plan-action-stamp (define-convenience-action-methods component-operation-time (operation component)) (defgeneric mark-operation-done (operation component)) ;; ASDF4: hide it behind (setf plan-action-stamp) (defgeneric compute-action-stamp (plan operation component &key just-done) (:documentation "Has this action been successfully done already, and at what known timestamp has it been done at or will it be done at? Takes two keywords JUST-DONE and PLAN: JUST-DONE is a boolean that is true if the action was just successfully performed, at which point we want compute the actual stamp and warn if files are missing; otherwise we are making plans, anticipating the effects of the action. PLAN is a plan object modelling future effects of actions, or NIL to denote what actually happened. Returns two values: * a STAMP saying when it was done or will be done, or T if the action has involves files that need to be recomputed. * a boolean DONE-P that indicates whether the action has actually been done, and both its output-files and its in-image side-effects are up to date.")) (defclass action-status () ((stamp :initarg :stamp :reader action-stamp :documentation "STAMP associated with the ACTION if it has been completed already in some previous image, or T if it needs to be done.") (done-p :initarg :done-p :reader action-done-p :documentation "a boolean, true iff the action was already done (before any planned action).")) (:documentation "Status of an action")) (defmethod print-object ((status action-status) stream) (print-unreadable-object (status stream :type t) (with-slots (stamp done-p) status (format stream "~@{~S~^ ~}" :stamp stamp :done-p done-p)))) (defmethod component-operation-time ((o operation) (c component)) (gethash (type-of o) (component-operation-times c))) (defmethod mark-operation-done ((o operation) (c component)) (setf (gethash (type-of o) (component-operation-times c)) (compute-action-stamp nil o c :just-done t)))) ;;;; Perform (with-upgradability () (defgeneric* (perform-with-restarts) (operation component)) (defgeneric* (perform) (operation component)) (define-convenience-action-methods perform (operation component)) (defmethod perform :before ((o operation) (c component)) (ensure-all-directories-exist (output-files o c))) (defmethod perform :after ((o operation) (c component)) (mark-operation-done o c)) (defmethod perform ((o operation) (c parent-component)) nil) (defmethod perform ((o operation) (c source-file)) ;; For backward compatibility, don't error on operations that don't specify propagation. (when (typep o '(or downward-operation upward-operation sideway-operation selfward-operation non-propagating-operation)) (sysdef-error (compatfmt "~@") 'perform (cons o c)))) (defmethod perform-with-restarts (operation component) ;; TOO verbose, especially as the default. Add your own :before method ;; to perform-with-restart or perform if you want that: #|(explain operation component)|# (perform operation component)) (defmethod perform-with-restarts :around (operation component) (loop (restart-case (return (call-next-method)) (retry () :report (lambda (s) (format s (compatfmt "~@") (action-description operation component)))) (accept () :report (lambda (s) (format s (compatfmt "~@") (action-description operation component))) (mark-operation-done operation component) (return)))))) ;;;; ------------------------------------------------------------------------- ;;;; Actions to build Common Lisp software (uiop/package:define-package :asdf/lisp-action (:recycle :asdf/lisp-action :asdf) (:intern #:proclamations #:flags) (:use :uiop/common-lisp :uiop :asdf/upgrade :asdf/cache :asdf/component :asdf/system :asdf/find-component :asdf/find-system :asdf/operation :asdf/action) (:export #:try-recompiling #:cl-source-file #:cl-source-file.cl #:cl-source-file.lsp #:basic-load-op #:basic-compile-op #:compile-op-flags #:compile-op-proclamations #:load-op #:prepare-op #:compile-op #:test-op #:load-source-op #:prepare-source-op #:call-with-around-compile-hook #:perform-lisp-compilation #:perform-lisp-load-fasl #:perform-lisp-load-source #:lisp-compilation-output-files #:flags)) (in-package :asdf/lisp-action) ;;;; Component classes (with-upgradability () (defclass cl-source-file (source-file) ((type :initform "lisp"))) (defclass cl-source-file.cl (cl-source-file) ((type :initform "cl"))) (defclass cl-source-file.lsp (cl-source-file) ((type :initform "lsp")))) ;;;; Operation classes (with-upgradability () (defclass basic-load-op (operation) ()) (defclass basic-compile-op (operation) ((proclamations :initarg :proclamations :accessor compile-op-proclamations :initform nil) (flags :initarg :flags :accessor compile-op-flags :initform nil)))) ;;; Our default operations: loading into the current lisp image (with-upgradability () (defclass prepare-op (upward-operation sideway-operation) ((sideway-operation :initform 'load-op :allocation :class)) (:documentation "Load dependencies necessary for COMPILE-OP or LOAD-OP of a given COMPONENT.")) (defclass load-op (basic-load-op downward-operation selfward-operation) ;; NB: even though compile-op depends on prepare-op it is not needed-in-image-p, ;; so we need to directly depend on prepare-op for its side-effects in the current image. ((selfward-operation :initform '(prepare-op compile-op) :allocation :class))) (defclass compile-op (basic-compile-op downward-operation selfward-operation) ((selfward-operation :initform 'prepare-op :allocation :class))) (defclass prepare-source-op (upward-operation sideway-operation) ((sideway-operation :initform 'load-source-op :allocation :class))) (defclass load-source-op (basic-load-op downward-operation selfward-operation) ((selfward-operation :initform 'prepare-source-op :allocation :class))) (defclass test-op (selfward-operation) ((selfward-operation :initform 'load-op :allocation :class)))) ;;;; prepare-op, compile-op and load-op ;;; prepare-op (with-upgradability () (defmethod action-description ((o prepare-op) (c component)) (format nil (compatfmt "~@") c)) (defmethod perform ((o prepare-op) (c component)) nil) (defmethod input-files ((o prepare-op) (s system)) (if-let (it (system-source-file s)) (list it)))) ;;; compile-op (with-upgradability () (defmethod action-description ((o compile-op) (c component)) (format nil (compatfmt "~@") c)) (defmethod action-description ((o compile-op) (c parent-component)) (format nil (compatfmt "~@") c)) (defgeneric call-with-around-compile-hook (component thunk)) (defmethod call-with-around-compile-hook ((c component) function) (call-around-hook (around-compile-hook c) function)) (defun perform-lisp-compilation (o c) (let (;; Before 2.26.53, that was unfortunately component-pathname. Now, ;; we consult input-files, the first of which should be the one to compile-file (input-file (first (input-files o c))) ;; on some implementations, there are more than one output-file, ;; but the first one should always be the primary fasl that gets loaded. (outputs (output-files o c))) (multiple-value-bind (output warnings-p failure-p) (destructuring-bind (output-file &optional #+(or clasp ecl mkcl) object-file #+clisp lib-file warnings-file) outputs (call-with-around-compile-hook c #'(lambda (&rest flags) (apply 'compile-file* input-file :output-file output-file :external-format (component-external-format c) :warnings-file warnings-file (append #+clisp (list :lib-file lib-file) #+(or clasp ecl mkcl) (list :object-file object-file) flags (compile-op-flags o)))))) (check-lisp-compile-results output warnings-p failure-p "~/asdf-action::format-action/" (list (cons o c)))))) (defun report-file-p (f) (equalp (pathname-type f) "build-report")) (defun perform-lisp-warnings-check (o c) (let* ((expected-warnings-files (remove-if-not #'warnings-file-p (input-files o c))) (actual-warnings-files (loop :for w :in expected-warnings-files :when (get-file-stamp w) :collect w :else :do (warn "Missing warnings file ~S while ~A" w (action-description o c))))) (check-deferred-warnings actual-warnings-files) (let* ((output (output-files o c)) (report (find-if #'report-file-p output))) (when report (with-open-file (s report :direction :output :if-exists :supersede) (format s ":success~%")))))) (defmethod perform ((o compile-op) (c cl-source-file)) (perform-lisp-compilation o c)) (defun lisp-compilation-output-files (o c) (let* ((i (first (input-files o c))) (f (compile-file-pathname i #+clasp :output-type #+ecl :type #+(or clasp ecl) :fasl #+mkcl :fasl-p #+mkcl t))) `(,f ;; the fasl is the primary output, in first position #+clasp ,@(unless nil ;; was (use-ecl-byte-compiler-p) `(,(compile-file-pathname i :output-type :object))) #+clisp ,@`(,(make-pathname :type "lib" :defaults f)) #+ecl ,@(unless (use-ecl-byte-compiler-p) `(,(compile-file-pathname i :type :object))) #+mkcl ,(compile-file-pathname i :fasl-p nil) ;; object file ,@(when (and *warnings-file-type* (not (builtin-system-p (component-system c)))) `(,(make-pathname :type *warnings-file-type* :defaults f)))))) (defmethod output-files ((o compile-op) (c cl-source-file)) (lisp-compilation-output-files o c)) (defmethod perform ((o compile-op) (c static-file)) nil) (defmethod perform ((o compile-op) (c system)) (when (and *warnings-file-type* (not (builtin-system-p c))) (perform-lisp-warnings-check o c))) (defmethod input-files ((o compile-op) (c system)) (when (and *warnings-file-type* (not (builtin-system-p c))) ;; The most correct way to do it would be to use: ;; (traverse-sub-actions o c :other-systems nil :keep-operation 'compile-op :keep-component 'cl-source-file) ;; but it's expensive and we don't care too much about file order or ASDF extensions. (loop :for sub :in (sub-components c :type 'cl-source-file) :nconc (remove-if-not 'warnings-file-p (output-files o sub))))) (defmethod output-files ((o compile-op) (c system)) (when (and *warnings-file-type* (not (builtin-system-p c))) (if-let ((pathname (component-pathname c))) (list (subpathname pathname (coerce-filename c) :type "build-report")))))) ;;; load-op (with-upgradability () (defmethod action-description ((o load-op) (c cl-source-file)) (format nil (compatfmt "~@") c)) (defmethod action-description ((o load-op) (c parent-component)) (format nil (compatfmt "~@") c)) (defmethod action-description ((o load-op) (c component)) (format nil (compatfmt "~@") c)) (defmethod perform-with-restarts ((o load-op) (c cl-source-file)) (loop (restart-case (return (call-next-method)) (try-recompiling () :report (lambda (s) (format s "Recompile ~a and try loading it again" (component-name c))) (perform (find-operation o 'compile-op) c))))) (defun perform-lisp-load-fasl (o c) (if-let (fasl (first (input-files o c))) (load* fasl))) (defmethod perform ((o load-op) (c cl-source-file)) (perform-lisp-load-fasl o c)) (defmethod perform ((o load-op) (c static-file)) nil)) ;;;; prepare-source-op, load-source-op ;;; prepare-source-op (with-upgradability () (defmethod action-description ((o prepare-source-op) (c component)) (format nil (compatfmt "~@") c)) (defmethod input-files ((o prepare-source-op) (s system)) (if-let (it (system-source-file s)) (list it))) (defmethod perform ((o prepare-source-op) (c component)) nil)) ;;; load-source-op (with-upgradability () (defmethod action-description ((o load-source-op) (c component)) (format nil (compatfmt "~@") c)) (defmethod action-description ((o load-source-op) (c parent-component)) (format nil (compatfmt "~@") c)) (defun perform-lisp-load-source (o c) (call-with-around-compile-hook c #'(lambda () (load* (first (input-files o c)) :external-format (component-external-format c))))) (defmethod perform ((o load-source-op) (c cl-source-file)) (perform-lisp-load-source o c)) (defmethod perform ((o load-source-op) (c static-file)) nil)) ;;;; test-op (with-upgradability () (defmethod perform ((o test-op) (c component)) nil) (defmethod operation-done-p ((o test-op) (c system)) "Testing a system is _never_ done." nil)) ;;;; ------------------------------------------------------------------------- ;;;; Plan (uiop/package:define-package :asdf/plan (:recycle :asdf/plan :asdf) (:use :uiop/common-lisp :uiop :asdf/upgrade :asdf/component :asdf/operation :asdf/system :asdf/cache :asdf/find-system :asdf/find-component :asdf/operation :asdf/action :asdf/lisp-action) (:export #:component-operation-time #:mark-operation-done #:plan #:plan-traversal #:sequential-plan #:*default-plan-class* #:planned-action-status #:plan-action-status #:action-already-done-p #:circular-dependency #:circular-dependency-actions #:node-for #:needed-in-image-p #:action-index #:action-planned-p #:action-valid-p #:plan-record-dependency #:normalize-forced-systems #:action-forced-p #:action-forced-not-p #:map-direct-dependencies #:reduce-direct-dependencies #:direct-dependencies #:compute-action-stamp #:traverse-action #:circular-dependency #:circular-dependency-actions #:call-while-visiting-action #:while-visiting-action #:make-plan #:plan-actions #:perform-plan #:plan-operates-on-p #:planned-p #:index #:forced #:forced-not #:total-action-count #:planned-action-count #:planned-output-action-count #:visited-actions #:visiting-action-set #:visiting-action-list #:plan-actions-r #:required-components #:filtered-sequential-plan #:plan-system #:plan-action-filter #:plan-component-type #:plan-keep-operation #:plan-keep-component #:traverse-actions #:traverse-sub-actions)) (in-package :asdf/plan) ;;;; Generic plan traversal class (with-upgradability () (defclass plan () ()) (defclass plan-traversal (plan) ((system :initform nil :initarg :system :accessor plan-system) (forced :initform nil :initarg :force :accessor plan-forced) (forced-not :initform nil :initarg :force-not :accessor plan-forced-not) (total-action-count :initform 0 :accessor plan-total-action-count) (planned-action-count :initform 0 :accessor plan-planned-action-count) (planned-output-action-count :initform 0 :accessor plan-planned-output-action-count) (visited-actions :initform (make-hash-table :test 'equal) :accessor plan-visited-actions) (visiting-action-set :initform (make-hash-table :test 'equal) :accessor plan-visiting-action-set) (visiting-action-list :initform () :accessor plan-visiting-action-list)))) ;;;; Planned action status (with-upgradability () (defgeneric plan-action-status (plan operation component) (:documentation "Returns the ACTION-STATUS associated to the action of OPERATION on COMPONENT in the PLAN")) (defgeneric (setf plan-action-status) (new-status plan operation component) (:documentation "Sets the ACTION-STATUS associated to the action of OPERATION on COMPONENT in the PLAN")) (defclass planned-action-status (action-status) ((planned-p :initarg :planned-p :reader action-planned-p :documentation "a boolean, true iff the action was included in the plan.") (index :initarg :index :reader action-index :documentation "an integer, counting all traversed actions in traversal order.")) (:documentation "Status of an action in a plan")) (defmethod print-object ((status planned-action-status) stream) (print-unreadable-object (status stream :type t :identity nil) (with-slots (stamp done-p planned-p index) status (format stream "~@{~S~^ ~}" :stamp stamp :done-p done-p :planned-p planned-p :index index)))) (defmethod action-planned-p ((action-status t)) t) ; default method for non planned-action-status objects ;; TODO: eliminate NODE-FOR, use CONS. ;; Supposes cleaner protocol for operation initargs passed to MAKE-OPERATION. ;; However, see also component-operation-time and mark-operation-done (defun node-for (o c) (cons (type-of o) c)) (defun action-already-done-p (plan operation component) (action-done-p (plan-action-status plan operation component))) (defmethod plan-action-status ((plan null) (o operation) (c component)) (multiple-value-bind (stamp done-p) (component-operation-time o c) (make-instance 'action-status :stamp stamp :done-p done-p))) (defmethod (setf plan-action-status) (new-status (plan null) (o operation) (c component)) (let ((to (type-of o)) (times (component-operation-times c))) (if (action-done-p new-status) (remhash to times) (setf (gethash to times) (action-stamp new-status)))) new-status)) ;;;; forcing (with-upgradability () (defgeneric action-forced-p (plan operation component)) (defgeneric action-forced-not-p (plan operation component)) (defun normalize-forced-systems (x system) (etypecase x ((or (member nil :all) hash-table function) x) (cons (list-to-hash-set (mapcar #'coerce-name x))) ((eql t) (when system (list-to-hash-set (list (coerce-name system))))))) (defun normalize-forced-not-systems (x system) (let ((requested (etypecase x ((or (member nil :all) hash-table function) x) (cons (list-to-hash-set (mapcar #'coerce-name x))) ((eql t) (if system (let ((name (coerce-name system))) #'(lambda (x) (not (equal x name)))) t))))) (if (and *immutable-systems* requested) #'(lambda (x) (or (call-function requested x) (call-function *immutable-systems* x))) (or *immutable-systems* requested)))) (defun action-override-p (plan operation component override-accessor) (declare (ignore operation)) (call-function (funcall override-accessor plan) (coerce-name (component-system (find-component () component))))) (defmethod action-forced-p (plan operation component) (and ;; Did the user ask us to re-perform the action? (action-override-p plan operation component 'plan-forced) ;; You really can't force a builtin system and :all doesn't apply to it, ;; except it it's the specifically the system currently being built. (not (let ((system (component-system component))) (and (builtin-system-p system) (not (eq system (plan-system plan)))))))) (defmethod action-forced-not-p (plan operation component) ;; Did the user ask us to not re-perform the action? ;; NB: force-not takes precedence over force, as it should (action-override-p plan operation component 'plan-forced-not)) (defmethod action-forced-p ((plan null) (operation operation) (component component)) nil) (defmethod action-forced-not-p ((plan null) (operation operation) (component component)) nil)) ;;;; action-valid-p (with-upgradability () (defgeneric action-valid-p (plan operation component) (:documentation "Is this action valid to include amongst dependencies?")) (defmethod action-valid-p ((plan t) (o operation) (c component)) (if-let (it (component-if-feature c)) (featurep it) t)) (defmethod action-valid-p ((plan t) (o null) (c t)) nil) (defmethod action-valid-p ((plan t) (o t) (c null)) nil) (defmethod action-valid-p ((plan null) (o operation) (c component)) t)) ;;;; Is the action needed in this image? (with-upgradability () (defgeneric needed-in-image-p (operation component) (:documentation "Is the action of OPERATION on COMPONENT needed in the current image to be meaningful, or could it just as well have been done in another Lisp image?")) (defmethod needed-in-image-p ((o operation) (c component)) ;; We presume that actions that modify the filesystem don't need be run ;; in the current image if they have already been done in another, ;; and can be run in another process (e.g. a fork), ;; whereas those that don't are meant to side-effect the current image and can't. (not (output-files o c)))) ;;;; Visiting dependencies of an action and computing action stamps (with-upgradability () (defun (map-direct-dependencies) (plan operation component fun) (loop* :for (dep-o-spec . dep-c-specs) :in (component-depends-on operation component) :for dep-o = (find-operation operation dep-o-spec) :when dep-o :do (loop :for dep-c-spec :in dep-c-specs :for dep-c = (and dep-c-spec (resolve-dependency-spec component dep-c-spec)) :when (and dep-c (action-valid-p plan dep-o dep-c)) :do (funcall fun dep-o dep-c)))) (defun (reduce-direct-dependencies) (plan operation component combinator seed) (map-direct-dependencies plan operation component #'(lambda (dep-o dep-c) (setf seed (funcall combinator dep-o dep-c seed)))) seed) (defun (direct-dependencies) (plan operation component) (reduce-direct-dependencies plan operation component #'acons nil)) ;; In a distant future, get-file-stamp, component-operation-time and latest-stamp ;; shall also be parametrized by the plan, or by a second model object, ;; so they need not refer to the state of the filesystem, ;; and the stamps could be cryptographic checksums rather than timestamps. ;; Such a change remarkably would only affect COMPUTE-ACTION-STAMP. (defmethod compute-action-stamp (plan (o operation) (c component) &key just-done) ;; Given an action, figure out at what time in the past it has been done, ;; or if it has just been done, return the time that it has. ;; Returns two values: ;; 1- the TIMESTAMP of the action if it has already been done and is up to date, ;; or T is either hasn't been done or is out of date. ;; 2- the DONE-IN-IMAGE-P boolean flag that is T if the action has already been done ;; in the current image, or NIL if it hasn't. ;; Note that if e.g. LOAD-OP only depends on up-to-date files, but ;; hasn't been done in the current image yet, then it can have a non-T timestamp, ;; yet a NIL done-in-image-p flag. (nest (block ()) (let ((dep-stamp ; collect timestamp from dependencies (or T if forced or out-of-date) (reduce-direct-dependencies plan o c #'(lambda (o c stamp) (if-let (it (plan-action-status plan o c)) (latest-stamp stamp (action-stamp it)) t)) nil))) ;; out-of-date dependency: don't bother expensively querying the filesystem (when (and (eq dep-stamp t) (not just-done)) (return (values t nil)))) ;; collect timestamps from inputs, and exit early if any is missing (let* ((in-files (input-files o c)) (in-stamps (mapcar #'get-file-stamp in-files)) (missing-in (loop :for f :in in-files :for s :in in-stamps :unless s :collect f)) (latest-in (stamps-latest (cons dep-stamp in-stamps)))) (when (and missing-in (not just-done)) (return (values t nil)))) ;; collect timestamps from outputs, and exit early if any is missing (let* ((out-files (output-files o c)) (out-stamps (mapcar (if just-done 'register-file-stamp 'get-file-stamp) out-files)) (missing-out (loop :for f :in out-files :for s :in out-stamps :unless s :collect f)) (earliest-out (stamps-earliest out-stamps))) (when (and missing-out (not just-done)) (return (values t nil)))) (let* (;; There are three kinds of actions: (out-op (and out-files t)) ; those that create files on the filesystem ;;(image-op (and in-files (null out-files))) ; those that load stuff into the image ;;(null-op (and (null out-files) (null in-files))) ; placeholders that do nothing ;; When was the thing last actually done? (Now, or ask.) (op-time (or just-done (component-operation-time o c))) ;; Time stamps from the files at hand, and whether any is missing (all-present (not (or missing-in missing-out))) ;; Has any input changed since we last generated the files? (up-to-date-p (stamp<= latest-in earliest-out)) ;; If everything is up to date, the latest of inputs and outputs is our stamp (done-stamp (stamps-latest (cons latest-in out-stamps)))) ;; Warn if some files are missing: ;; either our model is wrong or some other process is messing with our files. (when (and just-done (not all-present)) (warn "~A completed without ~:[~*~;~*its input file~:p~2:*~{ ~S~}~*~]~ ~:[~; or ~]~:[~*~;~*its output file~:p~2:*~{ ~S~}~*~]" (action-description o c) missing-in (length missing-in) (and missing-in missing-out) missing-out (length missing-out)))) ;; Note that we use stamp<= instead of stamp< to play nice with generated files. ;; Any race condition is intrinsic to the limited timestamp resolution. (if (or just-done ;; The done-stamp is valid: if we're just done, or ;; if all filesystem effects are up-to-date and there's no invalidating reason. (and all-present up-to-date-p (operation-done-p o c) (not (action-forced-p plan o c)))) (values done-stamp ;; return the hard-earned timestamp (or just-done out-op ;; a file-creating op is done when all files are up to date ;; a image-effecting a placeholder op is done when it was actually run, (and op-time (eql op-time done-stamp)))) ;; with the matching stamp ;; done-stamp invalid: return a timestamp in an indefinite future, action not done yet (values t nil))))) ;;;; Generic support for plan-traversal (with-upgradability () (defgeneric plan-record-dependency (plan operation component)) (defgeneric call-while-visiting-action (plan operation component function) (:documentation "Detect circular dependencies")) (defmethod initialize-instance :after ((plan plan-traversal) &key force force-not system &allow-other-keys) (with-slots (forced forced-not) plan (setf forced (normalize-forced-systems force system)) (setf forced-not (normalize-forced-not-systems force-not system)))) (defmethod (setf plan-action-status) (new-status (plan plan-traversal) (o operation) (c component)) (setf (gethash (node-for o c) (plan-visited-actions plan)) new-status)) (defmethod plan-action-status ((plan plan-traversal) (o operation) (c component)) (or (and (action-forced-not-p plan o c) (plan-action-status nil o c)) (values (gethash (node-for o c) (plan-visited-actions plan))))) (defmethod action-valid-p ((plan plan-traversal) (o operation) (s system)) (and (not (action-forced-not-p plan o s)) (call-next-method))) (defmethod call-while-visiting-action ((plan plan-traversal) operation component fun) (with-accessors ((action-set plan-visiting-action-set) (action-list plan-visiting-action-list)) plan (let ((action (cons operation component))) (when (gethash action action-set) (error 'circular-dependency :actions (member action (reverse action-list) :test 'equal))) (setf (gethash action action-set) t) (push action action-list) (unwind-protect (funcall fun) (pop action-list) (setf (gethash action action-set) nil)))))) ;;;; Actual traversal: traverse-action (with-upgradability () (define-condition circular-dependency (system-definition-error) ((actions :initarg :actions :reader circular-dependency-actions)) (:report (lambda (c s) (format s (compatfmt "~@") (circular-dependency-actions c))))) (defmacro while-visiting-action ((p o c) &body body) `(call-while-visiting-action ,p ,o ,c #'(lambda () ,@body))) (defgeneric traverse-action (plan operation component needed-in-image-p)) ;; TRAVERSE-ACTION, in the context of a given PLAN object that accumulates dependency data, ;; visits the action defined by its OPERATION and COMPONENT arguments, ;; and all its transitive dependencies (unless already visited), ;; in the context of the action being (or not) NEEDED-IN-IMAGE-P, ;; i.e. needs to be done in the current image vs merely have been done in a previous image. ;; For actions that are up-to-date, it returns a STAMP identifying the state of the action ;; (that's timestamp, but it could be a cryptographic digest in some ASDF extension), ;; or T if the action needs to be done again. ;; ;; Note that for an XCVB-like plan with one-image-per-file-outputting-action, ;; the below method would be insufficient, since it assumes a single image ;; to traverse each node at most twice; non-niip actions would be traversed only once, ;; but niip nodes could be traversed once per image, i.e. once plus once per non-niip action. (defmethod traverse-action (plan operation component needed-in-image-p) (block nil ;; ACTION-VALID-P among other things, handles forcing logic, including FORCE-NOT, ;; and IF-FEATURE filtering. (unless (action-valid-p plan operation component) (return nil)) ;; the following hook is needed by POIU, which tracks a full dependency graph, ;; instead of just a dependency order as in vanilla ASDF (plan-record-dependency plan operation component) ;; needed in image distinguishes b/w things that must happen in the ;; current image and those things that simply need to have been done in a previous one. (let* ((aniip (needed-in-image-p operation component)) ; action-specific needed-in-image ;; effective niip: meaningful for the action and required by the plan as traversed (eniip (and aniip needed-in-image-p)) ;; status: have we traversed that action previously, and if so what was its status? (status (plan-action-status plan operation component))) (when (and status (or (action-done-p status) (action-planned-p status) (not eniip))) (return (action-stamp status))) ; Already visited with sufficient need-in-image level! (labels ((visit-action (niip) ; We may visit the action twice, once with niip NIL, then T (map-direct-dependencies ; recursively traverse dependencies plan operation component #'(lambda (o c) (traverse-action plan o c niip))) (multiple-value-bind (stamp done-p) ; AFTER dependencies have been traversed, (compute-action-stamp plan operation component) ; compute action stamp (let ((add-to-plan-p (or (eql stamp t) (and niip (not done-p))))) (cond ; it needs be done if it's out of date or needed in image but absent ((and add-to-plan-p (not niip)) ; if we need to do it, (visit-action t)) ; then we need to do it *in the (current) image*! (t (setf (plan-action-status plan operation component) ; update status: (make-instance 'planned-action-status :stamp stamp ; computed stamp :done-p (and done-p (not add-to-plan-p)) ; done *and* up-to-date? :planned-p add-to-plan-p ; included in list of things to be done? :index (if status ; index of action amongst all nodes in traversal (action-index status) ;; if already visited, keep index (incf (plan-total-action-count plan))))) ; else new index (when add-to-plan-p ; if it needs to be added to the plan, (incf (plan-planned-action-count plan)) ; count it (unless aniip ; if it's output-producing, (incf (plan-planned-output-action-count plan)))) ; count it stamp)))))) ; return the stamp (while-visiting-action (plan operation component) ; maintain context, handle circularity. (visit-action eniip))))))) ; visit the action ;;;; Sequential plans (the default) (with-upgradability () (defclass sequential-plan (plan-traversal) ((actions-r :initform nil :accessor plan-actions-r))) (defgeneric plan-actions (plan)) (defmethod plan-actions ((plan list)) plan) (defmethod plan-actions ((plan sequential-plan)) (reverse (plan-actions-r plan))) (defmethod plan-record-dependency ((plan sequential-plan) (o operation) (c component)) (values)) (defmethod (setf plan-action-status) :after (new-status (p sequential-plan) (o operation) (c component)) (when (action-planned-p new-status) (push (cons o c) (plan-actions-r p))))) ;;;; High-level interface: traverse, perform-plan, plan-operates-on-p (with-upgradability () (defgeneric make-plan (plan-class operation component &key &allow-other-keys) (:documentation "Generate and return a plan for performing OPERATION on COMPONENT.")) (define-convenience-action-methods make-plan (plan-class operation component &key)) (defgeneric perform-plan (plan &key)) (defgeneric plan-operates-on-p (plan component)) (defvar *default-plan-class* 'sequential-plan) (defmethod make-plan (plan-class (o operation) (c component) &rest keys &key &allow-other-keys) (let ((plan (apply 'make-instance (or plan-class *default-plan-class*) :system (component-system c) keys))) (traverse-action plan o c t) plan)) (defmethod perform-plan :around ((plan t) &key) #+xcl (declare (ignorable plan)) (let ((*package* *package*) (*readtable* *readtable*)) (with-compilation-unit () ;; backward-compatibility. (call-next-method)))) ;; Going forward, see deferred-warning support in lisp-build. (defmethod perform-plan ((plan t) &rest keys &key &allow-other-keys) (apply 'perform-plan (plan-actions plan) keys)) (defmethod perform-plan ((steps list) &key force &allow-other-keys) (loop* :for (o . c) :in steps :when (or force (not (nth-value 1 (compute-action-stamp nil o c)))) :do (perform-with-restarts o c))) (defmethod plan-operates-on-p ((plan plan-traversal) (component-path list)) (plan-operates-on-p (plan-actions plan) component-path)) (defmethod plan-operates-on-p ((plan list) (component-path list)) (find component-path (mapcar 'cdr plan) :test 'equal :key 'component-find-path))) ;;;; Incidental traversals ;;; Making a FILTERED-SEQUENTIAL-PLAN can be used to, e.g., all of the source ;;; files required by a bundling operation. (with-upgradability () (defclass filtered-sequential-plan (sequential-plan) ((action-filter :initform t :initarg :action-filter :reader plan-action-filter) (component-type :initform t :initarg :component-type :reader plan-component-type) (keep-operation :initform t :initarg :keep-operation :reader plan-keep-operation) (keep-component :initform t :initarg :keep-component :reader plan-keep-component))) (defmethod initialize-instance :after ((plan filtered-sequential-plan) &key force force-not other-systems) (declare (ignore force force-not)) (with-slots (forced forced-not action-filter system) plan (setf forced (normalize-forced-systems (if other-systems :all t) system)) (setf forced-not (normalize-forced-not-systems (if other-systems nil t) system)) (setf action-filter (ensure-function action-filter)))) (defmethod action-valid-p ((plan filtered-sequential-plan) o c) (and (funcall (plan-action-filter plan) o c) (typep c (plan-component-type plan)) (call-next-method))) (defmethod traverse-actions (actions &rest keys &key plan-class &allow-other-keys) (let ((plan (apply 'make-instance (or plan-class 'filtered-sequential-plan) keys))) (loop* :for (o . c) :in actions :do (traverse-action plan o c t)) plan)) (define-convenience-action-methods traverse-sub-actions (operation component &key)) (defmethod traverse-sub-actions ((operation operation) (component component) &rest keys &key &allow-other-keys) (apply 'traverse-actions (direct-dependencies t operation component) :system (component-system component) keys)) (defmethod plan-actions ((plan filtered-sequential-plan)) (with-slots (keep-operation keep-component) plan (loop* :for (o . c) :in (call-next-method) :when (and (typep o keep-operation) (typep c keep-component)) :collect (cons o c)))) (defmethod required-components (system &rest keys &key (goal-operation 'load-op) &allow-other-keys) (remove-duplicates (mapcar 'cdr (plan-actions (apply 'traverse-sub-actions goal-operation system (remove-plist-key :goal-operation keys)))) :from-end t))) ;;;; ------------------------------------------------------------------------- ;;;; Invoking Operations (uiop/package:define-package :asdf/operate (:recycle :asdf/operate :asdf) (:use :uiop/common-lisp :uiop :asdf/upgrade :asdf/cache :asdf/component :asdf/system :asdf/operation :asdf/action :asdf/find-system :asdf/find-component :asdf/lisp-action :asdf/plan) (:export #:operate #:oos #:*systems-being-operated* #:build-op #:make #:load-system #:load-systems #:load-systems* #:compile-system #:test-system #:require-system #:*load-system-operation* #:module-provide-asdf #:component-loaded-p #:already-loaded-systems)) (in-package :asdf/operate) (with-upgradability () (defgeneric* (operate) (operation component &key &allow-other-keys) (:documentation "Operate does three things: 1. It creates an instance of OPERATION-CLASS using any keyword parameters as initargs. 2. It finds the asdf-system specified by SYSTEM (possibly loading it from disk). 3. It then calls MAKE-PLAN with the operation and system as arguments The operation of making a plan is wrapped in WITH-COMPILATION-UNIT and error handling code. If a VERSION argument is supplied, then operate also ensures that the system found satisfies it using the VERSION-SATISFIES method. Note that dependencies may cause the operation to invoke other operations on the system or its components: the new operations will be created with the same initargs as the original one. The :FORCE or :FORCE-NOT argument to OPERATE can be: T to force the inside of the specified system to be rebuilt (resp. not), without recursively forcing the other systems we depend on. :ALL to force all systems including other systems we depend on to be rebuilt (resp. not). (SYSTEM1 SYSTEM2 ... SYSTEMN) to force systems named in a given list :FORCE has precedence over :FORCE-NOT; builtin systems cannot be forced.")) (define-convenience-action-methods operate (operation component &key) ;; I'd like to at least remove-plist-keys :force :force-not :verbose, ;; but swank.asd relies on :force (!). :operation-initargs t ;; backward-compatibility with ASDF1. Yuck. :if-no-component (error 'missing-component :requires component)) (defvar *systems-being-operated* nil "A boolean indicating that some systems are being operated on") (defmethod operate :around (operation component &rest keys &key verbose (on-warnings *compile-file-warnings-behaviour*) (on-failure *compile-file-failure-behaviour*) &allow-other-keys) (let* ((systems-being-operated *systems-being-operated*) (*systems-being-operated* (or systems-being-operated (make-hash-table :test 'equal))) (operation-remaker ;; how to remake the operation after ASDF was upgraded (if it was) (etypecase operation (operation (let ((name (type-of operation)) (initargs (operation-original-initargs operation))) #'(lambda () (apply 'make-operation name :original-initargs initargs initargs)))) ((or symbol string) (constantly operation)))) (component-path (typecase component ;; to remake the component after ASDF upgrade (component (component-find-path component)) (t component)))) ;; Before we operate on any system, make sure ASDF is up-to-date, ;; for if an upgrade is ever attempted at any later time, there may be BIG trouble. (unless systems-being-operated (when (upgrade-asdf) ;; If we were upgraded, restart OPERATE the hardest of ways, for ;; its function may have been redefined, its symbol uninterned, its package deleted. (return-from operate (apply 'operate (funcall operation-remaker) component-path keys)))) ;; Setup proper bindings around any operate call. (with-asdf-cache () (let* ((*verbose-out* (and verbose *standard-output*)) (*compile-file-warnings-behaviour* on-warnings) (*compile-file-failure-behaviour* on-failure)) (call-next-method))))) (defmethod operate :before ((operation operation) (component component) &key version &allow-other-keys) (let ((system (component-system component))) (setf (gethash (coerce-name system) *systems-being-operated*) system)) (unless (version-satisfies component version) (error 'missing-component-of-version :requires component :version version))) (defmethod operate ((operation operation) (component component) &rest keys &key plan-class &allow-other-keys) (let ((plan (apply 'make-plan plan-class operation component keys))) (apply 'perform-plan plan keys) (values operation plan))) (defun oos (operation component &rest args &key &allow-other-keys) (apply 'operate operation component args)) (setf (documentation 'oos 'function) (format nil "Short for _operate on system_ and an alias for the OPERATE function.~%~%~a" (documentation 'operate 'function)))) ;;;; Common operations (with-upgradability () (defvar *load-system-operation* 'load-op "Operation used by ASDF:LOAD-SYSTEM. By default, ASDF:LOAD-OP. You may override it with e.g. ASDF:LOAD-FASL-OP from asdf-bundle or ASDF:LOAD-SOURCE-OP if your fasl loading is somehow broken. The default operation may change in the future if we implement a component-directed strategy for how to load or compile systems.") (defmethod component-depends-on ((o prepare-op) (s system)) (loop :for (o . cs) :in (call-next-method) :collect (cons (if (eq o 'load-op) *load-system-operation* o) cs))) (defclass build-op (non-propagating-operation) () (:documentation "Since ASDF3, BUILD-OP is the recommended 'master' operation, to operate by default on a system or component, via the function BUILD. Its meaning is configurable via the :BUILD-OPERATION option of a component. which typically specifies the name of a specific operation to which to delegate the build, as a symbol or as a string later read as a symbol (after loading the defsystem-depends-on); if NIL is specified (the default), BUILD-OP falls back to the *LOAD-SYSTEM-OPERATION* that will load the system in the current image, and its typically LOAD-OP.")) (defmethod component-depends-on ((o build-op) (c component)) `((,(or (component-build-operation c) *load-system-operation*) ,c) ,@(call-next-method))) (defun make (system &rest keys) "The recommended way to interact with ASDF3.1 is via (ASDF:MAKE :FOO). It will build system FOO using the operation BUILD-OP, the meaning of which is configurable by the system, and defaults to *LOAD-SYSTEM-OPERATION*, usually LOAD-OP, to load it in current image." (apply 'operate 'build-op system keys) t) (defun load-system (system &rest keys &key force force-not verbose version &allow-other-keys) "Shorthand for `(operate 'asdf:load-op system)`. See OPERATE for details." (declare (ignore force force-not verbose version)) (apply 'operate *load-system-operation* system keys) t) (defun load-systems* (systems &rest keys) "Loading multiple systems at once." (dolist (s systems) (apply 'load-system s keys))) (defun load-systems (&rest systems) "Loading multiple systems at once." (load-systems* systems)) (defun compile-system (system &rest args &key force force-not verbose version &allow-other-keys) "Shorthand for `(asdf:operate 'asdf:compile-op system)`. See OPERATE for details." (declare (ignore force force-not verbose version)) (apply 'operate 'compile-op system args) t) (defun test-system (system &rest args &key force force-not verbose version &allow-other-keys) "Shorthand for `(asdf:operate 'asdf:test-op system)`. See OPERATE for details." (declare (ignore force force-not verbose version)) (apply 'operate 'test-op system args) t)) ;;;;; Define the function REQUIRE-SYSTEM, that, similarly to REQUIRE, ;; only tries to load its specified target if it's not loaded yet. (with-upgradability () (defun component-loaded-p (component) "has given COMPONENT been successfully loaded in the current image (yet)?" (action-already-done-p nil (make-instance 'load-op) (find-component component ()))) (defun already-loaded-systems () "return a list of the names of the systems that have been successfully loaded so far" (remove-if-not 'component-loaded-p (registered-systems))) (defun require-system (system &rest keys &key &allow-other-keys) "Ensure the specified SYSTEM is loaded, passing the KEYS to OPERATE, but skip any update to the system or its dependencies if they have already been loaded." (apply 'load-system system :force-not (already-loaded-systems) keys))) ;;;; Define the class REQUIRE-SYSTEM, to be hooked into CL:REQUIRE when possible, ;; i.e. for ABCL, CLISP, ClozureCL, CMUCL, ECL, MKCL and SBCL (with-upgradability () (defvar *modules-being-required* nil) (defclass require-system (system) ((module :initarg :module :initform nil :accessor required-module)) (:documentation "A SYSTEM subclass whose processing is handled by the implementation's REQUIRE rather than by internal ASDF mechanisms.")) (defmethod perform ((o compile-op) (c require-system)) nil) (defmethod perform ((o load-op) (s require-system)) (let* ((module (or (required-module s) (coerce-name s))) (*modules-being-required* (cons module *modules-being-required*))) (assert (null (component-children s))) (require module))) (defmethod resolve-dependency-combination (component (combinator (eql :require)) arguments) (unless (length=n-p arguments 1) (error (compatfmt "~@") (cons combinator arguments) component combinator)) (let* ((module (car arguments)) (name (string-downcase module)) (system (find-system name nil))) (assert module) ;;(unless (typep system '(or null require-system)) ;; (warn "~S depends on ~S but ~S is registered as a ~S" ;; component (cons combinator arguments) module (type-of system))) (or system (let ((system (make-instance 'require-system :name name))) (register-system system) system)))) (defun module-provide-asdf (name) (let ((module (string-downcase name))) (unless (member module *modules-being-required* :test 'equal) (let ((*modules-being-required* (cons module *modules-being-required*)) #+sbcl (sb-impl::*requiring* (remove module sb-impl::*requiring* :test 'equal))) (handler-bind ((style-warning #'muffle-warning) (missing-component (constantly nil)) (error #'(lambda (e) (format *error-output* (compatfmt "~@~%") name e)))) (let ((*verbose-out* (make-broadcast-stream))) (let ((system (find-system module nil))) (when system (require-system system :verbose nil) t))))))))) ;;;; Some upgrade magic (with-upgradability () (defun restart-upgraded-asdf () ;; If we're in the middle of something, restart it. (when *asdf-cache* (let ((l (loop :for k :being :the hash-keys :of *asdf-cache* :when (eq (first k) 'find-system) :collect (second k)))) (clrhash *asdf-cache*) (dolist (s l) (find-system s nil))))) (register-hook-function '*post-upgrade-restart-hook* 'restart-upgraded-asdf)) ;;;; --------------------------------------------------------------------------- ;;;; asdf-output-translations (uiop/package:define-package :asdf/output-translations (:recycle :asdf/output-translations :asdf) (:use :uiop/common-lisp :uiop :asdf/upgrade) (:export #:*output-translations* #:*output-translations-parameter* #:invalid-output-translation #:output-translations #:output-translations-initialized-p #:initialize-output-translations #:clear-output-translations #:disable-output-translations #:ensure-output-translations #:apply-output-translations #:validate-output-translations-directive #:validate-output-translations-form #:validate-output-translations-file #:validate-output-translations-directory #:parse-output-translations-string #:wrapping-output-translations #:user-output-translations-pathname #:system-output-translations-pathname #:user-output-translations-directory-pathname #:system-output-translations-directory-pathname #:environment-output-translations #:process-output-translations #:compute-output-translations #+abcl #:translate-jar-pathname )) (in-package :asdf/output-translations) (when-upgrading () (undefine-function '(setf output-translations))) (with-upgradability () (define-condition invalid-output-translation (invalid-configuration warning) ((format :initform (compatfmt "~@")))) (defvar *output-translations* () "Either NIL (for uninitialized), or a list of one element, said element itself being a sorted list of mappings. Each mapping is a pair of a source pathname and destination pathname, and the order is by decreasing length of namestring of the source pathname.") (defun output-translations () (car *output-translations*)) (defun set-output-translations (new-value) (setf *output-translations* (list (stable-sort (copy-list new-value) #'> :key #'(lambda (x) (etypecase (car x) ((eql t) -1) (pathname (let ((directory (pathname-directory (car x)))) (if (listp directory) (length directory) 0)))))))) new-value) (defun* ((setf output-translations)) (new-value) (set-output-translations new-value)) (defun output-translations-initialized-p () (and *output-translations* t)) (defun clear-output-translations () "Undoes any initialization of the output translations." (setf *output-translations* '()) (values)) (register-clear-configuration-hook 'clear-output-translations) (defun validate-output-translations-directive (directive) (or (member directive '(:enable-user-cache :disable-cache nil)) (and (consp directive) (or (and (length=n-p directive 2) (or (and (eq (first directive) :include) (typep (second directive) '(or string pathname null))) (and (location-designator-p (first directive)) (or (location-designator-p (second directive)) (location-function-p (second directive)))))) (and (length=n-p directive 1) (location-designator-p (first directive))))))) (defun validate-output-translations-form (form &key location) (validate-configuration-form form :output-translations 'validate-output-translations-directive :location location :invalid-form-reporter 'invalid-output-translation)) (defun validate-output-translations-file (file) (validate-configuration-file file 'validate-output-translations-form :description "output translations")) (defun validate-output-translations-directory (directory) (validate-configuration-directory directory :output-translations 'validate-output-translations-directive :invalid-form-reporter 'invalid-output-translation)) (defun parse-output-translations-string (string &key location) (cond ((or (null string) (equal string "")) '(:output-translations :inherit-configuration)) ((not (stringp string)) (error (compatfmt "~@") string)) ((eql (char string 0) #\") (parse-output-translations-string (read-from-string string) :location location)) ((eql (char string 0) #\() (validate-output-translations-form (read-from-string string) :location location)) (t (loop :with inherit = nil :with directives = () :with start = 0 :with end = (length string) :with source = nil :with separator = (inter-directory-separator) :for i = (or (position separator string :start start) end) :do (let ((s (subseq string start i))) (cond (source (push (list source (if (equal "" s) nil s)) directives) (setf source nil)) ((equal "" s) (when inherit (error (compatfmt "~@") string)) (setf inherit t) (push :inherit-configuration directives)) (t (setf source s))) (setf start (1+ i)) (when (> start end) (when source (error (compatfmt "~@") string)) (unless inherit (push :ignore-inherited-configuration directives)) (return `(:output-translations ,@(nreverse directives))))))))) (defparameter* *default-output-translations* '(environment-output-translations user-output-translations-pathname user-output-translations-directory-pathname system-output-translations-pathname system-output-translations-directory-pathname)) (defun wrapping-output-translations () `(:output-translations ;; Some implementations have precompiled ASDF systems, ;; so we must disable translations for implementation paths. #+(or clasp #|clozure|# ecl mkcl sbcl) ,@(let ((h (resolve-symlinks* (lisp-implementation-directory)))) (when h `(((,h ,*wild-path*) ())))) #+mkcl (,(translate-logical-pathname "CONTRIB:") ()) ;; All-import, here is where we want user stuff to be: :inherit-configuration ;; These are for convenience, and can be overridden by the user: #+abcl (#p"/___jar___file___root___/**/*.*" (:user-cache #p"**/*.*")) #+abcl (#p"jar:file:/**/*.jar!/**/*.*" (:function translate-jar-pathname)) ;; We enable the user cache by default, and here is the place we do: :enable-user-cache)) (defparameter *output-translations-file* (parse-unix-namestring "common-lisp/asdf-output-translations.conf")) (defparameter *output-translations-directory* (parse-unix-namestring "common-lisp/asdf-output-translations.conf.d/")) (defun user-output-translations-pathname (&key (direction :input)) (xdg-config-pathname *output-translations-file* direction)) (defun system-output-translations-pathname (&key (direction :input)) (find-preferred-file (system-config-pathnames *output-translations-file*) :direction direction)) (defun user-output-translations-directory-pathname (&key (direction :input)) (xdg-config-pathname *output-translations-directory* direction)) (defun system-output-translations-directory-pathname (&key (direction :input)) (find-preferred-file (system-config-pathnames *output-translations-directory*) :direction direction)) (defun environment-output-translations () (getenv "ASDF_OUTPUT_TRANSLATIONS")) (defgeneric process-output-translations (spec &key inherit collect)) (defun inherit-output-translations (inherit &key collect) (when inherit (process-output-translations (first inherit) :collect collect :inherit (rest inherit)))) (defun* (process-output-translations-directive) (directive &key inherit collect) (if (atom directive) (ecase directive ((:enable-user-cache) (process-output-translations-directive '(t :user-cache) :collect collect)) ((:disable-cache) (process-output-translations-directive '(t t) :collect collect)) ((:inherit-configuration) (inherit-output-translations inherit :collect collect)) ((:ignore-inherited-configuration :ignore-invalid-entries nil) nil)) (let ((src (first directive)) (dst (second directive))) (if (eq src :include) (when dst (process-output-translations (pathname dst) :inherit nil :collect collect)) (when src (let ((trusrc (or (eql src t) (let ((loc (resolve-location src :ensure-directory t :wilden t))) (if (absolute-pathname-p loc) (resolve-symlinks* loc) loc))))) (cond ((location-function-p dst) (funcall collect (list trusrc (ensure-function (second dst))))) ((typep dst 'boolean) (funcall collect (list trusrc t))) (t (let* ((trudst (resolve-location dst :ensure-directory t :wilden t))) (funcall collect (list trudst t)) (funcall collect (list trusrc trudst))))))))))) (defmethod process-output-translations ((x symbol) &key (inherit *default-output-translations*) collect) (process-output-translations (funcall x) :inherit inherit :collect collect)) (defmethod process-output-translations ((pathname pathname) &key inherit collect) (cond ((directory-pathname-p pathname) (process-output-translations (validate-output-translations-directory pathname) :inherit inherit :collect collect)) ((probe-file* pathname :truename *resolve-symlinks*) (process-output-translations (validate-output-translations-file pathname) :inherit inherit :collect collect)) (t (inherit-output-translations inherit :collect collect)))) (defmethod process-output-translations ((string string) &key inherit collect) (process-output-translations (parse-output-translations-string string) :inherit inherit :collect collect)) (defmethod process-output-translations ((x null) &key inherit collect) (inherit-output-translations inherit :collect collect)) (defmethod process-output-translations ((form cons) &key inherit collect) (dolist (directive (cdr (validate-output-translations-form form))) (process-output-translations-directive directive :inherit inherit :collect collect))) (defun compute-output-translations (&optional parameter) "read the configuration, return it" (remove-duplicates (while-collecting (c) (inherit-output-translations `(wrapping-output-translations ,parameter ,@*default-output-translations*) :collect #'c)) :test 'equal :from-end t)) (defvar *output-translations-parameter* nil) (defun initialize-output-translations (&optional (parameter *output-translations-parameter*)) "read the configuration, initialize the internal configuration variable, return the configuration" (setf *output-translations-parameter* parameter (output-translations) (compute-output-translations parameter))) (defun disable-output-translations () "Initialize output translations in a way that maps every file to itself, effectively disabling the output translation facility." (initialize-output-translations '(:output-translations :disable-cache :ignore-inherited-configuration))) ;; checks an initial variable to see whether the state is initialized ;; or cleared. In the former case, return current configuration; in ;; the latter, initialize. ASDF will call this function at the start ;; of (asdf:find-system). (defun ensure-output-translations () (if (output-translations-initialized-p) (output-translations) (initialize-output-translations))) (defun* (apply-output-translations) (path) (etypecase path (logical-pathname path) ((or pathname string) (ensure-output-translations) (loop* :with p = (resolve-symlinks* path) :for (source destination) :in (car *output-translations*) :for root = (when (or (eq source t) (and (pathnamep source) (not (absolute-pathname-p source)))) (pathname-root p)) :for absolute-source = (cond ((eq source t) (wilden root)) (root (merge-pathnames* source root)) (t source)) :when (or (eq source t) (pathname-match-p p absolute-source)) :return (translate-pathname* p absolute-source destination root source) :finally (return p))))) ;; Hook into uiop's output-translation mechanism #-cormanlisp (setf *output-translation-function* 'apply-output-translations) #+abcl (defun translate-jar-pathname (source wildcard) (declare (ignore wildcard)) (flet ((normalize-device (pathname) (if (find :windows *features*) pathname (make-pathname :defaults pathname :device :unspecific)))) (let* ((jar (pathname (first (pathname-device source)))) (target-root-directory-namestring (format nil "/___jar___file___root___/~@[~A/~]" (and (find :windows *features*) (pathname-device jar)))) (relative-source (relativize-pathname-directory source)) (relative-jar (relativize-pathname-directory (ensure-directory-pathname jar))) (target-root-directory (normalize-device (pathname-directory-pathname (parse-namestring target-root-directory-namestring)))) (target-root (merge-pathnames* relative-jar target-root-directory)) (target (merge-pathnames* relative-source target-root))) (normalize-device (apply-output-translations target)))))) ;;;; ----------------------------------------------------------------- ;;;; Source Registry Configuration, by Francois-Rene Rideau ;;;; See the Manual and https://bugs.launchpad.net/asdf/+bug/485918 (uiop/package:define-package :asdf/source-registry (:recycle :asdf/source-registry :asdf) (:use :uiop/common-lisp :uiop :asdf/upgrade :asdf/find-system) (:export #:*source-registry-parameter* #:*default-source-registries* #:invalid-source-registry #:source-registry-initialized-p #:initialize-source-registry #:clear-source-registry #:*source-registry* #:ensure-source-registry #:*source-registry-parameter* #:*default-source-registry-exclusions* #:*source-registry-exclusions* #:*wild-asd* #:directory-asd-files #:register-asd-directory #:*recurse-beyond-asds* #:collect-asds-in-directory #:collect-sub*directories-asd-files #:validate-source-registry-directive #:validate-source-registry-form #:validate-source-registry-file #:validate-source-registry-directory #:parse-source-registry-string #:wrapping-source-registry #:default-user-source-registry #:default-system-source-registry #:user-source-registry #:system-source-registry #:user-source-registry-directory #:system-source-registry-directory #:environment-source-registry #:process-source-registry #:compute-source-registry #:flatten-source-registry #:sysdef-source-registry-search)) (in-package :asdf/source-registry) (with-upgradability () (define-condition invalid-source-registry (invalid-configuration warning) ((format :initform (compatfmt "~@")))) ;; Using ack 1.2 exclusions (defvar *default-source-registry-exclusions* '(".bzr" ".cdv" ;; "~.dep" "~.dot" "~.nib" "~.plst" ; we don't support ack wildcards ".git" ".hg" ".pc" ".svn" "CVS" "RCS" "SCCS" "_darcs" "_sgbak" "autom4te.cache" "cover_db" "_build" "debian")) ;; debian often builds stuff under the debian directory... BAD. (defvar *source-registry-exclusions* *default-source-registry-exclusions*) (defvar *source-registry* nil "Either NIL (for uninitialized), or an equal hash-table, mapping system names to pathnames of .asd files") (defun source-registry-initialized-p () (typep *source-registry* 'hash-table)) (defun clear-source-registry () "Undoes any initialization of the source registry." (setf *source-registry* nil) (values)) (register-clear-configuration-hook 'clear-source-registry) (defparameter *wild-asd* (make-pathname* :directory nil :name *wild* :type "asd" :version :newest)) (defun directory-asd-files (directory) (directory-files directory *wild-asd*)) (defun collect-asds-in-directory (directory collect) (let ((asds (directory-asd-files directory))) (map () collect asds) asds)) (defvar *recurse-beyond-asds* t "Should :tree entries of the source-registry recurse in subdirectories after having found a .asd file? True by default.") (defun process-source-registry-cache (directory collect) (let ((cache (ignore-errors (safe-read-file-form (subpathname directory ".cl-source-registry.cache"))))) (when (and (listp cache) (eq :source-registry-cache (first cache))) (loop :for s :in (rest cache) :do (funcall collect (subpathname directory s))) t))) (defun collect-sub*directories-asd-files (directory &key (exclude *default-source-registry-exclusions*) collect (recurse-beyond-asds *recurse-beyond-asds*) ignore-cache) (collect-sub*directories directory #'(lambda (dir) (unless (and (not ignore-cache) (process-source-registry-cache directory collect)) (let ((asds (collect-asds-in-directory dir collect))) (or recurse-beyond-asds (not asds))))) #'(lambda (x) (not (member (car (last (pathname-directory x))) exclude :test #'equal))) (constantly nil))) (defun validate-source-registry-directive (directive) (or (member directive '(:default-registry)) (and (consp directive) (let ((rest (rest directive))) (case (first directive) ((:include :directory :tree) (and (length=n-p rest 1) (location-designator-p (first rest)))) ((:exclude :also-exclude) (every #'stringp rest)) ((:default-registry) (null rest))))))) (defun validate-source-registry-form (form &key location) (validate-configuration-form form :source-registry 'validate-source-registry-directive :location location :invalid-form-reporter 'invalid-source-registry)) (defun validate-source-registry-file (file) (validate-configuration-file file 'validate-source-registry-form :description "a source registry")) (defun validate-source-registry-directory (directory) (validate-configuration-directory directory :source-registry 'validate-source-registry-directive :invalid-form-reporter 'invalid-source-registry)) (defun parse-source-registry-string (string &key location) (cond ((or (null string) (equal string "")) '(:source-registry :inherit-configuration)) ((not (stringp string)) (error (compatfmt "~@") string)) ((find (char string 0) "\"(") (validate-source-registry-form (read-from-string string) :location location)) (t (loop :with inherit = nil :with directives = () :with start = 0 :with end = (length string) :with separator = (inter-directory-separator) :for pos = (position separator string :start start) :do (let ((s (subseq string start (or pos end)))) (flet ((check (dir) (unless (absolute-pathname-p dir) (error (compatfmt "~@") string)) dir)) (cond ((equal "" s) ; empty element: inherit (when inherit (error (compatfmt "~@") string)) (setf inherit t) (push ':inherit-configuration directives)) ((string-suffix-p s "//") ;; TODO: allow for doubling of separator even outside Unix? (push `(:tree ,(check (subseq s 0 (- (length s) 2)))) directives)) (t (push `(:directory ,(check s)) directives)))) (cond (pos (setf start (1+ pos))) (t (unless inherit (push '(:ignore-inherited-configuration) directives)) (return `(:source-registry ,@(nreverse directives)))))))))) (defun register-asd-directory (directory &key recurse exclude collect) (if (not recurse) (collect-asds-in-directory directory collect) (collect-sub*directories-asd-files directory :exclude exclude :collect collect))) (defparameter* *default-source-registries* '(environment-source-registry user-source-registry user-source-registry-directory default-user-source-registry system-source-registry system-source-registry-directory default-system-source-registry) "List of default source registries" "3.1.0.102") (defparameter *source-registry-file* (parse-unix-namestring "common-lisp/source-registry.conf")) (defparameter *source-registry-directory* (parse-unix-namestring "common-lisp/source-registry.conf.d/")) (defun wrapping-source-registry () `(:source-registry #+(or clasp ecl sbcl) (:tree ,(resolve-symlinks* (lisp-implementation-directory))) :inherit-configuration #+mkcl (:tree ,(translate-logical-pathname "CONTRIB:")) #+cmu (:tree #p"modules:") #+scl (:tree #p"file://modules/"))) (defun default-user-source-registry () `(:source-registry (:tree (:home "common-lisp/")) #+sbcl (:directory (:home ".sbcl/systems/")) (:directory ,(xdg-data-home "common-lisp/systems/")) (:tree ,(xdg-data-home "common-lisp/source/")) :inherit-configuration)) (defun default-system-source-registry () `(:source-registry ,@(loop :for dir :in (xdg-data-dirs "common-lisp/") :collect `(:directory (,dir "systems/")) :collect `(:tree (,dir "source/"))) :inherit-configuration)) (defun user-source-registry (&key (direction :input)) (xdg-config-pathname *source-registry-file* direction)) (defun system-source-registry (&key (direction :input)) (find-preferred-file (system-config-pathnames *source-registry-file*) :direction direction)) (defun user-source-registry-directory (&key (direction :input)) (xdg-config-pathname *source-registry-directory* direction)) (defun system-source-registry-directory (&key (direction :input)) (find-preferred-file (system-config-pathnames *source-registry-directory*) :direction direction)) (defun environment-source-registry () (getenv "CL_SOURCE_REGISTRY")) (defgeneric* (process-source-registry) (spec &key inherit register)) (defun* (inherit-source-registry) (inherit &key register) (when inherit (process-source-registry (first inherit) :register register :inherit (rest inherit)))) (defun* (process-source-registry-directive) (directive &key inherit register) (destructuring-bind (kw &rest rest) (if (consp directive) directive (list directive)) (ecase kw ((:include) (destructuring-bind (pathname) rest (process-source-registry (resolve-location pathname) :inherit nil :register register))) ((:directory) (destructuring-bind (pathname) rest (when pathname (funcall register (resolve-location pathname :ensure-directory t))))) ((:tree) (destructuring-bind (pathname) rest (when pathname (funcall register (resolve-location pathname :ensure-directory t) :recurse t :exclude *source-registry-exclusions*)))) ((:exclude) (setf *source-registry-exclusions* rest)) ((:also-exclude) (appendf *source-registry-exclusions* rest)) ((:default-registry) (inherit-source-registry '(default-user-source-registry default-system-source-registry) :register register)) ((:inherit-configuration) (inherit-source-registry inherit :register register)) ((:ignore-inherited-configuration) nil))) nil) (defmethod process-source-registry ((x symbol) &key inherit register) (process-source-registry (funcall x) :inherit inherit :register register)) (defmethod process-source-registry ((pathname pathname) &key inherit register) (cond ((directory-pathname-p pathname) (let ((*here-directory* (resolve-symlinks* pathname))) (process-source-registry (validate-source-registry-directory pathname) :inherit inherit :register register))) ((probe-file* pathname :truename *resolve-symlinks*) (let ((*here-directory* (pathname-directory-pathname pathname))) (process-source-registry (validate-source-registry-file pathname) :inherit inherit :register register))) (t (inherit-source-registry inherit :register register)))) (defmethod process-source-registry ((string string) &key inherit register) (process-source-registry (parse-source-registry-string string) :inherit inherit :register register)) (defmethod process-source-registry ((x null) &key inherit register) (inherit-source-registry inherit :register register)) (defmethod process-source-registry ((form cons) &key inherit register) (let ((*source-registry-exclusions* *default-source-registry-exclusions*)) (dolist (directive (cdr (validate-source-registry-form form))) (process-source-registry-directive directive :inherit inherit :register register)))) (defun flatten-source-registry (&optional parameter) (remove-duplicates (while-collecting (collect) (with-pathname-defaults () ;; be location-independent (inherit-source-registry `(wrapping-source-registry ,parameter ,@*default-source-registries*) :register #'(lambda (directory &key recurse exclude) (collect (list directory :recurse recurse :exclude exclude)))))) :test 'equal :from-end t)) ;; Will read the configuration and initialize all internal variables. (defun compute-source-registry (&optional parameter (registry *source-registry*)) (dolist (entry (flatten-source-registry parameter)) (destructuring-bind (directory &key recurse exclude) entry (let* ((h (make-hash-table :test 'equal))) ; table to detect duplicates (register-asd-directory directory :recurse recurse :exclude exclude :collect #'(lambda (asd) (let* ((name (pathname-name asd)) (name (if (typep asd 'logical-pathname) ;; logical pathnames are upper-case, ;; at least in the CLHS and on SBCL, ;; yet (coerce-name :foo) is lower-case. ;; won't work well with (load-system "Foo") ;; instead of (load-system 'foo) (string-downcase name) name))) (cond ((gethash name registry) ; already shadowed by something else nil) ((gethash name h) ; conflict at current level (when *verbose-out* (warn (compatfmt "~@") directory recurse name (gethash name h) asd))) (t (setf (gethash name registry) asd) (setf (gethash name h) asd)))))) h))) (values)) (defvar *source-registry-parameter* nil) (defun initialize-source-registry (&optional (parameter *source-registry-parameter*)) ;; Record the parameter used to configure the registry (setf *source-registry-parameter* parameter) ;; Clear the previous registry database: (setf *source-registry* (make-hash-table :test 'equal)) ;; Do it! (compute-source-registry parameter)) ;; Checks an initial variable to see whether the state is initialized ;; or cleared. In the former case, return current configuration; in ;; the latter, initialize. ASDF will call this function at the start ;; of (asdf:find-system) to make sure the source registry is initialized. ;; However, it will do so *without* a parameter, at which point it ;; will be too late to provide a parameter to this function, though ;; you may override the configuration explicitly by calling ;; initialize-source-registry directly with your parameter. (defun ensure-source-registry (&optional parameter) (unless (source-registry-initialized-p) (initialize-source-registry parameter)) (values)) (defun sysdef-source-registry-search (system) (ensure-source-registry) (values (gethash (primary-system-name system) *source-registry*)))) ;;;; ------------------------------------------------------------------------- ;;;; Defsystem (uiop/package:define-package :asdf/parse-defsystem (:recycle :asdf/parse-defsystem :asdf/defsystem :asdf) (:nicknames :asdf/defsystem) ;; previous name, to be compatible with, in case anyone cares (:use :uiop/common-lisp :asdf/driver :asdf/upgrade :asdf/cache :asdf/component :asdf/system :asdf/find-system :asdf/find-component :asdf/action :asdf/lisp-action :asdf/operate) (:import-from :asdf/system #:depends-on #:weakly-depends-on) (:export #:defsystem #:register-system-definition #:class-for-type #:*default-component-class* #:determine-system-directory #:parse-component-form #:non-toplevel-system #:non-system-system #:sysdef-error-component #:check-component-input)) (in-package :asdf/parse-defsystem) ;;; Pathname (with-upgradability () (defun determine-system-directory (pathname) ;; The defsystem macro calls this function to determine ;; the pathname of a system as follows: ;; 1. if the pathname argument is an pathname object (NOT a namestring), ;; that is already an absolute pathname, return it. ;; 2. otherwise, the directory containing the LOAD-PATHNAME ;; is considered (as deduced from e.g. *LOAD-PATHNAME*), and ;; if it is indeed available and an absolute pathname, then ;; the PATHNAME argument is normalized to a relative pathname ;; as per PARSE-UNIX-NAMESTRING (with ENSURE-DIRECTORY T) ;; and merged into that DIRECTORY as per SUBPATHNAME. ;; Note: avoid *COMPILE-FILE-PATHNAME* because .asd is loaded, ;; and may be from within the EVAL-WHEN of a file compilation. ;; If no absolute pathname was found, we return NIL. (check-type pathname (or null string pathname)) (pathname-directory-pathname (resolve-symlinks* (ensure-absolute-pathname (parse-unix-namestring pathname :type :directory) #'(lambda () (ensure-absolute-pathname (load-pathname) 'get-pathname-defaults nil)) nil))))) ;;; Component class (with-upgradability () (defvar *default-component-class* 'cl-source-file) (defun class-for-type (parent type) (or (coerce-class type :package :asdf/interface :super 'component :error nil) (and (eq type :file) (coerce-class (or (loop :for p = parent :then (component-parent p) :while p :thereis (module-default-component-class p)) *default-component-class*) :package :asdf/interface :super 'component :error nil)) (sysdef-error "don't recognize component type ~S" type)))) ;;; Check inputs (with-upgradability () (define-condition non-system-system (system-definition-error) ((name :initarg :name :reader non-system-system-name) (class-name :initarg :class-name :reader non-system-system-class-name)) (:report (lambda (c s) (format s (compatfmt "~@") (non-system-system-name c) (non-system-system-class-name c) 'system)))) (define-condition non-toplevel-system (system-definition-error) ((parent :initarg :parent :reader non-toplevel-system-parent) (name :initarg :name :reader non-toplevel-system-name)) (:report (lambda (c s) (format s (compatfmt "~@") (non-toplevel-system-parent c) (non-toplevel-system-name c))))) (defun sysdef-error-component (msg type name value) (sysdef-error (strcat msg (compatfmt "~&~@")) type name value)) (defun check-component-input (type name weakly-depends-on depends-on components) "A partial test of the values of a component." (unless (listp depends-on) (sysdef-error-component ":depends-on must be a list." type name depends-on)) (unless (listp weakly-depends-on) (sysdef-error-component ":weakly-depends-on must be a list." type name weakly-depends-on)) (unless (listp components) (sysdef-error-component ":components must be NIL or a list of components." type name components))) (defun* (normalize-version) (form &key pathname component parent) (labels ((invalid (&optional (continuation "using NIL instead")) (warn (compatfmt "~@") form component parent pathname continuation)) (invalid-parse (control &rest args) (unless (if-let (target (find-component parent component)) (builtin-system-p target)) (apply 'warn control args) (invalid)))) (if-let (v (typecase form ((or string null) form) (real (invalid "Substituting a string") (format nil "~D" form)) ;; 1.0 becomes "1.0" (cons (case (first form) ((:read-file-form) (destructuring-bind (subpath &key (at 0)) (rest form) (safe-read-file-form (subpathname pathname subpath) :at at :package :asdf-user))) ((:read-file-line) (destructuring-bind (subpath &key (at 0)) (rest form) (safe-read-file-line (subpathname pathname subpath) :at at))) (otherwise (invalid)))) (t (invalid)))) (if-let (pv (parse-version v #'invalid-parse)) (unparse-version pv) (invalid)))))) ;;; "inline methods" (with-upgradability () (defparameter* +asdf-methods+ '(perform-with-restarts perform explain output-files operation-done-p)) (defun %remove-component-inline-methods (component) (dolist (name +asdf-methods+) (map () ;; this is inefficient as most of the stored ;; methods will not be for this particular gf ;; But this is hardly performance-critical #'(lambda (m) (remove-method (symbol-function name) m)) (component-inline-methods component))) (component-inline-methods component) nil) (defun %define-component-inline-methods (ret rest) (loop* :for (key value) :on rest :by #'cddr :for name = (and (keywordp key) (find key +asdf-methods+ :test 'string=)) :when name :do (destructuring-bind (op &rest body) value (loop :for arg = (pop body) :while (atom arg) :collect arg :into qualifiers :finally (destructuring-bind (o c) arg (pushnew (eval `(defmethod ,name ,@qualifiers ((,o ,op) (,c (eql ,ret))) ,@body)) (component-inline-methods ret))))))) (defun %refresh-component-inline-methods (component rest) ;; clear methods, then add the new ones (%remove-component-inline-methods component) (%define-component-inline-methods component rest))) ;;; Main parsing function (with-upgradability () (defun* parse-dependency-def (dd) (if (listp dd) (case (first dd) (:feature (unless (= (length dd) 3) (sysdef-error "Ill-formed feature dependency: ~s" dd)) (let ((embedded (parse-dependency-def (third dd)))) `(:feature ,(second dd) ,embedded))) (feature (sysdef-error "`feature' has been removed from the dependency spec language of ASDF. Use :feature instead in ~s." dd)) (:require (unless (= (length dd) 2) (sysdef-error "Ill-formed require dependency: ~s" dd)) dd) (:version (unless (= (length dd) 3) (sysdef-error "Ill-formed version dependency: ~s" dd)) `(:version ,(coerce-name (second dd)) ,(third dd))) (otherwise (sysdef-error "Ill-formed dependency: ~s" dd))) (coerce-name dd))) (defun* parse-dependency-defs (dd-list) "Parse the dependency defs in DD-LIST into canonical form by translating all system names contained using COERCE-NAME. Return the result." (mapcar 'parse-dependency-def dd-list)) (defun* (parse-component-form) (parent options &key previous-serial-component) (destructuring-bind (type name &rest rest &key (builtin-system-p () bspp) ;; the following list of keywords is reproduced below in the ;; remove-plist-keys form. important to keep them in sync components pathname perform explain output-files operation-done-p weakly-depends-on depends-on serial do-first if-component-dep-fails version ;; list ends &allow-other-keys) options (declare (ignore perform explain output-files operation-done-p builtin-system-p)) (check-component-input type name weakly-depends-on depends-on components) (when (and parent (find-component parent name) (not ;; ignore the same object when rereading the defsystem (typep (find-component parent name) (class-for-type parent type)))) (error 'duplicate-names :name name)) (when do-first (error "DO-FIRST is not supported anymore as of ASDF 3")) (let* ((name (coerce-name name)) (args `(:name ,name :pathname ,pathname ,@(when parent `(:parent ,parent)) ,@(remove-plist-keys '(:components :pathname :if-component-dep-fails :version :perform :explain :output-files :operation-done-p :weakly-depends-on :depends-on :serial) rest))) (component (find-component parent name)) (class (class-for-type parent type))) (when (and parent (subtypep class 'system)) (error 'non-toplevel-system :parent parent :name name)) (if component ; preserve identity (apply 'reinitialize-instance component args) (setf component (apply 'make-instance class args))) (component-pathname component) ; eagerly compute the absolute pathname (when (typep component 'system) ;; cache information for introspection (setf (slot-value component 'depends-on) (parse-dependency-defs depends-on) (slot-value component 'weakly-depends-on) ;; these must be a list of systems, cannot be features or versioned systems (mapcar 'coerce-name weakly-depends-on))) (let ((sysfile (system-source-file (component-system component)))) ;; requires the previous (when (and (typep component 'system) (not bspp)) (setf (builtin-system-p component) (lisp-implementation-pathname-p sysfile))) (setf version (normalize-version version :component name :parent parent :pathname sysfile))) ;; Don't use the accessor: kluge to avoid upgrade issue on CCL 1.8. ;; A better fix is required. (setf (slot-value component 'version) version) (when (typep component 'parent-component) (setf (component-children component) (loop :with previous-component = nil :for c-form :in components :for c = (parse-component-form component c-form :previous-serial-component previous-component) :for name = (component-name c) :collect c :when serial :do (setf previous-component name))) (compute-children-by-name component)) (when previous-serial-component (push previous-serial-component depends-on)) (when weakly-depends-on ;; ASDF4: deprecate this feature and remove it. (appendf depends-on (remove-if (complement #'(lambda (x) (find-system x nil))) weakly-depends-on))) ;; Used by POIU. ASDF4: rename to component-depends-on? (setf (component-sideway-dependencies component) depends-on) (%refresh-component-inline-methods component rest) (when if-component-dep-fails (error "The system definition for ~S uses deprecated ~ ASDF option :IF-COMPONENT-DEP-FAILS. ~ Starting with ASDF 3, please use :IF-FEATURE instead" (coerce-name (component-system component)))) component))) (defun register-system-definition (name &rest options &key pathname (class 'system) (source-file () sfp) defsystem-depends-on &allow-other-keys) ;; The system must be registered before we parse the body, ;; otherwise we recur when trying to find an existing system ;; of the same name to reuse options (e.g. pathname) from. ;; To avoid infinite recursion in cases where you defsystem a system ;; that is registered to a different location to find-system, ;; we also need to remember it in the asdf-cache. (with-asdf-cache () (let* ((name (coerce-name name)) (source-file (if sfp source-file (resolve-symlinks* (load-pathname)))) (registered (system-registered-p name)) (registered! (if registered (rplaca registered (get-file-stamp source-file)) (register-system (make-instance 'system :name name :source-file source-file)))) (system (reset-system (cdr registered!) :name name :source-file source-file)) (component-options (remove-plist-keys '(:defsystem-depends-on :class) options)) (defsystem-dependencies (loop :for spec :in defsystem-depends-on :when (resolve-dependency-spec nil spec) :collect :it))) ;; cache defsystem-depends-on in canonical form (when defsystem-depends-on (setf component-options (append `(:defsystem-depends-on ,(parse-dependency-defs defsystem-depends-on)) component-options))) (set-asdf-cache-entry `(find-system ,name) (list system)) (load-systems* defsystem-dependencies) ;; We change-class AFTER we loaded the defsystem-depends-on ;; since the class might be defined as part of those. (let ((class (class-for-type nil class))) (unless (subtypep class 'system) (error 'non-system-system :name name :class-name (class-name class))) (unless (eq (type-of system) class) (change-class system class))) (parse-component-form nil (list* :module name :pathname (determine-system-directory pathname) component-options))))) (defmacro defsystem (name &body options) `(apply 'register-system-definition ',name ',options))) ;;;; ------------------------------------------------------------------------- ;;;; ASDF-Bundle (uiop/package:define-package :asdf/bundle (:recycle :asdf/bundle :asdf) (:use :uiop/common-lisp :uiop :asdf/upgrade :asdf/component :asdf/system :asdf/find-system :asdf/find-component :asdf/operation :asdf/action :asdf/lisp-action :asdf/plan :asdf/operate :asdf/defsystem) (:export #:bundle-op #:bundle-type #:program-system #:bundle-system #:bundle-pathname-type #:bundlable-file-p #:direct-dependency-files #:monolithic-op #:monolithic-bundle-op #:operation-monolithic-p #:basic-compile-bundle-op #:prepare-bundle-op #:compile-bundle-op #:load-bundle-op #:monolithic-compile-bundle-op #:monolithic-load-bundle-op #:lib-op #:monolithic-lib-op #:dll-op #:monolithic-dll-op #:deliver-asd-op #:monolithic-deliver-asd-op #:program-op #:image-op #:compiled-file #:precompiled-system #:prebuilt-system #:user-system-p #:user-system #:trivial-system-p #:make-build #:build-args #:name-suffix #:prologue-code #:epilogue-code #:static-library)) (in-package :asdf/bundle) (with-upgradability () (defclass bundle-op (basic-compile-op) ((build-args :initarg :args :initform nil :accessor extra-build-args) (name-suffix :initarg :name-suffix :initform nil) (bundle-type :initform :no-output-file :reader bundle-type) #+(or clasp ecl) (lisp-files :initform nil :accessor extra-object-files))) (defclass monolithic-op (operation) () (:documentation "A MONOLITHIC operation operates on a system *and all of its dependencies*. So, for example, a monolithic concatenate operation will concatenate together a system's components and all of its dependencies, but a simple concatenate operation will concatenate only the components of the system itself.")) ;; operation on a system and its dependencies (defclass monolithic-bundle-op (monolithic-op bundle-op) ;; Old style way of specifying prologue and epilogue on ECL: in the monolithic operation ((prologue-code :initform nil :accessor prologue-code) (epilogue-code :initform nil :accessor epilogue-code))) (defclass program-system (system) ;; New style (ASDF3.1) way of specifying prologue and epilogue on ECL: in the system ((prologue-code :initform nil :initarg :prologue-code :reader prologue-code) (epilogue-code :initform nil :initarg :epilogue-code :reader epilogue-code) (no-uiop :initform nil :initarg :no-uiop :reader no-uiop) (prefix-lisp-object-files :initarg :prefix-lisp-object-files :initform nil :accessor prefix-lisp-object-files) (postfix-lisp-object-files :initarg :postfix-lisp-object-files :initform nil :accessor postfix-lisp-object-files) (extra-object-files :initarg :extra-object-files :initform nil :accessor extra-object-files) (extra-build-args :initarg :extra-build-args :initform nil :accessor extra-build-args))) (defmethod prologue-code ((x t)) nil) (defmethod epilogue-code ((x t)) nil) (defmethod no-uiop ((x t)) nil) (defmethod prefix-lisp-object-files ((x t)) nil) (defmethod postfix-lisp-object-files ((x t)) nil) (defmethod extra-object-files ((x t)) nil) (defmethod extra-build-args ((x t)) nil) (defclass link-op (bundle-op) () (:documentation "Abstract operation for linking files together")) (defclass gather-op (bundle-op) ((gather-op :initform nil :allocation :class :reader gather-op)) (:documentation "Abstract operation for gathering many input files from a system")) (defun operation-monolithic-p (op) (typep op 'monolithic-op)) (defmethod component-depends-on ((o gather-op) (s system)) (let* ((mono (operation-monolithic-p o)) (deps (required-components s :other-systems mono :component-type (if mono 'system '(not system)) :goal-operation (find-operation o 'load-op) :keep-operation 'compile-op))) ;; NB: the explicit make-operation on ECL and MKCL ;; ensures that we drop the original-initargs and its magic flags when recursing. `((,(make-operation (or (gather-op o) (if mono 'lib-op 'compile-op))) ,@deps) ,@(call-next-method)))) ;; create a single fasl for the entire library (defclass basic-compile-bundle-op (bundle-op) ((bundle-type :initform :fasl))) (defclass prepare-bundle-op (sideway-operation) ((sideway-operation :initform #+(or clasp ecl mkcl) 'load-bundle-op #-(or clasp ecl mkcl) 'load-op :allocation :class))) (defclass lib-op (link-op gather-op non-propagating-operation) ((bundle-type :initform :lib)) (:documentation "compile the system and produce linkable (.a) library for it.")) (defclass compile-bundle-op (basic-compile-bundle-op selfward-operation #+(or clasp ecl mkcl) link-op #-(or clasp ecl) gather-op) ((selfward-operation :initform '(prepare-bundle-op #+(or clasp ecl) lib-op) :allocation :class))) (defclass load-bundle-op (basic-load-op selfward-operation) ((selfward-operation :initform '(prepare-bundle-op compile-bundle-op) :allocation :class))) ;; NB: since the monolithic-op's can't be sideway-operation's, ;; if we wanted lib-op, dll-op, deliver-asd-op to be sideway-operation's, ;; we'd have to have the monolithic-op not inherit from the main op, ;; but instead inherit from a basic-FOO-op as with basic-compile-bundle-op above. (defclass dll-op (link-op gather-op non-propagating-operation) ((bundle-type :initform :dll)) (:documentation "compile the system and produce dynamic (.so/.dll) library for it.")) (defclass deliver-asd-op (basic-compile-op selfward-operation) ((selfward-operation :initform '(compile-bundle-op #+(or clasp ecl mkcl) lib-op) :allocation :class)) (:documentation "produce an asd file for delivering the system as a single fasl")) (defclass monolithic-deliver-asd-op (monolithic-bundle-op deliver-asd-op) ((selfward-operation :initform '(monolithic-compile-bundle-op #+(or clasp ecl mkcl) monolithic-lib-op) :allocation :class)) (:documentation "produce fasl and asd files for combined system and dependencies.")) (defclass monolithic-compile-bundle-op (monolithic-bundle-op basic-compile-bundle-op #+(or clasp ecl mkcl) link-op gather-op non-propagating-operation) ((gather-op :initform #+(or clasp ecl mkcl) 'lib-op #-(or clasp ecl mkcl) 'compile-bundle-op :allocation :class)) (:documentation "Create a single fasl for the system and its dependencies.")) (defclass monolithic-load-bundle-op (monolithic-bundle-op load-bundle-op) ((selfward-operation :initform 'monolithic-compile-bundle-op :allocation :class)) (:documentation "Load a single fasl for the system and its dependencies.")) (defclass monolithic-lib-op (monolithic-bundle-op lib-op non-propagating-operation) () (:documentation "Create a single linkable library for the system and its dependencies.")) (defclass monolithic-dll-op (monolithic-bundle-op dll-op non-propagating-operation) ((bundle-type :initform :dll)) (:documentation "Create a single dynamic (.so/.dll) library for the system and its dependencies.")) (defclass image-op (monolithic-bundle-op selfward-operation #+(or clasp ecl mkcl) link-op #+(or clasp ecl mkcl) gather-op) ((bundle-type :initform :image) (selfward-operation :initform '(#-(or clasp ecl mkcl) load-op) :allocation :class)) (:documentation "create an image file from the system and its dependencies")) (defclass program-op (image-op) ((bundle-type :initform :program)) (:documentation "create an executable file from the system and its dependencies")) (defun bundle-pathname-type (bundle-type) (etypecase bundle-type ((eql :no-output-file) nil) ;; should we error out instead? ((or null string) bundle-type) ((eql :fasl) #-(or clasp ecl mkcl) (compile-file-type) #+(or clasp ecl mkcl) "fasb") #+(or clasp ecl) ((member :dll :lib :shared-library :static-library :program :object :program) (compile-file-type :type bundle-type)) ((member :image) #+allegro "dxl" #+(and clisp os-windows) "exe" #-(or allegro (and clisp os-windows)) "image") ((member :dll :shared-library) (os-cond ((os-macosx-p) "dylib") ((os-unix-p) "so") ((os-windows-p) "dll"))) ((member :lib :static-library) (os-cond ((os-unix-p) "a") ((os-windows-p) (if (featurep '(:or :mingw32 :mingw64)) "a" "lib")))) ((eql :program) (os-cond ((os-unix-p) nil) ((os-windows-p) "exe"))))) (defun bundle-output-files (o c) (let ((bundle-type (bundle-type o))) (unless (or (eq bundle-type :no-output-file) ;; NIL already means something regarding type. (and (null (input-files o c)) (not (member bundle-type '(:image :program))))) (let ((name (or (component-build-pathname c) (format nil "~A~@[~A~]" (component-name c) (slot-value o 'name-suffix)))) (type (bundle-pathname-type bundle-type))) (values (list (subpathname (component-pathname c) name :type type)) (eq (type-of o) (component-build-operation c))))))) (defmethod output-files ((o bundle-op) (c system)) (bundle-output-files o c)) #-(or clasp ecl mkcl) (progn (defmethod perform ((o image-op) (c system)) (dump-image (output-file o c) :executable (typep o 'program-op))) (defmethod perform :before ((o program-op) (c system)) (setf *image-entry-point* (ensure-function (component-entry-point c))))) (defclass compiled-file (file-component) ((type :initform #-(or clasp ecl mkcl) (compile-file-type) #+(or clasp ecl mkcl) "fasb"))) (defclass precompiled-system (system) ((build-pathname :initarg :fasl))) (defclass prebuilt-system (system) ((build-pathname :initarg :static-library :initarg :lib :accessor prebuilt-system-static-library)))) ;;; ;;; BUNDLE-OP ;;; ;;; This operation takes all components from one or more systems and ;;; creates a single output file, which may be ;;; a FASL, a statically linked library, a shared library, etc. ;;; The different targets are defined by specialization. ;;; (with-upgradability () (defmethod initialize-instance :after ((instance bundle-op) &rest initargs &key (name-suffix nil name-suffix-p) &allow-other-keys) (declare (ignore initargs name-suffix)) (unless name-suffix-p (setf (slot-value instance 'name-suffix) (unless (typep instance 'program-op) ;; "." is no good separator for Logical Pathnames, so we use "--" (if (operation-monolithic-p instance) "--all-systems" #-(or clasp ecl mkcl) "--system")))) (when (typep instance 'monolithic-bundle-op) (destructuring-bind (&key lisp-files prologue-code epilogue-code &allow-other-keys) (operation-original-initargs instance) (setf (prologue-code instance) prologue-code (epilogue-code instance) epilogue-code) #-(or clasp ecl) (assert (null (or lisp-files #-mkcl epilogue-code #-mkcl prologue-code))) #+(or clasp ecl) (setf (extra-object-files instance) lisp-files))) (setf (extra-build-args instance) (remove-plist-keys '(:type :monolithic :name-suffix :epilogue-code :prologue-code :lisp-files :force :force-not :plan-class) ;; TODO: refactor so we don't mix plan and operation arguments (operation-original-initargs instance)))) (defun bundlable-file-p (pathname) (let ((type (pathname-type pathname))) (declare (ignorable type)) (or #+(or clasp ecl) (or (equalp type (compile-file-type :type :object)) (equalp type (compile-file-type :type :static-library))) #+mkcl (or (equalp type (compile-file-type :fasl-p nil)) #+(or unix mingw32 mingw64) (equalp type "a") ;; valid on Unix and MinGW #+(and windows (not (or mingw32 mingw64))) (equalp type "lib")) #+(or abcl allegro clisp clozure cmu lispworks sbcl scl xcl) (equalp type (compile-file-type))))) (defgeneric* (trivial-system-p) (component)) (defun user-system-p (s) (and (typep s 'system) (not (builtin-system-p s)) (not (trivial-system-p s))))) (eval-when (#-lispworks :compile-toplevel :load-toplevel :execute) (deftype user-system () '(and system (satisfies user-system-p)))) ;;; ;;; First we handle monolithic bundles. ;;; These are standalone systems which contain everything, ;;; including other ASDF systems required by the current one. ;;; A PROGRAM is always monolithic. ;;; ;;; MONOLITHIC SHARED LIBRARIES, PROGRAMS, FASL ;;; (with-upgradability () (defun direct-dependency-files (o c &key (test 'identity) (key 'output-files) &allow-other-keys) ;; This file selects output files from direct dependencies; ;; your component-depends-on method better gathered the correct dependencies in the correct order. (while-collecting (collect) (map-direct-dependencies t o c #'(lambda (sub-o sub-c) (loop :for f :in (funcall key sub-o sub-c) :when (funcall test f) :do (collect f)))))) (defmethod input-files ((o gather-op) (c system)) (unless (eq (bundle-type o) :no-output-file) (direct-dependency-files o c :test 'bundlable-file-p :key 'output-files))) (defun select-bundle-operation (type &optional monolithic) (ecase type ((:dll :shared-library) (if monolithic 'monolithic-dll-op 'dll-op)) ((:lib :static-library) (if monolithic 'monolithic-lib-op 'lib-op)) ((:fasl) (if monolithic 'monolithic-compile-bundle-op 'compile-bundle-op)) ((:image) 'image-op) ((:program) 'program-op))) ;; DEPRECATED. This is originally from asdf-ecl.lisp. Does anyone use it? (defun make-build (system &rest args &key (monolithic nil) (type :fasl) (move-here nil move-here-p) &allow-other-keys) (let* ((operation-name (select-bundle-operation type monolithic)) (move-here-path (if (and move-here (typep move-here '(or pathname string))) (ensure-pathname move-here :namestring :lisp :ensure-directory t) (system-relative-pathname system "asdf-output/"))) (operation (apply #'operate operation-name system (remove-plist-keys '(:monolithic :type :move-here) args))) (system (find-system system)) (files (and system (output-files operation system)))) (if (or move-here (and (null move-here-p) (member operation-name '(:program :image)))) (loop :with dest-path = (resolve-symlinks* (ensure-directories-exist move-here-path)) :for f :in files :for new-f = (make-pathname :name (pathname-name f) :type (pathname-type f) :defaults dest-path) :do (rename-file-overwriting-target f new-f) :collect new-f) files))) ;; DEPRECATED. Does anyone use this? (defun bundle-system (system &rest args &key force (verbose t) version &allow-other-keys) (declare (ignore force verbose version)) (apply #'operate 'deliver-asd-op system args))) ;;; ;;; LOAD-BUNDLE-OP ;;; ;;; This is like ASDF's LOAD-OP, but using bundle fasl files. ;;; (with-upgradability () (defmethod component-depends-on ((o load-bundle-op) (c system)) `((,o ,@(component-sideway-dependencies c)) (,(if (user-system-p c) 'compile-bundle-op 'load-op) ,c) ,@(call-next-method))) (defmethod input-files ((o load-bundle-op) (c system)) (when (user-system-p c) (output-files (find-operation o 'compile-bundle-op) c))) (defmethod perform ((o load-bundle-op) (c system)) (when (input-files o c) (perform-lisp-load-fasl o c))) (defmethod mark-operation-done :after ((o load-bundle-op) (c system)) (mark-operation-done (find-operation o 'load-op) c))) ;;; ;;; PRECOMPILED FILES ;;; ;;; This component can be used to distribute ASDF systems in precompiled form. ;;; Only useful when the dependencies have also been precompiled. ;;; (with-upgradability () (defmethod trivial-system-p ((s system)) (every #'(lambda (c) (typep c 'compiled-file)) (component-children s))) (defmethod input-files ((o operation) (c compiled-file)) (list (component-pathname c))) (defmethod perform ((o load-op) (c compiled-file)) (perform-lisp-load-fasl o c)) (defmethod perform ((o load-source-op) (c compiled-file)) (perform (find-operation o 'load-op) c)) (defmethod perform ((o operation) (c compiled-file)) nil)) ;;; ;;; Pre-built systems ;;; (with-upgradability () (defmethod trivial-system-p ((s prebuilt-system)) t) (defmethod perform ((o link-op) (c prebuilt-system)) nil) (defmethod perform ((o basic-compile-bundle-op) (c prebuilt-system)) nil) (defmethod perform ((o lib-op) (c prebuilt-system)) nil) (defmethod perform ((o dll-op) (c prebuilt-system)) nil) (defmethod component-depends-on ((o gather-op) (c prebuilt-system)) nil) (defmethod output-files ((o lib-op) (c prebuilt-system)) (values (list (prebuilt-system-static-library c)) t))) ;;; ;;; PREBUILT SYSTEM CREATOR ;;; (with-upgradability () (defmethod output-files ((o deliver-asd-op) (s system)) (list (make-pathname :name (component-name s) :type "asd" :defaults (component-pathname s)))) (defmethod perform ((o deliver-asd-op) (s system)) (let* ((inputs (input-files o s)) (fasl (first inputs)) (library (second inputs)) (asd (first (output-files o s))) (name (if (and fasl asd) (pathname-name asd) (return-from perform))) (version (component-version s)) (dependencies (if (operation-monolithic-p o) (remove-if-not 'builtin-system-p (required-components s :component-type 'system :keep-operation 'load-op)) (while-collecting (x) ;; resolve the sideway-dependencies of s (map-direct-dependencies t 'load-op s #'(lambda (o c) (when (and (typep o 'load-op) (typep c 'system)) (x c))))))) (depends-on (mapcar 'coerce-name dependencies))) (when (pathname-equal asd (system-source-file s)) (cerror "overwrite the asd file" "~/asdf-action:format-action/ is going to overwrite the system definition file ~S which is probably not what you want; you probably need to tweak your output translations." (cons o s) asd)) (with-open-file (s asd :direction :output :if-exists :supersede :if-does-not-exist :create) (format s ";;; Prebuilt~:[~; monolithic~] ASDF definition for system ~A~%" (operation-monolithic-p o) name) (format s ";;; Built for ~A ~A on a ~A/~A ~A~%" (lisp-implementation-type) (lisp-implementation-version) (software-type) (machine-type) (software-version)) (let ((*package* (find-package :asdf-user))) (pprint `(defsystem ,name :class prebuilt-system :version ,version :depends-on ,depends-on :components ((:compiled-file ,(pathname-name fasl))) ,@(when library `(:lib ,(file-namestring library)))) s) (terpri s))))) #-(or clasp ecl mkcl) (defmethod perform ((o basic-compile-bundle-op) (c system)) (let* ((input-files (input-files o c)) (fasl-files (remove (compile-file-type) input-files :key #'pathname-type :test-not #'equalp)) (non-fasl-files (remove (compile-file-type) input-files :key #'pathname-type :test #'equalp)) (output-files (output-files o c)) (output-file (first output-files))) (assert (eq (not input-files) (not output-files))) (when input-files (when non-fasl-files (error "On ~A, asdf/bundle can only bundle FASL files, but these were also produced: ~S" (implementation-type) non-fasl-files)) (when (or (prologue-code o) (epilogue-code o) (prologue-code c) (epilogue-code c)) (error "prologue-code and epilogue-code are not supported on ~A" (implementation-type))) (with-staging-pathname (output-file) (combine-fasls fasl-files output-file))))) (defmethod input-files ((o load-op) (s precompiled-system)) (bundle-output-files (find-operation o 'compile-bundle-op) s)) (defmethod perform ((o load-op) (s precompiled-system)) (perform-lisp-load-fasl o s)) (defmethod component-depends-on ((o load-bundle-op) (s precompiled-system)) #+xcl (declare (ignorable o)) `((load-op ,s) ,@(call-next-method)))) #| ;; Example use: (asdf:defsystem :precompiled-asdf-utils :class asdf::precompiled-system :fasl (asdf:apply-output-translations (asdf:system-relative-pathname :asdf-utils "asdf-utils.system.fasl"))) (asdf:load-system :precompiled-asdf-utils) |# #+(or clasp ecl mkcl) (with-upgradability () ;; I think that Juanjo intended for this to be, ;; but beware the weird bug in test-xach-update-bug.script, ;; and also it makes mkcl fail test-logical-pathname.script, ;; and ecl fail test-bundle.script. ;;(unless (or #+(or clasp ecl) (use-ecl-byte-compiler-p)) ;; (setf *load-system-operation* 'load-bundle-op)) (defun uiop-library-pathname () #+clasp (probe-file* (compile-file-pathname "sys:uiop" :output-type :object)) #+ecl (or (probe-file* (compile-file-pathname "sys:uiop" :type :lib)) ;; new style (probe-file* (compile-file-pathname "sys:uiop" :type :object))) ;; old style #+mkcl (make-pathname :type (bundle-pathname-type :lib) :defaults #p"sys:contrib;uiop")) (defun asdf-library-pathname () #+clasp (probe-file* (compile-file-pathname "sys:asdf" :output-type :object)) #+ecl (or (probe-file* (compile-file-pathname "sys:asdf" :type :lib)) ;; new style (probe-file* (compile-file-pathname "sys:asdf" :type :object))) ;; old style #+mkcl (make-pathname :type (bundle-pathname-type :lib) :defaults #p"sys:contrib;asdf")) (defun compiler-library-pathname () #+clasp (compile-file-pathname "sys:cmp" :output-type :lib) #+ecl (compile-file-pathname "sys:cmp" :type :lib) #+mkcl (make-pathname :type (bundle-pathname-type :lib) :defaults #p"sys:cmp")) (defun make-library-system (name pathname) (make-instance 'prebuilt-system :name (coerce-name name) :static-library (resolve-symlinks* pathname))) (defmethod component-depends-on :around ((o image-op) (c system)) (destructuring-bind ((lib-op . deps)) (call-next-method) (flet ((has-it-p (x) (find x deps :test 'equal :key 'coerce-name))) `((,lib-op ,@(unless (or (no-uiop c) (has-it-p "cmp")) `(,(make-library-system "cmp" (compiler-library-pathname)))) ,@(unless (or (no-uiop c) (has-it-p "uiop") (has-it-p "asdf")) (cond ((system-source-directory :uiop) `(,(find-system :uiop))) ((system-source-directory :asdf) `(,(find-system :asdf))) (t `(,@(if-let (uiop (uiop-library-pathname)) `(,(make-library-system "uiop" uiop))) ,(make-library-system "asdf" (asdf-library-pathname)))))) ,@deps))))) (defmethod perform ((o link-op) (c system)) (let* ((object-files (input-files o c)) (output (output-files o c)) (bundle (first output)) (programp (typep o 'program-op)) (kind (bundle-type o))) (when output (apply 'create-image bundle (append (when programp (prefix-lisp-object-files c)) object-files (when programp (postfix-lisp-object-files c))) :kind kind :prologue-code (or (prologue-code o) (when programp (prologue-code c))) :epilogue-code (or (epilogue-code o) (when programp (epilogue-code c))) :build-args (or (extra-build-args o) (when programp (extra-build-args c))) :extra-object-files (or (extra-object-files o) (when programp (extra-object-files c))) :no-uiop (no-uiop c) (when programp `(:entry-point ,(component-entry-point c)))))))) #+(and (not asdf-use-unsafe-mac-bundle-op) (or (and clasp ecl darwin) (and abcl darwin (not abcl-bundle-op-supported)))) (defmethod perform :before ((o basic-compile-bundle-op) (c component)) (unless (featurep :asdf-use-unsafe-mac-bundle-op) (cerror "Continue after modifying *FEATURES*." "BASIC-COMPILE-BUNDLE-OP operations are not supported on Mac OS X for this lisp.~%~T~ To continue, push :asdf-use-unsafe-mac-bundle-op onto *FEATURES*.~%~T~ Please report to ASDF-DEVEL if this works for you."))) ;;;; ------------------------------------------------------------------------- ;;;; Concatenate-source (uiop/package:define-package :asdf/concatenate-source (:recycle :asdf/concatenate-source :asdf) (:use :uiop/common-lisp :uiop :asdf/upgrade :asdf/component :asdf/operation :asdf/system :asdf/find-system :asdf/action :asdf/lisp-action :asdf/bundle) (:export #:concatenate-source-op #:load-concatenated-source-op #:compile-concatenated-source-op #:load-compiled-concatenated-source-op #:monolithic-concatenate-source-op #:monolithic-load-concatenated-source-op #:monolithic-compile-concatenated-source-op #:monolithic-load-compiled-concatenated-source-op)) (in-package :asdf/concatenate-source) ;;; ;;; Concatenate sources ;;; (with-upgradability () (defclass basic-concatenate-source-op (bundle-op) ((bundle-type :initform "lisp"))) (defclass basic-load-concatenated-source-op (basic-load-op selfward-operation) ()) (defclass basic-compile-concatenated-source-op (basic-compile-op selfward-operation) ()) (defclass basic-load-compiled-concatenated-source-op (basic-load-op selfward-operation) ()) (defclass concatenate-source-op (basic-concatenate-source-op non-propagating-operation) ()) (defclass load-concatenated-source-op (basic-load-concatenated-source-op) ((selfward-operation :initform '(prepare-op concatenate-source-op) :allocation :class))) (defclass compile-concatenated-source-op (basic-compile-concatenated-source-op) ((selfward-operation :initform '(prepare-op concatenate-source-op) :allocation :class))) (defclass load-compiled-concatenated-source-op (basic-load-compiled-concatenated-source-op) ((selfward-operation :initform '(prepare-op compile-concatenated-source-op) :allocation :class))) (defclass monolithic-concatenate-source-op (basic-concatenate-source-op monolithic-bundle-op non-propagating-operation) ()) (defclass monolithic-load-concatenated-source-op (basic-load-concatenated-source-op) ((selfward-operation :initform 'monolithic-concatenate-source-op :allocation :class))) (defclass monolithic-compile-concatenated-source-op (basic-compile-concatenated-source-op) ((selfward-operation :initform 'monolithic-concatenate-source-op :allocation :class))) (defclass monolithic-load-compiled-concatenated-source-op (basic-load-compiled-concatenated-source-op) ((selfward-operation :initform 'monolithic-compile-concatenated-source-op :allocation :class))) (defmethod input-files ((operation basic-concatenate-source-op) (s system)) (loop :with encoding = (or (component-encoding s) *default-encoding*) :with other-encodings = '() :with around-compile = (around-compile-hook s) :with other-around-compile = '() :for c :in (required-components s :goal-operation 'compile-op :keep-operation 'compile-op :other-systems (operation-monolithic-p operation)) :append (when (typep c 'cl-source-file) (let ((e (component-encoding c))) (unless (equal e encoding) (let ((a (assoc e other-encodings))) (if a (push (component-find-path c) (cdr a)) (push (list a (component-find-path c)) other-encodings))))) (unless (equal around-compile (around-compile-hook c)) (push (component-find-path c) other-around-compile)) (input-files (make-operation 'compile-op) c)) :into inputs :finally (when other-encodings (warn "~S uses encoding ~A but has sources that use these encodings:~{ ~A~}" operation encoding (mapcar #'(lambda (x) (cons (car x) (list (reverse (cdr x))))) other-encodings))) (when other-around-compile (warn "~S uses around-compile hook ~A but has sources that use these hooks: ~A" operation around-compile other-around-compile)) (return inputs))) (defmethod output-files ((o basic-compile-concatenated-source-op) (s system)) (lisp-compilation-output-files o s)) (defmethod perform ((o basic-concatenate-source-op) (s system)) (let* ((ins (input-files o s)) (out (output-file o s)) (tmp (tmpize-pathname out))) (concatenate-files ins tmp) (rename-file-overwriting-target tmp out))) (defmethod perform ((o basic-load-concatenated-source-op) (s system)) (perform-lisp-load-source o s)) (defmethod perform ((o basic-compile-concatenated-source-op) (s system)) (perform-lisp-compilation o s)) (defmethod perform ((o basic-load-compiled-concatenated-source-op) (s system)) (perform-lisp-load-fasl o s))) ;;;; ------------------------------------------------------------------------- ;;;; Package systems in the style of quick-build or faslpath (uiop:define-package :asdf/package-inferred-system (:recycle :asdf/package-inferred-system :asdf/package-system :asdf) (:use :uiop/common-lisp :uiop :asdf/defsystem ;; Using the old name of :asdf/parse-defsystem for compatibility :asdf/upgrade :asdf/component :asdf/system :asdf/find-system :asdf/lisp-action) (:export #:package-inferred-system #:sysdef-package-inferred-system-search #:package-system ;; backward compatibility only. To be removed. #:register-system-packages #:*defpackage-forms* #:*package-inferred-systems* #:package-inferred-system-missing-package-error)) (in-package :asdf/package-inferred-system) (with-upgradability () (defparameter *defpackage-forms* '(defpackage define-package)) (defun initial-package-inferred-systems-table () (let ((h (make-hash-table :test 'equal))) (dolist (p (list-all-packages)) (dolist (n (package-names p)) (setf (gethash n h) t))) h)) (defvar *package-inferred-systems* (initial-package-inferred-systems-table)) (defclass package-inferred-system (system) ()) ;; For backward compatibility only. To be removed in an upcoming release: (defclass package-system (package-inferred-system) ()) (defun defpackage-form-p (form) (and (consp form) (member (car form) *defpackage-forms*))) (defun stream-defpackage-form (stream) (loop :for form = (read stream nil nil) :while form :when (defpackage-form-p form) :return form)) (defun file-defpackage-form (file) "Return the first DEFPACKAGE form in FILE." (with-input-file (f file) (stream-defpackage-form f))) (define-condition package-inferred-system-missing-package-error (system-definition-error) ((system :initarg :system :reader error-system) (pathname :initarg :pathname :reader error-pathname)) (:report (lambda (c s) (format s (compatfmt "~@") (error-system c) (error-pathname c))))) (defun package-dependencies (defpackage-form) "Return a list of packages depended on by the package defined in DEFPACKAGE-FORM. A package is depended upon if the DEFPACKAGE-FORM uses it or imports a symbol from it." (assert (defpackage-form-p defpackage-form)) (remove-duplicates (while-collecting (dep) (loop* :for (option . arguments) :in (cddr defpackage-form) :do (ecase option ((:use :mix :reexport :use-reexport :mix-reexport) (dolist (p arguments) (dep (string p)))) ((:import-from :shadowing-import-from) (dep (string (first arguments)))) ((:nicknames :documentation :shadow :export :intern :unintern :recycle))))) :from-end t :test 'equal)) (defun package-designator-name (package) (etypecase package (package (package-name package)) (string package) (symbol (string package)))) (defun register-system-packages (system packages) "Register SYSTEM as providing PACKAGES." (let ((name (or (eq system t) (coerce-name system)))) (dolist (p (ensure-list packages)) (setf (gethash (package-designator-name p) *package-inferred-systems*) name)))) (defun package-name-system (package-name) "Return the name of the SYSTEM providing PACKAGE-NAME, if such exists, otherwise return a default system name computed from PACKAGE-NAME." (check-type package-name string) (if-let ((system-name (gethash package-name *package-inferred-systems*))) system-name (string-downcase package-name))) (defun package-inferred-system-file-dependencies (file &optional system) (if-let (defpackage-form (file-defpackage-form file)) (remove t (mapcar 'package-name-system (package-dependencies defpackage-form))) (error 'package-inferred-system-missing-package-error :system system :pathname file))) (defun same-package-inferred-system-p (system name directory subpath dependencies) (and (eq (type-of system) 'package-inferred-system) (equal (component-name system) name) (pathname-equal directory (component-pathname system)) (equal dependencies (component-sideway-dependencies system)) (let ((children (component-children system))) (and (length=n-p children 1) (let ((child (first children))) (and (eq (type-of child) 'cl-source-file) (equal (component-name child) "lisp") (and (slot-boundp child 'relative-pathname) (equal (slot-value child 'relative-pathname) subpath)))))))) (defun sysdef-package-inferred-system-search (system) (let ((primary (primary-system-name system))) (unless (equal primary system) (let ((top (find-system primary nil))) (when (typep top 'package-inferred-system) (if-let (dir (system-source-directory top)) (let* ((sub (subseq system (1+ (length primary)))) (f (probe-file* (subpathname dir sub :type "lisp") :truename *resolve-symlinks*))) (when (file-pathname-p f) (let ((dependencies (package-inferred-system-file-dependencies f system)) (previous (cdr (system-registered-p system)))) (if (same-package-inferred-system-p previous system dir sub dependencies) previous (eval `(defsystem ,system :class package-inferred-system :source-file nil :pathname ,dir :depends-on ,dependencies :components ((cl-source-file "lisp" :pathname ,sub))))))))))))))) (with-upgradability () (pushnew 'sysdef-package-inferred-system-search *system-definition-search-functions*) (setf *system-definition-search-functions* (remove (find-symbol* :sysdef-package-system-search :asdf/package-system nil) *system-definition-search-functions*))) ;;;; ------------------------------------------------------------------------- ;;; Internal hacks for backward-compatibility (uiop/package:define-package :asdf/backward-internals (:recycle :asdf/backward-internals :asdf) (:use :uiop/common-lisp :uiop :asdf/upgrade :asdf/find-system) (:export ;; for internal use #:make-sub-operation #:load-sysdef #:make-temporary-package)) (in-package :asdf/backward-internals) (when-upgrading (:when (fboundp 'make-sub-operation)) (defun make-sub-operation (c o dep-c dep-o) (declare (ignore c o dep-c dep-o)) (asdf-upgrade-error))) ;;;; load-sysdef (with-upgradability () (defun load-sysdef (name pathname) (load-asd pathname :name name)) (defun make-temporary-package () ;; For loading a .asd file, we don't make a temporary package anymore, ;; but use ASDF-USER. I'd like to have this function do this, ;; but since whoever uses it is likely to delete-package the result afterwards, ;; this would be a bad idea, so preserve the old behavior. (make-package (fresh-package-name :prefix :asdf :index 0) :use '(:cl :asdf)))) ;;;; ------------------------------------------------------------------------- ;;; Backward-compatible interfaces (uiop/package:define-package :asdf/backward-interface (:recycle :asdf/backward-interface :asdf) (:use :uiop/common-lisp :uiop :asdf/upgrade :asdf/component :asdf/system :asdf/find-system :asdf/operation :asdf/action :asdf/lisp-action :asdf/plan :asdf/operate :asdf/output-translations) (:export #:*asdf-verbose* #:operation-error #:compile-error #:compile-failed #:compile-warned #:error-component #:error-operation #:traverse #:component-load-dependencies #:enable-asdf-binary-locations-compatibility #:operation-forced #:operation-on-failure #:operation-on-warnings #:on-failure #:on-warnings #:component-property #:run-shell-command #:system-definition-pathname)) (in-package :asdf/backward-interface) (with-upgradability () (define-condition operation-error (error) ;; Bad, backward-compatible name ;; Used by SBCL, cffi-tests, clsql-mysql, clsql-uffi, qt, elephant, uffi-tests, sb-grovel ((component :reader error-component :initarg :component) (operation :reader error-operation :initarg :operation)) (:report (lambda (c s) (format s (compatfmt "~@<~A while invoking ~A on ~A~@:>") (type-of c) (error-operation c) (error-component c))))) (define-condition compile-error (operation-error) ()) (define-condition compile-failed (compile-error) ()) (define-condition compile-warned (compile-error) ()) (defun component-load-dependencies (component) ;; Old deprecated name for the same thing. Please update your software. (component-sideway-dependencies component)) (defgeneric operation-forced (operation)) ;; Used by swank.asd for swank-loader. (defmethod operation-forced ((o operation)) (getf (operation-original-initargs o) :force)) (defgeneric operation-on-warnings (operation)) (defgeneric operation-on-failure (operation)) (defgeneric (setf operation-on-warnings) (x operation)) (defgeneric (setf operation-on-failure) (x operation)) (defmethod operation-on-warnings ((o operation)) *compile-file-warnings-behaviour*) (defmethod operation-on-failure ((o operation)) *compile-file-failure-behaviour*) (defmethod (setf operation-on-warnings) (x (o operation)) (setf *compile-file-warnings-behaviour* x)) (defmethod (setf operation-on-failure) (x (o operation)) (setf *compile-file-failure-behaviour* x)) (defun system-definition-pathname (x) ;; As of 2.014.8, we mean to make this function obsolete, ;; but that won't happen until all clients have been updated. ;;(cerror "Use ASDF:SYSTEM-SOURCE-FILE instead" "Function ASDF:SYSTEM-DEFINITION-PATHNAME is obsolete. It used to expose ASDF internals with subtle differences with respect to user expectations, that have been refactored away since. We recommend you use ASDF:SYSTEM-SOURCE-FILE instead for a mostly compatible replacement that we're supporting, or even ASDF:SYSTEM-SOURCE-DIRECTORY or ASDF:SYSTEM-RELATIVE-PATHNAME if that's whay you mean." ;;) (system-source-file x)) (defgeneric* (traverse) (operation component &key &allow-other-keys) (:documentation "Generate and return a plan for performing OPERATION on COMPONENT. The plan returned is a list of dotted-pairs. Each pair is the CONS of ASDF operation object and a COMPONENT object. The pairs will be processed in order by OPERATE.")) (define-convenience-action-methods traverse (operation component &key)) (defmethod traverse ((o operation) (c component) &rest keys &key plan-class &allow-other-keys) (plan-actions (apply 'make-plan plan-class o c keys)))) ;;;; ASDF-Binary-Locations compatibility ;; This remains supported for legacy user, but not recommended for new users. (with-upgradability () (defun enable-asdf-binary-locations-compatibility (&key (centralize-lisp-binaries nil) (default-toplevel-directory (subpathname (user-homedir-pathname) ".fasls/")) ;; Use ".cache/common-lisp/" instead ??? (include-per-user-information nil) (map-all-source-files (or #+(or clasp clisp ecl mkcl) t nil)) (source-to-target-mappings nil) (file-types `(,(compile-file-type) "build-report" #+(or clasp ecl) (compile-file-type :type :object) #+mkcl (compile-file-type :fasl-p nil) #+clisp "lib" #+sbcl "cfasl" #+sbcl "sbcl-warnings" #+clozure "ccl-warnings"))) #+(or clasp clisp ecl mkcl) (when (null map-all-source-files) (error "asdf:enable-asdf-binary-locations-compatibility doesn't support :map-all-source-files nil on CLISP, ECL and MKCL")) (let* ((patterns (if map-all-source-files (list *wild-file*) (loop :for type :in file-types :collect (make-pathname :type type :defaults *wild-file*)))) (destination-directory (if centralize-lisp-binaries `(,default-toplevel-directory ,@(when include-per-user-information (cdr (pathname-directory (user-homedir-pathname)))) :implementation ,*wild-inferiors*) `(:root ,*wild-inferiors* :implementation)))) (initialize-output-translations `(:output-translations ,@source-to-target-mappings #+abcl (#p"jar:file:/**/*.jar!/**/*.*" (:function translate-jar-pathname)) #+abcl (#p"/___jar___file___root___/**/*.*" (,@destination-directory)) ,@(loop :for pattern :in patterns :collect `((:root ,*wild-inferiors* ,pattern) (,@destination-directory ,pattern))) (t t) :ignore-inherited-configuration)))) (defmethod operate :before (operation-class system &rest args &key &allow-other-keys) (declare (ignore operation-class system args)) (when (find-symbol* '#:output-files-for-system-and-operation :asdf nil) (error "ASDF 2 is not compatible with ASDF-BINARY-LOCATIONS, which you are using. ASDF 2 now achieves the same purpose with its builtin ASDF-OUTPUT-TRANSLATIONS, which should be easier to configure. Please stop using ASDF-BINARY-LOCATIONS, and instead use ASDF-OUTPUT-TRANSLATIONS. See the ASDF manual for details. In case you insist on preserving your previous A-B-L configuration, but do not know how to achieve the same effect with A-O-T, you may use function ASDF:ENABLE-ASDF-BINARY-LOCATIONS-COMPATIBILITY as documented in the manual; call that function where you would otherwise have loaded and configured A-B-L.")))) ;;; run-shell-command ;; WARNING! The function below is not just deprecated but also dysfunctional. ;; Please use asdf/run-program:run-program instead. (with-upgradability () (defun run-shell-command (control-string &rest args) "Interpolate ARGS into CONTROL-STRING as if by FORMAT, and synchronously execute the result using a Bourne-compatible shell, with output to *VERBOSE-OUT*. Returns the shell's exit code. PLEASE DO NOT USE. Deprecated function, for backward-compatibility only. Please use UIOP:RUN-PROGRAM instead." (let ((command (apply 'format nil control-string args))) (asdf-message "; $ ~A~%" command) (let ((exit-code (ignore-errors (nth-value 2 (run-program command :force-shell t :ignore-error-status t :output *verbose-out*))))) (typecase exit-code ((integer 0 255) exit-code) (t 255)))))) (with-upgradability () (defvar *asdf-verbose* nil)) ;; backward-compatibility with ASDF2 only. Unused. ;; backward-compatibility methods. Do NOT use in new code. NOT SUPPORTED. (with-upgradability () (defgeneric component-property (component property)) (defgeneric (setf component-property) (new-value component property)) (defmethod component-property ((c component) property) (cdr (assoc property (slot-value c 'properties) :test #'equal))) (defmethod (setf component-property) (new-value (c component) property) (let ((a (assoc property (slot-value c 'properties) :test #'equal))) (if a (setf (cdr a) new-value) (setf (slot-value c 'properties) (acons property new-value (slot-value c 'properties))))) new-value)) ;;;; --------------------------------------------------------------------------- ;;;; Handle ASDF package upgrade, including implementation-dependent magic. (uiop/package:define-package :asdf/interface (:nicknames :asdf :asdf-utilities) (:recycle :asdf/interface :asdf) (:unintern #:loaded-systems ; makes for annoying SLIME completion #:output-files-for-system-and-operation) ; ASDF-BINARY-LOCATION function we use to detect ABL (:use :uiop/common-lisp :uiop :asdf/upgrade :asdf/cache :asdf/component :asdf/system :asdf/find-system :asdf/find-component :asdf/operation :asdf/action :asdf/lisp-action :asdf/output-translations :asdf/source-registry :asdf/plan :asdf/operate :asdf/parse-defsystem :asdf/bundle :asdf/concatenate-source :asdf/backward-internals :asdf/backward-interface :asdf/package-inferred-system) ;; Note: (1) we are NOT automatically reexporting everything from previous packages. ;; (2) we only reexport UIOP functionality when backward-compatibility requires it. (:export #:defsystem #:find-system #:load-asd #:locate-system #:coerce-name #:primary-system-name #:oos #:operate #:make-plan #:perform-plan #:sequential-plan #:system-definition-pathname #:search-for-system-definition #:find-component #:component-find-path #:compile-system #:load-system #:load-systems #:load-systems* #:require-system #:test-system #:clear-system #:operation #:make-operation #:find-operation #:upward-operation #:downward-operation #:sideway-operation #:selfward-operation #:non-propagating-operation #:build-op #:make #:load-op #:prepare-op #:compile-op #:prepare-source-op #:load-source-op #:test-op #:feature #:version #:version-satisfies #:upgrade-asdf #:implementation-identifier #:implementation-type #:hostname #:input-files #:output-files #:output-file #:perform #:perform-with-restarts #:operation-done-p #:explain #:action-description #:component-sideway-dependencies #:needed-in-image-p #:component-load-dependencies #:run-shell-command ; deprecated, do not use #:bundle-op #:monolithic-bundle-op #:precompiled-system #:compiled-file #:bundle-system #:program-system #:make-build #:basic-compile-bundle-op #:prepare-bundle-op #:compile-bundle-op #:load-bundle-op #:monolithic-compile-bundle-op #:monolithic-load-bundle-op #:lib-op #:dll-op #:deliver-asd-op #:program-op #:image-op #:monolithic-lib-op #:monolithic-dll-op #:monolithic-deliver-asd-op #:concatenate-source-op #:load-concatenated-source-op #:compile-concatenated-source-op #:load-compiled-concatenated-source-op #:monolithic-concatenate-source-op #:monolithic-load-concatenated-source-op #:monolithic-compile-concatenated-source-op #:monolithic-load-compiled-concatenated-source-op #:operation-monolithic-p #:required-components #:component-loaded-p #:component #:parent-component #:child-component #:system #:module #:file-component #:source-file #:c-source-file #:java-source-file #:cl-source-file #:cl-source-file.cl #:cl-source-file.lsp #:static-file #:doc-file #:html-file #:file-type #:source-file-type #:register-preloaded-system #:sysdef-preloaded-system-search #:register-immutable-system #:sysdef-immutable-system-search #:package-inferred-system #:register-system-packages #:package-system ;; backward-compatibility during migration, to be removed in a further release. #:component-children ; component accessors #:component-children-by-name #:component-pathname #:component-relative-pathname #:component-name #:component-version #:component-parent #:component-system #:component-encoding #:component-external-format #:component-depends-on ; backward-compatible name rather than action-depends-on #:module-components ; backward-compatibility #:operation-on-warnings #:operation-on-failure ; backward-compatibility #:component-property ; backward-compatibility #:traverse ; backward-compatibility #:system-description #:system-long-description #:system-author #:system-maintainer #:system-license #:system-licence #:system-source-file #:system-source-directory #:system-relative-pathname #:system-homepage #:system-mailto #:system-bug-tracker #:system-long-name #:system-source-control #:map-systems #:system-defsystem-depends-on #:system-depends-on #:system-weakly-depends-on #:*system-definition-search-functions* ; variables #:*central-registry* #:*compile-file-warnings-behaviour* #:*compile-file-failure-behaviour* #:*resolve-symlinks* #:*load-system-operation* #:*asdf-verbose* ;; unused. For backward-compatibility only. #:*verbose-out* #:asdf-version #:compile-condition #:compile-file-error #:compile-warned-error #:compile-failed-error #:compile-warned-warning #:compile-failed-warning #:operation-error #:compile-failed #:compile-warned #:compile-error ;; backward compatibility #:error-name #:error-pathname #:load-system-definition-error #:error-component #:error-operation #:system-definition-error #:missing-component #:missing-component-of-version #:missing-dependency #:missing-dependency-of-version #:circular-dependency ; errors #:duplicate-names #:non-toplevel-system #:non-system-system #:package-inferred-system-missing-package-error #:operation-definition-warning #:operation-definition-error #:try-recompiling ; restarts #:retry #:accept #:coerce-entry-to-directory #:remove-entry-from-registry #:clear-configuration-and-retry #:*encoding-detection-hook* #:*encoding-external-format-hook* #:*default-encoding* #:*utf-8-external-format* #:clear-configuration #:*output-translations-parameter* #:initialize-output-translations #:disable-output-translations #:clear-output-translations #:ensure-output-translations #:apply-output-translations #:compile-file* #:compile-file-pathname* #:*warnings-file-type* #:enable-deferred-warnings-check #:disable-deferred-warnings-check #:enable-asdf-binary-locations-compatibility #:*default-source-registries* #:*source-registry-parameter* #:initialize-source-registry #:compute-source-registry #:clear-source-registry #:ensure-source-registry #:process-source-registry #:system-registered-p #:registered-systems #:already-loaded-systems #:resolve-location #:asdf-message #:*user-cache* #:user-output-translations-pathname #:system-output-translations-pathname #:user-output-translations-directory-pathname #:system-output-translations-directory-pathname #:user-source-registry #:system-source-registry #:user-source-registry-directory #:system-source-registry-directory )) ;;;; --------------------------------------------------------------------------- ;;;; ASDF-USER, where the action happens. (uiop/package:define-package :asdf/user (:nicknames :asdf-user) ;; NB: releases before 3.1.2 this :use'd only uiop/package instead of uiop below. ;; They also :use'd uiop/common-lisp, that reexports common-lisp and is not included in uiop. ;; ASDF3 releases from 2.27 to 2.31 called uiop asdf-driver and asdf/foo uiop/foo. ;; ASDF1 and ASDF2 releases (2.26 and earlier) create a temporary package ;; that only :use's :cl and :asdf (:use :uiop/common-lisp :uiop :asdf/interface)) ;;;; ----------------------------------------------------------------------- ;;;; ASDF Footer: last words and cleanup (uiop/package:define-package :asdf/footer (:recycle :asdf/footer :asdf) (:use :uiop/common-lisp :uiop :asdf/upgrade :asdf/find-system :asdf/operate :asdf/bundle)) (in-package :asdf/footer) ;;;; Hook ASDF into the implementation's REQUIRE and other entry points. #+(or abcl clasp clisp clozure cmu ecl mkcl sbcl) (with-upgradability () (if-let (x (and #+clisp (find-symbol* '#:*module-provider-functions* :custom nil))) (eval `(pushnew 'module-provide-asdf #+abcl sys::*module-provider-functions* #+(or clasp cmu ecl) ext:*module-provider-functions* #+clisp ,x #+clozure ccl:*module-provider-functions* #+mkcl mk-ext:*module-provider-functions* #+sbcl sb-ext:*module-provider-functions*))) #+(or clasp ecl mkcl) (progn (pushnew '("fasb" . si::load-binary) si::*load-hooks* :test 'equal :key 'car) #+(or (and clasp windows) (and ecl win32) (and mkcl windows)) (unless (assoc "asd" #+(or clasp ecl) ext:*load-hooks* #+mkcl si::*load-hooks* :test 'equal) (appendf #+(or clasp ecl) ext:*load-hooks* #+mkcl si::*load-hooks* '(("asd" . si::load-source)))) (setf #+(or clasp ecl) ext:*module-provider-functions* #+mkcl mk-ext::*module-provider-functions* (loop :for f :in #+(or clasp ecl) ext:*module-provider-functions* #+mkcl mk-ext::*module-provider-functions* :collect (if (eq f 'module-provide-asdf) f #'(lambda (name) (let ((l (multiple-value-list (funcall f name)))) (and (first l) (register-preloaded-system (coerce-name name))) (values-list l)))))))) #+cmu ;; Hook into the CMUCL herald. (with-upgradability () (defun herald-asdf (stream) (format stream " ASDF ~A" (asdf-version))) (setf (getf ext:*herald-items* :asdf) `(herald-asdf))) ;;;; Done! (with-upgradability () #+allegro (when (boundp 'excl:*warn-on-nested-reader-conditionals*) (setf excl:*warn-on-nested-reader-conditionals* asdf/common-lisp::*acl-warn-save*)) (dolist (f '(:asdf :asdf2 :asdf3 :asdf3.1 :asdf-package-system)) (pushnew f *features*)) ;; Provide both lowercase and uppercase, to satisfy more people, especially LispWorks users. (provide "asdf") (provide "ASDF") (cleanup-upgraded-asdf)) (when *load-verbose* (asdf-message ";; ASDF, version ~a~%" (asdf-version))) ecl-16.1.2/contrib/asdf/asdf.texinfo000066400000000000000000007246151266352375300172670ustar00rootroot00000000000000\input texinfo @c -*- texinfo -*- @c %**start of header @setfilename asdf.info @settitle ASDF Manual @syncodeindex tp fn @c %**end of header @c We use @&key, etc to escape & from TeX in lambda lists -- @c so we need to define them for info as well. @macro AallowOtherKeys &allow-other-keys @end macro @macro Aoptional &optional @end macro @macro Arest &rest @end macro @macro Akey &key @end macro @macro Abody &body @end macro @c for install-info @dircategory Software development @direntry * asdf: (asdf). Another System Definition Facility (for Common Lisp) @end direntry @copying This manual describes ASDF, a system definition facility for Common Lisp programs and libraries. You can find the latest version of this manual at @url{http://common-lisp.net/project/asdf/asdf.html}. ASDF Copyright @copyright{} 2001-2014 Daniel Barlow and contributors. This manual Copyright @copyright{} 2001-2014 Daniel Barlow and contributors. This manual revised @copyright{} 2009-2014 Robert P. Goldman and Francois-Rene Rideau. Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the ``Software''), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. @end copying @titlepage @title ASDF: Another System Definition Facility @c The following two commands start the copyright page. @page @vskip 0pt plus 1filll @insertcopying @end titlepage @c Output the table of contents at the beginning. @contents @c ------------------- @ifnottex @node Top, Introduction, (dir), (dir) @top ASDF: Another System Definition Facility @insertcopying @menu * Introduction:: * Quick start summary:: * Loading ASDF:: * Configuring ASDF:: * Using ASDF:: * Defining systems with defsystem:: * The object model of ASDF:: * Controlling where ASDF searches for systems:: * Controlling where ASDF saves compiled files:: * Error handling:: * Miscellaneous additional functionality:: * Getting the latest version:: * FAQ:: * Ongoing Work:: * Bibliography:: * Concept Index:: * Function and Class Index:: * Variable Index:: @c @detailmenu @c @detailmenu --- The Detailed Node Listing --- Loading ASDF * Loading a pre-installed ASDF:: * Checking whether ASDF is loaded:: * Upgrading ASDF:: * Loading ASDF from source:: Upgrading ASDF * Upgrading your implementation's ASDF:: * Issues with upgrading ASDF:: Configuring ASDF * Configuring ASDF to find your systems:: * Configuring ASDF to find your systems --- old style:: * Configuring where ASDF stores object files:: * Resetting the ASDF configuration:: Using ASDF * Loading a system:: * Other Operations:: * Moving on:: Defining systems with defsystem * The defsystem form:: * A more involved example:: * The defsystem grammar:: * Other code in .asd files:: * The package-inferred-system extension:: The Object model of ASDF * Operations:: * Components:: * Dependencies:: * Functions:: Operations * Predefined operations of ASDF:: * Creating new operations:: Components * Common attributes of components:: * Pre-defined subclasses of component:: * Creating new component types:: properties * Pre-defined subclasses of component:: * Creating new component types:: Controlling where ASDF searches for systems * Configurations:: * Truenames and other dangers:: * XDG base directory:: * Backward Compatibility:: * Configuration DSL:: * Configuration Directories:: * Shell-friendly syntax for configuration:: * Search Algorithm:: * Caching Results:: * Configuration API:: * Introspection:: * Status:: * Rejected ideas:: * TODO:: * Credits for the source-registry:: Configuration Directories * The here directive:: Introspection * *source-registry-parameter* variable:: * Information about system dependencies:: Controlling where ASDF saves compiled files * Output Configurations:: * Output Backward Compatibility:: * Output Configuration DSL:: * Output Configuration Directories:: * Output Shell-friendly syntax for configuration:: * Semantics of Output Translations:: * Output Caching Results:: * Output location API:: * Credits for output translations:: Miscellaneous additional functionality * Controlling file compilation:: * Controlling source file character encoding:: * Some Utility Functions:: FAQ * Where do I report a bug?:: * What has changed between ASDF 1 ASDF 2 and ASDF 3?:: * Issues with installing the proper version of ASDF:: * Issues with configuring ASDF:: * Issues with using and extending ASDF to define systems:: * ASDF development FAQs:: ``What has changed between ASDF 1, ASDF 2, and ASDF 3?'' * What are ASDF 1 2 3?:: * How do I detect the ASDF version?:: * ASDF can portably name files in subdirectories:: * Output translations:: * Source Registry Configuration:: * Usual operations are made easier to the user:: * Many bugs have been fixed:: * ASDF itself is versioned:: * ASDF can be upgraded:: * Decoupled release cycle:: * Pitfalls of the transition to ASDF 2:: * What happened to the bundle operations:: Issues with installing the proper version of ASDF * My Common Lisp implementation comes with an outdated version of ASDF. What to do?:: * I'm a Common Lisp implementation vendor. When and how should I upgrade ASDF?:: Issues with configuring ASDF * How can I customize where fasl files are stored?:: * How can I wholly disable the compiler output cache?:: Issues with using and extending ASDF to define systems * How can I cater for unit-testing in my system?:: * How can I cater for documentation generation in my system?:: * How can I maintain non-Lisp (e.g. C) source files?:: * I want to put my module's files at the top level. How do I do this?:: * How do I create a system definition where all the source files have a .cl extension?:: * How do I mark a source file to be loaded only and not compiled?:: * How do I work with readtables?:: ASDF development FAQs * How do run the tests interactively in a REPL?:: @end detailmenu @end menu @end ifnottex @c ------------------- @node Introduction, Quick start summary, Top, Top @comment node-name, next, previous, up @chapter Introduction @cindex ASDF-related features @vindex *features* @cindex Testing for ASDF @cindex ASDF versions @cindex :asdf @cindex :asdf2 @cindex :asdf3 ASDF is Another System Definition Facility: a tool for specifying how systems of Common Lisp software are made up of components (sub-systems and files), and how to operate on these components in the right order so that they can be compiled, loaded, tested, etc. If you are new to ASDF, @pxref{Quick start summary,,the quick start guide}. ASDF presents three faces: one for users of Common Lisp software who want to reuse other people's code, one for writers of Common Lisp software who want to specify how to build their systems, and one for implementers of Common Lisp extensions who want to extend the build system. For more specifics, @pxref{Using ASDF,,Loading a system}, to learn how to use ASDF to load a system. @xref{Defining systems with defsystem}, to learn how to define a system of your own. @xref{The object model of ASDF}, for a description of the ASDF internals and how to extend ASDF. Note that ASDF is @emph{not} a tool for library and system @emph{installation}; it plays a role like @t{make} or @t{ant}, not like a package manager. In particular, ASDF should not to be confused with ASDF-Install, which attempts to find and download ASDF systems for you. Despite the name, ASDF-Install is not part of ASDF, but a separate piece of software. ASDF-Install is also unmaintained and obsolete. We recommend you use Quicklisp (@uref{http://www.quicklisp.org}) instead, a Common Lisp package manager which works well and is being actively maintained. If you want to download software from version control instead of tarballs, so you may more easily modify it, we recommend clbuild (@uref{http://common-lisp.net/project/clbuild/}). We recommend @file{~/common-lisp/} as a place into which to install Common Lisp software; starting with ASDF 3.1.2, it is included in the default source-registry configuration. @node Quick start summary, Loading ASDF, Introduction, Top @chapter Quick start summary @itemize @item To load an ASDF system: @itemize @item Load ASDF itself into your Lisp image, either through @code{(require "asdf")} (if it's supplied by your lisp implementation) or else through @code{(load "/path/to/asdf.lisp")}. For more details, @ref{Loading ASDF}. @item Make sure ASDF can find system definitions through proper source-registry configuration. For more details, @xref{Configuring ASDF to find your systems}. The simplest way is simply to put all your lisp code in subdirectories of @file{~/common-lisp/} (starting with ASDF 3.1.2), or @file{~/.local/share/common-lisp/source/} (for ASDF 2 and later, or if you want to keep source in a hidden directory). Such code will automatically be found. @item Load a system with @code{(asdf:load-system :system)}. @xref{Using ASDF}. @end itemize @item To make your own ASDF system: @itemize @item As above, load and configure ASDF. @item Make a new directory for your system, @code{my-system/} in a location where ASDF can find it (@pxref{Configuring ASDF to find your systems}). All else being equal, the easiest location is probably @file{~/common-lisp/my-system/}. @item Create an ASDF system definition listing the dependencies of your system, its components, and their interdependencies, and put it in @file{my-system.asd}. This file must have the same name as your system. @xref{Defining systems with defsystem}. @item Use @code{(asdf:load-system :my-system)} to make sure it's all working properly. @xref{Using ASDF}. @end itemize @end itemize @c FIXME: (1) add a sample project that the user can cut and paste to @c get started. (2) discuss the option of starting with Quicklisp. @node Loading ASDF, Configuring ASDF, Quick start summary, Top @comment node-name, next, previous, up @chapter Loading ASDF @menu * Loading a pre-installed ASDF:: * Checking whether ASDF is loaded:: * Upgrading ASDF:: * Loading ASDF from source:: @end menu @node Loading a pre-installed ASDF, Checking whether ASDF is loaded, Loading ASDF, Loading ASDF @section Loading a pre-installed ASDF Most recent Lisp implementations include a copy of ASDF 3, or at least ASDF 2. You can usually load this copy using Common Lisp's @code{require} function.@footnote{ NB: all implementations except GNU CLISP also accept @code{(require "ASDF")}, @code{(require 'asdf)} and @code{(require :asdf)}. For portability's sake, you should use @code{(require "asdf")}. } @lisp (require "asdf") @end lisp As of the writing of this manual, the following implementations provide ASDF 3 this way: ABCL, Allegro CL, Clozure CL, CMUCL, ECL, GNU CLISP, MKCL, SBCL. The following implementations only provide ASDF 2: LispWorks, mocl, XCL. The following implementations don't provide ASDF: Corman CL, GCL, Genera, MCL, SCL. The latter implementations are not actively maintained; if some of them are ever released again, they probably will include ASDF 3. If the implementation you are using doesn't provide ASDF 2 or ASDF 3, see @pxref{Loading ASDF,,Loading ASDF from source} below. If that implementation is still actively maintained, you may also send a bug report to your Lisp vendor and complain about their failing to provide ASDF. @node Checking whether ASDF is loaded, Upgrading ASDF, Loading a pre-installed ASDF, Loading ASDF @section Checking whether ASDF is loaded To check whether ASDF is properly loaded in your current Lisp image, you can run this form: @lisp (asdf:asdf-version) @end lisp If it returns a string, that is the version of ASDF that is currently installed. If it raises an error, then either ASDF is not loaded, or you are using a very old version of ASDF, and need to install ASDF 3. You can check whether an old version is loaded by checking if the ASDF package is present. The form below will allow you to programmatically determine whether a recent version is loaded, an old version is loaded, or none at all: @lisp (when (find-package :asdf) (let ((ver (symbol-value (or (find-symbol (string :*asdf-version*) :asdf) (find-symbol (string :*asdf-revision*) :asdf))))) (etypecase ver (string ver) (cons (with-output-to-string (s) (loop for (n . m) on ver do (princ n s) (when m (princ "." s))))) (null "1.0")))) @end lisp If it returns @code{nil} then ASDF is not installed. Otherwise it should return a string. If it returns @code{"1.0"}, then it can actually be any version before 1.77 or so, or some buggy variant of 1.x. If you are experiencing problems with ASDF, please try upgrading to the latest released version, using the method below, before you contact us and raise an issue. @node Upgrading ASDF, Loading ASDF from source, Checking whether ASDF is loaded, Loading ASDF @section Upgrading ASDF @c FIXME: tighten this up a bit -- there's a lot of stuff here that @c doesn't matter to almost anyone. Move discussion of updating antique @c versions of ASDF down, or encapsulate it. If you want to upgrade to a more recent ASDF version, you need to install and configure your ASDF just like any other system (@pxref{Configuring ASDF to find your systems}). If your implementation provides ASDF 3 or later, you only need to @code{(require "asdf")}: ASDF will automatically look whether an updated version of itself is available amongst the regularly configured systems, before it compiles anything else. @menu * Upgrading your implementation's ASDF:: * Issues with upgrading ASDF:: @end menu @node Upgrading your implementation's ASDF, Issues with upgrading ASDF, Upgrading ASDF, Upgrading ASDF @subsection Upgrading your implementation's ASDF Most implementations provide a recent ASDF 3 in their latest release. If yours doesn't, we recommend upgrading your implementation. If the latest version of your implementation still doesn't provide ASDF, or provides an old version, we recommend installing a recent ASDF so your implementation provides it, as explained below. If all fails, we recommend you load ASDF from source @pxref{Loading ASDF,,Loading ASDF from source}. The ASDF source repository contains a tool to help you upgrade your implementation's ASDF. You can invoke it from the shell command-line as @code{tools/asdf-tools install-asdf lispworks} (where you can replace @code{lispworks} by the name of the relevant implementation), or you can @code{(load "tools/install-asdf.lisp")} from your Lisp REPL. It works on Allegro CL, Clozure CL, CMU CL, ECL, GCL, GNU CLISP, LispWorks, MKCL, SBCL, SCL, XCL. It doesn't work on ABCL, Corman CL, Genera, MCL, MOCL. Happily, ABCL is usually pretty up to date and shouldn't need that script. GCL requires a very recent version, and hasn't been tested for lack of success compiling it. Corman CL, Genera, MCL are obsolete anyway. MOCL is under development. Finally, if your implementation only provides ASDF 2, and you can't or won't upgrade it or override its ASDF module, you may simply configure ASDF to find a proper upgrade; however, to avoid issues with a self-upgrade in mid-build, you @emph{must} make sure to upgrade ASDF immediately after requiring the builtin ASDF 2: @lisp (require "asdf") ;; <--- insert programmatic configuration here if needed (asdf:load-system :asdf) @end lisp @node Issues with upgrading ASDF, , Upgrading your implementation's ASDF, Upgrading ASDF @subsection Issues with upgrading ASDF Note that there are some limitations to upgrading ASDF: @itemize @item Previously loaded ASDF extensions become invalid, and will need to be reloaded. Examples include CFFI-Grovel, hacks used by ironclad, etc. Since it isn't possible to automatically detect what extensions need to be invalidated, ASDF will invalidate @emph{all} previously loaded systems when it is loaded on top of a forward-incompatible ASDF version. @footnote{ @vindex *oldest-forward-compatible-asdf-version* Forward incompatibility can be determined using the variable @code{asdf/upgrade::*oldest-forward-compatible-asdf-version*}, which is 2.33 at the time of this writing.} Starting with ASDF 3 (2.27 or later), this self-upgrade will be automatically attempted as the first step to any system operation, to avoid any possibility of a catastrophic attempt to self-upgrade in mid-build. @c FIXME: Fix grammar below. @item For this and many other reasons, you should load, configure and upgrade ASDF as one of the very first things done by your build and startup scripts. It is safer if you upgrade ASDF and its extensions as a special step at the very beginning of whatever script you are running, before you start using ASDF to load anything else. @item Until all implementations provide ASDF 3 or later, it is unsafe to upgrade ASDF as part of loading a system that depends on a more recent version of ASDF, since the new one might shadow the old one while the old one is running, and the running old one will be confused when extensions are loaded into the new one. In the meantime, we recommend that your systems should @emph{not} specify @code{:depends-on (:asdf)}, or @code{:depends-on ((:version :asdf "3.0.1"))}, but instead that they check that a recent enough ASDF is installed, with such code as: @example (unless (or #+asdf2 (asdf:version-satisfies (asdf:asdf-version) *required-asdf-version*)) (error "FOO requires ASDF ~A or later." *required-asdf-version*)) @end example @item Until all implementations provide ASDF 3 or later, it is unsafe for a system to transitively depend on ASDF and not directly depend on ASDF; if any of the system you use either depends-on asdf, system-depends-on asdf, or transitively does, you should also do as well. @end itemize @node Loading ASDF from source, , Upgrading ASDF, Loading ASDF @section Loading ASDF from source If your implementation doesn't include ASDF, if for some reason the upgrade somehow fails, does not or cannot apply to your case, you will have to install the file @file{asdf.lisp} somewhere and load it with: @lisp (load "/path/to/your/installed/asdf.lisp") @end lisp The single file @file{asdf.lisp} is all you normally need to use ASDF. You can extract this file from latest release tarball on the @url{http://common-lisp.net/project/asdf/,ASDF website}. If you are daring and willing to report bugs, you can get the latest and greatest version of ASDF from its git repository. @xref{Getting the latest version}. For maximum convenience you might want to have ASDF loaded whenever you start your Lisp implementation, for example by loading it from the startup script or dumping a custom core --- check your Lisp implementation's manual for details. @node Configuring ASDF, Using ASDF, Loading ASDF, Top @comment node-name, next, previous, up @chapter Configuring ASDF For standard use cases, ASDF should work pretty much out of the box. We recommend you skim the sections on configuring ASDF to find your systems and choose the method of installing Lisp software that works best for you. Then skip directly to @xref{Using ASDF}. That will probably be enough. You are unlikely to have to worry about the way ASDF stores object files, and resetting the ASDF configuration is usually only needed in corner cases. @menu * Configuring ASDF to find your systems:: * Configuring ASDF to find your systems --- old style:: * Configuring where ASDF stores object files:: * Resetting the ASDF configuration:: @end menu @node Configuring ASDF to find your systems, Configuring ASDF to find your systems --- old style, Configuring ASDF, Configuring ASDF @section Configuring ASDF to find your systems In order to compile and load your systems, ASDF must be configured to find the @file{.asd} files that contain system definitions. There are a number of different techniques for setting yourself up with ASDF, starting from easiest to the most complex: @itemize @bullet @item Put all of your systems in one of the standard locations, subdirectories of @itemize @item @file{~/common-lisp/} or @item @file{~/.local/share/common-lisp/source/}. @end itemize If you install software there, you don't need further configuration.@footnote{@file{~/common-lisp/} is only included in the default configuration starting with ASDF 3.1.2 or later.} @item If you're using some tool to install software (e.g. Quicklisp), the authors of that tool should already have configured ASDF. @item If you have more specific desires about how to lay out your software on disk, the preferred way to configure where ASDF finds your systems is the @code{source-registry} facility, fully described in its own chapter of this manual. @xref{Controlling where ASDF searches for systems}. Here is a quick recipe for getting started: The simplest way to add a path to your search path, say @file{/home/luser/.asd-link-farm/} is to create the directory @file{~/.config/common-lisp/source-registry.conf.d/} and there create a file with any name of your choice, and with the type @file{conf}@footnote{By requiring the @file{.conf} extension, and ignoring other files, ASDF allows you to have disabled files, editor backups, etc. in the same directory with your active configuration files. ASDF will also ignore files whose names start with a @file{.} character. It is customary to start the filename with two digits, to control the sorting of the @code{conf} files in the source registry directory, and thus the order in which the directories will be scanned.}, for instance @file{42-asd-link-farm.conf}, containing the line: @kbd{(:directory "/home/luser/.asd-link-farm/")} If you want all the subdirectories under @file{/home/luser/lisp/} to be recursively scanned for @file{.asd} files, instead use: @kbd{(:tree "/home/luser/lisp/")} ASDF will automatically read your configuration the first time you try to find a system. If necessary, you can reset the source-registry configuration with: @lisp (asdf:clear-source-registry) @end lisp @item In earlier versions of ASDF, the system source registry was configured using a global variable, @code{asdf:*central-registry*}. For more details about this, see the following section, @ref{Configuring ASDF to find your systems --- old style}. Unless you need to understand this, skip directly to @ref{Configuring where ASDF stores object files}. @end itemize Note that your Operating System distribution or your system administrator may already have configured system-managed libraries for you. @node Configuring ASDF to find your systems --- old style, Configuring where ASDF stores object files, Configuring ASDF to find your systems, Configuring ASDF @section Configuring ASDF to find your systems --- old style @c FIXME: this section should be moved elsewhere. The novice user @c should not be burdened with it. [2014/02/27:rpg] The old way to configure ASDF to find your systems is by @code{push}ing directory pathnames onto the variable @code{asdf:*central-registry*}. You must configure this variable between the time you load ASDF and the time you first try to use it. Loading and configuring ASDF presumably happen as part of some initialization script that builds or starts your Common Lisp software system. (For instance, some SBCL users used to put it in their @file{~/.sbclrc}.) The @code{asdf:*central-registry*} is empty by default in ASDF 2 or ASDF 3, but is still supported for compatibility with ASDF 1. When used, it takes precedence over the above source-registry.@footnote{ It is possible to further customize the system definition file search. That's considered advanced use, and covered later: search forward for @code{*system-definition-search-functions*}. @xref{Defining systems with defsystem}.} For example, let's say you want ASDF to find the @file{.asd} file @file{/home/me/src/foo/foo.asd}. In your lisp initialization file, you could have the following: @lisp (require "asdf") (push "/home/me/src/foo/" asdf:*central-registry*) @end lisp Note the trailing slash: when searching for a system, ASDF will evaluate each entry of the central registry and coerce the result to a pathname.@footnote{ ASDF will indeed call @code{eval} on each entry. It will skip entries that evaluate to @code{nil}. Strings and pathname objects are self-evaluating, in which case the @code{eval} step does nothing; but you may push arbitrary s-expressions onto the central registry. These s-expressions may be evaluated to compute context-dependent entries, e.g. things that depend on the value of shell variables or the identity of the user. The variable @code{asdf:*central-registry*} is thus a list of ``system directory designators''. A @dfn{system directory designator} is a form which will be evaluated whenever a system is to be found, and must evaluate to a directory to look in (or @code{NIL}). By ``directory'', we mean ``designator for a pathname with a non-empty DIRECTORY component''. } The trailing directory name separator is necessary to tell Lisp that you're discussing a directory rather than a file. If you leave it out, ASDF is likely to look in @code{/home/me/src/} instead of @code{/home/me/src/foo/} as you intended, and fail to find your system definition. Typically there are a lot of @file{.asd} files, and a common idiom was to put @emph{symbolic links} to all of one's @file{.asd} files in a common directory and push @emph{that} directory (the ``link farm'') onto @code{asdf:*central-registry*}, instead of pushing each individual system directory. ASDF knows to follow @emph{symlinks} to the actual location of the systems.@footnote{ On Windows, you can use Windows shortcuts instead of POSIX symlinks. if you try aliases under MacOS, we are curious to hear about your experience.} For example, if @code{#p"/home/me/cl/systems/"} is an element of @code{*central-registry*}, you could set up the system @var{foo} as follows: @example $ cd /home/me/cl/systems/ $ ln -s ~/src/foo/foo.asd . @end example This old style for configuring ASDF is not recommended for new users, but it is supported for old users, and for users who want to programmatically control what directories are added to the ASDF search path. @node Configuring where ASDF stores object files, Resetting the ASDF configuration, Configuring ASDF to find your systems --- old style, Configuring ASDF @section Configuring where ASDF stores object files @findex clear-output-translations ASDF lets you configure where object files will be stored. Sensible defaults are provided and you shouldn't normally have to worry about it. This allows the same source code repository to be shared between several versions of several Common Lisp implementations, between several users using different compilation options, with users who lack write privileges on shared source directories, etc. This also keeps source directories from being cluttered with object/fasl files. Starting with ASDF 2, the @code{asdf-output-translations} facility was added to ASDF itself. This facility controls where object files will be stored. This facility is fully described in a chapter of this manual, @ref{Controlling where ASDF saves compiled files}. @c FIXME: possibly this should be moved elsewhere. It's redundant here, @c and makes this section of the manual too long and daunting for the @c new user. [2014/02/27:rpg] @c The simplest way to add a translation to your search path, @c say from @file{/foo/bar/baz/quux/} @c to @file{/where/i/want/my/fasls/} @c is to create the directory @c @file{~/.config/common-lisp/asdf-output-translations.conf.d/} @c and there create a file with any name of your choice and the type @file{conf}, @c for instance @file{42-bazquux.conf} @c containing the line: @c @kbd{("/foo/bar/baz/quux/" "/where/i/want/my/fasls/")} @c To disable output translations for source under a given directory, @c say @file{/toto/tata/} @c you can create a file @file{40-disable-toto.conf} @c with the line: @c @kbd{("/toto/tata/")} @c To wholly disable output translations for all directories, @c you can create a file @file{00-disable.conf} @c with the line: @c @kbd{(t t)} @c Note that your Operating System distribution or your system administrator @c may already have configured translations for you. @c In absence of any configuration, the default is to redirect everything @c under an implementation-dependent subdirectory of @file{~/.cache/common-lisp/}. @c @xref{Controlling where ASDF searches for systems}, for full details. @c The required @file{.conf} extension allows you to have disabled files @c or editor backups (ending in @file{~}), and works portably @c (for instance, it is a pain to allow both empty and non-empty extension on CLISP). @c Excluded are files the name of which start with a @file{.} character. @c It is customary to start the filename with two digits @c that specify the order in which the directories will be scanned. @c ASDF will automatically read your configuration @c the first time you try to find a system. @c You can reset the source-registry configuration with: @c @lisp @c (asdf:clear-output-translations) @c @end lisp @c And you probably should do so before you dump your Lisp image, @c if the configuration may change @c between the machine where you save it at the time you save it @c and the machine you resume it at the time you resume it. @c (Once again, you should use @code{(asdf:clear-configuration)} @c before you dump your Lisp image, which includes the above.) Note that before ASDF 2, other ASDF add-ons offered the same functionality, each in subtly different and incompatible ways: ASDF-Binary-Locations, cl-launch, common-lisp-controller. ASDF-Binary-Locations is now not needed anymore and should not be used. cl-launch 3.000 and common-lisp-controller 7.2 have been updated to delegate object file placement to ASDF. @node Resetting the ASDF configuration, , Configuring where ASDF stores object files, Configuring ASDF @section Resetting the ASDF configuration @c FIXME: this should probably be moved out of the "quickstart" part of @c the manual. [2014/02/27:rpg] When you dump and restore an image, or when you tweak your configuration, you may want to reset the ASDF configuration. For that you may use the following function: @defun clear-configuration Undoes any ASDF configuration regarding source-registry or output-translations. @end defun @vindex *image-dump-hook* This function is pushed onto the @code{uiop:*image-dump-hook*} by default, which means that if you save an image using @code{uiop:dump-image}, or via @code{asdf:image-op} and @code{asdf:program-op}, it will be automatically called to clear your configuration. If for some reason you prefer to call your implementation's underlying functionality, be sure to call @code{clear-configuration} manually, or push it into your implementation's equivalent of @code{uiop:*image-dump-hook*}, e.g. @code{sb-ext:*save-hooks*} on SBCL, or @code{ext:*before-save-initializations*} on CMUCL and SCL, etc. @node Using ASDF, Defining systems with defsystem, Configuring ASDF, Top @chapter Using ASDF @menu * Loading a system:: * Other Operations:: * Moving on:: @end menu @node Loading a system, Other Operations, Using ASDF, Using ASDF @section Loading a system The system @var{foo} is loaded (and compiled, if necessary) by evaluating the following Lisp form: @example (asdf:load-system :@var{foo}) @end example On some implementations (namely recent versions of ABCL, Clozure CL, CMUCL, ECL, GNU CLISP, MKCL and SBCL), ASDF hooks into the @code{CL:REQUIRE} facility and you can just use: @example (require :@var{foo}) @end example In older versions of ASDF, you needed to use @code{(asdf:oos 'asdf:load-op :@var{foo})}. If your ASDF is too old to provide @code{asdf:load-system} though we recommend that you upgrade to ASDF 3. @xref{Loading ASDF,,Loading ASDF from source}. Note the name of a system is specified as a string or a symbol. If a symbol (including a keyword), its name is taken and lowercased. The name must be a suitable value for the @code{:name} initarg to @code{make-pathname} in whatever filesystem the system is to be found. The lower-casing-symbols behaviour is unconventional, but was selected after some consideration. The type of systems we want to support either have lowercase as customary case (Unix, Mac, Windows) or silently convert lowercase to uppercase (lpns). @c so this makes more sense than attempting to use @code{:case :common}, @c which is reported not to work on some implementations @node Other Operations, Moving on, Loading a system, Using ASDF @section Other Operations @findex load-system @findex compile-system @findex test-system @findex requrie-system ASDF provides three commands for the most common system operations: @code{load-system}, @code{compile-system}, and @code{test-system}. It also provides @code{require-system}, a version of @code{load-system} that skips trying to update systems that are already loaded. @c FIXME: We seem to export @findex bundle-system also. @findex operate @findex oos Because ASDF is an extensible system for defining @emph{operations} on @emph{components}, it also provides a generic function @code{operate} (which is usually abbreviated by @code{oos}, which stands for operate-on-system). You'll use @code{oos} whenever you want to do something beyond compiling, loading and testing. Output from ASDF and ASDF extensions are sent to the CL stream @code{*standard-output*}, so rebinding that stream around calls to @code{asdf:operate} should redirect all output from ASDF operations. @c Reminder: before ASDF can operate on a system, however, @c it must be able to find and load that system's definition. @c @xref{Configuring ASDF,,Configuring ASDF to find your systems}. @c FIXME: the following is too complicated for here, especially since @c :force hasn't been defined yet. Move it. [2014/02/27:rpg] @findex already-loaded-systems @findex require-system @findex load-system @vindex *load-system-operation* For advanced users, note that @code{require-system} calls @code{load-system} with keyword arguments @code{:force-not (already-loaded-systems)}. @code{already-loaded-systems} returns a list of the names of loaded systems. @code{load-system} applies @code{operate} with the operation from @code{*load-system-operation*} (which by default is @code{load-op}), the system, and any provided keyword arguments. @node Moving on, , Other Operations, Using ASDF @section Moving on That's all you need to know to use ASDF to load systems written by others. The rest of this manual deals with writing system definitions for Common Lisp software you write yourself, including how to extend ASDF to define new operation and component types. @node Defining systems with defsystem, The object model of ASDF, Using ASDF, Top @comment node-name, next, previous, up @chapter Defining systems with defsystem This chapter describes how to use ASDF to define systems and develop software. @menu * The defsystem form:: * A more involved example:: * The defsystem grammar:: * Other code in .asd files:: * The package-inferred-system extension:: @end menu @node The defsystem form, A more involved example, Defining systems with defsystem, Defining systems with defsystem @comment node-name, next, previous, up @section The defsystem form @findex defsystem @cindex asdf-user @findex load-asd This section begins with an example of a system definition, then gives the full grammar of @code{defsystem}. Let's look at a simple system. This is a complete file that should be saved as @file{hello-lisp.asd} (in order that ASDF can find it when ordered to operate on the system named @code{"hello-lisp"}). @c FIXME: the first example should have an outside dependency, e.g., @c CL-PPCRE. @lisp (in-package :asdf-user) (defsystem "hello-lisp" :description "hello-lisp: a sample Lisp system." :version "0.0.1" :author "Joe User " :licence "Public Domain" :components ((:file "packages") (:file "macros" :depends-on ("packages")) (:file "hello" :depends-on ("macros")))) @end lisp Some notes about this example: @itemize @item The file starts with an @code{in-package} form for package @code{asdf-user}. Quick summary: just do this, because it helps make interactive development of @code{defsystem} forms behave in the same was as when these forms are loaded by ASDF. If that's enough for you, skip the rest of this item. Otherwise read on for the gory details. If your file is loaded by ASDF 3, it will be loaded into the @code{asdf-user} package. The @code{in-package} form will ensure that the system definition is read the same as within ASDF when you load it interactively with @code{cl:load}. However, we recommend that you load @file{.asd} files through function @code{asdf::load-asd} rather than through @code{cl:load}, in which case this form is unnecessary. Recent versions of SLIME (2013-02 and later) know to do that. @item You can always rely on symbols from both package @code{asdf} and @code{common-lisp} being available in @code{.asd} files -- most importantly including @code{defsystem}. @c FIXME: the following should be inserted in a more advanced @c bit of the manual. For now, it is simply elided. @c Starting with ASDF 3.1, @c @file{.asd} files are read in the package @code{asdf-user} @c that uses @code{asdf}, @code{uiop} and @code{uiop/common-lisp} @c (a variant of @code{common-lisp} @c that has some portability fixes on old implementations). @c ASDF 3 releases before 3.1 also read in package @code{asdf-user} @c but that package don't use the full @code{uiop}, only @code{uiop/package}. @c ASDF 1 and ASDF 2 releases (up until 2.26) instead read @file{.asd} files @c in a temporary package @code{asdf@emph{N}} @c that uses @code{asdf} and @code{common-lisp}. @c You may thus have to package-qualify some symbols with @code{uiop:} @c to support older variants of ASDF 3, @c and/or package-qualify them with @code{asdf::} @c to be compatible with even older variants of ASDF 2 @c (and then only use the few already available in ASDF 2). @item The @code{defsystem} form defines a system named @code{hello-lisp} that contains three source files: @file{packages}, @file{macros} and @file{hello}. @c FIXME: The first example system should probably use just :serial T. @item The file @file{macros} depends on @file{packages} (presumably because the package it's in is defined in @file{packages}), and the file @file{hello} depends on @file{macros} (and hence, transitively on @file{packages}). This means that ASDF will compile and load @file{packages} and @file{macros} before starting the compilation of file @file{hello}. @item System source files should be located in the same directory as the @code{.asd} file with the system definition. @c FIXME: the following should live somewhere, but not in the quickstart @c page. [2014/05/03:rpg] @c ASDF resolves symbolic links (or Windows shortcuts) @c before loading the system definition file and @c stores its location in the resulting system@footnote{ @c It is possible, though almost never necessary, to override this behaviour.}. @c This is a good thing because the user can move the system sources @c without having to edit the system definition. @c FIXME: Should have cross-reference to "Version specifiers" in the @c defsystem grammar, but the cross-referencing is so broken by @c insufficient node breakdown that I have not put one in. @c FIXME: this is way too detailed for the first example! @c move it! @item Make sure you know how the @code{:version} numbers will be parsed! Only period-separated non-negative integers are accepted. See below Version specifiers in @ref{The defsystem grammar}. @cindex :version @end itemize @node A more involved example, The defsystem grammar, The defsystem form, Defining systems with defsystem @comment node-name, next, previous, up @section A more involved example @findex defsystem Let's illustrate some more involved uses of @code{defsystem} via a slightly convoluted example: @lisp (in-package :asdf-user) (defsystem "foo" :version "1.0.0" :components ((:module "mod" :components ((:file "bar") (:file"baz") (:file "quux")) :perform (compile-op :after (op c) (do-something c)) :explain (compile-op :after (op c) (explain-something c))) (:file "blah"))) @end lisp The @code{:module} component named @code{"mod"} is a collection of three files, which will be located in a subdirectory of the main code directory named @file{mod} (this location can be overridden; see the discussion of the @code{:pathname} option in @ref{The defsystem grammar}). The method-form tokens provide a shorthand for defining methods on particular components. This part @lisp :perform (compile-op :after (op c) (do-something c)) :explain (compile-op :after (op c) (explain-something c)) @end lisp has the effect of @lisp (defmethod perform :after ((op compile-op) (c (eql ...))) (do-something c)) (defmethod explain :after ((op compile-op) (c (eql ...))) (explain-something c)) @end lisp where @code{...} is the component in question. In this case @code{...} would expand to something like @lisp (find-component "foo" "mod") @end lisp For more details on the syntax of such forms, see @ref{The defsystem grammar}. For more details on what these methods do, @pxref{Operations} in @ref{The object model of ASDF}. @c FIXME: The following plunge into detail weeds is not appropriate in this @c location. [2010/10/03:rpg] @c note that although this also supports @code{:before} methods, @c they may not do what you want them to --- @c a @code{:before} method on perform @code{((op compile-op) (c (eql ...)))} @c will run after all the dependencies and sub-components have been processed, @c but before the component in question has been compiled. @c FIXME: There should be YA example that shows definitions of functions @c and classes. The following material should go there. @c @item @c If in addition to simply using @code{defsystem}, @c you are going to define functions, @c create ASDF extension, globally bind symbols, etc., @c it is recommended that to avoid namespace pollution between systems, @c you should create your own package for that purpose, with: @c @lisp @c (defpackage :hello-lisp-system @c (:use :cl :asdf)) @c (in-package :hello-lisp-system) @c @end lisp @node The defsystem grammar, Other code in .asd files, A more involved example, Defining systems with defsystem @comment node-name, next, previous, up @section The defsystem grammar @findex defsystem @cindex DEFSYSTEM grammar @c FIXME: @var typesetting not consistently used here. We should either expand @c its use to everywhere, or we should kill it everywhere. @example system-definition := ( defsystem system-designator @var{system-option}* ) system-option := :defsystem-depends-on system-list | :weakly-depends-on @var{system-list} | :class class-name (see discussion below) | module-option | option module-option := :components component-list | :serial [ t | nil ] option := | :pathname pathname-specifier | :default-component-class class-name | :perform method-form | :explain method-form | :output-files method-form | :operation-done-p method-form | :if-feature feature-expression | :depends-on ( @var{dependency-def}* ) | :in-order-to ( @var{dependency}+ ) system-list := ( @var{simple-component-name}* ) component-list := ( @var{component-def}* ) component-def := ( component-type simple-component-name @var{option}* ) component-type := :module | :file | :static-file | other-component-type other-component-type := symbol-by-name (@pxref{The defsystem grammar,,Component types}) # This is used in :depends-on, as opposed to ``dependency,'' # which is used in :in-order-to dependency-def := simple-component-name | ( :feature @var{feature-expression} dependency-def ) | ( :version simple-component-name version-specifier ) | ( :require module-name ) # ``dependency'' is used in :in-order-to, as opposed to # ``dependency-def'' dependency := (dependent-op @var{requirement}+) requirement := (required-op @var{required-component}+) dependent-op := operation-name required-op := operation-name simple-component-name := string | symbol pathname-specifier := pathname | string | symbol method-form := (operation-name qual lambda-list @Arest{} body) qual := method qualifier component-dep-fail-option := :fail | :try-next | :ignore feature-expression := keyword | (:and @var{feature-expression}*) | (:or @var{feature-expression}*) | (:not @var{feature-expression}) @end example @subsection Component names Component names (@code{simple-component-name}) may be either strings or symbols. @subsection Component types Component type names, even if expressed as keywords, will be looked up by name in the current package and in the asdf package, if not found in the current package. So a component type @code{my-component-type}, in the current package @code{my-system-asd} can be specified as @code{:my-component-type}, or @code{my-component-type}. @code{system} and its subclasses are @emph{not} allowed as component types for such children components. @subsection System class names A system class name will be looked up in the same way as a Component type (see above), except that only @code{system} and its subclasses are allowed. Typically, one will not need to specify a system class name, unless using a non-standard system class defined in some ASDF extension, typically loaded through @code{DEFSYSTEM-DEPENDS-ON}, see below. For such class names in the ASDF package, we recommend that the @code{:class} option be specified using a keyword symbol, such as @example :class :MY-NEW-SYSTEM-SUBCLASS @end example This practice will ensure that package name conflicts are avoided. Otherwise, the symbol @code{MY-NEW-SYSTEM-SUBCLASS} will be read into the current package @emph{before} it has been exported from the ASDF extension loaded by @code{:defsystem-depends-on}, causing a name conflict in the current package. @subsection Defsystem depends on @cindex :defsystem-depends-on The @code{:defsystem-depends-on} option to @code{defsystem} allows the programmer to specify another ASDF-defined system or set of systems that must be loaded @emph{before} the system definition is processed. Typically this is used to load an ASDF extension that is used in the system definition. @subsection Weakly depends on @cindex :weakly-depends-on We do @emph{NOT} recommend you use this feature. If you are tempted to write a system @var{foo} that weakly-depends-on a system @var{bar}, we recommend that you should instead write system @var{foo} in a parametric way, and offer some special variable and/or some hook to specialize its behavior; then you should write a system @var{foo+bar} that does the hooking of things together. The (deprecated) @code{:weakly-depends-on} option to @code{defsystem} allows the programmer to specify another ASDF-defined system or set of systems that ASDF should @emph{try} to load, but need not load in order to be successful. Typically this is used if there are a number of systems that, if present, could provide additional functionality, but which are not necessary for basic function. Currently, although it is specified to be an option only to @code{defsystem}, this option is accepted at any component, but it probably only makes sense at the @code{defsystem} level. Programmers are cautioned not to use this component option except at the @code{defsystem} level, as this anomalous behavior may be removed without warning. @c Finally, you might look into the @code{asdf-system-connections} extension, @c that will let you define additional code to be loaded @c when two systems are simultaneously loaded. @c It may or may not be considered good style, but at least it can be used @c in a way that has deterministic behavior independent of load order, @c unlike @code{weakly-depends-on}. @subsection Pathname specifiers @cindex pathname specifiers A pathname specifier (@code{pathname-specifier}) may be a pathname, a string or a symbol. When no pathname specifier is given for a component, which is the usual case, the component name itself is used. If a string is given, which is the usual case, the string will be interpreted as a Unix-style pathname where @code{/} characters will be interpreted as directory separators. Usually, Unix-style relative pathnames are used (i.e. not starting with @code{/}, as opposed to absolute pathnames); they are relative to the path of the parent component. Finally, depending on the @code{component-type}, the pathname may be interpreted as either a file or a directory, and if it's a file, a file type may be added corresponding to the @code{component-type}, or else it will be extracted from the string itself (if applicable). For instance, the @code{component-type} @code{:module} wants a directory pathname, and so a string @code{"foo/bar"} will be interpreted as the pathname @file{#p"foo/bar/"}. On the other hand, the @code{component-type} @code{:file} wants a file of type @code{lisp}, and so a string @code{"foo/bar"} will be interpreted as the pathname @file{#p"foo/bar.lisp"}, and a string @code{"foo/bar.quux"} will be interpreted as the pathname @file{#p"foo/bar.quux.lisp"}. Finally, the @code{component-type} @code{:static-file} wants a file without specifying a type, and so a string @code{"foo/bar"} will be interpreted as the pathname @file{#p"foo/bar"}, and a string @code{"foo/bar.quux"} will be interpreted as the pathname @file{#p"foo/bar.quux"}. ASDF interprets the string @code{".."} as the pathname directory component word @code{:back}, which when merged, goes back one level in the directory hierarchy. If a symbol is given, it will be translated into a string, and downcased in the process. The downcasing of symbols is unconventional, but was selected after some consideration. Observations suggest that the type of systems we want to support either have lowercase as customary case (Unix, Mac, windows) or silently convert lowercase to uppercase (lpns), so this makes more sense than attempting to use @code{:case :common} as argument to @code{make-pathname}, which is reported not to work on some implementations. Pathname objects may be given to override the path for a component. Such objects are typically specified using reader macros such as @code{#p} or @code{#.(make-pathname ...)}. Note however, that @code{#p...} is a shorthand for @code{#.(parse-namestring ...)} and that the behavior of @code{parse-namestring} is completely non-portable, unless you are using Common Lisp @code{logical-pathname}s, which themselves involve other non-portable behavior (@pxref{The defsystem grammar,,Using logical pathnames}, below). Pathnames made with @code{#.(make-pathname ...)} can usually be done more easily with the string syntax above. The only case that you really need a pathname object is to override the component-type default file type for a given component. Therefore, pathname objects should only rarely be used. Unhappily, ASDF 1 used not to properly support parsing component names as strings specifying paths with directories, and the cumbersome @code{#.(make-pathname ...)} syntax had to be used. An alternative to @code{#.} read-time evaluation is to use @code{(eval `(defsystem ... ,pathname ...))}. Note that when specifying pathname objects, ASDF does not do any special interpretation of the pathname influenced by the component type, unlike the procedure for pathname-specifying strings. On the one hand, you have to be careful to provide a pathname that correctly fulfills whatever constraints are required from that component type (e.g. naming a directory or a file with appropriate type); on the other hand, you can circumvent the file type that would otherwise be forced upon you if you were specifying a string. @subsection Version specifiers @cindex version specifiers @cindex :version Version specifiers are strings to be parsed as period-separated lists of integers. I.e., in the example, @code{"0.2.1"} is to be interpreted, roughly speaking, as @code{(0 2 1)}. In particular, version @code{"0.2.1"} is interpreted the same as @code{"0.0002.1"}, though the latter is not canonical and may lead to a warning being issued. Also, @code{"1.3"} and @code{"1.4"} are both strictly @code{uiop:version<} to @code{"1.30"}, quite unlike what would have happened had the version strings been interpreted as decimal fractions. Instead of a string representing the version, the @code{:version} argument can be an expression that is resolved to such a string using the following trivial domain-specific language: in addition to being a literal string, it can be an expression of the form @code{(:read-file-form :at )}, which will be resolved by reading a form in the specified pathname (read as a subpathname of the current system if relative or a unix-namestring). You may use a @code{uiop:access-at} specifier with the (optional) @code{:at} keyword, by default the specifier is @code{0}, meaning the first form is returned; subforms can also be specified, with e.g. @code{(1 2 2)} specifying ``the third subform (index 2) of the third subform (index 2) of the second form (index 1)'' in the file (mind the off-by-one error in the English language). System definers are encouraged to use version identifiers of the form @var{x}.@var{y}.@var{z} for major version, minor version and patch level, where significant API incompatibilities are signaled by an increased major number. @xref{Common attributes of components}. @subsection Require @cindex :require dependencies Use the implementation's own @code{require} to load the @var{module-name}. @subsection Using logical pathnames @cindex logical pathnames We do not generally recommend the use of logical pathnames, especially not so to newcomers to Common Lisp. However, we do support the use of logical pathnames by old timers, when such is their preference. To use logical pathnames, you will have to provide a pathname object as a @code{:pathname} specifier to components that use it, using such syntax as @code{#p"LOGICAL-HOST:absolute;path;to;component.lisp"}. You only have to specify such logical pathname for your system or some top-level component. Sub-components' relative pathnames, specified using the string syntax for names, will be properly merged with the pathnames of their parents. The specification of a logical pathname host however is @emph{not} otherwise directly supported in the ASDF syntax for pathname specifiers as strings. The @code{asdf-output-translation} layer will avoid trying to resolve and translate logical pathnames. The advantage of this is that you can define yourself what translations you want to use with the logical pathname facility. The disadvantage is that if you do not define such translations, any system that uses logical pathnames will behave differently under asdf-output-translations than other systems you use. If you wish to use logical pathnames you will have to configure the translations yourself before they may be used. ASDF currently provides no specific support for defining logical pathname translations. Note that the reasons we do not recommend logical pathnames are that (1) there is no portable way to set up logical pathnames before they are used, (2) logical pathnames are limited to only portably use a single character case, digits and hyphens. While you can solve the first issue on your own, describing how to do it on each of fifteen implementations supported by ASDF is more than we can document. As for the second issue, mind that the limitation is notably enforced on SBCL, and that you therefore can't portably violate the limitations but must instead define some encoding of your own and add individual mappings to name physical pathnames that do not fit the restrictions. This can notably be a problem when your Lisp files are part of a larger project in which it is common to name files or directories in a way that includes the version numbers of supported protocols, or in which files are shared with software written in different programming languages where conventions include the use of underscores, dots or CamelCase in pathnames. @subsection Serial dependencies @cindex serial dependencies If the @code{:serial t} option is specified for a module, ASDF will add dependencies for each child component, on all the children textually preceding it. This is done as if by @code{:depends-on}. @lisp :serial t :components ((:file "a") (:file "b") (:file "c")) @end lisp is equivalent to @lisp :components ((:file "a") (:file "b" :depends-on ("a")) (:file "c" :depends-on ("a" "b"))) @end lisp @subsection Source location (@code{:pathname}) The @code{:pathname} option is optional in all cases for systems defined via @code{defsystem}, and generally is unnecessary. In the simple case, source files will be found in the same directory as the system or, in the case of modules, in a subdirectory with the same name as the module. @c FIXME: This should be moved elsewhere -- it's too much detail for the @c grammar section. More specifically, ASDF follows a hairy set of rules that are designed so that @enumerate @item @code{find-system} will load a system from disk and have its pathname default to the right place. @item This pathname information will not be overwritten with @code{*default-pathname-defaults*} (which could be somewhere else altogether) if the user loads up the @file{.asd} file into his editor and interactively re-evaluates that form. @end enumerate If a system is being loaded for the first time, its top-level pathname will be set to: @itemize @item The host/device/directory parts of @code{*load-truename*}, if it is bound. @item @code{*default-pathname-defaults*}, otherwise. @end itemize If a system is being redefined, the top-level pathname will be @itemize @item changed, if explicitly supplied or obtained from @code{*load-truename*} (so that an updated source location is reflected in the system definition) @item changed if it had previously been set from @code{*default-pathname-defaults*} @item left as before, if it had previously been set from @code{*load-truename*} and @code{*load-truename*} is currently unbound (so that a developer can evaluate a @code{defsystem} form from within an editor without clobbering its source location) @end itemize @subsection if-feature option @cindex :if-feature component option @anchor{if-feature-option} @c redo if this ever becomes a node in @c its own right... This option allows you to specify a feature expression to be evaluated as if by @code{#+} to conditionally include a component in your build. If the expression is false, the component is dropped as well as any dependency pointing to it. As compared to using @code{#+} which is expanded at read-time, this allows you to have an object in your component hierarchy that can be used for manipulations beside building your project, and that is accessible to outside code that wishes to reason about system structure. Programmers should be careful to consider @strong{when} the @code{:if-feature} is evaluated. Recall that ASDF first computes a build plan, and then executes that plan. ASDF will check to see whether or not a feature is present @strong{at planning time}, not during the build. It follows that one cannot use @code{:if-feature} to check features that are set during the course of the build. It can only be used to check the state of features before any build operations have been performed. This option was added in ASDF 3. For more information, @xref{required-features, Required features}. @subsection if-component-dep-fails option @cindex :if-component-dep-fails component option This option was removed in ASDF 3. Its semantics was limited in purpose and dubious to explain, and its implementation was breaking a hole into the ASDF object model. Please use the @code{if-feature} option instead. @subsection feature requirement This requirement was removed in ASDF 3.1. Please do not use it. In most cases, @code{:if-feature} (@pxref{if-feature-option}) will provide an adequate substitute. The @code{feature} requirement used to ensure that a chain of component dependencies would fail when a key feature was absent. Used in conjunction with @code{:if-component-dep-fails} this provided a roundabout way to express conditional compilation. @node Other code in .asd files, The package-inferred-system extension, The defsystem grammar, Defining systems with defsystem @section Other code in .asd files Files containing @code{defsystem} forms are regular Lisp files that are executed by @code{load}. Consequently, you can put whatever Lisp code you like into these files. However, it is recommended to keep such forms to a minimal, and to instead define @code{defsystem} extensions that you use with @code{:defsystem-depends-on}. If however, you might insist on including code in the @file{.asd} file itself, e.g., to examine and adjust the compile-time environment, possibly adding appropriate features to @code{*features*}. If so, here are some conventions we recommend you follow, so that users can control certain details of execution of the Lisp in @file{.asd} files: @itemize @item Any informative output (other than warnings and errors, which are the condition system's to dispose of) should be sent to the standard CL stream @code{*standard-output*}, so that users can easily control the disposition of output from ASDF operations. @end itemize @node The package-inferred-system extension, , Other code in .asd files, Defining systems with defsystem @section The package-inferred-system extension Starting with release 3.1.2, ASDF supports a one-package-per-file style of programming, whereby each file is its own system, and dependencies are deduced from the @code{defpackage} form (or its variant @code{uiop:define-package}). In this style, packages refer to a system with the same name (downcased); and if a system is defined with @code{:class package-inferred-system}, then system names that start with that name (using the slash @code{/} separator) refer to files under the filesystem hierarchy where the system is defined. For instance, if system @code{my-lib} is defined in @file{/foo/bar/my-lib/my-lib.asd}, then system @code{my-lib/src/utility} will be found in file @file{/foo/bar/my-lib/src/utility.lisp}. This style was made popular by @code{faslpath} and @code{quick-build} before, and at the cost of a stricter package discipline, seems to make for more maintainable code. It is used by ASDF itself (starting with ASDF 3) and by @code{lisp-interface-library}. To use this style, choose a toplevel system name, e.g. @code{my-lib}, and create a file @file{my-lib.asd} with the @code{:class :package-inferred-system} option in its @code{defsystem}. For instance: @example #-asdf3 (error "my-lib requires ASDF 3") (defsystem my-lib :class :package-inferred-system :defsystem-depends-on (:asdf-package-system) :depends-on (:my-lib/interface/all :my-lib/src/all :my-lib/extras/all) :in-order-to ((test-op (load-op :my-lib/test/all))) :perform (test-op (o c) (symbol-call :my-lib/test/all :test-suite))) (defsystem :my-lib/test :depends-on (:my-lib/test/all)) (register-system-packages :my-lib/interface/all '(:my-lib-interface)) (register-system-packages :my-lib/src/all '(:my-lib-implementation)) (register-system-packages :my-lib/test/all '(:my-lib-test)) (register-system-packages :closer-mop '(:c2mop :closer-common-lisp :c2cl :closer-common-lisp-user :c2cl-user)) @end example In the code above, the @code{:defsystem-depends-on (:asdf-package-system)} is for compatibility with older versions of ASDF 3 (ASDF 2 is not supported), and requires the @code{asdf-package-system} library to be present (it is implicitly provided by ASDF starting with release 3.1.2, which can be detected with the feature @code{:asdf3.1}). The function @code{register-system-packages} has to be called to register packages used or provided by your system and its components where the name of the system that provides the package is not the downcase of the package name. Then, file @file{interface/order.lisp} under the @code{lil} hierarchy, that defines abstract interfaces for order comparisons, starts with the following form, dependencies being trivially computed from the @code{:use} and @code{:mix} clauses: @example (uiop:define-package :lil/interface/order (:use :closer-common-lisp :lil/interface/definition :lil/interface/base :lil/interface/eq :lil/interface/group) (:mix :fare-utils :uiop :alexandria) (:export ...)) @end example ASDF can tell that this file depends on system @code{closer-mop} (registered above), @code{lil/interface/definition}, @code{lil/interface/base}, @code{lil/interface/eq}, and @code{lil/interface/group} (package and system names match, and they will be looked up hierarchically). ASDF also detects dependencies from @code{:import-from} clauses. You may thus import a well-defined set of symbols from an existing package as loaded from suitably named system; or if you prefer to use any such symbol fully qualified by a package prefix, you may declare a dependency on such a package and its corresponding system via an @code{:import-from} clause with an empty list of symbols, as in: @example (defpackage :foo/bar (:use :cl) (:import-from :foo/baz #:sym1 #:sym2) (:import-from :foo/quux) (:export ...)) @end example The form @code{uiop:define-package} is supported as well as @code{defpackage}, and has many options that prove useful in this context, such as @code{:use-reexport} and @code{:mix-reexport} that allow for ``inheritance'' of symbols being exported. @node The object model of ASDF, Controlling where ASDF searches for systems, Defining systems with defsystem, Top @comment node-name, next, previous, up @chapter The Object model of ASDF @tindex component @tindex operation ASDF is designed in an object-oriented way from the ground up. Both a system's structure and the operations that can be performed on systems follow a extensible protocol, allowing programmers to add new behaviors to ASDF. For example, @code{cffi} adds support for special FFI description files that interface with C libraries and for wrapper files that embed C code in Lisp. @code{abcl-jar} supports creating Java JAR archives in ABCL. @code{poiu} supports compiling code in parallel using background processes. The key classes in ASDF are @code{component} and @code{operation}. A @code{component} represents an individual source file or a group of source files, and the products (e.g., fasl files) produced from it. An @code{operation} represents a transformation that can be performed on a component, turning them from source files to intermediate results to final outputs. Components are related by @emph{dependencies}, specified in system definitions. When ordered to @code{operate} with some operation on a component (usually a system), ASDF will first compute a @emph{plan} by traversing the dependency graph using function @code{make-plan}.@footnote{ Historically, the function that built a plan was called @code{traverse}, and returned a list of actions; it was deprecated in favor of @code{make-plan} (that returns a plan object) when the @code{plan} objects were introduced; the old function is kept for backward compatibility and debugging purposes only. } The resulting plan object contains an ordered list of @emph{actions}. An action is a pair of an @code{operation} and a @code{component}, representing a particular build step to be @code{perform}ed. The ordering of the plan ensures that no action is performed before all its dependencies have been fulfilled.@footnote{ The term @emph{action} was used by Kent Pitman in his article, ``The Description of Large Systems,'' (@pxref{Bibliography}). Although the term was only used by ASDF hackers starting with ASDF 2, the concept was there since the very beginning of ASDF 1, just not clearly articulated. } In this chapter, we describe ASDF's object-oriented protocol, the classes that make it up, and the generic functions on those classes. These generic functions often take both an operation and a component as arguments: much of the power and configurability of ASDF is provided by this use of CLOS's multiple dispatch. We will describe the built-in component and operation classes, and explain how to extend the ASDF protocol by defining new classes and methods for ASDF's generic functions. We will also describe the many @emph{hooks} that can be configured to customize the behavior of existing @emph{functions}. @c FIXME: Swap operations and components. @c FIXME: Possibly add a description of the PLAN object. @c Not critical, since the user isn't expected to interact with it. @menu * Operations:: * Components:: * Dependencies:: * Functions:: @end menu @node Operations, Components, The object model of ASDF, The object model of ASDF @comment node-name, next, previous, up @section Operations @cindex operation An @dfn{operation} object of the appropriate type is instantiated whenever the user wants to do something with a system like @itemize @item compile all its files @item load the files into a running lisp environment @item copy its source files somewhere else @end itemize Operations can be invoked directly, or examined to see what their effects would be without performing them. There are a bunch of methods specialised on operation and component type that actually do the grunt work. Operations are invoked on systems via @code{operate} (@pxref{operate}). ASDF contains a number of pre-defined @t{operation} classes for common, and even fairly uncommon tasks that you might want to do with it. In addition, ASDF contains ``abstract'' @t{operation} classes that programmers can use as building blocks to define ASDF extensions. We discuss these in turn below. @c The operation object contains whatever state is relevant for this purpose @c (perhaps a list of visited nodes, for example) @c but primarily is a nice thing to specialise operation methods on @c and easier than having them all be @code{EQL} methods. @menu * Predefined operations of ASDF:: * Creating new operations:: @end menu Operations are invoked on systems via @code{operate}. @anchor{operate} @deffn {Generic function} @code{operate} @var{operation} @var{component} @Arest{} @var{initargs} @Akey{} @code{force} @code{force-not} @code{verbose} @AallowOtherKeys @deffnx {Generic function} @code{oos} @var{operation} @var{component} @Arest{} @var{initargs} @Akey{} @AallowOtherKeys{} @code{operate} invokes @var{operation} on @var{system}. @code{oos} is a synonym for @code{operate} (it stands for operate-on-system). @var{operation} is a symbol that is passed, along with the supplied @var{initargs}, to @code{make-operation} (which will call @code{make-instance}) to create the operation object. @var{component} is a component designator, usually a string or symbol that designates a system, sometimes a list of strings or symbols that designate a subcomponent of a system. The @var{initargs} are passed to the @code{make-instance} call when creating the operation object. @c We probably want to deprecate that, because @c (1) there is a mix of flags for operate, for the operation-class, for the plan-class, etc. @c (2) flags to operations have never been well-supported, anyway. @c The future solution probably involves having an explicit :operation-options keyword or some such @c (if operation options are not wholly eliminated), a separate :plan-options, etc. Note that dependencies may cause the operation to invoke other operations on the system or its components: the new operations will be created with the same @var{initargs} as the original one. If @var{force} is @code{:all}, then all systems are forced to be recompiled even if not modified since last compilation. If @var{force} is @code{t}, then only the system being loaded is forced to be recompiled even if not modified since last compilation, but other systems are not affected. If @var{force} is a list, then it specifies a list of systems that are forced to be recompiled even if not modified since last compilation. If @var{force-not} is @code{:all}, then all systems are forced not to be recompiled even if modified since last compilation. If @var{force-not} is @code{t}, then all systems but the system being loaded are forced not to be recompiled even if modified since last compilation (note: this was changed in ASDF 3.1.2). If @var{force-not} is a list, then it specifies a list of systems that are forced not to be recompiled even if modified since last compilation. Both @var{force} and @var{force-not} apply to systems that are dependencies and were already compiled. @var{force-not} takes precedences over @var{force}, as it should, really, but unhappily only since ASDF 3.1.2. Moreover, systems the name of which is member of the set @var{*immutable-systems*} (represented as an equal hash-table) are always considered @var{forced-not}, and even their @file{.asd} is not refreshed from the filesystem. To see what @code{operate} would do, you can use: @example (asdf:traverse operation-class system-name) @end example @end deffn @node Predefined operations of ASDF, Creating new operations, Operations, Operations @comment node-name, next, previous, up @subsection Predefined operations of ASDF @c FIXME: All these deffn's should be replaced with deftyp. Also, we @c should set up an appropriate index. All the operations described in this section are in the @code{asdf} package. They are invoked via the @code{operate} generic function. @lisp (asdf:operate 'asdf:@var{operation-name} :@var{system-name} @{@var{operation-options ...}@}) @end lisp @deffn Operation @code{compile-op} This operation compiles the specified component. A @code{cl-source-file} will be @code{compile-file}'d. All the children and dependencies of a system or module will be recursively compiled by @code{compile-op}. @code{compile-op} depends on @code{prepare-op} which itself depends on a @code{load-op} of all of a component's dependencies, as well as of its parent's dependencies. When @code{operate} is called on @code{compile-op}, all these dependencies will be loaded as well as compiled; yet, some parts of the system main remain unloaded, because nothing depends on them. Use @code{load-op} to load a system. @end deffn @deffn Operation @code{load-op} This operation loads the compiled code for a specified component. A @code{cl-source-file} will have its compiled fasl @code{load}ed, which fasl is the output of @code{compile-op} that @code{load-op} depends on. @code{load-op} will recursively load all the children of a system or module. @code{load-op} also depends on @code{prepare-op} which itself depends on a @code{load-op} of all of a component's dependencies, as well as of its parent's dependencies. @end deffn @deffn Operation @code{prepare-op} This operation ensures that the dependencies of a component and its recursive parents are loaded (as per @code{load-op}), as a prerequisite before @code{compile-op} and @code{load-op} operations may be performed on a given component. @end deffn @deffn Operation @code{load-source-op}, @code{prepare-source-op} @code{load-source-op} will load the source for the files in a module rather than the compiled fasl output. It has a @code{prepare-source-op} analog to @code{prepare-op}, that ensures the dependencies are themselves loaded via @code{load-source-op}. @end deffn @anchor{test-op} @deffn Operation @code{test-op} This operation will perform some tests on the module. The default method will do nothing. The default dependency is to require @code{load-op} to be performed on the module first. Its @code{operation-done-p} method returns @code{nil}, which means that the operation is @emph{never} done -- we assume that if you invoke the @code{test-op}, you want to test the system, even if you have already done so. The results of this operation are not defined by ASDF. It has proven difficult to define how the test operation should signal its results to the user in a way that is compatible with all of the various test libraries and test techniques in use in the community, and given the fact that ASDF operations do not return a value indicating success or failure. For those willing to go to the effort, we suggest defining conditions to signal when a @code{test-op} fails, and storing in those conditions information that describes which tests fail. People typically define a separate test @emph{system} to hold the tests. Doing this avoids unnecessarily adding a test framework as a dependency on a library. For example, one might have @lisp (defsystem foo :in-order-to ((test-op (test-op "foo/test"))) ...) (defsystem foo/test :depends-on (foo fiveam) ; fiveam is a test framework library ...) @end lisp Then one defines @code{perform} methods on @code{test-op} such as the following: @lisp (defsystem foo/test :depends-on (foo fiveam) ; fiveam is a test framework library :perform (test-op (o s) (uiop:symbol-call :fiveam '#:run! (uiop:find-symbol* '#:foo-test-suite :foo-tests))) ...) @end lisp @end deffn @deffn Operation @code{compile-bundle-op}, @code{monolithic-compile-bundle-op}, @code{load-bundle-op}, @code{monolithic-load-bundle-op}, @code{deliver-asd-op}, @code{monolithic-deliver-asd-op}, @code{lib-op}, @code{monolithic-lib-op}, @code{dll-op}, @code{monolithic-dll-op}, @code{image-op}, @code{program-op} These are ``bundle'' operations, that can create a single-file ``bundle'' for all the contents of each system in an application, or for the entire application. @code{compile-bundle-op} will create a single fasl file for each of the systems needed, grouping all its many fasls in one, so you can deliver each system as a single fasl @code{monolithic-compile-bundle-op} will create a single fasl file for the target system and all its dependencies, so you can deliver your entire application as a single fasl. @code{load-bundle-op} will load the output of @code{compile-bundle-op}. Note that if it the output is not up-to-date, @code{compile-bundle-op} may load the intermediate fasls as a side-effect. Bundling fasls together matters a lot on ECL, where the dynamic linking involved in loading tens of individual fasls can be noticeably more expensive than loading a single one. NB: @code{compile-bundle-op}, @code{monolithic-compile-bundle-op}, @code{load-bundle-op}, @code{monolithic-load-bundle-op}, @code{deliver-asd-op}, @code{monolithic-deliver-asd-op} were respectively called @code{fasl-op}, @code{monolithic-fasl-op}, @code{load-fasl-op}, @code{monolithic-load-fasl-op}, @code{binary-op}, @code{monolithic-binary-op} before ASDF 3.1. The old names still exist for backward compatibility, though they poorly label what is going on. Once you have created a fasl with @code{compile-bundle-op}, you can use @code{precompiled-system} to deliver it in a way that is compatible with clients having dependencies on your system, whether it is distributed as source or as a single binary; the @file{.asd} file to be delivered with the fasl will look like this: @example (defsystem :mysystem :class :precompiled-system :fasl (some expression that will evaluate to a pathname)) @end example Or you can use @code{deliver-asd-op} to let ASDF create such a system for you as well as the @code{compile-bundle-op} output, or @code{monolithic-deliver-asd-op}. This allows you to deliver code for your systems or applications as a single file. Of course, if you want to test the result in the current image, @emph{before} you try to use any newly created @file{.asd} files, you should not forget to @code{(asdf:clear-configuration)} or at least @code{(asdf:clear-source-registry)}, so it re-populates the source-registry from the filesystem. The @code{program-op} operation will create an executable program from the specified system and its dependencies. You can use UIOP for its pre-image-dump hooks, its post-image-restore hooks, and its access to command-line arguments. And you can specify an entry point @code{my-app:main} by specifying in your @code{defsystem} the option @code{:entry-point "my-app:main"}. Depending on your implementation, running @code{(asdf:operate 'asdf:program-op :my-app)} may quit the current Lisp image upon completion. See the example in @file{test/hello-world-example.asd} and @file{test/hello.lisp}, as built and tested by @file{test/test-program.script} and @file{test/make-hello-world.lisp}. @code{image-op} will dump an image that may not be standalone and does not start its own function, but follows the usual execution convention of the underlying Lisp, just with more code pre-loaded, for use as an intermediate build result or with a wrapper invocation script. There is also @code{lib-op} for building a linkable @file{.a} file (Windows: @file{.lib}) from all linkable object dependencies (FFI files, and on ECL, Lisp files too), and its monolithic equivalent @code{monolithic-lib-op}. And there is also @code{dll-op} (respectively its monolithic equivalent @code{monolithic-lib-op}) for building a linkable @file{.so} file (Windows: @file{.dll}, MacOS X: @file{.dynlib}) to create a single dynamic library for all the extra FFI code to be linked into each of your systems (respectively your entire application). All these ``bundle'' operations are available since ASDF 3 on all actively supported Lisp implementations, but may be unavailable on unmaintained legacy implementations. This functionality was previously available for select implementations, as part of a separate system @code{asdf-bundle}, itself descended from the ECL-only @code{asdf-ecl}. The pathname of the output of bundle operations is subject to output-translation as usual, unless the operation is equal to the @code{:build-operation} argument to @code{defsystem}. This behavior is not very satisfactory and may change in the future. Maybe you have suggestions on how to better configure it? @end deffn @deffn Operation @code{concatenate-source-op}, @code{monolithic-concatenate-source-op}, @code{load-concatenated-source-op}, @code{compile-concatenated-source-op}, @code{load-compiled-concatenated-source-op}, @code{monolithic-load-concatenated-source-op}, @code{monolithic-compile-concatenated-source-op}, @code{monolithic-load-compiled-concatenated-source-op} These operations, as their respective names indicate, will concatenate all the @code{cl-source-file} source files in a system (or in a system and all its dependencies, if monolithic), in the order defined by dependencies, then load the result, or compile and then load the result. These operations are useful to deliver a system or application as a single source file, and for testing that said file loads properly, or compiles and then loads properly. ASDF itself is delivered as a single source file this way, using @code{monolithic-concatenate-source-op}, prepending a prelude and the @code{uiop} library before the @code{asdf/defsystem} system itself. @end deffn @node Creating new operations, , Predefined operations of ASDF, Operations @comment node-name, next, previous, up @subsection Creating new operations ASDF was designed to be extensible in an object-oriented fashion. To teach ASDF new tricks, a programmer can implement the behaviour he wants by creating a subclass of @code{operation}. ASDF's pre-defined operations are in no way ``privileged'', but it is requested that developers never use the @code{asdf} package for operations they develop themselves. The rationale for this rule is that we don't want to establish a ``global asdf operation name registry'', but also want to avoid name clashes. Your operation @emph{must} usually provide methods for one or more of the following generic functions: @itemize @findex perform @item @code{perform} Unless your operation, like @code{prepare-op}, is for dependency propagation only, the most important function for which to define a method is usually @code{perform}, which will be called to perform the operation on a specified component, after all dependencies have been performed. The @code{perform} method must call @code{input-files} and @code{output-files} (see below) to locate its inputs and outputs, because the user is allowed to override the method or tweak the output-translation mechanism. Perform should only use the primary value returned by @code{output-files}. If one and only one output file is expected, it can call @code{output-file} that checks that this is the case and returns the first and only list element. @findex output-files @item @code{output-files} If your perform method has any output, you must define a method for this function. for ASDF to determine where the outputs of performing operation lie. Your method may return two values, a list of pathnames, and a boolean. If the boolean is @code{nil} (or you fail to return multiple values), then enclosing @code{:around} methods may translate these pathnames, e.g. to ensure object files are somehow stored in some implementation-dependent cache. If the boolean is @code{t} then the pathnames are marked not be translated by the enclosing @code{:around} method. @findex component-depends-on @item @code{component-depends-on} If the action of performing the operation on a component has dependencies, you must define a method on @code{component-depends-on}. Your method will take as specialized arguments an operation and a component which together identify an action, and return a list of entries describing actions that this action depends on. The format of entries is described below. It is @emph{strongly} advised that you should always append the results of @code{(call-next-method)} to the results of your method, or ``interesting'' failures will likely occur, unless you're a true specialist of ASDF internals. It is unhappily too late to compatibly use the @code{append} method combination, but conceptually that's the protocol that is being manually implemented. Each entry returned by @code{component-depends-on} is itself a list. The first element of an entry is an operation designator: either an operation object designating itself, or a symbol that names an operation class (that ASDF will instantiate using @code{make-operation}). For instance, @code{load-op}, @code{compile-op} and @code{prepare-op} are common such names, denoting the respective operations. @c FIXME COERCE-NAME is referenced, but not defined. @findex coerce-name @findex find-component The rest of each entry is a list of component designators: either a component object designating itself, or an identifier to be used with @code{find-component}. @code{find-component} will be called with the current component's parent as parent, and the identifier as second argument. The identifier is typically a string, a symbol (to be downcased as per @code{coerce-name}), or a list of strings or symbols. In particular, the empty list @code{nil} denotes the parent itself. @end itemize An operation @emph{may} provide methods for the following generic functions: @itemize @item @code{input-files} @findex input-files A method for this function is often not needed, since ASDF has a pretty clever default @code{input-files} mechanism. You only need create a method if there are multiple ultimate input files, and/or the bottom one doesn't depend on the @code{component-pathname} of the component. @item @code{operation-done-p} @findex operation-done-p You only need to define a method on that function if you can detect conditions that invalidate previous runs of the operation, even though no filesystem timestamp has changed, in which case you return @code{nil} (the default is @code{t}). For instance, the method for @code{test-op} always returns @code{nil}, so that tests are always run afresh. Of course, the @code{test-op} for your system could depend on a deterministically repeatable @code{test-report-op}, and just read the results from the report files, in which case you could have this method return @code{t}. @end itemize Operations that print output should send that output to the standard CL stream @code{*standard-output*}, as the Lisp compiler and loader do. @node Components, Dependencies, Operations, The object model of ASDF @comment node-name, next, previous, up @section Components @cindex component @cindex system @cindex system designator @cindex component designator @vindex *system-definition-search-functions* A @code{component} represents an individual source file or a group of source files, and the things that get transformed into. A @code{system} is a component at the top level of the component hierarchy, that can be found via @code{find-system}. A @code{source-file} is a component representing a single source-file and the successive output files into which it is transformed. A @code{module} is an intermediate component itself grouping several other components, themselves source-files or further modules. A @dfn{system designator} is a system itself, or a string or symbol that behaves just like any other component name (including with regard to the case conversion rules for component names). A @dfn{component designator}, relative to a base component, is either a component itself, or a string or symbol, or a list of designators. @defun find-system system-designator @Aoptional{} (error-p t) Given a system designator, @code{find-system} finds and returns a system. If no system is found, an error of type @code{missing-component} is thrown, or @code{nil} is returned if @code{error-p} is false. To find and update systems, @code{find-system} funcalls each element in the @code{*system-definition-search-functions*} list, expecting a pathname to be returned, or a system object, from which a pathname may be extracted, and that will be registered. The resulting pathname (if any) is loaded if one of the following conditions is true: @itemize @item there is no system of that name in memory @item the pathname is different from that which was previously loaded @item the file's @code{last-modified} time exceeds the @code{last-modified} time of the system in memory @end itemize @cindex ASDF-USER package When system definitions are loaded from @file{.asd} files, they are implicitly loaded into the @code{ASDF-USER} package, which uses @code{ASDF}, @code{UIOP} and @code{UIOP/COMMON-LISP}@footnote{ Note that between releases 2.27 and 3.0.3, only @code{UIOP/PACKAGE}, not all of @code{UIOP}, was used; if you want your code to work with releases earlier than 3.1.2, you may have to explicitly define a package that uses @code{UIOP}, or use proper package prefix to your symbols, as in @code{uiop:version<}.} Programmers who do anything non-trivial in a @file{.asd} file, such as defining new variables, functions or classes, should include @code{defpackage} and @code{in-package} forms in this file, so they will not overwrite each others' extensions. Such forms might also help the files behave identically if loaded manually with @code{cl:load} for development or debugging, though we recommend you use the function @code{asdf::load-asd} instead, which the @code{slime-asdf} contrib knows about. The default value of @code{*system-definition-search-functions*} is a list of three functions. The first function looks in each of the directories given by evaluating members of @code{*central-registry*} for a file whose name is the name of the system and whose type is @file{asd}; the first such file is returned, whether or not it turns out to actually define the appropriate system. The second function does something similar, for the directories specified in the @code{source-registry}, but searches the filesystem only once and caches its results. The third function makes the @code{package-inferred-system} extension work, @pxref{The package-inferred-system extension}. Because of the way these search functions are defined, you should put the definition for a system @var{foo} in a file named @file{foo.asd}, in a directory that is in the central registry or which can be found using the source registry configuration. @c FIXME: Move this discussion to the system definition grammar, or somewhere else. @anchor{System names} @cindex System names @cindex Primary system name @findex primary-system-name It is often useful to define multiple systems in a same file, but ASDF can only locate a system's definition file based on the system name. For this reason, ASDF 3's system search algorithm has been extended to allow a file @file{foo.asd} to contain secondary systems named @var{foo/bar}, @var{foo/baz}, @var{foo/quux}, etc., in addition to the primary system named @var{foo}. The first component of a system name, separated by the slash character, @code{/}, is called the primary name of a system. The primary name may be extracted by function @code{asdf::primary-system-name}; when ASDF 3 is told to find a system whose name has a slash, it will first attempt to load the corresponding primary system, and will thus see any such definitions, and/or any definition of a @code{package-inferred-system}.@footnote{ ASDF 2.26 and earlier versions do not support this primary system name convention. With these versions of ASDF you must explicitly load @file{foo.asd} before you can use system @var{foo/bar} defined therein, e.g. using @code{(asdf:find-system "foo")}. We do not support ASDF 2, and recommend that you should upgrade to ASDF 3. } If your file @file{foo.asd} also defines systems that do not follow this convention, e.g., a system named @var{foo-test}, ASDF will not be able to automatically locate a definition for these systems, and will only see their definition if you explicitly find or load the primary system using e.g. @code{(asdf:find-system "foo")} before you try to use them. We strongly recommend against this practice, though it is currently supported for backward compatibility. @end defun @defun primary-system-name name Internal (not exported) function, @code{asdf::primary-system-name}. Returns the primary system name (the portion before the slash, @code{/}, in a secondary system name) from @var{name}. @end defun @defun locate-system name This function should typically @emph{not} be invoked directly. It is exported as part of the API only for programmers who wish to provide their own @code{*system-definition-search-functions*}. Given a system @var{name} designator, try to locate where to load the system definition from. @c (This does not include the loading of the system definition, @c which is done by @code{find-system}, @c or the loading of the system itself, which is done by @code{load-system}; @c however, for systems the definition of which has already been loaded, @c @code{locate-system} may return an object of class @code{system}.) Returns five values: @var{foundp}, @var{found-system}, @var{pathname}, @var{previous}, and @var{previous-time}. @var{foundp} is true when a system was found, either a new as yet unregistered one, or a previously registered one. The @var{found-system} return value will be a @code{system} object, if a system definition is found in your source registry. @c This system may be registered (by @code{register-system}) or may not, if @c it's preloaded code. Fare writes: @c In the case of preloaded code, as for "asdf", "uiop", etc., @c themselves, the system objects are not registered until after they are @c initially located by sysdef-preloaded-system-search as a fallback when @c no source code was found. The system definition will @emph{not} be loaded if it hasn't been loaded already. @var{pathname} when not null is a path from which to load the system, either associated with @var{found-system}, or with the @var{previous} system. If @var{previous} is not null, it will be a @emph{previously loaded} @code{system} object of the same name (note that the system @emph{definition} is previously-loaded: the system itself may or may not be). @var{previous-time} when not null is the timestamp of the previous system definition file, at the time when the @var{previous} system definition was loaded. For example, if your current registry has @file{foo.asd} in @file{/current/path/to/foo.asd}, but system @code{foo} was previously loaded from @file{/previous/path/to/foo.asd} then @var{locate-system} will return the following values: @enumerate @item @var{foundp} will be @code{T}, @item @var{found-system} will be @code{NIL}, @item @var{pathname} will be @code{#p"/current/path/to/foo.asd"}, @item @var{previous} will be an object of type @code{SYSTEM} with @code{system-source-file} slot value of @code{#p"/previous/path/to/foo.asd"} @item @var{previous-time} will be the timestamp of @code{#p"/previous/path/to/foo.asd"} at the time it was loaded. @end enumerate @end defun @defun find-component base path Given a @var{base} component (or designator for such), and a @var{path}, find the component designated by the @var{path} starting from the @var{base}. If @var{path} is a component object, it designates itself, independently from the base. @findex coerce-name If @var{path} is a string, or symbol denoting a string via @code{coerce-name}, then @var{base} is resolved to a component object, which must be a system or module, and the designated component is the child named by the @var{path}. If @var{path} is a @code{cons} cell, @code{find-component} with the base and the @code{car} of the @var{path}, and the resulting object is used as the base for a tail call to @code{find-component} with the @code{car} of the @var{path}. If @var{base} is a component object, it designates itself. If @var{base} is null, then @var{path} is used as the base, with @code{nil} as the path. If @var{base} is a string, or symbol denoting a string via @code{coerce-name}, it designates a system as per @code{find-system}. If @var{base} is a @code{cons} cell, it designates the component found by @code{find-component} with its @code{car} as base and @code{cdr} as path. @end defun @menu * Common attributes of components:: * Pre-defined subclasses of component:: * Creating new component types:: @end menu @node Common attributes of components, Pre-defined subclasses of component, Components, Components @comment node-name, next, previous, up @subsection Common attributes of components All components, regardless of type, have the following attributes. All attributes except @code{name} are optional. @subsubsection Name @findex coerce-name A component name is a string or a symbol. If a symbol, its name is taken and lowercased. This translation is performed by the exported function @code{coerce-name}. Unless overridden by a @code{:pathname} attribute, the name will be interpreted as a pathname specifier according to a Unix-style syntax. @xref{The defsystem grammar,,Pathname specifiers}. @subsubsection Version identifier @findex version-satisfies @cindex :version This optional attribute specifies a version for the current component. The version should typically be a string of integers separated by dots, for example @samp{1.0.11}. For more information on version specifiers, see @ref{The defsystem grammar}. A version may then be queried by the generic function @code{version-satisfies}, to see if @code{:version} dependencies are satisfied, and when specifying dependencies, a constraint of minimal version to satisfy can be specified using e.g. @code{(:version "mydepname" "1.0.11")}. Note that in the wild, we typically see version numbering only on components of type @code{system}. Presumably it is much less useful within a given system, wherein the library author is responsible to keep the various files in synch. @subsubsection Required features @anchor{required-features} Traditionally defsystem users have used @code{#+} reader conditionals to include or exclude specific per-implementation files. For example, CFFI, the portable C foreign function interface contained lines like: @lisp #+sbcl (:file "cffi-sbcl") @end lisp An unfortunate side effect of this approach is that no single implementation can read the entire system. This causes problems if, for example, one wished to design an @code{archive-op} that would create an archive file containing all the sources, since for example the file @code{cffi-sbcl.lisp} above would be invisible when running the @code{archive-op} on any implementation other than SBCL. Starting with ASDF 3, components may therefore have an @code{:if-feature} option. The value of this option should be a feature expression using the same syntax as @code{#+} does. If that feature expression evaluates to false, any reference to the component will be ignored during compilation, loading and/or linking. Since the expression is read by the normal reader, you must explicitly prefix your symbols with @code{:} so they be read as keywords; this is as contrasted with the @code{#+} syntax that implicitly reads symbols in the keyword package by default. For instance, @code{:if-feature (:and :x86 (:or :sbcl :cmu :scl))} specifies that the given component is only to be compiled and loaded when the implementation is SBCL, CMUCL or Scieneer CL on an x86 machine. You cannot write it as @code{:if-feature (and x86 (or sbcl cmu scl))} since the symbols would not be read as keywords. @xref{if-feature-option}. @subsubsection Dependencies This attribute specifies dependencies of the component on its siblings. It is optional but often necessary. There is an excitingly complicated relationship between the initarg and the method that you use to ask about dependencies Dependencies are between (operation component) pairs. In your initargs for the component, you can say @lisp :in-order-to ((compile-op (load-op "a" "b") (compile-op "c")) (load-op (load-op "foo"))) @end lisp This means the following things: @itemize @item before performing compile-op on this component, we must perform load-op on @var{a} and @var{b}, and compile-op on @var{c}, @item before performing @code{load-op}, we have to load @var{foo} @end itemize The syntax is approximately @verbatim (this-op @{(other-op required-components)@}+) simple-component-name := string | symbol required-components := simple-component-name | (required-components required-components) component-name := simple-component-name | (:version simple-component-name minimum-version-object) @end verbatim Side note: This is on a par with what ACL defsystem does. mk-defsystem is less general: it has an implied dependency @verbatim for all source file x, (load x) depends on (compile x) @end verbatim and using a @code{:depends-on} argument to say that @var{b} depends on @var{a} @emph{actually} means that @verbatim (compile b) depends on (load a) @end verbatim This is insufficient for e.g. the McCLIM system, which requires that all the files are loaded before any of them can be compiled ] End side note In ASDF, the dependency information for a given component and operation can be queried using @code{(component-depends-on operation component)}, which returns a list @lisp ((load-op "a") (load-op "b") (compile-op "c") ...) @end lisp @code{component-depends-on} can be subclassed for more specific component/operation types: these need to @code{(call-next-method)} and append the answer to their dependency, unless they have a good reason for completely overriding the default dependencies. If it weren't for CLISP, we'd be using @code{LIST} method combination to do this transparently. But, we need to support CLISP. If you have the time for some CLISP hacking, I'm sure they'd welcome your fixes. @c Doesn't CLISP now support LIST method combination? A minimal version can be specified for a component you depend on (typically another system), by specifying @code{(:version "other-system" "1.2.3")} instead of simply @code{"other-system"} as the dependency. See the discussion of the semantics of @code{:version} in the defsystem grammar. @c FIXME: Should have cross-reference to "Version specifiers" in the @c defsystem grammar, but the cross-referencing is so broken by @c insufficient node breakdown that I have not put one in. @subsubsection pathname This attribute is optional and if absent (which is the usual case), the component name will be used. @xref{The defsystem grammar,,Pathname specifiers}, for an explanation of how this attribute is interpreted. Note that the @code{defsystem} macro (used to create a ``top-level'' system) does additional processing to set the filesystem location of the top component in that system. This is detailed elsewhere. @xref{Defining systems with defsystem}. @subsubsection properties This attribute is optional. Packaging systems often require information about files or systems in addition to that specified by ASDF's pre-defined component attributes. Programs that create vendor packages out of ASDF systems therefore have to create ``placeholder'' information to satisfy these systems. Sometimes the creator of an ASDF system may know the additional information and wish to provide it directly. @code{(component-property component property-name)} and associated @code{setf} method will allow the programmatic update of this information. Property names are compared as if by @code{EQL}, so use symbols or keywords or something. @menu * Pre-defined subclasses of component:: * Creating new component types:: @end menu @node Pre-defined subclasses of component, Creating new component types, Common attributes of components, Components @comment node-name, next, previous, up @subsection Pre-defined subclasses of component @deffn Component source-file A source file is any file that the system does not know how to generate from other components of the system. Note that this is not necessarily the same thing as ``a file containing data that is typically fed to a compiler''. If a file is generated by some pre-processor stage (e.g. a @file{.h} file from @file{.h.in} by autoconf) then it is not, by this definition, a source file. Conversely, we might have a graphic file that cannot be automatically regenerated, or a proprietary shared library that we received as a binary: these do count as source files for our purposes. Subclasses of source-file exist for various languages. @emph{FIXME: describe these.} @end deffn @deffn Component module A module is a collection of sub-components. A module component has the following extra initargs: @itemize @item @code{:components} the components contained in this module @item @code{:default-component-class} All children components which don't specify their class explicitly are inferred to be of this type. @item @code{:if-component-dep-fails} This attribute was removed in ASDF 3. Do not use it. Use @code{:if-feature} instead (@pxref{required-features}, and @pxref{if-feature-option}). @item @code{:serial} When this attribute is set, each subcomponent of this component is assumed to depend on all subcomponents before it in the list given to @code{:components}, i.e. all of them are loaded before a compile or load operation is performed on it. @end itemize The default operation knows how to traverse a module, so most operations will not need to provide methods specialised on modules. @code{module} may be subclassed to represent components such as foreign-language linked libraries or archive files. @end deffn @deffn Component system @code{system} is a subclass of @code{module}. A system is a module with a few extra attributes for documentation purposes; these are given elsewhere. @xref{The defsystem grammar}. Users can create new classes for their systems: the default @code{defsystem} macro takes a @code{:class} keyword argument. @end deffn @node Creating new component types, , Pre-defined subclasses of component, Components @comment node-name, next, previous, up @subsection Creating new component types New component types are defined by subclassing one of the existing component classes and specializing methods on the new component class. @c FIXME: this should perhaps be explained more throughly, @c not only by example ... As an example, suppose we have some implementation-dependent functionality that we want to isolate in one subdirectory per Lisp implementation our system supports. We create a subclass of @code{cl-source-file}: @lisp (defclass unportable-cl-source-file (cl-source-file) ()) @end lisp Function @code{asdf:implementation-type} (exported since 2.014.14) gives us the name of the subdirectory. All that's left is to define how to calculate the pathname of an @code{unportable-cl-source-file}. @lisp (defmethod component-pathname ((component unportable-cl-source-file)) (merge-pathnames* (parse-unix-namestring (format nil "~(~A~)/" (asdf:implementation-type))) (call-next-method))) @end lisp The new component type is used in a @code{defsystem} form in this way: @lisp (defsystem :foo :components ((:file "packages") ... (:unportable-cl-source-file "threads" :depends-on ("packages" ...)) ... ) @end lisp @node Dependencies, Functions, Components, The object model of ASDF @section Dependencies @c FIXME: Moved this material here, but it isn't very comfortable @c here.... Also needs to be revised to be coherent. To be successfully build-able, this graph of actions must be acyclic. If, as a user, extender or implementer of ASDF, you introduce a cycle into the dependency graph, ASDF will fail loudly. To clearly distinguish the direction of dependencies, ASDF 3 uses the words @emph{requiring} and @emph{required} as applied to an action depending on the other: the requiring action @code{depends-on} the completion of all required actions before it may itself be @code{perform}ed. Using the @code{defsystem} syntax, users may easily express direct dependencies along the graph of the object hierarchy: between a component and its parent, its children, and its siblings. By defining custom CLOS methods, you can express more elaborate dependencies as you wish. Most common operations, such as @code{load-op}, @code{compile-op} or @code{load-source-op} are automatically propagate ``downward'' the component hierarchy and are ``covariant'' with it: to act the operation on the parent module, you must first act it on all the children components, with the action on the parent being parent of the action on each child. Other operations, such as @code{prepare-op} and @code{prepare-source-op} (introduced in ASDF 3) are automatically propagated ``upward'' the component hierarchy and are ``contravariant'' with it: to perform the operation of preparing for compilation of a child component, you must perform the operation of preparing for compilation of its parent component, and so on, ensuring that all the parent's dependencies are (compiled and) loaded before the child component may be compiled and loaded. Yet other operations, such as @code{test-op} or @code{load-bundle-op} remain at the system level, and are not propagated along the hierarchy, but instead do something global on the system. @node Functions, , Dependencies, The object model of ASDF @comment node-name, next, previous, up @section Functions @c FIXME: this does not belong here.... @defun version-satisfies @var{version} @var{version-spec} Does @var{version} satisfy the @var{version-spec}. A generic function. ASDF provides built-in methods for @var{version} being a @code{component} or @code{string}. @var{version-spec} should be a string. If it's a component, its version is extracted as a string before further processing. A version string satisfies the version-spec if after parsing, the former is no older than the latter. Therefore @code{"1.9.1"}, @code{"1.9.2"} and @code{"1.10"} all satisfy @code{"1.9.1"}, but @code{"1.8.4"} or @code{"1.9"} do not. For more information about how @code{version-satisfies} parses and interprets version strings and specifications, @pxref{The defsystem grammar} (version specifiers) and @ref{Common attributes of components}. Note that in versions of ASDF prior to 3.0.1, including the entire ASDF 1 and ASDF 2 series, @code{version-satisfies} would also require that the version and the version-spec have the same major version number (the first integer in the list); if the major version differed, the version would be considered as not matching the spec. But that feature was not documented, therefore presumably not relied upon, whereas it was a nuisance to several users. Starting with ASDF 3.0.1, @code{version-satisfies} does not treat the major version number specially, and returns T simply if the first argument designates a version that isn't older than the one specified as a second argument. If needs be, the @code{(:version ...)} syntax for specifying dependencies could be in the future extended to specify an exclusive upper bound for compatible versions as well as an inclusive lower bound. @end defun @node Controlling where ASDF searches for systems, Controlling where ASDF saves compiled files, The object model of ASDF, Top @comment node-name, next, previous, up @chapter Controlling where ASDF searches for systems @menu * Configurations:: * Truenames and other dangers:: * XDG base directory:: * Backward Compatibility:: * Configuration DSL:: * Configuration Directories:: * Shell-friendly syntax for configuration:: * Search Algorithm:: * Caching Results:: * Configuration API:: * Introspection:: * Status:: * Rejected ideas:: * TODO:: * Credits for the source-registry:: @end menu @node Configurations, Truenames and other dangers, Controlling where ASDF searches for systems, Controlling where ASDF searches for systems @section Configurations Configurations specify paths where to find system files. @enumerate @item The search registry may use some hardcoded wrapping registry specification. This allows some implementations (notably SBCL) to specify where to find some special implementation-provided systems that need to precisely match the version of the implementation itself. @item An application may explicitly initialize the source-registry configuration using the configuration API (@pxref{Controlling where ASDF searches for systems,Configuration API,Configuration API}, below) in which case this takes precedence. It may itself compute this configuration from the command-line, from a script, from its own configuration file, etc. @item The source registry will be configured from the environment variable @code{CL_SOURCE_REGISTRY} if it exists. @item The source registry will be configured from user configuration file @file{$XDG_CONFIG_DIRS/common-lisp/source-registry.conf} (which defaults to @file{~/.config/common-lisp/source-registry.conf}) if it exists. @item The source registry will be configured from user configuration directory @file{$XDG_CONFIG_DIRS/common-lisp/source-registry.conf.d/} (which defaults to @file{~/.config/common-lisp/source-registry.conf.d/}) if it exists. @item The source registry will be configured from default user configuration trees @file{~/common-lisp/} (since ASDF 3.1.2 only), @file{~/.sbcl/systems/} (on SBCL only), @file{$XDG_DATA_HOME/common-lisp/systems/} (no recursion, link farm) @file{$XDG_DATA_HOME/common-lisp/source/}. The @code{XDG_DATA_HOME} directory defaults to @file{~/.local/share/}. On Windows, the @code{local-appdata} and @code{appdata} directories are used instead. @item The source registry will be configured from system configuration file @file{/etc/common-lisp/source-registry.conf} if it exists. @item The source registry will be configured from system configuration directory @file{/etc/common-lisp/source-registry.conf.d/} if it exists. @item The source registry will be configured from a default configuration. This configuration may allow for implementation-specific systems to be found, for systems to be found the current directory (at the time that the configuration is initialized) as well as @code{:directory} entries for @file{$XDG_DATA_DIRS/common-lisp/systems/} and @code{:tree} entries for @file{$XDG_DATA_DIRS/common-lisp/source/}, where @code{XDG_DATA_DIRS} defaults to @file{/usr/local/share} and @file{/usr/share} on Unix, and the @code{common-appdata} directory on Windows. @item The source registry may include implementation-dependent directories that correspond to implementation-provided extensions. @end enumerate Each of these configurations is specified as an s-expression in a trivial domain-specific language (defined below). Additionally, a more shell-friendly syntax is available for the environment variable (defined yet below). Each of these configurations is only used if the previous configuration explicitly or implicitly specifies that it includes its inherited configuration. Additionally, some implementation-specific directories may be automatically prepended to whatever directories are specified in configuration files, no matter if the last one inherits or not. @node Truenames and other dangers, XDG base directory, Configurations, Controlling where ASDF searches for systems @section Truenames and other dangers One great innovation of the original ASDF was its ability to leverage @code{CL:TRUENAME} to locate where your source code was and where to build it, allowing for symlink farms as a simple but effective configuration mechanism that is easy to control programmatically. ASDF 3 still supports this configuration style, and it is enabled by default; however we recommend you instead use our source-registry configuration mechanism described below, because it is easier to setup in a portable way across users and implementations. Additionally, some people dislike truename, either because it is very slow on their system, or because they are using content-addressed storage where the truename of a file is related to a digest of its individual contents, and not to other files in the same intended project. For these people, ASDF 3 allows to eschew the @code{TRUENAME} mechanism, by setting the variable @var{asdf:*resolve-symlinks*} to @code{nil}. PS: Yes, if you haven't read Vernor Vinge's short but great classic ``True Names... and Other Dangers'' then you're in for a treat. @node XDG base directory, Backward Compatibility, Truenames and other dangers, Controlling where ASDF searches for systems @section XDG base directory Note that we purport to respect the XDG base directory specification as to where configuration files are located, where data files are located, where output file caches are located. Mentions of XDG variables refer to that document. @url{http://standards.freedesktop.org/basedir-spec/basedir-spec-latest.html} This specification allows the user to specify some environment variables to customize how applications behave to his preferences. On Windows platforms, when not using Cygwin, instead of the XDG base directory specification, we try to use folder configuration from the registry regarding @code{Common AppData} and similar directories. Since support for querying the Windows registry is not possible to do in reasonable amounts of portable Common Lisp code, ASDF 3 relies on the environment variables that Windows usually exports. @node Backward Compatibility, Configuration DSL, XDG base directory, Controlling where ASDF searches for systems @section Backward Compatibility For backward compatibility as well as to provide a practical backdoor for hackers, ASDF will first search for @file{.asd} files in the directories specified in @code{asdf:*central-registry*} before it searches in the source registry above. @xref{Configuring ASDF,,Configuring ASDF to find your systems --- old style}. By default, @code{asdf:*central-registry*} will be empty. This old mechanism will therefore not affect you if you don't use it, but will take precedence over the new mechanism if you do use it. @node Configuration DSL, Configuration Directories, Backward Compatibility, Controlling where ASDF searches for systems @section Configuration DSL @cindex :inherit-configuration source config directive @cindex inherit-configuration source config directive @cindex :ignore-invalid-entries source config directive @cindex ignore-invalid-entries source config directive @cindex :directory source config directive @cindex directory source config directive @cindex :tree source config directive @cindex tree source config directive @cindex :exclude source config directive @cindex exclude source config directive @cindex :also-exclude source config directive @cindex also-exclude source config directive @cindex :include source config directive @cindex include source config directive @cindex :default-registry source config directive @cindex default-registry source config directive Here is the grammar of the s-expression (SEXP) DSL for source-registry configuration: @c FIXME: This is too wide for happy compilation into pdf. @example ;; A configuration is a single SEXP starting with the keyword ;; :source-registry followed by a list of directives. CONFIGURATION := (:source-registry DIRECTIVE ...) ;; A directive is one of the following: DIRECTIVE := ;; INHERITANCE DIRECTIVE: ;; Your configuration expression MUST contain ;; exactly one of the following: :inherit-configuration | ;; splices inherited configuration (often specified last) or :ignore-inherited-configuration | ;; drop inherited configuration (specified anywhere) ;; forward compatibility directive (since ASDF 2.011.4), useful when ;; you want to use new configuration features but have to bootstrap ;; the newer required ASDF from an older release that doesn't ;; support said features: :ignore-invalid-entries | ;; add a single directory to be scanned (no recursion) (:directory DIRECTORY-PATHNAME-DESIGNATOR) | ;; add a directory hierarchy, recursing but ;; excluding specified patterns (:tree DIRECTORY-PATHNAME-DESIGNATOR) | ;; override the defaults for exclusion patterns (:exclude EXCLUSION-PATTERN ...) | ;; augment the defaults for exclusion patterns (:also-exclude EXCLUSION-PATTERN ...) | ;; Note that the scope of a an exclude pattern specification is ;; the rest of the current configuration expression or file. ;; splice the parsed contents of another config file (:include REGULAR-FILE-PATHNAME-DESIGNATOR) | ;; This directive specifies that some default must be spliced. :default-registry REGULAR-FILE-PATHNAME-DESIGNATOR := PATHNAME-DESIGNATOR ; interpreted as a file DIRECTORY-PATHNAME-DESIGNATOR := PATHNAME-DESIGNATOR ; interpreted as a directory PATHNAME-DESIGNATOR := NIL | ;; Special: skip this entry. ABSOLUTE-COMPONENT-DESIGNATOR ;; see pathname DSL EXCLUSION-PATTERN := a string without wildcards, that will be matched exactly against the name of a any subdirectory in the directory component of a path. e.g. @code{"_darcs"} will match @file{#p"/foo/bar/_darcs/src/bar.asd"} @end example Pathnames are designated using another DSL, shared with the output-translations configuration DSL below. The DSL is resolved by the function @code{asdf::resolve-location}, to be documented and exported at some point in the future. @example ABSOLUTE-COMPONENT-DESIGNATOR := (ABSOLUTE-COMPONENT-DESIGNATOR RELATIVE-COMPONENT-DESIGNATOR ...) | STRING | ;; namestring (better be absolute or bust, directory assumed where ;; applicable). In output-translations, directory is assumed and ;; **/*.*.* added if it's last. On MCL, a MacOSX-style POSIX ;; namestring (for MacOS9 style, use #p"..."); Note that none of the ;; above applies to strings used in *central-registry*, which ;; doesn't use this DSL: they are processed as normal namestrings. ;; however, you can compute what you put in the *central-registry* ;; based on the results of say ;; (asdf::resolve-location "/Users/fare/cl/cl-foo/") PATHNAME | ;; pathname (better be an absolute path, or bust) ;; In output-translations, unless followed by relative components, ;; it better have appropriate wildcards, as in **/*.*.* :HOME | ; designates the user-homedir-pathname ~/ :USER-CACHE | ; designates the default location for the user cache :HERE | ;; designates the location of the configuration file ;; (or *default-pathname-defaults*, if invoked interactively) :ROOT ;; magic, for output-translations source only: paths that are relative ;; to the root of the source host and device They keyword :SYSTEM-CACHE is not accepted in ASDF 3.1 and beyond: it was a security hazard. RELATIVE-COMPONENT-DESIGNATOR := (RELATIVE-COMPONENT-DESIGNATOR RELATIVE-COMPONENT-DESIGNATOR ...) | STRING | ;; relative directory pathname as interpreted by ;; parse-unix-namestring. ;; In output translations, if last component, **/*.*.* is added PATHNAME | ; pathname; unless last component, directory is assumed. :IMPLEMENTATION | ;; directory based on implementation, e.g. sbcl-1.0.45-linux-x64 :IMPLEMENTATION-TYPE | ;; a directory based on lisp-implementation-type only, e.g. sbcl :DEFAULT-DIRECTORY | ;; a relativized version of the default directory :*/ | ;; any direct subdirectory (since ASDF 2.011.4) :**/ | ;; any recursively inferior subdirectory (since ASDF 2.011.4) :*.*.* | ;; any file (since ASDF 2.011.4) The keywords :UID and :USERNAME are no longer supported. @end example For instance, as a simple case, my @file{~/.config/common-lisp/source-registry.conf}, which is the default place ASDF looks for this configuration, once contained: @example (:source-registry (:tree (:home "cl")) ;; will expand to e.g. "/home/joeluser/cl/" :inherit-configuration) @end example @node Configuration Directories, Shell-friendly syntax for configuration, Configuration DSL, Controlling where ASDF searches for systems @section Configuration Directories Configuration directories consist in files each containing a list of directives without any enclosing @code{(:source-registry ...)} form. The files will be sorted by namestring as if by @code{string<} and the lists of directives of these files with be concatenated in order. An implicit @code{:inherit-configuration} will be included at the @emph{end} of the list. System-wide or per-user Common Lisp software distributions such as Debian packages or some future version of @code{clbuild} may then include files such as @file{/etc/common-lisp/source-registry.conf.d/10-foo.conf} or @file{~/.config/common-lisp/source-registry.conf.d/10-foo.conf} to easily and modularly register configuration information about software being distributed. The convention is that, for sorting purposes, the names of files in such a directory begin with two digits that determine the order in which these entries will be read. Also, the type of these files must be @file{.conf}, which not only simplifies the implementation by allowing for more portable techniques in finding those files, but also makes it trivial to disable a file, by renaming it to a different file type. Directories may be included by specifying a directory pathname or namestring in an @code{:include} directive, e.g.: @example (:include "/foo/bar/") @end example Hence, to achieve the same effect as my example @file{~/.config/common-lisp/source-registry.conf} above, I could simply create a file @file{~/.config/common-lisp/source-registry.conf.d/33-home-fare-cl.conf} alone in its directory with the following contents: @example (:tree "/home/fare/cl/") @end example @menu * The here directive:: @end menu @node The here directive, , Configuration Directories, Configuration Directories @subsection The :here directive The @code{:here} directive is an absolute pathname designator that refers to the directory containing the configuration file currently being processed. The @code{:here} directive is intended to simplify the delivery of complex CL systems, and for easy configuration of projects shared through revision control systems, in accordance with our design principle that each participant should be able to provide all and only the information available to him or her. Consider a person X who has set up the source code repository for a complex project with a master directory @file{dir/}. Ordinarily, one might simply have the user add a directive that would look something like this: @example (:tree "path/to/dir") @end example But what if X knows that there are very large subtrees under dir that are filled with, e.g., Java source code, image files for icons, etc.? All of the asdf system definitions are contained in the subdirectories @file{dir/src/lisp/} and @file{dir/extlib/lisp/}, and these are the only directories that should be searched. In this case, X can put into @file{dir/} a file @file{asdf.conf} that contains the following: @example (:source-registry (:tree (:here "src/lisp/")) (:tree (:here "extlib/lisp")) (:directory (:here "outlier/"))) @end example Then when someone else (call her Y) checks out a copy of this repository, she need only add @example (:include "/path/to/my/checkout/directory/asdf.conf") @end example to one of her previously-existing asdf source location configuration files, or invoke @code{initialize-source-registry} with a configuration form containing that s-expression. ASDF will find the .conf file that X has provided, and then set up source locations within the working directory according to X's (relative) instructions. @node Shell-friendly syntax for configuration, Search Algorithm, Configuration Directories, Controlling where ASDF searches for systems @section Shell-friendly syntax for configuration When considering environment variable @code{CL_SOURCE_REGISTRY} ASDF will skip to next configuration if it's an empty string. It will @code{READ} the string as a SEXP in the DSL if it begins with a paren @code{(}, otherwise it will be interpreted much like @code{TEXINPUTS}, as a list of paths, where * paths are separated by a @code{:} (colon) on Unix platforms (including cygwin), by a @code{;} (semicolon) on other platforms (mainly, Windows). * each entry is a directory to add to the search path. * if the entry ends with a double slash @code{//} then it instead indicates a tree in the subdirectories of which to recurse. * if the entry is the empty string (which may only appear once), then it indicates that the inherited configuration should be spliced there. @node Search Algorithm, Caching Results, Shell-friendly syntax for configuration, Controlling where ASDF searches for systems @section Search Algorithm @vindex *default-source-registry-exclusions* In case that isn't clear, the semantics of the configuration is that when searching for a system of a given name, directives are processed in order. When looking in a directory, if the system is found, the search succeeds, otherwise it continues. When looking in a tree, if one system is found, the search succeeds. If multiple systems are found, the consequences are unspecified: the search may succeed with any of the found systems, or an error may be raised. ASDF currently returns the first system found, XCVB currently raised an error. If none is found, the search continues. Exclude statements specify patterns of subdirectories the systems from which to ignore. Typically you don't want to use copies of files kept by such version control systems as Darcs. Exclude statements are not propagated to further included or inherited configuration files or expressions; instead the defaults are reset around every configuration statement to the default defaults from @code{asdf::*default-source-registry-exclusions*}. Include statements cause the search to recurse with the path specifications from the file specified. An inherit-configuration statement cause the search to recurse with the path specifications from the next configuration (@pxref{Controlling where ASDF searches for systems,,Configurations} above). @node Caching Results, Configuration API, Search Algorithm, Controlling where ASDF searches for systems @section Caching Results The implementation is allowed to either eagerly compute the information from the configurations and file system, or to lazily re-compute it every time, or to cache any part of it as it goes. In practice, the recommended @code{source-registry} eagerly collects and caches results and you need to explicitly flush the cache for change to be taken into account, whereas the old-style @code{*central-registry*} mechanism queries the filesystem every time. To explicitly flush any information cached by the system after a change was made in the filesystem, @xref{Configuration API}, and e.g. call @code{asdf:clear-source-registry}. Starting with ASDF 3.1.4, you can also explicitly build a persistent cache of the @file{.asd} files found under a tree: when recursing into a directory declared by @code{:tree} and its transitive subdirectories, if a file @file{.cl-source-registry.cache} exists containing a form that is a list starting with @code{:source-registry-cache} followed by a list of strings, as in @code{(:source-registry-cache @emph{"foo/bar.asd" "path/to/more.asd" ...})}, then the strings are assumed to be @code{unix-namestring}s designating the available asd files under that tree, and the recursion otherwise stops. The list can also be empty, allowing to stop a costly recursion in a huge directory tree. To update such a cache after you install, update or remove source repositories, you can run a script distributed with ASDF: @code{tools/cl-source-registry-cache.lisp @emph{/path/to/directory}}. To wholly invalidate the cache, you can delete the file @file{.cl-source-registry.cache} in that directory. In either case, for an existing Lisp process to see this change, it needs to clear its own cache with e.g. @code{(asdf:clear-source-registry)}. Developers may safely create a cache in their development tree, and we recommend they do it at the top of their source tree if it contains more than a small number of files and directories; they only need update it when they create, remove or move @file{.asd} files. Software distribution managers may also safely create such a cache, but they must be careful to update it every time they install, update or remove a software source repository or installation package. Finally, advanced developers who juggle with a lot of code in their @code{source-registry} may manually manage such a cache, to allow for faster startup of Lisp programs. This persistence cache can help you reduce startup latency. For instance, on one machine with hundreds of source repositories, such a cache shaves half a second at the startup of every @code{#!/usr/bin/cl} script using SBCL, more on other implementations; this makes a notable difference as to their subjective interactivity and usability. The speedup will only happen if the implementation-provided ASDF is recent enough (3.1.3.7 or later); it is not enough for a recent ASDF upgrade to be present, since the upgrade will itself be found but after the old version has scanned the directories without heeding such a cache. To upgrade the implementation-provided ASDF, use our script @code{tools/install-asdf.lisp}. @node Configuration API, Introspection, Caching Results, Controlling where ASDF searches for systems @section Configuration API The specified functions are exported from your build system's package. Thus for ASDF the corresponding functions are in package ASDF, and for XCVB the corresponding functions are in package XCVB. @defun initialize-source-registry @Aoptional{} PARAMETER will read the configuration and initialize all internal variables. You may extend or override configuration from the environment and configuration files with the given @var{PARAMETER}, which can be @code{nil} (no configuration override), or a SEXP (in the SEXP DSL), a string (as in the string DSL), a pathname (of a file or directory with configuration), or a symbol (fbound to function that when called returns one of the above). @end defun @defun clear-source-registry undoes any source registry configuration and clears any cache for the search algorithm. You might want to call this function (or better, @code{clear-configuration}) before you dump an image that would be resumed with a different configuration, and return an empty configuration. Note that this does not include clearing information about systems defined in the current image, only about where to look for systems not yet defined. @end defun @defun ensure-source-registry @Aoptional{} PARAMETER checks whether a source registry has been initialized. If not, initialize it with the given @var{PARAMETER}. @end defun Every time you use ASDF's @code{find-system}, or anything that uses it (such as @code{operate}, @code{load-system}, etc.), @code{ensure-source-registry} is called with parameter @code{nil}, which the first time around causes your configuration to be read. If you change a configuration file, you need to explicitly @code{initialize-source-registry} again, or maybe simply to @code{clear-source-registry} (or @code{clear-configuration}) which will cause the initialization to happen next time around. @node Introspection, Status, Configuration API, Controlling where ASDF searches for systems @section Introspection @menu * *source-registry-parameter* variable:: * Information about system dependencies:: @end menu @node *source-registry-parameter* variable, Information about system dependencies, Introspection, Introspection @subsection *source-registry-parameter* variable @vindex *source-registry-parameter* We have made available the variable @code{*source-registry-parameter*} that can be used by code that wishes to introspect about the (past) configuration of ASDF's source registry. @strong{This variable should never be set!} It will be set as a side-effect of calling @code{initialize-source-registry}; user code should treat it as read-only. @node Information about system dependencies, , *source-registry-parameter* variable, Introspection @subsection Information about system dependencies ASDF makes available three functions to read system interdependencies. These are intended to aid programmers who wish to perform dependency analyses. @defun system-defsystem-depends-on system @end defun @defun system-depends-on system @end defun @defun system-weakly-depends-on system Returns a list of names of systems that are weakly depended on by @var{system}. Weakly depended on systems are optionally loaded only if ASDF can find them; failure to find such systems does @emph{not} cause an error in loading. Note that the return value for @code{system-weakly-depends-on} is simpler than the return values of the other two system dependency introspection functions. @end defun @node Status, Rejected ideas, Introspection, Controlling where ASDF searches for systems @section Status This mechanism is vastly successful, and we have declared that @code{asdf:*central-registry*} is not recommended anymore, though we will continue to support it. All hooks into implementation-specific search mechanisms have been integrated in the @code{wrapping-source-registry} that everyone uses implicitly. @node Rejected ideas, TODO, Status, Controlling where ASDF searches for systems @section Rejected ideas Alternatives I (FRR) considered and rejected while developing ASDF 2 included: @enumerate @item Keep @code{asdf:*central-registry*} as the master with its current semantics, and somehow the configuration parser expands the new configuration language into a expanded series of directories of subdirectories to lookup, pre-recursing through specified hierarchies. This is kludgy, and leaves little space of future cleanups and extensions. @item Keep @code{asdf:*central-registry*} as the master but extend its semantics in completely new ways, so that new kinds of entries may be implemented as a recursive search, etc. This seems somewhat backwards. @item Completely remove @code{asdf:*central-registry*} and break backwards compatibility. Hopefully this will happen in a few years after everyone migrate to a better ASDF and/or to XCVB, but it would be very bad to do it now. @item Replace @code{asdf:*central-registry*} by a symbol-macro with appropriate magic when you dereference it or setf it. Only the new variable with new semantics is handled by the new search procedure. Complex and still introduces subtle semantic issues. @end enumerate I've been suggested the below features, but have rejected them, for the sake of keeping ASDF no more complex than strictly necessary. @itemize @item More syntactic sugar: synonyms for the configuration directives, such as @code{(:add-directory X)} for @code{(:directory X)}, or @code{(:add-directory-hierarchy X)} or @code{(:add-directory X :recurse t)} for @code{(:tree X)}. @item The possibility to register individual files instead of directories. @item Integrate Xach Beane's tilde expander into the parser, or something similar that is shell-friendly or shell-compatible. I'd rather keep ASDF minimal. But maybe this precisely keeps it minimal by removing the need for evaluated entries that ASDF has? i.e. uses of @code{USER-HOMEDIR-PATHNAME} and @code{$SBCL_HOME} Hopefully, these are already superseded by the @code{:default-registry} @item Using the shell-unfriendly syntax @code{/**} instead of @code{//} to specify recursion down a filesystem tree in the environment variable. It isn't that Lisp friendly either. @end itemize @node TODO, Credits for the source-registry, Rejected ideas, Controlling where ASDF searches for systems @section TODO @itemize @item Add examples @end itemize @node Credits for the source-registry, , TODO, Controlling where ASDF searches for systems @section Credits for the source-registry Thanks a lot to Stelian Ionescu for the initial idea. Thanks to Rommel Martinez for the initial implementation attempt. All bad design ideas and implementation bugs are mine, not theirs. But so are good design ideas and elegant implementation tricks. --- Francois-Rene Rideau @email{fare@@tunes.org}, Mon, 22 Feb 2010 00:07:33 -0500 @node Controlling where ASDF saves compiled files, Error handling, Controlling where ASDF searches for systems, Top @comment node-name, next, previous, up @chapter Controlling where ASDF saves compiled files @cindex asdf-output-translations @vindex ASDF_OUTPUT_TRANSLATIONS Each Common Lisp implementation has its own format for compiled files or fasls.@footnote{``FASL'' is short for ``FASt Loading.''} If you use multiple implementations (or multiple versions of the same implementation), you'll soon find your source directories littered with various @file{fasl}s, @file{dfsl}s, @file{cfsl}s and so on. Worse yet, multiple implementations use the same file extension and some implementations maintain the same file extension while changing formats from version to version (or platform to platform). This can lead to many errors and much confusion as you switch from one implementation to the next. Since ASDF 2, ASDF includes the @code{asdf-output-translations} facility to mitigate the problem. @menu * Output Configurations:: * Output Backward Compatibility:: * Output Configuration DSL:: * Output Configuration Directories:: * Output Shell-friendly syntax for configuration:: * Semantics of Output Translations:: * Output Caching Results:: * Output location API:: * Credits for output translations:: @end menu @node Output Configurations, Output Backward Compatibility, Controlling where ASDF saves compiled files, Controlling where ASDF saves compiled files @section Configurations @c FIXME: Explain how configurations work: can't expect reader will have @c looked at previous chapter. Probably cut and paste will do. Configurations specify mappings from input locations to output locations. Once again we rely on the XDG base directory specification for configuration. @xref{Controlling where ASDF searches for systems,,XDG base directory}. @enumerate @item Some hardcoded wrapping output translations configuration may be used. This allows special output translations (or usually, invariant directories) to be specified corresponding to the similar special entries in the source registry. @item An application may explicitly initialize the output-translations configuration using the Configuration API in which case this takes precedence. (@pxref{Controlling where ASDF saves compiled files,,Configuration API}.) It may itself compute this configuration from the command-line, from a script, from its own configuration file, etc. @item The source registry will be configured from the environment variable @code{ASDF_OUTPUT_TRANSLATIONS} if it exists. @item The source registry will be configured from user configuration file @file{$XDG_CONFIG_DIRS/common-lisp/asdf-output-translations.conf} (which defaults to @file{~/.config/common-lisp/asdf-output-translations.conf}) if it exists. @item The source registry will be configured from user configuration directory @file{$XDG_CONFIG_DIRS/common-lisp/asdf-output-translations.conf.d/} (which defaults to @file{~/.config/common-lisp/asdf-output-translations.conf.d/}) if it exists. @item The source registry will be configured from system configuration file @file{/etc/common-lisp/asdf-output-translations.conf} if it exists. @item The source registry will be configured from system configuration directory @file{/etc/common-lisp/asdf-output-translations.conf.d/} if it exists. @end enumerate Each of these configurations is specified as a SEXP in a trivial domain-specific language (@pxref{Configuration DSL}). Additionally, a more shell-friendly syntax is available for the environment variable (@pxref{Shell-friendly syntax for configuration}). When processing an entry in the above list of configuration methods, ASDF will stop unless that entry explicitly or implicitly specifies that it includes its inherited configuration. Note that by default, a per-user cache is used for output files. This allows the seamless use of shared installations of software between several users, and takes files out of the way of the developers when they browse source code, at the expense of taking a small toll when developers have to clean up output files and find they need to get familiar with output-translations first.@footnote{A @code{CLEAN-OP} would be a partial solution to this problem.} @node Output Backward Compatibility, Output Configuration DSL, Output Configurations, Controlling where ASDF saves compiled files @section Backward Compatibility @cindex ASDF-BINARY-LOCATIONS compatibility @c FIXME: Demote this section -- the typical reader doesn't care about @c backwards compatibility. We purposely do @emph{not} provide backward compatibility with earlier versions of @code{ASDF-Binary-Locations} (8 Sept 2009), @code{common-lisp-controller} (7.0) or @code{cl-launch} (2.35), each of which had similar general capabilities. The APIs of these programs were not designed for easy user configuration through configuration files. Recent versions of @code{common-lisp-controller} (7.2) and @code{cl-launch} (3.000) use the new @code{asdf-output-translations} API as defined below. @code{ASDF-Binary-Locations} is fully superseded and not to be used anymore. This incompatibility shouldn't inconvenience many people. Indeed, few people use and customize these packages; these few people are experts who can trivially adapt to the new configuration. Most people are not experts, could not properly configure these features (except inasmuch as the default configuration of @code{common-lisp-controller} and/or @code{cl-launch} might have been doing the right thing for some users), and yet will experience software that ``just works'', as configured by the system distributor, or by default. Nevertheless, if you are a fan of @code{ASDF-Binary-Locations}, we provide a limited emulation mode: @defun enable-asdf-binary-locations-compatibility @Akey{} centralize-lisp-binaries default-toplevel-directory include-per-user-information map-all-source-files source-to-target-mappings This function will initialize the new @code{asdf-output-translations} facility in a way that emulates the behavior of the old @code{ASDF-Binary-Locations} facility. Where you would previously set global variables @var{*centralize-lisp-binaries*}, @var{*default-toplevel-directory*}, @var{*include-per-user-information*}, @var{*map-all-source-files*} or @var{*source-to-target-mappings*} you will now have to pass the same values as keyword arguments to this function. Note however that as an extension the @code{:source-to-target-mappings} keyword argument will accept any valid pathname designator for @code{asdf-output-translations} instead of just strings and pathnames. @end defun If you insist, you can also keep using the old @code{ASDF-Binary-Locations} (the one available as an extension to load of top of ASDF, not the one built into a few old versions of ASDF), but first you must disable @code{asdf-output-translations} with @code{(asdf:disable-output-translations)}, or you might experience ``interesting'' issues. Also, note that output translation is enabled by default. To disable it, use @code{(asdf:disable-output-translations)}. @node Output Configuration DSL, Output Configuration Directories, Output Backward Compatibility, Controlling where ASDF saves compiled files @section Configuration DSL Here is the grammar of the SEXP DSL for @code{asdf-output-translations} configuration: @verbatim ;; A configuration is single SEXP starting with keyword :source-registry ;; followed by a list of directives. CONFIGURATION := (:output-translations DIRECTIVE ...) ;; A directive is one of the following: DIRECTIVE := ;; INHERITANCE DIRECTIVE: ;; Your configuration expression MUST contain ;; exactly one of either of these: :inherit-configuration | ;; splices inherited configuration (often specified last) :ignore-inherited-configuration | ;; drop inherited configuration (specified anywhere) ;; forward compatibility directive (since ASDF 2.011.4), useful when ;; you want to use new configuration features but have to bootstrap a ;; the newer required ASDF from an older release that doesn't have ;; said features: :ignore-invalid-entries | ;; include a configuration file or directory (:include PATHNAME-DESIGNATOR) | ;; enable global cache in ~/.common-lisp/cache/sbcl-1.0.45-linux-amd64/ ;; or something. :enable-user-cache | ;; Disable global cache. Map / to / :disable-cache | ;; add a single directory to be scanned (no recursion) (DIRECTORY-DESIGNATOR DIRECTORY-DESIGNATOR) ;; use a function to return the translation of a directory designator (DIRECTORY-DESIGNATOR (:function TRANSLATION-FUNCTION)) DIRECTORY-DESIGNATOR := NIL | ; As source: skip this entry. As destination: same as source T | ; as source matches anything, as destination ; maps pathname to itself. ABSOLUTE-COMPONENT-DESIGNATOR ; same as in the source-registry language TRANSLATION-FUNCTION := SYMBOL | ;; symbol naming a function that takes two arguments: ;; the pathname to be translated and the matching ;; DIRECTORY-DESIGNATOR LAMBDA ;; A form which evaluates to a function taking two arguments: ;; the pathname to be translated and the matching ;; DIRECTORY-DESIGNATOR @end verbatim Relative components better be either relative or subdirectories of the path before them, or bust. @c FIXME: the following assumes that the reader is familiar with the use @c of this pattern in logical pathnames, which may not be a reasonable @c assumption. Expand. The last component, if not a pathname, is notionally completed by @file{/**/*.*}. You can specify more fine-grained patterns by using a pathname object as the last component e.g. @file{#p"some/path/**/foo*/bar-*.fasl"} You may use @code{#+features} to customize the configuration file. The second designator of a mapping may be @code{nil}, indicating that files are not mapped to anything but themselves (same as if the second designator was the same as the first). When the first designator is @code{t}, the mapping always matches. When the first designator starts with @code{:root}, the mapping matches any host and device. In either of these cases, if the second designator isn't @code{t} and doesn't start with @code{:root}, then strings indicating the host and pathname are somehow copied in the beginning of the directory component of the source pathname before it is translated. When the second designator is @code{t}, the mapping is the identity. When the second designator starts with @code{:root}, the mapping preserves the host and device of the original pathname. Notably, this allows you to map files to a subdirectory of the whichever directory the file is in. Though the syntax is not quite as easy to use as we'd like, you can have an (source destination) mapping entry such as follows in your configuration file, or you may use @code{enable-asdf-binary-locations-compatibility} with @code{:centralize-lisp-binaries nil} which will do the same thing internally for you: @lisp #.(let ((wild-subdir (make-pathname :directory '(:relative :wild-inferiors))) (wild-file (make-pathname :name :wild :version :wild :type :wild))) `((:root ,wild-subdir ,wild-file) (:root ,wild-subdir :implementation ,wild-file))) @end lisp Starting with ASDF 2.011.4, you can use the simpler: @code{`(:root (:root :**/ :implementation :*.*.*))} @code{:include} statements cause the search to recurse with the path specifications from the file specified. If the @code{translate-pathname} mechanism cannot achieve a desired translation, the user may provide a function which provides the required algorithm. Such a translation function is specified by supplying a list as the second @code{directory-designator} the first element of which is the keyword @code{:function}, and the second element of which is either a symbol which designates a function or a lambda expression. The function designated by the second argument must take two arguments, the first being the pathname of the source file, the second being the wildcard that was matched. When invoked, the function should return the translated pathname. An @code{:inherit-configuration} statement causes the search to recurse with the path specifications from the next configuration in the bulleted list. @xref{Controlling where ASDF saves compiled files,,Configurations}, above. @vindex @code{asdf::*user-cache*} @itemize @item @code{:enable-user-cache} is the same as @code{(t :user-cache)}. @item @code{:disable-cache} is the same as @code{(t t)}. @item @code{:user-cache} uses the contents of variable @code{asdf::*user-cache*} which by default is the same as using @code{(:home ".cache" "common-lisp" :implementation)}. @end itemize @node Output Configuration Directories, Output Shell-friendly syntax for configuration, Output Configuration DSL, Controlling where ASDF saves compiled files @section Configuration Directories Configuration directories consist of files, each of which contains a list of directives without any enclosing @code{(:output-translations ...)} form. The files will be sorted by namestring as if by @code{string<} and the lists of directives of these files with be concatenated in order. An implicit @code{:inherit-configuration} will be included at the @emph{end} of the list. System-wide or per-user Common Lisp software distributions such as Debian packages or some future version of @code{clbuild} may then include files such as @file{/etc/common-lisp/asdf-output-translations.conf.d/10-foo.conf} or @file{~/.config/common-lisp/asdf-output-translations.conf.d/10-foo.conf} to easily and modularly register configuration information about software being distributed. The convention is that, for sorting purposes, the names of files in such a directory begin with two digits that determine the order in which these entries will be read. Also, the type of these files must be @file{.conf}, which not only simplifies the implementation by allowing for more portable techniques in finding those files, but also makes it trivial to disable a file, by renaming it to a different file type. Directories may be included by specifying a directory pathname or namestring in an @code{:include} directive, e.g.: @verbatim (:include "/foo/bar/") @end verbatim @node Output Shell-friendly syntax for configuration, Semantics of Output Translations, Output Configuration Directories, Controlling where ASDF saves compiled files @section Shell-friendly syntax for configuration When considering environment variable @code{ASDF_OUTPUT_TRANSLATIONS} ASDF will skip to the next configuration if it's an empty string. It will @code{READ} the string as an SEXP in the DSL if it begins with a paren @code{(} and it will be interpreted as a list of directories. Directories should come by pairs, indicating a mapping directive. Entries are separated by a @code{:} (colon) on Unix platforms (including cygwin), by a @code{;} (semicolon) on other platforms (mainly, Windows). The magic empty entry, if it comes in what would otherwise be the first entry in a pair, indicates the splicing of inherited configuration. If it comes as the second entry in a pair, it indicates that the directory specified first is to be left untranslated (which has the same effect as if the directory had been repeated). Thus @code{"/foo:/bar::/baz:"} means that things under directory @file{/foo/} are translated to be under @file{/bar/}, then include the inherited configuration, then specify that things under directory @file{/baz/} are not translated. @node Semantics of Output Translations, Output Caching Results, Output Shell-friendly syntax for configuration, Controlling where ASDF saves compiled files @section Semantics of Output Translations From the specified configuration, a list of mappings is extracted in a straightforward way: mappings are collected in order, recursing through included or inherited configuration as specified. To this list is prepended some implementation-specific mappings, and is appended a global default. The list is then compiled to a mapping table as follows: for each entry, in order, resolve the first designated directory into an actual directory pathname for source locations. If no mapping was specified yet for that location, resolve the second designated directory to an output location directory add a mapping to the table mapping the source location to the output location, and add another mapping from the output location to itself (unless a mapping already exists for the output location). Based on the table, a mapping function is defined, mapping source pathnames to output pathnames: given a source pathname, locate the longest matching prefix in the source column of the mapping table. Replace that prefix by the corresponding output column in the same row of the table, and return the result. If no match is found, return the source pathname. (A global default mapping the filesystem root to itself may ensure that there will always be a match, with same fall-through semantics). @node Output Caching Results, Output location API, Semantics of Output Translations, Controlling where ASDF saves compiled files @section Caching Results The implementation is allowed to either eagerly compute the information from the configurations and file system, or to lazily re-compute it every time, or to cache any part of it as it goes. To explicitly flush any information cached by the system, use the API below. @node Output location API, Credits for output translations, Output Caching Results, Controlling where ASDF saves compiled files @section Output location API The specified functions are exported from package ASDF. @defun initialize-output-translations @Aoptional{} PARAMETER will read the configuration and initialize all internal variables. You may extend or override configuration from the environment and configuration files with the given @var{PARAMETER}, which can be @code{nil} (no configuration override), or a SEXP (in the SEXP DSL), a string (as in the string DSL), a pathname (of a file or directory with configuration), or a symbol (fbound to function that when called returns one of the above). @end defun @defun disable-output-translations will initialize output translations in a way that maps every pathname to itself, effectively disabling the output translation facility. @end defun @defun clear-output-translations undoes any output translation configuration and clears any cache for the mapping algorithm. You might want to call this function (or better, @code{clear-configuration}) before you dump an image that would be resumed with a different configuration, and return an empty configuration. Note that this does not include clearing information about systems defined in the current image, only about where to look for systems not yet defined. @end defun @defun ensure-output-translations @Aoptional{} PARAMETER checks whether output translations have been initialized. If not, initialize them with the given @var{PARAMETER}. This function will be called before any attempt to operate on a system. @end defun @defun apply-output-translations PATHNAME Applies the configured output location translations to @var{PATHNAME} (calls @code{ensure-output-translations} for the translations). @end defun Every time you use ASDF's @code{output-files}, or anything that uses it (that may compile, such as @code{operate}, @code{perform}, etc.), @code{ensure-output-translations} is called with parameter @code{nil}, which the first time around causes your configuration to be read. If you change a configuration file, you need to explicitly @code{initialize-output-translations} again, or maybe @code{clear-output-translations} (or @code{clear-configuration}), which will cause the initialization to happen next time around. @node Credits for output translations, , Output location API, Controlling where ASDF saves compiled files @section Credits for output translations Thanks a lot to Peter van Eynde for @code{Common Lisp Controller} and to Bjorn Lindberg and Gary King for @code{ASDF-Binary-Locations}. All bad design ideas and implementation bugs are to mine, not theirs. But so are good design ideas and elegant implementation tricks. --- Francois-Rene Rideau @email{fare@@tunes.org} @c @section Default locations @c @findex output-files-for-system-and-operation @c The default binary location for each Lisp implementation @c is a subdirectory of each source directory. @c To account for different Lisps, Operating Systems, Implementation versions, @c and so on, ASDF borrows code from SLIME @c to create reasonable custom directory names. @c Here are some examples: @c @itemize @c @item @c SBCL, version 1.0.45 on Mac OS X for Intel: @code{sbcl-1.0.45-darwin-x86} @c @item @c Franz Allegro, version 8.0, ANSI Common Lisp: @code{allegro-8.0a-macosx-x86} @c @item @c Franz Allegro, version 8.1, Modern (case sensitive) Common Lisp: @code{allegro-8.1m-macosx-x86} @c @end itemize @c By default, all output file pathnames will be relocated @c to some thus-named subdirectory of @file{~/.cache/common-lisp/}. @c See the document @file{README.asdf-output-translations} @c for a full specification on how to configure @code{asdf-output-translations}. @node Error handling, Miscellaneous additional functionality, Controlling where ASDF saves compiled files, Top @comment node-name, next, previous, up @chapter Error handling @findex SYSTEM-DEFINITION-ERROR @findex OPERATION-ERROR @section ASDF errors If ASDF detects an incorrect system definition, it will signal a generalised instance of @code{SYSTEM-DEFINITION-ERROR}. Operations may go wrong (for example when source files contain errors). These are signalled using generalised instances of @code{OPERATION-ERROR}. @section Compilation error and warning handling @vindex *compile-file-warnings-behaviour* @vindex *compile-file-errors-behavior* ASDF checks for warnings and errors when a file is compiled. The variables @var{*compile-file-warnings-behaviour*} and @var{*compile-file-errors-behavior*} control the handling of any such events. The valid values for these variables are @code{:error}, @code{:warn}, and @code{:ignore}. @node Miscellaneous additional functionality, Getting the latest version, Error handling, Top @comment node-name, next, previous, up @chapter Miscellaneous additional functionality ASDF includes several additional features that are generally useful for system definition and development. @menu * Controlling file compilation:: * Controlling source file character encoding:: * Some Utility Functions:: @end menu @node Controlling file compilation, Controlling source file character encoding, Miscellaneous additional functionality, Miscellaneous additional functionality @section Controlling file compilation @cindex :around-compile @cindex around-compile keyword @cindex compile-check keyword @cindex :compile-check @findex compile-file* @c FIXME: Needs rewrite. Start with motivation -- why are we doing @c this? (there is some, but it's buried). Also, all of a sudden in @c the middle of the discussion we start talking about a "hook," which @c is confusing. When declaring a component (system, module, file), you can specify a keyword argument @code{:around-compile function}. If left unspecified (and therefore unbound), the value will be inherited from the parent component if any, or with a default of @code{nil} if no value is specified in any transitive parent. The argument must be either @code{nil}, an fbound symbol, a lambda-expression (e.g. @code{(lambda (thunk) ...(funcall thunk ...) ...)}) a function object (e.g. using @code{#.#'} but that's discouraged because it prevents the introspection done by e.g. asdf-dependency-grovel), or a string that when @code{read} yields a symbol or a lambda-expression. @code{nil} means the normal compile-file function will be called. A non-nil value designates a function of one argument that will be called with a function that will invoke @code{compile-file*} with various arguments; the around-compile hook may supply additional keyword arguments to pass to that call to @code{compile-file*}. One notable argument that is heeded by @code{compile-file*} is @code{:compile-check}, a function called when the compilation was otherwise a success, with the same arguments as @code{compile-file}; the function shall return true if the compilation and its resulting compiled file respected all system-specific invariants, and false (@code{nil}) if it broke any of those invariants; it may issue warnings or errors before it returns @code{nil}. (NB: The ability to pass such extra flags is only available starting with ASDF 2.22.3.) This feature is notably exercised by asdf-finalizers. By using a string, you may reference a function, symbol and/or package that will only be created later during the build, but isn't yet present at the time the defsystem form is evaluated. However, if your entire system is using such a hook, you may have to explicitly override the hook with @code{nil} for all the modules and files that are compiled before the hook is defined. Using this hook, you may achieve such effects as: locally renaming packages, binding @var{*readtables*} and other syntax-controlling variables, handling warnings and other conditions, proclaiming consistent optimization settings, saving code coverage information, maintaining meta-data about compilation timings, setting gensym counters and PRNG seeds and other sources of non-determinism, overriding the source-location and/or timestamping systems, checking that some compile-time side-effects were properly balanced, etc. Note that there is no around-load hook. This is on purpose. Some implementations such as ECL, GCL or MKCL link object files, which allows for no such hook. Other implementations allow for concatenating FASL files, which doesn't allow for such a hook either. We aim to discourage something that's not portable, and has some dubious impact on performance and semantics even when it is possible. Things you might want to do with an around-load hook are better done around-compile, though it may at times require some creativity (see e.g. the @code{package-renaming} system). @node Controlling source file character encoding, Some Utility Functions, Controlling file compilation, Miscellaneous additional functionality @section Controlling source file character encoding Starting with ASDF 2.21, components accept a @code{:encoding} option so authors may specify which character encoding should be used to read and evaluate their source code. When left unspecified, the encoding is inherited from the parent module or system; if no encoding is specified at any point, or if @code{nil} is explicitly specified, an extensible protocol described below is followed, that ultimately defaults to @code{:utf-8} since ASDF 3. The protocol to determine the encoding is to call the function @code{detect-encoding}, which itself, if provided a valid file, calls the function specified by @var{*encoding-detection-hook*}, or else defaults to the @var{*default-encoding*}. The @var{*encoding-detection-hook*} is by default bound to function @code{always-default-encoding}, that always returns the contents of @var{*default-encoding*}. @var{*default-encoding*} is bound to @code{:utf-8} by default (before ASDF 3, the default was @code{:default}). Whichever encoding is returned must be a portable keyword, that will be translated to an implementation-specific external-format designator by function @code{encoding-external-format}, which itself simply calls the function specified @var{*encoding-external-format-hook*}; that function by default is @code{default-encoding-external-format}, that only recognizes @code{:utf-8} and @code{:default}, and translates the former to the implementation-dependent @var{*utf-8-external-format*}, and the latter to itself (that itself is portable but has an implementation-dependent meaning). In other words, there now are plenty of extension hooks, but by default ASDF enforces the previous @emph{de facto} standard behavior of using @code{:utf-8}, independently from whatever configuration the user may be using. Thus, system authors can now rely on @code{:utf-8} being used while compiling their files, even if the user is currently using @code{:koi8-r} or @code{:euc-jp} as their interactive encoding. (Before ASDF 3, there was no such guarantee, @code{:default} was used, and only plain ASCII was safe to include in source code.) Some legacy implementations only support 8-bit characters, and some implementations provide 8-bit only variants. On these implementations, the @var{*utf-8-external-format*} gracefully falls back to @code{:default}, and Unicode characters will be read as multi-character mojibake. To detect such situations, UIOP will push the @code{:asdf-unicode} feature on implementations that support Unicode, and you can use reader-conditionalization to protect any @code{:encoding @emph{encoding}} statement, as in @code{#+asdf-unicode :encoding #+asdf-unicode :utf-8}. We recommend that you avoid using unprotected @code{:encoding} specifications until after ASDF 2.21 or later becomes widespread (in April 2014, only LispWorks lags with ASDF 2.019, and is scheduled to be updated later this year). While it offers plenty of hooks for extension, and one such extension is available (see @code{asdf-encodings} below), ASDF itself only recognizes one encoding beside @code{:default}, and that is @code{:utf-8}, which is the @emph{de facto} standard, already used by the vast majority of libraries that use more than ASCII. On implementations that do not support unicode, the feature @code{:asdf-unicode} is absent, and the @code{:default} external-format is used to read even source files declared as @code{:utf-8}. On these implementations, non-ASCII characters intended to be read as one CL character may thus end up being read as multiple CL characters. In most cases, this shouldn't affect the software's semantics: comments will be skipped just the same, strings with be read and printed with slightly different lengths, symbol names will be accordingly longer, but none of it should matter. But a few systems that actually depend on unicode characters may fail to work properly, or may work in a subtly different way. See for instance @code{lambda-reader}. We invite you to embrace UTF-8 as the encoding for non-ASCII characters starting today, even without any explicit specification in your @file{.asd} files. Indeed, on some implementations and configurations, UTF-8 is already the @code{:default}, and loading your code may cause errors if it is encoded in anything but UTF-8. Therefore, even with the legacy behavior, non-UTF-8 is guaranteed to break for some users, whereas UTF-8 is pretty much guaranteed not to break anywhere (provided you do @emph{not} use a BOM), although it might be read incorrectly on some implementations. @code{:utf-8} has been the default value of @code{*default-encoding*} since ASDF 3. If you need non-standard character encodings for your source code, use the extension system @code{asdf-encodings}, by specifying @code{:defsystem-depends-on (:asdf-encodings)} in your @code{defsystem}. This extension system will register support for more encodings using the @code{*encoding-external-format-hook*} facility, so you can explicitly specify @code{:encoding :latin1} in your @file{.asd} file. Using the @code{*encoding-detection-hook*} it will also eventually implement some autodetection of a file's encoding from an emacs-style @code{-*- mode: lisp ; coding: latin1 -*-} declaration, or otherwise based on an analysis of octet patterns in the file. At this point, @code{asdf-encoding} only supports the encodings that are supported as part of your implementation. Since the list varies depending on implementations, we still recommend you use @code{:utf-8} everywhere, which is the most portable (next to it is @code{:latin1}). Recent versions of Quicklisp include @code{asdf-encodings}; if you're not using it, you may get this extension using git: @kbd{git clone git://common-lisp.net/projects/asdf/asdf-encodings.git} or @kbd{git clone ssh://common-lisp.net/project/asdf/git/asdf-encodings.git}. You can also browse the repository on @url{http://common-lisp.net/gitweb?p=projects/asdf/asdf-encodings.git}. When you use @code{asdf-encodings}, any @file{.asd} file loaded will use the autodetection algorithm to determine its encoding. If you depend on this detection happening, you should explicitly load @code{asdf-encodings} early in your build. Note that @code{:defsystem-depends-on} cannot be used here: by the time the @code{:defsystem-depends-on} is loaded, the enclosing @code{defsystem} form has already been read. In practice, this means that the @code{*default-encoding*} is usually used for @file{.asd} files. Currently, this defaults to @code{:utf-8}, and you should be safe using Unicode characters in those files. This might matter, for instance, in meta-data about author's names. Otherwise, the main data in these files is component (path)names, and we don't recommend using non-ASCII characters for these, for the result probably isn't very portable. @section Miscellaneous Functions These functions are exported by ASDF for your convenience. @anchor{system-relative-pathname} @defun system-relative-pathname system name @Akey{} type It's often handy to locate a file relative to some system. The @code{system-relative-pathname} function meets this need. It takes two mandatory arguments @var{system} and @var{name} and a keyword argument @var{type}: @var{system} is name of a system, whereas @var{name} and optionally @var{type} specify a relative pathname, interpreted like a component pathname specifier by @code{coerce-pathname}. @xref{The defsystem grammar,,Pathname specifiers}. It returns a pathname built from the location of the system's source directory and the relative pathname. For example: @lisp > (asdf:system-relative-pathname 'cl-ppcre "regex.data") #P"/repository/other/cl-ppcre/regex.data" @end lisp @end defun @defun system-source-directory system-designator ASDF does not provide a turnkey solution for locating data (or other miscellaneous) files that are distributed together with the source code of a system. Programmers can use @code{system-source-directory} to find such files. Returns a pathname object. The @var{system-designator} may be a string, symbol, or ASDF system object. @end defun @defun clear-system system-designator It is sometimes useful to force recompilation of a previously loaded system. For these cases, @code{(asdf:clear-system :foo)} will remove the system from the table of currently loaded systems: the next time the system @code{foo} or one that depends on it is re-loaded, @code{foo} will be loaded again.@footnote{Alternatively, you could touch @code{foo.asd} or remove the corresponding fasls from the output file cache.} Note that this does not and cannot undo the previous loading of the system. Common Lisp has no provision for such an operation, and its reliance on irreversible side-effects to global data structures makes such a thing impossible in the general case. If the software being re-loaded is not conceived with hot upgrade in mind, re-loading may cause many errors, warnings or subtle silent problems, as packages, generic function signatures, structures, types, macros, constants, etc. are being redefined incompatibly. It is up to the user to make sure that reloading is possible and has the desired effect. In some cases, extreme measures such as recursively deleting packages, unregistering symbols, defining methods on @code{update-instance-for-redefined-class} and much more are necessary for reloading to happen smoothly. ASDF itself goes to extensive effort to make a hot upgrade possible with respect to its own code. If you want, you can reuse some of its utilities such as @code{uiop:define-package} and @code{uiop:with-upgradability}, and get inspiration (or disinspiration) from what it does in @file{header.lisp} and @file{upgrade.lisp}. @end defun @defun register-preloaded-system name @Arest{} keys A system with name @var{name}, created by @code{make-instance} with extra keys @var{keys} (e.g. @code{:version}), is registered as @emph{preloaded}. That is, its code has already been loaded into the current image, and if at some point some other system @code{:depends-on} it yet no source code is found, it is considered as already provided, and ASDF will not raise a @code{missing-component} error. This function is particularly useful if you distribute your code as fasls with either @code{compile-bundle-op} or @code{monolithic-compile-bundle-op}, and want to register systems so that dependencies will work uniformly whether you're using your software from source or from fasl. @end defun @defun run-shell-command control-string @Arest{} args This function is obsolete and present only for the sake of backwards-compatibility: ``If it's not backwards, it's not compatible''. We @emph{strongly} discourage its use. Its current behavior is only well-defined on Unix platforms (which include MacOS X and cygwin). On Windows, anything goes. The following documentation is only for the purpose of your migrating away from it in a way that preserves semantics. Instead we recommend the use @code{run-program}, described in the next section, and available as part of ASDF since ASDF 3. @code{run-shell-command} takes as arguments a format @code{control-string} and arguments to be passed to @code{format} after this control-string to produce a string. This string is a command that will be evaluated with a POSIX shell if possible; yet, on Windows, some implementations will use CMD.EXE, while others (like SBCL) will make an attempt at invoking a POSIX shell (and fail if it is not present). @end defun @node Some Utility Functions, , Controlling source file character encoding, Miscellaneous additional functionality @section Some Utility Functions The below functions are not exported by ASDF itself, but by UIOP, available since ASDF 3. Some of them have precursors in ASDF 2, but we recommend you rely on ASDF 3 for active developments. UIOP provides many, many more utility functions, and we recommend you read its README and sources for more information. @defun parse-unix-namestring name @Akey{} type defaults dot-dot ensure-directory @AallowOtherKeys Coerce NAME into a PATHNAME using standard Unix syntax. Unix syntax is used whether or not the underlying system is Unix; on non-Unix systems it is only usable for relative pathnames. In order to manipulate relative pathnames portably, it is crucial to possess a portable pathname syntax independent of the underlying OS. This is what @code{parse-unix-namestring} provides, and why we use it in ASDF. When given a @code{pathname} object, just return it untouched. When given @code{nil}, just return @code{nil}. When given a non-null @code{symbol}, first downcase its name and treat it as a string. When given a @code{string}, portably decompose it into a pathname as below. @code{#\/} separates directory components. The last @code{#\/}-separated substring is interpreted as follows: 1- If @var{type} is @code{:directory} or @var{ensure-directory} is true, the string is made the last directory component, and its @code{name} and @code{type} are @code{nil}. if the string is empty, it's the empty pathname with all slots @code{nil}. 2- If @var{type} is @code{nil}, the substring is a file-namestring, and its @code{name} and @code{type} are separated by @code{split-name-type}. 3- If @var{type} is a string, it is the given @code{type}, and the whole string is the @code{name}. Directory components with an empty name the name @code{.} are removed. Any directory named @code{..} is read as @var{dot-dot}, which must be one of @code{:back} or @code{:up} and defaults to @code{:back}. @vindex *nil-pathname* @code{host}, @code{device} and @code{version} components are taken from @var{defaults}, which itself defaults to @code{*nil-pathname*}. @code{*nil-pathname*} is also used if @var{defaults} is @code{nil}. No host or device can be specified in the string itself, which makes it unsuitable for absolute pathnames outside Unix. For relative pathnames, these components (and hence the defaults) won't matter if you use @code{merge-pathnames*} but will matter if you use @code{merge-pathnames}, which is an important reason to always use @code{merge-pathnames*}. Arbitrary keys are accepted, and the parse result is passed to @code{ensure-pathname} with those keys, removing @var{type}, @var{defaults} and @var{dot-dot}. When you're manipulating pathnames that are supposed to make sense portably even though the OS may not be Unixish, we recommend you use @code{:want-relative t} so that @code{parse-unix-namestring} will throw an error if the pathname is absolute. @end defun @defun merge-pathnames* specified @Aoptional{} defaults This function is a replacement for @code{merge-pathnames} that uses the host and device from the @var{defaults} rather than the @var{specified} pathname when the latter is a relative pathname. This allows ASDF and its users to create and use relative pathnames without having to know beforehand what are the host and device of the absolute pathnames they are relative to. @end defun @defun subpathname pathname subpath @Akey{} type This function takes a @var{pathname} and a @var{subpath} and a @var{type}. If @var{subpath} is already a @code{pathname} object (not namestring), and is an absolute pathname at that, it is returned unchanged; otherwise, @var{subpath} is turned into a relative pathname with given @var{type} as per @code{parse-unix-namestring} with @code{:want-relative t :type }@var{type}, then it is merged with the @code{pathname-directory-pathname} of @var{pathname}, as per @code{merge-pathnames*}. We strongly encourage the use of this function for portably resolving relative pathnames in your code base. @end defun @defun subpathname* pathname subpath @Akey{} type This function returns @code{nil} if the base @var{pathname} is @code{nil}, otherwise acts like @code{subpathname}. @end defun @defun run-program command @Akey{} ignore-error-status force-shell input output @ error-output if-input-does-not-exist if-output-exists if-error-output-exists @ element-type external-format @AallowOtherKeys @code{run-program} takes a @var{command} argument that is either a list of a program name or path and its arguments, or a string to be executed by a shell. It spawns the command, waits for it to return, verifies that it exited cleanly (unless told not too below), and optionally captures and processes its output. It accepts many keyword arguments to configure its behavior. @code{run-program} returns three values: the first for the output, the second for the error-output, and the third for the return value. (Beware that before ASDF 3.0.2.11, it didn't handle input or error-output, and returned only one value, the one for the output if any handler was specified, or else the exit code; please upgrade ASDF, or at least UIOP, to rely on the new enhanced behavior.) @var{output} is its most important argument; it specifies how the output is captured and processed. If it is @code{nil}, then the output is redirected to the null device, that will discard it. If it is @code{:interactive}, then it is inherited from the current process (beware: this may be different from your @var{*standard-output*}, and under SLIME will be on your @code{*inferior-lisp*} buffer). If it is @code{t}, output goes to your current @var{*standard-output*} stream. Otherwise, @var{output} should be a value that is a suitable first argument to @code{slurp-input-stream} (see below), or a list of such a value and keyword arguments. In this case, @code{run-program} will create a temporary stream for the program output; the program output, in that stream, will be processed by a call to @code{slurp-input-stream}, using @var{output} as the first argument (or if it's a list the first element of @var{output} and the rest as keywords). The primary value resulting from that call (or @code{nil} if no call was needed) will be the first value returned by @code{run-program}. E.g., using @code{:output :string} will have it return the entire output stream as a string. And using @code{:output '(:string :stripped t)} will have it return the same string stripped of any ending newline. @var{error-output} is similar to @var{output}, except that the resulting value is returned as the second value of @code{run-program}. @code{t} designates the @var{*error-output*}. Also @code{:output} means redirecting the error output to the output stream, in which case @code{nil} is returned. @var{input} is similar to @var{output}, except that @code{vomit-output-stream} is used, no value is returned, and @code{t} designates the @var{*standard-input*}. @code{element-type} and @code{external-format} are passed on to your Lisp implementation, when applicable, for creation of the output stream. One and only one of the stream slurping or vomiting may or may not happen in parallel in parallel with the subprocess, depending on options and implementation, and with priority being given to output processing. Other streams are completely produced or consumed before or after the subprocess is spawned, using temporary files. @code{force-shell} forces evaluation of the command through a shell, even if it was passed as a list rather than a string. If a shell is used, it is @file{/bin/sh} on Unix or @file{CMD.EXE} on Windows, except on implementations that (erroneously, IMNSHO) insist on consulting @code{$SHELL} like clisp. @code{ignore-error-status} causes @code{run-program} to not raise an error if the spawned program exits in error. Following POSIX convention, an error is anything but a normal exit with status code zero. By default, an error of type @code{subprocess-error} is raised in this case. @code{run-program} works on all platforms supported by ASDF, except Genera. See the source code for more documentation. @end defun @defun slurp-input-stream processor input-stream @Akey{} @code{slurp-input-stream} is a generic function of two arguments, a target object and an input stream, and accepting keyword arguments. Predefined methods based on the target object are as follows: @itemize @item If the object is a function, the function is called with the stream as argument. @item If the object is a cons, its first element is applied to its rest appended by a list of the input stream. @item If the object is an output stream, the contents of the input stream are copied to it. If the @var{linewise} keyword argument is provided, copying happens line by line, and an optional @var{prefix} is printed before each line. Otherwise, copying happen based on a buffer of size @var{buffer-size}, using the specified @var{element-type}. @item If the object is @code{'string} or @code{:string}, the content is captured into a string. Accepted keywords include the @var{element-type} and a flag @var{stripped}, which when true causes any single line ending to be removed as per @code{uiop:stripln}. @item If the object is @code{:lines}, the content is captured as a list of strings, one per line, without line ending. If the @var{count} keyword argument is provided, it is a maximum count of lines to be read. @item If the object is @code{:line}, the content is captured as with @code{:lines} above, and then its sub-object is extracted with the @var{at} argument, which defaults to @code{0}, extracting the first line. A number will extract the corresponding line. See the documentation for @code{uiop:access-at}. @item If the object is @code{:forms}, the content is captured as a list of S-expressions, as read by the Lisp reader. If the @var{count} argument is provided, it is a maximum count of lines to be read. We recommend you control the syntax with such macro as @code{uiop:with-safe-io-syntax}. @item If the object is @code{:form}, the content is captured as with @code{:forms} above, and then its sub-object is extracted with the @var{at} argument, which defaults to @code{0}, extracting the first form. A number will extract the corresponding form. See the documentation for @code{uiop:access-at}. We recommend you control the syntax with such macro as @code{uiop:with-safe-io-syntax}. @end itemize @end defun @node Getting the latest version, FAQ, Miscellaneous additional functionality, Top @comment node-name, next, previous, up @chapter Getting the latest version Decide which version you want. The @code{master} branch is where development happens; its @code{HEAD} is usually OK, including the latest fixes and portability tweaks, but an occasional regression may happen despite our (limited) test suite. The @code{release} branch is what cautious people should be using; it has usually been tested more, and releases are cut at a point where there isn't any known unresolved issue. You may get the ASDF source repository using git: @kbd{git clone git://common-lisp.net/projects/asdf/asdf.git} You will find the above referenced tags in this repository. You can also browse the repository on @url{http://common-lisp.net/gitweb?p=projects/asdf/asdf.git}. Discussion of ASDF development is conducted on the mailing list @kbd{asdf-devel@@common-lisp.net}. @url{http://common-lisp.net/cgi-bin/mailman/listinfo/asdf-devel} @node FAQ, Ongoing Work, Getting the latest version, Top @comment node-name, next, previous, up @chapter FAQ @menu * Where do I report a bug?:: * What has changed between ASDF 1 ASDF 2 and ASDF 3?:: * Issues with installing the proper version of ASDF:: * Issues with configuring ASDF:: * Issues with using and extending ASDF to define systems:: * ASDF development FAQs:: @end menu @node Where do I report a bug?, What has changed between ASDF 1 ASDF 2 and ASDF 3?, FAQ, FAQ @section ``Where do I report a bug?'' ASDF bugs are tracked on launchpad: @url{https://launchpad.net/asdf}. If you're unsure about whether something is a bug, or for general discussion, use the @url{http://common-lisp.net/cgi-bin/mailman/listinfo/asdf-devel,asdf-devel mailing list} @node What has changed between ASDF 1 ASDF 2 and ASDF 3?, Issues with installing the proper version of ASDF, Where do I report a bug?, FAQ @section ``What has changed between ASDF 1, ASDF 2, and ASDF 3?'' We released ASDF 2.000 on May 31st 2010, and ASDF 3.0.0 on May 15th 2013. Releases of ASDF 2 and later have since then been included in all actively maintained CL implementations that used to bundle ASDF 1, plus some implementations that previously did not. ASDF has been made to work with all actively maintained CL implementations and even a few implementations that are @emph{not} actively maintained. @xref{FAQ,,``What has changed between ASDF 1 and ASDF 2?''}. Furthermore, it is possible to upgrade from ASDF 1 to ASDF 2 or ASDF 3 on the fly (though we recommend instead upgrading your implementation or its ASDF module). For this reason, we have stopped supporting ASDF 1 and ASDF 2. If you are using ASDF 1 or ASDF 2 and are experiencing any kind of issues or limitations, we recommend you upgrade to ASDF 3 --- and we explain how to do that. @xref{Loading ASDF}. (In the context of compatibility requirements, ASDF 2.27, released on Feb 1st 2013, and further 2.x releases up to 2.33, count as pre-releases of ASDF 3, and define the @code{:asdf3} feature; still, please use the latest release). Release ASDF 3.1.2 and later also define the @code{:asdf3.1} feature. @menu * What are ASDF 1 2 3?:: * How do I detect the ASDF version?:: * ASDF can portably name files in subdirectories:: * Output translations:: * Source Registry Configuration:: * Usual operations are made easier to the user:: * Many bugs have been fixed:: * ASDF itself is versioned:: * ASDF can be upgraded:: * Decoupled release cycle:: * Pitfalls of the transition to ASDF 2:: * What happened to the bundle operations:: @end menu @node What are ASDF 1 2 3?, How do I detect the ASDF version?, What has changed between ASDF 1 ASDF 2 and ASDF 3?, What has changed between ASDF 1 ASDF 2 and ASDF 3? @subsection What are ASDF 1, ASDF 2, and ASDF 3? ASDF 1 refers to any release earlier than 1.369 or so (from August 2001 to October 2009), and to any development revision earlier than 2.000 (May 2010). If your copy of ASDF doesn't even contain version information, it's an old ASDF 1. Revisions between 1.656 and 1.728 may count as development releases for ASDF 2. ASDF 2 refers to releases from 2.000 (May 31st 2010) to 2.26 (Oct 30 2012), and any development revision newer than ASDF 1 and older than 2.27 (Feb 1 2013). ASDF 3 refers to releases from 2.27 (Feb 1 2013) to 2.33 and 3.0.0 onward (May 15 2013). 2.27 to 2.33 count as pre-releases to ASDF 3. @node How do I detect the ASDF version?, ASDF can portably name files in subdirectories, What are ASDF 1 2 3?, What has changed between ASDF 1 ASDF 2 and ASDF 3? @subsection How do I detect the ASDF version? @findex asdf-version @cindex *features* All releases of ASDF push @code{:asdf} onto @code{*features*}. Releases starting with ASDF 2 push @code{:asdf2} onto @code{*features*}. Releases starting with ASDF 3 (including 2.27 and later pre-releases) push @code{:asdf3} onto @code{*features*}. Furthermore, releases starting with ASDF 3.1.2 (May 2014), though they count as ASDF 3, include enough progress that they push @code{:asdf3.1} onto @code{*features*}. You may depend on the presence or absence of these features to write code that takes advantage of recent ASDF functionality but still works on older versions, or at least detects the old version and signals an error. Additionally, all releases starting with ASDF 2 define a function @code{(asdf:asdf-version)} you may use to query the version. All releases starting with 2.013 display the version number prominently on the second line of the @file{asdf.lisp} source file. If you are experiencing problems or limitations of any sort with ASDF 1 or ASDF 2, we recommend that you should upgrade to the latest release, be it ASDF 3 or other. @node ASDF can portably name files in subdirectories, Output translations, How do I detect the ASDF version?, What has changed between ASDF 1 ASDF 2 and ASDF 3? @subsection ASDF can portably name files in subdirectories Common Lisp namestrings are not portable, except maybe for logical pathname namestrings, that themselves have various limitations and require a lot of setup that is itself ultimately non-portable. In ASDF 1, the only portable ways to refer to pathnames inside systems and components were very awkward, using @code{#.(make-pathname ...)} and @code{#.(merge-pathnames ...)}. Even the above were themselves were inadequate in the general case due to host and device issues, unless horribly complex patterns were used. Plenty of simple cases that looked portable actually weren't, leading to much confusion and greavance. ASDF 2 implements its own portable syntax for strings as pathname specifiers. Naming files within a system definition becomes easy and portable again. @xref{Miscellaneous additional functionality,system-relative-pathname}, @code{merge-pathnames*}, @code{coerce-pathname}. On the other hand, there are places where systems used to accept namestrings where you must now use an explicit pathname object: @code{(defsystem ... :pathname "LOGICAL-HOST:PATH;TO;SYSTEM;" ...)} must now be written with the @code{#p} syntax: @code{(defsystem ... :pathname #p"LOGICAL-HOST:PATH;TO;SYSTEM;" ...)} @xref{The defsystem grammar,,Pathname specifiers}. @node Output translations, Source Registry Configuration, ASDF can portably name files in subdirectories, What has changed between ASDF 1 ASDF 2 and ASDF 3? @subsection Output translations A popular feature added to ASDF was output pathname translation: @code{asdf-binary-locations}, @code{common-lisp-controller}, @code{cl-launch} and other hacks were all implementing it in ways both mutually incompatible and difficult to configure. Output pathname translation is essential to share source directories of portable systems across multiple implementations or variants thereof, or source directories of shared installations of systems across multiple users, or combinations of the above. In ASDF 2, a standard mechanism is provided for that, @code{asdf-output-translations}, with sensible defaults, adequate configuration languages, a coherent set of configuration files and hooks, and support for non-Unix platforms. @xref{Controlling where ASDF saves compiled files}. @node Source Registry Configuration, Usual operations are made easier to the user, Output translations, What has changed between ASDF 1 ASDF 2 and ASDF 3? @subsection Source Registry Configuration Configuring ASDF used to require special magic to be applied just at the right moment, between the moment ASDF is loaded and the moment it is used, in a way that is specific to the user, the implementation he is using and the application he is building. This made for awkward configuration files and startup scripts that could not be shared between users, managed by administrators or packaged by distributions. ASDF 2 provides a well-documented way to configure ASDF, with sensible defaults, adequate configuration languages, and a coherent set of configuration files and hooks. We believe it's a vast improvement because it decouples application distribution from library distribution. The application writer can avoid thinking where the libraries are, and the library distributor (dpkg, clbuild, advanced user, etc.) can configure them once and for every application. Yet settings can be easily overridden where needed, so whoever needs control has exactly as much as required. At the same time, ASDF 2 remains compatible with the old magic you may have in your build scripts (using @code{*central-registry*} and @code{*system-definition-search-functions*}) to tailor the ASDF configuration to your build automation needs, and also allows for new magic, simpler and more powerful magic. @xref{Controlling where ASDF searches for systems}. @node Usual operations are made easier to the user, Many bugs have been fixed, Source Registry Configuration, What has changed between ASDF 1 ASDF 2 and ASDF 3? @subsection Usual operations are made easier to the user In ASDF 1, you had to use the awkward syntax @code{(asdf:oos 'asdf:load-op :foo)} to load a system, and similarly for @code{compile-op}, @code{test-op}. In ASDF 2, you can use shortcuts for the usual operations: @code{(asdf:load-system :foo)}, and similarly for @code{compile-system}, @code{test-system}. @node Many bugs have been fixed, ASDF itself is versioned, Usual operations are made easier to the user, What has changed between ASDF 1 ASDF 2 and ASDF 3? @subsection Many bugs have been fixed The following issues and many others have been fixed: @itemize @item The infamous TRAVERSE function has been revamped completely between ASDF 1 and ASDF 2, with many bugs squashed. In particular, dependencies were not correctly propagated across modules but now are. It has been completely rewritten many times over between ASDF 2.000 and ASDF 3, with fundamental issues in the original model being fixed. Timestamps were not propagated at all, and now are. The internal model of how actions depend on each other is now both consistent and complete. The @code{:version} and the @code{:force (system1 .. systemN)} feature have been fixed. @item Performance has been notably improved for large systems (say with thousands of components) by using hash-tables instead of linear search, and linear-time list accumulation instead of cubic time recursive append, for an overall @emph{O(n)} complexity vs @emph{O(n^4)}. @item Many features used to not be portable, especially where pathnames were involved. Windows support was notably quirky because of such non-portability. @item The internal test suite used to massively fail on many implementations. While still incomplete, it now fully passes on all implementations supported by the test suite, though some tests are commented out on a few implementations. @item Support was lacking for some implementations. ABCL and GCL were notably wholly broken. ECL extensions were not integrated with ASDF release. @item The documentation was grossly out of date. @end itemize @node ASDF itself is versioned, ASDF can be upgraded, Many bugs have been fixed, What has changed between ASDF 1 ASDF 2 and ASDF 3? @subsection ASDF itself is versioned Between new features, old bugs fixed, and new bugs introduced, there were various releases of ASDF in the wild, and no simple way to check which release had which feature set. People using or writing systems had to either make worst-case assumptions as to what features were available and worked, or take great pains to have the correct version of ASDF installed. With ASDF 2, we provide a new stable set of working features that everyone can rely on from now on. Use @code{#+asdf2} to detect presence of ASDF 2, @code{(asdf:version-satisfies (asdf:asdf-version) "2.345.67")} to check the availability of a version no earlier than required. @node ASDF can be upgraded, Decoupled release cycle, ASDF itself is versioned, What has changed between ASDF 1 ASDF 2 and ASDF 3? @subsection ASDF can be upgraded When an old version of ASDF was loaded, it was very hard to upgrade ASDF in your current image without breaking everything. Instead you had to exit the Lisp process and somehow arrange to start a new one from a simpler image. Something that can't be done from within Lisp, making automation of it difficult, which compounded with difficulty in configuration, made the task quite hard. Yet as we saw before, the task would have been required to not have to live with the worst case or non-portable subset of ASDF features. With ASDF 2, it is easy to upgrade from ASDF 2 to later versions from within Lisp, and not too hard to upgrade from ASDF 1 to ASDF 2 from within Lisp. We support hot upgrade of ASDF and any breakage is a bug that we will do our best to fix. There are still limitations on upgrade, though, most notably the fact that after you upgrade ASDF, you must also reload or upgrade all ASDF extensions. @node Decoupled release cycle, Pitfalls of the transition to ASDF 2, ASDF can be upgraded, What has changed between ASDF 1 ASDF 2 and ASDF 3? @subsection Decoupled release cycle When vendors were releasing their Lisp implementations with ASDF, they had to basically never change version because neither upgrade nor downgrade was possible without breaking something for someone, and no obvious upgrade path was visible and recommendable. With ASDF 2, upgrade is possible, easy and can be recommended. This means that vendors can safely ship a recent version of ASDF, confident that if a user isn't fully satisfied, he can easily upgrade ASDF and deal with a supported recent version of it. This means that release cycles will be causally decoupled, the practical consequence of which will mean faster convergence towards the latest version for everyone. @node Pitfalls of the transition to ASDF 2, What happened to the bundle operations, Decoupled release cycle, What has changed between ASDF 1 ASDF 2 and ASDF 3? @subsection Pitfalls of the transition to ASDF 2 The main pitfalls in upgrading to ASDF 2 seem to be related to the output translation mechanism. @itemize @item Output translations is enabled by default. This may surprise some users, most of them in pleasant way (we hope), a few of them in an unpleasant way. It is trivial to disable output translations. @xref{FAQ,,``How can I wholly disable the compiler output cache?''}. @item Some systems in the large have been known not to play well with output translations. They were relatively easy to fix. Once again, it is also easy to disable output translations, or to override its configuration. @item The new ASDF output translations are incompatible with ASDF-Binary-Locations. They replace A-B-L, and there is compatibility mode to emulate your previous A-B-L configuration. See @code{enable-asdf-binary-locations-compatibility} in @pxref{Controlling where ASDF saves compiled files,,Backward Compatibility}. But thou shalt not load ABL on top of ASDF 2. @end itemize Other issues include the following: @itemize @item ASDF pathname designators are now specified in places where they were unspecified, and a few small adjustments have to be made to some non-portable defsystems. Notably, in the @code{:pathname} argument to a @code{defsystem} and its components, a logical pathname (or implementation-dependent hierarchical pathname) must now be specified with @code{#p} syntax where the namestring might have previously sufficed; moreover when evaluation is desired @code{#.} must be used, where it wasn't necessary in the toplevel @code{:pathname} argument (but necessary in other @code{:pathname} arguments). @item There is a slight performance bug, notably on SBCL, when initially searching for @file{asd} files, the implicit @code{(directory "/configured/path/**/*.asd")} for every configured path @code{(:tree "/configured/path/")} in your @code{source-registry} configuration can cause a slight pause. Try to @code{(time (asdf:initialize-source-registry))} to see how bad it is or isn't on your system. If you insist on not having this pause, you can avoid the pause by overriding the default source-registry configuration and not use any deep @code{:tree} entry but only @code{:directory} entries or shallow @code{:tree} entries. Or you can fix your implementation to not be quite that slow when recursing through directories. @emph{Update}: This performance bug fixed the hard way in 2.010. @item On Windows, only LispWorks supports proper default configuration pathnames based on the Windows registry. Other implementations make do with environment variables, that you may have to define yourself if you're using an older version of Windows. Windows support is somewhat less tested than Unix support. Please help report and fix bugs. @emph{Update}: As of ASDF 2.21, all implementations should now use the same proper default configuration pathnames and they should actually work, though they haven't all been tested. @item The mechanism by which one customizes a system so that Lisp files may use a different extension from the default @file{.lisp} has changed. Previously, the pathname for a component was lazily computed when operating on a system, and you would @code{(defmethod source-file-type ((component cl-source-file) (system (eql (find-system 'foo)))) (declare (ignorable component system)) "lis")}. Now, the pathname for a component is eagerly computed when defining the system, and instead you will @code{(defclass cl-source-file.lis (cl-source-file) ((type :initform "lis")))} and use @code{:default-component-class cl-source-file.lis} as argument to @code{defsystem}, as detailed in a @pxref{FAQ,How do I create a system definition where all the source files have a .cl extension?} below. @findex source-file-type @end itemize @node What happened to the bundle operations, , Pitfalls of the transition to ASDF 2, What has changed between ASDF 1 ASDF 2 and ASDF 3? @subsection What happened to the bundle operations? @tindex fasl-op (obsolete) @tindex load-fasl-op (obsolete) @tindex binary-op (obsolete) @tindex monolithic-fasl-op (obsolete) @tindex monolithic-load-fasl-op (obsolete) @tindex monolithic-binary-op (obsolete) @tindex compile-bundle-op @tindex load-bundle-op @tindex deliver-asd-op @tindex monolithic-compile-bundle-op @tindex monolithic-load-bundle-op @tindex monolithic-deliver-asd-op Some of the bundle operations were renamed after ASDF 3.1.3, and the old names have been removed. Old bundle operations, and their modern equivalents are: @itemize @item @code{fasl-op} is now @code{compile-bundle-op} @item @code{load-fasl-op} is now @code{load-bundle-op} @item @code{binary-op} is now @code{deliver-asd-op} @item @code{monolithic-fasl-op} is now @code{monolithic-compile-bundle-op} @item @code{monolithic-load-fasl-op} is now @code{monolithic-load-bundle-op} @item @code{monolithic-binary-op} is now @code{monolithic-deliver-asd-op} @end itemize @node Issues with installing the proper version of ASDF, Issues with configuring ASDF, What has changed between ASDF 1 ASDF 2 and ASDF 3?, FAQ @section Issues with installing the proper version of ASDF @menu * My Common Lisp implementation comes with an outdated version of ASDF. What to do?:: * I'm a Common Lisp implementation vendor. When and how should I upgrade ASDF?:: @end menu @node My Common Lisp implementation comes with an outdated version of ASDF. What to do?, I'm a Common Lisp implementation vendor. When and how should I upgrade ASDF?, Issues with installing the proper version of ASDF, Issues with installing the proper version of ASDF @subsection ``My Common Lisp implementation comes with an outdated version of ASDF. What to do?'' We recommend you upgrade ASDF. @xref{Loading ASDF,,Upgrading ASDF}. If this does not work, it is a bug, and you should report it. @xref{FAQ, report-bugs, Where do I report a bug}. In the meantime, you can load @file{asdf.lisp} directly. @xref{Loading ASDF,Loading an otherwise installed ASDF}. @node I'm a Common Lisp implementation vendor. When and how should I upgrade ASDF?, , My Common Lisp implementation comes with an outdated version of ASDF. What to do?, Issues with installing the proper version of ASDF @subsection ``I'm a Common Lisp implementation vendor. When and how should I upgrade ASDF?'' Since ASDF 2, it should always be a good time to upgrade to a recent version of ASDF. You may consult with the maintainer for which specific version they recommend, but the latest @code{release} should be correct. Though we do try to test ASDF releases against all implementations that we can, we may not be testing against all variants of your implementation, and we may not be running enough tests; we trust you to thoroughly test it with your own implementation before you release it. If there are any issues with the current release, it's a bug that you should report upstream and that we will fix ASAP. As to how to include ASDF, we recommend the following: @itemize @item If ASDF isn't loaded yet, then @code{(require "asdf")} should load the version of ASDF that is bundled with your system. If possible so should @code{(require "ASDF")}. You may have it load some other version configured by the user, if you allow such configuration. @item If your system provides a mechanism to hook into @code{CL:REQUIRE}, then it would be nice to add ASDF to this hook the same way that ABCL, CCL, CLISP, CMUCL, ECL, SBCL and SCL do it. Please send us appropriate code to this end. @item You may, like SBCL since 1.1.13 or MKCL since 1.1.9, have ASDF create bundle FASLs that are provided as modules by your Lisp distribution. You may also, but we don't recommend that anymore, have ASDF like SBCL up until 1.1.12 be implicitly used when requiring modules that are provided by your Lisp distribution; if you do, you should add them in the beginning of both @code{wrapping-source-registry} and @code{wrapping-output-translations}. @item If you have magic systems as above, like SBCL used to do, then we explicitly ask you to @emph{NOT} distribute @file{asdf.asd} as part of those magic systems. You should still include the file @file{asdf.lisp} in your source distribution and precompile it in your binary distribution, but @file{asdf.asd} if included at all, should be secluded from the magic systems, in a separate file hierarchy. Alternatively, you may provide the system after renaming it and its @file{.asd} file to e.g. @code{asdf-ecl} and @file{asdf-ecl.asd}, or @code{sb-asdf} and @file{sb-asdf.asd}. Indeed, if you made @file{asdf.asd} a magic system, then users would no longer be able to upgrade ASDF using ASDF itself to some version of their preference that they maintain independently from your Lisp distribution. @item If you do not have any such magic systems, or have other non-magic systems that you want to bundle with your implementation, then you may add them to the @code{wrapping-source-registry}, and you are welcome to include @file{asdf.asd} amongst them. Non-magic systems should be at the back of the @code{wrapping-source-registry} while magic systems are at the front. If they are precompiled, they should also be in the @code{wrapping-output-translations}. @item Since ASDF 3, the library UIOP comes transcluded in ASDF. But if you want to be nice to users who care for UIOP but not for ASDF, you may package UIOP separately, so that one may @code{(require "uiop")} and not load ASDF, or one may @code{(require "asdf")} which would implicitly require and load the former. @item Please send us upstream any patches you make to ASDF itself, so we can merge them back in for the benefit of your users when they upgrade to the upstream version. @end itemize @node Issues with configuring ASDF, Issues with using and extending ASDF to define systems, Issues with installing the proper version of ASDF, FAQ @section Issues with configuring ASDF @menu * How can I customize where fasl files are stored?:: * How can I wholly disable the compiler output cache?:: @end menu @node How can I customize where fasl files are stored?, How can I wholly disable the compiler output cache?, Issues with configuring ASDF, Issues with configuring ASDF @subsection ``How can I customize where fasl files are stored?'' @xref{Controlling where ASDF saves compiled files}. Note that in the past there was an add-on to ASDF called @code{ASDF-binary-locations}, developed by Gary King. That add-on has been merged into ASDF proper, then superseded by the @code{asdf-output-translations} facility. Note that use of @code{asdf-output-translations} can interfere with one aspect of your systems --- if your system uses @code{*load-truename*} to find files (e.g., if you have some data files stored with your program), then the relocation that this ASDF customization performs is likely to interfere. Use @code{asdf:system-relative-pathname} to locate a file in the source directory of some system, and use @code{asdf:apply-output-translations} to locate a file whose pathname has been translated by the facility. @node How can I wholly disable the compiler output cache?, , How can I customize where fasl files are stored?, Issues with configuring ASDF @subsection ``How can I wholly disable the compiler output cache?'' To permanently disable the compiler output cache for all future runs of ASDF, you can: @example mkdir -p ~/.config/common-lisp/asdf-output-translations.conf.d/ echo ':disable-cache' > ~/.config/common-lisp/asdf-output-translations.conf.d/99-disable-cache.conf @end example This assumes that you didn't otherwise configure the ASDF files (if you did, edit them again), and don't somehow override the configuration at runtime with a shell variable (see below) or some other runtime command (e.g. some call to @code{asdf:initialize-output-translations}). To disable the compiler output cache in Lisp processes run by your current shell, try (assuming @code{bash} or @code{zsh}) (on Unix and cygwin only): @example export ASDF_OUTPUT_TRANSLATIONS=/: @end example To disable the compiler output cache just in the current Lisp process, use (after loading ASDF but before using it): @example (asdf:disable-output-translations) @end example Note that this does @emph{NOT} belong in a @file{.asd} file. Please do not tamper with ASDF configuration from a @file{.asd} file, and only do this from your personal configuration or build scripts. @node Issues with using and extending ASDF to define systems, ASDF development FAQs, Issues with configuring ASDF, FAQ @section Issues with using and extending ASDF to define systems @menu * How can I cater for unit-testing in my system?:: * How can I cater for documentation generation in my system?:: * How can I maintain non-Lisp (e.g. C) source files?:: * I want to put my module's files at the top level. How do I do this?:: * How do I create a system definition where all the source files have a .cl extension?:: * How do I mark a source file to be loaded only and not compiled?:: * How do I work with readtables?:: @end menu @node How can I cater for unit-testing in my system?, How can I cater for documentation generation in my system?, Issues with using and extending ASDF to define systems, Issues with using and extending ASDF to define systems @subsection ``How can I cater for unit-testing in my system?'' ASDF provides a predefined test operation, @code{test-op}. @xref{Predefined operations of ASDF, test-op}. The test operation, however, is largely left to the system definer to specify. @code{test-op} has been a topic of considerable discussion on the @url{http://common-lisp.net/cgi-bin/mailman/listinfo/asdf-devel,asdf-devel mailing list}, and on the @url{https://launchpad.net/asdf,launchpad bug-tracker}. We provide some guidelines in the discussion of @code{test-op}. @c cut the following because it's discussed in the discussion of test-op. @c Here are some guidelines: @c @itemize @c @item @c For a given system, @var{foo}, you will want to define a corresponding @c test system, such as @var{foo-test}. The reason that you will want this @c separate system is that ASDF does not out of the box supply components @c that are conditionally loaded. So if you want to have source files @c (with the test definitions) that will not be loaded except when testing, @c they should be put elsewhere. @c @item @c The @var{foo-test} system can be defined in an asd file of its own or @c together with @var{foo}. An aesthetic preference against cluttering up @c the filesystem with extra asd files should be balanced against the @c question of whether one might want to directly load @var{foo-test}. @c Typically one would not want to do this except in early stages of @c debugging. @c @item @c Record that testing is implemented by @var{foo-test}. For example: @c @example @c (defsystem @var{foo} @c :in-order-to ((test-op (test-op @var{foo-test}))) @c ....) @c (defsystem @var{foo-test} @c :depends-on (@var{foo} @var{my-test-library} ...) @c ....) @c @end example @c @end itemize @c This procedure will allow you to support users who do not wish to @c install your test framework. @c One oddity of ASDF is that @code{operate} (@pxref{Operations,operate}) @c does not return a value. So in current versions of ASDF there is no @c reliable programmatic means of determining whether or not a set of tests @c has passed, or which tests have failed. The user must simply read the @c console output. This limitation has been the subject of much @c discussion. @node How can I cater for documentation generation in my system?, How can I maintain non-Lisp (e.g. C) source files?, How can I cater for unit-testing in my system?, Issues with using and extending ASDF to define systems @subsection ``How can I cater for documentation generation in my system?'' Various ASDF extensions provide some kind of @code{doc-op} operation. See also @url{https://bugs.launchpad.net/asdf/+bug/479470}. @node How can I maintain non-Lisp (e.g. C) source files?, I want to put my module's files at the top level. How do I do this?, How can I cater for documentation generation in my system?, Issues with using and extending ASDF to define systems @subsection ``How can I maintain non-Lisp (e.g. C) source files?'' See @code{cffi}'s @code{cffi-grovel}. @anchor{report-bugs} @node I want to put my module's files at the top level. How do I do this?, How do I create a system definition where all the source files have a .cl extension?, How can I maintain non-Lisp (e.g. C) source files?, Issues with using and extending ASDF to define systems @subsection ``I want to put my module's files at the top level. How do I do this?'' By default, the files contained in an asdf module go in a subdirectory with the same name as the module. However, this can be overridden by adding a @code{:pathname ""} argument to the module description. For example, here is how it could be done in the spatial-trees ASDF system definition for ASDF 2: @example (asdf:defsystem :spatial-trees :components ((:module base :pathname "" :components ((:file "package") (:file "basedefs" :depends-on ("package")) (:file "rectangles" :depends-on ("package")))) (:module tree-impls :depends-on (base) :pathname "" :components ((:file "r-trees") (:file "greene-trees" :depends-on ("r-trees")) (:file "rstar-trees" :depends-on ("r-trees")) (:file "rplus-trees" :depends-on ("r-trees")) (:file "x-trees" :depends-on ("r-trees" "rstar-trees")))) (:module viz :depends-on (base) :pathname "" :components ((:static-file "spatial-tree-viz.lisp"))) (:module tests :depends-on (base) :pathname "" :components ((:static-file "spatial-tree-test.lisp"))) (:static-file "LICENCE") (:static-file "TODO"))) @end example All of the files in the @code{tree-impls} module are at the top level, instead of in a @file{tree-impls/} subdirectory. Note that the argument to @code{:pathname} can be either a pathname object or a string. A pathname object can be constructed with the @file{#p"foo/bar/"} syntax, but this is discouraged because the results of parsing a namestring are not portable. A pathname can only be portably constructed with such syntax as @code{#.(make-pathname :directory '(:relative "foo" "bar"))}, and similarly the current directory can only be portably specified as @code{#.(make-pathname :directory '(:relative))}. However, as of ASDF 2, you can portably use a string to denote a pathname. The string will be parsed as a @code{/}-separated path from the current directory, such that the empty string @code{""} denotes the current directory, and @code{"foo/bar"} (no trailing @code{/} required in the case of modules) portably denotes the same subdirectory as above. When files are specified, the last @code{/}-separated component is interpreted either as the name component of a pathname (if the component class specifies a pathname type), or as a name component plus optional dot-separated type component (if the component class doesn't specifies a pathname type). @node How do I create a system definition where all the source files have a .cl extension?, How do I mark a source file to be loaded only and not compiled?, I want to put my module's files at the top level. How do I do this?, Issues with using and extending ASDF to define systems @subsection How do I create a system definition where all the source files have a .cl extension? Starting with ASDF 2.014.14, you may just pass the builtin class @code{cl-source-file.cl} as the @code{:default-component-class} argument to @code{defsystem}: @lisp (defsystem my-cl-system :default-component-class cl-source-file.cl ...) @end lisp Another builtin class @code{cl-source-file.lsp} is offered for files ending in @file{.lsp}. If you want to use a different extension for which ASDF doesn't provide builtin support, or want to support versions of ASDF earlier than 2.014.14 (but later than 2.000), you can define a class as follows: @lisp ;; Prologue: make sure we're using a sane package. (defpackage :my-asdf-extension (:use :asdf :common-lisp) (:export #:cl-source-file.lis)) (in-package :my-asdf-extension) (defclass cl-source-file.lis (cl-source-file) ((type :initform "lis"))) @end lisp Then you can use it as follows: @lisp (defsystem my-cl-system :default-component-class my-asdf-extension:cl-source-file.lis ...) @end lisp Of course, if you're in the same package, e.g. in the same file, you won't need to use the package qualifier before @code{cl-source-file.lis}. Actually, if all you're doing is defining this class and using it in the same file without other fancy definitions, you might skip package complications: @lisp (in-package :asdf) (defclass cl-source-file.lis (cl-source-file) ((type :initform "lis"))) (defsystem my-cl-system :default-component-class cl-source-file.lis ...) @end lisp It is possible to achieve the same effect in a way that supports both ASDF 1 and ASDF 2, but really, friends don't let friends use ASDF 1. Please upgrade to ASDF 3. In short, though: do same as above, but @emph{before} you use the class in a @code{defsystem}, you also define the following method: @lisp (defmethod source-file-type ((f cl-source-file.lis) (s system)) (declare (ignorable f s)) "lis") @end lisp @node How do I mark a source file to be loaded only and not compiled?, How do I work with readtables?, How do I create a system definition where all the source files have a .cl extension?, Issues with using and extending ASDF to define systems @subsection How do I mark a source file to be loaded only and not compiled? There is no provision in ASDF for ensuring that some components are always loaded as source, while others are always compiled. There is @code{load-source-op} (@pxref{Predefined operations of ASDF,load-source-op}), but that is an operation to be applied to a system as a whole, not to one or another specific source files. While this idea often comes up in discussions, it doesn't play well with either the linking model of ECL or with various bundle operations. In addition, the dependency model of ASDF would have to be modified incompatibly to allow for such a trick. @c If your code doesn't compile cleanly, fix it. @c If compilation makes it slow, use @code{declaim} or @code{eval-when} @c to adjust your compiler settings, @c or eschew compilation by @code{eval}uating a quoted source form at load-time. @node How do I work with readtables?, , How do I mark a source file to be loaded only and not compiled?, Issues with using and extending ASDF to define systems @subsection How do I work with readtables? @cindex readtables It is possible to configure the lisp syntax by modifying the currently-active readtable. However, this same readtable is shared globally by all software being compiled by ASDF, especially since @code{load} and @code{compile-file} both bind @var{*readtable*}, so that its value is the same across the build at the start of every file (unless overridden by some @code{perform :around} method), even if a file locally binds it to a different readtable during the build. Therefore, the following hygiene restrictions apply. If you don't abide by these restrictions, there will be situations where your output files will be corrupted during an incremental build. We are not trying to prescribe new restrictions for the sake of good style: these restrictions have always applied implicitly, and we are simply describing what they have always been. @itemize @item It is forbidden to modifying any standard character or standard macro dispatch defined in the CLHS. @item No two dependencies may assign different meanings to the same non-standard character. @item Using any non-standard character while expecting the implementation to treat some way counts as such an assignment of meaning. @item libraries need to document these assignments of meaning to non-standard characters. @item free software libraries will register these changes on: @url{http://www.cliki.net/Macro%20Characters} @end itemize If you want to use readtable modifications that cannot abide by those restrictions, you @emph{must} create a different readtable object and set @var{*readtable*} to temporarily bind it to your new readtable (which will be undone after processing the file). For that, we recommend you use system @code{named-readtables} to define or combine such readtables using @code{named-readtables:defreadtable} and use them using @code{named-readtables:in-readtable}. Equivalently, you can use system @code{cl-syntax}, that itself uses @code{named-readtables}, but may someday do more with, e.g. @var{*print-pprint-dispatch*}. For even more advanced syntax modification beyond what a readtable can express, you may consider either: @itemize @item a @code{perform} method that compiles a constant file that contains a single form @code{#.*code-read-with-alternate-reader*} in an environment where this special variable was bound to the code read by your alternate reader, or @item using the system @code{reader-interception}. @end itemize Beware that @c unless and until the @code{syntax-control} branch is merged, it is unsafe to use ASDF from the REPL to compile or load systems while the readtable isn't the shared readtable previously used to build software. You @emph{must} manually undo any binding of @var{*readtable*} at the REPL and restore its initial value whenever you call @code{operate} (via e.g. @code{load-system}, @code{test-system} or @code{require}) from a REPL that is using a different readtable. @subsubsection How should my system use a readtable exported by another system? Use from the @code{named-readtables} system the macro @code{named-readtables:in-readtable}. If the other system fails to use @code{named-readtables}, fix it and send a patch upstream. In the day and age of Quicklisp and clbuild, there is little reason to eschew using such an important library anymore. @subsubsection How should my library make a readtable available to other systems? Use from the @code{named-readtables} system the macro @code{named-readtables:defreadtable}. @node ASDF development FAQs, , Issues with using and extending ASDF to define systems, FAQ @section ASDF development FAQs @menu * How do run the tests interactively in a REPL?:: @end menu @node How do run the tests interactively in a REPL?, , ASDF development FAQs, ASDF development FAQs @subsection How do run the tests interactively in a REPL? This not-so-frequently asked question is primarily for ASDF developers, but those who encounter an unexpected error in some test may be interested, too. Here's the procedure for experimenting with tests in a REPL: @example ;; BEWARE! Some tests expect you to be in the .../asdf/test directory ;; If your REPL is not there yet, change your current directory: ;; under SLIME, you may: ,change-directory ~/common-lisp/asdf/test/ ;; otherwise you may evaluate something like: (require "asdf") (asdf:upgrade-asdf) ;load UIOP & update asdf.lisp (uiop:chdir (asdf:system-relative-pathname :asdf "test/")) (setf *default-pathname-defaults* (uiop:getcwd)) ;; Load the test script support. (load "script-support.lisp") ;; Initialize the script support. ;; This will also change your *package* to asdf-test. ;; NB: this function is also available from package cl-user, ;; and also available with the shorter name da in both packages. (asdf-test::debug-asdf) ;; In case you modified ASDF since you last tested it, ;; you need to update asdf.lisp itself by evaluating 'make' in a shell, ;; or (require "asdf") (asdf:load-system :asdf) in another CL REPL, ;; if not done in this REPL above. ;; *Then*, in this REPL, you need to evaluate: ;(asdf-test::compile-load-asdf) ;; Now, you may experiment with test code from a .script file. ;; See the instructions given at the end of your failing test ;; to identify which form is needed, e.g. (frob-packages) (asdf::with-asdf-cache () (load "test-utilities.script")) @end example @comment FIXME: Add a FAQ about how to use a new system class... @comment node-name, next, previous, up @node Ongoing Work, Bibliography, FAQ, Top @unnumbered Ongoing Work For an active list of things to be done, see the @file{TODO} file in the source repository. Also, bugs are now tracked on launchpad: @url{https://launchpad.net/asdf}. @node Bibliography, Concept Index, Ongoing Work, Top @unnumbered Bibliography @itemize @item Francois-Rene Rideau: ``ASDF 3, or Why Lisp is Now an Acceptable Scripting Language'', 2014. This article describes the innovations in ASDF 3 and 3.1, as well as historical information on previous versions. @url{http://github.com/fare/asdf3-2013} @item Alastair Bridgewater: ``Quick-build'' (private communication), 2012. @code{quick-build} is a simple and robust one file, one package build system, similar to @code{faslpath}, in 182 lines of code (117 of which are not blank, not comments, not docstrings). Unhappily, it remains unpublished and its IP status is unclear as of April 2014. @code{asdf/package-system} is mostly compatible with it, modulo a different setup for toplevel hierarchies. @item Zach Beane: ``Quicklisp'', 2011. The Quicklisp blog and Xach's livejournal contain information on Quicklisp. @url{http://blog.quicklisp.org/} @url{http://xach.livejournal.com/} @item Francois-Rene Rideau and Robert Goldman: ``Evolving ASDF: More Cooperation, Less Coordination'', 2010. This article describes the main issues solved by ASDF 2. @url{http://common-lisp.net/project/asdf/doc/ilc2010draft.pdf} @url{http://www.common-lisp.org/gitweb?p=projects/asdf/ilc2010.git} @item Francois-Rene Rideau and Spencer Brody: ``XCVB: an eXtensible Component Verifier and Builder for Common Lisp'', 2009. This article describes XCVB, a proposed competitor for ASDF, many ideas of which have been incorporated into ASDF 2 and 3, though many other of which still haven't. @url{http://common-lisp.net/projects/xcvb/} @item Peter von Etter: ``faslpath'', 2009. @code{faslpath} is similar to the latter @code{quick-build} and our letter @code{asdf/package-system} extension, except that it uses the dot @code{.} rather than the slash @code{/} as a separator. @url{https://code.google.com/p/faslpath/} @item Drew McDermott: ``A Framework for Maintaining the Coherence of a Running Lisp,'' International Lisp Conference, 2005, available in pre-print form at @url{http://www.cs.yale.edu/homes/dvm/papers/lisp05.pdf} @item Dan Barlow: ``ASDF Manual'', 2004. Older versions of this document from the days of ASDF 1; they include ideas laid down by Dan Barlow, and comparisons with older defsystems (@code{mk-defsystem}) and defsystem (@code{defsystem-4}, kmp's Memo 801). @item Marco Antoniotti and Peter Van Eynde: ``@code{DEFSYSTEM}: A @code{make} for Common Lisp, A Thoughtful Re-Implementation of an Old Idea'', 2002. The @file{defsystem-4} proposal available in the CLOCC repository. @item Mark Kantrovitz: ``Defsystem: A Portable Make Facility for Common Lisp'', 1990. The classic @file{mk-defsystem}, later variants of which are available in the CLOCC repository as @code{defsystem-3.x}. @item Richard Elliot Robbins: ``BUILD: A Tool for Maintaining Consistency in Modular Systems'', MIT AI TR 874, 1985. @url{ftp://publications.ai.mit.edu/ai-publications/pdf/AITR-874.pdf} @item Kent M. Pitman (kmp): ``The Description of Large Systems'', MIT AI Memo 801, 1984. Available in updated-for-CL form on the web at @url{http://nhplace.com/kent/Papers/Large-Systems.html} @item Dan Weinreb and David Moon: ``Lisp Machine Manual'', MIT, 1981. The famous CHINE NUAL describes one of the earliest variants of DEFSYSTEM. @url{https://bitsavers.trailing-edge.com/pdf/mit/cadr/chinual_4thEd_Jul81.pdf} @end itemize @node Concept Index, Function and Class Index, Bibliography, Top @unnumbered Concept Index @printindex cp @node Function and Class Index, Variable Index, Concept Index, Top @unnumbered Function and Class Index @printindex fn @node Variable Index, , Function and Class Index, Top @unnumbered Variable Index @printindex vr @bye @c LocalWords: clbuild tarballs defsystem Quicklisp initarg uiop fasl @c LocalWords: namestring initargs fasls ecl-16.1.2/contrib/bytecmp/000077500000000000000000000000001266352375300154635ustar00rootroot00000000000000ecl-16.1.2/contrib/bytecmp/bytecmp.lsp000077500000000000000000000122651266352375300176570ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; Package: C -*- ;;;; ;;;; Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. ;;;; Copyright (c) 1990, Giuseppe Attardi. ;;;; Copyright (c) 2001, Juan Jose Garcia Ripoll ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. ;;;; BYTECMP Fake compiler which is used as a replacement when we do not ;;;; want or can have the real native compiler. (in-package "EXT") (defpackage "C" (:use "CL") (:export "*SUPPRESS-COMPILER-WARNINGS*" "*SUPPRESS-COMPILER-NOTES*")) (defun bc-disassemble (thing) (when (si::valid-function-name-p thing) (setq thing (fdefinition thing))) (cond ((null thing)) ((functionp thing) (si::bc-disassemble thing)) ((and (consp thing) (member (car thing) '(LAMBDA 'EXT:LAMBDA-BLOCK))) (disassemble (compile nil thing))) (t (error 'simple-type-error :datum thing :expected-type '(OR FUNCTION (SATISFIES SI:VALID-FUNCTION-NAME-P)) :format-control "DISASSEMBLE cannot accept ~A" :format-arguments (list thing)))) nil) (defun bc-compile (name &optional (def nil supplied-p) &aux form) (cond ((and supplied-p def) (when (functionp def) (unless (function-lambda-expression def) (return-from bc-compile (values def nil nil))) (setf def (function-lambda-expression def))) (setq form (if name `(progn (setf (symbol-function ',name) #',def) ',name) `(setq GAZONK #',def)))) ((not (fboundp name)) (error "Symbol ~s is unbound." name)) ((typep (setf def (symbol-function name)) 'standard-generic-function) (warn "COMPILE can not compile generic functions yet") (return-from bc-compile (values def t nil))) ((null (setq form (function-lambda-expression def))) (warn "We have lost the original function definition for ~s. Compilation failed" name) (return-from bc-compile (values def t nil))) (t (setq form `(progn (setf (symbol-function ',name) #',form) ',name)))) (values (eval form) nil nil)) (defun bc-compile-file-pathname (name &key (output-file name) (type :fasl) verbose print c-file h-file data-file shared-data-file system-p load external-format) (declare (ignore load c-file h-file data-file shared-data-file system-p verbose print)) (let ((extension "fasc")) (case type ((:fasl :fas) (setf extension "fasc")) (t (error "In COMPILE-FILE-PATHNAME, the type ~A is unsupported." type))) (make-pathname :type extension :defaults output-file))) (defun bc-compile-file (input &key ((:verbose *compile-verbose*) *compile-verbose*) ((:print *compile-print*) *compile-print*) (load nil) (external-format :default) (output-file nil output-file-p) &allow-other-keys &aux foo) (setf output-file (if output-file-p (pathname output-file) (bc-compile-file-pathname input))) (when *compile-verbose* (format t "~&;;; Compiling ~A" input)) (cond ((not (streamp input)) (let* ((ext:*source-location* (cons (truename input) 0)) (*compile-file-pathname* (pathname (merge-pathnames input))) (*compile-file-truename* (truename input))) (with-open-file (sin input :direction :input) (bc-compile-file sin :output-file output-file)))) ((not output-file-p) (error "COMPILE-FILE invoked with a stream input and no :OUTPUT-FILE")) (t (with-open-file (sout output-file :direction :output :if-exists :supersede :if-does-not-exist :create :external-format external-format) (let ((binary (loop with *package* = *package* with *readtable* = *readtable* with ext:*bytecodes-compiler* = t for position = (file-position input) for form = (read input nil :EOF) until (eq form :EOF) do (when ext::*source-location* (rplacd ext:*source-location* position)) collect (si:eval-with-env form nil nil nil nil)))) (sys:with-ecl-io-syntax (write binary :stream sout :circle t :escape t :readably t :pretty nil)) (terpri sout))))) (when load (load output-file :verbose *compile-verbose*)) (values output-file nil nil)) (defun install-bytecodes-compiler () (ext::package-lock (find-package :cl) nil) (pushnew :ecl-bytecmp *features*) (setf (fdefinition 'disassemble) #'bc-disassemble (fdefinition 'compile) #'bc-compile (fdefinition 'compile-file) #'bc-compile-file (fdefinition 'compile-file-pathname) #'bc-compile-file-pathname) (ext::package-lock (find-package :cl) t)) (defun install-c-compiler () (require :cmp) (locally (declare (notinline install-c-compiler)) (funcall 'install-c-compiler))) #-ecl-min (progn #+(and dlopen (not windows)) (sys::autoload "SYS:cmp" 'compile-file 'compile 'compile-file-pathname 'disassemble) #-(and dlopen (not windows)) (install-bytecodes-compiler) ) (provide '#:BYTECMP) #-ecl-min (package-lock "COMMON-LISP" t) ecl-16.1.2/contrib/cl-simd/000077500000000000000000000000001266352375300153505ustar00rootroot00000000000000ecl-16.1.2/contrib/cl-simd/LICENSE000066400000000000000000000022721266352375300163600ustar00rootroot00000000000000(This is the MIT / X Consortium license as taken from http://www.opensource.org/licenses/mit-license.html on or about Monday; July 13, 2009) Copyright (c) 2010 by Alexander Gavrilov Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ecl-16.1.2/contrib/cl-simd/README000066400000000000000000000005601266352375300162310ustar00rootroot00000000000000This module implements SSE intrinsic functions for ECL and SBCL. NOTE: CURRENTLY THIS SHOULD BE CONSIDERED EXPERIMENTAL, AND SUBJECT TO INCOMPATIBLE CHANGES IN A FUTURE RELEASE. Since the implementation is closely tied to the internals of the compiler, it should normally be obtained exclusively via the bundled contrib mechanism of the above implementations. ecl-16.1.2/contrib/cl-simd/cl-simd.asd000066400000000000000000000030201266352375300173640ustar00rootroot00000000000000;;; -*- mode: Lisp; indent-tabs-mode: nil; -*- ;;; ;;; Copyright (C) 2010, Alexander Gavrilov (angavrilov@gmail.com) ;;; ;;; This file defines the cl-simd ASDF system. ;;; ;;; Note that a completely independent definition ;;; is used to build the system as an ECL contrib. (defsystem :cl-simd :version "1.0" #+sb-building-contrib :pathname #+sb-building-contrib #p"SYS:CONTRIB;CL-SIMD;" :components #+(and sbcl sb-sse-intrinsics) ((:file "sse-package") (:file "sbcl-core" :depends-on ("sse-package")) (:file "sse-intrinsics" :depends-on ("sbcl-core")) (:file "sbcl-functions" :depends-on ("sse-intrinsics")) (:file "sbcl-arrays" :depends-on ("sbcl-functions")) (:file "sse-array-defs" :depends-on ("sbcl-arrays")) (:file "sse-utils" :depends-on ("sse-array-defs"))) #+(and ecl sse2) ((:file "sse-package") (:file "ecl-sse-core" :depends-on ("sse-package")) (:file "sse-intrinsics" :depends-on ("ecl-sse-core")) (:file "sse-array-defs" :depends-on ("sse-intrinsics")) (:file "ecl-sse-utils" :depends-on ("sse-intrinsics")) (:file "sse-utils" :depends-on ("ecl-sse-utils"))) #-(or (and sbcl sb-sse-intrinsics) (and ecl sse2)) ()) #+(or (and sbcl sb-sse-intrinsics) (and ecl sse2)) (defmethod perform :after ((o load-op) (c (eql (find-system :cl-simd)))) (provide :cl-simd)) (defmethod perform ((o test-op) (c (eql (find-system :cl-simd)))) #+(or (and sbcl sb-sse-intrinsics) (and ecl sse2)) (or (load (compile-file "test-sfmt.lisp")) (error "test-sfmt failed"))) ecl-16.1.2/contrib/cl-simd/cl-simd.texinfo000066400000000000000000000256621266352375300203110ustar00rootroot00000000000000@node cl-simd @section cl-simd @cindex SSE2 Intrinsics @cindex Intrinsics, SSE2 The @code{cl-simd} module provides access to SSE2 instructions (which are nowadays supported by any CPU compatible with x86-64) in the form of @emph{intrinsic functions}, similar to the way adopted by modern C compilers. It also provides some lisp-specific functionality, like setf-able intrinsics for accessing lisp arrays. When this module is loaded, it defines an @code{:sse2} feature, which can be subsequently used for conditional compilation of code that depends on it. Intrinsic functions are available from the @code{sse} package. This API, with minor technical differences, is supported by both ECL and SBCL (x86-64 only). @menu * SSE pack types:: * SSE array type:: * Differences from C intrinsics:: * Comparisons and NaN handling:: * Simple extensions:: * Lisp array accessors:: * Example:: @end menu @node SSE pack types @subsection SSE pack types The package defines and/or exports the following types to represent 128-bit SSE register contents: @anchor{Type sse:sse-pack} @deftp {Type} @somepkg{sse-pack,sse} @&optional item-type The generic SSE pack type. @end deftp @anchor{Type sse:int-sse-pack} @deftp {Type} @somepkg{int-sse-pack,sse} Same as @code{(sse-pack integer)}. @end deftp @anchor{Type sse:float-sse-pack} @deftp {Type} @somepkg{float-sse-pack,sse} Same as @code{(sse-pack single-float)}. @end deftp @anchor{Type sse:double-sse-pack} @deftp {Type} @somepkg{double-sse-pack,sse} Same as @code{(sse-pack double-float)}. @end deftp Declaring variable types using the subtype appropriate for your data is likely to lead to more efficient code (especially on ECL). However, the compiler implicitly casts between any subtypes of sse-pack when needed. Printed representation of SSE packs can be controlled by binding @code{*sse-pack-print-mode*}: @anchor{Variable sse:*sse-pack-print-mode*} @defvr {Variable} @somepkg{@earmuffs{sse-pack-print-mode},sse} When set to one of @code{:int}, @code{:float} or @code{:double}, specifies the way SSE packs are printed. A @code{NIL} value (default) instructs the implementation to make its best effort to guess from the data and context. @end defvr @node SSE array type @subsection SSE array type @anchor{Type sse:sse-array} @deftp {Type} @somepkg{sse-array,sse} element-type @&optional dimensions Expands to a lisp array type that is efficiently supported by AREF-like accessors. It should be assumed to be a subtype of @code{SIMPLE-ARRAY}. The type expander signals warnings or errors if it detects that the element-type argument value is inappropriate or unsafe. @end deftp @anchor{Function sse:make-sse-array} @deffn {Function} @somepkg{make-sse-array,sse} dimensions @&key element-type initial-element displaced-to displaced-index-offset Creates an object of type @code{sse-array}, or signals an error. In non-displaced case ensures alignment of the beginning of data to the 16-byte boundary. Unlike @code{make-array}, the element type defaults to (unsigned-byte 8). @end deffn On ECL this function supports full-featured displacement. On SBCL it has to simulate it by sharing the underlying data vector, and does not support nonzero index offset. @node Differences from C intrinsics @subsection Differences from C intrinsics Intel Compiler, GCC and @url{http://msdn.microsoft.com/en-us/library/y0dh78ez%28VS.80%29.aspx,MSVC} all support the same set of SSE intrinsics, originally designed by Intel. This package generally follows the naming scheme of the C version, with the following exceptions: @itemize @item Underscores are replaced with dashes, and the @code{_mm_} prefix is removed in favor of packages. @item The 'e' from @code{epi} is dropped because MMX is obsolete and won't be supported. @item @code{_si128} functions are renamed to @code{-pi} for uniformity and brevity. The author has personally found this discrepancy in the original C intrinsics naming highly jarring. @item Comparisons are named using graphic characters, e.g. @code{<=-ps} for @code{cmpleps}, or @code{/>-ps} for @code{cmpngtps}. In some places the set of comparison functions is extended to cover the full possible range. @item Scalar comparison predicates are named like @code{..-ss?} for @code{comiss}, and @code{..-ssu?} for @code{ucomiss} wrappers. @item Conversion functions are renamed to @code{convert-*-to-*} and @code{truncate-*-to-*}. @item A few functions are completely renamed: @code{cpu-mxcsr} (setf-able), @code{cpu-pause}, @code{cpu-load-fence}, @code{cpu-store-fence}, @code{cpu-memory-fence}, @code{cpu-clflush}, @code{cpu-prefetch-*}. @end itemize In addition, foreign pointer access intrinsics have an additional optional integer offset parameter to allow more efficient coding of pointer deference, and the most common ones have been renamed and made SETF-able: @itemize @item @code{mem-ref-ss}, @code{mem-ref-ps}, @code{mem-ref-aps} @item @code{mem-ref-sd}, @code{mem-ref-pd}, @code{mem-ref-apd} @item @code{mem-ref-pi}, @code{mem-ref-api}, @code{mem-ref-si64} @end itemize (The @code{-ap*} version requires alignment.) @node Comparisons and NaN handling @subsection Comparisons and NaN handling Floating-point arithmetic intrinsics have trivial IEEE semantics when given QNaN and SNaN arguments. Comparisons have more complex behavior, detailed in the following table: @multitable { @code{/>=-ss, />=-ps} } { @code{/>=-sd, />=-pd} } { Not greater or equal } { Result for NaN } { QNaN traps } @item Single-float @tab Double-float @tab Condition @tab Result for NaN @tab QNaN traps @item @code{=-ss}, @code{=-ps} @tab @code{=-sd}, @code{=-pd} @tab Equal @tab False @tab No @item @code{<-ss}, @code{<-ps} @tab @code{<-sd}, @code{<-pd} @tab Less @tab False @tab Yes @item @code{<=-ss}, @code{<=-ps} @tab @code{<=-sd}, @code{<=-pd} @tab Less or equal @tab False @tab Yes @item @code{>-ss}, @code{>-ps} @tab @code{>-sd}, @code{>-pd} @tab Greater @tab False @tab Yes @item @code{>=-ss}, @code{>=-ps} @tab @code{>=-sd}, @code{>=-pd} @tab Greater or equal @tab False @tab Yes @item @code{/=-ss}, @code{/=-ps} @tab @code{/=-sd}, @code{/=-pd} @tab Not equal @tab True @tab No @item @code{/<-ss}, @code{/<-ps} @tab @code{/<-sd}, @code{/<-pd} @tab Not less @tab True @tab Yes @item @code{/<=-ss}, @code{/<=-ps} @tab @code{/<=-sd}, @code{/<=-pd} @tab Not less or equal @tab True @tab Yes @item @code{/>-ss}, @code{/>-ps} @tab @code{/>-sd}, @code{/>-pd} @tab Not greater @tab True @tab Yes @item @code{/>=-ss}, @code{/>=-ps} @tab @code{/>=-sd}, @code{/>=-pd} @tab Not greater or equal @tab True @tab Yes @item @code{cmpord-ss}, @code{cmpord-ps} @tab @code{cmpord-sd}, @code{cmpord-pd} @tab Ordered, i.e. no NaN args @tab False @tab No @item @code{cmpunord-ss}, @code{cmpunord-ps} @tab @code{cmpunord-sd}, @code{cmpunord-pd} @tab Unordered, i.e. with NaN args @tab True @tab No @end multitable Likewise for scalar comparison predicates, i.e. functions that return the result of the comparison as a Lisp boolean instead of a bitmask sse-pack: @multitable { Single-float } { Double-float } { Not greater or equal } { Result for NaN } { QNaN traps } @item Single-float @tab Double-float @tab Condition @tab Result for NaN @tab QNaN traps @item @code{=-ss?} @tab @code{=-sd?} @tab Equal @tab True @tab Yes @item @code{=-ssu?} @tab @code{=-sdu?} @tab Equal @tab True @tab No @item @code{<-ss?} @tab @code{<-sd?} @tab Less @tab True @tab Yes @item @code{<-ssu?} @tab @code{<-sdu?} @tab Less @tab True @tab No @item @code{<=-ss?} @tab @code{<=-sd?} @tab Less or equal @tab True @tab Yes @item @code{<=-ssu?} @tab @code{<=-sdu?} @tab Less or equal @tab True @tab No @item @code{>-ss?} @tab @code{>-sd?} @tab Greater @tab False @tab Yes @item @code{>-ssu?} @tab @code{>-sdu?} @tab Greater @tab False @tab No @item @code{>=-ss?} @tab @code{>=-sd?} @tab Greater or equal @tab False @tab Yes @item @code{>=-ssu?} @tab @code{>=-sdu?} @tab Greater or equal @tab False @tab No @item @code{/=-ss?} @tab @code{/=-sd?} @tab Not equal @tab False @tab Yes @item @code{/=-ssu?} @tab @code{/=-sdu?} @tab Not equal @tab False @tab No @end multitable Note that MSDN specifies different return values for the C counterparts of some of these functions when called with NaN arguments, but that seems to disagree with the actually generated code. @node Simple extensions @subsection Simple extensions This module extends the set of basic intrinsics with the following simple compound functions: @itemize @item @code{neg-ss}, @code{neg-ps}, @code{neg-sd}, @code{neg-pd}, @code{neg-pi8}, @code{neg-pi16}, @code{neg-pi32}, @code{neg-pi64}: implement numeric negation of the corresponding data type. @item @code{not-ps}, @code{not-pd}, @code{not-pi}: implement bitwise logical inversion. @item @code{if-ps}, @code{if-pd}, @code{if-pi}: perform element-wise combining of two values based on a boolean condition vector produced as a combination of comparison function results through bitwise logical functions. The condition value must use all-zero bitmask for false, and all-one bitmask for true as a value for each logical vector element. The result is undefined if any other bit pattern is used. N.B.: these are @emph{functions}, so both branches of the conditional are always evaluated. @end itemize The module also provides symbol macros that expand into expressions producing certain constants in the most efficient way: @itemize @item 0.0-ps 0.0-pd 0-pi for zero @item true-ps true-pd true-pi for all 1 bitmask @item false-ps false-pd false-pi for all 0 bitmask (same as zero) @end itemize @node Lisp array accessors @subsection Lisp array accessors In order to provide better integration with ordinary lisp code, this module implements a set of AREF-like memory accessors: @itemize @item @code{(ROW-MAJOR-)?AREF-PREFETCH-(T0|T1|T2|NTA)} for cache prefetch. @item @code{(ROW-MAJOR-)?AREF-CLFLUSH} for cache flush. @item @code{(ROW-MAJOR-)?AREF-[AS]?P[SDI]} for whole-pack read & write. @item @code{(ROW-MAJOR-)?AREF-S(S|D|I64)} for scalar read & write. @end itemize (Where A = aligned; S = aligned streamed write.) These accessors can be used with any non-bit specialized array or vector, without restriction on the precise element type (although it should be declared at compile time to ensure generation of the fastest code). Additional index bound checking is done to ensure that enough bytes of memory are accessible after the specified index. As an exception, ROW-MAJOR-AREF-PREFETCH-* does not do any range checks at all, because the prefetch instructions are officially safe to use with bad addresses. The AREF-PREFETCH-* and *-CLFLUSH functions do only ordinary index checks without the usual 16-byte extension. @node Example @subsection Example This code processes several single-float arrays, storing either the value of a*b, or c/3.5 into result, depending on the sign of mode: @example (loop for i from 0 below 128 by 4 do (setf (aref-ps result i) (if-ps (<-ps (aref-ps mode i) 0.0-ps) (mul-ps (aref-ps a i) (aref-ps b i)) (div-ps (aref-ps c i) (set1-ps 3.5))))) @end example As already noted above, both branches of the if are always evaluated. ecl-16.1.2/contrib/cl-simd/ecl-sse-core.lisp000066400000000000000000000363521266352375300205330ustar00rootroot00000000000000;;; -*- mode: Lisp; indent-tabs-mode: nil; -*- ;;; ;;; Copyright (c) 2010, Alexander Gavrilov (angavrilov@gmail.com) ;;; ;;; This file defines macros for wrapping C-level SSE intrinsics. ;;; (in-package #:SSE) ;;; The compound SSE pack type (deftype sse-pack (&optional item) (ecase item (* 'ext:sse-pack) ((single-float float) 'float-sse-pack) (double-float 'double-sse-pack) (integer 'int-sse-pack))) ;;; Helper macros and functions (defmacro typename-case (value &body clauses) "Syntax: (case value &body clauses)" `(cond ,@(mapcar (lambda (clause) `((subtypep ,value ',(first clause)) ,@(rest clause))) clauses) (t (error "Unsupported type name: ~S" ,value)))) (defun foreign-type-of (lt) (typename-case lt (nil :object) (int-sse-pack :int-sse-pack) (float-sse-pack :float-sse-pack) (double-sse-pack :double-sse-pack) (boolean :bool) (single-float :float) (double-float :double) (fixnum :fixnum) #+uint32-t (ext:integer32 :int32-t) #+uint32-t (ext:byte32 :uint32-t) #+uint64-t (ext:integer64 :int64-t) #+uint64-t (ext:byte64 :uint64-t) (integer :fixnum))) (defun pointer-c-type-of (lt) (typename-case lt (nil "void") (int-sse-pack "__m128i") (float-sse-pack "float") (double-sse-pack "double"))) ;; Accept any real values for floating-point arguments: (defun declaim-arg-type-of (lt) (typename-case lt ((or single-float double-float) 'real) (ext:sse-pack 'ext:sse-pack) (fixnum 'fixnum) (t lt))) (defun inline-arg-type-of (lt) (typename-case lt ((or single-float double-float) 'c::fixnum-float) (fixnum 'fixnum) (t lt))) ;; Constant expansion (defun expand-constant (form env &optional chgp) (let* ((mform (macroexpand form env)) (cform (cond ((and (symbolp mform) (constantp mform)) (symbol-value mform)) (t mform)))) (values cform (or chgp (not (eql cform form)))))) ;; Macro helpers (defun make-arg-name (index) (intern (format nil "ARG~A" index))) (defun make-arg-nums (lst) (loop for i from 0 below (length lst) collect i)) (defun wrap-ret-arg (core ret-type &optional ret-arg) (cond ((eq ret-type nil) (format nil "(~A,Cnil)" core)) (ret-arg (format nil "@~36R;(~A,#~36R)" ret-arg core ret-arg)) (t core))) ;; Constant generation (defun make-pack-of-bin (bin-value &key (as 'int-sse-pack)) (let* ((all (loop for i from 0 to 15 for v = bin-value then (ash v -8) collect (logand v 255))) (pack (ext:vector-to-sse-pack (make-array 16 :element-type '(unsigned-byte 8) :initial-contents all)))) (if (eq as 'int-sse-pack) pack `(the ,as ,(ext:sse-pack-as-elt-type pack (ecase as (EXT:FLOAT-SSE-PACK 'single-float) (EXT:DOUBLE-SSE-PACK 'double-float))))))) (defmacro def-inline (name mode arg-types ret-type call-str &rest flags) `(eval-when (:compile-toplevel :load-toplevel) (c::def-inline ',name ',mode ',arg-types ',ret-type ,call-str ,@flags))) (defmacro def-intrinsic (name arg-types ret-type c-name &key (export t) ret-arg reorder-args immediate-args defun-body) "Defines and exports an SSE intrinsic function with matching open-coding rules." (let* ((anums (make-arg-nums arg-types)) (asyms (mapcar #'make-arg-name anums)) (aftypes (mapcar #'foreign-type-of arg-types)) (rftype (foreign-type-of ret-type)) (call-anums (if reorder-args (reverse anums) anums)) (call-str (wrap-ret-arg (format nil "~A(~{#~36R~^,~})" c-name call-anums) ret-type ret-arg))) `(progn ,(if export `(export ',name)) ,@(if immediate-args ; Generate a constantness verifier macro `((define-compiler-macro ,name (&whole whole &environment env ,@asyms &aux chgp) ,@(loop for (arg type) in immediate-args collect `(let ((oldv ,arg)) (multiple-value-setq (,arg chgp) (expand-constant oldv env chgp)) (unless (typep ,arg ',type) (c::cmperr "In call to ~A: Argument ~S~@[ = ~S~] is not a constant of type ~A" ',name oldv (unless (eql oldv ,arg) ,arg) ',type)))) (if chgp (list ',name ,@asyms) whole)))) (proclaim '(ftype (function ,(mapcar #'declaim-arg-type-of arg-types) ,(or ret-type 'null)) ,name)) ,@(if (null immediate-args) `((defun ,name ,asyms (declare (optimize (speed 0) (debug 0) (safety 1))) (ffi:c-inline ,asyms ,aftypes ,rftype ,(or defun-body call-str) :one-liner t)))) (def-inline ,name :always ,(mapcar #'inline-arg-type-of arg-types) ,rftype ,call-str :inline-or-warn t)))) (defmacro def-unary-intrinsic (name ret-type insn cost c-name &key (arg-type ret-type) partial result-size immediate-arg) (declare (ignore insn cost partial result-size)) `(def-intrinsic ,name (,arg-type ,@(if immediate-arg (list immediate-arg))) ,ret-type ,c-name :immediate-args ,(if immediate-arg `((arg1 ,immediate-arg))))) (defmacro def-cvt-to-int32-intrinsic (name ret-type insn cost c-name &key (arg-type ret-type) partial immediate-arg) (declare (ignore insn cost partial)) (assert (subtypep ret-type '(signed-byte 32))) `(def-intrinsic ,name (,arg-type ,@(if immediate-arg (list immediate-arg))) ,ret-type ,c-name :immediate-args ,(if immediate-arg `((arg1 ,immediate-arg))))) (defmacro def-binary-intrinsic (name ret-type insn cost c-name &key (x-type ret-type) (y-type ret-type) commutative tags immediate-arg) (declare (ignore insn cost commutative tags)) `(def-intrinsic ,name (,x-type ,y-type ,@(if immediate-arg (list immediate-arg))) ,ret-type ,c-name :immediate-args ,(if immediate-arg `((arg2 ,immediate-arg))))) (defmacro def-sse-int-intrinsic (name int-type ret-type insn cost c-name &key (arg-type ret-type) immediate-arg make-temporary defun-body) (declare (ignore insn cost make-temporary)) `(def-intrinsic ,name (,arg-type ,int-type ,@(if immediate-arg (list immediate-arg))) ,ret-type ,c-name :immediate-args ,(if immediate-arg `((arg2 ,immediate-arg))) :defun-body ,defun-body)) (defmacro def-comparison-intrinsic (name arg-type insn cost c-name &key commutative tags) (declare (ignore insn cost commutative tags)) `(def-intrinsic ,name (,arg-type ,arg-type) boolean ,c-name)) (defmacro %def-aref-intrinsic (tag val-type c-type reader writer &key (aux-args "") (bsize 16)) "Defines and exports macros and functios that implement vectorized array access." (let* ((rftype (foreign-type-of val-type)) (aref-name (intern (format nil "AREF-~A" tag) *package*)) (rm-aref-name (intern (format nil "ROW-MAJOR-AREF-~A" tag) *package*)) (rm-aset-name (intern (format nil "ROW-MAJOR-ASET-~A" tag) *package*)) (known-elt-types '((single-float "sf") (double-float "df") (ext:byte8 "b8") (ext:integer8 "i8") #+uint16-t (ext:byte16 "b16") #+uint16-t (ext:integer16 "i16") #+uint32-t (ext:byte32 "b32") #+uint32-t (ext:integer32 "i32") #+uint64-t (ext:byte64 "b64") #+uint64-t (ext:integer64 "i64")))) (flet ((fmtr (ptr-fmt &rest ptr-args) (wrap-ret-arg (format nil "~A((~A*)~?~A)" reader c-type ptr-fmt ptr-args aux-args) val-type)) (fmtw (ptr-fmt &rest ptr-args) (wrap-ret-arg (format nil "~A((~A*)~?,#2)" writer c-type ptr-fmt ptr-args) val-type 2))) `(progn (export ',aref-name) (export ',rm-aref-name) (defmacro ,aref-name (array &rest indexes) (let ((varr (gensym "ARR"))) `(let ((,varr ,array)) (declare (:read-only ,varr)) (,',rm-aref-name ,varr (array-row-major-index ,varr ,@indexes))))) (proclaim '(ftype (function (array fixnum) ,(or val-type 'null)) ,rm-aref-name)) (defun ,rm-aref-name (array index) (declare (optimize (speed 0) (debug 0) (safety 2))) (ffi:c-inline (array index) (:object :int) ,rftype ,(fmtr "ecl_row_major_ptr(#0,#1,~A)" bsize) :one-liner t)) ;; AREF (def-inline ,rm-aref-name :always (t t) ,rftype ,(fmtr "ecl_row_major_ptr(#0,fixint(#1),~A)" bsize) :inline-or-warn t) (def-inline ,rm-aref-name :always (t fixnum) ,rftype ,(fmtr "ecl_row_major_ptr(#0,#1,~A)" bsize)) ;; AREF unsafe ,@(mapcar (lambda (spec) `(def-inline ,rm-aref-name :unsafe ((array ,(first spec)) fixnum) ,rftype ,(fmtr "(&(#0)->array.self.~A[#1])" (second spec)))) known-elt-types) ,@(if writer `((define-setf-expander ,aref-name (array &rest indexes) (let ((varr (gensym)) (vidx (gensym)) (vval (gensym))) (values (list varr vidx) (list array `(array-row-major-index ,varr ,@indexes)) (list vval) `(,',rm-aset-name ,varr ,vidx ,vval) `(,',rm-aref-name ,varr ,vidx)))) (proclaim '(ftype (function (array fixnum ,(declaim-arg-type-of val-type)) ,val-type) ,rm-aset-name)) (defun ,rm-aset-name (array index value) (declare (optimize (speed 0) (debug 0) (safety 2))) (prog1 value (ffi:c-inline (array index value) (:object :int ,rftype) :void ,(fmtw "ecl_row_major_ptr(#0,#1,~A)" bsize) :one-liner t))) (defsetf ,rm-aref-name ,rm-aset-name) ;; ASET (def-inline ,rm-aset-name :always (t t ,val-type) ,rftype ,(fmtw "ecl_row_major_ptr(#0,fixint(#1),~A)" bsize) :inline-or-warn t) (def-inline ,rm-aset-name :always (t fixnum ,val-type) ,rftype ,(fmtw "ecl_row_major_ptr(#0,#1,~A)" bsize)) ;; ASET unsafe ,@(mapcar (lambda (spec) `(def-inline ,rm-aset-name :unsafe ((array ,(first spec)) fixnum ,val-type) ,rftype ,(fmtw "(&(#0)->array.self.~A[#1])" (second spec)))) known-elt-types))))))) (defmacro def-aref-intrinsic (tag val-type reader-fun writer-fun &key (ref-size 16)) `(%def-aref-intrinsic ,tag ,val-type ,(pointer-c-type-of val-type) ,(get reader-fun 'c-function-name) ,(get writer-fun 'c-function-name) :bsize ,ref-size :aux-args ,(get reader-fun 'c-call-aux-args))) (defmacro def-mem-intrinsic (name c-type ret-type c-name &key (public t) prefix-args (prefix-fmt "~@{#~36R,~}") postfix-args (postfix-fmt "~@{,#~36R~}" pf-p) ret-arg) "Defines and exports an SSE memory access intrinsic function with matching open-coding rules." (let* ((anums (make-arg-nums (append prefix-args postfix-args))) (asyms (mapcar #'make-arg-name anums)) (prefix-nums (subseq anums 0 (length prefix-args))) (postfix-nums (mapcar #'1+ (subseq anums (length prefix-args)))) (prefix-syms (subseq asyms 0 (length prefix-args))) (postfix-syms (subseq asyms (length prefix-args))) (prefix-itypes (mapcar #'inline-arg-type-of prefix-args)) (postfix-itypes (mapcar #'inline-arg-type-of postfix-args)) (rftype (foreign-type-of ret-type)) (ptr-idx (length prefix-args)) (offset-idx (+ ptr-idx 1 (length postfix-args)))) (flet ((fmt (ptr-text) (wrap-ret-arg (format nil "~A(~?(~A*)~?~?)" c-name prefix-fmt prefix-nums c-type ptr-text (list ptr-idx offset-idx) postfix-fmt postfix-nums) ret-type ret-arg))) `(progn ,(when public `(export ',name)) (eval-when (:compile-toplevel :load-toplevel :execute) (setf (get ',name 'c-function-name) ,c-name) ,(if (and pf-p (null postfix-args)) `(setf (get ',name 'c-call-aux-args) ,postfix-fmt))) (proclaim '(ftype (function (,@(mapcar #'declaim-arg-type-of prefix-args) si:foreign-data ,@(mapcar #'declaim-arg-type-of postfix-args) &optional fixnum) ,ret-type) ,name)) (defun ,name (,@prefix-syms ptr ,@postfix-syms &optional (offset 0)) (declare (optimize (speed 0) (debug 0) (safety 1))) (ffi:c-inline (,@prefix-syms ptr ,@postfix-syms offset) (,@(mapcar #'foreign-type-of prefix-args) :pointer-void ,@(mapcar #'foreign-type-of postfix-args) :int) ,rftype ,(fmt "(((char*)#~A) + #~A)") :one-liner t)) (def-inline ,name :always (,@prefix-itypes t ,@postfix-itypes) ,rftype ,(fmt "ecl_to_pointer(#~A)") :inline-or-warn t) (def-inline ,name :always (,@prefix-itypes t ,@postfix-itypes t) ,rftype ,(fmt "(((char*)ecl_to_pointer(#~A)) + fixint(#~A))")) (def-inline ,name :always (,@prefix-itypes t ,@postfix-itypes fixnum) ,rftype ,(fmt "(((char*)ecl_to_pointer(#~A)) + #~A)")) (def-inline ,name :unsafe (,@prefix-itypes si:foreign-data ,@postfix-itypes) ,rftype ,(fmt "(#~A)->foreign.data")) (def-inline ,name :unsafe (,@prefix-itypes si:foreign-data ,@postfix-itypes t) ,rftype ,(fmt "(((char*)(#~A)->foreign.data) + fix(#~A))")) (def-inline ,name :unsafe (,@prefix-itypes si:foreign-data ,@postfix-itypes fixnum) ,rftype ,(fmt "(((char*)(#~A)->foreign.data) + #~A)")))))) (defmacro def-load-intrinsic (name ret-type insn c-name &key register-arg tags size postfix-fmt) (declare (ignore insn tags size)) `(def-mem-intrinsic ,name ,(pointer-c-type-of ret-type) ,ret-type ,c-name :prefix-args ,(if register-arg (list ret-type)) :postfix-fmt ,(or postfix-fmt ""))) (defmacro def-store-intrinsic (name ret-type insn c-name &key setf-name) (declare (ignore insn)) `(progn (def-mem-intrinsic ,name ,(pointer-c-type-of ret-type) ,ret-type ,c-name :public ,(not setf-name) :postfix-args (,ret-type) :ret-arg 1) ,(if setf-name `(defsetf ,setf-name (pointer &optional (offset 0)) (value) `(,',name ,pointer ,value ,offset))))) ecl-16.1.2/contrib/cl-simd/ecl-sse-utils.lisp000066400000000000000000000355061266352375300207430ustar00rootroot00000000000000;;; -*- mode: Lisp; indent-tabs-mode: nil; -*- ;;; ;;; Copyright (c) 2010, Alexander Gavrilov (angavrilov@gmail.com) ;;; ;;; This file defines some extensions to the base intrinsic set, ;;; and other utility functions. ;;; (in-package #:SSE) ;;; Helper macros and functions (eval-when (:compile-toplevel :load-toplevel :execute) ;; Try using a matching inverse function name (defun lookup-flip (arg pairs &key no-reverse) (and (consp arg) (let ((fix (or (cdr (assoc (first arg) pairs)) (unless no-reverse (car (rassoc (first arg) pairs)))))) (cond ((eq fix :identity) (assert (null (cddr arg))) (second arg)) (fix `(,fix ,@(rest arg))) (t nil))))) ;; Macroexpand, plus compiler expand some specific names (defun expand-condition (form env) (setq form (macroexpand form env)) (loop while (and (consp form) (symbolp (first form)) (get (first form) 'expand-in-condition)) do (setq form (c::cmp-expand-macro (compiler-macro-function (first form)) form env))) form) ;; Checks if the form is an unary call (defun is-unary? (form op) (and (consp form) (eq (first form) op) (null (cddr form)))) ;; IF-style function expander (defun expand-if-macro (condition then-value else-value env if-f not-f or-f and-f andnot-f type-name zero-val &key flip) (let* ((condition (expand-condition condition env)) (then-value (macroexpand then-value env)) (else-value (macroexpand else-value env)) (then-zero? (equal then-value zero-val)) (else-zero? (equal else-value zero-val))) (cond ((is-unary? condition not-f) (expand-if-macro (second condition) else-value then-value env if-f not-f or-f and-f andnot-f type-name zero-val :flip (not flip))) ((and then-zero? else-zero?) zero-val) (then-zero? `(,andnot-f ,condition ,else-value)) (else-zero? `(,and-f ,condition ,then-value)) (t (let* ((csym (gensym)) (args `((,and-f ,csym ,then-value) (,andnot-f ,csym ,else-value)))) `(let ((,csym ,condition)) (declare (type ,type-name ,csym) (:read-only ,csym)) (,or-f ,@(if flip (reverse args) args))))))))) (defmacro def-utility (name arg-types ret-type expansion &key expand-args expand-in-condition) "Defines and exports a function & compiler macro with the specified expansion." (let* ((anames (mapcar #'make-arg-name (make-arg-nums arg-types)))) `(progn (export ',name) (eval-when (:compile-toplevel :load-toplevel) ,@(if expand-in-condition `((setf (get ',name 'expand-in-condition) t))) (define-compiler-macro ,name (&environment env ,@anames) (declare (ignorable env)) ,@(loop for arg in (if (eq expand-args t) anames expand-args) collect `(setq ,arg (macroexpand ,arg env))) ,expansion)) (proclaim '(ftype (function ,(mapcar #'declaim-arg-type-of arg-types) ,ret-type) ,name)) (defun ,name ,anames (declare (optimize (speed 0) (debug 0) (safety 1))) (let ,(mapcar #'list anames anames) (declare ,@(loop for an in anames and at in arg-types collect `(type ,at ,an))) ;; Depends on the compiler macro being expanded: (,name ,@anames)))))) (defmacro def-if-function (name type-name postfix) `(def-utility ,name (,type-name ,type-name ,type-name) ,type-name (expand-if-macro arg0 arg1 arg2 env ',name ',(intern (format nil "NOT-~A" postfix)) ',(intern (format nil "OR-~A" postfix)) ',(intern (format nil "AND-~A" postfix)) ',(intern (format nil "ANDNOT-~A" postfix)) ',type-name '(,(intern (format nil "SETZERO-~A" postfix)))))) ;;; Aligned array allocation (deftype sse-array (elt-type &optional dims) "Type of arrays efficiently accessed by SSE aref intrinsics and returned by make-sse-array. Should be assumed to be SIMPLE-ARRAY, except that displacing with MAKE-SSE-ARRAY is allowed." (when (eq elt-type '*) (c::cmperr "SSE-ARRAY must have a specific element type.")) (let ((upgraded (upgraded-array-element-type elt-type))) (when (member upgraded '(t bit)) (c::cmperr "Invalid SSE-ARRAY element type: ~S" elt-type)) (unless (subtypep upgraded elt-type) (c::cmpwarn "SSE-ARRAY element type ~S has been upgraded to ~S" elt-type upgraded)) `(array ,upgraded ,dims))) (defun make-sse-array (dimensions &rest args &key (element-type '(unsigned-byte 8)) displaced-to &allow-other-keys) "Allocates an SSE-ARRAY aligned to the 16-byte boundary. May flatten displacement chains for performance reasons." (if displaced-to (apply #'make-array dimensions args) (multiple-value-bind (elt-size adj-type) (array-element-type-byte-size element-type) (when (eq adj-type t) (error "Cannot use element type T with SSE.")) (sys::remf args :element-type) (let* ((full-size (if (numberp dimensions) dimensions (reduce #'* dimensions))) (padded-size (+ full-size (ceiling 15 elt-size))) (array (apply #'make-array padded-size :element-type adj-type args)) (misalign (ffi:c-inline (array) (:object) :int "(((unsigned long)(#0)->array.self.b8) & 15)" :one-liner t)) (offset (/ (if (> misalign 0) (- 16 misalign) 0) elt-size))) (make-array dimensions :element-type element-type :displaced-to array :displaced-index-offset offset))))) ;;; Single-float tools ;; Constants (defmacro set-true-ss () (load-time-value (make-pack-of-bin #xFFFFFFFF :as 'float-sse-pack))) (defmacro set-true-ps () (load-time-value (make-pack-of-bin -1 :as 'float-sse-pack))) (eval-when (:compile-toplevel :load-toplevel) (define-symbol-macro 0.0-ps (setzero-ps)) (define-symbol-macro true-ss (set-true-ss)) (define-symbol-macro false-ss (setzero-ps)) (define-symbol-macro true-ps (set-true-ps)) (define-symbol-macro false-ps (setzero-ps))) ;; Bitwise if (def-if-function if-ps float-sse-pack #:ps) ;; Arithmetic negation (xor with negative zero) (def-utility neg-ss (float-sse-pack) float-sse-pack `(xor-ps ,arg0 ,(load-time-value (make-pack-of-bin #x80000000 :as 'float-sse-pack)))) (def-utility neg-ps (float-sse-pack) float-sse-pack `(xor-ps ,arg0 ,(load-time-value (make-pack-of-bin #x80000000800000008000000080000000 :as 'float-sse-pack)))) ;; Logical inversion (def-utility not-ps (float-sse-pack) float-sse-pack (or (lookup-flip arg0 '((=-ps . /=-ps) (<-ps . /<-ps) (<=-ps . /<=-ps) (>-ps . />-ps) (>=-ps . />=-ps) (cmpord-ps . cmpunord-ps) (not-ps . :identity))) `(xor-ps ,arg0 true-ps)) :expand-args t) ;; Shuffle (defun shuffle-ps (x y mask) (declare (optimize (speed 0) (debug 0) (safety 1)) (type t x y mask)) (check-type x sse-pack) (check-type y sse-pack) (check-type mask (unsigned-byte 8)) (ffi:c-inline (x y mask) (:object :object :int) :float-sse-pack "_mm_setr_ps( (#0)->sse.data.sf[(#2)&3], (#0)->sse.data.sf[((#2)>>2)&3], (#1)->sse.data.sf[((#2)>>4)&3], (#1)->sse.data.sf[((#2)>>6)&3] )" :one-liner t)) ;;; Double-float tools ;; Constants (defmacro set-true-sd () (load-time-value (make-pack-of-bin #xFFFFFFFFFFFFFFFF :as 'double-sse-pack))) (defmacro set-true-pd () (load-time-value (make-pack-of-bin -1 :as 'double-sse-pack))) (eval-when (:compile-toplevel :load-toplevel) (define-symbol-macro 0.0-pd (setzero-pd)) (define-symbol-macro true-sd (set-true-sd)) (define-symbol-macro false-sd (setzero-pd)) (define-symbol-macro true-pd (set-true-pd)) (define-symbol-macro false-pd (setzero-pd))) ;; Bitwise if (def-if-function if-pd double-sse-pack #:pd) ;; Arithmetic negation (xor with negative zero) (def-utility neg-sd (double-sse-pack) double-sse-pack `(xor-pd ,arg0 ,(load-time-value (make-pack-of-bin #x8000000000000000 :as 'double-sse-pack)))) (def-utility neg-pd (double-sse-pack) double-sse-pack `(xor-pd ,arg0 ,(load-time-value (make-pack-of-bin #x80000000000000008000000000000000 :as 'double-sse-pack)))) ;; Logical inversion (def-utility not-pd (double-sse-pack) double-sse-pack (or (lookup-flip arg0 '((=-pd . /=-pd) (<-pd . /<-pd) (<=-pd . /<=-pd) (>-pd . />-pd) (>=-pd . />=-pd) (cmpord-pd . cmpunord-pd) (not-pd . :identity))) `(xor-pd ,arg0 true-pd)) :expand-args t) ;; Shuffle (defun shuffle-pd (x y mask) (declare (optimize (speed 0) (debug 0) (safety 1)) (type t x y mask)) (check-type x sse-pack) (check-type y sse-pack) (check-type mask (unsigned-byte 2)) (ffi:c-inline (x y mask) (:object :object :int) :double-sse-pack "_mm_setr_pd( (#0)->sse.data.df[(#2)&1], (#1)->sse.data.df[((#2)>>1)&1] )" :one-liner t)) ;;; Integer tools ;; Constants (defmacro set-true-pi () (load-time-value (make-pack-of-bin -1 :as 'int-sse-pack))) (eval-when (:compile-toplevel :load-toplevel) (define-symbol-macro 0-pi (setzero-pi)) (define-symbol-macro true-pi (set-true-pi)) (define-symbol-macro false-pi (setzero-pi))) ;; Bitwise if (def-if-function if-pi float-sse-pack #:pi) ;; Arithmetic negation (subtract from 0) (macrolet ((frob (name subf) `(def-utility ,name (int-sse-pack) int-sse-pack `(,',subf (setzero-pi) ,arg0)))) (frob neg-pi8 sub-pi8) (frob neg-pi16 sub-pi16) (frob neg-pi32 sub-pi32) (frob neg-pi64 sub-pi64)) ;; Logical inversion (def-utility not-pi (int-sse-pack) int-sse-pack (or (lookup-flip arg0 '((<=-pi8 . >-pi8) (<=-pi16 . >-pi16) (<=-pi32 . >-pi32) (>=-pi8 . <-pi8) (>=-pi16 . <-pi16) (>=-pi32 . <-pi32) (/=-pi8 . =-pi8) (/=-pi16 . =-pi16) (/=-pi32 . =-pi32) (not-pi . :identity)) :no-reverse t) `(xor-pi ,arg0 true-pi)) :expand-args t) (macrolet ((frob (name code) `(def-utility ,name (int-sse-pack int-sse-pack) int-sse-pack ,code :expand-in-condition t))) (frob <=-pi8 `(not-pi (>-pi8 ,arg0 ,arg1))) (frob <=-pi16 `(not-pi (>-pi16 ,arg0 ,arg1))) (frob <=-pi32 `(not-pi (>-pi32 ,arg0 ,arg1))) (frob >=-pi8 `(not-pi (<-pi8 ,arg0 ,arg1))) (frob >=-pi16 `(not-pi (<-pi16 ,arg0 ,arg1))) (frob >=-pi32 `(not-pi (<-pi32 ,arg0 ,arg1))) (frob /=-pi8 `(not-pi (=-pi8 ,arg0 ,arg1))) (frob /=-pi16 `(not-pi (=-pi16 ,arg0 ,arg1))) (frob /=-pi32 `(not-pi (=-pi32 ,arg0 ,arg1)))) ;; Shifts (defun slli-pi (x shift) (declare (optimize (speed 0) (debug 0) (safety 1)) (type t x shift)) (check-type x sse-pack) (check-type shift (unsigned-byte 8)) (ffi:c-inline (x shift) (:object :int) :object "cl_object rv = ecl_make_int_sse_pack(_mm_setzero_si128()); unsigned bshift=(#1), i; for (i = 0; i + bshift < 16; i++) rv->sse.data.b8[i+bshift] = (#0)->sse.data.b8[i]; @(return) = rv;")) (defun srli-pi (x shift) (declare (optimize (speed 0) (debug 0) (safety 1)) (type t x shift)) (check-type x sse-pack) (check-type shift (unsigned-byte 8)) (ffi:c-inline (x shift) (:object :int) :object "cl_object rv = ecl_make_int_sse_pack(_mm_setzero_si128()); int bshift=(#1), i; for (i = 16 - bshift - 1; i >= 0; i--) rv->sse.data.b8[i] = (#0)->sse.data.b8[i+bshift]; @(return) = rv;")) ;; Extract & insert (defun extract-pi16 (x index) (declare (optimize (speed 0) (debug 0) (safety 1)) (type t x index)) (check-type x sse-pack) (check-type index (unsigned-byte 8)) (ffi:c-inline (x index) (:object :int) :fixnum "*((unsigned short*)&(#0)->sse.data.b8[((#1)&3)*2])" :one-liner t)) (defun insert-pi16 (x ival index) (declare (optimize (speed 0) (debug 0) (safety 1)) (type t x ival index)) (check-type x sse-pack) (check-type index (unsigned-byte 8)) (ffi:c-inline (x ival index) (:int-sse-pack :int :int) :object "cl_object rv = ecl_make_int_sse_pack(#0); *((unsigned short*)&rv->sse.data.b8[((#2)&3)*2]) = (unsigned short)(#1); @(return) = rv;")) ;; Shuffles (defun shuffle-pi32 (x mask) (declare (optimize (speed 0) (debug 0) (safety 1)) (type t x mask)) (check-type x sse-pack) (check-type mask (unsigned-byte 8)) (ffi:c-inline (x mask) (:object :int) :int-sse-pack "unsigned *pd = (unsigned*)(#0)->sse.data.b8; @(return) = _mm_setr_epi32(pd[(#1)&3],pd[((#1)>>2)&3],pd[((#1)>>4)&3],pd[((#1)>>6)&3]);")) (defun shufflelo-pi16 (x mask) (declare (optimize (speed 0) (debug 0) (safety 1)) (type t x mask)) (check-type x sse-pack) (check-type mask (unsigned-byte 8)) (ffi:c-inline (x mask) (:object :int) :int-sse-pack "unsigned short *pd = (unsigned short*)(#0)->sse.data.b8; @(return) = _mm_setr_epi16( pd[(#1)&3],pd[((#1)>>2)&3],pd[((#1)>>4)&3],pd[(((#1)>>6)&3)], pd[4], pd[5], pd[6], pd[7] );")) (defun shufflehi-pi16 (x mask) (declare (optimize (speed 0) (debug 0) (safety 1)) (type t x mask)) (check-type x sse-pack) (check-type mask (unsigned-byte 8)) (ffi:c-inline (x mask) (:object :int) :int-sse-pack "unsigned short *pb = (unsigned short*)(#0)->sse.data.b8, *pd = pb+4; @(return) = _mm_setr_epi16( pb[0], pb[1], pb[2], pb[3], pd[(#1)&3],pd[((#1)>>2)&3],pd[((#1)>>4)&3],pd[(((#1)>>6)&3)] );")) ecl-16.1.2/contrib/cl-simd/sbcl-arrays.lisp000066400000000000000000000314501266352375300204660ustar00rootroot00000000000000;;; -*- mode: Lisp; indent-tabs-mode: nil; -*- ;;; ;;; Copyright (c) 2010, Alexander Gavrilov (angavrilov@gmail.com) ;;; ;;; This file contains the groundwork for vectorized ;;; array access intrinsics. ;;; (in-package #:SSE) ;; SSE array element size calculation (eval-when (:compile-toplevel :load-toplevel :execute) (defun sse-elt-shift-from-saetp (info) (and info (subtypep (saetp-specifier info) 'number) (not (saetp-fixnum-p info)) (case (saetp-n-bits info) (8 0) (16 1) (32 2) (64 3) (128 4))))) (defglobal %%size-shift-table%% (let ((arr (make-array (1+ widetag-mask) :initial-element nil))) (loop for info across *specialized-array-element-type-properties* for shift = (sse-elt-shift-from-saetp info) when shift do (setf (svref arr (saetp-typecode info)) shift)) arr) "A table of element size shifts for supported SSE array types.") (declaim (inline sse-elt-shift-of) (ftype (function (t) (integer 0 4)) sse-elt-shift-of)) (defun sse-elt-shift-of (obj) "Returns the SSE element size shift for the given object, or fails if it is not a valid SSE vector." (declare (optimize (safety 0))) (the (integer 0 4) (or (svref %%size-shift-table%% (if (sb-vm::%other-pointer-p obj) (%other-pointer-widetag obj) 0)) (error 'type-error :datum obj :expected-type 'sse-array)))) ;;; Type and allocation (deftype sse-array (&optional (elt-type '* et-p) dims) "Type of arrays efficiently accessed by SSE aref intrinsics and returned by make-sse-array. Should be assumed to be SIMPLE-ARRAY, except that displacing with MAKE-SSE-ARRAY is allowed." (if (eq elt-type '*) (progn (when et-p (error "SSE-ARRAY must have a specific element type.")) `(simple-array * ,dims)) (let* ((upgraded (upgraded-array-element-type elt-type)) (shift (sse-elt-shift-from-saetp (find-saetp upgraded)))) (when (null shift) (error "Invalid SSE-ARRAY element type: ~S" elt-type)) (unless (subtypep upgraded elt-type) (warn "SSE-ARRAY element type ~S has been upgraded to ~S" elt-type upgraded)) `(simple-array ,upgraded ,dims)))) (defun make-sse-array (dimensions &key (element-type '(unsigned-byte 8)) (initial-element nil ie-p) displaced-to (displaced-index-offset 0)) "Allocates an SSE-ARRAY aligned to the 16-byte boundary. Flattens displacement chains for performance reasons." (let* ((upgraded (upgraded-array-element-type element-type)) (shift (sse-elt-shift-from-saetp (find-saetp upgraded)))) (when (null shift) (error "Invalid SSE-ARRAY element type: ~S" element-type)) (if displaced-to ;; Fake displacement by allocating a simple-array header (let* ((dimensions (if (listp dimensions) dimensions (list dimensions))) (rank (length dimensions)) (count (reduce #'* dimensions))) (unless (subtypep element-type (array-element-type displaced-to)) (error "can't displace an array of type ~S into another of type ~S" element-type (array-element-type displaced-to))) (with-array-data ((data displaced-to) (start displaced-index-offset) (end)) (unless (= start 0) (error "SSE-ARRAY does not support displaced index offset.")) (unless (<= count end) (array-bounding-indices-bad-error data start count)) (if (= rank 1) (progn (when (< count end) (warn "SSE-ARRAY displaced size extended to the full length of the vector.")) data) (let ((new-array (make-array-header simple-array-widetag rank))) (set-array-header new-array data count nil 0 dimensions nil t))))) ;; X86-64 vectors are already aligned to 16 bytes (apply #'make-array dimensions :element-type upgraded (if ie-p (list :initial-element initial-element)))))) ;;; AREF intrinsic definition helpers (defconstant +vector-data-fixup+ (- (* vector-data-offset n-word-bytes) other-pointer-lowtag) "Offset from a tagged vector pointer to its data") (defmacro array-data-expr (array-var &optional is-vector) (ecase is-vector (:yes array-var) (:no `(%array-data-vector ,array-var)) ((nil) `(if (array-header-p ,array-var) (%array-data-vector ,array-var) ,array-var)))) ;; Depends on the vector-length field being in the same place ;; as the array fill pointer, which for simple-array is equal ;; to the total size. (defknown %sse-array-size (simple-array fixnum) array-total-size (flushable always-translatable)) (define-vop (%sse-array-size/0) (:translate %sse-array-size) (:args (array :scs (descriptor-reg))) (:arg-types * (:constant (integer 0 0))) (:info gap) (:ignore gap) (:policy :fast-safe) (:results (result :scs (any-reg))) (:result-types tagged-num) (:generator 3 (loadw result array vector-length-slot other-pointer-lowtag))) (define-vop (%sse-array-size %sse-array-size/0) (:arg-types * (:constant (integer 1 16))) (:ignore) (:temporary (:sc any-reg) tmp) (:generator 8 (loadw result array vector-length-slot other-pointer-lowtag) (inst mov tmp (fixnumize gap)) (inst cmp result tmp) (inst cmov :ng tmp result) (inst sub result tmp))) (defmacro with-sse-data (((sap-var data-var array) (offset-var index)) &body code) ;; Compute a SAP and offset for the specified array and index. Check bounds. (with-unique-names (data-index data-end elt-shift access-size) (once-only ((array array) (index index)) `(locally (declare (optimize (insert-array-bounds-checks 0))) (with-array-data ((,data-var ,array) (,data-index ,index) (,data-end)) (let* ((,sap-var (int-sap (get-lisp-obj-address ,data-var))) (,elt-shift (sse-elt-shift-of ,data-var)) (,access-size (ash 16 (- ,elt-shift))) (,offset-var (+ (ash ,data-index ,elt-shift) +vector-data-fixup+))) (declare (type system-area-pointer ,sap-var) (type fixnum ,offset-var)) (unless (<= 0 ,data-index (+ ,data-index ,access-size) ,data-end) (array-bounding-indices-bad-error ,array ,index (+ ,index ,access-size))) ,@code)))))) (defun sse-array-info-or-give-up (lvar ref-size) ;; Look up the SSE element size and check if it is definitely a vector (let ((type (lvar-type lvar))) (unless (and (array-type-p type) (not (array-type-complexp type))) (give-up-ir1-transform "not a simple array")) (let* ((etype (array-type-specialized-element-type type)) (shift (sse-elt-shift-from-saetp (if (eq etype *wild-type*) nil (find-saetp-by-ctype etype))))) (unless shift (give-up-ir1-transform "not a known SSE-compatible array element type: ~S" (type-specifier etype))) (values (ash 1 shift) ; step (ash (1- ref-size) (- shift)) ; gap (and (listp (array-type-dimensions type)) (if (null (cdr (array-type-dimensions type))) :yes :no)))))) (defmacro def-aref-intrinsic (postfix rtype reader writer &key (ref-size 16)) (let* ((rm-aref (symbolicate "ROW-MAJOR-AREF-" postfix)) (rm-aset (if writer (symbolicate "ROW-MAJOR-ASET-" postfix))) (aref (symbolicate "AREF-" postfix)) (aset (if writer (symbolicate "%ASET-" postfix))) (reader-vop (symbolicate "%" reader)) (reader/ix-vop (symbolicate "%" reader "/IX")) (writer-vop (if writer (symbolicate "%" writer))) (writer/ix-vop (if writer (symbolicate "%" writer "/IX"))) (rtype (or rtype '(values))) (index-expression (if (= ref-size 0) ``(the signed-word index) ``(the signed-word (%check-bound array (%sse-array-size array ,gap) index))))) `(progn ;; ROW-MAJOR-AREF (export ',rm-aref) (defknown ,rm-aref (array index) ,rtype (foldable flushable)) (defun ,rm-aref (array index) (with-sse-data ((sap data array) (offset index)) (,reader-vop sap offset 1 0))) ;; (deftransform ,rm-aref ((array index) (simple-array t) * :important t) ,(format nil "open-code ~A" rm-aref) (multiple-value-bind (step gap is-vector) (sse-array-info-or-give-up array ,ref-size) (declare (ignorable gap)) `(,',reader/ix-vop (array-data-expr array ,is-vector) ,,index-expression ,step ,+vector-data-fixup+))) ;; AREF (export ',aref) (defknown ,aref (array &rest index) ,rtype (foldable flushable)) (defun ,aref (array &rest indices) (declare (truly-dynamic-extent indices)) (with-sse-data ((sap data array) (offset (%array-row-major-index array indices))) (,reader-vop sap offset 1 0))) ;; (defoptimizer (,aref derive-type) ((array &rest indices) node) (assert-array-rank array (length indices)) (values-specifier-type ',rtype)) (deftransform ,aref ((array &rest indices) (simple-array &rest t) * :important t) ,(format nil "open-code ~A" aref) (multiple-value-bind (step gap is-vector) (sse-array-info-or-give-up array ,ref-size) (declare (ignorable gap)) (let ((syms (make-gensym-list (length indices)))) `(lambda (array ,@syms) (let ((index ,(if (eq is-vector :yes) (first syms) `(array-row-major-index array ,@syms)))) (,',reader/ix-vop (array-data-expr array ,is-vector) ,,index-expression ,step ,+vector-data-fixup+)))))) ,@(if writer `(;; ROW-MAJOR-ASET (defknown ,rm-aset (array index sse-pack) ,rtype (unsafe)) (defsetf ,rm-aref ,rm-aset) (defun ,rm-aset (array index new-value) (with-sse-data ((sap data array) (offset index)) (,writer-vop sap offset 1 0 (the ,rtype new-value)) new-value)) ;; (deftransform ,rm-aset ((array index value) (simple-array t t) * :important t) ,(format nil "open-code ~A" rm-aset) (multiple-value-bind (step gap is-vector) (sse-array-info-or-give-up array ,ref-size) (declare (ignorable gap)) `(progn (,',writer/ix-vop (array-data-expr array ,is-vector) ,,index-expression ,step ,+vector-data-fixup+ (the sse-pack value)) value))) ;; %ASET (defknown ,aset (array &rest t) ,rtype (unsafe)) (defsetf ,aref ,aset) (defun ,aset (array &rest stuff) (let ((new-value (car (last stuff)))) (with-sse-data ((sap data array) (offset (%array-row-major-index array (nbutlast stuff)))) (,writer-vop sap offset 1 0 (the ,rtype new-value)) new-value))) ;; (defoptimizer (,aset derive-type) ((array &rest stuff) node) (assert-array-rank array (1- (length stuff))) (assert-lvar-type (car (last stuff)) (specifier-type 'sse-pack) (lexenv-policy (node-lexenv node))) (specifier-type ',rtype)) (deftransform ,aset ((array &rest stuff) (simple-array &rest t) * :important t) ,(format nil "open-code ~A" aset) (multiple-value-bind (step gap is-vector) (sse-array-info-or-give-up array ,ref-size) (declare (ignorable gap)) (let ((syms (make-gensym-list (length stuff)))) `(lambda (array ,@syms) (let ((index ,(if (eq is-vector :yes) (first syms) `(array-row-major-index array ,@(butlast syms))))) (,',writer/ix-vop (array-data-expr array ,is-vector) ,,index-expression ,step ,+vector-data-fixup+ (the sse-pack ,(car (last syms))))) ,(car (last syms))))))))))) ecl-16.1.2/contrib/cl-simd/sbcl-core.lisp000066400000000000000000000642361266352375300201250ustar00rootroot00000000000000;;; -*- mode: Lisp; indent-tabs-mode: nil; -*- ;;; ;;; Copyright (c) 2010, Alexander Gavrilov (angavrilov@gmail.com) ;;; ;;; This file contains definitions of abstract VOPs, macros ;;; and utility functions used to implement the intrinsics. ;;; (in-package #:SSE) ;;; The specific pack types (deftype int-sse-pack () '(sse-pack integer)) (deftype float-sse-pack () '(sse-pack single-float)) (deftype double-sse-pack () '(sse-pack double-float)) ;;; Helper functions (defconstant +uint32-mask+ #xFFFFFFFF) (defconstant +uint64-mask+ #xFFFFFFFFFFFFFFFF) (defconstant +min-int32+ (- (ash 1 31))) (defconstant +max-int32+ (1- (ash 1 31))) (defun type-name-to-primitive (lt) (primitive-type-name (primitive-type (specifier-type lt)))) (defun move-cmd-for-type (lt) (ecase lt (int-sse-pack 'movdqa) ((float-sse-pack double-sse-pack) 'movaps))) (defun ensure-reg-or-mem (tn) (sc-case tn ((sse-pack-immediate immediate) (register-inline-constant (tn-value tn))) (t tn))) (defmacro ensure-load (type tgt src) `(unless (location= ,tgt ,src) (inst ,(move-cmd-for-type type) ,tgt (ensure-reg-or-mem ,src)))) (defmacro ensure-move (type tgt src) `(unless (location= ,tgt ,src) (inst ,(move-cmd-for-type type) ,tgt ,src))) (defmacro save-intrinsic-spec (name info) `(eval-when (:compile-toplevel :load-toplevel :execute) (setf (get ',name 'intrinsic-spec) ',info))) (defmacro def-splice-transform (name args &body code) (let* ((direct-args (mapcar (lambda (x) (if (consp x) (gensym) x)) args)) (flat-args (mapcan (lambda (x) (if (consp x) (copy-list (rest x)) (list x))) args))) `(deftransform ,name ((,@direct-args) * *) ,(format nil "Simplify combination ~A" (cons name args)) ,@(loop for spec in args and name in direct-args when (consp spec) collect `(splice-fun-args ,name ',(first spec) ,(1- (length spec)))) (list* 'lambda ',flat-args ',code)))) ;;; Index-offset splicing (defun skip-casts (lvar) (let ((inside (lvar-uses lvar))) (if (and (cast-p inside) (policy inside (= sb-c::type-check 0))) (skip-casts (cast-value inside)) lvar))) (defun delete-casts (lvar) (loop for inside = (lvar-uses lvar) while (cast-p inside) do (delete-filter inside lvar (cast-value inside)))) (defun fold-index-addressing (fun-name index scale offset &key prefix-args postfix-args) (multiple-value-bind (func index-args) (extract-fun-args (skip-casts index) '(+ - * ash) 2) (destructuring-bind (x constant) index-args (declare (ignorable x)) (unless (constant-lvar-p constant) (give-up-ir1-transform)) (let ((value (lvar-value constant)) (scale-value (lvar-value scale)) (offset-value (lvar-value offset))) (unless (integerp value) (give-up-ir1-transform)) (multiple-value-bind (new-scale new-offset) (ecase func (+ (values scale-value (+ offset-value (* value scale-value)))) (- (values scale-value (- offset-value (* value scale-value)))) (* (values (* scale-value value) offset-value)) (ash (unless (>= value 0) (give-up-ir1-transform "negative index shift")) (values (ash scale-value value) offset-value))) (unless (and (typep new-scale '(signed-byte 32)) (typep new-offset 'signed-word)) (give-up-ir1-transform "constant is too large for inlining")) (delete-casts index) (splice-fun-args index func 2) `(lambda (,@prefix-args thing index const scale offset ,@postfix-args) (declare (ignore const scale offset)) (,fun-name ,@prefix-args thing (the signed-word index) ,new-scale ,new-offset ,@postfix-args))))))) (deftransform fold-ref-index-addressing ((thing index scale offset) * * :defun-only t :node node) (fold-index-addressing (lvar-fun-name (basic-combination-fun node)) index scale offset)) (deftransform fold-xmm-ref-index-addressing ((value thing index scale offset) * * :defun-only t :node node) (fold-index-addressing (lvar-fun-name (basic-combination-fun node)) index scale offset :prefix-args '(value))) (deftransform fold-set-index-addressing ((thing index scale offset value) * * :defun-only t :node node) (fold-index-addressing (lvar-fun-name (basic-combination-fun node)) index scale offset :postfix-args '(value))) ;;; Index-offset addressing (defun is-tagged-load-scale (value) (not (logtest value (1- (ash 1 n-fixnum-tag-bits))))) (deftype tagged-load-scale () '(and fixnum (satisfies is-tagged-load-scale))) (defun find-lea-scale (scale) (cond ((not (logtest scale 7)) (values (/ scale 8) 8)) ((not (logtest scale 3)) (values (/ scale 4) 4)) ((not (logtest scale 1)) (values (/ scale 2) 2)) (t (values scale 1)))) (defun reduce-offset (ioffset scale offset) "Redistribute value from ioffset to offset, while keeping offset int32." (let* ((istep (if (< ioffset 0) -1 1)) (icount (max 0 (if (< ioffset 0) (- (1+ +min-int32+) ioffset) ; = (- +max-int32+) (- ioffset +max-int32+)))) (ostep (* istep scale)) (ocount (truncate (- (if (> ostep 0) +max-int32+ +min-int32+) offset) ostep)) (count (min ocount icount))) (values (- ioffset (* count istep)) (+ offset (* count ostep))))) (defun split-offset (offset scale) (if (typep offset '(signed-byte 32)) (values 0 offset) (multiple-value-bind (div rem) (floor offset scale) (assert (typep rem '(signed-byte 32))) (if (typep div '(signed-byte 32)) (values div rem) (reduce-offset div scale rem))))) (defun power-of-2? (scale) (and (> scale 0) (not (logtest scale (1- scale))))) (defun find-power-of-2 (scale) (assert (power-of-2? scale)) (loop for i from 0 and sv = scale then (ash sv -1) when (<= sv 1) return i)) (defun make-scaled-ea (size sap index scale offset tmp &key fixnum-index) "Returns an ea representing the given index*scale + offset formula. May emit additional instructions using the temporary register." (assemble () (if (or (sc-is index immediate) (= scale 0)) ;; Fully constant offset (let ((value (if (= scale 0) offset (+ (* (tn-value index) scale) offset)))) (assert (typep value '(signed-byte 64))) (if (typep value '(signed-byte 32)) (make-ea size :base sap :disp value) (progn (inst mov tmp (register-inline-constant value)) (make-ea size :base sap :index tmp)))) ;; Indexing (progn (when (sc-is index any-reg) (assert (and fixnum-index (is-tagged-load-scale scale))) (setf scale (ash scale (- n-fixnum-tag-bits)))) (multiple-value-bind (rscale lscale) (find-lea-scale scale) ;; One-instruction case? (if (and (= rscale 1) (typep offset '(signed-byte 32))) (make-ea size :base sap :index index :scale scale :disp offset) ;; Use temporary (multiple-value-bind (roffset loffset) (split-offset offset lscale) (labels ((negate-when-<0 (register scale) (when (< scale 0) (inst neg register))) (emit-shift-mul (register scale) (inst shl register (find-power-of-2 (abs scale))) (negate-when-<0 register scale)) ;; Tries to compute tmp via LEA (try-use-lea (scale &optional base) (multiple-value-bind (rrscale rlscale) (find-lea-scale scale) (when (and (= (abs rrscale) 1) (typep (* rrscale roffset) '(signed-byte 32))) (when (and (= roffset 0) (null base)) ; minimize loffset (multiple-value-setq (roffset loffset) (floor offset lscale))) (let ((xoffset (* rrscale roffset))) (inst lea tmp (if (and (= rlscale 1) (null base)) (make-ea :byte :base index :disp xoffset) (make-ea :byte :base base :index index :scale rlscale :disp xoffset)))) (negate-when-<0 tmp rrscale) :success)))) (declare (inline negate-when-<0 emit-shift-mul)) (cond ;; same register shift? ((and (= roffset 0) (location= tmp index) (power-of-2? (abs rscale))) (emit-shift-mul tmp rscale)) ;; one LEA? ((try-use-lea rscale)) ((try-use-lea (1- rscale) index)) ;; Generic case, use mul/shl and add (t (if (power-of-2? (abs rscale)) (progn (move tmp index) (emit-shift-mul tmp rscale)) (inst imul tmp index rscale)) (unless (= roffset 0) ;; Make loffset as small as possible (multiple-value-setq (roffset loffset) (floor offset lscale)) (if (typep roffset '(signed-byte 32)) (inst add tmp roffset) (inst add tmp (register-inline-constant roffset)))))) (make-ea size :base sap :index tmp :scale lscale :disp loffset))))))))) ;; Initialization (defmacro def-float-set-intrinsic (&whole whole pubname fname atype aregtype rtype move) (declare (ignore pubname)) `(progn (save-intrinsic-spec ,fname ,whole) (defknown ,fname (,atype) ,rtype (foldable flushable)) (define-vop (,fname) (:translate ,fname) (:args (arg :scs (,aregtype) :target dst)) (:arg-types ,atype) (:results (dst :scs (sse-reg))) (:result-types ,(type-name-to-primitive rtype)) (:policy :fast-safe) (:generator 1 (unless (location= dst arg) (inst ,move dst arg)))))) ;; Unary operations (define-vop (sse-unary-base-op) ;; no immediate because expecting to be folded (:args (x :scs (sse-reg))) (:arg-types sse-pack) (:policy :fast-safe) (:note "inline SSE unary operation") (:vop-var vop) (:save-p :compute-only)) (define-vop (sse-unary-op sse-unary-base-op) (:args (x :scs (sse-reg) :target r)) (:results (r :scs (sse-reg)))) (define-vop (sse-unary-to-int-op sse-unary-base-op) (:results (r :scs (signed-reg)))) (define-vop (sse-unary-to-uint-op sse-unary-base-op) (:results (r :scs (unsigned-reg)))) (defmacro def-unary-intrinsic (&whole whole name rtype insn cost c-name &key partial immediate-arg result-size arg-type) (declare (ignore c-name arg-type)) (let* ((imm (if immediate-arg '(imm))) (immt (if immediate-arg (list immediate-arg)))) (assert (or (not partial) (not (subtypep rtype 'integer)))) `(progn (export ',name) (save-intrinsic-spec ,name ,whole) (defknown ,name (sse-pack ,@immt) ,rtype (foldable flushable)) (define-vop (,name ,(cond ((subtypep rtype 'unsigned-byte) 'sse-unary-to-uint-op) ((subtypep rtype 'integer) 'sse-unary-to-int-op) (t 'sse-unary-op))) (:translate ,name) (:result-types ,(type-name-to-primitive rtype)) ,@(if immediate-arg `((:arg-types sse-pack (:constant ,immediate-arg)) (:info imm))) (:generator ,cost ,@(ecase partial (:one-arg `((ensure-move ,rtype r x) (inst ,insn r ,@imm))) (t `((ensure-move ,rtype r x) (inst ,insn r r ,@imm))) ((nil) `((inst ,insn ,(if result-size `(reg-in-size r ,result-size) 'r) x ,@imm))))))))) ;; Unary to int32 & sign-extend (define-vop (sse-cvt-to-int32-op sse-unary-base-op) (:temporary (:sc signed-reg :offset rax-offset :target r :to :result) rax) (:results (r :scs (signed-reg)))) (defmacro def-cvt-to-int32-intrinsic (name rtype insn cost c-name &key arg-type) (declare (ignore arg-type)) `(progn (export ',name) (save-intrinsic-spec ,name (def-unary-intrinsic ,name ,rtype ,insn ,cost ,c-name)) (defknown ,name (sse-pack) (signed-byte 32) (foldable flushable)) (define-vop (,name sse-cvt-to-int32-op) (:translate ,name) (:result-types ,(type-name-to-primitive rtype)) (:generator ,cost (inst ,insn (reg-in-size rax :dword) x) (inst cdqe) (move r rax))))) ;; NOT intrinsics (define-vop (sse-not-op sse-unary-op) (:temporary (:sc sse-reg) tmp)) (defmacro def-not-intrinsic (name rtype insn) `(progn (export ',name) (save-intrinsic-spec ,name (def-unary-intrinsic ,name ,rtype ,insn 3 nil)) (defknown ,name (sse-pack) ,rtype (foldable flushable)) (define-vop (,name sse-not-op) (:translate ,name) (:result-types ,(type-name-to-primitive rtype)) (:generator 3 (if (location= x r) (progn (inst pcmpeqd tmp tmp) (inst ,insn r tmp)) (progn (inst pcmpeqd r r) (inst ,insn r x))))))) ;; Binary operations (define-vop (sse-binary-base-op) (:args (x :scs (sse-reg sse-pack-immediate) :target r) (y :scs (sse-reg sse-pack-immediate))) (:results (r :scs (sse-reg))) (:arg-types sse-pack sse-pack) (:policy :fast-safe) (:note "inline SSE binary operation") (:vop-var vop) (:save-p :compute-only)) (define-vop (sse-binary-op sse-binary-base-op) (:temporary (:sc sse-reg) tmp)) (define-vop (sse-binary-comm-op sse-binary-base-op) (:args (x :scs (sse-reg sse-pack-immediate) :target r) (y :scs (sse-reg sse-pack-immediate) :target r))) (defmacro def-binary-intrinsic (&whole whole name rtype insn cost c-name &key commutative tags immediate-arg x-type y-type) (declare (ignore c-name x-type y-type)) (let* ((imm (if immediate-arg '(imm))) (immt (if immediate-arg (list immediate-arg)))) `(progn (export ',name) (save-intrinsic-spec ,name ,whole) (defknown ,name (sse-pack sse-pack ,@immt) ,rtype (foldable flushable)) (define-vop (,name ,(if commutative 'sse-binary-comm-op 'sse-binary-op)) (:translate ,name) (:result-types ,(type-name-to-primitive rtype)) ,@(if immediate-arg `((:arg-types sse-pack sse-pack (:constant ,immediate-arg)) (:info imm))) (:generator ,cost ,@(if commutative `((when (location= y r) (rotatef x y)) (ensure-load ,rtype r x) (inst ,insn ,@tags r (ensure-reg-or-mem y) ,@imm)) `((unless (location= y r) (setf tmp r)) (ensure-load ,rtype tmp x) (inst ,insn ,@tags tmp (ensure-reg-or-mem y) ,@imm) (ensure-move ,rtype r tmp)))))))) ;;; XMM/Integer combination intrinsics (define-vop (sse-int-base-op) (:results (r :scs (sse-reg))) (:policy :fast-safe) (:note "inline SSE/integer operation") (:vop-var vop) (:save-p :compute-only)) (define-vop (sse-int-op sse-int-base-op) (:args (x :scs (sse-reg sse-pack-immediate) :target r) (iv :scs (signed-reg signed-stack immediate))) (:arg-types sse-pack signed-num)) (define-vop (sse-uint-op sse-int-base-op) (:args (x :scs (sse-reg sse-pack-immediate) :target r) (iv :scs (unsigned-reg unsigned-stack immediate))) (:arg-types sse-pack unsigned-num)) (defmacro def-sse-int-intrinsic (&whole whole name itype rtype insn cost c-name &key make-temporary immediate-arg defun-body) (declare (ignore c-name defun-body)) (let* ((imm (if immediate-arg '(imm))) (immt (if immediate-arg (list immediate-arg))) (unsigned? (subtypep itype 'unsigned-byte))) `(progn (export ',name) (save-intrinsic-spec ,name ,whole) (defknown ,name (sse-pack ,itype ,@immt) ,rtype (foldable flushable)) (define-vop (,name ,(if unsigned? 'sse-uint-op 'sse-int-op)) (:translate ,name) (:result-types ,(type-name-to-primitive rtype)) ,@(if immediate-arg `((:arg-types sse-pack ,(if unsigned? 'unsigned-num 'signed-num) (:constant ,immediate-arg)) (:info imm))) ,@(if make-temporary `((:temporary (:sc sse-reg) tmp))) (:generator ,cost (ensure-load ,rtype r x) ,@(if (eq make-temporary t) '((inst movd tmp (ensure-reg-or-mem iv))) make-temporary) (inst ,insn r ,(if make-temporary 'tmp '(ensure-reg-or-mem iv)) ,@imm)))))) ;;; Comparison predicate intrinsics (define-vop (sse-comparison-op) (:args (x :scs (sse-reg)) (y :scs (sse-reg sse-pack-immediate))) (:arg-types sse-pack sse-pack) (:policy :fast-safe) (:note "inline SSE binary comparison predicate") (:vop-var vop) (:save-p :compute-only)) (define-vop (sse-comparison-comm-op sse-comparison-op) (:args (x :scs (sse-reg) :load-if (not (and (sc-is x sse-pack-immediate) (sc-is y sse-reg)))) (y :scs (sse-reg sse-pack-immediate)))) (defmacro def-comparison-intrinsic (&whole whole name arg-type insn cost c-name &key commutative tags) (declare (ignore arg-type c-name)) (let* () `(progn (export ',name) (save-intrinsic-spec ,name ,whole) (defknown ,name (sse-pack sse-pack) boolean (foldable flushable)) (define-vop (,name ,(if commutative 'sse-comparison-comm-op 'sse-comparison-op)) (:translate ,name) (:conditional ,@tags) (:generator ,cost ,(if commutative `(if (sc-is x sse-reg) (inst ,insn x y) (inst ,insn y x)) `(inst ,insn x y))))))) ;;; Memory intrinsics (define-vop (sse-load-base-op) (:results (r :scs (sse-reg))) (:policy :fast-safe) (:note "inline SSE load operation")) (define-vop (sse-load-op sse-load-base-op) (:args (sap :scs (sap-reg) :to :eval) (index :scs (signed-reg immediate) :target tmp)) (:arg-types system-area-pointer signed-num (:constant fixnum) (:constant signed-word)) (:temporary (:sc signed-reg :from (:argument 1)) tmp) (:info scale offset)) (define-vop (sse-load-op/tag sse-load-base-op) (:args (sap :scs (sap-reg) :to :eval) (index :scs (any-reg signed-reg immediate) :target tmp)) (:arg-types system-area-pointer tagged-num (:constant tagged-load-scale) (:constant signed-word)) (:temporary (:sc any-reg :from (:argument 1)) tmp) (:info scale offset)) (define-vop (sse-xmm-load-op sse-load-base-op) (:args (value :scs (sse-reg sse-pack-immediate) :target r) (sap :scs (sap-reg) :to :eval) (index :scs (signed-reg immediate) :target tmp)) (:arg-types sse-pack system-area-pointer signed-num (:constant fixnum) (:constant signed-word)) (:temporary (:sc signed-reg :from (:argument 2)) tmp) (:info scale offset)) (define-vop (sse-xmm-load-op/tag sse-load-base-op) (:args (value :scs (sse-reg sse-pack-immediate) :target r) (sap :scs (sap-reg) :to :eval) (index :scs (any-reg signed-reg immediate) :target tmp)) (:arg-types sse-pack system-area-pointer tagged-num (:constant tagged-load-scale) (:constant signed-word)) (:temporary (:sc any-reg :from (:argument 2)) tmp) (:info scale offset)) (define-vop (sse-load-ix-op sse-load-base-op) (:args (sap :scs (descriptor-reg) :to :eval) (index :scs (signed-reg immediate) :target tmp)) (:arg-types * signed-num (:constant fixnum) (:constant signed-word)) (:temporary (:sc signed-reg :from (:argument 1)) tmp) (:info scale offset)) (define-vop (sse-load-ix-op/tag sse-load-base-op) (:args (sap :scs (descriptor-reg) :to :eval) (index :scs (any-reg signed-reg immediate) :target tmp)) (:arg-types * tagged-num (:constant tagged-load-scale) (:constant signed-word)) (:temporary (:sc any-reg :from (:argument 1)) tmp) (:info scale offset)) (defmacro def-load-intrinsic (&whole whole name rtype insn c-name &key register-arg tags postfix-fmt (size :qword)) (declare (ignore c-name postfix-fmt)) (let* ((vop (symbolicate "%" name)) (ix-vop (symbolicate vop "/IX")) (valtype (if register-arg '(sse-pack))) (r-arg (if rtype '(r))) (rtypes (if rtype `(:result-types ,(type-name-to-primitive rtype)) `(:results)))) (assert (or rtype (not register-arg))) `(progn (export ',name) (save-intrinsic-spec ,name ,whole) (defknown ,vop (,@valtype system-area-pointer signed-word fixnum signed-word) ,(or rtype '(values)) (flushable always-translatable)) (define-vop (,vop ,(if register-arg 'sse-xmm-load-op 'sse-load-op)) (:translate ,vop) ,rtypes (:generator 5 ,(if register-arg `(ensure-load ,rtype r value)) (inst ,insn ,@tags ,@r-arg (make-scaled-ea ,size sap index scale offset tmp)))) (define-vop (,(symbolicate vop "/TAG") ,(if register-arg 'sse-xmm-load-op/tag 'sse-load-op/tag)) (:translate ,vop) ,rtypes (:generator 4 ,(if register-arg `(ensure-load ,rtype r value)) (inst ,insn ,@tags ,@r-arg (make-scaled-ea ,size sap index scale offset tmp :fixnum-index t)))) (%deftransform ',vop '(function * *) #',(if register-arg 'fold-xmm-ref-index-addressing 'fold-ref-index-addressing) "fold semi-constant offset expressions") ,@(if (null register-arg) `(;; Vector indexing version (defknown ,ix-vop (simple-array signed-word fixnum signed-word) ,(or rtype '(values)) (flushable always-translatable)) (define-vop (,ix-vop sse-load-ix-op) (:translate ,ix-vop) ,rtypes (:generator 4 (inst ,insn ,@tags ,@r-arg (make-scaled-ea ,size sap index scale offset tmp)))) (define-vop (,(symbolicate ix-vop "/TAG") sse-load-ix-op/tag) (:translate ,ix-vop) ,rtypes (:generator 3 (inst ,insn ,@tags ,@r-arg (make-scaled-ea ,size sap index scale offset tmp :fixnum-index t)))) (%deftransform ',ix-vop '(function * *) #'fold-ref-index-addressing "fold semi-constant index expressions")))))) (define-vop (sse-store-base-op) (:policy :fast-safe) (:note "inline SSE store operation")) (define-vop (sse-store-op sse-store-base-op) (:args (sap :scs (sap-reg) :to :eval) (index :scs (signed-reg immediate) :target tmp) (value :scs (sse-reg))) (:arg-types system-area-pointer signed-num (:constant fixnum) (:constant signed-word) sse-pack) (:temporary (:sc signed-reg :from (:argument 1)) tmp) (:info scale offset)) (define-vop (sse-store-op/tag sse-store-base-op) (:args (sap :scs (sap-reg) :to :eval) (index :scs (any-reg signed-reg immediate) :target tmp) (value :scs (sse-reg))) (:arg-types system-area-pointer tagged-num (:constant tagged-load-scale) (:constant signed-word) sse-pack) (:temporary (:sc any-reg :from (:argument 1)) tmp) (:info scale offset)) (define-vop (sse-store-ix-op sse-store-base-op) (:args (sap :scs (descriptor-reg) :to :eval) (index :scs (signed-reg immediate) :target tmp) (value :scs (sse-reg))) (:arg-types * signed-num (:constant fixnum) (:constant signed-word) sse-pack) (:temporary (:sc signed-reg :from (:argument 1)) tmp) (:info scale offset)) (define-vop (sse-store-ix-op/tag sse-store-base-op) (:args (sap :scs (descriptor-reg) :to :eval) (index :scs (any-reg signed-reg immediate) :target tmp) (value :scs (sse-reg))) (:arg-types * tagged-num (:constant tagged-load-scale) (:constant signed-word) sse-pack) (:temporary (:sc any-reg :from (:argument 1)) tmp) (:info scale offset)) (defmacro def-store-intrinsic (&whole whole name rtype insn c-name &key setf-name) (declare (ignore rtype c-name)) (let* ((vop (symbolicate "%" name)) (ix-vop (symbolicate vop "/IX"))) `(progn ,(unless setf-name `(export ',name)) (save-intrinsic-spec ,name ,whole) (defknown ,vop (system-area-pointer signed-word fixnum signed-word sse-pack) (values) (unsafe always-translatable)) (define-vop (,vop sse-store-op) (:translate ,vop) (:generator 5 (inst ,insn (make-scaled-ea :qword sap index scale offset tmp) value))) (define-vop (,(symbolicate vop "/TAG") sse-store-op/tag) (:translate ,vop) (:generator 4 (inst ,insn (make-scaled-ea :qword sap index scale offset tmp :fixnum-index t) value))) (%deftransform ',vop '(function * *) #'fold-set-index-addressing "fold semi-constant offset expressions") ;; Vector indexing version (defknown ,ix-vop (simple-array signed-word fixnum signed-word sse-pack) (values) (unsafe always-translatable)) (define-vop (,ix-vop sse-store-ix-op) (:translate ,ix-vop) (:generator 4 (inst ,insn (make-scaled-ea :qword sap index scale offset tmp) value))) (define-vop (,(symbolicate ix-vop "/TAG") sse-store-ix-op/tag) (:translate ,ix-vop) (:generator 3 (inst ,insn (make-scaled-ea :qword sap index scale offset tmp :fixnum-index t) value))) (%deftransform ',ix-vop '(function * *) #'fold-set-index-addressing "fold semi-constant index expressions")))) ecl-16.1.2/contrib/cl-simd/sbcl-functions.lisp000066400000000000000000000430451266352375300212000ustar00rootroot00000000000000;;; -*- mode: Lisp; indent-tabs-mode: nil; -*- ;;; ;;; Copyright (c) 2010, Alexander Gavrilov (angavrilov@gmail.com) ;;; ;;; This file implements VOP-wrapping functions and non-primitive ;;; extensions to the core intrinsic set. ;;; (in-package #:SSE) ;;; Materialize the intrinsic functions. ;; Since VOPs are activated only on load, actual functions that ;; wrap them have to be defined in a different file. This is a ;; hack to generate the functions from the same macro invocations ;; as the VOPS. (macrolet ((def-float-set-intrinsic (pubname fname atype aregtype rtype move) (declare (ignore aregtype move)) `(progn (defun ,fname (arg) (declare (type ,atype arg)) (truly-the ,rtype (%primitive ,fname arg))) ;; Public function - includes coercion (export ',pubname) (declaim (ftype (function (real) ,rtype) ,pubname) (inline ,pubname)) (defun ,pubname (arg) (,fname (coerce arg ',atype))))) (def-unary-intrinsic (name rtype insn cost c-name &key immediate-arg &allow-other-keys) (declare (ignore insn cost c-name)) (unless immediate-arg `(defun ,name (x) (declare (type sse-pack x)) (truly-the ,rtype (%primitive ,name x))))) (def-binary-intrinsic (name rtype insn cost c-name &key immediate-arg &allow-other-keys) (declare (ignore insn cost c-name)) (unless immediate-arg `(defun ,name (x y ,@(if immediate-arg '(imm))) (declare (type sse-pack x y)) (truly-the ,rtype (%primitive ,name x y))))) (def-sse-int-intrinsic (name itype rtype insn cost c-name &key immediate-arg &allow-other-keys) (declare (ignore insn cost c-name)) (unless immediate-arg `(defun ,name (x iv) (declare (type sse-pack x) (type ,itype iv)) (truly-the ,rtype (%primitive ,name x iv))))) (def-comparison-intrinsic (name arg-type insn cost c-name &key &allow-other-keys) (declare (ignore insn cost c-name arg-type)) `(defun ,name (x y) (declare (type sse-pack x y)) (truly-the boolean (,name x y)))) (def-load-intrinsic (name rtype insn c-name &key register-arg &allow-other-keys) (declare (ignore insn c-name)) (let* ((vop (symbolicate "%" name)) (valarg (if register-arg '(value)))) `(progn (declaim (inline ,name)) (defun ,name (,@valarg pointer &optional (offset 0)) (declare ,@(if register-arg '((type sse-pack value))) (type system-area-pointer pointer) (type signed-word offset)) ,(if rtype `(truly-the ,rtype (,vop ,@valarg pointer offset 1 0)) `(,vop ,@valarg pointer offset 1 0)))))) (def-store-intrinsic (name rtype insn c-name &key setf-name &allow-other-keys) (declare (ignore insn c-name)) (let* ((vop (symbolicate "%" name))) `(progn (declaim (inline ,name)) (defun ,name (pointer value &optional (offset 0)) (declare (type system-area-pointer pointer) (type sse-pack value) (type signed-word offset)) (,vop pointer offset 1 0 value) (truly-the ,rtype value)) ,(if setf-name `(defsetf ,setf-name (pointer &optional (offset 0)) (value) `(,',name ,pointer ,value ,offset))))))) ;; Load the definition list #.(loop for name being each present-symbol when (get name 'intrinsic-spec) collect it into specs finally (return `(progn ,@specs)))) ;;; Helper functions and macros (defmacro def-utility (name args rtype &body code) `(progn (export ',name) (declaim (ftype (function ,(mapcar (constantly 'sse-pack) args) ,rtype) ,name) (inline ,name)) (defun ,name ,args ,@code))) (defmacro def-if-function (name rtype postfix) (let* ((not-x (symbolicate "NOT-" postfix)) (or-x (symbolicate "OR-" postfix)) (and-x (symbolicate "AND-" postfix)) (andn-x (symbolicate "ANDNOT-" postfix)) (xor-x (symbolicate "XOR-" postfix)) (true (%make-sse-pack #xFFFFFFFFFFFFFFFF #xFFFFFFFFFFFFFFFF)) (false (%make-sse-pack 0 0))) `(progn (export ',name) (defknown ,name (sse-pack sse-pack sse-pack) ,rtype (foldable flushable)) (defun ,name (condition true-val false-val) (,or-x (,and-x condition true-val) (,andn-x condition false-val))) ;; Instead of inlining, use a transform so that the splice ;; rule has a chance to apply. This depends on transform ;; definitions behaving like a LIFO: (deftransform ,name ((condition true-val false-val) * *) "Expand the conditional." '(,or-x (,and-x condition true-val) (,andn-x condition false-val))) (def-splice-transform ,name ((,not-x cond) tv fv) (,name cond fv tv)) ;; NOT elimination and partial constant folding for bitwise ops: (def-splice-transform ,not-x ((,not-x arg1)) arg1) (def-splice-transform ,and-x (arg1 (,not-x arg2)) (,andn-x arg2 arg1)) (def-splice-transform ,and-x ((,not-x arg1) arg2) (,andn-x arg1 arg2)) (def-splice-transform ,andn-x ((,not-x arg1) arg2) (,and-x arg1 arg2)) (%deftransform ',or-x '(function * *) #'commutative-arg-swap "place constant arg last") (%deftransform ',and-x '(function * *) #'commutative-arg-swap "place constant arg last") (%deftransform ',xor-x '(function * *) #'commutative-arg-swap "place constant arg last") (deftransform ,or-x ((arg1 arg2) (* (constant-arg (member ,true))) *) ,true) (deftransform ,or-x ((arg1 arg2) (* (constant-arg (member ,false))) *) 'arg1) (deftransform ,and-x ((arg1 arg2) (* (constant-arg (member ,true))) *) 'arg1) (deftransform ,and-x ((arg1 arg2) (* (constant-arg (member ,false))) *) ,false) (deftransform ,xor-x ((arg1 arg2) (* (constant-arg (member ,false))) *) 'arg1) (deftransform ,andn-x ((arg1 arg2) (* (constant-arg (member ,true))) *) 'arg1) (deftransform ,andn-x ((arg1 arg2) (* (constant-arg (member ,false))) *) ,false) (deftransform ,andn-x ((arg1 arg2) ((constant-arg (member ,true)) *) *) ,false) (deftransform ,andn-x ((arg1 arg2) ((constant-arg (member ,false)) *) *) 'arg2)))) (defmacro def-not-cmp-pairs (not-fun &rest pairs) `(progn ,@(loop for (a b) on pairs by #'cddr collect `(def-splice-transform ,not-fun ((,a arg1 arg2)) (,b arg1 arg2)) collect `(def-splice-transform ,not-fun ((,b arg1 arg2)) (,a arg1 arg2))))) ;;; CPU control (defun cpu-mxcsr () (cpu-mxcsr)) (defun %set-cpu-mxcsr (x) (declare (type (unsigned-byte 32) x)) (%set-cpu-mxcsr x)) (defsetf cpu-mxcsr %set-cpu-mxcsr) (defun cpu-load-fence () (cpu-load-fence)) (defun cpu-store-fence () (cpu-store-fence)) (defun cpu-memory-fence () (cpu-memory-fence)) (defun cpu-pause () (cpu-pause)) ;;; Single-float ;; Constants (define-symbol-macro 0.0-ps (truly-the float-sse-pack #.(%make-sse-pack 0 0))) (define-symbol-macro true-ss (truly-the float-sse-pack #.(%make-sse-pack #xFFFFFFFF 0))) (define-symbol-macro true-ps (truly-the float-sse-pack #.(%make-sse-pack #xFFFFFFFFFFFFFFFF #xFFFFFFFFFFFFFFFF))) (define-symbol-macro false-ss (truly-the float-sse-pack #.(%make-sse-pack 0 0))) (define-symbol-macro false-ps (truly-the float-sse-pack #.(%make-sse-pack 0 0))) ;; Initialization (declaim (inline set1-ps set-ps setr-ps setzero-ps)) (defun set1-ps (val) (let ((valv (set-ss val))) (shuffle-ps valv valv 0))) (defun set-ps (x3 x2 x1 x0) (movelh-ps (unpacklo-ps (set-ss x0) (set-ss x1)) (unpacklo-ps (set-ss x2) (set-ss x3)))) (defun setr-ps (x0 x1 x2 x3) (movelh-ps (unpacklo-ps (set-ss x0) (set-ss x1)) (unpacklo-ps (set-ss x2) (set-ss x3)))) (defun setzero-ps () 0.0-ps) ;; Arithmetic negation (def-utility neg-ss (arg) float-sse-pack (xor-ps arg #.(%make-sse-pack #x80000000 0))) (def-utility neg-ps (arg) float-sse-pack (xor-ps arg #.(%make-sse-pack #x8000000080000000 #x8000000080000000))) ;; Bitwise operations (def-if-function if-ps float-sse-pack #:ps) ;; Comparisons (def-utility >-ss (x y) float-sse-pack (<-ss y x)) (def-utility >-ps (x y) float-sse-pack (<-ps y x)) (def-utility >=-ss (x y) float-sse-pack (<=-ss y x)) (def-utility >=-ps (x y) float-sse-pack (<=-ps y x)) (def-utility />-ss (x y) float-sse-pack (/<-ss y x)) (def-utility />-ps (x y) float-sse-pack (/<-ps y x)) (def-utility />=-ss (x y) float-sse-pack (/<=-ss y x)) (def-utility />=-ps (x y) float-sse-pack (/<=-ps y x)) (def-not-cmp-pairs not-ps =-ps /=-ps <-ps /<-ps <=-ps /<=-ps >-ps />-ps >=-ps />=-ps cmpord-ps cmpunord-ps) ;; Shuffle (declaim (inline %sse-pack-to-int %int-to-sse-pack %shuffle-subints)) (defun %sse-pack-to-int (pack) (logior (%sse-pack-low pack) (ash (%sse-pack-high pack) 64))) (defun %int-to-sse-pack (val &aux (mask #xFFFFFFFFFFFFFFFF)) (%make-sse-pack (logand val mask) (logand (ash val -64) mask))) (defun %shuffle-subints (xval yval imm bit-cnt &aux (mask (1- (ash 1 bit-cnt)))) (flet ((bits (idx) (logand 3 (ash imm (* -2 idx)))) (val (src idx) (logand mask (ash src (* (- bit-cnt) idx))))) (logior (val xval (bits 0)) (ash (val xval (bits 1)) bit-cnt) (ash (val yval (bits 2)) (* 2 bit-cnt)) (ash (val yval (bits 3)) (* 3 bit-cnt))))) (defun shuffle-ps (x y imm) (declare (type sse-pack x y)) (let* ((xval (%sse-pack-to-int x)) (yval (%sse-pack-to-int y))) (truly-the float-sse-pack (%int-to-sse-pack (%shuffle-subints xval yval imm 32))))) ;;; Double-float ;; Constants (define-symbol-macro 0.0-pd (truly-the double-sse-pack #.(%make-sse-pack 0 0))) (define-symbol-macro true-sd (truly-the double-sse-pack #.(%make-sse-pack #xFFFFFFFFFFFFFFFF 0))) (define-symbol-macro true-pd (truly-the double-sse-pack #.(%make-sse-pack #xFFFFFFFFFFFFFFFF #xFFFFFFFFFFFFFFFF))) (define-symbol-macro false-sd (truly-the double-sse-pack #.(%make-sse-pack 0 0))) (define-symbol-macro false-pd (truly-the double-sse-pack #.(%make-sse-pack 0 0))) ;; Initialization (declaim (inline set1-pd set-pd setr-pd setzero-pd)) (defun set1-pd (val) (let ((valv (set-sd val))) (shuffle-pd valv valv 0))) (defun set-pd (x1 x0) (unpacklo-pd (set-sd x0) (set-sd x1))) (defun setr-pd (x0 x1) (unpacklo-pd (set-sd x0) (set-sd x1))) (defun setzero-pd () 0.0-pd) ;; Arithmetic negation (def-utility neg-sd (arg) double-sse-pack (xor-pd arg #.(%make-sse-pack #x8000000000000000 0))) (def-utility neg-pd (arg) double-sse-pack (xor-pd arg #.(%make-sse-pack #x8000000000000000 #x8000000000000000))) ;; Bitwise operations (def-if-function if-pd double-sse-pack #:pd) ;; Comparisons (def-utility >-sd (x y) double-sse-pack (<-sd y x)) (def-utility >-pd (x y) double-sse-pack (<-pd y x)) (def-utility >=-sd (x y) double-sse-pack (<=-sd y x)) (def-utility >=-pd (x y) double-sse-pack (<=-pd y x)) (def-utility />-sd (x y) double-sse-pack (/<-sd y x)) (def-utility />-pd (x y) double-sse-pack (/<-pd y x)) (def-utility />=-sd (x y) double-sse-pack (/<=-sd y x)) (def-utility />=-pd (x y) double-sse-pack (/<=-pd y x)) (def-not-cmp-pairs not-pd =-pd /=-pd <-pd /<-pd <=-pd /<=-pd >-pd />-pd >=-pd />=-pd cmpord-pd cmpunord-pd) ;; Shuffle (defun shuffle-pd (x y imm) (declare (type sse-pack x y)) (truly-the double-sse-pack (%make-sse-pack (if (logtest imm 1) (%sse-pack-high x) (%sse-pack-low x)) (if (logtest imm 2) (%sse-pack-high y) (%sse-pack-low y))))) ;;; Integer ;; Constants (define-symbol-macro 0-pi (truly-the int-sse-pack #.(%make-sse-pack 0 0))) (define-symbol-macro true-pi (truly-the int-sse-pack #.(%make-sse-pack #xFFFFFFFFFFFFFFFF #xFFFFFFFFFFFFFFFF))) (define-symbol-macro false-pi (truly-the int-sse-pack #.(%make-sse-pack 0 0))) ;; Initialization (macrolet ((defset (name type) `(defun ,name (x) (declare (type ,type x)) (,name x)))) (defset %set-int (signed-byte 64)) (defset %set-uint (unsigned-byte 64)) (defset convert-si32-to-pi (signed-byte 32)) (defset convert-su32-to-pi (unsigned-byte 32)) (defset convert-si64-to-pi (signed-byte 64)) (defset convert-su64-to-pi (unsigned-byte 64))) (macrolet ((defset1 (name setter type shuffle &rest expands) `(progn (export ',name) (declaim (inline ,name)) (defun ,name (arg) (let ((val (,setter (the ,type arg)))) (declare (type int-sse-pack val)) ,@(loop for x in expands collect `(setq val (,x val val))) (shuffle-pi32 val ,shuffle)))))) (defset1 set1-pi8 %set-int fixnum #4r0000 unpacklo-pi8 unpacklo-pi16) (defset1 set1-pi16 %set-int fixnum #4r0000 unpacklo-pi16) (defset1 set1-pi32 %set-int (signed-byte 32) #4r0000) (defset1 set1-pu32 %set-uint (unsigned-byte 32) #4r0000) (defset1 set1-pi64 %set-int (signed-byte 64) #4r1010) (defset1 set1-pu64 %set-uint (unsigned-byte 64) #4r1010)) (macrolet ((defset (name rname setter type depth) (let* ((names (loop for i from 0 below (ash 1 depth) collect (symbolicate (format nil "X~A" i)))) (funcs #(unpacklo-pi64 unpacklo-pi32 unpacklo-pi16 unpacklo-pi8)) (body (loop for i downfrom depth to 0 for bv = (mapcar (lambda (x) `(,setter (the ,type ,x))) names) then (loop for (a b) on bv by #'cddr collect `(,(svref funcs i) ,a ,b)) finally (return (first bv))))) `(progn (export ',name) (export ',rname) (declaim (inline ,name ,rname)) (defun ,name (,@(reverse names)) ,body) (defun ,rname (,@names) ,body))))) (defset set-pi8 setr-pi8 %set-int fixnum 4) (defset set-pi16 setr-pi16 %set-int fixnum 3) (defset set-pi32 setr-pi32 %set-int (signed-byte 32) 2) (defset set-pu32 setr-pu32 %set-uint (unsigned-byte 32) 2) (defset set-pi64 setr-pi64 %set-int (signed-byte 64) 1) (defset set-pu64 setr-pu64 %set-uint (unsigned-byte 64) 1)) (declaim (inline setzero-pi)) (defun setzero-pi () 0-pi) ;; Masked move (export 'maskmoveu-pi) (declaim (inline maskmoveu-pi)) (defun maskmoveu-pi (value mask pointer &optional (offset 0)) (declare (type sse-pack value mask) (type system-area-pointer pointer) (type fixnum offset)) (%maskmoveu-pi value mask pointer offset)) ;; Arithmetic negation (subtract from 0) (macrolet ((frob (name subf) `(def-utility ,name (arg) int-sse-pack (,subf 0-pi arg)))) (frob neg-pi8 sub-pi8) (frob neg-pi16 sub-pi16) (frob neg-pi32 sub-pi32) (frob neg-pi64 sub-pi64)) ;; Bitwise operations (def-if-function if-pi int-sse-pack #:pi) ;; Comparisons (def-utility <-pi8 (x y) int-sse-pack (>-pi8 y x)) (def-utility <-pi16 (x y) int-sse-pack (>-pi16 y x)) (def-utility <-pi32 (x y) int-sse-pack (>-pi32 y x)) (def-utility <=-pi8 (x y) int-sse-pack (not-pi (>-pi8 x y))) (def-utility <=-pi16 (x y) int-sse-pack (not-pi (>-pi16 x y))) (def-utility <=-pi32 (x y) int-sse-pack (not-pi (>-pi32 x y))) (def-utility >=-pi8 (x y) int-sse-pack (not-pi (>-pi8 y x))) (def-utility >=-pi16 (x y) int-sse-pack (not-pi (>-pi16 y x))) (def-utility >=-pi32 (x y) int-sse-pack (not-pi (>-pi32 y x))) (def-utility /=-pi8 (x y) int-sse-pack (not-pi (=-pi8 x y))) (def-utility /=-pi16 (x y) int-sse-pack (not-pi (=-pi16 x y))) (def-utility /=-pi32 (x y) int-sse-pack (not-pi (=-pi32 x y))) ;; Shifts (defun slli-pi (x imm) (declare (type sse-pack x)) (truly-the int-sse-pack (if (> imm 15) 0-pi (%int-to-sse-pack (ash (%sse-pack-to-int x) (* 8 imm)))))) (defun srli-pi (x imm) (declare (type sse-pack x)) (truly-the int-sse-pack (if (> imm 15) 0-pi (%int-to-sse-pack (ash (%sse-pack-to-int x) (* -8 imm)))))) ;; Extract & insert (defun extract-pi16 (x imm) (declare (type sse-pack x)) (logand #xFFFF (ash (%sse-pack-to-int x) (- (* 16 (logand imm 7)))))) (defun insert-pi16 (x intv imm) (declare (type sse-pack x)) (let ((shift (* 16 (logand imm 7)))) (truly-the int-sse-pack (%int-to-sse-pack (logior (logand (%sse-pack-to-int x) (lognot (ash #xFFFF shift))) (ash (logand intv #xFFFF) shift)))))) ;; Shuffle (defun shuffle-pi32 (x imm) (declare (type sse-pack x)) (let* ((xval (%sse-pack-to-int x))) (truly-the int-sse-pack (%int-to-sse-pack (%shuffle-subints xval xval imm 32))))) (defun shufflelo-pi16 (x imm) (declare (type sse-pack x)) (let* ((xval (%sse-pack-low x))) (truly-the int-sse-pack (%make-sse-pack (%shuffle-subints xval xval imm 16) (%sse-pack-high x))))) (defun shufflehi-pi16 (x imm) (declare (type sse-pack x)) (let* ((xval (%sse-pack-high x))) (truly-the int-sse-pack (%make-sse-pack (%sse-pack-low x) (%shuffle-subints xval xval imm 16))))) ecl-16.1.2/contrib/cl-simd/sse-array-defs.lisp000066400000000000000000000040311266352375300210640ustar00rootroot00000000000000;;; -*- mode: Lisp; indent-tabs-mode: nil; -*- ;;; ;;; Copyright (c) 2010, Alexander Gavrilov (angavrilov@gmail.com) ;;; ;;; This file contains definitions for vectorized access ;;; to specialized lisp arrays. ;;; (in-package #:SSE) ;;; Prefetch: AREF-PREFETCH-*, ROW-MAJOR-AREF-PREFETCH-* (def-aref-intrinsic #:PREFETCH-T0 nil cpu-prefetch-t0 nil :ref-size 0) (def-aref-intrinsic #:PREFETCH-T1 nil cpu-prefetch-t1 nil :ref-size 0) (def-aref-intrinsic #:PREFETCH-T2 nil cpu-prefetch-t2 nil :ref-size 0) (def-aref-intrinsic #:PREFETCH-NTA nil cpu-prefetch-nta nil :ref-size 0) (def-aref-intrinsic #:CLFLUSH nil cpu-clflush nil :ref-size 1) ;;; Single-float ;; AREF-SS, ROW-MAJOR-AREF-SS (def-aref-intrinsic #:SS float-sse-pack mem-ref-ss mem-set-ss :ref-size 4) ;; AREF-PS, ROW-MAJOR-AREF-PS (def-aref-intrinsic #:PS float-sse-pack mem-ref-ps mem-set-ps) ;; AREF-APS, ROW-MAJOR-AREF-APS (requires alignment) (def-aref-intrinsic #:APS float-sse-pack mem-ref-aps mem-set-aps) ;; AREF-SPS, ROW-MAJOR-AREF-SPS (requires alignment; no write cache) (def-aref-intrinsic #:SPS float-sse-pack mem-ref-aps stream-ps) ;;; Double-float ;; AREF-SD, ROW-MAJOR-AREF-SD (def-aref-intrinsic #:SD double-sse-pack mem-ref-sd mem-set-sd :ref-size 8) ;; AREF-PD, ROW-MAJOR-AREF-PD (def-aref-intrinsic #:PD double-sse-pack mem-ref-pd mem-set-pd) ;; AREF-APD, ROW-MAJOR-AREF-APD (requires alignment) (def-aref-intrinsic #:APD double-sse-pack mem-ref-apd mem-set-apd) ;; AREF-SPD, ROW-MAJOR-AREF-SPD (requires alignment; no write cache) (def-aref-intrinsic #:SPD double-sse-pack mem-ref-apd stream-pd) ;;; Integer ;; AREF-SI64, ROW-MAJOR-AREF-SI64 (def-aref-intrinsic #:SI64 int-sse-pack mem-ref-si64 mem-set-si64 :ref-size 8) ;; AREF-PI, ROW-MAJOR-AREF-PI (def-aref-intrinsic #:PI int-sse-pack mem-ref-pi mem-set-pi) ;; AREF-API, ROW-MAJOR-AREF-API (requires alignment) (def-aref-intrinsic #:API int-sse-pack mem-ref-api mem-set-api) ;; AREF-SPI, ROW-MAJOR-AREF-SPI (requires alignment; no write cache) (def-aref-intrinsic #:SPI int-sse-pack mem-ref-api stream-pi) ecl-16.1.2/contrib/cl-simd/sse-intrinsics.lisp000066400000000000000000001042511266352375300212210ustar00rootroot00000000000000;;; -*- mode: Lisp; indent-tabs-mode: nil; -*- ;;; ;;; Copyright (c) 2010, Alexander Gavrilov (angavrilov@gmail.com) ;;; ;;; This file contains definitions for all SSE intrinsics. ;;; ;;; The macros are defined in the *-core.lisp files. ;;; On SBCL wrapping functions are defined by sbcl-functions.lisp. ;;; (in-package #:SSE) #+(and ecl (or ecl_min stage1 cross)) (eval-when (:compile-toplevel) ;; During the initial bootstrap sequence when the contribs are ;; compiled, the system does not load fasls after building them. ;; (For all it knows, it might be cross-compiling to another architecture.) ;; Work around by loading the macro definition file into the interpreter: (load (merge-pathnames #P"ecl-sse-core.lisp" *compile-file-truename*))) ;;; Prefetch (def-load-intrinsic cpu-prefetch-t0 nil prefetch "_mm_prefetch" :tags (:t0) :size :byte :postfix-fmt ",_MM_HINT_T0") (def-load-intrinsic cpu-prefetch-t1 nil prefetch "_mm_prefetch" :tags (:t1) :size :byte :postfix-fmt ",_MM_HINT_T1") (def-load-intrinsic cpu-prefetch-t2 nil prefetch "_mm_prefetch" :tags (:t2) :size :byte :postfix-fmt ",_MM_HINT_T2") (def-load-intrinsic cpu-prefetch-nta nil prefetch "_mm_prefetch" :tags (:nta) :size :byte :postfix-fmt ",_MM_HINT_NTA") (def-load-intrinsic cpu-clflush nil clflush "_mm_clflush" :size :byte) ;;; CPU control #+sbcl (progn (defknown cpu-mxcsr () (unsigned-byte 32) (flushable)) (define-vop (cpu-mxcsr) (:translate cpu-mxcsr) (:args) (:arg-types) (:results (result :scs (unsigned-reg))) (:result-types unsigned-num) (:temporary (:sc unsigned-stack) tmp) (:policy :fast-safe) (:generator 3 (let ((ea (make-ea :dword :base rbp-tn :disp (frame-byte-offset (tn-offset tmp))))) (inst stmxcsr ea) (inst mov (reg-in-size result :dword) ea)))) (defknown %set-cpu-mxcsr ((unsigned-byte 32)) (unsigned-byte 32) (unsafe)) (define-vop (%set-cpu-mxcsr) (:translate %set-cpu-mxcsr) (:args (value :scs (unsigned-reg unsigned-stack) :target result)) (:arg-types unsigned-num) (:results (result :scs (unsigned-reg) :load-if (not (and (sc-is result unsigned-stack) (or (sc-is value unsigned-reg) (location= value result)))))) (:result-types unsigned-num) (:temporary (:sc unsigned-stack) tmp) (:policy :fast-safe) (:generator 3 (cond ((sc-is value unsigned-stack) (setf tmp value)) ((sc-is result unsigned-stack) (setf tmp result))) (move tmp value) (unless (location= result tmp) (move result value)) (let ((ea (make-ea :dword :base rbp-tn :disp (frame-byte-offset (tn-offset tmp))))) (inst ldmxcsr ea)))) (macrolet ((defvoid (name insn) `(progn (export ',name) (defknown ,name () (values) ()) (define-vop (,name) (:translate ,name) (:policy :fast-safe) (:generator 1 (inst ,insn)))))) (defvoid cpu-load-fence lfence) (defvoid cpu-store-fence sfence) (defvoid cpu-memory-fence mfence) (defvoid cpu-pause pause))) #+ecl (progn (def-intrinsic cpu-mxcsr () fixnum "_mm_getcsr") (def-intrinsic %set-cpu-mxcsr (fixnum) fixnum "_mm_setcsr" :export nil :ret-arg 0) (defsetf cpu-mxcsr %set-cpu-mxcsr) (def-intrinsic cpu-load-fence () nil "_mm_lfence") (def-intrinsic cpu-store-fence () nil "_mm_sfence") (def-intrinsic cpu-memory-fence () nil "_mm_mfence") (def-intrinsic cpu-pause () nil "_mm_pause")) ;;; Single-float ;; Initialization #+sbcl (def-float-set-intrinsic set-ss %set-ss single-float single-reg float-sse-pack movaps) #+ecl (progn (def-intrinsic set-ss (single-float) float-sse-pack "_mm_set_ss") (def-intrinsic set1-ps (single-float) float-sse-pack "_mm_set1_ps") (def-intrinsic set-ps (single-float single-float single-float single-float) float-sse-pack "_mm_set_ps") (def-intrinsic setr-ps (single-float single-float single-float single-float) float-sse-pack "_mm_setr_ps") (def-intrinsic setzero-ps () float-sse-pack "_mm_setzero_ps")) ;; Memory (def-load-intrinsic mem-ref-ss float-sse-pack movss "_mm_load_ss") (def-load-intrinsic mem-ref-ps float-sse-pack movups "_mm_loadu_ps") (def-load-intrinsic mem-ref-aps float-sse-pack movaps "_mm_load_ps") (def-store-intrinsic mem-set-ss float-sse-pack movss "_mm_store_ss" :setf-name mem-ref-ss) (def-store-intrinsic mem-set-ps float-sse-pack movups "_mm_storeu_ps" :setf-name mem-ref-ps) (def-store-intrinsic mem-set-aps float-sse-pack movaps "_mm_store_ps" :setf-name mem-ref-aps) (def-store-intrinsic stream-ps float-sse-pack movntps "_mm_stream_ps") ;; Arithmetics (def-binary-intrinsic add-ss float-sse-pack addss 3 "_mm_add_ss") (def-binary-intrinsic add-ps float-sse-pack addps 3 "_mm_add_ps" :commutative t) (def-binary-intrinsic sub-ss float-sse-pack subss 3 "_mm_sub_ss") (def-binary-intrinsic sub-ps float-sse-pack subps 3 "_mm_sub_ps") (def-binary-intrinsic mul-ss float-sse-pack mulss 5 "_mm_mul_ss") (def-binary-intrinsic mul-ps float-sse-pack mulps 5 "_mm_mul_ps" :commutative t) (def-binary-intrinsic div-ss float-sse-pack divss 13 "_mm_div_ss") (def-binary-intrinsic div-ps float-sse-pack divps 13 "_mm_div_ps") (def-binary-intrinsic min-ss float-sse-pack minss 3 "_mm_min_ss") (def-binary-intrinsic min-ps float-sse-pack minps 3 "_mm_min_ps":commutative t) (def-binary-intrinsic max-ss float-sse-pack maxss 3 "_mm_max_ss") (def-binary-intrinsic max-ps float-sse-pack maxps 3 "_mm_max_ps" :commutative t) (def-unary-intrinsic sqrt-ss float-sse-pack sqrtss 20 "_mm_sqrt_ss" :partial t) (def-unary-intrinsic sqrt-ps float-sse-pack sqrtps 20 "_mm_sqrt_ps") (def-unary-intrinsic rsqrt-ss float-sse-pack rsqrtss 20 "_mm_rsqrt_ss" :partial t) (def-unary-intrinsic rsqrt-ps float-sse-pack rsqrtps 20 "_mm_rsqrt_ps") (def-unary-intrinsic rcp-ss float-sse-pack rcpss 13 "_mm_rcp_ss" :partial t) (def-unary-intrinsic rcp-ps float-sse-pack rcpps 13 "_mm_rcp_ps") ;; Bitwise logic #+sbcl (def-not-intrinsic not-ps float-sse-pack xorps) (def-binary-intrinsic and-ps float-sse-pack andps 1 "_mm_and_ps" :commutative t) (def-binary-intrinsic andnot-ps float-sse-pack andnps 1 "_mm_andnot_ps") (def-binary-intrinsic or-ps float-sse-pack orps 1 "_mm_or_ps" :commutative t) (def-binary-intrinsic xor-ps float-sse-pack xorps 1 "_mm_xor_ps" :commutative t) ;; Comparisons (def-binary-intrinsic =-ss float-sse-pack cmpss 3 "_mm_cmpeq_ss" :tags (:eq)) (def-binary-intrinsic =-ps float-sse-pack cmpps 3 "_mm_cmpeq_ps" :tags (:eq) :commutative t) (def-binary-intrinsic <-ss float-sse-pack cmpss 3 "_mm_cmplt_ss" :tags (:lt)) (def-binary-intrinsic <-ps float-sse-pack cmpps 3 "_mm_cmplt_ps" :tags (:lt)) (def-binary-intrinsic <=-ss float-sse-pack cmpss 3 "_mm_cmple_ss" :tags (:le)) (def-binary-intrinsic <=-ps float-sse-pack cmpps 3 "_mm_cmple_ps" :tags (:le)) #+ecl (def-binary-intrinsic >-ss float-sse-pack nil nil "_mm_cmpgt_ss") #+ecl (def-binary-intrinsic >-ps float-sse-pack nil nil "_mm_cmpgt_ps") #+ecl (def-binary-intrinsic >=-ss float-sse-pack nil nil "_mm_cmpge_ss") #+ecl (def-binary-intrinsic >=-ps float-sse-pack nil nil "_mm_cmpge_ps") (def-binary-intrinsic /=-ss float-sse-pack cmpss 3 "_mm_cmpneq_ss" :tags (:neq)) (def-binary-intrinsic /=-ps float-sse-pack cmpps 3 "_mm_cmpneq_ps" :tags (:neq) :commutative t) (def-binary-intrinsic /<-ss float-sse-pack cmpss 3 "_mm_cmpnlt_ss" :tags (:nlt)) (def-binary-intrinsic /<-ps float-sse-pack cmpps 3 "_mm_cmpnlt_ps" :tags (:nlt)) (def-binary-intrinsic /<=-ss float-sse-pack cmpss 3 "_mm_cmpnle_ss" :tags (:nle)) (def-binary-intrinsic /<=-ps float-sse-pack cmpps 3 "_mm_cmpnle_ps" :tags (:nle)) #+ecl (def-binary-intrinsic />-ss float-sse-pack nil nil "_mm_cmpngt_ss") #+ecl (def-binary-intrinsic />-ps float-sse-pack nil nil "_mm_cmpngt_ps") #+ecl (def-binary-intrinsic />=-ss float-sse-pack nil nil "_mm_cmpnge_ss") #+ecl (def-binary-intrinsic />=-ps float-sse-pack nil nil "_mm_cmpnge_ps") (def-binary-intrinsic cmpord-ss float-sse-pack cmpss 3 "_mm_cmpord_ss" :tags (:ord)) ; neither is NaN (def-binary-intrinsic cmpord-ps float-sse-pack cmpps 3 "_mm_cmpord_ps" :tags (:ord) :commutative t) (def-binary-intrinsic cmpunord-ss float-sse-pack cmpss 3 "_mm_cmpunord_ss" :tags (:unord)) (def-binary-intrinsic cmpunord-ps float-sse-pack cmpps 3 "_mm_cmpunord_ps" :tags (:unord) :commutative t) (def-comparison-intrinsic =-ss? float-sse-pack comiss 3 "_mm_comieq_ss" :commutative t :tags (:e)) (def-comparison-intrinsic =-ssu? float-sse-pack ucomiss 3 "_mm_ucomieq_ss" :commutative t :tags (:e)) (def-comparison-intrinsic <-ss? float-sse-pack comiss 3 "_mm_comilt_ss" :tags (:b)) (def-comparison-intrinsic <-ssu? float-sse-pack ucomiss 3 "_mm_ucomilt_ss" :tags (:b)) (def-comparison-intrinsic <=-ss? float-sse-pack comiss 3 "_mm_comile_ss" :tags (:be)) (def-comparison-intrinsic <=-ssu? float-sse-pack ucomiss 3 "_mm_ucomile_ss" :tags (:be)) (def-comparison-intrinsic >-ss? float-sse-pack comiss 3 "_mm_comigt_ss" :tags (:a)) (def-comparison-intrinsic >-ssu? float-sse-pack ucomiss 3 "_mm_ucomigt_ss" :tags (:a)) (def-comparison-intrinsic >=-ss? float-sse-pack comiss 3 "_mm_comige_ss" :tags (:ae)) (def-comparison-intrinsic >=-ssu? float-sse-pack ucomiss 3 "_mm_ucomige_ss" :tags (:ae)) (def-comparison-intrinsic /=-ss? float-sse-pack comiss 3 "_mm_comineq_ss" :commutative t :tags (:ne)) (def-comparison-intrinsic /=-ssu? float-sse-pack ucomiss 3 "_mm_ucomineq_ss" :commutative t :tags (:ne)) ;; Misc (def-binary-intrinsic unpackhi-ps float-sse-pack unpckhps 1 "_mm_unpackhi_ps") (def-binary-intrinsic unpacklo-ps float-sse-pack unpcklps 1 "_mm_unpacklo_ps") (def-binary-intrinsic move-ss float-sse-pack movss 1 "_mm_move_ss") (def-binary-intrinsic movehl-ps float-sse-pack movhlps 1 "_mm_movehl_ps") (def-binary-intrinsic movelh-ps float-sse-pack movlhps 1 "_mm_movelh_ps") (def-unary-intrinsic movemask-ps (unsigned-byte 4) movmskps 1 "_mm_movemask_ps" :arg-type float-sse-pack) ;; Shuffle (def-binary-intrinsic shuffle-ps float-sse-pack shufps 1 "_mm_shuffle_ps" :immediate-arg (unsigned-byte 8)) ;; Conversion (def-unary-intrinsic convert-pi32-to-ps float-sse-pack cvtdq2ps 3 "_mm_cvtepi32_ps" :arg-type int-sse-pack) (def-unary-intrinsic convert-ps-to-pi32 int-sse-pack cvtps2dq 3 "_mm_cvtps_epi32" :arg-type float-sse-pack) (def-unary-intrinsic truncate-ps-to-pi32 int-sse-pack cvttps2dq 3 "_mm_cvttps_epi32" :arg-type float-sse-pack) (def-sse-int-intrinsic convert-si32-to-ss (signed-byte 32) float-sse-pack cvtsi2ss 3 "_mm_cvtsi32_ss") (def-cvt-to-int32-intrinsic convert-ss-to-si32 (signed-byte 32) cvtss2si 3 "_mm_cvtss_si32" :arg-type float-sse-pack) (def-cvt-to-int32-intrinsic truncate-ss-to-si32 (signed-byte 32) cvttss2si 3 "_mm_cvttss_si32" :arg-type float-sse-pack) #+(or x86_64 x86-64) (def-sse-int-intrinsic convert-si64-to-ss (signed-byte 64) float-sse-pack cvtsi2ss 3 #-msvc "_mm_cvtsi64_ss" #+msvc "_mm_cvtsi64x_ss") #+(or x86_64 x86-64) (def-unary-intrinsic convert-ss-to-si64 (signed-byte 64) cvtss2si 3 #-msvc "_mm_cvtss_si64" #+msvc "_mm_cvtss_si64x" :arg-type float-sse-pack) #+(or x86_64 x86-64) (def-unary-intrinsic truncate-ss-to-si64 (signed-byte 64) cvttss2si 3 #-msvc "_mm_cvttss_si64" #+msvc "_mm_cvttss_si64x" :arg-type float-sse-pack) ;;; Double-float ;; Initialization #+sbcl (def-float-set-intrinsic set-sd %set-sd double-float double-reg double-sse-pack movapd) #+ecl (progn (def-intrinsic set-sd (double-float) double-sse-pack "_mm_set_sd") (def-intrinsic set1-pd (double-float) double-sse-pack "_mm_set1_pd") (def-intrinsic set-pd (double-float double-float) double-sse-pack "_mm_set_pd") (def-intrinsic setr-pd (double-float double-float) double-sse-pack "_mm_setr_pd") (def-intrinsic setzero-pd () double-sse-pack "_mm_setzero_pd")) ;; Memory (def-load-intrinsic mem-ref-sd double-sse-pack movsd "_mm_load_sd") (def-load-intrinsic mem-ref-pd double-sse-pack movupd "_mm_loadu_pd") (def-load-intrinsic mem-ref-apd double-sse-pack movapd "_mm_load_pd") (def-load-intrinsic loadh-pd double-sse-pack movhpd "_mm_loadh_pd" :register-arg t) (def-load-intrinsic loadl-pd double-sse-pack movlpd "_mm_loadl_pd" :register-arg t) (def-store-intrinsic mem-set-sd double-sse-pack movsd "_mm_store_sd" :setf-name mem-ref-sd) (def-store-intrinsic mem-set-pd double-sse-pack movupd "_mm_storeu_pd" :setf-name mem-ref-pd) (def-store-intrinsic mem-set-apd double-sse-pack movapd "_mm_store_pd" :setf-name mem-ref-apd) (def-store-intrinsic storeh-pd double-sse-pack movhpd "_mm_storeh_pd") (def-store-intrinsic storel-pd double-sse-pack movlpd "_mm_storel_pd") (def-store-intrinsic stream-pd double-sse-pack movntpd "_mm_stream_pd") ;; Arithmetics (def-binary-intrinsic add-sd double-sse-pack addsd 3 "_mm_add_sd") (def-binary-intrinsic add-pd double-sse-pack addpd 3 "_mm_add_pd" :commutative t) (def-binary-intrinsic sub-sd double-sse-pack subsd 3 "_mm_sub_sd") (def-binary-intrinsic sub-pd double-sse-pack subpd 3 "_mm_sub_pd") (def-binary-intrinsic mul-sd double-sse-pack mulsd 5 "_mm_mul_sd") (def-binary-intrinsic mul-pd double-sse-pack mulpd 5 "_mm_mul_pd" :commutative t) (def-binary-intrinsic div-sd double-sse-pack divsd 13 "_mm_div_sd") (def-binary-intrinsic div-pd double-sse-pack divpd 13 "_mm_div_pd") (def-binary-intrinsic min-sd double-sse-pack minsd 3 "_mm_min_sd") (def-binary-intrinsic min-pd double-sse-pack minpd 3 "_mm_min_pd" :commutative t) (def-binary-intrinsic max-sd double-sse-pack maxsd 3 "_mm_max_sd") (def-binary-intrinsic max-pd double-sse-pack maxpd 3 "_mm_max_pd" :commutative t) (def-binary-intrinsic sqrt-sd double-sse-pack sqrtsd 20 "_mm_sqrt_sd") (def-unary-intrinsic sqrt-pd double-sse-pack sqrtpd 20 "_mm_sqrt_pd") ;; Bitwise logic #+sbcl (def-not-intrinsic not-pd double-sse-pack xorpd) (def-binary-intrinsic and-pd double-sse-pack andpd 1 "_mm_and_pd" :commutative t) (def-binary-intrinsic andnot-pd double-sse-pack andnpd 1 "_mm_andnot_pd") (def-binary-intrinsic or-pd double-sse-pack orpd 1 "_mm_or_pd" :commutative t) (def-binary-intrinsic xor-pd double-sse-pack xorpd 1 "_mm_xor_pd" :commutative t) ;; Comparisons (def-binary-intrinsic =-sd double-sse-pack cmpsd 3 "_mm_cmpeq_sd" :tags (:eq)) (def-binary-intrinsic =-pd double-sse-pack cmppd 3 "_mm_cmpeq_pd" :tags (:eq) :commutative t) (def-binary-intrinsic <-sd double-sse-pack cmpsd 3 "_mm_cmplt_sd" :tags (:lt)) (def-binary-intrinsic <-pd double-sse-pack cmppd 3 "_mm_cmplt_pd" :tags (:lt)) (def-binary-intrinsic <=-sd double-sse-pack cmpsd 3 "_mm_cmple_sd" :tags (:le)) (def-binary-intrinsic <=-pd double-sse-pack cmppd 3 "_mm_cmple_pd" :tags (:le)) #+ecl (def-binary-intrinsic >-sd double-sse-pack nil nil "_mm_cmpgt_sd") #+ecl (def-binary-intrinsic >-pd double-sse-pack nil nil "_mm_cmpgt_pd") #+ecl (def-binary-intrinsic >=-sd double-sse-pack nil nil "_mm_cmpge_sd") #+ecl (def-binary-intrinsic >=-pd double-sse-pack nil nil "_mm_cmpge_pd") (def-binary-intrinsic /=-sd double-sse-pack cmpsd 3 "_mm_cmpneq_sd" :tags (:neq)) (def-binary-intrinsic /=-pd double-sse-pack cmppd 3 "_mm_cmpneq_pd" :tags (:neq) :commutative t) (def-binary-intrinsic /<-sd double-sse-pack cmpsd 3 "_mm_cmpnlt_sd" :tags (:nlt)) (def-binary-intrinsic /<-pd double-sse-pack cmppd 3 "_mm_cmpnlt_pd" :tags (:nlt)) (def-binary-intrinsic /<=-sd double-sse-pack cmpsd 3 "_mm_cmpnle_sd" :tags (:nle)) (def-binary-intrinsic /<=-pd double-sse-pack cmppd 3 "_mm_cmpnle_pd" :tags (:nle)) #+ecl (def-binary-intrinsic />-sd double-sse-pack nil nil "_mm_cmpngt_sd") #+ecl (def-binary-intrinsic />-pd double-sse-pack nil nil "_mm_cmpngt_pd") #+ecl (def-binary-intrinsic />=-sd double-sse-pack nil nil "_mm_cmpnge_sd") #+ecl (def-binary-intrinsic />=-pd double-sse-pack nil nil "_mm_cmpnge_pd") (def-binary-intrinsic cmpord-sd double-sse-pack cmpsd 3 "_mm_cmpord_sd" :tags (:ord)) ; neither is NaN (def-binary-intrinsic cmpord-pd double-sse-pack cmppd 3 "_mm_cmpord_pd" :tags (:ord) :commutative t) (def-binary-intrinsic cmpunord-sd double-sse-pack cmpsd 3 "_mm_cmpunord_sd" :tags (:unord)) (def-binary-intrinsic cmpunord-pd double-sse-pack cmppd 3 "_mm_cmpunord_pd" :tags (:unord) :commutative t) (def-comparison-intrinsic =-sd? double-sse-pack comisd 3 "_mm_comieq_sd" :commutative t :tags (:e)) (def-comparison-intrinsic =-sdu? double-sse-pack ucomisd 3 "_mm_ucomieq_sd" :commutative t :tags (:e)) (def-comparison-intrinsic <-sd? double-sse-pack comisd 3 "_mm_comilt_sd" :tags (:b)) (def-comparison-intrinsic <-sdu? double-sse-pack ucomisd 3 "_mm_ucomilt_sd" :tags (:b)) (def-comparison-intrinsic <=-sd? double-sse-pack comisd 3 "_mm_comile_sd" :tags (:be)) (def-comparison-intrinsic <=-sdu? double-sse-pack ucomisd 3 "_mm_ucomile_sd" :tags (:be)) (def-comparison-intrinsic >-sd? double-sse-pack comisd 3 "_mm_comigt_sd" :tags (:a)) (def-comparison-intrinsic >-sdu? double-sse-pack ucomisd 3 "_mm_ucomigt_sd" :tags (:a)) (def-comparison-intrinsic >=-sd? double-sse-pack comisd 3 "_mm_comige_sd" :tags (:ae)) (def-comparison-intrinsic >=-sdu? double-sse-pack ucomisd 3 "_mm_ucomige_sd" :tags (:ae)) (def-comparison-intrinsic /=-sd? double-sse-pack comisd 3 "_mm_comineq_sd" :commutative t :tags (:ne)) (def-comparison-intrinsic /=-sdu? double-sse-pack ucomisd 3 "_mm_ucomineq_sd" :commutative t :tags (:ne)) ;; Misc (def-binary-intrinsic unpackhi-pd double-sse-pack unpckhpd 1 "_mm_unpackhi_pd") (def-binary-intrinsic unpacklo-pd double-sse-pack unpcklpd 1 "_mm_unpacklo_pd") (def-binary-intrinsic move-sd double-sse-pack movsd 1 "_mm_move_sd") (def-unary-intrinsic movemask-pd (unsigned-byte 2) movmskpd 1 "_mm_movemask_pd" :arg-type double-sse-pack) ;; Shuffle (def-binary-intrinsic shuffle-pd double-sse-pack shufpd 1 "_mm_shuffle_pd" :immediate-arg (unsigned-byte 2)) ;; Conversion (def-unary-intrinsic convert-ps-to-pd double-sse-pack cvtps2pd 3 "_mm_cvtps_pd" :arg-type float-sse-pack) (def-unary-intrinsic convert-pd-to-ps float-sse-pack cvtpd2ps 3 "_mm_cvtpd_ps" :arg-type double-sse-pack) (def-binary-intrinsic convert-ss-to-sd double-sse-pack cvtss2sd 3 "_mm_cvtss_sd" :y-type float-sse-pack) (def-binary-intrinsic convert-sd-to-ss float-sse-pack cvtsd2ss 3 "_mm_cvtsd_ss" :y-type double-sse-pack) (def-unary-intrinsic convert-pi32-to-pd double-sse-pack cvtdq2pd 3 "_mm_cvtepi32_pd" :arg-type int-sse-pack) (def-unary-intrinsic convert-pd-to-pi32 int-sse-pack cvtpd2dq 3 "_mm_cvtpd_epi32" :arg-type double-sse-pack) (def-unary-intrinsic truncate-pd-to-pi32 int-sse-pack cvttpd2dq 3 "_mm_cvttpd_epi32" :arg-type double-sse-pack) (def-sse-int-intrinsic convert-si32-to-sd (signed-byte 32) double-sse-pack cvtsi2ss 3 "_mm_cvtsi32_sd") (def-cvt-to-int32-intrinsic convert-sd-to-si32 (signed-byte 32) cvtsd2si 3 "_mm_cvtsd_si32" :arg-type double-sse-pack) (def-cvt-to-int32-intrinsic truncate-sd-to-si32 (signed-byte 32) cvttsd2si 3 "_mm_cvttsd_si32" :arg-type double-sse-pack) #+(or x86_64 x86-64) (def-sse-int-intrinsic convert-si64-to-sd (signed-byte 64) double-sse-pack cvtsi2ss 3 #-msvc "_mm_cvtsi64_sd" #+msvc "_mm_cvtsi64x_sd") #+(or x86_64 x86-64) (def-unary-intrinsic convert-sd-to-si64 (signed-byte 64) cvtsd2si 3 #-msvc "_mm_cvtsd_si64" #+msvc "_mm_cvtsd_si64x" :arg-type double-sse-pack) #+(or x86_64 x86-64) (def-unary-intrinsic truncate-sd-to-si64 (signed-byte 64) cvttsd2si 3 #-msvc "_mm_cvttsd_si64" #+msvc "_mm_cvttsd_si64x" :arg-type double-sse-pack) ;;; Integer ;; Initialization #+ecl (progn (def-intrinsic set1-pi8 (fixnum) int-sse-pack "_mm_set1_epi8") (def-intrinsic set1-pi16 (fixnum) int-sse-pack "_mm_set1_epi16") (def-intrinsic set1-pi32 (ext:integer32) int-sse-pack "_mm_set1_epi32") #+x86_64 (def-intrinsic set1-pi64 (ext:integer64) int-sse-pack "_mm_set1_epi64x") (def-intrinsic set1-pu32 (ext:byte32) int-sse-pack "_mm_set1_epi32") #+x86_64 (def-intrinsic set1-pu64 (ext:byte64) int-sse-pack "_mm_set1_epi64x") ;;----- (def-intrinsic set-pi8 (fixnum fixnum fixnum fixnum fixnum fixnum fixnum fixnum fixnum fixnum fixnum fixnum fixnum fixnum fixnum fixnum) int-sse-pack "_mm_set_epi8") (def-intrinsic set-pi16 (fixnum fixnum fixnum fixnum fixnum fixnum fixnum fixnum) int-sse-pack "_mm_set_epi16") (def-intrinsic set-pi32 (ext:integer32 ext:integer32 ext:integer32 ext:integer32) int-sse-pack "_mm_set_epi32") #+x86_64 (def-intrinsic set-pi64 (ext:integer64 ext:integer64) int-sse-pack "_mm_set_epi64x") (def-intrinsic set-pu32 (ext:byte32 ext:byte32 ext:byte32 ext:byte32) int-sse-pack "_mm_set_epi32") #+x86_64 (def-intrinsic set-pu64 (ext:byte64 ext:byte64) int-sse-pack "_mm_set_epi64x") ;;----- (def-intrinsic setr-pi8 (fixnum fixnum fixnum fixnum fixnum fixnum fixnum fixnum fixnum fixnum fixnum fixnum fixnum fixnum fixnum fixnum) int-sse-pack "_mm_setr_epi8") (def-intrinsic setr-pi16 (fixnum fixnum fixnum fixnum fixnum fixnum fixnum fixnum) int-sse-pack "_mm_setr_epi16") (def-intrinsic setr-pi32 (ext:integer32 ext:integer32 ext:integer32 ext:integer32) int-sse-pack "_mm_setr_epi32") #+x86_64 (def-intrinsic setr-pi64 (ext:integer64 ext:integer64) int-sse-pack "_mm_set_epi64x" :reorder-args t) (def-intrinsic setr-pu32 (ext:byte32 ext:byte32 ext:byte32 ext:byte32) int-sse-pack "_mm_setr_epi32") #+x86_64 (def-intrinsic setr-pu64 (ext:byte64 ext:byte64) int-sse-pack "_mm_set_epi64x" :reorder-args t) ;;----- (def-intrinsic setzero-pi () int-sse-pack "_mm_setzero_si128")) ;; Memory (def-load-intrinsic mem-ref-pi int-sse-pack movdqu "_mm_loadu_si128") (def-load-intrinsic mem-ref-api int-sse-pack movdqa "_mm_load_si128") (def-load-intrinsic mem-ref-si64 int-sse-pack movd "_mm_loadl_epi64") (def-store-intrinsic mem-set-pi int-sse-pack movdqu "_mm_storeu_si128" :setf-name mem-ref-pi) (def-store-intrinsic mem-set-api int-sse-pack movdqa "_mm_store_si128" :setf-name mem-ref-api) (def-store-intrinsic mem-set-si64 int-sse-pack movd "_mm_storel_epi64" :setf-name mem-ref-si64) (def-store-intrinsic stream-pi int-sse-pack movntdq "_mm_stream_si128") ;; Masked move #+ecl (def-mem-intrinsic maskmoveu-pi "char" nil "_mm_maskmoveu_si128" :prefix-args (int-sse-pack int-sse-pack)) #+sbcl (progn (defknown %maskmoveu-pi (sse-pack sse-pack system-area-pointer fixnum) (values) (unsafe)) (define-vop (%maskmoveu-pi) (:translate %maskmoveu-pi) (:args (value :scs (sse-reg)) (mask :scs (sse-reg)) (sap :scs (sap-reg) :target rdi) (offset :scs (signed-reg))) (:arg-types sse-pack sse-pack system-area-pointer signed-num) (:temporary (:sc sap-reg :offset rdi-offset :from :eval) rdi) (:policy :fast-safe) (:note "inline MASKMOVEU operation") (:generator 5 (if (location= sap rdi) (inst add rdi offset) (inst lea rdi (make-ea :qword :base sap :index offset))) (inst maskmovdqu value mask))) (define-vop (%maskmoveu-pi-c) (:translate %maskmoveu-pi) (:args (value :scs (sse-reg)) (mask :scs (sse-reg)) (sap :scs (sap-reg) :target rdi)) (:arg-types sse-pack sse-pack system-area-pointer (:constant (signed-byte 32))) (:info offset) (:temporary (:sc sap-reg :offset rdi-offset :from :eval) rdi) (:policy :fast-safe) (:note "inline MASKMOVEU operation") (:generator 4 (if (location= sap rdi) (unless (= offset 0) (inst add rdi offset)) (if (= offset 0) (inst mov rdi sap) (inst lea rdi (make-ea :qword :base sap :disp offset)))) (inst maskmovdqu value mask))) (def-splice-transform %maskmoveu-pi (value mask (sap+ sap offset1) offset2) (%maskmoveu-pi value mask sap (+ offset1 offset2)))) ;; Arithmetics (def-binary-intrinsic add-pi8 int-sse-pack paddb 1 "_mm_add_epi8" :commutative t) (def-binary-intrinsic add-pi16 int-sse-pack paddw 1 "_mm_add_epi16" :commutative t) (def-binary-intrinsic add-pi32 int-sse-pack paddd 1 "_mm_add_epi32" :commutative t) (def-binary-intrinsic add-pi64 int-sse-pack paddq 1 "_mm_add_epi64" :commutative t) (def-binary-intrinsic adds-pi8 int-sse-pack paddsb 1 "_mm_adds_epi8" :commutative t) (def-binary-intrinsic adds-pi16 int-sse-pack paddsw 1 "_mm_adds_epi16" :commutative t) (def-binary-intrinsic adds-pu8 int-sse-pack paddusb 1 "_mm_adds_epu8" :commutative t) (def-binary-intrinsic adds-pu16 int-sse-pack paddusw 1 "_mm_adds_epu16" :commutative t) (def-binary-intrinsic avg-pu8 int-sse-pack pavgb 1 "_mm_avg_epu8" :commutative t) (def-binary-intrinsic avg-pu16 int-sse-pack pavgw 1 "_mm_avg_epu16" :commutative t) (def-binary-intrinsic madd-pi16 int-sse-pack pmaddwd 1 "_mm_madd_epi16" :commutative t) (def-binary-intrinsic max-pu8 int-sse-pack pmaxub 1 "_mm_max_epu8" :commutative t) (def-binary-intrinsic max-pi16 int-sse-pack pmaxsw 1 "_mm_max_epi16" :commutative t) (def-binary-intrinsic min-pu8 int-sse-pack pminub 1 "_mm_min_epu8" :commutative t) (def-binary-intrinsic min-pi16 int-sse-pack pminsw 1 "_mm_min_epi16" :commutative t) (def-binary-intrinsic mulhi-pi16 int-sse-pack pmulhw 3 "_mm_mulhi_epi16" :commutative t) (def-binary-intrinsic mulhi-pu16 int-sse-pack pmulhuw 3 "_mm_mulhi_epu16" :commutative t) (def-binary-intrinsic mullo-pi16 int-sse-pack pmullw 3 "_mm_mullo_epi16" :commutative t) (def-binary-intrinsic mul-pu32 int-sse-pack pmuludq 3 "_mm_mul_epu32" :commutative t) (def-binary-intrinsic sad-pu8 int-sse-pack psadbw 1 "_mm_sad_epu8" :commutative t) (def-binary-intrinsic sub-pi8 int-sse-pack psubb 1 "_mm_sub_epi8") (def-binary-intrinsic sub-pi16 int-sse-pack psubw 1 "_mm_sub_epi16") (def-binary-intrinsic sub-pi32 int-sse-pack psubd 1 "_mm_sub_epi32") (def-binary-intrinsic sub-pi64 int-sse-pack psubq 1 "_mm_sub_epi64") (def-binary-intrinsic subs-pi8 int-sse-pack psubsb 1 "_mm_subs_epi8") (def-binary-intrinsic subs-pi16 int-sse-pack psubsw 1 "_mm_subs_epi16") (def-binary-intrinsic subs-pu8 int-sse-pack psubusb 1 "_mm_subs_epu8") (def-binary-intrinsic subs-pu16 int-sse-pack psubusw 1 "_mm_subs_epu16") ;; Bitwise logic #+sbcl (def-not-intrinsic not-pi int-sse-pack pxor) (def-binary-intrinsic and-pi int-sse-pack pand 1 "_mm_and_si128" :commutative t) (def-binary-intrinsic andnot-pi int-sse-pack pandn 1 "_mm_andnot_si128") (def-binary-intrinsic or-pi int-sse-pack por 1 "_mm_or_si128" :commutative t) (def-binary-intrinsic xor-pi int-sse-pack pxor 1 "_mm_xor_si128" :commutative t) ;; Shifts (def-unary-intrinsic slli-pi int-sse-pack pslldq 1 "_mm_slli_si128" :partial :one-arg :immediate-arg (unsigned-byte 8)) (def-sse-int-intrinsic slli-pi16 fixnum int-sse-pack psllw 3 "_mm_slli_epi16" :make-temporary t :defun-body "_mm_sll_epi16(#0,_mm_cvtsi32_si128(#1))") (def-sse-int-intrinsic slli-pi32 fixnum int-sse-pack pslld 3 "_mm_slli_epi32" :make-temporary t :defun-body "_mm_sll_epi32(#0,_mm_cvtsi32_si128(#1))") (def-sse-int-intrinsic slli-pi64 fixnum int-sse-pack psllq 3 "_mm_slli_epi64" :make-temporary t :defun-body "_mm_sll_epi64(#0,_mm_cvtsi32_si128(#1))") (def-binary-intrinsic sll-pi16 int-sse-pack psllw 1 "_mm_sll_epi16") (def-binary-intrinsic sll-pi32 int-sse-pack pslld 1 "_mm_sll_epi32") (def-binary-intrinsic sll-pi64 int-sse-pack psllq 1 "_mm_sll_epi64") (def-sse-int-intrinsic srai-pi16 fixnum int-sse-pack psraw 3 "_mm_srai_epi16" :make-temporary t :defun-body "_mm_sra_epi16(#0,_mm_cvtsi32_si128(#1))") (def-sse-int-intrinsic srai-pi32 fixnum int-sse-pack psrad 3 "_mm_srai_epi32" :make-temporary t :defun-body "_mm_sra_epi32(#0,_mm_cvtsi32_si128(#1))") (def-binary-intrinsic sra-pi16 int-sse-pack psraw 1 "_mm_sra_epi16") (def-binary-intrinsic sra-pi32 int-sse-pack psrad 1 "_mm_sra_epi32") (def-unary-intrinsic srli-pi int-sse-pack psrldq 1 "_mm_srli_si128" :partial :one-arg :immediate-arg (unsigned-byte 8)) (def-sse-int-intrinsic srli-pi16 fixnum int-sse-pack psrlw 3 "_mm_srli_epi16" :make-temporary t :defun-body "_mm_srl_epi16(#0,_mm_cvtsi32_si128(#1))") (def-sse-int-intrinsic srli-pi32 fixnum int-sse-pack psrld 3 "_mm_srli_epi32" :make-temporary t :defun-body "_mm_srl_epi32(#0,_mm_cvtsi32_si128(#1))") (def-sse-int-intrinsic srli-pi64 fixnum int-sse-pack psrlq 3 "_mm_srli_epi64" :make-temporary t :defun-body "_mm_srl_epi64(#0,_mm_cvtsi32_si128(#1))") (def-binary-intrinsic srl-pi16 int-sse-pack psrlw 1 "_mm_srl_epi16") (def-binary-intrinsic srl-pi32 int-sse-pack psrld 1 "_mm_srl_epi32") (def-binary-intrinsic srl-pi64 int-sse-pack psrlq 1 "_mm_srl_epi64") #+sbcl (macrolet ((defimm (name insn bits &key arithmetic) `(define-vop (,(symbolicate "%" name "-IMM") sse-int-base-op) (:translate ,name) (:args (x :scs (sse-reg) :target r)) (:arg-types sse-pack (:constant fixnum)) (:result-types sb-kernel:int-sse-pack) (:info immv) (:generator 1 ,@(let ((core `(progn (ensure-move int-sse-pack r x) (unless (= immv 0) (inst ,insn r immv))))) (if arithmetic `((when (or (< immv 0) (>= immv ,bits)) (setf immv ,bits)) ,core) `((if (or (< immv 0) (>= immv ,bits)) (inst pxor r r) ,core)))))))) (defimm slli-pi16 psllw-imm 16) (defimm slli-pi32 pslld-imm 32) (defimm slli-pi64 psllq-imm 64) (defimm srai-pi16 psraw-imm 16 :arithmetic t) (defimm srai-pi32 psrad-imm 32 :arithmetic t) (defimm srli-pi16 psrlw-imm 16) (defimm srli-pi32 psrld-imm 32) (defimm srli-pi64 psrlq-imm 64)) ;; Comparisons (def-binary-intrinsic =-pi8 int-sse-pack pcmpeqb 1 "_mm_cmpeq_epi8") (def-binary-intrinsic =-pi16 int-sse-pack pcmpeqw 1 "_mm_cmpeq_epi16") (def-binary-intrinsic =-pi32 int-sse-pack pcmpeqd 1 "_mm_cmpeq_epi32") #+ecl (def-binary-intrinsic <-pi8 int-sse-pack nil nil "_mm_cmplt_epi8") #+ecl (def-binary-intrinsic <-pi16 int-sse-pack nil nil "_mm_cmplt_epi16") #+ecl (def-binary-intrinsic <-pi32 int-sse-pack nil nil "_mm_cmplt_epi32") (def-binary-intrinsic >-pi8 int-sse-pack pcmpgtb 1 "_mm_cmpgt_epi8") (def-binary-intrinsic >-pi16 int-sse-pack pcmpgtw 1 "_mm_cmpgt_epi16") (def-binary-intrinsic >-pi32 int-sse-pack pcmpgtd 1 "_mm_cmpgt_epi32") ;; Misc (def-binary-intrinsic packs-pi16 int-sse-pack packsswb 1 "_mm_packs_epi16") (def-binary-intrinsic packs-pi32 int-sse-pack packssdw 1 "_mm_packs_epi32") (def-binary-intrinsic packus-pi16 int-sse-pack packuswb 1 "_mm_packus_epi16") (def-unary-intrinsic extract-pi16 (unsigned-byte 16) pextrw 1 "_mm_extract_epi16" :immediate-arg (unsigned-byte 8) :arg-type int-sse-pack) (def-sse-int-intrinsic insert-pi16 fixnum int-sse-pack pinsrw 1 "_mm_insert_epi16" :immediate-arg (unsigned-byte 8)) (def-unary-intrinsic movemask-pi8 (unsigned-byte 16) pmovmskb 1 "_mm_movemask_epi8" :arg-type int-sse-pack) (def-binary-intrinsic unpackhi-pi8 int-sse-pack punpckhbw 1 "_mm_unpackhi_epi8") (def-binary-intrinsic unpackhi-pi16 int-sse-pack punpckhwd 1 "_mm_unpackhi_epi16") (def-binary-intrinsic unpackhi-pi32 int-sse-pack punpckhdq 1 "_mm_unpackhi_epi32") (def-binary-intrinsic unpackhi-pi64 int-sse-pack punpckhqdq 1 "_mm_unpackhi_epi64") (def-binary-intrinsic unpacklo-pi8 int-sse-pack punpcklbw 1 "_mm_unpacklo_epi8") (def-binary-intrinsic unpacklo-pi16 int-sse-pack punpcklwd 1 "_mm_unpacklo_epi16") (def-binary-intrinsic unpacklo-pi32 int-sse-pack punpckldq 1 "_mm_unpacklo_epi32") (def-binary-intrinsic unpacklo-pi64 int-sse-pack punpcklqdq 1 "_mm_unpacklo_epi64") (def-unary-intrinsic move-pi64 int-sse-pack movq 1 "_mm_move_epi64") ;; Shuffle (def-unary-intrinsic shuffle-pi32 int-sse-pack pshufd 1 "_mm_shuffle_epi32" :immediate-arg (unsigned-byte 8)) (def-unary-intrinsic shufflelo-pi16 int-sse-pack pshuflw 1 "_mm_shufflelo_epi16" :immediate-arg (unsigned-byte 8)) (def-unary-intrinsic shufflehi-pi16 int-sse-pack pshufhw 1 "_mm_shufflehi_epi16" :immediate-arg (unsigned-byte 8)) ;; Conversion #+sbcl (progn (export 'convert-si32-to-pi) (defknown convert-si32-to-pi ((signed-byte 32)) int-sse-pack (foldable flushable)) (export 'convert-su32-to-pi) (defknown convert-su32-to-pi ((unsigned-byte 32)) int-sse-pack (foldable flushable)) (export 'convert-si64-to-pi) (defknown convert-si64-to-pi ((signed-byte 64)) int-sse-pack (foldable flushable)) (export 'convert-su64-to-pi) (defknown convert-su64-to-pi ((unsigned-byte 64)) int-sse-pack (foldable flushable)) (defknown %set-int ((signed-byte 64)) int-sse-pack (foldable flushable always-translatable)) (defknown %set-uint ((unsigned-byte 64)) int-sse-pack (foldable flushable always-translatable)) (define-vop (%set-int) (:translate %set-int %set-uint convert-si32-to-pi convert-su32-to-pi convert-si64-to-pi convert-su64-to-pi) (:args (arg :scs (signed-reg unsigned-reg signed-stack unsigned-stack))) (:arg-types untagged-num) (:results (dst :scs (sse-reg))) (:result-types sb-kernel:int-sse-pack) (:policy :fast-safe) (:generator 1 (inst movd dst arg)))) #+ecl (progn (def-intrinsic convert-si32-to-pi (ext:integer32) int-sse-pack "_mm_cvtsi32_si128") (def-intrinsic convert-su32-to-pi (ext:byte32) int-sse-pack "_mm_cvtsi32_si128") #+x86_64 (def-intrinsic convert-si64-to-pi (ext:integer64) int-sse-pack #-msvc "_mm_cvtsi64_si128" #+msvc "_mm_cvtsi64x_si128") #+x86_64 (def-intrinsic convert-su64-to-pi (ext:byte64) int-sse-pack #-msvc "_mm_cvtsi64_si128" #+msvc "_mm_cvtsi64x_si128")) (def-cvt-to-int32-intrinsic convert-pi-to-si32 (signed-byte 32) movd 1 "_mm_cvtsi128_si32" :arg-type int-sse-pack) (def-unary-intrinsic convert-pi-to-su32 (unsigned-byte 32) movd 1 "_mm_cvtsi128_si32" :result-size :dword :arg-type int-sse-pack) #+(or x86_64 x86-64) (def-unary-intrinsic convert-pi-to-si64 (signed-byte 64) movd 1 #-msvc "_mm_cvtsi128_si64" #+msvc "_mm_cvtsi128_si64x" :arg-type int-sse-pack) #+(or x86_64 x86-64) (def-unary-intrinsic convert-pi-to-su64 (unsigned-byte 64) movd 1 #-msvc "_mm_cvtsi128_si64" #+msvc "_mm_cvtsi128_si64x" :arg-type int-sse-pack) ecl-16.1.2/contrib/cl-simd/sse-package.lisp000066400000000000000000000045441266352375300204330ustar00rootroot00000000000000;;; -*- mode: Lisp; indent-tabs-mode: nil; -*- ;;; ;;; Copyright (c) 2010, Alexander Gavrilov (angavrilov@gmail.com) ;;; ;;; This file defines a package for all SSE intrinsics. ;;; #+ecl (eval-when (:load-toplevel) (require 'cmp)) #+sbcl (pushnew :SSE2 *features*) (defpackage #:SSE #+sbcl (:use #:COMMON-LISP #:SB-C #:SB-VM #:SB-INT #:SB-KERNEL #:SB-ASSEM #:SB-EXT #:SB-SYS) #+sbcl (:import-from #:SB-VM #:SINGLE-REG #:DOUBLE-REG #:SSE-REG #:SSE-PACK-IMMEDIATE #:SIGNED-REG #:SIGNED-STACK #:UNSIGNED-REG #:UNSIGNED-STACK #:SIGNED-NUM #:UNSIGNED-NUM #:UNTAGGED-NUM #:IMMEDIATE #:SAP-REG #:DESCRIPTOR-REG #:ANY-REG #:TAGGED-NUM #:RAX-OFFSET #:RDI-OFFSET #:RBP-TN #:FRAME-BYTE-OFFSET #:MAKE-EA #:REG-IN-SIZE #:LOADW) #+sbcl (:import-from #:SB-C #:SPLICE-FUN-ARGS #:EXTRACT-FUN-ARGS #:%DEFTRANSFORM #:COMMUTATIVE-ARG-SWAP #:GIVE-UP-IR1-TRANSFORM #:ABORT-IR1-TRANSFORM #:INSERT-ARRAY-BOUNDS-CHECKS #:VECTOR-LENGTH #:ASSERT-ARRAY-RANK #:ASSERT-LVAR-TYPE #:CONSTANT-LVAR-P #:LVAR-VALUE #:LVAR-TYPE #:LVAR-USES #:LVAR-FUN-NAME #:BASIC-COMBINATION-FUN #:LEXENV-POLICY #:NODE-LEXENV #:POLICY #:CAST-P #:CAST-VALUE #:DELETE-FILTER #:FIND-SAETP #:FIND-SAETP-BY-CTYPE) #+sbcl (:import-from #:SB-IMPL #:%ARRAY-ROW-MAJOR-INDEX) #+sbcl (:shadow #:INT-SSE-PACK #:FLOAT-SSE-PACK #:DOUBLE-SSE-PACK) #+ecl (:use #:COMMON-LISP #:FFI) #+ecl (:import-from #:EXT #:INT-SSE-PACK #:FLOAT-SSE-PACK #:DOUBLE-SSE-PACK #:SSE-PACK-P #:ARRAY-ELEMENT-TYPE-BYTE-SIZE #:*SSE-PACK-PRINT-MODE*) #+ecl (:shadow #:SSE-PACK) ;; Common exports: (:export #:SSE-PACK #:SSE-PACK-P #:INT-SSE-PACK #:FLOAT-SSE-PACK #:DOUBLE-SSE-PACK #:*SSE-PACK-PRINT-MODE* #:SSE-ARRAY #:MAKE-SSE-ARRAY #:0.0-PS #:TRUE-SS #:FALSE-SS #:TRUE-PS #:FALSE-PS #:SET1-PS #:SET-PS #:SETR-PS #:SETZERO-PS #:0.0-PD #:TRUE-SD #:FALSE-SD #:TRUE-PD #:FALSE-PD #:SET1-PD #:SET-PD #:SETR-PD #:SETZERO-PD #:0-PI #:TRUE-PI #:FALSE-PI #:SETZERO-PI #:CPU-MXCSR #:CPU-MXCSR-BITS #:WITH-SAVED-MXCSR #:CPU-CONFIGURE-ROUNDING)) ecl-16.1.2/contrib/cl-simd/sse-utils.lisp000066400000000000000000000123031266352375300201700ustar00rootroot00000000000000;;; -*- mode: Lisp; indent-tabs-mode: nil; -*- ;;; ;;; Copyright (c) 2010, Alexander Gavrilov (angavrilov@gmail.com) ;;; ;;; This file implements some common utility functions. ;;; (in-package #:SSE) ;;; CPU control (eval-when (:compile-toplevel :load-toplevel :execute) (declaim (ftype (function (&rest t) (unsigned-byte 32)) cpu-mxcsr-bits)) (defun cpu-mxcsr-bits (&rest tags) (loop with mask = 0 for tag in tags for bit = (if (listp tag) (apply #'cpu-mxcsr-bits tag) (ecase tag (:except-invalid #x1) (:except-denormal #x2) (:except-divide-zero #x4) (:except-overflow #x8) (:except-underflow #x10) (:except-precision #x20) (:except-all #x3F) (:denormals-are-zero #x40) (:mask-invalid #x80) (:mask-denormal #x100) (:mask-divide-zero #x200) (:mask-overflow #x400) (:mask-underflow #x800) (:mask-precision #x1000) (:mask-all #x1f80) (:round-nearest 0) (:round-negative #x2000) (:round-positive #x4000) (:round-zero #x6000) (:round-bits #x6000) (:flush-to-zero #x8000))) do (setf mask (logior mask bit)) finally (return mask))) (defun expand-cpu-mxcsr-bits (tags on-fail) (loop for tag in tags when (keywordp tag) collect tag into kwds else collect tag into rest finally (return (cond ((and kwds rest) `(logior ,(apply #'cpu-mxcsr-bits kwds) (cpu-mxcsr-bits ,@rest))) (kwds (apply #'cpu-mxcsr-bits kwds)) (t on-fail)))))) (define-compiler-macro cpu-mxcsr-bits (&whole whole &rest tags) (expand-cpu-mxcsr-bits tags whole)) (defmacro with-saved-mxcsr (&body code) (let ((v (gensym "CSR"))) `(let ((,v (cpu-mxcsr))) (declare (type (unsigned-byte 32) ,v) #+ecl (:read-only ,v)) (unwind-protect (progn ,@code) (%set-cpu-mxcsr ,v))))) #+nil (defun cpu-check-exceptions (&rest tags) (let ((mask (logand (cpu-mxcsr-bits (or tags :except-all)) (cpu-mxcsr-bits :except-all))) (csr (get-cpu-mxcsr))) (declare (optimize (safety 0) (speed 3) (debug 0)) (type fixnum csr mask)) (not (zerop (logand mask csr))))) #+nil (define-compiler-macro cpu-check-exceptions (&whole whole &rest tags) (let ((bits (expand-cpu-mxcsr-bits (or tags '(except-all)) nil))) (if (integerp bits) `(locally (declare (optimize (speed 3) (safety 0) (debug 0))) (not (zerop (logand (cpu-get-mxcsr) ,(logand bits (cpu-mxcsr-bits :except-all)))))) whole))) #+nil (macrolet ((foo (&rest names) (let* ((kwds (mapcar (lambda (x) (intern (format nil "MASK-~A" x) :keyword)) names)) (pvars (mapcar (lambda (x) (intern (format nil "~A-P" x))) names))) `(defun cpu-mask-exceptions (&key ,@(mapcar (lambda (n p) `(,n nil ,p)) names pvars) (other nil rest-p)) (let ((set-bits (logior ,@(mapcar (lambda (n k) `(if ,n (cpu-mxcsr-bits ,k) 0)) names kwds))) (arg-bits (logior ,@(mapcar (lambda (p k) `(if ,p (cpu-mxcsr-bits ,k) 0)) pvars kwds)))) (%set-cpu-mxcsr (the fixnum (if (not rest-p) (logior set-bits (logand (get-cpu-mxcsr) (lognot arg-bits))) (logior set-bits (if other (logand (cpu-mxcsr-bits :mask-all) (lognot arg-bits)) 0) (logiand (get-cpu-mxcsr) (lognot (cpu-mxcsr-bits :mask-all))))))) nil))))) (foo invalid denormal divide-zero overflow underflow precision)) (defun cpu-configure-rounding (&key round-to (denormals-are-zero nil daz-p) (flush-to-zero nil ftz-p)) (let ((set 0) (mask 0)) (when round-to (setf mask (cpu-mxcsr-bits :round-bits) set (ecase round-to (:zero (cpu-mxcsr-bits :round-zero)) (:negative (cpu-mxcsr-bits :round-negative)) (:positive (cpu-mxcsr-bits :round-positive)) (:nearest (cpu-mxcsr-bits :round-nearest))))) (when daz-p (setf mask (logior mask (cpu-mxcsr-bits :denormals-are-zero))) (when denormals-are-zero (setf set (logior set (cpu-mxcsr-bits :denormals-are-zero))))) (when ftz-p (setf mask (logior mask (cpu-mxcsr-bits :flush-to-zero))) (when flush-to-zero (setf set (logior set (cpu-mxcsr-bits :flush-to-zero))))) (setf (cpu-mxcsr) (the (unsigned-byte 32) (logior set (logand (cpu-mxcsr) (lognot mask))))) nil)) ecl-16.1.2/contrib/cl-simd/test-sfmt.lisp000066400000000000000000000135741266352375300202010ustar00rootroot00000000000000;;; -*- mode: Lisp; indent-tabs-mode: nil; -*- ;;; ;;; Dumbly translated from C code at: http://github.com/jj1bdx/sfmt-extstate (eval-when (:compile-toplevel :load-toplevel :execute) (require :cl-simd)) (defpackage #:sfmt-test (:use #:common-lisp #:sse)) (in-package #:sfmt-test) (deftype uint32 () '(unsigned-byte 32)) (deftype uint32-vector () '(sse-array uint32 (*))) (defconstant +mexp+ 19937) (defconstant +n+ (1+ (floor +mexp+ 128))) (defconstant +pos1+ 122) (defconstant +sl1+ 18) (defconstant +sl2+ 1) (defconstant +sr1+ 11) (defconstant +sr2+ 1) (defconstant +msk1+ #xdfffffef) (defconstant +msk2+ #xddfecb7f) (defconstant +msk3+ #xbffaffff) (defconstant +msk4+ #xbffffff6) (defconstant +parity1+ #x00000001) (defconstant +parity2+ #x00000000) (defconstant +parity3+ #x00000000) (defconstant +parity4+ #x13c9e684) (defconstant +uint32-mask+ #xFFFFFFFF) (defvar *work-buffer* (make-sse-array (* +n+ 4) :element-type 'uint32)) (defun period-certification (buffer) (declare (type uint32-vector buffer)) (let ((inner (logxor (logand (aref buffer 0) +parity1+) (logand (aref buffer 1) +parity2+) (logand (aref buffer 2) +parity3+) (logand (aref buffer 3) +parity4+)))) (loop for i = 16 then (ash i -1) while (> i 0) do (setf inner (logxor inner (ash inner (- i))))) (when (logtest inner 1) (return-from period-certification))) (loop for i from 0 to 3 for parity in (load-time-value (list +parity1+ +parity2+ +parity3+ +parity4+)) do (loop for work = 1 then (ash work 1) for j from 0 below 32 when (/= 0 (logand work parity)) do (progn (setf (aref buffer i) (logxor (aref buffer i) work)) (return-from period-certification))))) (defun init-gen-rand (seed buffer) (declare (type uint32 seed) (type uint32-vector buffer)) (setf (aref buffer 0) seed) (loop for i from 1 below (array-total-size buffer) do (setf (aref buffer i) (logand +uint32-mask+ (+ i (* 1812433253 (logxor (aref buffer (1- i)) (ash (aref buffer (1- i)) -30))))))) (period-certification buffer)) ;; Should be an inline function, but it's broken in ECL (defmacro recursion (a b c d mask) `(let ((x ,a) (y (srli-pi32 ,b +sr1+)) (z (srli-pi ,c +sr2+)) (v (slli-pi32 ,d +sl1+)) (m ,mask)) (xor-pi (xor-pi (xor-pi z x) v) (xor-pi (slli-pi x +sl2+) (and-pi y m))))) (defmacro sfmt-aref (buf idx) `(row-major-aref-api ,buf (the fixnum (* 4 (the fixnum ,idx))))) (defun gen-rand-all (buffer) (declare (optimize (speed 3) #+ecl (safety 0) (debug 0) #+sbcl (sb-c::insert-array-bounds-checks 0)) (type uint32-vector buffer)) #+ecl (check-type buffer uint32-vector) (assert (= (array-total-size buffer) (* +n+ 4))) (let ((mask (set-pu32 +msk4+ +msk3+ +msk2+ +msk1+)) (r1 (sfmt-aref buffer (- +n+ 2))) (r2 (sfmt-aref buffer (- +n+ 1)))) (declare (type int-sse-pack mask r1 r2)) (macrolet ((twist (delta) `(psetq r1 r2 r2 (setf (sfmt-aref buffer i) (recursion (sfmt-aref buffer i) (sfmt-aref buffer (+ i (the fixnum ,delta))) r1 r2 mask))))) (loop for i fixnum from 0 below (- +n+ +pos1+) do (twist +pos1+)) (loop for i fixnum from (- +n+ +pos1+) below +n+ do (twist (- +pos1+ +n+)))))) (defun gen-rand-array (output buffer) (declare (optimize (speed 3) #+ecl (safety 0) (debug 0) #+sbcl (sb-c::insert-array-bounds-checks 0)) (type uint32-vector buffer output)) #+ecl (check-type buffer uint32-vector) #+ecl (check-type output uint32-vector) (assert (= (array-total-size buffer) (* +n+ 4))) (let ((mask (set-pu32 +msk4+ +msk3+ +msk2+ +msk1+)) (size (floor (array-total-size output) 4)) (r1 (sfmt-aref buffer (- +n+ 2))) (r2 (sfmt-aref buffer (- +n+ 1)))) (declare (type int-sse-pack mask r1 r2) (type fixnum size)) (assert (> size (* +n+ 2))) (macrolet ((twist (tgt src1 delta1 src2 delta2) `(psetq r1 r2 r2 (setf (sfmt-aref ,tgt i) (recursion (sfmt-aref ,src1 (- i (the fixnum ,delta1))) (sfmt-aref ,src2 (+ i (the fixnum ,delta2))) r1 r2 mask))))) (loop for i fixnum from 0 below (- +n+ +pos1+) do (twist output buffer 0 buffer +pos1+)) (loop for i fixnum from (- +n+ +pos1+) below +n+ do (twist output buffer 0 output (- +pos1+ +n+))) (loop for i fixnum from +n+ below (- size +n+) do (twist output output +n+ output (- +pos1+ +n+))) #+ () (loop for j fixnum from 0 below (- (* 2 +n+) size) do (setf (sfmt-aref buffer j) (sfmt-aref output (+ j (the fixnum (- size +n+)))))) (loop for i fixnum from (- size +n+) below size for j fixnum from 0 below +n+ ;(max 0 (- (* 2 +n+) size)) do (twist output output +n+ output (- +pos1+ +n+)) do (setf (sfmt-aref buffer j) r2)) output))) (defun test () (let ((out (make-sse-array 10000 :element-type 'uint32))) (init-gen-rand 1234 *work-buffer*) (gen-rand-array out *work-buffer*) (assert (equal (coerce (subseq out 995 1000) 'list) '(2499610950 3057240914 1662679783 461224431 1168395933))) (gen-rand-array out *work-buffer*) (assert (equal (coerce (subseq out 995 1000) 'list) '(648219337 458306832 3674950976 4030368244 2918117049))))) (dotimes (i 10) (test)) ecl-16.1.2/contrib/deflate/000077500000000000000000000000001266352375300154245ustar00rootroot00000000000000ecl-16.1.2/contrib/deflate/COPYING000066400000000000000000000024501266352375300164600ustar00rootroot00000000000000 Copyright (C) 2000-2010 PMSF IT Consulting Pierre R. Mai Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. Except as contained in this notice, the name of the author shall not be used in advertising or otherwise to promote the sale, use or other dealings in this Software without prior written authorization from the author. ecl-16.1.2/contrib/deflate/README000066400000000000000000000021761266352375300163120ustar00rootroot00000000000000This library is an implementation of Deflate (RFC 1951) decompression, with optional support for ZLIB-style (RFC 1950) and gzip-style (RFC 1952) wrappers of deflate streams. It currently does not handle compression, although this is a natural extension. The implementation should be portable across all ANSI compliant CL implementations, but has been optimized mostly for SBCL and CMU CL (and other implementations that can generate fast code for word-sized integer calculations based on standard type declarations), and somewhat (mostly the otherwise very expensive CRC-32 calculations) for Lispworks. The performance is still a bit off from zlib/gzip (by a factor of around 3-3.5 on my systems), and while much of the performance loss is likely to be in the stream-based I/O, a less naive implementation of the huffman decoding step is also likely to benefit performance a bit. The implementation is licensed under the MIT-style license contained in the file COPYING and the header of each source file. Please direct any feedback to pmai@pmsf.de. A git repository of this library is available under http://github.com/pmai/Deflate/tree/master ecl-16.1.2/contrib/deflate/deflate.asd000066400000000000000000000034731266352375300175300ustar00rootroot00000000000000;;;; Deflate --- RFC 1951 Deflate Decompression ;;;; ;;;; Copyright (C) 2000-2010 PMSF IT Consulting Pierre R. Mai. ;;;; ;;;; Permission is hereby granted, free of charge, to any person obtaining ;;;; a copy of this software and associated documentation files (the ;;;; "Software"), to deal in the Software without restriction, including ;;;; without limitation the rights to use, copy, modify, merge, publish, ;;;; distribute, sublicense, and/or sell copies of the Software, and to ;;;; permit persons to whom the Software is furnished to do so, subject to ;;;; the following conditions: ;;;; ;;;; The above copyright notice and this permission notice shall be ;;;; included in all copies or substantial portions of the Software. ;;;; ;;;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, ;;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ;;;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. ;;;; IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR ;;;; OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ;;;; ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR ;;;; OTHER DEALINGS IN THE SOFTWARE. ;;;; ;;;; Except as contained in this notice, the name of the author shall ;;;; not be used in advertising or otherwise to promote the sale, use or ;;;; other dealings in this Software without prior written authorization ;;;; from the author. ;;;; ;;;; $Id$ (cl:in-package "CL-USER") ;;;; %File Description: ;;;; ;;;; This file contains the system definition form for the ;;;; Deflate Decompression Library. System definitions use the ;;;; ASDF system definition facility. ;;;; (asdf:defsystem '#:deflate :description "Deflate Decompression Library" :author "Pierre R. Mai " :components ((:file "deflate"))) ecl-16.1.2/contrib/deflate/deflate.lisp000066400000000000000000001033431266352375300177250ustar00rootroot00000000000000;;;; Deflate --- RFC 1951 Deflate Decompression ;;;; ;;;; Copyright (C) 2000-2010 PMSF IT Consulting Pierre R. Mai. ;;;; ;;;; Permission is hereby granted, free of charge, to any person obtaining ;;;; a copy of this software and associated documentation files (the ;;;; "Software"), to deal in the Software without restriction, including ;;;; without limitation the rights to use, copy, modify, merge, publish, ;;;; distribute, sublicense, and/or sell copies of the Software, and to ;;;; permit persons to whom the Software is furnished to do so, subject to ;;;; the following conditions: ;;;; ;;;; The above copyright notice and this permission notice shall be ;;;; included in all copies or substantial portions of the Software. ;;;; ;;;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, ;;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ;;;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. ;;;; IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR ;;;; OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ;;;; ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR ;;;; OTHER DEALINGS IN THE SOFTWARE. ;;;; ;;;; Except as contained in this notice, the name of the author shall ;;;; not be used in advertising or otherwise to promote the sale, use or ;;;; other dealings in this Software without prior written authorization ;;;; from the author. ;;;; ;;;; $Id$ (cl:defpackage "DEFLATE" (:use "COMMON-LISP") (:export #:decompression-error #:deflate-decompression-error #:zlib-decompression-error #:gzip-decompression-error #:inflate-stream #:inflate-zlib-stream #:parse-zlib-header #:parse-zlib-footer #:inflate-gzip-stream #:parse-gzip-header #:parse-gzip-footer #:gunzip)) (cl:in-package "DEFLATE") (declaim (optimize (safety 0) (speed 3))) ;;;; %File Description: ;;;; ;;;; This file contains routines implementing the RFC 1951 Deflate ;;;; Compression and/or Decompression method, as used by e.g. gzip and ;;;; other compression and archiving tools and protocols. It also ;;;; implements handling routines for zlib-style (RFC 1950) and ;;;; gzip-style (RFC 1952) wrappers around raw Deflate streams. ;;;; ;;;; The main entry points are the functions inflate-stream, and its ;;;; cousins inflate-zlib-stream and inflate-gzip-stream, which take ;;;; an input-stream and an output-stream as their arguments, and ;;;; inflate the RFC 1951, RFC 1950 or RFC 1952-style deflate formats ;;;; from the input-stream to the output-stream. ;;;; ;;; ;;; Conditions ;;; (define-condition decompression-error (simple-error) ()) (define-condition deflate-decompression-error (decompression-error) () (:report (lambda (c s) (with-standard-io-syntax (let ((*print-readably* nil)) (format s "Error detected during deflate decompression: ~?" (simple-condition-format-control c) (simple-condition-format-arguments c))))))) (define-condition zlib-decompression-error (decompression-error) () (:report (lambda (c s) (with-standard-io-syntax (let ((*print-readably* nil)) (format s "Error detected during zlib decompression: ~?" (simple-condition-format-control c) (simple-condition-format-arguments c))))))) (define-condition gzip-decompression-error (decompression-error) () (:report (lambda (c s) (with-standard-io-syntax (let ((*print-readably* nil)) (format s "Error detected during zlib decompression: ~?" (simple-condition-format-control c) (simple-condition-format-arguments c))))))) ;;; ;;; Adler-32 Checksums ;;; (defconstant +adler-32-start-value+ 1 "Start value for Adler-32 checksums as per RFC 1950.") (defconstant +adler-32-base+ 65521 "Base value for Adler-32 checksums as per RFC 1950.") (declaim (ftype (function ((unsigned-byte 32) (simple-array (unsigned-byte 8) (*)) fixnum) (unsigned-byte 32)) update-adler32-checksum)) (defun update-adler32-checksum (crc buffer end) (declare (type (unsigned-byte 32) crc) (type (simple-array (unsigned-byte 8) (*)) buffer) (type fixnum end) (optimize (speed 3) (debug 0) (space 0) (safety 0)) #+sbcl (sb-ext:muffle-conditions sb-ext:compiler-note)) (let ((s1 (ldb (byte 16 0) crc)) (s2 (ldb (byte 16 16) crc))) (declare (type (unsigned-byte 32) s1 s2)) (dotimes (i end) (declare (type fixnum i)) (setq s1 (mod (+ s1 (aref buffer i)) +adler-32-base+) s2 (mod (+ s2 s1) +adler-32-base+))) (dpb s2 (byte 16 16) s1))) ;;; ;;; CRC-32 Checksums ;;; (defconstant +crc-32-start-value+ 0 "Start value for CRC-32 checksums as per RFC 1952.") (defconstant +crc-32-polynomial+ #xedb88320 "CRC-32 Polynomial as per RFC 1952.") (declaim (ftype #-lispworks (function () (simple-array (unsigned-byte 32) (256))) #+lispworks (function () (sys:simple-int32-vector 256)) generate-crc32-table)) (defun generate-crc32-table () (let ((result #-lispworks (make-array 256 :element-type '(unsigned-byte 32)) #+lispworks (sys:make-simple-int32-vector 256))) (dotimes (i #-lispworks (length result) #+lispworks 256 result) (let ((cur i)) (dotimes (k 8) (setq cur (if (= 1 (logand cur 1)) (logxor (ash cur -1) +crc-32-polynomial+) (ash cur -1)))) #-lispworks (setf (aref result i) cur) #+lispworks (setf (sys:int32-aref result i) (sys:integer-to-int32 (dpb (ldb (byte 32 0) cur) (byte 32 0) (if (logbitp 31 cur) -1 0)))))))) (declaim (ftype (function ((unsigned-byte 32) (simple-array (unsigned-byte 8) (*)) fixnum) (unsigned-byte 32)) update-crc32-checksum)) #-lispworks (defun update-crc32-checksum (crc buffer end) (declare (type (unsigned-byte 32) crc) (type (simple-array (unsigned-byte 8) (*)) buffer) (type fixnum end) (optimize (speed 3) (debug 0) (space 0) (safety 0)) #+sbcl (sb-ext:muffle-conditions sb-ext:compiler-note)) (let ((table (load-time-value (generate-crc32-table))) (cur (logxor crc #xffffffff))) (declare (type (simple-array (unsigned-byte 32) (256)) table) (type (unsigned-byte 32) cur)) (dotimes (i end) (declare (type fixnum i)) (let ((index (logand #xff (logxor cur (aref buffer i))))) (declare (type (unsigned-byte 8) index)) (setq cur (logxor (aref table index) (ash cur -8))))) (logxor cur #xffffffff))) #+lispworks (defun update-crc32-checksum (crc buffer end) (declare (type (unsigned-byte 32) crc) (type (simple-array (unsigned-byte 8) (*)) buffer) (type fixnum end) (optimize (speed 3) (debug 0) (space 0) (safety 0) (float 0))) (let ((table (load-time-value (generate-crc32-table))) (cur (sys:int32-lognot (sys:integer-to-int32 (dpb (ldb (byte 32 0) crc) (byte 32 0) (if (logbitp 31 crc) -1 0)))))) (declare (type (sys:simple-int32-vector 256) table) (type sys:int32 cur)) (dotimes (i end) (declare (type fixnum i)) (let ((index (sys:int32-to-integer (sys:int32-logand #xff (sys:int32-logxor cur (aref buffer i)))))) (declare (type fixnum index)) (setq cur (sys:int32-logxor (sys:int32-aref table index) (sys:int32-logand #x00ffffff (sys:int32>> cur 8)))))) (ldb (byte 32 0) (sys:int32-to-integer (sys:int32-lognot cur))))) ;;; ;;; Helper Data Structures: Sliding Window Stream ;;; (eval-when (:compile-toplevel :load-toplevel :execute) (defconstant +sliding-window-size+ 32768 "Size of sliding window for RFC 1951 Deflate compression scheme.")) (defstruct sliding-window-stream (stream nil :type stream :read-only t) (buffer (make-array +sliding-window-size+ :element-type '(unsigned-byte 8)) :type (simple-array (unsigned-byte 8) (#.+sliding-window-size+)) :read-only t) (buffer-end 0 :type fixnum) (checksum nil :type symbol :read-only t) (checksum-value 0 :type (unsigned-byte 32))) (declaim (inline sliding-window-stream-write-byte)) (defun sliding-window-stream-write-byte (stream byte) (declare (type sliding-window-stream stream) (type (unsigned-byte 8) byte) #+sbcl (sb-ext:muffle-conditions sb-ext:compiler-note)) "Write a single byte to the sliding-window-stream." (let ((end (sliding-window-stream-buffer-end stream))) (declare (type fixnum end)) (unless (< end +sliding-window-size+) (write-sequence (sliding-window-stream-buffer stream) (sliding-window-stream-stream stream)) (case (sliding-window-stream-checksum stream) (:adler-32 (setf (sliding-window-stream-checksum-value stream) (update-adler32-checksum (sliding-window-stream-checksum-value stream) (sliding-window-stream-buffer stream) +sliding-window-size+))) (:crc-32 (setf (sliding-window-stream-checksum-value stream) (update-crc32-checksum (sliding-window-stream-checksum-value stream) (sliding-window-stream-buffer stream) +sliding-window-size+)))) (setq end 0)) (setf (aref (sliding-window-stream-buffer stream) end) byte (sliding-window-stream-buffer-end stream) (1+ end)))) (defun sliding-window-stream-flush (stream) (declare (type sliding-window-stream stream)) "Flush any remaining buffered bytes from the stream." (let ((end (sliding-window-stream-buffer-end stream))) (declare (type fixnum end)) (unless (zerop end) (case (sliding-window-stream-checksum stream) (:adler-32 (setf (sliding-window-stream-checksum-value stream) (update-adler32-checksum (sliding-window-stream-checksum-value stream) (sliding-window-stream-buffer stream) end))) (:crc-32 (setf (sliding-window-stream-checksum-value stream) (update-crc32-checksum (sliding-window-stream-checksum-value stream) (sliding-window-stream-buffer stream) end)))) (write-sequence (sliding-window-stream-buffer stream) (sliding-window-stream-stream stream) :end end)))) (defun sliding-window-stream-copy-bytes (stream distance length) (declare (type sliding-window-stream stream) (type fixnum distance length)) "Copy a number of bytes from the current sliding window." (let* ((end (sliding-window-stream-buffer-end stream)) (start (mod (- end distance) +sliding-window-size+)) (buffer (sliding-window-stream-buffer stream))) (declare (type fixnum end start) (type (simple-array (unsigned-byte 8) (#.+sliding-window-size+)) buffer)) (dotimes (i length) (sliding-window-stream-write-byte stream (aref buffer (mod (+ start i) +sliding-window-size+)))))) ;;; ;;; Helper Data Structures: Bit-wise Input Stream ;;; (defstruct bit-stream (stream nil :type stream :read-only t) (next-byte 0 :type fixnum) (bits 0 :type (unsigned-byte 29)) (bit-count 0 :type (unsigned-byte 8))) (declaim (inline bit-stream-get-byte)) (defun bit-stream-get-byte (stream) (declare (type bit-stream stream)) "Read another byte from the underlying stream." (the (unsigned-byte 8) (read-byte (bit-stream-stream stream)))) (declaim (inline bit-stream-read-bits)) (defun bit-stream-read-bits (stream bits) (declare (type bit-stream stream) #-ecl (type (unsigned-byte 8) bits)) "Read single or multiple bits from the given bit-stream." (loop while (< (bit-stream-bit-count stream) bits) do ;; Fill bits (setf (bit-stream-bits stream) (logior (bit-stream-bits stream) (the (unsigned-byte 29) (ash (bit-stream-get-byte stream) (bit-stream-bit-count stream)))) (bit-stream-bit-count stream) (+ (bit-stream-bit-count stream) 8))) ;; Return properly masked bits (if (= (bit-stream-bit-count stream) bits) (prog1 (bit-stream-bits stream) (setf (bit-stream-bits stream) 0 (bit-stream-bit-count stream) 0)) (prog1 (ldb (byte bits 0) (bit-stream-bits stream)) (setf (bit-stream-bits stream) (ash (bit-stream-bits stream) (- bits)) (bit-stream-bit-count stream) (- (bit-stream-bit-count stream) bits))))) (declaim (inline bit-stream-copy-block)) (defun bit-stream-copy-block (stream out-stream) (declare (type bit-stream stream) (type sliding-window-stream out-stream) (optimize (speed 3) (safety 0) (space 0) (debug 0))) "Copy a given block of bytes directly from the underlying stream." ;; Skip any remaining unprocessed bits (setf (bit-stream-bits stream) 0 (bit-stream-bit-count stream) 0) ;; Get LEN/NLEN and copy bytes (let* ((len (logior (bit-stream-get-byte stream) (ash (bit-stream-get-byte stream) 8))) (nlen (ldb (byte 16 0) (lognot (logior (bit-stream-get-byte stream) (ash (bit-stream-get-byte stream) 8)))))) (unless (= len nlen) (error 'deflate-decompression-error :format-control "Block length mismatch for stored block: LEN(~D) vs. NLEN(~D)!" :format-arguments (list len nlen))) (dotimes (i len) (sliding-window-stream-write-byte out-stream (bit-stream-get-byte stream))))) ;;; ;;; Huffman Coding ;;; ;;; A decode-tree struct contains all information necessary to decode ;;; the given canonical huffman code. Note that length-count contains ;;; the number of codes with a given length for each length, whereas ;;; the code-symbols array contains the symbols corresponding to the ;;; codes in canoical order of the codes. ;;; ;;; Decoding then uses this information and the principles underlying ;;; canonical huffman codes to determine whether the currently ;;; collected word falls between the first code and the last code for ;;; the current length, and if so, uses the offset to determine the ;;; code's symbol. Otherwise more bits are needed. (defstruct decode-tree (length-count (make-array 16 :element-type 'fixnum :initial-element 0) :type (simple-array fixnum (*)) :read-only t) (code-symbols (make-array 16 :element-type 'fixnum :initial-element 0) :type (simple-array fixnum (*)))) (defun make-huffman-decode-tree (code-lengths) "Construct a huffman decode-tree for the canonical huffman code with the code lengths of each symbol given in the input array." (let* ((max-length (reduce #'max code-lengths :initial-value 0)) (next-code (make-array (1+ max-length) :element-type 'fixnum :initial-element 0)) (code-symbols (make-array (length code-lengths) :element-type 'fixnum :initial-element 0)) (length-count (make-array (1+ max-length) :element-type 'fixnum :initial-element 0))) ;; Count length occurences and calculate offsets of smallest codes (loop for index from 1 to max-length for code = 0 then (+ code (aref length-count (1- index))) do (setf (aref next-code index) code) initially ;; Count length occurences (loop for length across code-lengths do (incf (aref length-count length)) finally (setf (aref length-count 0) 0))) ;; Construct code symbols mapping (loop for length across code-lengths for index upfrom 0 unless (zerop length) do (setf (aref code-symbols (aref next-code length)) index) (incf (aref next-code length))) ;; Return result (make-decode-tree :length-count length-count :code-symbols code-symbols))) (declaim (inline read-huffman-code)) (defun read-huffman-code (bit-stream decode-tree) (declare (type bit-stream bit-stream) (type decode-tree decode-tree) (optimize (speed 3) (safety 0) (space 0) (debug 0))) "Read the next huffman code word from the given bit-stream and return its decoded symbol, for the huffman code given by decode-tree." (loop with length-count of-type (simple-array fixnum (*)) = (decode-tree-length-count decode-tree) with code-symbols of-type (simple-array fixnum (*)) = (decode-tree-code-symbols decode-tree) for code of-type fixnum = (bit-stream-read-bits bit-stream 1) then (+ (* code 2) (bit-stream-read-bits bit-stream 1)) for index of-type fixnum = 0 then (+ index count) for first of-type fixnum = 0 then (* (+ first count) 2) for length of-type fixnum upfrom 1 below (length length-count) for count = (aref length-count length) thereis (when (< code (the fixnum (+ first count))) (aref code-symbols (+ index (- code first)))) finally (error 'deflate-decompression-error :format-control "Corrupted Data detected during decompression: ~ Incorrect huffman code (~X) in huffman decode!" :format-arguments (list code)))) ;;; ;;; Standard Huffman Tables ;;; (defparameter *std-lit-decode-tree* (make-huffman-decode-tree (concatenate 'vector (make-sequence 'vector 144 :initial-element 8) (make-sequence 'vector 112 :initial-element 9) (make-sequence 'vector 24 :initial-element 7) (make-sequence 'vector 8 :initial-element 8)))) (defparameter *std-dist-decode-tree* (make-huffman-decode-tree (make-sequence 'vector 32 :initial-element 5))) ;;; ;;; Dynamic Huffman Table Handling ;;; (defparameter *code-length-entry-order* #(16 17 18 0 8 7 9 6 10 5 11 4 12 3 13 2 14 1 15) "Order of Code Length Tree Code Lengths.") (defun decode-code-length-entries (bit-stream count decode-tree) "Decode the given number of code length entries from the bit-stream using the given decode-tree, and return a corresponding array of code lengths for further processing." (do ((result (make-array count :element-type 'fixnum :initial-element 0)) (index 0)) ((>= index count) result) (let ((code (read-huffman-code bit-stream decode-tree))) (ecase code ((0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) (setf (aref result index) code) (incf index)) (16 (let ((length (+ 3 (bit-stream-read-bits bit-stream 2)))) (dotimes (i length) (setf (aref result (+ index i)) (aref result (1- index)))) (incf index length))) (17 (let ((length (+ 3 (bit-stream-read-bits bit-stream 3)))) (dotimes (i length) (setf (aref result (+ index i)) 0)) (incf index length))) (18 (let ((length (+ 11 (bit-stream-read-bits bit-stream 7)))) (dotimes (i length) (setf (aref result (+ index i)) 0)) (incf index length))))))) (defun decode-huffman-tables (bit-stream) "Decode the stored huffman tables from the given bit-stream, returning the corresponding decode-trees for literals/length and distance codes." (let* ((hlit (bit-stream-read-bits bit-stream 5)) (hdist (bit-stream-read-bits bit-stream 5)) (hclen (bit-stream-read-bits bit-stream 4))) ;; Construct Code Length Decode Tree (let ((cl-decode-tree (loop with code-lengths = (make-array 19 :element-type '(unsigned-byte 8) :initial-element 0) for index from 0 below (+ hclen 4) for code-length = (bit-stream-read-bits bit-stream 3) for code-index = (aref *code-length-entry-order* index) do (setf (aref code-lengths code-index) code-length) finally (return (make-huffman-decode-tree code-lengths))))) ;; Decode Code Length Table and generate separate huffman trees (let ((entries (decode-code-length-entries bit-stream (+ hlit 257 hdist 1) cl-decode-tree))) (values (make-huffman-decode-tree (subseq entries 0 (+ hlit 257))) (make-huffman-decode-tree (subseq entries (+ hlit 257)))))))) ;;; ;;; Compressed Block Handling ;;; (declaim (inline decode-length-entry)) (defun decode-length-entry (symbol bit-stream) "Decode the given length symbol into a proper length specification." (cond ((<= symbol 264) (- symbol 254)) ((<= symbol 268) (+ 11 (* (- symbol 265) 2) (bit-stream-read-bits bit-stream 1))) ((<= symbol 272) (+ 19 (* (- symbol 269) 4) (bit-stream-read-bits bit-stream 2))) ((<= symbol 276) (+ 35 (* (- symbol 273) 8) (bit-stream-read-bits bit-stream 3))) ((<= symbol 280) (+ 67 (* (- symbol 277) 16) (bit-stream-read-bits bit-stream 4))) ((<= symbol 284) (+ 131 (* (- symbol 281) 32) (bit-stream-read-bits bit-stream 5))) ((= symbol 285) 258) (t (error 'deflate-decompression-error :format-control "Strange Length Code in bitstream: ~D" :format-arguments (list symbol))))) (declaim (inline decode-distance-entry)) (defun decode-distance-entry (symbol bit-stream) "Decode the given distance symbol into a proper distance specification." (cond ((<= symbol 3) (1+ symbol)) (t (multiple-value-bind (order offset) (truncate symbol 2) (let* ((extra-bits (1- order)) (factor (ash 1 extra-bits))) (+ (1+ (ash 1 order)) (* offset factor) (bit-stream-read-bits bit-stream extra-bits))))))) (defun decode-huffman-block (bit-stream window-stream lit-decode-tree dist-decode-tree) "Decode the huffman code block using the huffman codes given by lit-decode-tree and dist-decode-tree." (do ((symbol (read-huffman-code bit-stream lit-decode-tree) (read-huffman-code bit-stream lit-decode-tree))) ((= symbol 256)) (cond ((<= symbol 255) (sliding-window-stream-write-byte window-stream symbol)) (t (let ((length (decode-length-entry symbol bit-stream)) (distance (decode-distance-entry (read-huffman-code bit-stream dist-decode-tree) bit-stream))) (sliding-window-stream-copy-bytes window-stream distance length)))))) ;;; ;;; Block Handling Code ;;; (defun decode-block (bit-stream window-stream) "Decompress a block read from bit-stream into window-stream." (let* ((finalp (not (zerop (bit-stream-read-bits bit-stream 1)))) (type (bit-stream-read-bits bit-stream 2))) (ecase type (#b00 (bit-stream-copy-block bit-stream window-stream)) (#b01 (decode-huffman-block bit-stream window-stream *std-lit-decode-tree* *std-dist-decode-tree*)) (#b10 (multiple-value-bind (lit-decode-tree dist-decode-tree) (decode-huffman-tables bit-stream) (decode-huffman-block bit-stream window-stream lit-decode-tree dist-decode-tree))) (#b11 (error 'deflate-decompression-error :format-control "Encountered Reserved Block Type ~D!" :format-arguments (list type)))) (not finalp))) ;;; ;;; ZLIB - RFC 1950 handling ;;; (defun parse-zlib-header (input-stream) "Parse a ZLIB-style header as per RFC 1950 from the input-stream and return the compression-method, compression-level dictionary-id and flags fields of the header as return values. Checks the header for corruption and signals a zlib-decompression-error in case of corruption." (let ((compression-method (read-byte input-stream)) (flags (read-byte input-stream))) (unless (zerop (mod (+ (* compression-method 256) flags) 31)) (error 'zlib-decompression-error :format-control "Corrupted Header ~2,'0X,~2,'0X!" :format-arguments (list compression-method flags))) (let ((dict (unless (zerop (ldb (byte 1 5) flags)) (parse-zlib-checksum input-stream)))) (values (ldb (byte 4 0) compression-method) (ldb (byte 4 4) compression-method) dict (ldb (byte 2 6) flags))))) (defun parse-zlib-checksum (input-stream) (+ (* (read-byte input-stream) 256 256 256) (* (read-byte input-stream) 256 256) (* (read-byte input-stream) 256) (read-byte input-stream))) (defun parse-zlib-footer (input-stream) "Parse the ZLIB-style footer as per RFC 1950 from the input-stream and return the Adler-32 checksum contained in the footer as its return value." (parse-zlib-checksum input-stream)) ;;; ;;; GZIP - RFC 1952 handling ;;; (defconstant +gzip-header-id1+ 31 "GZIP Header Magic Value ID1 as per RFC 1952.") (defconstant +gzip-header-id2+ 139 "GZIP Header Magic Value ID2 as per RFC 1952.") (defun parse-gzip-header (input-stream) "Parse a GZIP-style header as per RFC 1952 from the input-stream and return the compression-method, text-flag, modification time, XFLAGS, OS, FEXTRA flags, filename, comment and CRC16 fields of the header as return values (or nil if any given field is not present). Checks the header for magic values and correct flags settings and signals a gzip-decompression-error in case of incorrect or unsupported magic values or flags." (let ((id1 (read-byte input-stream)) (id2 (read-byte input-stream)) (compression-method (read-byte input-stream)) (flags (read-byte input-stream))) (unless (and (= id1 +gzip-header-id1+) (= id2 +gzip-header-id2+)) (error 'gzip-decompression-error :format-control "Header missing magic values ~2,'0X,~2,'0X (got ~2,'0X,~2,'0X instead)!" :format-arguments (list +gzip-header-id1+ +gzip-header-id2+ id1 id2))) (unless (= compression-method 8) (error 'gzip-decompression-error :format-control "Unknown compression-method in Header ~2,'0X!" :format-arguments (list compression-method))) (unless (zerop (ldb (byte 3 5) flags)) (error 'gzip-decompression-error :format-control "Unknown flags in Header ~2,'0X!" :format-arguments (list flags))) (values compression-method ;; FTEXT (= 1 (ldb (byte 1 0) flags)) ;; MTIME (parse-gzip-mtime input-stream) ;; XFLAGS (read-byte input-stream) ;; OS (read-byte input-stream) ;; FEXTRA (unless (zerop (ldb (byte 1 2) flags)) (parse-gzip-extra input-stream)) ;; FNAME (unless (zerop (ldb (byte 1 3) flags)) (parse-gzip-string input-stream)) ;; FCOMMENT (unless (zerop (ldb (byte 1 4) flags)) (parse-gzip-string input-stream)) ;; CRC16 (unless (zerop (ldb (byte 1 1) flags)) (+ (read-byte input-stream) (* (read-byte input-stream 256))))))) (defun parse-gzip-mtime (input-stream) (let ((time (+ (read-byte input-stream) (* (read-byte input-stream) 256) (* (read-byte input-stream) 256 256) (* (read-byte input-stream) 256 256 256)))) (if (zerop time) nil (+ time 2208988800)))) (defun parse-gzip-extra (input-stream) (let* ((length (+ (read-byte input-stream) (* (read-byte input-stream) 256))) (result (make-array length :element-type '(unsigned-byte 8)))) (read-sequence result input-stream) result)) (defun parse-gzip-string (input-stream) (with-output-to-string (string) (loop for value = (read-byte input-stream) until (zerop value) do (write-char (code-char value) string)))) (defun parse-gzip-checksum (input-stream) (+ (read-byte input-stream) (* (read-byte input-stream) 256) (* (read-byte input-stream) 256 256) (* (read-byte input-stream) 256 256 256))) (defun parse-gzip-footer (input-stream) "Parse the GZIP-style footer as per RFC 1952 from the input-stream and return the CRC-32 checksum and ISIZE fields contained in the footer as its return values." (values (parse-gzip-checksum input-stream) ;; ISIZE (+ (read-byte input-stream) (* (read-byte input-stream) 256) (* (read-byte input-stream) 256 256) (* (read-byte input-stream) 256 256 256)))) ;;; ;;; Main Entry Points ;;; (defun inflate-stream (input-stream output-stream &key checksum) "Inflate the RFC 1951 data from the given input stream into the given output stream, which are required to have an element-type of (unsigned-byte 8). If checksum is given, it indicates the checksumming algorithm to employ in calculating a checksum of the expanded content, which is then returned from this function. Valid values are :adler-32 for Adler-32 checksum (see RFC 1950), or :crc-32 for CRC-32 as per ISO 3309 (see RFC 1952, ZIP)." (loop with window-stream = (make-sliding-window-stream :stream output-stream :checksum checksum :checksum-value (ecase checksum ((nil) 0) (:crc-32 +crc-32-start-value+) (:adler-32 +adler-32-start-value+))) with bit-stream = (make-bit-stream :stream input-stream) while (decode-block bit-stream window-stream) finally (sliding-window-stream-flush window-stream) (when checksum (return (sliding-window-stream-checksum-value window-stream))))) (defun inflate-zlib-stream (input-stream output-stream &key check-checksum) "Inflate the RFC 1950 zlib data from the given input stream into the given output stream, which are required to have an element-type of (unsigned-byte 8). This returns the Adler-32 checksum of the file as its first return value, with the compression level as its second return value. Note that it is the responsibility of the caller to check whether the expanded data matches the Adler-32 checksum, unless the check-checksum keyword argument is set to true, in which case the checksum is checked internally and a zlib-decompression-error is signalled if they don't match." (multiple-value-bind (cm cinfo dictid flevel) (parse-zlib-header input-stream) (unless (= cm 8) (error 'zlib-decompression-error :format-control "Unknown compression method ~D!" :format-arguments (list cm))) (unless (<= cinfo 7) (error 'zlib-decompression-error :format-control "Unsupported sliding window size 2^~D = ~D!" :format-arguments (list (+ 8 cinfo) (expt 2 (+ 8 cinfo))))) (unless (null dictid) (error 'zlib-decompression-error :format-control "Unknown preset dictionary id ~8,'0X!" :format-arguments (list dictid))) (let ((checksum-new (inflate-stream input-stream output-stream :checksum (when check-checksum :adler-32))) (checksum-old (parse-zlib-footer input-stream))) (when (and check-checksum (not (= checksum-old checksum-new))) (error 'zlib-decompression-error :format-control "Checksum mismatch for decompressed stream: ~8,'0X != ~8,'0X!" :format-arguments (list checksum-old checksum-new))) (values checksum-old flevel)))) (defun inflate-gzip-stream (input-stream output-stream &key check-checksum) "Inflate the RFC 1952 gzip data from the given input stream into the given output stream, which are required to have an element-type of (unsigned-byte 8). This returns the CRC-32 checksum of the file as its first return value, with any filename, modification time, and comment fields as further return values or nil if not present. Note that it is the responsibility of the caller to check whether the expanded data matches the CRC-32 checksum, unless the check-checksum keyword argument is set to true, in which case the checksum is checked internally and a gzip-decompression-error is signalled if they don't match." (multiple-value-bind (cm ftext mtime xfl os fextra fname fcomment) (parse-gzip-header input-stream) (declare (ignore ftext xfl os fextra)) (unless (= cm 8) (error 'gzip-decompression-error :format-control "Unknown compression method ~D!" :format-arguments (list cm))) (let ((checksum-new (inflate-stream input-stream output-stream :checksum (when check-checksum :crc-32))) (checksum-old (parse-gzip-footer input-stream))) ;; Handle Checksums (when (and check-checksum (not (= checksum-old checksum-new))) (error 'gzip-decompression-error :format-control "Checksum mismatch for decompressed stream: ~8,'0X != ~8,'0X!" :format-arguments (list checksum-old checksum-new))) (values checksum-old fname mtime fcomment)))) (defun gunzip (input-file output-file) (with-open-file (input input-file :element-type '(unsigned-byte 8)) (with-open-file (output output-file :direction :output :if-exists :supersede :element-type '(unsigned-byte 8)) (inflate-gzip-stream input output))) (probe-file output-file)) (provide '#:deflate) ecl-16.1.2/contrib/defsystem/000077500000000000000000000000001266352375300160235ustar00rootroot00000000000000ecl-16.1.2/contrib/defsystem/README000066400000000000000000000021401266352375300167000ustar00rootroot00000000000000This is MK:DEFSYSTEM 3.6i, a 'make' utility for Common Lisp. The current distribution contains a file `defsystem.lisp', a `docs' directory, a `debian' directory, and this README file. MK:DEFSYSTEM 3.6i works on most Common Lisp implementations and it is used by a wide variety of projects. INSTALLATION To install MK:DEFSYSTEM 3.x, you should just make sure to LOAD the file `defystem.lisp' in you CL environment. You can do that by putting the appropriate LOAD statement in you CL initialization file (which most implementations have). DOCUMENTATION The documentation for MK:DEFSYSTEM 3.6i is part of a the following CMU TR Mark Kantrowitz, "Portable Utilities for Common Lisp, User Guide and Implementation Notes", Tech Report CMU-CS-91-143, School of Computer Science, Carnegie Mellon University, May 1991. The `docs' directory contains a quick introduction to MK:DEFSYSTEM. HELP and BUG REPORTS For help and bug reports, the `clocc-list@sourceforge.net' mailing list is usually the right place where to send requests and other correspondence. ======= Enjoy. Marco Antoniotti, 2005-09-04 ecl-16.1.2/contrib/defsystem/defsystem.lisp000066400000000000000000007177111266352375300207350ustar00rootroot00000000000000;;; -*- Mode: Lisp; Package: make -*- ;;; -*- Mode: CLtL; Syntax: Common-Lisp -*- ;;; DEFSYSTEM 3.6 Interim. ;;; defsystem.lisp -- ;;; **************************************************************** ;;; MAKE -- A Portable Defsystem Implementation ******************** ;;; **************************************************************** ;;; This is a portable system definition facility for Common Lisp. ;;; Though home-grown, the syntax was inspired by fond memories of the ;;; defsystem facility on Symbolics 3600's. The exhaustive lists of ;;; filename extensions for various lisps and the idea to have one ;;; "operate-on-system" function instead of separate "compile-system" ;;; and "load-system" functions were taken from Xerox Corp.'s PCL ;;; system. ;;; This system improves on both PCL and Symbolics defsystem utilities ;;; by performing a topological sort of the graph of file-dependency ;;; constraints. Thus, the components of the system need not be listed ;;; in any special order, because the defsystem command reorganizes them ;;; based on their constraints. It includes all the standard bells and ;;; whistles, such as not recompiling a binary file that is up to date ;;; (unless the user specifies that all files should be recompiled). ;;; Originally written by Mark Kantrowitz, School of Computer Science, ;;; Carnegie Mellon University, October 1989. ;;; MK:DEFSYSTEM 3.6 Interim ;;; ;;; Copyright (c) 1989 - 1999 Mark Kantrowitz. All rights reserved. ;;; 1999 - 2005 Mark Kantrowitz and Marco Antoniotti. All ;;; rights reserved. ;;; Use, copying, modification, merging, publishing, distribution ;;; and/or sale of this software, source and/or binary files and ;;; associated documentation files (the "Software") and of derivative ;;; works based upon this Software are permitted, as long as the ;;; following conditions are met: ;;; o this copyright notice is included intact and is prominently ;;; visible in the Software ;;; o if modifications have been made to the source code of the ;;; this package that have not been adopted for inclusion in the ;;; official version of the Software as maintained by the Copyright ;;; holders, then the modified package MUST CLEARLY identify that ;;; such package is a non-standard and non-official version of ;;; the Software. Furthermore, it is strongly encouraged that any ;;; modifications made to the Software be sent via e-mail to the ;;; MK-DEFSYSTEM maintainers for consideration of inclusion in the ;;; official MK-DEFSYSTEM package. ;;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, ;;; EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ;;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. ;;; IN NO EVENT SHALL M. KANTROWITZ AND M. ANTONIOTTI BE LIABLE FOR ANY ;;; CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, ;;; TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE ;;; SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ;;; Except as contained in this notice, the names of M. Kantrowitz and ;;; M. Antoniotti shall not be used in advertising or otherwise to promote ;;; the sale, use or other dealings in this Software without prior written ;;; authorization from M. Kantrowitz and M. Antoniotti. ;;; Please send bug reports, comments and suggestions to . ;;; ******************************** ;;; Change Log ********************* ;;; ******************************** ;;; ;;; Note: Several of the fixes from 30-JAN-91 and 31-JAN-91 were done in ;;; September and October 1990, but not documented until January 1991. ;;; ;;; akd = Abdel Kader Diagne ;;; as = Andreas Stolcke ;;; bha = Brian Anderson ;;; brad = Brad Miller ;;; bw = Robert Wilhelm ;;; djc = Daniel J. Clancy ;;; fdmm = Fernando D. Mato Mira ;;; gc = Guillaume Cartier ;;; gi = Gabriel Inaebnit ;;; gpw = George Williams ;;; hkt = Rick Taube ;;; ik = Ik Su Yoo ;;; jk = John_Kolojejchick@MORK.CIMDS.RI.CMU.EDU ;;; kt = Kevin Thompson ;;; kc = Kaelin Colclasure ;;; kmr = Kevin M. Rosenberg ;;; lmh = Liam M. Healy ;;; mc = Matthew Cornell ;;; oc = Oliver Christ ;;; rs = Ralph P. Sobek ;;; rs2 = Richard Segal ;;; sb = Sean Boisen ;;; ss = Steve Strassman ;;; tar = Thomas A. Russ ;;; toni = Anton Beschta ;;; yc = Yang Chen ;;; ;;; Thanks to Steve Strassmann and ;;; Sean Boisen for detailed bug reports and ;;; miscellaneous assistance. Thanks also to Gabriel Inaebnit ;;; for help with VAXLisp bugs. ;;; ;;; 05-NOV-90 hkt Changed canonicalize-system-name to make system ;;; names package independent. Interns them in the ;;; keyword package. Thus either strings or symbols may ;;; be used to name systems from the user's point of view. ;;; 05-NOV-90 hkt Added definition FIND-SYSTEM to allow OOS to ;;; work on systems whose definition hasn't been loaded yet. ;;; 05-NOV-90 hkt Added definitions COMPILE-SYSTEM and LOAD-SYSTEM ;;; as alternates to OOS for naive users. ;;; 05-NOV-90 hkt Shadowing-import of 'defsystem in Allegro CL 3.1 [NeXT] ;;; into USER package instead of import. ;;; 15-NOV-90 mk Changed package name to "MAKE", eliminating "DEFSYSTEM" ;;; to avoid conflicts with allegro, symbolics packages ;;; named "DEFSYSTEM". ;;; 30-JAN-91 mk Modified append-directories to work with the ;;; logical-pathnames system. ;;; 30-JAN-91 mk Append-directories now works with Sun CL4.0. Also, fixed ;;; bug wrt Lucid 4.0's pathnames (which changed from lcl3.0 ;;; -- 4.0 uses a list for the directory slot, whereas ;;; 3.0 required a string). Possible fix to symbolics bug. ;;; 30-JAN-91 mk Defined NEW-REQUIRE to make redefinition of REQUIRE ;;; cleaner. Replaced all calls to REQUIRE in this file with ;;; calls to NEW-REQUIRE, which should avoid compiler warnings. ;;; 30-JAN-91 mk In VAXLisp, when we redefine lisp:require, the compiler ;;; no longer automatically executes require forms when it ;;; encounters them in a file. The user can always wrap an ;;; (eval-when (compile load eval) ...) around the require ;;; form. Alternately, see commented out code near the ;;; redefinition of lisp:require which redefines it as a ;;; macro instead. ;;; 30-JAN-91 mk Added parameter :version to operate-on-system. If it is ;;; a number, that number is used as part of the binary ;;; directory name as the place to store and load files. ;;; If NIL (the default), uses regular binary directory. ;;; If T, tries to find the most recent version of the ;;; binary directory. ;;; 30-JAN-91 mk Added global variable *use-timeouts* (default: t), which ;;; specifies whether timeouts should be used in ;;; Y-OR-N-P-WAIT. This is provided for users whose lisps ;;; don't handle read-char-no-hang properly, so that they ;;; can set it to NIL to disable the timeouts. Usually the ;;; reason for this is the lisp is run on top of UNIX, ;;; which buffers input LINES (and provides input editing). ;;; To get around this we could always turn CBREAK mode ;;; on and off, but there's no way to do this in a portable ;;; manner. ;;; 30-JAN-91 mk Fixed bug where in :test t mode it was actually providing ;;; the system, instead of faking it. ;;; 30-JAN-91 mk Changed storage of system definitions to a hash table. ;;; Changed canonicalize-system-name to coerce the system ;;; names to uppercase strings. Since we're no longer using ;;; get, there's no need to intern the names as symbols, ;;; and strings don't have packages to cause problems. ;;; Added UNDEFSYSTEM, DEFINED-SYSTEMS, and DESCRIBE-SYSTEM. ;;; Added :delete-binaries command. ;;; 31-JAN-91 mk Franz Allegro CL has a defsystem in the USER package, ;;; so we need to do a shadowing import to avoid name ;;; conflicts. ;;; 31-JAN-91 mk Fixed bug in compile-and-load-operation where it was ;;; only loading newly compiled files. ;;; 31-JAN-91 mk Added :load-time slot to components to record the ;;; file-write-date of the binary/source file that was loaded. ;;; Now knows "when" (which date version) the file was loaded. ;;; Added keyword :minimal-load and global *minimal-load* ;;; to enable defsystem to avoid reloading unmodified files. ;;; Note that if B depends on A, but A is up to date and ;;; loaded and the user specified :minimal-load T, then A ;;; will not be loaded even if B needs to be compiled. So ;;; if A is an initializations file, say, then the user should ;;; not specify :minimal-load T. ;;; 31-JAN-91 mk Added :load-only slot to components. If this slot is ;;; specified as non-NIL, skips over any attempts to compile ;;; the files in the component. (Loading the file satisfies ;;; the need to recompile.) ;;; 31-JAN-91 mk Eliminated use of set-alist-lookup and alist-lookup, ;;; replacing it with hash tables. It was too much bother, ;;; and rather brittle too. ;;; 31-JAN-91 mk Defined #@ macro character for use with AFS @sys ;;; feature simulator. #@"directory" is then synonymous ;;; with (afs-binary-directory "directory"). ;;; 31-JAN-91 mk Added :private-file type of module. It is similar to ;;; :file, but has an absolute pathname. This allows you ;;; to specify a different version of a file in a system ;;; (e.g., if you're working on the file in your home ;;; directory) without completely rewriting the system ;;; definition. ;;; 31-JAN-91 mk Operations on systems, such as :compile and :load, ;;; now propagate to subsystems the system depends on ;;; if *operations-propagate-to-subsystems* is T (the default) ;;; and the systems were defined using either defsystem ;;; or as a :system component of another system. Thus if ;;; a system depends on another, it can now recompile the ;;; other. ;;; 01-FEB-91 mk Added default definitions of PROVIDE/REQUIRE/*MODULES* ;;; for lisps that have thrown away these definitions in ;;; accordance with CLtL2. ;;; 01-FEB-91 mk Added :compile-only slot to components. Analogous to ;;; :load-only. If :compile-only is T, will not load the ;;; file on operation :compile. Either compiles or loads ;;; the file, but not both. In other words, compiling the ;;; file satisfies the demand to load it. This is useful ;;; for PCL defmethod and defclass definitions, which wrap ;;; an (eval-when (compile load eval) ...) around the body ;;; of the definition -- we save time by not loading the ;;; compiled code, since the eval-when forces it to be ;;; loaded. Note that this may not be entirely safe, since ;;; CLtL2 has added a :load keyword to compile-file, and ;;; some lisps may maintain a separate environment for ;;; the compiler. This feature is for the person who asked ;;; that a :COMPILE-SATISFIES-LOAD keyword be added to ;;; modules. It's named :COMPILE-ONLY instead to match ;;; :LOAD-ONLY. ;;; 11-FEB-91 mk Now adds :mk-defsystem to features list, to allow ;;; special cased loading of defsystem if not already ;;; present. ;;; 19-FEB-91 duff Added filename extension for hp9000/300's running Lucid. ;;; 26-FEB-91 mk Distinguish between toplevel systems (defined with ;;; defsystem) and systems defined as a :system module ;;; of a defsystem. The former can depend only on systems, ;;; while the latter can depend on anything at the same ;;; level. ;;; 12-MAR-91 mk Added :subsystem component type to be a system with ;;; pathnames relative to its parent component. ;;; 12-MAR-91 mk Uncommented :device :absolute for CMU pathnames, so ;;; that the leading slash is included. ;;; 12-MAR-91 brad Patches for Allegro 4.0.1 on Sparc. ;;; 12-MAR-91 mk Changed definition of format-justified-string so that ;;; it no longer depends on the ~<~> format directives, ;;; because Allegro 4.0.1 has a bug which doesn't support ;;; them. Anyway, the new definition is twice as fast ;;; and conses half as much as FORMAT. ;;; 12-MAR-91 toni Remove nils from list in expand-component-components. ;;; 12-MAR-91 bw If the default-package and system have the same name, ;;; and the package is not loaded, this could lead to ;;; infinite loops, so we bomb out with an error. ;;; Fixed bug in default packages. ;;; 13-MAR-91 mk Added global *providing-blocks-load-propagation* to ;;; control whether system dependencies are loaded if they ;;; have already been provided. ;;; 13-MAR-91 brad In-package is a macro in CLtL2 lisps, so we change ;;; the package manually in operate-on-component. ;;; 15-MAR-91 mk Modified *central-registry* to be either a single ;;; directory pathname, or a list of directory pathnames ;;; to be checked in order. ;;; 15-MAR-91 rs Added afs-source-directory to handle versions when ;;; compiling C code under lisp. Other minor changes to ;;; translate-version and operate-on-system. ;;; 21-MAR-91 gi Fixed bug in defined-systems. ;;; 22-MAR-91 mk Replaced append-directories with new version that works ;;; by actually appending the directories, after massaging ;;; them into the proper format. This should work for all ;;; CLtL2-compliant lisps. ;;; 09-APR-91 djc Missing package prefix for lp:pathname-host-type. ;;; Modified component-full-pathname to work for logical ;;; pathnames. ;;; 09-APR-91 mk Added *dont-redefine-require* to control whether ;;; REQUIRE is redefined. Fixed minor bugs in redefinition ;;; of require. ;;; 12-APR-91 mk (pathname-host nil) causes an error in MCL 2.0b1 ;;; 12-APR-91 mc Ported to MCL2.0b1. ;;; 16-APR-91 mk Fixed bug in needs-loading where load-time and ;;; file-write-date got swapped. ;;; 16-APR-91 mk If the component is load-only, defsystem shouldn't ;;; tell you that there is no binary and ask you if you ;;; want to load the source. ;;; 17-APR-91 mc Two additional operations for MCL. ;;; 21-APR-91 mk Added feature requested by ik. *files-missing-is-an-error* ;;; new global variable which controls whether files (source ;;; and binary) missing cause a continuable error or just a ;;; warning. ;;; 21-APR-91 mk Modified load-file-operation to allow compilation of source ;;; files during load if the binary files are old or ;;; non-existent. This adds a :compile-during-load keyword to ;;; oos, and load-system. Global *compile-during-load* sets ;;; the default (currently :query). ;;; 21-APR-91 mk Modified find-system so that there is a preference for ;;; loading system files from disk, even if the system is ;;; already defined in the environment. ;;; 25-APR-91 mk Removed load-time slot from component defstruct and added ;;; function COMPONENT-LOAD-TIME to store the load times in a ;;; hash table. This is safer than the old definition because ;;; it doesn't wipe out load times every time the system is ;;; redefined. ;;; 25-APR-91 mk Completely rewrote load-file-operation. Fixed some bugs ;;; in :compile-during-load and in the behavior of defsystem ;;; when multiple users are compiling and loading a system ;;; instead of just a single user. ;;; 16-MAY-91 mk Modified FIND-SYSTEM to do the right thing if the system ;;; definition file cannot be found. ;;; 16-MAY-91 mk Added globals *source-pathname-default* and ;;; *binary-pathname-default* to contain default values for ;;; :source-pathname and :binary-pathname. For example, set ;;; *source-pathname-default* to "" to avoid having to type ;;; :source-pathname "" all the time. ;;; 27-MAY-91 mk Fixed bug in new-append-directories where directory ;;; components of the form "foo4.0" would appear as "foo4", ;;; since pathname-name truncates the type. Changed ;;; pathname-name to file-namestring. ;;; 3-JUN-91 gc Small bug in new-append-directories; replace (when ;;; abs-name) with (when (not (null-string abs-name))) ;;; 4-JUN-91 mk Additional small change to new-append-directories for ;;; getting the device from the relative pname if the abs ;;; pname is "". This is to fix a small behavior in CMU CL old ;;; compiler. Also changed (when (not (null-string abs-name))) ;;; to have an (and abs-name) in there. ;;; 8-JAN-92 sb Added filename extension for defsystem under Lucid Common ;;; Lisp/SGO 3.0.1+. ;;; 8-JAN-92 mk Changed the definition of prompt-string to work around an ;;; AKCL bug. Essentially, AKCL doesn't default the colinc to ;;; 1 if the colnum is provided, so we hard code it. ;;; 8-JAN-92 rs (pathname-directory (pathname "")) returns '(:relative) in ;;; Lucid, instead of NIL. Changed new-append-directories and ;;; test-new-append-directories to reflect this. ;;; 8-JAN-92 mk Fixed problem related to *load-source-if-no-binary*. ;;; compile-and-load-source-if-no-binary wasn't checking for ;;; the existence of the binary if this variable was true, ;;; causing the file to not be compiled. ;;; 8-JAN-92 mk Fixed problem with null-string being called on a pathname ;;; by returning NIL if the argument isn't a string. ;;; 3-NOV-93 mk In Allegro 4.2, pathname device is :unspecific by default. ;;; 11-NOV-93 fdmm Fixed package definition lock problem when redefining ;;; REQUIRE on ACL. ;;; 11-NOV-93 fdmm Added machine and software types for SGI and IRIX. It is ;;; important to distinguish the OS version and CPU type in ;;; SGI+ACL, since ACL 4.1 on IRIX 4.x and ACL 4.2 on IRIX 5.x ;;; have incompatible .fasl files. ;;; 01-APR-94 fdmm Fixed warning problem when redefining REQUIRE on LispWorks. ;;; 01-NOV-94 fdmm Replaced (software-type) call in ACL by code extracting ;;; the interesting parts from (software-version) [deleted ;;; machine name and id]. ;;; 03-NOV-94 fdmm Added a hook (*compile-file-function*), that is funcalled ;;; by compile-file-operation, so as to support other languages ;;; running on top of Common Lisp. ;;; The default is to compile Common Lisp. ;;; 03-NOV-94 fdmm Added SCHEME-COMPILE-FILE, so that defsystem can now ;;; compile Pseudoscheme files. ;;; 04-NOV-94 fdmm Added the exported generic function SET-LANGUAGE, to ;;; have a clean, easy to extend interface for telling ;;; defsystem which language to assume for compilation. ;;; Currently supported arguments: :common-lisp, :scheme. ;;; 11-NOV-94 kc Ported to Allegro CL for Windows 2.0 (ACLPC) and CLISP. ;;; 18-NOV-94 fdmm Changed the entry *filename-extensions* for LispWorks ;;; to support any platform. ;;; Added entries for :mcl and :clisp too. ;;; 16-DEC-94 fdmm Added and entry for CMU CL on SGI to *filename-extensions*. ;;; 16-DEC-94 fdmm Added OS version identification for CMU CL on SGI. ;;; 16-DEC-94 fdmm For CMU CL 17 : Bypassed make-pathnames call fix ;;; in NEW-APPEND-DIRECTORIES. ;;; 16-DEC-94 fdmm Added HOME-SUBDIRECTORY to fix CMU's ignorance about `~' ;;; when specifying registries. ;;; 16-DEC-94 fdmm For CMU CL 17 : Bypassed :device fix in make-pathnames call ;;; in COMPONENT-FULL-PATHNAME. This fix was also reported ;;; by kc on 12-NOV-94. CMU CL 17 now supports CLtL2 pathnames. ;;; 16-DEC-94 fdmm Removed a quote before the call to read in the readmacro ;;; #@. This fixes a really annoying misfeature (couldn't do ;;; #@(concatenate 'string "foo/" "bar"), for example). ;;; 03-JAN-95 fdmm Do not include :pcl in *features* if :clos is there. ;;; 2-MAR-95 mk Modified fdmm's *central-registry* change to use ;;; user-homedir-pathname and to be a bit more generic in the ;;; pathnames. ;;; 2-MAR-95 mk Modified fdmm's updates to *filename-extensions* to handle ;;; any CMU CL binary extensions. ;;; 2-MAR-95 mk Make kc's port to ACLPC a little more generic. ;;; 2-MAR-95 mk djc reported a bug, in which GET-SYSTEM was not returning ;;; a system despite the system's just having been loaded. ;;; The system name specified in the :depends-on was a ;;; lowercase string. I am assuming that the system name ;;; in the defsystem form was a symbol (I haven't verified ;;; that this was the case with djc, but it is the only ;;; reasonable conclusion). So, CANONICALIZE-SYSTEM-NAME ;;; was storing the system in the hash table as an ;;; uppercase string, but attempting to retrieve it as a ;;; lowercase string. This behavior actually isn't a bug, ;;; but a user error. It was intended as a feature to ;;; allow users to use strings for system names when ;;; they wanted to distinguish between two different systems ;;; named "foo.system" and "Foo.system". However, this ;;; user error indicates that this was a bad design decision. ;;; Accordingly, CANONICALIZE-SYSTEM-NAME now uppercases ;;; even strings for retrieving systems, and the comparison ;;; in *modules* is now case-insensitive. The result of ;;; this change is if the user cannot have distinct ;;; systems in "Foo.system" and "foo.system" named "Foo" and ;;; "foo", because they will clobber each other. There is ;;; still case-sensitivity on the filenames (i.e., if the ;;; system file is named "Foo.system" and you use "foo" in ;;; the :depends-on, it won't find it). We didn't take the ;;; further step of requiring system filenames to be lowercase ;;; because we actually find this kind of case-sensitivity ;;; to be useful, when maintaining two different versions ;;; of the same system. ;;; 7-MAR-95 mk Added simplistic handling of logical pathnames. Also ;;; modified new-append-directories so that it'll try to ;;; split up pathname directories that are strings into a ;;; list of the directory components. Such directories aren't ;;; ANSI CL, but some non-conforming implementations do it. ;;; 7-MAR-95 mk Added :proclamations to defsystem form, which can be used ;;; to set the compiler optimization level before compilation. ;;; For example, ;;; :proclamations '(optimize (safety 3) (speed 3) (space 0)) ;;; 7-MAR-95 mk Defsystem now tells the user when it reloads the system ;;; definition. ;;; 7-MAR-95 mk Fixed problem pointed out by yc. If ;;; *source-pathname-default* is "" and there is no explicit ;;; :source-pathname specified for a file, the file could ;;; wind up with an empty file name. In other words, this ;;; global default shouldn't apply to :file components. Added ;;; explicit test for null strings, and when present replaced ;;; them with NIL (for binary as well as source, and also for ;;; :private-file components). ;;; 7-MAR-95 tar Fixed defsystem to work on TI Explorers (TI CL). ;;; 7-MAR-95 jk Added machine-type-translation for Decstation 5000/200 ;;; under Allegro 3.1 ;;; 7-MAR-95 as Fixed bug in AKCL-1-615 in which defsystem added a ;;; subdirectory "RELATIVE" to all filenames. ;;; 7-MAR-95 mk Added new test to test-new-append-directories to catch the ;;; error fixed by as. Essentially, this error occurs when the ;;; absolute-pathname has no directory (i.e., it has a single ;;; pathname component as in "foo" and not "foo/bar"). If ;;; RELATIVE ever shows up in the Result, we now know to ;;; add an extra conditionalization to prevent abs-keyword ;;; from being set to :relative. ;;; 7-MAR-95 ss Miscellaneous fixes for MCL 2.0 final. ;;; *compile-file-verbose* not in MCL, *version variables ;;; need to occur before AFS-SOURCE-DIRECTORY definition, ;;; and certain code needed to be in the CCL: package. ;;; 8-MAR-95 mk Y-OR-N-P-WAIT uses a busy-waiting. On Lisp systems where ;;; the time functions cons, such as CMU CL, this can cause a ;;; lot of ugly garbage collection messages. Modified the ;;; waiting to include calls to SLEEP, which should reduce ;;; some of the consing. ;;; 8-MAR-95 mk Replaced fdmm's SET-LANGUAGE enhancement with a more ;;; general extension, along the lines suggested by akd. ;;; Defsystem now allows components to specify a :language ;;; slot, such as :language :lisp, :language :scheme. This ;;; slot is inherited (with the default being :lisp), and is ;;; used to obtain compilation and loading functions for ;;; components, as well as source and binary extensions. The ;;; compilation and loading functions can be overridden by ;;; specifying a :compiler or :loader in the system ;;; definition. Also added :documentation slot to the system ;;; definition. ;;; Where this comes in real handy is if one has a ;;; compiler-compiler implemented in Lisp, and wants the ;;; system to use the compiler-compiler to create a parser ;;; from a grammar and then compile parser. To do this one ;;; would create a module with components that looked ;;; something like this: ;;; ((:module cc :components ("compiler-compiler")) ;;; (:module gr :compiler 'cc :loader #'ignore ;;; :source-extension "gra" ;;; :binary-extension "lisp" ;;; :depends-on (cc) ;;; :components ("sample-grammar")) ;;; (:module parser :depends-on (gr) ;;; :components ("sample-grammar"))) ;;; Defsystem would then compile and load the compiler, use ;;; it (the function cc) to compile the grammar into a parser, ;;; and then compile the parser. The only tricky part is ;;; cc is defined by the system, and one can't include #'cc ;;; in the system definition. However, one could include ;;; a call to mk:define-language in the compiler-compiler file, ;;; and define :cc as a language. This is the prefered method. ;;; 8-MAR-95 mk New definition of topological-sort suggested by rs2. This ;;; version avoids the call to SORT, but in practice isn't ;;; much faster. However, it avoids the need to maintain a ;;; TIME slot in the topsort-node structure. ;;; 8-MAR-95 mk rs2 also pointed out that the calls to MAKE-PATHNAME and ;;; NAMESTRING in COMPONENT-FULL-PATHNAME are a major reason ;;; why defsystem is slow. Accordingly, I've changed ;;; COMPONENT-FULL-PATHNAME to include a call to NAMESTRING ;;; (and removed all other calls to NAMESTRING), and also made ;;; a few changes to minimize the number of calls to ;;; COMPONENT-FULL-PATHNAME, such as memoizing it. See To Do ;;; below for other related comments. ;;; 8-MAR-95 mk Added special hack requested by Steve Strassman, which ;;; allows one to specify absolute pathnames in the shorthand ;;; for a list of components, and have defsystem recognize ;;; which are absolute and which are relative. ;;; I actually think this would be a good idea, but I haven't ;;; tested it, so it is disabled by default. Search for ;;; *enable-straz-absolute-string-hack* to enable it. ;;; 8-MAR-95 kt Fixed problem with EXPORT in AKCL 1.603, in which it wasn't ;;; properly exporting the value of the global export ;;; variables. ;;; 8-MAR-95 mk Added UNMUNGE-LUCID to fix nasty problem with COMPILE-FILE ;;; in Lucid. Lucid apparently tries to merge the :output-file ;;; with the source file when the :output-file is a relative ;;; pathname. Wierd, and definitely non-standard. ;;; 9-MAR-95 mk Changed ALLEGRO-MAKE-SYSTEM-FASL to also include the files ;;; in any systems the system depends on, as per a ;;; request of oc. ;;; 9-MAR-95 mk Some version of CMU CL couldn't hack a call to ;;; MAKE-PATHNAME with :host NIL. I'm not sure which version ;;; it is, but the current version doesn't have this problem. ;;; If given :host nil, it defaults the host to ;;; COMMON-LISP::*UNIX-HOST*. So I haven't "fixed" this ;;; problem. ;;; 9-MAR-95 mk Integrated top-level commands for Allegro designed by bha ;;; into the code, with slight modifications. ;;; 9-MAR-95 mk Instead of having COMPUTE-SYSTEM-PATH check the current ;;; directory in a hard-coded fashion, include the current ;;; directory in the *central-registry*, as suggested by ;;; bha and others. ;;; 9-MAR-95 bha Support for Logical Pathnames in Allegro. ;;; 9-MAR-95 mk Added modified version of bha's DEFSYSPATH idea. ;;; 13-MAR-95 mk Added a macro for the simple serial case, where a system ;;; (or module) is simple a list of files, each of which ;;; depends on the previous one. If the value of :components ;;; is a list beginning with :serial, it expands each ;;; component and makes it depend on the previous component. ;;; For example, (:serial "foo" "bar" "baz") would create a ;;; set of components where "baz" depended on "bar" and "bar" ;;; on "foo". ;;; 13-MAR-95 mk *** Now version 3.0. This version is a interim bug-fix and ;;; update, since I do not have the time right now to complete ;;; the complete overhaul and redesign. ;;; Major changes in 3.0 include CMU CL 17, CLISP, ACLPC, TI, ;;; LispWorks and ACL(SGI) support, bug fixes for ACL 4.1/4.2. ;;; 14-MAR-95 fdmm Finally added the bit of code to discriminate cleanly ;;; among different lisps without relying on (software-version) ;;; idiosyncracies. ;;; You can now customize COMPILER-TYPE-TRANSLATION so that ;;; AFS-BINARY-DIRECTORY can return a different value for ;;; different lisps on the same platform. ;;; If you use only one compiler, do not care about supporting ;;; code for multiple versions of it, and want less verbose ;;; directory names, just set *MULTIPLE-LISP-SUPPORT* to nil. ;;; 17-MAR-95 lmh Added EVAL-WHEN for one of the MAKE-PACKAGE calls. ;;; CMU CL's RUN-PROGRAM is in the extensions package. ;;; ABSOLUTE-FILE-NAMESTRING-P was missing :test keyword ;;; Rearranged conditionalization in DIRECTORY-TO-LIST to ;;; suppress compiler warnings in CMU CL. ;;; 17-MAR-95 mk Added conditionalizations to avoid certain CMU CL compiler ;;; warnings reported by lmh. ;;; 19990610 ma Added shadowing of 'HARDCOPY-SYSTEM' for LW Personal Ed. ;;; 19991211 ma NEW VERSION 4.0 started. ;;; 19991211 ma Merged in changes requested by T. Russ of ;;; ISI. Please refer to the special "ISI" comments to ;;; understand these changes ;;; 20000228 ma The symbols FIND-SYSTEM, LOAD-SYSTEM, DEFSYSTEM, ;;; COMPILE-SYSTEM and HARDCOPY-SYSTEM are no longer ;;; imported in the COMMON-LISP-USER package. ;;; Cfr. the definitions of *EXPORTS* and ;;; *SPECIAL-EXPORTS*. ;;; 2000-07-21 rlt Add COMPILER-OPTIONS to defstruct to allow user to ;;; specify special compiler options for a particular ;;; component. ;;; 2002-01-08 kmr Changed allegro symbols to lowercase to support ;;; case-sensitive images ;;;--------------------------------------------------------------------------- ;;; ISI Comments ;;; ;;; 19991211 Marco Antoniotti ;;; These comments come from the "ISI Branch". I believe I did ;;; include the :load-always extension correctly. The other commets ;;; seem superseded by other changes made to the system in the ;;; following years. Some others are now useless with newer systems ;;; (e.g. filename truncation for new Windows based CL ;;; implementations.) ;;; 1-OCT-92 tar Fixed problem with TI Lisp machines and append-directory. ;;; 1-OCT-92 tar Made major modifications to compile-file-operation and ;;; load-file-operation to reduce the number of probe-file ;;; and write-date inquiries. This makes the system run much ;;; faster through slow network connections. ;;; 13-OCT-92 tar Added :load-always slot to components. If this slot is ;;; specified as non-NIL, always loads the component. ;;; This does not trigger dependent compilation. ;;; (This can be useful when macro definitions needed ;;; during compilation are changed by later files. In ;;; this case, not reloading up-to-date files can ;;; cause different results.) ;;; 28-OCT-93 tar Allegro 4.2 causes an error on (pathname-device nil) ;;; 14-SEP-94 tar Disable importing of symbols into (CL-)USER package ;;; to minimize conflicts with other defsystem utilities. ;;; 10-NOV-94 tar Added filename truncation code to support Franz Allegro ;;; PC with it's 8 character filename limitation. ;;; 15-MAY-98 tar Changed host attribute for pathnames to support LispWorks ;;; (Windows) pathnames which reference other Drives. Also ;;; updated file name convention. ;;; 9-NOV-98 tar Updated new-append-directories for Lucid 5.0 ;;; ;;; ******************************** ;;; Ports ************************** ;;; ******************************** ;;; ;;; DEFSYSTEM has been tested (successfully) in the following lisps: ;;; CMU Common Lisp (M2.9 15-Aug-90, Compiler M1.8 15-Aug-90) ;;; CMU Common Lisp (14-Dec-90 beta, Python Compiler 0.0 PMAX/Mach) ;;; CMU Common Lisp 17f (Python 1.0) ;;; Franz Allegro Common Lisp 3.1.12 (ExCL 3/30/90) ;;; Franz Allegro Common Lisp 4.0/4.1/4.2 ;;; Franz Allegro Common Lisp for Windows (2.0) ;;; Lucid Common Lisp (Version 2.1 6-DEC-87) ;;; Lucid Common Lisp (3.0 [SPARC,SUN3]) ;;; Lucid Common Lisp (4.0 [SPARC,SUN3]) ;;; VAXLisp (v2.2) [VAX/VMS] ;;; VAXLisp (v3.1) ;;; Harlequin LispWorks ;;; CLISP (CLISP3 [SPARC]) ;;; Symbolics XL12000 (Genera 8.3) ;;; Scieneer Common Lisp (SCL) 1.1 ;;; Macintosh Common Lisp ;;; ECL ;;; ;;; DEFSYSTEM needs to be tested in the following lisps: ;;; OpenMCL ;;; Symbolics Common Lisp (8.0) ;;; KCL (June 3, 1987 or later) ;;; AKCL (1.86, June 30, 1987 or later) ;;; TI (Release 4.1 or later) ;;; Ibuki Common Lisp (01/01, October 15, 1987) ;;; Golden Common Lisp (3.1 IBM-PC) ;;; HP Common Lisp (same as Lucid?) ;;; Procyon Common Lisp ;;; ******************************** ;;; To Do ************************** ;;; ******************************** ;;; ;;; COMPONENT-FULL-PATHNAME is a major source of slowness in the system ;;; because of all the calls to the expensive operations MAKE-PATHNAME ;;; and NAMESTRING. To improve performance, DEFSYSTEM should be reworked ;;; to avoid any need to call MAKE-PATHNAME and NAMESTRING, as the logical ;;; pathnames package does. Unfortunately, I don't have the time to do this ;;; right now. Instead, I installed a temporary improvement by memoizing ;;; COMPONENT-FULL-PATHNAME to cache previous calls to the function on ;;; a component by component and type by type basis. The cache is ;;; cleared before each call to OOS, in case filename extensions change. ;;; But DEFSYSTEM should really be reworked to avoid this problem and ;;; ensure greater portability and to also handle logical pathnames. ;;; ;;; Also, PROBE-FILE and FILE-WRITE-DATE are other sources of slowness. ;;; Perhaps by also memoizing FILE-WRITE-DATE and reimplementing PROBE-FILE ;;; in terms of FILE-WRITE-DATE, can achieve a further speed-up. This was ;;; suggested by Steven Feist (feist@ils.nwu.edu). ;;; ;;; True CLtL2 logical pathnames support -- can't do it, because CLtL2 ;;; doesn't have all the necessary primitives, and even in Allegro CL 4.2 ;;; (namestring #l"foo:bar;baz.lisp") ;;; does not work properly. ;;; ;;; Create separate stand-alone documentation for defsystem, and also ;;; a test suite. ;;; ;;; Change SYSTEM to be a class instead of a struct, and make it a little ;;; more generic, so that it permits alternate system definitions. ;;; Replace OPERATE-ON-SYSTEM with MAP-SYSTEM (args: function, system-name, ;;; &rest options) ;;; ;;; Add a patch directory mechanism. Perhaps have several directories ;;; with code in them, and the first one with the specified file wins? ;;; LOAD-PATCHES function. ;;; ;;; Need way to load old binaries even if source is newer. ;;; ;;; Allow defpackage forms/package definitions in the defsystem? If ;;; a package not defined, look for and load a file named package.pkg? ;;; ;;; need to port for GNU CL (ala kcl)? ;;; ;;; Someone asked whether one can have :file components at top-level. I believe ;;; this is the case, but should double-check that it is possible (and if ;;; not, make it so). ;;; ;;; A common error/misconception seems to involve assuming that :system ;;; components should include the name of the system file, and that ;;; defsystem will automatically load the file containing the system ;;; definition and propagate operations to it. Perhaps this would be a ;;; nice feature to add. ;;; ;;; If a module is :load-only t, then it should not execute its :finally-do ;;; and :initially-do clauses during compilation operations, unless the ;;; module's files happen to be loaded during the operation. ;;; ;;; System Class. Customizable delimiters. ;;; ;;; Load a system (while not loading anything already loaded) ;;; and inform the user of out of date fasls with the choice ;;; to load the old fasl or recompile and then load the new ;;; fasl? ;;; ;;; modify compile-file-operation to handle a query keyword.... ;;; ;;; Perhaps systems should keep around the file-write-date of the system ;;; definition file, to prevent excessive reloading of the system definition? ;;; ;;; load-file-operation needs to be completely reworked to simplify the ;;; logic of when files get loaded or not. ;;; ;;; Need to revamp output: Nesting and indenting verbose output doesn't ;;; seem cool, especially when output overflows the 80-column margins. ;;; ;;; Document various ways of writing a system. simple (short) form ;;; (where :components is just a list of filenames) in addition to verbose. ;;; Put documentation strings in code. ;;; ;;; :load-time for modules and systems -- maybe record the time the system ;;; was loaded/compiled here and print it in describe-system? ;;; ;;; Make it easy to define new functions that operate on a system. For ;;; example, a function that prints out a list of files that have changed, ;;; hardcopy-system, edit-system, etc. ;;; ;;; If a user wants to have identical systems for different lisps, do we ;;; force the user to use logical pathnames? Or maybe we should write a ;;; generic-pathnames package that parses any pathname format into a ;;; uniform underlying format (i.e., pull the relevant code out of ;;; logical-pathnames.lisp and clean it up a bit). ;;; ;;; Verify that Mac pathnames now work with append-directories. ;;; ;;; A common human error is to violate the modularization by making a file ;;; in one module depend on a file in another module, instead of making ;;; one module depend on the other. This is caught because the dependency ;;; isn't found. However, is there any way to provide a more informative ;;; error message? Probably not, especially if the system has multiple ;;; files of the same name. ;;; ;;; For a module none of whose files needed to be compiled, have it print out ;;; "no files need recompilation". ;;; ;;; Write a system date/time to a file? (version information) I.e., if the ;;; filesystem supports file version numbers, write an auxiliary file to ;;; the system definition file that specifies versions of the system and ;;; the version numbers of the associated files. ;;; ;;; Add idea of a patch directory. ;;; ;;; In verbose printout, have it log a date/time at start and end of ;;; compilation: ;;; Compiling system "test" on 31-Jan-91 21:46:47 ;;; by Defsystem version v2.0 01-FEB-91. ;;; ;;; Define other :force options: ;;; :query allows user to specify that a file not normally compiled ;;; should be. OR ;;; :confirm allows user to specify that a file normally compiled ;;; shouldn't be. AND ;;; ;;; We currently assume that compilation-load dependencies and if-changed ;;; dependencies are identical. However, in some cases this might not be ;;; true. For example, if we change a macro we have to recompile functions ;;; that depend on it (except in lisps that automatically do this, such ;;; as the new CMU Common Lisp), but not if we change a function. Splitting ;;; these apart (with appropriate defaulting) would be nice, but not worth ;;; doing immediately since it may save only a couple of file recompilations, ;;; while making defsystem much more complex than it already is. ;;; ;;; Current dependencies are limited to siblings. Maybe we should allow ;;; nephews and uncles? So long as it is still a DAG, we can sort it. ;;; Answer: No. The current setup enforces a structure on the modularity. ;;; Otherwise, why should we have modules if we're going to ignore it? ;;; ;;; Currently a file is recompiled more or less if the source is newer ;;; than the binary or if the file depends on a file that has changed ;;; (i.e., was recompiled in this session of a system operation). ;;; Neil Goldman has pointed out that whether a file ;;; needs recompilation is really independent of the current session of ;;; a system operation, and depends only on the file-write-dates of the ;;; source and binary files for a system. Thus a file should require ;;; recompilation in the following circumstances: ;;; 1. If a file's source is newer than its binary, or ;;; 2. If a file's source is not newer than its binary, but the file ;;; depends directly or indirectly on a module (or file) that is newer. ;;; For a regular file use the file-write-date (FWD) of the source or ;;; binary, whichever is more recent. For a load-only file, use the only ;;; available FWD. For a module, use the most recent (max) FWD of any of ;;; its components. ;;; The impact of this is that instead of using a boolean CHANGED variable ;;; throughout the code, we need to allow CHANGED to be NIL/T/ or ;;; maybe just the FWD timestamp, and to use the value of CHANGED in ;;; needs-compilation decisions. (Use of NIL/T as values is an optimization. ;;; The FWD timestamp which indicates the most recent time of any changes ;;; should be sufficient.) This will affect not just the ;;; compile-file-operation, but also the load-file-operation because of ;;; compilation during load. Also, since FWDs will be used more prevalently, ;;; we probably should couple this change with the inclusion of load-times ;;; in the component defstruct. This is a tricky and involved change, and ;;; requires more thought, since there are subtle cases where it might not ;;; be correct. For now, the change will have to wait until the DEFSYSTEM ;;; redesign. ;;; ******************************************************************** ;;; How to Use this System ********************************************* ;;; ******************************************************************** ;;; To use this system, ;;; 1. If you want to have a central registry of system definitions, ;;; modify the value of the variable *central-registry* below. ;;; 2. Load this file (defsystem.lisp) in either source or compiled form, ;;; 3. Load the file containing the "defsystem" definition of your system, ;;; 4. Use the function "operate-on-system" to do things to your system. ;;; For more information, see the documentation and examples in ;;; lisp-utilities.ps. ;;; ******************************** ;;; Usage Comments ***************** ;;; ******************************** ;;; If you use symbols in the system definition file, they get interned in ;;; the COMMON-LISP-USER package, which can lead to name conflicts when ;;; the system itself seeks to export the same symbol to the COMMON-LISP-USER ;;; package. The workaround is to use strings instead of symbols for the ;;; names of components in the system definition file. In the major overhaul, ;;; perhaps the user should be precluded from using symbols for such ;;; identifiers. ;;; ;;; If you include a tilde in the :source-pathname in Allegro, as in "~/lisp", ;;; file name expansion is much slower than if you use the full pathname, ;;; as in "/user/USERID/lisp". ;;; ;;; **************************************************************** ;;; Lisp Code ****************************************************** ;;; **************************************************************** ;;; ******************************** ;;; Massage CLtL2 onto *features* ** ;;; ******************************** ;;; Let's be smart about CLtL2 compatible Lisps: (eval-when (compile load eval) #+(or (and allegro-version>= (version>= 4 0)) :mcl :sbcl) (pushnew :cltl2 *features*)) ;;; ******************************** ;;; Provide/Require/*modules* ****** ;;; ******************************** ;;; Since CLtL2 has dropped require and provide from the language, some ;;; lisps may not have the functions PROVIDE and REQUIRE and the ;;; global *MODULES*. So if lisp::provide and user::provide are not ;;; defined, we define our own. ;;; Hmmm. CMU CL old compiler gives bogus warnings here about functions ;;; and variables not being declared or bound, apparently because it ;;; sees that (or (fboundp 'lisp::require) (fboundp 'user::require)) returns ;;; T, so it doesn't really bother when compiling the body of the unless. ;;; The new compiler does this properly, so I'm not going to bother ;;; working around this. ;;; Some Lisp implementations return bogus warnings about assuming ;;; *MODULE-FILES* and *LIBRARY* to be special, and CANONICALIZE-MODULE-NAME ;;; and MODULE-FILES being undefined. Don't worry about them. ;;; Now that ANSI CL includes PROVIDE and REQUIRE again, is this code ;;; necessary? #-(or :CMU :vms :mcl :lispworks :clisp :gcl :sbcl :cormanlisp :scl :ecl (and allegro-version>= (version>= 4 1))) (eval-when #-(or :lucid) (:compile-toplevel :load-toplevel :execute) #+(or :lucid) (compile load eval) (unless (or (fboundp 'lisp::require) (fboundp 'user::require) #+(and :excl (and allegro-version>= (version>= 4 0))) (fboundp 'cltl1::require) #+:lispworks (fboundp 'system::require)) #-:lispworks (in-package "LISP") #+:lispworks (in-package "SYSTEM") (export '(*modules* provide require)) ;; Documentation strings taken almost literally from CLtL1. (defvar *modules* () "List of names of the modules that have been loaded into Lisp so far. It is used by PROVIDE and REQUIRE.") ;; We provide two different ways to define modules. The default way ;; is to put either a source or binary file with the same name ;; as the module in the library directory. The other way is to define ;; the list of files in the module with defmodule. ;; The directory listed in *library* is implementation dependent, ;; and is intended to be used by Lisp manufacturers as a place to ;; store their implementation dependent packages. ;; Lisp users should use systems and *central-registry* to store ;; their packages -- it is intended that *central-registry* is ;; set by the user, while *library* is set by the lisp. (defvar *library* nil ; "/usr/local/lisp/Modules/" "Directory within the file system containing files, where the name of a file is the same as the name of the module it contains.") (defvar *module-files* (make-hash-table :test #'equal) "Hash table mapping from module names to list of files for the module. REQUIRE loads these files in order.") (defun canonicalize-module-name (name) ;; if symbol, string-downcase the printrep to make nicer filenames. (if (stringp name) name (string-downcase (string name)))) (defmacro defmodule (name &rest files) "Defines a module NAME to load the specified FILES in order." `(setf (gethash (canonicalize-module-name ,name) *module-files*) ',files)) (defun module-files (name) (gethash name *module-files*)) (defun provide (name) "Adds a new module name to the list of modules maintained in the variable *modules*, thereby indicating that the module has been loaded. Name may be a string or symbol -- strings are case-senstive, while symbols are treated like lowercase strings. Returns T if NAME was not already present, NIL otherwise." (let ((module (canonicalize-module-name name))) (unless (find module *modules* :test #'string=) ;; Module not present. Add it and return T to signify that it ;; was added. (push module *modules*) t))) (defun require (name &optional pathname) "Tests whether a module is already present. If the module is not present, loads the appropriate file or set of files. The pathname argument, if present, is a single pathname or list of pathnames whose files are to be loaded in order, left to right. If the pathname is nil, the system first checks if a module was defined using defmodule and uses the pathnames so defined. If that fails, it looks in the library directory for a file with name the same as that of the module. Returns T if it loads the module." (let ((module (canonicalize-module-name name))) (unless (find module *modules* :test #'string=) ;; Module is not already present. (when (and pathname (not (listp pathname))) ;; If there's a pathname or pathnames, ensure that it's a list. (setf pathname (list pathname))) (unless pathname ;; If there's no pathname, try for a defmodule definition. (setf pathname (module-files module))) (unless pathname ;; If there's still no pathname, try the library directory. (when *library* (setf pathname (concatenate 'string *library* module)) ;; Test if the file exists. ;; We assume that the lisp will default the file type ;; appropriately. If it doesn't, use #+".fasl" or some ;; such in the concatenate form above. (if (probe-file pathname) ;; If it exists, ensure we've got a list (setf pathname (list pathname)) ;; If the library file doesn't exist, we don't want ;; a load error. (setf pathname nil)))) ;; Now that we've got the list of pathnames, let's load them. (dolist (pname pathname t) (load pname :verbose nil)))))) ) ; eval-when ;;; ******************************** ;;; Set up Package ***************** ;;; ******************************** ;;; Unfortunately, lots of lisps have their own defsystems, some more ;;; primitive than others, all uncompatible, and all in the DEFSYSTEM ;;; package. To avoid name conflicts, we've decided to name this the ;;; MAKE package. A nice side-effect is that the short nickname ;;; MK is my initials. #+(or clisp cormanlisp ecl (and gcl defpackage) sbcl) (defpackage "MAKE" (:use "COMMON-LISP") (:nicknames "MK")) #-(or :sbcl :cltl2 :lispworks :ecl :scl) (in-package "MAKE" :nicknames '("MK")) ;;; For CLtL2 compatible lisps... #+(and :excl :allegro-v4.0 :cltl2) (defpackage "MAKE" (:nicknames "MK" "make" "mk") (:use :common-lisp) (:import-from cltl1 *modules* provide require)) ;;; *** Marco Antoniotti 19970105 ;;; In Allegro 4.1, 'provide' and 'require' are not external in ;;; 'CLTL1'. However they are in 'COMMON-LISP'. Hence the change. #+(and :excl :allegro-v4.1 :cltl2) (defpackage "MAKE" (:nicknames "MK" "make" "mk") (:use :common-lisp) ) #+(and :excl :allegro-version>= (version>= 4 2)) (defpackage "MAKE" (:nicknames "MK" "make" "mk") (:use :common-lisp)) #+:lispworks (defpackage "MAKE" (:nicknames "MK") (:use "COMMON-LISP") (:import-from system *modules* provide require) (:export "DEFSYSTEM" "COMPILE-SYSTEM" "LOAD-SYSTEM" "DEFINE-LANGUAGE" "*MULTIPLE-LISP-SUPPORT*")) #+:mcl (defpackage "MAKE" (:nicknames "MK") (:use "COMMON-LISP") (:import-from ccl *modules* provide require)) ;;; *** Marco Antoniotti 19951012 ;;; The code below, is originally executed also for CMUCL. However I ;;; believe this is wrong, since CMUCL comes with its own defpackage. ;;; I added the extra :CMU in the 'or'. #+(and :cltl2 (not (or :cmu :clisp :sbcl (and :excl (or :allegro-v4.0 :allegro-v4.1)) :mcl))) (eval-when (compile load eval) (unless (find-package "MAKE") (make-package "MAKE" :nicknames '("MK") :use '("COMMON-LISP")))) ;;; *** Marco Antoniotti 19951012 ;;; Here I add the proper defpackage for CMU #+:CMU (defpackage "MAKE" (:use "COMMON-LISP" "CONDITIONS") (:nicknames "MK")) #+:sbcl (defpackage "MAKE" (:use "COMMON-LISP") (:nicknames "MK")) #+:scl (defpackage :make (:use :common-lisp) (:nicknames :mk)) #+(or :cltl2 :lispworks :scl) (eval-when (compile load eval) (in-package "MAKE")) #+ecl (in-package "MAKE") ;;; *** Marco Antoniotti 19970105 ;;; 'provide' is not esternal in 'CLTL1' in Allegro v 4.1 #+(and :excl :allegro-v4.0 :cltl2) (cltl1:provide 'make) #+(and :excl :allegro-v4.0 :cltl2) (provide 'make) #+:openmcl (cl:provide 'make) #+(and :mcl (not :openmcl)) (ccl:provide 'make) #+(and :cltl2 (not (or (and :excl (or :allegro-v4.0 :allegro-v4.1)) :mcl))) (provide 'make) #+:lispworks (provide 'make) #-(or :cltl2 :lispworks) (provide 'make) (pushnew :mk-defsystem *features*) ;;; Some compatibility issues. Mostly for CormanLisp. ;;; 2002-02-20 Marco Antoniotti #+cormanlisp (defun compile-file-pathname (pathname-designator) (merge-pathnames (make-pathname :type "fasl") (etypecase pathname-designator (pathname pathname-designator) (string (parse-namestring pathname-designator)) ;; We need FILE-STREAM here as well. ))) #+cormanlisp (defun file-namestring (pathname-designator) (let ((p (etypecase pathname-designator (pathname pathname-designator) (string (parse-namestring pathname-designator)) ;; We need FILE-STREAM here as well. ))) (namestring (make-pathname :directory () :name (pathname-name p) :type (pathname-type p) :version (pathname-version p))))) ;;; The external interface consists of *exports* and *other-exports*. ;;; AKCL (at least 1.603) grabs all the (export) forms and puts them up top in ;;; the compile form, so that you can't use a defvar with a default value and ;;; then a succeeding export as well. (eval-when (compile load eval) (defvar *special-exports* nil) (defvar *exports* nil) (defvar *other-exports* nil) (export (setq *exports* '(operate-on-system oos afs-binary-directory afs-source-directory files-in-system))) (export (setq *special-exports* '())) (export (setq *other-exports* '(*central-registry* *bin-subdir* add-registry-location list-central-registry-directories print-central-registry-directories find-system defsystem compile-system load-system hardcopy-system system-definition-pathname missing-component missing-component-name missing-component-component missing-module missing-system register-foreign-system machine-type-translation software-type-translation compiler-type-translation ;; require define-language allegro-make-system-fasl files-which-need-compilation undefsystem defined-systems describe-system clean-system edit-system ;hardcopy-system system-source-size make-system-tag-table *defsystem-version* *compile-during-load* *minimal-load* *dont-redefine-require* *files-missing-is-an-error* *reload-systems-from-disk* *source-pathname-default* *binary-pathname-default* *multiple-lisp-support* run-unix-program *default-shell* run-shell-command ))) ) ;;; We import these symbols into the USER package to make them ;;; easier to use. Since some lisps have already defined defsystem ;;; in the user package, we may have to shadowing-import it. #| #-(or :sbcl :cmu :ccl :allegro :excl :lispworks :symbolics) (eval-when (compile load eval) (import *exports* #-(or :cltl2 :lispworks) "USER" #+(or :cltl2 :lispworks) "COMMON-LISP-USER") (import *special-exports* #-(or :cltl2 :lispworks) "USER" #+(or :cltl2 :lispworks) "COMMON-LISP-USER")) #+(or :sbcl :cmu :ccl :allegro :excl :lispworks :symbolics) (eval-when (compile load eval) (import *exports* #-(or :cltl2 :lispworks) "USER" #+(or :cltl2 :lispworks) "COMMON-LISP-USER") (shadowing-import *special-exports* #-(or :cltl2 :lispworks) "USER" #+(or :cltl2 :lispworks) "COMMON-LISP-USER")) |# #-(or :PCL :CLOS :scl) (when (find-package "PCL") (pushnew :pcl *modules*) (pushnew :pcl *features*)) ;;; ******************************** ;;; Defsystem Version ************** ;;; ******************************** (defparameter *defsystem-version* "3.6 Interim, 2005-09-01" "Current version number/date for MK:DEFSYSTEM.") ;;; ******************************** ;;; Customizable System Parameters * ;;; ******************************** (defvar *dont-redefine-require* #+cmu (if (find-symbol "*MODULE-PROVIDER-FUNCTIONS*" "EXT") t nil) #+(or clisp sbcl) t #+allegro t #-(or cmu sbcl clisp allegro) nil "If T, prevents the redefinition of REQUIRE. This is useful for lisps that treat REQUIRE specially in the compiler.") (defvar *multiple-lisp-support* t "If T, afs-binary-directory will try to return a name dependent on the particular lisp compiler version being used.") ;;; home-subdirectory -- ;;; HOME-SUBDIRECTORY is used only in *central-registry* below. ;;; Note that CMU CL 17e does not understand the ~/ shorthand for home ;;; directories. ;;; ;;; Note: ;;; 20020220 Marco Antoniotti ;;; The #-cormanlisp version is the original one, which is broken anyway, since ;;; it is UNIX dependent. ;;; I added the kludgy #+cormalisp (v 1.5) one, since it is missing ;;; the ANSI USER-HOMEDIR-PATHNAME function. #-cormanlisp (defun home-subdirectory (directory) (concatenate 'string #+(or :sbcl :cmu :scl) "home:" #-(or :sbcl :cmu :scl) (let ((homedir (user-homedir-pathname))) (or (and homedir (namestring homedir)) "~/")) directory)) #+cormanlisp (defun home-subdirectory (directory) (declare (type string directory)) (concatenate 'string "C:\\" directory)) ;;; The following function is available for users to add ;;; (setq mk:*central-registry* (defsys-env-search-path)) ;;; to Lisp init files in order to use the value of the DEFSYSPATH ;;; instead of directly coding it in the file. #+:allegro (defun defsys-env-search-path () "This function grabs the value of the DEFSYSPATH environment variable and breaks the search path into a list of paths." (remove-duplicates (split-string (sys:getenv "DEFSYSPATH") :item #\:) :test #'string-equal)) ;;; Change this variable to set up the location of a central ;;; repository for system definitions if you want one. ;;; This is a defvar to allow users to change the value in their ;;; lisp init files without worrying about it reverting if they ;;; reload defsystem for some reason. ;;; Note that if a form is included in the registry list, it will be evaluated ;;; in COMPUTE-SYSTEM-PATH to return the appropriate directory to check. (defvar *central-registry* `(;; Current directory "./" #+:LUCID (working-directory) #+ACLPC (current-directory) #+:allegro (excl:current-directory) #+:clisp (ext:default-directory) #+:sbcl (progn *default-pathname-defaults*) #+(or :cmu :scl) (ext:default-directory) ;; *** Marco Antoniotti ;; Somehow it is better to qualify default-directory in CMU with ;; the appropriate package (i.e. "EXTENSIONS".) ;; Same for Allegro. #+(and :lispworks (not :lispworks4)) ,(multiple-value-bind (major minor) #-:lispworks-personal-edition (system::lispworks-version) #+:lispworks-personal-edition (values system::*major-version-number* system::*minor-version-number*) (if (or (> major 3) (and (= major 3) (> minor 2)) (and (= major 3) (= minor 2) (equal (lisp-implementation-version) "3.2.1"))) `(make-pathname :directory ,(find-symbol "*CURRENT-WORKING-DIRECTORY*" (find-package "SYSTEM"))) (find-symbol "*CURRENT-WORKING-DIRECTORY*" (find-package "LW")))) #+:lispworks4 (hcl:get-working-directory) ;; Home directory #-sbcl (mk::home-subdirectory "lisp/systems/") ;; Global registry #+unix (pathname "/usr/local/lisp/Registry/") ) "Central directory of system definitions. May be either a single directory pathname, or a list of directory pathnames to be checked after the local directory.") (defun add-registry-location (pathname) "Adds a path to the central registry." (pushnew pathname *central-registry* :test #'equal)) (defun registry-pathname (registry) "Return the pathname represented by the element of *CENTRAL-REGISTRY*." (typecase registry (string (pathname registry)) (pathname registry) (otherwise (pathname (eval registry))))) (defun print-central-registry-directories (&optional (stream *standard-output*)) (dolist (registry *central-registry*) (print (registry-pathname registry) stream))) (defun list-central-registry-directories () (mapcar #'registry-pathname *central-registry*)) (defvar *bin-subdir* ".bin/" "The subdirectory of an AFS directory where the binaries are really kept.") ;;; These variables set up defaults for operate-on-system, and are used ;;; for communication in lieu of parameter passing. Yes, this is bad, ;;; but it keeps the interface small. Also, in the case of the -if-no-binary ;;; variables, parameter passing would require multiple value returns ;;; from some functions. Why make life complicated? (defvar *tell-user-when-done* nil "If T, system will print ...DONE at the end of an operation") (defvar *oos-verbose* nil "Operate on System Verbose Mode") (defvar *oos-test* nil "Operate on System Test Mode") (defvar *load-source-if-no-binary* nil "If T, system will try loading the source if the binary is missing") (defvar *bother-user-if-no-binary* t "If T, the system will ask the user whether to load the source if the binary is missing") (defvar *load-source-instead-of-binary* nil "If T, the system will load the source file instead of the binary.") (defvar *compile-during-load* :query "If T, the system will compile source files during load if the binary file is missing. If :query, it will ask the user for permission first.") (defvar *minimal-load* nil "If T, the system tries to avoid reloading files that were already loaded and up to date.") (defvar *files-missing-is-an-error* t "If both the source and binary files are missing, signal a continuable error instead of just a warning.") (defvar *operations-propagate-to-subsystems* t "If T, operations like :COMPILE and :LOAD propagate to subsystems of a system that are defined either using a component-type of :system or by another defsystem form.") ;;; Particular to CMULisp (defvar *compile-error-file-type* "err" "File type of compilation error file in cmulisp") (defvar *cmu-errors-to-terminal* t "Argument to :errors-to-terminal in compile-file in cmulisp") (defvar *cmu-errors-to-file* t "If T, cmulisp will write an error file during compilation") ;;; ******************************** ;;; Global Variables *************** ;;; ******************************** ;;; Massage people's *features* into better shape. (eval-when (compile load eval) (dolist (feature *features*) (when (and (symbolp feature) ; 3600 (equal (symbol-name feature) "CMU")) (pushnew :CMU *features*))) #+Lucid (when (search "IBM RT PC" (machine-type)) (pushnew :ibm-rt-pc *features*)) ) ;;; *filename-extensions* is a cons of the source and binary extensions. (defvar *filename-extensions* (car `(#+(and Symbolics Lispm) ("lisp" . "bin") #+(and dec common vax (not ultrix)) ("LSP" . "FAS") #+(and dec common vax ultrix) ("lsp" . "fas") #+ACLPC ("lsp" . "fsl") #+CLISP ("lisp" . "fas") #+KCL ("lsp" . "o") #+ECL ("lsp" . "fas") #+IBCL ("lsp" . "o") #+Xerox ("lisp" . "dfasl") ;; Lucid on Silicon Graphics #+(and Lucid MIPS) ("lisp" . "mbin") ;; the entry for (and lucid hp300) must precede ;; that of (and lucid mc68000) for hp9000/300's running lucid, ;; since *features* on hp9000/300's also include the :mc68000 ;; feature. #+(and lucid hp300) ("lisp" . "6bin") #+(and Lucid MC68000) ("lisp" . "lbin") #+(and Lucid Vax) ("lisp" . "vbin") #+(and Lucid Prime) ("lisp" . "pbin") #+(and Lucid SUNRise) ("lisp" . "sbin") #+(and Lucid SPARC) ("lisp" . "sbin") #+(and Lucid :IBM-RT-PC) ("lisp" . "bbin") ;; PA is Precision Architecture, HP's 9000/800 RISC cpu #+(and Lucid PA) ("lisp" . "hbin") #+excl ("cl" . ,(pathname-type (compile-file-pathname "foo.cl"))) #+(or :cmu :scl) ("lisp" . ,(or (c:backend-fasl-file-type c:*backend*) "fasl")) ; #+(and :CMU (not (or :sgi :sparc))) ("lisp" . "fasl") ; #+(and :CMU :sgi) ("lisp" . "sgif") ; #+(and :CMU :sparc) ("lisp" . "sparcf") #+PRIME ("lisp" . "pbin") #+HP ("l" . "b") #+TI ("lisp" . #.(string (si::local-binary-file-type))) #+:gclisp ("LSP" . "F2S") #+pyramid ("clisp" . "o") ;; Harlequin LispWorks #+:lispworks ("lisp" . ,COMPILER:*FASL-EXTENSION-STRING*) ; #+(and :sun4 :lispworks) ("lisp" . "wfasl") ; #+(and :mips :lispworks) ("lisp" . "mfasl") #+:mcl ("lisp" . ,(pathname-type (compile-file-pathname "foo.lisp"))) #+:coral ("lisp" . "fasl") ;; Otherwise, ("lisp" . ,(pathname-type (compile-file-pathname "foo.lisp"))))) "Filename extensions for Common Lisp. A cons of the form (Source-Extension . Binary-Extension). If the system is unknown (as in *features* not known), defaults to lisp and fasl.") (defvar *system-extension* ;; MS-DOS systems can only handle three character extensions. #-ACLPC "system" #+ACLPC "sys" "The filename extension to use with systems.") ;;; The above variables and code should be extended to allow a list of ;;; valid extensions for each lisp implementation, instead of a single ;;; extension. When writing a file, the first extension should be used. ;;; But when searching for a file, every extension in the list should ;;; be used. For example, CMU Common Lisp recognizes "lisp" "l" "cl" and ;;; "lsp" (*load-source-types*) as source code extensions, and ;;; (c:backend-fasl-file-type c:*backend*) ;;; (c:backend-byte-fasl-file-type c:*backend*) ;;; and "fasl" as binary (object) file extensions (*load-object-types*). ;;; Note that the above code is used below in the LANGUAGE defstruct. ;;; There is no real support for this variable being nil, so don't change it. ;;; Note that in any event, the toplevel system (defined with defsystem) ;;; will have its dependencies delayed. Not having dependencies delayed ;;; might be useful if we define several systems within one defsystem. (defvar *system-dependencies-delayed* t "If T, system dependencies are expanded at run time") ;;; Replace this with consp, dammit! (defun non-empty-listp (list) (and list (listp list))) ;;; ******************************** ;;; Component Operation Definition * ;;; ******************************** (eval-when (:compile-toplevel :load-toplevel :execute) (defvar *version-dir* nil "The version subdir. bound in operate-on-system.") (defvar *version-replace* nil "The version replace. bound in operate-on-system.") (defvar *version* nil "Default version.")) (defvar *component-operations* (make-hash-table :test #'equal) "Hash table of (operation-name function) pairs.") (defun component-operation (name &optional operation) (if operation (setf (gethash name *component-operations*) operation) (gethash name *component-operations*))) ;;; ******************************** ;;; AFS @sys immitator ************* ;;; ******************************** ;;; mc 11-Apr-91: Bashes MCL's point reader, so commented out. #-:mcl (eval-when (compile load eval) ;; Define #@"foo" as a shorthand for (afs-binary-directory "foo"). ;; For example, ;; #@"foo" ;; "foo/.bin/rt_mach/" (set-dispatch-macro-character #\# #\@ #'(lambda (stream char arg) (declare (ignore char arg)) `(afs-binary-directory ,(read stream t nil t))))) (defvar *find-irix-version-script* "\"1,4 d\\ s/^[^M]*IRIX Execution Environment 1, *[a-zA-Z]* *\\([^ ]*\\)/\\1/p\\ /./,$ d\\ \"") (defun operating-system-version () #+(and :sgi :excl) (let* ((full-version (software-version)) (blank-pos (search " " full-version)) (os (subseq full-version 0 blank-pos)) (version-rest (subseq full-version (1+ blank-pos))) os-version) (setq blank-pos (search " " version-rest)) (setq version-rest (subseq version-rest (1+ blank-pos))) (setq blank-pos (search " " version-rest)) (setq os-version (subseq version-rest 0 blank-pos)) (setq version-rest (subseq version-rest (1+ blank-pos))) (setq blank-pos (search " " version-rest)) (setq version-rest (subseq version-rest (1+ blank-pos))) (concatenate 'string os " " os-version)) ; " " version-rest #+(and :sgi :cmu :sbcl) (concatenate 'string (software-type) (software-version)) #+(and :lispworks :irix) (let ((soft-type (software-type))) (if (equalp soft-type "IRIX5") (progn (foreign:call-system (format nil "versions ~A | sed -e ~A > ~A" "eoe1" *find-irix-version-script* "irix-version") "/bin/csh") (with-open-file (s "irix-version") (format nil "IRIX ~S" (read s)))) soft-type)) #-(or (and :excl :sgi) (and :cmu :sgi) (and :lispworks :irix)) (software-type)) (defun compiler-version () #+:lispworks (concatenate 'string "lispworks" " " (lisp-implementation-version)) #+excl (concatenate 'string "excl" " " excl::*common-lisp-version-number*) #+sbcl (concatenate 'string "sbcl" " " (lisp-implementation-version)) #+cmu (concatenate 'string "cmu" " " (lisp-implementation-version)) #+scl (concatenate 'string "scl" " " (lisp-implementation-version)) #+kcl "kcl" #+IBCL "ibcl" #+akcl "akcl" #+gcl "gcl" #+ecl "ecl" #+lucid "lucid" #+ACLPC "aclpc" #+CLISP "clisp" #+Xerox "xerox" #+symbolics "symbolics" #+mcl "mcl" #+coral "coral" #+gclisp "gclisp" ) (defun afs-binary-directory (root-directory) ;; Function for obtaining the directory AFS's @sys feature would have ;; chosen when we're not in AFS. This function is useful as the argument ;; to :binary-pathname in defsystem. For example, ;; :binary-pathname (afs-binary-directory "scanner/") (let ((machine (machine-type-translation #-(and :sgi :allegro-version>= (version>= 4 2)) (machine-type) #+(and :sgi :allegro-version>= (version>= 4 2)) (machine-version))) (software (software-type-translation #-(and :sgi (or :cmu :sbcl :scl (and :allegro-version>= (version>= 4 2)))) (software-type) #+(and :sgi (or :cmu :sbcl :scl (and :allegro-version>= (version>= 4 2)))) (operating-system-version))) (lisp (compiler-type-translation (compiler-version)))) ;; pmax_mach rt_mach sun3_35 sun3_mach vax_mach (setq root-directory (namestring root-directory)) (setq root-directory (ensure-trailing-slash root-directory)) (format nil "~A~@[~A~]~@[~A/~]" root-directory *bin-subdir* (if *multiple-lisp-support* (afs-component machine software lisp) (afs-component machine software))))) (defun afs-source-directory (root-directory &optional version-flag) ;; Function for obtaining the directory AFS's @sys feature would have ;; chosen when we're not in AFS. This function is useful as the argument ;; to :source-pathname in defsystem. (setq root-directory (namestring root-directory)) (setq root-directory (ensure-trailing-slash root-directory)) (format nil "~A~@[~A/~]" root-directory (and version-flag (translate-version *version*)))) (defun null-string (s) (when (stringp s) (string-equal s ""))) (defun ensure-trailing-slash (dir) (if (and dir (not (null-string dir)) (not (char= (char dir (1- (length dir))) #\/)) (not (char= (char dir (1- (length dir))) #\\)) ) (concatenate 'string dir "/") dir)) (defun afs-component (machine software &optional lisp) (format nil "~@[~A~]~@[_~A~]~@[_~A~]" machine (or software "mach") lisp)) (defvar *machine-type-alist* (make-hash-table :test #'equal) "Hash table for retrieving the machine-type") (defun machine-type-translation (name &optional operation) (if operation (setf (gethash (string-upcase name) *machine-type-alist*) operation) (gethash (string-upcase name) *machine-type-alist*))) (machine-type-translation "IBM RT PC" "rt") (machine-type-translation "DEC 3100" "pmax") (machine-type-translation "DEC VAX-11" "vax") (machine-type-translation "DECstation" "pmax") (machine-type-translation "Sun3" "sun3") (machine-type-translation "Sun-4" "sun4") (machine-type-translation "MIPS Risc" "mips") (machine-type-translation "SGI" "sgi") (machine-type-translation "Silicon Graphics Iris 4D" "sgi") (machine-type-translation "Silicon Graphics Iris 4D (R3000)" "sgi") (machine-type-translation "Silicon Graphics Iris 4D (R4000)" "sgi") (machine-type-translation "Silicon Graphics Iris 4D (R4400)" "sgi") (machine-type-translation "IP22" "sgi") ;;; MIPS R4000 Processor Chip Revision: 3.0 ;;; MIPS R4400 Processor Chip Revision: 5.0 ;;; MIPS R4600 Processor Chip Revision: 1.0 (machine-type-translation "IP20" "sgi") ;;; MIPS R4000 Processor Chip Revision: 3.0 (machine-type-translation "IP17" "sgi") ;;; MIPS R4000 Processor Chip Revision: 2.2 (machine-type-translation "IP12" "sgi") ;;; MIPS R2000A/R3000 Processor Chip Revision: 3.0 (machine-type-translation "IP7" "sgi") ;;; MIPS R2000A/R3000 Processor Chip Revision: 3.0 (machine-type-translation "x86" "x86") ;;; ACL (machine-type-translation "IBM PC Compatible" "x86") ;;; LW (machine-type-translation "I686" "x86") ;;; LW (machine-type-translation "PC/386" "x86") ;;; CLisp Win32 #+(and :lucid :sun :mc68000) (machine-type-translation "unknown" "sun3") (defvar *software-type-alist* (make-hash-table :test #'equal) "Hash table for retrieving the software-type") (defun software-type-translation (name &optional operation) (if operation (setf (gethash (string-upcase name) *software-type-alist*) operation) (gethash (string-upcase name) *software-type-alist*))) (software-type-translation "BSD UNIX" "mach") ; "unix" (software-type-translation "Ultrix" "mach") ; "ultrix" (software-type-translation "SunOS" "SunOS") (software-type-translation "MACH/4.3BSD" "mach") (software-type-translation "IRIX System V" "irix") ; (software-type) (software-type-translation "IRIX5" "irix5") ;;(software-type-translation "IRIX liasg5 5.2 02282016 IP22 mips" "irix5") ; (software-version) (software-type-translation "IRIX 5.2" "irix5") (software-type-translation "IRIX 5.3" "irix5") (software-type-translation "IRIX5.2" "irix5") (software-type-translation "IRIX5.3" "irix5") (software-type-translation "Linux" "linux") ; Lispworks for Linux (software-type-translation "Linux 2.x, Redhat 6.x and 7.x" "linux") ; ACL (software-type-translation "Microsoft Windows 9x/Me and NT/2000/XP" "win32") (software-type-translation "Windows NT" "win32") ; LW for Windows (software-type-translation "ANSI C program" "ansi-c") ; CLISP (software-type-translation "C compiler" "ansi-c") ; CLISP for Win32 (software-type-translation nil "") #+:lucid (software-type-translation "Unix" #+:lcl4.0 "4.0" #+(and :lcl3.0 (not :lcl4.0)) "3.0") (defvar *compiler-type-alist* (make-hash-table :test #'equal) "Hash table for retrieving the Common Lisp type") (defun compiler-type-translation (name &optional operation) (if operation (setf (gethash (string-upcase name) *compiler-type-alist*) operation) (gethash (string-upcase name) *compiler-type-alist*))) (compiler-type-translation "lispworks 3.2.1" "lispworks") (compiler-type-translation "lispworks 3.2.60 beta 6" "lispworks") (compiler-type-translation "lispworks 4.2.0" "lispworks") #+allegro (eval-when (:compile-toplevel :load-toplevel :execute) (unless (or (find :case-sensitive common-lisp:*features*) (find :case-insensitive common-lisp:*features*)) (if (or (eq excl:*current-case-mode* :case-sensitive-lower) (eq excl:*current-case-mode* :case-sensitive-upper)) (push :case-sensitive common-lisp:*features*) (push :case-insensitive common-lisp:*features*)))) #+(and allegro case-sensitive ics) (compiler-type-translation "excl 6.1" "excl-m") #+(and allegro case-sensitive (not ics)) (compiler-type-translation "excl 6.1" "excl-m8") #+(and allegro case-insensitive ics) (compiler-type-translation "excl 6.1" "excl-a") #+(and allegro case-insensitive (not ics)) (compiler-type-translation "excl 6.1" "excl-a8") (compiler-type-translation "excl 4.2" "excl") (compiler-type-translation "excl 4.1" "excl") (compiler-type-translation "cmu 17f" "cmu") (compiler-type-translation "cmu 17e" "cmu") (compiler-type-translation "cmu 17d" "cmu") ;;; ******************************** ;;; System Names ******************* ;;; ******************************** ;;; If you use strings for system names, be sure to use the same case ;;; as it appears on disk, if the filesystem is case sensitive. (defun canonicalize-system-name (name) ;; Originally we were storing systems using GET. This meant that the ;; name of a system had to be a symbol, so we interned the symbols ;; in the keyword package to avoid package dependencies. Now that we're ;; storing the systems in a hash table, we've switched to using strings. ;; Since the hash table is case sensitive, we use uppercase strings. ;; (Names of modules and files may be symbols or strings.) #||(if (keywordp name) name (intern (string-upcase (string name)) "KEYWORD"))||# (if (stringp name) (string-upcase name) (string-upcase (string name)))) (defvar *defined-systems* (make-hash-table :test #'equal) "Hash table containing the definitions of all known systems.") (defun get-system (name) "Returns the definition of the system named NAME." (gethash (canonicalize-system-name name) *defined-systems*)) (defsetf get-system (name) (value) `(setf (gethash (canonicalize-system-name ,name) *defined-systems*) ,value)) (defun undefsystem (name) "Removes the definition of the system named NAME." (remhash (canonicalize-system-name name) *defined-systems*)) (defun defined-systems () "Returns a list of defined systems." (let ((result nil)) (maphash #'(lambda (key value) (declare (ignore key)) (push value result)) *defined-systems*) result)) (defun defined-names-and-systems () "Returns a a-list of defined systems along with their names." (loop for sname being the hash-keys of *defined-systems* using (hash-value s) collect (cons sname s))) ;;; ******************************** ;;; Directory Pathname Hacking ***** ;;; ******************************** ;;; Unix example: An absolute directory starts with / while a ;;; relative directory doesn't. A directory ends with /, while ;;; a file's pathname doesn't. This is important 'cause ;;; (pathname-directory "foo/bar") will return "foo" and not "foo/". ;;; I haven't been able to test the fix to the problem with symbolics ;;; hosts. Essentially, append-directories seems to have been tacking ;;; the default host onto the front of the pathname (e.g., mk::source-pathname ;;; gets a "B:" on front) and this overrides the :host specified in the ;;; component. The value of :host should override that specified in ;;; the :source-pathname and the default file server. If this doesn't ;;; fix things, specifying the host in the root pathname "F:>root-dir>" ;;; may be a good workaround. ;;; Need to verify that merging of pathnames where modules are located ;;; on different devices (in VMS-based VAXLisp) now works. ;;; Merge-pathnames works for VMS systems. In VMS systems, the directory ;;; part is enclosed in square brackets, e.g., ;;; "[root.child.child_child]" or "[root.][child.][child_child]" ;;; To concatenate directories merge-pathnames works as follows: ;;; (merge-pathnames "" "[root]") ==> "[root]" ;;; (merge-pathnames "[root.]" "[son]file.ext") ==> "[root.son]file.ext" ;;; (merge-pathnames "[root.]file.ext" "[son]") ==> "[root.son]file.ext" ;;; (merge-pathnames "[root]file.ext" "[son]") ==> "[root]file.ext" ;;; Thus the problem with the #-VMS code was that it was merging x y into ;;; [[x]][y] instead of [x][y] or [x]y. ;;; Miscellaneous notes: ;;; On GCLisp, the following are equivalent: ;;; "\\root\\subdir\\BAZ" ;;; "/root/subdir/BAZ" ;;; On VAXLisp, the following are equivalent: ;;; "[root.subdir]BAZ" ;;; "[root.][subdir]BAZ" ;;; Use #+:vaxlisp for VAXLisp 3.0, #+(and vms dec common vax) for v2.2 (defun new-append-directories (absolute-dir relative-dir) ;; Version of append-directories for CLtL2-compliant lisps. In particular, ;; they must conform to section 23.1.3 "Structured Directories". We are ;; willing to fix minor aberations in this function, but not major ones. ;; Tested in Allegro CL 4.0 (SPARC), Allegro CL 3.1.12 (DEC 3100), ;; CMU CL old and new compilers, Lucid 3.0, Lucid 4.0. (setf absolute-dir (or absolute-dir "") relative-dir (or relative-dir "")) (let* ((abs-dir (pathname absolute-dir)) (rel-dir (pathname relative-dir)) (host (pathname-host abs-dir)) (device (if (null-string absolute-dir) ; fix for CMU CL old compiler (pathname-device rel-dir) (pathname-device abs-dir))) (abs-directory (directory-to-list (pathname-directory abs-dir))) (abs-keyword (when (keywordp (car abs-directory)) (pop abs-directory))) ;; Stig (July 2001): ;; Somehow CLISP dies on the next line, but NIL is ok. (abs-name (ignore-errors (file-namestring abs-dir))) ; was pathname-name (rel-directory (directory-to-list (pathname-directory rel-dir))) (rel-keyword (when (keywordp (car rel-directory)) (pop rel-directory))) #-(or :MCL :sbcl :clisp) (rel-file (file-namestring rel-dir)) ;; Stig (July 2001); ;; These values seems to help clisp as well #+(or :MCL :sbcl :clisp) (rel-name (pathname-name rel-dir)) #+(or :MCL :sbcl :clisp) (rel-type (pathname-type rel-dir)) (directory nil)) ;; TI Common Lisp pathnames can return garbage for file names because ;; of bizarreness in the merging of defaults. The following code makes ;; sure that the name is a valid name by comparing it with the ;; pathname-name. It also strips TI specific extensions and handles ;; the necessary case conversion. TI maps upper back into lower case ;; for unix files! #+TI (if (search (pathname-name abs-dir) abs-name :test #'string-equal) (setf abs-name (string-right-trim "." (string-upcase abs-name))) (setf abs-name nil)) #+TI (if (search (pathname-name rel-dir) rel-file :test #'string-equal) (setf rel-file (string-right-trim "." (string-upcase rel-file))) (setf rel-file nil)) ;; Allegro v4.0/4.1 parses "/foo" into :directory '(:absolute :root) ;; and filename "foo". The namestring of a pathname with ;; directory '(:absolute :root "foo") ignores everything after the ;; :root. #+(and allegro-version>= (version>= 4 0)) (when (eq (car abs-directory) :root) (pop abs-directory)) #+(and allegro-version>= (version>= 4 0)) (when (eq (car rel-directory) :root) (pop rel-directory)) (when (and abs-name (not (null-string abs-name))) ; was abs-name (cond ((and (null abs-directory) (null abs-keyword)) #-(or :lucid :kcl :akcl TI) (setf abs-keyword :relative) (setf abs-directory (list abs-name))) (t (setf abs-directory (append abs-directory (list abs-name)))))) (when (and (null abs-directory) (or (null abs-keyword) ;; In Lucid, an abs-dir of nil gets a keyword of ;; :relative since (pathname-directory (pathname "")) ;; returns (:relative) instead of nil. #+:lucid (eq abs-keyword :relative)) rel-keyword) ;; The following feature switches seem necessary in CMUCL ;; Marco Antoniotti 19990707 #+(or :sbcl :CMU) (if (typep abs-dir 'logical-pathname) (setf abs-keyword :absolute) (setf abs-keyword rel-keyword)) #-(or :sbcl :CMU) (setf abs-keyword rel-keyword)) (setf directory (append abs-directory rel-directory)) (when abs-keyword (setf directory (cons abs-keyword directory))) (namestring (make-pathname :host host :device device :directory directory :name #-(or :sbcl :MCL :clisp) rel-file #+(or :sbcl :MCL :clisp) rel-name #+(or :sbcl :MCL :clisp) :type #+(or :sbcl :MCL :clisp) rel-type )))) (defun directory-to-list (directory) ;; The directory should be a list, but nonstandard implementations have ;; been known to use a vector or even a string. (cond ((listp directory) directory) ((stringp directory) (cond ((find #\; directory) ;; It's probably a logical pathname, so split at the ;; semicolons: (split-string directory :item #\;)) #+MCL ((and (find #\: directory) (not (find #\/ directory))) ;; It's probably a MCL pathname, so split at the colons. (split-string directory :item #\:)) (t ;; It's probably a unix pathname, so split at the slash. (split-string directory :item #\/)))) (t (coerce directory 'list)))) (defparameter *append-dirs-tests* '("~/foo/" "baz/bar.lisp" "~/foo" "baz/bar.lisp" "/foo/bar/" "baz/barf.lisp" "/foo/bar/" "/baz/barf.lisp" "foo/bar/" "baz/barf.lisp" "foo/bar" "baz/barf.lisp" "foo/bar" "/baz/barf.lisp" "foo/bar/" "/baz/barf.lisp" "/foo/bar/" nil "foo/bar/" nil "foo/bar" nil "foo" nil "foo" "" nil "baz/barf.lisp" nil "/baz/barf.lisp" nil nil)) (defun test-new-append-directories (&optional (test-dirs *append-dirs-tests*)) (do* ((dir-list test-dirs (cddr dir-list)) (abs-dir (car dir-list) (car dir-list)) (rel-dir (cadr dir-list) (cadr dir-list))) ((null dir-list) (values)) (format t "~&ABS: ~S ~18TREL: ~S ~41TResult: ~S" abs-dir rel-dir (new-append-directories abs-dir rel-dir)))) #|| (test-new-append-directories) ABS: "~/foo/" REL: "baz/bar.lisp" Result: "/usr0/mkant/foo/baz/bar.lisp" ABS: "~/foo" REL: "baz/bar.lisp" Result: "/usr0/mkant/foo/baz/bar.lisp" ABS: "/foo/bar/" REL: "baz/barf.lisp" Result: "/foo/bar/baz/barf.lisp" ABS: "/foo/bar/" REL: "/baz/barf.lisp" Result: "/foo/bar/baz/barf.lisp" ABS: "foo/bar/" REL: "baz/barf.lisp" Result: "foo/bar/baz/barf.lisp" ABS: "foo/bar" REL: "baz/barf.lisp" Result: "foo/bar/baz/barf.lisp" ABS: "foo/bar" REL: "/baz/barf.lisp" Result: "foo/bar/baz/barf.lisp" ABS: "foo/bar/" REL: "/baz/barf.lisp" Result: "foo/bar/baz/barf.lisp" ABS: "/foo/bar/" REL: NIL Result: "/foo/bar/" ABS: "foo/bar/" REL: NIL Result: "foo/bar/" ABS: "foo/bar" REL: NIL Result: "foo/bar/" ABS: "foo" REL: NIL Result: "foo/" ABS: "foo" REL: "" Result: "foo/" ABS: NIL REL: "baz/barf.lisp" Result: "baz/barf.lisp" ABS: NIL REL: "/baz/barf.lisp" Result: "/baz/barf.lisp" ABS: NIL REL: NIL Result: "" ||# (defun append-directories (absolute-directory relative-directory) "There is no CL primitive for tacking a subdirectory onto a directory. We need such a function because defsystem has both absolute and relative pathnames in the modules. This is a somewhat ugly hack which seems to work most of the time. We assume that ABSOLUTE-DIRECTORY is a directory, with no filename stuck on the end. Relative-directory, however, may have a filename stuck on the end." (when (or absolute-directory relative-directory) (cond ;; KMR commented out because: when appending two logical pathnames, ;; using this code translates the first logical pathname then appends ;; the second logical pathname -- an error. #| ;; We need a reliable way to determine if a pathname is logical. ;; Allegro 4.1 does not recognize the syntax of a logical pathname ;; as being logical unless its logical host is already defined. #+(or (and allegro-version>= (version>= 4 1)) :logical-pathnames-mk) ((and absolute-directory (logical-pathname-p absolute-directory) relative-directory) ;; For use with logical pathnames package. (append-logical-directories-mk absolute-directory relative-directory)) |# ((namestring-probably-logical absolute-directory) ;; A simplistic stab at handling logical pathnames (append-logical-pnames absolute-directory relative-directory)) (t ;; In VMS, merge-pathnames actually does what we want!!! #+:VMS (namestring (merge-pathnames (or absolute-directory "") (or relative-directory ""))) #+:macl1.3.2 (namestring (make-pathname :directory absolute-directory :name relative-directory)) ;; Cross your fingers and pray. #-(or :VMS :macl1.3.2) (new-append-directories absolute-directory relative-directory))))) #+:logical-pathnames-mk (defun append-logical-directories-mk (absolute-dir relative-dir) (lp:append-logical-directories absolute-dir relative-dir)) ;;; append-logical-pathnames-mk -- ;;; The following is probably still bogus and it does not solve the ;;; problem of appending two logical pathnames. ;;; Anyway, as per suggetsion by KMR, the function is not called ;;; anymore. ;;; Hopefully this will not cause problems for ACL. #+(and (and allegro-version>= (version>= 4 1)) (not :logical-pathnames-mk)) (defun append-logical-directories-mk (absolute-dir relative-dir) ;; We know absolute-dir and relative-dir are non nil. Moreover ;; absolute-dir is a logical pathname. (setq absolute-dir (logical-pathname absolute-dir)) (etypecase relative-dir (string (setq relative-dir (parse-namestring relative-dir))) (pathname #| do nothing |#)) (translate-logical-pathname (merge-pathnames relative-dir absolute-dir))) #| Old version 2002-03-02 #+(and (and allegro-version>= (version>= 4 1)) (not :logical-pathnames-mk)) (defun append-logical-directories-mk (absolute-dir relative-dir) ;; We know absolute-dir and relative-dir are non nil. Moreover ;; absolute-dir is a logical pathname. (setq absolute-dir (logical-pathname absolute-dir)) (etypecase relative-dir (string (setq relative-dir (parse-namestring relative-dir))) (pathname #| do nothing |#)) (translate-logical-pathname (make-pathname :host (or (pathname-host absolute-dir) (pathname-host relative-dir)) :directory (append (pathname-directory absolute-dir) (cdr (pathname-directory relative-dir))) :name (or (pathname-name absolute-dir) (pathname-name relative-dir)) :type (or (pathname-type absolute-dir) (pathname-type relative-dir)) :version (or (pathname-version absolute-dir) (pathname-version relative-dir))))) ;; Old version #+(and (and allegro-version>= (version>= 4 1)) (not :logical-pathnames-mk)) (defun append-logical-directories-mk (absolute-dir relative-dir) (when (or absolute-dir relative-dir) (setq absolute-dir (logical-pathname (or absolute-dir "")) relative-dir (logical-pathname (or relative-dir ""))) (translate-logical-pathname (make-pathname :host (or (pathname-host absolute-dir) (pathname-host relative-dir)) :directory (append (pathname-directory absolute-dir) (cdr (pathname-directory relative-dir))) :name (or (pathname-name absolute-dir) (pathname-name relative-dir)) :type (or (pathname-type absolute-dir) (pathname-type relative-dir)) :version (or (pathname-version absolute-dir) (pathname-version relative-dir)))))) |# ;;; determines if string or pathname object is logical #+:logical-pathnames-mk (defun logical-pathname-p (thing) (eq (lp:pathname-host-type thing) :logical)) ;;; From Kevin Layer for 4.1final. #+(and (and allegro-version>= (version>= 4 1)) (not :logical-pathnames-mk)) (defun logical-pathname-p (thing) (typep (parse-namestring thing) 'logical-pathname)) (defun pathname-logical-p (thing) (typecase thing (logical-pathname t) #+clisp ; CLisp has non conformant Logical Pathnames. (pathname (pathname-logical-p (namestring thing))) (string (and (= 1 (count #\: thing)) ; Shortcut. (ignore-errors (translate-logical-pathname thing)) t)) (t nil))) ;;; This affects only one thing. ;;; 19990707 Marco Antoniotti ;;; old version (defun namestring-probably-logical (namestring) (and (stringp namestring) ;; unix pathnames don't have embedded semicolons (find #\; namestring))) #|| ;;; New version (defun namestring-probably-logical (namestring) (and (stringp namestring) (typep (parse-namestring namestring) 'logical-pathname))) ;;; New new version ;;; 20000321 Marco Antoniotti (defun namestring-probably-logical (namestring) (pathname-logical-p namestring)) ||# #|| This is incorrect, as it strives to keep strings around, when it shouldn't. MERGE-PATHNAMES already DTRT. (defun append-logical-pnames (absolute relative) (declare (type (or null string pathname) absolute relative)) (let ((abs (if absolute #-clisp (namestring absolute) #+clisp absolute ;; Stig (July 2001): hack to avoid CLISP from translating the whole string "")) (rel (if relative (namestring relative) "")) ) ;; Make sure the absolute directory ends with a semicolon unless ;; the pieces are null strings (unless (or (null-string abs) (null-string rel) (char= (char abs (1- (length abs))) #\;)) (setq abs (concatenate 'string abs ";"))) ;; Return the concatenate pathnames (concatenate 'string abs rel))) ||# (defun append-logical-pnames (absolute relative) (declare (type (or null string pathname) absolute relative)) (let ((abs (if absolute (pathname absolute) (make-pathname :directory (list :absolute) :name nil :type nil) )) (rel (if relative (pathname relative) (make-pathname :directory (list :relative) :name nil :type nil) )) ) ;; The following is messed up because CMUCL and LW use different ;; defaults for host (in particular LW uses NIL). Thus ;; MERGE-PATHNAMES has legitimate different behaviors on both ;; implementations. Of course this is disgusting, but that is the ;; way it is and the rest tries to circumvent this crap. (etypecase abs (logical-pathname (etypecase rel (logical-pathname (namestring (merge-pathnames rel abs))) (pathname ;; The following potentially translates the logical pathname ;; very early, but we cannot avoid it. (namestring (merge-pathnames rel (translate-logical-pathname abs)))) )) (pathname (namestring (merge-pathnames rel abs))) ))) #|| ;;; This was a try at appending a subdirectory onto a directory. ;;; It failed. We're keeping this around to prevent future mistakes ;;; of a similar sort. (defun merge-directories (absolute-directory relative-directory) ;; replace concatenate with something more intelligent ;; i.e., concatenation won't work with some directories. ;; it should also behave well if the parent directory ;; has a filename at the end, or if the relative-directory ain't relative (when absolute-directory (setq absolute-directory (pathname-directory absolute-directory))) (concatenate 'string (or absolute-directory "") (or relative-directory ""))) ||# #|| (defun d (d n) (namestring (make-pathname :directory d :name n))) D (d "~/foo/" "baz/bar.lisp") "/usr0/mkant/foo/baz/bar.lisp" (d "~/foo" "baz/bar.lisp") "/usr0/mkant/foo/baz/bar.lisp" (d "/foo/bar/" "baz/barf.lisp") "/foo/bar/baz/barf.lisp" (d "foo/bar/" "baz/barf.lisp") "foo/bar/baz/barf.lisp" (d "foo/bar" "baz/barf.lisp") "foo/bar/baz/barf.lisp" (d "foo/bar" "/baz/barf.lisp") "foo/bar//baz/barf.lisp" (d "foo/bar" nil) "foo/bar/" (d nil "baz/barf.lisp") "baz/barf.lisp" (d nil nil) "" ||# ;;; The following is a change proposed by DTC for SCL. ;;; Maybe it could be used all the time. #-scl (defun new-file-type (pathname type) ;; why not (make-pathname :type type :defaults pathname)? (make-pathname :host (pathname-host pathname) :device (pathname-device pathname) :directory (pathname-directory pathname) :name (pathname-name pathname) :type type :version (pathname-version pathname))) #+scl (defun new-file-type (pathname type) ;; why not (make-pathname :type type :defaults pathname)? (make-pathname :host (pathname-host pathname :case :common) :device (pathname-device pathname :case :common) :directory (pathname-directory pathname :case :common) :name (pathname-name pathname :case :common) :type (string-upcase type) :version (pathname-version pathname :case :common))) ;;; ******************************** ;;; Component Defstruct ************ ;;; ******************************** (defvar *source-pathname-default* nil "Default value of :source-pathname keyword in DEFSYSTEM. Set this to \"\" to avoid having to type :source-pathname \"\" all the time.") (defvar *binary-pathname-default* nil "Default value of :binary-pathname keyword in DEFSYSTEM.") (defstruct (topological-sort-node (:conc-name topsort-)) (color :white :type (member :gray :black :white)) ) (defparameter *component-evaluated-slots* '(:source-root-dir :source-pathname :source-extension :binary-root-dir :binary-pathname :binary-extension)) (defparameter *component-form-slots* '(:initially-do :finally-do :compile-form :load-form)) (defstruct (component (:include topological-sort-node) (:print-function print-component)) (type :file ; to pacify the CMUCL compiler (:type is alway supplied) :type (member :defsystem :system :subsystem :module :file :private-file )) (name nil :type (or symbol string)) (indent 0 :type (mod 1024)) ; Number of characters of indent in ; verbose output to the user. host ; The pathname host (i.e., "/../a"). device ; The pathname device. source-root-dir ; Relative or absolute (starts ; with "/"), directory or file ; (ends with "/"). (source-pathname *source-pathname-default*) source-extension ; A string, e.g., "lisp" ; if NIL, inherit (binary-pathname *binary-pathname-default*) binary-root-dir binary-extension ; A string, e.g., "fasl". If ; NIL, uses default for ; machine-type. package ; Package for use-package. ;; The following three slots are used to provide for alternate compilation ;; and loading functions for the files contained within a component. If ;; a component has a compiler or a loader specified, those functions are ;; used. Otherwise the functions are derived from the language. If no ;; language is specified, it defaults to Common Lisp (:lisp). Other current ;; possible languages include :scheme (PseudoScheme) and :c, but the user ;; can define additional language mappings. Compilation functions should ;; accept a pathname argument and a :output-file keyword; loading functions ;; just a pathname argument. The default functions are #'compile-file and ;; #'load. Unlike fdmm's SET-LANGUAGE macro, this allows a defsystem to ;; mix languages. (language nil :type (or null symbol)) (compiler nil :type (or null symbol function)) (loader nil :type (or null symbol function)) (compiler-options nil :type list) ; A list of compiler options to ; use for compiling this ; component. These must be ; keyword options supported by ; the compiler. (components () :type list) ; A list of components ; comprising this component's ; definition. (depends-on () :type list) ; A list of the components ; this one depends on. may ; refer only to the components ; at the same level as this ; one. proclamations ; Compiler options, such as ; '(optimize (safety 3)). (initially-do (lambda () nil)) ; Form to evaluate before the ; operation. (finally-do (lambda () nil)) ; Form to evaluate after the operation. (compile-form (lambda () nil)) ; For foreign libraries. (load-form (lambda () nil)) ; For foreign libraries. ;; load-time ; The file-write-date of the ; binary/source file loaded. ;; If load-only is T, will not compile the file on operation :compile. ;; In other words, for files which are :load-only T, loading the file ;; satisfies any demand to recompile. load-only ; If T, will not compile this ; file on operation :compile. ;; If compile-only is T, will not load the file on operation :compile. ;; Either compiles or loads the file, but not both. In other words, ;; compiling the file satisfies the demand to load it. This is useful ;; for PCL defmethod and defclass definitions, which wrap a ;; (eval-when (compile load eval) ...) around the body of the definition. ;; This saves time in some lisps. compile-only ; If T, will not load this ; file on operation :compile. #|| ISI Extension ||# load-always ; If T, will force loading ; even if file has not ; changed. ;; PVE: add banner (banner nil :type (or null string)) (documentation nil :type (or null string)) ; Optional documentation slot (long-documentation nil :type (or null string)) ; Optional long documentation slot ;; Added AUTHOR, MAINTAINER, VERSION and LICENCE slots. (author nil :type (or null string)) (licence nil :type (or null string)) (maintainer nil :type (or null string)) (version nil :type (or null string)) ;; Added NON-REQUIRED-P slot. Useful for optional items. (non-required-p nil :type boolean) ; If T a missing file or ; sub-directory will not cause ; an error. ) ;;; To allow dependencies from "foreign systems" like ASDF or one of ;;; the proprietary ones like ACL or LW. (defstruct (foreign-system (:include component (type :system))) kind ; This is a keyword: (member :asdf :pcl :lispworks-common-defsystem ...) object ; The actual foreign system object. ) (defun register-foreign-system (name &key representation kind) (declare (type (or symbol string) name)) (let ((fs (make-foreign-system :name name :kind kind :object representation))) (setf (get-system name) fs))) (define-condition missing-component (simple-condition) ((name :reader missing-component-name :initarg :name) (component :reader missing-component-component :initarg :component) ) #-gcl (:default-initargs :component nil) (:report (lambda (mmc stream) (format stream "MK:DEFSYSTEM: missing component ~S for ~S." (missing-component-name mmc) (missing-component-component mmc)))) ) (define-condition missing-module (missing-component) () (:report (lambda (mmc stream) (format stream "MK:DEFSYSTEM: missing module ~S for ~S." (missing-component-name mmc) (missing-component-component mmc)))) ) (define-condition missing-system (missing-module) () (:report (lambda (msc stream) (format stream "MK:DEFSYSTEM: missing system ~S~@[ for S~]." (missing-component-name msc) (missing-component-component msc)))) ) (defvar *file-load-time-table* (make-hash-table :test #'equal) "Hash table of file-write-dates for the system definitions and files in the system definitions.") (defun component-load-time (component) (when component (etypecase component (string (gethash component *file-load-time-table*)) (pathname (gethash (namestring component) *file-load-time-table*)) (component (ecase (component-type component) (:defsystem (let* ((name (component-name component)) (path (when name (compute-system-path name nil)))) (declare (type (or string pathname null) path)) (when path (gethash (namestring path) *file-load-time-table*)))) ((:file :private-file) ;; Use only :source pathname to identify component's ;; load time. (let ((path (component-full-pathname component :source))) (when path (gethash path *file-load-time-table*))))))))) #-(or :cmu) (defsetf component-load-time (component) (value) `(when ,component (etypecase ,component (string (setf (gethash ,component *file-load-time-table*) ,value)) (pathname (setf (gethash (namestring (the pathname ,component)) *file-load-time-table*) ,value)) (component (ecase (component-type ,component) (:defsystem (let* ((name (component-name ,component)) (path (when name (compute-system-path name nil)))) (declare (type (or string pathname null) path)) (when path (setf (gethash (namestring path) *file-load-time-table*) ,value)))) ((:file :private-file) ;; Use only :source pathname to identify file. (let ((path (component-full-pathname ,component :source))) (when path (setf (gethash path *file-load-time-table*) ,value))))))) ,value)) #+(or :cmu) (defun (setf component-load-time) (value component) (declare (type (or null string pathname component) component) (type (or unsigned-byte null) value)) (when component (etypecase component (string (setf (gethash component *file-load-time-table*) value)) (pathname (setf (gethash (namestring (the pathname component)) *file-load-time-table*) value)) (component (ecase (component-type component) (:defsystem (let* ((name (component-name component)) (path (when name (compute-system-path name nil)))) (declare (type (or string pathname null) path)) (when path (setf (gethash (namestring path) *file-load-time-table*) value)))) ((:file :private-file) ;; Use only :source pathname to identify file. (let ((path (component-full-pathname component :source))) (when path (setf (gethash path *file-load-time-table*) value))))))) value)) ;;; compute-system-path -- (defun compute-system-path (module-name definition-pname) (let* ((module-string-name (etypecase module-name (symbol (string-downcase (string module-name))) (string module-name))) (file-pathname (make-pathname :name module-string-name :type *system-extension*)) (lib-file-pathname (make-pathname :directory (list :relative module-string-name) :name module-string-name :type *system-extension*)) ) (or (when definition-pname ; given pathname for system def (probe-file definition-pname)) ;; Then the central registry. Note that we also check the current ;; directory in the registry, but the above check is hard-coded. (cond (*central-registry* (if (listp *central-registry*) (dolist (registry *central-registry*) (let* ((reg-path (registry-pathname registry)) (file (or (probe-file (append-directories reg-path file-pathname)) (probe-file (append-directories reg-path lib-file-pathname))))) (when file (return file)))) (or (probe-file (append-directories *central-registry* file-pathname)) (probe-file (append-directories *central-registry* lib-file-pathname)) )) ) (t ;; No central registry. Assume current working directory. ;; Maybe this should be an error? (or (probe-file file-pathname) (probe-file lib-file-pathname))))) )) (defun system-definition-pathname (system-name) (let ((system (ignore-errors (find-system system-name :error)))) (if system (let ((system-def-pathname (make-pathname :type "system" :defaults (pathname (component-full-pathname system :source)))) ) (values system-def-pathname (probe-file system-def-pathname))) (values nil nil)))) #| (defun compute-system-path (module-name definition-pname) (let* ((filename (format nil "~A.~A" (if (symbolp module-name) (string-downcase (string module-name)) module-name) *system-extension*))) (or (when definition-pname ; given pathname for system def (probe-file definition-pname)) ;; Then the central registry. Note that we also check the current ;; directory in the registry, but the above check is hard-coded. (cond (*central-registry* (if (listp *central-registry*) (dolist (registry *central-registry*) (let ((file (probe-file (append-directories (registry-pathname registry) filename)))) (when file (return file)))) (probe-file (append-directories *central-registry* filename)))) (t ;; No central registry. Assume current working directory. ;; Maybe this should be an error? (probe-file filename)))))) |# (defvar *reload-systems-from-disk* t "If T, always tries to reload newer system definitions from disk. Otherwise first tries to find the system definition in the current environment.") (defun find-system (system-name &optional (mode :ask) definition-pname) "Returns the system named SYSTEM-NAME. If not already loaded, loads it, depending on the value of *RELOAD-SYSTEMS-FROM-DISK* and of the value of MODE. MODE can be :ASK, :ERROR, :LOAD-OR-NIL, or :LOAD. :ASK is the default. This allows OPERATE-ON-SYSTEM to work on non-loaded as well as loaded system definitions. DEFINITION-PNAME is the pathname for the system definition, if provided." (ecase mode (:ask (or (get-system system-name) (when (y-or-n-p-wait #\y 20 "System ~A not loaded. Shall I try loading it? " system-name) (find-system system-name :load definition-pname)))) (:error (or (get-system system-name) (error 'missing-system :name system-name))) (:load-or-nil (let ((system (get-system system-name))) ;; (break "System ~S ~S." system-name system) (or (unless *reload-systems-from-disk* system) ;; If SYSTEM-NAME is a symbol, it will lowercase the ;; symbol's string. ;; If SYSTEM-NAME is a string, it doesn't change the case of the ;; string. So if case matters in the filename, use strings, not ;; symbols, wherever the system is named. (when (foreign-system-p system) (warn "Foreign system ~S cannot be reloaded by MK:DEFSYSTEM." system) (return-from find-system nil)) (let ((path (compute-system-path system-name definition-pname))) (when (and path (or (null system) (null (component-load-time path)) (< (component-load-time path) (file-write-date path)))) (tell-user-generic (format nil "Loading system ~A from file ~A" system-name path)) (load path) (setf system (get-system system-name)) (when system (setf (component-load-time path) (file-write-date path)))) system) system))) (:load (or (unless *reload-systems-from-disk* (get-system system-name)) (when (foreign-system-p (get-system system-name)) (warn "Foreign system ~S cannot be reloaded by MK:DEFSYSTEM." (get-system system-name)) (return-from find-system nil)) (or (find-system system-name :load-or-nil definition-pname) (error "Can't find system named ~s." system-name)))))) (defun print-component (component stream depth) (declare (ignore depth)) (format stream "#<~:@(~A~): ~A>" (component-type component) (component-name component))) (defun describe-system (name &optional (stream *standard-output*)) "Prints a description of the system to the stream. If NAME is the name of a system, gets it and prints a description of the system. If NAME is a component, prints a description of the component." (let ((system (if (typep name 'component) name (find-system name :load)))) (format stream "~&~A ~A: ~ ~@[~& Host: ~A~]~ ~@[~& Device: ~A~]~ ~@[~& Package: ~A~]~ ~& Source: ~@[~A~] ~@[~A~] ~@[~A~]~ ~& Binary: ~@[~A~] ~@[~A~] ~@[~A~]~ ~@[~& Depends On: ~A ~]~& Components:~{~15T~A~&~}" (component-type system) (component-name system) (component-host system) (component-device system) (component-package system) (component-root-dir system :source) (component-pathname system :source) (component-extension system :source) (component-root-dir system :binary) (component-pathname system :binary) (component-extension system :binary) (component-depends-on system) (component-components system)) #||(when recursive (dolist (component (component-components system)) (describe-system component stream recursive)))||# system)) (defun canonicalize-component-name (component) ;; Within the component, the name is a string. (if (typep (component-name component) 'string) ;; Unnecessary to change it, so just return it, same case (component-name component) ;; Otherwise, make it a downcase string -- important since file ;; names are often constructed from component names, and unix ;; prefers lowercase as a default. (setf (component-name component) (string-downcase (string (component-name component)))))) (defun component-pathname (component type) (when component (ecase type (:source (component-source-pathname component)) (:binary (component-binary-pathname component)) (:error (component-error-pathname component))))) (defun component-error-pathname (component) (let ((binary (component-pathname component :binary))) (new-file-type binary *compile-error-file-type*))) (defsetf component-pathname (component type) (value) `(when ,component (ecase ,type (:source (setf (component-source-pathname ,component) ,value)) (:binary (setf (component-binary-pathname ,component) ,value))))) (defun component-root-dir (component type) (when component (ecase type (:source (component-source-root-dir component)) ((:binary :error) (component-binary-root-dir component)) ))) (defsetf component-root-dir (component type) (value) `(when ,component (ecase ,type (:source (setf (component-source-root-dir ,component) ,value)) (:binary (setf (component-binary-root-dir ,component) ,value))))) (defvar *source-pathnames-table* (make-hash-table :test #'equal) "Table which maps from components to full source pathnames.") (defvar *binary-pathnames-table* (make-hash-table :test #'equal) "Table which maps from components to full binary pathnames.") (defparameter *reset-full-pathname-table* t "If T, clears the full-pathname tables before each call to OPERATE-ON-SYSTEM. Setting this to NIL may yield faster performance after multiple calls to LOAD-SYSTEM and COMPILE-SYSTEM, but could result in changes to system and language definitions to not take effect, and so should be used with caution.") (defun clear-full-pathname-tables () (clrhash *source-pathnames-table*) (clrhash *binary-pathnames-table*)) (defun component-full-pathname (component type &optional (version *version*)) (when component (case type (:source (let ((old (gethash component *source-pathnames-table*))) (or old (let ((new (component-full-pathname-i component type version))) (setf (gethash component *source-pathnames-table*) new) new)))) (:binary (let ((old (gethash component *binary-pathnames-table*))) (or old (let ((new (component-full-pathname-i component type version))) (setf (gethash component *binary-pathnames-table*) new) new)))) (otherwise (component-full-pathname-i component type version))))) (defun component-full-pathname-i (component type &optional (version *version*) &aux version-dir version-replace) ;; If the pathname-type is :binary and the root pathname is null, ;; distribute the binaries among the sources (= use :source pathname). ;; This assumes that the component's :source pathname has been set ;; before the :binary one. (if version (multiple-value-setq (version-dir version-replace) (translate-version version)) (setq version-dir *version-dir* version-replace *version-replace*)) ;; (format *trace-output* "~&>>>> VERSION COMPUTED ~S ~S~%" version-dir version-replace) (let ((pathname (append-directories (if version-replace version-dir (append-directories (component-root-dir component type) version-dir)) (component-pathname component type)))) ;; When a logical pathname is used, it must first be translated to ;; a physical pathname. This isn't strictly correct. What should happen ;; is we fill in the appropriate slots of the logical pathname, and ;; then return the logical pathname for use by compile-file & friends. ;; But calling translate-logical-pathname to return the actual pathname ;; should do for now. ;; (format t "pathname = ~A~%" pathname) ;; (format t "type = ~S~%" (component-extension component type)) ;; 20000303 Marco Antoniotti ;; Changed the following according to suggestion by Ray Toy. I ;; just collapsed the tests for "logical-pathname-ness" into a ;; single test (heavy, but probably very portable) and added the ;; :name argument to the MAKE-PATHNAME in the MERGE-PATHNAMES ;; beacuse of possible null names (e.g. :defsystem components) ;; causing problems with the subsequenct call to NAMESTRING. ;; (format *trace-output* "~&>>>> PATHNAME is ~S~%" pathname) ;; 20050309 Marco Antoniotti ;; The treatment of PATHNAME-HOST and PATHNAME-DEVICE in the call ;; to MAKE-PATHNAME in the T branch is bogus. COMPONENT-DEVICE ;; and COMPONENT-HOST must respect the ANSI definition, hence, ;; they cannot be PATHNAMEs. The simplification of the code is ;; useful. SCL compatibility may be broken, but I doubt it will. ;; 20050310 Marco Antoniotti ;; After a suggestion by David Tolpin, the code is simplified even ;; more, and the logic should be now more clear: use the user ;; supplied pieces of the pathname if non nil. ;; 20050613 Marco Antoniotti ;; Added COMPONENT-NAME extraction to :NAME part, in case the ;; PATHNAME-NAME is NIL. (cond ((pathname-logical-p pathname) ; See definition of test above. (setf pathname (merge-pathnames pathname (make-pathname :name (component-name component) :type (component-extension component type)))) (namestring (translate-logical-pathname pathname))) (t (namestring (make-pathname :host (or (component-host component) (pathname-host pathname)) :directory (pathname-directory pathname #+scl :case #+scl :common ) :name (or (pathname-name pathname #+scl :case #+scl :common ) (component-name component)) :type #-scl (component-extension component type) #+scl (string-upcase (component-extension component type)) :device #+sbcl :unspecific #-(or :sbcl) (or (component-device component) (pathname-device pathname #+scl :case #+scl :common )) ;; :version :newest )))))) #-lispworks (defun translate-version (version) ;; Value returns the version directory and whether it replaces ;; the entire root (t) or is a subdirectory. ;; Version may be nil to signify no subdirectory, ;; a symbol, such as alpha, beta, omega, :alpha, mark, which ;; specifies a subdirectory of the root, or ;; a string, which replaces the root. (cond ((null version) (values "" nil)) ((symbolp version) (values (let ((sversion (string version))) (if (find-if #'lower-case-p sversion) sversion (string-downcase sversion))) nil)) ((stringp version) (values version t)) (t (error "~&; Illegal version ~S" version)))) ;;; Looks like LW has a bug in MERGE-PATHNAMES. ;;; ;;; (merge-pathnames "" "LP:foo;bar;") ==> "LP:" ;;; ;;; Which is incorrect. ;;; The change here ensures that the result of TRANSLATE-VERSION is ;;; appropriate. #+lispworks (defun translate-version (version) ;; Value returns the version directory and whether it replaces ;; the entire root (t) or is a subdirectory. ;; Version may be nil to signify no subdirectory, ;; a symbol, such as alpha, beta, omega, :alpha, mark, which ;; specifies a subdirectory of the root, or ;; a string, which replaces the root. (cond ((null version) (values (pathname "") nil)) ((symbolp version) (values (let ((sversion (string version))) (if (find-if #'lower-case-p sversion) (pathname sversion) (pathname (string-downcase sversion)))) nil)) ((stringp version) (values (pathname version) t)) (t (error "~&; Illegal version ~S" version)))) (defun component-extension (component type &key local) (ecase type (:source (or (component-source-extension component) (unless local (default-source-extension component)) ; system default ;; (and (component-language component)) )) (:binary (or (component-binary-extension component) (unless local (default-binary-extension component)) ; system default ;; (and (component-language component)) )) (:error *compile-error-file-type*))) (defsetf component-extension (component type) (value) `(ecase ,type (:source (setf (component-source-extension ,component) ,value)) (:binary (setf (component-binary-extension ,component) ,value)) (:error (setf *compile-error-file-type* ,value)))) ;;; ******************************** ;;; System Definition ************** ;;; ******************************** (defun create-component (type name definition-body &optional parent (indent 0)) (let ((component (apply #'make-component :type type :name name :indent indent definition-body))) ;; Set up :load-only attribute (unless (find :load-only definition-body) ;; If the :load-only attribute wasn't specified, ;; inherit it from the parent. If no parent, default it to nil. (setf (component-load-only component) (when parent (component-load-only parent)))) ;; Set up :compile-only attribute (unless (find :compile-only definition-body) ;; If the :compile-only attribute wasn't specified, ;; inherit it from the parent. If no parent, default it to nil. (setf (component-compile-only component) (when parent (component-compile-only parent)))) ;; Set up :compiler-options attribute (unless (find :compiler-options definition-body) ;; If the :compiler-option attribute wasn't specified, ;; inherit it from the parent. If no parent, default it to NIL. (setf (component-compiler-options component) (when parent (component-compiler-options parent)))) #|| ISI Extension ||# ;; Set up :load-always attribute (unless (find :load-always definition-body) ;; If the :load-always attribute wasn't specified, ;; inherit it from the parent. If no parent, default it to nil. (setf (component-load-always component) (when parent (component-load-always parent)))) ;; Initializations/after makes (canonicalize-component-name component) ;; Inherit package from parent if not specified. (setf (component-package component) (or (component-package component) (when parent (component-package parent)))) ;; Type specific setup: (when (or (eq type :defsystem) (eq type :system) (eq type :subsystem)) (setf (get-system name) component) #|(unless (component-language component) (setf (component-language component) :lisp))|#) ;; Set up the component's pathname (create-component-pathnames component parent) ;; If there are any components of the component, expand them too. (expand-component-components component (+ indent 2)) ;; Make depends-on refer to structs instead of names. (link-component-depends-on (component-components component)) ;; Design Decision: Topologically sort the dependency graph at ;; time of definition instead of at time of use. Probably saves a ;; little bit of time for the user. ;; Topological Sort the components at this level. (setf (component-components component) (topological-sort (component-components component))) ;; Return the component. component)) ;;; preprocess-component-definition -- ;;; New function introduced to manipulate the "evaluated" slots as per ;;; SDS' suggestions. ;;; 20050824 (defun preprocess-component-definition (definition-body) `(list* ,@(loop for slot in *component-evaluated-slots* for value = (getf definition-body slot) when value do (remf definition-body slot) and nconc `(,slot ,value)) ,@(loop for slot in *component-form-slots* do (remf definition-body slot) nconc `(,slot (lambda () ,(getf definition-body slot)))) ',definition-body)) ;;; defsystem -- ;;; The main macro. ;;; ;;; 2002-11-22 Marco Antoniotti ;;; Added code to achieve a first cut "pathname less" operation, ;;; following the ideas in ASDF. If the DEFSYSTEM form is loaded from ;;; a file, then the location of the file (intended as a directory) is ;;; computed from *LOAD-PATHNAME* and stored as the :SOURCE-PATHNAME ;;; of the system. (defmacro defsystem (name &rest definition-body) (unless (find :source-pathname definition-body) (setf definition-body (list* :source-pathname '(when #-gcl *load-pathname* #+gcl si::*load-pathname* (make-pathname :name nil :type nil :defaults #-gcl *load-pathname* #+gcl si::*load-pathname* )) definition-body))) `(create-component :defsystem ',name ,(preprocess-component-definition definition-body) nil 0)) (defun create-component-pathnames (component parent) ;; Set up language-specific defaults (setf (component-language component) (or (component-language component) ; for local defaulting (when parent ; parent's default (component-language parent)))) (setf (component-compiler component) (or (component-compiler component) ; for local defaulting (when parent ; parent's default (component-compiler parent)))) (setf (component-loader component) (or (component-loader component) ; for local defaulting (when parent ; parent's default (component-loader parent)))) ;; Evaluate the root dir arg (setf (component-root-dir component :source) (eval (component-root-dir component :source))) (setf (component-root-dir component :binary) (eval (component-root-dir component :binary))) ;; Evaluate the pathname arg (setf (component-pathname component :source) (eval (component-pathname component :source))) (setf (component-pathname component :binary) (eval (component-pathname component :binary))) ;; Pass along the host and devices (setf (component-host component) (or (component-host component) (when parent (component-host parent)) (pathname-host *default-pathname-defaults*))) (setf (component-device component) (or (component-device component) (when parent (component-device parent)))) ;; Set up extension defaults (setf (component-extension component :source) (or (component-extension component :source :local #| (component-language component) |# t ) ; local default (when (component-language component) (default-source-extension component)) (when parent ; parent's default (component-extension parent :source)))) (setf (component-extension component :binary) (or (component-extension component :binary :local #| (component-language component) |# t ) ; local default (when (component-language component) (default-binary-extension component)) (when parent ; parent's default (component-extension parent :binary)))) ;; Set up pathname defaults -- expand with parent ;; We must set up the source pathname before the binary pathname ;; to allow distribution of binaries among the sources to work. (generate-component-pathname component parent :source) (generate-component-pathname component parent :binary)) ;;; generate-component-pathnames -- ;;; maybe file's inheriting of pathnames should be moved elsewhere? (defun generate-component-pathname (component parent pathname-type) ;; Pieces together a pathname for the component based on its component-type. ;; Assumes source defined first. ;; Null binary pathnames inherit from source instead of the component's ;; name. This allows binaries to be distributed among the source if ;; binary pathnames are not specified. Or if the root directory is ;; specified for binaries, but no module directories, it inherits ;; parallel directory structure. (case (component-type component) ((:defsystem :system) ; Absolute Pathname ;; Set the root-dir to be the absolute pathname (setf (component-root-dir component pathname-type) (or (component-pathname component pathname-type) (when (eq pathname-type :binary) ;; When the binary root is nil, use source. (component-root-dir component :source))) ) ;; Set the relative pathname to be nil (setf (component-pathname component pathname-type) nil));; should this be "" instead? ;; If the name of the component-pathname is nil, it ;; defaults to the name of the component. Use "" to ;; avoid this defaulting. (:private-file ; Absolute Pathname ;; Root-dir is the directory part of the pathname (setf (component-root-dir component pathname-type) "" #+ignore(or (when (component-pathname component pathname-type) (pathname-directory (component-pathname component pathname-type))) (when (eq pathname-type :binary) ;; When the binary root is nil, use source. (component-root-dir component :source))) ) ;; If *SOURCE-PATHNAME-DEFAULT* or *BINARY-PATHNAME-DEFAULT* is "", ;; then COMPONENT-SOURCE-PATHNAME or COMPONENT-BINARY-PATHNAME could ;; wind up being "", which is wrong for :file components. So replace ;; them with NIL. (when (null-string (component-pathname component pathname-type)) (setf (component-pathname component pathname-type) nil)) ;; The relative pathname is the name part (setf (component-pathname component pathname-type) (or (when (and (eq pathname-type :binary) (null (component-pathname component :binary))) ;; When the binary-pathname is nil use source. (component-pathname component :source)) (or (when (component-pathname component pathname-type) ;; (pathname-name ) (component-pathname component pathname-type)) (component-name component))))) ((:module :subsystem) ; Pathname relative to parent. ;; Inherit root-dir from parent (setf (component-root-dir component pathname-type) (component-root-dir parent pathname-type)) ;; Tack the relative-dir onto the pathname (setf (component-pathname component pathname-type) (or (when (and (eq pathname-type :binary) (null (component-pathname component :binary))) ;; When the binary-pathname is nil use source. (component-pathname component :source)) (append-directories (component-pathname parent pathname-type) (or (component-pathname component pathname-type) (component-name component)))))) (:file ; Pathname relative to parent. ;; Inherit root-dir from parent (setf (component-root-dir component pathname-type) (component-root-dir parent pathname-type)) ;; If *SOURCE-PATHNAME-DEFAULT* or *BINARY-PATHNAME-DEFAULT* is "", ;; then COMPONENT-SOURCE-PATHNAME or COMPONENT-BINARY-PATHNAME could ;; wind up being "", which is wrong for :file components. So replace ;; them with NIL. (when (null-string (component-pathname component pathname-type)) (setf (component-pathname component pathname-type) nil)) ;; Tack the relative-dir onto the pathname (setf (component-pathname component pathname-type) (or (append-directories (component-pathname parent pathname-type) (or (component-pathname component pathname-type) (component-name component) (when (eq pathname-type :binary) ;; When the binary-pathname is nil use source. (component-pathname component :source))))))) )) #|| ;; old version (defun expand-component-components (component &optional (indent 0)) (let ((definitions (component-components component))) (setf (component-components component) (remove-if #'null (mapcar #'(lambda (definition) (expand-component-definition definition component indent)) definitions))))) ||# ;;; new version (defun expand-component-components (component &optional (indent 0)) (let ((definitions (component-components component))) (if (eq (car definitions) :serial) (setf (component-components component) (expand-serial-component-chain (cdr definitions) component indent)) (setf (component-components component) (expand-component-definitions definitions component indent))))) (defun expand-component-definitions (definitions parent &optional (indent 0)) (let ((components nil)) (dolist (definition definitions) (let ((new (expand-component-definition definition parent indent))) (when new (push new components)))) (nreverse components))) (defun expand-serial-component-chain (definitions parent &optional (indent 0)) (let ((previous nil) (components nil)) (dolist (definition definitions) (let ((new (expand-component-definition definition parent indent))) (when new ;; Make this component depend on the previous one. Since ;; we don't know the form of the definition, we have to ;; expand it first. (when previous (pushnew previous (component-depends-on new))) ;; The dependencies will be linked later, so we use the name ;; instead of the actual component. (setq previous (component-name new)) ;; Save the new component. (push new components)))) ;; Return the list of expanded components, in appropriate order. (nreverse components))) (defparameter *enable-straz-absolute-string-hack* nil "Special hack requested by Steve Strassman, where the shorthand that specifies a list of components as a list of strings also recognizes absolute pathnames and treats them as files of type :private-file instead of type :file. Defaults to NIL, because I haven't tested this.") (defun absolute-file-namestring-p (string) ;; If a FILE namestring starts with a slash, or is a logical pathname ;; as implied by the existence of a colon in the filename, assume it ;; represents an absolute pathname. (or (find #\: string :test #'char=) (and (not (null-string string)) (char= (char string 0) #\/)))) (defun expand-component-definition (definition parent &optional (indent 0)) ;; Should do some checking for malformed definitions here. (cond ((null definition) nil) ((stringp definition) ;; Strings are assumed to be of type :file (if (and *enable-straz-absolute-string-hack* (absolute-file-namestring-p definition)) ;; Special hack for Straz (create-component :private-file definition nil parent indent) ;; Normal behavior (create-component :file definition nil parent indent))) ((and (listp definition) (not (member (car definition) '(:defsystem :system :subsystem :module :file :private-file)))) ;; Lists whose first element is not a component type ;; are assumed to be of type :file (create-component :file (first definition) ;; (preprocess-component-definition (rest definition)) ; Not working. (rest definition) parent indent)) ((listp definition) ;; Otherwise, it is (we hope) a normal form definition (create-component (first definition) ; type (second definition) ; name ;; definition body ;; (preprocess-component-definition (cddr definition)) ; Not working. (cddr definition) parent ; parent indent) ; indent ))) (defun link-component-depends-on (components) (dolist (component components) (unless (and *system-dependencies-delayed* (eq (component-type component) :defsystem)) (setf (component-depends-on component) (mapcar #'(lambda (dependency) (let ((parent (find (string dependency) components :key #'component-name :test #'string-equal))) (cond (parent parent) ;; make it more intelligent about the following (t (warn "Dependency ~S of component ~S not found." dependency component))))) (component-depends-on component)))))) ;;; ******************************** ;;; Topological Sort the Graph ***** ;;; ******************************** ;;; New version of topological sort suggested by rs2. Even though ;;; this version avoids the call to sort, in practice it isn't faster. It ;;; does, however, eliminate the need to have a TIME slot in the ;;; topological-sort-node defstruct. (defun topological-sort (list &aux (sorted-list nil)) (labels ((dfs-visit (znode) (setf (topsort-color znode) :gray) (unless (and *system-dependencies-delayed* (eq (component-type znode) :system)) (dolist (child (component-depends-on znode)) (cond ((eq (topsort-color child) :white) (dfs-visit child)) ((eq (topsort-color child) :gray) (format t "~&Detected cycle containing ~A" child))))) (setf (topsort-color znode) :black) (push znode sorted-list))) (dolist (znode list) (setf (topsort-color znode) :white)) (dolist (znode list) (when (eq (topsort-color znode) :white) (dfs-visit znode))) (nreverse sorted-list))) #|| ;;; Older version of topological sort. (defun topological-sort (list &aux (time 0)) ;; The algorithm works by calling depth-first-search to compute the ;; blackening times for each vertex, and then sorts the vertices into ;; reverse order by blackening time. (labels ((dfs-visit (node) (setf (topsort-color node) 'gray) (unless (and *system-dependencies-delayed* (eq (component-type node) :defsystem)) (dolist (child (component-depends-on node)) (cond ((eq (topsort-color child) 'white) (dfs-visit child)) ((eq (topsort-color child) 'gray) (format t "~&Detected cycle containing ~A" child))))) (setf (topsort-color node) 'black) (setf (topsort-time node) time) (incf time))) (dolist (node list) (setf (topsort-color node) 'white)) (dolist (node list) (when (eq (topsort-color node) 'white) (dfs-visit node))) (sort list #'< :key #'topsort-time))) ||# ;;; ******************************** ;;; Output to User ***************** ;;; ******************************** ;;; All output to the user is via the tell-user functions. (defun split-string (string &key (item #\space) (test #'char=)) ;; Splits the string into substrings at spaces. (let ((len (length string)) (index 0) result) (dotimes (i len (progn (unless (= index len) (push (subseq string index) result)) (reverse result))) (when (funcall test (char string i) item) (unless (= index i);; two spaces in a row (push (subseq string index i) result)) (setf index (1+ i)))))) ;; probably should remove the ",1" entirely. But AKCL 1.243 dies on it ;; because of an AKCL bug. ;; KGK suggests using an 8 instead, but 1 does nicely. (defun prompt-string (component) (format nil "; ~:[~;TEST:~]~V,1@T " *oos-test* (component-indent component))) #|| (defun format-justified-string (prompt contents) (format t (concatenate 'string "~%" prompt "-~{~<~%" prompt " ~1,80:; ~A~>~^~}") (split-string contents)) (finish-output *standard-output*)) ||# (defun format-justified-string (prompt contents &optional (width 80) (stream *standard-output*)) (let ((prompt-length (+ 2 (length prompt)))) (cond ((< (+ prompt-length (length contents)) width) (format stream "~%~A- ~A" prompt contents)) (t (format stream "~%~A-" prompt) (do* ((cursor prompt-length) (contents (split-string contents) (cdr contents)) (content (car contents) (car contents)) (content-length (1+ (length content)) (1+ (length content)))) ((null contents)) (cond ((< (+ cursor content-length) width) (incf cursor content-length) (format stream " ~A" content)) (t (setf cursor (+ prompt-length content-length)) (format stream "~%~A ~A" prompt content))))))) (finish-output stream)) (defun tell-user (what component &optional type no-dots force) (when (or *oos-verbose* force) (format-justified-string (prompt-string component) (format nil "~A ~(~A~) ~@[\"~A\"~] ~:[~;...~]" ;; To have better messages, wrap the following around the ;; case statement: ;;(if (find (component-type component) ;; '(:defsystem :system :subsystem :module)) ;; "Checking" ;; (case ...)) ;; This gets around the problem of DEFSYSTEM reporting ;; that it's loading a module, when it eventually never ;; loads any of the files of the module. (case what ((compile :compile) (if (component-load-only component) ;; If it is :load-only t, we're loading. "Loading" ;; Otherwise we're compiling. "Compiling")) ((load :load) "Loading") (otherwise what)) (component-type component) (or (when type (component-full-pathname component type)) (component-name component)) (and *tell-user-when-done* (not no-dots)))))) (defun tell-user-done (component &optional force no-dots) ;; test is no longer really used, but we're leaving it in. (when (and *tell-user-when-done* (or *oos-verbose* force)) (format t "~&~A~:[~;...~] Done." (prompt-string component) (not no-dots)) (finish-output *standard-output*))) (defmacro with-tell-user ((what component &optional type no-dots force) &body body) `(progn (tell-user ,what ,component ,type ,no-dots ,force) ,@body (tell-user-done ,component ,force ,no-dots))) (defun tell-user-no-files (component &optional force) (when (or *oos-verbose* force) (format-justified-string (prompt-string component) (format nil "Source file ~A ~ ~:[and binary file ~A ~;~]not found, not loading." (component-full-pathname component :source) (or *load-source-if-no-binary* *load-source-instead-of-binary*) (component-full-pathname component :binary))))) (defun tell-user-require-system (name parent) (when *oos-verbose* (format t "~&; ~:[~;TEST:~] - System ~A requires ~S" *oos-test* (component-name parent) name) (finish-output *standard-output*))) (defun tell-user-generic (string) (when *oos-verbose* (format t "~&; ~:[~;TEST:~] - ~A" *oos-test* string) (finish-output *standard-output*))) ;;; ******************************** ;;; Y-OR-N-P-WAIT ****************** ;;; ******************************** ;;; Y-OR-N-P-WAIT is like Y-OR-N-P, but will timeout after a specified ;;; number of seconds. I should really replace this with a call to ;;; the Y-OR-N-P-WAIT defined in the query.cl package and include that ;;; instead. (defparameter *use-timeouts* t "If T, timeouts in Y-OR-N-P-WAIT are enabled. Otherwise it behaves like Y-OR-N-P. This is provided for users whose lisps don't handle read-char-no-hang properly.") (defparameter *clear-input-before-query* t "If T, y-or-n-p-wait will clear the input before printing the prompt and asking the user for input.") ;;; The higher *sleep-amount* is, the less consing, but the lower the ;;; responsiveness. (defparameter *sleep-amount* #-CMU 0.1 #+CMU 1.0 "Amount of time to sleep between checking query-io. In multiprocessing Lisps, this allows other processes to continue while we busy-wait. If 0, skips call to SLEEP.") (defun internal-real-time-in-seconds () (get-universal-time)) (defun read-char-wait (&optional (timeout 20) input-stream (eof-error-p t) eof-value &aux peek) (do ((start (internal-real-time-in-seconds))) ((or (setq peek (listen input-stream)) (< (+ start timeout) (internal-real-time-in-seconds))) (when peek ;; was read-char-no-hang (read-char input-stream eof-error-p eof-value))) (unless (zerop *sleep-amount*) (sleep *sleep-amount*)))) ;;; Lots of lisps, especially those that run on top of UNIX, do not get ;;; their input one character at a time, but a whole line at a time because ;;; of the buffering done by the UNIX system. This causes y-or-n-p-wait ;;; to not always work as expected. ;;; ;;; I wish lisp did all its own buffering (turning off UNIX input line ;;; buffering by putting the UNIX into CBREAK mode). Of course, this means ;;; that we lose input editing, but why can't the lisp implement this? (defun y-or-n-p-wait (&optional (default #\y) (timeout 20) format-string &rest args) "Y-OR-N-P-WAIT prints the message, if any, and reads characters from *QUERY-IO* until the user enters y, Y or space as an affirmative, or either n or N as a negative answer, or the timeout occurs. It asks again if you enter any other characters." (when *clear-input-before-query* (clear-input *query-io*)) (when format-string (fresh-line *query-io*) (apply #'format *query-io* format-string args) ;; FINISH-OUTPUT needed for CMU and other places which don't handle ;; output streams nicely. This prevents it from continuing and ;; reading the query until the prompt has been printed. (finish-output *query-io*)) (loop (let* ((read-char (if *use-timeouts* (read-char-wait timeout *query-io* nil nil) (read-char *query-io*))) (char (or read-char default))) ;; We need to ignore #\newline because otherwise the bugs in ;; clear-input will cause y-or-n-p-wait to print the "Type ..." ;; message every time... *sigh* ;; Anyway, we might want to use this to ignore whitespace once ;; clear-input is fixed. (unless (find char '(#\tab #\newline #\return)) (when (null read-char) (format *query-io* "~@[~A~]" default) (finish-output *query-io*)) (cond ((null char) (return t)) ((find char '(#\y #\Y #\space) :test #'char=) (return t)) ((find char '(#\n #\N) :test #'char=) (return nil)) (t (when *clear-input-before-query* (clear-input *query-io*)) (format *query-io* "~&Type \"y\" for yes or \"n\" for no. ") (when format-string (fresh-line *query-io*) (apply #'format *query-io* format-string args)) (finish-output *query-io*))))))) #|| (y-or-n-p-wait #\y 20 "What? ") (progn (format t "~&hi") (finish-output) (y-or-n-p-wait #\y 10 "1? ") (y-or-n-p-wait #\n 10 "2? ")) ||# ;;;=========================================================================== ;;; Running the operations. (defvar %%component%% nil) (export '(%%component%%)) ; Just a placeholder. Move it to the export list. (defmacro with-special-component-vars ((c) &body forms) `(let ((%%component%% ,c)) (declare (special %%component%%)) ,@forms)) ;;; ******************************** ;;; Operate on System ************** ;;; ******************************** ;;; Operate-on-system ;;; Operation is :compile, 'compile, :load or 'load ;;; Force is :all or :new-source or :new-source-and-dependents or a list of ;;; specific modules. ;;; :all (or T) forces a recompilation of every file in the system ;;; :new-source-and-dependents compiles only those files whose ;;; sources have changed or who depend on recompiled files. ;;; :new-source compiles only those files whose sources have changed ;;; A list of modules means that only those modules and their ;;; dependents are recompiled. ;;; Test is T to print out what it would do without actually doing it. ;;; Note: it automatically sets verbose to T if test is T. ;;; Verbose is T to print out what it is doing (compiling, loading of ;;; modules and files) as it does it. ;;; Dribble should be the pathname of the dribble file if you want to ;;; dribble the compilation. ;;; Load-source-instead-of-binary is T to load .lisp instead of binary files. ;;; Version may be nil to signify no subdirectory, ;;; a symbol, such as alpha, beta, omega, :alpha, mark, which ;;; specifies a subdirectory of the root, or ;;; a string, which replaces the root. (defun operate-on-system (name operation &key force (version *version*) (test *oos-test*) (verbose *oos-verbose*) (load-source-instead-of-binary *load-source-instead-of-binary*) (load-source-if-no-binary *load-source-if-no-binary*) (bother-user-if-no-binary *bother-user-if-no-binary*) (compile-during-load *compile-during-load*) dribble (minimal-load *minimal-load*) (override-compilation-unit t) ) (declare #-(or :cltl2 :ansi-cl) (ignore override-compilation-unit)) (unwind-protect ;; Protect the undribble. (#+(and (or :cltl2 :ansi-cl) (not :gcl)) with-compilation-unit #+(and (or :cltl2 :ansi-cl) (not :gcl)) (:override override-compilation-unit) #-(and (or :cltl2 :ansi-cl) (not :gcl)) progn (when *reset-full-pathname-table* (clear-full-pathname-tables)) (when dribble (dribble dribble)) (when test (setq verbose t)) (when (null force) ; defaults (case operation ((load :load) (setq force :all)) ((compile :compile) (setq force :new-source-and-dependents)) (t (setq force :all)))) ;; Some CL implementations have a variable called *compile-verbose* ;; or *compile-file-verbose*. (multiple-value-bind (*version-dir* *version-replace*) (translate-version version) ;; CL implementations may uniformly default this to nil (let ((*load-verbose* #-common-lisp-controller t #+common-lisp-controller nil) ; nil #-(or MCL CMU CLISP ECL :sbcl lispworks scl) (*compile-file-verbose* t) ; nil #+common-lisp-controller (*compile-print* nil) #+(and common-lisp-controller cmu) (ext:*compile-progress* nil) #+(and common-lisp-controller cmu) (ext:*require-verbose* nil) #+(and common-lisp-controller cmu) (ext:*gc-verbose* nil) (*compile-verbose* #-common-lisp-controller t #+common-lisp-controller nil) ; nil (*version* version) (*oos-verbose* verbose) (*oos-test* test) (*load-source-if-no-binary* load-source-if-no-binary) (*compile-during-load* compile-during-load) (*bother-user-if-no-binary* bother-user-if-no-binary) (*load-source-instead-of-binary* load-source-instead-of-binary) (*minimal-load* minimal-load) (system (if (and (component-p name) (member (component-type name) '(:system :defsystem :subsystem))) name (find-system name :load)))) #-(or CMU CLISP :sbcl :lispworks :cormanlisp scl) (declare (special *compile-verbose* #-MCL *compile-file-verbose*) #-openmcl (ignore *compile-verbose* #-MCL *compile-file-verbose*) #-openmcl (optimize (inhibit-warnings 3))) (unless (component-operation operation) (error "Operation ~A undefined." operation)) (operate-on-component system operation force)))) (when dribble (dribble)))) (defun compile-system (name &key force (version *version*) (test *oos-test*) (verbose *oos-verbose*) (load-source-instead-of-binary *load-source-instead-of-binary*) (load-source-if-no-binary *load-source-if-no-binary*) (bother-user-if-no-binary *bother-user-if-no-binary*) (compile-during-load *compile-during-load*) dribble (minimal-load *minimal-load*)) ;; For users who are confused by OOS. (operate-on-system name :compile :force force :version version :test test :verbose verbose :load-source-instead-of-binary load-source-instead-of-binary :load-source-if-no-binary load-source-if-no-binary :bother-user-if-no-binary bother-user-if-no-binary :compile-during-load compile-during-load :dribble dribble :minimal-load minimal-load)) (defun load-system (name &key force (version *version*) (test *oos-test*) (verbose *oos-verbose*) (load-source-instead-of-binary *load-source-instead-of-binary*) (load-source-if-no-binary *load-source-if-no-binary*) (bother-user-if-no-binary *bother-user-if-no-binary*) (compile-during-load *compile-during-load*) dribble (minimal-load *minimal-load*)) ;; For users who are confused by OOS. (operate-on-system name :load :force force :version version :test test :verbose verbose :load-source-instead-of-binary load-source-instead-of-binary :load-source-if-no-binary load-source-if-no-binary :bother-user-if-no-binary bother-user-if-no-binary :compile-during-load compile-during-load :dribble dribble :minimal-load minimal-load)) (defun clean-system (name &key (force :all) (version *version*) (test *oos-test*) (verbose *oos-verbose*) dribble) "Deletes all the binaries in the system." ;; For users who are confused by OOS. (operate-on-system name :delete-binaries :force force :version version :test test :verbose verbose :dribble dribble)) (defun edit-system (name &key force (version *version*) (test *oos-test*) (verbose *oos-verbose*) dribble) (operate-on-system name :edit :force force :version version :test test :verbose verbose :dribble dribble)) (defun hardcopy-system (name &key force (version *version*) (test *oos-test*) (verbose *oos-verbose*) dribble) (operate-on-system name :hardcopy :force force :version version :test test :verbose verbose :dribble dribble)) ;;; ensure-external-system-def-loaded component -- ;;; Let's treat definition clauses of the form ;;; ;;; (:system "name") ;;; i.e. ;;; ;;; (:system "name" :components nil) ;;; ;;; in a special way. ;;; When encountered, MK:DEFSYSTEM tries to FIND-SYSTEM ;;; the system named "name" (by forcing a reload from disk). ;;; This may be more "natural". (defun ensure-external-system-def-loaded (component) (assert (member (component-type component) '(:subsystem :system))) (when (null (component-components component)) (let* ((cname (component-name component))) (declare (ignorable cname)) ;; First we ensure that we reload the system definition. (undefsystem cname) (let* ((*reload-systems-from-disk* t) (system-component (find-system (component-name component) :load ;; Let's not supply the def-pname ;; yet. #+not-yet (merge-pathname (make-pathname :name cname :type "system" :directory ()) (component-full-pathname component :source)) )) ) ;; Now we have a problem. ;; We have just ensured that a system definition is ;; loaded, however, the COMPONENT at hand is different ;; from SYSTEM-COMPONENT. ;; To fix this problem we just use the following ;; kludge. This should prevent re-entering in this ;; code branch, while actually preparing the COMPONENT ;; for operation. (setf (component-components component) (list system-component)) )))) (defun operate-on-component (component operation force &aux changed) ;; Returns T if something changed and had to be compiled. (let ((type (component-type component)) (old-package (package-name *package*))) (unwind-protect ;; Protect old-package. (progn ;; Use the correct package. (when (component-package component) (tell-user-generic (format nil "Using package ~A" (component-package component))) (unless *oos-test* (unless (find-package (component-package component)) ;; If the package name is the same as the name of the system, ;; and the package is not defined, this would lead to an ;; infinite loop, so bomb out with an error. (when (string-equal (string (component-package component)) (component-name component)) (format t "~%Component ~A not loaded:~%" (component-name component)) (error " Package ~A is not defined" (component-package component))) ;; If package not found, try using REQUIRE to load it. (new-require (component-package component))) ;; This was USE-PACKAGE, but should be IN-PACKAGE. ;; Actually, CLtL2 lisps define in-package as a macro, ;; so we'll set the package manually. ;; (in-package (component-package component)) (let ((package (find-package (component-package component)))) (when package (setf *package* package))))) ;; Marco Antoniotti 20040609 ;; New feature. Try to FIND-SYSTEM :system components if ;; they have no local :components definition. ;; OPERATE-ON-SYSTEM-DEPENDENCIES should still work as ;; advertised, given the small change made there. (when (or (eq type :system) (eq type :subsystem)) (ensure-external-system-def-loaded component)) (when (or (eq type :defsystem) (eq type :system)) (operate-on-system-dependencies component operation force)) ;; Do any compiler proclamations (when (component-proclamations component) (tell-user-generic (format nil "Doing proclamations for ~A" (component-name component))) (unless *oos-test* (proclaim (component-proclamations component)))) ;; Do any initial actions (when (component-initially-do component) (tell-user-generic (format nil "Doing initializations for ~A" (component-name component))) (unless *oos-test* (with-special-component-vars (component) (let ((initially-do (component-initially-do component))) (if (functionp initially-do) (funcall initially-do) (eval initially-do)))) )) ;; If operation is :compile and load-only is T, this would change ;; the operation to load. Only, this would mean that a module would ;; be considered to have changed if it was :load-only and had to be ;; loaded, and then dependents would be recompiled -- this doesn't ;; seem right. So instead, we propagate the :load-only attribute ;; to the components, and modify compile-file-operation so that ;; it won't compile the files (and modify tell-user to say "Loading" ;; instead of "Compiling" for load-only modules). #|| (when (and (find operation '(:compile compile)) (component-load-only component)) (setf operation :load)) ||# ;; Do operation and set changed flag if necessary. (setq changed (case type ((:file :private-file) (funcall (component-operation operation) component force)) ((:module :system :subsystem :defsystem) (operate-on-components component operation force changed)))) ;; Do any final actions (when (component-finally-do component) (tell-user-generic (format nil "Doing finalizations for ~A" (component-name component))) (unless *oos-test* (with-special-component-vars (component) (let ((finally-do (component-finally-do component))) (if (functionp finally-do) (funcall finally-do) (eval finally-do)))) )) ;; add the banner if needed #+(or cmu scl) (when (component-banner component) (unless (stringp (component-banner component)) (error "The banner should be a string, it is: ~S" (component-banner component))) (setf (getf ext:*herald-items* (intern (string-upcase (component-name component)) (find-package :keyword))) (list (component-banner component))))) ;; Reset the package. (Cleanup form of unwind-protect.) ;;(in-package old-package) (setf *package* (find-package old-package))) ;; Provide the loaded system (when (or (eq type :defsystem) (eq type :system) (eq type :subsystem)) (tell-user-generic (format nil "Providing system ~A~%" (component-name component))) (or *oos-test* (provide (canonicalize-system-name (component-name component)))))) ;; Return non-NIL if something changed in this component and hence had ;; to be recompiled. This is only used as a boolean. changed) (defvar *force* nil) (defvar *providing-blocks-load-propagation* t "If T, if a system dependency exists on *modules*, it is not loaded.") (defun operate-on-system-dependencies (component operation &optional force) (when *system-dependencies-delayed* (let ((*force* force)) (dolist (system (component-depends-on component)) ;; For each system that this system depends on, if it is a ;; defined system (either via defsystem or component type :system), ;; and propagation is turned on, propagates the operation to the ;; subsystem. Otherwise runs require (my version) on that system ;; to load it (needed since we may be depending on a lisp ;; dependent package). ;; Explores the system tree in a DFS manner. ;; Do not try to do anything with non system components. (cond ((and *operations-propagate-to-subsystems* (not (listp system)) (or (stringp system) (symbolp system)) ;; The subsystem is a defined system. (find-system system :load-or-nil)) ;; Call OOS on it. Since *system-dependencies-delayed* is ;; T, the :depends-on slot is filled with the names of ;; systems, not defstructs. ;; Aside from system, operation, force, for everything else ;; we rely on the globals. (unless (and *providing-blocks-load-propagation* ;; If *providing-blocks-load-propagation* is T, ;; the system dependency must not exist in the ;; *modules* for it to be loaded. Note that ;; the dependencies are implicitly systems. (find operation '(load :load)) ;; (or (eq force :all) (eq force t)) (find (canonicalize-system-name system) *modules* :test #'string-equal)) (operate-on-system system operation :force force))) ((listp system) ;; If the SYSTEM is a list then its contents are as follows. ;; ;; ( &optional ) ;; (destructuring-bind (system-name definition-pathname action &optional version) system (tell-user-require-system (if (and (null system-name) (null definition-pathname)) action system) component) (or *oos-test* (new-require system-name nil (eval definition-pathname) action (or version *version*))))) ((and (component-p system) (not (member (component-type system) '(:defsystem :subsystem :system)))) ;; Do nothing for non system components. ) (t (tell-user-require-system system component) (or *oos-test* (new-require system)))) )))) ;;; Modules can depend only on siblings. If a module should depend ;;; on an uncle, then the parent module should depend on that uncle ;;; instead. Likewise a module should depend on a sibling, not a niece ;;; or nephew. Modules also cannot depend on cousins. Modules cannot ;;; depend on parents, since that is circular. (defun module-depends-on-changed (module changed) (dolist (dependent (component-depends-on module)) (when (member dependent changed) (return t)))) (defun operate-on-components (component operation force changed) (with-tell-user (operation component) (if (component-components component) (dolist (module (component-components component)) (when (operate-on-component module operation (cond ((and (module-depends-on-changed module changed) #||(some #'(lambda (dependent) (member dependent changed)) (component-depends-on module))||# (or (non-empty-listp force) (eq force :new-source-and-dependents))) ;; The component depends on a changed file ;; and force agrees. (if (eq force :new-source-and-dependents) :new-source-all :all)) ((and (non-empty-listp force) (member (component-name module) force :test #'string-equal :key #'string)) ;; Force is a list of modules ;; and the component is one of them. :all) (t force))) (push module changed))) (case operation ((compile :compile) (with-special-component-vars (component) (let ((compile-form (component-compile-form component))) (if (functionp compile-form) (funcall compile-form) (eval compile-form))))) ((load :load) (with-special-component-vars (component) (let ((load-form (component-load-form component))) (if (functionp load-form) (funcall load-form) (eval load-form))) ))))) ;; This is only used as a boolean. changed) ;;; ******************************** ;;; New Require ******************** ;;; ******************************** ;;; This needs cleaning. Obviously the code is a left over from the ;;; time people did not know how to use packages in a proper way or ;;; CLs were shaky in their implementation. ;;; First of all we need this. (Commented out for the time being) ;;; (shadow '(cl:require)) (defvar *old-require* nil) ;;; All calls to require in this file have been replaced with calls ;;; to new-require to avoid compiler warnings and make this less of ;;; a tangled mess. (defun new-require (module-name &optional pathname definition-pname default-action (version *version*)) ;; If the pathname is present, this behaves like the old require. (unless (and module-name (find (string module-name) *modules* :test #'string=)) (handler-case (cond (pathname (funcall *old-require* module-name pathname)) ;; If the system is defined, load it. ((find-system module-name :load-or-nil definition-pname) (operate-on-system module-name :load :force *force* :version version :test *oos-test* :verbose *oos-verbose* :load-source-if-no-binary *load-source-if-no-binary* :bother-user-if-no-binary *bother-user-if-no-binary* :compile-during-load *compile-during-load* :load-source-instead-of-binary *load-source-instead-of-binary* :minimal-load *minimal-load*)) ;; If there's a default action, do it. This could be a progn which ;; loads a file that does everything. ((and default-action (eval default-action))) ;; If no system definition file, try regular require. ;; had last arg PATHNAME, but this wasn't really necessary. ((funcall *old-require* module-name)) ;; If no default action, print a warning or error message. (t #|| (format t "~&Warning: System ~A doesn't seem to be defined..." module-name) ||# (error 'missing-system :name module-name))) (missing-module (mmc) (signal mmc)) ; Resignal. (error (e) (declare (ignore e)) ;; Signal a (maybe wrong) MISSING-SYSTEM. (error 'missing-system :name module-name))) )) ;;; Note that in some lisps, when the compiler sees a REQUIRE form at ;;; top level it immediately executes it. This is as if an ;;; (eval-when (compile load eval) ...) were wrapped around the REQUIRE ;;; form. I don't see any easy way to do this without making REQUIRE ;;; a macro. ;;; ;;; For example, in VAXLisp, if a (require 'streams) form is at the top of ;;; a file in the system, compiling the system doesn't wind up loading the ;;; streams module. If the (require 'streams) form is included within an ;;; (eval-when (compile load eval) ...) then everything is OK. ;;; ;;; So perhaps we should replace the redefinition of lisp:require ;;; with the following macro definition: #|| (unless *old-require* (setf *old-require* (symbol-function #-(or :lispworks :sbcl (and :excl :allegro-v4.0)) 'lisp:require #+:sbcl 'cl:require #+:lispworks 'system:::require #+(and :excl :allegro-v4.0) 'cltl1:require)) (let (#+:CCL (ccl:*warn-if-redefine-kernel* nil)) ;; Note that lots of lisps barf if we redefine a function from ;; the LISP package. So what we do is define a macro with an ;; unused name, and use (setf macro-function) to redefine ;; lisp:require without compiler warnings. If the lisp doesn't ;; do the right thing, try just replacing require-as-macro ;; with lisp:require. (defmacro require-as-macro (module-name &optional pathname definition-pname default-action (version '*version*)) `(eval-when (compile load eval) (new-require ,module-name ,pathname ,definition-pname ,default-action ,version))) (setf (macro-function #-(and :excl :sbcl :allegro-v4.0) 'lisp:require #+:sbcl 'cl:require #+(and :excl :allegro-v4.0) 'cltl1:require) (macro-function 'require-as-macro)))) ||# ;;; This will almost certainly fix the problem, but will cause problems ;;; if anybody does a funcall on #'require. ;;; Redefine old require to call the new require. (eval-when #-(or :lucid) (:load-toplevel :execute) #+(or :lucid) (load eval) (unless *old-require* (setf *old-require* (symbol-function #-(or (and :excl :allegro-v4.0) :mcl :sbcl :lispworks) 'lisp:require #+(and :excl :allegro-v4.0) 'cltl1:require #+:sbcl 'cl:require #+:lispworks3.1 'common-lisp::require #+(and :lispworks (not :lispworks3.1)) 'system::require #+:openmcl 'cl:require #+(and :mcl (not :openmcl)) 'ccl:require )) (unless *dont-redefine-require* (let (#+(or :mcl (and :CCL (not :lispworks))) (ccl:*warn-if-redefine-kernel* nil)) #-(or :ecl (and allegro-version>= (version>= 4 1)) :lispworks) (setf (symbol-function #-(or (and :excl :allegro-v4.0) :mcl :sbcl :lispworks) 'lisp:require #+(and :excl :allegro-v4.0) 'cltl1:require #+:lispworks3.1 'common-lisp::require #+:sbcl 'cl:require #+(and :lispworks (not :lispworks3.1)) 'system::require #+:openmcl 'cl:require #+(and :mcl (not :openmcl)) 'ccl:require ) (symbol-function 'new-require)) #+:ecl (progn (ext:package-lock "CL" nil) (setf (symbol-function 'lisp:require) (symbol-function 'new-require)) (ext:package-lock "CL" t)) #+:lispworks (let ((warn-packs system::*packages-for-warn-on-redefinition*)) (declare (special system::*packages-for-warn-on-redefinition*)) (setq system::*packages-for-warn-on-redefinition* nil) (setf (symbol-function #+:lispworks3.1 'common-lisp::require #-:lispworks3.1 'system::require ) (symbol-function 'new-require)) (setq system::*packages-for-warn-on-redefinition* warn-packs)) #+(and allegro-version>= (version>= 4 1)) (excl:without-package-locks (setf (symbol-function 'lisp:require) (symbol-function 'new-require)))))) ) ;;; Well, let's add some more REQUIRE hacking; specifically for SBCL, ;;; and, eventually, for CMUCL. #+sbcl (eval-when (:compile-toplevel :load-toplevel :execute) (defun sbcl-mk-defsystem-module-provider (name) ;; Let's hope things go smoothly. (let ((module-name (string-downcase (string name)))) (when (mk:find-system module-name :load-or-nil) (mk:load-system module-name :compile-during-load t :verbose nil)))) (pushnew 'sbcl-mk-defsystem-module-provider sb-ext:*module-provider-functions*) ) #+#.(cl:if (cl:and (cl:find-package "EXT") (cl:find-symbol "*MODULE-PROVIDER-FUNCTIONS*" "EXT")) '(and) '(or)) (progn (defun cmucl-mk-defsystem-module-provider (name) (let ((module-name (string-downcase (string name)))) (when (mk:find-system module-name :load-or-nil) (mk:load-system module-name :compile-during-load t :verbose nil)))) (pushnew 'cmucl-mk-defsystem-module-provider ext:*module-provider-functions*) ) ;;; ******************************** ;;; Language-Dependent Characteristics ;;; ******************************** ;;; This section is used for defining language-specific behavior of ;;; defsystem. If the user changes a language definition, it should ;;; take effect immediately -- they shouldn't have to reload the ;;; system definition file for the changes to take effect. (defvar *language-table* (make-hash-table :test #'equal) "Hash table that maps from languages to language structures.") (defun find-language (name) (gethash name *language-table*)) (defstruct (language (:print-function print-language)) name ; The name of the language (a keyword) compiler ; The function used to compile files in the language loader ; The function used to load files in the language source-extension ; Filename extensions for source files binary-extension ; Filename extensions for binary files ) (defun print-language (language stream depth) (declare (ignore depth)) (format stream "#<~:@(~A~): ~A ~A>" (language-name language) (language-source-extension language) (language-binary-extension language))) (defun compile-function (component) (or (component-compiler component) (let ((language (find-language (or (component-language component) :lisp)))) (when language (language-compiler language))) #'compile-file)) (defun load-function (component) (or (component-loader component) (let ((language (find-language (or (component-language component) :lisp)))) (when language (language-loader language))) #'load)) (defun default-source-extension (component) (let ((language (find-language (or (component-language component) :lisp)))) (or (when language (language-source-extension language)) (car *filename-extensions*)))) (defun default-binary-extension (component) (let ((language (find-language (or (component-language component) :lisp)))) (or (when language (language-binary-extension language)) (cdr *filename-extensions*)))) (defmacro define-language (name &key compiler loader source-extension binary-extension) (let ((language (gensym "LANGUAGE"))) `(let ((,language (make-language :name ,name :compiler ,compiler :loader ,loader :source-extension ,source-extension :binary-extension ,binary-extension))) (setf (gethash ,name *language-table*) ,language) ,name))) #|| ;;; Test System for verifying multi-language capabilities. (defsystem foo :language :lisp :components ((:module c :language :c :components ("foo" "bar")) (:module lisp :components ("baz" "barf")))) ||# ;;; *** Lisp Language Definition (define-language :lisp :compiler #'compile-file :loader #'load :source-extension (car *filename-extensions*) :binary-extension (cdr *filename-extensions*)) ;;; *** PseudoScheme Language Definition (defun scheme-compile-file (filename &rest args) (let ((scheme-package (find-package '#:scheme))) (apply (symbol-function (find-symbol (symbol-name 'compile-file) scheme-package)) filename (funcall (symbol-function (find-symbol (symbol-name '#:interaction-environment) scheme-package))) args))) (define-language :scheme :compiler #'scheme-compile-file :loader #'load :source-extension "scm" :binary-extension "bin") ;;; *** C Language Definition ;;; This is very basic. Somebody else who needs it can add in support ;;; for header files, libraries, different C compilers, etc. For example, ;;; we might add a COMPILER-OPTIONS slot to the component defstruct. (defparameter *c-compiler* "gcc") #-(or symbolics (and :lispworks :harlequin-pc-lisp )) (defun run-unix-program (program arguments) ;; arguments should be a list of strings, where each element is a ;; command-line option to send to the program. #+:lucid (run-program program :arguments arguments) #+:allegro (excl:run-shell-command (format nil "~A~@[ ~{~A~^ ~}~]" program arguments)) #+(or :kcl :ecl) (system (format nil "~A~@[ ~{~A~^ ~}~]" program arguments)) #+(or :cmu :scl) (extensions:run-program program arguments) #+:openmcl (ccl:run-program program arguments) #+:sbcl (sb-ext:run-program program arguments) #+:lispworks (foreign:call-system-showing-output (format nil "~A~@[ ~{~A~^ ~}~]" program arguments)) #+clisp (#+lisp=cl ext:run-program #-lisp=cl lisp:run-program program :arguments arguments) ) #+(or symbolics (and :lispworks :harlequin-pc-lisp)) (defun run-unix-program (program arguments) (declare (ignore program arguments)) (error "MK::RUN-UNIX-PROGRAM: this does not seem to be a UN*X system.") ) ;;; This is inspired by various versions - all very UNIX/Linux ;;; dependent - appearing in ASDF and UFFI. The original versions and Copyrights ;;; are by Dan Barlow, Kevin Rosenberg and many others. ;;; This version should be more liberal. (defvar *default-shell* "/bin/sh") #+(or windows ms-windows win32) (eval-when (:load-toplevel :execute) ;; Lets assume a "standard" Cygwin installation. (if (probe-file (pathname "C:\\cygwin\\bin\\sh.exe")) (setf *default-shell* "C:\\cygwin\\bin\\sh.exe") (setf *default-shell* nil))) (defun run-shell-command (command-control-string arguments &key (output *trace-output*) (shell *default-shell*) ) "Executes a shell 'command' in an underlying process. RUN-SHELL-COMMAND interpolate ARGS into CONTROL-STRING as if by FORMAT, and synchronously execute the result using a Bourne-compatible shell, with output to *trace-output*. Returns the shell's exit code." (declare (ignorable shell)) (let ((command (apply #'format nil command-control-string arguments))) #+sbcl (sb-impl::process-exit-code (sb-ext:run-program shell (list "-c" command) :input nil :output output)) #+(or cmu scl) (ext:process-exit-code (ext:run-program shell (list "-c" command) :input nil :output output)) #+allegro (excl:run-shell-command command :input nil :output output) #+(and lispworks win32) (system:call-system-showing-output (format nil "cmd /c ~A" command) :output-stream output) #+(and lispworks (not win32)) (system:call-system-showing-output command :shell-type shell :output-stream output) #+clisp ;XXX not exactly *trace-output*, I know (ext:run-shell-command command :output :terminal :wait t) #+openmcl (nth-value 1 (ccl:external-process-status (ccl:run-program shell (list "-c" command) :input nil :output output :wait t))) #-(or openmcl clisp lispworks allegro scl cmu sbcl) (error "RUN-SHELL-PROGRAM not implemented for this Lisp") )) #|| (defun c-compile-file (filename &rest args &key output-file error-file) ;; gcc -c foo.c -o foo.o (declare (ignore args)) (run-unix-program *c-compiler* (format nil "-c ~A~@[ -o ~A~]" filename output-file))) ||# #|| (defun c-compile-file (filename &rest args &key output-file error-file) ;; gcc -c foo.c -o foo.o (declare (ignore args error-file)) (run-unix-program *c-compiler* `("-c" ,filename ,@(if output-file `("-o" ,output-file))))) ||# ;;; The following code was inserted to improve C compiler support (at ;;; least under Linux/GCC). ;;; Thanks to Espen S Johnsen. ;;; ;;; 20001118 Marco Antoniotti. (defun default-output-pathname (path1 path2 type) (if (eq path1 t) (translate-logical-pathname (merge-pathnames (make-pathname :type type) (pathname path2))) (translate-logical-pathname (pathname path1)))) (defun run-compiler (program arguments output-file error-file error-output verbose) #-(or cmu scl) (declare (ignore error-file error-output)) (flet ((make-useable-stream (&rest streams) (apply #'make-broadcast-stream (delete nil streams))) ) (let (#+(or cmu scl) (error-file error-file) #+(or cmu scl) (error-file-stream nil) (verbose-stream nil) (old-timestamp (file-write-date output-file)) (fatal-error nil) (output-file-written nil) ) (unwind-protect (progn #+(or cmu scl) (setf error-file (when error-file (default-output-pathname error-file output-file *compile-error-file-type*)) error-file-stream (and error-file (open error-file :direction :output :if-exists :supersede))) (setf verbose-stream (make-useable-stream #+cmu error-file-stream (and verbose *trace-output*))) (format verbose-stream "Running ~A~@[ ~{~A~^ ~}~]~%" program arguments) (setf fatal-error #-(or cmu scl) (and (run-unix-program program arguments) nil) ; Incomplete. #+(or cmu scl) (let* ((error-output (make-useable-stream error-file-stream (if (eq error-output t) *error-output* error-output))) (process (ext:run-program program arguments :error error-output))) (not (zerop (ext:process-exit-code process))))) (setf output-file-written (and (probe-file output-file) (not (eql old-timestamp (file-write-date output-file))))) (when output-file-written (format verbose-stream "~A written~%" output-file)) (format verbose-stream "Running of ~A finished~%" program) (values (and output-file-written output-file) fatal-error fatal-error)) #+(or cmu scl) (when error-file (close error-file-stream) (unless (or fatal-error (not output-file-written)) (delete-file error-file))) (values (and output-file-written output-file) fatal-error fatal-error))))) ;;; C Language definitions. (defun c-compile-file (filename &rest args &key (output-file t) (error-file t) (error-output t) (verbose *compile-verbose*) debug link optimize cflags definitions include-paths library-paths libraries (error t)) (declare (ignore args)) (flet ((map-options (flag options &optional (func #'identity)) (mapcar #'(lambda (option) (format nil "~A~A" flag (funcall func option))) options)) ) (let* ((output-file (default-output-pathname output-file filename "o")) (arguments `(,@(when (not link) '("-c")) ,@(when debug '("-g")) ,@(when optimize (list (format nil "-O~D" optimize))) ,@cflags ,@(map-options "-D" definitions #'(lambda (definition) (if (atom definition) definition (apply #'format nil "~A=~A" definition)))) ,@(map-options "-I" include-paths #'truename) ,(namestring (truename filename)) "-o" ,(namestring (translate-logical-pathname output-file)) ,@(map-options "-L" library-paths #'truename) ,@(map-options "-l" libraries)))) (multiple-value-bind (output-file warnings fatal-errors) (run-compiler *c-compiler* arguments output-file error-file error-output verbose) (if (and error (or (not output-file) fatal-errors)) (error "Compilation failed") (values output-file warnings fatal-errors)))))) (define-language :c :compiler #'c-compile-file :loader #+:lucid #'load-foreign-files #+:allegro #'load #+(or :cmu :scl) #'alien:load-foreign #+:sbcl #'sb-alien:load-foreign #+(and :lispworks :unix (not :linux) (not :macosx)) #'link-load:read-foreign-modules #+(and :lispworks :unix (or :linux :macosx)) #'fli:register-module #+(and :lispworks :win32) #'fli:register-module #+(or :ecl :gcl :kcl) #'load ; should be enough. #-(or :lucid :allegro :cmu :sbcl :scl :lispworks :ecl :gcl :kcl) (lambda (&rest args) (declare (ignore args)) (cerror "Continue returning NIL." "Loader not defined for C foreign libraries in ~A ~A." (lisp-implementation-type) (lisp-implementation-version))) :source-extension "c" :binary-extension "o") ;;; Fortran Language definitions. ;;; From Matlisp. (export '(*fortran-compiler* *fortran-options*)) (defparameter *fortran-compiler* "g77") (defparameter *fortran-options* '("-O")) (defun fortran-compile-file (filename &rest args &key output-file error-file &allow-other-keys) (declare (ignore error-file args)) (let ((arg-list (append *fortran-options* `("-c" ,filename ,@(if output-file `("-o" ,output-file)))))) (run-unix-program *fortran-compiler* arg-list))) (mk:define-language :fortran :compiler #'fortran-compile-file :loader #'identity :source-extension "f" :binary-extension "o") ;;; AR support. ;; How to create a library (archive) of object files (export '(*ar-program* build-lib)) (defparameter *ar-program* "ar") (defun build-lib (libname directory) (let ((args (list "rv" (truename libname)))) (format t ";;; Building archive ~A~%" libname) (run-unix-program *ar-program* (append args (mapcar #'truename (directory directory)))))) ;;; ******************************** ;;; Component Operations *********** ;;; ******************************** ;;; Define :compile/compile and :load/load operations (eval-when (:load-toplevel :execute) (component-operation :compile 'compile-and-load-operation) (component-operation 'compile 'compile-and-load-operation) (component-operation :load 'load-file-operation) (component-operation 'load 'load-file-operation) ) (defun compile-and-load-operation (component force) ;; FORCE was CHANGED. this caused defsystem during compilation to only ;; load files that it immediately compiled. (let ((changed (compile-file-operation component force))) ;; Return T if the file had to be recompiled and reloaded. (if (and changed (component-compile-only component)) ;; For files which are :compile-only T, compiling the file ;; satisfies the need to load. changed ;; If the file wasn't compiled, or :compile-only is nil, ;; check to see if it needs to be loaded. (and (load-file-operation component force) ; FORCE was CHANGED ??? changed)))) (defun unmunge-lucid (namestring) ;; Lucid's implementation of COMPILE-FILE is non-standard, in that ;; when the :output-file is a relative pathname, it tries to munge ;; it with the directory of the source file. For example, ;; (compile-file "src/globals.lisp" :output-file "bin/globals.sbin") ;; tries to stick the file in "./src/bin/globals.sbin" instead of ;; "./bin/globals.sbin" like any normal lisp. This hack seems to fix the ;; problem. I wouldn't have expected this problem to occur with any ;; use of defsystem, but some defsystem users are depending on ;; using relative pathnames (at least three folks reported the problem). (cond ((null-string namestring) namestring) ((char= (char namestring 0) #\/) ;; It's an absolute namestring namestring) (t ;; Ugly, but seems to fix the problem. (concatenate 'string "./" namestring)))) #+gcl (defun ensure-directories-exist (arg0 &key verbose) (declare (ignore arg0 verbose)) ()) (defun compile-file-operation (component force) ;; Returns T if the file had to be compiled. (let ((must-compile ;; For files which are :load-only T, loading the file ;; satisfies the demand to recompile. (and (null (component-load-only component)) ; not load-only (or (find force '(:all :new-source-all t) :test #'eq) (and (find force '(:new-source :new-source-and-dependents) :test #'eq) (needs-compilation component nil))))) (source-pname (component-full-pathname component :source))) (cond ((and must-compile (probe-file source-pname)) (with-tell-user ("Compiling source" component :source) (let ((output-file #+:lucid (unmunge-lucid (component-full-pathname component :binary)) #-:lucid (component-full-pathname component :binary))) ;; make certain the directory we need to write to ;; exists [pvaneynd@debian.org 20001114] ;; Added PATHNAME-HOST following suggestion by John ;; DeSoi [marcoxa@sourceforge.net 20020529] (ensure-directories-exist (make-pathname :host (pathname-host output-file) :directory (pathname-directory output-file))) (or *oos-test* (apply (compile-function component) source-pname :output-file output-file #+(or :cmu :scl) :error-file #+(or :cmu :scl) (and *cmu-errors-to-file* (component-full-pathname component :error)) #+cmu :error-output #+cmu *cmu-errors-to-terminal* (component-compiler-options component) )))) must-compile) (must-compile (tell-user "Source file not found. Not compiling" component :source :no-dots :force) nil) (t nil)))) ;;; compiled-file-p -- ;;; See CLOCC/PORT/sys.lisp:compiled-file-p (eval-when (:load-toplevel :execute :compile-toplevel) (when (find-package "PORT") (import (find-symbol "COMPILED-FILE-P" "PORT")))) (unless (fboundp 'compiled-file-p) (defun compiled-file-p (file-name) "Return T if the FILE-NAME is a filename designator for a valid compiled. Signal an error when it is not a filename designator. Return NIL when the file does not exist, or is not readable, or does not contain valid compiled code." #+clisp (with-open-file (in file-name :direction :input :if-does-not-exist nil) (handler-bind ((error (lambda (c) (declare (ignore c)) (return-from compiled-file-p nil)))) (and in (char= #\( (peek-char nil in nil #\a)) (let ((form (read in nil nil))) (and (consp form) (eq (car form) 'SYSTEM::VERSION) (null (eval form))))))) #-clisp (declare (ignorable file-name)) #-clisp t)) (defun needs-compilation (component force) ;; If there is no binary, or it is older than the source ;; file, then the component needs to be compiled. ;; Otherwise we only need to recompile if it depends on a file that changed. (declare (ignore force)) (let ((source-pname (component-full-pathname component :source)) (binary-pname (component-full-pathname component :binary))) (and ;; source must exist (probe-file source-pname) (or ;; We force recompilation. #|(find force '(:all :new-source-all) :test #'eq)|# ;; no binary (null (probe-file binary-pname)) ;; old binary (< (file-write-date binary-pname) (file-write-date source-pname)) ;; invalid binary (not (compiled-file-p binary-pname)))))) (defun needs-loading (component &optional (check-source t) (check-binary t)) ;; Compares the component's load-time against the file-write-date of ;; the files on disk. (let ((load-time (component-load-time component)) (source-pname (component-full-pathname component :source)) (binary-pname (component-full-pathname component :binary))) (or #|| ISI Extension ||# (component-load-always component) ;; File never loaded. (null load-time) ;; Binary is newer. (when (and check-binary (probe-file binary-pname)) (< load-time (file-write-date binary-pname))) ;; Source is newer. (when (and check-source (probe-file source-pname)) (< load-time (file-write-date source-pname)))))) ;;; Need to completely rework this function... (defun load-file-operation (component force) ;; Returns T if the file had to be loaded (let* ((binary-pname (component-full-pathname component :binary)) (source-pname (component-full-pathname component :source)) (binary-exists (probe-file binary-pname)) (source-exists (probe-file source-pname)) (source-needs-loading (needs-loading component t nil)) (binary-needs-loading (needs-loading component nil t)) ;; needs-compilation has an implicit source-exists in it. (needs-compilation (if (component-load-only component) source-needs-loading (needs-compilation component force))) (check-for-new-source ;; If force is :new-source*, we're checking for files ;; whose source is newer than the compiled versions. (find force '(:new-source :new-source-and-dependents :new-source-all) :test #'eq)) (load-binary (or (find force '(:all :new-source-all t) :test #'eq) binary-needs-loading)) (load-source (or *load-source-instead-of-binary* (and load-binary (component-load-only component)) (and check-for-new-source needs-compilation))) (compile-and-load (and needs-compilation (or load-binary check-for-new-source) (compile-and-load-source-if-no-binary component))) ) ;; When we're trying to minimize the files loaded to only those ;; that need be, restrict the values of load-source and load-binary ;; so that we only load the component if the files are newer than ;; the load-time. (when (and *minimal-load* (not (find force '(:all :new-source-all) :test #'eq))) (when load-source (setf load-source source-needs-loading)) (when load-binary (setf load-binary binary-needs-loading))) (when (or load-source load-binary compile-and-load) (cond (compile-and-load ;; If we're loading the binary and it is old or nonexistent, ;; and the user says yes, compile and load the source. (compile-file-operation component t) (with-tell-user ("Loading binary" component :binary) (or *oos-test* (progn (funcall (load-function component) binary-pname) (setf (component-load-time component) (file-write-date binary-pname))))) t) ((and source-exists (or (and load-source ; implicit needs-comp... (or *load-source-instead-of-binary* (component-load-only component) (not *compile-during-load*))) (and load-binary (not binary-exists) (load-source-if-no-binary component)))) ;; Load the source if the source exists and: ;; o we're loading binary and it doesn't exist ;; o we're forcing it ;; o we're loading new source and user wasn't asked to compile (with-tell-user ("Loading source" component :source) (or *oos-test* (progn (funcall (load-function component) source-pname) (setf (component-load-time component) (file-write-date source-pname))))) t) ((and binary-exists load-binary) (with-tell-user ("Loading binary" component :binary) (or *oos-test* (progn (funcall (load-function component) binary-pname) (setf (component-load-time component) (file-write-date binary-pname))))) t) ((and (not binary-exists) (not source-exists)) (tell-user-no-files component :force) (when *files-missing-is-an-error* (cerror "Continue, ignoring missing files." "~&Source file ~S ~:[and binary file ~S ~;~]do not exist." source-pname (or *load-source-if-no-binary* *load-source-instead-of-binary*) binary-pname)) nil) (t nil))))) (eval-when (load eval) (component-operation :clean 'delete-binaries-operation) (component-operation 'clean 'delete-binaries-operation) (component-operation :delete-binaries 'delete-binaries-operation) (component-operation 'delete-binaries 'delete-binaries-operation) ) (defun delete-binaries-operation (component force) (when (or (eq force :all) (eq force t) (and (find force '(:new-source :new-source-and-dependents :new-source-all) :test #'eq) (needs-compilation component nil))) (let ((binary-pname (component-full-pathname component :binary))) (when (probe-file binary-pname) (with-tell-user ("Deleting binary" component :binary) (or *oos-test* (delete-file binary-pname))))))) ;; when the operation = :compile, we can assume the binary exists in test mode. ;; ((and *oos-test* ;; (eq operation :compile) ;; (probe-file (component-full-pathname component :source))) ;; (with-tell-user ("Loading binary" component :binary))) (defun binary-exists (component) (probe-file (component-full-pathname component :binary))) ;;; or old-binary (defun compile-and-load-source-if-no-binary (component) (when (not (or *load-source-instead-of-binary* (and *load-source-if-no-binary* (not (binary-exists component))))) (cond ((component-load-only component) #|| (let ((prompt (prompt-string component))) (format t "~A- File ~A is load-only, ~ ~&~A not compiling." prompt (component-full-pathname component :source) prompt)) ||# nil) ((eq *compile-during-load* :query) (let* ((prompt (prompt-string component)) (compile-source (y-or-n-p-wait #\y 30 "~A- Binary file ~A is old or does not exist. ~ ~&~A Compile (and load) source file ~A instead? " prompt (component-full-pathname component :binary) prompt (component-full-pathname component :source)))) (unless (y-or-n-p-wait #\y 30 "~A- Should I bother you if this happens again? " prompt) (setq *compile-during-load* (y-or-n-p-wait #\y 30 "~A- Should I compile while loading the system? " prompt))) ; was compile-source, then t compile-source)) (*compile-during-load*) (t nil)))) (defun load-source-if-no-binary (component) (and (not *load-source-instead-of-binary*) (or (and *load-source-if-no-binary* (not (binary-exists component))) (component-load-only component) (when *bother-user-if-no-binary* (let* ((prompt (prompt-string component)) (load-source (y-or-n-p-wait #\y 30 "~A- Binary file ~A does not exist. ~ ~&~A Load source file ~A instead? " prompt (component-full-pathname component :binary) prompt (component-full-pathname component :source)))) (setq *bother-user-if-no-binary* (y-or-n-p-wait #\n 30 "~A- Should I bother you if this happens again? " prompt )) (unless *bother-user-if-no-binary* (setq *load-source-if-no-binary* load-source)) load-source))))) ;;; ******************************** ;;; Allegro Toplevel Commands ****** ;;; ******************************** ;;; Creates toplevel command aliases for Allegro CL. #+:allegro (top-level:alias ("compile-system" 8) (system &key force (minimal-load mk:*minimal-load*) test verbose version) "Compile the specified system" (mk:compile-system system :force force :minimal-load minimal-load :test test :verbose verbose :version version)) #+:allegro (top-level:alias ("load-system" 5) (system &key force (minimal-load mk:*minimal-load*) (compile-during-load mk:*compile-during-load*) test verbose version) "Compile the specified system" (mk:load-system system :force force :minimal-load minimal-load :compile-during-load compile-during-load :test test :verbose verbose :version version)) #+:allegro (top-level:alias ("show-system" 5) (system) "Show information about the specified system." (mk:describe-system system)) #+:allegro (top-level:alias ("describe-system" 9) (system) "Show information about the specified system." (mk:describe-system system)) #+:allegro (top-level:alias ("system-source-size" 9) (system) "Show size information about source files in the specified system." (mk:system-source-size system)) #+:allegro (top-level:alias ("clean-system" 6) (system &key force test verbose version) "Delete binaries in the specified system." (mk:clean-system system :force force :test test :verbose verbose :version version)) #+:allegro (top-level:alias ("edit-system" 7) (system &key force test verbose version) "Load system source files into Emacs." (mk:edit-system system :force force :test test :verbose verbose :version version)) #+:allegro (top-level:alias ("hardcopy-system" 9) (system &key force test verbose version) "Hardcopy files in the specified system." (mk:hardcopy-system system :force force :test test :verbose verbose :version version)) #+:allegro (top-level:alias ("make-system-tag-table" 13) (system) "Make an Emacs TAGS file for source files in specified system." (mk:make-system-tag-table system)) ;;; ******************************** ;;; Allegro Make System Fasl ******* ;;; ******************************** #+:excl (defun allegro-make-system-fasl (system destination &optional (include-dependents t)) (excl:shell (format nil "rm -f ~A; cat~{ ~A~} > ~A" destination (if include-dependents (files-in-system-and-dependents system :all :binary) (files-in-system system :all :binary)) destination))) (defun files-which-need-compilation (system) (mapcar #'(lambda (comp) (component-full-pathname comp :source)) (remove nil (file-components-in-component (find-system system :load) :new-source)))) (defun files-in-system-and-dependents (name &optional (force :all) (type :source) version) ;; Returns a list of the pathnames in system and dependents in load order. (let ((system (find-system name :load))) (multiple-value-bind (*version-dir* *version-replace*) (translate-version version) (let ((*version* version)) (let ((result (file-pathnames-in-component system type force))) (dolist (dependent (reverse (component-depends-on system))) (setq result (append (files-in-system-and-dependents dependent force type version) result))) result))))) (defun files-in-system (name &optional (force :all) (type :source) version) ;; Returns a list of the pathnames in system in load order. (let ((system (if (and (component-p name) (member (component-type name) '(:defsystem :system :subsystem))) name (find-system name :load)))) (multiple-value-bind (*version-dir* *version-replace*) (translate-version version) (let ((*version* version)) (file-pathnames-in-component system type force))))) (defun file-pathnames-in-component (component type &optional (force :all)) (mapcar #'(lambda (comp) (component-full-pathname comp type)) (file-components-in-component component force))) (defun file-components-in-component (component &optional (force :all) &aux result changed) (case (component-type component) ((:file :private-file) (when (setq changed (or (find force '(:all t) :test #'eq) (and (not (non-empty-listp force)) (needs-compilation component nil)))) (setq result (list component)))) ((:module :system :subsystem :defsystem) (dolist (module (component-components component)) (multiple-value-bind (r c) (file-components-in-component module (cond ((and (some #'(lambda (dependent) (member dependent changed)) (component-depends-on module)) (or (non-empty-listp force) (eq force :new-source-and-dependents))) ;; The component depends on a changed file and force agrees. :all) ((and (non-empty-listp force) (member (component-name module) force :test #'string-equal :key #'string)) ;; Force is a list of modules and the component is ;; one of them. :all) (t force))) (when c (push module changed) (setq result (append result r))))))) (values result changed)) (setf (symbol-function 'oos) (symbol-function 'operate-on-system)) ;;; ******************************** ;;; Additional Component Operations ;;; ******************************** ;;; *** Edit Operation *** ;;; Should this conditionalization be (or :mcl (and :CCL (not :lispworks)))? #| #+:ccl (defun edit-operation (component force) "Always returns nil, i.e. component not changed." (declare (ignore force)) ;; (let* ((full-pathname (make::component-full-pathname component :source)) (already-editing\? #+:mcl (dolist (w (CCL:windows :class 'fred-window)) (when (equal (CCL:window-filename w) full-pathname) (return w))) #-:mcl nil)) (if already-editing\? #+:mcl (CCL:window-select already-editing\?) #-:mcl nil (ed full-pathname))) nil) #+:allegro (defun edit-operation (component force) "Edit a component - always returns nil, i.e. component not changed." (declare (ignore force)) (let ((full-pathname (component-full-pathname component :source))) (ed full-pathname)) nil) #+(or :ccl :allegro) (make::component-operation :edit 'edit-operation) #+(or :ccl :allegro) (make::component-operation 'edit 'edit-operation) |# ;;; *** Hardcopy System *** (defparameter *print-command* "enscript -2Gr" ; "lpr" "Command to use for printing files on UNIX systems.") #+:allegro (defun hardcopy-operation (component force) "Hardcopy a component - always returns nil, i.e. component not changed." (declare (ignore force)) (let ((full-pathname (component-full-pathname component :source))) (excl:run-shell-command (format nil "~A ~A" *print-command* full-pathname))) nil) #+:allegro (make::component-operation :hardcopy 'hardcopy-operation) #+:allegro (make::component-operation 'hardcopy 'hardcopy-operation) ;;; *** System Source Size *** (defun system-source-size (system-name &optional (force :all)) "Prints a short report and returns the size in bytes of the source files in ." (let* ((file-list (files-in-system system-name force :source)) (total-size (file-list-size file-list))) (format t "~&~a/~a (~:d file~:p) totals ~:d byte~:p (~:d kB)" system-name force (length file-list) total-size (round total-size 1024)) total-size)) (defun file-list-size (file-list) "Returns the size in bytes of the files in ." ;; (let ((total-size 0)) (dolist (file file-list) (with-open-file (stream file) (incf total-size (file-length stream)))) total-size)) ;;; *** System Tag Table *** #+:allegro (defun make-system-tag-table (system-name) "Makes an Emacs tag table using the GNU etags program." (let ((files-in-system (files-in-system system-name :all :source))) (format t "~&Making tag table...") (excl:run-shell-command (format nil "etags ~{~a ~}" files-in-system)) (format t "done.~%"))) ;;; end of file -- defsystem.lisp -- ecl-16.1.2/contrib/ecl-cdb/000077500000000000000000000000001266352375300153115ustar00rootroot00000000000000ecl-16.1.2/contrib/ecl-cdb/ecl-cdb.lisp000066400000000000000000000254641266352375300175060ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; Package: SYSTEM -*- ;;;; ;;;; Copyright (c) 2011, Juan Jose Garcia-Ripoll. ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. ;;;; ;;;; This file implements the CDB specification, which you find here ;;;; http://cr.yp.to/cdb/cdb.txt and is reproduced below, replicating ;;;; the interface developed by Zach Beane under the name ZCDB. ;;;; ;;;; A structure for constant databases ;;;; 19960914 ;;;; Copyright 1996 ;;;; D. J. Bernstein, djb@pobox.com ;;;; ;;;; A cdb is an associative array: it maps strings (``keys'') to strings ;;;; (``data''). ;;;; ;;;; A cdb contains 256 pointers to linearly probed open hash tables. The ;;;; hash tables contain pointers to (key,data) pairs. A cdb is stored in ;;;; a single file on disk: ;;;; ;;;; +----------------+---------+-------+-------+-----+---------+ ;;;; | p0 p1 ... p255 | records | hash0 | hash1 | ... | hash255 | ;;;; +----------------+---------+-------+-------+-----+---------+ ;;;; ;;;; Each of the 256 initial pointers states a position and a length. The ;;;; position is the starting byte position of the hash table. The length ;;;; is the number of slots in the hash table. ;;;; ;;;; Records are stored sequentially, without special alignment. A record ;;;; states a key length, a data length, the key, and the data. ;;;; ;;;; Each hash table slot states a hash value and a byte position. If the ;;;; byte position is 0, the slot is empty. Otherwise, the slot points to ;;;; a record whose key has that hash value. ;;;; ;;;; Positions, lengths, and hash values are 32-bit quantities, stored in ;;;; little-endian form in 4 bytes. Thus a cdb must fit into 4 gigabytes. ;;;; ;;;; A record is located as follows. Compute the hash value of the key in ;;;; the record. The hash value modulo 256 is the number of a hash table. ;;;; The hash value divided by 256, modulo the length of that table, is a ;;;; slot number. Probe that slot, the next higher slot, and so on, until ;;;; you find the record or run into an empty slot. ;;;; ;;;; The cdb hash function is ``h = ((h << 5) + h) ^ c'', with a starting ;;;; hash of 5381. ;;;; (defpackage "ECL-CDB" (:use "CL") (:export "WITH-OUTPUT-TO-CDB" "ADD-RECORD" "LOOKUP-CDB")) (in-package "ECL-CDB") (defstruct cdb stream pathname word-buffer tables temporary-pathname) (defun read-word (stream) (logior (read-byte stream) (ash (read-byte stream) 8) (ash (read-byte stream) 16) (ash (read-byte stream) 24))) (defun write-word (byte stream) (declare (type (unsigned-byte 32) byte) (stream stream) (optimize speed (safety 0))) (write-byte (logand #xff byte) stream) (write-byte (logand #xff (ash byte -8)) stream) (write-byte (logand #xff (ash byte -16)) stream) (write-byte (logand #xff (ash byte -24)) stream)) (defun write-vector (vector stream) (declare (type (array (unsigned-byte 8) (*)) vector)) (loop for v across vector do (write-word v stream))) (defun to-cdb-hash (key-vector) (declare (type (array (unsigned-byte 8) (*)) key-vector)) (loop with h of-type (unsigned-integer 32) = 5381 for byte of-type (unsigned-byte 8) across key-vector do (setf h (logxor (logand #xffffffff (+ (ash (logand #.(ash #xffffffff -5) h) 5) h)) byte)) finally (return h))) (defun %make-cdb (cdb-pathname temporary-pathname) (let ((stream (open temporary-pathname :direction :output :if-exists :supersede :if-does-not-exist :create :element-type '(unsigned-byte 8)))) (if stream (progn (file-position stream 0) (dotimes (i (* 256 2)) (write-word 0 stream)) (make-cdb :stream stream :pathname cdb-pathname :tables (make-array 256 :initial-element nil) :temporary-pathname temporary-pathname)) (error "Unable to create CDB at filename ~A" temporary-pathname)))) (defmacro with-output-to-cdb ((cdb cdb-pathname temporary-pathname) &body body) `(let (,cdb) (unwind-protect (progn (setf ,cdb (%make-cdb ,cdb-pathname ,temporary-pathname)) ,@body) (close-cdb ,cdb)))) (defun add-record (key value cdb) ;; This routine dumps the data of this record, storing a small ;; reference in the CDB structure itself. This reference will be ;; used to create the hash. (let* ((hash-key (to-cdb-hash key)) (table-index (logand #xff hash-key)) (stream (cdb-stream cdb))) (push (cons hash-key (file-position stream)) (aref (cdb-tables cdb) table-index)) (write-word (length key) stream) (write-word (length value) stream) (write-sequence key stream) (write-sequence value stream))) (defun dump-table (table stream) (declare (optimize speed (safety 0))) ;; TABLE is an association list of (HASH-KEY . FILE-POSITION) ;; We dump it at the end of the file. The length of the actual ;; file table can be a bit larger, to avoid many coincidences. ;; Here we use a factor 2. (loop with length = (* 2 (length table)) with vector = (make-array (* 2 length) :initial-element 0 :element-type '(unsigned-byte 32)) for (hash-key . pos) in table for index = (mod (ash hash-key -8) length) do (loop for disp from 0 below length for i = (* 2 (mod (+ disp index) length)) for record-pos = (aref vector (1+ i)) until (zerop record-pos) finally (setf (aref vector i) hash-key (aref vector (1+ i)) pos)) finally (progn (write-vector vector stream) (return length)))) (defun dump-cdb (cdb) ;; After we have dumped all the records in the file, we append the ;; hash tables and recreate the index table at the beginning. (let* ((stream (cdb-stream cdb)) (index (make-array (* 2 256) :element-type '(unsigned-byte 32)))) (loop for table across (cdb-tables cdb) for i of-type fixnum from 0 by 2 do (setf (aref index i) (file-position stream) (aref index (1+ i)) (dump-table table stream))) (file-position stream 0) (write-vector index stream))) (defun close-cdb (cdb) (let ((stream (cdb-stream cdb))) (when (open-stream-p stream) (dump-cdb cdb) (close stream) (when (cdb-pathname cdb) (rename-file (cdb-temporary-pathname cdb) (cdb-pathname cdb)))))) (defun cdb-error (stream) (error "Error when reading CDB database ~A" stream)) (defun values-coincide (position key-vector stream return-position-p) (unless (file-position stream position) (cdb-error stream)) (let ((key-length (read-word stream))) (when (= key-length (length key-vector)) (let* ((value-length (read-word stream)) (other-key (make-array key-length :element-type '(unsigned-byte 8)))) (read-sequence other-key stream) (when (equalp other-key key-vector) (if return-position-p (file-position stream) (let ((value (make-array value-length :element-type '(unsigned-byte 8)))) (read-sequence value stream) value) )))))) (defun lookup-cdb (key stream &optional return-position-p) (if (streamp stream) (let* ((hash (to-cdb-hash key)) (table (logand #xFF hash))) (unless (file-position stream (* table 8)) (cdb-error stream)) (let* ((start (read-word stream)) (length (read-word stream)) (index (mod (ash hash -8) length))) (loop for reset = t for i from 0 below length for rounded-i = (mod (+ index i) length) for position = (+ start (* 8 rounded-i)) do (progn (when reset (unless (file-position stream position) (cdb-error stream)) (setf reset nil)) (let* ((other-hash (read-word stream)) (record-position (read-word stream))) (when (zerop record-position) (return nil)) (when (= other-hash hash) (let ((output (values-coincide record-position key stream return-position-p))) (if output (return output) (setf reset t))))))))) (with-open-file (s stream :direction :input :element-type '(unsigned-byte 8)) (lookup-cdb key s return-position-p)))) (defun map-cdb (function stream) (if (streamp stream) (let* ((index (make-array (* 256 2) :element-type '(unsigned-byte 32)))) (unless (file-position stream 0) (cdb-error stream)) (unless (= (read-sequence index stream) (length index)) (cdb-error stream)) (loop for i from 0 by 2 below (length index) for table-position = (aref index i) for table-length = (aref index (1+ i)) do (progn (unless (file-position stream table-position) (cdb-error stream)) (loop for i from 0 below table-length for position from table-position by 8 for record-hash = (read-word stream) for record-position = (read-word stream) unless (zerop record-position) do (progn (unless (file-position stream record-position) (cdb-error stream)) (let* ((key-length (read-word stream)) (value-length (read-word stream)) (key (make-array key-length :element-type '(unsigned-byte 8))) (value (make-array value-length :element-type '(unsigned-byte 8)))) (unless (and (= (read-sequence key stream) key-length) (= (read-sequence value stream) value-length)) (cdb-error stream)) (funcall function key value))))))) (with-open-file (s stream :direction :input :element-type '(unsigned-byte 8)) (map-cdb function s)))) (provide '#:ecl-cdb) ecl-16.1.2/contrib/ecl-cdb/ecl-help.lisp000066400000000000000000000041021266352375300176700ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; Package: SYSTEM -*- ;;;; ;;;; Copyright (c) 2011, Juan Jose Garcia-Ripoll. ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. ;;;; (in-package "SYSTEM") (defun to-cdb-vector (object) (let* ((vector (make-array 128 :adjustable t :fill-pointer 0 :element-type '(unsigned-byte 8) :initial-element 0)) (stream (ext:make-sequence-output-stream vector :external-format #+unicode :utf-8 #-unicode :default))) (with-standard-io-syntax (let ((si::*print-package* (find-package "CL"))) (write object :stream stream :pretty nil :readably nil :escape t))) vector)) (defun from-cdb-vector (vector) (let* ((stream (ext:make-sequence-input-stream vector :external-format #+unicode :utf-8 #-unicode :default))) (read stream nil nil nil))) (defun search-help-file (string path) (let* ((key (to-cdb-vector string)) (value (ecl-cdb:lookup-cdb key path))) (when value (from-cdb-vector value)))) (defun dump-help-file (hash-table path &optional merge test) (when merge (error "DUMP-HELP-FILE does not suport yet the third argument")) (ecl-cdb:with-output-to-cdb (cdb nil path) (loop for k being the hash-key of hash-table using (hash-value v) do (ecl-cdb:add-record (to-cdb-vector k) (to-cdb-vector v) cdb))) ;; Testing the consistency of the output (when test (loop for k being the hash-key of hash-table using (hash-value v) for other-value = (search-help-file k path) unless (and other-value (equalp other-value v)) do (error "Symbol ~A not found in database ~A" k path)))) ecl-16.1.2/contrib/ecl-curl/000077500000000000000000000000001266352375300155265ustar00rootroot00000000000000ecl-16.1.2/contrib/ecl-curl/ecl-curl.lisp000066400000000000000000000251261266352375300201330ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; Package: C -*- ;;; ;;; ecl-curl.lisp - download of files via http ;;; ;;; (c) 2011, Juan Jose Garcia-Ripoll ;;; ;;; THIS CODE IS BASED ON ASDF-INSTALL. AS SUCH IT RETAINS THE FOLLOWING ;;; COPYRIGHT NOTICE ;;; ;;; The original ASDF-INSTALL code (the files Makefile, README, ;;; asdf-install.asd, defpackage.lisp, and installer.lisp) was written by ;;; Daniel Barlow and is distributed with SBCL and ;;; therefore in the public domain. The SBCL Common Lisp implementation ;;; can be obtained from Sourceforge: . ;;; ;;; The initial port of ASDF-INSTALL to other Lisps was done by Dr. Edmund ;;; Weitz and included the file port.lisp and some ;;; changes to the files mentioned above. More code was provided by Marco ;;; Baringer (OpenMCL port), James Anderson ;;; (MCL port, including the file digitool.lisp), ;;; Kiyoshi Mizumaru , Robert P. Goldman ;;; , and Raymond Toy ;;; (bugfixes). Marco Antoniotti added support for ;;; MK:DEFSYSTEM which includes the files load-asdf-install.lisp, ;;; loader.lisp, and finally split-sequence.lisp which has its own ;;; copyright notice. ASDF-Install is currently maintained by Gary King ;;; and is hosted on Common-Lisp.net. ;;; ;;; The complete code distributed with this archive (asdf-install.tar.gz) ;;; is copyrighted by the above-mentioned authors and governed by the ;;; following license. ;;; ;;; Redistribution and use in source and binary forms, with or without ;;; modification, are permitted provided that the following conditions are ;;; met: ;;; ;;; * Redistributions of source code must retain the above copyright ;;; notice, this list of conditions and the following disclaimer. ;;; ;;; * Redistributions in binary form must reproduce the above ;;; copyright notice, this list of conditions and the following ;;; disclaimer in the documentation and/or other materials ;;; provided with the distribution. ;;; ;;; THIS SOFTWARE IS PROVIDED BY THE AUTHORS 'AS IS' AND ANY EXPRESSED OR ;;; IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED ;;; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE ;;; DISCLAIMED. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, ;;; INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES ;;; (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR ;;; SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ;;; HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, ;;; STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING ;;; IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE ;;; POSSIBILITY OF SUCH DAMAGE. (require :sockets) (defpackage #:ecl-curl (:use #:sb-bsd-sockets #:cl) (:export #:download-url-to-file #:download-error #:download-url #:download-response)) (in-package "ECL-CURL") ;;;--------------------------------------------------------------------------- ;;; CONDITIONS ;;; (define-condition http-transfer-error (error) ((url :initarg :url :reader download-url))) (define-condition download-error (http-transfer-error) ((response :initarg :response :reader download-response)) (:report (lambda (c s) (format s "Server responded ~A for GET ~A" (download-response c) (download-url c))))) ;;;--------------------------------------------------------------------------- ;;; PORTABILITY LAYER ;;; (defvar *stream-buffer-size* 8192) (defun copy-stream (from to) "Copy into TO from FROM until end of the input stream, in blocks of *stream-buffer-size*. The streams should have the same element type." (unless (subtypep (stream-element-type to) (stream-element-type from)) (error "Incompatible streams ~A and ~A." from to)) (let ((buf (make-array *stream-buffer-size* :element-type (stream-element-type from)))) (loop (let ((pos #-(or :clisp :cmu) (read-sequence buf from) #+:clisp (ext:read-byte-sequence buf from :no-hang nil) #+:cmu (sys:read-n-bytes from buf 0 *stream-buffer-size* nil))) (when (zerop pos) (return)) (write-sequence buf to :end pos))))) (defun make-stream-from-url (url) (let ((s (make-instance 'sb-bsd-sockets:inet-socket :type :stream :protocol :tcp))) (sb-bsd-sockets:socket-connect s (car (sb-bsd-sockets:host-ent-addresses (sb-bsd-sockets:get-host-by-name (url-host url)))) (url-port url)) (sb-bsd-sockets:socket-make-stream s :input t :output t :buffering :full :external-format #+unicode :iso-8859-1 #-unicode :default))) ;;;--------------------------------------------------------------------------- ;;; URL handling. ;;; (defun url-host (url) (assert (string-equal url "http://" :end1 7)) (let* ((port-start (position #\: url :start 7)) (host-end (min (or (position #\/ url :start 7) (length url)) (or port-start (length url))))) (subseq url 7 host-end))) (defun url-port (url) (assert (string-equal url "http://" :end1 7)) (let ((port-start (position #\: url :start 7))) (if port-start (parse-integer url :start (1+ port-start) :junk-allowed t) 80))) ; This is from Juri Pakaste's base64.lisp (defparameter *encode-table* "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=") (defun base64-encode (string) (let ((result (make-array (list (* 4 (truncate (/ (+ 2 (length string)) 3)))) :element-type 'base-char))) (do ((sidx 0 (+ sidx 3)) (didx 0 (+ didx 4)) (chars 2 2) (value nil nil)) ((>= sidx (length string)) t) (setf value (ash (logand #xFF (char-code (char string sidx))) 8)) (dotimes (n 2) (when (< (+ sidx n 1) (length string)) (setf value (logior value (logand #xFF (char-code (char string (+ sidx n 1)))))) (incf chars)) (when (= n 0) (setf value (ash value 8)))) (setf (elt result (+ didx 3)) (elt *encode-table* (if (> chars 3) (logand value #x3F) 64))) (setf value (ash value -6)) (setf (elt result (+ didx 2)) (elt *encode-table* (if (> chars 2) (logand value #x3F) 64))) (setf value (ash value -6)) (setf (elt result (+ didx 1)) (elt *encode-table* (logand value #x3F))) (setf value (ash value -6)) (setf (elt result didx) (elt *encode-table* (logand value #x3F)))) result)) (defvar *proxy* (ext:getenv "http_proxy")) (defvar *proxy-user* nil) (defvar *proxy-passwd* nil) (defun request-uri (url) (assert (string-equal url "http://" :end1 7)) (if *proxy* url (let ((path-start (position #\/ url :start 7))) (if path-start (subseq url path-start) "/index.html")))) ;;;--------------------------------------------------------------------------- ;;; CONNECTION & HEADRE ;;; (defun header-pair (name headers) "Searchers headers for name _without_ case sensitivity. Headers should be an alist mapping symbols to values; name a symbol. Returns the \(name value\) pair if name is found or nil if it is not." (assoc name headers :test (lambda (a b) (string-equal (symbol-name a) (symbol-name b))))) (defun header-value (name headers) "Searchers headers for name _without_ case sensitivity. Headers should be an alist mapping symbols to values; name a symbol. Returns the value if name is found or nil if it is not." (cdr (header-pair name headers))) (defun url-connection (url) (let ((stream (make-stream-from-url (or *proxy* url))) (host (url-host url))) (format stream "GET ~A HTTP/1.0~C~CHost: ~A~C~C" (request-uri url) #\Return #\Linefeed host #\Return #\Linefeed) (when (and *proxy-passwd* *proxy-user*) (format stream "Proxy-Authorization: Basic ~A~C~C" (base64-encode (format nil "~A:~A" *proxy-user* *proxy-passwd*)) #\Return #\Linefeed)) (format stream "~C~C" #\Return #\Linefeed) (force-output stream) (values (let* ((l (read-line stream)) (space (position #\Space l))) (parse-integer l :start (1+ space) :junk-allowed t)) (loop for line = (read-line stream) until (or (null line) (zerop (length line)) (eql (elt line 0) (code-char 13))) collect (let ((colon (position #\: line))) (cons (intern (string-upcase (subseq line 0 colon)) :keyword) (string-trim (list #\Space (code-char 13)) (subseq line (1+ colon)))))) stream))) ;;;--------------------------------------------------------------------------- ;;; DOWNLOAD ;;; (defun download-url-to-file (url file-name &key quiet) "Resolves url and then downloads it to file-name; returns the url actually used." (multiple-value-bind (response headers stream) (loop (multiple-value-bind (response headers stream) (url-connection url) (unless (member response '(301 302)) (return (values response headers stream))) (close stream) (setf url (header-value :location headers)))) (when (>= response 400) (error 'download-error :url url :response response)) (let ((length (parse-integer (or (header-value :content-length headers) "") :junk-allowed t))) (unless quiet (format t "~&;;; Downloading ~A bytes from ~A to ~A ...~%" (or length "some unknown number of") url file-name)) (force-output) (let ((ok? nil) (o nil)) (unwind-protect (progn (setf o (open file-name :direction :output :if-exists :supersede :external-format #-unicode :default #+unicode :latin-1)) (if length (let ((buf (make-array length :element-type (stream-element-type stream)))) (read-sequence buf stream) (write-sequence buf o)) (copy-stream stream o)) (setf ok? t)) (when o (close o :abort (null ok?)))))) (close stream)) (values url)) (provide '#:ecl-curl) ecl-16.1.2/contrib/encodings/000077500000000000000000000000001266352375300157715ustar00rootroot00000000000000ecl-16.1.2/contrib/encodings/ATARIST.BIN000066400000000000000000000020021266352375300174240ustar00rootroot00000000000000  !!""##$$%%&&''(())**++,,--..//00112233445566778899::;;<<==>>??@@AABBCCDDEEFFGGHHIIJJKKLLMMNNOOPPQQRRSSTTUUVVWWXXYYZZ[[\\]]^^__``aabbccddeeffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~€Чќ‚щƒт„ф…р†х‡чˆъ‰ыŠш‹яŒюьŽФХЩ‘ц’Ц“є”і•ђ–ћ—љ˜џ™жšм›ЂœЃЅžпŸ’ сЁэЂѓЃњЄёЅбІЊЇКЈПЉ#ЊЌЋНЌМ­ЁЎЋЏЛАуБѕВиГјДSЕRЖРЗУИеЙЈКДЛ МЖНЉОЎП!"Р3С2ТаУбФвХгЦдЧеШжЩзЪиЫйЬлЭмЮоЯрасбтвфгцдчешжщзъипйккнлумхнЇо"'п"рБсВт“уРфЃхУцЕчФшІщ˜ъЉыДь".эЦю"я")№"aёБђ"eѓ"dє# ѕ#!іїї"HјАљ"њЗћ"ќ §ВўГџЏecl-16.1.2/contrib/encodings/CP-856.BIN000066400000000000000000000015361266352375300171520ustar00rootroot00000000000000Ў  !!""##$$%%&&''(())**++,,--..//00112233445566778899::;;<<==>>??@@AABBCCDDEEFFGGHHIIJJKKLLMMNNOOPPQQRRSSTTUUVVWWXXYYZZ[[\\]]^^__``aabbccddeeffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~€аб‚вƒг„д…е†ж‡зˆи‰йŠк‹лŒмнŽопр‘с’т“у”ф•х–ц—ч˜ш™щšъœЃžзЉЎЊЌЋНЌМЎЋЏЛА%‘Б%’В%“Г%Д%$ИЉЙ%cК%QЛ%WМ%]НЂОЅП%Р%С%4Т%,У%Ф%Х%<Ш%ZЩ%TЪ%iЫ%fЬ%`Э%PЮ%lЯЄй%к% л%ˆм%„нІп%€цЕюЏяД№­ёБђ ѓОєЖѕЇіїїИјАљЈњЗћЙќГ§Вў% џ ecl-16.1.2/contrib/encodings/DOS-CP437.BIN000066400000000000000000000020021266352375300175000ustar00rootroot00000000000000  !!""##$$%%&&''(())**++,,--..//00112233445566778899::;;<<==>>??@@AABBCCDDEEFFGGHHIIJJKKLLMMNNOOPPQQRRSSTTUUVVWWXXYYZZ[[\\]]^^__``aabbccddeeffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~€Чќ‚щƒт„ф…р†х‡чˆъ‰ыŠш‹яŒюьŽФХЩ‘ц’Ц“є”і•ђ–ћ—љ˜џ™жšм›ЂœЃЅž ЇŸ’ сЁэЂѓЃњЄёЅбІЊЇКЈПЉ#ЊЌЋНЌМ­ЁЎЋЏЛА%‘Б%’В%“Г%Д%$Е%aЖ%bЗ%VИ%UЙ%cК%QЛ%WМ%]Н%\О%[П%Р%С%4Т%,У%Ф%Х%<Ц%^Ч%_Ш%ZЩ%TЪ%iЫ%fЬ%`Э%PЮ%lЯ%gа%hб%dв%eг%Yд%Xе%Rж%Sз%kи%jй%к% л%ˆм%„н%Œо%п%€рБспт“уРфЃхУцЕчФшІщ˜ъЉыДь"эЦюЕя")№"aёБђ"eѓ"dє# ѕ#!іїї"HјАљ"њЗћ"ќ §Вў% џ ecl-16.1.2/contrib/encodings/DOS-CP737.BIN000066400000000000000000000020021266352375300175030ustar00rootroot00000000000000  !!""##$$%%&&''(())**++,,--..//00112233445566778899::;;<<==>>??@@AABBCCDDEEFFGGHHIIJJKKLLMMNNOOPPQQRRSSTTUUVVWWXXYYZZ[[\\]]^^__``aabbccddeeffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~€‘’‚“ƒ”„•…–†—‡˜ˆ™‰šŠ›‹œŒžŽŸ Ё‘Ѓ’Є“Ѕ”І•Ї–Ј—Љ˜Б™ВšГ›ДœЕЖžЗŸИ ЙЁКЂЛЃМЄНЅОІПЇРЈСЉУЊТЋФЌХ­ЦЎЧЏША%‘Б%’В%“Г%Д%$Е%aЖ%bЗ%VИ%UЙ%cК%QЛ%WМ%]Н%\О%[П%Р%С%4Т%,У%Ф%Х%<Ц%^Ч%_Ш%ZЩ%TЪ%iЫ%fЬ%`Э%PЮ%lЯ%gа%hб%dв%eг%Yд%Xе%Rж%Sз%kи%jй%к% л%ˆм%„н%Œо%п%€рЩсЌт­уЎфЪхЏцЬчЭшЫщЮъ†ыˆь‰эŠюŒяŽ№ёБђ"eѓ"dєЊѕЋіїї"HјАљ"њЗћ"ќ §Вў% џ ecl-16.1.2/contrib/encodings/DOS-CP775.BIN000066400000000000000000000020021266352375300175050ustar00rootroot00000000000000  !!""##$$%%&&''(())**++,,--..//00112233445566778899::;;<<==>>??@@AABBCCDDEEFFGGHHIIJJKKLLMMNNOOPPQQRRSSTTUUVVWWXXYYZZ[[\\]]^^__``aabbccddeeffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~€ќ‚щƒ„ф…#†х‡ˆB‰ŠV‹WŒ+yŽФХЩ‘ц’Ц“M”і•"–Ђ—Z˜[™жšм›јœЃиžзŸЄ Ё*ЂѓЃ{Є|ЅzІ ЇІЈЉЉЎЊЌЋНЌМ­AЎЋЏЛА%‘Б%’В%“Г%Д%$ЕЖ ЗИЙ%cК%QЛ%WМ%]Н.О`П%Р%С%4Т%,У%Ф%Х%<ЦrЧjШ%ZЩ%TЪ%iЫ%fЬ%`Э%PЮ%lЯ}аб вгд/еaжsзkи~й%к% л%ˆм%„н%Œо%п%€ргсптLуCфѕхецЕчDш6щ7ъ;ы<ьFэюEя №­ёБђ ѓОєЖѕЇіїї јАљ"њЗћЙќГ§Вў% џ ecl-16.1.2/contrib/encodings/DOS-CP850.BIN000066400000000000000000000020021266352375300174770ustar00rootroot00000000000000  !!""##$$%%&&''(())**++,,--..//00112233445566778899::;;<<==>>??@@AABBCCDDEEFFGGHHIIJJKKLLMMNNOOPPQQRRSSTTUUVVWWXXYYZZ[[\\]]^^__``aabbccddeeffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~€Чќ‚щƒт„ф…р†х‡чˆъ‰ыŠш‹яŒюьŽФХЩ‘ц’Ц“є”і•ђ–ћ—љ˜џ™жšм›јœЃиžзŸ’ сЁэЂѓЃњЄёЅбІЊЇКЈПЉЎЊЌЋНЌМ­ЁЎЋЏЛА%‘Б%’В%“Г%Д%$ЕСЖТЗРИЉЙ%cК%QЛ%WМ%]НЂОЅП%Р%С%4Т%,У%Ф%Х%<ЦуЧУШ%ZЩ%TЪ%iЫ%fЬ%`Э%PЮ%lЯЄа№бавЪгЫдШе1жЭзЮиЯй%к% л%ˆм%„нІоЬп%€ргсптдувфѕхецЕчўшощкълыйь§энюЏяД№­ёБђ ѓОєЖѕЇіїїИјАљЈњЗћЙќГ§Вў% џ ecl-16.1.2/contrib/encodings/DOS-CP852.BIN000066400000000000000000000020021266352375300175010ustar00rootroot00000000000000  !!""##$$%%&&''(())**++,,--..//00112233445566778899::;;<<==>>??@@AABBCCDDEEFFGGHHIIJJKKLLMMNNOOPPQQRRSSTTUUVVWWXXYYZZ[[\\]]^^__``aabbccddeeffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~€Чќ‚щƒт„ф…o†‡чˆB‰ыŠP‹QŒюyŽФЩ‘9’:“є”і•=–>—Z˜[™жšм›dœeAžзŸ  сЁэЂѓЃњЄЅІ}Ї~ЈЉЊЌЋzЌ ­_ЎЋЏЛА%‘Б%’В%“Г%Д%$ЕСЖТЗИ^Й%cК%QЛ%WМ%]Н{О|П%Р%С%4Т%,У%Ф%Х%<ЦЧШ%ZЩ%TЪ%iЫ%fЬ%`Э%PЮ%lЯЄабвгЫдеGжЭзЮий%к% л%ˆм%„нbоnп%€ргсптдуCфDхHц`чaшTщкъUыpь§энюcяД№­ёнђлѓЧєиѕЇіїїИјАљЈњйћqќX§Yў% џ ecl-16.1.2/contrib/encodings/DOS-CP855.BIN000066400000000000000000000020021266352375300175040ustar00rootroot00000000000000  !!""##$$%%&&''(())**++,,--..//00112233445566778899::;;<<==>>??@@AABBCCDDEEFFGGHHIIJJKKLLMMNNOOPPQQRRSSTTUUVVWWXXYYZZ[[\\]]^^__``aabbccddeeffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~€R‚Sƒ„Q…†T‡ˆU‰ŠV‹ŒWŽXY‘ ’Z“ ”[• –\— ˜^™š_›œN.žJŸ* 0ЁЂ1ЃЄFЅ&І4ЇЈ5ЉЊDЋ$Ќ3­ЎЋЏЛА%‘Б%’В%“Г%Д%$ЕEЖ%З8ИЙ%cК%QЛ%WМ%]Н9ОП%Р%С%4Т%,У%Ф%Х%<Ц:ЧШ%ZЩ%TЪ%iЫ%fЬ%`Э%PЮ%lЯЄа;бв<гд=еж>зи?й%к% л%ˆм%„ноOп%€р/с@т уAф!хBц"чCш#щ6ъы2ьэLю,я!№­ёKђ+ѓ7єѕHі(їMј-љIњ)ћGќ'§Їў% џ ecl-16.1.2/contrib/encodings/DOS-CP857.BIN000066400000000000000000000017661266352375300175260ustar00rootroot00000000000000њ  !!""##$$%%&&''(())**++,,--..//00112233445566778899::;;<<==>>??@@AABBCCDDEEFFGGHHIIJJKKLLMMNNOOPPQQRRSSTTUUVVWWXXYYZZ[[\\]]^^__``aabbccddeeffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~€Чќ‚щƒт„ф…р†х‡чˆъ‰ыŠш‹яŒю1ŽФХЩ‘ц’Ц“є”і•ђ–ћ—љ˜0™жšм›јœЃиž^Ÿ_ сЁэЂѓЃњЄёЅбІЇЈПЉЎЊЌЋНЌМ­ЁЎЋЏЛА%‘Б%’В%“Г%Д%$ЕСЖТЗРИЉЙ%cК%QЛ%WМ%]НЂОЅП%Р%С%4Т%,У%Ф%Х%<ЦуЧУШ%ZЩ%TЪ%iЫ%fЬ%`Э%PЮ%lЯЄаКбЊвЪгЫдШжЭзЮиЯй%к% л%ˆм%„нІоЬп%€ргсптдувфѕхецЕшзщкълыйььэџюЏяД№­ёБѓОєЖѕЇіїїИјАљЈњЗћЙќГ§Вў% џ ecl-16.1.2/contrib/encodings/DOS-CP860.BIN000066400000000000000000000020021266352375300175000ustar00rootroot00000000000000  !!""##$$%%&&''(())**++,,--..//00112233445566778899::;;<<==>>??@@AABBCCDDEEFFGGHHIIJJKKLLMMNNOOPPQQRRSSTTUUVVWWXXYYZZ[[\\]]^^__``aabbccddeeffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~€Чќ‚щƒт„у…р†С‡чˆъ‰ЪŠш‹ЭŒдьŽУТЩ‘Р’Ш“є”ѕ•ђ–к—љ˜Ь™еšм›ЂœЃйž ЇŸг сЁэЂѓЃњЄёЅбІЊЇКЈПЉвЊЌЋНЌМ­ЁЎЋЏЛА%‘Б%’В%“Г%Д%$Е%aЖ%bЗ%VИ%UЙ%cК%QЛ%WМ%]Н%\О%[П%Р%С%4Т%,У%Ф%Х%<Ц%^Ч%_Ш%ZЩ%TЪ%iЫ%fЬ%`Э%PЮ%lЯ%gа%hб%dв%eг%Yд%Xе%Rж%Sз%kи%jй%к% л%ˆм%„н%Œо%п%€рБспт“уРфЃхУцЕчФшІщ˜ъЉыДь"эЦюЕя")№"aёБђ"eѓ"dє# ѕ#!іїї"HјАљ"њЗћ"ќ §Вў% џ ecl-16.1.2/contrib/encodings/DOS-CP861.BIN000066400000000000000000000020021266352375300175010ustar00rootroot00000000000000  !!""##$$%%&&''(())**++,,--..//00112233445566778899::;;<<==>>??@@AABBCCDDEEFFGGHHIIJJKKLLMMNNOOPPQQRRSSTTUUVVWWXXYYZZ[[\\]]^^__``aabbccddeeffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~€Чќ‚щƒт„ф…р†х‡чˆъ‰ыŠш‹аŒ№оŽФХЩ‘ц’Ц“є”і•ў–ћ—н˜§™жšм›јœЃиž ЇŸ’ сЁэЂѓЃњЄСЅЭІгЇкЈПЉ#ЊЌЋНЌМ­ЁЎЋЏЛА%‘Б%’В%“Г%Д%$Е%aЖ%bЗ%VИ%UЙ%cК%QЛ%WМ%]Н%\О%[П%Р%С%4Т%,У%Ф%Х%<Ц%^Ч%_Ш%ZЩ%TЪ%iЫ%fЬ%`Э%PЮ%lЯ%gа%hб%dв%eг%Yд%Xе%Rж%Sз%kи%jй%к% л%ˆм%„н%Œо%п%€рБспт“уРфЃхУцЕчФшІщ˜ъЉыДь"эЦюЕя")№"aёБђ"eѓ"dє# ѕ#!іїї"HјАљ"њЗћ"ќ §Вў% џ ecl-16.1.2/contrib/encodings/DOS-CP862.BIN000066400000000000000000000020021266352375300175020ustar00rootroot00000000000000  !!""##$$%%&&''(())**++,,--..//00112233445566778899::;;<<==>>??@@AABBCCDDEEFFGGHHIIJJKKLLMMNNOOPPQQRRSSTTUUVVWWXXYYZZ[[\\]]^^__``aabbccddeeffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~€аб‚вƒг„д…е†ж‡зˆи‰йŠк‹лŒмнŽопр‘с’т“у”ф•х–ц—ч˜ш™щšъ›ЂœЃЅž ЇŸ’ сЁэЂѓЃњЄёЅбІЊЇКЈПЉ#ЊЌЋНЌМ­ЁЎЋЏЛА%‘Б%’В%“Г%Д%$Е%aЖ%bЗ%VИ%UЙ%cК%QЛ%WМ%]Н%\О%[П%Р%С%4Т%,У%Ф%Х%<Ц%^Ч%_Ш%ZЩ%TЪ%iЫ%fЬ%`Э%PЮ%lЯ%gа%hб%dв%eг%Yд%Xе%Rж%Sз%kи%jй%к% л%ˆм%„н%Œо%п%€рБспт“уРфЃхУцЕчФшІщ˜ъЉыДь"эЦюЕя")№"aёБђ"eѓ"dє# ѕ#!іїї"HјАљ"њЗћ"ќ §Вў% џ ecl-16.1.2/contrib/encodings/DOS-CP863.BIN000066400000000000000000000020021266352375300175030ustar00rootroot00000000000000  !!""##$$%%&&''(())**++,,--..//00112233445566778899::;;<<==>>??@@AABBCCDDEEFFGGHHIIJJKKLLMMNNOOPPQQRRSSTTUUVVWWXXYYZZ[[\\]]^^__``aabbccddeeffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~€Чќ‚щƒт„Т…р†Ж‡чˆъ‰ыŠш‹яŒю ŽРЇЩ‘Ш’Ъ“є”Ы•Я–ћ—љ˜Є™дšм›ЂœЃйžлŸ’ ІЁДЂѓЃњЄЈЅИІГЇЏЈЮЉ#ЊЌЋНЌМ­ОЎЋЏЛА%‘Б%’В%“Г%Д%$Е%aЖ%bЗ%VИ%UЙ%cК%QЛ%WМ%]Н%\О%[П%Р%С%4Т%,У%Ф%Х%<Ц%^Ч%_Ш%ZЩ%TЪ%iЫ%fЬ%`Э%PЮ%lЯ%gа%hб%dв%eг%Yд%Xе%Rж%Sз%kи%jй%к% л%ˆм%„н%Œо%п%€рБспт“уРфЃхУцЕчФшІщ˜ъЉыДь"эЦюЕя")№"aёБђ"eѓ"dє# ѕ#!іїї"HјАљ"њЗћ"ќ §Вў% џ ecl-16.1.2/contrib/encodings/DOS-CP864.BIN000066400000000000000000000017521266352375300175170ustar00rootroot00000000000000є  !!""##$$%j&&''(())**++,,--..//00112233445566778899::;;<<==>>??@@AABBCCDDEEFFGGHHIIJJKKLLMMNNOOPPQQRRSSTTUUVVWWXXYYZZ[[\\]]^^__``aabbccddeeffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~€АЗ‚"ƒ"„%’…%†%‡%<ˆ%$‰%,Š%‹%4Œ%% Ž%%В‘"’Ц“Б”Н•М–"H—Ћ˜Л™ўїšўјўћžўќ  Ё­Ђў‚ЃЃЄЄЅў„ЈўŽЉўЊў•Ћў™Ќ ­ўЎўЁЏўЅА`БaВbГcДdЕeЖfЗgИhЙiКўбЛМўБНўЕОўЙПРЂСў€ТўУўƒФў…ХўЪЦў‹ЧўШў‘Щў“Ъў—Ыў›ЬўŸЭўЃЮўЇЯўЉаўЋбў­вўЏгўГдўЗеўЛжўПзўСиўХйўЫкўЯлІмЌнїозпўЩр@сўгтўзуўлфўпхўуцўччўышўэщўяъўѓыўНьўЬэўЮюўЭяўс№ў}ёQђўхѓўщєўьѕў№іўђїўајўељўѕњўіћўнќўй§ўёў% ecl-16.1.2/contrib/encodings/DOS-CP865.BIN000066400000000000000000000020021266352375300175050ustar00rootroot00000000000000  !!""##$$%%&&''(())**++,,--..//00112233445566778899::;;<<==>>??@@AABBCCDDEEFFGGHHIIJJKKLLMMNNOOPPQQRRSSTTUUVVWWXXYYZZ[[\\]]^^__``aabbccddeeffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~€Чќ‚щƒт„ф…р†х‡чˆъ‰ыŠш‹яŒюьŽФХЩ‘ц’Ц“є”і•ђ–ћ—љ˜џ™жšм›јœЃиž ЇŸ’ сЁэЂѓЃњЄёЅбІЊЇКЈПЉ#ЊЌЋНЌМ­ЁЎЋЏЄА%‘Б%’В%“Г%Д%$Е%aЖ%bЗ%VИ%UЙ%cК%QЛ%WМ%]Н%\О%[П%Р%С%4Т%,У%Ф%Х%<Ц%^Ч%_Ш%ZЩ%TЪ%iЫ%fЬ%`Э%PЮ%lЯ%gа%hб%dв%eг%Yд%Xе%Rж%Sз%kи%jй%к% л%ˆм%„н%Œо%п%€рБспт“уРфЃхУцЕчФшІщ˜ъЉыДь"эЦюЕя")№"aёБђ"eѓ"dє# ѕ#!іїї"HјАљ"њЗћ"ќ §Вў% џ ecl-16.1.2/contrib/encodings/DOS-CP866.BIN000066400000000000000000000020021266352375300175060ustar00rootroot00000000000000  !!""##$$%%&&''(())**++,,--..//00112233445566778899::;;<<==>>??@@AABBCCDDEEFFGGHHIIJJKKLLMMNNOOPPQQRRSSTTUUVVWWXXYYZZ[[\\]]^^__``aabbccddeeffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~€‚ƒ„…†‡ˆ‰Š‹ŒŽ ‘!’"“#”$•%–&—'˜(™)š*›+œ,-ž.Ÿ/ 0Ё1Ђ2Ѓ3Є4Ѕ5І6Ї7Ј8Љ9Њ:Ћ;Ќ<­=Ў>Џ?А%‘Б%’В%“Г%Д%$Е%aЖ%bЗ%VИ%UЙ%cК%QЛ%WМ%]Н%\О%[П%Р%С%4Т%,У%Ф%Х%<Ц%^Ч%_Ш%ZЩ%TЪ%iЫ%fЬ%`Э%PЮ%lЯ%gа%hб%dв%eг%Yд%Xе%Rж%Sз%kи%jй%к% л%ˆм%„н%Œо%п%€р@сAтBуCфDхEцFчGшHщIъJыKьLэMюNяO№ёQђѓTєѕWії^јАљ"њЗћ"ќ!§Єў% џ ecl-16.1.2/contrib/encodings/DOS-CP869.BIN000066400000000000000000000017361266352375300175260ustar00rootroot00000000000000ю  !!""##$$%%&&''(())**++,,--..//00112233445566778899::;;<<==>>??@@AABBCCDDEEFFGGHHIIJJKKLLMMNNOOPPQQRRSSTTUUVVWWXXYYZZ[[\\]]^^__``aabbccddeeffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~††ˆЗ‰ЌŠІ‹ Œ ˆŽ ‰Š‘Њ’Œ•Ž–Ћ—Љ˜™ВšГ›ЌœЃ­žЎŸЏ ЪЁЂЬЃЭЄ‘Ѕ’І“Ї”Ј•Љ–Њ—ЋНЌ˜­™ЎЋЏЛА%‘Б%’В%“Г%Д%$ЕšЖ›ЗœИЙ%cК%QЛ%WМ%]НžОŸП%Р%С%4Т%,У%Ф%Х%<Ц ЧЁШ%ZЩ%TЪ%iЫ%fЬ%`Э%PЮ%lЯЃаЄбЅвІгЇдЈеЉжБзВиГй%к% л%ˆм%„нДоЕп%€рЖсЗтИуЙфКхЛцМчНшОщПъРыСьУэТюФя„№­ёБђХѓЦєЧѕЇіШї…јАљЈњЩћЫќА§Юў% џ ecl-16.1.2/contrib/encodings/DOS-CP874.BIN000066400000000000000000000016061266352375300175160ustar00rootroot00000000000000Т  !!""##$$%%&&''(())**++,,--..//00112233445566778899::;;<<==>>??@@AABBCCDDEEFFGGHHIIJJKKLLMMNNOOPPQQRRSSTTUUVVWWXXYYZZ[[\\]]^^__``aabbccddeeffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~€ Ќ… &‘ ’ “ ” • "– —   ЁЂЃЄЅІЇЈЉ Њ Ћ Ќ ­ ЎЏАБВГДЕЖЗИЙКЛМНОПР С!Т"У#Ф$Х%Ц&Ч'Ш(Щ)Ъ*Ы+Ь,Э-Ю.Я/а0б1в2г3д4е5ж6з7и8й9к:п?р@сAтBуCфDхEцFчGшHщIъJыKьLэMюNяO№PёQђRѓSєTѕUіVїWјXљYњZћ[ecl-16.1.2/contrib/encodings/ISO-2022-JP000066400000000000000000000035321266352375300172430ustar00rootroot00000000000000(cl:unless (cl:find-package :ISO-2022-JP) (make-package :ISO-2022-JP)) (in-package :ISO-2022-JP) (defun compose (bytes) (loop for i in bytes with cum = 0 do (setf cum (+ (ash cum 8) i)) finally (return cum))) (defun mapping-hash-table (sequence &optional (mask 0)) (loop with hash = (make-hash-table :size (floor (* 1.5 (length sequence))) :test 'eq) for i from 0 below (length sequence) by 2 for multibyte = (elt sequence i) for codepoint = (elt sequence (1+ i)) for unicode-char = (code-char codepoint) when (zerop (logand multibyte mask)) do (progn (setf (gethash multibyte hash) unicode-char) (setf (gethash unicode-char hash) multibyte) (when (> multibyte #xFF) (setf (gethash (ash multibyte -8) hash) t))) finally (return hash))) (defun multimap (escapes tables) (loop for seq in escapes for table in tables for table-cons = (member table tables :test 'eq) do (progn ;; Change escape sequence into byte codes (setf seq (mapcar #'char-code seq)) ;; Store it in the hash table (setf (gethash t table) seq) (loop for other-table in tables do (loop for i from 1 for precedings = (butlast seq i) while precedings do (setf (gethash (compose precedings) other-table) t) finally (setf (gethash (compose seq) other-table) table-cons))))) (nconc tables tables)) (defparameter ext::iso-2022-jp (let* ((ascii-no-esc (mapping-hash-table (loop for i from 0 to 127 unless (= i (char-code #\esc)) nconc (list i i)))) (jis208 (mapping-hash-table (ext::load-encoding :jisx0208) #x8080)) (jis201 (mapping-hash-table (ext::load-encoding :jisx0201) #x80))) (multimap '((#\Esc #\( #\B) (#\Esc #\( #\J) (#\Esc #\$ #\@) (#\Esc #\$ #\B)) (list ascii-no-esc jis201 jis208 jis208)))) (delete-package :ISO-2022-JP) ecl-16.1.2/contrib/encodings/ISO-2022-JP-1000066400000000000000000000037071266352375300174050ustar00rootroot00000000000000(cl:unless (cl:find-package :ISO-2022-JP-1) (make-package :ISO-2022-JP-1)) (in-package :ISO-2022-JP-1) (defun compose (bytes) (loop for i in bytes with cum = 0 do (setf cum (+ (ash cum 8) i)) finally (return cum))) (defun mapping-hash-table (sequence &optional (mask 0)) (loop with hash = (make-hash-table :size (floor (* 1.5 (length sequence))) :test 'eq) for i from 0 below (length sequence) by 2 for multibyte = (elt sequence i) for codepoint = (elt sequence (1+ i)) for unicode-char = (code-char codepoint) when (zerop (logand multibyte mask)) do (progn (setf (gethash multibyte hash) unicode-char) (setf (gethash unicode-char hash) multibyte) (when (> multibyte #xFF) (setf (gethash (ash multibyte -8) hash) t))) finally (return hash))) (defun multimap (escapes tables) (loop for seq in escapes for table in tables for table-cons = (member table tables :test 'eq) do (progn ;; Change escape sequence into byte codes (setf seq (mapcar #'char-code seq)) ;; Store it in the hash table (setf (gethash t table) seq) (loop for other-table in tables do (loop for i from 1 for precedings = (butlast seq i) while precedings do (setf (gethash (compose precedings) other-table) t) finally (setf (gethash (compose seq) other-table) table-cons))))) (nconc tables tables)) (defparameter ext::iso-2022-jp-1 (let* ((ascii-no-esc (mapping-hash-table (loop for i from 0 to 127 unless (= i (char-code #\esc)) nconc (list i i)))) (jis212 (mapping-hash-table (ext::load-encoding :jisx0212) #x8080)) (jis208 (mapping-hash-table (ext::load-encoding :jisx0208) #x8080)) (jis201 (mapping-hash-table (ext::load-encoding :jisx0201) #x80))) (multimap '((#\Esc #\( #\B) (#\Esc #\( #\J) (#\Esc #\$ #\@) (#\Esc #\$ #\B) (#\Esc #\$ #\( #\D)) (list ascii-no-esc jis201 jis208 jis208 jis212)))) (delete-package :ISO-2022-JP-1) ecl-16.1.2/contrib/encodings/ISO-8859-1.BIN000066400000000000000000000020021266352375300175200ustar00rootroot00000000000000  !!""##$$%%&&''(())**++,,--..//00112233445566778899::;;<<==>>??@@AABBCCDDEEFFGGHHIIJJKKLLMMNNOOPPQQRRSSTTUUVVWWXXYYZZ[[\\]]^^__``aabbccddeeffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~€€‚‚ƒƒ„„……††‡‡ˆˆ‰‰ŠŠ‹‹ŒŒŽŽ‘‘’’““””••––——˜˜™™šš››œœžžŸŸ  ЁЁЂЂЃЃЄЄЅЅІІЇЇЈЈЉЉЊЊЋЋЌЌ­­ЎЎЏЏААББВВГГДДЕЕЖЖЗЗИИЙЙККЛЛММННООППРРССТТУУФФХХЦЦЧЧШШЩЩЪЪЫЫЬЬЭЭЮЮЯЯааббввггддеежжззииййккллммннооппррссттууффххццччшшщщъъыыььээююяя№№ёёђђѓѓєєѕѕііїїјјљљњњћћќќ§§ўўџџecl-16.1.2/contrib/encodings/ISO-8859-10.BIN000066400000000000000000000020021266352375300176000ustar00rootroot00000000000000  !!""##$$%%&&''(())**++,,--..//00112233445566778899::;;<<==>>??@@AABBCCDDEEFFGGHHIIJJKKLLMMNNOOPPQQRRSSTTUUVVWWXXYYZZ[[\\]]^^__``aabbccddeeffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~€€‚‚ƒƒ„„……††‡‡ˆˆ‰‰ŠŠ‹‹ŒŒŽŽ‘‘’’““””••––——˜˜™™šš››œœžžŸŸ  ЁЂЃ"Є*Ѕ(І6ЇЇЈ;ЉЊ`ЋfЌ}­­ЎjЏJААБВГ#Д+Е)Ж7ЗЗИ<ЙКaЛgМ~Н ОkПKРССТТУУФФХХЦЦЧ.Ш ЩЩЪЫЫЬЭЭЮЮЯЯаабEвLггддеежжзhиийrккллммннооппрссттууффххццч/ш щщъыыьээююяя№№ёFђMѓѓєєѕѕііїiјјљsњњћћќќ§§ўўџ8ecl-16.1.2/contrib/encodings/ISO-8859-11.BIN000066400000000000000000000017421266352375300176130ustar00rootroot00000000000000№  !!""##$$%%&&''(())**++,,--..//00112233445566778899::;;<<==>>??@@AABBCCDDEEFFGGHHIIJJKKLLMMNNOOPPQQRRSSTTUUVVWWXXYYZZ[[\\]]^^__``aabbccddeeffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~€€‚‚ƒƒ„„……††‡‡ˆˆ‰‰ŠŠ‹‹ŒŒŽŽ‘‘’’““””••––——˜˜™™šš››œœžžŸŸ  ЁЂЃЄЅІЇЈЉ Њ Ћ Ќ ­ ЎЏАБВГДЕЖЗИЙКЛМНОПР С!Т"У#Ф$Х%Ц&Ч'Ш(Щ)Ъ*Ы+Ь,Э-Ю.Я/а0б1в2г3д4е5ж6з7и8й9к:п?р@сAтBуCфDхEцFчGшHщIъJыKьLэMюNяO№PёQђRѓSєTѕUіVїWјXљYњZћ[ecl-16.1.2/contrib/encodings/ISO-8859-13.BIN000066400000000000000000000020021266352375300176030ustar00rootroot00000000000000  !!""##$$%%&&''(())**++,,--..//00112233445566778899::;;<<==>>??@@AABBCCDDEEFFGGHHIIJJKKLLMMNNOOPPQQRRSSTTUUVVWWXXYYZZ[[\\]]^^__``aabbccddeeffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~€€‚‚ƒƒ„„……††‡‡ˆˆ‰‰ŠŠ‹‹ŒŒŽŽ‘‘’’““””••––——˜˜™™šš››œœžžŸŸ  Ё ЂЂЃЃЄЄЅ ІІЇЇЈиЉЉЊVЋЋЌЌ­­ЎЎЏЦААББВВГГД ЕЕЖЖЗЗИјЙЙКWЛЛММННООПцРС.ТУФФХХЦЧШ ЩЩЪyЫЬ"Э6Ю*Я;а`бCвEггдLеежжззиrйAкZлjммн{о}ппрс/туффххцчш щщъzыь#э7ю+я<№aёDђFѓѓєMѕѕііїїјsљBњ[ћkќќ§|ў~џ ecl-16.1.2/contrib/encodings/ISO-8859-14.BIN000066400000000000000000000020021266352375300176040ustar00rootroot00000000000000  !!""##$$%%&&''(())**++,,--..//00112233445566778899::;;<<==>>??@@AABBCCDDEEFFGGHHIIJJKKLLMMNNOOPPQQRRSSTTUUVVWWXXYYZZ[[\\]]^^__``aabbccddeeffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~€€‚‚ƒƒ„„……††‡‡ˆˆ‰‰ŠŠ‹‹ŒŒŽŽ‘‘’’““””••––——˜˜™™šš››œœžžŸŸ  ЁЂЃЃЄ Ѕ І ЇЇЈ€ЉЉЊ‚Ћ Ќђ­­ЎЎЏxАБВ Г!Д@ЕAЖЖЗVИЙWКƒЛ`МѓН„О…ПaРРССТТУУФФХХЦЦЧЧШШЩЩЪЪЫЫЬЬЭЭЮЮЯЯаtббввггддеежжзjииййккллммнноvппррссттууффххццччшшщщъъыыььээююяя№uёёђђѓѓєєѕѕііїkјјљљњњћћќќ§§ўwџџecl-16.1.2/contrib/encodings/ISO-8859-15.BIN000066400000000000000000000020021266352375300176050ustar00rootroot00000000000000  !!""##$$%%&&''(())**++,,--..//00112233445566778899::;;<<==>>??@@AABBCCDDEEFFGGHHIIJJKKLLMMNNOOPPQQRRSSTTUUVVWWXXYYZZ[[\\]]^^__``aabbccddeeffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~€€‚‚ƒƒ„„……††‡‡ˆˆ‰‰ŠŠ‹‹ŒŒŽŽ‘‘’’““””••––——˜˜™™šš››œœžžŸŸ  ЁЁЂЂЃЃЄ ЌЅЅІ`ЇЇЈaЉЉЊЊЋЋЌЌ­­ЎЎЏЏААББВВГГД}ЕЕЖЖЗЗИ~ЙЙККЛЛМRНSОxППРРССТТУУФФХХЦЦЧЧШШЩЩЪЪЫЫЬЬЭЭЮЮЯЯааббввггддеежжззииййккллммннооппррссттууффххццччшшщщъъыыььээююяя№№ёёђђѓѓєєѕѕііїїјјљљњњћћќќ§§ўўџџecl-16.1.2/contrib/encodings/ISO-8859-16.BIN000066400000000000000000000020021266352375300176060ustar00rootroot00000000000000  !!""##$$%%&&''(())**++,,--..//00112233445566778899::;;<<==>>??@@AABBCCDDEEFFGGHHIIJJKKLLMMNNOOPPQQRRSSTTUUVVWWXXYYZZ[[\\]]^^__``aabbccddeeffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~€€‚‚ƒƒ„„……††‡‡ˆˆ‰‰ŠŠ‹‹ŒŒŽŽ‘‘’’““””••––——˜˜™™šš››œœžžŸŸ  ЁЂЃAЄ ЌЅ І`ЇЇЈaЉЉЊЋЋЌy­­ЎzЏ{ААББВ ГBД}Е ЖЖЗЗИ~Й КЛЛМRНSОxП|РРССТТУФФХЦЦЧЧШШЩЩЪЪЫЫЬЬЭЭЮЮЯЯабCввггддеPжжзZиpййккллммноппррссттуффхццччшшщщъъыыььээююяя№ёDђђѓѓєєѕQіії[јqљљњњћћќќ§ўџџecl-16.1.2/contrib/encodings/ISO-8859-2.BIN000066400000000000000000000020021266352375300175210ustar00rootroot00000000000000  !!""##$$%%&&''(())**++,,--..//00112233445566778899::;;<<==>>??@@AABBCCDDEEFFGGHHIIJJKKLLMMNNOOPPQQRRSSTTUUVVWWXXYYZZ[[\\]]^^__``aabbccddeeffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~€€‚‚ƒƒ„„……††‡‡ˆˆ‰‰ŠŠ‹‹ŒŒŽŽ‘‘’’““””••––——˜˜™™šš››œœžžŸŸ  ЁЂиЃAЄЄЅ=ІZЇЇЈЈЉ`Њ^ЋdЌy­­Ў}Џ{ААБВлГBДДЕ>Ж[ЗЧИИЙaК_ЛeМzНнО~П|РTССТТУФФХ9ЦЧЧШ ЩЩЪЫЫЬЭЭЮЮЯабCвGггддеPжжззиXйnкклpммнноbппрUссттуффх:цччш щщъыыьээююя№ёDђHѓѓєєѕQііїїјYљoњњћqќќ§§ўcџйecl-16.1.2/contrib/encodings/ISO-8859-3.BIN000066400000000000000000000017461266352375300175400ustar00rootroot00000000000000ђ  !!""##$$%%&&''(())**++,,--..//00112233445566778899::;;<<==>>??@@AABBCCDDEEFFGGHHIIJJKKLLMMNNOOPPQQRRSSTTUUVVWWXXYYZZ[[\\]]^^__``aabbccddeeffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~€€‚‚ƒƒ„„……††‡‡ˆˆ‰‰ŠŠ‹‹ŒŒŽŽ‘‘’’““””••––——˜˜™™šš››œœžžŸŸ  Ё&ЂиЃЃЄЄІ$ЇЇЈЈЉ0Њ^ЋЌ4­­Џ{ААБ'ВВГГДДЕЕЖ%ЗЗИИЙ1К_ЛМ5ННП|РРССТТФФХ ЦЧЧШШЩЩЪЪЫЫЬЬЭЭЮЮЯЯббввггдде жжззиййккллммнlо\ппррссттффх ц ччшшщщъъыыььээююяяёёђђѓѓєєѕ!ііїїјљљњњћћќќ§mў]џйecl-16.1.2/contrib/encodings/ISO-8859-4.BIN000066400000000000000000000020021266352375300175230ustar00rootroot00000000000000  !!""##$$%%&&''(())**++,,--..//00112233445566778899::;;<<==>>??@@AABBCCDDEEFFGGHHIIJJKKLLMMNNOOPPQQRRSSTTUUVVWWXXYYZZ[[\\]]^^__``aabbccddeeffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~€€‚‚ƒƒ„„……††‡‡ˆˆ‰‰ŠŠ‹‹ŒŒŽŽ‘‘’’““””••––——˜˜™™šš››œœžžŸŸ  ЁЂ8ЃVЄЄЅ(І;ЇЇЈЈЉ`ЊЋ"Ќf­­Ў}ЏЏААБВлГWДДЕ)Ж<ЗЧИИЙaКЛ#МgНJО~ПKРССТТУУФФХХЦЦЧ.Ш ЩЩЪЫЫЬЭЭЮЮЯ*абEвLг6ддеежжззиийrккллммнhоjппрссттууффххццч/ш щщъыыьээююя+№ёFђMѓ7єєѕѕііїїјјљsњњћћќќ§iўkџйecl-16.1.2/contrib/encodings/ISO-8859-5.BIN000066400000000000000000000020021266352375300175240ustar00rootroot00000000000000  !!""##$$%%&&''(())**++,,--..//00112233445566778899::;;<<==>>??@@AABBCCDDEEFFGGHHIIJJKKLLMMNNOOPPQQRRSSTTUUVVWWXXYYZZ[[\\]]^^__``aabbccddeeffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~€€‚‚ƒƒ„„……††‡‡ˆˆ‰‰ŠŠ‹‹ŒŒŽŽ‘‘’’““””••––——˜˜™™šš››œœžžŸŸ  ЁЂЃЄЅІЇЈЉ Њ Ћ Ќ ­­ЎЏАБВГДЕЖЗИЙКЛМНОПР С!Т"У#Ф$Х%Ц&Ч'Ш(Щ)Ъ*Ы+Ь,Э-Ю.Я/а0б1в2г3д4е5ж6з7и8й9к:л;м<н=о>п?р@сAтBуCфDхEцFчGшHщIъJыKьLэMюNяO№!ёQђRѓSєTѕUіVїWјXљYњZћ[ќ\§Їў^џ_ecl-16.1.2/contrib/encodings/ISO-8859-6.BIN000066400000000000000000000015161266352375300175360ustar00rootroot00000000000000І  !!""##$$%%&&''(())**++,,--..//00112233445566778899::;;<<==>>??@@AABBCCDDEEFFGGHHIIJJKKLLMMNNOOPPQQRRSSTTUUVVWWXXYYZZ[[\\]]^^__``aabbccddeeffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~€€‚‚ƒƒ„„……††‡‡ˆˆ‰‰ŠŠ‹‹ŒŒŽŽ‘‘’’““””••––——˜˜™™šš››œœžžŸŸ  ЄЄЌ ­­ЛПС!Т"У#Ф$Х%Ц&Ч'Ш(Щ)Ъ*Ы+Ь,Э-Ю.Я/а0б1в2г3д4е5ж6з7и8й9к:р@сAтBуCфDхEцFчGшHщIъJыKьLэMюNяO№PёQђRecl-16.1.2/contrib/encodings/ISO-8859-7.BIN000066400000000000000000000017661266352375300175460ustar00rootroot00000000000000њ  !!""##$$%%&&''(())**++,,--..//00112233445566778899::;;<<==>>??@@AABBCCDDEEFFGGHHIIJJKKLLMMNNOOPPQQRRSSTTUUVVWWXXYYZZ[[\\]]^^__``aabbccddeeffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~€€‚‚ƒƒ„„……††‡‡ˆˆ‰‰ŠŠ‹‹ŒŒŽŽ‘‘’’““””••––——˜˜™™šš››œœžžŸŸ  Ё Ђ ЃЃЄ ЌЅ ЏІІЇЇЈЈЉЉЊzЋЋЌЌ­­Џ ААББВВГГД„Е…Ж†ЗЗИˆЙ‰КŠЛЛМŒННОŽПРС‘Т’У“Ф”Х•Ц–Ч—Ш˜Щ™ЪšЫ›ЬœЭЮžЯŸа бЁгЃдЄеЅжІзЇиЈйЉкЊлЋмЌн­оЎпЏрАсБтВуГфДхЕцЖчЗшИщЙъКыЛьМэНюОяП№РёСђТѓУєФѕХіЦїЧјШљЩњЪћЫќЬ§ЭўЮecl-16.1.2/contrib/encodings/ISO-8859-8.BIN000066400000000000000000000015621266352375300175410ustar00rootroot00000000000000И  !!""##$$%%&&''(())**++,,--..//00112233445566778899::;;<<==>>??@@AABBCCDDEEFFGGHHIIJJKKLLMMNNOOPPQQRRSSTTUUVVWWXXYYZZ[[\\]]^^__``aabbccddeeffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~€€‚‚ƒƒ„„……††‡‡ˆˆ‰‰ŠŠ‹‹ŒŒŽŽ‘‘’’““””••––——˜˜™™šš››œœžžŸŸ  ЂЂЃЃЄЄЅЅІІЇЇЈЈЉЉЊзЋЋЌЌ­­ЎЎЏЏААББВВГГДДЕЕЖЖЗЗИИЙЙКїЛЛММННООп расбтвугфдхецжчзшищйъкыльмэнюояп№рёсђтѓуєфѕхіцїчјшљщњъ§ ў ecl-16.1.2/contrib/encodings/ISO-8859-9.BIN000066400000000000000000000020021266352375300175300ustar00rootroot00000000000000  !!""##$$%%&&''(())**++,,--..//00112233445566778899::;;<<==>>??@@AABBCCDDEEFFGGHHIIJJKKLLMMNNOOPPQQRRSSTTUUVVWWXXYYZZ[[\\]]^^__``aabbccddeeffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~€€‚‚ƒƒ„„……††‡‡ˆˆ‰‰ŠŠ‹‹ŒŒŽŽ‘‘’’““””••––——˜˜™™šš››œœžžŸŸ  ЁЁЂЂЃЃЄЄЅЅІІЇЇЈЈЉЉЊЊЋЋЌЌ­­ЎЎЏЏААББВВГГДДЕЕЖЖЗЗИИЙЙККЛЛММННООППРРССТТУУФФХХЦЦЧЧШШЩЩЪЪЫЫЬЬЭЭЮЮЯЯаббввггддеежжззииййккллммн0о^ппррссттууффххццччшшщщъъыыььээююяя№ёёђђѓѓєєѕѕііїїјјљљњњћћќќ§1ў_џџecl-16.1.2/contrib/encodings/JISX0201.BIN000066400000000000000000000011721266352375300174040ustar00rootroot00000000000000< !!""##$$%%&&''(())**++,,--..//00112233445566778899::;;<<==>>??@@AABBCCDDEEFFGGHHIIJJKKLLMMNNOOPPQQRRSSTTUUVVWWXXYYZZ[[\Ѕ]]^^__``aabbccddeeffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~ >ЁџaЂџbЃџcЄџdЅџeІџfЇџgЈџhЉџiЊџjЋџkЌџl­џmЎџnЏџoАџpБџqВџrГџsДџtЕџuЖџvЗџwИџxЙџyКџzЛџ{Мџ|Нџ}Оџ~ПџРџ€СџТџ‚УџƒФџ„Хџ…Цџ†Чџ‡ШџˆЩџ‰ЪџŠЫџ‹ЬџŒЭџЮџŽЯџаџбџ‘вџ’гџ“дџ”еџ•жџ–зџ—иџ˜йџ™кџšлџ›мџœнџоџžпџŸecl-16.1.2/contrib/encodings/JISX0208.BIN000066400000000000000000000655761266352375300174350ustar00rootroot000000000000005О!!0!"0!#0!$џ !%џ!&0ћ!'џ!(џ!)џ!*џ!+0›!,0œ!-Д!.џ@!/Ј!0џ>!1џу!2џ?!30§!40ў!50!60ž!70!8Nн!90!:0!;0!<0ќ!= !> !?џ!@џ"‚"?"ƒ"@"*"A")"J"'"K"("LЌ"M!в"N!д"O""P""\" "]"Ѕ"^#"_""`""a"a"b"R"c"j"d"k"e""f"="g""h"5"i"+"j","r!+"s 0"t&o"u&m"v&j"w "x !"yЖ"~%я#0џ#1џ#2џ#3џ#4џ#5џ#6џ#7џ#8џ#9џ#Aџ!#Bџ"#Cџ##Dџ$#Eџ%#Fџ&#Gџ'#Hџ(#Iџ)#Jџ*#Kџ+#Lџ,#Mџ-#Nџ.#Oџ/#Pџ0#Qџ1#Rџ2#Sџ3#Tџ4#Uџ5#Vџ6#Wџ7#Xџ8#Yџ9#Zџ:#aџA#bџB#cџC#dџD#eџE#fџF#gџG#hџH#iџI#jџJ#kџK#lџL#mџM#nџN#oџO#pџP#qџQ#rџR#sџS#tџT#uџU#vџV#wџW#xџX#yџY#zџZ$!0A$"0B$#0C$$0D$%0E$&0F$'0G$(0H$)0I$*0J$+0K$,0L$-0M$.0N$/0O$00P$10Q$20R$30S$40T$50U$60V$70W$80X$90Y$:0Z$;0[$<0\$=0]$>0^$?0_$@0`$A0a$B0b$C0c$D0d$E0e$F0f$G0g$H0h$I0i$J0j$K0k$L0l$M0m$N0n$O0o$P0p$Q0q$R0r$S0s$T0t$U0u$V0v$W0w$X0x$Y0y$Z0z$[0{$\0|$]0}$^0~$_0$`0€$a0$b0‚$c0ƒ$d0„$e0…$f0†$g0‡$h0ˆ$i0‰$j0Š$k0‹$l0Œ$m0$n0Ž$o0$p0$q0‘$r0’$s0“%!0Ё%"0Ђ%#0Ѓ%$0Є%%0Ѕ%&0І%'0Ї%(0Ј%)0Љ%*0Њ%+0Ћ%,0Ќ%-0­%.0Ў%/0Џ%00А%10Б%20В%30Г%40Д%50Е%60Ж%70З%80И%90Й%:0К%;0Л%<0М%=0Н%>0О%?0П%@0Р%A0С%B0Т%C0У%D0Ф%E0Х%F0Ц%G0Ч%H0Ш%I0Щ%J0Ъ%K0Ы%L0Ь%M0Э%N0Ю%O0Я%P0а%Q0б%R0в%S0г%T0д%U0е%V0ж%W0з%X0и%Y0й%Z0к%[0л%\0м%]0н%^0о%_0п%`0р%a0с%b0т%c0у%d0ф%e0х%f0ц%g0ч%h0ш%i0щ%j0ъ%k0ы%l0ь%m0э%n0ю%o0я%p0№%q0ё%r0ђ%s0ѓ%t0є%u0ѕ%v0і&!‘&"’&#“&$”&%•&&–&'—&(˜&)™&*š&+›&,œ&-&.ž&/Ÿ&0 &1Ё&2Ѓ&3Є&4Ѕ&5І&6Ї&7Ј&8Љ&AБ&BВ&CГ&DД&EЕ&FЖ&GЗ&HИ&IЙ&JК&KЛ&LМ&MН&NО&OП&PР&QС&RУ&SФ&TХ&UЦ&VЧ&WШ&XЩ'!'"'#'$'%'&'''(')'*'+','-'.'/'0'1'2 '3!'4"'5#'6$'7%'8&'9'':(';)'<*'=+'>,'?-'@.'A/'Q0'R1'S2'T3'U4'V5'WQ'X6'Y7'Z8'[9'\:'];'^<'_='`>'a?'b@'cA'dB'eC'fD'gE'hF'iG'jH'kI'lJ'mK'nL'oM'pN'qO(!%("%(#% ($%(%%(&%('%((%,()%$(*%4(+%<(,%(-%(.%(/%(0%(1%(2%#(3%3(4%+(5%;(6%K(7% (8%/(9%((:%7(;%?(<%(=%0(>%%(?%8(@%B0!Nœ0"U0#Z0$–?0%TР0&a0'c(0(Yі0)"0*„u0+ƒ0,zP0-`Њ0.cс0/n%00eэ01„f02‚І03›ѕ04h“05W'06eЁ07bq08[›09Yа0:†{0;˜є0<}b0=}О0>›Ž0?b0@|Ÿ0AˆЗ0B[‰0C^Е0Dc 0Ef—0FhH0G•Ч0H—0IgO0JNх0KO 0LOM0MO0NPI0OVђ0PY70QYд0RZ0S\ 0T`п0Ua0Vap0Wf0Xi0YpК0ZuO0[up0\yћ0]}­0^}я0_€У0`„0aˆc0b‹0cU0dz0eS;0fN•0gNЅ0hWп0i€В0jС0kxя0lN0mXё0nnЂ0o80pz20qƒ(0r‚‹0sœ/0tQA0uSp0vTН0wTс0xVр0yYћ0z_0{˜ђ0|mы0}€ф0~…-1!–b1"–p1#– 1$—ћ1%T 1&Sѓ1'[‡1(pЯ1)Н1*Т1+–ш1,So1-\1.zК1/N10x“11ќ12n&13V14U15k16…17œ;18Yх19SЉ1:mf1;tм1<•1=VB1>N‘1?K1@–ђ1AƒO1B™ 1CSс1DUЖ1E[01F_q1Gf 1Hfѓ1Ih1Jl81Klѓ1Lm)1Mt[1NvШ1OzN1P˜41Q‚ё1Rˆ[1SŠ`1T’э1UmВ1VuЋ1WvЪ1X™Х1Y`І1Z‹1[Š1\•В1]iŽ1^S­1_Q†1`W1aX01bYD1c[Д1d^і1e`(1fcЉ1gcє1hlП1io1jpŽ1kq1lqY1mqе1ns?1o~1p‚v1q‚б1r…—1s`1t’[1u1vXi1weМ1xlZ1yu%1zQљ1{Y.1|Ye1}_€1~_м2!bМ2"eњ2#j*2$k'2%kД2&s‹2'С2(‰V2),2*2+žФ2,\Ё2-l–2.ƒ{2/Q20\K21aЖ22Ц23hv24ra25NY26Oњ27Sx28`i29n)2:zO2;—ѓ2Nю2?OU2@O=2AOЁ2BOs2CR 2DSя2EV 2FY2GZС2H[Ж2I[с2Jyб2Kf‡2Lgœ2MgЖ2NkL2OlГ2Ppk2QsТ2Ry2SyО2Tz<2U{‡2V‚Б2W‚л2Xƒ2Yƒw2Zƒя2[ƒг2\‡f2]ŠВ2^V)2_ŒЈ2`ц2aN2b—2c†Š2dOФ2e\ш2fb2grY2hu;2iх2j‚Н2k†ў2lŒР2m–Х2n™2o™е2pNЫ2qO2r‰у2sVо2tXJ2uXЪ2v^ћ2w_ы2x`*2y`”2z`b2{aа2|b2}bа2~e93!›A3"ff3#hА3$mw3%pp3&uL3'v†3(}u3)‚Ѕ3*‡љ3+•‹3,–Ž3-Œ3.Qё3/RО30Y31TГ32[Г33]34ah35i‚36mЏ37x38„Ы39ˆW3:Šr3;“Ї3<šИ3=ml3>™Ј3?†й3@WЃ3Agџ3B†Ю3C’3DRƒ3EV‡3FT3G^г3Hbс3IdЙ3Jh<3Kh83LkЛ3Msr3NxК3Ozk3P‰š3Q‰в3Rk3S3Tэ3U•Ѓ3V–”3W—i3X[f3Y\Г3Zi}3[˜M3\˜N3]c›3^{ 3_j+3`j3ahЖ3bœ 3co_3dRr3eU3f`p3gbь3hm;3in3jnб3k„[3l‰3mD3nN3oœ93pSі3qi3rj:3s—„3th*3uQ\3vzУ3w„В3x‘м3y“Œ3zV[3{(3|h"3}ƒ3~„14!|Ѕ4"R4#‚Х4$tц4%N~4&Oƒ4'Q 4([в4)R 4*Rи4+Rч4,]ћ4-Uš4.X*4/Yц40[Œ41[˜42[л43^r44^y45`Ѓ46a47ac48aО49cл4:eb4;gб4k>4?kS4@lW4Ao"4Bo—4CoE4DtА4Eu4Fvу4Gw 4Hzџ4I{Ё4J|!4K}щ4L64M№4N€4O‚f4Pƒž4Q‰Г4RŠЬ4SŒЋ4T„4U”Q4V•“4W•‘4X•Ђ4Y–e4Z—г4[™(4\‚4]N84^T+4_\И4`]Ь4asЉ4bvL4cw<4d\Љ4eы4f 4g–С4h˜4i˜T4j˜X4kO4lO4mSq4nUœ4oVh4pWњ4qYG4r[ 4s[Ф4t\4u^ 4v^~4w_Ь4xcю4yg:4zeз4{eт4|g4}hЫ4~hФ5!j_5"^05#kХ5$l5%l}5&u5'yH5([c5)z5*}5+_Н5,‰5-Š5.ŒД5/w50ŽЬ5152˜т53š54›<55N€56P}57Q58Y“59[œ5:b/5;b€5r 5?u‘5@yG5AЉ5B‡ћ5CŠМ5D‹p5EcЌ5FƒЪ5G— 5HT 5IT5JUЋ5KhT5LjX5MŠp5Nx'5Ogu5PžЭ5QSt5R[Ђ5S5T†P5U5VN5WNE5XNЧ5YO5ZSЪ5[T85\[Ў5]_5^`%5_eQ5`g=5alB5blr5clу5dpx5et5fzv5gzЎ5h{5i}5j|ў5k}f5leч5mr[5nSЛ5o\E5p]ш5qbв5rbр5sc5tn 5u†Z5vŠ15wн5x’ј5yo5zyІ5{›Z5|NЈ5}NЋ5~NЌ6!O›6"O 6#Pб6$QG6%zі6&Qq6'Qі6(ST6)S!6*S6+Sы6,UЌ6-Xƒ6.\с6/_760_J61`/62`P63`m64c65eY66jK67lС68rТ69rэ6:wя6;€ј6<6=‚6>…N6?ї6@“с6A—џ6B™W6CšZ6DN№6EQн6F\-6Gf6Him6I\@6Jfђ6Kiu6Ls‰6MhP6N|6OPХ6PRф6QWG6R]ў6S“&6TeЄ6Uk#6Vk=6Wt46Xy6YyН6Z{K6[}Ъ6\‚Й6]ƒЬ6^ˆ6_‰_6`‹96aб6b‘б6cT6d’€6eN]6fP66gSх6hS:6irз6js–6kwщ6l‚ц6mŽЏ6n™Ц6o™Ш6p™в6qQw6ra6s†^6tUА6uzz6vPv6w[г6xG6y–…6zN26{jл6|‘ч6}\Q6~\H7!c˜7"zŸ7#l“7$—t7%a7&zЊ7'qŠ7(–ˆ7)|‚7*h7+~p7,hQ7-“l7.Rђ7/T70…Ћ71Š72Є73ŽЭ74с75Sf76ˆˆ77yA78OТ79PО7:R7;QD7sъ7?W‹7@YQ7A_b7B_„7C`u7Dav7Eag7FaЉ7GcВ7Hd:7Iel7Jfo7KhB7Ln7Muf7Nz=7O|ћ7P}L7Q}™7R~K7Sk7Tƒ7UƒJ7V†Э7WŠ7XŠc7Y‹f7ZŽ§7[˜7\7]‚И7^Ю7_›ш7`R‡7ab7bdƒ7coР7d–™7ehA7fP‘7gk 7hlz7ioT7jzt7k}P7lˆ@7mŠ#7ng7oNі7pP97qP&7rPe7sQ|7tR87uRc7vUЇ7wW7xX7yZЬ7z^њ7{aВ7|aј7}bѓ7~cr8!i8"j)8#r}8$rЌ8%s.8&x8'xo8(}y8)w 8*€Љ8+‰‹8,‹8-Œт8.Žв8/c80“u81–z82˜U83š84žx85QC86SŸ87SГ88^{89_&8:n8;n8}C8?‚78@Š8AŠњ8B–P8CNN8DP 8ESф8FT|8GVњ8HYб8I[d8J]ё8K^Ћ8L_'8Mb88NeE8OgЏ8PnV8Qrа8R|Ъ8SˆД8T€Ё8U€с8Vƒ№8W†N8XŠ‡8Yш8Z’78[–Ч8\˜g8]Ÿ8^N”8_N’8`O 8aSH8bTI8cT>8dZ/8e_Œ8f_Ё8g`Ÿ8hhЇ8ijŽ8jtZ8kx8lŠž8mŠЄ8n‹w8o‘8pN^8q›Щ8rNЄ8sO|8tOЏ8uP8vP8wQI8xQl8yRŸ8zRЙ8{Rў8|Sš8}Sу8~T9!T9"U‰9#WQ9$WЂ9%Y}9&[T9'[]9([9)]х9*]ч9+]ї9,^x9-^ƒ9.^š9/^З90_91`R92aL93b—94bи95cЇ96e;97f98fC99fє9:gm9;h!9l_9?m*9@mi9An/9Bn9Cu29Dv‡9Exl9Fz?9G|р9H}9I}9J}^9K}Б9L€9M€9N€Џ9O€Б9PT9Q9R‚*9SƒR9TˆL9Uˆa9V‹9WŒЂ9XŒќ9YЪ9Z‘u9[’q9\x?9]’ќ9^•Є9_–M9`˜9a™™9bšи9c;9dR[9eRЋ9fSї9gT9hXе9ibї9joр9kŒj9l_9mžЙ9nQK9oR;9pTJ9qV§9rz@9s‘w9t`9užв9vsD9wo 9xp9yu9z_§9{`к9|šЈ9}rл9~М:!kd:"˜:#NЪ:$V№:%Wd:&XО:'ZZ:(`h:)aЧ:*f:+f:,h9:-hБ:.mї:/uе:0}::1‚n:2›B:3N›:4OP:5SЩ:6U:7]o:8]ц:9]ю::gћ:;l™:ŠP:?“–:@ˆп:AWP:B^Ї:Cc+:DPЕ:EPЌ:FQ:Gg:HTЩ:IX^:JYЛ:K[А:L_i:MbM:NcЁ:Oh=:Pks:Qn:Rp}:S‘Ч:Tr€:Ux:Vx&:Wym:XeŽ:Y}0:Zƒм:[ˆС:\ :]–›:^Rd:_W(:`gP:aj:bŒЁ:cQД:dWB:e–*:fX::giŠ:h€Д:iTВ:j]:kWќ:lx•:mњ:nO\:oRJ:pT‹:qd>:rf(:sg:tgѕ:uz„:v{V:w}":x“/:yh\:z›­:{{9:|S:}QŠ:~R7;![п;"bі;#dЎ;$dц;%g-;&kК;'…Љ;(–б;)v;*›ж;+cL;,“;-›Ћ;.vП;/fR;0N ;1P˜;2SТ;3\q;4`ш;5d’;6ec;7h_;8qц;9sЪ;:u#;;{—;<~‚;=†•;>‹ƒ;?Œл;@‘x;A™;BeЌ;CfЋ;Dk‹;ENе;FNд;GO:;HO;IR:;JSј;KSђ;LUу;MVл;NXы;OYЫ;PYЩ;QYџ;R[P;S\M;T^;U^+;V_з;W`;Xc;Ye/;Z[\;[eЏ;\eН;]eш;^g;_kb;`k{;al;bsE;cyI;dyС;e|ј;f};g}+;h€Ђ;i;jѓ;k‰–;lŠ^;mŠi;nŠf;oŠŒ;pŠю;qŒЧ;rŒм;s–Ь;t˜ќ;uko;vN‹;wO<;xO;yQP;z[W;{[њ;|aH;}c;~fB<%tН<&uд<'xС<(y:<)€ <*€3<+ъ<,„”<-ž<.lPn_“=?b=@gд=AlA=Bn =Csc=D~&=E‘Э=F’ƒ=GSд=HY=I[П=Jmб=Ky]=L~.=M|›=NX~=OqŸ=PQњ=QˆS=R№=SOЪ=T\ћ=Uf%=VwЌ=Wzу=X‚=Y™џ=ZQЦ=[_Њ=\eь=]io=^k‰=_mѓ=`n–=aod=bvў=c}=d]с=eu=f‘‡=g˜=hQц=iR=jb@=kf‘=lfй=mn=n^Ж=o}в=pr=qfј=r…Џ=s…ї=tŠј=uRЉ=vSй=wYs=x^=y_=z`U={’ф=|–d=}PЗ=~Q>!Rн>"S >#SG>$Sь>%Tш>&UF>'U1>(V>)Yh>*YО>+Z<>,[Е>-\>.\>/\>0\>1^„>2^Š>3^р>4_p>5b>6b„>7bл>8cŒ>9cw>:f>;f >=fv>>g~>?hЂ>@j>Aj5>BlМ>Cmˆ>Dn >EnX>Fq<>Gq&>Hqg>IuЧ>Jw>Kx]>Ly>Mye>Ny№>Ozр>P{>Q|Ї>R}9>S€–>Tƒж>U„‹>V…I>Wˆ]>Xˆѓ>YŠ>ZŠ<>[ŠT>\Šs>]Œa>^Œо>_‘Є>`’f>a“~>b”>c–œ>d—˜>eN >fN>gN>hNW>iQ—>jRp>kWЮ>lX4>mXЬ>n[">o^8>p`Х>qdў>rga>sgV>tmD>urЖ>vus>wzc>x„И>y‹r>z‘И>{“ >|V1>}Wє>~˜ў?!bэ?"i ?#k–?$qэ?%~T?&€w?'‚r?(‰ц?)˜п?*‡U?+Б?,\;?-O8?.Oс?/OЕ?0U?1Z ?2[н?3[щ?4_У?5aN?6c/?7eА?8fK?9hю?:i›?;mx?uЙ??w?@y^?Ayц?B}3?Cу?D‚Џ?E…Њ?F‰Њ?GŠ:?HŽЋ?I›?J2?K‘н?L—?MNК?NNС?OR?PXu?QXь?R\ ?Su?T\=?UN?VŠ ?WХ?X–c?Y—m?Z{%?[ŠЯ?\˜?]‘b?^Vѓ?_SЈ?`?aT9?bW‚?c^%?dcЈ?el4?fpŠ?gwa?h|‹?iр?jˆp?kB?l‘T?m“?n“?o–?pt^?qšФ?r]?s]i?tep?ugЂ?vЈ?w–л?xcn?ygI?zi?{ƒХ?|˜?}–Р?~ˆў@!o„@"dz@#[ј@$N@%p,@&u]@'f/@(QФ@)R6@*Rт@+Yг@,_@-`'@.b@/e?@0et@1f@2ft@3hђ@4h@5kc@6n@7rr@8u@9vл@:|О@;€V@‰@?Š @@Š“@AŠЫ@B@C‘’@D—R@E—Y@Fe‰@Gz@H@I–Л@J^-@K`м@Lb@MeЅ@Nf@Og@Pwѓ@QzM@R|M@S~>@T @UŒЌ@Vd@Wс@XŽ_@YxЉ@ZR@[bй@\cЅ@]dB@^b˜@_Š-@`zƒ@a{Р@bŠЌ@c–ъ@d}v@e‚ @f‡I@gNй@hQH@iSC@jS`@k[Ѓ@l\@m\@n]н@ob&@pbG@qdА@rh@sh4@tlЩ@umE@vm@wgг@xo\@yqN@zq}@{eЫ@|z@}{­@~}кA!~JA"ЈA#zA$‚A%‚9A&…ІA'ŠnA(ŒЮA)ѕA*xA+wA,’­A-’‘A.•ƒA/›ЎA0RMA1U„A2o8A3q6A4QhA5y…A6~UA7ГA8|ЮA9VLA:XQA;\ЈAf§A?iZA@rйAAuABuŽACyADyVAEyпAF|—AG} AH}DAI†AJŠ4AK–;ALaAMŸ ANPчAORuAPSЬAQSтARP ASUЊATXюAUYOAVr=AW[‹AX\dAYSAZ`уA[`ѓA\c\A]cƒA^c?A_cЛA`dЭAaeщAbfљAc]уAdiЭAei§AfoAgqхAhN‰AiuщAjvјAkz“Al|пAm}ЯAn}œAo€aApƒIAqƒXAr„lAs„МAt…ћAuˆХAvpAwAxmAy“—Az—A{šA|PЯA}X—A~aŽB!гB"…5B#B$ B%OУB&PtB'RGB(SsB)`oB*cIB+g_B,n,B-ГB.B/OзB0\^B1ŒЪB2eЯB3}šB4SRB5ˆ–B6QvB7cУB8[XB9[kB:\ B;d BNжB?YB@Y*BAlpBBŠQBCU>BDXBEYЅBF`№BGbSBHgСBI‚5BJiUBK–@BL™ФBMš(BNOSBOXBP[ўBQ€BR\БBS^/BT_…BU` BVaKBWb4BXfџBYl№BZnоB[€ЮB\B]‚дB^ˆ‹B_ŒИB`Ba.Bb–ŠBcžлBd›лBeNуBfS№BgY'Bh{,Bi‘Bj˜LBkљBlnнBmp'BnSSBoUDBp[…BqbXBrbžBsbгBtlЂBuoяBvt"BwŠBx”8ByoСBzŠўB{ƒ8B|QчB}†јB~SъC!SщC"OFC#TC$АC%YjC&1C']§C(zъC)ПC*hкC+Œ7C,rјC-œHC.j=C/ŠАC0N9C1SXC2VC3WfC4bХC5cЂC6eцC7kNC8mсC9n[C:p­C;wэC}ЛC?€=C@€ЦCA†ЫCBŠ•CC“[CDVуCEXЧCF_>CGe­CHf–CIj€CJkЕCKu7CLŠЧCMP$CNwхCOW0CP_CQ`eCRfzCSl`CTuєCUzCVnCWєCX‡CYECZ™ГC[{ЩC\u\C]zљC^{QC_„ФC`CayщCbz’Ccƒ6CdZсCew@CfN-CgNђCh[™Ci_рCjbНCkfvєD?gD@lˆDAsЭDBŒУDC“ЎDD–sDEm%DFXœDGiDHiЬDI§DJ“šDKuлDLDMXZDNhDOcДDPiћDQOCDRo,DSgиDTЛDU…&DV}ДDW“TDXi?DYopDZWjD[XїD\[,D]},D^r*D_T D`‘уDaДDbN­DcONDdP\DePuDfRCDgŒžDhTHDiX$Dj[šDk^Dl^•Dm^­Dn^їDo_Dp`ŒDqbЕDrc:DscаDthЏDul@Dvx‡DwyŽDxz Dy}рDz‚GD{ŠD|ŠцD}ŽDD~E!ИE"‘-E#‘иE$ŸE%lхE&dXE'dтE(euE)nєE*v„E+{E,iE-“бE.nКE/TђE0_ЙE1dЄE2ME3эE4’DE5QxE6XkE7Y)E8\UE9^—E:mћE;~EŽтE?˜[E@pЙEAOEBkПECoБEDu0EE–ћEFQNEGTEHX5EIXWEJYЌEK\`EL_’EMe—ENg\EOn!EPv{EQƒпERŒэESET§EU“MEVx%EWx:EXRЊEY^ІEZWE[YtE\`E]PE^QZE_QЌE`QЭEaREbUEcXTEdXXEeYWEf[•Eg\іEh]‹Ei`МEjb•Ekd-ElgqEmhCEnhМEohпEpvзEqmиErnoEsm›EtpoEuqШEv_SEwuиExywEy{IEz{TE{{RE||жE}}qE~R0F!„cF"…iF#…фF$ŠF%‹F&ŒFF'ŽF(F)F*”F+–vF,˜-F-š0F.•иF/PЭF0RеF1T F2XF3\F4aЇF5džF6mF7wГF8zхF9€єF:„F;SF<’…F=\рF>F?S?F@_—FA_ГFBmœFCryFDwcFEyПFF{фFGkвFHrьFIŠ­FJhFKjaFLQјFMzFNi4FO\JFPœіFQ‚ыFR[ХFS‘IFTpFUVxFV\oFW`ЧFXefFYlŒFZŒZF[AF\˜F]TQF^fЧF_’ F`YHFaЃFbQ…FcNMFdQъFe…™Ff‹FgpXFhczFi“KFjibFk™ДFl~FmuwFnSWFoi`FpŽпFq–уFrl]FsNŒFt\3G?ПG@ВGA‰—GB†ЄGC]єGDbŠGEd­GF‰‡GGgwGHlтGIm>GJt6GKx4GLZFGMuGN‚­GO™ЌGPOѓGQ^УGRbнGSc’GTeWGUgoGVvУGWrLGX€ЬGY€КGZ)G[‘MG\P G]WљG^Z’G_h…G`isGaqdGbr§GcŒЗGdXђGeŒрGf–jGgGh‡GiyфGjwчGk„)GlO/GmReGnSZGobЭGpgЯGqlЪGrv}Gs{”Gt|•Gu‚6Gv…„GwыGxfнGyo GzrG{~G|ƒЋG}™СG~žІH!Q§H"{БH#xrH${ИH%€‡H&{HH'jшH(^aH)€ŒH*uQH+u`H,QkH-’bH.nŒH/vzH0‘—H1šъH2OH3pH4bœH5{OH6•ЅH7œщH8VzH9XYH:†фH;–МHSJH?SЭH@SлHA^HBd,HCe‘HDgHEl>HFlNHGrHHHrЏHIsэHJuTHK~AHL‚,HM…щHNŒЉHO{ФHP‘ЦHQqiHR˜HS˜яHTc=HUfiHVujHWvфHXxаHY…CHZ†юH[S*H\SQH]T&H^YƒH_^‡H`_|Ha`ВHbbIHcbyHdbЋHeeHfkдHglЬHhuВHivЎHjx‘HkyиHl}ЫHmwHn€ЅHoˆЋHpŠЙHqŒЛHrHs—^Ht˜лHuj Hv|8HwP™Hx\>Hy_ЎHzg‡H{kиH|t5H}w H~ŽI!Ÿ;I"gЪI#zI$S9I%u‹I&šэI'_fI(I)ƒёI*€˜I+_ŠUI?ŒyI@^пIAcЯIBuХICyвID‚зIE“(IF’ђIG„œIH†эIIœ-IJTСIK_lILeŒIMm\INpIOŒЇIPŒгIQ˜;IReOIStіITN IUNиIVWрIWY+IXZfIY[ЬIZQЈI[^I\^œI]`I^bvI_ewI`eЇIafnIbmnIcr6Id{&IePIfšIg‚™Ih‹\IiŒ IjŒцIktIl–Im–DInOЎIodЋIpkfIq‚Ir„aIs…jItшIu\IviSIw˜ЈIx„zIy…WIzOI{RoI|_ЉI}^EI~g J!yJ"yJ#‰J$‰†J%mѕJ&_J'bUJ(lИJ)NЯJ*riJ+›’J,RJ-T;J.VtJ/XГJ0aЄJ1bnJ2qJ3YnJ4|‰J5|оJ6}J7–№J8e‡J9€^J:NJ;OuJ^cJ?^sJ@_ JAgФJBN&JC…=JD•‰JE–[JF|sJG˜JHPћJIXСJJvVJKxЇJLR%JMwЅJN…JO{†JPPOJQY JRrGJS{ЧJT}шJUКJVдJWMJXOПJYRЩJZZ)J[_J\—­J]OнJ^‚J_’ъJ`WJacUJbkiJcu+JdˆмJeJfzBJgRпJhX“JiaUJjb JkfЎJlkЭJm|?JnƒщJoP#JpOјJqSJrTFJsX1JtYIJu[Jv\№Jw\яJx])Jy^–JzbБJ{cgJ|e>J}eЙJ~g K!lеK"lсK#pљK$x2K%~+K&€оK'‚ГK(„ K)„ьK*‡K+‰K,Š*K-ŒJK.ІK/’вK0˜§K1œѓK2lK3NOK4NЁK5PK6RVK7WJK8YЈK9^=K:_иK;_йKgK?gаK@hвKAQ’KB}!KC€ЊKDЈKE‹KFŒŒKGŒПKH’~KI–2KJT KK˜,KLSKMPеKNS\KOXЈKPdВKQg4KRrgKSwfKTzFKU‘цKVRУKWlЁKXk†KYXKZ^LK[YTK\g,K]ћK^QсK_vЦK`diKaxшKb›TKcžЛKdWЫKeYЙKff'KggšKhkЮKiTщKjiйKk^UKlœKmg•Kn›ЊKogўKpœRKqh]KrNІKsOуKtSШKubЙKvg+KwlЋKxФKyO­Kz~mK{žПK|NK}abK~n€L!o+L"…L#TsL$g*L%›EL&]ѓL'{•L(\ЌL)[ЦL*‡L+nJL,„бL-zL.L/Y™L0|L1lL2w L3RйL4Y"L5q!L6r_L7wлL8—'L9aL:i L;ZLT L?T}L@fLAvпLBїLC’˜LDœєLEYъLFr]LGnХLHQMLIhЩLJ}ПLK}ьLL—bLMžКLNdxLOj!LPƒLQY„LR[_LSkлLTsLUvђLV}ВLW€LX„™LYQ2LZg(L[žйL\vюL]gbL^RџL_™L`\$Lab;Lb|~LcŒАLdUOLe`ЖLf} Lg•€LhSLiN_LjQЖLkYLlr:Lm€6Ln‘ЮLo_%LpwтLqS„Lr_yLs}Lt…ЌLuŠ3LvŽLw—VLxgѓLy…ЎLz”SL{a L|aL}lЙL~vRM!ŠэM"8M#U/M$OQM%Q*M&RЧM'SЫM([ЅM)^}M*` M+a‚M,cжM-g M.gкM/ngM0mŒM1s6M2s7M3u1M4yPM5ˆеM6Š˜M7JM8‘M9ѕM:–ФM;‡MOYM?NM@Š‰MA?MB˜MCP­MD^|MEY–MF[ЙMG^ИMHcкMIcњMJdСMKfмMLiJMMiиMNm MOnЖMPq”MQu(MRzЏMSŠMT€MU„IMV„ЩMW‰MX‹!MYŽ MZeM[–}M\™ M]a~M^b‘M_k2M`lƒMamtMbЬMcќMdmРMe…Mf‡КMgˆјMhgeMiƒБMj˜N!N?QЬN@[юNAe™NBhNCmМNDsNEvBNFw­NGzNH|чNI‚oNJŠвNK|NL‘ЯNM–uNN˜NOR›NP}бNQP+NRS˜NSg—NTmЫNUqаNVt3NWшNX*NY–ЃNZœWN[žŸN\t`N]XAN^m™N_}/N`˜^NaNфNbO6NcO‹NdQЗNeRБNf]КNg`NhsВNiyN}}єN~€oO!„юO"#O#“,O$TBO%›oO&jгO'p‰O(ŒТO)яO*—2O+RДO,ZAO-^ЪO._O/gO0i|O1i”O2mjO3oO4rbO5rќO6{эO7€O8€~O9‡KO:ЮO;QmO<ž“O=y„O>€‹O?“2O@ŠжOAP-OBTŒOCŠqODkjOEŒФOFOG`бOHg OIђOJN™OKN˜OLœOMŠkON…СOO…hOPiOQn~ORx—OSUP!_ P"NP#NP$N*P%N1P&N6P'NNТP?NзP@NоPANэPBNпPCNїPDO PEOZPFO0PGO[PHO]PIOWPJOGPKOvPLOˆPMOPNO˜POO{PPOiPQOpPRO‘PSOoPTO†PUO–PVQPWOдPXOпPYOЮPZOиP[OлP\OбP]OкP^OаP_OфP`OхPaPPbP(PcPPdP*PeP%PfPPgOPhOіPiP!PjP)PkP,PlOўPmOяPnPPoPPpPCPqPGPrgPsPUPtPPPuPHPvPZPwPVPxPlPyPxPzP€P{PšP|P…P}PДP~PВQ!PЩQ"PЪQ#PГQ$PТQ%PжQ&PоQ'PхQ(PэQ)PуQ*PюQ+PљQ,PѕQ-Q Q.QQ/QQ0QQ1QQ2QQ3QQ4Q!Q5Q:Q6Q7Q7QQbQ?zјQ@QiQAQjQBQnQCQ€QDQ‚QEVиQFQŒQGQ‰QHQQIQ‘QJQ“QKQ•QLQ–QMQЄQNQІQOQЂQPQЉQQQЊQRQЋQSQГQTQБQUQВQVQАQWQЕQXQНQYQХQZQЩQ[QлQ\QрQ]†UQ^QщQ_QэQ`Q№QaQѕQbQўQcRQdR QeRQfRQgR'QhR*QiR.QjR3QkR9QlROQmRDQnRKQoRLQpR^QqRTQrRjQsRtQtRiQuRsQvRQwR}QxRQyR”QzR’Q{RqQ|RˆQ}R‘Q~ЈR!ЇR"RЌR#R­R$RМR%RЕR&RСR'RЭR(RзR)RоR*RуR+RцR,˜эR-RрR.RѓR/RѕR0RјR1RљR2SR3SR4u8R5S R6SR7SR8SR9SR:S#R;S/RS8R?S@R@SFRASERBNRCSIRDSMREQжRFS^RGSiRHSnRIYRJS{RKSwRLS‚RMS–RNS ROSІRPSЅRQSЎRRSАRSSЖRTSУRU|RV–йRWSпRXfќRYqюRZSюR[SшR\SэR]SњR^TR_T=R`T@RaT,RbT-RcTTЏS?UŠS@UŸSAU{SBU~SCU˜SDUžSEUЎSFU|SGUƒSHUЉSIU‡SJUЈSKUкSLUХSMUпSNUФSOUмSPUфSQUдSRVSSUїSTVSUUўSVU§SWVSXUљSYVNSZVPS[qпS\V4S]V6S^V2S_V8S`VkSaVdSbV/ScVlSdVjSeV†SfV€SgVŠShV SiV”SjVSkVЅSlVЎSmVЖSnVДSoVТSpVМSqVСSrVУSsVРStVШSuVЮSvVбSwVгSxVзSyVюSzVљS{WS|VџS}WS~W T!WT"W T#W T$WT%WT&WT'UЧT(WT)W&T*W7T+W8T,WNT-W;T.W@T/WOT0WiT1WРT2WˆT3WaT4WT5W‰T6W“T7W T8WГT9WЄT:WЊT;WАTWдT?WвT@WгTAX TBWжTCWуTDX TEXTFXTGXrTHX!TIXbTJXKTKXpTLkРTMXRTNX=TOXyTPX…TQXЙTRXŸTSXЋTTXКTUXоTVXЛTWXИTXXЎTYXХTZXгT[XбT\XзT]XйT^XиT_XхT`XмTaXфTbXпTcXяTdXњTeXљTfXћTgXќThX§TiYTjY TkYTlYTmhІTnY%ToY,TpY-TqY2TrY8TsY>TtzвTuYUTvYPTwYNTxYZTyYXTzYbT{Y`T|YgT}YlT~YiU!YxU"YU#YU$O^U%OЋU&YЃU'YВU(YЦU)YшU*YмU+YU,YйU-YкU.Z%U/ZU0ZU1ZU2Z U3ZU4Z@U5ZlU6ZIU7Z5U8Z6U9ZbU:ZjU;ZšUZЫU?ZТU@ZНUAZуUBZзUCZцUDZщUEZжUFZњUGZћUH[ UI[ UJ[UK[2ULZаUM[*UN[6UO[>UP[CUQ[EUR[@US[QUT[UUU[ZUV[[UW[eUX[iUY[pUZ[sU[[uU\[xU]eˆU^[zU_[€U`[ƒUa[ІUb[ИUc[УUd[ЧUe[ЩUf[дUg[аUh[фUi[цUj[тUk[оUl[хUm[ыUn[№Uo[іUp[ѓUq\Ur\Us\Ut\ Uu\Uv\ Uw\"Ux\(Uy\8Uz\9U{\AU|\FU}\NU~\SV!\PV"\OV#[qV$\lV%\nV&NbV'\vV(\yV)\ŒV*\‘V+\”V,Y›V-\ЋV.\ЛV/\ЖV0\МV1\ЗV2\ХV3\ОV4\ЧV5\йV6\щV7\§V8\њV9\эV:]ŒV;\ъV<] V=]V>]V?]\V@]VA]VB]VC]VD]"VE]VF]VG]VH]LVI]RVJ]NVK]KVL]lVM]sVN]vVO]‡VP]„VQ]‚VR]ЂVS]VT]ЌVU]ЎVV]НVW]VX]ЗVY]МVZ]ЩV[]ЭV\]гV]]вV^]жV_]лV`]ыVa]ђVb]ѕVc^ Vd^Ve^Vf^Vg^Vh^6Vi^7Vj^DVk^CVl^@Vm^NVn^WVo^TVp^_Vq^bVr^dVs^GVt^uVu^vVv^zVwžМVx^Vy^ Vz^СV{^ТV|^ШV}^аV~^ЯW!^жW"^уW#^нW$^кW%^лW&^тW'^сW(^шW)^щW*^ьW+^ёW,^ѓW-^№W.^єW/^јW0^ўW1_W2_ W3_]W4_\W5_ W6_W7_W8_)W9_-W:_8W;_AW<_HW=_LW>_NW?_/W@_QWA_VWB_WWC_YWD_aWE_mWF_sWG_wWH_ƒWI_‚WJ_WK_ŠWL_ˆWM_‘WN_‡WO_žWP_™WQ_˜WR_ WS_ЈWT_­WU_МWV_жWW_ћWX_фWY_јWZ_ёW[_нW\`ГW]_џW^`!W_``W``Wa`Wb`)Wc`Wd`1We`Wf`Wg`+Wh`&Wi`Wj`:Wk`ZWl`AWm`jWn`wWo`_Wp`JWq`FWr`MWs`cWt`CWu`dWv`BWw`lWx`kWy`YWz`W{`W|`чW}`ƒW~`šX!`„X"`›X#`–X$`—X%`’X&`ЇX'`‹X(`сX)`ИX*`рX+`гX,`ДX-_№X.`НX/`ЦX0`ЕX1`иX2aMX3aX4aX5`іX6`їX7aX8`єX9`њX:aX;a!X<`ћX=`ёX>a X?aX@aGXAa>XBa(XCa'XDaJXEa?XFabЦY?dдY@bШYAbмYBbЬYCbЪYDbТYEbЧYFb›YGbЩYHc YIbюYJbёYKc'YLcYMcYNbяYObѕYPcPYQc>YRcMYSdYTcOYUc–YVcŽYWc€YXcЋYYcvYZcЃY[cY\c‰Y]cŸY^cЕY_ckY`ciYacОYbcщYccРYdcЦYecуYfcЩYgcвYhcіYicФYjdYkd4YldYmdYnd&Yod6YpeYqdYrd(YsdYtdgYudoYvdvYwdNYxe*Yyd•Yzd“Y{dЅY|dЉY}dˆY~dМZ!dкZ"dвZ#dХZ$dЧZ%dЛZ&dиZ'dТZ(dёZ)dчZ*‚ Z+dрZ,dсZ-bЌZ.dуZ/dяZ0e,Z1dіZ2dєZ3dђZ4dњZ5eZ6d§Z7eZ8eZ9eZ:e$Z;e#Ze5Z?e7Z@e6ZAe8ZBuKZCeHZDeVZEeUZFeMZGeXZHe^ZIe]ZJerZKexZLe‚ZMeƒZN‹ŠZOe›ZPeŸZQeЋZReЗZSeУZTeЦZUeСZVeФZWeЬZXeвZYeлZZeйZ[eрZ\eсZ]eёZ^grZ_f Z`fZaeћZbgsZcf5Zdf6Zef4ZffZgfOZhfDZifIZjfAZkf^Zlf]ZmfdZnfgZofhZpf_ZqfbZrfpZsfƒZtfˆZufŽZvf‰Zwf„Zxf˜ZyfZzfСZ{fЙZ|fЩZ}fОZ~fМ[!fФ["fИ[#fж[$fк[%fр[&f?['fц[(fщ[)f№[*fѕ[+fї[,g[-g[.g[/g&[0g'[1—8[2g.[3g?[4g6[5gA[6g8[7g7[8gF[9g^[:g`[;gY[g‰[?gp[@gЉ[Ag|[Bgj[CgŒ[Dg‹[EgІ[FgЁ[Gg…[HgЗ[Igя[JgД[Kgь[LgГ[Mgщ[NgИ[Ogф[Pgо[Qgн[Rgт[Sgю[TgЙ[UgЮ[VgЦ[Wgч[Xjœ[Yh[ZhF[[h)[\h@[]hM[^h2[_hN[`hГ[ah+[bhY[chc[dhw[eh[fhŸ[gh[hh­[ih”[jh[kh›[lhƒ[mjЎ[nhЙ[oht[phЕ[qh [rhК[si[th[uh~[vi[whЪ[xi[yhи[zi"[{i&[|hс[}i [~hЭ\!hд\"hч\#hе\$i6\%i\&i\'hз\(hу\)i%\*hљ\+hр\,hя\-i(\.i*\/i\0i#\1i!\2hЦ\3iy\4iw\5i\\6ix\7ik\8iT\9i~\:in\;i9\iY\?i0\@ia\Ai^\Bi]\Ci\Dij\EiВ\FiЎ\Giа\HiП\IiС\Jiг\KiО\LiЮ\M[ш\NiЪ\Oiн\PiЛ\QiУ\RiЇ\Sj.\Ti‘\Ui \Viœ\Wi•\XiД\Yiо\Ziш\[j\\j\]iџ\^k \_iљ\`iђ\aiч\bj\ciБ\dj\eiэ\fj\giы\hj \ij\jjС\kj#\lj\mjD\nj \ojr\pj6\qjx\rjG\sjb\tjY\ujf\vjH\wj8\xj"\yj\zj\{j \|j„\}jЂ\~jЃ]!j—]"†]#jЛ]$jУ]%jТ]&jИ]'jГ](jЌ])jо]*jб]+jп],jЊ]-jк].jъ]/jћ]0k]1†]2jњ]3k]4k]5›1]6k]7k8]8k7]9vм]:k9];˜ю]kI]?kP]@kY]AkT]Bk[]Ck_]Dka]Ekx]Fky]Gk]Hk€]Ik„]Jkƒ]Kk]Lk˜]Mk•]Nkž]OkЄ]PkЊ]QkЋ]RkЏ]SkВ]TkБ]UkГ]VkЗ]WkМ]XkЦ]YkЫ]Zkг][kп]\kь]]kы]^kѓ]_kя]`žО]al]bl]cl]dl]el$]fl#]gl^]hlU]ilb]jlj]kl‚]ll]mlš]nl]ol›]pl~]qlh]rls]sl’]tl]ulФ]vlё]wlг]xlН]ylз]zlХ]{lн]|lЎ]}lБ]~lО^!lК^"lл^#lя^$lй^%lъ^&m^'ˆM^(m6^)m+^*m=^+m8^,m^-m5^.m3^/m^0m ^1mc^2m“^3md^4mZ^5my^6mY^7mŽ^8m•^9oф^:m…^;mљ^mЕ^?mЧ^@mц^AmИ^BmЦ^Cmь^Dmо^EmЬ^Fmш^Gmв^HmХ^Imњ^Jmй^Kmф^Lmе^Mmъ^Nmю^On-^Pnn^Qn.^Rn^Snr^Tn_^Un>^Vn#^Wnk^Xn+^Ynv^ZnM^[n^\nC^]n:^^nN^_n$^`nџ^an^bn8^cn‚^dnЊ^en˜^fnЩ^gnЗ^hnг^inН^jnЏ^knФ^lnВ^mnд^nnе^on^pnЅ^qnТ^rnŸ^soA^to^upL^vnь^wnј^xnў^yo?^znђ^{o1^|nя^}o2^~nЬ_!o>_"o_#nї_$o†_%oz_&ox_'o_(o€_)oo_*o[_+oѓ_,om_-o‚_.o|_/oX_0oŽ_1o‘_2oТ_3of_4oГ_5oЃ_6oЁ_7oЄ_8oЙ_9oЦ_:oЊ_;oп_oд_?oи_@oё_Aoю_Boл_Cp _Dp _Eoњ_Fp_Gp_Hp_Ioў_Jp_Kp_Lot_Mp_Np_Op_Pp0_Qp>_Rp2_SpQ_Tpc_Up™_Vp’_WpЏ_Xpё_YpЌ_ZpИ_[pГ_\pЎ_]pп_^pЫ__pн_`pй_aq _bp§_cq_dq_eqe_fqU_gqˆ_hqf_iqb_jqL_kqV_lql_mq_nqћ_oq„_pq•_qqЈ_rqЌ_sqз_tqЙ_uqО_vqв_wqЩ_xqд_yqЮ_zqр_{qь_|qч_}qѕ_~qќ`!qљ`"qџ`#r `$r`%r`&r(`'r-`(r,`)r0`*r2`+r;`,r<`-r?`.r@`/rF`0rK`1rX`2rt`3r~`4r‚`5r`6r‡`7r’`8r–`9rЂ`:rЇ`;rЙ`rЦ`?rФ`@rЮ`Arв`Brт`Crр`Drс`Erљ`Frї`GP`Hs`Is `Js`Ks`Ls`Ms4`Ns/`Os)`Ps%`Qs>`RsN`SsO`Tžи`UsW`Vsj`Wsh`Xsp`Ysx`Zsu`[s{`\sz`]sШ`^sГ`_sЮ``sЛ`asР`bsх`csю`dsо`etЂ`ft`gto`ht%`isј`jt2`kt:`ltU`mt?`nt_`otY`ptA`qt\`rti`stp`ttc`utj`vtv`wt~`xt‹`ytž`ztЇ`{tЪ`|tЯ`}tд`~sёa!tрa"tуa#tчa$tщa%tюa&tђa't№a(tёa)tјa*tїa+ua,ua-ua.u a/ua0u a1ua2ua3ua4u&a5u,a6uuia?uda@ugaAukaBumaCuxaDuvaEu†aFu‡aGutaHuŠaIu‰aJu‚aKu”aLušaMuaNuЅaOuЃaPuТaQuГaRuУaSuЕaTuНaUuИaVuМaWuБaXuЭaYuЪaZuвa[uйa\uуa]uоa^uўa_uџa`uќaavabu№acuњaduђaeuѓafv agv ahv aivajv'akv alv!amv"anv$aov4apv0aqv;arvGasvHatvFauv\avvXawvaaxvbayvhazvia{vja|vga}vla~vpb!vrb"vvb#vxb$v|b%v€b&vƒb'vˆb(v‹b)vŽb*v–b+v“b,v™b-všb.vАb/vДb0vИb1vЙb2vКb3vТb4vЭb5vжb6vвb7vоb8vсb9vхb:vчb;vъb<†/b=vћb>wb?wb@wbAw)bBw$bCwbDw%bEw&bFwbGw7bHw8bIwGbJwZbKwhbLwkbMw[bNwebOwbPw~bQwybRwŽbSw‹bTw‘bUw bVwžbWwАbXwЖbYwЙbZwПb[wМb\wНb]wЛb^wЧb_wЭb`wзbawкbbwмbcwуbdwюbewќbfx bgxbhy&bix bjy*bkxEblxŽbmxtbnx†box|bpxšbqxŒbrxЃbsxЕbtxЊbuxЏbvxбbwxЦbxxЫbyxдbzxОb{xМb|xХb}xЪb~xьc!xчc"xкc#x§c$xєc%yc&yc'yc(yc)y,c*y+c+y@c,y`c-yWc.y_c/yZc0yUc1ySc2yzc3yc4yŠc5yc6yЇc7ŸKc8yЊc9yЎc:yГc;yЙcyеc?yчc@yьcAyсcByуcCzcDz cEzcFzcGz cHzcIy€cJz1cKz;cLz>cMz7cNzCcOzWcPzIcQzacRzbcSzicTŸcUzpcVzycWz}cXzˆcYz—cZz•c[z˜c\z–c]zЉc^zШc_zАc`zЖcazХcbzФcczПcdƒcezЧcfzЪcgzЭchzЯcizеcjzгckzйclzкcmzнcnzсcozтcpzцcqzэcrz№cs{ct{cu{ cv{cw{3cx{cy{cz{c{{5c|{(c}{6c~{Pd!{zd"{d#{Md${ d%{Ld&{Ed'{ud({ed){td*{gd+{pd,{qd-{ld.{nd/{d0{˜d1{Ÿd2{d3{œd4{šd5{‹d6{’d7{d8{]d9{™d:{Ыd;{Сd<{Ьd={Яd>{Дd?{Цd@{нdA{щdB|dC|dD{цdE{хdF|`dG|dH|dI|dJ{ѓdK{їdL|dM| dN{іdO|#dP|'dQ|*dR|dS|7dT|+dU|=dV|LdW|CdX|TdY|OdZ|@d[|Pd\|Xd]|_d^|dd_|Vd`|eda|ldb|udc|ƒdd|de|Єdf|­dg|Ђdh|Ћdi|Ёdj|Јdk|Гdl|Вdm|Бdn|Ўdo|Йdp|Нdq|Рdr|Хds|Тdt|иdu|вdv|мdw|тdx›;dy|яdz|ђd{|єd||іd}|њd~}e!}e"}e#}e$} e%}Ee&}Ke'}.e(}2e)}?e*}5e+}Fe,}se-}Ve.}Ne/}re0}he1}ne2}Oe3}ce4}“e5}‰e6}[e7}e8}}e9}›e:}Кe;}Ўe<}Ѓe=}Еe>}Чe?}Нe@}ЋeA~=eB}ЂeC}ЏeD}мeE}ИeF}ŸeG}АeH}иeI}нeJ}фeK}оeL}ћeM}ђeN}сeO~eP~ eQ~#eR~!eS~eT~1eU~eV~ eW~ eX~"eY~FeZ~fe[~;e\~5e]~9e^~Ce_~7e`~2ea~:eb~gec~]ed~Vee~^ef~Yeg~Zeh~yei~jej~iek~|el~{em~ƒen}еeo~}epЎeq~er~ˆes~‰et~Œeu~’ev~ew~“ex~”ey~–ez~Že{~›e|~œe}8e~:f!Ef"Lf#Mf$Nf%Pf&Qf'Uf(Tf)Xf*_f+`f,hf-if.gf/xf0‚f1†f2ƒf3ˆf4‡f5Œf6”f7žf8f9šf:Ѓf;Џf<Вf=Йf>Ўf?Жf@ИfA‹qfBХfCЦfDЪfEеfFдfGсfHцfIщfJѓfKљfL˜мfM€fN€fO€ fP€fQ€fR€fS€fT€!fU€(fV€?fW€;fX€JfY€FfZ€Rf[€Xf\€Zf]€_f^€bf_€hf`€sfa€rfb€pfc€vfd€yfe€}ff€fg€„fh€†fi€…fj€›fk€“fl€šfm€­fnQfo€Ќfp€лfq€хfr€йfs€нft€Фfu€кfv€жfw fx€яfy€ёfzf{)f|#f}/f~Kg!–‹g"Fg#>g$Sg%Qg&€ќg'qg(ng)eg*fg+tg,ƒg-ˆg.Šg/€g0‚g1 g2•g3Єg4Ѓg5_g6“g7Љg8Аg9Еg:Оg;Иg<Нg=Рg>Тg?Кg@ЩgAЭgBбgCйgDиgEШgFкgGпgHрgIчgJњgKћgLўgM‚gN‚gO‚gP‚gQ‚ gR‚ gS‚gT‚gU‚)gV‚+gW‚8gX‚3gY‚@gZ‚Yg[‚Xg\‚]g]‚Zg^‚_g_‚dg`‚bga‚hgb‚jgc‚kgd‚.ge‚qgf‚wgg‚xgh‚~gi‚gj‚’gk‚Ћgl‚Ÿgm‚Лgn‚Ќgo‚сgp‚уgq‚пgr‚вgs‚єgt‚ѓgu‚њgvƒ“gwƒgx‚ћgy‚љgz‚оg{ƒg|‚мg}ƒ g~‚йh!ƒ5h"ƒ4h#ƒh$ƒ2h%ƒ1h&ƒ@h'ƒ9h(ƒPh)ƒEh*ƒ/h+ƒ+h,ƒh-ƒh.ƒ…h/ƒšh0ƒЊh1ƒŸh2ƒЂh3ƒ–h4ƒ#h5ƒŽh6ƒ‡h7ƒŠh8ƒ|h9ƒЕh:ƒsh;ƒuh<ƒ h=ƒ‰h>ƒЈh?ƒєh@„hAƒыhBƒЮhCƒ§hD„hEƒиhF„ hGƒСhHƒїhI„hJƒрhKƒђhL„ hM„"hN„ hOƒНhP„8hQ…hRƒћhS„mhT„*hU„† i?†i@† iA…ўiB…њiC†iD†"iE†iF†0iG†?iH†MiINUiJ†TiK†_iL†giM†qiN†“iO†ЃiP†ЉiQ†ЊiR†‹iS†ŒiT†ЖiU†ЏiV†ФiW†ЦiX†АiY†ЩiZˆ#i[†Ћi\†дi]†оi^†щi_†ьi`†пia†лib†яic‡id‡ie‡if‡ig‡ih†ћii‡ij‡ ik‡ il†љim‡ in‡4io‡?ip‡7iq‡;ir‡%is‡)it‡iu‡`iv‡_iw‡xix‡Liy‡Niz‡ti{‡Wi|‡hi}‡ni~‡Yj!‡Sj"‡cj#‡jj$ˆj%‡Ђj&‡Ÿj'‡‚j(‡Џj)‡Ыj*‡Нj+‡Рj,‡аj-–жj.‡Ћj/‡Фj0‡Гj1‡Чj2‡Цj3‡Лj4‡яj5‡ђj6‡рj7ˆj8ˆ j9‡ўj:‡іj;‡їj<ˆj=‡вj>ˆj?ˆj@ˆjAˆ"jBˆ!jCˆ1jDˆ6jEˆ9jFˆ'jGˆ;jHˆDjIˆBjJˆRjKˆYjLˆ^jMˆbjNˆkjOˆjPˆ~jQˆžjRˆujSˆ}jTˆЕjUˆrjVˆ‚jWˆ—jXˆ’jYˆЎjZˆ™j[ˆЂj\ˆj]ˆЄj^ˆАj_ˆПj`ˆБjaˆУjbˆФjcˆдjdˆиjeˆйjfˆнjgˆљjh‰jiˆќjjˆєjkˆшjlˆђjm‰jn‰ jo‰ jp‰jq‰Cjr‰js‰%jt‰*ju‰+jv‰Ajw‰Djx‰;jy‰6jz‰8j{‰Lj|‰j}‰`j~‰^k!‰fk"‰dk#‰mk$‰jk%‰ok&‰tk'‰wk(‰~k)‰ƒk*‰ˆk+‰Šk,‰“k-‰˜k.‰Ёk/‰Љk0‰Іk1‰Ќk2‰Џk3‰Вk4‰Кk5‰Нk6‰Пk7‰Рk8‰кk9‰мk:‰нk;‰чk<‰єk=‰јk>Šk?Šk@ŠkAŠ kBŠkCŠkDŠ%kEŠ6kFŠAkGŠ[kHŠRkIŠFkJŠHkKŠ|kLŠmkMŠlkNŠbkOŠ…kPŠ‚kQŠ„kRŠЈkSŠЁkTŠ‘kUŠЅkVŠІkWŠškXŠЃkYŠФkZŠЭk[ŠТk\Šкk]Šыk^Šѓk_Šчk`ŠфkaŠёkb‹kcŠрkdŠтkeŠїkfŠоkgŠлkh‹ ki‹kj‹kkŠсkl‹km‹kn‹ko‹ kp‹3kq—Ћkr‹&ks‹+kt‹>ku‹(kv‹Akw‹Lkx‹Oky‹Nkz‹Ik{‹Vk|‹[k}‹Zk~‹kl!‹_l"‹ll#‹ol$‹tl%‹}l&‹€l'‹Œl(‹Žl)‹’l*‹“l+‹–l,‹™l-‹šl.Œ:l/ŒAl0Œ?l1ŒHl2ŒLl3ŒNl4ŒPl5ŒUl6Œbl7Œll8Œxl9Œzl:Œ‚l;Œ‰l<Œ…l=ŒŠl>Œl?ŒŽl@Œ”lAŒ|lBŒ˜lCblDŒ­lEŒЊlFŒНlGŒВlHŒГlIŒЎlJŒЖlKŒШlLŒСlMŒфlNŒуlOŒкlPŒ§lQŒњlRŒћlSlTlU lVlWlX lYlZŸNl[l\ŒЭl]l^l_gl`mlaqlbslcld™leТlfОlgКlhЯliкljжlkЬllлlmЫlnъloыlpпlqуlrќlsŽltŽ luџlvŽlwŽlxŽlyŽlzŽBl{Ž5l|Ž0l}Ž4l~ŽJm!ŽGm"ŽIm#ŽLm$ŽPm%ŽHm&ŽYm'Ždm(Ž`m)Ž*m*Žcm+ŽUm,Žvm-Žrm.Ž|m/Žm0Ž‡m1Ž…m2Ž„m3Ž‹m4ŽŠm5Ž“m6Ž‘m7Ž”m8Ž™m9ŽЊm:ŽЁm;ŽЌm<ŽАm=ŽЦm>ŽБm?ŽОm@ŽХmAŽШmBŽЫmCŽлmDŽуmEŽќmFŽћmGŽыmHŽўmI mJmKmLmMmNmOmPmQmR mS&mT3mU;mV9mWEmXBmY>mZLm[Im\Fm]Nm^Wm_\m`bmacmbdmcœmdŸmeЃmf­mgЏmhЗmiкmjхmkтmlъmmяmn‡moєmpmqљmrњmsmtmu!mv mwmxmy mz'm{6m|5m}9m~јn!On"Pn#Qn$Rn%n&In'>n(Vn)Xn*^n+hn,on-vn.–Јn/rn0‚n1}n2n3€n4Šn5‰n6n7Јn8Џn9Бn:Еn;тn<фn=bHn>лn?‘n@‘nA‘nB‘2nC‘0nD‘JnE‘VnF‘XnG‘cnH‘enI‘inJ‘snK‘rnL‘‹nM‘‰nN‘‚nO‘ЂnP‘ЋnQ‘ЏnR‘ЊnS‘ЕnT‘ДnU‘КnV‘РnW‘СnX‘ЩnY‘ЫnZ‘аn[‘жn\‘пn]‘сn^‘лn_‘ќn`‘ѕna‘іnb’nc‘џnd’ne’,nf’ng’nh’^ni’Wnj’Enk’Inl’dnm’Hnn’•no’?np’Knq’Pnr’œns’–nt’“nu’›nv’Znw’Яnx’Йny’Зnz’щn{“n|’њn}“Dn~“.o!“o"“"o#“o$“#o%“:o&“5o'“;o(“\o)“`o*“|o+“no,“Vo-“Аo.“Ќo/“­o0“”o1“Йo2“жo3“зo4“шo5“хo6“иo7“Уo8“нo9“аo:“Шo;“фo<”o=”o>”o?”o@”oA”oB”6oC”+oD”5oE”!oF”:oG”AoH”RoI”DoJ”[oK”`oL”boM”^oN”joO’)oP”poQ”uoR”woS”}oT”ZoU”|oV”~oW”oX”oY•‚oZ•‡o[•Šo\•”o]•–o^•˜o_•™o`• oa•Јob•Їoc•­od•Мoe•Лof•Йog•Оoh•Ъoioіoj•Уok•Эol•Ьom•еon•дoo•жop•мoq•сor•хos•тot–!ou–(ov–.ow–/ox–Boy–Loz–Oo{–Ko|–wo}–\o~–^p!–]p"–_p#–fp$–rp%–lp&–p'–˜p(–•p)–—p*–Њp+–Їp,–Бp-–Вp.–Аp/–Дp0–Жp1–Иp2–Йp3–Юp4–Ыp5–Щp6–Эp7‰Mp8–мp9— p:–еp;–љp<—p=—p>—p?—p@—pA—pB—pC—pD—pE—$pF—*pG—0pH—9pI—=pJ—>pK—DpL—FpM—HpN—BpO—IpP—\pQ—`pR—dpS—fpT—hpURвpV—kpW—qpX—ypY—…pZ—|p[—p\—zp]—†p^—‹p_—p`—pa—œpb—Јpc—Іpd—Ѓpe—Гpf—Дpg—Уph—Цpi—Шpj—Ыpk—мpl—эpmŸOpn—ђpozпpp—іpq—ѕpr˜ps˜ pt˜8pu˜$pv˜!pw˜7px˜=py˜Fpz˜Op{˜Kp|˜kp}˜op~˜pq!˜qq"˜tq#˜sq$˜Њq%˜Џq&˜Бq'˜Жq(˜Фq)˜Уq*˜Цq+˜щq,˜ыq-™q.™ q/™q0™q1™q2™!q3™q4™q5™$q6™ q7™,q8™.q9™=q:™>q;™Bq<™Iq=™Eq>™Pq?™Kq@™QqA™RqB™LqC™UqD™—qE™˜qF™ЅqG™­qH™ЎqI™МqJ™пqK™лqL™нqM™иqN™бqO™эqP™юqQ™ёqR™ђqS™ћqT™јqUšqVšqWšqX™тqYšqZš+q[š7q\šEq]šBq^š@q_šCq`š>qašUqbšMqcš[qdšWqeš_qfšbqgšeqhšdqišiqjškqkšjqlš­qmšАqnšМqošРqpšЯqqšбqršгqsšдqtšоqušпqvšтqwšуqxšцqyšяqzšыq{šюq|šєq}šёq~šїr!šћr"›r#›r$›r%›r&›"r'›#r(›%r)›'r*›(r+›)r,›*r-›.r.›/r/›2r0›Dr1›Cr2›Or3›Mr4›Nr5›Qr6›Xr7›tr8›“r9›ƒr:›‘r;›–r<›—r=›Ÿr>› r?›Јr@›ДrA›РrB›ЪrC›ЙrD›ЦrE›ЯrF›бrG›вrH›уrI›тrJ›фrK›дrL›сrMœ:rN›ђrO›ёrP›№rQœrRœrSœ rTœrUœ rVœrWœrXœrYœ rZœr[œ.r\œr]œ%r^œ$r_œ!r`œ0raœGrbœ2rcœFrdœ>reœZrfœ`rgœgrhœvriœxrjœчrkœьrlœ№rm rnroœыrprqrr*rs&rtЏru#rvrwDrxryrzAr{?r|>r}Fr~Hs!]s"^s#ds$Qs%Ps&Ys'rs(‰s)‡s*Ћs+os,zs-šs.Єs/Љs0Вs1Фs2Сs3Лs4Иs5Кs6Цs7Яs8Тs9йs:гs;јs<цs=эs>яs?§s@žsAžsBžsCžusDžysEž}sFžsGžˆsHž‹sIžŒsJž’sKž•sLž‘sMžsNžЅsOžЉsPžИsQžЊsRž­sS—asTžЬsUžЮsVžЯsWžаsXžдsYžмsZžоs[žнs\žрs]žхs^žшs_žяs`žєsažіsbžїscžљsdžћsežќsfž§sgŸshŸsivЗsjŸskŸ!slŸ,smŸ>snŸJsoŸRspŸTsqŸcsrŸ_ssŸ`stŸasuŸfsvŸgswŸlsxŸjsyŸwszŸrs{Ÿvs|Ÿ•s}Ÿœs~Ÿ t!X/t"iЧt#Yt$tdt%Qмt&q™ecl-16.1.2/contrib/encodings/JISX0212.BIN000066400000000000000000000573161266352375300174210ustar00rootroot00000000000000/f"/и"0Ч"1И"2й"3н"4Џ"5л"6к"7џ^"8„"9…"BЁ"CІ"DП"kК"lЊ"mЉ"nЎ"o!""pЄ"q!&a†&bˆ&c‰&dŠ&eЊ&gŒ&iŽ&jЋ&l&qЌ&r­&sЎ&tЏ&uЪ&v&wЬ&xТ&yЭ&zЫ&{А&|Ю'B'C'D'E'F'G'H'I 'J 'K 'L 'M'N'rR'sS'tT'uU'vV'wW'xX'yY'zZ'{['|\'}^'~_)!Ц)")$&)&2)(A))?)+J),и)-R)/f)0о)Aц)B)C№)D')E1)F3)G8)HB)I@)JI)KK)Lј)MS)Nп)Og)Pў*!С*"Р*#Ф*$Т*%*&Э*'*(*)Х**У*+*,*- *.Ч*/ *0*1Щ*2Ш*3Ы*4Ъ*5*6*7*8*:*;*<"*= *>$*?Э*@Ь*AЯ*BЮ*CЯ*D0*E**F.*G(*H4*I6*J9*K=*L;*MC*NG*OE*Pб*Qг*Rв*Sж*Tд*Uб*VP*WL*Xе*YT*ZX*[V*\Z*]\*^`*_^*`d*ab*bк*cй*dм*eл*fl*gг*hp*ij*jr*kn*lh*mз*nл*oй*pе*qt*rн*sx*tv*uy*v}*w{+!с+"р+#ф+$т+%+&Ю+'+(+)х+*у+++, +- +.ч+/ +0+1щ+2ш+3ы+4ъ+5+6+7+8+9ѕ+:+;+=!+>%+?э+@ь+Aя+Bю+Cа+E++F/+G)+H5+I7+J:+K>+L<+MD+NH+OF+Pё+Qѓ+Rђ+Sі+Tє+Uв+VQ+WM+Xѕ+YU+ZY+[W+\[+]]+^a+__+`e+ac+bњ+cљ+dќ+eћ+fm+gд+hq+ik+js+ko+li+mи+nм+oк+pж+qu+r§+sџ+tw+uz+v~+w|0!N0"N0#N0$N 0%N0&N0'N#0(N$0)N(0*N+0+N.0,N/0-N00.N50/N@00NA01ND02NG03NQ04NZ05N\06Nc07Nh08Ni09Nt0:Nu0;Ny0N–0?N—0@N0ANЏ0BNЙ0CNУ0DNа0ENк0FNл0GNр0HNс0INт0JNш0KNя0LNё0MNѓ0NNѕ0ON§0PNў0QNџ0RO0SO0TO0UO0VO 0WO 0XO0YO0ZO0[O0\O0]O.0^O10_O`0`O30aO50bO70cO90dO;0eO>0fO@0gOB0hOH0iOI0jOK0kOL0lOR0mOT0nOV0oOX0pO_0qOc0rOj0sOl0tOn0uOq0vOw0wOx0xOy0yOz0zO}0{O~0|O0}O‚0~O„1!O…1"O‰1#OŠ1$OŒ1%OŽ1&O1'O’1(O“1)O”1*O—1+O™1,Oš1-Ož1.OŸ1/OВ10OЗ11OЙ12OЛ13OМ14OН15OО16OР17OС18OХ19OЦ1:OШ1;OЩ1OЭ1?OЯ1@Oв1AOм1BOр1COт1DO№1EOђ1FOќ1GO§1HOџ1IP1JP1KP1LP1MP 1NP 1OP1PP1QP1RP1SP1TP1UP1VP1WP1XP"1YP'1ZP.1[P01\P21]P31^P51_P@1`PA1aPB1bPE1cPF1dPJ1ePL1fPN1gPQ1hPR1iPS1jPW1kPY1lP_1mP`1nPb1oPc1pPf1qPg1rPj1sPm1tPp1uPq1vP;1wP1xPƒ1yP„1zP†1{PŠ1|PŽ1}P1~P2!P’2"P“2#P”2$P–2%P›2&Pœ2'Pž2(PŸ2)P 2*PЁ2+PЂ2,PЊ2-PЏ2.PА2/PЙ20PК21PН22PР23PУ24PФ25PЧ26PЬ27PЮ28Pа29Pг2:Pд2;Pи2Pп2?Pт2@Pф2APц2BPш2CPщ2DPя2EPё2FPі2GPњ2HPў2IQ2JQ2KQ2LQ2MQ 2NQ 2OQ 2PQ2QPђ2RQ2SQ2TQ2UQ2VQ2WQ2XQ2YQ#2ZQ'2[Q(2\Q,2]Q-2^Q/2_Q12`Q32aQ42bQ52cQ82dQ92eQB2fQJ2gQO2hQS2iQU2jQW2kQX2lQ_2mQd2nQf2oQ~2pQƒ2qQ„2rQ‹2sQŽ2tQ˜2uQ2vQЁ2wQЃ2xQ­2yQИ2zQК2{QМ2|QО2}QП2~QТ3!QШ3"QЯ3#Qб3$Qв3%Qг3&Qе3'Qи3(Qо3)Qт3*Qх3+Qю3,Qђ3-Qѓ3.Qє3/Qї30R31R32R33R34R35R36R37R38R"39R(3:R13;R23RE3?RI3@RU3ARW3BRX3CRZ3DR\3ER_3FR`3GRa3HRf3IRn3JRw3KRx3LRy3MR€3NR‚3OR…3PRŠ3QRŒ3RR“3SR•3TR–3UR—3VR˜3WRš3XRœ3YRЄ3ZRЅ3[RІ3\RЇ3]RЏ3^RА3_RЖ3`RЗ3aRИ3bRК3cRЛ3dRН3eRР3fRФ3gRЦ3hRШ3iRЬ3jRЯ3kRб3lRд3mRж3nRл3oRм3pRс3qRх3rRш3sRщ3tRъ3uRь3vR№3wRё3xRє3yRі3zRї3{S3|S3}S 3~S 4!S 4"S4#S4$S4%S4&S4'S4(S4)S%4*S'4+S(4,S)4-S+4.S,4/S-40S041S242S543S<44S=45S>46SB47SL48SK49SY4:S[4;Sa4Sl4?Sm4@Sr4ASy4BS~4CSƒ4DS‡4ESˆ4FSŽ4GS“4HS”4IS™4JS4KSЁ4LSЄ4MSЊ4NSЋ4OSЏ4PSВ4QSД4RSЕ4SSЗ4TSИ4USК4VSН4WSР4XSХ4YSЯ4ZSв4[Sг4\Sе4]Sк4^Sн4_Sо4`Sр4aSц4bSч4cSѕ4dT4eT4fT4gT!4hT'4iT(4jT*4kT/4lT14mT44nT54oTC4pTD4qTG4rTM4sTO4tT^4uTb4vTd4wTf4xTg4yTi4zTk4{Tm4|Tn4}Tt4~T5!T5"Tƒ5#T…5$Tˆ5%T‰5&T5'T‘5(T•5)T–5*Tœ5+TŸ5,TЁ5-TІ5.TЇ5/TЉ50TЊ51T­52TЎ53TБ54TЗ55TЙ56TК57TЛ58TП59TЦ5:TЪ5;TЭ5Tъ5?Tь5@Tя5ATі5BTќ5CTў5DTџ5EU5FU5GU5HU5IU 5JU 5KU 5LU5MU5NU*5OU+5PU25QU55RU65SU;5TU<5UU=5VUA5WUG5XUI5YUJ5ZUM5[UP5\UQ5]UX5^UZ5_U[5`U^5aU`5bUa5cUd5dUf5eU5fU5gU‚5hU†5iUˆ5jUŽ5kU5lU‘5mU’5nU“5oU”5pU—5qUЃ5rUЄ5sU­5tUВ5uUП5vUС5wUУ5xUЦ5yUЩ5zUЫ5{UЬ5|UЮ5}Uб5~Uв6!Uг6"Uз6#Uи6$Uл6%Uо6&Uт6'Uщ6(Uі6)Uџ6*V6+V6,V 6-V 6.V6/V60V61V62V63V64V,65V066V367V568V769V96:V;6;V<6V@6?VA6@VC6AVD6BVF6CVI6DVK6EVM6FVO6GVT6HV^6IV`6JVa6KVb6LVc6MVf6NVi6OVm6PVo6QVq6RVr6SVu6TV„6UV…6VVˆ6WV‹6XVŒ6YV•6ZV™6[Vš6\V6]Vž6^VŸ6_VІ6`VЇ6aVЈ6bVЉ6cVЋ6dVЌ6eV­6fVБ6gVГ6hVЗ6iVО6jVХ6kVЩ6lVЪ6mVЫ6nVЯ6oVа6pVЬ6qVЭ6rVй6sVм6tVн6uVп6vVс6wVф6xVх6yVц6zVч6{Vш6|Vё6}Vы6~Vэ7!Vі7"Vї7#W7$W7%W7&W 7'W 7(W7)W7*W7+W7,W7-W 7.W"7/W#70W$71W%72W)73W*74W,75W.76W/77W378W479W=7:W>7;W?7WL7?WM7@WR7AWb7BWe7CWg7DWh7EWk7FWm7GWn7HWo7IWp7JWq7KWs7LWt7MWu7NWw7OWy7PWz7QW{7RW|7SW~7TW7UWƒ7VWŒ7WW”7XW—7YW™7ZWš7[Wœ7\W7]Wž7^WŸ7_WЁ7`W•7aWЇ7bWЈ7cWЉ7dWЌ7eWИ7fWН7gWЧ7hWШ7iWЬ7jWЯ7kWе7lWн7mWо7nWф7oWц7pWч7qWщ7rWэ7sW№7tWѕ7uWі7vWј7wW§7xWў7yWџ7zX7{X7|X7}X 7~Wс8!X 8"X 8#X8$X8%X8&X 8'X&8(X'8)X-8*X28+X98,X?8-XI8.XL8/XM80XO81XP82XU83X_84Xa85Xd86Xg87Xh88Xx89X|8:X8;X€8Xˆ8?X‰8@XŠ8AXŒ8BX8CX8DX8EX”8FX–8GX8HX 8IXЁ8JXЂ8KXІ8LXЉ8MXБ8NXВ8OXФ8PXМ8QXТ8RXШ8SXЭ8TXЮ8UXа8VXв8WXд8XXж8YXк8ZXн8[Xс8\Xт8]Xщ8^Xѓ8_Y8`Y8aY 8bY 8cY8dY8eY8f†A8gY8hY!8iY#8jY$8kY(8lY/8mY08nY38oY58pY68qY?8rYC8sYF8tYR8uYS8vYY8wY[8xY]8yY^8zY_8{Ya8|Yc8}Yk8~Ym9!Yo9"Yr9#Yu9$Yv9%Yy9&Y{9'Y|9(Y‹9)YŒ9*YŽ9+Y’9,Y•9-Y—9.YŸ9/YЄ90YЇ91Y­92YЎ93YЏ94YА95YГ96YЗ97YК98YМ99YС9:YУ9;YФ9YЭ9?Yв9@Yн9AYо9BYп9CYу9DYф9EYч9FYю9GYя9HYё9IYђ9JYє9KYї9LZ9MZ9NZ 9OZ 9PZ9QZ9RZ9SZ9TZ#9UZ$9VZ'9WZ(9XZ*9YZ-9ZZ09[ZD9\ZE9]ZG9^ZH9_ZL9`ZP9aZU9bZ^9cZc9dZe9eZg9fZm9gZw9hZz9iZ{9jZ~9kZ‹9lZ9mZ“9nZ–9oZ™9pZœ9qZž9rZŸ9sZ 9tZЂ9uZЇ9vZЌ9wZБ9xZВ9yZГ9zZЕ9{ZИ9|ZК9}ZЛ9~ZП:!ZФ:"ZЦ:#ZШ:$ZЯ:%Zк:&Zм:'Zр:(Zх:)Zъ:*Zю:+Zѕ:,Zі:-Z§:.[:/[:0[:1[:2[4:3[:4[:5[:6[!:7[%:8[-:9[8::[A:;[K:<[L:=[R:>[V:?[^:@[h:A[n:B[o:C[|:D[}:E[~:F[:G[:H[„:I[†:J[Š:K[Ž:L[:M[‘:N[“:O[”:P[–:Q[Ј:R[Љ:S[Ќ:T[­:U[Џ:V[Б:W[В:X[З:Y[К:Z[М:[[Р:\[С:][Э:^[Я:_[ж:`[з:a[и:b[й:c[к:d[р:e[я:f[ё:g[є:h[§:i\ :j\:k\:l\:m\#:n\&:o\):p\+:q\,:r\.:s\0:t\2:u\5:v\6:w\Y:x\Z:y\\:z\b:{\c:|\g:}\h:~\i;!\m;"\p;#\t;$\u;%\z;&\{;'\|;(\};)\‡;*\ˆ;+\Š;,\;-\’;.\;/\Ÿ;0\ ;1\Ђ;2\Ѓ;3\І;4\Њ;5\В;6\Д;7\Е;8\К;9\Щ;:\Ы;;\в;<\н;=\з;>\ю;?\ё;@\ђ;A\є;B];C];D] ;E];F]+;G]#;H]$;I]&;J]';K]1;L]4;M]9;N]=;O]?;P]B;Q]C;R]F;S]H;T]U;U]Q;V]Y;W]J;X]_;Y]`;Z]a;[]b;\]d;]]j;^]m;_]p;`]y;a]z;b]~;c];d];e]ƒ;f]ˆ;g]Š;h]’;i]“;j]”;k]•;l]™;m]›;n]Ÿ;o] ;p]Ї;q]Ћ;r]А;s]Д;t]И;u]Й;v]У;w]Ч;x]Ы;y]а;z]Ю;{]и;|]й;}]р;~]ф<2^K<3^P<4^I<5^Q<6^V<7^X<8^[<9^\<:^^<;^h<<^j<=^k<>^l_б=?_в=@_г=A_д=B_о=C_с=D_т=E_ш=F_щ=G_ъ=H_ь=I_э=J_ю=K_я=L_ђ=M_ѓ=N_і=O_њ=P_ќ=Q`=R` =S` =T`=U`=V`=W`=X`=Y`=Z`$=[`-=\`3=]`5=^`@=_`G=``H=a`I=b`L=c`Q=d`T=e`V=f`W=g`]=h`a=i`g=j`q=k`~=l`=m`‚=n`†=o`ˆ=p`Š=q`Ž=r`‘=s`“=t`•=u`˜=v`=w`ž=x`Ђ=y`Є=z`Ѕ={`Ј=|`А=}`Б=~`З>!`Л>"`О>#`Т>$`Ф>%`Ш>&`Щ>'`Ъ>(`Ы>)`Ю>*`Я>+`д>,`е>-`й>.`л>/`н>0`о>1`т>2`х>3`ђ>4`ѕ>5`ј>6`ќ>7`§>8a>9a>:a >;a >=a>>a>?a>@a>Aa>Ba>Ca>Da>Ea>Fa">Ga*>Ha+>Ia0>Ja1>Ka5>La6>Ma7>Na9>OaA>PaE>QaF>RaI>Sa^>Ta`>Ual>Var>Wax>Xa{>Ya|>Za>[a€>\a>]aƒ>^a„>_a‹>`a>aa’>ba“>ca—>da˜>eaœ>fa>gaŸ>ha >iaЅ>jaЈ>kaЊ>la­>maИ>naЙ>oaМ>paР>qaС>raТ>saЮ>taЯ>uaе>vaм>waн>xaо>yaп>zaс>{aт>|aч>}aщ>~aх?!aь?"aэ?#aя?$b?%b?&b?'b?(b?)b?*b?+b ?,b"?-b#?.b'?/b)?0b+?1b9?2b=?3bB?4bC?5bD?6bF?7bL?8bP?9bQ?:bR?;bT?b\??bd?@bm?Abo?Bbs?Cbz?Db}?Eb?FbŽ?Gb?Hb?IbІ?JbЈ?KbГ?LbЖ?MbЗ?NbК?ObО?PbП?QbФ?RbЮ?Sbе?Tbж?Ubк?Vbъ?Wbђ?Xbє?Ybќ?Zb§?[c?\c?]c ?^c ?_c ?`c?ac?bc?cc?dc)?ec*?fc-?gc5?hc6?ic9?jccр@?cх@@cъ@Acь@Bcђ@Ccѓ@Dcѕ@Ecј@Fcљ@Gd @Hd @Id@Jd@Kd@Ld@Md@Nd @Od"@Pd$@Qd%@Rd)@Sd*@Td/@Ud0@Vd5@Wd=@Xd?@YdK@ZdO@[dQ@\dR@]dS@^dT@_dZ@`d[@ad\@bd]@cd_@dd`@eda@fdc@gdm@hds@idt@jd{@kd}@ld…@md‡@nd@od@pd‘@qd˜@rd™@sd›@td@udŸ@vdЁ@wdЃ@xdІ@ydЈ@zdЌ@{dГ@|dН@}dО@~dПA!dФA"dЩA#dЪA$dЫA%dЬA&dЮA'dаA(dбA)dеA*dзA+dфA,dхA-dщA.dъA/dэA0d№A1dѕA2dїA3dћA4dџA5eA6eA7eA8e A9e A:eA;eAeA?eA@eAAeABe"ACe&ADe)AEe.AFe1AGe:AHefaB?fћB@fjBAfkBBflBCf~BDfsBEfuBFfBGfwBHfxBIfyBJf{BKf€BLf|BMf‹BNfŒBOfBPfBQf’BRf™BSfšBTf›BUfœBVfŸBWf BXfЄBYf­BZfБB[fВB\fЕB]fЛB^fПB_fРB`fТBafУBbfШBcfЬBdfЮBefЯBffдBgfлBhfпBifшBjfыBkfьBlfюBmfњBngBogBpgBqgBrgBsgBtg Bug"Bvg3Bwg>BxgEBygGBzgHB{gLB|gTB}gUB~g]C!gfC"glC#gnC$gtC%gvC&g{C'gC(g„C)gŽC*gC+g‘C,g“C-g–C.g˜C/g™C0g›C1gАC2gБC3gВC4gЕC5gЛC6gМC7gНC8gљC9gРC:gТC;gУCgЩC?gвC@gзCAgйCBgмCCgсCDgцCEg№CFgђCGgіCHgїCIhRCJhCKhCLhCMhCNh(COh'CPh,CQh-CRh/CSh0CTh1CUh3CVh;CWh?CXhDCYhECZhJC[hLC\hUC]hWC^hXC_h[C`hkCahnCbhoCchpCdhqCehrCfhuCghyChhzCih{Cjh|Ckh‚Clh„Cmh†CnhˆCoh–Cph˜CqhšCrhœCshЁCthЃCuhЅCvhЉCwhЊCxhЎCyhВCzhЛC{hХC|hШC}hЬC~hЯD!hаD"hбD#hгD$hжD%hйD&hмD'hнD(hхD)hшD*hъD+hыD,hьD-hэD.h№D/hёD0hѕD1hіD2hћD3hќD4h§D5iD6i D7i D8iD9iD:iD;iDi3D?i5D@i8DAi;DBiBDCiEDDiIDEiNDFiWDGi[DHicDIidDJieDKifDLihDMiiDNilDOipDPiqDQirDRizDSi{DTiDUi€DViDWi’DXi–DYi˜DZiЁD[iЅD\iІD]iЈD^iЋD_i­D`iЏDaiЗDbiИDciКDdiМDeiХDfiШDgiбDhiжDiiзDjiтDkiхDliюDmiяDniёDoiѓDpiѕDqiўDrjDsjDtjDujDvjDwjDxjDyjDzj D{j$D|j(D}j0D~j2E!j4E"j7E#j;E$j>E%j?E&jEE'jFE(jIE)jJE*jNE+jPE,jQE-jRE.jUE/jVE0j[E1jdE2jgE3jjE4jqE5jsE6j~E7jE8jƒE9j†E:j‡E;j‰Ej›E?jE@jžEAjŸEBjЅECjЋEDjЏEEjАEFjБEGjДEHjНEIjОEJjПEKjЦELjЩEMjШENjЬEOjаEPjдEQjеERjжESjмETjнEUjфEVjчEWjьEXj№EYjёEZjђE[jќE\j§E]kE^kE_kE`kEak EbkEckEdkEekEfkEgkEhk$Eik(Ejk+Ekk,Elk/Emk5Enk6Eok;Epk?EqkFErkJEskMEtkREukVEvkXEwk]Exk`EykgEzkkE{knE|kpE}kuE~k}F!k~F"k‚F#k…F$k—F%k›F&kŸF'k F(kЂF)kЃF*kЈF+kЉF,kЌF-k­F.kЎF/kАF0kИF1kЙF2kНF3kОF4kУF5kФF6kЩF7kЬF8kжF9kкF:kсF;kуFkюF?kёF@kїFAkљFBkџFClFDlFElFFl FGl FHlFIlFJlFKlFLlFMl&FNl'FOl(FPl,FQl.FRl3FSl5FTl6FUl:FVl;FWl?FXlJFYlKFZlMF[lOF\lRF]lTF^lYF_l[F`l\FalkFblmFcloFdltFelvFflxFglyFhl{Fil…Fjl†Fkl‡Fll‰Fml”Fnl•Fol—Fpl˜FqlœFrlŸFslАFtlВFulДFvlТFwlЦFxlЭFylЯFzlаF{lбF|lвF}lдF~lжG!lкG"lмG#lрG$lчG%lщG&lыG'lьG(lюG)lђG*lєG+mG,mG-m G.mG/mG0mG1mG2mG3m&G4m'G5m(G6lgG7m.G8m/G9m1G:m9G;mm^G?m_G@maGAmeGBmgGCmoGDmpGEm|GFm‚GGm‡GHm‘GIm’GJm”GKm–GLm—GMm˜GNmЊGOmЌGPmДGQmЗGRmЙGSmНGTmПGUmФGVmШGWmЪGXmЮGYmЯGZmжG[mлG\mнG]mпG^mрG_mтG`mхGamщGbmяGcm№GdmєGemіGfmќGgnGhnGinGjn"Gkn'Gln2Gmn6Gnn9Gon;GpnnљH?nћH@n§HAoHBoHCo HDo HEo HFoHGoHHoHIoHJo&HKo)HLo*HMo/HNo0HOo3HPo6HQo;HRopUI?p]I@p^IApNIBpdICpeIDplIEpnIFpuIGpvIHp~IIpIJp…IKp†ILp”IMp•INp–IOp—IPp˜IQp›IRpЄISpЋITpАIUpБIVpДIWpЗIXpЪIYpбIZpгI[pдI\pеI]pжI^pиI_pмI`pфIapњIbqIcqIdqIeqIfqIgq Ihq IiqIjqIkq Ilq+Imq-Inq/Ioq0Ipq1Iqq8IrqAIsqEItqFIuqGIvqJIwqKIxqPIyqRIzqWI{qZI|q\I}q^I~q`J!qhJ"qyJ#q€J$q…J%q‡J&qŒJ'q’J(qšJ)q›J*q J+qЂJ,qЏJ-qАJ.qВJ/qГJ0qКJ1qПJ2qРJ3qСJ4qФJ5qЫJ6qЬJ7qгJ8qжJ9qйJ:qкJ;qмJrJ?rJ@rJAr JBrJCrJDrJErJFrJGr$JHr+JIr/JJr4JKr8JLr9JMrAJNrBJOrCJPrEJQrNJRrOJSrPJTrSJUrUJVrVJWrZJXr\JYr^JZr`J[rcJ\rhJ]rkJ^rnJ_roJ`rqJarwJbrxJcr{Jdr|JerJfr„Jgr‰JhrJirŽJjr“Jkr›JlrЈJmr­JnrЎJorБJprДJqrОJrrСJsrЧJtrЩJurЬJvrеJwrжJxrиJyrпJzrхJ{rѓJ|rєJ}rњJ~rћK!rўK"sK#sK$sK%sK&s K's K(sK)sK*sK+sK,sK-s"K.s$K/s'K0s(K1s,K2s1K3s2K4s5K5s:K6s;K7s=K8sCK9sMK:sPK;sRKs]K?s^K@s_KAs`KBsfKCsgKDsiKEskKFslKGsnKHsoKIsqKJswKKsyKLs|KMs€KNsKOsƒKPs…KQs†KRsŽKSsKTs“KUs•KVs—KWs˜KXsœKYsžKZsŸK[s K\sЂK]sЅK^sІK_sЊK`sЋKas­KbsЕKcsЗKdsЙKesМKfsНKgsПKhsХKisЦKjsЩKksЫKlsЬKmsЯKnsвKosгKpsжKqsйKrsнKssсKtsуKusцKvsчKwsщKxsєKysѕKzsїK{sљK|sњK}sћK~s§L!sџL"tL#tL$tL%tL&t L'tL(tL)tL*t$L+t&L,t(L-t)L.t*L/t+L0t,L1t-L2t.L3t/L4t0L5t1L6t9L7t@L8tCL9tDL:tFL;tGLtQL?tRL@tWLAt]LBtbLCtfLDtgLEthLFtkLGtmLHtnLItqLJtrLKt€LLtLMt…LNt†LOt‡LPt‰LQtLRtLSt‘LTt’LUt˜LVt™LWtšLXtœLYtŸLZt L[tЁL\tЃL]tІL^tЈL_tЉL`tЊLatЋLbtЎLctЏLdtБLetВLftЕLgtЙLhtЛLitПLjtШLktЩLltЬLmtаLntгLotиLptкLqtлLrtоLstпLttфLutшLvtъLwtыLxtяLytєLztњL{tћL|tќL}tџL~uM!uM"uM#uM$u M%u!M&u$M'u'M(u)M)u*M*u/M+u6M,u9M-u=M.u>M/u?M0u@M1uCM2uGM3uHM4uNM5uPM6uRM7uWM8u^M9u_M:uaM;uoMuzM?u{M@u|MAu}MBu~MCuMDu…MEuMFu’MGu“MHu•MIu™MJuœMKuЂMLuЄMMuДMNuКMOuПMPuРMQuСMRuФMSuЦMTuЬMUuЮMVuЯMWuзMXuмMYuпMZuрM[uсM\uфM]uчM^uьM_uюM`uяMauёMbuљMcvMdvMevMfvMgvMhvMiv Mjv MkvMlvMmvMnvMovMpvMqvMrvMsvMtvMuv#Mvv%Mwv&Mxv)Myv-Mzv2M{v3M|v5M}v8M~v9N!v:N"vv N?vЂN@vЃNAvЄNBvЅNCvІNDvЇNEvЈNFvЊNGv­NHvНNIvСNJvХNKvЩNLvЫNMvЬNNvЮNOvдNPvйNQvрNRvцNSvшNTvьNUv№NVvёNWvіNXvљNYvќNZwN[wN\w N]wN^wN_wN`wNawNbwNcwNdwNew"Nfw(Ngw-Nhw.Niw/Njw4Nkw5Nlw6Nmw9Nnw=Now>NpwBNqwENrwFNswJNtwMNuwNNvwONwwRNxwVNywWNzw\N{w^N|w_N}w`N~wbO!wdO"wgO#wjO$wlO%wpO&wrO'wsO(wtO)wzO*w}O+w€O,w„O-wŒO.wO/w”O0w•O1w–O2wšO3wŸO4wЂO5wЇO6wЊO7wЎO8wЏO9wБO:wЕO;wОOwбO?wвO@wеOAwйOBwоOCwпODwрOEwфOFwцOGwъOHwьOIw№OJwёOKwєOLwјOMwћONxOOxOPx OQx ORxOSxOTxOUx!OVx"OWx#OXx-OYx.OZx0O[x5O\x7O]xCO^xDO_xGO`xHOaxLObxNOcxROdx\Oex^Ofx`OgxaOhxcOixdOjxhOkxjOlxnOmxzOnx~OoxŠOpxOqx”Orx˜OsxЁOtxOuxžOvxŸOwxЄOxxЈOyxЌOzx­O{xАO|xБO}xВO~xГP!xЛP"xНP#xПP$xЧP%xШP&xЩP'xЬP(xЮP)xвP*xгP+xеP,xжP-xфP.xлP/xпP0xрP1xсP2xцP3xъP4xђP5xѓP6yP7xіP8xїP9xњP:xћP;xџPyP?yP@yPAyPByPCy PDy%PEy'PFy)PGy-PHy1PIy4PJy5PKy;PLy=PMy?PNyDPOyEPPyFPQyJPRyKPSyOPTyQPUyTPVyXPWy[PXy\PYygPZyiP[ykP\yrP]yyP^y{P_y|P`y~Pay‹PbyŒPcy‘Pdy“Pey”Pfy•Pgy–Phy˜Piy›PjyœPkyЁPlyЈPmyЉPnyЋPoyЏPpyБPqyДPryИPsyЛPtyТPuyФPvyЧPwyШPxyЪPyyЯPzyдP{yжP|yкP}yнP~yоQ!yрQ"yтQ#yхQ$yъQ%yыQ&yэQ'yёQ(yјQ)yќQ*zQ+zQ,zQ-z Q.z Q/z Q0zQ1zQ2zQ3zQ4z!Q5z'Q6z+Q7z-Q8z/Q9z0Q:z4Q;z5Qz:Q?zDQ@zEQAzGQBzHQCzLQDzUQEzVQFzYQGz\QHz]QIz_QJz`QKzeQLzgQMzjQNzmQOzuQPzxQQz~QRz€QSz‚QTz…QUz†QVzŠQWz‹QXzQYz‘QZz”Q[zžQ\z Q]zЃQ^zЌQ_zГQ`zЕQazЙQbzЛQczМQdzЦQezЩQfzЬQgzЮQhzбQizлQjzшQkzщQlzыQmzьQnzёQozєQpzћQqz§QrzўQs{Qt{Qu{Qv{#Qw{'Qx{)Qy{*Qz{+Q{{-Q|{.Q}{/Q~{0R!{1R"{4R#{=R${?R%{@R&{AR'{GR({NR){UR*{`R+{dR,{fR-{iR.{jR/{mR0{oR1{rR2{sR3{wR4{„R5{‰R6{ŽR7{R8{‘R9{–R:{›R;{žR<{ R={ЅR>{ЌR?{ЏR@{АRA{ВRB{ЕRC{ЖRD{КRE{ЛRF{МRG{НRH{ТRI{ХRJ{ШRK{ЪRL{дRM{жRN{зRO{йRP{кRQ{лRR{шRS{ъRT{ђRU{єRV{ѕRW{јRX{љRY{њRZ{ќR[{ўR\|R]|R^|R_|R`|Ra| Rb| Rc| Rd|Re|Rf|Rg|Rh| Ri|%Rj|&Rk|(Rl|,Rm|1Rn|3Ro|4Rp|6Rq|9Rr|:Rs|FRt|JRu|URv|QRw|RRx|SRy|YRz|ZR{|[R||\R}|]R~|^S!|aS"|cS#|gS$|iS%|mS&|nS'|pS(|rS)|yS*||S+|}S,|†S-|‡S.|S/|”S0|žS1| S2|ІS3|АS4|ЖS5|ЗS6|КS7|ЛS8|МS9|ПS:|ФS;|ЧS<|ШS=|ЩS>|ЭS?|ЯS@|гSA|дSB|еSC|зSD|йSE|кSF|нSG|цSH|щSI|ыSJ|ѕSK}SL}SM}SN} SO}SP}SQ}SR}SS}ST}SU}SV}#SW}&SX}*SY}-SZ}1S[}S^}@S_}AS`}GSa}HSb}MSc}QSd}SSe}WSf}YSg}ZSh}\Si}]Sj}eSk}gSl}jSm}pSn}xSo}zSp}{Sq}Sr}Ss}‚St}ƒSu}…Sv}†Sw}ˆSx}‹Sy}ŒSz}S{}‘S|}–S}}—S~}T!}žT"}ІT#}ЇT$}ЊT%}ГT&}ЖT'}ЗT(}ЙT)}ТT*}УT+}ФT,}ХT-}ЦT.}ЬT/}ЭT0}ЮT1}зT2}йT3~T4}тT5}хT6}цT7}ъT8}ыT9}эT:}ёT;}ѕT<}іT=}љT>}њT?~T@~TA~TB~TC~TD~TE~TF~ TG~'TH~(TI~,TJ~-TK~/TL~3TM~6TN~?TO~DTP~ETQ~GTR~NTS~PTT~RTU~XTV~_TW~aTX~bTY~eTZ~kT[~nT\~oT]~sT^~xT_~~T`~Ta~†Tb~‡Tc~ŠTd~Te~‘Tf~•Tg~˜Th~šTi~Tj~žTkTo?TpCTqDTrGTsOTtRTuSTv[Tw\Tx]TyaTzcT{dT|eT}fT~mU!qU"}U#~U$U%€U&‹U'U(U)U*‘U+–U,—U-œU.ЁU/ЂU0ІU1ЊU2­U3ДU4МU5ПU6РU7УU8ШU9ЮU:ЯU;лU<пU=уU>хU?шU@ьUAюUBяUCђUDњUE§UFўUGџUH€UI€UJ€ UK€ UL€UM€UN€UO€UP€UQ€UR€US€UT€UU€ UV€$UW€&UX€,UY€.UZ€0U[€4U\€5U]€7U^€9U_€:U`€Ub€@Uc€DUd€`Ue€dUf€fUg€mUh€qUi€uUj€Uk€ˆUl€ŽUm€œUn€žUo€ІUp€ЇUq€ЋUr€ИUs€ЙUt€ШUu€ЭUv€ЯUw€вUx€дUy€еUz€зU{€иU|€рU}€эU~€юV!€№V"€ђV#€ѓV$€іV%€љV&€њV'€ўV(V) V*V+V,V-V.V/ V0$V1'V2,V30V45V5:V6aV?gV@hVAiVBmVCoVDwVEVFVG„VH…VI†VJ‹VKŽVL–VM˜VN›VOžVPЂVQЎVRВVSДVTЛVUЫVVУVWХVXЪVYЮVZЯV[еV\зV]лV^нV_оV`сVaфVbыVcьVd№VeёVfђVgѕVhіViјVjљVk§VlџVm‚Vn‚Vo‚Vp‚Vq‚Vr‚Vs‚Vt‚Vu‚!Vv‚"Vw‚(Vx‚2Vy‚4Vz‚:V{‚CV|‚DV}‚EV~‚FW!‚KW"‚NW#‚OW$‚QW%‚VW&‚\W'‚`W(‚cW)‚gW*‚mW+‚tW,‚{W-‚}W.‚W/‚€W0‚W1‚ƒW2‚„W3‚‡W4‚‰W5‚ŠW6‚ŽW7‚‘W8‚”W9‚–W:‚˜W;‚šW<‚›W=‚ W>‚ЁW?‚ЃW@‚ЄWA‚ЇWB‚ЈWC‚ЉWD‚ЊWE‚ЎWF‚АWG‚ВWH‚ДWI‚ЗWJ‚КWK‚МWL‚ОWM‚ПWN‚ЦWO‚аWP‚еWQ‚кWR‚рWS‚тWT‚фWU‚шWV‚ъWW‚эWX‚яWY‚іWZ‚їW[‚§W\‚ўW]ƒW^ƒW_ƒW`ƒWaƒ Wbƒ WcƒTWdƒWeƒWfƒWgƒWhƒ!Wiƒ"Wjƒ,Wkƒ-Wlƒ.Wmƒ0Wnƒ3Woƒ7Wpƒ:WqƒƒSX?ƒшX@ƒъXAƒіXBƒјXCƒљXDƒќXE„XF„XG„ XH„XI„XJ„XK„XLƒ­XM„/XN„9XO„EXP„GXQ„HXR„JXS„MXT„OXU„QXV„RXW„VXX„XXY„YXZ„ZX[„\X\„`X]„dX^„eX_„gX`„jXa„pXb„sXc„tXd„vXe„xXf„|Xg„}Xh„Xi„…Xj„’Xk„“Xl„•Xm„žXn„ІXo„ЈXp„ЉXq„ЊXr„ЏXs„БXt„ДXu„КXv„НXw„ОXx„РXy„ТXz„ЧX{„ШX|„ЬX}„ЯX~„гY!„мY"„чY#„ъY$„яY%„№Y&„ёY'„ђY(„їY)…2Y*„њY+„ћY,„§Y-…Y.…Y/…Y0… Y1…Y2…Y3…Y4…Y5…"Y6…#Y7…$Y8…%Y9…'Y:…*Y;…+Y<…/Y=…3Y>…4Y?…6Y@…?YA…FYB…OYC…PYD…QYE…RYF…SYG…VYH…YYI…\YJ…]YK…^YL…_YM…`YN…aYO…bYP…dYQ…kYR…oYS…yYT…zYU…{YV…}YW…YX…YY……YZ…†Y[…‰Y\…‹Y]…ŒY^…Y_…“Y`…˜Ya…Yb…ŸYc… Yd…ЂYe…ЅYf…ЇYg…ДYh…ЖYi…ЗYj…ИYk…МYl…НYm…ОYn…ПYo…ТYp…ЧYq…ЪYr…ЫYs…ЮYt…­Yu…иYv…кYw…пYx…рYy…цYz…шY{…эY|…ѓY}…іY~…ќZ!…џZ"†Z#†Z$†Z%† Z&†Z'†Z(†Z)†Z*†Z+†Z,†Z-†Z.†!Z/†'Z0†)Z1†6Z2†8Z3†:Z4††YZ?†]Z@†`ZA†aZB†bZC†cZD†dZE†iZF†lZG†oZH†uZI†vZJ†wZK†zZL†ZM†‘ZN†–ZO†˜ZP†šZQ†œZR†ЁZS†ІZT†ЇZU†ЈZV†­ZW†БZX†ГZY†ДZZ†ЕZ[†ЗZ\†ИZ]†ЙZ^†ПZ_†РZ`†СZa†УZb†ХZc†бZd†вZe†еZf†зZg†кZh†мZi†рZj†уZk†хZl†чZm†ˆZn†њZo†ќZp†§Zq‡Zr‡Zs‡Zt‡ Zu‡Zv‡Zw‡Zx‡Zy‡Zz‡Z{‡Z|‡Z}‡!Z~‡#[!‡(["‡.[#‡/[$‡1[%‡2[&‡9['‡:[(‡<[)‡=[*‡>[+‡@[,‡C[-‡E[.‡M[/‡X[0‡][1‡a[2‡d[3‡e[4‡o[5‡q[6‡r[7‡{[8‡ƒ[9‡„[:‡…[;‡†[<‡‡[=‡ˆ[>‡‰[?‡‹[@‡Œ[A‡[B‡“[C‡•[D‡—[E‡˜[F‡™[G‡ž[H‡ [I‡Ѓ[J‡Ї[K‡Ќ[L‡­[M‡Ў[N‡Б[O‡Е[P‡О[Q‡П[R‡С[S‡Ш[T‡Щ[U‡Ъ[V‡Ю[W‡е[X‡ж[Y‡й[Z‡к[[‡м[\‡п[]‡т[^‡у[_‡ф[`‡ъ[a‡ы[b‡э[c‡ё[d‡ѓ[e‡ј[f‡њ[g‡џ[hˆ[iˆ[jˆ[kˆ [lˆ [mˆ [nˆ[oˆ[pˆ[qˆ[rˆ[sˆ[tˆ[uˆˆ[wˆ[xˆ[yˆ([zˆ-[{ˆ.[|ˆ0[}ˆ2[~ˆ5\!ˆ:\"ˆ<\#ˆA\$ˆC\%ˆE\&ˆH\'ˆI\(ˆJ\)ˆK\*ˆN\+ˆQ\,ˆU\-ˆV\.ˆX\/ˆZ\0ˆ\\1ˆ_\2ˆ`\3ˆd\4ˆi\5ˆq\6ˆy\7ˆ{\8ˆ€\9ˆ˜\:ˆš\;ˆ›\<ˆœ\=ˆŸ\>ˆ \?ˆЈ\@ˆЊ\AˆК\BˆН\CˆО\DˆР\EˆЪ\FˆЫ\GˆЬ\HˆЭ\IˆЮ\Jˆб\Kˆв\Lˆг\Mˆл\Nˆо\Oˆч\Pˆя\Qˆ№\Rˆё\Sˆѕ\Tˆї\U‰\V‰\W‰ \X‰\Y‰\Z‰\[‰\\‰\]‰\^‰\_‰\`‰ \a‰&\b‰'\c‰(\d‰0\e‰1\f‰2\g‰5\h‰9\i‰:\j‰>\k‰@\l‰B\m‰E\n‰F\o‰I\p‰O\q‰R\r‰W\s‰Z\t‰[\u‰\\v‰a\w‰b\x‰c\y‰k\z‰n\{‰p\|‰s\}‰u\~‰z]!‰{]"‰|]#‰}]$‰‰]%‰]&‰]'‰”](‰•])‰›]*‰œ]+‰Ÿ],‰ ]-‰Ѕ].‰А]/‰Д]0‰Е]1‰Ж]2‰З]3‰М]4‰д]5‰е]6‰ж]7‰з]8‰и]9‰х]:‰щ];‰ы]<‰э]=‰ё]>‰ѓ]?‰і]@‰љ]A‰§]B‰џ]CŠ]DŠ]EŠ]FŠ]GŠ]HŠ]IŠ]JŠ]KŠ]LŠ ]MŠ"]NŠ$]OŠ&]PŠ+]QŠ,]RŠ/]SŠ5]TŠ7]UŠ=]VŠ>]WŠ@]XŠC]YŠE]ZŠG][ŠI]\ŠM]]ŠN]^ŠS]_ŠV]`ŠW]aŠX]bŠ\]cŠ]]dŠa]eŠe]fŠg]gŠu]hŠv]iŠw]jŠy]kŠz]lŠ{]mŠ~]nŠ]oŠ€]pŠƒ]qŠ†]rŠ‹]sŠ]tŠ]uŠ’]vŠ–]wŠ—]xŠ™]yŠŸ]zŠЇ]{ŠЉ]|ŠЎ]}ŠЏ]~ŠГ^!ŠЖ^"ŠЗ^#ŠЛ^$ŠО^%ŠУ^&ŠЦ^'ŠШ^(ŠЩ^)ŠЪ^*Šб^+Šг^,Šд^-Šе^.Šз^/Šн^0Šп^1Šь^2Š№^3Šє^4Šѕ^5Šі^6Šќ^7Šџ^8‹^9‹^:‹ ^;‹^<‹^=‹^>‹^?‹ ^@‹-^A‹0^B‹7^C‹<^D‹B^E‹C^F‹D^G‹E^H‹F^I‹H^J‹R^K‹S^L‹T^M‹Y^N‹M^O‹^^P‹c^Q‹m^R‹v^S‹x^T‹y^U‹|^V‹~^W‹^X‹„^Y‹…^Z‹‹^[‹^\‹^]‹”^^‹•^_‹œ^`‹ž^a‹Ÿ^bŒ8^cŒ9^dŒ=^eŒ>^fŒE^gŒG^hŒI^iŒK^jŒO^kŒQ^lŒS^mŒT^nŒW^oŒX^pŒ[^qŒ]^rŒY^sŒc^tŒd^uŒf^vŒh^wŒi^xŒm^yŒs^zŒu^{Œv^|Œ{^}Œ~^~Œ†_!Œ‡_"Œ‹_#Œ_$Œ’_%Œ“_&Œ™_'Œ›_(Œœ_)ŒЄ_*ŒЙ_+ŒК_,ŒХ_-ŒЦ_.ŒЩ_/ŒЫ_0ŒЯ_1Œж_2Œе_3Œй_4Œн_5Œс_6Œш_7Œь_8Œя_9Œ№_:Œђ_;Œѕ_<Œї_=Œј_>Œў_?Œџ_@_A_B _C_D_E_Fe_Gi_Hl_In_J_K‚_L„_Mˆ_N_O_P‘_Q•_Rž_SŸ_T _UІ_VЋ_WЌ_XЏ_YВ_ZЕ_[З_\Й_]Л_^Р__Х_`Ц_aЧ_bШ_cЪ_dЮ_eб_fд_gе_hз_iй_jф_kх_lч_mь_n№_oМ_pё_qђ_rє_s§_tŽ_uŽ_vŽ_wŽ_xŽ _yŽ_zŽ_{Ž_|Ž _}Ž!_~Ž"`!Ž#`"Ž&`#Ž'`$Ž1`%Ž3`&Ž6`'Ž7`(Ž8`)Ž9`*Ž=`+Ž@`,ŽA`-ŽK`.ŽM`/ŽN`0ŽO`1ŽT`2Ž[`3Ž\`4Ž]`5Ž^`6Ža`7Žb`8Ži`9Žl`:Žm`;Žo`<Žp`=Žq`>Žy`?Žz`@Ž{`AŽ‚`BŽƒ`CŽ‰`DŽ`EŽ’`FŽ•`GŽš`HŽ›`IŽ`JŽž`KŽЂ`LŽЇ`MŽЉ`NŽ­`OŽЎ`PŽГ`QŽЕ`RŽК`SŽЛ`TŽР`UŽС`VŽУ`WŽФ`XŽЧ`YŽЯ`ZŽб`[Žд`\Žм`]Žш`^Žю`_Ž№``Žё`aŽї`bŽљ`cŽњ`dŽэ`e`f`g`h`i`j`k`l`m`n`o `p!`q#`r%`s'`t(`u,`v-`w.`x4`y5`z6`{7`|:`}@`~Aa!Ca"Ga#Oa$Qa%Ra&Sa'Ta(Ua)Xa*]a+^a,ea-a. a/Ёa0Єa1Ѕa2Іa3Еa4Жa5Иa6Оa7Рa8Сa9Цa:Ъa;Ыa<Эa=аa>вa?гa@еaAрaBуaCфaDшaEюaFёaGѕaHіaIћaJўaKaLaMaN aOaPaQ(aR)aS/aT*aU,aV-aW3aX4aY7aZ?a[Ca\Da]La^[a_]a`baafabgacladpaetafyag…ahˆai‹ajŒakŽalam•an—ao˜ap™aq›ar asЁatЂauЅavАawВaxГayДazЖa{Нa|Ьa}Оa~Уb!Фb"Хb#Чb$Шb%еb&зb'иb(йb)мb*нb+пb,хb-вb.іb/ыb0яb1№b2єb3ўb4џb5‘b6‘b7‘b8‘b9‘b:‘ b;‘b<‘b=‘b>‘b?‘b@‘bA‘bB‘bC‘ bD‘%bE‘"bF‘#bG‘'bH‘)bI‘.bJ‘/bK‘1bL‘4bM‘6bN‘7bO‘9bP‘:bQ‘’ c?’ c@’ cA’cB’cC’cD’cE’cF’cG’cH’#cI’$cJ’%cK’&cL’(cM’.cN’/cO’0cP’3cQ’5cR’6cS’8cT’9cU’:cV’cX’@cY’BcZ’Cc[’Fc\’Gc]’Jc^’Mc_’Nc`’Oca’Qcb’Xcc’Ycd’\ce’]cf’`cg’ach’eci’gcj’hck’icl’ncm’ocn’pco’ucp’vcq’wcr’xcs’yct’{cu’|cv’}cw’cx’ˆcy’‰cz’Šc{’c|’Žc}’’c~’—d!’™d"’Ÿd#’ d$’Єd%’Ѕd&’Їd'’Јd(’Ћd)’Џd*’Вd+’Жd,’Иd-’Кd.’Лd/’Мd0’Нd1’Пd2’Рd3’Сd4’Тd5’Уd6’Хd7’Цd8’Чd9’Шd:’Ыd;’Ьd<’Эd=’Юd>’аd?’гd@’еdA’зdB’иdC’йdD’мdE’нdF’пdG’рdH’сdI’уdJ’хdK’чdL’шdM’ьdN’юdO’№dP’љdQ’ћdR’џdS“dT“dU“dV“ dW“dX“dY“dZ“d[“d\“d]“d^“!d_“$d`“%da“'db“)dc“*dd“3de“4df“6dg“7dh“Gdi“Hdj“Idk“Pdl“Qdm“Rdn“Udo“Wdp“Xdq“Zdr“^ds“ddt“edu“gdv“idw“jdx“mdy“odz“pd{“qd|“sd}“td~“ve!“ze"“}e#“e$“€e%“e&“‚e'“ˆe(“Še)“‹e*“e+“e,“’e-“•e.“˜e/“›e0“že1“Ёe2“Ѓe3“Єe4“Іe5“Јe6“Ћe7“Дe8“Еe9“Жe:“Кe;“Љe<“Сe=“Фe>“Хe?“Цe@“ЧeA“ЩeB“ЪeC“ЫeD“ЬeE“ЭeF“гeG“йeH“мeI“оeJ“пeK“тeL“цeM“чeN“љeO“їeP“јeQ“њeR“ћeS“§eT”eU”eV”eW”eX” eY” eZ”e[”e\”e]”e^”e_”e`”.ea”/eb”1ec”2ed”3ee”4ef”;eg”?eh”=ei”Cej”Eek”Hel”Jem”Len”Ueo”Yep”\eq”_er”aes”cet”heu”kev”mew”nex”oey”qez”re{”„e|”ƒe}•xe~•yf!•~f"•„f#•ˆf$•Œf%•f&•Žf'•f(•žf)•Ÿf*•Ёf+•Іf,•Љf-•Ћf.•Ќf/•Дf0•Жf1•Кf2•Нf3•Пf4•Цf5•Шf6•Щf7•Ыf8•аf9•бf:•вf;•гf<•йf=•кf>•нf?•оf@•пfA•рfB•фfC•цfD–fE–fF–"fG–$fH–%fI–&fJ–,fK–1fL–3fM–7fN–8fO–9fP–:fQ–—xg?—{g@—}gA—gB—€gC—‰gD—•gE—–gF——gG—™gH—šgI—žgJ—ŸgK—ЂgL—ЌgM—ЎgN—БgO—ВgP—ЕgQ—ЖgR—ИgS—ЙgT—КgU—МgV—ОgW—ПgX—СgY—ФgZ—Хg[—Чg\—Щg]—Ъg^—Ьg_—Эg`—Юga—аgb—бgc—дgd—зge—иgf—йgg—нgh—оgi—рgj—лgk—сgl—фgm—яgn—ёgo—єgp—їgq—јgr—њgs˜gt˜ gu˜gv˜ gw˜gx˜gy˜gz˜g{˜g|˜ g}˜#g~˜&h!˜+h"˜.h#˜/h$˜0h%˜2h&˜3h'˜5h(˜%h)˜>h*˜Dh+˜Gh,˜Jh-˜Qh.˜Rh/˜Sh0˜Vh1˜Wh2˜Yh3˜Zh4˜bh5˜ch6˜eh7˜fh8˜jh9˜lh:˜Ћh;˜­h<˜Ўh=˜Аh>˜Дh?˜Зh@˜ИhA˜КhB˜ЛhC˜ПhD˜ТhE˜ХhF˜ШhG˜ЬhH˜сhI˜уhJ˜хhK˜цhL˜чhM˜ъhN˜ѓhO˜іhP™hQ™hR™hS™hT™hU™hV™hW™hX™hY™hZ™h[™"h\™&h]™'h^™+h_™1h`™2ha™3hb™4hc™5hd™9he™:hf™;hg™ši?ši@š iAš"iBš#iCš$iDš'iEš-iFš.iGš3iHš5iIš6iJš8iKšGiLšAiMšDiNšJiOšKiPšLiQšNiRšQiSšTiTšViUš]iVšЊiWšЌiXšЎiYšЏiZšВi[šДi\šЕi]šЖi^šЙi_šЛi`šОiašПibšСicšУidšЦiešШifšЮigšаihšвiišеijšжikšзilšлimšмinšрiošфipšхiqšчiršщisšьitšђiušѓivšѕiwšљixšњiyš§izšџi{›i|›i}›i~›j!›j"›j#›j$› j%› j&› j'› j(›j)›j*›j+›j,›j-›j.›j/› j0›&j1›+j2›-j3›3j4›4j5›5j6›7j7›9j8›:j9›=j:›Hj;›Kj<›Lj=›Uj>›Vj?›Wj@›[jA›^jB›ajC›cjD›ejE›fjF›hjG›jjH›kjI›ljJ›mjK›njL›sjM›ujN›wjO›xjP›yjQ›jR›€jS›„jT›…jU›†jV›‡jW›‰jX›ŠjY›‹jZ›j[›j\›j]›”j^›šj_›j`›žja›Іjb›Їjc›Љjd›Ќje›Аjf›Бjg›Вjh›Зji›Иjj›Лjk›Мjl›Оjm›Пjn›Сjo›Чjp›Шjq›Юjr›аjs›зjt›иju›нjv›пjw›хjx›чjy›ъjz›ыj{›яj|›ѓj}›їj~›јk!›љk"›њk#›§k$›џk%œk&œk'œ k(œk)œk*œk+œk,œk-œk.œk/œk0œ"k1œ#k2œ&k3œ'k4œ(k5œ)k6œ*k7œ1k8œ5k9œ6k:œ7k;œ=k<œAk=œCk>œDk?œEk@œIkAœJkBœNkCœOkDœPkEœSkFœTkGœVkHœXkIœ[kJœ]kKœ^kLœ_kMœckNœikOœjkPœ\kQœkkRœhkSœnkTœpkUœrkVœukWœwkXœ{kYœцkZœђk[œїk\œљk] k^k_k`kakbkckdke/kf0kg2kh3ki4kj:kkжl?зl@кlAоlBпlCрlDхlEчlFщlGыlHюlI№lJѓlKєlLўlMž lNžlOžlPžlQžlRžlSžlTžlUžlVžlWžlXžlYžzlZž{l[ž|l\ž€l]ž‚l^žƒl_ž„l`ž…laž‡lbžŽlcžldž–lež˜lfž›lgžžlhžЄližЈljžЌlkžЎllžЏlmžАlnžГložДlpžЕlqžЦlržШlsžЫltžеlužпlvžфlwžчlxžьlyžэlzžюl{ž№l|žёl}žђl~žѕm!žјm"žџm#Ÿm$Ÿm%Ÿ m&Ÿm'Ÿm(Ÿm)Ÿm*Ÿm+Ÿm,Ÿm-Ÿm.Ÿm/Ÿm0Ÿm1Ÿ"m2Ÿ&m3Ÿ*m4Ÿ+m5Ÿ/m6Ÿ1m7Ÿ2m8Ÿ4m9Ÿ7m:Ÿ9m;Ÿ:m<ŸŸ?m?ŸAm@ŸCmAŸDmBŸEmCŸFmDŸGmEŸSmFŸUmGŸVmHŸWmIŸXmJŸZmKŸ]mLŸ^mMŸhmNŸimOŸmmPŸnmQŸomRŸpmSŸqmTŸsmUŸumVŸzmWŸ}mXŸmYŸmZŸ‘m[Ÿ’m\Ÿ”m]Ÿ–m^Ÿ—m_Ÿžm`ŸЁmaŸЂmbŸЃmcŸЅecl-16.1.2/contrib/encodings/KOI8-R.BIN000066400000000000000000000020021266352375300172260ustar00rootroot00000000000000  !!""##$$%%&&''(())**++,,--..//00112233445566778899::;;<<==>>??@@AABBCCDDEEFFGGHHIIJJKKLLMMNNOOPPQQRRSSTTUUVVWWXXYYZZ[[\\]]^^__``aabbccddeeffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~€%%‚% ƒ%„%…%†%‡%$ˆ%,‰%4Š%<‹%€Œ%„%ˆŽ%Œ%%‘‘%’’%““# ”% •"–"—"H˜"d™"eš ›#!œАВžЗŸї %PЁ%QЂ%RЃQЄ%SЅ%TІ%UЇ%VЈ%WЉ%XЊ%YЋ%ZЌ%[­%\Ў%]Џ%^А%_Б%`В%aГД%bЕ%cЖ%dЗ%eИ%fЙ%gК%hЛ%iМ%jН%kО%lПЉРNС0Т1УFФ4Х5ЦDЧ3ШEЩ8Ъ9Ы:Ь;Э<Ю=Я>а?бOв@гAдBеCж6з2иLйKк7лHмMнIоGпJр.сту&фхц$чш%щъыьэюя№ё/ђ ѓ!є"ѕ#іїј,љ+њћ(ќ-§)ў'џ*ecl-16.1.2/contrib/encodings/KOI8-U.BIN000066400000000000000000000020021266352375300172310ustar00rootroot00000000000000  !!""##$$%%&&''(())**++,,--..//00112233445566778899::;;<<==>>??@@AABBCCDDEEFFGGHHIIJJKKLLMMNNOOPPQQRRSSTTUUVVWWXXYYZZ[[\\]]^^__``aabbccddeeffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~€%%‚% ƒ%„%…%†%‡%$ˆ%,‰%4Š%<‹%€Œ%„%ˆŽ%Œ%%‘‘%’’%““# ”% •"–"—"H˜"d™"eš ›#!œАВžЗŸї %PЁ%QЂ%RЃQЄTЅ%TІVЇWЈ%WЉ%XЊ%YЋ%ZЌ%[­‘Ў%]Џ%^А%_Б%`В%aГДЕ%cЖЗИ%fЙ%gК%hЛ%iМ%jНО%lПЉРNС0Т1УFФ4Х5ЦDЧ3ШEЩ8Ъ9Ы:Ь;Э<Ю=Я>а?бOв@гAдBеCж6з2иLйKк7лHмMнIоGпJр.сту&фхц$чш%щъыьэюя№ё/ђ ѓ!є"ѕ#іїј,љ+њћ(ќ-§)ў'џ*ecl-16.1.2/contrib/encodings/SHIFT-JIS.BIN000066400000000000000000000667661266352375300176500ustar00rootroot000000000000006њ !!""##$$%%&&''(())**++,,--..//00112233445566778899::;;<<==>>??@@AABBCCDDEEFFGGHHIIJJKKLLMMNNOOPPQQRRSSTTUUVVWWXXYYZZ[[\Ѕ]]^^__``aabbccddeeffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~ >@0A0B0Cџ DџE0ћFџGџHџIџJ0›K0œLДMџ@NЈOџ>PџуQџ?R0§S0ўT0U0žV0WNнX0Y0Z0[0ќ\ ] ^џ_\`0a bџ\c &d %e f g h iџjџ k0l0mџ;nџ=oџ[pџ]q0r0 s0 t0 u0 v0 w0x0y0z0{џ |"}Б~з€їџ‚"`ƒџ„џ…"f†"g‡"ˆ"4‰&BŠ&@‹АŒ 2 3Ž!џхџ‘Ђ’Ѓ“џ”џ•џ–џ —џ ˜Ї™&š&›%Ыœ%Я%Юž%ЧŸ%Ц %ЁЁ% Ђ%ГЃ%ВЄ%НЅ%МІ ;Ї0Ј!’Љ!Њ!‘Ћ!“Ќ0И"Й" К"†Л"‡М"‚Н"ƒО"*П")Ш"'Щ"(ЪЌЫ!вЬ!дЭ"Ю"к" л"Ѕм#н"о"п"aр"Rс"jт"kу"ф"=х"ц"5ч"+ш",№!+ё 0ђ&oѓ&mє&jѕ і !їЖќ%я‚Oџ‚Pџ‚Qџ‚Rџ‚Sџ‚Tџ‚Uџ‚Vџ‚Wџ‚Xџ‚`џ!‚aџ"‚bџ#‚cџ$‚dџ%‚eџ&‚fџ'‚gџ(‚hџ)‚iџ*‚jџ+‚kџ,‚lџ-‚mџ.‚nџ/‚oџ0‚pџ1‚qџ2‚rџ3‚sџ4‚tџ5‚uџ6‚vџ7‚wџ8‚xџ9‚yџ:‚џA‚‚џB‚ƒџC‚„џD‚…џE‚†џF‚‡џG‚ˆџH‚‰џI‚ŠџJ‚‹џK‚ŒџL‚џM‚ŽџN‚џO‚џP‚‘џQ‚’џR‚“џS‚”џT‚•џU‚–џV‚—џW‚˜џX‚™џY‚šџZ‚Ÿ0A‚ 0B‚Ё0C‚Ђ0D‚Ѓ0E‚Є0F‚Ѕ0G‚І0H‚Ї0I‚Ј0J‚Љ0K‚Њ0L‚Ћ0M‚Ќ0N‚­0O‚Ў0P‚Џ0Q‚А0R‚Б0S‚В0T‚Г0U‚Д0V‚Е0W‚Ж0X‚З0Y‚И0Z‚Й0[‚К0\‚Л0]‚М0^‚Н0_‚О0`‚П0a‚Р0b‚С0c‚Т0d‚У0e‚Ф0f‚Х0g‚Ц0h‚Ч0i‚Ш0j‚Щ0k‚Ъ0l‚Ы0m‚Ь0n‚Э0o‚Ю0p‚Я0q‚а0r‚б0s‚в0t‚г0u‚д0v‚е0w‚ж0x‚з0y‚и0z‚й0{‚к0|‚л0}‚м0~‚н0‚о0€‚п0‚р0‚‚с0ƒ‚т0„‚у0…‚ф0†‚х0‡‚ц0ˆ‚ч0‰‚ш0Š‚щ0‹‚ъ0Œ‚ы0‚ь0Ž‚э0‚ю0‚я0‘‚№0’‚ё0“ƒ@0ЁƒA0ЂƒB0ЃƒC0ЄƒD0ЅƒE0ІƒF0ЇƒG0ЈƒH0ЉƒI0ЊƒJ0ЋƒK0ЌƒL0­ƒM0ЎƒN0ЏƒO0АƒP0БƒQ0ВƒR0ГƒS0ДƒT0ЕƒU0ЖƒV0ЗƒW0ИƒX0ЙƒY0КƒZ0Лƒ[0Мƒ\0Нƒ]0Оƒ^0Пƒ_0Рƒ`0Сƒa0Тƒb0Уƒc0Фƒd0Хƒe0Цƒf0Чƒg0Шƒh0Щƒi0Ъƒj0Ыƒk0Ьƒl0Эƒm0Юƒn0Яƒo0аƒp0бƒq0вƒr0гƒs0дƒt0еƒu0жƒv0зƒw0иƒx0йƒy0кƒz0лƒ{0мƒ|0нƒ}0оƒ~0пƒ€0рƒ0сƒ‚0тƒƒ0уƒ„0фƒ…0хƒ†0цƒ‡0чƒˆ0шƒ‰0щƒŠ0ъƒ‹0ыƒŒ0ьƒ0эƒŽ0юƒ0яƒ0№ƒ‘0ёƒ’0ђƒ“0ѓƒ”0єƒ•0ѕƒ–0іƒŸ‘ƒ ’ƒЁ“ƒЂ”ƒЃ•ƒЄ–ƒЅ—ƒІ˜ƒЇ™ƒЈšƒЉ›ƒЊœƒЋƒЌžƒ­ŸƒЎ ƒЏЁƒАЃƒБЄƒВЅƒГІƒДЇƒЕЈƒЖЉƒПБƒРВƒСГƒТДƒУЕƒФЖƒХЗƒЦИƒЧЙƒШКƒЩЛƒЪМƒЫНƒЬОƒЭПƒЮРƒЯСƒаУƒбФƒвХƒгЦƒдЧƒеШƒжЩ„@„A„B„C„D„E„F„G„H„I„J„K„L„M„N„O„P„Q „R!„S"„T#„U$„V%„W&„X'„Y(„Z)„[*„\+„],„^-„_.„`/„p0„q1„r2„s3„t4„u5„vQ„w6„x7„y8„z9„{:„|;„}<„~=„€>„?„‚@„ƒA„„B„…C„†D„‡E„ˆF„‰G„ŠH„‹I„ŒJ„K„ŽL„M„N„‘O„Ÿ%„ %„Ё% „Ђ%„Ѓ%„Є%„Ѕ%„І%,„Ї%$„Ј%4„Љ%<„Њ%„Ћ%„Ќ%„­%„Ў%„Џ%„А%#„Б%3„В%+„Г%;„Д%K„Е% „Ж%/„З%(„И%7„Й%?„К%„Л%0„М%%„Н%8„О%BˆŸNœˆ UˆЁZˆЂ–?ˆЃTРˆЄaˆЅc(ˆІYіˆЇ"ˆЈ„uˆЉƒˆЊzPˆЋ`ЊˆЌcсˆ­n%ˆЎeэˆЏ„fˆА‚ІˆБ›ѕˆВh“ˆГW'ˆДeЁˆЕbqˆЖ[›ˆЗYаˆИ†{ˆЙ˜єˆК}bˆЛ}ОˆМ›ŽˆНbˆО|ŸˆПˆЗˆР[‰ˆС^ЕˆТc ˆУf—ˆФhHˆХ•ЧˆЦ—ˆЧgOˆШNхˆЩO ˆЪOMˆЫOˆЬPIˆЭVђˆЮY7ˆЯYдˆаZˆб\ ˆв`пˆгaˆдapˆеfˆжiˆзpКˆиuOˆйupˆкyћˆл}­ˆм}яˆн€Уˆо„ˆпˆcˆр‹ˆсUˆтzˆуS;ˆфN•ˆхNЅˆцWпˆч€ВˆшСˆщxяˆъNˆыXёˆьnЂˆэ8ˆюz2ˆяƒ(ˆ№‚‹ˆёœ/ˆђQAˆѓSpˆєTНˆѕTсˆіVрˆїYћˆј_ˆљ˜ђˆњmыˆћ€фˆќ…-‰@–b‰A–p‰B– ‰C—ћ‰DT ‰ESѓ‰F[‡‰GpЯ‰HН‰IТ‰J–ш‰KSo‰L\‰MzК‰NN‰Ox“‰Pќ‰Qn&‰RV‰SU‰Tk‰U…‰Vœ;‰WYх‰XSЉ‰Ymf‰Ztм‰[•‰\VB‰]N‘‰^K‰_–ђ‰`ƒO‰a™ ‰bSс‰cUЖ‰d[0‰e_q‰ff ‰gfѓ‰hh‰il8‰jlѓ‰km)‰lt[‰mvШ‰nzN‰o˜4‰p‚ё‰qˆ[‰rŠ`‰s’э‰tmВ‰uuЋ‰vvЪ‰w™Х‰x`І‰y‹‰zŠ‰{•В‰|iŽ‰}S­‰~Q†‰€W‰X0‰‚YD‰ƒ[Д‰„^і‰…`(‰†cЉ‰‡cє‰ˆlП‰‰o‰ŠpŽ‰‹q‰ŒqY‰qе‰Žs?‰~‰‚v‰‘‚б‰’…—‰“`‰”’[‰•‰–Xi‰—eМ‰˜lZ‰™u%‰šQљ‰›Y.‰œYe‰_€‰ž_м‰ŸbМ‰ eњ‰Ёj*‰Ђk'‰ЃkД‰Єs‹‰ЅС‰І‰V‰Ї,‰Ј‰ЉžФ‰Њ\Ё‰Ћl–‰Ќƒ{‰­Q‰Ў\K‰ЏaЖ‰АЦ‰Бhv‰Вra‰ГNY‰ДOњ‰ЕSx‰Ж`i‰Зn)‰ИzO‰Й—ѓ‰КN ‰ЛS‰МNю‰НOU‰ОO=‰ПOЁ‰РOs‰СR ‰ТSя‰УV ‰ФY‰ХZС‰Ц[Ж‰Ч[с‰Шyб‰Щf‡‰Ъgœ‰ЫgЖ‰ЬkL‰ЭlГ‰Юpk‰ЯsТ‰аy‰бyО‰вz<‰г{‡‰д‚Б‰е‚л‰жƒ‰зƒw‰иƒя‰йƒг‰к‡f‰лŠВ‰мV)‰нŒЈ‰оц‰пN‰р—‰с†Š‰тOФ‰у\ш‰фb‰хrY‰цu;‰чх‰ш‚Н‰щ†ў‰ъŒР‰ы–Х‰ь™‰э™е‰юNЫ‰яO‰№‰у‰ёVо‰ђXJ‰ѓXЪ‰є^ћ‰ѕ_ы‰і`*‰ї`”‰ј`b‰љaа‰њb‰ћbа‰ќe9Š@›AŠAffŠBhАŠCmwŠDppŠEuLŠFv†ŠG}uŠH‚ЅŠI‡љŠJ•‹ŠK–ŽŠLŒŠMQёŠNRОŠOYŠPTГŠQ[ГŠR]ŠSahŠTi‚ŠUmЏŠVxŠW„ЫŠXˆWŠYŠrŠZ“ЇŠ[šИŠ\mlŠ]™ЈŠ^†йŠ_WЃŠ`gџŠa†ЮŠb’ŠcRƒŠdV‡ŠeTŠf^гŠgbсŠhdЙŠih<Šjh8ŠkkЛŠlsrŠmxКŠnzkŠo‰šŠp‰вŠqkŠrŠsэŠt•ЃŠu–”Šv—iŠw[fŠx\ГŠyi}Šz˜MŠ{˜NŠ|c›Š}{ Š~j+Š€jŠhЖŠ‚œ Šƒo_Š„RrŠ…UŠ†`pŠ‡bьŠˆm;Š‰nŠŠnбŠ‹„[ŠŒ‰ŠDŠŽNŠœ9ŠSіŠ‘iŠ’j:Š“—„Š”h*Š•Q\Š–zУŠ—„ВŠ˜‘мŠ™“ŒŠšV[Š›(Šœh"ŠƒŠž„1ŠŸ|ЅŠ RŠЁ‚ХŠЂtцŠЃN~ŠЄOƒŠЅQ ŠІ[вŠЇR ŠЈRиŠЉRчŠЊ]ћŠЋUšŠЌX*Š­YцŠЎ[ŒŠЏ[˜ŠА[лŠБ^rŠВ^yŠГ`ЃŠДaŠЕacŠЖaОŠЗcлŠИebŠЙgбŠКhSŠЛhњŠМk>ŠНkSŠОlWŠПo"ŠРo—ŠСoEŠТtАŠУuŠФvуŠХw ŠЦzџŠЧ{ЁŠШ|!ŠЩ}щŠЪ6ŠЫ№ŠЬ€ŠЭ‚fŠЮƒžŠЯ‰ГŠаŠЬŠбŒЋŠв„Šг”QŠд•“Šе•‘Šж•ЂŠз–eŠи—гŠй™(Šк‚ŠлN8ŠмT+Šн\ИŠо]ЬŠпsЉŠрvLŠсw<Šт\ЉŠуыŠф Šх–СŠц˜Šч˜TŠш˜XŠщOŠъOŠыSqŠьUœŠэVhŠюWњŠяYGŠ№[ Šё[ФŠђ\Šѓ^ Šє^~Šѕ_ЬŠіcюŠїg:ŠјeзŠљeтŠњgŠћhЫŠќhФ‹@j_‹A^0‹BkХ‹Cl‹Dl}‹Eu‹FyH‹G[c‹Hz‹I}‹J_Н‹K‰‹LŠ‹MŒД‹Nw‹OŽЬ‹P‹Q˜т‹Rš‹S›<‹TN€‹UP}‹VQ‹WY“‹X[œ‹Yb/‹Zb€‹[dь‹\k:‹]r ‹^u‘‹_yG‹`Љ‹a‡ћ‹bŠМ‹c‹p‹dcЌ‹eƒЪ‹f— ‹gT ‹hT‹iUЋ‹jhT‹kjX‹lŠp‹mx'‹ngu‹ožЭ‹pSt‹q[Ђ‹r‹s†P‹t‹uN‹vNE‹wNЧ‹xO‹ySЪ‹zT8‹{[Ў‹|_‹}`%‹~eQ‹€g=‹lB‹‚lr‹ƒlу‹„px‹…t‹†zv‹‡zЎ‹ˆ{‹‰}‹Š|ў‹‹}f‹Œeч‹r[‹ŽSЛ‹\E‹]ш‹‘bв‹’bр‹“c‹”n ‹•†Z‹–Š1‹—н‹˜’ј‹™o‹šyІ‹››Z‹œNЈ‹NЋ‹žNЌ‹ŸO›‹ O ‹ЁPб‹ЂQG‹Ѓzі‹ЄQq‹ЅQі‹ІST‹ЇS!‹ЈS‹ЉSы‹ЊUЌ‹ЋXƒ‹Ќ\с‹­_7‹Ў_J‹Џ`/‹А`P‹Б`m‹Вc‹ГeY‹ДjK‹ЕlС‹ЖrТ‹Зrэ‹Иwя‹Й€ј‹К‹Л‚‹М…N‹Нї‹О“с‹П—џ‹Р™W‹СšZ‹ТN№‹УQн‹Ф\-‹Хf‹Цim‹Ч\@‹Шfђ‹Щiu‹Ъs‰‹ЫhP‹Ь|‹ЭPХ‹ЮRф‹ЯWG‹а]ў‹б“&‹вeЄ‹гk#‹дk=‹еt4‹жy‹зyН‹и{K‹й}Ъ‹к‚Й‹лƒЬ‹мˆ‹н‰_‹о‹9‹пб‹р‘б‹сT‹т’€‹уN]‹фP6‹хSх‹цS:‹чrз‹шs–‹щwщ‹ъ‚ц‹ыŽЏ‹ь™Ц‹э™Ш‹ю™в‹яQw‹№a‹ё†^‹ђUА‹ѓzz‹єPv‹ѕ[г‹іG‹ї–…‹јN2‹љjл‹њ‘ч‹ћ\Q‹ќ\HŒ@c˜ŒAzŸŒBl“ŒC—tŒDaŒEzЊŒFqŠŒG–ˆŒH|‚ŒIhŒJ~pŒKhQŒL“lŒMRђŒNTŒO…ЋŒPŠŒQЄŒRŽЭŒSсŒTSfŒUˆˆŒVyAŒWOТŒXPОŒYRŒZQDŒ[USŒ\W-Œ]sъŒ^W‹Œ_YQŒ`_bŒa_„Œb`uŒcavŒdagŒeaЉŒfcВŒgd:ŒhelŒifoŒjhBŒknŒlufŒmz=Œn|ћŒo}LŒp}™Œq~KŒrkŒsƒŒtƒJŒu†ЭŒvŠŒwŠcŒx‹fŒyŽ§Œz˜Œ{Œ|‚ИŒ}ЮŒ~›шŒ€R‡ŒbŒ‚dƒŒƒoРŒ„–™Œ…hAŒ†P‘Œ‡k ŒˆlzŒ‰oTŒŠztŒ‹}PŒŒˆ@ŒŠ#ŒŽgŒNіŒP9Œ‘P&Œ’PeŒ“Q|Œ”R8Œ•RcŒ–UЇŒ—WŒ˜XŒ™ZЬŒš^њŒ›aВŒœaјŒbѓŒžcrŒŸiŒ j)ŒЁr}ŒЂrЌŒЃs.ŒЄxŒЅxoŒІ}yŒЇw ŒЈ€ЉŒЉ‰‹ŒЊ‹ŒЋŒтŒЌŽвŒ­cŒЎ“uŒЏ–zŒА˜UŒБšŒВžxŒГQCŒДSŸŒЕSГŒЖ^{ŒЗ_&ŒИnŒЙnŒКs„ŒЛsўŒМ}CŒН‚7ŒОŠŒПŠњŒР–PŒСNNŒТP ŒУSфŒФT|ŒХVњŒЦYбŒЧ[dŒШ]ёŒЩ^ЋŒЪ_'ŒЫb8ŒЬeEŒЭgЏŒЮnVŒЯrаŒа|ЪŒбˆДŒв€ЁŒг€сŒдƒ№Œе†NŒжŠ‡ŒзшŒи’7Œй–ЧŒк˜gŒлŸŒмN”ŒнN’ŒоO ŒпSHŒрTIŒсT>ŒтZ/Œу_ŒŒф_ЁŒх`ŸŒцhЇŒчjŽŒшtZŒщxŒъŠžŒыŠЄŒь‹wŒэ‘ŒюN^Œя›ЩŒ№NЄŒёO|ŒђOЏŒѓPŒєPŒѕQIŒіQlŒїRŸŒјRЙŒљRўŒњSšŒћSуŒќT@TAU‰BWQCWЂDY}E[TF[]G[H]хI]чJ]їK^xL^ƒM^šN^ЗO_P`RQaLRb—SbиTcЇUe;VfWfCXfєYgmZh![h—\iЫ]l_^m*_mi`n/anbu2cv‡dxlez?f|рg}h}i}^j}Бk€l€m€Џn€БoTpq‚*rƒRsˆLtˆau‹vŒЂwŒќxЪy‘uz’q{x?|’ќ}•Є~–M€˜™™‚šиƒ;„R[…RЋ†Sї‡TˆXе‰bїŠoр‹ŒjŒ_žЙŽQKR;TJ‘V§’z@“‘w”`•žв–sD—o ˜p™uš_§›`кœšЈrлžМŸkd ˜ЁNЪЂV№ЃWdЄXОЅZZІ`hЇaЧЈfЉfЊh9ЋhБЌmї­uеЎ}:Џ‚nА›BБN›ВOPГSЩДUЕ]oЖ]цЗ]юИgћЙl™КtsЛxМŠPН“–ОˆпПWPР^ЇСc+ТPЕУPЌФQХgЦTЩЧX^ШYЛЩ[АЪ_iЫbMЬcЁЭh=ЮksЯnаp}б‘Чвr€гxдx&еymжeŽз}0иƒмйˆСк л–›мRdнW(оgPпjрŒЁсQДтWBу–*фX:хiŠц€ДчTВш]щWќъx•ыњьO\эRJюT‹яd>№f(ёgђgѕѓz„є{Vѕ}"і“/їh\ј›­љ{9њSћQŠќR7Ž@[пŽAbіŽBdЎŽCdцŽDg-ŽEkКŽF…ЉŽG–бŽHvŽI›жŽJcLŽK“ŽL›ЋŽMvПŽNfRŽON ŽPP˜ŽQSТŽR\qŽS`шŽTd’ŽUecŽVh_ŽWqцŽXsЪŽYu#ŽZ{—Ž[~‚Ž\†•Ž]‹ƒŽ^ŒлŽ_‘xŽ`™ŽaeЌŽbfЋŽck‹ŽdNеŽeNдŽfO:ŽgOŽhR:ŽiSјŽjSђŽkUуŽlVлŽmXыŽnYЫŽoYЩŽpYџŽq[PŽr\MŽs^Žt^+Žu_зŽv`ŽwcŽxe/Žy[\ŽzeЏŽ{eНŽ|eшŽ}gŽ~kbŽ€k{ŽlŽ‚sEŽƒyIŽ„yСŽ…|јŽ†}Ž‡}+Žˆ€ЂŽ‰ŽŠѓŽ‹‰–ŽŒŠ^ŽŠiŽŽŠfŽŠŒŽŠюŽ‘ŒЧŽ’ŒмŽ“–ЬŽ”˜ќŽ•koŽ–N‹Ž—O<Ž˜OŽ™QPŽš[WŽ›[њŽœaHŽcŽžfBŽŸk!Ž nЫŽЁlЛŽЂr>ŽЃtНŽЄuдŽЅxСŽІy:ŽЇ€ ŽЈ€3ŽЉъŽЊ„”ŽЋžŽЌlPŽ­žŽЎ_ŽЏ‹XŽА+ŽБzњŽВŽјŽГ[ŽД–ыŽЕNŽЖSёŽЗWїŽИY1ŽЙZЩŽК[ЄŽЛ`‰ŽМnŽНoŽОuОŽПŒъŽР[ŸŽС…ŽТ{рŽУPrŽФgєŽХ‚ŽЦ\aŽЧ…JŽШ~ŽЩ‚ŽЪQ™ŽЫ\ŽЬchŽЭfŽЮeœŽЯqnŽаy>Žб}Žв€Žг‹ŽдŽЪŽеnŽж†ЧŽзЊŽиPŽйRњŽк\:ŽлgSŽмp|Žнr5Žо‘LŽп‘ШŽр“+Žс‚хŽт[ТŽу_1Žф`љŽхN;ŽцSжŽч[ˆŽшbKŽщg1ŽъkŠŽыrщŽьsрŽэz.ŽюkŽяЃŽ№‘RŽё™–ŽђQŽѓSзŽєTjŽѕ[џŽіcˆŽїj9Žј}ЌŽљ—ŽњVкŽћSЮŽќTh@[—A\1B]оCOюDaEbўFm2GyРHyЫI}BJ~MKвLэM‚N„OˆFP‰rQ‹RŽtS/T1U‘KV‘lW–ЦX‘œYNРZOO[QE\SA]_“^b_gд`lAan bscc~&d‘Эe’ƒfSдgYh[Пimбjy]k~.l|›mX~nqŸoQњpˆSq№rOЪs\ћtf%uwЌvzуw‚x™џyQЦz_Њ{eь|io}k‰~mѓ€n–od‚vўƒ}„]с…u†‘‡‡˜ˆQц‰RŠb@‹f‘ŒfйnŽ^Ж}вr‘fј’…Џ“…ї”Šј•RЉ–Sй—Ys˜^™_š`U›’фœ–dPЗžQŸRн S ЁSGЂSьЃTшЄUFЅU1ІVЇYhЈYОЉZ<Њ[ЕЋ\Ќ\­\Ў\Џ^„А^ŠБ^рВ_pГbДb„ЕbлЖcŒЗcwИfЙf Кf-ЛfvМg~НhЂОjПj5РlМСmˆТn УnXФq<Хq&ЦqgЧuЧШwЩx]ЪyЫyeЬy№ЭzрЮ{Я|Їа}9б€–вƒжг„‹д…Iеˆ]жˆѓзŠиŠ<йŠTкŠsлŒaмŒон‘Єо’fп“~р”с–œт—˜уN фNхNцNWчQ—шRpщWЮъX4ыXЬь["э^8ю`Хяdў№gaёgVђmDѓrЖєusѕzcі„Иї‹rј‘Иљ“ њV1ћWєќ˜ў@bэAi Bk–CqэD~TE€wF‚rG‰цH˜пI‡UJБK\;LO8MOсNOЕOUPZ Q[нR[щS_УTaNUc/VeАWfKXhюYi›Zmx[mё\u3]uЙ^w_y^`yцa}3bуc‚Џd…Њe‰ЊfŠ:gŽЋh›i2j‘нk—lNКmNСnRoXupXьq\ rus\=tNuŠ vХw–cx—my{%zŠЯ{˜|‘b}Vѓ~SЈ€T9‚W‚ƒ^%„cЈ…l4†pŠ‡waˆ|‹‰рŠˆp‹BŒ‘T“Ž“–t^‘šФ’]“]i”ep•gЂ–Ј—–л˜cn™gIši›ƒХœ˜–РžˆўŸo„ dzЁ[јЂNЃp,Єu]Ѕf/ІQФЇR6ЈRтЉYгЊ_Ћ`'Ќb­e?ЎetЏfАftБhђВhГkcДnЕrrЖuЗvлИ|ОЙ€VКX№Лˆ§М‰НŠ ОŠ“ПŠЫРС‘’Т—RУ—YФe‰ХzЦЧ–ЛШ^-Щ`мЪbЫeЅЬfЭgЮwѓЯzMа|Mб~>в гŒЌдdесжŽ_зxЉиRйbйкcЅлdBмb˜нŠ-оzƒп{РрŠЌс–ът}vу‚ ф‡IхNйцQHчSCшS`щ[Ѓъ\ы\ь]нэb&юbGяdА№hёh4ђlЩѓmEєmѕgгіo\їqNјq}љeЫњzћ{­ќ}к‘@~J‘AЈ‘Bz‘C‚‘D‚9‘E…І‘FŠn‘GŒЮ‘Hѕ‘Ix‘Jw‘K’­‘L’‘‘M•ƒ‘N›Ў‘ORM‘PU„‘Qo8‘Rq6‘SQh‘Ty…‘U~U‘VГ‘W|Ю‘XVL‘YXQ‘Z\Ј‘[cЊ‘\fў‘]f§‘^iZ‘_rй‘`u‘auŽ‘by‘cyV‘dyп‘e|—‘f} ‘g}D‘h†‘iŠ4‘j–;‘ka‘lŸ ‘mPч‘nRu‘oSЬ‘pSт‘qP ‘rUЊ‘sXю‘tYO‘ur=‘v[‹‘w\d‘xS‘y`у‘z`ѓ‘{c\‘|cƒ‘}c?‘~cЛ‘€dЭ‘eщ‘‚fљ‘ƒ]у‘„iЭ‘…i§‘†o‘‡qх‘ˆN‰‘‰uщ‘Švј‘‹z“‘Œ|п‘}Я‘Ž}œ‘€a‘ƒI‘‘ƒX‘’„l‘“„М‘”…ћ‘•ˆХ‘–p‘—‘˜m‘™“—‘š—‘›š‘œPЯ‘X—‘žaŽ‘Ÿг‘ …5‘Ё‘Ђ ‘ЃOУ‘ЄPt‘ЅRG‘ІSs‘Ї`o‘ЈcI‘Љg_‘Њn,‘ЋГ‘Ќ‘­Oз‘Ў\^‘ЏŒЪ‘АeЯ‘Б}š‘ВSR‘Гˆ–‘ДQv‘ЕcУ‘Ж[X‘З[k‘И\ ‘Йd ‘КgQ‘Л\‘МNж‘НY‘ОY*‘Пlp‘РŠQ‘СU>‘ТX‘УYЅ‘Ф`№‘ХbS‘ЦgС‘Ч‚5‘ШiU‘Щ–@‘Ъ™Ф‘Ыš(‘ЬOS‘ЭX‘Ю[ў‘Я€‘а\Б‘б^/‘в_…‘г` ‘дaK‘еb4‘жfџ‘зl№‘иnо‘й€Ю‘к‘л‚д‘мˆ‹‘нŒИ‘о‘п.‘р–Š‘сžл‘т›л‘уNу‘фS№‘хY'‘ц{,‘ч‘‘ш˜L‘щљ‘ъnн‘ыp'‘ьSS‘эUD‘ю[…‘яbX‘№bž‘ёbг‘ђlЂ‘ѓoя‘єt"‘ѕŠ‘і”8‘їoС‘јŠў‘љƒ8‘њQч‘ћ†ј‘ќSъ’@Sщ’AOF’BT’CА’DYj’E1’F]§’Gzъ’HП’Ihк’JŒ7’Krј’LœH’Mj=’NŠА’ON9’PSX’QV’RWf’SbХ’TcЂ’Ueц’VkN’Wmс’Xn[’Yp­’Zwэ’[zя’\{Њ’]}Л’^€=’_€Ц’`†Ы’aŠ•’b“[’cVу’dXЧ’e_>’fe­’gf–’hj€’ikЕ’ju7’kŠЧ’lP$’mwх’nW0’o_’p`e’qfz’rl`’suє’tz’un’vє’w‡’xE’y™Г’z{Щ’{u\’|zљ’}{Q’~„Ф’€’yщ’‚z’’ƒƒ6’„Zс’…w@’†N-’‡Nђ’ˆ[™’‰_р’ŠbН’‹f<’Œgё’lш’Ž†k’ˆw’Š;’‘‘N’’’ѓ’“™а’”j’•p&’–s*’—‚ч’˜„W’™ŒЏ’šN’›QF’œQЫ’U‹’ž[ѕ’Ÿ^’ ^3’Ё^’Ђ_’Ѓ_5’Є_k’Ѕ_Д’Іaђ’Їc’ЈfЂ’Љg’Њon’ЋrR’Ќu:’­w:’Ў€t’Џ9’Аx’Б‡v’ВŠП’ГŠм’Д…’Еѓ’Ж’š’З•w’И˜’Йœх’КRХ’ЛcW’Мvє’Нg’Оlˆ’ПsЭ’РŒУ’С“Ў’Т–s’Уm%’ФXœ’Хi’ЦiЬ’Ч§’Ш“š’Щuл’Ъ’ЫXZ’Ьh’ЭcД’Юiћ’ЯOC’аo,’бgи’вЛ’г…&’д}Д’е“T’жi?’зop’иWj’йXї’к[,’л},’мr*’нT ’о‘у’пД’рN­’сON’тP\’уPu’фRC’хŒž’цTH’чX$’ш[š’щ^’ъ^•’ы^­’ь^ї’э_’ю`Œ’яbЕ’№c:’ёcа’ђhЏ’ѓl@’єx‡’ѕyŽ’іz ’ї}р’ј‚G’љŠ’њŠц’ћŽD’ќ“@И“A‘-“B‘и“CŸ“Dlх“EdX“Fdт“Geu“Hnє“Iv„“J{“Ki“L“б“MnК“NTђ“O_Й“PdЄ“QM“Rэ“S’D“TQx“UXk“VY)“W\U“X^—“Ymћ“Z~“[u“\ŒМ“]Žт“^˜[“_pЙ“`O“akП“boБ“cu0“d–ћ“eQN“fT“gX5“hXW“iYЌ“j\`“k_’“le—“mg\“nn!“ov{“pƒп“qŒэ“r“s§“t“M“ux%“vx:“wRЊ“x^І“yW“zYt“{`“|P“}QZ“~QЌ“€QЭ“R“‚U“ƒXT“„XX“…YW“†[•“‡\і“ˆ]‹“‰`М“Šb•“‹d-“Œgq“hC“ŽhМ“hп“vз“‘mи“’no““m›“”po“•qШ“–_S“—uи“˜yw“™{I“š{T“›{R“œ|ж“}q“žR0“Ÿ„c“ …i“Ё…ф“ЂŠ“Ѓ‹“ЄŒF“ЅŽ“І“Ї“Ј”“Љ–v“Њ˜-“Ћš0“Ќ•и“­PЭ“ЎRе“ЏT “АX“Б\“ВaЇ“Гdž“Дm“ЕwГ“Жzх“З€є“И„“ЙS“К’…“Л\р“М“НS?“О_—“П_Г“Рmœ“Сry“Тwc“УyП“Ф{ф“Хkв“Цrь“ЧŠ­“Шh“Щja“ЪQј“Ыz“Ьi4“Э\J“Юœі“Я‚ы“а[Х“б‘I“вp“гVx“д\o“е`Ч“жef“зlŒ“иŒZ“йA“к˜“лTQ“мfЧ“н’ “оYH“пЃ“рQ…“сNM“тQъ“у…™“ф‹“хpX“цcz“ч“K“шib“щ™Д“ъ~“ыuw“ьSW“эi`“юŽп“я–у“№l]“ёNŒ“ђ\<“ѓ_“єщ“ѕS“іŒб“ї€‰“ј†y“љ^џ“њeх“ћNs“ќQe”@Y‚”A\?”B—ю”CNћ”DYŠ”E_Э”FŠ”Goс”HyА”Iyb”J[ч”K„q”Ls+”MqБ”N^t”O_ѕ”Pc{”Qdš”RqУ”S|˜”TNC”U^ќ”VNK”WWм”XVЂ”Y`Љ”ZoУ”[} ”\€§”]3”^П”_В”`‰—”a†Є”b]є”cbŠ”dd­”e‰‡”fgw”glт”hm>”it6”jx4”kZF”lu”m‚­”n™Ќ”oOѓ”p^У”qbн”rc’”seW”tgo”uvУ”vrL”w€Ь”x€К”y)”z‘M”{P ”|Wљ”}Z’”~h…”€is”qd”‚r§”ƒŒЗ”„Xђ”…Œр”†–j”‡”ˆ‡”‰yф”Šwч”‹„)”ŒO/”Re”ŽSZ”bЭ”gЯ”‘lЪ”’v}”“{”””|•”•‚6”–…„”—ы”˜fн”™o ”šr”›~”œƒЋ”™С”žžІ”ŸQ§” {Б”Ёxr”Ђ{И”Ѓ€‡”Є{H”Ѕjш”І^a”Ї€Œ”ЈuQ”Љu`”ЊQk”Ћ’b”ЌnŒ”­vz”Ў‘—”Џšъ”АO”Бp”Вbœ”Г{O”Д•Ѕ”Еœщ”ЖVz”ЗXY”И†ф”Й–М”КO4”ЛR$”МSJ”НSЭ”ОSл”П^”Рd,”Сe‘”Тg”Уl>”ФlN”ХrH”ЦrЏ”Чsэ”ШuT”Щ~A”Ъ‚,”Ы…щ”ЬŒЉ”Э{Ф”Ю‘Ц”Яqi”а˜”б˜я”вc=”гfi”дuj”еvф”жxа”з…C”и†ю”йS*”кSQ”лT&”мYƒ”н^‡”о_|”п`В”рbI”сby”тbЋ”уe”фkд”хlЬ”цuВ”чvЎ”шx‘”щyи”ъ}Ы”ыw”ь€Ѕ”эˆЋ”юŠЙ”яŒЛ”№”ё—^”ђ˜л”ѓj ”є|8”ѕP™”і\>”ї_Ў”јg‡”љkи”њt5”ћw ”ќŽ•@Ÿ;•AgЪ•Bz•CS9•Du‹•Ešэ•F_f•G•Hƒё•I€˜•J_<•K_Х•Lub•M{F•N<•Ohg•PYы•QZ›•R}•Sv~•T‹,•UOѕ•V_j•Wj•Xl7•Yo•Ztт•[yh•\ˆh•]ŠU•^Œy•_^п•`cЯ•auХ•byв•c‚з•d“(•e’ђ•f„œ•g†э•hœ-•iTС•j_l•keŒ•lm\•mp•nŒЇ•oŒг•p˜;•qeO•rtі•sN •tNи•uWр•vY+•wZf•x[Ь•yQЈ•z^•{^œ•|`•}bv•~ew•€eЇ•fn•‚mn•ƒr6•„{&•…P•†š•‡‚™•ˆ‹\•‰Œ •ŠŒц•‹t•Œ–•–D•ŽOЎ•dЋ•kf•‘‚•’„a•“…j•”ш••\•–iS•—˜Ј•˜„z•™…W•šO•›Ro•œ_Љ•^E•žg •Ÿy• y•Ё‰•Ђ‰†•Ѓmѕ•Є_•ЅbU•ІlИ•ЇNЯ•Јri•Љ›’•ЊR•ЋT;•ЌVt•­XГ•ЎaЄ•Џbn•Аq•БYn•В|‰•Г|о•Д}•Е–№•Жe‡•З€^•ИN•ЙOu•КQu•ЛX@•М^c•Н^s•О_ •ПgФ•РN&•С…=•Т•‰•У–[•Ф|s•Х˜•ЦPћ•ЧXС•ШvV•ЩxЇ•ЪR%•ЫwЅ•Ь…•Э{†•ЮPO•ЯY •аrG•б{Ч•в}ш•гК•дд•еM•жOП•зRЩ•иZ)•й_•к—­•лOн•м‚•н’ъ•оW•пcU•рki•сu+•тˆм•у•фzB•хRп•цX“•чaU•шb •щfЎ•ъkЭ•ы|?•ьƒщ•эP#•юOј•яS•№TF•ёX1•ђYI•ѓ[•є\№•ѕ\я•і])•ї^–•јbБ•љcg•њe>•ћeЙ•ќg –@lе–Alс–Bpљ–Cx2–D~+–E€о–F‚Г–G„ –H„ь–I‡–J‰–KŠ*–LŒJ–MІ–N’в–O˜§–Pœѓ–Ql–RNO–SNЁ–TP–URV–VWJ–WYЈ–X^=–Y_и–Z_й–[b?–\fД–]g–^gа–_hв–`Q’–a}!–b€Њ–cЈ–d‹–eŒŒ–fŒП–g’~–h–2–iT –j˜,–kS–lPе–mS\–nXЈ–odВ–pg4–qrg–rwf–szF–t‘ц–uRУ–vlЁ–wk†–xX–y^L–zYT–{g,–|ћ–}Qс–~vЦ–€di–xш–‚›T–ƒžЛ–„WЫ–…YЙ–†f'–‡gš–ˆkЮ–‰Tщ–Šiй–‹^U–Œœ–g•–Ž›Њ–gў–œR–‘h]–’NІ–“Oу–”SШ–•bЙ––g+–—lЋ–˜Ф–™O­–š~m–›žП–œN–ab–žn€–Ÿo+– …–ЁTs–Ђg*–Ѓ›E–Є]ѓ–Ѕ{•–І\Ќ–Ї[Ц–Ј‡–ЉnJ–Њ„б–Ћz–Ќ–­Y™–Ў|–Џl–Аw –БRй–ВY"–Гq!–Дr_–Еwл–Ж—'–Зa–Иi –ЙZ–КZ–ЛQЅ–МT –НT}–Оf–Пvп–Рї–С’˜–Тœє–УYъ–Фr]–ХnХ–ЦQM–ЧhЩ–Ш}П–Щ}ь–Ъ—b–ЫžК–Ьdx–Эj!–Юƒ–ЯY„–а[_–бkл–вs–гvђ–д}В–е€–ж„™–зQ2–иg(–йžй–кvю–лgb–мRџ–н™–о\$–пb;–р|~–сŒА–тUO–у`Ж–ф} –х•€–цS–чN_–шQЖ–щY–ъr:–ы€6–ь‘Ю–э_%–юwт–яS„–№_y–ё}–ђ…Ќ–ѓŠ3–єŽ–ѕ—V–іgѓ–ї…Ў–ј”S–љa –њa–ћlЙ–ќvR—@Šэ—A8—BU/—COQ—DQ*—ERЧ—FSЫ—G[Ѕ—H^}—I` —Ja‚—Kcж—Lg —Mgк—Nng—OmŒ—Ps6—Qs7—Ru1—SyP—Tˆе—UŠ˜—VJ—W‘—Xѕ—Y–Ф—Z‡—[Y—\Nˆ—]OY—^N—_Š‰—`?—a˜—bP­—c^|—dY–—e[Й—f^И—gcк—hcњ—idС—jfм—kiJ—liи—mm —nnЖ—oq”—pu(—qzЏ—rŠ—s€—t„I—u„Щ—v‰—w‹!—xŽ —ye—z–}—{™ —|a~—}b‘—~k2—€lƒ—mt—‚Ь—ƒќ—„mР—……—†‡К—‡ˆј—ˆge—‰ƒБ—Š˜<—‹–ї—Œm—}a—Ž„=—‘j—Nq—‘Su—’]P—“k—”oы—•…Э—–†-——‰Ї—˜R)—™T—š\e—›gN—œhЈ—t—žtƒ—Ÿuт— ˆЯ—Ёˆс—Ђ‘Ь—Ѓ–т—Є–x—Ѕ_‹—Іs‡—ЇzЫ—Ј„N—Љc —Њue—ЋR‰—ЌmA—­nœ—Ўt —ЏuY—Аxk—Б|’—В–†—Гzм—ДŸ—ЕOЖ—Жan—ЗeХ—И†\—ЙN†—КNЎ—ЛPк—МN!—НQЬ—О[ю—Пe™—Рh—СmМ—Тs—УvB—Фw­—Хz—Ц|ч—Ч‚o—ШŠв—Щ|—Ъ‘Я—Ы–u—Ь˜—ЭR›—Ю}б—ЯP+—аS˜—бg——вmЫ—гqа—дt3—еш—ж*—з–Ѓ—иœW—йžŸ—кt`—лXA—мm™—н}/—о˜^—пNф—рO6—сO‹—тQЗ—уRБ—ф]К—х`—цsВ—чy<—ш‚г—щ’4—ъ–З—ы–і—ь— —эž——юŸb—яfІ—№kt—ёR—ђRЃ—ѓpШ—єˆТ—ѕ^Щ—і`K—їa—јo#—љqI—њ|>—ћ}є—ќ€o˜@„ю˜A#˜B“,˜CTB˜D›o˜Ejг˜Fp‰˜GŒТ˜Hя˜I—2˜JRĘKZA˜L^ژM_˜Ng˜Oi|˜Pi”˜Qmj˜Ro˜Srb˜Trќ˜U{э˜V€˜W€~˜X‡K˜YЮ˜ZQm˜[ž“˜\y„˜]€‹˜^“2˜_Šж˜`P-˜aTŒ˜bŠq˜ckj˜dŒФ˜e˜f`б˜gg ˜hђ˜iN™˜jN˜˜kœ˜lŠk˜m…С˜n…h˜oi˜pn~˜qx—˜rU˜Ÿ_ ˜ N˜ЁN˜ЂN*˜ЃN1˜ЄN6˜ЅN<˜ІN?˜ЇNB˜ЈNV˜ЉNX˜ЊN‚˜ЋN…˜ЌŒk˜­NŠ˜Ў‚˜Џ_ ˜АNŽ˜БNž˜ВNŸ˜ГN ˜ДNЂ˜ЕNА˜ЖNØЗNƘИNޘЙNݘКNԘЛN֘МNҘНNз˜ОNо˜ПNэ˜РNп˜СNї˜ТO ˜УOZ˜ФO0˜ХO[˜ЦO]˜ЧOW˜ШOG˜ЩOv˜ЪOˆ˜ЫO˜ЬO˜˜ЭO{˜ЮOi˜ЯOp˜аO‘˜бOo˜вO†˜гO–˜дQ˜еOд˜жOп˜зOޘиOи˜йOл˜кOб˜лOк˜мOа˜нOф˜оOх˜пP˜рP(˜сP˜тP*˜уP%˜фP˜хO˜цOі˜чP!˜шP)˜щP,˜ъOў˜ыOя˜ьP˜эP˜юPC˜яPG˜№g˜ёPU˜ђPP˜ѓPH˜єPZ˜ѕPV˜іPl˜їPx˜јP€˜љPš˜њP…˜ћPĘќPВ™@PЩ™APЪ™BPГ™CPТ™DPж™EPо™FPх™GPэ™HPу™IPю™JPљ™KPѕ™LQ ™MQ™NQ™OQ™PQ™QQ™RQ™SQ!™TQ:™UQ7™VQ<™WQ;™XQ?™YQ@™ZQR™[QL™\QT™]Qb™^zј™_Qi™`Qj™aQn™bQ€™cQ‚™dVи™eQŒ™fQ‰™gQ™hQ‘™iQ“™jQ•™kQ–™lQЄ™mQІ™nQЂ™oQЉ™pQЊ™qQЋ™rQГ™sQБ™tQВ™uQА™vQЕ™wQН™xQХ™yQЩ™zQл™{Qр™|†U™}Qщ™~Qэ™€Q№™Qѕ™‚Qў™ƒR™„R ™…R™†R™‡R'™ˆR*™‰R.™ŠR3™‹R9™ŒRO™RD™ŽRK™RL™R^™‘RT™’Rj™“Rt™”Ri™•Rs™–R™—R}™˜R™™R”™šR’™›Rq™œRˆ™R‘™žЈ™ŸЇ™ RЌ™ЁR­™ЂRМ™ЃRЕ™ЄRС™ЅRЭ™ІRз™ЇRо™ЈRу™ЉRц™Њ˜э™ЋRр™ЌRѓ™­Rѕ™ЎRј™ЏRљ™АS™БS™Вu8™ГS ™ДS™ЕS™ЖS™ЗS™ИS#™ЙS/™КS1™ЛS3™МS8™НS@™ОSF™ПSE™РN™СSI™ТSM™УQж™ФS^™ХSi™ЦSn™ЧY™ШS{™ЩSw™ЪS‚™ЫS–™ЬS ™ЭSІ™ЮSЅ™ЯSЎ™аSА™бSЖ™вSУ™г|™д–й™еSп™жfќ™зqю™иSю™йSш™кSэ™лSњ™мT™нT=™оT@™пT,™рT-™сT<™тT.™уT6™фT)™хT™цTN™чT™шTu™щTŽ™ъT_™ыTq™ьTw™эTp™юT’™яT{™№T€™ёTv™ђT„™ѓT™єT†™ѕTЧ™іTЂ™їTИ™јTЅ™љTЌ™њTФ™ћTШ™ќTЈš@TЋšATТšBTЄšCTОšDTМšETиšFTхšGTцšHUšIUšJT§šKTюšLTэšMTњšNTтšOU9šPU@šQUcšRULšSU.šTU\šUUEšVUVšWUWšXU8šYU3šZU]š[U™š\U€š]TЏš^UŠš_UŸš`U{šaU~šbU˜šcUžšdUЎšeU|šfUƒšgUЉšhU‡šiUЈšjUкškUХšlUпšmUФšnUмšoUфšpUдšqVšrUїšsVštUўšuU§švVšwUљšxVNšyVPšzqпš{V4š|V6š}V2š~V8š€VkšVdš‚V/šƒVlš„Vjš…V†š†V€š‡VŠšˆV š‰V”šŠVš‹VЅšŒVЎšVЖšŽVДšVТšVМš‘VСš’VУš“VРš”VШš•VЮš–Vбš—Vгš˜Vзš™VюššVљš›WšœVџšWšžW šŸWš W šЁW šЂWšЃWšЄWšЅUЧšІWšЇW&šЈW7šЉW8šЊWNšЋW;šЌW@š­WOšЎWišЏWРšАWˆšБWašВWšГW‰šДW“šЕW šЖWГšЗWЄšИWЊšЙWАšКWУšЛWЦšМWдšНWвšОWгšПX šРWжšСWуšТX šУXšФXšХXršЦX!šЧXbšШXKšЩXpšЪkРšЫXRšЬX=šЭXyšЮX…šЯXЙšаXŸšбXЋšвXКšгXоšдXЛšеXИšжXЎšзXХšиXгšйXбšкXзšлXйšмXиšнXхšоXмšпXфšрXпšсXяšтXњšуXљšфXћšхXќšцX§šчYšшY šщYšъYšыhІšьY%šэY,šюY-šяY2š№Y8šёY>šђzвšѓYUšєYPšѕYNšіYZšїYXšјYbšљY`šњYgšћYlšќYi›@Yx›AY›BY›CO^›DOЋ›EYЃ›FYВ›GYЦ›HYш›IYм›JY›KYй›LYк›MZ%›NZ›OZ›PZ›QZ ›RZ›SZ@›TZl›UZI›VZ5›WZ6›XZb›YZj›ZZš›[ZМ›\ZО›]ZЫ›^ZТ›_ZН›`Zу›aZз›bZц›cZщ›dZж›eZњ›fZћ›g[ ›h[ ›i[›j[2›kZа›l[*›m[6›n[>›o[C›p[E›q[@›r[Q›s[U›t[Z›u[[›v[e›w[i›x[p›y[s›z[u›{[x›|eˆ›}[z›~[€›€[ƒ›[І›‚[И›ƒ[У›„[Ч›…[Щ›†[䛇[а›ˆ[ф›‰[ц›Š[т›‹[о›Œ[х›[ы›Ž[№›[і›[ѓ›‘\›’\›“\›”\ ›•\›–\ ›—\"›˜\(›™\8›š\9››\A›œ\F›\N›ž\S›Ÿ\P› \O›Ё[q›Ђ\l›Ѓ\n›ЄNb›Ѕ\v›І\y›Ї\Œ›Ј\‘›Љ\”›ЊY››Ћ\Ћ›Ќ\Л›­\Ж›Ў\М›Џ\З›А\Х›Б\О›В\Ч›Г\й›Д\щ›Е\§›Ж\њ›З\э›И]Œ›Й\ъ›К] ›Л]›М]›Н]\›О]›П]›Р]›С]›Т]"›У]›Ф]›Х]›Ц]L›Ч]R›Ш]N›Щ]K›Ъ]l›Ы]s›Ь]v›Э]‡›Ю]„›Я]‚›а]Ђ›б]›в]Ќ›г]Ў›д]Н›е]›ж]З›з]М›и]Щ›й]Э›к]г›л]в›м]ж›н]л›о]ы›п]ђ›р]ѕ›с^ ›т^›у^›ф^›х^›ц^6›ч^7›ш^D›щ^C›ъ^@›ы^N›ь^W›э^T›ю^_›я^b›№^d›ё^G›ђ^u›ѓ^v›є^z›ѕžМ›і^›ї^ ›ј^С›љ^Т›њ^Ш›ћ^а›ќ^Яœ@^жœA^уœB^нœC^кœD^лœE^тœF^сœG^шœH^щœI^ьœJ^ёœK^ѓœL^№œM^єœN^јœO^ўœP_œQ_ œR_]œS_\œT_ œU_œV_œW_)œX_-œY_8œZ_Aœ[_Hœ\_Lœ]_Nœ^_/œ__Qœ`_Vœa_Wœb_Yœc_aœd_mœe_sœf_wœg_ƒœh_‚œi_œj_Šœk_ˆœl_‘œm_‡œn_žœo_™œp_˜œq_ œr_Јœs_­œt_Мœu_жœv_ћœw_фœx_јœy_ёœz_нœ{`Гœ|_џœ}`!œ~``œ€`œ`œ‚`)œƒ`œ„`1œ…`œ†`œ‡`+œˆ`&œ‰`œŠ`:œ‹`ZœŒ`Aœ`jœŽ`wœ`_œ`Jœ‘`Fœ’`Mœ“`cœ”`Cœ•`dœ–`Bœ—`lœ˜`kœ™`Yœš`œ›`œœ`чœ`ƒœž`šœŸ`„œ `›œЁ`–œЂ`—œЃ`’œЄ`ЇœЅ`‹œІ`сœЇ`ИœЈ`рœЉ`гœЊ`ДœЋ_№œЌ`Нœ­`ЦœЎ`ЕœЏ`иœАaMœБaœВaœГ`іœД`їœЕaœЖ`єœЗ`њœИaœЙa!œК`ћœЛ`ёœМa œНaœОaGœПa>œРa(œСa'œТaJœУa?œФa<œХa,œЦa4œЧa=œШaBœЩaDœЪasœЫawœЬaXœЭaYœЮaZœЯakœаatœбaoœвaeœгaqœдa_œеa]œжaSœзauœиa™œйa–œкa‡œлaЌœмa”œнašœоaŠœпa‘œрaЋœсaЎœтaЬœуaЪœфaЩœхaїœцaШœчaУœшaЦœщaКœъaЫœыyœьaЭœэaцœюaуœяaіœ№aњœёaєœђaџœѓa§œєaќœѕaўœіbœїbœјb œљb œњb œћbœќb@bAb!Bb*Cb.Db0Eb2Fb3GbAHbNIb^JbcKb[Lb`MbhNb|Ob‚Pb‰Qb~Rb’Sb“Tb–UbдVbƒWb”XbзYbбZbЛ[bЯ\bџ]bЦ^dд_bШ`bмabЬbbЪcbТdbЧeb›fbЩgc hbюibёjc'kclcmbяnbѕocPpc>qcMrdscOtc–ucŽvc€wcЋxcvycЃzc{c‰|cŸ}cЕ~ck€cicО‚cщƒcР„cЦ…cу†cЩ‡cвˆcі‰cФŠd‹d4ŒddŽd&d6e‘d’d(“d”dg•do–dv—dN˜e*™d•šd“›dЅœdЉdˆždМŸdк dвЁdХЂdЧЃdЛЄdиЅdТІdёЇdчЈ‚ ЉdрЊdсЋbЌЌdу­dяЎe,ЏdіАdєБdђВdњГeДd§ЕeЖeЗeИe$Йe#Кe+Лe4Мe5Нe7Оe6Пe8РuKСeHТeVУeUФeMХeXЦe^Чe]ШerЩexЪe‚ЫeƒЬ‹ŠЭe›ЮeŸЯeЋаeЗбeУвeЦгeСдeФеeЬжeвзeлиeййeркeслeёмgrнf оfпeћрgsсf5тf6уf4фfхfOцfDчfIшfAщf^ъf]ыfdьfgэfhюf_яfb№fpёfƒђfˆѓfŽєf‰ѕf„іf˜їfјfСљfЙњfЩћfОќfМž@fФžAfИžBfжžCfкžDfрžEf?žFfцžGfщžHf№žIfѕžJfїžKgžLgžMgžNg&žOg'žP—8žQg.žRg?žSg6žTgAžUg8žVg7žWgFžXg^žYg`žZgYž[gcž\gdž]g‰ž^gpž_gЉž`g|žagjžbgŒžcg‹ždgІžegЁžfg…žggЗžhgяžigДžjgьžkgГžlgщžmgИžngфžogоžpgнžqgтžrgюžsgЙžtgЮžugЦžvgчžwjœžxhžyhFžzh)ž{h@ž|hMž}h2ž~hNž€hГžh+ž‚hYžƒhcž„hwž…hž†hŸž‡hžˆh­ž‰h”žŠhž‹h›žŒhƒžjЎžŽhЙžhtžhЕž‘h ž’hКž“iž”hž•h~ž–iž—hЪž˜iž™hиžši"ž›i&žœhсži žžhЭžŸhдž hчžЁhеžЂi6žЃižЄižЅhзžІhуžЇi%žЈhљžЉhрžЊhяžЋi(žЌi*ž­ižЎi#žЏi!žАhЦžБiyžВiwžГi\žДixžЕikžЖiTžЗi~žИinžЙi9žКitžЛi=žМiYžНi0žОiažПi^žРi]žСižТijžУiВžФiЎžХiаžЦiПžЧiСžШiгžЩiОžЪiЮžЫ[шžЬiЪžЭiнžЮiЛžЯiУžаiЇžбj.žвi‘žгi žдiœžеi•žжiДžзiоžиiшžйjžкjžлiџžмk žнiљžоiђžпiчžрjžсiБžтjžуiэžфjžхiыžцj žчjžшjСžщj#žъjžыjDžьj žэjržюj6žяjxž№jGžёjbžђjYžѓjfžєjHžѕj8žіj"žїjžјjžљj žњj„žћjЂžќjЃŸ@j—ŸA†ŸBjЛŸCjУŸDjТŸEjИŸFjГŸGjЌŸHjоŸIjбŸJjпŸKjЊŸLjкŸMjъŸNjћŸOkŸP†ŸQjњŸRkŸSkŸT›1ŸUkŸVk8ŸWk7ŸXvмŸYk9ŸZ˜юŸ[kGŸ\kCŸ]kIŸ^kPŸ_kYŸ`kTŸak[Ÿbk_ŸckaŸdkxŸekyŸfkŸgk€Ÿhk„ŸikƒŸjkŸkk˜Ÿlk•ŸmkžŸnkЄŸokЊŸpkЋŸqkЏŸrkВŸskБŸtkГŸukЗŸvkМŸwkЦŸxkЫŸykгŸzkпŸ{kьŸ|kыŸ}kѓŸ~kяŸ€žОŸlŸ‚lŸƒlŸ„lŸ…l$Ÿ†l#Ÿ‡l^ŸˆlUŸ‰lbŸŠljŸ‹l‚ŸŒlŸlšŸŽlŸl›Ÿl~Ÿ‘lhŸ’lsŸ“l’Ÿ”lŸ•lФŸ–lёŸ—lгŸ˜lНŸ™lзŸšlХŸ›lнŸœlЎŸlБŸžlОŸŸlКŸ lлŸЁlяŸЂlйŸЃlъŸЄmŸЅˆMŸІm6ŸЇm+ŸЈm=ŸЉm8ŸЊmŸЋm5ŸЌm3Ÿ­mŸЎm ŸЏmcŸАm“ŸБmdŸВmZŸГmyŸДmYŸЕmŽŸЖm•ŸЗoфŸИm…ŸЙmљŸКnŸЛn ŸМmЕŸНmЧŸОmцŸПmИŸРmЦŸСmьŸТmоŸУmЬŸФmшŸХmвŸЦmХŸЧmњŸШmйŸЩmфŸЪmеŸЫmъŸЬmюŸЭn-ŸЮnnŸЯn.ŸаnŸбnrŸвn_Ÿгn>Ÿдn#ŸеnkŸжn+ŸзnvŸиnMŸйnŸкnCŸлn:ŸмnNŸнn$ŸоnџŸпnŸрn8Ÿсn‚ŸтnЊŸуn˜ŸфnЩŸхnЗŸцnгŸчnНŸшnЏŸщnФŸъnВŸыnдŸьnеŸэnŸюnЅŸяnТŸ№nŸŸёoAŸђoŸѓpLŸєnьŸѕnјŸіnўŸїo?ŸјnђŸљo1ŸњnяŸћo2ŸќnЬЁџaЂџbЃџcЄџdЅџeІџfЇџgЈџhЉџiЊџjЋџkЌџl­џmЎџnЏџoАџpБџqВџrГџsДџtЕџuЖџvЗџwИџxЙџyКџzЛџ{Мџ|Нџ}Оџ~ПџРџ€СџТџ‚УџƒФџ„Хџ…Цџ†Чџ‡ШџˆЩџ‰ЪџŠЫџ‹ЬџŒЭџЮџŽЯџаџбџ‘вџ’гџ“дџ”еџ•жџ–зџ—иџ˜йџ™кџšлџ›мџœнџоџžпџŸр@o>рAoрBnїрCo†рDozрEoxрFoрGo€рHooрIo[рJoѓрKomрLo‚рMo|рNoXрOoŽрPo‘рQoТрRofрSoГрToЃрUoЁрVoЄрWoЙрXoЦрYoЊрZoпр[oер\oьр]oдр^oир_oёр`oюрaoлрbp рcp рdoњрepрfpрgpрhoўрipрjpрkotрlpрmpрnpрop0рpp>рqp2рrpQрspcрtp™рup’рvpЏрwpёрxpЌрypИрzpГр{pЎр|pпр}pЫр~pнр€pйрq р‚p§рƒqр„qр…qeр†qUр‡qˆрˆqfр‰qbрŠqLр‹qVрŒqlрqрŽqћрq„рq•р‘qЈр’qЌр“qзр”qЙр•qОр–qвр—qЩр˜qдр™qЮрšqрр›qьрœqчрqѕрžqќрŸqљр qџрЁr рЂrрЃrрЄr(рЅr-рІr,рЇr0рЈr2рЉr;рЊr<рЋr?рЌr@р­rFрЎrKрЏrXрАrtрБr~рВr‚рГrрДr‡рЕr’рЖr–рЗrЂрИrЇрЙrЙрКrВрЛrУрМrЦрНrФрОrЮрПrврРrтрСrррТrсрУrљрФrїрХPрЦsрЧs рШsрЩsрЪsрЫs4рЬs/рЭs)рЮs%рЯs>раsNрбsOрвžиргsWрдsjреshржspрзsxриsuрйs{ркszрлsШрмsГрнsЮроsЛрпsРррsхрсsюртsоруtЂрфtрхtoрцt%рчsјршt2рщt:ръtUрыt?рьt_рэtYрюtAряt\р№tiрёtpрђtcрѓtjрєtvрѕt~ріt‹рїtžрјtЇрљtЪрњtЯрћtдрќsёс@tрсAtусBtчсCtщсDtюсEtђсFt№сGtёсHtјсItїсJuсKuсLuсMu сNuсOu сPuсQuсRuсSu&сTu,сUu<сVuDсWuMсXuJсYuIсZu[с[uFс\uZс]uiс^udс_ugс`ukсaumсbuxсcuvсdu†сeu‡сfutсguŠсhu‰сiu‚сju”сkušсluсmuЅсnuЃсouТсpuГсquУсruЕсsuНсtuИсuuМсvuБсwuЭсxuЪсyuвсzuйс{uус|uос}uўс~uџс€uќсvс‚u№сƒuњс„uђс…uѓс†v с‡v сˆv с‰vсŠv'с‹v сŒv!сv"сŽv$сv4сv0с‘v;с’vGс“vHс”vFс•v\с–vXс—vaс˜vbс™vhсšviс›vjсœvgсvlсžvpсŸvrс vvсЁvxсЂv|сЃv€сЄvƒсЅvˆсІv‹сЇvŽсЈv–сЉv“сЊv™сЋvšсЌvАс­vДсЎvИсЏvЙсАvКсБvТсВvЭсГvжсДvвсЕvосЖvссЗvхсИvчсЙvъсК†/сЛvћсМwсНwсОwсПw)сРw$сСwсТw%сУw&сФwсХw7сЦw8сЧwGсШwZсЩwhсЪwkсЫw[сЬweсЭwсЮw~сЯwyсаwŽсбw‹свw‘сгw сдwžсеwАсжwЖсзwЙсиwПсйwМскwНслwЛсмwЧснwЭсоwзспwксрwмссwустwюсуwќсфx схxсцy&счx сшy*сщxEсъxŽсыxtсьx†сэx|сюxšсяxŒс№xЃсёxЕсђxЊсѓxЏсєxбсѕxЦсіxЫсїxдсјxОсљxМсњxХсћxЪсќxьт@xчтAxктBx§тCxєтDyтEyтFyтGyтHy,тIy+тJy@тKy`тLyWтMy_тNyZтOyUтPySтQyzтRyтSyŠтTyтUyЇтVŸKтWyЊтXyЎтYyГтZyЙт[yКт\yЩт]yет^yчт_yьт`yстayутbzтcz тdzтezтfz тgzтhy€тiz1тjz;тkz>тlz7тmzCтnzWтozIтpzaтqzbтrziтsŸтtzpтuzyтvz}тwzˆтxz—тyz•тzz˜т{z–т|zЉт}zШт~zАт€zЖтzХт‚zФтƒzПт„ƒт…zЧт†zЪт‡zЭтˆzЯт‰zетŠzгт‹zйтŒzктzнтŽzстzттzцт‘zэт’z№т“{т”{т•{ т–{т—{3т˜{т™{тš{т›{5тœ{(т{6тž{PтŸ{zт {тЁ{MтЂ{ тЃ{LтЄ{EтЅ{uтІ{eтЇ{tтЈ{gтЉ{pтЊ{qтЋ{lтЌ{nт­{тЎ{˜тЏ{ŸтА{тБ{œтВ{šтГ{‹тД{’тЕ{тЖ{]тЗ{™тИ{ЫтЙ{СтК{ЬтЛ{ЯтМ{ДтН{ЦтО{нтП{щтР|тС|тТ{цтУ{хтФ|`тХ|тЦ|тЧ|тШ{ѓтЩ{їтЪ|тЫ| тЬ{ітЭ|#тЮ|'тЯ|*та|тб|7тв|+тг|=тд|Lте|Cтж|Tтз|Oти|@тй|Pтк|Xтл|_тм|dтн|Vто|eтп|lтр|uтс|ƒтт|ту|Єтф|­тх|Ђтц|Ћтч|Ётш|Јтщ|Гтъ|Вты|Бть|Ўтэ|Йтю|Нтя|Рт№|Хтё|Ттђ|итѓ|втє|мтѕ|тті›;тї|ятј|ђтљ|єтњ|ітћ|њтќ}у@}уA}уB}уC} уD}EуE}KуF}.уG}2уH}?уI}5уJ}FуK}sуL}VуM}NуN}rуO}hуP}nуQ}OуR}cуS}“уT}‰уU}[уV}уW}}уX}›уY}КуZ}Ўу[}Ѓу\}Еу]}Чу^}Ну_}Ћу`~=уa}Ђуb}Џуc}муd}Иуe}Ÿуf}Ауg}иуh}нуi}фуj}оуk}ћуl}ђуm}суn~уo~ уp~#уq~!уr~уs~1уt~уu~ уv~ уw~"уx~Fуy~fуz~;у{~5у|~9у}~Cу~~7у€~2у~:у‚~gуƒ~]у„~Vу…~^у†~Yу‡~Zуˆ~yу‰~jуŠ~iу‹~|уŒ~{у~ƒуŽ}еу~}уЎу‘~у’~ˆу“~‰у”~Œу•~’у–~у—~“у˜~”у™~–уš~Žу›~›уœ~œу8уž:уŸEу LуЁMуЂNуЃPуЄQуЅUуІTуЇXуЈ_уЉ`уЊhуЋiуЌgу­xуЎ‚уЏ†уАƒуБˆуВ‡уГŒуД”уЕžуЖуЗšуИЃуЙЏуКВуЛЙуМЎуНЖуОИуП‹qуРХуСЦуТЪуУеуФдуХсуЦцуЧщуШѓуЩљуژмуЫ€уЬ€уЭ€ уЮ€уЯ€уа€уб€ув€!уг€(уд€?уе€;уж€Jуз€Fуи€Rуй€Xук€Zул€_ум€bун€hуо€sуп€rур€pус€vут€yуу€}уф€ух€„уц€†уч€…уш€›ущ€“уъ€šуы€­уьQуэ€Ќую€луя€ху№€йуё€нуђ€Фуѓ€кує€жуѕ уі€яуї€ёујуљ)уњ#ућ/уќKф@–‹фAFфB>фCSфDQфE€ќфFqфGnфHeфIfфJtфKƒфLˆфMŠфN€фO‚фP фQ•фRЄфSЃфT_фU“фVЉфWАфXЕфYОфZИф[Нф\Рф]Тф^Кф_Щф`ЭфaбфbйфcифdШфeкфfпфgрфhчфiњфjћфkўфl‚фm‚фn‚фo‚фp‚ фq‚ фr‚фs‚фt‚)фu‚+фv‚8фw‚3фx‚@фy‚Yфz‚Xф{‚]ф|‚Zф}‚_ф~‚dф€‚bф‚hф‚‚jфƒ‚kф„‚.ф…‚qф†‚wф‡‚xфˆ‚~ф‰‚фŠ‚’ф‹‚ЋфŒ‚Ÿф‚ЛфŽ‚Ќф‚сф‚уф‘‚пф’‚вф“‚єф”‚ѓф•‚њф–ƒ“ф—ƒф˜‚ћф™‚љфš‚оф›ƒфœ‚мфƒ фž‚йфŸƒ5ф ƒ4фЁƒфЂƒ2фЃƒ1фЄƒ@фЅƒ9фІƒPфЇƒEфЈƒ/фЉƒ+фЊƒфЋƒфЌƒ…ф­ƒšфЎƒЊфЏƒŸфАƒЂфБƒ–фВƒ#фГƒŽфДƒ‡фЕƒŠфЖƒ|фЗƒЕфИƒsфЙƒuфКƒ фЛƒ‰фМƒЈфНƒєфО„фПƒыфРƒЮфСƒ§фТ„фУƒифФ„ фХƒСфЦƒїфЧ„фШƒрфЩƒђфЪ„ фЫ„"фЬ„ фЭƒНфЮ„8фЯ…фаƒћфб„mфв„*фг„<фд…Zфе„„фж„wфз„kфи„­фй„nфк„‚фл„iфм„Fфн„,фо„oфп„yфр„5фс„Ъфт„bфу„Йфф„Пфх„Ÿфц„йфч„Эфш„Лфщ„кфъ„афы„Сфь„Цфэ„жфю„Ёфя…!ф№„џфё„єфђ…фѓ…фє…,фѕ…фі…фї…фј„ќфљ…@фњ…cфћ…Xфќ…Hх@…AхA†хB…KхC…UхD…€хE…ЄхF…ˆхG…‘хH…ŠхI…ЈхJ…mхK…”хL…›хM…ъхN…‡хO…œхP…wхQ…~хR…хS…ЩхT…КхU…ЯхV…ЙхW…ахX…ехY…нхZ…хх[…мх\…љх]† х^†х_† х`…ўхa…њхb†хc†"хd†хe†0хf†?хg†MхhNUхi†Tхj†_хk†gхl†qхm†“хn†Ѓхo†Љхp†Њхq†‹хr†Œхs†Жхt†Џхu†Фхv†Цхw†Ахx†Щхyˆ#хz†Ћх{†дх|†ох}†щх~†ьх€†пх†лх‚†яхƒ‡х„‡х…‡х†‡х‡‡хˆ†ћх‰‡хŠ‡ х‹‡ хŒ†љх‡ хŽ‡4х‡?х‡7х‘‡;х’‡%х“‡)х”‡х•‡`х–‡_х—‡xх˜‡Lх™‡Nхš‡tх›‡Wхœ‡hх‡nхž‡YхŸ‡Sх ‡cхЁ‡jхЂˆхЃ‡ЂхЄ‡ŸхЅ‡‚хІ‡ЏхЇ‡ЫхЈ‡НхЉ‡РхЊ‡ахЋ–жхЌ‡Ћх­‡ФхЎ‡ГхЏ‡ЧхА‡ЦхБ‡ЛхВ‡яхГ‡ђхД‡рхЕˆхЖˆ хЗ‡ўхИ‡іхЙ‡їхКˆхЛ‡вхМˆхНˆхОˆхПˆ"хРˆ!хСˆ1хТˆ6хУˆ9хФˆ'хХˆ;хЦˆDхЧˆBхШˆRхЩˆYхЪˆ^хЫˆbхЬˆkхЭˆхЮˆ~хЯˆžхаˆuхбˆ}хвˆЕхгˆrхдˆ‚хеˆ—хжˆ’хзˆЎхиˆ™хйˆЂхкˆхлˆЄхмˆАхнˆПхоˆБхпˆУхрˆФхсˆдхтˆихуˆйхфˆнххˆљхц‰хчˆќхшˆєхщˆшхъˆђхы‰хь‰ хэ‰ хю‰хя‰Cх№‰хё‰%хђ‰*хѓ‰+хє‰Aхѕ‰Dхі‰;хї‰6хј‰8хљ‰Lхњ‰хћ‰`хќ‰^ц@‰fцA‰dцB‰mцC‰jцD‰oцE‰tцF‰wцG‰~цH‰ƒцI‰ˆцJ‰ŠцK‰“цL‰˜цM‰ЁцN‰ЉцO‰ІцP‰ЌцQ‰ЏцR‰ВцS‰КцT‰НцU‰ПцV‰РцW‰кцX‰мцY‰нцZ‰чц[‰єц\‰јц]Šц^Šц_Šц`Š цaŠцbŠцcŠ%цdŠ6цeŠAцfŠ[цgŠRцhŠFцiŠHцjŠ|цkŠmцlŠlцmŠbцnŠ…цoŠ‚цpŠ„цqŠЈцrŠЁцsŠ‘цtŠЅцuŠІцvŠšцwŠЃцxŠФцyŠЭцzŠТц{Šкц|Šыц}Šѓц~Šчц€ŠфцŠёц‚‹цƒŠрц„Šтц…Šїц†Šоц‡Šлцˆ‹ ц‰‹цŠ‹ц‹ŠсцŒ‹ц‹цŽ‹ц‹ ц‹3ц‘—Ћц’‹&ц“‹+ц”‹>ц•‹(ц–‹Aц—‹Lц˜‹Oц™‹Nцš‹Iц›‹Vцœ‹[ц‹Zцž‹kцŸ‹_ц ‹lцЁ‹oцЂ‹tцЃ‹}цЄ‹€цЅ‹ŒцІ‹ŽцЇ‹’цЈ‹“цЉ‹–цЊ‹™цЋ‹šцЌŒ:ц­ŒAцЎŒ?цЏŒHцАŒLцБŒNцВŒPцГŒUцДŒbцЕŒlцЖŒxцЗŒzцИŒ‚цЙŒ‰цКŒ…цЛŒŠцМŒцНŒŽцОŒ”цПŒ|цРŒ˜цСbцТŒ­цУŒЊцФŒНцХŒВцЦŒГцЧŒЎцШŒЖцЩŒШцЪŒСцЫŒфцЬŒуцЭŒкцЮŒ§цЯŒњцаŒћцбцвцг цдцецж цзциŸNцйцкŒЭцлцмцнgцоmцпqцрsцсцт™цуТцфОцхКццЯцчкцшжцщЬцълцыЫцьъцэыцюпцяуц№ќцёŽцђŽ цѓџцєŽцѕŽціŽцїŽцјŽBцљŽ5цњŽ0цћŽ4цќŽJч@ŽGчAŽIчBŽLчCŽPчDŽHчEŽYчFŽdчGŽ`чHŽ*чIŽcчJŽUчKŽvчLŽrчMŽ|чNŽчOŽ‡чPŽ…чQŽ„чRŽ‹чSŽŠчTŽ“чUŽ‘чVŽ”чWŽ™чXŽЊчYŽЁчZŽЌч[ŽАч\ŽЦч]ŽБч^ŽОч_ŽХч`ŽШчaŽЫчbŽлчcŽучdŽќчeŽћчfŽычgŽўчh чiчjчkчlчmчnчoчpчq чr&чs3чt;чu9чvEчwBчx>чyLчzIч{Fч|Nч}Wч~\ч€bчcч‚dчƒœч„Ÿч…Ѓч†­ч‡ЏчˆЗч‰кчŠхч‹тчŒъчячŽ‡чєчч‘љч’њч“ч”ч•!ч– ч—ч˜ч™ чš'ч›6чœ5ч9чžјчŸOч PчЁQчЂRчЃчЄIчЅ>чІVчЇXчЈ^чЉhчЊoчЋvчЌ–Јч­rчЎ‚чЏ}чАчБ€чВŠчГ‰чДчЕЈчЖЏчЗБчИЕчЙтчКфчЛbHчМлчН‘чО‘чП‘чР‘2чС‘0чТ‘JчУ‘VчФ‘XчХ‘cчЦ‘eчЧ‘iчШ‘sчЩ‘rчЪ‘‹чЫ‘‰чЬ‘‚чЭ‘ЂчЮ‘ЋчЯ‘Џча‘Њчб‘Ечв‘Дчг‘Кчд‘Рче‘Счж‘Щчз‘Ычи‘ачй‘жчк‘пчл‘счм‘лчн‘ќчо‘ѕчп‘ічр’чс‘џчт’чу’,чф’чх’чц’^чч’Wчш’Eчщ’Iчъ’dчы’Hчь’•чэ’?чю’Kчя’Pч№’œчё’–чђ’“чѓ’›чє’Zчѕ’Ячі’Йчї’Зчј’щчљ“чњ’њчћ“Dчќ“.ш@“шA“"шB“шC“#шD“:шE“5шF“;шG“\шH“`шI“|шJ“nшK“VшL“АшM“ЌшN“­шO“”шP“ЙшQ“жшR“зшS“шшT“хшU“ишV“УшW“ншX“ашY“ШшZ“фш[”ш\”ш]”ш^”ш_”ш`”шa”6шb”+шc”5шd”!шe”:шf”Aшg”Rшh”Dшi”[шj”`шk”bшl”^шm”jшn’)шo”pшp”uшq”wшr”}шs”Zшt”|шu”~шv”шw”шx•‚шy•‡шz•Šш{•”ш|•–ш}•˜ш~•™ш€• ш•Јш‚•Їшƒ•­ш„•Мш…•Лш†•Йш‡•Ошˆ•Ъш‰oішŠ•Уш‹•ЭшŒ•Ьш•ешŽ•дш•жш•мш‘•сш’•хш“•тш”–!ш•–(ш––.ш—–/ш˜–Bш™–Lшš–Oш›–Kшœ–wш–\шž–^шŸ–]ш –_шЁ–fшЂ–rшЃ–lшЄ–шЅ–˜шІ–•шЇ–—шЈ–ЊшЉ–ЇшЊ–БшЋ–ВшЌ–Аш­–ДшЎ–ЖшЏ–ИшА–ЙшБ–ЮшВ–ЫшГ–ЩшД–ЭшЕ‰MшЖ–мшЗ— шИ–ешЙ–љшК—шЛ—шМ—шН—шО—шП—шР—шС—шТ—шУ—$шФ—*шХ—0шЦ—9шЧ—=шШ—>шЩ—DшЪ—FшЫ—HшЬ—BшЭ—IшЮ—\шЯ—`ша—dшб—fшв—hшгRвшд—kше—qшж—yшз—…ши—|шй—шк—zшл—†шм—‹шн—шо—шп—œшр—Јшс—Ішт—Ѓшу—Гшф—Дшх—Ушц—Цшч—Шшш—Ышщ—мшъ—эшыŸOшь—ђшэzпшю—ішя—ѕш№˜шё˜ шђ˜8шѓ˜$шє˜!шѕ˜7ші˜=шї˜Fшј˜Oшљ˜Kшњ˜kшћ˜oшќ˜pщ@˜qщA˜tщB˜sщC˜ЊщD˜ЏщE˜БщF˜ЖщG˜ФщH˜УщI˜ЦщJ˜щщK˜ыщL™щM™ щN™щO™щP™щQ™!щR™щS™щT™$щU™ щV™,щW™.щX™=щY™>щZ™Bщ[™Iщ\™Eщ]™Pщ^™Kщ_™Qщ`™Rщa™Lщb™Uщc™—щd™˜щe™Ѕщf™­щg™Ўщh™Мщi™пщj™лщk™нщl™ищm™бщn™эщo™ющp™ёщq™ђщr™ћщs™јщtšщušщvšщw™тщxšщyš+щzš7щ{šEщ|šBщ}š@щ~šCщ€š>щšUщ‚šMщƒš[щ„šWщ…š_щ†šbщ‡šeщˆšdщ‰šiщŠškщ‹šjщŒš­щšАщŽšМщšРщšЯщ‘šбщ’šгщ“šдщ”šощ•šпщ–šтщ—šущ˜šцщ™šящššыщ›šющœšєщšёщžšїщŸšћщ ›щЁ›щЂ›щЃ›щЄ›"щЅ›#щІ›%щЇ›'щЈ›(щЉ›)щЊ›*щЋ›.щЌ›/щ­›2щЎ›DщЏ›CщА›OщБ›MщВ›NщГ›QщД›XщЕ›tщЖ›“щЗ›ƒщИ›‘щЙ›–щК›—щЛ›ŸщМ› щН›ЈщО›ДщП›РщР›ЪщС›ЙщТ›ЦщУ›ЯщФ›бщХ›вщЦ›ущЧ›тщШ›фщЩ›дщЪ›сщЫœ:щЬ›ђщЭ›ёщЮ›№щЯœщаœщбœ щвœщгœ щдœщеœщжœщзœ щиœщйœ.щкœщлœ%щмœ$щнœ!щоœ0щпœGщрœ2щсœFщтœ>щуœZщфœ`щхœgщцœvщчœxщшœчщщœьщъœ№щы щьщэœыщющящ№*щё&щђЏщѓ#щєщѕDщіщїщјAщљ?щњ>щћFщќHъ@]ъA^ъBdъCQъDPъEYъFrъG‰ъH‡ъIЋъJoъKzъLšъMЄъNЉъOВъPФъQСъRЛъSИъTКъUЦъVЯъWТъXйъYгъZјъ[цъ\эъ]яъ^§ъ_žъ`žъažъbžuъcžyъdž}ъežъfžˆъgž‹ъhžŒъiž’ъjž•ъkž‘ъlžъmžЅъnžЉъožИъpžЊъqž­ъr—aъsžЬъtžЮъužЯъvžаъwžдъxžмъyžоъzžнъ{žръ|žхъ}žшъ~žяъ€žєъžіъ‚žїъƒžљъ„žћъ…žќъ†ž§ъ‡ŸъˆŸъ‰vЗъŠŸъ‹Ÿ!ъŒŸ,ъŸ>ъŽŸJъŸRъŸTъ‘Ÿcъ’Ÿ_ъ“Ÿ`ъ”Ÿaъ•Ÿfъ–Ÿgъ—Ÿlъ˜Ÿjъ™ŸwъšŸrъ›ŸvъœŸ•ъŸœъžŸ ъŸX/ъ iЧъЁYъЂtdъЃQмъЄq™ecl-16.1.2/contrib/encodings/WINDOWS-CP1250.BIN000066400000000000000000000017561266352375300202760ustar00rootroot00000000000000і  !!""##$$%%&&''(())**++,,--..//00112233445566778899::;;<<==>>??@@AABBCCDDEEFFGGHHIIJJKKLLMMNNOOPPQQRRSSTTUUVVWWXXYYZZ[[\\]]^^__``aabbccddeeffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~€ Ќ‚ „ … &† ‡ !‰ 0Š`‹ 9ŒZdŽ}y‘ ’ “ ” • "– — ™!"ša› :œ[ež~Ÿz  ЁЧЂиЃAЄЄЅІІЇЇЈЈЉЉЊ^ЋЋЌЌ­­ЎЎЏ{ААББВлГBДДЕЕЖЖЗЗИИЙК_ЛЛМ=НнО>П|РTССТТУФФХ9ЦЧЧШ ЩЩЪЫЫЬЭЭЮЮЯабCвGггддеPжжззиXйnкклpммнноbппрUссттуффх:цччш щщъыыьээююя№ёDђHѓѓєєѕQііїїјYљoњњћqќќ§§ўcџйecl-16.1.2/contrib/encodings/WINDOWS-CP1251.BIN000066400000000000000000000017761266352375300203010ustar00rootroot00000000000000ў  !!""##$$%%&&''(())**++,,--..//00112233445566778899::;;<<==>>??@@AABBCCDDEEFFGGHHIIJJKKLLMMNNOOPPQQRRSSTTUUVVWWXXYYZZ[[\\]]^^__``aabbccddeeffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~€‚ ƒS„ … &† ‡ !ˆ Ќ‰ 0Š ‹ 9Œ  Ž R‘ ’ “ ” • "– — ™!"šY› :œZ\ž[Ÿ_  ЁЂ^ЃЄЄЅІІЇЇЈЉЉЊЋЋЌЌ­­ЎЎЏААББВГVД‘ЕЕЖЖЗЗИQЙ!КTЛЛМXНОUПWРСТУФХЦЧШЩЪЫЬЭЮЯа б!в"г#д$е%ж&з'и(й)к*л+м,н-о.п/р0с1т2у3ф4х5ц6ч7ш8щ9ъ:ы;ь<э=ю>я?№@ёAђBѓCєDѕEіFїGјHљIњJћKќL§MўNџOecl-16.1.2/contrib/encodings/WINDOWS-CP1252.BIN000066400000000000000000000017561266352375300203000ustar00rootroot00000000000000і  !!""##$$%%&&''(())**++,,--..//00112233445566778899::;;<<==>>??@@AABBCCDDEEFFGGHHIIJJKKLLMMNNOOPPQQRRSSTTUUVVWWXXYYZZ[[\\]]^^__``aabbccddeeffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~€ Ќ‚ ƒ’„ … &† ‡ !ˆЦ‰ 0Š`‹ 9ŒRŽ}‘ ’ “ ” • "– — ˜м™!"ša› :œSž~Ÿx  ЁЁЂЂЃЃЄЄЅЅІІЇЇЈЈЉЉЊЊЋЋЌЌ­­ЎЎЏЏААББВВГГДДЕЕЖЖЗЗИИЙЙККЛЛММННООППРРССТТУУФФХХЦЦЧЧШШЩЩЪЪЫЫЬЬЭЭЮЮЯЯааббввггддеежжззииййккллммннооппррссттууффххццччшшщщъъыыььээююяя№№ёёђђѓѓєєѕѕііїїјјљљњњћћќќ§§ўўџџecl-16.1.2/contrib/encodings/WINDOWS-CP1253.BIN000066400000000000000000000016761266352375300203020ustar00rootroot00000000000000о  !!""##$$%%&&''(())**++,,--..//00112233445566778899::;;<<==>>??@@AABBCCDDEEFFGGHHIIJJKKLLMMNNOOPPQQRRSSTTUUVVWWXXYYZZ[[\\]]^^__``aabbccddeeffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~€ Ќ‚ ƒ’„ … &† ‡ !‰ 0‹ 9‘ ’ “ ” • "– — ™!"› :  Ё…Ђ†ЃЃЄЄЅЅІІЇЇЈЈЉЉЋЋЌЌ­­ЎЎЏ ААББВВГГД„ЕЕЖЖЗЗИˆЙ‰КŠЛЛМŒННОŽПРС‘Т’У“Ф”Х•Ц–Ч—Ш˜Щ™ЪšЫ›ЬœЭЮžЯŸа бЁгЃдЄеЅжІзЇиЈйЉкЊлЋмЌн­оЎпЏрАсБтВуГфДхЕцЖчЗшИщЙъКыЛьМэНюОяП№РёСђТѓУєФѕХіЦїЧјШљЩњЪћЫќЬ§ЭўЮecl-16.1.2/contrib/encodings/WINDOWS-CP1254.BIN000066400000000000000000000017461266352375300203010ustar00rootroot00000000000000ђ  !!""##$$%%&&''(())**++,,--..//00112233445566778899::;;<<==>>??@@AABBCCDDEEFFGGHHIIJJKKLLMMNNOOPPQQRRSSTTUUVVWWXXYYZZ[[\\]]^^__``aabbccddeeffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~€ Ќ‚ ƒ’„ … &† ‡ !ˆЦ‰ 0Š`‹ 9ŒR‘ ’ “ ” • "– — ˜м™!"ša› :œSŸx  ЁЁЂЂЃЃЄЄЅЅІІЇЇЈЈЉЉЊЊЋЋЌЌ­­ЎЎЏЏААББВВГГДДЕЕЖЖЗЗИИЙЙККЛЛММННООППРРССТТУУФФХХЦЦЧЧШШЩЩЪЪЫЫЬЬЭЭЮЮЯЯаббввггддеежжззииййккллммн0о^ппррссттууффххццччшшщщъъыыььээююяя№ёёђђѓѓєєѕѕііїїјјљљњњћћќќ§1ў_џџecl-16.1.2/contrib/encodings/WINDOWS-CP1255.BIN000066400000000000000000000016461266352375300203010ustar00rootroot00000000000000в  !!""##$$%%&&''(())**++,,--..//00112233445566778899::;;<<==>>??@@AABBCCDDEEFFGGHHIIJJKKLLMMNNOOPPQQRRSSTTUUVVWWXXYYZZ[[\\]]^^__``aabbccddeeffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~€ Ќ‚ ƒ’„ … &† ‡ !ˆЦ‰ 0‹ 9‘ ’ “ ” • "– — ˜м™!"› :  ЁЁЂЂЃЃЄ ЊЅЅІІЇЇЈЈЉЉЊзЋЋЌЌ­­ЎЎЏЏААББВВГГДДЕЕЖЖЗЗИИЙЙКїЛЛММННООППРАСБТВУГФДХЕЦЖЧЗШИЩЙЫЛЬМЭНЮОЯПаРбСвТгУд№еёжђзѓиєрасбтвугфдхецжчзшищйъкыльмэнюояп№рёсђтѓуєфѕхіцїчјшљщњъ§ ў ecl-16.1.2/contrib/encodings/WINDOWS-CP1256.BIN000066400000000000000000000020021266352375300202650ustar00rootroot00000000000000  !!""##$$%%&&''(())**++,,--..//00112233445566778899::;;<<==>>??@@AABBCCDDEEFFGGHHIIJJKKLLMMNNOOPPQQRRSSTTUUVVWWXXYYZZ[[\\]]^^__``aabbccddeeffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~€ Ќ~‚ ƒ’„ … &† ‡ !ˆЦ‰ 0Šy‹ 9ŒR†Ž˜ˆЏ‘ ’ “ ” • "– — ˜Љ™!"š‘› :œS ž ŸК  Ё ЂЂЃЃЄЄЅЅІІЇЇЈЈЉЉЊОЋЋЌЌ­­ЎЎЏЏААББВВГГДДЕЕЖЖЗЗИИЙЙКЛЛММННООПРСС!Т"У#Ф$Х%Ц&Ч'Ш(Щ)Ъ*Ы+Ь,Э-Ю.Я/а0б1в2г3д4е5ж6ззи7й8к9л:м@нAоBпCррсDттуEфFхGцHччшшщщъъыыьIэJююяя№KёLђMѓNєєѕOіPїїјQљљњRћћќќ§ ў џвecl-16.1.2/contrib/encodings/WINDOWS-CP1257.BIN000066400000000000000000000017221266352375300202760ustar00rootroot00000000000000ш  !!""##$$%%&&''(())**++,,--..//00112233445566778899::;;<<==>>??@@AABBCCDDEEFFGGHHIIJJKKLLMMNNOOPPQQRRSSTTUUVVWWXXYYZZ[[\\]]^^__``aabbccddeeffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~€ Ќ‚ „ … &† ‡ !‰ 0‹ 9ЈŽЧИ‘ ’ “ ” • "– — ™!"› :Џžл  ЂЂЃЃЄЄІІЇЇЈиЉЉЊVЋЋЌЌ­­ЎЎЏЦААББВВГГДДЕЕЖЖЗЗИјЙЙКWЛЛММННООПцРС.ТУФФХХЦЧШ ЩЩЪyЫЬ"Э6Ю*Я;а`бCвEггдLеежжззиrйAкZлjммн{о}ппрс/туффххцчш щщъzыь#э7ю+я<№aёDђFѓѓєMѕѕііїїјsљBњ[ћkќќ§|ў~џйecl-16.1.2/contrib/encodings/WINDOWS-CP1258.BIN000066400000000000000000000017361266352375300203040ustar00rootroot00000000000000ю  !!""##$$%%&&''(())**++,,--..//00112233445566778899::;;<<==>>??@@AABBCCDDEEFFGGHHIIJJKKLLMMNNOOPPQQRRSSTTUUVVWWXXYYZZ[[\\]]^^__``aabbccddeeffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~€ Ќ‚ ƒ’„ … &† ‡ !ˆЦ‰ 0‹ 9ŒR‘ ’ “ ” • "– — ˜м™!"› :œSŸx  ЁЁЂЂЃЃЄЄЅЅІІЇЇЈЈЉЉЊЊЋЋЌЌ­­ЎЎЏЏААББВВГГДДЕЕЖЖЗЗИИЙЙККЛЛММННООППРРССТТУФФХХЦЦЧЧШШЩЩЪЪЫЫЬЭЭЮЮЯЯаббв ггдде жжззииййккллммнЏоппррссттуффххццччшшщщъъыыьээююяя№ёёђ#ѓѓєєѕЁііїїјјљљњњћћќќ§Аў Ћџџecl-16.1.2/contrib/encodings/WINDOWS-CP932.BIN000066400000000000000000000756561266352375300202360ustar00rootroot00000000000000=ж  !!""##$$%%&&''(())**++,,--..//00112233445566778899::;;<<==>>??@@AABBCCDDEEFFGGHHIIJJKKLLMMNNOOPPQQRRSSTTUUVVWWXXYYZZ[[\\]]^^__``aabbccddeeffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~ЁџaЂџbЃџcЄџdЅџeІџfЇџgЈџhЉџiЊџjЋџkЌџl­џmЎџnЏџoАџpБџqВџrГџsДџtЕџuЖџvЗџwИџxЙџyКџzЛџ{Мџ|Нџ}Оџ~ПџРџ€СџТџ‚УџƒФџ„Хџ…Цџ†Чџ‡ШџˆЩџ‰ЪџŠЫџ‹ЬџŒЭџЮџŽЯџаџбџ‘вџ’гџ“дџ”еџ•жџ–зџ—иџ˜йџ™кџšлџ›мџœнџоџžпџŸ@0A0B0Cџ DџE0ћFџGџHџIџJ0›K0œLДMџ@NЈOџ>PџуQџ?R0§S0ўT0U0žV0WNнX0Y0Z0[0ќ\ ] ^џ_џ<`џ^a"%bџ\c &d %e f g h iџjџ k0l0mџ;nџ=oџ[pџ]q0r0 s0 t0 u0 v0 w0x0y0z0{џ |џ }Б~з€їџ‚"`ƒџ„џ…"f†"g‡"ˆ"4‰&BŠ&@‹АŒ 2 3Ž!џхџ‘џр’џс“џ”џ•џ–џ —џ ˜Ї™&š&›%Ыœ%Я%Юž%ЧŸ%Ц %ЁЁ% Ђ%ГЃ%ВЄ%НЅ%МІ ;Ї0Ј!’Љ!Њ!‘Ћ!“Ќ0И"Й" К"†Л"‡М"‚Н"ƒО"*П")Ш"'Щ"(ЪџтЫ!вЬ!дЭ"Ю"к" л"Ѕм#н"о"п"aр"Rс"jт"kу"ф"=х"ц"5ч"+ш",№!+ё 0ђ&oѓ&mє&jѕ і !їЖќ%я‚Oџ‚Pџ‚Qџ‚Rџ‚Sџ‚Tџ‚Uџ‚Vџ‚Wџ‚Xџ‚`џ!‚aџ"‚bџ#‚cџ$‚dџ%‚eџ&‚fџ'‚gџ(‚hџ)‚iџ*‚jџ+‚kџ,‚lџ-‚mџ.‚nџ/‚oџ0‚pџ1‚qџ2‚rџ3‚sџ4‚tџ5‚uџ6‚vџ7‚wџ8‚xџ9‚yџ:‚џA‚‚џB‚ƒџC‚„џD‚…џE‚†џF‚‡џG‚ˆџH‚‰џI‚ŠџJ‚‹џK‚ŒџL‚џM‚ŽџN‚џO‚џP‚‘џQ‚’џR‚“џS‚”џT‚•џU‚–џV‚—џW‚˜џX‚™џY‚šџZ‚Ÿ0A‚ 0B‚Ё0C‚Ђ0D‚Ѓ0E‚Є0F‚Ѕ0G‚І0H‚Ї0I‚Ј0J‚Љ0K‚Њ0L‚Ћ0M‚Ќ0N‚­0O‚Ў0P‚Џ0Q‚А0R‚Б0S‚В0T‚Г0U‚Д0V‚Е0W‚Ж0X‚З0Y‚И0Z‚Й0[‚К0\‚Л0]‚М0^‚Н0_‚О0`‚П0a‚Р0b‚С0c‚Т0d‚У0e‚Ф0f‚Х0g‚Ц0h‚Ч0i‚Ш0j‚Щ0k‚Ъ0l‚Ы0m‚Ь0n‚Э0o‚Ю0p‚Я0q‚а0r‚б0s‚в0t‚г0u‚д0v‚е0w‚ж0x‚з0y‚и0z‚й0{‚к0|‚л0}‚м0~‚н0‚о0€‚п0‚р0‚‚с0ƒ‚т0„‚у0…‚ф0†‚х0‡‚ц0ˆ‚ч0‰‚ш0Š‚щ0‹‚ъ0Œ‚ы0‚ь0Ž‚э0‚ю0‚я0‘‚№0’‚ё0“ƒ@0ЁƒA0ЂƒB0ЃƒC0ЄƒD0ЅƒE0ІƒF0ЇƒG0ЈƒH0ЉƒI0ЊƒJ0ЋƒK0ЌƒL0­ƒM0ЎƒN0ЏƒO0АƒP0БƒQ0ВƒR0ГƒS0ДƒT0ЕƒU0ЖƒV0ЗƒW0ИƒX0ЙƒY0КƒZ0Лƒ[0Мƒ\0Нƒ]0Оƒ^0Пƒ_0Рƒ`0Сƒa0Тƒb0Уƒc0Фƒd0Хƒe0Цƒf0Чƒg0Шƒh0Щƒi0Ъƒj0Ыƒk0Ьƒl0Эƒm0Юƒn0Яƒo0аƒp0бƒq0вƒr0гƒs0дƒt0еƒu0жƒv0зƒw0иƒx0йƒy0кƒz0лƒ{0мƒ|0нƒ}0оƒ~0пƒ€0рƒ0сƒ‚0тƒƒ0уƒ„0фƒ…0хƒ†0цƒ‡0чƒˆ0шƒ‰0щƒŠ0ъƒ‹0ыƒŒ0ьƒ0эƒŽ0юƒ0яƒ0№ƒ‘0ёƒ’0ђƒ“0ѓƒ”0єƒ•0ѕƒ–0іƒŸ‘ƒ ’ƒЁ“ƒЂ”ƒЃ•ƒЄ–ƒЅ—ƒІ˜ƒЇ™ƒЈšƒЉ›ƒЊœƒЋƒЌžƒ­ŸƒЎ ƒЏЁƒАЃƒБЄƒВЅƒГІƒДЇƒЕЈƒЖЉƒПБƒРВƒСГƒТДƒУЕƒФЖƒХЗƒЦИƒЧЙƒШКƒЩЛƒЪМƒЫНƒЬОƒЭПƒЮРƒЯСƒаУƒбФƒвХƒгЦƒдЧƒеШƒжЩ„@„A„B„C„D„E„F„G„H„I„J„K„L„M„N„O„P„Q „R!„S"„T#„U$„V%„W&„X'„Y(„Z)„[*„\+„],„^-„_.„`/„p0„q1„r2„s3„t4„u5„vQ„w6„x7„y8„z9„{:„|;„}<„~=„€>„?„‚@„ƒA„„B„…C„†D„‡E„ˆF„‰G„ŠH„‹I„ŒJ„K„ŽL„M„N„‘O„Ÿ%„ %„Ё% „Ђ%„Ѓ%„Є%„Ѕ%„І%,„Ї%$„Ј%4„Љ%<„Њ%„Ћ%„Ќ%„­%„Ў%„Џ%„А%#„Б%3„В%+„Г%;„Д%K„Е% „Ж%/„З%(„И%7„Й%?„К%„Л%0„М%%„Н%8„О%B‡@$`‡A$a‡B$b‡C$c‡D$d‡E$e‡F$f‡G$g‡H$h‡I$i‡J$j‡K$k‡L$l‡M$m‡N$n‡O$o‡P$p‡Q$q‡R$r‡S$s‡T!`‡U!a‡V!b‡W!c‡X!d‡Y!e‡Z!f‡[!g‡\!h‡]!i‡_3I‡`3‡a3"‡b3M‡c3‡d3'‡e3‡f36‡g3Q‡h3W‡i3 ‡j3&‡k3#‡l3+‡m3J‡n3;‡o3œ‡p3‡q3ž‡r3Ž‡s3‡t3Ф‡u3Ё‡~3{‡€0‡0‡‚!‡ƒ3Э‡„!!‡…2Є‡†2Ѕ‡‡2І‡ˆ2Ї‡‰2Ј‡Š21‡‹22‡Œ29‡3~‡Ž3}‡3|‡"R‡‘"a‡’"+‡“".‡”"‡•"‡–"Ѕ‡—" ‡˜"‡™"П‡š"5‡›")‡œ"*ˆŸNœˆ UˆЁZˆЂ–?ˆЃTРˆЄaˆЅc(ˆІYіˆЇ"ˆЈ„uˆЉƒˆЊzPˆЋ`ЊˆЌcсˆ­n%ˆЎeэˆЏ„fˆА‚ІˆБ›ѕˆВh“ˆГW'ˆДeЁˆЕbqˆЖ[›ˆЗYаˆИ†{ˆЙ˜єˆК}bˆЛ}ОˆМ›ŽˆНbˆО|ŸˆПˆЗˆР[‰ˆС^ЕˆТc ˆУf—ˆФhHˆХ•ЧˆЦ—ˆЧgOˆШNхˆЩO ˆЪOMˆЫOˆЬPIˆЭVђˆЮY7ˆЯYдˆаZˆб\ ˆв`пˆгaˆдapˆеfˆжiˆзpКˆиuOˆйupˆкyћˆл}­ˆм}яˆн€Уˆо„ˆпˆcˆр‹ˆсUˆтzˆуS;ˆфN•ˆхNЅˆцWпˆч€ВˆшСˆщxяˆъNˆыXёˆьnЂˆэ8ˆюz2ˆяƒ(ˆ№‚‹ˆёœ/ˆђQAˆѓSpˆєTНˆѕTсˆіVрˆїYћˆј_ˆљ˜ђˆњmыˆћ€фˆќ…-‰@–b‰A–p‰B– ‰C—ћ‰DT ‰ESѓ‰F[‡‰GpЯ‰HН‰IТ‰J–ш‰KSo‰L\‰MzК‰NN‰Ox“‰Pќ‰Qn&‰RV‰SU‰Tk‰U…‰Vœ;‰WYх‰XSЉ‰Ymf‰Ztм‰[•‰\VB‰]N‘‰^K‰_–ђ‰`ƒO‰a™ ‰bSс‰cUЖ‰d[0‰e_q‰ff ‰gfѓ‰hh‰il8‰jlѓ‰km)‰lt[‰mvШ‰nzN‰o˜4‰p‚ё‰qˆ[‰rŠ`‰s’э‰tmВ‰uuЋ‰vvЪ‰w™Х‰x`І‰y‹‰zŠ‰{•В‰|iŽ‰}S­‰~Q†‰€W‰X0‰‚YD‰ƒ[Д‰„^і‰…`(‰†cЉ‰‡cє‰ˆlП‰‰o‰ŠpŽ‰‹q‰ŒqY‰qе‰Žs?‰~‰‚v‰‘‚б‰’…—‰“`‰”’[‰•‰–Xi‰—eМ‰˜lZ‰™u%‰šQљ‰›Y.‰œYe‰_€‰ž_м‰ŸbМ‰ eњ‰Ёj*‰Ђk'‰ЃkД‰Єs‹‰ЅС‰І‰V‰Ї,‰Ј‰ЉžФ‰Њ\Ё‰Ћl–‰Ќƒ{‰­Q‰Ў\K‰ЏaЖ‰АЦ‰Бhv‰Вra‰ГNY‰ДOњ‰ЕSx‰Ж`i‰Зn)‰ИzO‰Й—ѓ‰КN ‰ЛS‰МNю‰НOU‰ОO=‰ПOЁ‰РOs‰СR ‰ТSя‰УV ‰ФY‰ХZС‰Ц[Ж‰Ч[с‰Шyб‰Щf‡‰Ъgœ‰ЫgЖ‰ЬkL‰ЭlГ‰Юpk‰ЯsТ‰аy‰бyО‰вz<‰г{‡‰д‚Б‰е‚л‰жƒ‰зƒw‰иƒя‰йƒг‰к‡f‰лŠВ‰мV)‰нŒЈ‰оц‰пN‰р—‰с†Š‰тOФ‰у\ш‰фb‰хrY‰цu;‰чх‰ш‚Н‰щ†ў‰ъŒР‰ы–Х‰ь™‰э™е‰юNЫ‰яO‰№‰у‰ёVо‰ђXJ‰ѓXЪ‰є^ћ‰ѕ_ы‰і`*‰ї`”‰ј`b‰љaа‰њb‰ћbа‰ќe9Š@›AŠAffŠBhАŠCmwŠDppŠEuLŠFv†ŠG}uŠH‚ЅŠI‡љŠJ•‹ŠK–ŽŠLŒŠMQёŠNRОŠOYŠPTГŠQ[ГŠR]ŠSahŠTi‚ŠUmЏŠVxŠW„ЫŠXˆWŠYŠrŠZ“ЇŠ[šИŠ\mlŠ]™ЈŠ^†йŠ_WЃŠ`gџŠa†ЮŠb’ŠcRƒŠdV‡ŠeTŠf^гŠgbсŠhdЙŠih<Šjh8ŠkkЛŠlsrŠmxКŠnzkŠo‰šŠp‰вŠqkŠrŠsэŠt•ЃŠu–”Šv—iŠw[fŠx\ГŠyi}Šz˜MŠ{˜NŠ|c›Š}{ Š~j+Š€jŠhЖŠ‚œ Šƒo_Š„RrŠ…UŠ†`pŠ‡bьŠˆm;Š‰nŠŠnбŠ‹„[ŠŒ‰ŠDŠŽNŠœ9ŠSіŠ‘iŠ’j:Š“—„Š”h*Š•Q\Š–zУŠ—„ВŠ˜‘мŠ™“ŒŠšV[Š›(Šœh"ŠƒŠž„1ŠŸ|ЅŠ RŠЁ‚ХŠЂtцŠЃN~ŠЄOƒŠЅQ ŠІ[вŠЇR ŠЈRиŠЉRчŠЊ]ћŠЋUšŠЌX*Š­YцŠЎ[ŒŠЏ[˜ŠА[лŠБ^rŠВ^yŠГ`ЃŠДaŠЕacŠЖaОŠЗcлŠИebŠЙgбŠКhSŠЛhњŠМk>ŠНkSŠОlWŠПo"ŠРo—ŠСoEŠТtАŠУuŠФvуŠХw ŠЦzџŠЧ{ЁŠШ|!ŠЩ}щŠЪ6ŠЫ№ŠЬ€ŠЭ‚fŠЮƒžŠЯ‰ГŠаŠЬŠбŒЋŠв„Šг”QŠд•“Šе•‘Šж•ЂŠз–eŠи—гŠй™(Šк‚ŠлN8ŠмT+Šн\ИŠо]ЬŠпsЉŠрvLŠсw<Šт\ЉŠуыŠф Šх–СŠц˜Šч˜TŠш˜XŠщOŠъOŠыSqŠьUœŠэVhŠюWњŠяYGŠ№[ Šё[ФŠђ\Šѓ^ Šє^~Šѕ_ЬŠіcюŠїg:ŠјeзŠљeтŠњgŠћhЫŠќhФ‹@j_‹A^0‹BkХ‹Cl‹Dl}‹Eu‹FyH‹G[c‹Hz‹I}‹J_Н‹K‰‹LŠ‹MŒД‹Nw‹OŽЬ‹P‹Q˜т‹Rš‹S›<‹TN€‹UP}‹VQ‹WY“‹X[œ‹Yb/‹Zb€‹[dь‹\k:‹]r ‹^u‘‹_yG‹`Љ‹a‡ћ‹bŠМ‹c‹p‹dcЌ‹eƒЪ‹f— ‹gT ‹hT‹iUЋ‹jhT‹kjX‹lŠp‹mx'‹ngu‹ožЭ‹pSt‹q[Ђ‹r‹s†P‹t‹uN‹vNE‹wNЧ‹xO‹ySЪ‹zT8‹{[Ў‹|_‹}`%‹~eQ‹€g=‹lB‹‚lr‹ƒlу‹„px‹…t‹†zv‹‡zЎ‹ˆ{‹‰}‹Š|ў‹‹}f‹Œeч‹r[‹ŽSЛ‹\E‹]ш‹‘bв‹’bр‹“c‹”n ‹•†Z‹–Š1‹—н‹˜’ј‹™o‹šyІ‹››Z‹œNЈ‹NЋ‹žNЌ‹ŸO›‹ O ‹ЁPб‹ЂQG‹Ѓzі‹ЄQq‹ЅQі‹ІST‹ЇS!‹ЈS‹ЉSы‹ЊUЌ‹ЋXƒ‹Ќ\с‹­_7‹Ў_J‹Џ`/‹А`P‹Б`m‹Вc‹ГeY‹ДjK‹ЕlС‹ЖrТ‹Зrэ‹Иwя‹Й€ј‹К‹Л‚‹М…N‹Нї‹О“с‹П—џ‹Р™W‹СšZ‹ТN№‹УQн‹Ф\-‹Хf‹Цim‹Ч\@‹Шfђ‹Щiu‹Ъs‰‹ЫhP‹Ь|‹ЭPХ‹ЮRф‹ЯWG‹а]ў‹б“&‹вeЄ‹гk#‹дk=‹еt4‹жy‹зyН‹и{K‹й}Ъ‹к‚Й‹лƒЬ‹мˆ‹н‰_‹о‹9‹пб‹р‘б‹сT‹т’€‹уN]‹фP6‹хSх‹цS:‹чrз‹шs–‹щwщ‹ъ‚ц‹ыŽЏ‹ь™Ц‹э™Ш‹ю™в‹яQw‹№a‹ё†^‹ђUА‹ѓzz‹єPv‹ѕ[г‹іG‹ї–…‹јN2‹љjл‹њ‘ч‹ћ\Q‹ќ\HŒ@c˜ŒAzŸŒBl“ŒC—tŒDaŒEzЊŒFqŠŒG–ˆŒH|‚ŒIhŒJ~pŒKhQŒL“lŒMRђŒNTŒO…ЋŒPŠŒQЄŒRŽЭŒSсŒTSfŒUˆˆŒVyAŒWOТŒXPОŒYRŒZQDŒ[USŒ\W-Œ]sъŒ^W‹Œ_YQŒ`_bŒa_„Œb`uŒcavŒdagŒeaЉŒfcВŒgd:ŒhelŒifoŒjhBŒknŒlufŒmz=Œn|ћŒo}LŒp}™Œq~KŒrkŒsƒŒtƒJŒu†ЭŒvŠŒwŠcŒx‹fŒyŽ§Œz˜Œ{Œ|‚ИŒ}ЮŒ~›шŒ€R‡ŒbŒ‚dƒŒƒoРŒ„–™Œ…hAŒ†P‘Œ‡k ŒˆlzŒ‰oTŒŠztŒ‹}PŒŒˆ@ŒŠ#ŒŽgŒNіŒP9Œ‘P&Œ’PeŒ“Q|Œ”R8Œ•RcŒ–UЇŒ—WŒ˜XŒ™ZЬŒš^њŒ›aВŒœaјŒbѓŒžcrŒŸiŒ j)ŒЁr}ŒЂrЌŒЃs.ŒЄxŒЅxoŒІ}yŒЇw ŒЈ€ЉŒЉ‰‹ŒЊ‹ŒЋŒтŒЌŽвŒ­cŒЎ“uŒЏ–zŒА˜UŒБšŒВžxŒГQCŒДSŸŒЕSГŒЖ^{ŒЗ_&ŒИnŒЙnŒКs„ŒЛsўŒМ}CŒН‚7ŒОŠŒПŠњŒР–PŒСNNŒТP ŒУSфŒФT|ŒХVњŒЦYбŒЧ[dŒШ]ёŒЩ^ЋŒЪ_'ŒЫb8ŒЬeEŒЭgЏŒЮnVŒЯrаŒа|ЪŒбˆДŒв€ЁŒг€сŒдƒ№Œе†NŒжŠ‡ŒзшŒи’7Œй–ЧŒк˜gŒлŸŒмN”ŒнN’ŒоO ŒпSHŒрTIŒсT>ŒтZ/Œу_ŒŒф_ЁŒх`ŸŒцhЇŒчjŽŒшtZŒщxŒъŠžŒыŠЄŒь‹wŒэ‘ŒюN^Œя›ЩŒ№NЄŒёO|ŒђOЏŒѓPŒєPŒѕQIŒіQlŒїRŸŒјRЙŒљRўŒњSšŒћSуŒќT@TAU‰BWQCWЂDY}E[TF[]G[H]хI]чJ]їK^xL^ƒM^šN^ЗO_P`RQaLRb—SbиTcЇUe;VfWfCXfєYgmZh![h—\iЫ]l_^m*_mi`n/anbu2cv‡dxlez?f|рg}h}i}^j}Бk€l€m€Џn€БoTpq‚*rƒRsˆLtˆau‹vŒЂwŒќxЪy‘uz’q{x?|’ќ}•Є~–M€˜™™‚šиƒ;„R[…RЋ†Sї‡TˆXе‰bїŠoр‹ŒjŒ_žЙŽQKR;TJ‘V§’z@“‘w”`•žв–sD—o ˜p™uš_§›`кœšЈrлžМŸkd ˜ЁNЪЂV№ЃWdЄXОЅZZІ`hЇaЧЈfЉfЊh9ЋhБЌmї­uеЎ}:Џ‚nА›BБN›ВOPГSЩДUЕ]oЖ]цЗ]юИgћЙl™КtsЛxМŠPН“–ОˆпПWPР^ЇСc+ТPЕУPЌФQХgЦTЩЧX^ШYЛЩ[АЪ_iЫbMЬcЁЭh=ЮksЯnаp}б‘Чвr€гxдx&еymжeŽз}0иƒмйˆСк л–›мRdнW(оgPпjрŒЁсQДтWBу–*фX:хiŠц€ДчTВш]щWќъx•ыњьO\эRJюT‹яd>№f(ёgђgѕѓz„є{Vѕ}"і“/їh\ј›­љ{9њSћQŠќR7Ž@[пŽAbіŽBdЎŽCdцŽDg-ŽEkКŽF…ЉŽG–бŽHvŽI›жŽJcLŽK“ŽL›ЋŽMvПŽNfRŽON ŽPP˜ŽQSТŽR\qŽS`шŽTd’ŽUecŽVh_ŽWqцŽXsЪŽYu#ŽZ{—Ž[~‚Ž\†•Ž]‹ƒŽ^ŒлŽ_‘xŽ`™ŽaeЌŽbfЋŽck‹ŽdNеŽeNдŽfO:ŽgOŽhR:ŽiSјŽjSђŽkUуŽlVлŽmXыŽnYЫŽoYЩŽpYџŽq[PŽr\MŽs^Žt^+Žu_зŽv`ŽwcŽxe/Žy[\ŽzeЏŽ{eНŽ|eшŽ}gŽ~kbŽ€k{ŽlŽ‚sEŽƒyIŽ„yСŽ…|јŽ†}Ž‡}+Žˆ€ЂŽ‰ŽŠѓŽ‹‰–ŽŒŠ^ŽŠiŽŽŠfŽŠŒŽŠюŽ‘ŒЧŽ’ŒмŽ“–ЬŽ”˜ќŽ•koŽ–N‹Ž—O<Ž˜OŽ™QPŽš[WŽ›[њŽœaHŽcŽžfBŽŸk!Ž nЫŽЁlЛŽЂr>ŽЃtНŽЄuдŽЅxСŽІy:ŽЇ€ ŽЈ€3ŽЉъŽЊ„”ŽЋžŽЌlPŽ­žŽЎ_ŽЏ‹XŽА+ŽБzњŽВŽјŽГ[ŽД–ыŽЕNŽЖSёŽЗWїŽИY1ŽЙZЩŽК[ЄŽЛ`‰ŽМnŽНoŽОuОŽПŒъŽР[ŸŽС…ŽТ{рŽУPrŽФgєŽХ‚ŽЦ\aŽЧ…JŽШ~ŽЩ‚ŽЪQ™ŽЫ\ŽЬchŽЭfŽЮeœŽЯqnŽаy>Žб}Žв€Žг‹ŽдŽЪŽеnŽж†ЧŽзЊŽиPŽйRњŽк\:ŽлgSŽмp|Žнr5Žо‘LŽп‘ШŽр“+Žс‚хŽт[ТŽу_1Žф`љŽхN;ŽцSжŽч[ˆŽшbKŽщg1ŽъkŠŽыrщŽьsрŽэz.ŽюkŽяЃŽ№‘RŽё™–ŽђQŽѓSзŽєTjŽѕ[џŽіcˆŽїj9Žј}ЌŽљ—ŽњVкŽћSЮŽќTh@[—A\1B]оCOюDaEbўFm2GyРHyЫI}BJ~MKвLэM‚N„OˆFP‰rQ‹RŽtS/T1U‘KV‘lW–ЦX‘œYNРZOO[QE\SA]_“^b_gд`lAan bscc~&d‘Эe’ƒfSдgYh[Пimбjy]k~.l|›mX~nqŸoQњpˆSq№rOЪs\ћtf%uwЌvzуw‚x™џyQЦz_Њ{eь|io}k‰~mѓ€n–od‚vўƒ}„]с…u†‘‡‡˜ˆQц‰RŠb@‹f‘ŒfйnŽ^Ж}вr‘fј’…Џ“…ї”Šј•RЉ–Sй—Ys˜^™_š`U›’фœ–dPЗžQŸRн S ЁSGЂSьЃTшЄUFЅU1ІVЇYhЈYОЉZ<Њ[ЕЋ\Ќ\­\Ў\Џ^„А^ŠБ^рВ_pГbДb„ЕbлЖcŒЗcwИfЙf Кf-ЛfvМg~НhЂОjПj5РlМСmˆТn УnXФq<Хq&ЦqgЧuЧШwЩx]ЪyЫyeЬy№ЭzрЮ{Я|Їа}9б€–вƒжг„‹д…Iеˆ]жˆѓзŠиŠ<йŠTкŠsлŒaмŒон‘Єо’fп“~р”с–œт—˜уN фNхNцNWчQ—шRpщWЮъX4ыXЬь["э^8ю`Хяdў№gaёgVђmDѓrЖєusѕzcі„Иї‹rј‘Иљ“ њV1ћWєќ˜ў@bэAi Bk–CqэD~TE€wF‚rG‰цH˜пI‡UJБK\;LO8MOсNOЕOUPZ Q[нR[щS_УTaNUc/VeАWfKXhюYi›Zmx[mё\u3]uЙ^w_y^`yцa}3bуc‚Џd…Њe‰ЊfŠ:gŽЋh›i2j‘нk—lNКmNСnRoXupXьq\ rus\=tNuŠ vХw–cx—my{%zŠЯ{˜|‘b}Vѓ~SЈ€T9‚W‚ƒ^%„cЈ…l4†pŠ‡waˆ|‹‰рŠˆp‹BŒ‘T“Ž“–t^‘šФ’]“]i”ep•gЂ–Ј—–л˜cn™gIši›ƒХœ˜–РžˆўŸo„ dzЁ[јЂNЃp,Єu]Ѕf/ІQФЇR6ЈRтЉYгЊ_Ћ`'Ќb­e?ЎetЏfАftБhђВhГkcДnЕrrЖuЗvлИ|ОЙ€VКX№Лˆ§М‰НŠ ОŠ“ПŠЫРС‘’Т—RУ—YФe‰ХzЦЧ–ЛШ^-Щ`мЪbЫeЅЬfЭgЮwѓЯzMа|Mб~>в гŒЌдdесжŽ_зxЉиRйbйкcЅлdBмb˜нŠ-оzƒп{РрŠЌс–ът}vу‚ ф‡IхNйцQHчSCшS`щ[Ѓъ\ы\ь]нэb&юbGяdА№hёh4ђlЩѓmEєmѕgгіo\їqNјq}љeЫњzћ{­ќ}к‘@~J‘AЈ‘Bz‘C‚‘D‚9‘E…І‘FŠn‘GŒЮ‘Hѕ‘Ix‘Jw‘K’­‘L’‘‘M•ƒ‘N›Ў‘ORM‘PU„‘Qo8‘Rq6‘SQh‘Ty…‘U~U‘VГ‘W|Ю‘XVL‘YXQ‘Z\Ј‘[cЊ‘\fў‘]f§‘^iZ‘_rй‘`u‘auŽ‘by‘cyV‘dyп‘e|—‘f} ‘g}D‘h†‘iŠ4‘j–;‘ka‘lŸ ‘mPч‘nRu‘oSЬ‘pSт‘qP ‘rUЊ‘sXю‘tYO‘ur=‘v[‹‘w\d‘xS‘y`у‘z`ѓ‘{c\‘|cƒ‘}c?‘~cЛ‘€dЭ‘eщ‘‚fљ‘ƒ]у‘„iЭ‘…i§‘†o‘‡qх‘ˆN‰‘‰uщ‘Švј‘‹z“‘Œ|п‘}Я‘Ž}œ‘€a‘ƒI‘‘ƒX‘’„l‘“„М‘”…ћ‘•ˆХ‘–p‘—‘˜m‘™“—‘š—‘›š‘œPЯ‘X—‘žaŽ‘Ÿг‘ …5‘Ё‘Ђ ‘ЃOУ‘ЄPt‘ЅRG‘ІSs‘Ї`o‘ЈcI‘Љg_‘Њn,‘ЋГ‘Ќ‘­Oз‘Ў\^‘ЏŒЪ‘АeЯ‘Б}š‘ВSR‘Гˆ–‘ДQv‘ЕcУ‘Ж[X‘З[k‘И\ ‘Йd ‘КgQ‘Л\‘МNж‘НY‘ОY*‘Пlp‘РŠQ‘СU>‘ТX‘УYЅ‘Ф`№‘ХbS‘ЦgС‘Ч‚5‘ШiU‘Щ–@‘Ъ™Ф‘Ыš(‘ЬOS‘ЭX‘Ю[ў‘Я€‘а\Б‘б^/‘в_…‘г` ‘дaK‘еb4‘жfџ‘зl№‘иnо‘й€Ю‘к‘л‚д‘мˆ‹‘нŒИ‘о‘п.‘р–Š‘сžл‘т›л‘уNу‘фS№‘хY'‘ц{,‘ч‘‘ш˜L‘щљ‘ъnн‘ыp'‘ьSS‘эUD‘ю[…‘яbX‘№bž‘ёbг‘ђlЂ‘ѓoя‘єt"‘ѕŠ‘і”8‘їoС‘јŠў‘љƒ8‘њQч‘ћ†ј‘ќSъ’@Sщ’AOF’BT’CА’DYj’E1’F]§’Gzъ’HП’Ihк’JŒ7’Krј’LœH’Mj=’NŠА’ON9’PSX’QV’RWf’SbХ’TcЂ’Ueц’VkN’Wmс’Xn[’Yp­’Zwэ’[zя’\{Њ’]}Л’^€=’_€Ц’`†Ы’aŠ•’b“[’cVу’dXЧ’e_>’fe­’gf–’hj€’ikЕ’ju7’kŠЧ’lP$’mwх’nW0’o_’p`e’qfz’rl`’suє’tz’un’vє’w‡’xE’y™Г’z{Щ’{u\’|zљ’}{Q’~„Ф’€’yщ’‚z’’ƒƒ6’„Zс’…w@’†N-’‡Nђ’ˆ[™’‰_р’ŠbН’‹f<’Œgё’lш’Ž†k’ˆw’Š;’‘‘N’’’ѓ’“™а’”j’•p&’–s*’—‚ч’˜„W’™ŒЏ’šN’›QF’œQЫ’U‹’ž[ѕ’Ÿ^’ ^3’Ё^’Ђ_’Ѓ_5’Є_k’Ѕ_Д’Іaђ’Їc’ЈfЂ’Љg’Њon’ЋrR’Ќu:’­w:’Ў€t’Џ9’Аx’Б‡v’ВŠП’ГŠм’Д…’Еѓ’Ж’š’З•w’И˜’Йœх’КRХ’ЛcW’Мvє’Нg’Оlˆ’ПsЭ’РŒУ’С“Ў’Т–s’Уm%’ФXœ’Хi’ЦiЬ’Ч§’Ш“š’Щuл’Ъ’ЫXZ’Ьh’ЭcД’Юiћ’ЯOC’аo,’бgи’вЛ’г…&’д}Д’е“T’жi?’зop’иWj’йXї’к[,’л},’мr*’нT ’о‘у’пД’рN­’сON’тP\’уPu’фRC’хŒž’цTH’чX$’ш[š’щ^’ъ^•’ы^­’ь^ї’э_’ю`Œ’яbЕ’№c:’ёcа’ђhЏ’ѓl@’єx‡’ѕyŽ’іz ’ї}р’ј‚G’љŠ’њŠц’ћŽD’ќ“@И“A‘-“B‘и“CŸ“Dlх“EdX“Fdт“Geu“Hnє“Iv„“J{“Ki“L“б“MnК“NTђ“O_Й“PdЄ“QM“Rэ“S’D“TQx“UXk“VY)“W\U“X^—“Ymћ“Z~“[u“\ŒМ“]Žт“^˜[“_pЙ“`O“akП“boБ“cu0“d–ћ“eQN“fT“gX5“hXW“iYЌ“j\`“k_’“le—“mg\“nn!“ov{“pƒп“qŒэ“r“s§“t“M“ux%“vx:“wRЊ“x^І“yW“zYt“{`“|P“}QZ“~QЌ“€QЭ“R“‚U“ƒXT“„XX“…YW“†[•“‡\і“ˆ]‹“‰`М“Šb•“‹d-“Œgq“hC“ŽhМ“hп“vз“‘mи“’no““m›“”po“•qШ“–_S“—uи“˜yw“™{I“š{T“›{R“œ|ж“}q“žR0“Ÿ„c“ …i“Ё…ф“ЂŠ“Ѓ‹“ЄŒF“ЅŽ“І“Ї“Ј”“Љ–v“Њ˜-“Ћš0“Ќ•и“­PЭ“ЎRе“ЏT “АX“Б\“ВaЇ“Гdž“Дm“ЕwГ“Жzх“З€є“И„“ЙS“К’…“Л\р“М“НS?“О_—“П_Г“Рmœ“Сry“Тwc“УyП“Ф{ф“Хkв“Цrь“ЧŠ­“Шh“Щja“ЪQј“Ыz“Ьi4“Э\J“Юœі“Я‚ы“а[Х“б‘I“вp“гVx“д\o“е`Ч“жef“зlŒ“иŒZ“йA“к˜“лTQ“мfЧ“н’ “оYH“пЃ“рQ…“сNM“тQъ“у…™“ф‹“хpX“цcz“ч“K“шib“щ™Д“ъ~“ыuw“ьSW“эi`“юŽп“я–у“№l]“ёNŒ“ђ\<“ѓ_“єщ“ѕS“іŒб“ї€‰“ј†y“љ^џ“њeх“ћNs“ќQe”@Y‚”A\?”B—ю”CNћ”DYŠ”E_Э”FŠ”Goс”HyА”Iyb”J[ч”K„q”Ls+”MqБ”N^t”O_ѕ”Pc{”Qdš”RqУ”S|˜”TNC”U^ќ”VNK”WWм”XVЂ”Y`Љ”ZoУ”[} ”\€§”]3”^П”_В”`‰—”a†Є”b]є”cbŠ”dd­”e‰‡”fgw”glт”hm>”it6”jx4”kZF”lu”m‚­”n™Ќ”oOѓ”p^У”qbн”rc’”seW”tgo”uvУ”vrL”w€Ь”x€К”y)”z‘M”{P ”|Wљ”}Z’”~h…”€is”qd”‚r§”ƒŒЗ”„Xђ”…Œр”†–j”‡”ˆ‡”‰yф”Šwч”‹„)”ŒO/”Re”ŽSZ”bЭ”gЯ”‘lЪ”’v}”“{”””|•”•‚6”–…„”—ы”˜fн”™o ”šr”›~”œƒЋ”™С”žžІ”ŸQ§” {Б”Ёxr”Ђ{И”Ѓ€‡”Є{H”Ѕjш”І^a”Ї€Œ”ЈuQ”Љu`”ЊQk”Ћ’b”ЌnŒ”­vz”Ў‘—”Џšъ”АO”Бp”Вbœ”Г{O”Д•Ѕ”Еœщ”ЖVz”ЗXY”И†ф”Й–М”КO4”ЛR$”МSJ”НSЭ”ОSл”П^”Рd,”Сe‘”Тg”Уl>”ФlN”ХrH”ЦrЏ”Чsэ”ШuT”Щ~A”Ъ‚,”Ы…щ”ЬŒЉ”Э{Ф”Ю‘Ц”Яqi”а˜”б˜я”вc=”гfi”дuj”еvф”жxа”з…C”и†ю”йS*”кSQ”лT&”мYƒ”н^‡”о_|”п`В”рbI”сby”тbЋ”уe”фkд”хlЬ”цuВ”чvЎ”шx‘”щyи”ъ}Ы”ыw”ь€Ѕ”эˆЋ”юŠЙ”яŒЛ”№”ё—^”ђ˜л”ѓj ”є|8”ѕP™”і\>”ї_Ў”јg‡”љkи”њt5”ћw ”ќŽ•@Ÿ;•AgЪ•Bz•CS9•Du‹•Ešэ•F_f•G•Hƒё•I€˜•J_<•K_Х•Lub•M{F•N<•Ohg•PYы•QZ›•R}•Sv~•T‹,•UOѕ•V_j•Wj•Xl7•Yo•Ztт•[yh•\ˆh•]ŠU•^Œy•_^п•`cЯ•auХ•byв•c‚з•d“(•e’ђ•f„œ•g†э•hœ-•iTС•j_l•keŒ•lm\•mp•nŒЇ•oŒг•p˜;•qeO•rtі•sN •tNи•uWр•vY+•wZf•x[Ь•yQЈ•z^•{^œ•|`•}bv•~ew•€eЇ•fn•‚mn•ƒr6•„{&•…P•†š•‡‚™•ˆ‹\•‰Œ •ŠŒц•‹t•Œ–•–D•ŽOЎ•dЋ•kf•‘‚•’„a•“…j•”ш••\•–iS•—˜Ј•˜„z•™…W•šO•›Ro•œ_Љ•^E•žg •Ÿy• y•Ё‰•Ђ‰†•Ѓmѕ•Є_•ЅbU•ІlИ•ЇNЯ•Јri•Љ›’•ЊR•ЋT;•ЌVt•­XГ•ЎaЄ•Џbn•Аq•БYn•В|‰•Г|о•Д}•Е–№•Жe‡•З€^•ИN•ЙOu•КQu•ЛX@•М^c•Н^s•О_ •ПgФ•РN&•С…=•Т•‰•У–[•Ф|s•Х˜•ЦPћ•ЧXС•ШvV•ЩxЇ•ЪR%•ЫwЅ•Ь…•Э{†•ЮPO•ЯY •аrG•б{Ч•в}ш•гК•дд•еM•жOП•зRЩ•иZ)•й_•к—­•лOн•м‚•н’ъ•оW•пcU•рki•сu+•тˆм•у•фzB•хRп•цX“•чaU•шb •щfЎ•ъkЭ•ы|?•ьƒщ•эP#•юOј•яS•№TF•ёX1•ђYI•ѓ[•є\№•ѕ\я•і])•ї^–•јbБ•љcg•њe>•ћeЙ•ќg –@lе–Alс–Bpљ–Cx2–D~+–E€о–F‚Г–G„ –H„ь–I‡–J‰–KŠ*–LŒJ–MІ–N’в–O˜§–Pœѓ–Ql–RNO–SNЁ–TP–URV–VWJ–WYЈ–X^=–Y_и–Z_й–[b?–\fД–]g–^gа–_hв–`Q’–a}!–b€Њ–cЈ–d‹–eŒŒ–fŒП–g’~–h–2–iT –j˜,–kS–lPе–mS\–nXЈ–odВ–pg4–qrg–rwf–szF–t‘ц–uRУ–vlЁ–wk†–xX–y^L–zYT–{g,–|ћ–}Qс–~vЦ–€di–xш–‚›T–ƒžЛ–„WЫ–…YЙ–†f'–‡gš–ˆkЮ–‰Tщ–Šiй–‹^U–Œœ–g•–Ž›Њ–gў–œR–‘h]–’NІ–“Oу–”SШ–•bЙ––g+–—lЋ–˜Ф–™O­–š~m–›žП–œN–ab–žn€–Ÿo+– …–ЁTs–Ђg*–Ѓ›E–Є]ѓ–Ѕ{•–І\Ќ–Ї[Ц–Ј‡–ЉnJ–Њ„б–Ћz–Ќ–­Y™–Ў|–Џl–Аw –БRй–ВY"–Гq!–Дr_–Еwл–Ж—'–Зa–Иi –ЙZ–КZ–ЛQЅ–МT –НT}–Оf–Пvп–Рї–С’˜–Тœє–УYъ–Фr]–ХnХ–ЦQM–ЧhЩ–Ш}П–Щ}ь–Ъ—b–ЫžК–Ьdx–Эj!–Юƒ–ЯY„–а[_–бkл–вs–гvђ–д}В–е€–ж„™–зQ2–иg(–йžй–кvю–лgb–мRџ–н™–о\$–пb;–р|~–сŒА–тUO–у`Ж–ф} –х•€–цS–чN_–шQЖ–щY–ъr:–ы€6–ь‘Ю–э_%–юwт–яS„–№_y–ё}–ђ…Ќ–ѓŠ3–єŽ–ѕ—V–іgѓ–ї…Ў–ј”S–љa –њa–ћlЙ–ќvR—@Šэ—A8—BU/—COQ—DQ*—ERЧ—FSЫ—G[Ѕ—H^}—I` —Ja‚—Kcж—Lg —Mgк—Nng—OmŒ—Ps6—Qs7—Ru1—SyP—Tˆе—UŠ˜—VJ—W‘—Xѕ—Y–Ф—Z‡—[Y—\Nˆ—]OY—^N—_Š‰—`?—a˜—bP­—c^|—dY–—e[Й—f^И—gcк—hcњ—idС—jfм—kiJ—liи—mm —nnЖ—oq”—pu(—qzЏ—rŠ—s€—t„I—u„Щ—v‰—w‹!—xŽ —ye—z–}—{™ —|a~—}b‘—~k2—€lƒ—mt—‚Ь—ƒќ—„mР—……—†‡К—‡ˆј—ˆge—‰ƒБ—Š˜<—‹–ї—Œm—}a—Ž„=—‘j—Nq—‘Su—’]P—“k—”oы—•…Э—–†-——‰Ї—˜R)—™T—š\e—›gN—œhЈ—t—žtƒ—Ÿuт— ˆЯ—Ёˆс—Ђ‘Ь—Ѓ–т—Є–x—Ѕ_‹—Іs‡—ЇzЫ—Ј„N—Љc —Њue—ЋR‰—ЌmA—­nœ—Ўt —ЏuY—Аxk—Б|’—В–†—Гzм—ДŸ—ЕOЖ—Жan—ЗeХ—И†\—ЙN†—КNЎ—ЛPк—МN!—НQЬ—О[ю—Пe™—Рh—СmМ—Тs—УvB—Фw­—Хz—Ц|ч—Ч‚o—ШŠв—Щ|—Ъ‘Я—Ы–u—Ь˜—ЭR›—Ю}б—ЯP+—аS˜—бg——вmЫ—гqа—дt3—еш—ж*—з–Ѓ—иœW—йžŸ—кt`—лXA—мm™—н}/—о˜^—пNф—рO6—сO‹—тQЗ—уRБ—ф]К—х`—цsВ—чy<—ш‚г—щ’4—ъ–З—ы–і—ь— —эž——юŸb—яfІ—№kt—ёR—ђRЃ—ѓpШ—єˆТ—ѕ^Щ—і`K—їa—јo#—љqI—њ|>—ћ}є—ќ€o˜@„ю˜A#˜B“,˜CTB˜D›o˜Ejг˜Fp‰˜GŒТ˜Hя˜I—2˜JRĘKZA˜L^ژM_˜Ng˜Oi|˜Pi”˜Qmj˜Ro˜Srb˜Trќ˜U{э˜V€˜W€~˜X‡K˜YЮ˜ZQm˜[ž“˜\y„˜]€‹˜^“2˜_Šж˜`P-˜aTŒ˜bŠq˜ckj˜dŒФ˜e˜f`б˜gg ˜hђ˜iN™˜jN˜˜kœ˜lŠk˜m…С˜n…h˜oi˜pn~˜qx—˜rU˜Ÿ_ ˜ N˜ЁN˜ЂN*˜ЃN1˜ЄN6˜ЅN<˜ІN?˜ЇNB˜ЈNV˜ЉNX˜ЊN‚˜ЋN…˜ЌŒk˜­NŠ˜Ў‚˜Џ_ ˜АNŽ˜БNž˜ВNŸ˜ГN ˜ДNЂ˜ЕNА˜ЖNØЗNƘИNޘЙNݘКNԘЛN֘МNҘНNз˜ОNо˜ПNэ˜РNп˜СNї˜ТO ˜УOZ˜ФO0˜ХO[˜ЦO]˜ЧOW˜ШOG˜ЩOv˜ЪOˆ˜ЫO˜ЬO˜˜ЭO{˜ЮOi˜ЯOp˜аO‘˜бOo˜вO†˜гO–˜дQ˜еOд˜жOп˜зOޘиOи˜йOл˜кOб˜лOк˜мOа˜нOф˜оOх˜пP˜рP(˜сP˜тP*˜уP%˜фP˜хO˜цOі˜чP!˜шP)˜щP,˜ъOў˜ыOя˜ьP˜эP˜юPC˜яPG˜№g˜ёPU˜ђPP˜ѓPH˜єPZ˜ѕPV˜іPl˜їPx˜јP€˜љPš˜њP…˜ћPĘќPВ™@PЩ™APЪ™BPГ™CPТ™DPж™EPо™FPх™GPэ™HPу™IPю™JPљ™KPѕ™LQ ™MQ™NQ™OQ™PQ™QQ™RQ™SQ!™TQ:™UQ7™VQ<™WQ;™XQ?™YQ@™ZQR™[QL™\QT™]Qb™^zј™_Qi™`Qj™aQn™bQ€™cQ‚™dVи™eQŒ™fQ‰™gQ™hQ‘™iQ“™jQ•™kQ–™lQЄ™mQІ™nQЂ™oQЉ™pQЊ™qQЋ™rQГ™sQБ™tQВ™uQА™vQЕ™wQН™xQХ™yQЩ™zQл™{Qр™|†U™}Qщ™~Qэ™€Q№™Qѕ™‚Qў™ƒR™„R ™…R™†R™‡R'™ˆR*™‰R.™ŠR3™‹R9™ŒRO™RD™ŽRK™RL™R^™‘RT™’Rj™“Rt™”Ri™•Rs™–R™—R}™˜R™™R”™šR’™›Rq™œRˆ™R‘™žЈ™ŸЇ™ RЌ™ЁR­™ЂRМ™ЃRЕ™ЄRС™ЅRЭ™ІRз™ЇRо™ЈRу™ЉRц™Њ˜э™ЋRр™ЌRѓ™­Rѕ™ЎRј™ЏRљ™АS™БS™Вu8™ГS ™ДS™ЕS™ЖS™ЗS™ИS#™ЙS/™КS1™ЛS3™МS8™НS@™ОSF™ПSE™РN™СSI™ТSM™УQж™ФS^™ХSi™ЦSn™ЧY™ШS{™ЩSw™ЪS‚™ЫS–™ЬS ™ЭSІ™ЮSЅ™ЯSЎ™аSА™бSЖ™вSУ™г|™д–й™еSп™жfќ™зqю™иSю™йSш™кSэ™лSњ™мT™нT=™оT@™пT,™рT-™сT<™тT.™уT6™фT)™хT™цTN™чT™шTu™щTŽ™ъT_™ыTq™ьTw™эTp™юT’™яT{™№T€™ёTv™ђT„™ѓT™єT†™ѕTЧ™іTЂ™їTИ™јTЅ™љTЌ™њTФ™ћTШ™ќTЈš@TЋšATТšBTЄšCTОšDTМšETиšFTхšGTцšHUšIUšJT§šKTюšLTэšMTњšNTтšOU9šPU@šQUcšRULšSU.šTU\šUUEšVUVšWUWšXU8šYU3šZU]š[U™š\U€š]TЏš^UŠš_UŸš`U{šaU~šbU˜šcUžšdUЎšeU|šfUƒšgUЉšhU‡šiUЈšjUкškUХšlUпšmUФšnUмšoUфšpUдšqVšrUїšsVštUўšuU§švVšwUљšxVNšyVPšzqпš{V4š|V6š}V2š~V8š€VkšVdš‚V/šƒVlš„Vjš…V†š†V€š‡VŠšˆV š‰V”šŠVš‹VЅšŒVЎšVЖšŽVДšVТšVМš‘VСš’VУš“VРš”VШš•VЮš–Vбš—Vгš˜Vзš™VюššVљš›WšœVџšWšžW šŸWš W šЁW šЂWšЃWšЄWšЅUЧšІWšЇW&šЈW7šЉW8šЊWNšЋW;šЌW@š­WOšЎWišЏWРšАWˆšБWašВWšГW‰šДW“šЕW šЖWГšЗWЄšИWЊšЙWАšКWУšЛWЦšМWдšНWвšОWгšПX šРWжšСWуšТX šУXšФXšХXršЦX!šЧXbšШXKšЩXpšЪkРšЫXRšЬX=šЭXyšЮX…šЯXЙšаXŸšбXЋšвXКšгXоšдXЛšеXИšжXЎšзXХšиXгšйXбšкXзšлXйšмXиšнXхšоXмšпXфšрXпšсXяšтXњšуXљšфXћšхXќšцX§šчYšшY šщYšъYšыhІšьY%šэY,šюY-šяY2š№Y8šёY>šђzвšѓYUšєYPšѕYNšіYZšїYXšјYbšљY`šњYgšћYlšќYi›@Yx›AY›BY›CO^›DOЋ›EYЃ›FYВ›GYЦ›HYш›IYм›JY›KYй›LYк›MZ%›NZ›OZ›PZ›QZ ›RZ›SZ@›TZl›UZI›VZ5›WZ6›XZb›YZj›ZZš›[ZМ›\ZО›]ZЫ›^ZТ›_ZН›`Zу›aZз›bZц›cZщ›dZж›eZњ›fZћ›g[ ›h[ ›i[›j[2›kZа›l[*›m[6›n[>›o[C›p[E›q[@›r[Q›s[U›t[Z›u[[›v[e›w[i›x[p›y[s›z[u›{[x›|eˆ›}[z›~[€›€[ƒ›[І›‚[И›ƒ[У›„[Ч›…[Щ›†[䛇[а›ˆ[ф›‰[ц›Š[т›‹[о›Œ[х›[ы›Ž[№›[і›[ѓ›‘\›’\›“\›”\ ›•\›–\ ›—\"›˜\(›™\8›š\9››\A›œ\F›\N›ž\S›Ÿ\P› \O›Ё[q›Ђ\l›Ѓ\n›ЄNb›Ѕ\v›І\y›Ї\Œ›Ј\‘›Љ\”›ЊY››Ћ\Ћ›Ќ\Л›­\Ж›Ў\М›Џ\З›А\Х›Б\О›В\Ч›Г\й›Д\щ›Е\§›Ж\њ›З\э›И]Œ›Й\ъ›К] ›Л]›М]›Н]\›О]›П]›Р]›С]›Т]"›У]›Ф]›Х]›Ц]L›Ч]R›Ш]N›Щ]K›Ъ]l›Ы]s›Ь]v›Э]‡›Ю]„›Я]‚›а]Ђ›б]›в]Ќ›г]Ў›д]Н›е]›ж]З›з]М›и]Щ›й]Э›к]г›л]в›м]ж›н]л›о]ы›п]ђ›р]ѕ›с^ ›т^›у^›ф^›х^›ц^6›ч^7›ш^D›щ^C›ъ^@›ы^N›ь^W›э^T›ю^_›я^b›№^d›ё^G›ђ^u›ѓ^v›є^z›ѕžМ›і^›ї^ ›ј^С›љ^Т›њ^Ш›ћ^а›ќ^Яœ@^жœA^уœB^нœC^кœD^лœE^тœF^сœG^шœH^щœI^ьœJ^ёœK^ѓœL^№œM^єœN^јœO^ўœP_œQ_ œR_]œS_\œT_ œU_œV_œW_)œX_-œY_8œZ_Aœ[_Hœ\_Lœ]_Nœ^_/œ__Qœ`_Vœa_Wœb_Yœc_aœd_mœe_sœf_wœg_ƒœh_‚œi_œj_Šœk_ˆœl_‘œm_‡œn_žœo_™œp_˜œq_ œr_Јœs_­œt_Мœu_жœv_ћœw_фœx_јœy_ёœz_нœ{`Гœ|_џœ}`!œ~``œ€`œ`œ‚`)œƒ`œ„`1œ…`œ†`œ‡`+œˆ`&œ‰`œŠ`:œ‹`ZœŒ`Aœ`jœŽ`wœ`_œ`Jœ‘`Fœ’`Mœ“`cœ”`Cœ•`dœ–`Bœ—`lœ˜`kœ™`Yœš`œ›`œœ`чœ`ƒœž`šœŸ`„œ `›œЁ`–œЂ`—œЃ`’œЄ`ЇœЅ`‹œІ`сœЇ`ИœЈ`рœЉ`гœЊ`ДœЋ_№œЌ`Нœ­`ЦœЎ`ЕœЏ`иœАaMœБaœВaœГ`іœД`їœЕaœЖ`єœЗ`њœИaœЙa!œК`ћœЛ`ёœМa œНaœОaGœПa>œРa(œСa'œТaJœУa?œФa<œХa,œЦa4œЧa=œШaBœЩaDœЪasœЫawœЬaXœЭaYœЮaZœЯakœаatœбaoœвaeœгaqœдa_œеa]œжaSœзauœиa™œйa–œкa‡œлaЌœмa”œнašœоaŠœпa‘œрaЋœсaЎœтaЬœуaЪœфaЩœхaїœцaШœчaУœшaЦœщaКœъaЫœыyœьaЭœэaцœюaуœяaіœ№aњœёaєœђaџœѓa§œєaќœѕaўœіbœїbœјb œљb œњb œћbœќb@bAb!Bb*Cb.Db0Eb2Fb3GbAHbNIb^JbcKb[Lb`MbhNb|Ob‚Pb‰Qb~Rb’Sb“Tb–UbдVbƒWb”XbзYbбZbЛ[bЯ\bџ]bЦ^dд_bШ`bмabЬbbЪcbТdbЧeb›fbЩgc hbюibёjc'kclcmbяnbѕocPpc>qcMrdscOtc–ucŽvc€wcЋxcvycЃzc{c‰|cŸ}cЕ~ck€cicО‚cщƒcР„cЦ…cу†cЩ‡cвˆcі‰cФŠd‹d4ŒddŽd&d6e‘d’d(“d”dg•do–dv—dN˜e*™d•šd“›dЅœdЉdˆždМŸdк dвЁdХЂdЧЃdЛЄdиЅdТІdёЇdчЈ‚ ЉdрЊdсЋbЌЌdу­dяЎe,ЏdіАdєБdђВdњГeДd§ЕeЖeЗeИe$Йe#Кe+Лe4Мe5Нe7Оe6Пe8РuKСeHТeVУeUФeMХeXЦe^Чe]ШerЩexЪe‚ЫeƒЬ‹ŠЭe›ЮeŸЯeЋаeЗбeУвeЦгeСдeФеeЬжeвзeлиeййeркeслeёмgrнf оfпeћрgsсf5тf6уf4фfхfOцfDчfIшfAщf^ъf]ыfdьfgэfhюf_яfb№fpёfƒђfˆѓfŽєf‰ѕf„іf˜їfјfСљfЙњfЩћfОќfМž@fФžAfИžBfжžCfкžDfрžEf?žFfцžGfщžHf№žIfѕžJfїžKgžLgžMgžNg&žOg'žP—8žQg.žRg?žSg6žTgAžUg8žVg7žWgFžXg^žYg`žZgYž[gcž\gdž]g‰ž^gpž_gЉž`g|žagjžbgŒžcg‹ždgІžegЁžfg…žggЗžhgяžigДžjgьžkgГžlgщžmgИžngфžogоžpgнžqgтžrgюžsgЙžtgЮžugЦžvgчžwjœžxhžyhFžzh)ž{h@ž|hMž}h2ž~hNž€hГžh+ž‚hYžƒhcž„hwž…hž†hŸž‡hžˆh­ž‰h”žŠhž‹h›žŒhƒžjЎžŽhЙžhtžhЕž‘h ž’hКž“iž”hž•h~ž–iž—hЪž˜iž™hиžši"ž›i&žœhсži žžhЭžŸhдž hчžЁhеžЂi6žЃižЄižЅhзžІhуžЇi%žЈhљžЉhрžЊhяžЋi(žЌi*ž­ižЎi#žЏi!žАhЦžБiyžВiwžГi\žДixžЕikžЖiTžЗi~žИinžЙi9žКitžЛi=žМiYžНi0žОiažПi^žРi]žСižТijžУiВžФiЎžХiаžЦiПžЧiСžШiгžЩiОžЪiЮžЫ[шžЬiЪžЭiнžЮiЛžЯiУžаiЇžбj.žвi‘žгi žдiœžеi•žжiДžзiоžиiшžйjžкjžлiџžмk žнiљžоiђžпiчžрjžсiБžтjžуiэžфjžхiыžцj žчjžшjСžщj#žъjžыjDžьj žэjržюj6žяjxž№jGžёjbžђjYžѓjfžєjHžѕj8žіj"žїjžјjžљj žњj„žћjЂžќjЃŸ@j—ŸA†ŸBjЛŸCjУŸDjТŸEjИŸFjГŸGjЌŸHjоŸIjбŸJjпŸKjЊŸLjкŸMjъŸNjћŸOkŸP†ŸQjњŸRkŸSkŸT›1ŸUkŸVk8ŸWk7ŸXvмŸYk9ŸZ˜юŸ[kGŸ\kCŸ]kIŸ^kPŸ_kYŸ`kTŸak[Ÿbk_ŸckaŸdkxŸekyŸfkŸgk€Ÿhk„ŸikƒŸjkŸkk˜Ÿlk•ŸmkžŸnkЄŸokЊŸpkЋŸqkЏŸrkВŸskБŸtkГŸukЗŸvkМŸwkЦŸxkЫŸykгŸzkпŸ{kьŸ|kыŸ}kѓŸ~kяŸ€žОŸlŸ‚lŸƒlŸ„lŸ…l$Ÿ†l#Ÿ‡l^ŸˆlUŸ‰lbŸŠljŸ‹l‚ŸŒlŸlšŸŽlŸl›Ÿl~Ÿ‘lhŸ’lsŸ“l’Ÿ”lŸ•lФŸ–lёŸ—lгŸ˜lНŸ™lзŸšlХŸ›lнŸœlЎŸlБŸžlОŸŸlКŸ lлŸЁlяŸЂlйŸЃlъŸЄmŸЅˆMŸІm6ŸЇm+ŸЈm=ŸЉm8ŸЊmŸЋm5ŸЌm3Ÿ­mŸЎm ŸЏmcŸАm“ŸБmdŸВmZŸГmyŸДmYŸЕmŽŸЖm•ŸЗoфŸИm…ŸЙmљŸКnŸЛn ŸМmЕŸНmЧŸОmцŸПmИŸРmЦŸСmьŸТmоŸУmЬŸФmшŸХmвŸЦmХŸЧmњŸШmйŸЩmфŸЪmеŸЫmъŸЬmюŸЭn-ŸЮnnŸЯn.ŸаnŸбnrŸвn_Ÿгn>Ÿдn#ŸеnkŸжn+ŸзnvŸиnMŸйnŸкnCŸлn:ŸмnNŸнn$ŸоnџŸпnŸрn8Ÿсn‚ŸтnЊŸуn˜ŸфnЩŸхnЗŸцnгŸчnНŸшnЏŸщnФŸъnВŸыnдŸьnеŸэnŸюnЅŸяnТŸ№nŸŸёoAŸђoŸѓpLŸєnьŸѕnјŸіnўŸїo?ŸјnђŸљo1ŸњnяŸћo2ŸќnЬр@o>рAoрBnїрCo†рDozрEoxрFoрGo€рHooрIo[рJoѓрKomрLo‚рMo|рNoXрOoŽрPo‘рQoТрRofрSoГрToЃрUoЁрVoЄрWoЙрXoЦрYoЊрZoпр[oер\oьр]oдр^oир_oёр`oюрaoлрbp рcp рdoњрepрfpрgpрhoўрipрjpрkotрlpрmpрnpрop0рpp>рqp2рrpQрspcрtp™рup’рvpЏрwpёрxpЌрypИрzpГр{pЎр|pпр}pЫр~pнр€pйрq р‚p§рƒqр„qр…qeр†qUр‡qˆрˆqfр‰qbрŠqLр‹qVрŒqlрqрŽqћрq„рq•р‘qЈр’qЌр“qзр”qЙр•qОр–qвр—qЩр˜qдр™qЮрšqрр›qьрœqчрqѕрžqќрŸqљр qџрЁr рЂrрЃrрЄr(рЅr-рІr,рЇr0рЈr2рЉr;рЊr<рЋr?рЌr@р­rFрЎrKрЏrXрАrtрБr~рВr‚рГrрДr‡рЕr’рЖr–рЗrЂрИrЇрЙrЙрКrВрЛrУрМrЦрНrФрОrЮрПrврРrтрСrррТrсрУrљрФrїрХPрЦsрЧs рШsрЩsрЪsрЫs4рЬs/рЭs)рЮs%рЯs>раsNрбsOрвžиргsWрдsjреshржspрзsxриsuрйs{ркszрлsШрмsГрнsЮроsЛрпsРррsхрсsюртsоруtЂрфtрхtoрцt%рчsјршt2рщt:ръtUрыt?рьt_рэtYрюtAряt\р№tiрёtpрђtcрѓtjрєtvрѕt~ріt‹рїtžрјtЇрљtЪрњtЯрћtдрќsёс@tрсAtусBtчсCtщсDtюсEtђсFt№сGtёсHtјсItїсJuсKuсLuсMu сNuсOu сPuсQuсRuсSu&сTu,сUu<сVuDсWuMсXuJсYuIсZu[с[uFс\uZс]uiс^udс_ugс`ukсaumсbuxсcuvсdu†сeu‡сfutсguŠсhu‰сiu‚сju”сkušсluсmuЅсnuЃсouТсpuГсquУсruЕсsuНсtuИсuuМсvuБсwuЭсxuЪсyuвсzuйс{uус|uос}uўс~uџс€uќсvс‚u№сƒuњс„uђс…uѓс†v с‡v сˆv с‰vсŠv'с‹v сŒv!сv"сŽv$сv4сv0с‘v;с’vGс“vHс”vFс•v\с–vXс—vaс˜vbс™vhсšviс›vjсœvgсvlсžvpсŸvrс vvсЁvxсЂv|сЃv€сЄvƒсЅvˆсІv‹сЇvŽсЈv–сЉv“сЊv™сЋvšсЌvАс­vДсЎvИсЏvЙсАvКсБvТсВvЭсГvжсДvвсЕvосЖvссЗvхсИvчсЙvъсК†/сЛvћсМwсНwсОwсПw)сРw$сСwсТw%сУw&сФwсХw7сЦw8сЧwGсШwZсЩwhсЪwkсЫw[сЬweсЭwсЮw~сЯwyсаwŽсбw‹свw‘сгw сдwžсеwАсжwЖсзwЙсиwПсйwМскwНслwЛсмwЧснwЭсоwзспwксрwмссwустwюсуwќсфx схxсцy&счx сшy*сщxEсъxŽсыxtсьx†сэx|сюxšсяxŒс№xЃсёxЕсђxЊсѓxЏсєxбсѕxЦсіxЫсїxдсјxОсљxМсњxХсћxЪсќxьт@xчтAxктBx§тCxєтDyтEyтFyтGyтHy,тIy+тJy@тKy`тLyWтMy_тNyZтOyUтPySтQyzтRyтSyŠтTyтUyЇтVŸKтWyЊтXyЎтYyГтZyЙт[yКт\yЩт]yет^yчт_yьт`yстayутbzтcz тdzтezтfz тgzтhy€тiz1тjz;тkz>тlz7тmzCтnzWтozIтpzaтqzbтrziтsŸтtzpтuzyтvz}тwzˆтxz—тyz•тzz˜т{z–т|zЉт}zШт~zАт€zЖтzХт‚zФтƒzПт„ƒт…zЧт†zЪт‡zЭтˆzЯт‰zетŠzгт‹zйтŒzктzнтŽzстzттzцт‘zэт’z№т“{т”{т•{ т–{т—{3т˜{т™{тš{т›{5тœ{(т{6тž{PтŸ{zт {тЁ{MтЂ{ тЃ{LтЄ{EтЅ{uтІ{eтЇ{tтЈ{gтЉ{pтЊ{qтЋ{lтЌ{nт­{тЎ{˜тЏ{ŸтА{тБ{œтВ{šтГ{‹тД{’тЕ{тЖ{]тЗ{™тИ{ЫтЙ{СтК{ЬтЛ{ЯтМ{ДтН{ЦтО{нтП{щтР|тС|тТ{цтУ{хтФ|`тХ|тЦ|тЧ|тШ{ѓтЩ{їтЪ|тЫ| тЬ{ітЭ|#тЮ|'тЯ|*та|тб|7тв|+тг|=тд|Lте|Cтж|Tтз|Oти|@тй|Pтк|Xтл|_тм|dтн|Vто|eтп|lтр|uтс|ƒтт|ту|Єтф|­тх|Ђтц|Ћтч|Ётш|Јтщ|Гтъ|Вты|Бть|Ўтэ|Йтю|Нтя|Рт№|Хтё|Ттђ|итѓ|втє|мтѕ|тті›;тї|ятј|ђтљ|єтњ|ітћ|њтќ}у@}уA}уB}уC} уD}EуE}KуF}.уG}2уH}?уI}5уJ}FуK}sуL}VуM}NуN}rуO}hуP}nуQ}OуR}cуS}“уT}‰уU}[уV}уW}}уX}›уY}КуZ}Ўу[}Ѓу\}Еу]}Чу^}Ну_}Ћу`~=уa}Ђуb}Џуc}муd}Иуe}Ÿуf}Ауg}иуh}нуi}фуj}оуk}ћуl}ђуm}суn~уo~ уp~#уq~!уr~уs~1уt~уu~ уv~ уw~"уx~Fуy~fуz~;у{~5у|~9у}~Cу~~7у€~2у~:у‚~gуƒ~]у„~Vу…~^у†~Yу‡~Zуˆ~yу‰~jуŠ~iу‹~|уŒ~{у~ƒуŽ}еу~}уЎу‘~у’~ˆу“~‰у”~Œу•~’у–~у—~“у˜~”у™~–уš~Žу›~›уœ~œу8уž:уŸEу LуЁMуЂNуЃPуЄQуЅUуІTуЇXуЈ_уЉ`уЊhуЋiуЌgу­xуЎ‚уЏ†уАƒуБˆуВ‡уГŒуД”уЕžуЖуЗšуИЃуЙЏуКВуЛЙуМЎуНЖуОИуП‹qуРХуСЦуТЪуУеуФдуХсуЦцуЧщуШѓуЩљуژмуЫ€уЬ€уЭ€ уЮ€уЯ€уа€уб€ув€!уг€(уд€?уе€;уж€Jуз€Fуи€Rуй€Xук€Zул€_ум€bун€hуо€sуп€rур€pус€vут€yуу€}уф€ух€„уц€†уч€…уш€›ущ€“уъ€šуы€­уьQуэ€Ќую€луя€ху№€йуё€нуђ€Фуѓ€кує€жуѕ уі€яуї€ёујуљ)уњ#ућ/уќKф@–‹фAFфB>фCSфDQфE€ќфFqфGnфHeфIfфJtфKƒфLˆфMŠфN€фO‚фP фQ•фRЄфSЃфT_фU“фVЉфWАфXЕфYОфZИф[Нф\Рф]Тф^Кф_Щф`ЭфaбфbйфcифdШфeкфfпфgрфhчфiњфjћфkўфl‚фm‚фn‚фo‚фp‚ фq‚ фr‚фs‚фt‚)фu‚+фv‚8фw‚3фx‚@фy‚Yфz‚Xф{‚]ф|‚Zф}‚_ф~‚dф€‚bф‚hф‚‚jфƒ‚kф„‚.ф…‚qф†‚wф‡‚xфˆ‚~ф‰‚фŠ‚’ф‹‚ЋфŒ‚Ÿф‚ЛфŽ‚Ќф‚сф‚уф‘‚пф’‚вф“‚єф”‚ѓф•‚њф–ƒ“ф—ƒф˜‚ћф™‚љфš‚оф›ƒфœ‚мфƒ фž‚йфŸƒ5ф ƒ4фЁƒфЂƒ2фЃƒ1фЄƒ@фЅƒ9фІƒPфЇƒEфЈƒ/фЉƒ+фЊƒфЋƒфЌƒ…ф­ƒšфЎƒЊфЏƒŸфАƒЂфБƒ–фВƒ#фГƒŽфДƒ‡фЕƒŠфЖƒ|фЗƒЕфИƒsфЙƒuфКƒ фЛƒ‰фМƒЈфНƒєфО„фПƒыфРƒЮфСƒ§фТ„фУƒифФ„ фХƒСфЦƒїфЧ„фШƒрфЩƒђфЪ„ фЫ„"фЬ„ фЭƒНфЮ„8фЯ…фаƒћфб„mфв„*фг„<фд…Zфе„„фж„wфз„kфи„­фй„nфк„‚фл„iфм„Fфн„,фо„oфп„yфр„5фс„Ъфт„bфу„Йфф„Пфх„Ÿфц„йфч„Эфш„Лфщ„кфъ„афы„Сфь„Цфэ„жфю„Ёфя…!ф№„џфё„єфђ…фѓ…фє…,фѕ…фі…фї…фј„ќфљ…@фњ…cфћ…Xфќ…Hх@…AхA†хB…KхC…UхD…€хE…ЄхF…ˆхG…‘хH…ŠхI…ЈхJ…mхK…”хL…›хM…ъхN…‡хO…œхP…wхQ…~хR…хS…ЩхT…КхU…ЯхV…ЙхW…ахX…ехY…нхZ…хх[…мх\…љх]† х^†х_† х`…ўхa…њхb†хc†"хd†хe†0хf†?хg†MхhNUхi†Tхj†_хk†gхl†qхm†“хn†Ѓхo†Љхp†Њхq†‹хr†Œхs†Жхt†Џхu†Фхv†Цхw†Ахx†Щхyˆ#хz†Ћх{†дх|†ох}†щх~†ьх€†пх†лх‚†яхƒ‡х„‡х…‡х†‡х‡‡хˆ†ћх‰‡хŠ‡ х‹‡ хŒ†љх‡ хŽ‡4х‡?х‡7х‘‡;х’‡%х“‡)х”‡х•‡`х–‡_х—‡xх˜‡Lх™‡Nхš‡tх›‡Wхœ‡hх‡nхž‡YхŸ‡Sх ‡cхЁ‡jхЂˆхЃ‡ЂхЄ‡ŸхЅ‡‚хІ‡ЏхЇ‡ЫхЈ‡НхЉ‡РхЊ‡ахЋ–жхЌ‡Ћх­‡ФхЎ‡ГхЏ‡ЧхА‡ЦхБ‡ЛхВ‡яхГ‡ђхД‡рхЕˆхЖˆ хЗ‡ўхИ‡іхЙ‡їхКˆхЛ‡вхМˆхНˆхОˆхПˆ"хРˆ!хСˆ1хТˆ6хУˆ9хФˆ'хХˆ;хЦˆDхЧˆBхШˆRхЩˆYхЪˆ^хЫˆbхЬˆkхЭˆхЮˆ~хЯˆžхаˆuхбˆ}хвˆЕхгˆrхдˆ‚хеˆ—хжˆ’хзˆЎхиˆ™хйˆЂхкˆхлˆЄхмˆАхнˆПхоˆБхпˆУхрˆФхсˆдхтˆихуˆйхфˆнххˆљхц‰хчˆќхшˆєхщˆшхъˆђхы‰хь‰ хэ‰ хю‰хя‰Cх№‰хё‰%хђ‰*хѓ‰+хє‰Aхѕ‰Dхі‰;хї‰6хј‰8хљ‰Lхњ‰хћ‰`хќ‰^ц@‰fцA‰dцB‰mцC‰jцD‰oцE‰tцF‰wцG‰~цH‰ƒцI‰ˆцJ‰ŠцK‰“цL‰˜цM‰ЁцN‰ЉцO‰ІцP‰ЌцQ‰ЏцR‰ВцS‰КцT‰НцU‰ПцV‰РцW‰кцX‰мцY‰нцZ‰чц[‰єц\‰јц]Šц^Šц_Šц`Š цaŠцbŠцcŠ%цdŠ6цeŠAцfŠ[цgŠRцhŠFцiŠHцjŠ|цkŠmцlŠlцmŠbцnŠ…цoŠ‚цpŠ„цqŠЈцrŠЁцsŠ‘цtŠЅцuŠІцvŠšцwŠЃцxŠФцyŠЭцzŠТц{Šкц|Šыц}Šѓц~Šчц€ŠфцŠёц‚‹цƒŠрц„Šтц…Šїц†Šоц‡Šлцˆ‹ ц‰‹цŠ‹ц‹ŠсцŒ‹ц‹цŽ‹ц‹ ц‹3ц‘—Ћц’‹&ц“‹+ц”‹>ц•‹(ц–‹Aц—‹Lц˜‹Oц™‹Nцš‹Iц›‹Vцœ‹[ц‹Zцž‹kцŸ‹_ц ‹lцЁ‹oцЂ‹tцЃ‹}цЄ‹€цЅ‹ŒцІ‹ŽцЇ‹’цЈ‹“цЉ‹–цЊ‹™цЋ‹šцЌŒ:ц­ŒAцЎŒ?цЏŒHцАŒLцБŒNцВŒPцГŒUцДŒbцЕŒlцЖŒxцЗŒzцИŒ‚цЙŒ‰цКŒ…цЛŒŠцМŒцНŒŽцОŒ”цПŒ|цРŒ˜цСbцТŒ­цУŒЊцФŒНцХŒВцЦŒГцЧŒЎцШŒЖцЩŒШцЪŒСцЫŒфцЬŒуцЭŒкцЮŒ§цЯŒњцаŒћцбцвцг цдцецж цзциŸNцйцкŒЭцлцмцнgцоmцпqцрsцсцт™цуТцфОцхКццЯцчкцшжцщЬцълцыЫцьъцэыцюпцяуц№ќцёŽцђŽ цѓџцєŽцѕŽціŽцїŽцјŽBцљŽ5цњŽ0цћŽ4цќŽJч@ŽGчAŽIчBŽLчCŽPчDŽHчEŽYчFŽdчGŽ`чHŽ*чIŽcчJŽUчKŽvчLŽrчMŽ|чNŽчOŽ‡чPŽ…чQŽ„чRŽ‹чSŽŠчTŽ“чUŽ‘чVŽ”чWŽ™чXŽЊчYŽЁчZŽЌч[ŽАч\ŽЦч]ŽБч^ŽОч_ŽХч`ŽШчaŽЫчbŽлчcŽучdŽќчeŽћчfŽычgŽўчh чiчjчkчlчmчnчoчpчq чr&чs3чt;чu9чvEчwBчx>чyLчzIч{Fч|Nч}Wч~\ч€bчcч‚dчƒœч„Ÿч…Ѓч†­ч‡ЏчˆЗч‰кчŠхч‹тчŒъчячŽ‡чєчч‘љч’њч“ч”ч•!ч– ч—ч˜ч™ чš'ч›6чœ5ч9чžјчŸOч PчЁQчЂRчЃчЄIчЅ>чІVчЇXчЈ^чЉhчЊoчЋvчЌ–Јч­rчЎ‚чЏ}чАчБ€чВŠчГ‰чДчЕЈчЖЏчЗБчИЕчЙтчКфчЛbHчМлчН‘чО‘чП‘чР‘2чС‘0чТ‘JчУ‘VчФ‘XчХ‘cчЦ‘eчЧ‘iчШ‘sчЩ‘rчЪ‘‹чЫ‘‰чЬ‘‚чЭ‘ЂчЮ‘ЋчЯ‘Џча‘Њчб‘Ечв‘Дчг‘Кчд‘Рче‘Счж‘Щчз‘Ычи‘ачй‘жчк‘пчл‘счм‘лчн‘ќчо‘ѕчп‘ічр’чс‘џчт’чу’,чф’чх’чц’^чч’Wчш’Eчщ’Iчъ’dчы’Hчь’•чэ’?чю’Kчя’Pч№’œчё’–чђ’“чѓ’›чє’Zчѕ’Ячі’Йчї’Зчј’щчљ“чњ’њчћ“Dчќ“.ш@“шA“"шB“шC“#шD“:шE“5шF“;шG“\шH“`шI“|шJ“nшK“VшL“АшM“ЌшN“­шO“”шP“ЙшQ“жшR“зшS“шшT“хшU“ишV“УшW“ншX“ашY“ШшZ“фш[”ш\”ш]”ш^”ш_”ш`”шa”6шb”+шc”5шd”!шe”:шf”Aшg”Rшh”Dшi”[шj”`шk”bшl”^шm”jшn’)шo”pшp”uшq”wшr”}шs”Zшt”|шu”~шv”шw”шx•‚шy•‡шz•Šш{•”ш|•–ш}•˜ш~•™ш€• ш•Јш‚•Їшƒ•­ш„•Мш…•Лш†•Йш‡•Ошˆ•Ъш‰oішŠ•Уш‹•ЭшŒ•Ьш•ешŽ•дш•жш•мш‘•сш’•хш“•тш”–!ш•–(ш––.ш—–/ш˜–Bш™–Lшš–Oш›–Kшœ–wш–\шž–^шŸ–]ш –_шЁ–fшЂ–rшЃ–lшЄ–шЅ–˜шІ–•шЇ–—шЈ–ЊшЉ–ЇшЊ–БшЋ–ВшЌ–Аш­–ДшЎ–ЖшЏ–ИшА–ЙшБ–ЮшВ–ЫшГ–ЩшД–ЭшЕ‰MшЖ–мшЗ— шИ–ешЙ–љшК—шЛ—шМ—шН—шО—шП—шР—шС—шТ—шУ—$шФ—*шХ—0шЦ—9шЧ—=шШ—>шЩ—DшЪ—FшЫ—HшЬ—BшЭ—IшЮ—\шЯ—`ша—dшб—fшв—hшгRвшд—kше—qшж—yшз—…ши—|шй—шк—zшл—†шм—‹шн—шо—шп—œшр—Јшс—Ішт—Ѓшу—Гшф—Дшх—Ушц—Цшч—Шшш—Ышщ—мшъ—эшыŸOшь—ђшэzпшю—ішя—ѕш№˜шё˜ шђ˜8шѓ˜$шє˜!шѕ˜7ші˜=шї˜Fшј˜Oшљ˜Kшњ˜kшћ˜oшќ˜pщ@˜qщA˜tщB˜sщC˜ЊщD˜ЏщE˜БщF˜ЖщG˜ФщH˜УщI˜ЦщJ˜щщK˜ыщL™щM™ щN™щO™щP™щQ™!щR™щS™щT™$щU™ щV™,щW™.щX™=щY™>щZ™Bщ[™Iщ\™Eщ]™Pщ^™Kщ_™Qщ`™Rщa™Lщb™Uщc™—щd™˜щe™Ѕщf™­щg™Ўщh™Мщi™пщj™лщk™нщl™ищm™бщn™эщo™ющp™ёщq™ђщr™ћщs™јщtšщušщvšщw™тщxšщyš+щzš7щ{šEщ|šBщ}š@щ~šCщ€š>щšUщ‚šMщƒš[щ„šWщ…š_щ†šbщ‡šeщˆšdщ‰šiщŠškщ‹šjщŒš­щšАщŽšМщšРщšЯщ‘šбщ’šгщ“šдщ”šощ•šпщ–šтщ—šущ˜šцщ™šящššыщ›šющœšєщšёщžšїщŸšћщ ›щЁ›щЂ›щЃ›щЄ›"щЅ›#щІ›%щЇ›'щЈ›(щЉ›)щЊ›*щЋ›.щЌ›/щ­›2щЎ›DщЏ›CщА›OщБ›MщВ›NщГ›QщД›XщЕ›tщЖ›“щЗ›ƒщИ›‘щЙ›–щК›—щЛ›ŸщМ› щН›ЈщО›ДщП›РщР›ЪщС›ЙщТ›ЦщУ›ЯщФ›бщХ›вщЦ›ущЧ›тщШ›фщЩ›дщЪ›сщЫœ:щЬ›ђщЭ›ёщЮ›№щЯœщаœщбœ щвœщгœ щдœщеœщжœщзœ щиœщйœ.щкœщлœ%щмœ$щнœ!щоœ0щпœGщрœ2щсœFщтœ>щуœZщфœ`щхœgщцœvщчœxщшœчщщœьщъœ№щы щьщэœыщющящ№*щё&щђЏщѓ#щєщѕDщіщїщјAщљ?щњ>щћFщќHъ@]ъA^ъBdъCQъDPъEYъFrъG‰ъH‡ъIЋъJoъKzъLšъMЄъNЉъOВъPФъQСъRЛъSИъTКъUЦъVЯъWТъXйъYгъZјъ[цъ\эъ]яъ^§ъ_žъ`žъažъbžuъcžyъdž}ъežъfžˆъgž‹ъhžŒъiž’ъjž•ъkž‘ъlžъmžЅъnžЉъožИъpžЊъqž­ъr—aъsžЬъtžЮъužЯъvžаъwžдъxžмъyžоъzžнъ{žръ|žхъ}žшъ~žяъ€žєъžіъ‚žїъƒžљъ„žћъ…žќъ†ž§ъ‡ŸъˆŸъ‰vЗъŠŸъ‹Ÿ!ъŒŸ,ъŸ>ъŽŸJъŸRъŸTъ‘Ÿcъ’Ÿ_ъ“Ÿ`ъ”Ÿaъ•Ÿfъ–Ÿgъ—Ÿlъ˜Ÿjъ™ŸwъšŸrъ›ŸvъœŸ•ъŸœъžŸ ъŸX/ъ iЧъЁYъЂtdъЃQмъЄq™э@~ŠэA‰эB“HэC’ˆэD„мэEOЩэFpЛэGf1эHhШэI’љэJfћэK_EэLN(эMNсэNNќэOOэPOэQO9эROVэSO’эTOŠэUOšэVO”эWOЭэXP@эYP"эZOџэ[Pэ\PFэ]Ppэ^PBэ_P”э`PєэaPиэbQJэcQdэdQэeQОэfQьэgRэhRœэiRІэjRРэkRлэlSэmSэnS$эoSrэpS“эqSВэrSнэsњэtTœэuTŠэvTЉэwTџэxU†эyWYэzWeэ{WЌэ|WШэ}WЧэ~њэ€њэXžэ‚XВэƒY э„YSэ…Y[э†Y]э‡YcэˆYЄэ‰YКэŠ[Vэ‹[РэŒu/э[иэŽ[ьэ\э\Іэ‘\Кэ’\ѕэ“]'э”]Sэ•њэ–]Bэ—]mэ˜]Иэ™]Йэš]аэ›_!эœ_4э_gэž_ЗэŸ_оэ `]эЁ`…эЂ`ŠэЃ`оэЄ`еэЅa эІ`ђэЇaэЈa7эЉa0эЊa˜эЋbэЌbІэ­cѕэЎd`эЏdэАdЮэБeNэВfэГfэДf;эЕf эЖf.эЗfэИf$эЙfeэКfWэЛfYэМњэНfsэОf™эПf эРfВэСfПэТfњэУgэФљ)эХgfэЦgЛэЧhRэШgРэЩhэЪhDэЫhЯэЬњэЭihэЮњэЯi˜эаiтэбj0эвjkэгjFэдjsэеj~эжjтэзjфэиkжэйl?экl\элl†эмloэнlкэоmэпm‡эрmoэсm–этmЌэуmЯэфmјэхmђэцmќэчn9эшn\эщn'эъn<эыnПэьoˆээoЕэюoѕэяpэ№pэёp(эђp…эѓpЋэєqэѕqэіq\эїqFэјqGэљњэњqСэћqўэќrБю@rОюAs$юBњюCswюDsНюEsЩюFsжюGsуюHsвюItюJsѕюKt&юLt*юMt)юNt.юOtbюPt‰юQtŸюRuюSuoюTv‚юUvœюVvžюWv›юXvІюYњюZwFю[RЏю\x!ю]xNю^xdю_xzю`y0юaњюbњюcњюdy”юeњюfy›юgzбюhzчюiњюjzыюk{žюlњюm}Hюn}\юo}Зюp} юq}жюr~RюsGюtЁюuњюvƒюwƒbюxƒюyƒЧюzƒію{„Hю|„Дю}…Sю~…Yю€…kюњю‚…Аюƒњ ю„њ!ю…ˆю†ˆѕю‡ŠюˆŠ7ю‰ŠyюŠŠЇю‹ŠОюŒŠпюњ"юŽŠію‹Sю‹ю‘Œ№ю’Œєю“ю”vю•њ#ю–ŽЯю—њ$ю˜њ%ю™gюšою›њ&юœ‘ю‘'юž‘кюŸ‘зю ‘оюЁ‘эюЂ‘ююЃ‘фюЄ‘хюЅ’юІ’юЇ’ юЈ’:юЉ’@юЊ’<юЋ’NюЌ’Yю­’QюЎ’9юЏ’gюА’ЇюБ’wюВ’xюГ’чюД’зюЕ’йюЖ’аюЗњ'юИ’еюЙ’рюК’гюЛ“%юМ“!юН’ћюОњ(юП“юР’џюС“юТ“юУ“pюФ“WюХ“ЄюЦ“ЦюЧ“оюШ“јюЩ”1юЪ”EюЫ”HюЬ•’юЭљмюЮњ)юЯ–юа–Џюб—3юв—;юг—Cюд—Mюе—Oюж—Qюз—Uюи˜Wюй˜eюкњ*юлњ+юм™'юнњ,юо™žюпšNюрšйюсšмют›uюу›rюф›юх›Бюц›Лючœюшpющkюъњ-юыžюьžбюя!pю№!qюё!rюђ!sюѓ!tює!uюѕ!vюі!wюї!xюј!yюљџтюњџфюћџюќџњ@!pњA!qњB!rњC!sњD!tњE!uњF!vњG!wњH!xњI!yњJ!`њK!aњL!bњM!cњN!dњO!eњP!fњQ!gњR!hњS!iњTџтњUџфњVџњWџњX21њY!њZ!!њ["5њ\~Šњ]‰њ^“Hњ_’ˆњ`„мњaOЩњbpЛњcf1њdhШњe’љњffћњg_EњhN(њiNсњjNќњkOњlOњmO9њnOVњoO’њpOŠњqOšњrO”њsOЭњtP@њuP"њvOџњwPњxPFњyPpњzPBњ{P”њ|Pєњ}Pињ~QJњ€QdњQњ‚QОњƒQьњ„Rњ…Rœњ†RІњ‡RРњˆRлњ‰SњŠSњ‹S$њŒSrњS“њŽSВњSнњњњ‘Tœњ’TŠњ“TЉњ”Tџњ•U†њ–WYњ—Weњ˜WЌњ™WШњšWЧњ›њњœњњXžњžXВњŸY њ YSњЁY[њЂY]њЃYcњЄYЄњЅYКњІ[VњЇ[РњЈu/њЉ[ињЊ[ьњЋ\њЌ\Іњ­\КњЎ\ѕњЏ]'њА]SњБњњВ]BњГ]mњД]ИњЕ]ЙњЖ]ањЗ_!њИ_4њЙ_gњК_ЗњЛ_оњМ`]њН`…њО`ŠњП`оњР`ењСa њТ`ђњУaњФa7њХa0њЦa˜њЧbњШbІњЩcѕњЪd`њЫdњЬdЮњЭeNњЮfњЯfњаf;њбf њвf.њгfњдf$њеfeњжfWњзfYњињњйfsњкf™њлf њмfВњнfПњоfњњпgњрљ)њсgfњтgЛњуhRњфgРњхhњцhDњчhЯњшњњщihњъњњыi˜њьiтњэj0њюjkњяjFњ№jsњёj~њђjтњѓjфњєkжњѕl?њіl\њїl†њјloњљlкњњmњћm‡њќmoћ@m–ћAmЌћBmЯћCmјћDmђћEmќћFn9ћGn\ћHn'ћIn<ћJnПћKoˆћLoЕћMoѕћNpћOpћPp(ћQp…ћRpЋћSqћTqћUq\ћVqFћWqGћXњћYqСћZqўћ[rБћ\rОћ]s$ћ^њћ_swћ`sНћasЩћbsжћcsућdsвћetћfsѕћgt&ћht*ћit)ћjt.ћktbћlt‰ћmtŸћnuћouoћpv‚ћqvœћrvžћsv›ћtvІћuњћvwFћwRЏћxx!ћyxNћzxdћ{xzћ|y0ћ}њћ~њћ€њћy”ћ‚њћƒy›ћ„zбћ…zчћ†њћ‡zыћˆ{žћ‰њћŠ}Hћ‹}\ћŒ}Зћ} ћŽ}жћ~RћGћ‘Ёћ’њћ“ƒћ”ƒbћ•ƒћ–ƒЧћ—ƒіћ˜„Hћ™„Дћš…Sћ›…Yћœ…kћњћž…АћŸњ ћ њ!ћЁˆћЂˆѕћЃŠћЄŠ7ћЅŠyћІŠЇћЇŠОћЈŠпћЉњ"ћЊŠіћЋ‹SћЌ‹ћ­Œ№ћЎŒєћЏћАvћБњ#ћВŽЯћГњ$ћДњ%ћЕgћЖоћЗњ&ћИ‘ћЙ‘'ћК‘кћЛ‘зћМ‘оћН‘эћО‘юћП‘фћР‘хћС’ћТ’ћУ’ ћФ’:ћХ’@ћЦ’<ћЧ’NћШ’YћЩ’QћЪ’9ћЫ’gћЬ’ЇћЭ’wћЮ’xћЯ’чћа’зћб’йћв’аћгњ'ћд’еће’рћж’гћз“%ћи“!ћй’ћћкњ(ћл“ћм’џћн“ћо“ћп“pћр“Wћс“Єћт“Цћу“оћф“јћх”1ћц”Eћч”Hћш•’ћщљмћъњ)ћы–ћь–Џћэ—3ћю—;ћя—Cћ№—Mћё—Oћђ—Qћѓ—Uћє˜Wћѕ˜eћіњ*ћїњ+ћј™'ћљњ,ћњ™žћћšNћќšйќ@šмќA›uќB›rќC›ќD›БќE›ЛќFœќGpќHkќIњ-ќJžќKžбecl-16.1.2/contrib/encodings/WINDOWS-CP936.BIN000066400000000000000000002532021266352375300202230ustar00rootroot00000000000000Ћ@  !!""##$$%%&&''(())**++,,--..//00112233445566778899::;;<<==>>??@@AABBCCDDEEFFGGHHIIJJKKLLMMNNOOPPQQRRSSTTUUVVWWXXYYZZ[[\\]]^^__``aabbccddeeffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~€ Ќ@NANBNCNDNENFNGNHN IN!JN#KN&LN)MN.NN/ON1PN3QN5RN7SN<TN@UNAVNBWNDXNFYNJZNQ[NU\NW]NZ^N[_Nb`NcaNdbNecNgdNheNjfNkgNlhNmiNnjNokNrlNtmNunNvoNwpNxqNyrNzsN{tN|uN}vNwN€xNyN‚zNƒ{N„|N…}N‡~NŠ€NN–‚N—ƒN™„Nœ…N†Nž‡NЃˆNЊ‰NЏŠNА‹NБŒNДNЖŽNЗNИNЙ‘NМ’NН“NО”NШ•NЬ–NЯ—Nа˜Nв™NкšNл›NмœNрNтžNцŸNч NщЁNэЂNюЃNяЄNёЅNєІNјЇNљЈNњЉNќЊNўЋOЌO­OЎOЏOАOБOВOГO ДO ЕOЖOЗOИOЙOКOЛOМO!НO#ОO(ПO)РO,СO-ТO.УO1ФO3ХO5ЦO7ЧO9ШO;ЩO>ЪO?ЫO@ЬOAЭOBЮODЯOEаOGбOHвOIгOJдOKеOLжORзOTиOVйOaкObлOfмOhнOjоOkпOmрOnсOqтOrуOuфOwхOxцOyчOzшO}щO€ъOыO‚ьO…эO†юO‡яOŠ№OŒёOŽђOѓO’єO“ѕO•іO–їO˜јO™љOšњOœћOžќOŸ§OЁўOЂ‚@OЄ‚AOЋ‚BO­‚COА‚DOБ‚EOВ‚FOГ‚GOД‚HOЖ‚IOЗ‚JOИ‚KOЙ‚LOК‚MOЛ‚NOМ‚OOН‚POО‚QOР‚ROС‚SOТ‚TOЦ‚UOЧ‚VOШ‚WOЩ‚XOЫ‚YOЬ‚ZOЭ‚[Oв‚\Oг‚]Oд‚^Oе‚_Oж‚`Oй‚aOл‚bOр‚cOт‚dOф‚eOх‚fOч‚gOы‚hOь‚iO№‚jOђ‚kOє‚lOѕ‚mOі‚nOї‚oOљ‚pOћ‚qOќ‚rO§‚sOџ‚tP‚uP‚vP‚wP‚xP‚yP‚zP‚{P‚|P‚}P ‚~P ‚€P ‚P‚‚P‚ƒP‚„P‚…P‚†P‚‡P‚ˆP‚‰P‚ŠP‚‹P ‚ŒP"‚P#‚ŽP$‚P'‚P+‚‘P/‚’P0‚“P1‚”P2‚•P3‚–P4‚—P5‚˜P6‚™P7‚šP8‚›P9‚œP;‚P=‚žP?‚ŸP@‚ PA‚ЁPB‚ЂPD‚ЃPE‚ЄPF‚ЅPI‚ІPJ‚ЇPK‚ЈPM‚ЉPP‚ЊPQ‚ЋPR‚ЌPS‚­PT‚ЎPV‚ЏPW‚АPX‚БPY‚ВP[‚ГP]‚ДP^‚ЕP_‚ЖP`‚ЗPa‚ИPb‚ЙPc‚КPd‚ЛPf‚МPg‚НPh‚ОPi‚ПPj‚РPk‚СPm‚ТPn‚УPo‚ФPp‚ХPq‚ЦPr‚ЧPs‚ШPt‚ЩPu‚ЪPx‚ЫPy‚ЬPz‚ЭP|‚ЮP}‚ЯP‚аP‚‚бPƒ‚вP„‚гP†‚дP‡‚еP‰‚жPŠ‚зP‹‚иPŒ‚йPŽ‚кP‚лP‚мP‘‚нP’‚оP“‚пP”‚рP•‚сP–‚тP—‚уP˜‚фP™‚хPš‚цP›‚чPœ‚шP‚щPž‚ъPŸ‚ыP ‚ьPЁ‚эPЂ‚юPЄ‚яPІ‚№PЊ‚ёPЋ‚ђP­‚ѓPЎ‚єPЏ‚ѕPА‚іPБ‚їPГ‚јPД‚љPЕ‚њPЖ‚ћPЗ‚ќPИ‚§PЙ‚ўPМƒ@PНƒAPОƒBPПƒCPРƒDPСƒEPТƒFPУƒGPФƒHPХƒIPЦƒJPЧƒKPШƒLPЩƒMPЪƒNPЫƒOPЬƒPPЭƒQPЮƒRPаƒSPбƒTPвƒUPгƒVPдƒWPеƒXPзƒYPиƒZPйƒ[Pлƒ\Pмƒ]Pнƒ^Pоƒ_Pпƒ`PрƒaPсƒbPтƒcPуƒdPфƒePхƒfPшƒgPщƒhPъƒiPыƒjPяƒkP№ƒlPёƒmPђƒnPєƒoPіƒpPїƒqPјƒrPљƒsPњƒtPќƒuP§ƒvPўƒwPџƒxQƒyQƒzQƒ{Qƒ|Qƒ}Qƒ~Qƒ€Q ƒQ ƒ‚Q ƒƒQ ƒ„Qƒ…Qƒ†Qƒ‡QƒˆQƒ‰QƒŠQƒ‹QƒŒQƒQƒŽQƒQƒQƒ‘Qƒ’Qƒ“Qƒ”Qƒ•Q ƒ–Q"ƒ—Q#ƒ˜Q$ƒ™Q%ƒšQ&ƒ›Q'ƒœQ(ƒQ)ƒžQ*ƒŸQ+ƒ Q,ƒЁQ-ƒЂQ.ƒЃQ/ƒЄQ0ƒЅQ1ƒІQ2ƒЇQ3ƒЈQ4ƒЉQ5ƒЊQ6ƒЋQ7ƒЌQ8ƒ­Q9ƒЎQ:ƒЏQ;ƒАQ<ƒБQ=ƒВQ>ƒГQBƒДQGƒЕQJƒЖQLƒЗQNƒИQOƒЙQPƒКQRƒЛQSƒМQWƒНQXƒОQYƒПQ[ƒРQ]ƒСQ^ƒТQ_ƒУQ`ƒФQaƒХQcƒЦQdƒЧQfƒШQgƒЩQiƒЪQjƒЫQoƒЬQrƒЭQzƒЮQ~ƒЯQƒаQƒƒбQ„ƒвQ†ƒгQ‡ƒдQŠƒеQ‹ƒжQŽƒзQƒиQƒйQ‘ƒкQ“ƒлQ”ƒмQ˜ƒнQšƒоQƒпQžƒрQŸƒсQЁƒтQЃƒуQІƒфQЇƒхQЈƒцQЉƒчQЊƒшQ­ƒщQЎƒъQДƒыQИƒьQЙƒэQКƒюQОƒяQПƒ№QСƒёQТƒђQУƒѓQХƒєQШƒѕQЪƒіQЭƒїQЮƒјQаƒљQвƒњQгƒћQдƒќQеƒ§QжƒўQз„@Qи„AQй„BQк„CQм„DQо„EQп„FQт„GQу„HQх„IQц„JQч„KQш„LQщ„MQъ„NQь„OQю„PQё„QQђ„RQє„SQї„TQў„UR„VR„WR „XR „YR „ZR„[R„\R„]R„^R„_R„`R„aR„bR!„cR"„dR#„eR%„fR&„gR'„hR*„iR,„jR/„kR1„lR2„mR4„nR5„oR<„pR>„qRD„rRE„sRF„tRG„uRH„vRI„wRK„xRN„yRO„zRR„{RS„|RU„}RW„~RX„€RY„RZ„‚R[„ƒR]„„R_„…R`„†Rb„‡Rc„ˆRd„‰Rf„ŠRh„‹Rk„ŒRl„Rm„ŽRn„Rp„Rq„‘Rs„’Rt„“Ru„”Rv„•Rw„–Rx„—Ry„˜Rz„™R{„šR|„›R~„œR€„Rƒ„žR„„ŸR…„ R†„ЁR‡„ЂR‰„ЃRŠ„ЄR‹„ЅRŒ„ІR„ЇRŽ„ЈR„ЉR‘„ЊR’„ЋR”„ЌR•„­R–„ЎR—„ЏR˜„АR™„БRš„ВRœ„ГRЄ„ДRЅ„ЕRІ„ЖRЇ„ЗRЎ„ИRЏ„ЙRА„КRД„ЛRЕ„МRЖ„НRЗ„ОRИ„ПRЙ„РRК„СRЛ„ТRМ„УRН„ФRР„ХRС„ЦRТ„ЧRФ„ШRХ„ЩRЦ„ЪRШ„ЫRЪ„ЬRЬ„ЭRЭ„ЮRЮ„ЯRЯ„аRб„бRг„вRд„гRе„дRз„еRй„жRк„зRл„иRм„йRн„кRо„лRр„мRс„нRт„оRу„пRх„рRц„сRч„тRш„уRщ„фRъ„хRы„цRь„чRэ„шRю„щRя„ъRё„ыRђ„ьRѓ„эRє„юRѕ„яRі„№Rї„ёRј„ђRћ„ѓRќ„єR§„ѕS„іS„їS„јS„љS„њS „ћS „ќS „§S „ўS…@S…AS…BS…CS…DS…ES…FS…GS…HS…IS"…JS$…KS%…LS'…MS(…NS)…OS+…PS,…QS-…RS/…SS0…TS1…US2…VS3…WS4…XS5…YS6…ZS7…[S8…\S<…]S=…^S@…_SB…`SD…aSF…bSK…cSL…dSM…eSP…fST…gSX…hSY…iS[…jS]…kSe…lSh…mSj…nSl…oSm…pSr…qSv…rSy…sS{…tS|…uS}…vS~…wS€…xS…ySƒ…zS‡…{Sˆ…|SŠ…}SŽ…~S…€S…S‘…‚S’…ƒS“…„S”……S–…†S—…‡S™…ˆS›…‰Sœ…ŠSž…‹S …ŒSЁ…SЄ…ŽSЇ…SЊ…SЋ…‘SЌ…’S­…“SЏ…”SА…•SБ…–SВ…—SГ…˜SД…™SЕ…šSЗ…›SИ…œSЙ…SК…žSМ…ŸSН… SО…ЁSР…ЂSУ…ЃSФ…ЄSХ…ЅSЦ…ІSЧ…ЇSЮ…ЈSЯ…ЉSа…ЊSв…ЋSг…ЌSе…­Sк…ЎSм…ЏSн…АSо…БSс…ВSт…ГSч…ДSє…ЕSњ…ЖSў…ЗSџ…ИT…ЙT…КT…ЛT…МT …НT…ОT…ПT…РT…СT…ТT"…УT$…ФT%…ХT*…ЦT0…ЧT3…ШT6…ЩT7…ЪT:…ЫT=…ЬT?…ЭTA…ЮTB…ЯTD…аTE…бTG…вTI…гTL…дTM…еTN…жTO…зTQ…иTZ…йT]…кT^…лT_…мT`…нTa…оTc…пTe…рTg…сTi…тTj…уTk…фTl…хTm…цTn…чTo…шTp…щTt…ъTy…ыTz…ьT~…эT…юT…яTƒ…№T……ёT‡…ђTˆ…ѓT‰…єTŠ…ѕT…іT‘…їT“…јT—…љT˜…њTœ…ћTž…ќTŸ…§T …ўTЁ†@TЂ†ATЅ†BTЎ†CTА†DTВ†ETЕ†FTЖ†GTЗ†HTЙ†ITК†JTМ†KTО†LTУ†MTХ†NTЪ†OTЫ†PTж†QTи†RTл†STр†TTс†UTт†VTу†WTф†XTы†YTь†ZTя†[T№†\Tё†]Tє†^Tѕ†_Tі†`Tї†aTј†bTљ†cTћ†dTў†eU†fU†gU†hU†iU†jU†kU †lU †mU †nU †oU†pU†qU†rU†sU†tU†uU†vU†wU†xU†yU†zU†{U†|U!†}U%†~U&†€U(†U)†‚U+†ƒU-†„U2†…U4††U5†‡U6†ˆU8†‰U9†ŠU:†‹U;†ŒU=†U@†ŽUB†UE†UG†‘UH†’UK†“UL†”UM†•UN†–UO†—UQ†˜UR†™US†šUT†›UW†œUX†UY†žUZ†ŸU[† U]†ЁU^†ЂU_†ЃU`†ЄUb†ЅUc†ІUh†ЇUi†ЈUk†ЉUo†ЊUp†ЋUq†ЌUr†­Us†ЎUt†ЏUy†АUz†БU}†ВU†ГU…†ДU††ЕUŒ†ЖU†ЗUŽ†ИU†ЙU’†КU“†ЛU•†МU–†НU—†ОUš†ПU›†РUž†СU †ТUЁ†УUЂ†ФUЃ†ХUЄ†ЦUЅ†ЧUІ†ШUЈ†ЩUЉ†ЪUЊ†ЫUЋ†ЬUЌ†ЭU­†ЮUЎ†ЯUЏ†аUА†бUВ†вUД†гUЖ†дUИ†еUК†жUМ†зUП†иUР†йUС†кUТ†лUУ†мUЦ†нUЧ†оUШ†пUЪ†рUЫ†сUЮ†тUЯ†уUа†фUе†хUз†цUи†чUй†шUк†щUл†ъUо†ыUр†ьUт†эUч†юUщ†яUэ†№Uю†ёU№†ђUё†ѓUє†єUі†ѕUј†іUљ†їUњ†јUћ†љUќ†њUџ†ћV†ќV†§V†ўV‡@V‡AV‡BV ‡CV ‡DV ‡EV‡FV‡GV‡HV‡IV‡JV‡KV‡LV‡MV‡NV‡OV‡PV‡QV ‡RV!‡SV"‡TV%‡UV&‡VV(‡WV)‡XV*‡YV+‡ZV.‡[V/‡\V0‡]V3‡^V5‡_V7‡`V8‡aV:‡bV<‡cV=‡dV>‡eV@‡fVA‡gVB‡hVC‡iVD‡jVE‡kVF‡lVG‡mVH‡nVI‡oVJ‡pVK‡qVO‡rVP‡sVQ‡tVR‡uVS‡vVU‡wVV‡xVZ‡yV[‡zV]‡{V^‡|V_‡}V`‡~Va‡€Vc‡Ve‡‚Vf‡ƒVg‡„Vm‡…Vn‡†Vo‡‡Vp‡ˆVr‡‰Vs‡ŠVt‡‹Vu‡ŒVw‡Vx‡ŽVy‡Vz‡V}‡‘V~‡’V‡“V€‡”V‡•V‚‡–Vƒ‡—V„‡˜V‡‡™Vˆ‡šV‰‡›VŠ‡œV‹‡VŒ‡žV‡ŸV‡ V‘‡ЁV’‡ЂV”‡ЃV•‡ЄV–‡ЅV—‡ІV˜‡ЇV™‡ЈVš‡ЉV›‡ЊVœ‡ЋV‡ЌVž‡­VŸ‡ЎV ‡ЏVЁ‡АVЂ‡БVЄ‡ВVЅ‡ГVІ‡ДVЇ‡ЕVЈ‡ЖVЉ‡ЗVЊ‡ИVЋ‡ЙVЌ‡КV­‡ЛVЎ‡МVА‡НVБ‡ОVВ‡ПVГ‡РVД‡СVЕ‡ТVЖ‡УVИ‡ФVЙ‡ХVК‡ЦVЛ‡ЧVН‡ШVО‡ЩVП‡ЪVР‡ЫVС‡ЬVТ‡ЭVУ‡ЮVФ‡ЯVХ‡аVЦ‡бVЧ‡вVШ‡гVЩ‡дVЫ‡еVЬ‡жVЭ‡зVЮ‡иVЯ‡йVа‡кVб‡лVв‡мVг‡нVе‡оVж‡пVи‡рVй‡сVм‡тVу‡уVх‡фVц‡хVч‡цVш‡чVщ‡шVъ‡щVь‡ъVю‡ыVя‡ьVђ‡эVѓ‡юVі‡яVї‡№Vј‡ёVћ‡ђVќ‡ѓW‡єW‡ѕW‡іW‡їW‡јW ‡љW ‡њW ‡ћW‡ќW‡§W‡ўWˆ@WˆAWˆBWˆCWˆDWˆEWˆFWˆGWˆHWˆIWˆJWˆKWˆLW ˆMW!ˆNW"ˆOW$ˆPW%ˆQW&ˆRW'ˆSW+ˆTW1ˆUW2ˆVW4ˆWW5ˆXW6ˆYW7ˆZW8ˆ[W<ˆ\W=ˆ]W?ˆ^WAˆ_WCˆ`WDˆaWEˆbWFˆcWHˆdWIˆeWKˆfWRˆgWSˆhWTˆiWUˆjWVˆkWXˆlWYˆmWbˆnWcˆoWeˆpWgˆqWlˆrWnˆsWpˆtWqˆuWrˆvWtˆwWuˆxWxˆyWyˆzWzˆ{W}ˆ|W~ˆ}Wˆ~W€ˆ€WˆW‡ˆ‚WˆˆƒW‰ˆ„WŠˆ…Wˆ†WŽˆ‡WˆˆWˆ‰W‘ˆŠW”ˆ‹W•ˆŒW–ˆW—ˆŽW˜ˆW™ˆWšˆ‘Wœˆ’Wˆ“Wžˆ”WŸˆ•WЅˆ–WЈˆ—WЊˆ˜WЌˆ™WЏˆšWАˆ›WБˆœWГˆWЕˆžWЖˆŸWЗˆ WЙˆЁWКˆЂWЛˆЃWМˆЄWНˆЅWОˆІWПˆЇWРˆЈWСˆЉWФˆЊWХˆЋWЦˆЌWЧˆ­WШˆЎWЩˆЏWЪˆАWЬˆБWЭˆВWаˆГWбˆДWгˆЕWжˆЖWзˆЗWлˆИWмˆЙWоˆКWсˆЛWтˆМWуˆНWхˆОWцˆПWчˆРWшˆСWщˆТWъˆУWыˆФWьˆХWюˆЦW№ˆЧWёˆШWђˆЩWѓˆЪWѕˆЫWіˆЬWїˆЭWћˆЮWќˆЯWўˆаWџˆбXˆвXˆгXˆдXˆеXˆжX ˆзX ˆиX ˆйXˆкXˆлXˆмXˆнXˆоXˆпXˆрXˆсXˆтXˆуXˆфXˆхXˆцXˆчX"ˆшX#ˆщX%ˆъX&ˆыX'ˆьX(ˆэX)ˆюX+ˆяX,ˆ№X-ˆёX.ˆђX/ˆѓX1ˆєX2ˆѕX3ˆіX4ˆїX6ˆјX7ˆљX8ˆњX9ˆћX:ˆќX;ˆ§X<ˆўX=‰@X>‰AX?‰BX@‰CXA‰DXB‰EXC‰FXE‰GXF‰HXG‰IXH‰JXI‰KXJ‰LXK‰MXN‰NXO‰OXP‰PXR‰QXS‰RXU‰SXV‰TXW‰UXY‰VXZ‰WX[‰XX\‰YX]‰ZX_‰[X`‰\Xa‰]Xb‰^Xc‰_Xd‰`Xf‰aXg‰bXh‰cXi‰dXj‰eXm‰fXn‰gXo‰hXp‰iXq‰jXr‰kXs‰lXt‰mXu‰nXv‰oXw‰pXx‰qXy‰rXz‰sX{‰tX|‰uX}‰vX‰wX‚‰xX„‰yX†‰zX‡‰{Xˆ‰|XŠ‰}X‹‰~XŒ‰€X‰XŽ‰‚X‰ƒX‰„X‘‰…X”‰†X•‰‡X–‰ˆX—‰‰X˜‰ŠX›‰‹Xœ‰ŒX‰X ‰ŽXЁ‰XЂ‰XЃ‰‘XЄ‰’XЅ‰“XІ‰”XЇ‰•XЊ‰–XЋ‰—XЌ‰˜X­‰™XЎ‰šXЏ‰›XА‰œXБ‰XВ‰žXГ‰ŸXД‰ XЕ‰ЁXЖ‰ЂXЗ‰ЃXИ‰ЄXЙ‰ЅXК‰ІXЛ‰ЇXН‰ЈXО‰ЉXП‰ЊXР‰ЋXТ‰ЌXУ‰­XФ‰ЎXЦ‰ЏXЧ‰АXШ‰БXЩ‰ВXЪ‰ГXЫ‰ДXЬ‰ЕXЭ‰ЖXЮ‰ЗXЯ‰ИXа‰ЙXв‰КXг‰ЛXд‰МXж‰НXз‰ОXи‰ПXй‰РXк‰СXл‰ТXм‰УXн‰ФXо‰ХXп‰ЦXр‰ЧXс‰ШXт‰ЩXу‰ЪXх‰ЫXц‰ЬXч‰ЭXш‰ЮXщ‰ЯXъ‰аXэ‰бXя‰вXё‰гXђ‰дXє‰еXѕ‰жXї‰зXј‰иXњ‰йXћ‰кXќ‰лX§‰мXў‰нXџ‰оY‰пY‰рY‰сY‰тY‰уY‰фY ‰хY ‰цY ‰чY ‰шY‰щY‰ъY‰ыY‰ьY‰эY‰юY‰яY‰№Y‰ёY‰ђY ‰ѓY!‰єY"‰ѕY#‰іY&‰їY(‰јY,‰љY0‰њY2‰ћY3‰ќY5‰§Y6‰ўY;Š@Y=ŠAY>ŠBY?ŠCY@ŠDYCŠEYEŠFYFŠGYJŠHYLŠIYMŠJYPŠKYRŠLYSŠMYYŠNY[ŠOY\ŠPY]ŠQY^ŠRY_ŠSYaŠTYcŠUYdŠVYfŠWYgŠXYhŠYYiŠZYjŠ[YkŠ\YlŠ]YmŠ^YnŠ_YoŠ`YpŠaYqŠbYrŠcYuŠdYwŠeYzŠfY{ŠgY|ŠhY~ŠiYŠjY€ŠkY…ŠlY‰ŠmY‹ŠnYŒŠoYŽŠpYŠqYŠrY‘ŠsY”ŠtY•ŠuY˜ŠvYšŠwY›ŠxYœŠyYŠzYŸŠ{Y Š|YЁŠ}YЂŠ~YІŠ€YЇŠYЌŠ‚Y­ŠƒYАŠ„YБŠ…YГŠ†YДŠ‡YЕŠˆYЖŠ‰YЗŠŠYИŠ‹YКŠŒYМŠYНŠŽYПŠYРŠYСŠ‘YТŠ’YУŠ“YФŠ”YХŠ•YЧŠ–YШŠ—YЩŠ˜YЬŠ™YЭŠšYЮŠ›YЯŠœYеŠYжŠžYйŠŸYлŠ YоŠЁYпŠЂYрŠЃYсŠЄYтŠЅYфŠІYцŠЇYчŠЈYщŠЉYъŠЊYыŠЋYэŠЌYюŠ­YяŠЎY№ŠЏYёŠАYђŠБYѓŠВYєŠГYѕŠДYіŠЕYїŠЖYјŠЗYњŠИYќŠЙY§ŠКYўŠЛZŠМZŠНZ ŠОZ ŠПZ ŠРZŠСZŠТZŠУZŠФZŠХZŠЦZŠЧZŠШZŠЩZŠЪZŠЫZŠЬZŠЭZ!ŠЮZ"ŠЯZ$ŠаZ&ŠбZ'ŠвZ(ŠгZ*ŠдZ+ŠеZ,ŠжZ-ŠзZ.ŠиZ/ŠйZ0ŠкZ3ŠлZ5ŠмZ7ŠнZ8ŠоZ9ŠпZ:ŠрZ;ŠсZ=ŠтZ>ŠуZ?ŠфZAŠхZBŠцZCŠчZDŠшZEŠщZGŠъZHŠыZKŠьZLŠэZMŠюZNŠяZOŠ№ZPŠёZQŠђZRŠѓZSŠєZTŠѕZVŠіZWŠїZXŠјZYŠљZ[ŠњZ\ŠћZ]ŠќZ^Š§Z_ŠўZ`‹@Za‹AZc‹BZd‹CZe‹DZf‹EZh‹FZi‹GZk‹HZl‹IZm‹JZn‹KZo‹LZp‹MZq‹NZr‹OZs‹PZx‹QZy‹RZ{‹SZ|‹TZ}‹UZ~‹VZ€‹WZ‹XZ‚‹YZƒ‹ZZ„‹[Z…‹\Z†‹]Z‡‹^Zˆ‹_Z‰‹`ZŠ‹aZ‹‹bZŒ‹cZ‹dZŽ‹eZ‹fZ‹gZ‘‹hZ“‹iZ”‹jZ•‹kZ–‹lZ—‹mZ˜‹nZ™‹oZœ‹pZ‹qZž‹rZŸ‹sZ ‹tZЁ‹uZЂ‹vZЃ‹wZЄ‹xZЅ‹yZІ‹zZЇ‹{ZЈ‹|ZЉ‹}ZЋ‹~ZЌ‹€Z­‹ZЎ‹‚ZЏ‹ƒZА‹„ZБ‹…ZД‹†ZЖ‹‡ZЗ‹ˆZЙ‹‰ZК‹ŠZЛ‹‹ZМ‹ŒZН‹ZП‹ŽZР‹ZУ‹ZФ‹‘ZХ‹’ZЦ‹“ZЧ‹”ZШ‹•ZЪ‹–ZЫ‹—ZЭ‹˜ZЮ‹™ZЯ‹šZа‹›Zб‹œZг‹Zе‹žZз‹ŸZй‹ Zк‹ЁZл‹ЂZн‹ЃZо‹ЄZп‹ЅZт‹ІZф‹ЇZх‹ЈZч‹ЉZш‹ЊZъ‹ЋZь‹ЌZэ‹­Zю‹ЎZя‹ЏZ№‹АZђ‹БZѓ‹ВZє‹ГZѕ‹ДZі‹ЕZї‹ЖZј‹ЗZљ‹ИZњ‹ЙZћ‹КZќ‹ЛZ§‹МZў‹НZџ‹О[‹П[‹Р[‹С[‹Т[‹У[‹Ф[‹Х[‹Ц[‹Ч[ ‹Ш[ ‹Щ[ ‹Ъ[ ‹Ы[‹Ь[‹Э[‹Ю[‹Я[‹а[‹б[‹в[‹г[‹д[‹е[‹ж[‹з[‹и[‹й[‹к[‹л[ ‹м[!‹н["‹о[#‹п[$‹р[%‹с[&‹т['‹у[(‹ф[)‹х[*‹ц[+‹ч[,‹ш[-‹щ[.‹ъ[/‹ы[0‹ь[1‹э[3‹ю[5‹я[6‹№[8‹ё[9‹ђ[:‹ѓ[;‹є[<‹ѕ[=‹і[>‹ї[?‹ј[A‹љ[B‹њ[C‹ћ[D‹ќ[E‹§[F‹ў[GŒ@[HŒA[IŒB[JŒC[KŒD[LŒE[MŒF[NŒG[OŒH[RŒI[VŒJ[^ŒK[`ŒL[aŒM[gŒN[hŒO[kŒP[mŒQ[nŒR[oŒS[rŒT[tŒU[vŒV[wŒW[xŒX[yŒY[{ŒZ[|Œ[[~Œ\[Œ][‚Œ^[†Œ_[ŠŒ`[Œa[ŽŒb[Œc[‘Œd[’Œe[”Œf[–Œg[ŸŒh[ЇŒi[ЈŒj[ЉŒk[ЌŒl[­Œm[ЎŒn[ЏŒo[БŒp[ВŒq[ЗŒr[КŒs[ЛŒt[МŒu[РŒv[СŒw[УŒx[ШŒy[ЩŒz[ЪŒ{[ЫŒ|[ЭŒ}[ЮŒ~[ЯŒ€[бŒ[дŒ‚[еŒƒ[жŒ„[зŒ…[иŒ†[йŒ‡[кŒˆ[лŒ‰[мŒŠ[рŒ‹[тŒŒ[уŒ[цŒŽ[чŒ[щŒ[ъŒ‘[ыŒ’[ьŒ“[эŒ”[яŒ•[ёŒ–[ђŒ—[ѓŒ˜[єŒ™[ѕŒš[іŒ›[їŒœ[§Œ[ўŒž\ŒŸ\Œ \ŒЁ\ŒЂ\ŒЃ\ŒЄ\ ŒЅ\ ŒІ\ ŒЇ\ŒЈ\ŒЉ\ŒЊ\ŒЋ\ŒЌ\Œ­\ŒЎ\ŒЏ\ŒА\ ŒБ\!ŒВ\#ŒГ\&ŒД\(ŒЕ\)ŒЖ\*ŒЗ\+ŒИ\-ŒЙ\.ŒК\/ŒЛ\0ŒМ\2ŒН\3ŒО\5ŒП\6ŒР\7ŒС\CŒТ\DŒУ\FŒФ\GŒХ\LŒЦ\MŒЧ\RŒШ\SŒЩ\TŒЪ\VŒЫ\WŒЬ\XŒЭ\ZŒЮ\[ŒЯ\\Œа\]Œб\_Œв\bŒг\dŒд\gŒе\hŒж\iŒз\jŒи\kŒй\lŒк\mŒл\pŒм\rŒн\sŒо\tŒп\uŒр\vŒс\wŒт\xŒу\{Œф\|Œх\}Œц\~Œч\€Œш\ƒŒщ\„Œъ\…Œы\†Œь\‡Œэ\‰Œю\ŠŒя\‹Œ№\ŽŒё\Œђ\’Œѓ\“Œє\•Œѕ\Œі\žŒї\ŸŒј\ Œљ\ЁŒњ\ЄŒћ\ЅŒќ\ІŒ§\ЇŒў\Ј@\ЊA\ЎB\ЏC\АD\ВE\ДF\ЖG\ЙH\КI\ЛJ\МK\ОL\РM\ТN\УO\ХP\ЦQ\ЧR\ШS\ЩT\ЪU\ЬV\ЭW\ЮX\ЯY\аZ\б[\г\\д]\е^\ж_\з`\иa\кb\лc\мd\нe\оf\пg\рh\тi\уj\чk\щl\ыm\ьn\юo\яp\ёq\ђr\ѓs\єt\ѕu\іv\їw\јx\љy\њz\ќ{\§|\ў}\џ~]€]]‚]ƒ]„] …] †] ‡] ˆ] ‰]Š]‹]Œ]]Ž]]]‘]’]“]”]•]–] —]!˜]"™]#š]%›](œ]*]+ž],Ÿ]/ ]0Ё]1Ђ]2Ѓ]3Є]5Ѕ]6І]7Ї]8Ј]9Љ]:Њ];Ћ]<Ќ]?­]@Ў]AЏ]BА]CБ]DВ]EГ]FД]HЕ]IЖ]MЗ]NИ]OЙ]PК]QЛ]RМ]SН]TО]UП]VР]WС]YТ]ZУ]\Ф]^Х]_Ц]`Ч]aШ]bЩ]cЪ]dЫ]eЬ]fЭ]gЮ]hЯ]jа]mб]nв]pг]qд]rе]sж]uз]vи]wй]xк]yл]zм]{н]|о]}п]~р]с]€т]у]ƒф]„х]…ц]†ч]‡ш]ˆщ]‰ъ]Šы]‹ь]Œэ]ю]Žя]№]ё]‘ђ]’ѓ]“є]”ѕ]•і]–ї]—ј]˜љ]šњ]›ћ]œќ]ž§]Ÿў] Ž@]ЁŽA]ЂŽB]ЃŽC]ЄŽD]ЅŽE]ІŽF]ЇŽG]ЈŽH]ЉŽI]ЊŽJ]ЋŽK]ЌŽL]­ŽM]ЎŽN]ЏŽO]АŽP]БŽQ]ВŽR]ГŽS]ДŽT]ЕŽU]ЖŽV]ИŽW]ЙŽX]КŽY]ЛŽZ]МŽ[]НŽ\]ОŽ]]ПŽ^]РŽ_]СŽ`]ТŽa]УŽb]ФŽc]ЦŽd]ЧŽe]ШŽf]ЩŽg]ЪŽh]ЫŽi]ЬŽj]ЮŽk]ЯŽl]аŽm]бŽn]вŽo]гŽp]дŽq]еŽr]жŽs]зŽt]иŽu]йŽv]кŽw]мŽx]пŽy]рŽz]уŽ{]фŽ|]ъŽ}]ьŽ~]эŽ€]№Ž]ѕŽ‚]іŽƒ]јŽ„]љŽ…]њŽ†]ћŽ‡]ќŽˆ]џŽ‰^ŽŠ^Ž‹^ŽŒ^ Ž^ ŽŽ^ Ž^ Ž^Ž‘^Ž’^Ž“^Ž”^Ž•^Ž–^ Ž—^!Ž˜^"Ž™^#Žš^$Ž›^%Žœ^(Ž^)Žž^*ŽŸ^+Ž ^,ŽЁ^/ŽЂ^0ŽЃ^2ŽЄ^3ŽЅ^4ŽІ^5ŽЇ^6ŽЈ^9ŽЉ^:ŽЊ^>ŽЋ^?ŽЌ^@Ž­^AŽЎ^CŽЏ^FŽА^GŽБ^HŽВ^IŽГ^JŽД^KŽЕ^MŽЖ^NŽЗ^OŽИ^PŽЙ^QŽК^RŽЛ^SŽМ^VŽН^WŽО^XŽП^YŽР^ZŽС^\ŽТ^]ŽУ^_ŽФ^`ŽХ^cŽЦ^dŽЧ^eŽШ^fŽЩ^gŽЪ^hŽЫ^iŽЬ^jŽЭ^kŽЮ^lŽЯ^mŽа^nŽб^oŽв^pŽг^qŽд^uŽе^wŽж^yŽз^~Žи^Žй^‚Žк^ƒŽл^…Žм^ˆŽн^‰Žо^ŒŽп^Žр^ŽŽс^’Žт^˜Žу^›Žф^Žх^ЁŽц^ЂŽч^ЃŽш^ЄŽщ^ЈŽъ^ЉŽы^ЊŽь^ЋŽэ^ЌŽю^ЎŽя^ЏŽ№^АŽё^БŽђ^ВŽѓ^ДŽє^КŽѕ^ЛŽі^МŽї^НŽј^ПŽљ^РŽњ^СŽћ^ТŽќ^УŽ§^ФŽў^Х@^ЦA^ЧB^ШC^ЫD^ЬE^ЭF^ЮG^ЯH^аI^дJ^еK^зL^иM^йN^кO^мP^нQ^оR^пS^рT^сU^тV^уW^фX^хY^цZ^ч[^щ\^ы]^ь^^э_^ю`^яa^№b^ёc^ђd^ѓe^ѕf^јg^љh^ћi^ќj^§k_l_m_n_ o_ p_ q_r_s_t_u_v_w_x_y_z_{_!|_"}_#~_$€_(_+‚_,ƒ_.„_0…_2†_3‡_4ˆ_5‰_6Š_7‹_8Œ_;_=Ž_>_?_A‘_B’_C“_D”_E•_F–_G—_H˜_I™_Jš_K›_Lœ_M_Nž_OŸ_Q _TЁ_YЂ_ZЃ_[Є_\Ѕ_^І__Ї_`Ј_cЉ_eЊ_gЋ_hЌ_k­_nЎ_oЏ_rА_tБ_uВ_vГ_xД_zЕ_}Ж_~З_И_ƒЙ_†К_Л_ŽМ_Н_‘О_“П_”Р_–С_šТ_›У_Ф_žХ_ŸЦ_ Ч_ЂШ_ЃЩ_ЄЪ_ЅЫ_ІЬ_ЇЭ_ЉЮ_ЋЯ_Ќа_Џб_Ав_Бг_Вд_Ге_Дж_Жз_Ии_Йй_Кк_Лл_Ом_Пн_Ро_Сп_Тр_Чс_Шт_Ъу_Ыф_Юх_гц_дч_еш_кщ_лъ_мы_оь_пэ_тю_уя_х№_цё_шђ_щѓ_ьє_яѕ_№і_ђї_ѓј_єљ_іњ_їћ_љќ_њ§_ќў`@`A` B` C` D`E`F`G`H`I`J`K`L`"M`#N`$O`,P`-Q`.R`0S`1T`2U`3V`4W`6X`7Y`8Z`9[`:\`=]`>^`@_`D``Ea`Fb`Gc`Hd`Ie`Jf`Lg`Nh`Oi`Qj`Sk`Tl`Vm`Wn`Xo`[p`\q`^r`_s``t`au`ev`fw`nx`qy`rz`t{`u|`w}`~~`€€``‚‚`…ƒ`†„`‡…`ˆ†`Š‡`‹ˆ`Ž‰`Š`‹`‘Œ`“`•Ž`—`˜`™‘`œ’`ž“`Ё”`Ђ•`Є–`Ѕ—`Ї˜`Љ™`Њš`Ў›`Аœ`Г`Еž`ЖŸ`З `ЙЁ`КЂ`НЃ`ОЄ`ПЅ`РІ`СЇ`ТЈ`УЉ`ФЊ`ЧЋ`ШЌ`Щ­`ЬЎ`ЭЏ`ЮА`ЯБ`аВ`вГ`гД`дЕ`жЖ`зЗ`йИ`лЙ`оК`сЛ`тМ`уН`фО`хП`ъР`ёС`ђТ`ѕУ`їФ`јХ`ћЦ`ќЧ`§Ш`ўЩ`џЪaЫaЬaЭaЮaЯa аa бa вaгaдaеaжaзaиaйaкaлaмaнaоaпa!рa"сa%тa(уa)фa*хa,цa-чa.шa/щa0ъa1ыa2ьa3эa4юa5яa6№a7ёa8ђa9ѓa:єa;ѕa<іa=їa>јa@љaAњaBћaCќaD§aEўaF‘@aG‘AaI‘BaK‘CaM‘DaO‘EaP‘FaR‘GaS‘HaT‘IaV‘JaW‘KaX‘LaY‘MaZ‘Na[‘Oa\‘Pa^‘Qa_‘Ra`‘Saa‘Tac‘Uad‘Vae‘Waf‘Xai‘Yaj‘Zak‘[al‘\am‘]an‘^ao‘_aq‘`ar‘aas‘bat‘cav‘dax‘eay‘faz‘ga{‘ha|‘ia}‘ja~‘ka‘la€‘ma‘na‚‘oaƒ‘pa„‘qa…‘ra†‘sa‡‘taˆ‘ua‰‘vaŠ‘waŒ‘xa‘ya‘za‘{a‘‘|a’‘}a“‘~a•‘€a–‘a—‘‚a˜‘ƒa™‘„aš‘…a›‘†aœ‘‡až‘ˆaŸ‘‰a ‘ŠaЁ‘‹aЂ‘ŒaЃ‘aЄ‘ŽaЅ‘aІ‘aЊ‘‘aЋ‘’a­‘“aЎ‘”aЏ‘•aА‘–aБ‘—aВ‘˜aГ‘™aД‘šaЕ‘›aЖ‘œaИ‘aЙ‘žaК‘ŸaЛ‘ aМ‘ЁaН‘ЂaП‘ЃaР‘ЄaС‘ЅaУ‘ІaФ‘ЇaХ‘ЈaЦ‘ЉaЧ‘ЊaЩ‘ЋaЬ‘ЌaЭ‘­aЮ‘ЎaЯ‘Џaа‘Аaг‘Бaе‘Вaж‘Гaз‘Дaи‘Еaй‘Жaк‘Зaл‘Иaм‘Йaн‘Кaо‘Лaп‘Мaр‘Нaс‘Оaт‘Пaу‘Рaф‘Сaх‘Тaч‘Уaш‘Фaщ‘Хaъ‘Цaы‘Чaь‘Шaэ‘Щaю‘Ъaя‘Ыa№‘Ьaё‘Эaђ‘Юaѓ‘Яaє‘аaі‘бaї‘вaј‘гaљ‘дaњ‘еaћ‘жaќ‘зa§‘иaў‘йb‘кb‘лb‘мb‘нb‘оb‘пb‘рb ‘сb‘тb‘уb‘фb‘хb‘цb‘чb ‘шb#‘щb&‘ъb'‘ыb(‘ьb)‘эb+‘юb-‘яb/‘№b0‘ёb1‘ђb2‘ѓb5‘єb6‘ѕb8‘іb9‘їb:‘јb;‘љb<‘њbB‘ћbD‘ќbE‘§bF‘ўbJ’@bO’AbP’BbU’CbV’DbW’EbY’FbZ’Gb\’Hb]’Ib^’Jb_’Kb`’Lba’Mbb’Nbd’Obe’Pbh’Qbq’Rbr’Sbt’Tbu’Ubw’Vbx’Wbz’Xb{’Yb}’Zb’[b‚’\bƒ’]b…’^b†’_b‡’`bˆ’ab‹’bbŒ’cb’dbŽ’eb’fb’gb”’hb™’ibœ’jb’kbž’lbЃ’mbІ’nbЇ’obЉ’pbЊ’qb­’rbЎ’sbЏ’tbА’ubВ’vbГ’wbД’xbЖ’ybЗ’zbИ’{bК’|bО’}bР’~bС’€bУ’bЫ’‚bЯ’ƒbб’„bе’…bн’†bо’‡bр’ˆbс’‰bф’Šbъ’‹bы’Œb№’bђ’Žbѕ’bј’bљ’‘bњ’’bћ’“c’”c’•c’–c’—c’˜c ’™c ’šc ’›c ’œc’c’žc’Ÿc’ c’Ёc’Ђc’Ѓc’Єc’Ѕc’Іc&’Їc'’Јc)’Љc,’Њc-’Ћc.’Ќc0’­c1’Ўc3’Џc4’Аc5’Бc6’Вc7’Гc8’Дc;’Еc<’Жc>’Зc?’Иc@’ЙcA’КcD’ЛcG’МcH’НcJ’ОcQ’ПcR’РcS’СcT’ТcV’УcW’ФcX’ХcY’ЦcZ’Чc[’Шc\’Щc]’Ъc`’Ыcd’Ьce’Эcf’Юch’Яcj’аck’бcl’вco’гcp’дcr’еcs’жct’зcu’иcx’йcy’кc|’лc}’мc~’нc’оc’пcƒ’рc„’сc…’тc†’уc‹’фc’хc‘’цc“’чc”’шc•’щc—’ъc™’ыcš’ьc›’эcœ’юc’яcž’№cŸ’ёcЁ’ђcЄ’ѓcІ’єcЋ’ѕcЏ’іcБ’їcВ’јcЕ’љcЖ’њcЙ’ћcЛ’ќcН’§cП’ўcР“@cС“AcТ“BcУ“CcХ“DcЧ“EcШ“FcЪ“GcЫ“HcЬ“Icб“Jcг“Kcд“Lcе“Mcз“Ncи“Ocй“Pcк“Qcл“Rcм“Scн“Tcп“Ucт“Vcф“Wcх“Xcц“Ycч“Zcш“[cы“\cь“]cю“^cя“_c№“`cё“acѓ“bcѕ“ccї“dcљ“ecњ“fcћ“gcќ“hcў“id“jd“kd“ld“md“nd “od “pd “qd“rd“sd“td“ud“vd“wd“xd“yd“zd“{d“|d"“}d#“~d$“€d%“d'“‚d(“ƒd)“„d+“…d.“†d/“‡d0“ˆd1“‰d2“Šd3“‹d5“Œd6“d7“Žd8“d9“d;“‘d<“’d>““d@“”dB“•dC“–dI“—dK“˜dL“™dM“šdN“›dO“œdP“dQ“ždS“ŸdU“ dV“ЁdW“ЂdY“ЃdZ“Єd[“Ѕd\“Іd]“Їd_“Јd`“Љda“Њdb“Ћdc“Ќdd“­de“Ўdf“Џdh“Аdj“Бdk“Вdl“Гdn“Дdo“Еdp“Жdq“Зdr“Иds“Йdt“Кdu“Лdv“Мdw“Нd{“Оd|“Пd}“Рd~“Сd“Тd€“Уd“Фdƒ“Хd†“Цdˆ“Чd‰“ШdŠ“Щd‹“ЪdŒ“Ыd“ЬdŽ“Эd“Юd“Яd““аd”“бd—“вd˜“гdš“дd›“еdœ“жd“зdŸ“иd “йdЁ“кdЂ“лdЃ“мdЅ“нdІ“оdЇ“пdЈ“рdЊ“сdЋ“тdЏ“уdБ“фdВ“хdГ“цdД“чdЖ“шdЙ“щdЛ“ъdН“ыdО“ьdП“эdС“юdУ“яdФ“№dЦ“ёdЧ“ђdШ“ѓdЩ“єdЪ“ѕdЫ“іdЬ“їdЯ“јdб“љdг“њdд“ћdе“ќd擧dй“ўdк”@dл”Adм”Bdн”Cdп”Ddр”Edс”Fdу”Gdх”Hdч”Idш”Jdщ”Kdъ”Ldы”Mdь”Ndэ”Odю”Pdя”Qd№”Rdё”Sdђ”Tdѓ”Udє”Vdѕ”Wdі”Xdї”Ydј”Zdљ”[dњ”\dћ”]dќ”^d§”_dў”`dџ”ae”be”ce”de”ee”fe”ge”he”ie ”je ”ke ”le ”me”ne”oe”pe”qe”re”se”te”ue”ve”we”xe”ye”ze”{e”|e”}e ”~e!”€e"”e#”‚e$”ƒe&”„e'”…e(”†e)”‡e*”ˆe,”‰e-”Še0”‹e1”Œe2”e3”Že7”e:”e<”‘e=”’e@”“eA””eB”•eC”–eD”—eF”˜eG”™eJ”šeK”›eM”œeN”eP”žeR”ŸeS” eT”ЁeW”ЂeX”ЃeZ”Єe\”Ѕe_”Іe`”Їea”Јed”Љee”Њeg”Ћeh”Ќei”­ej”Ўem”Џen”Аeo”Бeq”Вes”Гeu”Дev”Еex”Жey”Зez”Иe{”Йe|”Кe}”Лe~”Мe”Нe€”Оe”Пe‚”Рeƒ”Сe„”Тe…”Уe†”Фeˆ”Хe‰”ЦeŠ”Чe”ШeŽ”Щe”Ъe’”Ыe””Ьe•”Эe–”Юe˜”Яeš”аe”бež”вe ”гeЂ”дeЃ”еeІ”жeЈ”зeЊ”иeЌ”йeЎ”кeБ”лeВ”мeГ”нeД”оeЕ”пeЖ”рeЗ”сeИ”тeК”уeЛ”фeО”хeП”цeР”чeТ”шeЧ”щeШ”ъeЩ”ыeЪ”ьeЭ”эeа”юeб”яeг”№eд”ёeе”ђeи”ѓeй”єeк”ѕeл”іeм”їeн”јeо”љeп”њeс”ћeу”ќeф”§eъ”ўeы•@eђ•Aeѓ•Beє•Ceѕ•Deј•Eeљ•Feћ•Geќ•He§•Ieў•Jeџ•Kf•Lf•Mf•Nf•Of•Pf •Qf •Rf •Sf•Tf•Uf•Vf•Wf•Xf•Yf•Zf•[f•\f•]f!•^f"•_f#•`f$•af&•bf)•cf*•df+•ef,•ff.•gf0•hf2•if3•jf7•kf8•lf9•mf:•nf;•of=•pf?•qf@•rfB•sfD•tfE•ufF•vfG•wfH•xfI•yfJ•zfM•{fN•|fP•}fQ•~fX•€fY•f[•‚f\•ƒf]•„f^•…f`•†fb•‡fc•ˆfe•‰fg•Šfi•‹fj•Œfk•fl•Žfm•fq•fr•‘fs•’fu•“fx•”fy••f{•–f|•—f}•˜f•™f€•šf•›fƒ•œf…•f†•žfˆ•Ÿf‰• fŠ•Ёf‹•Ђf•ЃfŽ•Єf•Ѕf•Іf’•Їf“•Јf”•Љf••Њf˜•Ћf™•Ќfš•­f›•Ўfœ•Џfž•АfŸ•Бf •ВfЁ•ГfЂ•ДfЃ•ЕfЄ•ЖfЅ•ЗfІ•ИfЉ•ЙfЊ•КfЋ•ЛfЌ•Мf­•НfЏ•ОfА•ПfБ•РfВ•СfГ•ТfЕ•УfЖ•ФfЗ•ХfИ•ЦfК•ЧfЛ•ШfМ•ЩfН•ЪfП•ЫfР•ЬfС•ЭfТ•ЮfУ•ЯfФ•аfХ•бfЦ•вfЧ•гfШ•дfЩ•еfЪ•жfЫ•зfЬ•иfЭ•йfЮ•кfЯ•лfа•мfб•нfв•оfг•пfд•рfе•сfж•тfз•уfи•фfк•хfо•цfп•чfр•шfс•щfт•ъfу•ыfф•ьfх•эfч•юfш•яfъ•№fы•ёfь•ђfэ•ѓfю•єfя•ѕfё•іfѕ•їfі•јfј•љfњ•њfћ•ћf§•ќg•§g•ўg–@g–Ag–Bg–Cg–Dg –Eg–Fg–Gg–Hg–Ig–Jg–Kg–Lg–Mg–Ng–Og–Pg –Qg!–Rg"–Sg#–Tg$–Ug%–Vg'–Wg)–Xg.–Yg0–Zg2–[g3–\g6–]g7–^g8–_g9–`g;–ag<–bg>–cg?–dgA–egD–fgE–ggG–hgJ–igK–jgM–kgR–lgT–mgU–ngW–ogX–pgY–qgZ–rg[–sg]–tgb–ugc–vgd–wgf–xgg–ygk–zgl–{gn–|gq–}gt–~gv–€gx–gy–‚gz–ƒg{–„g}–…g€–†g‚–‡gƒ–ˆg…–‰g†–Šgˆ–‹gŠ–ŒgŒ–g–ŽgŽ–g–g‘–‘g’–’g“–“g”–”g––•g™––g›–—gŸ–˜g –™gЁ–šgЄ–›gІ–œgЉ–gЌ–žgЎ–ŸgБ– gВ–ЁgД–ЂgЙ–ЃgК–ЄgЛ–ЅgМ–ІgН–ЇgО–ЈgП–ЉgР–ЊgТ–ЋgХ–ЌgЦ–­gЧ–ЎgШ–ЏgЩ–АgЪ–БgЫ–ВgЬ–ГgЭ–ДgЮ–Еgе–Жgж–Зgз–Иgл–Йgп–Кgс–Лgу–Мgф–Нgц–Оgч–Пgш–Рgъ–Сgы–Тgэ–Уgю–Фgђ–Хgѕ–Цgі–Чgї–Шgј–Щgљ–Ъgњ–Ыgћ–Ьgќ–Эgў–Юh–Яh–аh–бh–вh–гh –дh–еh–жh–зh–иh–йh–кh–лh–мh–нh–оh–пh –рh"–сh#–тh$–уh%–фh&–хh'–цh(–чh+–шh,–щh-–ъh.–ыh/–ьh0–эh1–юh4–яh5–№h6–ёh:–ђh;–ѓh?–єhG–ѕhK–іhM–їhO–јhR–љhV–њhW–ћhX–ќhY–§hZ–ўh[—@h\—Ah]—Bh^—Ch_—Dhj—Ehl—Fhm—Ghn—Hho—Ihp—Jhq—Khr—Lhs—Mhu—Nhx—Ohy—Phz—Qh{—Rh|—Sh}—Th~—Uh—Vh€—Wh‚—Xh„—Yh‡—Zhˆ—[h‰—\hŠ—]h‹—^hŒ—_h—`hŽ—ah—bh‘—ch’—dh”—eh•—fh–—gh˜—hh™—ihš—jh›—khœ—lh—mhž—nhŸ—oh —phЁ—qhЃ—rhЄ—shЅ—thЉ—uhЊ—vhЋ—whЌ—xhЎ—yhБ—zhВ—{hД—|hЖ—}hЗ—~hИ—€hЙ—hК—‚hЛ—ƒhМ—„hН—…hО—†hП—‡hС—ˆhУ—‰hФ—ŠhХ—‹hЦ—ŒhЧ—hШ—ŽhЪ—hЬ—hЮ—‘hЯ—’hа—“hб—”hг—•hд—–hж——hз—˜hй—™hл—šhм—›hн—œhо—hп—žhс—Ÿhт— hф—Ёhх—Ђhц—Ѓhч—Єhш—Ѕhщ—Іhъ—Їhы—Јhь—Љhэ—Њhя—Ћhђ—Ќhѓ—­hє—Ўhі—Џhї—Аhј—Бhћ—Вh§—Гhў—Дhџ—Еi—Жi—Зi—Иi—Йi—Кi—Лi—Мi —Нi —Оi —Пi—Рi—Сi—Тi—Уi—Фi—Хi—Цi—Чi—Шi—Щi—Ъi—Ыi—Ьi—Эi!—Юi"—Яi#—аi%—бi&—вi'—гi(—дi)—еi*—жi+—зi,—иi.—йi/—кi1—лi2—мi3—нi5—оi6—пi7—рi8—сi:—тi;—уi<—фi>—хi@—цiA—чiC—шiD—щiE—ъiF—ыiG—ьiH—эiI—юiJ—яiK—№iL—ёiM—ђiN—ѓiO—єiP—ѕiQ—іiR—їiS—јiU—љiV—њiX—ћiY—ќi[—§i\—ўi_˜@ia˜Aib˜Bid˜Cie˜Dig˜Eih˜Fii˜Gij˜Hil˜Iim˜Jio˜Kip˜Lir˜Mis˜Nit˜Oiu˜Piv˜Qiz˜Ri{˜Si}˜Ti~˜Ui˜Vi˜Wiƒ˜Xi…˜YiŠ˜Zi‹˜[iŒ˜\iŽ˜]i˜^i˜_i‘˜`i’˜ai“˜bi–˜ci—˜di™˜eiš˜fi˜giž˜hiŸ˜ii ˜jiЁ˜kiЂ˜liЃ˜miЄ˜niЅ˜oiІ˜piЉ˜qiЊ˜riЌ˜siЎ˜tiЏ˜uiА˜vi˜wiØxiŘyiƘziȘ{iɘ|iʘ}i̘~i͘€iȁiϘ‚iИƒiҘ„iӘ…iԘ†i՘‡i֘ˆiט‰iؘŠi٘‹iۘŒiݘiߘŽiб˜iв˜iг˜‘iе˜’iж˜“iз˜”iи˜•iй˜–iк˜—i옘iн˜™iо˜šiс˜›iт˜œiу˜iф˜žiх˜Ÿiц˜ iч˜Ёiш˜Ђiщ˜Ѓiъ˜Єiы˜Ѕiь˜Іiю˜Їiя˜Јi№˜Љiё˜Њiѓ˜Ћiє˜Ќiѕ˜­iі˜Ўiї˜Џiј˜Аiљ˜Бiњ˜Вiћ˜Гiќ˜Дiў˜Еj˜Жj˜Зj˜Иj˜Йj˜Кj˜Лj˜Мj˜Нj˜Оj ˜Пj ˜Рj ˜Сj ˜Тj˜Уj˜Фj˜Хj˜Цj˜Чj˜Шj˜Щj˜Ъj˜Ыj˜Ьj˜Эj˜Юj˜Яj˜аj˜бj ˜вj"˜гj#˜дj$˜еj%˜жj&˜зj'˜иj)˜йj+˜кj,˜лj-˜мj.˜нj0˜оj2˜пj3˜рj4˜сj6˜тj7˜уj8˜фj9˜хj:˜цj;˜чj<˜шj?˜щj@˜ъjA˜ыjB˜ьjC˜эjE˜юjF˜яjH˜№jI˜ёjJ˜ђjK˜ѓjL˜єjM˜ѕjN˜іjO˜їjQ˜јjR˜љjS˜њjT˜ћjU˜ќjV˜§jW˜ўjZ™@j\™Aj]™Bj^™Cj_™Dj`™Ejb™Fjc™Gjd™Hjf™Ijg™Jjh™Kji™Ljj™Mjk™Njl™Ojm™Pjn™Qjo™Rjp™Sjr™Tjs™Ujt™Vju™Wjv™Xjw™Yjx™Zjz™[j{™\j}™]j~™^j™_j™`j‚™ajƒ™bj…™cj†™dj‡™ejˆ™fj‰™gjŠ™hj‹™ijŒ™jj™kj™lj’™mj“™nj”™oj•™pj–™qj˜™rj™™sjš™tj›™ujœ™vj™wjž™xjŸ™yjЁ™zjЂ™{jЃ™|jЄ™}jЅ™~jІ™€jЇ™jЈ™‚jЊ™ƒj­™„jЎ™…jЏ™†jА™‡jБ™ˆjВ™‰jГ™ŠjД™‹jЕ™ŒjЖ™jЗ™ŽjИ™jЙ™jК™‘jЛ™’jМ™“jН™”jО™•jП™–jР™—jС™˜jТ™™jУ™šjФ™›jХ™œjЦ™jЧ™žjШ™ŸjЩ™ jЪ™ЁjЫ™ЂjЬ™ЃjЭ™ЄjЮ™ЅjЯ™Іjа™Їjб™Јjв™Љjг™Њjд™Ћjе™Ќjж™­jз™Ўjи™Џjй™Аjк™Бjл™Вjм™Гjн™Дjо™Еjп™Жjр™Зjс™Иjт™Йjу™Кjф™Лjх™Мjц™Нjч™Оjш™Пjщ™Рjъ™Сjы™Тjь™Уjэ™Фjю™Хjя™Цj№™Чjё™Шjђ™Щjѓ™Ъjє™Ыjѕ™Ьjі™Эjї™Юjј™Яjљ™аjњ™бjћ™вjќ™гj§™дjў™еjџ™жk™зk™иk™йk™кk™лk™мk™нk™оk™пk ™рk ™сk ™тk ™уk ™фk™хk™цk™чk™шk™щk™ъk™ыk™ьk™эk™юk™яk™№k™ёk™ђk™ѓk™єk™ѕk™іk%™їk&™јk(™љk)™њk*™ћk+™ќk,™§k-™ўk.š@k/šAk0šBk1šCk3šDk4šEk5šFk6šGk8šHk;šIk<šJk=šKk?šLk@šMkAšNkBšOkDšPkEšQkHšRkJšSkKšTkMšUkNšVkOšWkPšXkQšYkRšZkSš[kTš\kUš]kVš^kWš_kXš`kZšak[šbk\šck]šdk^šek_šfk`šgkašhkhšikišjkkškklšlkmšmknšnkošokpšpkqšqkršrksšsktštkušukvšvkwšwkxšxkzšyk}šzk~š{kš|k€š}k…š~kˆš€kŒškŽš‚kšƒkš„k‘š…k”š†k•š‡k—šˆk˜š‰k™šŠkœš‹kšŒkžškŸšŽk škЂškЃš‘kЄš’kЅš“kІš”kЇš•kЈš–kЉš—kЋš˜kЌš™k­šškЎš›kЏšœkАškБšžkВšŸkЖš kИšЁkЙšЂkКšЃkЛšЄkМšЅkНšІkОšЇkРšЈkУšЉkФšЊkЦšЋkЧšЌkШš­kЩšЎkЪšЏkЬšАkЮšБkаšВkбšГkиšДkкšЕkмšЖkнšЗkоšИkпšЙkрšКkтšЛkуšМkфšНkхšОkцšПkчšРkшšСkщšТkьšУkэšФkюšХk№šЦkёšЧkђšШkєšЩkіšЪkїšЫkјšЬkњšЭkћšЮkќšЯkўšаkџšбlšвlšгlšдlšеlšжlšзl šиl šйl šкl šлlšмlšнlšоlšпlšрlšсl šтl#šуl%šфl+šхl,šцl-šчl1šшl3šщl6šъl7šыl9šьl:šэl;šюl<šяl>š№l?šёlCšђlDšѓlEšєlHšѕlKšіlLšїlMšјlNšљlOšњlQšћlRšќlSš§lVšўlX›@lY›AlZ›Blb›Clc›Dle›Elf›Flg›Glk›Hll›Ilm›Jln›Klo›Llq›Mls›Nlu›Olw›Plx›Qlz›Rl{›Sl|›Tl›Ul€›Vl„›Wl‡›XlŠ›Yl‹›Zl›[lŽ›\l‘›]l’›^l•›_l–›`l—›al˜›blš›clœ›dl›elž›fl ›glЂ›hlЈ›ilЌ›jlЏ›klА›llД›mlЕ›nlЖ›olЗ›plК›qlР›rlС›slТ›tlУ›ulЦ›vlЧ›wlШ›xlЫ›ylЭ›zlЮ›{lЯ›|lб›}lв›~l蛈lй›lк›‚lм›ƒlн›„lп›…lф›†lц›‡lч›ˆlщ›‰lь›Šlэ›‹lђ›Œlє›lљ›Žlџ›m›m›‘m›’m›“m›”m›•m ›–m ›—m ›˜m›™m›šm››m›œm›m›žm›Ÿm› m›Ёm›Ђm›Ѓm ›Єm!›Ѕm"›Іm#›Їm$›Јm&›Љm(›Њm)›Ћm,›Ќm-›­m/›Ўm0›Џm4›Аm6›Бm7›Вm8›Гm:›Дm?›Еm@›ЖmB›ЗmD›ИmI›ЙmL›КmP›ЛmU›МmV›НmW›ОmX›Пm[›Рm]›Сm_›Тma›Уmb›Фmd›Хme›Цmg›Чmh›Шmk›Щml›Ъmm›Ыmp›Ьmq›Эmr›Юms›Яmu›аmv›бmy›вmz›гm{›дm}›еm~›жm›зm€›иm›йmƒ›кm„›лm†›мm‡›нmŠ›оm‹›пm›рm›сm›тm’›уm–›фm—›хm˜›цm™›чmš›шmœ›щmЂ›ъmЅ›ыmЌ›ьm­›эmА›юmБ›яmГ›№mД›ёmЖ›ђmЗ›ѓmЙ›єmК›ѕmЛ›іmМ›їmН›јmО›љmС›њmТ›ћmУ›ќmШ›§mЩ›ўmЪœ@mЭœAmЮœBmЯœCmаœDmвœEmгœFmдœGmеœHmзœImкœJmлœKmмœLmпœMmтœNmуœOmхœPmчœQmшœRmщœSmъœTmэœUmяœVm№œWmђœXmєœYmѕœZmіœ[mјœ\mњœ]m§œ^mўœ_mџœ`nœanœbnœcnœdnœenœfnœgnœhn œin œjnœknœlnœmnœnnœonœpnœqnœrnœsnœtn"œun&œvn'œwn(œxn*œyn,œzn.œ{n0œ|n1œ}n3œ~n5œ€n6œn7œ‚n9œƒn;œ„n<œ…n=œ†n>œ‡n?œˆn@œ‰nAœŠnBœ‹nEœŒnFœnGœŽnHœnIœnJœ‘nKœ’nLœ“nOœ”nPœ•nQœ–nRœ—nUœ˜nWœ™nYœšnZœ›n\œœn]œn^œžn`œŸnaœ nbœЁncœЂndœЃneœЄnfœЅngœІnhœЇniœЈnjœЉnlœЊnmœЋnoœЌnpœ­nqœЎnrœЏnsœАntœБnuœВnvœГnwœДnxœЕnyœЖnzœЗn{œИn|œЙn}œКn€œЛnœМn‚œНn„œОn‡œПnˆœРnŠœСn‹œТnŒœУnœФnŽœХn‘œЦn’œЧn“œШn”œЩn•œЪn–œЫn—œЬn™œЭnšœЮn›œЯnœаnžœбn œвnЁœгnЃœдnЄœеnІœжnЈœзnЉœиnЋœйnЌœкn­œлnЎœмnАœнnГœоnЕœпnИœрnЙœсnМœтnОœуnПœфnРœхnУœцnФœчnХœшnЦœщnШœъnЩœыnЪœьnЬœэnЭœюnЮœяnаœ№nвœёnжœђnиœѓnйœєnлœѕnмœіnнœїnуœјnчœљnъœњnыœћnьœќnэœ§nюœўnя@n№AnёBnђCnѓDnѕEnіFnїGnјHnњInћJnќKn§LnўMnџNoOoPoQoRoSoToUo Vo Wo Xo YoZo[o\o]o^o_o`oaobocodoeofogo!ho"io#jo%ko&lo'mo(no,oo.po0qo2ro4so5to7uo8vo9wo:xo;yo<zo={o?|o@}oA~oB€oCoD‚oEƒoH„oI…oJ†oL‡oNˆoO‰oPŠoQ‹oRŒoSoTŽoUoVoW‘oY’oZ“o[”o]•o_–o`—oa˜oc™odšoe›ogœohoižojŸok olЁooЂopЃoqЄosЅouІovЇowЈoyЉo{Њo}Ћo~Ќo­o€ЎoЏo‚АoƒБo…Вo†Гo‡ДoŠЕo‹ЖoЗoИo‘Йo’Кo“Лo”Мo•Нo–Оo—Пo˜Рo™СošТo›УoФožХoŸЦo ЧoЂШoЃЩoЄЪoЅЫoІЬoЈЭoЉЮoЊЯoЋаoЌбo­вoЎгoЏдoАеoБжoВзoДиoЕйoЗкoИлoКмoЛнoМоoНпoОрoПсoСтoУуoФфoХхoЦцoЧчoШшoЪщoЫъoЬыoЭьoЮэoЯюoаяoг№oдёoеђoжѓoзєoиѕoйіoкїoлјoмљoнњoпћoтќoу§oфўoхž@oцžAoчžBoшžCoщžDoъžEoыžFoьžGoэžHo№žIoёžJoђžKoѓžLoєžMoѕžNoіžOoїžPoјžQoљžRoњžSoћžToќžUo§žVoўžWoџžXpžYpžZpž[pž\pž]pž^pž_pž`pžap žbp žcp ždp žep žfpžgpžhpžipžjpžkpžlpžmpžnpžopžppžqpžrpžspžtpžup žvp!žwp"žxp$žyp%žzp&ž{p'ž|p(ž}p)ž~p*ž€p+žp,ž‚p-žƒp.ž„p/ž…p0ž†p1ž‡p2žˆp3ž‰p4žŠp6ž‹p7žŒp8žp:žŽp;žp<žp=ž‘p>ž’p?ž“p@ž”pAž•pBž–pCž—pDž˜pEž™pFžšpGž›pHžœpIžpJžžpKžŸpMž pNžЁpPžЂpQžЃpRžЄpSžЅpTžІpUžЇpVžЈpWžЉpXžЊpYžЋpZžЌp[ž­p\žЎp]žЏp_žАp`žБpažВpbžГpcžДpdžЕpežЖpfžЗpgžИphžЙpižКpjžЛpnžМpqžНpržОpsžПptžРpwžСpyžТpzžУp{žФp}žХpžЦp‚žЧpƒžШp„žЩp†žЪp‡žЫpˆžЬp‹žЭpŒžЮpžЯpžаpžбp‘žвp“žгp—žдp˜žеpšžжp›žзpžžиpŸžйp žкpЁžлpЂžмpЃžнpЄžоpЅžпpІžрpЇžсpЈžтpЉžуpЊžфpАžхpВžцpДžчpЕžшpЖžщpКžъpОžыpПžьpФžэpХžюpЦžяpЧž№pЩžёpЫžђpЬžѓpЭžєpЮžѕpЯžіpаžїpбžјpвžљpгžњpдžћpеžќpжž§pзžўpкŸ@pмŸApнŸBpоŸCpрŸDpсŸEpтŸFpуŸGpхŸHpъŸIpюŸJp№ŸKpёŸLpђŸMpѓŸNpєŸOpѕŸPpіŸQpјŸRpњŸSpћŸTpќŸUpўŸVpџŸWqŸXqŸYqŸZqŸ[qŸ\qŸ]qŸ^qŸ_qŸ`q Ÿaq Ÿbq ŸcqŸdqŸeqŸfqŸgqŸhqŸiqŸjqŸkqŸlqŸmqŸnq Ÿoq!Ÿpq"Ÿqq#Ÿrq$Ÿsq%Ÿtq'Ÿuq(Ÿvq)Ÿwq*Ÿxq+Ÿyq,Ÿzq-Ÿ{q.Ÿ|q2Ÿ}q3Ÿ~q4Ÿ€q5Ÿq7Ÿ‚q8Ÿƒq9Ÿ„q:Ÿ…q;Ÿ†q<Ÿ‡q=Ÿˆq>Ÿ‰q?ŸŠq@Ÿ‹qAŸŒqBŸqCŸŽqDŸqFŸqGŸ‘qHŸ’qIŸ“qKŸ”qMŸ•qOŸ–qPŸ—qQŸ˜qRŸ™qSŸšqTŸ›qUŸœqVŸqWŸžqXŸŸqYŸ qZŸЁq[ŸЂq]ŸЃq_ŸЄq`ŸЅqaŸІqbŸЇqcŸЈqeŸЉqiŸЊqjŸЋqkŸЌqlŸ­qmŸЎqoŸЏqpŸАqqŸБqtŸВquŸГqvŸДqwŸЕqyŸЖq{ŸЗq|ŸИq~ŸЙqŸКq€ŸЛqŸМq‚ŸНqƒŸОq…ŸПq†ŸРq‡ŸСqˆŸТq‰ŸУq‹ŸФqŒŸХqŸЦqŽŸЧqŸШq‘ŸЩq’ŸЪq“ŸЫq•ŸЬq–ŸЭq—ŸЮqšŸЯq›ŸаqœŸбqŸвqžŸгqЁŸдqЂŸеqЃŸжqЄŸзqЅŸиqІŸйqЇŸкqЉŸлqЊŸмqЋŸнq­ŸоqЎŸпqЏŸрqАŸсqБŸтqВŸуqДŸфqЖŸхqЗŸцqИŸчqКŸшqЛŸщqМŸъqНŸыqОŸьqПŸэqРŸюqСŸяqТŸ№qФŸёqХŸђqЦŸѓqЧŸєqШŸѕqЩŸіqЪŸїqЫŸјqЬŸљqЭŸњqЯŸћqаŸќqбŸ§qвŸўqг @qж Aqз Bqи Cqй Dqк Eqл Fqм Gqн Hqо Iqп Jqс Kqт Lqу Mqф Nqц Oqш Pqщ Qqъ Rqы Sqь Tqэ Uqя Vq№ Wqё Xqђ Yqѓ Zqє [qѕ \qі ]qї ^qј _qњ `qћ aqќ bq§ cqў dqџ er fr gr hr ir jr kr lr mr  nr  or  pr  qr  rr sr tr ur vr wr xr yr zr {r |r }r ~r €r r ‚r ƒr „r  …r! †r" ‡r# ˆr$ ‰r% Šr& ‹r' Œr) r+ Žr- r. r/ ‘r2 ’r3 “r4 ”r: •r< –r> —r@ ˜rA ™rB šrC ›rD œrE rF žrI ŸrJ  rK ЁrN ЂrO ЃrP ЄrQ ЅrS ІrT ЇrU ЈrW ЉrX ЊrZ Ћr\ Ќr^ ­r` Ўrc Џrd Аre Бrh Вrj Гrk Дrl Еrm Жrp Зrq Иrs Йrt Кrv Лrw Мrx Нr{ Оr| Пr} Рr‚ Сrƒ Тr… Уr† Фr‡ Хrˆ Цr‰ ЧrŒ ШrŽ Щr Ъr‘ Ыr“ Ьr” Эr• Юr– Яr— аr˜ бr™ вrš гr› дrœ еr жrž зr  иrЁ йrЂ кrЃ лrЄ мrЅ нrІ оrЇ пrЈ рrЉ сrЊ тrЋ уrЎ фrБ хrВ цrГ чrЕ шrК щrЛ ъrМ ыrН ьrО эrП юrР яrХ №rЦ ёrЧ ђrЩ ѓrЪ єrЫ ѕrЬ іrЯ їrб јrг љrд њrе ћrж ќrи §rк ўrлЁЁ0ЁЂ0ЁЃ0ЁЄЗЁЅЩЁІЧЁЇЈЁЈ0ЁЉ0ЁЊ ЁЋџ^ЁЌ Ё­ &ЁЎ ЁЏ ЁА ЁБ ЁВ0ЁГ0ЁД0ЁЕ0 ЁЖ0 ЁЗ0 ЁИ0 ЁЙ0 ЁК0ЁЛ0ЁМ0ЁН0ЁО0ЁП0ЁРБЁСзЁТїЁУ"6ЁФ"'ЁХ"(ЁЦ"ЁЧ"ЁШ"*ЁЩ")ЁЪ"ЁЫ"7ЁЬ"ЁЭ"ЅЁЮ"%ЁЯ" Ёа#Ёб"™Ёв"+Ёг".Ёд"aЁе"LЁж"HЁз"=Ёи"Ёй"`Ёк"nЁл"oЁм"dЁн"eЁо"Ёп"5Ёр"4Ёс&BЁт&@ЁуАЁф 2Ёх 3Ёц!ЁчџЁшЄЁщџрЁъџсЁы 0ЁьЇЁэ!Ёю&Ёя&Ё№%ЫЁё%ЯЁђ%ЮЁѓ%ЧЁє%ЦЁѕ%ЁЁі% Ёї%ГЁј%ВЁљ ;Ёњ!’Ёћ!Ёќ!‘Ё§!“Ёў0ЂЁ!pЂЂ!qЂЃ!rЂЄ!sЂЅ!tЂІ!uЂЇ!vЂЈ!wЂЉ!xЂЊ!yЂБ$ˆЂВ$‰ЂГ$ŠЂД$‹ЂЕ$ŒЂЖ$ЂЗ$ŽЂИ$ЂЙ$ЂК$‘ЂЛ$’ЂМ$“ЂН$”ЂО$•ЂП$–ЂР$—ЂС$˜ЂТ$™ЂУ$šЂФ$›ЂХ$tЂЦ$uЂЧ$vЂШ$wЂЩ$xЂЪ$yЂЫ$zЂЬ${ЂЭ$|ЂЮ$}ЂЯ$~Ђа$Ђб$€Ђв$Ђг$‚Ђд$ƒЂе$„Ђж$…Ђз$†Ђи$‡Ђй$`Ђк$aЂл$bЂм$cЂн$dЂо$eЂп$fЂр$gЂс$hЂт$iЂх2 Ђц2!Ђч2"Ђш2#Ђщ2$Ђъ2%Ђы2&Ђь2'Ђэ2(Ђю2)Ђё!`Ђђ!aЂѓ!bЂє!cЂѕ!dЂі!eЂї!fЂј!gЂљ!hЂњ!iЂћ!jЂќ!kЃЁџЃЂџЃЃџЃЄџхЃЅџЃІџЃЇџЃЈџЃЉџ ЃЊџ ЃЋџ ЃЌџ Ѓ­џ ЃЎџЃЏџЃАџЃБџЃВџЃГџЃДџЃЕџЃЖџЃЗџЃИџЃЙџЃКџЃЛџЃМџЃНџЃОџЃПџЃРџ ЃСџ!ЃТџ"ЃУџ#ЃФџ$ЃХџ%ЃЦџ&ЃЧџ'ЃШџ(ЃЩџ)ЃЪџ*ЃЫџ+ЃЬџ,ЃЭџ-ЃЮџ.ЃЯџ/Ѓаџ0Ѓбџ1Ѓвџ2Ѓгџ3Ѓдџ4Ѓеџ5Ѓжџ6Ѓзџ7Ѓиџ8Ѓйџ9Ѓкџ:Ѓлџ;Ѓмџ<Ѓнџ=Ѓоџ>Ѓпџ?Ѓрџ@ЃсџAЃтџBЃуџCЃфџDЃхџEЃцџFЃчџGЃшџHЃщџIЃъџJЃыџKЃьџLЃэџMЃюџNЃяџOЃ№џPЃёџQЃђџRЃѓџSЃєџTЃѕџUЃіџVЃїџWЃјџXЃљџYЃњџZЃћџ[Ѓќџ\Ѓ§џ]ЃўџуЄЁ0AЄЂ0BЄЃ0CЄЄ0DЄЅ0EЄІ0FЄЇ0GЄЈ0HЄЉ0IЄЊ0JЄЋ0KЄЌ0LЄ­0MЄЎ0NЄЏ0OЄА0PЄБ0QЄВ0RЄГ0SЄД0TЄЕ0UЄЖ0VЄЗ0WЄИ0XЄЙ0YЄК0ZЄЛ0[ЄМ0\ЄН0]ЄО0^ЄП0_ЄР0`ЄС0aЄТ0bЄУ0cЄФ0dЄХ0eЄЦ0fЄЧ0gЄШ0hЄЩ0iЄЪ0jЄЫ0kЄЬ0lЄЭ0mЄЮ0nЄЯ0oЄа0pЄб0qЄв0rЄг0sЄд0tЄе0uЄж0vЄз0wЄи0xЄй0yЄк0zЄл0{Єм0|Єн0}Єо0~Єп0Єр0€Єс0Єт0‚Єу0ƒЄф0„Єх0…Єц0†Єч0‡Єш0ˆЄщ0‰Єъ0ŠЄы0‹Єь0ŒЄэ0Єю0ŽЄя0Є№0Єё0‘Єђ0’Єѓ0“ЅЁ0ЁЅЂ0ЂЅЃ0ЃЅЄ0ЄЅЅ0ЅЅІ0ІЅЇ0ЇЅЈ0ЈЅЉ0ЉЅЊ0ЊЅЋ0ЋЅЌ0ЌЅ­0­ЅЎ0ЎЅЏ0ЏЅА0АЅБ0БЅВ0ВЅГ0ГЅД0ДЅЕ0ЕЅЖ0ЖЅЗ0ЗЅИ0ИЅЙ0ЙЅК0КЅЛ0ЛЅМ0МЅН0НЅО0ОЅП0ПЅР0РЅС0СЅТ0ТЅУ0УЅФ0ФЅХ0ХЅЦ0ЦЅЧ0ЧЅШ0ШЅЩ0ЩЅЪ0ЪЅЫ0ЫЅЬ0ЬЅЭ0ЭЅЮ0ЮЅЯ0ЯЅа0аЅб0бЅв0вЅг0гЅд0дЅе0еЅж0жЅз0зЅи0иЅй0йЅк0кЅл0лЅм0мЅн0нЅо0оЅп0пЅр0рЅс0сЅт0тЅу0уЅф0фЅх0хЅц0цЅч0чЅш0шЅщ0щЅъ0ъЅы0ыЅь0ьЅэ0эЅю0юЅя0яЅ№0№Ѕё0ёЅђ0ђЅѓ0ѓЅє0єЅѕ0ѕЅі0іІЁ‘ІЂ’ІЃ“ІЄ”ІЅ•ІІ–ІЇ—ІЈ˜ІЉ™ІЊšІЋ›ІЌœІ­ІЎžІЏŸІА ІБЁІВЃІГЄІДЅІЕІІЖЇІЗЈІИЉІСБІТВІУГІФДІХЕІЦЖІЧЗІШИІЩЙІЪКІЫЛІЬМІЭНІЮОІЯПІаРІбСІвУІгФІдХІеЦІжЧІзШІиЩІрў5Ісў6Ітў9Іуў:Іфў?Іхў@Іцў=Ічў>ІшўAІщўBІъўCІыўDІюў;Іяў<І№ў7Іёў8Іђў1Ієў3Іѕў4ЇЁЇЂЇЃЇЄЇЅЇІЇЇЇЈЇЉЇЊЇЋЇЌЇ­ЇЎЇЏЇАЇБЇВ ЇГ!ЇД"ЇЕ#ЇЖ$ЇЗ%ЇИ&ЇЙ'ЇК(ЇЛ)ЇМ*ЇН+ЇО,ЇП-ЇР.ЇС/Їб0Їв1Їг2Їд3Їе4Їж5ЇзQЇи6Їй7Їк8Їл9Їм:Їн;Їо<Їп=Їр>Їс?Їт@ЇуAЇфBЇхCЇцDЇчEЇшFЇщGЇъHЇыIЇьJЇэKЇюLЇяMЇ№NЇёOЈ@ЪЈAЫЈBйЈC ЈD ЈE %ЈF 5ЈG!ЈH! ЈI!–ЈJ!—ЈK!˜ЈL!™ЈM"ЈN"ЈO"#ЈP"RЈQ"fЈR"gЈS"ПЈT%PЈU%QЈV%RЈW%SЈX%TЈY%UЈZ%VЈ[%WЈ\%XЈ]%YЈ^%ZЈ_%[Ј`%\Јa%]Јb%^Јc%_Јd%`Јe%aЈf%bЈg%cЈh%dЈi%eЈj%fЈk%gЈl%hЈm%iЈn%jЈo%kЈp%lЈq%mЈr%nЈs%oЈt%pЈu%qЈv%rЈw%sЈx%Јy%‚Јz%ƒЈ{%„Ј|%…Ј}%†Ј~%‡Ј€%ˆЈ%‰Ј‚%ŠЈƒ%‹Ј„%ŒЈ…%Ј†%ŽЈ‡%Јˆ%“Ј‰%”ЈŠ%•Ј‹%МЈŒ%НЈ%тЈŽ%уЈ%фЈ%хЈ‘& Ј’"•Ј“0Ј”0Ј•0ЈЁЈЂсЈЃЮЈЄрЈЅЈІщЈЇЈЈшЈЉ+ЈЊэЈЋаЈЌьЈ­MЈЎѓЈЏвЈАђЈБkЈВњЈГдЈДљЈЕжЈЖиЈЗкЈИмЈЙќЈКъЈЛQЈНDЈОHЈРaЈХ1ЈЦ1ЈЧ1ЈШ1ЈЩ1 ЈЪ1 ЈЫ1 ЈЬ1 ЈЭ1 ЈЮ1ЈЯ1Ја1Јб1Јв1Јг1Јд1Је1Јж1Јз1Ји1Јй1Јк1Јл1Јм1Јн1Јо1Јп1Јр1 Јс1!Јт1"Ју1#Јф1$Јх1%Јц1&Јч1'Јш1(Јщ1)Љ@0!ЉA0"ЉB0#ЉC0$ЉD0%ЉE0&ЉF0'ЉG0(ЉH0)ЉI2ЃЉJ3ŽЉK3ЉL3œЉM3ЉN3žЉO3ЁЉP3ФЉQ3ЮЉR3бЉS3вЉT3еЉUў0ЉVџтЉWџфЉY!!ЉZ21Љ\ Љ`0ќЉa0›Љb0œЉc0§Љd0ўЉe0Љf0Љg0žЉhўIЉiўJЉjўKЉkўLЉlўMЉmўNЉnўOЉoўPЉpўQЉqўRЉrўTЉsўUЉtўVЉuўWЉvўYЉwўZЉxў[Љyў\Љzў]Љ{ў^Љ|ў_Љ}ў`Љ~ўaЉ€ўbЉўcЉ‚ўdЉƒўeЉ„ўfЉ…ўhЉ†ўiЉ‡ўjЉˆўkЉ–0ЉЄ%ЉЅ%ЉІ%ЉЇ%ЉЈ%ЉЉ%ЉЊ%ЉЋ%ЉЌ%Љ­% ЉЎ% ЉЏ% ЉА% ЉБ% ЉВ%ЉГ%ЉД%ЉЕ%ЉЖ%ЉЗ%ЉИ%ЉЙ%ЉК%ЉЛ%ЉМ%ЉН%ЉО%ЉП%ЉР%ЉС%ЉТ%ЉУ%ЉФ% ЉХ%!ЉЦ%"ЉЧ%#ЉШ%$ЉЩ%%ЉЪ%&ЉЫ%'ЉЬ%(ЉЭ%)ЉЮ%*ЉЯ%+Ља%,Љб%-Љв%.Љг%/Љд%0Ље%1Љж%2Љз%3Љи%4Љй%5Љк%6Љл%7Љм%8Љн%9Љо%:Љп%;Љр%<Љс%=Љт%>Љу%?Љф%@Љх%AЉц%BЉч%CЉш%DЉщ%EЉъ%FЉы%GЉь%HЉэ%IЉю%JЉя%KЊ@rмЊArнЊBrпЊCrтЊDrуЊErфЊFrхЊGrцЊHrчЊIrъЊJrыЊKrѕЊLrіЊMrљЊNr§ЊOrўЊPrџЊQsЊRsЊSsЊTsЊUsЊVsЊWsЊXs ЊYs ЊZs Њ[s Њ\sЊ]sЊ^sЊ_sЊ`sЊasЊbsЊcsЊdsЊes Њfs#Њgs$Њhs&Њis'Њjs(Њks-Њls/Њms0Њns2Њos3Њps5Њqs6Њrs:Њss;Њts<Њus=Њvs@ЊwsAЊxsBЊysCЊzsDЊ{sEЊ|sFЊ}sGЊ~sHЊ€sIЊsJЊ‚sKЊƒsLЊ„sNЊ…sOЊ†sQЊ‡sSЊˆsTЊ‰sUЊŠsVЊ‹sXЊŒsYЊsZЊŽs[Њs\Њs]Њ‘s^Њ’s_Њ“saЊ”sbЊ•scЊ–sdЊ—seЊ˜sfЊ™sgЊšshЊ›siЊœsjЊskЊžsnЊŸspЊ sqЋ@srЋAssЋBstЋCsuЋDsvЋEswЋFsxЋGsyЋHszЋIs{ЋJs|ЋKs}ЋLsЋMs€ЋNsЋOs‚ЋPsƒЋQs…ЋRs†ЋSsˆЋTsŠЋUsŒЋVsЋWsЋXsЋYs’ЋZs“Ћ[s”Ћ\s•Ћ]s—Ћ^s˜Ћ_s™Ћ`sšЋasœЋbsЋcsžЋds ЋesЁЋfsЃЋgsЄЋhsЅЋisІЋjsЇЋksЈЋlsЊЋmsЌЋns­ЋosБЋpsДЋqsЕЋrsЖЋssИЋtsЙЋusМЋvsНЋwsОЋxsПЋysСЋzsУЋ{sФЋ|sХЋ}sЦЋ~sЧЋ€sЫЋsЬЋ‚sЮЋƒsвЋ„sгЋ…sдЋ†sеЋ‡sжЋˆsзЋ‰sиЋŠsкЋ‹sлЋŒsмЋsнЋŽsпЋsсЋsтЋ‘sуЋ’sфЋ“sцЋ”sшЋ•sъЋ–sыЋ—sьЋ˜sюЋ™sяЋšs№Ћ›sёЋœsѓЋsєЋžsѕЋŸsіЋ sїЌ@sјЌAsљЌBsњЌCsћЌDsќЌEs§ЌFsўЌGsџЌHtЌItЌJtЌKtЌLtЌMtЌNt ЌOt ЌPt ЌQtЌRtЌStЌTtЌUtЌVtЌWtЌXtЌYtЌZtЌ[tЌ\tЌ]tЌ^tЌ_t Ќ`t!Ќat#Ќbt$Ќct'Ќdt)Ќet+Ќft-Ќgt/Ќht1Ќit2Ќjt7Ќkt8Ќlt9Ќmt:Ќnt;Ќot=Ќpt>Ќqt?Ќrt@ЌstBЌttCЌutDЌvtEЌwtFЌxtGЌytHЌztIЌ{tJЌ|tKЌ}tLЌ~tMЌ€tNЌtOЌ‚tPЌƒtQЌ„tRЌ…tSЌ†tTЌ‡tVЌˆtXЌ‰t]ЌŠt`Ќ‹taЌŒtbЌtcЌŽtdЌteЌtfЌ‘tgЌ’thЌ“tiЌ”tjЌ•tkЌ–tlЌ—tnЌ˜toЌ™tqЌštrЌ›tsЌœttЌtuЌžtxЌŸtyЌ tz­@t{­At|­Bt}­Ct­Dt‚­Et„­Ft…­Gt†­Htˆ­It‰­JtŠ­KtŒ­Lt­Mt­Nt‘­Ot’­Pt“­Qt”­Rt•­St–­Tt—­Ut˜­Vt™­Wtš­Xt›­Yt­ZtŸ­[t ­\tЁ­]tЂ­^tЃ­_tЄ­`tЅ­atІ­btЊ­ctЋ­dtЌ­et­­ftЎ­gtЏ­htА­itБ­jtВ­ktГ­ltД­mtЕ­ntЖ­otЗ­ptИ­qtЙ­rtЛ­stМ­ttН­utО­vtП­wtР­xtС­ytТ­ztУ­{tФ­|tХ­}tЦ­~tЧ­€tШ­tЩ­‚tЪ­ƒtЫ­„tЬ­…tЭ­†tЮ­‡tЯ­ˆtа­‰tб­Štг­‹tд­Œtе­tж­Žtз­tи­tй­‘tк­’tл­“tн­”tп­•tс­–tх­—tч­˜tш­™tщ­štъ­›tы­œtь­tэ­žt№­Ÿtё­ tђЎ@tѓЎAtѕЎBtјЎCtљЎDtњЎEtћЎFtќЎGt§ЎHtўЎIuЎJuЎKuЎLuЎMuЎNuЎOuЎPuЎQu ЎRu ЎSu ЎTu ЎUuЎVuЎWuЎXuЎYuЎZuЎ[uЎ\uЎ]uЎ^uЎ_u Ў`u!Ўau"Ўbu#Ўcu$Ўdu&Ўeu'Ўfu*Ўgu.Ўhu4Ўiu6Ўju9Ўku<Ўlu=Ўmu?ЎnuAЎouBЎpuCЎquDЎruFЎsuGЎtuIЎuuJЎvuMЎwuPЎxuQЎyuRЎzuSЎ{uUЎ|uVЎ}uWЎ~uXЎ€u]Ўu^Ў‚u_Ўƒu`Ў„uaЎ…ubЎ†ucЎ‡udЎˆugЎ‰uhЎŠuiЎ‹ukЎŒulЎumЎŽunЎuoЎupЎ‘uqЎ’usЎ“uuЎ”uvЎ•uwЎ–uzЎ—u{Ў˜u|Ў™u}Ўšu~Ў›u€ЎœuЎu‚Ўžu„ЎŸu…Ў u‡Џ@uˆЏAu‰ЏBuŠЏCuŒЏDuЏEuŽЏFuЏGu“ЏHu•ЏIu˜ЏJu›ЏKuœЏLužЏMuЂЏNuІЏOuЇЏPuЈЏQuЉЏRuЊЏSu­ЏTuЖЏUuЗЏVuКЏWuЛЏXuПЏYuРЏZuСЏ[uЦЏ\uЫЏ]uЬЏ^uЮЏ_uЯЏ`uаЏauбЏbuгЏcuзЏduйЏeuкЏfuмЏguнЏhuпЏiuрЏjuсЏkuхЏluщЏmuьЏnuэЏouюЏpuяЏquђЏruѓЏsuѕЏtuіЏuuїЏvuјЏwuњЏxuћЏyu§ЏzuўЏ{vЏ|vЏ}vЏ~vЏ€vЏv Џ‚v Џƒv Џ„vЏ…vЏ†vЏ‡vЏˆvЏ‰vЏŠvЏ‹vЏŒvЏvЏŽvЏv!Џv#Џ‘v'Џ’v(Џ“v,Џ”v.Џ•v/Џ–v1Џ—v2Џ˜v6Џ™v7Џšv9Џ›v:Џœv;Џv=ЏžvAЏŸvBЏ vDА@vEАAvFАBvGАCvHАDvIАEvJАFvKАGvNАHvOАIvPАJvQАKvRАLvSАMvUАNvWАOvXАPvYАQvZАRv[АSv]АTv_АUv`АVvaАWvbАXvdАYveАZvfА[vgА\vhА]viА^vjА_vlА`vmАavnАbvpАcvqАdvrАevsАfvtАgvuАhvvАivwАjvyАkvzАlv|АmvАnv€АovАpvƒАqv…Аrv‰АsvŠАtvŒАuvАvvАwvАxv’Аyv”Аzv•А{v—А|v˜А}všА~v›А€vœАvА‚vžАƒvŸА„v А…vЁА†vЂА‡vЃАˆvЅА‰vІАŠvЇА‹vЈАŒvЉАvЊАŽvЋАvЌАv­А‘vЏА’vАА“vГА”vЕА•vЖА–vЗА—vИА˜vЙА™vКАšvЛА›vМАœvНАvОАžvРАŸvСА vУАЁUJАЂ–?АЃWУАЄc(АЅTЮАІU АЇTРАЈv‘АЉvLАЊ…<АЋwюАЌ‚~А­xАЎr1АЏ–˜АА—АБl(АВ[‰АГOњАДc АЕf—АЖ\ИАЗ€њАИhHАЙ€ЎАКfАЛvЮАМQљАНeVАОqЌАПёАРˆ„АСPВАТYeАУaЪАФoГАХ‚­АЦcLАЧbRАШSэАЩT'АЪ{АЫQkАЬuЄАЭ]єАЮbдАЯЫАа—vАбbŠАв€АгW]Ад—8АеbАжr8Азv}АиgЯАйv~АкdFАлOpАм%АнbмАоzАпe‘АрsэАсd,АтbsАу‚,Аф˜АхgАцrHАчbnАшbЬАщO4АъtуАыSJАьRžАэ~ЪАюІАя^.А№h†АёiœАђ€Аѓ~бАєhвАѕxХАі†ŒАї•QАјPАљŒ$Ањ‚оАћ€оАќSА§‰АўReБ@vФБAvЧБBvЩБCvЫБDvЬБEvгБFvеБGvйБHvкБIvмБJvнБKvоБLvрБMvсБNvтБOvуБPvфБQvцБRvчБSvшБTvщБUvъБVvыБWvьБXvэБYv№БZvѓБ[vѕБ\vіБ]vїБ^vњБ_vћБ`v§БavџБbwБcwБdwБewБfwБgw Бhw БiwБjwБkwБlwБmwБnwБowБpwБqwБrwБswБtwБuwБvwБwwБxw!Бyw#Бzw$Б{w%Б|w'Б}w*Б~w+Б€w,Бw.Б‚w0Бƒw1Б„w2Б…w3Б†w4Б‡w9Бˆw;Б‰w=БŠw>Б‹w?БŒwBБwDБŽwEБwFБwHБ‘wIБ’wJБ“wKБ”wLБ•wMБ–wNБ—wOБ˜wRБ™wSБšwTБ›wUБœwVБwWБžwXБŸwYБ w\БЁ…„БЂ–љБЃOнБЄX!БЅ™qБІ[БЇbББЈbЅБЉfДБЊŒyБЋœБЌrБ­goБЎx‘БЏ`ВБАSQББSБВˆБГ€ЬБДБЕ”ЁБЖP БЗrШБИYБЙ`ыБКqБЛˆЋБМYTБН‚яБОg,БП{(БР])БС~їБТu-БУlѕБФŽfБХјБЦ<БЧŸ;БШkдБЩ‘БЪ{БЫ_|БЬxЇБЭ„жБЮ…=БЯkеБаkйБбkжБв^Бг^‡БдuљБе•эБжe]Бз_ Би_ХБйŸБкXСБлТБмБн–[Бо—­БпЙБрБс,БтbAБуOПБфSиБхS^БцЈБчЉБшЋБщMБъhБы_jБь˜БэˆhБюœжБяa‹Б№R+Бёv*Бђ_lБѓeŒБєoвБѕnшБі[ОБїdHБјQuБљQАБњgФБћNБќyЩБ§™|БўpГВ@w]ВAw^ВBw_ВCw`ВDwdВEwgВFwiВGwjВHwmВIwnВJwoВKwpВLwqВMwrВNwsВOwtВPwuВQwvВRwwВSwxВTwzВUw{ВVw|ВWwВXw‚ВYwƒВZw†В[w‡В\wˆВ]w‰В^wŠВ_w‹В`wВawВbw“Вcw”Вdw•Вew–Вfw—Вgw˜Вhw™ВiwšВjw›ВkwœВlwВmwžВnwЁВowЃВpwЄВqwІВrwЈВswЋВtw­ВuwЎВvwЏВwwБВxwВВywДВzwЖВ{wЗВ|wИВ}wЙВ~wКВ€wМВwОВ‚wРВƒwСВ„wТВ…wУВ†wФВ‡wХВˆwЦВ‰wЧВŠwШВ‹wЩВŒwЪВwЫВŽwЬВwЮВwЯВ‘wаВ’wбВ“wвВ”wгВ•wдВ–wеВ—wж˜wиВ™wйВšwкВ›wнВœwоВwпВžwрВŸwсВ wфВЁuХВЂ^vВЃsЛВЄƒрВЅd­ВІbшВЇ”ЕВЈlтВЉSZВЊRУВЋdВЌ”ТВ­{”ВЎO/ВЏ^ВА‚6ВБВВŠВГn$ВДlЪВЕšsВЖcUВЗS\ВИTњВЙˆeВКWрВЛN ВМ^ВНkeВО|?ВПшВР`ВСdцВТsВУˆСВФgPВХbMВЦ"ВЧwlВШŽ)ВЩ‘ЧВЪ_iВЫƒмВЬ…!ВЭ™ВЮSТВЯ†•Ваk‹Вб`эВв`шВгpВд‚ЭВе‚1ВжNгВзlЇВи…ЯВйdЭВк|йВлi§ВмfљВнƒIВоS•Вп{VВрOЇВсQŒВтmKВу\BВфŽmВхcвВцSЩВчƒ,Вшƒ6ВщgхВъxДВыd=Вь[пВэ\”Вю]юВя‹чВ№bЦВёgєВђŒzВѓdВєcКВѕ‡IВі™‹ВїŒВј Вљ”ђВњNЇВћ–Вќ˜ЄВ§f ВўsГ@wцГAwшГBwъГCwяГDw№ГEwёГFwђГGwєГHwѕГIwїГJwљГKwњГLwћГMwќГNxГOxГPxГQxГRxГSxГTx ГUx ГVxГWxГXxГYxГZxГ[xГ\xГ]xГ^x Г_x!Г`x"Гax$Гbx(Гcx*Гdx+Гex.Гfx/Гgx1Гhx2Гix3Гjx5Гkx6Гlx=Гmx?ГnxAГoxBГpxCГqxDГrxFГsxHГtxIГuxJГvxKГwxMГxxOГyxQГzxSГ{xTГ|xXГ}xYГ~xZГ€x[Гx\Г‚x^Гƒx_Г„x`Г…xaГ†xbГ‡xcГˆxdГ‰xeГŠxfГ‹xgГŒxhГxiГŽxoГxpГxqГ‘xrГ’xsГ“xtГ”xuГ•xvГ–xxГ—xyØxzГ™x{Гšx}Г›x~ГœxГx€ГžxГŸx‚Г xƒГЁW:ГЂ\ГЃ^8ГЄ•ГЅPГІ€ ГЇS‚ГЈe^ГЉuEГЊU1ГЋP!ГЌ…Г­b„ГЎ”žГЏgГАV2ГБonГВ]тГГT5ГДp’ГЕfГЖboГЗdЄГИcЃГЙ_{ГКoˆГЛєГМуГНАГО\ГПfhГР_ёГСl‰ГТ–HГУГФˆlГХd‘ГЦy№ГЧWЮГШjYГЩbГЪTHГЫNXГЬz ГЭ`щГЮo„ГЯ‹кГаbГбГвš‹ГгyфГдTГеuєГжcГзSГиl`ГйпГк_ГлšpГм€;ГнŸГоOˆГп\:ГрdГсХГтeЅГуpНГфQEГхQВГц†kГч]Гш[ ГщbНГъ‘lГыutГьŽ Гэz ГюaГя{yГ№NЧГё~јГђw…ГѓNГєэГѕRГіQњГїjqГјSЈГљŽ‡Гњ•Гћ–ЯГќnСГ§–dГўiZД@x„ДAx…ДBx†ДCxˆДDxŠДEx‹ДFxДGxДHx’ДIx”ДJx•ДKx–ДLx™ДMxДNxžДOx ДPxЂДQxЄДRxІДSxЈДTxЉДUxЊДVxЋДWxЌДXx­ДYxЎДZxЏД[xЕД\xЖД]xЗД^xИД_xКД`xЛДaxМДbxНДcxПДdxРДexТДfxУДgxФДhxЦДixЧДjxШДkxЬДlxЭДmxЮДnxЯДoxбДpxвДqxгДrxжДsxзДtxиДuxкДvxлДwxмДxxнДyxоДzxпД{xрД|xсД}xтД~xуД€xфДxхД‚xцДƒxчД„xщД…xъД†xыД‡xэДˆxюД‰xяДŠx№Д‹xёДŒxѓДxѕДŽxіДxјДxљД‘xћД’xќД“x§Д”xўД•xџД–yД—yĘyД™yДšyД›yДœyДy Дžy ДŸy Д y ДЁx@ДЂPЈДЃwзДЄdДЅ‰цДІYДЇcуДЈ]нДЉzДЊi=ДЋO ДЌ‚9Д­U˜ДЎN2ДЏuЎДАz—ДБ^bДВ^ŠДГ•яДДRДЕT9ДЖpŠДЗcvДИ•$ДЙW‚ДКf%ДЛi?ДМ‘‡ДНUДОmѓДП~ЏДРˆ"ДСb3ДТ~№ДУuЕДФƒ(ДХxСДЦ–ЬДЧžДШaHДЩtїДЪ‹ЭДЫkdДЬR:ДЭPДЮk!ДЯ€jДа„qДбVёДвSДгNЮДдNДеQбДж|—Дз‘‹Ди|ДйOУДкŽДл{сДмzœДнdgДо]ДпPЌДрДсvДт|ЙДуmьДфрДхgQДц[XДч[јДшxЫДщdЎДъdДыcЊДьc+Дэ•Дюd-ДяОД№{TДёv)ДђbSДѓY'ДєTFДѕkyДіPЃДїb4Дј^&Дљk†ДњNуДћ7Дќˆ‹Д§_…Дў.Е@y ЕAyЕByЕCyЕDyЕEyЕFyЕGyЕHyЕIyЕJyЕKyЕLyЕMyЕNyЕOyЕPyЕQy ЕRy!ЕSy"ЕTy#ЕUy%ЕVy&ЕWy'ЕXy(ЕYy)ЕZy*Е[y+Е\y,Е]y-Е^y.Е_y/Е`y0Еay1Еby2Еcy3Еdy5Еey6Еfy7Еgy8Еhy9Еiy=Еjy?ЕkyBЕlyCЕmyDЕnyEЕoyGЕpyJЕqyKЕryLЕsyMЕtyNЕuyOЕvyPЕwyQЕxyRЕyyTЕzyUЕ{yXЕ|yYЕ}yaЕ~ycЕ€ydЕyfЕ‚yiЕƒyjЕ„ykЕ…ylЕ†ynЕ‡ypЕˆyqЕ‰yrЕŠysЕ‹ytЕŒyuЕyvЕŽyyЕy{Еy|Е‘y}Е’y~Е“yЕ”y‚Е•yƒЕ–y†Е—y‡Е˜yˆЕ™y‰Еšy‹Е›yŒЕœyЕyŽЕžyЕŸy‘Е y’ЕЁ` ЕЂ€=ЕЃbХЕЄN9ЕЅSUЕІјЕЇcИЕЈ€ЦЕЉeцЕЊl.ЕЋOFЕЌ`юЕ­mсЕЎ‹оЕЏ_9ЕА†ЫЕБ_SЕВc!ЕГQZЕДƒaЕЕhcЕЖRЕЗccЕИŽHЕЙPЕК\›ЕЛywЕМ[ќЕНR0ЕОz;ЕП`МЕРSЕСvзЕТ_ЗЕУ_—ЕФv„ЕХŽlЕЦpoЕЧv{ЕШ{IЕЩwЊЕЪQѓЕЫ“ЕЬX$ЕЭONЕЮnєЕЯъЕаeLЕб{ЕвrФЕгmЄЕдпЕеZсЕжbЕЕз^•ЕиW0Ей„‚Ек{,Ел^Ем_ЕнЕоЕЕрc‚ЕсnЧЕтx˜ЕуpЙЕфQxЕх—[ЕцWЋЕчu5ЕшOCЕщu8Еъ^—Еы`цЕьY`ЕэmРЕюkПЕяx‰Е№SќЕё–еЕђQЫЕѓRЕєc‰ЕѕT Еі”“ЕїŒЕјЬЕљr9ЕњxŸЕћ‡vЕќэЕ§Œ ЕўSрЖ@y“ЖAy”ЖBy•ЖCy–ЖDy—ЖEy˜ЖFy™ЖGy›ЖHyœЖIyЖJyžЖKyŸЖLy ЖMyЁЖNyЂЖOyЃЖPyЄЖQyЅЖRyІЖSyЈЖTyЉЖUyЊЖVyЋЖWyЌЖXy­ЖYyЎЖZyЏЖ[yАЖ\yБЖ]yВЖ^yДЖ_yЕЖ`yЖЖayЗЖbyИЖcyМЖdyПЖeyТЖfyФЖgyХЖhyЧЖiyШЖjyЪЖkyЬЖlyЮЖmyЯЖnyаЖoyгЖpyдЖqyжЖryзЖsyйЖtyкЖuyлЖvyмЖwyнЖxyоЖyyрЖzyсЖ{yтЖ|yхЖ}yшЖ~yъЖ€yьЖyюЖ‚yёЖƒyђЖ„yѓЖ…yєЖ†yѕЖ‡yіЖˆyїЖ‰yљЖŠyњЖ‹yќЖŒyўЖyџЖŽzЖzЖzЖ‘zЖ’zЖ“z Ж”z Ж•z Ж–zЖ—zƘzЖ™zЖšzЖ›zЖœzЖzЖžzЖŸzЖ zЖЁNЖЂvяЖЃSюЖЄ”‰ЖЅ˜vЖІŸЖЇ•-ЖЈ[šЖЉ‹ЂЖЊN"ЖЋNЖЌQЌЖ­„cЖЎaТЖЏRЈЖАh ЖБO—ЖВ`kЖГQЛЖДmЖЕQ\ЖЖb–ЖЗe—ЖИ–aЖЙŒFЖКЖЛuиЖМ§ЖНwcЖОkвЖПrŠЖРrьЖС‹ћЖТX5ЖУwyЖФLЖХg\ЖЦ•@ЖЧ€šЖШ^ІЖЩn!ЖЪY’ЖЫzяЖЬwэЖЭ•;ЖЮkЕЖЯe­ЖаЖбXЖвQQЖг–Жд[љЖеXЉЖжT(ЖзŽrЖиefЖй˜ЖкVфЖл”ЖмvўЖнAЖоc‡ЖпTЦЖрYЖсY:ЖтW›ЖуŽВЖфg5ЖхњЖц‚5ЖчRAЖш`№ЖщXЖъ†ўЖы\шЖьžEЖэOФЖю˜Жя‹ЙЖ№Z%Жё`vЖђS„Жѓb|ЖєOЖѕ‘Жі™Жї`iЖј€ ЖљQ?Жњ€3Жћ\Жќ™uЖ§m1ЖўNŒЗ@zЗAzЗBz!ЗCz"ЗDz$ЗEz%ЗFz&ЗGz'ЗHz(ЗIz)ЗJz*ЗKz+ЗLz,ЗMz-ЗNz.ЗOz/ЗPz0ЗQz1ЗRz2ЗSz4ЗTz5ЗUz6ЗVz8ЗWz:ЗXz>ЗYz@ЗZzAЗ[zBЗ\zCЗ]zDЗ^zEЗ_zGЗ`zHЗazIЗbzJЗczKЗdzLЗezMЗfzNЗgzOЗhzPЗizRЗjzSЗkzTЗlzUЗmzVЗnzXЗozYЗpzZЗqz[Зrz\Зsz]Зtz^Зuz_Зvz`ЗwzaЗxzbЗyzcЗzzdЗ{zeЗ|zfЗ}zgЗ~zhЗ€ziЗzjЗ‚zkЗƒzlЗ„zmЗ…znЗ†zoЗ‡zqЗˆzrЗ‰zsЗŠzuЗ‹z{ЗŒz|Зz}ЗŽz~Зz‚Зz…З‘z‡З’z‰З“zŠЗ”z‹З•zŒЗ–zŽЗ—zЗ˜zЗ™z“Зšz”З›z™ЗœzšЗz›ЗžzžЗŸzЁЗ zЂЗЁ0ЗЂSбЗЃZЗЄ{OЗЅOЗІNOЗЇ–ЗЈlеЗЉsаЗЊ…щЗЋ^ЗЌujЗ­ћЗЎj ЗЏwўЗА”’ЗБ~AЗВQсЗГpцЗДSЭЗЕдЗЖƒЗЗ)ЗИrЏЗЙ™mЗКlлЗЛWJЗМ‚ГЗНeЙЗО€ЊЗПb?ЗР–2ЗСYЈЗТNџЗУ‹ПЗФ~КЗХe>ЗЦƒђЗЧ—^ЗШUaЗ٘оЗЪ€ЅЗЫS*ЗЬ‹§ЗЭT ЗЮ€КЗЯ^ŸЗаlИЗб9Зв‚ЌЗг‘ZЗдT)ЗеlЗжRЗз~ЗЗиW_ЗйqЗкl~Зл|‰ЗмYKЗнN§Зо_џЗпa$Зр|ЊЗсN0Зт\ЗуgЋЗф‡Зх\№Зц• Зч˜ЮЗшuЏЗщp§Зъ"ЗыQЏЗьЗэ‹НЗюYIЗяQфЗ№O[ЗёT&ЗђY+ЗѓewЗє€ЄЗѕ[uЗіbvЗїbТЗјЗљ^EЗњlЗћ{&ЗќOЗ§OиЗўg И@zЃИAzЄИBzЇИCzЉИDzЊИEzЋИFzЎИGzЏИHzАИIzБИJzВИKzДИLzЕИMzЖИNzЗИOzИИPzЙИQzКИRzЛИSzМИTzНИUzОИVzРИWzСИXzТИYzУИZzФИ[zХИ\zЦИ]zЧИ^zШИ_zЩИ`zЪИazЬИbzЭИczЮИdzЯИezаИfzбИgzвИhzгИizдИjzеИkzзИlzиИmzкИnzлИozмИpzнИqzсИrzтИszфИtzчИuzшИvzщИwzъИxzыИyzьИzzюИ{z№И|zёИ}zђИ~zѓИ€zєИzѕИ‚zіИƒzїИ„zјИ…zћИ†zќИ‡zўИˆ{И‰{ИŠ{И‹{ИŒ{И{ ИŽ{ И{ И{И‘{И’{И“{И”{И•{И–{И—{Ș{И™{Иš{И›{!Иœ{"И{#Иž{'ИŸ{)И {-ИЁmnИЂmЊИЃyИЄˆБИЅ_ИІu+ИЇbšИЈ…ИЉOяИЊ‘мИЋeЇИЌ/И­QИЎ^œИЏPИАtИБRoИВ‰†ИГKИДY ИЕP…ИЖNиИЗ–ИИr6ИЙyИКИЛ[ЬИМ‹ЃИН–DИОY‡ИПИРTИСVvИТVИУ‹хИФe9ИХi‚ИЦ”™ИЧvжИШn‰ИЩ^rИЪuИЫgFИЬgбИЭzџИЮ€ИЯvИаaИбyЦИвebИгcИдQˆИеRИж”ЂИз8Ии€›Ий~ВИк\—Илn/Имg`Ин{йИоv‹ИпšиИрИс”Ит|еИуdИф•PИхz?ИцTJИчTхИшkLИщdИъbИыž=Иь€ѓИэu™ИюRrИя—iИ№„[Иёh<Иђ†фИѓ–Иє–”Иѕ”ьИіN*ИїTИј~йИљh9ИњпИћ€ИќfєИ§^šИўЙЙ@{/ЙA{0ЙB{2ЙC{4ЙD{5ЙE{6ЙF{7ЙG{9ЙH{;ЙI{=ЙJ{?ЙK{@ЙL{AЙM{BЙN{CЙO{DЙP{FЙQ{HЙR{JЙS{MЙT{NЙU{SЙV{UЙW{WЙX{YЙY{\ЙZ{^Й[{_Й\{aЙ]{cЙ^{dЙ_{eЙ`{fЙa{gЙb{hЙc{iЙd{jЙe{kЙf{lЙg{mЙh{oЙi{pЙj{sЙk{tЙl{vЙm{xЙn{zЙo{|Йp{}Йq{Йr{Йs{‚Йt{ƒЙu{„Йv{†Йw{‡Йx{ˆЙy{‰Йz{ŠЙ{{‹Й|{ŒЙ}{ŽЙ~{Й€{‘Й{’Й‚{“Йƒ{–Й„{˜Й…{™Й†{šЙ‡{›Йˆ{žЙ‰{ŸЙŠ{ Й‹{ЃЙŒ{ЄЙ{ЅЙŽ{ЎЙ{ЏЙ{АЙ‘{ВЙ’{ГЙ“{ЕЙ”{ЖЙ•{ЗЙ–{ЙЙ—{Кɘ{ЛЙ™{МЙš{НЙ›{ОЙœ{ПЙ{РЙž{ТЙŸ{УЙ {ФЙЁWТЙЂ€?ЙЃh—ЙЄ]хЙЅe;ЙІRŸЙЇ`mЙЈŸšЙЉO›ЙЊŽЌЙЋQlЙЌ[ЋЙ­_ЙЎ]щЙЏl^ЙАbёЙБ!ЙВQqЙГ”ЉЙДRўЙЕlŸЙЖ‚пЙЗrзЙИWЂЙЙg„ЙК-ЙЛYЙМœЙНƒЧЙОT•ЙП{ЙРO0ЙСlНЙТ[dЙУYбЙФŸЙХSфЙЦ†ЪЙЧšЈЙШŒ7ЙЩ€ЁЙЪeEЙۘ~ЙЬVњЙЭ–ЧЙЮR.ЙЯtмЙаRPЙб[сЙвcЙг‰ЙдNVЙеbаЙж`*ЙзhњЙиQsЙй[˜ЙкQ Йл‰ТЙм{ЁЙ홆ЙоPЙп`яЙрpLЙс/ЙтQIЙу^ЙфЙхtpЙц‰ФЙчW-ЙшxEЙщ_RЙъŸŸЙы•њЙьhЙэ›<Йю‹сЙяvxЙ№hBЙёgмЙђъЙѓ5ЙєR=ЙѕŠЙіnкЙїhЭЙј•ЙљэЙњV§ЙћgœЙќˆљЙ§ЧЙўTШК@{ХКA{ШКB{ЩКC{ЪКD{ЫКE{ЭКF{ЮКG{ЯКH{аКI{вКJ{дКK{еКL{жКM{зКN{иКO{лКP{мКQ{оКR{пКS{рКT{тКU{уКV{фКW{чКX{шКY{щКZ{ыК[{ьК\{эК]{яК^{№К_{ђК`{ѓКa{єКb{ѕКc{іКd{јКe{љКf{њКg{ћКh{§Кi{џКj|Кk|Кl|Кm|Кn|Кo|Кp|Кq|Кr| Кs| Кt| Кu|Кv|Кw|Кx|Кy|Кz|К{|К||К}|К~|К€|К|К‚|Кƒ|К„|К…| К†|!К‡|"Кˆ|#К‰|$КŠ|%К‹|(КŒ|)К|+КŽ|,К|-К|.К‘|/К’|0К“|1К”|2К•|3К–|4К—|5ʘ|6К™|7Кš|9К›|:Кœ|;К|<Кž|=КŸ|>К |BКЁšИКЂ[iКЃmwКЄl&КЅNЅКІ[ГКЇš‡КЈ‘cКЉaЈКЊЏКЋ—щКЌT+К­mЕКЎ[вКЏQ§КАUŠКБUКВ№КГdМКДcMКЕeёКЖaОКЗ`КИq КЙlWККlIКЛY/КМgmКН‚*КОXеКПVŽКРŒjКСkыКТнКУY}КФ€КХSїКЦmiКЧTuКШUКЩƒwКЪƒЯКЫh8КЬyОКЭTŒКЮOUКЯTКаvвКбŒ‰Кв–КгlГКдmИКеkКж‰КзždКи:КйV?КкžбКлuеКм_ˆКнrрКо`hКпTќКрNЈКсj*КтˆaКу`RКфpКхTФКцpиКч†yКшž?Кщm*Къ[Кы_Кь~ЂКэU‰КюOЏКяs4К№T<КёSšКђPКѓTКєT|КѕNNКі_§КїtZКјXіКљ„kКњ€сКћ‡tКќrаК§|ЪКўnVЛ@|CЛA|DЛB|EЛC|FЛD|GЛE|HЛF|IЛG|JЛH|KЛI|LЛJ|NЛK|OЛL|PЛM|QЛN|RЛO|SЛP|TЛQ|UЛR|VЛS|WЛT|XЛU|YЛV|ZЛW|[ЛX|\ЛY|]ЛZ|^Л[|_Л\|`Л]|aЛ^|bЛ_|cЛ`|dЛa|eЛb|fЛc|gЛd|hЛe|iЛf|jЛg|kЛh|lЛi|mЛj|nЛk|oЛl|pЛm|qЛn|rЛo|uЛp|vЛq|wЛr|xЛs|yЛt|zЛu|~Лv|Лw|€Лx|Лy|‚Лz|ƒЛ{|„Л||…Л}|†Л~|‡Л€|ˆЛ|ŠЛ‚|‹Лƒ|ŒЛ„|Л…|ŽЛ†|Л‡|Лˆ|“Л‰|”ЛŠ|–Л‹|™ЛŒ|šЛ|›ЛŽ| Л|ЁЛ|ЃЛ‘|ІЛ’|ЇЛ“|ЈЛ”|ЉЛ•|ЋЛ–|ЌЛ—|­Л˜|ЏЛ™|АЛš|ДЛ›|ЕЛœ|ЖЛ|ЗЛž|ИЛŸ|КЛ |ЛЛЁ_'ЛЂ†NЛЃU,ЛЄbЄЛЅN’ЛІlЊЛЇb7ЛЈ‚БЛЉTзЛЊSNЛЋs>ЛЌnбЛ­u;ЛЎRЛЏSЛА‹нЛБiаЛВ_ŠЛГ`ЛДmюЛЕWOЛЖk"ЛЗsЏЛИhSЛЙиЛКЛЛcbЛМ`ЃЛНU$ЛОuъЛПŒbЛРqЛСmЃЛТ[ІЛУ^{ЛФƒRЛХaLЛЦžФЛЧxњЛШ‡WЛЩ|'ЛЪv‡ЛЫQ№ЛЬ`іЛЭqLЛЮfCЛЯ^LЛа`MЛбŒЛвppЛгc%Лд‰Ле_НЛж`bЛз†дЛиVоЛйkСЛк`”ЛлagЛмSIЛн`рЛоffЛп?Лрy§ЛсOЛтpщЛуlGЛф‹ГЛх‹ђЛц~иЛчƒdЛшfЛщZZЛъ›BЛыmQЛьmїЛэŒAЛюm;ЛяOЛ№pkЛёƒЗЛђbЛѓ`бЛє— Лѕ'ЛіyxЛїQћЛјW>ЛљWњЛњg:ЛћuxЛќz=Л§yяЛў{•М@|ПМA|РМB|ТМC|УМD|ФМE|ЦМF|ЩМG|ЫМH|ЮМI|ЯМJ|аМK|бМL|вМM|гМN|дМO|иМP|кМQ|лМR|нМS|оМT|сМU|тМV|уМW|фМX|хМY|цМZ|чМ[|щМ\|ъМ]|ыМ^|ьМ_|эМ`|юМa|№Мb|ёМc|ђМd|ѓМe|єМf|ѕМg|іМh|їМi|љМj|њМk|ќМl|§Мm|ўМn|џМo}Мp}Мq}Мr}Мs}Мt}Мu}Мv}Мw}Мx} Мy} Мz} М{} М|}М}}М~}М€}М}М‚}Мƒ}М„}М…}М†}М‡}Мˆ}М‰}МŠ}М‹}МŒ}М}МŽ}М}!М}#М‘}$М’}%М“}&М”}(М•})М–}*М—},̘}-М™}.Мš}0М›}1Мœ}2М}3Мž}4МŸ}5М }6МЁ€ŒМЂ™eМЃљМЄoРМЅ‹ЅМІž!МЇYьМЈ~щМЉ МЊT МЋgМЌhиМ­‘МЎ|MМЏ–ЦМАSЪМБ`%МВuОМГlrМДSsМЕZЩМЖ~ЇМЗc$МИQрМЙ МК]ёМЛ„пММb€МНQ€МО[cМПOМРymМСRBМТ`ИМУmNМФ[ФМХ[ТМЦ‹ЁМЧ‹АМШeтМЩ_ЬМЪ–EМЫY“МЬ~чМЭ~ЊМЮV МЯgЗМаY9МбOsМв[ЖМгR МдƒZМе˜ŠМж>Мзu2Ми”ОМйPGМкz<МлNїМмgЖМнš~МоZСМпk|МрvбМсWZМт\Му{:Мф•єМхqNМцQ|Мч€ЉМш‚pМщYxМъМыƒ'МьhРМэgьМюxБМяxwМ№bуМёcaМђ{€МѓOэМєRjМѕQЯМіƒPМїiлМј’tМљѕМњ1Мћ‰СМќ•.М§{­МўNіН@}7НA}8НB}9НC}:НD};НE}<НF}=НG}>НH}?НI}@НJ}AНK}BНL}CНM}DНN}EНO}FНP}GНQ}HНR}IНS}JНT}KНU}LНV}MНW}NНX}OНY}PНZ}QН[}RН\}SН]}TН^}UН_}VН`}WНa}XНb}YНc}ZНd}[Нe}\Нf}]Нg}^Нh}_Нi}`Нj}aНk}bНl}cНm}dНn}eНo}fНp}gНq}hНr}iНs}jНt}kНu}lНv}mНw}oНx}pНy}qНz}rН{}sН|}tН}}uН~}vН€}xН}yН‚}zНƒ}{Н„}|Н…}}Н†}~Н‡}Нˆ}€Н‰}НŠ}‚Н‹}ƒНŒ}„Н}…НŽ}†Н}‡Н}ˆН‘}‰Н’}ŠН“}‹Н”}ŒН•}Н–}ŽН—}Н˜}Н™}‘Нš}’Н›}“Нœ}”Н}•Нž}–НŸ}—Н }˜НЁPeНЂ‚0НЃRQНЄ™oНЅnНІn…НЇmЇНЈ^њНЉPѕНЊYмНЋ\НЌmFН­l_НЎu†НЏ„‹НАhhНБYVНВ‹ВНГS НД‘qНЕ–MНЖ…IНЗiНИyНЙq&НК€іНЛNЄНМЪННmGНОš„НПZНРVМНСdНТ”№НУwыНФOЅНХНЦrсНЧ‰вНШ™zНЩ4НЪ~оНЫRНЬeYНЭ‘uНЮНЯƒНаSыНбz–НвcэНгcЅНдv†НеyјНжˆWНз–6Ниb*НйRЋНк‚‚НлhTНмgpНнcwНоwkНпzэНрmНс~гНт‰уНуYаНфbНх…ЩНц‚ЅНчuLНшPНщNЫНъuЅНы‹ыНь\JНэ]ўНю{KНяeЄН№‘бНёNЪНђm%Нѓ‰_Нє}'Нѕ•&НіNХНїŒ(НјлНљ—sНњfKНћyНќбН§pьНўmxО@}™ОA}šОB}›ОC}œОD}ОE}žОF}ŸОG} ОH}ЁОI}ЂОJ}ЃОK}ЄОL}ЅОM}ЇОN}ЈОO}ЉОP}ЊОQ}ЋОR}ЌОS}­ОT}ЏОU}АОV}БОW}ВОX}ГОY}ДОZ}ЕО[}ЖО\}ЗО]}ИО^}ЙО_}КО`}ЛОa}МОb}НОc}ООd}ПОe}РОf}СОg}ТОh}УОi}ФОj}ХОk}ЦОl}ЧОm}ШОn}ЩОo}ЪОp}ЫОq}ЬОr}ЭОs}ЮОt}ЯОu}аОv}бОw}вОx}гОy}дОz}еО{}жО|}зО}}иО~}йО€}кО}лО‚}мОƒ}нО„}оО…}пО†}рО‡}сОˆ}тО‰}уОŠ}фО‹}хОŒ}цО}чОŽ}шО}щО}ъО‘}ыО’}ьО“}эО”}юО•}яО–}№О—}ёО˜}ђО™}ѓОš}єО›}ѕОœ}іО}їОž}јОŸ}љО }њОЁ\=ОЂRВОЃƒFОЄQbОЅƒОІw[ОЇfvОЈœИОЉNЌОЊ`ЪОЋ|ООЌ|ГО­~ЯОЎN•ОЏ‹fОАfoОБ˜ˆОВ—YОГXƒОДelОЕ•\ОЖ_„ОЗuЩОИ—VОЙzпОКzоОЛQРОМpЏОНz˜ООcъОПzvОР~ ОСs–ОТ—эОУNEОФpxОХN]ОЦ‘RОЧSЉОШeQОЩeчОЪќОЫ‚ОЬTŽОЭ\1ОЮušОЯ— ОаbиОбrйОвuНОг\EОдšyОеƒЪОж\@ОзT€ОиwщОйN>ОкlЎОл€ZОмbвОнcnОо]шОпQwОрнОсŽОт•/ОуOёОфSхОх`чОцpЌОчRgОшcPОщžCОъZОыP&Оьw7ОэSwОю~тОяd…О№e+Оёb‰Ођc˜ОѓPОєr5Оѕ‰ЩОіQГОї‹РОј~нОљWGОњƒЬОћ”ЇОќQ›О§TОў\ћП@}ћПA}ќПB}§ПC}ўПD}џПE~ПF~ПG~ПH~ПI~ПJ~ПK~ПL~ПM~ПN~ ПO~ ПP~ ПQ~ ПR~ ПS~ПT~ПU~ПV~ПW~ПX~ПY~ПZ~П[~П\~П]~П^~П_~П`~Пa~Пb~Пc~Пd~Пe~ Пf~!Пg~"Пh~#Пi~$Пj~%Пk~&Пl~'Пm~(Пn~)Пo~*Пp~+Пq~,Пr~-Пs~.Пt~/Пu~0Пv~1Пw~2Пx~3Пy~4Пz~5П{~6П|~7П}~8П~~9П€~:П~<П‚~=Пƒ~>П„~?П…~@П†~BП‡~CПˆ~DП‰~EПŠ~FП‹~HПŒ~IП~JПŽ~KП~LП~MП‘~NП’~OП“~PП”~QП•~RП–~SП—~TϘ~UП™~VПš~WП›~XПœ~YП~ZПž~[ПŸ~\П ~]ПЁOЪПЂzуПЃmZПЄсПЅšПІU€ПЇT–ПЈSaПЉTЏПЊ_ПЋcщПЌiwП­QяПЎahПЏR ПАX*ПБRиПВWNПГx ПДw ПЕ^ЗПЖawПЗ|рПИb[ПЙb—ПКNЂПЛp•ПМ€ПНbїПОpфПП—`ПРWwПС‚лПТgяПУhѕПФxеП՘—ПЦyбПЧXѓПШTГПЩSяПЪn4ПЫQKПЬR;ПЭ[ЂПЮ‹ўПЯ€ЏПаUCПбWІПв`sПгWQПдT-ПеzzПж`PПз[TПиcЇПйb ПкSуПлbcПм[ЧПнgЏПоTэПпzŸПр‚цПс‘wПт^“ПуˆфПфY8ПхWЎПцcПчшПш€яПщWWПъ{wПыOЉПь_ыПэ[НПюk>ПяS!П№{PПёrТПђhFПѓwџПєw6ПѕeїПіQЕПїNПјvдПљ\ППњzЅПћ„uПќYNП§›AПўP€Р@~^РA~_РB~`РC~aРD~bРE~cРF~dРG~eРH~fРI~gРJ~hРK~iРL~jРM~kРN~lРO~mРP~nРQ~oРR~pРS~qРT~rРU~sРV~tРW~uРX~vРY~wРZ~xР[~yР\~zР]~{Р^~|Р_~}Р`~~Рa~Рb~€Рc~Рd~ƒРe~„Рf~…Рg~†Рh~‡Рi~ˆРj~‰Рk~ŠРl~‹Рm~ŒРn~Рo~ŽРp~Рq~Рr~‘Рs~’Рt~“Рu~”Рv~•Рw~–Рx~—Рy~˜Рz~™Р{~šР|~œР}~Р~~žР€~ЎР~ДР‚~ЛРƒ~МР„~жР…~фР†~ьР‡~љРˆ Р‰РŠР‹7РŒ9Р;РŽ<Р=Р>Р‘?Р’@Р“AР”CР•FР–GР—HИIР™JРšKР›LРœMРNРžOРŸRР SРЁ™ˆРЂa'РЃnƒРЄWdРЅfРІcFРЇV№РЈbьРЉbiРЊ^гРЋ–РЌWƒР­bЩРЎU‡РЏ‡!РАJРБЃРВUfРГƒБРДgeРЕVРЖ„нРЗZjРИhРЙbцРК{юРЛ–РМQpРНoœРОŒ0РПc§РР‰ШРСaвРТРУpТРФnхРХtРЦi”РЧrќРШ^ЪРЩЮРЪgРЫmjРЬc^РЭRГРЮrbРЯ€РаOlРбYхРв‘jРгpйРдmРеRвРжNPРз–їРи•mРй…~РкxЪРл}/РмQ!РнW’РоdТРРр|{РсlъРтhёРуi^РфQЗРхS˜РцhЈРчrРшžЮРщ{ёРъrјРыyЛРьoРэtРюgNРя‘ЬР№œЄРёy<Рђƒ‰РѓƒTРєTРѕhРіN=РїS‰РјRБРљx>РњS†РћR)РќPˆР§O‹РўOаС@VСAYСB[СC\СD]СE^СF`СGcСHdСIeСJfСKgСLkСMlСNmСOoСPpСQsСRuСSvСTwСUxСVzСW{СX|СY}СZС[€С\‚С]ƒС^„С_…С`†Сa‡СbˆСc‰Сd‹СeСfСgСh‘Сi’Сj“Сk•Сl–Сm—Сn˜Сo™Сp›СqœСr СsЂСtЃСuЅСvІСwЈСxЉСyЊСzЋС{ЌС|­С}ЎС~БС€ГСДС‚ЕСƒЖС„ЗС…КС†ЛС‡ОСˆРС‰ТСŠУС‹ФСŒЦСЧСŽШСЩСЫС‘ЭС’ЯС“аС”бС•вС–гС—жјзС™йСšкС›лСœмСнСžоСŸтС уСЁuтСЂzЫСЃ|’СЄlЅСЅ–ЖСІR›СЇtƒСЈTщСЉOщСЊ€TСЋƒВСЌоС­•pСЎ^ЩСЏ`САmŸСБ^СВe[СГ8СД”ўСЕ`KСЖpМСЗ~УСИ|ЎСЙQЩСКhСЛ|БСМ‚oСНN$СО†СП‘ЯСРf~ССNЎСТŒСУdЉСФ€JСХPкСЦu—СЧqЮСШ[хСЩНСЪofСЫN†СЬd‚СЭ•cСЮ^жСЯe™СаRСбˆТСвpШСгRЃСдsСеt3Сжg—СзxїСи—СйN4СкЛСлœоСмmЫСнQлСоAСпTСрbЮСсsВСтƒёСу–іСфŸ„Сх”УСцO6СчšСшQЬСщpuСъ–uСы\­Сь˜†СэSцСюNфСяnœС№t СёiДСђxkСѓ™СєuYСѕRСіv$СїmAСјgѓСљQmСњŸ™Сћ€KСќT™С§{<СўzПТ@фТAчТBшТCъТDыТEьТFэТGяТHђТIєТJѕТKіТLїТMјТNљТOњТP§ТQўТRџТS€ТT€ТU€ТV€ ТW€ ТX€ТY€ТZ€Т[€Т\€Т]€Т^€Т_€Т`€Тa€!Тb€#Тc€$Тd€+Тe€,Тf€-Тg€.Тh€/Тi€0Тj€2Тk€4Тl€9Тm€:Тn€<Тo€>Тp€@Тq€AТr€DТs€EТt€GТu€HТv€IТw€NТx€OТy€PТz€QТ{€SТ|€UТ}€VТ~€WТ€€YТ€[Т‚€\Тƒ€]Т„€^Т…€_Т†€`Т‡€aТˆ€bТ‰€cТŠ€dТ‹€eТŒ€fТ€gТŽ€hТ€kТ€lТ‘€mТ’€nТ“€oТ”€pТ•€rТ–€sТ—€tҘ€uТ™€vТš€wТ›€xТœ€yТ€zТž€{ТŸ€|Т €}ТЁ–†ТЂW„ТЃbтТЄ–GТЅi|ТІZТЇdТЈ{гТЉoТЊ–KТЋ‚ІТЌSbТ­˜…ТЎ^ТЏp‰ТАcГТБSdТВ†OТГœТДž“ТЕxŒТЖ—2ТЗяТИBТЙžТКo^ТЛy„ТМ_UТН–FТОb.ТПštТРTТС”нТТOЃТУeХТФ\eТХ\aТЦТЧ†QТШl/ТЩ_‹ТЪs‡ТЫnфТЬ~џТЭ\цТЮcТЯ[jТаnцТбSuТвNqТгc ТдueТеbЁТжnТзO&ТиNбТйlІТк~ЖТл‹КТм„Тн‡КТоWТп;Тр•#Тс{ЉТтšЁТуˆјТф„=ТхmТцš†Тч~мТшYˆТщžЛТъs›ТыxТь†‚ТэšlТюš‚ТяVТ№TТёWЫТђNpТѓžІТєSVТѕШТі Тїw’Тј™’Тљ†юТњnсТћ…ТќfќТ§abТўo+У@€~УA€УB€‚УC€…УD€ˆУE€ŠУF€УG€ŽУH€УI€УJ€‘УK€’УL€”УM€•УN€—УO€™УP€žУQ€ЃУR€ІУS€ЇУT€ЈУU€ЌУV€АУW€ГУX€ЕУY€ЖУZ€ИУ[€ЙУ\€ЛУ]€ХУ^€ЧУ_€ШУ`€ЩУa€ЪУb€ЫУc€ЯУd€аУe€бУf€вУg€гУh€дУi€еУj€иУk€пУl€рУm€тУn€уУo€цУp€юУq€ѕУr€їУs€љУt€ћУu€ўУv€џУwУxУyУzУ{У|У}У~ У€ УУ‚УƒУ„У…У†У‡Уˆ У‰!УŠ"У‹#УŒ$У%УŽ&У'У(У‘)У’*У“+У”-У•.У–0У—3Ә4У™5Уš7У›9Уœ:У;Уž<УŸ=У ?УЁŒ)УЂ‚’УЃƒ+УЄvђУЅlУІ_йУЇƒНУЈs+УЉƒУЊ•УЋkлУЌwлУ­”ЦУЎSoУЏƒУАQ’УБ^=УВŒŒУГ8УДNHУЕsЋУЖgšУЗh…УИ‘vУЙ— УКqdУЛlЁУМw УНZ’УО•AУПkЯУРŽУСf'УТ[аУУYЙУФZšУХ•шУЦ•їУЧNьУШ„ УЩ„™УЪjЌУЫvпУЬ•0УЭsУЮhІУЯ[_Уаw/Уб‘šУв—aУг|мУдїУеŒУж_%Уз|sУиyиУй‰ХУкlЬУл‡Ум[ЦУн^BУоhЩУпw Ур~ѕУсQ•УтQMУуRЩУфZ)УхУц—bУч‚зУшcЯУщw„Уъ…аУыyвУьn:Уэ^™УюY™Уя…У№pmУёlУђbПУѓvПУєeOУѕ`ЏУі•§УїfУј‡ŸУљž#Уњ”эУћT УќT}У§Œ,УўdxФ@@ФAAФBBФCCФDDФEEФFGФGIФHMФINФJOФKRФLVФMWФNXФO[ФP\ФQ]ФR^ФS_ФTaФUbФVcФWdФXfФYhФZjФ[kФ\lФ]oФ^rФ_sФ`uФavФbwФcxФdФeƒФf„Фg…Фh†Фi‡Фj‰Фk‹ФlŒФmФnŽФoФp’Фq“Фr”Фs•Фt–Фu—Фv™ФwšФxžФyŸФz Ф{ЁФ|ЂФ}ЄФ~ЅФ€ЇФЉФ‚ЋФƒЌФ„­Ф…ЎФ†ЏФ‡АФˆБФ‰ВФŠДФ‹ЕФŒЖФЗФŽИФЙФМФ‘НФ’ОФ“ПФ”ФФ•ХФ–ЧФ—ШԘЩФ™ЫФšЭФ›ЮФœЯФаФžбФŸвФ гФЁdyФЂ†ФЃj!ФЄœФЅxшФІdiФЇ›TФЈbЙФЉg+ФЊƒЋФЋXЈФЌžиФ­lЋФЎo ФЏ[оФА–LФБŒ ФВr_ФГgаФДbЧФЕraФЖNЉФЗYЦФИkЭФЙX“ФКfЎФЛ^UФМRпФНaUФОg(ФПvюФРwfФСrgФТzFФУbџФФTъФХTPФЦ” ФЧЃФШZФЩ~ГФЪlФЫNCФЬYvФЭ€ФЮYHФЯSWФаu7Фб–ОФвVЪФгc ФдФе`|Фж•љФзmжФиTbФй™ФкQ…ФлZщФ숧ФнYЎФо—ФпP*ФрlхФс\<ФтbпФуO`ФфS?Фх{ФцФчnКФш…+ФщbШФъ^tФыxОФьdЕФэc{Фю_ѕФяZФ№‘ФёžФђ\?ФѓcOФє€BФѕ[}ФіUnФї•JФј•MФљm…Фњ`ЈФћgрФќrоФ§QнФў[Х@дХAеХBжХCзХDиХEйХFкХGлХHмХIнХJоХKпХLрХMсХNтХOфХPхХQцХRшХSщХTыХUюХVяХW№ХXёХYђХZѕХ[іХ\їХ]јХ^љХ_њХ`§ХaџХb‚Хc‚Хd‚Хe‚ Хf‚ Хg‚ Хh‚Хi‚Хj‚Хk‚Хl‚Хm‚Хn‚Хo‚Хp‚Хq‚Хr‚Хs‚ Хt‚$Хu‚%Хv‚&Хw‚'Хx‚)Хy‚.Хz‚2Х{‚:Х|‚<Х}‚=Х~‚?Х€‚@Х‚AХ‚‚BХƒ‚CХ„‚EХ…‚FХ†‚HХ‡‚JХˆ‚LХ‰‚MХŠ‚NХ‹‚PХŒ‚QХ‚RХŽ‚SХ‚TХ‚UХ‘‚VХ’‚WХ“‚YХ”‚[Х•‚\Х–‚]Х—‚^՘‚`Х™‚aХš‚bХ›‚cХœ‚dХ‚eХž‚fХŸ‚gХ ‚iХЁbчХЂlоХЃr[ХЄbmХЅ”ЎХІ~НХЇХЈmSХЉQœХЊ_ХЋYtХЌRЊХ­`ХЎYsХЏf–ХА†PХБuŸХВc*ХГaцХД|яХЕ‹њХЖTцХЗk'ХИž%ХЙkДХК…еХЛTUХМPvХНlЄХОUjХПДХРr,ХС^ХТ`ХУt6ХФbЭХХc’ХЦrLХЧ_˜ХШnCХЩm>ХЪeХЫoXХЬvиХЭxаХЮvќХЯuTХаR$ХбSлХвNSХг^žХдeСХе€*Хж€жХзb›ХиT†ХйR(ХкpЎХлˆХмбХнlсХоTxХп€кХрWљХсˆєХтTХу–jХф‘MХхOiХцl›ХчUЗХшvЦХщx0ХъbЈХыpљХьoŽХэ_mХю„ьХяhкХ№x|Хё{їХђЈХѓg ХєžOХѕcgХіxАХїWoХјxХљ—9ХњbyХћbЋХќRˆХ§t5ХўkзЦ@‚jЦA‚kЦB‚lЦC‚mЦD‚qЦE‚uЦF‚vЦG‚wЦH‚xЦI‚{ЦJ‚|ЦK‚€ЦL‚ЦM‚ƒЦN‚…ЦO‚†ЦP‚‡ЦQ‚‰ЦR‚ŒЦS‚ЦT‚“ЦU‚”ЦV‚•ЦW‚–ЦX‚šЦY‚›ЦZ‚žЦ[‚ Ц\‚ЂЦ]‚ЃЦ^‚ЇЦ_‚ВЦ`‚ЕЦa‚ЖЦb‚КЦc‚ЛЦd‚МЦe‚ПЦf‚РЦg‚ТЦh‚УЦi‚ХЦj‚ЦЦk‚ЩЦl‚аЦm‚жЦn‚йЦo‚кЦp‚нЦq‚тЦr‚чЦs‚шЦt‚щЦu‚ъЦv‚ьЦw‚эЦx‚юЦy‚№Цz‚ђЦ{‚ѓЦ|‚ѕЦ}‚іЦ~‚јЦ€‚њЦ‚ќЦ‚‚§Цƒ‚ўЦ„‚џЦ…ƒЦ†ƒ Ц‡ƒ Цˆƒ Ц‰ƒЦŠƒЦ‹ƒЦŒƒЦƒЦŽƒЦƒЦƒЦ‘ƒЦ’ƒ Ц“ƒ!Ц”ƒ"Ц•ƒ#Ц–ƒ$Ц—ƒ%֘ƒ&Ц™ƒ)Цšƒ*Ц›ƒ.Цœƒ0Цƒ2Цžƒ7ЦŸƒ;Ц ƒ=ЦЁUdЦЂ>ЦЃuВЦЄvЎЦЅS9ЦІuоЦЇPћЦЈ\AЦЉ‹lЦЊ{ЧЦЋPOЦЌrGЦ­š—ЦЎ˜иЦЏoЦАtтЦБyhЦВd‡ЦГwЅЦДbќЦؑЦЖ+ЦЗTСЦИ€XЦЙNRЦКWjЦЛ‚љЦМ„ ЦН^sЦОQэЦПtіЦР‹ФЦС\OЦТWaЦУlќЦԘ‡ЦХZFЦЦx4ЦЧ›DЦШыЦЩ|•ЦЪRVЦЫbQЦЬ”њЦЭNЦЦЮƒ†ЦЯ„aЦаƒщЦб„ВЦвWдЦгg4ЦдWЦеfnЦжmfЦзŒ1ЦиfнЦйpЦкgЦлk:ЦмhЦнbЦоYЛЦпNЦрQФЦсoЦтgвЦуlЦфQvЦхhЫЦцYGЦчkgЦшufЦщ]ЦъЦыŸPЦьeзЦэyHЦюyAЦяš‘Ц№wЦё\‚ЦђN^ЦѓOЦєT/ЦѕYQЦіx ЦїVhЦјlЦљФЦњ_Цћl}ЦќlуЦ§‹ЋЦўcЧ@ƒ>ЧAƒ?ЧBƒAЧCƒBЧDƒDЧEƒEЧFƒHЧGƒJЧHƒKЧIƒLЧJƒMЧKƒNЧLƒSЧMƒUЧNƒVЧOƒWЧPƒXЧQƒYЧRƒ]ЧSƒbЧTƒpЧUƒqЧVƒrЧWƒsЧXƒtЧYƒuЧZƒvЧ[ƒyЧ\ƒzЧ]ƒ~Ч^ƒЧ_ƒ€Ч`ƒЧaƒ‚ЧbƒƒЧcƒ„Чdƒ‡ЧeƒˆЧfƒŠЧgƒ‹ЧhƒŒЧiƒЧjƒЧkƒЧlƒ‘Чmƒ”Чnƒ•Чoƒ–Чpƒ—Чqƒ™ЧrƒšЧsƒЧtƒŸЧuƒЁЧvƒЂЧwƒЃЧxƒЄЧyƒЅЧzƒІЧ{ƒЇЧ|ƒЌЧ}ƒ­Ч~ƒЎЧ€ƒЏЧƒЕЧ‚ƒЛЧƒƒОЧ„ƒПЧ…ƒТЧ†ƒУЧ‡ƒФЧˆƒЦЧ‰ƒШЧŠƒЩЧ‹ƒЫЧŒƒЭЧƒЮЧŽƒаЧƒбЧƒвЧ‘ƒгЧ’ƒеЧ“ƒзЧ”ƒйЧ•ƒкЧ–ƒлЧ—ƒоטƒтЧ™ƒуЧšƒфЧ›ƒцЧœƒчЧƒшЧžƒыЧŸƒьЧ ƒэЧЁ`pЧЂm=ЧЃruЧЄbfЧЅ”ŽЧІ”ХЧЇSCЧЈСЧЉ{~ЧЊNпЧЋŒ&ЧЌN~Ч­žдЧЎ”БЧЏ”ГЧАRMЧБo\ЧВcЧГmEЧДŒ4ЧЕXЧЖ]LЧЗk ЧИkIЧЙgЊЧКT[ЧЛTЧМŒЧНX™ЧО…7ЧП_:ЧРbЂЧСjGЧТ•9ЧУerЧФ`„ЧХheЧЦwЇЧЧNTЧШOЈЧЩ]чЧЪ—˜ЧЫdЌЧЬиЧЭ\эЧЮOЯЧЯzЧаRЧбƒЧвNЧг`/ЧдzƒЧе”ІЧжOЕЧзNВЧиyцЧйt4ЧкRфЧл‚ЙЧмdвЧнyНЧо[нЧпlЧр—RЧс{Чтl"ЧуP>ЧфSЧхnЧцdЮЧчftЧшl0Чщ`ХЧъ˜wЧы‹їЧь^†Чэt<ЧюzwЧяyЫЧ№NЧёБЧђtЧѓlBЧєVкЧѕ‘KЧіlХЧї‹ЧјS:Чљ†ЦЧњfђЧћŽЏЧќ\HЧ§šqЧўn Ш@ƒюШAƒяШBƒѓШCƒєШDƒѕШEƒіШFƒїШGƒњШHƒћШIƒќШJƒўШKƒџШL„ШM„ШN„ШO„ШP„ШQ„ ШR„ ШS„ШT„ШU„ШV„ШW„ШX„ШY„ШZ„Ш[„Ш\„Ш]„Ш^„Ш_„ Ш`„!Шa„"Шb„#Шc„)Шd„*Шe„+Шf„,Шg„-Шh„.Шi„/Шj„0Шk„2Шl„3Шm„4Шn„5Шo„6Шp„7Шq„9Шr„:Шs„;Шt„>Шu„?Шv„@Шw„AШx„BШy„CШz„DШ{„EШ|„GШ}„HШ~„IШ€„JШ„KШ‚„LШƒ„MШ„„NШ…„OШ†„PШ‡„RШˆ„SШ‰„TШŠ„UШ‹„VШŒ„XШ„]ШŽ„^Ш„_Ш„`Ш‘„bШ’„dШ“„eШ”„fШ•„gШ–„hШ—„jؘ„nШ™„oШš„pШ›„rШœ„tШ„wШž„yШŸ„{Ш „|ШЁSжШЂZ6ШЃŸ‹ШЄЃШЅSЛШІWШЇ˜ЇШЈgCШЉ‘›ШЊlЩШЋQhШЌuЪШ­bѓШЎrЌШЏR8ШАRШБ:ШВp”ШГv8ШДStШЕžJШЖiЗШЗxnШИ–РШЙˆйШКЄШЛq6ШМqУШНQ‰ШОgгШПtфШРXфШСeШТVЗШУ‹ЉШФ™vШХbpШЦ~еШЧ`љШШpэШЩXьШЪNСШЫNКШЬ_ЭШЭ—чШЮNћШЯ‹ЄШаRШбYŠШв~ЋШгbTШдNЭШеeхШжbШзƒ8Ши„ЩШйƒcШк‡Шлq”ШмnЖШн[ЙШо~вШпQ—ШрcЩШсgдШт€‰Шуƒ9ШфˆШхQШц[zШчY‚ШшБШщNsШъl]ШыQeШь‰%ШэoШю–.Шя…JШ№t^Шё•Шђ•№ШѓmІШє‚хШѕ_1Шіd’ШїmШј„(ШљnШњœУШћX^Шќ[Ш§N ШўSСЩ@„}ЩA„~ЩB„ЩC„€ЩD„ЩE„ƒЩF„„ЩG„…ЩH„†ЩI„ŠЩJ„ЩK„ЩL„ЩM„‘ЩN„’ЩO„“ЩP„”ЩQ„•ЩR„–ЩS„˜ЩT„šЩU„›ЩV„ЩW„žЩX„ŸЩY„ ЩZ„ЂЩ[„ЃЩ\„ЄЩ]„ЅЩ^„ІЩ_„ЇЩ`„ЈЩa„ЉЩb„ЊЩc„ЋЩd„ЌЩe„­Щf„ЎЩg„АЩh„БЩi„ГЩj„ЕЩk„ЖЩl„ЗЩm„ЛЩn„МЩo„ОЩp„РЩq„ТЩr„УЩs„ХЩt„ЦЩu„ЧЩv„ШЩw„ЫЩx„ЬЩy„ЮЩz„ЯЩ{„вЩ|„дЩ}„еЩ~„зЩ€„иЩ„йЩ‚„кЩƒ„лЩ„„мЩ…„оЩ†„сЩ‡„тЩˆ„фЩ‰„чЩŠ„шЩ‹„щЩŒ„ъЩ„ыЩŽ„эЩ„юЩ„яЩ‘„ёЩ’„ђЩ“„ѓЩ”„єЩ•„ѕЩ–„іЩ—„їЩ˜„јЩ™„љЩš„њЩ›„ћЩœ„§Щ„ўЩž…ЩŸ…Щ …ЩЁOЩЂecЩЃhQЩЄUгЩЅN'ЩІdЩЇššЩЈbkЩЉZТЩЊt_ЩЋ‚rЩЌmЉЩ­hюЩЎPчЩЏƒŽЩАxЩБg@ЩВR9ЩГl™ЩД~БЩЕPЛЩЖUeЩЗq^ЩИ{[ЩЙfRЩКsЪЩЛ‚ыЩМgIЩН\qЩОR ЩПq}ЩРˆkЩС•ъЩТ–UЩУdХЩФaЩХГЩЦU„ЩЧlUЩШbGЩЩ.ЩЪX’ЩЫO$ЩЬUFЩЭOЩЮfLЩЯN Ща\ЩбˆѓЩвhЂЩгcNЩдz ЩеpчЩж‚ЩзRњЩи—іЩй\ЩкTшЩлЕЩм~ЭЩнYbЩоJЩп†ЧЩр‚ Щс‚ ЩтfЩуdDЩф\ЩхaQЩцm‰Щчy>Щш‹ОЩщx7Щъu3ЩыT{ЩьO8ЩэŽЋЩюmёЩяZ Щ№~ХЩёy^ЩђlˆЩѓ[ЁЩєZvЩѕuЩі€ОЩїaNЩјnЩљX№ЩњuЩћu%ЩќrrЩ§SGЩў~ѓЪ@…ЪA…ЪB…ЪC…ЪD…ЪE…ЪF… ЪG… ЪH… ЪI… ЪJ…ЪK…ЪL…ЪM…ЪN…ЪO…ЪP…ЪQ…ЪR…ЪS…ЪT…ЪU…ЪV…ЪW… ЪX…"ЪY…#ЪZ…$Ъ[…%Ъ\…&Ъ]…'Ъ^…(Ъ_…)Ъ`…*Ъa…-Ъb….Ъc…/Ъd…0Ъe…1Ъf…2Ъg…3Ъh…4Ъi…5Ъj…6Ъk…>Ъl…?Ъm…@Ъn…AЪo…BЪp…DЪq…EЪr…FЪs…GЪt…KЪu…LЪv…MЪw…NЪx…OЪy…PЪz…QЪ{…RЪ|…SЪ}…TЪ~…UЪ€…WЪ…XЪ‚…ZЪƒ…[Ъ„…\Ъ……]Ъ†…_Ъ‡…`Ъˆ…aЪ‰…bЪŠ…cЪ‹…eЪŒ…fЪ…gЪŽ…iЪ…jЪ…kЪ‘…lЪ’…mЪ“…nЪ”…oЪ•…pЪ–…qЪ—…sژ…uЪ™…vЪš…wЪ›…xЪœ…|Ъ…}Ъž…ЪŸ…€Ъ …ЪЁwЪЂvлЪЃRiЪЄ€мЪЅW#ЪІ^ЪЇY1ЪЈrюЪЉeНЪЊnЪЋ‹зЪЌ\8Ъ­†qЪЎSAЪЏwѓЪАbўЪБeіЪВNРЪØпЪД†€ЪЕ[žЪЖ‹ЦЪЗSђЪИwтЪЙOЪК\NЪЛšvЪМYЫЪН_ЪОy:ЪПXыЪРNЪСgџЪТN‹ЪУbэЪФŠ“ЪХЪЦRПЪЧf/ЪШUмЪЩVlЪЪЪЫNеЪЬOЪЭ‘ЪЪЮ™pЪЯlЪа^Ъб`CЪв[ЄЪг‰ЦЪд‹еЪеe6ЪжbKЪз™–Ъи[ˆЪй[џЪкcˆЪлU.ЪмSзЪнv&ЪоQ}Ъп…,ЪрgЂЪсhГЪтkŠЪуb’Ъф“ЪхSдЪц‚ЪчmбЪшuЪщNfЪъNЪы[pЪьqŸЪэ…ЏЪюf‘ЪяfйЪ№rЪё‡ЪђžЭЪѓŸ Ъє\^Ъѕg/Ъі№ЪїhЪјg_Ъљb ЪњzжЪћX…Ъќ^ЖЪ§epЪўo1Ы@…‚ЫA…ƒЫB…†ЫC…ˆЫD…‰ЫE…ŠЫF…‹ЫG…ŒЫH…ЫI…ŽЫJ…ЫK…‘ЫL…’ЫM…“ЫN…”ЫO…•ЫP…–ЫQ…—ЫR…˜ЫS…™ЫT…šЫU…ЫV…žЫW…ŸЫX… ЫY…ЁЫZ…ЂЫ[…ЃЫ\…ЅЫ]…ІЫ^…ЇЫ_…ЉЫ`…ЋЫa…ЌЫb…­Ыc…БЫd…ВЫe…ГЫf…ДЫg…ЕЫh…ЖЫi…ИЫj…КЫk…ЛЫl…МЫm…НЫn…ОЫo…ПЫp…РЫq…ТЫr…УЫs…ФЫt…ХЫu…ЦЫv…ЧЫw…ШЫx…ЪЫy…ЫЫz…ЬЫ{…ЭЫ|…ЮЫ}…бЫ~…вЫ€…дЫ…жЫ‚…зЫƒ…иЫ„…йЫ……кЫ†…лЫ‡…нЫˆ…оЫ‰…пЫŠ…рЫ‹…сЫŒ…тЫ…уЫŽ…хЫ…цЫ…чЫ‘…шЫ’…ъЫ“…ыЫ”…ьЫ•…эЫ–…юЫ—…яۘ…№Ы™…ёЫš…ђЫ›…ѓЫœ…єЫ…ѕЫž…іЫŸ…їЫ …јЫЁ`UЫЂR7ЫЃ€ ЫЄdTЫЅˆpЫІu)ЫЇ^ЫЈhЫЉbєЫЊ—ЫЋSЬЫЌr=Ы­ŒЫЎl4ЫЏwaЫАzЫБT.ЫВwЌЫØzЫД‚ЫЕ‹єЫЖxUЫЗgЫИpСЫЙeЏЫКd•ЫЛV6ЫМ`ЫНyСЫОSјЫПNЫРk{ЫС€†ЫТ[њЫУUуЫФVлЫХO:ЫЦO<ЫЧ™rЫШ]ѓЫЩg~ЫЪ€8ЫЫ`Ыܘ‚ЫЭЫЮ[‹ЫЯ‹МЫа‹ѕЫбdЫв‚XЫгdоЫдU§Ые‚ЯЫж‘eЫзOзЫи} ЫйЫк|ŸЫлPѓЫмXQЫнnЏЫо[ПЫп‹ЩЫр€ƒЫс‘xЫт„œЫу{—Ыф†}Ых–‹Ыц–Ыч~хЫшšгЫщxŽЫъ\ЫыzWЫьBЫэ–ЇЫюy_Ыя[YЫ№c_Ыё{ Ыђ„бЫѓh­ЫєUЫѕ)ЫіtЫї}"Ыј•Ыљb@ЫњXLЫћNжЫќ[ƒЫ§YyЫўXTЬ@…љЬA…њЬB…ќЬC…§ЬD…ўЬE†ЬF†ЬG†ЬH†ЬI†ЬJ†ЬK†ЬL†ЬM† ЬN† ЬO† ЬP† ЬQ† ЬR†ЬS†ЬT†ЬU†ЬV†ЬW†ЬX†ЬY†ЬZ†Ь[†Ь\†Ь]†Ь^†Ь_†Ь`†Ьa†Ьb† Ьc†!Ьd†"Ьe†#Ьf†$Ьg†%Ьh†&Ьi†(Ьj†*Ьk†+Ьl†,Ьm†-Ьn†.Ьo†/Ьp†0Ьq†1Ьr†2Ьs†3Ьt†4Ьu†5Ьv†6Ьw†7Ьx†9Ьy†:Ьz†;Ь{†=Ь|†>Ь}†?Ь~†@Ь€†AЬ†BЬ‚†CЬƒ†DЬ„†EЬ…†FЬ††GЬ‡†HЬˆ†IЬ‰†JЬŠ†KЬ‹†LЬŒ†RЬ†SЬŽ†UЬ†VЬ†WЬ‘†XЬ’†YЬ“†[Ь”†\Ь•†]Ь–†_Ь—†`ܘ†aЬ™†cЬš†dЬ›†eЬœ†fЬ†gЬž†hЬŸ†iЬ †jЬЁsmЬЂcЬЃŽKЬЄŽЬЅ€ЮЬІ‚дЬЇbЌЬЈS№ЬЉl№ЬЊ‘^ЬЋY*ЬЌ`Ь­lpЬЎWMЬЏdJЬА*ЬБv+ЬВnщЬГW[ЬДj€ЬЕu№ЬЖomЬЗŒ-ЬИŒЬЙWfЬКkяЬЛˆ’ЬМxГЬНcЂЬОSљЬПp­ЬРldЬСXXЬТd*ЬУXЬФhрЬХ›ЬЦUЬЧ|жЬШPЬЩŽКЬЪmЬЬЫŸЬЬpыЬЭcЬЮm›ЬЯnдЬа~цЬб„ЬвhCЬгЬдmиЬе–vЬж‹ЈЬзYWЬиryЬй…фЬк~ЬлuМЬмŠŠЬнhЏЬоRTЬпŽ"Ьр•ЬсcаЬт˜˜ЬуŽDЬфU|ЬхOSЬцfџЬчVЬш`еЬщm•ЬъRCЬы\IЬьY)ЬэmћЬюXkЬяu0Ь№uЬё`lЬђ‚ЬѓFЬєcЬѕgaЬітЬїw:ЬјѓЬљ4Ьњ”СЬћ^ЬќS…Ь§T,ЬўpУЭ@†mЭA†oЭB†pЭC†rЭD†sЭE†tЭF†uЭG†vЭH†wЭI†xЭJ†ƒЭK†„ЭL†…ЭM††ЭN†‡ЭO†ˆЭP†‰ЭQ†ŽЭR†ЭS†ЭT†‘ЭU†’ЭV†”ЭW†–ЭX†—ЭY†˜ЭZ†™Э[†šЭ\†›Э]†žЭ^†ŸЭ_† Э`†ЁЭa†ЂЭb†ЅЭc†ІЭd†ЋЭe†­Эf†ЎЭg†ВЭh†ГЭi†ЗЭj†ИЭk†ЙЭl†ЛЭm†МЭn†НЭo†ОЭp†ПЭq†СЭr†ТЭs†УЭt†ХЭu†ШЭv†ЬЭw†ЭЭx†вЭy†гЭz†еЭ{†жЭ|†зЭ}†кЭ~†мЭ€†нЭ†рЭ‚†сЭƒ†тЭ„†уЭ…†хЭ††цЭ‡†чЭˆ†шЭ‰†ъЭŠ†ыЭ‹†ьЭŒ†яЭ†ѕЭŽ†іЭ†їЭ†њЭ‘†ћЭ’†ќЭ“†§Э”†џЭ•‡Э–‡Э—‡ݘ‡Э™‡ Эš‡ Э›‡Эœ‡Э‡Эž‡ЭŸ‡Э ‡ЭЁl@ЭЂ^їЭЃP\ЭЄN­ЭЅ^­ЭІc:ЭЇ‚GЭЈЭЉhPЭЊ‘nЭЋwГЭЌT Э­”мЭЎ_dЭЏzхЭАhvЭБcEЭВ{RЭГ~пЭДuлЭЕPwЭЖb•ЭЗY4ЭИЭЙQјЭКyУЭЛzЭМVўЭН_’ЭОЭПm‚ЭР\`ЭСWЭТTЭУQTЭФnMЭХVтЭЦcЈЭט“ЭШЭЩ‡ЭЪ‰*ЭЫЭЬTЭЭ\oЭЮРЭЯbжЭаbXЭб1Эвž5Эг–@ЭдšnЭеš|Эжi-ЭзYЅЭиbгЭйU>ЭкcЭлTЧЭм†йЭнm<ЭоZЭпtцЭрˆœЭсkjЭтYЭуŒLЭф_/Эхn~ЭцsЉЭч˜}ЭшN8ЭщpїЭъ[ŒЭыx—Эьc=ЭэfZЭюv–Эя`ЫЭ№[›ЭёZIЭђNЭѓUЭєljЭѕs‹ЭіNЁЭїg‰ЭјQЭљ_€ЭњeњЭћgЭќ_иЭ§Y„ЭўZЮ@‡ЮA‡ЮB‡ЮC‡ЮD‡ ЮE‡$ЮF‡&ЮG‡'ЮH‡(ЮI‡*ЮJ‡+ЮK‡,ЮL‡-ЮM‡/ЮN‡0ЮO‡2ЮP‡3ЮQ‡5ЮR‡6ЮS‡8ЮT‡9ЮU‡:ЮV‡<ЮW‡=ЮX‡@ЮY‡AЮZ‡BЮ[‡CЮ\‡DЮ]‡EЮ^‡FЮ_‡JЮ`‡KЮa‡MЮb‡OЮc‡PЮd‡QЮe‡RЮf‡TЮg‡UЮh‡VЮi‡XЮj‡ZЮk‡[Юl‡\Юm‡]Юn‡^Юo‡_Юp‡aЮq‡bЮr‡fЮs‡gЮt‡hЮu‡iЮv‡jЮw‡kЮx‡lЮy‡mЮz‡oЮ{‡qЮ|‡rЮ}‡sЮ~‡uЮ€‡wЮ‡xЮ‚‡yЮƒ‡zЮ„‡Ю…‡€Ю†‡Ю‡‡„Юˆ‡†Ю‰‡‡ЮŠ‡‰Ю‹‡ŠЮŒ‡ŒЮ‡ŽЮŽ‡Ю‡Ю‡‘Ю‘‡’Ю’‡”Ю“‡•Ю”‡–Ю•‡˜Ю–‡™Ю—‡šЮ˜‡›Ю™‡œЮš‡Ю›‡žЮœ‡ Ю‡ЁЮž‡ЂЮŸ‡ЃЮ ‡ЄЮЁ]ЭЮЂ_ЎЮЃSqЮЄ—цЮЅнЮІhEЮЇVєЮЈU/ЮЉ`пЮЊN:ЮЋoMЮЌ~єЮ­‚ЧЮЎ„ЮЏYдЮАOЮБO*ЮВ\>ЮГ~ЌЮДg*ЮЕ…ЮЖTsЮЗuOЮИ€УЮЙU‚ЮК›OЮЛOMЮМn-ЮНŒЮО\ ЮПapЮРSkЮСvЮТn)ЮУ†ŠЮФe‡ЮХ•ћЮЦ~ЙЮЧT;ЮШz3ЮЩ} ЮЪ•юЮЫUсЮЬСЮЭtюЮЮcЮЯ‡ЮаmЁЮбzЮвbЮгeЁЮдSgЮеcсЮжlƒЮз]ыЮиT\Юй”ЈЮкNLЮлlaЮм‹ьЮн\KЮоeрЮп‚œЮрhЇЮсT>ЮтT4ЮуkЫЮфkfЮхN”ЮцcBЮчSHЮш‚ЮщO ЮъOЎЮыW^Юьb Юэ–ўЮюfdЮяriЮ№RџЮёRЁЮђ`ŸЮѓ‹яЮєfЮѕq™ЮіgЮї‰ЮјxRЮљw§ЮњfpЮћV;ЮќT8Ю§•!ЮўrzЯ@‡ЅЯA‡ІЯB‡ЇЯC‡ЉЯD‡ЊЯE‡ЎЯF‡АЯG‡БЯH‡ВЯI‡ДЯJ‡ЖЯK‡ЗЯL‡ИЯM‡ЙЯN‡ЛЯO‡МЯP‡ОЯQ‡ПЯR‡СЯS‡ТЯT‡УЯU‡ФЯV‡ХЯW‡ЧЯX‡ШЯY‡ЩЯZ‡ЬЯ[‡ЭЯ\‡ЮЯ]‡ЯЯ^‡аЯ_‡дЯ`‡еЯa‡жЯb‡зЯc‡иЯd‡йЯe‡кЯf‡мЯg‡нЯh‡оЯi‡пЯj‡сЯk‡тЯl‡уЯm‡фЯn‡цЯo‡чЯp‡шЯq‡щЯr‡ыЯs‡ьЯt‡эЯu‡яЯv‡№Яw‡ёЯx‡ђЯy‡ѓЯz‡єЯ{‡ѕЯ|‡іЯ}‡їЯ~‡јЯ€‡њЯ‡ћЯ‚‡ќЯƒ‡§Я„‡џЯ…ˆЯ†ˆЯ‡ˆЯˆˆЯ‰ˆЯŠˆЯ‹ˆЯŒˆЯˆ ЯŽˆ Яˆ Яˆ Я‘ˆЯ’ˆЯ“ˆЯ”ˆЯ•ˆЯ–ˆЯ—ˆߘˆЯ™ˆЯšˆЯ›ˆЯœˆЯˆЯžˆЯŸˆ Я ˆ#ЯЁzЯЂ`oЯЃ^ ЯЄ`‰ЯЅЯІYЯЇ`мЯЈq„ЯЉpяЯЊnЊЯЋlPЯЌr€Я­j„ЯЎˆ­ЯЏ^-ЯАN`ЯБZГЯВUœЯГ”уЯДmЯЕ|ћЯЖ–™ЯЗbЯИ~ЦЯЙwŽЯК†~ЯЛS#ЯМ—ЯН–ЯОf‡ЯП\сЯРO ЯСrэЯТN ЯУSІЯФYЯХTЯЦc€ЯЧ•(ЯШQHЯЩNйЯЪœœЯЫ~ЄЯЬTИЯЭ$ЯЮˆTЯЯ‚7Яа•ђЯбmŽЯв_&ЯгZЬЯдf>Яе–iЯжsАЯзs.ЯиSПЯйzЯк™…ЯлЁЯм[ЊЯн–wЯо–PЯп~ПЯрvјЯсSЂЯт•vЯу™™Яф{БЯх‰DЯцnXЯчNaЯшдЯщyeЯъ‹цЯы`ѓЯьTЭЯэNЋЯю˜yЯя]їЯ№jaЯёPЯЯђTЯѓŒaЯє„'Яѕx]Яі—ЯїRJЯјTюЯљVЃЯњ•ЯћmˆЯќ[ЕЯ§mЦЯўfSа@ˆ$аAˆ%аBˆ&аCˆ'аDˆ(аEˆ)аFˆ*аGˆ+аHˆ,аIˆ-аJˆ.аKˆ/аLˆ0аMˆ1аNˆ3аOˆ4аPˆ5аQˆ6аRˆ7аSˆ8аTˆ:аUˆ;аVˆ=аWˆ>аXˆ?аYˆAаZˆBа[ˆCа\ˆFа]ˆGа^ˆHа_ˆIа`ˆJаaˆKаbˆNаcˆOаdˆPаeˆQаfˆRаgˆSаhˆUаiˆVаjˆXаkˆZаlˆ[аmˆ\аnˆ]аoˆ^аpˆ_аqˆ`аrˆfаsˆgаtˆjаuˆmаvˆoаwˆqаxˆsаyˆtаzˆuа{ˆvа|ˆxа}ˆyа~ˆzа€ˆ{аˆ|а‚ˆ€аƒˆƒа„ˆ†а…ˆ‡а†ˆ‰а‡ˆŠаˆˆŒа‰ˆŽаŠˆа‹ˆаŒˆ‘аˆ“аŽˆ”аˆ•аˆ—а‘ˆ˜а’ˆ™а“ˆšа”ˆ›а•ˆа–ˆžа—ˆŸа˜ˆ а™ˆЁаšˆЃа›ˆЅаœˆІаˆЇаžˆЈаŸˆЉа ˆЊаЁ\аЂ[]аЃh!аЄ€–аЅUxаІ{аЇeHаЈiTаЉN›аЊkGаЋ‡NаЌ—‹а­SOаЎcаЏd:аАЊаБeœаВ€СаГŒаДQ™аЕhАаЖSxаЗ‡љаИaШаЙlФаКlћаЛŒ"аМ\QаН…ЊаО‚ЏаП• аРk#аС›аТeАаУ_ћаФ_УаХOсаЦˆEаЧfаШeаЩs)аЪ`њаЫQtаЬRаЭW‹аЮ_bаЯЂааˆLаб‘’ав^xагgOад`'аеYгажQDазQіаи€јайSакlyал–ФамqŠанOаоOюапžарg=асUХат•ауyРафˆ–ах~уацXŸачb аш—ащ†ZаъVаы˜{аь_аэ‹Иаю„Фая‘Wа№Sйаёeэађ^аѓu\ає`dаѕ}nаіZаї~ъај~эаљiањUЇаћ[Ѓаќ`Ќа§eЫаўs„б@ˆЌбAˆЎбBˆЏбCˆАбDˆВбEˆГбFˆДбGˆЕбHˆЖбIˆИбJˆЙбKˆКбLˆЛбMˆНбNˆОбOˆПбPˆРбQˆУбRˆФбSˆЧбTˆШбUˆЪбVˆЫбWˆЬбXˆЭбYˆЯбZˆаб[ˆбб\ˆгб]ˆжб^ˆзб_ˆкб`ˆлбaˆмбbˆнбcˆобdˆрбeˆсбfˆцбgˆчбhˆщбiˆъбjˆыбkˆьбlˆэбmˆюбnˆябoˆђбpˆѕбqˆібrˆїбsˆњбtˆћбuˆ§бvˆџбw‰бx‰бy‰бz‰б{‰б|‰б}‰б~‰ሉ б‰ ႉ бƒ‰ ᄉб…‰ᆉᇉбˆ‰቉бŠ‰ዉбŒ‰б‰бŽ‰б‰б‰ ᑉ"б’‰#ᓉ$ᔉ&ᕉ'б–‰(б—‰)б˜‰,ᙉ-бš‰.ᛉ/бœ‰1б‰2бž‰3бŸ‰5б ‰7бЁ бЂvcбЃw)бЄ~кбЅ—tбІ…›бЇ[fбЈztбЉ–ъбЊˆ@бЋRЫбЌqб­_ЊбЎeьбЏ‹тбА[ћбБšoбВ]сбГk‰бДl[бЕ‹­бЖ‹ЏбЗ бИХбЙS‹бКbМбЛž&бМž-бНT@бОN+бП‚НбРrYбС†œбТ]бУˆYбФmЏбХ–ХбЦTббЧNšбШ‹ЖбЩq бЪTНбЫ– бЬpпбЭmљбЮvабЯN%баxбб‡бв\Љбг^ібдŠбе˜œбж–бзpŽбиlПбйYDбкcЉблw<бмˆMбнoбо‚sбпX0брqебсSŒбтxбу–СбфUбх_fбцq0бч[ДбшŒбщšŒбъkƒбыY.бьž/бэyчбюghбяblб№OoбёuЁбђŠбѓm бє–3бѕl'біN№бїuвбјQ{бљh7бњo>бћ€бќpб§Y–бўtvв@‰8вA‰9вB‰:вC‰;вD‰<вE‰=вF‰>вG‰?вH‰@вI‰BвJ‰CвK‰EвL‰FвM‰GвN‰HвO‰IвP‰JвQ‰KвR‰LвS‰MвT‰NвU‰OвV‰PвW‰QвX‰RвY‰SвZ‰Tв[‰Uв\‰Vв]‰Wв^‰Xв_‰Yв`‰Zвa‰[вb‰\вc‰]вd‰`вe‰aвf‰bвg‰cвh‰dвi‰eвj‰gвk‰hвl‰iвm‰jвn‰kвo‰lвp‰mвq‰nвr‰oвs‰pвt‰qвu‰rвv‰sвw‰tвx‰uвy‰vвz‰wв{‰xв|‰yв}‰zв~‰|∉}в‰~₉€вƒ‰‚℉„в…‰…↉‡в‡‰ˆвˆ‰‰в‰‰ŠвŠ‰‹в‹‰ŒвŒ‰в‰ŽвŽ‰в‰в‰‘⑉’в’‰“Ⓣ”┉•в•‰–в–‰—в—‰˜в˜‰™в™‰šвš‰›в›‰œвœ‰в‰žвž‰ŸвŸ‰ в ‰ЁвЁdGвЂ\'вЃeвЄz‘вЅŒ#вІYквЇTЌвЈ‚вЉƒoвЊ‰вЋ€вЌi0в­VNвЎ€6вЏr7вА‘ЮвБQЖвВN_вØuвДc–вЕNвЖSівЗfѓвИKвЙYвКmВвЛNвМXљвНS;вОcжвП”ёвРOвСO вТˆcвӘвФY7вХWвЦyћвЧNъвШ€№вЩu‘вЪl‚вЫ[œвЬYшвЭ_]вЮiвЯ†ваPвб]ђввNYвгwувдNхве‚zвжb‘взfви‘вй\yвкNПвл_yвмЦвн8ввпuЋврNІвсˆдвтaвуkХвф_ЦвхNIвцvЪвчnЂвш‹увщ‹ЎвъŒ вы‹бвь_вэќвюЬвя~Юв№ƒ5вёƒkвђVрвѓkЗвє—ѓвѕ–4віYћвїTвј”івљmывњ[Хвћ™nвќ\9в§_вў–г@‰ЂгA‰ЃгB‰ЄгC‰ЅгD‰ІгE‰ЇгF‰ЈгG‰ЉгH‰ЊгI‰ЋгJ‰ЌгK‰­гL‰ЎгM‰ЏгN‰АгO‰БгP‰ВгQ‰ГгR‰ДгS‰ЕгT‰ЖгU‰ЗгV‰ИгW‰ЙгX‰КгY‰ЛгZ‰Мг[‰Нг\‰Ог]‰Пг^‰Рг_‰Уг`‰Эгa‰ггb‰дгc‰егd‰згe‰игf‰йгg‰лгh‰нгi‰пгj‰ргk‰сгl‰тгm‰фгn‰чгo‰шгp‰щгq‰ъгr‰ьгs‰эгt‰югu‰№гv‰ёгw‰ђгx‰єгy‰ѕгz‰іг{‰їг|‰јг}‰љг~‰њг€‰ћг‰ќг‚‰§гƒ‰ўг„‰џг…Šг†Šг‡ŠгˆŠг‰ŠгŠŠг‹ŠгŒŠ гŠ гŽŠ гŠ гŠ г‘Šг’Šг“Šг”Šг•Šг–Šг—Šг˜Šг™ŠгšŠг›ŠгœŠгŠгžŠгŸŠг ŠгЁSpгЂ‚ёгЃj1гЄZtгЅžpгІ^”гЇ(гЈƒЙгЉ„$гЊ„%гЋƒgгЌ‡Gг­ЮгЎbгЏvШгА_qгБ˜–гВxlгГf гДTпгЕbхгЖOcгЗУгИuШгЙ^ИгК–ЭгЛŽ гМ†љгНTгОlѓгПmŒгРl8гС`гТRЧгУu(гФ^}гХOгЦ` гЧ_чгШ\$гЩu1гЪЎгЫ”РгЬrЙгЭlЙгЮn8гЯ‘Iгаg гбSЫгвSѓггOQгд‘Щге‹ёгжSШгз^|гиТгйmфгкNŽглvТгмi†гн†^гоaгп‚грOYгсOогт>гуœ|гфa гхnгцnгч–…гшNˆгщZ1гъ–шгыNгь\гэyЙгю[‡гя‹эг№Нгёs‰гђWпгѓ‚‹гєСгѕTгіGгїUЛгј\ъгљ_Ёгњaгћk2гќrёг§€ВгўŠ‰д@ŠдAŠдBŠ дCŠ!дDŠ"дEŠ#дFŠ$дGŠ%дHŠ&дIŠ'дJŠ(дKŠ)дLŠ*дMŠ+дNŠ,дOŠ-дPŠ.дQŠ/дRŠ0дSŠ1дTŠ2дUŠ3дVŠ4дWŠ5дXŠ6дYŠ7дZŠ8д[Š9д\Š:д]Š;д^Š<д_Š=д`Š?дaŠ@дbŠAдcŠBдdŠCдeŠDдfŠEдgŠFдhŠGдiŠIдjŠJдkŠKдlŠLдmŠMдnŠNдoŠOдpŠPдqŠQдrŠRдsŠSдtŠTдuŠUдvŠVдwŠWдxŠXдyŠYдzŠZд{Š[д|Š\д}Š]д~Š^д€Š_дŠ`д‚ŠaдƒŠbд„Šcд…Šdд†Šeд‡ŠfдˆŠgд‰ŠhдŠŠiд‹ŠjдŒŠkдŠlдŽŠmдŠnдŠoд‘Špд’Šqд“Šrд”Šsд•Štд–Šuд—Švд˜Šwд™ŠxдšŠzд›Š{дœŠ|дŠ}дžŠ~дŸŠд Š€дЁmtдЂ[гдЃˆе䪘„дЅŒkдІšmдЇž3дЈn дЉQЄдЊQCдЋWЃдЌˆд­SŸдЎcєдЏ•дАVэдБTXдВWдГs?дДnдЕдЖмдЗ‚бдИa?дЙ`(дК–bдЛf№дМ~ІдНŠдОУдП”ЅдР\ГдС|ЄдТgдУ`ІдФ–дХ€дЦN‘дЧчдШSдЩ–hдЪQAдЫадЬ…tдЭ‘]дЮfUдЯ—ѕда[UдбSдвx8дгgBддh=деTЩджp~дз[Ади}дйQдкW(длTБдмeднf‚до^дпCдрдс„lдтmду|пдфQџдх…ћдцgЃдчeщдшoЁдщ†ЄдъŽдыVjдь дэv‚дюpvдяqхд№#дёbщдђRдѓl§дє<дѕ`діXžдїaŽдјfўдљ`дњbNдћUГдќn#д§g-дўgе@ŠеAŠ‚еBŠƒеCŠ„еDŠ…еEŠ†еFŠ‡еGŠˆеHŠ‹еIŠŒеJŠеKŠŽеLŠеMŠеNŠ‘еOŠ’еPŠ”еQŠ•еRŠ–еSŠ—еTŠ˜еUŠ™еVŠšеWŠ›еXŠœеYŠеZŠžе[ŠŸе\Š е]ŠЁе^ŠЂе_ŠЃе`ŠЄеaŠЅеbŠІеcŠЇеdŠЈеeŠЉеfŠЊеgŠЋеhŠЌеiŠ­еjŠЎеkŠЏеlŠАеmŠБеnŠВеoŠГеpŠДеqŠЕеrŠЖеsŠЗеtŠИеuŠЙеvŠКеwŠЛеxŠМеyŠНеzŠОе{ŠПе|ŠРе}ŠСе~ŠТе€ŠУеŠФе‚ŠХеƒŠЦе„ŠЧе…ŠШе†ŠЩе‡ŠЪеˆŠЫе‰ŠЬеŠŠЭе‹ŠЮеŒŠЯеŠаеŽŠбеŠвеŠге‘Šде’Šее“Šже”Šзе•Šие–Šйе—Šке˜Šле™ŠмеšŠне›ŠоеœŠпеŠреžŠсеŸŠте ŠуеЁ”сеЂ•јеЃw(еЄhеЅiЈеІT‹еЇNMеЈpИеЉ‹ШеЊdXеЋe‹еЌ[…е­z„еЎP:еЏ[шеАwЛеБkсеВŠyеГ|˜еДlОеЕvЯеЖeЉеЗ—еИ]-еЙ\UеК†8еЛhеМS`еНbеОzйеПn[еР~§еСjеТzреУ_pеФo3еХ_ еЦcŒеЧmЈеШgVеЩNеЪ^еЫ&еЬNзеЭ€РеЮv4еЯ–œеаbлебf-евb~егlМедuееqgежiезQFе與ейSьекnелb˜емTђе톹ео™еп€ер•ес…етйеуmYефsЭехeŸецwечuешx'ещћеъеы”ˆеьOІеэg•еюuЙея‹Ъе№—еёc/еђ•Gеѓ–5еє„Иеѕc#еіwAеї_ејr№ељN‰ењ`ећetеќbяе§kcеўe?ж@ŠфжAŠхжBŠцжCŠчжDŠшжEŠщжFŠъжGŠыжHŠьжIŠэжJŠюжKŠяжLŠ№жMŠёжNŠђжOŠѓжPŠєжQŠѕжRŠіжSŠїжTŠјжUŠљжVŠњжWŠћжXŠќжYŠ§жZŠўж[Šџж\‹ж]‹ж^‹ж_‹ж`‹жa‹жb‹жc‹жd‹ жe‹ жf‹ жg‹ жh‹ жi‹жj‹жk‹жl‹жm‹жn‹жo‹жp‹жq‹жr‹жs‹жt‹жu‹жv‹жw‹жx‹жy‹жz‹ж{‹ ж|‹!ж}‹"ж~‹#戋$ж‹%ж‚‹'жƒ‹(ж„‹)ж…‹*憋+懋,жˆ‹-手.жŠ‹/ж‹‹0жŒ‹1ж‹2жŽ‹3ж‹4ж‹5ж‘‹6ж’‹7ж“‹8ж”‹9ж•‹:ж–‹;ж—‹<ж˜‹=ж™‹>жš‹?ж›‹@жœ‹Aж‹Bжž‹CжŸ‹Dж ‹EжЁ^'жЂuЧжЃбжЄ‹СжЅ‚жІgжЇe/жЈT1жЉ‡жЊwхжЋ€ЂжЌж­lAжЎNKжЏ~ЧжА€LжБvєжВi жГk–жДbgжЕP<жЖO„жЗW@жИcжЙkbжКОжЛSъжМeшжН~ИжО_зжПcжРcЗжСѓжТєжУnжФ^жХ\йжЦR6жЧfzжШyщжЩzжЪ(жЫp™жЬuджЭnожЮlЛжЯz’жаN-жбvХжв_ржг”Ÿждˆwже~ШжжyЭжз€Пжи‘ЭжйNђжкOжл‚жмThжн]ожоm2жп‹Ьжр|Ѕжсtжт€˜жу^жфT’жхvБжц[™жчf<жшšЄжщsржъh*жы†лжьg1жэs*жю‹јжя‹лж№жёzљжђpлжѓqnжєbФжѕwЉжіV1жїN;жј„WжљgёжњRЉжћ†Ржќ.槔јжў{Qз@‹FзA‹GзB‹HзC‹IзD‹JзE‹KзF‹LзG‹MзH‹NзI‹OзJ‹PзK‹QзL‹RзM‹SзN‹TзO‹UзP‹VзQ‹WзR‹XзS‹YзT‹ZзU‹[зV‹\зW‹]зX‹^зY‹_зZ‹`з[‹aз\‹bз]‹cз^‹dз_‹eз`‹gзa‹hзb‹iзc‹jзd‹kзe‹mзf‹nзg‹oзh‹pзi‹qзj‹rзk‹sзl‹tзm‹uзn‹vзo‹wзp‹xзq‹yзr‹zзs‹{зt‹|зu‹}зv‹~зw‹зx‹€зy‹зz‹‚з{‹ƒз|‹„з}‹…з~‹†з€‹‡з‹ˆз‚‹‰зƒ‹Šз„‹‹з…‹Œз†‹з‡‹Žзˆ‹з‰‹зŠ‹‘з‹‹’зŒ‹“з‹”зŽ‹•з‹–з‹—з‘‹˜з’‹™з“‹šз”‹›з•‹œз–‹з—‹žз˜‹Ÿз™‹Ќзš‹Бз›‹Лзœ‹Чз‹азž‹ъзŸŒ з ŒзЁOOзЂlшзЃy]зЄš{зЅb“зІr*зЇb§зЈNзЉxзЊlзЋdАзЌZз­{ЦзЎhiзЏ^„зАˆХзБY†зВdžзГXюзДrЖзЕiзЖ•%зЗ§зИXзЙW`зКзЛŒзМQЦзНcIзОbйзПSSзРhLзСt"зТƒзУ‘LзФUDзХw@зЦp|зЧmJзШQyзЩTЈзЪDзЫYџзЬnЫзЭmФзЮ[\зЯ}+заNдзб|}звnгзг[Pздъзеn зж[Wзз›зиhезйŽ*зк[—зл~ќзм`;зн~ЕзоЙзпpзрYOзсcЭзтyпзуГзфSRзхeЯзцyVзч‹Хзш–;зщ~Фзъ”Лзы~‚зьV4зэ‘‰зюgзяjз№\ зёuзђf(зѓ]цзєOPзѕgозіPZзїO\зјWPзљ^Їи@Œ8иAŒ9иBŒ:иCŒ;иDŒ<иEŒ=иFŒ>иGŒ?иHŒ@иIŒBиJŒCиKŒDиLŒEиMŒHиNŒJиOŒKиPŒMиQŒNиRŒOиSŒPиTŒQиUŒRиVŒSиWŒTиXŒVиYŒWиZŒXи[ŒYи\Œ[и]Œ\и^Œ]и_Œ^и`Œ_иaŒ`иbŒcиcŒdиdŒeиeŒfиfŒgиgŒhиhŒiиiŒlиjŒmиkŒnиlŒoиmŒpиnŒqиoŒrиpŒtиqŒuиrŒvиsŒwиtŒ{иuŒ|иvŒ}иwŒ~иxŒиyŒ€иzŒи{Œƒи|Œ„и}Œ†и~Œ‡и€ŒˆиŒ‹и‚ŒиƒŒŽи„Œи…Œи†Œ‘и‡Œ’иˆŒ“и‰Œ•иŠŒ–и‹Œ—иŒŒ™иŒšиŽŒ›иŒœиŒи‘Œžи’ŒŸи“Œ и”ŒЁи•ŒЂи–ŒЃи—ŒЄи˜ŒЅи™ŒІиšŒЇи›ŒЈиœŒЉиŒЊиžŒЋиŸŒЌи Œ­иЁNиЂN иЃQ@иЄNиЅ^џиІSEиЇNиЈN˜иЉNиЊ›2иЋ[lиЌViи­N(иЎyКиЏN?иАSиБNGиВY-иГr;иДSnиЕlиЖVпиЗ€фиИ™—иЙkгиКw~иЛŸиМN6иНNŸиОŸиПN\иРNiиСN“иТ‚ˆиУ[[иФUlиХVиЦNФиЧSиШSиЩSЃиЪSЅиЫSЎиЬ—eиЭ]иЮSиЯSѕиаS&ибS.ивS>иг\идSfиеScижRизRииRийR-икR3илR?имR@инRLиоR^ипRaирR\ис„ЏитR}иуR‚ифRихRицR“ичQ‚ишTищNЛиъNУиыNЩиьNТиэNшиюNсияNыи№NоиёOиђNѓиѓO"иєOdиѕNѕиіO%иїO'ијO иљO+ињO^ићOgиќe8и§OZиўO]й@ŒЎйAŒЏйBŒАйCŒБйDŒВйEŒГйFŒДйGŒЕйHŒЖйIŒЗйJŒИйKŒЙйLŒКйMŒЛйNŒМйOŒНйPŒОйQŒПйRŒРйSŒСйTŒТйUŒУйVŒФйWŒХйXŒЦйYŒЧйZŒШй[ŒЩй\ŒЪй]ŒЫй^ŒЬй_ŒЭй`ŒЮйaŒЯйbŒайcŒбйdŒвйeŒгйfŒдйgŒейhŒжйiŒзйjŒийkŒййlŒкйmŒлйnŒмйoŒнйpŒойqŒпйrŒрйsŒсйtŒтйuŒуйvŒфйwŒхйxŒцйyŒчйzŒшй{Œщй|Œъй}Œый~Œьй€ŒэйŒюй‚ŒяйƒŒ№й„Œёй…Œђй†Œѓй‡ŒєйˆŒѕй‰ŒійŠŒїй‹ŒјйŒŒљйŒњйŽŒћйŒќйŒ§й‘Œўй’Œџй“й”й•й–й—й˜й™йšй›йœ й йž йŸ й  йЁO_йЂOWйЃO2йЄO=йЅOvйІOtйЇO‘йЈO‰йЉOƒйЊOйЋO~йЌO{й­OЊйЎO|йЏOЌйАO”йБOцйВOшйГOъйДOХйЕOкйЖOуйЗOмйИOбйЙOпйКOјйЛP)йМPLйНOѓйОP,йПPйРP.йСP-йТOўйУPйФP йХP%йЦP(йЧP~йШPCйЩPUйЪPHйЫPNйЬPlйЭP{йЮPЅйЯPЇйаPЉйбPКйвPжйгQйдPэйеPьйжPцйзPюйиQййQ йкNнйлl=ймOXйнOeйоOЮйпŸ йрlFйс|tйтQnйу]§йфžЩйх™˜йцQйчYйшRљйщS йъŠйыSйьQыйэYйюQUйяN й№QVйёNГйђˆnйѓˆЄйєNЕйѕйіˆвйїy€йј[4йљˆйњИйћQЋйќQБй§QНйўQМк@кAкBкCкDкEкFкGкHкIкJкKкLкMкNкO кPQкQRкRWкS_кTeкUhкViкWjкXlкYnкZoк[qк\rк]xк^yк_zк`{кa|кb}кc~кdкe€кf‚кgƒкh†кi‡кjˆкk‰кlŒкmкnŽкoкpкq’кr“кs•кt–кu—кv˜кw™кxšкy›кzœк{к|žк} к~Ёк€ЂкЄк‚ЅкƒІк„Їк…Јк†Љк‡ЊкˆЋк‰ЌкŠ­к‹ЎкŒЏкАкŽВкЖкЗк‘Йк’Лк“Нк”Рк•Ск–Тк—Хк˜Чк™ШкšЩк›ЪкœЭкакžвкŸгк дкЁQЧкЂQ–кЃQЂкЄQЅкЅ‹ кІ‹ІкЇ‹ЇкЈ‹ЊкЉ‹ДкЊ‹ЕкЋ‹ЗкЌ‹Тк­‹УкЎ‹ЫкЏ‹ЯкА‹ЮкБ‹вкВ‹гкГ‹дкД‹жкЕ‹икЖ‹йкЗ‹мкИ‹пкЙ‹ркК‹фкЛ‹шкМ‹щкН‹юкО‹№кП‹ѓкР‹ікС‹љкТ‹ќкУ‹џкФŒкХŒкЦŒкЧŒкШŒ кЩŒкЪŒкЫŒкЬŒкЭŒкЮŒкЯŒкаŒкбŒквŒкгŒкдŒ кеŒ!кжŒ%кзŒ'киŒ*кйŒ+ккŒ.клŒ/кмŒ2кнŒ3коŒ5кпŒ6крSiксSzкт–ку–"кф–!кх–1кц–*кч–=кш–<кщ–Bкъ–Iкы–Tкь–_кэ–gкю–lкя–rк№–tкё–ˆкђ–кѓ–—кє–Акѕ—кі›кїкј™кљЌкњЁкћДкќГк§ЖкўКл@елAилBйлCмлDрлEслFтлGхлHцлIчлJщлKэлLюлM№лNёлOђлPєлQілRќлSўлTџлUŽлVŽлWŽлXŽлYŽлZŽл[Žл\Žл]Ž л^Ž л_Žл`ŽлaŽлbŽлcŽлdŽлeŽлfŽлgŽлhŽлiŽлjŽлkŽлlŽ лmŽ!лnŽ$лoŽ%лpŽ&лqŽ'лrŽ(лsŽ+лtŽ-лuŽ0лvŽ2лwŽ3лxŽ4лyŽ6лzŽ7л{Ž8л|Ž;л}Ž<л~Ž>л€Ž?лŽCл‚ŽEлƒŽFл„ŽLл…ŽMл†ŽNл‡ŽOлˆŽPл‰ŽSлŠŽTл‹ŽUлŒŽVлŽWлŽŽXлŽZлŽ[л‘Ž\л’Ž]л“Ž^л”Ž_л•Ž`л–Žaл—Žbл˜Žcл™ŽdлšŽeл›ŽgлœŽhлŽjлžŽkлŸŽnл ŽqлЁИлЂАлЃЯлЄХлЅОлІалЇФлЈЧлЉглЊцлЋтлЌмл­злЎллЏылАялБўлВ‘лГ‘"лД‘лЕ‘#лЖ‘1лЗ‘/лИ‘9лЙ‘CлК‘FлЛR лМYBлНRЂлОRЌлПR­лРRОлСTџлТRалУRжлФR№лХSплЦqюлЧwЭлШ^єлЩQѕлЪQќлЫ›/лЬSЖлЭ_лЮuZлЯ]ялаWLлбWЉлвWЁлгX~лдXМлеXХлжXблзW)лиW,лйW*лкW3ллW9лмW.лнW/лоW\лпW;лрWBлсWiлтW…луWkлфW†лхW|лцW{лчWhлшWmлщWvлъWsлыW­льWЄлэWŒлюWВляWЯл№WЇлёWДлђW“лѓW лєWелѕWиліWклїWйлјWвлљWИлњWєлћWялќWјл§WфлўWнм@ŽsмAŽuмBŽwмCŽxмDŽyмEŽzмFŽ{мGŽ}мHŽ~мIŽ€мJŽ‚мKŽƒмLŽ„мMŽ†мNŽˆмOŽ‰мPŽŠмQŽ‹мRŽŒмSŽмTŽŽмUŽ‘мVŽ’мWŽ“мXŽ•мYŽ–мZŽ—м[Ž˜м\Ž™м]Žšм^Ž›м_Žм`ŽŸмaŽ мbŽЁмcŽЂмdŽЃмeŽЄмfŽЅмgŽІмhŽЇмiŽЈмjŽЉмkŽЊмlŽ­мmŽЎмnŽАмoŽБмpŽГмqŽДмrŽЕмsŽЖмtŽЗмuŽИмvŽЙмwŽЛмxŽМмyŽНмzŽОм{ŽПм|ŽРм}ŽСм~ŽТм€ŽУмŽФм‚ŽХмƒŽЦм„ŽЧм…ŽШм†ŽЩм‡ŽЪмˆŽЫм‰ŽЬмŠŽЭм‹ŽЯмŒŽамŽбмŽŽвмŽгмŽдм‘Žем’Žжм“Žзм”Žим•Žйм–Žкм—Žлм˜Žмм™ŽнмšŽом›ŽпмœŽрмŽсмžŽтмŸŽум ŽфмЁX мЂX мЃW§мЄWэмЅXмІXмЇXмЈXDмЉX мЊXeмЋXlмЌXм­X‰мЎXšмЏX€мА™ЈмБŸмВaџмГ‚yмД‚}мЕ‚мЖ‚мЗ‚ŠмИ‚ЈмЙ‚„мК‚ŽмЛ‚‘мМ‚—мН‚™мО‚ЋмП‚ИмР‚ОмС‚АмТ‚ШмУ‚ЪмФ‚умХ‚˜мЦ‚ЗмЧ‚ЎмШ‚ЫмЩ‚ЬмЪ‚СмЫ‚ЉмЬ‚ДмЭ‚ЁмЮ‚ЊмЯ‚Ÿма‚Фмб‚Юмв‚Ємг‚смдƒ ме‚їмж‚фмзƒмиƒмй‚ммк‚ємл‚вмм‚имнƒ мо‚ћмп‚гмрƒмсƒмтƒмуƒмфƒмх‚рмц‚емчƒмшƒQмщƒ[мъƒ\мыƒмьƒ’мэƒ<мюƒ4мяƒ1м№ƒ›мёƒ^мђƒ/мѓƒOмєƒGмѕƒCміƒ_мїƒ@мјƒмљƒ`мњƒ-мћƒ:мќƒ3м§ƒfмўƒeн@ŽхнAŽцнBŽчнCŽшнDŽщнEŽънFŽынGŽьнHŽэнIŽюнJŽянKŽ№нLŽёнMŽђнNŽѓнOŽєнPŽѕнQŽінRŽїнSŽјнTŽљнUŽњнVŽћнWŽќнXŽ§нYŽўнZŽџн[н\н]н^н_н`нaнbнcнd нe нf нg нh нiнjнkнlнmнnнoнpнqнrнsнtнuнvнwнxнyнzн{ н|!н}"н~#н€$н%н‚&нƒ'н„(н…)н†*н‡+нˆ,н‰-нŠ.н‹/нŒ0н1нŽ2н3н4н‘5н’6н“7н”8н•9н–:н—;н˜<н™=нš>н›?нœ@нAнžBнŸCн DнЁƒhнЂƒнЃƒiнЄƒlнЅƒjнІƒmнЇƒnнЈƒАнЉƒxнЊƒГнЋƒДнЌƒ н­ƒЊнЎƒ“нЏƒœнАƒ…нБƒ|нВƒЖнГƒЉнДƒ}нЕƒИнЖƒ{нЗƒ˜нИƒžнЙƒЈнКƒКнЛƒМнМƒСнН„нОƒхнПƒинРXнС„нТ„ нУƒннФƒ§нХƒжнЦ„нЧ„8нШ„нЩ„нЪƒднЫƒпнЬ„нЭ„нЮƒјнЯƒљнаƒънбƒХнвƒРнг„&ндƒ№неƒснж„\нз„Qни„Zнй„Yнк„sн넇нм„ˆнн„zннп„xнр„<нс„Fнт„iну„vнф„Œнх„Žнц„1нч„mнш„Снщ„Энъ„аны„цнь„Ннэ„гню„Ъня„Пн№„Кнё„рнђ„Ёнѓ„Йнє„Днѕ„—ні„хнї„унј… нљu нњ…8нћ„№нќ…9н§…нў…:о@EоAFоBGоCHоDIоEJоFKоGLоHMоINоJOоKPоLQоMRоNSоOTоPUоQVоRWоSXоTYоUZоV[оW\оX]оY^оZ_о[`о\aо]bо^cо_dо`eоajоb€оcŒоd’оeоf оgЁоhЂоiЄоjЅоkІоlЇоmЊоnЌоo­оpЎоqЏоrВоsГоtДоuЕоvЗоwИоxКоyЛоzМо{По|Ро}Уо~Цо€ЩоЪо‚ЫоƒЬо„Эо…Яо†во‡жоˆзо‰коŠро‹соŒуочоŽьояоёо‘ђо’єо“ѕо”іо•њо–ћо—ќо˜ўо™џоšо›оœ ооžоŸо оЁ…VоЂ…;оЃ„џоЄ„ќоЅ…YоІ…HоЇ…hоЈ…dоЉ…^оЊ…zоЋwЂоЌ…Cо­…rоЎ…{оЏ…ЄоА…ЈоБ…‡оВ…оГ…yоД…ЎоЕ…œоЖ……оЗ…ЙоИ…ЗоЙ…АоК…гоЛ…СоМ…моН…џоО†'оП†оР†)оС†оТ†<оУ^ўоФ_оХY<оЦYAоЧ€7оШYUоЩYZоЪYXоЫSоЬ\"оЭ\%оЮ\,оЯ\4оаbLобbjовbŸогbЛодbЪоеbкожbзозbюоиc"ойbіокc9олcKомcCонc­ооcіопcqорczосcŽотcДоуcmофcЌохcŠоцciочcЎошcМощcђоъcјоыcроьcџоэcФоюcоояcЮо№dRоёcЦођcОоѓdEоєdAоѕd оіdоїd ојd ољd&оњd!оћd^оќd„о§dmоўd–п@пAпB#пC$пD%пE'пF(пG)пH*пI+пJ,пK0пL1пM2пN3пO4пP7пQ9пR:пS=пT?пU@пVCпWEпXFпYHпZIп[Jп\Kп]Lп^Nп_Tп`UпaVпbYпcZпd\пe]пf^пg_пh`пiaпjdпkfпlgпmiпnjпokпplпqoпrpпsqпtrпusпvvпwwпxxпyyпzzп{{п||п}~п~п€„п…п‚†пƒ‡п„‰п…Šп†Œп‡пˆŽп‰пŠп‹’пŒ”п–пŽ˜пšпœп‘žп’Ÿп“ п”Єп•Ѕп–Їп—Јп˜Љп™Ћпš­п›ВпœЗпМпžНпŸПп РпЁdzпЂdЗпЃdИпЄd™пЅdКпІdРпЇdапЈdзпЉdфпЊdтпЋe пЌe%п­e.пЎ_ пЏ_впАuпБ_пВS_пГSёпДS§пЕSщпЖSшпЗSћпИTпЙTпКTпЛTKпМTRпНTSпОTTпПTVпРTCпСT!пТTWпУTYпФT#пХT2пЦT‚пЧT”пШTwпЩTqпЪTdпЫTšпЬT›пЭT„пЮTvпЯTfпаTпбTапвT­пгTТпдTДпеTвпжTЇпзTІпиTгпйTдпкTrплTЃпмTепнTЛпоTПппTЬпрTйпсTкптTмпуTЉпфTЊпхTЄпцTнпчTЯпшTопщUпъTчпыU пьT§пэUпюTѓпяU"п№U#пёUпђUпѓU'пєU*пѕUgпіUпїUЕпјUIпљUmпњUAпћUUпќU?п§UPпўU<р@ТрAУрBЦрCШрDЩрEЫрFЬрGЭрHврIдрJерKжрLирMйрNкрOорPпрQррRурSфрTхрUщрVърWьрXюрY№рZёр[ђр\ѓр]ѕр^ір_їр`љрaњрbћрcќрdџрe‘рf‘рg‘рh‘рi‘рj‘рk‘рl‘ рm‘ рn‘ рo‘ рp‘ рq‘рr‘рs‘рt‘рu‘рv‘рw‘рx‘рy‘рz‘р{‘р|‘р}‘р~‘р€‘р‘р‚‘ рƒ‘!р„‘$р…‘%р†‘&р‡‘'рˆ‘(р‰‘)рŠ‘*р‹‘+рŒ‘,р‘-рŽ‘.р‘0р‘2р‘‘3р’‘4р“‘5р”‘6р•‘7р–‘8р—‘:р˜‘;р™‘<рš‘=р›‘>рœ‘?р‘@рž‘AрŸ‘Bр ‘DрЁU7рЂUVрЃUuрЄUvрЅUwрІU3рЇU0рЈU\рЉU‹рЊUврЋUƒрЌUБр­UЙрЎUˆрЏUрАUŸрБU~рВUжрГU‘рДU{рЕUпрЖUНрЗUОрИU”рЙU™рКUърЛUїрМUЩрНVрОUбрПUырРUьрСUдрТUцрУUнрФUФрХUярЦUхрЧUђрШUѓрЩUЬрЪUЭрЫUшрЬUѕрЭUфрЮ”рЯVраVрбV рвVргV$рдV#реUўржVрзV'риV-рйVXркV9рлVWрмV,рнVMроVbрпVYррV\рсVLртVTруV†рфVdрхVqрцVkрчV{ршV|рщV…ръV“рыVЏрьVдрэVзрюVнряVср№VѕрёVырђVљрѓVџрєWрѕW ріW рїWрј^рљ^рњ^рћ^рќ^1р§^;рў^<с@‘EсA‘GсB‘HсC‘QсD‘SсE‘TсF‘UсG‘VсH‘XсI‘YсJ‘[сK‘\сL‘_сM‘`сN‘fсO‘gсP‘hсQ‘kсR‘mсS‘sсT‘zсU‘{сV‘|сW‘€сX‘сY‘‚сZ‘ƒс[‘„с\‘†с]‘ˆс^‘Šс_‘Žс`‘сa‘“сb‘”сc‘•сd‘–сe‘—сf‘˜сg‘™сh‘œсi‘сj‘žсk‘Ÿсl‘ сm‘Ёсn‘Єсo‘Ѕсp‘Ісq‘Їсr‘Јсs‘Љсt‘Ћсu‘Ќсv‘Асw‘Бсx‘Всy‘Гсz‘Жс{‘Зс|‘Ис}‘Йс~‘Лс€‘Мс‘Нс‚‘Осƒ‘Пс„‘Рс…‘Сс†‘Тс‡‘Усˆ‘Фс‰‘ХсŠ‘Цс‹‘ШсŒ‘Ыс‘асŽ‘вс‘гс‘дс‘‘ес’‘жс“‘зс”‘ис•‘йс–‘кс—‘лс˜‘нс™‘осš‘пс›‘рсœ‘сс‘тсž‘усŸ‘фс ‘хсЁ^7сЂ^DсЃ^TсЄ^[сЅ^^сІ^aсЇ\ŒсЈ\zсЉ\сЊ\сЋ\–сЌ\ˆс­\˜сЎ\™сЏ\‘сА\šсБ\œсВ\ЕсГ\ЂсД\НсЕ\ЌсЖ\ЋсЗ\БсИ\ЃсЙ\СсК\ЗсЛ\ФсМ\всН\фсО\ЫсП\хсР]сС]сТ]'сУ]&сФ].сХ]$сЦ]сЧ]сШ]сЩ]XсЪ]>сЫ]4сЬ]=сЭ]lсЮ][сЯ]oса]]сб]kсв]Kсг]Jсд]iсе]tсж]‚сз]™си]сйŒsск]Зсл]Хсм_sсн_wсо_‚сп_‡ср_‰сс_Œст_•су_™сф_œсх_Јсц_­сч_Есш_Мсщˆbсъ_aсыr­сьrАсэrДсюrЗсяrИс№rУсёrСсђrЮсѓrЭсєrвсѕrшсіrясїrщсјrђсљrєсњrїсћsсќrѓс§sсўrњт@‘цтA‘чтB‘штC‘щтD‘ътE‘ытF‘ьтG‘этH‘ютI‘ятJ‘№тK‘ётL‘ђтM‘ѓтN‘єтO‘ѕтP‘ітQ‘їтR‘јтS‘љтT‘њтU‘ћтV‘ќтW‘§тX‘ўтY‘џтZ’т[’т\’т]’т^’т_’т`’тa’тb’тc’ тd’ тe’ тf’ тg’ тh’тi’тj’тk’тl’тm’тn’тo’тp’тq’тr’тs’тt’тu’тv’тw’тx’тy’тz’ т{’!т|’"т}’#т~’$т€’%т’&т‚’'тƒ’(т„’)т…’*т†’+т‡’,тˆ’-т‰’.тŠ’/т‹’0тŒ’1т’2тŽ’3т’4т’5т‘’6т’’7т“’8т”’9т•’:т–’;т—’<т˜’=т™’>тš’?т›’@тœ’Aт’Bтž’CтŸ’Dт ’EтЁrћтЂsтЃsтЄs!тЅs тІsтЇsтЈsтЉs"тЊs9тЋs%тЌs,т­s8тЎs1тЏsPтАsMтБsWтВs`тГslтДsoтЕs~тЖ‚тЗY%тȘчтЙY$тКYтЛ™cтМ™gтН™hтО™iтП™jтР™kтС™lтТ™tтУ™wтФ™}тХ™€тЦ™„тЧ™‡тШ™ŠтЩ™тЪ™тЫ™‘тЬ™“тЭ™”тЮ™•тЯ^€та^‘тб^‹тв^–тг^Ѕтд^ те^Йтж^Етз^Оти^ГтйSтк^втл^бтм^лтн^што^ътпКтр_Фтс_Щтт_жту_Ятф`тх_ютц`тч_стш_фтщ_ўтъ`ты`ть_ътэ_этю_јтя`т№`5тё`&тђ`тѓ`тє` тѕ`)ті`+тї` тј`?тљ`!тњ`xтћ`yтќ`{т§`zтў`Bу@’FуA’GуB’HуC’IуD’JуE’KуF’LуG’MуH’NуI’OуJ’PуK’QуL’RуM’SуN’TуO’UуP’VуQ’WуR’XуS’YуT’ZуU’[уV’\уW’]уX’^уY’_уZ’`у[’aу\’bу]’cу^’dу_’eу`’fуa’gуb’hуc’iуd’jуe’kуf’lуg’mуh’nуi’oуj’pуk’qуl’rуm’sуn’uуo’vуp’wуq’xуr’yуs’zуt’{уu’|уv’}уw’~уx’уy’€уz’у{’‚у|’ƒу}’„у~’…у€’†у’‡у‚’ˆуƒ’‰у„’Šу…’‹у†’Œу‡’уˆ’у‰’уŠ’‘у‹’’уŒ’“у’”уŽ’•у’–у’—у‘’˜у’’™у“’šу”’›у•’œу–’у—’žу˜’Ÿу™’ уš’Ёу›’Ђуœ’Ѓу’Єуž’ЅуŸ’Іу ’ЇуЁ`jуЂ`}уЃ`–уЄ`šуЅ`­уІ`уЇ`ƒуЈ`’уЉ`ŒуЊ`›уЋ`ьуЌ`Лу­`БуЎ`нуЏ`иуА`ЦуБ`куВ`ДуГa уДa&уЕaуЖa#уЗ`єуИaуЙaуКa+уЛaJуМauуНaЌуОa”уПaЇуРaЗуСaдуТaѕуУ_нуФ–ГуХ•щуЦ•ыуЧ•ёуШ•ѓуЩ•ѕуЪ•іуЫ•ќуЬ•ўуЭ–уЮ–уЯ–уа–уб– ув– уг– уд– уе–уж–уз–уи–уй–ук–ул–умN,унr?уоbупl5урlTусl\утlJууlЃуфl…ухlуцl”учlŒушlhущliуъltуыlvуьl†уэlЉуюlауяlду№l­уёlїуђlјуѓlёуєlзуѕlВуіlруїlжујlњуљlыуњlюућlБуќlгу§lяуўlўф@’ЈфA’ЉфB’ЊфC’ЋфD’ЌфE’­фF’ЏфG’АфH’БфI’ВфJ’ГфK’ДфL’ЕфM’ЖфN’ЗфO’ИфP’ЙфQ’КфR’ЛфS’МфT’НфU’ОфV’ПфW’РфX’СфY’ТфZ’Уф[’Фф\’Хф]’Цф^’Чф_’Щф`’Ъфa’Ыфb’Ьфc’Эфd’Юфe’Яфf’афg’бфh’вфi’гфj’дфk’ефl’жфm’зфn’ифo’йфp’кфq’лфr’мфs’нфt’офu’пфv’рфw’сфx’тфy’уфz’фф{’хф|’цф}’чф~’шф€’щф’ъф‚’ыфƒ’ьф„’эф…’юф†’яф‡’№фˆ’ёф‰’ђфŠ’ѓф‹’єфŒ’ѕф’іфŽ’їф’јф’љф‘’њф’’ћф“’ќф”’§ф•’ўф–’џф—“ф˜“ф™“фš“ф›“фœ“ф“фž“фŸ“ф “ фЁm9фЂm'фЃm фЄmCфЅmHфІmфЇmфЈmфЉmфЊm+фЋmMфЌm.ф­m5фЎmфЏmOфАmRфБmTфВm3фГm‘фДmoфЕmžфЖm фЗm^фИm“фЙm”фКm\фЛm`фМm|фНmcфОnфПmЧфРmХфСmофТnфУmПфФmрфХnфЦmцфЧmнфШmйфЩnфЪmЋфЫn фЬmЎфЭn+фЮnnфЯnNфаnkфбnВфвn_фгn†фдnSфеnTфжn2фзn%фиnDфйnпфкnБфлn˜фмnрфнo-фоnтфпnЅфрnЇфсnНфтnЛфуnЗффnзфхnДфцnЯфчnфшnТфщnŸфъobфыoFфьoGфэo$фюoфяnљф№o/фёo6фђoKфѓotфєo*фѕo фіo)фїo‰фјoфљoŒфњoxфћorфќo|ф§ozфўoбх@“ хA“ хB“ хC“ хD“хE“хF“хG“хH“хI“хJ“хK“хL“хM“хN“хO“хP“хQ“хR“хS“хT“хU“хV“ хW“!хX“"хY“#хZ“$х[“%х\“&х]“'х^“(х_“)х`“*хa“+хb“,хc“-хd“.хe“/хf“0хg“1хh“2хi“3хj“4хk“5хl“6хm“7хn“8хo“9хp“:хq“;хr“<хs“=хt“?хu“@хv“Aхw“Bхx“Cхy“Dхz“Eх{“Fх|“Gх}“Hх~“Iх€“Jх“Kх‚“Lхƒ“Mх„“Nх…“Oх†“Pх‡“Qхˆ“Rх‰“SхŠ“Tх‹“UхŒ“Vх“WхŽ“Xх“Yх“Zх‘“[х’“\х““]х”“^х•“_х–“`х—“aх˜“bх™“cхš“dх›“eхœ“fх“gхž“hхŸ“iх “kхЁoЩхЂoЇхЃoЙхЄoЖхЅoТхІoсхЇoюхЈoохЉoрхЊoяхЋpхЌp#х­pхЎp9хЏp5хАpOхБp^хВ[€хГ[„хД[•хЕ[“хЖ[ЅхЗ[ИхИu/хЙšžхКd4хЛ[фхМ[юхН‰0хО[№хПŽGхР‹хСЖхТгхУехФххХюхЦфхЧщхШцхЩѓхЪшхЫхЬхЭ хЮ&хЯха хбхв!хг5хд6хе-хж/хзDхиQхйRхкPхлhхмXхнbхо[хпfЙхрtхс}хт‚хуˆхфƒхх‹хц_Pхч_Wхш_Vхщ_Xхъ\;хыTЋхь\Pхэ\Yхю[qхя\cх№\fхёМхђ_*хѓ_)хє_-хѕ‚tхі_<хї›;хј\nхљYхњYƒхћYхќYЉх§YЊхўYЃц@“lцA“mцB“nцC“oцD“pцE“qцF“rцG“sцH“tцI“uцJ“vцK“wцL“xцM“yцN“zцO“{цP“|цQ“}цR“~цS“цT“€цU“цV“‚цW“ƒцX“„цY“…цZ“†ц[“‡ц\“ˆц]“‰ц^“Šц_“‹ц`“Œцa“цb“Žцc“цd“‘цe“’цf““цg“”цh“•цi“–цj“—цk“˜цl“™цm“šцn“›цo“œцp“цq“žцr“Ÿцs“ цt“Ёцu“Ђцv“Ѓцw“Єцx“Ѕцy“Іцz“Їц{“Јц|“Љц}“Њц~“Ћц€“Ќц“­ц‚“Ўцƒ“Џц„“Ац…“Бц†“Вц‡“Гцˆ“Дц‰“ЕцŠ“Жц‹“ЗцŒ“Иц“ЙцŽ“Кц“Лц“Мц‘“Нц’“Оц““Пц”“Рц•“Сц–“Тц—“Уц˜“Фц™“Хцš“Цц›“Чцœ“Шц“Щцž“ЫцŸ“Ьц “ЭцЁY—цЂYЪцЃYЋцЄYžцЅYЄцІYвцЇYВцЈYЏцЉYзцЊYОцЋZцЌZц­YнцЎZцЏYуцАYицБYљцВZ цГZ цДZ2цЕZ4цЖZцЗZ#цИZцЙZ@цКZgцЛZJцМZUцНZ<цОZbцПZuцР€ьцСZЊцТZ›цУZwцФZzцХZОцЦZыцЧZВцШZвцЩZдцЪZИцЫZрцЬZуцЭZёцЮZжцЯZццаZицбZмцв[ цг[цд[це[2цж[7цз[@ци\цй\цк[Zцл[eцм[sцн[Qцо[Sцп[bцрšuцсšwцтšxцуšzцфšцхš}ццš€цчšцшš…цщšˆцъšŠцыšцьš’цэš“цюš–цяš˜ц№š›цёšœцђšцѓšŸцєš цѕšЂціšЃцїšЅцјšЇцљ~Ÿцњ~Ёцћ~Ѓцќ~Ѕц§~Јцў~Љч@“ЮчA“ЯчB“ачC“бчD“вчE“гчF“дчG“ечH“зчI“ичJ“йчK“кчL“лчM“мчN“нчO“очP“пчQ“рчR“счS“тчT“учU“фчV“хчW“цчX“ччY“шчZ“щч[“ъч\“ыч]“ьч^“эч_“юч`“ячa“№чb“ёчc“ђчd“ѓчe“єчf“ѕчg“ічh“їчi“јчj“љчk“њчl“ћчm“ќчn“§чo“ўчp“џчq”чr”чs”чt”чu”чv”чw”чx”чy”чz” ч{” ч|” ч}” ч~” ч€”ч”ч‚”чƒ”ч„”ч…”ч†”ч‡”чˆ”ч‰”чŠ”ч‹”чŒ”ч”чŽ”ч”ч”ч‘”ч’” ч“”!ч””"ч•”#ч–”$ч—”%ч˜”&ч™”'чš”(ч›”)чœ”*ч”+чž”,чŸ”-ч ”.чЁ~­чЂ~АчЃ~ОчЄ~РчЅ~СчІ~ТчЇ~ЩчЈ~ЫчЉ~ЬчЊ~ачЋ~дчЌ~зч­~лчЎ~рчЏ~счА~шчБ~ычВ~ючГ~ячД~ёчЕ~ђчЖ чЗ~ічИ~њчЙ~ћчК~ўчЛчМчНчОчПчР чС чТчУчФчХчЦчЧчШчЩчЪ!чЫ"чЬ#чЭ$чЮ%чЯ&ча'чб*чв+чг,чд-че/чж0чз1чи2чй3чк5чл^zчмuчн]лчоu>чп•чрsŽчсs‘чтsЎчуsЂчфsŸчхsЯчцsТччsбчшsЗчщsГчъsРчыsЩчьsШчэsхчюsйчя˜|ч№t чёsщчђsччѓsочєsКчѕsђчіtчїt*чјt[чљt&чњt%чћt(чќt0ч§t.чўt,ш@”/шA”0шB”1шC”2шD”3шE”4шF”5шG”6шH”7шI”8шJ”9шK”:шL”;шM”<шN”=шO”?шP”@шQ”AшR”BшS”CшT”DшU”EшV”FшW”GшX”HшY”IшZ”Jш[”Kш\”Lш]”Mш^”Nш_”Oш`”Pшa”Qшb”Rшc”Sшd”Tшe”Uшf”Vшg”Wшh”Xшi”Yшj”Zшk”[шl”\шm”]шn”^шo”_шp”`шq”aшr”bшs”cшt”dшu”eшv”fшw”gшx”hшy”iшz”jш{”lш|”mш}”nш~”oш€”pш”qш‚”rшƒ”sш„”tш…”uш†”vш‡”wшˆ”xш‰”yшŠ”zш‹”{шŒ”|ш”}шŽ”~ш”ш”€ш‘”ш’”‚ш“”ƒш””„ш•”‘ш–”–ш—”˜ш˜”Чш™”Яшš”гш›”дшœ”кш”цшž”ћшŸ•ш • шЁtшЂtшЃtAшЄt\шЅtWшІtUшЇtYшЈtwшЉtmшЊt~шЋtœшЌtŽш­t€шЎtшЏt‡шАt‹шБtžшВtЈшГtЉшДtшЕtЇшЖtвшЗtКшИ—ъшЙ—ышК—ьшЛgLшМgSшНg^шОgHшПgiшРgЅшСg‡шТgjшУgsшФg˜шХgЇшЦguшЧgЈшШgžшЩg­шЪg‹шЫgwшЬg|шЭg№шЮh шЯgишаh шбgщшвgАшгh шдgйшеgЕшжgкшзgГшиgншйhшкgУшлgИшмgтшнhшоgСшпg§шрh2шсh3штh`шуhaшфhNшхhbшцhDшчhdшшhƒшщhшъhUшыhfшьhAшэhgшюh@шяh>ш№hJшёhIшђh)шѓhЕшєhшѕhtшіhwшїh“шјhkшљhТшњinшћhќшќiш§i шўhљщ@•'щA•3щB•=щC•CщD•HщE•KщF•UщG•ZщH•`щI•nщJ•tщK•uщL•wщM•xщN•yщO•zщP•{щQ•|щR•}щS•~щT•€щU•щV•‚щW•ƒщX•„щY•…щZ•†щ[•‡щ\•ˆщ]•‰щ^•Šщ_•‹щ`•Œщa•щb•Žщc•щd•щe•‘щf•’щg•“щh•”щi••щj•–щk•—щl•˜щm•™щn•šщo•›щp•œщq•щr•žщs•Ÿщt• щu•Ёщv•Ђщw•Ѓщx•Єщy•Ѕщz•Іщ{•Їщ|•Јщ}•Љщ~•Њщ€•Ћщ•Ќщ‚•­щƒ•Ўщ„•Џщ…•Ащ†•Бщ‡•Вщˆ•Гщ‰•ДщŠ•Ещ‹•ЖщŒ•Зщ•ИщŽ•Йщ•Кщ•Лщ‘•Мщ’•Нщ“•Ощ”•Пщ••Рщ–•Сщ—•Тщ˜•Ущ™•Фщš•Хщ›•Цщœ•Чщ•Шщž•ЩщŸ•Ъщ •ЫщЁi$щЂh№щЃi щЄiщЅiWщІhущЇiщЈiqщЉi9щЊi`щЋiBщЌi]щ­i„щЎikщЏi€щАi˜щБixщВi4щГiЬщДi‡щЕiˆщЖiЮщЗi‰щИifщЙicщКiyщЛi›щМiЇщНiЛщОiЋщПi­щРiдщСiБщТiСщУiЪщФiпщХi•щЦiрщЧiщШiџщЩj/щЪiэщЫjщЬjщЭjeщЮiђщЯjDщаj>щбj щвjPщгj[щдj5щеjŽщжjyщзj=щиj(щйjXщкj|щлj‘щмjщнjЉщоj—щпjЋщрs7щсsRщтkщуk‚щфk‡щхk„щцk’щчk“щшkщщkšщъk›щыkЁщьkЊщэkщюmщяqщ№rщёsщђuщѓvщєxщѕwщіyщїzщј|щљ~щњщћ‚щќ„щ§‡щў‹ъ@•ЬъA•ЭъB•ЮъC•ЯъD•аъE•бъF•въG•гъH•дъI•еъJ•жъK•зъL•иъM•йъN•къO•лъP•мъQ•нъR•оъS•пъT•ръU•съV•тъW•уъX•фъY•хъZ•цъ[•чъ\•ьъ]•џъ^–ъ_–ъ`–ъa–ъb–ъc– ъd–#ъe–$ъf–%ъg–&ъh–'ъi–(ъj–)ъk–+ъl–,ъm–-ъn–/ъo–0ъp–7ъq–8ъr–9ъs–:ъt–>ъu–Aъv–Cъw–Jъx–Nъy–Oъz–Qъ{–Rъ|–Sъ}–Vъ~–Wъ€–Xъ–Yъ‚–Zъƒ–\ъ„–]ъ…–^ъ†–`ъ‡–cъˆ–eъ‰–fъŠ–kъ‹–mъŒ–nъ–oъŽ–pъ–qъ–sъ‘–xъ’–yъ“–zъ”–{ъ•–|ъ––}ъ—–~ъ˜–ъ™–€ъš–ъ›–‚ъœ–ƒъ–„ъž–‡ъŸ–‰ъ –ŠъЁъЂŽъЃъЄ˜ъЅšъІŽЮъЇb ъЈbъЉbъЊbъЋb"ъЌb!ъ­b%ъЎb$ъЏb,ъАчъБtяъВtєъГtџъДuъЕuъЖuъЗe4ъИeюъЙeяъКe№ъЛf ъМfъНgrъОfъПfъРfъСp…ъТfїъУfъФf4ъХf1ъЦf6ъЧf5ъШ€ъЩf_ъЪfTъЫfAъЬfOъЭfVъЮfaъЯfWъаfwъбf„ъвfŒъгfЇъдfъеfОъжfлъзfмъиfцъйfщък2ъл3ъм6ън;ъо=ъп@ърEъсFътHъуIъфGъхMъцUъчYъш‰Чъщ‰Ъъъ‰Ыъы‰Ьъь‰Юъэ‰Яъю‰аъя‰бъ№rnъёrŸъђr]ъѓrfъєroъѕr~ъіrъїr„ъјr‹ъљrъњrъћr’ъќcъ§c2ъўcАы@–ŒыA–ŽыB–‘ыC–’ыD–“ыE–•ыF––ыG–šыH–›ыI–ыJ–žыK–ŸыL– ыM–ЁыN–ЂыO–ЃыP–ЄыQ–ЅыR–ІыS–ЈыT–ЉыU–ЊыV–ЋыW–ЌыX–­ыY–ЎыZ–Џы[–Бы\–Вы]–Ды^–Еы_–Зы`–Иыa–Кыb–Лыc–Пыd–Тыe–Уыf–Шыg–Ъыh–Ыыi–аыj–быk–гыl–дыm–жыn–зыo–иыp–йыq–кыr–лыs–мыt–ныu–оыv–пыw–сыx–тыy–уыz–фы{–хы|–цы}–чы~–ыы€–ьы–эы‚–юыƒ–№ы„–ёы…–ђы†–єы‡–ѕыˆ–јы‰–њыŠ–ћы‹–ќыŒ–§ы–џыŽ—ы—ы—ы‘— ы’— ы“— ы”—ы•—ы–—ы——ы˜—ы™—ыš—ы›—ыœ—ы—ыž—ыŸ—ы — ыЁd?ыЂdиыЃ€ыЄkъыЅkѓыІk§ыЇkѕыЈkљыЉlыЊlыЋlыЌl ы­lыЎlыЏlыАlыБl!ыВl)ыГl$ыДl*ыЕl2ыЖe5ыЗeUыИekыЙrMыКrRыЛrVыМr0ыН†bыОRыП€ŸыР€œыС€“ыТ€МыУg ыФ€НыХ€БыЦ€ЋыЧ€­ыШ€ДыЩ€ЗыЪ€чыЫ€шыЬ€щыЭ€ъыЮ€лыЯ€Тыа€Фыб€йыв€Эыг€зыдgые€ныж€ыыз€ёыи€єый€эык ылым€ђын€ќыоgыпырŒZыс6ытыу,ыфых2ыцHычLышSыщtыъYыыZыьqыэ`ыюiыя|ы№}ыёmыђgыѓXMыєZЕыѕˆыі‚ыї‘ыјnеыљЃыњЊыћЬыќg&ы§ЪыўЛь@—!ьA—"ьB—#ьC—$ьD—%ьE—&ьF—'ьG—(ьH—)ьI—+ьJ—,ьK—.ьL—/ьM—1ьN—3ьO—4ьP—5ьQ—6ьR—7ьS—:ьT—;ьU—<ьV—=ьW—?ьX—@ьY—AьZ—Bь[—Cь\—Dь]—Eь^—Fь_—Gь`—Hьa—Iьb—Jьc—Kьd—Lьe—Mьf—Nьg—Oьh—Pьi—Qьj—Tьk—Uьl—Wьm—Xьn—Zьo—\ьp—]ьq—_ьr—cьs—dьt—fьu—gьv—hьw—jьx—kьy—lьz—mь{—nь|—oь}—pь~—qь€—rь—uь‚—wьƒ—xь„—yь…—zь†—{ь‡—}ьˆ—~ь‰—ьŠ—€ь‹—ьŒ—‚ь—ƒьŽ—„ь—†ь—‡ь‘—ˆь’—‰ь“—Šь”—Œь•—Žь–—ь——ь˜—“ь™—•ьš—–ь›——ьœ—™ь—šьž—›ьŸ—œь —ьЁСьЂІьЃk$ьЄk7ьЅk9ьІkCьЇkFьЈkYьЉ˜бьЊ˜вьЋ˜гьЌ˜еь­˜йьЎ˜кьЏkГьА_@ьБkТьВ‰ѓьГeьДŸQьЕe“ьЖeМьЗeЦьИeФьЙeУьКeЬьЛeЮьМeвьНeжьОp€ьПpœьРp–ьСpьТpЛьУpРьФpЗьХpЋьЦpБьЧpшьШpЪьЩqьЪqьЫqьЬq/ьЭq1ьЮqsьЯq\ьаqhьбqEьвqrьгqJьдqxьеqzьжq˜ьзqГьиqЕьйqЈькq ьлqрьмqдьнqчьоqљьпrьрr(ьсplьтqьуqfьфqЙьхb>ьцb=ьчbCьшbHьщbIьъy;ьыy@ььyFьэyIьюy[ьяy\ь№ySьёyZьђybьѓyWьєy`ьѕyoьіygьїyzьјy…ьљyŠьњyšьћyЇьќyГь§_бьў_аэ@—žэA—ŸэB—ЁэC—ЂэD—ЄэE—ЅэF—ІэG—ЇэH—ЈэI—ЉэJ—ЊэK—ЌэL—ЎэM—АэN—БэO—ГэP—ЕэQ—ЖэR—ЗэS—ИэT—ЙэU—КэV—ЛэW—МэX—НэY—ОэZ—Пэ[—Рэ\—Сэ]—Тэ^—Уэ_—Фэ`—Хэa—Цэb—Чэc—Шэd—Щэe—Ъэf—Ыэg—Ьэh—Ээi—Юэj—Яэk—аэl—бэm—вэn—гэo—дэp—еэq—жэr—зэs—иэt—йэu—кэv—лэw—мэx—нэy—оэz—пэ{—рэ|—сэ}—тэ~—уэ€—фэ—хэ‚—шэƒ—юэ„—яэ…—№э†—ёэ‡—ђэˆ—єэ‰—їэŠ—јэ‹—љэŒ—њэ—ћэŽ—ќэ—§э—ўэ‘—џэ’˜э“˜э”˜э•˜э–˜э—˜э˜˜э™˜эš˜э›˜ эœ˜ э˜ эž˜ эŸ˜ э ˜эЁ`<эЂ`]эЃ`ZэЄ`gэЅ`AэІ`YэЇ`cэЈ`ЋэЉaэЊa эЋa]эЌaЉэ­aэЎaЫэЏaбэАbэБ€€эВ€эГl“эДlіэЕmќэЖwіэЗwјэИxэЙx эКxэЛxэМxэНeЋэОx-эПxэРxэСx9эТx:эУx;эФxэХx<эЦx%эЧx,эШx#эЩx)эЪxNэЫxmэЬxVэЭxWэЮx&эЯxPэаxGэбxLэвxjэгx›эдx“эеxšэжx‡эзxœэиxЁэйxЃэкxВэлxЙэмxЅэнxдэоxйэпxЩэрxьэсxђэтyэуxєэфyэхy$эцyэчy4эшŸ›эщžљэъžћэыžќэьvёээwэюw эяvљэ№wэёwэђwэѓw"эєwэѕw-эіw&эїw5эјw8эљwPэњwQэћwGэќwCэ§wZэўwhю@˜юA˜юB˜юC˜юD˜юE˜юF˜юG˜юH˜юI˜юJ˜юK˜юL˜юM˜юN˜юO˜юP˜юQ˜ юR˜!юS˜"юT˜#юU˜$юV˜%юW˜&юX˜'юY˜(юZ˜)ю[˜*ю\˜+ю]˜,ю^˜-ю_˜.ю`˜/юa˜0юb˜1юc˜2юd˜3юe˜4юf˜5юg˜6юh˜7юi˜8юj˜9юk˜:юl˜;юm˜<юn˜=юo˜>юp˜?юq˜@юr˜Aюs˜Bюt˜Cюu˜Dюv˜Eюw˜Fюx˜Gюy˜Hюz˜Iю{˜Jю|˜Kю}˜Lю~˜Mю€˜Nю˜Oю‚˜Pюƒ˜Qю„˜Rю…˜Sю†˜Tю‡˜Uюˆ˜Vю‰˜WюŠ˜Xю‹˜YюŒ˜Zю˜[юŽ˜\ю˜]ю˜^ю‘˜_ю’˜`ю“˜aю”˜bю•˜cю–˜dю—˜eю˜˜fю™˜gюš˜hю›˜iюœ˜jю˜kюž˜lюŸ˜mю ˜nюЁwbюЂweюЃwюЄwюЅw}юІw€юЇwŒюЈw‘юЉwŸюЊw юЋwАюЌwЕю­wНюЎu:юЏu@юАuNюБuKюВuHюГu[юДurюЕuyюЖuƒюЗXюИaюЙ_юКŠHюЛhюМtюНqюОyюПюР~юСvЭюТvхюУˆ2юФ”…юХ”†юЦ”‡юЧ”‹юШ”ŠюЩ”ŒюЪ”юЫ”юЬ”юЭ””юЮ”—юЯ”•юа”šюб”›юв”œюг”Ѓюд”Єюе”Ћюж”Њюз”­юи”Ќюй”Џюк”Аюл”Вюм”Дюн”Жюо”Зюп”Июр”Йюс”Кют”Мюу”Нюф”Пюх”Фюц”Шюч”Щюш”Ъющ”Ыюъ”Ьюы”Эюь”Ююэ”аюю”бюя”вю№”еюё”жюђ”зюѓ”йює”июѕ”люі”оюї”пюј”рюљ”тюњ”фюћ”хюќ”чю§”шюў”ъя@˜oяA˜pяB˜qяC˜rяD˜sяE˜tяF˜‹яG˜ŽяH˜’яI˜•яJ˜™яK˜ЃяL˜ЈяM˜ЉяN˜ЊяO˜ЋяP˜ЌяQ˜­яR˜ЎяS˜ЏяT˜АяU˜БяV˜ВяW˜ГяX˜ДяY˜ЕяZ˜Жя[˜Зя\˜Ия]˜Йя^˜Кя_˜Ля`˜Мяa˜Няb˜Ояc˜Пяd˜Ряe˜Сяf˜Тяg˜Уяh˜Фяi˜Хяj˜Цяk˜Чяl˜Шяm˜Щяn˜Ъяo˜Ыяp˜Ьяq˜Эяr˜Яяs˜аяt˜дяu˜жяv˜зяw˜ляx˜мяy˜няz˜ря{˜ся|˜тя}˜уя~˜фя€˜хя˜ця‚˜щяƒ˜ъя„˜ыя…˜ья†˜эя‡˜юяˆ˜яя‰˜№яŠ˜ёя‹˜ђяŒ˜ѓя˜єяŽ˜ѕя˜ія˜їя‘˜јя’˜љя“˜њя”˜ћя•˜ќя–˜§я—˜ўя˜˜џя™™яš™я›™яœ™я™яž™яŸ™я ™яЁ”щяЂ”ыяЃ”юяЄ”яяЅ”ѓяІ”єяЇ”ѕяЈ”їяЉ”љяЊ”ќяЋ”§яЌ”џя­•яЎ•яЏ•яА•яБ• яВ• яГ• яД•яЕ•яЖ•яЗ•яИ•яЙ•яК•яЛ•яМ•яН•яО•яП•яР•"яС•*яТ•+яУ•)яФ•,яХ•1яЦ•2яЧ•4яШ•6яЩ•7яЪ•8яЫ•<яЬ•>яЭ•?яЮ•BяЯ•5яа•Dяб•Eяв•Fяг•Iяд•Lяе•Nяж•Oяз•Rяи•Sяй•Tяк•Vял•Wям•Xян•Yяо•[яп•^яр•_яс•]ят•aяу•bяф•dях•eяц•fяч•gяш•hящ•iяъ•jяы•kяь•lяэ•oяю•qяя•rя№•sяё•:яђwчяѓwьяє–Щяѕyеяіyэяїyуяјyыяљzяњ]Gяћzяќzя§zяўz№@™№A™ №B™ №C™ №D™ №E™№F™№G™№H™№I™№J™№K™№L™№M™№N™№O™№P™№Q™№R™№S™№T™№U™№V™ №W™!№X™"№Y™#№Z™$№[™%№\™&№]™'№^™(№_™)№`™*№a™+№b™,№c™-№d™/№e™0№f™1№g™2№h™3№i™4№j™5№k™6№l™7№m™8№n™9№o™:№p™;№q™<№r™=№s™>№t™?№u™@№v™A№w™B№x™C№y™D№z™E№{™F№|™G№}™H№~™I№€™J№™K№‚™L№ƒ™M№„™N№…™O№†™P№‡™Q№ˆ™R№‰™S№Š™V№‹™W№Œ™X№™Y№Ž™Z№™[№™\№‘™]№’™^№“™_№”™`№•™a№–™b№—™d№˜™f№™™s№š™x№›™y№œ™{№™~№ž™‚№Ÿ™ƒ№ ™‰№Ёz9№Ђz7№ЃzQ№ЄžЯ№Ѕ™Ѕ№Іzp№Їvˆ№ЈvŽ№Љv“№Њv™№ЋvЄ№Ќtо№­tр№Ўu,№Џž №Аž"№Бž(№Вž)№Гž*№Дž+№Еž,№Жž2№Зž1№Иž6№Йž8№Кž7№Лž9№Мž:№Нž>№ОžA№ПžB№РžD№СžF№ТžG№УžH№ФžI№ХžK№ЦžL№ЧžN№ШžQ№ЩžU№ЪžW№ЫžZ№Ьž[№Эž\№Юž^№Яžc№аžf№бžg№вžh№гži№дžj№еžk№жžl№зžq№иžm№йžs№кu’№лu”№мu–№нu №оu№пuЌ№рuЃ№сuГ№тuД№уuИ№фuФ№хuБ№цuА№чuУ№шuТ№щuж№ъuЭ№ыuу№ьuш№эuц№юuф№яuы№№uч№ёv№ђuё№ѓuќ№єuџ№ѕv№іv№їv№јv №љv№њv №ћv%№ќv№§v№ўvё@™ŒёA™ŽёB™šёC™›ёD™œёE™ёF™žёG™ŸёH™ ёI™ЁёJ™ЂёK™ЃёL™ЄёM™ІёN™ЇёO™ЉёP™ЊёQ™ЋёR™ЌёS™­ёT™ЎёU™ЏёV™АёW™БёX™ВёY™ГёZ™Дё[™Её\™Жё]™Зё^™Иё_™Йё`™Кёa™Лёb™Мёc™Нёd™Оёe™Пёf™Рёg™Сёh™Тёi™Уёj™Фёk™Хёl™Цёm™Чёn™Шёo™Щёp™Ъёq™Ыёr™Ьёs™Эёt™Юёu™Яёv™аёw™бёx™вёy™гёz™дё{™её|™жё}™зё~™иё€™йё™кё‚™лёƒ™мё„™нё…™оё†™пё‡™рёˆ™сё‰™тёŠ™уё‹™фёŒ™хё™цёŽ™чё™шё™щё‘™ъё’™ыё“™ьё”™эё•™юё–™яё—™№ё˜™ёё™™ђёš™ѓё›™єёœ™ѕё™іёž™їёŸ™јё ™љёЁvёЂv<ёЃv"ёЄv ёЅv@ёІv-ёЇv0ёЈv?ёЉv5ёЊvCёЋv>ёЌv3ё­vMёЎv^ёЏvTёАv\ёБvVёВvkёГvoёДЪёЕzцёЖzxёЗzyёИz€ёЙz†ёКzˆёЛz•ёМzІёНz ёОzЌёПzЈёРz­ёСzГёТˆdёУˆiёФˆrёХˆ}ёЦˆёЧˆ‚ёШˆЂёЩˆЦёЪˆЗёЫˆМёЬˆЩёЭˆтёЮˆЮёЯˆуёаˆхёбˆёёв‰ёгˆќёдˆшёеˆўёжˆ№ёз‰!ёи‰ёй‰ёк‰ёл‰ ём‰4ён‰+ёо‰6ёп‰Aёр‰fёс‰{ётu‹ёу€хёфvВёхvДёцwмёч€ёш€ёщ€ёъ€ёы€ ёь€"ёэ€%ёю€&ёя€'ё№€)ёё€(ёђ€1ёѓ€ ёє€5ёѕ€Cёі€Fёї€Mёј€Rёљ€iёњ€qёћ‰ƒёќ˜xё§˜€ёў˜ƒђ@™њђA™ћђB™ќђC™§ђD™ўђE™џђFšђGšђHšђIšђJšђKšђLšђMšђNšђOš ђPš ђQš ђRš ђSš ђTšђUšђVšђWšђXšђYšђZšђ[šђ\šђ]šђ^šђ_šђ`šђašђbšђcšђdšђešђfš ђgš!ђhš"ђiš#ђjš$ђkš%ђlš&ђmš'ђnš(ђoš)ђpš*ђqš+ђrš,ђsš-ђtš.ђuš/ђvš0ђwš1ђxš2ђyš3ђzš4ђ{š5ђ|š6ђ}š7ђ~š8ђ€š9ђš:ђ‚š;ђƒš<ђ„š=ђ…š>ђ†š?ђ‡š@ђˆšAђ‰šBђŠšCђ‹šDђŒšEђšFђŽšGђšHђšIђ‘šJђ’šKђ“šLђ”šMђ•šNђ–šOђ—šPђ˜šQђ™šRђššSђ›šTђœšUђšVђžšWђŸšXђ šYђЁ˜‰ђЂ˜ŒђЃ˜ђЄ˜ђЅ˜”ђІ˜šђЇ˜›ђЈ˜žђЉ˜ŸђЊ˜ЁђЋ˜ЂђЌ˜Ѕђ­˜ІђЎ†MђЏ†TђА†lђБ†nђВ†ђГ†zђД†|ђЕ†{ђЖ†ЈђЗ†ђИ†‹ђЙ†ЌђК†ђЛ†ЇђМ†ЃђН†ЊђО†“ђП†ЉђР†ЖђС†ФђТ†ЕђУ†ЮђФ†АђХ†КђЦ†БђЧ†ЏђШ†ЩђЩ†ЯђЪ†ДђЫ†щђЬ†ёђЭ†ђђЮ†эђЯ†ѓђа†ађб‡ђв†ођг†єђд†пђе†иђж†бђз‡ђи‡ђй†јђк‡ђл‡ ђм‡ ђн‡ ђо‡#ђп‡;ђр‡ђс‡%ђт‡.ђу‡ђф‡>ђх‡Hђц‡4ђч‡1ђш‡)ђщ‡7ђъ‡?ђы‡‚ђь‡"ђэ‡}ђю‡~ђя‡{ђ№‡`ђё‡pђђ‡Lђѓ‡nђє‡‹ђѕ‡Sђі‡cђї‡|ђј‡dђљ‡Yђњ‡eђћ‡“ђќ‡Џђ§‡Јђў‡вѓ@šZѓAš[ѓBš\ѓCš]ѓDš^ѓEš_ѓFš`ѓGšaѓHšbѓIšcѓJšdѓKšeѓLšfѓMšgѓNšhѓOšiѓPšjѓQškѓRšrѓSšƒѓTš‰ѓUšѓVšŽѓWš”ѓXš•ѓYš™ѓZšІѓ[šЉѓ\šЊѓ]šЋѓ^šЌѓ_š­ѓ`šЎѓašЏѓbšВѓcšГѓdšДѓešЕѓfšЙѓgšЛѓhšНѓišОѓjšПѓkšУѓlšФѓmšЦѓnšЧѓošШѓpšЩѓqšЪѓršЭѓsšЮѓtšЯѓušаѓvšвѓwšдѓxšеѓyšжѓzšзѓ{šйѓ|šкѓ}šлѓ~šмѓ€šнѓšоѓ‚šрѓƒšтѓ„šуѓ…šфѓ†šхѓ‡šчѓˆšшѓ‰šщѓŠšъѓ‹šьѓŒšюѓš№ѓŽšёѓšђѓšѓѓ‘šєѓ’šѕѓ“šіѓ”šїѓ•šјѓ–šњѓ—šќѓ˜š§ѓ™šўѓššџѓ››ѓœ›ѓ›ѓž›ѓŸ›ѓ ›ѓЁ‡ЦѓЂ‡ˆѓЃ‡…ѓЄ‡­ѓЅ‡—ѓІ‡ƒѓЇ‡ЋѓЈ‡хѓЉ‡ЌѓЊ‡ЕѓЋ‡ГѓЌ‡Ыѓ­‡гѓЎ‡НѓЏ‡бѓА‡РѓБ‡ЪѓВ‡лѓГ‡ъѓД‡рѓЕ‡юѓЖˆѓЗˆѓИ‡ўѓЙˆ ѓКˆѓЛˆ!ѓМˆ9ѓНˆ<ѓО6ѓПBѓРDѓСEѓТ‚ѓУzњѓФz§ѓХ{ѓЦ{ѓЧ{ѓШ{ѓЩ{ ѓЪ{+ѓЫ{ѓЬ{GѓЭ{8ѓЮ{*ѓЯ{ѓа{.ѓб{1ѓв{ ѓг{%ѓд{$ѓе{3ѓж{>ѓз{ѓи{Xѓй{Zѓк{Eѓл{uѓм{Lѓн{]ѓо{`ѓп{nѓр{{ѓс{bѓт{rѓу{qѓф{ѓх{Іѓц{Їѓч{Иѓш{Ќѓщ{ѓъ{Јѓы{…ѓь{Њѓэ{œѓю{Ђѓя{Ћѓ№{Дѓё{бѓђ{Сѓѓ{Ьѓє{нѓѕ{кѓі{хѓї{цѓј{ъѓљ| ѓњ{ўѓћ{ќѓќ|ѓ§|ѓў| є@›єA› єB› єC› єD› єE› єF›єG›єH›єI›єJ›єK›єL›єM›єN›єO›єP›єQ›єR›єS›єT›єU› єV›!єW›"єX›$єY›%єZ›&є[›'є\›(є]›)є^›*є_›+є`›,єa›-єb›.єc›0єd›1єe›3єf›4єg›5єh›6єi›7єj›8єk›9єl›:єm›=єn›>єo›?єp›@єq›Fєr›Jєs›Kєt›Lєu›Nєv›Pєw›Rєx›Sєy›Uєz›Vє{›Wє|›Xє}›Yє~›Zє€›[є›\є‚›]єƒ›^є„›_є…›`є†›aє‡›bєˆ›cє‰›dєŠ›eє‹›fєŒ›gє›hєŽ›iє›jє›kє‘›lє’›mє“›nє”›oє•›pє–›qє—›rє˜›sє™›tєš›uє››vєœ›wє›xєž›yєŸ›zє ›{єЁ|єЂ|*єЃ|&єЄ|8єЅ|AєІ|@єЇўєЈ‚єЉ‚єЊ‚єЋьєЌˆDє­‚!єЎ‚"єЏ‚#єА‚-єБ‚/єВ‚(єГ‚+єД‚8єЕ‚;єЖ‚3єЗ‚4єИ‚>єЙ‚DєК‚IєЛ‚KєМ‚OєН‚ZєО‚_єП‚hєРˆ~єСˆ…єТˆˆєУˆиєФˆпєХ‰^єЦєЧŸєШЇєЩЏєЪАєЫВєЬ||єЭeIєЮ|‘єЯ|єа|œєб|žєв|Ђєг|Вєд|Мєе|Нєж|Сєз|Чєи|Ьєй|Эєк|Шєл|Хєм|зєн|шєо‚nєпfЈєрПєсЮєтеєухєфсєхцєцщєчюєшѓєщ|јєъ}wєы}Ієь}Ўєэ~Gєю~›єяžИє№žДєёsєђ„єѓ”єє‘єѕБєіgєїmєјŒGєљŒIєњ‘Jєћ‘Pєќ‘Nє§‘Oєў‘dѕ@›|ѕA›}ѕB›~ѕC›ѕD›€ѕE›ѕF›‚ѕG›ƒѕH›„ѕI›…ѕJ›†ѕK›‡ѕL›ˆѕM›‰ѕN›ŠѕO›‹ѕP›ŒѕQ›ѕR›ŽѕS›ѕT›ѕU›‘ѕV›’ѕW›“ѕX›”ѕY›•ѕZ›–ѕ[›—ѕ\›˜ѕ]›™ѕ^›šѕ_››ѕ`›œѕa›ѕb›žѕc›Ÿѕd› ѕe›Ёѕf›Ђѕg›Ѓѕh›Єѕi›Ѕѕj›Іѕk›Їѕl›Јѕm›Љѕn›Њѕo›Ћѕp›Ќѕq›­ѕr›Ўѕs›Џѕt›Аѕu›Бѕv›Вѕw›Гѕx›Дѕy›Еѕz›Жѕ{›Зѕ|›Иѕ}›Йѕ~›Кѕ€›Лѕ›Мѕ‚›Нѕƒ›Оѕ„›Пѕ…›Рѕ†›Сѕ‡›Тѕˆ›Уѕ‰›ФѕŠ›Хѕ‹›ЦѕŒ›Чѕ›ШѕŽ›Щѕ›Ъѕ›Ыѕ‘›Ьѕ’›Эѕ“›Юѕ”›Яѕ•›аѕ–›бѕ—›вѕ˜›гѕ™›дѕš›еѕ››жѕœ›зѕ›иѕž›йѕŸ›кѕ ›лѕЁ‘bѕЂ‘aѕЃ‘pѕЄ‘iѕЅ‘oѕІ‘}ѕЇ‘~ѕЈ‘rѕЉ‘tѕЊ‘yѕЋ‘ŒѕЌ‘…ѕ­‘ѕЎ‘ѕЏ‘‘ѕА‘ЂѕБ‘ЃѕВ‘ЊѕГ‘­ѕД‘ЎѕЕ‘ЏѕЖ‘ЕѕЗ‘ДѕИ‘КѕЙŒUѕКž~ѕЛИѕМыѕНŽѕОŽYѕПŽiѕРЕѕСПѕТМѕУКѕФФѕХжѕЦзѕЧкѕШоѕЩЮѕЪЯѕЫлѕЬЦѕЭьѕЮїѕЯјѕауѕбљѕвћѕгфѕдŽ ѕе§ѕжŽѕзŽѕиŽѕйŽ,ѕкŽ.ѕлŽ#ѕмŽ/ѕнŽ:ѕоŽ@ѕпŽ9ѕрŽ5ѕсŽ=ѕтŽ1ѕуŽIѕфŽAѕхŽBѕцŽQѕчŽRѕшŽJѕщŽpѕъŽvѕыŽ|ѕьŽoѕэŽtѕюŽ…ѕяŽѕ№Ž”ѕёŽѕђŽœѕѓŽžѕєŒxѕѕŒ‚ѕіŒŠѕїŒ…ѕјŒ˜ѕљŒ”ѕњe›ѕћ‰жѕќ‰оѕ§‰кѕў‰мі@›міA›ніB›оіC›піD›ріE›сіF›тіG›уіH›фіI›хіJ›ціK›чіL›шіM›щіN›ъіO›ыіP›ьіQ›эіR›юіS›яіT›№іU›ёіV›ђіW›ѓіX›єіY›ѕіZ›іі[›їі\›јі]›љі^›њі_›ћі`›ќіa›§іb›ўіc›џіdœіeœіfœіgœіhœіiœіjœіkœіlœіmœ іnœ іoœ іpœ іqœ іrœіsœіtœіuœіvœіwœіxœіyœіzœі{œі|œі}œі~œі€œіœі‚œіƒœі„œі…œ і†œ!і‡œ"іˆœ#і‰œ$іŠœ%і‹œ&іŒœ'іœ(іŽœ)іœ*іœ+і‘œ,і’œ-і“œ.і”œ/і•œ0і–œ1і—œ2і˜œ3і™œ4іšœ5і›œ6іœœ7іœ8іžœ9іŸœ:і œ;іЁ‰хіЂ‰ыіЃ‰яіЄŠ>іЅ‹&іІ—SіЇ–щіЈ–ѓіЉ–яіЊ—іЋ—іЌ—і­—іЎ—іЏ—*іА—-іБ—0іВ—>іГŸ€іДŸƒіЕŸ…іЖŸ†іЗŸ‡іИŸˆіЙŸ‰іКŸŠіЛŸŒіМžўіНŸ іОŸ іП–ЙіР–МіС–НіТ–ЮіУ–віФwПіХ–ріЦ’ŽіЧ’ЎіШ’ШіЩ“>іЪ“jіЫ“ЪіЬ“іЭ”>іЮ”kіЯœіаœ‚ібœ…івœ†ігœ‡ідœˆіеz#іжœ‹ізœŽіиœійœ‘ікœ’ілœ”імœ•інœšіоœ›іпœžірœŸісœ ітœЁіуœЂіфœЃіхœЅіцœІічœЇішœЈіщœЉіъœЋіыœ­іьœЎіэœАіюœБіяœВі№œГіёœДіђœЕіѓœЖієœЗіѕœКііœЛіїœМіјœНіљœФіњœХіћœЦіќœЧі§œЪіўœЫї@œ<їAœ=їBœ>їCœ?їDœ@їEœAїFœBїGœCїHœDїIœEїJœFїKœGїLœHїMœIїNœJїOœKїPœLїQœMїRœNїSœOїTœPїUœQїVœRїWœSїXœTїYœUїZœVї[œWї\œXї]œYї^œZї_œ[ї`œ\їaœ]їbœ^їcœ_їdœ`їeœaїfœbїgœcїhœdїiœeїjœfїkœgїlœhїmœiїnœjїoœkїpœlїqœmїrœnїsœoїtœpїuœqїvœrїwœsїxœtїyœuїzœvї{œwї|œxї}œyї~œzї€œ{їœ}ї‚œ~їƒœ€ї„œƒї…œ„ї†œ‰ї‡œŠїˆœŒї‰œїŠœ“ї‹œ–їŒœ—їœ˜їŽœ™їœїœЊї‘œЌї’œЏї“œЙї”œОї•œПї–œРї—œСї˜œТї™œШїšœЩї›œбїœœвїœкїžœлїŸœрї œсїЁœЬїЂœЭїЃœЮїЄœЯїЅœаїІœгїЇœдїЈœеїЉœзїЊœиїЋœйїЌœмї­œнїЎœпїЏœтїА—|їБ—…їВ—‘їГ—’їД—”їЕ—ЏїЖ—ЋїЗ—ЃїИ—ВїЙ—ДїКšБїЛšАїМšЗїНžXїОšЖїПšКїРšМїСšСїТšРїУšХїФšТїХšЫїЦšЬїЧšбїШ›EїЩ›CїЪ›GїЫ›IїЬ›HїЭ›MїЮ›QїЯ˜шїа™ їб™.їв™Uїг™Tїдšпїеšсїжšцїзšяїиšыїйšћїкšэїлšљїм›їн›їо›їп›їр›#їсžНїтžОїу~;їфž‚їхž‡їцžˆїчž‹їшž’їщ“жїъžїыžŸїьžлїэžмїюžнїяžрї№žпїёžтїђžщїѓžчїєžхїѕžъїіžяїїŸ"їјŸ,їљŸ/їњŸ9їћŸ7їќŸ=ї§Ÿ>їўŸDј@œујAœфјBœхјCœцјDœчјEœшјFœщјGœъјHœыјIœьјJœэјKœюјLœяјMœ№јNœёјOœђјPœѓјQœєјRœѕјSœіјTœїјUœјјVœљјWœњјXœћјYœќјZœ§ј[œўј\œџј]ј^ј_ј`јaјbјcјdјeјf јg јh јi јj јkјlјmјnјoјpјqјrјsјtјuјvјwјxјyјzј{ј|ј} ј~!ј€"ј#ј‚$јƒ%ј„&ј…'ј†(ј‡)јˆ*ј‰+јŠ,ј‹-јŒ.ј/јŽ0ј1ј2ј‘3ј’4ј“5ј”6ј•7ј–8ј—9ј˜:ј™;јš<ј›=јœ>ј?јž@јŸAј Bљ@CљADљBEљCFљDGљEHљFIљGJљHKљILљJMљKNљLOљMPљNQљORљPSљQTљRUљSVљTWљUXљVYљWZљX[љY\љZ]љ[^љ\_љ]`љ^aљ_bљ`cљadљbeљcfљdgљehљfiљgjљhkљilљjmљknљloљmpљnqљorљpsљqtљruљsvљtwљuxљvyљwzљx{љy|љz}љ{~љ|љ}€љ~љ€‚љƒљ‚„љƒ…љ„†љ…‡љ†ˆљ‡‰љˆŠљ‰‹љŠŒљ‹љŒŽљљŽљ‘љ’љ‘“љ’”љ“•љ”–љ•—љ–˜љ—™љ˜šљ™›љšœљ›љœžљŸљž љŸЁљ Ђњ@ЃњAЄњBЅњCІњDЇњEЈњFЉњGЊњHЋњIЌњJ­њKЎњLЏњMАњNБњOВњPГњQДњRЕњSЖњTЗњUИњVЙњWКњXЛњYМњZНњ[Оњ\Пњ]Рњ^Сњ_Тњ`УњaФњbХњcЦњdЧњeШњfЩњgЪњhЫњiЬњjЭњkЮњlЯњmањnбњoвњpгњqдњrењsжњtзњuињvйњwкњxлњyмњzнњ{оњ|пњ}рњ~сњ€тњуњ‚фњƒхњ„цњ…чњ†шњ‡щњˆъњ‰ыњŠьњ‹эњŒюњяњŽ№њёњђњ‘ѓњ’єњ“ѕњ”іњ•їњ–јњ—љњ˜њњ™ћњšќњ›§њœўњџњžžњŸžњ žћ@žћAžћBžћCžћDžћEžћFž ћGž ћHž ћIž ћJž ћKžћLžћMžћNžћOžћPžћQžћRžћSžћTžћUžћVžћWžћXžћYžћZžћ[žћ\ž$ћ]ž'ћ^ž.ћ_ž0ћ`ž4ћaž;ћbž<ћcž@ћdžMћežPћfžRћgžSћhžTћižVћjžYћkž]ћlž_ћmž`ћnžaћožbћpžeћqžnћržoћsžrћtžtћužuћvžvћwžwћxžxћyžyћzžzћ{ž{ћ|ž|ћ}ž}ћ~ž€ћ€žћžƒћ‚ž„ћƒž…ћ„ž†ћ…ž‰ћ†žŠћ‡žŒћˆžћ‰žŽћŠžћ‹žћŒž‘ћž”ћŽž•ћž–ћž—ћ‘ž˜ћ’ž™ћ“žšћ”ž›ћ•žœћ–žžћ—ž ћ˜žЁћ™žЂћšžЃћ›žЄћœžЅћžЇћžžЈћŸžЉћ žЊќ@žЋќAžЌќBž­ќCžЎќDžЏќEžАќFžБќGžВќHžГќIžЕќJžЖќKžЗќLžЙќMžКќNžМќOžПќPžРќQžСќRžТќSžУќTžХќUžЦќVžЧќWžШќXžЪќYžЫќZžЬќ[žаќ\žвќ]žгќ^žеќ_žжќ`žзќažйќbžкќcžоќdžсќežуќfžфќgžцќhžшќižыќjžьќkžэќlžюќmž№ќnžёќožђќpžѓќqžєќržѕќsžіќtžїќužјќvžњќwž§ќxžџќyŸќzŸќ{Ÿќ|Ÿќ}Ÿќ~Ÿќ€ŸќŸќ‚ŸќƒŸ ќ„Ÿ ќ…Ÿ ќ†Ÿќ‡ŸќˆŸќ‰ŸќŠŸќ‹ŸќŒŸќŸќŽŸќŸќŸќ‘Ÿќ’Ÿќ“Ÿ!ќ”Ÿ#ќ•Ÿ$ќ–Ÿ%ќ—Ÿ&ќ˜Ÿ'ќ™Ÿ(ќšŸ)ќ›Ÿ*ќœŸ+ќŸ-ќžŸ.ќŸŸ0ќ Ÿ1§@Ÿ2§AŸ3§BŸ4§CŸ5§DŸ6§EŸ8§FŸ:§GŸ<§HŸ?§IŸ@§JŸA§KŸB§LŸC§MŸE§NŸF§OŸG§PŸH§QŸI§RŸJ§SŸK§TŸL§UŸM§VŸN§WŸO§XŸR§YŸS§ZŸT§[ŸU§\ŸV§]ŸW§^ŸX§_ŸY§`ŸZ§aŸ[§bŸ\§cŸ]§dŸ^§eŸ_§fŸ`§gŸa§hŸb§iŸc§jŸd§kŸe§lŸf§mŸg§nŸh§oŸi§pŸj§qŸk§rŸl§sŸm§tŸn§uŸo§vŸp§wŸq§xŸr§yŸs§zŸt§{Ÿu§|Ÿv§}Ÿw§~Ÿx§€Ÿy§Ÿz§‚Ÿ{§ƒŸ|§„Ÿ}§…Ÿ~§†Ÿ§‡Ÿ‚§ˆŸ§‰ŸŽ§ŠŸ§‹Ÿ§ŒŸ‘§Ÿ’§ŽŸ“§Ÿ”§Ÿ•§‘Ÿ–§’Ÿ—§“Ÿ˜§”Ÿœ§•Ÿ§–Ÿž§—ŸЁ§˜ŸЂ§™ŸЃ§šŸЄ§›ŸЅ§œљ,§љy§žљ•§Ÿљч§ љёў@њ ўAњ ўBњўCњўDњўEњўFњўGњўHњўIњ ўJњ!ўKњ#ўLњ$ўMњ'ўNњ(ўOњ)ecl-16.1.2/contrib/encodings/WINDOWS-CP949.BIN000066400000000000000000002061421266352375300202300ustar00rootroot00000000000000†0  !!""##$$%%&&''(())**++,,--..//00112233445566778899::;;<<==>>??@@AABBCCDDEEFFGGHHIIJJKKLLMMNNOOPPQQRRSSTTUUVVWWXXYYZZ[[\\]]^^__``aabbccddeeffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~AЌBЌCЌDЌEЌ FЌ GЌ HЌIЌJЌKЌLЌMЌ!NЌ"OЌ#PЌ%QЌ&RЌ'SЌ(TЌ)UЌ*VЌ+WЌ.XЌ2YЌ3ZЌ4aЌ5bЌ6cЌ7dЌ:eЌ;fЌ=gЌ>hЌ?iЌAjЌBkЌClЌDmЌEnЌFoЌGpЌHqЌIrЌJsЌLtЌNuЌOvЌPwЌQxЌRyЌSzЌUЌV‚ЌWƒЌY„ЌZ…Ќ[†Ќ]‡Ќ^ˆЌ_‰Ќ`ŠЌa‹ЌbŒЌcЌdŽЌeЌfЌg‘Ќh’Ќi“Ќj”Ќk•Ќl–Ќm—Ќn˜Ќo™ЌršЌs›ЌuœЌvЌyžЌ{ŸЌ| Ќ}ЁЌ~ЂЌЃЌ‚ЄЌ‡ЅЌˆІЌЇЌŽЈЌЉЌ‘ЊЌ’ЋЌ“ЌЌ•­Ќ–ЎЌ—ЏЌ˜АЌ™БЌšВЌ›ГЌžДЌЂЕЌЃЖЌЄЗЌЅИЌІЙЌЇКЌЋЛЌ­МЌЎНЌБОЌВПЌГРЌДСЌЕТЌЖУЌЗФЌКХЌОЦЌПЧЌРШЌТЩЌУЪЌХЫЌЦЬЌЧЭЌЩЮЌЪЯЌЫаЌЭбЌЮвЌЯгЌадЌбеЌвжЌгзЌдиЌжйЌикЌйлЌкмЌлнЌмоЌнпЌорЌпсЌттЌууЌхфЌцхЌщцЌычЌэшЌющЌђъЌєыЌїьЌјэЌљюЌњяЌћ№ЌўёЌџђ­ѓ­є­ѕ­і­ї­ј­ љ­ њ­ ћ­ќ­§­ў­‚A­‚B­‚C­‚D­‚E­‚F­‚G­‚H­‚I­‚J­‚K­!‚L­"‚M­#‚N­$‚O­%‚P­&‚Q­'‚R­(‚S­*‚T­+‚U­.‚V­/‚W­0‚X­1‚Y­2‚Z­3‚a­6‚b­7‚c­9‚d­:‚e­;‚f­=‚g­>‚h­?‚i­@‚j­A‚k­B‚l­C‚m­F‚n­H‚o­J‚p­K‚q­L‚r­M‚s­N‚t­O‚u­Q‚v­R‚w­S‚x­U‚y­V‚z­W‚­Y‚‚­Z‚ƒ­[‚„­\‚…­]‚†­^‚‡­_‚ˆ­`‚‰­b‚Š­d‚‹­e‚Œ­f‚­g‚Ž­h‚­i‚­j‚‘­k‚’­n‚“­o‚”­q‚•­r‚–­w‚—­x‚˜­y‚™­z‚š­~‚›­€‚œ­ƒ‚­„‚ž­…‚Ÿ­†‚ ­‡‚Ё­Š‚Ђ­‹‚Ѓ­‚Є­Ž‚Ѕ­‚І­‘‚Ї­’‚Ј­“‚Љ­”‚Њ­•‚Ћ­–‚Ќ­—‚­­˜‚Ў­™‚Џ­š‚А­›‚Б­ž‚В­Ÿ‚Г­ ‚Д­Ё‚Е­Ђ‚Ж­Ѓ‚З­Ѕ‚И­І‚Й­Ї‚К­Ј‚Л­Љ‚М­Њ‚Н­Ћ‚О­Ќ‚П­­‚Р­Ў‚С­Џ‚Т­А‚У­Б‚Ф­В‚Х­Г‚Ц­Д‚Ч­Е‚Ш­Ж‚Щ­И‚Ъ­Й‚Ы­К‚Ь­Л‚Э­М‚Ю­Н‚Я­О‚а­П‚б­Т‚в­У‚г­Х‚д­Ц‚е­Ч‚ж­Щ‚з­Ъ‚и­Ы‚й­Ь‚к­Э‚л­Ю‚м­Я‚н­в‚о­д‚п­е‚р­ж‚с­з‚т­и‚у­й‚ф­к‚х­л‚ц­н‚ч­о‚ш­п‚щ­с‚ъ­т‚ы­у‚ь­х‚э­ц‚ю­ч‚я­ш‚№­щ‚ё­ъ‚ђ­ы‚ѓ­ь‚є­э‚ѕ­ю‚і­я‚ї­№‚ј­ё‚љ­ђ‚њ­ѓ‚ћ­є‚ќ­ѕ‚§­і‚ў­їƒA­њƒB­ћƒC­§ƒD­ўƒEЎƒFЎƒGЎƒHЎƒIЎƒJЎƒKЎ ƒLЎ ƒMЎƒNЎƒOЎƒPЎƒQЎƒRЎƒSЎƒTЎƒUЎƒVЎƒWЎƒXЎƒYЎƒZЎƒaЎƒbЎƒcЎƒdЎ ƒeЎ!ƒfЎ"ƒgЎ#ƒhЎ$ƒiЎ%ƒjЎ&ƒkЎ'ƒlЎ(ƒmЎ)ƒnЎ*ƒoЎ+ƒpЎ,ƒqЎ-ƒrЎ.ƒsЎ/ƒtЎ2ƒuЎ3ƒvЎ5ƒwЎ6ƒxЎ9ƒyЎ;ƒzЎ<ƒЎ=ƒ‚Ў>ƒƒЎ?ƒ„ЎBƒ…ЎDƒ†ЎGƒ‡ЎHƒˆЎIƒ‰ЎKƒŠЎOƒ‹ЎQƒŒЎRƒЎSƒŽЎUƒЎWƒЎXƒ‘ЎYƒ’ЎZƒ“Ў[ƒ”Ў^ƒ•Ўbƒ–Ўcƒ—Ўdƒ˜Ўfƒ™ЎgƒšЎjƒ›ЎkƒœЎmƒЎnƒžЎoƒŸЎqƒ ЎrƒЁЎsƒЂЎtƒЃЎuƒЄЎvƒЅЎwƒІЎzƒЇЎ~ƒЈЎƒЉЎ€ƒЊЎƒЋЎ‚ƒЌЎƒƒ­Ў†ƒЎЎ‡ƒЏЎˆƒАЎ‰ƒБЎŠƒВЎ‹ƒГЎƒДЎŽƒЕЎƒЖЎƒЗЎ‘ƒИЎ’ƒЙЎ“ƒКЎ”ƒЛЎ•ƒМЎ–ƒНЎ—ƒОЎ˜ƒПЎ™ƒРЎšƒСЎ›ƒТЎœƒУЎƒФЎžƒХЎŸƒЦЎ ƒЧЎЁƒШЎЂƒЩЎЃƒЪЎЄƒЫЎЅƒЬЎІƒЭЎЇƒЮЎЈƒЯЎЉƒаЎЊƒбЎЋƒвЎЌƒгЎ­ƒдЎЎƒеЎЏƒжЎАƒзЎБƒиЎВƒйЎГƒкЎДƒлЎЕƒмЎЖƒнЎЗƒоЎИƒпЎЙƒрЎКƒсЎЛƒтЎПƒуЎСƒфЎТƒхЎУƒцЎХƒчЎЦƒшЎЧƒщЎШƒъЎЩƒыЎЪƒьЎЫƒэЎЮƒюЎвƒяЎгƒ№ЎдƒёЎеƒђЎжƒѓЎзƒєЎкƒѕЎлƒіЎнƒїЎоƒјЎпƒљЎрƒњЎсƒћЎтƒќЎуƒ§ЎфƒўЎх„AЎц„BЎч„CЎщ„DЎъ„EЎь„FЎю„GЎя„HЎ№„IЎё„JЎђ„KЎѓ„LЎѕ„MЎі„NЎї„OЎљ„PЎњ„QЎћ„RЎ§„SЎў„TЎџ„UЏ„VЏ„WЏ„XЏ„YЏ„ZЏ„aЏ„bЏ „cЏ „dЏ „eЏ „fЏ„gЏ„hЏ„iЏ„jЏ„kЏ„lЏ„mЏ„nЏ„oЏ„pЏ„qЏ„rЏ„sЏ„tЏ„uЏ„vЏ„wЏ „xЏ!„yЏ"„zЏ#„Џ$„‚Џ%„ƒЏ&„„Џ'„…Џ(„†Џ)„‡Џ*„ˆЏ+„‰Џ.„ŠЏ/„‹Џ1„ŒЏ3„Џ5„ŽЏ6„Џ7„Џ8„‘Џ9„’Џ:„“Џ;„”Џ>„•Џ@„–ЏD„—ЏE„˜ЏF„™ЏG„šЏJ„›ЏK„œЏL„ЏM„žЏN„ŸЏO„ ЏQ„ЁЏR„ЂЏS„ЃЏT„ЄЏU„ЅЏV„ІЏW„ЇЏX„ЈЏY„ЉЏZ„ЊЏ[„ЋЏ^„ЌЏ_„­Џ`„ЎЏa„ЏЏb„АЏc„БЏf„ВЏg„ГЏh„ДЏi„ЕЏj„ЖЏk„ЗЏl„ИЏm„ЙЏn„КЏo„ЛЏp„МЏq„НЏr„ОЏs„ПЏt„РЏu„СЏv„ТЏw„УЏx„ФЏz„ХЏ{„ЦЏ|„ЧЏ}„ШЏ~„ЩЏ„ЪЏ„ЫЏ‚„ЬЏƒ„ЭЏ…„ЮЏ†„ЯЏ‡„аЏ‰„бЏŠ„вЏ‹„гЏŒ„дЏ„еЏŽ„жЏ„зЏ’„иЏ“„йЏ”„кЏ–„лЏ—„мЏ˜„нЏ™„оЏš„пЏ›„рЏ„сЏž„тЏŸ„уЏ „фЏЁ„хЏЂ„цЏЃ„чЏЄ„шЏЅ„щЏІ„ъЏЇ„ыЏЈ„ьЏЉ„эЏЊ„юЏЋ„яЏЌ„№Џ­„ёЏЎ„ђЏЏ„ѓЏА„єЏБ„ѕЏВ„іЏГ„їЏД„јЏЕ„љЏЖ„њЏЗ„ћЏК„ќЏЛ„§ЏН„ўЏО…AЏП…BЏС…CЏТ…DЏУ…EЏФ…FЏХ…GЏЦ…HЏЪ…IЏЬ…JЏЯ…KЏа…LЏб…MЏв…NЏг…OЏе…PЏж…QЏз…RЏи…SЏй…TЏк…UЏл…VЏн…WЏо…XЏп…YЏр…ZЏс…aЏт…bЏу…cЏф…dЏх…eЏц…fЏч…gЏъ…hЏы…iЏь…jЏэ…kЏю…lЏя…mЏђ…nЏѓ…oЏѕ…pЏі…qЏї…rЏљ…sЏњ…tЏћ…uЏќ…vЏ§…wЏў…xЏџ…yА…zА…А…‚А…ƒА…„А……А …†А …‡А …ˆА …‰А…ŠА…‹А…ŒА…А…ŽА…А…А…‘А…’А…“А…”А…•А…–А…—А …˜А!…™А"…šА#…›А$…œА%…А&…žА'…ŸА)… А*…ЁА+…ЂА,…ЃА-…ЄА.…ЅА/…ІА0…ЇА1…ЈА2…ЉА3…ЊА4…ЋА5…ЌА6…­А7…ЎА8…ЏА9…АА:…БА;…ВА<…ГА=…ДА>…ЕА?…ЖА@…ЗАA…ИАB…ЙАC…КАF…ЛАG…МАI…НАK…ОАM…ПАO…РАP…САQ…ТАR…УАV…ФАX…ХАZ…ЦА[…ЧА\…ША^…ЩА_…ЪА`…ЫАa…ЬАb…ЭАc…ЮАd…ЯАe…аАf…бАg…вАh…гАi…дАj…еАk…жАl…зАm…иАn…йАo…кАp…лАq…мАr…нАs…оАt…пАu…рАv…сАw…тАx…уАy…фАz…хА{…цА~…чА…шА…щА‚…ъАƒ…ыА……ьА†…эА‡…юАˆ…яА‰…№АŠ…ёА‹…ђАŽ…ѓА…єА’…ѕА“…іА”…їА•…јА–…љА—…њА›…ћА…ќАž…§АЃ…ўАЄ†AАЅ†BАІ†CАЇ†DАЊ†EАА†FАВ†GАЖ†HАЗ†IАЙ†JАК†KАЛ†LАН†MАО†NАП†OАР†PАС†QАТ†RАУ†SАЦ†TАЪ†UАЫ†VАЬ†WАЭ†XАЮ†YАЯ†ZАв†aАг†bАе†cАж†dАз†eАй†fАк†gАл†hАм†iАн†jАо†kАп†lАс†mАт†nАу†oАф†pАц†qАч†rАш†sАщ†tАъ†uАы†vАь†wАэ†xАю†yАя†zА№†Аё†‚Ађ†ƒАѓ†„Ає†…Аѕ††Аі†‡Аї†ˆАј†‰Аљ†ŠАњ†‹Аћ†ŒАќ†А§†ŽАў†Аџ†Б†‘Б†’Б†“Б†”Б†•Б†–Б†—Б†˜Б †™Б †šБ†›Б†œБ†Б†žБ†ŸБ† Б†ЁБ†ЂБ†ЃБ†ЄБ †ЅБ!†ІБ"†ЇБ&†ЈБ'†ЉБ)†ЊБ*†ЋБ+†ЌБ-†­Б.†ЎБ/†ЏБ0†АБ1†ББ2†ВБ3†ГБ6†ДБ:†ЕБ;†ЖБ<†ЗБ=†ИБ>†ЙБ?†КБB†ЛБC†МБE†НБF†ОБG†ПБI†РБJ†СБK†ТБL†УБM†ФБN†ХБO†ЦБR†ЧБS†ШБV†ЩБW†ЪБY†ЫБZ†ЬБ[†ЭБ]†ЮБ^†ЯБ_†аБa†бБb†вБc†гБd†дБe†еБf†жБg†зБh†иБi†йБj†кБk†лБl†мБm†нБn†оБo†пБp†рБq†сБr†тБs†уБt†фБu†хБv†цБw†чБz†шБ{†щБ}†ъБ~†ыБ†ьБ†эБƒ†юБ„†яБ…†№Б††ёБ‡†ђБŠ†ѓБŒ†єБŽ†ѕБ†іБ†їБ‘†јБ•†љБ–†њБ—†ћБ™†ќБš†§Б›†ўБ‡AБž‡BБŸ‡CБ ‡DБЁ‡EБЂ‡FБЃ‡GБЄ‡HБЅ‡IБІ‡JБЇ‡KБЉ‡LБЊ‡MБЋ‡NБЌ‡OБ­‡PБЎ‡QБЏ‡RБА‡SББ‡TБВ‡UБГ‡VБД‡WБЕ‡XБЖ‡YБЗ‡ZБИ‡aБЙ‡bБК‡cБЛ‡dБМ‡eБН‡fБО‡gБП‡hБР‡iБС‡jБТ‡kБУ‡lБФ‡mБХ‡nБЦ‡oБЧ‡pБШ‡qБЩ‡rБЪ‡sБЫ‡tБЭ‡uБЮ‡vБЯ‡wБб‡xБв‡yБг‡zБе‡Б懂Бз‡ƒБ臄Бй‡…БꇆБ뇇Бо‡ˆБр‡‰Бс‡ŠБт‡‹Бу‡ŒБф‡Бх‡ŽБц‡Бч‡Бъ‡‘Бы‡’Бэ‡“Бю‡”Бя‡•Бё‡–Бђ‡—Бѓ‡˜Бє‡™Бѕ‡šБі‡›Бї‡œБј‡Бњ‡žБќ‡ŸБў‡ Бџ‡ЁВ‡ЂВ‡ЃВ‡ЄВ‡ЅВ‡ІВ‡ЇВ ‡ЈВ ‡ЉВ ‡ЊВ‡ЋВ‡ЌВ‡­В‡ЎВ‡ЏВ‡АВ‡БВ‡ВВ‡ГВ‡ДВ‡ЕВ‡ЖВ‡ЗВ‡ИВ!‡ЙВ"‡КВ#‡ЛВ$‡МВ%‡НВ&‡ОВ'‡ПВ(‡РВ)‡СВ*‡ТВ+‡УВ,‡ФВ-‡ХВ.‡ЦВ/‡ЧВ0‡ШВ1‡ЩВ2‡ЪВ3‡ЫВ5‡ЬВ6‡ЭВ7‡ЮВ8‡ЯВ9‡аВ:‡бВ;‡вВ=‡гВ>‡дВ?‡еВ@‡жВA‡зВB‡иВC‡йВD‡кВE‡лВF‡мВG‡нВH‡оВI‡пВJ‡рВK‡сВL‡тВM‡уВN‡фВO‡хВP‡цВQ‡чВR‡шВS‡щВT‡ъВU‡ыВV‡ьВW‡эВY‡юВZ‡яВ[‡№В]‡ёВ^‡ђВ_‡ѓВa‡єВb‡ѕВc‡іВd‡їВe‡јВf‡љВg‡њВj‡ћВk‡ќВl‡§Вm‡ўВnˆAВoˆBВpˆCВqˆDВrˆEВsˆFВvˆGВwˆHВxˆIВyˆJВzˆKВ{ˆLВ}ˆMВ~ˆNВˆOВ€ˆPВˆQВ‚ˆRВƒˆSВ†ˆTВ‡ˆUВˆˆVВŠˆWВ‹ˆXВŒˆYВˆZВŽˆaВˆbВ’ˆcВ“ˆdВ•ˆeВ–ˆfВ—ˆgВ›ˆhВœˆiВˆjВžˆkВŸˆlВЂˆmВЄˆnВЇˆoВЈˆpВЉˆqВЋˆrВ­ˆsВЎˆtВЏˆuВБˆvВВˆwВГˆxВЕˆyВЖˆzВЗˆВИˆ‚ВЙˆƒВКˆ„ВЛˆ…ВМˆ†ВНˆ‡ВОˆˆВПˆ‰ВРˆŠВСˆ‹ВТˆŒВУˆВФˆŽВХˆВЦˆВЧˆ‘ВЪˆ’ВЫˆ“ВЭˆ”ВЮˆ•ВЯˆ–Вбˆ—Вгˆ˜Вдˆ™ВеˆšВжˆ›ВзˆœВкˆВмˆžВоˆŸВпˆ ВрˆЁВсˆЂВуˆЃВчˆЄВщˆЅВъˆІВ№ˆЇВёˆЈВђˆЉВіˆЊВќˆЋВ§ˆЌВўˆ­ГˆЎГˆЏГˆАГˆБГˆВГ ˆГГ ˆДГ ˆЕГ ˆЖГ ˆЗГˆИГˆЙГˆКГˆЛГˆМГˆНГˆОГˆПГˆРГˆСГˆТГˆУГ ˆФГ!ˆХГ"ˆЦГ#ˆЧГ$ˆШГ%ˆЩГ&ˆЪГ'ˆЫГ(ˆЬГ)ˆЭГ*ˆЮГ+ˆЯГ,ˆаГ-ˆбГ.ˆвГ/ˆгГ0ˆдГ1ˆеГ2ˆжГ3ˆзГ4ˆиГ5ˆйГ6ˆкГ7ˆлГ8ˆмГ9ˆнГ:ˆоГ;ˆпГ<ˆрГ=ˆсГ>ˆтГ?ˆуГ@ˆфГAˆхГBˆцГCˆчГDˆшГEˆщГFˆъГGˆыГHˆьГIˆэГJˆюГKˆяГLˆ№ГMˆёГNˆђГOˆѓГPˆєГQˆѕГRˆіГSˆїГWˆјГYˆљГZˆњГ]ˆћГ`ˆќГaˆ§ГbˆўГc‰AГf‰BГh‰CГj‰DГl‰EГm‰FГo‰GГr‰HГs‰IГu‰JГv‰KГw‰LГy‰MГz‰NГ{‰OГ|‰PГ}‰QГ~‰RГ‰SГ‚‰TГ†‰UГ‡‰VГˆ‰WГ‰‰XГŠ‰YГ‹‰ZГ‰aГŽ‰bГ‰cГ‘‰dГ’‰eГ“‰fГ•‰gГ–‰hГ—‰i؉jГ™‰kГš‰lГ›‰mГœ‰nГ‰oГž‰pГŸ‰qГЂ‰rГЃ‰sГЄ‰tГЅ‰uГІ‰vГЇ‰wГЉ‰xГЊ‰yГЋ‰zГ­‰ГЎ‰‚ГЏ‰ƒГА‰„ГБ‰…ГВ‰†ГГ‰‡ГД‰ˆГЕ‰‰ГЖ‰ŠГЗ‰‹ГИ‰ŒГЙ‰ГК‰ŽГЛ‰ГМ‰ГН‰‘ГО‰’ГП‰“ГР‰”ГС‰•ГТ‰–ГУ‰—ГЦ‰˜ГЧ‰™ГЩ‰šГЪ‰›ГЭ‰œГЯ‰Гб‰žГв‰ŸГг‰ Гж‰ЁГи‰ЂГк‰ЃГм‰ЄГо‰ЅГп‰ІГс‰ЇГт‰ЈГу‰ЉГх‰ЊГц‰ЋГч‰ЌГщ‰­Гъ‰ЎГы‰ЏГь‰АГэ‰БГю‰ВГя‰ГГ№‰ДГё‰ЕГђ‰ЖГѓ‰ЗГє‰ИГѕ‰ЙГі‰КГї‰ЛГј‰МГљ‰НГњ‰ОГћ‰ПГ§‰РГў‰СГџ‰ТД‰УД‰ФД‰ХД‰ЦД‰ЧД‰ШД‰ЩД‰ЪД‰ЫД ‰ЬД ‰ЭД ‰ЮД ‰ЯД ‰аД‰бД‰вД‰гД‰дД‰еД‰жД‰зД‰иД‰йД‰кД‰лД‰мД‰нД‰оД‰пД!‰рД"‰сД#‰тД$‰уД%‰фД&‰хД'‰цД*‰чД,‰шД-‰щД.‰ъД/‰ыД0‰ьД1‰эД2‰юД3‰яД5‰№Д6‰ёД7‰ђД8‰ѓД9‰єД:‰ѕД;‰іД<‰їД=‰јД>‰љД?‰њД@‰ћДA‰ќДB‰§ДC‰ўДDŠAДEŠBДFŠCДGŠDДHŠEДIŠFДJŠGДKŠHДLŠIДMŠJДNŠKДOŠLДRŠMДSŠNДUŠOДVŠPДWŠQДYŠRДZŠSД[ŠTД\ŠUД]ŠVД^ŠWД_ŠXДbŠYДdŠZДfŠaДgŠbДhŠcДiŠdДjŠeДkŠfДmŠgДnŠhДoŠiДpŠjДqŠkДrŠlДsŠmДtŠnДuŠoДvŠpДwŠqДxŠrДyŠsДzŠtД{ŠuД|ŠvД}ŠwД~ŠxДŠyДŠzД‚ŠДƒŠ‚Д„ŠƒД…Š„Д†Š…Д‡Š†Д‰Š‡ДŠŠˆД‹Š‰ДŒŠŠДŠ‹ДŽŠŒДŠДŠŽД‘ŠД’ŠД“Š‘Д”Š’Д•Š“Д–Š”Д—Š•Д˜Š–Д™Š—ДšŠ˜Д›Š™ДœŠšДžŠ›ДŸŠœД ŠДЁŠžДЂŠŸДЃŠ ДЅŠЁДІŠЂДЇŠЃДЉŠЄДЊŠЅДЋŠІД­ŠЇДЎŠЈДЏŠЉДАŠЊДБŠЋДВŠЌДГŠ­ДДŠЎДЖŠЏДИŠАДКŠБДЛŠВДМŠГДНŠДДОŠЕДПŠЖДСŠЗДТŠИДУŠЙДХŠКДЦŠЛДЧŠМДЩŠНДЪŠОДЫŠПДЬŠРДЭŠСДЮŠТДЯŠУДбŠФДвŠХДгŠЦДдŠЧДжŠШДзŠЩДиŠЪДйŠЫДкŠЬДлŠЭДоŠЮДпŠЯДсŠаДтŠбДхŠвДчŠгДшŠдДщŠеДъŠжДыŠзДюŠиД№ŠйДђŠкДѓŠлДєŠмДѕŠнДіŠоДїŠпДљŠрДњŠсДћŠтДќŠуД§ŠфДўŠхДџŠцЕŠчЕŠшЕŠщЕŠъЕŠыЕŠьЕŠэЕŠюЕŠяЕ Š№Е ŠёЕ ŠђЕ ŠѓЕ ŠєЕŠѕЕŠіЕŠїЕŠјЕŠљЕŠњЕŠћЕŠќЕŠ§ЕŠўЕ‹AЕ‹BЕ‹CЕ ‹DЕ!‹EЕ"‹FЕ#‹GЕ&‹HЕ+‹IЕ,‹JЕ-‹KЕ.‹LЕ/‹MЕ2‹NЕ3‹OЕ5‹PЕ6‹QЕ7‹RЕ9‹SЕ:‹TЕ;‹UЕ<‹VЕ=‹WЕ>‹XЕ?‹YЕB‹ZЕF‹aЕG‹bЕH‹cЕI‹dЕJ‹eЕN‹fЕO‹gЕQ‹hЕR‹iЕS‹jЕU‹kЕV‹lЕW‹mЕX‹nЕY‹oЕZ‹pЕ[‹qЕ^‹rЕb‹sЕc‹tЕd‹uЕe‹vЕf‹wЕg‹xЕh‹yЕi‹zЕj‹Еk‹‚Еl‹ƒЕm‹„Еn‹…Еo‹†Еp‹‡Еq‹ˆЕr‹‰Еs‹ŠЕt‹‹Еu‹ŒЕv‹Еw‹ŽЕx‹Еy‹Еz‹‘Е{‹’Е|‹“Е}‹”Е~‹•Е‹–Е€‹—Е‹˜Е‚‹™Еƒ‹šЕ„‹›Е…‹œЕ†‹Е‡‹žЕˆ‹ŸЕ‰‹ ЕŠ‹ЁЕ‹‹ЂЕŒ‹ЃЕ‹ЄЕŽ‹ЅЕ‹ІЕ‹ЇЕ‘‹ЈЕ’‹ЉЕ“‹ЊЕ”‹ЋЕ•‹ЌЕ–‹­Е—‹ЎЕ˜‹ЏЕ™‹АЕš‹БЕ›‹ВЕœ‹ГЕ‹ДЕž‹ЕЕŸ‹ЖЕЂ‹ЗЕЃ‹ИЕЅ‹ЙЕІ‹КЕЇ‹ЛЕЉ‹МЕЌ‹НЕ­‹ОЕЎ‹ПЕЏ‹РЕВ‹СЕЖ‹ТЕЗ‹УЕИ‹ФЕЙ‹ХЕК‹ЦЕО‹ЧЕП‹ШЕС‹ЩЕТ‹ЪЕУ‹ЫЕХ‹ЬЕЦ‹ЭЕЧ‹ЮЕШ‹ЯЕЩ‹аЕЪ‹бЕЫ‹вЕЮ‹гЕв‹дЕг‹еЕд‹жЕе‹зЕж‹иЕз‹йЕй‹кЕк‹лЕл‹мЕм‹нЕн‹оЕо‹пЕп‹рЕр‹сЕс‹тЕт‹уЕу‹фЕф‹хЕх‹цЕц‹чЕч‹шЕш‹щЕщ‹ъЕъ‹ыЕы‹ьЕэ‹эЕю‹юЕя‹яЕ№‹№Её‹ёЕђ‹ђЕѓ‹ѓЕє‹єЕѕ‹ѕЕі‹іЕї‹їЕј‹јЕљ‹љЕњ‹њЕћ‹ћЕќ‹ќЕ§‹§Еў‹ўЕџŒAЖŒBЖŒCЖŒDЖŒEЖŒFЖŒGЖŒHЖŒIЖŒJЖ ŒKЖ ŒLЖ ŒMЖ ŒNЖ ŒOЖŒPЖŒQЖŒRЖŒSЖŒTЖŒUЖŒVЖŒWЖŒXЖŒYЖŒZЖŒaЖŒbЖŒcЖ ŒdЖ!ŒeЖ"ŒfЖ#ŒgЖ$ŒhЖ&ŒiЖ'ŒjЖ(ŒkЖ)ŒlЖ*ŒmЖ+ŒnЖ-ŒoЖ.ŒpЖ/ŒqЖ0ŒrЖ1ŒsЖ2ŒtЖ3ŒuЖ5ŒvЖ6ŒwЖ7ŒxЖ8ŒyЖ9ŒzЖ:ŒЖ;Œ‚Ж<ŒƒЖ=Œ„Ж>Œ…Ж?Œ†Ж@Œ‡ЖAŒˆЖBŒ‰ЖCŒŠЖDŒ‹ЖEŒŒЖFŒЖGŒŽЖIŒЖJŒЖKŒ‘ЖLŒ’ЖMŒ“ЖNŒ”ЖOŒ•ЖPŒ–ЖQŒ—ЖRŒ˜ЖSŒ™ЖTŒšЖUŒ›ЖVŒœЖWŒЖXŒžЖYŒŸЖZŒ Ж[ŒЁЖ\ŒЂЖ]ŒЃЖ^ŒЄЖ_ŒЅЖ`ŒІЖaŒЇЖbŒЈЖcŒЉЖeŒЊЖfŒЋЖgŒЌЖiŒ­ЖjŒЎЖkŒЏЖlŒАЖmŒБЖnŒВЖoŒГЖpŒДЖqŒЕЖrŒЖЖsŒЗЖtŒИЖuŒЙЖvŒКЖwŒЛЖxŒМЖyŒНЖzŒОЖ{ŒПЖ|ŒРЖ}ŒСЖ~ŒТЖŒУЖ€ŒФЖŒХЖ‚ŒЦЖƒŒЧЖ„ŒШЖ…ŒЩЖ†ŒЪЖ‡ŒЫЖˆŒЬЖ‰ŒЭЖŠŒЮЖ‹ŒЯЖŒŒаЖŒбЖŽŒвЖŒгЖŒдЖ‘ŒеЖ’ŒжЖ“ŒзЖ”ŒиЖ•ŒйЖ–ŒкЖ—ŒлƘŒмЖ™ŒнЖšŒоЖ›ŒпЖžŒрЖŸŒсЖЁŒтЖЂŒуЖЃŒфЖЅŒхЖІŒцЖЇŒчЖЈŒшЖЉŒщЖЊŒъЖ­ŒыЖЎŒьЖЏŒэЖАŒюЖВŒяЖГŒ№ЖДŒёЖЕŒђЖЖŒѓЖЗŒєЖИŒѕЖЙŒіЖКŒїЖЛŒјЖМŒљЖНŒњЖОŒћЖПŒќЖРŒ§ЖСŒўЖТAЖУBЖФCЖХDЖЦEЖЧFЖШGЖЩHЖЪIЖЫJЖЬKЖЭLЖЮMЖЯNЖаOЖбPЖвQЖгRЖеSЖжTЖзUЖиVЖйWЖкXЖлYЖмZЖнaЖоbЖпcЖрdЖсeЖтfЖуgЖфhЖхiЖцjЖчkЖшlЖщmЖъnЖыoЖьpЖэqЖюrЖяsЖёtЖђuЖѓvЖѕwЖіxЖїyЖљzЖњЖћ‚ЖќƒЖ§„Жў…Жџ†З‡ЗˆЗ‰ЗŠЗ‹ЗŒЗ З ŽЗ З З ‘З’З“З”З•З–З—З˜З™ЗšЗ›ЗœЗЗžЗŸЗ ЗЁЗЂЗЃЗ ЄЗ!ЅЗ"ІЗ#ЇЗ$ЈЗ%ЉЗ&ЊЗ'ЋЗ*ЌЗ+­З-ЎЗ.ЏЗ1АЗ2БЗ3ВЗ4ГЗ5ДЗ6ЕЗ7ЖЗ:ЗЗ<ИЗ=ЙЗ>КЗ?ЛЗ@МЗAНЗBОЗCПЗEРЗFСЗGТЗIУЗJФЗKХЗMЦЗNЧЗOШЗPЩЗQЪЗRЫЗSЬЗVЭЗWЮЗXЯЗYаЗZбЗ[вЗ\гЗ]дЗ^еЗ_жЗaзЗbиЗcйЗeкЗfлЗgмЗiнЗjоЗkпЗlрЗmсЗnтЗoуЗrфЗtхЗvцЗwчЗxшЗyщЗzъЗ{ыЗ~ьЗэЗюЗ‚яЗƒ№З…ёЗ†ђЗ‡ѓЗˆєЗ‰ѕЗŠіЗ‹їЗŽјЗ“љЗ”њЗ•ћЗšќЗ›§ЗўЗžŽAЗŸŽBЗЁŽCЗЂŽDЗЃŽEЗЄŽFЗЅŽGЗІŽHЗЇŽIЗЊŽJЗЎŽKЗЏŽLЗАŽMЗБŽNЗВŽOЗГŽPЗЖŽQЗЗŽRЗЙŽSЗКŽTЗЛŽUЗМŽVЗНŽWЗОŽXЗПŽYЗРŽZЗСŽaЗТŽbЗУŽcЗФŽdЗХŽeЗЦŽfЗШŽgЗЪŽhЗЫŽiЗЬŽjЗЭŽkЗЮŽlЗЯŽmЗаŽnЗбŽoЗвŽpЗгŽqЗдŽrЗеŽsЗжŽtЗзŽuЗиŽvЗйŽwЗкŽxЗлŽyЗмŽzЗнŽЗоŽ‚ЗпŽƒЗрŽ„ЗсŽ…ЗтŽ†ЗуŽ‡ЗфŽˆЗхŽ‰ЗцŽŠЗчŽ‹ЗшŽŒЗщŽЗъŽŽЗыŽЗюŽЗяŽ‘ЗёŽ’ЗђŽ“ЗѓŽ”ЗѕŽ•ЗіŽ–ЗїŽ—ЗјŽ˜ЗљŽ™ЗњŽšЗћŽ›ЗўŽœИŽИŽžИŽŸИŽ ИŽЁИ ŽЂИ ŽЃИ ŽЄИŽЅИŽІИŽЇИŽЈИŽЉИŽЊИŽЋИŽЌИŽ­ИŽЎИŽЏИŽАИŽБИ ŽВИ!ŽГИ"ŽДИ#ŽЕИ&ŽЖИ'ŽЗИ)ŽИИ*ŽЙИ+ŽКИ-ŽЛИ.ŽМИ/ŽНИ0ŽОИ1ŽПИ2ŽРИ3ŽСИ6ŽТИ:ŽУИ;ŽФИ<ŽХИ=ŽЦИ>ŽЧИ?ŽШИAŽЩИBŽЪИCŽЫИEŽЬИFŽЭИGŽЮИHŽЯИIŽаИJŽбИKŽвИLŽгИMŽдИNŽеИOŽжИPŽзИRŽиИTŽйИUŽкИVŽлИWŽмИXŽнИYŽоИZŽпИ[ŽрИ^ŽсИ_ŽтИaŽуИbŽфИcŽхИeŽцИfŽчИgŽшИhŽщИiŽъИjŽыИkŽьИnŽэИpŽюИrŽяИsŽ№ИtŽёИuŽђИvŽѓИwŽєИyŽѕИzŽіИ{ŽїИ}ŽјИ~ŽљИŽњИ€ŽћИŽќИ‚Ž§ИƒŽўИ„AИ…BИ†CИ‡DИˆEИ‰FИŠGИ‹HИŒIИŽJИKИLИ‘MИ’NИ“OИ”PИ•QИ–RИ—SȘTИ™UИšVИ›WИœXИYИžZИŸaИ bИЁcИЂdИЃeИЄfИЅgИІhИЇiИЉjИЊkИЋlИЌmИ­nИЎoИЏpИБqИВrИГsИЕtИЖuИЗvИЙwИКxИЛyИМzИНИО‚ИПƒИТ„ИФ…ИЦ†ИЧ‡ИШˆИЩ‰ИЪŠИЫ‹ИЭŒИЮИЯŽИбИвИг‘Ие’Иж“Из”Ии•Ий–Ик—Ил˜Им™ИоšИр›ИтœИуИфžИхŸИц ИчЁИъЂИыЃИэЄИюЅИяІИёЇИђЈИѓЉИєЊИѕЋИіЌИї­ИњЎИќЏИўАИџБЙВЙГЙДЙЕЙЖЙЗЙИЙЙЙ КЙ ЛЙ МЙ НЙ ОЙПЙРЙСЙТЙУЙФЙХЙЦЙЧЙШЙЩЙЪЙЫЙЬЙЭЙЮЙЯЙ!аЙ"бЙ#вЙ$гЙ%дЙ&еЙ'жЙ(зЙ)иЙ*йЙ+кЙ,лЙ-мЙ.нЙ/оЙ0пЙ1рЙ2сЙ3тЙ4уЙ5фЙ6хЙ7цЙ8чЙ9шЙ:щЙ;ъЙ>ыЙ?ьЙAэЙBюЙCяЙE№ЙFёЙGђЙHѓЙIєЙJѕЙKіЙMїЙNјЙPљЙRњЙSћЙTќЙU§ЙVўЙWAЙZBЙ[CЙ]DЙ^EЙ_FЙaGЙbHЙcIЙdJЙeKЙfLЙgMЙjNЙlOЙnPЙoQЙpRЙqSЙrTЙsUЙvVЙwWЙyXЙzYЙ{ZЙ}aЙ~bЙcЙ€dЙeЙ‚fЙƒgЙ†hЙˆiЙ‹jЙŒkЙlЙmЙ‘nЙ’oЙ“pЙ”qЙ•rЙ–sЙ—tɘuЙ™vЙšwЙ›xЙœyЙzЙžЙŸ‚Й ƒЙЁ„ЙЂ…ЙЃ†ЙЄ‡ЙЅˆЙІ‰ЙЇŠЙЈ‹ЙЉŒЙЊЙЋŽЙЎЙЏЙБ‘ЙВ’ЙГ“ЙЕ”ЙЖ•ЙЗ–ЙИ—ЙЙ˜ЙК™ЙЛšЙО›ЙРœЙТЙУžЙФŸЙХ ЙЦЁЙЧЂЙЪЃЙЫЄЙЭЅЙгІЙдЇЙеЈЙжЉЙзЊЙкЋЙмЌЙп­ЙрЎЙтЏЙцАЙчБЙщВЙъГЙыДЙэЕЙюЖЙяЗЙ№ИЙёЙЙђКЙѓЛЙіМЙћНЙќОЙ§ПЙўРЙџСКТКУКФКХКЦКЧК ШК ЩК ЪК ЫК ЬКЭКЮКЯКаКбКвКгКдКеКжКзКиКйКкКлКмКнК оК!пК"рК#сК$тК%уК&фК'хК(цК)чК*шК+щК,ъК-ыК.ьК/эК0юК1яК2№К3ёК4ђК5ѓК6єК7ѕК:іК;їК=јК>љК?њКAћКCќКD§КEўКF‘AКG‘BКJ‘CКL‘DКO‘EКP‘FКQ‘GКR‘HКV‘IКW‘JКY‘KКZ‘LК[‘MК]‘NК^‘OК_‘PК`‘QКa‘RКb‘SКc‘TКf‘UКj‘VКk‘WКl‘XКm‘YКn‘ZКo‘aКr‘bКs‘cКu‘dКv‘eКw‘fКy‘gКz‘hК{‘iК|‘jК}‘kК~‘lК‘mК€‘nК‘oК‚‘pК†‘qКˆ‘rК‰‘sКŠ‘tК‹‘uК‘vКŽ‘wК‘xК‘yК‘‘zК’‘К“‘‚К”‘ƒК•‘„К–‘…К—‘†К˜‘‡К™‘ˆКš‘‰К›‘ŠКœ‘‹К‘ŒКž‘КŸ‘ŽК ‘КЁ‘КЂ‘‘КЃ‘’КЄ‘“КЅ‘”КІ‘•КЇ‘–КЊ‘—К­‘˜КЎ‘™КЏ‘šКБ‘›КГ‘œКД‘КЕ‘žКЖ‘ŸКЗ‘ КК‘ЁКМ‘ЂКО‘ЃКП‘ЄКР‘ЅКС‘ІКТ‘ЇКУ‘ЈКХ‘ЉКЦ‘ЊКЧ‘ЋКЩ‘ЌКЪ‘­КЫ‘ЎКЬ‘ЏКЭ‘АКЮ‘БКЯ‘ВКа‘ГКб‘ДКв‘ЕКг‘ЖКд‘ЗКе‘ИКж‘ЙКз‘ККк‘ЛКл‘МКм‘НКн‘ОКо‘ПКп‘РКр‘СКс‘ТКт‘УКу‘ФКф‘ХКх‘ЦКц‘ЧКч‘ШКш‘ЩКщ‘ЪКъ‘ЫКы‘ЬКь‘ЭКэ‘ЮКю‘ЯКя‘аК№‘бКё‘вКђ‘гКѓ‘дКє‘еКѕ‘жКі‘зКї‘иКј‘йКљ‘кКњ‘лКћ‘мК§‘нКў‘оКџ‘пЛ‘рЛ‘сЛ‘тЛ‘уЛ‘фЛ‘хЛ‘цЛ ‘чЛ ‘шЛ ‘щЛ ‘ъЛ‘ыЛ‘ьЛ‘эЛ‘юЛ‘яЛ‘№Л‘ёЛ‘ђЛ‘ѓЛ‘єЛ‘ѕЛ‘іЛ‘їЛ‘јЛ!‘љЛ"‘њЛ#‘ћЛ$‘ќЛ%‘§Л&‘ўЛ'’AЛ(’BЛ*’CЛ,’DЛ-’EЛ.’FЛ/’GЛ0’HЛ1’IЛ2’JЛ3’KЛ7’LЛ9’MЛ:’NЛ?’OЛ@’PЛA’QЛB’RЛC’SЛF’TЛH’UЛJ’VЛK’WЛL’XЛN’YЛQ’ZЛR’aЛS’bЛU’cЛV’dЛW’eЛY’fЛZ’gЛ[’hЛ\’iЛ]’jЛ^’kЛ_’lЛ`’mЛb’nЛd’oЛe’pЛf’qЛg’rЛh’sЛi’tЛj’uЛk’vЛm’wЛn’xЛo’yЛp’zЛq’Лr’‚Лs’ƒЛt’„Лu’…Лv’†Лw’‡Лx’ˆЛy’‰Лz’ŠЛ{’‹Л|’ŒЛ}’Л~’ŽЛ’Л€’Л’‘Л‚’’Лƒ’“Л„’”Л…’•Л†’–Л‡’—Л‰’˜ЛŠ’™Л‹’šЛ’›ЛŽ’œЛ’Л‘’žЛ’’ŸЛ“’ Л”’ЁЛ•’ЂЛ–’ЃЛ—’ЄЛ˜’ЅЛ™’ІЛš’ЇЛ›’ЈЛœ’ЉЛ’ЊЛž’ЋЛŸ’ЌЛ ’­ЛЁ’ЎЛЂ’ЏЛЃ’АЛЅ’БЛІ’ВЛЇ’ГЛЉ’ДЛЊ’ЕЛЋ’ЖЛ­’ЗЛЎ’ИЛЏ’ЙЛА’КЛБ’ЛЛВ’МЛГ’НЛЕ’ОЛЖ’ПЛИ’РЛЙ’СЛК’ТЛЛ’УЛМ’ФЛН’ХЛО’ЦЛП’ЧЛС’ШЛТ’ЩЛУ’ЪЛХ’ЫЛЦ’ЬЛЧ’ЭЛЩ’ЮЛЪ’ЯЛЫ’аЛЬ’бЛЭ’вЛЮ’гЛЯ’дЛб’еЛв’жЛд’зЛе’иЛж’йЛз’кЛи’лЛй’мЛк’нЛл’оЛм’пЛн’рЛо’сЛп’тЛр’уЛс’фЛт’хЛу’цЛф’чЛх’шЛц’щЛч’ъЛш’ыЛщ’ьЛъ’эЛы’юЛь’яЛэ’№Лю’ёЛя’ђЛ№’ѓЛё’єЛђ’ѕЛѓ’іЛє’їЛѕ’јЛі’љЛї’њЛњ’ћЛћ’ќЛ§’§Лў’ўМ“AМ“BМ“CМ“DМ“EМ“FМ “GМ“HМ“IМ“JМ“KМ“LМ“MМ “NМ!“OМ"“PМ#“QМ&“RМ(“SМ*“TМ+“UМ,“VМ.“WМ/“XМ2“YМ3“ZМ5“aМ6“bМ7“cМ9“dМ:“eМ;“fМ<“gМ=“hМ>“iМ?“jМB“kМF“lМG“mМH“nМJ“oМK“pМN“qМO“rМQ“sМR“tМS“uМT“vМU“wМV“xМW“yМX“zМY“МZ“‚М[“ƒМ\“„М^“…М_“†М`“‡Мa“ˆМb“‰Мc“ŠМd“‹Мe“ŒМf“Мg“ŽМh“Мi“Мj“‘Мk“’Мl““Мm“”Мn“•Мo“–Мp“—Мq“˜Мr“™Мs“šМt“›Мu“œМv“Мw“žМx“ŸМy“ Мz“ЁМ{“ЂМ|“ЃМ}“ЄМ~“ЅМ“ІМ€“ЇМ“ЈМ‚“ЉМƒ“ЊМ†“ЋМ‡“ЌМ‰“­МŠ“ЎМ“ЏМ“АМ“БМ‘“ВМ’“ГМ““ДМ–“Е̘“ЖМ›“ЗМœ“ИМ“ЙМž“КМŸ“ЛМЂ“ММЃ“НМЅ“ОМІ“ПМЉ“РМЊ“СМЋ“ТМЌ“УМ­“ФМЎ“ХМЏ“ЦМВ“ЧМЖ“ШМЗ“ЩМИ“ЪМЙ“ЫМК“ЬМЛ“ЭМО“ЮМП“ЯМС“аМТ“бМУ“вМХ“гМЦ“дМЧ“еМШ“жМЩ“зМЪ“иМЫ“йМЬ“кМЮ“лМв“мМг“нМд“оМж“пМз“рМй“сМк“тМл“уМн“фМо“хМп“цМр“чМс“шМт“щМу“ъМф“ыМх“ьМц“эМч“юМш“яМщ“№Мъ“ёМы“ђМь“ѓМэ“єМю“ѕМя“іМ№“їМё“јМђ“љМѓ“њМї“ћМљ“ќМњ“§Мћ“ўМ§”AМў”BМџ”CН”DН”EН”FН”GН”HН”IН ”JН ”KН ”LН ”MН”NН”OН”PН”QН”RН”SН”TН”UН”VН”WН”XН”YН”ZН”aН”bН”cН ”dН!”eН"”fН#”gН%”hН&”iН'”jН(”kН)”lН*”mН+”nН-”oН.”pН/”qН0”rН1”sН2”tН3”uН4”vН5”wН6”xН7”yН8”zН9”Н:”‚Н;”ƒН<”„Н=”…Н>”†Н?”‡НA”ˆНB”‰НC”ŠНD”‹НE”ŒНF”НG”ŽНJ”НK”НM”‘НN”’НO”“НQ””НR”•НS”–НT”—НU”˜НV”™НW”šНZ”›Н[”œН\”Н]”žН^”ŸН_” Н`”ЁНa”ЂНb”ЃНc”ЄНe”ЅНf”ІНg”ЇНi”ЈНj”ЉНk”ЊНl”ЋНm”ЌНn”­Нo”ЎНp”ЏНq”АНr”БНs”ВНt”ГНu”ДНv”ЕНw”ЖНx”ЗНy”ИНz”ЙН{”КН|”ЛН}”МН~”НН”ОН‚”ПНƒ”РН…”СН†”ТН‹”УНŒ”ФН”ХНŽ”ЦН”ЧН’”ШН””ЩН–”ЪН—”Ы͘”ЬН›”ЭН”ЮНž”ЯНŸ”аН ”бНЁ”вНЂ”гНЃ”дНЅ”еНІ”жНЇ”зНЈ”иНЉ”йНЊ”кНЋ”лНЌ”мН­”нНЎ”оНЏ”пНБ”рНВ”сНГ”тНД”уНЕ”фНЖ”хНЗ”цНЙ”чНК”шНЛ”щНМ”ъНН”ыНО”ьНП”эНР”юНС”яНТ”№НУ”ёНФ”ђНХ”ѓНЦ”єНЧ”ѕНШ”іНЩ”їНЪ”јНЫ”љНЬ”њНЭ”ћНЮ”ќНЯ”§На”ўНб•AНв•BНг•CНж•DНз•EНй•FНк•GНл•HНн•IНо•JНп•KНр•LНс•MНт•NНу•OНф•PНх•QНц•RНч•SНш•TНъ•UНы•VНь•WНэ•XНю•YНя•ZНё•aНђ•bНѓ•cНѕ•dНі•eНї•fНљ•gНњ•hНћ•iНќ•jН§•kНў•lНџ•mО•nО•oО•pО•qО•rО•sО •tО •uО •vО•wО•xО•yО•zО•О•‚О•ƒО•„О•…О•†О•‡О•ˆО•‰О •ŠО!•‹О"•ŒО#•О$•ŽО%•О&•О'•‘О(•’О)•“О*•”О+••О,•–О-•—О.•˜О/•™О0•šО1•›О2•œО3•О4•žО5•ŸО6• О7•ЁО8•ЂО9•ЃО:•ЄО;•ЅО<•ІО=•ЇО>•ЈО?•ЉО@•ЊОA•ЋОB•ЌОC•­ОF•ЎОG•ЏОI•АОJ•БОK•ВОM•ГОO•ДОP•ЕОQ•ЖОR•ЗОS•ИОV•ЙОX•КО\•ЛО]•МО^•НО_•ООb•ПОc•РОe•СОf•ТОg•УОi•ФОk•ХОl•ЦОm•ЧОn•ШОo•ЩОr•ЪОv•ЫОw•ЬОx•ЭОy•ЮОz•ЯО~•аО•бО•вО‚•гОƒ•дО…•еО†•жО‡•зОˆ•иО‰•йОŠ•кО‹•лОŽ•мО’•нО“•оО”•пО••рО–•сО—•тОš•уО›•фОœ•хО•цОž•чОŸ•шО •щОЁ•ъОЂ•ыОЃ•ьОЄ•эОЅ•юОІ•яОЇ•№ОЉ•ёОЊ•ђОЋ•ѓОЌ•єО­•ѕОЎ•іОЏ•їОА•јОБ•љОВ•њОГ•ћОД•ќОЕ•§ОЖ•ўОЗ–AОИ–BОЙ–CОК–DОЛ–EОМ–FОН–GОО–HОП–IОР–JОС–KОТ–LОУ–MОФ–NОХ–OОЦ–PОЧ–QОШ–RОЩ–SОЪ–TОЫ–UОЬ–VОЭ–WОЮ–XОЯ–YОв–ZОг–aОе–bОж–cОй–dОк–eОл–fОм–gОн–hОо–iОп–jОс–kОт–lОц–mОч–nОш–oОщ–pОъ–qОы–rОэ–sОю–tОя–uО№–vОё–wОђ–xОѓ–yОє–zОѕ–Оі–‚Ої–ƒОј–„Ољ–…Оњ–†Оћ–‡Оќ–ˆО§–‰Оў–ŠОџ–‹П–ŒП–П–ŽП–П–П–‘П–’П –“П –”П –•П ––П–—П–˜П–™П–šП–›П–œП–П–žП–ŸП– П–ЁП–ЂП–ЃП –ЄП!–ЅП"–ІП#–ЇП$–ЈП%–ЉП&–ЊП'–ЋП(–ЌП)–­П*–ЎП+–ЏП,–АП-–БП.–ВП/–ГП0–ДП1–ЕП2–ЖП3–ЗП4–ИП5–ЙП6–КП7–ЛП8–МП9–НП:–ОП;–ПП<–РП=–СП>–ТП?–УПB–ФПC–ХПE–ЦПF–ЧПG–ШПI–ЩПJ–ЪПK–ЫПL–ЬПM–ЭПN–ЮПO–ЯПR–аПS–бПT–вПV–гПW–дПX–еПY–жПZ–зП[–иП\–йП]–кП^–лП_–мП`–нПa–оПb–пПc–рПd–сПe–тПf–уПg–фПh–хПi–цПj–чПk–шПl–щПm–ъПn–ыПo–ьПp–эПq–юПr–яПs–№Пt–ёПu–ђПv–ѓПw–єПx–ѕПy–іПz–їП{–јП|–љП}–њП~–ћП–ќП€–§П–ўП‚—AПƒ—BП„—CП…—DП†—EП‡—FПˆ—GП‰—HПŠ—IП‹—JПŒ—KП—LПŽ—MП—NП—OП‘—PП’—QП“—RП•—SП–—TП——UϘ—VП™—WПš—XП›—YПœ—ZП—aПž—bПŸ—cП —dПЁ—eПЂ—fПЃ—gПЄ—hПЅ—iПІ—jПЇ—kПЈ—lПЉ—mПЊ—nПЋ—oПЌ—pП­—qПЎ—rПЏ—sПБ—tПВ—uПГ—vПД—wПЕ—xПЖ—yПЗ—zПИ—ПЙ—‚ПК—ƒПЛ—„ПМ—…ПН—†ПО—‡ПП—ˆПР—‰ПС—ŠПТ—‹ПУ—ŒПФ—ПЦ—ŽПЧ—ПШ—ПЩ—‘ПЪ—’ПЫ—“ПЮ—”ПЯ—•Пб—–Пв——Пг—˜Пе—™Пж—šПз—›Пи—œПй—Пк—žПл—ŸПн— По—ЁПр—ЂПт—ЃПу—ЄПф—ЅПх—ІПц—ЇПч—ЈПш—ЉПщ—ЊПъ—ЋПы—ЌПь—­Пэ—ЎПю—ЏПя—АП№—БПё—ВПђ—ГПѓ—ДПє—ЕПѕ—ЖПі—ЗПї—ИПј—ЙПљ—КПњ—ЛПћ—МПќ—НП§—ОПў—ППџ—РР—СР—ТР—УР—ФР—ХР—ЦР—ЧР—ШР—ЩР —ЪР —ЫР —ЬР —ЭР —ЮР—ЯР—аР—бР—вР—гР—дР—еР—жР—зР—иР—йР—кР—лР—мР—нР—оР—пР—рР —сР!—тР"—уР#—фР$—хР%—цР&—чР'—шР(—щР)—ъР*—ыР+—ьР,—эР-—юР.—яР/—№Р0—ёР1—ђР2—ѓР3—єР4—ѕР5—іР6—їР7—јР8—љР9—њР:—ћР;—ќР=—§Р>—ўР?˜AР@˜BРA˜CРB˜DРC˜EРD˜FРE˜GРF˜HРG˜IРH˜JРI˜KРJ˜LРK˜MРL˜NРM˜OРN˜PРO˜QРP˜RРR˜SРS˜TРT˜UРU˜VРV˜WРW˜XРY˜YРZ˜ZР[˜aР]˜bР^˜cР_˜dРa˜eРb˜fРc˜gРd˜hРe˜iРf˜jРg˜kРj˜lРk˜mРl˜nРm˜oРn˜pРo˜qРp˜rРq˜sРr˜tРs˜uРt˜vРu˜wРv˜xРw˜yРx˜zРy˜Рz˜‚Р{˜ƒР|˜„Р}˜…Р~˜†Р˜‡Р€˜ˆР˜‰Р‚˜ŠРƒ˜‹Р„˜ŒР…˜Р†˜ŽР‡˜Рˆ˜Р‰˜‘РŠ˜’Р‹˜“РŒ˜”Р˜•РŽ˜–Р˜—Р’˜˜Р“˜™Р•˜šР–˜›Р—˜œР™˜Рš˜žР›˜ŸРœ˜ Р˜ЁРž˜ЂРŸ˜ЃРЂ˜ЄРЄ˜ЅРІ˜ІРЇ˜ЇРЈ˜ЈРЉ˜ЉРЊ˜ЊРЋ˜ЋРЎ˜ЌРБ˜­Р˜ЎРǘЏРȘАРɘБРʘВР˘ГРΘДРҘЕРӘЖРԘЗР֘ИРטЙРژКРۘЛРݘМРޘНРߘОРб˜ПРв˜РРг˜СРд˜ТРе˜УРж˜ФРз˜ХРк˜ЦРо˜ЧРп˜ШРр˜ЩРс˜ЪРт˜ЫРу˜ЬРц˜ЭРч˜ЮРщ˜ЯРъ˜аРы˜бРэ˜вРю˜гРя˜дР№˜еРё˜жРђ˜зРѓ˜иРі˜йРј˜кРњ˜лРћ˜мРќ˜нР§˜оРў˜пРџ˜рС˜сС˜тС˜уС˜фС˜хС˜цС ˜чС ˜шС ˜щС ˜ъС ˜ыС˜ьС˜эС˜юС˜яС˜№С˜ёС˜ђС˜ѓС˜єС˜ѕС˜іС˜їС!˜јС"˜љС%˜њС(˜ћС)˜ќС*˜§С+˜ўС.™AС2™BС3™CС4™DС5™EС7™FС:™GС;™HС=™IС>™JС?™KСA™LСB™MСC™NСD™OСE™PСF™QСG™RСJ™SСN™TСO™UСP™VСQ™WСR™XСS™YСV™ZСW™aСY™bСZ™cС[™dС]™eС^™fС_™gС`™hСa™iСb™jСc™kСf™lСj™mСk™nСl™oСm™pСn™qСo™rСq™sСr™tСs™uСu™vСv™wСw™xСy™yСz™zС{™С|™‚С}™ƒС~™„С™…С€™†С™‡С‚™ˆСƒ™‰С„™ŠС†™‹С‡™ŒСˆ™С‰™ŽСŠ™С‹™С™‘С‘™’С’™“С“™”С•™•С—™–С˜™—С™™˜Сš™™С›™šСž™›С ™œСЂ™СЃ™žСЄ™ŸСІ™ СЇ™ЁСЊ™ЂСЋ™ЃС­™ЄСЎ™ЅСЏ™ІСБ™ЇСВ™ЈСГ™ЉСД™ЊСЕ™ЋСЖ™ЌСЗ™­СИ™ЎСЙ™ЏСК™АСЛ™БСМ™ВСО™ГСП™ДСР™ЕСС™ЖСТ™ЗСУ™ИСХ™ЙСЦ™КСЧ™ЛСЩ™МСЪ™НСЫ™ОСЭ™ПСЮ™РСЯ™ССа™ТСб™УСв™ФСг™ХСе™ЦСж™ЧСй™ШСк™ЩСл™ЪСм™ЫСн™ЬСо™ЭСп™ЮСс™ЯСт™аСу™бСх™вСц™гСч™дСщ™еСъ™жСы™зСь™иСэ™йСю™кСя™лСђ™мСє™нСѕ™оСі™пСї™рСј™сСљ™тСњ™уСћ™фСў™хСџ™цТ™чТ™шТ™щТ™ъТ™ыТ™ьТ™эТ ™юТ ™яТ ™№Т™ёТ™ђТ™ѓТ™єТ™ѕТ™іТ™їТ™јТ™љТ™њТ™ћТ™ќТ!™§Т"™ўТ#šAТ$šBТ%šCТ&šDТ'šEТ*šFТ,šGТ.šHТ0šIТ3šJТ5šKТ6šLТ7šMТ8šNТ9šOТ:šPТ;šQТ<šRТ=šSТ>šTТ?šUТ@šVТAšWТBšXТCšYТDšZТEšaТFšbТGšcТIšdТJšeТKšfТLšgТMšhТNšiТOšjТRškТSšlТUšmТVšnТWšoТYšpТZšqТ[šrТ\šsТ]štТ^šuТ_švТašwТbšxТcšyТdšzТfšТgš‚ТhšƒТiš„Тjš…Тkš†Тnš‡ТošˆТqš‰ТršŠТsš‹ТušŒТvšТwšŽТxšТyšТzš‘Т{š’Т~š“Т€š”Т‚š•Тƒš–Т„š—Т…š˜Т†š™Т‡ššТŠš›Т‹šœТŒšТšžТŽšŸТš Т‘šЁТ’šЂТ“šЃТ”šЄТ•šЅТ–šІТ—šЇТ™šЈТššЉТœšЊТžšЋТŸšЌТ š­ТЁšЎТЂšЏТЃšАТІšБТЇšВТЉšГТЊšДТЋšЕТЎšЖТЏšЗТАšИТБšЙТВšКТГšЛТЖšМТИšНТКšОТЛšПТМšРТНšСТОšТТПšУТРšФТСšХТТšЦТУšЧТФšШТХšЩТЦšЪТЧšЫТШšЬТЩšЭТЪšЮТЫšЯТЬšаТЭšбТЮšвТЯšгТаšдТбšеТвšжТгšзТдšиТеšйТжšкТзšлТиšмТйšнТкšоТлšпТоšрТпšсТсšтТтšуТхšфТцšхТчšцТшšчТщšшТъšщТюšъТ№šыТђšьТѓšэТєšюТѕšяТїš№ТњšёТ§šђТўšѓТџšєУšѕУšіУšїУšјУšљУšњУšћУ šќУ š§УšўУ›AУ›BУ›CУ›DУ›EУ›FУ›GУ›HУ›IУ›JУ›KУ›LУ ›MУ!›NУ"›OУ#›PУ&›QУ'›RУ*›SУ+›TУ,›UУ-›VУ.›WУ/›XУ0›YУ1›ZУ2›aУ3›bУ4›cУ5›dУ6›eУ7›fУ8›gУ9›hУ:›iУ;›jУ<›kУ=›lУ>›mУ?›nУ@›oУA›pУB›qУC›rУD›sУF›tУG›uУH›vУI›wУJ›xУK›yУL›zУM›УN›‚УO›ƒУP›„УQ›…УR›†УS›‡УT›ˆУU›‰УV›ŠУW›‹УX›ŒУY›УZ›ŽУ[›У\›У]›‘У^›’У_›“У`›”Уa›•Уb›–Уc›—Уd›˜Уe›™Уf›šУg››Уj›œУk›Уm›žУn›ŸУo› Уq›ЁУs›ЂУt›ЃУu›ЄУv›ЅУw›ІУz›ЇУ{›ЈУ~›ЉУ›ЊУ€›ЋУ›ЌУ‚›­Уƒ›ЎУ…›ЏУ†›АУ‡›БУ‰›ВУŠ›ГУ‹›ДУ›ЕУŽ›ЖУ›ЗУ›ИУ‘›ЙУ’›КУ“›ЛУ”›МУ•›НУ–›ОУ—›ПӘ›РУ™›СУš›ТУ››УУœ›ФУ›ХУž›ЦУŸ›ЧУ ›ШУЁ›ЩУЂ›ЪУЃ›ЫУЄ›ЬУЅ›ЭУІ›ЮУЇ›ЯУЈ›аУЉ›бУЊ›вУЋ›гУЌ›дУ­›еУЎ›жУЏ›зУА›иУБ›йУВ›кУГ›лУД›мУЕ›нУЖ›оУЗ›пУИ›рУЙ›сУК›тУЛ›уУМ›фУН›хУО›цУП›чУС›шУТ›щУУ›ъУФ›ыУХ›ьУЦ›эУЧ›юУШ›яУЩ›№УЪ›ёУЫ›ђУЬ›ѓУЭ›єУЮ›ѕУЯ›іУа›їУб›јУв›љУг›њУд›ћУе›ќУ曧Уз›ўУкœAУлœBУнœCУоœDУсœEУуœFУфœGУхœHУцœIУчœJУъœKУыœLУьœMУюœNУяœOУ№œPУёœQУђœRУѓœSУіœTУїœUУљœVУњœWУћœXУќœYУ§œZУўœaУџœbФœcФœdФœeФœfФœgФœhФœiФœjФ œkФ œlФ œmФ œnФ œoФœpФœqФœrФœsФœtФœuФœvФœwФœxФœyФœzФœФœ‚ФœƒФœ„Фœ…Фœ†Ф œ‡Ф!œˆФ"œ‰Ф#œŠФ%œ‹Ф&œŒФ'œФ(œŽФ)œФ*œФ+œ‘Ф-œ’Ф.œ“Ф/œ”Ф1œ•Ф2œ–Ф3œ—Ф5œ˜Ф6œ™Ф7œšФ8œ›Ф9œœФ:œФ;œžФ>œŸФ?œ Ф@œЁФAœЂФBœЃФCœЄФDœЅФEœІФFœЇФGœЈФIœЉФJœЊФKœЋФLœЌФMœ­ФNœЎФOœЏФPœАФQœБФRœВФSœГФTœДФUœЕФVœЖФWœЗФXœИФYœЙФZœКФ[œЛФ\œМФ]œНФ^œОФ_œПФ`œРФaœСФbœТФcœУФfœФФgœХФiœЦФjœЧФkœШФmœЩФnœЪФoœЫФpœЬФqœЭФrœЮФsœЯФvœаФwœбФxœвФzœгФ{œдФ|œеФ}œжФ~œзФœиФœйФ‚œкФƒœлФ„œмФ…œнФ†œоФ‡œпФˆœрФ‰œсФŠœтФ‹œуФŒœфФœхФŽœцФœчФœшФ‘œщФ’œъФ“œыФ•œьФ–œэФ—œюԘœяФ™œ№ФšœёФ›œђФœѓФžœєФŸœѕФ œіФЁœїФЂœјФЃœљФЄœњФЅœћФІœќФЇœ§ФЈœўФЉAФЊBФЋCФЌDФ­EФЎFФЏGФАHФБIФВJФГKФДLФЕMФЖNФЗOФЙPФКQФЛRФНSФОTФПUФРVФСWФТXФУYФФZФХaФЦbФЧcФШdФЩeФЪfФЫgФЬhФЭiФЮjФЯkФаlФбmФвnФгoФдpФеqФжrФзsФиtФйuФкvФлwФмxФнyФоzФпФр‚ФсƒФт„Фу…Фф†Фх‡ФцˆФч‰ФшŠФъ‹ФыŒФьФэŽФюФяФђ‘Фѓ’Фѕ“Фі”Фї•Фљ–Фћ—Фќ˜Ф§™ФўšХ›ХœХХžХŸХ ХЁХ ЂХ ЃХ ЄХ ЅХІХЇХЈХЉХЊХЋХЌХ­ХЎХЏХАХБХВХГХДХ ЕХ!ЖХ"ЗХ#ИХ$ЙХ%КХ&ЛХ'МХ*НХ+ОХ-ПХ.РХ/СХ1ТХ2УХ3ФХ4ХХ5ЦХ6ЧХ7ШХ:ЩХ<ЪХ>ЫХ?ЬХ@ЭХAЮХBЯХCаХFбХGвХKгХOдХPеХQжХRзХVиХZйХ[кХ\лХ_мХbнХcоХeпХfрХgсХiтХjуХkфХlхХmцХnчХoшХrщХvъХwыХxьХyэХzюХ{яХ~№ХёХђХ‚ѓХƒєХ…ѕХ†іХˆїХ‰јХŠљХ‹њХŽћХќХ’§Х“ўХ”žAХ–žBХ™žCХšžDХ›žEХžFХžžGХŸžHХЁžIХЂžJХЃžKХЄžLХЅžMХІžNХЇžOХЈžPХЊžQХЋžRХЌžSХ­žTХЎžUХЏžVХАžWХБžXХВžYХГžZХЖžaХЗžbХКžcХПždХРžeХСžfХТžgХУžhХЫžiХЭžjХЯžkХвžlХгžmХеžnХжžoХзžpХйžqХкžrХлžsХмžtХнžuХоžvХпžwХтžxХфžyХцžzХчžХшž‚ХщžƒХъž„Хыž…Хяž†Хёž‡ХђžˆХѓž‰ХѕžŠХјž‹ХљžŒХњžХћžŽЦžЦžЦž‘Ц ž’Ц ž“Ц ž”Ц ž•Цž–Цž—Цž˜Цž™ЦžšЦž›ЦžœЦžЦžžЦžŸЦž ЦžЁЦžЂЦ žЃЦ!žЄЦ"žЅЦ#žІЦ&žЇЦ'žЈЦ)žЉЦ*žЊЦ+žЋЦ/žЌЦ1ž­Ц2žЎЦ6žЏЦ8žАЦ:žБЦ<žВЦ=žГЦ>žДЦ?žЕЦBžЖЦCžЗЦEžИЦFžЙЦGžКЦIžЛЦJžМЦKžНЦLžОЦMžПЦNžРЦOžСЦRžТЦVžУЦWžФЦXžХЦYžЦЦZžЧЦ[žШЦ^žЩЦ_žЪЦažЫЦbžЬЦcžЭЦdžЮЦežЯЦfžаЦgžбЦhžвЦižгЦjžдЦkžеЦmžжЦnžзЦpžиЦržйЦsžкЦtžлЦužмЦvžнЦwžоЦzžпЦ{žрЦ}žсЦ~žтЦžуЦžфЦ‚žхЦƒžцЦ„žчЦ…žшЦ†žщЦ‡žъЦŠžыЦŒžьЦŽžэЦžюЦžяЦ‘ž№Ц’žёЦ“žђЦ–žѓЦ—žєЦ™žѕЦšžіЦ›žїЦžјЦžžљЦŸžњЦ žћЦЁžќЦЂž§ЦЃžўЦІŸAЦЈŸBЦЊŸCЦЋŸDЦЌŸEЦ­ŸFЦЎŸGЦЏŸHЦВŸIЦГŸJЦЕŸKЦЖŸLЦЗŸMЦЛŸNЦМŸOЦНŸPЦОŸQЦПŸRЦТŸSЦФŸTЦЦŸUЦЧŸVЦШŸWЦЩŸXЦЪŸYЦЫŸZЦЮŸaЦЯŸbЦбŸcЦвŸdЦгŸeЦеŸfЦжŸgЦзŸhЦиŸiЦйŸjЦкŸkЦлŸlЦоŸmЦпŸnЦтŸoЦуŸpЦфŸqЦхŸrЦцŸsЦчŸtЦъŸuЦыŸvЦэŸwЦюŸxЦяŸyЦёŸzЦђŸЦѓŸ‚ЦєŸƒЦѕŸ„ЦіŸ…ЦїŸ†ЦњŸ‡ЦћŸˆЦќŸ‰ЦўŸŠЦџŸ‹ЧŸŒЧŸЧŸŽЧŸЧŸЧŸ‘Ч Ÿ’Ч Ÿ“Ч Ÿ”Ч Ÿ•ЧŸ–ЧŸ—ЧŸ˜ЧŸ™ЧŸšЧŸ›ЧŸœЧŸЧŸžЧŸŸЧŸ ЧŸЁЧŸЂЧŸЃЧ"ŸЄЧ#ŸЅЧ%ŸІЧ&ŸЇЧ'ŸЈЧ)ŸЉЧ*ŸЊЧ+ŸЋЧ,ŸЌЧ-Ÿ­Ч.ŸЎЧ/ŸЏЧ2ŸАЧ4ŸБЧ6ŸВЧ8ŸГЧ9ŸДЧ:ŸЕЧ;ŸЖЧ>ŸЗЧ?ŸИЧAŸЙЧBŸКЧCŸЛЧEŸМЧFŸНЧGŸОЧHŸПЧIŸРЧKŸСЧNŸТЧPŸУЧYŸФЧZŸХЧ[ŸЦЧ]ŸЧЧ^ŸШЧ_ŸЩЧaŸЪЧbŸЫЧcŸЬЧdŸЭЧeŸЮЧfŸЯЧgŸаЧiŸбЧjŸвЧlŸгЧmŸдЧnŸеЧoŸжЧpŸзЧqŸиЧrŸйЧsŸкЧvŸлЧwŸмЧyŸнЧzŸоЧ{ŸпЧŸрЧ€ŸсЧŸтЧ‚ŸуЧ†ŸфЧ‹ŸхЧŒŸцЧŸчЧŸшЧ’ŸщЧ“ŸъЧ•ŸыЧ™ŸьЧ›ŸэЧœŸюЧŸяЧžŸ№ЧŸŸёЧЂŸђЧЇŸѓЧЈŸєЧЉŸѕЧЊŸіЧЋŸїЧЎŸјЧЏŸљЧБŸњЧВŸћЧГŸќЧЕŸ§ЧЖŸўЧЗ AЧИ BЧЙ CЧК DЧЛ EЧО FЧТ GЧУ HЧФ IЧХ JЧЦ KЧЧ LЧЪ MЧЫ NЧЭ OЧЯ PЧб QЧв RЧг SЧд TЧе UЧж VЧз WЧй XЧк YЧл ZЧм aЧо bЧп cЧр dЧс eЧт fЧу gЧх hЧц iЧч jЧщ kЧъ lЧы mЧэ nЧю oЧя pЧ№ qЧё rЧђ sЧѓ tЧє uЧѕ vЧі wЧї xЧј yЧљ zЧњ Чћ ‚Чќ ƒЧ§ „Чў …Чџ †Ш ‡Ш ˆШ ‰Ш ŠШ ‹Ш  ŒШ  Ш  ŽШ  Ш Ш ‘Ш ’Ш “Ш ”Ш •Ш –Ш —Ш ˜Ш ™Ш šШ! ›Ш" œШ# Ш% žШ& ŸШ'  Ш( ЁШ) ЂШ* ЃШ+ ЄШ. ЅШ0 ІШ2 ЇШ3 ЈШ4 ЉШ5 ЊШ6 ЋШ7 ЌШ9 ­Ш: ЎШ; ЏШ= АШ> БШ? ВШA ГШB ДШC ЕШD ЖШE ЗШF ИШG ЙШJ КШK ЛШN МШO НШP ОШQ ПШR РШS СШU ТШV УШW ФШX ХШY ЦШZ ЧШ[ ШШ\ ЩШ] ЪШ^ ЫШ_ ЬШ` ЭШa ЮШb ЯШc аШd бШe вШf гШg дШh еШi жШj зШk иШl йШm кШn лШo мШr нШs оШu пШv рШw сШy тШ{ уШ| фШ} хШ~ цШ чШ‚ шШ„ щШˆ ъШ‰ ыШŠ ьШŽ эШ юШ яШ‘ №Ш’ ёШ“ ђШ• ѓШ– єШ— ѕШ˜ іШ™ їШš јШ› љШœ њШž ћШ  ќШЂ §ШЃ ўШЄЁAШЅЁBШІЁCШЇЁDШЉЁEШЊЁFШЋЁGШЌЁHШ­ЁIШЎЁJШЏЁKШАЁLШБЁMШВЁNШГЁOШДЁPШЕЁQШЖЁRШЗЁSШИЁTШЙЁUШКЁVШЛЁWШОЁXШПЁYШРЁZШСЁaШТЁbШУЁcШХЁdШЦЁeШЧЁfШЩЁgШЪЁhШЫЁiШЭЁjШЮЁkШЯЁlШаЁmШбЁnШвЁoШгЁpШжЁqШиЁrШкЁsШлЁtШмЁuШнЁvШоЁwШпЁxШтЁyШуЁzШхЁШцЁ‚ШчЁƒШшЁ„ШщЁ…ШъЁ†ШыЁ‡ШьЁˆШэЁ‰ШюЁŠШяЁ‹Ш№ЁŒШёЁШђЁŽШѓЁШєЁШіЁ‘ШїЁ’ШјЁ“ШљЁ”ШњЁ•ШћЁ–ШўЁ—ШџЁ˜ЩЁ™ЩЁšЩЁ›ЩЁœЩЁЩ ЁžЩ ЁŸЩ Ё ЩЁЁ0ЁЂ0ЁЃ0ЁЄЗЁЅ %ЁІ &ЁЇЈЁЈ0ЁЉ­ЁЊ ЁЋ"%ЁЌџ<Ё­"<ЁЎ ЁЏ ЁА ЁБ ЁВ0ЁГ0ЁД0ЁЕ0 ЁЖ0 ЁЗ0 ЁИ0 ЁЙ0 ЁК0ЁЛ0ЁМ0ЁН0ЁОБЁПзЁРїЁС"`ЁТ"dЁУ"eЁФ"ЁХ"4ЁЦАЁЧ 2ЁШ 3ЁЩ!ЁЪ!+ЁЫџрЁЬџсЁЭџхЁЮ&BЁЯ&@Ёа" Ёб"ЅЁв#Ёг"Ёд"Ёе"aЁж"RЁзЇЁи ;Ёй&Ёк&Ёл%ЫЁм%ЯЁн%ЮЁо%ЧЁп%ЦЁр%ЁЁс% Ёт%ГЁу%ВЁф%НЁх%МЁц!’Ёч!Ёш!‘Ёщ!“Ёъ!”Ёы0Ёь"jЁэ"kЁю"Ёя"=Ё№"Ёё"5Ёђ"+Ёѓ",Ёє"Ёѕ" Ёі"†Ёї"‡Ёј"‚Ёљ"ƒЁњ"*Ёћ")Ёќ"'Ё§"(ЁўџтЂAЩЂBЩЂCЩЂDЩЂEЩЂFЩЂGЩЂHЩЂIЩЂJЩЂKЩЂLЩЂMЩЂNЩЂOЩ ЂPЩ!ЂQЩ"ЂRЩ#ЂSЩ$ЂTЩ%ЂUЩ&ЂVЩ'ЂWЩ(ЂXЩ)ЂYЩ*ЂZЩ+ЂaЩ-ЂbЩ.ЂcЩ/ЂdЩ0ЂeЩ1ЂfЩ2ЂgЩ3ЂhЩ5ЂiЩ6ЂjЩ7ЂkЩ8ЂlЩ9ЂmЩ:ЂnЩ;ЂoЩ<ЂpЩ=ЂqЩ>ЂrЩ?ЂsЩ@ЂtЩAЂuЩBЂvЩCЂwЩDЂxЩEЂyЩFЂzЩGЂЩHЂ‚ЩIЂƒЩJЂ„ЩKЂ…ЩLЂ†ЩMЂ‡ЩNЂˆЩOЂ‰ЩRЂŠЩSЂ‹ЩUЂŒЩVЂЩWЂŽЩYЂЩZЂЩ[Ђ‘Щ\Ђ’Щ]Ђ“Щ^Ђ”Щ_Ђ•ЩbЂ–ЩdЂ—ЩeЂ˜ЩfЂ™ЩgЂšЩhЂ›ЩiЂœЩjЂЩkЂžЩmЂŸЩnЂ ЩoЂЁ! !дЂЃ"ЂЄ"ЂЅДЂІџ^ЂЇЧЂЈиЂЉнЂЊкЂЋйЂЌИЂ­лЂЎЁЂЏПЂАаЂБ".ЂВ"ЂГ"ЂДЄЂЕ! ЂЖ 0ЂЗ%СЂИ%РЂЙ%ЗЂК%ЖЂЛ&dЂМ&`ЂН&aЂО&eЂП&gЂР&cЂС"™ЂТ%ШЂУ%ЃЂФ%аЂХ%бЂЦ%’ЂЧ%ЄЂШ%ЅЂЩ%ЈЂЪ%ЇЂЫ%ІЂЬ%ЉЂЭ&hЂЮ&ЂЯ&Ђа&Ђб&ЂвЖЂг Ђд !Ђе!•Ђж!—Ђз!™Ђи!–Ђй!˜Ђк&mЂл&iЂм&jЂн&lЂо2Ђп2Ђр!Ђс3ЧЂт!"Ђу3ТЂф3иЂх!!Ђц ЌЂчЎЃAЩqЃBЩrЃCЩsЃDЩuЃEЩvЃFЩwЃGЩxЃHЩyЃIЩzЃJЩ{ЃKЩ}ЃLЩ~ЃMЩЃNЩ€ЃOЩЃPЩ‚ЃQЩƒЃRЩ„ЃSЩ…ЃTЩ†ЃUЩ‡ЃVЩŠЃWЩ‹ЃXЩЃYЩŽЃZЩЃaЩ‘ЃbЩ’ЃcЩ“ЃdЩ”ЃeЩ•ЃfЩ–ЃgЩ—ЃhЩšЃiЩœЃjЩžЃkЩŸЃlЩ ЃmЩЁЃnЩЂЃoЩЃЃpЩЄЃqЩЅЃrЩІЃsЩЇЃtЩЈЃuЩЉЃvЩЊЃwЩЋЃxЩЌЃyЩ­ЃzЩЎЃЩЏЃ‚ЩАЃƒЩБЃ„ЩВЃ…ЩГЃ†ЩДЃ‡ЩЕЃˆЩЖЃ‰ЩЗЃŠЩИЃ‹ЩЙЃŒЩКЃЩЛЃŽЩМЃЩНЃЩОЃ‘ЩПЃ’ЩТЃ“ЩУЃ”ЩХЃ•ЩЦЃ–ЩЩЃ—ЩЫЃ˜ЩЬЃ™ЩЭЃšЩЮЃ›ЩЯЃœЩвЃЩдЃžЩзЃŸЩиЃ ЩлЃЁџЃЂџЃЃџЃЄџЃЅџЃІџЃЇџЃЈџЃЉџ ЃЊџ ЃЋџ ЃЌџ Ѓ­џ ЃЎџЃЏџЃАџЃБџЃВџЃГџЃДџЃЕџЃЖџЃЗџЃИџЃЙџЃКџЃЛџЃМџЃНџЃОџЃПџЃРџ ЃСџ!ЃТџ"ЃУџ#ЃФџ$ЃХџ%ЃЦџ&ЃЧџ'ЃШџ(ЃЩџ)ЃЪџ*ЃЫџ+ЃЬџ,ЃЭџ-ЃЮџ.ЃЯџ/Ѓаџ0Ѓбџ1Ѓвџ2Ѓгџ3Ѓдџ4Ѓеџ5Ѓжџ6Ѓзџ7Ѓиџ8Ѓйџ9Ѓкџ:Ѓлџ;ЃмџцЃнџ=Ѓоџ>Ѓпџ?Ѓрџ@ЃсџAЃтџBЃуџCЃфџDЃхџEЃцџFЃчџGЃшџHЃщџIЃъџJЃыџKЃьџLЃэџMЃюџNЃяџOЃ№џPЃёџQЃђџRЃѓџSЃєџTЃѕџUЃіџVЃїџWЃјџXЃљџYЃњџZЃћџ[Ѓќџ\Ѓ§џ]ЃўџуЄAЩоЄBЩпЄCЩсЄDЩуЄEЩхЄFЩцЄGЩшЄHЩщЄIЩъЄJЩыЄKЩюЄLЩђЄMЩѓЄNЩєЄOЩѕЄPЩіЄQЩїЄRЩњЄSЩћЄTЩ§ЄUЩўЄVЩџЄWЪЄXЪЄYЪЄZЪЄaЪЄbЪЄcЪЄdЪ ЄeЪЄfЪЄgЪЄhЪЄiЪЄjЪЄkЪЄlЪЄmЪЄnЪЄoЪЄpЪЄqЪЄrЪЄsЪЄtЪЄuЪ ЄvЪ!ЄwЪ"ЄxЪ#ЄyЪ$ЄzЪ%ЄЪ&Є‚Ъ'ЄƒЪ(Є„Ъ*Є…Ъ+Є†Ъ,Є‡Ъ-ЄˆЪ.Є‰Ъ/ЄŠЪ0Є‹Ъ1ЄŒЪ2ЄЪ3ЄŽЪ4ЄЪ5ЄЪ6Є‘Ъ7Є’Ъ8Є“Ъ9Є”Ъ:Є•Ъ;Є–Ъ<Є—Ъ=Є˜Ъ>Є™Ъ?ЄšЪ@Є›ЪAЄœЪBЄЪCЄžЪDЄŸЪEЄ ЪFЄЁ11ЄЂ12ЄЃ13ЄЄ14ЄЅ15ЄІ16ЄЇ17ЄЈ18ЄЉ19ЄЊ1:ЄЋ1;ЄЌ1<Є­1=ЄЎ1>ЄЏ1?ЄА1@ЄБ1AЄВ1BЄГ1CЄД1DЄЕ1EЄЖ1FЄЗ1GЄИ1HЄЙ1IЄК1JЄЛ1KЄМ1LЄН1MЄО1NЄП1OЄР1PЄС1QЄТ1RЄУ1SЄФ1TЄХ1UЄЦ1VЄЧ1WЄШ1XЄЩ1YЄЪ1ZЄЫ1[ЄЬ1\ЄЭ1]ЄЮ1^ЄЯ1_Єа1`Єб1aЄв1bЄг1cЄд1dЄе1eЄж1fЄз1gЄи1hЄй1iЄк1jЄл1kЄм1lЄн1mЄо1nЄп1oЄр1pЄс1qЄт1rЄу1sЄф1tЄх1uЄц1vЄч1wЄш1xЄщ1yЄъ1zЄы1{Єь1|Єэ1}Єю1~Єя1Є№1€Єё1Єђ1‚Єѓ1ƒЄє1„Єѕ1…Єі1†Єї1‡Єј1ˆЄљ1‰Єњ1ŠЄћ1‹Єќ1ŒЄ§1Єў1ŽЅAЪGЅBЪHЅCЪIЅDЪJЅEЪKЅFЪNЅGЪOЅHЪQЅIЪRЅJЪSЅKЪUЅLЪVЅMЪWЅNЪXЅOЪYЅPЪZЅQЪ[ЅRЪ^ЅSЪbЅTЪcЅUЪdЅVЪeЅWЪfЅXЪgЅYЪiЅZЪjЅaЪkЅbЪlЅcЪmЅdЪnЅeЪoЅfЪpЅgЪqЅhЪrЅiЪsЅjЪtЅkЪuЅlЪvЅmЪwЅnЪxЅoЪyЅpЪzЅqЪ{ЅrЪ|ЅsЪ~ЅtЪЅuЪ€ЅvЪЅwЪ‚ЅxЪƒЅyЪ…ЅzЪ†ЅЪ‡Ѕ‚ЪˆЅƒЪ‰Ѕ„ЪŠЅ…Ъ‹Ѕ†ЪŒЅ‡ЪЅˆЪŽЅ‰ЪЅŠЪЅ‹Ъ‘ЅŒЪ’ЅЪ“ЅŽЪ”ЅЪ•ЅЪ–Ѕ‘Ъ—Ѕ’Ъ™Ѕ“ЪšЅ”Ъ›Ѕ•ЪœЅ–ЪЅ—ЪžЅ˜ЪŸЅ™Ъ ЅšЪЁЅ›ЪЂЅœЪЃЅЪЄЅžЪЅЅŸЪІЅ ЪЇЅЁ!pЅЂ!qЅЃ!rЅЄ!sЅЅ!tЅІ!uЅЇ!vЅЈ!wЅЉ!xЅЊ!yЅА!`ЅБ!aЅВ!bЅГ!cЅД!dЅЕ!eЅЖ!fЅЗ!gЅИ!hЅЙ!iЅС‘ЅТ’ЅУ“ЅФ”ЅХ•ЅЦ–ЅЧ—ЅШ˜ЅЩ™ЅЪšЅЫ›ЅЬœЅЭЅЮžЅЯŸЅа ЅбЁЅвЃЅгЄЅдЅЅеІЅжЇЅзЈЅиЉЅсБЅтВЅуГЅфДЅхЕЅцЖЅчЗЅшИЅщЙЅъКЅыЛЅьМЅэНЅюОЅяПЅ№РЅёСЅђУЅѓФЅєХЅѕЦЅіЧЅїШЅјЩІAЪЈІBЪЉІCЪЊІDЪЋІEЪЌІFЪ­ІGЪЎІHЪЏІIЪАІJЪБІKЪВІLЪГІMЪДІNЪЕІOЪЖІPЪЗІQЪИІRЪЙІSЪКІTЪЛІUЪОІVЪПІWЪСІXЪТІYЪУІZЪХІaЪЦІbЪЧІcЪШІdЪЩІeЪЪІfЪЫІgЪЮІhЪаІiЪвІjЪдІkЪеІlЪжІmЪзІnЪкІoЪлІpЪмІqЪнІrЪоІsЪпІtЪсІuЪтІvЪуІwЪфІxЪхІyЪцІzЪчІЪшІ‚ЪщІƒЪъІ„ЪыІ…ЪэІ†ЪюІ‡ЪяІˆЪ№І‰ЪёІŠЪђІ‹ЪѓІŒЪѕІЪіІŽЪїІЪјІЪљІ‘ЪњІ’ЪћІ“ЪќІ”Ъ§І•ЪўІ–ЪџІ—ЫІ˜ЫІ™ЫІšЫІ›ЫІœЫІЫІžЫІŸЫ І Ы ІЁ%ІЂ%ІЃ% ІЄ%ІЅ%ІІ%ІЇ%ІЈ%,ІЉ%$ІЊ%4ІЋ%<ІЌ%І­%ІЎ%ІЏ%ІА%ІБ%ІВ%#ІГ%3ІД%+ІЕ%;ІЖ%KІЗ% ІИ%/ІЙ%(ІК%7ІЛ%?ІМ%ІН%0ІО%%ІП%8ІР%BІС%ІТ%ІУ%ІФ%ІХ%ІЦ%ІЧ%ІШ% ІЩ%ІЪ%ІЫ%!ІЬ%"ІЭ%&ІЮ%'ІЯ%)Іа%*Іб%-Ів%.Іг%1Ід%2Іе%5Іж%6Із%9Іи%:Ій%=Ік%>Іл%@Ім%AІн%CІо%DІп%EІр%FІс%GІт%HІу%IІф%JЇAЫ ЇBЫ ЇCЫ ЇDЫЇEЫЇFЫЇGЫЇHЫЇIЫЇJЫЇKЫЇLЫЇMЫЇNЫЇOЫЇPЫЇQЫЇRЫЇSЫ"ЇTЫ#ЇUЫ$ЇVЫ%ЇWЫ&ЇXЫ'ЇYЫ(ЇZЫ)ЇaЫ*ЇbЫ+ЇcЫ,ЇdЫ-ЇeЫ.ЇfЫ/ЇgЫ0ЇhЫ1ЇiЫ2ЇjЫ3ЇkЫ4ЇlЫ5ЇmЫ6ЇnЫ7ЇoЫ8ЇpЫ9ЇqЫ:ЇrЫ;ЇsЫ<ЇtЫ=ЇuЫ>ЇvЫ?ЇwЫ@ЇxЫBЇyЫCЇzЫDЇЫEЇ‚ЫFЇƒЫGЇ„ЫJЇ…ЫKЇ†ЫMЇ‡ЫNЇˆЫOЇ‰ЫQЇŠЫRЇ‹ЫSЇŒЫTЇЫUЇŽЫVЇЫWЇЫZЇ‘Ы[Ї’Ы\Ї“Ы^Ї”Ы_Ї•Ы`Ї–ЫaЇ—ЫbЇ˜ЫcЇ™ЫeЇšЫfЇ›ЫgЇœЫhЇЫiЇžЫjЇŸЫkЇ ЫlЇЁ3•ЇЂ3–ЇЃ3—ЇЄ!ЇЅ3˜ЇІ3ФЇЇ3ЃЇЈ3ЄЇЉ3ЅЇЊ3ІЇЋ3™ЇЌ3šЇ­3›ЇЎ3œЇЏ3ЇА3žЇБ3ŸЇВ3 ЇГ3ЁЇД3ЂЇЕ3ЪЇЖ3ЇЗ3ŽЇИ3ЇЙ3ЯЇК3ˆЇЛ3‰ЇМ3ШЇН3ЇЇО3ЈЇП3АЇР3БЇС3ВЇТ3ГЇУ3ДЇФ3ЕЇХ3ЖЇЦ3ЗЇЧ3ИЇШ3ЙЇЩ3€ЇЪ3ЇЫ3‚ЇЬ3ƒЇЭ3„ЇЮ3КЇЯ3ЛЇа3МЇб3НЇв3ОЇг3ПЇд3Їе3‘Їж3’Їз3“Їи3”Їй!&Їк3РЇл3СЇм3ŠЇн3‹Їо3ŒЇп3жЇр3ХЇс3­Їт3ЎЇу3ЏЇф3лЇх3ЉЇц3ЊЇч3ЋЇш3ЌЇщ3нЇъ3аЇы3гЇь3УЇэ3ЩЇю3мЇя3ЦЈAЫmЈBЫnЈCЫoЈDЫpЈEЫqЈFЫrЈGЫsЈHЫtЈIЫuЈJЫvЈKЫwЈLЫzЈMЫ{ЈNЫ|ЈOЫ}ЈPЫ~ЈQЫЈRЫ€ЈSЫЈTЫ‚ЈUЫƒЈVЫ„ЈWЫ…ЈXЫ†ЈYЫ‡ЈZЫˆЈaЫ‰ЈbЫŠЈcЫ‹ЈdЫŒЈeЫЈfЫŽЈgЫЈhЫЈiЫ‘ЈjЫ’ЈkЫ“ЈlЫ”ЈmЫ•ЈnЫ–ЈoЫ—ЈpۘЈqЫ™ЈrЫšЈsЫ›ЈtЫЈuЫžЈvЫŸЈwЫ ЈxЫЁЈyЫЂЈzЫЃЈЫЄЈ‚ЫЅЈƒЫІЈ„ЫЇЈ…ЫЈЈ†ЫЉЈ‡ЫЊЈˆЫЋЈ‰ЫЌЈŠЫ­Ј‹ЫЎЈŒЫЏЈЫАЈŽЫБЈЫВЈЫГЈ‘ЫДЈ’ЫЕЈ“ЫЖЈ”ЫЗЈ•ЫЙЈ–ЫКЈ—ЫЛЈ˜ЫМЈ™ЫНЈšЫОЈ›ЫПЈœЫРЈЫСЈžЫТЈŸЫУЈ ЫФЈЁЦЈЂаЈЃЊЈЄ&ЈІ2ЈЈ?ЈЉAЈЊиЈЋRЈЌКЈ­оЈЎfЈЏJЈБ2`ЈВ2aЈГ2bЈД2cЈЕ2dЈЖ2eЈЗ2fЈИ2gЈЙ2hЈК2iЈЛ2jЈМ2kЈН2lЈО2mЈП2nЈР2oЈС2pЈТ2qЈУ2rЈФ2sЈХ2tЈЦ2uЈЧ2vЈШ2wЈЩ2xЈЪ2yЈЫ2zЈЬ2{ЈЭ$аЈЮ$бЈЯ$вЈа$гЈб$дЈв$еЈг$жЈд$зЈе$иЈж$йЈз$кЈи$лЈй$мЈк$нЈл$оЈм$пЈн$рЈо$сЈп$тЈр$уЈс$фЈт$хЈу$цЈф$чЈх$шЈц$щЈч$`Јш$aЈщ$bЈъ$cЈы$dЈь$eЈэ$fЈю$gЈя$hЈ№$iЈё$jЈђ$kЈѓ$lЈє$mЈѕ$nЈіНЈї!SЈј!TЈљМЈњОЈћ![Јќ!\Ј§!]Јў!^ЉAЫХЉBЫЦЉCЫЧЉDЫШЉEЫЩЉFЫЪЉGЫЫЉHЫЬЉIЫЭЉJЫЮЉKЫЯЉLЫаЉMЫбЉNЫвЉOЫгЉPЫеЉQЫжЉRЫзЉSЫиЉTЫйЉUЫкЉVЫлЉWЫмЉXЫнЉYЫоЉZЫпЉaЫрЉbЫсЉcЫтЉdЫуЉeЫхЉfЫцЉgЫшЉhЫъЉiЫыЉjЫьЉkЫэЉlЫюЉmЫяЉnЫ№ЉoЫёЉpЫђЉqЫѓЉrЫєЉsЫѕЉtЫіЉuЫїЉvЫјЉwЫљЉxЫњЉyЫћЉzЫќЉЫ§Љ‚ЫўЉƒЫџЉ„ЬЉ…ЬЉ†ЬЉ‡ЬЉˆЬЉ‰ЬЉŠЬЉ‹ЬЉŒЬЉЬ ЉŽЬ ЉЬ ЉЬЉ‘ЬЉ’ЬЉ“ЬЉ”ЬЉ•ЬЉ–ЬЉ—ЬЉ˜ЬЉ™ЬЉšЬЉ›ЬЉœЬЉЬЉžЬ ЉŸЬ#Љ Ь$ЉЁцЉЂЉЃ№ЉЄ'ЉЅ1ЉІ3ЉЇ8ЉЈ@ЉЉBЉЊјЉЋSЉЌпЉ­ўЉЎgЉЏKЉАIЉБ2ЉВ2ЉГ2ЉД2ЉЕ2ЉЖ2ЉЗ2ЉИ2ЉЙ2ЉК2 ЉЛ2 ЉМ2 ЉН2 ЉО2 ЉП2ЉР2ЉС2ЉТ2ЉУ2ЉФ2ЉХ2ЉЦ2ЉЧ2ЉШ2ЉЩ2ЉЪ2ЉЫ2ЉЬ2ЉЭ$œЉЮ$ЉЯ$žЉа$ŸЉб$ Љв$ЁЉг$ЂЉд$ЃЉе$ЄЉж$ЅЉз$ІЉи$ЇЉй$ЈЉк$ЉЉл$ЊЉм$ЋЉн$ЌЉо$­Љп$ЎЉр$ЏЉс$АЉт$БЉу$ВЉф$ГЉх$ДЉц$ЕЉч$tЉш$uЉщ$vЉъ$wЉы$xЉь$yЉэ$zЉю${Љя$|Љ№$}Љё$~Љђ$Љѓ$€Љє$Љѕ$‚ЉіЙЉїВЉјГЉљ tЉњ Љћ Љќ ‚Љ§ ƒЉў „ЊAЬ%ЊBЬ&ЊCЬ*ЊDЬ+ЊEЬ-ЊFЬ/ЊGЬ1ЊHЬ2ЊIЬ3ЊJЬ4ЊKЬ5ЊLЬ6ЊMЬ7ЊNЬ:ЊOЬ?ЊPЬ@ЊQЬAЊRЬBЊSЬCЊTЬFЊUЬGЊVЬIЊWЬJЊXЬKЊYЬMЊZЬNЊaЬOЊbЬPЊcЬQЊdЬRЊeЬSЊfЬVЊgЬZЊhЬ[ЊiЬ\ЊjЬ]ЊkЬ^ЊlЬ_ЊmЬaЊnЬbЊoЬcЊpЬeЊqЬgЊrЬiЊsЬjЊtЬkЊuЬlЊvЬmЊwЬnЊxЬoЊyЬqЊzЬrЊЬsЊ‚ЬtЊƒЬvЊ„ЬwЊ…ЬxЊ†ЬyЊ‡ЬzЊˆЬ{Њ‰Ь|ЊŠЬ}Њ‹Ь~ЊŒЬЊЬ€ЊŽЬЊЬ‚ЊЬƒЊ‘Ь„Њ’Ь…Њ“Ь†Њ”Ь‡Њ•ЬˆЊ–Ь‰Њ—ЬŠЊ˜Ь‹Њ™ЬŒЊšЬЊ›ЬŽЊœЬЊЬЊžЬ‘ЊŸЬ’Њ Ь“ЊЁ0AЊЂ0BЊЃ0CЊЄ0DЊЅ0EЊІ0FЊЇ0GЊЈ0HЊЉ0IЊЊ0JЊЋ0KЊЌ0LЊ­0MЊЎ0NЊЏ0OЊА0PЊБ0QЊВ0RЊГ0SЊД0TЊЕ0UЊЖ0VЊЗ0WЊИ0XЊЙ0YЊК0ZЊЛ0[ЊМ0\ЊН0]ЊО0^ЊП0_ЊР0`ЊС0aЊТ0bЊУ0cЊФ0dЊХ0eЊЦ0fЊЧ0gЊШ0hЊЩ0iЊЪ0jЊЫ0kЊЬ0lЊЭ0mЊЮ0nЊЯ0oЊа0pЊб0qЊв0rЊг0sЊд0tЊе0uЊж0vЊз0wЊи0xЊй0yЊк0zЊл0{Њм0|Њн0}Њо0~Њп0Њр0€Њс0Њт0‚Њу0ƒЊф0„Њх0…Њц0†Њч0‡Њш0ˆЊщ0‰Њъ0ŠЊы0‹Њь0ŒЊэ0Њю0ŽЊя0Њ№0Њё0‘Њђ0’Њѓ0“ЋAЬ”ЋBЬ•ЋCЬ–ЋDЬ—ЋEЬšЋFЬ›ЋGЬЋHЬžЋIЬŸЋJЬЁЋKЬЂЋLЬЃЋMЬЄЋNЬЅЋOЬІЋPЬЇЋQЬЊЋRЬЎЋSЬЏЋTЬАЋUЬБЋVЬВЋWЬГЋXЬЖЋYЬЗЋZЬЙЋaЬКЋbЬЛЋcЬНЋdЬОЋeЬПЋfЬРЋgЬСЋhЬТЋiЬУЋjЬЦЋkЬШЋlЬЪЋmЬЫЋnЬЬЋoЬЭЋpЬЮЋqЬЯЋrЬбЋsЬвЋtЬгЋuЬеЋvЬжЋwЬзЋxЬиЋyЬйЋzЬкЋЬлЋ‚ЬмЋƒЬнЋ„ЬоЋ…ЬпЋ†ЬрЋ‡ЬсЋˆЬтЋ‰ЬуЋŠЬхЋ‹ЬцЋŒЬчЋЬшЋŽЬщЋЬъЋЬыЋ‘ЬэЋ’ЬюЋ“ЬяЋ”ЬёЋ•ЬђЋ–ЬѓЋ—ЬєЋ˜ЬѕЋ™ЬіЋšЬїЋ›ЬјЋœЬљЋЬњЋžЬћЋŸЬќЋ Ь§ЋЁ0ЁЋЂ0ЂЋЃ0ЃЋЄ0ЄЋЅ0ЅЋІ0ІЋЇ0ЇЋЈ0ЈЋЉ0ЉЋЊ0ЊЋЋ0ЋЋЌ0ЌЋ­0­ЋЎ0ЎЋЏ0ЏЋА0АЋБ0БЋВ0ВЋГ0ГЋД0ДЋЕ0ЕЋЖ0ЖЋЗ0ЗЋИ0ИЋЙ0ЙЋК0КЋЛ0ЛЋМ0МЋН0НЋО0ОЋП0ПЋР0РЋС0СЋТ0ТЋУ0УЋФ0ФЋХ0ХЋЦ0ЦЋЧ0ЧЋШ0ШЋЩ0ЩЋЪ0ЪЋЫ0ЫЋЬ0ЬЋЭ0ЭЋЮ0ЮЋЯ0ЯЋа0аЋб0бЋв0вЋг0гЋд0дЋе0еЋж0жЋз0зЋи0иЋй0йЋк0кЋл0лЋм0мЋн0нЋо0оЋп0пЋр0рЋс0сЋт0тЋу0уЋф0фЋх0хЋц0цЋч0чЋш0шЋщ0щЋъ0ъЋы0ыЋь0ьЋэ0эЋю0юЋя0яЋ№0№Ћё0ёЋђ0ђЋѓ0ѓЋє0єЋѕ0ѕЋі0іЌAЬўЌBЬџЌCЭЌDЭЌEЭЌFЭЌGЭЌHЭЌIЭЌJЭ ЌKЭ ЌLЭ ЌMЭЌNЭЌOЭЌPЭЌQЭЌRЭЌSЭЌTЭЌUЭЌVЭЌWЭЌXЭЌYЭЌZЭ ЌaЭ!ЌbЭ"ЌcЭ#ЌdЭ%ЌeЭ&ЌfЭ'ЌgЭ)ЌhЭ*ЌiЭ+ЌjЭ-ЌkЭ.ЌlЭ/ЌmЭ0ЌnЭ1ЌoЭ2ЌpЭ3ЌqЭ4ЌrЭ5ЌsЭ6ЌtЭ7ЌuЭ8ЌvЭ:ЌwЭ;ЌxЭ<ЌyЭ=ЌzЭ>ЌЭ?Ќ‚Э@ЌƒЭAЌ„ЭBЌ…ЭCЌ†ЭDЌ‡ЭEЌˆЭFЌ‰ЭGЌŠЭHЌ‹ЭIЌŒЭJЌЭKЌŽЭLЌЭMЌЭNЌ‘ЭOЌ’ЭPЌ“ЭQЌ”ЭRЌ•ЭSЌ–ЭTЌ—ЭUЌ˜ЭVЌ™ЭWЌšЭXЌ›ЭYЌœЭZЌЭ[ЌžЭ]ЌŸЭ^Ќ Э_ЌЁЌЂЌЃЌЄЌЅЌІЌЇЌЈЌЉЌЊЌЋЌЌЌ­ЌЎЌЏЌАЌБЌВ ЌГ!ЌД"ЌЕ#ЌЖ$ЌЗ%ЌИ&ЌЙ'ЌК(ЌЛ)ЌМ*ЌН+ЌО,ЌП-ЌР.ЌС/Ќб0Ќв1Ќг2Ќд3Ќе4Ќж5ЌзQЌи6Ќй7Ќк8Ќл9Ќм:Ќн;Ќо<Ќп=Ќр>Ќс?Ќт@ЌуAЌфBЌхCЌцDЌчEЌшFЌщGЌъHЌыIЌьJЌэKЌюLЌяMЌ№NЌёO­AЭa­BЭb­CЭc­DЭe­EЭf­FЭg­GЭh­HЭi­IЭj­JЭk­KЭn­LЭp­MЭr­NЭs­OЭt­PЭu­QЭv­RЭw­SЭy­TЭz­UЭ{­VЭ|­WЭ}­XЭ~­YЭ­ZЭ€­aЭ­bЭ‚­cЭƒ­dЭ„­eЭ…­fЭ†­gЭ‡­hЭ‰­iЭŠ­jЭ‹­kЭŒ­lЭ­mЭŽ­nЭ­oЭ­pЭ‘­qЭ’­rЭ“­sЭ–­tЭ—­uЭ™­vЭš­wЭ›­xЭ­yЭž­zЭŸ­Э ­‚ЭЁ­ƒЭЂ­„ЭЃ­…ЭІ­†ЭЈ­‡ЭЊ­ˆЭЋ­‰ЭЌ­ŠЭ­­‹ЭЎ­ŒЭЏ­ЭБ­ŽЭВ­ЭГ­ЭД­‘ЭЕ­’ЭЖ­“ЭЗ­”ЭИ­•ЭЙ­–ЭК­—ЭЛ­˜ЭМ­™ЭН­šЭО­›ЭП­œЭР­ЭС­žЭТ­ŸЭУ­ ЭХЎAЭЦЎBЭЧЎCЭШЎDЭЩЎEЭЪЎFЭЫЎGЭЭЎHЭЮЎIЭЯЎJЭбЎKЭвЎLЭгЎMЭдЎNЭеЎOЭжЎPЭзЎQЭиЎRЭйЎSЭкЎTЭлЎUЭмЎVЭнЎWЭоЎXЭпЎYЭрЎZЭсЎaЭтЎbЭуЎcЭфЎdЭхЎeЭцЎfЭчЎgЭщЎhЭъЎiЭыЎjЭэЎkЭюЎlЭяЎmЭёЎnЭђЎoЭѓЎpЭєЎqЭѕЎrЭіЎsЭїЎtЭњЎuЭќЎvЭўЎwЭџЎxЮЎyЮЎzЮЎЮЎ‚ЮЎƒЮЎ„ЮЎ…Ю Ў†Ю Ў‡Ю ЎˆЮ Ў‰ЮЎŠЮЎ‹ЮЎŒЮЎЮЎŽЮЎЮЎЮЎ‘ЮЎ’ЮЎ“ЮЎ”ЮЎ•ЮЎ–ЮЎ—ЮЎ˜ЮЎ™Ю"ЎšЮ#Ў›Ю%ЎœЮ&ЎЮ'ЎžЮ)ЎŸЮ*Ў Ю+ЏAЮ,ЏBЮ-ЏCЮ.ЏDЮ/ЏEЮ2ЏFЮ4ЏGЮ6ЏHЮ7ЏIЮ8ЏJЮ9ЏKЮ:ЏLЮ;ЏMЮ<ЏNЮ=ЏOЮ>ЏPЮ?ЏQЮ@ЏRЮAЏSЮBЏTЮCЏUЮDЏVЮEЏWЮFЏXЮGЏYЮHЏZЮIЏaЮJЏbЮKЏcЮLЏdЮMЏeЮNЏfЮOЏgЮPЏhЮQЏiЮRЏjЮSЏkЮTЏlЮUЏmЮVЏnЮWЏoЮZЏpЮ[ЏqЮ]ЏrЮ^ЏsЮbЏtЮcЏuЮdЏvЮeЏwЮfЏxЮgЏyЮjЏzЮlЏЮnЏ‚ЮoЏƒЮpЏ„ЮqЏ…ЮrЏ†ЮsЏ‡ЮvЏˆЮwЏ‰ЮyЏŠЮzЏ‹Ю{ЏŒЮ}ЏЮ~ЏŽЮЏЮ€ЏЮЏ‘Ю‚Џ’ЮƒЏ“Ю†Џ”ЮˆЏ•ЮŠЏ–Ю‹Џ—ЮŒЏ˜ЮЏ™ЮŽЏšЮЏ›Ю’ЏœЮ“ЏЮ•ЏžЮ–ЏŸЮ—Џ Ю™АAЮšАBЮ›АCЮœАDЮАEЮžАFЮŸАGЮЂАHЮІАIЮЇАJЮЈАKЮЉАLЮЊАMЮЋАNЮЎАOЮЏАPЮААQЮБАRЮВАSЮГАTЮДАUЮЕАVЮЖАWЮЗАXЮИАYЮЙАZЮКАaЮЛАbЮМАcЮНАdЮОАeЮПАfЮРАgЮТАhЮУАiЮФАjЮХАkЮЦАlЮЧАmЮШАnЮЩАoЮЪАpЮЫАqЮЬАrЮЭАsЮЮАtЮЯАuЮаАvЮбАwЮвАxЮгАyЮдАzЮеАЮжА‚ЮзАƒЮиА„ЮйА…ЮкА†ЮлА‡ЮмАˆЮнА‰ЮоАŠЮпА‹ЮрАŒЮсАЮтАŽЮуАЮцАЮчА‘ЮщА’ЮъА“ЮэА”ЮюА•ЮяА–Ю№А—ЮёА˜ЮђА™ЮѓАšЮіА›ЮњАœЮћАЮќАžЮ§АŸЮўА ЮџАЁЌАЂЌАЃЌАЄЌАЅЌАІЌ АЇЌ АЈЌАЉЌАЊЌАЋЌАЌЌА­ЌАЎЌАЏЌААЌАБЌАВЌАГЌАДЌАЕЌ АЖЌ$АЗЌ,АИЌ-АЙЌ/АКЌ0АЛЌ1АМЌ8АНЌ9АОЌ<АПЌ@АРЌKАСЌMАТЌTАУЌXАФЌ\АХЌpАЦЌqАЧЌtАШЌwАЩЌxАЪЌzАЫЌ€АЬЌАЭЌƒАЮЌ„АЯЌ…АаЌ†АбЌ‰АвЌŠАгЌ‹АдЌŒАеЌАжЌ”АзЌœАиЌАйЌŸАкЌ АлЌЁАмЌЈАнЌЉАоЌЊАпЌЌАрЌЏАсЌААтЌИАуЌЙАфЌЛАхЌМАцЌНАчЌСАшЌФАщЌШАъЌЬАыЌеАьЌзАэЌрАюЌсАяЌфА№ЌчАёЌшАђЌъАѓЌьАєЌяАѕЌ№АіЌёАїЌѓАјЌѕАљЌіАњЌќАћЌ§Аќ­А§­Аў­БAЯБBЯБCЯБDЯБEЯБFЯ БGЯ БHЯ БIЯ БJЯ БKЯБLЯБMЯБNЯБOЯБPЯБQЯБRЯБSЯБTЯБUЯБVЯБWЯБXЯ!БYЯ"БZЯ#БaЯ%БbЯ&БcЯ'БdЯ(БeЯ)БfЯ*БgЯ+БhЯ.БiЯ2БjЯ3БkЯ4БlЯ5БmЯ6БnЯ7БoЯ9БpЯ:БqЯ;БrЯ<БsЯ=БtЯ>БuЯ?БvЯ@БwЯAБxЯBБyЯCБzЯDБЯEБ‚ЯFБƒЯGБ„ЯHБ…ЯIБ†ЯJБ‡ЯKБˆЯLБ‰ЯMБŠЯNБ‹ЯOБŒЯPБЯQБŽЯRБЯSБЯVБ‘ЯWБ’ЯYБ“ЯZБ”Я[Б•Я]Б–Я^Б—Я_Б˜Я`Б™ЯaБšЯbБ›ЯcБœЯfБЯhБžЯjБŸЯkБ ЯlБЁ­ БЂ­ БЃ­БЄ­БЅ­БІ­БЇ­ БЈ­)БЉ­,БЊ­-БЋ­4БЌ­5Б­­8БЎ­<БЏ­DБА­EББ­GБВ­IБГ­PБД­TБЕ­XБЖ­aБЗ­cБИ­lБЙ­mБК­pБЛ­sБМ­tБН­uБО­vБП­{БР­|БС­}БТ­БУ­БФ­‚БХ­ˆБЦ­‰БЧ­ŒБШ­БЩ­œБЪ­БЫ­ЄБЬ­ЗБЭ­РБЮ­СБЯ­ФБа­ШБб­аБв­бБг­гБд­мБе­рБж­фБз­јБи­љБй­ќБк­џБлЎБмЎБнЎБоЎ БпЎ БрЎ БсЎБтЎ0БуЎ1БфЎ4БхЎ7БцЎ8БчЎ:БшЎ@БщЎAБъЎCБыЎEБьЎFБэЎJБюЎLБяЎMБ№ЎNБёЎPБђЎTБѓЎVБєЎ\БѕЎ]БіЎ_БїЎ`БјЎaБљЎeБњЎhБћЎiБќЎlБ§ЎpБўЎxВAЯmВBЯnВCЯoВDЯrВEЯsВFЯuВGЯvВHЯwВIЯyВJЯzВKЯ{ВLЯ|ВMЯ}ВNЯ~ВOЯВPЯВQЯ‚ВRЯƒВSЯ„ВTЯ†ВUЯ‡ВVЯˆВWЯ‰ВXЯŠВYЯ‹ВZЯВaЯŽВbЯВcЯВdЯ‘ВeЯ’ВfЯ“ВgЯ”ВhЯ•ВiЯ–ВjЯ—ВkߘВlЯ™ВmЯšВnЯ›ВoЯœВpЯВqЯžВrЯŸВsЯ ВtЯЂВuЯЃВvЯЄВwЯЅВxЯІВyЯЇВzЯЉВЯЊВ‚ЯЋВƒЯЌВ„Я­В…ЯЎВ†ЯЏВ‡ЯБВˆЯВВ‰ЯГВŠЯДВ‹ЯЕВŒЯЖВЯЗВŽЯИВЯЙВЯКВ‘ЯЛВ’ЯМВ“ЯНВ”ЯОВ•ЯПВ–ЯРВ—ЯС˜ЯТВ™ЯУВšЯХВ›ЯЦВœЯЧВЯШВžЯЩВŸЯЪВ ЯЫВЁЎyВЂЎ{ВЃЎ|ВЄЎ}ВЅЎ„ВІЎ…ВЇЎŒВЈЎМВЉЎНВЊЎОВЋЎРВЌЎФВ­ЎЬВЎЎЭВЏЎЯВАЎаВБЎбВВЎиВГЎйВДЎмВЕЎшВЖЎыВЗЎэВИЎєВЙЎјВКЎќВЛЏВМЏВНЏ ВОЏВПЏ,ВРЏ-ВСЏ0ВТЏ2ВУЏ4ВФЏ<ВХЏ=ВЦЏ?ВЧЏAВШЏBВЩЏCВЪЏHВЫЏIВЬЏPВЭЏ\ВЮЏ]ВЯЏdВаЏeВбЏyВвЏ€ВгЏ„ВдЏˆВеЏВжЏ‘ВзЏ•ВиЏœВйЏИВкЏЙВлЏМВмЏРВнЏЧВоЏШВпЏЩВрЏЫВсЏЭВтЏЮВуЏдВфЏмВхЏшВцЏщВчЏ№ВшЏёВщЏєВъЏјВыАВьАВэАВюА ВяАВ№АВёАВђАВѓА(ВєАDВѕАEВіАHВїАJВјАLВљАNВњАSВћАTВќАUВ§АWВўАYГAЯЬГBЯЭГCЯЮГDЯЯГEЯаГFЯбГGЯвГHЯгГIЯдГJЯеГKЯжГLЯзГMЯиГNЯйГOЯкГPЯлГQЯмГRЯнГSЯоГTЯпГUЯтГVЯуГWЯхГXЯцГYЯчГZЯщГaЯъГbЯыГcЯьГdЯэГeЯюГfЯяГgЯђГhЯєГiЯіГjЯїГkЯјГlЯљГmЯњГnЯћГoЯ§ГpЯўГqЯџГrаГsаГtаГuаГvаГwаГxаГyа Гzа Га Г‚а Гƒа Г„аГ…аГ†аГ‡аГˆаГ‰аГŠаГ‹аГŒаГаГŽаГаГаГ‘аГ’аГ“аГ”а Г•а!Г–а"Г—а#Øа$Г™а%Гšа&Г›а'Гœа(Га)Гžа*ГŸа+Г а,ГЁА]ГЂА|ГЃА}ГЄА€ГЅА„ГІАŒГЇАГЈАГЉА‘ГЊА˜ГЋА™ГЌАšГ­АœГЎАŸГЏА ГААЁГБАЂГВАЈГГАЉГДАЋГЕАЌГЖА­ГЗАЎГИАЏГЙАБГКАГГЛАДГМАЕГНАИГОАМГПАФГРАХГСАЧГТАШГУАЩГФАаГХАбГЦАдГЧАиГШАрГЩАхГЪБГЫБ ГЬБ ГЭБ ГЮБГЯБГаБГбБГвБГгБГдБГеБГжБ#ГзБ$ГиБ%ГйБ(ГкБ,ГлБ4ГмБ5ГнБ7ГоБ8ГпБ9ГрБ@ГсБAГтБDГуБHГфБPГхБQГцБTГчБUГшБXГщБ\ГъБ`ГыБxГьБyГэБ|ГюБ€ГяБ‚Г№БˆГёБ‰ГђБ‹ГѓБГєБ’ГѕБ“ГіБ”ГїБ˜ГјБœГљБЈГњБЬГћБаГќБдГ§БмГўБнДAа.ДBа/ДCа0ДDа1ДEа2ДFа3ДGа6ДHа7ДIа9ДJа:ДKа;ДLа=ДMа>ДNа?ДOа@ДPаAДQаBДRаCДSаFДTаHДUаJДVаKДWаLДXаMДYаNДZаOДaаQДbаRДcаSДdаUДeаVДfаWДgаYДhаZДiа[Дjа\Дkа]Дlа^Дmа_ДnаaДoаbДpаcДqаdДrаeДsаfДtаgДuаhДvаiДwаjДxаkДyаnДzаoДаqД‚аrДƒаsД„аuД…аvД†аwД‡аxДˆаyД‰аzДŠа{Д‹а~ДŒаДа€ДŽа‚ДаƒДа„Д‘а…Д’а†Д“а‡Д”аˆД•а‰Д–аŠД—а‹Д˜аŒД™аДšаŽД›аДœаДа‘Дžа’ДŸа“Д а”ДЁБпДЂБшДЃБщДЄБьДЅБ№ДІБљДЇБћДЈБ§ДЉВДЊВДЋВДЌВ Д­В ДЎВДЏВДАВДБВДВВ ДГВ4ДДВ<ДЕВXДЖВ\ДЗВ`ДИВhДЙВiДКВtДЛВuДМВ|ДНВ„ДОВ…ДПВ‰ДРВДСВ‘ДТВ”ДУ˜ДФВ™ДХВšДЦВ ДЧВЁДШВЃДЩВЅДЪВІДЫВЊДЬВЌДЭВАДЮВДДЯВШДаВЩДбВЬДвВаДгВвДдВиДеВйДжВлДзВнДиВтДйВфДкВхДлВцДмВшДнВыДоВьДпВэДрВюДсВяДтВѓДуВєДфВѕДхВїДцВјДчВљДшВњДщВћДъВџДыГДьГДэГДюГДяГД№ГДёГДђГДѓГДєГДѕГTДіГUДїГVДјГXДљГ[ДњГ\ДћГ^ДќГ_Д§ГdДўГeЕAа•ЕBа–ЕCа—ЕDа˜ЕEа™ЕFаšЕGа›ЕHаœЕIаЕJаžЕKаŸЕLа ЕMаЁЕNаЂЕOаЃЕPаІЕQаЇЕRаЉЕSаЊЕTаЋЕUа­ЕVаЎЕWаЏЕXаАЕYаБЕZаВЕaаГЕbаЖЕcаИЕdаКЕeаЛЕfаМЕgаНЕhаОЕiаПЕjаТЕkаУЕlаХЕmаЦЕnаЧЕoаЪЕpаЫЕqаЬЕrаЭЕsаЮЕtаЯЕuавЕvажЕwазЕxаиЕyайЕzакЕалЕ‚аоЕƒапЕ„асЕ…атЕ†ауЕ‡ахЕˆацЕ‰ачЕŠашЕ‹ащЕŒаъЕаыЕŽаюЕађЕаѓЕ‘аєЕ’аѕЕ“аіЕ”аїЕ•аљЕ–ањЕ—аћЕ˜аќЕ™а§ЕšаўЕ›аџЕœбЕбЕžбЕŸбЕ бЕЁГgЕЂГiЕЃГkЕЄГnЕЅГpЕІГqЕЇГtЕЈГxЕЉГ€ЕЊГЕЋГƒЕЌГ„Е­Г…ЕЎГŒЕЏГЕАГ”ЕБГ ЕВГЁЕГГЈЕДГЌЕЕГФЕЖГХЕЗГШЕИГЫЕЙГЬЕКГЮЕЛГаЕМГдЕНГеЕОГзЕПГйЕРГлЕСГнЕТГрЕУГфЕФГшЕХГќЕЦДЕЧДЕШДЕЩД ЕЪД(ЕЫД)ЕЬД+ЕЭД4ЕЮДPЕЯДQЕаДTЕбДXЕвД`ЕгДaЕдДcЕеДeЕжДlЕзД€ЕиДˆЕйДЕкДЄЕлДЈЕмДЌЕнДЕЕоДЗЕпДЙЕрДРЕсДФЕтДШЕуДаЕфДеЕхДмЕцДнЕчДрЕшДуЕщДфЕъДцЕыДьЕьДэЕэДяЕюДёЕяДјЕ№ЕЕёЕЕђЕЕѓЕЕєЕЕѕЕ$ЕіЕ%ЕїЕ'ЕјЕ(ЕљЕ)ЕњЕ*ЕћЕ0ЕќЕ1Е§Е4ЕўЕ8ЖAбЖBбЖCбЖDбЖEб ЖFб ЖGб ЖHб ЖIбЖJбЖKбЖLбЖMбЖNбЖOбЖPбЖQбЖRбЖSбЖTбЖUбЖVбЖWбЖXбЖYбЖZбЖaб Жbб!Жcб"Жdб#Жeб$Жfб%Жgб&Жhб'Жiб(Жjб)Жkб*Жlб+Жmб,Жnб-Жoб.Жpб/Жqб2Жrб3Жsб5Жtб6Жuб7Жvб9Жwб;Жxб<Жyб=Жzб>Жб?Ж‚бBЖƒбFЖ„бGЖ…бHЖ†бIЖ‡бJЖˆбKЖ‰бNЖŠбOЖ‹бQЖŒбRЖбSЖŽбUЖбVЖбWЖ‘бXЖ’бYЖ“бZЖ”б[Ж•б^Ж–б`Ж—бbƘбcЖ™бdЖšбeЖ›бfЖœбgЖбiЖžбjЖŸбkЖ бmЖЁЕ@ЖЂЕAЖЃЕCЖЄЕDЖЅЕEЖІЕKЖЇЕLЖЈЕMЖЉЕPЖЊЕTЖЋЕ\ЖЌЕ]Ж­Е_ЖЎЕ`ЖЏЕaЖАЕ ЖБЕЁЖВЕЄЖГЕЈЖДЕЊЖЕЕЋЖЖЕАЖЗЕБЖИЕГЖЙЕДЖКЕЕЖЛЕЛЖМЕМЖНЕНЖОЕРЖПЕФЖРЕЬЖСЕЭЖТЕЯЖУЕаЖФЕбЖХЕиЖЦЕьЖЧЖЖШЖЖЩЖЖЪЖЖЫЖ%ЖЬЖ,ЖЭЖ4ЖЮЖHЖЯЖdЖаЖhЖбЖœЖвЖЖгЖ ЖдЖЄЖеЖЋЖжЖЌЖзЖБЖиЖдЖйЖ№ЖкЖєЖлЖјЖмЗЖнЗЖоЗЖпЗ(ЖрЗ)ЖсЗ,ЖтЗ/ЖуЗ0ЖфЗ8ЖхЗ9ЖцЗ;ЖчЗDЖшЗHЖщЗLЖъЗTЖыЗUЖьЗ`ЖэЗdЖюЗhЖяЗpЖ№ЗqЖёЗsЖђЗuЖѓЗ|ЖєЗ}ЖѕЗ€ЖіЗ„ЖїЗŒЖјЗЖљЗЖњЗЖћЗ‘ЖќЗ’Ж§З–ЖўЗ—ЗAбnЗBбoЗCбpЗDбqЗEбrЗFбsЗGбtЗHбuЗIбvЗJбwЗKбxЗLбyЗMбzЗNб{ЗOб}ЗPб~ЗQбЗRб€ЗSбЗTб‚ЗUбƒЗVб…ЗWб†ЗXб‡ЗYб‰ЗZбŠЗaб‹ЗbбŒЗcбЗdбŽЗeбЗfбЗgб‘Зhб’Зiб“Зjб”Зkб•Зlб–Зmб—Зnб˜Зoб™ЗpбšЗqб›ЗrбœЗsбЗtбžЗuбŸЗvбЂЗwбЃЗxбЅЗyбІЗzбЇЗбЉЗ‚бЊЗƒбЋЗ„бЌЗ…б­З†бЎЗ‡бЏЗˆбВЗ‰бДЗŠбЖЗ‹бЗЗŒбИЗбЙЗŽбЛЗбНЗбОЗ‘бПЗ’бСЗ“бТЗ”бУЗ•бФЗ–бХЗ—бЦǘбЧЗ™бШЗšбЩЗ›бЪЗœбЫЗбЬЗžбЭЗŸбЮЗ бЯЗЁЗ˜ЗЂЗ™ЗЃЗœЗЄЗ ЗЅЗЈЗІЗЉЗЇЗЋЗЈЗЌЗЉЗ­ЗЊЗДЗЋЗЕЗЌЗИЗ­ЗЧЗЎЗЩЗЏЗьЗАЗэЗБЗ№ЗВЗєЗГЗќЗДЗ§ЗЕЗџЗЖИЗЗИЗИИЗЙИЗКИ ЗЛИ ЗМИЗНИЗОИЗПИЗРИЗСИ$ЗТИ%ЗУИ(ЗФИ,ЗХИ4ЗЦИ5ЗЧИ7ЗШИ8ЗЩИ9ЗЪИ@ЗЫИDЗЬИQЗЭИSЗЮИ\ЗЯИ]ЗаИ`ЗбИdЗвИlЗгИmЗдИoЗеИqЗжИxЗзИ|ЗиИЗйИЈЗкИАЗлИДЗмИИЗнИРЗоИСЗпИУЗрИХЗсИЬЗтИаЗуИдЗфИнЗхИпЗцИсЗчИшЗшИщЗщИьЗъИ№ЗыИјЗьИљЗэИћЗюИ§ЗяЙЗ№ЙЗёЙ ЗђЙ<ЗѓЙ=ЗєЙ@ЗѕЙDЗіЙLЗїЙOЗјЙQЗљЙXЗњЙYЗћЙ\ЗќЙ`З§ЙhЗўЙiИAбаИBббИCбвИDбгИEбдИFбеИGбжИHбзИIбйИJбкИKблИLбмИMбнИNбоИOбпИPбрИQбсИRбтИSбуИTбфИUбхИVбцИWбчИXбшИYбщИZбъИaбыИbбьИcбэИdбюИeбяИfб№ИgбёИhбђИiбѓИjбѕИkбіИlбїИmбљИnбњИoбћИpбќИqб§ИrбўИsбџИtвИuвИvвИwвИxвИyвИzвИвИ‚в Иƒв И„в И…в И†вИ‡вИˆвИ‰вИŠвИ‹вИŒвИвИŽвИвИвИ‘вИ’вИ“вИ”вИ•вИ–вИ—в Șв!И™в"Иšв#И›в$Иœв%Ив&Иžв'ИŸв(И в)ИЁЙkИЂЙmИЃЙtИЄЙuИЅЙxИІЙ|ИЇЙ„ИЈЙ…ИЉЙ‡ИЊЙ‰ИЋЙŠИЌЙИ­ЙŽИЎЙЌИЏЙ­ИАЙАИБЙДИВЙМИГЙНИДЙПИЕЙСИЖЙШИЗЙЩИИЙЬИЙЙЮИКЙЯИЛЙаИМЙбИНЙвИОЙиИПЙйИРЙлИСЙнИТЙоИУЙсИФЙуИХЙфИЦЙхИЧЙшИШЙьИЩЙєИЪЙѕИЫЙїИЬЙјИЭЙљИЮЙњИЯКИаКИбКИвКИгК8ИдК9ИеК<ИжК@ИзКBИиКHИйКIИкКKИлКMИмКNИнКSИоКTИпКUИрКXИсК\ИтКdИуКeИфКgИхКhИцКiИчКpИшКqИщКtИъКxИыКƒИьК„ИэК…ИюК‡ИяКŒИ№КЈИёКЉИђКЋИѓКЌИєКАИѕКВИіКИИїКЙИјКЛИљКНИњКФИћКШИќКиИ§КйИўКќЙAв*ЙBв+ЙCв.ЙDв/ЙEв1ЙFв2ЙGв3ЙHв5ЙIв6ЙJв7ЙKв8ЙLв9ЙMв:ЙNв;ЙOв>ЙPв@ЙQвBЙRвCЙSвDЙTвEЙUвFЙVвGЙWвIЙXвJЙYвKЙZвLЙaвMЙbвNЙcвOЙdвPЙeвQЙfвRЙgвSЙhвTЙiвUЙjвVЙkвWЙlвXЙmвYЙnвZЙoв[Йpв]Йqв^Йrв_Йsв`ЙtвaЙuвbЙvвcЙwвeЙxвfЙyвgЙzвhЙвiЙ‚вjЙƒвkЙ„вlЙ…вmЙ†вnЙ‡вoЙˆвpЙ‰вqЙŠвrЙ‹вsЙŒвtЙвuЙŽвvЙвwЙвxЙ‘вyЙ’вzЙ“в{Й”в|Й•в}Й–в~Й—вɘв‚Й™вƒЙšв…Й›в†Йœв‡Йв‰ЙžвŠЙŸв‹Й вŒЙЁЛЙЂЛЙЃЛ ЙЄЛЙЅЛЙІЛЙЇЛЙЈЛ ЙЉЛ)ЙЊЛ+ЙЋЛ4ЙЌЛ5Й­Л6ЙЎЛ8ЙЏЛ;ЙАЛ<ЙБЛ=ЙВЛ>ЙГЛDЙДЛEЙЕЛGЙЖЛIЙЗЛMЙИЛOЙЙЛPЙКЛTЙЛЛXЙМЛaЙНЛcЙОЛlЙПЛˆЙРЛŒЙСЛЙТЛЄЙУЛЈЙФЛЌЙХЛДЙЦЛЗЙЧЛРЙШЛФЙЩЛШЙЪЛаЙЫЛгЙЬЛјЙЭЛљЙЮЛќЙЯЛџЙаМЙбМЙвМЙгМ ЙдМ ЙеМ ЙжМ ЙзМЙиМЙйМЙкМЙлМЙмМЙнМЙоМЙпМЙрМЙсМЙтМЙуМ$ЙфМ%ЙхМ'ЙцМ)ЙчМ-ЙшМ0ЙщМ1ЙъМ4ЙыМ8ЙьМ@ЙэМAЙюМCЙяМDЙ№МEЙёМIЙђМLЙѓМMЙєМPЙѕМ]ЙіМ„ЙїМ…ЙјМˆЙљМ‹ЙњМŒЙћМŽЙќМ”Й§М•ЙўМ—КAвКBвŽКCвКDв’КEв“КFв”КGв–КHв—КIв˜КJв™КKвšКLв›КMвКNвžКOвŸКPвЁКQвЂКRвЃКSвЅКTвІКUвЇКVвЈКWвЉКXвЊКYвЋКZв­КaвЎКbвЏКcвАКdвВКeвГКfвДКgвЕКhвЖКiвЗКjвККkвЛКlвНКmвОКnвСКoвУКpвФКqвХКrвЦКsвЧКtвЪКuвЬКvвЭКwвЮКxвЯКyваКzвбКввК‚вгКƒвеК„вжК…взК†вйК‡вкКˆвлК‰внКŠвоК‹впКŒврКвсКŽвтКвуКвцК‘вчК’вшК“вщК”въК•выК–вьК—вэʘвюК™вяКšвђК›вѓКœвѕКвіКžвїКŸвљК вњКЁМ™КЂМšКЃМ КЄМЁКЅМЄКІМЇКЇМЈКЈМАКЉМБКЊМГКЋМДКЌМЕК­ММКЎМНКЏМРКАМФКБМЭКВМЯКГМаКДМбКЕМеКЖМиКЗМмКИМєКЙМѕККМіКЛМјКММќКННКОНКПНКРН КСНКТНКУН$КФН,КХН@КЦНHКЧНIКШНLКЩНPКЪНXКЫНYКЬНdКЭНhКЮН€КЯНКаН„КбН‡КвНˆКгН‰КдНŠКеНКжН‘КзН“КиН•КйН™КкНšКлНœКмНЄКнНАКоНИКпНдКрНеКсНиКтНмКуНщКфН№КхНєКцНјКчОКшОКщОКъО КыО КьОКэОКюОКяОК№ОКёОDКђОEКѓОHКєОLКѕОNКіОTКїОUКјОWКљОYКњОZКћО[КќО`К§ОaКўОdЛAвћЛBвќЛCв§ЛDвўЛEвџЛFгЛGгЛHгЛIгЛJгЛKг ЛLг ЛMг ЛNгЛOгЛPгЛQгЛRгЛSгЛTгЛUгЛVгЛWгЛXгЛYг"ЛZг#Лaг$Лbг&Лcг'Лdг*Лeг+Лfг-Лgг.Лhг/Лiг1Лjг2Лkг3Лlг4Лmг5Лnг6Лoг7Лpг:Лqг>Лrг?Лsг@ЛtгAЛuгBЛvгCЛwгFЛxгGЛyгHЛzгIЛгJЛ‚гKЛƒгLЛ„гMЛ…гNЛ†гOЛ‡гPЛˆгQЛ‰гRЛŠгSЛ‹гTЛŒгUЛгVЛŽгWЛгXЛгYЛ‘гZЛ’г[Л“г\Л”г]Л•г^Л–г_Л—г`˘гaЛ™гbЛšгcЛ›гdЛœгeЛгfЛžгgЛŸгhЛ гiЛЁОhЛЂОjЛЃОpЛЄОqЛЅОsЛІОtЛЇОuЛЈО{ЛЉО|ЛЊО}ЛЋО€ЛЌО„Л­ОŒЛЎОЛЏОЛАОЛБО‘ЛВΘЛГО™ЛДОЈЛЕОаЛЖОбЛЗОдЛИОзЛЙОиЛКОрЛЛОуЛМОфЛНОхЛООьЛППЛРПЛСП ЛТПЛУПЛФПЛХПЛЦПЛЧП@ЛШПAЛЩПDЛЪПHЛЫПPЛЬПQЛЭПUЛЮП”ЛЯПАЛаПХЛбПЬЛвПЭЛгПаЛдПдЛеПмЛжПпЛзПсЛиР<ЛйРQЛкРXЛлР\ЛмР`ЛнРhЛоРiЛпРЛрР‘ЛсР”ЛтИЛуР ЛфРЁЛхРЃЛцРЅЛчРЌЛшР­ЛщРЏЛъРАЛыРГЛьРДЛэРЕЛюРЖЛяРМЛ№РНЛёРПЛђРРЛѓРСЛєРХЛѕРШЛіРЩЛїРЬЛјРаЛљРиЛњРйЛћРлЛќРмЛ§РнЛўРфМAгjМBгkМCгlМDгmМEгnМFгoМGгpМHгqМIгrМJгsМKгtМLгuМMгvМNгwМOгxМPгyМQгzМRг{МSг~МTгМUгМVг‚МWгƒМXг…МYг†МZг‡МaгˆМbг‰МcгŠМdг‹МeгŽМfг’Мgг“Мhг”Мiг•Мjг–Мkг—МlгšМmг›МnгМoгžМpгŸМqгЁМrгЂМsгЃМtгЄМuгЅМvгІМwгЇМxгЊМyгЌМzгЎМгЏМ‚гАМƒгБМ„гВМ…гГМ†гЕМ‡гЖМˆгЗМ‰гЙМŠгКМ‹гЛМŒгНМгОМŽгПМгРМгСМ‘гТМ’гУМ“гЦМ”гЧМ•гЪМ–гЫМ—гЬ̘гЭМ™гЮМšгЯМ›гбМœгвМггМžгдМŸгеМ гжМЁРхМЂРшМЃРьМЄРєМЅРѕМІРїМЇРљМЈСМЉСМЊСМЋСМЌСМ­СМЎСМЏСМАСМБС МВС#МГС$МДС&МЕС'МЖС,МЗС-МИС/МЙС0МКС1МЛС6ММС8МНС9МОС<МПС@МРСHМССIМТСKМУСLМФСMМХСTМЦСUМЧСXМШС\МЩСdМЪСeМЫСgМЬСhМЭСiМЮСpМЯСtМаСxМбС…МвСŒМгСМдСŽМеСМжС”МзС–МиСœМйСМкСŸМлСЁМмСЅМнСЈМоСЉМпСЌМрСАМсСНМтСФМуСШМфСЬМхСдМцСзМчСиМшСрМщСфМъСшМыС№МьСёМэСѓМюСќМяС§М№ТМёТМђТ МѓТ МєТМѕТМіТМїТМјТМљТМњТ МћТ(МќТ)М§Т+МўТ-НAгзНBгйНCгкНDглНEгмНFгнНGгоНHгпНIгрНJгтНKгфНLгхНMгцНNгчНOгшНPгщНQгъНRгыНSгюНTгяНUгёНVгђНWгѓНXгѕНYгіНZгїНaгјНbгљНcгњНdгћНeгўНfдНgдНhдНiдНjдНkдНlдНmд Нnд Нoд Нpд Нqд НrдНsдНtдНuдНvдНwдНxдНyдНzдНдН‚дНƒдН„дН…дН†дН‡дНˆдН‰д НŠд!Н‹д"НŒд#Нд$НŽд%Нд&Нд'Н‘д(Н’д)Н“д*Н”д+Н•д,Н–д-Н—д.͘д/Н™д0Нšд1Н›д2Нœд3Нд4Нžд5НŸд6Н д7НЁТ/НЂТ1НЃТ2НЄТ4НЅТHНІТPНЇТQНЈТTНЉТXНЊТ`НЋТeНЌТlН­ТmНЎТpНЏТtНАТ|НБТ}НВТНГТНДТˆНЕТ‰НЖТНЗҘНИТ›НЙТНКТЄНЛТЅНМТЈННТЌНОТ­НПТДНРТЕНСТЗНТТЙНУТмНФТнНХТрНЦТуНЧТфНШТыНЩТьНЪТэНЫТяНЬТёНЭТіНЮТјНЯТљНаТћНбТќНвУНгУНдУ НеУ НжУ НзУНиУНйУНкУНлУНмУ$НнУ%НоУ(НпУ)НрУEНсУhНтУiНуУlНфУpНхУrНцУxНчУyНшУ|НщУ}НъУ„НыУˆНьУŒНэУРНюУиНяУйН№УмНёУпНђУрНѓУтНєУшНѕУщНіУэНїУєНјУѕНљУјНњФНћФНќФ$Н§Ф,НўФ0ОAд8ОBд9ОCд:ОDд;ОEд<ОFд=ОGд>ОHд?ОIдAОJдBОKдCОLдEОMдFОNдGОOдHОPдIОQдJОRдKОSдLОTдMОUдNОVдOОWдPОXдQОYдRОZдSОaдTОbдUОcдVОdдWОeдXОfдYОgдZОhд[Оiд]Оjд^Оkд_ОlдaОmдbОnдcОoдeОpдfОqдgОrдhОsдiОtдjОuдkОvдlОwдnОxдpОyдqОzдrОдsО‚дtОƒдuО„дvО…дwО†дzО‡д{Оˆд}О‰д~ОŠдО‹дƒОŒд„Од…ОŽд†Од‡ОдŠО‘дŒО’дŽО“дО”дО•д‘О–д’О—д“О˜д•О™д–Оšд—О›д˜Оœд™ОдšОžд›ОŸдœО дОЁФ4ОЂФ<ОЃФ=ОЄФHОЅФdОІФeОЇФhОЈФlОЉФtОЊФuОЋФyОЌФ€О­Ф”ОЎФœОЏФИОАФМОБФщОВФ№ОГФёОДФєОЕФјОЖФњОЗФџОИХОЙХОКХ ОЛХОМХОНХООХ(ОПХ)ОРХ,ОСХ0ОТХ8ОУХ9ОФХ;ОХХ=ОЦХDОЧХEОШХHОЩХIОЪХJОЫХLОЬХMОЭХNОЮХSОЯХTОаХUОбХWОвХXОгХYОдХ]ОеХ^ОжХ`ОзХaОиХdОйХhОкХpОлХqОмХsОнХtОоХuОпХ|ОрХ}ОсХ€ОтХ„ОуХ‡ОфХŒОхХОцХОчХ‘ОшХ•ОщХ—Оъ՘ОыХœОьХ ОэХЉОюХДОяХЕО№ХИОёХЙОђХЛОѓХМОєХНОѕХООіХФОїХХОјХЦОљХЧОњХШОћХЩОќХЪО§ХЬОўХЮПAдžПBдŸПCд ПDдЁПEдЂПFдЃПGдЄПHдЅПIдІПJдЇПKдЈПLдЊПMдЋПNдЌПOд­ПPдЎПQдЏПRдАПSдБПTдВПUдГПVдДПWдЕПXдЖПYдЗПZдИПaдЙПbдКПcдЛПdдМПeдНПfдОПgдППhдРПiдСПjдТПkдУПlдФПmдХПnдЦПoдЧПpдШПqдЩПrдЪПsдЫПtдЭПuдЮПvдЯПwдбПxдвПyдгПzдеПджП‚дзПƒдиП„дйП…дкП†длП‡днПˆдоП‰дрПŠдсП‹дтПŒдуПдфПŽдхПдцПдчП‘дщП’дъП“дыП”дэП•дюП–дяП—дёП˜дђП™дѓПšдєП›дѕПœдіПдїПžдљПŸдњП дќПЁХаПЂХбПЃХдПЄХиПЅХрПІХсПЇХуПЈХхПЉХьПЊХэПЋХюПЌХ№П­ХєПЎХіПЏХїПАХќПБХ§ПВХўПГХџПДЦПЕЦПЖЦПЗЦПИЦПЙЦПКЦ ПЛЦПМЦПНЦПОЦППЦПРЦ$ПСЦ%ПТЦ(ПУЦ,ПФЦ-ПХЦ.ПЦЦ0ПЧЦ3ПШЦ4ПЩЦ5ПЪЦ7ПЫЦ9ПЬЦ;ПЭЦ@ПЮЦAПЯЦDПаЦHПбЦPПвЦQПгЦSПдЦTПеЦUПжЦ\ПзЦ]ПиЦ`ПйЦlПкЦoПлЦqПмЦxПнЦyПоЦ|ПпЦ€ПрЦˆПсЦ‰ПтЦ‹ПуЦПфЦ”ПхЦ•Пц֘ПчЦœПшЦЄПщЦЅПъЦЇПыЦЉПьЦАПэЦБПюЦДПяЦИП№ЦЙПёЦКПђЦРПѓЦСПєЦУПѕЦХПіЦЬПїЦЭПјЦаПљЦдПњЦмПћЦнПќЦрП§ЦсПўЦшРAдўРBдџРCеРDеРEеРFеРGеРHеРIеРJе РKе РLе РMе РNеРOеРPеРQеРRеРSеРTеРUеРVеРWеРXеРYеРZеРaеРbеРcе Рdе!Рeе"Рfе#Рgе$Рhе%Рiе&Рjе'Рkе(Рlе)Рmе*Рnе+Рoе,Рpе-Рqе.Рrе/Рsе0Рtе1Рuе2Рvе3Рwе4Рxе5Рyе6Рzе7Ре8Р‚е9Рƒе:Р„е;Р…е>Р†е?Р‡еAРˆеBР‰еCРŠеEР‹еFРŒеGРеHРŽеIРеJРеKР‘еNР’еPР“еRР”еSР•еTР–еUР—еVИеWР™еZРšе[Р›е]Рœе^Ре_РžеaРŸеbР еcРЁЦщРЂЦьРЃЦ№РЄЦјРЅЦљРІЦ§РЇЧРЈЧРЉЧРЊЧ РЋЧРЌЧР­ЧРЎЧРЏЧ РАЧ!РБЧ$РВЧ(РГЧ0РДЧ1РЕЧ3РЖЧ5РЗЧ7РИЧ<РЙЧ=РКЧ@РЛЧDРМЧJРНЧLРОЧMРПЧOРРЧQРСЧRРТЧSРУЧTРФЧUРХЧVРЦЧWРЧЧXРШЧ\РЩЧ`РЪЧhРЫЧkРЬЧtРЭЧuРЮЧxРЯЧ|РаЧ}РбЧ~РвЧƒРгЧ„РдЧ…РеЧ‡РжЧˆРзЧ‰РиЧŠРйЧŽРкЧРлЧ‘РмЧ”РнЧ–РоЧ—РпטРрЧšРсЧ РтЧЁРуЧЃРфЧЄРхЧЅРцЧІРчЧЌРшЧ­РщЧАРъЧДРыЧМРьЧНРэЧПРюЧРРяЧСР№ЧШРёЧЩРђЧЬРѓЧЮРєЧаРѕЧиРіЧнРїЧфРјЧшРљЧьРњШРћШРќШР§ШРўШ СAеdСBеfСCеgСDеjСEеlСFеnСGеoСHеpСIеqСJеrСKеsСLеvСMеwСNеyСOеzСPе{СQе}СRе~СSеСTе€СUеСVе‚СWеƒСXе†СYеŠСZе‹СaеŒСbеСcеŽСdеСeе‘Сfе’Сgе“Сhе”Сiе•Сjе–Сkе—Сlе˜Сmе™СnеšСoе›СpеœСqеСrеžСsеŸСtе СuеЁСvеЂСwеЃСxеЄСyеІСzеЇСеЈС‚еЉСƒеЊС„еЋС…еЌС†е­С‡еЎСˆеЏС‰еАСŠеБС‹еВСŒеГСеДСŽеЕСеЖСеЗС‘еИС’еЙС“еКС”еЛС•еМС–еНС—еОјеПС™еРСšеСС›еТСœеУСеФСžеХСŸеЦС еЧСЁШСЂШСЃШСЄШСЅШСІШСЇШСЈШ СЉШ$СЊШ,СЋШ-СЌШ/С­Ш1СЎШ8СЏШ<САШ@СБШHСВШIСГШLСДШMСЕШTСЖШpСЗШqСИШtСЙШxСКШzСЛШ€СМШСНШƒСОШ…СПШ†СРШ‡ССШ‹СТШŒСУШСФШ”СХШСЦШŸСЧШЁСШШЈСЩШМСЪШНСЫШФСЬШШСЭШЬСЮШдСЯШеСаШзСбШйСвШрСгШсСдШфСеШѕСжШќСзШ§СиЩСйЩСкЩСлЩСмЩ СнЩ СоЩСпЩСрЩСсЩ,СтЩ4СуЩPСфЩQСхЩTСцЩXСчЩ`СшЩaСщЩcСъЩlСыЩpСьЩtСэЩ|СюЩˆСяЩ‰С№ЩŒСёЩСђЩ˜СѓЩ™СєЩ›СѕЩСіЩРСїЩССјЩФСљЩЧСњЩШСћЩЪСќЩаС§ЩбСўЩгТAеЪТBеЫТCеЭТDеЮТEеЯТFебТGегТHедТIееТJежТKезТLекТMемТNеоТOепТPерТQесТRетТSеуТTецТUечТVещТWеъТXеыТYеэТZеюТaеяТbе№ТcеёТdеђТeеѓТfеіТgејТhењТiећТjеќТkе§ТlеўТmеџТnжТoжТpжТqжТrжТsж Тtж Тuж Тvж Тwж ТxжТyжТzжТжТ‚жТƒжТ„жТ…жТ†жТ‡жТˆжТ‰жТŠж!Т‹ж"ТŒж#Тж%ТŽж&Тж'Тж(Т‘ж)Т’ж*Т“ж+Т”ж,Т•ж.Т–ж/Т—ж0Ҙж1Т™ж2Тšж3Т›ж4Тœж5Тж6Тžж7ТŸж:Т ж;ТЁЩеТЂЩжТЃЩйТЄЩкТЅЩмТІЩнТЇЩрТЈЩтТЉЩфТЊЩчТЋЩьТЌЩэТ­ЩяТЎЩ№ТЏЩёТАЩјТБЩљТВЩќТГЪТДЪТЕЪ ТЖЪ ТЗЪ ТИЪ ТЙЪТКЪТЛЪ)ТМЪLТНЪMТОЪPТПЪTТРЪ\ТСЪ]ТТЪ_ТУЪ`ТФЪaТХЪhТЦЪ}ТЧЪ„ТШژТЩЪМТЪЪНТЫЪРТЬЪФТЭЪЬТЮЪЭТЯЪЯТаЪбТбЪгТвЪиТгЪйТдЪрТеЪьТжЪєТзЫТиЫТйЫТкЫТлЫ ТмЫ!ТнЫAТоЫHТпЫIТрЫLТсЫPТтЫXТуЫYТфЫ]ТхЫdТцЫxТчЫyТшЫœТщЫИТъЫдТыЫфТьЫчТэЫщТюЬ ТяЬ Т№ЬТёЬТђЬТѓЬТєЬ!ТѕЬ"ТіЬ'ТїЬ(ТјЬ)ТљЬ,ТњЬ.ТћЬ0ТќЬ8Т§Ь9ТўЬ;УAж=УBж>УCж?УDжAУEжBУFжCУGжDУHжFУIжGУJжJУKжLУLжNУMжOУNжPУOжRУPжSУQжVУRжWУSжYУTжZУUж[УVж]УWж^УXж_УYж`УZжaУaжbУbжcУcжdУdжeУeжfУfжhУgжjУhжkУiжlУjжmУkжnУlжoУmжrУnжsУoжuУpжvУqжwУrжxУsжyУtжzУuж{Уvж|Уwж}Уxж~УyжУzж€УжУ‚ж‚Уƒж„У„ж†У…ж‡У†жˆУ‡ж‰УˆжŠУ‰ж‹УŠжŽУ‹жУŒж‘Уж’УŽж“Уж•Уж–У‘ж—У’ж˜У“ж™У”жšУ•ж›У–жœУ—жžУ˜ж У™жЂУšжЃУ›жЄУœжЅУжІУžжЇУŸжЉУ жЊУЁЬ<УЂЬ=УЃЬ>УЄЬDУЅЬEУІЬHУЇЬLУЈЬTУЉЬUУЊЬWУЋЬXУЌЬYУ­Ь`УЎЬdУЏЬfУАЬhУБЬpУВЬuУГܘУДЬ™УЕЬœУЖЬ УЗЬЈУИЬЉУЙЬЋУКЬЌУЛЬ­УМЬДУНЬЕУОЬИУПЬМУРЬФУСЬХУТЬЧУУЬЩУФЬаУХЬдУЦЬфУЧЬьУШЬ№УЩЭУЪЭУЫЭ УЬЭ УЭЭУЮЭУЯЭУаЭУбЭУвЭ$УгЭ(УдЭ,УеЭ9УжЭ\УзЭ`УиЭdУйЭlУкЭmУлЭoУмЭqУнЭxУоЭˆУпЭ”УрЭ•УсݘУтЭœУуЭЄУфЭЅУхЭЇУцЭЉУчЭАУшЭФУщЭЬУъЭаУыЭшУьЭьУэЭ№УюЭјУяЭљУ№ЭћУёЭ§УђЮУѓЮУєЮ УѕЮУіЮУїЮ УјЮ!УљЮ$УњЮ(УћЮ0УќЮ1У§Ю3УўЮ5ФAжЋФBж­ФCжЎФDжЏФEжБФFжВФGжГФHжДФIжЕФJжЖФKжЗФLжИФMжКФNжМФOжНФPжОФQжПФRжРФSжСФTжТФUжУФVжЦФWжЧФXжЩФYжЪФZжЫФaжЭФbжЮФcжЯФdжаФeжвФfжгФgжеФhжжФiжиФjжкФkжлФlжмФmжнФnжоФoжпФpжсФqжтФrжуФsжхФtжцФuжчФvжщФwжъФxжыФyжьФzжэФжюФ‚жяФƒжёФ„жђФ…жѓФ†жєФ‡жіФˆжїФ‰жјФŠжљФ‹жњФŒжћФжўФŽжџФзФзФ‘зФ’зФ“зФ”зФ•зФ–з Ф—з Ԙз Ф™з Фšз Ф›зФœзФзФžзФŸзФ зФЁЮXФЂЮYФЃЮ\ФЄЮ_ФЅЮ`ФІЮaФЇЮhФЈЮiФЉЮkФЊЮmФЋЮtФЌЮuФ­ЮxФЎЮ|ФЏЮ„ФАЮ…ФБЮ‡ФВЮ‰ФГЮФДЮ‘ФЕЮ”ФЖޘФЗЮ ФИЮЁФЙЮЃФКЮЄФЛЮЅФМЮЌФНЮ­ФОЮСФПЮфФРЮхФСЮшФТЮыФУЮьФФЮєФХЮѕФЦЮїФЧЮјФШЮљФЩЯФЪЯФЫЯФЬЯФЭЯФЮЯФЯЯФаЯФбЯФвЯ ФгЯ$ФдЯ,ФеЯ-ФжЯ/ФзЯ0ФиЯ1ФйЯ8ФкЯTФлЯUФмЯXФнЯ\ФоЯdФпЯeФрЯgФсЯiФтЯpФуЯqФфЯtФхЯxФцЯ€ФчЯ…ФшЯŒФщЯЁФъЯЈФыЯАФьЯФФэЯрФюЯсФяЯфФ№ЯшФёЯ№ФђЯёФѓЯѓФєЯѕФѕЯќФіаФїаФјаФљаФња-Фћа4Фќа5Ф§а8Фўа<ХAзХBзХCзХDзХEзХFзХGзХHзХIз!ХJз"ХKз#ХLз$ХMз%ХNз&ХOз'ХPз*ХQз,ХRз.ХSз/ХTз0ХUз1ХVз2ХWз3ХXз6ХYз7ХZз9Хaз:Хbз;Хcз=Хdз>Хeз?Хfз@ХgзAХhзBХiзCХjзEХkзFХlзHХmзJХnзKХoзLХpзMХqзNХrзOХsзRХtзSХuзUХvзZХwз[Хxз\Хyз]Хzз^Хз_Х‚зbХƒзdХ„зfХ…зgХ†зhХ‡зjХˆзkХ‰зmХŠзnХ‹зoХŒзqХзrХŽзsХзuХзvХ‘зwХ’зxХ“зyХ”зzХ•з{Х–з~Х—з՘з€Х™з‚ХšзƒХ›з„Хœз…Хз†Хžз‡ХŸзŠХ з‹ХЁаDХЂаEХЃаGХЄаIХЅаPХІаTХЇаXХЈа`ХЉаlХЊаmХЋаpХЌаtХ­а|ХЎа}ХЏаХАаЄХБаЅХВаЈХГаЌХДаДХЕаЕХЖаЗХЗаЙХИаРХЙаСХКаФХЛаШХМаЩХНааХОабХПагХРадХСаеХТамХУанХФарХХафХЦаьХЧаэХШаяХЩа№ХЪаёХЫајХЬб ХЭб0ХЮб1ХЯб4Хаб8Хбб:Хвб@ХгбAХдбCХебDХжбEХзбLХибMХйбPХкбTХлб\Хмб]Хнб_ХобaХпбhХрбlХсб|Хтб„ХубˆХфб ХхбЁХцбЄХчбЈХшбАХщбБХъбГХыбЕХьбКХэбМХюбРХябиХ№бєХёбјХђвХѓв ХєвХѕв,Хів-Хїв0Хјв4Хљв<Хњв=Хћв?ХќвAХ§вHХўв\ЦAзЦBзŽЦCзЦDз‘ЦEз’ЦFз“ЦGз”ЦHз•ЦIз–ЦJз—ЦKзšЦLзœЦMзžЦNзŸЦOз ЦPзЁЦQзЂЦRзЃЦЁвdЦЂв€ЦЃвЦЄв„ЦЅвˆЦІвЦЇв‘ЦЈв•ЦЉвœЦЊв ЦЋвЄЦЌвЌЦ­вБЦЎвИЦЏвЙЦАвМЦБвПЦВвРЦГвТЦДвШЦЕвЩЦЖвЫЦЗвдЦИвиЦЙвмЦКвфЦЛвхЦМв№ЦНвёЦОвєЦПвјЦРгЦСгЦТгЦУгЦФг ЦХг ЦЦгЦЧгЦШгЦЩгЦЪгЦЫгЦЬгЦЭг ЦЮг!ЦЯг%Цаг(Цбг)Цвг,Цгг0Цдг8Цег9Цжг;Цзг<Циг=ЦйгDЦкгEЦлг|Цмг}Цнг€Цог„ЦпгŒЦргЦсгЦтгЦуг‘Цфг˜Цхг™ЦцгœЦчг ЦшгЈЦщгЉЦъгЋЦыг­ЦьгДЦэгИЦюгМЦягФЦ№гХЦёгШЦђгЩЦѓгаЦєгиЦѕгсЦігуЦїгьЦјгэЦљг№ЦњгєЦћгќЦќг§Ц§гџЦўдЧЁдЧЂдЧЃд@ЧЄдDЧЅд\ЧІд`ЧЇдdЧЈдmЧЉдoЧЊдxЧЋдyЧЌд|Ч­дЧЎд€ЧЏд‚ЧАдˆЧБд‰ЧВд‹ЧГдЧДд”ЧЕдЉЧЖдЬЧЗдаЧИддЧЙдмЧКдпЧЛдшЧМдьЧНд№ЧОдјЧПдћЧРд§ЧСеЧТеЧУе ЧФеЧХеЧЦеЧЧе<ЧШе=ЧЩе@ЧЪеDЧЫеLЧЬеMЧЭеOЧЮеQЧЯеXЧаеYЧбе\Чве`ЧгеeЧдеhЧееiЧжеkЧзеmЧиеtЧйеuЧкеxЧле|Чме„Чне…Чое‡ЧпеˆЧре‰ЧсеЧтеЅЧуеШЧфеЩЧхеЬЧцеаЧчевЧшеиЧщейЧъелЧыенЧьефЧэехЧюешЧяеьЧ№еєЧёеѕЧђеїЧѓељЧєжЧѕжЧіжЧїжЧјжЧљжЧњжЧћжЧќжЧ§жЧўж ШЁж$ШЂж-ШЃж8ШЄж9ШЅж<ШІж@ШЇжEШЈжHШЉжIШЊжKШЋжMШЌжQШ­жTШЎжUШЏжXШАж\ШБжgШВжiШГжpШДжqШЕжtШЖжƒШЗж…ШИжŒШЙжШКжШЛж”ШМжШНжŸШОжЁШПжЈШРжЌШСжАШТжЙШУжЛШФжФШХжХШЦжШШЧжЬШШжбШЩждШЪжзШЫжйШЬжрШЭжфШЮжшШЯж№ШажѕШбжќШвж§ШгзШдзШезШжзШззШизШйз Шкз(Шлз)Шмз+Шнз-Шоз4Шпз5Шрз8Шсз<ШтзDШузGШфзIШхзPШцзQШчзTШшзVШщзWШъзXШызYШьз`ШэзaШюзcШязeШ№зiШёзlШђзpШѓзtШєз|Шѕз}ШізШїзˆШјз‰ШљзŒШњзШћз˜Шќз™Ш§з›ШўзЪЁO=ЪЂOsЪЃPGЪЄPљЪЅR ЪІSяЪЇTuЪЈTхЪЉV ЪЊZСЪЋ[ЖЪЌf‡Ъ­gЖЪЎgЗЪЏgяЪАkLЪБsТЪВuТЪГz<ЪД‚лЪЕƒЪЖˆWЪЗˆˆЪИŠ6ЪЙŒШЪКЯЪЛŽћЪМцЪН™еЪОR;ЪПStЪРTЪС`jЪТadЪУkМЪФsЯЪХЪЦ‰КЪЧ‰вЪШ•ЃЪЩOƒЪЪR ЪЫXОЪЬYxЪЭYцЪЮ^rЪЯ^yЪаaЧЪбcРЪвgFЪгgьЪдhЪеo—ЪжvNЪзw ЪиxѕЪйzЪкzџЪл|!Ъм€Ън‚nЪо‚qЪпŠыЪр•“ЪсNkЪтUЪуfїЪфn4ЪхxЃЪцzэЪч„[Ъш‰Ъщ‡NЪъ—ЈЪыRиЪьWNЪэX*Ъю]LЪяaЪ№aОЪёb!ЪђebЪѓgбЪєjDЪѕnЪіuЪїuГЪјvуЪљwАЪњ}:ЪћЏЪќ”QЪ§”RЪўŸ•ЫЁS#ЫЂ\ЌЫЃu2ЫЄ€лЫЅ’@ЫІ•˜ЫЇR[ЫЈXЫЉYмЫЊ\ЁЫЋ]ЫЌ^ЗЫ­_:ЫЎ_JЫЏawЫАl_ЫБuzЫВu†ЫГ|рЫД}sЫЕ}БЫЖŒЫЗTЫИ‚!ЫЙ…‘ЫК‰AЫЛ‹ЫМ’ќЫН–MЫОœGЫПNЫЫРNїЫСP ЫТQёЫУXOЫФa7ЫХa>ЫЦahЫЧe9ЫШiъЫЩoЫЪuЅЫЫv†ЫЬvжЫЭ{‡ЫЮ‚ЅЫЯ„ЫЫаљЫб“ЇЫв•‹ЫгU€Ыд[ЂЫеWQЫжљЫз|ГЫиЙЫй‘ЕЫкP(ЫлSЛЫм\EЫн]шЫоbвЫпcnЫрdкЫсdчЫтn ЫуpЌЫфy[ЫхнЫцŽЫчљЫш}Ыщ’EЫъ’јЫыN~ЫьNіЫэPeЫю]ўЫя^њЫ№aЫёiWЫђqЫѓ†TЫєŽGЫѕ“uЫіš+ЫїN^ЫјP‘ЫљgpЫњh@ЫћQ ЫќRЫ§R’ЫўjЂЬЁwМЬЂ’ЬЃžдЬЄRЋЬЅ`/ЬІђЬЇPHЬЈaЉЬЉcэЬЊdЪЬЋh<ЬЌj„Ь­oРЬЎˆЬЏ‰ЁЬА–”ЬБXЬВr}ЬГrЌЬДuЬЕ}yЬЖ~mЬЗ€ЉЬИ‰‹ЬЙ‹tЬКcЬЛQЬМb‰ЬНlzЬОoTЬП}PЬР:ЬСŠ#ЬТQ|ЬУaJЬФ{ЬХ‹ЬЦ’WЬЧ“ŒЬШNЌЬЩOгЬЪPЬЫPОЬЬQЬЭRСЬЮRЭЬЯSЬаWpЬбXƒЬв^šЬг_‘ЬдavЬеaЌЬжdЮЬзelЬиfoЬйfЛЬкfєЬлh—Ьмm‡Ьнp…ЬоpёЬпtŸЬрtЅЬсtЪЬтuйЬуxlЬфxьЬхzпЬцzіЬч}EЬш}“Ьщ€Ьъ€?ЬыЬьƒ–Ьэ‹fЬюЬяЬ№“сЬё˜Ьђ˜8ЬѓšZЬє›шЬѕOТЬіUSЬїX:ЬјYQЬљ[cЬњ\FЬћ`ИЬќbЬ§hBЬўhАЭЁhшЭЂnЊЭЃuLЭЄvxЭЅxЮЭІz=ЭЇ|ћЭЈ~kЭЉ~|ЭЊŠЭЋŠЁЭЌŒ?Э­–ŽЭЎФЭЏSфЭАSщЭБTJЭВTqЭГVњЭДYбЭЕ[dЭЖ\;ЭЗ^ЋЭИbїЭЙe7ЭКeEЭЛerЭМf ЭНgЏЭОiСЭПlНЭРuќЭСvЭТw~ЭУz?ЭФ”ЭХ€ЭЦ€ЁЭЧЭШ‚цЭЩ‚§ЭЪƒ№ЭЫ…СЭЬˆ1ЭЭˆДЭЮŠЅЭЯљЭаœЭб“.Эв–ЧЭг˜gЭдšиЭеŸЭжTэЭзe›ЭиfђЭйhЭкz@ЭлŒ7Эм`ЭнV№ЭоWdЭп]ЭрfЭсhБЭтhЭЭуnўЭфt(ЭхˆžЭц›фЭчlhЭшљЭщšЈЭъO›ЭыQlЭьQqЭэRŸЭю[TЭя]хЭ№`PЭё`mЭђbёЭѓcЇЭєe;ЭѕsйЭіzzЭї†ЃЭјŒЂЭљ—ЭњN2Эћ[сЭќbЭ§gœЭўtмЮЁyбЮЂƒгЮЃŠ‡ЮЄŠВЮЅшЮІNЮЇ“KЮЈ˜FЮЉ^гЮЊiшЮЋ…џЮЌэЮ­љЮЎQ ЮЏ[˜ЮА[ьЮБacЮВhњЮГk>ЮДpLЮЕt/ЮЖtиЮЗ{ЁЮИPЮЙƒХЮК‰РЮЛŒЋЮМ•мЮН™(ЮОR.ЮП`]ЮРbьЮСЮТOŠЮУQIЮФS!ЮХXйЮЦ^уЮЧfрЮШm8ЮЩpšЮЪrТЮЫsжЮЬ{PЮЭ€ёЮЮ”[ЮЯSfЮаc›ЮбkЮвNVЮгP€ЮдXJЮеXоЮж`*Юзa'ЮиbаЮйiаЮк›AЮл[Юм}Юн€БЮо_ЮпNЄЮрPбЮсTЌЮтUЌЮу[ Юф] Юх]чЮцe*ЮчeNЮшh!ЮщjKЮъrсЮыvŽЮьwяЮэ}^ЮюљЮя Ю№…NЮё†пЮђЮѓNЮєЪЮѕ™ЮіšUЮї›ЋЮјNЮљNEЮњN]ЮћNЧЮќOёЮ§QwЮўRўЯЁS@ЯЂSуЯЃSхЯЄTŽЯЅVЯІWuЯЇWЂЯЈ[ЧЯЉ]‡ЯЊ^аЯЋaќЯЌbиЯ­eQЯЎgИЯЏgщЯАiЫЯБkPЯВkЦЯГkьЯДlBЯЕnЯЖpxЯЗrзЯИs–ЯЙtЯКwПЯЛwщЯМzvЯН}ЯО€ ЯПќЯР‚ЯС‚ ЯТ‚пЯУˆbЯФ‹3ЯХŒќЯЦŽРЯЧЯШБЯЩ’dЯЪ’ЖЯЫ™вЯЬšEЯЭœщЯЮзЯЯŸœЯаW Яб\@ЯвƒЪЯг— Яд—ЋЯеžДЯжTЯзz˜ЯиЄЯйˆйЯкŽЭЯлсЯмXЯн\HЯоc˜ЯпzŸЯр[ЎЯс_ЯтzyЯуzЎЯф‚ŽЯхŽЌЯцP&ЯчR8ЯшRјЯщSwЯъWЯыbѓЯьcrЯэk ЯюmУЯяw7Я№SЅЯёsWЯђ…hЯѓŽvЯє•еЯѕg:ЯіjУЯїopЯјŠmЯљŽЬЯњ™KЯћљЯќfwЯ§kxЯўŒДаЁ›<аЂљаЃSыаЄW-аЅYNаІcЦаЇiћаЈsъаЉxEаЊzКаЋzХаЌ|ўа­„uаЎ‰аЏsаА5аБ•ЈаВRћаГWGаДuGаЕ{`аЖƒЬаЗ’аИљаЙjXаКQKаЛRKаМR‡аНbаОhиаПiuаР–™аСPХаТRЄаУRфаФaУаХeЄаЦh9аЧiџаШt~аЩ{KаЪ‚ЙаЫƒыаЬ‰ВаЭ‹9аЮбаЯ™Iааљ абNЪавY—агdвадfаеjŽажt4азyаиyНай‚Љакˆ~алˆам‰_анљ ао“&апO арSЪас`%атbqауlrаф}ах}fацN˜ачQbашwмащ€ЏаъOаыOаьQvаэQ€аюUмаяVhа№W;аёWњађWќаѓYаєYGаѕY“аі[Фаї\ај]аљ]ёањ^~аћ_Ьаќb€а§eзаўeубЁgбЂgбЃg^бЄhЫбЅhФбІj_бЇk:бЈl#бЉl}бЊl‚бЋmЧбЌs˜б­t&бЎt*бЏt‚бАtЃбБuxбВuбГxбДxябЕyAбЖyGбЗyHбИyzбЙ{•бК}бЛ}КбМˆбН€бО€-бП€ŒбРŠбС‹OбТŒHбУwбФ“!бХ“$б֘тбЧ™QбШšбЩšбЪšeбЫž’бЬ}ЪбЭOvбЮT бЯbюбаhTбб‘ббвUЋбгQ:бдљ бељ бжZбзaцбиљ бйbЯбкbџблљбмљбнљбољбпљбрљбсЃбтљбуљбфљбхљбцљбчŠўбшљбщљбъљбыљбьf–бэљбюqVбяљб№љбё–убђљ бѓcOбєczбѕSWбіљ!бїgбјi`бљnsбњљ"бћu7бќљ#б§љ$бўљ%вЁ} ‚&вЃљ'вЄˆrвЅVЪвІZвЇљ(вЈљ)вЉљ*вЊљ+вЋљ,вЌNCв­љ-вЎQgвЏYHвАg№вБ€вВљ.вГYsвД^tвЕdšвЖyЪвЗ_ѕвИ`lвЙbШвКc{вЛ[чвМ[звНRЊвОљ/вПYtвР_)вС`вТљ0вУљ1вФљ2вХtYвЦљ3вЧљ4вШљ5вЩљ6вЪљ7вЫљ8вЬ™бвЭљ9вЮљ:вЯљ;ваљ<вбљ=ввљ>вгљ?вдљ@вељAвжљBвзљCвиoУвйљDвкљEвлПвмВвн`ёвољFвпљGврfвсљHвтљIву\?вфљJвхљKвцљLвчљMвшљNвщљOвъљPвыљQвьZщвэŠ%вюg{вя}в№љRвёљSвђљTвѓљUвєљVвѕљWві€§вїљXвјљYвљ\<вњlхвћS?вќnКв§Yвўƒ6гЁN9гЂNЖгЃOFгЄUЎгЅWгІXЧгЇ_VгЈeЗгЉeцгЊj€гЋkЕгЌnMг­wэгЎzягЏ|гА}огБ†ЫгВˆ’гГ‘2гД“[гЕdЛгЖoОгЗszгИuИгЙTгКUVгЛWMгМaКгНdдгОfЧгПmсгРn[гСomгТoЙгУu№гФ€CгХНгЦ…AгЧ‰ƒгШŠЧгЩ‹ZгЪ“гЫl“гЬuSгЭ{TгЮŽгЯ]гаUгбXгвXXгг^bгдbгеdžгжhргзuvги|жгй‡ГгкžшглNугмWˆгнWnгоY'гп\ гр\Бгс^6гт_…гуb4гфdсгхsГгцњгчˆ‹гшŒИгщ–Šгъžлгы[…гь_Згэ`ГгюPгяRг№R0гёWгђX5гѓXWгє\гѕ\`гі\ігї]‹гј^Ігљ_’гњ`Мгћcгќc‰г§dгўhCдЁhљдЂjТдЃmидЄn!дЅnддІoфдЇqўдЈvмдЉwyдЊyБдЋz;дЌ„д­‰ЉдЎŒэдЏѓдАŽHдБдВдГSдД§дЕ“MдЖ–vдЗ—мдИkвдЙpдКrXдЛrЂдМshдНwcдОyПдП{фдР~›дС‹€дТXЉдУ`ЧдФefдХe§дЦfОдЧlŒдШqдЩqЩдЪŒZдۘдЬNmдЭzдЮNндЯQЌдаQЭдбRедвT дгaЇддgqдеhPджhпдзmдиo|дйuМдкwГдлzхдм€єдн„cдо’…дпQ\дрe—дсg\дтg“дуuидфzЧдхƒsдцљZдчŒFдшдщ˜-дъ\oдыРдь‚šдэAдюoдя’ д№_—дё]дђjYдѓqШдєv{дѕ{Iді…фдї‹дј‘'дљš0дњU‡дћaідќљ[д§viдў…еЁ†?еЂ‡КеЃˆјеЄеЅљ\еІmеЇpйеЈsоеЉ}aеЊ„=еЋљ]еЌ‘jе­™ёеЎљ^еЏN‚еАSuеБkеВkеГp>еДrеЕ†-еЖžеЗRLеИЃеЙ]PеКdхеЛe,еМkеНoыеО|CеП~œеР…ЭеС‰dеТ‰НеУbЩеФиеХˆеЦ^ЪеЧgеШmjеЩrќеЪtеЫtoеЬ‡‚еЭоеЮO†еЯ] еа_ еб„ евQЗегc едueееNЎежPезQiеиQЩейhекjел|Ўем|Бен|чео‚oепŠверес‘ЯетOЖеуQ7ефRѕехTBец^ьечanешb>ещeХеъjкеыoўеьy*еэ…меюˆ#ея•­е№šbеёšjеђž—еѓžЮеєR›еѕfЦеіkwеїpејy+ељbењ—Bећaеќbе§e#еўo#жЁqIжЂt‰жЃ}єжЄ€oжЅ„южІ&жЇ#жЈ“JжЉQНжЊRжЋRЃжЌm ж­pШжЎˆТжЏ^ЩжАe‚жБkЎжВoТжГ|>жДsuжЕNфжЖO6жЗVљжИљ_жЙ\КжК]КжЛ`жМsВжН{-жОšжПЮжР€FжСжТ’4жУ–іжФ—Hж՘жЦŸaжЧO‹жШoЇжЩyЎжЪ‘ДжЫ–ЗжЬRожЭљ`жЮdˆжЯdФжаjгжбo^жвpжгrждvчже€жж†жз†\жияжйжк—2жл›oжмњжнžuжоxŒжпyжр} жсƒЩжт“жуžжфž“жхŠжжцXпжч_жшg'жщp'жъtЯжы|`жь€~жэQ!жюp(жяrbж№xЪжёŒТжђŒкжѓŒєжє–їжѕN†жіPкжї[южј^жжљe™жњqЮжћvBжќw­ж§€Jжў„ќзЁ|зЂ›'зЃŸзЄXизЅZAзІ\bзЇjзЈmкзЉoзЊv;зЋ}/зЌ~7з­…зЎ‰8зЏ“фзА–KзБR‰зВeвзГgѓзДiДзЕmAзЖnœзЗpзИt зЙt`зКuYзЛv$зМxkзН‹,зΘ^зПQmзРb.зС–xзТO–зУP+зФ]зХmъзЦ}ИзЧ*зШ_‹зЩaDзЪhзЫљaзЬ–†зЭRвзЮ€‹зЯQмзаQЬзбi^звzзг}Оздƒёзе–uзжOкззR)зиS˜зйTзкUзл\eзм`ЇзнgNзоhЈзпmlзрrзсrјзтtзуtƒзфљbзхuтзц|lзчyзшИзщƒ‰зъˆЯзыˆсзь‘Ьзэ‘азю–тзя›Щз№Tзёo~зђqазѓt˜зє…њзѕŽЊзі–ЃзїœWзјžŸзљg—зњmЫзћt3зќшз§—зўx,иЁzЫиЂ{ иЃ|’иЄdiиЅtjиІuђиЇxМиЈxшиЉ™ЌиЊ›TиЋžЛиЌ[ои­^UиЎo иЏœиАƒЋиБˆиВNиГSMиДZ)иЕ]виЖ_NиЗabиИc=иЙfiиКfќиЛnџиМo+иНpcиОwžиП„,иР…иСˆ;иТиУ™EиФœ;иХUиЦbЙиЧg+иШlЋиЩƒ иЪ‰jиЫ—zиЬNЁиЭY„иЮ_ииЯ_йиаgиб}ВивTиг‚’идƒ+иеƒНижиз™ииWЫийYЙикZ’ил[аимf'инgšиоh…ипkЯирqdисuитŒЗиуŒуифих›EицичŒŠиш–Lищš@иъžЅиы[_иьlиэsиюvђияvп蹄 иёQЊиђ‰“иѓQMиєQ•иѕRЩиіhЩиїl”ијwиљw ињ}Пић}ьиќ—bи§žЕиўnХйЁ…йЂQЅйЃT йЄT}йЅfйІfйЇi'йЈnŸйЉvПйЊw‘йЋƒйЌ„Тй­‡ŸйЎ‘iйЏ’˜йАœєйБˆ‚йВOЎйГQ’йДRпйЕYЦйЖ^=йЗaUйИdxйЙdyйКfЎйЛgайМj!йНkЭйОkлйПr_йРraйСtAйТw8йУwлйФ€йХ‚МйЦƒйЧ‹йШ‹(йЩŒŒйЪg(йЫlйЬrgйЭvюйЮwfйЯzFйаЉйбkйвl’йгY"йдg&йе„™йжSoйзX“йиY™йй^пйкcЯйлf4ймgsйнn:йоs+йпzзйр‚зйс“(йтRййу]ыйфaЎйхaЫйцb йчbЧйшdЋйщeрйъiYйыkfйьkЫйэq!йюsїйяu]й№~Fйё‚йђƒйѓ…jйєŠЃйѕŒПйі—'йїaйјXЈйљžийњPйћRйќT;й§UOйўe‡кЁlvкЂ} кЃ} кЄ€^кЅ†ŠкІ•€кЇ–якЈRџкЉl•кЊriкЋTsкЌZšк­\>кЎ]KкЏ_LкА_ЎкБg*кВhЖкГicкДn<кЕnDкЖw кЗ|sкИŽкЙ…‡кК‹кЛїкМ—aкНžєкО\ЗкП`ЖкРa кСaЋкТeOкУeћкФeќкХlкЦlякЧsŸкШsЩкЩ}скЪ•”кЫ[ЦкЬ‡кЭ‹кЮR]кЯSZкаbЭкбdквdВкгg4кдj8кеlЪкжsРкзtžки{”кй|•кк~клŠкм‚6кн…„коыкп–љкр™СксO4ктSJкуSЭкфSлкхbЬкцd,кчeкшe‘кщiУкъlюкыoXкьsэкэuTкюv"кяvфк№vќкёxакђxћкѓy,кє}Fкѕ‚,кі‡ркїд꼘ꚘякњRУкћbдкќdЅк§n$кўoQлЁv|лЂЫлЃ‘БлЄ’bлЅšюлІ›CлЇP#лЈPлЉWJлЊYЈлЋ\(лЌ^Gл­_wлЎb?лЏe>лАeЙлБeСлВf лГg‹лДiœлЕnТлЖxХлЗ}!лИ€ЊлЙ€лК‚+лЛ‚ГлМ„ЁлН†ŒлОŠ*лП‹лРІлС–2лТŸлУP лФOѓлХљcлЦWљлЧ_˜лШbмлЩc’лЪgoлЫnCлЬqлЭvУлЮ€ЬлЯ€клаˆєлбˆѕлв‰лгŒрлд)ле‘Mлж–jлзO/лиOpлй^лкgЯллh"лмv}лнv~ло›Dлп^aлрj лсqiлтqдлуujлфљdлх~Aлц…Cлч…щлш˜млщOлъ{Oлыpль•ЅлэQслю^ляhЕл№l>лёlNлђlллѓrЏлє{Флѕƒліlелїt:лјPћлљRˆлњXСлћdилќj—л§tЇлўvVмЁxЇмЂ†мЃ•тмЄ—9мЅљeмІS^мЇ_мЈ‹ŠмЉЈмЊЏмЋŠмЌR%м­wЅмЎœIмЏŸмАNмБPмВQuмГ\[мД^wмЕfмЖf:мЗgФмИhХмЙpГмКuмЛuХмМyЩмНzнмО'мП™ мРšмСOнмТX!мУX1мФ[імХfnмЦkeмЧmмШnzмЩo}мЪsфмЫu+мЬƒщмЭˆммЮ‰мЯ‹\мамбOмвPемгSмдS\ме[“мж_Љмзg миyмйyмкƒ/мл…мм‰м퉆мо9мп;мр™Ѕмсœмтg,муNvмфOјмхYIмц\мч\ямш\№мщcgмъhвмыp§мьqЂмэt+мю~+мя„ь칇мё"мђ’вмѓœѓмєN мѕNиміOямїP…мјRVмљRoмњT&мћTмќWрм§Y+мўZfнЁ[ZнЂ[uнЃ[ЬнЄ^œнЅљfнІbvнЇewнЈeЇнЉmnнЊnЅнЋr6нЌ{&н­|?нЎ6нЏPнАQнБšнВ‚@нГ‚™нДƒЉнЕŠнЖŒ нЗŒцнИŒћнЙtнККнЛшнМ‘мнН–нО–DнП™йнРœчнСSнТRнУT)нФVtнХXГнЦYTнЧYnнШ_џнЩaЄнЪbnнЫfнЬl~нЭqнЮvЦнЯ|‰на|онб}нв‚ЌнгŒСнд–№нељgнжO[нз_ни_нйbТнк])нлg нмhкннx|но~CнпlнрNнсP™нтSнуS*нфSQнхYƒнцZbнч^‡нш`ВнщaŠнъbIныbyньeнэg‡нюiЇняkдн№kжнёkзнђkинѓlИнєљhнѕt5ніuњнїxнјx‘нљyенњyинћ|ƒнќ}Ын§снў€ЅоЁ>оЂТоЃƒђоЄ‡оЅˆшоІŠЙоЇ‹lоЈŒЛоЉ‘оЊ—^лоЌŸ;о­VЌоЎ[*оЏ_lоАeŒоБjГоВkЏоГm\оДoёоЕpоЖr]оЗs­оИŒЇоЙŒгоʘ;оЛa‘оМl7оН€XоОšоПNMоРN‹оСN›оТNеоУO:оФO<оХOоЦOпоЧPџоШSђоЩSјоЪUоЫUуоЬVлоЭXыоЮYbоЯZоа[ыоб[њов\ог]ѓод^+ое_™ож`озchоиeœойeЏокgіолgћомh­онk{ооl™опlзорn#осp отsEоуxофy>охy@оцy`очyСош{щощ}оъ}rоы€†оь‚ оэƒŽою„боя†Чо№ˆпоёŠPођŠ^оѓ‹оєŒмоѕfоі­оїЊој˜ќољ™поњžоћRJоќљiо§gоўљjпЁP˜пЂR*пЃ\qпЄecпЅlUпІsЪпЇu#пЈuпЉ{—пЊ„œпЋ‘xпЌ—0п­NwпЎd’пЏkКпАq^пБ…ЉпВN пГљkпДgIпЕhюпЖnпЗ‚ŸпИ…пЙˆkпКcїпЛoпМ’п͘ЏпОN пПPЗпРPЯпСQпТUFпУUЊпФVпХ[@пЦ\пЧ\рпШ^8пЩ^ŠпЪ^ пЫ^ТпЬ`ѓпЭhQпЮjaпЯnXпаr=пбr@пвrРпгvјпдyeпе{Бпждпзˆѓпи‰єпйŠsпкŒaплŒопм—пнX^поtНппŒ§прUЧпсљlптzaпу}"пф‚rпхrrпцuпчu%пшљmпщ{пъX…пыXћпь]Мпэ^пю^Жпя_п№`Uпёb’пђcпѓeMпєf‘пѕfйпіfјпїhпјhђпљr€пњt^пћ{nпќ}nп§}жпўrрЁ€хрЂ‚рЃ…ЏрЄ‰рЅŠ“рІрЇ’фрЈžЭрЉŸ рЊYрЋYmрЌ^-р­`мрЎfрЏfsрАgрБlPрВmХрГo_рДwѓрЕxЉрЖ„ЦрЗ‘ЫрИ“+рЙNйрКPЪрЛQHрМU„рН[ рО[ЃрПbGрРe~рСeЫрТn2рУq}рФtрХtDрЦt‡рЧtПрШvlрЩyЊрЪ}крЫ~UрЬЈрЭzрЮГрЯ‚9ра†рб‡ьрвŠuргурдxре’‘рж”%рз™Mри›ЎрйShрк\QрлiTрмlФрнm)роn+рп‚ рр…›рс‰;ртŠ-руŠЊрф–ърхŸgрцRaрчfЙршkВрщ~–ръ‡ўры рь•ƒрэ–]рюeряm‰р№qюрёљnрђWЮрѓYгрє[Ќрѕ`'рі`њрїbрјfрљf_рњs)рћsљрќvлр§wрў{lсЁ€VсЂ€rсЃeсЄŠ сЅ‘’сІNсЇRтсЈkrсЉmсЊzсЋ{9сЌ}0с­љoсЎŒАсЏSьсАV/сБXQсВ[ЕсГ\сД\сЕ]тсЖb@сЗcƒсИdсЙf-сКhГсЛlМсМmˆсНnЏсОpсПpЄсРqвсСu&сТuсУuŽсФvсХ{сЦ{рсЧ|+сШ} сЩ}9сЪ…,сЫ…mсЬ†сЭŠ4сЮ сЯaсаЕсб’Зсв—ісгš7сдOзсе\lсжg_сзm‘си|Ÿсй~Œск‹слсмсн[kсо]§спd ср„Рсс\ст˜ссуs‡сф[‹сх`šсцg~счmосшŠсщŠІсъсы˜ сьR7сэљpсюpQсяxŽс№“–сёˆpсђ‘зсѓOюсєSзсѕU§сіVксїW‚сјX§сљZТсњ[ˆсћ\Ћсќ\Рс§^%сўaтЁb тЂbKтЃcˆтЄdтЅe6тІexтЇj9тЈkŠтЉl4тЊmтЋo1тЌqчт­rщтЎsxтЏtтАtВтБv&тВwaтГyРтДzWтЕzътЖ|ЙтЗ}тИ}ЌтЙ~aтКžтЛ)тМƒ1тН„тО„ктП…ътРˆ–тСŠАтТ‹тУ8тФBтХƒтЦ‘lтЧ’–тШ’ЙтЩ–‹тЪ–ЇтЫ–ЈтЬ–жтЭ—тޘтЯ™–таšгтб›твSдтгX~тдYте[pтж[ПтзmбтиoZтйqŸткt!тлtЙтм€…тнƒ§то]стп_‡тр_Њтс`BттeьтуhтфioтхjSтцk‰тчm5тшmѓтщsутъvўтыwЌть{Mтэ}тю#тя‚т№ƒ@тё„єтђ…cтѓŠbтєŠФтѕ‘‡ті“тї˜тј™Дтљb тњˆSтћ№тќ’eт§]тў]'уЁ]iуЂt_уЃуЄ‡hуЅoеуІbўуЇвуЈ‰6уЉ‰rуЊNуЋNXуЌPчу­RнуЎSGуЏbуАfуБ~iуВˆуГ–^уДOуЕSуЖV6уЗYЫуИZЄуЙ\8уК\NуЛ\MуМ^уН_уО`CуПeНуРf/уСfBуТgОуУgєуФsуХwтуЦy:уЧХуШ„”уЩ„ЭуЪ‰–уЫŠfуЬŠiуЭŠсуЮŒUуЯŒzуаWєуб[дув_уг`oудbэуеi ужk–узn\уиq„уй{вук‡Uул‹XумŽўун˜пуупO8урOусOсутT{ууZ уф[Иухa<уцeАучfhушqќущu3уъy^уы}3уьNуэууюƒ˜уя…Њу№…Юуё‡уђŠ уѓŽЋує›уѕљqуіХуїY1уј[Єуљ[цуњ`‰ућ[щуќ\ у§_УуўlфЁљrфЂmёфЃp фЄuфЅ‚ЏфІŠіфЇNРфЈSAфЉљsфЊ–йфЋlфЌNžф­OФфЎQRфЏU^фАZ%фБ\шфВbфГrYфД‚НфЕƒЊфЖ†ўфЗˆYфИŠфЙ–?фК–ХфЛ™фМ фН]фОX фП\ГфР]НфС^DфТ`сфУaфФcсфХjфЦn%фЧ‘фШ“Tф٘NфЪœфЫŸwфЬ[‰фЭ\ИфЮc фЯfOфаhHфбw<фв–Сфг—фд˜Tфе›ŸфжeЁфз‹фиŽЫфй•МфкU5фл\Љфм]жфн^Ефоf—фпvLфрƒєфс•ЧфтXгфуbМффrЮфх(фцN№фчY.фш`фщf;фъkƒфыyчфь&фэS“фюTРфяWУф№]фёaфђfжфѓmЏфєxфѕ‚~фі–˜фї—DфјS„фљb|фњc–фћmВфќ~ ф§Kфў˜MхЁjћхЂLхЃЏхЄžхЅN_хІP;хЇQЖхЈYхЉ`љхЊcіхЋi0хЌr:х­€6хЎљtхЏ‘ЮхА_1хБљuхВљvхГ}хД‚ххЕ„oхЖ„ЛхЗ…ххИŽхЙљwхКOoхЛљxхМљyхНXфхО[CхП`YхРcкхСeхТemхУf˜хФљzхХiJхЦj#хЧm хШpхЩqlхЪuвхЫv хЬyГхЭzpхЮљ{хЯŠхаљ|хб‰Dхвљ}хг‹“хд‘Рхе–}хжљ~хз™ хиWхй_ЁхкeМхлoхмvхнyІхоŠžхп™­хр›ZхсŸlхтQхуaЖхфb‘ххjхцЦхчPCхшX0хщ_fхъq хыŠхьŠњхэ[|хю†хяOњх№Q<хёVДхђYDхѓcЉхєmљхѕ]ЊхіimхїQ†хјNˆхљOYхњљхћљ€хќљх§Y‚хўљ‚цЁљƒцЂk_цЃl]цЄљ„цЅtЕцІyцЇљ…цЈ‚цЉ‚EцЊƒ9цЋ?цЌ]ц­љ†цЎ™цЏљ‡цАљˆцБљ‰цВNІцГљŠцДWпцЕ_yцЖfцЗљ‹цИљŒцЙuЋцК~yцЛ‹oцМљцНцОš[цПVЅцРX'цСYјцТZцУ[ДцФљŽцХ^іцЦљцЧљцШcPцЩc;цЪљ‘цЫi=цЬl‡цЭlПцЮmŽцЯm“цаmѕцбoцвљ’цгpпцдq6цеqYцжљ“цзqУциqецйљ”цкxOцлxoцмљ•цн{uцо}уцпљ–цр~/цсљ—цтˆMцуŽпцфљ˜цхљ™ццљšцч’[цшљ›цщœіцъљœцыљцьљžцэ`…цюm…цяљŸц№qБцёљ цђљЁцѓ•БцєS­цѕљЂціљЃцїљЄцјgгцљљЅцњpŽцћq0цќt0ц§‚vцў‚вчЁљІчЂ•ЛчЃšхчЄž}чЅfФчІљЇчЇqСчЈ„IчЉљЈчЊљЉчЋXKчЌљЊч­љЋчЎ]ИчЏ_qчАљЌчБf чВfŽчГiyчДiЎчЕl8чЖlѓчЗn6чИoAчЙoкчКpчЛp/чМqPчНqпчОspчПљ­чРt[чСљЎчТtдчУvШчФzNчХ~“чЦљЏчЧљАчШ‚ёчЩŠ`чЪЮчЫљБчЬ“HчЭљВчЮ—чЯљГчаљДчбNBчвP*чгљЕчдRчеSсчжfѓчзlmчиoЪчйs чкwчлzbчм‚Ўчн…нчо†чпљЖчрˆдчсŠcчт‹}чуŒkчфљЗчх’ГчцљИчч—чш˜чщN”чъO чыOЩчьPВчэSHчюT>чяT3ч№UкчёXbчђXКчѓYgчєZчѕ[фчі`ŸчїљЙчјaЪчљeVчњeџчћfdчќhЇч§lZчўoГшЁpЯшЂqЌшЃsRшЄ{}шЅ‡шІŠЄшЇœ2шЈŸшЉ\KшЊlƒшЋsDшЌs‰ш­’:шЎnЋшЏteшАvшБziшВ~шГ† шДQ@шЕXХшЖdСшЗtюшИuшЙvpшКСшЛ•шМ–ЭшН™TшОn&шПtцшРzЉшСzЊшТхшУ†йшФ‡xшХŠшЦZIшЧ[ŒшШ[›шЩhЁшЪiшЫmcшЬsЉшЭtшЮt,шЯx—ша}щшбышвшгUшдƒžшеŒLшж–.шз˜шиf№шй_€шкeњшлg‰шмljшнs‹шоP-шпZшрkjшсwюштYшу]lшф]Эшхs%шцuOшчљКшшљЛшщPхшъQљшыX/шьY-шэY–шюYкшя[хш№љМшёљНшђ]Ђшѓbзшєdшѕd“шіdўшїљОшјfмшљљПшњjHшћљРшќqџш§tdшўљСщЁzˆщЂzЏщЃ~GщЄ~^щЅ€щІpщЇљТщЈ‡ящЉ‰щЊ‹ щЋYщЌљУщ­€щЎ™RщЏa~щАk2щБmtщВ~щГ‰%щДБщЕOбщЖP­щЗQ—щИRЧщЙWЧщКX‰щЛ[ЙщМ^ИщНaBщОi•щПmŒщРngщСnЖщТq”щУtbщФu(щХu,щЦ€sщЧƒ8щШ„ЩщЩŽ щЪ“”щЫ“ощЬљФщЭNŽщЮOQщЯPvщаQ*щбSШщвSЫщгSѓщд[‡ще[гщж\$щзaщиa‚щйeєщкr[щлs—щмt@щнvТщоyPщпy‘щрyЙщс}щтНщу‚‹щф…ещх†^щцТщчGщшѕщщ‘ъщъ–…щы–шщь–щщэRжщю_gщяeэщ№f1щёh/щђq\щѓz6щєСщѕ˜ щіN‘щїљХщјjRщљkžщњoщћq‰щќ€щ§‚Ищў…SъЁKъЂ–•ъЃ–ђъЄ—ћъЅ…ъІ›1ъЇNъЈqŠъЉ–ФъЊQCъЋSŸъЌTсъ­WъЎWъЏWЃъАZ›ъБZФъВ[УъГ`(ъДa?ъЕcєъЖl…ъЗm9ъИnrъЙnъКr0ъЛs?ъМtWъН‚бъОˆъПEъР`ъСљЦъТ–bъӘXъФъХgъЦŠъЧ’^ъШOMъЩPIъЪPоъЫSqъЬW ъЭYдъЮZъЯ\ ъаapъбfъвn-ъгr2ъдtKъе}яъж€Уъз„ъи„fъй…?ък‡_ълˆ[ъм‰ън‹ъоUъп—Ыър›OъсNsътO‘ъуQъфQjъхљЧъцU/ъчUЉъш[zъщ[Ѕъъ^|ъы^}ъь^Оъэ` ъю`пъяaъ№a ъёcФъђe8ъѓg ъєљШъѕgдъіgкъїљЩъјiaъљibъњlЙъћm'ъќљЪъ§n8ъўљЫыЁoсыЂs6ыЃs7ыЄљЬыЅt\ыІu1ыЇљЭыЈvRыЉљЮыЊљЯыЋ}­ыЌўы­„8ыЎˆеыЏŠ˜ыАŠлыБŠэыВŽ0ыГŽBыДJыЕ>ыЖzыЗ‘IыИ‘ЩыЙ“nыКљаыЛљбыМX ыНљвыОkгыП€‰ыР€ВыСљгыТљдыУQAыФYkыХ\9ыЦљеыЧљжыШodыЩsЇыЪ€фыЫыЬљзыЭ’ыЮ•ыЯљиыаљйыбљкывљлыг€ыдbыеpыж}hыз‡ыиљмыйW ык`iылaGымkЗынŠОыо’€ып–БырNYысTытmыыу…-ыф–pых—ѓыц˜юычcжышlуыщ‘ыъQныыaЩыьКыэљыюOыяPы№Qыё[œыђaыѓaџыєdьыѕiыіkХыїu‘ыјwуыљЉыњ‚dыћ…ыќ‡ћы§ˆcыўŠМьЁ‹pьЂ‘ЋьЃNŒьЄNхьЅO ьІљньЇљоьЈY7ьЉYшьЊљпьЋ]ђьЌ_ь­_[ьЎ`!ьЏљрьАљсьБљтьВљуьГr>ьДsхьЕљфьЖupьЗuЭьИљхьЙyћьКљцьЛ€ ьМ€3ьН€„ьО‚сьПƒQьРљчьСљшьТŒНьУŒГьФ‡ьХљщьЦљъьטєьШ™ ьЩљыьЪљььЫp7ьЬvЪьЭЪьЮЬьЯќьа‹ьбNКьвNСьгRьдSpьељэьжTНьзVрьиYћьй[Хьк_ьл_Эьмnnьнљюьољяьп}jьрƒ5ьсљ№ьт†“ьуŠьфљёьх—mьц—wьчљђьшљѓьщNьъOZьыO~ььXљьэeхьюnЂья8ь№“Аьё™ЙьђNћьѓXььєYŠьѕYйьі`AьїљєьјљѕьљzьњљіьћƒOьќŒУь§QeьўSDэЁљїэЂљјэЃљљэЄNЭэЅRiэІ[UэЇ‚ПэЈNдэЉR:эЊTЈэЋYЩэЌYџэ­[PэЎ[WэЏ[\эА`cэБaHэВnЫэГp™эДqnэЕs†эЖtїэЗuЕэИxСэЙ}+эК€эЛъэМƒ(эН…эО…ЩэПŠюэРŒЧэС–ЬэТO\эУRњэФVМэХeЋэЦf(эЧp|эШpИэЩr5эЪ}НэЫ‚эЬ‘LэЭ–РэЮrэЯ[qэаhчэбk˜эвozэгvоэд\‘эеfЋэжo[эз{Дэи|*эйˆ6эк–мэлNэмNзэнS эоX4эпXЛэрXяэсYlэт\эу^3эф^„эх_5эцcŒэчfВэшgVэщjэъjЃэыk эьo?ээrFэюљњэяsPэ№t‹эёzрэђ|ЇэѓxэєпэѕчэіƒŠэї„lэј…#эљ…”эњ…Яэћˆнэќэ§‘Ќэў•wюЁ–œюЂQюЃTЩюЄW(юЅ[АюІbMюЇgPюЈh=юЉh“юЊn=юЋnгюЌp}ю­~!юЎˆСюЏŒЁюА юБŸKюВŸNюГr-юД{юЕŠЭюЖ“юЗOGюИONюЙQ2юКT€юЛYаюМ^•юНbЕюОguюПinюРjюСlЎюТnюУrйюФs*юХuНюЦ{ИюЧ}5юШ‚чюЩƒљюЪ„WюЫ…їюЬŠ[юЭŒЏюЮŽ‡юЯюаИюб–ЮювŸ_югRуюдT юеZсюж[ТюзdXюиeuюйnєюкrФюлљћюмv„юнzMюо{юп|Mюр~>юспютƒ{юу‹+юфŒЪюхdюцсючŽ_юшъющљюъiюы“бюьOCюэOzююPГюяQhю№QxюёRMюђRjюѓXaюєX|юѕY`юі\юї\Uюј^люљ`›юњb0юћhюќkПю§lюўoБяЁqNяЂt яЃu0яЄu8яЅuQяІvrяЇ{LяЈ{‹яЉ{­яЊ{ЦяЋ~яЌŠnя­>яЎIяЏ’?яА’“яБ“"яВ”+яГ–ћяĘZяŘkяЖ™яЗRяИb*яЙb˜яКmYяЛvdяМzЪяН{РяО}vяПS`яР\ОяС^—яТo8яУpЙяФ|˜яХ—яЦ›ŽяЧžояШcЅяЩdzяЪ‡vяЫNяЬN•яЭN­яЮP\яЯPuяаTHябYУяв[šяг^@яд^­яе^їяж_яз`Хяиc:яйe?якetялeЬямfvянfxяоgўяпihярj‰ясkcятl@яуmРяфmшяхnяцn^ячpяшpЁящsŽяъs§яыu:яьw[яэx‡яюyŽяяz я№z}яё|Ояђ}Žяѓ‚GяєŠяѕŠъяіŒžяї‘-яј‘Jяљ‘ияњ’fяћ’Ьяќ“ я§—яў—V№Ё—\№Ђ˜№ЃŸ№ЄR6№ЅR‘№ІU|№ЇX$№Ј^№Љ_№Њ`Œ№Ћcа№ЌhЏ№­oп№Ўym№Џ{,№АЭ№Б…К№Вˆ§№ГŠј№ДŽD№Е‘№Ж–d№З–›№И—=№Й˜L№КŸJ№ЛOЮ№МQF№НQЫ№ОRЉ№ПV2№Р_№С_k№ТcЊ№УdЭ№Фeщ№ХfA№Цfњ№Чfљ№Шg№Щh№Ъhз№Ыi§№Ьo№Эon№Юqg№Яqх№аr*№бtЊ№вw:№гyV№дyZ№еyп№жz №зz•№и|—№й|п№к}D№л~p№м€‡№н…ћ№о†Є№пŠT№рŠП№с™№тŽ№у №фm№х‘у№ц–;№ч–е№шœх№щeЯ№ъ|№ыГ№ь“У№э[X№ю\ №яSR№№bй№ёs№ђP'№ѓ[—№є_ž№ѕ`А№іak№їhе№јmй№љt.№њz.№ћ}B№ќ}œ№§~1№ўkёЁŽ*ёЂŽ5ёЃ“~ёЄ”ёЅOPёІWPёЇ]цёЈ^ЇёЉc+ёЊjёЋN;ёЌOOё­OёЎPZёЏYнёА€ФёБTjёВThёГUўёДYOёЕ[™ёЖ]оёЗ^кёИf]ёЙg1ёКgёёЛh*ёМlшёНm2ёОnJёПoёРpЗёСsрёТu‡ёУ|LёФ}ёХ},ёЦ}ЂёЧ‚ёШ†лёЩŠ;ёЪŠ…ёЫpёЬŽŠёЭ3ёЮ1ёЯ‘Nёа‘Rёб”Dёв™аёгzљёд|ЅёеOЪёжQёзQЦёиWШёй[яёк\ћёлfYёмj=ёнmZёоn–ёпoьёрq ёсuoётzуёуˆ"ёф!ёхuёц–Ыёч™џёшƒёщN-ёъNђёыˆFёь‘ЭёэS}ёюjлёяikё№lAёё„zёђXžёѓaŽёєfўёѕbяёіpнёїuёјuЧёљ~Rёњ„Иёћ‹Iёќё§NKёўSъђЁTЋђЂW0ђЃW@ђЄ_зђЅcђІcђЇdoђЈe/ђЉeшђЊfzђЋgђЌgГђ­kbђЎl`ђЏlšђАo,ђБwхђВx%ђГyIђДyWђЕ}ђЖ€ЂђЗђИѓђЙ‚ђК‚ЗђЛ‡ђМŠŒђНљќђОђПОђРrђСvєђТzђУz7ђФ~TђХ€wђЦUђЧUдђШXuђЩc/ђЪd"ђЫfIђЬfKђЭhmђЮi›ђЯk„ђаm%ђбnБђвsЭђгthђдtЁђеu[ђжuЙђзvсђиwђйw‹ђкyцђл~ ђм~ђнћђо…/ђпˆ—ђрŠ:ђсŒбђтŽыђуАђф2ђх“­ђц–cђч–sђш—ђщO„ђъSёђыYъђьZЩђэ^ђюhNђяtЦђ№uОђёyщђђz’ђѓЃђє†эђѕŒъђіЬђїэђјeŸђљgђњљ§ђћWїђќoWђ§}нђў/ѓЁ“іѓЂ–ЦѓЃ_ЕѓЄaђѓЅo„ѓІNѓЇO˜ѓЈPѓЉSЩѓЊUпѓЋ]oѓЌ]юѓ­k!ѓЎkdѓЏxЫѓА{šѓБљўѓВŽIѓГŽЪѓДnѓЕcIѓЖd>ѓЗw@ѓИz„ѓЙ“/ѓК”ѓЛŸjѓМdАѓНoЏѓОqцѓПtЈѓРtкѓСzФѓТ|ѓУ~‚ѓФ|ВѓХ~˜ѓЦ‹šѓЧ ѓШ”}ѓЩ™ѓЪ™LѓЫR9ѓЬ[пѓЭdцѓЮg-ѓЯ}.ѓаPэѓбSУѓвXyѓгaXѓдaYѓеaњѓжeЌѓзzйѓи‹’ѓй‹–ѓкP ѓлP!ѓмRuѓнU1ѓоZ<ѓп^рѓр_pѓсa4ѓтe^ѓуf ѓфf6ѓхfЂѓцiЭѓчnФѓшo2ѓщsѓъv!ѓыz“ѓь9ѓэ‚Yѓюƒжѓя„Мѓ№PЕѓёW№ѓђ[Рѓѓ[шѓє_iѓѕcЁѓіx&ѓї}Еѓјƒмѓљ…!ѓњ‘Чѓћ‘ѕѓќQŠѓ§gѕѓў{VєЁŒЌєЂQФєЃYЛєЄ`НєЅ†UєІPєЇљџєЈRTєЉ\:єЊa}єЋbєЌbгє­dђєЎeЅєЏnЬєАv єБ єВŽ`єГ–_єД–ЛєЕNпєЖSCєЗU˜єИY)єЙ]нєКdХєЛlЩєМmњєНs”єОzєП‚єР…ІєСŒфєТŽєУwєФ‘чєХ•сєЦ–!єЧ—ЦєШQјєЩTђєЪU†єЫ_ЙєЬdЄєЭoˆєЮ}ДєЯєаMєб”5євPЩєг\єдlОєеmћєжuєзwЛєи|=єй|dєкŠyєлŠТємXєнYОєо^єпcwєрrRєсuŠєтwkєуŠмєфŒМєхєц^ѓєчftєшmјєщ€}єъƒСєыŠЫєь—Qєэ›жєюњєяRCє№fџєёm•єђnяєѓ}рєєŠцєѕ.єі^єїšдєјRєљRєњTшєћa”єќb„є§bлєўhЂѕЁiѕЂiZѕЃj5ѕЄp’ѕЅq&ѕІx]ѕЇyѕЈyѕЉyвѕЊz ѕЋ€–ѕЌ‚xѕ­‚еѕЎƒIѕЏ…IѕАŒ‚ѕБ…ѕВ‘bѕГ‘‹ѕД‘ЎѕЕOУѕЖVбѕЗqэѕИwзѕЙ‡ѕК‰јѕЛ[јѕМ_жѕНgQѕОЈѕПSтѕРXZѕС[ѕѕТ`ЄѕУaѕФd`ѕХ~=ѕЦ€pѕЧ…%ѕШ’ƒѕЩdЎѕЪPЌѕЫ]ѕЬgѕЭXœѕЮbНѕЯcЈѕаiѕбixѕвjѕгnkѕдvКѕеyЫѕж‚Лѕз„)ѕиŠЯѕйЈѕк§ѕл‘ѕм‘Kѕн‘œѕо“ѕп“ѕр“šѕс–лѕтš6ѕуœ ѕфNѕхu\ѕцy]ѕчzњѕш{Qѕщ{Щѕъ~.ѕы„ФѕьŽYѕэŽtѕюŽјѕяѕ№f%ѕёi?ѕђtCѕѓQњѕєg.ѕѕžмѕіQEѕї_рѕјl–ѕљ‡ђѕњˆ]ѕћˆwѕќ`Дѕ§Еѕў„іЁіЂSжіЃT9іЄV4іЅZ6іІ\1іЇpŠіЈріЉ€ZіЊіЋэіЌЃі­‘‰іЎš_іЏђіАPtіБNФіВS іГ`ћіДn,іЕ\dіЖOˆіЗP$іИUфіЙ\йіК^_іЛ`eіМh”іНlЛіОmФіПqОіРuдіСuєіТvaіУzіФzIіХ}ЧіЦ}ћіЧnіШєіЩ†ЉіЪіЫ–ЩіЬ™ГіЭŸRіЮRGіЯRХіа˜эіб‰ЊівNігgвідoіеOЕіж[тізg•іиlˆійmxікtілx'ім‘нін“|іо‡Фіпyфірz1іс_ыітNжіуTЄіфU>іхXЎіцYЅіч`№ішbSіщbжіъg6іыiUіь‚5іэ–@ію™Бія™ні№P,іёSSіђUDіѓW|ієњіѕbXііњіїdтіјfkіљgніњoСіћoяіќt"і§t8іўŠїЁ”8їЂTQїЃVїЄWfїЅ_HїІašїЇkNїЈpXїЉp­їЊ}ЛїЋŠ•їЌYjї­+їЎcЂїЏwїА€=їБŒЊїВXTїГd-їДiЛїЕ[•їЖ^їЗnoїИњїЙ…iїКQLїЛS№їМY*їН` їОaKїПk†їРlpїСl№їТ{їУ€ЮїФ‚дїХЦїЦАїЧ˜БїШњїЩdЧїЪoЄїЫd‘їЬeїЭQNїЮTїЯWїаŠїбa_ївhvїгњїдuлїе{Rїж}qїзїиXїйiЬїкїл‰*їмїн˜9їоPxїпYWїрYЌїсb•їтїу›*їфa]їхryїц•жїчWaїшZFїщ]єїъbŠїыd­їьdњїэgwїюlтїяm>ї№r,їёt6їђx4їѓwїє‚­їѕлїі˜їїR$їјWBїљgїњrHїћtуїќŒЉї§Іїў’јЁ–*јЂQkјЃSэјЄcLјЅOiјІUјЇ`–јЈeWјЉl›јЊmјЋrLјЌr§ј­zјЎ‰‡јЏŒјА_mјБoŽјВpљјГЈјДaјЕOПјЖPOјЗbAјИrGјЙ{ЧјК}шјЛщјМMјН—­јОšјПŒЖјРWjјС^sјТgАјУ„ јФŠUјХT јЦ[јЧ^cјШ^тјЩ_ јЪeƒјЫ€КјЬ…=јЭ•‰јЮ–[јЯOHјаSјбS јвSјгT†јдTњјеWјж^јз`јиb›јйbБјкcUјлњјмlсјнmfјоuБјпx2јр€ојс/јт‚оју„aјф„Вјхˆјц‰јч јш’ъјщ˜§јъ›‘јы^EјьfДјэfнјюpјяrј№њјёOѕјђR}јѓ_jјєaSјѕgSјіjјїoјјtтјљyhјњˆhјћŒyјќ˜Чј§˜ФјўšCљЁTСљЂzљЃiSљЄŠїљЅŒJљІ˜ЈљЇ™ЎљЈ_|љЉbЋљЊuВљЋvЎљЌˆЋљ­љЎ–BљЏS9љА_<љБ_ХљВlЬљГsЬљДubљЕu‹љЖ{FљЗ‚ўљИ™љЙNOљК<љЛN љМOUљНSІљОYљП^ШљРf0љСlГљТtUљУƒwљФ‡fљХŒРљЦPљЧ—љШœљЩXбљЪ[xљЫ†PљЬ‹љЭДљЮ[вљЯ`hља`љбeёљвlWљгo"љдoЃљеpљжUљз№љи•‘љй•’љк–Pљл—гљмRrљнDљоQ§љпT+љрTИљсUcљтUŠљуjЛљфmЕљх}иљц‚fљч’œљш–wљщžyљъTљыTШљьvвљэ†фљю•Єљя•дљ№–\љёNЂљђO љѓYюљєZцљѕ]їљі`Rљїb—љјgmљљhAљњl†љћn/љќ8љ§€›љў‚*њЁњњЂњ њЃ˜њЄNЅњЅPUњІTГњЇW“њЈYZњЉ[iњЊ[ГњЋaШњЌiwњ­mwњЎp#њЏ‡љњА‰уњБŠrњВŠчњГ‚њД™эњЕšИњЖRОњЗh8њИPњЙ^xњКgOњЛƒGњМˆLњНNЋњОTњПVЎњРsцњС‘њТ—џњУ™ њФ™WњХ™™њЦVSњЧXŸњШ†[њЩŠ1њЪaВњЫjіњЬs{њЭŽвњЮkGњЯ–ЊњаšWњбYUњвrњгkњд—iњеOдњж\єњз_&њиaјњйf[њкlыњлpЋњмs„њнsЙњоsўњпw)њрwMњс}Cњт}bњу~#њф‚7њхˆRњцњ њчŒтњш’Iњщ˜oњъ[Qњыztњьˆ@њэ˜њюZЬњяOрњ№STњёY>њђ\§њѓc>њєmyњѕrљњіњїњјƒЂњљ’Яњњ˜0њћNЈњќQDњ§RњўW‹ћЁ_bћЂlТћЃnЮћЄpћЅpPћІpЏћЇq’ћЈsщћЉtiћЊƒJћЋ‡ЂћЌˆaћ­ћЎЂћЏ“ЃћА™ЈћБQnћВ_WћГ`рћДagћЕfГћЖ…YћЗŽJћИ‘ЏћЙ—‹ћКNNћЛN’ћМT|ћНXећОXњћПY}ћР\ЕћС_'ћТb6ћУbHћФf ћХfgћЦkыћЧmiћШmЯћЩnVћЪnјћЫo”ћЬoрћЭoщћЮp]ћЯrаћаt%ћбtZћвtрћгv“ћдy\ће|Ъћж~ћз€сћи‚Іћй„kћк„Пћл†Nћм†_ћн‡tћо‹wћпŒjћр“Ќћс˜ћт˜eћу`бћфbћх‘wћцZZћчfћшmїћщn>ћъt?ћы›Bћь_§ћэ`кћю{ћяTФћ№_ћёl^ћђlгћѓm*ћєpићѕ}ћі†yћїŠ ћј;ћљSћњTŒћћ[ћќj:ћ§pkћўuuќЁyќЂyОќЃ‚БќЄƒяќЅŠqќІ‹AќЇŒЈќЈ—tќЉњ ќЊdєќЋe+ќЌxКќ­xЛќЎzkќЏN8ќАUšќБYPќВ[ІќГ^{ќД`ЃќЕcлќЖkaќЗfeќИhSќЙnќКqeќЛtАќМ}ќН„ќОšiќПœ%ќРm;ќСnбќТs>ќУŒAќФ•ЪќХQ№ќЦ^LќЧ_ЈќШ`MќЩ`іќЪa0ќЫaLќЬfCќЭfDќЮiЅќЯlСќаn_ќбnЩќвobќгqLќдtœќеv‡ќж{Сќз|'ќиƒRќй‡WќкQќл–ќмžУќнS/ќоVоќп^ћќр_Šќс`bќт`”ќуaїќфffќхgќцjœќчmюќшoЎќщppќъsjќы~jќьОќэƒ4ќю†дќяŠЈќ№ŒФќёRƒќђsrќѓ[–ќєjkќѕ”ќіTюќїV†ќј[]ќљeHќњe…ќћfЩќќhŸќ§mќўmЦ§Ёr;§Ђ€Д§Ѓ‘u§ЄšM§ЅOЏ§ІP§ЇSš§ЈT§ЉT<§ЊU‰§ЋUХ§Ќ^?§­_Œ§Ўg=§Џqf§Аsн§Б§ВRл§ГRѓ§ДXd§ЕXЮ§Жq§Зq§Иqћ§Й…А§КŠ§Лfˆ§М…Ј§НUЇ§Оf„§ПqJ§Р„1§СSI§ТU™§УkС§Ф_Y§Х_Н§Цcю§Чf‰§ШqG§ЩŠё§Ъ§ЫžО§ЬO§Эd:§ЮpЫ§Яuf§а†g§б`d§в‹N§гј§дQG§еQі§жS§зm6§и€ј§йžб§кf§лk#§мp˜§нuе§оT§п\y§р}§сŠ§тk §уk=§фkF§хT8§ц`p§чm=§ше§щ‚§ъPж§ыQо§ьUœ§эVk§юVЭ§яYь§№[ §ё^ §ђa™§ѓa˜§єb1§ѕf^§іfц§їq™§јqЙ§љqК§њrЇ§ћyЇ§ќz§§В§ўŠpecl-16.1.2/contrib/encodings/WINDOWS-CP950.BIN000066400000000000000000001523761266352375300202310ustar00rootroot00000000000000j~  !!""##$$%%&&''(())**++,,--..//00112233445566778899::;;<<==>>??@@AABBCCDDEEFFGGHHIIJJKKLLMMNNOOPPQQRRSSTTUUVVWWXXYYZZ[[\\]]^^__``aabbccddeeffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~Ё@0ЁAџ ЁB0ЁC0ЁDџЁE 'ЁFџЁGџЁHџЁIџЁJў0ЁK &ЁL %ЁMўPЁNўQЁOўRЁPЗЁQўTЁRўUЁSўVЁTўWЁUџ\ЁV ЁWў1ЁX ЁYў3ЁZ%tЁ[ў4Ё\ўOЁ]џЁ^џ Ё_ў5Ё`ў6Ёaџ[Ёbџ]Ёcў7Ёdў8Ёe0Ёf0Ёgў9Ёhў:Ёi0Ёj0Ёkў;Ёlў<Ёm0 Ёn0 Ёoў=Ёpў>Ёq0Ёr0 Ёsў?Ёtў@Ёu0 Ёv0 ЁwўAЁxўBЁy0Ёz0Ё{ўCЁ|ўDЁ}ўYЁ~ўZЁЁў[ЁЂў\ЁЃў]ЁЄў^ЁЅ ЁІ ЁЇ ЁЈ ЁЉ0ЁЊ0ЁЋ 5ЁЌ 2Ё­џЁЎџЁЏџ ЁА ;ЁБЇЁВ0ЁГ%ЫЁД%ЯЁЕ%ГЁЖ%ВЁЗ%ЮЁИ&ЁЙ&ЁК%ЧЁЛ%ЦЁМ%ЁЁН% ЁО%НЁП%МЁР2ЃЁС!ЁТЏЁУџуЁФџ?ЁХЭЁЦўIЁЧўJЁШўMЁЩўNЁЪўKЁЫўLЁЬў_ЁЭў`ЁЮўaЁЯџ Ёаџ ЁбзЁвїЁгБЁд"ЁеџЁжџЁзџЁи"fЁй"gЁк"`Ёл"Ём"RЁн"aЁоўbЁпўcЁрўdЁсўeЁтўfЁуџ^Ёф")Ёх"*Ёц"ЅЁч" Ёш"Ёщ"ПЁъ3вЁы3бЁь"+Ёэ".Ёю"5Ёя"4Ё№&@Ёё&BЁђ"•Ёѓ"™Ёє!‘Ёѕ!“Ёі!Ёї!’Ёј!–Ёљ!—Ёњ!™Ёћ!˜Ёќ"%Ё§"#ЁўџЂ@џ<ЂA"ЂBўhЂCџЂDџхЂE0ЂFџрЂGџсЂHџЂIџ ЂJ!ЂK! ЂLўiЂMўjЂNўkЂO3еЂP3œЂQ3ЂR3žЂS3ЮЂT3ЁЂU3ŽЂV3ЂW3ФЂXАЂYQYЂZQ[Ђ[Q^Ђ\Q]Ђ]QaЂ^QcЂ_UчЂ`tщЂa|ЮЂb%Ђc%‚Ђd%ƒЂe%„Ђf%…Ђg%†Ђh%‡Ђi%ˆЂj%Ђk%ŽЂl%Ђm%ŒЂn%‹Ђo%ŠЂp%‰Ђq%<Ђr%4Ђs%,Ђt%$Ђu%Ђv%”Ђw%Ђx%Ђy%•Ђz% Ђ{%Ђ|%Ђ}%Ђ~%mЂЁ%nЂЂ%pЂЃ%oЂЄ%PЂЅ%^ЂІ%jЂЇ%aЂЈ%тЂЉ%уЂЊ%хЂЋ%фЂЌ%qЂ­%rЂЎ%sЂЏџЂАџЂБџЂВџЂГџЂДџЂЕџЂЖџЂЗџЂИџЂЙ!`ЂК!aЂЛ!bЂМ!cЂН!dЂО!eЂП!fЂР!gЂС!hЂТ!iЂУ0!ЂФ0"ЂХ0#ЂЦ0$ЂЧ0%ЂШ0&ЂЩ0'ЂЪ0(ЂЫ0)ЂЬSAЂЭSDЂЮSEЂЯџ!Ђаџ"Ђбџ#Ђвџ$Ђгџ%Ђдџ&Ђеџ'Ђжџ(Ђзџ)Ђиџ*Ђйџ+Ђкџ,Ђлџ-Ђмџ.Ђнџ/Ђоџ0Ђпџ1Ђрџ2Ђсџ3Ђтџ4Ђуџ5Ђфџ6Ђхџ7Ђцџ8Ђчџ9Ђшџ:ЂщџAЂъџBЂыџCЂьџDЂэџEЂюџFЂяџGЂ№џHЂёџIЂђџJЂѓџKЂєџLЂѕџMЂіџNЂїџOЂјџPЂљџQЂњџRЂћџSЂќџTЂ§џUЂўџVЃ@џWЃAџXЃBџYЃCџZЃD‘ЃE’ЃF“ЃG”ЃH•ЃI–ЃJ—ЃK˜ЃL™ЃMšЃN›ЃOœЃPЃQžЃRŸЃS ЃTЁЃUЃЃVЄЃWЅЃXІЃYЇЃZЈЃ[ЉЃ\БЃ]ВЃ^ГЃ_ДЃ`ЕЃaЖЃbЗЃcИЃdЙЃeКЃfЛЃgМЃhНЃiОЃjПЃkРЃlСЃmУЃnФЃoХЃpЦЃqЧЃrШЃsЩЃt1Ѓu1Ѓv1Ѓw1Ѓx1 Ѓy1 Ѓz1 Ѓ{1 Ѓ|1 Ѓ}1Ѓ~1ЃЁ1ЃЂ1ЃЃ1ЃЄ1ЃЅ1ЃІ1ЃЇ1ЃЈ1ЃЉ1ЃЊ1ЃЋ1ЃЌ1Ѓ­1ЃЎ1ЃЏ1ЃА1ЃБ1 ЃВ1!ЃГ1"ЃД1#ЃЕ1$ЃЖ1%ЃЗ1&ЃИ1'ЃЙ1(ЃК1)ЃЛйЃМЩЃНЪЃОЧЃПЫЃс ЌЄ@NЄANYЄBNЄCNЄDNCЄEN]ЄFN†ЄGNŒЄHNКЄIQ?ЄJQeЄKQkЄLQрЄMRЄNRЄOR›ЄPSЄQSAЄRS\ЄSSШЄTN ЄUN ЄVNЄWN ЄXN+ЄYN8ЄZQсЄ[NEЄ\NHЄ]N_Є^N^Є_NŽЄ`NЁЄaQ@ЄbRЄcRњЄdSCЄeSЩЄfSуЄgWЄhXыЄiYЄjY'ЄkYsЄl[PЄm[QЄn[SЄo[јЄp\Єq\"Єr\8Єs\qЄt]нЄu]хЄv]ёЄw]ђЄx]ѓЄy]ўЄz^rЄ{^ўЄ|_ Є}_Є~bMЄЁNЄЂNЄЃN ЄЄN-ЄЅN0ЄІN9ЄЇNKЄЈ\9ЄЉNˆЄЊN‘ЄЋN•ЄЌN’Є­N”ЄЎNЂЄЏNСЄАNРЄБNУЄВNЦЄГNЧЄДNЭЄЕNЪЄЖNЫЄЗNФЄИQCЄЙQAЄКQgЄЛQmЄМQnЄНQlЄОQ—ЄПQіЄРRЄСRЄТRЄУRћЄФRўЄХRџЄЦSЄЧS9ЄШSHЄЩSGЄЪSEЄЫS^ЄЬS„ЄЭSЫЄЮSЪЄЯSЭЄаXьЄбY)ЄвY+ЄгY*ЄдY-Єе[TЄж\Єз\$Єи\:Єй\oЄк]єЄл^{Єм^џЄн_Єо_Єп_УЄрbЄсb6ЄтbKЄуbNЄфe/Єхe‡Єцe—ЄчeЄЄшeЙЄщeхЄъf№ЄыgЄьg(Єэk ЄюkbЄяkyЄ№kЫЄёkдЄђkлЄѓlЄєl4ЄѕpkЄіr*Єїr6Єјr;ЄљrGЄњrYЄћr[ЄќrЌЄ§s‹ЄўNЅ@NЅANЅBNЅCNЅDN;ЅENMЅFNOЅGNNЅHNхЅINиЅJNдЅKNеЅLNжЅMNзЅNNуЅONфЅPNйЅQNоЅRQEЅSQDЅTQ‰ЅUQŠЅVQЌЅWQљЅXQњЅYQјЅZR Ѕ[R Ѕ\RŸЅ]SЅ^SЅ_SЅ`SЅaNпЅbSJЅcSIЅdSaЅeS`ЅfSoЅgSnЅhSЛЅiSяЅjSфЅkSѓЅlSьЅmSюЅnSщЅoSшЅpSќЅqSјЅrSѕЅsSыЅtSцЅuSъЅvSђЅwSёЅxS№ЅySхЅzSэЅ{SћЅ|VлЅ}VкЅ~YЅЁY.ЅЂY1ЅЃYtЅЄYvЅЅ[UЅІ[ƒЅЇ\<ЅЈ]шЅЉ]чЅЊ]цЅЋ^ЅЌ^Ѕ­^sЅЎ^|ЅЏ_ЅА_ЅБ_ЅВ_ХЅГb ЅДbSЅЕbTЅЖbRЅЗbQЅИeЅЅЙeцЅКg.ЅЛg,ЅМg*ЅНg+ЅОg-ЅПkcЅРkЭЅСlЅТlЅУl8ЅФlAЅХl@ЅЦl>ЅЧrЏЅШs„ЅЩs‰ЅЪtмЅЫtцЅЬuЅЭuЅЮu(ЅЯu)Ѕаu0Ѕбu1Ѕвu2Ѕгu3Ѕдu‹Ѕеv}ЅжvЎЅзvПЅиvюЅйwлЅкwтЅлwѓЅмy:ЅнyОЅоztЅпzЫЅрNЅсNЅтNRЅуNSЅфNiЅхN™ЅцNЄЅчNІЅшNЅЅщNџЅъO ЅыOЅьO ЅэOЅюO ЅяOЅ№OЅёOЅђNђЅѓNіЅєNћЅѕN№ЅіNѓЅїN§ЅјOЅљO ЅњQIЅћQGЅќQFЅ§QHЅўQhІ@QqІAQІBQАІCRІDRІERІFRІGRІHRЃІISІJS!ІKS ІLSpІMSqІNT ІOTІPT ІQT ІRTІSTІTT ІUTІVTІWT ІXTІYTІZTІ[TІ\TІ]VрІ^VоІ_VнІ`W3ІaW0ІbW(ІcW-ІdW,ІeW/ІfW)ІgYІhYІiY7ІjY8ІkY„ІlYxІmYƒІnY}ІoYyІpY‚ІqYІr[WІs[XІt[‡Іu[ˆІv[…Іw[‰Іx[њІy\Іz\yІ{]оІ|^І}^vІ~^tІЁ_ІЂ_ІЃ_йІЄ_жІЅbІІb ІЇb ІЈbІЉbcІЊb[ІЋbXІЌe6І­eщІЎeшІЏeьІАeэІБfђІВfѓІГg ІДg=ІЕg4ІЖg1ІЗg5ІИk!ІЙkdІКk{ІЛlІМl]ІНlWІОlYІПl_ІРl`ІСlPІТlUІУlaІФl[ІХlMІЦlNІЧppІШr_ІЩr]ІЪv~ІЫzљІЬ|sІЭ|јІЮ6ІЯŠІаНІб€Ів€Іг€ Ід€Іе€3Іж€Із€‰Іи€‹Ій€ŒІкуІлъІмѓІнќІо‚ Іп‚Ір‚Іс‚nІт‚rІу‚~Іф†kІхˆ@ІцˆLІчˆcІш‰Іщ–!ІъN2ІыNЈІьOMІэOOІюOGІяOWІ№O^ІёO4ІђO[ІѓOUІєO0ІѕOPІіOQІїO=ІјO:ІљO8ІњOCІћOTІќO<І§OFІўOcЇ@O\ЇAO`ЇBO/ЇCONЇDO6ЇEOYЇFO]ЇGOHЇHOZЇIQLЇJQKЇKQMЇLQuЇMQЖЇNQЗЇOR%ЇPR$ЇQR)ЇRR*ЇSR(ЇTRЋЇURЉЇVRЊЇWRЌЇXS#ЇYSsЇZSuЇ[TЇ\T-Ї]TЇ^T>Ї_T&Ї`TNЇaT'ЇbTFЇcTCЇdT3ЇeTHЇfTBЇgTЇhT)ЇiTJЇjT9ЇkT;ЇlT8ЇmT.ЇnT5ЇoT6ЇpT ЇqT<ЇrT@ЇsT1ЇtT+ЇuTЇvT,ЇwVъЇxV№ЇyVфЇzVыЇ{WJЇ|WQЇ}W@Ї~WMЇЁWGЇЂWNЇЃW>ЇЄWPЇЅWOЇІW;ЇЇXяЇЈY>ЇЉYЇЊY’ЇЋYЈЇЌYžЇ­YЃЇЎY™ЇЏY–ЇАYЇБYЄЇВY“ЇГYŠЇДYЅЇЕ[]ЇЖ[\ЇЗ[ZЇИ[[ЇЙ[ŒЇК[‹ЇЛ[ЇМ\,ЇН\@ЇО\AЇП\?ЇР\>ЇС\ЇТ\‘ЇУ\”ЇФ\ŒЇХ]ыЇЦ^ ЇЧ^ЇШ^‡ЇЩ^ŠЇЪ^їЇЫ_ЇЬ_ЇЭ_dЇЮ_bЇЯ_wЇа_yЇб_иЇв_ЬЇг_зЇд_ЭЇе_ёЇж_ыЇз_јЇи_ъЇйbЇкbЇлb„Їмb—Їнb–Їоb€ЇпbvЇрb‰ЇсbmЇтbŠЇуb|Їфb~ЇхbyЇцbsЇчb’ЇшboЇщb˜ЇъbnЇыb•Їьb“Їэb‘Їюb†Їяe9Ї№e;Їёe8ЇђeёЇѓfєЇєg_ЇѕgNЇіgOЇїgPЇјgQЇљg\ЇњgVЇћg^ЇќgIЇ§gFЇўg`Ј@gSЈAgWЈBkeЈCkЯЈDlBЈEl^ЈFl™ЈGlЈHlˆЈIl‰ЈJl…ЈKl›ЈLljЈMlzЈNlЈOlpЈPlŒЈQlhЈRl–ЈSl’ЈTl}ЈUlƒЈVlrЈWl~ЈXltЈYl†ЈZlvЈ[lЈ\l”Ј]l˜Ј^l‚Ј_pvЈ`p|Јap}ЈbpxЈcrbЈdraЈer`ЈfrФЈgrТЈhs–Јiu,Јju+Јku7Јlu8Јmv‚ЈnvяЈowуЈpyСЈqyРЈryПЈszvЈt|ћЈuUЈv€–Јw€“Јx€Јy€˜Јz€›Ј{€šЈ|€ВЈ}‚oЈ~‚’ЈЁ‚‹ЈЂ‚ЈЃ‰‹ЈЄ‰вЈЅŠЈІŒ7ЈЇŒFЈЈŒUЈЉŒЈЊdЈЋpЈЌГЈ­ŽЋЈЎŽЪЈЏ›ЈААЈБТЈВЦЈГХЈДФЈЕ]сЈЖ‘ЈЗЂЈИЊЈЙІЈКЃЈЛ‘IЈМ‘ЦЈН‘ЬЈО–2ЈП–.ЈР–1ЈС–*ЈТ–,ЈУN&ЈФNVЈХNsЈЦN‹ЈЧN›ЈШNžЈЩNЋЈЪNЌЈЫOoЈЬOЈЭOЈЮOsЈЯOЈаOlЈбO›ЈвO‹ЈгO†ЈдOƒЈеOpЈжOuЈзOˆЈиOiЈйO{ЈкO–ЈлO~ЈмOЈнO‘ЈоOzЈпQTЈрQRЈсQUЈтQiЈуQwЈфQvЈхQxЈцQНЈчQ§ЈшR;ЈщR8ЈъR7ЈыR:ЈьR0ЈэR.ЈюR6ЈяRAЈ№RОЈёRЛЈђSRЈѓSTЈєSSЈѕSQЈіSfЈїSwЈјSxЈљSyЈњSжЈћSдЈќSзЈ§TsЈўTuЉ@T–ЉATxЉBT•ЉCT€ЉDT{ЉETwЉFT„ЉGT’ЉHT†ЉIT|ЉJTЉKTqЉLTvЉMTŒЉNTšЉOTbЉPThЉQT‹ЉRT}ЉSTŽЉTVњЉUWƒЉVWwЉWWjЉXWiЉYWaЉZWfЉ[WdЉ\W|Љ]YЉ^YIЉ_YGЉ`YHЉaYDЉbYTЉcYОЉdYЛЉeYдЉfYЙЉgYЎЉhYбЉiYЦЉjYаЉkYЭЉlYЫЉmYгЉnYЪЉoYЏЉpYГЉqYвЉrYХЉs[_Љt[dЉu[cЉv[—Љw[šЉx[˜Љy[œЉz[™Љ{[›Љ|\Љ}\HЉ~\EЉЁ\FЉЂ\ЗЉЃ\ЁЉЄ\ИЉЅ\ЉЉІ\ЋЉЇ\БЉЈ\ГЉЉ^ЉЊ^ЉЋ^ЉЌ^Љ­^ЉЎ^ЉЏ^xЉА^šЉБ^—ЉВ^œЉГ^•ЉД^–ЉЕ^іЉЖ_&ЉЗ_'ЉИ_)ЉЙ_€ЉК_ЉЛ_ЉМ_|ЉН_нЉО_рЉП_§ЉР_ѕЉС_џЉТ`ЉУ`ЉФ`/ЉХ`5ЉЦ`ЉЧ`*ЉШ`ЉЩ`!ЉЪ`'ЉЫ`)ЉЬ`+ЉЭ`ЉЮbЉЯbЉаb?Љбb>Љвb@ЉгbЉдbЩЉеbЬЉжbФЉзbПЉиbТЉйbЙЉкbвЉлbлЉмbЋЉнbгЉоbдЉпbЫЉрbШЉсbЈЉтbНЉуbМЉфbаЉхbйЉцbЧЉчbЭЉшbЕЉщbкЉъbБЉыbиЉьbжЉэbзЉюbЦЉяbЌЉ№bЮЉёe>ЉђeЇЉѓeМЉєeњЉѕfЉіfЉїf ЉјfЉљfЉњfЉћfЉќfЉ§fЉўf Њ@fЊAg ЊBg ЊCgmЊDg‹ЊEg•ЊFgqЊGgœЊHgsЊIgwЊJg‡ЊKgЊLg—ЊMgoЊNgpЊOgЊPg‰ЊQg~ЊRgЊSguЊTgšЊUg“ЊVg|ЊWgjЊXgrЊYk#ЊZkfЊ[kgЊ\kЊ]lЊ^lЊ_lуЊ`lшЊalѓЊblБЊclЬЊdlхЊelГЊflНЊglОЊhlМЊilтЊjlЋЊklеЊllгЊmlИЊnlФЊolЙЊplСЊqlЎЊrlзЊslХЊtlёЊulПЊvlЛЊwlсЊxlлЊylЪЊzlЌЊ{lяЊ|lмЊ}lжЊ~lрЊЁp•ЊЂpŽЊЃp’ЊЄpŠЊЅp™ЊІr,ЊЇr-ЊЈr8ЊЉrHЊЊrgЊЋriЊЌrРЊ­rЮЊЎrйЊЏrзЊАrаЊБsЉЊВsЈЊГsŸЊДsЋЊЕsЅЊЖu=ЊЗuЊИu™ЊЙušЊКv„ЊЛvТЊМvђЊНvєЊОwхЊПw§ЊРy>ЊСy@ЊТyAЊУyЩЊФyШЊХzzЊЦzyЊЧzњЊШ|ўЊЩTЊЪŒЊЫ‹ЊЬ€ЊЭ€КЊЮ€ЅЊЯ€ЂЊа€БЊб€ЁЊв€ЋЊг€ЉЊд€ДЊе€ЊЊж€ЏЊзхЊиўЊй‚ Њк‚ГЊл‚Њм‚™Њн‚­Њо‚НЊп‚ŸЊр‚ЙЊс‚БЊт‚ЌЊу‚ЅЊф‚ЏЊх‚ИЊц‚ЃЊч‚АЊш‚ОЊщ‚ЗЊъ†NЊы†qЊьRЊэˆhЊюŽЫЊяЮЊ№дЊёбЊђЕЊѓИЊєБЊѕЖЊі‘ЧЊї‘бЊј•wЊљ•€Њњ–Њћ–@Њќ–?Њ§–;Њў–DЋ@–BЋA–ЙЋB–шЋC—RЋD—^ЋENŸЋFN­ЋGNЎЋHOсЋIOЕЋJOЏЋKOПЋLOрЋMOбЋNOЯЋOOнЋPOУЋQOЖЋROиЋSOпЋTOЪЋUOзЋVOЎЋWOаЋXOФЋYOТЋZOкЋ[OЮЋ\OоЋ]OЗЋ^QWЋ_Q’Ћ`Q‘ЋaQ ЋbRNЋcRCЋdRJЋeRMЋfRLЋgRKЋhRGЋiRЧЋjRЩЋkRУЋlRСЋmS ЋnSWЋoS{ЋpSšЋqSлЋrTЌЋsTРЋtTЈЋuTЮЋvTЩЋwTИЋxTІЋyTГЋzTЧЋ{TТЋ|TНЋ}TЊЋ~TСЋЁTФЋЂTШЋЃTЏЋЄTЋЋЅTБЋІTЛЋЇTЉЋЈTЇЋЉTПЋЊVџЋЋW‚ЋЌW‹Ћ­W ЋЎWЃЋЏWЂЋАWЮЋБWЎЋВW“ЋГYUЋДYQЋЕYOЋЖYNЋЗYPЋИYмЋЙYиЋКYџЋЛYуЋМYшЋНZЋОYхЋПYъЋРYкЋСYцЋТZЋУYћЋФ[iЋХ[ЃЋЦ[ІЋЧ[ЄЋШ[ЂЋЩ[ЅЋЪ\ЋЫ\NЋЬ\OЋЭ\MЋЮ\KЋЯ\йЋа\вЋб]їЋв^Ћг^%Ћд^Ће^}Ћж^ Ћз^ІЋи^њЋй_Ћк_-Ћл_eЋм_ˆЋн_…Ћо_ŠЋп_‹Ћр_‡Ћс_ŒЋт_‰Ћу`Ћф`Ћх` Ћц`%Ћч`Ћш`(Ћщ`MЋъ`pЋы`hЋь`bЋэ`FЋю`CЋя`lЋ№`kЋё`jЋђ`dЋѓbAЋєbмЋѕcЋіc ЋїbќЋјbэЋљcЋњbюЋћb§ЋќcЋ§bёЋўbїЌ@bяЌAbьЌBbўЌCbєЌDcЌEcЌFe?ЌGeEЌHeЋЌIeНЌJeтЌKf%ЌLf-ЌMf ЌNf'ЌOf/ЌPfЌQf(ЌRf1ЌSf$ЌTfїЌUgџЌVgгЌWgёЌXgдЌYgаЌZgьЌ[gЖЌ\gЏЌ]gѕЌ^gщЌ_gяЌ`gФЌagбЌbgДЌcgкЌdgхЌegИЌfgЯЌggоЌhgѓЌigАЌjgйЌkgтЌlgнЌmgвЌnkjЌokƒЌpk†ЌqkЕЌrkвЌskзЌtlЌulЩЌvm Ќwm2Ќxm*ЌymAЌzm%Ќ{m Ќ|m1Ќ}mЌ~mЌЁm;ЌЂm=ЌЃm>ЌЄm6ЌЅmЌІlѕЌЇm9ЌЈm'ЌЉm8ЌЊm)ЌЋm.ЌЌm5Ќ­mЌЎm+ЌЏpЋЌАpКЌБpГЌВpЌЌГpЏЌДp­ЌЕpИЌЖpЎЌЗpЄЌИr0ЌЙrrЌКroЌЛrtЌМrщЌНrрЌОrсЌПsЗЌРsЪЌСsЛЌТsВЌУsЭЌФsРЌХsГЌЦuЌЧu-ЌШuOЌЩuLЌЪuNЌЫuKЌЬuЋЌЭuЄЌЮuЅЌЯuЂЌаuЃЌбvxЌвv†Ќгv‡ЌдvˆЌеvШЌжvЦЌзvУЌиvХЌйwЌкvљЌлvјЌмw Ќнw ЌоvўЌпvќЌрwЌсwмЌтxЌуxЌфx Ќхx ЌцyFЌчyIЌшyHЌщyGЌъyЙЌыyКЌьyбЌэyвЌюyЫЌяzЌ№zЌёzџЌђz§Ќѓ|}Ќє}Ќѕ}Ќі}Ќї} Ќј}Ќљ}Ќњ}Ќћ8ЌќŽЌ§ПЌў€­@€­A€ ­B€­C€6­D€ж­E€х­F€к­G€У­H€Ф­I€Ь­J€с­K€л­L€Ю­M€о­N€ф­O€н­Pє­Q‚"­R‚ч­Sƒ­Tƒ­U‚у­V‚л­W‚ц­Xƒ­Y‚х­Zƒ­[ƒ ­\‚в­]‚з­^‚ё­_ƒ­`‚м­a‚д­b‚б­c‚о­d‚г­e‚п­f‚я­gƒ­h†P­i†y­j†{­k†z­lˆM­mˆk­n‰­o‰д­pŠ­qŠ­rŠ­sŒž­tŒ ­ut­vs­wД­xŽЭ­yŽЬ­z№­{ц­|т­}ъ­~х­Ёэ­Ђы­Ѓф­Єш­ЅЪ­ІЮ­ЇС­ЈУ­Љ‘K­Њ‘J­Ћ‘Э­Ќ•‚­­–P­Ў–K­Џ–L­А–M­Б—b­В—i­Г—Ы­Д—э­Е—ѓ­Ж˜­З˜Ј­И˜л­Й˜п­К™–­Л™™­МNX­НNГ­ОP ­ПP ­РP#­СOя­ТP&­УP%­ФOј­ХP)­ЦP­ЧP­ШP<­ЩP­ЪP­ЫP­ЬP­ЭOњ­ЮP­ЯP­аP(­бOё­вP!­гP ­дP­еP­жOѓ­зOю­иP-­йP*­кOў­лP+­мP ­нQ|­оQЄ­пQЅ­рQЂ­сQЭ­тQЬ­уQЦ­фQЫ­хRV­цR\­чRT­шR[­щR]­ъS*­ыS­ьSŸ­эS­юSп­яTш­№U­ёU­ђU7­ѓTќ­єTх­ѕTђ­іU­їTњ­јU­љTщ­њTэ­ћTс­ќU ­§Tю­ўTъЎ@TцЎAU'ЎBUЎCT§ЎDUЎEWЎFWЎGWТЎHWдЎIWЫЎJWУЎKX ЎLYЎMYWЎNYXЎOYZЎPZЎQZЎRZЎSZЎTZЎUZЎVYьЎWZ ЎXZ#ЎYZ)ЎZZ%Ў[Z Ў\Z Ў][kЎ^\XЎ_[АЎ`[ГЎa[ЖЎb[ДЎc[ЎЎd[ЕЎe[ЙЎf[ИЎg\Ўh\QЎi\UЎj\PЎk\эЎl\§Ўm\ћЎn\ъЎo\шЎp\№Ўq\іЎr]Ўs\єЎt]юЎu^-Ўv^+Ўw^ЋЎx^­Ўy^ЇЎz_1Ў{_’Ў|_‘Ў}_Ў~`YЎЁ`cЎЂ`eЎЃ`PЎЄ`UЎЅ`mЎІ`iЎЇ`oЎЈ`„ЎЉ`ŸЎЊ`šЎЋ`ЎЌ`”Ў­`ŒЎЎ`…ЎЏ`–ЎАbGЎБbѓЎВcЎГbџЎДcNЎЕc>ЎЖc/ЎЗcUЎИcBЎЙcFЎКcOЎЛcIЎМc:ЎНcPЎОc=ЎПc*ЎРc+ЎСc(ЎТcMЎУcLЎФeHЎХeIЎЦe™ЎЧeСЎШeХЎЩfBЎЪfIЎЫfOЎЬfCЎЭfRЎЮfLЎЯfEЎаfAЎбfјЎвgЎгgЎдgЎеh!Ўжh8ЎзhHЎиhFЎйhSЎкh9ЎлhBЎмhTЎнh)ЎоhГЎпhЎрhLЎсhQЎтh=ЎуgєЎфhPЎхh@Ўцh<ЎчhCЎшh*ЎщhEЎъhЎыhЎьhAЎэkŠЎюk‰ЎяkЗЎ№l#Ўёl'Ўђl(Ўѓl&Ўєl$Ўѕl№ЎіmjЎїm•ЎјmˆЎљm‡ЎњmfЎћmxЎќmwЎ§mYЎўm“Џ@mlЏAm‰ЏBmnЏCmZЏDmtЏEmiЏFmŒЏGmŠЏHmyЏIm…ЏJmeЏKm”ЏLpЪЏMpиЏNpфЏOpйЏPpШЏQpЯЏRr9ЏSryЏTrќЏUrљЏVr§ЏWrјЏXrїЏYs†ЏZsэЏ[t Џ\sюЏ]sрЏ^sъЏ_sоЏ`uTЏau]Џbu\ЏcuZЏduYЏeuОЏfuХЏguЧЏhuВЏiuГЏjuНЏkuМЏluЙЏmuТЏnuИЏov‹ЏpvАЏqvЪЏrvЭЏsvЮЏtw)ЏuwЏvw Џww(ЏxwщЏyx0Џzx'Џ{x8Џ|xЏ}x4Џ~x7ЏЁx%ЏЂx-ЏЃx ЏЄxЏЅx2ЏІyUЏЇyPЏЈy`ЏЉy_ЏЊyVЏЋy^ЏЌy]Џ­yWЏЎyZЏЏyфЏАyуЏБyчЏВyпЏГyцЏДyщЏЕyиЏЖz„ЏЗzˆЏИzйЏЙ{ЏК{ЏЛ|‰ЏМ}!ЏН}ЏО} ЏП} ЏР} ЏС}"ЏТ}ЏУ}ЏФ}ЏХ}ЏЦ}ЏЧ} ЏШ}ЏЩ}ЏЪ:ЏЫ_ЏЬ”ЏЭХЏЮСЏЯ€Џа€Џб€Џв€Џг€Џд€=Џе€?Џж€ёЏзЏи€№ЏйЏк€эЏл€єЏмЏн€јЏо€ѓЏпЏр€§Џс Џт€ќЏу€яЏфэЏхьЏц‚Џч‚Џш‚*Џщ‚+Џъ‚(Џы‚,Џь‚ЛЏэƒ+ЏюƒRЏяƒTЏ№ƒJЏёƒ8ЏђƒPЏѓƒIЏєƒ5Џѕƒ4ЏіƒOЏїƒ2Џјƒ9Џљƒ6ЏњƒЏћƒ@Џќƒ1Џ§ƒ(ЏўƒCА@†TАA†ŠАB†ЊАC†“АD†ЄАE†ЉАF†ŒАG†ЃАH†œАIˆpАJˆwАKˆАLˆ‚АMˆ}АNˆyАOŠАPŠАQŠАRŠ АSŠАTŠ АUŠАVŠАWŠАXŠАYŠАZŒHА[ŒzА\ŒyА]ŒЁА^ŒЂА_wА`ŽЌАaŽвАbŽдАcŽЯАdБАeАfАgїАhАiњАjєАkАl§АmАnјАo•АpсАqнАrтАs‘RАt‘MАu‘LАv‘иАw‘нАx‘зАy‘мАz‘йА{•ƒА|–bА}–cА~–aАЁ–[АЂ–]АЃ–dАЄ–XАЅ–^АІ–ЛАЇ˜тАЈ™ЌАЉšЈАЊšиАЋ›%АЌ›2А­›<АЎN~АЏPzААP}АБP\АВPGАГPCАДPLАЕPZАЖPIАЗPeАИPvАЙPNАКPUАЛPuАМPtАНPwАОPOАПPАРPoАСPmАТQ\АУQ•АФQ№АХRjАЦRoАЧRвАШRйАЩRиАЪRеАЫSАЬSАЭSАЮS?АЯS@АаS>АбSУАвfќАгUFАдUjАеUfАжUDАзU^АиUaАйUCАкUJАлU1АмUVАнUOАоUUАпU/АрUdАсU8АтU.АуU\АфU,АхUcАцU3АчUAАшUWАщWАъW АыW АьWпАэXАюX АяXА№WрАёWфАђWњАѓXАєX5АѕWїАіWљАїY АјYbАљZ6АњZAАћZIАќZfА§ZjАўZ@Б@Z<БAZbБBZZБCZFБDZJБE[pБF[ЧБG[ХБH[ФБI[ТБJ[ПБK[ЦБL\ БM\БN\БO\`БP\\БQ\]БR]БS]БT]БU]БV]БW]"БX]БY])БZ]Б[]Б\]$Б]]'Б^]Б_]тБ`^8Бa^6Бb^3Бc^7Бd^ЗБe^ИБf^ЖБg^ЕБh^ОБi_5Бj_7Бk_WБl_lБm_iБn_kБo_—Бp_™Бq_žБr_˜Бs_ЁБt_ Бu_œБv`Бw`ЃБx`‰Бy` Бz`ЈБ{`ЫБ|`ДБ}`цБ~`НБЁ`ХБЂ`ЛБЃ`ЕБЄ`мБЅ`МБІ`иБЇ`еБЈ`ЦБЉ`пБЊ`ИБЋ`кБЌ`ЧБ­bБЎbБЏbHБАc ББcЇБВcrБГc–БДcЂБЕcЅБЖcwБЗcgБИc˜БЙcЊБКcqБЛcЉБМc‰БНcƒБОc›БПckБРcЈБСc„БТcˆБУc™БФcЁБХcЌБЦc’БЧcБШc€БЩc{БЪciБЫchБЬczБЭe]БЮeVБЯeQБаeYБбeWБвU_БгeOБдeXБеeUБжeTБзeœБиe›БйeЌБкeЯБлeЫБмeЬБнeЮБоf]БпfZБрfdБсfhБтffБуf^БфfљБхRзБцgБчhБшhЏБщhЂБъh“БыhЕБьhБэhvБюhББяhЇБ№h—БёhАБђhƒБѓhФБєh­Бѕh†Біh…Бїh”БјhБљhЈБњhŸБћhЁБќh‚Б§k2БўkКВ@kыВAkьВBl+ВCmŽВDmМВEmѓВFmйВGmВВHmсВImЬВJmфВKmћВLmњВMnВNmЧВOmЫВPmЏВQmбВRmЎВSmоВTmљВUmИВVmїВWmѕВXmХВYmвВZnВ[mЕВ\mкВ]mыВ^mиВ_mъВ`mёВamюВbmшВcmЦВdmФВemЊВfmьВgmПВhmцВipљВjq Вkq Вlp§ВmpяВnr=Вor}ВprВqsВrsВssВtsВusВvs‡ВwtВxt ВytВztВ{sўВ|t В}tрВ~tіВЁtїВЂuВЃu"ВЄueВЅufВІubВЇupВЈuВЉuдВЊuеВЋuЕВЌuЪВ­uЭВЎvŽВЏvдВАvвВБvлВВw7ВГw>ВДw<ВЕw6ВЖw8ВЗw:ВИxkВЙxCВКxNВЛyeВМyhВНymВОyћВПz’ВРz•ВС{ ВТ{(ВУ{ВФ{,ВХ{&ВЦ{ВЧ{ВШ{.ВЩ|’ВЪ|—ВЫ|•ВЬ}FВЭ}CВЮ}qВЯ}.Ва}9Вб}<Вв}@Вг}0Вд}3Ве}DВж}/Вз}BВи}2Вй}1Вк=ВлžВмšВнЬВоЮВпвВр€Вс€JВт€FВу/ВфВх#Вц+Вч)Вш0Вщ$Въ‚Вы‚5Вь‚7Вэ‚6Вю‚9ВяƒŽВ№ƒžВёƒ˜ВђƒxВѓƒЂВєƒ–ВѕƒНВіƒЋВїƒ’ВјƒŠВљƒ“Вњƒ‰Вћƒ ВќƒwВ§ƒ{Вўƒ|Г@ƒ†ГAƒЇГB†UГC_jГD†ЧГE†РГF†ЖГG†ФГH†ЕГI†ЦГJ†ЫГK†БГL†ЏГM†ЩГNˆSГOˆžГPˆˆГQˆЋГRˆ’ГSˆ–ГTˆГUˆ‹ГV‰“ГW‰ГXŠ*ГYŠГZŠ#Г[Š%Г\Š1Г]Š-Г^ŠГ_ŠГ`Š"ГaŒIГbŒZГcŒЉГdŒЌГeŒЋГfŒЈГgŒЊГhŒЇГigГjfГkОГlКГmŽлГnŽпГoГp ГqГrГs#ГtГuГvГwГxГy ГzГ{"Г|Г}Г~ГЁшГЂэГЃ§ГЄ‘WГЅ‘ЮГІ‘ѕГЇ‘цГЈ‘уГЉ‘чГЊ‘эГЋ‘щГЌ•‰Г­–jГЎ–uГЏ–sГА–xГБ–pГВ–tГГ–vГД–wГЕ–lГЖ–РГЗ–ъГИ–щГЙzрГКzпГ˘Г̘ГН›ZГОœхГПžuГРžГСžЅГТžЛГУPЂГФPГХP…ГЦP™ГЧP‘ГШP€ГЩP–ГЪP˜ГЫPšГЬgГЭQёГЮRrГЯRtГаRuГбRiГвRоГгRнГдRлГеSZГжSЅГзU{ГиU€ГйUЇГкU|ГлUŠГмUГнU˜ГоU‚ГпUœГрUЊГсU”ГтU‡ГуU‹ГфUƒГхUГГцUЎГчUŸГшU>ГщUВГъUšГыUЛГьUЌГэUБГюU~ГяU‰Г№UЋГёU™ГђW ГѓX/ГєX*ГѕX4ГіX$ГїX0ГјX1ГљX!ГњXГћX ГќXљГ§XњГўY`Д@ZwДAZšДBZДCZ’ДDZ›ДEZЇДF[sДG[qДH[вДI[ЬДJ[гДK[аДL\ ДM\ ДN\1ДO]LДP]PДQ]4ДR]GДS]§ДT^EДU^=ДV^@ДW^CДX^~ДY^ЪДZ^СД[^ТД\^ФД]_<Д^_mД__ЉД`_ЊДa_ЈДb`бДc`сДd`ВДe`ЖДf`рДgaДha#Дi`њДjaДk`№Дl`ћДm`єДnahДo`ёДpaДq`іДra ДsaДtaДubДvbIДwcЃДxcŒДycЯДzcРД{cщД|cЩД}cЦД~cЭДЁcвДЂcуДЃcаДЄcсДЅcжДІcэДЇcюДЈcvДЉcєДЊcъДЋcлДЌdRД­cкДЎcљДЏe^ДАefДБebДВecДГe‘ДДeДЕeЏДЖfnДЗfpДИftДЙfvДКfoДЛf‘ДМfzДНf~ДОfwДПfўДРfџДСgДТgДУhњДФhеДХhрДЦhиДЧhзДШiДЩhпДЪhѕДЫhюДЬhчДЭhљДЮhвДЯhђДаhуДбhЫДвhЭДгi ДдiДеiДжhЩДзhкДиinДйhћДкk>Длk:Дмk=Днk˜Доk–ДпkМДрkяДсl.Дтl/Дуl,Дфn/Дхn8ДцnTДчn!Дшn2ДщngДъnJДыn Дьn%Дэn#ДюnДяn[Д№nXДёn$ДђnVДѓnnДєn-Дѕn&ДіnoДїn4ДјnMДљn:Дњn,ДћnCДќnД§n>ДўnЫЕ@n‰ЕAnЕBnNЕCncЕDnDЕEnrЕFniЕGn_ЕHqЕIqЕJq&ЕKq0ЕLq!ЕMq6ЕNqnЕOqЕPrLЕQr„ЕRr€ЕSs6ЕTs%ЕUs4ЕVs)ЕWt:ЕXt*ЕYt3ЕZt"Е[t%Е\t5Е]t6Е^t4Е_t/Е`tЕat&Еbt(Еcu%Еdu&ЕeukЕfujЕguтЕhuлЕiuуЕjuйЕkuиЕluоЕmuрЕnv{Еov|Еpv–Еqv“ЕrvДЕsvмЕtwOЕuwэЕvx]ЕwxlЕxxoЕyz ЕzzЕ{z Е|zЕ}zЕ~z˜ЕЁz—ЕЂz–ЕЃzхЕЄzуЕЅ{IЕІ{VЕЇ{FЕЈ{PЕЉ{RЕЊ{TЕЋ{MЕЌ{KЕ­{OЕЎ{QЕЏ|ŸЕА|ЅЕБ}^ЕВ}PЕГ}hЕД}UЕЕ}+ЕЖ}nЕЗ}rЕИ}aЕЙ}fЕК}bЕЛ}pЕМ}sЕНU„ЕОдЕПеЕР€ ЕС€RЕТ€…ЕУUЕФTЕХKЕЦQЕЧNЕШ9ЕЩFЕЪ>ЕЫLЕЬSЕЭtЕЮ‚ЕЯ‚ЕаƒщЕб„ЕвƒјЕг„ ЕдƒрЕеƒХЕж„ ЕзƒСЕиƒяЕйƒёЕкƒєЕл„WЕм„ Енƒ№Ео„ ЕпƒЬЕрƒ§ЕсƒђЕтƒЪЕу„8Еф„Ех„ЕцƒмЕч„ЕшƒдЕщƒпЕъ†[Еы†пЕь†йЕэ†эЕю†дЕя†лЕ№†фЕё†аЕђ†оЕѓˆWЕєˆСЕѕˆТЕіˆБЕї‰ƒЕј‰–ЕљŠ;ЕњŠ`ЕћŠUЕќŠ^Е§Š<ЕўŠAЖ@ŠTЖAŠ[ЖBŠPЖCŠFЖDŠ4ЖEŠ:ЖFŠ6ЖGŠVЖHŒaЖIŒ‚ЖJŒЏЖKŒМЖLŒГЖMŒНЖNŒСЖOŒЛЖPŒРЖQŒДЖRŒЗЖSŒЖЖTŒПЖUŒИЖVŠЖW…ЖXЖYЮЖZнЖ[ЫЖ\кЖ]бЖ^ЬЖ_лЖ`ЦЖaŽћЖbŽјЖcŽќЖdœЖe.Жf5Жg1Жh8Жi2Жj6Жk‘ЖlѕЖm‘ ЖnўЖo‘cЖp‘eЖq‘ЯЖr’Жs’Жt’#Жu’ Жv’Жw’ Жx’Жy’Жz’Ж{•”Ж|•Ж}•‹Ж~•‘ЖЁ•“ЖЂ•’ЖЃ•ŽЖЄ–ŠЖЅ–ŽЖІ–‹ЖЇ–}ЖЈ–…ЖЉ–†ЖЊ–ЖЋ–rЖЌ–„Ж­–СЖЎ–ХЖЏ–ФЖА–ЦЖБ–ЧЖВ–яЖГ–ђЖД—ЬЖŘЖƘЖǘЖȘчЖɘъЖʘяЖ˘щЖ̘ђЖ͘эЖО™ЎЖП™­ЖРžУЖСžЭЖТžбЖУN‚ЖФP­ЖХPЕЖЦPВЖЧPГЖШPХЖЩPОЖЪPЌЖЫPЗЖЬPЛЖЭPЏЖЮPЧЖЯRЖаRwЖбR}ЖвRпЖгRцЖдRфЖеRтЖжRуЖзS/ЖиUпЖйUшЖкUгЖлUцЖмUЮЖнUмЖоUЧЖпUбЖрUуЖсUфЖтUяЖуUкЖфUсЖхUХЖцUЦЖчUхЖшUЩЖщWЖъWЖыX^ЖьXQЖэXXЖюXWЖяXZЖ№XTЖёXkЖђXLЖѓXmЖєXJЖѕXbЖіXRЖїXKЖјYgЖљZСЖњZЩЖћZЬЖќZОЖ§ZНЖўZМЗ@ZГЗAZТЗBZВЗC]iЗD]oЗE^LЗF^yЗG^ЩЗH^ШЗI_ЗJ_YЗK_ЌЗL_ЎЗMaЗNaЗOaHЗPaЗQ`ѓЗRaЗS`љЗTaЗUaЗVaNЗWaLЗXaDЗYaMЗZa>З[a4З\a'З]a З^aЗ_a7З`b!Зab"ЗbdЗcd>ЗddЗed*Зfd-Зgd=Зhd,ЗidЗjdЗkdЗld Зmd6ЗndЗodЗpdЗqelЗreŸЗseАЗtf—Зuf‰Зvf‡ЗwfˆЗxf–Зyf„Зzf˜З{fЗ|gЗ}i”З~imЗЁiZЗЂiwЗЃi`ЗЄiTЗЅiuЗІi0ЗЇi‚ЗЈiJЗЉihЗЊikЗЋi^ЗЌiSЗ­iyЗЎi†ЗЏi]ЗАicЗБi[ЗВkGЗГkrЗДkРЗЕkПЗЖkгЗЗk§ЗИnЂЗЙnЏЗКnгЗЛnЖЗМnТЗНnЗОnЗПnЧЗРnХЗСnЅЗТn˜ЗУnМЗФnКЗХnЋЗЦnбЗЧn–ЗШnœЗЩnФЗЪnдЗЫnЊЗЬnЇЗЭnДЗЮqNЗЯqYЗаqiЗбqdЗвqIЗгqgЗдq\ЗеqlЗжqfЗзqLЗиqeЗйq^ЗкqFЗлqhЗмqVЗнr:ЗоrRЗпs7ЗрsEЗсs?Зтs>ЗуtoЗфtZЗхtUЗцt_Зчt^ЗшtAЗщt?ЗъtYЗыt[Зьt\ЗэuvЗюuxЗяvЗ№u№ЗёvЗђuђЗѓuёЗєuњЗѕuџЗіuєЗїuѓЗјvоЗљvпЗњw[ЗћwkЗќwfЗ§w^ЗўwcИ@wyИAwjИBwlИCw\ИDweИEwhИFwbИGwюИHxŽИIxАИJx—ИKx˜ИLxŒИMx‰ИNx|ИOx‘ИPx“ИQxИRyzИSyИTyИU„,ИVyНИWzИXzИYz ИZzИ[zИ\zИ]zŸИ^z И_{wИ`{РИa{`Иb{nИc{gИd|БИe|ГИf|ЕИg}“Иh}yИi}‘Иj}Иk}Иl}[ИmnИniИojИprИqЉИrЈИsЄИt€VИu€XИv€†Иw€„ИxqИypИzxИ{eИ|nИ}sИ~kИЁyИЂzИЃfИЄ‚ИЅ‚GИІ„‚ИЇ„wИЈ„=ИЉ„1ИЊ„uИЋ„fИЌ„kИ­„IИЎ„lИЏ„[ИА„<ИБ„5ИВ„aИГ„cИД„iИЕ„mИЖ„FИЗ†^ИИ†\ИЙ†_ИК†љИЛ‡ИМ‡ИН‡ИО‡ИП†ўИР†ћИС‡ИТ‡ИУ‡ИФ‡ ИХˆYИЦˆпИЧˆдИШˆйИЩˆмИЪˆиИЫˆнИЬˆсИЭˆЪИЮˆеИЯˆвИа‰œИб‰уИвŠkИгŠrИдŠsИеŠfИжŠiИзŠpИиŠ‡ИйŠ|ИкŠcИлŠ ИмŠqИнŠ…ИоŠmИпŠbИрŠnИсŠlИтŠyИуŠ{ИфŠ>ИхŠhИцŒbИчŒŠИшŒ‰ИщŒЪИъŒЧИыŒШИьŒФИэŒВИюŒУИяŒТИ№ŒХИёсИђпИѓшИєяИѕѓИіњИїъИјфИљцИњŽВИћИќ И§ŽўИў Й@ŸЙAВЙBKЙCJЙDSЙEBЙFTЙG<ЙHUЙIPЙJGЙKOЙLNЙMMЙNQЙO>ЙPAЙQ‘ЙR‘ЙS‘lЙT‘jЙU‘iЙV‘ЩЙW’7ЙX’WЙY’8ЙZ’=Й[’@Й\’>Й]’[Й^’KЙ_’dЙ`’QЙa’4Йb’IЙc’MЙd’EЙe’9Йf’?Йg’ZЙh•˜Йi–˜Йj–”Йk–•Йl–ЭЙm–ЫЙn–ЩЙo–ЪЙp–їЙq–ћЙr–љЙs–іЙt—VЙu—tЙv—vЙw˜Йx˜Йy˜Йz˜ Й{˜Й|˜ Й}˜ќЙ~˜єЙЁ˜§ЙЂ˜ўЙЃ™ГЙЄ™БЙЅ™ДЙІšсЙЇœщЙЈž‚ЙЉŸЙЊŸЙЋŸ ЙЌPчЙ­PюЙЎPхЙЏPжЙАPэЙБPкЙВPеЙГPЯЙДPбЙЕPёЙЖPЮЙЗPщЙИQbЙЙQѓЙКRƒЙЛR‚ЙМS1ЙНS­ЙОUўЙПVЙРVЙСVЙТU§ЙУVЙФVЙХV ЙЦV ЙЧVЙШUїЙЩVЙЪVЙЫVЙЬVЙЭUіЙЮWЙЯWЙаXuЙбX~ЙвXƒЙгX“ЙдXŠЙеXyЙжX…ЙзX}ЙиX§ЙйY%ЙкY"ЙлY$ЙмYjЙнYiЙоZсЙпZцЙрZщЙсZзЙтZжЙуZиЙфZуЙх[uЙц[оЙч[чЙш[сЙщ[хЙъ[цЙы[шЙь[тЙэ[фЙю[пЙя\ Й№\bЙё]„Йђ]‡Йѓ^[Йє^cЙѕ^UЙі^WЙї^TЙј^гЙљ^жЙњ_ Йћ_FЙќ_pЙ§_ЙЙўaGК@a?КAaKКBawКCabКDacКEa_КFaZКGaXКHauКIb*КJd‡КKdXКLdTКMdЄКNdxКOd_КPdzКQdQКRdgКSd4КTdmКUd{КVerКWeЁКXeзКYeжКZfЂК[fЈК\fК]iœК^iЈК_i•К`iСКaiЎКbiгКciЫКdi›КeiЗКfiЛКgiЋКhiДКiiаКjiЭКki­КliЬКmiІКniУКoiЃКpkIКqkLКrl3Кso3КtoКunўКvoКwnєКxo)Кyo>Кzo К{o,К|oК}oК~o"КЁnџКЂnяКЃoКЄo1КЅo8КІo2КЇo#КЈoКЉo+КЊo/КЋoˆКЌo*К­nьКЎoКЏnђКАnЬКБnїКВq”КГq™КДq}КЕqŠКЖq„КЗq’КИr>КЙr’ККr–КЛsDКМsPКНtdКОtcКПtjКРtpКСtmКТuКУu‘КФv'КХv КЦv КЧv КШvКЩvсКЪvуКЫw„КЬw}КЭwКЮwaКЯxСКаxŸКбxЇКвxГКгxЉКдxЃКеyŽКжyКзyКиz.Кйz1КкzЊКлzЉКмzэКнzяКо{ЁКп{•Кр{‹Кс{uКт{—Ку{Кф{”Кх{Кц{ИКч{‡Кш{„Кщ|ЙКъ|НКы|ОКь}ЛКэ}АКю}œКя}НК№}ОКё} Кђ}ЪКѓ}ДКє}ВКѕ}БКі}ККї}ЂКј}ПКљ}ЕКњ}ИКћ}­Кќ}вК§}ЧКў}ЌЛ@pЛAрЛBсЛCпЛD€^ЛE€ZЛF€‡ЛGPЛH€ЛIЛJˆЛKŠЛLЛM‚ЛNчЛOњЛP‚ЛQ‚ЛR‚ЛS‚KЛT„ЩЛU„ПЛV„ЦЛW„ФЛX„™ЛY„žЛZ„ВЛ[„œЛ\„ЫЛ]„ИЛ^„РЛ_„гЛ`„Лa„МЛb„бЛc„ЪЛd‡?Лe‡Лf‡;Лg‡"Лh‡%Лi‡4Лj‡Лk‡UЛl‡7Лm‡)ЛnˆѓЛo‰ЛpˆєЛqˆљЛrˆјЛsˆ§ЛtˆшЛu‰ЛvˆяЛwŠІЛxŠŒЛyŠžЛzŠЃЛ{ŠЛ|ŠЁЛ}Š“Л~ŠЄЛЁŠЊЛЂŠЅЛЃŠЈЛЄŠ˜ЛЅŠ‘ЛІŠšЛЇŠЇЛЈŒjЛЉŒЛЊŒŒЛЋŒгЛЌŒбЛ­ŒвЛЎkЛЏ™ЛА•ЛБќЛВЛГЛДЛЕЛЖЃЛЗ`ЛИXЛЙ\ЛКcЛЛYЛМ^ЛНbЛО]ЛП[ЛР‘ЛС‘ЛТ‘ЛУ‘uЛФ‘xЛХ‘wЛЦ‘tЛЧ’xЛШ’€ЛЩ’…ЛЪ’˜ЛЫ’–ЛЬ’{ЛЭ’“ЛЮ’œЛЯ’ЈЛа’|Лб’‘Лв•ЁЛг•ЈЛд•ЉЛе•ЃЛж•ЅЛз•ЄЛи–™Лй–œЛк–›Лл–ЬЛм–вЛн—Ло—|Лп—…Лр—іЛс˜Лт˜Лу˜ЏЛф˜БЛх™Лц™Лч™ Лш™ Лщ™СЛъšЏЛыšАЛьšцЛэ›AЛю›BЛяœєЛ№œіЛёœѓЛђžМЛѓŸ;ЛєŸJЛѕQЛіQЛїPћЛјPѕЛљPљЛњQЛћQЛќQ Л§QЛўQмМ@R‡МARˆМBR‰МCRМDRŠМER№МFSВМGV.МHV;МIV9МJV2МKV?МLV4МMV)МNVSМOVNМPVWМQVtМRV6МSV/МTV0МUX€МVXŸМWXžМXXГМYXœМZXЎМ[XЉМ\XІМ]YmМ^[ М_ZћМ`[ МaZѕМb[ Мc[Мd[юМe[ьМf[щМg[ыМh\dМi\eМj]Мk]”Мl^bМm^_Мn^aМo^тМp^кМq^пМr^нМs^уМt^рМu_HМv_qМw_ЗМx_ЕМyavМzagМ{anМ|a]М}aUМ~a‚МЁa|МЂapМЃakМЄa~МЅaЇМІaМЇaЋМЈaŽМЉaЌМЊašМЋaЄМЌa”М­aЎМЎb.МЏdiМАdoМБdyМВdžМГdВМДdˆМЕdМЖdАМЗdЅМИd“МЙd•МКdЉМЛd’ММdЎМНd­МОdЋМПdšМРdЌМСd™МТdЂМУdГМФeuМХewМЦexМЧfЎМШfЋМЩfДМЪfБМЫj#МЬjМЭiшМЮjМЯjМаjМбi§Мвj!МгjМдj МеiѓМжjМзjМиiэМйjМкkPМлkNМмkЄМнkХМоkЦМпo?Мрo|Мсo„МтoQМуofМфoTМхo†МцomМчo[МшoxМщonМъoŽМыozМьopМэodМюo—МяoXМ№nеМёooМђo`Мѓo_МєqŸМѕqЌМіqБМїqЈМјrVМљr›МњsNМћsWМќtiМ§t‹МўtƒН@t~НAt€НBuНCv НDv)НEvНFv$НGv&НHv!НIv"НJvšНKvКНLvфНMwŽНNw‡НOwŒНPw‘НQw‹НRxЫНSxХНTxКНUxЪНVxОНWxеНXxМНYxаНZz?Н[z<Н\z@Н]z=Н^z7Н_z;Н`zЏНazЎНb{­Нc{БНd{ФНe{ДНf{ЦНg{ЧНh{СНi{ Нj{ЬНk|ЪНl}рНm}єНn}яНo}ћНp}иНq}ьНr}нНs}шНt}уНu}кНv}оНw}щНx}žНy}йНz}ђН{}љН|uН}wН~ЏНЁщНЂ€&НЃ›НЄœНЅНІ НЇšНЈ˜НЉ…НЊ…=НЋ…НЌ„юН­…,НЎ…-НЏ…НА…НБ…#НВ…!НГ…НД„ьНЕ…%НЖ„џНЗ…НИ‡‚НЙ‡tНК‡vНЛ‡`НМ‡fНН‡xНО‡hНП‡YНР‡WНС‡LНТ‡SНУˆ[НФˆ]НХ‰НЦ‰НЧ‰НШ‰НЩ‰НЪ‰ НЫŠМНЬŠвНЭŠЧНЮŠФНЯŠ•НаŠЫНбŠјНвŠВНгŠЩНдŠТНеŠПНжŠАНзŠжНиŠЭНйŠЖНкŠЙНлŠлНмŒLНнŒNНоŒlНпŒрНрŒоНсŒцНтŒфНуŒьНфŒэНхŒтНцŒуНчŒмНшŒъНщŒсНъmНыŸНьЃНэŽ+НюŽНяŽН№Ž"НёŽНђŽ)НѓŽНєŽ!НѕŽНіŽКНїНјНљНњ)Нћ&Нќ*Н§НўО@%ОAiОBnОChОDmОEwОF‘0ОG‘-ОH‘'ОI‘1ОJ‘‡ОK‘‰ОL‘‹ОM‘ƒОN’ХОO’ЛОP’ЗОQ’ъОR’ЌОS’фОT’СОU’ГОV’МОW’вОX’ЧОY’№ОZ’ВО[•­О\•БО]—О^—О_—О`— Оa—`Оb—Оc—‹Оd—Оe˜!Оf˜+Оg˜Оh˜ГОi™ Оj™Оk™Оl™Оm™нОn™аОo™пОp™лОq™бОr™еОs™вОt™йОušЗОvšюОwšяОx›'Оy›EОz›DО{›wО|›oО}О~ ОЁОЂžЉОЃžООЄžЮОЅXЈОІŸRОЇQОЈQОЉQОЊQОЋQОЌQ€О­QЊОЎQнОЏR‘ОАR“ОБRѓОВVYОГVkОДVyОЕViОЖVdОЗVxОИVjОЙVhОКVeОЛVqОМVoОНVlООVbОПVvОРXСОСXООТXЧОУXХОФYnОХ[ОЦ[4ОЧ[xОШ[№ОЩ\ОЪ_JОЫaВОЬa‘ОЭaЉОЮaŠОЯaЭОаaЖОбaООвaЪОгaШОдb0ОеdХОжdСОзdЫОиdЛОйdМОкdкОлdФОмdЧОнdТОоdЭОпdПОрdвОсdдОтdООуetОфfЦОхfЩОцfЙОчfФОшfЧОщfИОъj=Оыj8Оьj:ОэjYОюjkОяjXО№j9ОёjDОђjbОѓjaОєjKОѕjGОіj5Оїj_ОјjHОљkYОњkwОћlОќoТО§oБОўoЁП@oУПAoЄПBoСПCoЇПDoГПEoРПFoЙПGoЖПHoІПIo ПJoДПKqОПLqЩПMqаПNqвПOqШПPqеПQqЙПRqЮПSqйПTqмПUqУПVqФПWshПXtœПYtЃПZt˜П[tŸП\tžП]tтП^u П_u П`v4Пav8Пbv:ПcvчПdvхПew ПfwžПgwŸПhwЅПixшПjxкПkxьПlxчПmyІПnzMПozNПpzFПqzLПrzKПszКПt{йПu|Пv{ЩПw{фПx{лПy{сПz{щП{{цП||еП}|жП~~ ПЁ~ПЂ~ПЃ~ПЄ~#ПЅ~ПІ~ПЇ~ ПЈ~ПЉyПЊВПЋ№ПЌёП­юПЎ€(ПЏГПАЉПБЈПВћПГ‚ПД‚XПЕ‚YПЖ…JПЗ…YПИ…HПЙ…hПК…iПЛ…CПМ…IПН…mПО…jПП…^ПР‡ƒПС‡ŸПТ‡žПУ‡ЂПФ‡ПХˆaПЦ‰*ПЧ‰2ПШ‰%ПЩ‰+ПЪ‰!ПЫ‰ЊПЬ‰ІПЭŠцПЮŠњПЯŠыПаŠёПб‹ПвŠмПгŠчПдŠюПеŠўПж‹Пз‹ПиŠїПйŠэПкŠѓПлŠіПмŠќПнŒkПоŒmПпŒ“ПрŒєПсŽDПтŽ1ПуŽ4ПфŽBПхŽ9ПцŽ5Пч;Пш/Пщ8Пъ3ПыЈПьІПэuПюtПяxП№rПё|ПђzПѓ‘4Пє‘’Пѕ“ Пі“6Пї’јПј“3Пљ“/Пњ“"Пћ’ќПќ“+П§“Пў“Р@“РA“&РB“!РC“РD“.РE“РF•ЛРG–ЇРH–ЈРI–ЊРJ–еРK—РL—РM—РN— РO—РP—РQ—[РR—\РS—fРT—˜РU˜0РV˜8РW˜;РX˜7РY˜-РZ˜9Р[˜$Р\™Р]™(Р^™Р_™Р`™!Рa™Рb™эРc™тРd™ёРešИРfšМРgšћРhšэРi›(Рj›‘РkРl#Рm&Рn(РoРpРqžиРržдРsŸРtŸœРuQ*РvQРwQ!РxQ2РyRѕРzVŽР{V€Р|VР}V…Р~V‡РЁVРЂXеРЃXгРЄXбРЅXЮРІ[0РЇ[*РЈ[$РЉ[zРЊ\7РЋ\hРЌ]МР­]КРЎ]НРЏ]ИРА^kРБ_LРВ_НРГaЩРДaТРЕaЧРЖaцРЗaЫРИb2РЙb4РКdЮРЛdЪРМdиРНdрРОd№РПdцРРdьРСdёРТdтРУdэРФe‚РХeƒРЦfйРЧfжРШj€РЩj”РЪj„РЫjЂРЬjœРЭjлРЮjЃРЯj~Раj—РбjРвj Ргk\РдkЎРеkкРжlРзoиРиoёРйoпРкoрРлoлРмoфРнoыРоoяРпo€РрoьРсoсРтoщРуoеРфoюРхo№РцqчРчqпРшqюРщqцРъqхРыqэРьqьРэqєРюqрРяr5Р№rFРёspРђsrРѓtЉРєtАРѕtІРіtЈРїvFРјvBРљvLРњvъРћwГРќwЊР§wАРўwЌС@wЇСAw­СBwяСCxїСDxњСExєСFxяСGyСHyЇСIyЊСJzWСKzПСL|СM| СN{ўСO{їСP| СQ{рСR|рСS|мСT|оСU|тСV|пСW|йСX|нСY~.СZ~>С[~FС\~7С]~2С^~CС_~+С`~=Сa~1Сb~EСc~AСd~4Сe~9Сf~HСg~5Сh~?Сi~/СjDСkѓСlќСm€qСn€rСo€pСp€oСq€sСrЦСsУСtКСuТСvРСwПСxНСyЩСzОС{шС|‚ С}‚qС~…ЊСЁ…„СЂ…~СЃ…œСЄ…‘СЅ…”СІ…ЏСЇ…›СЈ…‡СЉ…ЈСЊ…ŠСЋ†gСЌ‡РС­‡бСЎ‡ГСЏ‡вСА‡ЦСБ‡ЋСВ‡ЛСГ‡КСД‡ШСЕ‡ЫСЖ‰;СЗ‰6СИ‰DСЙ‰8СК‰=СЛ‰ЌСМ‹СН‹СО‹СП‹СР‹ СС‹ СТ‹СУ‹СФ‹СХŒAСЦŒ?СЧŒsСШŒњСЩŒ§СЪŒќСЫŒјСЬŒћСЭЈСЮŽIСЯŽKСаŽHСбŽJСвDСг>СдBСеEСж?СзСи}Сй„СкСл‚См€Сн‘9Со‘ЃСп‘žСр‘œСс“MСт“‚Су“(Сф“uСх“JСц“eСч“KСш“Сщ“~Съ“lСы“[Сь“pСэ“ZСю“TСя•ЪС№•ЫСё•ЬСђ•ШСѓ•ЦСє–БСѕ–ИСі–жСї—Сј—Сљ— Сњ—гСћ˜FСќ˜ЖС§™5СўšТ@™џТA›ЎТB›ЋТC›ЊТD›­ТE;ТF?ТGž‹ТHžЯТIžоТJžмТKžнТLžлТMŸ>ТNŸKТOSтТPV•ТQVЎТRXйТSXиТT[8ТU_]ТVaуТWb3ТXdєТYdђТZdўТ[eТ\dњТ]dћТ^dїТ_eЗТ`fмТag&ТbjГТcjЌТdjУТejЛТfjИТgjТТhjЎТijЏТjk_ТkkxТlkЏТmp Тnp ТooўТppТqoњТrpТspТtqћТuqќТvqўТwqјТxswТysuТztЇТ{tПТ|uТ}vVТ~vXТЁvRТЂwНТЃwПТЄwЛТЅwМТІyТЇyЎТЈzaТЉzbТЊz`ТЋzФТЌzХТ­|+ТЎ|'ТЏ|*ТА|ТБ|#ТВ|!ТГ|чТД~TТЕ~UТЖ~^ТЗ~ZТИ~aТЙ~RТК~YТЛHТМљТНћТО€wТП€vТРЭТСЯТТ‚ ТУ…ЯТФ…ЉТХ…ЭТЦ…аТЧ…ЩТШ…АТЩ…КТЪ…ЙТЫ…ІТЬ‡яТЭ‡ьТЮ‡ђТЯ‡рТа‰†Тб‰ВТв‰єТг‹(Тд‹9Те‹,Тж‹+ТзŒPТиТйŽYТкŽcТлŽfТмŽdТнŽ_ТоŽUТпŽРТрIТсMТт‡ТуƒТфˆТх‘ЋТц‘ЌТч‘аТш“”Тщ“ŠТъ“–Ты“ЂТь“ГТэ“ЎТю“ЌТя“АТ№“˜Тё“šТђ“—Тѓ•дТє•жТѕ•аТі•еТї–тТј–мТљ–йТњ–лТћ–оТќ—$Т§—ЃТў—ІУ@—­УA—љУB˜MУC˜OУD˜LУE˜NУF˜SУG˜КУH™>УI™?УJ™=УK™.УL™ЅУMšУNšСУO›УP›УQ›OУR›NУS›MУT›ЪУU›ЩУV›§УW›ШУX›РУYQУZ]У[`У\žрУ]ŸУ^Ÿ,У_Q3У`VЅУaXоУbXпУcXтУd[ѕУeŸУf^ьУgaђУhaїУiaіУjaѕУkeУleУmfрУnfнУojхУpjнУqjкУrjгУspУtpУup(УvpУwpУxpУypУzrУ{r У|rXУ}rЂУ~sxУЁszУЂtНУЃtЪУЄtуУЅu‡УІu†УЇv_УЈvaУЉwЧУЊyУЋyБУЌzkУ­ziУЎ|>УЏ|?УА|8УБ|=УВ|7УГ|@УД~kУЕ~mУЖ~yУЗ~iУИ~jУЙ…УК~sУЛЖУМЙУНИУОиУП…щУР…нУС…ъУТ…еУУ…фУФ…хУХ…їУЦ‡ћУЧˆУШˆ УЩ‡љУЪ‡ўУЫ‰`УЬ‰_УЭ‰VУЮ‰^УЯ‹AУа‹\Уб‹XУв‹IУг‹ZУд‹NУе‹OУж‹FУз‹YУиУй УкŽ|УлŽrУмŽ‡УнŽvУоŽlУпŽzУрŽtУсTУтNУу­УфŠУх‹Уц‘БУч‘ЎУш“сУщ“бУъ“пУы“УУь“ШУэ“мУю“нУя“жУ№“тУё“ЭУђ“иУѓ“фУє“зУѕ“шУі•мУї–ДУј–уУљ—*Уњ—'Ућ—aУќ—мУ§—ћУў˜^Ф@˜XФA˜[ФB˜МФC™EФD™IФEšФFšФG› ФH›шФI›чФJ›жФK›лФL‰ФMaФNrФOjФPlФQž’ФRž—ФSž“ФTžДФURјФVVЈФWVЗФXVЖФYVДФZVМФ[XфФ\[@Ф][CФ^[}Ф_[іФ`]ЩФaaјФbaњФceФdeФeeФffцФgg'ФhjьФip>Фjp0Фkp2ФlrФms{ФntЯФovbФpveФqy&Фry*Фsy,Фty+ФuzЧФvzіФw|LФx|CФy|MФz|яФ{|№Ф|ЎФ}~}Ф~~|ФЁ~‚ФЂLФЃ€ФЄкФЅ‚fФІ…ћФЇ…љФЈ†ФЉ…њФЊ†ФЋ† ФЌ†Ф­† ФЎˆФЏˆФА‰dФБ‰КФВ‰јФГ‹pФД‹lФЕ‹fФЖ‹oФЗ‹_ФИ‹kФЙФК ФЛŽ‰ФМŽФНŽ…ФОŽ‚ФП‘ДФР‘ЫФС”ФТ”ФУ“§ФФ•сФХ—0Ф֘ФФЧ™RФШ™QФЩ™ЈФЪš+ФЫš0ФЬš7ФЭš5ФЮœФЯœ ФаžyФбžЕФвžшФгŸ/ФдŸ_ФеŸcФжŸaФзQ7ФиQ8ФйVСФкVРФлVТФмYФн\lФо]ЭФпaќФрaўФсeФтeФуe•ФфfщФхjћФцkФчjњФшkВФщpLФъrФыrЇФьtжФэtдФюviФяwгФ№|PФё~Фђ~ŒФѓМФє†Фѕ†-Фі†Фїˆ#Фјˆ"Фљˆ!ФњˆФћ‰jФќ‰lФ§‰НФў‹tХ@‹wХA‹}ХBХCŽŠХDŽХEŽ‹ХF_ХGЏХH‘КХI”.ХJ”3ХK”5ХL”:ХM”8ХN”2ХO”+ХP•тХQ—8ХR—9ХS—2ХT—џХU˜gХV˜eХW™WХXšEХYšCХZš@Х[š>Х\šЯХ]›TХ^›QХ_œ-Х`œ%ХaЏХbДХcТХdИХežХfžяХgŸХhŸ\ХiŸfХjŸgХkQ<ХlQ;ХmVШХnVЪХoVЩХp[Хq]дХr]вХs_NХtaџХue$Хvk ХwkaХxpQХypXХzs€Х{tфХ|uŠХ}vnХ~vlХЁyГХЂ|`ХЃ|_ХЄ€~ХЅ€}ХІпХЇ‰rХЈ‰oХЉ‰ќХЊ‹€ХЋХЌХ­Ž‘ХЎŽ“ХЏaХА‘HХБ”DХВ”QХГ”RХД—=ХЕ—>ХЖ—УХЗ—СХȘkХЙ™UХКšUХЛšMХМšвХН›ХОœIХПœ1ХРœ>ХСœ;ХТгХУзХФŸ4ХХŸlХЦŸjХЧŸ”ХШVЬХЩ]жХЪbХЫe#ХЬe+ХЭe*ХЮfьХЯkХаtкХбzЪХв|dХг|cХд|eХе~“Хж~–Хз~”ХитХй†8Хк†?Хлˆ1Хм‹ŠХнХоХп”cХр”`Хс”dХт—hХу˜oХф™\ХхšZХцš[ХчšWХшšгХщšдХъšбХыœTХьœWХэœVХюхХяžŸХ№žєХёVбХђXщХѓe,Хєp^ХѕvqХіvrХїwзХјPХљˆХњˆ6Хћˆ9ХќˆbХ§‹“Хў‹’Ц@‹–ЦA‚wЦBЦC‘РЦD”jЦE—BЦF—HЦG—DЦH—ЦЦI˜pЦJš_ЦK›"ЦL›XЦMœ_ЦNљЦOњЦPž|ЦQž}ЦRŸЦSŸwЦTŸrЦU^ѓЦVkЦWpcЦX|lЦY|nЦZˆ;Ц[‰РЦ\ŽЁЦ]‘СЦ^”rЦ_”pЦ`˜qЦa™^ЦbšжЦc›#ЦdžЬЦepdЦfwкЦg‹šЦh”wЦi—ЩЦjšbЦkšeЦl~œЦm‹œЦnŽЊЦo‘ХЦp”}Цq”~Цr”|ЦsœwЦtœxЦužїЦvŒTЦw”ЦxžЦyr(ЦzšjЦ{›1Ц|žЦ}žЦ~|rЩ@NBЩAN\ЩBQѕЩCSЩDS‚ЩENЩFN ЩGNGЩHNЩIVзЩJњ ЩK\nЩL_sЩMNЩNQ‡ЩONЩPN.ЩQN“ЩRNТЩSNЩЩTNШЩUQ˜ЩVRќЩWSlЩXSЙЩYW ЩZYЩ[Y,Щ\\Щ]]џЩ^eсЩ_kГЩ`kЬЩalЩbr?ЩcN1ЩdN<ЩeNшЩfNмЩgNщЩhNсЩiNнЩjNкЩkR ЩlSЩmSLЩnW"ЩoW#ЩpYЩqY/Щr[Щs[„Щt\Щu\;Щv\tЩw\sЩx^Щy^€Щz^‚Щ{_ЩЩ|b Щ}bPЩ~lЩЁl6ЩЂlCЩЃl?ЩЄl;ЩЅrЎЩІrАЩЇsŠЩЈyИЩЉ€ŠЩЊ–ЩЋOЩЌOЩ­O,ЩЎNѕЩЏOЩАNёЩБOЩВNїЩГOЩДOЩЕOЩЖOЩЗO"ЩИOЩЙOЩКNєЩЛOЩМQБЩНRЩОR ЩПRЩРRІЩСS"ЩТSЩУSMЩФSŠЩХTЩЦVсЩЧVпЩШW.ЩЩW*ЩЪW4ЩЫY<ЩЬY€ЩЭY|ЩЮY…ЩЯY{ЩаY~ЩбYwЩвYЩг[VЩд\Ще\%Щж\|Щз\zЩи\{Щй\~Щк]пЩл^uЩм^„Щн_Що_Щп_tЩр_еЩс_дЩт_ЯЩуb\Щфb^ЩхbdЩцbaЩчbfЩшbbЩщbYЩъb`ЩыbZЩьbeЩэeяЩюeюЩяg>Щ№g9Щёg8Щђg;Щѓg:Щєg?Щѕg<Щіg3ЩїlЩјlFЩљlRЩњl\ЩћlOЩќlJЩ§lTЩўlKЪ@lLЪApqЪBr^ЪCrДЪDrЕЪEsŽЪFu*ЪGvЪHzuЪIQЪJ‚xЪK‚|ЪL‚€ЪM‚}ЪN‚ЪO†MЪP‰~ЪQ™ЪR—ЪS˜ЪT›ЪU”ЪV–"ЪW–$ЪX– ЪY–#ЪZOVЪ[O;Ъ\ObЪ]OIЪ^OSЪ_OdЪ`O>ЪaOgЪbORЪcO_ЪdOAЪeOXЪfO-ЪgO3ЪhO?ЪiOaЪjQЪkQЙЪlRЪmRЪnR!ЪoR­ЪpRЎЪqS ЪrScЪsSrЪtSŽЪuSЪvT0ЪwT7ЪxT*ЪyTTЪzTEЪ{TЪ|TЪ}T%Ъ~TЪЁT=ЪЂTOЪЃTAЪЄT(ЪЅT$ЪІTGЪЇVюЪЈVчЪЉVхЪЊWAЪЋWEЪЌWLЪ­WIЪЎWKЪЏWRЪАYЪБY@ЪВYІЪГY˜ЪДY ЪЕY—ЪЖYŽЪЗYЂЪИYЪЙYЪКYЇЪЛYЁЪМ[ŽЪН[’ЪО\(ЪП\*ЪР\ЪС\ЪТ\ˆЪУ\‹ЪФ\‰ЪХ\’ЪЦ\ŠЪЧ\†ЪШ\“ЪЩ\•ЪЪ]рЪЫ^ ЪЬ^ЪЭ^‹ЪЮ^‰ЪЯ^ŒЪа^ˆЪб^Ъв_Ъг_Ъд_xЪе_vЪж_вЪз_бЪи_аЪй_эЪк_шЪл_юЪм_ѓЪн_сЪо_фЪп_уЪр_њЪс_яЪт_їЪу_ћЪф`Ъх_єЪцb:ЪчbƒЪшbŒЪщbŽЪъbЪыb”Ъьb‡ЪэbqЪюb{ЪяbzЪ№bpЪёbЪђbˆЪѓbwЪєb}ЪѕbrЪіbtЪїe7Ъјe№ЪљeєЪњeѓЪћeђЪќeѕЪ§gEЪўgGЫ@gYЫAgUЫBgLЫCgHЫDg]ЫEgMЫFgZЫGgKЫHkаЫIlЫJlЫKlxЫLlgЫMlkЫNl„ЫOl‹ЫPlЫQlqЫRloЫSliЫTlšЫUlmЫVl‡ЫWl•ЫXlœЫYlfЫZlsЫ[leЫ\l{Ы]lŽЫ^ptЫ_pzЫ`rcЫarПЫbrНЫcrУЫdrЦЫerСЫfrКЫgrХЫhs•Ыis—Ыjs“Ыks”Ыls’Ыmu:Ыnu9Ыou”Ыpu•ЫqvЫry=Ыs€4Ыt€•Ыu€™Ыv€Ыw€’Ыx€œЫy‚Ыz‚Ы{‚…Ы|‚ŽЫ}‚‘Ы~‚“ЫЁ‚ŠЫЂ‚ƒЫЃ‚„ЫЄŒxЫЅЩЫІПЫЇŸЫЈЁЫЉЅЫЊžЫЋЇЫЌ Ы­–0ЫЎ–(ЫЏ–/ЫА–-ЫБN3ЫВO˜ЫГO|ЫДO…ЫЕO}ЫЖO€ЫЗO‡ЫИOvЫЙOtЫКO‰ЫЛO„ЫМOwЫНOLЫОO—ЫПOjЫРOšЫСOyЫТOЫУOxЫФOЫХOœЫЦO”ЫЧOžЫШO’ЫЩO‚ЫЪO•ЫЫOkЫЬOnЫЭQžЫЮQМЫЯQОЫаR5ЫбR2ЫвR3ЫгRFЫдR1ЫеRМЫжS ЫзS ЫиS<ЫйS’ЫкS”ЫлT‡ЫмTЫнTЫоT‘ЫпT‚ЫрTˆЫсTkЫтTzЫуT~ЫфTeЫхTlЫцTtЫчTfЫшTЫщToЫъTaЫыT`ЫьT˜ЫэTcЫюTgЫяTdЫ№VїЫёVљЫђWoЫѓWrЫєWmЫѕWkЫіWqЫїWpЫјWvЫљW€ЫњWuЫћW{ЫќWsЫ§WtЫўWbЬ@WhЬAW}ЬBY ЬCYEЬDYЕЬEYКЬFYЯЬGYЮЬHYВЬIYЬЬJYСЬKYЖЬLYМЬMYУЬNYжЬOYБЬPYНЬQYРЬRYШЬSYДЬTYЧЬU[bЬV[eЬW[“ЬX[•ЬY\DЬZ\GЬ[\ЎЬ\\ЄЬ]\ Ь^\ЕЬ_\ЏЬ`\ЈЬa\ЌЬb\ŸЬc\ЃЬd\­Ьe\ЂЬf\ЊЬg\ЇЬh\Ьi\ЅЬj\ЖЬk\АЬl\ІЬm^Ьn^Ьo^Ьp_(Ьq_"Ьr_#Ьs_$Ьt_TЬu_‚Ьv_~Ьw_}Ьx_оЬy_хЬz`-Ь{`&Ь|`Ь}`2Ь~` ЬЁ`4ЬЂ` ЬЃ`ЬЄ`3ЬЅ`ЬІ`ЬЇ`,ЬЈ`"ЬЉ` ЬЊ`ЬЋ`.ЬЌ`Ь­`ЬЎ` ЬЏ` ЬА`ЬБbЬВb=ЬГb­ЬДbДЬЕbбЬЖbОЬЗbЊЬИbЖЬЙbЪЬКbЎЬЛbГЬМbЏЬНbЛЬОbЉЬПbАЬРbИЬСe=ЬТeЈЬУeЛЬФf ЬХeќЬЦfЬЧfЬШfЬЩeћЬЪfЬЫf ЬЬf ЬЭfЬЮe§ЬЯfЬаfЬбfіЬвg Ьгg…ЬдglЬеgŽЬжg’ЬзgvЬиg{Ьйg˜Ькg†Ьлg„ЬмgtЬнgЬоgŒЬпgzЬрgŸЬсg‘Ьтg™ЬуgƒЬфg}ЬхgЬцgxЬчgyЬшg”Ьщk%Ьъk€Ьыk~ЬьkоЬэlЬюl“ЬяlьЬ№lыЬёlюЬђlйЬѓlЖЬєlдЬѕl­ЬіlчЬїlЗЬјlаЬљlТЬњlКЬћlУЬќlЦЬ§lэЬўlђЭ@lвЭAlнЭBlДЭClŠЭDlЭEl€ЭFlоЭGlРЭHm0ЭIlЭЭJlЧЭKlАЭLlљЭMlЯЭNlщЭOlбЭPp”ЭQp˜ЭRp…ЭSp“ЭTp†ЭUp„ЭVp‘ЭWp–ЭXp‚ЭYpšЭZpƒЭ[rjЭ\rжЭ]rЫЭ^rиЭ_rЩЭ`rмЭarвЭbrдЭcrкЭdrЬЭerбЭfsЄЭgsЁЭhs­ЭisІЭjsЂЭks ЭlsЌЭmsЭntнЭotшЭpu?Эqu@Эru>ЭsuŒЭtu˜ЭuvЏЭvvѓЭwvёЭxv№ЭyvѕЭzwјЭ{wќЭ|wљЭ}wћЭ~wњЭЁwїЭЂyBЭЃy?ЭЄyХЭЅzxЭІz{ЭЇzћЭЈ|uЭЉ|§ЭЊ€5ЭЋ€ЭЌ€ЎЭ­€ЃЭЎ€ИЭЏ€ЕЭА€­ЭБ‚ ЭВ‚ ЭГ‚РЭД‚ЋЭЕ‚šЭЖ‚˜ЭЗ‚›ЭИ‚ЕЭЙ‚ЇЭК‚ЎЭЛ‚МЭМ‚žЭН‚КЭО‚ДЭП‚ЈЭР‚ЁЭС‚ЉЭТ‚ТЭУ‚ЄЭФ‚УЭХ‚ЖЭЦ‚ЂЭЧ†pЭШ†oЭЩ†mЭЪ†nЭЫŒVЭЬвЭЭЫЭЮгЭЯЭЭажЭбеЭвзЭгВЭдДЭеЏЭжГЭзАЭи–9Эй–=Эк–<Эл–:Эм–CЭнOЭЭоOХЭпOгЭрOВЭсOЩЭтOЫЭуOСЭфOдЭхOмЭцOйЭчOЛЭшOГЭщOлЭъOЧЭыOжЭьOКЭэOРЭюOЙЭяOьЭ№RDЭёRIЭђRРЭѓRТЭєS=ЭѕS|ЭіS—ЭїS–ЭјS™ЭљS˜ЭњTКЭћTЁЭќT­Э§TЅЭўTЯЮ@TУЮAƒ ЮBTЗЮCTЎЮDTжЮETЖЮFTХЮGTЦЮHT ЮITpЮJTМЮKTЂЮLTОЮMTrЮNTоЮOTАЮPWЕЮQWžЮRWŸЮSWЄЮTWŒЮUW—ЮVWЮWW›ЮXW”ЮYW˜ЮZWЮ[W™Ю\WЅЮ]WšЮ^W•Ю_XєЮ`Y ЮaYSЮbYсЮcYоЮdYюЮeZЮfYёЮgYнЮhYњЮiY§ЮjYќЮkYіЮlYфЮmYђЮnYїЮoYлЮpYщЮqYѓЮrYѕЮsYрЮtYўЮuYєЮvYэЮw[ЈЮx\LЮy\аЮz\иЮ{\ЬЮ|\зЮ}\ЫЮ~\лЮЁ\оЮЂ\кЮЃ\ЩЮЄ\ЧЮЅ\ЪЮІ\жЮЇ\гЮЈ\дЮЉ\ЯЮЊ\ШЮЋ\ЦЮЌ\ЮЮ­\пЮЎ\јЮЏ]љЮА^!ЮБ^"ЮВ^#ЮГ^ ЮД^$ЮЕ^АЮЖ^ЄЮЗ^ЂЮИ^›ЮЙ^ЃЮК^ЅЮЛ_ЮМ_.ЮН_VЮО_†ЮП`7ЮР`9ЮС`TЮТ`rЮУ`^ЮФ`EЮХ`SЮЦ`GЮЧ`IЮШ`[ЮЩ`LЮЪ`@ЮЫ`BЮЬ`_ЮЭ`$ЮЮ`DЮЯ`XЮа`fЮб`nЮвbBЮгbCЮдbЯЮеc Южc ЮзbѕЮиcЮйcЮкbыЮлbљЮмcЮнc ЮоbјЮпbіЮрcЮсcЮтcЮуbњЮфcЮхbћЮцb№ЮчeAЮшeCЮщeЊЮъeПЮыf6Юьf!Юэf2Ююf5ЮяfЮ№f&Юёf"Юђf3Юѓf+Юєf:ЮѕfЮіf4Юїf9Юјf.ЮљgЮњgЮћgСЮќgђЮ§gШЮўgКЯ@gмЯAgЛЯBgјЯCgиЯDgРЯEgЗЯFgХЯGgыЯHgфЯIgпЯJgЕЯKgЭЯLgГЯMgїЯNgіЯOgюЯPgуЯQgТЯRgЙЯSgЮЯTgчЯUg№ЯVgВЯWgќЯXgЦЯYgэЯZgЬЯ[gЎЯ\gцЯ]gлЯ^gњЯ_gЩЯ`gЪЯagУЯbgъЯcgЫЯdk(Яek‚Яfk„ЯgkЖЯhkжЯikиЯjkрЯkl Яll!Яmm(Яnm4Яom-ЯpmЯqm<Яrm?ЯsmЯtm ЯulкЯvm3ЯwmЯxmЯym:ЯzmЯ{mЯ|mЯ}mЯ~mBЯЁmЯЂmЯЃm7ЯЄmЯЅmЯІm@ЯЇmЯЈm ЯЉm,ЯЊmЯЋm"ЯЌm Я­mЯЎpЗЯЏpŸЯАpОЯБpБЯВpАЯГpЁЯДpДЯЕpЕЯЖpЉЯЗrAЯИrIЯЙrJЯКrlЯЛrpЯМrsЯНrnЯОrЪЯПrфЯРrшЯСrыЯТrпЯУrъЯФrцЯХrуЯЦs…ЯЧsЬЯШsТЯЩsШЯЪsХЯЫsЙЯЬsЖЯЭsЕЯЮsДЯЯsыЯаsПЯбsЧЯвsОЯгsУЯдsЦЯеsИЯжsЫЯзtьЯиtюЯйu.ЯкuGЯлuHЯмuЇЯнuЊЯоvyЯпvФЯрwЯсwЯтwЯуwЯфw ЯхvїЯцvћЯчvњЯшwчЯщwшЯъxЯыxЯьxЯэxЯюxЯяxЯ№xЯёx ЯђxЯѓxЯєyJЯѕyLЯіyKЯїyEЯјyDЯљyеЯњyЭЯћyЯЯќyжЯ§yЮЯўz€а@z~аAzбаB{аC{аD|zаE|xаF|yаG|аH|€аI|аJ}аK}аL}аMXаN‘аOаPОаQ€аR€аS€аT€аU€7аV€иаW€ЧаX€раY€баZ€Ша[€Та\€аа]€Ха^€уа_€йа`€маa€Ъаb€еаc€Щаd€Яаe€заf€цаg€Эаhџаi‚!аj‚”аk‚йаl‚ўаm‚љаnƒаo‚шаpƒаq‚еаrƒ:аs‚ыаt‚жаu‚єаv‚ьаw‚саx‚ђаy‚ѕаzƒ а{‚ћа|‚іа}‚№а~‚ъаЁ‚фаЂ‚раЃ‚њаЄ‚ѓаЅ‚эаІ†wаЇ†tаЈ†|аЉ†sаЊˆAаЋˆNаЌˆgа­ˆjаЎˆiаЏ‰гаАŠаБŠаВrаГуаДсаЕюаЖраЗёаИНаЙПаКеаЛХаМОаНЧаОЫаПШаР‘даС‘гаТ–TаУ–OаФ–QаХ–SаЦ–JаЧ–NаШPаЩPаЪPаЫPаЬP"аЭP0аЮPаЯOѕааOєабP3авP7агP,адOіаеOїажPазPаиP айP'акP5алP/амP1анPаоQZапQ”арQ“асQЪатQФауQХафQШахQЮацRaачRZашRRащR^аъR_аыRUаьRbаэRЭаюSаяSžа№U&аёTтађUаѓUаєTчаѕTѓаіTфаїUајTџаљUањUаћTыаќUа§UаўTёб@U бATћбBTїбCTјбDTрбEUбFUбGU бHWбIWбJWЬбKX2бLWебMWвбNWКбOWЦбPWНбQWМбRWИбSWЖбTWПбUWЧбVWабWWЙбXWСбYYбZYJб[Zб\Zб]Z-б^Z.б_Zб`ZбaZбbZ бcZбdZ3бe[lбf[Їбg[­бh[Ќбi\бj\Vбk\Tбl\ьбm\џбn\юбo\ёбp\їбq]бr\љбs^)бt^(бu^Јбv^Ўбw^Њбx^Ќбy_3бz_0б{_gб|`]б}`Zб~`gбЁ`AбЂ`ЂбЃ`ˆбЄ`€бЅ`’бІ`бЇ`бЈ`ƒбЉ`•бЊ`›бЋ`—бЌ`‡б­`œбЎ`ŽбЏbбАbFбБbђбВcбГcVбДc,бЕcDбЖcEбЗc6бИcCбЙcфбКc9бЛcKбМcJбНc<бОc)бПcAбРc4бСcXбТcTбУcYбФc-бХcGбЦc3бЧcZбШcQбЩc8бЪcWбЫc@бЬcHбЭeJбЮeFбЯeЦбаeУббeФбвeТбгfJбдf_беfGбжfQбзgбиgбйhбкhблhIбмh2бнh3боh;бпhKбрhOбсhбтh1буhбфh5бхh+бцh-бчh/бшhNбщhDбъh4быhбьhбэhбюh&бяh(б№h.бёhMбђh:бѓh%бєh бѕk,біk/бїk-бјk1бљk4бњkmбћ€‚бќkˆб§kцбўkфв@kшвAkувBkтвCkчвDl%вEmzвFmcвGmdвHmvвIm вJmaвKm’вLmXвMmbвNmmвOmoвPm‘вQmвRmявSmвTm†вUm^вVmgвWm`вXm—вYmpвZm|в[m_в\m‚в]m˜в^m/в_mhв`m‹вam~вbm€вcm„вdmвemƒвfm{вgm}вhmuвimвjpмвkpгвlpбвmpнвnpЫвo9вppтвqpзвrpввspовtpрвupдвvpЭвwpХвxpЦвypЧвzpкв{pЮв|pсв}rBв~rxвЁrwвЂrvвЃsвЄrњвЅrєвІrўвЇrівЈrѓвЉrћвЊsвЋsгвЌsйв­sхвЎsжвЏsМвАsчвБsувВsщвГsмвДsввЕsлвЖsдвЗsнвИsквЙsзвКsивЛsшвМtовНtпвОtєвПtѕвРu!вСu[вТu_вУuАвФuСвХuЛвЦuФвЧuРвШuПвЩuЖвЪuКвЫvŠвЬvЩвЭwвЮwвЯwваwвбwввw#вгwвдwвеwвжwвзw"виw'вйx#вкx,влx"вмx5внx/воx(впx.врx+всx!втx)вуx3вфx*вхx1вцyTвчy[вшyOвщy\въySвыyRвьyQвэyывюyьвяyрв№yювёyэвђyъвѓyмвєyовѕyнвіz†вїz‰вјz…вљz‹вњzŒвћzŠвќz‡в§zивў{г@{гA{гB{гC{гD{гE{ гF{гG{ гH{гI|„гJ|‘гK|ŠгL|ŒгM|ˆгN|гO|…гP}гQ}гR}гS}гT}гU}гV}гW}гX}гY}гZ} г[\г\aг]^г^`г_]г`[гa–гb’гcУгdТгeРгf€гg€>гh€9гi€њгj€ђгk€љгl€ѕгmгn€ћгoгp‚гq‚/гr‚%гsƒ3гtƒ-гuƒDгvƒгwƒQгxƒ%гyƒVгzƒ?г{ƒAг|ƒ&г}ƒг~ƒ"гЁƒBгЂƒNгЃƒгЄƒ*гЅƒгІƒ<гЇƒMгЈƒгЉƒ$гЊƒ гЋƒ7гЌƒ/г­ƒ)гЎƒGгЏƒEгАƒLгБƒSгВƒгГƒ,гДƒKгЕƒ'гЖƒHгЗ†SгИ†RгЙ†ЂгК†ЈгЛ†–гМ†гН†‘гО†žгП†‡гР†—гС††гТ†‹гУ†šгФ†…гХ†ЅгЦ†™гЧ†ЁгШ†ЇгЩ†•гЪ†˜гЫ†ŽгЬ†гЭ†гЮ†”гЯˆCгаˆDгбˆmгвˆuггˆvгдˆrгеˆ€гжˆqгзˆгиˆoгйˆƒгкˆ~глˆtгмˆ|гнŠгоŒGгпŒWгрŒ{гсŒЄгтŒЃгуvгфxгхЕгцЗгчЖгшŽбгщŽггъўгыѕгьгэџгюћгяг№ќгёігђжгѓргєйгѕкгіугїпгјхгљигњлгћзгќмг§фгў‘Pд@‘NдA‘OдB‘едC‘тдD‘кдE–\дF–_дG–МдH˜удIšпдJ›/дKNдLPpдMPjдNPaдOP^дPP`дQPSдRPKдSP]дTPrдUPHдVPMдWPAдXP[дYPJдZPbд[Pд\PEд]P_д^Piд_Pkд`PcдaPdдbPFдcP@дdPnдePsдfPWдgPQдhQадiRkдjRmдkRlдlRnдmRждnRгдoS-дpSœдqUuдrUvдsU<дtUMдuUPдvU4дwU*дxUQдyUbдzU6д{U5д|U0д}URд~UEдЁU дЂU2дЃUeдЄUNдЅU9дІUHдЇU-дЈU;дЉU@дЊUKдЋW дЌWд­WћдЎXдЏWтдАWідБWмдВWєдГXдДWэдЕW§дЖXдЗWјдИX дЙWѓдКWЯдЛXдМWюдНWудОWђдПWхдРWьдСWсдТXдУWќдФXдХWчдЦXдЧX дШWёдЩWщдЪW№дЫX дЬXдЭY\дЮZ`дЯZXдаZUдбZgдвZ^дгZ8ддZ5деZmджZPдзZ_диZeдйZlдкZSдлZdдмZWднZCдоZ]дпZRдрZDдсZ[дтZHдуZŽдфZ>дхZMдцZ9дчZLдшZpдщZiдъZGдыZQдьZVдэZBдюZ\дя[rд№[nдё[Сдђ[Рдѓ\Yдє]дѕ] ді]дї]дј] дљ] дњ](дћ] дќ]&д§]%дў]е@]0еA]еB]#еC]еD].еE^>еF^4еG^БеH^ДеI^ЙеJ^ВеK^ГеL_6еM_8еN_›еO_–еP_ŸеQ`ŠеR`еS`†еT`ОеU`АеV`КеW`геX`деY`ЯеZ`фе[`йе\`не]`Ше^`Бе_`ле``Зеa`Ъеb`Пеc`Уеd`Эеe`Реfc2еgceеhcŠеic‚еjc}еkcНеlcžеmc­еncеoc—еpcЋеqcŽеrcoеsc‡еtcеucnеvcЏеwcuеxcœеycmеzcЎе{c|е|cЄе}c;е~cŸеЁcxеЂc…еЃcеЄc‘еЅcеІcpеЇeSеЈeЭеЉfeеЊfaеЋf[еЌfYе­f\еЎfbеЏgеАhyеБh‡еВhеГhœеДhmеЕhnеЖhЎеЗhЋеИiVеЙhoеКhЃеЛhЌеМhЉеНhuеОhtеПhВеРhеСhwеТh’еУh|еФhkеХhrеЦhЊеЧh€еШhqеЩh~еЪh›еЫh–еЬh‹еЭh еЮh‰еЯhЄеаhxебh{евh‘егhŒедhŠееh}ежk6езk3еиk7ейk8екk‘елkемkенkŽеоkŒепl*ерmРесmЋетmДеуmГефntехmЌецmщечmтешmЗещmіеъmдеыnеьmШеэmреюmпеяmже№mОеёmхеђmмеѓmнеєmлеѕmєеіmЪеїmНејmэељm№ењmКећmееќmТе§mЯеўmЩж@mажAmђжBmгжCm§жDmзжEmЭжFmужGmЛжHpњжIq жJpїжKqжLpєжMq жNp№жOqжPpѓжQqжRpќжSpџжTqжUqжVqжWpјжXpіжYq жZqж[qж\r~ж]r{ж^r|ж_rж`sжasжbsжcsжdsжes жfsжgrџжhsжisжjsˆжksіжlsјжmsѕжntжotжps§жqtжrtжssњжtsќжusџжvt жwt жxsєжytжzudж{ucж|uЮж}uвж~uЯжЁuЫжЂuЬжЃuбжЄuажЅvжІv‰жЇvгжЈw9жЉw/жЊw-жЋw1жЌw2ж­w4жЎw3жЏw=жАw%жБw;жВw5жГxHжДxRжЕxIжЖxMжЗxJжИxLжЙx&жКxEжЛxPжМydжНygжОyiжПyjжРycжСykжТyaжУyЛжФyњжХyјжЦyіжЧyїжШzжЩz”жЪzжЫ{5жЬ{GжЭ{4жЮ{%жЯ{0жа{"жб{$жв{3жг{жд{*же{жж{1жз{+жи{-жй{/жк{2жл{8жм{жн{#жо|”жп|˜жр|–жс|Ѓжт}5жу}=жф}8жх}6жц}:жч}Eжш},жщ})жъ}Aжы}Gжь}>жэ}?жю}Jжя};ж№}(жёcжђ•жѓœжєжѕ›жіЪжїЫжјЭжљажњбжћЧжќЯж§Щжў€з@€зA€зB€GзC€CзD€HзEзF%зGзHзI-зJзK,зLзM!зNзO'зPзQ"зR‚зS‚8зT‚3зU‚:зV‚4зW‚2зX‚tзYƒзZƒЃз[ƒЈз\ƒз]ƒzз^ƒsз_ƒЄз`ƒtзaƒзbƒзcƒ•зdƒ™зeƒuзfƒ”зgƒЉзhƒ}зiƒƒзjƒŒзkƒзlƒ›зmƒЊзnƒ‹зoƒ~зpƒЅзqƒЏзrƒˆзsƒ—зtƒАзuƒзvƒІзwƒ‡зxƒЎзyƒvзzƒšз{†Yз|†Vз}†Пз~†ЗзЁ†ТзЂ†СзЃ†ХзЄ†КзЅ†АзІ†ШзЇ†ЙзЈ†ГзЉ†ИзЊ†ЬзЋ†ДзЌ†Лз­†МзЎ†УзЏ†НзА†ОзБˆRзВˆ‰зГˆ•зДˆЈзЕˆЂзЖˆЊзЗˆšзИˆ‘зЙˆЁзКˆŸзЛˆ˜зМˆЇзНˆ™зОˆ›зПˆ—зРˆЄзСˆЌзТˆŒзУˆ“зФˆŽзХ‰‚зЦ‰жзЧ‰йзШ‰езЩŠ0зЪŠ'зЫŠ,зЬŠзЭŒ9зЮŒ;зЯŒ\заŒ]збŒ}звŒЅзг}зд{зеyзжМззТзиЙзйПзкСзлŽизмŽознŽнзоŽмзпŽззрŽрзсŽсзт$зу зфзхзц зч!зшязщъзъ№зыєзьђзэѓзюдзяыз№ьзёщзђ‘Vзѓ‘Xзє‘Zзѕ‘Sзі‘Uзї‘ьзј‘єзљ‘ёзњ‘ѓзћ‘јзќ‘ф科љзў‘ъи@‘ыиA‘їиB‘шиC‘юиD•zиE•†иF•ˆиG–|иH–mиI–kиJ–qиK–oиL–ПиM—jиN˜иO˜хиP™—иQP›иRP•иSP”иTPžиUP‹иVPЃиWPƒиXPŒиYPŽиZPи[Phи\Pœи]P’и^P‚и_P‡и`Q_иaQдиbSиcSиdSЄиeSЇиfU‘иgUЈиhUЅиiU­иjUwиkVEиlUЂиmU“иnUˆиoUиpUЕиqUиrUЃиsU’иtUЄиuU}иvUŒиwUІиxUиyU•иzUЁи{UŽи|W и}X)и~X7иЁXиЂXиЃX'иЄX#иЅX(иІWѕиЇXHиЈX%иЉXиЊXиЋX3иЌX?и­X6иЎX.иЏX9иАX8иБX-иВX,иГX;иДYaиЕZЏиЖZ”иЗZŸиИZzиЙZЂиКZžиЛZxиМZІиНZ|иОZЅиПZЌиРZ•иСZЎиТZ7иУZ„иФZŠиХZ—иЦZƒиЧZ‹иШZЉиЩZ{иЪZ}иЫZŒиЬZœиЭZиЮZ“иЯZиа[ъиб[Эив[Ыиг[дид[бие[Ъиж[Юиз\ ии\0ий]7ик]Cил]kим]Aин]Kио]?ип]5ир]Qис]Nит]Uиу]3иф]:их]Rиц]=ич]1иш]Yищ]Bиъ]9иы]Iиь]8иэ]<ию]2ия]6и№]@иё]Eиђ^Dиѓ^Aиє_Xиѕ_Іиі_Ѕиї_Ћиј`Щиљ`Йињ`Ьић`тиќ`Юи§`Фиўaй@`ђйAa йBaйCaйD`ѕйEaйF`јйG`ќйH`ўйI`СйJaйKaйLaйMaйN`џйOaйPa йQbJйRc”йScБйTcАйUcЮйVcхйWcшйXcяйYcУйZdй[cѓй\cЪй]cрй^cій_cей`cђйacѕйbdaйccпйdcОйecнйfcмйgcФйhcийicгйjcТйkcЧйlcЬйmcЫйncШйoc№йpcзйqcййre2йsegйtejйuedйve\йwehйxeeйyeŒйzeй{ežй|eЎй}eай~eвйЁf|йЂflйЃf{йЄf€йЅfqйІfyйЇfjйЈfrйЉgйЊi йЋhгйЌiй­hмйЎi*йЏhьйАhъйБhёйВiйГhжйДhїйЕhыйЖhфйЗhійИiйЙiйКhѓйЛhсйМiйНhЬйОiйПipйРhДйСiйТhяйУhЦйФiйХhјйЦhайЧh§йШhќйЩhшйЪi йЫi йЬiйЭhЮйЮhШйЯhнйаhойбhцйвhєйгhбйдiйеhдйжhщйзiйиi%ййhЧйкk9йлk;ймk?йнk<йоk”йпk—йрk™йсk•йтkНйуk№йфkђйхkѓйцl0йчmќйшnFйщnGйъnйыnIйьnˆйэn<йюn=йяnEй№nbйёn+йђn?йѓnAйєn]йѕnsйіnйїn3йјnKйљn@йњnQйћn;йќnй§n.йўn^к@nhкAn\кBnaкCn1кDn(кEn`кFnqкGnkкHn9кIn"кJn0кKnSкLneкMn'кNnxкOndкPnwкQnUкRnyкSnRкTnfкUn5кVn6кWnZкXq кYqкZq/к[pћк\q.к]q1к^q#к_q%к`q"кaq2кbqкcq(кdq:кeqкfrKкgrZкhrˆкir‰кjr†кkr…кlr‹кmsкns кos0кps"кqs1кrs3кss'кts2кus-кvs&кws#кxs5кys кzt.к{t,к|t0к}t+к~tкЁtкЂt!кЃt-кЄt1кЅt$кІt#кЇtкЈt)кЉt кЊt2кЋtћкЌu/к­uoкЎulкЏuчкАuккБuскВuцкГuнкДuпкЕuфкЖuзкЗv•кИv’кЙvккКwFкЛwGкМwDкНwMкОwEкПwJкРwNкСwKкТwLкУwокФwькХx`кЦxdкЧxeкШx\кЩxmкЪxqкЫxjкЬxnкЭxpкЮxiкЯxhкаx^кбxbквytкгysкдyrкеypкжzкзz киzкйz ккzклz™кмzцкнzфко{Jкп{;кр{Dкс{Hкт{Lку{Nкф{@кх{Xкц{Eкч|Ђкш|žкщ|Јкъ|Ёкы}Xкь}oкэ}cкю}Sкя}Vк№}gкё}jкђ}Oкѓ}mкє}\кѕ}kкі}Rкї}Tкј}iкљ}Qкњ}_кћ}Nкќ>к§?кўeл@fлAЂлB лCЁлDзлE€QлF€OлG€PлH€ўлI€длJCлKJлLRлMOлNGлO=лPMлQ:лRцлSюлTїлUјлVљлW‚лX‚<лY‚=лZ‚?л[‚uл\ƒ;л]ƒЯл^ƒљл_„#л`ƒРлaƒшлb„лcƒчлdƒфлeƒќлfƒілg„лhƒЦлiƒШлjƒылkƒулlƒПлm„лnƒнлoƒхлpƒилqƒџлrƒслsƒЫлtƒЮлuƒжлvƒѕлwƒЩлx„ лy„лzƒол{„л|„л}ƒТл~ƒѓлЁƒелЂƒњлЃƒЧлЄƒблЅƒълІ„лЇƒУлЈƒьлЉƒюлЊƒФлЋƒћлЌƒзл­ƒтлЎ„лЏƒллАƒўлБ†илВ†тлГ†цлД†глЕ†улЖ†клЗ†ълИ†нлЙ†ылК†млЛ†ьлМ†щлН†злО†шлП†блРˆHлСˆVлТˆUлУˆКлФˆзлХˆЙлЦˆИлЧˆРлШˆОлЩˆЖлЪˆМлЫˆЗлЬˆНлЭˆВлЮ‰лЯˆЩла‰•лб‰˜лв‰—лг‰нлд‰кле‰ллжŠNлзŠMлиŠ9лйŠYлкŠ@ллŠWлмŠXлнŠDлоŠEлпŠRлрŠHлсŠQлтŠJлуŠLлфŠOлхŒ_лцŒлчŒ€лшŒКлщŒОлъŒАлыŒЙльŒЕлэ„лю€ля‰л№илёглђЭлѓЧлєжлѕмліЯлїелјйлљШлњзлћХлќŽял§ŽїлўŽњм@ŽљмAŽцмBŽюмCŽхмDŽѕмEŽчмFŽшмGŽімHŽымIŽёмJŽьмKŽємLŽщмM-мN4мO/мP‘мQ‘,мR‘мSџмTќмU‘мVљмWћмX‘мY‘мZ‘м[‘м\‘м]‘aм^‘dм_‘_м`‘bмa‘`мb’мc’ мd’%мe’мf’мg’&мh’мi’ мj’мk’мl‘џмm‘§мn’мo’мp’'мq’мr’мs’$мt’мu’мv’мw’мx•{мy•мz•Œм{•м|–‡м}–~м~–ˆмЁ–‰мЂ–ƒмЃ–€мЄ–ТмЅ–ШмІ–УмЇ–ёмЈ–№мЉ—lмЊ—pмЋ—n썘쭘ЉмЎ˜ымЏœцмАžљмБNƒмВN„мГNЖмДPНмЕPПмЖPЦмЗPЎмИPФмЙPЪмКPДмЛPШмМPТмНPАмОPСмПPКмРPБмСPЫмТPЩмУPЖмФPИмХQзмЦRzмЧRxмШR{мЩR|мЪUУмЫUлмЬUЬмЭUамЮUЫмЯUЪмаUнмбUРмвUдмгUФмдUщмеUПмжUвмзUмиUЯмйUемкUтмлUжммUШмнUђмоUЭмпUймрUТмсWмтXSмуXhмфXdмхXOмцXMмчXIмшXoмщXUмъXNмыX]мьXYмэXeмюX[мяX=м№XcмёXqмђXќмѓZЧмєZФмѕZЫміZКмїZИмјZБмљZЕмњZАмћZПмќZШм§ZЛмўZЦн@ZЗнAZРнBZЪнCZДнDZЖнEZЭнFZЙнGZнH[жнI[инJ[йнK\нL\3нM]qнN]cнO]JнP]eнQ]rнR]lнS]^нT]hнU]gнV]bнW]№нX^OнY^NнZ^Jн[^Mн\^Kн]^Хн^^Ьн_^Цн`^Ынa^Чнb_@нc_Џнd_­нe`їнfaIнgaJнha+нiaEнja6нka2нla.нmaFнna/нoaOнpa)нqa@нrb нs‘hнtb#нub%нvb$нwcХнxcёнycынzdн{dн|d н}d н~d$нЁd3нЂdCнЃdнЄdнЅdнІd9нЇd7нЈd"нЉd#нЊd нЋd&нЌd0н­d(нЎdAнЏd5нАd/нБd нВdнГd@нДd%нЕd'нЖd нЗcчнИdнЙd.нКd!нЛdнМeoнНe’нОeгнПf†нРfŒнСf•нТfнУf‹нФfŠнХf™нЦf”нЧfxнШg нЩifнЪi_нЫi8нЬiNнЭibнЮiqнЯi?наiEнбijнвi9нгiBндiWнеiYнжizнзiHниiIнйi5нкilнлi3нмi=ннieноh№нпixнрi4нсiiнтi@нуioнфiDнхivнцiXнчiAншitнщiLнъi;ныiKньi7нэi\нюiOняiQн№i2нёiRнђi/нѓi{нєi<нѕkFніkEнїkCнјkBнљkHнњkAнћk›нќњ н§kћнўkќо@kљоAkїоBkјоCn›оDnжоEnШоFnоGnРоHnŸоIn“оJn”оKn оLnБоMnЙоNnЦоOnвоPnНоQnСоRnžоSnЩоTnЗоUnАоVnЭоWnІоXnЯоYnВоZnОо[nУо\nмо]nио^n™о_n’о`nŽоanоbnЄоcnЁоdnПоenГоfnаоgnЪоhn—оinЎоjnЃоkqGоlqTоmqRоnqcоoq`оpqAоqq]оrqbоsqrоtqxоuqjоvqaоwqBоxqXоyqCоzqKо{qpо|q_о}qPо~qSоЁqDоЂqMоЃqZоЄrOоЅrоІrŒоЇr‘оЈrоЉrŽоЊs<оЋsBоЌs;о­s:оЎs@оЏsJоАsIоБtDоВtJоГtKоДtRоЕtQоЖtWоЗt@оИtOоЙtPоКtNоЛtBоМtFоНtMоОtTоПtсоРtџоСtўоТt§оУuоФuyоХuwоЦiƒоЧuяоШvоЩvоЪuїоЫuўоЬuќоЭuљоЮuјоЯvоаuћобuіовuэогuѕодu§оеv™ожvЕозvноиwUойw_окw`олwRомwVонwZооwiопwgорwTосwYотwmоуwрофx‡охxšоцx”очxошx„ощx•оъx…оыx†оьxЁоэxƒоюxyояx™о№x€оёx–ођx{оѓy|оєy‚оѕy}оіyyоїzојzољzоњzоћzоќzо§z"оўzп@zпAzпBzЃпCzЂпDzžпEzыпF{fпG{dпH{mпI{tпJ{iпK{rпL{eпM{sпN{qпO{pпP{aпQ{xпR{vпS{cпT|ВпU|ДпV|ЏпW}ˆпX}†пY}€пZ}п[}п\}…п]}zп^}Žп_}{п`}ƒпa}|пb}Œпc}”пd}„пe}}пf}’пgmпhkпigпjhпklпlІпmЅпnЇпoлпpмпq€!пrdпs`пtwпu\пviпw[пxbпyrпzg!п{^п|vп}gп~oпЁDпЂaпЃ‚пЄ‚IпЅ‚DпІ‚@пЇ‚BпЈ‚EпЉ„ёпЊ„?пЋ„VпЌ„vп­„yпЎ„пЏ„пА„eпБ„QпВ„@пГ„†пД„gпЕ„0пЖ„MпЗ„}пИ„ZпЙ„YпК„tпЛ„sпМ„]пН…пО„^пП„7пР„:пС„4пТ„zпУ„CпФ„xпХ„2пЦ„EпЧ„)пШƒйпЩ„KпЪ„/пЫ„BпЬ„-пЭ„_пЮ„pпЯ„9па„Nпб„Lпв„Rпг„oпд„Хпе„Žпж„;пз„Gпи„6пй„3пк„hпл„~пм„Dпн„+по„`пп„Tпр„nпс„Pпт‡ пу‡пф†їпх‡ пц†њпч†жпш†ѕпщ‡Mпъ†јпы‡пь‡ пэ‡пю†іпя‡ ﹇пёˆжпђˆЫпѓˆЭпєˆЮпѕˆопіˆлпїˆкпјˆЬпљˆапњ‰…пћ‰›пќ‰п柳хпў‰фр@‰срA‰ррB‰трC‰мрD‰црEŠvрFŠ†рGŠрHŠaрIŠ?рJŠwрKŠ‚рLŠ„рMŠuрNŠƒрOŠрPŠtрQŠzрRŒ<рSŒKрTŒJрUŒeрVŒdрWŒfрXŒ†рYŒ„рZŒ…р[ŒЬр\hр]iр^‘р_Œр`Žрaрbрc“рd”рeрf’рg№рhррiьрjёрkюрlарmщрnурoтрpчрqђрrырsєрtрuŽџрvрwрxрyрzр{р| р}Rр~?рЁDрЂIрЃ=рЄ‘рЅ‘ рІ‘рЇ‘рЈ‘рЉ‘рЊ‘ рЋ‘рЌ‘nр­‘oрЎ’HрЏ’RрА’0рБ’:рВ’fрГ’3рД’eрЕ’^рЖ’ƒрЗ’.рИ’JрЙ’FрК’mрЛ’lрМ’OрН’`рО’gрП’oрР’6рС’aрТ’pрУ’1рФ’TрХ’cрЦ’PрЧ’rрШ’NрЩ’SрЪ’LрЫ’VрЬ’2рЭ•ŸрЮ•œрЯ•žра•›рб–’рв–“рг–‘рд–—ре–Юрж–њрз–§ри–јрй–ѕрк—sрл—wрм—xрн—rро˜рп˜ рр˜рс˜Ќрт˜іру˜љрф™Џрх™Врц™Арч™Ершš­рщšЋръ›[рыœърьœэрэœчрюž€ряž§р№PцрёPдрђPзрѓPшрєPѓрѕPлріPърїPнрјPфрљPгрњPьрћP№рќPяр§PурўPрс@QисAR€сBRсCRщсDRысES0сFSЌсGV'сHVсIV сJVсKUќсLVсMVсNVсOVсPVсQUњсRVсSVсTUџсUUљсVX‰сWX|сXXсYX˜сZX†с[Xс\Xс]Xtс^X‹с_Xzс`X‡сaX‘сbXŽсcXvсdX‚сeXˆсfX{сgX”сhXсiXўсjYkсkZмсlZюсmZхсnZесoZъсpZксqZэсrZысsZѓсtZтсuZрсvZлсwZьсxZосyZнсzZйс{Zшс|Zпс}[wс~[рсЁ[усЂ\cсЃ]‚сЄ]€сЅ]}сІ]†сЇ]zсЈ]сЉ]wсЊ]ŠсЋ]‰сЌ]ˆс­]~сЎ]|сЏ]сА]yсБ]сВ^XсГ^YсД^SсЕ^исЖ^бсЗ^зсИ^ЮсЙ^мсК^есЛ^йсМ^всН^дсО_DсП_CсР_oсС_ЖсТa,сУa(сФaAсХa^сЦaqсЧasсШaRсЩaSсЪarсЫalсЬa€сЭatсЮaTсЯazсаa[сбaeсвa;сгajсдaaсеaVсжb)сзb'сиb+сйd+скdMслd[смd]снdtсоdvспdrсрdsссd}стduсуdfсфdІсхdNсцd‚счd^сшd\сщdKсъdSсыd`сьdPсэdсюd?сяdlс№dkсёdYсђdeсѓdwсєesсѕe сіfЁсїf сјfŸсљgсњgсћg"сќiБс§iЖсўiЩт@i тAiЮтBi–тCiАтDiЌтEiМтFi‘тGi™тHiŽтIiЇтJiтKiЉтLiОтMiЏтNiПтOiФтPiНтQiЄтRiдтSiЙтTiЪтUišтViЯтWiГтXi“тYiЊтZiЁт[ižт\iйт]i—т^iт_iТт`iЕтaiЅтbiЦтckJтdkMтekKтfkžтgkŸтhk тikУтjkФтkkўтlnЮтmnѕтnnётooтpo%тqnјтro7тsnћтto.тuo тvoNтwoтxoтyo'тzoт{o;т|oт}nэт~o тЁo6тЂosтЃnљтЄnютЅo-тІo@тЇo0тЈo<тЉo5тЊnытЋoтЌoт­oCтЎoтЏn§тАnітБo9тВoтГnќтДo:тЕoтЖo тЗoтИoтЙo!тКq‡тЛqтМq‰тНq€тОq…тПq‚тРqтСq{тТq†тУqтФq—тХrDтЦrSтЧr—тШr•тЩr“тЪsCтЫsMтЬsQтЭsLтЮtbтЯtsтаtqтбtuтвtrтгtgтдtnтеuтжuтзuтиu}тйuткvтлvтмv тнvтоvтпv трvтсvИттwтуw|тфw…тхw‚тцwnтчw€тшwoтщw~тъwƒтыxВтьxЊтэxДтюx­тяxЈт№x~тёxЋтђxžтѓxЅтєx тѕxЌтіxЂтїxЄтјy˜тљyŠтњy‹тћy–тќy•т§y”тўy“у@y—уAyˆуBy’уCyуDz+уEzJуFz0уGz/уHz(уIz&уJzЈуKzЋуLzЌуMzюуN{ˆуO{œуP{ŠуQ{‘уR{уS{–уT{уU{ŒуV{›уW{ŽуX{…уY{˜уZR„у[{™у\{Єу]{‚у^|Лу_|Пу`|Муa|Куb}Їуc}Зуd}Туe}Ѓуf}Њуg}Суh}Руi}Хуj}уk}Юуl}Фуm}Цуn}Ыуo}Ьуp}Џуq}Йуr}–уs}Муt}Ÿуu}Іуv}Ўуw}Љуx}Ёуy}Щуzsу{ту|уу}ху~оуЁ€$уЂ€]уЃ€\уЄ‰уЅ†уІƒуЇ‡уЈуЉŒуЊ‹уЋ‚уЌ„—у­„ЄуЎ„ЁуЏ„ŸуА„КуБ„ЮуВ„ТуГ„ЌуД„ЎуЕ„ЋуЖ„ЙуЗ„ДуИ„СуЙ„ЭуК„ЊуЛ„šуМ„БуН„ауО„уП„ЇуР„ЛуС„ЂуТ„”уУ„ЧуФ„ЬуХ„›уЦ„ЉуЧ„ЏуШ„ЈуЩ„жуЪ„˜уЫ„ЖуЬ„ЯуЭ„ уЮ„зуЯ„дуа„вуб„лув„Ауг„‘уд†aуе‡3уж‡#уз‡(уи‡kуй‡@ук‡.ул‡ум‡!ун‡уо‡уп‡Cур‡,ус‡Aут‡>уу‡Fуф‡ ух‡2уц‡*уч‡-уш‡<ущ‡уъ‡:уы‡1уь‡5уэ‡Bую‡&уя‡'у№‡8уё‡$уђ‡уѓ‡0ує‡уѕˆїуіˆчуїˆёујˆђуљˆњуњˆўућˆюуќˆќу§ˆіуўˆћф@ˆ№фAˆьфBˆыфC‰фD‰ЁфE‰ŸфF‰žфG‰щфH‰ыфI‰шфJŠЋфKŠ™фLŠ‹фMŠ’фNŠфOŠ–фPŒ=фQŒhфRŒiфSŒефTŒЯфUŒзфV–фWŽ фXŽфYџфZŽ ф[§ф\Ž ф]Žф^Žф_Žф`ŽфaўфbŽфcŽфdфeфfфg фh‘#фi‘фj‘ фk‘"фl‘фm‘фn‘фo‘$фp‘!фq‘фr‘zфs‘rфt‘yфu‘sфv’Ѕфw’Єфx’vфy’›фz’zф{’ ф|’”ф}’Њф~’фЁ’ІфЂ’šфЃ’ЋфЄ’yфЅ’—фІ’фЇ’ЃфЈ’юфЉ’ŽфЊ’‚фЋ’•фЌ’Ђф­’}фЎ’ˆфЏ’ЁфА’ŠфБ’†фВ’ŒфГ’™фД’ЇфЕ’~фЖ’‡фЗ’ЉфИ’фЙ’‹фК’-фЛ–žфМ–ЁфН–џфО—XфП—}фР—zфС—~фТ—ƒфУ—€фФ—‚фХ—{фЦ—„фЧ—фШ—фЩ—ЮфЪ—Эфۘфܘ­фݘЎфЮ™фЯ™фа™фб™фв™œфг™Уфд™Йфе™Лфж™Кфз™Тфи™Нфй™ЧфкšБфлšуфмšчфн›>фо›?фп›`фр›aфс›_фтœёфуœђффœѕфхžЇфцPџфчQфшQ0фщPјфъQфыQфьPіфэPўфюQ фяQ ф№P§фёQ фђR‹фѓRŒфєRёфѕRяфіVHфїVBфјVLфљV5фњVAфћVJфќVIф§VFфўVXх@VZхAV@хBV3хCV=хDV,хEV>хFV8хGV*хHV:хIWхJXЋхKXхLXБхMX хNXЃхOXЏхPXЌхQXЅхRXЁхSXџхTZџхUZєхVZ§хWZїхXZіхY[хZZјх[[х\Zљх][х^[х_[х`[хa\gхb]™хc]—хd]Ÿхe]’хf]Ђхg]“хh]•хi] хj]œхk]Ёхl]šхm]žхn^iхo^]хp^`хq^\хr}ѓхs^лхt^охu^схv_Iхw_Вхxa‹хyaƒхzayх{aБх|aАх}aЂх~a‰хЁa›хЂa“хЃaЏхЄa­хЅaŸхІa’хЇaЊхЈaЁхЉaхЊafхЋaГхЌb-х­dnхЎdpхЏd–хАd хБd…хВd—хГdœхДdхЕd‹хЖdŠхЗdŒхИdЃхЙdŸхКdhхЛdБхМd˜хНevхОezхПeyхРe{хСeВхТeГхУfЕхФfАхХfЉхЦfВхЧfЗхШfЊхЩfЏхЪjхЫjхЬjхЭiххЮiјхЯjхаiёхбiфхвj хгiџхдiьхеiтхжjхзjхиiўхйj'хкiђхлiюхмjхнiїхоiчхпj@хрjхсiцхтiћхуj хфiќххiыхцj хчjхшjхщj%хъjхыiіхьj&хэjхюiєхяjх№kQхёkЅхђkЃхѓkЂхєkІхѕlхіlхїkџхјlхљoAхњo&хћo~хќo‡х§oЦхўo’ц@oцAo‰цBoŒцCobцDoOцEo…цFoZцGo–цHovцIolцJo‚цKoUцLorцMoRцNoPцOoWцPo”цQo“цRo]цSoцToaцUokцVo}цWogцXoцYoSцZo‹ц[oiц\oц]o•ц^ocц_owц`ojцao{цbqВцcqЏцdq›цeqАцfq цgqšцhqЉцiqЕцjqцkqЅцlqžцmqЄцnqЁцoqЊцpqœцqqЇцrqГцsr˜цtršцusXцvsRцws^цxs_цys`цzs]ц{s[ц|saц}sZц~sYцЁsbцЂt‡цЃt‰цЄtŠцЅt†цІtцЇt}цЈt…цЉtˆцЊt|цЋtyцЌuц­uцЎu~цЏv%цАvцБvцВvцГvцДv#цЕvцЖv(цЗvцИvœцЙvцКvžцЛv›цМwцНwцОw‰цПwˆцРxЭцСxЛцТxЯцУxЬцФxбцХxЮцЦxдцЧxШцШxУцЩxФцЪxЩцЫyšцЬyЁцЭy цЮyœцЯyЂцаy›цбkvцвz9цгzВцдzДцеzГцж{Зцз{Ыци{Оцй{Ќцк{Юцл{Џцм{Йцн{Ъцо{Ецп|Хцр|Шцс|Ьцт|Ыцу}їцф}лцх}ъцц}чцч}зцш}сцщ~цъ}њцы}цць}іцэ}ёцю}№ця}юц№}пцёvцђЌцѓАцє­цѕэціыцїъцјьцљццњшцћ€dцќ€gц§ЃцўŸч@žчA•чBЂчC™чD—чE‚чF‚OчG‚SчH‚RчI‚PчJ‚NчK‚QчL…$чM…;чN…чO…чP…)чQ…чR… чS… чT…чU… чV…'чW…чX„ћчY…+чZ„њч[…ч\… ч]„єч^…*ч_„ђч`…чa„їчb„ычc„ѓчd„ќчe…чf„ъчg„щчh…чi„ўчj…(чk…чl….чm…чn„§чo…чp„ічq…1чr…&чs„ччt„шчu„№чv„ячw„љчx…чy… чz…0ч{… ч|…ч}…/ч~†bчЁ‡VчЂ‡cчЃ‡dчЄ‡wчЅ‡счІ‡sчЇ‡XчЈ‡TчЉ‡[чЊ‡RчЋ‡aчЌ‡Zч­‡QчЎ‡^чЏ‡mчА‡jчБ‡PчВ‡NчГ‡_чД‡]чЕ‡oчЖ‡lчЗ‡zчИ‡nчЙ‡\чК‡eчЛ‡OчМ‡{чН‡uчО‡bчП‡gчР‡iчСˆZчТ‰чУ‰ чФ‰чХ‰ чЦ‰чЧ‰чШ‰чЩ‰чЪ‰чЫ‰чЬ‰чЭ‰ чЮ‰ЂчЯ‰Єча‰Ѓчб‰эч≹чг‰ьчдŠЯчеŠЦчжŠИчзŠгчиŠбчйŠдчкŠечлŠЛчмŠзчнŠОчоŠРчпŠХчрŠичсŠУчтŠКчуŠНчфŠйчхŒ>чцŒMччŒчшŒхчщŒпчъŒйчыŒшчьŒкчэŒнчюŒччя ч№œчёЁчђ›чѓŽ чєŽ#чѕŽ%чіŽ$чїŽ.чјŽчљŽчњŽчћŽчќŽч§Ž&чўŽ'ш@ŽшAŽшBŽшCŽшDŽшEŽшFŽшG,шH$шIшJшK шL#шMшNшOsшPpшQoшRgшSkшT‘/шU‘+шV‘)шW‘*шX‘2шY‘&шZ‘.ш[‘…ш\‘†ш]‘Šш^‘ш_‘‚ш`‘„шa‘€шb’ашc’Ушd’Фшe’Ршf’йшg’Жшh’Яшi’ёшj’пшk’ишl’щшm’зшn’ншo’Ьшp’яшq’Тшr’шшs’Ъшt’Шшu’Юшv’цшw’Эшx’ешy’Щшz’рш{’ош|’чш}’бш~’гшЁ’ЕшЂ’сшЃ’ЦшЄ’ДшЅ•|шІ•ЌшЇ•ЋшЈ•ЎшЉ•АшЊ–ЄшЋ–ЂшЌ–гш­—шЎ—шЏ—шА—ZшБ—ŠшВ—ŽшГ—ˆшД—ашЕ—ЯшƘшǘшȘ&шɘ)шʘ(ш˘ ш̘ш͘'шΘВшП™шИњшС™шТ™шУ™шФ™шХ™шЦ™мшЧ™ЭшШ™ЯшЩ™гшЪ™дшЫ™ЮшЬ™ЩшЭ™жшЮ™ишЯ™Ыша™зшб™ЬшвšГшгšьшдšышеšѓшжšђшзšёши›Fшй›Cшк›gшл›tшм›qшн›fшо›vшп›uшр›pшс›hшт›dшу›lшфœќшхœњшцœ§шчœџшшœїшщшъшыœљшьœћшэшюшяш№žƒшёžгшђŸшѓŸшєQшѕQшіQшїQшјQшљQошњS4шћSсшќVpш§V`шўVnщ@VsщAVfщBVcщCVmщDVrщEV^щFVwщGWщHWщIXШщJXНщKXЩщLXПщMXКщNXТщOXМщPXЦщQ[щR[щS[щT[!щU[щV[щW[щX[щY[(щZ[щ[[ щ\[щ][ящ^]Ќщ_]Бщ`]Љщa]Їщb]Ещc]Ащd]Ўщe]Њщf]Јщg]Вщh]­щi]Џщj]Дщk^gщl^hщm^fщn^oщo^щщp^чщq^цщr^шщs^хщt_Kщu_МщvaщwaЈщxa–щyaХщzaДщ{aЦщ|aСщ}aЬщ~aКщЁaПщЂaИщЃaŒщЄdзщЅdжщІdащЇdЯщЈdЩщЉdНщЊd‰щЋdУщЌdлщ­dѓщЎdйщЏe3щАeщБe|щВeЂщГfШщДfОщЕfРщЖfЪщЗfЫщИfЯщЙfНщКfЛщЛfКщМfЬщНg#щОj4щПjfщРjIщСjgщТj2щУjhщФj>щХj]щЦjmщЧjvщШj[щЩjQщЪj(щЫjZщЬj;щЭj?щЮjAщЯjjщаjdщбjPщвjOщгjTщдjoщеjiщжj`щзj<щиj^щйjVщкjUщлjMщмjNщнjFщоkUщпkTщрkVщсkЇщтkЊщуkЋщфkШщхkЧщцlщчlщшlщщo­щъoЫщыoЃщьoЧщэoМщюoЮщяoШщ№o^щёoФщђoНщѓožщєoЪщѕoЈщіpщїoЅщјoЎщљoКщњoЌщћoЊщќoЯщ§oПщўoИъ@oЂъAoЩъBoЋъCoЭъDoЏъEoВъFoАъGqХъHqТъIqПъJqИъKqжъLqРъMqСъNqЫъOqдъPqЪъQqЧъRqЯъSqНъTqиъUqМъVqЦъWqкъXqлъYrъZržъ[siъ\sfъ]sgъ^slъ_seъ`skъasjъbtъctšъdt ъet”ъft’ъgt•ъhtЁъiu ъju€ъkv/ъlv-ъmv1ъnv=ъov3ъpv<ъqv5ъrv2ъsv0ъtvЛъuvцъvwšъwwъxwЁъywœъzw›ъ{wЂъ|wЃъ}w•ъ~w™ъЁw—ъЂxнъЃxщъЄxхъЅxъъІxоъЇxуъЈxлъЉxсъЊxтъЋxэъЌxпъ­xръЎyЄъЏzDъАzHъБzGъВzЖъГzИъДzЕъЕzБъЖzЗъЗ{оъИ{уъЙ{чъК{нъЛ{еъМ{хъН{къО{шъП{љъР{дъС{ъъТ{тъУ{мъФ{ыъХ{иъЦ{пъЧ|въШ|дъЩ|зъЪ|аъЫ|бъЬ~ъЭ~!ъЮ~ъЯ~ ъа~ъб~ ъв~ъг~ъд~ъе~ъж~ъз~"ъи~ ъй~ък~ъл~ ъм~ън~%ъо~$ъпCър{ъс|ътzъуБъфяъх€*ъц€)ъч€lъшБъщІъъЎъыЙъьЕъэЋъюАъяЌъ№ДъёВъђЗъѓЇъєђъѕ‚Uъі‚Vъї‚Wъј…Vъљ…Eъњ…kъћ…Mъќ…Sъ§…aъў…Xы@…@ыA…FыB…dыC…AыD…bыE…DыF…QыG…GыH…cыI…>ыJ…[ыK…qыL…NыM…nыN…uыO…UыP…gыQ…`ыR…ŒыS…fыT…]ыU…TыV…eыW…lыX†cыY†eыZ†dы[‡›ы\‡ы]‡—ы^‡“ы_‡’ы`‡ˆыa‡ыb‡–ыc‡˜ыd‡yыe‡‡ыf‡Ѓыg‡…ыh‡ыi‡‘ыj‡ыk‡„ыl‡”ыm‡œыn‡šыo‡‰ыp‰ыq‰&ыr‰0ыs‰-ыt‰.ыu‰'ыv‰1ыw‰"ыx‰)ыy‰#ыz‰/ы{‰,ы|‰ы}‰ёы~ŠрыЁŠтыЂŠђыЃŠєыЄŠѕыЅŠныІ‹ыЇŠфыЈŠпыЉŠ№ыЊŠШыЋŠоыЌŠсы­ŠшыЎŠџыЏŠяыАŠћыБŒ‘ыВŒ’ыГŒыДŒѕыЕŒюыЖŒёыЗŒ№ыИŒѓыЙlыКnыЛЅыМЇыНŽ3ыОŽ>ыПŽ8ыРŽ@ыСŽEыТŽ6ыУŽ<ыФŽ=ыХŽAыЦŽ0ыЧŽ?ыШŽНыЩ6ыЪ.ыЫ5ыЬ2ыЭ9ыЮ7ыЯ4ыаvыбyыв{ыг†ыдњые‘3ыж‘5ыз‘6ыи‘“ый‘ык‘‘ыл‘ым‘ын“'ыо“ып“ыр“ыс“ыт“ыу“zыф“8ых“<ыц“ыч“#ыш“ыщ“ыъ“Fыы“-ыь“ыэ“ ыю’Ыыя“ы№’њыё“%ыђ“ыѓ’љыє’їыѕ“4ыі“ыї“$ыј’џыљ“)ыњ“9ыћ“5ыќ“*ы§“ыў“ ь@“ ьA’ўьB“ ьC“ьD’ћьE“ьF•МьG•ЭьH•ОьI•ЙьJ•КьK•ЖьL•ПьM•ЕьN•НьO–ЉьP–дьQ— ьR—ьS—ьT—™ьU——ьV—”ьW—№ьX—јьY˜5ьZ˜/ь[˜2ь\™$ь]™ь^™'ь_™)ь`™žьa™юьb™ььc™хьd™фьe™№ьf™уьg™ъьh™щьi™чьjšЙьkšПьlšДьmšЛьnšіьošњьpšљьqšїьr›3ьs›€ьt›…ьu›‡ьv›|ьw›~ьx›{ьy›‚ьz›“ь{›’ь|›ь}›zь~›•ьЁ›}ьЂ›ˆьЃ%ьЄьЅ ьІьЇьЈ)ьЉьЊьЋ"ьЌь­ьЎьЏžˆьАž†ьБž‡ьВžЎьГž­ьДžеьЕžжьЖžњьЗŸьИŸ=ьЙQ&ьКQ%ьЛQ"ьМQ$ьНQ ьОQ)ьПRєьРV“ьСVŒьТVьУV†ьФV„ьХVƒьЦV~ьЧV‚ьШVьЩVьЪXжьЫXдьЬXЯьЭXвьЮ[-ьЯ[%ьа[2ьб[#ьв[,ьг['ьд[&ье[/ьж[.ьз[{ьи[ёьй[ђьк]Зьл^lьм^jьн_Оьо_ЛьпaУьрaЕьсaМьтaчьуaрьфaхьхaфьцaшьчaоьшdяьщdщьъdуьыdыььdфьэdшьюeьяe€ь№eЖьёeкьђfвьѓjьєj–ьѕjьіjЅьїj‰ьјjŸьљj›ьњjЁьћjžьќj‡ь§j“ьўjŽэ@j•эAjƒэBjЈэCjЄэDj‘эEjэFjІэGjšэHj…эIjŒэJj’эKk[эLk­эMl эNoЬэOoЉэPoєэQoдэRoуэSoмэToээUoчэVoцэWoоэXoђэYoнэZoтэ[oшэ\qсэ]qёэ^qшэ_qђэ`qфэaq№эbqтэcssэdsnэesoэft—эgtВэhtЋэitэjtЊэkt­эltБэmtЅэntЏэouэpuэquэruэsu„эtvCэuvHэvvIэwvGэxvЄэyvщэzwЕэ{wЋэ|wВэ}wЗэ~wЖэЁwДэЂwБэЃwЈэЄw№эЅxѓэІx§эЇyэЈxћэЉxќэЊxђэЋyэЌxљэ­xўэЎyэЏyЋэАyЈэБz\эВz[эГzVэДzXэЕzTэЖzZэЗzОэИzРэЙzСэК|эЛ|эМ{ђэН|эО{џэП{ћэР|эС{єэТ| эУ{ѓэФ|эХ| эЦ|эЧ|эШ{јэЩ{§эЪ|эЫ{№эЬ{ёэЭ|эЮ| эЯ|шэа~-эб~<эв~Bэг~3эд˜Hэе~8эж~*эз~Iэи~@эй~Gэк~)эл~Lэм~0эн~;эо~6эп~Dэр~:эсEэтэу~эф}эхєэцђэч€,эшЛэщФэъЬэыЪэьХээЧэюМэящэ№‚[эё‚Zэђ‚\эѓ…ƒэє…€эѕ…эі…Їэї…•эј… эљ…‹эњ…Ѓэћ…{эќ…Єэ§…šэў…žю@…wюA…|юB…‰юC…ЁюD…zюE…xюF…WюG…ŽюH…–юI…†юJ…юK…™юL…юM…юN…ЂюO…‚юP…ˆюQ……юR…yюS…vюT…˜юU…юV…ŸюW†hюX‡ОюY‡ЊюZ‡­ю[‡Хю\‡Аю]‡Ќю^‡Йю_‡Ею`‡Мюa‡Ўюb‡Щюc‡Уюd‡Тюe‡Ьюf‡Зюg‡Џюh‡Фюi‡Ъюj‡Дюk‡Жюl‡Пюm‡Июn‡Нюo‡оюp‡Вюq‰5юr‰3юs‰<юt‰>юu‰Aюv‰Rюw‰7юx‰Bюy‰­юz‰Џю{‰Ўю|‰ђю}‰ѓю~‹юЁ‹юЂ‹юЃ‹юЄ‹юЅ‹ юІ‹"юЇ‹юЈ‹юЉ‹юЊ‹юЋ‹ юЌ‹ю­‹юЎ‹юЏ‹юА‹юБŒOюВŒpюГŒrюДŒqюЕŒoюЖŒ•юЗŒ”юИŒљюЙoюКŽNюЛŽMюМŽSюНŽPюОŽLюПŽGюРCюС@юТ…юУ~юФ‘8юХ‘šюЦ‘ЂюЧ‘›юШ‘™юЩ‘ŸюЪ‘ЁюЫ‘юЬ‘ юЭ“ЁюЮ“ƒюЯ“Џюа“dюб“Vюв“Gюг“|юд“Xюе“\юж“vюз“Iюи“Pюй“Qюк“`юл“mюм“юн“Lюо“jюп“yюр“Wюс“Uют“Rюу“Oюф“qюх“wюц“{юч“aюш“^ющ“cюъ“gюы“€юь“Nюэ“Yюю•Чюя•Рю№•Щюё•Уюђ•Хюѓ•Зює–Ўюѕ–Аюі–Ќюї— юј—юљ—юњ—юћ—юќ—šю§—Ёюў—œя@—žяA—яB—еяC—дяD—ёяE˜AяF˜DяG˜JяH˜IяI˜EяJ˜CяK™%яL™+яM™,яN™*яO™3яP™2яQ™/яR™-яS™1яT™0яU™˜яV™ЃяW™ЁяXšяY™њяZ™єя[™їя\™љя]™јя^™ія_™ћя`™§яa™ўяb™ќяcšяdšОяešўяfš§яg›яhšќяi›Hяj›šяk›Јяl›žяm››яn›Іяo›Ёяp›Ѕяq›Єяr›†яs›Ђяt› яu›Џяv3яwAяxgяy6яz.я{/я|1я}8я~0яЁEяЂBяЃCяЄ>яЅ7яІ@яЇ=яЈѕяЉ-яЊžŠяЋž‰яЌžя­žАяЎžШяЏžкяАžћяБžџяВŸ$яГŸ#яДŸ"яЕŸTяЖŸ яЗQ1яИQ-яЙQ.яКV˜яЛVœяМV—яНVšяОVяПV™яРYpяС[<яТ\iяУ\jяФ]РяХ^mяЦ^nяЧaияШaпяЩaэяЪaюяЫaёяЬaъяЭa№яЮaыяЯaжяаaщябdџявeягd§ядdјяеeяжeязdќяиe”яйeлякfкялfлямfиянjХяоjЙяпjНярjсясjЦятjКяуjЖяфjЗяхjЧяцjДячj­яшk^ящkЩяъl яыpяьp яэp яюpяяpя№pяёpяђoџяѓpяєoћяѕp&яіoќяїoїяјp яљrяњqџяћqљяќrя§q§яўsv№@tИ№AtР№BtЕ№CtС№DtО№EtЖ№FtЛ№GtТ№Hu№Iu№Jv\№Kvd№LvY№MvP№NvS№OvW№PvZ№QvІ№RvН№Svь№TwТ№UwК№Vxџ№Wy №Xy№Yy№Zy №[y№\y№]y№^y­№_yЌ№`z_№a|№b|)№c|№d| №e|№f|-№g|№h|&№i|(№j|"№k|%№l|0№m~\№n~P№o~V№p~c№q~X№r~b№s~_№t~Q№u~`№v~W№w~S№xЕ№yГ№zї№{ј№|€u№}б№~в№Ёа№Ђ‚_№Ѓ‚^№Є…Д№Ѕ…Ц№І…Р№Ї…У№Ј…Т№Љ…Г№Њ…Е№Ћ…Н№Ќ…Ч№­…Ф№Ў…П№Џ…Ы№А…Ю№Б…Ш№В…Х№Г…Б№Д…Ж№Е…в№Ж†$№З…И№И…З№Й…О№К†i№Л‡ч№М‡ц№Н‡т№О‡л№П‡ы№Р‡ъ№С‡х№Т‡п№У‡ѓ№Ф‡ф№Х‡д№Ц‡м№Ч‡г№Ш‡э№Щ‡и№Ъ‡у№Ы‡Є№Ь‡з№Э‡й№Юˆ№Я‡є№а‡ш№б‡н№в‰S№г‰K№д‰O№е‰L№ж‰F№з‰P№и‰Q№й‰I№к‹*№л‹'№м‹#№н‹3№о‹0№п‹5№р‹G№с‹/№т‹<№у‹>№ф‹1№х‹%№ц‹7№ч‹&№ш‹6№щ‹.№ъ‹$№ы‹;№ь‹=№э‹:№юŒB№яŒu№№Œ™№ёŒ˜№ђŒ—№ѓŒў№є№ѕ№і№їŽ\№јŽb№љŽ`№њŽW№ћŽV№ќŽ^№§Že№ўŽgё@Ž[ёAŽZёBŽaёCŽ]ёDŽiёEŽTёFFёGGёHHёIKёJ‘(ёK‘:ёL‘;ёM‘>ёN‘ЈёO‘ЅёP‘ЇёQ‘ЏёR‘ЊёS“ЕёT“ŒёU“’ёV“ЗёW“›ёX“ёY“‰ёZ“Їё[“Žё\“Њё]“žё^“Іё_“•ё`“ˆёa“™ёb“Ÿёc“ёd“Бёe“‘ёf“Вёg“Єёh“Јёi“Дёj“Ѓёk“Ѕёl•вёm•гёn•бёo–Гёp–зёq–кёr]Тёs–пёt–иёu–нёv—#ёw—"ёx—%ёy—Ќёz—Ўё{—Јё|—Ћё}—Єё~—ЊёЁ—ЂёЂ—ЅёЃ—зёЄ—йёЅ—жёІ—иёЇ—њёЈ˜PёЉ˜QёЊ˜RёЋ˜ИёЌ™Aё­™<ёЎ™:ёЏšёАš ёБš ёВš ёГšёДšёЕš ёЖšёЗšёИšёЙšРёКšмёЛ›ёМ›ёН›ёО›)ёП›5ёР›JёС›LёТ›KёУ›ЧёФ›ЦёХ›УёЦ›ПёЧ›СёШ›ЕёЩ›ИёЪ›гёЫ›ЖёЬ›ФёЭ›ЙёЮ›НёЯ\ёаSёбOёвJёг[ёдKёеYёжVёзLёиWёйRёкTёл_ёмXёнZёоžŽёпžŒёрžпёсŸётŸёуŸёфŸ%ёхŸ+ёцŸ*ёчŸ)ёшŸ(ёщŸLёъŸUёыQ4ёьQ5ёэR–ёюRїёяSДё№VЋёёV­ёђVІёѓVЇёєVЊёѕVЌёіXкёїXнёјXлёљYёњ[=ёћ[>ёќ[?ё§]Уёў^pђ@_ПђAaћђBeђCeђDe ђEe ђFe ђGeђHe„ђIeођJeнђKfођLjчђMjрђNjЬђOjбђPjйђQjЫђRjпђSjмђTjађUjыђVjЯђWjЭђXjођYk`ђZkАђ[l ђ\pђ]p'ђ^p ђ_pђ`p+ђap!ђbp"ђcp#ђdp)ђepђfp$ђgpђhp*ђir ђjr ђkrђlrђmrђnrЅђorІђprЄђqrЃђrrЁђstЫђttХђutЗђvtУђwuђxv`ђywЩђzwЪђ{wФђ|wёђ}yђ~yђЁy!ђЂyђЃyђЄyђЅyАђІzgђЇzhђЈ|3ђЉ|<ђЊ|9ђЋ|,ђЌ|;ђ­|ьђЎ|ъђЏ~vђА~uђБ~xђВ~pђГ~wђД~oђЕ~zђЖ~rђЗ~tђИ~hђЙKђКJђЛƒђМ†ђНЗђО§ђПўђР€xђСзђТеђУ‚dђФ‚aђХ‚cђЦ…ыђЧ…ёђШ…эђЩ…йђЪ…сђЫ…шђЬ…кђЭ…зђЮ…ьђЯ…ђђа…јђб…иђв…пђг…уђд…мђе…бђж…№ђз…цђи…яђй…ођк…тђлˆђм‡њђнˆђо‡іђп‡їђрˆ ђсˆ ђтˆ ђуˆђф‡ќђхˆђц‡џђчˆ ђшˆђщ‰bђъ‰Zђы‰[ђь‰Wђэ‰aђю‰\ђя‰Xђ№‰]ђё‰Yђђ‰ˆђѓ‰Зђє‰Жђѕ‰іђі‹Pђї‹Hђј‹Jђљ‹@ђњ‹Sђћ‹Vђќ‹Tђ§‹Kђў‹Uѓ@‹QѓA‹BѓB‹RѓC‹WѓDŒCѓEŒwѓFŒvѓGŒšѓHѓIѓJ ѓKЌѓLЊѓM­ѓNЋѓOŽmѓPŽxѓQŽsѓRŽjѓSŽoѓTŽ{ѓUŽТѓVRѓWQѓXOѓYPѓZSѓ[Дѓ\‘@ѓ]‘?ѓ^‘Аѓ_‘­ѓ`“оѓa“Чѓb“Яѓc“Тѓd“кѓe“аѓf“љѓg“ьѓh“Ьѓi“йѓj“Љѓk“цѓl“Ъѓm“дѓn“юѓo“уѓp“еѓq“Фѓr“Юѓs“Рѓt“вѓu“чѓv•}ѓw•кѓx•лѓy–сѓz—)ѓ{—+ѓ|—,ѓ}—(ѓ~—&ѓЁ—ГѓЂ—ЗѓЃ—ЖѓЄ—нѓЅ—оѓІ—пѓЇ˜\ѓЈ˜YѓЉ˜]ѓЊ˜WѓЋ˜ПѓЌ˜Нѓ­˜ЛѓЎ˜ОѓЏ™HѓА™GѓБ™CѓВ™ІѓГ™ЇѓДšѓЕšѓЖš%ѓЗšѓИš$ѓЙšѓКš"ѓЛš ѓМš'ѓНš#ѓОšѓПšѓРšѓСšТѓТ› ѓУ› ѓФ›ѓХ› ѓЦ›7ѓЧ›ъѓШ›ыѓЩ›рѓЪ›оѓЫ›фѓЬ›цѓЭ›тѓЮ›№ѓЯ›дѓа›зѓб›ьѓв›мѓг›йѓд›хѓе›еѓж›сѓз›кѓиwѓйѓкŠѓл„ѓмˆѓнqѓо€ѓпxѓр†ѓс‹ѓтŒѓу}ѓфkѓхtѓцuѓчpѓшiѓщ…ѓъsѓы{ѓь‚ѓэoѓюyѓяѓ№‡ѓёhѓђž”ѓѓž‘ѓєžРѓѕžќѓіŸ-ѓїŸ@ѓјŸAѓљŸMѓњŸVѓћŸWѓќŸXѓ§S7ѓўVВє@VЕєAVГєBXуєC[EєD]ЦєE]ЧєF^юєG^яєH_РєI_СєJaљєKeєLeєMeєNeєOeпєPfшєQfуєRfфєSjѓєTj№єUjъєVjшєWjљєXjёєYjюєZjяє[p<є\p5є]p/є^p7є_p4є`p1єapBєbp8єcp?єdp:єep9єfp@єgp;єhp3єipAєjrєkrєlrЈєms}єns|єotКєpvЋєqvЊєrvОєsvэєtwЬєuwЮєvwЯєwwЭєxwђєyy%єzy#є{y'є|y(є}y$є~y)єЁyВєЂznєЃzlєЄzmєЅzїєІ|IєЇ|HєЈ|JєЉ|GєЊ|EєЋ|юєЌ~{є­~~єЎ~єЏ~€єАКєБџєВ€yєГлєДйєЕ‚ єЖ‚hєЗ‚iєИ†"єЙ…џєК†єЛ…ўєМ†єН†єО…ієП†єР† єС†єТ† єУ…§єФˆєХˆєЦˆєЧˆєШˆєЩˆєЪ‰cєЫ‰fєЬ‰ЙєЭ‰їєЮ‹`єЯ‹jєа‹]єб‹hєв‹cєг‹eєд‹gєе‹mєжЎєзŽ†єиŽˆєйŽ„єкYєлVємWєнUєоXєпZєрєс‘Cєт‘Aєу‘Зєф‘Еєх‘Вєц‘Гєч” єш”єщ“ћєъ” єы”єь”єэ“ўєю”єя”є№”(єё”єђ” єѓ“ѕєє”єѕ“їєі”єї”єј”єљ”єњ“њєћ” єќ“јє§” єў“џѕ@“ќѕA” ѕB“іѕC”ѕD”ѕE•оѕF•рѕG•пѕH—.ѕI—/ѕJ—ЙѕK—ЛѕL—§ѕM—ўѕN˜`ѕO˜bѕP˜cѕQ˜_ѕR˜СѕS˜ТѕT™PѕU™NѕV™YѕW™LѕX™KѕY™SѕZš2ѕ[š4ѕ\š1ѕ]š,ѕ^š*ѕ_š6ѕ`š)ѕaš.ѕbš8ѕcš-ѕdšЧѕešЪѕfšЦѕg›ѕh›ѕi›ѕjœ ѕkœѕl›їѕmœѕnœѕo›јѕpœ@ѕqœѕrœѕsœѕtœѕuœѕvœ ѕwŸѕx™ѕyЄѕzѕ{’ѕ|˜ѕ}ѕ~›ѕЁ ѕЂ”ѕЃœѕЄЊѕЅ—ѕІЁѕЇšѕЈЂѕЉЈѕЊžѕЋЃѕЌПѕ­ЉѕЎ–ѕЏІѕАЇѕБž™ѕВž›ѕГžšѕДžхѕЕžфѕЖžчѕЗžцѕИŸ0ѕЙŸ.ѕКŸ[ѕЛŸ`ѕМŸ^ѕНŸ]ѕОŸYѕПŸ‘ѕРQ:ѕСQ9ѕТR˜ѕУR—ѕФVУѕХVНѕЦVОѕЧ[HѕШ[GѕЩ]ЫѕЪ]ЯѕЫ^ёѕЬa§ѕЭeѕЮkѕЯjќѕаkѕбjјѕвkѕгpCѕдpDѕеpJѕжpHѕзpIѕиpEѕйpFѕкrѕлrѕмrѕнs~ѕоuѕпvjѕрwаѕсy-ѕтy1ѕуy/ѕф|Tѕх|Sѕц|ђѕч~Šѕш~‡ѕщ~ˆѕъ~‹ѕы~†ѕь~ѕэMѕюЛѕя€0ѕ№нѕё†ѕђ†*ѕѓ†&ѕє†ѕѕ†#ѕі†ѕї†ѕј†'ѕљ†.ѕњ†!ѕћ† ѕќ†)ѕ§†ѕў†%і@ˆ)іAˆіBˆіCˆ іDˆ$іEˆіFˆ+іGˆJіH‰mіI‰iіJ‰nіK‰kіL‰њіM‹yіN‹xіO‹EіP‹zіQ‹{іRіSіTЏіUŽŽіVŽŒіW^іX[іY]іZ‘Fі[‘Dі\‘Eі]‘Йі^”?і_”;і`”6іa”)іb”=іc”<іd”0іe”9іf”*іg”7іh”,іi”@іj”1іk•хіl•фіm•уіn—5іo—:іp—Піq—сіr˜dіs˜Щіt˜Ціu˜Ріv™Xіw™Vіxš9іyš=іzšFі{šDі|šBі}šAі~š:іЁš?іЂšЭіЃ›іЄ›іЅ›іІ›іЇ›:іЈ›RіЉœ+іЊœіЋœіЌœ,і­œ#іЎœ(іЏœ)іАœ$іБœ!іВЗіГЖіДМіЕСіЖЧіЗЪіИЯіЙОіКХіЛУіМЛіНЕіОЮіПЙіРКіСЌіТШіУБіФ­іХЬіЦГіЧЭіШВіЩžzіЪžœіЫžыіЬžюіЭžэіЮŸіЯŸіаŸібŸ1івŸNігŸeідŸdіеŸ’іжNЙізVЦіиVХійVЫікYqіл[Kім[Lін]еіо]біп^ђірe!ісe ітe&іуe"іфk іхkіцk ічl ішpUіщpVіъpWіыpRіьrіэrіюrЉіяsі№tиіёtеіђtйіѓtзієvmіѕv­ііy5іїyДіјzpіљzqіњ|Wіћ|\іќ|Yі§|[іў|Zї@|єїA|ёїB~‘їCOїD‡їEоїF‚kїG†4їH†5їI†3їJ†,їK†2їL†6їMˆ,їNˆ(їOˆ&їPˆ*їQˆ%їR‰qїS‰ПїT‰ОїU‰ћїV‹~їW‹„їX‹‚їY‹†їZ‹…ї[‹ї\ї]Ž•ї^Ž”ї_Žšї`Ž’їaŽїbŽ–їcŽ—їd`їebїf‘Gїg”Lїh”Pїi”Jїj”Kїk”Oїl”Gїm”Eїn”Hїo”Iїp”Fїq—?їr—уїs˜jїt˜iїu˜Ыїv™Tїw™[їxšNїyšSїzšTї{šLї|šOї}šHї~šJїЁšIїЂšRїЃšPїЄšаїЅ›їІ›+їЇ›;їЈ›VїЉ›UїЊœFїЋœHїЌœ?ї­œDїЎœ9їЏœ3їАœAїБœ<їВœ7їГœ4їДœ2їЕœ=їЖœ6їЗлїИвїЙоїКкїЛЫїМаїНмїОбїПпїРщїСйїТиїУжїФѕїХеїЦнїЧžЖїШž№їЩŸ5їЪŸ3їЫŸ2їЬŸBїЭŸkїЮŸ•їЯŸЂїаQ=їбR™ївXшїгXчїдYrїе[Mїж]иїзˆ/їи_Oїйbїкbїлbїмe)їнe%їоe–їпfыїрkїсkїтkїуkЪїфp[їхpZїцr"їчs‚їшsїщsƒїъvpїыwдїь|gїэ|fїю~•їя‚lї№†:їё†@їђ†9їѓ†<їє†1їѕ†;їі†>їїˆ0їјˆ2їљˆ.їњˆ3їћ‰vїќ‰tї§‰sїў‰ўј@‹ŒјA‹ŽјB‹‹јC‹ˆјDŒEјEјFŽ˜јGdјHcјI‘МјJ”bјK”UјL”]јM”WјN”^јO—ФјP—ХјQ˜јRšVјSšYјT›јU›јV› јWœRјXœXјYœPјZœJј[œMј\œKј]œUј^œYј_œLј`œNјaћјbїјcяјdујeыјfјјgфјhіјiсјjюјkцјlђјm№јnтјoьјpєјqѓјrшјsэјtžТјužајvžђјwžѓјxŸјyŸјzŸ8ј{Ÿ7ј|Ÿ6ј}ŸCј~ŸOјЁŸqјЂŸpјЃŸnјЄŸoјЅVгјІVЭјЇ[NјЈ\mјЉe-јЊfэјЋfюјЌkј­p_јЎpaјЏp]јАp`јБr#јВtлјГtхјДwејЕy8јЖyЗјЗyЖјИ|jјЙ~—јК‰јЛ‚mјМ†CјНˆ8јОˆ7јПˆ5јРˆKјС‹”јТ‹•јУŽžјФŽŸјХŽ јЦŽјЧ‘ОјШ‘НјЩ‘ТјЪ”kјЫ”hјЬ”iјЭ–хјЮ—FјЯ—Cја—Gјб—Чјв—хјгš^јдšеје›Yјжœcјзœgјиœfјйœbјкœ^јлœ`јмžјнўјоžјпžјрžјсžјтžјуžјфž јхџјц§јчžјшž јщŸјъŸFјыŸtјьŸuјэŸvјюVдјяe.ј№eИјёkјђkјѓkјєkјѕpbјіr&јїrЊјјwијљwйјњy9јћ|iјќ|kј§|іјў~šљ@~˜љA~›љB~™љCрљDсљE†FљF†GљG†HљH‰yљI‰zљJ‰|љK‰{љL‰џљM‹˜љN‹™љOŽЅљPŽЄљQŽЃљR”nљS”mљT”oљU”qљV”sљW—IљX˜rљY™_љZœhљ[œnљ\œmљ]ž љ^ž љ_žљ`žљažљbžљcžЁљdžѕљeŸ љfŸGљgŸxљhŸ{љiŸzљjŸyљkWљlpfљm|oљnˆ<љoВљpŽІљq‘Уљr”tљs”xљt”vљu”uљvš`љwœtљxœsљyœqљzœuљ{žљ|žљ}žіљ~Ÿ љЁŸЄљЂphљЃpeљЄ|їљЅ†jљІˆ>љЇˆ=љЈˆ?љЉ‹žљЊŒœљЋŽЉљЌŽЩљ­—KљЎ˜sљЏ˜tљА˜ЬљБ™aљВ™ЋљГšdљДšfљЕšgљЖ›$љЗžљИžљЙŸHљКbљЛkљМr'љН†LљОŽЈљП”‚љР”€љС”љТšiљУšhљФ›.љХžљЦr)љЧ†KљШ‹ŸљЩ”ƒљЪœyљЫžЗљЬvuљЭškљЮœzљЯžљаpiљбpjљвžЄљгŸ~љдŸIљеŸ˜љжxљз’ЙљиˆЯљйXЛљк`Rљл|ЇљмZњљн%Tљо%fљп%Wљр%`љс%lљт%cљу%Zљф%iљх%]љц%Rљч%dљш%Uљщ%^љъ%jљы%aљь%Xљэ%gљю%[љя%Sљ№%eљё%Vљђ%_љѓ%kљє%bљѕ%Yљі%hљї%\љј%Qљљ%Pљњ%mљћ%nљќ%pљ§%oљў%“ecl-16.1.2/contrib/encodings/generate.lisp000066400000000000000000000112261266352375300204560ustar00rootroot00000000000000;;; -*- Mode: Lisp; Syntax: Common-Lisp; -*- ;;; ;;; Copyright (c) 2009, Juan Jose Garcia-Ripoll ;;; ;;; This program is free software; you can redistribute it and/or ;;; modify it under the terms of the GNU Library General Public ;;; License as published by the Free Software Foundation; either ;;; version 2 of the License, or (at your option) any later version. ;;; ;;; See file '../Copyright' for full details. (load (merge-pathnames "tools" *load-pathname*)) (defconstant +encodings-root+ (translate-logical-pathname #p"ext:encodings;")) (loop for entry in +all-mappings+ for name = (first entry) for orig = (make-pathname :name name :type "BIN" :defaults +encodings-root+) for copy = (ensure-directories-exist (make-pathname :name name :type "BIN" :defaults "build:encodings;")) do (progn (unless (probe-file orig) (error "Missing mapping") (let ((mapping (if (equalp name "JISX0208") (mapcar #'rest (read-mapping name 3)) (read-mapping name)))) (dump-mapping-array mapping orig))) (copy-encoding-file orig copy))) (defconstant +aliases+ '((:us-ascii ext::ascii) (:utf-8 ext::utf8) (:ucs-2 ext::ucs2 ext::utf-16 ext::utf16 ext::unicode) (:ucs-2le ext::ucs2le ext::utf-16le) (:ucs-2be ext::ucs2be ext::utf-16be) (:ucs-4 ext::ucs4 ext::utf-32 ext::utf32) (:ucs-4be ext::ucs4be ext::utf-32be) (:ucs-4le ext::ucs4le ext::utf-32le) (ext::koi8-r ext::koi8r) (ext::iso-8859-1 ext::iso8859-1 ext::latin-1 ext::cp819 ext::ibm819) (ext::iso-8859-2 ext::iso8859-2 ext::latin-2 ext::latin2) (ext::iso-8859-3 ext::iso8859-3 ext::latin-3 ext::latin3) (ext::iso-8859-4 ext::iso8859-4 ext::latin-4 ext::latin4) (ext::iso-8859-5 ext::iso8859-5 ext::cyrillic) (ext::iso-8859-6 ext::iso8859-6 ext::arabic ext::asmo-708 ext::ecma-114) (ext::iso-8859-7 ext::iso8859-7 ext::greek8 ext::greek ext::ecma-118) (ext::iso-8859-8 ext::iso8859-8 ext::hebrew) (ext::iso-8859-9 ext::iso8859-9 ext::latin-5 ext::latin5) (ext::iso-8859-10 ext::iso8859-10 ext::latin-6 ext::latin6) ;(:iso-8859-11 :iso8859-11 :thai) (ext::iso-8859-13 ext::iso8859-13 ext::latin-7 ext::latin7) (ext::iso-8859-14 ext::iso8859-14 ext::latin-8 ext::latin8) (ext::iso-8859-15 ext::iso8859-15 ext::latin-9 ext::latin9) (ext::dos-cp437 ext::ibm437) (ext::dos-cp850 ext::ibm850 ext::cp850) (ext::dos-cp852 ext::ibm852) (ext::dos-cp855 ext::ibm855) (ext::dos-cp857 ext::ibm857) (ext::dos-cp860 ext::ibm860) (ext::dos-cp861 ext::ibm861) (ext::dos-cp862 ext::ibm862 ext::cp862) (ext::dos-cp863 ext::ibm863) (ext::dos-cp864 ext::ibm864) (ext::dos-cp865 ext::ibm865) (ext::dos-cp866 ext::ibm866 ext::cp866) (ext::dos-cp869 ext::ibm869) (ext::windows-cp932 ext::windows-932 ext::cp932) (ext::windows-cp936 ext::windows-936 ext::cp936) (ext::windows-cp949 ext::windows-949 ext::cp949) (ext::windows-cp950 ext::windows-950 ext::cp950) (ext::windows-cp1250 ext::windows-1250 ext::ms-ee) (ext::windows-cp1251 ext::windows-1251 ext::ms-cyrl) (ext::windows-cp1252 ext::windows-1252 ext::ms-ansi) (ext::windows-cp1253 ext::windows-1253 ext::ms-greek) (ext::windows-cp1254 ext::windows-1254 ext::ms-turk) (ext::windows-cp1255 ext::windows-1255 ext::ms-hebr) (ext::windows-cp1256 ext::windows-1256 ext::ms-arab) (ext::windows-cp1257 ext::windows-1257 ext::winbaltrim) (ext::windows-cp1258 ext::windows-1258) )) (loop for (name . aliases) in +aliases+ do (loop with *package* = (find-package "CL") for alias in aliases for filename0 = (make-pathname :name (symbol-name alias) :defaults "build:encodings;") for filename = (ensure-directories-exist filename0) do (with-open-file (out filename :direction :output :if-exists :supersede :if-does-not-exist :create :element-type 'base-char) (format t "~%;;; Creating alias ~A -> ~A, ~A" alias name filename) (if (keywordp name) (format out "(defparameter ~S '~S)" alias name) (format out "(defparameter ~S (ext::make-encoding '~S))" alias name)) ))) (copy-encoding-file "ext:encodings;tools.lisp" "build:encodings;tools.lisp") (copy-encoding-file (merge-pathnames "ISO-2022-JP" +encodings-root+) "build:encodings;ISO-2022-JP") (copy-encoding-file (merge-pathnames "ISO-2022-JP-1" +encodings-root+) "build:encodings;ISO-2022-JP-1") ecl-16.1.2/contrib/encodings/tools.lisp000066400000000000000000000245151266352375300200310ustar00rootroot00000000000000;;; -*- Mode: Lisp; Syntax: Common-Lisp; -*- ;;; ;;; Copyright (c) 2009, Juan Jose Garcia-Ripoll ;;; ;;; This program is free software; you can redistribute it and/or ;;; modify it under the terms of the GNU Library General Public ;;; License as published by the Free Software Foundation; either ;;; version 2 of the License, or (at your option) any later version. ;;; ;;; See file '../Copyright' for full details. (defconstant +sequence-type+ '(unsigned-byte 16)) (defconstant +source-pathname+ (make-pathname :name nil :type nil :directory (append (pathname-directory *load-pathname*) (list "sources")) :host (pathname-host *load-pathname*) :device (pathname-device *load-pathname*))) (defconstant +all-mappings+ '(("ATARIST" "http://unicode.org/Public/MAPPINGS/VENDORS/MISC/ATARIST.TXT") ("ISO-8859-1" "http://unicode.org/Public/MAPPINGS/ISO8859/8859-1.TXT") ("ISO-8859-2" "http://unicode.org/Public/MAPPINGS/ISO8859/8859-2.TXT") ("ISO-8859-3" "http://unicode.org/Public/MAPPINGS/ISO8859/8859-3.TXT") ("ISO-8859-4" "http://unicode.org/Public/MAPPINGS/ISO8859/8859-4.TXT") ("ISO-8859-5" "http://unicode.org/Public/MAPPINGS/ISO8859/8859-5.TXT") ("ISO-8859-6" "http://unicode.org/Public/MAPPINGS/ISO8859/8859-6.TXT") ("ISO-8859-7" "http://unicode.org/Public/MAPPINGS/ISO8859/8859-7.TXT") ("ISO-8859-8" "http://unicode.org/Public/MAPPINGS/ISO8859/8859-8.TXT") ("ISO-8859-9" "http://unicode.org/Public/MAPPINGS/ISO8859/8859-9.TXT") ("ISO-8859-10" "http://unicode.org/Public/MAPPINGS/ISO8859/8859-10.TXT") ("ISO-8859-11" "http://unicode.org/Public/MAPPINGS/ISO8859/8859-11.TXT") ("ISO-8859-13" "http://unicode.org/Public/MAPPINGS/ISO8859/8859-13.TXT") ("ISO-8859-14" "http://unicode.org/Public/MAPPINGS/ISO8859/8859-14.TXT") ("ISO-8859-15" "http://unicode.org/Public/MAPPINGS/ISO8859/8859-15.TXT") ("ISO-8859-16" "http://unicode.org/Public/MAPPINGS/ISO8859/8859-16.TXT") ("KOI8-R" "http://unicode.org/Public/MAPPINGS/VENDORS/MISC/KOI8-R.TXT") ("KOI8-U" "http://unicode.org/Public/MAPPINGS/VENDORS/MISC/KOI8-U.TXT") ("CP-856" "http://unicode.org/Public/MAPPINGS/VENDORS/MISC/CP856.TXT") ("CP-856" "http://unicode.org/Public/MAPPINGS/VENDORS/MISC/CP856.TXT") ("DOS-CP437" "http://unicode.org/Public/MAPPINGS/VENDORS/MICSFT/PC/CP437.TXT") ("DOS-CP737" "http://unicode.org/Public/MAPPINGS/VENDORS/MICSFT/PC/CP737.TXT") ("DOS-CP775" "http://unicode.org/Public/MAPPINGS/VENDORS/MICSFT/PC/CP775.TXT") ("DOS-CP850" "http://unicode.org/Public/MAPPINGS/VENDORS/MICSFT/PC/CP850.TXT") ("DOS-CP852" "http://unicode.org/Public/MAPPINGS/VENDORS/MICSFT/PC/CP852.TXT") ("DOS-CP855" "http://unicode.org/Public/MAPPINGS/VENDORS/MICSFT/PC/CP855.TXT") ("DOS-CP857" "http://unicode.org/Public/MAPPINGS/VENDORS/MICSFT/PC/CP857.TXT") ("DOS-CP860" "http://unicode.org/Public/MAPPINGS/VENDORS/MICSFT/PC/CP860.TXT") ("DOS-CP861" "http://unicode.org/Public/MAPPINGS/VENDORS/MICSFT/PC/CP861.TXT") ("DOS-CP862" "http://unicode.org/Public/MAPPINGS/VENDORS/MICSFT/PC/CP862.TXT") ("DOS-CP863" "http://unicode.org/Public/MAPPINGS/VENDORS/MICSFT/PC/CP863.TXT") ("DOS-CP864" "http://unicode.org/Public/MAPPINGS/VENDORS/MICSFT/PC/CP864.TXT") ("DOS-CP865" "http://unicode.org/Public/MAPPINGS/VENDORS/MICSFT/PC/CP865.TXT") ("DOS-CP866" "http://unicode.org/Public/MAPPINGS/VENDORS/MICSFT/PC/CP866.TXT") ("DOS-CP869" "http://unicode.org/Public/MAPPINGS/VENDORS/MICSFT/PC/CP869.TXT") ("DOS-CP874" "http://unicode.org/Public/MAPPINGS/VENDORS/MICSFT/PC/CP874.TXT") ; Redundant WINDOWS-CP874 DOS-CP874 ;("WINDOWS-CP874" "http://unicode.org/Public/MAPPINGS/VENDORS/MICSFT/WINDOWS/CP874.TXT") ("WINDOWS-CP932" "http://unicode.org/Public/MAPPINGS/VENDORS/MICSFT/WINDOWS/CP932.TXT") ("WINDOWS-CP936" "http://unicode.org/Public/MAPPINGS/VENDORS/MICSFT/WINDOWS/CP936.TXT") ("WINDOWS-CP949" "http://unicode.org/Public/MAPPINGS/VENDORS/MICSFT/WINDOWS/CP949.TXT") ("WINDOWS-CP950" "http://unicode.org/Public/MAPPINGS/VENDORS/MICSFT/WINDOWS/CP950.TXT") ("WINDOWS-CP1250" "http://unicode.org/Public/MAPPINGS/VENDORS/MICSFT/WINDOWS/CP1250.TXT") ("WINDOWS-CP1251" "http://unicode.org/Public/MAPPINGS/VENDORS/MICSFT/WINDOWS/CP1251.TXT") ("WINDOWS-CP1252" "http://unicode.org/Public/MAPPINGS/VENDORS/MICSFT/WINDOWS/CP1252.TXT") ("WINDOWS-CP1253" "http://unicode.org/Public/MAPPINGS/VENDORS/MICSFT/WINDOWS/CP1253.TXT") ("WINDOWS-CP1254" "http://unicode.org/Public/MAPPINGS/VENDORS/MICSFT/WINDOWS/CP1254.TXT") ("WINDOWS-CP1255" "http://unicode.org/Public/MAPPINGS/VENDORS/MICSFT/WINDOWS/CP1255.TXT") ("WINDOWS-CP1256" "http://unicode.org/Public/MAPPINGS/VENDORS/MICSFT/WINDOWS/CP1256.TXT") ("WINDOWS-CP1257" "http://unicode.org/Public/MAPPINGS/VENDORS/MICSFT/WINDOWS/CP1257.TXT") ("WINDOWS-CP1258" "http://unicode.org/Public/MAPPINGS/VENDORS/MICSFT/WINDOWS/CP1258.TXT") ("JISX0201" "http://unicode.org/Public/MAPPINGS/OBSOLETE/EASTASIA/JIS/JIS0201.TXT") ("JISX0208" "http://unicode.org/Public/MAPPINGS/OBSOLETE/EASTASIA/JIS/JIS0208.TXT" ;; Fixes compatible with libiconv: we replace a reverse solidus with a ;; fullwidth reverse solidus, so that JISX0208 does not contain characters ;; in the ASCII range (Needed by ISO-2022-JP-1) ((#x815F #x2140 #xff3c))) ("JISX0212" "http://unicode.org/Public/MAPPINGS/OBSOLETE/EASTASIA/JIS/JIS0212.TXT" ;; Fixes compatible with libiconv: we replace a tilde with a ;; fullwidth tilde, so that JISX0212 does not contain characters ;; in the ASCII range (Needed by ISO-2022-JP-1) ((#x2237 #xff5e))) ("SHIFT-JIS" "http://unicode.org/Public/MAPPINGS/OBSOLETE/EASTASIA/JIS/SHIFTJIS.TXT") ;Unable to parse because they output more than one Unicode character ;("SJIS-0213" "http://x0213.org/codetable/sjis-0213-2004-std.txt") ;("EUC-JISX0213" "http://x0213.org/codetable/euc-jis") )) (defun download (filename url) (unless (probe-file filename) (let ((command (format nil "curl \"~A\" > ~A" url filename))) (unless (zerop (si::system command)) (error "Unable to retrieve file ~A" url))))) (defun reformat (line) (loop with l = (length line) for i from 0 below l for c = (char line i) do (cond ((eql c #\#) (return (if (zerop i) "" (subseq line 0 (1- i))))) ((not (standard-char-p c)) (setf (char line i) #\space)) ((and (eql c #\0) (let ((j (1+ i))) (and (< j l) (member (char line j) '(#\x #\X))))) (setf (char line i) #\#))) finally (return line))) (defun read-mapping (name &optional (n 2)) (let* ((source-file (make-pathname :name name :defaults +source-pathname+)) (record (find name +all-mappings+ :key #'first :test #'equalp)) (fixes (third record)) (source-url (fourth record))) (unless (probe-file source-file) (unless source-url (error "Unknown encoding ~A" name)) (download file source-url)) (with-open-file (in source-file :direction :input) (loop with output = '() for line = (reformat (read-line in nil nil)) while line unless (zerop (length line)) do (with-input-from-string (aux line) (let ((byte-list (loop for byte = (read aux nil nil) while byte collect byte))) (unless (/= (length byte-list) n) (loop for i in fixes when (= (first i) (first byte-list)) do (progn (setf byte-list i) (return))) (push byte-list output)))) finally (return (nreverse output)))))) (defun mapping-hash-table (mapping) (loop with hash = (make-hash-table :size (floor (* 1.5 (length mapping))) :test 'eq) for (multibyte codepoint) in mapping for unicode-char = (code-char codepoint) do (progn (setf (gethash multibyte hash) unicode-char) (setf (gethash unicode-char hash) multibyte) (when (> multibyte #xFF) (setf (gethash (ash multibyte -8) hash) t))) finally (return hash))) (defun dump-mapping-array (mapping-assoc output-file) (let* ((mapping-list (reduce #'nconc mapping-assoc)) (mapping-array (make-array (length mapping-list) :element-type +sequence-type+ :initial-contents mapping-list))) (format t "~%;;; Generating ~A" output-file) (force-output t) (with-open-file (s output-file :direction :output :if-exists :supersede :element-type +sequence-type+ :external-format :big-endian) (write-byte (length mapping-array) s) (write-sequence mapping-array s)))) (defun copy-encoding-file (in out) (let ((buffer (make-array 8192 :element-type '(unsigned-byte 8)))) (format t "~%;;; Copying ~A to ~A" in out) (with-open-file (sin in :direction :input :element-type '(unsigned-byte 8)) (with-open-file (sout out :direction :output :element-type '(unsigned-byte 8) :if-exists :supersede :if-does-not-exist :create) (loop for nbytes = (read-sequence buffer sin) until (zerop nbytes) do (write-sequence buffer sout :end nbytes)))))) (defun all-valid-unicode-chars (mapping) (cond ((consp mapping) (loop for sublist on mapping for i from 0 below 10 until (and (eq sublist mapping) (plusp i)) collect (all-valid-unicode-chars (first sublist)))) ((hash-table-p mapping) (concatenate 'string (loop for key being the hash-key in mapping when (characterp key) collect key))) ((eq mapping :iso-8859-1) (coerce 'string (loop for i from 0 to 255 collect (code-char i)))) (t (error "Unknown encoding")))) (defun compare-hashes (h1 h2) (flet ((h1-in-h2 (h1 h2) (loop for k being the hash-key in h1 using (hash-value v) for v2 = (gethash k h2 nil) unless (or (consp v2) (consp v) (equal v v2)) do (progn (print (list h1 k v h2 k v2)) (error) (return nil)) finally (return t)))) (and (h1-in-h2 h1 h2) (h1-in-h2 h2 h1)))) ecl-16.1.2/contrib/profile/000077500000000000000000000000001266352375300154605ustar00rootroot00000000000000ecl-16.1.2/contrib/profile/profile.lisp000066400000000000000000000530161266352375300200160ustar00rootroot00000000000000;;;; This software is part of the SBCL system. See the README file for ;;;; more information. ;;;; ;;;; This software is derived from the CMU CL system, which was ;;;; written at Carnegie Mellon University and released into the ;;;; public domain. The software is in the public domain and is ;;;; provided with absolutely no warranty. See the COPYING and CREDITS ;;;; files for more information. (eval-when (:compile-toplevel :load-toplevel) (defpackage "PROFILE" (:nicknames "PROF" "SB-PROFILE") (:export "PROFILE" "REPORT" "RESET" "UNPROFILE" "UNPROFILE-ALL")) ) (in-package "PROFILE") ;;;; reading internal run time with high resolution and low overhead (defconstant +ticks-per-second+ internal-time-units-per-second) #+threads (defvar *profile-lock* (mp:make-lock)) (eval-when (:compile-toplevel :execute) (defmacro get-internal-ticks () '(get-internal-run-time)) (defmacro gethash-locked (&rest args) `(mp:with-lock (*profile-lock*) (gethash ,@args))) (defmacro remhash-locked (&rest args) `(mp:with-lock (*profile-lock*) (remhash ,@args))) (defmacro remhash-locked (&rest args) `(mp:with-lock (*profile-lock*) (remhash ,@args))) (defmacro sethash-locked (hash key value) `(mp:with-lock (*profile-lock*) (setf (gethash ,hash ,key) ,value))) (defmacro dohash (((key value) hash &key locked) &body body) (let* ((it (gensym)) (entry (gensym)) (body `(with-hash-table-iterator (,it ,hash) (loop (multiple-value-bind (,entry ,key ,value) (,it) (unless ,entry (return)) (let () ,@body)))))) (if locked `(mp:with-lock (*profile-lock*) ,body) body))) (defmacro without-package-locks (&rest body) `(progn ,@body)) ) (ffi:clines " extern ECL_API size_t GC_get_total_bytes(); ") (let () ; This prevents compile-time evaluation of the following (defconstant +wrap+ (ffi:c-inline () () :object "ecl_make_unsigned_integer(~((size_t)0))" :one-liner t))) (defun get-bytes-consed (orig) (let ((bytes (ffi:c-inline () () :object "ecl_make_unsigned_integer(GC_get_total_bytes())" :one-liner t))) (if (< bytes orig) (+ (- +wrap+ orig) bytes) (- bytes orig)))) (deftype counter () '(integer 0 *)) ;;;; implementation-dependent interfaces #| ;;; To avoid unnecessary consing in the "encapsulation" code, we want ;;; find out the number of required arguments, and use &REST to ;;; capture only non-required arguments. This function returns (VALUES ;;; MIN-ARGS OPTIONALS-P), where MIN-ARGS is the number of required ;;; arguments and OPTIONALS-P is true iff there are any non-required ;;; arguments (such as &OPTIONAL, &REST, or &KEY). (declaim (ftype (function ((or symbol cons)) (values fixnum t)) fun-signature)) (defun fun-signature (name) (let ((type (info :function :type name))) (cond ((not (fun-type-p type)) (values 0 t)) (t (values (length (fun-type-required type)) (or (fun-type-optional type) (fun-type-keyp type) (fun-type-rest type))))))) |# ;;;; global data structures ;;; We associate a PROFILE-INFO structure with each profiled function ;;; name. This holds the functions that we call to manipulate the ;;; closure which implements the encapsulation. (defvar *profiled-fun-name->info* (make-hash-table ;; EQL testing isn't good enough for generalized function names ;; like (SETF FOO). :test 'equal)) (defstruct (profile-info (:copier nil)) (name (missing-arg) :read-only t) (encapsulated-fun (missing-arg) :type function :read-only t) (encapsulation-fun (missing-arg) :type function :read-only t) (read-stats-fun (missing-arg) :type function :read-only t) (clear-stats-fun (missing-arg) :type function :read-only t)) ;;; These variables are used to subtract out the time and consing for ;;; recursive and other dynamically nested profiled calls. The total ;;; resource consumed for each nested call is added into the ;;; appropriate variable. When the outer function returns, these ;;; amounts are subtracted from the total. (defvar *enclosed-ticks* 0) (defvar *enclosed-consing* 0) (declaim (type counter *enclosed-ticks* *enclosed-consing*)) ;;; This variable is also used to subtract out time for nested ;;; profiled calls. The time inside the profile wrapper call -- ;;; between its two calls to GET-INTERNAL-TICKS -- is accounted ;;; for by the *ENCLOSED-TIME* variable. However, there's also extra ;;; overhead involved, before we get to the first call to ;;; GET-INTERNAL-TICKS, and after we get to the second call. By ;;; keeping track of the count of enclosed profiled calls, we can try ;;; to compensate for that. (defvar *enclosed-profiles* 0) (declaim (type counter *enclosed-profiles*)) ;;; the encapsulated function we're currently computing profiling data ;;; for, recorded so that we can detect the problem of ;;; PROFILE-computing machinery calling a function which has itself ;;; been PROFILEd (defvar *computing-profiling-data-for*) ;;; the components of profiling overhead (defstruct (overhead (:copier nil)) ;; the number of ticks a bare function call takes. This is ;; factored into the other overheads, but not used for itself. (call (missing-arg) :type single-float :read-only t) ;; the number of ticks that will be charged to a profiled ;; function due to the profiling code (internal (missing-arg) :type single-float :read-only t) ;; the number of ticks of overhead for profiling that a single ;; profiled call adds to the total runtime for the program (total (missing-arg) :type single-float :read-only t)) (defvar *overhead*) (declaim (type overhead *overhead*)) (makunbound '*overhead*) ; in case we reload this file when tweaking ;;;; profile encapsulations ;;; Trade off space for time by handling the usual all-FIXNUM cases inline. (eval-when (:compile-toplevel) (defmacro fastbig- (x y) `(- ,x ,y)) (defmacro fastbig-1+ (x) `(1+ ,x))) ;;; Return a collection of closures over the same lexical context, ;;; (VALUES ENCAPSULATION-FUN READ-STATS-FUN CLEAR-STATS-FUN). ;;; ;;; ENCAPSULATION-FUN is a plug-in replacement for ENCAPSULATED-FUN, ;;; which updates statistics whenever it's called. ;;; ;;; READ-STATS-FUN returns the statistics: ;;; (VALUES COUNT TIME CONSING PROFILE). ;;; COUNT is the count of calls to ENCAPSULATION-FUN. TICKS is ;;; the total number of ticks spent in ENCAPSULATED-FUN. ;;; CONSING is the total consing of ENCAPSULATION-FUN. PROFILE is the ;;; number of calls to the profiled function, stored for the purposes ;;; of trying to estimate that part of profiling overhead which occurs ;;; outside the interval between the profile wrapper function's timer ;;; calls. ;;; ;;; CLEAR-STATS-FUN clears the statistics. ;;; ;;; (The reason for implementing this as coupled closures, with the ;;; counts built into the lexical environment, is that we hope this ;;; will minimize profiling overhead.) (defun profile-encapsulation-lambdas (encapsulated-fun) (declare (type function encapsulated-fun)) (let* ((count 0) (ticks 0) (consing 0) (profiles 0)) (declare (type counter count ticks consing profiles)) (values ;; ENCAPSULATION-FUN (lambda (&rest args) (declare (optimize speed safety)) ;; Make sure that we're not recursing infinitely. (when (boundp '*computing-profiling-data-for*) (unprofile-all) ; to avoid further recursion (error "~@" *computing-profiling-data-for* encapsulated-fun encapsulated-fun)) ;; FIXME: Probably when this is stable, we should optimize (SAFETY 0). (incf count 1) (let ((dticks 0) (dconsing 0) (inner-enclosed-profiles 0) (old-enclosed-ticks *enclosed-ticks*) (old-enclosed-consing *enclosed-consing*) (old-enclosed-profiles *enclosed-profiles*) (start-ticks (get-internal-ticks)) (start-consed (get-bytes-consed 0))) (unwind-protect (progn (setf *enclosed-ticks* 0 *enclosed-profiles* 0 *enclosed-consing* 0) (apply encapsulated-fun args)) (setf dticks (- (get-internal-ticks) start-ticks)) (setf dconsing (get-bytes-consed start-consed)) (setf inner-enclosed-profiles *enclosed-profiles*) (let ((net-dticks (- dticks *enclosed-ticks*))) (incf ticks net-dticks)) (let ((net-dconsing (- dconsing *enclosed-consing*))) (incf consing net-dconsing)) (incf profiles inner-enclosed-profiles) (setf *enclosed-ticks* (+ old-enclosed-ticks dticks) *enclosed-consing* (+ old-enclosed-consing dconsing) *enclosed-profiles* (+ old-enclosed-profiles inner-enclosed-profiles 1))))) ;; READ-STATS-FUN (lambda () (values count ticks consing profiles)) ;; CLEAR-STATS-FUN (lambda () (setf count 0 ticks 0 consing 0 profiles 0))))) ;;;; interfaces ;;; A symbol or (SETF FOO) list names a function, a string names all ;;; the functions named by symbols in the named package. (defun mapc-on-named-funs (function names) (dolist (name names) (etypecase name (symbol (funcall function name)) (list (legal-fun-name-or-type-error name) ;; Then we map onto it. (funcall function name)) (string (let ((package (si:coerce-to-package name))) (do-symbols (symbol package) (when (eq (symbol-package symbol) package) (when (and (fboundp symbol) (not (macro-function symbol)) (not (special-operator-p symbol))) (funcall function symbol)) (let ((setf-name `(setf ,symbol))) (when (fboundp setf-name) (funcall function setf-name))))))))) (values)) ;;; Profile the named function, which should exist and not be profiled ;;; already. (defun profile-1-unprofiled-fun (name) (let ((encapsulated-fun (fdefinition name))) (multiple-value-bind (encapsulation-fun read-stats-fun clear-stats-fun) (profile-encapsulation-lambdas encapsulated-fun) (without-package-locks (setf (fdefinition name) encapsulation-fun)) (sethash-locked name *profiled-fun-name->info* (make-profile-info :name name :encapsulated-fun encapsulated-fun :encapsulation-fun encapsulation-fun :read-stats-fun read-stats-fun :clear-stats-fun clear-stats-fun)) (values)))) ;;; Profile the named function. If already profiled, unprofile first. (defun profile-1-fun (name) (cond ((fboundp name) (when (gethash-locked name *profiled-fun-name->info*) (warn "~S is already profiled, so unprofiling it first." name) (unprofile-1-fun name)) (profile-1-unprofiled-fun name)) (t (warn "ignoring undefined function ~S" name))) (values)) ;;; Unprofile the named function, if it is profiled. (defun unprofile-1-fun (name) (let ((pinfo (gethash-locked name *profiled-fun-name->info*))) (cond (pinfo (remhash-locked name *profiled-fun-name->info*) (if (eq (fdefinition name) (profile-info-encapsulation-fun pinfo)) (without-package-locks (setf (fdefinition name) (profile-info-encapsulated-fun pinfo))) (warn "preserving current definition of redefined function ~S" name))) (t (warn "~S is not a profiled function." name)))) (values)) (defmacro profile (&rest names) "PROFILE Name* If no names are supplied, return the list of profiled functions. If names are supplied, wrap profiling code around the named functions. As in TRACE, the names are not evaluated. A symbol names a function. A string names all the functions named by symbols in the named package. If a function is already profiled, then unprofile and reprofile (useful to notice function redefinition.) If a name is undefined, then we give a warning and ignore it. See also UNPROFILE, REPORT and RESET." (if (null names) `(loop for k being each hash-key in *profiled-fun-name->info* collecting k) `(mapc-on-named-funs #'profile-1-fun ',names))) (defmacro unprofile (&rest names) "Unwrap any profiling code around the named functions, or if no names are given, unprofile all profiled functions. A symbol names a function. A string names all the functions named by symbols in the named package. NAMES defaults to the list of names of all currently profiled functions." (if names `(mapc-on-named-funs #'unprofile-1-fun ',names) `(unprofile-all))) (defun unprofile-all () (dohash ((name profile-info) *profiled-fun-name->info* :locked t) (declare (ignore profile-info)) (unprofile-1-fun name))) (defun reset () "Reset the counters for all profiled functions." (dohash ((name profile-info) *profiled-fun-name->info* :locked t) (declare (ignore name)) (funcall (profile-info-clear-stats-fun profile-info)))) ;;;; reporting results (defstruct (time-info (:copier nil)) name calls seconds consing) ;;; Return our best guess for the run time in a function, subtracting ;;; out factors for profiling overhead. We subtract out the internal ;;; overhead for each call to this function, since the internal ;;; overhead is the part of the profiling overhead for a function that ;;; is charged to that function. ;;; ;;; We also subtract out a factor for each call to a profiled function ;;; within this profiled function. This factor is the total profiling ;;; overhead *minus the internal overhead*. We don't subtract out the ;;; internal overhead, since it was already subtracted when the nested ;;; profiled functions subtracted their running time from the time for ;;; the enclosing function. (defun compensate-time (calls ticks profile) (let ((raw-compensated (- (/ (float ticks) (float +ticks-per-second+)) (* (overhead-internal *overhead*) (float calls)) (* (- (overhead-total *overhead*) (overhead-internal *overhead*)) (float profile))))) (max raw-compensated 0.0))) (defun report () "Report results from profiling. The results are approximately adjusted for profiling overhead. The compensation may be rather inaccurate when bignums are involved in runtime calculation, as in a very-long-running Lisp process." (unless (boundp '*overhead*) (setf *overhead* (compute-overhead))) (let ((time-info-list ()) (no-call-name-list ())) (dohash ((name pinfo) *profiled-fun-name->info* :locked t) (unless (eq (fdefinition name) (profile-info-encapsulation-fun pinfo)) (warn "Function ~S has been redefined, so times may be inaccurate.~@ PROFILE it again to record calls to the new definition." name)) (multiple-value-bind (calls ticks consing profile) (funcall (profile-info-read-stats-fun pinfo)) (if (zerop calls) (push name no-call-name-list) (push (make-time-info :name name :calls calls :seconds (compensate-time calls ticks profile) :consing consing) time-info-list)))) (setf time-info-list (sort time-info-list #'>= :key #'time-info-seconds)) (print-profile-table time-info-list) (when no-call-name-list (format *trace-output* "~%These functions were not called:~%~{~<~%~:; ~S~>~}~%" (sort no-call-name-list #'string< :key (lambda (name) (symbol-name (if (consp name) (cadr name) name)))))) (values))) (defun print-profile-table (time-info-list) (let ((total-seconds 0.0) (total-consed 0) (total-calls 0) (seconds-width (length "seconds")) (consed-width (length "consed")) (calls-width (length "calls")) (sec/call-width 10) (name-width 6)) (dolist (time-info time-info-list) (incf total-seconds (time-info-seconds time-info)) (incf total-consed (time-info-consing time-info)) (incf total-calls (time-info-calls time-info))) (setf seconds-width (max (length (format nil "~10,3F" total-seconds)) seconds-width) calls-width (max (length (format nil "~:D" total-calls)) calls-width) consed-width (max (length (format nil "~:D" total-consed)) consed-width)) (flet ((dashes () (dotimes (i (+ seconds-width consed-width calls-width sec/call-width name-width (* 5 3))) (write-char #\- *trace-output*)) (terpri *trace-output*))) (format *trace-output* "~&~@{ ~v:@<~A~>~^|~}~%" seconds-width "seconds" (1+ consed-width) "consed" (1+ calls-width) "calls" (1+ sec/call-width) "sec/call" (1+ name-width) "name") (dashes) (dolist (time-info time-info-list) (format *trace-output* "~v,3F | ~v:D | ~v:D | ~10,6F | ~S~%" seconds-width (time-info-seconds time-info) consed-width (time-info-consing time-info) calls-width (time-info-calls time-info) (/ (time-info-seconds time-info) (float (time-info-calls time-info))) (time-info-name time-info))) (dashes) (format *trace-output* "~v,3F | ~v:D | ~v:D | | Total~%" seconds-width total-seconds consed-width total-consed calls-width total-calls) (format *trace-output* "~%estimated total profiling overhead: ~4,2F seconds~%" (* (overhead-total *overhead*) (float total-calls))) (format *trace-output* "~&overhead estimation parameters:~% ~Ss/call, ~Ss total profiling, ~Ss internal profiling~%" (overhead-call *overhead*) (overhead-total *overhead*) (overhead-internal *overhead*))))) ;;;; overhead estimation ;;; We average the timing overhead over this many iterations. ;;; ;;; (This is a variable, not a constant, so that it can be set in ;;; .sbclrc if desired. Right now, that's an unsupported extension ;;; that I (WHN) use for my own experimentation, but it might ;;; become supported someday. Comments?) (declaim (type unsigned-byte *timer-overhead-iterations*)) (defparameter *timer-overhead-iterations* 500000) ;;; a dummy function that we profile to find profiling overhead (declaim (notinline compute-overhead-aux)) (defun compute-overhead-aux (x) (declare (ignore x))) ;;; Return a newly computed OVERHEAD object. (defun compute-overhead () (format *debug-io* "~&measuring PROFILE overhead..") (flet ((frob () (let ((start (get-internal-ticks)) (fun (symbol-function 'compute-overhead-aux))) (declare (type function fun)) (dotimes (i *timer-overhead-iterations*) (funcall fun fun)) (/ (float (- (get-internal-ticks) start)) (float +ticks-per-second+) (float *timer-overhead-iterations*))))) (let (;; Measure unprofiled calls to estimate call overhead. (call-overhead (frob)) total-overhead internal-overhead) ;; Measure profiled calls to estimate profiling overhead. (unwind-protect (progn (profile compute-overhead-aux) (setf total-overhead (- (frob) call-overhead))) (let* ((pinfo (gethash-locked 'compute-overhead-aux *profiled-fun-name->info*)) (read-stats-fun (profile-info-read-stats-fun pinfo)) (time (nth-value 1 (funcall read-stats-fun)))) (setf internal-overhead (/ (float time) (float +ticks-per-second+) (float *timer-overhead-iterations*)))) (unprofile compute-overhead-aux)) (prog1 (make-overhead :call call-overhead :total total-overhead :internal internal-overhead) (format *debug-io* "done~%"))))) ;;; It would be bad to compute *OVERHEAD*, save it into a .core file, ;;; then load the old *OVERHEAD* value from the .core file into a ;;; different machine running at a different speed. We avoid this by ;;; erasing *CALL-OVERHEAD* whenever we save a .core file. (defun profile-deinit () (without-package-locks (makunbound '*overhead*))) ecl-16.1.2/contrib/quicklisp/000077500000000000000000000000001266352375300160245ustar00rootroot00000000000000ecl-16.1.2/contrib/quicklisp/LICENSE.txt000066400000000000000000000020661266352375300176530ustar00rootroot00000000000000Copyright (c) 2011 Zachary Beane Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ecl-16.1.2/contrib/quicklisp/ecl-quicklisp.lisp000066400000000000000000000037671266352375300214770ustar00rootroot00000000000000(defpackage :ecl-quicklisp (:use :cl)) (in-package :ecl-quicklisp) (require :ecl-curl) (defparameter *quicklisp-url* "http://beta.quicklisp.org/quicklisp.lisp") (defparameter *quicklisp-directory* #+windows (translate-logical-pathname "SYS:QUICKLISP;") #-windows (translate-logical-pathname "HOME:QUICKLISP;") ) (defparameter *quicklisp-setup* #+windows "SYS:QUICKLISP;SETUP.LISP" #-windows "HOME:QUICKLISP;SETUP.LISP" ) (defun safe-download (url filename) (ensure-directories-exist filename) (handler-case (ecl-curl:download-url-to-file url filename) (ecl-curl:download-error (c) (format t "~&;;;~%;;; Unable to download quicklisp. Aborting. ~%;;;") (ext:quit 1))) filename) (defun install-quicklisp (target-directory) (let ((file (merge-pathnames "_installer.lisp" target-directory))) (ensure-directories-exist file) (ecl-curl:download-url-to-file *quicklisp-url* file) (load file) (eval (read-from-string (format nil "(quicklisp-quickstart:install :path ~S)" (namestring (truename target-directory)))) ))) (handler-case (progn (unless (probe-file *quicklisp-setup*) (install-quicklisp *quicklisp-directory*)) (unless (find-package "QL") (load *quicklisp-setup*)) (eval (read-from-string " (pushnew #'(ext:lambda-block quicklisp-require (module) (let* ((module (string-downcase module))) (when (find module (ql:provided-systems t) :test #'string-equal :key #'ql-dist:name) (and (ql:quickload module) (provide module))))) sys::*module-provider-functions*) "))) (error (c) (format t "~%;;; Unable to load / install quicklisp. Error message follows:~%~A" c))) (provide '#:ecl-quicklisp) ecl-16.1.2/contrib/quicklisp/minitar.lisp000066400000000000000000000104221266352375300203570ustar00rootroot00000000000000(defpackage #:ql-minitar (:documentation "A simple implementation of unpacking the 'tar' file format.") (:use #:cl) (:export #:tarball-contents #:unpack-tarball)) (in-package #:ql-minitar) (defun make-block-buffer () (make-array 512 :element-type '(unsigned-byte 8) :initial-element 0)) (defun skip-n-blocks (n stream) (let ((block (make-block-buffer))) (dotimes (i n) (read-sequence block stream)))) (defun ascii-subseq (vector start end) (let ((string (make-string (- end start)))) (loop for i from 0 for j from start below end do (setf (char string i) (code-char (aref vector j)))) string)) (defun block-asciiz-string (block start length) (let* ((end (+ start length)) (eos (or (position 0 block :start start :end end) end))) (ascii-subseq block start eos))) (defun prefix (header) (when (plusp (aref header 345)) (block-asciiz-string header 345 155))) (defun name (header) (block-asciiz-string header 0 100)) (defun payload-size (header) (values (parse-integer (block-asciiz-string header 124 12) :radix 8))) (defun nth-block (n file) (with-open-file (stream file :element-type '(unsigned-byte 8)) (let ((block (make-block-buffer))) (skip-n-blocks (1- n) stream) (read-sequence block stream) block))) (defun payload-type (code) (case code (0 :file) (48 :file) (50 :symlink) (76 :long-name) (53 :directory) (103 :global-header) (t :unsupported))) (defun full-path (header) (let ((prefix (prefix header)) (name (name header))) (if prefix (format nil "~A/~A" prefix name) name))) (defun save-file (file size stream) (multiple-value-bind (full-blocks partial) (truncate size 512) (ensure-directories-exist file) (with-open-file (outstream file :direction :output :if-exists :supersede :element-type '(unsigned-byte 8)) (let ((block (make-block-buffer))) (dotimes (i full-blocks) (read-sequence block stream) (write-sequence block outstream)) (when (plusp partial) (read-sequence block stream) (write-sequence block outstream :end partial)))))) (defun unpack-tarball (tarfile &key (directory *default-pathname-defaults*)) (let ((block (make-block-buffer))) (with-open-file (stream tarfile :element-type '(unsigned-byte 8)) (loop (let ((size (read-sequence block stream))) (when (zerop size) (return)) (unless (= size 512) (error "Bad size on tarfile")) (when (every #'zerop block) (return)) (let* ((payload-code (aref block 156)) (payload-type (payload-type payload-code)) (tar-path (full-path block)) (full-path (merge-pathnames tar-path directory)) (payload-size (payload-size block)) (block-count (ceiling (payload-size block) 512))) (case payload-type (:file (save-file full-path payload-size stream)) (:directory (ensure-directories-exist full-path)) ((:symlink :long-name :global-header) ;; These block types aren't required for Quicklisp archives (skip-n-blocks block-count stream)) (t (warn "Unknown tar block payload code -- ~D" payload-code) (skip-n-blocks block-count stream))))))))) (defun contents (tarfile) (let ((block (make-block-buffer)) (result '())) (with-open-file (stream tarfile :element-type '(unsigned-byte 8)) (loop (let ((size (read-sequence block stream))) (when (zerop size) (return (nreverse result))) (unless (= size 512) (error "Bad size on tarfile")) (when (every #'zerop block) (return (nreverse result))) (let* ((payload-type (payload-type (aref block 156))) (tar-path (full-path block)) (payload-size (payload-size block))) (skip-n-blocks (ceiling payload-size 512) stream) (case payload-type (:file (push tar-path result)) (:directory (push tar-path result))))))))) ecl-16.1.2/contrib/rt/000077500000000000000000000000001266352375300144455ustar00rootroot00000000000000ecl-16.1.2/contrib/rt/rt.lisp000066400000000000000000000220301266352375300157600ustar00rootroot00000000000000#|----------------------------------------------------------------------------| | Copyright 1990 by the Massachusetts Institute of Technology, Cambridge MA. | | | | Permission to use, copy, modify, and distribute this software and its | | documentation for any purpose and without fee is hereby granted, provided | | that this copyright and permission notice appear in all copies and | | supporting documentation, and that the name of M.I.T. not be used in | | advertising or publicity pertaining to distribution of the software | | without specific, written prior permission. M.I.T. makes no | | representations about the suitability of this software for any purpose. | | It is provided "as is" without express or implied warranty. | | | | M.I.T. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING | | ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL | | M.I.T. BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR | | ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, | | WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, | | ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS | | SOFTWARE. | |----------------------------------------------------------------------------|# (defpackage :sb-rt (:nicknames :rt :regression-test :rtest) (:use #:cl) (:export #:*do-tests-when-defined* #:*test* #:continue-testing #:deftest #:deftest* #:do-test #:do-tests #:get-test #:pending-tests #:rem-all-tests #:rem-test) (:documentation "The MIT regression tester")) (in-package :sb-rt) (defvar *test* nil "Current test name") (defvar *do-tests-when-defined* nil) (defvar *entries* '(nil) "Test database") (defvar *in-test* nil "Used by TEST") (defvar *debug* nil "For debugging") (defvar *catch-errors* t "When true, causes errors in a test to be caught.") (defvar *print-circle-on-failure* nil "Failure reports are printed with *PRINT-CIRCLE* bound to this value.") (defvar *compile-tests* nil "When true, compile the tests before running them.") (defvar *optimization-settings* '((safety 3))) (defvar *expected-failures* nil "A list of test names that are expected to fail.") (defstruct (entry (:conc-name nil) (:type list)) pend name form) (defmacro vals (entry) `(cdddr ,entry)) (defmacro defn (entry) `(cdr ,entry)) (defun pending-tests () (do ((l (cdr *entries*) (cdr l)) (r nil)) ((null l) (nreverse r)) (when (pend (car l)) (push (name (car l)) r)))) (defun rem-all-tests () (setq *entries* (list nil)) nil) (defun rem-test (&optional (name *test*)) (do ((l *entries* (cdr l))) ((null (cdr l)) nil) (when (equal (name (cadr l)) name) (setf (cdr l) (cddr l)) (return name)))) (defun get-test (&optional (name *test*)) (defn (get-entry name))) (defun get-entry (name) (let ((entry (find name (cdr *entries*) :key #'name :test #'equal))) (when (null entry) (report-error t "~%No test with name ~:@(~S~)." name)) entry)) (defmacro deftest (name form &rest values) `(add-entry '(t ,name ,form .,values))) (defmacro deftest* (name form result) `(deftest ,name ,form ,@(eval result))) (defun add-entry (entry) (setq entry (copy-list entry)) (do ((l *entries* (cdr l))) (nil) (when (null (cdr l)) (setf (cdr l) (list entry)) (return nil)) (when (equal (name (cadr l)) (name entry)) (setf (cadr l) entry) (report-error nil "Redefining test ~:@(~S~)" (name entry)) (return nil))) (when *do-tests-when-defined* (do-entry entry)) (setq *test* (name entry))) (defun report-error (error? &rest args) (cond (*debug* (apply #'format t args) (if error? (throw '*debug* nil))) (error? (apply #'error args)) (t (apply #'format t args)))) (defun do-test (&optional (name *test*)) (do-entry (get-entry name))) (defun equalp-with-case (x y) "Like EQUALP, but doesn't do case conversion of characters." (cond ((eq x y) t) ((consp x) (and (consp y) (equalp-with-case (car x) (car y)) (equalp-with-case (cdr x) (cdr y)))) ((and (typep x 'array) (= (array-rank x) 0)) (equalp-with-case (aref x) (aref y))) ((typep x 'vector) (and (typep y 'vector) (let ((x-len (length x)) (y-len (length y))) (and (eql x-len y-len) (loop for e1 across x for e2 across y always (equalp-with-case e1 e2)))))) ((and (typep x 'array) (typep y 'array) (not (equal (array-dimensions x) (array-dimensions y)))) nil) ((typep x 'array) (and (typep y 'array) (let ((size (array-total-size x))) (loop for i from 0 below size always (equalp-with-case (row-major-aref x i) (row-major-aref y i)))))) (t (eql x y)))) (defun do-entry (entry &optional (s *standard-output*)) (catch '*in-test* (setq *test* (name entry)) (setf (pend entry) t) (let* ((*in-test* t) ;; (*break-on-warnings* t) (aborted nil) r) ;; (declare (special *break-on-warnings*)) (block aborted (setf r (flet ((%do () (if *compile-tests* (multiple-value-list (funcall (compile nil `(lambda () (declare (optimize ,@*optimization-settings*)) ,(form entry))))) (multiple-value-list (eval (form entry)))))) (if *catch-errors* (handler-bind ((style-warning #'muffle-warning) (error #'(lambda (c) (setf aborted t) (setf r (list c)) (return-from aborted nil)))) (%do)) (%do))))) (setf (pend entry) (or aborted (not (equalp-with-case r (vals entry))))) (when (pend entry) (let ((*print-circle* *print-circle-on-failure*)) (format s "~&Test ~:@(~S~) failed~ ~%Form: ~S~ ~%Expected value~P: ~ ~{~S~^~%~17t~}~%" *test* (form entry) (length (vals entry)) (vals entry)) (format s "Actual value~P: ~ ~{~S~^~%~15t~}.~%" (length r) r) (let ((x (first r))) (when (typep x 'condition) (format s "~&Condition: ~A" x))) )))) (when (not (pend entry)) *test*)) (defun continue-testing () (if *in-test* (throw '*in-test* nil) (do-entries *standard-output*))) (defun do-tests (&optional (out *standard-output*)) (dolist (entry (cdr *entries*)) (setf (pend entry) t)) (if (streamp out) (do-entries out) (with-open-file (stream out :direction :output) (do-entries stream)))) (defun do-entries (s) (format s "~&Doing ~A pending test~:P ~ of ~A tests total.~%" (count t (cdr *entries*) :key #'pend) (length (cdr *entries*))) (dolist (entry (cdr *entries*)) (when (pend entry) (format s "~@[~<~%~:; ~:@(~S~)~>~]" (do-entry entry s)))) (let ((pending (pending-tests)) (expected-table (make-hash-table :test #'equal))) (dolist (ex *expected-failures*) (setf (gethash ex expected-table) t)) (let ((new-failures (loop for pend in pending unless (gethash pend expected-table) collect pend))) (if (null pending) (format s "~&No tests failed.") (progn (format s "~&~A out of ~A ~ total tests failed: ~ ~:@(~{~<~% ~1:;~S~>~ ~^, ~}~)." (length pending) (length (cdr *entries*)) pending) (if (null new-failures) (format s "~&No unexpected failures.") (when *expected-failures* (format s "~&~A unexpected failures: ~ ~:@(~{~<~% ~1:;~S~>~ ~^, ~}~)." (length new-failures) new-failures))) )) (finish-output s) (null pending)))) (provide '#:rt) ecl-16.1.2/contrib/serve-event/000077500000000000000000000000001266352375300162635ustar00rootroot00000000000000ecl-16.1.2/contrib/serve-event/event-test-eintr.lisp000066400000000000000000000010361266352375300223710ustar00rootroot00000000000000;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; Test that serve-event can be interrupted ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (require 'serve-event) (defun serve-event-loop () (serve-event:serve-all-events) (format t "serve-event-loop interrupted~%") (serve-event-loop)) (let ((thread (mp:process-run-function 'loop #'serve-event-loop))) (defun interrupt-loop () (sleep 5) (mp:interrupt-process thread (lambda ())) (interrupt-loop))) (interrupt-loop)ecl-16.1.2/contrib/serve-event/event-test.lisp000066400000000000000000000011571266352375300212560ustar00rootroot00000000000000 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; Test Example ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (require 'serve-event) (in-package "SERVE-EVENT") (defun test-stdin () (format t "DOING STDIN~%") (with-fd-handler (0 :input #'(lambda (fd) (declare (ignore fd)) (format t "Got data~%") (read-char))) (loop ;; FIXME: End condition (format t "Entering serve-all-events...~%")(force-output) (serve-all-events 5) (format t "Events served~%")))) (test-stdin) ecl-16.1.2/contrib/serve-event/serve-event.lisp000066400000000000000000000217711266352375300214270ustar00rootroot00000000000000;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; ;; This file provides a port the SBCL/CMUCL 'serve-event' ;; functionality to ecl. serve-event provides a lispy abstraction of ;; unix select(2) non-blocking IO (and potentially other variants such as ;; epoll). It works with Unix-level file-descriptors, which can be ;; retrieved from the sockets module using the socket-file-descriptor ;; slot. ;; ;; As this file is based on SBCL's serve-event module it is being ;; released under the same (non) license as SBCL (i.e. public-domain). ;; ;; The original port was made by Steve Smith (tarkasteve@gmail.com) ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; Test Example ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; ;; (defun test-stdin () ;; (format t "DOING STDIN~%") ;; (with-fd-handler (0 :input #'(lambda (fd) (declare (ignore fd)) ;; (format t "Got data~%") ;; (read-char))) ;; (loop ;; FIXME: End condition ;; (format t "Entering serve-all-events...~%")(force-output) ;; (serve-all-events 5) ;; (format t "Events served~%")))) ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; ;; A more advanced example using sockets is available here: ;; ;; http://haltcondition.net/?p=2232 ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (defpackage "SERVE-EVENT" (:use "CL" "FFI") (:export "WITH-FD-HANDLER" "ADD-FD-HANDLER" "REMOVE-FD-HANDLER" "SERVE-EVENT" "SERVE-ALL-EVENTS")) (in-package "SERVE-EVENT") (clines "#include " "#include ") (eval-when (:compile-toplevel :execute) (defmacro c-constant (c-name) `(c-inline () () :int ,c-name :one-liner t)) (defmacro define-c-constants (&rest args) `(let () ,@(loop for (lisp-name c-name) on args by #'cddr collect `(defconstant ,lisp-name (c-constant ,c-name)))))) (define-c-constants +eintr+ "EINTR") (defstruct (handler (:constructor make-handler (descriptor direction function)) (:copier nil)) ;; Reading or writing... (direction nil :type (member :input :output)) ;; File descriptor this handler is tied to. ;; FIXME: Should be based on FD_SETSIZE (descriptor 0) ;; Function to call. (function nil :type function)) (defvar *descriptor-handlers* nil #!+sb-doc "List of all the currently active handlers for file descriptors") (defun coerce-to-descriptor (stream-or-fd direction) (etypecase stream-or-fd (fixnum stream-or-fd) (file-stream (si:file-stream-fd stream-or-fd)) (two-way-stream (coerce-to-descriptor (case direction (:input (two-way-stream-input-stream stream-or-fd)) (:output (two-way-stream-output-stream stream-or-fd))) direction)) #+clos-streams (stream (gray::stream-file-descriptor stream-or-fd direction)))) ;;; Add a new handler to *descriptor-handlers*. (defun add-fd-handler (stream-or-fd direction function) "Arrange to call FUNCTION whenever the fd designated by STREAM-OR-FD is usable. DIRECTION should be either :INPUT or :OUTPUT. The value returned should be passed to SYSTEM:REMOVE-FD-HANDLER when it is no longer needed." (unless (member direction '(:input :output)) (error 'simple-type-error :format-control "Invalid direction ~S, must be either ~ :INPUT or :OUTPUT." :format-arguments (list direction) :datum direction :expected-type '(member :input :output))) (let ((handler (make-handler (coerce-to-descriptor stream-or-fd direction) direction function))) (push handler *descriptor-handlers*) handler)) ;;; Remove an old handler from *descriptor-handlers*. (defun remove-fd-handler (handler) #!+sb-doc "Removes HANDLER from the list of active handlers." (setf *descriptor-handlers* (delete handler *descriptor-handlers*))) ;;; Add the handler to *descriptor-handlers* for the duration of BODY. (defmacro with-fd-handler ((fd direction function) &rest body) "Establish a handler with SYSTEM:ADD-FD-HANDLER for the duration of BODY. DIRECTION should be either :INPUT or :OUTPUT, FD is the file descriptor to use, and FUNCTION is the function to call whenever FD is usable." (let ((handler (gensym))) `(let (,handler) (unwind-protect (progn (setf ,handler (add-fd-handler ,fd ,direction ,function)) ,@body) (when ,handler (remove-fd-handler ,handler)))))) (defmacro fd-zero(fdset) `(c-inline (,fdset) (:object) :void "FD_ZERO((fd_set*)#0->foreign.data)" :one-liner t :side-effects t)) (defmacro fd-set (fd fdset) `(c-inline (,fd ,fdset) (:int :object) :void "FD_SET(#0, (fd_set*)#1->foreign.data);" :one-liner t :side-effects t)) (defmacro fd-isset (fd fdset) `(c-inline (,fd ,fdset) (:int :object) :int "FD_ISSET(#0, (fd_set*)#1->foreign.data)" :one-liner t :side-effects t)) (defun fdset-size () (c-inline () () :int "sizeof(fd_set)" :one-liner t :side-effects nil)) (defun serve-event (&optional (seconds nil)) "Receive pending events on all FD-STREAMS and dispatch to the appropriate handler functions. If timeout is specified, server will wait the specified time (in seconds) and then return, otherwise it will wait until something happens. Server returns T if something happened and NIL otherwise. Timeout 0 means polling without waiting." ;; fd_set is an opaque typedef, so we can't declare it locally. ;; However we can fine out its size and allocate a char array of ;; the same size which can be used in its place. (let ((fsize (fdset-size))) (with-foreign-objects ((rfd `(:array :unsigned-char ,fsize)) (wfd `(:array :unsigned-char ,fsize))) (fd-zero rfd) (fd-zero wfd) (let ((maxfd 0)) ;; Load the descriptors into the relevant set (dolist (handler *descriptor-handlers*) (let ((fd (handler-descriptor handler))) (ecase (handler-direction handler) (:input (fd-set fd rfd)) (:output (fd-set fd wfd))) (when (> fd maxfd) (setf maxfd fd)))) (multiple-value-bind (retval errno) (if (null seconds) ;; No timeout (c-inline (rfd wfd (1+ maxfd)) (:object :object :int) (values :int :int) "{ @(return 0) = select(#2, (fd_set*)#0->foreign.data, (fd_set*)#1->foreign.data, NULL, NULL); @(return 1) = errno; }" :one-liner nil :side-effects t) (c-inline (rfd wfd (1+ maxfd) seconds) (:object :object :int :double) (values :int :int) "{ struct timeval tv; double seconds = #3; tv.tv_sec = seconds; tv.tv_usec = (seconds * 1e6); @(return 0) = select(#2, (fd_set*)#0->foreign.data, (fd_set*)#1->foreign.data, NULL, &tv); @(return 1) = errno; }" :one-liner nil :side-effects t)) (cond ((zerop retval) nil) ((minusp retval) (if (= errno +eintr+) ;; suppress EINTR nil ;; otherwise error (error "Error during select"))) ((plusp retval) (dolist (handler *descriptor-handlers*) (let ((fd (handler-descriptor handler))) (if (plusp (ecase (handler-direction handler) (:input (fd-isset fd rfd)) (:output (fd-isset fd wfd)))) (funcall (handler-function handler) (handler-descriptor handler))))) t))))))) ;;; Wait for up to timeout seconds for an event to happen. Make sure all ;;; pending events are processed before returning. (defun serve-all-events (&optional (timeout nil)) "SERVE-ALL-EVENTS calls SERVE-EVENT with the specified timeout. If SERVE-EVENT does something (returns T) it loops over SERVE-EVENT with a timeout of 0 until there are no more events to serve. SERVE-ALL-EVENTS returns T if SERVE-EVENT did something and NIL if not." (do ((res nil) (sval (serve-event timeout) (serve-event 0))) ((null sval) res) (setq res t))) (provide '#:serve-event) ecl-16.1.2/contrib/sockets/000077500000000000000000000000001266352375300154735ustar00rootroot00000000000000ecl-16.1.2/contrib/sockets/package.lisp000066400000000000000000000021261266352375300177600ustar00rootroot00000000000000;; -*- Mode: Lisp; Syntax: Common-Lisp -*- ;; $Id$ ;; This file is based on SBCL's SB-BSD-SOCKET module and has been ;; heavily modified to work with ECL by Julian Stecklina. ;; Port to Windows Sockets contributed by M. Goffioul. ;; You may do whatever you want with this file. (PUBLIC DOMAIN) ;; Trivial stuff is copied from SBCL's SB-BSD-SOCKETS, which is also ;; in the public domain. (defpackage "SB-BSD-SOCKETS" (:use "CL" "FFI" "SI") (:export "GET-HOST-BY-NAME" "GET-HOST-BY-ADDRESS" "SOCKET-BIND" "SOCKET-ACCEPT" "SOCKET-CONNECT" "SOCKET-PEERNAME" "SOCKET-NAME" "SOCKET-LISTEN" "SOCKET-RECEIVE" "SOCKET-CLOSE" "SOCKET-MAKE-STREAM" "GET-PROTOCOL-BY-NAME" "MAKE-INET-ADDRESS" "LOCAL-SOCKET" "SOCKET" "INET-SOCKET" "SOCKET-FILE-DESCRIPTOR" #+:win32 "NAMED-PIPE-SOCKET" "SOCKET-FAMILY" "SOCKET-PROTOCOL" "SOCKET-TYPE" "SOCKET-ERROR" "NAME-SERVICE-ERROR" "NON-BLOCKING-MODE" "HOST-ENT-NAME" "HOST-ENT-ALIASES" "HOST-ENT-ADDRESS-TYPE" "HOST-ENT-ADDRESSES" "HOST-ENT" "HOST-ENT-ADDRESS" "SOCKET-SEND")) ecl-16.1.2/contrib/sockets/sb-bsd-sockets.lisp000066400000000000000000000000231266352375300212020ustar00rootroot00000000000000(require 'SOCKETS) ecl-16.1.2/contrib/sockets/sockets.lisp000077500000000000000000001713651266352375300200570ustar00rootroot00000000000000;; -*- Mode: Lisp; Syntax: Common-Lisp -*- ;; $Id$ ;; This file is based on SBCL's SB-BSD-SOCKET module and has been ;; heavily modified to work with ECL by Julian Stecklina. ;; Port to Windows Sockets contributed by M. Goffioul. ;; You may do whatever you want with this file. (PUBLIC DOMAIN) ;; Trivial stuff is copied from SBCL's SB-BSD-SOCKETS, which is also ;; in the public domain. (in-package "SB-BSD-SOCKETS") ;; Obviously this requires the one or other form of BSD compatible ;; socket interface. #+(or :win32 :mingw32) (eval-when (:compile-toplevel :load-toplevel :execute) (pushnew :wsock *features*)) ;; Include the neccessary headers #-:wsock (clines "#include " "#include " "#include " "#define wincoerce(t,x) (x)" #-:win32 "#include " "#include " "#include " "#include " "#include " "#include " "#include " "#include " #+:cygwin "#ifndef MSG_WAITALL #define MSG_WAITALL 0 #endif" "#ifndef MSG_CONFIRM" "#define MSG_CONFIRM 0" "#endif" "#ifndef MSG_NOSIGNAL" "#define MSG_NOSIGNAL 0" "#endif" "#ifndef MSG_DONTWAIT" "#define MSG_DONTWAIT 0" "#endif" "#ifndef MSG_EOR" "#define MSG_EOR 0" "#endif") #+:wsock (clines "#include " "typedef unsigned int uint32_t;" "#define wincoerce(t,x) ((t)(x))" #-:mingw32 "typedef int ssize_t;" "typedef int socklen_t;" "#define MSG_WAITALL 0" "#define MSG_EOR 0" "#define MSG_DONTWAIT 0" "#define MSG_NOSIGNAL 0" "#define MSG_CONFIRM 0" "#include " "#include " "#include ") #+:wsock (progn (defvar +wsock-initialized+ nil) (defun wsock-initialize () (unless +wsock-initialized+ (if (c-inline () () :object " { WSADATA wsadata; cl_object output; ecl_disable_interrupts(); if (WSAStartup(MAKEWORD(2,2), &wsadata) == NO_ERROR) output = ECL_T; else output = ECL_NIL; ecl_enable_interrupts(); @(return) = output; }") (setf +wsock-initialized+ t) (error "Unable to initialize Windows Socket library")))) (wsock-initialize) ); #+:wsock (eval-when (:compile-toplevel :execute) (defmacro c-constant (c-name) `(c-inline () () :int ,c-name :one-liner t)) (defmacro define-c-constants (&rest args) `(let () ; Prevents evaluation of constant value form ,@(loop for (lisp-name c-name) on args by #'cddr collect `(defconstant ,lisp-name (c-constant ,c-name)))))) #+:wsock (Clines "#define AF_LOCAL -1" ) (define-c-constants +af-inet+ "AF_INET" +af-local+ #-sun4sol2 "AF_LOCAL" #+sun4sol2 "AF_UNIX" +eagain+ "EAGAIN" +eintr+ "EINTR") #+:android (define-c-constants +ipproto_ip+ "IPPROTO_IP" +ipproto_icmp+ "IPPROTO_ICMP" +ipproto_igmp+ "IPPROTO_IGMP" +ipproto_ipip+ "IPPROTO_IPIP" +ipproto_tcp+ "IPPROTO_TCP" +ipproto_egp+ "IPPROTO_EGP" +ipproto_pup+ "IPPROTO_PUP" +ipproto_udp+ "IPPROTO_UDP" +ipproto_idp+ "IPPROTO_IDP" +ipproto_dccp+ "IPPROTO_DCCP" +ipproto_rsvp+ "IPPROTO_RSVP" +ipproto_gre+ "IPPROTO_GRE" +ipproto_ipv6+ "IPPROTO_IPV6" +ipproto_esp+ "IPPROTO_ESP" +ipproto_ah+ "IPPROTO_AH" +ipproto_pim+ "IPPROTO_PIM" +ipproto_comp+ "IPPROTO_COMP" +ipproto_sctp+ "IPPROTO_SCTP" +ipproto_raw+ "IPPROTO_RAW") #+:wsock (defconstant +af-named-pipe+ -2) ;; Foreign functions (defentry ff-socket (:int :int :int) (:int "socket") :no-interrupts t) (defentry ff-listen (:int :int) (:int "listen") :no-interrupts t) (defentry ff-close (:int) (:int "close") :no-interrupts t) #+:wsock (defentry ff-closesocket (:int) (:int "closesocket") :no-interrupts t) ;;; This courtesy of Pierre Mai in comp.lang.lisp 08 Jan 1999 00:51:44 +0100 ;;; Message-ID: <87lnjebq0f.fsf@orion.dent.isdn.cs.tu-berlin.de> (defun split (string &optional max (ws '(#\Space #\Tab))) "Split `string' along whitespace as defined by the sequence `ws'. The whitespace is elided from the result. The whole string will be split, unless `max' is a non-negative integer, in which case the string will be split into `max' tokens at most, the last one containing the whole rest of the given `string', if any." (flet ((is-ws (char) (find char ws))) (loop for start = (position-if-not #'is-ws string) then (position-if-not #'is-ws string :start index) for index = (and start (if (and max (= (1+ word-count) max)) nil (position-if #'is-ws string :start start))) while start collect (subseq string start index) count 1 into word-count while index))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; ;;; NAME RESOLVING ;;; (defclass host-ent () ((name :initarg :name :accessor host-ent-name) (aliases :initarg :aliases :accessor host-ent-aliases) (address-type :initarg :type :accessor host-ent-address-type) ; presently always AF_INET (addresses :initarg :addresses :accessor host-ent-addresses)) (:documentation "")) (defgeneric host-ent-address (host-ent) (:documentation "")) (defmethod host-ent-address ((host-ent host-ent)) (car (host-ent-addresses host-ent))) ;; FIXME: We should move this to using getaddrinfo (defun get-host-by-name (host-name) "Returns a HOST-ENT instance for HOST-NAME or throws some kind of condition. HOST-NAME may also be an IP address in dotted quad notation or some other weird stuff - see gethostbyname(3) for grisly details." (let ((host-ent (make-instance 'host-ent))) (if (c-inline (host-name host-ent #'(setf host-ent-name) #'(setf host-ent-aliases) #'(setf host-ent-address-type) #'(setf host-ent-addresses)) (:cstring t t t t t) t " { struct hostent *hostent = gethostbyname(#0); if (hostent != NULL) { char **aliases; char **addrs; cl_object aliases_list = ECL_NIL; cl_object addr_list = ECL_NIL; int length = hostent->h_length; funcall(3,#2,make_simple_base_string(hostent->h_name),#1); funcall(3,#4,ecl_make_integer(hostent->h_addrtype),#1); for (aliases = hostent->h_aliases; *aliases != NULL; aliases++) { aliases_list = CONS(make_simple_base_string(*aliases),aliases_list); } funcall(3,#3,aliases_list,#1); for (addrs = hostent->h_addr_list; *addrs != NULL; addrs++) { int pos; cl_object vector = funcall(2,@make-array,MAKE_FIXNUM(length)); for (pos = 0; pos < length; pos++) ecl_aset(vector, pos, MAKE_FIXNUM((unsigned char)((*addrs)[pos]))); addr_list = CONS(vector, addr_list); } funcall(3,#5,addr_list,#1); @(return) = #1; } else { @(return) = ECL_NIL; } }" :side-effects t) host-ent (name-service-error "get-host-by-name")))) (defun get-host-by-address (address) (assert (and (typep address 'vector) (= (length address) 4))) (let ((host-ent (make-instance 'host-ent))) (if (c-inline (address host-ent #'(setf host-ent-name) #'(setf host-ent-aliases) #'(setf host-ent-address-type) #'(setf host-ent-addresses)) (t t t t t t) t " { unsigned char vector[4]; struct hostent *hostent; vector[0] = fixint(ecl_aref(#0,0)); vector[1] = fixint(ecl_aref(#0,1)); vector[2] = fixint(ecl_aref(#0,2)); vector[3] = fixint(ecl_aref(#0,3)); ecl_disable_interrupts(); hostent = gethostbyaddr(wincoerce(const char *, vector),4,AF_INET); ecl_enable_interrupts(); if (hostent != NULL) { char **aliases; char **addrs; cl_object aliases_list = ECL_NIL; cl_object addr_list = ECL_NIL; int length = hostent->h_length; funcall(3,#2,make_simple_base_string(hostent->h_name),#1); funcall(3,#4,ecl_make_integer(hostent->h_addrtype),#1); for (aliases = hostent->h_aliases; *aliases != NULL; aliases++) { aliases_list = CONS(make_simple_base_string(*aliases),aliases_list); } funcall(3,#3,aliases_list,#1); for (addrs = hostent->h_addr_list; *addrs != NULL; addrs++) { int pos; cl_object vector = funcall(2,@make-array,MAKE_FIXNUM(length)); for (pos = 0; pos < length; pos++) ecl_aset(vector, pos, MAKE_FIXNUM((unsigned char)((*addrs)[pos]))); addr_list = CONS(vector, addr_list); } funcall(3,#5,addr_list,#1); @(return) = #1; } else { @(return) = ECL_NIL; } }" :side-effects t) host-ent (name-service-error "get-host-by-address")))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; ;;; SOCKET BASE CLASS AND GENERIC FUNCTIONS ;;; (defclass socket () ((file-descriptor :initarg :descriptor :reader socket-file-descriptor) (family :initform (error "No socket family") :reader socket-family) (protocol :initarg :protocol :reader socket-protocol :documentation "Protocol used by the socket. If a keyword, the symbol-name of the keyword will be passed to GET-PROTOCOL-BY-NAME downcased, and the returned value used as protocol. Other values are used as-is.") (type :initarg :type :reader socket-type :initform :stream :documentation "Type of the socket: :STREAM or :DATAGRAM.") (stream) #+:wsock (non-blocking-p :initform nil)) (:documentation "Common base class of all sockets, not meant to be directly instantiated.")) (defmethod print-object ((object socket) stream) (print-unreadable-object (object stream :type t :identity t) (princ "descriptor " stream) (princ (slot-value object 'file-descriptor) stream))) (defmethod shared-initialize :after ((socket socket) slot-names &key protocol type &allow-other-keys) (let* ((proto-num (cond ((and protocol (keywordp protocol)) (get-protocol-by-name (string-downcase (symbol-name protocol)))) (protocol protocol) (t 0))) (fd (or (and (slot-boundp socket 'file-descriptor) (socket-file-descriptor socket)) #+:wsock (and (member (socket-family socket) (list +af-named-pipe+ +af-local+)) 0) (ff-socket (socket-family socket) (ecase (or type (socket-type socket)) ((:datagram) (c-constant "SOCK_DGRAM")) ((:stream) (c-constant "SOCK_STREAM"))) proto-num)))) (if (= fd -1) (socket-error "socket")) (setf (slot-value socket 'file-descriptor) fd (slot-value socket 'protocol) proto-num) #+ ignore (sb-ext:finalize socket (lambda () (sockint::close fd))))) ;; Generics (defgeneric socket-bind (socket &rest address) (:documentation "Bind SOCKET to ADDRESS, which may vary according to socket family. For the INET family, pass ADDRESS and PORT as two arguments; for FILE address family sockets, pass the filename string. See also bind(2)")) (defgeneric socket-accept (socket) (:documentation "Perform the accept(2) call, returning a newly-created connected socket and the peer address as multiple values")) (defgeneric socket-connect (socket &rest address) (:documentation "Perform the connect(2) call to connect SOCKET to a remote PEER. No useful return value.")) (defgeneric socket-peername (socket) (:documentation "Return the socket's peer; depending on the address family this may return multiple values")) (defgeneric socket-name (socket) (:documentation "Return the address (as vector of bytes) and port that the socket is bound to, as multiple values.")) (defgeneric socket-listen (socket backlog) (:documentation "Mark SOCKET as willing to accept incoming connections. BACKLOG defines the maximum length that the queue of pending connections may grow to before new connection attempts are refused. See also listen(2)")) (defgeneric socket-receive (socket buffer length &key oob peek waitall element-type) (:documentation "Read LENGTH octets from SOCKET into BUFFER (or a freshly-consed buffer if NIL), using recvfrom(2). If LENGTH is NIL, the length of BUFFER is used, so at least one of these two arguments must be non-NIL. If BUFFER is supplied, it had better be of an element type one octet wide. Returns the buffer, its length, and the address of the peer that sent it, as multiple values. On datagram sockets, sets MSG_TRUNC so that the actual packet length is returned even if the buffer was too small")) (defgeneric socket-send (socket buffer length &key address external-format oob eor dontroute dontwait nosignal confirm more) (:documentation "Send length octets from buffer into socket, using sendto(2). If buffer is a string, it will converted to octets according to external-format& If length is nil, the length of the octet buffer is used. The format of address depends on the socket type (for example for inet domain sockets it would be a list of an ip address and a port). If no socket address is provided, send(2) will be called instead. Returns the number of octets written.")) (defgeneric socket-close (socket) (:documentation "Close SOCKET. May throw any kind of error that write(2) would have thrown. If SOCKET-MAKE-STREAM has been called, calls CLOSE on that stream instead")) (defgeneric socket-make-stream (socket &rest args) (:documentation "Find or create a STREAM that can be used for IO on SOCKET (which must be connected). ARGS are passed onto SB-SYS:MAKE-FD-STREAM.")) (defgeneric non-blocking-mode (socket) (:documentation "Is SOCKET in non-blocking mode?")) (defgeneric (setf non-blocking-mode) (non-blocking-p socket) (:documentation "Put SOCKET in non-blocking mode - or not, according to NON-BLOCKING-P")) (defgeneric socket-close-low-level (socket) (:documentation "Close SOCKET at low level. Do not use directly.")) ;; Methods (defmethod socket-listen ((socket socket) backlog) (let ((r (ff-listen (socket-file-descriptor socket) backlog))) (if (= r -1) (socket-error "listen")))) (defmethod socket-close-low-level ((socket socket)) (ff-close (socket-file-descriptor socket))) (defmethod socket-close ((socket socket)) ;; the close(2) manual page has all kinds of warning about not ;; checking the return value of close, on the grounds that an ;; earlier write(2) might have returned successfully w/o actually ;; writing the stuff to disk. It then goes on to define the only ;; possible error return as EBADF (fd isn't a valid open file ;; descriptor). Presumably this is an oversight and we could also ;; get anything that write(2) would have given us. ;; note that if you have a socket _and_ a stream on the same fd, ;; the socket will avoid doing anything to close the fd in case ;; the stream has done it already - if so, it may have been ;; reassigned to some other file, and closing it would be bad (let ((fd (socket-file-descriptor socket))) (unless (eql fd -1) ; already closed (cond ((slot-boundp socket 'stream) (let ((stream (slot-value socket 'stream))) #+threads (close (two-way-stream-input-stream stream)) #+threads (close (two-way-stream-output-stream stream)) #-threads (close stream)) ;; closes fd indirectly (slot-makunbound socket 'stream)) ((= (socket-close-low-level socket) -1) (socket-error "close"))) (setf (slot-value socket 'file-descriptor) -1)))) (ffi::clines " static void * safe_buffer_pointer(cl_object x, cl_index size) { cl_type t = type_of(x); int ok = 0; if (t == t_base_string) { ok = (size <= x->base_string.dim); } else if (t == t_vector) { cl_elttype aet = (cl_elttype)x->vector.elttype; if (aet == aet_b8 || aet == aet_i8 || aet == aet_bc) { ok = (size <= x->vector.dim); } else if (aet == aet_fix || aet == aet_index) { cl_index divisor = sizeof(cl_index); size = (size + divisor - 1) / divisor; ok = (size <= x->vector.dim); } } if (!ok) { FEerror(\"Lisp object is not a valid socket buffer: ~A\", 1, x); } return (void *)x->vector.self.t; } ") ;; FIXME: How bad is manipulating fillp directly? (defmethod socket-receive ((socket socket) buffer length &key oob peek waitall element-type) (unless (or buffer length) (error "You have to supply either buffer or length!")) (let ((buffer (or buffer (make-array length :element-type element-type))) (length (or length (length buffer))) (fd (socket-file-descriptor socket))) (multiple-value-bind (len-recv errno) (c-inline (fd buffer length oob peek waitall) (:int :object :int :bool :bool :bool) (values :long :int) " { int flags = ( #3 ? MSG_OOB : 0 ) | ( #4 ? MSG_PEEK : 0 ) | ( #5 ? MSG_WAITALL : 0 ); cl_type type = type_of(#1); ssize_t len; ecl_disable_interrupts(); len = recvfrom(#0, wincoerce(char*, safe_buffer_pointer(#1, #2)), #2, flags, NULL,NULL); ecl_enable_interrupts(); if (len >= 0) { if (type == t_vector) { #1->vector.fillp = len; } else if (type == t_base_string) { #1->base_string.fillp = len; } } @(return 0) = len; @(return 1) = errno; } " :one-liner nil) (cond ((and (= len-recv -1) (member errno (list +eagain+ +eintr+))) nil) ((= len-recv -1) (socket-error "receive")) (t (values buffer len-recv)))))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; ;;; INET SOCKETS ;;; ;; We could refactor a lot here, if we pass sockaddr_foo structs around in Lisp. But ;; I do not feel comfortable with that. (defun get-protocol-by-name (string-or-symbol) "Calls getprotobyname" #-:android (let ((string (string string-or-symbol))) (c-inline (string) (:cstring) :int "{ struct protoent *pe; pe = getprotobyname(#0); @(return 0) = pe ? pe->p_proto : -1; } ")) ;; getprotobyname is not yet implemented on bionic #+:android (let ((proto (string-downcase (if (symbolp string-or-symbol) (symbol-name string-or-symbol) string-or-symbol)))) (cond ((string= proto "ip") +ipproto_ip+) ((string= proto "icmp") +ipproto_icmp+) ((string= proto "igmp") +ipproto_igmp+) ((string= proto "ipip") +ipproto_ipip+) ((string= proto "tcp") +ipproto_tcp+) ((string= proto "egp") +ipproto_egp+) ((string= proto "pup") +ipproto_pup+) ((string= proto "udp") +ipproto_udp+) ((string= proto "idp") +ipproto_idp+) ((string= proto "dccp") +ipproto_dccp+) ((string= proto "rsvp") +ipproto_rsvp+) ((string= proto "gre") +ipproto_gre+) ((string= proto "ipv6") +ipproto_ipv6+) ((string= proto "esp") +ipproto_esp+) ((string= proto "ah") +ipproto_ah+) ((string= proto "pim") +ipproto_pim+) ((string= proto "comp") +ipproto_comp+) ((string= proto "sctp") +ipproto_sctp+) ((string= proto "raw") +ipproto_raw+)))) (defun make-inet-address (dotted-quads) "Return a vector of octets given a string DOTTED-QUADS in the format \"127.0.0.1\"" (map 'vector #'parse-integer (split dotted-quads nil '(#\.)))) (defclass inet-socket (socket) ((family :initform +af-inet+)) (:documentation "Class representing TCP and UDP sockets. Examples: (make-instance 'inet-socket :type :stream :protocol :tcp) (make-instance 'inet-socket :type :datagram :protocol :udp) ")) (defun make-inet-socket (type protocol) "Make an INET socket. Deprecated in favour of make-instance" (make-instance 'inet-socket :type type :protocol protocol)) (Clines " static void fill_inet_sockaddr(struct sockaddr_in *sockaddr, int port, int a1, int a2, int a3, int a4) { #if defined(_MSC_VER) || defined(mingw32) memset(sockaddr,0,sizeof(struct sockaddr_in)); #else bzero(sockaddr,sizeof(struct sockaddr_in)); #endif sockaddr->sin_family = AF_INET; sockaddr->sin_port = htons(port); sockaddr->sin_addr.s_addr= htonl((uint32_t)a1<<24 | (uint32_t)a2<<16 | (uint32_t)a3<<8 | (uint32_t)a4) ; } ") (defmethod socket-bind ((socket inet-socket) &rest address) (assert (= 2 (length address)) (address) "Socket-bind needs three parameters for inet sockets.") (let ((ip (first address)) (port (second address))) (if (= -1 (c-inline (port (aref ip 0) (aref ip 1) (aref ip 2) (aref ip 3) (socket-file-descriptor socket)) (:int :int :int :int :int :int) :int " { struct sockaddr_in sockaddr; int output; ecl_disable_interrupts(); fill_inet_sockaddr(&sockaddr, #0, #1, #2, #3, #4); output = bind(#5,(struct sockaddr*)&sockaddr, sizeof(struct sockaddr_in)); ecl_enable_interrupts(); @(return) = output; }" :side-effects t)) (socket-error "bind")))) (defmethod socket-accept ((socket inet-socket)) (let ((sfd (socket-file-descriptor socket))) (multiple-value-bind (fd vector port) (c-inline (sfd) (:int) (values :int :object :int) "{ struct sockaddr_in sockaddr; socklen_t addr_len = (socklen_t)sizeof(struct sockaddr_in); int new_fd; ecl_disable_interrupts(); new_fd = accept(#0, (struct sockaddr*)&sockaddr, &addr_len); ecl_enable_interrupts(); @(return 0) = new_fd; @(return 1) = ECL_NIL; @(return 2) = 0; if (new_fd != -1) { uint32_t ip = ntohl(sockaddr.sin_addr.s_addr); uint16_t port = ntohs(sockaddr.sin_port); cl_object vector = cl_make_array(1,MAKE_FIXNUM(4)); ecl_aset(vector,0, MAKE_FIXNUM( ip>>24 )); ecl_aset(vector,1, MAKE_FIXNUM( (ip>>16) & 0xFF)); ecl_aset(vector,2, MAKE_FIXNUM( (ip>>8) & 0xFF)); ecl_aset(vector,3, MAKE_FIXNUM( ip & 0xFF )); @(return 1) = vector; @(return 2) = port; } }") (cond ((= fd -1) (socket-error "accept")) (t (values (make-instance (class-of socket) :type (socket-type socket) :protocol (socket-protocol socket) :descriptor fd) vector port)))))) (defmethod socket-connect ((socket inet-socket) &rest address) (let ((ip (first address)) (port (second address))) (if (= -1 (c-inline (port (aref ip 0) (aref ip 1) (aref ip 2) (aref ip 3) (socket-file-descriptor socket)) (:int :int :int :int :int :int) :int " { struct sockaddr_in sockaddr; int output; ecl_disable_interrupts(); fill_inet_sockaddr(&sockaddr, #0, #1, #2, #3, #4); output = connect(#5,(struct sockaddr*)&sockaddr, sizeof(struct sockaddr_in)); ecl_enable_interrupts(); @(return) = output; }")) (socket-error "connect")))) (defmethod socket-peername ((socket inet-socket)) (let* ((vector (make-array 4)) (fd (socket-file-descriptor socket)) (port (c-inline (fd vector) (:int t) :int "@01;{ struct sockaddr_in name; socklen_t len = sizeof(struct sockaddr_in); int ret; ecl_disable_interrupts(); ret = getpeername(#0,(struct sockaddr*)&name,&len); ecl_enable_interrupts(); if (ret == 0) { uint32_t ip = ntohl(name.sin_addr.s_addr); uint16_t port = ntohs(name.sin_port); ecl_aset(#1,0, MAKE_FIXNUM( ip>>24 )); ecl_aset(#1,1, MAKE_FIXNUM( (ip>>16) & 0xFF)); ecl_aset(#1,2, MAKE_FIXNUM( (ip>>8) & 0xFF)); ecl_aset(#1,3, MAKE_FIXNUM( ip & 0xFF )); @(return) = port; } else { @(return) = -1; } }"))) (if (>= port 0) (values vector port) (socket-error "getpeername")))) (defmethod socket-name ((socket inet-socket)) (let* ((vector (make-array 4)) (fd (socket-file-descriptor socket)) (port (c-inline (fd vector) (:int t) :int "@01;{ struct sockaddr_in name; socklen_t len = sizeof(struct sockaddr_in); int ret; ecl_disable_interrupts(); ret = getsockname(#0,(struct sockaddr*)&name,&len); ecl_enable_interrupts(); if (ret == 0) { uint32_t ip = ntohl(name.sin_addr.s_addr); uint16_t port = ntohs(name.sin_port); ecl_aset(#1,0, MAKE_FIXNUM( ip>>24 )); ecl_aset(#1,1, MAKE_FIXNUM( (ip>>16) & 0xFF)); ecl_aset(#1,2, MAKE_FIXNUM( (ip>>8) & 0xFF)); ecl_aset(#1,3, MAKE_FIXNUM( ip & 0xFF )); @(return) = port; } else { @(return) = -1; } }"))) (if (>= port 0) (values vector port) (socket-error "getsockname")))) #+:wsock (defmethod socket-close-low-level ((socket inet-socket)) (ff-closesocket (socket-file-descriptor socket))) (defmethod socket-send ((socket socket) buffer length &key address external-format oob eor dontroute dontwait nosignal confirm more) (declare (ignore external-format more)) (assert (or (stringp buffer) (typep buffer 'vector))) (let (;eh, here goes string->octet convertion... ;When will ecl support Unicode? (length (or length (length buffer))) (fd (socket-file-descriptor socket))) (let ((len-sent (if address (progn (assert (= 2 (length address))) (c-inline (fd buffer length (second address) (aref (first address) 0) (aref (first address) 1) (aref (first address) 2) (aref (first address) 3) oob eor dontroute dontwait nosignal confirm) (:int :object :int :int :int :int :int :int :bool :bool :bool :bool :bool :bool) :long " { int sock = #0; int length = #2; void *buffer = safe_buffer_pointer(#1, length); int flags = ( #8 ? MSG_OOB : 0 ) | ( #9 ? MSG_EOR : 0 ) | ( #a ? MSG_DONTROUTE : 0 ) | ( #b ? MSG_DONTWAIT : 0 ) | ( #c ? MSG_NOSIGNAL : 0 ) | ( #d ? MSG_CONFIRM : 0 ); cl_type type = type_of(#1); struct sockaddr_in sockaddr; ssize_t len; ecl_disable_interrupts(); fill_inet_sockaddr(&sockaddr, #3, #4, #5, #6, #7); ##if (MSG_NOSIGNAL == 0) && defined(SO_NOSIGPIPE) { int sockopt = #c; setsockopt(#0,SOL_SOCKET,SO_NOSIGPIPE, wincoerce(char *,&sockopt), sizeof(int)); } ##endif len = sendto(sock, wincoerce(char *,buffer), length, flags,(struct sockaddr*)&sockaddr, sizeof(struct sockaddr_in)); ecl_enable_interrupts(); @(return) = len; } " :one-liner nil)) (c-inline (fd buffer length oob eor dontroute dontwait nosignal confirm) (:int :object :int :bool :bool :bool :bool :bool :bool) :long " { int sock = #0; int length = #2; void *buffer = safe_buffer_pointer(#1, length); int flags = ( #3 ? MSG_OOB : 0 ) | ( #4 ? MSG_EOR : 0 ) | ( #5 ? MSG_DONTROUTE : 0 ) | ( #6 ? MSG_DONTWAIT : 0 ) | ( #7 ? MSG_NOSIGNAL : 0 ) | ( #8 ? MSG_CONFIRM : 0 ); cl_type type = type_of(#1); ssize_t len; ecl_disable_interrupts(); ##if (MSG_NOSIGNAL == 0) && defined(SO_NOSIGPIPE) { int sockopt = #7; setsockopt(#0,SOL_SOCKET,SO_NOSIGPIPE, wincoerce(char *,&sockopt), sizeof(int)); } ##endif len = send(sock, wincoerce(char *, buffer), length, flags); ecl_enable_interrupts(); @(return) = len; } " :one-liner nil)))) (if (= len-sent -1) (socket-error "send") len-sent)))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; ;;; UNIX SOCKETS ;;; #-:wsock (progn (defclass local-socket (socket) ((family :initform +af-local+)) (:documentation "Class representing local domain (AF_LOCAL) sockets, also known as unix-domain sockets.")) (defmethod socket-bind ((socket local-socket) &rest address) (assert (= 1 (length address)) (address) "Socket-bind needs two parameters for local sockets.") (let ((name (first address)) (fd (socket-file-descriptor socket)) (family (socket-family socket))) (if (= -1 (c-inline (fd name family) (:int :cstring :int) :int " { struct sockaddr_un sockaddr; size_t size; int output; ##ifdef BSD sockaddr.sun_len = sizeof(struct sockaddr_un); ##endif sockaddr.sun_family = #2; strncpy(sockaddr.sun_path,#1,sizeof(sockaddr.sun_path)); sockaddr.sun_path[sizeof(sockaddr.sun_path)-1] = 0; ecl_disable_interrupts(); output = bind(#0,(struct sockaddr*)&sockaddr, sizeof(struct sockaddr_un)); ecl_enable_interrupts(); @(return) = output; }")) (socket-error "bind")))) (defmethod socket-accept ((socket local-socket)) (multiple-value-bind (fd name) (c-inline ((socket-file-descriptor socket)) (:int) (values :int :object) "{ struct sockaddr_un sockaddr; socklen_t addr_len = (socklen_t)sizeof(struct sockaddr_un); int new_fd; ecl_disable_interrupts(); new_fd = accept(#0, (struct sockaddr *)&sockaddr, &addr_len); ecl_enable_interrupts(); @(return 0) = new_fd; @(return 1) = (new_fd == -1) ? ECL_NIL : make_base_string_copy(sockaddr.sun_path); }") (cond ((= fd -1) (socket-error "accept")) (t (values (make-instance (class-of socket) :type (socket-type socket) :protocol (socket-protocol socket) :descriptor fd) name))))) (defmethod socket-connect ((socket local-socket) &rest address) (assert (= 1 (length address)) (address) "Socket-connect needs two parameters for local sockets.") (let ((path (first address)) (fd (socket-file-descriptor socket)) (family (socket-family socket))) (if (= -1 (c-inline (fd family path) (:int :int :cstring) :int " { struct sockaddr_un sockaddr; int output; ##ifdef BSD sockaddr.sun_len = sizeof(struct sockaddr_un); ##endif sockaddr.sun_family = #1; strncpy(sockaddr.sun_path,#2,sizeof(sockaddr.sun_path)); sockaddr.sun_path[sizeof(sockaddr.sun_path)-1] = 0; ecl_disable_interrupts(); output = connect(#0,(struct sockaddr*)&sockaddr, sizeof(struct sockaddr_un)); ecl_enable_interrupts(); @(return) = output; }")) (socket-error "connect")))) (defmethod socket-peername ((socket local-socket)) (let* ((fd (socket-file-descriptor socket)) (peer (c-inline (fd) (:int) t " { struct sockaddr_un name; socklen_t len = sizeof(struct sockaddr_un); int ret; ecl_disable_interrupts(); ret = getpeername(#0,(struct sockaddr*)&name,&len); ecl_enable_interrupts(); if (ret == 0) { @(return) = make_base_string_copy(name.sun_path); } else { @(return) = ECL_NIL; } }"))) (if peer peer (socket-error "getpeername")))) ) ;#-:wsock ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; ;;; UNIX SOCKETS [WIN32, using the cygwin way] ;;; #+:wsock (progn (defclass local-socket (socket) ((family :initform +af-local+) proxy-socket local-path) (:documentation "Class representing local domain (AF_LOCAL) sockets, also known as unix-domain sockets.")) (defmethod initialize-instance :after ((socket local-socket) &rest args) (declare (ignore args)) (with-slots (protocol type) socket (setf (slot-value socket 'proxy-socket) (make-instance 'inet-socket :protocol protocol :type type)))) (defmethod socket-bind ((socket local-socket) &rest address) (assert (= 1 (length address)) (address) "Socket-bind needs two parameters for local sockets.") (with-slots (proxy-socket local-path) socket (socket-bind proxy-socket #(127 0 0 1) 0) (multiple-value-bind (ip port) (socket-peername proxy-socket) (handler-case (with-open-file (fd (first address) :if-exists :error :if-does-not-exist :create :direction :output) (format fd "!~D 00000000-00000000-00000000-00000000" port)) (file-error () (socket-close proxy-socket) (c-inline () () nil "WSASetLastError(WSAEADDRINUSE)" :one-liner t) (socket-error "socket-bind"))) (setf local-path (first address)) socket))) (defmethod socket-accept ((socket local-socket)) (multiple-value-bind (new-socket addr) (socket-accept (slot-value socket 'proxy-socket)) (values socket (slot-value socket 'local-path)))) (defmethod socket-connect ((socket local-socket) &rest address) (assert (= 1 (length address)) (address) "Socket-connect needs two parameters for local sockets.") (with-slots (proxy-socket local-path) socket (handler-case (with-open-file (fd (first address) :if-does-not-exist :error :direction :input) (let ((buf (make-string 128)) port) (read-sequence buf fd) (unless (and (string-equal "!" (subseq buf 0 10)) (typep (setq port (read-from-string (subseq buf 10) nil 'eof)) '(integer 0 65535))) (c-inline () () nil "WSASetLastError(WSAEFAULT)" :one-liner t) (socket-error "connect")) (prog1 (socket-connect proxy-socket #(127 0 0 1) port) (setf local-path (first address))))) (file-error () (socket-error "connect"))))) (defmethod socket-peername ((socket local-socket)) (unless (slot-boundp socket 'local-path) (c-inline () () nil "WSASetLastError(WSAENOTCONN)" :one-liner t) (socket-error "socket-peername")) (slot-value socket 'local-path)) (defmethod socket-close ((socket local-socket)) (socket-close (slot-value socket 'proxy-socket)) (slot-makunbound socket 'local-path)) (defmethod socket-make-stream ((socket local-socket) &rest args) (apply #'socket-make-stream (cons (slot-value socket 'proxy-socket) args))) (defmethod non-blocking-mode ((socket local-socket)) (non-blocking-mode (slot-value socket 'proxy-socket))) (defmethod (setf non-blocking-mode) (non-blocking-p (socket local-socket)) (setf (non-blocking-mode (slot-value socket 'proxy-socket)) non-blocking-p)) ) ;#+:wsock ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; ;;; NAMED PIPE SOCKETS [WIN32] ;;; #+:wsock (progn (defclass named-pipe-socket (socket) ((family :initform +af-named-pipe+) (pipe-name :initarg :pipe-name)) (:documentation "Class representing Win32 named pipe, using a socket-like interface.")) (defmethod socket-bind ((socket named-pipe-socket) &rest address) (assert (= 1 (length address)) (address) "Socket-bind needs two parameters for local sockets.") (let* ((pipe-name (concatenate 'string "\\\\.\\pipe\\" (first address))) (hnd (c-inline (pipe-name) (:cstring) :int " { HANDLE hnd; ecl_disable_interrupts(); hnd = CreateNamedPipe( #0, PIPE_ACCESS_DUPLEX, PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_WAIT, PIPE_UNLIMITED_INSTANCES, 4096, 4096, NMPWAIT_USE_DEFAULT_WAIT, NULL); ecl_enable_interrupts(); if (hnd == INVALID_HANDLE_VALUE) @(return) = -1; else @(return) = _open_osfhandle((intptr_t)hnd, O_RDWR); }"))) (when (= hnd -1) (socket-error "CreateNamedPipe")) (setf (slot-value socket 'pipe-name) pipe-name) (setf (slot-value socket 'file-descriptor) hnd))) (defmethod socket-accept ((socket named-pipe-socket)) (let* ((fd (socket-file-descriptor socket)) (afd (c-inline (fd) (:int) :int " { HANDLE hnd = (HANDLE)_get_osfhandle(#0), dupHnd; ecl_disable_interrupts(); if (ConnectNamedPipe(hnd, NULL) != 0 || GetLastError() == ERROR_PIPE_CONNECTED) { @(return) = #0; } else @(return) = -1; ecl_enable_interrupts(); }" :one-liner nil))) (cond ((= afd -1) (socket-error "accept")) (t ;; rebind the socket to create a new named pipe instance in the server (socket-bind socket (subseq (slot-value socket 'pipe-name) 9)) (values (make-instance (class-of socket) :type (socket-type socket) :protocol (socket-protocol socket) :descriptor afd :pipe-name (slot-value socket 'pipe-name)) (slot-value socket 'pipe-name)))))) (defmethod socket-connect ((socket named-pipe-socket) &rest address) (assert (= 1 (length address)) (address) "Socket-connect needs two parameters for local sockets.") (let* ((path (first address)) (pipe-name (concatenate 'string "\\\\.\\pipe\\" path))) (if (= -1 (setf (slot-value socket 'file-descriptor) (c-inline (pipe-name) (:cstring) :int " { HANDLE hnd; ecl_disable_interrupts(); hnd = CreateFile( #0, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL); if (hnd == INVALID_HANDLE_VALUE) @(return) = -1; else @(return) = _open_osfhandle((intptr_t)hnd, O_RDWR); ecl_enable_interrupts(); }"))) (socket-error "connect") (setf (slot-value socket 'pipe-name) pipe-name)))) (defmethod socket-peername ((socket named-pipe-socket)) (slot-value socket 'pipe-name)) (defmethod (setf non-blocking-mode) (non-blocking-p (socket named-pipe-socket)) (let ((fd (socket-file-descriptor socket))) (if (= 0 (c-inline (fd non-blocking-p) (:int t) :int " { DWORD mode = PIPE_READMODE_BYTE | (#1 == ECL_T ? PIPE_NOWAIT : PIPE_WAIT); HANDLE h = (HANDLE)_get_osfhandle(#0); ecl_disable_interrupts(); @(return) = SetNamedPipeHandleState(h, &mode, NULL, NULL); ecl_enable_interrupts(); }" :one-liner nil)) (socket-error "SetNamedPipeHandleState") (setf (slot-value socket 'non-blocking-p) non-blocking-p)))) (defmethod socket-close ((socket named-pipe-socket)) (let ((fd (socket-file-descriptor socket))) (unless (c-inline (fd) (:int) t " { DWORD flags; HANDLE h = (HANDLE)_get_osfhandle(#0); ecl_disable_interrupts(); if (!GetNamedPipeInfo(h, &flags, NULL, NULL, NULL)) @(return) = ECL_NIL; if (flags == PIPE_CLIENT_END || DisconnectNamedPipe(h)) @(return) = ECL_T; else @(return) = ECL_NIL; ecl_enable_interrupts(); }" :one-liner nil) (socket-error "DisconnectNamedPipe")) (call-next-method))) ) ;#+:wsock ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; ;;; NON-BLOCKING MODE ;;; (defmethod non-blocking-mode ((socket socket)) #-:wsock (let ((fd (socket-file-descriptor socket))) (not (zerop (c-inline (fd) (:int) :int "fcntl(#0,F_GETFL,NULL)&O_NONBLOCK" :one-liner t)))) #+:wsock (slot-value socket 'non-blocking-p) ) (defmethod (setf non-blocking-mode) (non-blocking-p (socket socket)) (let ((fd (socket-file-descriptor socket)) (nblock (if non-blocking-p 1 0))) (if (= -1 (c-inline (fd nblock) (:int :int) :int #+:wsock " { int blocking_flag = (#1 ? 1 : 0); ecl_disable_interrupts(); @(return) = ioctlsocket(#0, FIONBIO, (u_long*)&blocking_flag); ecl_enable_interrupts(); }" #-:wsock " { int oldflags = fcntl(#0,F_GETFL,NULL); int newflags = (oldflags & ~O_NONBLOCK) | (#1 ? O_NONBLOCK : 0); ecl_disable_interrupts(); @(return) = fcntl(#0,F_SETFL,newflags); ecl_enable_interrupts(); }")) (socket-error #-:wsock "fcntl" #+:wsock "ioctlsocket") #-:wsock non-blocking-p #+:wsock (setf (slot-value socket 'non-blocking-p) non-blocking-p)))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; ;;; STREAMS ;;; ;;; To actually read/write to/from the sockets, we use Lisp streams. The ;;; following functions take care of building the streams. Fortunately ;;; we do not have to care about things like buffering, binary streams, ;;; etc, but we rather reuse the code from the C core. (For instance ;;; the sockets will be closed upon garbage collection) ;;; (defun dup (fd) (ffi:c-inline (fd) (:int) :int "dup(#0)" :one-liner t)) (defun make-stream-from-fd (fd mode &key buffering element-type (external-format :default) (name "FD-STREAM")) (assert (stringp name) (name) "name must be a string.") (let* ((smm-mode (ecase mode (:input (c-constant "ecl_smm_input")) (:output (c-constant "ecl_smm_output")) (:input-output (c-constant "ecl_smm_io")) #+:wsock (:input-wsock (c-constant "ecl_smm_input_wsock")) #+:wsock (:output-wsock (c-constant "ecl_smm_output_wsock")) #+:wsock (:input-output-wsock (c-constant "ecl_smm_io_wsock")) )) (external-format (unless (subtypep element-type 'integer) external-format)) (stream (ffi:c-inline (name fd smm-mode element-type external-format) (t :int :int t t) t " ecl_make_stream_from_fd(#0,#1,(enum ecl_smmode)#2, ecl_normalize_stream_element_type(#3), 0,#4)" :one-liner t))) (when buffering (si::set-buffering-mode stream buffering)) stream)) (defun auto-close-two-way-stream (stream) (declare (si::c-local)) (ffi:c-inline (stream) (t) :void "(#0)->stream.flags |= ECL_STREAM_CLOSE_COMPONENTS" :one-liner t)) (defun socket-make-stream-inner (fd input output buffering element-type external-format) ;; In Unix we have to create one stream per channel. The reason is ;; that buffered I/O is done using ANSI C FILEs which do not support ;; concurrent reads and writes -- if one thread is listening to the ;; FILE it blocks all output. The solution is to create a ;; two-way-stream when both input and output are T, and force that ;; stream to close its components (small hack in ECL). In Windows we ;; do not have this problem because we do not know how to wrap a ;; FILE around a socket. (cond ((and input output) #+wsock (make-stream-from-fd fd :input-output-wsock :buffering buffering :element-type element-type :external-format external-format) #-wsock (let* ((in (socket-make-stream-inner (dup fd) t nil buffering element-type external-format)) (out (socket-make-stream-inner fd nil t buffering element-type external-format)) (stream (make-two-way-stream in out))) (auto-close-two-way-stream stream) stream)) (input (make-stream-from-fd fd #-wsock :input #+wsock :input-wsock :buffering buffering :element-type element-type :external-format external-format)) (output (make-stream-from-fd fd #-wsock :output #+wsock :output-wsock :buffering buffering :element-type element-type :external-format external-format)) (t (error "SOCKET-MAKE-STREAM: at least one of :INPUT or :OUTPUT has to be true.")))) (defmethod socket-make-stream ((socket socket) &key (input nil input-p) (output nil output-p) (buffering :full) (element-type 'base-char) (external-format :default)) (let ((stream (and (slot-boundp socket 'stream) (slot-value socket 'stream)))) (unless stream ;; Complicated default logic for compatibility with previous releases ;; should disappear soon. (FIXME!) (unless (or input-p output-p) (setf input t output t)) (setf stream (socket-make-stream-inner (socket-file-descriptor socket) input output buffering element-type external-format)) (setf (slot-value socket 'stream) stream) #+ ignore (sb-ext:cancel-finalization socket)) stream)) (defmethod ext::stream-fd ((socket socket)) (socket-file-descriptor socket)) #+:wsock (defmethod socket-make-stream ((socket named-pipe-socket) &key input output (buffering :full) (external-format :default)) (let ((stream (and (slot-boundp socket 'stream) (slot-value socket 'stream)))) (unless stream (setf stream (let* ((fd (socket-file-descriptor socket)) (in (make-stream-from-fd fd :smm-input buffering external-format)) (out (make-stream-from-fd fd :smm-output buffering external-format))) (make-two-way-stream in out))) (setf (slot-value socket 'stream) stream)) stream)) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; ;;; ERROR HANDLING ;;; ;;; A plethora of conditions are defined below, almost one for each ;;; possible error produced by the socket or DNS interface. ;;; #+:wsock (defun get-win32-error-string (num) (c-inline (num) (:int) t "{char *lpMsgBuf; cl_object msg; ecl_disable_interrupts(); FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, #0, 0, (LPTSTR)&lpMsgBuf, 0, NULL); msg = make_base_string_copy(lpMsgBuf); LocalFree(lpMsgBuf); ecl_enable_interrupts(); @(return) = msg;}" :one-liner nil)) ;;; ;;; 1) SOCKET ERRORS ;;; (define-condition socket-error (error) ((errno :initform nil :initarg :errno :reader socket-error-errno) (symbol :initform nil :initarg :symbol :reader socket-error-symbol) (syscall :initform "outer space" :initarg :syscall :reader socket-error-syscall)) (:report (lambda (c s) (let ((num (socket-error-errno c))) (format s "Socket error in \"~A\": ~A (~A)" (socket-error-syscall c) (or (socket-error-symbol c) (socket-error-errno c)) #+:wsock (get-win32-error-string num) #-:wsock (c-inline (num) (:int) :cstring "strerror(#0)" :one-liner t))))) (:documentation "Common base class of socket related conditions.")) (defmacro define-socket-condition (symbol name) `(let () ; Prevents evaluation of constant value at compilation time (defconstant ,symbol (c-constant ,(symbol-name symbol))) (define-condition ,name (socket-error) ((symbol :reader socket-error-symbol :initform (quote ,symbol)))) (export ',name) (push (cons ,symbol (quote ,name)) *conditions-for-errno*))) (defparameter *conditions-for-errno* nil) ;;; this needs the rest of the list adding to it, really. They also ;;; need symbols to be added to constants.ccon ;;; I haven't yet thought of a non-kludgey way of keeping all this in ;;; the same place #+:wsock (Clines "#define EADDRINUSE WSAEADDRINUSE" "#define ECONNREFUSED WSAECONNREFUSED" "#define ETIMEDOUT WSAETIMEDOUT" "#define ENOBUFS WSAENOBUFS" "#define EOPNOTSUPP WSAEOPNOTSUPP" "#define EPROTONOSUPPORT WSAEPROTONOSUPPORT" "#define ESOCKTNOSUPPORT WSAESOCKTNOSUPPORT" "#define ENETUNREACH WSAENETUNREACH" "#define NETDB_INTERNAL WSAEAFNOSUPPORT" "#define NETDB_SUCCESS 0" ) (define-socket-condition EADDRINUSE address-in-use-error) (define-socket-condition EAGAIN interrupted-error) (define-socket-condition EBADF bad-file-descriptor-error) (define-socket-condition ECONNREFUSED connection-refused-error) (define-socket-condition ETIMEDOUT operation-timeout-error) (define-socket-condition EINTR interrupted-error) (define-socket-condition EINVAL invalid-argument-error) (define-socket-condition ENOBUFS no-buffers-error) (define-socket-condition ENOMEM out-of-memory-error) (define-socket-condition EOPNOTSUPP operation-not-supported-error) (define-socket-condition EPERM operation-not-permitted-error) (define-socket-condition EPROTONOSUPPORT protocol-not-supported-error) (define-socket-condition ESOCKTNOSUPPORT socket-type-not-supported-error) (define-socket-condition ENETUNREACH network-unreachable-error) (defun condition-for-errno (err) (or (cdr (assoc err *conditions-for-errno* :test #'eql)) 'socket-error)) (defun socket-error (where) (let* ((errno (c-constant #-:wsock "errno" #+:wsock "WSAGetLastError()")) (condition (condition-for-errno errno))) (error condition :errno errno :syscall where))) ;;; ;;; 2) DNS ERRORS ;;; (defvar *name-service-errno* 0 "The value of h_errno, after it's been fetched from Unix-land by calling GET-NAME-SERVICE-ERRNO") (defun name-service-error (where) (get-name-service-errno) ;; Comment next to NETDB_INTERNAL in netdb.h says "See errno.". ;; This special case treatment hasn't actually been tested yet. (if (= *name-service-errno* (c-constant "NETDB_INTERNAL")) (socket-error where) (let ((condition (condition-for-name-service-errno *name-service-errno*))) (error condition :errno *name-service-errno* :syscall where)))) (define-condition name-service-error (condition) ((errno :initform nil :initarg :errno :reader name-service-error-errno) (symbol :initform nil :initarg :symbol :reader name-service-error-symbol) (syscall :initform "an unknown location" :initarg :syscall :reader name-service-error-syscall)) (:report (lambda (c s) (let ((num (name-service-error-errno c))) (format s "Name service error in \"~A\": ~A (~A)" (name-service-error-syscall c) (or (name-service-error-symbol c) (name-service-error-errno c)) (get-name-service-error-message num)))))) (defmacro define-name-service-condition (symbol name) `(let () (defconstant ,symbol (c-constant ,(symbol-name symbol))) (define-condition ,name (name-service-error) ((symbol :reader name-service-error-symbol :initform (quote ,symbol)))) (push (cons ,symbol (quote ,name)) *conditions-for-name-service-errno*) (export (quote ,symbol)))) (defparameter *conditions-for-name-service-errno* nil) (define-name-service-condition NETDB_INTERNAL netdb-internal-error) (define-name-service-condition NETDB_SUCCESS netdb-success-error) (define-name-service-condition HOST_NOT_FOUND host-not-found-error) (define-name-service-condition TRY_AGAIN try-again-error) (define-name-service-condition NO_RECOVERY no-recovery-error) ;; this is the same as the next one ;;(define-name-service-condition NO_DATA no-data-error) (define-name-service-condition NO_ADDRESS no-address-error) (defun condition-for-name-service-errno (err) (or (cdr (assoc err *conditions-for-name-service-errno* :test #'eql)) 'name-service)) (defun get-name-service-errno () (setf *name-service-errno* (c-constant #-:wsock "h_errno" #+:wsock "WSAGetLastError()"))) (defun get-name-service-error-message (num) #+:nsr (c-inline (num) (:int) :cstring "strerror(#0)" :one-liner t) #+:wsock (get-win32-error-string num) #-(or :wsock :nsr) (c-inline (num) (:int) :cstring "strerror(#0)" :one-liner t) ) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; ;;; SOCKET OPTIONS ;;; (defun get-sockopt-int (fd level const) (let ((ret (c-inline (fd level const) (:int :int :int) t "{ int sockopt, ret; socklen_t socklen = sizeof(int); ecl_disable_interrupts(); ret = getsockopt(#0,#1,#2,wincoerce(char*,&sockopt),&socklen); ecl_enable_interrupts(); @(return) = (ret == 0) ? ecl_make_integer(sockopt) : ECL_NIL; }"))) (if ret ret (error "Sockopt error: ~A" (c-inline () () :cstring "strerror(errno)" :one-liner t))))) (defun get-sockopt-bool (fd level const) (let ((ret (c-inline (fd level const) (:int :int :int) t "{ int sockopt, ret; socklen_t socklen = sizeof(int); ecl_disable_interrupts(); ret = getsockopt(#0,#1,#2,wincoerce(char*,&sockopt),&socklen); ecl_enable_interrupts(); @(return) = (ret == 0) ? ecl_make_integer(sockopt) : ECL_NIL; }"))) (if ret (/= ret 0) (error "Sockopt error: ~A" (c-inline () () :cstring "strerror(errno)" :one-liner t))))) #+wsock (defun get-sockopt-timeval (fd level const) (* 1000 (get-sockopt-int fd level const))) #-wsock (defun get-sockopt-timeval (fd level const) (let ((ret (c-inline (fd level const) (:int :int :int) t "{ struct timeval tv; socklen_t socklen = sizeof(struct timeval); int ret; ecl_disable_interrupts(); ret = getsockopt(#0,#1,#2,wincoerce(char*,&tv),&socklen); ecl_enable_interrupts(); @(return) = (ret == 0) ? ecl_make_doublefloat((double)tv.tv_sec + ((double)tv.tv_usec) / 1000000.0) : ECL_NIL; }"))) (if ret ret (error "Sockopt error: ~A" (c-inline () () :cstring "strerror(errno)" :one-liner t))))) (defun get-sockopt-linger (fd level const) (let ((ret (c-inline (fd level const) (:int :int :int) t "{ struct linger sockopt; socklen_t socklen = sizeof(struct linger); int ret; ecl_disable_interrupts(); ret = getsockopt(#0,#1,#2,wincoerce(char*,&sockopt),&socklen); ecl_enable_interrupts(); @(return) = (ret == 0) ? ecl_make_integer((sockopt.l_onoff != 0) ? sockopt.l_linger : 0) : ECL_NIL; }"))) (if ret ret (error "Sockopt error: ~A" (c-inline () () :cstring "strerror(errno)" :one-liner t))))) (defun set-sockopt-int (fd level const value) (let ((ret (c-inline (fd level const value) (:int :int :int :int) t "{ int sockopt = #3; int ret; ecl_disable_interrupts(); ret = setsockopt(#0,#1,#2,wincoerce(char *,&sockopt),sizeof(int)); ecl_enable_interrupts(); @(return) = (ret == 0) ? ECL_T : ECL_NIL; }"))) (if ret value (error "Sockopt error: ~A" (c-inline () () :cstring "strerror(errno)" :one-liner t))))) (defun set-sockopt-bool (fd level const value) (let ((ret (c-inline (fd level const value) (:int :int :int :object) t "{ int sockopt = (#3 == ECL_NIL) ? 0 : 1; int ret; ecl_disable_interrupts(); ret = setsockopt(#0,#1,#2,wincoerce(char *,&sockopt),sizeof(int)); ecl_enable_interrupts(); @(return) = (ret == 0) ? ECL_T : ECL_NIL; }"))) (if ret value (error "Sockopt error: ~A" (c-inline () () :cstring "strerror(errno)" :one-liner t))))) #-wsock (defun set-sockopt-timeval (fd level const value) (let ((ret (c-inline (fd level const value) (:int :int :int :double) t "{ struct timeval tv; double tmp = #3; int ret; ecl_disable_interrupts(); tv.tv_sec = (int)tmp; tv.tv_usec = (int)((tmp-floor(tmp))*1000000.0); ret = setsockopt(#0,#1,#2,&tv,sizeof(struct timeval)); ecl_enable_interrupts(); @(return) = (ret == 0) ? ECL_T : ECL_NIL; }"))) (if ret value (error "Sockopt error: ~A" (c-inline () () :cstring "strerror(errno)" :one-liner t))))) #+wsock (defun set-sockopt-timeval (fd level const value) (set-sockopt-int fd level const (* 1000 value))) (defun set-sockopt-linger (fd level const value) (let ((ret (c-inline (fd level const value) (:int :int :int :int) t "{ struct linger sockopt = {0, 0}; int value = #3; int ret; if (value > 0) { sockopt.l_onoff = 1; sockopt.l_linger = value; } ecl_disable_interrupts(); ret = setsockopt(#0,#1,#2,wincoerce(char *,&sockopt), sizeof(struct linger)); ecl_enable_interrupts(); @(return) = (ret == 0) ? ECL_T : ECL_NIL; }"))) (if ret value (error "Sockopt error: ~A" (c-inline () () :cstring "strerror(errno)" :one-liner t))))) (eval-when (:compile-toplevel :load-toplevel) (defmacro define-sockopt (name c-level c-const type &optional (read-only nil)) `(progn (export ',name) (defun ,name (socket) (,(intern (format nil "GET-SOCKOPT-~A" type)) (socket-file-descriptor socket) (c-constant ,c-level) (c-constant ,c-const))) ,@(unless read-only `((defun (setf ,name) (value socket) (,(intern (format nil "SET-SOCKOPT-~A" type)) (socket-file-descriptor socket) (c-constant ,c-level) (c-constant ,c-const) value))))))) (define-sockopt sockopt-type "SOL_SOCKET" "SO_TYPE" int t) (define-sockopt sockopt-receive-buffer "SOL_SOCKET" "SO_RCVBUF" int) (define-sockopt sockopt-receive-timeout "SOL_SOCKET" "SO_RCVTIMEO" timeval) (define-sockopt sockopt-send-timeout "SOL_SOCKET" "SO_SNDTIMEO" timeval) (define-sockopt sockopt-reuse-address "SOL_SOCKET" "SO_REUSEADDR" bool) (define-sockopt sockopt-keep-alive "SOL_SOCKET" "SO_KEEPALIVE" bool) (define-sockopt sockopt-dont-route "SOL_SOCKET" "SO_DONTROUTE" bool) (define-sockopt sockopt-linger "SOL_SOCKET" "SO_LINGER" linger) #-(or :sun4sol2 :linux :android :wsock :cygwin) (define-sockopt sockopt-reuse-port "SOL_SOCKET" "SO_REUSEPORT" bool) (define-sockopt sockopt-tcp-nodelay "IPPROTO_TCP" "TCP_NODELAY" bool) ;; Add sockopts here as you need them... ;; Finished loading (provide '#:sockets) (provide '#:sb-bsd-sockets) ecl-16.1.2/contrib/sockets/test.lisp000066400000000000000000000227111266352375300173460ustar00rootroot00000000000000;; -*- Mode: Lisp; Syntax: Common-Lisp -*- ;; $Id$ ;; This file is based on SBCL's SB-BSD-SOCKET module and has been ;; heavily modified to work with ECL by Julian Stecklina. ;; Port to Windows Sockets contributed by M. Goffioul. ;; You may do whatever you want with this file. (PUBLIC DOMAIN) ;; Trivial stuff is copied from SBCL's SB-BSD-SOCKETS, which is also ;; in the public domain. (in-package :cl-user) (load "sys:sockets") (load "../rt/rt") (use-package :sb-bsd-sockets) (use-package :sb-rt) ;;; a real address (deftest make-inet-address (equalp (make-inet-address "127.0.0.1") #(127 0 0 1)) t) ;;; and an address with bit 8 set on some octets (deftest make-inet-address2 (equalp (make-inet-address "242.1.211.3") #(242 1 211 3)) t) (deftest make-inet-socket ;; make a socket (let ((s (make-instance 'inet-socket :type :stream :protocol (get-protocol-by-name "tcp")))) (and (> (socket-file-descriptor s) 1) t)) t) (deftest make-inet-socket-keyword ;; make a socket (let ((s (make-instance 'inet-socket :type :stream :protocol :tcp))) (and (> (socket-file-descriptor s) 1) t)) t) (deftest make-inet-socket-wrong ;; fail to make a socket: check correct error return. There's no nice ;; way to check the condition stuff on its own, which is a shame (handler-case (make-instance 'inet-socket :type :stream :protocol (get-protocol-by-name "udp")) ((or socket-type-not-supported-error protocol-not-supported-error) (c) (declare (ignorable c)) t) (:no-error nil)) t) (deftest make-inet-socket-keyword-wrong ;; same again with keywords (handler-case (make-instance 'inet-socket :type :stream :protocol :udp) ((or protocol-not-supported-error socket-type-not-supported-error) (c) (declare (ignorable c)) t) (:no-error nil)) t) (deftest non-block-socket (let ((s (make-instance 'inet-socket :type :stream :protocol :tcp))) (setf (non-blocking-mode s) t) (non-blocking-mode s)) t) (defun do-gc-portably () ;; cmucl on linux has generational gc with a keyword argument, ;; sbcl GC function takes same arguments no matter what collector is in ;; use #+(or sbcl gencgc) (SB-EXT:gc :full t) #+ecl (ext:gc t) ;; other platforms have full gc or nothing #-(or sbcl gencgc ecl) (sb-ext:gc)) (deftest inet-socket-bind (let ((s (make-instance 'inet-socket :type :stream :protocol (get-protocol-by-name "tcp")))) ;; Given the functions we've got so far, if you can think of a ;; better way to make sure the bind succeeded than trying it ;; twice, let me know ;; 1974 has no special significance, unless you're the same age as me (do-gc-portably) ;gc should clear out any old sockets bound to this port (socket-bind s (make-inet-address "127.0.0.1") 1974) (handler-case (let ((s2 (make-instance 'inet-socket :type :stream :protocol (get-protocol-by-name "tcp")))) (socket-bind s2 (make-inet-address "127.0.0.1") 1974) nil) (address-in-use-error () t))) t) (deftest simple-sockopt-test ;; test we can set SO_REUSEADDR on a socket and retrieve it, and in ;; the process that all the weird macros in sockopt happened right. (let ((s (make-instance 'inet-socket :type :stream :protocol (get-protocol-by-name "tcp")))) (setf (sockopt-reuse-address s) t) (sockopt-reuse-address s)) t) (defun read-buf-nonblock (buffer stream) "Like READ-SEQUENCE, but returns early if the full quantity of data isn't there to be read. Blocks if no input at all" (let ((eof (gensym))) (do ((i 0 (1+ i)) (c (read-char stream nil eof) (read-char-no-hang stream nil eof))) ((or (>= i (length buffer)) (not c) (eq c eof)) i) (setf (elt buffer i) c)))) (deftest name-service-return-type (vectorp (host-ent-address (get-host-by-address #(127 0 0 1)))) t) ;;; these require that the echo services are turned on in inetd (deftest simple-tcp-client (let ((s (make-instance 'inet-socket :type :stream :protocol :tcp)) (data (make-string 200))) (socket-connect s #(127 0 0 1) 7) (let ((stream (socket-make-stream s :input t :output t :buffering :none))) (format stream "here is some text") (let ((data (subseq data 0 (read-buf-nonblock data stream)))) (format t "~&Got ~S back from TCP echo server~%" data) (> (length data) 0)))) t) (deftest sockaddr-return-type (let ((s (make-instance 'inet-socket :type :stream :protocol :tcp))) (unwind-protect (progn (socket-connect s #(127 0 0 1) 7) (multiple-value-bind (host port) (socket-peername s) (and (vectorp host) (numberp port)))) (socket-close s))) t) (deftest simple-udp-client (let ((s (make-instance 'inet-socket :type :datagram :protocol (get-protocol-by-name "udp"))) (data (make-string 200))) (format t "Socket type is ~A~%" (sockopt-type s)) (socket-connect s #(127 0 0 1) 7) (let ((stream (socket-make-stream s :input t :output t :buffering :none))) (format stream "here is some text") (finish-output stream) (let ((data (subseq data 0 (read-buf-nonblock data stream)))) (format t "~&Got ~S back from UDP echo server~%" data) (> (length data) 0)))) t) ;;; A fairly rudimentary test that connects to the syslog socket and ;;; sends a message. Priority 7 is kern.debug; you'll probably want ;;; to look at /etc/syslog.conf or local equivalent to find out where ;;; the message ended up (deftest simple-local-client (progn ;; SunOS (Solaris) and Darwin systems don't have a socket at ;; /dev/log. We might also be building in a chroot or ;; something, so don't fail this test just because the file is ;; unavailable, or if it's a symlink to some weird character ;; device. (when (and (probe-file "/dev/log") #-ecl (sb-posix:s-issock (sb-posix::stat-mode (sb-posix:stat "/dev/log")))) (let ((s (make-instance 'local-socket :type :datagram))) (format t "Connecting ~A... " s) (finish-output) (handler-case (socket-connect s "/dev/log") (socket-error () (setq s (make-instance 'local-socket :type :stream)) (format t "failed~%Retrying with ~A... " s) (finish-output) (socket-connect s "/dev/log"))) (format t "ok.~%") (let ((stream (socket-make-stream s :input t :output t :buffering :none))) (format stream "<7>sb-bsd-sockets: Don't panic. We're testing local-domain client code; this message can safely be ignored")))) t) t) ;;; these require that the internet (or bits of it, at least) is available (deftest get-host-by-name (equalp (car (host-ent-addresses (get-host-by-name "a.root-servers.net"))) #(198 41 0 4)) t) (deftest get-host-by-address (host-ent-name (get-host-by-address #(198 41 0 4))) "a.root-servers.net") (deftest get-host-by-name-wrong (handler-case (get-host-by-name "foo.tninkpad.telent.net") (NAME-SERVICE-ERROR () t) (:no-error nil)) t) (defun http-stream (host port request) (let ((s (make-instance 'inet-socket :type :stream :protocol :tcp))) (socket-connect s (car (host-ent-addresses (get-host-by-name host))) port) (let ((stream (socket-make-stream s :input t :output t :buffering :none))) (format stream "~A HTTP/1.0~%~%" request)) s)) (deftest simple-http-client-1 (handler-case (let ((s (http-stream "ww.telent.net" 80 "HEAD /"))) (let ((data (make-string 200))) (setf data (subseq data 0 (read-buf-nonblock data (socket-make-stream s)))) (princ data) (> (length data) 0))) (network-unreachable-error () 'network-unreachable)) t) (deftest sockopt-receive-buffer ;; on Linux x86, the receive buffer size appears to be doubled in the ;; kernel: we set a size of x and then getsockopt() returns 2x. ;; This is why we compare with >= instead of = (handler-case (let ((s (http-stream "ww.telent.net" 80 "HEAD /"))) (setf (sockopt-receive-buffer s) 1975) (let ((data (make-string 200))) (setf data (subseq data 0 (read-buf-nonblock data (socket-make-stream s)))) (and (> (length data) 0) (>= (sockopt-receive-buffer s) 1975)))) (network-unreachable-error () 'network-unreachable)) t) ;;; we don't have an automatic test for some of this yet. There's no ;;; simple way to run servers and have something automatically connect ;;; to them as client, unless we spawn external programs. Then we ;;; have to start telling people what external programs they should ;;; have installed. Which, eventually, we will, but not just yet ;;; to check with this: can display packets from multiple peers ;;; peer address is shown correctly for each packet ;;; packet length is correct ;;; long (>500 byte) packets have the full length shown (doesn't work) (defun udp-server (port) (let ((s (make-instance 'inet-socket :type :datagram :protocol :udp))) (socket-bind s #(0 0 0 0) port) (loop (multiple-value-bind (buf len address port) (socket-receive s nil 500) (format t "Received ~A bytes from ~A:~A - ~A ~%" len address port (subseq buf 0 (min 10 len))))))) ecl-16.1.2/contrib/unicode/000077500000000000000000000000001266352375300154465ustar00rootroot00000000000000ecl-16.1.2/contrib/unicode/load-names.lisp000066400000000000000000000111721266352375300203610ustar00rootroot00000000000000(defun split-words (text &key (set '(#\Space)) (exclude t)) (loop with start = 0 with output = '() with elt-type = (array-element-type text) for i from 0 below (length text) for c across text when (member c set) do (setf output (list* (make-array (+ (- i start) (if exclude 0 1)) :element-type elt-type :displaced-to text :displaced-index-offset start) output) start (1+ i)) finally (return (nreverse (list* (make-array (- i start) :element-type elt-type :displaced-to text :displaced-index-offset start) output))))) (defun encode-words (words hash) (loop for word in words collect (or (gethash word hash) (let* ((word (copy-seq word)) (ndx (hash-table-count hash))) (setf (gethash word hash) (1+ ndx)))))) (defun fixup-hangul-syllables (dictionary) ;; "Hangul Syllable Composition, Unicode 5.1 section 3-12" (let* ((sbase #xac00) (lbase #x1100) (vbase #x1161) (tbase #x11a7) (scount 11172) (lcount 19) (vcount 21) (tcount 28) (ncount (* vcount tcount)) (table (make-hash-table))) (with-open-file (*standard-input* (make-pathname :name "Jamo" :type "txt")) (loop for line = (read-line nil nil) while line if (position #\; line) do (add-jamo-information line table))) (loop for sindex from 0 below scount for l = (+ lbase (floor sindex ncount)) for v = (+ vbase (floor (mod sindex ncount) tcount)) for tee = (+ tbase (mod sindex tcount)) for name = (list* "HANGUL_" "SYLLABLE_" (gethash l table) (gethash v table) (unless (= tee tbase) (list (gethash tee table)))) for code = (+ sbase sindex) collect (list* code (apply #'concatenate 'string name) (encode-words name dictionary))))) (defun add-jamo-information (line table) (let* ((split (split-words line :set '(#\;) :exclude t)) (code (parse-integer (first split) :radix 16)) (syllable (string-trim '(#\Space) (subseq (second split) 0 (position #\# (second split)))))) (setf (gethash code table) syllable))) (defvar *words*) (defparameter *data* (with-open-file (in "~/src/sbcl/tools-for-build/UnicodeData.txt" :direction :input) (loop with words = (setf *words* (make-hash-table :size 1024 :test #'equal)) for ucd-line = (read-line in nil nil nil) while ucd-line nconc (let* ((ucd-data (split-words ucd-line :set '(#\;))) (code (first ucd-data)) (name (second ucd-data))) (unless (eql (char name 0) #\<) (setf name (substitute #\_ #\Space name)) (list (list* (parse-integer code :radix 16) name (encode-words (split-words name :set '(#\Space #\_ #\-) :exclude nil) words)))))))) (print (length *data*)) (print (first (last *data*))) ;#+(or) (progn (setf *data* (sort (nconc (fixup-hangul-syllables *words*) *data*) #'< :key #'car)) (print (length *data*)) (print (first (last *data*)))) (defparameter *words-array* (loop with array = (make-array (1+ (hash-table-count *words*))) for k being the hash-key in *words* using (hash-value v) do (setf (aref array v) k) finally (return array))) (defparameter *last-word-index* (1- (length *words-array*))) (defparameter *words-array-bytes* (loop for c across *words-array* sum (1+ (length c)))) (defun code-to-string (code) (aref *words-array* code)) (defparameter *flattened-data* (loop for (code name . rest) in *data* nconc (append rest (list 0)))) (defparameter *group-names* (loop with output = '() with start = (first (first *data*)) with last = start for (code name . rest) in *data* do (when (>= (- code last) 2) (setf output (cons (list start last) output) start code)) (setf last code) finally (return (nreverse (cons (list start code) output))))) ecl-16.1.2/contrib/unicode/names-pairs-sort.lisp000066400000000000000000000227651266352375300215570ustar00rootroot00000000000000(defparameter *destination* (merge-pathnames "../../src/c/unicode/" (or *load-truename* *compile-pathname*))) (let* ((translated-data (copy-tree *compressed-data*)) (pairs (copy-tree *paired-data*)) (first-code (loop for (pair-code . pair) in pairs minimize pair-code)) (last-code (loop for (pair-code . pair) in pairs maximize pair-code))) ;; ;; We make sure that for each character there is a unique pair which is not ;; used anywhere else ;; (loop with used-code = (make-array (1+ last-code) :initial-element nil) for line in translated-data for pair-code = (third line) do (cond ((/= (length line) 3) (error "Error in compressed data: too long code ~A" line)) ((or (aref used-code pair-code) (< pair-code first-code)) (let ((new-pair (cons pair-code 0))) (setf pairs (acons (incf last-code) new-pair pairs) (third line) last-code))) (t (setf (aref used-code pair-code) t)))) ;; ;; We now renumber all pairs. ;; (let ((translation-table (make-array (1+ last-code) :initial-element nil)) (counter -1)) (flet ((add-code (code) (or (aref translation-table code) (setf (aref translation-table code) (incf counter)))) (translate (old-code) (or (aref translation-table old-code) (error "Unknown code ~A" old-code)))) ;; First of all we add the words (loop for i from 0 below first-code do (add-code i)) ;; Then we add all pairs that represent characters, so that they ;; are consecutive, too. (loop for line in translated-data do (setf (third line) (add-code (third line)))) ;; Finally, we add the remaining pairs (loop for record in pairs do (setf (car record) (add-code (car record)))) ;; ... and we fix the definitions (loop for (code . pair) in pairs do (setf (car pair) (translate (car pair)) (cdr pair) (translate (cdr pair)))))) (defparameter *sorted-compressed-data* translated-data) (defparameter *sorted-pairs* (sort pairs #'< :key #'car)) (print 'finished) ) (defparameter *grouped-characters* (loop with last-ucd-code = nil with start-ucd-code = nil with start-code = nil with output = '() with aux = '() for n from (third (first *sorted-compressed-data*)) for line in *sorted-compressed-data* for (ucd-code name code) = line do (cond ((/= code n) (error "Codes in *sorted-compressed-data* are not consecutive:~%~A" (cons line (subseq aux 0 10)))) ((null start-ucd-code) (setf start-ucd-code ucd-code start-code code)) ((= last-ucd-code (1- ucd-code)) ) (t (push (list start-ucd-code last-ucd-code start-code) output) (setf start-ucd-code ucd-code start-code code))) (setf last-ucd-code ucd-code aux (cons line aux)) finally (return (nreverse output)))) (with-open-file (s (merge-pathnames "ucd_names.h" *destination*) :direction :output :if-exists :supersede) (format s "/* * UNICODE NAMES DATABASE */ #ifndef ECL_UCD_NAMES_H #define ECL_UCD_NAMES_H 1 #define ECL_UCD_FIRST_PAIR ~D #define ECL_UCD_TOTAL_PAIRS ~D #define ECL_UCD_TOTAL_GROUPS ~D #define ECL_UCD_LARGEST_CHAR_NAME ~D #define ECL_UCD_TOTAL_NAMES ~D typedef struct { unsigned char codes[4]; } ecl_ucd_names_pair_type; typedef struct { int smallest, largest, pair_code; } ecl_ucd_names_char_group; typedef struct { unsigned char pair[2]; unsigned char code[3]; } ecl_ucd_code_and_pair; extern const ecl_ucd_names_pair_type ecl_ucd_names_pair[ECL_UCD_TOTAL_PAIRS]; extern const ecl_ucd_names_char_group ecl_ucd_names_char[ECL_UCD_TOTAL_GROUPS]; extern const char *ecl_ucd_names_word[ECL_UCD_FIRST_PAIR]; extern const ecl_ucd_code_and_pair ecl_ucd_sorted_pairs[ECL_UCD_TOTAL_NAMES]; #endif " (1+ *last-word-index*) (length *sorted-pairs*) (length *grouped-characters*) (loop for (code name . rest) in *compressed-data* maximize (length name)) (length *compressed-data*) )) (with-open-file (s (merge-pathnames "ucd_names_pair.c" *destination*) :direction :output :if-exists :supersede) (format s "/* * Pairs of symbols. */ #include #include \"ucd_names.h\" const ecl_ucd_names_pair_type ecl_ucd_names_pair[ECL_UCD_TOTAL_PAIRS] = { " (length *sorted-pairs*) (length *sorted-pairs*)) (loop for i from 0 for (pair-code . (a . b)) in *sorted-pairs* do (format s "~A{~D, ~D, ~D, ~D}~%" (if (plusp i) "," "") (logand a #xff) (ash a -8) (logand b #xff) (ash b -8) )) (format s "};~%")) (with-open-file (s (merge-pathnames "ucd_names_codes.c" *destination*) :direction :output :if-exists :supersede) (format s "/* * Sorted character names. */ #include #include \"ucd_names.h\" const ecl_ucd_code_and_pair ecl_ucd_sorted_pairs[ECL_UCD_TOTAL_NAMES] = { ") (loop with l = (sort (copy-tree *sorted-compressed-data*) #'string<= :key #'second) for (ucd-code name code) in l for i from 0 do (format s "~A{{~D, ~D}, {~D, ~D, ~D}}~%" (if (plusp i) "," "") (logand code #xff) (ash code -8) (logand ucd-code #xff) (logand (ash ucd-code -8) #xff) (logand (ash ucd-code -16) #xff))) (format s "};")) (with-open-file (s (merge-pathnames "ucd_names_str.c" *destination*) :direction :output :if-exists :supersede) (format s "/* * Dictionary words. */ #include #include \"ucd_names.h\" const char *ecl_ucd_names_word[ECL_UCD_FIRST_PAIR] = { ") (loop for i from 0 for c across *words-array* do (format s "~A~S~%" (if (plusp i) "," "") (or c ""))) (format s "};~%")) (with-open-file (s (merge-pathnames "ucd_names_char.c" *destination*) :direction :output :if-exists :supersede) (format s "/* * Dictionary words. */ #include #include #include \"ucd_names.h\" const ecl_ucd_names_char_group ecl_ucd_names_char[ECL_UCD_TOTAL_GROUPS] = { " (length *grouped-characters*)) (loop for i from 0 for (start end pair-code) in *grouped-characters* do (format s "~A{~D,~D,~D}~%" (if (plusp i) "," "") start end pair-code)) (format s "}; static int search_pair(ecl_character c) { int mid, low = 0, up = ECL_UCD_TOTAL_GROUPS-1; do { mid = (up + low) / 2; if (c < ecl_ucd_names_char[mid].smallest) up = mid-1; else if (c > ecl_ucd_names_char[mid].largest) low = mid+1; else return (c - ecl_ucd_names_char[mid].smallest) + ecl_ucd_names_char[mid].pair_code; } while (low <= up && (low >= 0) && (up < ECL_UCD_TOTAL_GROUPS)); return -1; } static void fill_pair_name(char *buffer, int pair) { if (pair < ECL_UCD_FIRST_PAIR) { strncat(buffer, ecl_ucd_names_word[pair], ECL_UCD_LARGEST_CHAR_NAME+1); /* printf(\"text=%s\\n\", ecl_ucd_names_word[pair]); */ } else { const ecl_ucd_names_pair_type p = ecl_ucd_names_pair[pair - ECL_UCD_FIRST_PAIR]; /* printf(\"ndx=%d\\n\", pair - ECL_UCD_FIRST_PAIR); printf(\"c0=%d\\n\", ecl_ucd_names_pair[pair - ECL_UCD_FIRST_PAIR].codes[0]); printf(\"c1=%d\\n\", ecl_ucd_names_pair[pair - ECL_UCD_FIRST_PAIR].codes[1]); printf(\"c2=%d\\n\", ecl_ucd_names_pair[pair - ECL_UCD_FIRST_PAIR].codes[2]); printf(\"c3=%d\\n\", ecl_ucd_names_pair[pair - ECL_UCD_FIRST_PAIR].codes[3]); */ fill_pair_name(buffer, (((unsigned int)p.codes[1]) << 8) | p.codes[0]); fill_pair_name(buffer, (((unsigned int)p.codes[3]) << 8) | p.codes[2]); } } cl_object _ecl_ucd_code_to_name(ecl_character c) { int pair = search_pair(c); if (pair < 0) return ECL_NIL; else { char buffer[ECL_UCD_LARGEST_CHAR_NAME+1]; buffer[0] = 0; fill_pair_name(buffer, pair); return make_base_string_copy(buffer); } } cl_object _ecl_ucd_name_to_code(cl_object name) { int mid, low = 0, up = ECL_UCD_TOTAL_NAMES-1; int l = ecl_length(name); if (l <= ECL_UCD_LARGEST_CHAR_NAME) { char buffer1[ECL_UCD_LARGEST_CHAR_NAME+1]; char buffer2[ECL_UCD_LARGEST_CHAR_NAME+1]; for (mid = 0; mid < l; mid++) { ecl_character c = ecl_char_upcase(ecl_char(name, mid)); buffer1[mid] = c; if (c < 32 || c > 127) /* All character names are [-A-Z_0-9]* */ return ECL_NIL; } buffer1[mid] = 0; do { ecl_ucd_code_and_pair p = ecl_ucd_sorted_pairs[mid = (low + up) / 2]; int flag, pair = ((unsigned int)p.pair[1] << 8) | p.pair[0]; buffer2[0] = 0; fill_pair_name(buffer2, pair); flag = strcmp(buffer1, buffer2); /* printf(\"[%d,%d,%d] %s <> (%d)%s -> %d\\n\", low, mid, up, buffer1, pair, buffer2, flag); */ if (flag == 0) { return ecl_make_fixnum(((unsigned int)p.code[2] << 16) | ((unsigned int)p.code[1] << 8) | p.code[0]); } else if (flag < 0) { up = mid - 1; } else { low = mid + 1; } } while (low <= up); } return ECL_NIL; } ")) ;(ext:run-program "/bin/sh" '("-c" "cp *.c *.h ~/devel/ecl/src/c/unicode/")) ecl-16.1.2/contrib/unicode/names-pairs.lisp000066400000000000000000000103031266352375300205530ustar00rootroot00000000000000(load "./load-names.lisp") (declaim (optimize (debug 0) (speed 3))) (setf *print-circle* t) (defun compute-pairs (data table) (clrhash table) (loop with max = 0 with max-pair = nil for (code name . l) in data do (loop for l2 on l for a = (car l2) for b = (cadr l2) while b do (let* ((pair (cons a b)) (c (gethash pair table))) (setf (gethash pair table) (setf c (if c (1+ c) 1)) a b) (when (> c max) (setf max c max-pair pair)))) finally (return (cons max max-pair)))) (defun replace-pair (pair code data) (let ((old-a (car pair)) (old-b (cdr pair))) (loop with more = 0 for (ucd-code name . l) in data do (loop with l2 = l for a = (first l2) for b = (second l2) while b do (when (and (eql a old-a) (eql b old-b)) ;; replace (a b . c) with (pair . c) (setf (car l2) code (cdr l2) (cddr l2))) do (setf l2 (cdr l2))) do (setf more (+ more (1- (length l)))) finally (return more)))) (defun compress (data) (loop with last-length = 0 with table = (make-hash-table :size 2048 :test #'equal) with pairs = '() for new-symbol from (1+ *last-word-index*) for (frequency . pair) = (compute-pairs data table) while (and pair (> frequency 1)) do (format t "~%;;; ~A, ~D -> ~D, ~D left" pair frequency new-symbol (replace-pair pair new-symbol data)) (setf pairs (acons new-symbol pair pairs)) finally ;; There are no redundant pairs. We just define ad-hoc new ;; symbols for all remaining strings. (loop with n = new-symbol for (code name . l) in data do (loop with l2 = l for a = (first l2) for b = (second l2) while b do (setf pairs (acons n (cons a b) pairs) (car l2) n (cdr l2) (cddr l2) n (1+ n)))) (print 'finished) (return-from compress (nreverse pairs)))) (progn (defparameter *compressed-data* (copy-tree *data*)) (defparameter *paired-data* (compress *compressed-data*))) (defparameter *last-code* (first (first (last *paired-data*)))) (defparameter *code-ndx-size* (ceiling (integer-length *last-code*) 8)) (defparameter *pair-table-size* (* (length *paired-data*) (* 2 *code-ndx-size*))) (defparameter *code-to-name-bytes* (* (length *compressed-data*) (+ 3 ; Size of Unicode code ;; Size of index into the data table *code-ndx-size*))) (defparameter *sorted-names-bytes* ;; The sorted list of character names is just a list of indices into ;; the *code-to-name-bytes* table (* (length *compressed-data*) *code-ndx-size*)) (defparameter *word-dictionary* (+ *words-array-bytes*)) (format t " ;;; Codes dictionary = ~D bytes ;;; Pair table size = ~D bytes ;;; Code to names table = ~D bytes ;;; Names to codes table = ~D bytes ;;; Total = ~D bytes " *word-dictionary* *pair-table-size* *code-to-name-bytes* *sorted-names-bytes* (+ *word-dictionary* *pair-table-size* *code-to-name-bytes* *sorted-names-bytes* )) ;;; WITH HANGUL ;;; Codes dictionary = 78566 bytes ;;; Pair table size = 198752 bytes ;;; Code to names table = 164570 bytes ;;; Names to codes table = 65828 bytes ;;; Total = 507716 bytes ;;; WITHOUT HANGUL ;;; Codes dictionary = 78555 bytes ;;; Pair table size = 150868 bytes ;;; Code to names table = 108710 bytes ;;; Names to codes table = 43484 bytes ;;; Total = 381617 bytes ;;; Without HANGUL (split by space and -) ;;; Codes dictionary = 58258 bytes ;;; Pair table size = 160576 bytes ;;; Code to names table = 108710 bytes ;;; Names to codes table = 43484 bytes ;;; Total = 371028 bytes ;;; With HANGUL (split by space and -) ;;; Codes dictionary = 58269 bytes ;;; Pair table size = 208460 bytes ;;; Code to names table = 164570 bytes ;;; Names to codes table = 65828 bytes ;;; Total = 497127 bytes ecl-16.1.2/contrib/unicode/ucd.dat000066400000000000000000003477021266352375300167300ustar00rootroot00000000000000Рџџџџџџџџџџџџџџ џџџџџџџџџџџџџџџџџџџџџџџџ џџ џџ џџ џџџџџџџџџџџџ џџ  џџ иџџ тџџ џџ џџ џџ џџ џџ џџ џџ џџ џџ џџ џџ џџ џџ џџ џџ џџ џџ џџ џџ џџ џџ џџ џџ џџ џџ џџ џџ џџ џџ џџ !џџ "џџ #џџ $џџ Tџџ [џџ gџџ kџџ vџџ zџџ џџ ‚џџ „џџ Ъџџ жџџ иџџ кџџ мџџ оџџ рџџ фџџ цџџ шџџ щџџ ъџџ №џџ                                         џџ џџџџџџџџџџџџџ џџџџџџџџџџџџ џџџџџџџџџџџ  џџ џ џ џ џ џ џ џ џ џ џ џџџџџџ џџџџ џџџџ џџ џџ џџ џџ џџ џџџџџџџџџџџџ џџџџ џџ џџџџџџџџџџ џџџџџџџџџџџџ џџ џџџџџџџџ џџџџџџџџџџ  !"#$%&'()*+,-./0123456789:;<=>????????@@@@@@@@@@@@@@@@@@@@@@@@@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijjkl@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@m@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@mџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ   зРРОХОРРУЖРЫНВННbcdefghijkНРЯЮЯРРabcdefghijklmnopqrstuvwxyzУРЖШБШABCDEFGHIJKLMNOPQRSTUVWXYZУЮЖЮ жРХХХХггШгКЮгШбЬШœгРШŽИЁЁЁРрстуфхцчшщъыьэюя№ёђѓєѕіЮјљњћќ§ўРСТУФХЦЧШЩЪЫЬЭЮЯабвгдежЮийклмноx     ! #"%$'&)(+*-,/.iI325476:9<;>=@?BADCFEHGKJMLONQPSRUTWVYX[Z]\_^a`cbedgfihkjmlonqpsrutwvџzy|{~}SCSƒ‚…„Tˆ‡VWŒ‹нY[’‘`cіih™˜=or uЁ ЃЂЅЄ€ЈЇƒ­ЌˆАЏŠ‹ДГЖЕ’ЙИ НМї ЦФФЩЧЧЬЪЪЮЭаЯвбдгжеизкймлŽпосрутхфчцщшыъэьяюѓёёѕє•Пљјћњ§ќџў     ž#"%$'&)(+*-,/.1032e,<;šf,~,,BA€‰ŒGFIHKJMLONo,m,p,†‰Š“”Ї—–b,œn,Ÿd,ІЉЎDБВEЗ ШШШШШШШШШШШШШШШШШШШШШШШШШШШШШШШШШШШШШШШШШШШSSSSSSSSSSSSSSSSSSSSSTOOOOTMOOOOOKKOOOOKKOOOOOOOOOOO#####OOOOSSSSSSSSW™SOOOSSSOO"SSSOOOOSTOOSUVVUVVUSSSSSSSSSSSSSqpsrШwvџџ§ўџРџџџџџШШЌР­ЎЏџЬџЭЮБВГДЕЖЗИЙКЛМНОПРСџУФХЦЧШЩЪЫ†ˆ‰Š‘’“”•–—˜™š›œžŸ ЁЃЃЄЅІЇЈЉЊЋŒŽз’˜І ЯйилкнмпосрутхфчцщшыъэьяюšЁљИ•Юјїђћњ{|}PQRSTUVWXYZ[\]^_0123456789:;<=>?@ABCDEFGHIJKLMNO !"#$%&'()*+,-./     a`cbedgfihkjmlonqpsrutwvyx{z}|~€вSSSSS ‹ŠŒŽ‘“’•”—–™˜›šœŸžЁ ЃЂЅЄЇІЉЈЋЊ­ЌЏЎБАГВЕДЗЖЙИЛКНМПОЯТСФУЦХШЧЪЩЬЫЮЭРбагведзжйилкнмпосрутхфчцщшыъэьяюё№ѓђѕєїіљјћњ§ќџў     ! #"%$'&џџџџџџџџџabcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†џџППППППџ123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVџПГџџџџџџOSSSSOSSSPOSSSSSSOOOOOOSSOSSPRS'()*+,-./00123Д4С56СSOС/џџџџџџџџ џџџџџ ССџџџџџџџџџџџџџЮЮЩООФНЛггSSSSSSSS;<=ЛџџЛЛ  89:;<=>?SSOOSSSSSOSSOXYZ[\]^_`aОММЛ @ Л SSSSSSSгSSSSOSSSгOSSO bcdefghijk аа ЛЛЛЛЛЛЛЛЛЛЛЛЛЛџ A SOSSOSSOOOSOOSOSSSOSOSOSOSSџџ """"""""""" џџџџџџџџџџџџџџvwxyz{|}~ SSSSSSSOSгРРРџџџџџ SSSSSSSSSSSSSSSSSSSSSџџСССССССССССССССџ OOOџџСџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ""" "$ """"""""& SOSS""" ""ППlmnopqrstuП џ џ"џ џџ џџ џ џ џџџ џџ$ """"џџџџ& џџџџџџџџџџџџ џ ""џџlmnopqrstu ХХ——————вХџџџџџ""џ џџџџ џџ џ џ џ џ џџ$џ""џџџџ""џџ""&џџџ"џџџџџџџ џ џџџџџџџlmnopqrstu"" "џџџџџџџџџџџ""џ џ џ џ џ џ џџ$ """""џ""џ&џџ џџџџџџџџџџџџџџџ ""џџlmnopqrstuџХџџџџџџџџџџџџџџџ"џ џџ џџ џ џ џ џџ$ """""џџџџ&џџџџџџџџ"џџџџ џ ""џџlmnopqrstuв ——————џџџџџџџџџџ" џ џџџ џ џџџ џ џ џџџ џџџ џџџ џџџџ"џџџџ&џџ џџџџџџџџџџџџџџџџџџџџlmnopqrstu———ггггггХгџџџџџџџ џ џ џ џ џџџ """џ"""џ"""&џџџџџџџBCџ џџџџџџ ""џџlmnopqrstuџџџџџџџџЁЁЁЁЁЁЁвџџџ џ џ џ џ џџ$ !џ!џ"&џџџџџџџџџџџџџџ џ ""џџlmnopqrstuџ џџџџџџџџџџџџџџџџ џ џ џџ """"џџ& џџџџџџџџџџџџџџџџ ""џџlmnopqrstu——————џџџв џџџ џџџ џ џ џџ џџџ&џџџџ"""џ"џџџџџџџџџџџџџџџџџџџПџџџџџџџџџџџџ " """"DD&џџџџХ "EEEE"""ПlmnopqrstuППџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ џ џџ џ џџ џџџџџџ џ џ џ џ џџ џ " """"FFџ"" џџ џџGGGG""џџlmnopqrstuџџ џџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ вввПППППППППППППППвввввOOввввввlmnopqrstu——————————вOвOвMУЖУЖ џ џџџџHI"J"""""IIII"I"SS&ПSS """""""""""џ""""""""""""""""""""""""""""""""""""џввввввввOввввввџввПППППввввППџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ """""""""$&&"" lmnopqrstuПППППП "" """   """" """O lmnopqrstu"вв--------- - - - - ------------------- -!-"-#-$-%-џџџџџџџџџџ Пџџџ џ џџ џ џ џџ џ џџ џ џџ џ џ џџ џ џ џџ џџSSSвПППППППϘ™š›œžŸ ———————————џџџ ггггггггггџџџџџџ џџџџџџџџџџџГ ПП з УЖџџџ ППП€€€џџџџџџџџџџџџџџџ џ ""&џџџџџџџџџџџ ""&ППџџџџџџџџџ ""џџџџџџџџџџџџ џ џ""џџџџџџџџџџџџ """""""""""""""""&"ППППППХ SџџlmnopqrstuџџџџџџЁЁЁЁЁЁЁЁЁЁџџџџџџРРРРРРГРРРР"""зџlmnopqrstuџџџџџџ  џџџџџџџџ R џџџџџ џџџџџџџџџџ џџџ"""""џџџџ"PSOџџџџгџџџРРlmnopqrstu џџ џџџџџџџџџџџ џџџџ џџџџџџlmnopqrstu˜џџџгггггггггггггггггггггггггггггггггг SOџџПП """"""""џ&"""""""""""SSSSSSSSџџOlmnopqrstuџџџџџџlmnopqrstuџџџџџџПППППППППППППџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ"""" $""""""" џџџџlmnopqrstuПППППППввввввввввSOSSSSSSSвввввввввџџџ"" """"""џџџ lmnopqrstuџџџџџџ $""""""џџџџџџџџПППП """""""""$џџџПППППlmnopqrstuџџџ lmnopqrstu ППџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџSSSП#OOOOOSSOOOOS####### O џџџџџџџџџџџџџ}Їc,SSOSSSSSSSOSSVLOKSSSSSSSSSSSSSSSSSSSSSSџџџџџџџџџџџџџџџџџџџџџUOSO     ! #"%$'&)(+*-,/.1032547698;:=<?>A@CBEDGFIHKJMLONQPSRUTWVYX[Z]\_^a`cbedgfihkjmlonqpsrutwvyx{z}|~€ƒ‚…„‡†‰ˆ‹ŠŒŽ‘“’•”`пЁ ЃЂЅЄЇІЉЈЋЊ­ЌЏЎБАГВЕДЗЖЙИЛКНМПОСРУТХФЧЦЩШЫЪЭЬЯЮбагведзжйилкнмпосрутхфчцщшыъэьяюё№ѓђѕєїіљјћњ§ќџў     џџџџ()*+,-./ !"#$%&'89:;<=>?01234567HIJKLMџџ@ABCDEџџY[]_џQџSџUџWhijklmno`abcdefgКЛШЩЪЫклјљъыњћџџˆ‰Š‹ŒŽ€‚ƒ„…†‡˜™š›œžŸ‘’“”•–—ЈЉЊЋЌ­ЎЏ ЁЂЃЄЅІЇИЙМџАБpqГШ™ШШШЬџrstuУШШШийџџабvwџШШШшщьрсz{хШШШџџќџxy|}ѓШШџзззззззззззГГГГГГРРЙЗТЙЙЗТЙРРРРРРРРдежОООООРРРРКИРРРРББРРРЪУЖРРРРРРРРРРРЮРБРРРРРРРРРРзџџџџџџџ‘’“”•–ЫЫЮУЖŽ‘’“”•–ЫЫЮУЖџџџџХХХХХХХХХХХХХХХХХХХХХХХХХХџџџџџџџџџџџџџџџџџџџџџџSS##SSSS###SS S ##SOS##OOOOSџџџџџџџџџџџџџџџгггггггггггЮгггггггЩггkхбN! ггЯЮЮЮЮгЮгг2!вЁЁЁЁЁЁЁЁЁЁЁЁЁЁЁЁ€p!€q!€r!€s!€t!€u!€v!€w!€x!€y!€z!€{!€|!€}!€~!€!€`!€a!€b!€c!€d!€e!€f!€g!€h!€i!€j!€k!€l!€m!€n!€o!€€€„!ƒ!€€€€ЁџџџџџџЮЮЮЮЮгггггЮЮггггЮггЮггЮгггггггЮгггггггггггггггггггггггггггггггЮЮггЮгЮгггггггггггггггггггггггггггггггЮЮЮЮЮЮЮЮЮЮЮЮЮЯЯЯЯЮЮЮЯЯЯЯЯЯЮЮЮЯЫЬЮЯЯЮЮЮЯЯЯЯЮЯЯЯЯЮЯЮЯЮЮЮЮЯЯЯЯЯЯЯЯЯЮЮЮЮЮЯЮЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЮЮЮЮЮЯЯЯЯЮЮЮЮЮЮЮЮЮЯЯЮЯЮЯЯЯЯЯЯЯЯЮЮЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЮЮЯЯЯЯЮЮЮЮЮЯЮЮЮЮЮЮЮЮЮЯЯЮЮЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЮЮЮЮЮЯЯЮЮЮЮЮЮЮЮЮЯЯЯЯЯЮЮЯЯЮЮЮЮЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЮЮЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯггггггггЯЯЯЯггггггггггггггггггггЯЯгггггггУЖгггггггггггвввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввгЮггггггггггггггггггггггггвгггггЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮггггггггггггггггггггггггггггггггггггггггЮЮЮЮЮЮггггггггггггггггггџџџџџџџџџџџџгггггггггггггггггггггггггггггггггггггггџџџџџџџџџџџџџџџџџџџџџџџџџгггггггггггџџџџџџџџџџџџџџџџџџџџџЃЄЅІЇЈЉЊЋЁЁЁЁЁЁЁЁЁЁЁЃЄЅІЇЈЉЊЋЁЁЁЁЁЁЁЁЁЁЁŽ‘’“”•–ŒŒŒŒŒŒŒŒŒŒŒввввввввввввввввввввввввввва$вб$вв$вг$вд$ве$вж$вз$ви$вй$вк$вл$вм$вн$во$вп$вр$вс$вт$ву$вф$вх$вц$вч$вш$вщ$вЖ$вЗ$вИ$вЙ$вК$вЛ$вМ$вН$вО$вП$вР$вС$вТ$вУ$вФ$вХ$вЦ$вЧ$вШ$вЩ$вЪ$вЫ$вЬ$вЭ$вЮ$вЯ$ЂЁЁЁЁЁЁЁЁЁЁЃЄЅІЇЈЉЊЋЁЂгггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггЮгггггггггЮггггггггггггггггггггггггггггггггггггггггггггггггггггггЮЮЮЮЮЮЮЮгггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггЮггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггвгггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггџгггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггУЖУЖУЖУЖУЖУЖУЖЃЄЅІЇЈЉЊЋЁЃЄЅІЇЈЉЊЋЁЃЄЅІЇЈЉЊЋЁггггггггггггггггггггггггггггггггггггггггггггЯЮЮЯЯУЖЮЯЯЮџЯџЮЮЮЮЮЯЯЯЯЮЮЮЮЮЯЯЯЮЮЮЯЯЯЯУЖУЖУЖУЖУЖЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮУЖУЖУЖУЖУЖУЖУЖУЖУЖУЖУЖЮЮЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЮЮЮЮЮЮЮЮЯЮЮЮЮЮЮЮЯЯЯЯЯЯЮЮЮЯЮЮЮЮЯЯЯЯЯЮЯЯЮЮУЖУЖЯЮЮЮЮЯЮЯЯЯЮЮЯЯЮЮЮЮЮЮЮЮЮЮЯЯЯЯЯЯЮЮУЖЮЮЮЮЮЮЮЮЮЮЮЮЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЮЯЯЯЯЮЮЯЮЯЮЮЯЮЯЯЯЯЮЮЮЮЮЯЯЮЮЮЮЮЮЯЯЯЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЯЯЮЮЮЮЮЮЮЮЮЮЮЯЯЮЮЮЮЯЯЯЯЮЯЯЮЮЯЯЮЮЮЮЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЮЮЯЯЯЯЯЯЯЯЮЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЮЮЮЮЮЯЮЯЮЮЮЯЯЯЯЯЮЮЮЮЮЯЯЯЮЮЮЮЯЮЮЮЯЯЯЯЯЮЯЮЮггггггггггггггггггггггггггггггггггггггггггггггггЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮггЮЮЮЮЮЮџџџггггггггггџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ0,1,2,3,4,5,6,7,8,9,:,;,<,=,>,?,@,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,[,\,],^,џ,,,,,,,,, , , , , ,,,,,,,,,,,,,,,,,,, ,!,",#,$,%,&,',(,),*,+,,,-,.,џa,`,k}}:>h,g,j,i,l,k,QqPRs,r,v,u,?@,€,ƒ,‚,…,„,‡,†,‰,ˆ,‹,Š,,Œ,,Ž,‘,,“,’,•,”,—,–,™,˜,›,š,,œ,Ÿ,ž,Ё, ,Ѓ,Ђ,Ѕ,Є,Ї,І,Љ,Ј,Ћ,Њ,­,Ќ,Џ,Ў,Б,А,Г,В,Е,Д,З,Ж,Й,И,Л,К,Н,М,П,О,С,Р,У,Т,Х,Ф,Ч,Ц,Щ,Ш,Ы,Ъ,Э,Ь,Я,Ю,б,а,г,в,е,д,з,ж,й,и,л,к,н,м,п,о,с,р,у,т,ггггггь,ы,ю,э,SSSџџџџџџџРРРРЁРР ЁЂЃЄЅІЇЈЉЊЋЌ­ЎЏАБВГДЕЖЗИЙКЛМНОПРСТУФХџџџџџџџџџџ џџџџџџџџџПџџџџџџџџџџџџџџ& џџџџџџџџџ џ џ џ џ џ џ џ џSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSРРКИКИРРРКИРКИРРРРРРРРРГРРГРКИРРКИУЖУЖУЖУЖРРРРРРРџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџггггггггггггггггггггггггггџгггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггџџџџџџџџџџџџггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггџџџџџџџџџџџџџџџџџџџџџџџџџџггггггггггггџџџџзРРРг €УЖУЖУЖУЖУЖггУЖУЖУЖУЖГТЕЕг€€€€€€€€€NRTPQQГгг€€€ Рггџ џџ%%ШШ Г Р џџџџџ џџџ џвв————вввввввввв џџџџџггггггггггггггггггггггггггггггггггггџџџџџџџџџџџџ вввввввввввввввввввввввввввввггџ——————————ввввввввввввввввввввввввввввввввввввввгЁЁЁЁЁЁЁЁЁЁЁЁЁЁЁввввввввввввввввввввввввввввгггв——————————вввввввввввввввввввввввввввввввввввввввЁЁЁЁЁЁЁЁЁЁЁЁЁЁЁввввввввввввггггвввввввввввввввввввввввввввввввввввввввввввввввџвввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввггггвввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввггвввввввввввввввввввввввввввввввг џџџџџџџџџџгггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггг џџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ  џџџгггггггггггггггггггггггггггггггггггггггггггггггггггггггџџџџџџџџџ ПП РРР lmnopqrstu џџџџџџџџџџџџџџџџџџџџAІ@ІCІBІEІDІGІFІIІHІKІJІMІLІOІNІQІPІSІRІUІTІWІVІYІXІ[ІZІ]І\І_І^ІaІ`ІcІbІeІdІgІfІiІhІkІjІmІlІ S РџџџџџџџџSSРІ€ІƒІ‚І…І„І‡І†І‰ІˆІ‹ІŠІІŒІІŽІ‘ІІ“І’І•І”І—І–Іџџџџџџџџ €€€€€€€€€€SSППППППџџџџџџџџШШШШШШШШШШШШШШШШШШШШШШШШШ#Ї"Ї%Ї$Ї'Ї&Ї)Ї(Ї+Ї*Ї-Ї,Ї/Ї.Ї3Ї2Ї5Ї4Ї7Ї6Ї9Ї8Ї;Ї:Ї=Ї<Ї?Ї>ЇAЇ@ЇCЇBЇEЇDЇGЇFЇIЇHЇKЇJЇMЇLЇOЇNЇQЇPЇSЇRЇUЇTЇWЇVЇYЇXЇ[ЇZЇ]Ї\Ї_Ї^ЇaЇ`ЇcЇbЇeЇdЇgЇfЇiЇhЇkЇjЇmЇlЇoЇnЇzЇyЇ|Ї{ЇyЇ~ЇЇ€ЇƒЇ‚Ї…Ї„Ї‡Ї†ЇЧЧŒЇ‹Їeџ‘ЇЇџџџџџџџџџџџџџџЁЇ ЇЃЇЂЇЅЇЄЇЇЇІЇЉЇЈЇџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ " & " ""ггггџџџџ——————ввХбџџџџџџ РРРРџџџџџџџџ &џџџџџџџџџППlmnopqrstuџџџџџџSSSSSSSSSSSSSSSSSS ППП џџџџlmnopqrstu """""OOOПП """""""""""џџџџџџџџџџџП џџџ""" $"""""ПППППППППППППџlmnopqrstuџџџџППџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ """"""""""џџџџџџџџџ " "џџlmnopqrstuџџПППП  ввв џџџџ S SSO SS SS S џџџџџџџџџџџџџџџџџџџџџџџџ ППџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ џџ џџ џџџџџџџџџ џ џџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ ""П&џџlmnopqrstuџџџџџџ џџџџџџџџџџџџ џџџџ џџџџ џџ џџ џџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ 7 Ы џ џ џ џ џ ЦЦЦЦЦЦЦЦЦЦЦЦЦЦЦЦџџџџџџџџџџџџџџџџџ ТЕџџџџџџџџџџџџџџџџ џџ џџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ Фгџџ""""""""""""""""РРРРРРРТЕРџџџџџџSSSSSSSџџџџџџџџџРГГББТЕТЕТЕТЕТЕТЕТЕТЕРРТЕРРРРБББНРНџРНРРГУЖУЖУЖОРРЫВЯЯЮџРХОРџџџџ џ џџџРРОХОРРУЖРЫНВННbcdefghijkНРЯЮЯРРAџBџCџDџEџFџGџHџIџJџKџLџMџNџOџPџQџRџSџTџUџVџWџXџYџZџУРЖШБШ!џ"џ#џ$џ%џ&џ'џ(џ)џ*џ+џ,џ-џ.џ/џ0џ1џ2џ3џ4џ5џ6џ7џ8џ9џ:џУЮЖЮУЖРУЖРР   џџџ џџ џџ џџ џџџХХЮШгХХџгЮЮЮЮггџџџџџџџџџџггџџ џ џ џ џ џџ џџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ џџџџџПРвџџџџ—————————————————————————————————————————————џџџвввввввввЁЁЁЁгггггггггггггггггЁџџџџџггггггггггггџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџвввввввввввввввввввввввввввввввввввввввввввввOџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ џџџ џџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ џ————џџџџџџџџџџџџ € €џџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ џП џџџџ П€€€€€џџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNO      !"#$%&' џџlmnopqrstuџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ џџ џ џ џџџ џџ џСЌЌЌЌЌЌЌЌџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ ЌЌЌЌЌЌџџџР џџџџџСџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ """џ""џџџџџ"O"S џ џ џџџџS#Oџџџџ&­ЎЏАЌЌЌЌџџџџџџџџСССССССССџџџџџџџ ЌЌСџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ џџџРРРРРРР џџЌЌЌЌЌЌЌЌ џџџџџЌЌЌЌЌЌЌЌџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ џџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџƒ„…†‡ˆ‰Š‹‚‚‚‚‚‚‚‚‚‚‚‚‚‚‚‚‚‚‚‚‚‚џџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ" """"""""""""""&ПППППППџџџџЃЄЅІЇЈЉЊЋЁЁЁЁЁЁЁЁЁЁЁlmnopqrstuџџџџџџџџџџџџџџџџ"" """"&$ППППППџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ џџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€џџџџџџџџџџџџџППППџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ џџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ џџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ џџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввџџџџџџџџџџвввввввввввввввввввввввввввввввввввввввџџвввввввввввввввввввввввввввввввввввввввввввввввввввввввввввв###вввOOOOOOOOввSSSSSOOввввввввввввввввввввввввввввввSSSSввввввввввввввввввввввввввввввввввввввввввввввввџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггSSSгџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџгггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггџџџџџџџџџ——————————————————џџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџЭЯЭЯЭЯЭЯЭЯџџbcdefghijkbcdefghijkbcdefghijkbcdefghijkbcdefghijkггггггггггггггггггггггггггггггггггггггггггггџџџџггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггџџџџџџџџџџџџгггггггггггггггџџггггггггггггггџџгггггггггггггггџгггггггггггггггџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџŽ‘’“”•–џџџџџвввввввввввввввввввввввввввввввџввввввввввввввввввввввввввввввввввввввввввввввввввввввввввџџџџџџвввввввввввввввввввввввввввввввввввввввввввџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџвввввввввввввввввввввввввввввџџџџџџџџџџџџџвввввввввввввввввввввввввввввввввввввввввввџџџџџвввввввввџџџџџџџввџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџгггггггггггггггггггггггггггггггггџџџџџџџџџџџџџџџггггггџггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггџџџггггггггггггггггггггџџџџџџџџџџџџгггггггггггггггггггггггггггггггггггггџгггггџџџџџџџџџџџџџџџџџџџџџгггггггггггггггггџџџџџџџџџџџџџџџгггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггџгџггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггвгггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггџггггџџџггггггггггггггггггггггггггггггггггггвгггггггггггггггггггггггггџџџџџџџџџџџџџџџџџџггггггггггггггггггггггггџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџгггггџггггггггггггггггџгггџгџгџгџгггџггггггџџггггџгџџггггџггггггггггггџџџџгггггггггггџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ џџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ џџџџџџџџџџџ џџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""џџџџџџџџџџџџџџџџџџecl-16.1.2/contrib/unicode/ucd.lisp000066400000000000000000000567631266352375300171330ustar00rootroot00000000000000;;; Common (defvar *extension-directory* (make-pathname :directory (pathname-directory *load-truename*))) (defparameter *unicode-char-limit* #x110000) (defparameter *page-size-exponent* 8) (defparameter *page-size* (ash 1 *page-size-exponent*)) (defun total-ucd-pages () (floor *unicode-char-limit* *page-size*)) (defun cp-high (cp) (ash cp (- *page-size-exponent*))) (defun cp-low (cp) (ldb (byte *page-size-exponent* 0) cp)) ;;; Generator (defstruct ucd misc transform) (defparameter *unicode-character-database* (make-pathname :directory (pathname-directory *load-truename*))) (defparameter *ucd-base* nil) (defparameter *unicode-names* (make-hash-table)) (defparameter *last-uppercase* nil) (defparameter *uppercase-transition-count* 0) (defparameter *different-titlecases* nil) (defparameter *different-numerics* nil) (defparameter *name-size* 0) (defparameter *misc-classless* 0) (defparameter *misc-hash* (make-hash-table :test #'equal)) (defparameter *misc-index* -1) (defparameter *misc-table* nil) (defparameter *misc-mapping* nil) (defparameter *both-cases* nil) (defparameter *decompositions* nil) (defparameter *decomposition-length-max* nil) (defparameter *decomposition-types* nil) (defparameter *decomposition-base* nil) (defun hash-misc (gc-index bidi-index ccc-index decimal-digit digit bidi-mirrored cl-both-case-p) (let* ((list (list gc-index bidi-index ccc-index decimal-digit digit bidi-mirrored cl-both-case-p)) (index (gethash list *misc-hash*))) (or index (progn (vector-push list *misc-table*) (setf (gethash list *misc-hash*) (incf *misc-index*)))))) (defun compare-misc-entry (left right) (destructuring-bind (left-gc-index left-bidi-index left-ccc-index left-decimal-digit left-digit left-bidi-mirrored left-cl-both-case-p) left (destructuring-bind (right-gc-index right-bidi-index right-ccc-index right-decimal-digit right-digit right-bidi-mirrored right-cl-both-case-p) right (or (and left-cl-both-case-p (not right-cl-both-case-p)) (and (or left-cl-both-case-p (not right-cl-both-case-p)) (or (< left-gc-index right-gc-index) (and (= left-gc-index right-gc-index) (or (< left-bidi-index right-bidi-index) (and (= left-bidi-index right-bidi-index) (or (< left-ccc-index right-ccc-index) (and (= left-ccc-index right-ccc-index) (or (string< left-decimal-digit right-decimal-digit) (and (string= left-decimal-digit right-decimal-digit) (or (string< left-digit right-digit) (and (string= left-digit right-digit) (string< left-bidi-mirrored right-bidi-mirrored)))))))))))))))) (defun build-misc-table () (sort *misc-table* #'compare-misc-entry) (setq *misc-mapping* (make-array (1+ *misc-index*))) (loop for i from 0 to *misc-index* do (setf (aref *misc-mapping* (gethash (aref *misc-table* i) *misc-hash*)) i))) (defun slurp-ucd () (setq *last-uppercase* nil) (setq *uppercase-transition-count* 0) (setq *different-titlecases* nil) (setq *different-numerics* nil) (setq *name-size* 0) (setq *misc-hash* (make-hash-table :test #'equal)) (setq *misc-index* -1) (setq *misc-table* (make-array *page-size* :fill-pointer 0)) (setq *both-cases* nil) (setq *decompositions* 0) (setq *decomposition-types* (make-hash-table :test #'equal)) (setq *decomposition-length-max* 0) (setq *decomposition-base* (make-array (total-ucd-pages) :initial-element nil)) (setq *ucd-base* (make-array (total-ucd-pages) :initial-element nil)) (with-open-file (*standard-input* (make-pathname :name "UnicodeData" :type "txt" :defaults *extension-directory*) :direction :input :external-format :default) (loop for line = (read-line nil nil) while line do (slurp-ucd-line line))) (setf *misc-classless* (hash-misc 0 0 0 "" "" "N" nil)) (second-pass) (build-misc-table) *decompositions*) (defun split-string (line character) (loop for prev-position = 0 then (1+ position) for position = (position character line :start prev-position) collect (subseq line prev-position position) do (unless position (loop-finish)))) (defun init-indices (strings) (let ((hash (make-hash-table :test #'equal))) (loop for string in strings for index from 0 do (setf (gethash string hash) index)) hash)) (defparameter *general-categories* (init-indices '("Lu" "Ll" "Lt" "Lm" "Lo" "Cc" "Cf" "Co" "Cs" "Mc" "Me" "Mn" "Nd" "Nl" "No" "Pc" "Pd" "Pe" "Pf" "Pi" "Po" "Ps" "Sc" "Sk" "Sm" "So" "Zl" "Zp" "Zs"))) (defparameter *bidi-classes* (init-indices '("AL" "AN" "B" "BN" "CS" "EN" "ES" "ET" "L" "LRE" "LRO" "NSM" "ON" "PDF" "R" "RLE" "RLO" "S" "WS"))) (defparameter *block-first* nil) (defun normalize-character-name (name) (when (find #\_ name) (error "Bad name for a character: ~A" name)) (unless (or (zerop (length name)) (find #\< name) (find #\> name)) (substitute #\_ #\Space name))) ;;; 3400 -- 4DB5 : cjk ideograph extension a ;Lo;0;L;;;;;N;;;;; ;;; AC00 -- D7A3 : hangul syllables ;Lo;0;L;;;;;N;;;;; ;;; D800 -- F8FF : surrogates and private use ;;; 20000 -- 2A6D6 : cjk ideograph extension b ;Lo;0;L;;;;;N;;;;; ;;; F0000 -- FFFFD : private use ;;; 100000 -- 10FFFD: private use (defun encode-ucd-line (line code-point) (destructuring-bind (name general-category canonical-combining-class bidi-class decomposition-type-and-mapping decimal-digit digit numeric bidi-mirrored unicode-1-name iso-10646-comment simple-uppercase simple-lowercase simple-titlecase) line (declare (ignore unicode-1-name iso-10646-comment)) (if (and (> (length name) 8) (string= ", First>" name :start2 (- (length name) 8))) (progn (setq *block-first* code-point) nil) (let* ((gc-index (or (gethash general-category *general-categories*) (error "unknown general category ~A" general-category))) (bidi-index (or (gethash bidi-class *bidi-classes*) (error "unknown bidirectional class ~A" bidi-class))) (ccc-index (parse-integer canonical-combining-class)) (digit-index (unless (string= "" decimal-digit) (parse-integer decimal-digit))) (upper-index (unless (string= "" simple-uppercase) (parse-integer simple-uppercase :radix 16))) (lower-index (unless (string= "" simple-lowercase) (parse-integer simple-lowercase :radix 16))) (title-index (unless (string= "" simple-titlecase) (parse-integer simple-titlecase :radix 16))) (cl-both-case-p (not (null (or (and (= gc-index 0) lower-index) (and (= gc-index 1) upper-index))))) (misc-index (hash-misc gc-index bidi-index ccc-index decimal-digit digit bidi-mirrored cl-both-case-p))) (declare (ignore digit-index)) (incf *name-size* (length name)) (when (string/= "" decomposition-type-and-mapping) (let ((split (split-string decomposition-type-and-mapping #\Space))) (when (char= #\< (aref (first split) 0)) (setf (gethash (pop split) *decomposition-types*) t)) (unless (aref *decomposition-base* (cp-high code-point)) (setf (aref *decomposition-base* (cp-high code-point)) (make-array (ash 1 *page-size-exponent*) :initial-element nil))) (setf (aref (aref *decomposition-base* (cp-high code-point)) (cp-low code-point)) (mapcar #'(lambda (string) (parse-integer string :radix 16)) split)) (setq *decomposition-length-max* (max *decomposition-length-max* (length split))) (incf *decompositions* (length split)))) (when (and (string/= "" simple-uppercase) (string/= "" simple-lowercase)) (push (list code-point upper-index lower-index) *both-cases*)) (when (string/= simple-uppercase simple-titlecase) (push (cons code-point title-index) *different-titlecases*)) (when (string/= digit numeric) (push (cons code-point numeric) *different-numerics*)) (cond ((= gc-index 8) (unless *last-uppercase* (incf *uppercase-transition-count*)) (setq *last-uppercase* t)) (t (when *last-uppercase* (incf *uppercase-transition-count*)) (setq *last-uppercase* nil))) (when (> ccc-index 255) (error "canonical combining class too large ~A" ccc-index)) (let ((result (make-ucd :misc misc-index :transform (or upper-index lower-index 0)))) (when (and (> (length name) 7) (string= ", Last>" name :start2 (- (length name) 7))) (let ((page-start (ash (+ *block-first* (ash 1 *page-size-exponent*) -1) (- *page-size-exponent*))) (page-end (ash code-point (- *page-size-exponent*)))) (loop for point from *block-first* below (ash page-start *page-size-exponent*) do (setf (aref (aref *ucd-base* (cp-high point)) (cp-low point)) result)) (loop for page from page-start below page-end do (setf (aref *ucd-base* page) (make-array (ash 1 *page-size-exponent*) :initial-element result))) (loop for point from (ash page-end *page-size-exponent*) below code-point do (setf (aref (aref *ucd-base* (cp-high point)) (cp-low point)) result)))) (values result (normalize-character-name name))))))) (defun slurp-ucd-line (line) (let* ((split-line (split-string line #\;)) (code-point (parse-integer (first split-line) :radix 16)) (code-high (ash code-point (- *page-size-exponent*))) (code-low (ldb (byte *page-size-exponent* 0) code-point))) (unless (aref *ucd-base* code-high) (setf (aref *ucd-base* code-high) (make-array (ash 1 *page-size-exponent*) :initial-element nil))) (multiple-value-bind (encoding name) (encode-ucd-line (cdr split-line) code-point) (setf (aref (aref *ucd-base* code-high) code-low) encoding (gethash code-point *unicode-names*) name)))) (defun second-pass () (loop for i from 0 below (length *ucd-base*) when (aref *ucd-base* i) do (loop for j from 0 below (length (aref *ucd-base* i)) for result = (aref (aref *ucd-base* i) j) when result when (let* ((transform-point (ucd-transform result)) (transform-high (ash transform-point (- *page-size-exponent*))) (transform-low (ldb (byte *page-size-exponent* 0) transform-point))) (and (plusp transform-point) (/= (ucd-transform (aref (aref *ucd-base* transform-high) transform-low)) (+ (ash i *page-size-exponent*) j)))) do (destructuring-bind (gc-index bidi-index ccc-index decimal-digit digit bidi-mirrored cl-both-case-p) (aref *misc-table* (ucd-misc result)) (declare (ignore cl-both-case-p)) (format t "~A~%" (+ (ash i *page-size-exponent*) j)) (setf (ucd-misc result) (hash-misc gc-index bidi-index ccc-index decimal-digit digit bidi-mirrored nil)))))) (defun write-3-byte (triplet stream) (write-2-byte triplet stream) (write-byte (ldb (byte 8 16) triplet) stream)) (defun write-2-byte (doublet stream) (write-byte (ldb (byte 8 0) doublet) stream) (write-byte (ldb (byte 8 8) doublet) stream)) (defun digit-to-byte (digit) (if (string= "" digit) 255 (parse-integer digit))) (defun output (&optional small-unicode) (let* ((num-pages (/ (if small-unicode #x10000 *unicode-char-limit*) *page-size*)) (ucd-file-name (concatenate 'base-string "ucd" (if small-unicode "16" ""))) (hash (make-hash-table :test #'equalp)) (index 0)) (loop for page across *ucd-base* for i from 0 below num-pages do (when page (unless (gethash page hash) (setf (gethash page hash) (incf index))))) (let ((array (make-array (1+ index)))) (maphash #'(lambda (key value) (setf (aref array value) key)) hash) (setf (aref array 0) (make-array (ash 1 *page-size-exponent*) :initial-element nil)) (with-open-file (stream (make-pathname :name ucd-file-name :type "dat" :defaults *extension-directory*) :direction :output :element-type '(unsigned-byte 8) :if-exists :supersede :if-does-not-exist :create) (let ((offset (* (length *misc-table*) 8))) (write-byte (mod offset *page-size*) stream) (write-byte (floor offset *page-size*) stream)) (loop for (gc-index bidi-index ccc-index decimal-digit digit bidi-mirrored) across *misc-table* do (write-byte gc-index stream) do (write-byte bidi-index stream) do (write-byte ccc-index stream) do (write-byte (digit-to-byte decimal-digit) stream) do (write-byte (digit-to-byte digit) stream) do (write-byte (if (string= "N" bidi-mirrored) 0 1) stream) do (write-byte 0 stream) do (write-byte 0 stream)) (print (length *misc-table*)) (loop for page across *ucd-base* for i from 0 below num-pages do (write-byte (if page (gethash page hash) 0) stream)) (loop for page across array for i from 0 below num-pages do (loop for entry across page do (write-byte (if entry (aref *misc-mapping* (ucd-misc entry)) *misc-classless*) stream) do (funcall (if small-unicode 'write-2-byte 'write-3-byte) (if entry (ucd-transform entry) 0) stream)))))) #+(or) (with-open-file (f (make-pathname :name "ucd-names" :type "lisp-expr" :defaults *extension-directory*) :direction :output :if-exists :supersede :if-does-not-exist :create) (with-standard-io-syntax (write-string ";;; Do not edit by hand: generated by ucd.lisp" f) (maphash (lambda (code name) (when name (print code f) (prin1 name f))) *unicode-names*)) (setf *unicode-names* nil)) (with-open-file (*standard-output* (make-pathname :name "numerics" :type "lisp-expr" :defaults *extension-directory*) :direction :output :if-exists :supersede :if-does-not-exist :create) (let ((*print-pretty* t)) (prin1 (mapcar #'(lambda (x) (cons (car x) (read-from-string (cdr x)))) *different-numerics*)))) (with-open-file (*standard-output* (make-pathname :name "titlecases" :type "lisp-expr" :defaults *extension-directory*) :direction :output :if-exists :supersede :if-does-not-exist :create) (let ((*print-pretty* t)) (prin1 *different-titlecases*))) (with-open-file (*standard-output* (make-pathname :name "misc" :type "lisp-expr" :defaults *extension-directory*) :direction :output :if-exists :supersede :if-does-not-exist :create) (let ((*print-pretty* t)) (prin1 `(:length ,(length *misc-table*) :uppercase ,(loop for (gc-index) across *misc-table* for i from 0 when (= gc-index 0) collect i) :lowercase ,(loop for (gc-index) across *misc-table* for i from 0 when (= gc-index 1) collect i) :titlecase ,(loop for (gc-index) across *misc-table* for i from 0 when (= gc-index 2) collect i))))) (values)) (defmacro with-c-file ((stream-var name) &rest body) `(with-open-file (,stream-var ,name :direction :output :external-format #-unicode :default #+unicode :us-ascii :if-exists :supersede :if-does-not-exist :create) ,@body)) (defun output-c (&optional small-unicode) (let* ((num-pages (/ (if small-unicode #x10000 *unicode-char-limit*) *page-size*)) (ucd-file-name (concatenate 'base-string "ucd" (if small-unicode "16" ""))) (hash (make-hash-table :test #'equalp)) (index 0) array) (with-c-file (stream (make-pathname :name ucd-file-name :type "c" :defaults *extension-directory*)) (format stream "~%extern const char ecl_ucd_page_table_0[];") (loop for page across *ucd-base* for i from 0 below num-pages do (when page (unless (gethash page hash) (setf (gethash page hash) (incf index)) (print index) (format stream "~%extern const char ecl_ucd_page_table_~D[];" index)))) (setf array (make-array (incf index))) (maphash #'(lambda (key value) (setf (aref array value) key)) hash) (setf (aref array 0) (make-array (ash 1 *page-size-exponent*) :initial-element nil)) (format stream "~%~%const unsigned char ecl_ucd_misc_table[~D] = {" (* 8 (length *misc-table*))) (loop with comma = "" for (gc-index bidi-index ccc-index decimal-digit digit bidi-mirrored) across *misc-table* do (format stream "~%~A~D, ~D, ~D, ~D, ~D, ~D, ~D, ~D" comma gc-index bidi-index ccc-index (digit-to-byte decimal-digit) (digit-to-byte digit) (if (string= "N" bidi-mirrored) 0 1) 0 0) do (setf comma ",")) (print *misc-table*) (print (length *misc-table*)) (format stream "~%};") (format stream "~%~%const unsigned char *const ecl_ucd_page_table[~D] = {" num-pages) (loop with comma = "" for page across *ucd-base* for i from 0 below num-pages for name = (if page (format nil "ecl_ucd_page_table_~D" (gethash page hash)) ;; fixme, this was so previously "ecl_ucd_page_table_0") do (format stream "~%~A~A" comma name) do (setf comma ",")) (format stream "~%};")) (print index) (loop for i from 0 below index by 16 for next = (min index (+ i 16)) for c-file = (format nil "~A-~4,'0D" ucd-file-name i) do (with-c-file (stream (make-pathname :name c-file :type "c" :defaults *extension-directory*)) (loop for j from i below next for page = (aref array j) do (format stream "~%const unsigned char ecl_ucd_page_table_~D[] = {" j) do (loop with comma = "" for entry across page for other-case = (if entry (ucd-transform entry) 0) do (format stream (if small-unicode "~%~A~D,~D,~D" "~%~A~D,~D,~D,~D") comma (if entry (aref *misc-mapping* (ucd-misc entry)) *misc-classless*) (ldb (byte 8 0) other-case) (ldb (byte 8 8) other-case) (ldb (byte 8 16) other-case)) do (setf comma ",")) do (format stream "~%};"))))) (values)) (defun read-compiled-ucd () (with-open-file (stream (make-pathname :name *ucd-file-name* :type "dat" :defaults *extension-directory*) :direction :input :element-type '(unsigned-byte 8)) (let ((length (file-length stream))) (setq *compiled-ucd* (make-array length :element-type '(unsigned-byte 8))) (read-sequence *compiled-ucd* stream))) (values)) #| (slurp-ucd) (output) (output t) |# ecl-16.1.2/contrib/unicode/ucd16.dat000066400000000000000000001563021266352375300170710ustar00rootroot00000000000000Рџџџџџџџџџџџџџџ џџџџџџџџџџџџџџџџџџџџџџџџ џџ џџ џџ џџџџџџџџџџџџ џџ  џџ иџџ тџџ џџ џџ џџ џџ џџ џџ џџ џџ џџ џџ џџ џџ џџ џџ џџ џџ џџ џџ џџ џџ џџ џџ џџ џџ џџ џџ џџ џџ џџ џџ !џџ "џџ #џџ $џџ Tџџ [џџ gџџ kџџ vџџ zџџ џџ ‚џџ „џџ Ъџџ жџџ иџџ кџџ мџџ оџџ рџџ фџџ цџџ шџџ щџџ ъџџ №џџ                                         џџ џџџџџџџџџџџџџ џџџџџџџџџџџџ џџџџџџџџџџџ  џџ џ џ џ џ џ џ џ џ џ џ џџџџџџ џџџџ џџџџ џџ џџ џџ џџ џџ џџџџџџџџџџџџ џџџџ џџ џџџџџџџџџџ џџџџџџџџџџџџ џџ џџџџџџџџ џџџџџџџџџџ  !"#$%&'()*+,-./0123456789:;<=>????????@@@@@@@@@@@@@@@@@@@@@@@@@ABCDEFџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ   зРРОХОРРУЖРЫНВННbcdefghijkНРЯЮЯРРabcdefghijklmnopqrstuvwxyzУРЖШБШABCDEFGHIJKLMNOPQRSTUVWXYZУЮЖЮ жРХХХХггШгКЮгШбЬШœгРШŽИЁЁЁРрстуфхцчшщъыьэюя№ёђѓєѕіЮјљњћќ§ўРСТУФХЦЧШЩЪЫЬЭЮЯабвгдежЮийклмноx     ! #"%$'&)(+*-,/.iI325476:9<;>=@?BADCFEHGKJMLONQPSRUTWVYX[Z]\_^a`cbedgfihkjmlonqpsrutwvџzy|{~}SCSƒ‚…„Tˆ‡VWŒ‹нY[’‘`cіih™˜=or uЁ ЃЂЅЄ€ЈЇƒ­ЌˆАЏŠ‹ДГЖЕ’ЙИ НМї ЦФФЩЧЧЬЪЪЮЭаЯвбдгжеизкймлŽпосрутхфчцщшыъэьяюѓёёѕє•Пљјћњ§ќџў     ž#"%$'&)(+*-,/.1032e,<;šf,~,,BA€‰ŒGFIHKJMLONo,m,p,†‰Š“”Ї—–b,œn,Ÿd,ІЉЎDБВEЗ ШШШШШШШШШШШШШШШШШШШШШШШШШШШШШШШШШШШШШШШШШШШSSSSSSSSSSSSSSSSSSSSSTOOOOTMOOOOOKKOOOOKKOOOOOOOOOOO#####OOOOSSSSSSSSW™SOOOSSSOO"SSSOOOOSTOOSUVVUVVUSSSSSSSSSSSSSqpsrШwvџџ§ўџРџџџџџШШЌР­ЎЏџЬџЭЮБВГДЕЖЗИЙКЛМНОПРСџУФХЦЧШЩЪЫ†ˆ‰Š‘’“”•–—˜™š›œžŸ ЁЃЃЄЅІЇЈЉЊЋŒŽз’˜І ЯйилкнмпосрутхфчцщшыъэьяюšЁљИ•Юјїђћњ{|}PQRSTUVWXYZ[\]^_0123456789:;<=>?@ABCDEFGHIJKLMNO !"#$%&'()*+,-./     a`cbedgfihkjmlonqpsrutwvyx{z}|~€вSSSSS ‹ŠŒŽ‘“’•”—–™˜›šœŸžЁ ЃЂЅЄЇІЉЈЋЊ­ЌЏЎБАГВЕДЗЖЙИЛКНМПОЯТСФУЦХШЧЪЩЬЫЮЭРбагведзжйилкнмпосрутхфчцщшыъэьяюё№ѓђѕєїіљјћњ§ќџў     ! #"%$'&џџџџџџџџџabcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†џџППППППџ123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVџПГџџџџџџOSSSSOSSSPOSSSSSSOOOOOOSSOSSPRS'()*+,-./00123Д4С56СSOС/џџџџџџџџ џџџџџ ССџџџџџџџџџџџџџЮЮЩООФНЛггSSSSSSSS;<=ЛџџЛЛ  89:;<=>?SSOOSSSSSOSSOXYZ[\]^_`aОММЛ @ Л SSSSSSSгSSSSOSSSгOSSO bcdefghijk аа ЛЛЛЛЛЛЛЛЛЛЛЛЛЛџ A SOSSOSSOOOSOOSOSSSOSOSOSOSSџџ """"""""""" џџџџџџџџџџџџџџvwxyz{|}~ SSSSSSSOSгРРРџџџџџ SSSSSSSSSSSSSSSSSSSSSџџСССССССССССССССџ OOOџџСџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ""" "$ """"""""& SOSS""" ""ППlmnopqrstuП џ џ"џ џџ џџ џ џ џџџ џџ$ """"џџџџ& џџџџџџџџџџџџ џ ""џџlmnopqrstu ХХ——————вХџџџџџ""џ џџџџ џџ џ џ џ џ џџ$џ""џџџџ""џџ""&џџџ"џџџџџџџ џ џџџџџџџlmnopqrstu"" "џџџџџџџџџџџ""џ џ џ џ џ џ џџ$ """""џ""џ&џџ џџџџџџџџџџџџџџџ ""џџlmnopqrstuџХџџџџџџџџџџџџџџџ"џ џџ џџ џ џ џ џџ$ """""џџџџ&џџџџџџџџ"џџџџ џ ""џџlmnopqrstuв ——————џџџџџџџџџџ" џ џџџ џ џџџ џ џ џџџ џџџ џџџ џџџџ"џџџџ&џџ џџџџџџџџџџџџџџџџџџџџlmnopqrstu———ггггггХгџџџџџџџ џ џ џ џ џџџ """џ"""џ"""&џџџџџџџBCџ џџџџџџ ""џџlmnopqrstuџџџџџџџџЁЁЁЁЁЁЁвџџџ џ џ џ џ џџ$ !џ!џ"&џџџџџџџџџџџџџџ џ ""џџlmnopqrstuџ џџџџџџџџџџџџџџџџ џ џ џџ """"џџ& џџџџџџџџџџџџџџџџ ""џџlmnopqrstu——————џџџв џџџ џџџ џ џ џџ џџџ&џџџџ"""џ"џџџџџџџџџџџџџџџџџџџПџџџџџџџџџџџџ " """"DD&џџџџХ "EEEE"""ПlmnopqrstuППџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ џ џџ џ џџ џџџџџџ џ џ џ џ џџ џ " """"FFџ"" џџ џџGGGG""џџlmnopqrstuџџ џџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ вввПППППППППППППППвввввOOввввввlmnopqrstu——————————вOвOвMУЖУЖ џ џџџџHI"J"""""IIII"I"SS&ПSS """""""""""џ""""""""""""""""""""""""""""""""""""џввввввввOввввввџввПППППввввППџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ """""""""$&&"" lmnopqrstuПППППП "" """   """" """O lmnopqrstu"вв--------- - - - - ------------------- -!-"-#-$-%-џџџџџџџџџџ Пџџџ џ џџ џ џ џџ џ џџ џ џџ џ џ џџ џ џ џџ џџSSSвПППППППϘ™š›œžŸ ———————————џџџ ггггггггггџџџџџџ џџџџџџџџџџџГ ПП з УЖџџџ ППП€€€џџџџџџџџџџџџџџџ џ ""&џџџџџџџџџџџ ""&ППџџџџџџџџџ ""џџџџџџџџџџџџ џ џ""џџџџџџџџџџџџ """""""""""""""""&"ППППППХ SџџlmnopqrstuџџџџџџЁЁЁЁЁЁЁЁЁЁџџџџџџРРРРРРГРРРР"""зџlmnopqrstuџџџџџџ  џџџџџџџџ R џџџџџ џџџџџџџџџџ џџџ"""""џџџџ"PSOџџџџгџџџРРlmnopqrstu џџ џџџџџџџџџџџ џџџџ џџџџџџlmnopqrstu˜џџџгггггггггггггггггггггггггггггггггг SOџџПП """"""""џ&"""""""""""SSSSSSSSџџOlmnopqrstuџџџџџџlmnopqrstuџџџџџџПППППППППППППџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ"""" $""""""" џџџџlmnopqrstuПППППППввввввввввSOSSSSSSSвввввввввџџџ"" """"""џџџ lmnopqrstuџџџџџџ $""""""џџџџџџџџПППП """""""""$џџџПППППlmnopqrstuџџџ lmnopqrstu ППџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџSSSП#OOOOOSSOOOOS####### O џџџџџџџџџџџџџ}Їc,SSOSSSSSSSOSSVLOKSSSSSSSSSSSSSSSSSSSSSSџџџџџџџџџџџџџџџџџџџџџUOSO     ! #"%$'&)(+*-,/.1032547698;:=<?>A@CBEDGFIHKJMLONQPSRUTWVYX[Z]\_^a`cbedgfihkjmlonqpsrutwvyx{z}|~€ƒ‚…„‡†‰ˆ‹ŠŒŽ‘“’•”`пЁ ЃЂЅЄЇІЉЈЋЊ­ЌЏЎБАГВЕДЗЖЙИЛКНМПОСРУТХФЧЦЩШЫЪЭЬЯЮбагведзжйилкнмпосрутхфчцщшыъэьяюё№ѓђѕєїіљјћњ§ќџў     џџџџ()*+,-./ !"#$%&'89:;<=>?01234567HIJKLMџџ@ABCDEџџY[]_џQџSџUџWhijklmno`abcdefgКЛШЩЪЫклјљъыњћџџˆ‰Š‹ŒŽ€‚ƒ„…†‡˜™š›œžŸ‘’“”•–—ЈЉЊЋЌ­ЎЏ ЁЂЃЄЅІЇИЙМџАБpqГШ™ШШШЬџrstuУШШШийџџабvwџШШШшщьрсz{хШШШџџќџxy|}ѓШШџзззззззззззГГГГГГРРЙЗТЙЙЗТЙРРРРРРРРдежОООООРРРРКИРРРРББРРРЪУЖРРРРРРРРРРРЮРБРРРРРРРРРРзџџџџџџџ‘’“”•–ЫЫЮУЖŽ‘’“”•–ЫЫЮУЖџџџџХХХХХХХХХХХХХХХХХХХХХХХХХХџџџџџџџџџџџџџџџџџџџџџџSS##SSSS###SS S ##SOS##OOOOSџџџџџџџџџџџџџџџгггггггггггЮгггггггЩггkхбN! ггЯЮЮЮЮгЮгг2!вЁЁЁЁЁЁЁЁЁЁЁЁЁЁЁЁ€p!€q!€r!€s!€t!€u!€v!€w!€x!€y!€z!€{!€|!€}!€~!€!€`!€a!€b!€c!€d!€e!€f!€g!€h!€i!€j!€k!€l!€m!€n!€o!€€€„!ƒ!€€€€ЁџџџџџџЮЮЮЮЮгггггЮЮггггЮггЮггЮгггггггЮгггггггггггггггггггггггггггггггЮЮггЮгЮгггггггггггггггггггггггггггггггЮЮЮЮЮЮЮЮЮЮЮЮЮЯЯЯЯЮЮЮЯЯЯЯЯЯЮЮЮЯЫЬЮЯЯЮЮЮЯЯЯЯЮЯЯЯЯЮЯЮЯЮЮЮЮЯЯЯЯЯЯЯЯЯЮЮЮЮЮЯЮЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЮЮЮЮЮЯЯЯЯЮЮЮЮЮЮЮЮЮЯЯЮЯЮЯЯЯЯЯЯЯЯЮЮЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЮЮЯЯЯЯЮЮЮЮЮЯЮЮЮЮЮЮЮЮЮЯЯЮЮЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЮЮЮЮЮЯЯЮЮЮЮЮЮЮЮЮЯЯЯЯЯЮЮЯЯЮЮЮЮЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЮЮЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯггггггггЯЯЯЯггггггггггггггггггггЯЯгггггггУЖгггггггггггвввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввгЮггггггггггггггггггггггггвгггггЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮггггггггггггггггггггггггггггггггггггггггЮЮЮЮЮЮггггггггггггггггггџџџџџџџџџџџџгггггггггггггггггггггггггггггггггггггггџџџџџџџџџџџџџџџџџџџџџџџџџгггггггггггџџџџџџџџџџџџџџџџџџџџџЃЄЅІЇЈЉЊЋЁЁЁЁЁЁЁЁЁЁЁЃЄЅІЇЈЉЊЋЁЁЁЁЁЁЁЁЁЁЁŽ‘’“”•–ŒŒŒŒŒŒŒŒŒŒŒввввввввввввввввввввввввввва$вб$вв$вг$вд$ве$вж$вз$ви$вй$вк$вл$вм$вн$во$вп$вр$вс$вт$ву$вф$вх$вц$вч$вш$вщ$вЖ$вЗ$вИ$вЙ$вК$вЛ$вМ$вН$вО$вП$вР$вС$вТ$вУ$вФ$вХ$вЦ$вЧ$вШ$вЩ$вЪ$вЫ$вЬ$вЭ$вЮ$вЯ$ЂЁЁЁЁЁЁЁЁЁЁЃЄЅІЇЈЉЊЋЁЂгггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггЮгггггггггЮггггггггггггггггггггггггггггггггггггггггггггггггггггггЮЮЮЮЮЮЮЮгггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггЮггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггвгггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггџгггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггУЖУЖУЖУЖУЖУЖУЖЃЄЅІЇЈЉЊЋЁЃЄЅІЇЈЉЊЋЁЃЄЅІЇЈЉЊЋЁггггггггггггггггггггггггггггггггггггггггггггЯЮЮЯЯУЖЮЯЯЮџЯџЮЮЮЮЮЯЯЯЯЮЮЮЮЮЯЯЯЮЮЮЯЯЯЯУЖУЖУЖУЖУЖЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮУЖУЖУЖУЖУЖУЖУЖУЖУЖУЖУЖЮЮЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЮЮЮЮЮЮЮЮЯЮЮЮЮЮЮЮЯЯЯЯЯЯЮЮЮЯЮЮЮЮЯЯЯЯЯЮЯЯЮЮУЖУЖЯЮЮЮЮЯЮЯЯЯЮЮЯЯЮЮЮЮЮЮЮЮЮЮЯЯЯЯЯЯЮЮУЖЮЮЮЮЮЮЮЮЮЮЮЮЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЮЯЯЯЯЮЮЯЮЯЮЮЯЮЯЯЯЯЮЮЮЮЮЯЯЮЮЮЮЮЮЯЯЯЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЯЯЮЮЮЮЮЮЮЮЮЮЮЯЯЮЮЮЮЯЯЯЯЮЯЯЮЮЯЯЮЮЮЮЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЮЮЯЯЯЯЯЯЯЯЮЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЮЮЮЮЮЯЮЯЮЮЮЯЯЯЯЯЮЮЮЮЮЯЯЯЮЮЮЮЯЮЮЮЯЯЯЯЯЮЯЮЮггггггггггггггггггггггггггггггггггггггггггггггггЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮЮггЮЮЮЮЮЮџџџггггггггггџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ0,1,2,3,4,5,6,7,8,9,:,;,<,=,>,?,@,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,[,\,],^,џ,,,,,,,,, , , , , ,,,,,,,,,,,,,,,,,,, ,!,",#,$,%,&,',(,),*,+,,,-,.,џa,`,k}}:>h,g,j,i,l,k,QqPRs,r,v,u,?@,€,ƒ,‚,…,„,‡,†,‰,ˆ,‹,Š,,Œ,,Ž,‘,,“,’,•,”,—,–,™,˜,›,š,,œ,Ÿ,ž,Ё, ,Ѓ,Ђ,Ѕ,Є,Ї,І,Љ,Ј,Ћ,Њ,­,Ќ,Џ,Ў,Б,А,Г,В,Е,Д,З,Ж,Й,И,Л,К,Н,М,П,О,С,Р,У,Т,Х,Ф,Ч,Ц,Щ,Ш,Ы,Ъ,Э,Ь,Я,Ю,б,а,г,в,е,д,з,ж,й,и,л,к,н,м,п,о,с,р,у,т,ггггггь,ы,ю,э,SSSџџџџџџџРРРРЁРР ЁЂЃЄЅІЇЈЉЊЋЌ­ЎЏАБВГДЕЖЗИЙКЛМНОПРСТУФХџџџџџџџџџџ џџџџџџџџџПџџџџџџџџџџџџџџ& џџџџџџџџџ џ џ џ џ џ џ џ џSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSРРКИКИРРРКИРКИРРРРРРРРРГРРГРКИРРКИУЖУЖУЖУЖРРРРРРРџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџггггггггггггггггггггггггггџгггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггџџџџџџџџџџџџггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггџџџџџџџџџџџџџџџџџџџџџџџџџџггггггггггггџџџџзРРРг €УЖУЖУЖУЖУЖггУЖУЖУЖУЖГТЕЕг€€€€€€€€€NRTPQQГгг€€€ Рггџ џџ%%ШШ Г Р џџџџџ џџџ џвв————вввввввввв џџџџџггггггггггггггггггггггггггггггггггггџџџџџџџџџџџџ вввввввввввввввввввввввввввввггџ——————————ввввввввввввввввввввввввввввввввввввввгЁЁЁЁЁЁЁЁЁЁЁЁЁЁЁввввввввввввввввввввввввввввгггв——————————вввввввввввввввввввввввввввввввввввввввЁЁЁЁЁЁЁЁЁЁЁЁЁЁЁввввввввввввггггвввввввввввввввввввввввввввввввввввввввввввввввџвввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввггггвввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввввггвввввввввввввввввввввввввввввввг џџџџџџџџџџгггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггггг џџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ  џџџгггггггггггггггггггггггггггггггггггггггггггггггггггггггџџџџџџџџџ ПП РРР lmnopqrstu џџџџџџџџџџџџџџџџџџџџAІ@ІCІBІEІDІGІFІIІHІKІJІMІLІOІNІQІPІSІRІUІTІWІVІYІXІ[ІZІ]І\І_І^ІaІ`ІcІbІeІdІgІfІiІhІkІjІmІlІ S РџџџџџџџџSSРІ€ІƒІ‚І…І„І‡І†І‰ІˆІ‹ІŠІІŒІІŽІ‘ІІ“І’І•І”І—І–Іџџџџџџџџ €€€€€€€€€€SSППППППџџџџџџџџШШШШШШШШШШШШШШШШШШШШШШШШШ#Ї"Ї%Ї$Ї'Ї&Ї)Ї(Ї+Ї*Ї-Ї,Ї/Ї.Ї3Ї2Ї5Ї4Ї7Ї6Ї9Ї8Ї;Ї:Ї=Ї<Ї?Ї>ЇAЇ@ЇCЇBЇEЇDЇGЇFЇIЇHЇKЇJЇMЇLЇOЇNЇQЇPЇSЇRЇUЇTЇWЇVЇYЇXЇ[ЇZЇ]Ї\Ї_Ї^ЇaЇ`ЇcЇbЇeЇdЇgЇfЇiЇhЇkЇjЇmЇlЇoЇnЇzЇyЇ|Ї{ЇyЇ~ЇЇ€ЇƒЇ‚Ї…Ї„Ї‡Ї†ЇЧЧŒЇ‹Їeџ‘ЇЇџџџџџџџџџџџџџџЁЇ ЇЃЇЂЇЅЇЄЇЇЇІЇЉЇЈЇџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ " & " ""ггггџџџџ——————ввХбџџџџџџ РРРРџџџџџџџџ &џџџџџџџџџППlmnopqrstuџџџџџџSSSSSSSSSSSSSSSSSS ППП џџџџlmnopqrstu """""OOOПП """""""""""џџџџџџџџџџџП џџџ""" $"""""ПППППППППППППџlmnopqrstuџџџџППџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ """"""""""џџџџџџџџџ " "џџlmnopqrstuџџПППП  ввв џџџџ S SSO SS SS S џџџџџџџџџџџџџџџџџџџџџџџџ ППџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ џџ џџ џџџџџџџџџ џ џџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ ""П&џџlmnopqrstuџџџџџџ џџџџџџџџџџџџ џџџџ џџџџ џџ џџ џџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ 7 Ы џ џ џ џ џ ЦЦЦЦЦЦЦЦЦЦЦЦЦЦЦЦџџџџџџџџџџџџџџџџџ ТЕџџџџџџџџџџџџџџџџ џџ џџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ Фгџџ""""""""""""""""РРРРРРРТЕРџџџџџџSSSSSSSџџџџџџџџџРГГББТЕТЕТЕТЕТЕТЕТЕТЕРРТЕРРРРБББНРНџРНРРГУЖУЖУЖОРРЫВЯЯЮџРХОРџџџџ џ џџџРРОХОРРУЖРЫНВННbcdefghijkНРЯЮЯРРAџBџCџDџEџFџGџHџIџJџKџLџMџNџOџPџQџRџSџTџUџVџWџXџYџZџУРЖШБШ!џ"џ#џ$џ%џ&џ'џ(џ)џ*џ+џ,џ-џ.џ/џ0џ1џ2џ3џ4џ5џ6џ7џ8џ9џ:џУЮЖЮУЖРУЖРР   џџџ џџ џџ џџ џџџХХЮШгХХџгЮЮЮЮггџџџџџџџџџџггџџecl-16.1.2/contrib/win32/000077500000000000000000000000001266352375300147625ustar00rootroot00000000000000ecl-16.1.2/contrib/win32/README000066400000000000000000000027401266352375300156450ustar00rootroot00000000000000In this directory you will find an interesting example of an application built using ECL's implementation of the UFFI specification. This example consists on several files: * win32.lisp: This is a lisp interface to the Microsoft Windows API for the graphical user interface. It is not finished but it suffices to demonstrate the most important ingredients you will need in a real-world application. * txtedit.lisp: A simple text editor written using the previous library. This text editor can make use of Scintilla component to provides syntax highlightning (http://www.scintilla.org). To enable it, simply copy the SciLexer.dll library in this directory (or where the system can find it). If the component is not present, a simple editor will be used instead. * lisp-kw.lisp: A file containing LISP keywords, used for syntax highlightning with the Scintilla component. This example makes use of static or dynamic FFI/callbacks. When win32.lisp is compiled into a FAS file, the static FFI/callbacks will be used. Otherwise, dynamic ones will be used (only under supported architectures). To compile the Win32 library (not required under architectures where dynamic FFI/callbacks are supported), use: (compile-file "win32.lisp") To start the editor, use: (load "txtedit") (win32::edit) This library has been contributed by Michael Goffioul (michael dot goffioul at swing dot be). Feel free to experiment with it and share your experience at the ECL mailing list. ecl-16.1.2/contrib/win32/lisp-kw.lisp000066400000000000000000000711231266352375300172450ustar00rootroot00000000000000(in-package "WIN32") (defparameter *txtedit-lisp-kw* "* find-method pprint-indent ** find-package pprint-linear *** find-restart pprint-logical-block + find-symbol pprint-newline ++ finish-output pprint-pop +++ first pprint-tab - fixnum pprint-tabular / flet prin1 // float prin1-to-string /// float-digits princ /= float-precision princ-to-string 1+ float-radix print 1- float-sign print-not-readable < floating-point-inexact print-not-readable-object <= floating-point-invalid-operation print-object = floating-point-overflow print-unreadable-object > floating-point-underflow probe-file >= floatp proclaim abort floor prog abs fmakunbound prog* access force-output prog1 acons format prog2 acos formatter progn acosh fourth program-error add-method fresh-line progv adjoin fround provide adjust-array ftruncate psetf adjustable-array-p ftype psetq allocate-instance funcall push alpha-char-p function pushnew alphanumericp function-keywords putprop and function-lambda-expression quote append functionp random apply gbitp random-state applyhook gcd random-state-p apropos generic-function rassoc apropos-list gensym rassoc-if aref gentemp rassoc-if-not arithmetic-error get ratio arithmetic-error-operands get-decoded-time rational arithmetic-error-operation get-dispatch-macro-character rationalize array get-internal-real-time rationalp array-dimension get-internal-run-time read array-dimension-limit get-macro-character read-byte array-dimensions get-output-stream-string read-char array-displacement get-properties read-char-no-hang array-element-type get-setf-expansion read-delimited-list array-has-fill-pointer-p get-setf-method read-eval-print array-in-bounds-p get-universal-time read-from-string array-rank getf read-line array-rank-limit gethash read-preserving-whitespace array-row-major-index go read-sequence array-total-size graphic-char-p reader-error array-total-size-limit handler-bind readtable arrayp handler-case readtable-case ash hash-table readtablep asin hash-table-count real asinh hash-table-p realp assert hash-table-rehash-size realpart assoc hash-table-rehash-threshold reduce assoc-if hash-table-size reinitialize-instance assoc-if-not hash-table-test rem atan host-namestring remf atanh identity remhash atom if remove base-char if-exists remove-duplicates base-string ignorable remove-if bignum ignore remove-if-not bit ignore-errors remove-method bit-and imagpart remprop bit-andc1 import rename-file bit-andc2 in-package rename-package bit-eqv in-package replace bit-ior incf require bit-nand initialize-instance rest bit-nor inline restart bit-not input-stream-p restart-bind bit-orc1 inspect restart-case bit-orc2 int-char restart-name bit-vector integer return bit-vector-p integer-decode-float return-from bit-xor integer-length revappend block integerp reverse boole interactive-stream-p room boole-1 intern rotatef boole-2 internal-time-units-per-second round boole-and intersection row-major-aref boole-andc1 invalid-method-error rplaca boole-andc2 invoke-debugger rplacd boole-c1 invoke-restart safety boole-c2 invoke-restart-interactively satisfies boole-clr isqrt sbit boole-eqv keyword scale-float boole-ior keywordp schar boole-nand labels search boole-nor lambda second boole-orc1 lambda-list-keywords sequence boole-orc2 lambda-parameters-limit serious-condition boole-set last set boole-xor lcm set-char-bit boolean ldb set-difference both-case-p ldb-test set-dispatch-macro-character boundp ldiff set-exclusive-or break least-negative-double-float set-macro-character broadcast-stream least-negative-long-float set-pprint-dispatch broadcast-stream-streams least-negative-normalized-double-float set-syntax-from-char built-in-class least-negative-normalized-long-float setf butlast least-negative-normalized-short-float setq byte least-negative-normalized-single-float seventh byte-position least-negative-short-float shadow byte-size least-negative-single-float shadowing-import call-arguments-limit least-positive-double-float shared-initialize call-method least-positive-long-float shiftf call-next-method least-positive-normalized-double-float short-float capitalize least-positive-normalized-long-float short-float-epsilon car least-positive-normalized-short-float short-float-negative-epsilon case least-positive-normalized-single-float short-site-name catch least-positive-short-float signal ccase least-positive-single-float signed-byte cdr length signum ceiling let simle-condition cell-error let* simple-array cell-error-name lisp simple-base-string cerror lisp-implementation-type simple-bit-vector change-class lisp-implementation-version simple-bit-vector-p char list simple-condition-format-arguments char-bit list* simple-condition-format-control char-bits list-all-packages simple-error char-bits-limit list-length simple-string char-code listen simple-string-p char-code-limit listp simple-type-error char-control-bit load simple-vector char-downcase load-logical-pathname-translations simple-vector-p char-equal load-time-value simple-warning char-font locally sin char-font-limit log single-flaot-epsilon char-greaterp logand single-float char-hyper-bit logandc1 single-float-epsilon char-int logandc2 single-float-negative-epsilon char-lessp logbitp sinh char-meta-bit logcount sixth char-name logeqv sleep char-not-equal logical-pathname slot-boundp char-not-greaterp logical-pathname-translations slot-exists-p char-not-lessp logior slot-makunbound char-super-bit lognand slot-missing char-upcase lognor slot-unbound char/= lognot slot-value char< logorc1 software-type char<= logorc2 software-version char= logtest some char> logxor sort char>= long-float space character long-float-epsilon special characterp long-float-negative-epsilon special-form-p check-type long-site-name special-operator-p cis loop speed class loop-finish sqrt class-name lower-case-p stable-sort class-of machine-instance standard clear-input machine-type standard-char clear-output machine-version standard-char-p close macro-function standard-class clrhash macroexpand standard-generic-function code-char macroexpand-1 standard-method coerce macroexpand-l standard-object commonp macrolet step compilation-speed make-array storage-condition compile make-array store-value compile-file make-broadcast-stream stream compile-file-pathname make-char stream-element-type compiled-function make-concatenated-stream stream-error compiled-function-p make-condition stream-error-stream compiler-let make-dispatch-macro-character stream-external-format compiler-macro make-echo-stream streamp compiler-macro-function make-hash-table streamup complement make-instance string complex make-instances-obsolete string-capitalize complexp make-list string-char compute-applicable-methods make-load-form string-char-p compute-restarts make-load-form-saving-slots string-downcase concatenate make-method string-equal concatenated-stream make-package string-greaterp concatenated-stream-streams make-pathname string-left-trim cond make-random-state string-lessp condition make-sequence string-not-equal conjugate make-string string-not-greaterp cons make-string-input-stream string-not-lessp consp make-string-output-stream string-right-strim constantly make-symbol string-right-trim constantp make-synonym-stream string-stream continue make-two-way-stream string-trim control-error makunbound string-upcase copy-alist map string/= copy-list map-into string< copy-pprint-dispatch mapc string<= copy-readtable mapcan string= copy-seq mapcar string> copy-structure mapcon string>= copy-symbol maphash stringp copy-tree mapl structure cos maplist structure-class cosh mask-field structure-object count max style-warning count-if member sublim count-if-not member-if sublis ctypecase member-if-not subseq debug merge subsetp decf merge-pathname subst declaim merge-pathnames subst-if declaration method subst-if-not declare method-combination substitute decode-float method-combination-error substitute-if decode-universal-time method-qualifiers substitute-if-not defclass min subtypep defconstant minusp svref defgeneric mismatch sxhash define-compiler-macro mod symbol define-condition most-negative-double-float symbol-function define-method-combination most-negative-fixnum symbol-macrolet define-modify-macro most-negative-long-float symbol-name define-setf-expander most-negative-short-float symbol-package define-setf-method most-negative-single-float symbol-plist define-symbol-macro most-positive-double-float symbol-value defmacro most-positive-fixnum symbolp defmethod most-positive-long-float synonym-stream defpackage most-positive-short-float synonym-stream-symbol defparameter most-positive-single-float sys defsetf muffle-warning system defstruct multiple-value-bind t deftype multiple-value-call tagbody defun multiple-value-list tailp defvar multiple-value-prog1 tan delete multiple-value-seteq tanh delete-duplicates multiple-value-setq tenth delete-file multiple-values-limit terpri delete-if name-char the delete-if-not namestring third delete-package nbutlast throw denominator nconc time deposit-field next-method-p trace describe nil translate-logical-pathname describe-object nintersection translate-pathname destructuring-bind ninth tree-equal digit-char no-applicable-method truename digit-char-p no-next-method truncase directory not truncate directory-namestring notany two-way-stream disassemble notevery two-way-stream-input-stream division-by-zero notinline two-way-stream-output-stream do nreconc type do* nreverse type-error do-all-symbols nset-difference type-error-datum do-exeternal-symbols nset-exclusive-or type-error-expected-type do-external-symbols nstring type-of do-symbols nstring-capitalize typecase documentation nstring-downcase typep dolist nstring-upcase unbound-slot dotimes nsublis unbound-slot-instance double-float nsubst unbound-variable double-float-epsilon nsubst-if undefined-function double-float-negative-epsilon nsubst-if-not unexport dpb nsubstitute unintern dribble nsubstitute-if union dynamic-extent nsubstitute-if-not unless ecase nth unread echo-stream nth-value unread-char echo-stream-input-stream nthcdr unsigned-byte echo-stream-output-stream null untrace ed number unuse-package eighth numberp unwind-protect elt numerator update-instance-for-different-class encode-universal-time nunion update-instance-for-redefined-class end-of-file oddp upgraded-array-element-type endp open upgraded-complex-part-type enough-namestring open-stream-p upper-case-p ensure-directories-exist optimize use-package ensure-generic-function or use-value eq otherwise user eql output-stream-p user-homedir-pathname equal package values equalp package-error values-list error package-error-package vector etypecase package-name vector-pop eval package-nicknames vector-push eval-when package-shadowing-symbols vector-push-extend evalhook package-use-list vectorp evenp package-used-by-list warn every packagep warning exp pairlis when export parse-error wild-pathname-p expt parse-integer with-accessors extended-char parse-namestring with-compilation-unit fboundp pathname with-condition-restarts fceiling pathname-device with-hash-table-iterator fdefinition pathname-directory with-input-from-string ffloor pathname-host with-open-file fifth pathname-match-p with-open-stream file-author pathname-name with-output-to-string file-error pathname-type with-package-iterator file-error-pathname pathname-version with-simple-restart file-length pathnamep with-slots file-namestring peek-char with-standard-io-syntax file-position phase write file-stream pi write-byte file-string-length plusp write-char file-write-date pop write-line fill position write-sequence fill-pointer position-if write-string find position-if-not write-to-string find-all-symbols pprint y-or-n-p find-class pprint-dispatch yes-or-no-p find-if pprint-exit-if-list-exhausted zerop find-if-not pprint-fill caar cadr cdar cddr caaar caadr cadar caddr cdaar cdadr cddar cdddr caaaar caaadr caadar caaddr cadaar cadadr caddar cadddr cdaaar cdaadr cdadar cdaddr cddaar cddadr cdddar cddddr *applyhook* *load-pathname* *print-pprint-dispatch* *break-on-signals* *load-print* *print-pprint-dispatch* *break-on-signals* *load-truename* *print-pretty* *break-on-warnings* *load-verbose* *print-radix* *compile-file-pathname* *macroexpand-hook* *print-readably* *compile-file-pathname* *modules* *print-right-margin* *compile-file-truename* *package* *print-right-margin* *compile-file-truename* *print-array* *query-io* *compile-print* *print-base* *random-state* *compile-verbose* *print-case* *read-base* *compile-verbose* *print-circle* *read-default-float-format* *debug-io* *print-escape* *read-eval* *debugger-hook* *print-gensym* *read-suppress* *default-pathname-defaults* *print-length* *readtable* *error-output* *print-level* *standard-input* *evalhook* *print-lines* *standard-output* *features* *print-miser-width* *terminal-io* *gensym-counter* *print-miser-width* *trace-output*") (defparameter *txtedit-lisp-kw2* ":abort :from-end :overwrite :adjustable :gensym :predicate :append :host :preserve-whitespace :array :if-does-not-exist :pretty :base :if-exists :print :case :include :print-function :circle :index :probe :conc-name :inherited :radix :constructor :initial-contents :read-only :copier :initial-element :rehash-size :count :initial-offset :rehash-threshold :create :initial-value :rename :default :input :rename-and-delete :defaults :internal :size :device :io :start :direction :junk-allowed :start1 :directory :key :start2 :displaced-index-offset :length :stream :displaced-to :level :supersede :element-type :name :test :end :named :test-not :end1 :new-version :type :end2 :nicknames :use :error :output :verbose :escape :output-file :version :external :fill-pointer") (defparameter *txtedit-decl-forms* '(defmacro defsetf deftype defun defmethod defgeneric lambda do do* do-all-symbols do-external-symbols do-symbols dotimes let let* flet macrolet labels multiple-value-bind locally)) ecl-16.1.2/contrib/win32/txtedit.lisp000066400000000000000000000754351266352375300173560ustar00rootroot00000000000000;;; Copyright (c) 2005, Michael Goffioul (michael dot goffioul at swing dot be) ;;; ;;; This program is free software; you can redistribute it and/or ;;; modify it under the terms of the GNU Library General Public ;;; License as published by the Free Software Foundation; either ;;; version 2 of the License, or (at your option) any later version. ;;; ;;; See file '../../Copyright' for full details. ;;; ;;; SAMPLE TEXT EDITOR APPLICATION USING THE WIN32 API ;;; (require "WIN32" "win32") (in-package "WIN32") (defvar *txtedit-class-registered* nil) (defvar *txtedit-width* 800) (defvar *txtedit-height* 600) (defvar *txtedit-edit* nil) (defvar *txtedit-tab* *NULL*) (defvar *txtedit-tab-proc* *NULL*) (defvar *txtedit-current* nil) (defvar *txtedit-edit-class* 0) (defvar *txtedit-process* nil) (defvar *txtedit-handle* *NULL*) (defvar *txtedit-files* nil) (defvar *txtedit-dlg-handle* *NULL*) (defvar *txtedit-findreplace-msg* (registerwindowmessage *FINDMSGSTRING*)) (defstruct txtedit (handle *NULL*) title dirty) (defvar *txtedit-default-title* "ECL Text Editor") (defparameter +IDM_OPEN+ 100) (defparameter +IDM_QUIT+ 101) (defparameter +IDM_SAVE+ 102) (defparameter +IDM_SAVEAS+ 103) (defparameter +IDM_NEW+ 104) (defparameter +IDM_CUT+ 105) (defparameter +IDM_COPY+ 106) (defparameter +IDM_PASTE+ 107) (defparameter +IDM_UNDO+ 108) (defparameter +IDM_SELECTALL+ 109) (defparameter +IDM_ABOUT+ 110) (defparameter +IDM_NEXTWINDOW+ 111) (defparameter +IDM_PREVWINDOW+ 112) (defparameter +IDM_CLOSE+ 113) (defparameter +IDM_MATCH_PAREN+ 114) (defparameter +IDM_FIND+ 115) (defparameter +IDM_WINDOW_FIRST+ 500) (defparameter +IDM_WINDOW_LAST+ 600) (defparameter +EDITCTL_ID+ 1000) (defparameter +TABCTL_ID+ 1001) (defparameter *txtedit-about-text* "Text Editor for ECL. This application serves as a demonstrator for the WIN32 FFI interface of ECL. Copyright (c) 2005, Michael Goffioul.") (defun create-menus () ;(return *NULL*) (let ((bar (createmenu)) (file_pop (createpopupmenu)) (edit_pop (createpopupmenu)) (win_pop (createpopupmenu)) (help_pop (createpopupmenu))) ;; File menu (appendmenu bar (logior *MF_STRING* *MF_POPUP*) (make-wparam file_pop) "&File") (appendmenu file_pop *MF_STRING* +IDM_NEW+ "&New Ctrl+N") (appendmenu file_pop *MF_STRING* +IDM_OPEN+ "&Open... Ctrl+O") (appendmenu file_pop *MF_STRING* +IDM_CLOSE+ "&Close Ctrl+W") (appendmenu file_pop *MF_SEPARATOR* 0 "") (appendmenu file_pop *MF_STRING* +IDM_SAVE+ "&Save Ctrl+S") (appendmenu file_pop *MF_STRING* +IDM_SAVEAS+ "Save &As...") (appendmenu file_pop *MF_SEPARATOR* 0 "") (appendmenu file_pop *MF_STRING* +IDM_QUIT+ "&Exit Ctrl+Q") ;; Edit menu (appendmenu bar (logior *MF_STRING* *MF_POPUP*) (make-wparam edit_pop) "&Edit") (appendmenu edit_pop *MF_STRING* +IDM_UNDO+ "&Undo Ctrl+Z") (appendmenu edit_pop *MF_SEPARATOR* 0 "") (appendmenu edit_pop *MF_STRING* +IDM_CUT+ "&Cut Ctrl+X") (appendmenu edit_pop *MF_STRING* +IDM_COPY+ "Cop&y Ctrl+C") (appendmenu edit_pop *MF_STRING* +IDM_PASTE+ "&Paste Ctrl+V") (appendmenu edit_pop *MF_SEPARATOR* 0 "") (appendmenu edit_pop *MF_STRING* +IDM_MATCH_PAREN+ "&Match parenthesis Ctrl+D") (appendmenu edit_pop *MF_SEPARATOR* 0 "") (appendmenu edit_pop *MF_STRING* +IDM_SELECTALL+ "&Select All Ctrl+A") ;; Windows menu (appendmenu bar (logior *MF_STRING* *MF_POPUP*) (make-wparam win_pop) "&Window") (appendmenu win_pop *MF_STRING* +IDM_NEXTWINDOW+ "&Next Ctrl+Right") (appendmenu win_pop *MF_STRING* +IDM_PREVWINDOW+ "&Previous Ctrl+Left") ;; Help menu (appendmenu bar (logior *MF_STRING* *MF_POPUP*) (make-wparam help_pop) "&Help") (appendmenu help_pop *MF_STRING* +IDM_ABOUT+ "&About...") bar)) (defun create-accels () (macrolet ((add-accel (key ID accTable pos) `(with-foreign-object (a 'ACCEL) (setf (get-slot-value a 'ACCEL 'fVirt) (logior *FCONTROL* *FVIRTKEY*)) (setf (get-slot-value a 'ACCEL 'key) ,(if (characterp key) `(char-code ,key) key)) (setf (get-slot-value a 'ACCEL 'cmd) ,ID) (setf (deref-array ,accTable '(* ACCEL) ,pos) a)))) (let* ((accTableSize (if (= *txtedit-edit-class* 2) 10 9)) (accTable (allocate-foreign-object 'ACCEL accTableSize))) (add-accel #\Q +IDM_QUIT+ accTable 0) (add-accel #\N +IDM_NEW+ accTable 1) (add-accel #\O +IDM_OPEN+ accTable 2) (add-accel #\S +IDM_SAVE+ accTable 3) (add-accel #\A +IDM_SELECTALL+ accTable 4) (add-accel *VK_LEFT* +IDM_PREVWINDOW+ accTable 5) (add-accel *VK_RIGHT* +IDM_NEXTWINDOW+ accTable 6) (add-accel #\W +IDM_CLOSE+ accTable 7) (add-accel #\F +IDM_FIND+ accTable 8) (when (= *txtedit-edit-class* 2) (add-accel #\D +IDM_MATCH_PAREN+ accTable 9)) (prog1 (createacceleratortable accTable accTableSize) (free-foreign-object accTable))))) (defun update-caption (hwnd) (let ((str (tab-name (current-editor) #'identity nil))) (setwindowtext hwnd (format nil "~@[~A - ~]~A~C" str *txtedit-default-title* #\Null)))) (defun current-editor () (nth *txtedit-current* *txtedit-edit*)) (defun tab-name (editor &optional (fun #'file-namestring) (final-char #\Null)) (format nil "~:[New~;~:*~A~]~@[*~*~]~@[~C~]" (and (txtedit-title editor) (funcall fun (txtedit-title editor))) (txtedit-dirty editor) final-char)) (defun update-tab (idx) (let ((editor (nth idx *txtedit-edit*))) (with-foreign-object (tab 'TCITEM) (setf (get-slot-value tab 'TCITEM 'mask) *TCIF_TEXT*) (setf (get-slot-value tab 'TCITEM 'pszText) (tab-name editor)) (sendmessage *txtedit-tab* *TCM_SETITEM* idx (make-lparam tab)) ))) (defun set-current-editor (idx hwnd &optional force-p) (when (<= 0 idx (1- (length *txtedit-edit*))) (let ((old-ed (and *txtedit-current* (current-editor))) (new-ed (nth idx *txtedit-edit*))) (unless (and (null force-p) (eq old-ed new-ed)) (setq *txtedit-current* idx) (setwindowpos (txtedit-handle new-ed) *HWND_TOP* 0 0 0 0 (logior *SWP_NOSIZE* *SWP_NOMOVE*)) (setfocus (txtedit-handle new-ed)) (when (/= (sendmessage *txtedit-tab* *TCM_GETCURSEL* 0 0) idx) (sendmessage *txtedit-tab* *TCM_SETCURSEL* idx 0)) (update-caption hwnd))))) (defun close-editor (idx hwnd) (let ((editor (nth idx *txtedit-edit*))) (if (or (null (txtedit-dirty editor)) (and (set-current-editor idx hwnd) nil) (let ((m-result (messagebox hwnd (format nil "Do you want to save changes?~@[~2%~A~%~]~C" (txtedit-title editor) #\Null) "Confirmation" (logior *MB_YESNOCANCEL* *MB_ICONQUESTION*)))) (cond ((= m-result *IDNO*) t) ((= m-result *IDCANCEL*) nil) ((= m-result *IDYES*) (warn "Not implemented") nil)))) (progn (destroywindow (txtedit-handle editor)) (sendmessage *txtedit-tab* *TCM_DELETEITEM* idx 0) (setq *txtedit-edit* (remove editor *txtedit-edit*)) (when *txtedit-edit* (set-current-editor (min (1- (length *txtedit-edit*)) (max *txtedit-current* 0)) hwnd t)) t) nil))) (ffi:def-struct SCNotification (NotifyHeader NMHDR) (position :int) (ch :int)) (defun init-scintilla-component (hnd) ;; Set LISP lexer (sendmessage hnd 4001 21 0) ;(sendmessage hnd 2090 7 0) ;; Define default style attributes (with-foreign-string (fn "Courier New") (sendmessage hnd 2056 32 (make-lparam fn))) (sendmessage hnd 2050 0 0) ;; Define comment style (sendmessage hnd 2051 1 #xDD0000) (sendmessage hnd 2054 1 0) (sendmessage hnd 2051 12 #xDD0000) (sendmessage hnd 2054 12 0) ;; Define string style (sendmessage hnd 2051 6 #x0000C8) ;; Define number style (sendmessage hnd 2051 2 #x0000C8) ;; Define operator style (sendmessage hnd 2051 10 #xC800C8) ;; Define symbol style (sendmessage hnd 2051 5 #xC8C800) ;; Define brace style (sendmessage hnd 2052 34 #xFFCCCC) (sendmessage hnd 2051 35 #xFFFFFF) (sendmessage hnd 2052 35 #x0000CC) ;; Define keyword style (sendmessage hnd 2051 3 #x00C8C8) (sendmessage hnd 2053 3 0) (sendmessage hnd 2051 4 #x00C800) (sendmessage hnd 2051 11 #x00C800) (unless (boundp '*txtedit-lisp-kw*) (load "lisp-kw.lisp")) (with-foreign-strings ((kwList *txtedit-lisp-kw*) (kwList2 *txtedit-lisp-kw2*)) (sendmessage hnd 4005 0 (make-lparam kwList)) (sendmessage hnd 4005 1 (make-lparam kwList2))) ;; Define margins (sendmessage hnd 2242 1 0) (with-foreign-string (s "_9999") (sendmessage hnd 2242 0 (sendmessage hnd 2276 33 (make-lparam s)))) ;; Define selection style (sendmessage hnd 2067 1 #xFFFFFF) ) (defun scintilla-indent-position (pos line hnd) (+ (sendmessage hnd 2127 line 0) (- pos (sendmessage hnd 2128 line 0)))) (defun scintilla-read-form (pos hnd) (read-from-string (with-output-to-string (s) (loop for k from pos with style = (sendmessage hnd 2010 pos 0) for ch = (code-char (sendmessage hnd 2007 k 0)) for st = (sendmessage hnd 2010 k 0) if (and (= st style) (graphic-char-p ch) (not (eq ch #\Space))) do (write-char ch s) else return nil)) nil nil)) (defun scintilla-declare-form-p (form) (member form *txtedit-decl-forms*)) (defun scintilla-compute-indentation (curPos curLine hnd) (loop for k from curPos downto 0 for ch = (code-char (sendmessage hnd 2007 k 0)) for st = (sendmessage hnd 2010 k 0) with depth = 0 with lineIndent = 0 with lastCharPos = nil with prevCharPos = nil when (= st 10) do (cond ((and (= depth 0) (eq ch #\()) (if lastCharPos (let ((lastChar (code-char (sendmessage hnd 2007 lastCharPos 0))) lastForm) (cond ((member lastChar (list #\( #\;)) (return (scintilla-indent-position lastCharPos curLine hnd))) ((and (setq lastForm (scintilla-read-form lastCharPos hnd)) (scintilla-declare-form-p lastForm)) (return (+ (scintilla-indent-position k curLine hnd) 2))) ((and prevCharPos (not (eq prevCharPos lastCharPos))) (return (scintilla-indent-position prevCharPos curLine hnd))) (t (return (+ (scintilla-indent-position lastCharPos curLine hnd) 1))))) (progn (return (+ (scintilla-indent-position k curLine hnd) 1))))) ((eq ch #\() (decf depth)) ((eq ch #\)) (incf depth))) if (and (graphic-char-p ch) (not (eq ch #\Space))) do (setq lastCharPos k) else do (setq prevCharPos lastCharPos) when (eq ch #\Newline) do (decf curLine) and do (case lineIndent (0 (incf lineIndent)) (1 (when (= depth 0) (return (sendmessage hnd 2127 (1+ curLine) 0))))) finally (return -1))) (defun scintilla-char-added (hnd ch) (cond ((eq ch #\Newline) (let* ((curPos (sendmessage hnd 2008 0 0)) (curLine (sendmessage hnd 2166 curPos 0)) (indent (scintilla-compute-indentation (1- curPos) curLine hnd))) (when (>= indent 0) (sendmessage hnd 2126 curLine indent) (sendmessage hnd 2025 (sendmessage hnd 2128 curLine 0) 0) ))) ;((eq ch #\() ; (let ((curPos (1- (sendmessage hnd 2008 0 0)))) ; (when (scintilla-valid-brace-p curPos hnd) ; (with-foreign-string (s ")") ; (sendmessage hnd 2003 (1+ curPos) (make-lparam s)))))) (t ))) (defun scintilla-get-matching-braces (hnd &aux curPos) (when (>= (setq curPos (1- (sendmessage hnd 2008 0 0))) 0) (let ((ch (code-char (sendmessage hnd 2007 curPos 0)))) (when (and (or (eq ch #\() (eq ch #\))) (= (sendmessage hnd 2010 curPos 0) 10)) (let ((matchPos (sendmessage hnd 2353 curPos 0))) (return-from scintilla-get-matching-braces (values curPos matchPos)))))) (values nil nil)) (defun scintilla-check-for-brace (hnd) (multiple-value-bind (curPos matchPos) (scintilla-get-matching-braces hnd) (if curPos (if (>= matchPos 0) (sendmessage hnd 2351 curPos matchPos) (sendmessage hnd 2352 curPos 0)) (sendmessage hnd 2351 #xFFFFFFFF -1)))) (defun create-editor (parent &optional (set-current t)) (with-foreign-object (r 'RECT) (getclientrect parent r) (sendmessage *txtedit-tab* *TCM_ADJUSTRECT* *FALSE* (make-lparam r)) (let ((new-editor (make-txtedit :handle (createwindowex *WS_EX_CLIENTEDGE* (txtedit-class-name) "" (logior *WS_CHILD* *WS_HSCROLL* *WS_VSCROLL* *WS_VISIBLE* *WS_CLIPSIBLINGS* *ES_AUTOHSCROLL* *ES_AUTOVSCROLL* *ES_MULTILINE* *ES_LEFT*) (get-slot-value r 'RECT 'left) (get-slot-value r 'RECT 'top) (- (get-slot-value r 'RECT 'right) (get-slot-value r 'RECT 'left)) (- (get-slot-value r 'RECT 'bottom) (get-slot-value r 'RECT 'top)) *txtedit-tab* (make-ID +EDITCTL_ID+) *NULL* *NULL*)))) (sendmessage (txtedit-handle new-editor) *WM_SETFONT* (make-wparam (getstockobject *SYSTEM_FIXED_FONT*)) 0) (case *txtedit-edit-class* (1 (sendmessage (txtedit-handle new-editor) *EM_SETEVENTMASK* 0 *ENM_CHANGE*)) (2 (init-scintilla-component (txtedit-handle new-editor)))) (with-foreign-object (tab 'TCITEM) (setf (get-slot-value tab 'TCITEM 'mask) *TCIF_TEXT*) (setf (get-slot-value tab 'TCITEM 'pszText) (tab-name new-editor)) (sendmessage *txtedit-tab* *TCM_INSERTITEM* (length *txtedit-edit*) (make-lparam tab))) (setq *txtedit-edit* (append *txtedit-edit* (list new-editor))) (when set-current (set-current-editor (1- (length *txtedit-edit*)) parent)) new-editor))) (defun unix2dos (str) (let ((new-str (make-array (length str) :element-type 'character :adjustable t :fill-pointer 0)) (return-p nil) c) (with-output-to-string (out new-str) (do ((it (si::make-seq-iterator str) (si::seq-iterator-next str it))) ((null it)) (case (setq c (si::seq-iterator-ref str it)) (#\Return (setq return-p t)) (#\Newline (unless return-p (write-char #\Return out)) (setq return-p nil)) (t (setq return-p nil))) (write-char c out))) new-str)) (defun read-file (pn hwnd) (setq pn (probe-file pn)) (if pn (with-open-file (f pn) (let* ((len (file-length f)) (buf (make-string len))) (read-sequence buf f) (setwindowtext (txtedit-handle (current-editor)) (unix2dos buf)) (setf (txtedit-dirty (current-editor)) nil) (setf (txtedit-title (current-editor)) (substitute #\\ #\/ (namestring pn))) (update-caption hwnd) (update-tab *txtedit-current*))) (messagebox hwnd "File does not exist." "Error" (logior *MB_OK* *MB_ICONERROR*)))) (defun save-file (pn hwnd) (unless pn (setq pn (txtedit-title (current-editor)))) (with-open-file (f pn :direction :output :if-does-not-exist :create :if-exists :supersede) (let ((txt (getwindowtext (txtedit-handle (current-editor))))) (write-sequence txt f) (setf (txtedit-title (current-editor)) (substitute #\\ #\/(namestring pn))) (setf (txtedit-dirty (current-editor)) nil) (update-caption hwnd) (update-tab *txtedit-current*)))) (defun close-or-exit (idx hwnd) (if (= (length *txtedit-edit*) 1) (postmessage hwnd *WM_CLOSE* 0 0) (close-editor idx hwnd))) (defun tab-proc (hwnd umsg wparam lparam) (cond ((or (= umsg *WM_COMMAND*) (= umsg *WM_NOTIFY*)) (txtedit-proc (getparent hwnd) umsg wparam lparam)) (t (callwindowproc *txtedit-tab-proc* hwnd umsg wparam lparam)))) (defvar *txtedit-level* 0) (defun txtedit-proc (hwnd umsg wparam lparam &aux (*txtedit-level* (1+ *txtedit-level*))) ;(format t "txtedit-proc: ~D~%" *txtedit-level*) (cond ((= umsg *WM_DESTROY*) (postquitmessage 0) 0) ((= umsg *WM_CLOSE*) (if (do ((flag t)) ((not (and *txtedit-edit* flag)) flag) (setq flag (close-editor 0 hwnd))) (destroywindow hwnd) 0)) ((= umsg *WM_CREATE*) (when (null-pointer-p (getmodulehandle "comctl32")) (initcommoncontrols)) (setq *txtedit-tab* (createwindowex 0 *WC_TABCONTROL* "" (logior *WS_CHILD* *WS_VISIBLE* *WS_CLIPCHILDREN*) 0 0 0 0 hwnd (make-ID +TABCTL_ID+) *NULL* *NULL*)) (setq *txtedit-tab-proc* (register-wndproc *txtedit-tab* #'tab-proc)) (sendmessage *txtedit-tab* *WM_SETFONT* (make-wparam (getstockobject *DEFAULT_GUI_FONT*)) 0) (create-editor hwnd) (with-cast-int-pointer (lparam CREATESTRUCT) (let ((params (get-slot-value lparam 'CREATESTRUCT 'lpCreateParams))) (unless (null-pointer-p params) (read-file (convert-from-foreign-string params) hwnd)))) 0) ((= umsg *WM_SIZE*) (unless (null-pointer-p *txtedit-tab*) (movewindow *txtedit-tab* 0 0 (loword lparam) (hiword lparam) *TRUE*) (with-foreign-object (r 'RECT) (setrect r 0 0 (loword lparam) (hiword lparam)) (sendmessage *txtedit-tab* *TCM_ADJUSTRECT* *FALSE* (make-lparam r)) (dotimes (k (length *txtedit-edit*)) (movewindow (txtedit-handle (nth k *txtedit-edit*)) (get-slot-value r 'RECT 'left) (get-slot-value r 'RECT 'top) (- (get-slot-value r 'RECT 'right) (get-slot-value r 'RECT 'left)) (- (get-slot-value r 'RECT 'bottom) (get-slot-value r 'RECT 'top)) (if (= k *txtedit-current*) *TRUE* *FALSE*))))) 0) ((= umsg *WM_SETFOCUS*) (unless (null-pointer-p (txtedit-handle (current-editor))) (setfocus (txtedit-handle (current-editor)))) 0) ((= umsg *WM_NOTIFY*) (with-cast-int-pointer (lparam NMHDR) (let ((ctrl-ID (get-slot-value lparam 'NMHDR 'idFrom)) (code (get-slot-value lparam 'NMHDR 'code)) (hnd (get-slot-value lparam 'NMHDR 'hwndFrom))) (cond ((= ctrl-ID +TABCTL_ID+) (cond ((= code *TCN_SELCHANGE*) (set-current-editor (sendmessage hnd *TCM_GETCURSEL* 0 0) hwnd)) (t ))) ((and (= *txtedit-edit-class* 2) (= code 2001)) (with-cast-pointer (lparam SCNotification) (scintilla-char-added hnd (code-char (get-slot-value lparam 'SCNotification 'ch))))) ((and (= *txtedit-edit-class* 2) (= code 2007)) (scintilla-check-for-brace hnd)) (t )))) 0) ((= umsg *WM_CONTEXTMENU*) (let ((hnd (make-handle wparam)) (x (get-x-lparam lparam)) (y (get-y-lparam lparam))) (cond ((equal hnd *txtedit-tab*) (with-foreign-objects ((ht 'TCHITTESTINFO) (pt 'POINT)) (setf (get-slot-value pt 'POINT 'x) x) (setf (get-slot-value pt 'POINT 'y) y) (screentoclient *txtedit-tab* pt) (setf (get-slot-value ht 'TCHITTESTINFO 'pt) pt) (let ((tab (sendmessage *txtedit-tab* *TCM_HITTEST* 0 (make-lparam ht)))) (when (>= tab 0) (let ((hMenu (createpopupmenu)) menu-ID) (appendmenu hMenu *MF_STRING* +IDM_CLOSE+ "&Close") (when (/= (setq menu-ID (trackpopupmenuex hMenu (logior *TPM_NONOTIFY* *TPM_RETURNCMD*) x y hwnd *NULL*)) 0) (close-or-exit tab hwnd)) (destroymenu hMenu)))))))) 0) ((= umsg *WM_INITMENUPOPUP*) (case (loword lparam) (2 (let* ((wMenu (make-handle wparam)) (nPos (loword lparam)) (nItems (getmenuitemcount wMenu))) (dotimes (j (- nItems 2)) (deletemenu wMenu 2 *MF_BYPOSITION*)) (when *txtedit-edit* (appendmenu wMenu *MF_SEPARATOR* 0 "") (loop for e in *txtedit-edit* for k from 0 do (progn (appendmenu wMenu *MF_STRING* (+ +IDM_WINDOW_FIRST+ k) (tab-name e)) (when (= k *txtedit-current*) (checkmenuitem wMenu (+ k 3) (logior *MF_BYPOSITION* *MF_CHECKED*)))))) (enablemenuitem wMenu +IDM_PREVWINDOW+ (if (= *txtedit-current* 0) *MF_GRAYED* *MF_ENABLED*)) (enablemenuitem wMenu +IDM_NEXTWINDOW+ (if (< *txtedit-current* (1- (length *txtedit-edit*))) *MF_ENABLED* *MF_GRAYED*)) )) ) 0) ((= umsg *WM_COMMAND*) (let ((ctrl-ID (loword wparam)) (nmsg (hiword wparam)) (hnd (make-pointer lparam 'HANDLE))) (cond ((= ctrl-ID +EDITCTL_ID+) (cond ((= nmsg *EN_CHANGE*) (unless (txtedit-dirty (current-editor)) (setf (txtedit-dirty (current-editor)) t) (update-caption hwnd) (update-tab *txtedit-current*))) (t ))) ((= ctrl-ID +IDM_QUIT+) (sendmessage hwnd *WM_CLOSE* 0 0)) ((= ctrl-ID +IDM_OPEN+) (let ((pn (get-open-filename :owner hwnd :filter '(("LISP source file (*.lisp)" . "*.lisp;*.lsp") ("All Files (*)" . "*"))))) (when pn (create-editor hwnd) (read-file pn hwnd)))) ((and (= ctrl-ID +IDM_SAVE+) (txtedit-title (current-editor))) (save-file nil hwnd)) ((or (= ctrl-ID +IDM_SAVEAS+) (and (= ctrl-ID +IDM_SAVE+) (null (txtedit-title (current-editor))))) (let ((pn (get-open-filename :owner hwnd :filter '(("LISP source file (*.lisp)" . "*.lisp;*.lsp") ("All Files (*)" . "*")) :dlgfn #'getsavefilename :flags *OFN_OVERWRITEPROMPT*))) (when pn (save-file pn hwnd)))) ((= ctrl-ID +IDM_NEW+) (create-editor hwnd)) ((= ctrl-ID +IDM_CUT+) (sendmessage (txtedit-handle (current-editor)) *WM_CUT* 0 0)) ((= ctrl-ID +IDM_COPY+) (sendmessage (txtedit-handle (current-editor)) *WM_COPY* 0 0)) ((= ctrl-ID +IDM_PASTE+) (sendmessage (txtedit-handle (current-editor)) *WM_PASTE* 0 0)) ((= ctrl-ID +IDM_UNDO+) (unless (= (sendmessage (txtedit-handle (current-editor)) *EM_CANUNDO* 0 0) 0) (sendmessage (txtedit-handle (current-editor)) *EM_UNDO* 0 0))) ((= ctrl-ID +IDM_SELECTALL+) (sendmessage (txtedit-handle (current-editor)) *EM_SETSEL* 0 -1)) ((= ctrl-ID +IDM_ABOUT+) (messagebox hwnd *txtedit-about-text* "About" (logior *MB_OK* *MB_ICONINFORMATION*))) ((= ctrl-ID +IDM_NEXTWINDOW+) (unless (>= (1+ *txtedit-current*) (length *txtedit-edit*)) (set-current-editor (1+ *txtedit-current*) hwnd))) ((= ctrl-ID +IDM_PREVWINDOW+) (unless (= *txtedit-current* 0) (set-current-editor (1- *txtedit-current*) hwnd))) ((= ctrl-ID +IDM_CLOSE+) (close-or-exit *txtedit-current* hwnd)) ((= ctrl-ID +IDM_MATCH_PAREN+) (let ((hnd (txtedit-handle (current-editor)))) (multiple-value-bind (curPos matchPos) (scintilla-get-matching-braces hnd) (when (and curPos (>= matchPos 0)) (sendmessage hnd 2025 (1+ matchPos) 0))))) ((= ctrl-ID +IDM_FIND+) (let* ((fr (allocate-foreign-object 'FINDREPLACE)) (str (make-string 1024 :initial-element #\Null))) (zeromemory fr (size-of-foreign-type 'FINDREPLACE)) (setf (get-slot-value fr 'FINDREPLACE 'lStructSize) (size-of-foreign-type 'FINDREPLACE)) (setf (get-slot-value fr 'FINDREPLACE 'hwndOwner) hwnd) (setf (get-slot-value fr 'FINDREPLACE 'lpstrFindWhat) str) (setf (get-slot-value fr 'FINDREPLACE 'wFindWhatLen) 1024) (setf (get-slot-value fr 'FINDREPLACE 'Flags) *FR_DOWN*) (setq *txtedit-dlg-handle* (findtext fr)))) ((<= +IDM_WINDOW_FIRST+ ctrl-ID +IDM_WINDOW_LAST+) (set-current-editor (- ctrl-ID +IDM_WINDOW_FIRST+) hwnd) 0) (t ))) 0) ((= uMsg (1+ *WM_USER*)) (print "Open file request received") (let ((fname (pop *txtedit-files*))) (when fname (create-editor hwnd) (read-file fname hwnd))) 0) ((= uMsg *txtedit-findreplace-msg*) (with-cast-int-pointer (lparam FINDREPLACE) (let ((flags (get-slot-value lparam 'FINDREPLACE 'Flags)) (hnd (txtedit-handle (current-editor)))) (cond ((/= 0 (logand flags *FR_DIALOGTERM*)) (free-foreign-object lparam) (setq *txtedit-dlg-handle* *NULL*)) ((/= 0 (logand flags *FR_FINDNEXT*)) (let ((str (get-slot-value lparam 'FINDREPLACE 'lpstrFindWhat)) pos (down (/= (logand flags *FR_DOWN*) 0))) (cond ((= *txtedit-edit-class* 2) (let ((selStart (sendmessage hnd 2143 0 0)) (selEnd (sendmessage hnd 2145 0 0))) (sendmessage hnd 2025 (if down selEnd selStart) 0) (sendmessage hnd 2366 0 0) (with-foreign-string (s str) (if (/= (setq pos (sendmessage hnd (if down 2367 2368) 0 (make-lparam s))) -1) (sendmessage hnd 2169 0 0) (progn (messagebox *txtedit-dlg-handle* "Finished searching the document" "Find" (logior *MB_OK* *MB_ICONINFORMATION*)) (sendmessage hnd 2160 selStart selEnd)))))) ))) ))) 0) (t (defwindowproc hwnd umsg wparam lparam)) )) (defun txtedit-class-name () (case *txtedit-edit-class* (0 "EDIT") (1 *RICHEDIT_CLASS*) (2 "Scintilla"))) (defun register-txtedit-class () (unless *txtedit-class-registered* (case *txtedit-edit-class* (-1 (or (and (not (null-pointer-p (loadlibrary "SciLexer.dll"))) (setq *txtedit-edit-class* 2)) (and (not (null-pointer-p (loadlibrary "riched20.dll"))) (setq *txtedit-edit-class* 1)) (setq *txtedit-edit-class* 0))) (1 (and (null-pointer-p (loadlibrary "riched20.dll")) (error "Cannot load WIN32 library: riched20.dll"))) (2 (and (null-pointer-p (loadlibrary "SciLexer.dll")) (error "Cannot load WIN32 library: SciLexer.dll")))) (make-wndclass "SimpleTextEditor" :lpfnWndProc #'txtedit-proc) (setq *txtedit-class-registered* t))) (defun unregister-txtedit-class () (when *txtedit-class-registered* (unregisterclass "SimpleTextEditor" *NULL*) (case *txtedit-edit-class* (1 (freelibrary (getmodulehandle "riched20.dll"))) (2 (freelibrary (getmodulehandle "SciLexer.dll")))) (setq *txtedit-class-registered* nil))) (defun txtedit (&optional fname &key (class -1) &aux (*txtedit-edit-class* class)) (register-txtedit-class) (let* ((fname-str (if fname (convert-to-foreign-string (coerce fname 'simple-string)) *NULL*)) (w (createwindow "SimpleTextEditor" *txtedit-default-title* (logior *WS_OVERLAPPEDWINDOW*) *CW_USEDEFAULT* *CW_USEDEFAULT* *txtedit-width* *txtedit-height* *NULL* (create-menus) *NULL* fname-str)) (accTable (create-accels))) (setq *txtedit-handle* w) (showwindow w *SW_SHOWNORMAL*) (updatewindow w) (event-loop :accelTable accTable :accelMain w :dlgSym '*txtedit-dlg-handle*) (setq *txtedit-edit* nil) (setq *txtedit-process* nil) (setq *txtedit-handle* *NULL*) (destroyacceleratortable accTable) (unless (null-pointer-p fname-str) (free-foreign-object fname-str)) (unregister-txtedit-class) nil)) (defun edit (&optional fname &key (class -1) (detach-p (member :threads *features*))) (if (or detach-p *txtedit-process*) (if (member :threads *features*) (if *txtedit-process* (progn (push fname *txtedit-files*) (postmessage *txtedit-handle* (1+ *WM_USER*) 0 0)) #+:threads (setq *txtedit-process* (mp:process-run-function "Text Editor" (lambda () (txtedit fname :class class))))) (error "No multi-threading environment detected.")) (txtedit fname :class class))) ecl-16.1.2/contrib/win32/win32.lisp000066400000000000000000001030101266352375300166100ustar00rootroot00000000000000;;; Copyright (c) 2005, Michael Goffioul (michael dot goffioul at swing dot be) ;;; ;;; This program is free software; you can redistribute it and/or ;;; modify it under the terms of the GNU Library General Public ;;; License as published by the Free Software Foundation; either ;;; version 2 of the License, or (at your option) any later version. ;;; ;;; See file '../../Copyright' for full details. ;;; ;;; FOREIGN FUNCTION INTERFACE TO MICROSOFT WINDOWS API ;;; (defpackage "WIN32" (:use "COMMON-LISP" "FFI") (:export)) (in-package "WIN32") (clines "#include " "#include " ) ;; Windows types (def-foreign-type HANDLE :pointer-void) (def-foreign-type LPCSTR :cstring) (def-foreign-type WNDPROC :pointer-void) (def-foreign-type DWORD :unsigned-int) (def-foreign-type WORD :unsigned-short) ;; Windows constants (defmacro define-win-constant (name value &optional (c-type :int)) `(defconstant ,name ,value)) (define-win-constant *TRUE* 1) (define-win-constant *FALSE* 0) (define-win-constant *WM_CLOSE* #x0010) (define-win-constant *WM_COMMAND* #x0111) (define-win-constant *WM_CONTEXTMENU* #x007b) (define-win-constant *WM_COPY* #x0301) (define-win-constant *WM_CREATE* #x0001) (define-win-constant *WM_CUT* #x0300) (define-win-constant *WM_DESTROY* #x0002) (define-win-constant *WM_GETFONT* #x0031) (define-win-constant *WM_GETMINMAXINFO* #x0024) (define-win-constant *WM_INITMENU* #x0116) (define-win-constant *WM_INITMENUPOPUP* #x0117) (define-win-constant *WM_NCPAINT* #x0085) (define-win-constant *WM_NOTIFY* #x004e) (define-win-constant *WM_PAINT* #x000f) (define-win-constant *WM_PASTE* #x0302) (define-win-constant *WM_QUIT* #x0012) (define-win-constant *WM_SETFOCUS* #x0007) (define-win-constant *WM_SETFONT* #x0030) (define-win-constant *WM_SIZE* #x0005) (define-win-constant *WM_UNDO* #x0304) (define-win-constant *WM_USER* #x0400) (define-win-constant *WS_BORDER* #x00800000) (define-win-constant *WS_CHILD* #x40000000) (define-win-constant *WS_CLIPCHILDREN* #x02000000) (define-win-constant *WS_CLIPSIBLINGS* #x04000000) (define-win-constant *WS_DLGFRAME* #x00400000) (define-win-constant *WS_DISABLED* #x08000000) (define-win-constant *WS_HSCROLL* #x00100000) (define-win-constant *WS_OVERLAPPEDWINDOW* #x00CF0000) (define-win-constant *WS_VISIBLE* #x10000000) (define-win-constant *WS_VSCROLL* #x00200000) (define-win-constant *WS_EX_CLIENTEDGE* #x00000200) (define-win-constant *RICHEDIT_CLASS* "RichEdit20A") (define-win-constant *WC_LISTVIEW* "SysListView32") (define-win-constant *WC_TABCONTROL* "SysTabControl32") (define-win-constant *HWND_BOTTOM* (make-pointer 1 'HANDLE)) (define-win-constant *HWND_NOTOPMOST* (make-pointer -2 'HANDLE)) (define-win-constant *HWND_TOP* (make-pointer 0 'HANDLE)) (define-win-constant *HWND_TOPMOST* (make-pointer -1 'HANDLE)) (define-win-constant *SWP_DRAWFRAME* #x0020) (define-win-constant *SWP_HIDEWINDOW* #x0080) (define-win-constant *SWP_NOMOVE* #x0002) (define-win-constant *SWP_NOOWNERZORDER* #x0200) (define-win-constant *SWP_NOREDRAW* #x0008) (define-win-constant *SWP_NOREPOSITION* #x0200) (define-win-constant *SWP_NOSIZE* #x0001) (define-win-constant *SWP_NOZORDER* #x0004) (define-win-constant *SWP_SHOWWINDOW* #x0040) (define-win-constant *BS_DEFPUSHBUTTON* #x00000000) (define-win-constant *BS_PUSHBUTTON* #x00000001) (define-win-constant *BN_CLICKED* 0) (define-win-constant *ES_AUTOHSCROLL* #x0080) (define-win-constant *ES_AUTOVSCROLL* #x0040) (define-win-constant *ES_LEFT* #x0000) (define-win-constant *ES_MULTILINE* #x0004) (define-win-constant *EM_CANUNDO* #x00c6) (define-win-constant *EM_SETEVENTMASK* (+ *WM_USER* 69)) (define-win-constant *EM_SETSEL* #x00b1) (define-win-constant *EM_UNDO* #x00c7) (define-win-constant *EN_CHANGE* #x0300) (define-win-constant *ENM_CHANGE* #x00000001) (define-win-constant *TCIF_IMAGE* #x0002) (define-win-constant *TCIF_PARAM* #x0008) (define-win-constant *TCIF_RTLREADING* #x0004) (define-win-constant *TCIF_STATE* #x0010) (define-win-constant *TCIF_TEXT* #x0001) (define-win-constant *TCHT_NOWHERE* #x0001) (define-win-constant *TCHT_ONITEM* #x0006) (define-win-constant *TCHT_ONITEMICON* #x0002) (define-win-constant *TCHT_ONITEMLABEL* #x0004) (define-win-constant *TCM_FIRST* #x1300) (define-win-constant *TCN_FIRST* #xfffffdda) (define-win-constant *TCM_ADJUSTRECT* (+ *TCM_FIRST* 40)) (define-win-constant *TCM_DELETEITEM* (+ *TCM_FIRST* 8)) (define-win-constant *TCM_GETCURSEL* (+ *TCM_FIRST* 11)) (define-win-constant *TCM_HITTEST* (+ *TCM_FIRST* 13)) (define-win-constant *TCM_INSERTITEM* (+ *TCM_FIRST* 7)) (define-win-constant *TCM_SETCURSEL* (+ *TCM_FIRST* 12)) (define-win-constant *TCM_SETITEM* (+ *TCM_FIRST* 6)) (define-win-constant *TCN_SELCHANGE* (- *TCN_FIRST* 1)) (define-win-constant *NM_FIRST* #x100000000) (define-win-constant *NM_CLICK* (- *NM_FIRST* 1)) (define-win-constant *NM_RCLICK* (- *NM_FIRST* 5)) (define-win-constant *SW_HIDE* 0) (define-win-constant *SW_SHOW* 5) (define-win-constant *SW_SHOWNORMAL* 1) (define-win-constant *RDW_ERASE* #x0004) (define-win-constant *RDW_FRAME* #x0400) (define-win-constant *RDW_INTERNALPAINT* #x0002) (define-win-constant *RDW_INVALIDATE* #x0001) (define-win-constant *RDW_NOERASE* #x0020) (define-win-constant *RDW_NOFRAME* #x0800) (define-win-constant *RDW_NOINTERNALPAINT* #x0010) (define-win-constant *RDW_VALIDATE* #x0008) (define-win-constant *RDW_ERASENOW* #x0200) (define-win-constant *RDW_UPDATENOW* #x0100) (define-win-constant *RDW_ALLCHILDREN* #x0080) (define-win-constant *RDW_NOCHILDREN* #x0040) (define-win-constant *CW_USEDEFAULT* (- #x80000000)) (define-win-constant *IDC_ARROW* 32512) (define-win-constant *IDI_APPLICATION* 32512) (define-win-constant *COLOR_BACKGROUND* 1) (define-win-constant *DEFAULT_GUI_FONT* 17) (define-win-constant *OEM_FIXED_FONT* 10) (define-win-constant *SYSTEM_FONT* 13) (define-win-constant *SYSTEM_FIXED_FONT* 16) (define-win-constant *MB_HELP* #x00004000) (define-win-constant *MB_OK* #x00000000) (define-win-constant *MB_OKCANCEL* #x00000001) (define-win-constant *MB_YESNO* #x00000004) (define-win-constant *MB_YESNOCANCEL* #x00000003) (define-win-constant *MB_ICONEXCLAMATION* #x00000030) (define-win-constant *MB_ICONWARNING* #x00000020) (define-win-constant *MB_ICONERROR* #x00000010) (define-win-constant *MB_ICONINFORMATION* #x00000040) (define-win-constant *MB_ICONQUESTION* #x00000020) (define-win-constant *IDCANCEL* 2) (define-win-constant *IDNO* 7) (define-win-constant *IDOK* 1) (define-win-constant *IDYES* 6) (define-win-constant *MF_BYCOMMAND* #x00000000) (define-win-constant *MF_BYPOSITION* #x00000400) (define-win-constant *MF_CHECKED* #x00000008) (define-win-constant *MF_DISABLED* #x00000002) (define-win-constant *MF_ENABLED* #x00000000) (define-win-constant *MF_GRAYED* #x00000001) (define-win-constant *MF_MENUBREAK* #x00000040) (define-win-constant *MF_POPUP* #x00000010) (define-win-constant *MF_SEPARATOR* #x00000800) (define-win-constant *MF_STRING* #x00000000) (define-win-constant *MF_UNCHECKED* #x00000000) (define-win-constant *TPM_CENTERALIGN* #x0004) (define-win-constant *TPM_LEFTALIGN* #x0000) (define-win-constant *TPM_RIGHTALIGN* #x0008) (define-win-constant *TPM_BOTTOMALIGN* #x0020) (define-win-constant *TPM_TOPALIGN* #x0000) (define-win-constant *TPM_VCENTERALIGN* #x0010) (define-win-constant *TPM_NONOTIFY* #x0080) (define-win-constant *TPM_RETURNCMD* #x0100) (define-win-constant *TPM_LEFTBUTTON* #x0000) (define-win-constant *TPM_RIGHTBUTTON* #x0002) (define-win-constant *OFN_FILEMUSTEXIST* #x00001000) (define-win-constant *OFN_OVERWRITEPROMPT* #x00000002) (define-win-constant *OFN_PATHMUSTEXIST* #x00000800) (define-win-constant *OFN_READONLY* #x00000001) (define-win-constant *FVIRTKEY* *TRUE*) (define-win-constant *FNOINVERT* #x02) (define-win-constant *FSHIFT* #x04) (define-win-constant *FCONTROL* #x08) (define-win-constant *FALT* #x10) (define-win-constant *VK_F1* #x70) (define-win-constant *VK_LEFT* #x25) (define-win-constant *VK_RIGHT* #x27) (define-win-constant *GWL_EXSTYLE* -20) (define-win-constant *GWL_HINSTANCE* -6) (define-win-constant *GWL_HWNDPARENT* -8) (define-win-constant *GWL_ID* -12) (define-win-constant *GWL_STYLE* -16) (define-win-constant *GWL_WNDPROC* -4) (define-win-constant *FINDMSGSTRING* "commdlg_FindReplace") (define-win-constant *HELPMSGSTRING* "commdlg_help") (define-win-constant *FR_DIALOGTERM* #x00000040) (define-win-constant *FR_DOWN* #x00000001) (define-win-constant *FR_FINDNEXT* #x00000008) (define-win-constant *FR_HIDEUPDOWN* #x00004000) (define-win-constant *FR_HIDEMATCHCASE* #x00008000) (define-win-constant *FR_HIDEWHOLEWORD* #x00010000) (define-win-constant *FR_MATCHCASE* #x00000004) (define-win-constant *FR_NOMATCHCASE* #x00000800) (define-win-constant *FR_NOUPDOWN* #x00000400) (define-win-constant *FR_NOWHOLEWORD* #x00001000) (define-win-constant *FR_REPLACE* #x00000010) (define-win-constant *FR_REPLACEALL* #x00000020) (define-win-constant *FR_SHOWHELP* #x00000080) (define-win-constant *FR_WHOLEWORD* #x00000002) (defconstant *NULL* (make-null-pointer :void)) ;; Windows structures (def-struct WNDCLASS (style :unsigned-int) (lpfnWndProc WNDPROC) (cbClsExtra :int) (cbWndExtra :int) (hInstance HANDLE) (hIcon HANDLE) (hCursor HANDLE) (hbrBackground HANDLE) (lpszMenuName :cstring) (lpszClassName :cstring)) (defun make-wndclass (name &key (style 0) (lpfnWndProc nil) (cbClsExtra 0) (cbWndExtra 0) (hInstance *NULL*) (hIcon (default-icon)) (hCursor (default-cursor)) (hbrBackground (default-background)) (lpszMenuName "")) (with-foreign-object (cls 'WNDCLASS) (setf (get-slot-value cls 'WNDCLASS 'style) style (get-slot-value cls 'WNDCLASS 'lpfnWndProc) (callback 'wndproc-proxy) (get-slot-value cls 'WNDCLASS 'cbClsExtra) cbClsExtra (get-slot-value cls 'WNDCLASS 'cbWndExtra) cbWndExtra (get-slot-value cls 'WNDCLASS 'hInstance) hInstance (get-slot-value cls 'WNDCLASS 'hIcon) hIcon (get-slot-value cls 'WNDCLASS 'hCursor) hCursor (get-slot-value cls 'WNDCLASS 'hbrBackground) hbrBackground (get-slot-value cls 'WNDCLASS 'lpszMenuName) lpszMenuName (get-slot-value cls 'WNDCLASS 'lpszClassName) (string name)) (register-wndproc (string name) lpfnWndProc) (registerclass cls))) (def-struct POINT (x :int) (y :int)) (def-struct MSG (hwnd HANDLE) (message :unsigned-int) (wParam :unsigned-int) (lParam :int) (time :unsigned-int) (pt POINT)) (def-struct CREATESTRUCT (lpCreateParams :pointer-void) (hInstance HANDLE) (hMenu HANDLE) (hwndParent HANDLE) (cx :int) (cy :int) (x :int) (y :int) (style :long) (lpszName :cstring) (lpszClass :cstring) (dwExStyle :unsigned-int)) (def-struct MINMAXINFO (ptReserved POINT) (ptMaxSize POINT) (ptMaxPosition POINT) (ptMinTrackSize POINT) (ptMaxTrackSize POINT)) (def-struct TEXTMETRIC (tmHeight :long) (tmAscent :long) (tmDescent :long) (tmInternalLeading :long) (tmExternalLeading :long) (tmAveCharWidth :long) (tmMaxCharWidth :long) (tmWeight :long) (tmOverhang :long) (tmDigitizedAspectX :long) (tmDigitizedAspectY :long) (tmFirstChar :char) (tmLastChar :char) (tmDefaultChar :char) (tmBreakChar :char) (tmItalic :byte) (tmUnderlined :byte) (tmStruckOut :byte) (tmPitchAndFamily :byte) (tmCharSet :byte)) (def-struct SIZE (cx :long) (cy :long)) (def-struct RECT (left :long) (top :long) (right :long) (bottom :long)) (def-struct TITLEBARINFO (cbSize :unsigned-int) (rcTitlebar RECT) (rgstate (:array :unsigned-int 6))) (def-struct OPENFILENAME (lStructSize :unsigned-int) (hwndOwner HANDLE) (hInstance HANDLE) (lpstrFilter LPCSTR) (lpstrCustomFilter LPCSTR) (nMaxFilter :unsigned-int) (nFilterIndex :unsigned-int) (lpstrFile LPCSTR) (nMaxFile :unsigned-int) (lpstrFileTitle LPCSTR) (nMaxFileTitle :unsigned-int) (lpstrInitialDir LPCSTR) (lpstrTitle LPCSTR) (Flags :unsigned-int) (nFileOffset :unsigned-short) (nFileExtension :unsigned-short) (lpstrDefExt LPCSTR) (lCustData :int) (lpfnHook HANDLE) (lpTemplateName LPCSTR) #|(pvReserved :pointer-void) (dwReserved :unsigned-int) (FlagsEx :unsigned-int)|#) (def-struct ACCEL (fVirt :byte) (key :unsigned-short) (cmd :unsigned-short)) (def-struct TCITEM (mask :unsigned-int) (dwState :unsigned-int) (dwStateMask :unsigned-int) (pszText :cstring) (cchTextMax :int) (iImage :int) (lParam :long)) (def-struct NMHDR (hwndFrom HANDLE) (idFrom :unsigned-int) (code :unsigned-int)) (def-struct TCHITTESTINFO (pt POINT) (flag :unsigned-int)) (def-struct TPMPARAMS (cbSize :unsigned-int) (rcExclude RECT)) (def-struct FINDREPLACE (lStructSize :unsigned-int) (hwndOwner HANDLE) (hInstance HANDLE) (Flags DWORD) (lpstrFindWhat LPCSTR) (lpstrReplaceWith LPCSTR) (wFindWhatLen WORD) (wReplaceWithLen WORD) (lpCustData :int) (lpfnHook HANDLE) (lpTemplateName LPCSTR)) ;; Windows functions (defvar *wndproc-db* nil) (defun register-wndproc (class-or-obj wndproc) (let ((entry (assoc class-or-obj *wndproc-db* :test #'equal))) (if entry (rplacd entry wndproc) (push (cons class-or-obj wndproc) *wndproc-db*))) (unless (stringp class-or-obj) (let ((old-proc (make-pointer (getwindowlong class-or-obj *GWL_WNDPROC*) 'HANDLE))) (setwindowlong class-or-obj *GWL_WNDPROC* (make-lparam (callback 'wndproc-proxy))) old-proc))) (defun get-wndproc (obj) (let ((entry (or (assoc obj *wndproc-db* :test #'equal) (assoc (getclassname obj) *wndproc-db* :test #'equal)))) (and entry (cdr entry)))) (defcallback (wndproc-proxy :stdcall) :int ((hnd :pointer-void) (umsg :unsigned-int) (wparam :unsigned-int) (lparam :int)) (let* ((wndproc (get-wndproc hnd))) (unless wndproc (error "Cannot find a registered Windows prodecure for object ~S" hnd)) (funcall wndproc hnd umsg wparam lparam))) (defun make-ID (id) (make-pointer id :pointer-void)) (setf (symbol-function 'make-handle) #'make-ID) (defun make-wparam (hnd) (pointer-address hnd)) (defun make-lparam (hnd) (pointer-address hnd)) (defmacro with-cast-int-pointer ((var type &optional ptr) &body body) (unless ptr (setq ptr var)) `(let ((,var (make-pointer ,ptr ',type))) ,@body)) (defmacro def-win32-function (name args &key (returning :void) module) `(def-function ,name ,args :returning ,returning :module ,module :call :stdcall)) (eval-when (:compile-toplevel) (define-compiler-macro def-win32-function (name args &key (returning :void) module) `(def-function ,name ,args :returning ,returning))) (load-foreign-library "kernel32") (load-foreign-library "comdlg32") (load-foreign-library "gdi32") (load-foreign-library "comctl32") (def-win32-function ("RtlZeroMemory" zeromemory) ((Destination :pointer-void) (Length :unsigned-int)) :returning :void :module "kernel32") (def-win32-function ("LoadLibraryA" loadlibrary) ((lpLibFileName LPCSTR)) :returning HANDLE :module "kernel32") (def-win32-function ("FreeLibrary" freelibrary) ((hLibModule HANDLE)) :returning :int :module "kernel32") (def-win32-function ("GetModuleHandleA" getmodulehandle) ((lpModuleName LPCSTR)) :returning HANDLE :module "kernel32") (def-win32-function ("GetStockObject" getstockobject) ((fnObject :int)) :returning HANDLE :module "gdi32") (def-win32-function ("GetTextMetricsA" gettextmetrics) ((hdc HANDLE) (lptm (* TEXTMETRIC))) :returning :int :module "gdi32") (def-win32-function ("GetDC" getdc) ((hWnd HANDLE)) :returning HANDLE :module "user32") (def-win32-function ("ReleaseDC" releasedc) ((hWnd HANDLE) (hdc HANDLE)) :returning :int :module "user32") (def-win32-function ("SelectObject" selectobject) ((hdc HANDLE) (hgdiobj HANDLE)) :returning HANDLE :module "gdi32") (def-win32-function ("GetTextExtentPoint32A" gettextextentpoint32) ((hdc HANDLE) (lpString :cstring) (cbString :int) (lpSize (* SIZE))) :returning :int :module "gdi32") (def-win32-function ("LoadCursorA" loadcursor-string) ((hnd HANDLE) (lpCursorName LPCSTR)) :returning HANDLE :module "user32") (def-win32-function ("LoadCursorA" loadcursor-int) ((hnd HANDLE) (lpCursorName :unsigned-int)) :returning HANDLE :module "user32") (defun loadcursor (hnd cur-name) (etypecase cur-name (fixnum (loadcursor-int hnd cur-name)) (string (loadcursor-string hnd cur-name)))) (defun default-cursor () (loadcursor *NULL* *IDC_ARROW*)) (def-win32-function ("LoadIconA" loadicon-int) ((hnd HANDLE) (lpIconName :unsigned-int)) :returning HANDLE :module "user32") (def-win32-function ("LoadIconA" loadicon-string) ((hnd HANDLE) (lpIconName LPCSTR)) :returning HANDLE :module "user32") (defun loadicon (hnd cur-name) (etypecase cur-name (fixnum (loadicon-int hnd cur-name)) (string (loadicon-string hnd cur-name)))) (defun default-icon () (loadicon *NULL* *IDI_APPLICATION*)) (defun default-background () (getstockobject *COLOR_BACKGROUND*)) (def-win32-function ("GetLastError" getlasterror) () :returning :unsigned-int :module "kernel32") (def-win32-function ("GetClassNameA" getclassname-i) ((hnd HANDLE) (lpClassName (* :char)) (maxCount :int)) :returning :int :module "user32") (defun getclassname (hnd &aux (max-length 64)) (with-foreign-object (s `(:array :char ,max-length)) (let ((n (getclassname-i hnd s max-length))) (when (= n 0) (error "Unable to get class name for ~A" hnd)) (convert-from-foreign-string s :length n)))) (def-win32-function ("RegisterClassA" registerclass) ((lpWndClass (* WNDCLASS))) :returning :int :module "user32") (def-win32-function ("UnregisterClassA" unregisterclass) ((lpClassName :cstring) (hInstance HANDLE)) :returning :int :module "user32") (def-win32-function ("GetWindowLongA" getwindowlong) ((hWnd HANDLE) (nIndex :int)) :returning :long :module "user32") (def-win32-function ("SetWindowLongA" setwindowlong) ((hWnd HANDLE) (nIndex :int) (dwNewLong :long)) :returning :long :module "user32") (def-win32-function ("CreateWindowExA" createwindowex) ((dwExStyle :unsigned-int) (lpClassName :cstring) (lpWindowName :cstring) (dwStyle :unsigned-int) (x :int) (y :int) (nWidth :int) (nHeight :int) (hWndParent HANDLE) (hMenu HANDLE) (hInstance HANDLE) (lpParam :pointer-void)) :returning HANDLE :module "user32") (defun createwindow (&rest args) (apply #'createwindowex 0 args)) (def-win32-function ("DestroyWindow" destroywindow) ((hWnd HANDLE)) :returning :int :module "user32") (def-win32-function ("ShowWindow" showwindow) ((hWnd HANDLE) (nCmdShow :int)) :returning :int :module "user32") (def-win32-function ("UpdateWindow" updatewindow) ((hWnd HANDLE)) :returning :void :module "user32") (def-win32-function ("RedrawWindow" redrawwindow) ((hWnd HANDLE) (lprcUpdate (* RECT)) (hrgnUpdate HANDLE) (flags :unsigned-int)) :returning :int :module "user32") (def-win32-function ("MoveWindow" movewindow) ((hWnd HANDLE) (x :int) (y :int) (nWidth :int) (nHeight :int) (bRepaint :int)) :returning :int :module "user32") (def-win32-function ("SetWindowPos" setwindowpos) ((hWnd HANDLE) (hWndInsertAfter HANDLE) (x :int) (y :int) (cx :int) (cy :int) (uFlags :unsigned-int)) :returning :int :module "user32") (def-win32-function ("BringWindowToTop" bringwindowtotop) ((hWnd HANDLE)) :returning :int :module "user32") (def-win32-function ("GetWindowTextA" getwindowtext-i) ((hWnd HANDLE) (lpString LPCSTR) (nMaxCount :int)) :returning :int :module "user32") (defun getwindowtext (hnd) (let ((len (1+ (getwindowtextlength hnd)))) (with-cstring (s (make-string len)) (getwindowtext-i hnd s len) (subseq s 0 (1- len))))) (def-win32-function ("GetWindowTextLengthA" getwindowtextlength) ((hWnd HANDLE)) :returning :int :module "user32") (def-win32-function ("SetWindowTextA" setwindowtext) ((hWnd HANDLE) (lpString LPCSTR)) :returning :int :module "user32") (def-win32-function ("GetParent" getparent) ((hWnd HANDLE)) :returning HANDLE :module "user32") (def-win32-function ("GetClientRect" getclientrect) ((hWnd HANDLE) (lpRect (* RECT))) :returning :int :module "user32") (def-win32-function ("GetWindowRect" getwindowrect) ((hWnd HANDLE) (lpRect (* RECT))) :returning :int :module "user32") (def-win32-function ("InvalidateRect" invalidaterect) ((hWnd HANDLE) (lpRect (* RECT)) (bErase :int)) :returning :int :module "user32") (def-win32-function ("SetRect" setrect) ((lpRect (* RECT)) (xLeft :int) (yTop :int) (xRight :int) (yBottom :int)) :returning :int :module "user32") ;(def-win32-function ("GetTitleBarInfo" gettitlebarinfo) ((hWnd HANDLE) (pti (* TITLEBARINFO))) :returning :int) (def-win32-function ("SetFocus" setfocus) ((hWnd HANDLE)) :returning HANDLE :module "user32") (def-win32-function ("PostQuitMessage" postquitmessage) ((nExitCode :int)) :returning :void :module "user32") (def-win32-function ("SendMessageA" sendmessage) ((hWnd HANDLE) (uMsg :unsigned-int) (wParam :unsigned-int) (lParam :int)) :returning :int :module "user32") (def-win32-function ("PostMessageA" postmessage) ((hWnd HANDLE) (uMsg :unsigned-int) (wParam :unsigned-int) (lParam :int)) :returning :int :module "user32") (def-win32-function ("RegisterWindowMessageA" registerwindowmessage) ((lpString LPCSTR)) :returning :unsigned-int :module "user32") (def-win32-function ("IsDialogMessageA" isdialogmessage) ((hDlg HANDLE) (lpMsg (* MSG))) :returning :int :module "user32") (def-win32-function ("DefWindowProcA" defwindowproc) ((hWnd HANDLE) (uMsg :unsigned-int) (wParam :unsigned-int) (lParam :int)) :returning :int :module "user32") (def-win32-function ("CallWindowProcA" callwindowproc) ((wndProc HANDLE) (hWnd HANDLE) (uMsg :unsigned-int) (wParam :unsigned-int) (lParam :int)) :returning :int :module "user32") (defun loword (x) (logand x #xffff)) (defun hiword (x) (logand (floor x 65536) #xffff)) (defun get-x-lparam (x) (loword x)) (defun get-y-lparam (x) (hiword x)) (def-win32-function ("ScreenToClient" screentoclient) ((hWnd HANDLE) (pt (* POINT))) :returning :int :module "user32") (def-win32-function ("MessageBoxA" messagebox) ((hWnd HANDLE) (lpText LPCSTR) (lpCaption LPCSTR) (uType :unsigned-int)) :returning :int :module "user32") (def-win32-function ("GetOpenFileNameA" getopenfilename) ((lpofn (* OPENFILENAME))) :returning :int :module "comdlg32") (def-win32-function ("GetSaveFileNameA" getsavefilename) ((lpofn (* OPENFILENAME))) :returning :int :module "comdlg32") (def-win32-function ("FindTextA" findtext) ((lpfr (* FINDREPLACE))) :returning HANDLE :module "comdlg32") (def-win32-function ("ReplaceTextA" replacetext) ((lpfr (* FINDREPLACE))) :returning HANDLE :module "comdlg32") (def-win32-function ("GetMessageA" getmessage) ((lpMsg (* MSG)) (hWnd HANDLE) (wMsgFitlerMin :unsigned-int) (wMsgFilterMax :unsigned-int)) :returning :int :module "user32") (def-win32-function ("TranslateMessage" translatemessage) ((lpMsg (* MSG))) :returning :int :module "user32") (def-win32-function ("DispatchMessageA" dispatchmessage) ((lpMsg (* MSG))) :returning :int :module "user32") (def-win32-function ("CreateMenu" createmenu) nil :returning HANDLE :module "user32") (def-win32-function ("CreatePopupMenu" createpopupmenu) nil :returning HANDLE :module "user32") (def-win32-function ("DestroyMenu" destroymenu) ((hMenu HANDLE)) :returning :int :module "user32") (def-win32-function ("AppendMenuA" appendmenu) ((hMenu HANDLE) (uFlags :unsigned-int) (uIDNewItem :unsigned-int) (lpNewItem LPCSTR)) :returning :int :module "user32") (def-win32-function ("GetSubMenu" getsubmenu) ((hMenu HANDLE) (nPos :int)) :returning HANDLE :module "user32") (def-win32-function ("DeleteMenu" deletemenu) ((hMenu HANDLE) (uPosition :unsigned-int) (uFlags :unsigned-int)) :returning :int :module "user32") (def-win32-function ("RemoveMenu" removemenu) ((hMenu HANDLE) (uPosition :unsigned-int) (uFlags :unsigned-int)) :returning :int :module "user32") (def-win32-function ("GetMenuItemCount" getmenuitemcount) ((hMenu HANDLE)) :returning :int :module "user32") (def-win32-function ("CheckMenuItem" checkmenuitem) ((hMenu HANDLE) (uIDCheckItem :unsigned-int) (uCheck :unsigned-int)) :returning :int :module "user32") (def-win32-function ("EnableMenuItem" enablemenuitem) ((hMenu HANDLE) (uIDCheckItem :unsigned-int) (uCheck :unsigned-int)) :returning :int :module "user32") (def-win32-function ("TrackPopupMenu" trackpopupmenu) ((hMenu HANDLE) (uFlags :unsigned-int) (x :int) (y :int) (nReserved :int) (hWnd HANDLE) (prcRect HANDLE)) :returning :int :module "user32") (def-win32-function ("TrackPopupMenuEx" trackpopupmenuex) ((hMenu HANDLE) (fuFlags :unsigned-int) (x :int) (y :int) (hWnd HANDLE) (lptpl (* TPMPARAMS))) :returning :int :module "user32") (def-win32-function ("CreateAcceleratorTableA" createacceleratortable) ((lpaccl (* ACCEL)) (cEntries :int)) :returning HANDLE :module "user32") (def-win32-function ("TranslateAcceleratorA" translateaccelerator) ((hWnd HANDLE) (hAccTable HANDLE) (lpMsg (* MSG))) :returning :int :module "user32") (def-win32-function ("DestroyAcceleratorTable" destroyacceleratortable) ((hAccTable HANDLE)) :returning :int :module "user32") (def-win32-function ("InitCommonControls" initcommoncontrols) () :returning :void :module "comctl32") (defun event-loop (&key (accelTable *NULL*) (accelMain *NULL*) (dlgSym nil)) (with-foreign-object (msg 'MSG) (loop for bRet = (getmessage msg *NULL* 0 0) when (= bRet 0) return bRet if (= bRet -1) do (error "GetMessage failed!!!") else do (or (and (not (null-pointer-p accelTable)) (not (null-pointer-p accelMain)) (/= (translateaccelerator accelMain accelTable msg) 0)) (and dlgSym (not (null-pointer-p (symbol-value dlgSym))) (/= (isdialogmessage (symbol-value dlgSym) msg) 0)) (progn (translatemessage msg) (dispatchmessage msg)))))) (defun y-or-no-p (&optional control &rest args) (let ((s (coerce (apply #'format nil control args) 'simple-string))) (= (messagebox *NULL* s "ECL Dialog" (logior *MB_YESNO* *MB_ICONQUESTION*)) *IDYES*))) (defun get-open-filename (&key (owner *NULL*) initial-dir filter (dlgfn #'getopenfilename) (flags 0) &aux (max-fn-size 1024)) (flet ((null-concat (x &optional y &aux (xx (if y x (car x))) (yy (if y y (cdr x)))) (concatenate 'string xx (string #\Null) yy))) (when filter (setq filter (format nil "~A~C~C" (reduce #'null-concat (mapcar #'null-concat filter)) #\Null #\Null))) (with-foreign-object (ofn 'OPENFILENAME) (with-cstrings ((fn (make-string max-fn-size :initial-element #\Null)) (filter filter)) (zeromemory ofn (size-of-foreign-type 'OPENFILENAME)) (setf (get-slot-value ofn 'OPENFILENAME 'lStructSize) (size-of-foreign-type 'OPENFILENAME)) (setf (get-slot-value ofn 'OPENFILENAME 'hwndOwner) owner) (setf (get-slot-value ofn 'OPENFILENAME 'lpstrFile) fn) (setf (get-slot-value ofn 'OPENFILENAME 'nMaxFile) max-fn-size) (setf (get-slot-value ofn 'OPENFILENAME 'Flags) flags) (when filter (setf (get-slot-value ofn 'OPENFILENAME 'lpstrFilter) filter)) (unless (= (funcall dlgfn ofn) 0) (pathname (string-trim (string #\Null) fn))))))) (defun find-text (&key (owner *NULL*) &aux (max-txt-size 1024)) (with-foreign-object (fr 'FINDREPLACE) (with-cstring (txt (make-string max-txt-size :initial-element #\Null)) (zeromemory fr (size-of-foreign-type 'FINDREPLACE)) (setf (get-slot-value fr 'FINDREPLACE 'lStructSize) (size-of-foreign-type 'FINDREPLACE)) (setf (get-slot-value fr 'FINDREPLACE 'hwndOwner) owner) (setf (get-slot-value fr 'FINDREPLACE 'wFindWhatLen) max-txt-size) ;(setf (get-slot-value fr 'FINDREPLACE 'Flags) 1) (let ((result (findtext fr))) (print result) txt)))) #| (defun set-wndproc (obj fun) (let ((cb (si:make-dynamic-callback fun (read-from-string (format nil "~A-WNDPROC" (gensym))) :int '(:pointer-void :unsigned-int :unsigned-int :int))) (old-wndproc (make-pointer (getwindowlong obj *GWL_WNDPROC*) 'HANDLE))) (setwindowlong obj *GWL_WNDPROC* (make-lparam cb)) old-wndproc)) |# (provide "WIN32") ;;; Test code (defconstant *HELLO_ID* 100) (defconstant *OK_ID* 101) (defparameter hBtn nil) (defparameter hOk nil) (defun button-min-size (hnd) (let ((fnt (make-pointer (sendmessage hnd *WM_GETFONT* 0 0) :pointer-void)) (hdc (getdc hnd)) (txt (getwindowtext hnd))) (unless (null-pointer-p fnt) (selectobject hdc fnt)) (with-foreign-objects ((sz 'SIZE) (tm 'TEXTMETRIC)) (gettextextentpoint32 hdc txt (length txt) sz) (gettextmetrics hdc tm) (releasedc hnd hdc) (list (+ (get-slot-value sz 'SIZE 'cx) 20) (+ (get-slot-value tm 'TEXTMETRIC 'tmHeight) 10))))) (defun get-titlebar-rect (hnd) (with-foreign-object (ti 'TITLEBARINFO) (setf (get-slot-value ti 'TITLEBARINFO 'cbSize) (size-of-foreign-type 'TITLEBARINFO)) (gettitlebarinfo hnd ti) (let ((rc (get-slot-value ti 'TITLEBARINFO 'rcTitlebar))) (list (get-slot-value rc 'RECT 'left) (get-slot-value rc 'RECT 'top) (get-slot-value rc 'RECT 'right) (get-slot-value rc 'RECT 'bottom))))) (defun test-wndproc (hwnd umsg wparam lparam) (cond ((= umsg *WM_DESTROY*) (setq hBtn nil hOk nil) (postquitmessage 0) 0) ((= umsg *WM_CREATE*) (setq hBtn (createwindowex 0 "BUTTON" "Hello World!" (logior *WS_VISIBLE* *WS_CHILD* *BS_PUSHBUTTON*) 0 0 50 20 hwnd (make-ID *HELLO_ID*) *NULL* *NULL*)) (setq hOk (createwindowex 0 "BUTTON" "Close" (logior *WS_VISIBLE* *WS_CHILD* *BS_PUSHBUTTON*) 0 0 50 20 hwnd (make-ID *OK_ID*) *NULL* *NULL*)) (sendmessage hBtn *WM_SETFONT* (make-wparam (getstockobject *DEFAULT_GUI_FONT*)) 0) (sendmessage hOk *WM_SETFONT* (make-wparam (getstockobject *DEFAULT_GUI_FONT*)) 0) 0) ((= umsg *WM_SIZE*) (let* ((new-w (loword lparam)) (new-h (hiword lparam)) (wb (- new-w 20)) (hb (/ (- new-h 30) 2))) (movewindow hBtn 10 10 wb hb *TRUE*) (movewindow hOk 10 (+ 20 hb) wb hb *TRUE*)) 0) ((= umsg *WM_GETMINMAXINFO*) (let* ((btn1-sz (and hBtn (button-min-size hBtn))) (btn2-sz (and hOk (button-min-size hOk))) #|(rc (get-titlebar-rect hWnd))|# (titleH #|(1+ (- (fourth rc) (second rc)))|# 30)) (when (and btn1-sz btn2-sz (> titleH 0)) (with-foreign-object (minSz 'POINT) (setf (get-slot-value minSz 'POINT 'x) (+ (max (first btn1-sz) (first btn2-sz)) 20)) (setf (get-slot-value minSz 'POINT 'y) (+ (second btn1-sz) (second btn2-sz) 30 titleH)) (with-cast-int-pointer (lparam MINMAXINFO) (setf (get-slot-value lparam 'MINMAXINFO 'ptMinTrackSize) minSz))))) 0) ((= umsg *WM_COMMAND*) (let ((n (hiword wparam)) (id (loword wparam))) (cond ((= n *BN_CLICKED*) (cond ((= id *HELLO_ID*) (format t "~&Hellow World!~%") (get-open-filename :owner hwnd)) ((= id *OK_ID*) (destroywindow hwnd)))) (t (format t "~&Un-handled notification: ~D~%" n)))) 0) (t (defwindowproc hwnd umsg wparam lparam)))) (defun do-test () (make-wndclass "MyClass" :lpfnWndProc #'test-wndproc) (let* ((hwnd (createwindowex 0 "MyClass" "ECL/Win32 test" *WS_OVERLAPPEDWINDOW* *CW_USEDEFAULT* *CW_USEDEFAULT* 130 120 *NULL* *NULL* *NULL* *NULL*))) (when (si::null-pointer-p hwnd) (error "Unable to create window")) (showwindow hwnd *SW_SHOWNORMAL*) (updatewindow hwnd) (event-loop) (unregisterclass "MyClass" *NULL*))) ecl-16.1.2/doc/000077500000000000000000000000001266352375300131255ustar00rootroot00000000000000ecl-16.1.2/doc/.gitignore000066400000000000000000000000201266352375300151050ustar00rootroot00000000000000ecl2.xml html/ ecl-16.1.2/doc/COPYING.GFDL000066400000000000000000000407601266352375300147020ustar00rootroot00000000000000 GNU Free Documentation License Version 1.1, March 2000 Copyright (C) 2000 Free Software Foundation, Inc. 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. 0. PREAMBLE The purpose of this License is to make a manual, textbook, or other written document "free" in the sense of freedom: to assure everyone the effective freedom to copy and redistribute it, with or without modifying it, either commercially or noncommercially. Secondarily, this License preserves for the author and publisher a way to get credit for their work, while not being considered responsible for modifications made by others. This License is a kind of "copyleft", which means that derivative works of the document must themselves be free in the same sense. It complements the GNU General Public License, which is a copyleft license designed for free software. We have designed this License in order to use it for manuals for free software, because free software needs free documentation: a free program should come with manuals providing the same freedoms that the software does. But this License is not limited to software manuals; it can be used for any textual work, regardless of subject matter or whether it is published as a printed book. We recommend this License principally for works whose purpose is instruction or reference. 1. APPLICABILITY AND DEFINITIONS This License applies to any manual or other work that contains a notice placed by the copyright holder saying it can be distributed under the terms of this License. The "Document", below, refers to any such manual or work. Any member of the public is a licensee, and is addressed as "you". A "Modified Version" of the Document means any work containing the Document or a portion of it, either copied verbatim, or with modifications and/or translated into another language. A "Secondary Section" is a named appendix or a front-matter section of the Document that deals exclusively with the relationship of the publishers or authors of the Document to the Document's overall subject (or to related matters) and contains nothing that could fall directly within that overall subject. (For example, if the Document is in part a textbook of mathematics, a Secondary Section may not explain any mathematics.) The relationship could be a matter of historical connection with the subject or with related matters, or of legal, commercial, philosophical, ethical or political position regarding them. The "Invariant Sections" are certain Secondary Sections whose titles are designated, as being those of Invariant Sections, in the notice that says that the Document is released under this License. The "Cover Texts" are certain short passages of text that are listed, as Front-Cover Texts or Back-Cover Texts, in the notice that says that the Document is released under this License. A "Transparent" copy of the Document means a machine-readable copy, represented in a format whose specification is available to the general public, whose contents can be viewed and edited directly and straightforwardly with generic text editors or (for images composed of pixels) generic paint programs or (for drawings) some widely available drawing editor, and that is suitable for input to text formatters or for automatic translation to a variety of formats suitable for input to text formatters. A copy made in an otherwise Transparent file format whose markup has been designed to thwart or discourage subsequent modification by readers is not Transparent. A copy that is not "Transparent" is called "Opaque". Examples of suitable formats for Transparent copies include plain ASCII without markup, Texinfo input format, LaTeX input format, SGML or XML using a publicly available DTD, and standard-conforming simple HTML designed for human modification. Opaque formats include PostScript, PDF, proprietary formats that can be read and edited only by proprietary word processors, SGML or XML for which the DTD and/or processing tools are not generally available, and the machine-generated HTML produced by some word processors for output purposes only. The "Title Page" means, for a printed book, the title page itself, plus such following pages as are needed to hold, legibly, the material this License requires to appear in the title page. For works in formats which do not have any title page as such, "Title Page" means the text near the most prominent appearance of the work's title, preceding the beginning of the body of the text. 2. VERBATIM COPYING You may copy and distribute the Document in any medium, either commercially or noncommercially, provided that this License, the copyright notices, and the license notice saying this License applies to the Document are reproduced in all copies, and that you add no other conditions whatsoever to those of this License. You may not use technical measures to obstruct or control the reading or further copying of the copies you make or distribute. However, you may accept compensation in exchange for copies. If you distribute a large enough number of copies you must also follow the conditions in section 3. You may also lend copies, under the same conditions stated above, and you may publicly display copies. 3. COPYING IN QUANTITY If you publish printed copies of the Document numbering more than 100, and the Document's license notice requires Cover Texts, you must enclose the copies in covers that carry, clearly and legibly, all these Cover Texts: Front-Cover Texts on the front cover, and Back-Cover Texts on the back cover. Both covers must also clearly and legibly identify you as the publisher of these copies. The front cover must present the full title with all words of the title equally prominent and visible. You may add other material on the covers in addition. Copying with changes limited to the covers, as long as they preserve the title of the Document and satisfy these conditions, can be treated as verbatim copying in other respects. If the required texts for either cover are too voluminous to fit legibly, you should put the first ones listed (as many as fit reasonably) on the actual cover, and continue the rest onto adjacent pages. If you publish or distribute Opaque copies of the Document numbering more than 100, you must either include a machine-readable Transparent copy along with each Opaque copy, or state in or with each Opaque copy a publicly-accessible computer-network location containing a complete Transparent copy of the Document, free of added material, which the general network-using public has access to download anonymously at no charge using public-standard network protocols. If you use the latter option, you must take reasonably prudent steps, when you begin distribution of Opaque copies in quantity, to ensure that this Transparent copy will remain thus accessible at the stated location until at least one year after the last time you distribute an Opaque copy (directly or through your agents or retailers) of that edition to the public. It is requested, but not required, that you contact the authors of the Document well before redistributing any large number of copies, to give them a chance to provide you with an updated version of the Document. 4. MODIFICATIONS You may copy and distribute a Modified Version of the Document under the conditions of sections 2 and 3 above, provided that you release the Modified Version under precisely this License, with the Modified Version filling the role of the Document, thus licensing distribution and modification of the Modified Version to whoever possesses a copy of it. In addition, you must do these things in the Modified Version: A. Use in the Title Page (and on the covers, if any) a title distinct from that of the Document, and from those of previous versions (which should, if there were any, be listed in the History section of the Document). You may use the same title as a previous version if the original publisher of that version gives permission. B. List on the Title Page, as authors, one or more persons or entities responsible for authorship of the modifications in the Modified Version, together with at least five of the principal authors of the Document (all of its principal authors, if it has less than five). C. State on the Title page the name of the publisher of the Modified Version, as the publisher. D. Preserve all the copyright notices of the Document. E. Add an appropriate copyright notice for your modifications adjacent to the other copyright notices. F. Include, immediately after the copyright notices, a license notice giving the public permission to use the Modified Version under the terms of this License, in the form shown in the Addendum below. G. Preserve in that license notice the full lists of Invariant Sections and required Cover Texts given in the Document's license notice. H. Include an unaltered copy of this License. I. Preserve the section entitled "History", and its title, and add to it an item stating at least the title, year, new authors, and publisher of the Modified Version as given on the Title Page. If there is no section entitled "History" in the Document, create one stating the title, year, authors, and publisher of the Document as given on its Title Page, then add an item describing the Modified Version as stated in the previous sentence. J. Preserve the network location, if any, given in the Document for public access to a Transparent copy of the Document, and likewise the network locations given in the Document for previous versions it was based on. These may be placed in the "History" section. You may omit a network location for a work that was published at least four years before the Document itself, or if the original publisher of the version it refers to gives permission. K. In any section entitled "Acknowledgements" or "Dedications", preserve the section's title, and preserve in the section all the substance and tone of each of the contributor acknowledgements and/or dedications given therein. L. Preserve all the Invariant Sections of the Document, unaltered in their text and in their titles. Section numbers or the equivalent are not considered part of the section titles. M. Delete any section entitled "Endorsements". Such a section may not be included in the Modified Version. N. Do not retitle any existing section as "Endorsements" or to conflict in title with any Invariant Section. If the Modified Version includes new front-matter sections or appendices that qualify as Secondary Sections and contain no material copied from the Document, you may at your option designate some or all of these sections as invariant. To do this, add their titles to the list of Invariant Sections in the Modified Version's license notice. These titles must be distinct from any other section titles. You may add a section entitled "Endorsements", provided it contains nothing but endorsements of your Modified Version by various parties--for example, statements of peer review or that the text has been approved by an organization as the authoritative definition of a standard. You may add a passage of up to five words as a Front-Cover Text, and a passage of up to 25 words as a Back-Cover Text, to the end of the list of Cover Texts in the Modified Version. Only one passage of Front-Cover Text and one of Back-Cover Text may be added by (or through arrangements made by) any one entity. If the Document already includes a cover text for the same cover, previously added by you or by arrangement made by the same entity you are acting on behalf of, you may not add another; but you may replace the old one, on explicit permission from the previous publisher that added the old one. The author(s) and publisher(s) of the Document do not by this License give permission to use their names for publicity for or to assert or imply endorsement of any Modified Version. 5. COMBINING DOCUMENTS You may combine the Document with other documents released under this License, under the terms defined in section 4 above for modified versions, provided that you include in the combination all of the Invariant Sections of all of the original documents, unmodified, and list them all as Invariant Sections of your combined work in its license notice. The combined work need only contain one copy of this License, and multiple identical Invariant Sections may be replaced with a single copy. If there are multiple Invariant Sections with the same name but different contents, make the title of each such section unique by adding at the end of it, in parentheses, the name of the original author or publisher of that section if known, or else a unique number. Make the same adjustment to the section titles in the list of Invariant Sections in the license notice of the combined work. In the combination, you must combine any sections entitled "History" in the various original documents, forming one section entitled "History"; likewise combine any sections entitled "Acknowledgements", and any sections entitled "Dedications". You must delete all sections entitled "Endorsements." 6. COLLECTIONS OF DOCUMENTS You may make a collection consisting of the Document and other documents released under this License, and replace the individual copies of this License in the various documents with a single copy that is included in the collection, provided that you follow the rules of this License for verbatim copying of each of the documents in all other respects. You may extract a single document from such a collection, and distribute it individually under this License, provided you insert a copy of this License into the extracted document, and follow this License in all other respects regarding verbatim copying of that document. 7. AGGREGATION WITH INDEPENDENT WORKS A compilation of the Document or its derivatives with other separate and independent documents or works, in or on a volume of a storage or distribution medium, does not as a whole count as a Modified Version of the Document, provided no compilation copyright is claimed for the compilation. Such a compilation is called an "aggregate", and this License does not apply to the other self-contained works thus compiled with the Document, on account of their being thus compiled, if they are not themselves derivative works of the Document. If the Cover Text requirement of section 3 is applicable to these copies of the Document, then if the Document is less than one quarter of the entire aggregate, the Document's Cover Texts may be placed on covers that surround only the Document within the aggregate. Otherwise they must appear on covers around the whole aggregate. 8. TRANSLATION Translation is considered a kind of modification, so you may distribute translations of the Document under the terms of section 4. Replacing Invariant Sections with translations requires special permission from their copyright holders, but you may include translations of some or all Invariant Sections in addition to the original versions of these Invariant Sections. You may include a translation of this License provided that you also include the original English version of this License. In case of a disagreement between the translation and the original English version of this License, the original English version will prevail. 9. TERMINATION You may not copy, modify, sublicense, or distribute the Document except as expressly provided for under this License. Any other attempt to copy, modify, sublicense or distribute the Document is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 10. FUTURE REVISIONS OF THIS LICENSE The Free Software Foundation may publish new, revised versions of the GNU Free Documentation 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. See http://www.gnu.org/copyleft/. Each version of the License is given a distinguishing version number. If the Document specifies that a particular numbered version of this License "or any later version" applies to it, you have the option of following the terms and conditions either of that specified version or of any later version that has been published (not as a draft) by the Free Software Foundation. If the Document does not specify a version number of this License, you may choose any version ever published (not as a draft) by the Free Software Foundation. ecl-16.1.2/doc/README000066400000000000000000000024621266352375300140110ustar00rootroot00000000000000Instructions to edit/build this book ==================================== This is the recommended way to edit this manual. It is the one I found most convenient both under Linux and OS X. * Install the xmlto package. You can do it in almost any Linux machine and also under OS X using the Fink packages. * Install Emacs (Linux) or Aquamacs (OS X). * Make sure you have the nxml-mode package. This is available in some Linux distributions and comes for free with Aquamacs. * In the nxml-mode you should replace the Docbook schemas, which go only up to version 4.2. These are the steps to do so: - Go to http://www.docbook.org/schemas/4x.html - Download the RELAX NG schema. It will suffice with docbook-rng-4.4.zip - Go to the place where nxml stores its schema files. In Debian/Ubuntu it is /usr/share/emacs/site-lisp/nxml-mode/schema, in Aquamacs it is in /Applications/Aquamacs.app/Content/Resources/site-lisp/nxml-mode/schema. - Make a backup copy of these schemas. - Unzip the previous package directly on top of the directory mentioned before. After these steps, you should be able to edit the manual. To build it, ensure that the "xmlto" program is in some of the directories listed in the PATH environment variable and type "make" from the command line. This will build the HTML version. ecl-16.1.2/doc/ansi_arrays.xml000066400000000000000000000105701266352375300161650ustar00rootroot00000000000000 %eclent; ]> Arrays
Array limits &ECL; arrays can have up to 64 dimensions. Common-Lisp constants related to arrays have the following values in &ECL;. Constant Value array-rank-limit 64 array-dimension-limit most-positive-fixnum array-total-size-limit array-dimension-limit
Specializations When the elements of an array are declared to have some precise type, such as a small or large integer, a character or a floating point number, &ECL; has means to store those elements in a more compact form, known as a specialized array. The list of types for which &ECL; specializes arrays is platform dependent, but is summarized in the following table, together with the C type which is used internally and the expected size. Specialized type Element C type Size bit - 1 bit character unsigned char or uint32_t Depends on character range base-char unsigned char fixnum cl_fixnum Machine word (32 or 64 bits) (signed-byte 8) int8_t 8 bits (unsigned-byte 8) uint8_t 8 bits (signed-byte 16) int16_t 16 bits (unsigned-byte 16) uint16_t 16 bits (signed-byte 32) int32_t 32 bits (unsigned-byte 32) uint32_t 32 bits (signed-byte 64) int64_t 64 bits (unsigned-byte 64) uint64_t 64 bits single-float or short-float float 32-bits IEEE float double-float double 64-bits IEEE float long-float long double Between 96 and 128 bits. t cl_object Size of a pointer. Let us remark that some of these specialized types might not exist in your platform. This is detected using conditional reading and features (See ).
ecl-16.1.2/doc/ansi_characters.xml000066400000000000000000000117021266352375300170010ustar00rootroot00000000000000 %eclent; ]> Characters &ECL; is fully ANSI Common-Lisp compliant in all aspects of the character data type, with the following peculiarities.
Unicode vs. POSIX locale There are two ways of building &ECL;: with C or with Unicode character codes. These build modes are accessed using the --disable-unicode and --enable-unicode configuration options, the last one being the default. When using C characters we are actually relying on the char type of the C language, using the C library functions for tasks such as character conversions, comparison, etc. In this case characters are typically 8 bit wide and the character order and collation are determines by the current POSIX or C locale. This is not very accurate, leaves out many languages and character encodings but it is sufficient for small applications that do not need multilingual support. When no option is specified &ECL; builds with support for a larger character set, the Unicode 6.0 standard. This uses 24 bit large character codes, also known as codepoints, with a large database of character properties which include their nature (alphanumeric, numeric, etc), their case, their collation properties, whether they are standalone or composing characters, etc.
Character types If compiled without Unicode support, &ECL; all characters are implemented using 8-bit codes and the type extended-char is empty. If compiled with Unicode support, characters are implemented using 24 bits and the extended-char type covers characters above code 255. Type With Unicode Without Unicode standard-char #\Newline,32-126 #\Newline,32-126 base-char 0-255 0-255 extended-char - 255-16777215
Character names All characters have a name. For non-printing characters between 0 and 32, and for 127 we use the ordinary ASCII names. Characters above 127 are printed and read using hexadecimal Unicode notation, with a U followed by 24 bit hexadecimal number, as in U0126. Examples of character names Character Code #\Null0#\Ack1#\Bell7#\Backspace8#\Tab9#\Newline10#\Linefeed10#\Page12#\Esc27#\Escape27#\Space32#\Rubout127#\U0080128
Note that #\Linefeed is synonymous with #\Newline and thus is a member of standard-char.
<code>#\Newline</code> characters Internally, &ECL; represents the #\Newline character by a single code. However, when using external formats, &ECL; may parse character pairs as a single #\Newline, and viceversa, use multiple characters to represent a single #\Newline. See .
ecl-16.1.2/doc/ansi_conditions.xml000066400000000000000000000005751266352375300170410ustar00rootroot00000000000000 %eclent; ]> Conditions ecl-16.1.2/doc/ansi_conses.xml000066400000000000000000000005521266352375300161550ustar00rootroot00000000000000 %eclent; ]> Conses ecl-16.1.2/doc/ansi_data_flow.xml000066400000000000000000000244221266352375300166250ustar00rootroot00000000000000 %eclent; ]> Data and control flow
<function>LET</function>, <function>FLET</function>, <function>LABELS</function> and function <emphasis>lambda list</emphasis> &ANSI; addendum &ANSI; doesn't specify what should happen if any of the LET, FLET and LABELS blocks contain many bindings (or functions) sharing the same name. Because the behavior varies between the implementations and the programmer can't rely on the spec, &ECL; signals an error if such situation occurs. This is also very unlikely, that programmer does that intentionally, since there is no valid use-case for it. Moreover, while &ANSI; defines lambda list parameters in the terms of LET*, when used in function context programmer can't provide an initialization forms for required parameters. If required parameters share the same name error is signalled. Described behavior is present in &ECL; since version 16.0.0. Previously the LET operator were using first binding, while lambda lists used last occurrence. Both FLET and LABELS were singalling an error if C compiler was used and used last binding as visible one when bytecmp was used.
Minimal compilation Former versions of &ECL;, as well as many other lisps, used linked lists to represent code. Executing code thus meant traversing these lists and performing code transformations, such as macro expansion, every time that a statement was to be executed. The result was a slow and memory hungry interpreter. Beginning with version 0.3, &ECL; was shipped with a bytecodes compiler and interpreter which circumvent the limitations of linked lists. When you enter code at the lisp prompt, or when you load a source file, &ECL; begins a process known as minimal compilation. Barely this process consists on parsing each form, macroexpanding it and translating it into an intermediate language made of bytecodes. The bytecodes compiler is implemented in src/c/compiler.d. The main entry point is the lisp function si::make-lambda, which takes a name for the function and the body of the lambda lists, and produces a lisp object that can be invoked. For instance, > (defvar fun (si::make-lambda 'f '((x) (1+ x)))) *FUN* > (funcall fun 2) 3 &ECL; can only execute bytecodes. When a list is passed to EVAL it must be first compiled to bytecodes and, if the process succeeds, the resulting bytecodes are passed to the interpreter. Similarly, every time a function object is created, such as in DEFUN or DEFMACRO, the compiler processes the lambda form to produce a suitable bytecodes object. The fact that &ECL; performs this eager compilation means that changes on a macro are not immediately seen in code which was already compiled. This has subtle implications. Take the following code: > (defmacro f (a b) `(+ ,a ,b)) F > (defun g (x y) (f x y)) G > (g 1 2) 3 > (defmacro f (a b) `(- ,a ,b)) F > (g 1 2) 3 The last statement always outputs 3 while in former implementations based on simple list traversal it would produce -1.
Function types Functions in &ECL; can be of two types: they are either compiled to bytecodes or they have been compiled to machine code using a lisp to C translator and a C compiler. To the first category belong function loaded from lisp source files or entered at the toplevel. To the second category belong all functions in the &ECL; core environment and functions in files processed by compile or compile-file. The output of (symbol-function fun) is one of the following: a function object denoting the definition of the function fun, a list of the form (macro . function-object) when fun denotes a macro, or simply 'special, when fun denotes a special form, such as block, if, etc. &ECL; usually drops the source code of a function unless the global variable si:*keep-definitions* was true when the function was translated into bytecodes. Therefore, if you wish to use compile and disassemble on defined functions, you should issue (setq si:*keep-definitions* t) at the beginning of your session. In we list all &CommonLisp; values related to the limits of functions. Function related constants call-arguments-limit 65536 lambda-parameters-limit call-arguments-limit multiple-values-limit 64 lambda-list-keywords (&optional; &rest; &key; &allow-other-keys; &aux; &whole; &environment; &body;)
C Calling conventions &ECL; is implemented using either a C or a C++ compiler. This is not a limiting factor, but imposes some constraints on how these languages are used to implement functions, multiple values, closures, etc. In particular, while C functions can be called with a variable number of arguments, there is no facility to check how many values were actually passed. This forces us to have two types of functions in &ECL; Functions that take a fixed number of arguments have a simple C signature, with all arguments being properly declared, as in cl_object cl_not(cl_object arg1). Functions with a variable number of arguments, such as those acception &optional;, &rest; or &key; arguments, must take as first argument the number of remaining ones, as in cl_object cl_list(cl_narg narg, ...). Here narg is the number of supplied arguments. The previous conventions set some burden on the C programmer that calls &ECL;, for she must know the type of function that is being called and supply the right number of arguments. This burden disappears for Common Lisp programmers, though. As an example let us assume that the user wants to invoke two functions which are part of the &ANSI; standard and thus are exported with a C name. The first example is cl_cos, which takes just one argument and has a signature cl_object cl_cos(cl_object). #include <math.h> ... cl_object angle = ecl_make_double_float(M_PI); cl_object c = cl_cos(angle); printf("\nThe cosine of PI is %g\n", ecl_double_float(c)); The second example also involves some Mathematics, but now we are going to use the C function corresponding to +. As described in the C dictionary, the C name for the plus operator is cl_P and has a signature cl_object cl_P(cl_narg narg,...). Our example now reads as follows cl_object one = ecl_make_fixnum(1); cl_object two = cl_P(2, one, one); cl_object three = cl_P(3, one, one, one); printf("\n1 + 1 is %d\n", ecl_fixnum(two)); printf("\n1 + 1 + 1 is %d\n", ecl_fixnum(three)); Note that most Common Lisp functions will not have a C name. In this case one must use the symbol that names them to actually call the functions, using cl_funcall or cl_apply. The previous examples may thus be rewritten as follows /* Symbol + in package CL */ cl_object plus = ecl_make_symbol("+","CL"); cl_object one = ecl_make_fixnum(1); cl_object two = cl_funcall(3, plus, one, one); cl_object three = cl_funcall(4, plus, one, one, one); printf("\n1 + 1 is %d\n", ecl_fixnum(two)); printf("\n1 + 1 + 1 is %d\n", ecl_fixnum(three)); Another restriction of C and C++ is that functions can only take a limited number of arguments. In order to cope with this problem, &ECL; uses an internal stack to pass any argument above a hardcoded limit, ECL_C_CALL_ARGUMENTS_LIMIT, which is as of this writing 63. The use of this stack is transparently handled by the Common Lisp functions, such as apply, funcall and their C equivalents, and also by a set of macros, cl_va_arg, which can be used for coding functions that take an arbitrary name of arguments.
ecl-16.1.2/doc/ansi_environment.xml000066400000000000000000000162211266352375300172270ustar00rootroot00000000000000 %eclent; ]> Environment
Dictionary disassemble Display the assembly code of a function disassemble function-designator* function-designator A symbol which is bound to a function in the global environment, or a lambda form Function As specified in &ANSI; this function outputs the internal represention of a compiled function, or of a lambda form, as it would look after being compiled. &ECL; only has a particular difference: it has two different compilers, one based on bytecodes and one based on the C language. The output will thus depend on the arguments and on which compiler is active at the moment in which this function is run. If the argument is a bytecompiled function, the output will be bytecodes. If the argument is a lambda form, it will be processed by the active compiler and the appropriate output (bytecodes or C) will be shown. If the argument is a C-compiled form, &ECL; will retrieve its original lambda form and process it with the currently active compiler. trace Follow execution of functions trace function-name* function-name {symbol | (symbol [option form]*)} symbol A symbol which is bound to a function in the global environment. Not evaluated. option One of :BREAK, :BREAK-AFTER, :COND-BEFORE, :COND-AFTER, :COND, :PRINT, :PRINT-AFTER, :STEP form A lisp form evaluated in an special environment. returns List of symbols with traced functions. Macro Causes one or more functions to be traced. Each function-name can be a symbol which is bound to a function, or a list containing that symbol plus additional options. If the function bound to that symbol is called, information about the argumetns and output of this function will be printed. Trace options will modify the amount of information and when it is printed. Not that if the function is called from another function compiled in the same file, tracing might not be enabled. If this is the case, to enable tracing, recompile the caller with a notinline declaration for the called function. trace returns a name list of those functions that were traced by the call to trace. If no function-name is given, trace simply returns a name list of all the currently traced functions. Trace options cause the normal printout to be suppressed, or cause extra information to be printed. Each option is a pair of an option keyword and a value form. If an already traced function is traced again, any new options replace the old options and a warning might be printed. The lisp form accompanying the option is evaluated in an environment where sys::arglist is contains the list of arguments to the function. The following options are defined: :cond :cond-before :cond-after If :cond-before is specified, then trace does nothing unless form evaluates to true at the time of the call. :cond-after is similar, but suppresses the initial printout, and is tested when the function returns. :cond tries both before and after. :step If form evaluates to true, the stepper is entered. :break :break-after If specified, and form evaluates to true, then the debugger is invoked at the start of the function or at the end of the function according to the respective option. :print :print-after In addition to the usual printout, the result of evaluating form is printed at the start of the function or at the end of the function, depending on the option. Multiple print options cause multiple values to be output, in the order in which they were introduced.
ecl-16.1.2/doc/ansi_evaluation.xml000066400000000000000000000115541266352375300170360ustar00rootroot00000000000000 %eclent; ]> Evaluation and compilation
Declarations
<function>OPTIMIZE</function> The OPTIMIZE declaration includes three concepts: DEBUG, SPEED, SAFETY and SPACE. Each of these declarations can take one of the integer values 0, 1, 2 and 3. According to these values, the implementation may decide how to compie or interpret a given lisp form. &ECL; currently does not use all these declarations, but some of them definitely affect the speed and behavior of compiled functions. For instance, the DEBUG declaration, as shown in , if the value of debugging is zero, the function will not appear in the debugger and, if redefined, some functions might not see the redefinition. Behavior for different levels of DEBUG Behavior 0 1 2 3 Compiled functions in the same source file are called directly Y Y N N Compiled function appears in debugger backtrace N N Y Y All functions get a global entry, that is, SI:C-LOCAL is ignored. N N Y Y
A bit more critical is the value of SAFETY because as shown in Table , it may affect the safety checks generated by the compiler. In particular, in some circumstances the compiler may assume that the arguments to a function are properly typed. For instance, if you compile with a low value of SAFETY, and invoke RPLACA, the consequences are unspecified. Behavior for different levels of SAFETY Behavior 0 1 2 3 The compiler generates type checks for the arguments of a lambda form, thus enforcing any type declaration written by the user. N Y Y Y The value of an expression or a variable declared by the user is assumed to be right. Y Y N N We believe type declarations and type inference and, if the type of a form is inferred to be right for a function, slot accessor, etc, this may be inlined. Affects functions like CAR, CDR, etc Y Y N N We believe types defined before compiling a file not change before the compiled code is loaded. Y Y N N Arguments in a lisp form are assumed to have the appropriate types so that the form will not fail. Y N N N The slots or fields in a lisp object are accessed directly without type checks even if the type of the object could not be inferred (see line above). Affects functions like PATHNAME-TYPE, CAR, REST, etc. Y N N N
ecl-16.1.2/doc/ansi_filenames.xml000066400000000000000000000205231266352375300166260ustar00rootroot00000000000000 %eclent; ]> Filenames
Syntax A pathname in the file system of Common-Lisp consists of six elements: host, device, directory, name, type and version. Pathnames are read and printed using the #P reader macro followed by the namestring. A namestring is a string which represents a pathname. The syntax of namestrings for logical pathnames is well explained in the &ANSI; and it can be roughly summarized as follows: hostname:;directory-item;0 or morename.type.version hostname = word directory-item = wildcard-word type, name = wildcard-word without dots Here, wildcard-word is a sequence of any character excluding #\Null and dots. word is like a wildcard-word but asterisks are excluded. The way &ECL; parses a namestring is by first looking for the hostname component in the previous template. If it is found and it corresponds to a previously defined logical hostname, it assumes that the namestring corresponds to a logical pathname. If hostname is not found or it is not a logical hostname, then &ECL; tries the physical pathname syntax device://hostname/directory-item/0 or morename.type device, hostname = word directory-item = wildcard-word type = wildcard-word without dots name = .wildcard-word If this syntax also fails, then the namestring is not a valid pathname string and a parse-error will be signalled. It is important to remark that in &ECL;, all physical namestrings result into pathnames with a version equal to :NEWEST. Pathnames which are not logical and have any other version (i. e. NIL or a number), cannot be printed readably, but can produce a valid namestring which results of ignoring the version. Finally, an important rule applies to physical namestrings: if a namestring contains one or more periods `.', the last period separates the namestring into the file name and the filetype. However, a namestring with a single leading period results in a name with a period in it. This is for compatibility with Unix filenames such as .bashrc, where the leading period indicates that the file is hidden. The previous rule has in important consequence, because it means that if you want to create a pathname without a name, you have to do it explicitely. In other words, ".*" is equivalent to (MAKE-PATHNAME :NAME ".*" :TYPE NIL), while (MAKE-PATHNAME :NAME NIL :TYPE :WILD) creates a pathname whose type is a wildcard. The following table illustrates how the physical pathnames work with practical examples. Examples of physical namestrings Namestring Name Type Directory Device "foo.lsp" "foo" "lsp" NIL NIL ".bashrc" ".bashrc" NIL NIL NIL ".ecl.lsp" ".ecl" "lsp" NIL NIL "foo.*" "foo" :WILD NIL NIL "*.*" :WILD :WILD NIL NIL "ecl/build/bare.lsp" "bare" "lsp" (:relative "ecl" "build") NIL "ecl/build/" NIL NIL (:relative "ecl" "build") NIL "../../ecl/build/" NIL NIL (:relative :up :up "ecl" "build") NIL "/etc/" NIL NIL (:absolute "etc") NIL "C:/etc/" NIL NIL (:absolute "etc") "C" ".*" ".*" NIL NIL NIL #.(MAKE-PATHNAME :TYPE "*") NIL :WILD NIL NIL
Wild pathnames and matching &ECL; accepts four kind of wildcards in pathnames. A single wildcard in a directory component, file name, type or version is parsed as the :WILD value. See for instance "*.*", "/home/*/.bashrc", etc A double wildcard in a directory component, such as in "/home/**/" is parsed as the :WILD-INFERIORS, and matches any number of directories, even nested ones, such as: /home/, /home/jlr, /home/jlr/lib, etc. An isolated wildcard "log*.txt" matches any number of characters: log.txt, log_back.txt, etc. A question mark "log?.txt" matches a single character: log1.txt, log2.txt... The matching rules in &CommonLisp; and &ECL; are simple but have some unintuitive consequences when compared to Unix/DOS rules. The most important one is that directories must always end with a trailing slash /, as in #p"/my/home/directory/". Second to that, NIL values can only be matched by NIL and :WILD. Hence, "*" can only match files without file type. For some examples see .
ecl-16.1.2/doc/ansi_files.xml000066400000000000000000000036041266352375300157660ustar00rootroot00000000000000 %eclent; ]> Files
Dictionary
<function>DIRECTORY</function> This function does not have any additional arguments other than the ones described in &ANSI;. To list files and directories, it follows the rules for matching pathnames described in . In short, you have the following practical examples: Examples of using <function>DIRECTORY</function> ArgumentMeaning "/home/jlr/*.*" List all files in directory /home/jlr/ Note that it lists only files, not directories! "/home/jlr/*" Same as before, but only files without type. "/home/jlr/*/" List all directories contained in /home/jlr/. Nested directories are not navigated. "/home/jlr/**/*.*" List all files in all directories contained in /home/jlr/, recursively. Nested directories are navigated.
ecl-16.1.2/doc/ansi_hash_tables.xml000066400000000000000000000006221266352375300171360ustar00rootroot00000000000000 %eclent; ]> Hash tables ... ecl-16.1.2/doc/ansi_numbers.xml000066400000000000000000000104421266352375300163350ustar00rootroot00000000000000 %eclent; ]> Numbers
Numeric types &ECL; supports all of the &CommonLisp; numeric tower, which is shown in . The details, however, depend both on the platform on which &ECL; runs and on the configuration which was chosen when building &ECL;. Numeric types in &ECL; TypeDescription fixnum Signed integer with a number of bits given by ext:fixnum-bits, fit in a machine word. bignum Arbitrary size integers, only limited by amount of memory. ratio Arbitrary size rational number, made up of two integers. short-float Equivalent to single-float. single-float 32-bits IEEE floating point number. double-float 64-bits IEEE floating point number. long-float Either equivalent to double-float, or a 96/128 bits IEEE floating point number (long double in C/C++). rational An alias for (or integer ratio) float An alias for (or single-float double-float short-float long-float) real An alias for (or real integer float) complex Complex number made of two real numbers of the above mentioned types.
In general, the size of a FIXNUM is determined by the word size of a machine, which ranges from 32 to 64 bits. Integers larger than this are implemented using the GNU Multiprecision library. Rationals are implemented using two integers, without caring whether they are fixnum or not. Floating point numbers include at least the two IEEE types of 32 and 64 bits respectively. In machines where it is supported, it is possible to associate the lisp LONG-FLOAT with the machine type long double whose size ranges from 96 to 128 bits, and which are a bit slower.
Random-States &ECL; relies internally on a 32-bit Mersenne-Twister random number generator, using a relatively large buffer to precompute about 5000 pseud-random bytes. This implies also that random states can be printed readably and also read, using the #$ macro. There is no provision to create random states from user arrays, though. Random state is printed unreadably by default. The #$ macro can be used to initialize generatorr with the random seed (an integer), an array of random bytes (mainly used for reading back printed random-state) and an another random-state (syntactic sugar for copying of the random-state).
ecl-16.1.2/doc/ansi_objects.xml000066400000000000000000000005611266352375300163140ustar00rootroot00000000000000 %eclent; ]> Objects ecl-16.1.2/doc/ansi_overview.xml000066400000000000000000000215301266352375300165300ustar00rootroot00000000000000 %eclent; ]> Overview
Reading this manual
Common Lisp users &ECL; supports all Common-Lisp data types exactly as defined in the &ANSI;. All functions and macros are expected to behave as described in that document and in the HyperSpec &HyperSpec; which is the online version of &ANSI;. In other words, the Standard is the basic reference for Common Lisp and also for &ECL;, and this first part of the book just complements it, describing implementation-specific features such as Platform dependent limits. Behavior which is marked as implementation specific in the standard. Some corner cases which are not described in &ANSI;. The philosophy behind certain implementation choices, etc. In order to aid in locating these differences, this first part of the manual copies the structure of the &ANSI; standard, having the same number of chapters, each one with a set of sections documenting the implementation-specific details.
C/C++ programmers The second goal of this document is to provide a reference for C programmers that want to create, manipulate and operate with Common Lisp programs at a lower level, or simply embedding &ECL; as a library. The C/C++ reference evolves in parallel with the Common Lisp one, in the form of one section with the name "C Reference" for each chapter of the &ANSI; standard. Much of what is presented in those sections is redundant with the Common Lisp specification. In particular, there is a one-to-one mapping between types and functions which should be obvious given the rules explained in . We must remark that the reference in this part of the manual is not enough to know how to embed &ECL; in a program. In practice the user or developer will also have to learn how to build programs, interface with foreign libraries, manage memory, etc. These concepts are explained in a different part of the book.
C Reference
One type for everything: <type>cl_object</type> &ECL; is designed around the basic principle that Common Lisp already provides everything that a programmer could need, orienting itself around the creation and manipulation of Common Lisp objects: conses, arrays, strings, characters, ... When embedding &ECL; there should be no need to use other C/C++ types, except when interfacing data to and from those other languages. All Common Lisp objects are represented internally through the same C type, cl_object, which is either a pointer to a union type or an integer, depending on the situation. While the inner guts of this type are exposed through various headers, the user should never rely on these details but rather use the macros and functions that are listed in this manual There are two types of Common Lisp objects: immediate and memory allocated ones. Immediate types fit in the bits of the cl_object word, and do not require the garbage collector to be created. The list of such types may depend on the platform, but it includes at least the fixnum and character types. Memory allocated types on the other hand require the use of the garbage collector to be created. &ECL; abstracts this from the user providing enough constructors, either in the form of Common Lisp functions (cl_make_array(), cl_complex(),...), or in the form of C/C++ constructors (ecl_make_symbol(), etc). Memory allocated types must always be kept alive so that the garbage collector does not reclaim them. This involves referencing the object from one of the places that the collector scans: The fields of an object (array, structure, etc) whic is itself alive. A special variable or a constant. The C stack (i.e. automatic variables in a function). Global variables or pointers that have been registered with the garbage collector. Further details will be provided in the section on Memory Management.
Naming conventions As explained in the introduction, each of the chapters in the Common Lisp standard can also be implemented using C functions and types. The mapping between both languages is done using a small set of rules described below. Functions in the Common Lisp ("CL") package are prefixed with the characters "cl_", functions in the System ("SI") package are prefix with "si_", etc, etc. If a function takes only a fixed number of arguments, it is mapped to a C function with also a fixed number of arguments. For instance, COS maps to cl_object cl_cos(cl_object), which takes a single Lisp object and returns a Lisp object of type FLOAT. If the function takes a variable number of arguments, its signature consists on an integer with the number of arguments and zero or more of required arguments and then a C vararg. This is the case of cl_object cl_list(cl_narg narg, ...), which can be invoked without arguments, as in cl_list(0), with one, cl_list(1, a), etc. Functions return at least one value, which is either the first value output by the function, or NIL. The extra values may be retrieved immediately after the function call using the function ecl_nth_value. In addition to the Common Lisp core functions (cl_*), there exist functions which are devoted only to C/C++ programming, with tasks such as coercion of objects to and from C types, optimized functions, inlined macroexpansions, etc. These functions and macros typically carry the prefix "ecl_" or "ECL_" and only return one value, if any.
Only in Common Lisp Some parts of the language are not available as C functions, even though they can be used in Common Lisp programs. These parts are either marked in the "ANSI Dictionary" sections using the tag &OCL;, or they are simply not mentioned (macros and special constructs). This typically happens with non-translatable constructs such as Common Lisp macros such as with-open-files. Common Lisp special forms, such as cond Common Lisp generic functions, which cannot be written in C because of their dynamical dispatch and automatic redefinition properties. In most of those cases there exist straightforward alternatives using the constructs and functions in &ECL;. For example, unwind-protect can be implemented using a C macro which is provided by &ECL; cl_env_ptr env = ecl_process_env(); CL_UNWIND_PROTECT_BEGIN(env) { /* protected code goes here */ } CL_UNWIND_PROTECT_EXIT { /* exit code goes here */ } CL_UNWIND_PROTECT_END; Common Lisp generic functions can be directly accessed using funcall or apply and the function name, as shown in the code below cl_object name = ecl_make_symbol("MY-GENERIC-FUNCTION","CL-USER"); cl_object output = cl_funcall(2, name, argument); Identifying these alternatives requires some knowledge of Common Lisp, which is why it is recommended to approach the embeddable components in &ECL; only when there is some familiarity with the language.
ecl-16.1.2/doc/ansi_packages.xml000066400000000000000000000063641266352375300164500ustar00rootroot00000000000000 %eclent; ]> Packages ECL packages Name Nickname In module Description COMMON-LISP CL, LISP &ECL; core Main &CommonLisp; package. CLOS MOP &ECL; core Symbols from the &AMOP;. EXT &ECL; core &ECL; extensions to the language & library. SYSTEM SI, SYS &ECL; core Functions and variables internal to the implementation. Never to be used. FFI ECL core Foreign function interface CMP C CMP The compiler XLIB CLX XLIB CLX library for X-Windows SB-BSD-SOCKETS SOCKETS Sockets library compatible with SBCL's SB-RT RT, REGRESSION-TEST RT Test units (customized for &ECL;) ASDF ASDF System definition file with &ECL; customizations.
In we list all packages available in &ECL;. The nicknames are aliases for a package. Thus, system:symbol may be written as sys:symbol or si:symbol. The module field explains which library provides what package. For instance, the ASDF is obtained when loading the ASDF library with (require 'asdf); and the XLIB package when configuring and loading the CLX library. ecl-16.1.2/doc/ansi_printer.xml000066400000000000000000000125041266352375300163460ustar00rootroot00000000000000 %eclent; ]> Printer In all situations where the rules are well specified, &ECL; prints objects according to &ANSI;. The specification leaves however a number of cases as implementation dependent behavior. The output of &ECL; in those cases is summarized in . Except for the types character and random-state, most of those examples regard non-standard written forms #<...> cannot be read back using read. These printed representations are just informative and should not be used to reconstruct or compare objects. Implementation specific printed representation Lisp type Format Remarks package #<package name> random-state #$character array bitvector #<bit-vector unique-id> Only when *print-array* is false. vector #<vector unique-id> Only when *print-array* is false. array #<array unique-id> Only when *print-array* is false. hash-table #<hash-table unique-id> readtable #<readtable unique-id> interpreted function #<bytecompiled-function name-or-id> Name is a symbol. machine compiled function #<compiled-function name> Name is a symbol. input-stream #<input stream "filename"> An stream that reads from filename. output-stream #<output stream "filename"> An stream that writes to filename. probe-stream #<probe stream "filename"> string-input-stream #<string-input stream from "string-piece"> The string is the text left to be read. string-output-stream #<string-output stream unique-id> two-way-stream #<two-way stream unique-id> echo-stream #<echo stream unique-id> synonym-stream #<synonym stream to symbol> broadcast-stream #<broadcast stream unique-id> concatenated-stream #<concatenated stream unique-id> closed-stream #<closed ...> The dots denote any of the above stream forms.
ecl-16.1.2/doc/ansi_reader.xml000066400000000000000000000005531266352375300161260ustar00rootroot00000000000000 %eclent; ]> Reader ecl-16.1.2/doc/ansi_sequences.xml000066400000000000000000000005661266352375300166630ustar00rootroot00000000000000 %eclent; ]> Sequences ecl-16.1.2/doc/ansi_streams.xml000066400000000000000000000314401266352375300163410ustar00rootroot00000000000000 %eclent; ]> Streams
ANSI Streams
Supported types &ECL; implements all stream types described in &ANSI;. Additionally, when configured with option , &ECL; includes a version of Gray streams where any object that implements the appropiate methods (stream-input-p, stream-read-char, etc) is a valid argument for the functions that expect streams, such as read, print, etc.
Element types &ECL; distinguishes between two kinds of streams: character streams and byte streams. Character streams only accept and produce characters, written or read one by one, with write-char or read-char, or in chunks, with write-sequence or any of the Lisp printer functions. Character operations are conditioned by the external format, as described in ANSI Common Lisp also supports binary streams. Here input and output is performed in chunks of bits. Binary streams are created with the function open passing as argument a subtype of integer and the implementation is free to round up that integer type to the closest size it supports. In particular &ECL; rounds up the size to a multiple of a byte. For example, the form (open "foo.bin" :direction :output :element-type '(unsigned-byte 13)), will open the file foo.bin for writing, using 16-bit words as the element type.
External formats An external format is an encoding for characters that maps character codes to a sequence of bytes, in a one-to-one or one-to-many fashion. External formats are also known as "character encodings" in the programming world and are an essential ingredient to be able to read and write text in different languages and alphabets. &ECL; has one of the most complete supports for external formats, covering all of the usual codepages from the Windows and Unix world, up to the more recent UTF-8, UCS-2 and UCS-4 formats, all of them with big and small endian variants, and considering different encodings for the newline character. However, the set of supported external formats depends on the size of the space of character codes. When &ECL; is built with Unicode support (the default option), it can represent all known characters from all known codepages, and thus all external formats are supported. However, when &ECL; is built with the restricted character set, it can only use one codepage (the one provided by the C library), with a few variants for the representation of end-of-line characters. In &ECL;, an external format designator is defined recursively as either a symbol or a list of symbols. The grammar is as follows external-format-designator := symbol | ( {symbol}+ ) and the table of known symbols is shown below. Note how some symbols (:cr, :little-endian, etc) just modify other external formats. Stream external formats Symbols Codepage or encoding Unicode required :cr #\Newline is Carriage Return No :crlf #\Newline is Carriage Return followed by Linefeed No :lf #\Newline is Linefeed No :little-endian Modify UCS to use little endian encoding. No :big-endian Modify UCS to use big endian encoding. No :utf-8 :utf8 Unicode UTF-8 Yes :ucs-2 :ucs2 :utf-16 :utf16 :unicode UCS-2 encoding with BOM. Yes :ucs-2le :ucs2le :utf-16le UCS-2 with big-endian encoding Yes :ucs-2be :ucs2be :utf-16be UCS-2 with big-endian encoding Yes :ucs-4 :ucs4 :utf-32 :utf32 UCS-4 encoding with BOM. Yes :ucs-4le :ucs4le :utf-32le UCS-4 with big-endian encoding Yes :ucs-4be :ucs4be :utf-32be UCS-4 with big-endian encoding Yes :iso-8859-1 :iso8859-1 :latin-1 :cp819 :ibm819 Latin-1 encoding Yes :iso-8859-2 :iso8859-2 :latin-2 :latin2 Latin-2 encoding Yes :iso-8859-3 :iso8859-3 :latin-3 :latin3 Latin-3 encoding Yes :iso-8859-4 :iso8859-4 :latin-4 :latin4 Latin-4 encoding Yes :iso-8859-5 :cyrillic Latin-5 encoding Yes :iso-8859-6 :arabic :asmo-708 :ecma-114 Latin-6 encoding Yes :iso-8859-7 :greek8 :greek :ecma-118 Greek encoding Yes :iso-8859-8 :hebrew Hebrew encoding Yes :iso-8859-9 :latin-5 :latin5 Latin-5 encoding Yes :iso-8859-10 :iso8859-10 :latin-6 :latin6 Latin-6 encoding Yes :iso-8859-13 :iso8859-13 :latin-7 :latin7 Latin-7 encoding Yes :iso-8859-14 :iso8859-14 :latin-8 :latin8 Latin-8 encoding Yes :iso-8859-15 :iso8859-15 :latin-9 :latin9 Latin-7 encoding Yes :dos-cp437 :ibm-437 IBM CP 437 Yes :dos-cp850 :ibm-850 :cp850 Windows CP 850 Yes :dos-cp852 :ibm-852 IBM CP 852 Yes :dos-cp855 :ibm-855 IBM CP 855 Yes :dos-cp860 :ibm-860 IBM CP 860 Yes :dos-cp861 :ibm-861 IBM CP 861 Yes :dos-cp862 :ibm-862 :cp862 Windows CP 862 Yes :dos-cp863 :ibm-863 IBM CP 863 Yes :dos-cp864 :ibm-864 IBM CP 864 Yes :dos-cp865 :ibm-865 IBM CP 865 Yes :dos-cp866 :ibm-866 :cp866 Windows CP 866 Yes :dos-cp869 :ibm-869 IBM CP 869 Yes :windows-cp932 :windows-932 :cp932 Windows CP 932 Yes :windows-cp936 :windows-936 :cp936 Windows CP 936 Yes :windows-cp949 :windows-949 :cp949 Windows CP 949 Yes :windows-cp950 :windows-950 :cp950 Windows CP 950 Yes :windows-cp1250 :windows-1250 :ms-ee Windows CP 1250 Yes :windows-cp1251 :windows-1251 :ms-cyrl Windows CP 1251 Yes :windows-cp1252 :windows-1252 :ms-ansi Windows CP 1252 Yes :windows-cp1253 :windows-1253 :ms-greek Windows CP 1253 Yes :windows-cp1254 :windows-1254 :ms-turk Windows CP 1254 Yes :windows-cp1255 :windows-1255 :ms-hebr Windows CP 1255 Yes :windows-cp1256 :windows-1256 :ms-arab Windows CP 1256 Yes :windows-cp1257 :windows-1257 :winbaltrim Windows CP 1257 Yes :windows-cp1258 :windows-1258 Windows CP 1258 Yes
ecl-16.1.2/doc/ansi_strings.xml000066400000000000000000000042361266352375300163570ustar00rootroot00000000000000 %eclent; ]> Strings
String types & Unicode The &ECL; implementation of strings is ANSI Common-Lisp compliant. There are basically four string types as shown in . As explained in , when Unicode support is disabled, character and base-character are the same type and the last two string types are equivalent to the first two. &CommonLisp; string types Abbreviation Expanded type Remarks string (array character (*)) 8 or 32 bits per character, adjustable. simple-string (simple-array character (*)) 8 or 32 bits per character, not adjustable nor displaced. base-string (array base-char (*)) 8 bits per character, adjustable. simple-base-string (simple-array base-char (*)) 8 bits per character, not adjustable nor displaced.
It is important to remember that strings with unicode characters can only be printed readably when the external format supports those characters. If this is not the case, &ECL; will signal a serious-condition. This condition will abort your program if not properly handled.
ecl-16.1.2/doc/ansi_structures.xml000066400000000000000000000005731266352375300171110ustar00rootroot00000000000000 %eclent; ]> Structures ecl-16.1.2/doc/ansi_symbols.xml000066400000000000000000000011171266352375300163510ustar00rootroot00000000000000 %eclent; ]> Symbols There are no implementation-specific limits on the size or content of symbol names. It is however not allowed to write on the strings which have been passed to #'make-symbol or returned from #'symbol-name. ecl-16.1.2/doc/ansi_system_construction.xml000066400000000000000000000006371266352375300210250ustar00rootroot00000000000000 %eclent; ]> System Construction ecl-16.1.2/doc/ansi_types.xml000066400000000000000000000013021266352375300160210ustar00rootroot00000000000000 %eclent; ]> Types and classes
Built-in-class &ECL; defines two additional built-in-class objects for user conveniance: single-float double-float
ecl-16.1.2/doc/asdf.xmlf000066400000000000000000000423011266352375300147320ustar00rootroot00000000000000 %eclent; ]> System building
Introduction A typical application will consist of multiple lisp files that have to be compiled and which will probably be linked to additional, third party libraries, either written themselves in &CommonLisp; or shipped as foreign C or C++ dynamically or statically linked lirbaries. Not only loading these files into a running &ECL; can be a slow process in some platforms, but shipping code in the form of multiple binaries and a script to load them is far from optimal. Traditionally, &CommonLisp; implemenations have provided a function to save the dump all data from a running Lisp process into a file. The result was called the Lisp image and could be shipped to other version compatible implementations.Nowadays, having less control of the systems it runs in, a Lisp implementation must work very hard to dump memory images and be able to load and execute them afterwards. &ECL; has chosen to avoid this process entirely. Instead, we conceive five different portable models for building and shippin your programs. The models, described in , enumerate the different kinds of files that &ECL; can portably produce. To get one or more of the products mentioned in the table, you may resort to a low level API described in . However, we recommend a simpler way based on using System Definition Files to describe the structure of your project and let &ECL; build the desired target for you. This approach is described in the following sections. Code distribution models Model Description :TYPE :MONOLITHIC Source code You distribute your programs in source code form. This is the easiest and most portable way, but not the fastest one. NA NA &FASL; or loadable file Best suited for development. You translate all lisp code to C and link it against possibly other C/C++ libraries to obtain a single binary file with extension .fas, like the compiled files you obtain from using compile-file. This "unified" &FASL; can be loaded a startup time to add new functionality to the &ECL; environment. :FASL T/NIL Standalone program Product shipping for final user. You translate all your lisp code to C using the &ECL; compiler. The final object files can be linked against other C/C++ libraries to obtain a standalone executable. :PROGRAM T Statically linked library For embedding purposes. You translate all your lisp code to C and combine the resulting object files into a single library with .a or .lib extension. You can distribute this library to other people and the final users can utilize these libraries to build standalone programs. :LIB T/NIL Dynamically linked library For embedding purposes. Similar to a statically linked library, but it is loaded at run time by the operating system and can be shared by more than one instance of a program. :LIB T/NIL
System definition files A System Definition File, or just system, is the lisp equivalent of a makefile in the Unix world: it contains a list of source files which are to be loaded or compiled, and dependencies among them ("load source file1.lsp before compiling file2.lsp", etc). It is difficult to tell about the Lisp Machines history, but probably the first most popular system definition format was called mk-defsystem or simply defsystem. Written by Mark Kantrowitz [], this library now lives in the CLOCC repository and is actively maintained. &ECL; ships with a copy of the version 3.x which fortunately has no customizations. You can load this copy by issuing (require 'defsystem) from the lisp toplevel. However, in the last years, Another System Definition Facility known as &ASDF; has become even more popular in the &CommonLisp; world. This new format simplifies writing extensions to handle new kind of source files and integrates very well with the package management utility known as ASDF-install. &ASDF; has a slightly different syntax from mk-defsystem 3.0, but because of reasons of popularity and better integration with &ECL;, in this manual we have focused on this particular library. A simple &ASDF; definition looks as follows: (defsystem test :source-pathname "~/src/test/" :source-extension "lisp" :components ((:module file1 :source-pathname "") (:module file2 :source-pathname "" :depends-on (file1)))) This example consists of two files, file1.lisp and file2.lisp, located in ~/src/test/. When compiling these files, file1.lisp will be processed before file2.lisp, because the second depends on the former one. There are more complex rules that allow a system to depend on others, and to contain other kind of files, such as C or Java binaries. For further information we recommend reading the online manual. You can load &ASDF; on a running &ECL; using a single lisp statement (require 'asdf). Once loaded, &ASDF; will extend the function require to recognize and load libraries that are placed in standard locations or which have been registered with &ASDF; itself. The following sections describe other features of &ASDF; which are specific to &ECL; and related to the code building and shipping mechanisms introduced before.
Practical examples The version of &ASDF; which is shipped with &ECL; has been further customized to allow building all the binary files mentioned in . The procedure to do this is documented in a detailed and formal manual page for . However, since practice is the best teacher, we will show a couple of examples of how to use this function before moving into the formal specification. In /ecl/examples/asdf you will find a very simple example that can be built in different forms. The example is built around a system definition file that depends on two sources, file1.lisp and file2.lisp: (defsystem #:example :serial t :components ((:file "file1") (:file "file2"))) We can built these files into a single &FASL; file, as shown below. Notice how there is a single file with the name *.fas, but there are two object files generated from their respective sources, file1.o, file2.o. > (require 'asdf) ;;; Loading #P"/home/jlr/lib/ecl/asdf.fas" ("ASDF") > (asdf:make-build :example :type :fasl) ... NIL > (directory "*.o") (#P"/home/jlr/src/ecls-new/examples/asdf/file2.o" #P"/home/jlr/src/ecls-new/examples/asdf/file1.o") > (directory "*.fas") (#P"/home/jlr/src/ecls-new/examples/asdf/example.fas") > (load "example.fas") ;;; Loading "/home/jlr/src/ecls-new/examples/asdf/example.fas" ====================================================================== We are now executing FILE1.LSP TEST-FUNCTION has been created We are now executing FILE2.LSP Calling TEST-FUNCTION in FILE2.LSP 1 + 1 is equal to 2 Finished ====================================================================== "/home/jlr/src/ecls-new/examples/asdf/example.fas" The previous sources may be combined into a single program, as shown below. Notice that we choose to execute ext:quit right after all compiled files have run. If you do not supply this parameter, example will jump to the lisp toplevel right after that. > (asdf:make-build :example :type :program :epilogue-code '(ext:quit 0)) NIL > (ext:system "./example") ====================================================================== We are now executing FILE1.LSP TEST-FUNCTION has been created We are now executing FILE2.LSP Calling TEST-FUNCTION in FILE2.LSP 1 + 1 is equal to 2 Finished ======================================================================
ASDF Reference asdf:make-build Block-build an &ASDF; system definition Function asdf:make-build system-name &key; type monolithic ld-flags prologue-code epilogue-code &allow-other-keys; system-name A symbol naming the system to be built. Only the symbol name is considered. type One of :FASL, :DLL, :LIB or :PROGRAM monolithic A boolean value. ld-flags A list of strings. prologue-code A string. epilogue-code A string or a lisp form. Description This function takes a system definition which is known to &ASDF; and builds one or more binary files, depending on the arguments. The possible output files depend on the value of type and are summarized in . Internally the function works similary to the &ASDF; function asdf:operate with the asdf:load-op operator. It finds out the requested system definition, either by searching in a set of predefined locations or because the system has been already loaded into memory, computes all libraries and components this system depends on, builds them and then produces the desired output. If the value of :monolithic is NIL the output binary will contain just the desired system, while in other cases the output will be linked together with all libraries your system depends on. Standalone executables, as specified by type = :program, are always monolithic, even without specifing this flag. All other systems might be non-monolithic, but in that case you will have to manually satisfy the required dependencies when using those files (unless you use asdf:load-bundle-op in which case asdf will satisfy required dependencies for you automatically). This function takes additional values which are related to the low level details of the produced binaries. First of all we find ld-flags, a list of strings with arguments for the object linker. You will only need this argument if you have to link your programs with foreign libraries. The next two arguments represent two pieces of code which are executed before (prologue-code) and after (epilogue-code) running your lisp code. The prologue code is a string with C code which you will typically use to initialize foreign libraries. It can only be C code because this code may be executed even before &ECL; itself is initialized. The epilogue code, on the other hand, can be either a string with C statements or a lisp form represented as a list. In the case of executables it conveniently defaults to a call to the toplevel (SI::TOP-LEVEL), while in the case of libraries and &FASL; files it is left empty. Examples See . asdf:load-bundle-op Compile and load one ore more libraries using unified &FASL; &ASDF; operator asdf:make-build 'asdf:load-bundle-op system-name &key; &allow-other-keys; system-name A symbol naming the system to be built. Only the symbol name is considered. Description This function is a replacement for the &ASDF; operator ASDF:LOAD-OP. Given a system name, it will build it and all its dependencies, to load them in the required order. The only difference with respect to ASDF:LOAD-OP is that it builds a single &FASL; file per module, thus being potentially faster and more resource efficient. Examples Assume you want to load the &CFFI; library, which has been registered with &ASDF;. You will simply type > (require 'asdf) ;;; Loading #P"/home/jlr/lib/ecl/asdf.fas" ("ASDF") > (asdf:operate 'asdf:load-bundle-op :cffi) ... T
ecl-16.1.2/doc/bibliography.xmlf000066400000000000000000000076401266352375300164770ustar00rootroot00000000000000 %eclent; ]> Bibliography John McCarthy et al. LISP 1.5 Programmer's Manual 2nd ed The M.I.T. Press, Massachussets Institute of Technology, 1985. Available at the Computer History Museum Communities Site ANSI Common Lisp Specification, ANSI/X3.226-1994. American National Standards Institute, 1994. Kent M. Pitman. The Common Lisp Hyperspec. Lispworks, 1996. Available in the Lispworks homepage. Guy L. Steele Jr et al. Common Lisp The Language. Digital Press, 1984. Guy L. Steele Jr. et al. Common Lisp The Language II. Digital Press, 1990. Taichi Yuasa and Masami Hagiya. Kyoto Common Lisp Report. Research Institute for Mathematical Sciences, Kyoto University, 1988. Giusseppe Attardi. The Embeddable Common Lisp. ACM Lisp Pointers, 8(1), 30-41, 1995. Mark Kantrowitz, Portable Utilities for Common Lisp. User Guide & Implementation. Cargnegie Mellon University, 1991. Available in the CMU repository Gregor Kickzales et al. The Art of the Metaobject Protocol The M.I.T. Press, Massachussets Institute of Technology, 1999. ecl-16.1.2/doc/clos.xmlf000066400000000000000000000714211266352375300147620ustar00rootroot00000000000000 %eclent; ]> CLOS
add-method— Generic: add-method generic-function method add-method— Method: add-method (
call-method— Macro: call-method method next-method-list
call-next-method— Macro: call-next-method &rest args
change-class— Generic: change-class instance new-class change-class— Method: change-class ( change-class— Method: change-class (
class-name— Generic: class-name class class-name— Method: class-name (
(setf class-name)— Generic: (setf class-name) new-value class (setf class-name)— Method: (setf class-name) new-value (class class)
class-of— Function: class-of object The function class-of returns the class of which the given object is an instance. The argument to class-of may be any Common-Lisp object.
compute-applicable-methods— Function: compute-applicable-methods generic-function function-arguments
defclass— Macro: defclass class-name (@{superclass-name@}*) ({slot-specifier}*) [class-option] class-name ::= symbol superclass-name ::= symbol slot-specifier ::= slot-name | (slot-name [slot-option]) slot-name ::= symbol slot-option ::= {:reader reader-function-name}* | {:writer writer-function-name}* | {:accessor reader-function-name}* | {:allocation allocation-type} | {:initarg initarg-name}* | {:initform form} | {:type type-specifier} | {:documentation string} reader-function-name ::= symbol writer-function-name ::= function-name function-name ::= symbol |(setf symbol) initarg-name ::= symbol allocation-type ::= :instance | :class class-option ::= (:default-initargs initarg-list) | (:documentation string) | (:metaclass class-name) initarg-list ::= {initarg-name default-initial-value-form}*
defgeneric— Macro: defgeneric function-name lambda-list [option | @{method-description@}*] function-name ::= symbol | (setf symbol) lambda-list ::= ({var}* [&optional {var | (var)}*] [&rest var] [&key {keyword-parameter}* [&allow-other-keys]]) keyword-parameter ::= var | ( {var | (keywordvar )}) option ::= (:argument-precedence-order {parameter-name}+) | (declare {declaration}+) | (:documentation string) | (:method-combination symbol {arg}*) | (:generic-function-class class-name) | (:method-class class-name) method-description ::= (:method {method-qualifier}* specialized-lambda-list [{declaration}* | documentation] {form}*) method-qualifier ::= non-nil-atom specialized-lambda-list ::= ({var | (var parameter-specializer-name)}* [&optional {var | (var [initform [supplied-p-parameter]])}*] [&rest var] [&key {specialized-keyword-parameter}* [&allow-other-keys]]) [&aux {var | (var [initform])}*] ) specialized-keyword-parameter ::= var | {({var | (keywordvar)} [initform [supplied-p-parameter]])}* parameter-specializer-name ::= symbol | (eql eql-specializer-form)
define-method-combination— Macro: define-method-combination name [short-form-option] define-method-combination— Macro: define-method-combination name lambda-list (@{method-group-specifier@}*) [(:arguments . lambda-list)] [(:generic-function generic-fn-symbol)] [@{declaration@}* | doc-string] @{form@}* short-form-option ::= :documentation string | :identity-with-one-argument boolean | :operator operator method-group-specifier ::= (variable {qualifier-pattern}+ | predicate [long-form-option]) long-form-option ::= :description format-string | :order order | :required boolean
defmethod— Macro: defmethod function-name @{method-qualifier@}+ specialized-lambda-list [@{declaration@}* | doc-string] @{form@}* function-name ::= symbol | (setf symbol) method-qualifier ::= non-nil-atom parameter-specializer-name ::= symbol | (eql eql-specializer-form )
documentation— Generic: documentation x &optional doc-type documentation— Method: documentation ( documentation— Method: documentation ( documentation— Method: documentation ( doumentation— Method: doumentation ( documentation— Method: documentation ( documentation— Method: documentation ( documentation— Method: documentation (
(setf documentation)— Generic: (setf documentation) new-value x &optional doc-type (setf documentation)— Method: (setf documentation) new-value (method standard-method) @optional{} doc-type (setf documentation)— Method: (setf documentation) new-value (class standard-class) @optional{} doc-type (setf documentation)— Method: (setf documentation) new-value (method-combination method-combination) (setf documentation)— Method: (setf documentation) new-value (slot-description standard-slot-description) @optional{} doc-type (setf documentation)— Method: (setf documentation) new-value (symbol symbol) @optional{} doc-type (setf documentation)— Method: (setf documentation) new-value (list list) @optional{} doc-type
ensure-generic-function— Function: ensure-generic-function {function-name &key lambda-list &key :argument-precedence-order :declare :documentation :generic-function-class|ekeys:method-combination :method-class :environment} function-name ::= symbol | (setf symbol)
find-class— Function: find-class symbol @optional{} errorp environment The function find-class returns the class object named by the given symbol in the given environment. The first argument to find-class is a symbol.
find-method— Generic: find-method generic-function method-qualifiers specializers &optional errorp find-method— Method: find-method ( method-qualifiers specializers &optional errorp
function-keywords— Generic: function-keywords method function-keywords— Method: function-keywords (
The generic function function-keywords is used to return the keyword parameter specifiers for a given method.
generic-function— Macro: generic-function {lambda-list \mchoiceoption | @{method-description@}*} option ::= (:argument-precedence-order {parameter-name}+) | (declare {declaration}+) | (:documentation string) | (:method-combination symbol {arg}*) | (:generic-function-class class-name) | (:method-class class-name) method-description ::= (:method {method-qualifier}* specialized-lambda-list {declaration | documentation}* {form}*) The generic-function macro creates an anonymous generic function. The generic function is created with the set of methods specified by its method descriptions. The option, method-qualifier, and specialized-lambda-list arguments are the same as for defgeneric. The generic function object is returned as the result. If no method descriptions are specified, an anonymous generic function with no methods is created. See defgeneric, generic-flet, generic-labels, defmethod.
initialize-instance— Generic: initialize-instance instance &rest initargs initialize-instance— Method: initialize-instance ( The generic function initialize-instance is called by make-instance to initialize a newly created instance. The generic function initialize-instance is called with the new instance and the defaulted initialization arguments.
invalid-method-error— Function: invalid-method-error method format-string @rest{} args The function invalid-method-error is used to signal an error when there is an applicable method whose qualifiers are not valid for the method combination type. The error message is constructed by using a format string and any arguments to it. Because an implementation may need to add additional contextual information to the error message, invalid-method-error should be called only within the dynamic extent of a method combination function. The function invalid-method-error is called automatically when a method fails to satisfy every qualifier pattern and predicate in a define-method-combination form. A method combination function that imposes additional restrictions should call invalid-method-error explicitly if it encounters a method it cannot accept.
make-instance— Generic: make-instance class &rest initargs make-instance— Method: make-instance ( make-instance— Method: make-instance ( The generic function make-instance creates and returns a new instance of the given class. The generic function make-instance may be used as described in section 1.9. The class argument is a class object or a symbol that names a class. The remaining arguments form a list of alternating initialization argument names and values. If the second of the above methods is selected, that method invokes make-instance on the arguments (find-class class) and initargs. The initialization arguments are checked within make-instance (see section 1.9). The new instance is returned.
make-instances-obsolete— Generic: make-instances-obsolete class make-instances-obsolete— Method: make-instances-obsolete ( make-instances-obsolete— Method: make-instances-obsolete (
method-combination-error— Function: method-combination-error format-string @rest{} args The function method-combination-error is used to signal an error in method combination. The error message is constructed by using a format string and any arguments to it. Because an implementation may need to add additional contextual information to the error message, method-combination-error should be called only within the dynamic extent of a method combination function. The format-string argument is a control string that can be given to format, and args are any arguments required by that string.
method-qualifiers— Generic: method-qualifiers method method-qualifiers— Method: method-qualifiers ( The generic function method-qualifiers returns a list of the qualifiers of the given method.
next-method-p— Function: next-method-p The locally defined function next-method-p can be used within the body of a method defined by a method-defining form to determine whether a next method exists.
no-applicable-method— Generic: no-applicable-method generic-function &rest function-arguments no-applicable-method— Method: no-applicable-method ( The generic function no-applicable-method is called when a generic function of the class standard-generic-function is invoked and no method on that generic function is applicable. The default method signals an error.
no-next-method— Generic: no-next-method generic-function method &rest args no-next-method— Method: no-next-method (
print-object— Generic: print-object object stream print-object— Method: print-object ( The generic function print-object writes the printed representation of an object to a stream. The function print-object is called by the print system; it should not be called by the user.
reinitialize-instance— Generic: reinitialize-instance instance &rest initargs reinitialize-instance— Method: reinitialize-instance ( The generic function reinitialize-instance can be used to change the values of local slots according to initialization arguments. This generic function is called by the Meta-Object Protocol. It can also be called by users.
remove-method— Generic: remove-method generic-function method remove-method— Method: remove-method ( The generic function remove-method removes a method from a generic function. It destructively modifies the specified generic function and returns the modified generic function as its result.
shared-initialize— Generic: shared-initialize instance slot-names &rest initargs shared-initialize— Method: shared-initialize ( The generic function shared-initialize is used to fill the slots of an instance using initialization arguments and :initform forms. It is called when an instance is created, when an instance is re-initialized, when an instance is updated to conform to a redefined class, and when an instance is updated to conform to a different class. The generic function shared-initialize is called by the system-supplied primary method for initialize-instance, reinitialize-instance, update-instance-for-redefined-class, and update-instance-for-different-class.
slot-boundp— Function: slot-boundp instance slot-name The function slot-boundp tests whether a specific slot in an instance is bound. The arguments are the instance and the name of the slot.
slot-exists-p— Function: slot-exists-p object slot-name The function slot-exists-p tests whether the specified object has a slot of the given name. The object argument is any object. The slot-name argument is a symbol.
slot-makunbound— Function: slot-makunbound instance slot-name The function slot-makunbound restores a slot in an instance to the unbound state. The arguments to slot-makunbound are the instance and the name of the slot.
slot-missing— Generic: slot-missing class object slot-name operation &optional new-value slot-missing— Method: slot-missing ( The generic function slot-missing is invoked when an attempt is made to access a slot in an object whose metaclass is standard-class and the name of the slot provided is not a name of a slot in that class. The default method signals an error.
slot-unbound— Generic: slot-unbound class instance slot-name slot-unbound— Method: slot-unbound ( The generic function slot-unbound is called when an unbound slot is read in an instance whose metaclass is standard-class. The default method signals an error.
slot-value— Function: slot-value object slot-name The function slot-value returns the value contained in the slot slot-name of the given object. If there is no slot with that name, slot-missing is called. If the slot is unbound, slot-unbound is called. The macro setf can be used with slot-value to change the value of a slot.
update-instance-for-different-class— Generic: update-instance-for-different-class previous current &rest initargs update-instance-for-different-class— Method: update-instance-for-different-class (
update-instance-for-redefined-class— Generic: update-instance-for-redefined-class instance added-slots discarded-slots property-list &rest initargs update-instance-for-redefined-class— Method: update-instance-for-redefined-class (
with-accessors— Macro: with-accessors ( The macro with-accessors creates a lexical environment in which specified slots are lexically available through their accessors as if they were variables. The macro with-accessors invokes the appropriate accessors to access the specified slots. Both setf and setq can be used to set the value of the slot. The result returned is that obtained by executing the forms specified by the body argument.
with-slots— Macro: with-slots ( slot-entry ::= slot-name | (variable-name slot-name) The macro with-slots creates a lexical context for referring to specified slots as though they were variables. Within such a context the value of the slot can be specified by using its slot name, as if it were a lexically bound variable. Both setf and setq can be used to set the value of the slot.
ecl-16.1.2/doc/compiler.xmlf000066400000000000000000000237571266352375300156450ustar00rootroot00000000000000 %eclent; ]> The Compiler The &ECL; compiler translates a Lisp program stored in a source file into a C program, invokes the C compiler to compile the C program, and then generates an object file, called fasl file (or o-file because of the actual filetype). The compiled program in a fasl file is loaded by the function load. Ordinarily, the object program generated by the &ECL; compiler scarcely does runtime error-checking for runtime efficiency. In addition, Lisp functions in the same source file are linked together and some system functions are open-coded in-line. To control runtime error checking, supply appropriate optimize declarations (see Section 7.1). The &ECL; compiler processes the eval-when special form exactly as specified in &Steele84; (see Section 5.3.3 of &Steele84;). The &ECL; compiler is invoked by the functions compile-file, compile, and disassemble described below. In addition, the &ECL; compiler may be invoked directly by the Shell commands ecl. This command requires the file name of the source file as its argument. ecl simply adds .lsp to the file name argument to obtain the full name of the source file. $ ecl filename has the same effect as the compiler invocation (compile-file filename) from within &ECL;, and $ ecl -C filename has the same effects as (compile-file filename :c-file t :h-file t :data-file t).
compile-file— Function: compile-file pathname &key :output-file :verbose :print :c-file :h-file :data-file compile-file compiles the Lisp program stored in the file specified by pathname, and generates a binary file. If :verbose is true, a message indicating what file is being compiled is printed. If :print is true, information about top-level forms in the file being compiled is printed. compile-file generates the following temporary files: Temporary File Contents c-file C version of the Lisp program h-file The include file referenced in the c-file data-file The Lisp data to be used at load time If files of these names already exist, the old files will be deleted first. Usually, these intermediate files are automatically deleted after execution of compile-file. The input-file is determined in the usual manner (see Section 2.9), except that, if the filetype is not specified, then the default filetype .lsp will be used. The keyword parameter :output-file defines the default directory and the default name to be applied to the output files (i.e., the fasl file and the temporary files). :output-file itself defaults to input-pathname. That is, if :output-file is not supplied, then the directory and the name of the input file will be used as the default directory and the default name for the output files. The file types of the output files are fixed as follows. Output File Filetype fasl file .o c-file .c h-file .h data-file .data Each output file can be specified by the corresponding keyword parameter. If the value of the keyword parameter is (), then the output file will be deleted after execution of compile-file. If the value of the keyword parameter is T, then the output file will be left in the default directory under the default name. Otherwise, the output file will be left in the directory under the name specified by the keyword parameter. The default value of :output-file is T, and the default values of :c-file, ::h-file, and :data-file are all (). (compile-file 'foo) The source file is FOO.lsp and the fasl file is FOO.o both in the current directory. (compile-file 'foo.lish) The source file is FOO.LISH and the fasl file is FOO.o'. (compile-file "/usr/mas/foo" :output-file "/usr/tai/baa") The source file is foo.lsp in the directory /usr/mas, and the fasl file is baa.o in the directory /usr/tai.
compile— Function: compile name code &optional definition If definition is not supplied, name should be the name of a not-yet-compiled function. In this case, compile compiles the function, replaces the previous definition of name with the compiled function,and returns name. If definition is supplied, it should be a lambda-expression to be compiled and name should be a symbol. If name is a non-() symbol, then compile installs the compiled function as the function definition of name and returns name. If name is (), then compile simply returns the compiled function. The &ECL; compiler is essentially a file compiler, and forms to be compiled are supposed to be stored in a file. Thus compile actually creates a source file which contains the form designated by the arguments. Then compile calls compile-file to get a fasl file, which is then loaded into &ECL;. The source file and the fasl file are given the names gazonk.lsp and gazonk.fasl, respectively. These files are not deleted automatically after the execution of compile.
disassemble— Function: disassemble &optional thing &key :h-file :data-file This function does not actually disassemble. It always calls the &ECL; compiler and prints the contents of the c-file, i.e., the C-language code, generated by the &ECL; compiler. If thing is not supplied, or if it is (), then the previously compiled form by disassemble will be compiled again. If thing is a symbol other than (), then it must be the name of a not-yet-compiled function, whose definition is to be compiled. In this case, it is an error if the name is associated with a special form or a macro. If thing is a lambda-expression (lambda lambda-list . body), then disassemble first creates a function definition (defun gazonk lambda-list . body) and this definition is compiled. (The function name gazonk has no special meanings. Indeed, the displayed code is essentially independent of the function name.) Otherwise, thing itself will be compiled as a top-level form. In any case, disassemble does not install the compiled function. disassemble returns no value. No intermediate h-file is created if the keyword parameter :h-file is () or if :h-file is not supplied. Otherwise, an intermediate h-file is created under the name specified by :h-file. Similarly, the intermediate data-file is specified by the keyword parameter :data-file.
ecl-16.1.2/doc/copyright.xmlf000066400000000000000000000032141266352375300160250ustar00rootroot00000000000000 Copyright ---- BEGINNING OF COPYRIGHT FOR THE ECL CORE ENVIRONMENT ------------ Copyright (c) 2015, Daniel KochmaХ„ski Copyright (c) 2000, Juan Jose Garcia Ripoll Copyright (c) 1990, 1991, 1993 Giuseppe Attardi Copyright (c) 1984 Taiichi Yuasa and Masami Hagiya All Rights Reserved ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version; see file 'Copying'. 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 Library General Public License for more details. You should have received a copy of the GNU Library General Public License along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. PLEASE NOTE THAT: This license covers all of the ECL program except for the files src/lsp/loop2.lsp ; Symbolic's LOOP macro src/lsp/pprint.lsp ; CMUCL's pretty printer src/lsp/format.lsp ; CMUCL's format and the directories contrib/ ; User contributed extensions src/clx/ ; portable CLX library from Telent Look the precise copyright of these extensions in the corresponding files. Report bugs, comments, suggestions to the ecl mailing list: ecls-list@lists.sourceforge.net. ---- END OF COPYRIGHT FOR THE ECL CORE ENVIRONMENT ------------------ ecl-16.1.2/doc/declarations.xmlf000066400000000000000000000712741266352375300165000ustar00rootroot00000000000000 %eclent; ]> Declarations &ECL; supports all kinds of declarations described in the &Steele84;. Any valid declaration will affect the &ECL; environment in some way or another, although information obtained by declarations, other than special declarations, is mainly used by the &ECL; compiler. As described in &Steele84;, Common-Lisp declarations are divided into two classes: proclamations and others. A proclamation is a global declaration given by the function proclaim, the top-level macro defvar, or the top-level macro defparameter. Once given, a proclamation remains effective during the &ECL; session unless it is shadowed by a local declaration or is canceled by another proclamation. Any other declaration is a local declaration and is given only by the special form declare. A local declaration remains in effect only within the body of the construct that surrounds the declaration. In the following nonsensical example borrowed from Chapter 9 of &Steele84;, (defun nonsense (k x z) (foo z x) (let ((j (foo k x)) (x (* k k))) (declare (inline foo) (special x z)) (foo x j z))) the inline and the special declarations both remain in effect within the surrounding let form. In this case, we say that the let form is the surrounding construct of these declarations.
the— Special Form: the value-type form The &ECL; interpreter does actually check whether the value of the form conforms to the data type specified by value-type and signals an error if the value does not. The type checking is performed by the function typep. For example,
(the fixnum (foo)) is equivalent to (let ((values (multiple-value-list (foo)))) (cond ((endp values) (error ``Too few return values.")) ((not (endp (cdr values))) (error ``Too many return values.")) ((typep (car values) 'fixnum) (car values)) (t (error ``~s is not of type fixnum." (car values))))) On the other hand, the &ECL; compiler uses the special form to obtain type information for compiled code optimization. No code for runtime type-checking is embedded in the compiled code.
Declaration Specifiers &ECL; recognizes all declaration specifiers defined in &Steele84;. The syntax of each such declaration specifier is exactly the same as defined in &Steele84;. In addition, &ECL; recognizes the object declaration specifier which is specific to &ECL;.
special— Declaration: special {variable-name}* The interpreter and the compiler of &ECL; both treat special declarations exactly as described in &Steele84;.
type— Declaration: type type {variable-name}* A type proclamation (type type var1 var2 ...) specifies that the dynamic values of the named variables are of the type type. A local type declaration specifies that the variables mentioned are bound by the surrounding construct and have values of the type type during execution of the surrounding construct. The compiler issues a warning if one of the named variables is not bound by the surrounding construct. The information given by type declarations is used by the compiler to optimize the compiled code. The behavior of the compiled code is unpredictable if a wrong type declaration is supplied. The compiler detects certain wrong type declarations at compile time.
For example, >(defun foo (x y) (declare (fixnum x) (character y)) (setq x y) ...)) foo >(compile 'foo) ; (defun foo ...) is being compiled. ;; Warning: Type mismatches between x and y. See Section 7.3 for further information on type declarations.
type— Declaration: type {variable-name}* (type var1 var2 ...) is equivalent to (type type var1 var2 ...), provided that type is one of the symbols in Table 4-1 of &Steele84;, other than function. Declaration specifications that begin with function are regarded as function declarations (see below).
function— Declaration: function function-name argument-types . return-types A function declaration is used to obtain type information for function call forms. That is, a function declaration specifies the argument and the return types of each form that calls the named function.
(defun foo () (declare (function bar (character) fixnum)) (+ (bar (atcholi1)) (bar (atcholi2)))) In this example, the function declaration specifies that the two functions atcholi1 and atcholi2 both return character objects when called within the body of foo, and that the function bar returns fixnum objects when called within the body of foo. The type information given by function declarations is used by the compiler to optimize the compiled code. The behavior of the compiled code is unpredictable if a wrong function declaration is supplied. The compiler detects certain wrong function declarations at compile time. For example, >(defun foo (x) (declare (fixnum x) (function bar (character) fixnum)) (bar x)) foo >(compile 'foo) ; (defun foo ...) is being compiled. ;; Warning: The type of the form x is not character. However, the compiler does not check the number of arguments, and thus, the following function definition will be compiled successfully without any warnings. (defun foo () (declare (function bar (character character) fixnum)) (+ (bar (atcholi1)) (bar (atcholi2) (atcholi3) (atcholi4)))) For this definition, the compiler assumes that the three functions atcholi1, atcholi2, and atcholi3 will return fixnum objects. The return type of atcholi4 is unknown at compile time. The complete syntax of a function declaration is: (function function-name ({type}* [{&optional | &rest | &key} {thing}*]) {(values {type}* ) | {type}*} ) Although &optional, &rest, and &key markers may appear in the list of argument types, only those types are recognized that appear before any such markers and the rest of the list is simply ignored. Note that functions with &optional, &rest, or &key parameters may still be declared by function declarations because of the use of function declarations mentioned above. The values construct in the specification of return types is almost useless: (function function-name argument-types (values type1 type2 …)) is equivalent to (function function-name argment-types type1 type2 …). See Section 7.3 for further information on function declarations.
ftype— Declaration: ftype function-type {function-name}* function-type must be a list whose first element is the symbol function. (ftype (function . rest) function-name-1 ... function-name-n) is equivalent to n consecutive function declarations (function function-name-1 . rest) ... (function function-name-n . rest).
notinline— Declaration: notinline {function-name}* (notinline function1 function2 ...) specifies that the compiler should not compile the named functions in-line. Calls to the named functions can be traced and an event (see Section 5.4) is pushed on the event stack when any one of the named functions is invoked.
inline— Declaration: inline {function-name}* An inline proclamation cancels currently effective notinline proclamations, and a local inline declaration locally shadows currently effective notinline declarations.
>(defun foo (x) (cons (car x) (locally (declare (inline car)) (car x)))) foo >(defun bar (x) (cons (car x) (locally (declare (inline car)) (car x)))) foo >(proclaim '(notinline car)) nil >(compile 'foo) ... >(proclaim '(inline car)) nil >(compile 'bar) ... Usually, primitive functions such as car are compiled in-line. Therefore, in this example, only the first call to car within foo is compiled not in-line. In general, the &ECL; compiler compiles functions in-line whenever possible. Thus an inline declaration (inline function1 function2 ...) is worthless if none of the named functions have previously been declared to be notinline.
ignore— Declaration: ignore {variable-name}* Usually, the compiler issues a warning if a lexical variable is never referred to. (ignore var1 ... varn) causes the compiler not to issue a warning even if the named variables are never referred to. The compiler issues a warning if one of the named variables is not bound by the surrounding construct, or if a named variable is actually referred to. ignore proclamations are simply ignored.
optimize— Declaration: optimize {(quality value) | quality}* &ECL; supports the four optimize qualities listed in the &Steele84;. speed and compilation-speed are used to set up the optimization switch of the C language compiler which is invoked to compile the C-language code generated by the &ECL; compiler (see Chapter 6). (optimize (speed n)) and (optimize (compilation-speed m)) are equivalent, where n and m are integers between 0 and 3, and m is equal to 3-n. When a &ECL; session is started, the speed quality is set to 3. That is, by default, the compiler generates the fastest code in the longest compilation time. The space quality specifies whether the code size is important or not: The compiled code is a little bit larger and faster when compiled with the space quality 0, than when compiled with the space quality 1, 2, or 3. When a &ECL; session is started, the space quality is set to 0. The safety quality determines how much runtime error checking code should be embedded in the compiled code. If the safety quality is 0, the compiled code scarcely does runtime error checking. If the safety quality is 1, then the compiled code for a function will check the number of arguments to the function at runtime. If the safety quality is 2 or 3, then the compiled code does full runtime error checking. In addition, the highest quality value 3 causes the compiler to treat all functions as if they were declared to be notinline. When a &ECL; session is started, the safety quality is set to 0.
declaration— Declaration: declaration {name}* A declaration declaration is used exactly as specified in the &Steele84;.
object— Declaration: object {variable-name}* This is the only declaration specifier that is specific to &ECL;. (object var1 ... varn) affects only variable bindings and specifies that the named variables can be allocated in the C stack (see Section 7.3). The compiler issues a warning if one of the named variables is not bound by the surrounding construct. object proclamations are simply ignored.
Significant Type Specifiers Whenever a declaration is encountered, each type specifier (if any) in the declaration is converted to one of the following type specifiers, which are collectively called the significant type specifiers. Here, the lines indicate subtype relations; the right type is a subtype of the left type. For instance, (vector t) is a subtype of (array t) and T, and (array t) itself is a subtype of T. However, (array t) and (array string-char) are disjoint types. The function subtypep is used for the conversion to significant type specifiers: If the first value of (subtypep raw-type type) is T for one of the significant type specifiers type, then the type specifier raw-type in the declaration is converted to type. If there are more than one such significant type specifiers, then the type specifier that is a subtype of other specifiers is selected. For example, type specifiers fixnum, (mod 3), and (member 0 1) are all converted to fixnum, though they are also subtypes of T. Because of this type specifier conversion, &ECL; may sometimes regard two seemingly distinct declarations as the same. For example, the following type declarations are completely equivalent, internally in &ECL;. (declare (type fixnum x))) (declare (type (mod 3) x)) (declare (type (member 0 1) x)) Type specifiers in declaration specifications passed to the &ECL; specific function proclamation are also converted to significant type specifiers. Thus, for example, >(proclaim '(function foo (fixnum) fixnum)) nil >(proclamation '(function foo ((mod 3)) (member 0 1))) t >(proclamation '(function foo (number) character)) nil The first call to proclamation returns T because both (mod 3) and (member 0 1) are converted to fixnum before the function type of foo is checked.
Treatment of Type Declarations &ECL; uses several runtime stacks. Arguments to functions, lexical and temporary variables are allocated on the C stack. Temporary values saved on the C stack may sometimes be represented as raw data instead of pointers to heap-allocated cells. Accessing such raw data on the C stack results in faster compiled code, partly because no pointer dereferencing operation is necessary, and partly because no cell is newly allocated on the heap when a new object is created. This is particularly helpful for numeric code which computes with floating point numbers. &ECL; uses a conservative garbage collector to scan the C stack and find references to live object.
Variable Allocations If a lexical variable is declared to be of fixnum, character, short-float, long-float, or their subtypes, then it is allocated on the C stack rather than on the value stack. In addition, the variable always has a raw datum as its value: 32 bit signed integer for fixnums, 8 bit character code with 24 bit padding for characters (remember that the font and bit fields of &ECL; characters are always 0), 32 bit floating point representation for short-floats, and 64 bit floating point representation for long-floats. Similarly, if a lexical variable is named in an object declaration (see Section 7.1), then it is allocated on the C stack but, in this case, the variable always has a cell pointer as its value. The user is strongly recommended to make sure that objects stored in such an object variable may never be garbage collected unexpectedly. For example, (do ((x (foo) (cdr x))) ((endp x)) (let ((y (car x))) (declare (object y)) (bar y))) this object declaration is completely safe because the value of the variable y is always a substructure of the value of x, which in turn is protected against garbage collection. Incidentally, loop variables of dolist may always be declared as object variables, since the dolist form has essentially the same control structure as the do form above. On the other hand, the result of evaluation of the following form is unpredictable, because the cons cell pointed to from the object variable z may be garbage collected before bar is called. (let ((z (cons x y))) (declare (object z)) (foo (cons x y)) (bar z)) Lexical variables that are not declared to be of fixnum, character, short-float, long-float, or their subtypes, and that are not named in object declarations are usually allocated on the value stack, but may possibly be allocated on the C stack automatically by the compiler.
Built-in Functions that Operate on Raw Data Directly Some built-in Common-Lisp functions can directly operate on raw data, if appropriate declarations are supplied. The addition function + is among such functions. (let ((x 1)) (declare (fixnum x)) ... (setq x (+ x 2)) ... ) In the compiled code for this let form, the raw fixnum datum (i.e., the 32 bit signed integer) stored in x is simply incremented by 2 and the resulting 32 bit signed integer is stored back into x. The compiler is sure that the addition for 32 bit signed integers will be performed on the call to +, because the arguments are both fixnums and the return value must be also a fixnum since the value is to be assigned to the fixnum variable. The knowledge of both the argument types and the return type is necessary for this decision: Addition of two fixnums may possibly produce a bignum and addition of two bignums may happen to produce a fixnum value. If either the argument type or the return type were not known to the compiler, the general addition function would be called to handle the general case. In the following form, for example, the compiler cannot be sure that the return value of the multiplication is a fixnum or that the arguments of the addition are fixnums. (setq x (+ (* x 3) 2)) In order to obtain the optimal code, a the special form should surround the multiplication. (setq x (+ (the fixnum (* x 3)) 2)) Built-in Common-Lisp functions that can directly operate on raw data are: arithmetic functions such as +, -, 1+, 1-, *, floor, mod, /, and expt. predicates such as eq, eql, equal, zerop, plusp, minusp, =, /=, <, <=, >, >=, char=, char/=, char<, char<=, char>, and char>=. sequence processing functions that receive or return one or more fixnum values, such as nth, nthcdr, length, and elt. array access functions such as svref, char, schar, and aref (see below). system-internal functions for array update (see below). type-specific functions such as char-code, code-char, and float. As mentioned in Section 2.5.1, array elements are represented in one of six ways depending on the type of the array. By supplying appropriate array type declarations, array access and update operations can handle raw data stored in arrays. For example, (let ((a (make-array n :element-type 'fixnum)) (sum 0)) (declare (type (array fixnum) a) (fixnum sum)) (dotimes (i n) ;;; Array initialization. (declare (fixnum i)) (setf (aref a i) i)) .... (dotimes (i n) ;;; Summing up the elements. (declare (fixnum i)) (setq sum (+ (aref a i) sum))) .... ) The setf form replaces the i-th element of the array a by the raw fixnum value of i. The aref form retrieves the raw fixnum datum stored in a. This raw datum is then added to the raw fixnum value of the fixnum variable sum, producing the raw fixnum datum to be stored in sum. Similar raw data handling is possible for arrays of types (array fixnum), (vector fixnum), (array string-char), string, (array short-float), (vector short-float), (array long-float), and (vector long-float).
Arguments/Values Passing Function proclamations (function function-name (arg-type1 arg-type2 ...) return-type) or its equivalents give the compiler the chance to generate compiled code so that arguments to the named functions and resulting values of the named functions will be passed via the C stack, thus increasing the efficiency of calls to these functions. Such arguments/values passing via the C stack is possible only if the called function is also defined in the same source file. This is because the code for the called function must have two entries: One entry for C arguments/values passing and another for ordinary Lisp arguments/values passing. (An ordinary function has only the latter entry.) When the latter entry is used, the arguments are unboxed and passed to the former entry. On return from the function, the resulting value is cast into a Lisp data type. A good example of this follows. (eval-when (compile) (proclaim '(function tak (fixnum fixnum fixnum) fixnum))) (defun tak (x y z) (declare (fixnum x y z)) (if (not (< y x)) z (tak (tak (1- x) y z) (tak (1- y) z x) (tak (1- z) x y)))) ;;; Call (tak 18 12 6). When tak is called with the arguments 18, 12, and 6, the raw fixnum data of the arguments are set to the parameters x, y, z. After that, only raw C data are used to perform the execution: No cell pointers are newly allocated nor even referenced. The built-in functions < and 1- directly operate on the raw data. Only at the return from the top-level call of tak, the resulting raw data value (which happens to be 7) is reallocated on the heap. Note that both the function proclamation and the local fixnum declaration are necessary to obtain the optimal code. The function proclamation is necessary for arguments/values passing via the C stack and the fixnum declaration is necessary to unbox the parameters into C variables.
ecl-16.1.2/doc/discarded.xmlf000066400000000000000000000030071266352375300157370ustar00rootroot00000000000000 ANSI Common Lisp Specification, ANSI/X3.226-1994. ANSI, 1994. Kent M. Pitman. Common Lisp HypersSpec, http://www.lisp.org/HyperSpec/FrontMatter/index.html Guy L. Steel Jr.. Common Lisp: the Language. Digital Press, 1984. Guy L. Steel Jr.. Common Lisp: the Language II. Digital Press, 1990. Taiichi Yuasa and Masami Hagiya. Kyoto Common-Lisp Report, Research Institute for Mathematical Sciences, Kyoto University, 1988. ecl-16.1.2/doc/ecl.css000066400000000000000000000017501266352375300144050ustar00rootroot00000000000000html { background: #FFF; } body { margin: 1em 125px 0 10%; line-height: 1.5em; padding: 0 2em 1em 2em; background: #FFF; font: 12px Verdana,Arial, sans-serif } ul, dd, dl, dt { margin-top: 0; margin-bottom: 0; } p, code, td, dl, dt { line-height: 1.5em; } table { font: inherit; } th, td { vertical-align: top; } h1, h2, h3, h4, h5 { background: #EEE; } code, pre { font-size: 1em; font-family: fixed; } pre { line-height: 1em; overflow: auto; } pre.screen { font-weight: bold; background: #EEE; border: 1px solid black; padding: 0.5em; } pre.programlisting { background: #EEEEEE; border-left: 1px solid black; border-top: 1px solid black; padding: 0.5em; } a { color: #000; font-weight: bold; } div p { padding: 0 2em } li p { padding: 0; margin: 0 } hr { display: none; } div.funcsynopsis p { text-indent: -2em; } div.variablelist { padding: 0 2em; } .type, .funcsynopsis, .symbol { font-family: fixed; } .type, .symbol, .replaceable { white-space: nowrap; } ecl-16.1.2/doc/ecl.ent000066400000000000000000000064341266352375300144070ustar00rootroot00000000000000 ECL"> CMUCL"> SBCL"> FFI"> UFFI"> CFFI"> ASDF"> FASL"> "> "> CLOS"> PCL"> "> "> UFFI"> FFI"> Lispworks"> OpenMCL"> MCL"> AllegroCL"> T"> NIL"> NULL"> C"> defsystem"> Cygwin"> Mingw"> [Only in Common Lisp]"> nil"> t">ecl-16.1.2/doc/ecl.html000066400000000000000000000000001266352375300145440ustar00rootroot00000000000000ecl-16.1.2/doc/ecl.xml000066400000000000000000000123531266352375300144160ustar00rootroot00000000000000 %eclent; ]> The &ECL; manual Juan JoseGarcia-Ripoll DanielKochmaХ„ski $date$ Standards Syntax Iteration Extensions and Libraries UFFI Reference Common Lisp symbols C/C++ index ecl-16.1.2/doc/ecldev.xmlf000066400000000000000000002576301266352375300152740ustar00rootroot00000000000000 %eclent; ]> Internals &ECL; is an implementation of the Common-Lisp language that is based on a kernel written in C plus a set of libraries written in Common-Lisp. The kernel includes a bytecodes compiler, an interpreter, and enough functions to create and manipulate all lisp objects. The lisp libraries provide higher level constructs such as macro definitions, LOOPs, an implementation of CLOS, and a translator from Lisp to C. As a result of this design, which dates back to the Kyoto CL and was later improved in Giuseppe Attardi's ECoLisp, &ECL; can be used as As a standalone implementation of the Common-Lisp language As an embedded interpreter subject to the control of a larger C program. As a Common-Lisp environment with C/C++ extensions. This manual describes the facility of &ECL; to interface the C language and &ECL;. With this facility, the user can arrange his or her C-language programs so that they can be invoked from &ECL;. In addition, the user can write Lisp function definitions in the C language to increase runtime efficiency.
Building programs In this section we describe how you can use &ECL; to build programs and loadable extensions that you can later on distribute to other people. What can &ECL; do? Some day for some reasons you will be in the need to distribute code that has been developed using &ECL;. In the following sections we will describe the means that &ECL; offers you to do so. Basically, these are the alternatives Source code You distribute your programs in source code form. This is the easiest and most portable way, but not the fastest one. Standalone programs You translate all your lisp code to C using the &ECL; compiler. The final object files can be linked against other C/C++ libraries to obtain a standalone executable. You can build statically and dynamically linked libraries. You translate all your lisp code to C and combine the resulting object files into a single library with .a extension. You can distribute this library to other people and the final users can utilize these libraries to build standalone programs. You can build dynamically loadable files. This is the most flexible way. You translate all lisp code to C and link it against possibly other C/C++ libraries to obtain a dynamically loadable library (file type .so under unix). This library can be loaded a startup time to add new functionality to the &ECL; environment. In several of these options, we have mentioned the possibility to include C/C++ code. Even if this is possible, you cannot use ordinary C/C++ compilers and makefiles to build &ECL; extensions, let it be programs or libraries. Briefly, you have to organize your code as follows Organize the C code as a library, let it be static or dynamic. Build a function, say mymain(), in which the initialization phase for your library is performed. Group the code that interfaces to Lisp in separate C files, all of which should include #include <ecl/ecl.h> at the beginning. Compile your lisp source files. Let &ECL; build the final executable or library. In the final step there are ways to instruct &ECL; to call your initialization function (mymain() in the example above). These means are explained in the following sections. Compiling files &ECL; supports two types of compilation. One is bytecodes compilation. This process is performed on-the-fly, as you load source files with lisp code. This leads to a series of bytes for each instruction, the so called "bytecodes". These bytecodes are interpreted in a virtual machine, which is written in C and which is reasonably fast. The other type of compilation is the so-called "native" compilation. This process consists on translating the lisp source file to C language. The intermediate file is later compiled using a C compiler. The result is an object file which may have different purposes. Dynamically loadable files or FASL (FASt Loadable) files These are produced in a &ECL; built with support for dynamically loadable libraries (Feature :DLOPEN is in *features*), when no extra arguments are passed to compile-file. These object files typically have the .fas extension, and can be loaded with load. They cannot be used to build libraries nor standalone executable programs. linkable object files These are produced when invoking compile-file with the keyword argument :system-p set to true. The object file typically has the .o extension. It cannot be loaded with load, but it can be used to build libraries, standalone executable programs, or larger FASL files. Building standalone executables To build an executable you need a working &ECL; image with the compiler. The function to build customized images is c::build-program. The description of this function is as follows. Care should be taken that image-name differs from any filename in lisp-files.
c:build-program— Function: c:build-program {image-name &key lisp-files ld-flags prologue-code epilogue-code} This function builds a lisp image up from the core lisp library, plus all components listed in lisp-files. Each component is either: A symbol: Names a statically linked library built from lisp code. A string: Denotes an object file built from lisp code. ld-flags is a list of strings with additional parameters to be passed to the linker. You can include here your favorite C/C++ libraries. prologue-code and epilogue-code are used to customize the initialization process of the lisp image. In order to build the executable, c:build-program first writes down a piece of C code which initializes the lisp environment. You can customize the initialization process by suppling code to be executed before (prologue-code) or after (epilogue-code) setting up the lisp environment. Typically prologue-code defaults to an empty string, while epilogue-code invokes the classical lisp top-level. Additionally, as a convenience, epilogue-code can be either a string with C code or also a list with a lisp form, which will be interpreted at run time.
Building libraries To build a library you proceed more or less the same way as with standalone executables. There are two different functions depending on whether you need to build static or shared libraries.
c:build-static-library— Function: c:build-static-library {library-name &key lisp-files prologue-code epilogue-code init-name} c:build-shared-library— Function: c:build-shared-library {library-name &key lisp-files prologue-code epilogue-code ld-flags init-name} This function builds a library file up from the object files listed in lisp-files. Each of the arguments to lisp-file must name a single object file produced with compile-file. library-name is the physical pathname corresponding to the library. The value of library-name must follow some system-specific conventions. To make your program portable, library-name should be built using the output of compile-file-pathname. prologue-code and epilogue-code are strings with C code to be executed before and after initializing the library, respectively. For dynamically linked libraries you can also provide a list of strings in ld-flags. These strings are additional parameters for the linker and their purpose is to link C/C++ extensions into the library. init-name gives the initialization function of the library a user-specified name. Thus a the generated library may be used and/or linked to a C application.
File names
compile-file-pathname— Function: compile-file-pathname {filename-base &key output-file type} When compiling lisp files, creating libraries, etc, a number of files are produced which are of interest for the user or programmer. However, the name of these files will change from system to system. The purpose of the function compile-file-pathname is to query the compiler about the name of the different files that it can produce. Possible values of the type argument include: :fas (default) Standard compiled files that can be loaded with load. :c, :data, :h Intermediate files produced by the Lisp-to-C translator. :o Linkable object files. :lib, :static-library A normal library produced with c:build-static-library. :dll, :shared-library A dynamically linked library produced with c:build-shared-library. :program An executable produced with c:build-program. The output of this function is system specific. For example, under FreeBSD > (compile-file-pathname "/this/path/mylib" :type :lib) #P"/this/path/libmylib.a" > (compile-file-pathname "/this/path/mylib" :type :dll) #P"/this/path/libmylib.so" > (compile-file-pathname "/this/path/mycode") #P"/this/path/mycode.fas"
Compiler examples The <filename>hello.lisp</filename> file In the following examples we will use the same lisp program. You have to create a file called hello.lisp which contains the following lines (princ "Hello world!") (terpri) (quit) If you start &ECL; and load this file in the Common-Lisp environment you will see the "Hello world!" message and the interpreter will be closed. ECL (Embeddable Common-Lisp) 0.9d Copyright (C) 1984 Taiichi Yuasa and Masami Hagiya Copyright (C) 1993 Giuseppe Attardi Copyright (C) 2000 Juan J. Garcia-Ripoll ECL is free software, and you are welcome to redistribute it under certain conditions; see file 'Copyright' for details. Type :h for Help. Top level. > (load "hello.lisp") ;;; Loading "hello.lisp" Hello World! Example of loadable object file You can only perform the example in this section if your &ECL; image supports dynamically loading of object files. This is true if you find the keyword :dlopen in the *features* variable. This is true, for instance, in a typical FreeBSD or Linux box, Type :h for Help. Top level. > *features* (:IEEE-FLOATING-POINT :IBM-PC :I386 :BSD :UNIX :DLOPEN :ANSI-CL :CLOS :BOEHM-GC :ECL :COMMON) In this example we build a loadable extension which prints the "Hello world!" message. First you need to create a the hello.lisp file. Next you have to enter the &ECL; environment and type (compile-file "hello.lisp"). This produces a loadable object file. Type :h for Help. Top level. > (compile-file "hello.lisp") ;;; Loading #P"/usr/lib/ecl/cmp.fas" ;;; Loading #P"/usr/lib/ecl/sysfun.lsp" ;;; Compiling hello.lisp. ;;; End of Pass 1. ;;; Calling the C compiler... ;;; Invoking external command: gcc -O2 -march=i686 -pipe -fomit-frame-pointer -fPIC -fstrict-aliasing -Dlinux -O "-I/usr/lib/ecl/" -w -c "hello.c" -o "hello.o" ;;; Invoking external command: gcc -o "hello.fas" -L"/usr/lib/ecl/" "hello.o" -Wl,–rpath,/usr/lib/ecl/ -shared -lecl -lgmp -lgc -ldl -lm ;;; OPTIMIZE levels: Safety=2, Space=0, Speed=3 ;;; Finished compiling hello.lisp. #P"hello.fas" Top level. > (load "hello") ;;; Loading #P"hello.fas" Hello World! Example of standalone program In this example we build a standalone program which prints the "Hello world!" message and does nothing else. First you must create the hello.lisp file shown above. Next you have to enter the &ECL; environment and type (compile-file "hello.lisp" :system-p t). This produces an object file that can be linked against the &ECL; core image. Type :h for Help. Top level. > (compile-file "hello.lisp" :system-p t) ;;; Loading #P"/usr/lib/ecl/cmp.fas" ;;; Loading #P"/usr/lib/ecl/sysfun.lsp" ;;; Compiling hello.lisp. ;;; End of Pass 1. ;;; Calling the C compiler... ;;; Invoking external command: gcc -O2 -march=i686 -pipe -fomit-frame-pointer -fPIC -fstrict-aliasing -Dlinux -O "-I/usr/lib/ecl/" -w -c "hello.c" -o "hello.o" ;;; OPTIMIZE levels: Safety=2, Space=0, Speed=3 ;;; Finished compiling hello.lisp. #P"hello.o" The final step is to build the executable using the c:build-program instruction. > (c:build-program "myecl" :lisp-files '("hello.o")) ;;; Invoking external command: gcc -O2 -march=i686 -pipe -fomit-frame-pointer -fPIC -fstrict-aliasing -Dlinux -O "-I/usr/lib/ecl/" -w -c "myecl.c" -o "myecl.o" ;;; Invoking external command: gcc -o "myecl" -L"/usr/lib/ecl/" "myecl.o" "hello.o" -Wl,–rpath,/usr/lib/ecl/ -lecl -lgmp -lgc -ldl -lm #P"myecl" Top level. Now you can execute this program from your favorite shell. % ./myecl Hello world! Combining files into a larger FASL You can only perform the example in this section if your &ECL; image supports dynamically loading of object files. In this example we build a loadable library which prints the "Hello world!" message and does nothing else. First you must create the hello.lisp file shown above. Next you have to enter the &ECL; environment and type (compile-file "hello.lisp" :system-p t). This produces an object file that can be linked to form a loadable library. Type :h for Help. Top level. > (compile-file "hello.lisp" :system-p t) ;;; Loading #P"/usr/lib/ecl/cmp.fas" ;;; Loading #P"/usr/lib/ecl/sysfun.lsp" ;;; Compiling hello.lisp. ;;; End of Pass 1. ;;; Calling the C compiler... ;;; Invoking external command: gcc -O2 -march=i686 -pipe -fomit-frame-pointer -fPIC -fstrict-aliasing -Dlinux -O "-I/usr/lib/ecl/" -w -c "hello.c" -o "hello.o" ;;; OPTIMIZE levels: Safety=2, Space=0, Speed=3 ;;; Finished compiling hello.lisp. #P"hello.o" The final step is to build the library using the c:build-fasl instruction. > (c:build-fasl "myecl" :lisp-files '("hello.o")) ;;; Invoking external command: gcc -O2 -march=i686 -pipe -fomit-frame-pointer -fPIC -fstrict-aliasing -Dlinux -O "-I/usr/lib/ecl/" -w -c "myecl.c" -o "myecl.o" ;;; Invoking external command: gcc -o "libmyecl.so" -L"/usr/lib/ecl/" "myecl.o" "hello.o" -Wl,–rpath,/usr/lib/ecl/ -shared -lecl -lgmp -lgc -ldl -lm #P"libmyecl.so" Now you can load this extension from any &ECL; image, even those you produce with c:build-program. <<<<<<<< THIS EXAMPLE IS WRONG?! >>>>>>>>> > (load "myecl") ;;; Loading myecl.fas Hello world! Bye.
Manipulating Lisp objects If you want to extend, fix or simply customize &ECL; for your own needs, you should understand how the implementation works. Objects representation In &ECL; a lisp object is represented by a type called cl_object. This type is a word which is long enough to host both an integer and a pointer. The least significant bits of this word, also called the tag bits, determine whether it is a pointer to a C structure representing a complex object, or whether it is an immediate data, such as a fixnum or a character. | word-1 | word-2 | ... | word-n | |----------------------| |--------|--------|-----|--------| | ...................00| | actual data of the object | |----------------------| |--------------------------------| ]]> The fixnums and characters are called immediate datatypes, because they require no more than the cl_object datatype to store all information. All other &ECL; objects are non-immediate and they are represented by a pointer to a cell that is allocated on the heap. Each cell consists of several words of memory and contains all the information related to that object. By storing data in multiples of a word size, we make sure that the least significant bits of a pointer are zero, which distinguishes pointers from immediate data. In an immediate datatype, the tag bits determine the type of the object. In non-immediate datatypes, the first byte in the cell contains the secondary type indicator, and distinguishes between different types of non immediate data. The use of the remaining bytes differs for each type of object. For instance, a cons cell consists of three words: There is one important function which tells the type of an object, plus several macros which group several tests.
cl_object— C type: cl_object This is the type of a lisp object. For your C/C++ program, a cl_object can be either a fixnum, a character, or a pointer to a union of structures (See the header object.h). The actual interpretation of that object can be guessed with the macro ecl_t_of. For example, if x is of type cl_object, and it is of type fixnum, we may retrieve its value if (ecl_t_of(x) == t_fixnum) printf("Integer value: %d\n", fix(x)); If x is of type cl_object and it does not contain an immediate datatype, you may inspect the cell associated to the lisp object using x as a pointer. For example, if (ecl_t_of(x) == t_cons) printf("CAR = %x, CDR = %x\n", x->cons.car, x->cons.cdr); else if (ecl_t_of(x) == t_string) printf("String: %s\n", x->string.self); You should see the following sections and the header object.h to learn how to use the different fields of a cl_object pointer.
cl_type— C type: cl_type Enumeration type which distinguishes the different types of lisp objects. The most important values are t_cons, t_fixnum, t_character, t_bignum, t_ratio, t_singlefloat, t_doublefloat, t_complex, t_symbol, t_package, t_hashtable, t_array, t_vector, t_string, t_bitvector, t_stream, t_random, t_readtable, t_pathname, t_bytecodes, t_cfun, t_cclosure, t_gfun, t_instance, t_foreign and t_thread.
ecl_t_of— Function: cl_type ecl_t_of (cl_object O) If O is a valid lisp object, ecl_t_of(O) returns an integer denoting the type that lisp object. That integer is one of the values of the enumeration type cl_type.
FIXNUMP— Function: bool FIXNUMP (cl_object o) CHARACTERP— Function: bool CHARACTERP (cl_object o) CONSP— Function: bool CONSP (cl_object o) LISTP— Function: bool LISTP (cl_object o) ATOM— Function: bool ATOM (cl_object o) ARRAYP— Function: bool ARRAYP (cl_object o) VECTORP— Function: bool VECTORP (cl_object o) STRINGP— Function: bool STRINGP (cl_object o) Different macros that check whether o belongs to the specified type. These checks have been optimized, and are preferred over several calls to ecl_t_of.
IMMEDIATE— Function: bool IMMEDIATE (cl_object o) Tells whether o is an immediate datatype.
Constructing objects On each of the following sections we will document the standard interface for building objects of different types. For some objects, though, it is too difficult to make a C interface that resembles all of the functionality in the lisp environment. In those cases you need to build the objects from their textual representation, or use the evaluator to build these objects. The first way makes use of a C or Lisp string to construct an object. The two functions you need to know are the following ones.
c_string_to_object— Function: cl_object c_string_to_object (const char *s) string_to_object— Function: cl_object string_to_object (cl_object o) c_string_to_object builds a lisp object from a C string which contains a suitable representation of a lisp object. string_to_object performs the same task, but uses a lisp string, and therefore it is less useful. Two examples of their use /* Using a C string */ cl_object array1 = c_string_to_object("#(1 2 3 4)"); /* Using a Lisp string */ cl_object string = make_simple_string("#(1 2 3 4)"); cl_object array2 = string_to_object(string);
Integers Common-Lisp distinguishes two types of integer types: bignums and fixnums. A fixnum is a small integer, which ideally occupies only a word of memory and which is between the values MOST-NEGATIVE-FIXNUM and MOST-POSITIVE-FIXNUM. A bignum is any integer which is not a fixnum and it is only constrained by the amount of memory available to represent it. In &ECL; a fixnum is an integer that, together with the tag bits, fits in a word of memory. The size of a word, and thus the size of a fixnum, varies from one architecture to another, and you should refer to the types and constants in the ecl.h header to make sure that your C extensions are portable. All other integers are stored as bignums, they are not immediate objects, they take up a variable amount of memory and the GNU Multiprecision Library is required to create, manipulate and calculate with them.
cl_fixnum— C type: cl_fixnum This is a C signed integer type capable of holding a whole fixnum without any loss of precision. The opposite is not true, and you may create a cl_fixnum which exceeds the limits of a fixnum and should be stored as a bignum.
cl_index— C type: cl_index This is a C unsigned integer type capable of holding a nonnegative fixnum without loss of precision. Typically, a cl_index is used as an index into an array, or into a proper list, etc.
MOST_NEGATIVE_FIXNUM— Constant: MOST_NEGATIVE_FIXNUM MOST_POSITIVE_FIXNUM— Constant: MOST_POSITIVE_FIXNUM These constants mark the limits of a fixnum.
FIXNUM_MINUSP— Function: bool FIXNUM_MINUSP (cl_object o) FIXNUM_PLUSP— Function: bool FIXNUM_PLUSP (cl_object o) These functions perform the checks (o < 0) and (0 <= o), respectively.
MAKE_FIXNUM— Function: cl_object MAKE_FIXNUM (cl_fixnum n) fix— Function: cl_fixnum fix (cl_object o) MAKE_FIXNUM and fix convert from an integer to a lisp object of fixnum type and vice versa. These functions no not check their arguments.
fixint— Function: cl_fixnum fixint (cl_object o) Converts a lisp fixnum to a C integer of the appropriate size. Signals an error if o is not of fixnum type.
fixnnint— Function: cl_index fixnnint (cl_object o) Similar to fixint but also ensures that o is not negative.
Characters &ECL; has only one type of characters, which fits in the C type char. The following constants and functions operate on characters.
CHAR_CODE_LIMIT— Constant: CHAR_CODE_LIMIT Each character is assigned an integer code which ranges from 0 to (CHAR_CODE_LIMIT-1).
CHAR_CODE— Function: cl_fixnum CHAR_CODE (cl_object o) char_code— Function: cl_fixnum char_code (cl_object o) Returns the integer code associated to a lisp character. Only char_code checks its arguments.
CODE_CHAR— Function: cl_object CODE_CHAR (cl_fixnum o) Returns the lisp character associated to an integer code. It does not check its arguments.
coerce_to_character— Function: cl_object coerce_to_character (cl_object o) Coerces a lisp object to type character. Valid arguments are a character, or a string designator of length 1. In all other cases an error is signaled.
char_eq— Function: bool char_eq (cl_object x, cl_object y) char_equal— Function: bool char_equal (cl_object x, cl_object y) Compare two characters for equality. char_eq take case into account and char_equal ignores it.
char_cmp— Function: int char_cmp (cl_object x, cl_object y) char_compare— Function: int char_compare (cl_object x, cl_object y) Compare the relative order of two characters. char_cmp takes care of case and char_compare converts all characters to uppercase before comparing them.
Arrays An array is an aggregate of data of a common type, which can be accessed with one or more nonnegative indices. &ECL; stores arrays as a C structure with a pointer to the region of memory which contains the actual data. The cell of an array datatype varies depending on whether it is a vector, a bytevector, a multidimensional array or a string. If x contains a vector, you can access the following fields: x->vector.elttype The type of the elements of the vector. x->vector.dim The maximum number of elements. x->vector.fillp Actual number of elements in the vector or "fill pointer". x->vector.self Union of pointers of different types. You should choose the right pointer depending on x->vector.elltype x->vector.hasfillp Whether x->vector.fillp can be smaller than x->vector.dim. If x contains a multidimensional array, the cell elements become x->array.elttype The type of the elements of the array. x->array.dim Number of elements in the array. x->array.rank Number of dimensions of the array. x->array.dims[] Array with the dimensions of the array. The elements range from x->array.dim[0] to x->array.dim[x->array.rank-1]. x->array.self Union of pointers to the actual data. You should choose the right pointer depending on x->array.elltype. x->array.rank Whether x->vector.fillp can be smaller than x->vector.dim. Bitvectors and strings are treated separately. Each array is of an specialized type which is the type of the elements of the array. &ECL; has arrays only a few following specialized types, and for each of these types there is a C integer which is the corresponding value of x->array.elttype or x->vector.elttype. We list those types together with the C constant that denotes that type: T aet_object CHARACTER aet_ch FIXNUM aet_fix BIT aet_bit SINGLE-FLOAT aet_sf DOUBLE-FLOAT aet_df
array_elttype— Function: cl_elttype array_elttype (cl_object o) Returns the element type of the array o, which can be a string, a bitvector, vector, or a multidimensional array. For example, the code array_elttype(c_string_to_object("\"AAA\"")) returns aet_ch, while the array_elttype(c_string_to_object("#(A B C)")) returns aet_object.
aref— Function: cl_object aref (cl_object array, cl_index index) aset— Function: cl_object aset (cl_object array, cl_index index, cl_object value) These functions are used to retrieve and set the elements of an array. The elements are accessed with one index, index, as in the lisp function ROW-MAJOR-AREF. For example cl_object array = c_string_to_object("#2A((1 2) (3 4))"); cl_object x = aref(array, 3); cl_print(1, x); /* Outputs 4 */ aset(array, 3, MAKE_FIXNUM(5)); cl_print(1, array); /* Outputs #2A((1 2) (3 5)) */
aref1— Function: cl_object aref1 (cl_object vector, cl_index index) aset1— Function: cl_object aset1 (cl_object vector, cl_index index, cl_object value) These functions are similar to aref and aset, but they operate on vectors. cl_object array = c_string_to_object("#(1 2 3 4)"); cl_object x = aref1(array, 3); cl_print(1, x); /* Outputs 4 */ aset1(array, 3, MAKE_FIXNUM(5)); cl_print(1, array); /* Outputs #(1 2 3 5) */
Strings A string, both in Common-Lisp and in &ECL; is nothing but a vector of characters. Therefore, almost everything mentioned in the section of arrays remains valid here. The only important difference is that &ECL; stores strings as a lisp object with a pointer to a zero terminated C string. Thus, if a string has n characters, &ECL; will reserve n+1 bytes for the string. This allows us to pass the string self pointer to any C routine. If x is a lisp object of type string, we can access the following fields: x->string.dim Maximum number of characters that it can contain. x->string.fillp Actual number of characters in the string. x->string.self Pointer to the characters. x->string.hasfillp True if x->string.fillp can be smaller than x->string.dim.
make_simple_string— Function: cl_object make_simple_string (char *s) make_string_copy— Function: cl_object make_string_copy (char *s) Both routines build a lisp string from a C string. make_string_copy allocates new space and copies the content of the string to it. make_simple_string simply uses the memory pointed by s, which should not be deallocated. Both routines use strlen to calculate the length of the string.
Bitvectors Streams Structures Instances Bytecodes A bytecodes object is a lisp object with a piece of code that can be interpreted. The objects of type t_bytecode are implicitly constructed by a call to eval, but can also be explicitly constructed with the make_lambda function.
cl_safe_eval— Function: cl_object cl_safe_eval (cl_object form, cl_object env, cl_object err_value cl_eval— Function: cl_object cl_eval (cl_object form) cl_safe_eval evaluates form in the lexical environment env, which can be nil. Before evaluating it, the expression form must be bytecompiled. cl_eval is the equivalent of cl_safe_eval but without environment and with err_value set to nil. It exists only for compatibility with previous versions. cl_object form = c_string_to_object("(print 1)"); cl_safe_eval(form,Cnil); cl_safe_eval(form, Cnil);
si_make_lambda— Function: cl_object si_make_lambda (cl_object name, cl_object def) Builds an interpreted lisp function with name given by the symbol name and body given by def. For instance, we would achieve the equivalent of (funcall #'(lambda (x y) (block foo (+ x y))) 1 2) with the following code cl_object def = c_string_to_object("((x y) (+ x y))"); cl_object name = _intern("foo") cl_object fun = si_make_lambda(name, def); return funcall(fun, MAKE_FIXNUM(1), MAKE_FIXNUM(2)); Notice that si_safe_lambda performs a bytecodes compilation of the definition and thus it may signal some errors. Such errors are not handled by the routine itself you might consider using cl_safe_eval or cl_eval instead: cl_object def = c_string_to_object("#'(lambda-block foo (x y) (+ x y))"); cl_object fun = cl_eval(def); return funcall(fun, MAKE_FIXNUM(1), MAKE_FIXNUM(2));
The interpreter &ECL; stacks &ECL; uses the following stacks: Frame Stack consisting of catch, block, tagbody frames Bind Stack for shallow binding of dynamic variables Interpreter Stack acts as a Forth data stack, keeping intermediate arguments to interpreted functions, plus a history of called functions. C Control Stack used for arguments/values passing, typed lexical variables, temporary values, and function invocation. Procedure Call Conventions &ECL; employs standard C calling conventions to achieve efficiency and interoperability with other languages. Each Lisp function is implemented as a C function which takes as many argument as the Lisp original plus one additional integer argument which holds the number of actual arguments. The function sets NValues to the number of Lisp values produced, it returns the first one and the remaining ones are kept in a global (per thread) array (VALUES). To show the argument/value passing mechanism, here we list the actual code for the Common-Lisp function cons. cl_cons(int narg, object car, object cdr) { object x; check_arg(2); x = alloc_object(t_cons); CAR(x) = car; CDR(x) = cdr; NValues = 1; return x; } &ECL; adopts the convention that the name of a function that implements a Common-Lisp function begins with a short package name (cl for COMMON-LISP, si for SYSTEM, etc), followed by L, and followed by the name of the Common-Lisp function. (Strictly speaking, `-' and `*' in the Common-Lisp function name are replaced by `_' and `A', respectively, to obey the syntax of C.) check_arg(2) in the code of cl_cons checks that exactly two arguments are supplied to cons. That is, it checks that narg is 2, and otherwise, it causes an error. allocate_object(t_cons) allocates a cons cell in the heap and returns the pointer to the cell. After the CAR and the CDR fields of the cell are set, the cell pointer is returned directly. The number assigned to NValues set by the function (1 in this case) represents the number of values of the function. In general, if one is to play with the C kernel of &ECL; there is no need to know about all these conventions. There is a preprocessor that takes care of the details, by using a lisp representation of the statements that output values, and of the function definitions. For instance, the actual source code for cl_cons in src/c/lists.d @(defun cons (car cdr) @ @(return CONS(car, cdr)) @) The lexical environment The &ECL; interpreter uses two A-lists (Association lists) to represent lexical environments. One for variable bindings One for local function/macro/tag/block bindings When a function closure is created, the current two A-lists are saved in the closure along with the lambda expression. Later, when the closure is invoked, the saved A-lists are used to recover the lexical environment. The interpreter stack The bytecodes interpreter uses a stack of its own to save and restore values from intermediate calculations. This Forth-like data stack is also used in other parts of the C kernel for various purposes, such as saving compiled code, keeping arguments to FORMAT, etc. However, one of the most important roles of the Interpreter Stack is to keep a log of the functions which are called during the execution of bytecodes. For each function invoked, the interpreter keeps three lisp objects on the stack: The first item is the object which is funcalled. It can be a bytecodes object, a compiled function or a generic function. In the last two cases the lexical environment is just NIL. In the first case, the second item on the stack is the lexical environment on which the code is executed. Each of these records are popped out of the stack after function invocation. Let us see how these invocation records are used for debugging. >(defun fact (x) ;;; Wrong definition of the (if (= x 0) ;;; factorial function. one ;;; one should be 1. (* x (fact (1- x))))) FACT >(fact 3) ;;; Tries 3! Error: The variable ONE is unbound. Error signalled by IF. Broken at IF. >>:b ;;; Backtrace. Backtrace: eval > fact > if > fact > if > fact > if > fact > IF ;;; Currently at the last IF. >>:h ;;; Help. Break commands: :q(uit) Return to some previous break level. :pop Pop to previous break level. :c(ontinue) Continue execution. :b(acktrace) Print backtrace. :f(unction) Show current function. :p(revious) Go to previous function. :n(ext) Go to next function. :g(o) Go to next function. :fs Search forward for function. :bs Search backward for function. :v(ariables) Show local variables, functions, blocks, and tags. :l(ocal) Return the nth local value on the stack. :hide Hide function. :unhide Unhide function. :hp Hide package. :unhp Unhide package. :unhide-all Unhide all variables and packages. :bds Show binding stack. :m(essage) Show error message. :hs Help stack. Top level commands: :cf Compile file. :exit or ^D Exit Lisp. :ld Load file. :step Single step form. :tr(ace) Trace function. :untr(ace) Untrace function. Help commands: :apropos Apropos. :doc(ument) Document. :h(elp) or ? Help. Type ":help help" for more information. >>:p ;;; Move to the last call of FACT. Broken at IF. >>:b Backtrace: eval > fact > if > fact > if > fact > if > FACT > if ;;; Now at the last FACT. >>:v ;;; The environment at the last call Local variables: ;;; to FACT is recovered. X: 0 ;;; X is the only bound variable. Block names: FACT. ;;; The block FACT is established. >>x 0 ;;; The value of x is 0. >>(return-from fact 1) ;;; Return from the last call of 6 ;;; FACT with the value of 0. ;;; The execution is resumed and > ;;; the value 6 is returned. ;;; Again at the top-level loop.
The compiler The compiler translates to C The &ECL; compiler is essentially a translator from Common-Lisp to C. Given a Lisp source file, the compiler first generates three intermediate files: a C-file which consists of the C version of the Lisp program an H-file which consists of declarations referenced in the C-file a Data-file which consists of Lisp data to be used at load time The &ECL; compiler then invokes the C compiler to compile the C-file into an object file. Finally, the contents of the Data-file is appended to the object file to make a Fasl-file. The generated Fasl-file can be loaded into the &ECL; system by the Common-Lisp function load. By default, the three intermediate files are deleted after the compilation, but, if asked, the compiler leaves them. The merits of the use of C as the intermediate language are: The &ECL; compiler is highly portable. Cross compilation is possible, because the contents of the intermediate files are common to all versions of &ECL;. For example, one can compile his or her Lisp program by the &ECL; compiler on a Sun, bring the intermediate files to DOS, compile the C-file with the gcc compiler under DOS, and then append the Data-file to the object file. This procedure generates the Fasl-file for the &ECL; system on DOS. This kind of cross compilation makes it easier to port &ECL;. Hardware-dependent optimizations such as register allocations are done by the C compiler. The demerits are: At those sites where no C compiler is available, the users cannot compile their Lisp programs. The compilation time is long. 70% to 80% of the compilation time is used by the C compiler. The &ECL; compiler is therefore slower than compiler generating machine code directly. The compiler mimics human C programmer The format of the intermediate C code generated by the &ECL; compiler is the same as the hand-coded C code of the &ECL; source programs. For example, supposing that the Lisp source file contains the following function definition: (defvar *delta* 2) (defun add1 (x) (+ *delta* x)) The compiler generates the following intermediate C code. /* function definition for ADD1 */ static cl_object L1(cl_object V1) { VT2 VLEX2 CLSR2 cl_object value0; value0=number_plus(symbol_value(VV[0]),V1); NVALUES=1; return value0; } /* initialization of this module */ void init_CODE(cl_object flag) { VT1 CLSR1 cl_object value0; if (!FIXNUMP(flag)){ Cblock=flag; #ifndef ECL_DYNAMIC_VV flag->cblock.data = VV; #endif flag->cblock.self_destruct=0; flag->cblock.data_size = VM; flag->cblock.data_text = compiler_data_text; flag->cblock.data_text_size = compiler_data_text_size; return;} #ifdef ECL_DYNAMIC_VV VV = Cblock->cblock.data; #endif T0= MAKE_FIXNUM(2); si_Xmake_special(VV[0]) if(SYM_VAL(T0)!=OBJNULL) cl_setq(VV[0],T0); cl_def_c_function(VV[1],(void*)L1,1); } The C function L1 implements the Lisp function add1. This relation is established by cl_def_c_function in the initialization function init_CODE, which is invoked at load time. There, the vector VV consists of Lisp objects; VV[0] and VV[1] in this example hold the Lisp symbols *delta* and add1. VM in the definition of L1 is a C macro declared in the corresponding H-file. The actual value of VM is the number of value stack locations used by this module, i.e., 2 in this example. Thus the following macro definition is found in the H-file. #define VM 2 Implementation of Compiled Closures The &ECL; compiler takes two passes before it invokes the C compiler. The major role of the first pass is to detect function closures and to detect, for each function closure, those lexical objects (i.e., lexical variable, local function definitions, tags, and block-names) to be enclosed within the closure. This check must be done before the C code generation in the second pass, because lexical objects to be enclosed in function closures are treated in a different way from those not enclosed. Ordinarily, lexical variables in a compiled function f are allocated on the C stack. However, if a lexical variable is to be enclosed in function closures, it is allocated on a list, called the “environment list”, which is local to f. In addition, a local variable is created which points to the lexical variable's location (within the environment list), so that the variable may be accessed through an indirection rather than by list traversal. The environment list is a pushdown list: It is empty when f is called. An element is pushed on the environment list when a variable to be enclosed in closures is bound, and is popped when the binding is no more in effect. That is, at any moment during execution of f, the environment list contains those lexical variables whose binding is still in effect and which should be enclosed in closures. When a compiled closure is created during execution of f, the compiled code for the closure is coupled with the environment list at that moment to form the compiled closure. Later, when the compiled closure is invoked, a pointer is set up to each lexical variable in the environment list, so that each object may be referenced through a memory indirection. Let us see an example. Suppose the following function has been compiled. (defun foo (x) (let ((a #'(lambda () (incf x))) (y x)) (values a #'(lambda () (incf x y))))) foo returns two compiled closures. The first closure increments x by one, whereas the second closure increments x by the initial value of x. Both closures return the incremented value of x. >(multiple-value-setq (f g) (foo 10)) #<compiled-closure nil> >(funcall f) 11 >(funcall g) 21 > After this, the two compiled closures look like: | 10 | --|------>| 21 | nil | |-------|------| |-------|------| |------|------| ^ first closure | |-------|------| | | * | --|----------| |-------|------| * : address of the compiled code for #'(lambda () (incf x)) ** : address of the compiled code for #'(lambda () (incf x y)) ]]> Use of Declarations to Improve Efficiency Declarations, especially type and function declarations, increase the efficiency of the compiled code. For example, for the following Lisp source file, with two Common-Lisp declarations added, (eval-when (compile) (proclaim '(function tak (fixnum fixnum fixnum) fixnum)) (defun tak (x y z) (declare (fixnum x y z)) (if (not (< y x)) z (tak (tak (1- x) y z) (tak (1- y) z x) (tak (1- z) x y)))) The compiler generates the following C code: /* local entry for function TAK */ static int LI1(register int V1,register int V2,register int V3) { VT3 VLEX3 CLSR3 TTL: if (V2 < V1) { goto L2;} return(V3); L2: { int V5; V5 = LI1((V1)-1,V2,V3); { int V6; V6 = LI1((V2)-1,V3,V1); V3 = LI1((V3)-1,V1,V2); V2 = V6; V1 = V5;}} goto TTL; ;;; Note: Tail-recursive call of TAK was replaced by iteration. } Inspecting generated C code Common-Lisp defines a function disassemble, which is supposed to disassemble a compiled function and to display the assembler code. According to Common-Lisp: The Language, This is primary useful for debugging the compiler, ..\\ This is, however, useless in our case, because we are not concerned with assembly language. Rather, we are interested in the C code generated by the &ECL; compiler. Thus the disassemble function in &ECL; accepts not-yet-compiled functions only and displays the translated C code. > (defun add1 (x) (1+ x)) ADD1 > (disassemble *) ;;; Compiling (DEFUN ADD1 ...). ;;; Emitting code for ADD1. /* function definition for ADD1 */ static L1(int narg, object V1) { VT3 VLEX3 CLSR3 TTL: VALUES(0) = one_plus((V1)); RETURN(1); } Embedding C code in lisp source There are several mechanism to integrate C code within &ECL;, but everything is built around two functions that allow the user to embed arbitrary C/C++ code into Lisp source code. The two mechanisms are the Clines and the c-inline special forms. The first one permits to insert code in the intermediate C/C++ file generated by the &ECL; compiler. Such a form outputs no value and takes no arguments, except a series of strings which are inserted literally, such as #include or #define statements, function definitions, etc.
Clines— Macro: Clines {{string}*} When the &ECL; compiler encounters a macro form (Clines string1 ... stringn), it simply outputs the strings into the c-file. The arguments are not evaluated and each argument must be a string. Each string may consist of any number of lines, and separate lines in the string are placed in separate lines in the c-file. In addition, each string opens a fresh line in the c-file, i.e., the first character in the string is placed at the first column of a line. Therefore, C-language preprocessor commands such as #define and #include will be recognized as such by the C compiler, if the ' # ' sign appears as the first character of the string or as the first character of a line within the string. When interpreted, a Clines macro form expands to ().
(use-package "FFI") (Clines " int tak(x, y, z) " " int x, y, z; " " { if (y >= x) return(z); " " else return(tak(tak(x-1, y, z), " " tak(y-1, z, x), " " tak(z-1, x, y))); " " } " ) (defun tak (x y z) (c-inline (x y z) (:int :int :int) :int "tak(#0,#1,#2)" :one-liner t)) The second mechanism, which you already appreciate in the example above, is the c-inline special form. This powerful method allows the user to insert C code which is evaluated, and which can accept values and return values from and to the Lisp world, with an automatic convertion taking place in both directions.
c-inline— Macro: c-inline {args-list arg-C-types output-C-type C-expr &key (side-effects T) (one-liner T)} c-inline is a special form that can only be used in compiled code. For all purposes it behaves as a Lisp form, which takes the arguments given in args-list and produces a single value. Behind the curtains, the arguments of args-list (which can be any valid Lisp form) are coerced to the the C types given in arg-C-types, passed to the C expression C-expr, and coerced back to Lisp using the C type output-C-type as a guide. Multiple return values can be returned by setting output-C-type to (values type-1 type-2 ...). C-expr is a string containing C code and maybe some special escape codes. First, the arguments of the form may be retrieved as #0, #1, etc. Second, if the c-inline form is a one-line C expression (That is, one-liner is true), then the whole expression is interpreted as the output value. But if the code, on the other hand, is a multiline expression (one-liner is false), the form has to be output using @(return) =.... Multiple values are returned as @(return 0)=... ; @(return 1)=...;. Finally, Lisp constants may be used in the C code making use of the prefix @. (use-package "FFI") (Clines " #include <math.h> double foo (double x, double y) { return sinh(x) * y; }") (defvar *a* (c-inline (1.23) (:double) :double "foo(#0,1.44)" :side-effects nil :one-liner t)) (defvar *b* (c-inline (1.23) (:double) :double "{cl_object x = symbol_value(@*a*); @(return) = foo(#0,object_to_float(x));}" :side-effects nil :one-liner nil))
The C language interface Using these special forms clines and c-inline, plus the ability to handle pointers to foreign data, we have built a rather complete FFI for interfacing with the C world. This interface is compatible with the UFFI specification, which can be found in the web. We recommend you to grab the documentation from this package and read it carefully. All examples should run unmodified under &ECL; (Of course, you do not need to download UFFI itself, as everything is already implemented in &ECL;. However, because &ECL; provides some additional functionality which escapes the UFFI, and also for compatibility with older versions of the &ECL; environment, we provide additional toplevel forms, which are listed in the next section. The old C language interface In this section we list several macros and toplevel forms which are provided either for convenience or for compatibility with older versions of &ECL;. You should avoid using them when the UFFI-compatible interface provides similar functionality. We define some terminology here which is used throughout this Section. A C-id is either a Lisp string consisting of a valid C-language identifier, or a Lisp symbol whose print-name, with all its alphabetic characters turned into lower case, is a valid C identifier. Thus the symbol foo is equivalent to the string "foo" when used as a C-id. Similarly, a C-expr is a string that may be regarded as a C-language expression. A C-type is one of the Lisp symbols :int, :char, :float, :double,... and :object. Each corresponds to a data type in the C language; :object is the type of Lisp object and other C-types are primitive data types in C.
defentry— Macro: defentry {function parameter-list C-function} defentry defines a Lisp function whose body consists of the calling sequence to a C-language function. function is the name of the Lisp function to be defined, and C-function specifies the C function to be invoked. C-function must be either a list (type C-id) or C-id, where type and C-id are the type and the name of the C function. type must be a C-type or the symbol void which means that the C function returns no value. (object C-id) may be abbreviated as C-id. parameter-list is a list of C-types for the parameters of the C function. For example, the following defentry form defines a Lisp function tak from which the C function tak above is called.
(defentry tak (:int :int :int) (:int tak)) The Lisp function tak defined by this defentry form requires three arguments. The arguments are converted to int values before they are passed to the C function. On return from the C function, the returned int value is converted to a Lisp integer (actually a fixnum) and this fixnum will be returned as the value of the Lisp function. See below for type conversion between Lisp and the C language. A defentry form is treated in the above way only when it appears as a top-level form of a Lisp source file. Otherwise, a defentry form expands to ().
defla— Macro: defla {name lambda-list {declaration | doc-string}*} When interpreted, defla is exactly the same as defun. That is, (defla name lambda-list . body) expands to (defun name lambda-list . body). However, defla forms are completely ignored by the compiler; no C-language code will be generated for defla forms. The primary use of defla is to define a Lisp function in two ways within a single Lisp source file; one in the C language and the other in Lisp. defla is short for DEFine Lisp Alternative.
Suppose you have a Lisp source file whose contents are: (use-package "FFI") ;;; C version of TAK. (Clines " int tak(x, y, z) int x, y, z; { if (y >= x) return(z); else return(tak(tak(x-1, y, z), tak(y-1, z, x), tak(z-1, x, y))); } " ) ;;; TAK calls the C function tak defined above. (defentry tak (:int :int :int) (:int tak)) ;;; The alternative Lisp definition of TAK. (defla tak (x y z) (if (>= y x) z (tak (tak (1- x) y z) (tak (1- y) z x) (tak (1- z) x y)))) When this file is loaded into &ECL;, the interpreter uses the Lisp version of the tak definition. Once this file has been compiled, and when the generated fasl file is loaded into &ECL;, a function call to tak is actually the call to the C version of tak.
defCbody— Function: defCbody name args-types result-type C-expr The &ECL; compiler produces a function named name with as many arguments as arg-types. The C-expr is an arbitrary C expression where the arguments to the function are denoted by # i , where i is the integer corresponding to the argument position. The args-types is the list of Common-Lisp types of the arguments to the function, while result-type is the Common-Lisp type of the result. The actual arguments are coerced to the required types before executing the C-expr and the result is converted into a Lisp object. defCbody is ignored by the interpreter.
For example, the logical AND of two integers could be defined as: (defCbody logand (fixnum fixnum) fixnum "(#0) & (#1)")
definline— Function: definline {name args-types result-type C-expr} definline behaves exactly as defCbody. Moreover, after a definline definition has been supplied, the &ECL; compiler will expand inline any call to function name into code corresponding to the C language expression C-expr, provided that the actual arguments are of the specified type. If the actual arguments cannot be coerced to those types, the inline expansion is not performed. definline is ignored by the interpreter.
For example, a function to access the n-th byte of a string and return it as an integer can be defined as follows: (definline aref-byte (string fixnum) fixnum "(#0)->ust.ust_self[#1]") The definitions of the C data structures used to represent \clisp objects can be found in file ecl.h in the directory "src/h" of the source distribution. &ECL; converts a Lisp object into a C-language data by using the Common-Lisp function coerce: For the C-type int (or char), the object is first coerced to a Lisp integer and the least significant 32-bit (or 8-bit) field is used as the C int (or char). For the C-type float (or double), the object is coerced to a single-float (or a double-float) and this value is used as the C float (or double). Conversion from a C data into a Lisp object is obvious: C char, int, float, and double become the equivalent Lisp character, fixnum, single-float, and double-float, respectively. Here we list the complete syntax of Clines, defentry, definline and defCbody macro forms.
The Garbage Collector Using &ECL; in existing application sometimes involves keeping Lisp objects where the garbage collector normally cannot see them.
Porting &ECL; To port &ECL; to a new architecture, the following steps are required: Ensure that the GNU Multiprecision library supports this machine. Ensure that the Boehm-Weiser garbage collector is supported by that architecture. Alternatively, port ECL's own garbage collector src/c/alloc.d and src/c/gbc.d to that platform. Fix src/aclocal.in, src/h/ecl.h and src/h/ecl-cmp.h so that they supply flags for the new host machine. Fix the machine dependent code in src/c/. The most critical parts are in the unix* and thread* files. Compile as in any other platform. Run the tests and compare to the results of other platforms.
ecl-16.1.2/doc/emacs.el000066400000000000000000000102611266352375300145370ustar00rootroot00000000000000(require 'cl) (defvar ecl-search-string "") (defun query-replace-ecl-doc (from-string to-string &optional delimited start end) (interactive (query-replace-read-args "Query replace" nil)) (let ((remaining (member (buffer-file-name (current-buffer)) ecl-doc-files))) (dolist (i (or remaining ecl-doc-files)) (let ((b (find-buffer-visiting i))) (unless (equal b (current-buffer)) (switch-to-buffer b) (beginning-of-buffer))) (perform-replace from-string to-string t nil delimited nil nil start end)))) (defun query-replace-regexp-ecl-doc (from-string to-string &optional delimited start end) (interactive (query-replace-read-args "Query replace" nil)) (let ((remaining (member (buffer-file-name (current-buffer)) ecl-doc-files))) (dolist (i (or remaining ecl-doc-files)) (let ((b (find-buffer-visiting i))) (unless (equal b (current-buffer)) (switch-to-buffer b) (beginning-of-buffer))) (query-replace-regexp from-string to-string delimited start end)))) (defun search-ecl-doc (string) (interactive "sString: ") (setq ecl-search-string string) (let ((remaining (member (buffer-file-name (current-buffer)) ecl-doc-files))) (dolist (i (or remaining ecl-doc-files)) (let ((b (find-buffer-visiting i))) (unless (equal b (current-buffer)) (print b) (switch-to-buffer b) (beginning-of-buffer))) (print '*) (setq case-fold-search t) (if (search-forward string nil t) (return))))) (defun search-next-ecl-doc () (interactive) (search-ecl-doc ecl-search-string)) (defun back-to-emacs () (interactive) (switch-to-buffer "emacs.el")) (defun next-ecl-doc () (interactive) (let ((remaining (member (buffer-file-name (current-buffer)) ecl-doc-files))) (when (cdr remaining) (switch-to-buffer (find-buffer-visiting (cadr remaining)))))) (global-set-key [?\M-p ?\C-i] 'back-to-emacs) (global-set-key [?\M-p ?\C-s] 'search-ecl-doc ) (global-set-key [?\M-p ?\C-n] 'search-next-ecl-doc ) (global-set-key [?\M-p ?\C-m] 'next-ecl-doc ) (global-set-key [?\M-p ?\C-p] 'ecl-load-symbols) (setq auto-mode-alist (acons "\\.d\\'" 'c-mode auto-mode-alist)) (setq ecl-doc-files (mapcar (lambda (x) ;(set-buffer "emacs.el") (concat (subseq (buffer-file-name (current-buffer)) 0 -8) x)) '( "asdf.xmlf" "bibliography.xmlf" "clos.xmlf" "compiler.xmlf" "copyright.xmlf" "declarations.xmlf" "discarded.xml" "discarded.xmlf" "ecl.xml" "ecldev.xmlf" "embed.xmlf" "ffi.xmlf" "gc.xmlf" "internals.xmlf" "interpreter.xmlf" "intro.xmlf" "io.xmlf" "macros.xmlf" "memory.xmlf" "mop.xmlf" "mp.xmlf" "os.xmlf" "pde.xmlf" "preface.xmlf" "ref_c_arrays.xml" "ref_c_characters.xml" "ref_c_conditions.xml" "ref_c_conses.xml" "ref_c_data_flow.xml" "ref_c_environment.xml" "ref_c_evaluation.xml" "ref_c_filenames.xml" "ref_c_files.xml" "ref_c_hash_tables.xml" "ref_c_numbers.xml" "ref_c_objects.xml" "ref_c_packages.xml" "ref_c_printer.xml" "ref_c_reader.xml" "ref_c_sequences.xml" "ref_c_streams.xml" "ref_c_strings.xml" "ref_c_structures.xml" "ref_c_symbols.xml" "ref_c_system_construction.xml" "ref_c_types_and_classes.xml" "ref_embed.xmlf" "ref_memory.xmlf" "ref_mp.xmlf" "ref_os.xmlf" "ref_signals.xmlf" "schemas.xml" "signals.xmlf" "uffi/ref_aggregate.xml" "uffi/ref_declare.xml" "uffi/ref_func_libr.xml" "uffi/ref_object.xml" "uffi/ref_primitive.xml" "uffi/ref_string.xml" "uffi/schemas.xml" "ansi_arrays.xml" "ansi_characters.xml" "ansi_conses.xml" "ansi_data_flow.xml" "ansi_environment.xml" "ansi_evaluation.xml" "ansi_filenames.xml" "ansi_files.xml" "ansi_hash_tables.xml" "ansi_numbers.xml" "ansi_objects.xml" "ansi_overview.xml" "ansi_packages.xml" "ansi_printer.xml" "ansi_reader.xml" "ansi_sequences.xml" "ansi_streams.xml" "ansi_strings.xml" "ansi_structures.xml" "ansi_symbols.xml" "ansi_system_construction.xml" "ansi_types.xml" ))) (mapcar 'find-file ecl-doc-files) (defun ecl-doc-revert () (interactive) (mapcar '(lambda (x) (let ((a (find-buffer-visiting x))) (and a (switch-to-buffer a) (revert-buffer t t)))) ecl-doc-files)) (defun ecl-doc-save () (interactive) (mapcar '(lambda (x) (let ((a (find-buffer-visiting x))) (and a (switch-to-buffer a) (save-buffer 0)))) ecl-doc-files)) ecl-16.1.2/doc/embed.xmlf000066400000000000000000000013131266352375300150670ustar00rootroot00000000000000 %eclent; ]> Embedding &ECL;
Introduction TBD.
ecl-16.1.2/doc/ffi.xmlf000066400000000000000000000513001266352375300145600ustar00rootroot00000000000000 %eclent; ]> Foreign Function Interface
What is a FFI? A Foreign Function Interface, or &FFI; for short, is a means for a programming language to interface with libraries written in other programming languages, the foreign code. You will see this concept most often being used in interpreted environments, such as Python, Ruby or Lisp, where one wants to reuse the big number of libraries written in C and C++ for dealing with graphical interfaces, networking, filesystems, etc. A FFI is made of at least three components: Foreign objects management This is the data that the foreign code will use. A &FFI; needs to provide means to build and manipulate foreign data, with automatic conversions to and from lisp data types whenever possible, and it also has to deal with issues like garbage collection and finalization. Foreign code loader To actually use a foreign routine, the code must reside in memory. The process of loading this code and finding out the addresses of the routines we want to use is normally done by an independent component. Foreign function invocation This is the part of the &FFI; that deals with actually calling the foreign routines we want to use. For that one typically has to tell the &FFI; what are the arguments that these routines expect, what are the calling conventions and where are these routines to be found. On top of these components sits a higher level interface written entirely in lisp, with which you will actually declare and use foreign variables, functions and libraries. In the following sections we describe both the details of the low-level components (, ), and of the higher level interface (). It is highly recommended that you read all sections.
Two kinds of FFI &ECL; allows for two different appraoches when building a &FFI;. Both approaches have a different implementation philosophy and affect the places where you can use the &FFI; and how. Static &FFI; For every foreign function and variable you might need to use, a wrapper is automatically written in C with the help of . These wrappers are compiled using an ordinary C compiler and linked against both the foreign libraries you want to use and against the &ECL; library. The result is a &FASL; file that can be loaded from &ECL; and where the wrappers appear as ordinary lisp functions and variables that the user may directly invoked. Dynamic &FFI; First of all, the foreign libraries are loaded in memory using the facilities of the operating system. Similar routines are used to find out and register the memory location of all the functions and variables we want to use. Finally, when actually accessing these functions, a little piece of assembly code does the job of translating the lisp data into foreign objects, storing the arguments in the stack and in CPU registers, calling the function and converting back the output of the function to lisp.
FFI components
As you see, the first approach uses rather portable technices based on a programming language (C, C++) which is strongly supported by the operating system. The conversion of data is performed calling routines in the &ECL; library and we need not care about the precise details (organizing the stack, CPU registers, etc) when calling a function: the compiler does this for us. On the other hand, the dynamic approach allows us to choose the libraries we load at any time, look for the functions and invoke them even from the toplevel, but it relies on unportable techniques and requires from us, the developers of &ECL;, to know very well both the assembly code of the machine &ECL; runs on and the calling conventions of that particular operating system. &ECL; currently supports the static method on all platforms, and the dynamical one a few of the most popular ones, shown in . You can test if your copy of &ECL; was built with DFFI by inspecting whether the symbol :DFFI is present in the list from variable *FEATURES*. DFFI support Architecture Support Operating systems Intel x86 32 bits Complete Any with SysV ABI (Linux, BSD), Windows, OS X Intel x86 64 bits In progress SysV ABI PowerPC 32 bits In progress OS X
Foreign objects While the foreign function invocation protocols differ strongly between platforms and implementations, foreign objects are pretty easy to handle portably. For &ECL;, a foreign object is just a bunch of bytes stored in memory. The lisp object for a foreign object encapsulates several bits of information: A list or a symbol specifying the C type of the object. The pointer to the region of memory where data is stored. A flag determining whether &ECL; can automatically manage that piece of memory and deallocated when no longer in use. A foreign object may contain many different kinds of data: integers, floating point numbers, C structures, unions, etc. The actual type of the object is stored in a list or a symbol which is understood by the higher level interface (). The most important component of the object is the memory region where data is stored. By default &ECL; assumes that the user will perform automatic managment of this memory, deleting the object when it is no longer needed. The first reason is that this block may have been allocated by a foreign routine using malloc(), or mmap(), or statically, by referring to a C constant. The second reason is that foreign functions may store references to this memory which &ECL; is not aware of and, in order to keep these references valid, &ECL; should not attempt to automatically destroy the object. In many cases, however, it is desirable to automatically destroy foreign objects once they have been used. The higher level interfaces &UFFI; and &CFFI; provide tools for doing this. For instance, in the following example adapted from the &UFFI; documentation, the string NAME is automatically deallocated (def-function "gethostname" ((name (* :unsigned-char)) (len :int)) :returning :int) (if (zerop (c-gethostname (ffi:char-array-to-pointer name) 256)) (format t "Hostname: ~S" (ffi:convert-from-foreign-string name)) (error "gethostname() failed."))
Higher level interfaces Up to now we have only discussed vague ideas about how a &FFI; works, but you are probably more interested on how to actually code all these things in lisp. You have here three possibilities: &ECL; supplies a high level interface which is compatible with &UFFI; up to version 1.8 (api for >=v2.0 is provided by cffi-uffi-compat system shipped with &CFFI;). Code designed for &UFFI; library should run mostly unchanged with &ECL;. Note, that api resides in ffi package, not uffi, to prevent conflicts with cffi-uffi-compat. The &CFFI; library features a mostly complete backend for &ECL;. This is however a work in progress, as the fact that &CFFI; allows for calling arbitrary functions without declaring them causes some troubles with &ECL;. &ECL;'s own low level interface. Only to be used if &ECL; is your deployment platform. It features some powerful constructs that allow you to merge arbitrary C code with lisp ( and ). In the following two subsections we will discuss two practical examples of using the native &UFFI; and the &CFFI; library.
UFFI example The example below shows how to use &UFFI; in an application. There are several important ingredients: You need to specify the libraries you use and do it at the toplevel, so that the compiler may include them at link time. Every function you will use has to be declared using ffi:def-function. #| Build and load this module with (compile-file "uffi.lsp" :load t) |# ;; ;; This toplevel statement notifies the compiler that we will ;; need this shared library at runtime. We do not need this ;; statement in windows. ;; #-(or ming32 windows) (ffi:load-foreign-library #+darwin "/usr/lib/libm.dylib" #-darwin "/usr/lib/libm.so") ;; ;; With this other statement, we import the C function sin(), ;; which operates on IEEE doubles. ;; (ffi:def-function ("sin" c-sin) ((arg :double)) :returning :double) ;; ;; We now use this function and compare with the lisp version. ;; (format t "~%Lisp sin:~t~d~%C sin:~t~d~%Difference:~t~d" (sin 1.0d0) (c-sin 1.0d0) (- (sin 1.0d0) (c-sin 1.0d0)))
CFFI example The &CFFI; library is an independent project and it is not shipped with &ECL;. If you wish to use it you can go to their homepage, download the code and build it using &ASDF;. &CFFI; differs slightly from &UFFI; in that functions may be used even without being declared beforehand. This poses a few problems to the &ECL; backend, but hopefully these should have been solved in the latest releases. #| Build and load this module with (compile-file "cffi.lsp" :load t) |# ;; ;; This toplevel statement notifies the compiler that we will ;; need this shared library at runtime. We do not need this ;; statement in windows. ;; #-(or ming32 windows) (cffi:load-foreign-library #+darwin "/usr/lib/libm.dylib" #-darwin "/usr/lib/libm.so") ;; ;; With this other statement, we import the C function sin(), ;; which operates on IEEE doubles. ;; (cffi:defcfun ("sin" c-sin) :double '(:double)) ;; ;; We now use this function and compare with the lisp version. ;; (format t "~%Lisp sin:~t~d~%C sin:~t~d~%Difference:~t~d" (sin 1.0d0) (c-sin 1.0d0) (- (sin 1.0d0) (c-sin 1.0d0))) ;; ;; The following also works: no declaration! ;; (let ((c-cos (cffi:foreign-funcall "cos" :double 1.0d0 :double))) (format t "~%Lisp cos:~t~d~%C cos:~t~d~%Difference:~t~d" (sin 1.0d0) c-sin (- (sin 1.0d0) c-sin)))
Low level example To compare with the previous pieces of code, we show how the previous programs would be written using and #| Build and load this module with (compile-file "ecl.lsp" :load t) |# ;; ;; With this other statement, we import the C function sin(), which ;; operates on IEEE doubles. Notice that we include the C header to ;; get the full declaration. ;; (defun c-sin (x) (ffi:clines "#include <math.h>") (ffi:c-inline (x) (:double) :double "sin(#0)" :one-liner t)) ;; ;; We now use this function and compare with the lisp version. ;; (format t "~%Lisp sin:~t~d~%C sin:~t~d~%Difference:~t~d" (sin 1.0d0) (c-sin 1.0d0) (- (sin 1.0d0) (c-sin 1.0d0)))
FFI Reference ffi:clines Insert C declarations and definitions Special form ffi:clines c-code* c-code One or more strings with C definitions. Not evaluated. returns No value. Description This special form inserts C code directly in the file that results from compiling lisp sources. Contrary to , this function may have no executable statements, accepts no input value and returnsn no value. The main use of FFI:CLINES is to declare or define C variables and functions that are going to be used later in other &FFI; statements. FFI:CLINES is a special form that can only be used in lisp compiled files as a toplevel form. Other uses will lead to an error being signaled, either at compilation time or when loading the file. Examples In this example the FFI:CLINES statement is required to get access to the C function cos() (ffi:clines "#include <math.h>") (defun cos (x) (ffi:c-inline (x) (:double) :double "cos(#0)" :on-liner t)) ffi:c-inline Inline C code in a lisp form. Special form ffi:c-inline (lisp-value*) (c-type*) return-type C-code &key; one-liner side-effects lisp-value A lisp expression, evaluated. c-type A valid FFI type. return-type A valid FFI type or (VALUES). C-code A string with valid C code plus some valid escape forms. one-liner A boolean, defaults to NIL. side-effects A boolean, defaults to T. returns One or more lisp values. Description This is an special form which can be only used in compiled code and whose purpose is to execute some C code getting and returning values from and to the lisp environment. The first argument to ffi:c-inline is a list of lisp forms. These forms are going to be evaluated and their lisp values will be transformed to the corresponding C types denoted by c-type. The input values are used to create a valid C expression using the template in C-code. This is a string of arbitrary size which mixes C expressions with two kind of escape forms. The first kind of escape form are made of a hash and a letter or a number, as in: #0, #1, ..., until #z. These codes are replaced by the corresponding input values. The second kind of escape form has the format @(return n), it can be used as lvalue in a C expression and it is used to set the n-th output value of the ffi:c-inline form. When the parameter one-liner is true, then the C template must be a simple C statement that outputs a value. In this case the use of @(return) is not allowed. When the parameter one-liner is false, then the C template may be a more complicated block form, with braces, conditionals, loops and spanning multiple lines. In this case the output of the form can only be set using @(return). Note that the conversion between lisp arguments and FFI types is automatic. Note also that ffi:c-inline cannot be used in interpreted or bytecompiled code! Examples The following example implements the transcendental function SIN using the C equivalent (ffi:c-lines "#include <math.h>") (defun mysin (x) (ffi:c-inline (x) (:double) :double "sin(#0)" :one-liner t :side-effects nil)) This function can also be implemented using the @(return) form as follows: (defun mysin (x) (ffi:c-inline (x) (:double) :double "@(return)=sin(#0);" :side-effects nil)) The following example is slightly more complicated as it involves loops and two output values: (defun sample (x) (ffi:c-inline (n1 n2) (:int :int) (values :int :int) "{ int n1 = #0, n2 = #1, out1 = 0, out2 = 1; while (n1 <= n2) { out1 += n1; out2 *= n1; n1++; } @(return 0)= out1; @(return 1)= out2; }" :side-effects nil))
ecl-16.1.2/doc/figures/000077500000000000000000000000001266352375300145715ustar00rootroot00000000000000ecl-16.1.2/doc/figures/ffi.pdf000066400000000000000000000267131266352375300160410ustar00rootroot00000000000000%PDF-1.3 %ФхђхыЇѓ аФЦ 2 0 obj << /Length 4 0 R /Filter /FlateDecode >> stream xк+TT(c}З\C—|…@1Дэ endstream endobj 4 0 obj 23 endobj 1 0 obj << /Type /Page /Parent 7 0 R /Resources 3 0 R /Contents 2 0 R /MediaBox [0 0 476 252] >> endobj 3 0 obj << /ProcSet [ /PDF ] /XObject << /Fm1 5 0 R >> >> endobj 5 0 obj << /Length 8 0 R /Type /XObject /Subtype /Form /FormType 1 /BBox [0 0 476 252] /Resources 6 0 R /Filter /FlateDecode >> stream xк•TлŽг0}їWЬ#<$ѕŒяЖЈЌДjј€ЅtЗ‹–m‘ј}Ц—ДИU9–'3чЯјюрнas Ч ,оѓт1.ШhgЁ‰рА…‡H)Аѕ2§К,Dўœтчˆ@:€64!O№4|ЬЛ5зXw\Ÿs№г 4ођЬeС*‚ŒQ эЂ€Œx3ƒќŽ[Г”H&яЄ“Ё“ˆš\(МTс$ ‰Х0ГЊk IFЎЦH(G™@Л).щсrГœHрCЬјЖ•~[еZыДsB)шX,Бebа?РЋ^Cџnњt<з2Ёk=:яPиpžiѓ<|кoSО EвhU1G\1‡Œ,Њ5ї@v'ЂlJмэa,ЎјcuUБAZZR03HdYЫчУіщё[нЅ љДi•4–w“Mbnг—ћїџd‘B§gџˆšEЃ1БƒЉXQ6f2k7‹\‹КE MURtШЩ™ЯйЩП9ЗУчxєbд%[HjуЃ(у0xvЫаы2шјЯM}ЁФl> /ExtGState << /Gs1 12 0 R /Gs4 13 0 R /Gs2 14 0 R /Gs3 15 0 R >> /Font << /F1.0 11 0 R >> >> endobj 12 0 obj << /Type /ExtGState /ca 0 >> endobj 13 0 obj << /Type /ExtGState /ca 0.38999999 >> endobj 14 0 obj << /Type /ExtGState /ca 0.40000001 >> endobj 15 0 obj << /Type /ExtGState /ca 1 >> endobj 16 0 obj << /Length 17 0 R /N 1 /Alternate /DeviceGray /Filter /FlateDecode >> stream xк•SMkQН3Vм„*ЂЅtѕ–E’0~,ЌЛ˜ЄiвcšЂAЧ™—dšљђЭ$šаU7nDЛn@—.КpQшFQ(е_рЂ~€(t)ž™‰Щи*ъ…їо™ћЮНїмћЂБuеuM™YЖ/ еL§j§;ђ†dЇСTЭs3•ЪB€mЧцtРіо’œлЉ §ŸжЙЇс|хмё]ŸHR€OДkе,px\sEрЏЯщžf?!:t|иЩЗЙ04VjU„г0ЬИжПнџ“Г‰аЗЫaЯвФK­#КƒkIzEфѓЛ~№‘uмž0š-Ÿž™9ЯRьŒЂœeLˆГЌcЙŸ VДЕt’ЉІЩBЊЧїИшr=M–йљйлQЌЗ—qNЩИ—`Щеем<№9ј'tžЫ_€ГaЬгX› 1Л„ѓќЬ№‹ЕШ/oиfy!ђЫ%л)_N‚ѓиѕ/Vёђ}ЏЛ˜фљКЌ–*8'Р)Ељ€3 ŽпoеЎƒџfП•-G~щ;еЩ$Nйиmb4G* ВАЋ”"иЁю № *„,ЏAЕС/ПБfE˜T‰с€Й‹ин0і6uРЂ‘ЉLЋIe]љЄzА*nкы‡_/Ј<ЪЉ`UQf џЄвЧНOcЫЄ&Мжpо B…JQpƒŒЉxG {mjШы ђ{хНXu>д9Њ}+ЬпЕuC†‡=гНCдн2nGjСоZй˜ŒWн{~};БЕВo6z8нlиOЬƒ3ŠП3ЌзФr†lўл‰jёњПфСпњŸБ№Q endstream endobj 17 0 obj 631 endobj 9 0 obj [ /ICCBased 16 0 R ] endobj 18 0 obj << /Length 19 0 R /N 3 /Alternate /DeviceRGB /Filter /FlateDecode >> stream xк}’OHQЧПГ%BЌe&R№NЖWэ`ŒнѕoЪЖЌkІВЮОйоЬn%Bˆ.Aж1КXбI:†‚b]"ш(‚—э73Люˆкƒ7я3ПџПп{@](mšz€yУЩў(Л;>Съ7P‡A+­Xf$‘v™lqdэ}…фœ›суѕџ] ‚U€ЦЌЧзžіxРсћЖiO:Ќфвb“ИMЄ’1тWФgГ>žіq†[ ё2ёMХ'"()Y'цБld4ƒф—‰Л2–’'&пРSg^™іа}8ѕЙ&›А€хwРЅжš,д \V:kВнЄ;ЉiнR;;\‘Œu?ЪхнV ўАџМ\ўћК\оC9ОuЅ(J•IвРыУ]§мрBS˜s_ QP5ћFzМкыз‹Gѕ%Ћt{3qWАDї0vz Мќ \}\ј$€дuЁКmўРЭ+˜…–ЭйЌC–;Xи9:Y„^gБBо,к\АACioci]gЎЉХЗИ(ёL;ђzБкя9кAnŒŽаIѓ Јмъ­А4“Iїан x#У{zwAМЈj}ƒЮ…аўЄŠОQЅѓš=˜ђ8аmшёс У(Фo{1Бcкбd5ОUщ­ЪgвЗtЖќЦlaШБi"па\.5цБ”šЫХт^Х8tph0шk€!‰~D† TвhdЁ‘”Л6‚иТьБ–:>fЄп&ŸmзчŠфэxнA4Ž…ЖƒLў&џ–Зф%љ­ќkБЅЊiФ”ІЌ?ћCqЬеИmЅ&/ОBy#Єе‘%iў 'ЫWЉЏ:еXlЉErr№'ё=_—м—)Œi7вЌ›Љфъ,њF|йNšйЎЭЏ6зrm^™м ЎЭšUсHWќ ЋУџ5;П?џЭАh endstream endobj 19 0 obj 706 endobj 10 0 obj [ /ICCBased 18 0 R ] endobj 7 0 obj << /Type /Pages /MediaBox [0 0 612 792] /Count 1 /Kids [ 1 0 R ] >> endobj 20 0 obj << /Type /Catalog /Pages 7 0 R /Version /1.4 >> endobj 21 0 obj << /Length 22 0 R /Length1 10124 /Filter /FlateDecode >> stream xкНzy|Tей№sЮ]gЩdf2ћ~3™™ь+„„2„$„}‰@‚ *bŒEХFˆT ,‚ЏŠ K3*М№R^,вкŠmХТkm­`Љ5m?Д­03яsя„~ДŸєз{sЮ=л}ЮГ?ЯЩ\  ….` FiиР x/'ЩЧL/ћTтљФg‰8r"ВqзиЏ ќ^МO ЈkЩНЄƒl$›h˜>AВ+9k<†|Ш‚QxзУ}А9pNСŸсoф Е1zІƒy+18ёQVc‘J™’6шФ{оыІЃ„'…d$™D–“я‘Mфч4›NЅє!њmњ)3Й‡YЦќœ}€эужr[yMќ‹ФбФщФћ(E7м Kс1Єю$œ…Ћ№a–‹HЉ&3ёю"лщaВƒІ“Ш r–і_“OШrrTKЭ4‡vаt/=IЪ,`61Я1ПfО`‡s”лС]тТџФgЧзФšЈH|œј+jЅJІ&Р,hEj—Р јRБя^”к)x Ю(ї'Ф§№Wф#qb2я d"™GШМ+И|IQTE дJ]ДЮІ‹i}Ÿv1N&›УЬ`zё~›9Ч\cЎБ›ЦšйQьhXЫ.fЗсН“нЭіБяrхмpn7ытжpk™9м{м9ў1~пЧ_сџ(d у„ћ„Е(3ЈГ?ИЭZX’иУЗ`Љ!Гa3Jci…nдЎЙd5тИ2ЭЬcЬ(ZˆкpAmнЫa sьHќ’щPS!Ќ.иХVƒ›л‚вy Q‹’7„ГВГ2CС@†?]ђy=n—гaЗY-fSšб Oбjд*Qр9–Ёrk§u-ОHА%Т§ѕѕyrппŠ­З ДD|8TwћšˆЏEYцЛ}eWЮћЛ•сфЪ№Э•DяЋ„ЪМ\_­пљIп%3&7bћ™“/вЏДЧ+эg•v Ж% _№еккk|втЋдuЖwзЖд ИУaй]ххЪŽ# pFЖ.oЗсC^Qqјkj#v2Чj[чF&MnЌ­qJRŽса”Fм#/wŒ'<­ыŸћt4 Г[фVы=ІЕ)B[dX†œˆе_Б>|ЩіuїFЋvэ-“ЈkmыЎC<]ŸьЖШНжЕилрCАteSc„Ќ@BЦqaMн6­<дВаQљЋ§эн [Й0ЅБЯvдњ[kš"0ЉБЯЖ+МмУЖЧ*$ЄўpоˆМђГBВ=–|ўюЩфјЯNh”uЇ~ƒЯБSn2€Ш;љG#žпe?"[&Wmeа=Ї —сеDЬˆЯШEa.0К5веpіš$r- kњTv‡LCKuЎoщжХmpНояыўP„ўўЯoiсњ/@nЪ‚ОЉ+8ЃнЉ0FоЮцo—хлY;аїлjoРОЬчˆ)R—/А р\Œ8ecЃ$ Ѕa ˆІююdЯ/ENtw;ЛeKіЃў~ <0r4JК&)S]~ЩЉ№\ђKˆV“ЬгAЈв74* ƒџ9‡Koх№ФЖTсpйПˆУхп„УCП‡+юЬсJФЙBц№А‡‡пЦсЊЮс№­и†Wџ‹8<ђ›pИцqИіЮЎCœkeњїqИў6ўчs+‡Ч"Жcћqxќ7с№„oФс‰wц№$ФyЂЬсЩџ>OЙ…УЪ9eW€gO УУЧ`bТ  Ј9Ж€aЈCХ ьЂjЕ4ч[NЮ„Ћ•уc•є_VŽзЧ*ЁЊ2V)—ЂТƒdaйСЎ‹^џ-wьЋ‘QvќЕ œžІ’шXКїё…еPРv–‹’ъв‘zьE§ЇP0ОПЈ0M2KSЩ—q5нrX9#yЧaˆ#ХS‘.„'е“FвN˜еЬvЋz:ЊŠЊљL5ч U*Ќд pd-aXŸI­qЬФq#.аh8FЅfyŽh(a€z1JšТ*LЩx•šсАЗ;lLIБZм фЕ]›ВCZ;QДOИj‹й'дЖе|ZWcƒ*+’ŽЬˆUЪЋˆСX^Ž†ђ‚Uљ9ЫѕcQ'иЮ{ЊiUОm`€СцTSЮРкUњЪJKQ!in†fЂ!i%ФЯHŒŸ0ы~нПђcjОА)vєХwшГt]{ˆ™ѓеHз+м˜‘ИРнЯ]Т дћУNn йЬ1^тeŸ ЋИ5i\ƒШ<х6ЬќP7ЃjVyЈЧcgŠh…ОШр№ЉŠьvЏo‡Дpž"её§(гё§WћхPUе_%7є(‘ЫТCСe ЄugPcQCŠI_LŒ†TНрТL1!”eд6m1ЄБ|1a V9x}ЅО2''YЫзуЭЄY$V>ёЇƒAo,)R:Є„xЩ єCJ%?ы!ƒ 'ЅЗњЮЧПјг•ц9щиаџ o\z§•Щ]Š_8Кngќнј[ёxќПі4­ПќЧЖџ„МNjЯўVбэзPoц ЇR№ќ7?ь]eиlЄХЂЦ“JСcХЂ4‡#% ГлчЄЮ5IФ@UЌ*І$CРфN`F ЧЋѕ"RkСJeдС„' $1''[І+ S‚ї`=ѕKFђY-“@Г=л6ЂcL…#ѕќŸт/ОMHСЎMлуOХz{ЬЁћšžnE $џкV.эƒ“ёї>;яShшХcK?в Сгѓ„p†рaY у!x=jЈЅZ-~­P9tŒ{Š.J4ЄM7’-uќе‹†ЄTc•Kк™a ^ЖрњF&чњћЬЃзNR/wь`МК'ЎыХ­ћ•ёшСŽ ЪУ6 еќНФЁQvVkЂd:юќс­;_”7§ћ §НЬЕыяаїbЇ•zcsх=Ю`ЕAёEVЬsŽ(џ`ЩЯ(@AhAaQZ‰СцЬйЗрфѓˆгX\ЯAQ8 (C=,'2а:^ˆ’†RчЬ[|жЇ иkтR"cђќizљњdїч^ф5ТуВеа6 !e<ˆ•„Ш(вH9„KЃd{иŠ^5AdаЭ№ЂšQЋ /тю8ї}ŽuheВ=ЌV]Ѓ}Iъ\rЛЯD_†ŸFU%6YєЋ–ПUTˆіпŒцo@ ў=џњщБ_ЧRгЁмБk3и_d_ЛvЗ" =‰ѓŠп–џЯSі[ЙWІgд@ЙЁz•…БXLЊ€жa#“нj{IкДфVПaс•Эшx &ЋEЖПСИБ^ ’ к‰D:*›~ЛЛшGЃŸŠЏЏ]9šŽфŽ]яxiсKћfОШЌН~:ўЇ ё/‰zIeЪQbS*ЇѕTЈ€JјUИ,ЛЈѕЇж*Љз/P-д хЂQЋbœХB†Ъ­зК+rh~VХЁ ZQœ0ъNt…в­Ў(щFrм^!фЮзPї`MЅPYщ2 YйЛ3УYЎ1ЉЁ2ћАсџIЖ€‡Щf ьЊBлХиЉ›ўЋЊ)5­хЭШђќўќ~йEЌхŠeg–1ЇБHiЊ6S‹Я$)†P nЋDЬVt`ŠлzќqYH П†I%шГЬDЖїAAКР ўсЄЄћ.Т-tшсBСќT:$ш–N˜еДYj/^<ЛЈnж>љ№3’z7ї—WŽu>h h=†ьм`sЖE5фЇn:vdKїЛ3rGя\ovёКWС|ВHЬЕхнг0.Лс‡лыыЗЦЖИвfЅ–Џі‡ы~ѕІWгШEYG:Бю$0>, чяvЙ>p1щbЊ‡rV7'дЗFc ‰Ÿ#_ŸOВР€!a•tЌљ†в^М8рћe–0К)мГ-МкТ›‚ФЈЦЪ,Xƒ$Mх &=ЁЬ&40™Fƒ‰*0ћ3’LтЭВТuіVМкђіпОМ№№]Хх;щМѕыŸyфppдIюdьу'ЧћуWуёH…ќšх—яљшЭїЖЬмЏш}Eтcц,;р„]с‚]vВеЖ[ьБ1cDУvӘxЗCHq›4NСщДъCFТ„ЈСсV‡Ќv—;J„ввх_лBхјўђђ;EМA˜ёДfutiњ`2жйБ‡БNRbЦ’ФX‡•ЪЦхX'н!ж)њ–dЄCUIjE‰ЌtАJzюkЏ~щcЏ)\НaЩ“і^Яўь+bќ…‹љ`Ю“ЛПДуУ5Нџ)љ”8ШPyP–ИРєЃ\5љ бвMзэbї8Й€hЂЉn=ˆnЗІІnЋ†ЫOЫзgŒЏ&фА{МЋЄЅеЗ’ў{й:l.•Бi6V`ЇAP;Х .Re” 'X-Vйk –Щ‚СƒŒ%_nиБ|ЧЮ‡Wя!н …УіН\ѕњ}т_]љˆЬКќС™џїйб!ƒ#гб‡д'.Ає!.Ш€б†—mŸsьђ2œŽІr&Гޘj6…Еa“˜х c5o2ЇЩ™гЮ_ŠчUчМПє_Ж^іkNNщ="'eЄnГИ3ЪyAАHn— v[4a‹k—ыкАЄ\œ]­ КPЊ;Ф9BљBШn†~!эl`IеџELЩъ”„­ љІž`$еїуЈТВ:№ГУQŽp,яХ ЦЈOг›є,Џ Є;3‚рwxм*ЋY$):ПCТ!+б†z•ЂЧ rnјEyВsВ'ї7У§ЭВ сm–<$™*щњ^Iž „CВ0>’KOќ“gR>XїФnђaђї‰aё ц2ЪФ y‡ТуKMЃХбЊFБIЕZЛЧЙлН'Д3чАSKz–ю”:]7ЫgЙэjЃ[š/фчs.&п’Ÿ—Х9 ЕКPЪ№`Шe/(МEЏі—ЫœŽ]ќТ№ЕяЎъWи›фoЎ?гсб2њ п BІ+ƒF'AЊN›pЇIШ™…іЈ5J_[с Ÿ-kшрLФx)=*Б$#žт•3dB№ІuЂ+'єб™%ƒwV.‰ŸйїЙюPJhи“я†ƒLщжхoФЏсЉyѕ;Чы=917ў[=м?rеѕтw:/l­>TЙaкЏІLњ q“’пqЂoжЖяыГ‚&Я[+0ЧЉ8o•†]Т%žQЋ№ИќЯљЈе#ЭЎ№РЇb•Ї”‡’0(ч#45C‰йПт^lіЕsмБw”m VУиYa3 OЭ!P„ žДn‰™ШР$А5*• ёуь(ТЪp… :>е*ZuждBSЉЗOгЬзh§ЕУэЗЋ)k HnЋ;…€wКLš:ї4d™Ђ„є9Вас<ю‘ќ ЧЪŒ’”ЗрqQЕџjldъф;ЮЄЅ&›#&№6к!8 ЭR9\$п–eЛгў6ЪnЩГЎ~Cy9I$чxц[H %ѓСYБw\OћХIЙ‡м……ГЦ”х9’]ˆџЬ)/N96™О2ЛrnŠЅz№§ bя"В(щŠФyVТxЈU~щ{6\ВUмЌЮђЛ[мЉпc‰Šo‹А—tП7i‡ŠМл&hнF]АлЭ4”ъpЊBfЛУ%*ŒŠЭwЪ“С0ЌlP“ІBe A"XБХЅ`KmвшБ-LСЄщAs†q№€ŒаЖŒш­(цWЩРї›•…уŽМЖyѓ+чˆчzќ/ПŠ_'Цпё$uчц™пЛоЗї"s!ў9ІБј$ч:&[a9іuЦЇВ$]щаЮн#юВвLбч2шxЗYHхun—&]GC6G†3)+=еюЯИcFЃ8Cљ€ wYœР9‚lœHgСŠиuA`Ќќ@мKц5rpшFШ€~1wц•DЧрЇ?мЈ;rД6€u<ПЗ4|ї#oЦul[6ЅАтрВŸџЌыž§Gчn{tњNfџКб™•ёп#/ož5и3:іЋ;Іа 01 1С”!Ь(–е‰zЊSTк(ЋЁA-:вˆлСnL‹’ZTПЧnQ?йМЧWŠ’(1мД&Yѕ,VГœШ†ГfЏље{9›[ядЏо€ІrИt;eŽ3ДwilЋlе‰˜7йБшћ H~јЛeЊ­мfуsІ­ц­й|fF T*еIЃ2F…ІeLЭۘ\І]–ВLзщяШшtwzvчІ1ђИ<6? fЇеe3ч™ђ3S5 Ф` 4@щ)j6'ЭіC—;M`нљлr4‚JЇЇHЏЭb Y‡g…PІЃHч щ‡C(п^Xдw3NЃ IЦr=Ж’Ї+9б//—e,Ÿd—rП"хq$ЭGPвy%P‰0ЙxŽрВБх6т˜гd“ˆ/5])]—"†д Tj’ЧJРgaх1И$bЗИ’'ƒdЂЇTIЅP|йЮ•0ЃЈKЂ1§—­^№C7в`/‘ЃК '"WФ@ЭюЙ[‡…јюšџsјЯїŽЄ=\pјsѓдfNxшdѕ‚ѓ]9-CdвŒТщгяЎЭР '={єу[џsнŒіaХЃ&„ыВэiю‚мкя}їьљ—шпP—Ќ‰+TХЭ@я0хћ)љъ:%Uсk)З2МNmp ЛfŸf9•ё2”ЙnБлзЅљYrЌЙќ”’ь$нtA•r‚юзЧ.*СуPђ9pж Ц<Аdї›{їЭE)“wdшБызs3тяoŒе–Ѕi]ЇŸOпкЈФхr^ћУяfЅV~†ф?˜Х˜o>­ё >Р]RО‹ИёХ>љЌx€–ФяПжЈўХџѓ-†“; ;h9ЊpLхІћ3АМ†э^ішХЙ3ь№<ŽЩЅлSАtВј,УRe9 +АЌс{`іх"Яw"м5ИЖсШпY Т{ |DОEЮR­Ѓ3щSєC&ƒљ?l#{Ћуѕ|”џущ с7bЃј#•^ѕGuXСк їЂ_"Z›ясВиЌ2KР8@/хб8qFн]SsълuЖu,˜гњѕЗ&‰6hЛу7"N%гcN„dBфBAд@-д)п3Œq0QљЂb ю?ІСє(ŒЮ‰B–С9ђcFи ‹ь„gБМ„…фiX†e –чАА7[{А&OїБbјY2&ЌaНw™ь^›Zу§†Ъƒ/xЯл>9Jь{_ ЈFЈЩKфE˜ ^ђfџ#V™dлЌEоœкKАtaa”š=}žbяq’ –р;A№АфMяяŠђМ—ŠЂ”єyO†Ђ,>~рС^8е{Т§‚їПмѓНЧБьMNѕdEхwіИy7zЂd[ŸwƒœАєyз'Кёе7Н‹Г6{ч)ѓу6Gщо>o9ЮO kМЅe’wАћЂЗ  іѓмуМйE?ёfИ•e>М.їFяPœђИkCCБ%=d;d“э}1о#иDrŒЮ*л%ЈЯ, DЩУсвњЬЭYѕЁ@ж8o Ћ.ТіДЗQ}юFХBŽ) ѓœ‚I4ŠzQ'jEЕ(ŠB”МоWхх’НP…lй{@фE.JоРAі(йЇ ю;$В"A4EП9(ыІk{ъх6оф•%ћ$‡і…НЌмb• =•kš4CJDŠъ!ЯDyXiщЌВU‡ЪыjўQеr[ѓ/qG6mhŒєИ›"Хr#сnК9™ѓџЛ:ФЊ­:'gь”e:—,œЇќюЏmУвyКГнщšэѓэ_ИdрЗў`Ыь9эђГЕ-ВФпVYшЏёэяœw‡щyђtЇПf?ЬЋНЋqџМp[M_gИSљрРьъЅЭЗэЕцц^KЋяЌZЖTоkvѓІ›хщйђ^Эђ^Эђ^ГУГ•Нd:k4T?акщЋ]0жЩlˆŒž<Ѓ1тkmЊ‰’ђяNТџ,СЂ endstream endobj 22 0 obj 6840 endobj 23 0 obj << /Type /FontDescriptor /Ascent 770 /CapHeight 684 /Descent -230 /Flags 32 /FontBBox [ 11 -222 769 737 ] /FontName /XOZFTU+Helvetica /ItalicAngle 0 /StemV 0 /MaxWidth 1500 /XHeight 513 /FontFile2 21 0 R >> endobj 24 0 obj [ 278 722 722 722 722 722 722 722 722 722 722 722 722 333 722 722 722 722 722 722 722 722 722 722 722 722 722 722 722 722 722 722 722 667 722 722 722 667 611 722 722 278 722 722 556 722 722 722 722 722 722 722 722 722 722 722 722 722 722 722 722 722 722 722 722 556 556 500 556 556 722 556 722 222 722 722 222 833 556 556 556 722 333 500 278 ] endobj 11 0 obj << /Type /Font /Subtype /TrueType /BaseFont /XOZFTU+Helvetica /FontDescriptor 23 0 R /Widths 24 0 R /FirstChar 32 /LastChar 116 /Encoding /MacRomanEncoding >> endobj 25 0 obj << /CreationDate (D:20061021004957+02'00') /ModDate (D:20061021004957+02'00') /Producer (Mac OS X 10.4.8 Quartz PDFContext) >> endobj xref 0 26 0000000000 00000 n 0000000137 00000 n 0000000022 00000 n 0000000241 00000 n 0000000119 00000 n 0000000306 00000 n 0000001013 00000 n 0000003044 00000 n 0000000994 00000 n 0000002142 00000 n 0000003007 00000 n 0000010726 00000 n 0000001189 00000 n 0000001234 00000 n 0000001288 00000 n 0000001342 00000 n 0000001387 00000 n 0000002122 00000 n 0000002178 00000 n 0000002987 00000 n 0000003127 00000 n 0000003191 00000 n 0000010122 00000 n 0000010143 00000 n 0000010366 00000 n 0000010901 00000 n trailer << /Size 26 /Root 20 0 R /Info 25 0 R /ID [ ] >> startxref 11044 %%EOF ecl-16.1.2/doc/figures/ffi.png000066400000000000000000000647721266352375300160630ustar00rootroot00000000000000‰PNG  IHDRИјяœжI pHYsgŸвR IDATxœьнexзпЦёйdу@Œwwww ЅИЛ)”hЁкв+ЅHqwŠŠЛЛЛ!BмeŸyЎќgg'ЩZv—ЭїsхћcцЬЩ,!w&G*•J ЮЦм,AAPd( 9YЁPЋ@бoVO”e@Aaаe1еc5(Ÿт [р‰2 ƒ  Ш (2Ъ€ ‚2 ƒ  Ш (2Ъ€ ‚2 ƒ  Ш (2Ъ€ ‚2 ƒ  Ш (2Ъ€ ‚2 ƒ  Ш (2Ъ€ ‚2 ƒ  Ш (2Ъ€ ‚2 ƒ  Ш (2Ъ€ ‚2 ƒ  Ш (2Ъ€ ‚2 ƒ  Ш (2Ъ€ ‚2 ƒ  Ш (2Ъ€ ‚2 ƒ  Ш (2Ъ€ ‚2 ƒ  Ш (2Ъ€ ‚2 ƒ  Ш (2Ъ€ ‚2 Ciю€бŒјз‰џnŠ+КзѕЧ У[ўЌСї/žОWЛжwŸг&НуџјiзЊ?џ3ќКщЖПvt“жU,сЂ‚ ŒъЕ№м‰{тJŸaЭ'џи#ыzІAP`="ТЂƒ?„‹+‘БFiљcp„Єх˜шј ŽŽŠ“o\ёёIrQAТBЅЗ=:2.ыК&Уа @AAPd0FLС3OЎ U‹ЋЕмyrYьEРj”Рjд-ЕњŸЩйсЂ`5zШ (2Ъ€ ‚2 ƒ  Ш (2Ъ€ ‚2 ƒ  Ш (2Ъ€ ‚2 Ciю@Жрџ6dЯжs6вАE%Яœ~QАe0…;з^Œъљ‡ќ{щg2ЋY. VƒЁ€ ‚2 ƒ  Ш (2˜ЬІаЈeХпџa`#y|м,џЂ`5ЪЌ‡вNњšJЅ2JЫšЭиййъд‚“ГCB^FщŒ…_ЌC/XG'{ЋМР,ЪЌ‡fxMNN1JЫšэ89;Ѕe€Х"(АNЮв f”–CC"%ž(€е#(А^овigўЁ†7›˜˜­q-WУ[X2‚2ыQ PnIхƒџGУ› ŠЛ“фРЪ”XЭ№o`ГСс’Š­OO›X8‚2ыQЄ„fёк…'6{эТcIЅ`‘9eжУ3wЎЂ%ЅYyлš“6ЛoћEIЅzнRЖ А|eVЅVƒ2’ЪСн—##bєn00 єђй‡W)­wƒ€OA€UiаМ‚Є›АgЫ9Нмјї1UŠњО| ЁA3щUж‡  РЊДўЌІЋЛ‹Є8gкџЗ!zДv§в“ГvJŠu—+XФ[Яў>eVХббў‹~$ХаЈQ=&%%ыдTHPјШž ““Є{ђѕжм .>eжfмД.Й5vЙrюQ–Г>Мзvџ‘SGn7­8щэЋ IНVƒвЛе5B/  РкxzЙЮ_5RГ~сф§ц•'m]s":*6НsU*ее ' ]жЋѕlЭэЏsфrњsУXўч€lAiю€ё5oW­яˆ–•дC#ОДtк˜U­:е(WЙpо|ољм“’R‚BТоО>Кџšџ›tG3џђз6ф€ьƒ  Р:ݘзџоЭ—7/?гќЋи˜„=[Юяйr^ЇћŽhёyŸ†FърР/X'gg‡=gg пЮ№Іœœэч­љывa†7ј„”X-;;хЬVя™ЌЙ`œіJ”-p№ЪœžƒšБc€OC/XЙжjT{ИpзЦ3Л7Нwѓ•–gйик4l^ЁKяэКжvrrШЪ,”BЅRe~Tz'+iіWэ0F =}єnїІГWЯ? |њс}XdИhkk…р‘;—З[оќЭкVэи­nю<в5цŸ|Š/вўЌ_т%(ШОbcуп‡E„ЧфЮ“ЫЫлMЉД5wFcxPfш€ьЫЩЩЁPQ6ЃШc2 ƒ  Ш (2Ъ€ ‚2 ƒ  Ш (2Ъ€ ‚2 ƒ  Ш (2Ъ€ ‚2 ƒ  Ш (2Ъ€ ‚2 ƒ  Ш (2Ъ€ ‚2 ƒ  Ш (2Ъ€ ‚2 ƒ  Ш (2Ъ€ ‚2 ƒ  Ш (2Ъ€ ‚2 ƒ  Ш (2Ъ€ ‚2 ƒ  Ш (2Ъ€ ‚2 ƒ  Ш (2Ъ€ ‚2 ƒ  Ш (2Ъ€ ‚2 CЁRЉє?YЁ0bW ыјЋv˜Л V(Ÿт swДЂ_тх‰2 ƒ  Ш (2”ЦjшŸ€ЋЦj ŒЂsоцюB6Тw–Ц№я9)))1IRTк) Œћ‰ё )))џыƒ­­Н–PклeХMгщޘ§ЖЄJˆ‹WЉT†\1†:,Šцџrк0юYїП–ƒ“Ѓy/ЇыЗW|КјжЈЇзŸэќcЭѕcчcЃЂ38,*,тцЩ‹7O^СЫзЇг№оЭzvttq2M'Cо­к^\)U­ТœЋг;ўак]+П›+)–ЈZnЮПЋmlєЅѓMЛA/я=N{YЉaЭЖџЅeFў>Ѕeп.z_:=:нГп–Tc|єцНо—ЫXї‰C{|=,‹`zoŸМлЈЛ'цєpuЯ“лЭЫ3ЏOѕ– Њ4Ўmяш _Вш-[ЅэЮЗ—Ь{9]ПНтгХeE‡GЎ˜іћWЭzŸлs$у”,єц§Ъяц­жўмоЃYз=Ѓ{zуўсuЛЬн ‹Уm`•"?†ћ=z~чь•c›їЮ0Љ_йцП љцўХцю`eн\В~Зфђйч/^ЈћФЁYеoЃњ{Ъo‹NmЫєayvcЎлтSФwЬТщЦjЭ+^c5Р2Uoб`ъњŒ~ –œ”ё1,<8єƒŸџучЏ;ђ>PrLJrђМгО^ЉЌеК‘ЎАsАЯxЪВ–Д|КdтЫСZ”3ќ.`љ7Пjж{|=ЌыИкЌЄуцх9єЇЏ;ыѕ}з‘’9Й;ЎЎлО™oЉЂFыn– єѓп6EПяО4wG,‹Йn‹ƒГSйZ•M|QVЬVЉtЯ“л=OюТeKЄцрЋ‡ЯЌњ~ўПwтУ’“’ч§vЮ5Х*–жЉ}[SўЏeтЫСZ1F9*•ъЯёГ$Ћ[(Š‘sЇvŸ8TЇѕ&Н хŸЖ~ОЃ‹ГȘ”˜ДєыŸгзЌЗoйІзŸ™Л‡лР*еhеpб™mэ‡єд““–Nњ)99й,НL‰ œ‰Ѓ›ім9{ERёлЗ-ћtжЃЕBeŠOZўГфї8Џм~r§žў]ЬJ%Ћ–ПLNJ^њѕ/YЗэХЇ‚л ›Аwt<{bлСн$ѕчw\ЕЭ,]L‰ œ‘”””Ќ‘ЋЗЈoШеšзkбћ3IёШЦєn0K ќq‚‹kNqхёЕ;G6XhoM†л [2{RЭV %ХЭs–EGD™Ѕ?€Щ”3rѕШYЩbзœ#чN3АйцН;I*іЗЬч‘n^fŒ“7ќД8,(Ф,§БмйŠBЁ&N3ы­}ƒВ ЅЋWl= ЋИ’”˜Дtrv_?˜л ћ№-UдЦF-9„~ 6W€ЌFP–ё1LtМ|}rИх2W,DпiЃне§xxљжёЭћЬе СmMи;:јѕ•У‚>šЅ3€ шАsЖ.ЉИyy˜Ѕ'Х9gŽaПLўuаdqqнЌE5Z5tЭэnЎ^™YnЫ‡зя~ъї•сэдhй@Пm&dO^|о={-ЎD‡Ejsbb\‚џkMјыGчœ9Д<иФ—ƒЕ"(Ы‹вјВwЮсb–žXšкm›дlншЪЁгi•ЈАˆ5?,ПxІ{evІП-БQбзŽœ5Мя‚љ o@іс”УYR‰Žа*(ЇЄЄјПVRB’і›јrАV НЇљDй9?VўПaПLvRџБсєЮƒwЮfї‚И-ВЭ‡ЌбсZeрSDP–Ї9‹пПЄёєЩгgъ(Iqљ7П&Ц'˜Ѕ?‚л ;pr‘>Qvpv2KO (Ы“™ЗЇ0G?,Uы]KV-/ЎјП№лљЧsѕЧBp[XНишIE2›А&ŒQ–—гУUR‰2ež\ПїTы}AыwjaтЙt666ЃцM›иЂOrRrZqїтu :З*PЂА){bQLy[М ц6grцЧeЦЋ€сШ>B?HƒѓШЋUPVк)ЬoШЅ]txtmтЫСZ”ххдxЂlт1XзŽлБ@л оJзЈhњE' •)оyt?ёувЄ„ФхпЮ™Еk™‰{bQLv[œrКTmZзИm@ІBC$їСOcSkН%%&}нКџИЦ=в>–LќЩX›R…ње›іш ЎD~ _;ѓsѕЧBp[XЅ{чЏKЖ­Э_ЌЙ:˜A9]хыV“Tži=Л.SЎм~vыпЃчiіNтŠOf•3ЦIFHŸміяН зЭе Сm`}nЙ,ЉдjгиL„Щ|щ*_Зкž%Ф•KOЖш§™QП~ќМЄ"y€нsђ№ž“‡хZY-ЇЛы ПZ0ъ{qqйф_œиbЇ>|%[сЖА>ЗNЉe[ЅmЭжЬеРxЂœЎ2Е*йиЈнŸ['/} 2JуšAЙD•rFiй,vi]ЅIqхнГзЛџ\kІюX n kђјњ]џчЏХ•Š jЪl;X‚rКœsц(RЁ”И’’’rb›ж.xtѕіѕсЮљ‹*TІИс-›бˆ_П•ŒйЕh­џ ?sѕЧBp[X­Пџ-ЉдmпЬ,=L† œЭџќЕ!,шЃьСкл4gЉЄв s+л4Л<ѓѕšoq%&"ЪРЕ юœНrяМкŒ.[лЦ]лвІ…h?Ќg‘ђjЯряœНrjчAsѕЧBp[|ъ">†-;SRlаЙU.7Гє0‚rFььэ>;@R<НѓрЙНGѕk0"$lщЄŸ%Х–};{ЪЏ_ƒХжжvєМi’нkXaвM - ЗР'-.:vvяq’бЩ.Ў9ЬgЎ.&CPЮDѓž=}ђHŠ Gх№i]›Jˆ‹џЙпWЏп‰‹ŽЮNн'5Ј‹–ЄXЅ2э‡іWТƒC§ќХѕ%8Гn €OTlTєЏƒ'?Н)]ЕџєБn^fщ`JхLи9иŸѓdUуфЄфп‡NљoЭŽ””-л ~№cЏБЏп•дќ0оЪўЏщ9y„WМцю…ХсЖјД$&$XЙmD­Я$C“A(SЋrѓ^Ьв+РФXG9s5Z5ју„епЯ“џžђлё­ћЯšXІfЅ NOLH<НурšФDFKўЊi­њu1~ЭЪбХiјЏпЮю=о(­E| —Я_;ƒR’“3mФЇˆяї›џ№)тkМ~ Ќ­AГ&†‡„—›ЦќюУСе;4ctjЗk:~ёL{G‡Ь§4 ž5ёцЩ‹бсЬWSУm`FкDс ”Њ^qъКyЙGў>u|“žI ‰цюˆeсЖАLіŽЙѓчѕЪяэUРЧЋ@о"хJVm^Яжжжм§ЬFЁ2`љVёЄзЎЃ?Ÿ˜‚яПvчме'зя……D…FЄоO[Ѕm.7змОЅŠVmZЇrу:VЖ№IшœЗFкŸ§U:Ь"€–ђ)ОHћsіќ.Р’‰П ш—xyЂlям ЛДnиЅuъЫ”””ЈА[[[зœцэ DP6&6ОАж?Ѕ аAAPd”e@AAPd”e@AAPd”e@AAPd”e@AAPd”e@AAPd”e@AAPd”e@AAPd”e@AAPd”e@AAPd”e@AAPd”e@AAPd”e@AAPd”e@†BЅRщВBaФЎYAПФЫe@AAPd(еPJмzc5@'6Ž§$Оs=ђ•˜‹ј+бљxKк§dЉTЊИИDqХСAicУW4h‹ œмНїцч_ї~ћЮЫYз= DPЖ~Лї\-Y~ђт%GSRєќ…whht>}9a}BB’qћ`БЪVn§Цsнz-жˆ,fgg›?ПЛГs&у;џZzЌ}чy‰‰de-0Fйš­\}jјш5*Й™SхЪцяиОj‡vUJ•єqwwI-FМ|єтeрЕы/—Џ<“ 9ыиёћ†ЌиИv„BЁШђо˜AйjmкraиЈеšѕвЅђ-œлЛe‹ š•'OЎ)9Uл敇 j$)ўНъЄо X>‚ВЕйрІdHБ››ѓпKиь%•ЛЏ2ш0ЃЄЄфїяУnн~}ќФ§ы7^Оy’еk„GGЧ'%%g~œ†˜˜јlИ&cbbRttМЙ{Ќzauў\rTR6И‰›ЭжЈ^ДByпЛїоЄU"#уž?,^млР–“y§:xЯўы{їп8{юqrrŠјЏьэ• ъ—jнВB/jчЯяЁ}›ы6œџРиЏO=›џЁRЉVЎ>ѕпс;7oП~§:XЁP90ЙYгr7БџРЭНћo<|ф№!<**NЁPјјИєѕЌZЅPп^ѕkе,ІeптуЏ])ЎTЌр›3ЇSzЧ‹……EяйwурЁл~o‚§п‡йл+‹ё*Z$OхŠћіЎ/ог>**.6іKIКК:ллЙ3Пњ IDATЫ|g‰ŠŠлЙћjкЫ9КvЉ)>ржэз[З_:zќолwƒ‚"ApqqШ›зЕB9пнjЗo[йййAк(d1VНА*Џ^-=QR||яЗХѓојп+OЮžГW\YБdPЋ– obе‹L……Eџ0ыŸП–“фcMv#†62ЙCž<ЙДiYщм_Мчe|фj;;Ѕ OŸ Жђќ…'тƒџл7)ƒ/џаЩSЗnйv)уџ–K–Ш;zDѓQ#šлкfђ+С—/ƒŠ•QћсмЩяыж)‘ёYсс1SЇяXЙњ”diШ4nnЮ#‡57ІUъ-?qуЂПŽЄ§эўОjзІrІ)Xаѓе“ЉОsзoШˆU’L/‘+—гв?єь^'уЮ[VН,БVНр‰ВU9{ўБЄвАAiЃЄdA† ibШ@gР\ŽНл{Рв(mŽOќcёсѕ›ЮmY?JvЙqm=vЏSзqq‰кŸВ`бЁяиЉЙЫІ'OЦMмИaѓље-_Ў€~=LЯ‡oЖђУ‡№ Ž ‹љхЗ§ЋжžоГc|эZХ ЙœJЅš9ћŸŸнŸщИ”ˆˆио§—ž=џxЩЂ†\tТeЋrўтSIЅ]›Jfщ `!v§sЕC—љZІф4ЁЁбm:ЮЛр WМxщiчn ЕOЩ*•jмW&NоЌMJNsэњЫjЕПпДх‚=LЯЖ—:vYqJNбЄх/gЮ>2фŠЃЦЎћёЇ=ко^ії‰•ЋOrEа O”­Ъ \ЕrastА{ї_яо{БxhDЊ:Е‹7kR.>w77ч€сoп~ 11yраyМrЕh^^ћЫЅgЧЎ+Нњ-•§ЅЗЗkсBЙCCЃŸ< зуу;u]XЃz§Ў8~тЦх+Nˆ+JЅmю… y%'Ї\НіBі‡ё“6ЖnYБ@Ц‘€оЪж#&&ўўƒw’bе*…ЭбРќТ†ŒX%IЩM›”]іч@йIЈ7nО?iуЙѓjЃŠG~ЙЖLщ|к0˜єэ–ААqЅXБ<Ы,S:_bb’fМћ{хIЭ”мВE…Eѓћ”,с#.&&&ђO+&%%оcбе 3K•є рчзУт…§Fhžопкй)wo[НЮŒЇЯў7ъумљЧЁЁб<`eыЊ”5г`iRRTџМeH В{…h.(ОxaПŒSr*…BБvХАвПGи_~лЏ}PЖБQ90ЙByпŒЛwџэбcїФ•n]keœ’S)•Ж›жŽ(Vf’xЉЛ%ЫыНЏат%ЧФ/э–-˜AJNUЎl‰ул|џУ.§.šЊgї:ЄфT9s:ѕэ]oњЬџ](%Eхї&„  Рza=4Ÿ(Лцr6KOѓzѓ&dЯОытJ“Цe43ЄЧззSВ№Еы/§§CЕ<}ФАІ™ІdA,:$~щццќЧМ>Z^Ђ`СмкЉEъc'юЅwpЦ^МЄЉN-tыZSR9sNКHЙ,WWчЇžщaIIЩлw^WњѕЎяээЊ}‡ j$~љъU№ѓчД?=Э‘cw%•AД]х#gNЇIкшqбT:TЫ;Ї6G.”[R ‰дћК =‚Вѕ№p—>кэœd#/?ПЬ“'WчNеtjЁmыJŽŽvтЪiэ ЎWЇ„6Yoн~/ЎTЋZX— ѕъ””TЎfИГ]z.]y.~щууІ§ЃwAzvгЋМzu3й#0ЋЋГ­ИТeІСeысщ)§іlј< ЋйййЮггrфpT$ Š7m\6гЗЮЮE {‰b{ќфН6'jЙUоYѕEшAЈVUЗеˆ]] №xћіcZхеы ZHuI§‡Š&Ъшtzўќю66 Э•ЊЕQ"хGdхЪх$Чqё:ьzz#([Љ-aсeX:;;л/GЗ4bƒББ Яд!јъЕ9…ЗЗЋ8(ќЈе#Ьreѓksи›ЏФ/•J똘ј›З^ЩŽќљмеƒrАNЇ ‚’’ђє™кНЊTБ N-(•ЖљдЛЁ=O­Ц]ЄR№ 2ц@PЖšП№§јQ:НАzšЫПј№дЃЩъŠš“eei9ш6(XmˆmRRrЭz?hн5yšŸxІ""b%s4GpeЊPСмњe#ЎФ Y„1ЪжУХХСо^э'Ÿ‡ќ“’’ЭеР,BУ4‚ВЏ>O”НМд‚Вq2iљ|Z'ёё2Ыфe,4TњIЙЛыМTNA_}~A2 ,O”­JХ ОзDzтуя?xЇыяRг“˜˜TЏёЌИИџ Ќ]ЋИоKЗYФXO”%“эœœŒ™ъД|>­=†э†Ghe7'ж#Ў%FSАxeЋвИa™kъ3пЏ^{aЌ |ўТSIуКЮћЬBvG’LНS_8йЭе˜л[иjБѕ‰Ўєј4%KI‚ оDZKКžŸ ‚ВUiмЈємХ•і^2ЈБQ—l,ш>я0Э лќо„дЎU\зvоНSwыцfЬэ{<<д:YКTОЗчБ}-ЙЙJ?ЉЗяtmDP`ЕЃlUъз-ecЃілЬУGяhПЃXЦ4ƒrЭХŒв2`Dšƒ^ћщМ„ ўяУФ/ѓљИщп' ’9sЯ_|яGm2nїъюгђ>„Љ;`qЪV%W.Ї*• ‹+))ЊЕЮођ…‹O<|'Ў”*щЃх’Б€)yzцќИшї&DзFBB"%ckT/jhЯDМНеf &&&Пж}q7УЙИ8HF_шzЏоНћјђЅ>ы7Р' lm† l$Љќ>џ сƒПћaЇЄвГ{mлВ‚ƒƒ]Х jƒ‚ФЫ!kiїžk’JjЦ ЪЕ4~ѓфi€лзžф^љљщ”ї§{гЈнЫBPЖ6ћ7, ОНBxxЬЄoЗвцёїO~(ЎиккєэUп6Ќ#йљфЉ‡ЯдЗеШдцmХ/mmmjTзmчМŒ5Ј_JR9QКW_Ц"#c+V›ZКТфДлwќєшIэZj‘§фщ!!‘щЌiпz\>ekcoЏœђuIqуцѓлw^жЏСррШсcжHŠУ†4)RФKПЌжА~iёK•JЕhЩэOїї=sіБИвОmeЭсМ†(S:Ÿdk’%ЫGEХiпТІ-юнћфi@ъЧkПвЅ|єшIэšjгcbў\rTЫsЏ]qфш==. Ÿ ‚В4 aўќю’bŸЫі§ЋѓГŸИИ„ŽŸ/xё"P\tqq˜1­ГA]ВRЧіU$1tЭК3сZяшОaѓyЩ~uƒ5F4HЁP дX\ ^ВќИ–ЇGDФў:я€ИвхГъњЌємЎM%Щy.9ЊMdOIIљх:ЩB‰‹KˆUћаoбC|rоПЛ}Ч/эуюывhIђ,%Х г‹-Aй 98и-Y4@ЁО˜RRrЗ^‹—,;І§Пў7oBкtœ{щђ3I}юœžyдwї,Šƒƒн№!MФ•шшј?южцм—/ƒfџВW\)T(w›V•Œй?Aaьш–’­4чџё_ppцУT*ешqы$“џ&MhЃ_7мм\іo(Ў„†F›И1уM=U*ејI›Ўпx™С10–/н†ИИЋ}”ЉєЙћSXАшP•šпЅ}ќќлў,КPNЯЁт`‡оЭЂ }rЪжЉCЛ*ѓя%)&$$ПОV§™ч/d22!!iеšгЊM=}ц‘фЏєk0|hScіШcFЖpU_$xб_Gўy(уГ#КїY,й“oсмоzlУ‘)ooзъ_JеыNПuћug„Ещ8wг– тт№ЁM%Ыншdќ˜V’ШОfн™VэKoŸэШШиž}—,жz„ Д~г9ЭтЫ—A.>5}g€ь† lЕЦi5zdsЭњѕ/4]ЈФ„/'ЌпЛџњЕы/оМ ‰Mxџ>ьњ—џьН6dФJoп1CGЎŠˆˆ•œ[ЗN‰%‹њ›Єћ€AМН]5џ­~ѕѕцЮ_,|ў\fb_RRђž}зЋдњNВ§dћЖ•;uЈ–EœѓS7ЩЎ=~~!ѕЯZЗсlLLМфрФФЄн{ЎVЈ6ѕˆњ“žŠ|hќTЌ“bХМ/ь')ž<ѕАFНГй{фшнд•ђ>|Пtљй„I› 'žѓ#‡Ѓ!WGЦT*еК2AY„ ›Я›И3@6ФЮ|жlсм>AA‘ВгјоМ љkщБП–гОЕ.ŸUпАf„ЃЃ}ц‡ gї:џОГQ=LьнcяўU*Њ_ЗdоМn9\>„П}їёа‘;AAвaEŠx-[<0ыzшшhПcѓ—еыNџP›0pшŠAУV–,‘ЗrЅ‚%KјМztћŽпУGў‰‰вс..л71ќЋrШ Ц7oП^Њ>HњхЫ щ3wЅўйо^);(іЛ)ŽПwљЪs;€єœ:§0Н5ЖЗяМќЧМ>’п0.ОРЌ™­­ЭжЃыз-9щл-Юќјj\›п~щncУЏ №)YЕ|prrЪѕЕоAИyыѕЭ[pСззѓФЁ)љђIчХWётоgŽOkїйМwядvаTЉTŸМќф}ч:;лo\;Ђd }Лаєз§} xL›ОSv~žь =Кеž9НЫЁ#wФEЅ­­ц‘а[;F…†FјяVчNеMй Л!їXП1ЃZ\:;Ѓv­т™*ЇzЕ"ЧўћvюЏ=IЩјфий)7Ў1alkЩмжL5Ј_ъфс)… хЮЂŽ‰UЌP№в™КюќWБ‚яЕ‹?wXШЗ_w8іп7’б Вьэ• ціоДnЄBЁHJR›ьщ™#НГ ЋШШиЛЏfpР†MŒОВб'[Ј\Ља…ггO™вВEэЯЊ^­ШіЭcЎœŸйДIйЌыЅ ХМпz]Л8SsYљѓЛoZ7ђєБiE‹цЩъО‰.ъqщьŒ5+†jѓЛPЁм3ЇwЙ|ю‡вЅђН'M—НqyжжЃлЗ­ьф$3ЂЃhб}lкЭ[ЏіИyрПлOžЄ-ЋЌP(rчЮQа7wЫцх;ДЋRГFQ~y’ГЮ(=T(§ћ6шб­іБїї§{уФЉўўaЉ!ЩЩЩ>>їœ;ЏЖ”gпоѕjT+*Ъ‚ lи|ž  dKљіsБББёєЬIJFvcoЏ,PРУЫ+—хЄdMЙr9™+%kщСУwт—ќЪˆжmT{œœ+—SЇU‹ЭSНZq§тЅg’ЭS‘х~‡dЕ„„$џPёGrВ[з^TпЙГQƒвЦю`6•’’В^}Ђ^з.5Rзьб­Жфр[Œ9Ѕ/&&ўсЃw/_EFJ—вЗи–Х—HL4Хцо’m‰Д‘œœЂЭц№њ‰‰‰ђє§гgš ˜žiо…шшјŒ75†^@іS ш8qeпю элVбђєm;д–iџМs Ѓѕ,{;yъс›7!тJПоѕSџаэѓZ“Ой"ўЋ›/Є(вJЅкЖуђБїž=|іќƒПџџV*ДЗWVЎTАU‹Šm[WЊUØхДœ&((bџ›{їпHOЇP(||м њzV­RЈoЏњк7'YcЄgїкvi/ŸИПrЭЉGп?{ў!::оЭЭЙXQя’%ђвЄa:?"~јОeћХн{ЎНx–’ЂrvЖїёqЋRЉpЏuкЖЎdШ2иIIЩGŽннДхтсЃwХs:эж/нЁ]•Ў]jЄ7gРИŒј.‚АnУYё•§њдKћНŸJЅZЙњд‡ямМ§њѕы`…BqфРфfMЫїг‘PШ.™ЉэЩЂ %†Ьв`GщЖj|=B{еыLПqѓUкЫ§ЎZ>D›7oНаgРВД—..AяўbO"ёзЃо_‰},нМѕы*”ћХЃyiпs6›-О|сєt§ж=yъСзSЖŠџЄЇYгrѓ~эYБBцЋfuЫЉќ§C'OнКeлЅŒcLЩyGh>jDѓL7Ђљ2ЈX™‰тJрлПrчЮ)ТБуїОћaч•Ћ/в;Зe‹ ПџвЃByпДJLLќфЉ[—§}"%%нюхЫчОyнШєBvЊЩSЖЮ]p0эхШсЭўњЃП .><|eЦK­чШсјэзэ'Œm-Л‚„вЙПИЋіNlгЊRІg§]аьI|фj;;Ѕ OŸ ЖђќЕљџэ›дЊeEйvФ_‰†d]†^@ЖжZ§лЬњчЎ^K7ЄyєиќЄMтJлж•HЩFГ{Я5qЅOЯКт'S=ОŽОаc;ы  ˆіŸЭkжzŽ6YV„у'юWЉљ§’e™ячšu-ЇYАшPЩђ_oоz1гєфiРИ‰ы4œyяў[элћ}ўVэЯ % ‚pфшн†Э~КuћџЗ1К{яMеZп/Yv<ƒ”,‚ПhгVП,_qBз.M›ОЃAгйЇdAЂЂтО›БГzщ~~ђ›;Ш”яТбcї*UŸ&IЩІAP€l­•њђъЩЩ)К.иДхBzпќT*е–mkдќПMП]\fЯьšЕЭ6vьК—(Ўєэ]OќВk—š66jKnлqYЇQЁaaб-л§v№аm:ІRЉЦŒ_ŸqЂЭК–гŽїе†‰“7ЧФ$dzpškз_VЋ§§І-tъ• гgюњfъ6mžG†‡Чtќ|AttќызС-л§іфi€6эЇЄЈЦ~Е!-akcЪwлљmПіH>ђЏлxж§z&TY&~.^zкЙлBЩ…Щ0FВЕzuK|жБкž}зг*с}.[Мєh—ЯЊ-’Їh/їУп„]Кќ|ѓЖ‹’сГ‚ ,šпЗDёМІэИеZГўŒјeъE%•чЩ“Ћi“ВЧŽпOЋ|ќu№аmэwjљхклwќФ[[›ŽэЋV(_ >wgg‡—Џ‚žПј№ќEр•Ћ/$˜9aCЃ†ЅЫ•-`т–S Оrэz™mНнмœЋV)\Оlш˜xџАKWž…†F‹HLL8tEЏ\-š—Я }Бe+NЬўeЏИтфd_ЙRA[[››З^kЮч{ћіуW“7;џфУ‡pq]ЁP+šЧЫ+ч‹—A’ПJыиЭ+ГЕщвЮнW‚‚"%Х‚=ЋV.\ЄАз‡Р№ЛїооНїFr€ПhЇЎ o]™#‡Ѓ6WЩ”)пџАvŸЭг)‘AВ5›-FЕэ4їфЉ‡тњх+Я/_yЎM §њдиПaжє.лyќф§ХKjk‰ЄMуыёEmqPaУІѓZхГчKfaЖo[yёТ~ ЪьйўєYРˆ1kФџ6T*еДщ;їьoЪ–S§НђЄf>kйЂТЂљ}$?K$&&ђO+&%%оcбе 3K•єД0}цЎД?whWхЧŸ—/W u”mJJЪ§яzѕ[rџк ‰+VПЌWЗф/ГОЈZЅАГѓџЏ/ўќљ‡йsіЎпx^ќHјіПЛїоˆ‡8ЇGœ’•Jлп}6bhSOOЕэ0ян;щл-GŽо_Мће†еЭє™2ёЛ0щл-aajл+–Їbљ‚eJчKLL*PРCпЯC[ Н€ьЮССnяЮ ’zЕaoЏ\0Зїк•УВЂWйгњчФ/•JлнjiжЙSu;;[qхпƒЗТТЂ5дДjэiёЫе‹nп1ЭGДYћ"44ZМцЎ eJчЫє,[[IX|ќD:Y-ыZсо§ЗGеЃdЗЎЕДY№[ЉДнДv„dUВ%ЫgzbЊяІtЊY#Ѓ5€›5)ЋЙrљrЦŽn™СYvvЪšееšѕšоС^^9Зn­ЭЬП§м]2щsыіЫ’їH'цzllLБ^rzЃ PгЂyљДЉ6?FНі ŽŽŽЯыэ–7ЏЋщчd+k7Ј §tssnпЖrzwl_еббNМРЙѓO^Н *\и+ƒK|”N&Лtхy§zЅ2э[›VХГєŠ‘^%ыZaСЂCт—nnЮЬы“iЫЉ ЬнЁ]ёtеc'Дz|koЏ9ЌYЦЧ8;;јјИН~­Жўкм9=•JлєNIUВ„кфWЭ)zщљrTKooWmŽ,\иЋcћЊтO<>>ёєйG;UзђZfyA1ЌЉ6ИГA.9Ьн‹l!,,њŸНзХ•n]k‰w†“Ш‘УБ]›Ъi#8SmмrсЛ)2ИŠk.gIeЭК3ћ5р!VЁМяІu#ЭвrRRђіjsћѕЎЏeXL5dP#qD{ѕ*јљѓХŠyg|VѓІхR7Щ˜Л›‹$(зЌQ4гГђљИ‰_FGЧЧХ%d:RХжжfир&™6žfм˜–тO\„+W_ш”Эѕ.ИК:џ8§ѓŒЩR НРќЖэИЏЖRЌьzbšЃ/6f6њBѓзљ7nёѓЋWAZїдд-пК-]‹­ZеТ:ЕPЏNIIхъѕ—™žЅхєV77ЕŸмн]мм\2=KsPodd\ІgUЌр›'ЛR7jXІhQЕСа—ЏjЕ”&sН ѕъ”0яЯъeЬO2юЂhбПqѓyЛкЕŠ5Ќ_КQƒвujwrвa[ђ,jYВЖRiѓж+љЃг‘?ŸћлЗг^ОzљЎЮЙ34"ЋH†cФ TЊЄЮлњ,ш)~)Y“X{цzД_‡'‹”0ГuЮI*.=э;pYІ'>}&]#bлŽЫѓыeg—юїїB…roн0КKї?4ї–Rч{ytњЬЃY‚`oЏЌSЛxГ&х:ДЋЂЭуе,j9(XmЂ[RRrЭz?dк™ŒIвМЌ\ЙœєhййY‡-tхцšљ ‰‚ОjA9**.99Eђ\цzД&žЅژSrrŠцЪn’їДyјшнŒэjбМќЅГ3њ X&йnZ"!!)5кNŸЙЋpсм}{е< azˆd]Ы†Ќh–žјјЄLqmb!\]uЮю’ ,BddЌ6ЃЈ%Ьѕ.˜c”0ЇЃЧюНfФ7lЪ|Aхre мИш7Э шѓDY}Sє|>юњ]:лО жџ`Б$у.œœьћї­_ €‡N=Лз–,Жpць#?ПЬзоЪ€‹‹CћЖU/ьџњщ‚э›ЧИЛKЇ]ЙіТ4-{{ЋmБ‘˜˜ќZ‹eХЌв§яt=хџGёK-wQб”mп‚2цqџСлkъ›“uъP5gNW6pvvшаNКЬХFѕѕ•ѕІTкvэRѓдбЉ’AЯзДиVЭ(-звXњЩSщЂxйФщГ’’фG­Шњј1ъі7тJ }ƒrЖ}z€yh.ŸмЗw=§šъжЕжЖ—Х•›/HћІЄЄT­ѕ}\мџ–Иxf†ц]YЪћЖkSiѓж‹i•k7ўgГЎeAд/%9хќХ'­[UдІёT‘‘БѕЯqйЖiŒ–яY”шшјЫWžзЋ+н :=ы6ž“ь‹Ў§Ййі]р‰2f””,Y>йЫ+g‹fхѕk­MЋŠ’эЌ=іПЎž8mllьэ•OžЄ}мМѕZћKHЖ,vtјп*cYзВ eJч“ь:БdљёЈЈ8элпДхТНћoгњік/Єt)эOЗ(ы7IИЪРђ'Ф/+W*TЖŒžнeлw  SSЉTББ т”љ%9Е< 07oBnпёKћVпЇ аесЃw?|WzvЋЃTкъзZъvж’Ђц‚Ъ’!Њч.<жўїюПЭ ЉЌkYЁP дX\ ^ВќИ–GDФў:я€ИвхГъњЌ%l V­9}џСлЬ„SЇJFG ъпPяыfлw  S{ѕ*иХ}ˆјувхчВGцє*>ь№бЛ&ю* 6§Ч]Uj~—іЁЙ• “ЕыЯJ*}zе5ЄСn]kI*[Ж_” i­Q­ЈјхтЅЧД|(ЈRЉNŸ}$ЎHтlжЕ,Тиб-ээе‹Юџу?m~XUЉTЃЧ­“L;›4Ё6ГL))Њ‘_ЎMШјАЈЈИ1уз‹+Йr9ѕюiа?Аьљ.”0ЕШ}џЊ-Ÿ\ЊЄOuѕЌЉЋV-*HfХE9ІіˆЁQƒвт%Н‚ƒ#{ї_’IжQЉT#ЦЌyё"P\”$уЌkYooзC›Š+еыNПu;Ѓam:ЮнЄ>ЉqјаІU*ЮИWюмљ'­;ќ›оaaб_єњѓСCЕ%2fЭј\ЫQущЩžяA>=)))ЯŸФХeђ„ eЫЖK’M7 |œ,‚ННђГŽ™ŒО(Z4ЯФёjOђіИYБњД#щџЪюо§Знz-^Бъ”И8alk7гДœjЮOн$ПќќBъ5žЕnУ阘xЩС‰‰IЛї\­PmЊфъ+ј.јНWz§љ„œ=їИ\•oŸ <"§ФGhnјuГсЛРЊ№щ .QюkqхФс)ЉЛ9р“АvƒtмEя†eAКw­-YIcяў‘‘Бт%чf|зyЧю+/_ЅUоПkнсїђх ”*щSЊЄOЉ’y==sМ{ъї&фјЩ—.?“\ЅRХ‚ПЬюІyѕЌkYGGћ›ПЌ^wКјIjllТРЁ+ [YВDоЪ• –,сѓъuаэ;~љknўчттА}ѓ§6pЖ#†5]БъTrrŠ яо…~3uлдяwјњz.фхтьрџ>єё“ї11вŸ™=NNNyѕ*јеЋtїўpvЖ?Аgb™вz.vЁ)ЛН Н€Љйи(rхr(•ќ;Ш,ŸмKЯх“%ьь”]>Ћ.)nм"xкВE…•ЫлйщМТ†—WЮ}Л&dКВЎхT+МtfFъК цЎXСїкХ;uаmcpЫ4zdѓ?цѕQ(к\̘їбƒпдЊ)н+Ф@йъ]  Рд ЪИ\ќQScПАVIIЩ’фjoЏќтѓšЦjПЛЦкЇN?zћіЃЄ8шџкЛЯИ&В.РzяMz‘"E)6]Б`Хоu]БЛЎКі+–зоЛшклКиБ bWPQQ.EzKHой“IH&H$aџЯфzgr‘ 9ssя9c~КЕ( #нх:ЪЪŠ#‡З{ёtUq™žЅwf. ƒшћK†M07злйЦЦ(tЩ€'–Й8›гь›65№цељЂK‡ЈЋЋЬšб#>v•o[GiŒсПѓ[`p8œКLКЁaWб ”4~aГПН>#.Ьюб­EŽGf)ЈІДрz”†р ћШз˜9Н{C &?ПФиb*Йk”eљz”‹+ёE|ъпgcЂŸ~ˆ‰§TRBMшfjЊлІ•ƒПŸгЈсэЬЬ„ьБk3sUU1oF%\Мќ,ъЮ›ЬЬBnЦ4uu s}KKgЇ&УЗщао…цфЋц$Їфffj™7бГЗ3щзЧ'Ј——ІІъƒЬўШWтїФКXЃ №пхйТЦГ… їћввЪТТђЂтrƒЁЇЋЁЇЇЁЁQї`KzgцRUUюеУГWOюУттŠšіwf@“/ў~Юў~дЪв?XЃџ- P‚ --5--5KТ@ŽЮЬЃЃЃ.ОHYућ-4к@ЙЌЌ*+Ћ0+ЛPUUЩоЮ„R ќ{АX5ЙЙ%9_ŠђѓKѕє4LŒuLMuEьв§~eeU’~€RSУЎЈЈжвR“в**Њ JuЄњƒзЃђђ*eeEeeЉЖЌЌJUUЉЮEhсП ЄЄЂДДЪФDЇ^В5е#™@C‘(‡Ој—ŸЯ„?={>і]b&Й][[ЭоЮФБЉйјрŸЛzдсЬЉЉyч/Х]ИєьўƒDn CЅіўЮн=† nkaAыvЙДДђяГ1ф–сCл’‹žпŠJи№ЮЛФЌsЪЪЊєє4ьMЭ&шаоEш9srŠNўѕјьљиOЩЙйй…l6GCCЅI=ЏЖ#†љіьоBlP›’’›‘љ-лK3={{оУММ’{nFо|ѕ)97'ЇˆлhhЈеоЯy`џV}ƒМiЦхUUЬиИdrKs+rŽЯz‘›[|)тљ…KЯоОЫЬЮ)*-­d0MšшY[z{йќ<Т_в]Р‡о'Џq=ЪOAсŸ`‚УсьџѓЮеы/ŸЧЇІІц1ŒШˆy;Йеув“›[|&ќщнћя2Г 3ГОVWГ,- Ќ­ ›Й˜љЙ}НdьЪЭ-о№nмГф”дМф”\nъ.†™™žy= s§–>vСЃ;ˆн“ššwћю[юї‚ХЏEОL!UˆэжеChеi  Бj<›љ22 fЯ?љзпOФіlчыИ|ЩРNЎ4Я\XXЖlХЙ{nRтcAЊЊЪ“'tZ0/ШФDGtЯфф\‡fГЩ-_вwrЇНoоzНhйпOc>еvl`WѕЋ‡yИ[ёZЪЫЋц…œкГ/ŠМѕТм\џФс)Ей\ѓœкАљ яс”Iwn§… ˆќќ’ХЁс‡ŽмЏЌdжvЌ‰‰ЮкUCGђЛ`_№gp{q;_!лrыЖ™/3ѓыМS'OG‹~m;9šMмхзЩ]hNžQSUђ'w~:щCіи‰ћ>zOю|ѕтœnЭщœЖ^`3_нЄІцݘ},тъ‹к.mƒбЋG‹Ыq+Qеa3_ќЫЯ[w\?qъqu5KtOFЏžЧєшжœwF~.f№№эЂЯУsуЪ|wkѕ;0 “ЛЭ|R}mцk$ѕNŸ‰vі˜G'J&тбуЄ.=жєьГЁЌŒZnQPфWŽnsЗэŒ%QUХмКуzГѓETьm§ІˆnНз‹ˆ’ЙCъаyЏДњЋзiоmякsKD”LDfцзNнVя ‹’tHqЯ’Нл.йГ/JD”LФ—/ХСТzєй 8бѕ#mоvЭЩ}ю‰SХ^я“ВgЬ>цл!”NќкмИљКEЫ…”(фТў?яxј„\МќLФЅЭсp._yсл!єд_б’žПКš5vb˜WыE‡ŽмŒСfs.E<ъПЉKЕyy%’>]#€ j ђО§ЗGŒо-XГQДk‘/ƒlЊЌuTјЙ˜ ›ђѓK%:ѓзЏe=њl OЭвД$4|~Шi:ї=EEх}n.+ЋJMЭ ьЕю}R6ѓГйœщГŽђ"l:bb?uшМ*--ŸfџШЏ:u[н яІgЦЌЃГчш•—ьгvёё“ъ№ŒЃ“њй"њўdг†ЭW&ўњ'Э›КЪJцШ_vџ}і)§ѓГX5нƒж:B­QLЧЛo§VHщ†Sf ›ф~ђ‘c&џvPАннЭвЧлжЮж˜ЩЌyŸ”ј>ыЭлL‹ЏцјЛoзmŒXВАПа3_И7tфСiZпЖM;ИY˜ыыщidчЅЇмИѕњхЋ4r‡3oС)C-rеPбі„E­\}мЂЎЎтйТZQQсљ‹TСЩяєє‚YѓŽ?xјžЗ\˜‹С`8и›k“Wѓ0™5СТž?]IgHЩЩЙНћoфцDфВАаoюnэр`ЂІЊœœ’›ј>Kp:66.yа№эQзџјСŸвŽ›Д_шлПžž†З—­ЛЋeYyUffaєгфтЎФПџ'&Ц:]ЛаЪuЯ•™YиЋпFIoЯ@œ>=oС)ЁџЄЄЄшсnЉЃЃ—LОш8ЮЈ1{›šв|Š[Ўољw11‰‰Ž—Ї‹“Й‹s--ЕьœТЌЌЂ/SЃnПЁє|Ÿ”={ў‰Н;ЧRкUT”xI—иlNQQ9љ_ЕДдШха„–F“вР+љ”““sЇЮ8LilщcЗzХСХy oвƒ'„QЖ‘­Y9xt++CJчььТё“PЂфNЎ{Ж7іfљьyЪяsŽ=xШїќ”i‡šЙ˜Зmг”ЮЯВ$4œї}P/ЏхKКЛYr—ЯВйь„7#FяJx“A>$ьРђCПvNЋW ііВх%Їќј1gхš GŽ=$ЯRЧПќќъuy‰smЎEОф}яр`В$Єпˆaэ(+zG'­\}ёъѕxrуНћяжЌП2ПиЇЈ/ћіпŒ’Лzlл4ŠRSžЩd]ЙВјЬлwпЖ{ВX5‡m‹yъьDЗ§œ?Nђ…)&Эн­›Й˜3™,KK)І@‚я‘œœ;f|ЅQA1Nяо==Н^>j„ЙНДДrс’3єŸ4ќм?IK FШќ>Хyћ’6„ŸžО2tакџ ssЕЌгR7{ў‰Њ*Ое2њњšW/Ю]Е|Аo[Gn”Lќ{б-Zа7ъњБ{s).E<Ї,Ш9qфзАнуj+Џ`kkМsы/П§к•мX]ЭŠИ/ДЩьРd–ЪWЏЧS6QЙ6ГИ>SDБEE…­GQR>Cнxїол+зјо КtvлИnИшЕJJŠ;ЖŒІTЗћ.ѓќХ8б?ВВтѕЫsщ/є_ ЕC— њOЫ—œ4ЁSmщ&V†rp0!ЗDо|MsHAикEFЬ]egгњ‘”E&55ь{nв–я1mцQђњ‚ ў>5эїiнEфпPWWљsпxПvNфЦГчc%ZРM„ЉЉndФМ•ЁƒЄ—Въбэ;o(зЃcSГиGЫEЌКiяяќ,z9OЂX—ЏМ ? ъх5lH[БGmй0ROOƒм’\пЗš2;0™%ЧђЮнЗ(-л6§,6UАЖЖњКџ %ЗМ}—I™ћмОыхЈ[FгYqЫ`0…MTWW!7Ў^wIь\‹єmнJTrпЮЎ‚? Л›хєЉ"ŽRVVjн’яД™Y_kы,hљ’tЪЕЌY9„,8tЗМ\|^‘яє:!§м?dP›о=НФЈЄЄxќаdЪљЎНд• Ш—,gЖюˆЄДlZ?ТЮNLІdss§e‹„яdъУЧђУqС?б9JAAЁЅЙ%;Їў“в!ГYђ(њє…В.ЖS€+ЭдШ}ƒ|(сцЫзпЖтЅЅхSцœ:6ќП6VV†МŠч\БqЩ™™тSЅ);‹юЃЁЁ*XA`УšсbыР99š‘ццвЭJстl>b˜/žЦЦ:Гf№х”-,,Пw?‘цейцmзШѕє4ЖnEѓXkkЃ ^|!ѕЭ( цк'OьDgЉ7ШˆœœЂˆЋ|SЊо^Ж”ЋЕ6У‡њR."в3 ШлЖІЕKИNY,ё))%"ГYђ(“ї™qѕяг’цБššЊк;“[ШЉЎ\‹Їьс›4О“Dc2Ј5Ѕхоёёb—Nnt&nѕіаДne/і(sў№КЌЌJt^<žQ#кбO^1dPJЫу'h[7,V %yіш‘ўІІКєЯ0~,пЄZJJоGўYЗкшъj,_2ўAƒ;љзcJЪф% ћбпАЗ7Ё|ž кА!mƒ'„QRL хэe+щи‚ШЯ/ЁффЉw2;0™%Џ3ЪOјeзfЖЖb’™™щЙЙZђОШы=ц‹э:utхV*ІOCCеŽ0‰яГФХ­‘+eM­Н{Œ$ЅІІ,zЭД Ю| vпгЊ„RgїRKтљxгКпрбее ЄrKIЅЕQЩн y-фЬгXО‚—.NMФ–['STTАДдпOrL&ыкѕ—=њlДЖ‘ДЩьР~ЙœQЎЌЌNњРеWдRQQMйяbUЇ„ИІІКф4НтпfŒ ХЏЛd'ЩэЄмн,ХnŽЄАцЯHM)эQяž=O!?TRR,/Џzў"ExяZX˜ыЇЇ[Л™’šGч(7W ‰žVVV!eЋ€‘Є'БЖ2JIЁѕђŠЭfgfІЄцІЄцЅЄц%ЇфrПOK+ 3Q-=2;0€'—ђзЏх”cуКD™ТЮL ьЌ,ЉЕHш0х_ќW@#^дбQЏУihˆ_>Qg††/- ,Г.-­ЌЉa f_Ў/ЙќЕВYЌšж~ЫОѓœ4ƒ{: ЪAvdeS5X ”Ћ‡TU1GИ}їээЛožЦ|ЊЎfIz)‘йШЙ ” ‹ЈЁŒq=E-_ eЋКЬ(ѓЪ”nBiжžўЙЁnЫH Ж.)Љ^/:Sѕ’ЊЊBФа оџиXзaFY‚@™ХЊйДѕкђUчd­ЮЙЬ @Щхe!3ЪF’•ЮЊ§Ьѕ3ЃLйaІЎЎ,іIVKў Ђ‹Œ%ИшSSSŠ7tІъ%UЩ_Ж ‡Т"ъ s‰ыыkˆяDA#Ш)СuDiiљB{Š@ЙЊИИbT№С`длЫv`џVоž6^žЖєз#™€,“Я@YX8[/g|7M§\—Mю™Y|3Oцхєф§~бJJ*šћ„ИxЬу}ХПќ\B)Wў.1ѓо§wєпЛ?Jl€јъuЅ…ўНbu5+9…VUШ:йШ8y ”Лuѕ Дьк{‹цБч/ЦедАy †З-яarg‡ГmW$§ef~НwŸ/dянгSz‰„ЅэќХ8š=йlік —Щ-ššЊ-}Є{‡аЬХœRјcзо[фE5b?љшuBњћЄlюWъч|ч&ѕ=L ;ИPZvьОIѓиъjжжтџ$МЩ ?TSSІ_Сёє™hщ%6–йШ8y ”Лz88№-E ?““S$іРђђЊu#Ш-;Йr(sѕщэE‰НОWD;“дб)гNу‚ЂyЌ :|єСЛDZ‹OЮ„?Ѕ,€ ьтЁЄЄ(q§ƒС`Lл‘мђѕk§[ІттŠЕќ/†§ZЊЊŠOz ђhиЖккjф–sb)u­ksќф#:=)%B++™љљДjтTVVЏпt…NЯК‘йШ8y ” ЦoSК’[˜Ьš%gФ8сiJ<7цчіф‡ЊЊЪ“Ц[ЪЌ8ЩБ ˆIDATЪЊ–.?KgTЩЩЙ+W_ Зииѕшж‚ЮБВ‰ХЊ™>ы(›Эн-#Ѓ`ёВpJуЂ}Є6ЎoІO ЄdбоДѕj^žј|gъŒУЉЉ|YMцЬьQЯу™Ё­­>n п]kM {цмуbLO/XЙц‚иnAxЕАЁД<|œ$і(‡3jЬžз щtž‚G0™qyE­; ~фРy ” ‚˜8. Љƒ)Йхрс{”Oџ)vяНЕ“џУVKKƒў}[RК§6Ѕ+yŽ™ ˆm;#ЗlП&z<_ОЕƒR“oЫ†‘ђž­ьц­„!#vTе^Џ.6юS+ПЅ”л~}|М8‚05е<ЁЙхЫ—т–э–МˆЕU+;ЛАGŸ ”<“&tњ1c††2szwЪЄђ™№Ї,<-тV№еы4пŸB““i-вѕˆGЇЯ:њх‹Јь1ЩЩЙнzЏмL9Б }}MeeОOlbу’ea`‰Чpъъ*‡іOЄLЋ,XєWŸ›тžQп0>|Шщкsэд‡)э[6ŒTЈ?gjЊЛkл/”ЦYsOєМхЃАє,VЭљ‹q^mQоЈzїєьфCџ'’YgЯЧњu\~.†МЖ› ˆœœЂ}ћowшМ*;›oб‹’’bш’?lxkV iбœ/WЩчЯљ~W>z_0k“Щ:{>ЦУ'$ђЦ+r{sЋЭыGH}Ќа ЌЌ ЗoMi\З1" pѕг˜”іВВЊ3сO§VddќГшBKKЩШH›’'=Н kЯЕwя йћьyЪЬ9ЧнНмМ•РmЁмT?yJƒСАВтЫуёПЕ—і†E}њє%/Џ$#Ѓ€ќтџ‘hLф22O;_Чe‹ћSжE\Ођтђ•vvЦNŽfЦF:ЉŸѓоdY7b˜я€~­„žyјPпЋз_;ёмxсвГ —žyyкјЗs23ггвTЭЮ)JЯ(ИљRА6‡ёžСпїѓ5033нММRюьбГч)ƒ‡o75еumfncmФbБE'}њєEш‡LєpЗњaуTSS9sbZЫvKŠ‹+xеСТЦNмяфhцйТкЩБIJjnќЫЯoпe2™дљ0MMеПNќІІ&qЩn;ЃGљ_‹|yъЏhrу§‰mл‡ккЕmнД‰™^M ћQtвѓЉф;C33нЅ ћO™vHєљ†Mhеn)љ5іъuZ@ръЖmšzЖАЖЕ1ЮЫ+љœ–џђsтћ,ђЭ\Ьџ˜лћ—qћx- o2ь]fup+,,пПgхc.‚ м]-Щз`u5‹<МWцwюфж h4ф;P&bqH?&Г†В2˜ ˆфф\бŸ–і ђ>ДЂˆіŽЋЉaŸфЯѕFФѓЉb3АZYF][`.хrвцюfљЫЈі?ясЕфф‰н1ЙuуЈсC}Ѕ<4ЊІMMянZиЋпFоф‡УI|ŸEyуЇааP9vhВ“#’]ќW>0‘ЩЌ ?CiOIЩKI^‰SEEщьщЙ4жО7їА^:h~ШiJ{є“бO>дv”›ЋХЭЋЈЉ)ЋЈ(UWГШC:p№.AЛЗЂX”ыEM Л  TOOCJЏm™Нjdv`r 2€,ЈЏ@ыBEEЩвв ЁGбфыmUGGНЁ‡r@QQСиXGzч—йЋFfарЯl(@=B  e!(@@ЪB P2€”„@A&јІK'755eоC{“ @УB  пvѕьъбаЃ Xz e!(@@ЪB P‚Ссpъ~0ƒQCЈ_пыbF@ЪB PтЛж(4V˜Q2€”„@  e!(@@ЪB P2€”„@  e!(@@ˆџŒ‡cЧїIENDЎB`‚ecl-16.1.2/doc/figures/hierarchy.fig000066400000000000000000000050701266352375300172400ustar00rootroot00000000000000#FIG 3.2 Produced by xfig version 3.2.5-alpha5 Portrait Center Metric A4 100.00 Single -2 1200 2 0 32 #f7fbff 0 33 #ffefd7 0 34 #efdfcf 0 35 #8e8679 0 36 #000000 0 37 #8e8279 0 38 #efe3e7 0 39 #fff3f7 0 40 #cfc3c7 0 41 #8e8286 0 42 #fffbcf 0 43 #efebbe 0 44 #cfcba6 0 45 #8e8a71 0 46 #dfffff 0 47 #cfefef 0 48 #b6cfcf 0 49 #798a8e 6 1575 3465 3645 4275 1 1 0 3 0 39 50 0 40 0.000 1 0.0000 2610 3870 990 360 2610 3870 1620 3510 4 0 0 50 0 19 32 0.0000 4 405 1110 2070 4050 KCL\001 -6 6 3420 5175 5490 5985 1 1 0 3 0 39 50 0 40 0.000 1 0.0000 4469 5582 990 360 4469 5582 3479 5222 4 0 0 50 0 19 32 0.0000 4 405 1080 3960 5760 ECL\001 -6 6 135 5220 2205 5985 1 1 0 3 0 39 50 0 40 0.000 1 0.0000 1188 5602 990 360 1188 5602 198 5242 4 0 0 50 0 19 32 0.0000 4 405 1500 540 5760 AKCL\001 -6 6 135 7110 2205 7875 1 1 0 3 0 39 50 0 40 0.000 1 0.0000 1188 7492 990 360 1188 7492 198 7132 4 0 0 50 0 19 32 0.0000 4 405 1140 630 7650 GCL\001 -6 6 3465 6345 5535 7155 1 1 1 3 0 30 50 0 20 8.000 1 0.0000 4481 6766 990 360 4481 6766 5471 6766 4 0 0 50 0 19 32 0.0000 4 405 1380 3832 6923 ECLs\001 -6 6 3510 7560 5580 8370 1 1 0 3 0 30 50 0 20 0.000 1 0.0000 4533 7959 990 360 4533 7959 5523 7959 4 0 0 50 0 19 32 0.0000 4 405 1080 4005 8130 ECL\001 -6 6 6930 6435 9360 7335 1 1 0 3 0 39 50 0 40 0.000 1 0.0000 8141 6884 1157 420 8141 6884 6984 6464 4 0 0 50 0 19 32 0.0000 4 405 1470 7425 7065 SBCL\001 -6 6 6030 3420 8730 4455 1 1 0 3 0 39 50 0 40 0.000 1 0.0000 7386 3936 1299 473 7386 3936 6087 3464 4 0 0 50 0 19 32 0.0000 4 405 1950 6390 4140 CMUCL\001 -6 6 3240 1170 6165 2610 2 4 0 3 0 7 51 -1 20 0.000 0 0 7 0 0 5 6120 2565 3285 2565 3285 1215 6120 1215 6120 2565 4 0 0 50 0 19 32 0.0000 4 405 2340 3510 1755 Common\001 4 0 0 50 -1 19 32 0.0000 4 510 1110 4050 2340 Lisp\001 -6 2 1 0 3 0 7 50 0 -1 0.000 0 0 -1 0 0 2 2610 4230 1170 5220 2 1 0 3 0 7 50 0 -1 0.000 0 0 -1 0 0 2 2160 5580 3510 5580 2 1 0 3 0 7 50 0 -1 0.000 0 0 -1 0 0 2 1170 5940 1170 7110 2 1 0 3 0 7 50 0 -1 0.000 0 0 -1 0 0 2 4500 5940 4500 6390 2 1 0 3 0 7 50 0 -1 0.000 0 0 -1 0 0 2 2617 4252 4507 5220 2 1 0 3 0 7 50 -1 -1 0.000 0 0 -1 0 0 3 4680 2565 2655 3510 2700 3465 2 1 0 3 0 7 50 -1 -1 0.000 0 0 -1 0 0 2 4635 2565 7380 3465 2 1 0 3 0 7 50 -1 -1 0.000 0 0 -1 0 0 2 7515 4455 8100 6435 2 1 1 3 0 7 50 -1 -1 4.000 0 0 -1 1 0 2 1 1 3.00 180.00 360.00 7065 4455 5220 7740 2 1 1 3 0 7 50 -1 -1 4.000 0 0 -1 1 0 2 1 1 3.00 180.00 360.00 7110 7065 5265 7740 2 1 0 3 0 7 50 0 -1 0.000 0 0 -1 0 0 2 4500 7132 4500 7612 4 0 0 50 0 19 32 0.0000 4 405 330 2662 5460 ?\001 4 0 0 50 0 19 32 0.0000 4 405 330 3772 4717 ?\001 ecl-16.1.2/doc/figures/hierarchy.png000066400000000000000000000306561266352375300172670ustar00rootroot00000000000000‰PNG  IHDR€ѕщЈи› pHYs M MвЮ­NtEXtSoftwareESP Ghostscript 815.02—v IDATxœэн[š›ИP;пGgўУJ&RчСнc,„.[вZOнsќш‚И}}н€Жўз{`п§~яН IЅ‚QмVЂН\чЪF|˜X^гWхЃн›6%‡р0<_F•Lђ(EŒтGя€ЙnR„ТУ(0сИ€rбw2ž€Ш0БH_`˜;9тР„ ЉX&ѕ`5:Ра€МŒ%МфЅяшE3ЙуёеУ@{š ™ж§~O|КЩCP@{˜9ЭT 4І š ЅМгPт}Љ3›Ф7 ‹d /ЬTгїу?5№qtи•‚Њ /Ђћ @wš ™ЧЉєНО№Ып|хёсч?ОŽСо|х`vе…ќЙчMќЪЛ5L_˜Œ0г*uY?Ј/ž­Jю~јћПвqсЕ7?e`Jwїžq§‘мн*зѕUJTЛSyГќЊ Яј‰ы›_ќZф!o‚Sf}г7§ыW,eЭЋ.ќј'Ў“ˆ№ RєЇ>ўr-пџњкšј^ п,aїы›Э?ю3Ю^˜‰0ьx­OoТѕl5Ў`нДСТ‹o~оW`n˜”mNЌ™Эš(56ж}W`ј BxT]‡Ф–s , GђтчcќJ•НъТ7*m~Љ‚Ё `јK‘AUWу`сЭ6?Ш~†ŽŒ‚fQзЋ‰Х|Ыт›зЉ@˜ ЅLЏјќПзЋПЎW ЋОOЂH/o—u€б `fpeSЦ‡пњp=ўЏєб^YxтЯк|с я`цДћž€н?~Lˆн—ZТаjlОXp3‹i|}}э&юЧoYЮ4п|hI ˜uЉЙЮ]§§hёЭ‡+д€™Gњџ)s?eдž_Пu}–ц+нЋyИВљD8ЫРЬц8?в/їЫ)јвтŒДYxоцщ>М@ šёњtЪRЂN0t €  `ш@@:Ра€0t €  `ш@@:№>`ИъѕЅЙg_ч5КА 5`(L|)0tІњ kРа†K^;€R„is†5ЉCIвHЄ =ЅРzзж§ю+я–lЬ!€!Куnцћ§žЂЛЫyќQ C{š !_ƒX)?q§3†’A{тJЯХЭ'ОЈВ Ah‚†b.fлцыЧ3\fдYППўјзЬ–Эа’0ts*D7щx6,…+DЃ ™Кї›ІgЊє…€д€a їџ”Z T†Од€ЁŒтyіѕѕu№раСzв†  }ЄФфЧьМR'юо„‹РкззWJ ЗY  MаЃqцН›HВЦOm`ЩЧ$NLh•fшNCЋ]†PЉўB{њ€Ёƒ‹/AКXU§…д€Ё€”HЫЎe~\јё’Ÿч˜м]”ъ/t!€сДЊ5Шwџ|ўуgМ›в сdЯ1yЊџ8х' 5`h-} Žw5зS }ќV%  Ї•}э`Н*И 8Mаа€0LТK`,:Ра€0Ь@0 ЧsР„рѕI\Ž0!Ш`5˜6тРФтК ,BŽ цЂя"ЄkƒШ0Q<_+e0йFqw‡H(оG†наUrNŽ зЙВŸ&(1Lз4F!€!Јє[g1ŒHC8Ч=šСьt†`фд`"I CРТ•сп’F$€ЁГ‚O^Ibˆ†nъ=є,‰!> ­Еœ5BCXкщ;aгЛ0v€.0ДjЎDI `Ј+TєnHbшHC-НXBC{Ъ(z7$14#€ЁЄqЃwУ№iЈMC‘;z/’ФP‰†K&Žо I e `ШДNєnHb(BУiЫFя†$†+0œ0ЭЋВ$1dРDєІФNУЂ7ƒ$†0ьгб[„$†w0l‰о$1l`јCє6 ‰сAУэ&z{Ф,NГ:cЌК“ФЌIГ.б$f)˜‰ор$1+Р,DGяˆМЂ˜Y `– z' ‰™ŒfrЂw>’˜9`І%zЇ'‰šfBЦX­F3"ЬTDят Ÿf ˜Iˆ^žIbтРŒMG/Ч$1a `F%z9Ef<Ђ—+$1A`F"z)Hг—f ЦXQ$І LtЂ—f$1- `тНє"‰i@ŽŽ^тФд#€ Dє–$І8LЂ—QHbJРt&z”$ц"L7ЦX1ILLЂ—)IbNР4%zY„Wѓ‘ІН,KѓŽІ.б ’˜ L-ЂvIb0х‰^H!‰'€)Щ+Ш`јєš0eˆ^ИN/Es•ш…т$ё 0™tєB’xb˜гD/Д'‰ч#€9AєBw’x˜$ЂЂ‘ФЃР|`Œ'‰%€yKєТX$ёX0<ЮоЏЏ/б Adj{Ўe `ўeV<ш%TЪцqЁШ €ЙнŒБ‚†.ЦmЫs U‘žGГ›heNЩ87ƒŸeyW›реžL№І*Х ngЮгљN™•З§,Zvм&жяхќ|э5б%ž#ЋvЫKЫІЊя1Яy_ПЭиАЇЄœЪќГ{lЉн%€ћыr‡xПW<єюy™›ЧmKY|O рnжЙ\gK™лтiQеёUbжн+€[sлŒE‰ml.€YЇHЅГOЮѓё}M?;ЎkњT„НD(r7šYˆЎeжS›§FGŠ_p“MS/€Ыs_gв˜"7i–.išb„§I“UЊж1СѕAГ) vlAі-5ˆо }p тсдOd”ШьaP-KПІ Хi2#P|U›Ѓžў+gёт\z §ˆчб(EГюШ р|-vтoJпS39'ўb›тєќЃ 0Ї wцЌёо+0‰–щ›ўБRщ›ёљЊžЗ+дŠй§~пмКEО4“msX#_"ўз{F•ў"П6.Іяы‡SJmЧ’§ѕѕѕ§ыU_,СЊqнујЦПDЈчш{K•–з;‰ѓ"Й%ѕ`2ЈјЎ#ў%"ш}Adэ; nоЯ> wqˆжqлN—ВЄ?˜jЗW|ˆруSОRћЁ‰Фе(јsWDОDЈŸъXжNп!ФПЩЅЏЊщЛщW>ѕЏ1Ѕ$hСMnp Š|‰Р™šEзЛГ›ІЇжj‚є}˜fC(Ўо7=iвOсьEЕq}“{ {‰Рƒй .иќНЦЯ={ўЇhчlдkЏŠіAv%/§Уб6љЌя]jХŒ‚>!ШШч"}6ao ѓ<Š†[лєm3b1o™EЖ}‚ч&žХ­<˜А§ИAV#ШNэгwїу–Ьi69Ш5ъ™m ›J˜оЉлпыSРОћ|Н ЙјˆуйkŸˆбЂ№ŠЗ?)ОpЌр%ОjугЉEB.Б:o—А94<qЯœ-ЃшИњлЌ.}‹3k<Х93уЌ ,X Ю?_IЈыЇ№ њыМCc‹o>Еyˆ ъяœчЎЊ 5рИ2ІЌзу5пщЧєТк‹SE^џdaNKjР™К—ѕŽХЗћЖoD[Ј'=МЫvSƒ>ЇуДЂ)ƒ/JM7Pѕ7дьм„Rъ эx:є*оž›hCŸ6тUОдCз^–єN 2ЁсƒЮa4жfMОЅW‚_?ЙћЧХєЃ!VNiyйј rТ>„uеу$)^žŠGћюрћПrхЭ g—sŠК/ОK{œYПUjаЈлˆo8г&ЯjŸчЧC-6ч^Љ•й]HїJu€зуpїГTЪ6xWD№;€ Ћ'€ѓmо XЉ*œg7ƒпНЪ№U­x5жIN+СЋ‰sЧgMє_с-ЙЇЎ/ЏoіMџзОЄ/щъЦ4(чbŽч&ЂЅяM Иˆзцш[ѓГЎй{HКœZCœоDSЊ'јдф…EЎђUЃ"Б Ќо&wП†ФЙ€р2^[wCЕHkаQйDScžИ”жЏ‚ѓ;žЪЙь5lЖР–bІяэvг;RžЬИn”›јJ]|3jЅŸќ8БЯСŠL_|ЖЌR#7+ЭЊэЂИМзnдћz­в@о=‹эЬaНfЏk_b›ѕCZ`œы^Рkˆ&шZv‡‡š„%”wgЉХuЯ=šйmбэ"ШXNbпmт’Gn"rнїAзѕЎKтЙK› Ох–БуL:еЂ[Љ_YУ6 l#NЭћ€>рІŽЫФ"ЧТN УщW0аQР}™r B—8К@sжXWї7nЫ)7ŠiŒu™&ХˆЧTЧrЊп"ШБqс6ц%›Wу>љ)€CЫGPќАЦY(hмk7ЗёŸЩуњ”(†cт—сЬqШ№ тПт›уš>ЗЩŽ‘^Юd%Ъr‚Ф4хqРkё8$šђŠ?œс&9EЏтн€ЯбG1@Us@X‹ьvМ„ŒїЈ(№MгQћyЪ,€'wъIG1 ­Е­|s#€g–7Я€†ЋM([аЪЁћLЯщњ?b%>Иђdnк]xB'и[9† ‚%CњCљs—%ћ!…žMwPЏУš)хь$9У­ŒY€†лЦz№– ФГтнРџzЏ™"„СуGŸзфёпN]ЈЪ)6‡НW€вїљз7+pПпƒ7 m„кŸР"д€6*д†ЁИяЊвyT{љг<’АщЛ1Sп№ЗQv>3i2И#5р1ŒuѕџњњкЌ№шЕсБZд™ƒhœž>рŒ•ОЏУЗћ†ІЌанi‚ŽЎЦд’ `CЏ<ЄНj\8Ў+О†K2/c`кК{бдdщ{m˜єpЗ Рpд€У™/z_ХЗŽ1uЉFОž˜AXБ,rн>wЧ"G6тœƒ‹аХ‚§!ЅC­ гKQaСє§­6ь HK]–ЅИГ•ЃїUќОaЈэ~яsY6К=м“єн%†Ё=мž>р>DяŽ}УВhFpв7E„Оa‡†fК>PклР­mІ–TшEˆaЈэQЄƒь ЋБMаэЈјfт%Ш#№–ЅмˆєНNm˜ЙЙ,ЌЦ(шъDo FK1“^Н2КЅ(G}VвЗ*1 e р–єз"zа7 ŒK И щлžк0У‰гђќL%И™ˆ‡hЂЗ/1Ь(Тц\и›Qа%Iпю^їЙ‘вЄLrS.EєFГ{s\"x-гXŠ6д€ ОэЮ2Ікщœ/ЕЉ_Е™ZВуš№ŽŽa8%x}CЪЇт; O+Љg’ОƒR†*С ЈŸ&z‡І6LGRga#}чрН@wš S‰оYi”ІсЊП‡jSN"}'І6 œ ѕЈ z—Ђ6 п†ЋВG‘ОkУ№ К*МOє"†A%И*}Р;Є/7}УЂи№ŽокL-)}'†)B™с•&ш?T|9ІQšГ&hТ`ТRў—єх#ЕaNQ68І,zЩЁ6LŠ FЋзГzK_ЎУЌ`‚лˆ˜ж `бK)b˜ЙЉWВhАєЅ }Уl8њЄXюu„ЂїЂн+‹нxЛнООО6;GУнЪ}>ZЋ Zњ^ёёІоў|pВИ)lЇмЈюVЉ‹о+лгюїЕючоyь„зкА<[ЂXњ^Ё7+ŽсХЙЮ№бќwх›Љ%;ЎЩ Ž‡јœТ^bzЕ‹›9€U|ЏKй‡іs"1Ьаt7mДT вРГ a‰оRьЩ^‡hiй›УєФзэИhЖАЬ`jУ“™>}Ÿ)ЈЅLX~Xс4Ј-eКуљVфЊtv!+яpнH|ък”јaзЏ+жМЕеяVFСniЉъ/ъКі-Юў‰f1Нй%ГјЙrŽЬzthЬнFAнИFмОvЊџ‰з_Yгмщ{ЊфйpmзД!€ jРqиўБ’}Э:бqЪЁn3Їм(њРU рє0‹ ѕ(?LVё]эѕЋmok>BЖцVзP>€WИщ^awЭ1цљј№ КQіУ:;сŠeы‚ЫnxqХFA/u2ПnбыцЯWFGOпЅŠhŠя­^ЁєB@WkР.jяq_kсYDvTК•яQVоіВ2xт˜)eВkй епY‡ŒеfПЅXЙ+Tq:€™ьДі&/ж‹нШ.\Ф‰–"йmШŒтьR6pI\щєЫ ЄSmЁykžнzœђs#Ц№@зпMхU'ЦЪ+{mа@Х Њћ=а‚Щры>‚Дѓя–uН8ОЖžэђй§фюагБNщ˜Ћ:nA}(Xі*mћю‹‡лЯ=6С Ї†ЃЎzEЋ=ѓѓйєM_ŸRчоцrЖђ€ŽытЇяС*Е/{W(ЗPЪлїЧLпФ/жKпМЯh3ѕФ6Џб}}ЯnpЫоk–[ЎЯь„ыvjРё+ЧЎЇobЧmЦgvЉR”в`Ї•э-Rіz…пkЙUhзфаgлж€#ay•rЕ*2z%/’O‰\Ѕјњ[яељуЙFвeХjЇяюЃ•оЋаNРS€Ё§РЃ7хUJп”E]џќmР}озаэѕЪ^ћНБ;ЎјhПИо9\Љ=-уйžАЯTИœЅzч„-{з }\8ЫХъЂ?мЅ>qъЗоунЫYƒ kŠѕЎqgЅо5й&ЬWhяџщН"ЬцпAXmвї]=5ЏdП>•јќїŠ‘aYoCjрње3;}уєИJПьёlшЁ и-WќяжЉњл1}(5S‡iwDи')uОА}:5~]‰]–ƒžсѓT”E\o›J|W ˜žvNZrIЁžFМбЗL7Ј‹'u^5ОпК2RснB.ЎПRAКџГ§hаўмђиLVм}Ѓ˜ьђл@‡№ЧPIЏйФМѓЊ”šТј!Ш ˜€‡#р*+H1cn?jЏzљXѓрѕ]ф*№ЪЎц№ЇмЌG-# 3ц˜,Л- h‘1w•НiюgК‰oУј6vп­ўŸ›"хбЃЭ_ъхщг—}}ТювJ-чн2хЭvTі§PН2SЃрх™fьеMx\3SIhуOpСfНЊЕЗƒC[ѕ‘ЄRWвЄoК6mбн[#Т>kїќ’О Ъъї8оо+Т*ў„UщrЇwъYњ;ƒг?yє=Ћ{p†˜eяЌQіvЂЩ6Ї‹JУ‰&Ж}§rжwзŸНZ_р_ўЄožMЁsђФPeя”ЭNŽМЊfк‚ля№шс‡9исзй‡mЬКŸwGУqжL] Мq0ыi]]Y}K З2щ> љsЪUeїж0ж3<ёйŸœЂœюѓ˜ћГOє’Т^­Ml\g’AЇ;7UХ3;7ƒ+Zcvxžuі›ДЈA+tЂsOЏsZgзѕu№4Zу5‰lЕRъЙƒJмж$Ъ™іХЕ,}ЪСJЫ‘•ї‰œЈФŽMД :ХcŸОžЗvњ7ЙгСDЋ•о•s‚(0ёЉ3љ›]1œГvLsржйR"XэŽ6OЩ™Ч<УмфY%ЮŸ5аo‹ˆNQхеŸљ)›6тvБбё=аgХy-|Р)ЊП{k —ŠПzх)(o~щтE"ШjŒЮC2mиЯЕ~љeйїЊp•.Юћv)™ЧTЮкАŸ?ъќіщрВ ХˆšiЅ1ThЦЎў(ч1Є‚_б˜тBЖьТЃНЎБюј™^ч№E”cИ™ћ}ьыо@T‚uЎ_єzP]Х€cЎёЃї РŠ00Пћ§ЎИНƒЩ_Й ``b€P009CˆIP‹›žX‚$шKћџЋБCјHє“0t €ЈШУHяh‚цd№3СЉ’ОФ'€ЈЫmа. ЬFѕ7,нРЯєГ‘Л A €ъмНРДЃњ›цсЕƒ D“НŒEа‚)Б6001 Ь@ю2 LтыыK ч=РДІј&€бЙ”3( ь‘О2˜ `кё0в7 ŒЪЃG MЃ’Л ЭыЁМƒЖЕуЬи§тЛЏЈџнжоіq}}}iО `ШАŸ|П'}9ёcŸОrџљѓu}vж Лпя+зй6ўq%šlЃшыЈ:ћыWЫ5yіРжъŸ­ œЄ§ц&€сЃ˜œa“йуž&Ўнаlsг ;оДЗ=_зМќQЪѕн‹KДЋГДэmј\ћъ]Уѕ@ЇŒъo/ƒ›Š\Nд€Yб —’ы6wђјЛвЏл˜лэОJšОzЏŸŒЩjР,gџQŸйыОЇ§ѓЯmљAЊKЩHм€ecЌ­Pf%wю н#П?ъЧnj'–W§ЭџSу-эіжХ‚}Oп.яЕУи™5”аў@й ˜9§) Ђїšнq[эO1cЏ.:ŽœХїjЏ#€™аŸ‹un#ѓС4ЧR~ёэPфУяюдG6Ёw†XgКZю4}РL%ј№цу\ќkbЌ6юР~ќмŸ5ќ§Лхxiщ{жЛСќшyНюЦВEQ3юѕќbz•њўѓgибa­Xл &…м-ыреХEZ[03шНЧЮ6hGЮрП<њзыЧ№ух9RфРЉїhqжЛ$ОУ˜й\ЎВН­)Kћ˜ай}в-4Љ Ы’wDoKЛIœУ?J­tєˆДЏ_ПjTkЇяюC'юЋпПяї{№јљМюѓЏџєZЅuМючћв"€пяпЗxЭЮЗ“5щSыmc+н.ѕwоEoЏѕYжюnO/Дš \дЧ|ћ>5t я!Јc_П~}O›U<єўnx‘_4Cб(­ЬШЂІяЋщ{џљѓ ЊZЊ[ЊЮЊюћjSёUы eЗQњј+jР ЋNњvь|}вEV)e!WF_W‚oЅыЌ2цAХw›к№qUX ЪлЮеЛњ{ъ)фь_Љ2NЬєЈјопШўbов Ў[Љ_O”XVfHїћНYЊЅdRЫˆ=ћ[ЧНбa‡[‹о‡Цпуdњўз"Ћ‘иQњњыз—ж tНV…_T ˜ё<Ъtифn“пeoКзѕ'гВт{Њ^XА™^Б.ЕД–Ž'ЖT†?ђB}“:eлŸмgШр˜6щльЗкл­>џkСЅЕї˜Чэёп›uРА–яDЏ””џОА!ї XЖ‘sэг7хйжзœKYЮЛO–]ЗьŸЋф] `x+`e.c•žЧ'?{ўcё-ЭЋ…tПPЦбёFdї_uНј‰-Я‰ыЖљdДJ№эЭ&ы†љ}ЬзуG„л‹vѕlЌхHНA^•^Ÿ>ћ[НJзы<вjРа_ƒЧ–ž_ш{АЅ~zё-eйнx*}Ч%€ЯwcNйзі…Њ>_ЅянUkіцk‹ђ"{Vф^№JЋєqБwEž?зЎћ§ыыKC]яКЬкQ;‰дйgs7_ЌёсDз|Е'€вП'[ЭЙ ‹LЪјбЉќ;ЕJэs§ЯјъYъ+ЫЊњдЧ^чЦst$€ЁКŸЬ9|\јЁ^LюVФ VЏ,*rЃk/qvEvЇT=ƒŒёnМп­асЦj_”н~ТЈЪU‚Г#d753–V$ ЏД-™3фJыЅ3ЗЫЎ8еH[АЅ7qQeGSG(cпЋф1$їЯ?EгН+Дxѕєlš^Џ|чЭ•(}Л;uрjOBY5}ЃРŒЏP—ѕѕыWbЄЅ2cŠђ­Ga8яBОўѓё“ЛГbх§h№€ЌM0SјчŸляпЛ]­ЕџмёгЗ VЕХ \‹оG—˜ъяFЧ}rќў€Œ…<ы›ИŠйs“Яlх^№ВЖ-Wёf‘œ“Šoiлф?N‹qЊнјјУыt `І"ƒ№ЌQmјV45‹№СWpS˜ЛuI\Тk;і•ЭЉz AŸMІєћИДfp>ЫЭ‘еЬl_ДBКВбћз’ѕўŠЙ?"u%Юƒ3 š х=УЎщГ•5ŽіЛхјžЕоЃGЏ[Z|ЎМ%з№Zье€™жі|Ћ9oх жz‹,gn›YћќтюeДт| яаяіVь.Њ{Фиш9ђgаБФџХ№ŸСDzˆпЉ6ТйyšЂъ„ЬЗм8L щьE]Yf‘ЋT&пJЬЂŒењЖНёdQб2ИMњf,ЖдŠеоЩлzќdY%€Itp~.aљŠўIDAT’Фѕ†VQPэAF‰AUvbФ­Иђ:‡ || Ѕ˜E<Ћ0ЗЗГbIп6Ѓњ‹w ?–ію,Јё[g?пfнŠKЙsРЌnѓDуŸџ§{ажsnЭTEюђжр—ЮPv'^.ОГирPц§Dп2–иnЁ ’„mВў<ЯsŒ>]щ›чЏ‰“F~цuЇŽ‘0дr№>СR™}№їŸ?] ЧВл_ј|_›Ѓob8ŒŒGЖЦ р”Л+]їАыh˜хk3ї™удЬўяwЇ§ XЖU?:5J ‡’}Fl‚Ž0(&рna8G­жчŸšP&'Г ЮŒ{”!юНцvq>ž!hOQИЉG=feŸюУ]йэM› +=В}]тŠ)шРEХ+яЅo.P”Гz x‚юи‹ЊCŠYkРГnWКз=PoŸ њШl|•vl•ž tЬНuє2eP­\ыјШаЉСЈН'K6A'г4>хЅ+_w€ОfyЋ=ЙєZйе№"Ё›Ш'йцЋЏvкВЉ9ƒkѕ^Я фАА9`чpVЈ‹uAЭ^gлЫpГSщDЛ…й 9чЦpoBюЫю"ХЌМ‚qлuзasKЯАчpВ‰aŽ рQojЮv§МA Д!Љ,zKБ'й5тEќн:И- зд|б•ч•[4оЦ^НDŸИq`Џ)ц=ПU{ЋХ0#†жю0Ћ‰Ч^лд\Фps~ {АŽCjyЧw|hѓNщ”e&.Аол7ПWrњБ*LlФЛ‡cяЎ93mуYo_j#˜G<4o/њЭвЗF{§Љeю.АуЭЧˆХˆы†ЫА‰kqJ6Жь™pœŠяЛЏœm=ОИРкО^оёЙBЩƒ!8Xv'oИoњ&ОЃэ ЂВ—yъХmІS—СŒn”2Млд<Фš3яўсыыЋ{њž]єe~ќbЛ#Y`Pїћ=x1о}ƒ4ѓW7ОјZЯ>ўХМ~пƒoкР–ЗУ2˜!ЄЮј1ќ жK{š ‡8Iо™щЉžч.сQкё Ин'ˆœ\єѕoЗ|О-Џ›9lЕЬLКрЁkLl;ЋёЉвёЬŒџL[5+КЇяFДѕaeџЛЕЙІFЈЬњаž &ІєbйўdддЬ@оŽ‚ц!ТЉ+†Qпє…јŽІЂ,.НЊ:ё$;А‚ю“лtќuHє'€уйSЗБeлŸЃнAk…&šВo2ЯcЈЉ™ ќp}‚УФ(впpš]ЊЬA№‘87дqжdМ_<%MпЅuэ ћ Њџ}7rЦyоєxЊШ +й†;}RќMey/ѓ†Q4„•ЇxЭњидvp2O_˜^Я&шhgcДѕQ|LпупчyпоЎrЃЬ|~мžJyРЪxЙяЉD>Ћ[NйRвїуBєђВ m ИjŸ}`Ъ+NœЇЖЎяi№f2(Щ№ЮП}РŸ7}ќю&эЎЌLњУоY/;шlb‰E:ђ=тй“(у,VкYЪ_#ŸлДy^ з‚oP8[?Е>i|NЬz^йђsъЅŸqЮ&ktеG’"ЬюT$}+‘Оёе(-_П~mхчЯ‹ЫЌњžьтя‹ѓ$$ДБ-ёЭЦ(ЅOh—о{e’ММЋFН†+Q(9ѕЙ—@­-#АOЭ™ђХ‹З&Š=KйЙхl`&Д™Ÿ2~†KњB6ЬДФpUЂ.РЬьѕU bјК'Ѓ\Fр<Ьќvп˜$‰ЯкэЅvl˜UˆсlЂjРЌхнћƒ%ёЋЗГ]4 ЬЂ$ё;rкР,э] ?,ЦS—ИJ@ nЗOI|›1Œ?NцтU `ињЦЗ1ѓ8ezNhFУ[)Iќ-Z$Ÿ{‹Аы4'€!еЉ<~ёѕˆN|шMCІь<юТ™б`(Ќo0;ЃaКIjч)ЬчџoК;ХњЧbIENDЎB`‚‰PNG  IHDR€ѕщЈи› pHYs M MвЮ­NtEXtSoftwareESP Ghostscript 815.02—vВIDATxœэе1 Р0РПчс‚$ њuЯЬо:uќШ€ `Р0`0  €€@Р€ `Р0`0  €€@Р€ `Р0`0  €€@Р€ `Р0`0  €€@Р€ `Р0`0  €€@Р€ `Р0`0  €€@Р€ `Р0`0  €€@Р€ `Р0`0  €€@Р€ `Р0`0  €€@Р€ `Р0`0  €€@Р€ `Р0`0  €€@Р€ `Р0`0  €€@Р€ `Р0`0  €€@Р€ `Р0`0  €€@Р€ `Р0`0  €€@Р€ `Р0`0  €€@Р€ `Р0`0  €€@Р€ `Р0`0  €€@Р€ `Р0`0  €€@Р€ `Р0`0  €€@Р€ `Р0`0  €€@Р€ `Р0`0  €€@Р€ `Р0`0  €€@Р€ `Р0`0  €€@Р€ `Р0`0  €€@Р€ `Р0`0  €€@Р€ `Р0`0  €€@Р€ `Р0`0  €€@Р€ `Р0`0  €€@Р€ `Р0`0  €€@Р€ `Р0`0  €€@Р€ `Р0`0  €€@Р€ `Р0`0  €€@Р€ `Р0`0  €€@Р€ `Р0`0  €€@Р€ `Р0`0  €€@Р€ `Р0`0  €€@Р€ `Р0`0  €€@Р€ `Р0`0  €€@Р€ `Р0`0  €€@Р€ `Р0`0  €€@Р€ `Р0`0  €€@Р€ `Р0`0  €€@Р€ `Р0`0  €€@Р€ `Р0`0  €€@Р€ `Р0`0  €€@Р€ `Р0`0  €€@Р€ `Р0`0  €€@Р€ `Р0`0  €€@Р€ `Р0`0  €€@Р€ `Р0`0  €€@Р€ `Р0`0  €€@Р€ `Р0`0  €€@Р€ `Р0`0  €€@Р€ `Р0`0  €€@Р€ `Р0`0  €€@Р€ `Р0`0  €€@Р€ `Р0`0  €€@Р€ `Р0`0  €€@Р€ `Р0`0  €€@Р€ `Р0`0  €€@Р€ `Р0`0  €€@Р€ `Р0`\œƒч=84IENDЎB`‚ecl-16.1.2/doc/internals.xmlf000066400000000000000000002136561266352375300160310ustar00rootroot00000000000000 %eclent; ]> Internals &ECL; is an implementation of the Common-Lisp language that is based on a kernel written in C plus a set of libraries written in Common-Lisp. The kernel includes a bytecodes compiler, an interpreter, and enough functions to create and manipulate all lisp objects. The lisp libraries provide higher level constructs such as macro definitions, LOOPs, an implementation of CLOS, and a translator from Lisp to C. As a result of this design, which dates back to the Kyoto CL and was later improved in Giuseppe Attardi's ECoLisp, &ECL; can be used as As a standalone implementation of the Common-Lisp language As an embedded interpreter subject to the control of a larger C program. As a Common-Lisp environment with C/C++ extensions. This manual describes the facility of &ECL; to interface the C language and &ECL;. With this facility, the user can arrange his or her C-language programs so that they can be invoked from &ECL;. In addition, the user can write Lisp function definitions in the C language to increase runtime efficiency. Building programs In this section we describe how you can use &ECL; to build programs and loadable extensions that you can later on distribute to other people.
What can &ECL; do? Some day for some reasons you will be in the need to distribute code that has been developed using &ECL;. In the following sections we will describe the means that &ECL; offers you to do so. Basically, these are the alternatives Source code You distribute your programs in source code form. This is the easiest and most portable way, but not the fastest one. Standalone programs You translate all your lisp code to C using the &ECL; compiler. The final object files can be linked against other C/C++ libraries to obtain a standalone executable. You can build statically and dynamically linked libraries. You translate all your lisp code to C and combine the resulting object files into a single library with .a extension. You can distribute this library to other people and the final users can utilize these libraries to build standalone programs. You can build dynamically loadable files. This is the most flexible way. You translate all lisp code to C and link it against possibly other C/C++ libraries to obtain a dynamically loadable library (file type .so under unix). This library can be loaded a startup time to add new functionality to the &ECL; environment. In several of these options, we have mentioned the possibility to include C/C++ code. Even if this is possible, you cannot use ordinary C/C++ compilers and makefiles to build &ECL; extensions, let it be programs or libraries. Briefly, you have to organize your code as follows Organize the C code as a library, let it be static or dynamic. Build a function, say mymain(), in which the initialization phase for your library is performed. Group the code that interfaces to Lisp in separate C files, all of which should include #include <ecl/ecl.h> at the beginning. Compile your lisp source files. Let &ECL; build the final executable or library. In the final step there are ways to instruct &ECL; to call your initialization function (mymain() in the example above). These means are explained in the following sections.
Compiling files &ECL; supports two types of compilation. One is bytecodes compilation. This process is performed on-the-fly, as you load source files with lisp code. This leads to a series of bytes for each instruction, the so called "bytecodes". These bytecodes are interpreted in a virtual machine, which is written in C and which is reasonably fast. The other type of compilation is the so-called "native" compilation. This process consists on translating the lisp source file to C language. The intermediate file is later compiled using a C compiler. The result is an object file which may have different purposes. Dynamically loadable files or FASL (FASt Loadable) files These are produced in a &ECL; built with support for dynamically loadable libraries (Feature :DLOPEN is in *features*), when no extra arguments are passed to compile-file. These object files typically have the .fas extension, and can be loaded with load. They cannot be used to build libraries nor standalone executable programs. linkable object files These are produced when invoking compile-file with the keyword argument :system-p set to true. The object file typically has the .o extension. It cannot be loaded with load, but it can be used to build libraries, standalone executable programs, or larger FASL files.
Building standalone executables To build an executable you need a working &ECL; image with the compiler. The function to build customized images is c::build-program. The description of this function is as follows. Care should be taken that image-name differs from any filename in lisp-files.
c:build-program Function: c:build-program {image-name &key lisp-files ld-flags prologue-code epilogue-code} This function builds a lisp image up from the core lisp library, plus all components listed in lisp-files. Each component is either: A symbol: Names a statically linked library built from lisp code. A string: Denotes an object file built from lisp code. ld-flags is a list of strings with additional parameters to be passed to the linker. You can include here your favorite C/C++ libraries. prologue-code and epilogue-code are used to customize the initialization process of the lisp image. In order to build the executable, c:build-program first writes down a piece of C code which initializes the lisp environment. You can customize the initialization process by suppling code to be executed before (prologue-code) or after (epilogue-code) setting up the lisp environment. Typically prologue-code defaults to an empty string, while epilogue-code invokes the classical lisp top-level. Additionally, as a convenience, epilogue-code can be either a string with C code or also a list with a lisp form, which will be interpreted at run time.
Building libraries To build a library you proceed more or less the same way as with standalone executables. There are two different functions depending on whether you need to build static or shared libraries.
c:build-static-library Function: c:build-static-library {library-name &key lisp-files prologue-code epilogue-code init-name} c:build-shared-library Function: c:build-shared-library {library-name &key lisp-files prologue-code epilogue-code ld-flags init-name} This function builds a library file up from the object files listed in lisp-files. Each of the arguments to lisp-file must name a single object file produced with compile-file. library-name is the physical pathname corresponding to the library. The value of library-name must follow some system-specific conventions. To make your program portable, library-name should be built using the output of compile-file-pathname. prologue-code and epilogue-code are strings with C code to be executed before and after initializing the library, respectively. For dynamically linked libraries you can also provide a list of strings in ld-flags. These strings are additional parameters for the linker and their purpose is to link C/C++ extensions into the library. init-name gives the initialization function of the library a user-specified name. Thus a the generated library may be used and/or linked to a C application. The recommended way to invoke init-name is following: cl_object the_block = read_VV(OBJNULL, init_FOO /* function name specified by init-name */); Be sure to call cl_boot before the invocation of init-name. In order to avoid that the returned object is garbage collected, you should keep the result of read_VV in a local variable.
File names
compile-file-pathname Function: compile-file-pathname {filename-base &key output-file type} When compiling lisp files, creating libraries, etc, a number of files are produced which are of interest for the user or programmer. However, the name of these files will change from system to system. The purpose of the function compile-file-pathname is to query the compiler about the name of the different files that it can produce. Possible values of the type argument include: :fas (default) Standard compiled files that can be loaded with load. :c, :data, :h Intermediate files produced by the Lisp-to-C translator. :o Linkable object files. :lib, :static-library A normal library produced with c:build-static-library. :dll, :shared-library A dynamically linked library produced with c:build-shared-library. :program An executable produced with c:build-program. The output of this function is system specific. For example, under FreeBSD > (compile-file-pathname "/this/path/mylib" :type :lib) #P"/this/path/libmylib.a" > (compile-file-pathname "/this/path/mylib" :type :dll) #P"/this/path/libmylib.so" > (compile-file-pathname "/this/path/mycode") #P"/this/path/mycode.fas"
Compiler examples
The <filename>hello.lisp</filename> file In the following examples we will use the same lisp program. You have to create a file called hello.lisp which contains the following lines (princ "Hello world!") (terpri) (quit) If you start &ECL; and load this file in the Common-Lisp environment you will see the "Hello world!" message and the interpreter will be closed. ECL (Embeddable Common-Lisp) 0.9d Copyright (C) 1984 Taiichi Yuasa and Masami Hagiya Copyright (C) 1993 Giuseppe Attardi Copyright (C) 2000 Juan J. Garcia-Ripoll ECL is free software, and you are welcome to redistribute it under certain conditions; see file 'Copyright' for details. Type :h for Help. Top level. > (load "hello.lisp") ;;; Loading "hello.lisp" Hello World!
Example of loadable object file You can only perform the example in this section if your &ECL; image supports dynamically loading of object files. This is true if you find the keyword :dlopen in the *features* variable. This is true, for instance, in a typical FreeBSD or Linux box, Type :h for Help. Top level. > *features* (:IEEE-FLOATING-POINT :IBM-PC :I386 :BSD :UNIX :DLOPEN :ANSI-CL :CLOS :BOEHM-GC :ECL :COMMON) In this example we build a loadable extension which prints the "Hello world!" message. First you need to create a the hello.lisp file. Next you have to enter the &ECL; environment and type (compile-file "hello.lisp"). This produces a loadable object file. Type :h for Help. Top level. > (compile-file "hello.lisp") ;;; Loading #P"/usr/lib/ecl/cmp.fas" ;;; Loading #P"/usr/lib/ecl/sysfun.lsp" ;;; Compiling hello.lisp. ;;; End of Pass 1. ;;; Calling the C compiler... ;;; Invoking external command: gcc -O2 -march=i686 -pipe -fomit-frame-pointer -fPIC -fstrict-aliasing -Dlinux -O "-I/usr/lib/ecl/" -w -c "hello.c" -o "hello.o" ;;; Invoking external command: gcc -o "hello.fas" -L"/usr/lib/ecl/" "hello.o" -Wl,–rpath,/usr/lib/ecl/ -shared -lecl -lgmp -lgc -ldl -lm ;;; OPTIMIZE levels: Safety=2, Space=0, Speed=3 ;;; Finished compiling hello.lisp. #P"hello.fas" Top level. > (load "hello") ;;; Loading #P"hello.fas" Hello World!
Example of standalone program In this example we build a standalone program which prints the "Hello world!" message and does nothing else. First you must create the hello.lisp file shown above. Next you have to enter the &ECL; environment and type (compile-file "hello.lisp" :system-p t). This produces an object file that can be linked against the &ECL; core image. Type :h for Help. Top level. > (compile-file "hello.lisp" :system-p t) ;;; Loading #P"/usr/lib/ecl/cmp.fas" ;;; Loading #P"/usr/lib/ecl/sysfun.lsp" ;;; Compiling hello.lisp. ;;; End of Pass 1. ;;; Calling the C compiler... ;;; Invoking external command: gcc -O2 -march=i686 -pipe -fomit-frame-pointer -fPIC -fstrict-aliasing -Dlinux -O "-I/usr/lib/ecl/" -w -c "hello.c" -o "hello.o" ;;; OPTIMIZE levels: Safety=2, Space=0, Speed=3 ;;; Finished compiling hello.lisp. #P"hello.o" The final step is to build the executable using the c:build-program instruction. > (c:build-program "myecl" :lisp-files '("hello.o")) ;;; Invoking external command: gcc -O2 -march=i686 -pipe -fomit-frame-pointer -fPIC -fstrict-aliasing -Dlinux -O "-I/usr/lib/ecl/" -w -c "myecl.c" -o "myecl.o" ;;; Invoking external command: gcc -o "myecl" -L"/usr/lib/ecl/" "myecl.o" "hello.o" -Wl,–rpath,/usr/lib/ecl/ -lecl -lgmp -lgc -ldl -lm #P"myecl" Top level. Now you can execute this program from your favorite shell. % ./myecl Hello world!
Combining files into a larger FASL You can only perform the example in this section if your &ECL; image supports dynamically loading of object files. In this example we build a loadable library which prints the "Hello world!" message and does nothing else. First you must create the hello.lisp file shown above. Next you have to enter the &ECL; environment and type (compile-file "hello.lisp" :system-p t). This produces an object file that can be linked to form a loadable library. Type :h for Help. Top level. > (compile-file "hello.lisp" :system-p t) ;;; Loading #P"/usr/lib/ecl/cmp.fas" ;;; Loading #P"/usr/lib/ecl/sysfun.lsp" ;;; Compiling hello.lisp. ;;; End of Pass 1. ;;; Calling the C compiler... ;;; Invoking external command: gcc -O2 -march=i686 -pipe -fomit-frame-pointer -fPIC -fstrict-aliasing -Dlinux -O "-I/usr/lib/ecl/" -w -c "hello.c" -o "hello.o" ;;; OPTIMIZE levels: Safety=2, Space=0, Speed=3 ;;; Finished compiling hello.lisp. #P"hello.o" The final step is to build the library using the c:build-fasl instruction. > (c:build-fasl "myecl" :lisp-files '("hello.o")) ;;; Invoking external command: gcc -O2 -march=i686 -pipe -fomit-frame-pointer -fPIC -fstrict-aliasing -Dlinux -O "-I/usr/lib/ecl/" -w -c "myecl.c" -o "myecl.o" ;;; Invoking external command: gcc -o "libmyecl.so" -L"/usr/lib/ecl/" "myecl.o" "hello.o" -Wl,–rpath,/usr/lib/ecl/ -shared -lecl -lgmp -lgc -ldl -lm #P"libmyecl.so" Now you can load this extension from any &ECL; image, even those you produce with c:build-program. <<<<<<<< THIS EXAMPLE IS WRONG?! >>>>>>>>> > (load "myecl") ;;; Loading myecl.fas Hello world! Bye.
Manipulating Lisp objects If you want to extend, fix or simply customize &ECL; for your own needs, you should understand how the implementation works.
Objects representation In &ECL; a lisp object is represented by a type called cl_object. This type is a word which is long enough to host both an integer and a pointer. The least significant bits of this word, also called the tag bits, determine whether it is a pointer to a C structure representing a complex object, or whether it is an immediate data, such as a fixnum or a character. | word-1 | word-2 | ... | word-n | |----------------------| |--------|--------|-----|--------| | ...................00| | actual data of the object | |----------------------| |--------------------------------| ]]> The fixnums and characters are called immediate datatypes, because they require no more than the cl_object datatype to store all information. All other &ECL; objects are non-immediate and they are represented by a pointer to a cell that is allocated on the heap. Each cell consists of several words of memory and contains all the information related to that object. By storing data in multiples of a word size, we make sure that the least significant bits of a pointer are zero, which distinguishes pointers from immediate data. In an immediate datatype, the tag bits determine the type of the object. In non-immediate datatypes, the first byte in the cell contains the secondary type indicator, and distinguishes between different types of non immediate data. The use of the remaining bytes differs for each type of object. For instance, a cons cell consists of three words: There is one important function which tells the type of an object, plus several macros which group several tests.
cl_object C type: cl_object This is the type of a lisp object. For your C/C++ program, a cl_object can be either a fixnum, a character, or a pointer to a union of structures (See the header object.h). The actual interpretation of that object can be guessed with the macro ecl_t_of. For example, if x is of type cl_object, and it is of type fixnum, we may retrieve its value if (ecl_t_of(x) == t_fixnum) printf("Integer value: %d\n", fix(x)); If x is of type cl_object and it does not contain an immediate datatype, you may inspect the cell associated to the lisp object using x as a pointer. For example, if (ecl_t_of(x) == t_cons) printf("CAR = %x, CDR = %x\n", x->cons.car, x->cons.cdr); else if (ecl_t_of(x) == t_string) printf("String: %s\n", x->string.self); You should see the following sections and the header object.h to learn how to use the different fields of a cl_object pointer.
cl_type C type: cl_type Enumeration type which distinguishes the different types of lisp objects. The most important values are t_cons, t_fixnum, t_character, t_bignum, t_ratio, t_singlefloat, t_doublefloat, t_complex, t_symbol, t_package, t_hashtable, t_array, t_vector, t_string, t_bitvector, t_stream, t_random, t_readtable, t_pathname, t_bytecodes, t_cfun, t_cclosure, t_gfun, t_instance, t_foreign and t_thread.
ecl_t_of Function: cl_type ecl_t_of (cl_object O) If O is a valid lisp object, ecl_t_of(O) returns an integer denoting the type that lisp object. That integer is one of the values of the enumeration type cl_type.
FIXNUMP Function: bool FIXNUMP (cl_object o) CHARACTERP Function: bool CHARACTERP (cl_object o) CONSP Function: bool CONSP (cl_object o) LISTP Function: bool LISTP (cl_object o) ATOM Function: bool ATOM (cl_object o) ARRAYP Function: bool ARRAYP (cl_object o) VECTORP Function: bool VECTORP (cl_object o) STRINGP Function: bool STRINGP (cl_object o) Different macros that check whether o belongs to the specified type. These checks have been optimized, and are preferred over several calls to ecl_t_of.
IMMEDIATE Function: bool IMMEDIATE (cl_object o) Tells whether o is an immediate datatype.
Constructing objects On each of the following sections we will document the standard interface for building objects of different types. For some objects, though, it is too difficult to make a C interface that resembles all of the functionality in the lisp environment. In those cases you need to build the objects from their textual representation, or use the evaluator to build these objects. The first way makes use of a C or Lisp string to construct an object. The two functions you need to know are the following ones.
c_string_to_object Function: cl_object c_string_to_object (const char *s) string_to_object Function: cl_object string_to_object (cl_object o) c_string_to_object builds a lisp object from a C string which contains a suitable representation of a lisp object. string_to_object performs the same task, but uses a lisp string, and therefore it is less useful. Two examples of their use /* Using a C string */ cl_object array1 = c_string_to_object("#(1 2 3 4)"); /* Using a Lisp string */ cl_object string = make_simple_string("#(1 2 3 4)"); cl_object array2 = string_to_object(string);
Integers Common-Lisp distinguishes two types of integer types: bignums and fixnums. A fixnum is a small integer, which ideally occupies only a word of memory and which is between the values MOST-NEGATIVE-FIXNUM and MOST-POSITIVE-FIXNUM. A bignum is any integer which is not a fixnum and it is only constrained by the amount of memory available to represent it. In &ECL; a fixnum is an integer that, together with the tag bits, fits in a word of memory. The size of a word, and thus the size of a fixnum, varies from one architecture to another, and you should refer to the types and constants in the ecl.h header to make sure that your C extensions are portable. All other integers are stored as bignums, they are not immediate objects, they take up a variable amount of memory and the GNU Multiprecision Library is required to create, manipulate and calculate with them.
cl_fixnum C type: cl_fixnum This is a C signed integer type capable of holding a whole fixnum without any loss of precision. The opposite is not true, and you may create a cl_fixnum which exceeds the limits of a fixnum and should be stored as a bignum.
cl_index C type: cl_index This is a C unsigned integer type capable of holding a nonnegative fixnum without loss of precision. Typically, a cl_index is used as an index into an array, or into a proper list, etc.
MOST_NEGATIVE_FIXNUM Constant: MOST_NEGATIVE_FIXNUM MOST_POSITIVE_FIXNUM Constant: MOST_POSITIVE_FIXNUM These constants mark the limits of a fixnum.
FIXNUM_MINUSP Function: bool FIXNUM_MINUSP (cl_object o) FIXNUM_PLUSP Function: bool FIXNUM_PLUSP (cl_object o) These functions perform the checks (o < 0) and (0 <= o), respectively.
MAKE_FIXNUM Function: cl_object MAKE_FIXNUM (cl_fixnum n) fix Function: cl_fixnum fix (cl_object o) MAKE_FIXNUM and fix convert from an integer to a lisp object of fixnum type and vice versa. These functions no not check their arguments.
fixint Function: cl_fixnum fixint (cl_object o) Converts a lisp fixnum to a C integer of the appropriate size. Signals an error if o is not of fixnum type.
fixnnint Function: cl_index fixnnint (cl_object o) Similar to fixint but also ensures that o is not negative.
Characters &ECL; has only one type of characters, which fits in the C type char. The following constants and functions operate on characters.
CHAR_CODE_LIMIT Constant: CHAR_CODE_LIMIT Each character is assigned an integer code which ranges from 0 to (CHAR_CODE_LIMIT-1).
CHAR_CODE Function: cl_fixnum CHAR_CODE (cl_object o) char_code Function: cl_fixnum char_code (cl_object o) Returns the integer code associated to a lisp character. Only char_code checks its arguments.
CODE_CHAR Function: cl_object CODE_CHAR (cl_fixnum o) Returns the lisp character associated to an integer code. It does not check its arguments.
coerce_to_character Function: cl_object coerce_to_character (cl_object o) Coerces a lisp object to type character. Valid arguments are a character, or a string designator of length 1. In all other cases an error is signaled.
char_eq Function: bool char_eq (cl_object x, cl_object y) char_equal Function: bool char_equal (cl_object x, cl_object y) Compare two characters for equality. char_eq take case into account and char_equal ignores it.
char_cmp Function: int char_cmp (cl_object x, cl_object y) char_compare Function: int char_compare (cl_object x, cl_object y) Compare the relative order of two characters. char_cmp takes care of case and char_compare converts all characters to uppercase before comparing them.
Arrays An array is an aggregate of data of a common type, which can be accessed with one or more nonnegative indices. &ECL; stores arrays as a C structure with a pointer to the region of memory which contains the actual data. The cell of an array datatype varies depending on whether it is a vector, a bytevector, a multidimensional array or a string. If x contains a vector, you can access the following fields: x->vector.elttype The type of the elements of the vector. x->vector.dim The maximum number of elements. x->vector.fillp Actual number of elements in the vector or "fill pointer". x->vector.self Union of pointers of different types. You should choose the right pointer depending on x->vector.elltype x->vector.hasfillp Whether x->vector.fillp can be smaller than x->vector.dim. If x contains a multidimensional array, the cell elements become x->array.elttype The type of the elements of the array. x->array.dim Number of elements in the array. x->array.rank Number of dimensions of the array. x->array.dims[] Array with the dimensions of the array. The elements range from x->array.dim[0] to x->array.dim[x->array.rank-1]. x->array.self Union of pointers to the actual data. You should choose the right pointer depending on x->array.elltype. x->array.rank Whether x->vector.fillp can be smaller than x->vector.dim. Bitvectors and strings are treated separately. Each array is of an specialized type which is the type of the elements of the array. &ECL; has arrays only a few following specialized types, and for each of these types there is a C integer which is the corresponding value of x->array.elttype or x->vector.elttype. We list those types together with the C constant that denotes that type: T aet_object CHARACTER aet_ch FIXNUM aet_fix BIT aet_bit SINGLE-FLOAT aet_sf DOUBLE-FLOAT aet_df
array_elttype Function: cl_elttype array_elttype (cl_object o) Returns the element type of the array o, which can be a string, a bitvector, vector, or a multidimensional array. For example, the code array_elttype(c_string_to_object("\"AAA\"")) returns aet_ch, while the array_elttype(c_string_to_object("#(A B C)")) returns aet_object.
aref Function: cl_object aref (cl_object array, cl_index index) aset Function: cl_object aset (cl_object array, cl_index index, cl_object value) These functions are used to retrieve and set the elements of an array. The elements are accessed with one index, index, as in the lisp function ROW-MAJOR-AREF. For example cl_object array = c_string_to_object("#2A((1 2) (3 4))"); cl_object x = aref(array, 3); cl_print(1, x); /* Outputs 4 */ aset(array, 3, MAKE_FIXNUM(5)); cl_print(1, array); /* Outputs #2A((1 2) (3 5)) */
aref1 Function: cl_object aref1 (cl_object vector, cl_index index) aset1 Function: cl_object aset1 (cl_object vector, cl_index index, cl_object value) These functions are similar to aref and aset, but they operate on vectors. cl_object array = c_string_to_object("#(1 2 3 4)"); cl_object x = aref1(array, 3); cl_print(1, x); /* Outputs 4 */ aset1(array, 3, MAKE_FIXNUM(5)); cl_print(1, array); /* Outputs #(1 2 3 5) */
Strings A string, both in Common-Lisp and in &ECL; is nothing but a vector of characters. Therefore, almost everything mentioned in the section of arrays remains valid here. The only important difference is that &ECL; stores strings as a lisp object with a pointer to a zero terminated C string. Thus, if a string has n characters, &ECL; will reserve n+1 bytes for the string. This allows us to pass the string self pointer to any C routine. If x is a lisp object of type string, we can access the following fields: x->string.dim Maximum number of characters that it can contain. x->string.fillp Actual number of characters in the string. x->string.self Pointer to the characters. x->string.hasfillp True if x->string.fillp can be smaller than x->string.dim.
make_simple_string Function: cl_object make_simple_string (char *s) make_string_copy Function: cl_object make_string_copy (char *s) Both routines build a lisp string from a C string. make_string_copy allocates new space and copies the content of the string to it. make_simple_string simply uses the memory pointed by s, which should not be deallocated. Both routines use strlen to calculate the length of the string.
Bitvectors
Streams
Structures
Instances
Bytecodes A bytecodes object is a lisp object with a piece of code that can be interpreted. The objects of type t_bytecode are implicitly constructed by a call to eval, but can also be explicitly constructed with the make_lambda function.
cl_safe_eval Function: cl_object cl_safe_eval (cl_object form, cl_object env, cl_object err_value cl_eval Function: cl_object cl_eval (cl_object form) cl_safe_eval evaluates form in the lexical environment env, which can be nil. Before evaluating it, the expression form must be bytecompiled. cl_eval is the equivalent of cl_safe_eval but without environment and with err_value set to nil. It exists only for compatibility with previous versions. cl_object form = c_string_to_object("(print 1)"); cl_safe_eval(form,Cnil); cl_safe_eval(form, Cnil);
si_make_lambda Function: cl_object si_make_lambda (cl_object name, cl_object def) Builds an interpreted lisp function with name given by the symbol name and body given by def. For instance, we would achieve the equivalent of (funcall #'(lambda (x y) (block foo (+ x y))) 1 2) with the following code cl_object def = c_string_to_object("((x y) (+ x y))"); cl_object name = _intern("foo") cl_object fun = si_make_lambda(name, def); return funcall(fun, MAKE_FIXNUM(1), MAKE_FIXNUM(2)); Notice that si_safe_lambda performs a bytecodes compilation of the definition and thus it may signal some errors. Such errors are not handled by the routine itself you might consider using cl_safe_eval or cl_eval instead: cl_object def = c_string_to_object("#'(lambda-block foo (x y) (+ x y))"); cl_object fun = cl_eval(def); return funcall(fun, MAKE_FIXNUM(1), MAKE_FIXNUM(2));
The interpreter
&ECL; stacks &ECL; uses the following stacks: Frame Stack consisting of catch, block, tagbody frames Bind Stack for shallow binding of dynamic variables Interpreter Stack acts as a Forth data stack, keeping intermediate arguments to interpreted functions, plus a history of called functions. C Control Stack used for arguments/values passing, typed lexical variables, temporary values, and function invocation.
Procedure Call Conventions &ECL; employs standard C calling conventions to achieve efficiency and interoperability with other languages. Each Lisp function is implemented as a C function which takes as many argument as the Lisp original plus one additional integer argument which holds the number of actual arguments. The function sets NValues to the number of Lisp values produced, it returns the first one and the remaining ones are kept in a global (per thread) array (VALUES). To show the argument/value passing mechanism, here we list the actual code for the Common-Lisp function cons. cl_cons(int narg, object car, object cdr) { object x; check_arg(2); x = alloc_object(t_cons); CAR(x) = car; CDR(x) = cdr; NValues = 1; return x; } &ECL; adopts the convention that the name of a function that implements a Common-Lisp function begins with a short package name (cl for COMMON-LISP, si for SYSTEM, etc), followed by L, and followed by the name of the Common-Lisp function. (Strictly speaking, `-' and `*' in the Common-Lisp function name are replaced by `_' and `A', respectively, to obey the syntax of C.) check_arg(2) in the code of cl_cons checks that exactly two arguments are supplied to cons. That is, it checks that narg is 2, and otherwise, it causes an error. allocate_object(t_cons) allocates a cons cell in the heap and returns the pointer to the cell. After the CAR and the CDR fields of the cell are set, the cell pointer is returned directly. The number assigned to NValues set by the function (1 in this case) represents the number of values of the function. In general, if one is to play with the C kernel of &ECL; there is no need to know about all these conventions. There is a preprocessor that takes care of the details, by using a lisp representation of the statements that output values, and of the function definitions. For instance, the actual source code for cl_cons in src/c/lists.d @(defun cons (car cdr) @ @(return CONS(car, cdr)) @)
The lexical environment The &ECL; interpreter uses two A-lists (Association lists) to represent lexical environments. One for variable bindings One for local function/macro/tag/block bindings When a function closure is created, the current two A-lists are saved in the closure along with the lambda expression. Later, when the closure is invoked, the saved A-lists are used to recover the lexical environment.
The interpreter stack The bytecodes interpreter uses a stack of its own to save and restore values from intermediate calculations. This Forth-like data stack is also used in other parts of the C kernel for various purposes, such as saving compiled code, keeping arguments to FORMAT, etc. However, one of the most important roles of the Interpreter Stack is to keep a log of the functions which are called during the execution of bytecodes. For each function invoked, the interpreter keeps three lisp objects on the stack: The first item is the object which is funcalled. It can be a bytecodes object, a compiled function or a generic function. In the last two cases the lexical environment is just NIL. In the first case, the second item on the stack is the lexical environment on which the code is executed. Each of these records are popped out of the stack after function invocation. Let us see how these invocation records are used for debugging. >(defun fact (x) ;;; Wrong definition of the (if (= x 0) ;;; factorial function. one ;;; one should be 1. (* x (fact (1- x))))) FACT >(fact 3) ;;; Tries 3! Error: The variable ONE is unbound. Error signalled by IF. Broken at IF. >>:b ;;; Backtrace. Backtrace: eval > fact > if > fact > if > fact > if > fact > IF ;;; Currently at the last IF. >>:h ;;; Help. Break commands: :q(uit) Return to some previous break level. :pop Pop to previous break level. :c(ontinue) Continue execution. :b(acktrace) Print backtrace. :f(unction) Show current function. :p(revious) Go to previous function. :n(ext) Go to next function. :g(o) Go to next function. :fs Search forward for function. :bs Search backward for function. :v(ariables) Show local variables, functions, blocks, and tags. :l(ocal) Return the nth local value on the stack. :hide Hide function. :unhide Unhide function. :hp Hide package. :unhp Unhide package. :unhide-all Unhide all variables and packages. :bds Show binding stack. :m(essage) Show error message. :hs Help stack. Top level commands: :cf Compile file. :exit or ^D Exit Lisp. :ld Load file. :step Single step form. :tr(ace) Trace function. :untr(ace) Untrace function. Help commands: :apropos Apropos. :doc(ument) Document. :h(elp) or ? Help. Type ":help help" for more information. >>:p ;;; Move to the last call of FACT. Broken at IF. >>:b Backtrace: eval > fact > if > fact > if > fact > if > FACT > if ;;; Now at the last FACT. >>:v ;;; The environment at the last call Local variables: ;;; to FACT is recovered. X: 0 ;;; X is the only bound variable. Block names: FACT. ;;; The block FACT is established. >>x 0 ;;; The value of x is 0. >>(return-from fact 1) ;;; Return from the last call of 6 ;;; FACT with the value of 0. ;;; The execution is resumed and > ;;; the value 6 is returned. ;;; Again at the top-level loop.
The compiler
The compiler translates to C The &ECL; compiler is essentially a translator from Common-Lisp to C. Given a Lisp source file, the compiler first generates three intermediate files: a C-file which consists of the C version of the Lisp program an H-file which consists of declarations referenced in the C-file a Data-file which consists of Lisp data to be used at load time The &ECL; compiler then invokes the C compiler to compile the C-file into an object file. Finally, the contents of the Data-file is appended to the object file to make a Fasl-file. The generated Fasl-file can be loaded into the &ECL; system by the Common-Lisp function load. By default, the three intermediate files are deleted after the compilation, but, if asked, the compiler leaves them. The merits of the use of C as the intermediate language are: The &ECL; compiler is highly portable. Cross compilation is possible, because the contents of the intermediate files are common to all versions of &ECL;. For example, one can compile his or her Lisp program by the &ECL; compiler on a Sun, bring the intermediate files to DOS, compile the C-file with the gcc compiler under DOS, and then append the Data-file to the object file. This procedure generates the Fasl-file for the &ECL; system on DOS. This kind of cross compilation makes it easier to port &ECL;. Hardware-dependent optimizations such as register allocations are done by the C compiler. The demerits are: At those sites where no C compiler is available, the users cannot compile their Lisp programs. The compilation time is long. 70% to 80% of the compilation time is used by the C compiler. The &ECL; compiler is therefore slower than compiler generating machine code directly.
The compiler mimics human C programmer The format of the intermediate C code generated by the &ECL; compiler is the same as the hand-coded C code of the &ECL; source programs. For example, supposing that the Lisp source file contains the following function definition: (defvar *delta* 2) (defun add1 (x) (+ *delta* x)) The compiler generates the following intermediate C code. /* function definition for ADD1 */ static cl_object L1(cl_object V1) { VT2 VLEX2 CLSR2 cl_object value0; value0=number_plus(symbol_value(VV[0]),V1); NVALUES=1; return value0; } /* initialization of this module */ void init_CODE(cl_object flag) { VT1 CLSR1 cl_object value0; if (!FIXNUMP(flag)){ Cblock=flag; #ifndef ECL_DYNAMIC_VV flag->cblock.data = VV; #endif flag->cblock.self_destruct=0; flag->cblock.data_size = VM; flag->cblock.data_text = compiler_data_text; flag->cblock.data_text_size = compiler_data_text_size; return;} #ifdef ECL_DYNAMIC_VV VV = Cblock->cblock.data; #endif T0= MAKE_FIXNUM(2); si_Xmake_special(VV[0]) if(SYM_VAL(T0)!=OBJNULL) cl_setq(VV[0],T0); cl_def_c_function(VV[1],(void*)L1,1); } The C function L1 implements the Lisp function add1. This relation is established by cl_def_c_function in the initialization function init_CODE, which is invoked at load time. There, the vector VV consists of Lisp objects; VV[0] and VV[1] in this example hold the Lisp symbols *delta* and add1. VM in the definition of L1 is a C macro declared in the corresponding H-file. The actual value of VM is the number of value stack locations used by this module, i.e., 2 in this example. Thus the following macro definition is found in the H-file. #define VM 2
Implementation of Compiled Closures The &ECL; compiler takes two passes before it invokes the C compiler. The major role of the first pass is to detect function closures and to detect, for each function closure, those lexical objects (i.e., lexical variable, local function definitions, tags, and block-names) to be enclosed within the closure. This check must be done before the C code generation in the second pass, because lexical objects to be enclosed in function closures are treated in a different way from those not enclosed. Ordinarily, lexical variables in a compiled function f are allocated on the C stack. However, if a lexical variable is to be enclosed in function closures, it is allocated on a list, called the "environment list", which is local to f. In addition, a local variable is created which points to the lexical variable's location (within the environment list), so that the variable may be accessed through an indirection rather than by list traversal. The environment list is a pushdown list: It is empty when f is called. An element is pushed on the environment list when a variable to be enclosed in closures is bound, and is popped when the binding is no more in effect. That is, at any moment during execution of f, the environment list contains those lexical variables whose binding is still in effect and which should be enclosed in closures. When a compiled closure is created during execution of f, the compiled code for the closure is coupled with the environment list at that moment to form the compiled closure. Later, when the compiled closure is invoked, a pointer is set up to each lexical variable in the environment list, so that each object may be referenced through a memory indirection. Let us see an example. Suppose the following function has been compiled. (defun foo (x) (let ((a #'(lambda () (incf x))) (y x)) (values a #'(lambda () (incf x y))))) foo returns two compiled closures. The first closure increments x by one, whereas the second closure increments x by the initial value of x. Both closures return the incremented value of x. >(multiple-value-setq (f g) (foo 10)) #<compiled-closure nil> >(funcall f) 11 >(funcall g) 21 > After this, the two compiled closures look like: | 10 | --|------>| 21 | nil | |-------|------| |-------|------| |------|------| ^ first closure | |-------|------| | | * | --|----------| |-------|------| * : address of the compiled code for #'(lambda () (incf x)) ** : address of the compiled code for #'(lambda () (incf x y)) ]]>
Use of Declarations to Improve Efficiency Declarations, especially type and function declarations, increase the efficiency of the compiled code. For example, for the following Lisp source file, with two Common-Lisp declarations added, (eval-when (compile) (proclaim '(function tak (fixnum fixnum fixnum) fixnum)) (defun tak (x y z) (declare (fixnum x y z)) (if (not (< y x)) z (tak (tak (1- x) y z) (tak (1- y) z x) (tak (1- z) x y)))) The compiler generates the following C code: /* local entry for function TAK */ static int LI1(register int V1,register int V2,register int V3) { VT3 VLEX3 CLSR3 TTL: if (V2 < V1) { goto L2;} return(V3); L2: { int V5; V5 = LI1((V1)-1,V2,V3); { int V6; V6 = LI1((V2)-1,V3,V1); V3 = LI1((V3)-1,V1,V2); V2 = V6; V1 = V5;}} goto TTL; ;;; Note: Tail-recursive call of TAK was replaced by iteration. }
Inspecting generated C code Common-Lisp defines a function disassemble, which is supposed to disassemble a compiled function and to display the assembler code. According to Common-Lisp: The Language, This is primary useful for debugging the compiler, ..\\ This is, however, useless in our case, because we are not concerned with assembly language. Rather, we are interested in the C code generated by the &ECL; compiler. Thus the disassemble function in &ECL; accepts not-yet-compiled functions only and displays the translated C code. > (defun add1 (x) (1+ x)) ADD1 > (disassemble *) ;;; Compiling (DEFUN ADD1 ...). ;;; Emitting code for ADD1. /* function definition for ADD1 */ static L1(int narg, object V1) { VT3 VLEX3 CLSR3 TTL: VALUES(0) = one_plus((V1)); RETURN(1); }
Porting &ECL; To port &ECL; to a new architecture, the following steps are required: Ensure that the GNU Multiprecision library supports this machine. Ensure that the Boehm-Weiser garbage collector is supported by that architecture. Alternatively, port ECL's own garbage collector src/c/alloc.d and src/c/gbc.d to that platform. Fix src/aclocal.in, src/h/config.h.in and src/h/ecl.h so that they supply flags for the new host machine. Fix the machine dependent code in src/c/. The most critical parts are in the unix*.d and thread*.d files. Compile as in any other platform. Run the tests and compare to the results of other platforms. ecl-16.1.2/doc/interpreter.xmlf000066400000000000000000000045431266352375300163660ustar00rootroot00000000000000 %eclent; ]> The Interpreter Former versions of &ECL;, as well as many other lisps, used linked lists to represent code. As of version 0.3 a bytecodes compiler and a bytecodes interpreter were developed to circumvent the limitations of linked lists. When you enter code at the lisp prompt, or when you load a source file, &ECL; begins a process known as minimal compilation. Barely this process consists on parsing each form, macroexpanding it and translating it into an intermediate language made of bytecodes. The bytecodes compiler is implemented in src/c/compiler.d. The main entry point is the lisp function SI::MAKE-LAMBDA, which takes a name for the function and the body of the lambda lists, and produces a lisp object that can be invoked. For instance, > (defvar fun (si::make-lambda 'f '((x) (1+ x)))) *FUN* > (funcall fun 2) 3 &ECL; can only execute bytecodes. When a list is passed to EVAL it must be first compiled to bytecodes and, if the process succeeds, then the resulting bytecodes are passed to the interpreter. Similarly, every time a function object is created, such as in DEFUN or DEFMACRO, the bytecodes compiler processes the lambda form to produce a suitable bytecodes object. The fact that &ECL; performs this eager compilation means that changes on a macro are not immediately seen in code which was already compiled. This has subtle implications. Take the following code: > (defmacro f (a b) `(+ ,a ,b)) F > (defun g (x y) (f x y)) G > (g 1 2) 3 > (defmacro f (a b) `(- ,a ,b)) F > (g 1 2) 3 The last statement always outputs 3 while in former implementations based on processing of lambda lists it would produce -1. ecl-16.1.2/doc/intro.xmlf000066400000000000000000000451521266352375300151570ustar00rootroot00000000000000 %eclent; ]> Preface
About this book This manual is part of the &ECL; software system. It documents deviations of &ECL; from the &ANSI; standard, as well as extensions, daily working process (compiling files, loading sources, creating programs, etc) and the internals of this implementation. This book is not intended as a source to learn &CommonLisp;. There are other tutorials and textbooks available in the Net which serve this purpose. The homepage of the Association of Lisp Users contains a good list of links of such teaching and learning material. This book is structured into three parts. We begin with documents all parts of the standard which are left as implementation specific. For instance, precision of floating point numbers, available character sets, actual input/output protocols, etc. introduces all features which are specific to &ECL; and which lay outside the standard. This includes configuring, building and installing &ECL; multiprocessing capabilities, graphics libraries, interfacing with the operating system, etc. deals with the internals of the implementation. This part is only intended for experienced programmers that want to learn how &ECL; does its work and wish to extend it, customize it or port it to new architectures. This part of the documentation is the most fragile one and prone to change. Missing highlights
What is &ECL;? &ECL; is an implementation of the Common-Lisp language that was developed by Giuseppe Attardi's up from the Kyoto Common-Lisp. See for the history of the code you are up to use. &ECL; (ECL for short) uses standard C calling conventions for Lisp compiled functions, which allows C programs to easily call Lisp functions and vice versa. No foreign function interface is required: data can be exchanged between C and Lisp with no need for conversion. &ECL; is based on a Common Runtime Support (CRS) which provides basic facilities for memory management, dynamic loading and dumping of binary images, support for multiple threads of execution. The CRS is built into a library that can be linked with the code of the application. &ECL; is modular: main modules are the program development tools (top level, debugger, trace, stepper), the compiler, and CLOS. A native implementation of CLOS is available in &ECL;: one can configure &ECL; with or without CLOS. A runtime version of &ECL; can be built with just the modules which are required by the application. The &ECL; compiler compiles from Lisp to C, and then invokes the GNU C compiler to produce binaries. While former releases of ECL adhere to the the reference of the language given in &Steele84;, the aim of &ECL; is now to achieve maximum compliance with ANSI Common-Lisp, the most up to date standard for Common-Lisp. Throughout this manual we will describe the &ECL; implementation and how it differs from &ANSI; and &Steele84;. In general, as work in &ECL; is completed section by section, we will drop compatibility with &Steele84; and the corresponding chapter will be updated to document only the differences with &ANSI;.
Credits The &ECL; project is an implementation of the Common-Lisp language that aims to comply with the ANSI Common-Lisp standard. The first ECL implementations were developed by Giuseppe Attardi's who produced an interpreter and compiler fully conformat with the Common-Lisp as reported in Steele:84. ECL derives itself mostly from Kyoto Common-Lisp, an implementation developed at the Research Institute for Mathematical Sciences (RIMS), Kyoto University, with the cooperation of Nippon Data General Corporation. The main developers of Kyoto Common-Lisp were Taiichi Yuasa and Masami Hagiya, of the Research Institute for Mathematical Sciences, at Kyoto University. We must thank Juan Jose Garcia Ripoll, Giuseppe Attardi, Yuasa and Hagiya for their wonderful work with preceding implementations and for putting them in the Public Domain under the GNU General Public License as published by the Free Software Foundation. Without them this product would have never been possible. This document is an update of the original ECL documentation, which was based in part on the material in [Yuasa:85, see ] The following people or organizations must be credited for support in the development of Kyoto Common-Lisp: Prof. Reiji Nakajima at RIMS, Kyoto University; Nippon Data General Corporation; Teruo Yabe; Toshiyasu Harada; Takashi Suzuki; Kibo Kurokawa; Data General Corporation; Richard Gabriel; Daniel Weinreb; Skef Wholey; Carl Hoffman; Naruhiko Kawamura; Takashi Sakuragawa; Akinori Yonezawa; Etsuya Shibayama; Hagiwara Laboratory; Shuji Doshita; Takashi Hattori. William F. Schelter improved KCL in several areas and developed Austin Kyoto Common-Lisp (AKCL). Many ideas and code from AKCL have been incorporated in &ECL;. The following is the full list of contributors to ECL: Taiichi Yuasa and Masami Hagiya (KCL), William F. Schelter (Dynamic loader, conservative Gc), Giuseppe Attardi (Top-level, trace, stepper, compiler, CLOS, multithread), Marcus Daniels (Linux port) Cornelis van der Laan (FreeBSD port) David Rudloff (NeXT port) Dan Stanger, Don Cohen, and Brian Spilsbury. We have to thank for the following pieces of software that have helped in the development of &ECL; Bruno Haible For the Cltl2-compliance test Peter Van Eynde For the ANSI-compliance test Symbolic's Inc. For the ANSI-compliant LOOP macro. The &ECL; project also owes a lot to the people who have tested this program and contributed with suggestions and error messages: Eric Marsden, Hannu Koivisto and Jeff Bowden, and others whose name I may have omitted.
Copyright Copyright © 2015 Daniel KochmaХ„ski Copyright © 2000 Juan Jose Garcia Ripoll Copyright © 1990, 1991, 1993 Giuseppe Attardi Copyright © 1984 Taiichi Yuasa and Masami Hagiya All Rights Reserved Summary:
Permission is granted to use, copy, modify this program, EXCEPT that the copyright notice must be reproduced on copies, and credit should be given to the authors where it is due. WE MAKE NO WARRANTY AND ACCEPT NO LIABILITY FOR THIS PROGRAM.
In detail: Permission to use, copy, modify this software and its documentation for any purpose is hereby granted without fee, provided that the above copyright notice appears in all copies, both that copyright notice and this permission notice appears in supporting documentation, and that you cause modified files to carry prominent notices stating that you changed the files and the date of any change. Please notify us if you are going to sell this software or its documentation for profit. WE DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL WE BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. Additionally:
&ECL; is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version; see file 'Copying'. 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 Library General Public License for more details. You should have received a copy of the GNU Library General Public License along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
Address for reporting bugs, comments, suggestions:
Building ECL Obtain the distribution from http://ecls.sourceforge.net. The distribution is in a gzip-compressed tar file named like ecl.tgz Prepare a directory (hereafter called ECL directory) for ECL. In the following examples, we suppose that the ECL directory is /usr/local/ecl. Extract the content from the compressed tar file. $ zcat ecl.tgz | tar xf - An auto configuration mechanism allows you to perform a standard installation with the following commands: $ ./configure This example will prepare to install executable files, manual pages and info files in standard directories like /usr/local/bin, /usr/local/man/man1, /usr/local/info. If you don't have access rights to these directories, you should give to configure alternate places. Try ./configure --help for instructions on how to supply this information to configure, but a good starting point is $ ./configure --prefix=$HOME Next you must build the program and install it $ make $ make install At the end of installation, the destination directories will contain several files. If you have not modified these directories when invoking configure the layout should be Executable files: $HOME/bin/ecl the &ECL; interpreter and compiler Help documents: $HOME/lib/ecl/help.doc data for the online help $HOME/man/man1/ecl.1 manual page for &ECL; $HOME/info/ecl.info this manual you are reading Library files and headers: $HOME/lib/ecl/libecl.a the core library in C $HOME/lib/ecl/libgmp.a GNU library for bignums $HOME/lib/ecl/libgc.a Boehm-Weiser garbage collector $HOME/lib/ecl/*.a Other lisp compiled code $HOME/lib/ecl/ecl/ Header files You can remove all intermediate files produced during installation with the command make clean.
Entering and leaving &ECL; &ECL; is invoked by the command ecl. % ecl ECL (Embeddable Common-Lisp) 0.0e Copyright (C) 1984 Taiichi Yuasa and Masami Hagiya Copyright (C) 1993 Giuseppe Attardi Copyright (C) 2000 Juan J. Garcia-Ripoll ECL is free software, and you are welcome to redistribute it under certain conditions; see file 'Copyright' for details. Type :h for Help. Top level. > When invoked, &ECL; will print the banner and initialize the system. The date in the &ECL; banner identifies the revision of &ECL;. Version (0.8) 05/14/1993 is the value of the function lisp-implementation-version. If there exists a file named init.lsp in the current working directory, &ECL; successively evaluates the forms in the file, immediately after the system initialization. The user may set up his or her own &ECL; environment (e.g., the memory configuration) with init.lsp. After the initialization, &ECL; enters the top-level loop and prints the prompt `>'. Type :h for Help. Top level. > The prompt indicates that &ECL; is now ready to receive a form from the terminal and to evaluate it. Usually, the current package (i.e., the value of *package*) is the user package, and the prompt appears as above. If, however, the current package is other than the user package, then the prompt will be prefixed by the package name. > (in-package 'cl) #<"COMMON-LISP" package> COMMON-LISP> (in-package 'system) #<"SYSTEM" package> SYSTEM> To exit from &ECL;, call the function quit. >(quit) Bye. % Alternatively, you may type ^D, i.e. press the key D while pressing down the control key (Ctrl). >^DBye. % You can disable ^D as the exit command by setting to T the following variable:
*ignore-eof-on-terminal-io*— System: *ignore-eof-on-terminal-io* This variable controls whether an end of file character (normally ^D) should terminate the session. The default value is ().
The top-level loop of &ECL; is almost the same as that defined in Section 20.2 of &Steele84;. Since the input from the terminal is in line mode, each top-level form should be followed by a newline. If more than one value is returned by the evaluation of the top-level form, the values will be printed successively. If no value is returned, then nothing will be printed. >(values 1 2) 1 2 >(values) > When an error is signalled, control will enter the break loop. >(defun foo (x) (bar x)) foo >(defun bar (y) (bee y y)) bar >(foo 'lish) Error: The function BEE is undefined. Error signalled by BAR. Broken at BAR. >> `>>' in the last line is the prompt of the break loop. Like in the top-level loop, the prompt will be prefixed by the current package name, if the current package is other than the user package. To go back to the top-level loop, type :q >>:q Top level. > See Section 5.4 for the details of the break loop. The terminal interrupt (usually caused by typing ^C (Control-C)) is a kind of error. It breaks the running program and calls the break level loop. Example: >(defun foo () (do () (nil))) foo >(foo) ^C Correctable error: Console interrupt. Signalled by DO. Broken at FOO. >>
ecl-16.1.2/doc/io.xmlf000066400000000000000000000256341266352375300144360ustar00rootroot00000000000000 %eclent; ]> Input and Output
Read macros #P" #"string" reads a pathname. #"string" is equivalent to (pathname "string"). #$ #$integer reads a random state. #$integer is equivalent to (make-random-state integer). The # macro '#,' works as described in &Steele84;, only if it is included in a constant object. The forms immediately after `#,' below will be evaluated when the compiled code is loaded. '#,x '(a b c (d #,e f) g) #(1 2 3 #,(+ a b c) 5 6) #C(0.0 #,(exp 1)) Otherwise, the effect of using '#,' is unpredictable. Note that, when interpreted code is loaded, '#,' has the same effect as the # macro '#.'.
Input and Output Functions The input and output functions of &ECL; almost follow the definitions in Chapter 22 of &Steele84;. Most of the differences come from the fact that, in &ECL;, input from the terminal is always in line mode and binary I/O is not supported. In &ECL;, *terminal-io* is a two-way stream from the standard input and to the standard output. The echoing to the terminal is performed by the underlying operating system. In particular, when a disk file is assigned to the standard output, nothing will be echoed at the terminal. Those functions that deviate from the definitions in &Steele84; are listed below.
load— Function: load pathname &key :print :verbose :if-does-not-exist If pathname does not specify the filetype of the input file, then load uses the association list si::*load-search-list* to find out a suitable filetype and the function to load it. Typically, this search list is made of the elements .fas, .lsp and .lisp, in this order. If everything fails, a file without filetype will be loaded.
open— Function: open Streams can only have element type base-char, (signed-byte 8) and (unsigned-byte 8). The :external-format is always :default.
close— Function: close The keyword variable :abort is always ignored.
listen— Function: listen This routine requires some low level functions which are not available on all platforms (For instance on Windows). When ECL is not able to determine whether a stream is interactive, listen returns true unless an end of file has been previously detected.
clear-input— Function: clear-input The functions clear-input and clear-output do nothing.
read-char-no-hang— Function: read-char-no-hang read-char-no-hang is equivalent to read-char.
The functions princ, write-char and write-byte do not always flush the stream. The stream is flushed when a newline character is written, or the input from the terminal is requested in the case that these functions operate on *terminal-io*
Network Streams With a configuration option, the following function is available which opens streams across network connections.
open-client-stream— Function: open-client-stream host port The string host indicates the name of the host, while port is an integer which identifies the port number to which to connect. This function returns a two-way stream which can be used in any of the stream operations.
open-server-stream— Function: open-server-stream host port A stream connected to port number port is created to which clients can connect. This function returns a two-way stream which can be used in any of the stream operations.
CLOS Streams When the optional CLOS subsystem is available, an interface is provided by &ECL; for using CLOS objects as Common-Lisp input/output character streams. Such support can be used for instance to build interactive character streams, which may be used by applications as the stream argument for Common-Lisp I/O functions such as read, listen, prin1, etc. The fundamental interface to clos-stream objects consists of (generic) functions which implement the basic Common-Lisp character stream operations (see Common-Lisp, Chapter 22) but whose details are implementation dependent. The following functions are automatically invoked by &ECL; when a stream operation involves a CLOS object as a stream parameter. The programmer should define these methods for any class of objects which are to be used for character input/output.
CLOS Stream Input Character input from an clos-stream is implemented by the following methods.
stream-read-char— Method: stream-read-char (object clos-stream) Returns the next character object read from the CLOS stream object.
stream-unread-char— Method: stream-unread-char (object clos-stream) character Unreads the character object character from the CLOS stream object. character will be the next character read by stream-read-char.
stream-listen— Method: stream-listen (object clos-stream) Returns () is no character is immediately available from the CLOS stream object. Otherwise, the next character is returned, as if stream-peek-char had been called.
stream-clear-input— Method: stream-clear-input object Clears any buffered characters on the CLOS stream object. Returns ().
CLOS Stream Output Character output from an clos-stream is implemented by the following methods.
stream-write-char— Method: stream-write-char (object clos-stream) character Outputs the character character to the CLOS stream object and returns it.
stream-clear-output— Method: stream-clear-output (object clos-stream) Aborts any outstanding output operation on the CLOS stream object and returns ().
stream-force-output— Method: stream-force-output (object clos-stream) Initiates the emptying of the internal buffers on the CLOS stream object and returns ().
CLOS Stream common The following functions should be available for all CLOS streams.
stream-interactive-p— Method: stream-interactive-p (object clos-stream)
stream-close— Method: stream-close (object clos-stream) Closes the stream for any further input or output.
ecl-16.1.2/doc/macros.xmlf000066400000000000000000000107271266352375300153100ustar00rootroot00000000000000 %eclent; ]> Macros A defmacro lambda-list is a lambda-list-like construct that is used as the third element in the defmacro form, (defmacro name efmacro-lambda-list [declaration | doc-string] {form}*) The description of defmacro lambda-lists in &Steele84; is quite ambiguous. &ECL; employs the following syntax. The complete syntax of a defmacro lambda-list is: ( [&whole var] [&environment var] [pseudo-var] [&optional {var | ( pseudo-var [initform [pseudo-var]] )}] {[{&rest | &body} pseudo-var] [&key {var | ({var | (keyword pseudo-var)} [initform [pseudo-var]])}* [&allow-other-keys]] [&aux {var | (pseudo-var [initform])}*] | . var } ) where pseudo-var is either a symbol or a list of the following form: ( {pseudo-var}* [&optional {var | (pseudo-var [initform [pseudo-var]])}*] {[{&rest | &body} pseudo-var] [&key {var | ({var | (keyword pseudo-var)} [initform [pseudo-var]])}* [&allow-other-keys]] [&aux {var | (pseudo-var [initform])}] | . var } ) The defmacro lambda-list keyword &whole may appear only at the top-level, first in the defmacro lambda-list. It is not allowed within pseudo-var. Use of the &whole keyword does not affect the processing of the rest of the defmacro lambda-list: (defmacro foo (&whole w x y) ...) and (defmacro foo (x y) ...) both bind the variables x and y to the second and the third elements, respectively, of macro forms of foo. The defmacro lambda-list keyword &environment may appear only at the top-level, first in the defmacro lambda-list if &whole is not supplied, or immediately after the variable that follows &whole, if &whole is supplied. &environment is not allowed within pseudo-var. Like &whole, use of &environment does not affect the processing of the rest of the defmacro lambda-list. If an &environment parameter is supplied and if this parameter is not used at all, then the &ECL; compiler will issue a warning. To suppress the warning, just remove the parameter from the defmacro lambda-list, or add an ignore declaration. The defmacro lambda-list keyword &body is completely equivalent to the &rest keyword. &ECL; takes no special action for &body parameters. Although useless, &ECL; allows supplied-p parameters to be destructured. This is useless because supplied-p parameters can never be bound to a non-empty list. Our intention is to stick to the specification in the &Steele84; as far as possible, even if it is silly to do so. Like for ordinary lambda-lists, the interpreter detects invalid arguments to macro expansion functions. When a parameter is destructured, the structure of the corresponding argument is also checked. Such runtime argument checking may or may not be embedded in compiled code, depending on the environment when the code was generated. If the code was generated while the safety optimize level is zero (that is, while the value of (proclamation '(optimize (safety 0))) is T), then the generated code does not perform argument checking at all. Otherwise, the compiled code does check the validity of arguments. ecl-16.1.2/doc/memory.xmlf000066400000000000000000000217121266352375300153300ustar00rootroot00000000000000 %eclent; ]> Memory Management
Introduction &ECL; relies on the Boehm-Weiser garbage collector for handling memory, creating and destroying objects, and handling finalization of objects that are no longer reachable. The use of a garbage collector, and in particular the use of a portable one, imposes certain restrictions that may appear odd for C/C++ programmers. In this section we will discuss garbage collection, how &ECL; configures and uses the memory management library, what users may expect, how to handle the memory and how to control the process by which objects are deleted.
Boehm-Weiser garbage collector First of all, the garbage collector must be able to determine which objects are alive and which are not. In other words, the collector must able to find all references to an object. One possiblity would be to know where all variables of a program reside, and where is the stack of the program and its size, and parse all data there, discriminating references to lisp objects. To do this precisely one would need a very precise control of the data and stack segments, as well as how objects are laid out by the C compiler. This is beyond &ECL;'s scope and wishes and it can make coexistence with other libraries (C++, Fortran, etc) difficult. The Boehm-Weiser garbage collector, on the other hand, is a conservative garbage collector. When scanning memory looking for references to live data, it guesses, conservatively, whether a word is a pointer or not. In case of doubt it will consider it to be a pointer and add it to the list of live objects. This may cause certain objects to be retained longer than what an user might expect but, in our experience, this is the best of both worlds and &ECL; uses certain strategies to minimize the amount of misinterpreted data. More precisely, &ECL; uses the garbage collector with the following settings: The collector will not scan the data sectors. If you embed &ECL; in another program, or link libraries with &ECL;, you will have to notify &ECL; which variables point to lisp objects. The collector is configured to ignore pointers that point to the middle of allocated objects. This minimizes the risk of misinterpreting integers as pointers to live obejcts. It is possible to register finalizers that are invoked when an object is destroyed, but for that you should use &ECL;'s API and understand the restriction described later in Except for finalization, which is a questionable feature, the previous settings are not very relevant for &CommonLisp; programmers, but are crucial for people interested in embedding in or cooperating with other C, C++ or Fortran libraries. Care should be taken when manipulating directly the GC library to avoid interfering with &ECL;'s expectations.
Memory limits Beginning with version 9.2.1, &ECL; operates a tighter control of the resources it uses. In particular, it features explicit limits in the four stacks and in the amount of live data. These limits are optional, can be changed at run time, but they allow users to better control the evolution of a program, handling memory and stack overflow gracefully via the &CommonLisp; condition system. The customizable limits are listed in , but they need a careful description. ext:heap-size limits the total amount of memory which is available for lisp objects. This is the memory used when you create conses, arrays, structures, etc. ext:c-stack controls the size of the stack for compiled code, including &ECL;'s library itself. This limit is less stringent than the others. For instance, when code is compiled with low safety settings, checks for this stack limit are usually omitted, for performance reasons. ext:binding-stack controls the number of nested bindings for special variables. The current value is usually safe enough, unless you have deep recursive functions that bind special variables, which is not really a good idea. ext:frame-stack controls the number of nested blocks, tagbody and other control structures. It affects both interpreted and compiled code, but quite often compiled code optimizes away these stack frames, saving memory and not being affected by this limit. ext:lisp-stack controls the size of the interpreter stack. It only affects interpreted code. If you look at , some of these limits may seem very stringent, but they exist to allow detecting and correcting both stack and memory overflow conditions. Larger values can be set systematically either in the ~/.eclrc initialization file, or using the command line options from the table.
Memory Conditions When &ECL; surpasses or approaches the memory limits it will signal a &CommonLisp; condition. There are two types of conditions, ext:stack-overflow and ext:storage-exhausted, for stack and heap overflows, respectively. Both errors are correctable, as the following session shows: > (defun foo (x) (foo x)) FOO > (foo 1) C-STACK overflow at size 1654784. Stack can probably be resized. Broken at SI:BYTECODES.Available restarts: 1. (CONTINUE) Extend stack size Broken at FOO. >> :r1 C-STACK overflow at size 2514944. Stack can probably be resized. Broken at SI:BYTECODES.Available restarts: 1. (CONTINUE) Extend stack size Broken at FOO. >> :q Top level.
Finalization As we all know, Common-Lisp relies on garbage collection for deleting unreachable objects. However, it makes no provision for the equivalent of a C++ Destructor function that should be called when the object is eliminated by the garbage collector. The equivalent of such methods in a garbage collected environment is normally called a finalizer. &ECL; includes a simple implementation of finalizers which makes the following promises. The finalizer can be any lisp function, let it be compiled or interpreter. Finalizers are not invoked during garbage collection. Instead, if an unreachable object is found to have an associated finalizer, it is pushed into a list and before the next garbage collection cycle, the finalizer will be invoked. If the finalizer is invoked and it makes the object reachable, for instance, by assigning it to a variable, it will not be destroyed, but it will have no longer a finalizer associated to it. &ECL; will strive to call finalizers before the environment is closed and the program is finished, but this mechanism may fail when exiting in a non ordinary way. The implementation is based on two functions, ext:set-finalizer and ext:get-finalizer, which allow setting and querying the finalizer functions for certain objects.
ecl-16.1.2/doc/mop.xmlf000066400000000000000000000061471266352375300146200ustar00rootroot00000000000000 %eclent; ]> Meta-Object Protocol (MOP)
Introduction The Meta-Object Protocol is an extension to &CommonLisp; which provides rules, functions and a type structure to handle the object system. It is a reflective system, where classes are also objects and can be created and manipulated using very well defined procedures. The Meta-Object Protocol associated to &CommonLisp;'s object system was introduced in a famous book, The Art of the Metaobject Protocol &AMOP;, which was probably intended for the &ANSI; specification but was drop out because of its revolutionary and then not too well tested ideas. The &AMOP; is present, in one way or another, in most &CommonLisp; implementations, eithr using proprietary systems or because their implementation of &CLOS; descended from &PCL; (Portable CommonLoops). It has thus become a de facto standard and &ECL; should not be without it. Unfortunately &ECL;'s own implemention originally contained only a subset of the &AMOP;. This was a clever decision at the time, since the focus was on performance and on producing a stable and lean implementation of &CommonLisp;. Nowadays it is however not an option, specially given that most of the &AMOP; can be implemented with little cost for both the implementor and the user. So &ECL; has an almost complete implementation of the &AMOP;. However, since it was written from scratch and progressed according to user's request and our own innovations, there might still be some missing functionality which we expect to correct in the near future. Please report any feature you miss as a bug through the appropriate channels. When considering the Metaobject Protocol, the book itself should be the main reference. The following sections contain only further extensions or improvements over the paragraphs which were either conflicting or less specified.
Classes [TODO: Document the class initialization / finalization protocol]
Slots [TODO: Document the slot descriptions and parameters.]
Generic functions and methods [TODO: Document the calling convetions for method functions.]
Sealed slots and classes [TODO: Document sealed slots]
ecl-16.1.2/doc/mp.xmlf000066400000000000000000000045611266352375300144370ustar00rootroot00000000000000 %eclent; ]> Multithreading
Tasks, threads or processes On most platforms, &ECL; supports native multithreading. That means there can be several tasks executing lisp code on parallel and sharing memory, variables and files. The interface for multitasking in &ECL;, like those of most other implementations, is based on a set of functions and types that resemble the multiprocessing capabilities of old Lisp Machines. This backward compatibility is why tasks or threads are called "processes". However, they should not be confused with operating system processes, which are made of programs running in separate contexts and without access to each other's memory. The implementation of threads in &ECL; is purely native and based on Posix Threads wherever avaiable. The use of native threads has advantanges. For instance, they allow for non-blocking file operations, so that while one task is reading a file, a different one is performing a computation. As mentioned above, tasks share the same memory, as well as the set of open files and sockets. This manifests on two features. First of all, different tasks can operate on the same lisp objects, reading and writing their slots, or manipulating the same arrays. Second, while threads share global variables, constants and function definitions they can also have thread-local bindings to special variables that are not seen by other tasks. The fact that different tasks have access to the same set of data allows both for flexibility and a greater risk. In order to control access to different resources, &ECL; provides the user with locks, as explained in the next section.
ecl-16.1.2/doc/os.xmlf000066400000000000000000000024661266352375300144460ustar00rootroot00000000000000 %eclent; ]> Operating System Interface
Processes &ECL; provides several facilities for invoking and communicating with . If one just wishes to execute some program, without caring for its output, then probably is the best function. In all other cases it is preferable to use , which opens pipes to communicate with the program and manipulate it while it runs on the background.
Command line arguments
OS Reference
ecl-16.1.2/doc/pde.xmlf000066400000000000000000000713031266352375300145710ustar00rootroot00000000000000 %eclent; ]> Program Development Facilities
The Stepper
step— Macro: step form Starts evaluating the form in the single-step mode. In this mode, before any form is evaluated, the Stepper will print the form and prompt the user for a Stepper command. The Stepper binds the two variables print-level and print-length both to 2, so that the current form may not occupy too much space on the screen. A Stepper command will be executed when the user types the single character for the command followed by the required arguments, if any, and presses the newline key. If the user presses the newline key without having typed any character, then the Stepper will assume that the Stepper command n was abbreviated.
The stepper commands are: Newline Next. Evaluates the current form in the single-step mode. :s, :skip Skip. Evaluates the current form in the ordinary mode. The single-step mode will be resumed at completion of the evaluation. :b, :back Backwards. Steps back to previous step form. :pr, :print Print. Pretty-prints the current form. :form Form. Return the current form. Nothing is done, but the current form is returned as the value of this command. As a consequence, it is printed by the top level in the usual way and saved in the variable *. The main purpose of this command is to allow the current form to be examined further by accessing *. :ret, :return Return. Return without evaluating the current form. :x, :exit Exit. Evaluates the current form and any other forms in the ordinary mode. ? Help. Lists the commands.
Errors
*break-enable*— Variable: *break-enable* This variable is used to determine whether to enter the break loop (see Section 5.4) when an error occurs. Even the function break checks this variable. Initially, this variable is set to T, and thus an error will invoke the break loop. If the value is (), functions that cause fatal errors, such as error, will just print an error message and control will return to the top-level loop (or to the current break loop, if already in the break loop). Functions that cause correctable errors, such as cerror, will print an error message and a “continue message”, and control will return to the next form. In &ECL;, backtrace is not part of an error message, but a break loop command will print backtrace. Therefore, if break-enable is (), no backtrace appears on the screen. When the break loop is entered, break-enable will be bound to ().
The Break Loop The break loop is a read-eval-print loop similar to the top-level loop. In addition to ordinary Lisp forms, the break loop accepts various commands with which the user can inspect and modify the state of the program execution. Each break loop command is identified with a keyword (i.e., a symbol in the keyword package). A break loop command is executed when the user inputs a list whose first element is the keyword that identifies the command. The rest of the list is the arguments to the command. They are evaluated before being passed to the command. If the command needs no arguments, then the user may input only the keyword. It is an error if the given keyword does not identify any command. Any other input to the break loop is regarded as an ordinary Lisp form; the form will be evaluated and the resulting values will be printed on the terminal. There can be several instances of the break loop at the same time, and each such instance is identified by a level number. When the break loop is entered during execution in the top-level loop, the break loop instance is given the level number 1. The break loop instance that is entered from the level n break loop is given the level number n+1. The prompt of the level n break loop is n+1 consecutive >'s, occasionally prefixed with the name of the current package. The break loop keeps track of the invocation sequence of functions (including special forms and macro expansion functions), which led up to the break loop from the previous break loop (or from the top-level loop, if the current break loop is level 1). The invocation sequence is maintained in a pushdown stack of events. An event consists of an event function and an event environment. An event function is: an interpreted (i.e., not compiled) function (global function, local function, lambda-expression, or closure), a special form within an interpreted function, a macro expansion function called from an interpreted function, a compiled function called from an interpreted function, or a compiled function called from another compiled function which was compiled while the safety optimize level is 3 or with a notinline declaration for the called function (see Chapter 7). An event is pushed on the event stack when execution of its event function begins, and is popped away at the completion of the execution. An event environment is the `environment' of the event function at the time the next event is pushed. Actually, an event environment is a pointer to the main stack of &ECL;. For each interpreted event function (i.e., event function in classes 1, 2, and 3), the pointer points to the first entry of the three contiguous main stack entries that hold the lexical environment of the event function. For each compiled event function (i.e., event function in classes 4 and 5), the pointer is set to the first entry of the main stack area that is used locally by the compiled code. In most cases, the first argument to the compiled function is saved in the first entry, the second argument in the second entry, and so on. The local variables of the function are allocated in the entries following the arguments. However, this is not always the case. Refer to Section 7.3 for variable allocations in compiled functions. By break level commands, the user can choose one of the events as the current event. If the current event function is an interpreted event function, then the break loop evaluates Lisp forms in the lexical environment retrieved from the event environment. In particular, local variables may be referenced by the variable names, local functions and local macros may be invoked as usual, established blocks may be exited from, and tags may be used as the destination of go. If the current function is a compiled function, Lisp forms are evaluated in the null environment. Within the break loop, each event is represented by the event symbol. The :backtrace command, for example, lists events in terms of their event symbols. If the event function is a named function (global or local) or a macro expansion function, then the function or macro name is used as the event symbol. If the event function is a special form, then the name of the special form is used. If the event function is a lambda-expression (or a closure), then the symbol lambda (or lambda-closure) is used. To suppress unnecessary information, the user can hide (or make invisible) some of the events. Invisible events do not appear in the backtrace, for example. Initially, only those events are invisible whose event symbols belong to the system internal package system. When the break loop is entered, the last visible event becomes the current event. The break loop commands are described below. Some of the commands allow abbreviation in the keywords that identify them. For example, the user may abbreviate :current as :c. The break loop commands return no values at all.
:current— Break Command: :current :c— Break Command: :c Prints the event symbol of the current event.
:previous— Break Command: :previous &optional n :p— Break Command: :p &optional n Makes the n-th previous visible event the new current event. Invisible events are not counted. If there are less than n previous events, then the first visible event in the invocation sequence becomes the new current event. n must be a positive integer and the default is 1.
:next— Break Command: :next &optional n :n— Break Command: :n &optional n Makes the n-th next visible event the new current event. If there are less than n next events, then the last visible event in the invocation sequence becomes the new current event. n must be a positive integer and the default is 1.
:backtrace— Break Command: :backtrace :b— Break Command: :b Prints the event symbols of all visible events in order. The symbol of the current event is printed in upper-case letters and the event symbols of other events are in lower-case.
:help— Break Command: :help :h— Break Command: :h Lists the break loop commands.
:quit— Break Command: :quit &optional n :q— Break Command: :q &optional n Returns control to the level n break loop. If n is 0 or if n is omitted, then control will return to the top-level loop. n must be a non-negative integer smaller than the current break level.
:continue— Break Command: :continue :c— Break Command: :c Returns control to the caller of the break loop. If the break loop has been entered from cerror, cerror returns () as its value and control will resume at that point. Otherwise, this command returns control to the previous break loop (or to the top-level loop, if the current break level is 1).
:variables— Break Command: :variables :v— Break Command: :v Prints the names of the bound variables in the current environment. To see the value of a bound variable, just type the variable name.
:functions— Break Command: :functions Prints the names of the local functions and local macros in the current environment. To see the definition of a local function or macro, use the function special form in the usual way. That is, (function name) will return the definition of the local function or macro whose name is name. Local functions and local macros may be invoked as usual.
:blocks— Break Command: :blocks Prints the names of the blocks established in the current environment. If a block block is established, then the return-from form (return-from block value) works as usual. That is, the block form that established block will return value as its value and control will resume at that point.
:tags— Break Command: :tags Prints the tags established in the current environment. If a tag tag is established, then the go form (go tag) works as usual. That is, control will resume at the position of tag in the surrounding tagbody.
:local— Break Command: :local &optional n :l— Break Command: :l &optional n If n is 0 or if it is omitted, then this command prints the value stored in the main stack entry that is pointed to by the current event environment. n is an offset from that entry. If n is positive, then the value of the n-th next (i.e., toward the top of the main stack) entry is printed. If n is negative, then the value of the n-th previous (i.e., toward the bottom of the main stack) entry is printed. n must be an integer. It is an error if the specified entry does not lie between the bottom and the top of the stack.
:hide— Break Command: :hide symbol Hides all events whose event symbol is symbol. In particular, by :hide 'lambda and hide 'lambda-closure, all events become invisible whose event functions are lambda-expressions and closures, respectively. If the event symbol of the current event happens to be symbol, then the last previous visible event will become the new current event. symbol must be a symbol. Events of eval and evalhook may never become invisible and attempts to hide them are simply ignored. It is always the case that the first event function is either eval or evalhook. Keeping both of them visible is the simplest way to avoid the silly attempts of the user to hide all events.
:hide-package— Break Command: :hide-package package Hides all events whose event symbol belongs to the package package. package may be any object that represents a package, i.e., a package object, a symbol, or a string. If the event symbol of the current event happens to belong to the package package, then the last previous visible event will become the new current event. Even if lisp package was specified as package, events of eval and evalhook do not become invisible. See the description of :hide above.
:unhide— Break Command: :unhide symbol :unhide is the inverse command of :hide. If, however, symbol belongs to one of the :hide-packaged packages, events of symbol become visible only after the package is :unhide-package 'd. symbol must be a symbol.
:unhide-package— Break Command: :unhide-package package :unhide-package is the inverse command of :hide-package. However, an event whose event symbol belongs to package becomes visible only after the symbol is unhide 'd, if the symbol was :code 'd before. package may be any object that represents a package, i.e., a package object, a symbol, or a string.
Example: > (defun fact (x) (if (= x 0) one (* x (fact (1- x))))) fact ;;; Wrong definition for fact, the factorial. > (fact 6) ;;; Tries to calculate factorial 6. Error: The variable ONE is unbound. Error signalled by IF. Broken at IF: ;;; Enters the break-loop. >> :h ;;; Help. Break commands: :q(uit) Return to some previous break level. :pop Pop to previous break level. :c(ontinue) Continue execution. :b(acktrace) Print backtrace. :f(unction) Show current function. :p(revious) Go to previous function. :n(ext) Go to next function. :g(o) Go to next function. :fs Search forward for function. :bs Search backward for function. :v(ariables) Show local variables, functions, blocks, and tags. :l(ocal) Return the nth local value on the stack. :hide Hide function. :unhide Unhide function. :hp Hide package. :unhp Unhide package. :unhide-all Unhide all variables and packages. :vs Show value stack. :bds Show binding stack. :m(essage) Show error message. :hs Help stack. Top level commands: :cf Compile file. :exit or ^D Exit Lisp. :ld Load file. :step Single step form. :tr(ace) Trace function. :untr(ace) Untrace function. Help commands: :apropos Apropos. :doc(ument) Document. :h(elp) or ? Help. Type ":help help" for more information. >> :b ;;; Backtrace. Backtrace: eval > fact > if > fact > if > fact > if > fact > if > fact > if > fact > if > fact > IF >>: p ;;; Moves to the previous event. Broken at FACT. >> :b ;;; Now inside of fact but outside of if. Backtrace: eval > fact > if > fact > if > fact > if > fact > if > fact > if > fact > if > FACT > if >> :v ;;; Shows local variables. Local variables: X: 1 Block names: FACT. >> x ;;; The value of x is 1. 1 >> (return-from fact 1) ;;; Returns from the fact block with value 1. 720 ;;; Now the correct answer. > ;;; Top-level.
Describe and Inspect
describe— Function: describe object Prints the information about object to the stream that is the value of *standard-output*. The description of an object consists of several fields, each of which is described in a recursive manner. For example, a symbol may have fields such as home package, variable documentation, value, function documentation, function binding, type documentation, deftype definition, properties.
inspect— Function: inspect object Prints the information about object in an interactive manner. The output of inspect is similar to that of describe, but after printing the label and the value of a field (the value itself is not describe 'd), it prompts the user to input a one-character command. The input to inspect is taken from the stream that is the value of *query-io*. Normally, the inspection of object terminates after all of its fields have been inspected. The following commands are supported: n Next. Goes to the next level; the field is inspected recursively. s Skip. Skips the inspection of the field. inspect proceeds to the next field. p Print. Pretty-prints the field and prompts again. u form Update. The form is evaluated and the field is replaced by the resulting value. If the field cannot be updated, the message Not updated. will be printed. a Abort. Aborts the inspection of the current object. The field and the rest of the fields are not inspected. e form Eval. Evaluates the specified form in the null environment and prints the resulting values. Then prompts again with the same field. q Quit. Aborts the entire inspection. ? Help. Lists the inspect commands.
The Profiler The profiler tool is enabled by default in the basic &ECL; configuration. It can be disabled with the configure option --disable-profiler.
profile— sys: profile grain &optional address This function activates the profiling of subsequent executions. grain is a value between 1 and 16384 which indicates the granularity of code segments to consider. There is a counter for each such segment. With each clock tick, the current segment is identified and its corresponding histogram count is incremented. A value of 0 for grain means stop profiling. address indicates the base address for the code being profiled.
display-profile— sys: display-profile Displays the histogram of accumulated tick counts. The ticks are attributed to the compiled Lisp function whose base address is closest to the start of the segment. This may not be totally accurate for system functions which invoke some auxiliary function to do the job.
clear-profile— sys: clear-profile Clears the profile histogram.
sys— Variable: sys *profile-array* Contains the profile histogram: two short integer counters are packed in each value of this array of fixnums.
Online Help Online help is provided by the following functions.
help— Function: help &optional symbol help with no arguments prints a greeting message to &ECL; beginners. help with a symbol argument prints the documentation associated with the symbol.
help*— Function: help* string &optional package Prints the documentation associated with those symbols in the specified package whose print names contain string as substring. string may be a symbol, in which case the print name of that symbol is used. package is optional and defaults to the LISP package. If package is (), then all packages are searched.
ecl-16.1.2/doc/preface.xmlf000066400000000000000000000466551266352375300154420ustar00rootroot00000000000000 %eclent; ]> Preface
About this book This manual is part of the &ECL; software system. It documents deviations of &ECL; from various standards (&ANSI;, &AMOP;,...), extensions, daily working process (compiling files, loading sources, creating programs, etc) and the internals of this implementation. This book is not intended as a source to learn &CommonLisp;. There are other tutorials and textbooks available in the Net which serve this purpose. The homepage of the Association of Lisp Users contains a good list of links of such teaching and learning material. This book is structured into three parts. We begin with which documents all parts of the standard which are left as implementation specific. For instance, precision of floating point numbers, available character sets, actual input/output protocols, etc. introduces all features which are specific to &ECL; and which lay outside the standard. This includes configuring, building and installing &ECL; multiprocessing capabilities, graphics libraries, interfacing with the operating system, etc. deals with the internals of the implementation. This part is only intended for experienced programmers that want to learn how &ECL; does its work and wish to extend it, customize it or port it to new architectures. This part of the documentation is the most fragile one and prone to change.
What is &ECL;? &CommonLisp; is a general purpose programming language. It lays its roots in the LISP programming language developed by John McCarthy in the 80s. &CommonLisp; as we know it &ANSI; is the result of an standarization process aimed at unifying the multiple lisp dialects that were born from that language. &ECL; is an implementation of the Common-Lisp language. As such it derives from the implementation of the same name developed by Giuseppe Attardi, which itself was built using code from the Kyoto Common-Lisp . See for the history of the code you are about to use. &ECL; (ECL for short) uses standard C calling conventions for Lisp compiled functions, which allows C programs to easily call Lisp functions and vice versa. No foreign function interface is required: data can be exchanged between C and Lisp with no need for conversion. &ECL; is based on a Common Runtime Support (CRS) which provides basic facilities for memory management, dynamic loading and dumping of binary images, support for multiple threads of execution. The CRS is built into a library that can be linked with the code of the application. &ECL; is modular: main modules are the program development tools (top level, debugger, trace, stepper), the compiler, and CLOS. A native implementation of CLOS is available in &ECL;. A runtime version of &ECL; can be built with just the modules which are required by the application. The &ECL; compiler compiles from Lisp to C, and then invokes the GNU C compiler to produce binaries. While former releases of ECL adhere to the the reference of the language given in &Steele84;, the aim of &ECL; is now to achieve maximum compliance with ANSI Common-Lisp, the most up to date standard for Common-Lisp.
History
ECL's family tree
The &ECL; project is an implementation of the Common-Lisp language inherits from many other previous projects, as shown in . The oldest ancestor is the Kyoto Common Lisp, an implementation developed at the the Research Institute for Mathematical Sciences, Kyoto University . This implementation was developed partially in C and partially in Common Lisp itself and featured a lisp to C translator. The KCL implementation remained a propietary project for some time. During this time, William F. Schelter improved KCL in several areas and developed Austin Kyoto Common-Lisp (AKCL). However, those changes had to be distributed as patches over the propietary KCL implementation and it was not until much later that both KCL and AKCL became freely available and gave rise to the GNU Common Lisp project, GCL. Around the 90's, Giusseppe Attardi worked on the KCL and AKCL code basis to produce an implementation of &CommonLisp; that could be embedded in other C programs . The result was an implementation sometimes known as ECL and sometimes as ECoLisp, which achieved rather good compliance to the informal specification of the language in &Steele84;, and which run on a rather big number of platforms. The &ECL; project stagnated a little bit in the coming years. In particular, certain dependencies such as object binary formats, word sizes and some C quirks made it difficult to port it to new platforms. Furthermore, &ECL; was not compliant with the ANSI specification, a goal that other Common Lisps were struggling to achieve. This is where the ECLS or ECL-Spain project began. Juanjo GarcУ­a-Ripoll took the ECoLisp sources and worked on them, with some immediate goals in mind: increase portability, make the code 64-bit clean, make it able to build itself from scratch, without other implementation of &CommonLisp; and restore the ability to link &ECL; with other C programs. Those goals were rather quickly achieved. &ECL; became ported to a number of platforms and with the years also compatibility with the ANSI specification became a more important goal. At some point the fork ECLS, with agreement of Prof. Attardi, took over the original ECL implementation and it became what it is nowadays, a community project. In 2013 once again project got unmaintained. In 2015 Daniel KochmaХ„ski took position of maintainer with consent of Juanjo GarcУ­a-Ripoll. The &ECL; project owes a lot to different people who have contributed in many different aspects, from pointing out bugs and incompatibilities of &ECL; with other programs and specifications, to actually solving these bugs and porting &ECL; to new platforms. Current development of &ECL; is still driven by Daniel KochmaХ„ski with main focus on improving ANSI compliance and compapibility with &CommonLisp; libraries ecosystem, fixing bugs, improving speed and protability. The project homepage is located at https://common-lisp.net/project/ecl/, and there are pointers to all project resources like mailing list and main repository.
Copyright of ECL &ECL; is distributed under the GNU LGPL, which allows for commercial uses of the software. A more precise description is given in the Copyright notice which is shipped with &ECL;. ---- BEGINNING OF COPYRIGHT FOR THE ECL CORE ENVIRONMENT ------------ Copyright (c) 2015, Daniel KochmaХ„ski Copyright (c) 2000, Juan Jose Garcia Ripoll Copyright (c) 1990, 1991, 1993 Giuseppe Attardi Copyright (c) 1984 Taiichi Yuasa and Masami Hagiya All Rights Reserved ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version; see file 'Copying'. 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 Library General Public License for more details. You should have received a copy of the GNU Library General Public License along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. PLEASE NOTE THAT: This license covers all of the ECL program except for the files src/lsp/loop2.lsp ; Symbolic's LOOP macro src/lsp/pprint.lsp ; CMUCL's pretty printer src/lsp/format.lsp ; CMUCL's format and the directories contrib/ ; User contributed extensions src/clx/ ; portable CLX library from Telent Look the precise copyright of these extensions in the corresponding files. Report bugs, comments, suggestions to the ecl mailing list: ecls-list@lists.sourceforge.net. ---- END OF COPYRIGHT FOR THE ECL CORE ENVIRONMENT ------------------
Copyright of this manual Copyright: Daniel KochmaХ„ski, 2015. Copyright: Juan JosУЉ GarcУ­a-Ripoll, 2006. Copyright: Kevin M. Rosenberg 2002-2003, (UFFI Reference) &ACL; is a registered trademark of Franz Inc. &LW; is a registered trademark of Xanalys Inc. Microsoft Windows is a registered trademark of Microsoft Inc. Other brand or product names are the registered trademarks or trademarks of their respective holders. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.1 or any later version published by the Free Software Foundation; with no Invariant Sections, with the no Front-Cover Texts, and with no Back-Cover Texts. A copy of the license is shown below. &GFDL;
Installation The following sections describe which machines are supported by &ECL;, how to build and install it on them. You should read at least and in particular which details the other sections containing installation instructions for your platform.
Supported platforms Supported platforms Architecture Operating system Toolchain TestedYES means that a dedicated machine regularly builds and tests &ECL; on this platform. x86 Intel 32 bit processors (Pentium, Pentium II, Pentium 3, Pentium 4) and AMD clones Linux Autoconf YES x86_64AMD and Intel processors with 64 bit extensions. Linux Autoconf YES PPC Linux Autoconf YES Itanium Linux Autoconf YES x86 FreeBSD Autoconf YES x86 OpenBSD Autoconf YES x86 NetBSD Autoconf YES x86 Windows XP, Vista, 7 Microsoft compilers YES x86 Windows XP, Vista, 7 &cygwin; YES x86 Windows XP, Vista, 7, 8 &mingw; and Msys tools YES x86 OS X Tiger Autoconf YES x86_64 OS X Tiger Autoconf YES x86 Solaris Autoconf YES x86_64 Solaris Autoconf YES Sparc Solaris Autoconf YES
In we show the operating systems in which ECL is known to run and where it is regularly tested. Note that ECL might successfully build on other platforms, and that porting is relatively easy. We regularly get reports on ECL being built on other platforms (ARM, Motorola 68x, Sparc, etc), so the best thing is to try yourself.
Autoconf based configuration &ECL;, like many other free programs, can be built and installed a GNU tool called Autoconf. This is a set of automatically generated scripts that detect the features of your machine, such as the compiler type, existing libraries, desired installation path, and configures &ECL; accordingly. The following procedure describes how to build &ECL; using this procedure and it applies to all platforms except for the Windows ports. Unpack the tar file $ gunzip -c ecl-16.0.0.tgz | tar xf - Choose a directory in which you will install &ECL;. Following the Unix covention we will use /usr/local Run the configuration file $ cd ecl-16.0.0 $ ./configure --prefix=/usr/local If you are building under Solaris 9 you should replace the last line with $ ./configure --enable-slow-config --with-system-gmp=no \ --prefix=/usr/local By now you should have a directory with the name build and a bunch of makefiles inside it. Use GNU make to begin building ECL. Normally this amounts to invoking $ make from the command line. Install the program using $ make install Make sure the program is installed and ready to run $ /usr/local/ecl ECL (Embeddable Common-Lisp) 16.0.0 Copyright (C) 1984 Taiichi Yuasa and Masami Hagiya Copyright (C) 1993 Giuseppe Attardi Copyright (C) 2000 Juan J. Garcia-Ripoll Copyright (C) 2015 Daniel Kochmanski ECL is free software, and you are welcome to redistribute it under certain conditions; see file 'Copyright' for details. Type :h for Help. Top level in: #<process TOP-LEVEL>. >
Platform specific instructions
Microsoft compilers If you have a commercial version of Microsoft Visual Studio, the steps are simple: Change to the msvc directory. Run nmake to build ECL. Run nmake install prefix=d:\Software\ECL where the prefix is the directory where you want to install ECL. Optionally, if you want to build a self-installing executable, you can install NSIS and run nmake windows-nsi. If you want to build ECL using the free Microsoft Visual Studio Express 2010 or better, you should follow these before building ECL as sketched before: Download and install Microsoft Visual Studio C++ Compiler. Download and install the Windows SDK Open the Windows SDK terminal, which will set up the appropriate paths and environment variables.
OpenBSD and NetBSD Before following the instructions in you should install the following packages: boehm-gc and gmp-4.1 or better. Another component, libffi will be needed if you want to use the dynamic foreign interface.
ecl-16.1.2/doc/ref_c_arrays.xml000066400000000000000000000516631266352375300163210ustar00rootroot00000000000000 %eclent; ]> Arrays
C Reference Types and constants C types, limits and enumerations Constants and types ECL_ARRAY_RANK_LIMIT ECL_ARRAY_DIMENSION_LIMIT ECL_ARRAY_TOTAL_LIMIT typedef enum { ecl_aet_object, ...} cl_elttype; Lisp or C type Enumeration value Lisp or C type Enumeration value t ecl_aet_object (unsigned-byte 1) ecl_aet_bit cl_fixnum ecl_aet_fix cl_index ecl_aet_index (unsigned-byte 8) ecl_aet_b8 (signed-byte 8) ecl_aet_i8 (unsigned-byte 16) ecl_aet_b16 (signed-byte 16) ecl_aet_i16 (unsigned-byte 32) ecl_aet_b32 (signed-byte 32) ecl_aet_i32 (unsigned-byte 64) ecl_aet_b64 (signed-byte 64) ecl_aet_i64 ecl_character ecl_aet_ch ecl_base_char ecl_aet_bc single-float ecl_aet_sf double-float ecl_aet_df Description This list contains the constants that limit the rank of an array (ECL_ARRAY_RANK_LIMIT), the maximum size of each dimension (ECL_ARRAY_DIMENSION_LIMIT) and the maximum number of elements in an array (ECL_ARRAY_TOTAL_LIMIT). &ECL; uses also internally a set of constants to describe the different specialized arrays. The constants form up the enumeration type cl_elttype. They are listed in the table above, which associates enumeration values with the corresponding Common Lisp element type. ecl_aet_to_symbol, ecl_symbol_to_aet To and from element types Functions cl_object ecl_aet_to_symbol cl_elttype param cl_elttype ecl_symbol_to_aet cl_object type Description ecl_aet_to_symbol returns the Lisp type associated to the elements of that specialized array class. ecl_symbol_to_aet does the converse, computing the C constant that is associated to a Lisp elment type. The functions may signal an error if any of the arguments is an invalid C or Lisp type. Constructors Creating arrays and vectors Functions cl_object ecl_alloc_simple_vector cl_elttype element_type cl_index length cl_object si_make_vector cl_object element_type cl_object length cl_object adjustablep cl_object fill_pointerp cl_object displaced_to cl_object displacement cl_object si_make_array cl_object element_type cl_object dimensions cl_object adjustablep cl_object fill_pointerp cl_object displaced_to cl_object displacement Description The function ecl_alloc_simple_vector is the simplest constructor, creating a simple vector (i.e. non-adjustable and without a fill pointer), of the given size, preallocating the memory for the array data. The first argument, element_type, is a C constant that represents a valid array element type (See cl_elttype). The function si_make_vector does the same job but allows creating an array with fill pointer, which is adjustable or displaced to another array. element_type is now a Common Lisp type descriptor, which is a symbol or list denoting a valid element type dimension is a non-negative fixnum with the vector size. fill_pointerp is either Cnil or a non-negative fixnum denoting the fill pointer value. displaced_to is either Cnil or a valid array to which the new array is displaced. displacement is either Cnil or a non-negative value with the array displacement. Finally, the function si_make_array does a similar job to si_make_function but its second argument, dimension, can be a list of dimensions, to create a multidimensional array. Example Create one-dimensional base-string with room for 11 characters: cl_object s = ecl_alloc_simple_vector(ecl_aet_bc, 11); Create a one-dimensional array with a fill pointer cl_object type = ecl_make_symbol("BYTE8","EXT"); cl_object a = si_make_vector(ecl_make_fixnum(16), type, Cnil, /* adjustable */ ecl_make_fixnum(0) /* fill-pointer */, Cnil /* displaced_to */, Cnil /* displacement */); An alternative formulation cl_object type = ecl_make_symbol("BYTE8","EXT"); cl_object a = si_make_array(ecl_make_fixnum(16), type, Cnil, /* adjustable */ ecl_make_fixnum(0) /* fill-pointer */, Cnil /* displaced_to */, Cnil /* displacement */); Create a 2-by-3 two-dimensional array, specialized for an integer type: cl_object dims = cl_list(2, ecl_make_fixnum(2), ecl_make_fixnum(3)); cl_object type = ecl_make_symbol("BYTE8","EXT"); cl_object a = si_make_array(dims, type, Cnil, /* adjustable */ Cnil /* fill-pointer */, Cnil /* displaced_to */, Cnil /* displacement */); Accessors Reading and writing array elements Functions cl_object ecl_aref cl_object array cl_index row_major_index cl_object ecl_aset cl_object array cl_index row_major_index cl_object new_value cl_object ecl_aref1 cl_object vector cl_index row_major_index cl_object ecl_aset1 cl_object vector cl_index row_major_index cl_object new_value Description ecl_aref accesses an array using the supplied row_major_index, checking the array bounds and returning a Lisp object for the value at that position. ecl_aset does the converse, storing a Lisp value at the given row_major_index. The first argument to ecl_aref or ecl_aset is an array of any number of dimensions. For an array of rank N and dimensions d1, d2 ... up to dN, the row major index associated to the indices (i1,i2,...iN) is computed using the formula i1+d1*(i2+d3*(i3+...)). ecl_aref1 and ecl_aset1 are specialized versions that only work with one-dimensional arrays or vectors. They verify that the first argument is indeed a vector. All functions above check that the index does not exceed the array bounds, that the values match the array element type and that the argument is an array (or a vector). If these conditions are not met, a type error is signaled. Array properties Array size, fill pointer, etc cl_elttype ecl_array_elttype cl_object array cl_index ecl_array_rank cl_object array cl_index ecl_array_dimension cl_object array cl_index index Description These functions query various properties of the arrays. Some of them belong to the list of functions in the Common Lisp package, without any need for specialized versions. More precisely ecl_array_elttype returns the array element type, with the encoding found in the enumeration cl_elttype. ecl_array_rank returns the number of dimensions of the vector or array. ecl_array_dimension queries the dimension of an array, where index is a non-negative integer between 0 and ecl_array_dimension(array)-1. ANSI Dictionary &ANSI-C-Dict; Lisp symbol C function make-array cl_object cl_make_array(cl_narg narg, cl_object dimension...) adjust-array cl_object cl_adjust_array(cl_narg narg, cl_object array, cl_object dimensions, ...) adjustable-array-p cl_object cl_adjustable_array_p(cl_object array) aref cl_object cl_aref(cl_narg narg, cl_object array, ...) array-dimension cl_object cl_array_dimension(cl_object array, cl_object index) array-dimensions cl_object cl_array_dimension(cl_object array) array-element-type cl_object cl_array_element_type(cl_object array) array-has-fill-pointer-p cl_object cl_array_has_fill_pointer_p(cl_object array) array-displacement cl_object cl_array_displacement(cl_object array) array-in-bounds-p cl_object cl_array_in_bounds_p(cl_narg narg, cl_object array, ...) array-rank cl_object cl_array_rank(cl_object array) array-row-major-index cl_object cl_array_row_major_index(cl_narg narg, cl_object array, ...) array-total-size cl_object cl_array_total_size(cl_object array) arrayp cl_object cl_arrayp(cl_object array) fill-pointer cl_object cl_fill_pointer(cl_object array) row-major-aref cl_object cl_row_major_aref(cl_object array, cl_object index) upgraded-array-element-type cl_object cl_upgraded_array_element_type(cl_narg narg, cl_object typespec, ...) simple-vector-p cl_object cl_simple_vector_p(cl_object object) svref cl_object cl_svref(cl_object simple_vector, cl_object index) vector cl_object cl_vector(cl_narg narg, ...) vector-pop cl_object cl_vector_pop(cl_object vector) vector-push cl_object cl_vector_push(cl_object new_element, cl_object vector) vector-push-extend cl_object cl_vector_push_extend(cl_narg narg, cl_object new_element, cl_object vector, ...) vectorp cl_object cl_vectorp(cl_object object) bit cl_object cl_bit(cl_narg narg, cl_object bit_array, ...) sbit cl_object cl_sbit(cl_narg narg, cl_object bit_array, ...) bit-and cl_object cl_bit_and(cl_narg narg, cl_object array1, cl_object array2, ...) bit-andc1 cl_object cl_bit_andc1(cl_narg narg, cl_object array1, cl_object array2, ...) bit-andc2 cl_object cl_bit_andc2(cl_narg narg, cl_object array1, cl_object array2, ...) bit-eqv cl_object cl_bit_eqv(cl_narg narg, cl_object array1, cl_object array2, ...) bit-ior cl_object cl_bit_ior(cl_narg narg, cl_object array1, cl_object array2, ...) bit-nand cl_object cl_bit_nand(cl_narg narg, cl_object array1, cl_object array2, ...) bit-nor cl_object cl_bit_nor(cl_narg narg, cl_object array1, cl_object array2, ...) bit-orc1 cl_object cl_bit_orc1(cl_narg narg, cl_object array1, cl_object array2, ...) bit-orc2 cl_object cl_bit_orc1(cl_narg narg, cl_object array1, cl_object array2, ...) bit-xor cl_object cl_bit_xor(cl_narg narg, cl_object array1, cl_object array2, ...) bit-not cl_object cl_bit_not(cl_narg narg, cl_object array, ...) Description
ecl-16.1.2/doc/ref_c_characters.xml000066400000000000000000000301751266352375300171320ustar00rootroot00000000000000 %eclent; ]> Characters
C Reference C types C character types Type names ecl_character character ecl_base_char base-char Description &ECL; defines two C types to hold its characters: ecl_base_char and ecl_character. When &ECL; is built without Unicode, they both coincide and typically match unsigned char, to cover the 256 codes that are needed. When &ECL; is built with Unicode, the two types are no longer equivalent, with ecl_character being larger. For your code to be portable and future proof, use both types to really express what you intend to do. Constructors Creating and extracting characters from Lisp objects Functions and macros cl_object ECL_CODE_CHAR ecl_character code ecl_character ECL_CHAR_CODE cl_object o cl_object ecl_char_code ecl_character code ecl_base_char ecl_base_char_code cl_object o Description These functions and macros convert back and forth from C character types to Lisp. The macros ECL_CHAR_CODE and ECL_CODE_CHAR perform this coercion without checking the arguments. The functions ecl_char_code and ecl_base_char_code, on the other hand, verify that the argument has the right type and signal an error otherwise. Predicates C predicates for Lisp characters Functions and macros bool ecl_base_char_p ecl_character c bool ecl_alpha_char_p ecl_character c bool ecl_alphanumeric_p ecl_character c bool ecl_graphic_char_p ecl_character c bool ecl_digit_p ecl_character c bool ecl_standard_char_p ecl_character c Description These functions are equivalent to their Lisp equivalents but return C booleans. Character case C functions related to the character case Functions and macros bool ecl_upper_case_p ecl_character c bool ecl_lower_case_p ecl_character c bool ecl_both_case_p ecl_character c ecl_character ecl_char_downcase ecl_character c ecl_character ecl_char_upcase ecl_character c Description These functions check or change the case of a character. Note that in an Unicode context, the output of these functions might not be accurate (for instance when the uppercase character has two or more codepoints). ANSI Dictionary &ANSI-C-Dict; Lisp symbol C function char= cl_object cl_charE(cl_narg narg, ...) char/= cl_object cl_charNE(cl_narg narg, ...) char< cl_object cl_charL(cl_narg narg, ...) char> cl_object cl_charG(cl_narg narg, ...) char<= cl_object cl_charLE(cl_narg narg, ...) char>= cl_object cl_charGE(cl_narg narg, ...) char-equal cl_object cl_char_equal(cl_narg narg, ...) char-not-equal cl_object cl_char_not_equal(cl_narg narg, ...) char-lessp cl_object cl_char_lessp(cl_narg narg, ...) char-greaterp cl_object cl_char_greaterp(cl_narg narg, ...) char-not-greaterp cl_object cl_char_not_greaterp(cl_narg narg, ...) char-not-lessp cl_object cl_char_not_lessp(cl_narg narg, ...) character cl_object cl_character(cl_object char_designator) characterp cl_object cl_characterp(cl_object object) alpha-char-p cl_object cl_alpha_char_p(cl_object character) alphanumericp cl_object cl_alphanumericp(cl_object character) digit-char cl_object cl_digit_char(cl_narg narg, cl_object character, ...) digit-char-p cl_object cl_digit_char_p(cl_narg narg, cl_object character, ...) graphic-char-p cl_object cl_graphic_char_p(cl_object character) standard-char-p cl_object cl_standard_char_p(cl_object character) char_upcase cl_object cl_char_upcase(cl_object character) char-downcase cl_object cl_char_downcase(cl_object character) upper-case-p cl_object cl_upper_case_p(cl_object character) lower-case-p cl_object cl_lower_case_p(cl_object character) both-case-p cl_object cl_both_case_p(cl_object character) char-code cl_object cl_char_code(cl_object character) char-int cl_object cl_char_int(cl_object character) code-char cl_object cl_code_char(cl_object code) char-name cl_object cl_char_name(cl_object character) name-char cl_object cl_name_char(cl_object name) Description
ecl-16.1.2/doc/ref_c_conditions.xml000066400000000000000000000213001266352375300171520ustar00rootroot00000000000000 %eclent; ]> Conditions
C Reference ECL_HANDLER_CASE C macro for handler-case ECL_HANDLER_CASE_BEGIN(env,names) { } ECL_HANDLER_CASE(n,condition) { { } ECL_HANDLER_CASE_END; Description ECL_HANDLER_CASE_BEGIN runs a block of C code with a set of error handlers bound to the names given by the list names. The subsequent ECL_HANDLER_CASE statements specify what to do when the n-th type of conditions is found, where n is an integer denoting the position of the name in the list names. When a condition is signaled, &ECL; scans the list of signal handlers, looking for matches based on typep. If the match with the highest precedence belongs to the list names, &ECL; will perform a non-local transfer of control to the appropriate ECL_HANDLER_CASE, passing it a condition object as unique argument. The following example shows how to establish a handler for ERROR conditions. Note how the first value to ECL_HANDLER_CASE matches the position of the restart name in the list: cl_object error = ecl_make_symbol("ERROR","CL"); ECL_RESTART_BEGIN(the_env, ecl_list1(error)) { /* This form is evaluated with bound handlers */ output = cl_eval(1, form); } ECL_HANDLER_CASE(1, condition) { /* This code is executed when an error happens */ /* We just return the error that took place */ output = condition; } ECL_RESTART_END; ECL_RESTART_CASE C macro for restart-case ECL_RESTART_CASE_BEGIN(env,names) { } ECL_RESTART_CASE(n,args) { { } ECL_RESTART_CASE_END; Description ECL_RESTART_CASE_BEGIN runs a block of C code with a set of restarts bound to the names given by the list names. The subsequent ECL_RESTART_CASE statements specify what to do when the n-th restart is invoked, where n is an integer denoting the position of the name in the list names. When the restart is invoked, it can receive any number of arguments, which are grouped in a list and stored in a new variable created with the name args. The following example shows how to establish an ABORT and a USE-VALUE restart. Note how the first value to ECL_RESTART_CASE matches the position of the restart name in the list: cl_object abort = ecl_make_symbol("ABORT","CL"); cl_object use_value = ecl_make_symbol("USE-VALUE","CL"); ECL_RESTART_BEGIN(the_env, cl_list(2, abort, use_value)) { /* This form is evaluated with bound restarts */ output = cl_eval(1, form); } ECL_RESTART_CASE(1, args) { /* This code is executed when the 1st restart (ABORT) is invoked */ output = Cnil; } ECL_RESTART_CASE(2, args) { /* This code is executed when the 2nd restart (ABORT) is invoked */ output = ECL_CAR(args); } ECL_RESTART_END; Conditions C dictionary &ANSI-C-Dict; Lisp symbol C function abort cl_object cl_abort(cl_narg narg, ...) break cl_object cl_break() cell-error-name &OCL; cerror cl_object cl_cerror(cl_narg narg, cl_object continue_format_control, cl_object datum, ...) compute-restarts cl_object cl_compute_restarts(cl_narg narg, ...) continue cl_object cl_continue(cl_narg narg, ...) error cl_object cl_error(cl_narg narg, cl_object datum, ...) find-restart cl_object cl_find_restart(cl_narg narg, cl_object identifier, ...) handler-case ECL_HANDLER_CASE macro invalid-method-error &OCL; invoke-debugger cl_object cl_invoke_debugger(cl_object condition) invoke-restart cl_object cl_invoke_restart(cl_narg narg, cl_object restart, ...) invoke-restart-interactively cl_object cl_invoke_restart_interactively(cl_object restart) make-condition cl_object cl_make_condition(cl_narg narg, cl_object type) method-combination-error &OCL; muffle-warning cl_object cl_muffle_warning(cl_narg narg, ...) restart-name &OCL; restart-case ECL_RESTART_CASE macro signal cl_object cl_signal(cl_narg narg, cl_object datum, ...) simple-condition-format-control &OCL; simple-condition-format-arguments &OCL; store-value cl_object cl_store_value(cl_narg narg, ...) use-value cl_object cl_use_value(cl_narg narg, ...) warn cl_object cl_warn(cl_narg narg, cl_object datum, ...) Description
ecl-16.1.2/doc/ref_c_conses.xml000066400000000000000000000427361266352375300163130ustar00rootroot00000000000000 %eclent; ]> Conses
C Reference ANSI Dictionary &ANSI-C-Dict; Lisp symbol C function cons cl_object cl_cons(cl_object car, cl_object cdr) consp cl_object cl_consp(cl_object object) atom cl_object cl_atom(cl_object object) rplaca cl_object cl_rplaca(cl_object cons, cl_object car) rplacd cl_object cl_rplacd(cl_object cons, cl_object cdr) car cl_object cl_car(cl_object cons) cdr cl_object cl_cdr(cl_object cons) caar cl_object cl_caar(cl_object cons) cdar cl_object cl_cdar(cl_object cons) cadr cl_object cl_cadr(cl_object cons) cddr cl_object cl_cddr(cl_object cons) caaar cl_object cl_caaar(cl_object cons) cdaar cl_object cl_cdaar(cl_object cons) cadar cl_object cl_cadar(cl_object cons) cddar cl_object cl_cddar(cl_object cons) caadr cl_object cl_caadr(cl_object cons) cdadr cl_object cl_cdadr(cl_object cons) caddr cl_object cl_caddr(cl_object cons) cdddr cl_object cl_cdddr(cl_object cons) caaaar cl_object cl_caaaar(cl_object cons) cdaaar cl_object cl_cdaaar(cl_object cons) cadaar cl_object cl_cadaar(cl_object cons) cddaar cl_object cl_cddaar(cl_object cons) caadar cl_object cl_caadar(cl_object cons) cdadar cl_object cl_cdadar(cl_object cons) caddar cl_object cl_caddar(cl_object cons) cdddar cl_object cl_cdddar(cl_object cons) caaadr cl_object cl_caaadr(cl_object cons) cdaadr cl_object cl_cdaadr(cl_object cons) cadadr cl_object cl_cadadr(cl_object cons) cddadr cl_object cl_cddadr(cl_object cons) caaddr cl_object cl_caaddr(cl_object cons) cdaddr cl_object cl_cdaddr(cl_object cons) cadddr cl_object cl_cadddr(cl_object cons) cddddr cl_object cl_cddddr(cl_object cons) copy-tree cl_object cl_copy_tree(cl_object tree) sublis cl_object cl_sublis(cl_narg narg, cl_object alist, cl_object tree, ...) nsublis cl_object cl_sublis(cl_narg narg, cl_object alist, cl_object tree, ...) subst cl_object cl_subst(cl_narg narg, cl_object new, cl_object old, cl_object tree, ...) subst-if cl_object cl_subst_if(cl_narg narg, cl_object new, cl_object predicate, cl_object tree, ...) subst-if-not cl_object cl_subst_if_not(cl_narg narg, cl_object new, cl_object predicate, cl_object tree, ...) nsubst cl_object cl_nsubst(cl_narg narg, cl_object new, cl_object old, cl_object tree, ...) nsubst-if cl_object cl_nsubst_if(cl_narg narg, cl_object new, cl_object predicate, cl_object tree, ...) nsubst-if-not cl_object cl_nsubst_if_not(cl_narg narg, cl_object new, cl_object predicate, cl_object tree, ...) tree-equal cl_object cl_tree_equal(cl_narg narg, cl_object tree1, cl_object tree2, ...) copy-list cl_object cl_copy_list(cl_object list) list cl_object cl_list(cl_narg narg, ...) list* cl_object cl_listA(cl_narg narg, ...) list-length cl_object cl_list_length(cl_object list) listp cl_object cl_listp(cl_object object) make-list cl_object cl_make_list(cl_narg narg, cl_object size, ...) first cl_object cl_first(cl_object list) second cl_object cl_second(cl_object list) third cl_object cl_third(cl_object list) fourth cl_object cl_fourth(cl_object list) fifth cl_object cl_fifth(cl_object list) sixth cl_object cl_sixth(cl_object list) seventh cl_object cl_seventh(cl_object list) eighth cl_object cl_eighth(cl_object list) ninth cl_object cl_ninth(cl_object list) tenth cl_object cl_tenth(cl_object list) nth cl_object cl_nth(cl_object n, cl_object list) endp cl_object cl_endp(cl_object list) null cl_object cl_null(cl_object object) nconc cl_object cl_nconc(cl_narg narg, ...) append cl_object cl_append(cl_narg narg, ...) revappend cl_object cl_revappend(cl_object list, cl_object tail) nreconc cl_object cl_nreconc(cl_object list, cl_object tail) butlast cl_object cl_butlast(cl_narg narg, cl_object list, ...) nbutlast cl_object cl_nbutlast(cl_narg narg, cl_object list, ...) last cl_object cl_last(cl_narg narg, cl_object list, ...) ldiff cl_object cl_ldiff(cl_object list, cl_object object) tailp cl_object cl_tailp(cl_object object, cl_object list) nthcdr cl_object cl_nthcdr(cl_object n, cl_object list) rest cl_object cl_rest(cl_object list) member cl_object cl_member(cl_narg narg, cl_object member, cl_object list, ....) member-if cl_object cl_member_if(cl_narg narg, cl_object predicate, cl_object list, ....) member-if-not cl_object cl_member_if_not(cl_narg narg, cl_object predicate, cl_object list, ....) mapc cl_object cl_mapc(cl_narg narg, cl_object function, ...) mapcar cl_object cl_mapcar(cl_narg narg, cl_object function, ...) mapcan cl_object cl_mapcan(cl_narg narg, cl_object function, ...) mapl cl_object cl_mapl(cl_narg narg, cl_object function, ...) maplist cl_object cl_maplist(cl_narg narg, cl_object function, ...) mapcon cl_object cl_mapcon(cl_narg narg, cl_object function, ...) acons cl_object cl_acons(cl_object key, cl_object datum, cl_object alist) assoc cl_object cl_assoc(cl_narg narg, cl_object item, cl_object alist, ...) assoc-if cl_object cl_assoc_if(cl_narg narg, cl_object predicate, cl_object alist, ...) assoc-if-not cl_object cl_assoc_if_not(cl_narg narg, cl_object predicate, cl_object alist, ...) copy-alist cl_object cl_copy_alist(cl_object alist) pairlis cl_object cl_pairlis(cl_narg narg, cl_object keys, cl_object data, ...) rassoc cl_object cl_rassoc(cl_narg narg, cl_object item, cl_object alist, ...) rassoc-if cl_object cl_rassoc_if(cl_narg narg, cl_object predicate, cl_object alist, ...) rassoc-if-not cl_object cl_rassoc_if_not(cl_narg narg, cl_object predicate, cl_object alist, ...) get-properties cl_object cl_get_properties(cl_object plist, cl_object indicator_list) getf cl_object cl_getf(cl_narg narg, cl_object plist, cl_object indicator, ...) intersection cl_object cl_intersection(cl_narg narg, cl_object list1, cl_object list2, ...) nintersection cl_object cl_nintersection(cl_narg narg, cl_object list1, cl_object list2, ...) adjoin cl_object cl_adjoin(cl_narg narg, cl_object item, cl_object list, ...) set-difference cl_object cl_set_difference(cl_narg narg, cl_object list1, cl_object list2, ...) nset-difference cl_object cl_nset_difference(cl_narg narg, cl_object list1, cl_object list2, ...) set-exclusive-or cl_object cl_set_exclusive_or(cl_narg narg, cl_object list1, cl_object list2, ...) nset-exclusive-or cl_object cl_nset_exclusive_or(cl_narg narg, cl_object list1, cl_object list2, ...) subsetp cl_object cl_subsetp(cl_narg narg, cl_object list1, cl_object list2, ...) union cl_object cl_union(cl_narg narg, cl_object list1, cl_object list2) nunion cl_object cl_nunion(cl_narg narg, cl_object list1, cl_object list2)
ecl-16.1.2/doc/ref_c_data_flow.xml000066400000000000000000000541741266352375300167600ustar00rootroot00000000000000 %eclent; ]> Data and control flow
C Reference ecl_bds_bind Bind a special variable Functions ecl_bds_bind cl_env_ptr cl_env cl_object var cl_object value ecl_bds_push cl_env_ptr cl_env cl_object var Description Establishes a variable binding for the symbol var in the Common Lisp environment env, assigning it value. This macro or function is the equivalent of LET* and LET. ecl_bds_push does a similar thing, but reuses the old value of the same variable. It is thus the equivalent of (LET ((VAR VAR)) ...) Every variable binding must undone when no longer needed. It is best practice to match each call to ecl_bds_bind by another call to ecl_bds_unwind in the same function. ecl_bds_unwind Undo one variable binding Function ecl_bds_unwind1 cl_env_ptr cl_env ecl_bds_unwind_n cl_env_ptr cl_env int n Description ecl_bds_unwind1 undoes the outermost variable binding, restoring the original value of the symbol in the process. ecl_bds_unwind_n does the same, but for the n last variables. Every variable binding must undone when no longer needed. It is best practice to match each call to ecl_bds_bind by another call to ecl_bds_unwind in the same function. ecl_setq C equivalent of setq Macro ecl_setq cl_env_ptr cl_env cl_object var cl_object value Description Assigns value to the special variable denoted by the symbol var, in the Common Lisp environment cl_env. This function implements a variable assignment, not a variable binding. It is thus the equivalent of setq. ecl_symbol_value C equivalent of symbol-value Funciton ecl_symbol_value cl_env_ptr cl_env cl_object var Description Retrieves the value of the special variable or constant denoted by the symbol var, in the Common Lisp environment cl_env. This function implements the equivalent of symbol-value and works both on special variables and constants. If the symbol is not bound, an error is signaled. ecl_va_arg Accepting a variable number of arguments Macros typedef struct { ... } ecl_va_list[1]; ecl_va_start ecl_va_list arglist last_argument narg n_ordinary cl_object ecl_va_arg ecl_va_list arglist cl_object ecl_va_end ecl_va_list arglist Description The macros above are used to code a function that accepts an arbitrary number of arguments. We will describe them in a practical example cl_object my_plus(cl_narg narg, cl_object required1, ...) { cl_env_ptr env = ecl_process_env(); cl_object other_value; ecl_va_list varargs; ecl_va_start(varargs, required1, narg, 1); while (narg > 1) { cl_object other_value = ecl_va_arg(varargs); required1 = ecl_plus(required1, other_value); } ecl_va_end(varargs); ecl_return1(env, required1); } The first thing to do is to declare the variable that will hold the arguments. This is varargs in our example and it has the type ecl_va_list. This arguments list is initialized with the ecl_va_start macro, based on the supplied number of arguments, narg, the number of required arguments which are passed as ordinary C arguments (1 in this case), the last such ordinary arguments, required, and the buffer for the argument list, varargs. Once varargs has been initialized, we can retrieve these values one by one using ecl_va_arg. Note that the returned value always has the type cl_object, for it is always a Common Lisp object. The last statement before returning the output of the function is ecl_va_end. This macro performs any required cleanup and should never be omitted. ecl_nth_value, ecl_nvalues Accessing output values Functions and macros cl_object ecl_nvalues cl_env_ptr env cl_object ecl_nth_value cl_env_ptr env int n Description Common Lisp functions may return zero, one or more values. In &ECL;, the first two cases do not require any special manipulation, as the C function returns either NIL or the first (zeroth) value directly. However, if one wishes to access additional values from a function, one needs to use these two macros or functions ecl_nvalues(env) returns the number of values that the function actually outputs. The single argument is the lisp environment. This value is larger or equal to 0 and smaller than ECL_MULTIPLE_VALUES_LIMIT. Once we know the number of return values, they can be directly accessed using the function ecl_nth_value(env,n), where n is a number larger than or equal to 1, and smaller than ECL_MULTIPLE_VALUES_LIMIT, which must correspond to a valid output value. No checking is done. Note that in both cases these macros and functions have to be used right after the Lisp function was called. This is so because other Lisp functions might destroy the content of the return stack. Example A C/C++ exceprt cl_env_ptr env = ecl_process_env(); cl_object a = ecl_make_fixnum(13); cl_object b = ecl_make_fixnum(6); cl_object modulus = cl_floor(2, a, b); cl_object remainder = ecl_nth_value(env, 1); The somewhat equivalent Common Lisp code (multiple-value-bind (modulus equivalent) (floor 13 6)) ecl_return0, ecl_return1, ... Returning multiple values ecl_return0 cl_env_ptr cl_env ecl_return1 cl_env_ptr cl_env cl_object value1 ecl_return2 cl_env_ptr cl_env cl_object value1 cl_object value2 ecl_return3 cl_env_ptr cl_env cl_object value1 cl_object value2 cl_object value3 Description Returns N values from a C/C++ function in a way that a Common Lisp function can recognize and use them. The 0-th value is returned directly, while values 1 to N are stored in the Common Lisp environment cl_env. This macro has to be used from a function which returns an object of type cl_object. ECL_BLOCK_BEGIN C macro for block ECL_BLOCK_BEGIN(env,code) { } ECL_BLOCK_END; Description ECL_BLOCK_BEGIN establishes a block named code that becomes visible for the Common Lisp code. This block can be used then as a target for cl_return. env must be the value of the current Common Lisp environment, obtained with ecl_process_env. The C/C++ program has to ensure that the code in ECL_BLOCK_END gets executed, avoiding a direct exit of the block via goto or a C/C++ return. ECL_CATCH_BEGIN C macro for catch ECL_CATCH_BEGIN(env,tag) { } ECL_CATCH_END; Description ECL_CATCH_BEGIN establishes a destination for throw with the code given by tag. env must be the value of the current Common Lisp environment, obtained with ecl_process_env. The C/C++ program has to ensure that the code in ECL_CATCH_END gets executed, avoiding a direct exit of the catch block via goto or a C/C++ return. ECL_UNWIND_PROTECT_BEGIN C macro for unwind-protect ECL_UNWIND_PROTECT_BEGIN(env) { } ECL_UNWIND_PROTECT_EXIT { } ECL_UNWIND_PROTECT_END; Description ECL_UNWIND_PROTECT_BEGIN establishes two blocks of C code that work like the equivalent ones in Common Lisp: a protected block, contained between the "BEGIN" and the "EXIT" statement, and the exit block, appearing immediately afterwards. The form guarantees that the exit block is always executed, even if the protected block attempts to exit via som nonlocal jump construct (throw,return, etc). env must be the value of the current Common Lisp environment, obtained with ecl_process_env. The utility of this construct is limited, for it only protects against nonlocal exits caused by Common Lisp constructs: it does not interfere with C goto, return or with C++ exceptions. ANSI Dictionary &ANSI-C-Dict; Lisp symbol C function or constant apply cl_object cl_apply(cl_narg narg, cl_object function, ...) call-arguments-limit ECL_CALL_ARGUMENTS_LIMIT compiled-function-p cl_object cl_compiled_function_p(cl_object object) complement cl_object cl_complement(cl_object function) constantly cl_object cl_constantly(cl_object value) every cl_object cl_every(cl_narg narg, cl_object predicate, ...) eq cl_object cl_eq(cl_object x, cl_object y) eql cl_object cl_eql(cl_object x, cl_object y) equal cl_object cl_equal(cl_object x, cl_object y) equalp cl_object cl_equalp(cl_object x, cl_object y) fboundp cl_object cl_fboundp(cl_object function_name) fdefinition cl_object cl_fdefinition(cl_object function_name) fmakunbound cl_object cl_fmakunbound(cl_object function_name) funcall cl_object cl_funcall(cl_narg narg, cl_object function, ...) function-lambda-expression cl_object cl_function_lambda_expression(cl_object function) functionp cl_object cl_functionp(cl_object object) get-setf-expansion cl_object cl_get_setf_expansion(cl_narg narg, cl_object place, ...) identity cl_object cl_identity(cl_object x) LET, LET* cl_object ecl_bds_bind(cl_env_ptr env, cl_object symbol, cl_object value) lambda-parameters-limit ECL_LAMBDA_PARAMETERS_LIMIT multiple-values-limit ECL_MULTIPLE_VALUES_LIMIT not cl_object cl_not(cl_object object) notevery cl_object cl_notevery(cl_narg narg, cl_object predicate, ...) notany cl_object cl_notany(cl_narg narg, cl_object predicate, ...) set cl_object cl_set(cl_object symbol, cl_object value) setq cl_object ecl_setq(cl_env_ptr env, cl_object symbol, cl_object value) symbol-value cl_object ecl_symbol_value(cl_env_ptr env, cl_object symbol) some cl_object cl_some(cl_narg narg, cl_object predicate, ...) values-list cl_object cl_values_list(cl_object list) Description
ecl-16.1.2/doc/ref_c_environment.xml000066400000000000000000000116711266352375300173570ustar00rootroot00000000000000 %eclent; ]> Environment
C Reference ANSI Dictionary &ANSI-C-Dict; Lisp symbol C function decode-universal-time cl_object cl_decode_universal_time(cl_narg narg, cl_object universal_time, ...) encode-universal-time cl_object cl_encode_universal_time(cl_narg narg, cl_object second, cl_object minute, cl_object hour, cl_object date, cl_object month, cl_object year, ...) get-universal-time cl_object cl_get_universal_time(void) get-decoded-time cl_object cl_get_decoded_time(void) sleep cl_object cl_sleep(cl_object seconds) apropos cl_object cl_apropos(cl_narg narg, cl_object string, ...) apropos-list cl_object cl_apropos_list(cl_narg narg, cl_object string, ...) describe cl_object cl_describe(cl_narg narg, cl_object object, ...) describe-object &OCL; get-internal-real-time cl_object cl_get_internal_real_time() get-internal-run-time cl_object cl_get_internal_run_time() disassemble &OCL; documentation &OCL; room cl_object cl_room(cl_narg narg, ...) ed cl_object cl_ed(cl_narg narg, ...) inspect cl_object cl_inspect(cl_object object) dribble cl_object cl_dribble(cl_narg narg, ...) lisp-implementation-type cl_object cl_lisp_implementation_type(void) lisp-implementation-version cl_object cl_lisp_implementation_version(void) short-site-name cl_object cl_short_site_name() long-site-name cl_object cl_long_site_name() machine-instance cl_object cl_machine_instance() machine-type cl_object cl_machine_type() machine-version cl_object cl_machine_version() software-type cl_object cl_software_type() software-version cl_object cl_software_version() user-homedir-pathname cl_object cl_user_homedir_pathname() Description
ecl-16.1.2/doc/ref_c_evaluation.xml000066400000000000000000000057251266352375300171650ustar00rootroot00000000000000 %eclent; ]> Evaluation and compilation
C Reference ecl_process_env Per-thread environment Function cl_env_ptr ecl_process_env Description &ECL; stores information about each thread on a dedicated structure, which is the process environment. A pointer to this structure can be retrieved using the function or macro above. This pointer can be used for a variety of tasks, such as defining special variable bindings, controlling interrupts, retrieving function output values, etc. ANSI Dictionary &ANSI-C-Dict; Lisp symbol C function compile &OCL; eval cl_object cl_eval(cl_object form) compiler-macro-function &OCL; macro-function cl_object cl_macro_function(cl_narg narg, cl_object symbol, ...) macroexpand cl_object cl_macroexpand(cl_narg narg, cl_object form, ...) macroexpand-1 cl_object cl_macroexpand_1(cl_narg narg, cl_object form, ...) proclaim &OCL; special-operator-p cl_object cl_special_operator_p(cl_object form) constantp cl_object cl_constantp(cl_narg narg, cl_object form, ...) Description
ecl-16.1.2/doc/ref_c_filenames.xml000066400000000000000000000113611266352375300167520ustar00rootroot00000000000000 %eclent; ]> Filenames
C Reference Filenames C dictionary &ANSI-C-Dict; Lisp symbol C function directory-namestring cl_object cl_directory_namestring(cl_object pathname) enough-namestring cl_object cl_enough_namestring(cl_narg narg, cl_object pathname, ...) file-namestring cl_object cl_file_namestring(cl_object pathname) host-namestring cl_object cl_host_namestring(cl_object pathname) load-logical-pathname-translations cl_object cl_load_logical_pathname_translations(cl_object host) logical-pathname-translations cl_object cl_logical_pathname_translations(cl_object host) logical-pathname cl_object cl_logical_pathname(cl_object pathspec) make-pathname cl_object cl_make_pathname(cl_narg narg, ...) merge-pathnames cl_object cl_merge_pathnames(cl_narg narg, cl_object pathname,...) namestring cl_object cl_namestring(cl_object pathname) parse-namestring cl_object cl_parse_namestring(cl_narg narg, cl_object thing, ...) pathname cl_object cl_pathname(cl_object pathspec) pathname-device cl_object cl_pathname_device(cl_narg narg, cl_object pathname, ...) pathname-directory cl_object cl_pathname_directory(cl_narg narg, cl_object pathname, ...) pathname-host cl_object cl_pathname_host(cl_narg narg, cl_object pathname, ...) pathname-match-p cl_object cl_pathname_match_p(cl_object pathname, cl_object wildcard) pathname-name cl_object cl_pathname_name(cl_narg narg, cl_object pathname, ...) pathname-type cl_object cl_pathname_type(cl_narg narg, cl_object pathname, ...) pathname-version cl_object cl_pathname_version(cl_object pathname) pathnamep cl_object cl_pathnamep(cl_object object) translate-logical-pathname cl_object cl_translate_logical_pathname(cl_narg narg, cl_object pathname, ...) translate-pathname cl_object cl_translate_pathname(cl_narg narg, cl_object source, cl_object from_wildcard, cl_object to_wildcard, ...) wild-pathname-p cl_object cl_wild_pathname_p(cl_narg narg, cl_object pathname, ...)
ecl-16.1.2/doc/ref_c_files.xml000066400000000000000000000040711266352375300161110ustar00rootroot00000000000000 %eclent; ]> Files
C Reference Files C dictionary &ANSI-C-Dict; Lisp symbol C function delete-file cl_object cl_delete_file(cl_object filespec) directory cl_object cl_directory(cl_narg narg, cl_object pathspec, ...) ensure-directories-exist cl_object cl_ensure_directories_exist(cl_narg narg, cl_object pathspec, ...) file-author cl_object cl_file_author(cl_object pathspec) file-error-pathname &OCL; file-write-date cl_object cl_file_write_date(cl_object pathspec) probe-file cl_object cl_probe_file(cl_object pathspec) rename-file cl_object cl_rename_file(cl_object filespec, cl_object new_name) truename cl_object cl_truename(cl_object filespec)
ecl-16.1.2/doc/ref_c_hash_tables.xml000066400000000000000000000053441266352375300172700ustar00rootroot00000000000000 %eclent; ]> Hash Tables
C Reference Hash tables C dictionary &ANSI-C-Dict; Lisp symbol C function clrhash cl_object cl_clrhash(cl_object hash_table) gethash cl_object cl_gethash(cl_narg narg, cl_object key, cl_object hash_table, ...) hash-table-count cl_object cl_hash_table_count(cl_object hash_table) hash-table-p cl_object cl_hash_table_p(cl_object hash_table) hash-table-rehash-size cl_object cl_hash_table_rehash_size(cl_object hash_table) hash-table-rehash-threshold cl_object cl_hash_table_rehash_thresholdy(cl_object hash_table) hash-table-size cl_object cl_hash_table_size(cl_object hash_table) hash-table-test cl_object cl_hash_table_test(cl_object hash_table) make-hash-table cl_object cl_make_hash_table(cl_narg narg, ...) maphash cl_object cl_maphash(cl_object function, cl_object hash_table) remhash cl_object cl_remhash(cl_object key, cl_object hash_table) sxhash cl_object cl_sxhash(cl_object object) Description
ecl-16.1.2/doc/ref_c_numbers.xml000066400000000000000000001120651266352375300164650ustar00rootroot00000000000000 %eclent; ]> Numbers
C Reference Number C types Numeric C types understood by ECL Type names cl_fixnum fixnum cl_index (integer 0 most-positive-fixnum) float short-float, single-float double double-float long double (*) long-float ECL_LONG_FLOAT :long-float uint8_t (unsigned-byte 8) int8_t (signed-byte 8) uint16_t (unsigned-byte 16) ecl_uint16_t :uint16-t int16_t (signed-byte 16) ecl_int16_t :uint16-t uint32_t (unsigned-byte 32) ecl_uint32_t :uint32-t int32_t (signed-byte 32) ecl_int32_t :uint32-t uint64_t (unsigned-byte 64) ecl_uint32_t :uint32-t int64_t (signed-byte 64) ecl_int64_t :uint32-t short (integer ffi:c-short-min ffi:c-short-max) ecl_uint64_t :uint32-t unsigned short (integer 0 ffi:c-ushort-max) int (integer ffi:c-int-min ffi:c-int-max) unsigned int (integer 0 ffi:c-uint-max) long (integer ffi:c-long-min ffi:c-long-max) unsigned long (integer 0 ffi:c-long-max) long long (integer ffi:c-long-long-min ffi:c-long-long-max) ecl_long_long_t :long-long unsigned long long (integer 0 ffi:c-ulong-long-max) ecl_ulong_long_t :long-long Description The table above shows the relation between C types and the equivalent Common Lisp types. All types are standard C99 types, except for two. First, cl_fixnum is the smallest signed integer that can fit a fixnum. Second, cl_index is the smallest unsigned integer that fits a fixnum and is typically the unsigned counterpart of cl_fixnum. (*) The long double does not exist on all platforms. When it exists, the macro ECL_LONG_DOUBLE will be defined, and long-double will be equivalent to it. Many other types might also not exist on all platforms. This includes not only long long and unsigned long long, but also some of the C99 integer types. There are two ways to detect which integer types are available in your system Check for the definition of C macros with a similar name, shown in the fourth column above. In Lisp code, check for the presence of the associated features, shown in the fifth column above. Number constructors Creating Lisp types from C numbers Functions and macros cl_object ecl_make_fixnum cl_fixnum n cl_object ecl_make_integer cl_fixnum n cl_object ecl_make_unsigned_integer cl_index n cl_object ecl_make_single_float float n cl_object ecl_make_double_float double n cl_object ecl_make_long_float long double n cl_object ecl_make_uint8_t uint8_t n cl_object ecl_make_int8_t int8_t n cl_object ecl_make_uint16_t uint16_t n cl_object ecl_make_int16_t int16_t n cl_object ecl_make_uint32_t uint32_t n cl_object ecl_make_int32_t int32_t n cl_object ecl_make_uint64_t uint64_t n cl_object ecl_make_int64_t int64_t n cl_object ecl_make_short short n cl_object ecl_make_ushort unsigned short n cl_object ecl_make_int int n cl_object ecl_make_uint unsigned int n cl_object ecl_make_long long n cl_object ecl_make_ulong unsigned long n cl_object ecl_make_long_long long long n cl_object ecl_make_ulong_long unsigned long long n cl_object ecl_make_ratio cl_object numerator cl_object denominator cl_object ecl_make_complex cl_object real cl_object imag Description These functions create a Lisp object from the corresponding C number. If the number is an integer type, the result will always be an integer, which may be a bignum. If on the other hand the C number is a float, double or long double, the result will be a float. There is some redundancy in the list of functions that convert from cl_fixnum and cl_index to lisp. On the one hand, ecl_make_fixnum() always creates a fixnum, dropping bits if necessary. On the other hand, ecl_make_integer and ecl_make_unsigned_integer faithfully converts to a Lisp integer, which may a bignum. Note also that some of the constructors do not use C numbers. This is the case of ecl_make_ratio and ecl_make_complex, because they are composite Lisp types. These functions or macros signal no errors. Number accessors Unchecked conversion from Lisp types to C numbers Functions and macros cl_fixnum ecl_fixnum cl_object n float ecl_single_float cl_object n double ecl_double_float cl_object n long double ecl_long_float cl_object n Description These functions and macros extract a C number from a Lisp object. They do not check the type of the Lisp object as they typically just access directly the value from a C structure. Number coercion Checked conversion from Lisp types to C numbers Functions and macros cl_fixnum ecl_to_fixnum cl_object n cl_index ecl_to_unsigned_integer cl_object n flaot ecl_to_float cl_object n double ecl_to_double cl_object n long double ecl_to_long_double cl_object n float ecl_to_float cl_object n int8_t ecl_to_uint8_t cl_object n int8_t ecl_to_int8_t cl_object n uint16_t ecl_to_uint16_t cl_object n int16_t ecl_to_int16_t cl_object n uint32_t ecl_to_uint32_t cl_object n int32_t ecl_to_int32_t cl_object n uint64_t ecl_to_uint64_t cl_object n int64_t ecl_to_int64_t cl_object n short ecl_to_short cl_object n unsigned short ecl_to_ushort cl_object n int ecl_to_int cl_object n unsigned int ecl_to_uint cl_object n long ecl_to_long cl_object n unsigned long ecl_to_ulong cl_object n long long ecl_to_long_long cl_object n unsigned long long ecl_to_ulong_long cl_object n Description These functions and macros convert a Lisp object to the corresponding C number type. The conversion is done through a coercion process which may signal an error if the argument does not fit the expected type. Numbers C dictionary &ANSI-C-Dict; Lisp symbol C function = cl_object cl_E() /= cl_object cl_NE() < cl_object cl_L() > cl_object cl_G() <= cl_object cl_LE() >= cl_object cl_GE() max cl_object cl_max(cl_narg narg, ...) min cl_object cl_min(cl_narg narg, ...) minusp cl_object cl_minusp(cl_object real) plusp cl_object cl_plusp(cl_object real) zerop cl_object cl_zerop(cl_object number) floor cl_object cl_floor(cl_narg narg, cl_object number, ...) ffloor cl_object cl_ffloor(cl_narg narg, cl_object number, ...) ceiling cl_object cl_ceiling(cl_narg narg, cl_object number, ...) fceiling cl_object cl_fceiling(cl_narg narg, cl_object number, ...) truncate cl_object cl_truncate(cl_narg narg, cl_object number, ...) ftruncate cl_object cl_ftruncate(cl_narg narg, cl_object number, ...) round cl_object cl_round(cl_narg narg, cl_object number, ...) fround cl_object cl_fround(cl_narg narg, cl_object number, ...) sin cl_object cl_sin(cl_object radians) cos cl_object cl_cos(cl_object radians) tan cl_object cl_tan(cl_object radians) asin cl_object cl_asin(cl_object number) acos cl_object cl_acos(cl_object number) atan cl_object cl_atan(cl_narg narg, cl_object number1, ...) sinh cl_object cl_sinh(cl_object number) cosh cl_object cl_cosh(cl_object number) tanh cl_object cl_tanh(cl_object number) asinh cl_object cl_asinh(cl_object number) cosh cl_object cl_acosh(cl_object number) atanh cl_object cl_atanh(cl_object number) * cl_object cl_X(cl_narg narg, ...) + cl_object cl_P(cl_narg narg, ...) - cl_object cl_M(cl_narg narg, cl_object number, ...) / cl_object cl_N(cl_narg narg, cl_object number, ...) 1+ cl_object cl_1P() 1- cl_object cl_1M() abs cl_object cl_abs(cl_object number) evenp cl_object cl_evenp(cl_object integer) oddp cl_object cl_oddp(cl_object integer) exp cl_object cl_exp(cl_object number) expt cl_object cl_expt(cl_object base, cl_object power) gcd cl_object cl_gcd(cl_narg narg, ...) lcm cl_object cl_lcm(cl_narg narg, ...) log cl_object cl_log(cl_narg narg, cl_object number, ...) mod cl_object cl_mod(cl_object number, cl_object divisor) rem cl_object cl_rem(cl_object number, cl_object divisor) signum cl_object cl_signum(cl_object number) sqrt cl_object cl_sqrt(cl_object number) isqrt cl_object cl_isqrt(cl_object natural) make-random-state cl_object cl_make_random_state(cl_narg narg, ...) random cl_object cl_random(cl_narg narg, cl_object limit, ...) random-state-p cl_object cl_random_state_p(cl_object object) numberp cl_object cl_numberp(cl_object object) cis cl_object cl_cis(cl_object radians) complex cl_object cl_complex(cl_narg narg, cl_object realpart, ...) complexp cl_object cl_complexp(cl_object object) conjugate cl_object cl_conjugate(cl_object number) phase cl_object cl_phase(cl_object number) realpart cl_object cl_realpart(cl_object number) imagpart cl_object cl_imagpart(cl_object number) upgraded-complex-part-type cl_object cl_upgraded_complex_part_type(cl_narg narg, cl_object typespec, ...) realp cl_object cl_realp(cl_object object) numerator cl_object cl_numerator(cl_object rational) denominator cl_object cl_denominator(cl_object rational) rational cl_object cl_rational(cl_object number) rationalize cl_object cl_rationalize(cl_object number) rationalp cl_object cl_rationalp(cl_object object) ash cl_object cl_ash(cl_object integer, cl_object count) integer-length cl_object cl_integer_length(cl_object integer) integerp cl_object cl_integerp(cl_object object) parse-integer cl_object cl_parse_integer(cl_narg narg, cl_object string, ...) boole cl_object cl_boole(cl_object op, cl_object integer1, cl_object integer2) logand cl_object cl_logand(cl_narg narg, ...) logandc1 cl_object cl_logandc1(cl_object integer1, cl_object integer2) logandc2 cl_object cl_logandc2(cl_object integer1, cl_object integer2) logeqv cl_object cl_logeqv(cl_narg narg, ...) logior cl_object cl_logior(cl_narg narg, ...) lognand cl_object cl_lognand(cl_object integer1, cl_object integer2) lognor cl_object cl_lognor(cl_object integer1, cl_object integer2) lognot cl_object cl_lognot(cl_object integer) logorc1 cl_object cl_logorc1(cl_object integer1, cl_object integer2) logorc2 cl_object cl_logorc2(cl_object integer1, cl_object integer2) logxor cl_object cl_logxor(cl_narg narg, ...) logbitp cl_object cl_logbitp(cl_object index, cl_object integer) logcount cl_object cl_logcount(cl_object integer) logtest cl_object cl_logtest(cl_object integer1, cl_object integer2) byte cl_object cl_byte(cl_object size, cl_object position) bytes-size cl_object cl_byte_size(cl_object bytespec) byte-position cl_object cl_byte_position(cl_object bytespec) deposit-field cl_object cl_deposit_field(cl_object newbyte, cl_object bytespec, cl_object integer) dpb cl_object cl_dpb(cl_object newbyte, cl_object bytespec, cl_object integer) ldb cl_object cl_ldb(cl_object bytespec, cl_object integer) ldb-test cl_object cl_ldb_test(cl_object bytespec, cl_object integer) mask-field cl_object cl_mask_field(cl_object bytespec, cl_object integer) decode-float cl_object cl_decode_float(cl_object float) scale-float cl_object cl_scale_float(cl_object float, cl_object integer) float-radix cl_object cl_float_radix(cl_object float) float-sign cl_object cl_float_sign(cl_narg narg, cl_object float1, ...) float-digits cl_object cl_float_digits(cl_object float) float-precision cl_object cl_float_precision(cl_object float) integer-decode-float cl_object cl_integer_decode_float(cl_object float) float cl_object cl_float(cl_narg narg, cl_object number) floatp cl_object cl_floatp(cl_object object) arithmetic-error-operands &OCL; arithmetic-error-operation &OCL;
ecl-16.1.2/doc/ref_c_objects.xml000066400000000000000000000120571266352375300164430ustar00rootroot00000000000000 %eclent; ]> Objects
C Reference ANSI Dictionary &ANSI-C-Dict; Lisp symbol C function function-keywords &OCL; ensure-generic-function cl_object cl_ensure_generic_function(cl_narg narg, cl_object function_name, ...) allocate-instance &OCL; reinitialize-instance &OCL; shared-initialize &OCL; update-instance-for-different-class &OCL; update-instance-for-redefined-class &OCL; change-class &OCL; slot-boundp cl_object cl_slot_boundp(cl_object instance, cl_object slot_name) slot-exists-p cl_object cl_slot_exists_p(cl_object instance, cl_object slot_name) slot-makunbound cl_object cl_slot_makunbound(cl_object instance, cl_object slot_name) slot-missing &OCL; slot-unbound &OCL; slot-value cl_object cl_slot_value(cl_object instance, cl_object slot_name) method-qualifiers &OCL; no-applicable-method &OCL; no-next-method &OCL; remove-method &OCL; make-instance &OCL; make-instances-obsolete &OCL; make-load-form &OCL; make-load-form-saving-slots cl_object cl_make_load_form_saving_slots(cl_narg narg, cl_object object, ...) find-class cl_object cl_find_class(cl_narg narg, cl_object symbol, ...) compute-applicable-methods &OCL; find-method &OCL; add-method &OCL; initialize-instance &OCL; class-name &OCL; (setf class-name) &OCL; class-of cl_object cl_class_of(cl_object object) unbound-slot-instance &OCL; Description
ecl-16.1.2/doc/ref_c_packages.xml000066400000000000000000000114671266352375300165740ustar00rootroot00000000000000 %eclent; ]> Packages
C Reference ANSI Dictionary &ANSI-C-Dict; Lisp symbol C function export cl_object cl_export(cl_narg narg, cl_object symbols_list, ...) find-symbol cl_object cl_find_symbol(cl_narg narg, cl_object string, ...) find-package cl_object cl_find_package(cl_object string) find-all-symbols cl_object cl_find_all_symbols(cl_object string) import cl_object cl_import(cl_narg narg, cl_object symbols) list-all-packages cl_object cl_list_all_packages(void) rename-package cl_object cl_rename_package(cl_narg narg, cl_object package, cl_object new_name, ...) shadow cl_object cl_shadow(cl_narg narg, cl_object symbol_names) shadowing-import cl_object cl_shadowing_import(cl_narg narg, cl_object symbols, ...) delete-package cl_object cl_delete_package(cl_object package_designator) make-package cl_object cl_make_package(cl_narg narg, cl_object package_name, ...) unexport cl_object cl_unexport(cl_narg narg, cl_object symbols_list, ...) unintern cl_object cl_unintern(cl_narg narg, cl_object symbol, ...) in-package cl_object si_select_package(cl_narg narg, cl_object name) unuse-package cl_object cl_unuse_package(cl_narg narg, cl_object packages_list) use-package cl_object cl_use_package(cl_narg narg, cl_object packages_list) intern cl_object cl_intern(cl_narg narg, cl_object string, ...) package-name cl_object cl_package_name(cl_object package_designator) package-nicknames cl_object cl_package_nicknames(cl_object package_designator) package-shadowing-symbols cl_object cl_package_shadowing_symbols(cl_object package_designator) package-use-list cl_object cl_package_use_list(cl_object package_designator) package-used-by-list cl_object cl_package_used_by_list(cl_object package_designator) packagep cl_object cl_packagep(cl_object object) package-error-package [Only in Common Lisp] Description
ecl-16.1.2/doc/ref_c_printer.xml000066400000000000000000000102371266352375300164730ustar00rootroot00000000000000 %eclent; ]> Printer
C Reference ANSI Dictionary &ANSI-C-Dict; Lisp symbol C function copy-pprint-dispatch cl_object cl_copy_pprint_dispatch(cl_narg narg, ...) pprint-dispatch cl_object cl_pprint_dispatch(cl_narg narg, cl_object object, ...) pprint-fill cl_object cl_pprint_fill(cl_narg narg, cl_object stream, cl_object object, ...) pprint-linear cl_object cl_pprint_linear(cl_narg narg, cl_object stream, cl_object object, ...) pprint-tabular cl_object cl_pprint_tabular(cl_narg narg, cl_object stream, cl_object object, ...) pprint-indent cl_object cl_pprint_indent(cl_narg narg, cl_object relative_to, cl_object n, ...) pprint-newline cl_object cl_pprint_newline(cl_narg narg, cl_object kind, ...) pprint-tab cl_object cl_pprint_tab(cl_narg narg, cl_object kind, cl_object colnum, cl_object colinc, ...) print-object &OCL; set-pprint-dispatch cl_object cl_set_pprint_dispatch(cl_narg narg, cl_object ype_spec, cl_object function, ...) write cl_object cl_write(cl_narg narg, cl_object object, ...) prin1 cl_object cl_prin1(cl_narg narg, cl_object object, ...) princ cl_object cl_princ(cl_narg narg, cl_object object, ...) print cl_object cl_print(cl_narg narg, cl_object object, ...) pprint cl_object cl_pprint(cl_narg narg, cl_object object, ...) write-to-string cl_object cl_write_to_string(cl_narg narg, cl_object object, ...) prin1-to-string cl_object cl_prin1_to_string(cl_object object) princ-to-string cl_object cl_princ_to_string(cl_object object) print-not-readable-object &OCL; format cl_object cl_format(cl_narg narg, cl_object string, ...) Description
ecl-16.1.2/doc/ref_c_reader.xml000066400000000000000000000062361266352375300162560ustar00rootroot00000000000000 %eclent; ]> Reader
C Reference ANSI Dictionary &ANSI-C-Dict; Lisp symbol C function copy-readtable cl_object cl_copy_readtable(cl_narg narg, ...) make-dispatch-macro-character cl_object cl_make_dispatch_macro_character(cl_narg narg, cl_object char, ...) read cl_object cl_read(cl_narg narg, ...) read-preerving-whitespace cl_object cl_read_preserving_whitespace(cl_narg narg, ...) read-delimited-list cl_object cl_read_delimited_list(cl_narg narg, cl_object char, ...) read-from-string cl_object cl_read_from_string(cl_narg narg, cl_object string, ...) readtable-case cl_object cl_readtable_case(cl_object readtable) readtablep cl_object cl_readtablep(cl_object object) get-dispatch-macro-character cl_object cl_get_dispatch_macro_character(cl_narg narg, cl_object disp_char, cl_object sub_char, ...) set-dispatch-macro-character cl_object cl_set_dispatch_macro_character(cl_narg narg, cl_object disp_char, cl_object sub_char, cl_object function, ...) get-macro-character cl_object cl_get_macro_character(cl_narg narg, cl_object char, ...) set-macro-character cl_object cl_set_macro_character(cl_narg narg, cl_object char, cl_object function, ...) set-syntax-from-char cl_object cl_set_syntax_from_char(cl_narg narg, cl_object to_char, cl_object from_char, ...) Description
ecl-16.1.2/doc/ref_c_sequences.xml000066400000000000000000000204071266352375300170030ustar00rootroot00000000000000 %eclent; ]> Conses
C Reference Sequences C dictionary &ANSI-C-Dict; Lisp symbol C function concatenate cl_object cl_concatenate(cl_narg narg, cl_object result_type, ...) copy-seq cl_object cl_copy_seq(cl_object sequence) count cl_object cl_count(cl_narg narg, cl_object item, cl_object sequence, ...) count-if cl_object cl_count_if(cl_narg narg, cl_object predicate, cl_object sequence, ...) count-if-not cl_object cl_count_if_not(cl_narg narg, cl_object predicate, cl_object sequence, ...) delete cl_object cl_delete(cl_narg narg, cl_object newitem, cl_object sequence, ...) delete-if cl_object cl_delete_if(cl_narg narg, cl_object newitem, cl_object test, cl_object sequence, ...) delete-if-not cl_object cl_delete_if_not(cl_narg narg, cl_object newitem, cl_object test, cl_object sequence, ...) delete-duplicates cl_object cl_delete_duplicates(cl_narg narg, cl_object sequence) elt cl_object cl_elt(cl_object sequence, cl_object index) fill cl_object cl_fill(cl_narg narg, cl_object sequence, cl_object item, ...) find cl_object cl_find(cl_narg narg, cl_object item, cl_object sequence, ...) find-if cl_object cl_find_if(cl_narg narg, cl_object predicate, cl_object sequence, ...) find-if-not cl_object cl_find_if_not(cl_narg narg, cl_object predicate, cl_object sequence, ...) make-sequence cl_object cl_make_sequence(cl_narg narg, cl_object result_type, cl_object size, ...) map cl_object cl_map(cl_narg narg, cl_object result_type, cl_object function) map-into cl_object cl_map_into(cl_narg narg, cl_object result_sequence, cl_object function, ...) merge cl_object cl_merge(cl_narg narg, cl_object result_type, cl_object sequence1, cl_object sequence2, ...) mismatch cl_object cl_mismatch(cl_narg narg, cl_object sequence1, cl_object sequence2) nreverse cl_object cl_nreverse(cl_object sequence) nsubstitute cl_object cl_nsubstitute(cl_narg narg, cl_object newitem, cl_object olditem, cl_object sequence, ...) nsubstitute-if cl_object cl_nsubstitute_if(cl_narg narg, cl_object newitem, cl_object predicate, cl_object sequence, ...) nsubstitute-if-not cl_object cl_nsubstitute_if_not(cl_narg narg, cl_object newitem, cl_object predicate, cl_object sequence, ...) position cl_object cl_position(cl_narg narg, cl_object item, cl_object sequence, ...) position-if cl_object cl_pos_pif(cl_narg narg, cl_object predicate, cl_object sequence, ...) position-if-not cl_object cl_pos_pif_not(cl_narg narg, cl_object predicate, cl_object sequence, ...) reduce cl_object cl_reduce(cl_narg narg, cl_object function, cl_object sequence, ...) remove cl_object cl_remove(cl_narg narg, cl_object newitem, cl_object sequence, ...) remove-if cl_object cl_remove_if(cl_narg narg, cl_object newitem, cl_object test, cl_object sequence, ...) remove-if-not cl_object cl_remove_if_not(cl_narg narg, cl_object newitem, cl_object test, cl_object sequence, ...) remove-duplicates cl_object cl_remove_duplicates(cl_narg narg, cl_object sequence) replace cl_object cl_replace(cl_narg narg, cl_object sequence1, cl_object sequence2) reverse cl_object cl_reverse(cl_object sequence) search cl_object cl_search(cl_narg narg, cl_object sequence1, cl_object sequence2) sort cl_object cl_sort(cl_narg narg, cl_object sequence, cl_object predicate, ...) stable-sort cl_object cl_stable_sort(cl_narg narg, cl_object sequence, cl_object predicate, ...) subseq cl_object cl_subseq(cl_narg narg, cl_object sequence, cl_object start) substitute cl_object cl_substitute(cl_narg narg, cl_object newitem, cl_object olditem, cl_object sequence, ...) substitute-if cl_object cl_substitute_if(cl_narg narg, cl_object newitem, cl_object predicate, cl_object sequence, ...) substitute-if-not cl_object cl_substitute_if_not(cl_narg narg, cl_object newitem, cl_object predicate, cl_object sequence, ...)
ecl-16.1.2/doc/ref_c_streams.xml000066400000000000000000000221261266352375300164660ustar00rootroot00000000000000 %eclent; ]> Streams
C Reference Streams C dictionary &ANSI-C-Dict; Lisp symbol C function broadcast-stream-streams cl_object cl_broadcast_stream_streams(cl_object broadcast_stream) clear-input cl_object cl_clear_input(cl_narg narg, ...) clear-output cl_object cl_clear_outputt(cl_narg narg, ...) close cl_object cl_close(cl_narg narg, cl_object stream, ...) concatenated-stream-streams cl_object cl_concatenated_stream_streams(cl_object concatenated_stream) echo-stream-input-stream cl_object cl_echo_stream_input_stream(cl_object echo_stream) echo-stream-output-stream cl_object cl_echo_stream_output_stream(cl_object echo_stream) file-length cl_object cl_file_length(cl_object stream) file-position cl_object cl_file_position(cl_object stream) file-string-length cl_object cl_file_string_length(cl_object stream, cl_object object) finish-output cl_object cl_finish_outputt(cl_narg narg, ...) force-output cl_object cl_force_outputt(cl_narg narg, ...) fresh-line cl_object cl_fresh_line(cl_narg narg, ...) get-output-stream-string cl_object cl_get_output_stream_string(cl_object string_output_stream) input-stream-p cl_object cl_input_stream_p(cl_object stream) interactive-stream-p cl_object cl_interactive_stream_p(cl_object stream) listen cl_object cl_listen(cl_narg narg, cl_object stream, ...) make-broadcast-stream cl_object cl_make_broadcast_stream(cl_narg narg, ...) make-concatenated-stream cl_object cl_make_concatenated_stream(cl_narg narg, ....) make-echo-stream cl_object cl_make_echo_stream(cl_object input, cl_object output) make-string-input-stream cl_object cl_make_string_input_stream(cl_narg narg, cl_object string, ...) make-string-output-stream cl_object cl_make_string_output_stream(cl_narg narg, ...) make-two-way-stream cl_object cl_make_two_way_stream(cl_object input, cl_object output) make-synonym-stream cl_object cl_make_synonym_stream(cl_object symbol) open cl_object cl_open(cl_narg narg, cl_object filespec, ...) open-stream-p cl_object cl_open_stream_p(cl_object stream) output-stream-p cl_object cl_output_stream_p(cl_object stream) peek-char cl_object cl_peek_char(cl_narg narg, ...) read-byte cl_object cl_read_byte(cl_narg narg, cl_object stream, ...) read-char cl_object cl_read_char(cl_narg narg, ...) read-char-no-hang cl_object cl_read_char_no_hang(cl_narg narg, ...) read-line cl_object cl_read_line(cl_narg narg, ...) read-sequence cl_object cl_read_sequence(cl_narg narg, cl_object sequence, cl_object stream) stream-element-type cl_object cl_stream_element_type(cl_object stream) stream-error-stream &OCL; stream-external-format cl_object cl_stream_external_format(cl_object stream) streamp cl_object cl_streamp(cl_object object) synonym-stream-symbol cl_object cl_synonym_stream_symbol(cl_object synonym_stream) terpri cl_object cl_terpri(cl_narg narg, ...) two-way-stream-input-stream cl_object cl_two_way_stream_input_stream(cl_object two_way_stream) two-way-stream-output-stream cl_object cl_two_way_stream_output_stream(cl_object two_way_stream) unread-char cl_object cl_unread_char(cl_narg narg, cl_object character, ...) write-byte cl_object cl_write_byte(cl_object byte, cl_object stream) write-char cl_object cl_write_char(cl_narg narg, cl_object character, ...) write-line cl_object cl_write_line(cl_narg narg, cl_object string) write-string cl_object cl_write_string(cl_narg narg, cl_object string) write-sequence cl_object cl_write_sequence(cl_narg narg, cl_object sequence, cl_object stream) y-or-n-p cl_object cl_y_or_n_p(cl_narg narg, ...) yes-or-no-p cl_object cl_yes_or_no_p(cl_narg narg, ...) Description
ecl-16.1.2/doc/ref_c_strings.xml000066400000000000000000000244671266352375300165130ustar00rootroot00000000000000 %eclent; ]> Strings and compilation
C Reference Base string constructors Building strings for C data Function cl_object ecl_alloc_adjustable_base_string cl_index length cl_object ecl_alloc_adjustable_simple_string cl_index length cl_object ecl_make_simple_base_string ecl_base_char* data cl_index length cl_object ecl_make_constant_base_string ecl_base_char* data cl_index length Description These are different ways to create a base string, which is a string that holds a small subset of characters, the base-char, with codes ranging from 0 to 255. ecl_alloc_simple_base_string creates an empty string with that much space for characters and a fixed lenght. The string does not have a fill pointer and cannot be resized, and the initial data is unspecified ecl_alloc_adjustable_base_string is similar to the previous function, but creates an adjustable string with a fill pointer. This means that the lenght of the string can be changed and the string itself can be resized to accomodate more data. The other constructors create strings but use some preexisting data. ecl_make_simple_base_string creates a string copying the data that the user supplies, and using freshly allocated memory. ecl_make_constant_base_string on the other hand, does not allocate memory, but simply uses the supplied pointer as buffer for the string. This last function should be used with care, ensuring that the supplied buffer is not deallocated. String accessors Reading and writing characters into a string Function ecl_character ecl_char cl_object string cl_index ndx ecl_character ecl_char_set cl_object string cl_index ndx ecl_character c Description Access to string information should be done using these two functions. The first one implements the equivalent of the CHAR function from Common Lisp, returning the character that is at position ndx in the string s. The counterpart of the previous function is ecl_char_set, which implements (SETF CHAR) and stores character c at the position ndx in the given string. Both functions check the type of their arguments and verify that the indices do not exceed the string boundaries. Otherwise they signal a serious-condition. Strings C dictionary &ANSI-C-Dict; Lisp symbol C function simple-string-p cl_object cl_simple_string_p(cl_object string) char cl_object cl_char(cl_object string, cl_object index) schar cl_object cl_schar(cl_object string, cl_object index) string cl_object cl_string(cl_object x) string-upcase cl_object cl_string_upcase(cl_narg narg, cl_obejct string, ...) string-downcase cl_object cl_string_downcase(cl_narg narg, cl_obejct string, ...) string-capitalize cl_object cl_string_capitalize(cl_narg narg, cl_obejct string, ...) nstring-upcase cl_object cl_nstring_upcase(cl_narg narg, cl_obejct string, ...) nstring-downcase cl_object cl_nstring_downcase(cl_narg narg, cl_obejct string, ...) nstring-capitalize cl_object cl_nstring_capitalize(cl_narg narg, cl_obejct string, ...) string-trim cl_object cl_string_trim(cl_object character_bag, cl_object string) string-left-trim cl_object cl_string_left_trim(cl_object character_bag, cl_object string) string-right-trim cl_object cl_string_right_trim(cl_object character_bag, cl_object string) string cl_object cl_string(cl_narg narg, cl_object string1, cl_object string2, ...) string= cl_object cl_stringE(cl_narg narg, cl_object string1, cl_object string2, ...) string/= cl_object cl_stringNE(cl_narg narg, cl_object string1, cl_object string2, ...) string< cl_object cl_stringL(cl_narg narg, cl_object string1, cl_object string2, ...) string> cl_object cl_stringG(cl_narg narg, cl_object string1, cl_object string2, ...) string<= cl_object cl_stringLE(cl_narg narg, cl_object string1, cl_object string2, ...) string>= cl_object cl_stringGE(cl_narg narg, cl_object string1, cl_object string2, ...) string-equal cl_object cl_string_equal(cl_narg narg, cl_object string1, cl_object string2, ...) string-not-equal cl_object cl_string_not_equal(cl_narg narg, cl_object string1, cl_object string2, ...) string-lessp cl_object cl_string_lessp(cl_narg narg, cl_object string1, cl_object string2, ...) string-greaterp cl_object cl_string_greaterp(cl_narg narg, cl_object string1, cl_object string2, ...) string-not-greaterp cl_object cl_string_not_greaterp(cl_narg narg, cl_object string1, cl_object string2, ...) string-not-lessp cl_object cl_string_not_lessp(cl_narg narg, cl_object string1, cl_object string2, ...) stringp cl_object cl_stringp(cl_object x) make-string cl_object cl_make_string(cl_narg narg, cl_object size, ...)
ecl-16.1.2/doc/ref_c_structures.xml000066400000000000000000000015431266352375300172330ustar00rootroot00000000000000 %eclent; ]> Structures
C Reference ANSI Dictionary &ANSI-C-Dict; Lisp symbol C function copy-structure cl_object cl_copy_structure(cl_object structure) Description
ecl-16.1.2/doc/ref_c_symbols.xml000066400000000000000000000140661266352375300165040ustar00rootroot00000000000000 %eclent; ]> Symbols and compilation
C Reference ecl_make_keyword Find a lisp keyword Function cl_object ecl_make_keyword char * name Description Many Lisp functions take keyword arguments. When invoking a function with keyword arguments we need keywords, which are a kind of symbols that live in the KEYWORD package. This function does the task of finding or creating those keywords from C strings. It is usually safe to store the resulting pointer, because keywords are always referenced by their package and will not be garbage collected (unless of course, you decide to delete it). Remember that the case of the string is significant. ecl_make_keyword("TO") with return :TO, while ecl_make_keyword("to") returns a completely different keywod, :|to|. In short, you usually want to use uppercase. Example The following example converts a section of a string to uppercase characters: cl_object start = ecl_make_keyword("START"); cl_object end = ecl_make_keyword("END"); ... sup = cl_string_upcase(4, s, start, ecl_make_fixnum(2), end, ecl_make_fixnum(6)); ... ecl_make_symbol Find a lisp symbol Function cl_object ecl_make_symbol const char * name const char * package_name Description This function finds or create a symbol in the given package. First of all, it tries to find the package named by package_name. If it does not exist, an error is signaled. Then, a symbol with the suppled name is searched in the given package. If the symbol exists, it is returned. If it does not exist, using INTERN. ANSI Dictionary &ANSI-C-Dict; Lisp symbol C function boundp cl_object cl_boundp(cl_object symbolp) copy-symbol cl_object cl_copy_symbol(cl_narg narg, cl_object symbol, ...) get cl_object cl_get(cl_object symbol, cl_object indicator) gensym cl_object cl_gensym(cl_narg narg, ...) gentemp cl_object cl_gentemp(cl_narg narg, ...) keywordp cl_object cl_keywordp(cl_object object) make-symbol cl_object cl_make_symbol(cl_object name) makunbound cl_object cl_makunbound(cl_object makunbound) remprop cl_object cl_remprop(cl_object symbol, cl_object indicator) set cl_object cl_set(cl_object symbol, cl_object value) symbolp cl_object cl_symbolp(cl_object object) symbol-function cl_object cl_symbol_function(cl_object symbol) symbol-name cl_object cl_symbol_name(cl_object symbol) symbol-package cl_object cl_symbol_package(cl_object symbol) symbol-plist cl_object cl_symbol_plist(cl_object symbol) symbol-value cl_object cl_symbol_value(cl_object symbol) Description
ecl-16.1.2/doc/ref_c_system_construction.xml000066400000000000000000000026311266352375300211450ustar00rootroot00000000000000 %eclent; ]> System Construction
C Reference ANSI Dictionary &ANSI-C-Dict; Lisp symbol C function compile-file &OCL; compile-file-pathname &OCL; load cl_object cl_load() provide cl_object cl_provide(cl_object module_name) require cl_object cl_require(cl_narg narg, cl_object module_name, ...) Description
ecl-16.1.2/doc/ref_c_types_and_classes.xml000066400000000000000000000030731266352375300205130ustar00rootroot00000000000000 %eclent; ]> Types and classes
C Reference ANSI Dictionary &ANSI-C-Dict; Lisp symbol C function coerce cl_object cl_coerce(cl_object object, cl_object result_type) subtypep cl_object cl_subtypep(cl_narg narg, cl_object type1, cl_object type2, ...) type-of cl_object cl_type_of(cl_object object) typep cl_object cl_typep(cl_narg narg, cl_object object, cl_object type_specifier, ...) type-error-datum &OCL; type-error-expected-type &OCL;
ecl-16.1.2/doc/ref_embed.xmlf000066400000000000000000000441611266352375300157330ustar00rootroot00000000000000 %eclent; ]> Embedding
Embedding Reference CL_CATCH_ALL Create a protected region. C Macro cl_env_ptr env = ecl_process_env(); CL_CATCH_ALL_BEGIN(env) { /* * Code that is protected. Uncaught lisp conditions, THROW, * signals such as SIGSEGV and SIGBUS may cause jump to * this region. */ } CL_CATCH_ALL_IF_CAUGHT { /* * If the exception, lisp condition or other control transfer * is caught, this code is executed. */ } CL_CATCH_ALL_END /* * In all cases we exit here. */ Description This is a set of three macros that create an UNWIND-PROTECT region that prevents any nonlocal transfer of control to outer loops. In the Lisp speak, the previous code is equivalent to (block nil (unwind-protect (progn ;; Code that is protected ) (return nil))) As explained in ,it is normally advisable to set up an unwind-protect frame to avoid the embedded lisp code to perform arbitary transfers of control. See also cl_unwind_protect CL_UNWIND_PROTECT Create a protected region. C Macro cl_env_ptr env = ecl_process_env(); CL_UNWIND_PROTECT_BEGIN(env) { /* * Code that is protected. Uncaught lisp conditions, THROW, * signals such as SIGSEGV and SIGBUS may cause jump to * this region. */ } CL_UNWIND_PROTECT_EXIT { /* * If the exception, lisp condition or other control transfer * is caught, this code is executed. After this code, the * process will jump to the original destination of the * THROW, GOTO or other control statement that was interrupted. */ } CL_UNWIND_PROTECT_END /* * We only exit here if NO nonlocal jump was interrupted. */ Description When embedding &ECL; it is normally advisable to set up an unwind-protect frame to avoid the embedded lisp code to perform arbitary transfers of control. Furthermore, the unwind protect form will be used in at least in the following ocasions: In a normal program exit, caused by ext:quit, &ECL; unwinds up to the outermost frame, which may be an or macro. Besides this, normal mechanisms for exit, such as ext:quit, and uncaught exceptions, such as serious signals (), are best handled using unwind-protect blocks. See also cl_boot Setup the lisp environment. Function int cl_boot int argc char **argv argc An integer with the number of arguments to this program. argv A vector of strings with the arguments to this program. Description This function must be called before any other function from the &ECL; library, including the creation of any lisp object or evaluating any lisp code. The only exception are and . cl_shutdown Close the lisp environment. Function int cl_shutdown void Description This function must be called before exiting a program that uses the &ECL; environment. It performs some cleaning, including the execution of any finalizers, unloading shared libraries and deleting temporary files that were created by the compiler. ecl_set_option Set a boot option. Function void ecl_set_option int option cl_fixnum value option An integer from . value A cl_index value for this option. Description This functions sets the value of different options that have to be customized before &ECL; boots. The table of options and default values [] shows that some of them are boolean, and some of them are unsigned integers. We distinguish three sets of values. The first set determines whether &ECL; handles certain exceptions, such as access to forbidden regions of memory, interrupts via Ctrl-C, floating point exceptions, etc. The second set is related to the sizes of different stacks. Currently &ECL; uses four stacks: a bind stack for keeping assignments to special variables; a frame stack for implementing blocks, tagbodys and catch points; an interpreter stack for evaluating bytecodes, and finally the machine or C stack, of the computer we run in. We can set the expected size of these stacks, together with the size of a safety area which, if penetrated, will lead to the generation of a correctable error. Boot options for embedded &ECL; Name (ECL_OPT_*) Type Default Description INCREMENTAL_GC boolean TRUE Activate generational garbage collector. TRAP_SIGSEGV boolean TRUE Capture SIGSEGV signals. TRAP_SIGFPE boolean TRUE Capture floating point exceptions. TRAP_SIGINT boolean TRUE Capture user interrupts. TRAP_SIGILL boolean TRUE Capture SIGILL exception. TRAP_INTERRUPT_SIGNAL boolean TRUE Capture the signal that implements mp:interrupt-process. SIGNAL_HANDLING_THREAD boolean TRUE Create a signal to capture and process asynchronous threads (See ). BOOTED boolean TRUE/FALSE Has &ECL; booted (read only). BIND_STACK_SIZE cl_index 8192 Size of stack for binding special variables. BIND_STACK_SAFETY_AREA cl_index 128 FRAME_STACK_SIZE cl_index 2048 Size of stack for nonlocal jumps. FRAME_STACK_SAFETY_AREA cl_index 128 LISP_STACK_SIZE cl_index 32768 Size of interpreter stack. LISP_STACK_SAFETY_AREA cl_index 128 C_STACK_SIZE cl_index 131072 Size of C stack (not exact). C_STACK_SAFETY_AREA cl_index 4192 SIGALTSTACK_SIZE cl_index 1 If nonzero, run C signal handler in an alternative signal. A small value is automatically incremented. THREAD_INTERRUPT_SIGNAL unsigned int 0 If nonzero, specify the unix signal which is used to communicate different Lisp threads.
ecl_get_option Read the value of a boot option. Function cl_fixnum ecl_get_option int option option An integer from . Description This functions reads the value of different options that have to be customized before &ECL; boots. The table of options and default values is . ecl_clear_interrupts Clear all pending signals and exceptions. Macro ecl_clear_interrupts Description This macro clears all pending interrupts. See also and . ecl_disable_interrupts Postpone handling of signals and exceptions. Macro ecl_disable_interrupts Description This macro sets a thread-local flag indicating that all received signals should be queued for later processing. See also and . ecl_enable_interrupts Activate handling of signals and exceptions. Macro ecl_enable_interrupts Description This macro sets a thread-local flag indicating that all received signals can be handled. If there are any pending signals, they will be immediately processed. See also and .
ecl-16.1.2/doc/ref_memory.xmlf000066400000000000000000000266471266352375300162000ustar00rootroot00000000000000 %eclent; ]> Memory Management
Memory Management Reference ext:stack-overflow Stack overflow condition. Class Precedence List ext:stack-overflow, storage-condition, serious-condition, condition, t Methods ext:stack-overflow-size condition integer ext:stack-overflow-type condition concept integer A non-negative integer. concept A symbol from , except ext:heap-size. Description This condition is signaled when one of the stack limits in are violated or dangerously approached. It can be handled by resetting the limits and continuing, or jumping to an outer control point. ext:storage-exhausted Memory overflow condition. Class Precedence List ext:storage-exhausted, storage-condition, serious-condition, condition, t Description This condition is signaled when &ECL; exhausts the ext:heap-size limit from . In handling this condition &ECL; follows this logic If the heap size limit was set to 0 (that is no limit), but there is some free space in the safety region &ECL; frees this space and issues a non-restartable error. The user may jump to an outer point or quit. If the heap size had a finite limit, &ECL; offers the user the chance to resize it, issuing a restartable condition. The user may at this point use (ext:set-limit 'ext:heap-size 0) to remove the heap limit and avoid further messages, or use the (continue) restart to let &ECL; enlarge the heap by some amount. Independently of the heap size limit, if &ECL; finds that ther is no space to free or to grow, &ECL; simply quits. There will be no chance to do some cleanup because there is no way to cons any additional data. ext:get-finalizer Return finalizer associated to an object. Function ext:get-finalizer object object Any lisp object. Description This function returns the finalizer associated to an object, or &nil;. ext:get-limit Query a memory or stack limit. Function ext:get-limit concept concept A symbol. Description Queries the different memory and stack limits that condition &ECL;'s behavior. The value to be queried is denoted by the symbol concept, which should be one from the list ext:set-finalizer Associate a finalizer to an object. Function ext:set-finalizer object function object Any lisp object. function A function or closure that takes one argument or &nil;. Description If function is &nil; no finalizer is associated to the object. Otherwise function must be a function or a closure of one argument, which will be invoked before the object is destroyed. Example Close a file associated to an object. (defclass my-class () ((file :initarg :file :initform nil))) (defun finalize-my-class (x) (let ((s (slot-value x 'file))) (when s (format t "~%;;; Closing" s) (close s)))) (defmethod initialize-instance :around ((my-instance my-class) &rest args) (ext:set-finalizer my-instance #'finalize-my-class) (call-next-method)) (progn (make-instance 'my-class :file (open "~/.ecl.old" :direction :input)) nil) (si::gc t) (si::gc t) ;; Closing ext:set-limit Set a memory or stack limit. Function ext:set-limit concept value concept A symbol. function A positive integer. Description Changes the different memory and stack limits that condition &ECL;'s behavior. The value to be changed is denoted by the symbol concept, while the value is the new maximum size. The valid symbols and units are listed in . Note that the limit has to be positive, but it may be smaller than the previous value of the limit. However, if the supplied value is smaller than what &ECL; is using at the moment, the new value will be silently ignored. Customizable memory limits Concept Units Default Command line ext:frame-stack Nested frames 2048 --frame-stack ext:binding-stack Bindings 8192 ext:c-stack Bytes 128 kilobytes --c-stack ext:heap-size Bytes 256 megabytes --heap-size ext:lisp-stack Bytes 32 kilobytes --lisp-stack
ecl-16.1.2/doc/ref_mp.xmlf000066400000000000000000000510711266352375300152710ustar00rootroot00000000000000 %eclent; ]> Multithreading
Multithreading Reference mp:all-processes Return the list of active processes. Function mp:all-processes Description Returns the list of processes associated to running tasks. The list is a fresh new one and can be destructively modified. However, it may happen that the output list is not up to date, because some of the tasks has expired before this copy is returned. mp:exit-process Exit the task from which it is invoked. Function mp:exit-process Description When called from a running task, this function immediately causes the task to finish. When invoked from the main thread, it is equivalent to invoking with exit code 0. Example See . mp:interrupt-process Interrupt a task. Function mp:interrupt-process process function process An object of type mp:process. function A function, which is to be executed in the interrupted process. Description This function sends a signal to a running task. When the task is free to process that signal, it will stop whatever it is doing and execute the given function. Example Kill a task that is doing nothing (See ). (flet ((task-to-be-killed () (loop (sleep 1)) ; Infinite loop )) (let ((task (mp:process-run-function 'background #'task-to-be-killed))) (sleep 10) (mp:interrupt-process task 'mp:exit-process))) mp:get-lock Try to obtain a lock. Function mp:get-lock lock &optional; wait lock An object of type mp:lock. wait Whether to wait to obtain the lock. Defaults to &nil;. Description This function tries to obtain exclusive use of a lock. If wait is &t;, and another task owns the lock, it may wait until the lock has been released. If wait is &nil; it will return true if and only if it succeeded on acquiring the lock. Example See . mp:giveup-lock Release a lock we have obtained before. Function mp:giveup-lock lock lock An object of type mp:lock. Description This function releases a lock which had been previously obtained using . Example See . mp:make-lock Create a new lock. Function mp:make-lock &key; name name A symbol to name the lock. Names not be unique. It defaults to &nil;. Description This function creates a lock object that can be use to synchronize different tasks. The own is initally free and not owned by any task. Locks are typically implemented using Posix mutexes. When garbage collected, a lock is automatically freed. Example See . mp:make-process Create a new thread. Function mp:make-process &key; name initial-bindings name A symbol to name the process. Processes can be unnamed and names need not be unique. initial-bindings The list of special variables which will be local to the new process. It defaults to &t;, which means copying all variables which are local to this process. Description This function creates a separate task, with a name, set of variable bindings and no function to run. See also . Example See mp:process-active-p Determine whether a task is running. Function mp:process-active-p process process An object of type mp:process. Description Returns true if the task is currently running. mp:process-enable Start up a task which was not running. Function mp:process-enable process process An object of type mp:process. Description The argument to this function should be a process created by , which has a function associated as per but which is not yet running. After invoking this function a new thread will be created in which the associated function will be executed. Example The following is a possible implementation of . (defun process-run-function (process-name process-function &rest args) (let ((process (mp:make-process name))) (apply #'mp:process-preset process function args) (mp:process-enable process))) mp:process-kill Try to stop a running task. Function mp:process-kill process process An object of type mp:process. Description This function tries to stop a running task. Killing a process may fail if the task has disabled interrupts. Example Kill a task that is doing nothing. (flet ((task-to-be-killed () (loop (sleep 1)) ; Infinite loop )) (let ((task (mp:process-run-function 'background #'task-to-be-killed))) (sleep 10) (mp:process-kill task))) mp:process-name Return the name of a task. Function mp:process-active-p process process An object of type mp:process. Description Returns the name of the given task, if any. mp:process-preset Associate a function to a process. Function mp:process-preset process function &rest; function-args process An object of type mp:process. function An interpret or compiled function. function-args One or more arguments for the function above. Description This function associates a function to a stopped task. This function will be the entry point when the task is enabled in the future. See also . Example See . mp:process-run-function Create a task and execute a function in it. Function mp:process-run-function name function &rest; function-args name A symbol to name the process. Processes can be unnamed and names need not be unique. function A function object, interpreted or compiled. function-args One or more arguments which will be passed to the function. Description This function creates a new process using , associates a function to it and then starts it using . Example As an example, the following code starts a background task that outputs a list of numbers, one every second: (flet ((count-numbers (end-number) (dotimes (i end-number) (format t "~%;;; Counting: ~i" i) (terpri) (sleep 1)))) (mp:process-run-function 'counter #'count-numbers 10)) mp:with-lock Synchronize a piece of code between different tasks. Macro mp::with-lock (lock) &body; body Description It grabs a lock, executes a piece of lisp code and releases the lock at the end. The inner forms are protected so that when any condition is signalled the lock is released. Example Ensure each task increments the counter properly. The lock is required because INCF is not an atomic operation. (defvar *counter* 0) (defvar *counter-lock* (mp:make-lock :name 'counter)) (flet ((task (name) (loop while (<= *counter* 10) do (progn (sleep 1) (with-lock (*counter-lock*) (format t "~%;;; ~A counts ~D" name *counter*) (terpri) (incf *counter*)))))) (mp:process-run-function 'ana #'task 'ana) (mp:process-run-function 'jose #'task 'jose))
ecl-16.1.2/doc/ref_os.xmlf000066400000000000000000000602411266352375300152750ustar00rootroot00000000000000 %eclent; ]> OS Reference ext:*help-message* Command line help message Variable Type A string Initial value &ECL; help message Description This variable contains the help message which is output when &ECL; is invoked with the . Example See . ext:*lisp-init-file-list* &ECL; initialization files. Constant Type A list of pathname designators. Initial value '("~/.ecl" "~/.eclrc") Description This variable contains the names of initialization files that are loaded by &ECL; or embedding programs. The loading of initialization files happens automatically in &ECL; unless invoked with the option . Whether initialization files are loaded or not is controlled by the command line options rules, as described in . Example See . ext:+default-command-arg-rules+ &ECL; command line options Constant Type A list of lists. Description This constant contains a list of rules for parsing the command line arguments. This list is made of all the options which &ECL; accepts by default. It can be passed as first argument to , and you can use it as a starting point to extend &ECL;. Example See . ext:command-args Original list of command line arguments. Function ext:command-args returns A list of strings. Description This function returns the list of command line arguments passed to either &ECL; or the program it was embedded in. The output is a list of strings and it corresponds to the argv vector in a C program. Typically, the first argument is the name of the program as it was invoked. You should not count on ths filename to be resolved. ext:process-command-args Process command line arguments. Function ext:process-command-args &key; args rules args A list of strings. Defaults to the output of rules A list of lists. Defaults to the value of Description This function processes the command line arguments passed to either &ECL; or the program that embeds it. It uses the list of rules rules, which has the following syntax: (option-name nargs template [:stop | :noloadrc | :loadrc]*) option-name A string with the option prefix as typed by the user. For instance , , , etc. nargs A nonnegative integer denoting the number of arguments taken by this option. template A lisp form, not evaluated, where numbers from 0 to nargs will be replaced by the corresponding option argument. :STOP If present, parsing of arguments stops after this option is found and processed. The list of remaining arguments is passed to the rule. &ECL;'s top-level uses this option with the -- command line option to set ext:*unprocessed-ecl-command-args* to the list of remaining arguments. :NOLOADRC and :LOADRC Determine whether the lisp initalization file () will be loaded before processing all forms. EXT:PROCESS-COMMAND-ARGS works as follows. First of all, it parses all the command line arguments, except for the first one, which is assumed to contain the program name. Each of these arguments is matched against the rules, sequentially, until one of the patterns succeeeds. A special name "*DEFAULT*", matches any unknown command line option. If there is no "*DEFAULT*" rule and no match is found, an error is signalled. For each rule that succeeds, the function constructs a lisp statement using the template. After all arguments have been processed, EXT:PROCESS-COMMAND-ARGS, and there were no occurences of :NOLOADRC, one of the files listed in will be loaded. Finally, the list of lisp statements will be evaluated. Example The following piece of code implements the ls command using lisp.Instructions for building this program are found under ecl/examples/cmdline/ls.lsp (setq ext:*help-message* " ls [--help | -?] filename* Lists the file that match the given patterns. ") (defun print-directory (pathnames) (format t "~{~A~%~}" (mapcar #'(lambda (x) (enough-namestring x (si::getcwd))) (mapcan #'directory (or pathnames '("*.*" "*/")))))) (defconstant +ls-rules+ '(("--help" 0 (progn (princ ext:*help-message* *standard-output*) (ext:quit 0))) ("-?" 0 (progn (princ ext:*help-message* *standard-output*) (ext:quit 0))) ("*DEFAULT*" 1 (print-directory 1) :stop))) (let ((ext:*lisp-init-file-list* NIL)) ; No initialization files (handler-case (ext:process-command-args :rules +ls-rules+) (error (c) (princ ext:*help-message* *error-output*) (ext:quit 1)))) (ext:quit 0) ext:quit Exit &ECL;. Function ext:quit &optional; exit-code exit-code An integer between 0 and 255 Description This function abruptly stops the execution of the program in which &ECL; is embedded. Depending on the platform, several other functions will be invoked to free resources, close loaded modules, etc. The exit code is the code seen by the parent process that invoked this program. Normally a code other than zero denotes an error. ext:external-process Holds process state. Structure ext:external-process PID process pid INPUT process input stream OUTPUT process output stream ERROR-STREAM process error stream %STATUS either :RUNNING, :STOPPED, :SIGNALED, :EXITED, :ERROR or :ABORT %CODE exit code or nil (if still running) Description This structure is responsible for holding external process state - process id, communication streams, runtime status and exit code. It is returned as third value of . ext:external-process-status Check status of . Function ext:external-process-status external-process Description Checks status of external-process. Returns it's current status, and if exited - EXIT-CODE as second value. ext:run-program Start and communicate with a child process. Function ext:run-program command argv &key; input output error wait environ if-input-does-exist if-output-exists if-error-exists external-format input One of :STREAM, T, NIL, string or pathname - defaults to :STREAM output One of :STREAM, T, NIL, string or pathname - defaults to :STREAM error One of :OUTPUT, :STREAM, T, NIL, string or pathname - defaults to :OUTPUT wait Boolean indicating if process should run synchronously, defaults to T environ List of strings containing environment bindings. Defaults to NIL (inheritance of lisp process environment). if-input-does-not-exist If :INPUT is pathname this symbol value is provided as :IF-DOES-NOT-EXIST for CL_OPEN. Defaults to NIL if-output-exists If :OUTPUT is pathname this symbol value is provided as :IF-EXISTS for CL_OPEN. Defaults to :ERROR if-error-exists If :ERROR is pathname this symbol value is provided as :IF-EXISTS for CL_OPEN. Defaults to :ERROR external-format External format used for both streams and pathnames. Defaults to :DEFAULT returns Two-way stream responsible for input/output with created process (created of :OUTPUT and :INPUT), Return code of spawned process. If process still runs then NIL structure holding process state. Description This function creates a external process by launching the program command with the arguments from the list argv. The arguments input, output and error are used to intercept the standard input, output and error streams of the program. A value of :STREAM means a lisp stream will be created to communicate with the child process. A value of NIL means that the data from this pipe will be discarded. The value of T means that the child process will use the parent's standard input, output or error channels. If value is pathname, then corresponding file will be used (strings are coerced to pathnames). For instance, if &ECL; writes to the console and you pass a value of output equal to T, the child process will also output to the console. Finally, the error messages of the child process are redirected to the same pipe as its standard output when error takes the value :OUTPUT. If the child process was succesfully launched, this function outputs a lisp stream to which we one may write, read or do both things, depending on the arguments input and output. If an error happened during the preparation of the child process (for instance the program was not found), this function returns NIL. Function returns three values - two-way stream for communication, return-code or nil depending if process is called asynchronously, and structure holding process state. The design of this function is inspired by the function of same name in &CMUCL; and &SBCL;. Example List all users in a Unix system. We use the sed command to parse the file with the list of users, removing comments and information other than the user names: (defun all-users (&optional (file "/etc/passwd")) (let ((s (ext:run-program "sed" (list "-e" "/^#.*$/d;/^[^:]*$/d;s,^\\([^:]*\\).*$,\\1,g" file) :input NIL :output :STREAM :error NIL))) (unless s (error "Unable to parse password file")) (loop for x = (read s NIL NIL) while x collect x))) Make a directory. Redirect standard error output to the same as the output: (ext:run-program "mkdir" '("./tmp") :output :STREAM :error :OUTPUT) Same as before, but now both the output and the standard error are discarded (ext:run-program "mkdir" '("./tmp") :output NIL :error :OUTPUT) Limitations All streams passed to ext:run-program has to have underlying file handler. That means, that if gray streams are passed to function - it might signal an error. Such situation occurs, when for instance :OUTPUT value is T and *standard-output* is bound to gray stream (default if using slime and emacs). ext:system Invoke a command using the shell. Function ext:system command command A string returns An integer (0-255) with the exit code of the program Description This function executes a command in the shell. In Unix systems, typically the environment variable SHELL determines which program will be invoked, while in Windows CMD.EXE is used. The string may thus be any valid command that the shell accepts and in can contain higher level elements such as input/output redirection. Output isn't printed. As an example, the following function uses an external editor to modify a lisp file and, if successful, loads the changed sources: (defun edit (filename) (let* ((editor #+windows "notepad.exe" #-windows "/usr/bin/emacs") (command (concatenate 'string editor " " filename))) (when (zerop (ext:system command)) (load filename)))) ecl-16.1.2/doc/ref_signals.xmlf000066400000000000000000000117411266352375300163150ustar00rootroot00000000000000 %eclent; ]> Signals
Signals Reference ext:with-interrupts Execute code with interrupts optionally enabled. Macro ext:with-interrupts &body; body Description Executes the given body with all interrupts enabled. Since interrupts are normally enabled, this macro only makes sense if there is an outer ext:without-interrupts with a corresponding ext:allow-with-interrupts: interrupts are not enabled if any outer mp:without-interrupts is not accompanied by mp:allow-with-interrupts. ext:without-interrupts Execute code without being interrupted. Macro ext:without-interrupts &body; body Description Executes the given body with all interrupts disabled. This macro is compatible with the one in &SBCL; and as such it also defines three other local macros ext:allow-with-interrupts, ext:with-local-interrupts and ext:with-restored-interrupts. Deferrable interrupts include most blockable POSIX signals, and mp:interrupt-process. Does not interfere with garbage collection, and does not inhibit scheduling of other threads. This macro binds allow-with-interrupts, with-local-interrupts and with-restored-interrupts as a local macros. ext:with-restored-interrupts executes the body with interrupts enabled if and only if the ext:without-interrupts was in an environment in which interrupts were allowed. ext:allow-with-interrupts allows the ext:with-interrupts to take effect during the dynamic scope of its body, unless there is an outer ext:without-interrupts without a corresponding ext:allow-with-interrupts. ext:with-local-interrupts executes its body with interrupts enabled provided that for there is an ext:allow-with-interrupts for every ext:without-interrupts surrounding the current one. ext:with-local-interrupts is equivalent to: (allow-with-interrupts (with-interrupts ...)) Care must be taken not to let either ext:allow-with-interrupts or ext:with-local-interrupts appear in a function that escapes from inside the ext:without-interrupts in: (without-interrupts ;; The body of the lambda would be executed with WITH-INTERRUPTS allowed ;; regardless of the interrupt policy in effect when it is called. (lambda () (allow-with-interrupts ...))) (without-interrupts ;; The body of the lambda would be executed with interrupts enabled ;; regardless of the interrupt policy in effect when it is called. (lambda () (with-local-interrupts ...)))
ecl-16.1.2/doc/schemas.xml000066400000000000000000000043341266352375300152760ustar00rootroot00000000000000 ecl-16.1.2/doc/signals.xmlf000066400000000000000000000316721266352375300154660ustar00rootroot00000000000000 %eclent; ]> Signals and interrupts
Problems associated to signals POSIX contemplates the notion of "signals", which are events that cause a process or a thread to be interrupted. Windows uses the term "exception", which includes also a more general kind of errors. In both cases the consequence is that a thread or process may be interrupted at any time, either by causes which are intrinsic to them (synchronous signals), such as floating point exceptions, or extrinsic (asynchronous signals), such as the process being aborted by the user. Of course, those interruptions are not always welcome. When the interrupt is delivered and a handler is invoked, the thread or even the whole program may be in an inconsistent state. For instance the thread may have acquired a lock, or it may be in the process of filling the fields of a structure. Furthermore, sometimes the signal that a process receives may not even be related to it, as in the case when a user presses Cltr-C and a SIGINT signal is delivered to an arbitrary thread, or when the process receives the Windows exception CTRL_CLOSE_EVENT denoting that the terminal window is being closed. Understanding this, POSIX restricts severely what functions can be called from a signal handler, thereby limiting its usefulness. However, Common Lisp users expect to be able to handle floating point exceptions and to gracefully manage user interrupts, program exits, etc. In an attempt to solve this seemingly impossible problem, &ECL; has taken a pragmatic approach that works, it is rather safe, but involves some work on the &ECL; maintainers and also on users that want to embed &ECL; as a library.
Kinds of signals
Synchronous signals The name derives from POSIX and it denotes interrupts that occur due to the code that a particular thread executes. They are largely equivalent to C++ and Java exceptions, and in Windows they are called "unchecked exceptions." Common Lisp programs may generate mostly three kinds of synchronous signals: Floating point exceptions, that result from overflows in computations, division by zero, and so on. Access violations, such as dereferencing NULL pointers, writing into regions of memory that are protected, etc. Process interrupts. The first family of signals are generated by the floating point processing hardware in the computer, and they typically happen when code is compiled with low security settings, performing mathematical operations without checks. The second family of signals may seem rare, but unfortunately they still happen quite often. One scenario is wrong code that handles memory directly via FFI. Another one is undetected stack overflows, which typically result in access to protected memory regions. Finally, a very common cause of these kind of exceptions is invoking a function that has been compiled with very low security settings with arguments that are not of the expected type -- for instance, passing a float when a structure is expected. The third family is related to the multiprocessing capabilities in Common Lisp systems and more precisely to the function which is used to kill, interrupt and inspect arbitrary threads. In POSIX systems &ECL; informs a given thread about the need to interrupt its execution by sending a particular signal from the set which is available to the user. Note that in neither of these cases we should let the signal pass unnoticed. Access violations and floating point exceptions may propagate through the program causing more harm than expected, and without process interrupts we will not be able to stop and cancel different threads. The only question that remains, though, is whether such signals can be handled by the thread in which they were generated and how.
Asynchronous signals In addition to the set of synchronous signals or "exceptions", we have a set of signals that denote "events", things that happen while the program is being executed, and "requests". Some typical examples are: Request for program termination (SIGKILL, SIGTERM). Indication that a child process has finished. Request for program interruption (SIGINT), typically as a consecuence of pressing a key combination, Ctrl-C. The important difference with synchronous signals is that we have no thread that causes the interrupt and thus there is no preferred way of handling them. Moreover, the operating system will typically dispatch these signals to an arbitrary thread, unless we set up mechanisms to prevent it. This can have nasty consequences if the incoming signal interrupt a system call, or leaves the interrupted thread in an inconsistent state.
Signals and interrupts in &ECL; The signal handling facilities in &ECL; are constrained by two needs. First of all, we can not ignore the synchronous signals mentioned in . Second, all other signals should cause the least harm to the running threads. Third, when a signal is handled synchronously using a signal handler, the handler should do almost nothing unless we are completely sure that we are in an interruptible region, that is outside system calls, in code that &ECL; knows and controls. The way in which this is solved is based on the existence of both synchronous and asynchronous signal handling code, as explained in the following two sections.
Handling of asynchronous signals In systems in which this is possible, &ECL; creates a signal handling thread to detect and process asynchronous signals (See ). This thread is a trivial one and does not process the signals itself: it communicates with, or launches new signal handling threads to act accordingly to the denoted events. The use of a separate thread has some nice consequences. The first one is that those signals will not interrupt any sensitive code. The second one is that the signal handling thread will be able to execute arbitrary lisp or C code, since it is not being executed in a sensitive context. Most important, this style of signal handling is the recommended one by the POSIX standards, and it is the one that Windows uses. The installation of the signal handling thread is dictated by a boot time option, ECL_OPT_SIGNAL_HANDLING_THREAD, and it will only be possible in systems that support either POSIX or Windows threads. Systems which embed &ECL; as an extension language may wish to deactivate the signal handling thread using the previously mentioned option. If this is the case, then they should take appropriate measures to avoid interrupting the code in &ECL; when such signals are delivered. Systems which embed &ECL; and do not mind having a separate signal handling thread can control the set of asynchronous signals which is handled by this thread. This is done again using the appropriate boot options such as ECL_OPT_TRAP_SIGINT, ECL_OPT_TRAP_SIGTERM, etc. Note that in order to detect and handle those signals, &ECL; must block them from delivery to any other thread. This means changing the sigprocmask() in POSIX systems or setting up a custom SetConsoleCtrlHandler() in Windows.
Handling of synchronous signals We have already mentioned that certain synchronous signals and exceptions can not be ignored and yet the corresponding signal handlers are not able to execute arbitrary code. To solve this seemingly impossible contradiction, &ECL; uses a simple solution, which is to mark the sections of code which are interruptible, and in which it is safe for the handler to run arbitrary code. All other regions would be considered "unsafe" and would be protected from signals and exceptions. In principle this "marking" of safe areas can be done using POSIX functions such as pthread_sigmask() or sigprocmask(). However in practice this is slow, as it involves at least a function call, resolving thread-local variables, etc, etc, and it will not work in Windows. Furthermore, sometimes we want signals to be detected but not to be immediately processed. For instance, when reading from the terminal we want to be able to interrupt the process, but we can not execute the code from the handler, since the C function which is used to read from the terminal, read(), may have left the input stream in an inconsistent, or even locked state. The approach in &ECL; is more lightweight: we install our own signal handler and use a thread-local variable as a flag that determines whether the thread is executing interrupt safe code or not. More precisely, if the variable ecl_process_env()->disable_interrupts is set, signals and exceptions will be postponed and then the information about the signal is queued. Otherwise the appropriate code is executed: for instance invoking the debugger, jumping to a condition handler, quitting, etc. Systems that embed &ECL; may wish to deactivate completely these signal handlers. This is done using the boot options, ECL_OPT_TRAP_SIGFPE, ECL_OPT_TRAP_SIGSEGV, ECL_OPT_TRAP_SIGBUS, ECL_OPT_TRAP_INTERRUPT_SIGNAL. Systems that embed &ECL; and want to allow handling of synchronous signals should take care to also trap the associated lisp conditions that may arise. This is automatically taken care of by functions such as si_safe_eval(), and in all other cases it can be solved by enclosing the unsafe code in a CL_CATCH_ALL_BEGIN frame (See ).
Considerations when embedding &ECL; There are several approaches when handling signals and interrupts in a program that uses &ECL;. One is to install your own signal handlers. This is perfectly fine, but you should respect the same restrictions as &ECL;. Namely, you may not execute arbitrary code from those signal handlers, and in particular it will not always be safe to execute Common Lisp code from there. If you want to use your own signal handlers then you should set the appropriate options before invoking cl_boot(), as explained in . Note that in this case &ECL; will not always be able to detect floating point exceptions, specially if your compiler does not support C99 and the corresponding floating point flags. The other option is to let &ECL; handle signals itself. This would be safer when the dominant part of the code is Common Lisp, but you may need to protect the code that embeds &ECL; from being interrupted using either the macros and or the POSIX functions pthread_sigmaks and sigprocmask.
ecl-16.1.2/doc/tmp/000077500000000000000000000000001266352375300137255ustar00rootroot00000000000000ecl-16.1.2/doc/tmp/placeholder000066400000000000000000000000001266352375300161200ustar00rootroot00000000000000ecl-16.1.2/doc/uffi/000077500000000000000000000000001266352375300140565ustar00rootroot00000000000000ecl-16.1.2/doc/uffi/ref_aggregate.xml000066400000000000000000000343361266352375300173730ustar00rootroot00000000000000 %eclent; ]> Aggregate Types Overview Aggregate types are comprised of one or more primitive types. def-enum Defines a &C; enumeration. Macro Syntax def-enum name fields &key separator-string Arguments and Values name A symbol that names the enumeration. fields A list of field defintions. Each definition can be a symbol or a list of two elements. Symbols get assigned a value of the current counter which starts at 0 and increments by 1 for each subsequent symbol. It the field definition is a list, the first position is the symbol and the second position is the value to assign the the symbol. The current counter gets set to 1+ this value. separator-string A string that governs the creation of constants. The default is "#". Description Declares a &C; enumeration. It generates constants with integer values for the elements of the enumeration. The symbols for the these constant values are created by the concatenation of the enumeration name, separator-string, and field symbol. Also creates a foreign type with the name name of type :int. Examples (def-enum abc (:a :b :c)) ;; Creates constants abc#a (1), abc#b (2), abc#c (3) and defines ;; the foreign type "abc" to be :int (def-enum efoo (:e1 (:e2 10) :e3) :separator-string "-") ;; Creates constants efoo-e1 (1), efoo-e2 (10), efoo-e3 (11) and defines ;; the foreign type efoo to be :int Side Effects Creates a :int foreign type, defines constants. Affected by None. Exceptional Situations None. def-struct Defines a &C; structure. Macro Syntax def-struct name &rest fields Arguments and Values name A symbol that names the structure. fields A variable number of field defintions. Each definition is a list consisting of a symbol naming the field followed by its foreign type. Description Declares a structure. A special type is available as a slot in the field. It is a pointer that points to an instance of the parent structure. It's type is :pointer-self. Examples (def-struct foo (a :unsigned-int) (b (* :char)) (c (:array :int 10)) (next :pointer-self)) Side Effects Creates a foreign type. Affected by None. Exceptional Situations None. get-slot-value Retrieves a value from a slot of a structure. Macro Syntax get-slot-value obj type field => value Arguments and Values obj A pointer to foreign structure. type A name of the foreign structure. field A name of the desired field in foreign structure. value The value of the field in the structure. Description Accesses a slot value from a structure. This is generalized and can be used with setf. Examples (get-slot-value foo-ptr 'foo-structure 'field-name) (setf (get-slot-value foo-ptr 'foo-structure 'field-name) 10) Side Effects None. Affected by None. Exceptional Situations None. get-slot-pointer Retrieves a pointer from a slot of a structure. Macro Syntax get-slot-pointer obj type field => pointer Arguments and Values obj A pointer to foreign structure. type A name of the foreign structure. field A name of the desired field in foreign structure. pointer The value of the field in the structure. Description This is similar to get-slot-value. It is used when the value of a slot is a pointer type. Examples (get-slot-pointer foo-ptr 'foo-structure 'my-char-ptr) Side Effects None. Affected by None. Exceptional Situations None. def-array-pointer Defines a pointer to a array of type. Macro Syntax def-array-pointer name type Arguments and Values name A name of the new foreign type. type The foreign type of the array elements. Description Defines a type tat is a pointer to an array of type. Examples (def-array-pointer byte-array-pointer :unsigned-char) Side Effects Defines a new foreign type. Affected by None. Exceptional Situations None. deref-array Deference an array. Macro Syntax deref-array array type position => value Arguments and Values array A foreign array. type The foreign type of the array. position An integer specifying the position to retrieve from the array. value The value stored in the position of the array. Description Dereferences (retrieves) the value of an array element. Examples (def-array-pointer ca :char) (let ((fs (convert-to-foreign-string "ab"))) (values (null-char-p (deref-array fs 'ca 0)) (null-char-p (deref-array fs 'ca 2)))) => &nil; &t; Notes The TYPE argument is ignored for CL implementations other than AllegroCL. If you want to cast a pointer to another type use WITH-CAST-POINTER together with DEREF-POINTER/DEREF-ARRAY. Side Effects None. Affected by None. Exceptional Situations None. def-union Defines a foreign union type. Macro Syntax def-union name &rest fields Arguments and Values name A name of the new union type. fields A list of fields of the union. Description Defines a foreign union type. Examples (def-union test-union (a-char :char) (an-int :int)) (let ((u (allocate-foreign-object 'test-union))) (setf (get-slot-value u 'test-union 'an-int) (+ 65 (* 66 256))) (prog1 (ensure-char-character (get-slot-value u 'test-union 'a-char)) (free-foreign-object u))) => #\A Side Effects Defines a new foreign type. Affected by None. Exceptional Situations None. ecl-16.1.2/doc/uffi/ref_declare.xml000066400000000000000000000042321266352375300170340ustar00rootroot00000000000000 %eclent; ]> Declarations Overview Declarations are used to give the compiler optimizing information about foreign types. Currently, only &CMUCL; supports declarations. On &ACL; and &LW;, these expressions declare the type generically as &t; def-type Defines a Common Lisp type. Macro Syntax def-type name type name A symbol naming the type type A form that specifies the &UFFI; type. It is not evaluated. Description Defines a Common Lisp type based on a &UFFI; type. Examples (def-type char-ptr '(* :char)) ... (defun foo (ptr) (declare (type char-ptr ptr)) ... Side Effects Defines a new &CommonLisp; type. Affected by None. Exceptional Situations None. ecl-16.1.2/doc/uffi/ref_func_libr.xml000066400000000000000000000201611266352375300173770ustar00rootroot00000000000000 %eclent; ]> Functions & Libraries def-function Declares a function. Macro def-function name args &key module returning name A string or list specificying the function name. If it is a string, that names the foreign function. A Lisp name is created by translating #\_ to #\- and by converting to upper-case in case-insensitive Lisp implementations. If it is a list, the first item is a string specifying the foreign function name and the second it is a symbol stating the Lisp name. args A list of argument declarations. If &nil;, indicates that the function does not take any arguments. module A string specifying which module (or library) that the foreign function resides. (Required by Lispworks) returning A declaration specifying the result type of the foreign function. If :void indicates module does not return any value. Description Declares a foreign function. Examples (def-function "gethostname" ((name (* :unsigned-char)) (len :int)) :returning :int) Side Effects None. Affected by None. Exceptional Situations None. load-foreign-library Loads a foreign library. Function load-foreign-library filename &key module supporting-libraries force-load => success filename A string or pathname specifying the library location in the filesystem. At least one implementation (&LW;) can not accept a logical pathname. If this parameter denotes a pathname without a directory component then most of the supported Lisp implementations will be able to find the library themselves if it is located in one of the standard locations as defined by the underlying operating system. module A string designating the name of the module to apply to functions in this library. (Required for Lispworks) supporting-libraries A list of strings naming the libraries required to link the foreign library. (Required by CMUCL) force-load Forces the loading of the library if it has been previously loaded. success A boolean flag, &t; if the library was able to be loaded successfully or if the library has been previously loaded, otherwise &nil;. Description Loads a foreign library. Applies a module name to functions within the library. Ensures that a library is only loaded once during a session. A library can be reloaded by using the :force-load key. Examples (load-foreign-library #p"/usr/lib/libmysqlclient.so" :module "mysql" :supporting-libraries '("c")) => T Side Effects Loads the foreign code into the Lisp system. Affected by Ability to load the file. Exceptional Situations None. find-foreign-library Finds a foreign library file. Function find-foreign-library names directories & drive-letters types => path names A string or list of strings containing the base name of the library file. directories A string or list of strings containing the directory the library file. drive-letters A string or list of strings containing the drive letters for the library file. types A string or list of strings containing the file type of the library file. Default is &nil;. If &nil;, will use a default type based on the currently running implementation. path A path containing the path found, or &nil; if the library file was not found. Description Finds a foreign library by searching through a number of possible locations. Returns the path of the first found file. Examples (find-foreign-library '("libmysqlclient" "libmysql") '("/opt/mysql/lib/mysql/" "/usr/local/lib/" "/usr/lib/" "/mysql/lib/opt/") :types '("so" "dll") :drive-letters '("C" "D" "E")) => #P"D:\\mysql\\lib\\opt\\libmysql.dll" Side Effects None. Affected by None. Exceptional Situations None. ecl-16.1.2/doc/uffi/ref_object.xml000066400000000000000000000541161266352375300167110ustar00rootroot00000000000000 %eclent; ]> Objects Overview Objects are entities that can allocated, referred to by pointers, and can be freed. allocate-foreign-object Allocates an instance of a foreign object. Macro allocate-foreign-object type &optional; size type The type of foreign object to allocate. This parameter is evaluated. size An optional size parameter that is evaluated. If specified, allocates and returns an array of type that is size members long. This parameter is evaluated. returns A pointer to the foreign object. Description Allocates an instance of a foreign object. It returns a pointer to the object. Examples (def-struct ab (a :int) (b :double)) (allocate-foreign-object 'ab) => #<ptr> Side Effects None. Affected by None. Exceptional Situations None. free-foreign-object Frees memory that was allocated for a foreign boject. Macro free-foreign-object ptr ptr A pointer to the allocated foreign object to free. Description Frees the memory used by the allocation of a foreign object. Side Effects None. Affected by None. Exceptional Situations None. with-foreign-object Wraps the allocation of a foreign object around a body of code. Macro with-foreign-object (var type) &body; body Arguments and Values var The variable name to bind. type The type of foreign object to allocate. This parameter is evaluated. returns The result of evaluating the body. Description This function wraps the allocation, binding, and destruction of a foreign object. On &CMUCL; and &LW; platforms the object is stack allocated for efficiency. Benchmarks show that &ACL; performs much better with static allocation. Examples (defun gethostname2 () "Returns the hostname" (uffi:with-foreign-object (name '(:array :unsigned-char 256)) (if (zerop (c-gethostname (uffi:char-array-to-pointer name) 256)) (uffi:convert-from-foreign-string name) (error "gethostname() failed.")))) Side Effects None. Affected by None. Exceptional Situations None. size-of-foreign-type Returns the number of data bytes used by a foreign object type. Macro size-of-foreign-type ftype ftype A foreign type specifier. This parameter is evaluated. Description Returns the number of data bytes used by a foreign object type. This does not include any Lisp storage overhead. Examples (size-of-foreign-object :unsigned-byte) => 1 (size-of-foreign-object 'my-100-byte-vector-type) => 100 Side Effects None. Affected by None. Exceptional Situations None. pointer-address Returns the address of a pointer. Macro pointer-address ptr ptr A pointer to a foreign object. returns An integer representing the pointer's address. Description Returns the address as an integer of a pointer. Side Effects None. Affected by None. Exceptional Situations None. deref-pointer Deferences a pointer. Macro deref-pointer ptr type ptr A pointer to a foreign object. type A foreign type of the object being pointed to. returns The value of the object where the pointer points. Description Returns the object to which a pointer points. Examples (let ((intp (allocate-foreign-object :int))) (setf (deref-pointer intp :int) 10) (prog1 (deref-pointer intp :int) (free-foreign-object intp))) => 10 Notes The TYPE argument is ignored for CL implementations other than AllegroCL. If you want to cast a pointer to another type use WITH-CAST-POINTER together with DEREF-POINTER/DEREF-ARRAY. Side Effects None. Affected by None. Exceptional Situations None. ensure-char-character Ensures that a dereferenced :char pointer is a character. Macro ensure-char-character object object Either a character or a integer specifying a character code. returns A character. Description Ensures that an objects obtained by dereferencing :char and :unsigned-char pointers are a lisp character. Examples (let ((fs (convert-to-foreign-string "a"))) (prog1 (ensure-char-character (deref-pointer fs :char)) (free-foreign-object fs))) => #\a Side Effects None. Affected by None. Exceptional Situations Depending upon the implementation and what &UFFI; expects, this macro may signal an error if the object is not a character or integer. ensure-char-integer Ensures that a dereferenced :char pointer is an integer. Macro ensure-char-integer object object Either a character or a integer specifying a character code. returns An integer. Description Ensures that an object obtained by dereferencing a :char pointer is an integer. Examples (let ((fs (convert-to-foreign-string "a"))) (prog1 (ensure-char-integer (deref-pointer fs :char)) (free-foreign-object fs))) => 96 Side Effects None. Affected by None. Exceptional Situations Depending upon the implementation and what &UFFI; expects, this macro may signal an error if the object is not a character or integer. make-null-pointer Create a &NULL; pointer. Macro make-null-pointer type type A type of object to which the pointer refers. returns The &NULL; pointer of type type. Description Creates a &NULL; pointer of a specified type. Side Effects None. Affected by None. Exceptional Situations None. null-pointer-p Tests a pointer for &NULL; value. Macro null-pointer-p ptr ptr A foreign object pointer. returns The boolean flag. Description A predicate testing if a pointer is has a &NULL; value. Side Effects None. Affected by None. Exceptional Situations None. +null-cstring-pointer+ A constant &NULL; cstring pointer. Constant Description A &NULL; cstring pointer. This can be used for testing if a cstring returned by a function is &NULL;. with-cast-pointer Wraps a body of code with a pointer cast to a new type. Macro with-cast-pointer (binding-name ptr type) &body; body binding-name A symbol which will be bound to the casted object. ptr A pointer to a foreign object. type A foreign type of the object being pointed to. returns The value of the object where the pointer points. Description Executes BODY with POINTER cast to be a pointer to type TYPE. BINDING-NAME is will be bound to this value during the execution of BODY. This is a no-op in AllegroCL but will wrap BODY in a LET form if BINDING-NAME is provided. This macro is meant to be used in conjunction with DEREF-POINTER or DEREF-ARRAY. In Allegro CL the "cast" will actually take place in DEREF-POINTER or DEREF-ARRAY. Examples (with-foreign-object (size :int) ;; FOO is a foreign function returning a :POINTER-VOID (let ((memory (foo size))) (when (mumble) ;; at this point we know for some reason that MEMORY points ;; to an array of unsigned bytes (with-cast-pointer (memory :unsigned-byte) (dotimes (i (deref-pointer size :int)) (do-something-with (deref-array memory '(:array :unsigned-byte) i))))))) Side Effects None. Affected by None. Exceptional Situations None. def-foreign-var Defines a symbol macro to access a variable in foreign code Macro def-foreign-var name type module name A string or list specificying the symbol macro's name. If it is a string, that names the foreign variable. A Lisp name is created by translating #\_ to #\- and by converting to upper-case in case-insensitive Lisp implementations. If it is a list, the first item is a string specifying the foreign variable name and the second it is a symbol stating the Lisp name. type A foreign type of the foreign variable. module A string specifying the module (or library) the foreign variable resides in. (Required by Lispworks) Description Defines a symbol macro which can be used to access (get and set) the value of a variable in foreign code. Examples C code int baz = 3; typedef struct { int x; double y; } foo_struct; foo_struct the_struct = { 42, 3.2 }; int foo () { return baz; } Lisp code (uffi:def-struct foo-struct (x :int) (y :double)) (uffi:def-function ("foo" foo) () :returning :int :module "foo") (uffi:def-foreign-var ("baz" *baz*) :int "foo") (uffi:def-foreign-var ("the_struct" *the-struct*) foo-struct "foo") *baz* => 3 (incf *baz*) => 4 (foo) => 4 Side Effects None. Affected by None. Exceptional Situations None. ecl-16.1.2/doc/uffi/ref_primitive.xml000066400000000000000000000200341266352375300174430ustar00rootroot00000000000000 %eclent; ]> Primitive Types Overview Primitive types have a single value, these include characters, numbers, and pointers. They are all symbols in the keyword package. :char - Signed 8-bits. A dereferenced :char pointer returns an character. :unsigned-char - Unsigned 8-bits. A dereferenced :unsigned-char pointer returns an character. :byte - Signed 8-bits. A dereferenced :byte pointer returns an integer. :unsigned-byte - Unsigned 8-bits. A dereferenced :unsigned-byte pointer returns an integer. :short - Signed 16-bits. :unsigned-short - Unsigned 16-bits. :int - Signed 32-bits. :unsigned-int - Unsigned 32-bits. :long - Signed 32 or 64 bits, depending upon the platform. :unsigned-long - Unsigned 32 or 64 bits, depending upon the platform. :float - 32-bit floating point. :double - 64-bit floating point. :cstring - A &NULL; terminated string used for passing and returning characters strings with a &C; function. :void - The absence of a value. Used to indicate that a function does not return a value. :pointer-void - Points to a generic object. * - Used to declare a pointer to an object def-constant Binds a symbol to a constant. Macro def-constant name value &key; export name A symbol that will be bound to the value. value An evaluated form that is bound the the name. export When &t;, the name is exported from the current package. The default is &nil; Description This is a thin wrapper around defconstant. It evaluates at compile-time and optionally exports the symbol from the package. Examples (def-constant pi2 (* 2 pi)) (def-constant exported-pi2 (* 2 pi) :export t) Side Effects Creates a new special variable.. Affected by None. Exceptional Situations None. def-foreign-type Defines a new foreign type. Macro def-foreign-type name type name A symbol naming the new foreign type. value A form that is not evaluated that defines the new foreign type. Description Defines a new foreign type. Examples (def-foreign-type my-generic-pointer :pointer-void) (def-foreign-type a-double-float :double-float) (def-foreign-type char-ptr (* :char)) Side Effects Defines a new foreign type. Affected by None. Exceptional Situations None. null-char-p Tests a character for &NULL; value. Macro null-char-p char char A character or integer. returns A boolean flag indicating if char is a &NULL; value. Description A predicate testing if a character or integer is &NULL;. This abstracts the difference in implementations where some return a character and some return a integer whence dereferencing a C character pointer. Examples (def-array-pointer ca :unsigned-char) (let ((fs (convert-to-foreign-string "ab"))) (values (null-char-p (deref-array fs 'ca 0)) (null-char-p (deref-array fs 'ca 2)))) => &nil; &t; Side Effects None. Affected by None. Exceptional Situations None. ecl-16.1.2/doc/uffi/ref_string.xml000066400000000000000000000340611266352375300167460ustar00rootroot00000000000000 %eclent; ]> Strings Overview &UFFI; has functions to two types of C-compatible strings: cstring and foreign strings. cstrings are used only as parameters to and from functions. In some implementations a cstring is not a foreign type but rather the Lisp string itself. On other platforms a cstring is a newly allocated foreign vector for storing characters. The following is an example of using cstrings to both send and return a value. (uffi:def-function ("getenv" c-getenv) ((name :cstring)) :returning :cstring) (defun my-getenv (key) "Returns an environment variable, or NIL if it does not exist" (check-type key string) (uffi:with-cstring (key-native key) (uffi:convert-from-cstring (c-getenv key-native)))) In contrast, foreign strings are always a foreign vector of characters which have memory allocated. Thus, if you need to allocate memory to hold the return value of a string, you must use a foreign string and not a cstring. The following is an example of using a foreign string for a return value. (uffi:def-function ("gethostname" c-gethostname) ((name (* :unsigned-char)) (len :int)) :returning :int) (defun gethostname () "Returns the hostname" (let* ((name (uffi:allocate-foreign-string 256)) (result-code (c-gethostname name 256)) (hostname (when (zerop result-code) (uffi:convert-from-foreign-string name)))) ;; UFFI does not yet provide a universal way to free ;; memory allocated by C's malloc. At this point, a program ;; needs to call C's free function to free such memory. (unless (zerop result-code) (error "gethostname() failed.")))) Foreign functions that return pointers to freshly allocated strings should in general not return cstrings, but foreign strings. (There is no portable way to release such cstrings from Lisp.) The following is an example of handling such a function. (uffi:def-function ("readline" c-readline) ((prompt :cstring)) :returning (* :char)) (defun readline (prompt) "Reads a string from console with line-editing." (with-cstring (c-prompt prompt) (let* ((c-str (c-readline c-prompt)) (str (convert-from-foreign-string c-str))) (uffi:free-foreign-object c-str) str))) convert-from-cstring Converts a cstring to a Lisp string. Macro Syntax convert-from-cstring cstring => string Arguments and Values cstring A cstring. string A Lisp string. Description Converts a Lisp string to a cstring. This is most often used when processing the results of a foreign function that returns a cstring. Side Effects None. Affected by None. Exceptional Situations None. convert-to-cstring Converts a Lisp string to a cstring. Macro Syntax convert-to-cstring string => cstring Arguments and Values string A Lisp string. cstring A cstring. Description Converts a Lisp string to a cstring. The cstring should be freed with free-cstring. Side Effects On some implementations, this function allocates memory. Affected by None. Exceptional Situations None. free-cstring Free memory used by cstring. Macro Syntax free-cstring cstring Arguments and Values cstring A cstring. Description Frees any memory possibly allocated by convert-to-cstring. On some implementions, a cstring is just the Lisp string itself. Side Effects None. Affected by None. Exceptional Situations None. with-cstring Binds a newly created cstring. Macro Syntax with-cstring (cstring string) {body} Arguments and Values cstring A symbol naming the cstring to be created. string A Lisp string that will be translated to a cstring. body The body of where the cstring will be bound. Description Binds a symbol to a cstring created from conversion of a string. Automatically frees the cstring. Examples (def-function ("getenv" c-getenv) ((name :cstring)) :returning :cstring) (defun getenv (key) "Returns an environment variable, or NIL if it does not exist" (check-type key string) (with-cstring (key-cstring key) (convert-from-cstring (c-getenv key-cstring)))) Side Effects None. Affected by None. Exceptional Situations None. convert-from-foreign-string Converts a foreign string into a Lisp string. Macro Syntax convert-from-foreign-string foreign-string &key length null-terminated-p => string Arguments and Values foreign-string A foreign string. length The length of the foreign string to convert. The default is the length of the string until a &NULL; character is reached. null-terminated-p A boolean flag with a default value of &t; When true, the string is converted until the first &NULL; character is reached. string A Lisp string. Description Returns a Lisp string from a foreign string. Can translated ASCII and binary strings. Side Effects None. Affected by None. Exceptional Situations None. convert-to-foreign-string Converts a Lisp string to a foreign string. Macro Syntax convert-to-foreign-string string => foreign-string Arguments and Values string A Lisp string. foreign-string A foreign string. Description Converts a Lisp string to a foreign string. Memory should be freed with free-foreign-object. Side Effects None. Affected by None. Exceptional Situations None. allocate-foreign-string Allocates space for a foreign string. Macro allocate-foreign-string size &key unsigned => foreign-string size The size of the space to be allocated in bytes. unsigned A boolean flag with a default value of &t;. When true, marks the pointer as an :unsigned-char. foreign-string A foreign string which has undefined contents. Description Allocates space for a foreign string. Memory should be freed with free-foreign-object. Side Effects None. Affected by None. Exceptional Situations None. ecl-16.1.2/doc/uffi/schemas.xml000066400000000000000000000012171266352375300162240ustar00rootroot00000000000000 ecl-16.1.2/doc/xsl/000077500000000000000000000000001266352375300137335ustar00rootroot00000000000000ecl-16.1.2/doc/xsl/add_indexterm.xml000066400000000000000000000034431266352375300172700ustar00rootroot00000000000000 cl c ecl-16.1.2/doc/xsl/customization.xml000066400000000000000000000024521266352375300173700ustar00rootroot00000000000000 ecl.css common-lisp appendix toc article/appendix nop article toc book toc,figure,table,example,equation chapter toc part toc preface toc reference toc sect1 nop sect2 nop sect3 nop sect4 nop sect5 nop section nop set toc ecl-16.1.2/doc/xsl/lispfunc-po.xml000066400000000000000000000033361266352375300167210ustar00rootroot00000000000000 ]> ( )   ecl-16.1.2/doc/xsl/lispfunc.xml000066400000000000000000000063611266352375300163060ustar00rootroot00000000000000 ]>

( ) ) ecl-16.1.2/doc/xsl/refentryintoc.xml000066400000000000000000000010751266352375300173530ustar00rootroot00000000000000 ecl-16.1.2/examples/000077500000000000000000000000001266352375300141765ustar00rootroot00000000000000ecl-16.1.2/examples/android/000077500000000000000000000000001266352375300156165ustar00rootroot00000000000000ecl-16.1.2/examples/android/.classpath000066400000000000000000000007221266352375300176020ustar00rootroot00000000000000 ecl-16.1.2/examples/android/.gitignore000066400000000000000000000001341266352375300176040ustar00rootroot00000000000000assets/lisp/lib assets/lisp/home bin/ ecl-android ecl-libdir gen/ libs/ obj local.propertiesecl-16.1.2/examples/android/.project000066400000000000000000000014631266352375300172710ustar00rootroot00000000000000 HelloEclActivity com.android.ide.eclipse.adt.ResourceManagerBuilder com.android.ide.eclipse.adt.PreCompilerBuilder org.eclipse.jdt.core.javabuilder com.android.ide.eclipse.adt.ApkBuilder com.android.ide.eclipse.adt.AndroidNature org.eclipse.jdt.core.javanature ecl-16.1.2/examples/android/.settings/000077500000000000000000000000001266352375300175345ustar00rootroot00000000000000ecl-16.1.2/examples/android/.settings/org.eclipse.jdt.core.prefs000066400000000000000000000002551266352375300245200ustar00rootroot00000000000000eclipse.preferences.version=1 org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6 org.eclipse.jdt.core.compiler.compliance=1.6 org.eclipse.jdt.core.compiler.source=1.6 ecl-16.1.2/examples/android/AndroidManifest.xml000066400000000000000000000013121266352375300214040ustar00rootroot00000000000000 ecl-16.1.2/examples/android/README000066400000000000000000000013371266352375300165020ustar00rootroot00000000000000This example was originally developed by Sylvain Ageneau. Integration with the current ECL done by Evrim Ulu and Daniel KochmaХ„ski. Original location of this this example is: http://github.com/ageneau/ecl-android Instructions: $ ln -s {$ECL_ANDROID_DIR} ecl-android $ ln -s ${ECL_LIB_DIR} ecl-libdir $ android update project -t android-10 -p . $ ndk-build $ ant debug install Where ECL_ANDROID_DIR contains a prefix to the directory where you installed cross-compiled ECL and the ECL_LIB_DIR contains path to the directory with ECL intern files in the lib/ dir. Example: $ export ECL_ANDROID_DIR=../../ecl-android $ export ECL_LIB_DIR=../../ecl-android/lib/ecl-16.1.0 Please direct further questions to ecl-devel@common-lisp.net ecl-16.1.2/examples/android/ant.properties000066400000000000000000000012721266352375300205200ustar00rootroot00000000000000# This file is used to override default values used by the Ant build system. # # This file must be checked into Version Control Systems, as it is # integral to the build system of your project. # This file is only used by the Ant script. # You can use this to override default values such as # 'source.dir' for the location of your java source folder and # 'out.dir' for the location of your output folder. # You can also use it define how the release builds are signed by declaring # the following properties: # 'key.store' for the location of your keystore and # 'key.alias' for the name of the key to use. # The password will be asked during the build when you use the 'release' target. ecl-16.1.2/examples/android/assets/000077500000000000000000000000001266352375300171205ustar00rootroot00000000000000ecl-16.1.2/examples/android/assets/lisp/000077500000000000000000000000001266352375300200675ustar00rootroot00000000000000ecl-16.1.2/examples/android/assets/lisp/etc/000077500000000000000000000000001266352375300206425ustar00rootroot00000000000000ecl-16.1.2/examples/android/assets/lisp/etc/init.lisp000066400000000000000000000010031266352375300224700ustar00rootroot00000000000000(in-package :cl-user) (format t "ECL (Embeddable Common-Lisp) ~A (git:~D)~%" (lisp-implementation-version) (ext:lisp-implementation-vcs-id)) (defvar *ecl-home* *default-pathname-defaults*) (format t "Loading the modules~%") (require '#:asdf) (require '#:sockets) (require '#:serve-event) (setf asdf:*user-cache* (merge-pathnames #P"../cache/" *default-pathname-defaults*)) (pushnew (namestring *default-pathname-defaults*) asdf:*central-registry*) (when (probe-file #P"etc/user.lisp") (load "etc/user")) ecl-16.1.2/examples/android/assets/lisp/etc/user.lisp000066400000000000000000000052101266352375300225070ustar00rootroot00000000000000(in-package :cl-user) (defun sysinfo (&optional (out *standard-output*)) "Print the current environment to a stream." (declare (stream out)) (format out "~&~%~75~~%~75,,,'-:@<<{[ The current environment ]}>~>~%~ Implementation:~20t~a~%~7tversion:~20t~a~%Machine: type:~20t~a ~7tversion:~20t~a~%~6tinstance:~20t~a~%Opeating System:~19t" (lisp-implementation-type) (lisp-implementation-version) (machine-type) (machine-version) (machine-instance)) #+darwin (princ " Darwin") #+unix (princ " Unix") (format out "~%Software: type:~20t~a~%~7tversion:~20t~a~%Site:~20t~a (~a) User home:~20t~a~%Default pathname:~20t~a~%" (software-type) (software-version) (long-site-name) (short-site-name) (user-homedir-pathname) *default-pathname-defaults*) (format out "Features: ~s. Modules:~s.~% Current package:~s~%" *features* *modules* *package*) (flet ((exdi (fl) (integer-length (nth-value 1 (decode-float fl))))) (format out "Fixnum length:~25t~3d bits Short Floats:~25t~3d bits exponent, ~3d bits significand (mantissa) Single Floats:~25t~3d bits exponent, ~3d bits significand (mantissa) Double Floats:~25t~3d bits exponent, ~3d bits significand (mantissa) Long Floats:~25t~3d bits exponent, ~3d bits significand (mantissa)~%" (integer-length most-positive-fixnum) (exdi most-positive-short-float) (float-digits most-positive-short-float) (exdi most-positive-single-float) (float-digits most-positive-single-float) (exdi most-positive-double-float) (float-digits most-positive-double-float) (exdi most-positive-long-float) (float-digits most-positive-long-float))) (dolist (sy '(array-total-size-limit array-rank-limit array-dimension-limit lambda-parameters-limit call-arguments-limit multiple-values-limit char-code-limit)) (format out " ~a:~30t~15:d~%" sy (symbol-value sy))) (format out "lambda-list-keywords:~s~%" lambda-list-keywords) (format out "Internal time unit:~25t~f sec~%*gensym-counter*:~25t~:d Current time:~25t" (/ internal-time-units-per-second) *gensym-counter*) (format out "~a" (get-universal-time)) (format out "~%~75~~%") (room) (values)) (sysinfo) ;; Quicklisp (defun get-quicklisp () (format t "Loading the quicklisp subsystem~%") (require '#:ecl-quicklisp) (require '#:deflate) (require '#:ql-minitar) ;; Replace the interpreted function with the precompiled equivalent ;; from DEFLATE (eval (read-from-string "(setf (symbol-function 'ql-gunzipper:gunzip) #'deflate:gunzip))"))) #+(or)(get-quicklisp) ecl-16.1.2/examples/android/build.xml000066400000000000000000000106421266352375300174420ustar00rootroot00000000000000 ecl-16.1.2/examples/android/jni/000077500000000000000000000000001266352375300163765ustar00rootroot00000000000000ecl-16.1.2/examples/android/jni/Android.mk000066400000000000000000000023541266352375300203130ustar00rootroot00000000000000# Copyright (C) 2009 The Android Open Source Project # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # BASE_PATH := $(call my-dir) include $(CLEAR_VARS) ECL_HOME := ../ecl-android LOCAL_MODULE := ecl_lib LOCAL_PATH := $(BASE_PATH) LOCAL_SRC_FILES := $(ECL_HOME)/lib/libecl.so include $(PREBUILT_SHARED_LIBRARY) # ecl_android shared object include $(CLEAR_VARS) ifeq ($(TARGET_ARCH),x86) PLATFORM := androidx86 else PLATFORM := android endif ECL_HOME := ecl-android LOCAL_MODULE := ecl_android LOCAL_PATH := $(BASE_PATH) LOCAL_SRC_FILES := org_lisp_ecl_EmbeddedCommonLisp.c ecl_boot.c LOCAL_CFLAGS += -I$(ECL_HOME)/include LOCAL_CFLAGS += -g -Wall -DANDROID LOCAL_SHARED_LIBRARIES := ecl_lib LOCAL_LDLIBS += -llog # -lecl include $(BUILD_SHARED_LIBRARY) ecl-16.1.2/examples/android/jni/ecl_boot.c000066400000000000000000000065061266352375300203370ustar00rootroot00000000000000#include #include #if ANDROID #include #endif #if ANDROID #define LOGI(...) ((void)__android_log_print(ANDROID_LOG_INFO, "native-activity", __VA_ARGS__)) #define LOGW(...) ((void)__android_log_print(ANDROID_LOG_WARN, "native-activity", __VA_ARGS__)) #define LOGE(...) ((void)__android_log_print(ANDROID_LOG_ERROR, "native-activity", __VA_ARGS__)) #define LOGV(...) ((void)__android_log_print(ANDROID_LOG_VERBOSE, "native-activity", __VA_ARGS__)) #else #define LOGI(...) #define LOGW(...) #define LOGE(...) #endif #include "ecl_boot.h" #ifdef __cplusplus #define ECL_CPP_TAG "C" #else #define ECL_CPP_TAG #endif /* extern ECL_CPP_TAG void init_lib_ASDF(); */ /* extern ECL_CPP_TAG void init_lib_SOCKETS(); */ /* extern ECL_CPP_TAG void init_lib_SB_BSD_SOCKETS(); */ /* extern ECL_CPP_TAG void init_lib_SERVE_EVENT(); */ /* extern ECL_CPP_TAG void init_lib_ECL_CDB(); */ /* extern ECL_CPP_TAG void init_lib_ECL_HELP() */; extern void loadLispFromAssets(char* fn); int ecl_boot(const char *root_dir) { char *ecl = "ecl"; char tmp[2048]; LOGI("ECL boot beginning\n"); LOGI("Setting directories\n"); setenv("HOME", root_dir, 1); sprintf(tmp, "%s/lib/", root_dir); setenv("ECLDIR", tmp, 1); sprintf(tmp, "%s/etc/", root_dir); setenv("ETC", tmp, 1); sprintf(tmp, "%s/home/", root_dir); setenv("HOME", tmp, 1); LOGI("Directories set\n"); /* ecl_set_option(ECL_OPT_TRAP_SIGFPE, 0); */ /* ecl_set_option(ECL_OPT_TRAP_SIGSEGV, 0); */ /* ecl_set_option(ECL_OPT_TRAP_SIGINT, 0); */ /* ecl_set_option(ECL_OPT_TRAP_SIGILL, 0); */ /* ecl_set_option(ECL_OPT_TRAP_SIGBUS, 0); */ /* ecl_set_option(ECL_OPT_TRAP_INTERRUPT_SIGNAL, 0); */ /* ecl_set_option(ECL_OPT_SIGNAL_HANDLING_THREAD, 0); */ /* ecl_set_option(ECL_OPT_INCREMENTAL_GC, 0); */ cl_boot(1, &ecl); LOGI("installing bytecodes compiler\n"); si_safe_eval(3, c_string_to_object("(si:install-bytecodes-compiler)"), ECL_NIL, OBJNULL); /* LOGI("initializing linked modules\n"); */ /* ecl_init_module(NULL, init_lib_ECL_HELP); */ /* ecl_init_module(NULL, init_lib_ASDF); */ /* ecl_init_module(NULL, init_lib_SOCKETS); */ /* ecl_init_module(NULL, init_lib_SERVE_EVENT); */ LOGI("writing some info to stdout\n"); si_safe_eval (3, c_string_to_object ("(format t \"ECL_BOOT, features = ~A ~%\" *features*)"), Cnil, OBJNULL); si_safe_eval (3, c_string_to_object ("(format t \"(truename SYS:): ~A)\" (truename \"SYS:\"))"), Cnil, OBJNULL); ecl_toplevel(root_dir); return 0; } void ecl_toplevel(const char *home) { char tmp[2048]; LOGI("Executing the init scripts\n"); CL_CATCH_ALL_BEGIN(ecl_process_env()) { sprintf(tmp, "(setq *default-pathname-defaults* #p\"%s/\")", home); si_safe_eval(3, c_string_to_object(tmp), Cnil, OBJNULL); si_select_package(ecl_make_simple_base_string("CL-USER", 7)); si_safe_eval(3, c_string_to_object("(load \"etc/init\")"), Cnil, OBJNULL); } CL_CATCH_ALL_END; LOGI("Toplevel initialization done\n"); } ecl-16.1.2/examples/android/jni/ecl_boot.h000066400000000000000000000002361266352375300203360ustar00rootroot00000000000000#ifndef _ECL_BOOT_H_ #define _ECL_BOOT_H_ int ecl_boot(const char *root_dir); void ecl_toplevel(const char *home); void eclshell_show(char *message); #endifecl-16.1.2/examples/android/jni/org_lisp_ecl_EmbeddedCommonLisp.c000066400000000000000000000100601266352375300247520ustar00rootroot00000000000000#include #if ANDROID #include #endif #include #include #include #include #include #include "ecl_boot.h" #if ANDROID #define ECL_TAG "ecl-native" #define LOGI(...) ((void)__android_log_print(ANDROID_LOG_INFO, ECL_TAG, __VA_ARGS__)) #define LOGW(...) ((void)__android_log_print(ANDROID_LOG_WARN, ECL_TAG, __VA_ARGS__)) #define LOGE(...) ((void)__android_log_print(ANDROID_LOG_ERROR, ECL_TAG, __VA_ARGS__)) #define LOGV(...) ((void)__android_log_print(ANDROID_LOG_VERBOSE, ECL_TAG, __VA_ARGS__)) #else #define LOGI(...) #define LOGW(...) #define LOGE(...) #endif #define jni_ecl_read_from_string(x) si_string_to_object(1, x) /* * Class: org_lisp_ecl_EmbeddedCommonLisp * Method: start * Signature: ()V */ JNIEXPORT void JNICALL Java_org_lisp_ecl_EmbeddedCommonLisp_start(JNIEnv *env, jobject this, jstring path) { const char *lisp_dir = (*env)->GetStringUTFChars(env, path, NULL); LOGI("XXX: ECL starting: *default-pathname-defaults* to: %s\n", lisp_dir); ecl_boot(lisp_dir); LOGI("ECL started."); }; /* This was fun to make UTF8 work across Java-C-Lisp boundaries. -evrim, 2014. */ cl_object java_string_to_ecl_string(JNIEnv *env, jstring str) { const jchar *txt = (*env)->GetStringChars(env, str, NULL); jsize len = (*env)->GetStringLength(env, str); cl_object ecl_txt = ecl_alloc_simple_extended_string(len); cl_index i; for (i=0;istring.self[i] = txt[i]; }; (*env)->ReleaseStringChars(env, str, txt); return ecl_txt; } jstring ecl_object_to_java_string(JNIEnv *env, cl_object o) { jstring ret; if (ECL_EXTENDED_STRING_P(o)) { LOGI("ecl->java extended string of fillp: %d, dim: %d", o->string.fillp, o->string.dim); jsize len = o->string.fillp; jchar *arr = malloc(sizeof(jchar)*(len+1)); cl_index i; for (i=0; istring.self[i]; } arr[len] = 0; ret = (*env)->NewString(env, arr, len); free(arr); } else if (ECL_STRINGP(o)) { LOGI("ecl->java base string of len %d: %s", o->base_string.dim, o->base_string.self); ret = (*env)->NewStringUTF(env, (const char*)o->base_string.self); } else { LOGI("ecl->java not a string, coercing"); return ecl_object_to_java_string(env, cl_princ_to_string(o)); } return ret; } /* * Class: org_lisp_ecl_EmbeddedCommonLisp * Method: exec * Signature: (Ljava/lang/String;)Ljava/lang/String; */ JNIEXPORT jstring JNICALL Java_org_lisp_ecl_EmbeddedCommonLisp_exec(JNIEnv *env, jobject this, jstring str) { jstring ret; cl_object txt = java_string_to_ecl_string(env, str); cl_object result = si_safe_eval(3, jni_ecl_read_from_string(txt), Cnil, OBJNULL); if (result) { ret = ecl_object_to_java_string(env, result); } else { ret = (*env)->NewStringUTF(env, "ERROR in eval"); } return ret; }; #undef jni_ecl_read_from_string /* * Class: org_lisp_ecl_EmbeddedCommonLisp * Method: exec_ * Signature: (Ljava/lang/String;)Ljava/lang/String; */ JNIEXPORT jstring JNICALL Java_org_lisp_ecl_EmbeddedCommonLisp_exec_(JNIEnv *env, jobject this, jstring str) { jstring ret; const char *cmd = (*env)->GetStringUTFChars(env, str, NULL); cl_object result = si_safe_eval(3, c_string_to_object(cmd), Cnil, OBJNULL); if (result) { cl_object out = si_coerce_to_base_string(cl_princ_to_string(result)); ret = (*env)->NewStringUTF(env, (const char*) out->base_string.self); } else { ret = (*env)->NewStringUTF(env, "ERROR in eval"); } return ret; }; ecl-16.1.2/examples/android/jni/org_lisp_ecl_EmbeddedCommonLisp.h000066400000000000000000000017331266352375300247660ustar00rootroot00000000000000/* DO NOT EDIT THIS FILE - it is machine generated */ #include /* Header for class org_lisp_ecl_EmbeddedCommonLisp */ #ifndef _Included_org_lisp_ecl_EmbeddedCommonLisp #define _Included_org_lisp_ecl_EmbeddedCommonLisp #ifdef __cplusplus extern "C" { #endif /* * Class: org_lisp_ecl_EmbeddedCommonLisp * Method: start * Signature: ()V */ JNIEXPORT void JNICALL Java_org_lisp_ecl_EmbeddedCommonLisp_start (JNIEnv *, jobject, jstring); /* * Class: org_lisp_ecl_EmbeddedCommonLisp * Method: exec * Signature: (Ljava/lang/String;)Ljava/lang/String; */ JNIEXPORT jstring JNICALL Java_org_lisp_ecl_EmbeddedCommonLisp_exec (JNIEnv *, jobject, jstring); /* /\* */ /* * Class: org_lisp_ecl_EmbeddedCommonLisp */ /* * Method: botExec */ /* * Signature: (Ljava/lang/String;)Ljava/lang/String; */ /* *\/ */ /* JNIEXPORT jstring JNICALL Java_org_lisp_ecl_EmbeddedCommonLisp_exec_ */ /* (JNIEnv *, jobject, jstring); */ #ifdef __cplusplus } #endif #endif ecl-16.1.2/examples/android/proguard-project.txt000066400000000000000000000014151266352375300216470ustar00rootroot00000000000000# To enable ProGuard in your project, edit project.properties # to define the proguard.config property as described in that file. # # Add project specific ProGuard rules here. # By default, the flags in this file are appended to flags specified # in ${sdk.dir}/tools/proguard/proguard-android.txt # You can edit the include path and order by changing the ProGuard # include property in project.properties. # # For more details, see # http://developer.android.com/guide/developing/tools/proguard.html # Add any project specific keep options here: # If your project uses WebView with JS, uncomment the following # and specify the fully qualified class name to the JavaScript interface # class: #-keepclassmembers class fqcn.of.javascript.interface.for.webview { # public *; #} ecl-16.1.2/examples/android/project.properties000066400000000000000000000010631266352375300214020ustar00rootroot00000000000000# This file is automatically generated by Android Tools. # Do not modify this file -- YOUR CHANGES WILL BE ERASED! # # This file must be checked in Version Control Systems. # # To customize properties used by the Ant build system edit # "ant.properties", and override values to adapt the script to your # project structure. # # To enable ProGuard to shrink and obfuscate your code, uncomment this (available properties: sdk.dir, user.home): #proguard.config=${sdk.dir}/tools/proguard/proguard-android.txt:proguard-project.txt # Project target. target=android-10 ecl-16.1.2/examples/android/res/000077500000000000000000000000001266352375300164075ustar00rootroot00000000000000ecl-16.1.2/examples/android/res/layout/000077500000000000000000000000001266352375300177245ustar00rootroot00000000000000ecl-16.1.2/examples/android/res/layout/main.xml000066400000000000000000000006171266352375300213760ustar00rootroot00000000000000 ecl-16.1.2/examples/android/res/values/000077500000000000000000000000001266352375300177065ustar00rootroot00000000000000ecl-16.1.2/examples/android/res/values/strings.xml000066400000000000000000000001541266352375300221210ustar00rootroot00000000000000 HelloECL ecl-16.1.2/examples/android/src/000077500000000000000000000000001266352375300164055ustar00rootroot00000000000000ecl-16.1.2/examples/android/src/org/000077500000000000000000000000001266352375300171745ustar00rootroot00000000000000ecl-16.1.2/examples/android/src/org/lisp/000077500000000000000000000000001266352375300201435ustar00rootroot00000000000000ecl-16.1.2/examples/android/src/org/lisp/ecl/000077500000000000000000000000001266352375300207065ustar00rootroot00000000000000ecl-16.1.2/examples/android/src/org/lisp/ecl/EmbeddedCommonLisp.java000066400000000000000000000007601266352375300252460ustar00rootroot00000000000000package org.lisp.ecl; import android.util.Log; public class EmbeddedCommonLisp { private static String TAG = "EmbeddedCommonLisp"; public void start() { start(System.getenv("user.dir")); } public native void start(String path); public native String exec(String string); // public native String botExec(String string); static { System.loadLibrary("ecl"); System.loadLibrary("ecl_android"); Log.w(TAG,"Done loading library"); } } ecl-16.1.2/examples/android/src/org/lisp/ecl/HelloEclActivity.java000066400000000000000000000076201266352375300247620ustar00rootroot00000000000000package org.lisp.ecl; import java.io.File; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import android.app.Activity; import android.content.Context; import android.content.SharedPreferences; import android.content.res.AssetManager; import android.os.Bundle; import android.util.Log; import android.widget.Toast; public class HelloEclActivity extends Activity { private static String TAG = "HelloEcl"; private static String RESOURCES_DIR = "lisp"; private static String APP_RESOURCES_DIR = "resources"; private EmbeddedCommonLisp ecl = new EmbeddedCommonLisp(); private static boolean DEBUG = false; static AssetManager assetManager; static File uncompressedFilesDir; /** Called when the activity is first created. */ @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); assetManager = getAssets(); SharedPreferences settings = getPreferences(MODE_PRIVATE); boolean assetsUncompressed = settings.getBoolean("assetsUncompressed", false); uncompressedFilesDir = getDir(APP_RESOURCES_DIR,MODE_PRIVATE); if(!assetsUncompressed) { uncompressDir(RESOURCES_DIR,uncompressedFilesDir); SharedPreferences.Editor editor = settings.edit(); editor.putBoolean("assetsUncompressed", true); editor.commit(); } Log.w(TAG,"ECL starting."); ecl.start(getResourcesPath()); Log.w(TAG,"ECL Started"); setContentView(R.layout.main); String result = ecl.exec("(format nil \"Hello from lisp\")"); System.out.println("Result: " + result); Context context = getApplicationContext(); int duration = Toast.LENGTH_LONG; Toast toast = Toast.makeText(context, result, duration); toast.show(); } public void uncompressDir(String in, File out) { try { String[] files = assetManager.list(in); Log.w(TAG,"Uncompressing: " + files.length + " files"); for(int i=0; i 0) { out.write(buf, 0, len); } in.close(); out.close(); Log.i(TAG,"File copied."); } } ecl-16.1.2/examples/asdf/000077500000000000000000000000001266352375300151135ustar00rootroot00000000000000ecl-16.1.2/examples/asdf/example.asd000066400000000000000000000001401266352375300172320ustar00rootroot00000000000000(defsystem :example :serial t :components ((:file "file1") (:file "file2"))) ecl-16.1.2/examples/asdf/file1.lisp000066400000000000000000000004211266352375300170010ustar00rootroot00000000000000(princ "======================================================================") (terpri) (princ "We are now executing FILE1.LSP") (terpri) (defun test-function (x y) (format t "~D + ~D is equal to ~D~%" x y (+ x y))) (princ "TEST-FUNCTION has been created") (terpri) ecl-16.1.2/examples/asdf/file2.lisp000066400000000000000000000003661266352375300170120ustar00rootroot00000000000000(princ "We are now executing FILE2.LSP") (terpri) (princ "Calling TEST-FUNCTION in FILE2.LSP") (terpri) (test-function 1 1) (princ "Finished") (terpri) (princ "======================================================================") (terpri) ecl-16.1.2/examples/asdf/readme.lisp000066400000000000000000000044731266352375300172510ustar00rootroot00000000000000;;; Copyright (c) 2005, Juan Jose Garcia-Ripoll ;;; ;;; This program is free software; you can redistribute it and/or ;;; modify it under the terms of the GNU Library General Public ;;; License as published by the Free Software Foundation; either ;;; version 2 of the License, or (at your option) any later version. ;;; ;;; See file '../../Copyright' for full details. ;;; ;;; This an extremely simple example of how to build standalone programs and ;;; unified fasl files from a system definition file. You should peruse this ;;; file and also test it by loading it on your copy of ECL. ;;; ;;; ;;; First of all, we need to include the ASDF module and the compiler ;;; (require 'asdf) (require 'cmp) (setf *load-verbose* nil) (setf *compile-verbose* nil) (setf c::*suppress-compiler-warnings* t) (setf c::*suppress-compiler-notes* t) ;;; This flag determines how lisp constants are compiled into the program. ;;; The default scheme does not work well in statically linked libraries ;;; yet. (setf c::*compile-in-constants* t) (push (make-pathname :name nil :type nil :version nil :defaults *load-truename*) asdf:*central-registry*) ;;; ;;; This will show you what is running behind the walls of ASDF. Everything ;;; is built on top of the powerful C::BUILDER routine, which allows one ;;; to build anything from executables to shared libraries. ;;; ;;(trace c::builder) ;;; ;;; Now we attempt building a single FASL file containing all those files. ;;; Notice that we remove any previous fasl file. ;;; (princ " Building FASL file 'example.fasb' ") (asdf:make-build :example :type :fasl :move-here "./") ;;; ;;; Now we load the previous file! ;;; (princ " Loading FASL file example.fasb ") (load "example.fasb") ;;; ;;; Now that it worked, we attempt building a single program file with everything. ;;; (princ " Building standalone executable 'example-mono' ('example-mono.exe' in Windows) ") (asdf:make-build :example :type :program :epilogue-code '(ext:quit 0) :move-here "./") ;;; ;;; Test the program ;;; (princ " Executing standalone file 'example' ") (ext:system "./example") ;;; ;;; Clean up everything ;;; (mapc #'delete-file (append (directory "*.o") (directory "*.obj") (directory "example-mono*"))) ecl-16.1.2/examples/build/000077500000000000000000000000001266352375300152755ustar00rootroot00000000000000ecl-16.1.2/examples/build/hello.lisp000066400000000000000000000010351266352375300172700ustar00rootroot00000000000000;;; Copyright (c) 2006, Juan Jose Garcia Ripoll. ;;; ;;; ECL is free software; you can redistribute it and/or ;;; modify it under the terms of the GNU Library General Public ;;; License as published by the Free Software Foundation; either ;;; version 2 of the License, or (at your option) any later version. ;;; ;;; See file '../Copyright' for full details. (ffi::clines "extern const char *hello_string;") (ffi::def-foreign-var ("hello_string" +hello-string+) (* :char) nil) (print (ffi:convert-from-foreign-string +hello-string+)) ecl-16.1.2/examples/build/hello_aux.c000066400000000000000000000006231266352375300174220ustar00rootroot00000000000000/* Copyright (c) 2006, Juan Jose Garcia Ripoll. * * ECL is free software; you can redistribute it and/or * modify it under the terms of the GNU Library General Public * License as published by the Free Software Foundation; either * version 2 of the License, or (at your option) any later version. * * See file '../Copyright' for full details. */ const char *hello_string = "Hello world!"; ecl-16.1.2/examples/build/readme.lisp000066400000000000000000000050271266352375300174270ustar00rootroot00000000000000;;; Copyright (c) 2006, Juan Jose Garcia Ripoll. ;;; ;;; ECL is free software; you can redistribute it and/or ;;; modify it under the terms of the GNU Library General Public ;;; License as published by the Free Software Foundation; either ;;; version 2 of the License, or (at your option) any later version. ;;; ;;; See file '../Copyright' for full details. ;;; ;;; DESCRIPTION: ;;; ;;; This file uses a "Hellow world!" string which is in an another C ;;; file called hello_aux.c. Both hello.lisp and hello_aux.c are ;;; compiled and linked into either ;;; ;;; 1) a FASL file (see build_fasl.lisp) ;;; 2) a shared library (see build_dll.lisp) ;;; 3) or a standalone executable file. (build_exe.lisp) ;;; ;;; USE: ;;; ;;; Launch a copy of ECL and load this file in it ;;; ;;; (load "readme.lisp") ;;; (format t " ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; ;;; BUILDING A COMPOUND FASL FILE ;;; ") ;;; ;;; * We compile hello.lisp and hello_aux.c separately. ;;; (compile-file "hello.lisp" :system-p t) (c::compiler-cc "hello_aux.c" (compile-file-pathname "hello_aux.c" :type :object)) ;;; ;;; * We combine both in a single FASL file ;;; (defconstant +compound-fasl+ (compile-file-pathname "compound" :type :fasl)) (c::build-fasl +compound-fasl+ :lisp-files (list (compile-file-pathname "hello.lisp" :type :object)) :ld-flags (list (namestring (compile-file-pathname "hello_aux.c" :type :object)))) ;;; ;;; * We load both files ;;; (load +compound-fasl+) (format t " ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; ;;; BUILDING A STANDALONE EXECUTABLE ;;; ") ;; ;; * Combine files in a standalone executable. We reuse the files ;; from the previous example ;; (defconstant +standalone-exe+ (compile-file-pathname "standalone" :type :program)) (c::build-program +standalone-exe+ :lisp-files (list (compile-file-pathname "hello.lisp" :type :object)) :ld-flags (list (namestring (compile-file-pathname "hello_aux.c" :type :object))) :epilogue-code '(si::quit)) ;; ;; * Test the program ;; (si::system (format nil "./~A" +standalone-exe+)) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; ;;; CLEAN UP ;;; (delete-file (compile-file-pathname "hello.lisp" :type :object)) (delete-file (compile-file-pathname "hello_aux.c" :type :object)) (delete-file +compound-fasl+) (delete-file +standalone-exe+) ecl-16.1.2/examples/cmdline/000077500000000000000000000000001266352375300156115ustar00rootroot00000000000000ecl-16.1.2/examples/cmdline/ls.lsp000066400000000000000000000017671266352375300167620ustar00rootroot00000000000000#| To create a program called ls.exe type the following lines from a lisp prompt: (compile-file "ls.lsp" :output-file "ls.o" :system-p t) (c::build-program "ls" :lisp-files '("ls.o")) NOTE: The content of this file must match the example in the documentation. |# (setq ext:*help-message* " ls [--help | -?] filename* Lists the file that match the given patterns. ") (defun print-directory (pathnames) (format t "~{~A~%~}" (mapcar #'(lambda (x) (enough-namestring x (si::getcwd))) (mapcan #'directory (or pathnames '("*.*" "*/")))))) (defconstant +ls-rules+ '(("--help" 0 (progn (princ ext:*help-message* *standard-output*) (ext:quit 0))) ("-?" 0 (progn (princ ext:*help-message* *standard-output*) (ext:quit 0))) ("*DEFAULT*" 1 (print-directory 1) :stop))) (let ((ext:*lisp-init-file-list* NIL)) ; No initialization files (handler-case (ext:process-command-args :rules +ls-rules+) (error (c) (princ ext:*help-message* *error-output*) (ext:quit 1)))) (ext:quit 0) ecl-16.1.2/examples/embed/000077500000000000000000000000001266352375300152525ustar00rootroot00000000000000ecl-16.1.2/examples/embed/Makefile000066400000000000000000000006121266352375300167110ustar00rootroot00000000000000hello.exe: hello.c hello-lisp.a $(CC) `ecl-config --cflags` -o $@ hello.c hello-lisp.a \ `ecl-config --ldflags` -lecl hello-lisp.a: hello-lisp.lisp ecl -norc \ -eval '(require :asdf)' \ -eval '(push "./" asdf:*central-registry*)' \ -eval '(asdf:make-build :hello-lisp :type :static-library :move-here "./")' \ -eval '(quit)' clean: -rm -f hello-lisp.a hello.exe ecl-16.1.2/examples/embed/README000066400000000000000000000003411266352375300161300ustar00rootroot00000000000000This example shows how to compile a Common Lisp program using ECL and link it together with a C program. The example focuses on the building process, not on the C code needed to do various things with the embedded libraries. ecl-16.1.2/examples/embed/hello-lisp.asd000066400000000000000000000001001266352375300200020ustar00rootroot00000000000000(defsystem "hello-lisp" :components ((:file "hello-lisp"))) ecl-16.1.2/examples/embed/hello-lisp.lisp000066400000000000000000000000601266352375300202070ustar00rootroot00000000000000(defun hello-lisp () (format t "hello-lisp!~%"))ecl-16.1.2/examples/embed/hello.c000066400000000000000000000007031266352375300165210ustar00rootroot00000000000000#include #include int main (int argc, char **argv) { /* Initialize ECL */ cl_boot(argc, argv); /* Initialize the library we linked in. Each library * has to be initialized. It is best if all libraries * are joined using ASDF:MAKE-BUILD. */ extern void init_lib_HELLO_LISP(cl_object); ecl_init_module(NULL, init_lib_HELLO_LISP); cl_eval(c_string_to_object("(hello-lisp)")); cl_shutdown(); return 0; } ecl-16.1.2/examples/ffi/000077500000000000000000000000001266352375300147425ustar00rootroot00000000000000ecl-16.1.2/examples/ffi/cffi.lsp000066400000000000000000000015741266352375300164000ustar00rootroot00000000000000#| Build and load this module with (compile-file "cffi.lsp" :load t) |# ;; ;; This toplevel statement notifies the compiler that we will ;; need this shared library at runtime. We do not need this ;; statement in windows. ;; #-(or ming32 windows) (cffi:load-foreign-library #+darwin "/usr/lib/libm.dylib" #-darwin "/usr/lib/libm.so") ;; ;; With this other statement, we import the C function sin(), ;; which operates on IEEE doubles. ;; (cffi:defcfun ("sin" c-sin) :double :double) ;; ;; We now use this function and compare with the lisp version. ;; (format t "~%Lisp sin:~t~d~%C sin:~t~d~%Difference:~t~d" (sin 1.0d0) (c-sin 1.0d0) (- (sin 1.0d0) (c-sin 1.0d0))) ;; ;; The following also works: no declaration! ;; (let ((c-cos (cffi:foreign-funcall "cos" :double 1.0d0 :double))) (format t "~%Lisp cos:~t~d~%C cos:~t~d~%Difference:~t~d" (sin 1.0d0) c-sin (- (sin 1.0d0) c-sin))) ecl-16.1.2/examples/ffi/ecl.lsp000066400000000000000000000010351266352375300162240ustar00rootroot00000000000000#| Build and load this module with (compile-file "ecl.lsp" :load t) |# ;; ;; With this other statement, we import the C function sin(), which ;; operates on IEEE doubles. Notice that we include the C header to ;; get the full declaration. ;; (defun c-sin (x) (ffi:clines "#include ") (ffi:c-inline (x) (:double) :double "sin(#0)" :one-liner t)) ;; ;; We now use this function and compare with the lisp version. ;; (format t "~%Lisp sin:~t~d~%C sin:~t~d~%Difference:~t~d" (sin 1.0d0) (c-sin 1.0d0) (- (sin 1.0d0) (c-sin 1.0d0))) ecl-16.1.2/examples/ffi/uffi.lsp000066400000000000000000000013151266352375300164130ustar00rootroot00000000000000#| Build this module with (compile-file "uffi.lsp") Load it with (load "uffi.fas") |# ;; ;; This toplevel statement notifies the compiler that we will ;; need this shared library at runtime. We do not need this ;; statement in windows. ;; #-windows (uffi:load-foreign-library #+darwin "/usr/lib/libm.dylib" #-darwin "/usr/lib/libm.so") ;; ;; With this other statement, we import the C function sin(), ;; which operates on IEEE doubles. ;; (uffi:def-function ("sin" c-sin) ((arg :double)) :returning :double) ;; ;; We now use this function and compare with the lisp version. ;; (format t "~%Lisp sin:~t~d~%C sin:~t~d~%Difference:~t~d" (sin 1.0d0) (c-sin 1.0d0) (- (sin 1.0d0) (c-sin 1.0d0))) ecl-16.1.2/examples/threads/000077500000000000000000000000001266352375300156305ustar00rootroot00000000000000ecl-16.1.2/examples/threads/import/000077500000000000000000000000001266352375300171425ustar00rootroot00000000000000ecl-16.1.2/examples/threads/import/Makefile000066400000000000000000000001761266352375300206060ustar00rootroot00000000000000# # Read the comments in import.c # import.exe: import.c gcc -g `ecl-config --cflags` import.c -o $@ `ecl-config --ldflags` ecl-16.1.2/examples/threads/import/import.c000066400000000000000000000071461266352375300206300ustar00rootroot00000000000000/* import.c -- Execute Lisp code from C-generated threads */ /* Copyright (c) 2005, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #include #include #include /* * GOAL: To execute lisp code from threads which have not * been generated by our lisp environment. * * ASSUMES: ECL has been configured with threads (--enable-threads) * and installed somewhere on the path. * * COMPILE: Run "make" from the command line. * * * When this example is compiled and run, it generates a number of * threads, each one executing some interpreted code -- in this case * a bunch of PRINT statements. * * Importing other threads into lisp is possible if these threads have * been intercepted by the garbage collector. The way to do it is to * include the on the source code that generates the threads, * as we do here. This takes care of replacing calls to phtread_create * or CreateThread (in unix and Windows respectively) with the * GC_pthread_create and GC_CreateThread functions. */ /* Unfortunately, the Bohem-Weiser garbage collector does not keep track * of its configuration. We have to add the following flags by hand in * order to force pthread_create being redefined. */ #define GC_THREADS #define _REENTRANT #include #include static void * thread_entry_point(void *data) { cl_object form = (cl_object)data; /* * This is the entry point of the threads we have created. * These threads have no valid lisp environment. The following * routine initializes the lisp and makes it ready for working * in this thread. */ ecl_import_current_thread(Cnil, Cnil); /* * Here we execute some lisp code code. */ cl_eval(form); /* * Finally, when we exit the thread we have to release the * resources allocated by the lisp environment. */ ecl_release_current_thread(); return NULL; } int main(int narg, char **argv) { pthread_t child_thread; int i, code; /* * First of all, we have to initialize the ECL environment. * This should be done from the main thread. */ cl_boot(narg, argv); /* * Here we spawn 10 threads using the OS functions. The * current version is for Unix and uses pthread_create. * Since we have included , pthread_create will be * replaced with the appropiate routine from the garbage * collector. */ cl_object sym_print = c_string_to_object("PRINT"); /* * This array will keep the forms we want to evaluate from * being garbage collected. */ volatile cl_object forms[4]; for (i = 0; i < 4; i++) { forms[i] = cl_list(2, sym_print, MAKE_FIXNUM(i)); code = pthread_create(&child_thread, NULL, thread_entry_point, (void*)forms[i]); if (code) { printf("Unable to create thread\n"); exit(1); } } /* * Here we wait for the last thread to finish. */ pthread_join(child_thread, NULL); return 0; } ecl-16.1.2/examples/threads/import_win32/000077500000000000000000000000001266352375300201645ustar00rootroot00000000000000ecl-16.1.2/examples/threads/import_win32/Makefile000066400000000000000000000004701266352375300216250ustar00rootroot00000000000000all: @echo You must specify a compiler type: mingw or msvc mingw: import-mingw.exe import-mingw.exe: import.c gcc -g `ecl-config --cflags` import.c -o $@ `ecl-config --ldflags` msvc: import-msvc.exe import-msvc.exe: import.c ecl-cc --compile -c import.c ecl-cc --link -Fe$@ import.obj del /q import.obj ecl-16.1.2/examples/threads/import_win32/import.c000066400000000000000000000065111266352375300216450ustar00rootroot00000000000000/* import.c -- Execute Lisp code from C-generated threads */ /* Copyright (c) 2005, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #include #ifndef _MSC_VER # include # include #endif /* * GOAL: To execute lisp code from threads which have not * been generated by our lisp environment. * * ASSUMES: ECL has been configured with threads (--enable-threads) * and installed somewhere on the path. * * COMPILE: Run "make" from the command line. * * * When this example is compiled and run, it generates a number of * threads, each one executing some interpreted code -- in this case * a bunch of PRINT statements. * * Importing other threads into lisp is possible if these threads have * been intercepted by the garbage collector. The way to do it is to * include the on the source code that generates the threads, * as we do here. This takes care of replacing calls to phtread_create * or CreateThread (in unix and Windows respectively) with the * GC_pthread_create and GC_CreateThread functions. */ #include #ifdef _MSC_VER #define sleep(x) Sleep((x)*1000) #endif static DWORD WINAPI thread_entry_point(void *data) { cl_object form = (cl_object)data; /* * This is the entry point of the threads we have created. * These threads have no valid lisp environment. The following * routine initializes the lisp and makes it ready for working * in this thread. */ ecl_import_current_thread(Cnil, Cnil); /* * Here we execute some lisp code code. */ cl_eval(form); /* * Finally, when we exit the thread we have to release the * resources allocated by the lisp environment. */ ecl_release_current_thread(); return 1; } int main(int narg, char **argv) { HANDLE code; DWORD child_thread; int i; cl_object sym_print; /* * First of all, we have to initialize the ECL environment. * This should be done from the main thread. */ cl_boot(narg, argv); /* * Here we spawn 10 threads using the OS functions. The * current version is for Unix and uses pthread_create. * Since we have included , pthread_create will be * replaced with the appropiate routine from the garbage * collector. */ sym_print = c_string_to_object("PRINT"); for (i = 0; i < 10; i++) { cl_object form = cl_list(2, sym_print, MAKE_FIXNUM(i)); code = (HANDLE)CreateThread(NULL, 0, thread_entry_point, form, 0, &child_thread); if (code == NULL) { printf("Unable to create thread. Code: %d\n", GetLastError()); exit(1); } } /* * Here we wait for the last thread to finish. */ sleep(10); return 0; } ecl-16.1.2/msvc/000077500000000000000000000000001266352375300133305ustar00rootroot00000000000000ecl-16.1.2/msvc/Makefile000077500000000000000000000345711266352375300150050ustar00rootroot00000000000000# # Makefile for ECoLisp # top_srcdir= ..\src srcdir = ..\src # ============================================================= # ECL configuration # SHORT_SITE_NAME = LONG_SITE_NAME = ECL_VERSION = 16.1.2 ECL_VERSION_NUMBER= 161002 ARCHITECTURE = PENTIUM4 SOFTWARE_TYPE = NT SOFTWARE_VERSION = 5.0 THEHOST = win32 # Define to 1 to make a 64-bit build # ECL_WIN64 = # Define here the processor type to compile GMP library # with maximum optimization. Possible values are: # gc -> generic implementation # p0 -> Pentium processor # p3 -> Pentium III processor # p4 -> Pentium IV processor !if "$(GMP_TYPE)" == "" GMP_TYPE = gc !endif # Set it to non-empty to include Win32 thread support # Currently it is NOT SUPPORTED to build ECL without threads. The reason # is that certain exception handlers in Windows always use new threads. # Without them, ECL would be an even more fragile piece of software. ECL_THREADS = 1 # Set it to empty to remove support for Unicode characters ECL_UNICODE = 1 # Set it to non-empty to enable Win32 debug support #ECL_DEBUG = 1 # Set it to non-empty to support SSE2 intrinsics ECL_SSE = # Add the extensions to include in the build process. Comment any # of the following lines to remove a feature from the build process # LISP->C compiled ECL_CMP = # ASDF support ECL_ASDF = # TCP support ECL_SOCKETS = # X Windows support # ECL_CLX = 1 # Regression Tests support ECL_RT = # Defsystem support ECL_DEFSYS = # Profiling ECL_PROFILE = # (ECL configuration) # ============================================================= TAR_DIR = %CD%\ecl-$(ECL_VERSION) # Programs used by "make": # CC = cl LIBS = eclgc.lib eclgmp.lib user32.lib ws2_32.lib shell32.lib RM = del RMDIR = rmdir /Q /S MKDIR = mkdir EXE = .exe CP = copy /Y MV = move /Y MSDEV = msdev MKNSI = makensis.exe !if "$(YASM)" == "" YASM=yasm-1.2.0-win32.exe !endif # ==================== Flags ==================== !if "$(ECL_WIN64)" != "" GMP_BITS=64 GC_CPU=AMD64 ARCHITECTURE=AMD64 VCREDIST=vcredist_x64.exe !else GMP_BITS=32 GC_CPU=i386 ARCHITECTURE=PENTIUM4 VCREDIST=vcredist_x86.exe !if "$(ECL_SSE)" != "" CFLAGS_SSE=/arch:SSE2 !endif !endif # # Configuration-specific (Debug/Release) options # !if "$(ECL_DEBUG)" != "" CFLAGS_OPTIMIZE = /Od CFLAGS_CONFIG = /Zi /D_DEBUG /MDd $(CFLAGS_OPTIMIZE) $(CFLAGS_SSE) LDFLAGS_CONFIG = /debug /nodefaultlib:msvcrt.lib SHARED_LDFLAGS = /LDd GCFLAGS = !else CFLAGS_OPTIMIZE = /O2 CFLAGS_CONFIG = /DNDEBUG /MD $(CFLAGS_OPTIMIZE) $(CFLAGS_SSE) LDFLAGS_CONFIG = /nodefaultlib:msvcrtd.lib SHARED_LDFLAGS = /LD GCFLAGS = nodebug=1 !endif CFLAGS = /EHsc /DGC_DLL /DGC_BUILD /nologo /D_CRT_SECURE_NO_DEPRECATE $(CFLAGS_CONFIG) LDFLAGS = /link /incremental:no /nologo /nodefaultlib:libcmt /nodefaultlib:libcmtd /nodefaultlib:libc /nodefaultlib:libcd $(LDFLAGS_CONFIG) # Additional configuration for thread support # !if "$(ECL_THREADS)" == "" ENV_EXPORT = cl_env,DATA !else ENV_EXPORT = ecl_process_env CFLAGS = $(CFLAGS) DEF = ecl-threads.def !endif !MESSAGE C++ compiler flags: $(CFLAGS) !MESSAGE C++ linker flags: $(LDFLAGS) # ==================== Where To Install Things ==================== # The default location for installation. Everything is placed in # subdirectories of this directory. The default values for many of # the variables below are expressed in terms of this one, so you may # not need to change them. This defaults to /usr/local. prefix=%CD%\package exec_prefix=$(prefix) bindir=$(prefix) libdir=$(prefix) includedir=$(prefix) docdir=$(prefix)\doc # Programs used by "make install": # SHELL = @SHELL@ INSTALL = @INSTALL@ INSTALL_PROGRAM = @INSTALL_PROGRAM@ INSTALL_SCRIPT = @INSTALL_SCRIPT@ INSTALL_DATA = @INSTALL_DATA@ mkinstalldirs = $(top_srcdir)/bdwgc/install-sh -d # Files # SUBDIR = c gc gmp LIBRARIES = TARGETS = ecl2$(EXE) DEF = ecl.def # Additional modules # ECL_MODULES = ECL_FEATURES = (cons :wants-dlopen *features*) !ifdef ECL_CMP ECL_MODULES = $(ECL_MODULES) cmp ECL_FEATURES = (cons :wants-cmp $(ECL_FEATURES)) !endif !ifdef ECL_ASDF ECL_MODULES = $(ECL_MODULES) asdf ECL_FEATURES = (cons :wants-asdf $(ECL_FEATURES)) !endif !ifdef ECL_SOCKETS ECL_MODULES = $(ECL_MODULES) sockets ECL_FEATURES = (cons :wants-sockets $(ECL_FEATURES)) !endif !ifdef ECL_CLX ECL_MODULES = $(ECL_MODULES) clx ECL_FEATURES = (cons :wants-clx $(ECL_FEATURES)) !endif !ifdef ECL_RT ECL_MODULES = $(ECL_MODULES) rt ECL_FEATURES = (cons :wants-rt $(ECL_FEATURES)) !endif !ifdef ECL_DEFSYS ECL_MODULES = $(ECL_MODULES) defsystem ECL_FEATURES = (cons :wants-defsystem $(ECL_FEATURES)) !endif !ifdef ECL_PROFILE ECL_MODULES = $(ECL_MODULES) profile ECL_FEATURES = (cons :wants-profile $(ECL_FEATURES)) !endif ECL_MODULES = $(ECL_MODULES) bytecmp ECL_FEATURES = (list* :builtin-bytecmp :wants-bytecmp $(ECL_FEATURES)) ECL_MODULES = $(ECL_MODULES) ecl-curl ECL_FEATURES = (cons :wants-ecl-curl $(ECL_FEATURES)) ECL_MODULES = $(ECL_MODULES) deflate ECL_FEATURES = (cons :wants-deflate $(ECL_FEATURES)) !MESSAGE ECL Modules: $(ECL_MODULES) !MESSAGE ECL Features: $(ECL_FEATURES) # Build rules # all: $(TARGETS) ecl-config.bat ecl-cc.bat .PHONY: all %Makefile: $(srcdir)/%Makefile.in config.status ./config.status c\cut$(EXE): $(top_srcdir)\util\cut.c cd c $(MAKE) cut$(EXE) cd .. $(TARGETS): $(UCDDAT) ecl_min$(EXE) compile.lsp sysfun.lsp BUILD-STAMP set ECLDIR=./ ecl_min < compile.lsp BUILD-STAMP: Makefile date /t > $@ ecl-static.lib: $(TARGETS) link /lib /out:$@ eclmin.lib c\all_symbols2.obj lsp.lib eclgmp.lib eclgc.lib ecl_min$(EXE): $(LIBRARIES) eclmin.lib $(CC) /Fe$@ cinit.obj c\all_symbols.obj eclmin.lib $(LDFLAGS) $(LIBS) if exist ecl_min$(EXE).manifest \ mt -manifest ecl_min.exe.manifest -outputresource:ecl_min.exe;1 -$(RM) ecl_min.exp ecl_min.lib ecl_min$(EXE).manifest .gdbinit: $(srcdir)\util\gdbinit $(CP) $(srcdir)\util\gdbinit $@ lsp/config.lsp: $(srcdir)/lsp/config.lsp.in Makefile c\cut$(EXE) if not exist lsp $(MKDIR) lsp c\cut "@ecldir\@" "$(libdir:\=/)" \ "@SHORT_SITE_NAME@" "$(SHORT_SITE_NAME)" \ "@LONG_SITE_NAME@" "$(LONG_SITE_NAME)" \ "@PACKAGE_VERSION@" "$(ECL_VERSION)" \ "@ARCHITECTURE@" "$(ARCHITECTURE)" \ "@SOFTWARE_TYPE@" "$(SOFTWARE_TYPE)" \ "@SOFTWARE_VERSION@" "$(SOFTWARE_VERSION)" \ "@thehost@" "$(THEHOST)" \ "@true_srcdir@" "$(srcdir:\=/)" \ "@top_srcdir@" "$(top_srcdir:\=/)/" \ < $(srcdir)\lsp\config.lsp.in > lsp\config.lsp compile.lsp: bare.lsp $(srcdir)/compile.lsp.in Makefile c\cut "@ecldir\@" "$(libdir:\=/)" \ "@libdir\@" "$(libdir:\=/)" \ "@true_srcdir@" "$(srcdir:\=/)" \ "@true_builddir@" "$(MAKEDIR:\=/)" \ "@CFLAGS@" "$(CFLAGS) -DGC_BUILD" \ "@ECL_CFLAGS@" "" \ "@CPPFLAGS@" "" \ "@ECL_LDRPATH@" "" \ "@LDFLAGS@" "$(LDFLAGS)" \ "@SHARED_LDFLAGS@" "$(SHARED_LDFLAGS)" \ "@BUNDLE_LDFLAGS@" "$(SHARED_LDFLAGS)" \ "@CLIBS@" "user32.lib ws2_32.lib shell32.lib" \ "@STATICLIBS@" "eclgmp.lib eclgc.lib" \ "@LIBS@" "user32.lib ws2_32.lib shell32.lib" \ "@CORE_LIBS@" "" \ "@FASL_LIBS@" "" \ "@OBJEXT@" "obj" \ "@SHAREDPREFIX@" "" \ "@SHAREDEXT@" "lib" \ "@LIBPREFIX@" "" \ "@LIBEXT@" "lib" \ "@EXEEXT@" ".exe" \ "@LDINSTALLNAME@" "" \ "@DEF@" "$(DEF)" \ "@RANLIB@" "ranlib" \ "@LSP_FEATURES@" "$(ECL_FEATURES)" \ "@ECL_CMPDIR@" "cmp" \ "@ECL_EXTRA_LISP_FILES@" "" \ "@ECL_INIT_FORM@" "(si::top-level t)" \ < $(srcdir)\compile.lsp.in > compile.lsp bare.lsp: $(srcdir)/bare.lsp.in lsp/load.lsp clos/load.lsp cmp/load.lsp cmp/cmpdefs.lsp c\cut "@true_srcdir@" "$(srcdir:\=/)" \ "@top_srcdir@" "$(srcdir:\=/)" \ "@true_builddir@" "$(MAKEDIR:\=/)"\ "@ECL_CMPDIR@" "cmp" < $(srcdir)\bare.lsp.in > bare.lsp lsp/load.lsp: $(srcdir)/lsp/load.lsp.in $(CP) $(srcdir)\lsp\load.lsp.in lsp\load.lsp clos/load.lsp: $(srcdir)/clos/load.lsp.in if not exist clos $(MKDIR) clos $(CP) $(srcdir)\clos\load.lsp.in clos\load.lsp cmp/load.lsp: $(srcdir)/cmp/load.lsp.in if not exist cmp $(MKDIR) cmp $(CP) $(srcdir)\cmp\load.lsp.in cmp\load.lsp cmp/cmpdefs.lsp: $(srcdir)/cmp/cmpdefs.lsp Makefile c\cut "@ECL_CC@" "$(CC)" \ "@CC_IS_CXX@" "nil" \ "@CFLAGS@" "$(CFLAGS)" \ "@CFLAGS_OPTIMIZE@" "$(CFLAGS_OPTIMIZE)" \ "@ECL_CFLAGS@" "" \ "@CPPFLAGS@" "" \ "@ECL_LDRPATH@" "" \ "@LDFLAGS@" "$(LDFLAGS)" \ "@SHARED_LDFLAGS@" "$(SHARED_LDFLAGS)" \ "@BUNDLE_LDFLAGS@" "$(SHARED_LDFLAGS)" \ "@CLIBS@" "user32.lib ws2_32.lib shell32.lib" \ "@STATICLIBS@" "eclgmp.lib eclgc.lib" \ "@OBJEXT@" "obj" \ "@SHAREDPREFIX@" "" \ "@SHAREDEXT@" "dll" \ "@LIBPREFIX@" "" \ "@LIBEXT@" "lib" \ "@EXEEXT@" ".exe" \ "@ecldir\@" "NIL" \ "@libdir\@" "NIL" \ "@includedir\@" "NIL" \ < $(srcdir)\cmp\cmpdefs.lsp > cmp\cmpdefs.lsp ecl-config.bat: util\ecl-config.bat Makefile c\cut "~A" "$(libdir:\=/)"\ "~*" "" \ "@ECL_CFLAGS@" "$(CFLAGS)" \ "@LDFLAGS@" "$(LDFLAGS)" \ "@CLIBS@" "" \ "@libdir@" "$(prefix:\=/)" \ "@includedir@" "$(prefix:\=/)/ecl" \ < util\ecl-config.bat > ecl-config.bat ecl-cc.bat: util\ecl-cc.bat Makefile c\cut "@ECL_CFLAGS@" "$(CFLAGS)" \ "@LDFLAGS@" "$(LDFLAGS)" \ "@CLIBS@" "" \ "@libdir@" "$(prefix:\=/)" \ "@includedir@" "$(prefix:\=/)/ecl" \ < util\ecl-cc.bat > ecl-cc.bat eclmin.lib: eclgmp.lib eclgc.lib lsp/config.lsp cd c $(MAKE) ECL_VERSION_NUMBER=$(ECL_VERSION_NUMBER) \ ECL_THREADS=$(ECL_THREADS) ECL_UNICODE=$(ECL_UNICODE) \ ECL_SSE=$(ECL_SSE) ECL_WIN64=$(ECL_WIN64) \ "ECL_CFLAGS=$(CFLAGS) -DGC_BUILD" cd .. eclgc.lib: cd gc $(MAKE) $(GCFLAGS) ECL_THREADS=$(ECL_THREADS) "CFLAGS_CONFIG=$(CFLAGS_CONFIG)" "MY_CPU=$(GC_CPU)" gc.lib $(CP) gc.lib ..\eclgc.lib cd .. if not exist ecl\gc $(MKDIR) ecl\gc if not exist ecl\gc\private $(MKDIR) ecl\gc\private for %h in (gc.h gc_version.h gc_local_alloc.h gc_pthread_redirects.h \ gc_config_macros.h leak_detector.h gc_typed.h \ private\gc_priv.h private\gcconfig.h gc_mark.h \ new_gc_alloc.h weakpointer.h gc_pthread_redirects.h) \ do $(CP) $(srcdir)\bdwgc\include\%h ecl\gc\%h eclgmp.lib: cd gmp $(MAKE) "MPN_TYPE=$(GMP_TYPE)" "CFLAGS_CONFIG=$(CFLAGS_CONFIG)" \ "BITS=$(GMP_BITS)" "YASM=$(YASM)" $(CP) gmp.lib ..\eclgmp.lib $(CP) gmp.h ..\ecl\gmp.h cd .. sysfun.lsp: $(CP) $(srcdir)\cmp\sysfun.lsp .\ rt.lisp: $(CP) $(srcdir)\..\contrib\rt\rt.lisp .\ install: IF NOT EXIST "$(prefix)" $(MKDIR) "$(prefix)" IF NOT EXIST "$(bindir)" $(MKDIR) "$(bindir)" for %i in ($(TARGETS) ecl.dll) do $(CP) %i "$(bindir)\%i" IF EXIST "$(bindir)\ecl2$(EXE)" $(MV) "$(bindir)\ecl2$(EXE)" "$(bindir)\ecl$(EXE)" IF EXIST ecl2$(EXE).manifest $(CP) ecl2$(EXE).manifest "$(bindir)\ecl$(EXE).manifest" IF EXIST ecl.dll.manifest $(CP) ecl.dll.manifest "$(bindir)" $(CP) ecl-config.bat "$(bindir)\ecl-config.bat" $(CP) ecl-cc.bat "$(bindir)\ecl-cc.bat" IF NOT EXIST "$(includedir)\ecl" $(MKDIR) "$(includedir)\ecl" IF NOT EXIST "$(includedir)\ecl\gc" $(MKDIR) $(includedir)\ecl\gc IF NOT EXIST "$(includedir)\ecl\gc\private" $(MKDIR) "$(includedir)\ecl\gc\private" for %i in (ecl\*.h ecl\gc\*.h ecl\gc\private\*.h) do $(CP) %i $(includedir)\%i IF EXIST "$(include)\ecl\atomic_ops" rmdir /S /Q "$(include)\ecl\atomic_ops" IF EXIST "ecl\atomic_ops" xcopy /S /Y "ecl\atomic_ops" "$(includedir)\atomic_ops\" cd c $(MAKE) cut.exe cd .. c\cut.exe < ecl\config.h > $(includedir)\ecl\config.h IF NOT EXIST "$(libdir)" $(MKDIR) "$(libdir)" IF NOT EXIST "$(libdir)\ecl" $(MKDIR) "$(libdir)\ecl" for %i in ($(LIBRARIES) c\dpp.exe BUILD-STAMP help.doc ecl.lib) do $(CP) %i "$(libdir)" for /f %i in ('type MODULES') do $(CP) %i "$(libdir)" for %i in (ecl-static.lib) do IF EXIST %i $(CP) %i "$(libdir)" IF NOT EXIST "$(docdir)" $(MKDIR) "$(docdir)" for %i in (..\Copyright ..\LGPL ..\README.1st ..\CHANGELOG) do $(CP) %i "$(docdir)" !if "$(ECL_UNICODE)" != "" IF NOT EXIST "$(libdir)\encodings" $(MKDIR) "$(libdir)\encodings" $(CP) encodings\*.* "$(libdir)\encodings" !endif check: package\ecl.exe cd tests $(MAKE) recheck: package\ecl.exe cd tests $(MAKE) clean $(MAKE) package\ecl.exe: ecl2$(EXE) $(MAKE) install ECL_THREADS=$(ECL_THREADS) ECL_UNICODE=$(ECL_UNICODE) windows-nsi: IF EXIST "$(TAR_DIR)" $(RMDIR) "$(TAR_DIR)" $(MKDIR) "$(TAR_DIR)" $(MAKE) prefix="$(TAR_DIR)" install ECL_UNICODE=$(ECL_UNICODE) IF EXIST "$(VCREDIST)" $(CP) "$(VCREDIST)" "$(TAR_DIR)" util\ecl_nsi.bat %%CD%%\"$(srcdir)"\util\ecl.nsi "$(TAR_DIR)" $(ECL_VERSION) "$(MKNSI)" "$(TAR_DIR)/ecl.nsi" $(MV) $(TAR_DIR)\Setup.exe ecl-$(ECL_VERSION).exe # $(RMDIR) $(TAR_DIR) clean: clean_ecl clean_lisp -$(RM) .gdbinit cinit.lib ecl_min.lib -$(RM) bdwgc\*.pdb cd gc -$(MAKE) ECL_THREADS=$(ECL_THREADS) clean cd .. -for %h in (gc.h gc_local_alloc.h gc_pthread_redirects.h \ gc_config_macros.h leak_detector.h gc_typed.h \ gc_mark.h private\gc_priv.h private\gcconfig.h) \ do $(RM) ecl\gc\%h -$(RMDIR) ecl\gc\private -$(RMDIR) ecl\gc cd gmp -$(MAKE) ECL_THREADS=$(ECL_THREADS) clean cd .. -$(RM) ecl\gmp.h clean_ecl: -for %i in (eclgc.lib eclgmp.lib lsp\config.lsp compile.lsp bare.lsp \ lsp\load.lsp clos\load.lsp cmp\load.lsp cmp\cmpdefs.lsp \ ecl.lib ecl.dll ecl_min$(EXE) eclmin.lib help.doc sysfun.lsp \ BUILD-STAMP $(TARGETS) *.exp *.ilk *.manifest *.pdb *.c *.obj \ ecl-config.bat ecl-static.lib *.tmp *.implib *.lib ecl.ico \ ecl-cc.bat ecl.rc ecl.res) \ do $(RM) %i cd c -$(MAKE) ECL_THREADS=$(ECL_THREADS) clean cd .. clean_lisp: -for %i in (lsp clos $(ECL_MODULES)) do for %k in (%i.lib %i.fas %i.ilk %i.c %i.obj %i.pdb) do $(RM) %k -for %i in (lsp clos ext $(ECL_MODULES)) do $(RMDIR) %i -for %i in ( *.fas *.implib *.lib *.asd) do $(RM) %i -$(RM) help.doc -$(RM) MODULES distclean: clean realclean: distclean test1: cd c; $(MAKE) $(MAKE) ecl_min $(MAKE) ecl cd tests; $(MAKE) diff tests tests2 test2: $(MAKE) clean_lisp cd c; $(MAKE) $(MAKE) ecl_min $(RM) ecl $(MAKE) ecl for i in lsp clos cmp; do diff --exclude=\*.o $$i old/$$i; done test3: -mkdir stage2 cp -rf lsp clos cmp stage2 -for i in lsp cmp clos clx tk; do test -f lib$$i.a && mv lib$$i.a stage2; done $(MAKE) clean_lisp ./ecl < compile.lsp -for i in lsp clos cmp clx tk; do test -d $$i && diff --exclude=\*.o $$i stage2/$$i; done | less test: $(MAKE) -C tests $(MAKE) -C ansi-tests > ansi-tests/log # -(diff tests ~/src/tests; diff --exclude log ansi-tests ~/src/ansi-tests) | less ecl-16.1.2/msvc/c/000077500000000000000000000000001266352375300135525ustar00rootroot00000000000000ecl-16.1.2/msvc/c/Makefile000077500000000000000000000126531266352375300152240ustar00rootroot00000000000000# # Makefile for ECL core library # top_srcdir = ..\..\src srcdir = ..\..\src\c !if "$(ECL_WIN64)" != "" ECL_FFI_OBJ= ECL_FPE_CODE=fpe_none.c !else ECL_FFI_OBJ=ffi_x86.obj ECL_FPE_CODE=fpe_x86.c !endif !if "$(ECL_THREADS)" != "" ECL_THREADS_FLAG=1 THREADS_OBJ= process.obj mutex.obj condition_variable.obj rwlock.obj \ semaphore.obj barrier.obj mailbox.obj atomic.obj queue.obj !else ECL_THREADS_FLAG=0 THREADS_OBJ= !endif !if "$(ECL_UNICODE)" != "" ECL_UNICODE_FLAG=21 ECL_UCD_OBJ = ucd.obj ucd-0000.obj ucd-0016.obj \ ucd-0032.obj ucd-0048.obj ucd-0064.obj \ ucd-0080.obj ucd-0096.obj !else ECL_UNICODE_FLAG=0 !endif !if "$(ECL_SSE)" != "" ECL_SSE_FLAG=1 ECL_SSE_OBJ=sse2.obj !else ECL_SSE_FLAG=0 ECL_SSE_OBJ= !endif # Programs used by "make": # TRUE_CC = cl CC = cl CFLAGS = -c $(ECL_CFLAGS) -DECL_API="__declspec(dllexport)" -I./ -I../ -I$(srcdir) -I$(top_srcdir)/bdwgc/include -I$(top_srcdir)/bdwgc/include/private SHELL = /bin/sh RM = del CP = copy /Y MV = move /Y LINK = link EXE = .exe DPP = .\dpp$(EXE) # Data for installation # INSTALL = @INSTALL@ INSTALL_DATA = @INSTALL_DATA@ prefix=@prefix@ exec_prefix=$(prefix) libdir=$(prefix)\lib\ecl # Files HDIR = $(top_srcdir)\h HFILES = ..\ecl\config.h ..\ecl\atomic_ops.h $(HDIR)\ecl.h $(HDIR)\ecl-cmp.h\ $(HDIR)\object.h $(HDIR)\cs.h $(HDIR)\stacks.h\ $(HDIR)\external.h $(HDIR)\cons.h $(HDIR)\legacy.h\ $(HDIR)\number.h $(HDIR)\page.h $(HDIR)\unify.h\ $(HDIR)\internal.h $(HDIR)\ecl-inl.h $(HDIR)\bytecodes.h \ $(HDIR)\impl\math_dispatch.h OBJS = main.obj symbol.obj package.obj cons.obj list.obj\ apply.obj eval.obj \ interpreter.obj compiler.obj disassembler.obj \ instance.obj gfun.obj cache.obj accessor.obj \ reference.obj character.obj\ file.obj read.obj print.obj error.obj string.obj cfun.obj\ parse_integer.obj parse_number.obj \ float_to_digits.obj float_to_string.obj \ integer_to_string.obj write_ugly.obj \ write_object.obj write_symbol.obj \ write_array.obj write_list.obj write_code.obj \ write_sse.obj print_unreadable.obj \ libraries.obj backtrace.obj mmap.obj cdata.obj \ cos.obj sin.obj tan.obj atan.obj \ cosh.obj sinh.obj tanh.obj \ exp.obj expt.obj log.obj \ sqrt.obj abs.obj \ zerop.obj plusp.obj minusp.obj \ negate.obj conjugate.obj \ one_plus.obj one_minus.obj \ plus.obj minus.obj times.obj divide.obj \ number_compare.obj number_equalp.obj minmax.obj \ floor.obj ceiling.obj round.obj truncate.obj \ typespec.obj assignment.obj \ predicate.obj big.obj number.obj\ num_pred.obj num_arith.obj num_co.obj\ num_log.obj num_rand.obj array.obj vector_push.obj \ sequence.obj cmpaux.obj\ macros.obj backq.obj stacks.obj \ time.obj unixint.obj\ mapfun.obj multival.obj hash.obj format.obj pathname.obj\ structure.obj load.obj unixfsys.obj unixsys.obj \ ffi.obj alloc_2.obj tcp.obj $(THREADS_OBJ) serialize.obj \ $(ECL_FFI_OBJ) $(ECL_UCD_OBJ) $(ECL_SSE_OBJ) all: $(DPP) ..\eclmin.lib ..\cinit.obj .SUFFIXES: .obj .c .d {$(srcdir:\=/)}.d{}.c: $(DPP) $< $@ {$(srcdir:\=/)/arch}.d{}.c: $(DPP) $< $@ {$(srcdir:\=/)/clos/}.d{}.c: $(DPP) $< $@ {$(srcdir:\=/)/reader}.d{}.c: $(DPP) $< $@ {$(srcdir:\=/)/printer}.d{}.c: $(DPP) $< $@ {$(srcdir:\=/)/ffi}.d{}.c: $(DPP) $< $@ {$(srcdir:\=/)/unicode}.c{}.c: $(DPP) $< $@ {$(srcdir:\=/)/numbers}.d{}.c: $(DPP) $< $@ {$(srcdir:\=/)/threads}.d{}.c: $(DPP) $< $@ #.d.c: # $(DPP) $< $@ .c.obj: $(CC) $(CFLAGS) /Fo$@ $< .PHONY: all cut.exe: $(top_srcdir)/util/cut.c $(CC) $(LDFLAGS) /Fecut.exe $(top_srcdir)/util/cut.c ..\eclmin.lib: $(OBJS:.obj=.c) all_symbols.c $(OBJS) all_symbols.obj all_symbols2.obj -$(RM) $@ $(LINK) -lib -out:$@ $(OBJS) clean: -for %f in ($(OBJS:.obj=.c) all_symbols.c) do $(RM) %f -for %f in ($(OBJS) all_symbols.obj all_symbols2.obj) do $(RM) %f -$(RM) *.pdb -for %f in (..\ecl\config.h dpp dpp.obj $(DPP) cut.exe cut.obj \ ..\eclmin.lib ..\cinit.obj cinit.c symbols_list2.h) \ do $(RM) %f -for %f in (..\ecl\*.h) do $(RM) %f -for %f in (cut.exe cut.obj dpp.exe dpp.obj) do $(RM) %f -del /S /Q ..\ecl\atomic* # Build rules $(DPP): $(srcdir)/dpp.c $(srcdir)/symbols_list2.h ../ecl/config.h $(TRUE_CC) -I.. -I./ $(srcdir)/dpp.c -o $@ $(HFILES): ../ecl/config.h.msvc6 Makefile -mkdir ..\ecl\impl cut.exe "@ECL_FPE_CODE@" "$(srcdir:\=/)/arch/$(ECL_FPE_CODE)" \ "@ECL_VERSION_NUMBER@" "$(ECL_VERSION_NUMBER)" \ "@ECL_THREADS@" "$(ECL_THREADS_FLAG)" \ "@ECL_UNICODE@" "$(ECL_UNICODE_FLAG)" \ "@ECL_SSE2@" "$(ECL_SSE_FLAG)" \ < ..\ecl\config.h.msvc6 > $@ xcopy /SYI $(top_srcdir)\h\* ..\ecl -mkdir ..\ecl\atomic_ops -mkdir ..\ecl\atomic_ops\sysdeps xcopy /SYI $(top_srcdir)\bdwgc\libatomic_ops\src\atomic_ops.h ..\ecl xcopy /SYI $(top_srcdir)\bdwgc\libatomic_ops\src\atomic_ops\generalize*.h ..\ecl\atomic_ops xcopy /SYI $(top_srcdir)\bdwgc\libatomic_ops\src\atomic_ops\sysdeps\* ..\ecl\atomic_ops\sysdeps xcopy /SYI $(top_srcdir)\bdwgc\libatomic_ops\src\atomic_ops\ao_version.h ..\ecl\atomic_ops # # GCC might break this code # gbc.o: gbc.c $(HFILES) $(CC) $(CFLAGS) -O0 gbc.c /Fo$@ # # This reduces the overhead of jumping to other functions # apply.o: apply.c $(HFILES) $(HDIR)/cs.h $(CC) $(CFLAGS) apply.c /Fo$@ # # These files are interrelated # all_symbols.obj: all_symbols.c $(CC) $(CFLAGS) -Fo$@ -I../ -I./ all_symbols.c all_symbols2.obj: all_symbols.c $(CC) $(CFLAGS) -DECL_FINAL -Fo$@ -I../ -I./ all_symbols.c # # This is in another directory # ../cinit.obj: cinit.c $(CC) $(CFLAGS) -I../ -I./ /Focinit.obj cinit.c $(MV) cinit.obj ..\ ecl-16.1.2/msvc/c/clos/000077500000000000000000000000001266352375300145125ustar00rootroot00000000000000ecl-16.1.2/msvc/c/clos/placeholder000066400000000000000000000000001266352375300167050ustar00rootroot00000000000000ecl-16.1.2/msvc/c/ffi/000077500000000000000000000000001266352375300143165ustar00rootroot00000000000000ecl-16.1.2/msvc/c/ffi/placeholder000066400000000000000000000000001266352375300165110ustar00rootroot00000000000000ecl-16.1.2/msvc/c/numbers/000077500000000000000000000000001266352375300152255ustar00rootroot00000000000000ecl-16.1.2/msvc/c/numbers/placeholder000066400000000000000000000000001266352375300174200ustar00rootroot00000000000000ecl-16.1.2/msvc/c/printer/000077500000000000000000000000001266352375300152355ustar00rootroot00000000000000ecl-16.1.2/msvc/c/printer/placeholder000066400000000000000000000000001266352375300174300ustar00rootroot00000000000000ecl-16.1.2/msvc/c/reader/000077500000000000000000000000001266352375300150145ustar00rootroot00000000000000ecl-16.1.2/msvc/c/reader/placeholder000066400000000000000000000000001266352375300172070ustar00rootroot00000000000000ecl-16.1.2/msvc/c/threads/000077500000000000000000000000001266352375300152045ustar00rootroot00000000000000ecl-16.1.2/msvc/c/threads/placeholder000066400000000000000000000000001266352375300173770ustar00rootroot00000000000000ecl-16.1.2/msvc/doc/000077500000000000000000000000001266352375300140755ustar00rootroot00000000000000ecl-16.1.2/msvc/doc/Makefile000066400000000000000000000125541266352375300155440ustar00rootroot00000000000000top_srcdir= ..\..\src srcdir = ..\..\src\doc prefix=@prefix@ exec_prefix=$(prefix)\bin infodir = $(prefix)\doc\info mandir=$(prefix)\doc\man docdir=$(prefix)\doc manext=1 INFOEXT = info SHELL = cmd.exe INSTALL = ..\install.bat INSTALL_PROGRAM = $(INSTALL) INSTALL_DATA = $(INSTALL) INSTALL_INFO = $(INSTALL) mkinstalldirs = $(SHELL) $(top_srcdir)/gc/mkinstalldirs.bat INFO_FILES = ecl.$(INFOEXT) ecldev.$(INFOEXT) HTML_FILES = index.html license.html lgpl.html news.html benchmark.html \ install.html download.html RM = erase RMDIR = rmdir /S /Q MKDIR = mkdir CP = copy /Y ECL_VERSION=0.9f FILTER = ..\c\cut$(EXE) "@PACKAGE_VERSION@" "$(ECL_VERSION)" ECL = ../ecl all: $(INFO_FILES) $(HTML_FILES) developers_manual user_manual clx_manual ecl.dvi: $(srcdir)/user.txi $(srcdir)/macros.txi clisp.sty ecl.sty tex $(srcdir)/user.txi ecldev.dvi: $(srcdir)/devel.txi $(srcdir)/macros.txi clisp.sty ecl.sty tex $(srcdir)/devel.txi clx.dvi: clx.texinfo tex clx.texinfo ecl.ps: ecl.dvi $(srcdir)/macros.txi dvips -o $@ ecl.dvi ecldev.ps: ecldev.dvi $(srcdir)/macros.txi dvips -o $@ ecldev.dvi clx.ps: clx.dvi dvips -o $@ clx.dvi install: all IF NOT EXIST $(docdir) $(MKDIR) $(docdir) for %i in (Copyright LGPL) do $(CP) $(top_srcdir)\..\%i $(docdir) for %i in ($(HTML_FILES)) do $(CP) %i $(docdir) IF NOT EXIST $(docdir)\ecldev $(MKDIR) $(docdir)\ecldev for %i in (ecldev\*) do $(CP) %i $(docdir)\ecldev IF NOT EXIST $(docdir)\ecl $(MKDIR) $(docdir)\ecl for %i in (ecl\*) do $(CP) %i $(docdir)\ecl IF NOT EXIST $(docdir)\clx $(MKDIR) $(docdir)\clx for %i in (clx\*) do $(CP) %i $(docdir)\clx flatinstall: all IF NOT EXIST $(docdir) $(MKDIR) $(docdir) for %i in (Copyright LGPL) do $(CP) $(top_srcdir)\..\%i $(docdir) for %i in ($(HTML_FILES)) do $(CP) %i $(docdir) IF NOT EXIST $(docdir)\ecldev $(MKDIR) $(docdir)\ecldev for %i in (ecldev\*) do $(CP) %i $(docdir)\ecldev IF NOT EXIST $(docdir)\ecl $(MKDIR) $(docdir)\ecl for %i in (ecl\*) do $(CP) %i $(docdir)\ecl IF NOT EXIST $(docdir)\clx $(MKDIR) $(docdir)\clx for %i in (clx\*) do $(CP) %i $(docdir)\clx uninstall: for k in $(INFO_FILES); do \ rm $$k; \ if [ -x $(INSTALL_INFO) ]; then \ $(INSTALL_INFO) --delete $$k; \ fi; \ done rm -r $(infodir)/ecl.$(INFOEXT) $(infodir)/ecldev.$(INFOEXT); \ rm $(mandir)/man$(manext)/ecl.$(manext) head2: developers_manual user_manual clx_manual $(srcdir)/head Makefile IF EXIST ecl\index.html ( \ ..\c\cut.exe "ecl/user.html" "ecl/index.html" \ "ecldev/devel.html" "ecldev/index.html" \ < $(srcdir)/head > head2 \ ) ELSE ( \ copy /y $(srcdir)/head head2 \ ) ecl.info.gz: ecl.info gzip < ecl.info > ecl.info.gz ecldev.info.gz: ecldev.info gzip < ecldev.info > ecldev.info.gz clx.info.gz: clx.info gzip < clx.info > clx.info.gz ecl.info: $(srcdir)/user.txi $(srcdir)/macros.txi makeinfo -I $(srcdir) --no-split $(srcdir)/user.txi ecldev.info: $(srcdir)/devel.txi $(srcdir)/macros.txi makeinfo -I $(srcdir) --no-split $(srcdir)/devel.txi clx.info: clx.texinfo makeinfo --no-split clx.texinfo clx.texinfo: $(top_srcdir)/clx/manual/clx.texinfo cp $(top_srcdir)/clx/manual/clx.texinfo . download.html: $(srcdir)/download.in.html head2 ( type head2 $(srcdir)\download.in.html $(srcdir)\end ) | $(FILTER) > $@ index.html: $(srcdir)/index.in.html head2 ( type head2 $(srcdir)\index.in.html $(srcdir)\end ) | $(FILTER) > $@ install.html: $(srcdir)/install.in.html head2 ( type head2 $(srcdir)\install.in.html $(srcdir)\end ) | $(FILTER) > $@ news.html: $(srcdir)\..\..\ANNOUNCEMENT head2 type head2 > html_tmp echo "
" >> html_tmp
	type $(srcdir)\..\..\ANNOUNCEMENT >> html_tmp
	echo "
" >> html_tmp type $(srcdir)\end >> html_tmp $(FILTER) < html_tmp > $@ $(RM) html_tmp benchmark.html: $(srcdir)/benchmark.in.html ../gabriel/BENCHMARK head2 type head2 > html_tmp type $(srcdir)\benchmark.in.html >> html_tmp echo "
" >> html_tmp
	type ..\gabriel\BENCHMARK >> html_tmp
	echo "
" >> html_tmp type $(srcdir)\end >> html_tmp $(FILTER) < html_tmp > $@ $(RM) html_tmp ../gabriel/BENCHMARK: if not exist ..\gabriel $(MKDIR) ..\gabriel echo No benchmarks available > ..\gabriel\BENCHMARK license.html: $(top_srcdir)/../Copyright head2 type head2 > html_tmp echo "
" >> html_tmp
	type $(top_srcdir)\..\Copyright >> html_tmp
	echo "
" >> html_tmp type $(srcdir)\end >> html_tmp $(FILTER) < html_tmp > $@ $(RM) html_tmp lgpl.html: $(top_srcdir)/../LGPL head2 type head2 > html_tmp echo "
" >> html_tmp
	type $(top_srcdir)\..\LGPL >> html_tmp
	echo "
" >> html_tmp type $(srcdir)\end >> html_tmp $(FILTER) < html_tmp > $@ $(RM) html_tmp user_manual: $(srcdir)/user.txi $(srcdir)/macros.txi echo "Producing ecl.html; ignore error messages." IF NOT EXIST ecl MKDIR ecl makeinfo -v -I $(srcdir) --html $(srcdir)/user.txi echo > user_manual developers_manual: $(srcdir)/devel.txi $(srcdir)/macros.txi echo "Producing ecldev.html; ignore error messages." IF NOT EXIST ecldev MKDIR ecldev makeinfo -v -I $(srcdir) --html $(srcdir)/devel.txi echo > developers_manual clx_manual: $(srcdir)/../clx/manual/clx.texinfo echo "Producing clx.html; ignore error messages." IF NOT EXIST clx MKDIR clx makeinfo -v --html $(srcdir)\..\clx\manual\clx.texinfo echo > clx_manual clean: -for %i in (ecl ecldev clx ..\gabriel) do $(RMDIR) %i -for %i in (ecl.info* ecldev.info* $(HTML_FILES) head2 user_manual developers_manual clx_manual ..\gabriel\BENCHMARK) do $(RM) %i ecl-16.1.2/msvc/ecl/000077500000000000000000000000001266352375300140735ustar00rootroot00000000000000ecl-16.1.2/msvc/ecl/config.h.msvc6000077500000000000000000000301131266352375300165470ustar00rootroot00000000000000/* config.h.in -- Template configuration file. */ /* Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECoLisp is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #define ECL_MS_WINDOWS_HOST /* * If ECL_API has been predefined, that means we are building the core * library and, under windows, we must tell the compiler to export * extern functions from the shared library. * If ECL_API is not defined, we are simply building an application that * uses ECL and, under windows, we must tell the compiler that certain * will be imported from a DLL. */ #if defined(mingw32) || defined(_MSC_VER) || defined(cygwin) # define ECL_DLLEXPORT __declspec(dllexport) # ifdef ECL_API # undef ECL_API # define ECL_API __declspec(dllexport) # else # define ECL_API __declspec(dllimport) # endif #else # define ECL_DLLEXPORT # ifdef ECL_API # undef ECL_API # endif # define ECL_API #endif /* Decimal number made with the formula yymmvv */ #define ECL_VERSION_NUMBER @ECL_VERSION_NUMBER@ /* * FEATURES LINKED IN */ /* Always use CLOS */ #define CLOS /* Use GNU Multiple Precision library for bignums */ #define WITH_GMP 1 #include /* Userland threads? */ #define ECL_THREADS @ECL_THREADS@ #if ECL_THREADS # define GC_WIN32_THREADS # define GC_THREADS # define ECL_WINDOWS_THREADS #else # undef ECL_THREADS #endif /* __thread thread-local variables? */ /* #undef WITH___THREAD */ /* Use Windows's interlocked operations to define compare-and-swap */ #define AO_ASSUME_WINDOWS98 /* Use Boehm's garbage collector */ #define GBC_BOEHM 0 #ifdef GBC_BOEHM # define GC_WIN32_THREADS /* For older versions */ # define GC_THREADS /* For >= 7.2 */ # include # define ECL_DYNAMIC_VV #endif #define ECL_LIBATOMIC_OPS_H /* Network streams */ #define TCP 1 #if defined(TCP) && (defined(_MSC_VER) || defined(mingw32)) # define ECL_WSOCK #endif /* Foreign functions interface */ #define ECL_FFI /* Support for Unicode strings */ #define ECL_UNICODE @ECL_UNICODE@ #if !ECL_UNICODE # undef ECL_UNICODE #endif /* Allow STREAM operations to work on arbitrary objects */ #define ECL_CLOS_STREAMS 1 /* Stack grows downwards */ #define ECL_DOWN_STACK 1 /* We have libffi and can use it */ /*#undef HAVE_LIBFFI*/ /* We have non-portable implementation of FFI calls */ #ifndef _M_X64 # define ECL_DYNAMIC_FFI 1 #endif /* We use hierarchical package names, like in Allegro CL */ #define ECL_RELATIVE_PACKAGE_NAMES 1 /* Use mprotect for fast interrupt dispatch */ /* #undef ECL_USE_MPROTECT */ #if defined(_MSC_VER) || defined(mingw32) # define ECL_USE_GUARD_PAGE #endif /* Integer types */ #define ecl_uint8_t unsigned char #define ecl_int8_t char #define ecl_uint16_t unsigned short #define ecl_int16_t short #define ecl_uint32_t unsigned int #define ecl_int32_t int #define ecl_uint64_t unsigned __int64 #define ecl_int64_t __int64 #define ecl_long_long_t long long #define ecl_ulong_long_t unsigned long long /* * C TYPES AND SYSTEM LIMITS */ /* * The integer type * * cl_fixnum must be an integer type, large enough to hold a pointer. * Ideally, according to the ISOC99 standard, we should use intptr_t, * but the required headers are not present in all systems. Hence we * use autoconf to guess the following values. */ #ifdef _M_X64 #define ECL_INT_BITS 64 #define ECL_LONG_BITS 32 #define ECL_FIXNUM_BITS 64 #define MOST_POSITIVE_FIXNUM ((cl_fixnum)2305843009213693951LL) #define MOST_NEGATIVE_FIXNUM ((cl_fixnum)-2305843009213693952LL) typedef long long cl_fixnum; typedef unsigned long long cl_index; typedef unsigned long long cl_hashkey; #else #define ECL_INT_BITS 32 #define ECL_LONG_BITS 32 #define ECL_FIXNUM_BITS 32 #define MOST_POSITIVE_FIXNUM ((cl_fixnum)536870911) #define MOST_NEGATIVE_FIXNUM ((cl_fixnum)-536870912) typedef int cl_fixnum; typedef unsigned int cl_index; typedef unsigned int cl_hashkey; #endif /* * The character type */ #ifdef ECL_UNICODE #define ECL_CHAR_CODE_LIMIT 1114112 /* unicode character code limit */ #else #define ECL_CHAR_CODE_LIMIT 256 /* unicode character code limit */ #endif typedef int ecl_character; typedef unsigned char ecl_base_char; /* * Array limits */ #define ECL_ARRAY_RANK_LIMIT 64 #ifdef GBC_BOEHM #define ECL_ARRAY_DIMENSION_LIMIT 536870911 #else #define ECL_ARRAY_DIMENSION_LIMIT 16*1024*1024 #endif #define ECL_ARRAY_TOTAL_LIMIT ECL_ARRAY_DIMENSION_LIMIT /* * Function limits. * * In general, any of these limits must fit in a "signed int". */ /* Maximum number of function arguments */ #define ECL_CALL_ARGUMENTS_LIMIT 65536 /* Maximum number of required arguments */ #define ECL_LAMBDA_PARAMETERS_LIMIT ECL_CALL_ARGUMENTS_LIMIT /* Numb. of args. which can be passed using the C stack */ /* See cmplam.lsp if you change this value */ #define ECL_C_ARGUMENTS_LIMIT 64 /* Maximum number of output arguments */ #define ECL_MULTIPLE_VALUES_LIMIT 64 /* A setjmp that does not save signals */ #define ecl_setjmp setjmp #define ecl_longjmp longjmp /* * Structure/Instance limits. The index to a slot must fit in the * "int" type. We also require ECL_SLOTS_LIMIT <= CALL_ARGUMENTS_LIMIT * because constructors typically require as many arguments as slots, * or more. */ #define ECL_SLOTS_LIMIT 32768 /* compiler understands long double */ /* #undef ECL_LONG_FLOAT */ /* compiler understands complex */ /* #undef HAVE_DOUBLE_COMPLEX */ /* #undef HAVE_FLOAT_COMPLEX */ /* Missing integer types */ typedef char int8_t; typedef short int16_t; typedef int int32_t; typedef unsigned char uint8_t; typedef unsigned short uint16_t; typedef unsigned int uint32_t; /* We can use small, two-words conses, without type information */ /* #undef ECL_SMALL_CONS */ #define ECL_INLINE #define ecl_likely(form) (form) #define ecl_unlikely(form) (form) #define ecl_attr_noreturn #if defined(__SSE2__) || (defined(_M_IX86_FP) && _M_IX86_FP >= 2) #define ECL_SSE2 @ECL_SSE2@ #if !ECL_SSE2 #undef ECL_SSE2 #endif #endif /* -CUT-: Everything below this mark will not be installed */ /* -------------------------------------------------------------------- * * BUILD OPTIONS WHICH NEED NOT BE EXPORTED * * -------------------------------------------------------------------- */ /* * FEATURES LINKED IN: */ /* CLX */ #define CLX 1 /* Locatives */ /* #undef LOCATIVE */ /* Use old MIT LOOP macro system */ /* #undef ECL_OLD_LOOP */ /* Define this if you want a runtime version only without compiler */ /* #undef RUNTIME */ /* Profile tool */ /* #undef PROFILE */ /* Program Development Environment */ /* #undef PDE */ /* Allow loading dynamically linked code */ #define ENABLE_DLOPEN 1 /* Undefine this if you do not want ECL to check for circular lists */ #define ECL_SAFE /* Use CMU Common-Lisp's FORMAT routine */ #define ECL_CMU_FORMAT 1 /* Bytecodes and arguments are 8 and 16 bits large, respectively */ /* #undef ECL_SMALL_BYTECODES */ /* Assembler implementation of APPLY and friends */ /* #undef ECL_ASM_APPLY */ /* Activate Boehm-Weiser incremental garbage collector */ /* #undef GBC_BOEHM_GENGC */ #define ECL_WEAK_HASH /* * SYSTEM FEATURES: */ /* Arguments cannot be accessed as array */ /* #undef NO_ARGS_ARRAY */ /* Most significant byte first */ /* #undef WORDS_BIGENDIAN */ /* Has */ /* #undef HAVE_SYS_RESOURCE_H */ /* #undef HAVE_ULIMIT_H */ /* High precision timer */ /* #undef HAVE_NANOSLEEP */ /* Float version if isnan() */ /* #undef HAVE_ISNANF */ /* float.h for epsilons, maximum real numbers, etc */ #define HAVE_FLOAT_H 1 /* select() */ /* #undef HAVE_SELECT */ /* #undef HAVE_SYS_SELECT_H */ /* #undef HAVE_SYS_IOCTL_H */ /* putenv() or setenv() */ #undef HAVE_SETENV #define HAVE_PUTENV 1 /* times() and sys/times.h */ /* #undef HAVE_TIMES */ /* gettimeofday() and sys/time.h */ /* #undef HAVE_GETTIMEOFDAY */ /* getrusage() and sys/resource.h */ /* #undef HAVE_GETRUSAGE */ /* user home directory, user name, etc... */ /* #undef HAVE_PW_H */ /* symbolic links and checking their existence */ /* #undef HAVE_LSTAT */ /* safe creation of temporary files */ /* #undef HAVE_MKSTEMP */ /* timer for userland threads */ /* #undef HAVE_ALARM */ /* filesytem */ /* #undef HAVE_DIRENT_H */ /* dynamic linking of libraries */ /* #undef HAVE_DLFCN_H */ /* #undef HAVE_LINK_H */ /* #undef HAVE_MACH_O_DYLD_H */ /* POSIX signals */ /* #undef HAVE_SIGPROCMASK */ /* isatty() checks whether a file is connected to a */ #define HAVE_ISATTY 1 /* can manipulate floating point environment */ /* #undef HAVE_FENV_H */ /* can activate individual traps in floating point environment */ /* #undef HAVE_FEENABLEEXCEPT */ /* do we want to deactivate all support for floating point exceptions */ /* #undef ECL_AVOID_FPE_H */ /* do we want to have signed zeros */ #define ECL_SIGNED_ZERO 1 /* do we want NaNs and Infs */ #define ECL_IEEE_FP 1 /* has support for large files */ /* #undef HAVE_FSEEKO */ /* compiler understands long long */ #define HAVE_LONG_LONG 1 /* the tzset() function gets the current time zone */ #define HAVE_TZSET 1 /* several floating point functions (ISO C99) */ #if 0 #undef HAVE_EXPF #undef HAVE_LOGF #undef HAVE_SQRTF #undef HAVE_COSF #undef HAVE_SINF #undef HAVE_TANF #undef HAVE_SINHF #undef HAVE_COSHF #undef HAVE_TANHF #endif #define HAVE_FLOORF #define HAVE_CEILF #define HAVE_FABSF #define HAVE_FREXPF #define HAVE_LDEXPF #define HAVE_LOG1PL /* whether we have sched_yield() that gives priority to other threads */ /* #undef HAVE_SCHED_YIELD */ /* uname() for system identification */ /* #undef HAVE_UNAME */ /* #undef HAVE_UNISTD_H */ /* #undef HAVE_SYS_WAIT_H */ /* size of long long */ #define ECL_LONG_LONG_BITS 64 /* * we do not manage to get proper signal handling of floating point * arithmetics in the Alpha chips. */ #if defined(__alpha__) # ifdef HAVE_FENV_H # undef HAVE_FENV_H # endif # ifdef HAVE_FEENABLEEXCEPT # undef HAVE_FEENABLEEXCEPT # endif #endif /* what characters are used to mark beginning of new line */ #define ECL_NEWLINE_IS_CRLF 1 /* #undef ECL_NEWLINE_IS_LFCR */ /* * PARAMETERS: */ /* * Memory limits for the old garbage collector. */ #define LISP_PAGESIZE 2048 /* Page size in bytes */ #define MAXPAGE 16384 /* Maximum Memory Size */ /* We reserve these many bytes for computation with bignums registers */ #define BIGNUM_REGISTER_SIZE 16 /* We allocate a number of strings in a pool which is used to speed up reading */ #define ECL_MAX_STRING_POOL_SIZE 10 #define ECL_BUFFER_STRING_SIZE 128 /* * Macros that depend on these system features. */ #if defined(sparc) || defined(i386) || defined(mips) # define stack_align(n) (((n) + 0x7) & ~0x7) #else # define stack_align(n) (((n) + 03) & ~03) #endif /* #undef FILE_CNT */ #if 0 == 1 # define FILE_CNT(fp) ((fp)->_IO_read_end - (fp)->_IO_read_ptr) #endif #if 0 == 2 # define FILE_CNT(fp) ((fp)->_r) #endif #if 3 == 3 # define FILE_CNT(fp) ((fp)->_cnt) #endif #if defined(cygwin) || defined(mingw32) || defined(_MSC_VER) # define IS_DIR_SEPARATOR(x) ((x=='/')||(x=='\\')) # define DIR_SEPARATOR '/' # define PATH_SEPARATOR ';' #else # define IS_DIR_SEPARATOR(x) (x=='/') # define DIR_SEPARATOR '/' # define PATH_SEPARATOR ':' #endif #define ECL_ARCHITECTURE "PENTIUM4" #ifdef ECL_AVOID_FPE_H # define ecl_detect_fpe() #else # include "@ECL_FPE_CODE@" #endif #define strcasecmp _stricmp #define isnan _isnan #define finite _finite #define sleep _sleep #include "@ECL_FPE_CODE@" #include #ifndef isfinite # define isfinite(x) (finite(x)) # define signbit(x) (_copysign(1.0,(x)) < 0) # define ECL_MATHERR_CLEAR # define ECL_MATHERR_TEST #endif ecl-16.1.2/msvc/gc/000077500000000000000000000000001266352375300137215ustar00rootroot00000000000000ecl-16.1.2/msvc/gc/Makefile000077500000000000000000000040031266352375300153610ustar00rootroot00000000000000# Makefile for Windows NT. Assumes Microsoft compiler. # DLLs are included in the root set under NT, but not under win32S. # Use "nmake nodebug=1 all" for optimized versions of library, gctest and editor. # MY_CPU=i386 for 32 bits or AMD64 for 64 bits CPU=$(MY_CPU) #!include srcdir=..\..\src\bdwgc !if "$(ECL_THREADS)" != "" THREADS_OBJ= win32_threads.obj thread_local_alloc.obj THREADS_FLAGS= -D_CRT_SECURE_NO_WARNINGS -DGC_DLL -DGC_BUILD -DGC_WIN32_THREADS -DTHREAD_LOCAL_ALLOC -DLARGE_CONFIG !else THREADS_OBJ= THREADS_FLAGS= -D_CRT_SECURE_NO_WARNINGS -DGC_DLL -DGC_BUILD -DLARGE_CONFIG !endif # Make sure that .cc is not viewed as a suffix. It is for VC++2005, but # not earlier versions. We can deal with either, but not inconsistency. .SUFFIXES: .SUFFIXES: .obj .cpp .c # Atomic_ops installation directory. For win32, the source directory # should do, since we only need the headers. # We assume this was manually unpacked, since I'm not sure there is # a Windows standard command line tool to do this. AO_SRC_DIR=$(srcdir)/libatomic_ops/src AO_INCLUDE_DIR=$(AO_SRC_DIR) OBJS= alloc.obj reclaim.obj allchblk.obj misc.obj mach_dep.obj os_dep.obj mark_rts.obj headers.obj mark.obj obj_map.obj blacklst.obj finalize.obj new_hblk.obj dbg_mlc.obj fnlz_mlc.obj malloc.obj stubborn.obj dyn_load.obj typd_mlc.obj ptr_chck.obj gc_cpp.obj mallocx.obj win32_threads.obj msvc_dbg.obj thread_local_alloc.obj all: gc.lib {$(srcdir)\extra}.c{}.obj: $(CC) -c -DWIN32 -D_MT $(CFLAGS_CONFIG) -Iinclude -I$(AO_INCLUDE_DIR) $(THREADS_FLAGS) -I$(srcdir)\include $< /Fo$*.obj {$(srcdir)}.c{}.obj: $(CC) -c -DWIN32 -D_MT $(CFLAGS_CONFIG) -Iinclude -I$(AO_INCLUDE_DIR) $(THREADS_FLAGS) -I$(srcdir)\include $< /Fo$*.obj {$(srcdir)}.cpp{}.obj: $(CC) -c -DWIN32 -D_MT $(CFLAGS_CONFIG) -Iinclude -I$(AO_INCLUDE_DIR) $(THREADS_FLAGS) -I$(srcdir)\include $< /Fo$*.obj gc.lib: $(OBJS) !if "$(CPU)" == "i386" lib /MACHINE:i386 /out:gc.lib $(OBJS) !else lib /MACHINE:X64 /out:gc.lib $(OBJS) !endif gc_cpp.cpp: $(srcdir)\gc_cpp.cc copy $? $@ ecl-16.1.2/msvc/gmp/000077500000000000000000000000001266352375300141135ustar00rootroot00000000000000ecl-16.1.2/msvc/gmp/Makefile000077500000000000000000000367301266352375300155670ustar00rootroot00000000000000srcdir = ..\..\src\gmp # # Change for other configurations # !if "$(BITS)" == "64" YASM_TARGET=win64 YASM_FLAGS=-D PIC D_WIN64=/D "WIN64" !if "$(MPN_TYPE)" == "" MPN_TYPE=amd64 !endif BITS=64 !else YASM_TARGET=win32 YASM_FLAGS= D_WIN64= BITS=32 !if "$(MPN_TYPE)" == "" MPN_TYPE=p3 !endif !endif !if "$(YASM)" == "" YASM=yasm-1.2.0-win32.exe !endif # for amd MPN_AMD64_C_SOURCES = \ mpn\generic\add.c \ mpn\generic\add_1.c \ mpn\generic\add_n.c \ mpn\generic\addmul_1.c \ mpn\generic\addsub_n.c \ mpn\generic\bdivmod.c \ mpn\generic\cmp.c \ mpn\generic\dc_divrem_n.c \ mpn\generic\dive_1.c \ mpn\generic\diveby3.c \ mpn\generic\divis.c \ mpn\generic\divrem.c \ mpn\generic\divrem_1.c \ mpn\generic\divrem_2.c \ mpn\generic\dump.c \ mpn\generic\fib2_ui.c \ mpn\generic\gcd.c \ mpn\generic\gcd_1.c \ mpn\generic\gcdext.c \ mpn\generic\get_d.c \ mpn\generic\get_str.c \ mpn\generic\jacbase.c \ mpn\generic\lshift.c \ mpn\generic\mod_1.c \ mpn\generic\mod_34lsub1.c \ mpn\generic\mode1o.c \ mpn\generic\mul.c \ mpn\generic\mul_1.c \ mpn\generic\mul_basecase.c \ mpn\generic\mul_fft.c \ mpn\generic\mul_n.c \ mpn\generic\mullow_basecase.c \ mpn\generic\mullow_n.c \ mpn\generic\perfsqr.c \ .\mpn\generic\popham2.c \ mpn\generic\pow_1.c \ mpn\generic\pre_divrem_1.c \ mpn\generic\pre_mod_1.c \ mpn\generic\random.c \ mpn\generic\random2.c \ mpn\generic\rootrem.c \ mpn\generic\rshift.c \ mpn\generic\sb_divrem_mn.c \ mpn\generic\scan0.c \ mpn\generic\scan1.c \ mpn\generic\set_str.c \ mpn\generic\sizeinbase.c \ mpn\generic\sqr_basecase.c \ mpn\generic\sqrtrem.c \ mpn\generic\sub.c \ mpn\generic\sub_1.c \ mpn\generic\sub_n.c \ mpn\generic\submul_1.c \ mpn\generic\tdiv_qr.c # for p4 MPN_P4_C_SOURCES = \ mpn\generic\add.c \ mpn\generic\add_1.c \ mpn\generic\addsub_n.c \ mpn\generic\bdivmod.c \ mpn\generic\cmp.c \ mpn\generic\dc_divrem_n.c \ mpn\generic\diveby3.c \ mpn\generic\divis.c \ mpn\generic\divrem.c \ mpn\generic\divrem_2.c \ mpn\generic\dump.c \ mpn\generic\fib2_ui.c \ mpn\generic\gcd.c \ mpn\generic\gcd_1.c \ mpn\generic\gcdext.c \ mpn\generic\get_d.c \ mpn\generic\get_str.c \ mpn\generic\jacbase.c \ mpn\generic\mul.c \ mpn\generic\mul_fft.c \ mpn\generic\mul_n.c \ mpn\generic\mullow_basecase.c \ mpn\generic\mullow_n.c \ mpn\generic\perfsqr.c \ mpn\generic\pow_1.c \ mpn\generic\pre_divrem_1.c \ mpn\generic\pre_mod_1.c \ mpn\generic\random.c \ mpn\generic\random2.c \ mpn\generic\rootrem.c \ mpn\generic\sb_divrem_mn.c \ mpn\generic\scan0.c \ mpn\generic\scan1.c \ mpn\generic\set_str.c \ mpn\generic\sizeinbase.c \ mpn\generic\sqrtrem.c \ mpn\generic\sub.c \ mpn\generic\sub_1.c \ mpn\generic\tdiv_qr.c # for p3 MPN_P3_C_SOURCES = \ mpn\generic\add.c \ mpn\generic\add_1.c \ mpn\generic\addsub_n.c \ mpn\generic\bdivmod.c \ mpn\generic\cmp.c \ mpn\generic\dc_divrem_n.c \ mpn\generic\diveby3.c \ mpn\generic\divis.c \ mpn\generic\divrem.c \ mpn\generic\divrem_2.c \ mpn\generic\dump.c \ mpn\generic\fib2_ui.c \ mpn\generic\gcd.c \ mpn\generic\gcd_1.c \ mpn\generic\gcdext.c \ mpn\generic\get_d.c \ mpn\generic\get_str.c \ mpn\generic\jacbase.c \ mpn\generic\mul.c \ mpn\generic\mul_fft.c \ mpn\generic\mul_n.c \ mpn\generic\mullow_basecase.c \ mpn\generic\mullow_n.c \ mpn\generic\perfsqr.c \ mpn\generic\pow_1.c \ mpn\generic\random.c \ mpn\generic\random2.c \ mpn\generic\rootrem.c \ mpn\generic\sb_divrem_mn.c \ mpn\generic\scan0.c \ mpn\generic\scan1.c \ mpn\generic\set_str.c \ mpn\generic\sizeinbase.c \ mpn\generic\sqrtrem.c \ mpn\generic\sub.c \ mpn\generic\sub_1.c \ mpn\generic\tdiv_qr.c MPN_GC_SOURCES = \ mpn\generic\add.c \ mpn\generic\add_1.c \ mpn\generic\add_n.c \ mpn\generic\addmul_1.c \ .\mpn\generic\addsub_n.c \ mpn\generic\bdivmod.c \ mpn\generic\cmp.c \ mpn\generic\dc_divrem_n.c \ mpn\generic\dive_1.c \ mpn\generic\diveby3.c \ mpn\generic\divis.c \ mpn\generic\divrem.c \ .\mpn\generic\divrem_1.c \ .\mpn\generic\divrem_2.c \ mpn\generic\dump.c \ mpn\generic\fib2_ui.c \ mpn\generic\gcd.c \ mpn\generic\gcd_1.c \ mpn\generic\gcdext.c \ mpn\generic\get_d.c \ mpn\generic\get_str.c \ mpn\generic\jacbase.c \ mpn\generic\lshift.c \ mpn\generic\mod_1.c \ mpn\generic\mod_34lsub1.c \ mpn\generic\mode1o.c \ mpn\generic\mul.c \ mpn\generic\mul_1.c \ mpn\generic\mul_basecase.c \ mpn\generic\mul_fft.c \ mpn\generic\mul_n.c \ mpn\generic\mullow_basecase.c \ mpn\generic\mullow_n.c \ mpn\generic\perfsqr.c \ .\mpn\generic\popham2.c \ mpn\generic\pow_1.c \ mpn\generic\pre_divrem_1.c \ mpn\generic\pre_mod_1.c \ mpn\generic\random.c \ mpn\generic\random2.c \ mpn\generic\rootrem.c \ mpn\generic\rshift.c \ mpn\generic\sb_divrem_mn.c \ mpn\generic\scan0.c \ mpn\generic\scan1.c \ mpn\generic\set_str.c \ mpn\generic\sizeinbase.c \ mpn\generic\sqr_basecase.c \ mpn\generic\sqrtrem.c \ mpn\generic\sub.c \ mpn\generic\sub_1.c \ mpn\generic\sub_n.c \ mpn\generic\submul_1.c \ mpn\generic\tdiv_qr.c MPF_SOURCES = \ mpf\abs.c \ mpf\add.c \ mpf\add_ui.c \ mpf\ceilfloor.c \ mpf\clear.c \ mpf\cmp.c \ mpf\cmp_d.c \ mpf\cmp_si.c \ mpf\cmp_ui.c \ mpf\div.c \ mpf\div_2exp.c \ mpf\div_ui.c \ mpf\dump.c \ mpf\eq.c \ mpf\fits_sint.c \ mpf\fits_slong.c \ mpf\fits_sshort.c \ mpf\fits_uint.c \ mpf\fits_ulong.c \ mpf\fits_ushort.c \ mpf\get_d.c \ mpf\get_d_2exp.c \ mpf\get_dfl_prec.c \ mpf\get_prc.c \ mpf\get_si.c \ mpf\get_str.c \ mpf\get_ui.c \ mpf\init.c \ mpf\init2.c \ mpf\inp_str.c \ mpf\int_p.c \ mpf\iset.c \ mpf\iset_d.c \ mpf\iset_si.c \ mpf\iset_str.c \ mpf\iset_ui.c \ mpf\mul.c \ mpf\mul_2exp.c \ mpf\mul_ui.c \ mpf\neg.c \ mpf\out_str.c \ mpf\pow_ui.c \ mpf\random2.c \ mpf\reldiff.c \ mpf\set.c \ mpf\set_d.c \ mpf\set_dfl_prec.c \ mpf\set_prc.c \ mpf\set_prc_raw.c \ mpf\set_q.c \ mpf\set_si.c \ mpf\set_str.c \ mpf\set_ui.c \ mpf\set_z.c \ mpf\size.c \ mpf\sqrt.c \ mpf\sqrt_ui.c \ mpf\sub.c \ mpf\sub_ui.c \ mpf\swap.c \ mpf\trunc.c \ mpf\ui_div.c \ mpf\ui_sub.c \ mpf\urandomb.c \ MPZ_SOURCES = \ mpz\abs.c \ mpz\add.c \ mpz\add_ui.c \ mpz\and.c \ mpz\aorsmul.c \ mpz\aorsmul_i.c \ mpz\array_init.c \ mpz\bin_ui.c \ mpz\bin_uiui.c \ mpz\cdiv_q.c \ mpz\cdiv_q_ui.c \ mpz\cdiv_qr.c \ mpz\cdiv_qr_ui.c \ mpz\cdiv_r.c \ mpz\cdiv_r_ui.c \ mpz\cdiv_ui.c \ mpz\cfdiv_q_2exp.c \ mpz\cfdiv_r_2exp.c \ mpz\clear.c \ mpz\clrbit.c \ mpz\cmp.c \ mpz\cmp_d.c \ mpz\cmp_si.c \ mpz\cmp_ui.c \ mpz\cmpabs.c \ mpz\cmpabs_d.c \ mpz\cmpabs_ui.c \ mpz\com.c \ mpz\combit.c \ mpz\cong.c \ mpz\cong_2exp.c \ mpz\cong_ui.c \ mpz\dive_ui.c \ mpz\divegcd.c \ mpz\divexact.c \ mpz\divis.c \ mpz\divis_2exp.c \ mpz\divis_ui.c \ mpz\dump.c \ mpz\export.c \ mpz\fac_ui.c \ mpz\fdiv_q.c \ mpz\fdiv_q_ui.c \ mpz\fdiv_qr.c \ mpz\fdiv_qr_ui.c \ mpz\fdiv_r.c \ mpz\fdiv_r_ui.c \ mpz\fdiv_ui.c \ mpz\fib2_ui.c \ mpz\fib_ui.c \ mpz\fits_sint.c \ mpz\fits_slong.c \ mpz\fits_sshort.c \ mpz\fits_uint.c \ mpz\fits_ulong.c \ mpz\fits_ushort.c \ mpz\gcd.c \ mpz\gcd_ui.c \ mpz\gcdext.c \ mpz\get_d.c \ mpz\get_d_2exp.c \ mpz\get_si.c \ mpz\get_str.c \ mpz\get_ui.c \ mpz\getlimbn.c \ mpz\hamdist.c \ mpz\import.c \ mpz\init.c \ mpz\init2.c \ mpz\inp_raw.c \ mpz\inp_str.c \ mpz\invert.c \ mpz\ior.c \ mpz\iset.c \ mpz\iset_d.c \ mpz\iset_si.c \ mpz\iset_str.c \ mpz\iset_ui.c \ mpz\lcm.c \ mpz\lcm_ui.c \ mpz\lucnum2_ui.c \ mpz\lucnum_ui.c \ mpz\millerrabin.c \ mpz\mod.c \ mpz\mul.c \ mpz\mul_2exp.c \ mpz\mul_si.c \ mpz\mul_ui.c \ mpz\n_pow_ui.c \ mpz\neg.c \ mpz\nextprime.c \ mpz\out_raw.c \ mpz\out_str.c \ mpz\perfpow.c \ mpz\perfsqr.c \ mpz\popcount.c \ mpz\pow_ui.c \ mpz\powm.c \ mpz\powm_ui.c \ mpz\pprime_p.c \ mpz\random.c \ mpz\random2.c \ mpz\realloc.c \ mpz\realloc2.c \ mpz\remove.c \ mpz\root.c \ mpz\rootrem.c \ mpz\rrandomb.c \ mpz\scan0.c \ mpz\scan1.c \ mpz\set.c \ .\mpz\set_d.c \ mpz\set_f.c \ mpz\set_q.c \ mpz\set_si.c \ mpz\set_str.c \ mpz\set_ui.c \ mpz\setbit.c \ mpz\size.c \ mpz\sizeinbase.c \ mpz\sqrt.c \ mpz\sqrtrem.c \ mpz\sub.c \ mpz\sub_ui.c \ mpz\swap.c \ mpz\tdiv_q.c \ mpz\tdiv_q_2exp.c \ mpz\tdiv_q_ui.c \ mpz\tdiv_qr.c \ mpz\tdiv_qr_ui.c \ mpz\tdiv_r.c \ mpz\tdiv_r_2exp.c \ mpz\tdiv_r_ui.c \ mpz\tdiv_ui.c \ mpz\tstbit.c \ mpz\ui_pow_ui.c \ mpz\ui_sub.c \ mpz\urandomb.c \ mpz\urandomm.c \ mpz\xor.c GMP_SOURCES = \ assert.c \ compat.c \ errno.c \ extract-dbl.c \ invalid.c \ memory.c \ mp_bpl.c \ mp_clz_tab.c \ mp_dv_tab.c \ mp_get_fns.c \ mp_minv_tab.c \ mp_set_fns.c \ rand.c \ randbui.c \ randclr.c \ randdef.c \ randiset.c \ randlc2s.c \ randlc2x.c \ randmt.c \ randmts.c \ randmui.c \ rands.c \ randsd.c \ randsdui.c \ tal-reent.c \ version.c \ mp_bases.c \ fib_table.c MPN_AMD64_ASM_SOURCES = \ mpn\amd64i\aors_n.asm \ mpn\amd64i\aorsmul_1.asm \ mpn\amd64i\copyd.asm \ mpn\amd64i\copyi.asm \ mpn\amd64i\dive_1.asm \ mpn\amd64i\lshift.asm \ mpn\amd64i\mode1o.asm \ mpn\amd64i\mul_1.asm \ mpn\amd64i\mul_basecase.asm \ mpn\amd64i\rshift.asm \ mpn\amd64i\sqr_basecase.asm MPN_P4_ASM_SOURCES = \ mpn\x86i\aors_n.asm \ mpn\x86i\aorsmul_1.asm \ mpn\x86i\pentium4\copyd.asm \ mpn\x86i\pentium4\copyi.asm \ mpn\x86i\dive_1.asm \ mpn\x86i\diveby3.asm \ mpn\x86i\divrem_1.asm \ mpn\x86i\lshift.asm \ mpn\x86i\mod_1.asm \ mpn\x86i\mod_34lsub1.asm \ mpn\x86i\mul_1.asm \ mpn\x86i\mul_basecase.asm \ mpn\x86i\rshift.asm \ mpn\x86i\udiv.asm \ mpn\x86i\umul.asm \ mpn\x86i\pentium4\mmx\lshift.asm \ mpn\x86i\pentium4\mmx\popham.asm \ mpn\x86i\pentium4\mmx\rshift.asm \ mpn\x86i\pentium4\sse2\add_n.asm \ mpn\x86i\pentium4\sse2\addmul_1.asm \ mpn\x86i\pentium4\sse2\dive_1.asm \ mpn\x86i\pentium4\sse2\diveby3.asm \ mpn\x86i\pentium4\sse2\mod_34lsub1.asm \ mpn\x86i\pentium4\sse2\mode1o.asm \ mpn\x86i\pentium4\sse2\mul_1.asm \ mpn\x86i\pentium4\sse2\mul_basecase.asm \ mpn\x86i\pentium4\sse2\sqr_basecase.asm \ mpn\x86i\pentium4\sse2\sub_n.asm \ mpn\x86i\pentium4\sse2\submul_1.asm MPN_P3_ASM_SOURCES = \ mpn\x86i\aors_n.asm \ mpn\x86i\p6\aorsmul_1.asm \ mpn\x86i\p6\copyd.asm \ mpn\x86i\copyi.asm \ mpn\x86i\p6\dive_1.asm \ mpn\x86i\p6\diveby3.asm \ mpn\x86i\divrem_1.asm \ mpn\x86i\lshift.asm \ mpn\x86i\p6\mod_1.asm \ mpn\x86i\mod_34lsub1.asm \ mpn\x86i\p6\mode1o.asm \ mpn\x86i\mul_1.asm \ mpn\x86i\mul_basecase.asm \ mpn\x86i\rshift.asm \ mpn\x86i\p6\sqr_basecase.asm \ mpn\x86i\udiv.asm \ mpn\x86i\umul.asm \ mpn\x86i\p6\mmx\divrem_1.asm \ mpn\x86i\p6\mmx\lshift.asm \ mpn\x86i\p6\mmx\popham.asm \ mpn\x86i\p6\p3mmx\popham.asm \ mpn\x86i\p6\mmx\rshift.asm MPN_GC_OBJS = $(MPN_GC_SOURCES:.c=.obj) #MPN_P0_OBJS = $(MPN_P0_ASM_SOURCES:.asm=.obj) $(MPN_P0_C_SOURCES:.c=.obj) MPN_P3_OBJS = $(MPN_P3_ASM_SOURCES:.asm=.obj) $(MPN_P3_C_SOURCES:.c=.obj) MPN_P4_OBJS = $(MPN_P4_ASM_SOURCES:.asm=.obj) $(MPN_P4_C_SOURCES:.c=.obj) MPN_AMD64_OBJS = $(MPN_AMD64_ASM_SOURCES:.asm=.obj) $(MPN_AMD64_C_SOURCES:.c=.obj) # MPZ_OBJS = $(MPZ_SOURCES:.c=.obj) GMP_OBJS = $(GMP_SOURCES:.c=.obj) GMP_ALL_OBJS = $(MPZ_OBJS) $(GMP_OBJS) AUTO_FILES = mp_bases.h mp_bases.c fac_ui.h fib_table.h fib_table.c perfsqr.h all: $(AUTO_FILES) gmp.lib mpn_gc.lib: msvc-build $(MPN_GC_OBJS) link -lib /NOLOGO /OUT:$@ $(MPN_GC_OBJS) mpn_p0.lib: msvc-build $(MPN_P0_OBJS) link -lib /NOLOGO /OUT:$@ $(MPN_P0_OBJS) mpn_p3.lib: msvc-build $(MPN_P3_OBJS) link -lib /NOLOGO /OUT:$@ $(MPN_P3_OBJS) mpn_p4.lib: msvc-build $(MPN_P4_OBJS) link -lib /NOLOGO /OUT:$@ $(MPN_P4_OBJS) mpn_amd64.lib: msvc-build $(MPN_AMD64_OBJS) link -lib /NOLOGO /OUT:$@ $(MPN_AMD64_OBJS) gmp.lib: mpn_$(MPN_TYPE).lib $(GMP_ALL_OBJS) link -lib /NOLOGO /OUT:$@ *.obj mpz\*.obj mpn_$(MPN_TYPE).lib #CFLAGS = $(CFLAGS_CONFIG) /nologo /W3 /EHsc /I "." /I $(srcdir) /I "$(srcdir)\mpn\generic" /D "WIN32" /D "_LIB" /D "_WIN32" /D "_MBCS" CFLAGS = $(CFLAGS_CONFIG) /nologo /W3 /EHsc /I "." /I $(srcdir) /I "$(srcdir)\mpn\generic" /D "_LIB" /D "_MBCS" $(D_WIN64) {.\mpn\generic}.c{.\mpn\generic}.obj: cl -c $(CFLAGS) /Fo$@ $? {.\mpz}.c{.\mpz}.obj: cl -c $(CFLAGS) /Fo$@ $? {$(srcdir)\mpn\generic}.c{mpn\generic}.obj: cl -c $(CFLAGS) /Fo$@ $? {$(srcdir)\mpn}.c{mpn}.obj: cl -c $(CFLAGS) /Fo$@ $? {$(srcdir)\mpz}.c{mpz}.obj: cl -c $(CFLAGS) /Fo$@ $? {$(srcdir)}.c{}.obj: cl -c $(CFLAGS) /Fo$@ $? .asm.obj: # nasm -O9 -Xvc -f win32 -i $(@D)\ -o $@ $? $(YASM) -O9 $(YASM_FLAGS) -Xvc -f $(YASM_TARGET) -i $(@D)\ -o $@ $? gen-bases.exe: build.vc8\gen-bases\gen-bases.c cl $(CFLAGS) /Fe$@ $? erase gen-bases.obj mp_bases.h: gen-bases.exe gen-bases.exe header $(BITS) 0 > $@ mp_bases.c: gen-bases.exe gen-bases.exe table $(BITS) 0 > $@ gen-fac_ui.exe: build.vc8\gen-fac_ui\gen-fac_ui.c cl $(CFLAGS) /Fe$@ $? erase gen-fac_ui.obj fac_ui.h: gen-fac_ui.exe gen-fac_ui.exe $(BITS) 0 > $@ gen-fib.exe: build.vc8\gen-fib\gen-fib.c cl $(CFLAGS) /Fe$@ $? erase gen-fib.obj fib_table.h: gen-fib.exe gen-fib.exe header $(BITS) 0 > $@ fib_table.c: gen-fib.exe gen-fib.exe table $(BITS) 0 > $@ gen-psqr.exe: build.vc8\gen-psqr\gen-psqr.c cl $(CFLAGS) /Fe$@ $? erase gen-psqr.obj perfsqr.h: gen-psqr.exe gen-psqr.exe $(BITS) 0 > $@ msvc-build: build.vc8\config-vc8.$(MPN_TYPE) build.vc8\gmp.h copy build.vc8\config-vc8.$(MPN_TYPE) config.h copy build.vc8\gmp.h gmp.h echo > $@ clean: -erase mpn\generic\*.obj -erase mpn\*.obj -erase mpz\*.obj -erase *.obj -erase mpn_*.lib -erase gmp.lib -for %o in ($(MPN_P0_ASM_SOURCES:.asm=.obj)) do erase %o -for %o in ($(MPN_P3_ASM_SOURCES:.asm=.obj)) do erase %o -for %o in ($(MPN_P4_ASM_SOURCES:.asm=.obj)) do erase %o -for %o in ($(AUTO_FILES)) do erase %o -erase config.h -erase gmp.h -erase msvc-build -erase *.exe *.manifest ecl-16.1.2/msvc/gmp/build.vc8/000077500000000000000000000000001266352375300157115ustar00rootroot00000000000000ecl-16.1.2/msvc/gmp/build.vc8/config-vc8.amd64000077500000000000000000000344711266352375300205250ustar00rootroot00000000000000/* Templates for defines setup by configure. Copyright 2000, 2001, 2002 Free Software Foundation, Inc. This file is part of the GNU MP Library. The GNU MP Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU MP Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU MP Library; see the file COPYING.LIB. If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ /* Define one (and only one) of these for the CPU host. Only hosts that are going to be tested for need to be in this list, not everything that can possibly be selected. */ #undef HAVE_HOST_CPU_alpha #undef HAVE_HOST_CPU_alphaev5 #undef HAVE_HOST_CPU_alphaev6 #undef HAVE_HOST_CPU_alphaev67 #undef HAVE_HOST_CPU_m68k #undef HAVE_HOST_CPU_m68000 #undef HAVE_HOST_CPU_m68010 #undef HAVE_HOST_CPU_m68020 #undef HAVE_HOST_CPU_m68030 #undef HAVE_HOST_CPU_m68040 #undef HAVE_HOST_CPU_m68060 #undef HAVE_HOST_CPU_m68302 #undef HAVE_HOST_CPU_m68360 #undef HAVE_HOST_CPU_powerpc604 #undef HAVE_HOST_CPU_powerpc604e #undef HAVE_HOST_CPU_powerpc750 #undef HAVE_HOST_CPU_powerpc7400 #undef HAVE_HOST_CPU_sparc #undef HAVE_HOST_CPU_sparcv8 #undef HAVE_HOST_CPU_supersparc #undef HAVE_HOST_CPU_sparclite #undef HAVE_HOST_CPU_microsparc #undef HAVE_HOST_CPU_ultrasparc1 #undef HAVE_HOST_CPU_ultrasparc2 #undef HAVE_HOST_CPU_sparc64 #undef HAVE_HOST_CPU_hppa1_0 #undef HAVE_HOST_CPU_hppa1_1 #undef HAVE_HOST_CPU_hppa2_0n #undef HAVE_HOST_CPU_hppa2_0w #undef HAVE_HOST_CPU_i386 #undef HAVE_HOST_CPU_i486 #undef HAVE_HOST_CPU_i586 #undef HAVE_HOST_CPU_i686 #undef HAVE_HOST_CPU_pentium #undef HAVE_HOST_CPU_pentiummmx #undef HAVE_HOST_CPU_pentiumpro #undef HAVE_HOST_CPU_pentium2 #undef HAVE_HOST_CPU_pentium3 #undef HAVE_HOST_CPU_k5 #undef HAVE_HOST_CPU_k6 #undef HAVE_HOST_CPU_k62 #undef HAVE_HOST_CPU_k63 #undef HAVE_HOST_CPU_athlon /* a dummy to make autoheader happy */ #undef HAVE_HOST_CPU_ /* Define one (and only one) of these for the CPU host family. Only hosts that are going to be tested for need to be in this list, not everything that can possibly be selected. */ #undef HAVE_HOST_CPU_FAMILY_power #undef HAVE_HOST_CPU_FAMILY_powerpc #define HAVE_HOST_CPU_FAMILY_x86 1 /* Define if we have native implementation of function. (use just one of the three following defines) */ #undef HAVE_NATIVE_mpn_add #undef HAVE_NATIVE_mpn_add_1 #undef HAVE_NATIVE_mpn_addmul_2 #undef HAVE_NATIVE_mpn_addmul_3 #undef HAVE_NATIVE_mpn_addmul_4 #undef HAVE_NATIVE_mpn_addsub_n #undef HAVE_NATIVE_mpn_addsub_nc #undef HAVE_NATIVE_mpn_and_n #undef HAVE_NATIVE_mpn_andn_n #undef HAVE_NATIVE_mpn_bdivmod #undef HAVE_NATIVE_mpn_cmp #undef HAVE_NATIVE_mpn_com_n #undef HAVE_NATIVE_mpn_divrem #undef HAVE_NATIVE_mpn_divrem_2 #undef HAVE_NATIVE_mpn_divrem_newton #undef HAVE_NATIVE_mpn_divrem_classic #undef HAVE_NATIVE_mpn_dump #undef HAVE_NATIVE_mpn_gcd #undef HAVE_NATIVE_mpn_gcd_1 #undef HAVE_NATIVE_mpn_gcd_finda #undef HAVE_NATIVE_mpn_gcdext #undef HAVE_NATIVE_mpn_get_str #undef HAVE_NATIVE_mpn_invert_limb #undef HAVE_NATIVE_mpn_ior_n #undef HAVE_NATIVE_mpn_iorn_n #undef HAVE_NATIVE_mpn_mul #undef HAVE_NATIVE_mpn_mul_2 #undef HAVE_NATIVE_mpn_mul_3 #undef HAVE_NATIVE_mpn_mul_4 #undef HAVE_NATIVE_mpn_mul_n #undef HAVE_NATIVE_mpn_nand_n #undef HAVE_NATIVE_mpn_nior_n #undef HAVE_NATIVE_mpn_perfect_square_p #undef HAVE_NATIVE_mpn_preinv_mod_1 #undef HAVE_NATIVE_mpn_random2 #undef HAVE_NATIVE_mpn_random #undef HAVE_NATIVE_mpn_rawrandom #undef HAVE_NATIVE_mpn_scan0 #undef HAVE_NATIVE_mpn_scan1 #undef HAVE_NATIVE_mpn_set_str #undef HAVE_NATIVE_mpn_sqrtrem #undef HAVE_NATIVE_mpn_sqr_diagonal #undef HAVE_NATIVE_mpn_sub #undef HAVE_NATIVE_mpn_sub_1 #undef HAVE_NATIVE_mpn_udiv_w_sdiv #undef HAVE_NATIVE_mpn_xor_n #undef HAVE_NATIVE_mpn_xnor_n #define HAVE_NATIVE_mpn_add_n 1 #define HAVE_NATIVE_mpn_add_nc 1 #define HAVE_NATIVE_mpn_sub_n 1 #define HAVE_NATIVE_mpn_sub_nc 1 #define HAVE_NATIVE_mpn_addmul_1 1 #define HAVE_NATIVE_mpn_addmul_1c 1 #define HAVE_NATIVE_mpn_submul_1 1 #define HAVE_NATIVE_mpn_submul_1c 1 #define HAVE_NATIVE_mpn_copyd 1 #define HAVE_NATIVE_mpn_copyi 1 #define HAVE_NATIVE_mpn_divexact_1 1 #undef HAVE_NATIVE_mpn_divexact_by3c #undef HAVE_NATIVE_mpn_divrem_1 #undef HAVE_NATIVE_mpn_divrem_1c #undef HAVE_NATIVE_mpn_hamdist #undef HAVE_NATIVE_mpn_popcount #define HAVE_NATIVE_mpn_lshift 1 #define HAVE_NATIVE_mpn_rshift 1 #undef HAVE_NATIVE_mpn_mod_1 #undef HAVE_NATIVE_mpn_mod_1c #define HAVE_NATIVE_mpn_modexact_1_odd 1 #define HAVE_NATIVE_mpn_modexact_1c_odd 1 #define HAVE_NATIVE_mpn_mul_1 1 #define HAVE_NATIVE_mpn_mul_1c 1 #define HAVE_NATIVE_mpn_mul_basecase 1 #define HAVE_NATIVE_mpn_sqr_basecase 1 #undef HAVE_NATIVE_mpn_umul_ppmm #undef HAVE_NATIVE_mpn_udiv_qrnnd /* For the generic C code */ #define HAVE_NATIVE_mpn_add_n 1 #define HAVE_NATIVE_mpn_sub_n 1 /* a dummy to make autoheader happy */ #undef HAVE_NATIVE_ /* The gmp-mparam.h to update when tuning. */ #undef GMP_MPARAM_H_SUGGEST /* Define if you have the `alarm' function. */ #undef HAVE_ALARM /* Define if alloca() works (via gmp-impl.h). */ #define HAVE_ALLOCA 1 /* Define if you have and it should be used (not on Ultrix). */ #undef HAVE_ALLOCA_H /* Define if the compiler accepts gcc style __attribute__ ((const)) */ #undef HAVE_ATTRIBUTE_CONST /* Define if the compiler accepts gcc style __attribute__ ((malloc)) */ #undef HAVE_ATTRIBUTE_MALLOC /* Define if the compiler accepts gcc style __attribute__ ((mode (XX))) */ #undef HAVE_ATTRIBUTE_MODE /* Define if the compiler accepts gcc style __attribute__ ((noreturn)) */ #undef HAVE_ATTRIBUTE_NORETURN /* Define if tests/libtests has calling conventions checking for the CPU */ #undef HAVE_CALLING_CONVENTIONS /* Define if you have the `clock' function. */ #define HAVE_CLOCK 1 /* Define if you have the `clock_gettime' function. */ #undef HAVE_CLOCK_GETTIME /* Define if you have the `cputime' function. */ #undef HAVE_CPUTIME /* Define to 1 if you have the declaration of `fgetc', and to 0 if you don't. */ #define HAVE_DECL_FGETC 1 /* Define to 1 if you have the declaration of `fscanf', and to 0 if you don't. */ #define HAVE_DECL_FSCANF 1 /* Define to 1 if you have the declaration of `optarg', and to 0 if you don't. */ #define HAVE_DECL_OPTARG 0 /* Define to 1 if you have the declaration of `ungetc', and to 0 if you don't. */ #define HAVE_DECL_UNGETC 1 /* Define to 1 if you have the declaration of `vfprintf', and to 0 if you don't. */ #define HAVE_DECL_VFPRINTF 1 /* Define if denormalized floats work. */ #define HAVE_DENORMS 1 /* Define if you have the header file. */ #undef HAVE_DLFCN_H /* Define one (and only one) of the following for the format of a `double'. If your format is not among these choices, or you don't know what it is, then leave all of them undefined. "IEEE_LITTLE_SWAPPED" means little endian, but with the two 4-byte halves swapped, as used by ARM CPUs in little endian mode. */ #undef HAVE_DOUBLE_IEEE_BIG_ENDIAN #define HAVE_DOUBLE_IEEE_LITTLE_ENDIAN 1 #undef HAVE_DOUBLE_IEEE_LITTLE_SWAPPED #undef HAVE_DOUBLE_VAX_D #undef HAVE_DOUBLE_VAX_G #undef HAVE_DOUBLE_CRAY_CFP /* Define if you have the header file. */ #define HAVE_FCNTL_H 1 /* Define if you have the header file. */ #undef HAVE_FPU_CONTROL_H /* Define if you have the `getpagesize' function. */ #undef HAVE_GETPAGESIZE /* Define if you have the `getrusage' function. */ #undef HAVE_GETRUSAGE /* Define if you have the `gettimeofday' function. */ #undef HAVE_GETTIMEOFDAY /* Define if 0/0, 1/0, -1/0 and sqrt(-1) work to generate NaN/infinities. */ #define HAVE_INFS 1 /* Define if the system has the type `intmax_t'. */ #undef HAVE_INTMAX_T /* Define if you have the header file. */ #undef HAVE_INTTYPES_H /* Define one (just one) of the following for the endiannes of `mp_limb_t'. If the endianness is not a simple big or little, or you don't know what it is, then leave both of these undefined. */ #undef HAVE_LIMB_BIG_ENDIAN #define HAVE_LIMB_LITTLE_ENDIAN 1 #define HAVE_STD__LOCALE 1 /* Define if you have the `localeconv' function. */ #define HAVE_LOCALECONV 1 /* Define if you have the header file. */ #define HAVE_LOCALE_H 1 /* Define if the system has the type `long double'. */ #define HAVE_LONG_DOUBLE 1 /* Define if the system has the type `long long'. */ #define HAVE_LONG_LONG 1 /* Define if you have the `lrand48' function. */ #undef HAVE_LRAND48 /* Define if you have the header file. */ #define HAVE_MEMORY_H 1 /* Define if you have the `memset' function. */ #define HAVE_MEMSET 1 /* Define if you have the `mmap' function. */ #undef HAVE_MMAP /* Define if you have the `mprotect' function. */ #undef HAVE_MPROTECT /* Define if you have the `obstack_vprintf' function. */ #undef HAVE_OBSTACK_VPRINTF /* Define if you have the `popen' function. */ #undef HAVE_POPEN /* Define if you have the `processor_info' function. */ #undef HAVE_PROCESSOR_INFO /* Define if the system has the type `ptrdiff_t'. */ #define HAVE_PTRDIFF_T 1 /* Define if the system has the type `quad_t'. */ #undef HAVE_QUAD_T #define HAVE_RAISE 1 /* Define if you have the `read_real_time' function. */ #undef HAVE_READ_REAL_TIME /* Define if you have the `sigaction' function. */ #undef HAVE_SIGACTION /* Define if you have the `sigaltstack' function. */ #undef HAVE_SIGALTSTACK /* Define if you have the `sigstack' function. */ #undef HAVE_SIGSTACK /* Tune directory speed_cyclecounter, undef=none, 1=32bits, 2=64bits) */ #define HAVE_SPEED_CYCLECOUNTER 2 /* Define if the system has the type `stack_t'. */ #undef HAVE_STACK_T /* Define if exists and works */ #define HAVE_STDARG 1 /* Define if you have the header file. */ #undef HAVE_STDINT_H /* Define if you have the header file. */ #define HAVE_STDLIB_H 1 /* Define if you have the `strcasecmp' function. */ #undef HAVE_STRCASECMP /* Define if you have the `strchr' function. */ #define HAVE_STRCHR 1 /* Define if cpp supports the ANSI # stringizing operator. */ #define HAVE_STRINGIZE 1 /* Define if you have the header file. */ #undef HAVE_STRINGS_H /* Define if you have the header file. */ #define HAVE_STRING_H 1 /* Define if you have the `strnlen' function. */ #define HAVE_STRNLEN 1 /* Define if you have the `strtoul' function. */ #define HAVE_STRTOUL 1 /* Define if you have the `sysconf' function. */ #undef HAVE_SYSCONF /* Define if you have the `sysctl' function. */ #undef HAVE_SYSCTL /* Define if you have the `sysctlbyname' function. */ #undef HAVE_SYSCTLBYNAME /* Define if you have the `syssgi' function. */ #undef HAVE_SYSSGI /* Define if you have the header file. */ #undef HAVE_SYS_MMAN_H /* Define if you have the header file. */ #undef HAVE_SYS_PARAM_H /* Define if you have the header file. */ #undef HAVE_SYS_PROCESSOR_H /* Define if you have the header file. */ #undef HAVE_SYS_RESOURCE_H /* Define if you have the header file. */ #define HAVE_SYS_STAT_H 1 /* Define if you have the header file. */ #undef HAVE_SYS_SYSCTL_H /* Define if you have the header file. */ #undef HAVE_SYS_SYSSGI_H /* Define if you have the header file. */ #undef HAVE_SYS_SYSTEMCFG_H /* Define if you have the header file. */ #undef HAVE_SYS_TIMES_H /* Define if you have the header file. */ #undef HAVE_SYS_TIME_H /* Define if you have the header file. */ #define HAVE_SYS_TYPES_H 1 /* Define if you have the `times' function. */ #undef HAVE_TIMES /* Define if you have the header file. */ #undef HAVE_UNISTD_H /* Define if you have vsnprintf and it works properly. */ #undef HAVE_VSNPRINTF /* Assembler local label prefix */ #undef LSYM_PREFIX /* Define if you have the `fesetround' function via the header file. */ #undef MPFR_HAVE_FESETROUND #define HAVE_SSTREAM 1 /* Name of package */ #define PACKAGE "gmp" /* Define if compiler has function prototypes */ #define PROTOTYPES 1 /* Define as the return type of signal handlers (`int' or `void'). */ #define RETSIGTYPE void /* The size of a `unsigned long', as computed by sizeof. */ #define SIZEOF_UNSIGNED_LONG 4 /* Define if sscanf requires writable inputs */ #undef SSCANF_WRITABLE_INPUT /* Define if you have the ANSI C header files. */ #define STDC_HEADERS 1 /* Define if you can safely include both and . */ #undef TIME_WITH_SYS_TIME /* Maximum size the tune program can test for KARATSUBA_SQR_THRESHOLD */ #define TUNE_KARATSUBA_SQR_MAX 67 /* Version number of package */ #define VERSION "4.2.1 (VC8)" /* ./configure --enable-assert option, to enable some ASSERT()s */ #undef WANT_ASSERT /* ./configure --enable-fft option, to enable FFTs for multiplication */ #define WANT_FFT 1 /* Define to 1 if --enable-profiling=gprof */ #undef WANT_PROFILING_GPROF /* Define to 1 if --enable-profiling=prof */ #undef WANT_PROFILING_PROF /* --enable-alloca=yes */ #undef WANT_TMP_ALLOCA /* --enable-alloca=debug */ #undef WANT_TMP_DEBUG /* --enable-alloca=malloc-notreentrant */ #undef WANT_TMP_NOTREENTRANT /* --enable-alloca=malloc-reentrant */ #define WANT_TMP_REENTRANT 1 /* Define if your processor stores words with the most significant byte first (like Motorola and SPARC, unlike Intel and VAX). */ #undef WORDS_BIGENDIAN /* Define if `lex' declares `yytext' as a `char *' by default, not a `char[]'. */ #undef YYTEXT_POINTER /* Define as `__inline' if that's what the C compiler calls it, or to nothing if it is not supported. */ #define inline __inline /* Define to empty if the keyword `volatile' does not work. Warning: valid code using `volatile' can become incorrect without. Disable with care. */ #undef volatile #ifdef _MSC_VER #define strcasecmp _stricmp #define strncasecmp _strnicmp #define alloca _alloca #define HAVE_STRCASECMP 1 #define HAVE_STRNCASECMP 1 #endif ecl-16.1.2/msvc/gmp/build.vc8/config-vc8.gc000077500000000000000000000343011266352375300201730ustar00rootroot00000000000000/* Templates for defines setup by configure. Copyright 2000, 2001, 2002 Free Software Foundation, Inc. This file is part of the GNU MP Library. The GNU MP Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU MP Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU MP Library; see the file COPYING.LIB. If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ /* Define one (and only one) of these for the CPU host. Only hosts that are going to be tested for need to be in this list, not everything that can possibly be selected. */ #undef HAVE_HOST_CPU_alpha #undef HAVE_HOST_CPU_alphaev5 #undef HAVE_HOST_CPU_alphaev6 #undef HAVE_HOST_CPU_alphaev67 #undef HAVE_HOST_CPU_m68k #undef HAVE_HOST_CPU_m68000 #undef HAVE_HOST_CPU_m68010 #undef HAVE_HOST_CPU_m68020 #undef HAVE_HOST_CPU_m68030 #undef HAVE_HOST_CPU_m68040 #undef HAVE_HOST_CPU_m68060 #undef HAVE_HOST_CPU_m68302 #undef HAVE_HOST_CPU_m68360 #undef HAVE_HOST_CPU_powerpc604 #undef HAVE_HOST_CPU_powerpc604e #undef HAVE_HOST_CPU_powerpc750 #undef HAVE_HOST_CPU_powerpc7400 #undef HAVE_HOST_CPU_sparc #undef HAVE_HOST_CPU_sparcv8 #undef HAVE_HOST_CPU_supersparc #undef HAVE_HOST_CPU_sparclite #undef HAVE_HOST_CPU_microsparc #undef HAVE_HOST_CPU_ultrasparc1 #undef HAVE_HOST_CPU_ultrasparc2 #undef HAVE_HOST_CPU_sparc64 #undef HAVE_HOST_CPU_hppa1_0 #undef HAVE_HOST_CPU_hppa1_1 #undef HAVE_HOST_CPU_hppa2_0n #undef HAVE_HOST_CPU_hppa2_0w #undef HAVE_HOST_CPU_i386 #undef HAVE_HOST_CPU_i486 #undef HAVE_HOST_CPU_i586 #undef HAVE_HOST_CPU_i686 #undef HAVE_HOST_CPU_pentium #undef HAVE_HOST_CPU_pentiummmx #undef HAVE_HOST_CPU_pentiumpro #undef HAVE_HOST_CPU_pentium2 #undef HAVE_HOST_CPU_pentium3 #undef HAVE_HOST_CPU_k5 #undef HAVE_HOST_CPU_k6 #undef HAVE_HOST_CPU_k62 #undef HAVE_HOST_CPU_k63 #undef HAVE_HOST_CPU_athlon /* a dummy to make autoheader happy */ #undef HAVE_HOST_CPU_ /* Define one (and only one) of these for the CPU host family. Only hosts that are going to be tested for need to be in this list, not everything that can possibly be selected. */ #undef HAVE_HOST_CPU_FAMILY_power #undef HAVE_HOST_CPU_FAMILY_powerpc #define HAVE_HOST_CPU_FAMILY_x86 1 /* Define if we have native implementation of function. (use just one of the three following defines) */ #undef HAVE_NATIVE_mpn_add #undef HAVE_NATIVE_mpn_add_1 #undef HAVE_NATIVE_mpn_addmul_2 #undef HAVE_NATIVE_mpn_addmul_3 #undef HAVE_NATIVE_mpn_addmul_4 #undef HAVE_NATIVE_mpn_addsub_n #undef HAVE_NATIVE_mpn_addsub_nc #undef HAVE_NATIVE_mpn_and_n #undef HAVE_NATIVE_mpn_andn_n #undef HAVE_NATIVE_mpn_bdivmod #undef HAVE_NATIVE_mpn_cmp #undef HAVE_NATIVE_mpn_com_n #undef HAVE_NATIVE_mpn_divrem #undef HAVE_NATIVE_mpn_divrem_2 #undef HAVE_NATIVE_mpn_divrem_newton #undef HAVE_NATIVE_mpn_divrem_classic #undef HAVE_NATIVE_mpn_dump #undef HAVE_NATIVE_mpn_gcd #undef HAVE_NATIVE_mpn_gcd_1 #undef HAVE_NATIVE_mpn_gcd_finda #undef HAVE_NATIVE_mpn_gcdext #undef HAVE_NATIVE_mpn_get_str #undef HAVE_NATIVE_mpn_invert_limb #undef HAVE_NATIVE_mpn_ior_n #undef HAVE_NATIVE_mpn_iorn_n #undef HAVE_NATIVE_mpn_mul #undef HAVE_NATIVE_mpn_mul_2 #undef HAVE_NATIVE_mpn_mul_3 #undef HAVE_NATIVE_mpn_mul_4 #undef HAVE_NATIVE_mpn_mul_n #undef HAVE_NATIVE_mpn_nand_n #undef HAVE_NATIVE_mpn_nior_n #undef HAVE_NATIVE_mpn_perfect_square_p #undef HAVE_NATIVE_mpn_preinv_mod_1 #undef HAVE_NATIVE_mpn_random2 #undef HAVE_NATIVE_mpn_random #undef HAVE_NATIVE_mpn_rawrandom #undef HAVE_NATIVE_mpn_scan0 #undef HAVE_NATIVE_mpn_scan1 #undef HAVE_NATIVE_mpn_set_str #undef HAVE_NATIVE_mpn_sqrtrem #undef HAVE_NATIVE_mpn_sqr_diagonal #undef HAVE_NATIVE_mpn_sub #undef HAVE_NATIVE_mpn_sub_1 #undef HAVE_NATIVE_mpn_udiv_w_sdiv #undef HAVE_NATIVE_mpn_xor_n #undef HAVE_NATIVE_mpn_xnor_n #undef HAVE_NATIVE_mpn_add_n #undef HAVE_NATIVE_mpn_add_nc #undef HAVE_NATIVE_mpn_sub_n #undef HAVE_NATIVE_mpn_sub_nc #undef HAVE_NATIVE_mpn_addmul_1 #undef HAVE_NATIVE_mpn_addmul_1c #undef HAVE_NATIVE_mpn_submul_1 #undef HAVE_NATIVE_mpn_submul_1c #undef HAVE_NATIVE_mpn_copyd #undef HAVE_NATIVE_mpn_copyi #undef HAVE_NATIVE_mpn_divexact_1 #undef HAVE_NATIVE_mpn_divexact_by3c #undef HAVE_NATIVE_mpn_divrem_1 #undef HAVE_NATIVE_mpn_divrem_1c #undef HAVE_NATIVE_mpn_hamdist #undef HAVE_NATIVE_mpn_popcount #undef HAVE_NATIVE_mpn_lshift #undef HAVE_NATIVE_mpn_rshift #undef HAVE_NATIVE_mpn_mod_1 #undef HAVE_NATIVE_mpn_mod_1c #undef HAVE_NATIVE_mpn_modexact_1_odd #undef HAVE_NATIVE_mpn_modexact_1c_odd #undef HAVE_NATIVE_mpn_mul_1 #undef HAVE_NATIVE_mpn_mul_1c #undef HAVE_NATIVE_mpn_mul_basecase #undef HAVE_NATIVE_mpn_sqr_basecase #undef HAVE_NATIVE_mpn_umul_ppmm #undef HAVE_NATIVE_mpn_udiv_qrnnd /* For the generic C code */ #define HAVE_NATIVE_mpn_add_n 1 #define HAVE_NATIVE_mpn_sub_n 1 /* a dummy to make autoheader happy */ #undef HAVE_NATIVE_ /* The gmp-mparam.h to update when tuning. */ #undef GMP_MPARAM_H_SUGGEST /* Define if you have the `alarm' function. */ #undef HAVE_ALARM /* Define if alloca() works (via gmp-impl.h). */ #define HAVE_ALLOCA 1 /* Define if you have and it should be used (not on Ultrix). */ #undef HAVE_ALLOCA_H /* Define if the compiler accepts gcc style __attribute__ ((const)) */ #undef HAVE_ATTRIBUTE_CONST /* Define if the compiler accepts gcc style __attribute__ ((malloc)) */ #undef HAVE_ATTRIBUTE_MALLOC /* Define if the compiler accepts gcc style __attribute__ ((mode (XX))) */ #undef HAVE_ATTRIBUTE_MODE /* Define if the compiler accepts gcc style __attribute__ ((noreturn)) */ #undef HAVE_ATTRIBUTE_NORETURN /* Define if tests/libtests has calling conventions checking for the CPU */ #undef HAVE_CALLING_CONVENTIONS /* Define if you have the `clock' function. */ #define HAVE_CLOCK 1 /* Define if you have the `clock_gettime' function. */ #undef HAVE_CLOCK_GETTIME /* Define if you have the `cputime' function. */ #undef HAVE_CPUTIME /* Define to 1 if you have the declaration of `fgetc', and to 0 if you don't. */ #define HAVE_DECL_FGETC 1 /* Define to 1 if you have the declaration of `fscanf', and to 0 if you don't. */ #define HAVE_DECL_FSCANF 1 /* Define to 1 if you have the declaration of `optarg', and to 0 if you don't. */ #define HAVE_DECL_OPTARG 0 /* Define to 1 if you have the declaration of `ungetc', and to 0 if you don't. */ #define HAVE_DECL_UNGETC 1 /* Define to 1 if you have the declaration of `vfprintf', and to 0 if you don't. */ #define HAVE_DECL_VFPRINTF 1 /* Define if denormalized floats work. */ #define HAVE_DENORMS 1 /* Define if you have the header file. */ #undef HAVE_DLFCN_H /* Define one (and only one) of the following for the format of a `double'. If your format is not among these choices, or you don't know what it is, then leave all of them undefined. "IEEE_LITTLE_SWAPPED" means little endian, but with the two 4-byte halves swapped, as used by ARM CPUs in little endian mode. */ #undef HAVE_DOUBLE_IEEE_BIG_ENDIAN #define HAVE_DOUBLE_IEEE_LITTLE_ENDIAN 1 #undef HAVE_DOUBLE_IEEE_LITTLE_SWAPPED #undef HAVE_DOUBLE_VAX_D #undef HAVE_DOUBLE_VAX_G #undef HAVE_DOUBLE_CRAY_CFP /* Define if you have the header file. */ #define HAVE_FCNTL_H 1 /* Define if you have the header file. */ #undef HAVE_FPU_CONTROL_H /* Define if you have the `getpagesize' function. */ #undef HAVE_GETPAGESIZE /* Define if you have the `getrusage' function. */ #undef HAVE_GETRUSAGE /* Define if you have the `gettimeofday' function. */ #undef HAVE_GETTIMEOFDAY /* Define if 0/0, 1/0, -1/0 and sqrt(-1) work to generate NaN/infinities. */ #define HAVE_INFS 1 /* Define if the system has the type `intmax_t'. */ #undef HAVE_INTMAX_T /* Define if you have the header file. */ #undef HAVE_INTTYPES_H /* Define one (just one) of the following for the endiannes of `mp_limb_t'. If the endianness is not a simple big or little, or you don't know what it is, then leave both of these undefined. */ #undef HAVE_LIMB_BIG_ENDIAN #define HAVE_LIMB_LITTLE_ENDIAN 1 #define HAVE_STD__LOCALE 1 /* Define if you have the `localeconv' function. */ #define HAVE_LOCALECONV 1 /* Define if you have the header file. */ #define HAVE_LOCALE_H 1 /* Define if the system has the type `long double'. */ #define HAVE_LONG_DOUBLE 1 /* Define if the system has the type `long long'. */ #define HAVE_LONG_LONG 0 /* Define if you have the `lrand48' function. */ #undef HAVE_LRAND48 /* Define if you have the header file. */ #define HAVE_MEMORY_H 1 /* Define if you have the `memset' function. */ #define HAVE_MEMSET 1 /* Define if you have the `mmap' function. */ #undef HAVE_MMAP /* Define if you have the `mprotect' function. */ #undef HAVE_MPROTECT /* Define if you have the `obstack_vprintf' function. */ #undef HAVE_OBSTACK_VPRINTF /* Define if you have the `popen' function. */ #undef HAVE_POPEN /* Define if you have the `processor_info' function. */ #undef HAVE_PROCESSOR_INFO /* Define if the system has the type `ptrdiff_t'. */ #define HAVE_PTRDIFF_T 1 /* Define if the system has the type `quad_t'. */ #undef HAVE_QUAD_T #define HAVE_RAISE 1 /* Define if you have the `read_real_time' function. */ #undef HAVE_READ_REAL_TIME /* Define if you have the `sigaction' function. */ #undef HAVE_SIGACTION /* Define if you have the `sigaltstack' function. */ #undef HAVE_SIGALTSTACK /* Define if you have the `sigstack' function. */ #undef HAVE_SIGSTACK /* Tune directory speed_cyclecounter, undef=none, 1=32bits, 2=64bits) */ #define HAVE_SPEED_CYCLECOUNTER 2 /* Define if the system has the type `stack_t'. */ #undef HAVE_STACK_T /* Define if exists and works */ #define HAVE_STDARG 1 /* Define if you have the header file. */ #undef HAVE_STDINT_H /* Define if you have the header file. */ #define HAVE_STDLIB_H 1 /* Define if you have the `strcasecmp' function. */ #undef HAVE_STRCASECMP /* Define if you have the `strchr' function. */ #define HAVE_STRCHR 1 /* Define if cpp supports the ANSI # stringizing operator. */ #define HAVE_STRINGIZE 1 /* Define if you have the header file. */ #undef HAVE_STRINGS_H /* Define if you have the header file. */ #define HAVE_STRING_H 1 /* Define if you have the `strnlen' function. */ #define HAVE_STRNLEN 1 /* Define if you have the `strtoul' function. */ #define HAVE_STRTOUL 1 /* Define if you have the `sysconf' function. */ #undef HAVE_SYSCONF /* Define if you have the `sysctl' function. */ #undef HAVE_SYSCTL /* Define if you have the `sysctlbyname' function. */ #undef HAVE_SYSCTLBYNAME /* Define if you have the `syssgi' function. */ #undef HAVE_SYSSGI /* Define if you have the header file. */ #undef HAVE_SYS_MMAN_H /* Define if you have the header file. */ #undef HAVE_SYS_PARAM_H /* Define if you have the header file. */ #undef HAVE_SYS_PROCESSOR_H /* Define if you have the header file. */ #undef HAVE_SYS_RESOURCE_H /* Define if you have the header file. */ #define HAVE_SYS_STAT_H 1 /* Define if you have the header file. */ #undef HAVE_SYS_SYSCTL_H /* Define if you have the header file. */ #undef HAVE_SYS_SYSSGI_H /* Define if you have the header file. */ #undef HAVE_SYS_SYSTEMCFG_H /* Define if you have the header file. */ #undef HAVE_SYS_TIMES_H /* Define if you have the header file. */ #undef HAVE_SYS_TIME_H /* Define if you have the header file. */ #define HAVE_SYS_TYPES_H 1 /* Define if you have the `times' function. */ #undef HAVE_TIMES /* Define if you have the header file. */ #undef HAVE_UNISTD_H /* Define if you have vsnprintf and it works properly. */ #undef HAVE_VSNPRINTF /* Assembler local label prefix */ #undef LSYM_PREFIX /* Define if you have the `fesetround' function via the header file. */ #undef MPFR_HAVE_FESETROUND #define HAVE_SSTREAM 1 /* Name of package */ #define PACKAGE "gmp" /* Define if compiler has function prototypes */ #define PROTOTYPES 1 /* Define as the return type of signal handlers (`int' or `void'). */ #define RETSIGTYPE void /* The size of a `unsigned long', as computed by sizeof. */ #define SIZEOF_UNSIGNED_LONG 4 /* Define if sscanf requires writable inputs */ #undef SSCANF_WRITABLE_INPUT /* Define if you have the ANSI C header files. */ #define STDC_HEADERS 1 /* Define if you can safely include both and . */ #undef TIME_WITH_SYS_TIME /* Maximum size the tune program can test for KARATSUBA_SQR_THRESHOLD */ #define TUNE_KARATSUBA_SQR_MAX 67 /* Version number of package */ #define VERSION "4.2.1 (VC8)" /* ./configure --enable-assert option, to enable some ASSERT()s */ #undef WANT_ASSERT /* ./configure --enable-fft option, to enable FFTs for multiplication */ #define WANT_FFT 1 /* Define to 1 if --enable-profiling=gprof */ #undef WANT_PROFILING_GPROF /* Define to 1 if --enable-profiling=prof */ #undef WANT_PROFILING_PROF /* --enable-alloca=yes */ #undef WANT_TMP_ALLOCA /* --enable-alloca=debug */ #undef WANT_TMP_DEBUG /* --enable-alloca=malloc-notreentrant */ #undef WANT_TMP_NOTREENTRANT /* --enable-alloca=malloc-reentrant */ #define WANT_TMP_REENTRANT 1 /* Define if your processor stores words with the most significant byte first (like Motorola and SPARC, unlike Intel and VAX). */ #undef WORDS_BIGENDIAN /* Define if `lex' declares `yytext' as a `char *' by default, not a `char[]'. */ #undef YYTEXT_POINTER /* Define as `__inline' if that's what the C compiler calls it, or to nothing if it is not supported. */ #define inline __inline /* Define to empty if the keyword `volatile' does not work. Warning: valid code using `volatile' can become incorrect without. Disable with care. */ #undef volatile #ifdef _MSC_VER #define strcasecmp _stricmp #define strncasecmp _strnicmp #define alloca _alloca #define HAVE_STRCASECMP 1 #define HAVE_STRNCASECMP 1 #endif ecl-16.1.2/msvc/gmp/build.vc8/config-vc8.p0000077500000000000000000000355421266352375300201310ustar00rootroot00000000000000/* Templates for defines setup by configure. Copyright 2000, 2001, 2002 Free Software Foundation, Inc. This file is part of the GNU MP Library. The GNU MP Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU MP Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU MP Library; see the file COPYING.LIB. If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ /* Define one (and only one) of these for the CPU host. Only hosts that are going to be tested for need to be in this list, not everything that can possibly be selected. */ #undef HAVE_HOST_CPU_alpha #undef HAVE_HOST_CPU_alphaev5 #undef HAVE_HOST_CPU_alphaev6 #undef HAVE_HOST_CPU_alphaev67 #undef HAVE_HOST_CPU_m68k #undef HAVE_HOST_CPU_m68000 #undef HAVE_HOST_CPU_m68010 #undef HAVE_HOST_CPU_m68020 #undef HAVE_HOST_CPU_m68030 #undef HAVE_HOST_CPU_m68040 #undef HAVE_HOST_CPU_m68060 #undef HAVE_HOST_CPU_m68302 #undef HAVE_HOST_CPU_m68360 #undef HAVE_HOST_CPU_powerpc604 #undef HAVE_HOST_CPU_powerpc604e #undef HAVE_HOST_CPU_powerpc750 #undef HAVE_HOST_CPU_powerpc7400 #undef HAVE_HOST_CPU_sparc #undef HAVE_HOST_CPU_sparcv8 #undef HAVE_HOST_CPU_supersparc #undef HAVE_HOST_CPU_sparclite #undef HAVE_HOST_CPU_microsparc #undef HAVE_HOST_CPU_ultrasparc1 #undef HAVE_HOST_CPU_ultrasparc2 #undef HAVE_HOST_CPU_sparc64 #undef HAVE_HOST_CPU_hppa1_0 #undef HAVE_HOST_CPU_hppa1_1 #undef HAVE_HOST_CPU_hppa2_0n #undef HAVE_HOST_CPU_hppa2_0w #undef HAVE_HOST_CPU_i386 #undef HAVE_HOST_CPU_i486 #undef HAVE_HOST_CPU_i586 #undef HAVE_HOST_CPU_i686 #define HAVE_HOST_CPU_pentium 1 #undef HAVE_HOST_CPU_pentiummmx #undef HAVE_HOST_CPU_pentiumpro #undef HAVE_HOST_CPU_pentium2 #undef HAVE_HOST_CPU_pentium3 #undef HAVE_HOST_CPU_k5 #undef HAVE_HOST_CPU_k6 #undef HAVE_HOST_CPU_k62 #undef HAVE_HOST_CPU_k63 #undef HAVE_HOST_CPU_athlon /* a dummy to make autoheader happy */ #undef HAVE_HOST_CPU_ /* Define one (and only one) of these for the CPU host family. Only hosts that are going to be tested for need to be in this list, not everything that can possibly be selected. */ #undef HAVE_HOST_CPU_FAMILY_power #undef HAVE_HOST_CPU_FAMILY_powerpc #define HAVE_HOST_CPU_FAMILY_x86 1 /* Define if we have native implementation of function. (use just one of the three following defines) */ #undef HAVE_NATIVE_mpn_add #undef HAVE_NATIVE_mpn_add_1 #undef HAVE_NATIVE_mpn_addmul_2 #undef HAVE_NATIVE_mpn_addmul_3 #undef HAVE_NATIVE_mpn_addmul_4 #undef HAVE_NATIVE_mpn_addsub_n #undef HAVE_NATIVE_mpn_addsub_nc #undef HAVE_NATIVE_mpn_and_n #undef HAVE_NATIVE_mpn_andn_n #undef HAVE_NATIVE_mpn_bdivmod #undef HAVE_NATIVE_mpn_cmp #undef HAVE_NATIVE_mpn_com_n #undef HAVE_NATIVE_mpn_divrem #undef HAVE_NATIVE_mpn_divrem_2 #undef HAVE_NATIVE_mpn_divrem_newton #undef HAVE_NATIVE_mpn_divrem_classic #undef HAVE_NATIVE_mpn_dump #undef HAVE_NATIVE_mpn_gcd #undef HAVE_NATIVE_mpn_gcd_1 #undef HAVE_NATIVE_mpn_gcd_finda #undef HAVE_NATIVE_mpn_gcdext #undef HAVE_NATIVE_mpn_get_str #undef HAVE_NATIVE_mpn_invert_limb #undef HAVE_NATIVE_mpn_ior_n #undef HAVE_NATIVE_mpn_iorn_n #undef HAVE_NATIVE_mpn_mul #undef HAVE_NATIVE_mpn_mul_2 #undef HAVE_NATIVE_mpn_mul_3 #undef HAVE_NATIVE_mpn_mul_4 #undef HAVE_NATIVE_mpn_mul_n #undef HAVE_NATIVE_mpn_nand_n #undef HAVE_NATIVE_mpn_nior_n #undef HAVE_NATIVE_mpn_perfect_square_p #undef HAVE_NATIVE_mpn_preinv_mod_1 #undef HAVE_NATIVE_mpn_random2 #undef HAVE_NATIVE_mpn_random #undef HAVE_NATIVE_mpn_rawrandom #undef HAVE_NATIVE_mpn_scan0 #undef HAVE_NATIVE_mpn_scan1 #undef HAVE_NATIVE_mpn_set_str #undef HAVE_NATIVE_mpn_sqrtrem #undef HAVE_NATIVE_mpn_sqr_diagonal #undef HAVE_NATIVE_mpn_sub #undef HAVE_NATIVE_mpn_sub_1 #undef HAVE_NATIVE_mpn_udiv_w_sdiv #undef HAVE_NATIVE_mpn_xor_n #undef HAVE_NATIVE_mpn_xnor_n #undef HAVE_NATIVE_mpn_add_n #undef HAVE_NATIVE_mpn_add_nc #undef HAVE_NATIVE_mpn_sub_n #undef HAVE_NATIVE_mpn_sub_nc #undef HAVE_NATIVE_mpn_addmul_1 #undef HAVE_NATIVE_mpn_addmul_1c #undef HAVE_NATIVE_mpn_submul_1 #undef HAVE_NATIVE_mpn_submul_1c #undef HAVE_NATIVE_mpn_copyd #undef HAVE_NATIVE_mpn_copyi #undef HAVE_NATIVE_mpn_divexact_1 #undef HAVE_NATIVE_mpn_divexact_by3c #undef HAVE_NATIVE_mpn_divrem_1 #undef HAVE_NATIVE_mpn_divrem_1c #undef HAVE_NATIVE_mpn_hamdist #undef HAVE_NATIVE_mpn_popcount #undef HAVE_NATIVE_mpn_lshift #undef HAVE_NATIVE_mpn_rshift #undef HAVE_NATIVE_mpn_mod_1 #undef HAVE_NATIVE_mpn_mod_1c #undef HAVE_NATIVE_mpn_modexact_1_odd #undef HAVE_NATIVE_mpn_modexact_1c_odd #undef HAVE_NATIVE_mpn_mul_1 #undef HAVE_NATIVE_mpn_mul_1c #undef HAVE_NATIVE_mpn_mul_basecase #undef HAVE_NATIVE_mpn_sqr_basecase #undef HAVE_NATIVE_mpn_umul_ppmm #undef HAVE_NATIVE_mpn_udiv_qrnnd /* For the Intel Pentium assembler code */ #define HAVE_NATIVE_mpn_add_n 1 #define HAVE_NATIVE_mpn_add_nc 1 #define HAVE_NATIVE_mpn_sub_n 1 #define HAVE_NATIVE_mpn_sub_nc 1 #define HAVE_NATIVE_mpn_addmul_1 1 #define HAVE_NATIVE_mpn_submul_1 1 #define HAVE_NATIVE_mpn_copyd 1 #define HAVE_NATIVE_mpn_copyi 1 #define HAVE_NATIVE_mpn_divexact_1 1 #define HAVE_NATIVE_mpn_divexact_by3c 1 #define HAVE_NATIVE_mpn_divrem_1 1 #define HAVE_NATIVE_mpn_divrem_1c 1 #define HAVE_NATIVE_mpn_lshift 1 #define HAVE_NATIVE_mpn_rshift 1 #define HAVE_NATIVE_mpn_mod_1 1 #define HAVE_NATIVE_mpn_mod_1c 1 #define HAVE_NATIVE_mpn_mul_1 1 #define HAVE_NATIVE_mpn_mul_basecase 1 #define HAVE_NATIVE_mpn_umul_ppmm 1 #define HAVE_NATIVE_mpn_udiv_qrnnd 1 /* a dummy to make autoheader happy */ #undef HAVE_NATIVE_ /* The gmp-mparam.h to update when tuning. */ #undef GMP_MPARAM_H_SUGGEST /* Define if you have the `alarm' function. */ #undef HAVE_ALARM /* Define if alloca() works (via gmp-impl.h). */ #define HAVE_ALLOCA 1 /* Define if you have and it should be used (not on Ultrix). */ #undef HAVE_ALLOCA_H /* Define if the compiler accepts gcc style __attribute__ ((const)) */ #undef HAVE_ATTRIBUTE_CONST /* Define if the compiler accepts gcc style __attribute__ ((malloc)) */ #undef HAVE_ATTRIBUTE_MALLOC /* Define if the compiler accepts gcc style __attribute__ ((mode (XX))) */ #undef HAVE_ATTRIBUTE_MODE /* Define if the compiler accepts gcc style __attribute__ ((noreturn)) */ #undef HAVE_ATTRIBUTE_NORETURN /* Define if tests/libtests has calling conventions checking for the CPU */ #undef HAVE_CALLING_CONVENTIONS /* Define if you have the `clock' function. */ #define HAVE_CLOCK 1 /* Define if you have the `clock_gettime' function. */ #undef HAVE_CLOCK_GETTIME /* Define if you have the `cputime' function. */ #undef HAVE_CPUTIME /* Define to 1 if you have the declaration of `fgetc', and to 0 if you don't. */ #define HAVE_DECL_FGETC 1 /* Define to 1 if you have the declaration of `fscanf', and to 0 if you don't. */ #define HAVE_DECL_FSCANF 1 /* Define to 1 if you have the declaration of `optarg', and to 0 if you don't. */ #define HAVE_DECL_OPTARG 0 /* Define to 1 if you have the declaration of `ungetc', and to 0 if you don't. */ #define HAVE_DECL_UNGETC 1 /* Define to 1 if you have the declaration of `vfprintf', and to 0 if you don't. */ #define HAVE_DECL_VFPRINTF 1 /* Define if denormalized floats work. */ #define HAVE_DENORMS 1 /* Define if you have the header file. */ #undef HAVE_DLFCN_H /* Define one (and only one) of the following for the format of a `double'. If your format is not among these choices, or you don't know what it is, then leave all of them undefined. "IEEE_LITTLE_SWAPPED" means little endian, but with the two 4-byte halves swapped, as used by ARM CPUs in little endian mode. */ #undef HAVE_DOUBLE_IEEE_BIG_ENDIAN #define HAVE_DOUBLE_IEEE_LITTLE_ENDIAN 1 #undef HAVE_DOUBLE_IEEE_LITTLE_SWAPPED #undef HAVE_DOUBLE_VAX_D #undef HAVE_DOUBLE_VAX_G #undef HAVE_DOUBLE_CRAY_CFP /* Define if you have the header file. */ #define HAVE_FCNTL_H 1 /* Define if you have the header file. */ #undef HAVE_FPU_CONTROL_H /* Define if you have the `getpagesize' function. */ #undef HAVE_GETPAGESIZE /* Define if you have the `getrusage' function. */ #undef HAVE_GETRUSAGE /* Define if you have the `gettimeofday' function. */ #undef HAVE_GETTIMEOFDAY /* Define if 0/0, 1/0, -1/0 and sqrt(-1) work to generate NaN/infinities. */ #define HAVE_INFS 1 /* Define if the system has the type `intmax_t'. */ #undef HAVE_INTMAX_T /* Define if you have the header file. */ #undef HAVE_INTTYPES_H /* Define one (just one) of the following for the endiannes of `mp_limb_t'. If the endianness is not a simple big or little, or you don't know what it is, then leave both of these undefined. */ #undef HAVE_LIMB_BIG_ENDIAN #define HAVE_LIMB_LITTLE_ENDIAN 1 #define HAVE_STD__LOCALE 1 /* Define if you have the `localeconv' function. */ #define HAVE_LOCALECONV 1 /* Define if you have the header file. */ #define HAVE_LOCALE_H 1 /* Define if the system has the type `long double'. */ #define HAVE_LONG_DOUBLE 1 /* Define if the system has the type `long long'. */ #define HAVE_LONG_LONG 1 /* Define if you have the `lrand48' function. */ #undef HAVE_LRAND48 /* Define if you have the header file. */ #define HAVE_MEMORY_H 1 /* Define if you have the `memset' function. */ #define HAVE_MEMSET 1 /* Define if you have the `mmap' function. */ #undef HAVE_MMAP /* Define if you have the `mprotect' function. */ #undef HAVE_MPROTECT /* Define if you have the `obstack_vprintf' function. */ #undef HAVE_OBSTACK_VPRINTF /* Define if you have the `popen' function. */ #undef HAVE_POPEN /* Define if you have the `processor_info' function. */ #undef HAVE_PROCESSOR_INFO /* Define if the system has the type `ptrdiff_t'. */ #define HAVE_PTRDIFF_T 1 /* Define if the system has the type `quad_t'. */ #undef HAVE_QUAD_T #define HAVE_RAISE 1 /* Define if you have the `read_real_time' function. */ #undef HAVE_READ_REAL_TIME /* Define if you have the `sigaction' function. */ #undef HAVE_SIGACTION /* Define if you have the `sigaltstack' function. */ #undef HAVE_SIGALTSTACK /* Define if you have the `sigstack' function. */ #undef HAVE_SIGSTACK /* Tune directory speed_cyclecounter, undef=none, 1=32bits, 2=64bits) */ #define HAVE_SPEED_CYCLECOUNTER 2 /* Define if the system has the type `stack_t'. */ #undef HAVE_STACK_T /* Define if exists and works */ #define HAVE_STDARG 1 /* Define if you have the header file. */ #undef HAVE_STDINT_H /* Define if you have the header file. */ #define HAVE_STDLIB_H 1 /* Define if you have the `strcasecmp' function. */ #undef HAVE_STRCASECMP /* Define if you have the `strchr' function. */ #define HAVE_STRCHR 1 /* Define if cpp supports the ANSI # stringizing operator. */ #define HAVE_STRINGIZE 1 /* Define if you have the header file. */ #undef HAVE_STRINGS_H /* Define if you have the header file. */ #define HAVE_STRING_H 1 /* Define if you have the `strnlen' function. */ #define HAVE_STRNLEN 1 /* Define if you have the `strtoul' function. */ #define HAVE_STRTOUL 1 /* Define if you have the `sysconf' function. */ #undef HAVE_SYSCONF /* Define if you have the `sysctl' function. */ #undef HAVE_SYSCTL /* Define if you have the `sysctlbyname' function. */ #undef HAVE_SYSCTLBYNAME /* Define if you have the `syssgi' function. */ #undef HAVE_SYSSGI /* Define if you have the header file. */ #undef HAVE_SYS_MMAN_H /* Define if you have the header file. */ #undef HAVE_SYS_PARAM_H /* Define if you have the header file. */ #undef HAVE_SYS_PROCESSOR_H /* Define if you have the header file. */ #undef HAVE_SYS_RESOURCE_H /* Define if you have the header file. */ #define HAVE_SYS_STAT_H 1 /* Define if you have the header file. */ #undef HAVE_SYS_SYSCTL_H /* Define if you have the header file. */ #undef HAVE_SYS_SYSSGI_H /* Define if you have the header file. */ #undef HAVE_SYS_SYSTEMCFG_H /* Define if you have the header file. */ #undef HAVE_SYS_TIMES_H /* Define if you have the header file. */ #undef HAVE_SYS_TIME_H /* Define if you have the header file. */ #define HAVE_SYS_TYPES_H 1 /* Define if you have the `times' function. */ #undef HAVE_TIMES /* Define if you have the header file. */ #undef HAVE_UNISTD_H /* Define if you have vsnprintf and it works properly. */ #undef HAVE_VSNPRINTF /* Assembler local label prefix */ #undef LSYM_PREFIX /* Define if you have the `fesetround' function via the header file. */ #undef MPFR_HAVE_FESETROUND #define HAVE_SSTREAM 1 /* Name of package */ #define PACKAGE "gmp" /* Define if compiler has function prototypes */ #define PROTOTYPES 1 /* Define as the return type of signal handlers (`int' or `void'). */ #define RETSIGTYPE void /* The size of a `unsigned long', as computed by sizeof. */ #define SIZEOF_UNSIGNED_LONG 4 /* Define if sscanf requires writable inputs */ #undef SSCANF_WRITABLE_INPUT /* Define if you have the ANSI C header files. */ #define STDC_HEADERS 1 /* Define if you can safely include both and . */ #undef TIME_WITH_SYS_TIME /* Maximum size the tune program can test for KARATSUBA_SQR_THRESHOLD */ #define TUNE_KARATSUBA_SQR_MAX 67 /* Version number of package */ #define VERSION "4.2.1 (VC8)" /* ./configure --enable-assert option, to enable some ASSERT()s */ #undef WANT_ASSERT /* ./configure --enable-fft option, to enable FFTs for multiplication */ #define WANT_FFT 1 /* Define to 1 if --enable-profiling=gprof */ #undef WANT_PROFILING_GPROF /* Define to 1 if --enable-profiling=prof */ #undef WANT_PROFILING_PROF /* --enable-alloca=yes */ #undef WANT_TMP_ALLOCA /* --enable-alloca=debug */ #undef WANT_TMP_DEBUG /* --enable-alloca=malloc-notreentrant */ #undef WANT_TMP_NOTREENTRANT /* --enable-alloca=malloc-reentrant */ #define WANT_TMP_REENTRANT 1 /* Define if your processor stores words with the most significant byte first (like Motorola and SPARC, unlike Intel and VAX). */ #undef WORDS_BIGENDIAN /* Define if `lex' declares `yytext' as a `char *' by default, not a `char[]'. */ #undef YYTEXT_POINTER /* Define as `__inline' if that's what the C compiler calls it, or to nothing if it is not supported. */ #define inline __inline /* Define to empty if the keyword `volatile' does not work. Warning: valid code using `volatile' can become incorrect without. Disable with care. */ #undef volatile #ifdef _MSC_VER #define strcasecmp _stricmp #define strncasecmp _strnicmp #define alloca _alloca #define HAVE_STRCASECMP 1 #define HAVE_STRNCASECMP 1 #endif ecl-16.1.2/msvc/gmp/build.vc8/config-vc8.p3000077500000000000000000000360361266352375300201330ustar00rootroot00000000000000/* Templates for defines setup by configure. Copyright 2000, 2001, 2002 Free Software Foundation, Inc. This file is part of the GNU MP Library. The GNU MP Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU MP Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU MP Library; see the file COPYING.LIB. If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ /* Define one (and only one) of these for the CPU host. Only hosts that are going to be tested for need to be in this list, not everything that can possibly be selected. */ #undef HAVE_HOST_CPU_alpha #undef HAVE_HOST_CPU_alphaev5 #undef HAVE_HOST_CPU_alphaev6 #undef HAVE_HOST_CPU_alphaev67 #undef HAVE_HOST_CPU_m68k #undef HAVE_HOST_CPU_m68000 #undef HAVE_HOST_CPU_m68010 #undef HAVE_HOST_CPU_m68020 #undef HAVE_HOST_CPU_m68030 #undef HAVE_HOST_CPU_m68040 #undef HAVE_HOST_CPU_m68060 #undef HAVE_HOST_CPU_m68302 #undef HAVE_HOST_CPU_m68360 #undef HAVE_HOST_CPU_powerpc604 #undef HAVE_HOST_CPU_powerpc604e #undef HAVE_HOST_CPU_powerpc750 #undef HAVE_HOST_CPU_powerpc7400 #undef HAVE_HOST_CPU_sparc #undef HAVE_HOST_CPU_sparcv8 #undef HAVE_HOST_CPU_supersparc #undef HAVE_HOST_CPU_sparclite #undef HAVE_HOST_CPU_microsparc #undef HAVE_HOST_CPU_ultrasparc1 #undef HAVE_HOST_CPU_ultrasparc2 #undef HAVE_HOST_CPU_sparc64 #undef HAVE_HOST_CPU_hppa1_0 #undef HAVE_HOST_CPU_hppa1_1 #undef HAVE_HOST_CPU_hppa2_0n #undef HAVE_HOST_CPU_hppa2_0w #undef HAVE_HOST_CPU_i386 #undef HAVE_HOST_CPU_i486 #undef HAVE_HOST_CPU_i586 #undef HAVE_HOST_CPU_i686 #undef HAVE_HOST_CPU_pentium #undef HAVE_HOST_CPU_pentiummmx #undef HAVE_HOST_CPU_pentiumpro #undef HAVE_HOST_CPU_pentium2 #define HAVE_HOST_CPU_pentium3 1 #undef HAVE_HOST_CPU_k5 #undef HAVE_HOST_CPU_k6 #undef HAVE_HOST_CPU_k62 #undef HAVE_HOST_CPU_k63 #undef HAVE_HOST_CPU_athlon /* a dummy to make autoheader happy */ #undef HAVE_HOST_CPU_ /* Define one (and only one) of these for the CPU host family. Only hosts that are going to be tested for need to be in this list, not everything that can possibly be selected. */ #undef HAVE_HOST_CPU_FAMILY_power #undef HAVE_HOST_CPU_FAMILY_powerpc #define HAVE_HOST_CPU_FAMILY_x86 1 /* Define if we have native implementation of function. (use just one of the three following defines) */ #undef HAVE_NATIVE_mpn_add #undef HAVE_NATIVE_mpn_add_1 #undef HAVE_NATIVE_mpn_addmul_2 #undef HAVE_NATIVE_mpn_addmul_3 #undef HAVE_NATIVE_mpn_addmul_4 #undef HAVE_NATIVE_mpn_addsub_n #undef HAVE_NATIVE_mpn_addsub_nc #undef HAVE_NATIVE_mpn_and_n #undef HAVE_NATIVE_mpn_andn_n #undef HAVE_NATIVE_mpn_bdivmod #undef HAVE_NATIVE_mpn_cmp #undef HAVE_NATIVE_mpn_com_n #undef HAVE_NATIVE_mpn_divrem #undef HAVE_NATIVE_mpn_divrem_2 #undef HAVE_NATIVE_mpn_divrem_newton #undef HAVE_NATIVE_mpn_divrem_classic #undef HAVE_NATIVE_mpn_dump #undef HAVE_NATIVE_mpn_gcd #undef HAVE_NATIVE_mpn_gcd_1 #undef HAVE_NATIVE_mpn_gcd_finda #undef HAVE_NATIVE_mpn_gcdext #undef HAVE_NATIVE_mpn_get_str #undef HAVE_NATIVE_mpn_invert_limb #undef HAVE_NATIVE_mpn_ior_n #undef HAVE_NATIVE_mpn_iorn_n #undef HAVE_NATIVE_mpn_mul #undef HAVE_NATIVE_mpn_mul_2 #undef HAVE_NATIVE_mpn_mul_3 #undef HAVE_NATIVE_mpn_mul_4 #undef HAVE_NATIVE_mpn_mul_n #undef HAVE_NATIVE_mpn_nand_n #undef HAVE_NATIVE_mpn_nior_n #undef HAVE_NATIVE_mpn_perfect_square_p #undef HAVE_NATIVE_mpn_preinv_mod_1 #undef HAVE_NATIVE_mpn_random2 #undef HAVE_NATIVE_mpn_random #undef HAVE_NATIVE_mpn_rawrandom #undef HAVE_NATIVE_mpn_scan0 #undef HAVE_NATIVE_mpn_scan1 #undef HAVE_NATIVE_mpn_set_str #undef HAVE_NATIVE_mpn_sqrtrem #undef HAVE_NATIVE_mpn_sqr_diagonal #undef HAVE_NATIVE_mpn_sub #undef HAVE_NATIVE_mpn_sub_1 #undef HAVE_NATIVE_mpn_udiv_w_sdiv #undef HAVE_NATIVE_mpn_xor_n #undef HAVE_NATIVE_mpn_xnor_n #undef HAVE_NATIVE_mpn_add_n #undef HAVE_NATIVE_mpn_add_nc #undef HAVE_NATIVE_mpn_sub_n #undef HAVE_NATIVE_mpn_sub_nc #undef HAVE_NATIVE_mpn_addmul_1 #undef HAVE_NATIVE_mpn_addmul_1c #undef HAVE_NATIVE_mpn_submul_1 #undef HAVE_NATIVE_mpn_submul_1c #undef HAVE_NATIVE_mpn_copyd #undef HAVE_NATIVE_mpn_copyi #undef HAVE_NATIVE_mpn_divexact_1 #undef HAVE_NATIVE_mpn_divexact_by3c #undef HAVE_NATIVE_mpn_divrem_1 #undef HAVE_NATIVE_mpn_divrem_1c #undef HAVE_NATIVE_mpn_hamdist #undef HAVE_NATIVE_mpn_popcount #undef HAVE_NATIVE_mpn_lshift #undef HAVE_NATIVE_mpn_rshift #undef HAVE_NATIVE_mpn_mod_1 #undef HAVE_NATIVE_mpn_mod_1c #undef HAVE_NATIVE_mpn_modexact_1_odd #undef HAVE_NATIVE_mpn_modexact_1c_odd #undef HAVE_NATIVE_mpn_mul_1 #undef HAVE_NATIVE_mpn_mul_1c #undef HAVE_NATIVE_mpn_mul_basecase #undef HAVE_NATIVE_mpn_sqr_basecase #undef HAVE_NATIVE_mpn_umul_ppmm #undef HAVE_NATIVE_mpn_udiv_qrnnd /* For the Intel P3 assembler code */ #define HAVE_NATIVE_mpn_add_n 1 #define HAVE_NATIVE_mpn_add_nc 1 #define HAVE_NATIVE_mpn_sub_n 1 #define HAVE_NATIVE_mpn_sub_nc 1 #define HAVE_NATIVE_mpn_addmul_1 1 #define HAVE_NATIVE_mpn_submul_1 1 #define HAVE_NATIVE_mpn_copyd 1 #define HAVE_NATIVE_mpn_copyi 1 #define HAVE_NATIVE_mpn_divexact_1 1 #define HAVE_NATIVE_mpn_divexact_by3c 1 #define HAVE_NATIVE_mpn_divrem_1 1 #define HAVE_NATIVE_mpn_divrem_1c 1 #define HAVE_NATIVE_mpn_hamdist 1 #define HAVE_NATIVE_mpn_popcount 1 #define HAVE_NATIVE_mpn_lshift 1 #define HAVE_NATIVE_mpn_rshift 1 #define HAVE_NATIVE_mpn_mod_1 1 #define HAVE_NATIVE_mpn_mod_1c 1 #define HAVE_NATIVE_mpn_modexact_1_odd 1 #define HAVE_NATIVE_mpn_modexact_1c_odd 1 #define HAVE_NATIVE_mpn_mul_1 1 #define HAVE_NATIVE_mpn_mul_basecase 1 #define HAVE_NATIVE_mpn_sqr_basecase 1 #define HAVE_NATIVE_mpn_umul_ppmm 1 #define HAVE_NATIVE_mpn_udiv_qrnnd 1 /* a dummy to make autoheader happy */ #undef HAVE_NATIVE_ /* The gmp-mparam.h to update when tuning. */ #undef GMP_MPARAM_H_SUGGEST /* Define if you have the `alarm' function. */ #undef HAVE_ALARM /* Define if alloca() works (via gmp-impl.h). */ #define HAVE_ALLOCA 1 /* Define if you have and it should be used (not on Ultrix). */ #undef HAVE_ALLOCA_H /* Define if the compiler accepts gcc style __attribute__ ((const)) */ #undef HAVE_ATTRIBUTE_CONST /* Define if the compiler accepts gcc style __attribute__ ((malloc)) */ #undef HAVE_ATTRIBUTE_MALLOC /* Define if the compiler accepts gcc style __attribute__ ((mode (XX))) */ #undef HAVE_ATTRIBUTE_MODE /* Define if the compiler accepts gcc style __attribute__ ((noreturn)) */ #undef HAVE_ATTRIBUTE_NORETURN /* Define if tests/libtests has calling conventions checking for the CPU */ #undef HAVE_CALLING_CONVENTIONS /* Define if you have the `clock' function. */ #define HAVE_CLOCK 1 /* Define if you have the `clock_gettime' function. */ #undef HAVE_CLOCK_GETTIME /* Define if you have the `cputime' function. */ #undef HAVE_CPUTIME /* Define to 1 if you have the declaration of `fgetc', and to 0 if you don't. */ #define HAVE_DECL_FGETC 1 /* Define to 1 if you have the declaration of `fscanf', and to 0 if you don't. */ #define HAVE_DECL_FSCANF 1 /* Define to 1 if you have the declaration of `optarg', and to 0 if you don't. */ #define HAVE_DECL_OPTARG 0 /* Define to 1 if you have the declaration of `ungetc', and to 0 if you don't. */ #define HAVE_DECL_UNGETC 1 /* Define to 1 if you have the declaration of `vfprintf', and to 0 if you don't. */ #define HAVE_DECL_VFPRINTF 1 /* Define if denormalized floats work. */ #define HAVE_DENORMS 1 /* Define if you have the header file. */ #undef HAVE_DLFCN_H /* Define one (and only one) of the following for the format of a `double'. If your format is not among these choices, or you don't know what it is, then leave all of them undefined. "IEEE_LITTLE_SWAPPED" means little endian, but with the two 4-byte halves swapped, as used by ARM CPUs in little endian mode. */ #undef HAVE_DOUBLE_IEEE_BIG_ENDIAN #define HAVE_DOUBLE_IEEE_LITTLE_ENDIAN 1 #undef HAVE_DOUBLE_IEEE_LITTLE_SWAPPED #undef HAVE_DOUBLE_VAX_D #undef HAVE_DOUBLE_VAX_G #undef HAVE_DOUBLE_CRAY_CFP /* Define if you have the header file. */ #define HAVE_FCNTL_H 1 /* Define if you have the header file. */ #undef HAVE_FPU_CONTROL_H /* Define if you have the `getpagesize' function. */ #undef HAVE_GETPAGESIZE /* Define if you have the `getrusage' function. */ #undef HAVE_GETRUSAGE /* Define if you have the `gettimeofday' function. */ #undef HAVE_GETTIMEOFDAY /* Define if 0/0, 1/0, -1/0 and sqrt(-1) work to generate NaN/infinities. */ #define HAVE_INFS 1 /* Define if the system has the type `intmax_t'. */ #undef HAVE_INTMAX_T /* Define if you have the header file. */ #undef HAVE_INTTYPES_H /* Define one (just one) of the following for the endiannes of `mp_limb_t'. If the endianness is not a simple big or little, or you don't know what it is, then leave both of these undefined. */ #undef HAVE_LIMB_BIG_ENDIAN #define HAVE_LIMB_LITTLE_ENDIAN 1 #define HAVE_STD__LOCALE 1 /* Define if you have the `localeconv' function. */ #define HAVE_LOCALECONV 1 /* Define if you have the header file. */ #define HAVE_LOCALE_H 1 /* Define if the system has the type `long double'. */ #define HAVE_LONG_DOUBLE 1 /* Define if the system has the type `long long'. */ #define HAVE_LONG_LONG 1 /* Define if you have the `lrand48' function. */ #undef HAVE_LRAND48 /* Define if you have the header file. */ #define HAVE_MEMORY_H 1 /* Define if you have the `memset' function. */ #define HAVE_MEMSET 1 /* Define if you have the `mmap' function. */ #undef HAVE_MMAP /* Define if you have the `mprotect' function. */ #undef HAVE_MPROTECT /* Define if you have the `obstack_vprintf' function. */ #undef HAVE_OBSTACK_VPRINTF /* Define if you have the `popen' function. */ #undef HAVE_POPEN /* Define if you have the `processor_info' function. */ #undef HAVE_PROCESSOR_INFO /* Define if the system has the type `ptrdiff_t'. */ #define HAVE_PTRDIFF_T 1 /* Define if the system has the type `quad_t'. */ #undef HAVE_QUAD_T #define HAVE_RAISE 1 /* Define if you have the `read_real_time' function. */ #undef HAVE_READ_REAL_TIME /* Define if you have the `sigaction' function. */ #undef HAVE_SIGACTION /* Define if you have the `sigaltstack' function. */ #undef HAVE_SIGALTSTACK /* Define if you have the `sigstack' function. */ #undef HAVE_SIGSTACK /* Tune directory speed_cyclecounter, undef=none, 1=32bits, 2=64bits) */ #define HAVE_SPEED_CYCLECOUNTER 2 /* Define if the system has the type `stack_t'. */ #undef HAVE_STACK_T /* Define if exists and works */ #define HAVE_STDARG 1 /* Define if you have the header file. */ #undef HAVE_STDINT_H /* Define if you have the header file. */ #define HAVE_STDLIB_H 1 /* Define if you have the `strcasecmp' function. */ #undef HAVE_STRCASECMP /* Define if you have the `strchr' function. */ #define HAVE_STRCHR 1 /* Define if cpp supports the ANSI # stringizing operator. */ #define HAVE_STRINGIZE 1 /* Define if you have the header file. */ #undef HAVE_STRINGS_H /* Define if you have the header file. */ #define HAVE_STRING_H 1 /* Define if you have the `strnlen' function. */ #define HAVE_STRNLEN 1 /* Define if you have the `strtoul' function. */ #define HAVE_STRTOUL 1 /* Define if you have the `sysconf' function. */ #undef HAVE_SYSCONF /* Define if you have the `sysctl' function. */ #undef HAVE_SYSCTL /* Define if you have the `sysctlbyname' function. */ #undef HAVE_SYSCTLBYNAME /* Define if you have the `syssgi' function. */ #undef HAVE_SYSSGI /* Define if you have the header file. */ #undef HAVE_SYS_MMAN_H /* Define if you have the header file. */ #undef HAVE_SYS_PARAM_H /* Define if you have the header file. */ #undef HAVE_SYS_PROCESSOR_H /* Define if you have the header file. */ #undef HAVE_SYS_RESOURCE_H /* Define if you have the header file. */ #define HAVE_SYS_STAT_H 1 /* Define if you have the header file. */ #undef HAVE_SYS_SYSCTL_H /* Define if you have the header file. */ #undef HAVE_SYS_SYSSGI_H /* Define if you have the header file. */ #undef HAVE_SYS_SYSTEMCFG_H /* Define if you have the header file. */ #undef HAVE_SYS_TIMES_H /* Define if you have the header file. */ #undef HAVE_SYS_TIME_H /* Define if you have the header file. */ #define HAVE_SYS_TYPES_H 1 /* Define if you have the `times' function. */ #undef HAVE_TIMES /* Define if you have the header file. */ #undef HAVE_UNISTD_H /* Define if you have vsnprintf and it works properly. */ #undef HAVE_VSNPRINTF /* Assembler local label prefix */ #undef LSYM_PREFIX /* Define if you have the `fesetround' function via the header file. */ #undef MPFR_HAVE_FESETROUND #define HAVE_SSTREAM 1 /* Name of package */ #define PACKAGE "gmp" /* Define if compiler has function prototypes */ #define PROTOTYPES 1 /* Define as the return type of signal handlers (`int' or `void'). */ #define RETSIGTYPE void /* The size of a `unsigned long', as computed by sizeof. */ #define SIZEOF_UNSIGNED_LONG 4 /* Define if sscanf requires writable inputs */ #undef SSCANF_WRITABLE_INPUT /* Define if you have the ANSI C header files. */ #define STDC_HEADERS 1 /* Define if you can safely include both and . */ #undef TIME_WITH_SYS_TIME /* Maximum size the tune program can test for KARATSUBA_SQR_THRESHOLD */ #define TUNE_KARATSUBA_SQR_MAX 67 /* Version number of package */ #define VERSION "4.2.1 (VC8)" /* ./configure --enable-assert option, to enable some ASSERT()s */ #undef WANT_ASSERT /* ./configure --enable-fft option, to enable FFTs for multiplication */ #define WANT_FFT 1 /* Define to 1 if --enable-profiling=gprof */ #undef WANT_PROFILING_GPROF /* Define to 1 if --enable-profiling=prof */ #undef WANT_PROFILING_PROF /* --enable-alloca=yes */ #undef WANT_TMP_ALLOCA /* --enable-alloca=debug */ #undef WANT_TMP_DEBUG /* --enable-alloca=malloc-notreentrant */ #undef WANT_TMP_NOTREENTRANT /* --enable-alloca=malloc-reentrant */ #define WANT_TMP_REENTRANT 1 /* Define if your processor stores words with the most significant byte first (like Motorola and SPARC, unlike Intel and VAX). */ #undef WORDS_BIGENDIAN /* Define if `lex' declares `yytext' as a `char *' by default, not a `char[]'. */ #undef YYTEXT_POINTER /* Define as `__inline' if that's what the C compiler calls it, or to nothing if it is not supported. */ #define inline __inline /* Define to empty if the keyword `volatile' does not work. Warning: valid code using `volatile' can become incorrect without. Disable with care. */ #undef volatile #ifdef _MSC_VER #define strcasecmp _stricmp #define strncasecmp _strnicmp #define alloca _alloca #define HAVE_STRCASECMP 1 #define HAVE_STRNCASECMP 1 #endif ecl-16.1.2/msvc/gmp/build.vc8/config-vc8.p4000077500000000000000000000362511266352375300201330ustar00rootroot00000000000000/* Templates for defines setup by configure. Copyright 2000, 2001, 2002 Free Software Foundation, Inc. This file is part of the GNU MP Library. The GNU MP Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU MP Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU MP Library; see the file COPYING.LIB. If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ /* Define one (and only one) of these for the CPU host. Only hosts that are going to be tested for need to be in this list, not everything that can possibly be selected. */ #undef HAVE_HOST_CPU_alpha #undef HAVE_HOST_CPU_alphaev5 #undef HAVE_HOST_CPU_alphaev6 #undef HAVE_HOST_CPU_alphaev67 #undef HAVE_HOST_CPU_m68k #undef HAVE_HOST_CPU_m68000 #undef HAVE_HOST_CPU_m68010 #undef HAVE_HOST_CPU_m68020 #undef HAVE_HOST_CPU_m68030 #undef HAVE_HOST_CPU_m68040 #undef HAVE_HOST_CPU_m68060 #undef HAVE_HOST_CPU_m68302 #undef HAVE_HOST_CPU_m68360 #undef HAVE_HOST_CPU_powerpc604 #undef HAVE_HOST_CPU_powerpc604e #undef HAVE_HOST_CPU_powerpc750 #undef HAVE_HOST_CPU_powerpc7400 #undef HAVE_HOST_CPU_sparc #undef HAVE_HOST_CPU_sparcv8 #undef HAVE_HOST_CPU_supersparc #undef HAVE_HOST_CPU_sparclite #undef HAVE_HOST_CPU_microsparc #undef HAVE_HOST_CPU_ultrasparc1 #undef HAVE_HOST_CPU_ultrasparc2 #undef HAVE_HOST_CPU_sparc64 #undef HAVE_HOST_CPU_hppa1_0 #undef HAVE_HOST_CPU_hppa1_1 #undef HAVE_HOST_CPU_hppa2_0n #undef HAVE_HOST_CPU_hppa2_0w #undef HAVE_HOST_CPU_i386 #undef HAVE_HOST_CPU_i486 #undef HAVE_HOST_CPU_i586 #undef HAVE_HOST_CPU_i686 #undef HAVE_HOST_CPU_pentium #undef HAVE_HOST_CPU_pentiummmx #undef HAVE_HOST_CPU_pentiumpro #undef HAVE_HOST_CPU_pentium2 #undef HAVE_HOST_CPU_pentium3 #define HAVE_HOST_CPU_pentium4 1 #undef HAVE_HOST_CPU_k5 #undef HAVE_HOST_CPU_k6 #undef HAVE_HOST_CPU_k62 #undef HAVE_HOST_CPU_k63 #undef HAVE_HOST_CPU_athlon /* a dummy to make autoheader happy */ #undef HAVE_HOST_CPU_ /* Define one (and only one) of these for the CPU host family. Only hosts that are going to be tested for need to be in this list, not everything that can possibly be selected. */ #undef HAVE_HOST_CPU_FAMILY_power #undef HAVE_HOST_CPU_FAMILY_powerpc #define HAVE_HOST_CPU_FAMILY_x86 1 /* Define if we have native implementation of function. (use just one of the three following defines) */ #undef HAVE_NATIVE_mpn_add #undef HAVE_NATIVE_mpn_add_1 #undef HAVE_NATIVE_mpn_addmul_2 #undef HAVE_NATIVE_mpn_addmul_3 #undef HAVE_NATIVE_mpn_addmul_4 #undef HAVE_NATIVE_mpn_addsub_n #undef HAVE_NATIVE_mpn_addsub_nc #undef HAVE_NATIVE_mpn_and_n #undef HAVE_NATIVE_mpn_andn_n #undef HAVE_NATIVE_mpn_bdivmod #undef HAVE_NATIVE_mpn_cmp #undef HAVE_NATIVE_mpn_com_n #undef HAVE_NATIVE_mpn_divrem #undef HAVE_NATIVE_mpn_divrem_2 #undef HAVE_NATIVE_mpn_divrem_newton #undef HAVE_NATIVE_mpn_divrem_classic #undef HAVE_NATIVE_mpn_dump #undef HAVE_NATIVE_mpn_gcd #undef HAVE_NATIVE_mpn_gcd_1 #undef HAVE_NATIVE_mpn_gcd_finda #undef HAVE_NATIVE_mpn_gcdext #undef HAVE_NATIVE_mpn_get_str #undef HAVE_NATIVE_mpn_invert_limb #undef HAVE_NATIVE_mpn_ior_n #undef HAVE_NATIVE_mpn_iorn_n #undef HAVE_NATIVE_mpn_mul #undef HAVE_NATIVE_mpn_mul_2 #undef HAVE_NATIVE_mpn_mul_3 #undef HAVE_NATIVE_mpn_mul_4 #undef HAVE_NATIVE_mpn_mul_n #undef HAVE_NATIVE_mpn_nand_n #undef HAVE_NATIVE_mpn_nior_n #undef HAVE_NATIVE_mpn_perfect_square_p #undef HAVE_NATIVE_mpn_preinv_mod_1 #undef HAVE_NATIVE_mpn_random2 #undef HAVE_NATIVE_mpn_random #undef HAVE_NATIVE_mpn_rawrandom #undef HAVE_NATIVE_mpn_scan0 #undef HAVE_NATIVE_mpn_scan1 #undef HAVE_NATIVE_mpn_set_str #undef HAVE_NATIVE_mpn_sqrtrem #undef HAVE_NATIVE_mpn_sqr_diagonal #undef HAVE_NATIVE_mpn_sub #undef HAVE_NATIVE_mpn_sub_1 #undef HAVE_NATIVE_mpn_udiv_w_sdiv #undef HAVE_NATIVE_mpn_xor_n #undef HAVE_NATIVE_mpn_xnor_n #undef HAVE_NATIVE_mpn_add_n #undef HAVE_NATIVE_mpn_add_nc #undef HAVE_NATIVE_mpn_sub_n #undef HAVE_NATIVE_mpn_sub_nc #undef HAVE_NATIVE_mpn_addmul_1 #undef HAVE_NATIVE_mpn_addmul_1c #undef HAVE_NATIVE_mpn_submul_1 #undef HAVE_NATIVE_mpn_submul_1c #undef HAVE_NATIVE_mpn_copyd #undef HAVE_NATIVE_mpn_copyi #undef HAVE_NATIVE_mpn_divexact_1 #undef HAVE_NATIVE_mpn_divexact_by3c #undef HAVE_NATIVE_mpn_divrem_1 #undef HAVE_NATIVE_mpn_divrem_1c #undef HAVE_NATIVE_mpn_hamdist #undef HAVE_NATIVE_mpn_popcount #undef HAVE_NATIVE_mpn_lshift #undef HAVE_NATIVE_mpn_rshift #undef HAVE_NATIVE_mpn_mod_1 #undef HAVE_NATIVE_mpn_mod_1c #undef HAVE_NATIVE_mpn_modexact_1_odd #undef HAVE_NATIVE_mpn_modexact_1c_odd #undef HAVE_NATIVE_mpn_mul_1 #undef HAVE_NATIVE_mpn_mul_1c #undef HAVE_NATIVE_mpn_mul_basecase #undef HAVE_NATIVE_mpn_sqr_basecase #undef HAVE_NATIVE_mpn_umul_ppmm #undef HAVE_NATIVE_mpn_udiv_qrnnd /* For the Intel P4 assembler code */ #define HAVE_NATIVE_mpn_add_n 1 #define HAVE_NATIVE_mpn_add_nc 1 #define HAVE_NATIVE_mpn_sub_n 1 #define HAVE_NATIVE_mpn_sub_nc 1 #define HAVE_NATIVE_mpn_addmul_1 1 #define HAVE_NATIVE_mpn_addmul_1c 1 #define HAVE_NATIVE_mpn_submul_1 1 #define HAVE_NATIVE_mpn_submul_1c 1 #define HAVE_NATIVE_mpn_copyd 1 #define HAVE_NATIVE_mpn_copyi 1 #define HAVE_NATIVE_mpn_divexact_1 1 #define HAVE_NATIVE_mpn_divexact_by3c 1 #define HAVE_NATIVE_mpn_divrem_1 1 #define HAVE_NATIVE_mpn_divrem_1c 1 #define HAVE_NATIVE_mpn_hamdist 1 #define HAVE_NATIVE_mpn_popcount 1 #define HAVE_NATIVE_mpn_lshift 1 #define HAVE_NATIVE_mpn_rshift 1 #define HAVE_NATIVE_mpn_mod_1 1 #define HAVE_NATIVE_mpn_mod_1c 1 #define HAVE_NATIVE_mpn_modexact_1_odd 1 #define HAVE_NATIVE_mpn_modexact_1c_odd 1 #define HAVE_NATIVE_mpn_mul_1 1 #define HAVE_NATIVE_mpn_mul_1c 1 #define HAVE_NATIVE_mpn_mul_basecase 1 #define HAVE_NATIVE_mpn_sqr_basecase 1 #define HAVE_NATIVE_mpn_umul_ppmm 1 #define HAVE_NATIVE_mpn_udiv_qrnnd 1 /* a dummy to make autoheader happy */ #undef HAVE_NATIVE_ /* The gmp-mparam.h to update when tuning. */ #undef GMP_MPARAM_H_SUGGEST /* Define if you have the `alarm' function. */ #undef HAVE_ALARM /* Define if alloca() works (via gmp-impl.h). */ #define HAVE_ALLOCA 1 /* Define if you have and it should be used (not on Ultrix). */ #undef HAVE_ALLOCA_H /* Define if the compiler accepts gcc style __attribute__ ((const)) */ #undef HAVE_ATTRIBUTE_CONST /* Define if the compiler accepts gcc style __attribute__ ((malloc)) */ #undef HAVE_ATTRIBUTE_MALLOC /* Define if the compiler accepts gcc style __attribute__ ((mode (XX))) */ #undef HAVE_ATTRIBUTE_MODE /* Define if the compiler accepts gcc style __attribute__ ((noreturn)) */ #undef HAVE_ATTRIBUTE_NORETURN /* Define if tests/libtests has calling conventions checking for the CPU */ #undef HAVE_CALLING_CONVENTIONS /* Define if you have the `clock' function. */ #define HAVE_CLOCK 1 /* Define if you have the `clock_gettime' function. */ #undef HAVE_CLOCK_GETTIME /* Define if you have the `cputime' function. */ #undef HAVE_CPUTIME /* Define to 1 if you have the declaration of `fgetc', and to 0 if you don't. */ #define HAVE_DECL_FGETC 1 /* Define to 1 if you have the declaration of `fscanf', and to 0 if you don't. */ #define HAVE_DECL_FSCANF 1 /* Define to 1 if you have the declaration of `optarg', and to 0 if you don't. */ #define HAVE_DECL_OPTARG 0 /* Define to 1 if you have the declaration of `ungetc', and to 0 if you don't. */ #define HAVE_DECL_UNGETC 1 /* Define to 1 if you have the declaration of `vfprintf', and to 0 if you don't. */ #define HAVE_DECL_VFPRINTF 1 /* Define if denormalized floats work. */ #define HAVE_DENORMS 1 /* Define if you have the header file. */ #undef HAVE_DLFCN_H /* Define one (and only one) of the following for the format of a `double'. If your format is not among these choices, or you don't know what it is, then leave all of them undefined. "IEEE_LITTLE_SWAPPED" means little endian, but with the two 4-byte halves swapped, as used by ARM CPUs in little endian mode. */ #undef HAVE_DOUBLE_IEEE_BIG_ENDIAN #define HAVE_DOUBLE_IEEE_LITTLE_ENDIAN 1 #undef HAVE_DOUBLE_IEEE_LITTLE_SWAPPED #undef HAVE_DOUBLE_VAX_D #undef HAVE_DOUBLE_VAX_G #undef HAVE_DOUBLE_CRAY_CFP /* Define if you have the header file. */ #define HAVE_FCNTL_H 1 /* Define if you have the header file. */ #undef HAVE_FPU_CONTROL_H /* Define if you have the `getpagesize' function. */ #undef HAVE_GETPAGESIZE /* Define if you have the `getrusage' function. */ #undef HAVE_GETRUSAGE /* Define if you have the `gettimeofday' function. */ #undef HAVE_GETTIMEOFDAY /* Define if 0/0, 1/0, -1/0 and sqrt(-1) work to generate NaN/infinities. */ #define HAVE_INFS 1 /* Define if the system has the type `intmax_t'. */ #undef HAVE_INTMAX_T /* Define if you have the header file. */ #undef HAVE_INTTYPES_H /* Define one (just one) of the following for the endiannes of `mp_limb_t'. If the endianness is not a simple big or little, or you don't know what it is, then leave both of these undefined. */ #undef HAVE_LIMB_BIG_ENDIAN #define HAVE_LIMB_LITTLE_ENDIAN 1 #define HAVE_STD__LOCALE 1 /* Define if you have the `localeconv' function. */ #define HAVE_LOCALECONV 1 /* Define if you have the header file. */ #define HAVE_LOCALE_H 1 /* Define if the system has the type `long double'. */ #define HAVE_LONG_DOUBLE 1 /* Define if the system has the type `long long'. */ #define HAVE_LONG_LONG 1 /* Define if you have the `lrand48' function. */ #undef HAVE_LRAND48 /* Define if you have the header file. */ #define HAVE_MEMORY_H 1 /* Define if you have the `memset' function. */ #define HAVE_MEMSET 1 /* Define if you have the `mmap' function. */ #undef HAVE_MMAP /* Define if you have the `mprotect' function. */ #undef HAVE_MPROTECT /* Define if you have the `obstack_vprintf' function. */ #undef HAVE_OBSTACK_VPRINTF /* Define if you have the `popen' function. */ #undef HAVE_POPEN /* Define if you have the `processor_info' function. */ #undef HAVE_PROCESSOR_INFO /* Define if the system has the type `ptrdiff_t'. */ #define HAVE_PTRDIFF_T 1 /* Define if the system has the type `quad_t'. */ #undef HAVE_QUAD_T #define HAVE_RAISE 1 /* Define if you have the `read_real_time' function. */ #undef HAVE_READ_REAL_TIME /* Define if you have the `sigaction' function. */ #undef HAVE_SIGACTION /* Define if you have the `sigaltstack' function. */ #undef HAVE_SIGALTSTACK /* Define if you have the `sigstack' function. */ #undef HAVE_SIGSTACK /* Tune directory speed_cyclecounter, undef=none, 1=32bits, 2=64bits) */ #define HAVE_SPEED_CYCLECOUNTER 2 /* Define if the system has the type `stack_t'. */ #undef HAVE_STACK_T /* Define if exists and works */ #define HAVE_STDARG 1 /* Define if you have the header file. */ #undef HAVE_STDINT_H /* Define if you have the header file. */ #define HAVE_STDLIB_H 1 /* Define if you have the `strcasecmp' function. */ #undef HAVE_STRCASECMP /* Define if you have the `strchr' function. */ #define HAVE_STRCHR 1 /* Define if cpp supports the ANSI # stringizing operator. */ #define HAVE_STRINGIZE 1 /* Define if you have the header file. */ #undef HAVE_STRINGS_H /* Define if you have the header file. */ #define HAVE_STRING_H 1 /* Define if you have the `strnlen' function. */ #define HAVE_STRNLEN 1 /* Define if you have the `strtoul' function. */ #define HAVE_STRTOUL 1 /* Define if you have the `sysconf' function. */ #undef HAVE_SYSCONF /* Define if you have the `sysctl' function. */ #undef HAVE_SYSCTL /* Define if you have the `sysctlbyname' function. */ #undef HAVE_SYSCTLBYNAME /* Define if you have the `syssgi' function. */ #undef HAVE_SYSSGI /* Define if you have the header file. */ #undef HAVE_SYS_MMAN_H /* Define if you have the header file. */ #undef HAVE_SYS_PARAM_H /* Define if you have the header file. */ #undef HAVE_SYS_PROCESSOR_H /* Define if you have the header file. */ #undef HAVE_SYS_RESOURCE_H /* Define if you have the header file. */ #define HAVE_SYS_STAT_H 1 /* Define if you have the header file. */ #undef HAVE_SYS_SYSCTL_H /* Define if you have the header file. */ #undef HAVE_SYS_SYSSGI_H /* Define if you have the header file. */ #undef HAVE_SYS_SYSTEMCFG_H /* Define if you have the header file. */ #undef HAVE_SYS_TIMES_H /* Define if you have the header file. */ #undef HAVE_SYS_TIME_H /* Define if you have the header file. */ #define HAVE_SYS_TYPES_H 1 /* Define if you have the `times' function. */ #undef HAVE_TIMES /* Define if you have the header file. */ #undef HAVE_UNISTD_H /* Define if you have vsnprintf and it works properly. */ #undef HAVE_VSNPRINTF /* Assembler local label prefix */ #undef LSYM_PREFIX /* Define if you have the `fesetround' function via the header file. */ #undef MPFR_HAVE_FESETROUND #define HAVE_SSTREAM 1 /* Name of package */ #define PACKAGE "gmp" /* Define if compiler has function prototypes */ #define PROTOTYPES 1 /* Define as the return type of signal handlers (`int' or `void'). */ #define RETSIGTYPE void /* The size of a `unsigned long', as computed by sizeof. */ #define SIZEOF_UNSIGNED_LONG 4 /* Define if sscanf requires writable inputs */ #undef SSCANF_WRITABLE_INPUT /* Define if you have the ANSI C header files. */ #define STDC_HEADERS 1 /* Define if you can safely include both and . */ #undef TIME_WITH_SYS_TIME /* Maximum size the tune program can test for KARATSUBA_SQR_THRESHOLD */ #define TUNE_KARATSUBA_SQR_MAX 67 /* Version number of package */ #define VERSION "4.2.1 (VC8)" /* ./configure --enable-assert option, to enable some ASSERT()s */ #undef WANT_ASSERT /* ./configure --enable-fft option, to enable FFTs for multiplication */ #define WANT_FFT 1 /* Define to 1 if --enable-profiling=gprof */ #undef WANT_PROFILING_GPROF /* Define to 1 if --enable-profiling=prof */ #undef WANT_PROFILING_PROF /* --enable-alloca=yes */ #undef WANT_TMP_ALLOCA /* --enable-alloca=debug */ #undef WANT_TMP_DEBUG /* --enable-alloca=malloc-notreentrant */ #undef WANT_TMP_NOTREENTRANT /* --enable-alloca=malloc-reentrant */ #define WANT_TMP_REENTRANT 1 /* Define if your processor stores words with the most significant byte first (like Motorola and SPARC, unlike Intel and VAX). */ #undef WORDS_BIGENDIAN /* Define if `lex' declares `yytext' as a `char *' by default, not a `char[]'. */ #undef YYTEXT_POINTER /* Define as `__inline' if that's what the C compiler calls it, or to nothing if it is not supported. */ #define inline __inline /* Define to empty if the keyword `volatile' does not work. Warning: valid code using `volatile' can become incorrect without. Disable with care. */ #undef volatile #ifdef _MSC_VER #define strcasecmp _stricmp #define strncasecmp _strnicmp #define alloca _alloca #define HAVE_STRCASECMP 1 #define HAVE_STRNCASECMP 1 #endif ecl-16.1.2/msvc/gmp/build.vc8/dll_gmp_amd64/000077500000000000000000000000001266352375300203225ustar00rootroot00000000000000ecl-16.1.2/msvc/gmp/build.vc8/dll_gmp_amd64/dll_gmp_amd64.vcproj000077500000000000000000007506161266352375300242020ustar00rootroot00000000000000 ecl-16.1.2/msvc/gmp/build.vc8/dll_gmp_gc/000077500000000000000000000000001266352375300200005ustar00rootroot00000000000000ecl-16.1.2/msvc/gmp/build.vc8/dll_gmp_gc/dll_gmp_gc.vcproj000077500000000000000000015243301266352375300233270ustar00rootroot00000000000000 ecl-16.1.2/msvc/gmp/build.vc8/dll_gmp_p0/000077500000000000000000000000001266352375300177265ustar00rootroot00000000000000ecl-16.1.2/msvc/gmp/build.vc8/dll_gmp_p0/dll_gmp_p0.vcproj000077500000000000000000007171071266352375300232100ustar00rootroot00000000000000 ecl-16.1.2/msvc/gmp/build.vc8/dll_gmp_p3/000077500000000000000000000000001266352375300177315ustar00rootroot00000000000000ecl-16.1.2/msvc/gmp/build.vc8/dll_gmp_p3/dll_gmp_p3.vcproj000077500000000000000000007127471266352375300232230ustar00rootroot00000000000000 ecl-16.1.2/msvc/gmp/build.vc8/dll_gmp_p4/000077500000000000000000000000001266352375300177325ustar00rootroot00000000000000ecl-16.1.2/msvc/gmp/build.vc8/dll_gmp_p4/dll_gmp_p4.vcproj000077500000000000000000007151421266352375300232150ustar00rootroot00000000000000 ecl-16.1.2/msvc/gmp/build.vc8/dll_mpfr/000077500000000000000000000000001266352375300175105ustar00rootroot00000000000000ecl-16.1.2/msvc/gmp/build.vc8/dll_mpfr/dll_mpfr.vcproj000077500000000000000000005243061266352375300225510ustar00rootroot00000000000000 ecl-16.1.2/msvc/gmp/build.vc8/file_copy.bat000077500000000000000000000002631266352375300203560ustar00rootroot00000000000000if not exist %1 ( echo file_copy failure: %1 not found && goto exit) if exist %2 ( fc %1 %2 > nul && if not %errorlevel 1 goto exit ) echo copying %1 to %2 && copy %1 %2 :exitecl-16.1.2/msvc/gmp/build.vc8/gen-bases/000077500000000000000000000000001266352375300175555ustar00rootroot00000000000000ecl-16.1.2/msvc/gmp/build.vc8/gen-bases/gen-bases.c000077500000000000000000000113451266352375300215740ustar00rootroot00000000000000/* Generate mp_bases data. Copyright 1991, 1993, 1994, 1996, 2000, 2002, 2004 Free Software Foundation, Inc. This file is part of the GNU MP Library. The GNU MP Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU MP Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU MP Library; see the file COPYING.LIB. If not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ #include #include "dumbmp.c" int chars_per_limb; double chars_per_bit_exactly; mpz_t big_base; int normalization_steps; mpz_t big_base_inverted; mpz_t t; #define POW2_P(n) (((n) & ((n) - 1)) == 0) unsigned int ulog2 (unsigned int x) { unsigned int i; for (i = 0; x != 0; i++) x >>= 1; return i; } void generate (int limb_bits, int nail_bits, int base) { int numb_bits = limb_bits - nail_bits; mpz_set_ui (t, 1L); mpz_mul_2exp (t, t, numb_bits); mpz_set_ui (big_base, 1L); chars_per_limb = 0; for (;;) { mpz_mul_ui (big_base, big_base, (long) base); if (mpz_cmp (big_base, t) > 0) break; chars_per_limb++; } chars_per_bit_exactly = 0.69314718055994530942 / log ((double) base); mpz_ui_pow_ui (big_base, (long) base, (long) chars_per_limb); normalization_steps = limb_bits - mpz_sizeinbase (big_base, 2); mpz_set_ui (t, 1L); mpz_mul_2exp (t, t, 2*limb_bits - normalization_steps); mpz_tdiv_q (big_base_inverted, t, big_base); mpz_set_ui (t, 1L); mpz_mul_2exp (t, t, limb_bits); mpz_sub (big_base_inverted, big_base_inverted, t); } void header (int limb_bits, int nail_bits) { int numb_bits = limb_bits - nail_bits; generate (limb_bits, nail_bits, 10); printf ("/* This file generated by gen-bases.c - DO NOT EDIT. */\n"); printf ("\n"); printf ("#if GMP_NUMB_BITS != %d\n", numb_bits); printf ("#error, error, this data is for %d bits\n", numb_bits); printf ("#endif\n"); printf ("\n"); printf ("/* mp_bases[10] data, as literal values */\n"); printf ("#define MP_BASES_CHARS_PER_LIMB_10 %d\n", chars_per_limb); printf ("#define MP_BASES_BIG_BASE_10 CNST_LIMB(0x"); mpz_out_str (stdout, 16, big_base); printf (")\n"); printf ("#define MP_BASES_BIG_BASE_INVERTED_10 CNST_LIMB(0x"); mpz_out_str (stdout, 16, big_base_inverted); printf (")\n"); printf ("#define MP_BASES_NORMALIZATION_STEPS_10 %d\n", normalization_steps); } void table (int limb_bits, int nail_bits) { int numb_bits = limb_bits - nail_bits; int base; printf ("/* This file generated by gen-bases.c - DO NOT EDIT. */\n"); printf ("\n"); printf ("#include \"gmp.h\"\n"); printf ("#include \"gmp-impl.h\"\n"); printf ("\n"); printf ("#if GMP_NUMB_BITS != %d\n", numb_bits); printf ("#error, error, this data is for %d bits\n", numb_bits); printf ("#endif\n"); printf ("\n"); puts ("const struct bases mp_bases[257] =\n{"); puts (" /* 0 */ { 0, 0.0, 0 },"); puts (" /* 1 */ { 0, 1e37, 0 },"); for (base = 2; base <= 256; base++) { generate (limb_bits, nail_bits, base); printf (" /* %3u */ { ", base); if (POW2_P (base)) { printf ("%u, %.16f, 0x%x },\n", chars_per_limb, chars_per_bit_exactly, ulog2 (base) - 1); } else { printf ("%u, %.16f, CNST_LIMB(0x", chars_per_limb, chars_per_bit_exactly); mpz_out_str (stdout, 16, big_base); printf ("), CNST_LIMB(0x"); mpz_out_str (stdout, 16, big_base_inverted); printf (") },\n"); } } puts ("};"); } int main (int argc, char **argv) { int limb_bits, nail_bits; mpz_init (big_base); mpz_init (big_base_inverted); mpz_init (t); if (argc != 4) { fprintf (stderr, "Usage: gen-bases \n"); exit (1); } limb_bits = atoi (argv[2]); nail_bits = atoi (argv[3]); if (limb_bits <= 0 || nail_bits < 0 || nail_bits >= limb_bits) { fprintf (stderr, "Invalid limb/nail bits: %d %d\n", limb_bits, nail_bits); exit (1); } if (strcmp (argv[1], "header") == 0) header (limb_bits, nail_bits); else if (strcmp (argv[1], "table") == 0) table (limb_bits, nail_bits); else { fprintf (stderr, "Invalid header/table choice: %s\n", argv[1]); exit (1); } return 0; } ecl-16.1.2/msvc/gmp/build.vc8/gen-bases/gen-bases.vcproj000077500000000000000000000065331266352375300226600ustar00rootroot00000000000000 ecl-16.1.2/msvc/gmp/build.vc8/gen-fac_ui/000077500000000000000000000000001266352375300177065ustar00rootroot00000000000000ecl-16.1.2/msvc/gmp/build.vc8/gen-fac_ui/gen-fac_ui.c000077500000000000000000000100161266352375300220500ustar00rootroot00000000000000/* Generate mpz_fac_ui data. Copyright 2002 Free Software Foundation, Inc. This file is part of the GNU MP Library. The GNU MP Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU MP Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU MP Library; see the file COPYING.LIB. If not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ #include #include #include "dumbmp.c" /* sets x=y*(y+2)*(y+4)*....*(y+2*(z-1)) */ void odd_products (mpz_t x, mpz_t y, int z) { mpz_t t; mpz_init_set (t, y); mpz_set_ui (x, 1); for (; z != 0; z--) { mpz_mul (x, x, t); mpz_add_ui (t, t, 2); } mpz_clear (t); return; } /* returns 0 on success */ int gen_consts (int numb, int nail, int limb) { mpz_t x, y, z, t; unsigned long a, b, first = 1; printf ("/* This file is automatically generated by gen-fac_ui.c */\n\n"); printf ("#if GMP_NUMB_BITS != %d\n", numb); printf ("#error , error this data is for %d GMP_NUMB_BITS only\n", numb); printf ("#endif\n"); printf ("#if GMP_LIMB_BITS != %d\n", limb); printf ("#error , error this data is for %d GMP_LIMB_BITS only\n", limb); printf ("#endif\n"); printf ("/* This table is 0!,1!,2!,3!,...,n! where n! has <= GMP_NUMB_BITS bits */\n"); printf ("#define ONE_LIMB_FACTORIAL_TABLE CNST_LIMB(0x1),CNST_LIMB(0x1),CNST_LIMB(0x2),"); mpz_init_set_ui (x, 2); for (b = 3;; b++) { mpz_mul_ui (x, x, b); /* so b!=a */ if (mpz_sizeinbase (x, 2) > numb) break; if (first) { first = 0; } else { printf ("),"); } printf ("CNST_LIMB(0x"); mpz_out_str (stdout, 16, x); } printf (")\n"); mpz_set_ui (x, 1); mpz_mul_2exp (x, x, limb + 1); /* x=2^(limb+1) */ mpz_init (y); mpz_set_ui (y, 10000); mpz_mul (x, x, y); /* x=2^(limb+1)*10^4 */ mpz_set_ui (y, 27182); /* exp(1)*10^4 */ mpz_tdiv_q (x, x, y); /* x=2^(limb+1)/exp(1) */ printf ("\n/* is 2^(GMP_LIMB_BITS+1)/exp(1) */\n"); printf ("#define FAC2OVERE CNST_LIMB(0x"); mpz_out_str (stdout, 16, x); printf (")\n"); printf ("\n/* FACMULn is largest odd x such that x*(x+2)*...*(x+2(n-1))<=2^GMP_NUMB_BITS-1 */\n\n"); mpz_init (z); mpz_init (t); for (a = 2; a <= 4; a++) { mpz_set_ui (x, 1); mpz_mul_2exp (x, x, numb); mpz_root (x, x, a); /* so x is approx sol */ if (mpz_even_p (x)) mpz_sub_ui (x, x, 1); mpz_set_ui (y, 1); mpz_mul_2exp (y, y, numb); mpz_sub_ui (y, y, 1); /* decrement x until we are <= real sol */ do { mpz_sub_ui (x, x, 2); odd_products (t, x, a); if (mpz_cmp (t, y) <= 0) break; } while (1); /* increment x until > real sol */ do { mpz_add_ui (x, x, 2); odd_products (t, x, a); if (mpz_cmp (t, y) > 0) break; } while (1); /* dec once to get real sol */ mpz_sub_ui (x, x, 2); printf ("#define FACMUL%lu CNST_LIMB(0x", a); mpz_out_str (stdout, 16, x); printf (")\n"); } return 0; } int main (int argc, char *argv[]) { int nail_bits, limb_bits, numb_bits; if (argc != 3) { fprintf (stderr, "Usage: gen-fac_ui limbbits nailbits\n"); exit (1); } limb_bits = atoi (argv[1]); nail_bits = atoi (argv[2]); numb_bits = limb_bits - nail_bits; if (limb_bits < 0 || nail_bits < 0 || numb_bits < 0) { fprintf (stderr, "Invalid limb/nail bits %d,%d\n", limb_bits, nail_bits); exit (1); } gen_consts (numb_bits, nail_bits, limb_bits); return 0; } ecl-16.1.2/msvc/gmp/build.vc8/gen-fac_ui/gen-fac_ui.vcproj000077500000000000000000000065131266352375300231400ustar00rootroot00000000000000 ecl-16.1.2/msvc/gmp/build.vc8/gen-fib/000077500000000000000000000000001266352375300172205ustar00rootroot00000000000000ecl-16.1.2/msvc/gmp/build.vc8/gen-fib/gen-fib.c000077500000000000000000000070421266352375300207010ustar00rootroot00000000000000/* Generate Fibonacci table data. Copyright 2001, 2002, 2004 Free Software Foundation, Inc. This file is part of the GNU MP Library. The GNU MP Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU MP Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU MP Library; see the file COPYING.LIB. If not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ #include #include "dumbmp.c" mpz_t *f; int fnum, fib_limit, luc_limit; void generate (int numb_bits) { mpz_t limit, l; int falloc, i; mpz_init_set_ui (limit, 1L); mpz_mul_2exp (limit, limit, numb_bits); /* fib(2n) > 2^n, so use 2n as a limit for the table size */ falloc = 2 * numb_bits; f = (mpz_t *) xmalloc (falloc * sizeof (*f)); mpz_init_set_ui (f[0], 1L); /* F[-1] */ mpz_init_set_ui (f[1], 0L); /* F[0] */ mpz_init (l); for (i = 2; ; i++) { ASSERT (i < falloc); /* F[i] = F[i-1] + F[i-2] */ mpz_init (f[i]); mpz_add (f[i], f[i-1], f[i-2]); if (mpz_cmp (f[i], limit) >= 0) break; fnum = i+1; fib_limit = i-1; /* L[i] = F[i]+2*F[i-1] */ mpz_add (l, f[i], f[i-1]); mpz_add (l, l, f[i-1]); if (mpz_cmp (l, limit) < 0) luc_limit = i-1; } mpz_clear (limit); } void header (int numb_bits) { printf ("/* This file generated by gen-fib.c - DO NOT EDIT. */\n"); printf ("\n"); printf ("#if GMP_NUMB_BITS != %d\n", numb_bits); printf ("#error, error, this data is for %d bits\n", numb_bits); printf ("#endif\n"); printf ("\n"); printf ("#define FIB_TABLE_LIMIT %d\n", fib_limit); printf ("#define FIB_TABLE_LUCNUM_LIMIT %d\n", luc_limit); } void table (int numb_bits) { int i; printf ("/* This file generated by gen-fib.c - DO NOT EDIT. */\n"); printf ("\n"); printf ("#include \"gmp.h\"\n"); printf ("#include \"gmp-impl.h\"\n"); printf ("\n"); printf ("#if GMP_NUMB_BITS != %d\n", numb_bits); printf ("#error, error, this data is for %d bits\n", numb_bits); printf ("#endif\n"); printf ("\n"); printf ("const mp_limb_t\n"); printf ("__gmp_fib_table[FIB_TABLE_LIMIT+2] = {\n"); for (i = 0; i < fnum; i++) { printf (" CNST_LIMB (0x"); mpz_out_str (stdout, 16, f[i]); printf ("), /* %d */\n", i-1); } printf ("};\n"); } int main (int argc, char *argv[]) { int limb_bits, nail_bits, numb_bits; if (argc != 4) { fprintf (stderr, "Usage: gen-bases \n"); exit (1); } limb_bits = atoi (argv[2]); nail_bits = atoi (argv[3]); if (limb_bits <= 0 || nail_bits < 0 || nail_bits >= limb_bits) { fprintf (stderr, "Invalid limb/nail bits: %d %d\n", limb_bits, nail_bits); exit (1); } numb_bits = limb_bits - nail_bits; generate (numb_bits); if (strcmp (argv[1], "header") == 0) header (numb_bits); else if (strcmp (argv[1], "table") == 0) table (numb_bits); else { fprintf (stderr, "Invalid header/table choice: %s\n", argv[1]); exit (1); } return 0; } ecl-16.1.2/msvc/gmp/build.vc8/gen-fib/gen-fib.vcproj000077500000000000000000000065021266352375300217620ustar00rootroot00000000000000 ecl-16.1.2/msvc/gmp/build.vc8/gen-psqr/000077500000000000000000000000001266352375300174455ustar00rootroot00000000000000ecl-16.1.2/msvc/gmp/build.vc8/gen-psqr/gen-psqr.c000077500000000000000000000421561266352375300213600ustar00rootroot00000000000000/* Generate perfect square testing data. Copyright 2002, 2003, 2004 Free Software Foundation, Inc. This file is part of the GNU MP Library. The GNU MP Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU MP Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU MP Library; see the file COPYING.LIB. If not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ #include #include #include "dumbmp.c" /* The aim of this program is to choose either mpn_mod_34lsub1 or mpn_mod_1 (plus a PERFSQR_PP modulus), and generate tables indicating quadratic residues and non-residues modulo small factors of that modulus. For the usual 32 or 64 bit cases mpn_mod_34lsub1 gets used. That function exists specifically because 2^24-1 and 2^48-1 have nice sets of prime factors. For other limb sizes it's considered, but if it doesn't have good factors then mpn_mod_1 will be used instead. When mpn_mod_1 is used, the modulus PERFSQR_PP is created from a selection of small primes, chosen to fill PERFSQR_MOD_BITS of a limb, with that bit count chosen so (2*GMP_LIMB_BITS)*2^PERFSQR_MOD_BITS <= GMP_LIMB_MAX, allowing PERFSQR_MOD_IDX in mpn/generic/perfsqr.c to do its calculation within a single limb. In either case primes can be combined to make divisors. The table data then effectively indicates remainders which are quadratic residues mod all the primes. This sort of combining reduces the number of steps needed after mpn_mod_34lsub1 or mpn_mod_1, saving code size and time. Nothing is gained or lost in terms of detections, the same total fraction of non-residues will be identified. Nothing particularly sophisticated is attempted for combining factors to make divisors. This is probably a kind of knapsack problem so it'd be too hard to attempt anything completely general. For the usual 32 and 64 bit limbs we get a good enough result just pairing the biggest and smallest which fit together, repeatedly. Another aim is to get powerful combinations, ie. divisors which identify biggest fraction of non-residues, and have those run first. Again for the usual 32 and 64 bits it seems good enough just to pair for big divisors then sort according to the resulting fraction of non-residues identified. Also in this program, a table sq_res_0x100 of residues modulo 256 is generated. This simply fills bits into limbs of the appropriate build-time GMP_LIMB_BITS each. */ /* Normally we aren't using const in gen*.c programs, so as not to have to bother figuring out if it works, but using it with f_cmp_divisor and f_cmp_fraction avoids warnings from the qsort calls. */ /* Same tests as gmp.h. */ #if defined (__STDC__) \ || defined (__cplusplus) \ || defined (_AIX) \ || defined (__DECC) \ || (defined (__mips) && defined (_SYSTYPE_SVR4)) \ || defined (_MSC_VER) \ || defined (_WIN32) #define HAVE_CONST 1 #endif #if ! HAVE_CONST #define const #endif mpz_t *sq_res_0x100; /* table of limbs */ int nsq_res_0x100; /* elements in sq_res_0x100 array */ int sq_res_0x100_num; /* squares in sq_res_0x100 */ double sq_res_0x100_fraction; /* sq_res_0x100_num / 256 */ int mod34_bits; /* 3*GMP_NUMB_BITS/4 */ int mod_bits; /* bits from PERFSQR_MOD_34 or MOD_PP */ int max_divisor; /* all divisors <= max_divisor */ int max_divisor_bits; /* ceil(log2(max_divisor)) */ double total_fraction; /* of squares */ mpz_t pp; /* product of primes, or 0 if mod_34lsub1 used */ mpz_t pp_norm; /* pp shifted so NUMB high bit set */ mpz_t pp_inverted; /* invert_limb style inverse */ mpz_t mod_mask; /* 2^mod_bits-1 */ char mod34_excuse[128]; /* why mod_34lsub1 not used (if it's not) */ /* raw list of divisors of 2^mod34_bits-1 or pp, just to show in a comment */ struct rawfactor_t { int divisor; int multiplicity; }; struct rawfactor_t *rawfactor; int nrawfactor; /* factors of 2^mod34_bits-1 or pp and associated data, after combining etc */ struct factor_t { int divisor; mpz_t inverse; /* 1/divisor mod 2^mod_bits */ mpz_t mask; /* indicating squares mod divisor */ double fraction; /* squares/total */ }; struct factor_t *factor; int nfactor; /* entries in use in factor array */ int factor_alloc; /* entries allocated to factor array */ int f_cmp_divisor (const void *parg, const void *qarg) { const struct factor_t *p, *q; p = parg; q = qarg; if (p->divisor > q->divisor) return 1; else if (p->divisor < q->divisor) return -1; else return 0; } int f_cmp_fraction (const void *parg, const void *qarg) { const struct factor_t *p, *q; p = parg; q = qarg; if (p->fraction > q->fraction) return 1; else if (p->fraction < q->fraction) return -1; else return 0; } /* Remove array[idx] by copying the remainder down, and adjust narray accordingly. */ #define COLLAPSE_ELEMENT(array, idx, narray) \ do { \ mem_copyi ((char *) &(array)[idx], \ (char *) &(array)[idx+1], \ ((narray)-((idx)+1)) * sizeof (array[0])); \ (narray)--; \ } while (0) /* return n*2^p mod m */ int mul_2exp_mod (int n, int p, int m) { int i; for (i = 0; i < p; i++) n = (2 * n) % m; return n; } /* return -n mod m */ int neg_mod (int n, int m) { ASSERT (n >= 0 && n < m); return (n == 0 ? 0 : m-n); } /* Set "mask" to a value such that "mask & (1< max_divisor / i) break; multiplicity++; mpz_set (m, q); mpz_tdiv_qr_ui (q, r, m, (unsigned long) i); } while (mpz_sgn (r) == 0); ASSERT (nrawfactor < factor_alloc); rawfactor[nrawfactor].divisor = i; rawfactor[nrawfactor].multiplicity = multiplicity; nrawfactor++; } mpz_clear (m); mpz_clear (q); mpz_clear (r); } if (nrawfactor <= 2) { mpz_t new_pp; sprintf (mod34_excuse, "only %d small factor%s", nrawfactor, nrawfactor == 1 ? "" : "s"); use_pp: /* reset to two limbs of max_divisor, in case the mpn_mod_34lsub1 code tried with just one */ max_divisor = 2*limb_bits; max_divisor_bits = log2_ceil (max_divisor); mpz_init (new_pp); nrawfactor = 0; mod_bits = MIN (numb_bits, limb_bits - max_divisor_bits); /* one copy of each small prime */ mpz_set_ui (pp, 1L); for (i = 3; i <= max_divisor; i++) { if (! isprime (i)) continue; mpz_mul_ui (new_pp, pp, (unsigned long) i); if (mpz_sizeinbase (new_pp, 2) > mod_bits) break; mpz_set (pp, new_pp); ASSERT (nrawfactor < factor_alloc); rawfactor[nrawfactor].divisor = i; rawfactor[nrawfactor].multiplicity = 1; nrawfactor++; } /* Plus an extra copy of one or more of the primes selected, if that still fits in max_divisor and the total in mod_bits. Usually only 3 or 5 will be candidates */ for (i = nrawfactor-1; i >= 0; i--) { if (rawfactor[i].divisor > max_divisor / rawfactor[i].divisor) continue; mpz_mul_ui (new_pp, pp, (unsigned long) rawfactor[i].divisor); if (mpz_sizeinbase (new_pp, 2) > mod_bits) continue; mpz_set (pp, new_pp); rawfactor[i].multiplicity++; } mod_bits = mpz_sizeinbase (pp, 2); mpz_set (pp_norm, pp); while (mpz_sizeinbase (pp_norm, 2) < numb_bits) mpz_add (pp_norm, pp_norm, pp_norm); mpz_preinv_invert (pp_inverted, pp_norm, numb_bits); mpz_clear (new_pp); } /* start the factor array */ for (i = 0; i < nrawfactor; i++) { int j; ASSERT (nfactor < factor_alloc); factor[nfactor].divisor = 1; for (j = 0; j < rawfactor[i].multiplicity; j++) factor[nfactor].divisor *= rawfactor[i].divisor; nfactor++; } combine: /* Combine entries in the factor array. Combine the smallest entry with the biggest one that will fit with it (ie. under max_divisor), then repeat that with the new smallest entry. */ qsort (factor, nfactor, sizeof (factor[0]), f_cmp_divisor); for (i = nfactor-1; i >= 1; i--) { if (factor[i].divisor <= max_divisor / factor[0].divisor) { factor[0].divisor *= factor[i].divisor; COLLAPSE_ELEMENT (factor, i, nfactor); goto combine; } } total_fraction = 1.0; for (i = 0; i < nfactor; i++) { mpz_init (factor[i].inverse); mpz_invert_ui_2exp (factor[i].inverse, (unsigned long) factor[i].divisor, (unsigned long) mod_bits); mpz_init (factor[i].mask); square_mask (factor[i].mask, factor[i].divisor); /* fraction of possible squares */ factor[i].fraction = (double) mpz_popcount (factor[i].mask) / factor[i].divisor; /* total fraction of possible squares */ total_fraction *= factor[i].fraction; } /* best tests first (ie. smallest fraction) */ qsort (factor, nfactor, sizeof (factor[0]), f_cmp_fraction); } void print (int limb_bits, int nail_bits) { int i; mpz_t mhi, mlo; printf ("/* This file generated by gen-psqr.c - DO NOT EDIT. */\n"); printf ("\n"); printf ("#if GMP_LIMB_BITS != %d || GMP_NAIL_BITS != %d\n", limb_bits, nail_bits); printf ("#error, error, this data is for %d bit limb and %d bit nail\n", limb_bits, nail_bits); printf ("#endif\n"); printf ("\n"); printf ("/* Non-zero bit indicates a quadratic residue mod 0x100.\n"); printf (" This test identifies %.2f%% as non-squares (%d/256). */\n", (1.0 - sq_res_0x100_fraction) * 100.0, 0x100 - sq_res_0x100_num); printf ("static const mp_limb_t\n"); printf ("sq_res_0x100[%d] = {\n", nsq_res_0x100); for (i = 0; i < nsq_res_0x100; i++) { printf (" CNST_LIMB(0x"); mpz_out_str (stdout, 16, sq_res_0x100[i]); printf ("),\n"); } printf ("};\n"); printf ("\n"); if (mpz_sgn (pp) != 0) { printf ("/* mpn_mod_34lsub1 not used due to %s */\n", mod34_excuse); printf ("/* PERFSQR_PP = "); } else printf ("/* 2^%d-1 = ", mod34_bits); for (i = 0; i < nrawfactor; i++) { if (i != 0) printf (" * "); printf ("%d", rawfactor[i].divisor); if (rawfactor[i].multiplicity != 1) printf ("^%d", rawfactor[i].multiplicity); } printf (" %s*/\n", mpz_sgn (pp) == 0 ? "... " : ""); printf ("#define PERFSQR_MOD_BITS %d\n", mod_bits); if (mpz_sgn (pp) != 0) { printf ("#define PERFSQR_PP CNST_LIMB(0x"); mpz_out_str (stdout, 16, pp); printf (")\n"); printf ("#define PERFSQR_PP_NORM CNST_LIMB(0x"); mpz_out_str (stdout, 16, pp_norm); printf (")\n"); printf ("#define PERFSQR_PP_INVERTED CNST_LIMB(0x"); mpz_out_str (stdout, 16, pp_inverted); printf (")\n"); } printf ("\n"); mpz_init (mhi); mpz_init (mlo); printf ("/* This test identifies %.2f%% as non-squares. */\n", (1.0 - total_fraction) * 100.0); printf ("#define PERFSQR_MOD_TEST(up, usize) \\\n"); printf (" do { \\\n"); printf (" mp_limb_t r; \\\n"); if (mpz_sgn (pp) != 0) printf (" PERFSQR_MOD_PP (r, up, usize); \\\n"); else printf (" PERFSQR_MOD_34 (r, up, usize); \\\n"); for (i = 0; i < nfactor; i++) { printf (" \\\n"); printf (" /* %5.2f%% */ \\\n", (1.0 - factor[i].fraction) * 100.0); printf (" PERFSQR_MOD_%d (r, CNST_LIMB(%2d), CNST_LIMB(0x", factor[i].divisor <= limb_bits ? 1 : 2, factor[i].divisor); mpz_out_str (stdout, 16, factor[i].inverse); printf ("), \\\n"); printf (" CNST_LIMB(0x"); if ( factor[i].divisor <= limb_bits) { mpz_out_str (stdout, 16, factor[i].mask); } else { mpz_tdiv_r_2exp (mlo, factor[i].mask, (unsigned long) limb_bits); mpz_tdiv_q_2exp (mhi, factor[i].mask, (unsigned long) limb_bits); mpz_out_str (stdout, 16, mhi); printf ("), CNST_LIMB(0x"); mpz_out_str (stdout, 16, mlo); } printf (")); \\\n"); } printf (" } while (0)\n"); printf ("\n"); printf ("/* Grand total sq_res_0x100 and PERFSQR_MOD_TEST, %.2f%% non-squares. */\n", (1.0 - (total_fraction * 44.0/256.0)) * 100.0); printf ("\n"); printf ("/* helper for tests/mpz/t-perfsqr.c */\n"); printf ("#define PERFSQR_DIVISORS { 256,"); for (i = 0; i < nfactor; i++) printf (" %d,", factor[i].divisor); printf (" }\n"); mpz_clear (mhi); mpz_clear (mlo); } int main (int argc, char *argv[]) { int limb_bits, nail_bits; if (argc != 3) { fprintf (stderr, "Usage: gen-psqr \n"); exit (1); } limb_bits = atoi (argv[1]); nail_bits = atoi (argv[2]); if (limb_bits <= 0 || nail_bits < 0 || nail_bits >= limb_bits) { fprintf (stderr, "Invalid limb/nail bits: %d %d\n", limb_bits, nail_bits); exit (1); } generate_sq_res_0x100 (limb_bits); generate_mod (limb_bits, nail_bits); print (limb_bits, nail_bits); return 0; } ecl-16.1.2/msvc/gmp/build.vc8/gen-psqr/gen-psqr.vcproj000077500000000000000000000065051266352375300224370ustar00rootroot00000000000000 ecl-16.1.2/msvc/gmp/build.vc8/getopt.c000077500000000000000000001033371266352375300173710ustar00rootroot00000000000000/* Getopt for GNU. NOTE: getopt is now part of the C library, so if you don't know what "Keep this file name-space clean" means, talk to drepper@gnu.org before changing it! Copyright (C) 1987,88,89,90,91,92,93,94,95,96,98,99,2000,2001,2002 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. */ /* This tells Alpha OSF/1 not to define a getopt prototype in . Ditto for AIX 3.2 and . */ #define HAVE_STRING_H 1 #ifndef _NO_PROTO # define _NO_PROTO #endif #ifdef HAVE_CONFIG_H # include #endif #if !defined __STDC__ || !__STDC__ /* This is a separate conditional since some stdc systems reject `defined (const)'. */ # ifndef const # define const # endif #endif #include /* Comment out all this code if we are using the GNU C Library, and are not actually compiling the library itself. This code is part of the GNU C Library, but also included in many other GNU distributions. Compiling and linking in this code is a waste when using the GNU C library (especially if it is a shared library). Rather than having every GNU program understand `configure --with-gnu-libc' and omit the object files, it is simpler to just do this in the source for each such file. */ #define GETOPT_INTERFACE_VERSION 2 #if !defined _LIBC && defined __GLIBC__ && __GLIBC__ >= 2 # include # if _GNU_GETOPT_INTERFACE_VERSION == GETOPT_INTERFACE_VERSION # define ELIDE_CODE # endif #endif #ifndef ELIDE_CODE /* This needs to come after some library #include to get __GNU_LIBRARY__ defined. */ #ifdef __GNU_LIBRARY__ /* Don't include stdlib.h for non-GNU C libraries because some of them contain conflicting prototypes for getopt. */ # include # include #endif /* GNU C library. */ #ifdef VMS # include # if HAVE_STRING_H - 0 # include # endif #endif #ifndef _ /* This is for other GNU distributions with internationalized messages. */ # if (HAVE_LIBINTL_H && ENABLE_NLS) || defined _LIBC # include # ifndef _ # define _(msgid) gettext (msgid) # endif # else # define _(msgid) (msgid) # endif # if defined _LIBC && defined USE_IN_LIBIO # include # endif #endif #ifndef attribute_hidden # define attribute_hidden #endif /* This version of `getopt' appears to the caller like standard Unix `getopt' but it behaves differently for the user, since it allows the user to intersperse the options with the other arguments. As `getopt' works, it permutes the elements of ARGV so that, when it is done, all the options precede everything else. Thus all application programs are extended to handle flexible argument order. Setting the environment variable POSIXLY_CORRECT disables permutation. Then the behavior is completely standard. GNU application programs can use a third alternative mode in which they can distinguish the relative order of options and other arguments. */ #include "getopt.h" /* For communication from `getopt' to the caller. When `getopt' finds an option that takes an argument, the argument value is returned here. Also, when `ordering' is RETURN_IN_ORDER, each non-option ARGV-element is returned here. */ char *optarg; /* Index in ARGV of the next element to be scanned. This is used for communication to and from the caller and for communication between successive calls to `getopt'. On entry to `getopt', zero means this is the first call; initialize. When `getopt' returns -1, this is the index of the first of the non-option elements that the caller should itself scan. Otherwise, `optind' communicates from one call to the next how much of ARGV has been scanned so far. */ /* 1003.2 says this must be 1 before any call. */ int optind = 1; /* Formerly, initialization of getopt depended on optind==0, which causes problems with re-calling getopt as programs generally don't know that. */ int __getopt_initialized attribute_hidden; /* The next char to be scanned in the option-element in which the last option character we returned was found. This allows us to pick up the scan where we left off. If this is zero, or a null string, it means resume the scan by advancing to the next ARGV-element. */ static char *nextchar; /* Callers store zero here to inhibit the error message for unrecognized options. */ int opterr = 1; /* Set to an option character which was unrecognized. This must be initialized on some systems to avoid linking in the system's own getopt implementation. */ int optopt = '?'; /* Describe how to deal with options that follow non-option ARGV-elements. If the caller did not specify anything, the default is REQUIRE_ORDER if the environment variable POSIXLY_CORRECT is defined, PERMUTE otherwise. REQUIRE_ORDER means don't recognize them as options; stop option processing when the first non-option is seen. This is what Unix does. This mode of operation is selected by either setting the environment variable POSIXLY_CORRECT, or using `+' as the first character of the list of option characters. PERMUTE is the default. We permute the contents of ARGV as we scan, so that eventually all the non-options are at the end. This allows options to be given in any order, even with programs that were not written to expect this. RETURN_IN_ORDER is an option available to programs that were written to expect options and other ARGV-elements in any order and that care about the ordering of the two. We describe each non-option ARGV-element as if it were the argument of an option with character code 1. Using `-' as the first character of the list of option characters selects this mode of operation. The special argument `--' forces an end of option-scanning regardless of the value of `ordering'. In the case of RETURN_IN_ORDER, only `--' can cause `getopt' to return -1 with `optind' != ARGC. */ static enum { REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER } ordering; /* Value of POSIXLY_CORRECT environment variable. */ static char *posixly_correct; #ifdef __GNU_LIBRARY__ /* We want to avoid inclusion of string.h with non-GNU libraries because there are many ways it can cause trouble. On some systems, it contains special magic macros that don't work in GCC. */ # include # define my_index strchr #else # if HAVE_STRING_H # include # else # include # endif /* Avoid depending on library functions or files whose names are inconsistent. */ #ifndef getenv extern char *getenv (); #endif static char * my_index (str, chr) const char *str; int chr; { while (*str) { if (*str == chr) return (char *) str; str++; } return 0; } /* If using GCC, we can safely declare strlen this way. If not using GCC, it is ok not to declare it. */ #ifdef __GNUC__ /* Note that Motorola Delta 68k R3V7 comes with GCC but not stddef.h. That was relevant to code that was here before. */ # if (!defined __STDC__ || !__STDC__) && !defined strlen /* gcc with -traditional declares the built-in strlen to return int, and has done so at least since version 2.4.5. -- rms. */ extern int strlen (const char *); # endif /* not __STDC__ */ #endif /* __GNUC__ */ #endif /* not __GNU_LIBRARY__ */ /* Handle permutation of arguments. */ /* Describe the part of ARGV that contains non-options that have been skipped. `first_nonopt' is the index in ARGV of the first of them; `last_nonopt' is the index after the last of them. */ static int first_nonopt; static int last_nonopt; #ifdef _LIBC /* Stored original parameters. XXX This is no good solution. We should rather copy the args so that we can compare them later. But we must not use malloc(3). */ extern int __libc_argc; extern char **__libc_argv; /* Bash 2.0 gives us an environment variable containing flags indicating ARGV elements that should not be considered arguments. */ # ifdef USE_NONOPTION_FLAGS /* Defined in getopt_init.c */ extern char *__getopt_nonoption_flags; static int nonoption_flags_max_len; static int nonoption_flags_len; # endif # ifdef USE_NONOPTION_FLAGS # define SWAP_FLAGS(ch1, ch2) \ if (nonoption_flags_len > 0) \ { \ char __tmp = __getopt_nonoption_flags[ch1]; \ __getopt_nonoption_flags[ch1] = __getopt_nonoption_flags[ch2]; \ __getopt_nonoption_flags[ch2] = __tmp; \ } # else # define SWAP_FLAGS(ch1, ch2) # endif #else /* !_LIBC */ # define SWAP_FLAGS(ch1, ch2) #endif /* _LIBC */ /* Exchange two adjacent subsequences of ARGV. One subsequence is elements [first_nonopt,last_nonopt) which contains all the non-options that have been skipped so far. The other is elements [last_nonopt,optind), which contains all the options processed since those non-options were skipped. `first_nonopt' and `last_nonopt' are relocated so that they describe the new indices of the non-options in ARGV after they are moved. */ #if defined __STDC__ && __STDC__ static void exchange (char **); #endif static void exchange (argv) char **argv; { int bottom = first_nonopt; int middle = last_nonopt; int top = optind; char *tem; /* Exchange the shorter segment with the far end of the longer segment. That puts the shorter segment into the right place. It leaves the longer segment in the right place overall, but it consists of two parts that need to be swapped next. */ #if defined _LIBC && defined USE_NONOPTION_FLAGS /* First make sure the handling of the `__getopt_nonoption_flags' string can work normally. Our top argument must be in the range of the string. */ if (nonoption_flags_len > 0 && top >= nonoption_flags_max_len) { /* We must extend the array. The user plays games with us and presents new arguments. */ char *new_str = malloc (top + 1); if (new_str == NULL) nonoption_flags_len = nonoption_flags_max_len = 0; else { memset (__mempcpy (new_str, __getopt_nonoption_flags, nonoption_flags_max_len), '\0', top + 1 - nonoption_flags_max_len); nonoption_flags_max_len = top + 1; __getopt_nonoption_flags = new_str; } } #endif while (top > middle && middle > bottom) { if (top - middle > middle - bottom) { /* Bottom segment is the short one. */ int len = middle - bottom; register int i; /* Swap it with the top part of the top segment. */ for (i = 0; i < len; i++) { tem = argv[bottom + i]; argv[bottom + i] = argv[top - (middle - bottom) + i]; argv[top - (middle - bottom) + i] = tem; SWAP_FLAGS (bottom + i, top - (middle - bottom) + i); } /* Exclude the moved bottom segment from further swapping. */ top -= len; } else { /* Top segment is the short one. */ int len = top - middle; register int i; /* Swap it with the bottom part of the bottom segment. */ for (i = 0; i < len; i++) { tem = argv[bottom + i]; argv[bottom + i] = argv[middle + i]; argv[middle + i] = tem; SWAP_FLAGS (bottom + i, middle + i); } /* Exclude the moved top segment from further swapping. */ bottom += len; } } /* Update records for the slots the non-options now occupy. */ first_nonopt += (optind - last_nonopt); last_nonopt = optind; } /* Initialize the internal data when the first call is made. */ #if defined __STDC__ && __STDC__ static const char *_getopt_initialize (int, char *const *, const char *); #endif static const char * _getopt_initialize (argc, argv, optstring) int argc; char *const *argv; const char *optstring; { /* Start processing options with ARGV-element 1 (since ARGV-element 0 is the program name); the sequence of previously skipped non-option ARGV-elements is empty. */ first_nonopt = last_nonopt = optind; nextchar = NULL; posixly_correct = getenv ("POSIXLY_CORRECT"); /* Determine how to handle the ordering of options and nonoptions. */ if (optstring[0] == '-') { ordering = RETURN_IN_ORDER; ++optstring; } else if (optstring[0] == '+') { ordering = REQUIRE_ORDER; ++optstring; } else if (posixly_correct != NULL) ordering = REQUIRE_ORDER; else ordering = PERMUTE; #if defined _LIBC && defined USE_NONOPTION_FLAGS if (posixly_correct == NULL && argc == __libc_argc && argv == __libc_argv) { if (nonoption_flags_max_len == 0) { if (__getopt_nonoption_flags == NULL || __getopt_nonoption_flags[0] == '\0') nonoption_flags_max_len = -1; else { const char *orig_str = __getopt_nonoption_flags; int len = nonoption_flags_max_len = strlen (orig_str); if (nonoption_flags_max_len < argc) nonoption_flags_max_len = argc; __getopt_nonoption_flags = (char *) malloc (nonoption_flags_max_len); if (__getopt_nonoption_flags == NULL) nonoption_flags_max_len = -1; else memset (__mempcpy (__getopt_nonoption_flags, orig_str, len), '\0', nonoption_flags_max_len - len); } } nonoption_flags_len = nonoption_flags_max_len; } else nonoption_flags_len = 0; #endif return optstring; } /* Scan elements of ARGV (whose length is ARGC) for option characters given in OPTSTRING. If an element of ARGV starts with '-', and is not exactly "-" or "--", then it is an option element. The characters of this element (aside from the initial '-') are option characters. If `getopt' is called repeatedly, it returns successively each of the option characters from each of the option elements. If `getopt' finds another option character, it returns that character, updating `optind' and `nextchar' so that the next call to `getopt' can resume the scan with the following option character or ARGV-element. If there are no more option characters, `getopt' returns -1. Then `optind' is the index in ARGV of the first ARGV-element that is not an option. (The ARGV-elements have been permuted so that those that are not options now come last.) OPTSTRING is a string containing the legitimate option characters. If an option character is seen that is not listed in OPTSTRING, return '?' after printing an error message. If you set `opterr' to zero, the error message is suppressed but we still return '?'. If a char in OPTSTRING is followed by a colon, that means it wants an arg, so the following text in the same ARGV-element, or the text of the following ARGV-element, is returned in `optarg'. Two colons mean an option that wants an optional arg; if there is text in the current ARGV-element, it is returned in `optarg', otherwise `optarg' is set to zero. If OPTSTRING starts with `-' or `+', it requests different methods of handling the non-option ARGV-elements. See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above. Long-named options begin with `--' instead of `-'. Their names may be abbreviated as long as the abbreviation is unique or is an exact match for some defined option. If they have an argument, it follows the option name in the same ARGV-element, separated from the option name by a `=', or else the in next ARGV-element. When `getopt' finds a long-named option, it returns 0 if that option's `flag' field is nonzero, the value of the option's `val' field if the `flag' field is zero. The elements of ARGV aren't really const, because we permute them. But we pretend they're const in the prototype to be compatible with other systems. LONGOPTS is a vector of `struct option' terminated by an element containing a name which is zero. LONGIND returns the index in LONGOPT of the long-named option found. It is only valid when a long-named option has been found by the most recent call. If LONG_ONLY is nonzero, '-' as well as '--' can introduce long-named options. */ int _getopt_internal (argc, argv, optstring, longopts, longind, long_only) int argc; char *const *argv; const char *optstring; const struct option *longopts; int *longind; int long_only; { int print_errors = opterr; if (optstring[0] == ':') print_errors = 0; if (argc < 1) return -1; optarg = NULL; if (optind == 0 || !__getopt_initialized) { if (optind == 0) optind = 1; /* Don't scan ARGV[0], the program name. */ optstring = _getopt_initialize (argc, argv, optstring); __getopt_initialized = 1; } /* Test whether ARGV[optind] points to a non-option argument. Either it does not have option syntax, or there is an environment flag from the shell indicating it is not an option. The later information is only used when the used in the GNU libc. */ #if defined _LIBC && defined USE_NONOPTION_FLAGS # define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0' \ || (optind < nonoption_flags_len \ && __getopt_nonoption_flags[optind] == '1')) #else # define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0') #endif if (nextchar == NULL || *nextchar == '\0') { /* Advance to the next ARGV-element. */ /* Give FIRST_NONOPT & LAST_NONOPT rational values if OPTIND has been moved back by the user (who may also have changed the arguments). */ if (last_nonopt > optind) last_nonopt = optind; if (first_nonopt > optind) first_nonopt = optind; if (ordering == PERMUTE) { /* If we have just processed some options following some non-options, exchange them so that the options come first. */ if (first_nonopt != last_nonopt && last_nonopt != optind) exchange ((char **) argv); else if (last_nonopt != optind) first_nonopt = optind; /* Skip any additional non-options and extend the range of non-options previously skipped. */ while (optind < argc && NONOPTION_P) optind++; last_nonopt = optind; } /* The special ARGV-element `--' means premature end of options. Skip it like a null option, then exchange with previous non-options as if it were an option, then skip everything else like a non-option. */ if (optind != argc && !strcmp (argv[optind], "--")) { optind++; if (first_nonopt != last_nonopt && last_nonopt != optind) exchange ((char **) argv); else if (first_nonopt == last_nonopt) first_nonopt = optind; last_nonopt = argc; optind = argc; } /* If we have done all the ARGV-elements, stop the scan and back over any non-options that we skipped and permuted. */ if (optind == argc) { /* Set the next-arg-index to point at the non-options that we previously skipped, so the caller will digest them. */ if (first_nonopt != last_nonopt) optind = first_nonopt; return -1; } /* If we have come to a non-option and did not permute it, either stop the scan or describe it to the caller and pass it by. */ if (NONOPTION_P) { if (ordering == REQUIRE_ORDER) return -1; optarg = argv[optind++]; return 1; } /* We have found another option-ARGV-element. Skip the initial punctuation. */ nextchar = (argv[optind] + 1 + (longopts != NULL && argv[optind][1] == '-')); } /* Decode the current option-ARGV-element. */ /* Check whether the ARGV-element is a long option. If long_only and the ARGV-element has the form "-f", where f is a valid short option, don't consider it an abbreviated form of a long option that starts with f. Otherwise there would be no way to give the -f short option. On the other hand, if there's a long option "fubar" and the ARGV-element is "-fu", do consider that an abbreviation of the long option, just like "--fu", and not "-f" with arg "u". This distinction seems to be the most useful approach. */ if (longopts != NULL && (argv[optind][1] == '-' || (long_only && (argv[optind][2] || !my_index (optstring, argv[optind][1]))))) { char *nameend; const struct option *p; const struct option *pfound = NULL; int exact = 0; int ambig = 0; int indfound = -1; int option_index; for (nameend = nextchar; *nameend && *nameend != '='; nameend++) /* Do nothing. */ ; /* Test all long options for either exact match or abbreviated matches. */ for (p = longopts, option_index = 0; p->name; p++, option_index++) if (!strncmp (p->name, nextchar, nameend - nextchar)) { if ((unsigned int) (nameend - nextchar) == (unsigned int) strlen (p->name)) { /* Exact match found. */ pfound = p; indfound = option_index; exact = 1; break; } else if (pfound == NULL) { /* First nonexact match found. */ pfound = p; indfound = option_index; } else if (long_only || pfound->has_arg != p->has_arg || pfound->flag != p->flag || pfound->val != p->val) /* Second or later nonexact match found. */ ambig = 1; } if (ambig && !exact) { if (print_errors) { #if defined _LIBC && defined USE_IN_LIBIO char *buf; if (__asprintf (&buf, _("%s: option `%s' is ambiguous\n"), argv[0], argv[optind]) >= 0) { if (_IO_fwide (stderr, 0) > 0) __fwprintf (stderr, L"%s", buf); else fputs (buf, stderr); free (buf); } #else fprintf (stderr, _("%s: option `%s' is ambiguous\n"), argv[0], argv[optind]); #endif } nextchar += strlen (nextchar); optind++; optopt = 0; return '?'; } if (pfound != NULL) { option_index = indfound; optind++; if (*nameend) { /* Don't test has_arg with >, because some C compilers don't allow it to be used on enums. */ if (pfound->has_arg) optarg = nameend + 1; else { if (print_errors) { #if defined _LIBC && defined USE_IN_LIBIO char *buf; int n; #endif if (argv[optind - 1][1] == '-') { /* --option */ #if defined _LIBC && defined USE_IN_LIBIO n = __asprintf (&buf, _("\ %s: option `--%s' doesn't allow an argument\n"), argv[0], pfound->name); #else fprintf (stderr, _("\ %s: option `--%s' doesn't allow an argument\n"), argv[0], pfound->name); #endif } else { /* +option or -option */ #if defined _LIBC && defined USE_IN_LIBIO n = __asprintf (&buf, _("\ %s: option `%c%s' doesn't allow an argument\n"), argv[0], argv[optind - 1][0], pfound->name); #else fprintf (stderr, _("\ %s: option `%c%s' doesn't allow an argument\n"), argv[0], argv[optind - 1][0], pfound->name); #endif } #if defined _LIBC && defined USE_IN_LIBIO if (n >= 0) { if (_IO_fwide (stderr, 0) > 0) __fwprintf (stderr, L"%s", buf); else fputs (buf, stderr); free (buf); } #endif } nextchar += strlen (nextchar); optopt = pfound->val; return '?'; } } else if (pfound->has_arg == 1) { if (optind < argc) optarg = argv[optind++]; else { if (print_errors) { #if defined _LIBC && defined USE_IN_LIBIO char *buf; if (__asprintf (&buf, _("\ %s: option `%s' requires an argument\n"), argv[0], argv[optind - 1]) >= 0) { if (_IO_fwide (stderr, 0) > 0) __fwprintf (stderr, L"%s", buf); else fputs (buf, stderr); free (buf); } #else fprintf (stderr, _("%s: option `%s' requires an argument\n"), argv[0], argv[optind - 1]); #endif } nextchar += strlen (nextchar); optopt = pfound->val; return optstring[0] == ':' ? ':' : '?'; } } nextchar += strlen (nextchar); if (longind != NULL) *longind = option_index; if (pfound->flag) { *(pfound->flag) = pfound->val; return 0; } return pfound->val; } /* Can't find it as a long option. If this is not getopt_long_only, or the option starts with '--' or is not a valid short option, then it's an error. Otherwise interpret it as a short option. */ if (!long_only || argv[optind][1] == '-' || my_index (optstring, *nextchar) == NULL) { if (print_errors) { #if defined _LIBC && defined USE_IN_LIBIO char *buf; int n; #endif if (argv[optind][1] == '-') { /* --option */ #if defined _LIBC && defined USE_IN_LIBIO n = __asprintf (&buf, _("%s: unrecognized option `--%s'\n"), argv[0], nextchar); #else fprintf (stderr, _("%s: unrecognized option `--%s'\n"), argv[0], nextchar); #endif } else { /* +option or -option */ #if defined _LIBC && defined USE_IN_LIBIO n = __asprintf (&buf, _("%s: unrecognized option `%c%s'\n"), argv[0], argv[optind][0], nextchar); #else fprintf (stderr, _("%s: unrecognized option `%c%s'\n"), argv[0], argv[optind][0], nextchar); #endif } #if defined _LIBC && defined USE_IN_LIBIO if (n >= 0) { if (_IO_fwide (stderr, 0) > 0) __fwprintf (stderr, L"%s", buf); else fputs (buf, stderr); free (buf); } #endif } nextchar = (char *) ""; optind++; optopt = 0; return '?'; } } /* Look at and handle the next short option-character. */ { char c = *nextchar++; char *temp = my_index (optstring, c); /* Increment `optind' when we start to process its last character. */ if (*nextchar == '\0') ++optind; if (temp == NULL || c == ':') { if (print_errors) { #if defined _LIBC && defined USE_IN_LIBIO char *buf; int n; #endif if (posixly_correct) { /* 1003.2 specifies the format of this message. */ #if defined _LIBC && defined USE_IN_LIBIO n = __asprintf (&buf, _("%s: illegal option -- %c\n"), argv[0], c); #else fprintf (stderr, _("%s: illegal option -- %c\n"), argv[0], c); #endif } else { #if defined _LIBC && defined USE_IN_LIBIO n = __asprintf (&buf, _("%s: invalid option -- %c\n"), argv[0], c); #else fprintf (stderr, _("%s: invalid option -- %c\n"), argv[0], c); #endif } #if defined _LIBC && defined USE_IN_LIBIO if (n >= 0) { if (_IO_fwide (stderr, 0) > 0) __fwprintf (stderr, L"%s", buf); else fputs (buf, stderr); free (buf); } #endif } optopt = c; return '?'; } /* Convenience. Treat POSIX -W foo same as long option --foo */ if (temp[0] == 'W' && temp[1] == ';') { char *nameend; const struct option *p; const struct option *pfound = NULL; int exact = 0; int ambig = 0; int indfound = 0; int option_index; /* This is an option that requires an argument. */ if (*nextchar != '\0') { optarg = nextchar; /* If we end this ARGV-element by taking the rest as an arg, we must advance to the next element now. */ optind++; } else if (optind == argc) { if (print_errors) { /* 1003.2 specifies the format of this message. */ #if defined _LIBC && defined USE_IN_LIBIO char *buf; if (__asprintf (&buf, _("%s: option requires an argument -- %c\n"), argv[0], c) >= 0) { if (_IO_fwide (stderr, 0) > 0) __fwprintf (stderr, L"%s", buf); else fputs (buf, stderr); free (buf); } #else fprintf (stderr, _("%s: option requires an argument -- %c\n"), argv[0], c); #endif } optopt = c; if (optstring[0] == ':') c = ':'; else c = '?'; return c; } else /* We already incremented `optind' once; increment it again when taking next ARGV-elt as argument. */ optarg = argv[optind++]; /* optarg is now the argument, see if it's in the table of longopts. */ for (nextchar = nameend = optarg; *nameend && *nameend != '='; nameend++) /* Do nothing. */ ; /* Test all long options for either exact match or abbreviated matches. */ for (p = longopts, option_index = 0; p->name; p++, option_index++) if (!strncmp (p->name, nextchar, nameend - nextchar)) { if ((unsigned int) (nameend - nextchar) == strlen (p->name)) { /* Exact match found. */ pfound = p; indfound = option_index; exact = 1; break; } else if (pfound == NULL) { /* First nonexact match found. */ pfound = p; indfound = option_index; } else /* Second or later nonexact match found. */ ambig = 1; } if (ambig && !exact) { if (print_errors) { #if defined _LIBC && defined USE_IN_LIBIO char *buf; if (__asprintf (&buf, _("%s: option `-W %s' is ambiguous\n"), argv[0], argv[optind]) >= 0) { if (_IO_fwide (stderr, 0) > 0) __fwprintf (stderr, L"%s", buf); else fputs (buf, stderr); free (buf); } #else fprintf (stderr, _("%s: option `-W %s' is ambiguous\n"), argv[0], argv[optind]); #endif } nextchar += strlen (nextchar); optind++; return '?'; } if (pfound != NULL) { option_index = indfound; if (*nameend) { /* Don't test has_arg with >, because some C compilers don't allow it to be used on enums. */ if (pfound->has_arg) optarg = nameend + 1; else { if (print_errors) { #if defined _LIBC && defined USE_IN_LIBIO char *buf; if (__asprintf (&buf, _("\ %s: option `-W %s' doesn't allow an argument\n"), argv[0], pfound->name) >= 0) { if (_IO_fwide (stderr, 0) > 0) __fwprintf (stderr, L"%s", buf); else fputs (buf, stderr); free (buf); } #else fprintf (stderr, _("\ %s: option `-W %s' doesn't allow an argument\n"), argv[0], pfound->name); #endif } nextchar += strlen (nextchar); return '?'; } } else if (pfound->has_arg == 1) { if (optind < argc) optarg = argv[optind++]; else { if (print_errors) { #if defined _LIBC && defined USE_IN_LIBIO char *buf; if (__asprintf (&buf, _("\ %s: option `%s' requires an argument\n"), argv[0], argv[optind - 1]) >= 0) { if (_IO_fwide (stderr, 0) > 0) __fwprintf (stderr, L"%s", buf); else fputs (buf, stderr); free (buf); } #else fprintf (stderr, _("%s: option `%s' requires an argument\n"), argv[0], argv[optind - 1]); #endif } nextchar += strlen (nextchar); return optstring[0] == ':' ? ':' : '?'; } } nextchar += strlen (nextchar); if (longind != NULL) *longind = option_index; if (pfound->flag) { *(pfound->flag) = pfound->val; return 0; } return pfound->val; } nextchar = NULL; return 'W'; /* Let the application handle it. */ } if (temp[1] == ':') { if (temp[2] == ':') { /* This is an option that accepts an argument optionally. */ if (*nextchar != '\0') { optarg = nextchar; optind++; } else optarg = NULL; nextchar = NULL; } else { /* This is an option that requires an argument. */ if (*nextchar != '\0') { optarg = nextchar; /* If we end this ARGV-element by taking the rest as an arg, we must advance to the next element now. */ optind++; } else if (optind == argc) { if (print_errors) { /* 1003.2 specifies the format of this message. */ #if defined _LIBC && defined USE_IN_LIBIO char *buf; if (__asprintf (&buf, _("\ %s: option requires an argument -- %c\n"), argv[0], c) >= 0) { if (_IO_fwide (stderr, 0) > 0) __fwprintf (stderr, L"%s", buf); else fputs (buf, stderr); free (buf); } #else fprintf (stderr, _("%s: option requires an argument -- %c\n"), argv[0], c); #endif } optopt = c; if (optstring[0] == ':') c = ':'; else c = '?'; } else /* We already incremented `optind' once; increment it again when taking next ARGV-elt as argument. */ optarg = argv[optind++]; nextchar = NULL; } } return c; } } int getopt (argc, argv, optstring) int argc; char *const *argv; const char *optstring; { return _getopt_internal (argc, argv, optstring, (const struct option *) 0, (int *) 0, 0); } #endif /* Not ELIDE_CODE. */ #ifdef TEST /* Compile with -DTEST to make an executable for use in testing the above definition of `getopt'. */ int main (argc, argv) int argc; char **argv; { int c; int digit_optind = 0; while (1) { int this_option_optind = optind ? optind : 1; c = getopt (argc, argv, "abc:d:0123456789"); if (c == -1) break; switch (c) { case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': if (digit_optind != 0 && digit_optind != this_option_optind) printf ("digits occur in two different argv-elements.\n"); digit_optind = this_option_optind; printf ("option %c\n", c); break; case 'a': printf ("option a\n"); break; case 'b': printf ("option b\n"); break; case 'c': printf ("option c with value `%s'\n", optarg); break; case '?': break; default: printf ("?? getopt returned character code 0%o ??\n", c); } } if (optind < argc) { printf ("non-option ARGV-elements: "); while (optind < argc) printf ("%s ", argv[optind++]); printf ("\n"); } exit (0); } #endif /* TEST */ ecl-16.1.2/msvc/gmp/build.vc8/getopt.h000077500000000000000000000144731266352375300174000ustar00rootroot00000000000000/* Declarations for getopt. Copyright (C) 1989-1994, 1996-1999, 2001 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. */ #ifndef _GETOPT_H #ifndef __need_getopt # define _GETOPT_H 1 #endif /* If __GNU_LIBRARY__ is not already defined, either we are being used standalone, or this is the first header included in the source file. If we are being used with glibc, we need to include , but that does not exist if we are standalone. So: if __GNU_LIBRARY__ is not defined, include , which will pull in for us if it's from glibc. (Why ctype.h? It's guaranteed to exist and it doesn't flood the namespace with stuff the way some other headers do.) */ #if !defined __GNU_LIBRARY__ # include #endif #ifdef __cplusplus extern "C" { #endif /* For communication from `getopt' to the caller. When `getopt' finds an option that takes an argument, the argument value is returned here. Also, when `ordering' is RETURN_IN_ORDER, each non-option ARGV-element is returned here. */ extern char *optarg; /* Index in ARGV of the next element to be scanned. This is used for communication to and from the caller and for communication between successive calls to `getopt'. On entry to `getopt', zero means this is the first call; initialize. When `getopt' returns -1, this is the index of the first of the non-option elements that the caller should itself scan. Otherwise, `optind' communicates from one call to the next how much of ARGV has been scanned so far. */ extern int optind; /* Callers store zero here to inhibit the error message `getopt' prints for unrecognized options. */ extern int opterr; /* Set to an option character which was unrecognized. */ extern int optopt; #ifndef __need_getopt /* Describe the long-named options requested by the application. The LONG_OPTIONS argument to getopt_long or getopt_long_only is a vector of `struct option' terminated by an element containing a name which is zero. The field `has_arg' is: no_argument (or 0) if the option does not take an argument, required_argument (or 1) if the option requires an argument, optional_argument (or 2) if the option takes an optional argument. If the field `flag' is not NULL, it points to a variable that is set to the value given in the field `val' when the option is found, but left unchanged if the option is not found. To have a long-named option do something other than set an `int' to a compiled-in constant, such as set a value from `optarg', set the option's `flag' field to zero and its `val' field to a nonzero value (the equivalent single-letter option character, if there is one). For long options that have a zero `flag' field, `getopt' returns the contents of the `val' field. */ struct option { # if (defined __STDC__ && __STDC__) || defined __cplusplus const char *name; # else char *name; # endif /* has_arg can't be an enum because some compilers complain about type mismatches in all the code that assumes it is an int. */ int has_arg; int *flag; int val; }; /* Names for the values of the `has_arg' field of `struct option'. */ # define no_argument 0 # define required_argument 1 # define optional_argument 2 #endif /* need getopt */ /* Get definitions and prototypes for functions to process the arguments in ARGV (ARGC of them, minus the program name) for options given in OPTS. Return the option character from OPTS just read. Return -1 when there are no more options. For unrecognized options, or options missing arguments, `optopt' is set to the option letter, and '?' is returned. The OPTS string is a list of characters which are recognized option letters, optionally followed by colons, specifying that that letter takes an argument, to be placed in `optarg'. If a letter in OPTS is followed by two colons, its argument is optional. This behavior is specific to the GNU `getopt'. The argument `--' causes premature termination of argument scanning, explicitly telling `getopt' that there are no more options. If OPTS begins with `--', then non-option arguments are treated as arguments to the option '\0'. This behavior is specific to the GNU `getopt'. */ #if (defined __STDC__ && __STDC__) || defined __cplusplus # ifdef __GNU_LIBRARY__ /* Many other libraries have conflicting prototypes for getopt, with differences in the consts, in stdlib.h. To avoid compilation errors, only prototype getopt for the GNU C library. */ extern int getopt (int ___argc, char *const *___argv, const char *__shortopts); # else /* not __GNU_LIBRARY__ */ extern int getopt (); # endif /* __GNU_LIBRARY__ */ # ifndef __need_getopt extern int getopt_long (int ___argc, char *const *___argv, const char *__shortopts, const struct option *__longopts, int *__longind); extern int getopt_long_only (int ___argc, char *const *___argv, const char *__shortopts, const struct option *__longopts, int *__longind); /* Internal only. Users should not call this directly. */ extern int _getopt_internal (int ___argc, char *const *___argv, const char *__shortopts, const struct option *__longopts, int *__longind, int __long_only); # endif #else /* not __STDC__ */ extern int getopt (); # ifndef __need_getopt extern int getopt_long (); extern int getopt_long_only (); extern int _getopt_internal (); # endif #endif /* __STDC__ */ #ifdef __cplusplus } #endif /* Make sure we later can get all the definitions and declarations. */ #undef __need_getopt #endif /* getopt.h */ ecl-16.1.2/msvc/gmp/build.vc8/gmp.h000077500000000000000000002415621266352375300166620ustar00rootroot00000000000000/* Definitions for GNU multiple precision functions. -*- mode: c -*- Copyright 1991, 1993, 1994, 1995, 1996, 1997, 1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc. This file is part of the GNU MP Library. The GNU MP Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU MP Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU MP Library; see the file COPYING.LIB. If not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ #ifndef __GMP_H__ #if defined (__cplusplus) #include /* for std::istream, std::ostream, std::string */ #endif /* Instantiated by configure. */ #if ! defined (__GMP_WITHIN_CONFIGURE) # if defined( _MSC_VER ) # if defined( _WIN64 ) # define __GMP_BITS_PER_MP_LIMB 64 # define GMP_LIMB_BITS 64 # define SIZEOF_MP_LIMB_T 8 # define _LONG_LONG_LIMB 1 # elif defined( _WIN32 ) # define __GMP_BITS_PER_MP_LIMB 32 # define GMP_LIMB_BITS 32 # define SIZEOF_MP_LIMB_T 4 # ifdef _LONG_LONG_LIMB # undef _LONG_LONG_LIMB # endif # else # error This is the wrong version of gmp.h # endif # endif # define GMP_NAIL_BITS 0 #endif #define GMP_NUMB_BITS (GMP_LIMB_BITS - GMP_NAIL_BITS) #define GMP_NUMB_MASK ((~ __GMP_CAST (mp_limb_t, 0)) >> GMP_NAIL_BITS) #define GMP_NUMB_MAX GMP_NUMB_MASK #define GMP_NAIL_MASK (~ GMP_NUMB_MASK) /* The following (everything under ifndef __GNU_MP__) must be identical in gmp.h and mp.h to allow both to be included in an application or during the library build. */ #ifndef __GNU_MP__ #define __GNU_MP__ 4 #define __need_size_t /* tell gcc stddef.h we only want size_t */ #if defined (__cplusplus) #include /* for size_t */ #else #include /* for size_t */ #endif #undef __need_size_t /* __STDC__ - some ANSI compilers define this only to 0, hence the use of "defined" and not "__STDC__-0". In particular Sun workshop C 5.0 sets __STDC__ to 0, but requires "##" for token pasting. _AIX - gnu ansidecl.h asserts that all known AIX compilers are ANSI but don't always define __STDC__. __DECC - current versions of DEC C (5.9 for instance) for alpha are ANSI, but don't define __STDC__ in their default mode. Don't know if old versions might have been K&R, but let's not worry about that unless someone is still using one. _mips - gnu ansidecl.h says the RISC/OS MIPS compiler is ANSI in SVR4 mode, but doesn't define __STDC__. _MSC_VER - Microsoft C is ANSI, but __STDC__ is undefined unless the /Za option is given (in which case it's 1). _WIN32 - tested for by gnu ansidecl.h, no doubt on the assumption that all w32 compilers are ansi. Note: This same set of tests is used by gen-psqr.c and demos/expr/expr-impl.h, so if anything needs adding, then be sure to update those too. */ #if defined (__STDC__) \ || defined (__cplusplus) \ || defined (_AIX) \ || defined (__DECC) \ || (defined (__mips) && defined (_SYSTYPE_SVR4)) \ || defined (_MSC_VER) \ || defined (_WIN32) #define __GMP_HAVE_CONST 1 #define __GMP_HAVE_PROTOTYPES 1 #define __GMP_HAVE_TOKEN_PASTE 1 #else #define __GMP_HAVE_CONST 0 #define __GMP_HAVE_PROTOTYPES 0 #define __GMP_HAVE_TOKEN_PASTE 0 #endif #if __GMP_HAVE_CONST #define __gmp_const const #define __gmp_signed signed #else #define __gmp_const #define __gmp_signed #endif /* __GMP_DECLSPEC supports Windows DLL versions of libgmp, and is empty in all other circumstances. When compiling objects for libgmp, __GMP_DECLSPEC is an export directive, or when compiling for an application it's an import directive. The two cases are differentiated by __GMP_WITHIN_GMP defined by the GMP Makefiles (and not defined from an application). __GMP_DECLSPEC_XX is similarly used for libgmpxx. __GMP_WITHIN_GMPXX indicates when building libgmpxx, and in that case libgmpxx functions are exports, but libgmp functions which might get called are imports. libmp.la uses __GMP_DECLSPEC, just as if it were libgmp.la. libgmp and libmp don't call each other, so there's no conflict or confusion. Libtool DLL_EXPORT define is not used. There's no attempt to support GMP built both static and DLL. Doing so would mean applications would have to tell us which of the two is going to be used when linking, and that seems very tedious and error prone if using GMP by hand, and equally tedious from a package since autoconf and automake don't give much help. __GMP_DECLSPEC is required on all documented global functions and variables, the various internals in gmp-impl.h etc can be left unadorned. But internals used by the test programs or speed measuring programs should have __GMP_DECLSPEC, and certainly constants or variables must have it or the wrong address will be resolved. In gcc __declspec can go at either the start or end of a prototype. In Microsoft C __declspec must go at the start, or after the type like void __declspec(...) *foo()". There's no __dllexport or anything to guard against someone foolish #defining dllexport. _export used to be available, but no longer. In Borland C _export still exists, but needs to go after the type, like "void _export foo();". Would have to change the __GMP_DECLSPEC syntax to make use of that. Probably more trouble than it's worth. */ #if defined (__GNUC__) #define __GMP_DECLSPEC_EXPORT __declspec(__dllexport__) #define __GMP_DECLSPEC_IMPORT __declspec(__dllimport__) #endif #if defined (_MSC_VER) || defined (__BORLANDC__) #define __GMP_DECLSPEC_EXPORT __declspec(dllexport) #define __GMP_DECLSPEC_IMPORT __declspec(dllimport) #endif #ifdef __WATCOMC__ #define __GMP_DECLSPEC_EXPORT __export #define __GMP_DECLSPEC_IMPORT __import #endif #ifdef __IBMC__ #define __GMP_DECLSPEC_EXPORT _Export #define __GMP_DECLSPEC_IMPORT _Import #endif #if __GMP_LIBGMP_DLL #if __GMP_WITHIN_GMP /* compiling to go into a DLL libgmp */ #define __GMP_DECLSPEC __GMP_DECLSPEC_EXPORT #else /* compiling to go into an application which will link to a DLL libgmp */ #define __GMP_DECLSPEC __GMP_DECLSPEC_IMPORT #endif #else /* all other cases */ #define __GMP_DECLSPEC #endif /* In order to overcome issue with LL64 vias L64 on Windows 64 the next level of indirection is introduced: gmp_long instead of long */ /* #ifdef _WIN64 #define gmp_long __int64 #else #define typedef gmp_long long #endif */ #ifdef __GMP_SHORT_LIMB typedef unsigned int mp_limb_t; typedef int mp_limb_signed_t; #else #ifdef _LONG_LONG_LIMB typedef unsigned long long int mp_limb_t; typedef long long int mp_limb_signed_t; #else typedef unsigned long int mp_limb_t; typedef long int mp_limb_signed_t; #endif #endif /* For reference, note that the name __mpz_struct gets into C++ mangled function names, which means although the "__" suggests an internal, we must leave this name for binary compatibility. */ typedef struct { int _mp_alloc; /* Number of *limbs* allocated and pointed to by the _mp_d field. */ int _mp_size; /* abs(_mp_size) is the number of limbs the last field points to. If _mp_size is negative this is a negative number. */ mp_limb_t *_mp_d; /* Pointer to the limbs. */ } __mpz_struct; #endif /* __GNU_MP__ */ typedef __mpz_struct MP_INT; /* gmp 1 source compatibility */ typedef __mpz_struct mpz_t[1]; typedef mp_limb_t * mp_ptr; typedef __gmp_const mp_limb_t * mp_srcptr; #if defined (_CRAY) && ! defined (_CRAYMPP) /* plain `int' is much faster (48 bits) */ #define __GMP_MP_SIZE_T_INT 1 typedef int mp_size_t; typedef int mp_exp_t; #else #define __GMP_MP_SIZE_T_INT 0 typedef long int mp_size_t; typedef long int mp_exp_t; #endif typedef struct { __mpz_struct _mp_num; __mpz_struct _mp_den; } __mpq_struct; typedef __mpq_struct MP_RAT; /* gmp 1 source compatibility */ typedef __mpq_struct mpq_t[1]; typedef struct { int _mp_prec; /* Max precision, in number of `mp_limb_t's. Set by mpf_init and modified by mpf_set_prec. The area pointed to by the _mp_d field contains `prec' + 1 limbs. */ int _mp_size; /* abs(_mp_size) is the number of limbs the last field points to. If _mp_size is negative this is a negative number. */ mp_exp_t _mp_exp; /* Exponent, in the base of `mp_limb_t'. */ mp_limb_t *_mp_d; /* Pointer to the limbs. */ } __mpf_struct; /* typedef __mpf_struct MP_FLOAT; */ typedef __mpf_struct mpf_t[1]; /* Available random number generation algorithms. */ typedef enum { GMP_RAND_ALG_DEFAULT = 0, GMP_RAND_ALG_LC = GMP_RAND_ALG_DEFAULT /* Linear congruential. */ } gmp_randalg_t; /* Random state struct. */ typedef struct { mpz_t _mp_seed; /* _mp_d member points to state of the generator. */ gmp_randalg_t _mp_alg; /* Currently unused. */ union { void *_mp_lc; /* Pointer to function pointers structure. */ } _mp_algdata; } __gmp_randstate_struct; typedef __gmp_randstate_struct gmp_randstate_t[1]; /* Types for function declarations in gmp files. */ /* ??? Should not pollute user name space with these ??? */ typedef __gmp_const __mpz_struct *mpz_srcptr; typedef __mpz_struct *mpz_ptr; typedef __gmp_const __mpf_struct *mpf_srcptr; typedef __mpf_struct *mpf_ptr; typedef __gmp_const __mpq_struct *mpq_srcptr; typedef __mpq_struct *mpq_ptr; /* This is not wanted in mp.h, so put it outside the __GNU_MP__ common section. */ #if __GMP_LIBGMP_DLL #if __GMP_WITHIN_GMPXX /* compiling to go into a DLL libgmpxx */ #define __GMP_DECLSPEC_XX __GMP_DECLSPEC_EXPORT #else /* compiling to go into a application which will link to a DLL libgmpxx */ #define __GMP_DECLSPEC_XX __GMP_DECLSPEC_IMPORT #endif #else /* all other cases */ #define __GMP_DECLSPEC_XX #endif #if __GMP_HAVE_PROTOTYPES #define __GMP_PROTO(x) x #else #define __GMP_PROTO(x) () #endif #ifndef __MPN #if __GMP_HAVE_TOKEN_PASTE #define __MPN(x) __gmpn_##x #else #define __MPN(x) __gmpn_/**/x #endif #endif /* For reference, "defined(EOF)" cannot be used here. In g++ 2.95.4, defines EOF but not FILE. */ #if defined (FILE) \ || defined (H_STDIO) \ || defined (_H_STDIO) /* AIX */ \ || defined (_STDIO_H) /* glibc, Sun, SCO */ \ || defined (_STDIO_H_) /* BSD, OSF */ \ || defined (__STDIO_H) /* Borland */ \ || defined (__STDIO_H__) /* IRIX */ \ || defined (_STDIO_INCLUDED) /* HPUX */ \ || defined (__dj_include_stdio_h_) /* DJGPP */ \ || defined (_FILE_DEFINED) /* Microsoft */ \ || defined (__STDIO__) /* Apple MPW MrC */ \ || defined (_MSL_STDIO_H) /* Metrowerks */ \ || defined (_STDIO_H_INCLUDED) /* QNX4 */ #define _GMP_H_HAVE_FILE 1 #endif /* In ISO C, if a prototype involving "struct obstack *" is given without that structure defined, then the struct is scoped down to just the prototype, causing a conflict if it's subsequently defined for real. So only give prototypes if we've got obstack.h. */ #if defined (_OBSTACK_H) /* glibc */ #define _GMP_H_HAVE_OBSTACK 1 #endif /* The prototypes for gmp_vprintf etc are provided only if va_list is available, via an application having included or . Usually va_list is a typedef so can't be tested directly, but C99 specifies that va_start is a macro (and it was normally a macro on past systems too), so look for that. will define some sort of va_list for vprintf and vfprintf, but let's not bother trying to use that since it's not standard and since application uses for gmp_vprintf etc will almost certainly require the whole or anyway. */ #ifdef va_start #define _GMP_H_HAVE_VA_LIST 1 #endif /* Test for gcc >= maj.min, as per __GNUC_PREREQ in glibc */ #if defined (__GNUC__) && defined (__GNUC_MINOR__) #define __GMP_GNUC_PREREQ(maj, min) \ ((__GNUC__ << 16) + __GNUC_MINOR__ >= ((maj) << 16) + (min)) #else #define __GMP_GNUC_PREREQ(maj, min) 0 #endif /* "pure" is in gcc 2.96 and up, see "(gcc)Function Attributes". Basically it means a function does nothing but examine its arguments and memory (global or via arguments) to generate a return value, but changes nothing and has no side-effects. __GMP_NO_ATTRIBUTE_CONST_PURE lets tune/common.c etc turn this off when trying to write timing loops. */ #if __GMP_GNUC_PREREQ (2,96) && ! defined (__GMP_NO_ATTRIBUTE_CONST_PURE) #define __GMP_ATTRIBUTE_PURE __attribute__ ((__pure__)) #else #define __GMP_ATTRIBUTE_PURE #endif /* __GMP_CAST allows us to use static_cast in C++, so our macros are clean to "g++ -Wold-style-cast". Casts in "extern inline" code within an extern "C" block don't induce these warnings, so __GMP_CAST only needs to be used on documented macros. */ #ifdef __cplusplus #define __GMP_CAST(type, expr) (static_cast (expr)) #else #define __GMP_CAST(type, expr) ((type) (expr)) #endif /* An empty "throw ()" means the function doesn't throw any C++ exceptions, this can save some stack frame info in applications. Currently it's given only on functions which never divide-by-zero etc, don't allocate memory, and are expected to never need to allocate memory. This leaves open the possibility of a C++ throw from a future GMP exceptions scheme. mpz_set_ui etc are omitted to leave open the lazy allocation scheme described in doc/tasks.html. mpz_get_d etc are omitted to leave open exceptions for float overflows. Note that __GMP_NOTHROW must be given on any inlines the same as on their prototypes (for g++ at least, where they're used together). Note also that g++ 3.0 demands that __GMP_NOTHROW is before other attributes like __GMP_ATTRIBUTE_PURE. */ #if defined (__cplusplus) #define __GMP_NOTHROW throw () #else #define __GMP_NOTHROW #endif /* PORTME: What other compilers have a useful "extern inline"? "static inline" would be an acceptable substitute if the compiler (or linker) discards unused statics. */ /* gcc has __inline__ in all modes, including strict ansi. Give a prototype for an inline too, so as to correctly specify "dllimport" on windows, in case the function is called rather than inlined. */ #ifdef __GNUC__ #define __GMP_EXTERN_INLINE extern __inline__ #define __GMP_INLINE_PROTOTYPES 1 #endif /* DEC C (eg. version 5.9) supports "static __inline foo()", even in -std1 strict ANSI mode. Inlining is done even when not optimizing (ie. -O0 mode, which is the default), but an unnecessary local copy of foo is emitted unless -O is used. "extern __inline" is accepted, but the "extern" appears to be ignored, ie. it becomes a plain global function but which is inlined within its file. Don't know if all old versions of DEC C supported __inline, but as a start let's do the right thing for current versions. */ #ifdef __DECC #define __GMP_EXTERN_INLINE static __inline #endif /* SCO OpenUNIX 8 cc supports "static inline foo()" but not in -Xc strict ANSI mode (__STDC__ is 1 in that mode). Inlining only actually takes place under -O. Without -O "foo" seems to be emitted whether it's used or not, which is wasteful. "extern inline foo()" isn't useful, the "extern" is apparently ignored, so foo is inlined if possible but also emitted as a global, which causes multiple definition errors when building a shared libgmp. */ #ifdef __SCO_VERSION__ #if __SCO_VERSION__ > 400000000 && __STDC__ != 1 \ && ! defined (__GMP_EXTERN_INLINE) #define __GMP_EXTERN_INLINE static inline #endif #endif /* C++ always has "inline" and since it's a normal feature the linker should discard duplicate non-inlined copies, or if it doesn't then that's a problem for everyone, not just GMP. */ #if defined (__cplusplus) && ! defined (__GMP_EXTERN_INLINE) #define __GMP_EXTERN_INLINE inline #endif /* Don't do any inlining within a configure run, since if the compiler ends up emitting copies of the code into the object file it can end up demanding the various support routines (like mpn_popcount) for linking, making the "alloca" test and perhaps others fail. And on hppa ia64 a pre-release gcc 3.2 was seen not respecting the "extern" in "extern __inline__", triggering this problem too. */ #if defined (__GMP_WITHIN_CONFIGURE) && ! __GMP_WITHIN_CONFIGURE_INLINE #undef __GMP_EXTERN_INLINE #endif /* By default, don't give a prototype when there's going to be an inline version. Note in particular that Cray C++ objects to the combination of prototype and inline. */ #ifdef __GMP_EXTERN_INLINE #ifndef __GMP_INLINE_PROTOTYPES #define __GMP_INLINE_PROTOTYPES 0 #endif #else #define __GMP_INLINE_PROTOTYPES 1 #endif #define __GMP_ABS(x) ((x) >= 0 ? (x) : -(x)) #define __GMP_MAX(h,i) ((h) > (i) ? (h) : (i)) /* __GMP_USHRT_MAX is not "~ (unsigned short) 0" because short is promoted to int by "~". */ #define __GMP_UINT_MAX (~ (unsigned) 0) #define __GMP_ULONG_MAX (~ (unsigned long) 0) #define __GMP_USHRT_MAX ((unsigned short) ~0) /* __builtin_expect is in gcc 3.0, and not in 2.95. */ #if __GMP_GNUC_PREREQ (3,0) #define __GMP_LIKELY(cond) __builtin_expect ((cond) != 0, 1) #define __GMP_UNLIKELY(cond) __builtin_expect ((cond) != 0, 0) #else #define __GMP_LIKELY(cond) (cond) #define __GMP_UNLIKELY(cond) (cond) #endif #ifdef _CRAY #define __GMP_CRAY_Pragma(str) _Pragma (str) #else #define __GMP_CRAY_Pragma(str) #endif /* Allow direct user access to numerator and denominator of a mpq_t object. */ #define mpq_numref(Q) (&((Q)->_mp_num)) #define mpq_denref(Q) (&((Q)->_mp_den)) #if defined (__cplusplus) extern "C" { #endif #define mp_set_memory_functions __gmp_set_memory_functions __GMP_DECLSPEC void mp_set_memory_functions __GMP_PROTO ((void *(*) (size_t), void *(*) (void *, size_t, size_t), void (*) (void *, size_t))) __GMP_NOTHROW; #define mp_get_memory_functions __gmp_get_memory_functions __GMP_DECLSPEC void mp_get_memory_functions __GMP_PROTO ((void *(**) (size_t), void *(**) (void *, size_t, size_t), void (**) (void *, size_t))) __GMP_NOTHROW; #define mp_bits_per_limb __gmp_bits_per_limb __GMP_DECLSPEC extern __gmp_const int mp_bits_per_limb; #define gmp_errno __gmp_errno __GMP_DECLSPEC extern int gmp_errno; #define gmp_version __gmp_version __GMP_DECLSPEC extern __gmp_const char * __gmp_const gmp_version; /**************** Random number routines. ****************/ /* obsolete */ #define gmp_randinit __gmp_randinit __GMP_DECLSPEC void gmp_randinit __GMP_PROTO ((gmp_randstate_t, gmp_randalg_t, ...)); #define gmp_randinit_default __gmp_randinit_default __GMP_DECLSPEC void gmp_randinit_default __GMP_PROTO ((gmp_randstate_t)); #define gmp_randinit_lc_2exp __gmp_randinit_lc_2exp __GMP_DECLSPEC void gmp_randinit_lc_2exp __GMP_PROTO ((gmp_randstate_t, mpz_srcptr, unsigned long int, unsigned long int)); #define gmp_randinit_lc_2exp_size __gmp_randinit_lc_2exp_size __GMP_DECLSPEC int gmp_randinit_lc_2exp_size __GMP_PROTO ((gmp_randstate_t, unsigned long)); #define gmp_randinit_mt __gmp_randinit_mt __GMP_DECLSPEC void gmp_randinit_mt __GMP_PROTO ((gmp_randstate_t)); #define gmp_randinit_set __gmp_randinit_set void gmp_randinit_set __GMP_PROTO ((gmp_randstate_t, __gmp_const __gmp_randstate_struct *)); #define gmp_randseed __gmp_randseed __GMP_DECLSPEC void gmp_randseed __GMP_PROTO ((gmp_randstate_t, mpz_srcptr)); #define gmp_randseed_ui __gmp_randseed_ui __GMP_DECLSPEC void gmp_randseed_ui __GMP_PROTO ((gmp_randstate_t, unsigned long int)); #define gmp_randclear __gmp_randclear __GMP_DECLSPEC void gmp_randclear __GMP_PROTO ((gmp_randstate_t)); #define gmp_urandomb_ui __gmp_urandomb_ui unsigned long gmp_urandomb_ui __GMP_PROTO ((gmp_randstate_t, unsigned long)); #define gmp_urandomm_ui __gmp_urandomm_ui unsigned long gmp_urandomm_ui __GMP_PROTO ((gmp_randstate_t, unsigned long)); /**************** Formatted output routines. ****************/ #define gmp_asprintf __gmp_asprintf __GMP_DECLSPEC int gmp_asprintf __GMP_PROTO ((char **, __gmp_const char *, ...)); #define gmp_fprintf __gmp_fprintf #ifdef _GMP_H_HAVE_FILE __GMP_DECLSPEC int gmp_fprintf __GMP_PROTO ((FILE *, __gmp_const char *, ...)); #endif #define gmp_obstack_printf __gmp_obstack_printf #if defined (_GMP_H_HAVE_OBSTACK) __GMP_DECLSPEC int gmp_obstack_printf __GMP_PROTO ((struct obstack *, __gmp_const char *, ...)); #endif #define gmp_obstack_vprintf __gmp_obstack_vprintf #if defined (_GMP_H_HAVE_OBSTACK) && defined (_GMP_H_HAVE_VA_LIST) __GMP_DECLSPEC int gmp_obstack_vprintf __GMP_PROTO ((struct obstack *, __gmp_const char *, va_list)); #endif #define gmp_printf __gmp_printf __GMP_DECLSPEC int gmp_printf __GMP_PROTO ((__gmp_const char *, ...)); #define gmp_snprintf __gmp_snprintf __GMP_DECLSPEC int gmp_snprintf __GMP_PROTO ((char *, size_t, __gmp_const char *, ...)); #define gmp_sprintf __gmp_sprintf __GMP_DECLSPEC int gmp_sprintf __GMP_PROTO ((char *, __gmp_const char *, ...)); #define gmp_vasprintf __gmp_vasprintf #if defined (_GMP_H_HAVE_VA_LIST) __GMP_DECLSPEC int gmp_vasprintf __GMP_PROTO ((char **, __gmp_const char *, va_list)); #endif #define gmp_vfprintf __gmp_vfprintf #if defined (_GMP_H_HAVE_FILE) && defined (_GMP_H_HAVE_VA_LIST) __GMP_DECLSPEC int gmp_vfprintf __GMP_PROTO ((FILE *, __gmp_const char *, va_list)); #endif #define gmp_vprintf __gmp_vprintf #if defined (_GMP_H_HAVE_VA_LIST) __GMP_DECLSPEC int gmp_vprintf __GMP_PROTO ((__gmp_const char *, va_list)); #endif #define gmp_vsnprintf __gmp_vsnprintf #if defined (_GMP_H_HAVE_VA_LIST) __GMP_DECLSPEC int gmp_vsnprintf __GMP_PROTO ((char *, size_t, __gmp_const char *, va_list)); #endif #define gmp_vsprintf __gmp_vsprintf #if defined (_GMP_H_HAVE_VA_LIST) __GMP_DECLSPEC int gmp_vsprintf __GMP_PROTO ((char *, __gmp_const char *, va_list)); #endif /**************** Formatted input routines. ****************/ #define gmp_fscanf __gmp_fscanf #ifdef _GMP_H_HAVE_FILE __GMP_DECLSPEC int gmp_fscanf __GMP_PROTO ((FILE *, __gmp_const char *, ...)); #endif #define gmp_scanf __gmp_scanf __GMP_DECLSPEC int gmp_scanf __GMP_PROTO ((__gmp_const char *, ...)); #define gmp_sscanf __gmp_sscanf __GMP_DECLSPEC int gmp_sscanf __GMP_PROTO ((__gmp_const char *, __gmp_const char *, ...)); #define gmp_vfscanf __gmp_vfscanf #if defined (_GMP_H_HAVE_FILE) && defined (_GMP_H_HAVE_VA_LIST) __GMP_DECLSPEC int gmp_vfscanf __GMP_PROTO ((FILE *, __gmp_const char *, va_list)); #endif #define gmp_vscanf __gmp_vscanf #if defined (_GMP_H_HAVE_VA_LIST) __GMP_DECLSPEC int gmp_vscanf __GMP_PROTO ((__gmp_const char *, va_list)); #endif #define gmp_vsscanf __gmp_vsscanf #if defined (_GMP_H_HAVE_VA_LIST) __GMP_DECLSPEC int gmp_vsscanf __GMP_PROTO ((__gmp_const char *, __gmp_const char *, va_list)); #endif /**************** Integer (i.e. Z) routines. ****************/ #define _mpz_realloc __gmpz_realloc #define mpz_realloc __gmpz_realloc __GMP_DECLSPEC void *_mpz_realloc __GMP_PROTO ((mpz_ptr, mp_size_t)); #define mpz_abs __gmpz_abs #if __GMP_INLINE_PROTOTYPES || defined (__GMP_FORCE_mpz_abs) __GMP_DECLSPEC void mpz_abs __GMP_PROTO ((mpz_ptr, mpz_srcptr)); #endif #define mpz_add __gmpz_add __GMP_DECLSPEC void mpz_add __GMP_PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr)); #define mpz_add_ui __gmpz_add_ui __GMP_DECLSPEC void mpz_add_ui __GMP_PROTO ((mpz_ptr, mpz_srcptr, unsigned long int)); #define mpz_addmul __gmpz_addmul __GMP_DECLSPEC void mpz_addmul __GMP_PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr)); #define mpz_addmul_ui __gmpz_addmul_ui __GMP_DECLSPEC void mpz_addmul_ui __GMP_PROTO ((mpz_ptr, mpz_srcptr, unsigned long int)); #define mpz_and __gmpz_and __GMP_DECLSPEC void mpz_and __GMP_PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr)); #define mpz_array_init __gmpz_array_init __GMP_DECLSPEC void mpz_array_init __GMP_PROTO ((mpz_ptr, mp_size_t, mp_size_t)); #define mpz_bin_ui __gmpz_bin_ui __GMP_DECLSPEC void mpz_bin_ui __GMP_PROTO ((mpz_ptr, mpz_srcptr, unsigned long int)); #define mpz_bin_uiui __gmpz_bin_uiui __GMP_DECLSPEC void mpz_bin_uiui __GMP_PROTO ((mpz_ptr, unsigned long int, unsigned long int)); #define mpz_cdiv_q __gmpz_cdiv_q __GMP_DECLSPEC void mpz_cdiv_q __GMP_PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr)); #define mpz_cdiv_q_2exp __gmpz_cdiv_q_2exp __GMP_DECLSPEC void mpz_cdiv_q_2exp __GMP_PROTO ((mpz_ptr, mpz_srcptr, unsigned long)); #define mpz_cdiv_q_ui __gmpz_cdiv_q_ui __GMP_DECLSPEC unsigned long int mpz_cdiv_q_ui __GMP_PROTO ((mpz_ptr, mpz_srcptr, unsigned long int)); #define mpz_cdiv_qr __gmpz_cdiv_qr __GMP_DECLSPEC void mpz_cdiv_qr __GMP_PROTO ((mpz_ptr, mpz_ptr, mpz_srcptr, mpz_srcptr)); #define mpz_cdiv_qr_ui __gmpz_cdiv_qr_ui __GMP_DECLSPEC unsigned long int mpz_cdiv_qr_ui __GMP_PROTO ((mpz_ptr, mpz_ptr, mpz_srcptr, unsigned long int)); #define mpz_cdiv_r __gmpz_cdiv_r __GMP_DECLSPEC void mpz_cdiv_r __GMP_PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr)); #define mpz_cdiv_r_2exp __gmpz_cdiv_r_2exp __GMP_DECLSPEC void mpz_cdiv_r_2exp __GMP_PROTO ((mpz_ptr, mpz_srcptr, unsigned long)); #define mpz_cdiv_r_ui __gmpz_cdiv_r_ui __GMP_DECLSPEC unsigned long int mpz_cdiv_r_ui __GMP_PROTO ((mpz_ptr, mpz_srcptr, unsigned long int)); #define mpz_cdiv_ui __gmpz_cdiv_ui __GMP_DECLSPEC unsigned long int mpz_cdiv_ui __GMP_PROTO ((mpz_srcptr, unsigned long int)) __GMP_ATTRIBUTE_PURE; #define mpz_clear __gmpz_clear __GMP_DECLSPEC void mpz_clear __GMP_PROTO ((mpz_ptr)); #define mpz_clrbit __gmpz_clrbit __GMP_DECLSPEC void mpz_clrbit __GMP_PROTO ((mpz_ptr, unsigned long int)); #define mpz_cmp __gmpz_cmp __GMP_DECLSPEC int mpz_cmp __GMP_PROTO ((mpz_srcptr, mpz_srcptr)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; #define mpz_cmp_d __gmpz_cmp_d __GMP_DECLSPEC int mpz_cmp_d __GMP_PROTO ((mpz_srcptr, double)) __GMP_ATTRIBUTE_PURE; #define _mpz_cmp_si __gmpz_cmp_si __GMP_DECLSPEC int _mpz_cmp_si __GMP_PROTO ((mpz_srcptr, signed long int)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; #define _mpz_cmp_ui __gmpz_cmp_ui __GMP_DECLSPEC int _mpz_cmp_ui __GMP_PROTO ((mpz_srcptr, unsigned long int)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; #define mpz_cmpabs __gmpz_cmpabs __GMP_DECLSPEC int mpz_cmpabs __GMP_PROTO ((mpz_srcptr, mpz_srcptr)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; #define mpz_cmpabs_d __gmpz_cmpabs_d __GMP_DECLSPEC int mpz_cmpabs_d __GMP_PROTO ((mpz_srcptr, double)) __GMP_ATTRIBUTE_PURE; #define mpz_cmpabs_ui __gmpz_cmpabs_ui __GMP_DECLSPEC int mpz_cmpabs_ui __GMP_PROTO ((mpz_srcptr, unsigned long int)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; #define mpz_com __gmpz_com __GMP_DECLSPEC void mpz_com __GMP_PROTO ((mpz_ptr, mpz_srcptr)); #define mpz_combit __gmpz_combit __GMP_DECLSPEC void mpz_combit __GMP_PROTO ((mpz_ptr, unsigned long int)); #define mpz_congruent_p __gmpz_congruent_p __GMP_DECLSPEC int mpz_congruent_p __GMP_PROTO ((mpz_srcptr, mpz_srcptr, mpz_srcptr)) __GMP_ATTRIBUTE_PURE; #define mpz_congruent_2exp_p __gmpz_congruent_2exp_p __GMP_DECLSPEC int mpz_congruent_2exp_p __GMP_PROTO ((mpz_srcptr, mpz_srcptr, unsigned long)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; #define mpz_congruent_ui_p __gmpz_congruent_ui_p __GMP_DECLSPEC int mpz_congruent_ui_p __GMP_PROTO ((mpz_srcptr, unsigned long, unsigned long)) __GMP_ATTRIBUTE_PURE; #define mpz_divexact __gmpz_divexact __GMP_DECLSPEC void mpz_divexact __GMP_PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr)); #define mpz_divexact_ui __gmpz_divexact_ui __GMP_DECLSPEC void mpz_divexact_ui __GMP_PROTO ((mpz_ptr, mpz_srcptr, unsigned long)); #define mpz_divisible_p __gmpz_divisible_p __GMP_DECLSPEC int mpz_divisible_p __GMP_PROTO ((mpz_srcptr, mpz_srcptr)) __GMP_ATTRIBUTE_PURE; #define mpz_divisible_ui_p __gmpz_divisible_ui_p __GMP_DECLSPEC int mpz_divisible_ui_p __GMP_PROTO ((mpz_srcptr, unsigned long)) __GMP_ATTRIBUTE_PURE; #define mpz_divisible_2exp_p __gmpz_divisible_2exp_p __GMP_DECLSPEC int mpz_divisible_2exp_p __GMP_PROTO ((mpz_srcptr, unsigned long)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; #define mpz_dump __gmpz_dump __GMP_DECLSPEC void mpz_dump __GMP_PROTO ((mpz_srcptr)); #define mpz_export __gmpz_export __GMP_DECLSPEC void *mpz_export __GMP_PROTO ((void *, size_t *, int, size_t, int, size_t, mpz_srcptr)); #define mpz_fac_ui __gmpz_fac_ui __GMP_DECLSPEC void mpz_fac_ui __GMP_PROTO ((mpz_ptr, unsigned long int)); #define mpz_fdiv_q __gmpz_fdiv_q __GMP_DECLSPEC void mpz_fdiv_q __GMP_PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr)); #define mpz_fdiv_q_2exp __gmpz_fdiv_q_2exp __GMP_DECLSPEC void mpz_fdiv_q_2exp __GMP_PROTO ((mpz_ptr, mpz_srcptr, unsigned long int)); #define mpz_fdiv_q_ui __gmpz_fdiv_q_ui __GMP_DECLSPEC unsigned long int mpz_fdiv_q_ui __GMP_PROTO ((mpz_ptr, mpz_srcptr, unsigned long int)); #define mpz_fdiv_qr __gmpz_fdiv_qr __GMP_DECLSPEC void mpz_fdiv_qr __GMP_PROTO ((mpz_ptr, mpz_ptr, mpz_srcptr, mpz_srcptr)); #define mpz_fdiv_qr_ui __gmpz_fdiv_qr_ui __GMP_DECLSPEC unsigned long int mpz_fdiv_qr_ui __GMP_PROTO ((mpz_ptr, mpz_ptr, mpz_srcptr, unsigned long int)); #define mpz_fdiv_r __gmpz_fdiv_r __GMP_DECLSPEC void mpz_fdiv_r __GMP_PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr)); #define mpz_fdiv_r_2exp __gmpz_fdiv_r_2exp __GMP_DECLSPEC void mpz_fdiv_r_2exp __GMP_PROTO ((mpz_ptr, mpz_srcptr, unsigned long int)); #define mpz_fdiv_r_ui __gmpz_fdiv_r_ui __GMP_DECLSPEC unsigned long int mpz_fdiv_r_ui __GMP_PROTO ((mpz_ptr, mpz_srcptr, unsigned long int)); #define mpz_fdiv_ui __gmpz_fdiv_ui __GMP_DECLSPEC unsigned long int mpz_fdiv_ui __GMP_PROTO ((mpz_srcptr, unsigned long int)) __GMP_ATTRIBUTE_PURE; #define mpz_fib_ui __gmpz_fib_ui __GMP_DECLSPEC void mpz_fib_ui __GMP_PROTO ((mpz_ptr, unsigned long int)); #define mpz_fib2_ui __gmpz_fib2_ui __GMP_DECLSPEC void mpz_fib2_ui __GMP_PROTO ((mpz_ptr, mpz_ptr, unsigned long int)); #define mpz_fits_sint_p __gmpz_fits_sint_p __GMP_DECLSPEC int mpz_fits_sint_p __GMP_PROTO ((mpz_srcptr)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; #define mpz_fits_slong_p __gmpz_fits_slong_p __GMP_DECLSPEC int mpz_fits_slong_p __GMP_PROTO ((mpz_srcptr)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; #define mpz_fits_sshort_p __gmpz_fits_sshort_p __GMP_DECLSPEC int mpz_fits_sshort_p __GMP_PROTO ((mpz_srcptr)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; #define mpz_fits_uint_p __gmpz_fits_uint_p #if __GMP_INLINE_PROTOTYPES || defined (__GMP_FORCE_mpz_fits_uint_p) __GMP_DECLSPEC int mpz_fits_uint_p __GMP_PROTO ((mpz_srcptr)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; #endif #define mpz_fits_ulong_p __gmpz_fits_ulong_p #if __GMP_INLINE_PROTOTYPES || defined (__GMP_FORCE_mpz_fits_ulong_p) __GMP_DECLSPEC int mpz_fits_ulong_p __GMP_PROTO ((mpz_srcptr)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; #endif #define mpz_fits_ushort_p __gmpz_fits_ushort_p #if __GMP_INLINE_PROTOTYPES || defined (__GMP_FORCE_mpz_fits_ushort_p) __GMP_DECLSPEC int mpz_fits_ushort_p __GMP_PROTO ((mpz_srcptr)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; #endif #define mpz_gcd __gmpz_gcd __GMP_DECLSPEC void mpz_gcd __GMP_PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr)); #define mpz_gcd_ui __gmpz_gcd_ui __GMP_DECLSPEC unsigned long int mpz_gcd_ui __GMP_PROTO ((mpz_ptr, mpz_srcptr, unsigned long int)); #define mpz_gcdext __gmpz_gcdext __GMP_DECLSPEC void mpz_gcdext __GMP_PROTO ((mpz_ptr, mpz_ptr, mpz_ptr, mpz_srcptr, mpz_srcptr)); #define mpz_get_d __gmpz_get_d __GMP_DECLSPEC double mpz_get_d __GMP_PROTO ((mpz_srcptr)) __GMP_ATTRIBUTE_PURE; #define mpz_get_d_2exp __gmpz_get_d_2exp __GMP_DECLSPEC double mpz_get_d_2exp __GMP_PROTO ((signed long int *, mpz_srcptr)); #define mpz_get_si __gmpz_get_si __GMP_DECLSPEC /* signed */ long int mpz_get_si __GMP_PROTO ((mpz_srcptr)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; #define mpz_get_str __gmpz_get_str __GMP_DECLSPEC char *mpz_get_str __GMP_PROTO ((char *, int, mpz_srcptr)); #define mpz_get_ui __gmpz_get_ui #if __GMP_INLINE_PROTOTYPES || defined (__GMP_FORCE_mpz_get_ui) __GMP_DECLSPEC unsigned long int mpz_get_ui __GMP_PROTO ((mpz_srcptr)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; #endif #define mpz_getlimbn __gmpz_getlimbn #if __GMP_INLINE_PROTOTYPES || defined (__GMP_FORCE_mpz_getlimbn) __GMP_DECLSPEC mp_limb_t mpz_getlimbn __GMP_PROTO ((mpz_srcptr, mp_size_t)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; #endif #define mpz_hamdist __gmpz_hamdist __GMP_DECLSPEC unsigned long int mpz_hamdist __GMP_PROTO ((mpz_srcptr, mpz_srcptr)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; #define mpz_import __gmpz_import __GMP_DECLSPEC void mpz_import __GMP_PROTO ((mpz_ptr, size_t, int, size_t, int, size_t, __gmp_const void *)); #define mpz_init __gmpz_init __GMP_DECLSPEC void mpz_init __GMP_PROTO ((mpz_ptr)); #define mpz_init2 __gmpz_init2 __GMP_DECLSPEC void mpz_init2 __GMP_PROTO ((mpz_ptr, unsigned long)); #define mpz_init_set __gmpz_init_set __GMP_DECLSPEC void mpz_init_set __GMP_PROTO ((mpz_ptr, mpz_srcptr)); #define mpz_init_set_d __gmpz_init_set_d __GMP_DECLSPEC void mpz_init_set_d __GMP_PROTO ((mpz_ptr, double)); #define mpz_init_set_si __gmpz_init_set_si __GMP_DECLSPEC void mpz_init_set_si __GMP_PROTO ((mpz_ptr, signed long int)); #define mpz_init_set_str __gmpz_init_set_str __GMP_DECLSPEC int mpz_init_set_str __GMP_PROTO ((mpz_ptr, __gmp_const char *, int)); #define mpz_init_set_ui __gmpz_init_set_ui __GMP_DECLSPEC void mpz_init_set_ui __GMP_PROTO ((mpz_ptr, unsigned long int)); #define mpz_inp_raw __gmpz_inp_raw #ifdef _GMP_H_HAVE_FILE __GMP_DECLSPEC size_t mpz_inp_raw __GMP_PROTO ((mpz_ptr, FILE *)); #endif #define mpz_inp_str __gmpz_inp_str #ifdef _GMP_H_HAVE_FILE __GMP_DECLSPEC size_t mpz_inp_str __GMP_PROTO ((mpz_ptr, FILE *, int)); #endif #define mpz_invert __gmpz_invert __GMP_DECLSPEC int mpz_invert __GMP_PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr)); #define mpz_ior __gmpz_ior __GMP_DECLSPEC void mpz_ior __GMP_PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr)); #define mpz_jacobi __gmpz_jacobi __GMP_DECLSPEC int mpz_jacobi __GMP_PROTO ((mpz_srcptr, mpz_srcptr)) __GMP_ATTRIBUTE_PURE; #define mpz_kronecker mpz_jacobi /* alias */ #define mpz_kronecker_si __gmpz_kronecker_si __GMP_DECLSPEC int mpz_kronecker_si __GMP_PROTO ((mpz_srcptr, long)) __GMP_ATTRIBUTE_PURE; #define mpz_kronecker_ui __gmpz_kronecker_ui __GMP_DECLSPEC int mpz_kronecker_ui __GMP_PROTO ((mpz_srcptr, unsigned long)) __GMP_ATTRIBUTE_PURE; #define mpz_si_kronecker __gmpz_si_kronecker __GMP_DECLSPEC int mpz_si_kronecker __GMP_PROTO ((long, mpz_srcptr)) __GMP_ATTRIBUTE_PURE; #define mpz_ui_kronecker __gmpz_ui_kronecker __GMP_DECLSPEC int mpz_ui_kronecker __GMP_PROTO ((unsigned long, mpz_srcptr)) __GMP_ATTRIBUTE_PURE; #define mpz_lcm __gmpz_lcm __GMP_DECLSPEC void mpz_lcm __GMP_PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr)); #define mpz_lcm_ui __gmpz_lcm_ui __GMP_DECLSPEC void mpz_lcm_ui __GMP_PROTO ((mpz_ptr, mpz_srcptr, unsigned long)); #define mpz_legendre mpz_jacobi /* alias */ #define mpz_lucnum_ui __gmpz_lucnum_ui __GMP_DECLSPEC void mpz_lucnum_ui __GMP_PROTO ((mpz_ptr, unsigned long int)); #define mpz_lucnum2_ui __gmpz_lucnum2_ui __GMP_DECLSPEC void mpz_lucnum2_ui __GMP_PROTO ((mpz_ptr, mpz_ptr, unsigned long int)); #define mpz_millerrabin __gmpz_millerrabin __GMP_DECLSPEC int mpz_millerrabin __GMP_PROTO ((mpz_srcptr, int)) __GMP_ATTRIBUTE_PURE; #define mpz_mod __gmpz_mod __GMP_DECLSPEC void mpz_mod __GMP_PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr)); #define mpz_mod_ui mpz_fdiv_r_ui /* same as fdiv_r because divisor unsigned */ #define mpz_mul __gmpz_mul __GMP_DECLSPEC void mpz_mul __GMP_PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr)); #define mpz_mul_2exp __gmpz_mul_2exp __GMP_DECLSPEC void mpz_mul_2exp __GMP_PROTO ((mpz_ptr, mpz_srcptr, unsigned long int)); #define mpz_mul_si __gmpz_mul_si __GMP_DECLSPEC void mpz_mul_si __GMP_PROTO ((mpz_ptr, mpz_srcptr, long int)); #define mpz_mul_ui __gmpz_mul_ui __GMP_DECLSPEC void mpz_mul_ui __GMP_PROTO ((mpz_ptr, mpz_srcptr, unsigned long int)); #define mpz_neg __gmpz_neg #if __GMP_INLINE_PROTOTYPES || defined (__GMP_FORCE_mpz_neg) __GMP_DECLSPEC void mpz_neg __GMP_PROTO ((mpz_ptr, mpz_srcptr)); #endif #define mpz_nextprime __gmpz_nextprime __GMP_DECLSPEC void mpz_nextprime __GMP_PROTO ((mpz_ptr, mpz_srcptr)); #define mpz_out_raw __gmpz_out_raw #ifdef _GMP_H_HAVE_FILE __GMP_DECLSPEC size_t mpz_out_raw __GMP_PROTO ((FILE *, mpz_srcptr)); #endif #define mpz_out_str __gmpz_out_str #ifdef _GMP_H_HAVE_FILE __GMP_DECLSPEC size_t mpz_out_str __GMP_PROTO ((FILE *, int, mpz_srcptr)); #endif #define mpz_perfect_power_p __gmpz_perfect_power_p __GMP_DECLSPEC int mpz_perfect_power_p __GMP_PROTO ((mpz_srcptr)) __GMP_ATTRIBUTE_PURE; #define mpz_perfect_square_p __gmpz_perfect_square_p #if __GMP_INLINE_PROTOTYPES || defined (__GMP_FORCE_mpz_perfect_square_p) __GMP_DECLSPEC int mpz_perfect_square_p __GMP_PROTO ((mpz_srcptr)) __GMP_ATTRIBUTE_PURE; #endif #define mpz_popcount __gmpz_popcount #if __GMP_INLINE_PROTOTYPES || defined (__GMP_FORCE_mpz_popcount) __GMP_DECLSPEC unsigned long int mpz_popcount __GMP_PROTO ((mpz_srcptr)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; #endif #define mpz_pow_ui __gmpz_pow_ui __GMP_DECLSPEC void mpz_pow_ui __GMP_PROTO ((mpz_ptr, mpz_srcptr, unsigned long int)); #define mpz_powm __gmpz_powm __GMP_DECLSPEC void mpz_powm __GMP_PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr, mpz_srcptr)); #define mpz_powm_ui __gmpz_powm_ui __GMP_DECLSPEC void mpz_powm_ui __GMP_PROTO ((mpz_ptr, mpz_srcptr, unsigned long int, mpz_srcptr)); #define mpz_probab_prime_p __gmpz_probab_prime_p __GMP_DECLSPEC int mpz_probab_prime_p __GMP_PROTO ((mpz_srcptr, int)) __GMP_ATTRIBUTE_PURE; #define mpz_random __gmpz_random __GMP_DECLSPEC void mpz_random __GMP_PROTO ((mpz_ptr, mp_size_t)); #define mpz_random2 __gmpz_random2 __GMP_DECLSPEC void mpz_random2 __GMP_PROTO ((mpz_ptr, mp_size_t)); #define mpz_realloc2 __gmpz_realloc2 __GMP_DECLSPEC void mpz_realloc2 __GMP_PROTO ((mpz_ptr, unsigned long)); #define mpz_remove __gmpz_remove __GMP_DECLSPEC unsigned long int mpz_remove __GMP_PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr)); #define mpz_root __gmpz_root __GMP_DECLSPEC int mpz_root __GMP_PROTO ((mpz_ptr, mpz_srcptr, unsigned long int)); #define mpz_rootrem __gmpz_rootrem __GMP_DECLSPEC void mpz_rootrem __GMP_PROTO ((mpz_ptr,mpz_ptr, mpz_srcptr, unsigned long int)); #define mpz_rrandomb __gmpz_rrandomb __GMP_DECLSPEC void mpz_rrandomb __GMP_PROTO ((mpz_ptr, gmp_randstate_t, unsigned long int)); #define mpz_scan0 __gmpz_scan0 __GMP_DECLSPEC unsigned long int mpz_scan0 __GMP_PROTO ((mpz_srcptr, unsigned long int)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; #define mpz_scan1 __gmpz_scan1 __GMP_DECLSPEC unsigned long int mpz_scan1 __GMP_PROTO ((mpz_srcptr, unsigned long int)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; #define mpz_set __gmpz_set __GMP_DECLSPEC void mpz_set __GMP_PROTO ((mpz_ptr, mpz_srcptr)); #define mpz_set_d __gmpz_set_d __GMP_DECLSPEC void mpz_set_d __GMP_PROTO ((mpz_ptr, double)); #define mpz_set_f __gmpz_set_f __GMP_DECLSPEC void mpz_set_f __GMP_PROTO ((mpz_ptr, mpf_srcptr)); #define mpz_set_q __gmpz_set_q #if __GMP_INLINE_PROTOTYPES || defined (__GMP_FORCE_mpz_set_q) __GMP_DECLSPEC void mpz_set_q __GMP_PROTO ((mpz_ptr, mpq_srcptr)); #endif #define mpz_set_si __gmpz_set_si __GMP_DECLSPEC void mpz_set_si __GMP_PROTO ((mpz_ptr, long int)); #define mpz_set_str __gmpz_set_str __GMP_DECLSPEC int mpz_set_str __GMP_PROTO ((mpz_ptr, __gmp_const char *, int)); #define mpz_set_ui __gmpz_set_ui __GMP_DECLSPEC void mpz_set_ui __GMP_PROTO ((mpz_ptr, unsigned long int)); #define mpz_setbit __gmpz_setbit __GMP_DECLSPEC void mpz_setbit __GMP_PROTO ((mpz_ptr, unsigned long int)); #define mpz_size __gmpz_size #if __GMP_INLINE_PROTOTYPES || defined (__GMP_FORCE_mpz_size) __GMP_DECLSPEC size_t mpz_size __GMP_PROTO ((mpz_srcptr)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; #endif #define mpz_sizeinbase __gmpz_sizeinbase __GMP_DECLSPEC size_t mpz_sizeinbase __GMP_PROTO ((mpz_srcptr, int)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; #define mpz_sqrt __gmpz_sqrt __GMP_DECLSPEC void mpz_sqrt __GMP_PROTO ((mpz_ptr, mpz_srcptr)); #define mpz_sqrtrem __gmpz_sqrtrem __GMP_DECLSPEC void mpz_sqrtrem __GMP_PROTO ((mpz_ptr, mpz_ptr, mpz_srcptr)); #define mpz_sub __gmpz_sub __GMP_DECLSPEC void mpz_sub __GMP_PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr)); #define mpz_sub_ui __gmpz_sub_ui __GMP_DECLSPEC void mpz_sub_ui __GMP_PROTO ((mpz_ptr, mpz_srcptr, unsigned long int)); #define mpz_ui_sub __gmpz_ui_sub __GMP_DECLSPEC void mpz_ui_sub __GMP_PROTO ((mpz_ptr, unsigned long int, mpz_srcptr)); #define mpz_submul __gmpz_submul __GMP_DECLSPEC void mpz_submul __GMP_PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr)); #define mpz_submul_ui __gmpz_submul_ui __GMP_DECLSPEC void mpz_submul_ui __GMP_PROTO ((mpz_ptr, mpz_srcptr, unsigned long int)); #define mpz_swap __gmpz_swap __GMP_DECLSPEC void mpz_swap __GMP_PROTO ((mpz_ptr, mpz_ptr)) __GMP_NOTHROW; #define mpz_tdiv_ui __gmpz_tdiv_ui __GMP_DECLSPEC unsigned long int mpz_tdiv_ui __GMP_PROTO ((mpz_srcptr, unsigned long int)) __GMP_ATTRIBUTE_PURE; #define mpz_tdiv_q __gmpz_tdiv_q __GMP_DECLSPEC void mpz_tdiv_q __GMP_PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr)); #define mpz_tdiv_q_2exp __gmpz_tdiv_q_2exp __GMP_DECLSPEC void mpz_tdiv_q_2exp __GMP_PROTO ((mpz_ptr, mpz_srcptr, unsigned long int)); #define mpz_tdiv_q_ui __gmpz_tdiv_q_ui __GMP_DECLSPEC unsigned long int mpz_tdiv_q_ui __GMP_PROTO ((mpz_ptr, mpz_srcptr, unsigned long int)); #define mpz_tdiv_qr __gmpz_tdiv_qr __GMP_DECLSPEC void mpz_tdiv_qr __GMP_PROTO ((mpz_ptr, mpz_ptr, mpz_srcptr, mpz_srcptr)); #define mpz_tdiv_qr_ui __gmpz_tdiv_qr_ui __GMP_DECLSPEC unsigned long int mpz_tdiv_qr_ui __GMP_PROTO ((mpz_ptr, mpz_ptr, mpz_srcptr, unsigned long int)); #define mpz_tdiv_r __gmpz_tdiv_r __GMP_DECLSPEC void mpz_tdiv_r __GMP_PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr)); #define mpz_tdiv_r_2exp __gmpz_tdiv_r_2exp __GMP_DECLSPEC void mpz_tdiv_r_2exp __GMP_PROTO ((mpz_ptr, mpz_srcptr, unsigned long int)); #define mpz_tdiv_r_ui __gmpz_tdiv_r_ui __GMP_DECLSPEC unsigned long int mpz_tdiv_r_ui __GMP_PROTO ((mpz_ptr, mpz_srcptr, unsigned long int)); #define mpz_tstbit __gmpz_tstbit __GMP_DECLSPEC int mpz_tstbit __GMP_PROTO ((mpz_srcptr, unsigned long int)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; #define mpz_ui_pow_ui __gmpz_ui_pow_ui __GMP_DECLSPEC void mpz_ui_pow_ui __GMP_PROTO ((mpz_ptr, unsigned long int, unsigned long int)); #define mpz_urandomb __gmpz_urandomb __GMP_DECLSPEC void mpz_urandomb __GMP_PROTO ((mpz_ptr, gmp_randstate_t, unsigned long int)); #define mpz_urandomm __gmpz_urandomm __GMP_DECLSPEC void mpz_urandomm __GMP_PROTO ((mpz_ptr, gmp_randstate_t, mpz_srcptr)); #define mpz_xor __gmpz_xor #define mpz_eor __gmpz_xor __GMP_DECLSPEC void mpz_xor __GMP_PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr)); /**************** Rational (i.e. Q) routines. ****************/ #define mpq_abs __gmpq_abs #if __GMP_INLINE_PROTOTYPES || defined (__GMP_FORCE_mpq_abs) __GMP_DECLSPEC void mpq_abs __GMP_PROTO ((mpq_ptr, mpq_srcptr)); #endif #define mpq_add __gmpq_add __GMP_DECLSPEC void mpq_add __GMP_PROTO ((mpq_ptr, mpq_srcptr, mpq_srcptr)); #define mpq_canonicalize __gmpq_canonicalize __GMP_DECLSPEC void mpq_canonicalize __GMP_PROTO ((mpq_ptr)); #define mpq_clear __gmpq_clear __GMP_DECLSPEC void mpq_clear __GMP_PROTO ((mpq_ptr)); #define mpq_cmp __gmpq_cmp __GMP_DECLSPEC int mpq_cmp __GMP_PROTO ((mpq_srcptr, mpq_srcptr)) __GMP_ATTRIBUTE_PURE; #define _mpq_cmp_si __gmpq_cmp_si __GMP_DECLSPEC int _mpq_cmp_si __GMP_PROTO ((mpq_srcptr, long, unsigned long)) __GMP_ATTRIBUTE_PURE; #define _mpq_cmp_ui __gmpq_cmp_ui __GMP_DECLSPEC int _mpq_cmp_ui __GMP_PROTO ((mpq_srcptr, unsigned long int, unsigned long int)) __GMP_ATTRIBUTE_PURE; #define mpq_div __gmpq_div __GMP_DECLSPEC void mpq_div __GMP_PROTO ((mpq_ptr, mpq_srcptr, mpq_srcptr)); #define mpq_div_2exp __gmpq_div_2exp __GMP_DECLSPEC void mpq_div_2exp __GMP_PROTO ((mpq_ptr, mpq_srcptr, unsigned long)); #define mpq_equal __gmpq_equal __GMP_DECLSPEC int mpq_equal __GMP_PROTO ((mpq_srcptr, mpq_srcptr)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; #define mpq_get_num __gmpq_get_num __GMP_DECLSPEC void mpq_get_num __GMP_PROTO ((mpz_ptr, mpq_srcptr)); #define mpq_get_den __gmpq_get_den __GMP_DECLSPEC void mpq_get_den __GMP_PROTO ((mpz_ptr, mpq_srcptr)); #define mpq_get_d __gmpq_get_d __GMP_DECLSPEC double mpq_get_d __GMP_PROTO ((mpq_srcptr)) __GMP_ATTRIBUTE_PURE; #define mpq_get_str __gmpq_get_str __GMP_DECLSPEC char *mpq_get_str __GMP_PROTO ((char *, int, mpq_srcptr)); #define mpq_init __gmpq_init __GMP_DECLSPEC void mpq_init __GMP_PROTO ((mpq_ptr)); #define mpq_inp_str __gmpq_inp_str #ifdef _GMP_H_HAVE_FILE __GMP_DECLSPEC size_t mpq_inp_str __GMP_PROTO ((mpq_ptr, FILE *, int)); #endif #define mpq_inv __gmpq_inv __GMP_DECLSPEC void mpq_inv __GMP_PROTO ((mpq_ptr, mpq_srcptr)); #define mpq_mul __gmpq_mul __GMP_DECLSPEC void mpq_mul __GMP_PROTO ((mpq_ptr, mpq_srcptr, mpq_srcptr)); #define mpq_mul_2exp __gmpq_mul_2exp __GMP_DECLSPEC void mpq_mul_2exp __GMP_PROTO ((mpq_ptr, mpq_srcptr, unsigned long)); #define mpq_neg __gmpq_neg #if __GMP_INLINE_PROTOTYPES || defined (__GMP_FORCE_mpq_neg) __GMP_DECLSPEC void mpq_neg __GMP_PROTO ((mpq_ptr, mpq_srcptr)); #endif #define mpq_out_str __gmpq_out_str #ifdef _GMP_H_HAVE_FILE __GMP_DECLSPEC size_t mpq_out_str __GMP_PROTO ((FILE *, int, mpq_srcptr)); #endif #define mpq_set __gmpq_set __GMP_DECLSPEC void mpq_set __GMP_PROTO ((mpq_ptr, mpq_srcptr)); #define mpq_set_d __gmpq_set_d __GMP_DECLSPEC void mpq_set_d __GMP_PROTO ((mpq_ptr, double)); #define mpq_set_den __gmpq_set_den __GMP_DECLSPEC void mpq_set_den __GMP_PROTO ((mpq_ptr, mpz_srcptr)); #define mpq_set_f __gmpq_set_f __GMP_DECLSPEC void mpq_set_f __GMP_PROTO ((mpq_ptr, mpf_srcptr)); #define mpq_set_num __gmpq_set_num __GMP_DECLSPEC void mpq_set_num __GMP_PROTO ((mpq_ptr, mpz_srcptr)); #define mpq_set_si __gmpq_set_si __GMP_DECLSPEC void mpq_set_si __GMP_PROTO ((mpq_ptr, signed long int, unsigned long int)); #define mpq_set_str __gmpq_set_str __GMP_DECLSPEC int mpq_set_str __GMP_PROTO ((mpq_ptr, __gmp_const char *, int)); #define mpq_set_ui __gmpq_set_ui __GMP_DECLSPEC void mpq_set_ui __GMP_PROTO ((mpq_ptr, unsigned long int, unsigned long int)); #define mpq_set_z __gmpq_set_z __GMP_DECLSPEC void mpq_set_z __GMP_PROTO ((mpq_ptr, mpz_srcptr)); #define mpq_sub __gmpq_sub __GMP_DECLSPEC void mpq_sub __GMP_PROTO ((mpq_ptr, mpq_srcptr, mpq_srcptr)); #define mpq_swap __gmpq_swap __GMP_DECLSPEC void mpq_swap __GMP_PROTO ((mpq_ptr, mpq_ptr)) __GMP_NOTHROW; /**************** Float (i.e. F) routines. ****************/ #define mpf_abs __gmpf_abs __GMP_DECLSPEC void mpf_abs __GMP_PROTO ((mpf_ptr, mpf_srcptr)); #define mpf_add __gmpf_add __GMP_DECLSPEC void mpf_add __GMP_PROTO ((mpf_ptr, mpf_srcptr, mpf_srcptr)); #define mpf_add_ui __gmpf_add_ui __GMP_DECLSPEC void mpf_add_ui __GMP_PROTO ((mpf_ptr, mpf_srcptr, unsigned long int)); #define mpf_ceil __gmpf_ceil __GMP_DECLSPEC void mpf_ceil __GMP_PROTO ((mpf_ptr, mpf_srcptr)); #define mpf_clear __gmpf_clear __GMP_DECLSPEC void mpf_clear __GMP_PROTO ((mpf_ptr)); #define mpf_cmp __gmpf_cmp __GMP_DECLSPEC int mpf_cmp __GMP_PROTO ((mpf_srcptr, mpf_srcptr)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; #define mpf_cmp_d __gmpf_cmp_d __GMP_DECLSPEC int mpf_cmp_d __GMP_PROTO ((mpf_srcptr, double)) __GMP_ATTRIBUTE_PURE; #define mpf_cmp_si __gmpf_cmp_si __GMP_DECLSPEC int mpf_cmp_si __GMP_PROTO ((mpf_srcptr, signed long int)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; #define mpf_cmp_ui __gmpf_cmp_ui __GMP_DECLSPEC int mpf_cmp_ui __GMP_PROTO ((mpf_srcptr, unsigned long int)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; #define mpf_div __gmpf_div __GMP_DECLSPEC void mpf_div __GMP_PROTO ((mpf_ptr, mpf_srcptr, mpf_srcptr)); #define mpf_div_2exp __gmpf_div_2exp __GMP_DECLSPEC void mpf_div_2exp __GMP_PROTO ((mpf_ptr, mpf_srcptr, unsigned long int)); #define mpf_div_ui __gmpf_div_ui __GMP_DECLSPEC void mpf_div_ui __GMP_PROTO ((mpf_ptr, mpf_srcptr, unsigned long int)); #define mpf_dump __gmpf_dump __GMP_DECLSPEC void mpf_dump __GMP_PROTO ((mpf_srcptr)); #define mpf_eq __gmpf_eq __GMP_DECLSPEC int mpf_eq __GMP_PROTO ((mpf_srcptr, mpf_srcptr, unsigned long int)) __GMP_ATTRIBUTE_PURE; #define mpf_fits_sint_p __gmpf_fits_sint_p __GMP_DECLSPEC int mpf_fits_sint_p __GMP_PROTO ((mpf_srcptr)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; #define mpf_fits_slong_p __gmpf_fits_slong_p __GMP_DECLSPEC int mpf_fits_slong_p __GMP_PROTO ((mpf_srcptr)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; #define mpf_fits_sshort_p __gmpf_fits_sshort_p __GMP_DECLSPEC int mpf_fits_sshort_p __GMP_PROTO ((mpf_srcptr)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; #define mpf_fits_uint_p __gmpf_fits_uint_p __GMP_DECLSPEC int mpf_fits_uint_p __GMP_PROTO ((mpf_srcptr)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; #define mpf_fits_ulong_p __gmpf_fits_ulong_p __GMP_DECLSPEC int mpf_fits_ulong_p __GMP_PROTO ((mpf_srcptr)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; #define mpf_fits_ushort_p __gmpf_fits_ushort_p __GMP_DECLSPEC int mpf_fits_ushort_p __GMP_PROTO ((mpf_srcptr)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; #define mpf_floor __gmpf_floor __GMP_DECLSPEC void mpf_floor __GMP_PROTO ((mpf_ptr, mpf_srcptr)); #define mpf_get_d __gmpf_get_d __GMP_DECLSPEC double mpf_get_d __GMP_PROTO ((mpf_srcptr)) __GMP_ATTRIBUTE_PURE; #define mpf_get_d_2exp __gmpf_get_d_2exp __GMP_DECLSPEC double mpf_get_d_2exp __GMP_PROTO ((signed long int *, mpf_srcptr)); #define mpf_get_default_prec __gmpf_get_default_prec __GMP_DECLSPEC unsigned long int mpf_get_default_prec __GMP_PROTO ((void)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; #define mpf_get_prec __gmpf_get_prec __GMP_DECLSPEC unsigned long int mpf_get_prec __GMP_PROTO ((mpf_srcptr)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; #define mpf_get_si __gmpf_get_si __GMP_DECLSPEC long mpf_get_si __GMP_PROTO ((mpf_srcptr)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; #define mpf_get_str __gmpf_get_str __GMP_DECLSPEC char *mpf_get_str __GMP_PROTO ((char *, mp_exp_t *, int, size_t, mpf_srcptr)); #define mpf_get_ui __gmpf_get_ui __GMP_DECLSPEC unsigned long mpf_get_ui __GMP_PROTO ((mpf_srcptr)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; #define mpf_init __gmpf_init __GMP_DECLSPEC void mpf_init __GMP_PROTO ((mpf_ptr)); #define mpf_init2 __gmpf_init2 __GMP_DECLSPEC void mpf_init2 __GMP_PROTO ((mpf_ptr, unsigned long int)); #define mpf_init_set __gmpf_init_set __GMP_DECLSPEC void mpf_init_set __GMP_PROTO ((mpf_ptr, mpf_srcptr)); #define mpf_init_set_d __gmpf_init_set_d __GMP_DECLSPEC void mpf_init_set_d __GMP_PROTO ((mpf_ptr, double)); #define mpf_init_set_si __gmpf_init_set_si __GMP_DECLSPEC void mpf_init_set_si __GMP_PROTO ((mpf_ptr, signed long int)); #define mpf_init_set_str __gmpf_init_set_str __GMP_DECLSPEC int mpf_init_set_str __GMP_PROTO ((mpf_ptr, __gmp_const char *, int)); #define mpf_init_set_ui __gmpf_init_set_ui __GMP_DECLSPEC void mpf_init_set_ui __GMP_PROTO ((mpf_ptr, unsigned long int)); #define mpf_inp_str __gmpf_inp_str #ifdef _GMP_H_HAVE_FILE __GMP_DECLSPEC size_t mpf_inp_str __GMP_PROTO ((mpf_ptr, FILE *, int)); #endif #define mpf_integer_p __gmpf_integer_p __GMP_DECLSPEC int mpf_integer_p __GMP_PROTO ((mpf_srcptr)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; #define mpf_mul __gmpf_mul __GMP_DECLSPEC void mpf_mul __GMP_PROTO ((mpf_ptr, mpf_srcptr, mpf_srcptr)); #define mpf_mul_2exp __gmpf_mul_2exp __GMP_DECLSPEC void mpf_mul_2exp __GMP_PROTO ((mpf_ptr, mpf_srcptr, unsigned long int)); #define mpf_mul_ui __gmpf_mul_ui __GMP_DECLSPEC void mpf_mul_ui __GMP_PROTO ((mpf_ptr, mpf_srcptr, unsigned long int)); #define mpf_neg __gmpf_neg __GMP_DECLSPEC void mpf_neg __GMP_PROTO ((mpf_ptr, mpf_srcptr)); #define mpf_out_str __gmpf_out_str #ifdef _GMP_H_HAVE_FILE __GMP_DECLSPEC size_t mpf_out_str __GMP_PROTO ((FILE *, int, size_t, mpf_srcptr)); #endif #define mpf_pow_ui __gmpf_pow_ui __GMP_DECLSPEC void mpf_pow_ui __GMP_PROTO ((mpf_ptr, mpf_srcptr, unsigned long int)); #define mpf_random2 __gmpf_random2 __GMP_DECLSPEC void mpf_random2 __GMP_PROTO ((mpf_ptr, mp_size_t, mp_exp_t)); #define mpf_reldiff __gmpf_reldiff __GMP_DECLSPEC void mpf_reldiff __GMP_PROTO ((mpf_ptr, mpf_srcptr, mpf_srcptr)); #define mpf_set __gmpf_set __GMP_DECLSPEC void mpf_set __GMP_PROTO ((mpf_ptr, mpf_srcptr)); #define mpf_set_d __gmpf_set_d __GMP_DECLSPEC void mpf_set_d __GMP_PROTO ((mpf_ptr, double)); #define mpf_set_default_prec __gmpf_set_default_prec __GMP_DECLSPEC void mpf_set_default_prec __GMP_PROTO ((unsigned long int)) __GMP_NOTHROW; #define mpf_set_prec __gmpf_set_prec __GMP_DECLSPEC void mpf_set_prec __GMP_PROTO ((mpf_ptr, unsigned long int)); #define mpf_set_prec_raw __gmpf_set_prec_raw __GMP_DECLSPEC void mpf_set_prec_raw __GMP_PROTO ((mpf_ptr, unsigned long int)) __GMP_NOTHROW; #define mpf_set_q __gmpf_set_q __GMP_DECLSPEC void mpf_set_q __GMP_PROTO ((mpf_ptr, mpq_srcptr)); #define mpf_set_si __gmpf_set_si __GMP_DECLSPEC void mpf_set_si __GMP_PROTO ((mpf_ptr, signed long int)); #define mpf_set_str __gmpf_set_str __GMP_DECLSPEC int mpf_set_str __GMP_PROTO ((mpf_ptr, __gmp_const char *, int)); #define mpf_set_ui __gmpf_set_ui __GMP_DECLSPEC void mpf_set_ui __GMP_PROTO ((mpf_ptr, unsigned long int)); #define mpf_set_z __gmpf_set_z __GMP_DECLSPEC void mpf_set_z __GMP_PROTO ((mpf_ptr, mpz_srcptr)); #define mpf_size __gmpf_size __GMP_DECLSPEC size_t mpf_size __GMP_PROTO ((mpf_srcptr)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; #define mpf_sqrt __gmpf_sqrt __GMP_DECLSPEC void mpf_sqrt __GMP_PROTO ((mpf_ptr, mpf_srcptr)); #define mpf_sqrt_ui __gmpf_sqrt_ui __GMP_DECLSPEC void mpf_sqrt_ui __GMP_PROTO ((mpf_ptr, unsigned long int)); #define mpf_sub __gmpf_sub __GMP_DECLSPEC void mpf_sub __GMP_PROTO ((mpf_ptr, mpf_srcptr, mpf_srcptr)); #define mpf_sub_ui __gmpf_sub_ui __GMP_DECLSPEC void mpf_sub_ui __GMP_PROTO ((mpf_ptr, mpf_srcptr, unsigned long int)); #define mpf_swap __gmpf_swap __GMP_DECLSPEC void mpf_swap __GMP_PROTO ((mpf_ptr, mpf_ptr)) __GMP_NOTHROW; #define mpf_trunc __gmpf_trunc __GMP_DECLSPEC void mpf_trunc __GMP_PROTO ((mpf_ptr, mpf_srcptr)); #define mpf_ui_div __gmpf_ui_div __GMP_DECLSPEC void mpf_ui_div __GMP_PROTO ((mpf_ptr, unsigned long int, mpf_srcptr)); #define mpf_ui_sub __gmpf_ui_sub __GMP_DECLSPEC void mpf_ui_sub __GMP_PROTO ((mpf_ptr, unsigned long int, mpf_srcptr)); #define mpf_urandomb __gmpf_urandomb __GMP_DECLSPEC void mpf_urandomb __GMP_PROTO ((mpf_t, gmp_randstate_t, unsigned long int)); /************ Low level positive-integer (i.e. N) routines. ************/ /* This is ugly, but we need to make user calls reach the prefixed function. */ #define mpn_add __MPN(add) #if __GMP_INLINE_PROTOTYPES || defined (__GMP_FORCE_mpn_add) __GMP_DECLSPEC mp_limb_t mpn_add __GMP_PROTO ((mp_ptr, mp_srcptr, mp_size_t, mp_srcptr,mp_size_t)); #endif #define mpn_add_1 __MPN(add_1) #if __GMP_INLINE_PROTOTYPES || defined (__GMP_FORCE_mpn_add_1) __GMP_DECLSPEC mp_limb_t mpn_add_1 __GMP_PROTO ((mp_ptr, mp_srcptr, mp_size_t, mp_limb_t)) __GMP_NOTHROW; #endif #define mpn_add_n __MPN(add_n) __GMP_DECLSPEC mp_limb_t mpn_add_n __GMP_PROTO ((mp_ptr, mp_srcptr, mp_srcptr, mp_size_t)); #define mpn_addmul_1 __MPN(addmul_1) __GMP_DECLSPEC mp_limb_t mpn_addmul_1 __GMP_PROTO ((mp_ptr, mp_srcptr, mp_size_t, mp_limb_t)); #define mpn_bdivmod __MPN(bdivmod) __GMP_DECLSPEC mp_limb_t mpn_bdivmod __GMP_PROTO ((mp_ptr, mp_ptr, mp_size_t, mp_srcptr, mp_size_t, unsigned long int)); #define mpn_cmp __MPN(cmp) #if __GMP_INLINE_PROTOTYPES || defined (__GMP_FORCE_mpn_cmp) __GMP_DECLSPEC int mpn_cmp __GMP_PROTO ((mp_srcptr, mp_srcptr, mp_size_t)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; #endif #define mpn_divexact_by3(dst,src,size) \ mpn_divexact_by3c (dst, src, size, __GMP_CAST (mp_limb_t, 0)) #define mpn_divexact_by3c __MPN(divexact_by3c) __GMP_DECLSPEC mp_limb_t mpn_divexact_by3c __GMP_PROTO ((mp_ptr, mp_srcptr, mp_size_t, mp_limb_t)); #define mpn_divmod_1(qp,np,nsize,dlimb) \ mpn_divrem_1 (qp, __GMP_CAST (mp_size_t, 0), np, nsize, dlimb) #define mpn_divrem __MPN(divrem) __GMP_DECLSPEC mp_limb_t mpn_divrem __GMP_PROTO ((mp_ptr, mp_size_t, mp_ptr, mp_size_t, mp_srcptr, mp_size_t)); #define mpn_divrem_1 __MPN(divrem_1) __GMP_DECLSPEC mp_limb_t mpn_divrem_1 __GMP_PROTO ((mp_ptr, mp_size_t, mp_srcptr, mp_size_t, mp_limb_t)); #define mpn_divrem_2 __MPN(divrem_2) __GMP_DECLSPEC mp_limb_t mpn_divrem_2 __GMP_PROTO ((mp_ptr, mp_size_t, mp_ptr, mp_size_t, mp_srcptr)); #define mpn_gcd __MPN(gcd) __GMP_DECLSPEC mp_size_t mpn_gcd __GMP_PROTO ((mp_ptr, mp_ptr, mp_size_t, mp_ptr, mp_size_t)); #define mpn_gcd_1 __MPN(gcd_1) __GMP_DECLSPEC mp_limb_t mpn_gcd_1 __GMP_PROTO ((mp_srcptr, mp_size_t, mp_limb_t)) __GMP_ATTRIBUTE_PURE; #define mpn_gcdext __MPN(gcdext) __GMP_DECLSPEC mp_size_t mpn_gcdext __GMP_PROTO ((mp_ptr, mp_ptr, mp_size_t *, mp_ptr, mp_size_t, mp_ptr, mp_size_t)); #define mpn_get_str __MPN(get_str) __GMP_DECLSPEC size_t mpn_get_str __GMP_PROTO ((unsigned char *, int, mp_ptr, mp_size_t)); #define mpn_hamdist __MPN(hamdist) __GMP_DECLSPEC unsigned long int mpn_hamdist __GMP_PROTO ((mp_srcptr, mp_srcptr, mp_size_t)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; #define mpn_lshift __MPN(lshift) __GMP_DECLSPEC mp_limb_t mpn_lshift __GMP_PROTO ((mp_ptr, mp_srcptr, mp_size_t, unsigned int)); #define mpn_mod_1 __MPN(mod_1) __GMP_DECLSPEC mp_limb_t mpn_mod_1 __GMP_PROTO ((mp_srcptr, mp_size_t, mp_limb_t)) __GMP_ATTRIBUTE_PURE; #define mpn_mul __MPN(mul) __GMP_DECLSPEC mp_limb_t mpn_mul __GMP_PROTO ((mp_ptr, mp_srcptr, mp_size_t, mp_srcptr, mp_size_t)); #define mpn_mul_1 __MPN(mul_1) __GMP_DECLSPEC mp_limb_t mpn_mul_1 __GMP_PROTO ((mp_ptr, mp_srcptr, mp_size_t, mp_limb_t)); #define mpn_mul_n __MPN(mul_n) __GMP_DECLSPEC void mpn_mul_n __GMP_PROTO ((mp_ptr, mp_srcptr, mp_srcptr, mp_size_t)); #define mpn_perfect_square_p __MPN(perfect_square_p) __GMP_DECLSPEC int mpn_perfect_square_p __GMP_PROTO ((mp_srcptr, mp_size_t)) __GMP_ATTRIBUTE_PURE; #define mpn_popcount __MPN(popcount) __GMP_DECLSPEC unsigned long int mpn_popcount __GMP_PROTO ((mp_srcptr, mp_size_t)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; #define mpn_pow_1 __MPN(pow_1) __GMP_DECLSPEC mp_size_t mpn_pow_1 __GMP_PROTO ((mp_ptr, mp_srcptr, mp_size_t, mp_limb_t, mp_ptr)); /* undocumented now, but retained here for upward compatibility */ #define mpn_preinv_mod_1 __MPN(preinv_mod_1) __GMP_DECLSPEC mp_limb_t mpn_preinv_mod_1 __GMP_PROTO ((mp_srcptr, mp_size_t, mp_limb_t, mp_limb_t)) __GMP_ATTRIBUTE_PURE; #define mpn_random __MPN(random) __GMP_DECLSPEC void mpn_random __GMP_PROTO ((mp_ptr, mp_size_t)); #define mpn_random2 __MPN(random2) __GMP_DECLSPEC void mpn_random2 __GMP_PROTO ((mp_ptr, mp_size_t)); #define mpn_rshift __MPN(rshift) __GMP_DECLSPEC mp_limb_t mpn_rshift __GMP_PROTO ((mp_ptr, mp_srcptr, mp_size_t, unsigned int)); #define mpn_scan0 __MPN(scan0) __GMP_DECLSPEC unsigned long int mpn_scan0 __GMP_PROTO ((mp_srcptr, unsigned long int)) __GMP_ATTRIBUTE_PURE; #define mpn_scan1 __MPN(scan1) __GMP_DECLSPEC unsigned long int mpn_scan1 __GMP_PROTO ((mp_srcptr, unsigned long int)) __GMP_ATTRIBUTE_PURE; #define mpn_set_str __MPN(set_str) __GMP_DECLSPEC mp_size_t mpn_set_str __GMP_PROTO ((mp_ptr, __gmp_const unsigned char *, size_t, int)); #define mpn_sqrtrem __MPN(sqrtrem) __GMP_DECLSPEC mp_size_t mpn_sqrtrem __GMP_PROTO ((mp_ptr, mp_ptr, mp_srcptr, mp_size_t)); #define mpn_sub __MPN(sub) #if __GMP_INLINE_PROTOTYPES || defined (__GMP_FORCE_mpn_sub) __GMP_DECLSPEC mp_limb_t mpn_sub __GMP_PROTO ((mp_ptr, mp_srcptr, mp_size_t, mp_srcptr,mp_size_t)); #endif #define mpn_sub_1 __MPN(sub_1) #if __GMP_INLINE_PROTOTYPES || defined (__GMP_FORCE_mpn_sub_1) __GMP_DECLSPEC mp_limb_t mpn_sub_1 __GMP_PROTO ((mp_ptr, mp_srcptr, mp_size_t, mp_limb_t)) __GMP_NOTHROW; #endif #define mpn_sub_n __MPN(sub_n) __GMP_DECLSPEC mp_limb_t mpn_sub_n __GMP_PROTO ((mp_ptr, mp_srcptr, mp_srcptr, mp_size_t)); #define mpn_submul_1 __MPN(submul_1) __GMP_DECLSPEC mp_limb_t mpn_submul_1 __GMP_PROTO ((mp_ptr, mp_srcptr, mp_size_t, mp_limb_t)); #define mpn_tdiv_qr __MPN(tdiv_qr) __GMP_DECLSPEC void mpn_tdiv_qr __GMP_PROTO ((mp_ptr, mp_ptr, mp_size_t, mp_srcptr, mp_size_t, mp_srcptr, mp_size_t)); /**************** mpz inlines ****************/ /* The following are provided as inlines where possible, but always exist as library functions too, for binary compatibility. Within gmp itself this inlining generally isn't relied on, since it doesn't get done for all compilers, whereas if something is worth inlining then it's worth arranging always. There are two styles of inlining here. When the same bit of code is wanted for the inline as for the library version, then __GMP_FORCE_foo arranges for that code to be emitted and the __GMP_EXTERN_INLINE directive suppressed, eg. mpz_fits_uint_p. When a different bit of code is wanted for the inline than for the library version, then __GMP_FORCE_foo arranges the inline to be suppressed, eg. mpz_abs. */ #if defined (__GMP_EXTERN_INLINE) && ! defined (__GMP_FORCE_mpz_abs) __GMP_EXTERN_INLINE void mpz_abs (mpz_ptr __gmp_w, mpz_srcptr __gmp_u) { if (__gmp_w != __gmp_u) mpz_set (__gmp_w, __gmp_u); __gmp_w->_mp_size = __GMP_ABS (__gmp_w->_mp_size); } #endif #if GMP_NAIL_BITS == 0 #define __GMPZ_FITS_UTYPE_P(z,maxval) \ mp_size_t __gmp_n = z->_mp_size; \ mp_ptr __gmp_p = z->_mp_d; \ return (__gmp_n == 0 || (__gmp_n == 1 && __gmp_p[0] <= maxval)); #else #define __GMPZ_FITS_UTYPE_P(z,maxval) \ mp_size_t __gmp_n = z->_mp_size; \ mp_ptr __gmp_p = z->_mp_d; \ return (__gmp_n == 0 || (__gmp_n == 1 && __gmp_p[0] <= maxval) \ || (__gmp_n == 2 && __gmp_p[1] <= ((mp_limb_t) maxval >> GMP_NUMB_BITS))); #endif #if defined (__GMP_EXTERN_INLINE) || defined (__GMP_FORCE_mpz_fits_uint_p) #if ! defined (__GMP_FORCE_mpz_fits_uint_p) __GMP_EXTERN_INLINE #endif int mpz_fits_uint_p (mpz_srcptr __gmp_z) __GMP_NOTHROW { __GMPZ_FITS_UTYPE_P (__gmp_z, __GMP_UINT_MAX); } #endif #if defined (__GMP_EXTERN_INLINE) || defined (__GMP_FORCE_mpz_fits_ulong_p) #if ! defined (__GMP_FORCE_mpz_fits_ulong_p) __GMP_EXTERN_INLINE #endif int mpz_fits_ulong_p (mpz_srcptr __gmp_z) __GMP_NOTHROW { __GMPZ_FITS_UTYPE_P (__gmp_z, __GMP_ULONG_MAX); } #endif #if defined (__GMP_EXTERN_INLINE) || defined (__GMP_FORCE_mpz_fits_ushort_p) #if ! defined (__GMP_FORCE_mpz_fits_ushort_p) __GMP_EXTERN_INLINE #endif int mpz_fits_ushort_p (mpz_srcptr __gmp_z) __GMP_NOTHROW { __GMPZ_FITS_UTYPE_P (__gmp_z, __GMP_USHRT_MAX); } #endif #if defined (__GMP_EXTERN_INLINE) || defined (__GMP_FORCE_mpz_get_ui) #if ! defined (__GMP_FORCE_mpz_get_ui) __GMP_EXTERN_INLINE #endif unsigned long mpz_get_ui (mpz_srcptr __gmp_z) __GMP_NOTHROW { mp_ptr __gmp_p = __gmp_z->_mp_d; mp_size_t __gmp_n = __gmp_z->_mp_size; mp_limb_t __gmp_l = __gmp_p[0]; /* This is a "#if" rather than a plain "if" so as to avoid gcc warnings about "<< GMP_NUMB_BITS" exceeding the type size, and to avoid Borland C++ 6.0 warnings about condition always true for something like "__GMP_ULONG_MAX < GMP_NUMB_MASK". */ #if GMP_NAIL_BITS == 0 || defined (_LONG_LONG_LIMB) /* limb==long and no nails, or limb==longlong, one limb is enough */ return (__gmp_n != 0 ? __gmp_l : 0); #else /* limb==long and nails, need two limbs when available */ __gmp_n = __GMP_ABS (__gmp_n); if (__gmp_n <= 1) return (__gmp_n != 0 ? __gmp_l : 0); else return __gmp_l + (__gmp_p[1] << GMP_NUMB_BITS); #endif } #endif #if defined (__GMP_EXTERN_INLINE) || defined (__GMP_FORCE_mpz_getlimbn) #if ! defined (__GMP_FORCE_mpz_getlimbn) __GMP_EXTERN_INLINE #endif mp_limb_t mpz_getlimbn (mpz_srcptr __gmp_z, mp_size_t __gmp_n) __GMP_NOTHROW { mp_limb_t __gmp_result = 0; if (__GMP_LIKELY (__gmp_n >= 0 && __gmp_n < __GMP_ABS (__gmp_z->_mp_size))) __gmp_result = __gmp_z->_mp_d[__gmp_n]; return __gmp_result; } #endif #if defined (__GMP_EXTERN_INLINE) && ! defined (__GMP_FORCE_mpz_neg) __GMP_EXTERN_INLINE void mpz_neg (mpz_ptr __gmp_w, mpz_srcptr __gmp_u) { if (__gmp_w != __gmp_u) mpz_set (__gmp_w, __gmp_u); __gmp_w->_mp_size = - __gmp_w->_mp_size; } #endif #if defined (__GMP_EXTERN_INLINE) || defined (__GMP_FORCE_mpz_perfect_square_p) #if ! defined (__GMP_FORCE_mpz_perfect_square_p) __GMP_EXTERN_INLINE #endif int mpz_perfect_square_p (mpz_srcptr __gmp_a) { mp_size_t __gmp_asize; int __gmp_result; __gmp_asize = __gmp_a->_mp_size; __gmp_result = (__gmp_asize >= 0); /* zero is a square, negatives are not */ if (__GMP_LIKELY (__gmp_asize > 0)) __gmp_result = mpn_perfect_square_p (__gmp_a->_mp_d, __gmp_asize); return __gmp_result; } #endif #if defined (__GMP_EXTERN_INLINE) || defined (__GMP_FORCE_mpz_popcount) #if ! defined (__GMP_FORCE_mpz_popcount) __GMP_EXTERN_INLINE #endif unsigned long mpz_popcount (mpz_srcptr __gmp_u) __GMP_NOTHROW { mp_size_t __gmp_usize; unsigned long __gmp_result; __gmp_usize = __gmp_u->_mp_size; __gmp_result = (__gmp_usize < 0 ? __GMP_ULONG_MAX : 0); if (__GMP_LIKELY (__gmp_usize > 0)) __gmp_result = mpn_popcount (__gmp_u->_mp_d, __gmp_usize); return __gmp_result; } #endif #if defined (__GMP_EXTERN_INLINE) || defined (__GMP_FORCE_mpz_set_q) #if ! defined (__GMP_FORCE_mpz_set_q) __GMP_EXTERN_INLINE #endif void mpz_set_q (mpz_ptr __gmp_w, mpq_srcptr __gmp_u) { mpz_tdiv_q (__gmp_w, mpq_numref (__gmp_u), mpq_denref (__gmp_u)); } #endif #if defined (__GMP_EXTERN_INLINE) || defined (__GMP_FORCE_mpz_size) #if ! defined (__GMP_FORCE_mpz_size) __GMP_EXTERN_INLINE #endif size_t mpz_size (mpz_srcptr __gmp_z) __GMP_NOTHROW { return __GMP_ABS (__gmp_z->_mp_size); } #endif /**************** mpq inlines ****************/ #if defined (__GMP_EXTERN_INLINE) && ! defined (__GMP_FORCE_mpq_abs) __GMP_EXTERN_INLINE void mpq_abs (mpq_ptr __gmp_w, mpq_srcptr __gmp_u) { if (__gmp_w != __gmp_u) mpq_set (__gmp_w, __gmp_u); __gmp_w->_mp_num._mp_size = __GMP_ABS (__gmp_w->_mp_num._mp_size); } #endif #if defined (__GMP_EXTERN_INLINE) && ! defined (__GMP_FORCE_mpq_neg) __GMP_EXTERN_INLINE void mpq_neg (mpq_ptr __gmp_w, mpq_srcptr __gmp_u) { if (__gmp_w != __gmp_u) mpq_set (__gmp_w, __gmp_u); __gmp_w->_mp_num._mp_size = - __gmp_w->_mp_num._mp_size; } #endif /**************** mpn inlines ****************/ /* The comments with __GMPN_ADD_1 below apply here too. The test for FUNCTION returning 0 should predict well. If it's assumed {yp,ysize} will usually have a random number of bits then the high limb won't be full and a carry out will occur a good deal less than 50% of the time. ysize==0 isn't a documented feature, but is used internally in a few places. Producing cout last stops it using up a register during the main part of the calculation, though gcc (as of 3.0) on an "if (mpn_add (...))" doesn't seem able to move the true and false legs of the conditional up to the two places cout is generated. */ #define __GMPN_AORS(cout, wp, xp, xsize, yp, ysize, FUNCTION, TEST) \ do { \ mp_size_t __gmp_i; \ mp_limb_t __gmp_x; \ \ /* ASSERT ((ysize) >= 0); */ \ /* ASSERT ((xsize) >= (ysize)); */ \ /* ASSERT (MPN_SAME_OR_SEPARATE2_P (wp, xsize, xp, xsize)); */ \ /* ASSERT (MPN_SAME_OR_SEPARATE2_P (wp, xsize, yp, ysize)); */ \ \ __gmp_i = (ysize); \ if (__gmp_i != 0) \ { \ if (FUNCTION (wp, xp, yp, __gmp_i)) \ { \ do \ { \ if (__gmp_i >= (xsize)) \ { \ (cout) = 1; \ goto __gmp_done; \ } \ __gmp_x = (xp)[__gmp_i]; \ } \ while (TEST); \ } \ } \ if ((wp) != (xp)) \ __GMPN_COPY_REST (wp, xp, xsize, __gmp_i); \ (cout) = 0; \ __gmp_done: \ ; \ } while (0) #define __GMPN_ADD(cout, wp, xp, xsize, yp, ysize) \ __GMPN_AORS (cout, wp, xp, xsize, yp, ysize, mpn_add_n, \ (((wp)[__gmp_i++] = (__gmp_x + 1) & GMP_NUMB_MASK) == 0)) #define __GMPN_SUB(cout, wp, xp, xsize, yp, ysize) \ __GMPN_AORS (cout, wp, xp, xsize, yp, ysize, mpn_sub_n, \ (((wp)[__gmp_i++] = (__gmp_x - 1) & GMP_NUMB_MASK), __gmp_x == 0)) /* The use of __gmp_i indexing is designed to ensure a compile time src==dst remains nice and clear to the compiler, so that __GMPN_COPY_REST can disappear, and the load/add/store gets a chance to become a read-modify-write on CISC CPUs. Alternatives: Using a pair of pointers instead of indexing would be possible, but gcc isn't able to recognise compile-time src==dst in that case, even when the pointers are incremented more or less together. Other compilers would very likely have similar difficulty. gcc could use "if (__builtin_constant_p(src==dst) && src==dst)" or similar to detect a compile-time src==dst. This works nicely on gcc 2.95.x, it's not good on gcc 3.0 where __builtin_constant_p(p==p) seems to be always false, for a pointer p. But the current code form seems good enough for src==dst anyway. gcc on x86 as usual doesn't give particularly good flags handling for the carry/borrow detection. It's tempting to want some multi instruction asm blocks to help it, and this was tried, but in truth there's only a few instructions to save and any gain is all too easily lost by register juggling setting up for the asm. */ #if GMP_NAIL_BITS == 0 #define __GMPN_AORS_1(cout, dst, src, n, v, OP, CB) \ do { \ mp_size_t __gmp_i; \ mp_limb_t __gmp_x, __gmp_r; \ \ /* ASSERT ((n) >= 1); */ \ /* ASSERT (MPN_SAME_OR_SEPARATE_P (dst, src, n)); */ \ \ __gmp_x = (src)[0]; \ __gmp_r = __gmp_x OP (v); \ (dst)[0] = __gmp_r; \ if (CB (__gmp_r, __gmp_x, (v))) \ { \ (cout) = 1; \ for (__gmp_i = 1; __gmp_i < (n);) \ { \ __gmp_x = (src)[__gmp_i]; \ __gmp_r = __gmp_x OP 1; \ (dst)[__gmp_i] = __gmp_r; \ ++__gmp_i; \ if (!CB (__gmp_r, __gmp_x, 1)) \ { \ if ((src) != (dst)) \ __GMPN_COPY_REST (dst, src, n, __gmp_i); \ (cout) = 0; \ break; \ } \ } \ } \ else \ { \ if ((src) != (dst)) \ __GMPN_COPY_REST (dst, src, n, 1); \ (cout) = 0; \ } \ } while (0) #endif #if GMP_NAIL_BITS >= 1 #define __GMPN_AORS_1(cout, dst, src, n, v, OP, CB) \ do { \ mp_size_t __gmp_i; \ mp_limb_t __gmp_x, __gmp_r; \ \ /* ASSERT ((n) >= 1); */ \ /* ASSERT (MPN_SAME_OR_SEPARATE_P (dst, src, n)); */ \ \ __gmp_x = (src)[0]; \ __gmp_r = __gmp_x OP (v); \ (dst)[0] = __gmp_r & GMP_NUMB_MASK; \ if (__gmp_r >> GMP_NUMB_BITS != 0) \ { \ (cout) = 1; \ for (__gmp_i = 1; __gmp_i < (n);) \ { \ __gmp_x = (src)[__gmp_i]; \ __gmp_r = __gmp_x OP 1; \ (dst)[__gmp_i] = __gmp_r & GMP_NUMB_MASK; \ ++__gmp_i; \ if (__gmp_r >> GMP_NUMB_BITS == 0) \ { \ if ((src) != (dst)) \ __GMPN_COPY_REST (dst, src, n, __gmp_i); \ (cout) = 0; \ break; \ } \ } \ } \ else \ { \ if ((src) != (dst)) \ __GMPN_COPY_REST (dst, src, n, 1); \ (cout) = 0; \ } \ } while (0) #endif #define __GMPN_ADDCB(r,x,y) ((r) < (y)) #define __GMPN_SUBCB(r,x,y) ((x) < (y)) #define __GMPN_ADD_1(cout, dst, src, n, v) \ __GMPN_AORS_1(cout, dst, src, n, v, +, __GMPN_ADDCB) #define __GMPN_SUB_1(cout, dst, src, n, v) \ __GMPN_AORS_1(cout, dst, src, n, v, -, __GMPN_SUBCB) /* Compare {xp,size} and {yp,size}, setting "result" to positive, zero or negative. size==0 is allowed. On random data usually only one limb will need to be examined to get a result, so it's worth having it inline. */ #define __GMPN_CMP(result, xp, yp, size) \ do { \ mp_size_t __gmp_i; \ mp_limb_t __gmp_x, __gmp_y; \ \ /* ASSERT ((size) >= 0); */ \ \ (result) = 0; \ __gmp_i = (size); \ while (--__gmp_i >= 0) \ { \ __gmp_x = (xp)[__gmp_i]; \ __gmp_y = (yp)[__gmp_i]; \ if (__gmp_x != __gmp_y) \ { \ /* Cannot use __gmp_x - __gmp_y, may overflow an "int" */ \ (result) = (__gmp_x > __gmp_y ? 1 : -1); \ break; \ } \ } \ } while (0) #if defined (__GMPN_COPY) && ! defined (__GMPN_COPY_REST) #define __GMPN_COPY_REST(dst, src, size, start) \ do { \ /* ASSERT ((start) >= 0); */ \ /* ASSERT ((start) <= (size)); */ \ __GMPN_COPY ((dst)+(start), (src)+(start), (size)-(start)); \ } while (0) #endif /* Copy {src,size} to {dst,size}, starting at "start". This is designed to keep the indexing dst[j] and src[j] nice and simple for __GMPN_ADD_1, __GMPN_ADD, etc. */ #if ! defined (__GMPN_COPY_REST) #define __GMPN_COPY_REST(dst, src, size, start) \ do { \ mp_size_t __gmp_j; \ /* ASSERT ((size) >= 0); */ \ /* ASSERT ((start) >= 0); */ \ /* ASSERT ((start) <= (size)); */ \ /* ASSERT (MPN_SAME_OR_SEPARATE_P (dst, src, size)); */ \ __GMP_CRAY_Pragma ("_CRI ivdep"); \ for (__gmp_j = (start); __gmp_j < (size); __gmp_j++) \ (dst)[__gmp_j] = (src)[__gmp_j]; \ } while (0) #endif /* Enhancement: Use some of the smarter code from gmp-impl.h. Maybe use mpn_copyi if there's a native version, and if we don't mind demanding binary compatibility for it (on targets which use it). */ #if ! defined (__GMPN_COPY) #define __GMPN_COPY(dst, src, size) __GMPN_COPY_REST (dst, src, size, 0) #endif #if defined (__GMP_EXTERN_INLINE) || defined (__GMP_FORCE_mpn_add) #if ! defined (__GMP_FORCE_mpn_add) __GMP_EXTERN_INLINE #endif mp_limb_t mpn_add (mp_ptr __gmp_wp, mp_srcptr __gmp_xp, mp_size_t __gmp_xsize, mp_srcptr __gmp_yp, mp_size_t __gmp_ysize) { mp_limb_t __gmp_c; __GMPN_ADD (__gmp_c, __gmp_wp, __gmp_xp, __gmp_xsize, __gmp_yp, __gmp_ysize); return __gmp_c; } #endif #if defined (__GMP_EXTERN_INLINE) || defined (__GMP_FORCE_mpn_add_1) #if ! defined (__GMP_FORCE_mpn_add_1) __GMP_EXTERN_INLINE #endif mp_limb_t mpn_add_1 (mp_ptr __gmp_dst, mp_srcptr __gmp_src, mp_size_t __gmp_size, mp_limb_t __gmp_n) __GMP_NOTHROW { mp_limb_t __gmp_c; __GMPN_ADD_1 (__gmp_c, __gmp_dst, __gmp_src, __gmp_size, __gmp_n); return __gmp_c; } #endif #if defined (__GMP_EXTERN_INLINE) || defined (__GMP_FORCE_mpn_cmp) #if ! defined (__GMP_FORCE_mpn_cmp) __GMP_EXTERN_INLINE #endif int mpn_cmp (mp_srcptr __gmp_xp, mp_srcptr __gmp_yp, mp_size_t __gmp_size) __GMP_NOTHROW { int __gmp_result; __GMPN_CMP (__gmp_result, __gmp_xp, __gmp_yp, __gmp_size); return __gmp_result; } #endif #if defined (__GMP_EXTERN_INLINE) || defined (__GMP_FORCE_mpn_sub) #if ! defined (__GMP_FORCE_mpn_sub) __GMP_EXTERN_INLINE #endif mp_limb_t mpn_sub (mp_ptr __gmp_wp, mp_srcptr __gmp_xp, mp_size_t __gmp_xsize, mp_srcptr __gmp_yp, mp_size_t __gmp_ysize) { mp_limb_t __gmp_c; __GMPN_SUB (__gmp_c, __gmp_wp, __gmp_xp, __gmp_xsize, __gmp_yp, __gmp_ysize); return __gmp_c; } #endif #if defined (__GMP_EXTERN_INLINE) || defined (__GMP_FORCE_mpn_sub_1) #if ! defined (__GMP_FORCE_mpn_sub_1) __GMP_EXTERN_INLINE #endif mp_limb_t mpn_sub_1 (mp_ptr __gmp_dst, mp_srcptr __gmp_src, mp_size_t __gmp_size, mp_limb_t __gmp_n) __GMP_NOTHROW { mp_limb_t __gmp_c; __GMPN_SUB_1 (__gmp_c, __gmp_dst, __gmp_src, __gmp_size, __gmp_n); return __gmp_c; } #endif #if defined (__cplusplus) } #endif /* Allow faster testing for negative, zero, and positive. */ #define mpz_sgn(Z) ((Z)->_mp_size < 0 ? -1 : (Z)->_mp_size > 0) #define mpf_sgn(F) ((F)->_mp_size < 0 ? -1 : (F)->_mp_size > 0) #define mpq_sgn(Q) ((Q)->_mp_num._mp_size < 0 ? -1 : (Q)->_mp_num._mp_size > 0) /* When using GCC, optimize certain common comparisons. */ #if defined (__GNUC__) #define mpz_cmp_ui(Z,UI) \ (__builtin_constant_p (UI) && (UI) == 0 \ ? mpz_sgn (Z) : _mpz_cmp_ui (Z,UI)) #define mpz_cmp_si(Z,SI) \ (__builtin_constant_p (SI) && (SI) == 0 ? mpz_sgn (Z) \ : __builtin_constant_p (SI) && (SI) > 0 \ ? _mpz_cmp_ui (Z, __GMP_CAST (unsigned long int, SI)) \ : _mpz_cmp_si (Z,SI)) #define mpq_cmp_ui(Q,NUI,DUI) \ (__builtin_constant_p (NUI) && (NUI) == 0 \ ? mpq_sgn (Q) : _mpq_cmp_ui (Q,NUI,DUI)) #define mpq_cmp_si(q,n,d) \ (__builtin_constant_p ((n) >= 0) && (n) >= 0 \ ? mpq_cmp_ui (q, __GMP_CAST (unsigned long, n), d) \ : _mpq_cmp_si (q, n, d)) #else #define mpz_cmp_ui(Z,UI) _mpz_cmp_ui (Z,UI) #define mpz_cmp_si(Z,UI) _mpz_cmp_si (Z,UI) #define mpq_cmp_ui(Q,NUI,DUI) _mpq_cmp_ui (Q,NUI,DUI) #define mpq_cmp_si(q,n,d) _mpq_cmp_si(q,n,d) #endif /* Using "&" rather than "&&" means these can come out branch-free. Every mpz_t has at least one limb allocated, so fetching the low limb is always allowed. */ #define mpz_odd_p(z) (((z)->_mp_size != 0) & __GMP_CAST (int, (z)->_mp_d[0])) #define mpz_even_p(z) (! mpz_odd_p (z)) /**************** C++ routines ****************/ #ifdef __cplusplus __GMP_DECLSPEC_XX std::ostream& operator<< (std::ostream &, mpz_srcptr); __GMP_DECLSPEC_XX std::ostream& operator<< (std::ostream &, mpq_srcptr); __GMP_DECLSPEC_XX std::ostream& operator<< (std::ostream &, mpf_srcptr); __GMP_DECLSPEC_XX std::istream& operator>> (std::istream &, mpz_ptr); __GMP_DECLSPEC_XX std::istream& operator>> (std::istream &, mpq_ptr); __GMP_DECLSPEC_XX std::istream& operator>> (std::istream &, mpf_ptr); #endif /* Source-level compatibility with GMP 2 and earlier. */ #define mpn_divmod(qp,np,nsize,dp,dsize) \ mpn_divrem (qp, __GMP_CAST (mp_size_t, 0), np, nsize, dp, dsize) /* Source-level compatibility with GMP 1. */ #define mpz_mdiv mpz_fdiv_q #define mpz_mdivmod mpz_fdiv_qr #define mpz_mmod mpz_fdiv_r #define mpz_mdiv_ui mpz_fdiv_q_ui #define mpz_mdivmod_ui(q,r,n,d) \ (((r) == 0) ? mpz_fdiv_q_ui (q,n,d) : mpz_fdiv_qr_ui (q,r,n,d)) #define mpz_mmod_ui(r,n,d) \ (((r) == 0) ? mpz_fdiv_ui (n,d) : mpz_fdiv_r_ui (r,n,d)) /* Useful synonyms, but not quite compatible with GMP 1. */ #define mpz_div mpz_fdiv_q #define mpz_divmod mpz_fdiv_qr #define mpz_div_ui mpz_fdiv_q_ui #define mpz_divmod_ui mpz_fdiv_qr_ui #define mpz_div_2exp mpz_fdiv_q_2exp #define mpz_mod_2exp mpz_fdiv_r_2exp enum { GMP_ERROR_NONE = 0, GMP_ERROR_UNSUPPORTED_ARGUMENT = 1, GMP_ERROR_DIVISION_BY_ZERO = 2, GMP_ERROR_SQRT_OF_NEGATIVE = 4, GMP_ERROR_INVALID_ARGUMENT = 8 }; /* Major version number is the value of __GNU_MP__ too, above and in mp.h. */ #define __GNU_MP_VERSION 4 #define __GNU_MP_VERSION_MINOR 2 #define __GNU_MP_VERSION_PATCHLEVEL 0 #define __GMP_H__ #endif /* __GMP_H__ */ ecl-16.1.2/msvc/gmp/build.vc8/gmp.ncb000077500000000000000000071457731266352375300172130ustar00rootroot00000000000000Microsoft C/C++ MSF 7.00 DS3H&1рќџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ Dџџ DџџF @џџ%| @џџ @џџ ”ШžШЉШДШТШаШмШЩ7Щ+'€7† 9;PRehjp%3=?CEJTVZ\lnrtˆ‘’’”–˜€'?@\]no№CTr йBBSSqq)€*Ž‘Z%33=?@@Z\]]wˆŽ’’”––˜˜ššb%%Š(EFVWtuК=ZlwS%%ˆЃ<<YYkkћEVt’~[“•—™›<$'(el%3=?CEJTVZ\lnrtˆ’’”t%)*Š”:)999;===???@@CCCEEEFFPPPRTTTVVVWWZZZ\\\]]hhhjllnnrrrtttuuw<†…'7==@@NZZ]]flloo{Х?\n’FWuF%”–˜š^%CEFFJJTVWWrtuuˆ”–˜šš~%9;PRhjŠŒŽ‘’’”–˜šF ‰’“”•–—˜™š›V’”–˜š(8CCFFOTTWWgrruu{Ÿ;RjЯ@]oelnoow/ƒOŽ‘˜*;=?@CEFRTVWZ\]jlnortuwHŒA†Œ”.1ŸhГEхh uИМ/IЂ*!Ђ"У'8 Dџџ Dџџb DџџŸ @џџPі… @џџ''m @џџ $$”Ш<ЩFЩTЩaЩnЩzЩАЩАЩ"WВКР Uz{УХЩсуч@–тщяpЖЙQZbfmo{‹–ЇЖЗЦЫбкфщяёfbQkmno{ФЫбR ЖЗИРХХЫеоуущѓ’ХуSPГ Q\lzІПУнсЛTxxxz”””СССУЯЯЯпппсэээУ,Vlmop{{|‚…‘––—šЉ­ИРФФЧЫЫЬббвеоттхщщъяя№ѓуblpz|‚‘—ІЉПУЧЬвнсхъ№<OQUVkŠйtPQSTЌP\dn{}ƒ’–˜ЊФШЫЭбгтцщыяёЬ\uГЛwД4‹к„Роm#$u…&'ГЛНUІЇЉПРХЩЫноучщХXYZ\%–бя~ S^_dquЋЌГЛЖQY\^hlrxЄІЎНПСлнпŸPЏPX\^”Яэ/ Š‹–йкфщя Dџџ Dџџb DџџГ @џџ@Д  @џџ++”Ш<ЩFЩВЩМЩЩЩжЩАЩ&чGTX[]||~……†œžР!FVX[[]]^_x|~€†‹–œœžžŸ ЉЉЋЋЌ­Б@‹ *+dРANNORUVnp|~“АБ№IdeŠ0_vx€† ­ЩDaГсF“–ЉЋYbBjv‚‹™Ї’ъHf‹OPS@AЛEhhhm‚ЇУkxy|‹Ž––ЂЃЉЌу ZZ{{Ž››ЈЈГ@УAKNNORdhћMc•Є<?DFGHjkt@AEЌ@NN‚Ї4f„^ŸЌфGSXX[^frxy‹ЂЃ NНFUXX[[^^r|…‹––œœŸŸЉЉЌЌАХKLMN%[œЉЦBMPST>dN|Џ@LNdhmj Dџџ DџџФ DџџФ Dџџ$$~Ф @џџ""kФ @џџ!!} АЩkФ!~Ф"Т Dџџp Dџџ??WР Dџџ qxјП @ wwнП @ vvТП @ uuЃП @ tt”П @ sshРAџџ WWhРAџџ VVhРAџџUUtРAџџTTtРAџџSStРAџџRR€Р @@џџ#"Р @@џџ* ˜Р @@џџ/ЃР @@џџ5ѓћАР @@џџ<цюБ @@џџ@ѓљЎЏ @@џџDщя­ @@џџGмтvЌ @@џџKбзЋЊ @@џџNПЬeЊ @@џџQ­КБЉ @@џџUЂЈ>І @@џџY•ž І @@џџ\yЅ @@џџ_ntкЄ @@џџbcišЄ @@џџeX^Qž @@џџi@FЛР@џџr,,ЪР@џџx))кР@џџ~&&чР@џџ„іР@џџŠС@џџŽС@џџ’С@џџ˜  -С@џџœ  <С@џџ JС@џџІ^С@џџ­kС@џџБ§§{С@џџЕњњ“С@џџЛїї С@џџСєє­С@џџШёёИС@џџЭююХС@џџгыыгС@џџишштС@џџоххёС@џџчттџС@џџьпп Т@џџѓммТ@џџњйй'Т@џџжж7Т@џџ ггEТ@џџЭЭZТ@џџТТiТ@џџППyТ@џџ#ММ‰Й@џџ(ЊЊnЙ@џџ-ЇЇUЙ@џџ2ЄЄ=Й@џџ6ЁЁ'Й@џџ:žžЙ@џџ?››њИ@џџD˜˜уИ@џџH••ЫИ@џџL’’ЖИ@џџO И@џџSŒŒˆИ@џџW‰‰nИ@џџ\††TИ@џџ`ƒƒ<И@џџd€€И@џџh}}§З@џџlzzиЗ@џџowwЖЗ@џџsttЁЗ@џџwqqŠЗ@џџ|nnoЗ@џџkkUЗ@џџ†hh;З@џџŒdd$З@џџ``З@џџ•]]ѓЖ@џџšZZлЖ@џџŸWWТЖ@џџЂTTЅЖ@џџЇPP†Ж@џџЋLLbЖ@џџАII>Ж@џџДFFЖ@џџИCC§Е@џџМ@@уЕ@џџР==ЭЕ@џџУ::ЖЕ@џџЦ77œЕ@џџЭ44‚Е@џџа11gЕ@џџг..BЕ@џџе++Е@џџй((џД@џџм%%шД@џџр""ЩД@џџуЃД@џџцД@џџщZД@џџь4Д@џџяД@џџђіГ@џџї  уГ@џџњ  ЬГ@џџџБГ@џџ™Г@џџ ƒГ@џџ ўўjГ@џџћћRГ@џџјј=Г@џџѕѕ(Г@џџђђГ@џџ яяћВ@џџ%ээхВ@џџ*ъъвВ@џџ.ччОВ@џџ2ссЊВ@џџ7оо•В@џџ;лл}В@џџ@ииcВ@џџEееIВ@џџJвв/В@џџNЯЯВ@џџRЬЬ§Б@џџVЩЩфБ@џџZЦЦЯБ@џџ^УУИБ@џџcППuБ@џџhЖЖ]Б@џџmГГJБ@џџqАА3Б@џџvЌЌБ@џџyЈЈБ@џџ~ЅЅъА@џџЂЂбА@џџ…ŸŸЖА@џџ‰œœА@џџ™™ƒА@џџ’––kА@џџ—““UА@џџœ;А@џџЁ$А@џџЅŠŠА@џџЈ‡‡ёЏ@џџЋ„„еЏ@џџА“Џ@џџЕvv{Џ@џџКrr^Џ@џџПoo@Џ@џџФll$Џ@џџШiiЏ@џџЭffчЎ@џџвccЩЎ@џџз``ЌЎ@џџн]]ŽЎ@џџуZZqЎ@џџшWWPЎ@џџэTT2Ў@џџђQQЎ@џџіNNЎ@џџњKKц­@џџџHHЪ­@џџEEБ­@џџ BB˜­@џџ??‚­@џџ<<k­@џџ99S­@џџ668­@џџ 33ёЌ@џџ$++иЌ@џџ(((ОЌ@џџ-%%ЄЌ@џџ1""_Ќ@џџ5HЌ@џџ93Ќ@џџ=Ќ@џџAЌ@џџEэЋ@џџJ  бЋ@џџPЙЋ@џџUЂЋ@џџZ‡Ћ@џџ^џџkЋ@џџbќќQЋ@џџfљљ0Ћ@џџjііЋ@џџpѓѓіЊ@џџv№№пЊ@џџ{ээ9Њ@џџ~ррЊ@џџƒммћЉ@џџ‡ззоЉ@џџ‹гг›Љ@џџЫЫ‚Љ@џџ•ШШgЉ@џџšХХOЉ@џџŸТТ1Љ@џџЄННЉ@џџЈККєЈ@џџ­ЗЗдЈ@џџБДДЋЈ@џџЖЏЏ•Ј@џџЛЌЌyЈ@џџПЉЉTЈ@џџУІІ/Ј@џџЧЃЃ Ј@џџЫ  нЇ@џџЯ››ЧЇ@џџд˜˜БЇ@џџй••—Ї@џџо‘‘|Ї@џџтŒŒ]Ї@џџцˆˆ9Ї@џџы……Ї@џџя‚‚ѓІ@џџѓдІ@џџї||КІ@џџћyyЄІ@џџўvvІ@џџsssІ@џџ ppђЅ@џџccиЅ@џџ``ЛЅ@џџ]]ŸЅ@џџZZ‡Ѕ@џџ!WWnЅ@џџ&TTXЅ@џџ+QQuЄ@џџ.??OЄ@џџ1<<+Є@џџ499 Є@џџ966ђЃ@џџ=33иЃ@џџA00ЛЃ@џџF--šЃ@џџK**|Ѓ@џџP''_Ѓ@џџV$$AЃ@џџ\!!$Ѓ@џџaЃ@џџfхЂ@џџkЬЂ@џџoГЂ@џџxœЂ@џџ{{Ђ@џџ  PЂ@џџƒ  *Ђ@џџ‡Ђ@џџŒчЁ@џџ‘ФЁ@џџ–§§™Ё@џџ›њњqЁ@џџ їїSЁ@џџЄєє=Ё@џџЈёё$Ё@џџЌююЁ@џџАыыы @џџДшшв @џџИххИ @џџМтт˜ @џџРппƒ @џџФммm @џџШййU @џџЫжж< @џџЯгг @џџдааўŸ@џџйЭЭрŸ@џџоЪЪУŸ@џџфЧЧЅŸ@џџъФФˆŸ@џџяССgŸ@џџєООIŸ@џџљЛЛ.Ÿ@џџўИИŸ@џџЕЕіž@џџВВмž@џџ ЏЏУž@џџЌЌЇž@џџЉЉŽž@џџІІxž@џџ!ЃЃ.ž@џџ%››Ш@џџ*……Б@џџ.‚‚š@џџ3~~ѓœ@џџ8^^иœ@џџ>[[Оœ@џџBXXKœ@џџGJJ0œ@џџLFFœ@џџP@@я›@џџT==Я›@џџW::Џ›@џџ[77›@џџ_44p›@џџc11M›@џџf..!›@џџj++№š@џџp&(Фš@џџs## š@џџx  …š@џџymš@џџzOš@џџ{#š@џџ€№™@џџ…  — @џџ†— @џџ‡ — @џџˆў– @џџ‰і– @џџŠы– @џџ‹л– @џџŒФ– @џџ†Т Dџџ —Т@0FŽ ВТ@0F ЬТ@ F  ёТ@0I У@0F‘ ’– @џџ’  <У Dџџ ’  ‚– @M “  m– @M ” g– @џџ• Z– @џџ– MУ Dџџ–ѕ^У@0R—їїyУ@0R˜ћћ”У@0R™ўўЎУ@0RšџџC– @џџ›ѓѓ<– @џџœђђ/– @џџ№№ЦУ Dџџь№зУ@0ZžююёУ@0ZŸяя– @џџ щщt @џџЁшшb @џџЂррS @џџЃппэ• @џџЄннц• @џџЅммй• @џџІзз Ф DџџІЯзФ@0dЇбб8Ф@0dЈггSФ@0dЉжжЏ• @џџЊШШ< @џџЋЧЧЌ DџџЌ;Р @џџ­}}$Р @џџЎ||Р @џџЏ{{‡П @џџАoozП @џџБnnlП @џџВmmaП @џџГllVП @џџДkkNП @џџЕjjBП @џџЙff3П @џџОdd'П @џџПccП @џџРbbП @џџСaa П @џџТ``јО @џџШ\\эО @џџЪLLуО @џџЬKKиО @џџаDDХО @џџдCCЗО @џџзBB”О @џџкAAŒО @џџм--‚О @џџо,,xО @џџр++О @џџфррdН @џџщЮЮъН @џџюЊЊнН @џџєЃЃаН @џџњЁЁУН @џџўŸŸЖН @џџžž‹Н @џџ QQ€Н @џџ33uН @џџ00Н @џџ!М @џџ$JJyМ @џџ%++cМ @џџ&((ћ @џџ'%% @џџ(  !М @џџ) М @џџ*љЛ @џџ+щЛ @џџ,йЛ @џџ-ЧЛ @џџ.  ГЛ @џџ/  ЁЛ @џџ0ƒЛ @џџ1sЛ @џџ2џџ]Л @џџ3ќќ7Л @џџ4љљ'Л @џџ5ііЛ @џџ6ѓѓ Л @џџ7№№ћК @џџ8ээщК @џџ9ъъеК @џџ:ччСК @џџ;ффЏК @џџ<ссŸК @џџ=оо“К @џџ>ллГ @џџ?ииŸ @џџ@ееoК @џџAввVК @џџFЯЯ6К @џџGЬЬ%К @џџKЩЩК @џџLФФёЙ @џџMССлЙ @џџNООХ @џџOЛЛЯ @џџPЖЖ™Й @џџQББ|Й @џџRЉЉcЙ @џџSІІJЙ @џџTЃЃ3Й @џџU  Й @џџVЙ @џџWššђИ @џџX——зИ @џџY””ТИ @џџZ‘‘­И @џџ[ŽŽ–И @џџ\‹‹}И @џџ]ˆˆbИ @џџ^……IИ @џџ_‚‚2И @џџ` И @џџa||№З @џџbyyУЗ @џџcvvЌЗ @џџdss™З @џџepp~З @џџfmmcЗ @џџgjjJЗ @џџhgg/З @џџibbЗ @џџj__З @џџk\\цЖ @џџlYYгЖ @џџmVVДЖ @џџnSS™Ж @џџoNNvЖ @џџpKKQЖ @џџqHH.Ж @џџrEE Ж @џџsBB№Е @џџt??йЕ @џџu<<ФЕ @џџv99ЋЕ @џџw66Е @џџx33wЕ @џџy00ZЕ @џџz---Е @џџ{** Е @џџ|''ѕД @џџ}$$оД @џџ~!!ЗД @џџ’Д @џџ€oД @џџHД @џџ‚#Д @џџƒД @џџ„яГ @џџ…  кГ @џџ†  СГ @џџ‡ЄГ @џџˆ‘Г @џџ‰xГ @џџŠ§§_Г @џџ‹њњHГ @џџŒїї5Г @џџєєГ @џџŽёё Г @џџюю№В @џџььнВ @џџ‘щщЪВ @џџ’ццЕВ @џџ“ррЂВ @џџ”нн‹В @џџ•ккrВ @џџ–ззWВ @џџ—дд>В @џџ˜бб#В @џџ™ЮЮ В @џџšЫЫёБ @џџ›ШШкБ @џџœХХЧБ @џџТТЌБ @џџžНН…Б @џџŸИИhБ @џџ ЕЕUБ @џџЁВВBБ @џџЂЏЏ'Б @џџЃЊЊБ @џџЄЇЇїА @џџЅЄЄрА @џџІЁЁХА @џџЇžžЊА @џџЈ››“А @џџЉ˜˜vА @џџЊ••cА @џџЋ’’IА @џџЌ/А @џџ­ŒŒА @џџЎ‰‰А @џџЏ††рЏ @џџАƒƒЭЏ @џџБ€€ІЏ @џџВ{{žЏ @џџГuu‹Џ @џџДttnЏ @џџЕqqQЏ @џџЖnn2Џ @џџЗkkЏ @џџИhhњЎ @џџЙeeзЎ @џџКbbОЎ @џџЛ__Ў @џџМ\\‚Ў @џџНYYcЎ @џџОVV@Ў @џџПSS'Ў @џџРPP Ў @џџСMMї­ @џџТJJи­ @џџУGGП­ @џџФDDІ­ @џџХAA­ @џџЦ>>z­ @џџЧ;;_­ @џџШ88J­ @џџЩ55)­ @џџЪ22џЌ @џџЫ--цЌ @џџЬ**ЭЌ @џџЭ''ВЌ @џџЮ$$™Ќ @џџЯ!!lЌ @џџаUЌ @џџб>Ќ @џџв+Ќ @џџгЌ @џџд§Ћ @џџе  рЋ @џџж  ХЋ @џџзАЋ @џџи—Ћ @џџйzЋ @џџкўў_Ћ @џџлћћFЋ @џџмјјЋ @џџнѕѕЋ @џџођђэЊ @џџпяядЊ @џџрььžЊ @џџсччPЊ @џџттт%Њ @џџупп Њ @џџфккяЉ @џџхееаЉ @џџцввЉЉ @џџчЭЭЉ @џџшЪЪwЉ @џџщЧЧZЉ @џџъФФGЉ @џџыСС<Љ @џџьПП)Љ @џџэММЉ @џџюЙЙхЈ @џџяЖЖЦЈ @џџ№ГГЙЈ @џџёББ Ј @џџђЎЎЈ @џџѓЋЋhЈ @џџєЈЈCЈ @џџѕЅЅЈ @џџіЂЂљЇ @џџїŸŸыЇ @џџјвЇ @џџљššПЇ @џџњ——ІЇ @џџћ””‹Ї @џџќpЇ @џџ§ŠŠMЇ @џџў‡‡(Ї @џџџ„„Ї @џџфІ @џџ~~ЧІ @џџ{{АІ @џџxx›І @џџuu‚І @џџrrgІ @џџoo1І @џџjjІ @џџeeцЅ @џџ bbЭЅ @џџ __ЌЅ @џџ \\•Ѕ @џџ YY|Ѕ @џџ VVcЅ @џџSSPЅ @џџPP Ѕ @џџKKЩЄ @џџFFŠЄ @џџAAcЄ @џџ>>>Є @џџ;;Є @џџ88Є @џџ55чЃ @џџ22ЬЃ @џџ//­Ѓ @џџ,,ŠЃ @џџ))qЃ @џџ&&PЃ @џџ##5Ѓ @џџ  Ѓ @џџѓЂ @џџкЂ @џџ СЂ @џџ!ЈЂ @џџ"“Ђ @џџ#fЂ @џџ$  =Ђ @џџ%Ђ @џџ&їЁ @џџ'кЁ @џџ(џџБЁ @џџ)ќќ„Ё @џџ*љљaЁ @џџ+ііHЁ @џџ,ѓѓ5Ё @џџ-№№Ё @џџ.ээљ  @џџ/ъър  @џџ0ччЦ  @џџ1ффЌ  @џџ2ссŽ  @џџ3оо{  @џџ4ллb  @џџ5ииK  @џџ6ее0  @џџ7вв  @џџ8ЯЯюŸ @џџ9ЬЬеŸ @џџ:ЩЩДŸ @џџ;ЦЦ™Ÿ @џџ<УУzŸ @џџ=РРWŸ @џџ>НН>Ÿ @џџ?КК!Ÿ @џџ@ЗЗŸ @џџAДДчž @џџBББдž @џџCЎЎЕž @џџDЋЋœž @џџEЈЈƒž @џџFЅЅpž @џџGЂЂIž @џџH=ž @џџIšš!ž @џџJ™™ž @џџK‘‘я @џџLŒŒе @џџM‡‡Н @џџN„„Ї @џџO @џџP||s @џџQttU @џџRoo; @џџSjj @џџTee @џџU``чœ @џџV]]Ыœ @џџWZZГœ @џџXWW‰œ @џџYRRYœ @џџZMM?œ @џџ[HH#œ @џџ\EEœ @џџ]??п› @џџ^<<С› @џџ_99Ÿ› @џџ`66ƒ› @џџa33_› @џџb00=› @џџc--› @џџd**лš @џџe%%Џš @џџf""“š @џџgyš @џџhcš @џџi>š @џџj š @џџk  и™ @џџlЭ™ @џџnР™ @џџpІ™ @џџrћћ—™ @џџtѕѕy™ @џџvєєc™ @џџwььS™ @џџxыыD™ @џџyъъ:™ @џџ|цц0™ @џџ~ххъ˜ @џџооۘ @џџ€ЬЬ͘ @џџœœ” @џџ„„„€˜ Dџџ…xxH˜ @џџˆmmь— @џџ‰NNU— @џџ‹99I— @џџ227— DџџŽ--– @џџчч• DџџЛЛћ” @џџ‘ІІз” @џџ’ЅЅК” @џџ“qqЎ” @џџ”pp—” @џџ•gg” @џџ–ffp” @џџ—ee6” @џџ˜;;(” @џџ™55” @џџš440 @џџ›33’ @џџœ22у @џџ//ж“ @џџž''„ @џџŸ&&П“ @џџ %%GHIKJNOSTUV[\efggђЁ} АЩ<„<„K„S„<„<„–„ž„<„<„с„щ„,…,…;…F…,…,……š…,…,…у…ю…”Ш7†H†\†q†ƒ†”ШО†Ю†с†ї† ‡ ‡‡ђЮ†ї†\†g‡”Ш7†H†\†q†ƒ†”ШО†Ю†с†ї† ‡ ‡ї ™‡Љ‡М‡ї ™‡Љ‡М‡3єш‡ћ‡ї ˆЉ‡%ˆžLQˆћ‡‡ђdˆћ‡ї ˆQˆwˆ”Шш‡ЃˆЕˆžLш‡ћ‡‡ђш‡ћ‡‡ђш‡ћ‡‡ђш‡ћ‡ї ˆQˆwˆї еˆеˆмˆцˆмˆцˆмˆ№ˆ”Шеˆцˆмˆ”Шƒ†”ШеˆцˆцˆмˆL‰мˆеˆеˆцˆмˆ‰мˆеˆ$ѓ3є‡ђШ‰žLцˆžLŠžLцˆžLŠ”Шеˆцˆмˆ‹ђ)Šї еˆмˆcŠї еˆмˆcŠ”Шцˆмˆ”Ш”ШzŠмˆеˆцˆмˆ”ШеˆЕŠžLцˆмˆџŠ‡ђцˆмˆџŠї еˆцˆцˆмˆL‰”Шеˆцˆмˆ”Шƒ†”Шеˆцˆмˆцˆмˆ ‡”Шцˆмˆ”Ш‹”Шеˆцˆмˆ‹ђ)ŠžLцˆцˆмˆg‡3єH‹‡ђеˆмˆX‹мˆеˆеˆ…‹еˆмˆеˆмˆ‘‹”Шцˆмˆ”Ш‹мˆеˆеˆмˆеˆмˆу‹”ШеˆмˆеˆмˆцˆŒ”Шеˆмˆцˆмˆ”Ш_Œ”Шеˆмˆеˆмˆцˆмˆ Œ”Шеˆцˆмˆ”Шƒ†”ШеˆеˆмˆцˆмˆžLчŒ”Шеˆцˆмˆ”Шƒ†”ШеˆцˆцˆмˆL‰ї 7=žLMї K„žL;…‚ї K„žL;…‚ї K„;…Нї K„K„щї K„;…žLŽї K„;…;…JŽї K„žLŽŽї K„;…Н3є;…БŽї K„у…ЫŽї K„žLŽŽ‡ђK„ј$‡ђїŽї K„йї K„…8ї K„žLŽŽї K„žLŽŽї žLdї K„œKuї K„;…Нї K„;…;…JŽї K„мˆ‘šї K„;…žLŽ3єП‡ђ3є;…Кї K„;…Нї K„;…žLŽї K„;…žLŽї K„;…;…JŽ‡ђ;…БŽ3єK„П‡ђёї K„žLŽŽ‡ђK„ј$‡ђїŽї K„йї K„œKuї K„;…Нї K„žLŽŽї K„žL;…БŽFёFё(‡ђ3є;…3й;…БŽžL;…БŽžLœKp;…wœK;…БŽї K„;…Н‡ђ;…БŽ‡ђ;…БŽ‡ђ;…БŽ‡ђ;…БŽ‡ђ;…БŽ‡ђ;…БŽ‡ђ;…;…žL™ї ;…БŽї K„;…žLŽї K„;…žLŽї K„;…;…JŽ‡ђ;…žLк‡ђ;…鑇ђ;…œK#‘‡ђ;…;…E‘ї K„ї K„;…Нї K„;…žLŽї K„;…;…JŽї K„;…Нї –„–„w‘ї –„……‘ї –„у…с‘ї –„žLžL ’‡ђ–„ј$‡ђ?’ї –„йžLf’ї –„у…с‘ї –„;…’ї –„у…с‘ї –„œKЛ’ї –„…М‡3єП‡ђ…з’ї –„…žL“ї –„……‘ї –„…М‡3є–„П‡ђ;“ї –„^“FёFё‡ђ…r“œK…™“ї с„…%ˆї с„…%ˆ‡ђ……Г“ї –„…žL“ї –„……‘‡ђ…žLžLх“‡ђ…йžL”‡ђ……Г“ї –„^“ї –„^“ї –„……‘ї с„у…у…L”ї с„=у…”ї с„=žLЮ”ї с„žLžL•‡ђу…žL5•žLс„у…žL^•ї с„у…žL^•ї с„у…у…L”žLс„с„у…žL™•ї с„с„у…у…ц•žLс„у…žL^•ї с„у…žL^•ї с„у…у…L”žLу…žL5•ї с„с„<–ї с„у…žL^•ї с„у…у…L”ї с„žLу…b–ї с„у…žL^•ї с„у…у…L”ї с„с„у…–ї с„у…wˆ3єу…‡ђл–ї с„žLњ–ї с„žLњ–‡ђс„ј$‡ђ—ї с„йD—ї с„;…^—ї с„œKŠ—ї с„у…wˆžLу…žL5•žLу…žL5•ї с„=žLЮ”ї с„с„у…žL™•‡ђс„у…žL^•žLс„у…у…L”ї с„žLњ–ї с„мˆD—ї с„мˆD—‡ђу…‡ђл–ї с„у…žLу…І—ї с„у…у…у…љ—ї с„у…žL^•‡ђу…ћ‡3єП‡ђу…U˜3єПу…~˜ї с„у…wˆї с„у…žL^•ї с„у…йЂ˜ї с„у…žL^•ї с„у…у…L”ї с„у…у…L”‡ђу…‡ђл–ї с„с„žLд˜ї с„žLњ–ї с„у…žL^•ї с„у…у…L”‡ђžLу… ™‡ђйу…2™‡ђу…žL5•‡ђу…йЕˆ‡ђу…у…R™ї с„у…у…L”‡ђс„у…у…L”3єс„П‡ђ„™3єс„ПЇ™ї с„žLњ–‡ђс„ј$‡ђ—ї с„йD—ї с„œKŠ—ї с„у…wˆї с„žLњ–ї с„Х™ї с„3є‡ђ3є‡ђ3єУ<й™žLу…у…R™FёFё‡ђу…/šйу…ћ‡œKpу…VšœKу…ћ‡ї с„с„с„у…у…xšžLс„у…žL^•ї с„у…у…L”‡ђу…ћ‡‡ђу…ћ‡‡ђу…ћ‡ї с„с„žLд˜ї с„žLњ–žLу…žL5•žLс„у…žL^•ї с„у…žL^•ї с„у…у…L”žLс„с„у…žL™•ї с„с„у…у…ц•žLс„у…žL^•ї с„у…žL^•ї с„у…у…L”ї с„žLњ–ЂЂрš‡ђ3є‡ђ3єу…щšї у…ћ‡‡ђу…žL5•‡ђу…žL5•‡ђу…у…R™ї с„у…žL^•ї с„у…у…L”‡ђу…žLžLA›‡ђу…у…žLy›‡ђу…у…у…К›ї с„žLњ–ї с„у…wˆ‡ђу…žL5•‡ђу…œKœ‡ђу…у…R™‡ђу…žL5•‡ђу…йЕˆ‡ђу…œKœ‡ђу…у…R™ї с„žLњ–ї с„Х™žLу…žL5•žLс„у…žL^•ї с„у…žL^•ї с„у…у…L”žLс„с„у…žL™•ї с„с„у…у…ц•žLс„у…žL^•ї с„у…žL^•ї с„у…у…L”ї с„žLžL•ї с„у…žL^•ї с„мˆмˆ&œї с„у…у…L”ї с„у…žL^•ї с„у…у…L”ї с„у…žL^•ї с„у…у…L”Ђс„мˆD—‡ђј$ј$ё)‡ђј$'‡ђПј$Ї'‡ђFёј$№'‡ђFё3єј$|'‡ђј$'‡ђПј$Ї'‡ђFœј$NœžL=žLlœžL=žLlœї =œї =žLlœї =у…Ѓœї =Яœюœї =œ‡ђ=žLlœї =у…žLžLї =œї =ftŸ‡ђБї ЛЮё žї xžŠžЌžХž/Ÿ>ŸSŸbŸwŸ†Ÿ›ŸЗŸШŸfЂЮŸѓŸАЩАЩ  ‡ђ‡ђ‘' 3 E R c c ййp ' ‚ c ” ‡ђ‡ђ' йžLЂЫАЩЁЅ Е Х д т ю љ 8Ёђ:Ё<Ё„Ё8Ёђ:Ёд †Ёт ю ‘ЁЬЁЯЁвЁиЁлЁсЁєЁіЁєЁ1Ђ„Ёђ:ЁGЂ^Ђ`ЂdЂhЂ|Ђ~ЂЂ|Ђ~Ђ•Ђ^ЂдЂЃдЂ|ЂЃѓїЪЬ&ЃѓїЪЬЛЃСЃАЄЗЄКЄЪЬНЄ№ЄѓїђрёѕЄ№Єѓїђрё(Ѕ8ЁCєhZ6Ѕ8ЁCєhZDЅ№Єѓїђрё%Ї(Ї+Ї№ЄžЇЗЄЁЇКЄЇЇ­Ї№ЄžЇЗЄЁЇКЄЇЇЈ№ЄžЇЗЄЁЇКЄЇЇHЉQЉVЉєЁбЉиЉчЉїЉЊЊЊ+Њ:ЊGЊTЊbЊqЊЊ“Њ ЊАЊШЊеЊтЊэЊњЊЋЋ&Ћ4ЋAЋLЋ\ЋlЋzЋЬЁЯЁвЁГЋЙЋЮЋѓїЪЬЌЌ"Ќ2Ќ?ЌLЌWЌgЌuЌƒЌЌœЌЊЌЕЌФЌаЌмЌщЌїЌ­­!­5­E­]­j­u­„­“­Ё­А­Л­Щ­й­ф­ѕ­ЎЎ+Ў>ЎPЎ`ЎmЎyЎ‡Ў–ЎЄЎДЎЬЎоЎыЎјЎ Џ!Џ4ЏIЏ]ЏpЏzЏ†Џ”ЏЄЏЏЏНЏЫЏиЏуЏ№ЏќЏ АА А,А7АDАRАaАoА~А‹АšАЇАВАСАЬАмАчАђАБ ББ)Б8БGБTБdБoБ}Б‹Б–БЃБЗБТБЭБЭБиБшБјБ ВВ(В;ВIВ[ВjВ{ВŽВœВЋВЗВШВжВф§ ГГ*Г6ГDГRГaГoГ|ÉÖèáГЛГЫГкГцГєГДД!Д7ДFДRД`ДpДˆДŸДЎДНДЮДйДчДѕДЕЕЕ)Е<ЕNЕ_ЕjЕxЕƒЕ—ЕЋЕПЕ_ЕгЕсЕьЕњЕ ЖЖ+Ж?ЖRЖdЖtЖЖЖ›ЖЊЖКЖШЖзЖхЖїЖЗЗ З+З@ЗTЗgЗ|ЗЗЃЗВЗРЗЯЗрЗѓЗИИ"И3ИFИTИbИpИ|И”ИЊИНИаИрИіИЙ!Й/Й:ЙKЙ[ЙiЙwЙ…Й’ЙЙЋЙИЙЧЙиЙыЙљЙ КК+К>КLК\КjК|К‡К˜КІКДКПКЪКЪКйКчКєКЛЛЛ(Л7ЛGЛUЛdЛtЛ‚Л‘ЛžЛДЛЩЛзЛцЛјЛ ММ,М;МNМ`М|М“МЊМЙМЧМгМчМНН^Ђ0Н^ЂЂЫъCН*CН*HН^НtН…НЁНЃНЅНCєАЩРНЫZЧНоНЃЫЂЫАЩуНчН} ыНCєyZCєЂЫАЩЂЫ` ѕН Ом } } } О$О2ОcОАЩЭЭЅЧ” qт]‚"вћ(FƒЧІ{|ЧЇ—ЧБТУэїЧЛ  аqœаЉвгаНЁљаО9::;CCЙ <>?DDdeefggЙЈБЙЋЙЏ|шЙЙЖ‚– ‚Іrs‚ЉЧ‚­;‚ЎYZ‚Е0‚О,k—CkЋћk­8kА’tPфш›ВВlљќkГГИМПТТЦЭагггжжйймммпттттхшыюёёєїњ§  "&),,,KP˜ВФSzЌащщі]t—D]•­]Ї‡]БВ]Лќ§Ъ]М%& ЩЪЊВТЦЮжрр`А†ЎMН )*012345с‡сКчЪ•гћEEKP›ЇЇЕЧсююјј++,,--KЪ­DЪВцчЪМ[]fhqs|~˜›œпсг• жџLQ~œИЪKгЖVWМЉЮЁ…š…БИКє…М+nЅSnЏqrnИ…nЙІwЉЧШwЕ01@ЎST@Џk)ЉМН)­23)М2ЅLlm2ЎP2Џkl2И€„RRSSTT”4Є89БЇЕ'Н $)*0134ЊЕфІ~фБХЭ—LЭ™жЭЅ_`ЭЌ'(ЭЏ€ЭЕ9ЭКфж“"'П“ %ПЇ—˜П­DEПЙЗёђПЛ ˆŸРˆИˆ‘—G‘Гz@ AJg~‰Œ‘змЌПPdzŸРСzЋўџz­;<zКвzПnC–ѓCЈЅІ,•Ѕ,e5Ё№ё5Ѓ !ak5ГєѕЈЂЃЌГёђИ|ЙžН*0134ОщьПbч“#()У…чœ]^чžБВчЁџчЃ23чЎbчМАЕИ№™№š%№Вьэ№Е?@№Зyzй•змнюяйЕ<=йЛЂЋЂВноЂО256:=‹Ї‘‹Џtv‹Вкл‹НQxЂЄ”Л”О1A”Пs}6 )\egpЗ}—E}ЊуЋЌ}Вз}Иˆ‰}ЛџFЋјљFН$255TYZ\abe{€ˆ‰­ЕЗК/–№ђѓ/ЈЂ/АŒ?D/ВЮ/Зbd8 Tbglqv‰Ž“8­2”,œ?@`bІeg|ъ˜ЋносžBGLfkЮуш.|ЙВЗХ!ъАЁъНЊѓ!Ьѓ•сјѓœ]ѓЂnѓІ~ѓЖYѓЛмžЎЅŸУЅ пыЦјCtЅЖNЅЙВфхŽžЅŽ опŽЎY—”gk8—™ђѕ—Ї—ЋI7ЩЪQ[cghpqx‚ŠŽ—˜ЁЂЃЄТЦЮзррI–їI—924  #&+.147:=@FJOTX[^bglqv~‚…‰Ž“›ŸЃІЉЌЏВЕИЛОСФЧЪЭагжймптхшыюёєїњ§  !$'*-0369<?CHMQTWZ]`cglpsvy|‚…ˆŒ‘•˜› ЃІЉЌЏДЗКНТХШЫЯгзмрфщэ№ѓіљќџ "%(+/369<?BEHKNQTWZ]`cfilorv}„‡Š“–™œŸЂЅЈЌАГЖКПУЦЩЬЯвеилосчъэяђѕјћў  "%(+.147:=@CFILPTWZ]`dhknqtwz}€ƒ†‰Œ’•˜›žЁЄЇЊГИМПТЦЭгжймптхшыюёєїњ§  "&),IžŸAIŸКIА;CIВбIИ‚ƒR–ўRГї;jl;АŒ;Зb;НRЋЯ;Р}ОСЦпрэ”Ёэ•нэЊя№эЋ эОLі–w›ŸЃІЉЌЏВЕИЛОСФФЧЧЪЭажйёє!!$$'*-366QTWWWsvy|‚…ˆŒ‘•˜ЌЏДЗЗНТХШЫЯгэ№ѓљќџ "%(+699<?BEHKKQTWZZ]]`cflorvœŸAЃдUіžБіЊяіГ п˜Њп›<=пЊьЈ“еЈЂБ–Б˜„ББЁќ§БЇ”БЉЭБ­AБГБМ JKLOPQKKKLLБНnš|šЃ)šЄAc—Bc™ьscšcocЄ>?cЅSTcЎVWcА’“cВдcЗjkcЙІЇcКЯа\]cМ()cОіљ LЛљU—'79;БЖЛОСФЬвеилосфчъэ№ѓіљќџ   %(+UoqU еUЌUАUБВГUЗgUЙЃ>š>ŸКЛ>Є;<>Іj>Ќ>Вбв>ЖE>Н$*25S__acdhz††ˆŠ‹ЌВГЕЖ›*+ž‘“ЂЌ Н14” 3„†Ъа7>K]ДЙšОТЦЦЦЮжљ•сљ ъыљЇŸ љЛТЖSТИ‘’ТМLMQRS~€ŽТО4556678ТПuЋЈЎЋЊчЋЕ67ЋНjЛДŸЦЧДЖST—HœRЎ\]А˜МJO]hsf,fЂ  O”`OšOЄ;OЉСXЅP!›*!ž™›!ŸЗИ!Лѓ!М ЈŸ Њкм„UUVVWWž‘ŸДЛ№Н!+0134Q^irx…™ЁЂЃЄР{ќН­ЖЗКХЛМ1ХЋХАžŸХО9>CЎ”%psр1FJOTX[^bglqv~‚……‰Ž““s…%еI†ЎЏ{ЗДЗО4B€˜Lvxгмптхшыюїњ§  09<?CHMZ`glp› ЃІЉКрфщі/3NiŠ™Ђѕјћў %+.17TЦпшюњ§€t€Н3€О+++1334578AABBiКЯаrВзи[”b[—9;$—$$Ёэ$Ѓ$Џh$А‰$З_$Н0134ЊЖ$Р| 5љљћ ЖBC И|} КФ М–хщў4kЁэюЃcelЉЙЊкВЫОажжжззџЌ-/пџД$Ш„бЋбАžК”qtКІxККсКМKMMPRRS‡ŠŠ‹Œ˜››œіљ ƒ›34ƒžЅІƒ лƒЌЯаƒА•ƒГ§ƒЛlœMlЌдlПmuЄ>uБЕuН0ь^p^˜jkm^Џn^Н&.tГОи',Aццц'–я'ЎPQж'БЊЌ'Й'Лії'Н0134'Ощь'Пc034525‚Š0™хEŠ›сю0œE0 вг0Ћѕ0ОщьЏhiМЫ:jъыь'(+7=@ІЌЕИИОСЧЭагйхюєњ§§  $*-036TyˆЃЉЏДЗХЫэѓџ (+?BHNTW]cfillo–Жвииэў =LZ]hwz}‰•›ЄЇЊТхы ۘ,ЊЗУФЫЬжм?@VXaclnwy“•ЁЂЋ­НПЯбкмшщђѓфцёѓў  Ы™ ---9;;CCЫœZ[ЫИ‘дžЎЏдІ{дЈГдЊьэдО9;CC͘?œž мтхшюњ 9<?CHM`glpщ/3Ki™сѕћў+.17Tw}žИЦш§"[fq|˜ТпіН„…†™ёђ†ЖKoДoЗjoКвг]x6ёёђђєєѕѕxžЂxГ§ўxО+35A”=С›9:СЂAЃ СГСКфхAМ *ЂЊА›œЊВнГийГœWXГЂ3Ќ3БЊ3Й ЁГЛ  ГМJMORS3Пd—}„‡“–ЈЌАГЖКУЦЩЬЯвеилоссъєV˜dœžЈЉœЂА‰ŠœЕ3ЖBЗ_`œНQ\exe•ЎхЂхЈЖЗeЊтхВщЮpAЮ” ikЉ0NІk“”NН"NПjз”ЁЅЉ­Д&WŸНОзЎbcWВдезИ”• – š ЈЎЏ И‹ ”, —,чъэяђ":=@CFILPWZ]`hknqtz}€ƒ†‰Œ’•˜›žžЁЄЇW‰œRT Гюя‰ЙЉ П`’2SŽƒŒ’–  ™ееБЇЈГю’ДПaћ%&4ћ“,ћ”ЂІЊЎЗ){ лм{Ђ ћЉе{ЏqћВьћКэюћМФЧШЩЪФ–1D™ъ]Фš"ФЁќФЕ9:­—I­Ѓ,-Пg­ЄBVW-Е*+­ИŽ-М  -НЖ >_ƒ›Ы%Q6”:;6•ЈЖА›ЖЕ6ЖЗsЖИŽ6КЪЬЭ6Н&ЖНžЂŸаеж•Є–юююјј--Ÿ›67eg ЯŸЅYŸКопŸНTZ[\bce{‚ƒ‰ŠŒŸО1223AABBhЈЈЉhБЕЖшД!шЙОqЁіqЃ&'bёЌ*qЎVёЏƒёБШЩёЙСТZ–к—MZ˜jkmкЁџкЂ`jкЄFZЉФХкБХЦкГ  ZДZЕ-.кМšœГЖИЙХШЪЫЃ,Ѓ˜v#š #œEF#ВЮЯ#ДЃДЃПt І ”, Є5 Іe ЎMN ВЫЬ Е'(ŒО-;•˜v•ЅYZЇ•ЈЋ•Вк•МACDЃЅІТЧЪджжъьэєії~Q_hqx†˜ЁЂЃЄ<==>?DDdeefgg~•Вў–6Ьчъъэяѕѕјћў   "%(.147@TWWZ]`dhnnq’˜˜›ЁЄЇTўŸЬ~ЗmnGjGЉСТGМ!PЂPЃ#$emPЅPQPЊтфАPЎS9˜ik9Ї„9Њп<>?DDdee–уч™СТЋђѓы–І'4ŸЃЃІЉЉЌЏЏЕЛЛОСФФЧЪЪЭагммптхшшыюёїїїњњ§  !!$''*-09<?CHMQQTWWZ]`cglpp|••˜˜›› ЃІЉЌЌЏКННТТХШЫЯгзмрфщэ№№№ѓѓі/369<<?BEEHNQQTWZZ]``cfirvvЩЯлŒA[fq|˜ЃАТпRы чыЇєЈЖєКънЇšнВщънНЃ нПvІ$dІ™љћеІЇ”•І­ABІЏ{}ъ•:ДЗЛ  #&+.47:FJOTX[^bglqv~‚…‰Ž“›ŸЃІЉЌЏВЕИЛОСФЧЪЭагжймптхшыюёєїњ§  !$'*-0369<?CHMQTWZ]`cglpsvy|‚…ˆŒ‘•˜› ЃІЉЌЏДЗКНТХШЫЯгзмрфщэ№ѓіљќџ "%(+/369<?BEHKNQTWZ]`cfilorv}„‡Š“–™œŸЂЅЈЌАГЖКПУЦЩЬЯвеилосчъэяђѕјћў  "%(+.147:=@CFILPTWZ]`dhknqtwz}€ƒ†‰Œ’•˜›žЁЄЇЊГИМПТЦЭгжймптхшыюёєїњ§  "&),|~˜22499;;ххххžŸŸ˜ о˜­>˜БЙђacЄaЁіїaПlJ­56JБЏJЗghJЙЃЄS.пГИМПТТЭггжйймммттттхыёєї  "&),,LQ~щіS™ыhШSЁѓS­5SН",<<3РФЧжпрџlГИИМППТЪЭЭгжжйппыююёєє ""&))S€—šT{­шыѕіј<–ђ< в<ЉП<И<Ощь "Ї‚А†‡Йš›КФЦЛэМюqžžŸŸюŸЬЭюЄGabїї“,їЁї­JKїАЄЅРЯа\]Р•бР™жЉ–ЉЉЭЯЃЉКоВЌ$%›Іuv›ЉЪ›КлdFFJX[[^^~‚……c…%Ѕе4I†хdН *hq˜СТЭЮрM7ЩЪQYaghpqx€ˆŽ—˜ЁЂЃЄТЦЮзррM›-MЇ‡ˆVКЯVПk?œHJ˜VNSŸДЕ­-Џe•Ђ— }ŠŠ““–™™œŸЂЅАГГЖКПУоо€дъєSœ? ЯаКХўџњ!MњŒњЎefњИ—У žžŸdeefggУ—KУžЋУŸЦУЗvwУНŸЄЌЯа\]ЌЌ˜„„††Ќ ст8BЌЅ\]ЌЎ\ЌБНПЌЗstЌЛЕžЋЌЕВрсž•ПžЊчщТžЏug–ЊgŸНgІopgЉФgЕ-p”eiop›0pžЂЃpЇŠŒpМ(YœMOYОіљ  t'(7ІЌЕИИСЧагйтхює$*-036T]css‚…ˆ‘ДЗКХШЫмэѓі "%(+3?BHNTW]cfilloЅЌПввеииэћў (4=FILPZ]dhwz}ƒ†‰•›ЄЇЊТхы K š  ЅKMq Л№ёЌ­.кл§—U§Ћ §БШ§Е?§Зy§ЙСЦ\]Ц фх37AЦЈГДЏ•СХШЏš"#Џ›6ЏКстИ–И™љИ сИБН”fj1œOTКеjГњjЛќs™ьstvsІosЛџ\žž?%˜ eSafkpuˆ’%Њпр%КЩЋђЗ\ЛѓєрŸЩр чшрЋ  рЏƒ„рАЁЂЩЄFHfЩЎ_ЩДв фвЇš›БвВцвЛ вМ€‡ŒŽЛцццЛ    [qsssŒ‘зм/3ЌП4PddхоЛЃ,ЛЅ\ЛЊшНО„!&2„ЁљњmЅІm•ББ##m– mšm иmОіљ vЌvА•–vЖKL_›01_Ѓ#_Ћћќ_Ќ_­89_Гњћ(”5(Ї„…(Гё1A^Т1Іjl˜1ЉМ1ЛіЂІfwxу/23I…PwуГ уЕ<уИ”уЛуОKLЬЂЬЃ/0gЬГе‡‰еŸЩЪеЏ€еЙЛеКчшОœWОЌ$ОЎ_`ОВр‡—F‡ЅV‡Ћў‡Пo›3ЉЪЫЕ34y;qы'(+7=@ІЌЕИИОСЧЭагйтхюєњ§§  $*-036T]y‚ˆ ЃІЉЏДЗХШЫэѓџ "(+?BHNTW]cfillo–Жввииэћў (=FLZ]hwz}ƒ‰•›ЄЇЊТy™ёє›ЗЩyšyЈЈyМ+,B•ЉBБЏАBЕ*BПf+Є8+ЌDІ4ДЅKЋѕіц•мцЅbcцЌ*+ц­GцЖYZЯЖИіЯ›9ЯБТи™ иœZиЃ/иЅ_иЌ'и­GHиЗvиО<DЁЗpЁЙБЁЛŠЃ)*oŠЄAC[ŠЗmŠКиŠО,,,“š “Ђ“Џtu“А˜™“Клм|Ѓ&|ЅVW|ЇŠ|ЙЉЊE@JEОщь.ž™š.ŸЗ.ЖEF7— &)-RSTUVW7ЛљњИЄ56ЎJДщ/     s+щКъыщЛђЃ2ђЅbђИ—˜л– #&+.147:=@ orЊлš%&лЖVлЙОПЄІuЄЌ!ЄГ„„††ІrЈЋЌ­>?БИМACDEEЃЅІЇЇджъьэююєіїјј–И‹ŒДH˜jmu№HЁѓєHЌHГїјHДHКЬQžQЋјQЏnoQЖHIQО ыьэјљњ !:™цЃБЄЗ\]П\]ь— NIf}ˆ‹жлЋОOcѕД$%ѕНЊБКоЉвоД!"Ї‚ЇžЈЇН_жАІxyАЋ™ŸУФ™Ёљ™Ќ!"™Г™ЖNP™Зpq™ЙБГщ™НQZbx‰b0рГГИММПТЦЦЭгжйпшшыюёёєїїњ§ "&&),,щщіb”bb˜ub ийbЖHbИ…†K QZ\xЁЂЃЄK•ЊKœHK ежT”aЖT•ЌTЈЅTИ‚=›-.=žš=Ё№=Ђ =Гє=Й : RRSSTTUUVVWWЁъЉЙКя›<яŒŽяЉезяГ  яМВЕЖЗИјО\јПw DџџёQ DџџЪY Dџџ*p Dџџьr Dџџ … нн: @џџ2?юї„ ?ммэ„ ?ллф„ ?ккж„ ?ийЧ„ ?жзИ„ ?де­„ ?вгЃ„  ?ббš„  ?аа‘„  ?ЯЯ†„  ?ЭЮ„  ?ЬЬy„ ?ЩЩp„ ?ШШg„ ?ЧЧ_„ ?ЦЦR„ ?ФХD„ ?ТУ6„ ?РС,„ ?ОП#„ ?НН„ ?ММ„ ?ЛЛ „ ?КК„ ?ЙЙ:…!?ЋЋвƒ 1@ЋЋW…#@ЈЈУƒ 1 AЈЈu…% AЅЅДƒ 1#BЅЅ“…'#BЂЂІƒ 1&CЂЂА…)&CŸŸ“ƒ 1*DŸŸй…+*D››ƒ 1.E››†-.E——kƒ 12F——-†/2F““[ƒ 16G““S†16GEƒ 19Hq†39HŒŒ7ƒ 1<IŒŒŽ†5<I‰‰)ƒ 1?J‰‰Ћ†7?J††ƒ 1BK††Ъ†9BKƒƒƒ 1ELƒƒэ†;EL€€ё‚ 1HM€€‡=HM}}ч‚ 1KN}}о‚KNzz)‡@KNyyд‚ 1MOyy8‡ @BTOlsЩ‚ C1VPlsГ‚ 2VV<u8‡ @E]VciЩ‚ C1_Wci8‡ @GeW[aЩ‚ C1gX[aH‡ @InXQXТ‚ C1pYQXH‡ @KwYHNТ‚ C1yZHNH‡ @MZ@FТ‚ C1[@FX‡ @Oƒ[4:š‚ 1…\4:r‡ Q…]+0„‚ 1‡^+0‘‡@ Pˆ^//Х‡ T‰_$)Х‡ 1‹`$)ф‡@ SŒ`((Х‡ Wa"Х‡ 1b"$ˆ@ Vb!!oˆ Zcg‚ 1“dЕˆ@ Y”d‰ ]”j‚ 1–k9‰$\—k  i‰$\—l  š‰4_˜l  г‰\›l  г‰\žl  Š\ l>Š@ \  myŠ €d ЁmЂŠ Ђ„•АŠ@f4Ђ„––э€ Ђ…‘”ЧŠ@ hЃ…““юŠ@ fЄ…˜˜‹@ fЅ…™™$‹@ fІ…šš@‹@ fЇ…››\‹@ fЈ…œœx‹@ fЉ…–‹B0@fЎ…хщ–‹B0@fВ…ŸЂА‹B0@fЖ…ЄЇЦ‹B0@fК…ЉЌм‹B0@fП…ЎДї‹B0@fТ…ЖКŒB0@fЧ…МТ)ŒB0@fЭ…ФЫDŒB0@fв…Эв\ŒB0@fз…дкtŒB0@fн…муŒB0@fр…ыюЏŒB0@fу…№ѓЮŒB0@fч…ѕљэŒB0@fщ…ћўB0@fь…ЂŠ эœ"‘АŠ@€4эœ##@ €юœ%%=@ €яœ&&_@ €№œ''€@ €ёœ((Ё@ €ђœ))Т@ €ѓœ**хB0@€јœrvхB0@€ќœ,/ŽB0@€œ14ŽB0@€œ69:ŽB0@€ œ;AZŽB0@€ œCGyŽB0@€œIO–ŽB0@€œQXЖŽB0@€œZ_гŽB0@€!œag№ŽB0@€'œipB0@€*œx{5B0@€-œ}€YB0@€1œ‚†}B0@€3œˆ‹™B0@€6œЙ š6В™АŠ@˜46В›› 18Г™Ь@ ˜9Гъ@ ˜:Гžž@ ˜;ГŸŸ$@ ˜<Г  A@ ˜=ГЁЁ`B0@˜BГќ`B0@˜FГЃІ{B0@˜JГЈЋ’B0@˜NГ­АЉB0@˜SГВЛХB0@˜VГНФрB0@˜[ГЦЬљB0@˜aГЮи‘B0@˜fГкт.‘B0@˜kГфъG‘B0@˜qГьњc‘B0@˜tГ „‘B0@˜wГ Є‘B0@˜{ГФ‘B0@˜}Гм‘B0@˜€Ге€ €ГˆŠЛ€ €Г…‡А€ Г‚‚І€ ‚Гј‘J џџƒГzz’ ЖƒХ&v€ 1…Ц&v ’$Е†Ц))7’@0@ЕŠЦ147’@0@ЕЦ,/N’@0@ЕЦ;>N’H0@Е’Ц69f’H0@Е”Ц@C€’H0@Е–ЦEHЊ’H0@Е™ЦaeЊ’H0@ЕœЦJMЧ’@0@ЕŸЦOSх’@0@ЕЂЦUY“H0@ЕЅЦ[_ “H0@ЕЈЦgj>“H0@ЕЋЦloј‘ ЕЌЦrr\“4Е­Цssu“4ЕЎЦtt“4ЕЏЦuu№АЦ""ыБЦ!!р ВЦж ГЦ“€ @џџЕЦ{€ @џџЗЦ~~U€ @џџЛЦ||  @џџМЦ     !#%')+-/13579;=>@COQTWZ]hf€šАБВГЖЩЪЫЬ "$&(*,.02468:<?ABEGIKMDFHJLNRPUSXV[Y^_abcd\`egjklmnopqrstuvwxyz{|}~i‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—™›œžŸ ЁЂЃЄЅІЇЈЉЊЋЌ­ЎЏ˜ЗИЙКЛМНОПРСТУФХЦЧШЕыl'mdmЁmнm3nŠnсn4oqo­oщo'p_p‘pФpїp)qpqИqrDrwrЉrлrsЂЫ=sLsЂЫ=sLsЂЫ=sLsЂЫ=sLsЂЫ=sLsrsЂЫ=sLsrsЂЫ=sLsrsЂЫ=sLsrsЂЫ=sLsЂЫ=sLsЂЫ=sLsЂЫ=sLsЂЫ=sLsЂЫ=sLsЂЫ=sLsЂЫ•sЂsРs`хs”t/tЂЫБtЂsРs`хs”ТtпtЂЫБtЂsРs`хs”_uЂЫБtЂsРs`хs”t/tЂЫБtЂsРs`хs”ТtпtЂЫБtЂsРs`хs”_uЂЫБtСuЂЫБtЂЫБtv~vЂЫБtvГvЂЫ=sЭvЂЫБtёvwЂЫБt@ххF>@цц`> ъъ~>ыы_= Ёгœ> ХХœ>@ ЙЙЋ>@ ККЛ>@ ЛЛЩ>@ ММй> РРэ> СС? "ТТ? %УУ+? (ЦЦ>?4 )ЧЧс; )CK?,//K?@/##K?@1""\?@3$$n?7,,n?:++n?B=''„?@--„?BC((š?F00Ў?4G22D; @џџHђђ:; @џџIёёЈ: Jрр> @џџK  > @џџL  я= @џџNх= @џџOє< @џџPч< @џџQššЦ< @џџS––М< @џџT““7< @џџVз; @џџWЫ; @џџXО; @џџYБ; @џџZЄ; @џџ[˜; @џџ\§§Œ; @џџ]ќќ~; @џџ^ћћm; @џџ`јјO; @џџaѕѕ-; @џџbяя ; @џџcюю; @џџdээ; @џџeыыё: @џџfшшд: @џџgччР: @џџhццЎ: @џџiххž: @џџjмм: @џџkЫЫ†: @џџlЪЪv: @џџmЩЩj: @џџnШШd: @џџoХХY: @џџpФФL: @џџqУУ9: @џџrЙЙ-: @џџsИИ: @џџtЗЗ: @џџuВВ : @џџvББё9 @џџwААх9 @џџxЉЉл9 @џџyЅЅЭ9 @џџz  Љ9 @џџ{””—9 @џџ|‹‹‰9 @џџ}‚‚z9 @џџ~xxh9 @џџ]]`9 @џџ€II8 @џџ…>>8 @џџŠ==a8 @џџ<<08 @џџ”;;8 @џџ•##ь7 @џџ–Ъ7 @џџ˜  Ў7 @џџšŽ7 @џџ›h7 @џџœќќW7 @џџЂнн37 @џџЈмм7 @џџЉжж§6 @џџЊббт6 @џџЌЧЧЭ6 @џџЎННЋ6 @џџБББ‰6 @џџГЇЇ\6 @џџЕžž36 @џџЖšš6 @џџЗ™™Џ5 @џџЙŠŠ—5 @џџК~~„5 @џџЛxxU5 @џџМssI5 @џџНll.5 @џџОgg5 @џџПff5 @џџСdd5 @џџУccП4 @џџФTTБ4 @џџХPP™4 @џџЦMM…4 @џџЧIIv4 @џџШEEf4 @џџЩAAU4 @џџЪ::G4 @џџЫ8884 @џџЬ55%4 @џџЭ444 @џџЮ33 4 @џџЯ00ђ3 @џџа++к3 Dџџб Ю3 @џџв Б @џџг  %    !"‡ђї ќ  ЂЫЂЫї !4ї !4ЂЫJ^ЂЫЂЫї ї ї uƒї uƒї uƒї uƒ”J^ЂЂЫЉОЂЫ‡ђжЂЫЂЫї н‡ђьї нї ‡ђжї нї ‡ђжЉО‡ђ$є5:GPCєї ЂЫcetc}—ŸЁ} АЩЃЈ­ГРУЪЭgђ} ау$єіcџcџ ЂЫЂЫc-c5EААЙШШЂЫААЩбіћ іћ 5іћ Yіћ |˜*/*ЛРгюѓЪЬї гюѓЪЬї ћYП* *…*лф*.*|ЊмЃЫ(АЩ} } ЏЧлъ ъ} } АЩАЩ} } ю} АЩ} } } • ЂЫЂЫфOht˜G488#6:ЫйP<]enu9:Йy;јљ=5cdŠТ=ты+Tы4[k5pЋ6Бt<ag‰Š‹є<ˆќ§SYˆн!ШЪ8>C];ї&ммннэюf4@A&:ЗЙf=ЊР  +ј;ыO;ѕ˜X8;:З˜;§a a8<Aс;"#$+,-//006:>jp{‘Š:Ъ~Љ 40Ъ7 3 :БЯсљ =‰Š‹Š=ДМЮ“8=:Ваjp{‘;э“;ќ<GS=‹г=|% <5gќ9АЗ|<agМ<s†“…4HIn!м.5gŠЎ72Ў:хёww!7<Z‚€6ЂЋЕСЫгиР:цђ<Z`p‘щ/щ5ŽЉ7Љ9’”РСТУщ;2Mђ3')+РСТУВ8>r=ЎС5fŠл9ЄЅл=ф! d:ОХдЄ;‚ŠŠŽ +Э#  %&+  ј 5ccddЭ5ŠЭ6НуцM7ммннээююЭ9œž GЁе<agVcV6•V;ѕП4RTVY\]т8=B?=Šh7ќ'H8 ;;<<==>>@ABCh9Y[]Ј:рББ4P5dfgQ7ммннээюю;;<<==>>@@AABBCCQ8;;<<==>>@@AABBCCё9АЮпё:шБ;Б=оъњ!#њ!Зк3 7жы)z9 rux”'(+,-ъы:;ё6”™ЃТдC8;;<<==>>@@AABBCCC<\]enu>  Pbiuь75Ь8BL:МУвŒ;ќе#& U4:=U5oqs}u8<е<ƒ–˜о4[ž:м~;ћО;о<ƒ˜~=ВТ'ZgMPS] Ѕч<…špOh˜08;@  (Ztˆ‘˜Їл™4LMY:НФгY<_kyт6Чфч ФЮуфЫ:цЫ;д8Cд:ч> }6  ЉГПЩ'§6бъН8@§:шЦab:АВМО†:Ъи†;ћ<(-{Ц<–Џ5ŠŽ™šЖ/<Uя=845x6ž ЂЇЉЋБГЕЖНПСФЧЩЫЮууффцч 23И:хцС9™A:Лj*6”j:Шжj<`j{ѓ Їл36•šЌЬй37мэѓ;'+,j3=Š\6žœ<ag%ag‰Š‹%44%5fх9ЉЅ= емрхцъыюђх=%> Юfil‚‹Ю3 Ž70439JЅйз4Z—5~€W7ню—9‡‰‹з;W=‹р/0ЈЌАДХЦмрр5Š`9HI ;ю <UWhw =ЧI5kl}Лў‰6ЇI7ммннээюю‰9~€‚’=ЖУ{7ќФ#   %&+„5wx’Ф6БЗD7ммннээююФ8AD;ђm:-:И-;яm;јЖЏоЖEv4DEv:Щзv;јјЖ<p‘АЛЪ_4:п:чŸ;§=‰_= ЁЈЌЙКРСТУХХЦЦ Dџџ:: Dџџ••P/ @џџгг/@џџЬЬ- @џџЛг-@џџЅЅю/@0ММ0@0НН30@0ООY0@0ПП{0@0РР™0@ СЦТ0@0 ТТѓ0@0 УУ%1@0  ФФX1@0  ХХŒ1@0 ЦЦА1@0 ЧЧб1@0 ШШє1@0ЩЩ 2@0ЪЪK2@0ЫЫv2@0ЬЬ”2@0ЭЭМ2@0ЮЮл2@0ЯЯњ2@0аа3@0бб83@0ввQ. @џџЖЖK. @џџЖЖ%. @џџВЖ]3@0ГГq3@0ДД„3@0ЕЕ . @џџЏЏљ- @џџЏЏз- @џџЋЏ˜3@0%­­Г3@0% ЎЎШ-@џџ ЉЉЙ- @џџ!ЈЈЊ- @џџ"ЇЇ–-@џџ"ІІc @џџ#Э @џџ$А @џџ%– @џџ&ўўŽ @џџ'љљ= @џџ(нн6 @џџ)мм @џџ*ббэ @џџ+ППг @џџ,ЖЖн/ @џџ.ѕѕТ/ @џџ0ъъІ/ Dџџ1ффw/ Dџџ2ооY. @џџ3дд. @џџ4ЗЗЈ+ @џџAŸŸI+ @џџLœœ- @џџY˜˜ц, @џџe””ч* @џџqŠ* @џџ}5* @џџ‰ŠŠр) @џџ™‡‡‹) @џџЇ„„6) @џџДс( @џџО~~K- @џџХ{{Œ( @џџЭxx3( @џџкuuж' @џџхrrv' @џџѓnn' @џџџjjИ& @џџ gge& @џџdd& @џџ'aaП% @џџ5^^l% @џџB[[% @џџLXXU, @џџRUUУ$ @џџZRR%, Dџџ[PP, @џџ]OOќ+ @џџ_NNй+ @џџaMMz+ @џџlBB+ @џџu??Ж* @џџ<<a* @џџŠ99 * @џџ•66З) @џџЄ33b) @џџБ00 ) @џџМ--И( @џџХ**c( @џџЬ''( @џџз##Љ' @џџр  F' @џџьу& @џџі& @џџ=& @џџ ъ% @џџ—% @џџ(D% @џџ3  ё$ @џџ<ƒ$ @џџC$ @џџHшшц# @џџRии‹# @џџZШШV# @џџcНН0# @џџpВВ # @џџ{ЇЇе" @џџ„œœ " @џџ‘‘‘k" @џџœ††6" @џџЅ{{" @џџЌpp“! @џџБee‰! @џџВ^^! @џџГZZw! @џџДUUa! @џџЕ==M! @џџЖ99.! @џџЗ33! @џџЙ++! @џџК##і @џџЛш @џџМи @џџНЛ @џџО  ž @џџП} @џџРіі$ @џџСооі @џџТггл @џџУССТ @џџФЗЗЋ @џџХББi @џџЧЇЇ€ @џџШ——R @џџЩŒŒ* @џџЪ! @џџЫzzя @џџЭooЬ @џџЮff‘ @џџЯ``P @џџбPP @џџгBBя @џџе;;Ъ @џџз11Š @џџи((w @џџй$$c @џџк!!C @џџл" @џџм   @џџнњ @џџољљр Dџџпёёз @џџрщщЮ @џџсппЦ @џџтее @џџуЮЮg @џџфППX @џџхЕЕ9 @џџчЃЃC @џџщЂЂ @џџыžž" @џџэj @џџю @џџяџ @џџ№      !"&'iђ‡ђ‹ђ‹ђ˜ђЋђFёЖђРђРђЦђ‡ђ‡ђРђРђРђєђРђќђ ѓ$ѓ$ѓ:ѓKѓ]ѓmѓmѓmѓ|ѓ—ѓАѓПѓЮѓыѓ єєє‡ђ‡ђmѓmѓ)є)є3є:єCєЂЫTЬЂЫЂЫЂЫЂЫEє”єžєЈєИєЧєаєеєнєфєьєѓєћєѕ”єžєЈєИєЧєаєеєнєфєьєJѕъѕіѕ”єžєіИєЧєаєеєнєфєьєіъѕіѕ”єžєіЧєаєеєнєфєьєЏіъѕіѕ”єžєЈєі=їЧєаєеєнєNїъѕіѕ”єžєЈє’їšїЁїЉїЧєаєАїъѕіѕ”єžєЈє’їšїЧєаєеєнєєїъѕіѕ”єžєЈєЧєаєеєнєфєьєѓєћєFјNјUјъѕіѕ”єžєЈєЧєаєеєнєфєьєѓєћє јъѕіѕ”єžєЈєИєЧєаєеєнєфєьєфјъѕіѕ”єžєЈєЧєаєеєнє!љъѕіѕ”єžєЧєаєYљъѕіѕ”єžєЈєЧєаєEє”єžєЈєИєЧєаєеєнєфєьєѓєћєѕ”єžєЈєИєЧєаєеєнєфєьєљъѕіѕ”єžєі=їИєЧєаєеєнєфєьєЏіъѕіѕ”єžєЈєі=їЧєаєеєнєNїъѕіѕ”єžєЈє’їšїЁїЉїЧєаєАїъѕіѕ”єžєЈє’їšїЧєаєеєнєєїъѕіѕ”єžєЈєЧєаєеєнєфєьєѓєћєFјNјUјъѕіѕ”єžєЈєЧєаєеєнєфєьєѓєћє јъѕіѕ”єžєЈєИєЧєаєеєнєфєьєфјъѕіѕ”єžєЈєЧєаєеєнє-њъѕ”єžєЧєаєYљъѕіѕ”єžєЈєЧєаєЂЫЂЫeњЂЫeњЂЫeњsњ”єžєЧєаєеєнєфєьєѓєћєжњ”єžєЧєаєеєнєфєьє1ћъѕіѕ”єžєіЧєаєеєнє•ћъѕіѕ”єžє’їšїЁїЉїЧєаєяћъѕіѕ”єžє’їšїЧєаєеєнєIќъѕіѕ”єžєЧєаєеєнєфєьєѓєћєFјNјГќъѕіѕ”єžєЧєаєеєнєфєьєѓєћє§ъѕіѕ”єžєЧєаєеєнєфєьєs§ъѕіѕ”єžєЧєаєеєнєХ§ъѕіѕ”єžєЧєаєў”єžєЧєаєеєнєфєьєѓєћєqў”єžєЧєаєеєнєфєьєЫўъѕіѕ”єžєіЧєаєеєнєфєьє4џъѕіѕ”єžєіЧєаєеєнє—џъѕіѕ”єžє’їšїЁїЉїЧєає№џъѕіѕ”єžє’їšїЧєаєеєнєIъѕіѕ”єžєЧєаєеєнєфєьєѓєћєFјNјВъѕіѕ”єžєЧєаєеєнєфєьєѓєћєъѕіѕ”єžєЧєаєеєнєфєьєpъѕіѕ”єžєЧєаєеєнєСъѕіѕ”єžєЧєає ъѕžєЧєМСъѕžєіЧєаєеєнєфєьєгъѕžєіЧєаєеєнєкъѕžє’їšїЁїЉїЧєає[ъѕžє’їšїЧєаєеєнєфєьєѓєћєђъѕžє’їšїЧєаєеєнєфєьє~ъѕžє’їšїЧєаєеєнєџъѕžєЧєаєеєнєфєьєѓєћєFјNј–ъѕžєЧєаєеєнєфєьєѓєћє" ъѕžєЧєаєеєнєфєьєЃ ъѕžєЧєаєеєнє ъѕžєЧєає„ ‘ •  В ЂЫЦ CєЂЫЂЫм ЂЫЂЫЂЫЂЫЂЫЂЫЂЫЂЫЂЫт t } АЩАЩЂЫ 2 ; ЂЫ@ \ ЂЫ\ i \  6 } < P ЂЫЂЫX • ЂЫЂЫЂЫ` ЂЫЂЫX v …  … ‘ Ѕ Ќ Ѕ gђЂЫЂЫTЧOOOOOOаOOOOOOPfv fv fv fv fv fv PIKNPIKNPIKNPIKNPIKNPIKNPP$ыээяыээяыээяыээяыээяыээяP/гггггга/ я№я№я№я№я№я№9BHNBHNBHNBHNBHNBHN9 ЁЃЁЃЁЃЁЃЁЃЁЃЙ!њejpu{€†‹‘–œЁЇЌВЗНТШЯипшэѕіїјљњћќ§ўџ   '(*+-.0134679:<=NPRZahnu{}‡Ž•›ЅЌВДЖОХЬвйпсуыђљџ &,39;=ELSY`fhjry€†“•—ŸІ­ГКРТФЮзф№§#)+-7@MYfqx…Œіїљњќ§џ    "#%&()+,./1245789;<=?@ARSUVXY[\^_abdeghjklnopxy{|~‚„…‡ˆŠ‹Ž‘’”•–˜™šejpu{€†‹‘–œЁЇЌВЗНТШЯипшэѕіїјљњћќ§ўџ   '(*+-.0134679:<=NPRZahnu{}‡Ž•›ЅЌВДЖОХЬвйпсуыђљџ &,39;=ELSY`fhjry€†“•—ŸІ­ГКРТФЮзф№§#)+-7@MYfqx…Œіїљњќ§џ    "#%&()+,./1245789;<=?@ARSUVXY[\^_abdeghjklnopxy{|~‚„…‡ˆŠ‹Ž‘’”•–˜™šejpu{€†‹‘–œЁЇЌВЗНТШЯипшэѕіїјљњћќ§ўџ   '(*+-.0134679:<=NPRZahnu{}‡Ž•›ЅЌВДЖОХЬвйпсуыђљџ &,39;=ELSY`fhjry€†“•—ŸІ­ГКРТФЮзф№§#)+-7@MYfqx…Œіїљњќ§џ    "#%&()+,./1245789;<=?@ARSUVXY[\^_abdeghjklnopxy{|~‚„…‡ˆŠ‹Ž‘’”•–˜™šejpu{€†‹‘–œЁЇЌВЗНТШЯипшэѕіїјљњћќ§ўџ   '(*+-.0134679:<=NPRZahnu{}‡Ž•›ЅЌВДЖОХЬвйпсуыђљџ &,39;=ELSY`fhjry€†“•—ŸІ­ГКРТФЮзф№§#)+-7@MYfqx…Œіїљњќ§џ    "#%&()+,./1245789;<=?@ARSUVXY[\^_abdeghjklnopxy{|~‚„…‡ˆŠ‹Ž‘’”•–˜™šejpu{€†‹‘–œЁЇЌВЗНТШЯипшэѕіїјљњћќ§ўџ   '(*+-.0134679:<=NPRZahnu{}‡Ž•›ЅЌВДЖОХЬвйпсуыђљџ &,39;=ELSY`fhjry€†“•—ŸІ­ГКРТФЮзф№§#)+-7@MYfqx…Œіїљњќ§џ    "#%&()+,./1245789;<=?@ARSUVXY[\^_abdeghjklnopxy{|~‚„…‡ˆŠ‹Ž‘’”•–˜™šejpu{€†‹‘–œЁЇЌВЗНТШЯипшэѕіїјљњћќ§ўџ   '(*+-.0134679:<=NPRZahnu{}‡Ž•›ЅЌВДЖОХЬвйпсуыђљџ &,39;=ELSY`fhjry€†“•—ŸІ­ГКРТФЮзф№§#)+-7@MYfqx…Œіїљњќ§џ    "#%&()+,./1245789;<=?@ARSUVXY[\^_abdeghjklnopxy{|~‚„…‡ˆŠ‹Ž‘’”•–˜™šЙ#АШгиуўџ<==РТФХвлш #)+-.;DQqsxz…Œ79;==?AAjlnp’”––˜ššШгиуўџ<==РТФХвлш #)+-.;DQqsxz…Œ79;==?AAjlnp’”––˜ššШгиуўџ<==РТФХвлш #)+-.;DQqsxz…Œ79;==?AAjlnp’”––˜ššШгиуўџ<==РТФХвлш #)+-.;DQqsxz…Œ79;==?AAjlnp’”––˜ššШгиуўџ<==РТФХвлш #)+-.;DQqsxz…Œ79;==?AAjlnp’”––˜ššШгиуўџ<==РТФХвлш #)+-.;DQqsxz…Œ79;==?AAjlnp’”––˜ššЙ$     !#$'(*+-.0134679:<=?@BCNR{ВЖпу 9=fj“—РФ)-’–УЧіїљњќ§џ    "#%&()+,./1245789;<=?@ACDFGRSUVXY[\^_abdeghjklnoprsuvxy{|~‚„…‡ˆŠ‹Ž‘’”•–˜™šœŸ     !#$'(*+-.0134679:<=?@BCNR{ВЖпу 9=fj“—РФ)-’–УЧіїљњќ§џ    "#%&()+,./1245789;<=?@ACDFGRSUVXY[\^_abdeghjklnoprsuvxy{|~‚„…‡ˆŠ‹Ž‘’”•–˜™šœŸ     !#$'(*+-.0134679:<=?@BCNR{ВЖпу 9=fj“—РФ)-’–УЧіїљњќ§џ    "#%&()+,./1245789;<=?@ACDFGRSUVXY[\^_abdeghjklnoprsuvxy{|~‚„…‡ˆŠ‹Ž‘’”•–˜™šœŸ     !#$'(*+-.0134679:<=?@BCNR{ВЖпу 9=fj“—РФ)-’–УЧіїљњќ§џ    "#%&()+,./1245789;<=?@ACDFGRSUVXY[\^_abdeghjklnoprsuvxy{|~‚„…‡ˆŠ‹Ž‘’”•–˜™šœŸ     !#$'(*+-.0134679:<=?@BCNR{ВЖпу 9=fj“—РФ)-’–УЧіїљњќ§џ    "#%&()+,./1245789;<=?@ACDFGRSUVXY[\^_abdeghjklnoprsuvxy{|~‚„…‡ˆŠ‹Ž‘’”•–˜™šœŸ     !#$'(*+-.0134679:<=?@BCNR{ВЖпу 9=fj“—РФ)-’–УЧіїљњќ§џ    "#%&()+,./1245789;<=?@ACDFGRSUVXY[\^_abdeghjklnoprsuvxy{|~‚„…‡ˆŠ‹Ž‘’”•–˜™šœŸ Й- ЈЎЈЎЈЎЈЎЈЎЈЎыffffffk" †ј†ј†ј†ј†ј†јk. МФМФМФМФМФМФы.ЪЪЪЪЪЪt.ННННННнRRRRRRн! fq|‡’ЈГОЩйщн#hбвгстуТХабвйклцчшђѓєџ #%+.9:;BCDOPQ[\]hijqsxz…‡ŒŽбвгстуТХабвйклцчшђѓєџ #%+.9:;BCDOPQ[\]hijqsxz…‡ŒŽбвгстуТХабвйклцчшђѓєџ #%+.9:;BCDOPQ[\]hijqsxz…‡ŒŽбвгстуТХабвйклцчшђѓєџ #%+.9:;BCDOPQ[\]hijqsxz…‡ŒŽбвгстуТХабвйклцчшђѓєџ #%+.9:;BCDOPQ[\]hijqsxz…‡ŒŽбвгстуТХабвйклцчшђѓєџ #%+.9:;BCDOPQ[\]hijqsxz…‡ŒŽн/ єѕєѕєѕєѕєѕєѕІ&&&&&&І/ тфтфтфтфтфтфBехнъіFS_lљехнъіFS_lљехнъіFS_lљехнъіFS_lљехнъіFS_lљехнъіFS_lљ˜)++ѕѕ)++ѕѕ)++ѕѕ)++ѕѕ)++ѕѕ)++ѕѕmoomoomoomoomoomoo˜.РРРРРРaŽЈ7MјŽЈ7MјŽЈ7MјŽЈ7MјŽЈ7MјŽЈ7Mјa„„„„„„a!<=FG<=FG<=FG<=FG<=FG<=FGс(+ќ%~+ќ%~+ќ%~+ќ%~+ќ%~+ќ%~a*999999ЪOOOOOOЪ$13;oЇљ13;oЇљ13;oЇљ13;oЇљ13;oЇљ13;oЇљг0ЇЉЋЏПШбЇЉЋЏПШбЇЉЋЏПШбЇЉЋЏПШбЇЉЋЏПШбЇЉЋЏПШбS„„„„„„гЖЖЖЖЖЖМOOOOOOМ 010101010101EGLNSUY[`b)+.7:;@CDMPQY\]fijqsxz…‡ŒŽ’”—ž ЅЇЌЎВЕЛОУХШЯбжинпуцьяџ()+,./;<=?@ACDFG[\^_abnoprsuv‚„…‡ˆ”•–˜™šœŸ {€‚†‹‘–˜ЇЌЎВЗЙиптуїјљћќџ   !#$-.0134?@BCпсфыэђєљћџ !&(,.359;>EGLNSUY[`b)+.7:;@CDMPQY\]fijqsxz…‡ŒŽ’”—ž ЅЇЌЎВЕЛОУХШЯбжинпуцьяџ()+,./;<=?@ACDFG[\^_abnoprsuv‚„…‡ˆ”•–˜™šœŸ {€‚†‹‘–˜ЇЌЎВЗЙиптуїјљћќџ   !#$-.0134?@BCпсфыэђєљћџ !&(,.359;>EGLNSUY[`b)+.7:;@CDMPQY\]fijqsxz…‡ŒŽ’”—ž ЅЇЌЎВЕЛОУХШЯбжинпуцьяџ()+,./;<=?@ACDFG[\^_abnoprsuv‚„…‡ˆ”•–˜™šœŸ {€‚†‹‘–˜ЇЌЎВЗЙиптуїјљћќџ   !#$-.0134?@BCпсфыэђєљћџ !&(,.359;>EGLNSUY[`b)+.7:;@CDMPQY\]fijqsxz…‡ŒŽ’”—ž ЅЇЌЎВЕЛОУХШЯбжинпуцьяџ()+,./;<=?@ACDFG[\^_abnoprsuv‚„…‡ˆ”•–˜™šœŸ {€‚†‹‘–˜ЇЌЎВЗЙиптуїјљћќџ   !#$-.0134?@BCпсфыэђєљћџ !&(,.359;>EGLNSUY[`b)+.7:;@CDMPQY\]fijqsxz…‡ŒŽ’”—ž ЅЇЌЎВЕЛОУХШЯбжинпуцьяџ()+,./;<=?@ACDFG[\^_abnoprsuv‚„…‡ˆ”•–˜™šœŸ {€‚†‹‘–˜ЇЌЎВЗЙиптуїјљћќџ   !#$-.0134?@BCпсфыэђєљћџ !&(,.359;>EGLNSUY[`b)+.7:;@CDMPQY\]fijqsxz…‡ŒŽ’”—ž ЅЇЌЎВЕЛОУХШЯбжинпуцьяџ()+,./;<=?@ACDFG[\^_abnoprsuv‚„…‡ˆ”•–˜™šœŸ  мтмтмтмтмтмт  љUSVY\_behklopsvy|‚…ˆ‹Ž‘’•–™š Э M!89BC89BC89BC89BC89BC89BCЭ#ДЫЬелмхЩЪнпръьэіјљ23FHISUV_ablЫЬелмхЩЪнпръьэіјљ23FHISUV_ablЫЬелмхЩЪнпръьэіјљ23FHISUV_ablЫЬелмхЩЪнпръьэіјљ23FHISUV_ablЫЬелмхЩЪнпръьэіјљ23FHISUV_ablЫЬелмхЩЪнпръьэіјљ23FHISUV_abl )------, ž ž ž ž ž ž  –OOьOOьOOьOOьOOьOOьV Ђ!Ђ!Ђ!Ђ!Ђ!Ђ!V– ўžўžўžўžўžўžV# Н§Н§Н§Н§Н§Н§ж'!’r!’r!’r!’r!’r!’r–- ІЈІЈІЈІЈІЈІЈџ$ЕЪЕЪЕЪЕЪЕЪЕЪOO„OO„OO„OO„OO„OO„ХШЪЮХШЪЮХШЪЮХШЪЮХШЪЮХШЪЮП% ^ ^ ^ ^ ^ ^-ЅЇЛЅЇЛЅЇЛЅЇЛЅЇЛЅЇЛ счсчсчсчсчсчH„ь„ь„ь„ь„ь„ьШ- ЉвЉвЉвЉвЉвЉв‘VX[`VX[`VX[`VX[`VX[`VX[`‘"ž†‹‘–ВЗјљќ#$0134BC &,39;=ELSY`УХЧЯжнуь+,./FG^_abuv„…‡ˆŸ †‹‘–ВЗјљќ#$0134BC &,39;=ELSY`УХЧЯжнуь+,./FG^_abuv„…‡ˆŸ †‹‘–ВЗјљќ#$0134BC &,39;=ELSY`УХЧЯжнуь+,./FG^_abuv„…‡ˆŸ †‹‘–ВЗјљќ#$0134BC &,39;=ELSY`УХЧЯжнуь+,./FG^_abuv„…‡ˆŸ †‹‘–ВЗјљќ#$0134BC &,39;=ELSY`УХЧЯжнуь+,./FG^_abuv„…‡ˆŸ †‹‘–ВЗјљќ#$0134BC &,39;=ELSY`УХЧЯжнуь+,./FG^_abuv„…‡ˆŸ Q.ЖЖЖЖЖЖ/ ЬЬЬЬЬЬЬЬЬЬЬЬ@:::::z OOOOOOOOOOOOњѕїљѕїљѕїљѕїљѕїљѕїљњ! lw‚˜ЃЎЙФгуяz+BBBBBBУOOOOOOC ЂЃЂЃЂЃЂЃЂЃЂЃC#ŒœЁЃЇЌЎВЗЙНТФњћќ§679:fhkrty{€‚†ˆ“•˜ŸЁІЈ­ЏГЕКМ   1245deghŠ‹ŽœЁЃЇЌЎВЗЙНТФњћќ§679:fhkrty{€‚†ˆ“•˜ŸЁІЈ­ЏГЕКМ   1245deghŠ‹ŽœЁЃЇЌЎВЗЙНТФњћќ§679:fhkrty{€‚†ˆ“•˜ŸЁІЈ­ЏГЕКМ   1245deghŠ‹ŽœЁЃЇЌЎВЗЙНТФњћќ§679:fhkrty{€‚†ˆ“•˜ŸЁІЈ­ЏГЕКМ   1245deghŠ‹ŽœЁЃЇЌЎВЗЙНТФњћќ§679:fhkrty{€‚†ˆ“•˜ŸЁІЈ­ЏГЕКМ   1245deghŠ‹ŽœЁЃЇЌЎВЗЙНТФњћќ§679:fhkrty{€‚†ˆ“•˜ŸЁІЈ­ЏГЕКМ   1245deghŠ‹Žƒ$У$NїRNїRNїRNїRNїRNїRƒ,žŸžŸžŸžŸžŸžŸУ.ЧЧЧЧЧЧC/ввввввl OOOOOOOOOOOO,ууууууЌЫЫЫЫЫЫl$ эяэяэяэяэяэяl% п[ п[ п[ п[ п[ п[5*71Š71Š71Š71Š71Š71Š5/аааааао ээээээээээээээээээээээээ$Y_kq}ƒY_kq}ƒY_kq}ƒY_kq}ƒY_kq}ƒY_kq}ƒ^эо113113113113113113ž ž.ТТТТТТ^/лллллл'R:R•:R•:R•:R•:R•gЛНПЛНПЛНПЛНПЛНПЛНП'"^pu{€†‹‘–œЁЇЌВЗШЯипіїјљњћќўџ    !#$*+-.013467<=?@BCВДЖОХЬвйпсуыђљџ &,39;=ELSY`fhjry€†РТФЮзф№§#)+-7@MYfqx…Œ’”–žЅЌВЛУХЧЯжнуьќ§џ %&()+,./12789;<=?@ACDFGXY[\^_abdejklnoprsuv~‚„…‡ˆŠ‹‘’”•–˜™šœŸ pu{€†‹‘–œЁЇЌВЗШЯипіїјљњћќўџ    !#$*+-.013467<=?@BCВДЖОХЬвйпсуыђљџ &,39;=ELSY`fhjry€†РТФЮзф№§#)+-7@MYfqx…Œ’”–žЅЌВЛУХЧЯжнуьќ§џ %&()+,./12789;<=?@ACDFGXY[\^_abdejklnoprsuv~‚„…‡ˆŠ‹‘’”•–˜™šœŸ pu{€†‹‘–œЁЇЌВЗШЯипіїјљњћќўџ    !#$*+-.013467<=?@BCВДЖОХЬвйпсуыђљџ &,39;=ELSY`fhjry€†РТФЮзф№§#)+-7@MYfqx…Œ’”–žЅЌВЛУХЧЯжнуьќ§џ %&()+,./12789;<=?@ACDFGXY[\^_abdejklnoprsuv~‚„…‡ˆŠ‹‘’”•–˜™šœŸ pu{€†‹‘–œЁЇЌВЗШЯипіїјљњћќўџ    !#$*+-.013467<=?@BCВДЖОХЬвйпсуыђљџ &,39;=ELSY`fhjry€†РТФЮзф№§#)+-7@MYfqx…Œ’”–žЅЌВЛУХЧЯжнуьќ§џ %&()+,./12789;<=?@ACDFGXY[\^_abdejklnoprsuv~‚„…‡ˆŠ‹‘’”•–˜™šœŸ pu{€†‹‘–œЁЇЌВЗШЯипіїјљњћќўџ    !#$*+-.013467<=?@BCВДЖОХЬвйпсуыђљџ &,39;=ELSY`fhjry€†РТФЮзф№§#)+-7@MYfqx…Œ’”–žЅЌВЛУХЧЯжнуьќ§џ %&()+,./12789;<=?@ACDFGXY[\^_abdejklnoprsuv~‚„…‡ˆŠ‹‘’”•–˜™šœŸ pu{€†‹‘–œЁЇЌВЗШЯипіїјљњћќўџ    !#$*+-.013467<=?@BCВДЖОХЬвйпсуыђљџ &,39;=ELSY`fhjry€†РТФЮзф№§#)+-7@MYfqx…Œ’”–žЅЌВЛУХЧЯжнуьќ§џ %&()+,./12789;<=?@ACDFGXY[\^_abdejklnoprsuv~‚„…‡ˆŠ‹‘’”•–˜™šœŸ ч*=7=7=7=7=7=7'/ЮЮЮЮЮЮpМлўМлўМлўМлўМлўМлўpMMMMMMА 0# ВќВќВќВќВќВќYxВv 7xВv 7xВv 7xВv 7xВv 7xВv 7$юіўтRюіўтRюіўтRюіўтRюіўтRюіўтRY!999999™" †‹‘–˜ВЗЙјљќ#$0134BC !&(,.359;>EGLNSUY[`bУХШЯбжинпуцья+,./FG^_abuv„…‡ˆŸ †‹‘–˜ВЗЙјљќ#$0134BC !&(,.359;>EGLNSUY[`bУХШЯбжинпуцья+,./FG^_abuv„…‡ˆŸ †‹‘–˜ВЗЙјљќ#$0134BC !&(,.359;>EGLNSUY[`bУХШЯбжинпуцья+,./FG^_abuv„…‡ˆŸ †‹‘–˜ВЗЙјљќ#$0134BC !&(,.359;>EGLNSUY[`bУХШЯбжинпуцья+,./FG^_abuv„…‡ˆŸ †‹‘–˜ВЗЙјљќ#$0134BC !&(,.359;>EGLNSUY[`bУХШЯбжинпуцья+,./FG^_abuv„…‡ˆŸ †‹‘–˜ВЗЙјљќ#$0134BC !&(,.359;>EGLNSUY[`bУХШЯбжинпуцья+,./FG^_abuv„…‡ˆŸ Y$ыээяыээяыээяыээяыээяыээя% В§X В§X В§X В§X В§X В§Xй+ IMIMIMIMIMIMY. КдКдКдКдКдКд"žшžшžшžшžшžш"            ЂЅЇЇЅЇЇЅЇЇЅЇЇЅЇЇЅЇЇb)000000‹# ШўШўШўШўШўШў‹)1+„1+„1+„1+„1+„1+„K- "{"{"{"{"{"{K. ЖРЖРЖРЖРЖРЖР*J‰”bFєJ‰”bFєJ‰”bFєJ‰”bFєJ‰”bFєJ‰”bFєT DGDGDGDGDGDG@BD@BD@BD@BD@BD@BD$ шшшшшш§$X^jp|‚X^jp|‚X^jp|‚X^jp|‚X^jp|‚X^jp|‚§llllll= нннннн} ѕіѕіѕіѕіѕіѕі=&Ц дедедедедедеF ъьэёъьэёъьэёъьэёъьэёъьэёЦ"Š‘–љ349;=ELSY`./ab‡ˆ‘–љ349;=ELSY`./ab‡ˆ‘–љ349;=ELSY`./ab‡ˆ‘–љ349;=ELSY`./ab‡ˆ‘–љ349;=ELSY`./ab‡ˆ‘–љ349;=ELSY`./ab‡ˆF' (######F,PP\cj}‰—ЇЎДРЧЮсэєћ!(;GNUht{‚•ЁЈЏТвлш +;DQsz” ЇЎХбипP\cj}‰—ЇЎДРЧЮсэєћ!(;GNUht{‚•ЁЈЏТвлш +;DQsz” ЇЎХбипP\cj}‰—ЇЎДРЧЮсэєћ!(;GNUht{‚•ЁЈЏТвлш +;DQsz” ЇЎХбипP\cj}‰—ЇЎДРЧЮсэєћ!(;GNUht{‚•ЁЈЏТвлш +;DQsz” ЇЎХбипP\cj}‰—ЇЎДРЧЮсэєћ!(;GNUht{‚•ЁЈЏТвлш +;DQsz” ЇЎХбипP\cj}‰—ЇЎДРЧЮсэєћ!(;GNUht{‚•ЁЈЏТвлш +;DQsz” ЇЎХбипяˆ79;DPY`gt†”ЄЋНФЫиъёј%2DKR_qxŒžЅЌЙЭжуќ"6?Lepw~‹ЄЋКЮемы #&),/2589<=@ADGSVY\_behklopsvy|‚…ˆ‹Ž‘’•–™š 79;DPY`gt†”ЄЋНФЫиъёј%2DKR_qxŒžЅЌЙЭжуќ"6?Lepw~‹ЄЋКЮемы #&),/2589<=@ADGSVY\_behklopsvy|‚…ˆ‹Ž‘’•–™š 79;DPY`gt†”ЄЋНФЫиъёј%2DKR_qxŒžЅЌЙЭжуќ"6?Lepw~‹ЄЋКЮемы #&),/2589<=@ADGSVY\_behklopsvy|‚…ˆ‹Ž‘’•–™š 79;DPY`gt†”ЄЋНФЫиъёј%2DKR_qxŒžЅЌЙЭжуќ"6?Lepw~‹ЄЋКЮемы #&),/2589<=@ADGSVY\_behklopsvy|‚…ˆ‹Ž‘’•–™š 79;DPY`gt†”ЄЋНФЫиъёј%2DKR_qxŒžЅЌЙЭжуќ"6?Lepw~‹ЄЋКЮемы #&),/2589<=@ADGSVY\_behklopsvy|‚…ˆ‹Ž‘’•–™š 79;DPY`gt†”ЄЋНФЫиъёј%2DKR_qxŒžЅЌЙЭжуќ"6?Lepw~‹ЄЋКЮемы #&),/2589<=@ADGSVY\_behklopsvy|‚…ˆ‹Ž‘’•–™š яkmokmokmokmokmokmo/"puw{€‚†‹‘–˜œЁЃЇЌЎВЗЙШЯвгипуіїјљњћќўџ    !#$*+-.013467<=?@BCВДЗОРХЧЬЮвдйлпсфыэђєљћџ !&(,.359;>EGLNSUY[`bfhkrty{€‚†ˆРТХЮбвзклфчш№ѓє§ #%)+.7;@DMQY]fjqsxz…‡ŒŽ’”—ž ЅЇЌЎВЕЛОУХШЯбжинпуцьяќ§џ %&()+,./12789;<=?@ACDFGXY[\^_abdejklnoprsuv~‚„…‡ˆŠ‹‘’”•–˜™šœŸ puw{€‚†‹‘–˜œЁЃЇЌЎВЗЙШЯвгипуіїјљњћќўџ    !#$*+-.013467<=?@BCВДЗОРХЧЬЮвдйлпсфыэђєљћџ !&(,.359;>EGLNSUY[`bfhkrty{€‚†ˆРТХЮбвзклфчш№ѓє§ #%)+.7;@DMQY]fjqsxz…‡ŒŽ’”—ž ЅЇЌЎВЕЛОУХШЯбжинпуцьяќ§џ %&()+,./12789;<=?@ACDFGXY[\^_abdejklnoprsuv~‚„…‡ˆŠ‹‘’”•–˜™šœŸ puw{€‚†‹‘–˜œЁЃЇЌЎВЗЙШЯвгипуіїјљњћќўџ    !#$*+-.013467<=?@BCВДЗОРХЧЬЮвдйлпсфыэђєљћџ !&(,.359;>EGLNSUY[`bfhkrty{€‚†ˆРТХЮбвзклфчш№ѓє§ #%)+.7;@DMQY]fjqsxz…‡ŒŽ’”—ž ЅЇЌЎВЕЛОУХШЯбжинпуцьяќ§џ %&()+,./12789;<=?@ACDFGXY[\^_abdejklnoprsuv~‚„…‡ˆŠ‹‘’”•–˜™šœŸ puw{€‚†‹‘–˜œЁЃЇЌЎВЗЙШЯвгипуіїјљњћќўџ    !#$*+-.013467<=?@BCВДЗОРХЧЬЮвдйлпсфыэђєљћџ !&(,.359;>EGLNSUY[`bfhkrty{€‚†ˆРТХЮбвзклфчш№ѓє§ #%)+.7;@DMQY]fjqsxz…‡ŒŽ’”—ž ЅЇЌЎВЕЛОУХШЯбжинпуцьяќ§џ %&()+,./12789;<=?@ACDFGXY[\^_abdejklnoprsuv~‚„…‡ˆŠ‹‘’”•–˜™šœŸ puw{€‚†‹‘–˜œЁЃЇЌЎВЗЙШЯвгипуіїјљњћќўџ    !#$*+-.013467<=?@BCВДЗОРХЧЬЮвдйлпсфыэђєљћџ !&(,.359;>EGLNSUY[`bfhkrty{€‚†ˆРТХЮбвзклфчш№ѓє§ #%)+.7;@DMQY]fjqsxz…‡ŒŽ’”—ž ЅЇЌЎВЕЛОУХШЯбжинпуцьяќ§џ %&()+,./12789;<=?@ACDFGXY[\^_abdejklnoprsuv~‚„…‡ˆŠ‹‘’”•–˜™šœŸ puw{€‚†‹‘–˜œЁЃЇЌЎВЗЙШЯвгипуіїјљњћќўџ    !#$*+-.013467<=?@BCВДЗОРХЧЬЮвдйлпсфыэђєљћџ !&(,.359;>EGLNSUY[`bfhkrty{€‚†ˆРТХЮбвзклфчш№ѓє§ #%)+.7;@DMQY]fjqsxz…‡ŒŽ’”—ž ЅЇЌЎВЕЛОУХШЯбжинпуцьяќ§џ %&()+,./12789;<=?@ACDFGXY[\^_abdejklnoprsuv~‚„…‡ˆŠ‹‘’”•–˜™šœŸ И''''''8иухбсТФайцђџ#+-9BO[hqx…Œ9=Alp’–šухбсТФайцђџ#+-9BO[hqx…Œ9=Alp’–šухбсТФайцђџ#+-9BO[hqx…Œ9=Alp’–šухбсТФайцђџ#+-9BO[hqx…Œ9=Alp’–šухбсТФайцђџ#+-9BO[hqx…Œ9=Alp’–šухбсТФайцђџ#+-9BO[hqx…Œ9=Alp’–šx$ эяэяэяэяэяэяИ&“ g“ g“ g“ g“ g“ gИ(******8.ДДДДДДИ/чччччч444444СээээээOOOOOOA„„„„„„!ZZZZZZ" pіpіpіpіpіpіA.ЕЕЕЕЕЕ*$!€ƒG!€ƒG!€ƒG!€ƒG!€ƒG!€ƒGj’’’’’’j №№№№№№ъ%Њ- Ї­Ї­Ї­Ї­Ї­Ї­Г''''''3шшъшшъшшъшшъшшъшшъѓ юіюіюіюіюіюі3AAAAAAѓ! itŠ• ЋЖСЮоьs$ эяэяэяэяэяэя3($Уu$Уu$Уu$Уu$Уu$Уu\"{€†‹‘–ЇЌВЗипїјљћќџ   !#$-.0134?@BCпсуыђљџ &,39;=ELSY`)+-7@MYfqx…Œ’”–žЅЌВЛУХЧЯжнуьџ()+,./;<=?@ACDFG[\^_abnoprsuv‚„…‡ˆ”•–˜™šœŸ {€†‹‘–ЇЌВЗипїјљћќџ   !#$-.0134?@BCпсуыђљџ &,39;=ELSY`)+-7@MYfqx…Œ’”–žЅЌВЛУХЧЯжнуьџ()+,./;<=?@ACDFG[\^_abnoprsuv‚„…‡ˆ”•–˜™šœŸ {€†‹‘–ЇЌВЗипїјљћќџ   !#$-.0134?@BCпсуыђљџ &,39;=ELSY`)+-7@MYfqx…Œ’”–žЅЌВЛУХЧЯжнуьџ()+,./;<=?@ACDFG[\^_abnoprsuv‚„…‡ˆ”•–˜™šœŸ {€†‹‘–ЇЌВЗипїјљћќџ   !#$-.0134?@BCпсуыђљџ &,39;=ELSY`)+-7@MYfqx…Œ’”–žЅЌВЛУХЧЯжнуьџ()+,./;<=?@ACDFG[\^_abnoprsuv‚„…‡ˆ”•–˜™šœŸ {€†‹‘–ЇЌВЗипїјљћќџ   !#$-.0134?@BCпсуыђљџ &,39;=ELSY`)+-7@MYfqx…Œ’”–žЅЌВЛУХЧЯжнуьџ()+,./;<=?@ACDFG[\^_abnoprsuv‚„…‡ˆ”•–˜™šœŸ {€†‹‘–ЇЌВЗипїјљћќџ   !#$-.0134?@BCпсуыђљџ &,39;=ELSY`)+-7@MYfqx…Œ’”–žЅЌВЛУХЧЯжнуьџ()+,./;<=?@ACDFG[\^_abnoprsuv‚„…‡ˆ”•–˜™šœŸ х -4-4-4-4-4-4%ууууууe&f df df df df df d%, LPLPLPLPLPLP%.ВВВВВВЅ.УУУУУУNЂЂЃЃЂЂЃЃЂЂЃЃЂЂЃЃЂЂЃЃЂЂЃЃЮймпймпймпймпймпймпŽ љћљћљћљћљћљћЮ"Ђ‘–˜љ349;>EGLNSUY[`b./ab‡ˆ‘–˜љ349;>EGLNSUY[`b./ab‡ˆ‘–˜љ349;>EGLNSUY[`b./ab‡ˆ‘–˜љ349;>EGLNSUY[`b./ab‡ˆ‘–˜љ349;>EGLNSUY[`b./ab‡ˆ‘–˜љ349;>EGLNSUY[`b./ab‡ˆŽ.ППППППзхчщхчщхчщхчщхчщхчщW„„„„„„—%-?˜?˜?˜?˜?˜?˜з-ЋЋЋЋЋЋз.ЩЩЩЩЩЩ/ЭЭЭЭЭЭрэяёэяёэяёэяёэяёэяё " ‘љ‘љ‘љ‘љ‘љ‘љр)4.‡4.‡4.‡4.‡4.‡4.‡‰OOOOOO ЯбЯбЯбЯбЯбЯб‰! ]^]^]^]^]^]^I+@Cœ@Cœ@Cœ@Cœ@Cœ@Cœ .ЏЏЏЏЏЏ‰/ссссссR$"ŠŒŽє"ŠŒŽє"ŠŒŽє"ŠŒŽє"ŠŒŽє"ŠŒŽє&9a9a9a9a9a9aR,PWZ^a„‡‹ŽЛОТХшыяђBEILorvyœŸЃІЫЮдз 47=@nqux›žЂЅЬЯгжWZ^a„‡‹ŽЛОТХшыяђBEILorvyœŸЃІЫЮдз 47=@nqux›žЂЅЬЯгжWZ^a„‡‹ŽЛОТХшыяђBEILorvyœŸЃІЫЮдз 47=@nqux›žЂЅЬЯгжWZ^a„‡‹ŽЛОТХшыяђBEILorvyœŸЃІЫЮдз 47=@nqux›žЂЅЬЯгжWZ^a„‡‹ŽЛОТХшыяђBEILorvyœŸЃІЫЮдз 47=@nqux›žЂЅЬЯгжWZ^a„‡‹ŽЛОТХшыяђBEILorvyœŸЃІЫЮдз 47=@nqux›žЂЅЬЯгж’,Ўпџ)Y…’ВУуџ(?CF[nru˜œŸпџ)Y…’ВУуџ(?CF[nru˜œŸпџ)Y…’ВУуџ(?CF[nru˜œŸпџ)Y…’ВУуџ(?CF[nru˜œŸпџ)Y…’ВУуџ(?CF[nru˜œŸпџ)Y…’ВУуџ(?CF[nru˜œŸ;Лh­ЏЖ^hs~‰”ŸЊЕРЭныыыыl™žžа§*W„БюWƒ”–žЅЌАВДЛНХЧЯжнсухьюDGsv ­ЏЖ^hs~‰”ŸЊЕРЭныыыыl™žžа§*W„БюWƒ”–žЅЌАВДЛНХЧЯжнсухьюDGsv ­ЏЖ^hs~‰”ŸЊЕРЭныыыыl™žžа§*W„БюWƒ”–žЅЌАВДЛНХЧЯжнсухьюDGsv ­ЏЖ^hs~‰”ŸЊЕРЭныыыыl™žžа§*W„БюWƒ”–žЅЌАВДЛНХЧЯжнсухьюDGsv ­ЏЖ^hs~‰”ŸЊЕРЭныыыыl™žžа§*W„БюWƒ”–žЅЌАВДЛНХЧЯжнсухьюDGsv ­ЏЖ^hs~‰”ŸЊЕРЭныыыыl™žžа§*W„БюWƒ”–žЅЌАВДЛНХЧЯжнсухьюDGsv Л       ћ"8œЁЇЌВЗНТњћќ§679:fhjry€†“•—ŸІ­ГК   1245deghŠ‹ŽœЁЇЌВЗНТњћќ§679:fhjry€†“•—ŸІ­ГК   1245deghŠ‹ŽœЁЇЌВЗНТњћќ§679:fhjry€†“•—ŸІ­ГК   1245deghŠ‹ŽœЁЇЌВЗНТњћќ§679:fhjry€†“•—ŸІ­ГК   1245deghŠ‹ŽœЁЇЌВЗНТњћќ§679:fhjry€†“•—ŸІ­ГК   1245deghŠ‹ŽœЁЇЌВЗНТњћќ§679:fhjry€†“•—ŸІ­ГК   1245deghŠ‹Ž„#ЎНТФ§9:“•˜ŸЁІЈ­ЏГЕКМ  45ghŽНТФ§9:“•˜ŸЁІЈ­ЏГЕКМ  45ghŽНТФ§9:“•˜ŸЁІЈ­ЏГЕКМ  45ghŽНТФ§9:“•˜ŸЁІЈ­ЏГЕКМ  45ghŽНТФ§9:“•˜ŸЁІЈ­ЏГЕКМ  45ghŽНТФ§9:“•˜ŸЁІЈ­ЏГЕКМ  45ghŽФ#ЫЬелмхD%      ­''''''mе1+9=­OOOOOO­WWWWWWэ НПНПНПНПНПНПэ!Шhjlsuw~€‚‰‹”–˜ŸЁЃЊЌЎЕЗЙРТФЭЯгнпуlnp™›žžавд§џ*,.WY[„†ˆБГЕю№єWY]ƒ…‡АВЕсуцhjlsuw~€‚‰‹”–˜ŸЁЃЊЌЎЕЗЙРТФЭЯгнпуlnp™›žžавд§џ*,.WY[„†ˆБГЕю№єWY]ƒ…‡АВЕсуцhjlsuw~€‚‰‹”–˜ŸЁЃЊЌЎЕЗЙРТФЭЯгнпуlnp™›žžавд§џ*,.WY[„†ˆБГЕю№єWY]ƒ…‡АВЕсуцhjlsuw~€‚‰‹”–˜ŸЁЃЊЌЎЕЗЙРТФЭЯгнпуlnp™›žžавд§џ*,.WY[„†ˆБГЕю№єWY]ƒ…‡АВЕсуцhjlsuw~€‚‰‹”–˜ŸЁЃЊЌЎЕЗЙРТФЭЯгнпуlnp™›žžавд§џ*,.WY[„†ˆБГЕю№єWY]ƒ…‡АВЕсуцhjlsuw~€‚‰‹”–˜ŸЁЃЊЌЎЕЗЙРТФЭЯгнпуlnp™›žžавд§џ*,.WY[„†ˆБГЕю№єWY]ƒ…‡АВЕсуц­.ХХХХХХЖ—cGз—cGз—cGз—cGз—cGз—cGзі$W]io{W]io{W]io{W]io{W]io{W]io{ЖZvZvZvZvZvZvі ЭгЭгЭгЭгЭгЭг6 ммммммі 6" {ї{ї{ї{ї{ї{їv')n)n)n)n)n)n6).џ(.џ(.џ(.џ(.џ(.џ(Ж*<<<<<<6,xNY`gptwВНФЫдилпъёј %.259DKR[_bfqxˆŒ“žЅЌЕЙМРЭжуќ’ЄЋЕКОУЮемцыяіїќ§џ    %&()+,./124578CDFGRSXY[\^_abdeghjkrsuvxy~‚„…‡ˆŠ‹Ž‘œŸ NY`gptwВНФЫдилпъёј %.259DKR[_bfqxˆŒ“žЅЌЕЙМРЭжуќ’ЄЋЕКОУЮемцыяіїќ§џ    %&()+,./124578CDFGRSXY[\^_abdeghjkrsuvxy~‚„…‡ˆŠ‹Ž‘œŸ NY`gptwВНФЫдилпъёј %.259DKR[_bfqxˆŒ“žЅЌЕЙМРЭжуќ’ЄЋЕКОУЮемцыяіїќ§џ    %&()+,./124578CDFGRSXY[\^_abdeghjkrsuvxy~‚„…‡ˆŠ‹Ž‘œŸ NY`gptwВНФЫдилпъёј %.259DKR[_bfqxˆŒ“žЅЌЕЙМРЭжуќ’ЄЋЕКОУЮемцыяіїќ§џ    %&()+,./124578CDFGRSXY[\^_abdeghjkrsuvxy~‚„…‡ˆŠ‹Ž‘œŸ NY`gptwВНФЫдилпъёј %.259DKR[_bfqxˆŒ“žЅЌЕЙМРЭжуќ’ЄЋЕКОУЮемцыяіїќ§џ    %&()+,./124578CDFGRSXY[\^_abdeghjkrsuvxy~‚„…‡ˆŠ‹Ž‘œŸ NY`gptwВНФЫдилпъёј %.259DKR[_bfqxˆŒ“žЅЌЕЙМРЭжуќ’ЄЋЕКОУЮемцыяіїќ§џ    %&()+,./124578CDFGRSXY[\^_abdeghjkrsuvxy~‚„…‡ˆŠ‹Ž‘œŸ Ÿ OOOOOOOOOOOO_ ььььььh OьOьOьOьOьOьЈOOOOOOш (!++++++Ј+CFŸCFŸCFŸCFŸCFŸCFŸqOOOOOOё$ё-ЎЎЎЎЎЎкHвтбкчѓ:CP\iвтбкчѓ:CP\iвтбкчѓ:CP\iвтбкчѓ:CP\iвтбкчѓ:CP\iвтбкчѓ:CP\išЄЄЄЄЄЄ#$Јј(чэЈј(чэЈј(чэЈј(чэЈј(чэЈј(чэЃOOOOOOc !$!$!$!$!$!$Ѓ,-8,-8,-8,-8,-8,-8c ььььььc$ыээяыээяыээяыээяыээяыээяу&c('''''' НемчНемчНемчНемчНемчНемчLЬffffffL„„„„„„Œ((іx(іx(іx(іx(іx(іx *666666Ь.ШШШШШШ§џ§џ§џ§џ§џ§џе" œњœњœњœњœњœње#<ЬмЪрэљ3IVbЬмЪрэљ3IVbЬмЪрэљ3IVbЬмЪрэљ3IVbЬмЪрэљ3IVbЬмЪрэљ3IVbU,{њU{њU{њU{њU{њU{њU@•••••О''''''ў ЦШЦШЦШЦШЦШЦШ~$ эяэяэяэяэяэяў.ЫЫЫЫЫЫ$<МЦлц<МЦлц<МЦлц<МЦлц<МЦлц<МЦлц<9;;BDDKNPP9;;BDDKNPP9;;BDDKNPP9;;BDDKNPP9;;BDDKNPP9;;BDDKNPPOOOOOO&, KOKOKOKOKOKOљ ././././././y-09=Alp’–š9=Alp’–š9=Alp’–š9=Alp’–š9=Alp’–š9=Alp’–šљ-ЏЏЏЏЏЏТ ЕЗЕЗЕЗЕЗЕЗЕЗТ/ шъшъшъшъшъшъ+Ћ ЋБЋБЋБЋБЋБЋБЋ$И   '(*+-.0134679:<=NpwВдлп .59[bfˆ“ЕМРє%)]j‡Žіїќ§џ   "%(+.147;?RX[^adgjnx{~„‡Š”˜   '(*+-.0134679:<=NpwВдлп .59[bfˆ“ЕМРє%)]j‡Žіїќ§џ   "%(+.147;?RX[^adgjnx{~„‡Š”˜   '(*+-.0134679:<=NpwВдлп .59[bfˆ“ЕМРє%)]j‡Žіїќ§џ   "%(+.147;?RX[^adgjnx{~„‡Š”˜   '(*+-.0134679:<=NpwВдлп .59[bfˆ“ЕМРє%)]j‡Žіїќ§џ   "%(+.147;?RX[^adgjnx{~„‡Š”˜   '(*+-.0134679:<=NpwВдлп .59[bfˆ“ЕМРє%)]j‡Žіїќ§џ   "%(+.147;?RX[^adgjnx{~„‡Š”˜   '(*+-.0134679:<=NpwВдлп .59[bfˆ“ЕМРє%)]j‡Žіїќ§џ   "%(+.147;?RX[^adgjnx{~„‡Š”˜4$[ams…[ams…[ams…[ams…[ams…[ams…4xxxxxx*@OOOVhz@OOOVhz@OOOVhz@OOOVhz@OOOVhz@OOOVhz!')+')+')+')+')+')+ц TЈTЈTЈTЈTЈTЈf„„„„„„ц# иџиџиџиџиџиџц,;”;”;”;”;”;”Я+5>+5>+5>+5>+5>+5>Я! ejpu{€†‹‘–œЁЇЌВЗНТШЯипшэээээѕіїјљњћќ§ўџ     !!#$$'(*+-..0134679:<=?@@BCCNPR\chnu{}‰•›ŸЅЇЌЎВДЖРЧЬвйпсуэєљ !&,39;=GNSY`fhjt{€†“•—ЁЈ­ГКРТФвлф№§ #)+-;DMfszŒ’”– ЇЌЛУХЧбиньіїљњќ§џ    "#%&()+,./1245789;<=?@ACDFGRSUVXY[\^_abdeghjklnoprsuvxy{|~‚„…‡ˆŠ‹Ž‘’”•–˜™šœŸ ejpu{€†‹‘–œЁЇЌВЗНТШЯипшэээээѕіїјљњћќ§ўџ     !!#$$'(*+-..0134679:<=?@@BCCNPR\chnu{}‰•›ŸЅЇЌЎВДЖРЧЬвйпсуэєљ !&,39;=GNSY`fhjt{€†“•—ЁЈ­ГКРТФвлф№§ #)+-;DMfszŒ’”– ЇЌЛУХЧбиньіїљњќ§џ    "#%&()+,./1245789;<=?@ACDFGRSUVXY[\^_abdeghjklnoprsuvxy{|~‚„…‡ˆŠ‹Ž‘’”•–˜™šœŸ ejpu{€†‹‘–œЁЇЌВЗНТШЯипшэээээѕіїјљњћќ§ўџ     !!#$$'(*+-..0134679:<=?@@BCCNPR\chnu{}‰•›ŸЅЇЌЎВДЖРЧЬвйпсуэєљ !&,39;=GNSY`fhjt{€†“•—ЁЈ­ГКРТФвлф№§ #)+-;DMfszŒ’”– ЇЌЛУХЧбиньіїљњќ§џ    "#%&()+,./1245789;<=?@ACDFGRSUVXY[\^_abdeghjklnoprsuvxy{|~‚„…‡ˆŠ‹Ž‘’”•–˜™šœŸ ejpu{€†‹‘–œЁЇЌВЗНТШЯипшэээээѕіїјљњћќ§ўџ     !!#$$'(*+-..0134679:<=?@@BCCNPR\chnu{}‰•›ŸЅЇЌЎВДЖРЧЬвйпсуэєљ !&,39;=GNSY`fhjt{€†“•—ЁЈ­ГКРТФвлф№§ #)+-;DMfszŒ’”– ЇЌЛУХЧбиньіїљњќ§џ    "#%&()+,./1245789;<=?@ACDFGRSUVXY[\^_abdeghjklnoprsuvxy{|~‚„…‡ˆŠ‹Ž‘’”•–˜™šœŸ ejpu{€†‹‘–œЁЇЌВЗНТШЯипшэээээѕіїјљњћќ§ўџ     !!#$$'(*+-..0134679:<=?@@BCCNPR\chnu{}‰•›ŸЅЇЌЎВДЖРЧЬвйпсуэєљ !&,39;=GNSY`fhjt{€†“•—ЁЈ­ГКРТФвлф№§ #)+-;DMfszŒ’”– ЇЌЛУХЧбиньіїљњќ§џ    "#%&()+,./1245789;<=?@ACDFGRSUVXY[\^_abdeghjklnoprsuvxy{|~‚„…‡ˆŠ‹Ž‘’”•–˜™šœŸ ejpu{€†‹‘–œЁЇЌВЗНТШЯипшэээээѕіїјљњћќ§ўџ     !!#$$'(*+-..0134679:<=?@@BCCNPR\chnu{}‰•›ŸЅЇЌЎВДЖРЧЬвйпсуэєљ !&,39;=GNSY`fhjt{€†“•—ЁЈ­ГКРТФвлф№§ #)+-;DMfszŒ’”– ЇЌЛУХЧбиньіїљњќ§џ    "#%&()+,./1245789;<=?@ACDFGRSUVXY[\^_abdeghjklnoprsuvxy{|~‚„…‡ˆŠ‹Ž‘’”•–˜™šœŸ иЈЈЈЈЈЈXБГЕБГЕБГЕБГЕБГЕБГЕX ььььььи      и!x ejlpuw{€‚†‹‘–˜œЁЃЇЌЎВЗЙНТФШЯгипуѕіїјљњћќ§ўџ    !#$'(*+-.0134679:<=?@BCIJJKNPSZ\achjnppuww{}€‡‰Ž•—›žžžŸ ЅЇЌЎВДЗОРХЧЬЮвддйллпсфыэђєљћџ !&(,..3559;>EGLNSUY[[`bbfhkrty{€‚†ˆˆ“•˜ŸЁІЈ­ЏГЕЕКММРТХЮвзлфш№єє§ #%%)+.7;@DMQY]]fjjqsxz…‡‡ŒŽŽ’”—ž ЅЇЌЎВЕЛОУХШЯбжинпуцьяіїљњќ§џ    "#%&()+,./1245789;<=?@ACDFGRSUVXY[\^_abdeghjklnoprsuvxy{|~‚„…‡ˆŠ‹Ž‘’”•–˜™šœŸ ejlpuw{€‚†‹‘–˜œЁЃЇЌЎВЗЙНТФШЯгипуѕіїјљњћќ§ўџ    !#$'(*+-.0134679:<=?@BCIJJKNPSZ\achjnppuww{}€‡‰Ž•—›žžžŸ ЅЇЌЎВДЗОРХЧЬЮвддйллпсфыэђєљћџ !&(,..3559;>EGLNSUY[[`bbfhkrty{€‚†ˆˆ“•˜ŸЁІЈ­ЏГЕЕКММРТХЮвзлфш№єє§ #%%)+.7;@DMQY]]fjjqsxz…‡‡ŒŽŽ’”—ž ЅЇЌЎВЕЛОУХШЯбжинпуцьяіїљњќ§џ    "#%&()+,./1245789;<=?@ACDFGRSUVXY[\^_abdeghjklnoprsuvxy{|~‚„…‡ˆŠ‹Ž‘’”•–˜™šœŸ ejlpuw{€‚†‹‘–˜œЁЃЇЌЎВЗЙНТФШЯгипуѕіїјљњћќ§ўџ    !#$'(*+-.0134679:<=?@BCIJJKNPSZ\achjnppuww{}€‡‰Ž•—›žžžŸ ЅЇЌЎВДЗОРХЧЬЮвддйллпсфыэђєљћџ !&(,..3559;>EGLNSUY[[`bbfhkrty{€‚†ˆˆ“•˜ŸЁІЈ­ЏГЕЕКММРТХЮвзлфш№єє§ #%%)+.7;@DMQY]]fjjqsxz…‡‡ŒŽŽ’”—ž ЅЇЌЎВЕЛОУХШЯбжинпуцьяіїљњќ§џ    "#%&()+,./1245789;<=?@ACDFGRSUVXY[\^_abdeghjklnoprsuvxy{|~‚„…‡ˆŠ‹Ž‘’”•–˜™šœŸ ejlpuw{€‚†‹‘–˜œЁЃЇЌЎВЗЙНТФШЯгипуѕіїјљњћќ§ўџ    !#$'(*+-.0134679:<=?@BCIJJKNPSZ\achjnppuww{}€‡‰Ž•—›žžžŸ ЅЇЌЎВДЗОРХЧЬЮвддйллпсфыэђєљћџ !&(,..3559;>EGLNSUY[[`bbfhkrty{€‚†ˆˆ“•˜ŸЁІЈ­ЏГЕЕКММРТХЮвзлфш№єє§ #%%)+.7;@DMQY]]fjjqsxz…‡‡ŒŽŽ’”—ž ЅЇЌЎВЕЛОУХШЯбжинпуцьяіїљњќ§џ    "#%&()+,./1245789;<=?@ACDFGRSUVXY[\^_abdeghjklnoprsuvxy{|~‚„…‡ˆŠ‹Ž‘’”•–˜™šœŸ ejlpuw{€‚†‹‘–˜œЁЃЇЌЎВЗЙНТФШЯгипуѕіїјљњћќ§ўџ    !#$'(*+-.0134679:<=?@BCIJJKNPSZ\achjnppuww{}€‡‰Ž•—›žžžŸ ЅЇЌЎВДЗОРХЧЬЮвддйллпсфыэђєљћџ !&(,..3559;>EGLNSUY[[`bbfhkrty{€‚†ˆˆ“•˜ŸЁІЈ­ЏГЕЕКММРТХЮвзлфш№єє§ #%%)+.7;@DMQY]]fjjqsxz…‡‡ŒŽŽ’”—ž ЅЇЌЎВЕЛОУХШЯбжинпуцьяіїљњќ§џ    "#%&()+,./1245789;<=?@ACDFGRSUVXY[\^_abdeghjklnoprsuvxy{|~‚„…‡ˆŠ‹Ž‘’”•–˜™šœŸ ejlpuw{€‚†‹‘–˜œЁЃЇЌЎВЗЙНТФШЯгипуѕіїјљњћќ§ўџ    !#$'(*+-.0134679:<=?@BCIJJKNPSZ\achjnppuww{}€‡‰Ž•—›žžžŸ ЅЇЌЎВДЗОРХЧЬЮвддйллпсфыэђєљћџ !&(,..3559;>EGLNSUY[[`bbfhkrty{€‚†ˆˆ“•˜ŸЁІЈ­ЏГЕЕКММРТХЮвзлфш№єє§ #%%)+.7;@DMQY]]fjjqsxz…‡‡ŒŽŽ’”—ž ЅЇЌЎВЕЛОУХШЯбжинпуцьяіїљњќ§џ    "#%&()+,./1245789;<=?@ACDFGRSUVXY[\^_abdeghjklnoprsuvxy{|~‚„…‡ˆŠ‹Ž‘’”•–˜™šœŸ !uxzuxzuxzuxzuxzuxzЁ,ЈРє"%)]jpw~‡‹Ž79jlnp’Рє"%)]jpw~‡‹Ž79jlnp’Рє"%)]jpw~‡‹Ž79jlnp’Рє"%)]jpw~‡‹Ž79jlnp’Рє"%)]jpw~‡‹Ž79jlnp’Рє"%)]jpw~‡‹Ž79jlnp’ŠB'(,ƒ„Ž–œД'(,ƒ„Ž–œД'(,ƒ„Ž–œД'(,ƒ„Ž–œД'(,ƒ„Ž–œД'(,ƒ„Ž–œД # ЇћЇћЇћЇћЇћЇћŠ*: 4: 4: 4: 4: 4: 4 œžœžœžœžœžœž“ЧЧЧЧЧЧ жижижижижижи!!#!#!#!#!#!#“! eѕeѕeѕeѕeѕeѕ'РjРjРjРjРjРj. БЗБЗБЗБЗБЗБЗ|B’ЫлЩпьј2HUa’ЫлЩпьј2HUa’ЫлЩпьј2HUa’ЫлЩпьј2HUa’ЫлЩпьј2HUa’ЫлЩпьј2HUa|#ŠНТ§9:“•—ŸІ­ГК  45ghŽНТ§9:“•—ŸІ­ГК  45ghŽНТ§9:“•—ŸІ­ГК  45ghŽНТ§9:“•—ŸІ­ГК  45ghŽНТ§9:“•—ŸІ­ГК  45ghŽНТ§9:“•—ŸІ­ГК  45ghŽќ+ JNJNJNJNJNJNХ''''''Х!‚ejlpuw{€‚†‹‘–˜œЁЃЇЌЎВЗЙНТФШЯипшэяѕіїјљњћќ§ўџ      !!#$$'((*++-..0113446779::<==?@@BCCNPRSZ\achjnu{}€†‡‰Ž”•—›žЄЅЇЋЌЎВДЖЗОРХЧЬЮвйпсуфыэђєљћџ !&(,39;=>EGLNSUY`fhjkrty{€‚†“•—˜ŸЁІЈ­ЏГКРЮзф№§)67?@LMYef’”–—ž ЅЇЌЎВЛУХЧШЯбжинпуьіїљњќ§џ    "##%&()+,./124578;<<?@@CDFGRSUVVXY[\^_abdeghjknoorsuvxy{||~‚„…‡ˆŠ‹Ž‘”••˜™™œŸ ejlpuw{€‚†‹‘–˜œЁЃЇЌЎВЗЙНТФШЯипшэяѕіїјљњћќ§ўџ      !!#$$'((*++-..0113446779::<==?@@BCCNPRSZ\achjnu{}€†‡‰Ž”•—›žЄЅЇЋЌЎВДЖЗОРХЧЬЮвйпсуфыэђєљћџ !&(,39;=>EGLNSUY`fhjkrty{€‚†“•—˜ŸЁІЈ­ЏГКРЮзф№§)67?@LMYef’”–—ž ЅЇЌЎВЛУХЧШЯбжинпуьіїљњќ§џ    "##%&()+,./124578;<<?@@CDFGRSUVVXY[\^_abdeghjknoorsuvxy{||~‚„…‡ˆŠ‹Ž‘”••˜™™œŸ ejlpuw{€‚†‹‘–˜œЁЃЇЌЎВЗЙНТФШЯипшэяѕіїјљњћќ§ўџ      !!#$$'((*++-..0113446779::<==?@@BCCNPRSZ\achjnu{}€†‡‰Ž”•—›žЄЅЇЋЌЎВДЖЗОРХЧЬЮвйпсуфыэђєљћџ !&(,39;=>EGLNSUY`fhjkrty{€‚†“•—˜ŸЁІЈ­ЏГКРЮзф№§)67?@LMYef’”–—ž ЅЇЌЎВЛУХЧШЯбжинпуьіїљњќ§џ    "##%&()+,./124578;<<?@@CDFGRSUVVXY[\^_abdeghjknoorsuvxy{||~‚„…‡ˆŠ‹Ž‘”••˜™™œŸ ejlpuw{€‚†‹‘–˜œЁЃЇЌЎВЗЙНТФШЯипшэяѕіїјљњћќ§ўџ      !!#$$'((*++-..0113446779::<==?@@BCCNPRSZ\achjnu{}€†‡‰Ž”•—›žЄЅЇЋЌЎВДЖЗОРХЧЬЮвйпсуфыэђєљћџ !&(,39;=>EGLNSUY`fhjkrty{€‚†“•—˜ŸЁІЈ­ЏГКРЮзф№§)67?@LMYef’”–—ž ЅЇЌЎВЛУХЧШЯбжинпуьіїљњќ§џ    "##%&()+,./124578;<<?@@CDFGRSUVVXY[\^_abdeghjknoorsuvxy{||~‚„…‡ˆŠ‹Ž‘”••˜™™œŸ ejlpuw{€‚†‹‘–˜œЁЃЇЌЎВЗЙНТФШЯипшэяѕіїјљњћќ§ўџ      !!#$$'((*++-..0113446779::<==?@@BCCNPRSZ\achjnu{}€†‡‰Ž”•—›žЄЅЇЋЌЎВДЖЗОРХЧЬЮвйпсуфыэђєљћџ !&(,39;=>EGLNSUY`fhjkrty{€‚†“•—˜ŸЁІЈ­ЏГКРЮзф№§)67?@LMYef’”–—ž ЅЇЌЎВЛУХЧШЯбжинпуьіїљњќ§џ    "##%&()+,./124578;<<?@@CDFGRSUVVXY[\^_abdeghjknoorsuvxy{||~‚„…‡ˆŠ‹Ž‘”••˜™™œŸ ejlpuw{€‚†‹‘–˜œЁЃЇЌЎВЗЙНТФШЯипшэяѕіїјљњћќ§ўџ      !!#$$'((*++-..0113446779::<==?@@BCCNPRSZ\achjnu{}€†‡‰Ž”•—›žЄЅЇЋЌЎВДЖЗОРХЧЬЮвйпсуфыэђєљћџ !&(,39;=>EGLNSUY`fhjkrty{€‚†“•—˜ŸЁІЈ­ЏГКРЮзф№§)67?@LMYef’”–—ž ЅЇЌЎВЛУХЧШЯбжинпуьіїљњќ§џ    "##%&()+,./124578;<<?@@CDFGRSUVVXY[\^_abdeghjknoorsuvxy{||~‚„…‡ˆŠ‹Ž‘”••˜™™œŸ E$ыээяыээяыээяыээяыээяыээя.!237237237237237237..ГГГГГГ./ЯЯЯЯЯЯЗ)333333З,љљљљљљЗ.ЦЦЦЦЦЦ€* #•—™œc #•—™œc #•—™œc #•—™œc #•—™œc #•—™œc€лсчлсчлсчлсчлсчлсч€ЄЄЄЄЄЄ€.ООООООiЃЅЇЃЅЇЃЅЇЃЅЇЃЅЇЃЅЇщ-­­­­­­щ/ѕл ЛСЛСЛСЛСЛСЛС  @џџаа§ @џџЩЩы @џџХХж @џџФФЫ @џџ УУЛ Dџџ ТТА @џџ ССЅ @џџ РР› @џџПП @џџОО‚ @џџННm DџџММх @џџЛЛZ @џџКК: @џџЎЎ @џџ­­ @џџЌЌт @џџЋЋУ @џџЊЊЋ @џџЉЉ‰ @џџ ЈЈg @џџ"ЇЇE @џџ%ІІ# @џџ(ЅЅ @џџ*ЄЄщ @џџ,ЃЃг @џџ-ЂЂЕ @џџ/ЁЁ— @џџ1  € @џџ2ŸŸc @џџ4žžF @џџ60 @џџ7œœ @џџ9››№ @џџ;ššа @џџ>™™А @џџA˜˜• @џџC——z @џџE––f @џџF••O @џџH””8 @џџJ““ @џџL’’ @џџN‘‘ы @џџOа @џџQЕ @џџSŽŽЁ @џџTƒ @џџVŒŒe @џџX‹‹G @џџ[ŠŠ) @џџ^‰‰ @џџ`ˆˆї @џџb‡‡х @џџc††Щ @џџe……­ @џџg„„‘ @џџjƒƒu @џџm‚‚^ @џџoG @џџq€€5 @џџr% @џџs~~ @џџu}}џ @џџw||у @џџy{{Ч @џџ{zzВ @џџ|yy— @џџ~xx| @џџ€wwh @џџvvJ @џџƒuu, @џџ…tt @џџˆss№ @џџ‹rrз @џџqqО @џџppЌ @џџoo’ @џџ’nnx @џџ”mme @џџ•llL @џџ—kk3 @џџ™jj! @џџšii @џџœhhщ @џџžggЭ @џџЁffБ @џџЄeeš @џџІddƒ @џџЈccs @џџЉbb` @џџЋaaM @џџ­``5 @џџЏ__ @џџБ^^  @џџВ]]ѕ @џџД\\о @џџЖ[[Ф @џџИYYЊ @џџКXX @џџНWWv @џџРVVa @џџТUUL @џџФTT< @џџХSS. @џџЦRR @џџШQQ @џџЪPPѓ @џџЫOOо @џџЭNNЩ @џџЯMMЛ @џџаLLЃ @џџвKK‹ @џџдJJs @џџзII[ @џџкHHH @џџмGG5 @џџоFF) @џџпEE @џџсDD  @џџуCCѕ @џџхBBп @џџчAAа @џџш@@Л @џџъ??І @џџь==˜ @џџэ<<€ @џџя;;h @џџё::P @џџє998 @џџї88% @џџљ77 @џџћ66 @џџќ55ђ @џџў44о @џџ33Ц @џџ22Ў @џџ11– @џџ00~ @џџ //k @џџ ..X @џџ--B @џџ,,, @џџ++ @џџ** @џџ))я @џџ((о @џџ''д @џџ&&С @џџ%%Ў @џџ!$$Ђ @џџ"## @џџ$""~ @џџ&!!s @џџ'  c @џџ)S @џџ+J @џџ,= @џџ.0 @џџ0 @џџ2 @џџ4 @џџ5№ @џџ7п @џџ9е @џџ:С @џџ<­ @џџ>™ @џџA… @џџDv @џџFg @џџH_ @џџIO @џџK  ? @џџM  2 @џџN  ) @џџO   @џџQ   @џџSэ @џџVй @џџYЪ @џџ[Л @џџ]Џ @џџ^Ї @џџ_• @џџaƒ @џџcq @џџfџџX @џџiўўK @џџk§§> @џџmќќ8 @џџnћћ) @џџpњњ @џџrљљ @џџsјј @џџuїїі @џџwііо @џџxѕѕв @џџzєєЦ @џџ|ѓѓС @џџ}ђђИ @џџёёЏ @џџ№№ч @џџƒууУ @џџ…ттИ Dџџ†сс› Dџџ‡ррu Dџџˆпп[ @џџŠооJ Dџџ‹нн9 DџџŒмм# @џџŽлл Dџџккџ @џџ‘ййЊ Dџџ’ии Dџџ“зз’ @џџ•жжƒ @џџ—ее| Dџџ˜ддv Dџџ™ггn Dџџšвв\ @џџœббJ @џџžаа= @џџ ЯЯ+ @џџЂЮЮ @џџЄЭЭ @џџІЬЬѓ DџџЇЫЫш DџџЈЪЪр DџџЉЩЩа DџџЊШШТ DџџЋЧЧЗ DџџЌЦЦЋ Dџџ­ХХЁ DџџЎФФš DџџЏУУc @џџАппU DџџБллЂЫЃЫЈЫМЫиЫсЫиЫЬЬЂЫЬ/Ь@ЬTЬZЬnЬЂЫ{Ь•ЬЃЫЉЬЪЬЯЬЪЬ№ЬЭЪЬfЭЪЬЦЭЮЪЬVЮЪЬ‘ЮЪЬЯЮжЮЪЬЯЮЯЪЬJЯЪЬ€ЯЋЯЪЬЪЯЪЬщЯ§ЯЪЬ<аЪЬ{а%бЪЬ^бЪЬ—бЪЬЯЮгбЪЬЯЮвЪЬCвЪЬwв вЪЬавЪЬгЪЬгЪЬ:гLгЪЬЈгЪЬдUдЪЬŒдЪЬУдЪЬЯЮ§дЪЬЯЮ7еЪЬiеЪЬ›еТеЪЬїеЪЬ,жЪЬЯЮdжЪЬЯЮœжЪЬЬжЪЬќж,зQзЪЬ}зЪЬЉзЪЬЦзЪЬузѕзЪЬQиЪЬ­иўиЪЬkйЪЬийЪЬЯЮHкЪЬЯЮИкЪЬ лЪЬˆлхлЪЬмЪЬм+мЪЬfмЪЬЁм§мЪЬAнЪЬ…нЪЬЯЮЬнЪЬЯЮоЪЬRоЪЬ‘оХоЪЬпЪЬ;пЪЬ;пЪЬTпbпЪЬbпЪЬКпЪЬлпЪЬќпЪЬЯЮ^рЪЬЯЮРрЪЬсЪЬnсЛстЪЬтЪЬ)т5тЪЬ5тЪЬlтЎтЪЬЭтЪЬьтЪЬЯЮ(уЪЬЯЮdуЪЬ™уЪЬЮуфЪЬhфЪЬЮфЪЬхфЪЬќфЮфЪЬхЪЬNх‰хЪЬКхЪЬыхЪЬЯЮцЪЬЯЮSцЪЬцЪЬЋцЬцЪЬљцЪЬ&чЪЬXчЪЬŠчЪЬЯЮПчЪЬЯЮЬцЪЬљцЪЬєчЪЬ#шЪЬRшЪЬЯЮ„шЪЬЯЮЖшЪЬршЪЬ щ)щЪЬ=щЪЬQщZщЪЬ…щЪЬАщащЪЬљщЪЬ"ъ@ъЪЬfъЪЬŒъЪЬŸъЪЬВъКъЪЬќъЪЬ>ыuыЪЬыЪЬЋыЪЬЯЮюыЪЬЯЮ1ьЪЬPьЪЬoь—ьЪЬОьЪЬхьэ@эЪЬnэЪЬœэЪЬЯЮЭэЪЬЯЮўэЪЬ=юЪЬ|юЧюљюЪЬяЪЬ+яЪЬЯЮYяЪЬЯЮ—ьЪЬОьЪЬ‡я­яЪЬНяЪЬЭявяЪЬљяЪЬ №<№ЪЬ]№ЪЬ~№Ѕ№ЪЬХ№ЪЬЂЫиЫЂЫиЫЂЫЂЫЂЫЂЫЬЂЫЂЫЂЫTЬЂЫЂЫЃЫЂЫЂЫЂЫЃЫЂЫЃЫЂЫЂЫЂЫЂЫЪЬЂЫЪЬЂЫЪЬЂЫЪЬЂЫЪЬЂЫх№ЂЫЂЫЂЫЂЫЂЫЂЫЂЫЂЫЂЫь№ЂЫџЧzG€GŠаШ "P 9а @WYsŠˆ’аа™›9МмРТЃЧB ,2P‚НЋR Х &'()*+,56789:;`abcdefghiooppqqrrssttuu|}~€‚ƒ„…†‡ˆ‰Š‹Œ“”•–—˜™š›œœœЂЃЄЅІЇЈ+GЮєџIWWk .ыЋЉыХRš›з &'()*+,56789:;`abcdefghooppqqrrssttuu|}~€‚ƒ„…†‡ˆ‰Š‹Œ“”•–—˜™š›œœœЂЃЄЅІЇЈ^&C@@GGQQXX__ЭЮЯаб№№ёёѓѓєєііїїљљњњќќ§§ўўџџ      !!""$$%%''(())**++,,--..//001122334466778899::;;==>>??AABBCCDDFFGGHHIIJJJKKKMMNNPPQQTTTUUUVVWWXXXYYY[[\\^^__``aaccddeeffgghhjjkkmmnnppqqrrssttuuwwxxzz{{||}}€€‚‚ƒƒ„„……‡‡ˆˆ‰‰ŠŠ‹‹ŒŒŽŽ‘‘’’““””––——˜˜™™šš››žž  ЁЁЃЃЄЄЅЅІІЇЇЈЈЊЊЋЋ­­ЎЎІ =>f•ŸКкОO  O”˜X ў)X -˜ <QЁ Ф№ёCDRaUWqˆ!iЁŠ 7@GQX_ВЗЙЛОJXа№CTTJНнСЪ J  #JuЈS !$гЂЉЌ|dw‡дћќ§ўџ       -./01234<=>CCCDDDEFGHILLMNRSTUVWZ[\`abcdefghiijkopqrstuvwxŽœœœžЉЊЋ<SZ|w… 8h›EІnWiЃвђCCDDEFGHILLMNRRSSTTUUVVWWZZ[[\\`abcdefghiijkooppqqrrssttuuvvwwxxŽŽœœœœžЉЉЊЊЋЋЎ $Ў 1.RSTUZ]o†ЗЦђї‡Ž‘€їЭ7ЬЛ )/€ ;‘€Ÿ) њ)  )EOb~щgš)‰щЃЊ­2  ђ 4Вy[ОоУ›РрЩ[HJe‚›ПdЛ 77Ь ‡ЙЙежйККЮЮаПРM`“Эf™О *0– 0жФџЙйК?  џ|HGId‘ƒz– :ЎƒеУВтФƒ +ƒcjm–ƒŒУЊlООоУУ, +1ЌovyЂ,tЇuПпШѕ B5FHMNPQc€ѕ\5_5u‚ЕŽЕЁо ВВЗЗтуФФХХоѕ о '-3о 3оNо[^чЗуХЇ g 6gЇ№ 0 №rЅА˜№š0œАСй ™ 9Ђ #тЋK §џ( CEF`|‹Jg„ЫУ ЬЮа @ЭѓўCDHRVVд &=QЯ= §ЧЩйЦѓіљЦ 2 5<@FЄЋЎЏ№ћќ CDЏ я (.4xпИЃсћќ§    EFGLRiœИё§ 8 ћ&8 8xm8“Сђѓєѕј С ; С %ЌЊ›иij <ўўџџ))**//008899HHIIVVVWWWeeffrrss‚‚ƒƒ‰‰ŠŠ˜˜™™ЅЅІІЊXt‹ѓ,Ы3ЛЛлППs  sIKfƒѓOsbl•3j\_бёDUU’хGѕії  !"-./01234<<==>>LMNSSZZ[[\\ijkvvwwxxŽŽœžЉЉЊЊЋЋЛ% 7?Bel%~х†e‹ЅРsІзqx{Є—x— р*Щђћќ§    EFGLRRiœ`a”ЩMЩ…‰Ј’‡жвєїњ ј 6=>A’n}Л Л ?ЛLЛТ їФYuŒmпэ ­ :­„mМЖндv5pгђђѓєѕії !"<=>RSTUVWZ[\opqrstuvwxŽœЉЊЋНііv 7vVXr‰_ 5п п Aш+Ъh :hvq џ*Бe˜š УН љDGa}šdkn—­ZК#їcопуфП#ЛлПc "%ЃKh…у{cž#Ѕ LTV[\^_p‡ ]LkUл•  ,  е •—žЁ> ќў'~ !~ /ОpwzЃ8 @џџ<<ў @џџ33є @џџhhш @џџggк @џџ ff @џџ ddœ @џџSSs @џџRR@ @џџBB @џџ>>ф @џџ55г @џџ))j @џџЧ @џџFёMё`ёtёwёtёЌёЎёtёрётёђђЌёtё,ђЌё9ђрёЂЫЂЫaђgђЂЫ6w–Чї0Py@ BD\]fnoq‹MOdfgg‰‹ŒŒYGj9GiHII™)MMNOOS\\^^_``ffgghhnnqqtttww~~‚ƒƒ‹‹ŒŒKBBDD\\\]]fffnnnoqqq‹‹‹ ddф/5dBє`hwƒ­Х%:MBЅRdddНX\mn|~~dd‰‰F IIOORRSS^^^__ggggttttu€€€‚ŒŒŒŒЖ"Al‘ ІОц(bо)ў13O^BЖVKMM–И˜~~и(8>8:<XYZfhmqw|ƒ‹ШY^ш^gtŒa (•бZ`jк\fnq~‹#(Гг')+3sIR\^nqtu|,:œOS_tЌS%9 @џџЂЫ+'3Ч00а0PGp9#)/‰0YYz00В0Ъ0J9›0Ѓ0У0ѓ39$"+T%(l00М04<BNT`f !0007I[n­0н3§9?KQ]c%9 –00ц5ю 8>JP\boqі8>JP\b:@LR^dF9oq00Ÿ00h0Ј0q00И DџџeL DџџўўxP@џџДДsP@џџГГnP@џџ ВВeP@џџ ББ\P@џџААЧB@џџЏЏSP@џџЎЎgB@џџ­­IP@џџЌЌAP@џџІІP@џџ!‹‹їO@џџ'ŠŠцO@џџ*‰‰еO@џџ/ˆˆЧO@џџ2‡‡ЙO@џџ7††ЉO@џџ>……›O@џџD„„ŒO@џџGƒƒ}O@џџJ‚‚nN@џџN@@_N@џџR??PN@џџU>>GN@џџX<<~P @[;;ЅЅ>I @џџ1@ЅЅ>I@џџDЄЄ7I@џџHЃЃ#I@џџMЂЂI@џџQ  I @@џџTJKI@@џџWŸŸ I@џџ[žžI @@џџ]HII@@џџ_§H@џџbœœђH@џџe››ыH@џџiššрH@џџk™™йH@џџn˜˜аH@џџs••ŠH@џџ{ˆˆІH@џџ‚‡‡™H@џџ‰††bH@џџ‘……|H@џџ˜„„pH@џџŸƒƒSH@џџЄFH@џџЉ€€8H@џџЎ,H@џџГ~~H@џџК||H@џџС{{H@џџЧzzпG@џџЮyyїG@џџеxxьG@џџлwwбG@џџсuuУG@џџчttЗG@џџэssЊG@џџѓrrG@џџљqq’G@џџџpp…G@џџnnxG@џџ mmmG@џџllaG@џџkkUG@џџjjKG@џџii2G@џџggG@џџ"ff G@џџ&eeG@џџ*ddєF@џџ0ccщF@џџ4bbнF@џџ9aaвF@џџ?``ШF@џџC__НF@џџH^^АF@џџN\\ЄF@џџT[[™F@џџXZZF@џџ]XXˆF@џџbXXюP @ЕgUUЇE @џџ1iUUЇE@џџoTT}F@џџuRRsF@џџ{RRQ @КOOŠE @џџ1ƒOOŠE@џџŠNN]F@џџ‘MMiF@џџ—LLSF@џџ›KKKF@џџŸJJ@F@џџЄII7F@џџЉHH0F@џџ­GG)F@џџАFFQ @ХГEE F @џџ1Е EE F@џџЙ CCF@џџМ BBF@џџО @@іE@џџХ ??тE@џџЫ >>F@џџв ==эE@џџи <<ЬE@џџо ;;МE@џџу 99иE@џџщ 77ХE@џџю 66ВE@џџђ 55$Q @гї 44E @џџ1љ 44E@џџџ 335Q @ж 22~E @џџ1 22~E@џџ 117E@џџ 00kE@џџ //XE@џџ ..FE@џџ --?E@џџ  ,,#E@џџ% ++E@џџ) )).E@џџ. ''E@џџ2 &&E@џџ4 %%E@џџ7 $$E@џџ: !!јD@џџ= зD@џџA аD@џџD ­D@џџH ЈD@џџK  D@џџN ›D@џџR ’D@џџV [@џџZ ‚D@џџ^ zD@џџa kD@џџd QD@џџg LD@џџj  HQ @ѓm  =D @џџ1o  =D@џџs  0D@џџu (D@џџw #D@џџz D@џџ€ D@џџƒ D@џџˆ D@џџ‹ ьC@џџ џџфC@џџ” ўўЦC@џџš §§ЖC@џџŸ ћћвC@џџЅ љљПC@џџЊ јј›C@џџА ііЅC@џџЕ єєŠC@џџМ ѓѓhC@џџТ ђђ]C@џџЦ ёёSC@џџЩ №№MC@џџЭ яяCC@џџв юю3C@џџз ээ%C@џџм ыы-C@џџр щщC@џџт шшѓB@џџц ттЮB@џџщ ккВB@џџю ееЅB@џџђ дд›B@џџє гг•B@џџї ввŽB@џџњ бб‡B@џџ§ аа‚B@џџ ЯЯzB@џџ ЬЬ\B@џџ ЧЧUB@џџ  ЦЦJB@џџ  ХХAB@џџ ФФ!B@џџ ССB@џџ ММB@џџ ЛЛ*A @џџ ’’A@џџ ‚‚z@ @џџ DDV; @џџ:CVQ@0" ;;cQ@0"!<<pQ@0""==~Q@0"#>>ŒQ@0"$??šQ@0"%@@ЋQ@0"&AAЛQ@0"'BB8P @џџ(ŸŸ/P @џџ)žžnO @џџ+~~cO @џџ-}}NO @џџ/ww=O @џџ0vv-O @џџ2uuO @џџ3ttO @џџ6ssO @џџ8rrѕN @џџ;qqчN @џџ=ppA @џџ>\\ЕH @џџ?YYБN @џџAQQЃN @џџDPP I @џџGOO§H @џџINN N @џџJ55 L @џџKююХH @џџLЙD @џџMWD @џџN№A @џџOЕЕдA @џџPЏЏЬA @џџQЎЎПA @џџR­­ВA @џџSЌЌЃA @џџTЋЋ–A @џџUЉЉ‰A @џџVЈЈ|A @џџWЇЇoA @џџXЅЅaA @џџYЄЄ:A @џџZЁЁZA @џџ[  SA @џџ\ŸŸMA @џџ]žž]; @џџ^ššm; @џџ`““ A @џџayyA @џџbssј@ @џџcqqю@ @џџdppф@ @џџeooз@ @џџfnnЮ@ @џџgkkХ@ @џџhjjМ@ @џџiii@ @џџj^^”@ @џџk\\‰@ @џџlPP@ @џџmOOE@ @џџnEEA@ @џџo664@ @џџp44*@ @џџq..#@ @џџr,,@ @џџs%%@ @џџt_bgjxДЙФвеђ#$%&'()*‡ђ‡ђŽ–Ђ‡ђ–Г‡ђŽж‡ђ‡ђ–Г‡ђПЦжъ‡ђFёџ.‡ђŽ–Ђ3єL`”–mє–Г‡ђ–ЃГПй–Г‡ђ–оГы3є ”–43є ”–r‡ђ–Г‡ђ–ГЂЉ–ДЂа–мЂ–ГЖђё1ЂЫ`GXl‡ђ‡ ПГЫрї  ‡Ы(7П‡Ы(p‡ЫžП‡ЫрПЦЫЭ‡ђЅхї‡ђЅ"‡ђЅхї‡ђЅ"‡ђ:NЅх_‡ђ:NЅЉ‡ђ:NЅх_‡ђ:NЅЉ‡ђ:Ѕхр‡ђ:Ѕ ‡ђ:Ѕхр‡ђ:Ѕ ‡ђ–ЅхE ‡ђ–Ѕz ‡ђ–ЅхE ‡ђ–Ѕz ‡ђЅхœ ­ ‡ђЅœ й Жђђ  !р‡ђ'!ЅМ6!м‡ђ'!ЅМ‡ђ'!Ѕ6!M‡ђ'!Ѕq‡ђGNЅхœ D!‡ђGNЅхœ Ђ‡ђGNЅх—!‡ђGNЅхч‡ђЅхœ ­ ‡ђЅхї‡ђЅхї‡ђGЅхœ Ђ‡ђGNЅхœ Ђ‡ђGNЅхœ Ђ‡ђGЅхч‡ђGNЅхч‡ђGNЅхч‡ђ–Ѕхœ щ!‡ђ–Ѕхœ щ!‡ђ–Ѕхœ щ!‡ђ–ЅхE ‡ђ–ЅхE ‡ђ–ЅхE ‡ђЅхœ ­ ‡ђЅхœ ­ ‡ђЅхœ ­ ‡ђЅхї‡ђЅхї‡ђЅхї‡ђЅœ й ‡ђЅ"‡ђGNЅœ +‡ђGNЅ]‡ђЅœ й ‡ђ–Ѕœ "‡ђЅ"‡ђ–Ѕz ‡ђ'!”Ѕ6!+‡ђ'!”Ѕ]‡ђB"”Ѕ6!Z"ЂЫ`‡ђG•"NЅœ Ќ"‡ђB"”Ѕь"ЂЫ`‡ђG•"NЅ&#‡ђGXЅœ +‡ђGXЅ]‡ђB"Ѕ6!e#ЂЫ`‡ђ’#XЅœ +‡ђB"Ѕ #ЂЫ`‡ђ’#XЅ]‡ђЅœ й ‡ђЅœ й ‡ђ–Ѕœ "‡ђ–Ѕœ "‡ђЅ"‡ђЅ"‡ђЅ"‡ђ–Ѕz ‡ђ–Ѕz ‡ђЬ# Жђ”Жђр#1ЂЫ`Жђњ#Xl‡ђЬ#–$Жђ’#%$–6$ЂЉ–ДЂR$]$ЂR$]$Ђа–мЂЂЂ–ГЂа]$Ђа–мЂЂ–ГП‡Ыh$t$‡ђ$Nжхœ Ћ$‡ђ$Nј$хœ %‡ђ$Nжхœ %‡ђ$NжхD%‡ђ$Nжх%‡ђ$Nжх%‡ђжхœ Ю%‡ђжхœ Ю%‡ђжхї%‡ђжхї%‡ђ$жхœ %‡ђ$Nжхœ %‡ђ$ж&œ )&‡ђ$жх%‡ђ$Nжх%‡ђ$жхZ&‡ђ–жхœ Š&‡ђ–жхœ Š&‡ђ–жхœ Š&‡ђ–жхН&‡ђ–жхН&‡ђ–жхН&‡ђжхœ Ю%‡ђжхœ Ю%‡ђжхœ Ю%‡ђжхї%‡ђжхї%‡ђжхї%‡ђ‡ђя&ж‡ђжœ њ&‡ђж'‡ђ%'Nжœ 0'‡ђжœ њ&‡ђ–жœ \'‡ђ%'Nж|'‡ђж'‡ђ–жЇ'‡ђ$Nжœ 0'‡ђ$Nж|'‡ђжœ њ&‡ђЦ'ж6!в'‡ђЦ'ж№'‡ђ (ж6!"(ЂЫ`‡ђ$`жœ 0'‡ђЦ'”ж6!0'‡ђЦ'”ж|'‡ђ (`ж6!I(ЂЫ`‡ђ$Nжœ ~(‡ђ$Nжœ ~(‡ђ$Nжœ 0'‡ђжœ њ&‡ђжœ њ&‡ђ–жœ \'‡ђ–жœ \'‡ђŽ–ЂFёИ(Ц(а(ф(ЂЫ`ї())()П‡ђ5)NжхF)‡ђ5)NжŠ)‡ђ5)NжхF)‡ђ5)NжŠ)‡ђ5)жхЛ)‡ђ5)жё)‡ђ5)жхЛ)‡ђ5)жё)‡ђж'‡ђ (ж*ЂЫ`‡ђ$ж|'‡ђ (`ж:*ЂЫ`‡ђ$Nжn*‡ђ–ї(Ї*`Б*‹ђ‹ђи*э*‡ђ§*жї –И(+‡ђжхї%‡ђж'‡ђжхї%‡ђж'‡ђї –Г‡ђ+0+‡ђ+0+‡ђ@+Y+.‡ђ+0+‡ђr+–Ђ‡ђ|+0+‡ђŽж‡ђŽ–Ђ‡ђж'‡ђж'П+Ђ+.‡ђ–Гї Д+0+‡ђ–ГFёИ(Ц(FёШ+ф(ЂЫ`Fёї())‡ђ‡ђ‡ђ–Г3єп+`”–mє–Г‡ђ–ЃГПй–Г‡ђ–оГы‡ђ–№+,‡ђ–жхН&‡ђ–жЇ'‡ђ–жхН&‡ђ–жЇ'+Ђ+( ,П+Ђ+–S,3є ”–43є ”–r‡ђ|+–{,‡ђŽж‡ђŽ–Ђ‡ђ–жЇ'‡ђ–жЇ'+Ђ+•,П+Ђ+.‡ђFёО,.‡ђ–ГFёї(г,–с,‡ђ–њ,-‡ђ‡ђ–Г‡ђ–Г‡ђ–Г‡ђ–ГПЦЂ+ъ‡ђ‡ђ–Г–Гї –ГП+Ђ+h$-‡ђŽ–Ђ‡ђ–ГєПA-Fё‡ђFё‡ђ‡ђ‡ђ‡ђFёO-Y-ЂЫc-ЂЫc-e-€-ƒ-˜-€-В-Ц-€-м-ф-м-і-€-м-E.м-ЂЫЂЫ~.‘.–.€-‘.Ќ.€-‘.К.‘.ЂЫХ./ЂЫЂЫ /Є/Ћ/В/Й/Р/Ч/Ћ/Ю/е/м/ЂЫу/і/ 0ЂЫГРАЩ0'0-0-000АЩЁ} 40M0f0l0ЂЫq0-0v0z0v0ЂЫсЧBиЏGIЅЅІІДДЖЖММООСССљљњњњ;<<GN<ЧO‡“аDаH“•PN>QЙAЌ9BС•ЙDЙO†’‚BЯc‚C.ђѓ13LMNT[\wxyz{|ƒ„…†‡ˆИЙЛНШЩлмнопрцчшщ:„…Š‘‘D“‚Dk"OОkDыDkE/ыHšFKOUыKьєFcн#5HIJKLMNTZ\abcelmnstuz{|€†‡ˆЎЏАБЕЙНЦЧЩЫабвзийопрфшщ];ˆš]Cё]FLMнFa]IЉнKшІ/ХыіBC02:ІH‡ІJЯSYТћНBcЛМФХЦЯабвдеикыэюяёђѓєіјљћ§ўџ$,0BGHI^apqrstu˜šœž ЂЃЉЊЎЏФЦдежзий02>?@z{‚ƒ„…†‡ˆ‰Š‹‘‘ЏВГF@˜IЏM˜NFFOOPPUUVVhiillqqqssuuww——aМaAЄaGkЪ 13yJ Fљ§'+7;=?ijklmnpqrstuwxyz{|~€ƒ„…†‡ˆЭЮЯабвдежзийлмнопртуфцчшщ"$&(,ЪюJBХЪHJKнЪLг CS@>cdSAŸFKluwSC№БSE-SFKSHSPЎМ@iМE69?GHIJKLMN[\^_`abcijklmnpqrstuwxyz{|~€ƒ„…†‡ˆ˜™š›žŸ ЂЃЄЇЉЊЋЌЎЏАБИЙЛНФХЦЧШЩЭЮЯабвдежзийлмнопрцчшщ "#$%&'(*,>?@‚ƒ„…†ˆŠ‹ЌЎАБГїGxїM12їOŠ–@$679;<=>? "#$%&@FIРKц@Lњ)BПСщыєі!“•/0129)FF)LљЉO…‘2fВ@cВAЌcВBеВE52Gg2M›BгЎCшА›Cєі›DhlI V›NJK›O„d    2244EFFOORRRUUXXqф@oфCўЭ# PQSVWYПРТїјћMAžEIktvMCяЭJвЭKшщMLњVMPV;:DжBнф ЁЈVIЇПA­dПCј?E,ПJбПM'ПNSbD”ˆFXCхЉz@sD‚ЛМПСФХЦЪЬЯабвдеикщыэюяёђѓєєііјљћ§ўџ$,0@BGHI^apqrstu“•˜šœž ЂЃЉЊЎЏФЦдежзий./011228>?@z{‚ƒ„…†‡ˆ‰Š‹­ЏВГzBЬ­њCџ†ˆzDCCюУGtУIДЕЖљЌAЋ,H~ЕHŠY5LљH{JСžNNNOOPPQQTTUUVVŽŽ’’““””••––——gBЪ­чJеgKпчNprp@B№AЕpHƒй+ RXІСљњY@?eйH˜EINT"N6  24ORUXДЖМОСљњ‹#4Д Awy{§”@\}FR§HœN}O‚ŽЦЦA­ЦCљ§FE-FH€ЦM(,Џ F</Pž8 дњ8 ,89HIJKLMNOTUZ\abcelmnstuz{|€†‡ˆЎЏАБЕЖЙНОЦЧЩЫабвзийопрфшщИBAее1<<==>>??LLMN[[\\``ccxx{{ƒƒ„„…††‡‡ˆЛНШШЩЩллммооппццчшшщ##$$%%&&8HИIГД8PŸjj ъAБъLs тт6ІІsыі02ѓBптІsFRsJЪsPГ\BЧЌмCEљ§'+7;=?ijklmnpqrstuwxy{|~€ƒ„…†‡ˆЭЮЯабвдежзийлмнопртуфцчшщ"$&(,мL\M мM.\PА%BЅ\^ЅBд%CщыЅCє%P––ŽBбE%ДF@BŽIЎŽJЭ-RС—E 24ORUXДЖМОСљњрAБрH™IPЌвŠвCљвF`вM(Л "е CEMNT`cx{|…ˆЂЄГЕИЙЛНШЩлмнопрчщ:;Л 0Л‘эюјљћ§&')+12345679;<=>?HIJKLMNORTUXZ[\^_`abcdeijklmnpqrwxy{|~€ƒ„…†ˆЉЊЋЌ­ЎЏАБГДЕЖИЙЛМНОСФХЦЧШЩЪЫЭЮЯабвдежзийлмнопртуфцчшщљњ "#$%&'(*,­ЛTђђђѓѓѓѓ01123<=>?LMMNNORT[\`cxy{|ƒ„……†‡ˆˆЄГЕИЙЛЛМННОСШЩлмнопрцччшщщ#$%&:„„„…………ŠŠŠ;C–эюјљћ§&')+.12345679;<=>?HIJKLMNORTUXZ[\^_`abcdeijklmnpqrstuwxyz{|~€ƒ„…†ˆЉЊЋЌ­ЎЏАБГДЕЖИЙЛМНОСФХЦЧШЩЪЫЭЮЯабвдежзийлмнопртуфцчшщљњ "#$%&'(*,­ <=>?BЕHz|э!   00224CCEOOTTUЅДЖМО;ŠŠm;“–эE<mGlі#$%&v'њv;““––vAЅіE=?vKрњіL_ VЛМФХЦвдеэюяёђѓєіјљћ§ўџ$,0GHI^apqrstu˜šœž ЂЃЉЊЎЏФЦдежзий12>?@z{‚„…†‡ˆ‰Š‹ВГ_@@пGwy_N?P_Oyh@AЈ@bшBо ЂhCђ(DkЈDшIЛМ1A  ššqIЋБKцчБNQTvš Ka‹АОЩз’šZA кAЏZJШ#§у&X#@,ЃAЋcCёЃЄЇ#Djk#E'+#IЂЃNPUwуNgipqcOz}ЬAЎLD ЬE7; Ge IžOŒOƒе#QWРјBМiqUBЦŽ•BвfjE&)UGjеOˆ”P’’>  LORU[\ƒ„†‡ЅДЖМОСцш~E12>IЄЅ~NDSbBЛgp‡BаdE$AЙ\AЈЎFXKиOsuy-OUЖОy;“yIЌТBе 0CE+N84@4нф ЁЈ@^AЉBМя№Gš›žŸ ?@‹БГE&E34GqOtP’’ц#2МfIЊfJЩfMцO‰•OIІЯIИи!`cЂГЕXE.иE7XKо!BПСЁKфŠ ]rъѕњ (8A)ŠCѓ‘ŠE2NOŠH†ˆ“! EЅ;'љ“;;gipqJС|PVПїќ+F<|AЇќBт|H„E@9EХ@jХE6ХHŽ.E'.Kл7E,07FHЗGs7IЃAsE!Gd€JЫi !ІЌ­ЎЏАБВГДiAЄiFLщFbђCџ†ˆrD6ђH›[лIЙлJд[LњлNccddeeffgghhiijjppppqqqqrrssЄF[ЄIА$M4ЛПСЪЬЯаиктщє!5@Zde“•œ­ЪЫтуф./189‡‰­ЏВД MІ N45– ХыіBCE02:;–AЉџщ‚ЛМПСФХЦЧЪЬЯабвгдеиктшщыэюя№ёђѓєіјљћ§ўџ  !$%&',-./0567<=@BCFGHIJKLMRXZ[\^_`abcdefgijklmnpqrstuwxz{~€ƒ„†‡ˆ“•˜™š›œžŸ ЂЃЄІЇЉЊЋЌ­ЎЏАБИЙСФХЦЧШЩЪЫЭЮЯабвдежзийлмоптуфцшљњ#$'(./012689:<>?@z{‚ƒ„…†‡ˆ‰Š‹ІЌ­ЎЏАБВГД)+139;>?NTy|…ГЕЛНнрчщ "%&*,@LO\^žШF_QDВбGuQM:AЁƒ$ FІ<ƒAЇF=IEHƒI­KзM N1OrtьCџ’ьGwѕIЛЛННѕJжѕNqsоЫППССЪЬщщыыэюёєєііјљћ§!&')+12345667799;;<=>?HIJKLMNORTUXZ[\^_`abcdeijklmnpqrstuwxyz{|~€ƒ„…†ˆ““••š›žŸЃЇЉЊЋЌ­ЎЏАБГДЕЖИЙЛМНОСФХЦЧШЩЪЫЭЮЯабвдежзийлмнопртуфцчшщљњ  ""#$%&'(*,.//001122889?­^ 24ORUXДЖМОСљњоDЇ RXwzІСљњЇE4TU0D0FG—АF\D™FZGf™H†™JЮтE<>bHƒ…K ђѓ24„…KFJKGiдAЏ=D  НF^=Ov бƒ†;=@†M#%P‹—ящєјљ&',67<=@Lwzƒ†цш#$'(/1oAЅяM/ј@qјD!xGmxPДСvМСЪЬЯаеикя№ђђѓѓѓўџџ -.001123<=>?CGLMMNNORT[\`cfxy{|ƒ„……†‡ˆˆ• ЂЄГЕИЙЛЛМННОСШЩлмнопрцччшщщ#$%&.:@„„………††ˆˆŠŠ‹­ЏБГA@6ABФAJЦAPЃІ*@,.*AŒ’•дўЊGr*IЂЂЄЄГГЕЕИИЙЙ::*JФЊM$*P––3BПСЪЬщыєі0“•./01283CэГDГJа3N9@%,D–œM$&хM/0ePБNЅІЮ@kЮBкeЏNJЧNOwз@nWDзD Dl FCE .Gљ§'+7;=?ijklmnpqrstuwxyz{|~€ƒ„…†‡ˆЭЮЯабвдежзийлмнопртуфцчшщњ"$&(,‰@MP‰AЈ‰D8 Lюђљњ’Cѓ1133MMNNyy||……ˆˆннррччщщ…‘‘D•’D’GpHzIŸFJ’Kу’M#{CђђѓѓRRМОСС„„……ŠŠ‘‘{M{O}~DD  ,F;<DM­Bдў-Cщ­Cі12­DГ­IБ-OuЖxDИ6 ˜™š›œžŸ  >?@@HJ6"UЖЖCјћ6JХЖM'*Ÿ;<fhpq––A‚žŸ KйLљ DџџіL @@џџtwъL @@џџ hoмL @@џџ`cЪL @@џџT[іL @@џџHKъL @@џџ$;CмL @@џџ*03ЪL @@џџ0#+ЏL @џџ1‡ђ”ЅМам‡ђ”ЅМ‡ђ”ЅаM‡ђ”Ѕq‡ђ””ЅМаЂ‡ђ””ЅМч‡ђ””Ѕа+‡ђ””Ѕ]ЂЫ+Ї T`htw!0H`t .;Hht LT`htк'?WkВ, &(*>@BXZlnJKhТL6ЪL#TъL;hЛT`htѓЛ#0;H A(2;C#'(02;@HJTWX`bhltv{C#(02;@HJУI`[L ;?@HJhkltvгL%'()=?@AVWXYjklm”| !.9FOR^frє)AYmмL0`Э#!",./49:DFGLOPRS\^_dfgprsxzе# "/:GPS_gs5LXbMLlvЖN оT`htN#(02;@HJTX`bhltvV5vKtцL02HJ`btvіLHt ,46DL\dpxzяT`htЏL8%0=HV`jtИITXK(2@Jl DџџGR Dџџ : @џџ2фQ D;фQ D;фQ D;фQ D;фQ D;фQ D;фQ D;фQ D;фQ D; фQ D; фQ D; фQ D; фQ D; фQ D;фQ D;фQ D;фQ D;фQ D;фQ D;фQ D;фQ D;фQ D;фQ D;6R @џџ     „0="=+=4=>=G=P=Y=b=l=u==Š=“==Ї=Б=Л=Х=Ю=з=р=ЂЫ 'чROS_SgU@RU(UБ4ё9A: ySёTљT U :šSbTЛФ8Н8STЅT­TеT6RSfSОSИ DџџaX@џџddZX@џџccSX@џџ bbLX@џџaaEX@џџ``=X@џџ__4X@џџ^^,X@џџ]]X@џџ"SS V @@џџ&FG‘V @@џџ*DE‰V @@џџ.BCV @@џџ2@AїW@џџ8::ьW@џџ=99рW@џџC88жW@џџH77ЪW@џџM66РW@џџQ55ЕW@џџV44­W@џџZ33ЂW@џџ`22šW@џџe11W@џџi00jX @m//~W @џџ1o//~W@џџt..vW@џџw--}X @z,,lW @џџ1|,,lW@џџ€++bW@џџ„**ŽX @"ˆ))VW @џџ1Š))VW@џџ((NW@џџ’''ЁX @&•&&DW @џџ1—&&DW@џџ›%%2W@џџ ##S @џџ1ОGG>S@џџУEE,S@џџШCC6S@џџЬBB$S@џџб==S@џџз<<S@џџм88X8@џџт66Н8@џџч44S@џџь33S@џџђ22юR@џџї11чR@џџќ00йR@џџ//ѕU @џџhh%X @џџZZX @џџ>>–U @џџООzU @џџГГХR @џџ..ЖR @џџ **™R @џџ ЉR @џџ R @џџ !%15@EMShly€„ˆ‹ЈЌ‡ђ–2Ћ2рЖђњ#Жђњ#Жђњ#Р2Э2Жђњ#Жђњ#Р2Nу2‡ђ–2Ћ2N3‡ђ–2Ћ2рЖђЬ# Жђњ#93P3Жђњ#аЭ2Жђњ#n3P3Жђњ#аЭ2‡ђ–2Ћ2Nх†3‡ђ–2Ћ2N3‡ђ–2Ћ2Nх†3‡ђ–2Ћ2N3‡ђ–2Ћ2хЫ3‡ђ–2Ћ2р‡ђ–2Ћ2хЫ3‡ђ–2Ћ2р3є’#:Nх43є’#:NA4Жђ”хm4р#х4ЂЫ`њ#`хЖ4Жђ”р#1ЂЫ`њ#`lЖђ”хm4р#х4ЂЫ`њ#XхЖ4Жђ”р#1ЂЫ`њ#Xlњ#XР2ф4Жђњ#Р2Э2Жђњ#’#•"Р2N5Жђњ#Р2Nу2‡ђ–2Ћ2Nх†3‡ђ–2Ћ2N3‡ђ–2Ћ2хЫ3‡ђ–2Ћ2р:5W5ЂЫ`ёX~5ЖђЬ# Њ5Е5ЂЫ`а5Xо5ъ5Жђо5жЖђњ# 6 636Жђњ# 6P3]6Ь#93р3єЬ#n3р]6Ь#аm6]6Ь#n3рЖђ'!‰6”A4B"‰6” 6ЂЫ`’#е6:ц6ј6‡ђ–2Ћ2N3Жђ'!‰6”A4B"‰6” 6ЂЫ`’#е6:ц6ј63є:N273є:N273єЬ# 3єЬ#n3рЖђ'!‰6P3B"‰6W5ЂЫ`’#е6:~5‡ђ–2Ћ2р]6Ь#аm6Жђ'!‰6P3B"‰6W5ЂЫ`’#е6:~5ЖђЬ# FёS7Ц(FёS7^7g7FёS7Ц(FёS7^7Nv7‡ђ“7|+NЅ7FёS7Ц(‡ђ“7б7.‡ђ“7б7.Fё5)0+Ђу7э7є7ў7FёS78/8FёS7Žg7FёS7G8/8FёS7Žg73є%'5)Nх\83є%'5)N•8FёЛ8хЩ8ц8х§8ЂЫ`S7`х#9FёЛ8Ц(ц8ф(ЂЫ`S7`)FёS7N9a9q9FёS7N9/8ј$|+8.3є|+G8.FёS7Ц(ј$|+Ž’9ј$|+G8.S7`^7NЇ9FёS7^7Nv7FёЦ'в9”•8 (в9”ц9ЂЫ`%'е65)ц6:‡ђ“7б7NхI:‡ђ“7б7NЅ7‡ђ“7б7NЅ7FёЦ'в9”•8 (в9”ц9ЂЫ`%'е65)ц6:FёЛ8хЩ8ц8х§8ЂЫ`S7`х#9FёЛ8Ц(ц8ф(ЂЫ`S7`)Ш+ˆ:š:ЂЫ`ї(В:о5Ц:Fё‡ђжШ+у:§:ЂЫ`ї(В:Д+;FёД+0+3є|+G8.‡ђ“7б7NхI:‡ђ“7б7NЅ7‡ђ“7б7NхI:‡ђ“7б7NЅ7‡ђ“7б7хD;‡ђ“7б7.‡ђ“7б7хD;‡ђ“7б7.‡ђ“7б7хD;‡ђ“7б7.‡ђ“7б7.ј$|+^7’9Fё5)0+Ђu;€;`‘;u;е6€;ц6З;3є|+Nы;3є|+Nы;3є|+0+‡ђ“7б7.FёЦ'в9/8 (в9§:ЂЫ`%'е65);FёЦ'в9/8 (в9§:ЂЫ`%'е65);%'я&Ц:FёS7^7g7‡ђ <<`-<Ђu;€;^7`Y<Ђu;^7`ў7u;е6€;ц6З;Ђu;€;`‘;‡ђ <<`-<‡ђ <<`х„<‡ђ <<`-<У<а<^7Nс<Ђu;€;^7NY<ЂЫ=ЂЫЂЫЂЫЂЫ =ЂЫ0ЂЫѕGI%ёёђђђјјљљљ      &'')**,--/00GSGHLMŠŽš›ёђјљ  UЂКЛW0ySOљTŸИЙB 48\^ТB0z~kT~4X^ahЧЮуъNUB ŸДЕИЙѓ@ADET xžЁЖЗњBCнTœ]UЌ]VІ/CEJXz~„ˆ˜ЇЊяі  #%(+.fSN&Tyz{OSHЯUжX ˜ ЃЅX›и!/468<CEJX\^ˆ˜­Ўяі  12X846иUзaЁSmдсV!W_aXdJ 2oqsuw„…†–ЌЎ()*./02468:Š5DIQW}‡—Єюѕ§  WŠW/ЪW6г66EJXXˆˆ˜˜яі  “!‚Ј&,SVўSXb|‹ќ+HMƒ†Ž›ЉЌђљ '*-0 {€š›ј  ^GHLM{ŠŽš›ёђјљ  >SEGОSpVѓ@A~W./0XPSЇ H›љ чR0ПРчStgU­чUйgVЇVАVY[%†Ќ*0™RйR/<™VтR/08<Blœзй "#_abT|bW*ЂW2 € A!#%ЫT˜š›KVќ4\^дVН84§R123=§Sv}Tƒе=X_ЦSqVхшSЏ ­Ў12я /<я By|œЃ"/UЃЅoUЎoVИB3//00666PPRRTXXXtuvwˆ‘“•–˜œ­Ўжзќќўў  12789:^_ИUгСk///0012346688<<=BCCEJPRXX\^ltuvwz|~~€„ˆˆŠŽ‘“•–˜˜š›œœŸЇЊ­ЎДИППжззйяіќў      #%(+.12789:D^_" GL{€…Ћёј)/U иV *I ##%%((ЊSnгЊUППР*W!`s fyz{˜ЬsS#Nmnopqrstuvw‘“•–гдє3456789:]^dГSosT‚мC2oqsuw„…†–ЊЋЌЎ()*./02468:S<%,HMЅTŽ%Vє%XZN‚ƒ…†ЈЉЋЌ&')*,-/0S3VяёNW'b—EGHLMŠŽš›ёђјљ  WT|~€UЂКЛFGVђрUи VFGZрW8 .2oqsuw„…†–ЊЋЌЎ()*./02468:IT{€ UЁIUЉк‰VBC’C66CCEEJJXXˆˆ˜˜яяіі  ’ScfЬЛ EGz~˜і ЛQ/012348<=COPPRR\^tuvwxz~„ŠŽ‘“•–š›œЁЇЊ­­ЎЎПжзњћќќўў    #%(+.1122789:^_{C ŠŽŽš››   Ф8\^DD{€DVћDW%&X=>э!;11122233344488<<<===GL\\\^^^{€‚„„…ŠšЇЇЈЊЊЋёј &)++,..mS$Nmnopqrstuvw‘“•–гджє3456789:]^d­T‘“­UПР­W3Ж"А<lіPRќў6"Šš 6)Ž› ЖR*6SBй6UЅvW-c_ п CJL‚„…ˆŠŽЇЈЊЋяё #%&()+,./_SMUЃЅhЅш *0lžŸЂѓшBbШфOшTœз(UЃё$HMђљ1A::ХХLLёSuёTžЖЗБUЩЬšSlДЕšW1ZXc#Q§c 011223346<==X\^ПcCCBOPRTlx„œžŸ ЁЂЃЅЇЊДЕЖЗИЙКЛежзийкшѓњћ!"#%(+.@ABCDEFGS_`abcLXal DџџZ Dџџ: @џџ28-фQ D;8фQ D;8фQ D;8фQ D;8фQ D;8фQ D;8фQ D;8фQ D;8фQ D; 8фQ D; 8фQ D; 8фQ D; 8фQ D; 8фQ D;8фQ D;8фQ D;8фQ D;8фQ D;8 фQ D;8 фQ D;8 фQ D;8!!фQ D;8!!фQ D;8!!фQ D;8""фQ D;8""фQ D;8""фQ D;8##фQ D;8##фQ D;8##фQ D;8$$фQ D;8$$фQ D; 8$$фQ D;!8%%фQ D;"8%%фQ D;#8%%фQ D;$8&&фQ D;%8&&фQ D;&8&&фQ D;'8''фQ D;(8''фQ D;)8''фQ D;*8((фQ D;+8((фQ D;,8((фQ D;-8))фQ D;.8))фQ D;/8))фQ D;08**фQ D;18**фQ D;28**фQ D;38++фQ D;48++фQ D;58++фQ D;68,,фQ D;78,,фQ D;88,,Z @џџ98      !"#$%&'()*+,-./0123456789:ОV„0ЪVЯVиVрVщVђVћVW WW!W)W4W=WGWSW]WeWpW{W…WW›WЇWВWМWЦWЯWлWфWэWіWџW XXX%X/X9XCXMXWX`XiXsX|X…XX—XЁXЋXЕXРXЪXЂЫB'gV' V)АV* h,љ= йH‰V(™V(d) fygI ВgЛл= ыHI!kg д8,ЄI"DV&фg*§H]I­W%6 fM!Цg#іg ПM#oV'яc)d$Б4ё9A: qI#V'‘V(h+ :-ЪL!šW*кg$ъgI#IЬ8+ I мL"`@џџУPyy4`@џџЩPxx+`@џџЯPww!`@џџдPuv`@џџиPtt `@џџнPrs`@џџсPqqј_@џџцPppя_@џџыPooц_@џџ№Pnnо_@џџѕPmmЖ_@џџљPdd_@џџџPYY–_@џџPXX_@џџ PNNу[@џџPKKХ[@џџPJJЄ[@џџPIIе[@џџPHHД[@џџPGG…[@џџ#PFFh_@џџ&PCCЄm @є)PBBO_ @џџ1+QBBO_@џџ/QAAF_@џџ3Q@@=_@џџ6Q??i[@џџ:Q>>P[@џџ>Q==_@џџBQ<<§^@џџFQ;;ђ^@џџJQ::н^@џџNQ99Ш^@џџQQ22Р^@џџTQ11В^@џџWQ00Ё^@џџ\Q((—^@џџaQ''Ž^@џџeQ&&s^@џџiQh^@џџmQ^^@џџpQR^@џџtQG^@џџwQ;^@џџ|Q  ,^@џџ€Q   ^@џџ„Q  ^@џџ‡Q   ^@џџ‹Q  ^@џџŽQє]@џџ’Qщ]@џџ•Qр]@џџ˜Qд]@џџœQЫ]@џџŸQП]@џџЃQЖ]@џџІQЊ]@џџЊQџџЁ]@џџ­Qўў•]@џџБQ§§Œ]@џџДQќќ€]@џџИQћћw]@џџЛQњњk]@џџПQљљb]@џџТQјјU]@џџЦQїїK]@џџЩQіі?]@џџЭQѕѕ6]@џџаQєє*]@џџдQѓѓ!]@џџзQђђ]@џџлQёё ]@џџоQ№№]@џџтQяяї\@џџхQююp\@џџцQааa\@џџшQЮЮY\@џџщQЫЫ+\@џџъQРР3\@џџьQОО[ @џџьWzЖm@0-эW{{Эm@0-юW||щm@0-яW}}n@0-№W~~ n@0-ёW5n@0-ђW€€[ @џџђ]qxJn@04ѓ]rrdn@04є]ssƒn@04ѕ]ttЂn@04і]uuРn@04ї]vvиn@04ј]wwєZ @џџјcho№n@0;љcii o@0;њcjj)o@0;ћckkHo@0;ќcllfo@0;§cmm~o@0;ўcnnЖZ @џџўi]d–o@0Bџi^^­o@0Bi__Щo@0Bi``хo@0Biaap@0Bibbp@0Bicc˜Z @џџiWWRf @џџi§e @џџi]]e @џџiППЋc @џџ i––Pb @џџ i––b @џџ i““zb @џџ i’’rb @џџ i‘‘ƒb @џџi;b @џџiaaa @џџiRRћa @џџiMMыa @џџiLLтa @џџiKKмa @џџiJJЦa @џџiIIЖa @џџiHH­a @џџi==a @џџiццф` @џџiннШ` @џџiдд™` @џџiЦЦЬ_ @џџi††{` @џџi‚‚Ѕ_ @џџiffа^ @џџi]]}^ @џџ i44ч\ @џџ!iк\ @џџ"iффЪ\ @џџ#iууС\ @џџ$iссЖ\ @џџ%iррЉ\ @џџ&iппž\ @џџ'iоо”\ @џџ(iммŠ\ @џџ)iлл€\ @џџ*iккy\ @џџ+iййA\ @џџ,iШШ\ @џџ-iКК№[ @џџ.iГГЖR @џџ/iААЁZ @џџ0i™™–[ @џџ1i••v[ @џџ2i””^[ @џџ3i““D[ @џџ4i’’4[ @џџ5i'[ @џџ6i‡Z @џџ7iXXwZ @џџ8i++mZ @џџ9i**bZ @џџ:i#',056789:;<=>CI^imqŽ–—˜™š›œžŸ ЂЃЄЅІЇЈЉЊЋЌЎЏАБВГДЕЖЗИКЛМНОПРСТУФЦЧШЩЪЫЬЭЮЯаѓ./012356789:<=>?@ACDEFGHЖђ ?R$є7у2Жђ ?R$є7у2?&?2?E?ј6Жђ?2?є7A4?&?2?E?ј6Жђ?2?є7A4‡ђP?2?є73]6c?R$є7u?‡ђŸ?Г?‡ђТ?Ы?в?‡ђу?я?3єЦ'@”@,@]@ (m@”@ƒ@ЂЫ`]@%'В:Э@`@т@3єЦ'1A@AA]@ (1A@[AЂЫ`]@%'В:а@ŽA3є'!ЦA”@йA]@B" B”@ BЂЫ`]@’#XЦAє7@jB3єЙBЩBВ:@мB3є CВ:@CЂ‡ђжAC‡ђICaCЂЫ`а5XICЮ>ЖђICњ>Жђё1ЂЫ`а5XlЖђё1ЂЫ`а5Xl3єа5XЅˆCх–C3єа5XЅˆCсCD1DЂЫ`а5XDUDЖђD~DŽDžDЂЫ`а5XˆCРDЖђˆCчD‡ђ‡ђ‡ђ‡ђ‡ђ‡ђ‡ђ‡ђ‡ђѕD E(EBE^ExEЂЫъEќE FF-FFFVFoF}F”FЇFУFбFшFї -FFFoF”FУF_Gї ‡žGЕGЪG‡žGљGHЂЫ`‡žGЕGXOHŒHЁHр‡ђЗH ї ЕGбHчH‡ћHIљGбHчH‡ћH`IЂЫ`КIXбHчH‡ћHЯIЖђ.JѕDXA4$Ь#AJSJх^J$Ь#AJSJ•JєЬ#AJSJх^JєЬ#AJSJ•JєЬ#хЙJєЬ# ЖђпJGSJѕJпJGXSJKЖђKKGSJXKKKGXSJsKйЬ#хЙJйЬ# ‡ђЬ#хЙJ‡ђЬ# œKЬ#хЙJœKЬ# ЃKЕKаKшKLB"аK+LЂЫ`LG•"аKbLЖђаK žLЬ#AJSJх^JžLЬ#AJSJ•JйЬ#AJSJх^JйЬ#AJSJ•JœKЬ#AJхЌLœKЬ#AJоLЖђ§L'!SJM§LB"SJ3MЂЫ`]MGXSJpMЖђŸM'!SJЋMŸMB"SJУMЂЫ`фMGXSJюMЖђя&'!SJNя&B"SJ+NЂЫ`^7GXSJKNЂу?я?ЂЂЂpN]$‡ђЅхœ ­ ‡ђЅхї‡ђЅхœ ­ ‡ђЅхœ ­ ‡ђЅхї‡ђЅхї‡ђЅœ й ‡ђЅ"‡ђЅœ й ‡ђЅœ й ‡ђЅхї‡ђЅ"‡ђЅхї‡ђЅ"‡ђЅ"‡ђЅ"‡ђ}N Ђу?я?ЂpN]$ЂЂЖђё”NЂNЂЫ`ёXШNкN‡ђŒHOO‡ђŒH2ODO‡ђŒHeOwO‡ђŒH˜OЇOХOЬOmѓгOгOгOХOє є є єХOЬOmѓгOгOгOХOйO є є єХOЬOmѓгOгOгOХOєрOрOрOХOЬOmѓгOгOгOХOйOыOыOыOХOЬOmѓгOгOгOХOйOрOрOрOйй‹ђ‹ђmѓmѓ‡ђГ ђOЇ*‡ћOP5PђOЇ*‡ћO}PђOЇ*‡ћOP5PђOЇ*‡ћO}PђOЇ*‡­PХPђOЇ*‡­PХPђOЇ*‡­PХPђOЇ*‡­PХPђO‡ћOPѓPђO‡ћO6QђO‡ћOPѓPђO‡ћO6QђO‡­P ђO‡­P ђO‡­P ђO‡­P ЖђaQoQЭ‡ђ‡†Q”QЃQЛQ‡ђ‡†QЃQнQњQ‡†Q”Q RR‡ђHR]RwR‡ђHRR­R‡ђHRЩRцRђO‡]RSђO‡R'SђO‡ЩROSЖђwSŽS1ЂЫ`wSXl‡ђЎSЪSр‡ђ‡ ‡ђHRцSTђO‡цST‡ђ‡>TRT‡ђ‡Ї*RT‡jTRT‡ђ‡jTRT‡ђѕD ‡ђѕD ‡ђѕD ЖђzTG%$NЖђzTG%$NЖђG%$…T‡ђ—TЁTАT‡ђ—TхвT‡ђ—Tя?‡ђ—TхвT‡ђ—Tя?‡ђ—TЁTхїT‡ђ—TЁTАTЂ—TхвTЂ—Tя?Ђ—TхвTЂ—Tя?‡ђэ7х,U‡ђэ7ж‡ђ—Tя?‡ђ—TхвT‡ђ—Tя?‡ђ—TхвT‡ђ—Tя?‡ђ—TхвT‡ђ—Tя?‡ђ—TхвT‡ђ—Tя?‡ђ—TхвT‡ђ—Tя?‡ђ—TхвT‡ђ—Tя?‡ђ—TхвT‡ђ—Tя?‡ђ—TхвT‡ђ—Tя?‡ђ—TхвT‡ђ—Tя?‡ђ—TхвT‡ђ—Tя?‡ђ—TхвT‡ђ—Tя?FUFUWU ѓ ѓ‹ђ є є єєpU‹ђ є є єUpU‹ђрOрOрOєpU‹ђрOрOрOUpUžLЂЫЂЫЂЫЂЫЂЫˆU›U­UОUЂЫЂЫЯUиUфUьUїUVфUЂЫЂЫЂЫЂЫЂЫЂЫЂЫЂЫЂЫЂЫ V#V*V/V4V9V>VBVFV /ЂЫJVЂЫ =ЂЫZVgVuV…V–VЅVЂЫЗVАЩЂЫиаHЂЄа^7]аaA‚C&'(ЧШЪЬдечшщъыьђѓєѕEknq{Š‹Œ‚ffhijxyzk ‘“—k"ЭkTњћk]љ Нkg‰]IИ]Vъьэ]g†&bmv&bL]МЦайєBЇЉЋ­ЏБВИЙНОаврстуфх"#%';=IJK_<aсѓ#dwM [zHK`th БВГДЗЛРФЩЯдисV§с\фЪљЪH7lžЪL ЪWЪ\уЇФгемъъ№№ЅЅІІРРддМcklМg‘“…Kю…[‹FnBN9nM)-nNKawєw!ИЙКЛМНОПРСТSUф&(*,ЈЊЌБЗРЩднщw/Vdvwxyz{|}~€ŠЇЈЉЊ­ЎЏБВГЖИЙКЛНОПРЧШЪЬабвгдейклмнорстуфхчшщъыьђѓєѕ"#%'()+-./012357IJKwV№ђѓwZ+w]њ”Бwc‹‘wfdelm@$()+-./01емтфцъ№–ŸЁЃЅІ@L@aюў,@d{|)B-9:;<=?FGHNRSXYmnopqrtuwxyz{|~ЂЄ:;<=DЊЌ­ДЕЖЗЛ)L2lmoprsГ2M"%2W 2aьќ*2bM^IЏaфZalu~ф`знфb}фg™Э stu|}~$%&234xyzЭ#ЙКМТУЦЫЬЭажзйЭJоЭKєѕЭVќжB *ŸІЩа4;жWжdПJнПM2ПNЗ^П]ЄСПfqˆeДЕЖˆfhijˆg‹‘Vѕ*+‘\лz+˜z@'ELЂЄЇЉЋ­ЏБВИЙНОаврстуфх"#%'9:;<<==CIJKЈzbs’zeДЕ, Щ,/,Vмо,XC,^ Ž‘’“”•–—˜ЋЌ­ЎЏАБВГДЕ,dz}5 tuvwxy‘’“5L5Vп5^  JЮVй&'X69чJсч\щ№[ВГ№gЈЉй+ЕЮйHЇPTY_йbzйcpЂWЂbw‹#У‹btuŠ™”\м“ АН”dŠ”fh}^4F …?F_@/Uјљ/c…8 =>FGHIJKNY\]^o{|8#/1}~…†ˆНОПРФХШЬЭвгезмноуфхъыь№єѕ !8eЊ" pзоќџfjzhЌщъъ%­ъLъgЈѓѓ` иьђќ"*0ѓgЈЉмCiяёѓѕїљћ§џ   dИИЙЙККЛЛММННООППРРССТТz|ƒ„…†‡ˆйклмнорстуфхчшщъыьюя№ђѓєѕ!#')-/137uwyƒ…‡‘“ mмLмM9мaBJЅ\оЅ_`fЅa)=K^ŽIНŽJйŽ^!&—EУХЫЭЮlmoprs|зиопьэђѓŽ“”—˜—^"'`bopITџIf[R^Rf`;C[wxyz{|}~€ƒ„…†‡ˆИЙКЛМНОПРТУФХЧШЪЫЬЭЮабвгдежзйклмнорстуфхчшщъыьюя№ђѓєѕ !"#%'()+-./012357lm;^ ›œžŸ ЁЂЃЄЅИЙКЛМНОПРСТ;bUaBйX#$e›Пэ=>FGHIJKmnopqrtuwxyz{|~э!%BppДУХЫЭFlor|ЌЕзоьђќџ fjptzŽ“–—mSкю CDJmZ*эeММmfdі./01тфі Љv'vKьіLvWIv[‹”іc tuvwxy‘’“іgЊ_ ЇЉЋ­ЏБВИЙНОаврстуфх"#%'<=IJKп Aеъьэ  _@A_NJ[_O_aђ"0пcqrпfxyzЈd‹(hпрт1A ааййттљљ2БKђѓБN\_1_>IJK1fXšЪЁ™šWšaJ]šbvfUc ŸЁЃЅІc cC6ВГЖtuvwxy‚ƒ„…†‡Ž‘’“Юйрсєѕіїјљ§  &'()*+,-9EFGHIу[•KЬ8ЗLXGЬZ_js|Ь_i†Ьbz|Ьdе Cqиэ EFGHIе"lor|е#КУЬЭзU,qе<z{|}е[”HU]їŸМеfu> ДУХЫЭЮђєlor|ЌЕођѓќџ>IГД>`yЗ^‡ZVX\ДЩІ‡\к ‰‹&Ж,­ЖAKKфW`ƒ€bu“eЖy-ХЭy;oprsљ= …ŠŒŽ’“”–—˜ЊyIЛy\йфœЌЙyg‹B ŸЁЃТBћeilmosyТ_d+NC+\ИРТ+`wЋcg–+eЊЌ4XD4[‡Д[’G4`x *ŸІЩа4;BЉЊ­ЎЏJKйѕ&'*+‰’Tрєі()\ЖИКЇФ_SYbIцPц#ЫfIЙfJеfM(ц^9:ц_nf`~OIЕЯIЧO_ABX opefijopstyzX ЄЙКЛМћўи!БТФемъ№‘•ŸЁЃЅІX8ЃЅФXKъиZ`kt}Xaё!/иeЛЛЁK№!WEЁZ[™!]ђ­Ё]ў–ГЁ^#(!`u!c„!dy!eЄЗИŠ $*4длущяЄПг #“ WŠWŠ\л‘•–—žЂЃЄЎВГДЛПРС `rŠaћ“!BДF pt'“8ЗР“;<JЮ`sv}€fT|ЙТЫжќ+CGmpsипэѓ quќb€E@:FХH67klžEXFХZ^ir{Х[“JХ`››œœžžŸŸ  ЁЁЂЂЃЃЄЄЅЅ.Kч7IВЗVњћќ7dz Рд€JзWD€\кф­К]я›И€]ћЁОaрцi 9CDEFGHIJщ/­Жi[Š>щ]ЇФrDAАўђHЊђ^:ђaDYrbr‘rg ŠŒŽ’“”–—˜лIШлJр[L[eВЄIП$M!Є[ŒIЁюя№ёђѓєѕіїјљњћќ§ўџ     &'(0129;<=>?@FGHIJKRSЋЌ­ЎЏАБВГДЕЖИЙКЛМНОПРСТФrstu‹ŒЂЄЋЌМжзюя№ !9:<CDtuvwxyz‚ƒ„…†‡Ž‘’“ЄВЮйкрстфюєѕіїјљњ§ &(*,9CDJ M N?@ЎЏ •ЅІ– F:ABNop;=EFklnoqr{|}ŠŒЊЌГДЕИНезмоъь№ђћќўџ   efijopstyzŽ‘“•—ЅІРдW–[Œ•–_RXaф–c“eЁЄџ=LОРЫЮаюя№ёђѓєѕіїјљњћќ§ўџ     &'0129:;<=>?@ACFGHIJKNRSXYdmnopqrtuwxyz{|~ƒY\]^oqrstuvwxyz{|}~€ƒ„…†‡ˆЂЄЇЈЉЊЋЌ­ЎЏБВГЕЖИЙКЛМНОПРЧШЮабвгдежзйклмнорстуфхчшъыюя№ђє !"#%'()./239:;<=ACDEGIJKkmnpqstuvwxyz{}€‚ƒ„…†‡Š‹ŒŽ‘’“Є­АВГДЖЗЮийкпрстэюѓєѕіїјњћ§ў   9CDEFGHIJdehilmoqsuxyˆ‰‹‘”•˜™ЁЅІТФЪЬщьѓѕ+-0157ЊИемъ№љ Ш^2H`zШ`ЮдHaяџ-ШeККQM#Qa№ .бcno:AOSК^012ЄНƒ нƒ$CЕG quƒ,ooIЌPSƒIМKуMN<ƒbtl$'(ЊЌ­ЗЙьVClWьWьd’u8ŸЁІиѕIЪЪЬЬ{{ѕJтѕUХNѕVо0129:;<=?@@FGHNRSXYmmnnooppqqrrttuuwwxxyyzz{{||~~Y\]^vwxyz{|}~€ƒ„…†‡ˆЂЂЄЄЉЊ­ЎВЖИЙКЛМНОПРТУФХЧШЪЫЬЭЮабвгдежзйклмнорстуфхчшщъыьюя№ђѓєѕ !"#%'(())++--./0123579::;;<<==CCDJtuvwxyz{|}‚ƒ„…†‡Ž‘’“ЄВГГДДЕЕЖЖЗИЮзийккмопррсъьэюю№ђѓєєѕііїїјљўџ  &((*,,9CCDDEJJlm’“”нщо &'(З^|ЌЌЌЌ­­­­ЕЕЖЖfjzŽ—˜оD@^[Š“^^о_mо`вЇ ЕЮmps‹­ЖпѓЇVјљ'[†'_=>FGHIJKЇc ЇfmА _`ajklєѕіhij0#Ž—АVјА`АdŒ.ПЪЯO%™Jк™Vі™`‰ЦdxтR knqŠ‹Œ EGbWbZb]ј“АтaCKЫ:rsKVтцK]і’ЏЫ]˜ЕKc‡ЫcmKd{|д }ŠŒŽŽ‘’““”•–——˜д8ЩдV§ўџд\уд]ЅТ= Юа  =&mpsН8ЃЛ=XEН\р=_?Нa@ †;>†M.0VЫЮ9[qGJ†_N†cŒ’†d†я<RSXYyzђє"#()./23:<z‹Зјњ§dhxяяM:oVюяZcnw€я_ooaє$2яb~яctoeГx$Y\]^Гј_pxaѕ%3xd„Сюя№ёђѓєѕіїјљњћќ§ўџ       &''((9:;<>AIJKNNNRSXXYYdwxyz{|~ЋЌ­ЎЏАБВГДЕЖИЙКЛМНОПРСТЄЏБГТФЧШЪЪЫЬЬЭЮдечшщъыьђѓѓєѕѕ./019EKkkkllmmnnnooppqqqrrss{ŠŠŠ‹‹ŒŒŒ‘’“ЄДЙКЛМемтфъъьэю№№ђѓѕњћћќў   *DEdeefhiijllmmosxyyz‰ŒŽ’––—˜™ŸЁЃЅЅІІЌБЗРЩдднщAJвA\ЧШС\с’ŸЏМAfZ*IB&&''((AAooББГГТТФФЧЧШШEEkknnqqŠŠŒŒЄЄЊЊДДћћўў    eeiillmmoossyy*JаЊM/ЊU!ЌЌ­­БББВВЗЗЗЛРРРФЩЩЩЯдддиннррщщъ*WF*]ѓКЊ]џЃР*aыBYЊeЗ*fW3}3B;wxyz{|~ЂЄ9:;<=CГJм3ND3\КОТГfopœM/1aщRœeЗИНhРРФддихM:;egˆN vДЕ  NJгNW HЮg•—з`Яэ§+Wd}} "Ќ Vї,-@ ^  hн .^яёѓѕїљћ§џ   ИЙКЛМНОПРСТz|ƒ„…†‡ˆйклмнорстуфхчшщъыьюя№ђѓєѕ!#')-/137uwyƒ…‡‘“ m‰DƒC€ Lљ§‰Vє() fRdeflm h Ќ­ЎЏнпфщъ’Cщщььѓѓѕѕееммъъ№№ЅЅІІIЎQU’Kя’M.{CЫЭЮЮьээђѓѓŽ—˜{M){_NSY{`‚~ћaEM{ffФ8ŸЁЯDDoppqFG}ќўџfjpqtuzDM#'DVсDW  D[‰’ФcklmnopqrsvwxyŠ‹Œ‘’“ФdŽDeЌ­ДЕЖ­C<=­IР­W­a=Ж ŸЇP O"чя6 \7юя№ёђѓєѕіїјљњћќ§ўџ        ЋЌ­ЎЏАБВГДЕЖИЙКЛМНОПРСТlrstuuŠ‹ŒžЇЈЉЊЋЌ­ЎЏЏIJKKSUˆ™6"Хьђ6)эѓ6JбЖM25ЖRА6UљЖZ]†=>Ж\р–ЃГР6]є‘ЎЖ]—ДЖ_dЖa@HЖeЙЙŸ;=ALPQRKхLhљш ІЈЋАйєѕїЌЏh@BшB  Ъ5шIЪЫh^h_ChcŠшcsё$ипqIКq_NRSXYZARZJдZXIк\фŽ•–—›ЂЃЄЋВГДИПРСZ_ABCкg˜#}›#IБЃN[`Ѓg— I­Z ]№ЌŒ]ќ•ВŒd‡ fS hБ]ёœЙ•]§ЂПcƒ~$ЋЌ­ЗМ~NMO~Wўcu~d…ўgЊЋЋGI1BCCpqqlmmopprss||ЌЌЌЌЌ­­­­­ЕЕЕЖЖЖНfjpqqtuuzŽ“”—˜GNGGS зиопьэђѓ“”G^PNI\P[‰=Pbg–Pe­9BЄ9aэ§+9fY^`qыD@ыHЉQVZ`ыKї ыaDLыfxєZh‡FIє]н#/mnopqrtuwxyz{|~}~…†ˆНОПРФШЬвгезмноуфхъыь№єѕ !нKєн^9І/:No;=Eknq{}ŠŒЊГемъ№ћў  ІJлa C\gŽ˜ јљ˜IО˜N<ŽŽ‘‘’’““””••––——˜˜™™››œœžžŸŸ  ЁЁЂЂЃЃЄЄЅЅЇЇQQZZ[[\\``aa˜ZWbvaѓaXJa\ЮвafdefJ aяёѓѕїљћ§џ   ИЙКЛМНОПРСТz|ƒ„…†‡ˆйклмнорстуфхчшщъыьюя№ђѓєѕ!#')-/137uwyƒ…‡‘“Њ mЈЊЌJKщJbY\]^S ЗРЩдS@?SAQQVSVфSXHS`{<–—˜Ю>ЖђК>њ>ЂЫ%2;w! (-5пf7ˆf*a Э# "#%/02;е##0 F – (5*I(*57‚f $(*-157Л(5c  (-5ыf1Kg -Sg(5|"/DD(*57”f$ @џџ%пq @џџ&жq @џџ'Щq @џџ)Оq @џџ*Гq @џџ+Іq @џџ-—q @џџ.op @џџ/АЩZZ&ZЂЫ1Z5Z8Z=Z5Z8Z[Z_ZCєhZjZCєoZyZъ|Z5ZˆZЂЫŒZZžZŒZЂЫЃZCєhZВZCєhZПZCєЫZдZкZCєcхZѕZCє[ЂЫA'Cчq !/0‡rBpCаq №q!0@r;ypЩq)Yr=ЉrFFHЂq 6+r6{rBdr=tr@фrTЭ# X 5<<­q­rFНrLf4:)NІq%жq+XYяZBBFFHopпq-Or;;˜ !!%)).//00??@@(r668Бa Wё9Lj :MU r3r6ЪrMГq&r/#r63r8Sr<ƒrBB| ќq)Lr;;BBBFFH%>.еrR^BОq'юq !!//00@@nr?ŽrCžrFHw Y—q$ЗrKNl Dџџеp Dџџ : @џџ2фQ D;фQ D;Фp @џџ Z„0ЂЫ 'Л :ФpЮp Б4ё9A: И DџџRq@џџ,,Gq@џџ++:q@џџ((]q @џџ 55Aq @џџ ))'q @џџ ''q @џџЅYБYя&жРђКYћY§YџYЂЫЂЫџ(CEї2:_OB'q&'Gq+8 ,hq3355;;==ˆqEС+a 3;Aq)2+,:q()Rq,jq5Л35;= A qsqCDd5M5]q35;=Ж0IўE^5– +,fq3355;;==~qDИ Dџџ @Aџџst, @Aџџ pqAџџnn<AџџfkKAџџ_d<Aџџ]]Ы|@џџ ')Й|@џџ##%‹|@џџ%!u|@џџ(Z|@џџ+E|@џџ03|@џџ3 |@џџ6юё!|@џџ8уцћ{@џџ;зйщ{@џџBЯев{@џџEЫЭП{@џџJХЩЅ{@џџNЖЙ–{@џџQВД†{@џџSЎА’~@џџTЋЋd{@џџW}€u{@џџYruЧz@џџa`gЋz@џџiW^šz@џџqNUzz@џџyELlz@џџ<CVz@џџ‰3:Iz@џџ+15z@џџ—#)&z@џџŸ! z@џџЇ§y@џџЎ ъy@џџЕЪy@џџЛњџОy@џџСѓјиx@џџФяё`y@џџЭфэ,y@џџелтјx@џџмгйТx@џџфЩбœx@џџыСЧvx@џџёКПdx@џџѕЕИUx@џџљАГAx@џџЈЎ)x@џџžІx@џџ–œџw@џџŽ”яw@џџ‡ŒR{@џџє}@џџ ||q}@џџ(ЩЯŸ|@џџ+ТФ}@џџ3КР3{@џџ7ЕИ!{@џџ;АГ {@џџ?{~њz@џџCvyжz@џџFrtшz@џџHhjн|@џџIddДv @џџIІ­X@0BJЈЈs@0BKЉЉ‰@0BLЊЊž@0BMЋЋМ@0BNЌЌЁv@џџNЅЅ}v @џџOЛt @џџP``4t @џџQAA#t @џџR@@>s @џџS--Ќy @џџVjj–y @џџ[iiE{ @џџ\;;чw @џџc77рw @џџj44иw @џџp11бw @џџv..Щw @џџ{++Тw @џџ€((Кw @џџ„%%Гw @џџˆ""Ћw @џџ‹Єw @џџŽw @џџ•’w @џџœ‹w @џџЂ€w @џџЈyw @џџ­  nw @џџВgw @џџЖ\w @џџКUw @џџНџџEw @џџРќќЉ} @џџТяяš} @џџФыы8w @џџХхх€6 @џџЧннw @џџЩйй"w @џџЬггљv @џџЮЛЛqv @џџЯššcv @џџа™™Uv @џџб˜˜Jv @џџв——fЂ[fmfЌёofћYЌё‹fffžfщfяfѓfјf§fggщfяfѓfјf§fgEgщfяfѓfјf§fŒgщfяfѓfјf§fЦgщfяfѓfјf hщfяfѓfјf?hщfяfѓf~hщfяfѓfАhщfяfђhщfяf&iщfяfѓfјf§fg[iщfяfѓfјf§fgŽiщfяfѓfјf§fПiщfяfѓfјf§fюiщfяfѓfјfjщfяfѓfјfFjщfяfѓfojщfяfѓf–jщfяfТjщfяfыj$k)k$kaknkЃЫkЃЫЉkЃЫяf!lЃЫHlŸЁ} АЩJl^ldl^lrlАЩul€l‹l4V9V–l›l lЅlŸЁ} } АЩЊlЗlФlбlоlrlBVFV /ŸЁ} АЩЂЫ@Чzp`Йkkllmmnn9ен &,28ЙzooppЙ|>#9~–˜žЈЊ‚C$,5>GP‚tMtw$тухцшщђѓѕіјљ   ()+,./124578є}|нtt]uyнvЋн|d&ooppІ/W`&zhŠt=vŠ|4юі~‰‘™ЃЋВЗѕќ &.7@IR[d˜w шщјљ4578a ъ:Hm‰J sx}ƒˆŽ—ЃВЗ†ЦЬаи№јЪHŠ‹Jv—ЪyctњЪ}@J~МФЮеощгs:мнпртухцшщьэя№ђѓѕіјљгеќ§џ    "#%&()+,./124578бwѕ.К^Кw№%њy8eeffgghhooppuuzzmEњz v†›У/1Mf~€У~Ьl$4=FO,dp,uv,y[лЌy `jlzl<ь| sx}ƒˆŽ—ЃЊЌ~Ц5ziv#u{*ru|:Е};оZcXtž~Гчs;gwрчwљ7Ї~ЗПч~Аt]0uw0v•Y>?_œcgqЦ{q|ЊтэAYtIЃz"gghhiijjkkllmmnnvvY}ЦЂt\тu†"wдейгйнхbw0пртухцшщя№ђѓѕіјљ   "#%&()+,./124578тyd A#е駧     #&),/258ЫteŽKw<мнпртухцшщьэя№ђѓѕіјљќ§џ    "#%&()+,./124578‹wц xќQ zg‹|;Ы|?'д Ybвгдuvд}A= ‡Ž–žЈКСЩглфНs9}v Ÿ45ую№іј§wћќ§ўџ  1ii}y \§yf НzoF"ћќ§ўџ   !"#1<iijj  — ЉБТЫмц№ЦOP‚†Œ–›ЁЉ„Ž—ОіVcFtH–—†wхцшщѕіјљ./124578†{,Ў†~†™Џ ѓњ #+3<EN/wеяwћP‡ioxVИ?BE]_fy|8 8wийфхјxZгј|БЖЛЪИ~ШСmw|‡œЂЊБЖЛНУЪЬ€ˆ‰‹‘“˜™›ЁЂЃЅЊЋ­ВЖЗЛМОУФЦЬЭЮадежинопсчшщъьѕїќў  %&(-.04679=?@BFHIKOQRT[]df™ГЗПЧШб$APuСvЈAxџTЈAzij*I,->?PQъx]ъyeu*}Нs %МОПЫЭЮŠ’šЄЌНХЯзрыєіћ§   '/8AJS\e3Xa3Bw|‡œЂѓBesuГwя"3{#Е3|7 \wпœxXСzg}Кьє%5,е #&),/258PQRSTWXYZ[\_bcdefghijklmnopstuvz}Ѕ\xЅ{.ЖОŽ^jŽvЂЮvЉ—^l—s6—u€W|8р5,е #&),/258PQRSTWXYZ[\_bcdefghijklmnopstuvz}рwј4`y \фЩwѓ+Izj+’Sb’wшx§R–R{'в{0Ы’~ЋЛ2`beŸЂЉЊЋЌ<ТУˆ˜ЁЂЊЕЛМУФЬЭЮдежнопчшщъYb?BE]`gy|;CПЮ{Oќќўў  .QQSSYY\\ћs<Лt `b)*r}„†—ћuˆћw(ћќ§ўџ   !"#)-.14>iiћ{2зћ~$B4„s5Duw}Вэ! ‡ˆКЛСУЩгдлнф??BBCEEF]]_`fgyyz||}mtLэvЌэ}vЖ#-ЖGdЁЛ6UИРіtuvxWК6}ОЭx2§§ўўџџ    /012RRSSTTUUVVXXYY[[\\]]``jj_xUŸ|<Тшzh1ArБUsqvšЉЊБxXq}Ще№јБ~Чбё~Zs1еwЬЭийšznNZ|9š} ыѓ§ #)/5~ŽЁЬчcCєћ#t @Chrsx‚ƒˆЉcv™Ѓy _czk PWŒxWŒ}ъ:<>Ь~ве<ZcUv˜UwнџUxUАjyZU~XY~/ўgMNOPpqst>s -9:;<=#ЕЗОybdsѓV‡\50uu}ЗљvКЛywу Тwђ(ТxYЩB}УТ}?@AB~ — ЉБЖТЫмц№аи+rЛЋwэЋzoW4tAD}ŽДvІ­О4wщцъ<fq_ћћќќ§§ўўџџ    79:PPQQRRSSTTWWXXYYZZ[[\\__bbccddiijjkkllmmnnssttvviifs2OћPOs0X $,5>GPиuиwі1иx]яЁ^n!e!v‹ЁvЅЈ!x§R!{"А!|5уŠx  'WWXXYYZZ[[\\Šzmy   ZZ[[\\|ќB Es/EwмќE{ %жэёѕљ;=ACE|8ЈФ Dџџ Dџџ Dџџ>Ќ @џџ&kї П$П-П*5GGJOOORRUZZZZ]]]``c'ЧФ *BCEEMMXX/ХBиФ+=BCGGJOOORRUZZZZ]]]``cХ58ХjЙ'.2335!ž8БФ%Х7і–'>Ќ'ОФ)2jоФ.S+У'78=jлФ ,578:;?BCjj+Х=<*t,єФ/0 Х3<Х DџџxЪ Dџџ7 @џџЕЫ @џџe‰ @џџ McтЪ @џџ.KмЪ @џџ%,F @џџ!!УЪ @џџЏЪ @џџІЪ @џџЪ @џџЪ @џџеЪ @џџ##‡ђКТУТЯТї пТэТFeї пТэТFeї пТэТћТУ‹ђУэ*ШŸШŸ‡ђШŸœK‡ђ$Уђ)7'ЎGЉ9Ъ?„‰NЋ)­CЫžŸZAšЅАZЉ4FI Њ]`…‡z­J2ЏAтЪ/Ry[TUVWXYZ[\^_abklmnopqrs{~ƒ†ˆЛ())+SA]`…‡3CšЅА{ :›І”•–УЪGJJ`‡•ыЪ/1CFINPRfhy’žЁЃІЋ­<˜МЦ?мЪ&Ы14PVWhpqЫ›ЇБэ•!ЭЌ35EHеЪ#|ѕЪ/1NPRfhy’ŸЂЃІЋ­~###F!344:EFFGHIIJ–fSЊЌІЪ 599:ACG]…”Ыf­ЏЪCFbџЪ /9?Aiwwwy{|˜&)*ЈDtuvŒAžŸЊЌАЪ6<A[„И DџџзЦ @@џџHIгЦ @@џџFGмЦ @@џџ DEЮЦ @@џџ BCЪЦ @@џџ@AЦЦ @@џџ>?ЦЦ @@џџ<=_Ч @@џџ:;РЦ @@џџ89МЦ @@џџ!673Ч @@џџ%45Ч @@џџ)23ЗЦ @@џџ-01Ч @@џџ0./ВЦ @@џџ3,-ЎЦ @@џџ6*+ЉЦ @@џџ9()ЅЦ @@џџ<&'Ч @@џџ?$%mЦ @@џџC"#hЦ @@џџF !cЦ @@џџI^Ц @@џџLRЦ @@џџOзЦ @@џџRгЦ @@џџUмЦ @@џџXЮЦ @@џџ[ЪЦ @@џџ^ЦЦ @@џџbЦЦ @@џџf  _Ч @@џџj  РЦ @@џџm МЦ @@џџp3Ч @@џџtЧ @@џџxЗЦ @@џџ|Ч @@џџўџВЦ @@џџ‚ќ§ЎЦ @@џџ…њћЉЦ @@џџˆјљЅЦ @@џџ‹іїЧ @@џџŽєѕmЦ @@џџ’ђѓhЦ @@џџ•№ёcЦ @@џџ˜юя^Ц @@џџ›ьэRЦ @@џџžъыЦЦ @@џџЂшщRЦ @@џџЅцчRЦ @@џџЈфхћЩ @5ЌзтgЩ @џџ1ЎзтdЩ@џџВЬЬaЩ@џџЕЫЫ^Щ@џџИЪЪ[Щ@џџМЩЩXЩ@џџПШШUЩ@џџТЧЧOЩ@џџЦЦЦJЩ@џџЩХХEЩ@џџЪРРУЧ @@џџЭЉЊВЧ @@џџаЇЈ№Ч @@џџгЅІНЧ @@џџжЃЄ­Ч @@џџйЁЂрЧ @@џџнŸ кЧ @@џџс›žгЧ @@џџф™šЮЧ @@џџч—˜ Ш @@џџы•–Ш @@џџю“”ЩЧ @@џџё‘’ЗЧ @@џџєЈЧ @@џџїŽіЧ @@џџњ‹ŒЁЧ @@џџў‰Š›Ч @@џџ‡ˆ•Ч @@џџ…†Ч @@џџƒ„Ш @@џџ €ќЧ @@џџ~Щ @@џџz{јШ @@џџuxюШ @@џџpsшШ @@џџmnуШ @@џџghнШ @@џџ"deзШ @@џџ%bcвШ @@џџ(`aЭШ @@џџ,^_ЧШ @@џџ0Z]ЖШ @@џџ3XYБШ @@џџ6VWЊШ @@џџ:TU›Ш @@џџ>RS•Ш @@џџBPQŽШ @@џџENOˆШ @@џџHLMƒШ @@џџKJK}Ш @@џџNHIxШ @@џџQFGrШ @@џџTDEkШ @@џџXBCeШ @@џџ[@A_Ш @@џџ^>?YШ @@џџa<=‡Ч@џџeЁЁpЧ@џџh  lЧ@џџl››hЧ@џџoššdЧ@џџr™™_Ч@џџv——NЧ@џџy””3Ч@џџ}ŽŽ/Ч@џџ+Ч@џџ„ŒŒ'Ч@џџ‡‹‹ Ч@џџ‹ŠŠЧ@џџ‰‰Ч@џџ’ˆˆЧ@џџ•‡‡Ч@џџ˜††јЦ@џџœƒƒѓЦ@џџŸ‚‚мЦ@џџЂзЦ@џџЅ~~гЦ@џџЈ}}ЮЦ@џџЋ||ЪЦ@џџЎ{{ЦЦ@џџВzzРЦ@џџЕyyМЦ@џџИxxЗЦ@џџМwwВЦ@џџПvvЎЦ@џџТuuЉЦ@џџХttЅЦ@џџШssœЦ@џџЫpp„Ц@џџЯoomЦ@џџгmmhЦ@џџжllcЦ@џџйkk^Ц@џџмjjYЦ@џџпggRЦ@џџтffЦ@џџуYYЬХ @џџу79 Ъ@0•ф88Ъ@0•х88ЉХ @џџх&,!Ъ@0˜ц''2Ъ@0˜ч((CЪ@0˜ш))TЪ@0˜щ**eЪ@0˜ъ++=Щ @џџыЛЛ7Щ @џџьЙЙ1Щ @џџэИИ'Щ @џџюЗЗЩ @џџяЖЖЩ @џџ№ЕЕЩ @џџёДД9Ч @џџђсЦ @џџѓvЦ @џџєqqAЦ @џџѕee8Ц @џџі__Ц @џџїPPЦ @џџјOOЦ @џџљMMЦ @џџњLLѕХ @џџћKKыХ @џџќJJхХ @џџ§IIнХ @џџўHHЛХ @џџџ@@–Х @џџ..€Х @џџ4–—™š›œжПтПёПжПтПёПжПтПёПжПтПёПжПтПёПжПтПРРжПтПР*РжПтПFРVРжПтПёПжПтПёПжПтПРРжПтПtР|РжПтПР*РжПтПёПжПтПёПжПтПёПжПтПёПжПтПёПжПтПёПжПРтП*РжПтПёПжПтПёПжПтПёПжПтПёП’Р˜РЁР’Р˜РЁР’Р˜РЁР’Р˜РЁР’Р˜РЁР’Р˜РРЊР’Р˜РИРСР’Р˜РбРлР’Р˜РЁР’Р˜РЁР’Р˜РРЊР’Р˜РtРэР’Р˜РИРСР’Р˜РЁР’Р˜РЁР’Р˜РЁР’Р˜РЁР’Р˜РЁР’Р˜РЁР’РИР˜РСР’Р˜РЁР’Р˜РЁР’Р˜РЁР’Р˜РЁРœK§РРСœK§РСй Сd(С,СР3СЂЫ•sœK?СFСPСœK§РСœK§РСœK?СFСPСœK§РСœK§РСœK§РFС_СœKqС}СœK’Р˜РЁР’Р˜РЁР’Р˜РЁР’Р˜РЁР’Р˜РЁР’Р˜РИРСР’Р˜РбРлР’Р˜РЁР’Р˜РЁР’Р˜РИРСР’Р˜РЁР’Р˜РЁР’Р˜РЁР’Р˜РЁР’Р˜РЁР’Р˜РИРСР’Р˜РЁР’Р˜РЁР’Р˜РЁР’Р˜РРЊР’Р˜РЁР’Р˜РtРэРжП‰СС*РжП‰СёПжПтПёПжПтПёПжПтПёПжПтПёПжПтПёПжПтПР*РжПтПFРVРжПтПёПжПтПёПжПтПРРжПтПtР|РжПтПР*РжПтПёПжПтПёПжПтПёПжПтПёПжПтПёПжПтПёПжПтПР*РжПтПёПжПтПёПжПтПёП’Р˜РИРСР‡ђЏСжœK?СFСPСœK§РСœK§РСœK§РЙСФС‡ђиСьСœK§РРСœK?СFСPСœK§РСœK§РСœK§РFС_СœK§РtРќСœK§РСœK§РСœK Т}СœKТх3ТœKТ0+œK§РСœK§РСœK§РСœK§РСœK§РСœK§РFС_СœK§РСœK§РСœK§РFС_СœK§РСœK§РСœK§РСœK§РСœK§РСœKVТeТ_СœKFС§Р_СœK§РСœK§РСœK§РСй Сd‡ђ?СжœKœKœK‡ђFёœKœKœKrТ{Т‚Т‰Т”ТžТЄТЂЫЂЫЂЫЂЫЌТВТЕТИТHlŸЁ} ЂЫЂЫЂЫФЦMЙ‡ЧЁШяGШіЧШZ;PЭ"‚а‚зииоотаЩt9ЧШХь,“џТЩrыХJЖ+ЧŒШыЧП+ШѓkШB#tw*ДХ+нХHДнШdEцžOЧ‡(EŒє$ЧЋг$ƒэШЩ €OШїOЩЦ˜_8            $$%%&&''(())**++,,--..//00112233445566XЩШaN!vФсЦ€ЁЧЎж'‰ѓ!ШђaЩЫJ ƒŠХWcНЪЦ{2aЂ@ Щ[[\œœJЩХЦPгЦ}5hЈFгЧЛу/™ |МЦx.W˜6ќЧФ~ы§EЩРТ…ЩTUюq8        ''--0011ЎЦu+K’њ*юШpwOw!4’фцшъью№ђєіјњќў   "$&(*,.02468:<>@BDFHЗЦw -Q–0ЗЧДм*љ7ЩЙ€ХЦLИ Ц[РЦy/Yš8Ч†Х ЧŠ ЦрЧПч1Ÿ iХЦЧШЩЪЫЬ .ƒЉХ&’”ЉЦt*Iј(ЩЧЙс+‘ћ ШЦэ-•ЩЩsщЩwRЦfфцъВЦv Mчќ,ВЧБй5Ї2ШєrШD%вШ`AЩДЛХ6@›Ч­е&‡ё›Ш R3[ЩЩ›Щl„ЦowdЧ™ЪdЩЬopmЦm'CŠђ"­ЧАи2ЁЭШ^=Ж;в–Х%.VЦfgjklmpstuvwxyz{|}~‡ˆ‰Š‹ŒŽ—™š›ЁЋЌ­ЎЏАБДЕЖЙКЛМРУФХЦШЩгдежзиймностуфчшыьэяђѓєѕії<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[^_`abcdeghjmnz{~€ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œŸ ЁЂЃЄЅІЇЈЉЊХЦЧШЩЪЫЬиоорфхцчшщъыьэюя№ёђѓєѕіїјљњћќ§ўџ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIvЦnq–ЦoёuwіЧУы(‹ѕШёЖШX9ЖЩpџOYop‚ƒ†‡ˆ‰Š‹ŒŽ—™š› ЁЋЌ­ЎЏАБДЕЖЙКЛМПРУФХЦШЩгдежзиймностуфчшыьэяёђѓєѕіїjРХЦЧШЩЪЫЬ_ ’”_Ч—0[œ :_Ш>ŸЩmhЦl&Aˆ№ hЧšЫЈЧЏз)їˆШ L-шШmI1A;;ААБШV71ЩИёЩxЦY[_ТЧ‰ S{2кЧМф0› cЦk%?†юУЧЖо6ЉƒШJ+уШgjGЩzЌ˜'ЬХ7=†ХlЧ›ЬеХ=ѕХKЗ•ЧЌд%…я•Ш P1UЩЧо‚ƒ^Цj$=„ь>ШѕЩЖ^ЩЪоЩv'Ц['Ч‹Ч'ЩЗgЩищ?ЇЩnpЧ №ЧРш4ЅpЩорттАЩoYЅf}X‘ПYЦgхYШ<ЩЕbw)ЂШ Чˆ ,O”ў.НЧЕн3Ѓ}ШH)НШ=ЩЛНЩqЦЦ z1_ ш <>Ч†яZ(/ЧЩ8 ‰—МфRZz› 2:8Ц_јЦƒxШF'јШuСчfgjklmmoopstuvwwxyzz{|}~†‡ˆ‰ŠŠ‹ŒŽŽ—™š›› ЁЁЋЌ­ЎЏАБДЕЖЙКЛППРУФХЦЦШШЩЩгдежжзиймностуфччшыьээяяёёђѓєєѕії<>@BBDFHJLNPPRTTVXZ^^`bdgjmpuuz~€€ƒ…‡‰‰‹‘“••—™›ŸŸЁЃЅЇЉХЦЦЧШЩЩЪЫЬЬфцшшъью№ђђєіјњќў    ""$&(*,.0024468:<<>>@BDFHAЦdeЧ jЊUйлнпсЊШT5ѓ‘sЦSmwz‰ŠŽ—›ЁЎМЦШЩжфчэяєBCPQRSTUZ\^_z{€‰Š•–›Ÿ ЦЩЬиклнтшщђѓ    "#012345:;<=>?ѓЦ‚3ЧŽ U4sЩTмCƒœЦprмЦ4eІD%[хХIЕЅЦs)GŽі&хЧПeШ@!N‚ƒЦOŽЦoёpruwЮЦ|3cЄBNЧ’”ЛЮЧКт.—ŽШ N/Щ[]œžзЦ~6nЊHWЧ’”зШbCзЩuС? DџџЫ DџџxЪ Dџџ7 @џџ‹ м @џџ -‰м @џџ*‡ђКТ~м‹м‡ђœмЅмЎмУї ЗмПмЧмЭм)7ŒЧІ!GЉ%W'ЎYЉBАЋh)­CЫ•–ZA’šŠx1dddhs|ƒZЉTgm ЊN\„[3456789;=KMPZ[]`ƒ…SAN\„3C’šƒž&{K ({ t}›ІUbcыЪŽ•—˜šž+м1EG<ŒЫŽ—˜žЫ“œмs|м.45Cgmэ•0MЇ?ЭЌ"SVXfl­knr‚эОjѕЪŽ–—˜›ž=а1@@BF !%&&(0cst|}юq!0UVWXYlmmnnt}&м.78T˜#"%%0?BBCNSTTWWYY\fgghhjkkrrs{{|‚‚„AŒ•–БМ##0bм.ž!м.И DџџpЫ DџџЫй@џџ99Нй@џџ77Ий@џџ 66Бй@џџ55Ќй@џџ44Їй@џџ33Ђй@џџ22й@џџ%11˜й@џџ+00xй@џџ.Wй@џџ2Dй@џџ5,i @<œe @џџ1Aœe@џџLЊe@џџS  e@џџX  bi @]  ze @џџ1_  ze@џџe  oe@џџi  [e@џџlPe@џџswi @z+e @џџ1|+e@џџ„e@џџ‰њњ1й@џџŽяявй @•ээ й @џџ1šээ й@џџЅшьй@џџЌччй@џџБххк @$Жффѓи @џџ1Иффѓи@џџОууыи@џџТссхи@џџЦппни@џџЪннзи@џџЮллЭи@џџвккХи@џџеййНи@џџивв•и@џџпЗЗк @/цЖЖ‰и @џџ1шЖЖ‰и@џџ№ДЕ‚и@џџєГГtи@џџјВВjи@џџ§ББ_и@џџААUи@џџЏЏMи@џџ ЎЎDи@џџ­­4и@џџЌЌ.и@џџЊЊ.к @;ЉЉ&и @џџ1ЉЉ&и@џџ%ЈЈ и@џџ+ЇЇ=к @?2ІІи @џџ14ІІи@џџ<ЅЅи@џџBЄЄLк @CIЃЃзз @џџ1K ЃЃзз@џџS ЂЂz@џџX œœїd@џџ^ ‰‰ьd@џџc ˆˆрd@џџi ‡‡жd@џџn ††Ьd@џџr ……Фd@џџu „„Лd@џџz ƒƒАd@џџ€ ‚‚Јd@џџ… ”d@џџ‹ €€Œd@џџ }}†d@џџ’ ||~d@џџ– {{xd@џџ™ zzpd@џџ yyjd@џџ  xx`@џџЃ vv,d@џџЈ ss‹i @Y­ rr@d @џџ1Џ rr@d@џџЕ qq7d@џџИ pp!d@џџО ood@џџУ nnd@џџЩ mmd@џџЮ llўc@џџг kkяc@џџз jjшc@џџм iii @dс hhпc @џџ1у hhпc@џџщ ggйc@џџю ff­i @hѓ eeбc @џџ1ѕ eeбc@џџћ ddЫc@џџ ccМi @l bbМc @џџ1 bbМc@џџ  aa}y@џџ ZZHy@џџ YYл}@џџ  XXБx@џџ% WWy@џџ* VVŒx@џџ. UUъx@џџ1 TT7x@џџ6 SS!x@џџ: RRO@џџ= QQ_x@џџ@ PP x@џџD OOЇз@џџJ 44[к @|Q 33™з @џџ1S33™з@џџ[22з@џџ`11pк @€f00dз @џџ1h00dз@џџo//?з@џџv..)з@џџ|,,Kз@џџ**2з@џџ…))"з@џџŠ((‚к @ˆ''з @џџ1‘''з@џџ—&&з@џџš$$ѓж@џџ !!ыж@џџЅ  сж@џџЋH@џџАзж@џџЕаж@џџЙФж@џџМДж@џџПж@џџСƒж@џџЧ’к @–Юuж @џџ1аuж@џџиlж@џџнЇк @šу  Cж @џџ1х  Cж@џџь  9ж@џџђ  "ж@џџї  ж@џџќ   ж@џџўе@џџєе@џџые@џџ хе@џџпе@џџЙк @Ізе @џџ1зе@џџ"*е @@џџ&ћўЪе@џџ*їїНе@џџ0ѕѕВе@џџ5єєІе@џџ;ѓѓœе@џџ@ђђ’е@џџDёёŠе@џџG№№е@џџLяяvе@џџRююnе@џџWээdе@џџ]ьь^е@џџbъъШк @ЖgщщVе @џџ1iщщVе@џџoшшНz@џџtччзк @КyццMе @џџ1{ццMе@џџффFе@џџ„тт*е@џџˆссе@џџ‹ппќд@џџŽннфд@џџ‘ммод@џџ—икжд@џџžджЮд@џџЅЯбАд@џџ­ЫЭ–д@џџБЧЧ‘д@џџДЦЦ‰д@џџИХХЫ@џџЛФФјЦ@џџПТТѓЦ@џџТССMд@џџХЃЃYЦ@џџШŸŸRЦ@џџЫžž,д@џџЯšš&д@џџб—— д@џџд––Ы@џџз••чкгк‹‹щг @џџ1н‹‹dг@џџрLг@џџу€€8г@џџц&г@џџщ~~§в@џџь}}rг@џџэjjZг@џџюiiDг@џџяhh1г@џџ№ggг@џџёffЮв@џџє^^ыв@џџї]]йв@џџјWWИв@џџћSSЄв@џџўRRХв@џџџAAАв@џџ@@šв@џџ==‘в@џџ<<в@џџ..zв@џџ--sв@џџ,,в@џџэб@џџ пб@џџ бб@џџМб@џџRq@џџGq@џџ  :q@џџ  vб@џџђђWб@џџёё<б @џџююб@џџ!жжѓа@џџ$ееса @џџ%вв"а@џџ(ЋЋёЯ@џџ*ЊЊа@џџ+ЅЅЯЯ @џџ,л Dџџ,Ž$л@0ќ-ОЯ @џџ.‰‰;л Dџџ.„‰Lл@0џ/ˆˆГЯ @џџ0~~`л Dџџ0|~qл@01}}ЇЯ @џџ2zz…л Dџџ2xz–л@03yy–Я @џџ4ggЊл Dџџ4egЛл@05ffqЯ @џџ6VViЯ @џџ6SVал@0 7TTол@0 8UUcЯ @џџ9QQSЯ @џџ9NQыл@0:OOјл@0;PP%Я @џџ<77‰в @џџ=,,й @џџ>++ƒй @џџ?**e @џџ@Ыз @џџA••Ћc @џџBŒŒ{` @џџCuuГз @џџDNNўж @џџE##žд @џџFЩЩсЦ @џџGРРAЦ @џџHњг @џџI””Пг @џџKŒŒв @џџLћб @џџMЧб @џџNAq @џџO  'q @џџP  иа @џџQЮЮЦа @џџRЩЩЕа @џџSШШЅа @џџTУУ–а @џџUТТ‡а @џџVССwа @џџWРРnа @џџXЛЛcа @џџYККZа @џџZЙЙOа @џџ[ИИEа @џџ\ЗЗ?а @џџ_ББ7а @џџbААцЯ @џџcЂЂзЯ @џџd˜˜xЯ @џџe““ŸЯ @џџgjjDЯ @џџhXXЯ @џџiFF;Я @џџjCCЯ @џџk11љЮ @џџl00dЫ @џџm#.:>BXcgk{‡•™ЅЕЙв§   dХnХжFё]M~ХSJŒХї ЊХЖХ“_ТХ‡ђйХ0+FёфM$SJ№ХFё^7$SJЦFёЦ%Ц$6ЦFёЦMЦ[ЦgЦtЦFёЦ%Ц[ЦgЦtЦї ‘Цdї ЉЦСЦиЦї Ї*жѕD E(EBE^ExEЂЫъEќE FF-FFFVFoF}F”FЇFУFбFшFї -FFFoF”FУF_Gї ‡žGЕGЪG‡žGљGHЂЫ`‡žGЕGXOHŒHЁHр‡ђЗH ї ЕGбHчH‡ћHIљGбHчH‡ћH`IЂЫ`КIXбHчH‡ћHЯIЖђ.JѕDXA4ї ЊХЖХ“_ТХіЦЧ#Ч:ЧSЧjЧЂЫъEќE FFЭЧуЧъE№ЧќEћЧ Ш ШF+Шї ЭЧуЧ№ЧћЧ Ш“Шї +УШзШщШ+УШЩ*ЩЂЫ`+УШзШВ:YЩ$пJЩ˜Щ‹ђБЩЩУЩ$пJЩ˜Щ‹ђБЩЩУЩиЩъЩ.‡ђйХ0+dХnХжї §Щ ЪЪ+-Ъ>Ъ€Ъ ЪЪ+-Ъ•ЪЂЫ`рЪ` ЪЪ+-ЪђЪžL]MЩBЫžL]MЩBЫ‡ђXЫS7хlЫ‡ђЫS7хЏЫ‡ђрЫS7хѕЫ‡ђXЫS7&Ь‡ђЫS7DЬ‡ђрЫS7bЬFёЦ%Ц$6Ц (€Ь%ЦŽЬЂЫ`$`Ц%ЦЎЬFёЦMЦ[ЦgЦtЦ (€Ь%Ц[ЦgЦгЬЂЫ`$`ЦMЦ[ЦgЦЭFёЦ%Ц[ЦgЦtЦ (€Ь%Ц[ЦgЦгЬЂЫ`$`Ц4Э[ЦgЦЭFёe`u`В:•8$Ь#AJSJх^J$Ь#AJSJ•JєЬ#AJSJх^JєЬ#AJSJ•JєЬ#хЙJєЬ# ЖђпJGSJѕJпJGXSJKЖђKKGSJXKKKGXSJsKйЬ#хЙJйЬ# ‡ђЬ#хЙJ‡ђЬ# œKЬ#хЙJœKЬ# ‡ђГ ЃKЕKаKшKLB"аK+LЂЫ`LG•"аKbLЖђаK žLЬ#AJSJх^JžLЬ#AJSJ•JйЬ#AJSJх^JйЬ#AJSJ•JœKЬ#AJхЌLœKЬ#AJоLЖђ§L'!SJM§LB"SJ3MЂЫ`]MGXSJpMЖђŸM'!SJЋMŸMB"SJУMЂЫ`фMGXSJюMЖђя&'!SJNя&B"SJ+NЂЫ`^7GXSJKNЂЂa”`нaяaEЭЂЂa`нaяa‡ЭЂЂa”`нa‡ЭЂЂa`нaЛЭЂ`нaяaсЭЂ`нaиЦї Ђa{[ЂЂa”`ЛЭЂЂaRc ЮЂ`э*ї Ђa{[ЂАaЦaиЦ3єЦ'‰6Nх%ЮaЮ (‰6NхЮЂЫ`aЮ%'дЮ:ыЮхЯ3єЦ'‰6N]ЯaЮ (‰6N†ЯЂЫ`aЮ%'дЮ:ыЮШЯа#аВ:pNх/аа#аjаpNа‡ђ#аpNхЇа‡ђ#аpNЭаFё§LЦ'SJŒХ§L (SJраЂЫ`]M$`SJб‡ђ+0+žL|+3бSJхBбžL|+3бSJsбй|+3бSJхBбй|+3бSJsбœK|+3бх‘бœK|+3бНбї жбэ*‡ђЇ*ж‡ђ3є'!в9NхщбaЮB"в9Nх%вЂЫ`aЮGXzвNхŽв3є'!в9NшвaЮB"в9NгЂЫ`aЮGXzвNSг‡ђЙBЩBšгхщб‡ђЙBЩBšгшв3є|+NхБг3є|+Nы;3є|+х3Т3є|+0+‡ђ CNхБг‡ђ CNы;FёŸMЦ'SJ№ХŸM (SJтгЂЫ`фM$`SJд#д*д3д<д#дJдZд<д$Т3бSJхBб$Т3бSJsбєТ3бSJхBбєТ3бSJsбєТх3ТєТ0+FёпJ$SJlдпJ$`SJдFёKK$SJМдKK$`SJддFёя&Ц'SJЦя& (SJњдЂЫ`я&$`SJет^ђ^_9еL (_bеЂЫ`L$е6_“еFё_0+ЩеЯеоеFe$яежžLжdmѓ/жя?ї EжАaЦaQжƒжї EжЮжхж§жс]7зЂ’зЃзАaЦaQжЕзЂ’зЃзЮжхж§жс]ий|+х3Тй|+0+‡ђ|+х3Т‡ђ|+0+œKТх3ТœKТ0+єєƒий Сd‡ђ?Сж‹ђŽиЂииЦї ї Еижї ЕижПизиќиЂЫй4йHй]йHй]йHй]йHй]йHй]й‹ђ‹ђ‹ђ‹ђ‹ђoйБYЇ*ж‡ђ{йŒйšйЈйЖђFёГйFœГйFœ‡ђРђFœОйдй§LdчйЅYБYя&жРђїйїйкП\6кŒкŒкžкП\Йк‡ђ&Щк‡ђ‡ђокяклжПл’Р%лœK6лGл[лййjл‡ђ‡ђxл‡ллšлЂЫЇлЂЫЂЫЂЫЂЫЂЫЂЫЂЫЂЫАлЮлелхлїлџYЂЫ'0FV /ŸЁ} АЩмммŸ00 м)м+м-м)м+мKмXмЂЫ_мCєЂЫЂЫdХ} АЩЂЫїGI% 0134bcceffhiirr      GS 0134Gq ЧбGдšP@AHIWP$ъъPeаж9~RR9есї9ж 9з)*,.‚Cфшьэюя &adgq€‚ƒЂЅЈЊ234‚дДН‚иГk ).kDзыв]ыеыж ыисєеtиВнин]йІ/,./2adgqs€‚ЂЅДкш &гgo~&д—Іеѓ&иЈЉЊ{8Edmжй+˜jjttyˆйч˜й0aЅ6ЙDa! OQRSUVWXYZсЦПРса веежноппчсжJ 4епхёћІЈЊТХЧёѓѕ  !*.234RSWXYZkmoy{}…‡‰ЏАБДв9J~UVWXYZЪЯЪеї§Ъжг ЬЬееф,>>EESЯNгећ§>AAEEHHOO)ж    )з),2 RS}~€шщъ'(bcefhiЃІЉк ВбћВеє2з)+1d)jццщъъ '((01344ЃІЉЖЖЖЖЖЗЗЗЗЗфффхххэdeй5dЫdгjrфдмdеьэdж dз/0M! OPQRSTUVWXYZЭ#bc{./8MдЃMефцMиЎЭикV=тўЇЛV#ф жB—žѕќжd†VЦžŸжддEVешщ3?аБ?в#FKПㄆŒПдЭбжк?BFI?з*.dlˆeуфх   ˆg  ˆЯbвиЄ0Cr‹Ÿ§аЇЈ‘в<K,д•–‘дЦze  zв-3њг“”Cж  Уй7,dps,дšЌй45ђѓєѕ !jklmno†‡ˆ‰ЕаШždžдШЩ№ 66pdyйcfYЦŸйвWZ"N"аЋ"ж "з(7Ђй2 щщъъ'(bbccefhiЃЃЃІІІЉ A&(*‹b)*,. xO йчшэ$э”d€Ы•”ж§Rя6}yZ§вfn}ЦпхчћЦаЩFетЏ *14чччч    /Я:>ККММО8 #^}~€фцqrЂЂЃЃЄЄЅЅІІЇЇЌ­ЎЏАБ0011ИB     01348eДИвAIS8гhpИй6g  в.5еяjj Ђоымръ%ЗjdxъxTjиБs $vДДДЕЖЖЖЖЗЗЗЗзs$ ДЖЗчъ ѓЦСѓаепхчsв,4ѓж!ѓзЂЃЄЅІЇ01ѓиуфмC!ТХЧёѓѕ  !*.234kmoy{}…‡‰ЏАБмгŠ‹‹ЅŒЅ ЃІЉ%Я 79:CОЩЫввЅаУиЅІЇ12—Eцщъ '(0134bcefhirЃІЉэ—гpvрd‡рЯ˜рвYZвЫЯ>ARqRЦžRйЛ фшью &adgq€‚ЂЅЈДу ЛRSЛeŠааййфцчшью         &.///001222334AAHHOOQRSSUUVVVWWXXXYYYZZZZadgqqrs€‚œЂЅЈДущъыьњ Лdƒ;ЯC99  BШeёаЂЅЈэ!7цшшщььюю &&'034QQSSUUVVWWXXYYZZbehrЂЂЃЅЅІЈЈЉДДЖф эeэбі v диEHіcђѓєѕ !jklmno†‡ˆ‰vбђів^vеюя_OŸпcgh_xP_ЯPUпбпе4пзЂ_иАЈ+4Јd(боухх(в!131AAAБxW1гguБгrx1йя6Бй5š9!~ЫЬЯадеий>>AAEEHHOOšв=Lгftд•–c$ььcC&ФХЦЧ  !jklmnoxyz{|}„…†‡ˆ‰Ќ­ЎЏАБcЯQсcаКЬd…Lв$GLLгiq€е"цщ'behrе#c/е<тфцчpqrsyVU~чч•бњџж Uз,,.UиЏ•иЗ> цщ'behrЃІЉЖф ўюљџ~$ ЕЖЗчь ўck~d{ОЯ‰ўеўж"#‡\Щ‡аС   &х ,Зх `ve з1y;'(efhiљЮ0B~PRSTWXYZЋc]Œ+eДж4иЌ—žѕќBв 04й1ццЯž Ђfв&INOQЯЯOаИЯгŠ‹Яећ§X 4œщъыьњи!/2иeиаЮ!ФOQ!do!eœчшњ !xRŠЪгу+=D # 0Šx АААБББ&&&''' Ь)Šе№ ж!‹Я4F“Яfjв+|b.ќ+ъ(cfi|гntќднE$щщEаЗХвANХий5.есї.иЊ27dp7xS7аА7й  йхi01234567щ/Зх i~чiЯSщг‹ŒђCVYZrDзrгjxrй[eл}XЄв@HRTІЈЊФХЦЧЫЯмнпст№ёђѓєѕї  !>AOQRSUVWXYZjklmnopxyz{|}„…†‡ˆ‰œЄЇЌ­ЎЏВГйлнпсњ015 N гfghijnopqr}~€ ,/2– B RS]^}~€фцчшщью  &',./023abdeghqrs€‚ЂЃЅІЈЉДЖкуфшэ   eїњ–Яgq­А–аТ–дЧиЅЇ1џХЅЇЊЋежёђ  !"#$%&,-.012<=@AFGHIWY]^fghijnopqr•–—šСТФХЦЧЫЯдистфчшъьэюя№ёђѓєѕї     !$&()*,./124OPQRSTUVWXYZacdfgijklmnopqsvxyz{|}€‚ƒ„…†‡ˆ‰œЂЄЅЇЈЊЌ­ЎЏАБЗзйкухчяњ    01234567Дшз/2й&HШeHyYШㆆ†‹ŒŒбcdeббК^œЖЗњ:q  КдЫЯ>Aƒжƒй*l$ ДЖЗчщ ьdˆlжьзЂЃЄЅІЇ01ѕIqqѕдмuжоZСТФХЦЧтфцч№ёђѓєѕ  )*,./01234jklmnopqrsxyz{|}„…†‡ˆ‰œЌ­ЎЏАБйккууффххчшњ         5о 3^"ц 0134rЖЖЖЖЗЗЗЗффхх    ^˜'одиH^еъ3Ї ъэя  (cfiƒЊЗх 2347'q ЇЯzЌЏЇжЇз4Їй30#3Аd‚ƒАв@MАдЫ> 6Єамьј+8VeАХdnЫФз&'7™з234тRьэюя&adg€‚ƒЂЄЅЇЈЊВГлнпс012347bTЫ:j'(hiЫccKdфцqrKз*Ыз•Ый9д ч  ,./023sTдІЌЙ= OQRSUVWXYZ=&ъ(cfiНzтч=а АААБББ&&&'''НеѕНиЩвНй7 PT†d|Я1я 0яfghijnopqrтэя)*pƒЄЇЊч 012347яfghijnopqr}~€яcjoe oз//22x$к xdzјЦТxЯ`“xд ЊЌЖЙКМОРЫЮxйСъч ]•–ššžŸЫЬЬЭЯаабеежййкмнссфшшшщщъъьььээюююяяђѓєѕїїћћ       !&&&''((,.//012234>>>?AAABEEFHHIOOQRSSUUVVVWWXXXYYYZZZZaaabbccdddeeffggghhiiq€€€‚‚‚ƒƒ†‡ˆ‰œЂЂЂЃЃЄЄЅЅЅІІЇЇЈЈЈЉЉЊЊВВГГллннппссущъыьњ 0011223344677Aq AЦœ*I  aaddgg€€‚‚њњ  Њe *есћ3чs3B]ГЯ~ЎБ3в"25ГзMNГиМОœe z™œœеђхЧЫЯди>AEHхехипNСТ№ёђѓєѕЮвW^ЮдЯANж   //0223WDежWdssзЯ˜Wбёћзе4зжззЂЃЄ0зилWй "ЃІЖ д– ж иЇ1 ."ЋТХЧёѓѕ  !*.234kmoy{}…‡‰ЏАБ‰D$v бепхчё‰в:,‰дХ‰иДЖ’Cффбжеп’еёз${CSSXXZZ{`tuћw}ћб*ћзЃЄІЈЉЊ02{иВГлнпсDDsФc-шщъьэюяђѓєѕ !&'(abcdefghilmno€‚ƒ†‡ˆ‰347Фd„Deуфх   DЯLXDгhvФжDи­Dй­ яяЖ !'йѕ…ј6%?ЖЅ6Й6"Љ6UЭж?FЖeŸЯjtŸиКРЮшBo˜ішcihдІЈв9hйqЯVїћёЯ ЊZЯOTZаЙZв%HMZгiwЃгqw#еп#йыыŒd}ŒxUŒгou енИ Dџџ Э @џџdd—Э @џџ[[BЭ @џџKK9Э @џџII0Э @џџGGЭ @џџBBЭ @џџAAЭ @џџ@@юЬ @џџ <<хЬ @џџ ;;иЬ @џџ ::ШЬ @џџ 66РЬ @џџ 55ЕЬ @џџ44”Ь @џџ11ŠЬ @џџ00|Ь @џџ//fЬ @џџ..]Ь @џџ--TЬ @џџ,,AЬ @џџ++9Ь @џџ**1Ь @џџ))'Ь @џџ((Ь @џџ''Ь @џџ&& Ь @џџ%%Ь @џџјЫ @џџпЫ @џџеЫ @џџЫЫ @џџ ТЫ @џџ!ЖЫ @џџ"Ф(Ф1ФHФ_Ф}ФŒФšФЏФКФУФгФлФсФ1Ф_ФHФюФћФХХ0%ХЗV'07ХHl@ХJХTХYХ]ХgђЂЫT'Ь(ЧЮpЬ.0ЭGpЭTаЮ€9Ь*9ЭIЙЭkйЮТЫЭ@"ЭBBЭKYЫЫ Э@AыЭn{TЬ,”Ь1„Юx]Ь-НЬ45V,-ЖЫfЬ.†Ь/0GIVЭPRпЫ"ŸЬ1KЭAЮq/Юr?Юs€OЮtŸЮ{јЫ!ШЬ6иЬ:јЬ<ЭBaZ(Ь"1Ь)AЬ+[бЬ6сЬ:;Š_šhj 39?EN Ь%JЬ+ŠЬ0ЊЭjЪЭlкЭmzуNуЮ‚|Ь/LЭPќЭo ЮpŒЮyеЫЬ&ЕЬ4хЬ;eЭT•ЮzЬ'юЬ<ОЮ~юЮƒїX—ЭWY[dРЬ5 Эcd`ЮuщЫЉЮ|rЮvВЮ}[ЭRС? DџџxЪ Dџџ7 @џџm’Ы @џџSk‰ @џџ FQтЪ @џџ C@м @џџ6м @џџ1м @џџћw @џџ‡ђКТ~м‹мї 0нжї 0нжї 0нж‡ђ‡ђ‡ђ>н"7nWм&pž3;<@м?PPм%&/Anxy‡‰‰GˆЫxy1м7dZAtZЉ" ЊgтЪ…Jм!""4>B[IJKLMNOPXYZ[\]^_`abfhjЛ--/2333478;;<?VdddghSAg3Ctћw&&()23334;;<gK B{ 4>›І+2ыЪpx{}€ƒ<nrЫ"%GKLT]^pƒ…ˆŠЫuŽХ/§w+;<<>э•&MЇ!()ѕЪpy|}€ƒfS‡‰ЫTŠ6м8OС? DџџЫ DџџxЪ Dџџ7 @џџ$Atо @џџЊ"о @џџ рЈўн @џџШођн @џџЗЦън @џџЎГнн @џџЄЋЂн @џџ Š–Šн @џџ$|ˆ}н @џџ%yyuн @џџ&xxnн @џџ'wwOн @џџ'qv‚о@0(rr”о@0)ssІо@0*ttЕо@0+uuDн @џџ,nn:н @џџ-mmн @џџ-ilШо@0.jjно@0/kk н @џџ0ffн @џџ1eeїм @џџ2ddям @џџ3ccьм @џџ4bbнм @џџ5aaЬм @џџ6``Рм @џџ7__Зм @џџ8^^Ќм @џџ9]]–м @џџ:[[…м @џџ;ZZwм @џџ<YYjм @џџ=XXБн @џџAšš_м @џџBPP‡ђКТ~м‹мї пТэТFeї пТэТFeї пТжї –нЁнЇн‡ђЕнЁнFe‡ђЕнЛнЁнУ‡ђСнвнун‡ђСнвнун‡ђ‡ђо‡ђШŸШŸœK‡ђ о‡ђ‡ђоШŸШŸШŸШŸœK‡ђ‡ђ‡ђ‡ђœK‡ђ‡ђ>н&о—ооЁо} kpžrЉTfЫ/0нimюYо„‚„’  ,-8b”MЂн‹ЇТнšœžK 789v !+Ќ,WipыЪЩЭЭжзсуьїўFKЋДЖ§  '/247;<>T”LЫ,8оЫежзtоЋ>Ў -нмa“Ѓэ}нyьэя1Y}н}‹ннЅМІOцЌФжOSѓO”Kям cчpqrrrtсOнqwэxО!/ЩилёXнs–—џ˜н}€‹Žос<A%/0aNaо—ZA+6ZЉ ЊУосфџ  jмXЮЮбжмУ:нmюя23Z[ddfk€дежŠн}ˆънЏНzоЎщ   У КТУ  !-/9SAУосфџ  3C+6нeгнœ<%)Ќм] ЯЬм`јњџGKьмbцNTWfinpЩилоё нfѓ@ЫЬнšžŸ,ојџGХБ1Y}ЅžѕЪ суЋДЖ'0347<>…мZкмнН%нjr‚‚„„ф%)2Zddf~€€‹‹˜œ д§ўeнu’’ŸЃњuн x}~€ˆ‰Ž”Їі%оєCEоt~ ЅЉЉЊЏББВВžЊмŸ^Н одˆЇnн!wээ~€ˆˆ‹‹Ž–—˜›œœŸŸ ЃЇЇњ§ўџ  ўнЩ;>о >ITUWfgiv~оЎъ  !7%зЎ WмЮэяwмYЭЮалПРЗм ^МKUgn™кїмdшtфWо|@Ў Рм _їјўџ)FGOd‹`н tИПФ›œŸ  )­UgnqђнИœ[2АБГЕЗИКЛОПТФЦЧЫЬЯгджикнпртухчьюя№ђєјљќ ЛaЇЈЈЈКРРРТТЫааабгггеелллмф )-2OOOQTZbbbddfkzzz€‰‰‰‹Ž”””–—˜›œœŸŸ Ѓ­РРРУааавдежіііњ§ўџ  [”M›ІI–›щъ;Н›dœЫуёњ KqtDнn1234<AAJYZ[\bzаэ• XbcdestИЮ >ЎMЇбцчшЭЌПN­-н k &+33[kежЖJ–м[нМ6оQŸKx€‚„Ž’ЅЈКМННУ_мPSˆF@hqЅЉЏБВИМНРТУ  ,-7ШнšœžКУФ1AIБнšŽЈФ Dџџїо Dџџс DџџС? DџџЫ DџџGR DџџBт Dџџ^ю Dџџ(( Dџџ,, Dџџ--Hђ Dџџ..Ћї @џџ@Dwї @џџ;>Œї @џџ88;ї @џџ3џі @џџ юї @џџ вы/ї @џџТЬюі @џџАНЧљ @џџ‚Пљ @џџr}fњ @џџhoAњ @џџ`f3њ @џџ#Z^њ @џџ(RXњ @џџ-LPtњ @џџ01Bжљ @џџ5#-ыљ @џџ:!Œњ @џџ? Шњ @џџDўкњ @џџIяљЁњ @џџNръИњ @џџSблWњ @џџXТЬ‚њ @џџ]ИР­љ @џџ`­Е—љ @џџcЁЊjљ @џџh˜ŸHљ @џџl‘•:љ @џџp…Œжї @џџqпі @џџsw{Юі @џџuDv>і @џџw<A2і @џџy2;ї оyожо‡ђ‡ђ‡ђож‡ђ$ПСœKї ”Шї Šо–о­ої Šо–оЩоної Šо–оЩоної Šо–оЩоної Šо–оЩоно‡ђппї #п-пћТ=пї [п-пћТeпї ƒп-пћТпмˆЋпКпЩпипмˆЋпКпЩпипмˆррЩпрмˆррЩпрї ƒп>рЩпJрї ƒп>рЩпJрFёkрЦ(Fё о0+Ђxр‚р‘рЛЭЂ р­риЦЂКр­р Ю' ї ї ї ї Ў›‘•™‡љ™žЧљ‚Й ˆ‰ŠŠŠ‹ЙУЧЧySІаi‚њЙы–2+ХОЩЫ<ыжZыц!ЋїAыљ‚KStЙУабгпртюяё§ў4tњ2&ЙЛМНОПУХЧШЪЫберфяѓў478::=fqЂІЈАБББВГГЕЖЗИШШШ&дO+fњiнjOr™›ž5<>AOїхљ™œžІY˜ДЕЖЗИЙЦЧШШШ(њMOSU[]acaпѓЁњрXG‚Šx…‡žŸЄЅЉJЬkavzЁИ;SA6t3C ()*3њ[cjGTcqЊееёё<kquy—Гgg3ШХЛХ%ХШЩEю"&œЗШŽBtюqЎЦЕШNю%%Юі:EюіБХhЅгзWВїгwї;—љЂWњУрЋ]сВ ї:њMU7Щ—ЖШ —$I—‚ЉЉnIю"#&nр ”œЇОЫ’{ВЌВшт2ю!!2ѕ=2і3ВњбжрхяєўЩтхљ[MNbr#-Л"гееежжзтфффххцёѓѓѓєєѕ4===>AЛ†’’™™Єћw$&л–MS[ai„лšŸЅ›І‡[і@;їrГГХХD7‚ŠŽ’–š Іdљ’”[vz 5 $&)э•…ЭЌWežЄ-тC­љЎ њMOSUVW[]acdeinnфjі–ЙУ MS[aiчстєжїжљ$Эhijjmno?E67x †‰‹ЙМОУЧЫŸ›cqџЪ $&*пі?xџіяПљr(!†‰Š’””Hі9Hљ’ШњўџžQЏOБМЙНОПУШЩЩЪЫ 27<БФqх!"#њ"MOOSU[]]acil„‰Š‹Ž‘’“•–—™š›Ÿ ЁЅІЇZA 7()*:љ†”књяQlvzуttc mšRT Х:Œї8=Œњ ƒДЦУжийклтхеЪAЕњбжрхяєўьz~klmuvwyz{{"#)+.2осC>і=њSЄІЇЈ'"#&ЇсC'НЫ^YїхіpHVWZ^bЙУббрр5bИ&МЧ A67Wi›K ЉН8Ј=›=рГFЅЇЈЉFеV} IZ^``bcjkoqrЏšR‰/їУЦрсттђєіљxОVd8ХПЪ7ИљЎБДИњбС›‹“—›ЁЇœO]Aњaј*ѕ8*іjљ™И DџџЖр@џџœр@џџ аа"а@џџ ЩЩёЯ@џџШШа@џџФФs^@џџЎЎh^@џџЌЌ^^@џџЋЋR^@џџЊЊG^@џџ!ЉЉ;^@џџ&ЇЇ,^@џџ*ІІ ^@џџ.ЅЅ^@џџ1ЄЄ ^@џџ5ЃЃ^@џџ8ЂЂє]@џџ<  щ]@џџ?ŸŸр]@џџBžžд]@џџFЫ]@џџIœœП]@џџM››Ж]@џџPššЊ]@џџT™™Ё]@џџW˜˜•]@џџ[——Œ]@џџ^––€]@џџb••w]@џџe””k]@џџi““b]@џџl’’U]@џџp‘‘K]@џџs?]@џџw6]@џџzŽŽ*]@џџ~!]@џџŒŒ]@џџ…‹‹ ]@џџˆŠŠ]@џџŒ‰‰ї\@џџˆˆ“р@џџ’~~‰р@џџ•}}р@џџ˜||uр@џџ›{{jр@џџŸzzaр@џџЂyyVр@џџІxxMр@џџЉwwEр@џџЌvv=р@џџЏuu2р@џџГtt*р@џџЖssр@џџКrrр@џџНqq р@џџСppр@џџФooљп@џџШnnёп@џџЫmmцп@џџЯllоп@џџвkkгп@џџжjjЫп@џџйiiПп@џџнhhЖп@џџрggЋп@џџфffЃп@џџчee˜п@џџыddп@џџюcc…п@џџђbb}п@џџѕaarп@џџљ``jп@џџќ___п@џџ^^Vп@џџ]]p\@џџ<<a\@џџ::Y\@џџ 77+\@џџ ,,3\@џџ **с @џџ vvс @џџuuс @џџttс @џџssh^ @џџddR^ @џџccір @џџbbыр @џџaa^^ @џџ__G^ @џџ ^^“р @џџ"]]‰р @џџ$\\™` @џџ%WWр @џџ'uр @џџ)aр @џџ+Mр @џџ-2р @џџ0р @џџ3 р @џџ6љп @џџ9цп @џџ<гп @џџ?Пп @џџBЋп @џџE˜п @џџH…п @џџK  rп @џџN  йр @џџR  Хр @џџVЉр @џџYббцЯ @џџZРРч\ @џџ[ААGп @џџ\к\ @џџ]VVЪ\ @џџ^UUС\ @џџ_SSЖ\ @џџ`RRЉ\ @џџaQQž\ @џџbPP”\ @џџcNNŠ\ @џџdMM€\ @џџeLLy\ @џџfKKA\ @џџg44\ @џџh&&№[ @џџiХH @џџj<п @џџk‡ђ&Ž,п6п‡ђŽ,пFe‡ђ&Щк‡ђ‡ђ‡ђ—TЁTАT‡ђ—TхвT‡ђ—Tя?‡ђ—TхвT‡ђ—Tя?‡ђ—TЁTхїT‡ђ—TЁTАTЂ—TхвTЂ—Tя?Ђ—TхвTЂ—Tя?‡ђэ7х,U‡ђэ7ж‡ђ—Tя?‡ђ—TхвT‡ђ—Tя?‡ђ—TхвT‡ђ—Tя?‡ђ—TхвT‡ђ—Tя?‡ђ—TхвT‡ђ—Tя?‡ђ—TхвT‡ђ—Tя?‡ђ—TхвT‡ђ—Tя?‡ђ—TхвT‡ђ—Tя?‡ђ—TхвT‡ђ—Tя?‡ђ—TхвT‡ђ—Tя?‡ђ—TхвT‡ђ—Tя?‡ђ—TхвT‡ђ—Tя?‡ђэ7ж‡ђэ7ж‡ђэ7ж‡ђэ7ж‡ђэ7х,U‡ђэ7ж‡ђэ7х,U‡ђэ7ж‡ђэ7ж‡ђэ7ж‡ђэ7х,U‡ђэ7ж‡ђэ7х,U‡ђэ7ж‡ђэ7х,U‡ђэ7ж‡ђэ7х,U‡ђэ7ж‡ђэ7х,U‡ђэ7ж‡ђэ7х,U‡ђэ7ж‡ђэ7х,U‡ђэ7ж‡ђэ7х,U‡ђэ7ж‡ђэ7х,U‡ђэ7ж‡ђэ7х,U‡ђэ7ж‡ђэ7х,U‡ђэ7ж‡ђэ7Uпх_п‡ђэ7UпFeFUFUWU ѓ ѓ~п‡п‘п›пЅп€-ЬпЯп€-Ьпіп€-Ьпр€-ЬпBр€-bр€-‚р€-Ёр€-ЂЫРраржрар№рарсарсар2с:сар2сfсар2с™сар2сОсар2смсар2сњсар2стар2с4тар2сRтар2сpтар2сŽтару2с уару2с$у)м+м8уЂЫЂЫ V#V*V/V4V9V>VBVFV /ЂЫJVЂЫ/ЂЫž#Ни\ 5CЕ‡\LG^Љ^GдаGп[mпcмъсpuy\ KVллщщ $1=Jљпnb^Ђ+\$,.k]“5NЋпfырaє] ЯBа\"$&гUцЯЛОРклмнопрстуфчщыэяёѓѕјћўцпlяЎ˜Ngккклллмммнннооопппрррссстттуууффф##$$%%&&''(())**++,,--..00112233445566778899::\\\]]]^^^___aaabbbcccddd˜пdсqvСu]]^^_`abcdefghijklmnopqrstuvwxyz{|}~ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ЂЃЄЅІІЇЇЉЊЋЌЎЎаацшъью№ђєїњ§<=>?@ABCDEFGIJKLMNOPQRSnopqa ! _aceimuvwyA\34a\:>С\ Sоояя'4@Mс\V!]Œ%>Ё]˜+DЧ   aрyJ +^`bdfhjlnprtxz‰‹‘“•—™› ЃЅЇЊЌIJKLMNOPQRSЪHŠ\%Mннссттууээѕіјљћќ&*+,3789?CDELPQRЪ\UU*]2KЊ]™8QŠxббггjп_кц\*рsф§jрzѓ"3\&*.s^Ўгпj“р~]qvгр&       мCU^`bdfhjlnprtxz‰‹‘“•—™› ЃЅЇЊЌ         IIJJKKLLMMNNOOPPQQRRSS<пœрабХHЅ\PХ`00112233445566778899::aabbccdd…пb EрvХр ./w! IJKLMNOPQRSї\ˆ#<^w]”)B^Єрqуњ€\ LVммыы%2>K]‰0Ic€]•6Oр]ž.G ^Ѕсnsinopqщ-  ..^`bdfhjlnprtxz‰‹‘“•—™› ЃЅЇЊЌЩ IJKLMNOPQRSЉ\ Qффўџ-:FSщ]ŸU‰р}\puЉрбгклмнопрстуфчщыэяёѓіљќџВ\QR^Њcrп` a2рt›N›]^_`abcdefghijklmnopqrstuvwxyz{|}~ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ЂЃЄЅІЇЉЊЋЌЎцччшщщъыыьээюяя№ёёђѓѓєѕіїјљњћќ§ўџ<<==>>??@@AABBCCDDEEFFGGIIJJKKLLMMNNOOPPQQRRSSUUnopq›\N;^Ї0123456789:IJKLMNOPQRSBKаОФЦрoтїl]^_`abcdefghijklmnopqrstuvwxyz{|}~ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ЂЃЄЅІЇЉЊЋЌцшъью№ђєїњ§<=>?@ABCDEFGIJKLMNOPQRSUnopqMрwЖй"{6 >ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžЂЂЃЃЄЄЅЅІЇЉЊЋЌЎ<=>?@ABCDEFGIJKLMNOPQRSЖ\ Rттјљ+8DQ6]Ž&?Ж]š,EVп]клмнопрстуфчщыэяёѓѕјћўЖпgоюVрxЖрірbџS*,7:<]^_`abcdefghijklmnopqrstuvwxyz{|}~ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ЂЃЄЅІЇЉЊЋЌЎФШЩаnopqПN#Ни?]3LП]›9R_п^ Ппhрrр|oth^Ќdсot1Aii‘\MёЯРЦШёпmсє]к\%Vккссттууччѕіјљћќ #*+,0789<CDEIPQRЃпeньЬ.  ]Š$=Œ]–*C_,^ІЎ#$%&'()*+,-<=>?@ABCDEF рp]‹1JU]‘4M•]—7Pd5^]^ІЇЎuр{nsž\Pррттууѓѓјљћќ)+,689BDEOQR^^Ћ_опkрђч\‚Ачр№[p\<>А`"+6;Т"Y\7™`Wйр   b]’(A"аЩЫ: A K]'@Ы]œ-F ^ЃЫпiп№”\ Nппёё(5ANд\Uд]:S= :<ІЇЎН\R=аббгг}пaлш=рuЦ\S.GИ Dџџ<т@џџ]]-т@џџZZт@џџSS‡с @џџ т @џџ <<ўс @џџ 77іс @џџ 66юс @џџ 55цс @џџ44ос @џџ33Яс @џџ..Чс @џџ,,Ос @џџ++Жс @џџ**Ўс @џџ))Їс @џџ(( с @џџ''™с @џџ&&”с @џџ!!qс @џџeс @џџ‡ђ“ужŸу“уЎуСуЂ‡ђзуёу ф#ф<фUфИТnфqфtфwфgђЁzфЂЫЂЫ&O‡сЇс(Чс, с'СZ]bda 0Ycщ/34567<qс™с&J Zbd 34567<”с!4тZ]bd<т] 34567<eс-тZbdЖ_iЖ_ЦbdЎс)Жс*Ос+ос3@цс4Aюс5Bіс6Cўс7Dт<IтPQтQSџZ]_OOЯс.hдZbИ Dџџ’т Dџџь@џџњњpы@џџррiы@џџппaы@џџ ооVы@џџннPы@џџммIы@џџллœЦ@џџии„Ц@џџзз$ъ@џџЙЙћщ@џџ$ЏА№щ@џџ(­­hч@џџ,___ч@џџ.\\Uч@џџ0[[ч@џџ5ZZ8ч@џџ9YY#ч@џџ=WW ч@џџ?TT"ю @џџ@66ю @џџA44§э @џџB33ёэ @џџC22тэ @џџD11жэ @џџE//Шэ @џџF..Лэ @џџG--Ќэ @џџH,,Ÿэ @џџI++“э @џџJ**э @џџK((pэ @џџL''eэ @џџM&&Wэ @џџN%%Lэ @џџO##?э @џџP""3э @џџQ!!%э @џџR  э @џџSэ @џџTэ @џџU§ь @џџVїь @џџWёь @џџXъь @џџYть @џџZкь @џџ[дь @џџ\Ьь @џџ]Хь @џџ^Зь @џџ_­ь @џџ`Іь @џџa  ›ь @џџb  Žь @џџc  ‚ь @џџd  tь @џџehь @џџf]ь @џџgVь @џџhIь @џџi;ь @џџj/ь @џџk$ь @џџlџџч @џџm§§ыц @џџnќќь @џџoјј ь @џџpїїь @џџqііѓы @џџrяячы @џџsююлы @џџtээЯы @џџuььУы @џџvыыЗы @џџwъъЋы @џџxщщы @џџyшшы @џџzччы @џџ{ццvЦ @џџ|йй4ы @џџ}ббы @џџ~ЯЯы @џџЮЮєъ @џџ€ЭЭръ @џџЬЬЯъ @џџ‚ЪЪМъ @џџƒЩЩЊъ @џџ„ШШ–ъ @џџ…ЧЧ„ъ @џџ†ЦЦsъ @џџ‡ХХZъ @џџˆССHъ @џџ‰РР<ъ @џџŠПП-ъ @џџ‹ООфщ @џџŒЁЁФщ @џџ››šщ @џџŽšš†щ @џџ™™}щ @џџ˜˜kщ @џџ‘——\щ @џџ’‘‘Qщ @џџ“?щ @џџ”.щ @џџ•щ @џџ–ŒŒщ @џџ—‹‹щ @џџ˜ŠŠћш @џџ™……ъш @џџš„„зш @џџ›ƒƒФш @џџœ‚‚Вш @џџЅш @џџž™ш @џџŸ~~Šш @џџ }}}ш @џџЁ||oш @џџЂ{{cш @џџЃzzQш @џџЄyyCш @џџЅtt*ш @џџІssш @џџЇnn§ч @џџЈmmфч @џџЉllЭч @џџЊkkЕч @џџЋjjŸч @џџЌii•ч @џџ­ccŒч @џџЎbbѕц @џџЏNNпц @џџАMMвц @џџБLLТц @џџВKKЙц @џџГJJЌц @џџДIIœц @џџЕHH“ц @џџЖGG…ц @џџЗFFxц @џџИEEoц @џџЙDDdц @џџКBBZц @џџЛAALц @џџМ@@@ц @џџН??1ц @џџО>>)ц @џџП==ц @џџР<<ц @џџС;;ц @џџТ::љх @џџУ99ях @џџФ88ух @џџХ77лх @џџЦ66Ях @џџЧ44Фх @џџШ33Их @џџЩ22Љх @џџЪ11Ёх @џџЫ00•х @џџЬ//†х @џџЭ..~х @џџЮ--qх @џџЯ,,cх @џџа++[х @џџб**$х @џџв!!‡т @џџгї ‡ђ§РС‡ђ§РС‡ђ§РСœK§РFС_СœK§РСœK§Р§цчœK§РСœKVТeТ_С‡ђ‡ђчЂи,чBчYч‹ђчЂииЦї —чБчЬчї ‹ђюччЂи шї чЂииЦ‹ђчЂииЦ‹ђ8шIш]шpш}шшšшЉшЗшЧшештшѕшщщ"щ.щ<щIщXщeщqщ}щ„щ‹щ’щšщЃщЌщГщМщФщгщощцщђщъ ъъ)ъ5ъ=ъ=ъKъXъdъpъ{ъ†ъъ™ъ ъЄ/Ћ/В/Й/Р/Ч/е/м/ЂЫЇъЌъБъЖъЛъРъХъЪъЯъдъйъоъ™ъЄ/Ћ/хъUы`ыkыvыUыvыыыŒы—ыvыЂы­ыИыУыvы­ыЮыйыфыяыњыььььЮыйыфыяыњыь&ь0ь9ьDьNьZьiьqь}ьŒь”ьЁь­ь} ЁАЩЕьМьТьгьзькьыьАЩюьИТ} Ёџьээ&э+э/эGэJэtфЂЫЂЫѕЕGдWYZ­Џ‡тGчZGщPЇтAОьщ™PымЙAъљх9ЙцJ9шstyыуТцKчN§‚ь ыцMќЋчizkщ—ЋыщєъЭ24ыб6tьAшц<щŒЁыш]ьц^ŸЎІъЧІь XЯх4§ЯъЪ/ычЯыью4ыЮaс\юЁх0JaыоЪŠО7:=Šш}ЁЅЉ“цGшn“э*|U<ъП&МъЩ.…цFыЮ3EыбХь.чWYZ­Џ.щЗыъЗьїь@ц?€ъХiAцЉх1K)ц=iыпВш[х*Dлх6лыэ›ь $х!TWYZ[\_­ЏњdцBфчl $щŒфщЁЅЉ$ъЗЙ$ьџ ЖзилмнопруЭ#UVX чTbЭчk!Эш‚‹‘˜– ZVЦилмнопру–ЦзчWZщ‹Ѕ–ъЧ,VынVьжэ/џTWYZ[\_­ЏЖзилмнопруњч_?щ ?э"HъР'Шэ.QшyQщъАКш…КщšУчj{CшtУыыэЌAщЌцIЌэ,е#V•х/IѕцNUч[c•чcїЕчj"5щ>х~х-Gчыю№щ­ј№ъЬ0ыЯpырpэ'YЃYшy™ш~ЁЅЉэтьтэ1"ю6ЫъЩд Z__ААдь§чm}ш|ЁЅЉ }щ˜§ь§э3ЦAы†х.Hц:†щ™яWoх+-07:=ях8oцDoш{ЁЅЉ /ьИх2LxцE8чYИъШСWWYYZZ­­ЏЏззиллмннопрууыЭыцьіэ(ъAРя*шsъш„ЊъШ-ъьsЦлнуsч_ѓчl}sщ—›sъХ*ѓыя3э!œЦиœцH\щ‘мъЪыЯ4ьњЅшЁЅЉ%э eэ&ŽЦзц;Žь эзшƒWэ% шnршƒръЬ1 шm~ ъАIыл ьїIьвцL’ъЦьјћш…ћщЏ;ьЛэ-„ЦзФх3ќФш‚ЁЅЉщŠФщ›„ъЦ+-ъО%mъС­ьЖ&:ЖvAчvЦжй_OЕпцMџ_ч\Ÿчi#Ÿэ+hч_hь1Aђђqх,F1ц>ёш„ёьёэ2кAПэZцAкчk|šщšъЖЗZъС(кьcх+Eух7#чWcшzЁЅЉ Lц@Œчbі щŠЬьLэ#И DџџИф @џџ??‘ф @џџ>><ф @џџ99ф @џџ88юу @џџ33Эу @џџ22˜у @џџ--vу @џџ,,Iу @џџ ((%у @џџ ''о4 @џџ фт @џџит @џџх_хdхЇхЌх№хѕхцц5ц:цrцvцшц№цЂЫ8'(ї4ЇН:ф8р5љ ”9Iу(iф9ђтТу.rф:ђф@ хAф(фтуХ@%5%у'mу(Эу2ѕф@ –4f(F 3о4ŽЦvу,юу3хAŸ.:?_ 4џтф3пф?h4H4X 4ит ˜у-ˆф:Иф?шф?aф9‘ф>Ку.zф:c 4уƒф:хA<ф9ќф@И Dџџѕf Dџџ,ё Dџџ  s№@џџ!!шё@џџпё@џџжё@џџch @ пf @џџ1 пf@џџыf@џџеf@џџ§§vh @ ќќЩf @џџ1ќќЩf@џџћћПf@џџ"љљ‰h @%јјГf @џџ1'јјГf@џџ+їїЇf@џџ2ѕѕžf@џџ8єєœh @<ђђˆf @џџ1>ђђˆf@џџCёё”f@џџF№№Џh @Jююaf @џџ1Lююaf@џџQээmf@џџTььё@џџXрр§№@џџ[ппш№@џџ^ллм№@џџaккв№@џџdййЖ№@џџhззХ№@џџkжж №@џџoддЌ№@џџrггяё @'vббŒ№ @џџ1xббŒ№@џџ}аа—№@џџ€ЯЯ€№@џџ„ЮЮy№@џџ†ЪЪg№@џџ‰ХХ]№@џџŒФФU№@џџУУL№@џџ’ССђ @1•РРA№ @џџ1—РРA№@џџ›ПП8№@џџžННђ @5ЁММ-№ @џџ1ЃММ-№@џџЇЛЛ№@џџЎЙЙ№@џџДИИђя@џџИЖЖ№@џџЛЕЕмя@џџПГГшя@џџТВВТя@џџЦААМя@џџШЏЏ%ђ @@Ь­­Јя @џџ1Ю ­­Јя@џџг ЌЌГя@џџж ЋЋ7ђ @Dк ЉЉ–я @џџ1м ЉЉ–я@џџс ЇЇ я@џџф ЅЅ:я@џџъ ЁЁя@џџэ   їю@џџ№ ŸŸдю@џџѓ žžFя@џџѕ ››%я@џџї ——я@џџљ ““тю@џџћ  f @џџћv€Тh@0OќwwЭh@0O§xxиh@0Oўyyфh@0Oџzz№h@0O{{ћh@0O||i@0O}}i@0O~~i@0OНю @џџ^^Юё @џџRf @џџ  Oя @џџœœ0я @џџ ˜˜я @џџ ””эю @џџ Хю @џџ ‡‡§e @џџ Ќю @џџ__Ђю @џџ &04?CPQRSTUVWXї Žюй‡ђICaCЂЫ`а5XICЮ>ЖђICњ>Жђё1ЂЫ`а5XlЖђё1ЂЫ`а5Xl3єа5XЅˆCх–C3єа5XЅˆCсCD1DЂЫ`а5XDUDЖђD~DŽDžDЂЫ`а5XˆCРDЖђˆCчD‹ђю™юАю‹ђюю єЦюњэ єюю єюююICю0юICњ>юICю0юICњ>Ш+ICиюЂЫ`ї(В:IC5юFёICњ>œKќюяzюї рOююрOююрO я2яFёИ(Ц(Ш+ф(ЂЫ`ї(В:)FёИ(Ц(Ш+ф(ЂЫ`ї(В:)3єї(<яжˆCхMя3єї(В:жˆC’яюDФя0юD~DюDФя0юD~DœKкяья<дўяШ+D№ЂЫ`ї(В:D'№FёD~DШ+ŽDM№ЂЫ`ї(В:ˆCl№FёˆCчD№И(В:Ѕ№А№н№2яэ№2я ёБYFœppРђ‡ђ‡ђ‡ђ‡ђ‡ђ‡ђ‡ђ‡ђ‡ђйёЂЫ(ё5ёEёTёdёЂЫЂЫЂЫЃ5GI юђјљљќ§§P“—›9f}y№Ъ!ТBЇЌИЙЛПаэёєѕїћ‚fЉЋЌ­ВГЕЖУЯабгджзлю№ёђ‚яЁТяАЋbhухыf]№ФІц+І/ЇГЛП+OяœяЁИ8 žŸ ЁЖдзпX ЇЉЌ­ЛМПРэюёђїјћќи+и TZxя 8№НС4ЁЁЅЇЇЉЋЌЌ­ААВГГЕЖИИЙЙЛПЮЮЯаабгджзрьээю№ёёђєєѕѕїћa+?*"Љ­бюђAf~afьэюaяŸ№ЕA№ПРJ Йѕj"ŠІj NЭџ*Iээёёєєѕѕїїћћ*f{Гг*,.If CE“!МРјќfxГfїјГяЋs№Ш!|"ќ+НСљ§мCЙѕ б^Љ­бюђž HJžfєЇ ЙЇfѕg№ХА IVЋЌ­ААВГЕЖУУФХ№ёђ0я˜№№п"fzЂютю"ёр Alnp д Ул”f№дюž§euНю^Џ§№пF UFя›œя ЅЋВЕЯгжь№япрIю @@џџ„‡Фё @@џџ€ƒНё @@џџ |Їё @@џџ x{Гё @@џџqw—ё @@џџlo ё @@џџdj‰ё @@џџ_b‘ё @@џџW]€ё @@џџ#SVrё @џџ$ыOьэњэыOююыOюююК>ю0юК>њ>юК>ю0юК>њ>И(В:К>5юFёК>њ>œK^юlюzюЂЫ5w!!).6;BFJNSW_dlqx|€„wf68BDFHJLlnxz|~€‚g№L—№[—ё.6dlЇё;Bqx€№U №n€ёS ё.d f .6;BFJdlqx|€IюN„‰ё!)W_‚f!%)+.268;?BDNPW[_adhlnquxz„†ТяђяDв№~rёЛ)_DD)+_aФёJ€Э##$&013=>@YZ\fgistvе#$1>ZgtеяSUU№P]№HХ№uНёF| F – )6B_lxЮяSUЖ№z&3@\ivя!.;WdqЈя+шя2ш№†a №?‘ё!WŠ(5^kc !).6;BFJNNSSW_dlqx|€„„Гя%Гё;q|#0=YfsVW^ @џџ?VVI— @џџ@RSD @џџARRI— @џџBOP. @џџCOOI— @џџDMM  @џџEMMI— @џџFKK @џџGKKI— @џџHIIў @џџIIIы @џџJGGм @џџKFFЮ @џџLEEI— @џџMAAЊ @џџNAAI— @џџO==“ @џџP==I— @џџQ<<ƒ @џџR<<r @џџS::I— @џџT99e @џџU99I— @џџV77W @џџW77I— @џџX55I @џџY55I— @џџZ22< @џџ[22I— @џџ\/0- @џџ]//I— @џџ^,- @џџ_,,I— @џџ`))їџ @џџa))I— @џџb''щџ @џџc''I— @џџd%%мџ @џџe%%I— @џџf##Щџ @џџg##I— @џџh!!Лџ @џџi!!I— @џџjЎџ @џџkI— @џџlšџ @џџmI— @џџn‡џ @џџoI— @џџpyџ @џџqI— @џџrgџ @џџsI— @џџtKџ @џџuI— @џџv7џ @џџwI— @џџxџ @џџyI— @џџzџ @џџ{I— @џџ|ѓў @џџ}I— @џџ~  хў @џџ  I— @џџ€  иў @џџ  I— @џџ‚  Хў @џџƒ  I— @џџ„Жў @џџ…Їў @џџ†I— @џџ‡–ў @џџˆI— @џџ‰ˆў @џџŠI— @џџ‹џџ{ў @џџŒџџI— @џџ§§oў @џџŽ§§Zў @џџћћI— @џџїїIў @џџ‘їїI— @џџ’єє9ў @џџ“єєI— @џџ”ђђ(ў @џџ•ђђI— @џџ–№№ў @џџ—№№I— @џџ˜ээў @џџ™ээI— @џџšыыя§ @џџ›ыыI— @џџœщщг§ @џџщщI— @џџžшшИ§ @џџŸшшI— @џџ ццŸ§ @џџЁццI— @џџЂхх’§ @џџЃххI— @џџЄфф…§ @џџЅффI— @џџІууy§ @џџЇууI— @џџЈттl§ @џџЉттI— @џџЊппX§ @џџЋппC§ @џџЌооI— @џџ­нн8§ @џџЎнн*§ @џџЏмм§ @џџАлл§ @џџБййI— @џџВжжіќ @џџГжжI— @џџДддщќ @џџЕддI— @џџЖааиќ @џџЗааI— @џџИЭЭШќ @џџЙЭЭI— @џџКЪЪИќ @џџЛЪЪI— @џџМШШЈќ @џџНШШI— @џџОЦ֘ќ @џџПЦЦI— @џџРФФˆќ @џџСФФI— @џџТТТxќ @џџУТТI— @џџФРРhќ @џџХРРI— @џџЦООSќ @џџЧООI— @џџШММBќ @џџЩММI— @џџЪКК'ќ @џџЫККI— @џџЬИИќ @џџЭИИI— @џџЮЖЖќ @џџЯЖЖI— @џџаДДѕћ @џџбДДI— @џџвВВхћ @џџгВВI— @џџдЏАЬћ @џџеЏЏI— @џџжЋЋГћ @џџзЋЋI— @џџиЊЊšћ @џџйЊЊћ @џџкЉЉI— @џџлЈЈ|ћ @џџмЈЈaћ @џџнЇЇI— @џџоІІPћ @џџпІІI— @џџрЅЅ>ћ @џџсЅЅI— @џџтЄЄ/ћ @џџуЄЄ$ћ @џџфЃЃћ @џџх  I— @џџцŸŸћ @џџчŸŸI— @џџшžžљњ @џџщžžыњ @џџъкњ @џџыššШњ @џџь™™I— @џџэ˜˜Ињ @џџю˜˜I— @џџя——Ёњ @џџ№——Œњ @џџё••I— @џџђ””‚њ @џџѓ””€˜ @џџє““I— @џџѕ““tњ @џџі““I— @џџї’’fњ @џџј’’I— @џџљ‘‘Wњ @џџњ‘‘I— @џџћAњ @џџќI— @џџ§3њ @џџўI— @џџџ‹‹њ @џџ‹‹I— @џџ‰‰њ @џџ‰‰ыљ @џџ††жљ @џџƒƒЧљ @џџ€€Пљ @џџI— @џџ~~­љ @џџ~~I— @џџ }}—љ @џџ }}I— @џџ {|jљ @џџ {{I— @џџ zzHљ @џџzzI— @џџyy:љ @џџyy-љ@џџvvљ@џџuuљ@џџttљ @џџssљ @џџppєј @џџooщј @џџnnој @џџmmI— @џџllдј @џџllI— @џџkkЪј @џџkkI— @џџjjРј @џџjjАј @џџhhI— @џџ fg˜ј @џџ!ff‰ј @џџ"dd~ј @џџ#bbI— @џџ$aatј @џџ%aafј @џџ&``Xј@џџ'__Œї@џџ(OOЋї @џџ)NNwї @џџ*MMYї @џџ+>>Oї @џџ,==;ї @џџ-;;/ї @џџ.::ї @џџ/99џі @џџ088юі @џџ177пі @џџ255Юі @џџ344I— @џџ422Лі @џџ522I— @џџ611Љі @џџ711I— @џџ800žі @џџ900I— @џџ://{і @џџ;//I— @џџ<..lі @џџ=..[і @џџ>--Hі @џџ?,,>і @џџ@**2і @џџA))>ј @џџB[[!ј @џџDZZcї @џџEII*і @џџF##ˆђ DџџG ЂЫ о0+Y~‡ђї ‡ђ‡ђ‡ђ‡ђ‡ђ‡ђ‡ђ‡ђ‡ђ‡ђ‡ђžLї ‡ђї ‡ђї ‡ђ‡ђї ‡ђї ‡ђї ‡ђї ”Ш”Ш”Ш”Ш‡ђ‡ђї ‡ђ”Ш‡ђ”Ш‡ђ”Ш‡ђ”Ш‡ђ”Ш‡ђ”Ш‡ђ”Шї мˆ‡ђї ї žLžL‡ђ”Ш‡ђ”Ш‡ђ”Ш‡ђ”Ш‡ђ”Ш‡ђ”Ш”Шї ї ‡ђ”Ш‡ђ”Ш‡ђžLмˆ‡ђ”Ш‡ђї ‡ђї ‡ђї ‡ђї ‡ђї ‡ђ”Ш‡ђ”Ш‡ђ”Ш‡ђ”Ш‡ђ”Ш‡ђ”Ш‡ђеˆ‡ђ”Ш‡ђ”Ш‡ђї ‡ђеˆ‡ђеˆ‡ђ”Ш‡ђ”Ш‡ђ”Ш‡ђї ‡ђї ‡ђ”Ш‡ђžL3є‡ђ”Ш‡ђ”Ш‡ђ”Ш‡ђї ‡ђ‡ђ”Ш‡ђ”Ш‡ђ”Ш‡ђ”Ш‡ђ”Ш‡ђ”Ш‡ђ‹ђ‡ђ‹ђ‡ђї ‡ђї ‡ђї ‡ђї ‡ђї ‡ђ‡ђ‡ђ‡ђ‡ђї ‡ђ”Ш‡ђї ‡ђї ‡ђ”Ш‡ђ”Ш‡ђ”Ш‡ђ”Ш‡ђ”Ш‡ђ”Ш‡ђ”Ш‡ђ”Ш‡ђ”Ш‡ђ”Ш‡ђ”Ш‡ђ”Ш‡ђ”Ш‡ђ”Ш‡ђ”Ш‡ђ”Ш‡ђ‡ђ‡ђ‡ђї ‡ђžLї ‡ђї ‡ђї ‡ђї ї ”Ш‡ђžL‡ђ”Ш”Шмˆмˆ‡ђмˆ‡ђмˆї ‡ђї ‡ђ‡ђ‡ђ‡ђї ‡ђї ‡ђї ‡ђї ‡ђї ‡ђї ї ї ї ”Ш‡ђFё‡ђFё‡ђЂ‡ђЂ‡ђЂ‡ђ‡ђžLї ї ї ї ї ‡ђї ‡ђї ‡ђї ї ‡ђї ї ї ‡ђї ї ‡ђої оmѓї ‡ђ‡ђ‡ђ‡ђœKї ї ‡ђ‡ђ‡ђї ‡ђї ‡ђЂ‡ђЂї ї ї ї } CН*о3оЂЫ:Чљ€PћІЙЌ 9ўєЙ‚k†‚њ”ќЖы–lm“‹‹ŒŒŽŽ‘’”ыљ†ыњыGыitwacegino‘”——˜˜™™ššЅАБВЕЗЙКМПСУХЧЩЫЯвезнопртуфхццью№ђєѕїјћ§џ  !#%')-.013689::<=>AEFJLMPSWX\]]cdehjlmorst}‚‚ƒtјaєјotњ“t‘є БГ&K.0acegi‘”™šЅВЕЗЙКМПСУХЧЩЫЯвезнтуфхью№ђѕј  !%')3689<>AJLMPS\ehjlmo}ƒљ|ћЉKŒ˜шщ†‡‹НДЖИКМджц  %'57IKMORgikmo|~˜јfњŠŒŽ˜ќЦў№,/2aћЇЪјkJћЅSUbiЏВДЖИКМОРТФЦШЪЭЭааджмтуфхцыэ№ђєї§  %'),/2579=EFIKMORVW[\]]begikmorrs|~‚SќОг§щ<ƒST`žžŸ    ЅЏВГДЖЗИКЛМННОРТФЦШЪЭавйшщыэю№ёђѓѓєіїљљ§џџ   !""#%&'(()9=?@ABCGIKMORV__``aabefgijkmnoppwwwwwxxxxxyyyyzzzz<2<Ž…§фюqџ†‡‹юі7ЎћЊЎџ.Ony.wїJMwћЇ7ќЛН&(np7џїџ)ЗЅюЖИРWs@RЌББ€˜“—˜™šРјjљpњ‰‹Љі1щјnщќдщџ'2і)Вњ—˜™šђћВтуфхыэ№ђѕј!<>AeВ§цr:rYђŠл–€‰‹’Н ДЖИКМджпцџ  %'57IKMPSgikmo|~[і-$НДЖИджр  57IKgik|~dљz$ћЃ$.12 5ƒ†•ЌЏM7 žŸЈОРТФЦШЪ)9\ њ‰‹’жїSWжљƒћ ќИ–ўџЪƒ†•џі8ПљZzˆђHі,љsHљzШњ™ћŸˆќФШќЭˆўHwˆ’Q7bi—k††‡‡њ‰‹’бe:љy:uУŠПXtC§оўэƒ<lАЮбнcЌVrlі.l§т5јVWZZЕњ—˜™šѕћД^ЭаНпцєїџ=žі0ојmљuњ‹оћБd-0^Vоg'НрЇсJЇјfh'ќКЇўgџ'.1ч‡'ŒŽpБЮбнdАјhYї>b|adg‘”——˜˜АБВДДЖЖИИКМОПРСТУФХЦЧШЩЪЫЮЮббдджжнноопртуфхцыэ№ђѕјћћџ    !#%')*-.012255779:<>AIIKKMPSXYZ\]cdeggiikkmotu||~~ƒK§Kџ”јdmдјl§лН8Џ=а”§ђKНїRRЦXt:ЊЖЦbЏrяZ abdjklmЊЋoх”/ї:/ћЄя§ыoў§Иљ~Ињ˜xќТИќЪ8§нИ§шЏ­­ЎЏАВAњџ@NQTј В*ѕO*і#%STjљ{ЊћЊЋ*§мЊAЊЄЄГ-02ѓїTW3њГћЋѓў—††‡мџ%мFœ”%нёѓіљ "?BхћВхў e9Ѕ]х†‡”Юі4ЮEї9—љ}Wњ‘зћАcW7 їM M ~ ŒŽ`I7 ЈОРТФЦШЪ)9\ —ƒЃЄЅІЇЈЉI—Н)*,-./01245789:;=>MNSTU`abdfhjklmnopsyz{}~€ƒ†‰‹‘’“”•—˜™šžŸ ЃЄЅІЇЈЉЊЋЏВДЖИКМОРТФЦШЪЭаджйлмноптуфхцшщыэ№ђєїћ§џ   !#%'),/2579:<=AEFGIKMORVYZ[\]_begikmoruwxyz|~‚ƒ†‡Š‹ŒŽ‘’”‰јdIўїЩџ#I5р Ў’§х’|Л .//0yzz||{OћwƒЄЅІЇ{і/Лі2;ї;{ўџЛџ!D7€D„Њ§й,DR-тJ-љv­љ~-/­Ж"—Ѓ6„ЖИі– ‰‹‘’”•Š”іќжЖў_ Šxy‘”§#пі5Ÿ§ц(!yzhqhќРЈќШ(ўђБМjlm‘“”•ZЭакњššћЊZўћšџš\oZxк†cКWscїIcќПСУХЧЩЫ*Œі/ŒїKOŒњ•ЬћЏŒ[ЬƒL•і/~—˜ЌГ#fў– jЃЃЈЉЉЊЊЋЌЌ>і*>јX[~јb>ћЅОCўIјUX‡љ|џ‡џљtќ ЗНвюѓљ"(jpљњžy§уyџљkBќМљЊ­ЏЋїN+rД_џfq }§ЎЏАБВИИfј`fњ’Or /012adg{ƒOї=иФЏВтуфхыэ№ђєї=berXн@Xј_иќаX§пиў !јVZЁњ—Šxbi m“ў“=|ћЈХў И Dџџ2ѕ@џџџџ*ѕ @џџяяtѓ @џџNNѓ @џџ BN:ѕ@0 CCMѕ@0 DD`ѕ@0 EEsѕ@0 FF†ѕ@0 GG™ѕ@0 HHЌѕ@0 IIШѕ@0 JJрѕ@0 KKіѕ@0 LLі@0 MMѕ @џџ №№ѓ @џџ == ѓ @џџ <<§ђ @џџ 99кђ @џџ      ї яёя&FeќёђžLžLžLžLžLžLžLžLžLžL˜ђЂЫ‡ђђђЂЫm'ЧєжѕфPТаѓŒPєІpєБ№єрYQ9ѓG9єœѕю№ТBіџтѓ‚єЙЂєП =+єšKєЅЫєзыєпtѓNСЯчєѓ’”єН!ZФ§ђ9bЬі=ѓHє˜ц2цђцєояђ8aЫє–єЛЯєи8 іСџџa"AѓItѓZФє”сєнѕуj'Ъѓ‹jєА*ѕяіџѓ=`ЩяЃѓ"]`‰Š‹ŒŽ‘’“”•–—˜™š›œЦЩнопрстуфхцГѓnГєбУєегєйѕц|' ѓ<_ШямѓŽ|єИ5ѓFEєЄUєЇѕєсNѓJu^ѓLwОѓ‰юѓ‘w'WѓKvЗєвзєк@єž)ѓCiѓM‚2џ’ѓ[2є›2ѕџѓBhЛєглєлћєтѓ9bЬФѓŠ$є™dєЏ-ѓD­єа ѕхЖ*јќЖжѓє—vєВџџ_єЉПєдшѓє•ˆєКЈєХдџ1ѓEкђšѓ\њѓ“ZєЈšєО  DџџЃ @LtР 1L: @џџ2wХ @  ў 1 Х @и ў 1и у @ ЅжhР 1!Ѕж @ %эѕF 1) эѕ @ - уыF 11!уы @5!йсF 19"йс' @="Язc 1A#Яз' @E#ХЭc 1I$ХЭ' @M$ЛУc 1Q%ЛУI @U%БЙ 1Y&БЙI @]&ЇЏ 1a'ЇЏI @e'Ѕ 1i(Ѕj @m(“›& 1q)“›j @u)‰‘& 1y*‰‘j @!}*‡& 1+‡‹ @#…+u}› 1‰,u}‹ @%,ks› 1‘-ks‹ @'•-ai› 1™.ai­ @).W__ 1Ё/W_­ @+Ѕ/MU_ 1Љ0MU­ @-­0CK_ 1Б1CK|† @/Е19A5 1Й29A|† @1Н2/75 1С3/7|† @3Х3%-5 1Щ4%-|† @5Э4#5 1б5#|† @7е55 1й6 @џџк6   !#%')+-/1357   "$&(*,.0246ёХЦBзvзЂЫ=sБtРEzЯžЯЮзќзЂЫ=sБtРEzЯžЯЮзNиaиЂЫ=sБtРEzЯžЯЮзќзЂЫ=sБtРE5‘РидиЂЫ=sБtРE5йв‘)йЂЫ=sБtРE5‘в‘’ЂЫ=sБtРE5‘РидиЂЫ=sБtРE5йв‘)йЂЫ=sБtРE5‘в‘’ЂЫ=sБtРE5‘РидиЂЫ=sБtРE5йв‘)йЂЫ=sБtРE5‘в‘’ЂЫ=sБtРE5‘РидиЂЫ=sБtРE5йв‘)йЂЫ=sБtРE5‘в‘’ЂЫ=sБtРE5‘РидиЂЫ=sБtРE5йв‘)йЂЫ=sБtРE5‘в‘’ЂЫ=sБtРE5‘РидиЂЫ=sБtРE5йв‘)йЂЫ=sБtРE5‘в‘’ЂЫ=sБtРEkй‘“йІйЂЫ=sБtРEkй‘РидиЂЫ=sБtРEkйцйв‘јйЂЫ=sБtРEkййв‘)йЂЫ=sБtРEkй‘в‘’ЂЫ=sБtРEЂЫR™ЉЦљЉpЯгћыЎЏї^љњћ§џ  "#&(,-0267:<@ADFJKMPRUWZ[_`efikopsuyz}ƒ„‡‰Ž‘“—˜›PQRTUVXYZ]^_bcdfghjklopq‚ЊЗЦтСю.7@KЊЌЗЗЦ‹ў­ГруыЮ, јЮGФ ОРСЧЫыэюѓд‚Nљњћ§џ  "#&(,-0267:<@ADFJLNPSUXZ\_aefikopsuyz}ƒ„‡‰Ž‘“—˜›RVZ_dhlrTƒI "'(*,1236;<=@EGHORY[cefmpwyƒ„‹Ž•—ŸЁЂЉЌГЕНПРЧЪбглнохшяёЇЊЎкнэ!ЛРР"#$6Э# z{Э96јќ !$'+.158;?BEIOTY^dgjnqtx{~‚…ˆŒ’–™œOSW\aeinэЉГЗЛМНОРЮбдемуыэі mtИш-Я,&љ"fЦжСюѓ.7@ЖmЏўлTXfj{|/Uоъ/ОщыПадJhJT^†šxЯ(1:CшїКч+ayС9їNё9ОыaЯБс!5>QбЛМНб##$FqбЗ1јГу%jњQ(2<FPZdnx‚Œ– ЊДОШвмц№љ§  !$'+.158;?BEJPUZ_dgjnqtx{~‚…ˆŒ’–™œЈлPTX]bfjo :wЪъ і“ЇЗ3ЌcCЊИМНЫншљљ"8f "%()*,/23469<=>@CGHMQRW[\aefkopuyzƒ„‰Ž“—˜ЁЂЇЋЌБЕЖЛПРХЩЪЯгдйноучшэёђЅЈЉЊЌ­Ўилмнор ѓОРыэі/8Asј#--??šВЬвтѕ| \."),36=@GJQT[^ehory|ƒ†—šЁЄЋЎЕИПТЩЬгжнрчъёє ‚f "&(*,0236:<=@DGHNRX[beflpvy€ƒ„ŠŽ”—žЁЂЈЌВЕМПРЦЪагкнофшюёІЈЉЊ­ЎОССЧЫйлмнрщъыююѓ ..77@@,##$%,//8AAFGJKе# ѕЯБс!о‚ББУгсс№ћ!!(,,15:>CюmМНљžнРэ>јГЕух%''ўщѓw|ЗЧЫ7ƒ\^np/AЗr| "(*,236<=@GHR[efpyƒ„Ž—ЁЂЌЕПРЪгношёјњћќџ "#&(,-0267:<@ADFIKMORTWY[^`efikopsuyz}ƒ„‡‰Ž‘“—˜›ЊЎнRVZ_dhlqрѓ%I€. "*,46>@HJRT\^fhprz|„†Ž˜šЂЄЌЎЖИРТЪЬджоршъђє)ƒЈЉ­лмрOQSUWYacegikiЯУ№rgБУгдс№ћ!(15:>CJ2/8AtЫђа,{C6668’ ЏЛМН"##$6[ Dџџ—ў @Ef: @џџ2 —ў @ "Cšў @ ў —ў 1 ў Ќў @ іћhР 1 іћЌў @  яєhР 1яєЌў @ шэhР 1шэЌў @ "сцhР 1$сцСў @(ШпhР 1+ШпСў @/ŸЦhР 12ŸЦS† 2}“мў@42€€ўў@42Eƒ 15}“ џ@ 6„„Iџ@ 7……tџ@ 8††œџ@ 9‡‡Фџ@ :ˆˆьџ@0@=ŠŽ@2@?’Ž† ?UIяј@4?U)ƒ 1BVII@ CVl@ DV‘@ EVЕ@ FVй@ GVў@ HV"@0@KV#&"@0@OV!N@2@QV(*{@ RV,,Ђ@ SV--Щ@ TV..№@ TY1B@0@,WY49T@0@,YY;?Ž@0,ZYAAТ@ Z_DXч@04Z_EE0]_TT@0@0a_HLDH0@0c_NQx0f_UUЉ40g_WWг@0@j_Zyї@0@m_{~@0@o_€‚=@0@r_Ий=@0@u_ЅЖ=@0@x_“Ѓ=@0@{_‘=@0@~_n=@0@_[k=@0@„_HY=@0@‡_4E=@0@Š_"2=@0@_ =@0@_і=@0@“_ує=@0@–_Сй=@0@™_ЎП=@0@œ_ЇЌ=@0@Ÿ_ Ѕ=@0@Ђ_šžg@0@І_)Ng@0@Љ_$'g@0@Ќ_"g@0@Б_љg@0@Е_єїg@0@З_лђ‰@0@М_U€‰@0@Р_PSЏ@0@Ф_‚Ѓд@0@Щ_ЅИњ@0@Э_КН@0@в_ПаG@0@ж_вжn@0@и_иь‘@0@л_юџЗ@0@н_лH0@п_@0@с_*#@0@х_5<#@0@ш_,3G@0@ъ_>Ek4ы_HHQ @џџь_      !"#$%&'()*+,0789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`-./1234568ЮpЮ­ЮшЮЯIЯzЯžЯ‚ЂЫ=sБtЧЯъЯа%аЂЫБtЧЯъЯ\аpаЂЫБtЧЯъЯЇаИаЂЫБtЧЯъЯэаџаЂЫБtzЯžЯ4б?бЂЫ=sБtzЯžЯoб{бЂЫ=sБtЂЫ=sLsšфwД+ДFДЂЫ/Щ^ЂЫЂЫ=sLsТ;еBТЋбЂЫ “Д“ЂЫЫбBФVФЂЫД+ДFДЂЫв‚ЂЫ4вЂЫYввЂЫвПвдвЂЫгYвв55Пвї5Пвїї 1гЫб^1гšН_г1гзНjг1г О{г1г_О‡г1гœО’г1гяОЈг1гЕгЯг1г}Пшг1гИПђг1гдд1гРд1г+д7д1гRРBд1г?ЫgЫ1гLдэЫ1гЋде4вUе‚ее4вUеПе4в4бше4вoб`Ж‚еѓе4вoб`ЖwЖ ж4вoб`Ж‚еѓе4вoб`ЖwЖ4в1жLжж4вoбВж`ЖыЖ4вoб`ЖwЖєЏoбВж`ЖыЖєЏoб`ЖwЖ ж4вЖШ4вєЏ‡ђ4вУж.ЕЭ4вяжkЭзєЏЂЫ”ў€PўПеP€ ШЭббд§ љЉі&R9ўЅМЬyў9ЬА‚Њ cn­Й /:R]д ‡”œЂЉќXЇСЄД…єм58tнЏ§§HKZa{}B =>@юјZjВКЛЫйъьјњц§ЕЕЩЩъъўў));;OOaauu‡‡ššЌЌfnЙ:]цƒа5цѓИ$)‚ƒ/Uњ )>V_/,,fСлн2_bƒŽим^††БЮ3VЏнј8--,>D‡‡xЯљ "8ј_AўЅЏПЬaС9s•jA../58ˆˆaЯАУхј$6J]pƒ•ЇКо§+Y…ЈТк№`ЇЯ*Mн/!ыИЬэ+>RdxŠœЏлєіљ$&)j :Š=>Ъ_ чm’fе“ЇcЕЩъў);Oau‡šЌ­ 0S*нЩ3 І/0:RS]ГqЯB?єљњ)=PUV}ЅКПгю}€„Š‹ŒŸЁЂЂЅІЈВЛТШЪЫЫЭў%&+/0:HINRS]ѓ278=>fhИЬэ+>RdxŠœЏСУч24bdm’ЏЩхј  /8AfБГе34VWга\tгб…‡ˆ‹Ž’”•šœ ЂЃЇЉЊSн\ўЯ| <є ј14;EIўKZ}…ў>%„EƒŠ—˜Ў:GH—ў#Fwƒ—5в—qЫ<ЗoЭ  =xjКОй;^7ƒŒЗЮaзн р8#(4;HNTUZ{€…‹’š ЇЎСуі"4H[n“ЅИлєљ$)PU‚ЅКПгию,5>XŠР:[рєњPV‚ЅЏКППХггHАр  ИОЭ$&)@Š‹Œ)ƒ3#(XY\uv€‹ЁЂЅЪЫЭтущъ№ёїј"#+EFNklmnopqrstuvwxyziЯkЦъ 7g”ВЪцhЖз7ZЉа.7@щм8A2ў‚rghАЙНУЭавзхюђј $,06?CJSW]eipy}ƒ‹•ЁЇАДКЦззоъ№§ +7KLYgr~~…”ЁЈВЖТШЪЮкцъ№љ§ "(`hnЇЖФФЯзн*7@MZcђф09B2Э@ђаaЛЅМПе{CєіњPRV]p‚‰ЅЏБКМПЬЬгеАГ{#&)Ф>fhioСУФЭнучщё  245=bdejxŽ’šмрхы^fgjБГДКОЮежй345;VWX^јN ^_fhkw‹‹Ž  ЃИНЬзэђ +0>CRWdix}ŠœЁЏДСУзч№і&24LRbdm~’ЁЏЖЩЮхъј§  (/18:AЭ# ‚Э9uv—˜"Ekmoqsuwy­B,/ €58э>45HI_afknoЂЉ­ААБГПУФХЫаекноухъьёѓјњ  #(+034=@BFKNSVW`ceЖ<8жiФЬщ5?e‘фї gДж5XЖоЛвзіїqКЮя-@TfzŒžБдэGzžГчњ ўPRUў,5Па#kwНзђ 0CWi}ЁДз№L~ЁЖЮъ§(1:nФн@cЈ:Ў€*4AH………‹’ššš ЇЎСуі"4H[n“ЅИєљ$)PU‚ЅКю,5шїeЗЫь*=Qcw‰›ЎРц1a‹Ўуі eЏд2Uqўю‘ўЈФё9 ё‚1ЬQ fС2bхБ3VQбААУqбcЕЩъў);Oau‡šЌ­ 0S1в%1ј$DHTTUUБФцљ%7K^q„–ЈМрџ-[‡ЊФнђaЉа +NњЁЪтщ№ї#FkmoqsuwycўгcC єіљќPRUXx}ЅЇЏКМПСЬгеЂЄЈОТФухёѓє^_ь§пьў,EJZlw~†™ЉАУлёHlўи ‚k,-.iioФФЬЬЭущщ  55=??_eexƒ‘‘рффїї  ]ggj~€…†‡ˆŠ‹Œ ЁЂЅДДКОЩЪЫЭжжйстушщъя№ёіїјџ&+355;INVXX^ьѓ ѕ§578=>AKўЕИЩЬъэў)+;>ORadux‡ŠšœЌЏеr#ЬбUИИЬЬээ++>>RRddxxŠŠœœЏЏѕЯАУхј$6J]pƒ•ЇКо§+Y…ЈТк№`ЇЯ*MОqбDо‚„%\aacktw’’•ЇЇЊААЕУУЩавххъјјў$$)66;JJO]]appuƒƒ‡••šЇЇЌККЦзооъъ§§ ++7KYYgr~……”ЈЈВВТТШЪккц№№љ ".01579:@BB``hhЇЇЖФЯЯзз**7MMZЬбоЯBžн hУ4dГ4W>ј?KPWБГФЦцшљћ%'79KM^_qs„…–˜ЈЊМОртџ-/[]‡‰ЊЌФЧнпђєacЉЋав  +-NP'ў_jƒšч‚№09D0tЏАБХЩЫЬЬ™ЉnЙ:]pЯwавзъKr~ВШ1:hФз„s•jY}KXY\]uv—˜"#&EFIklmnopqrstuvwxyzƒŠтRЎЙСдуюі ",4?HS[eny‹“ЅАтiФЬущ5?eƒ‘рфї gДж(5KXKЊ ccnІ­­Й   ў{KўК‹ў \^_aЅЉБЭЮа Kн  јkПк=`Њ Dџџ8ј @ъ№: @џџ2 ї8ј @уш}ј @ кр}ј @ гиxј @Щаxј @СЧ‚ј @ ИП8ј 1ИП—ј @ ЏЖ}ј 1ЏЖЋј @ !Ѕ­xј 1$Ѕ­Пј @(ЂtР 1*ЂПј @.–›tР 10–›Пј @4”tР 16”Пј @:ˆtР 1<ˆдј @@a†tР 1Ca†дј @G3_tР 1J3_Пј @N 1tР 1P 1Пј @Tн tР 1Vн дј @ZЖлtР 1] Жлдј @!a ‡ДtР 1d!‡Дq† $dI$Dяј@"4dI''7ƒ 1gJ$D љ@ "hJ**0љ@ "iJ++Uљ@ "jJ,,yљ@ "kJ--љ@ "lJ..Сљ@0@"oJ69Сљ@0@"sJ04эљ@2@"uJ;=њ@ "vJ??Aњ@ "wJ@@hњ@ "xJAAњ@ "xMCTКњ@0@0{MFKѓњ@0@0}MMQ-ћ@00~MSSaћ@ "~TVy†ћ@44~TWWЖћ4TuuЖћ@0@4„TZ`ућ@0@4†TbhќH0@4ˆTorEќ4‹Tvvvќ44ŒTxx ќ@0@"ŽT{€Уќ@0@"T‚…цќ@0@"’T‡Ž §@0@"•Tгі §@0@"˜TПб §@0@"›TЋН §@0@"žT—Љ §@0@"ЁTƒ• §@0@"ЄTn€ §@0@"ЇTZl §@0@"ЊTEW §@0@"­T1C §@0@"АT/ §@0@"ГT §@0@"ЖT№ §@0@"ЙTЯц §@0@"МTЛЭ §@0@"ПTДЙ §@0@"ТT­В §@0@"ХTЇЋ4§@0@"ШTј V§@0@"ЬT z§@0@"ЮT!(ž§@0@"вT3:ž§@0@"еT*1Т§@0@"зT<C ј @џџйTії @џџкTшї @џџлT  @џџмT   !$   #%&'()*+,-./04<=>?@ABCDEFGHIJKLMNOPQRSTU"12356789:;ЏФчФ$Х_ХХРХЏФчФ$Х_ХХРХЏФчФ$Х_ХХРХёХЦіЂЫ=sБtёХЦіЂЫ=sБtёХЦіЂЫ=sБt>ЦaЦ‰Ц›ЦЂЫБt>ЦaЦаЦъЦЂЫБt>ЦaЦ'Ч7ЧЂЫБt>ЦaЦjЧ‚ЧЂЫБtёХЦЖНЧЂЫ=sБtёХЦыЧ§ЧЂЫ=sБt>ЦaЦ3Ш<ШЂЫБt>ЦaЦhШyШЂЫБtёХЦ3Ш­ШЂЫ=sБtёХЦhШкШЂЫ=sБtЂЫ=sLseТ; ЩЂЫ “Д“ЂЫ/ЩBФVФЂЫД+ДFДЂЫ\ЩіЂЫЩЂЫДЩъЩЂЫ\ЩіЂЫЂЫЪДЩъЩ55ї ї JЪxЪ^JЪ“Йл\JЪдЙёПJЪЦСJЪЎЪЁРJЪпJжJЪKKƒиJЪЙЪвЪJЪфMdJЪщЪЫJЪ^7жJЪЫя?JЪ+Ы6ЫJЪіКїJЪ?ЫgЫJЪŽЫэЫJЪ4ЬЬЩЖШЩоЬ`Ж ЗЩЩ№Ь.ЕЭЩ?ЭkЭ‰ЭАЭCєэЭ-ЮЂЫ‚Як№.7BP€йпљЉЃЭЊpЯрє/8|ѓySY}FSTWX~СТЩЫгдкмуфъьƒ,0‚Њ—ЃРЭ9Яи тR*ЛЦЯлл№ћ(1<EPZenyƒŽ—ЂЋЖПЪŠЁЃрхљ6:NŠŒ˜šткнфшejpšЂЈЧЬвёў"(FSrw}Bјgk„‡ыЮb˜ФяDoKн$ ј  sЏе+Z€д“™ ЉЏЖєм36BјUkЙЭ#dx‘“ŸЁ}јВдлf4eа3цѓ,гњћ/??к˜ 8@@*<B8 Цпћ(<PeyŽЂЖЪxЯ.Чрќ)=QfzЃЗЫьѓў%glr“ЄЋЩЮдыєњ$*@IOVtyјнљN8ј ^~‹!ЋЛНХЮфцыюxјЈТЪaљС9|ѓAAA-36aЯ*Нбђ3G\p…™­Сењ#ZcinŒЁІЛХЫафјќ!&9MQgpv{н-aј j х:j :їŠ=P“ЇТжї $8LauŠžВЦ—Р3——РРГqŒп.$'*+,-.0ј ‡‰Š——ЖИЙМРРту35668acddfЅЇЈЏБВДИКЛѓ-IJOPХоњ';OdxЁЕЩщ$-6?fkq›ЃЉШЭгђљџ#)GNTsx~га]_}гб‘“”—™šž ЁЇЉЊ­ЏАДЖЗsј#_cdnoŽ™™ЇЇСХЦабц№№§§&';EERRlpq{|| <є13јCFMW[\јзйк ƒ-Ў:YZЉ.7@wћ—q‰мЗrfЗъ7ƒ6&*06;STW~‰ŠИЙМопу 568cdf‰Š‘—˜žŸЇЈБВКЛСТЩЪгдклуфъыЦпћ(<PeyŽЂЖЪfq›ЉШгђџ)GTs~р(06;FMZbouv{‚‡‘—žЇ­ДЛЯ№1EZnƒ—ЋПгј !*3<SР:nр _ŽСххц::;l р03гйооѓрѓ WY[уш8=fhЉ7Ља$,5>щм6?ЩыХоњ';OdxЁЕЩјЊДФЭжо)јGIJOPSgkrgnНЧЫбрфђќ)-3=AGQU\fjpz~…“™ЃЇ­ЗЛСЫЯеьєєњў#%&ZcgilnrwŒ“ЁЄІЋВЛХЩЫЮадйфыєјњќ!$&*/9@IMOQV]gptvy{„2щfkq›ЃЉШЭгђџ#)GTsx~ђа Šи b˜ФяDoRјТХжоїњ $'8;LOaduxŠžЁВЕЦЩ{C ŽЁЁхцчљљ:;<NNФкннфъј@+3}~——š­­АХЦЫопфњћ'(-;<AOPUdejxy~Ž“ЁЂЇЕЖЛЩЪЯрщѓ$&-/68?Э# њЭ9~СЩгкуъ­B*- €36-Яb˜ФяDoMј‚mј<Ж<JжqсжнфшejpšЂЈЧЬвёў"(FSrw}ЖожкєіїШс§*>Rg{ЄИЬяј.ТТжжїї  $$88LLaauuŠŠžžВВЦЦПаЫф-AUj~“ЇЛЯрѓ&/8wВй/]„Ј:Л€!*FSZ‘‘‘—žЇЇЇ­ДЛЯ№1EZnƒ—ЋПгј !*3h fшїФнљ&:NcwŒ ДШчa–УюCnHј{ё9 оQбђ__vŽŽЎССиццч.;;<YllƒqбТжї $8LauŠžВЦ—Р1в81јVZbuuvvОвѓ 4H]q†šЎТзћ[Мш=hњ‰Ио 5c‰—žЈВЛТЪдлфыcC Яйє]^}~ ‚j%'*+,-0?@AкннффшшъXeejjppˆ‰ŠššЂЂЈЈЗИЙМЧЧЬЬввнопухёёўў  ""((4568:FFSSbcdfrrww}}ˆ‰Š‘–—˜žŸІЇЈАБВЙКЛ,–FGZ[]]^_Y[__bffkqqsvwxŠŽŽ—˜››ЃЉЉЎЏВГЙМРССФШШЭггеийкпццчшяђђљџџ #))+./06;;<=DGGNTTYZ]^dhllossx~~€ƒ„…ŠŒ‘“˜šŸЁЈЊЊЋЌВДЕЛНОТФХЦЫЭЮЯджзмопфцчьюяьЯз ьѓ3еr6ѕƒ.U-.Хоњ';OdxЁЕЩѕЯНбђ3G\p…™­Сењ#ZŒЛф9gОqто‚Ў8}ŠŠžžЁДДЗННТЧббжзиийкрђђїќ    $)338=GGLQ\\afppuz……Š™™žЃ­­ВЗССЦЫеерьђѓєњњў##$%,./3578>@@ZZbbcgilnrŒŒ“˜˜ЁЄІЋЛЛФФХЩЫЮадффыяяєјњќ!$&*99@DDIMOQVggooptvy{ОЮŠоЯ@žно>ј1_qxОРвдѓѕ  "46HJ]_qs†ˆšœЎАТФзйћ§[]’МОшъ=?hjч‚'+gј*3ё DџџЦЮ @(,: @џџ2 -ОЮ @"&ЗЮ @  уЮ @ йЮ @аЮ @  Я @№Ю @ўЯ @јќƒє @ђіyє @!ь№pє @$цъfє @'рфZє @*коOє @-диCє @0ЮвыЮ @3ШЬіЮ @6ТЦЯ @9МРЯ @<ЖКџЮ @?АДЯ @BЊЎ‡ B8œє@4B8ч‚ 1E9œє@ F9Мє@ G9мє@ H9ќє@ I9ѕ@ J9Aѕ@ K9gѕ@ L9Šѕ@ M9­ѕ@ N9аѕQ9––аѕ8@S9‘“аѕ@0@V9"єѕ@2@X9$&і@0@[9.1і@0@_9(,9і@0@b99<9і@0@f937\і@0@i9>D~і@0@l9KP~іH0@n9FIœі@0@q9W]œіH0@s9RUМі@0@v9_eмі@0@y9lqміH0@{9gjћіH0@9swїH0@‚9y}<ї8@†9€[ї‰9——€ї4Š9™™Єї4‹9ššЦї4Œ9››ы @џџ9      !"#$%&'()*+,-./0123456789:‹ЎoЙ Т‹ЎoЙ Т‹ЎoЙ Т‹ЎoЙ Т‹ЎoЙ Т‹ЎoЙ Т‹ЎoЙ Т‹ЎoЙ Т‹ЎoЙ Т‹ЎoЙ Т‹ЎoЙ Т‹ЎoЙ Т‹ЎoЙ Т‹ЎoЙ Т‹ЎoЙ Т‹ЎoЙ Т‹ЎoЙ Т‹ЎoЙ Т‹ЎoЙ Т‹ЎoЙ Т‹ЎoЙ Т‹ЎoЙ ТЂЫ=sLsТe;BТšфwД+ДFДЂЫZТŠТЂЫЂЫГТ^ЂЫї аЎэ*ї яЎхТCЏї аЎэ*ї ЏхТCЏћТУŠТIУkУ”УIУЛУнУ^ЛУl’x’’šФШšBqбu{1вŒёѓ*TYZ„ˆ™Ъ(*.06[jњЊАЖМТШЮдкрцьђјў "( :-“Їu{*єloZєк3 gllnsy›ѓRWbcуЮтЯјњCЯИє@FK3єnpCєЮƒєђ| ‚ЯЊЌаьѓ!€<є‹%ўЇy|ѕЯ(*036;%ыBЊЌ­АВГЖИЙМОПТФХШЪЫЮабджзкмнртуцшщьюяђєѕјњћў   "$%(*+ž.__aо‚N*BaЊЊЌААВВЖЖИИММООТТФФШШЪЪЮЮадджккмрртццшььюђђєјјњњўў   ""$((*ОЮю"$Ўа(+36бажмтшює~б_aw17ƒAglЗЮшЗа6єMOр$(.39>FKRW_glsy€‘–—р!WZ€„рѓFKKMšI€>@ABIа.9rg (++.03569;ћІ_ac$Њsvћѓ@HMN…š„бadЭ# 0Э9 Ђ-ЯФЪіЮТФЯЖИнcџЮАВПа39;‰єY\€>>–——@ Dџџ Dџџ Dџџо DџџСьB џџNNль $:IЋ@4$==ѕƒ 1%:I: @џџ2+)aёь@ +@@э@ +AB/эB0@ +DIСьB +KKNэ:@ +NPnэ8@+SV‹э8+XXЇэ@0@+cgЇэ@0@+[aЦэ@ +iiчэ@ +jjюH0@+˜œюH0@%+’–юH0@++ŒюH0@1+…‰юH0@7+ƒюH0@=+x|юH0@C+rvюH0@I+lp#ю:@O+9@#ю:@U+7#ю:@[+ч#ю:@a+мф#ю:@g+вк#ю:@m+ЧЯ#ю:@s+НХ#ю:@y+ŸЛAю4@~+CW^ю4@ˆ+YЯ{ю4@+бъ˜ю4@”+ьЕю4@™+%бю4@ž+'-юю4@Є+/@я4@Љ+BH-яB џџЊ+77Fя /ЊOа2Ћ@-4ЊOггцƒ 1­Pа2[я@ -ЎPжжzя@ -ЏPзи—яB0@-ВPкп-яB-ГPссЕя:@-ЕPфцдя8@-ИPщь№я8-ЙPюю №@0@-НPљ§ №@0@-РPёї)№@ -СPџџI№@ -ТPi№H0@-ЩPJOi№H0@-аPCHi№H0@-зP<Ai№H0@-оP5:i№H0@-хP-2i№H0@-ьP&+i№H0@-ѓP#i№H0@-њPi№H0@-Pi№H0@-P i№H0@-Pƒ№:@-P2Oƒ№:@-P0ƒ№:@-$P ƒ№:@-+Pіƒ№:@-2Pсѓƒ№:@-9PЭпƒ№:@-@PИЪƒ№:@-GPЄЖƒ№:@-NPŽЂƒ№:@-UPwŒƒ№:@-\PRu №4@-cPRІП№4@-iPЈ1о№B џџjPЭЭђ№ VjSЛЩ ё@T4jSННїъ 1lTЛЩё@0@TpTРУFё:@TrTЦШёъ sTИИьъ tTЗЗoё ]tn.ЕЋ@[4tn00Nъ 1vo.Её@ [wo34œё@ [xo55о№B[yo77ЗёH0@[{o9<жёH0@[}o>AѕёH0@[oCFђH0@[oHK*ђH0@[ƒoMPDђ8@[‡oqwDђ@0@[‹o]aDђ@0@[ŽoR[^ђB0@[‘ochwђ:@[“okn’ђ8@[–oyЉђ:@[˜o’Ыђ:@[šo”—эђ:@[œo™œ ѓ:@[žožЁ(ѓ:@[ oЃІEѓ4@[ЂoЉЎ\ѓ4[ЃoААwѓ4[ЄoББŒѓ4[ЅoВВЉѓ4[ІoГГХѓ4[ЇoДДъ@џџ­oъ@џџГoъ@џџЙoъ@џџПoъ@џџХo=ъ @џџЦo++5ъ @џџЫo&&%ъ @џџаo%%6 @џџбo      !"#$%&'()*+/VYZ].0123456789:;<=>?@ABCDEFGHIJKLMNOPQR-UWXT\^_`abcdefghijklmnopqrstuv[ъ—ЂЫ=sЯИЙ+Й3є<˜№ъ—ЂЫї њ—`˜ЗŒЂЫњ—j˜ЂЫjэ*š˜˜ИoЙ‡Й“ЙЄЙ˜ИoЙ‡ЙдЙхЙ˜ИoЙ‡ЙЦК˜ИoЙ‡ЙпJ>К˜ИoЙ‡ЙKKrК˜ИoЙ‡Й]MК˜ИoЙ‡ЙфMЮК˜ИoЙ‡ЙіКЛ˜ИoЙ‡Й“ЙЄЙ˜ИoЙ‡ЙдЙхЙ˜ИoЙ‡ЙЦК˜ИoЙ‡ЙпJ>К˜ИoЙ‡ЙKKrК˜ИoЙ‡Й]MК˜ИoЙ‡ЙфMЮК˜ИoЙ‡ЙіКЛFё.Л9ЛDЛcЛ˜ИoЙ‡ЙxЛ‰ЛЛАЛ”СЛFё.Л)МDЛ;М˜ИoЙ‡Йї(”XМ˜ИtT”М˜ИзЊ”ЗМ˜ИзЊ”нМяМ˜ИЖ”Нъ—ЂЫ=s;НЙ+Й3є<˜№ъ—ЂЫї њ—`˜ЗŒЂЫњ—j˜ЂЫjэ*šо)о)ŸЌoЙ{НšНІНо)ŸЌoЙ{НзНщНо)ŸЌoЙ{Н О-Оо)ŸЌoЙ{Н_ОkОо)ŸЌoЙ{НœОГОо)ŸЌoЙ{НяО§Оо)ŸЌoЙ{Н0ПDПо)ŸЌoЙ{Н}ПˆПо)ŸЌoЙ{НИПЫПо)ŸЌoЙ{НРРо)ŸЌoЙ{НRРcРо)ŸЌoЙ{НšНІНо)ŸЌoЙ{НзНщНо)ŸЌoЙ{Н О-Оо)ŸЌoЙ{Н_ОkОо)ŸЌoЙ{НœОГОо)ŸЌoЙ{НяО§Оо)ŸЌoЙ{Н0ПDПо)ŸЌoЙ{Н}ПˆПо)ŸЌoЙ{НИПЫПо)ŸЌoЙ{НРРо)ŸЌoЙ{НRРcР‡ђ“РЌ$ЌРx’РР‡ђ“РЌ$Ќx’іРъ—ЂЫ=sЂЫUjы;ЂЫ'СFСЂЫ=s+Йšъ—ššY~`С`СЂЫUjы;ЂЫњ—j˜ЂЫjэ*3є<˜№ЂЫї њ—`˜ššY~`С`Сї ј$ššJJжПј$FœйРђ}СœKј$FœйРђ}С’Рј$FœйРђ}СžLј$Fœ‡ђРђЃСйј$Fœ‡ђРђЃСШСаСчСˆZыС№СѕСчСˆZыС№СЂЫшЂ{Ї V`uyщѕќS_fЯ;Deцъg‚™П?Cыж\\VVЋЋ@ЇЇ__№№‡ьЋХ'8љЇыюY^`no~­ГЕUXc+аЮйыи[]BЈ9ЯcфТB6СТУЫЬЭжзирсты  35=>?Zddkmt~†‡–ЋЌВЖЗЛОТУЧЪэђђѓѓѓўџ V{’ЈМбхњ"6ыЮВЁ tъ@”єыУЭитб4ь 3YBCFEУЭит 5?ъ%&ЏАЗ˜fцƒвнфёљ7SYdeOr%%&&ъ§Oы#egj|‚†“™ЉЋБНПХвдкцшюћ§#%+7?@CJa ca8ўЪ›C‚WЌ`ё!ы  &-5<CJ :a“Ї\VЋЇ_№;ћ#&ъ[.33359>Yfƒ„ŠŒ”БВГДЛНСЬЭаббжзззнџXYY^`no~‡­­ГЕЫр57:;;@AAAGimsy€†“™ ОШгнш:Zaccэ +0<CLNМ›>ŒXЫaгъ~ƒ ЌГSы#fij}‚†”™Њ­БОСХгжкчъюќџ$'+8?@EJьђћћ $$4[{|ƒ‡Š›И| ќsm†ЉХЇdЉђћ|ыYk­ООТЦааей  $$(cИКФЬƒ;V\Ў›9Š§ўgЙ…ъE™ьяё 6Ў: $%(ЬЯд:~€бгюƒ1;Gjllrrxx……ŒŒ’’˜˜ŸŸННЧЧввммчч99YYьь''//BBMNЎЮf.ы "*19@GNRwŽЄИЭсі 2юыТЬзс>ьw eЗr3зAїъМРЦР:/уш=?†н@R C™›WxŒЌЬ`bё€  "&*-159<@CGJNRVahntw{~„‹Ž’•›ЁЄЈЌЏЕИМРУЩЭбеиосхщьђіњў "&)/26;DHNS\^_`akkmnnoq||~ˆЉБГДЕЖНООПТЦЯЯааейс§§ў     #$$%(@д DIKRвзйфчъЋ@ы\^`VWXЋЌЫ§ЇЊЌ_`aЙ№ё€ыhmqx‚•—œ ЂИПвњ  !%-@ьDOPвлмцщ/ЋЌ­В Y‚ƒ„ŠŒыUВЂ„ђЅ 0S^crгкђњ=D\diЯ o…œАФйэ*IЉы{€щыСУЫЭжирты 5CFVбдщђ3rg7  "'*.169=@DGKNSoqx…‡œžЅАВЙФЦЮйлтэяї *,3IKВе&ђаYh~•ЌРещЃВФЮйуэѕ 5 Х ›ъJžd‚фыЗЭ# dЭ9RSUXY[ € ‘љћ§ўўџџЭыou{‚ˆ•›ŸЄНЧвмч9ьЖЗЛЛжq‡?Љ ceefкммнDFFGЯэѕSъџЪ%%&&?T  "&*-159<@CGJNRVahnw{~„Ž’•›ЄЈЌЏИМРУЭбеисхщьіњў "&)26;DHS\kn|ЉБНЯ§ #ІRS]^qrРСёђљњ[\cd/{ё9)ё‚бTZQб ЎЏАИœžЭqб\i–­Сжъџ'<EЇ_№‘ъH^ЌБъOЃёъИqыScdefфхцБыЏэ№ѕ-њ cкRЈDCYбь'/Bк37Эс7KNZыgjkšыxƒ„†Œ’š›Ьмнпхъѓєњыья№ёџ (,4:ь 5CzьŸЁЂЇ   cC ]^_`aЈЊЌЏАЗЗуЮIзЯdхCЯѕRcъ;УыКСд0L:Ќ~C{‚ŠŒ€‚†—™Z_a~€€ЁЃЄЎДЖЦйћў"(./FGJLMNPSUдеикмпрсхш "#(*+025689ьЯSDRŸвф ,ъ%%&&ьъЗ,ьїј !/TUЊЌѕƒ<GN[cNU[5 РСУЪЫЭежипртъы 5<=?еt a—ММяЗrrŒііјѕЯ '.6=DKSxЅЙЮтї 35ъ&ш@5ы[]Uь btv{~ƒ†‡‘–˜ўMž.07S^crЭгксђњTЉ7=DK\dNо<]yщюљSXcОqˆо‚  ''..66==DDKKSSYoqxx…‡œžЅЅАВЙЙФЦЮЮйлттэяїї  *,33;DIKScdefmsy€†“™ ЃВВОШгншэѕѕ:DIKRRSTZŸ ЁЂЇХвзйффхцчэ    'ЇUVY]`tuy{‚ƒƒ„„ŠŒщыєѕљќSU^_cfЇЇaоъ„Ѕ­ДЇ RЈCбg эч<Zvі`чR}kmВО5'Ь†№—fнGpЯ q‡žВЦля,K0ъ%&pь moy‚†‡ВДЖАь466PY:!YrjХуM 3бз;ATVZ\йЮK™ьЗУЪ/тRa   "(*/179>@EGLNTsy‰ ІДКШЯнуёј  .4Mmosuy{€‚†ˆ“•™› ЄЉОФШЮгйнушїљљћќўџ  ""$%'(+006:? ЈYŠŒY^`no­ГЕc+Ђыyƒ„†’“—šš››Эмнпцшъы№ѓѓєєbьfghinГдЇ~ ЯTKы:eghj|~€€€‰“•——— ЉЋЌБНПРХвдекцшщюћ§ў#%&+7;?@CDJRZ{ЃЈЎ.‹ыi€ Kь \pv~€—›ФФЬд‚3зAT *mosuy{€‚†ˆ“•™› ЄДЙОТШЬгзнсш 3:>ZЄЎЮэдЂ^я”ыv~дыЎДЕЙ›œžЄЅЎЏЮ=ъ+k”™žЃЦфRwŽЄИЭсі 2NŸНЧвмч9НъWX‹–ВX‡ˆЫрсaЗУЫ0<=Ц<Utє^ЏўgяŸgоHЦЮХчFъ+FьRSTјЅcкDС9PЬ ƒ˜МмёrŽіњAЬt~†‡‘j j:jьku~ОРТѓГq…œе%%Ј‚ƒ„ЯYЃ%5џ]_iхЧ~‚•™;?@dppqrsvvwЅ%бью%ъ%д%ыz  "'*.169=@DGKNSY\hix~•–ЅЌ­ЙРСЮежтщъїџ '3<Emosuy{€‚†ˆ“•™› ЃЄЇЎЏАВИОТФШЬЮгзйнсушьэюѕ  35:>Z_œž ХЭэ№ ЅьТУЧЧ— юXNъ/R]fkqЗИНСЭж@RX—9—E^lorux{‚…ˆŒ’•˜›ŸЂЄДДЗЗЙНТЧЬвзмсч 39>Y^ЄЄЋЋЎЎЗЗИИЙЙККУУФФХХЪЪЬЬЮья"#$'*+,/88==?BEFG—qWъ4HMž ЃЅыjр?9>CHMR]kqy”™žЃЉРЦфёљ &-5<CJRwŽЄИЭсі 2NS[clrx…Œ’˜ŸНЧвмч9 ;e|“ЉНвц7{РЪеп<рьрƒKбн   &&&---555<<<CCCJJJRRRwwwŽŽŽЄЄЄИИИЭЭЭсссііі   222SSЉЉ67 ь ѓ ))4[†ˆ›КвЅ 77ЭЭсс77KKNNЩъ}‚›ЋАW—ЌММя`rrŒёііјЩыlrx…Œ’˜tŒхtv{ƒћІTVЉЋЛ8R]cqРкёљaxyЬЭхD[cЎЏАРЪепъђѓ<[[\\d‘›žЖТэђљћ (06C{C%\lnt˜›ЌГЛПЧЪээљўџ ""(**02569:CEE{Wakps†ŠŠ˜  ЋДПШдншё§%.=CM-˜ЋЌ­-ЇqtРС-; ћ#Рг ъя№-ЯВ  ­ы—˜š›žяёѓєіїŒŽŽ‘’“јњњћ§Жv:6Жm[ŒіЮЂЇ ЖыЙРТЧгекњ &)Жь6899ЈЂƒ_ы h~•ЌРещ;DRпыДЙЄЎИЙКФЬЮ=BЈ:Tm ЈъM`ЊшъŠ‘Бhыў&Јl DџџpЫ Dџџ… @џџЂЫЭ#е#…l DџџЫ Dџџ : @џџ2фQ D;фQ D;фQ D;фQ D;фQ D;фQ D;фQ D;фQ D;фQ D; фQ D; фQ D; фQ D; фQ D; фQ D;фQ D;фQ D;фQ D;фQ D;фQ D;фQ D;фQ D;фQ D;фQ D;фQ D;фQ D;фQ D;фQ D;фQ D;фQ D;фQ D;фQ D;д @џџ       !„0є єєє#є,є3є:єAєKєTєZєaєhєqєxєєˆєє›єЄєЌєГєНєХєЮєзєсєъєѕєЂЫ(' ажзБ4ё9A: !xYЦЫqЯ‘д :RЦ‚д*еЪе"жз2зЛ xѓЦcЯыжЫlжФждхе&дЮдодFеO_xжH1 DџџЋ† NЏƒ 1OЏ: @џџ2P ЙОо8@P "Оо8@PОо PюоPп@ P%%>п@ P&&hп@ P''”п@2@P),Хп@ P..юп@ P//р@ P00@р@0@P8=@р@0@ P26kр@0@$PEHkр@0@(P?C–р@0@,PJMРр@0@/POUщрH0@1PWZс@0@3P\`9с@0@5Pbeaс@0@7Pgkˆс@0@9PmqЎс@0@>Psvзс@0@BPx§с@0@DP‡$т@0@GP‰Nт@0@IP‘—uт@0@KP™т@0@NPŸЄУт@0@RPІЉщт@0@TPЋЎу@0@VPАГ7у8@XPЗК]у8@ZPМП‚у8@\PСФЈу8@^PЦЩЭу8@`PЫЮѓу8@cPадф8@hPжл>ф8@jPнрdф8@lPтц‹ф8@nPшьВф8@pPюђмф8@rPєїх8@uPљ§+х8@zP +х8@~PџPх8@€P wх8@‚P х8@ŠP & х8@ŒPЦх:@P(+ях:@’P-0ц:@”P25Cц:@–P7:mц:@˜P<@“ц:@œPBHКц:@ЁPJfфц:@ЅPh„ ч:@ЊP†Š3ч:@ЎPŒ[ч:@ВP’•‚ч:@ДP—šЇч:@ЗPœžЭч4ИPЁЁѕч4ЙPЂЂш4КPЃЃEш4ЛPЄЄnш4МPЅЅ—ш4НPІІОш4ОPЇЇхш4ПPЈЈ щ4РPЉЉ5щ4СPЊЊ]щ4ТPЋЋ…щ4УPЌЌЎщ4ФP­­зщ4ХPЎЎ% @џџЦP      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQЂЫ=sLsЂЫ “Д“ЂЫЂЫГЛГъГГЛГ;šфwЂЫД+ДFДaДŠДИДеДєДaДŠД.ЕJЕ…ЕaД­ЕеДлЕaД­ЕJЕЖ*ЖQЖ`ЖwЖl’‡Ж’l’єЏ‡ђЅЖЅЖєЏЮЖкЖ`ЖыЖєЏЮЖ`ЖwЖЅЖЅЖЖШї ЅЖЅЖЖШєЏtT`Ж Зї ї      ї Зжї Ј(З5ЗBЗ    єЏї Зжї Ј(З5ЗBЗї Ј5З_З єЏї sЗЗ‹З”З ЗЌЗЕЗї ЅЖэЗ'ИЅЖэЗ'ИєЏЅЖЅЖєЏЮЖ`ЖwЖєЏЮЖкЖ`ЖыЖєЏtT`Ж ЗaДEИnИ…И…ЕaДaД…ИЖ*Ж єЏwЖ‡ђї #”’КИ  ЦИЦИ  ЦИЦИ‡ђ‡ђРђРђВЂЫŠ˜+Ї ‡нuGJан‘љм5†Йн‹›ЗbŒт …†(*-/9>?\yТ‚VsKнbД'єм258;tнsTонB‰ŒŽŸЂЃ§Я3<@G‡}нsuKVо %І€‰а2;†ЦнŽœ-~МН/..gm‰™Ÿ((--7<MЏн‰янЃ(zOож8 //28??EE†ŒŒ8н^ioƒ“єQXнj”ш?јнІaЛС9БA€BGŒA0028†н?EAн_2Ёо!$j :ЙŠ=АВЪ jp„ŽœЂЃ?z g…*н\jнp7>3B359<@BEG.%&Jsy‰ŸІЗМСЦЫжжжнтшюџџ   !!CJh’ЂЃЄЅІЇЈЉГ‚VsœЇ!#3н^__Sнd—| {\а8%&%eнp‹‹Œ››МVЅн„юо­ВЁ…оЊЅо!%Љ3@‡nоЂwН—5xBЗ`—н}Cзн™р)(-27<CJh†Œ’—œрJ\^ssyyІІє2CDJKNhik’€жиџрм+QSYЎ@о Эвкфъ№і%Ќщм28;IоаZiоџЉоNQSknpsђф3@‡2Ї2ŸRа9E2о Шпќ $ЉЛsGK{CJLsuy}ІЈDGKPTUYbimqrv€DDJLФM\`„бQT$оУ#Ѕэ!NSTUVWXYZkpqrstuvwЭ# {|~М­B?BEG € 258;авгљћќ оЙи#Є-оЦsоЋЖ<Ћ­ж…>\yнOо ОЭгйхыёі$ЈvоЃЖо NPXaekmuƒ_=Ё?EL’Ÿжйк  ?жкџ нORS_нj–<\ПнœтпнЁn€%J’шнЂ ё9 m†qбW‘нy:оЫZо пћ %­cољwЌ~suy}ІЈCGJVW`hstz~ ‚&%'./0jp„……†ŒŽœЂЃ(*-/9>>??V\\`syyz нJе#|еr •о #ž.OOQWœЎо‚233389;<@@@EG†‡‡‡~бRœžнўнЈhоС~оІgГД№—№‰БГДƒ  %)ГД™о $‚ DџџНЬ Dџџо‚ EЕ\rв@4EЖЖ: @џџ2Gb‚в@ GЙЙ•в@ GККЇв@ GЛЛКв@ GММЬв@  JСУмв  JУУєв  JУУ г  JУУ г@ JХХ9г@  JЦЦLг@  JЦЦ`г@  JЦЦsг@  MЩп&’@4 MЪЪ…г@0@MЭа г@2@MвдМг@ SтљЫг@0@Sхшрг@0@SъэігS№№дSёё,дSѓѓKдSїїeд@0@ SћzдH0@"S”дH0@$S  Љд@0@'S#&Љд@0@*S!Љд@0@.SЙдH0@0S(+Ыд@0@3S:=Ыд@0@6S48Ыд@0@:S.2одH0@<S?BэдH0@>SDGћдH0@@SIM еH0@BSORе@0@ESbeе@0@HS\`еH0@JSWZ-е@0@MSlq-еH0@OSgj=е@0@SS{=е@0@VSsyLе@0@YSƒ†]е@0@\S’]еH0@^Sˆ‹qе@0@aS™žqеH0@cS”—еH0@eS Ѓ’е@0@hSЅЋЂеB0@jS­ВГе@0@mSДЗУе@0@pSЙМге@0@tSОСяе@0@wSУмж@2@ySптжB0@|Sфы/жBSээAж@0€SююSж8@‚Sёѓfж8@„Sѕvж$„XŠж@0@CˆX Љж@0C‰X  Фж@0CŠX  рж@0C‹Xљж@0CŒXз$Œ\%з@0@I‘\Bз@0I’\\з@0I“\wз@0I”\з4@—\#Ѓз4@š\%7Жз4@œ\9FЦзŸ\HHпз4 \JJђз4Ё\KKи4Ђ\LLи4Ѓ\MM%и4Є\NN5и4Ѕ\OODи4І\PPUи4Ї\QQeиЈ\WWvиЉ\XX†иЋ\ZZœи­\[[БиJ џџЎ\ВВФиJ џџЏ\ААзиJ џџА\ЎЎъиJ џџБ\ЋЋйJ џџВ\ЉЉйJ џџГ\ЇЇ3йJ џџД\ЅЅHйJ џџЕ\ЃЃ[йJ џџЖ\ЁЁnйJ џџЗ\ŸŸйJ џџИ\“йJ џџЙ\ššЌйJ џџК\˜˜ТйJ џџЛ\––ййJ џџМ\””яйJ џџН\’’кJ џџО\ кJ џџП\9кJ џџР\‹‹TкJ џџС\‰‰jкJ џџТ\‡‡ƒкJ џџУ\……˜кJ џџФ\ƒƒВкJ џџХ\ХкJ џџЦ\икJ џџЧ\}}ыкJ џџШ\{{лJ џџЩ\yyлJ џџЪ\ww,лJ џџЫ\uuCлJ џџЬ\ss\лJ џџЭ\qqtлJ џџЮ\ooлJ џџЯ\mmЄлJ џџа\kkКл ‚а…&hyЮ 1в†&hШл@  в‡**ул ƒ г‡**њл@  г‰,.м … д‰..#м … е‰..ЄлJж‰00лJз‰11tлJи‰22\лJй‰33CлJк‰44,лJл‰55лJм‰66лJн‰77ыкJо‰88икJп‰99ХкJр‰::ВкJс‰;;˜кJт‰<<ƒкJу‰==jкJф‰>>TкJх‰??9кJц‰@A кJч‰BCкJш‰DE3м@  шŠGIKм › щŠIIяйJъŠKKййJыŠLLТйJьŠMMЌйJэŠNN“йJюŠOO\м@  ю‹QSuм Ђ я‹SSйJ№‹UUnйJё‹VV[йJђ‹WWHйJѓ‹XX3йJє‹YYйJѕ‹ZZйJі‹[[ъиJї‹\\†м@  їŒ^`žм Ќ јŒ``зиJљŒaaФиJњŒbbБиJћŒccЏм@  ћegЯм Б ќggnЮ @џџ§$$_Ю @џџў##QЮ @џџџ""FЮ @џџ 2Ю @џџЮ @џџЮ @џџњЭ @џџьЭ @џџфЭ @џџмЭ @џџЯЭ @џџХЭ @џџ МЭ @џџ АЭ @џџ ЂЭ @џџ •Э @џџ ‡Э @џџ{Э @џџpЭ @џџw @џџ   !"#$%&'()*+,-./0123456789:;<=>?@ABCINOPQRSTUVWXYZ[\]‚   DEFGHJKLMƒ…ˆ‰Š‹ŒŽ‘’“”•–—˜™š›žŸ ЁЂЄЅІЇЈЉЊЋЌЎЏАБ„†‡œЃ­В‡ђ‡ђ‡ђ‡ђЁ} АЩЎ‹ђ‹ђ‹ђЂЫї}~ЂЫЂЫЂЫї \ЎrЎї \ЎrЎІ<‡ђ‹Ў›ЎЗЎЂЫ5ї аЎэ*ї яЎжї Џ5ЏCЏPЏї аЎэ*ї Џжї ЏgЏCЏ5555ї аЎэ*ї wЏжPЏ™ЏБЏж™Џ™ЏБЏжЏFe™ЏБЏжї жЏжєЏАжєЏєЏ"АжєЏl’l’x’’‡ђl<<АжEА<Ажї MА<АpА‹Ў}АЗЎЂЫ5™Аїї ЎАОА3єЂЫї ЂЫ<АбАёАБ‡ђйЂЂЫ<А/БSБrБšБ‡ђДБї вБыБВ<Ажї ї ЎАОАPЏPЏ™ЏєЏєЏБšБВ‡ђ5І<,В3В3В3В_В_В_В_В_В_В_В_ВŒВŒВŒВŒВŒВИВИВИВИВИВИВИВИВИВИВИВИВИВИВИВИВИВИВИВЂЫќЌ} АЩхВыВыВыВыВыВыВыВыВыВыВыВыВыВыВыВыВыВыВыВzф Г Г Г Г Г(Г,Г,Г,Г,Г,Г,Г,Г,ГŸKГKГKГiГ4V*V/V#VlГsГzГГˆГоъ™ъ ъЄ/Ћ/В/Й/Р/Ч/е/м/ЂЫоGд{~ƒ…˜?DЇѕ‡Э2Я;ЧЯ ^aabbccЎАВМaGв"AаЮ3qаЯ`ЙAyЮH'kkmmooqqssuuwwyy{{}}ƒƒ……‡‡‰‰‹‹’’””––˜˜ššŸŸЁЁЃЃЅЅЇЇЉЉЋЋЎЎААВВЖ9ЯB9вюыЮ6wЋЯZЇ+вчшUXєЭA ЯWЁ]б™œf4жІ€ПП&Я?‰efя Абвж "*1TWЯЭ8AЮ=EбЉи;Oв<>?X УХШЩЪЫЬейиаO˜б­ибРРе§!CEPadс\aЯK’06AјўЁЯXЃЁаУЪ  #%17_ў :b“ЯSга?гбОРж"SвBCCCDD| М<БъќsЧ9МЭ6@ХЭ7AnЮ$\ЎЮ.Ўаw f7<ЏцwЗЮ0kљЗа(17AFKQЗбЙвїб еееежж'),-/12@RЭ@ЮРЯ\ЋiAЉ ЭЮitcВiЯL”FЉа IВ\$rg #%.01467:<bdђфUВ й2Эg2Ю>rач№ђаglђб ЬЮќ)556>@O›Ю<,00112233445566778899::;;<<==>>??@@BBDDkmoqsuwy{}ƒ…‡‰‹Й^[вZфЭ:CЭ# eЭ9ЕтжqжООЯ=…пqв€ џџ*_JŸ Юе !)?DЮ_Ю#[Ю*џЮ9}љЯOšПа.4:<џаlosw{ŸбДбпб Ре!BPˆаѓШа.1шб Ь %'5<Oё9QЮ"ZQб”™qб 1вэњХ­ф9к3їWXz9№ёѓэHZ[кArЙКЛМњЭ<DкЯaЎ:аХОњбсHуЮ5uЯ:CЯDCб‘ЌAЌ~ЬЮЮЮЯЯббвв!!!!""'))))*+,,-ьЭ;C,ЮьЯЙgllnossuv{{{}~ƒ…L,аУи бnpux}€е# •Э3ЕЯ[ЉѕЯК%(.147<W\^dJK5бž. ЅЅЇџQО;Џцо‚ЕХћћu}УУпэёH^_`aОЮ1mоЯbАбƒ~бЅ№—Рџ5ча\^gб›gв[№qpЭ0АЭ5№Ю7ypЯM–LєSЮйЮ4sбs{вфштDЂЭ4тЯg"вчщ‹Ю* Я<ƒKв<>>>??д\ аУ;Н\"§ЯЛ}аьёНбЛЯв,:ОПЦAЦ\#FЮ ?ЦЮ2oаМ/бŠЪЪњMxЯN˜LQјаinouvv}~~……ЩЩљLxбЂЇЈШШїџQA‚j&jkklmmnoopqqrsstuuvwwxyyz{{|}}~€‚ƒƒ„……†‡‡ˆ‰‰Š‹‹ŒŽ‘’’“””•––—˜˜™ššœžŸŸ ЁЁЂЃЃЄЅЅІЇЇЈЉЉЊЋЋ­ЎЎЏААБВВСбОжAвj ъAЊбЖЛ%3r^_`aГбЖЯб,мЭ9BЯ>‡\аЦмаW\bdйЅЮ.owЅЯYЅeаЩЭв%бˆЅбДЖЙЛОР%*15ЉVŸNЯGKKLLMMNNOO’”–˜šК_аСХWЧY^йјKWЯI^—аѕїWб–›œЫЫћNWвBCDр,Эвйхъћ #(.4:?DIOW\bgls{ƒˆ”™ ЅДЙОУпёѕ%р ˆ”™™›MN аУЉЩqлI€ћ§џ Ю‰ЯQUUVVWWXXYYZZ[[\\ŸЁЃЅЇЉЋЛ`IаЦ#:b вфћІЅЈRаЦЛю{Э1э‘ЪЮ„бЇЊmъ-Я@‹mатхъ№ёvAіЮ8{@ DџџёQ Dџџб DџџЅ” Dџџ“— Dџџ bš Dџџ ЉЊ Ž › ИЊ@4  : @џџ2Ђ ЩЊ@0@’ • ъЊ:@˜ š Ћ  } ‹ Ћ@ 4   œЊ 1 !} ‹ 2Ћ@0@  !‚ … TЋ:@ !ˆ Š wЋ Mey Ћ@4MffdЉ S#=Ћ@4S$$ž. p<ЖЂЋ@4p==ž.p55ЕЋ@ p@@ЦЋ@ wCbбЋwXXбЋ@0@wFIрЋ@0@wKUќЋwYYЌ4w[[#Ќw\\<Ќ w``PЌ@  ‹ЗєЋ@ 4 ‹ИИ`Ќ@  ™gДnЌB0@"#™mp…Ќ@0@"%™rxœЌ@0@"'™zГЌ@0@")™ƒ†ЬЌB0@"/™“ЬЌB0@"2™‰шЌB0@"5™›žшЌB0@";™•™­@2@"=™ЃЅ­"@™АА­8@"C™ЈЋ2­"F™ЎЎP­"I™ББj­4"J™ГГPЌ@џџJ™dd­:@ L™ЛО™­ O™ССЗ­ S™ТТе­ X™УУѕ­4@ [™Ыаѕ­4@ ^™ЦЩЎ4@ b™ве'Ў h™зиAЎ n™кл\Ў t™опyЎ z™ту”Ў4 {™ххЏЎ4 |™ццЬЎ4 }™ччцЎ4 ~™шшЏ4 ™щщЏ ™ыы6Џ ‚™яяPЏ …™ђђlЏ@0@Š™і|ЏH0@GŽ™ІЏ 1’šКЏH0@I•š"вЏ 1—›"тЏ4@š›ЌЏтЏ@0@Ÿ›arтЏ@0@Ѓ›P_тЏ@0@Ј›ANтЏ@0@Ћ›;?тЏ@0@Ў›79тЏ@0@А›15тЏ@0@RД›$&тЏ 1Жœ$&ёЏ@0@ИœtxА@0@ЛœzƒАH0@Нœ…ˆ!АH0@РœŠ—3АH0@УœšžGАH0@Цœ Ѓ[АBШœЅЅkАBЫœЇЇzАBЭœЉЉˆАЯœББЁАбœВВЏАдœГГША4еœЕЕеА@  еЇ&,ђА ` жЇ,,Б ` зЇ++Б ` иЇ++)Б ` йЇ++;Б ` кЇ**MБ ` лЇ**_Б ` мЇ))qБ ` нЇ))ƒБ ` оЇ))•Б ` пЇ((ЇБ ` рЇ((ЙБ@ сЇ--ЪБ@0@фЇ/2сБ@2@цЇ46љБ8@шЇ9< В$щЇhh'В@ ъЇkkDВ@ ыЇlleВH0@№ЇsweВH0@єЇnqВH0@љЇy}žВH0@ўЇƒОВH0@ЇŠОВH0@Ї…ˆнВH0@ Ї”—нВH0@ Ї’ќВH0@ЇžЇќВH0@Ї™œГH0@ЇЉ­9ГH0@ ЇДН9ГH0@$ЇЏВWГH0@+ЇПФxГB-ЇЦЦ˜ГB.ЇЪЪВГ8@2Їъ№ВГ@0@6ЇейВГ@0@9ЇЭгЯГB0@<ЇлрюГ:@>Їуч Д8@AЇђі)Д:@FЇ§ )Д:@JЇјћFД:@OЇ hД:@TЇ  ‹Д:@XЇ $ ‹Д:@[Ї  ­Д:@_Ї+ 2 ­Д:@bЇ& ) ЯД8@eЇ4 : яД:@jЇA G яД:@mЇ< ? Е:@sЇI R 2Е8@wЇT Z SЕ:@}Їa g SЕ:@Ї\ _ tЕ:@ˆЇi t ˜Е4‰Їw w ЖЕ4ŠЇx x wЋ ‹вUaЋ@›4‹вVVвЕ$›ŒвXXщЕ@ ›в[[Ж@ ›Žв\\ЖH0@›“вcgЖH0@›—в^a2ЖH0@›œвimLЖH0@›ЁвosgЖH0@›Ѕвz}gЖH0@›ЈвuxЖH0@›Ќв„‡ЖH0@›Џв‚›ЖH0@›ДвŽ—›ЖH0@›Зв‰ŒГЖH0@›Нв™ЮЖH0@›УвЄ­ЮЖH0@›ЧвŸЂчЖH0@›ЮвЏДЗB›авЖЖЗB›бвКК3З@0@›евХЩ3З@0@›ивНУKЗB0@›лвЫаeЗ:@›нвгз~З8@›рвко–З:@›хвхы–З:@›щвруЎЗ:@›ювэєЫЗ:@›ѓві§щЗ:@›їв щЗ:@›њвџИ:@›ўвИ:@›в #И8@›в!>И:@› в(.>И:@› в#&YИ:@›в09wИ8@›в;A“И:@›вHO“И:@› вCFЏИ:@›'вQ\ЮИ4›(в__чИ4›)в``wЋ *њTRЋ@Ч4*њUUўИ$Ч+њWWЙ@ Ч,њZZ#Й@ Ч-њ[[:ЙH0@Ч2њbj:ЙH0@Ч6њ]`JЙH0@Ч;њls_ЙH0@Ч@њu|uЙH0@ЧDњƒ†uЙH0@ЧGњ~ŠЙH0@ЧKњŠЙH0@ЧNњˆ‹ŸЙH0@ЧSњ— ŸЙH0@ЧVњ’•ВЙH0@Ч\њЂІШЙH0@Чbњ­ЖШЙH0@ЧfњЈЋмЙH0@ЧmњИНѓЙBЧoњПП КBЧpњУУК@0@ЧtњжкК@0@ЧyњЦд,КB0@Ч|њмсAКJЧ}њууYК:@ЧњцщmК8@Ч‚њья€К8@Ч„њёї“К:@Чˆњў“К:@Ч‹њљќЋК:@Чњ ЋК:@Ч’њ УК:@Ч—њ УК:@ЧšњйК:@Ч њ"*ђК:@ЧІњ18ђК:@ЧЊњ,/ Л:@ЧБњ:C#Л8@ЧГњEH6Л8@ЧЕњJNQЛ4ЧЖњQQeЛB џџЗњQQvЛ ѓЗ!@MЋ@ё4З!BB3 1Й"@MƒЛ@ ёК"EE›ЛH0@ёП"LP›ЛH0@ёУ"GJЌЛH0@ёШ"RVТЛH0@ёЭ"X\йЛH0@ёб"cfйЛH0@ёд"^aяЛH0@ёи"mpяЛH0@ёл"hkМH0@ёр"wМH0@ёу"ruМH0@ёщ"…0МH0@ёя"Œ•0МH0@ёѓ"‡ŠEМH0@ёњ"—›eЛBёћ"]М@0@ёџ"ЇЋ]М@0@ё"ŸЅqМB0@ё"­В‡М:@ё"ЕЙœМ8@ё "МПАМ:@ё"ЧЯАМ:@ё"СХФМ:@ё"бинМ:@ё"ксїМ:@ё!"ьіїМ:@ё$"уъН:@ё(" Н:@ё+"јџ)Н:@ё0")Н:@ё3" @Н:@ё9"#ZН8@ё="%.rН:@ёC"5;rН:@ёG"03ŠН:@ёN"=HЅН4ёO"KKКН4ёP"LLЭН P% ђН@4P%UЉ 1T& О@0@X&JО:@Z&€О [A ŠО@4[AjЈ [L‹ЛЋ@!4[LŒŒœО@ ! [P‘ЛО # \P‘‘аО # ]P‘‘фО # ^P‘‘њО # _P‘‘ П@ !`P’’ П@0@!cP”—;ПH0@!eP™œWПH0@!gPžЁpПH0@!iPЃІ‡П@2@!kPЈЊЃП:@!mP­АТП:@!oPВЕоП:@!qPЗКјП@ rP&Р@ sPTР@ tP  …Р@ uP!!ЙР@ vP""эР@ wP## СH0@€P%+KСH0@‰P-3wСH0@P5:ЇСH0@•P<@жСB—PBBТB˜PFF2Т8@œPdj2Т@0@ PQU2Т@0@ЃPIObТB0@ІPW\’Т:@ЈP_aУТ8@ЋPloёТ:@ДPq“У:@НP•КNУ:@УPМгУ:@ЩPељГУ:@ЫPћўьУ:@ЭP"Ф:@ЯPVФ4аP  €О бj,ŠО@K4бj--ƒФ@ Kвj00ЌФ@ Kгj11еФ@ Kдj22Х@ Kеj330Х@ Kжj44_Х@ Kзj55ХH0@Kрj7=ГХH0@Kщj?EкХH0@KяjGLЦH0@KѕjNR/ЦBKїjTT[ЦBKјjXXЦ@0@KќjcgЦ@0@Kџj[aЌЦB0@KjinзЦ:@KjqsЧ8@Kjvy,Ч:@Kj{UЧ:@KjŸФЧ:@KjЦн­Ч:@K%jпкЧ:@K'jШ:@K)j  ?Ш:@K+jnШ4K,j–ШB џџ-j))ИШ i-|О#ŠО@g4-|ТТхЈ 11}О#жШ@ g2}ХХЩ@ g3}ЦЦ,Щ@ g4}ЧЧVЩH0@g=}ЩЯxЩH0@gF}бз›ЩH0@gL}йнТЩH0@gR}пу–ШBgS}ххшЩ@0@gW}яѓшЩ@0@gZ}чэЪB0@g]}ѕњ6Ъ:@g_}§џ^Ъ8@gb}ƒЪ:@gk} ЈЪ:@gt}ЮЪ:@gz}јЪ:@g€}"!Ы @…}i‡.Ы @}Š}Xf0Ј 1Œ~Xf@Ы @‘~JQMЫ @€–~BGЈ 1˜BG_Ы @œ4;mЫ @ƒ ,1эЇ 1Ђ€,1€Ы @…Ј€ќ&ЇЇ 1Ћќ&˜Ы @‡АєљШЅ 1В‚єљЊЫ @‰Ж‚УШœІ 1ИƒУШКЫB џџЙƒССдЫ ŒЙ„КОqЇ 1Л…КОКЫB‹М…НН˜Ы @П…ЯђШЅ 1С†ЯђцЫJ џџТ†22§ЫJ џџУ†00ЬJ џџФ†...ЬJ џџХ†,,EЬJ џџЦ†**_ЬJ џџЧ†((zЬJ џџШ†&&’ЬJ џџЩ†$$ЌЬ ™ЩŽ!•Ѕ 1Ы!’ЬJ˜ЬzЬJ˜Э_ЬJ˜ЮEЬJ˜Я.ЬJ˜аЬJ˜б§ЫJ˜вцЫJ˜г %Ј @џџзUU Ј @џџл??дЇ @џџп))“Ї @џџтЬЬ‚Ї @џџхЪЪЧ @џџц   ›Чѓ!Ki{}~€ƒ…‡‰Œ™  pqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š`lmno" EGIJKLMNOPRSTUVWXYZ[\]^_!23456789:;<=>?@ABCD#$%&'()*+,-./0FHQabcdefghijkœžŸ ЁЂЃЄЅІЇЈЉЊЋЌ­ЎЏАБВГДЕЖЗИЙКЛМНОПРСТУФХЦШЩЪЫЬЭЮЯабвгдежзийклмнопрстуфхцчшщъыьэюяђєѕіїјљњћќ§ўџ     ё 123456789:;<=>?@ABCDEFGHIJ"#()*+,-./0$%&'LMNOPQRSTUVWXYZ[\]^_`abcdehjklmnopqrstuvwxyzg|‚„†ˆ‹Žš›œžŸ Ё˜ќwЂЫUjы;ЂЫЂЫ=sЂЫUjы;ЂЫЌ<‡ђЂЫ{“ЂЫЎэ*ЂЫО{“3єІ<‡ђ3єа№ї Žї Ђ`$ŽEŽQŽпƒЂ`э*ї !ј{[ї !јƒFё‡ђЊƒЂЫЂЫ[ŽvŽЂЫ”Žэ*ї ŽЉŽСŽ[ŽvŽ3єЂЫї жŽэŽї жŽ$ї жŽŽ3є\ЂЫšНЂЫнїї џ&жŽLbжŽxŒї LbжŽxŒї LbжŽxŒї LbжŽxŒз3єb5э‘жŽ‘Н2‘@‘Y‘i‘5‘в‘’ЂЫ=sБtРEl’x’’ЂЫЇ’ЂЫЗ’эŽЂЫx’Uе’№’ЂЫU“’9ЂЫx’;“е’U“ЂЫ†“’ЂЫ “Д“ЂЫЂЫx’Ы“с“ЂЫЇ’ЂЫ2‘†“’Y~”э*5x’’5†“’#”l’#”’l’жŽжŽї Ђ{[жŽгь} 7”ђ:”Ё>”ЭB”F”гOЂЫjэ*ЂЫї J”mѓk””З”ч”•3•5n••Г•”n•З”ч”Ь•”n•З”ч”Ь•”–ч”/–k”•я?”–ч”/–k”•я?ј$[–n–€–Љ–k”й–ф–ј$[–n–€–ь–”З”ч”*—Ц'5—ш№љ3V  . L n tІЧЬх”tЊJtо*нЅ\]Јntuv&&дуЈ™ Зe…~”ŸЕ–ЌІМЅ І B’˜ЇЬЭa Є JЧ5#SЁ( 0 гр-049МŸ*+МЅ 2ШМ<Rw€ёЁщѓћЉ@ЪЮвж 8<@D|‚…††Š’˜ ЅІЉЋЏЕРфчшээјў&*.2rwx{||€ˆŽ–›œŸЁЅЋЖкноууюєюЉjoјŠ † ‘–& + wЈ ‘‚šІЏРЫxœЅЖСw І w! 7аѕў-4CJYi7<Ot|вЗr РŸ(()*+Іr4>€ьЇ %(*ŒŽФЦ@R…€ў"LORUX[cemox}„Ž“—˜šЧЪЬЬЭЮвдееезлнооорьюяяёѓѕ   !"67::=?BDEEFGbegghimoppprvxyyy{ƒ…˜žЂЅЎЏДИЙМў "%'((2477:;>@AAcfilorz|„†•™œЅІЋЏАГхшъю№ёёёѓїљњњњќ   )--0356678IKNNQSVXYYZ[svy|‚ŠŒ”–ŸЅЉЌЕЖЛПРУ§          ! ! " " # + . / / 0 0 1 B F F I L N O O P Q b c f f i k n p q q r s щЇ)*?@iЊуВ xnнѕ2ЁтњrЂGhђЅ$gmzЃЈЎААББИУЧЬвхіŠŒНСгзыŒ•ѕiW$0­мЫлВЇў rg2ЩЭбеймпт7;?CGJNQ{‡ŸЌГЖКЦЮадпх%)-158<?q}•ЂЉЌАМФЦЪелђфЩ7%›Ÿ(()*ЉеCŸ1•л=,2 Ÿ $ ЄІвдdЉ#/4B ЈUЩзVОЦfЮжы$Њ2‡‰Ž“˜š%+027:>FЈЊЏДЙМ37ŸЁІЋАГ;@CEJNRZЏБЖЛРУT Y \ ^ c f j r Є;Ot|вЭЇ   MЈlst‚MЉГКЮдЉАФЪЉ*Њ%74 > P Э#$:;З_`e}~…{|~‘’”œŸВГЕ“”–ЉЊЌЃЄІЙКМЅ Э9 <CgЗ‹,#TUeŸ €  ІƒэЇ4’БЈ@CJ–Њ>?6 8 W X V69жqL]p KQ_w ПІо?ЇŠз?ЉѕїїјikklWYYZ­ЏЏАмоопЫЭЭЮлнноџЉt} ”ž‹•#)›Ѕ< B џтGMPQT[вдіўŠŒ“”жз’?Ыў"LOSUY[cemox}„Ž“—˜šЧЪЬвделноьюя 77::>?BDEcegmopvxyƒ…˜žЂЅЎЏДИЙМџ #%'()3477;;>@ABcfjlprz|„†•™œЅІЋЏАГцшъю№ёїљњ*--1356JKNNRSVXYsvz|€‚ŠŒ”–ŸЅЉЌЕЖЛПРУў       ! , . / C F F J L N O c c f f j k n p q Ш  Ov‚†э|у8 ШЅ7 ЭаѕјІ3uv}}~ЉГљ”•чшя№[\cdIJQRde/0Ÿ ЇЈШЩжзНОХЦЭЮежъы‚ ƒ ’ “ Ї !ˆЈ‘ ЊЂ™Љ€WLLXhQЇЇЉЭ;{)qЊ „Ѕ"œ-0ЌF I zЈ‘‚ІеxœЫњm‰•›ѕiW9­мJЫлz9\ЎСТУзкотыЅЇЉБВГTBПЖЦУЉUбlэ| ЌŸ+ЌІзGYlьІіўЌЉ*GIRUX[СФбеко]_lpuy^`ilorртэёіњnpy|‚јњ   Ќ~L•˜›љћќќў&&*,,2<<>CCFFGHHKRY\ccfflovw||~€‡ŒŽ’“”œœ­ЕџY\bcist‚ЕІк5ЉтQп?еuЉ(ЕЉ IOСЧ`fрхpvј§ѕН’Щбй7?G{‚ŸІЦЫ%-5qx•œМСѕ1ЪЮвжрт !8<@DOQ|‚…†Š ЃІЉртшэ&*.2=?rux{|€–™œŸжиоуžЅ(о @илпучBQb^ю . ž.O57<iФЧЬилпуі!%%17;;AAAPaatzz’š ЅЇЇЉЌНСФФЪагзыѕŒ•хѕ)TVXiBDFW$0­QПСУмLЖИКЫЦШЪло<!зкот.5DKZjяcvQl ЇМKLжьQХк_`еђw x ЇЅ*gІЦШ'Ї8FGVWYfghjlъыяђ^_cfvxLMQTghlnЂЃЇЊМОЫЬжйьюРСХШкмнабеиэюђєѕЇЇўч< IZmь`NiЄЭТвячqXk;№—ќ&CRc]zјlZАпЮоАŸ())*0ЈVYi08ПйЕЯ(A№qрp+ЪЮвжпт  !8<@DNQ| ЃЅптч&*.2<?ruw–™›еин™Љ+]ьUCРЗЧ Yr Кќp^8Дхвт‡ — Y}нcYо"ЉйG5"  утRFGKІТЯЫІт Ј?! ЉDЫЮгжкм 9<ADHK}…†‘™ЁЅЉЊЋЏИППРЧЪвййк'*/269sw{|‡—›Ÿ ЁЅЎЕЕЖНРШЯЯаKЊ-ЗИОУЭщѓўK_hбвюѓєѕіћ GQежмтъ _хцєњ  " ( 0 w дЇ)*”*‚„˜˜š?@DЃЅЙКМ#'(;<@AšœАБГ15STXЊЌРСУJ N k l p Tƒ д ЫCf&?щ4W M o §—‹=˜щ=Ёъ НЇ§ƒ$  =рhmˆ„”:‹–   Ц< FVfъ^LgЂЫРаэ/ ЏЅ./І’oЉ(я=8Nq|>6 W яZ…ИŸ)*+8 ИЅ0QјЅ m+ЧнѕiW­мЫлx$ ШЭЭщ ,FHf‡x*ЫЮгжкм 9<ADHK}€ЁЄЅЧЩЪ'*/269svw—š›НПРјtЉСЅ 67$%**+КРСУФЦЦЧЯаджнщы№єѕѕјЉ)С9 A‚#$%&'()*+,-./012ъЅ$djЗЛСТТУЦЫЫзилпуыэяђђќ&CGRYcl’ЌБВЕjЈ ‹”ЈТш№-\dJRe*ЉмJЦ8М*Њ‰“06ЊД,2ЁЋCIБЛ\ b j пN<j j BGHQVYbhl3&AŸЇАЕQTWЦжпцUXНХЮгehЭеоуъ ƒ  “ s –JiГqJ[n˜œІвіў*ФЦœЇзймш№мЈ,РЧЩбйпј()257?GNl{ŸГЦЮпх #%-5<Zq•ЉМФел\ЊЧвœЊ~ ‚ ˆ Ž ’ ˜ \хЇ)*?@%ЈUхЈСчяј§),[clqIQZ_dŸ ЅЉ,%5Œх9іУє%E[\lŽ•рЁў ІzћK\ow~ŽЇЪЪЮЉXuoЫEMW —  .5DKZj L`x Ё 9ЋЕаЁЋЦ?X Љб?-зЉ[кrі‚ —5wŒ5—­1ŽЄ(HžДA a —EbMOy}‚„Ž“˜šШЫЬЭ !7:?CEFcfgh™žЃЅЏДЙМ#&(47;?Adf•šœІЋАГцщъ*-1467KNSWYZtv ЅЊЌЖЛРУў  C F J M O P c f k o q r —qETeр‘;р—– І…Ў`ЇГ ЇыьэрЇ)?@рпFKXYrzƒЃЈАБЛЦЫвђі%17;APatz…Šš ”™žЃЈ­ВЗЩбйпчя§7?GN[cqv{ŸЦп %-5<IQ_dlq•Мећ/4GLRX^chmrx‡—ŸЇЕМСЧбкуьј %06=]blu~ƒˆ’˜ЂЈЎИЦжцьёљў ",2:E^ciouz„‰™ŸЅЏНХгкрхэіџ #)0;CIQnsy…Š”™ŸЉЏЕПЭеуъђј§    & + 4 < B I T \ b i ‚ ˆ ’ ˜ р5Œрƒ§ўў`н -GMRXСШбк]cluЦEJ^dioрцэіntyјў  ‰ ИУЭ_hЦЮббєіGжцIЁ  " IЇЅL‰6D'@5XN p I€ЫЬЭЭЭЯ ;<z| ЂIю,вЅ+CFXXYY*Цжхх))TVVXXBDDFFQQПССУУЖИИККЦШШЪЪRЊ %2F;EZT ^ r {ЂWgjћІ%&ACFFacffšœФЦазѕј{Ї НСгдлмншщщы;Ј]bdz{†{Љ)ЛЉRliyЛZFK[mou}‰ЈГУвції+Šжнў  \lm”рчяѕ O[ciрш=IQWdжо/‚˜ŸЇ­@DЃКШжму#'<@šБНХЫ15TXЊСЭелъJ N l p ‚ ’ {C\]bblttuvрт !OQрш=?жо{%‚‹šœІЏЛРУЫбемx’œЅБЖЙСЧЫвФŸ*,D Ј89NOqvDЈbbc{‚„DЉTBПЖЦэ‘Xk-ЇPVahdgъэ‚ ƒ ’ “ эЇ*-4эЈХ3!э!‰‹’6ЇgjŸŸ+ŸЉ+пq1;tz™žЃ­ВЗ ћEJ_xИєжц€хюлфЈŸ)Ј ОюмєhWgjёІ qЇЛСдщё9Б~9ouuv‚ƒ†’–—˜ЇЋЏЕИПРЬавзйкъэјќ§ўy|ˆŒŽЁЅЋЎЕЖТЦШЭЯаруюђѓєкŸљm[БрЯпк3 `яНСх)XFQУКЪc уІэяcЈ|‚уЉ`eуь€…љўw|џ‡Œ  cCUV ‚ •Ѕ $&(*,.02=еЅQ^`еІыUЈmtuxz€учшёєџйночъѕјUЉе# ;`~|’Г”ЊЄКеr7еtFHf>ІНС~ІЧЬЬцŒ“ўЇ€79:CFJOПЦЪЪЪгггкккпрј')14888AAAHHHNOl|||ЁЁЁВЧЧЧЭпрф"&&&///666<=Zrrr———ЈНННУежкrtхцщёђѓњћў '*-’”‰‹#%™›4 8 < > >Њ š:=М7:ГNQУf i > Ž7Џ4ІKЖc ОqM^qЧЈЃ‡Љ)˜K\ow~ ЗвѓѕехЇ2UВыђ_fvMThlЃЊМЬйьСШкбиюђљЇ#59KOUVjv‚x‡ЌЖаюn}ЂЌЦф !*Lн?`ѕ8 X x љЈЦ4"љЉ rxщѓў’˜‰™ŸyS\s’јˆюТBВЕПЭайЈЋЕУЦЯ=?@V X Y ДŸ(()**4ІЈЉ4Њ—ИЏПЈ›­ћЊ‡УЭхёњЈЎŸЅЏЕˆBMыэїсуэGI^`hj‡‰СУухчјњќ%(*02]_~€ˆŠЈЊљћ ,.^`uwŸЁртџ ;?CEnp…‡‘ЏБјњ  & ( T X \ ^ fGLео]bpy^cёњns  f4пO XІУдXЇЌ­X ˜?Й;АSРk XAGHH!Ј MOPpv 7 8 9 ŠІ ШЭЭчї,FGfŠЇЪЪЬЭ :Ђ rр Ь ЊВЭ  ЈУ=V “ІШЭЭшŽ“ЇЬL“Љ+l   ќџ*,-BCCFUVXYY]]bcОХЫЫЫвввј&)03999@@@l}}}‘   ыї!'''...Zsss‡–––сэ@EGLLLRRSXXY^^ccchhmmmry‚‡———АСЧЧЧбввкллууьььюѕјј  !%(*0667==>PQZ[]bbclmmuvv~~ƒƒƒˆˆ’˜™ЂЃЈЈЎЎЎИИИпљљћўўџ    "#,,223::;[\^ccciijoopuuzzz„„„‰šŸЅЅЅЏЏЏЮрхцэююіїїџџ   #*1;CIIJQQRklnsssyyz€……ŠŠŠ”””™ ЊЏЕЕЕПППој§§ў            # & & + + , . 1 4 < C J T \ b b c i i j }  ƒ | :_}{‘œВ“ЉЃЙќ,ЫЮгжкм9<ADHK}€…ЁЄЉЊИПЧЩвй'*/269sv{—šŸ ЎЕНПШЯќsашёХЇ "ХH 9 Eр^c~ƒuz…ŠЎЈž$ Dџџд Dџџ’ тї&’@4ууэ‘ “Џц @4””: @џџ2 9’@0@—šV’@2@œžt’H2@ Ѓˆ’4ЎЎœ’@0@ цщЕ’@2@ ыэ ’  Ъп&’@ 4 ЫЫЯ’@0@ Юб№’@2@ гећ‘ ВЧ&’@4ГГ“@0@ЖЙ1“@2@ЛНр‘ {Q“@4||Љ‘ 0ц @4b“@0@{“@2@•“H2@!$Ї“4//Й“@0@"‚д“@2@$„†г‘ $"cxQ“@4$"dd№“@0@'"gj ”@2@)"lnТ‘ )%K`Q“@#4)%LL'”@0@#,%ORJ”@2@#.%TVЕ‘ .(3HQ“@'4.(44n”@0@'1(7:‰”@2@'3(<> @џџ4(     #' !"$%&()*ЂЫї}~ЂЫј$Y~ЂЫї}~ЂЫЂЫї}~ЂЫЂЫї}~ЂЫЂЫї}~ЂЫј$Y~ЂЫї}~ЂЫЂЫї}~ЂЫЂЫї}~ЂЫЂЫї}~ЂЫЂЫ)w чqў Зr”р‘{„р!(7<BOTZglr„Š—œ ЇЖЛСЮгйцыё@R /7Og—ЎЖЮцЉ‘ 48LPdh|€љЩq *D\tŒЉУлѓЉ 78OPgh€—˜ЖЗЮЯцчТ‘KOT j *6 :В  (BZrŠЇСйёг‘cglўћ‘ВЖЛл=cC#/˜ЂЎ ”+sќSsќ| Е‘37<э‘ “—œГЗЫЯучЭ# E ! еt#Ђf4 &@XpˆЅПзяV6я=пq !<Tl„œ Лгы˜aё9 ’ЪЮг’тцы*p Dџџѕ Dџџ s  Dџџ!!м  Mfц @4MM   VЦ: @џџ2 : @џџ2Thѕ @ООѕ @ННѕ @ ММѕ @ ЛЛ @ПП @РР6HССF4ФФY4ХХn@0@UXn@0@PSƒ@2@Z\Щ  JJЛ  2Gц @422™@0@ 59Ж@2@";=h $ааJ  %ЪЪѕ  @џџ&JJфQ D;'ШШфQ D;(ШШфQ D;)ШШфQ D;*ШШфQ D;+ШШфQ D;,ШШ  @џџ0NN @џџ1k @џџ2      !ЂЫцљ§љЂЫњ‡ђ+њЂЫњGњЂЫ^њцљ§љЂЫј$ј$‡ђЂЫЂЫoњ0+ЂЫј$ЂЫ„њ0+ЂЫ5Ћњј$гњуњїњћћ)ћ6ћіћSћЂЫ`)3Ї Pgаим.p;Ш;YЬySKa}— A [_fm{‚ˆ•œЃЕk} BC [dfhms{}€‚ƒƒˆŒŒ•—šœžЃЇЇАЕЖФ птІ#ЦЭf4?^O d€šџ'*->Pe›БklMяEOSPQпq щяєў!6;PUZ_x А/ ]_ahqs?  vx{}ƒŒŽ’•—žЇИ$˜шьи!MPH8NNQh9кшB ˜Ш h Юа.СMajQ8NNQQё9TCopjŠL :hъ*J ЪзиппсŠ пГ$ѓЬC8NNQQrSrш5J !VZ]qvvŽŽЋЛМНООППРЪезкмшяяєєњ27MQVЃ су *4|b~˜ЎќqкЌ~ъ№№ііЌм MPUZХ$:<>Vе#c™Џѕ J%  [otxxy’’“­Х5  adh}€ƒ—šžE ГСўоMPŽ E>SMNžО&wlз246w! &*wnз  рZ]qvŽЋГЛМНОПРСшяєњў 5;APUZ`@$MP NQhƒЩq CbI€я№єіЉ шъ57PQЩ JVђ3к’CMMR ЭЮВ  A`Л MЛKMa}—{ истЛ 25;­$Э#bce~˜™›ЎЏБkэ $– EFMИ DџџX @џџJJE @џџHH5 @џџCCШ@џџ BB& @џџ AAž@џџ@@ю@џџ<<ъ@џџ::О@џџ99ж @џџ66Т@џџ44з @џџ%%R @џџ$$Ќ @џџ##? @џџ""7 @џџ5 іИіП\ліліяіП\її!їП\‡ђ?їVїyїї ї ЅїЙкЙкЙкЙкЂЫ)wZз%*7!5>FJ @BHPQUVjъ:R$)BBCQТ46<“0VVЋ1 < @BHUV|Ќ#(5^<}/ <5 CE Hm PQЖ Ж-TЦUVVOž@PUО9f.UUж6HHю<& Aџ 9:<@ABCHJPQZ?"'@@APШBQVX JС<<a Yд9И DџџЗy @@џџцјћ  @@џџФЬw @џџСС‡ @џџ ГГo @џџББZ @џџААK @џџЏЏB @џџЎЎ9 @џџ­­0 @џџЌЌ~ @џџЋЋ" @џџ"ЊЊ @џџ%ЉЉќ @џџ'ЈЈox@џџ*  Mx@џџ.ŸŸл @џџ1””И @џџ3Œ @џџ4HHt  @џџ5AAY  @џџ5=AЕ @06>>Ш @07??й @08@@'  @џџ9ўў  @џџ:ррЃy @џџ<ввх  @џџ=ККЩ  @џџ>ЗЗЌ  @џџ?ЖƘ  @џџ@ЕЕЦ  @џџA’’­  @џџDOOЄ  @џџFNNG  @џџGBB<  @џџH::1  @џџI99%  @џџJ88  @џџK77  @џџL66  @џџM55љ  @џџN44ю  @џџO33љv @џџQ..Х  @џџR((Й  @џџSї Ђa{[Ђ!ј,ј ЮAјђO3єcјqјЬч‡ђј—ј‡ђІјэ*‡ђ‡ђ‡ђЂa` ЮЙј]йШјэ*‡ђжјэ*3є3єЂa{[ЂЂaRc ЮžLчјd‡ђ‹ђџјРђ3є‡ђљЂЫљЪЬgђ„љ‹љ&э’љ˜љ)м+мАљ)мЂЫ} АЩТљЧљЬљбљжљq0!lЃЫлљЂЫ‘G <B‡ ГPНPHJ гйљv-.С9~uuŸŸЙ љ 49 ­y БТ/ФB~suvwz{|}Ÿ ЌцщыыьяB Ў+r.k @Уфд Фt AАє ЇлўT Џ= rtuvxyz{|}ŸS€˜ЂЯ}yl}=аOO&вдиклм swццЙЦ ’Octдмoxœ  6 Љo БИЇ8 ЋИ ˜ ЕкС!rrtuvvxxyyyzz{{{|||}}}}”ŸŸ ЇЉЊЌЌЏa!rta! rtuvxyz{|}!xdu 5J uvz{|} jŠW?ŠxNNOOъxNfwJ~xyz{|}ГзpqS  | 7< :ќ Јœ ЅСХ &(% 8х  КМОСЩдклмы.ч”Љю 3. Ž wї%w!ц7xevЗymц7 €6ёє`  )~rrЩ ЗдмэI   i 2ЊЋђCy|}в &Л$?rrtuvvxxyyyzz{{{|||}}}}Ÿ ЇЈЉЊЋЌБББ{Cvv{{}}л}j{л ”ћ Фдлмd.Ф#гф (Є Nd А..rtuvxyz{|}Ÿ ЇЈЌ­ЎэГM! rstuvwxyz{|}цэ!ttvvxxyyzz{{||}}ЇЇЌЭ#гйMx›Ÿ­ OЖ– ЊЋжBS€˜Ђа– JKv џJrstuvwxyz{|}”Ÿ ЈЉЊЋЌ­ЎЏАБГ _ А_xbsя Бп ЗшBTUVWXYZ[\]^_`™šw.Hyk| ФШшьэђЈ ‘А1AќќC‚ƒ„…†‡ˆ‰Š‹ŒЃЄБxiz1 9š–~rrZ А#УфЃyвзиc >У Жƒ ŒxOgxЌ~ФЦШЩЩЫŒ HKЌ Жлђyhy~ HJЋ' ў0 ЌYЛGY = рт" Њ СФЫ:СФ xarK Џ# DџџЙu *+: @џџ2 <@R  ()Сu @ &е 1 &мuJ џџ v  v 1 v@ fv Йм †v@ 4ЙррЗr 1Км Ђv@ КууШv@ Кффёv@ Кххw@ КццDw@ Кччkw@ Кшшœw@ КщщУw@ Къъыw@ Кыыx@ КььCx@  Кээjx@ !Кюю•x@ "КяяЦx@ #К№№ђx@ $Кєєy@ %КѕѕLy@ &Књњ~y@ 'КћћЖy@0@ +КQ^Жy@0@ /КBOЖy@0@"4ʘ™Жy 16˘™Жy@0@$:Л‘Жy 1<М‘Жy@0@ AМ‰ŽЖy@0@ EМ‚‡Жy@0@ IМ{€Жy@0@ LМtyЖy@0@ QМmrЖy@0@ UМfkЖy@0@ [М^dЖy@0@ `МV\Жy@0@ cМOTЖy@0@ fМIMЖy@0@ hМ#'фy@0@1mМ*@z 1oН*@фy@0@3tН(z 1vО(фy@0@5{Оz 1}ПAz@0@ П`cpz@ €Пeez@ ПffЭzJ ‚Пhhѓz@0@ …Пtwѓz@0@ ˆПorѓz@0@ ‹Пjm{@0@ ŽПƒ†{@0@ ‘П~{@0@ ”Пy|L{@0@ ˜ПлоL{@0@ œПжйt{@0@C ПФШL{ 1ЂРФШL{@0@ ІРЖТL{@0@ ЉРБДL{@0@ ­РЁЏL{@0@ ВРŸL{@0@ ЕРˆ‹Ё{@0@JКРадЯ{ 1МСадЁ{@0@LССЪЮЯ{ 1УТЪЮј{@0@ ЧТ.1ј{@0@ ЫТ), |@0@PЯТј{ 1бУј{@0@ еУ ј{@0@ иУј{@0@ мУјј{@0@ сУхіј{@0@ фУруM|@0@WщУ#'{| 1ыФ#'M|@0@Y№Ф!{| 1ђХ!Є|@0@ їХЊ­Є|@0@ ќХЅЈЬ|@0@]Х‘•Є| 1Ц‘•Є|@0@ Ц‹Є|@0@  Ц„‰Є|@0@ Ц‚Є|@0@ Цm}Є|@0@ ЦhkЄ|@0@ ЦSfЄ|@0@ #Ц8QЄ|@0@ 'Ц36љ|@0@g-ЦžЃ'} 1/ЧžЃљ|@0@i5Ч—œ'} 17Ш—œP}@0@ ;ШЧЬP}@0@ >ШРХP}@0@ BШЏОw}@0@ DШЮбž}@0@ JШ–ž}@0@ PШ‚‹Ч}@0@qVШjpž} 1XЩjpž}@0@ ^Щchž}@0@ cЩ]až}@0@ iЩV[ž}@0@ nЩPTž}@0@ tЩ6Nž}@0@ yЩ14ž}@0@ Щ/ž}@0@ †Щиž}@0@ ‹Щгжѕ}@0@|’Щy€$~ 1”Ъy€ѕ}@0@~›Ъrw$~ 1ЫrwN~H0@ ŸЫ N~@0@ Ёۘ›u~H0@ ЃЫЇЊu~@0@ ЅЫЂЅš~H0@ ЇЫБДš~@0@ ЉЫЌЏТ~H0@ ЋЫЛОТ~@0@ ­ЫЖЙш~H0@ АЫЧЬш~@0@ ГЫРХ H0@ ЖЫфі @0@ ЙЫат9@0@ МЫ(+dH0@ ОЫ-0‹H0@ РЫ25БH0@ ТЫ7:йH0@ ФЫ<?џH0@ ЦЫAE)€@0@ ЪЫLR)€@0@ ЭЫGJQ€H0@ ЯЫTW{€@0@ вЫYaЄ€H0@ дЫcfЫ€H0@ йЫhnё€H0@ пЫpz@0@ тЫ|’@H0@ цЫГЖ@H0@ ъЫЎБ@H0@ яЫ™Ќ@H0@ ѓЫ”—fH0@ їЫзкfH0@ ћЫвеfH0@ ЫНаfH0@ ЫИЛH0@ ЫіљH0@  ЫёєH0@ ЫтяH0@ ЫмрМH0@ ЫМH0@ ЫМH0@ "ЫМH0@ &ЫћџъH0@ *Ы69ъH0@ .Ы04ъH0@ 3Ы".ъH0@ 7Ы ‚H0@ ;ЫUX‚H0@ ?ЫOS‚H0@ DЫAM‚H0@ HЫ;?O‚H0@ LЫZ]w‚H0@ RЫŒw‚H0@ WЫz}w‚H0@ ZЫuxw‚H0@ aЫjsw‚H0@ fЫdhw‚H0@ iЫ_b ‚H0@ kЫŽ‘Я‚@  kЬ“–ƒ €Й lЬ––ƒ(  lЭ™žKƒ €Л mЭžžeƒ8@ rЭ Іƒ8@ vЭЈФЗƒ8@ yЭЦЩнƒ8@ }ЭЫи„8@ €Экс-„8@ „ЭучT„8@ ˆЭщї{„(  ˆЯљ§Ђ„@0Ф‰ЯћћЯ„@0ФŠЯќќќ„8 ‹Яљњ!…8@ Я!…8@ ЯџI…8 Я  r…8 ‘Я  š… г‘гЪйВ…@Ь4‘гЭЭSs ‘зОЧФ…@Ю4‘зППй…BЮ“зТТэ…BЮ•зФФ†BЮ—зЦЦ`s 1šиЪй†(Ь›иаб7†8@Ьžигж\†8ЬŸиии|† @иЃиВЛ5 1ЇйВЛ† лЇя2АФ†@й4Їя661s 1Ћ№2Аі†@ йЌ№99#‡@ й­№::S‡@ йЎ№<<‡@ йЏ№==Р‡@ йА№>>ј‡@ йБ№??(ˆ@ йВ№@@Zˆ@0@йЖ№ILZˆ@0@йИ№BD“ˆH0@йК№loЦˆH0@йМ№qtњˆ@0@йП№|њˆ@0@йС№vz.‰@0@йФ№‰Ž.‰@0@йЦ№ƒ‡b‰@0@йЩ№”–‰H0@йЬ№–šЩ‰@0@йЯ№œŸ§‰H0@йв№ЇЊ§‰H0@йе№ЁЅ0ŠH0@йи№ЌЏ|† @ђм№&/5 1рё&/dŠ ѕр$‘Š@ѓ4рФr 1ф$ ‹@ ѓх""S‹@ ѓц##‹‹@ ѓч%%Ы‹@ ѓш&&Œ@ ѓщ''BŒ@ ѓъ((xŒ@ ѓы))АŒ@ ѓь,,љŒ@0@ѓ№EMљŒ@0@ѓђ=@>H0@ѓєezwH0@ѓі|Б@0@ѓљŒ‘Б@0@ѓћŠы@0@ѓўžЃы@0@ѓ“œ%Ž@0@ѓЅА_ŽH0@ѓВƘŽ@0@ѓ ИЛвŽH0@ѓ УавŽH0@ѓНС H0@ѓвеEH0@ѓзфH0@ѓцщЙH0@ѓыјђH0@ѓњ§+H0@ѓ!џeH0@ѓ$ŸH0@ѓ' еB0@ѓ) ‘B0@ѓ+=‘B0@ѓ-!t‘@0ѓ.##’s @џџ0ђђBs @џџ2GGьr @џџ4CC‡r @џџ5qr @џџ6  @џџ7 Югилђѕ    "$%&'()*+,-./1356789:;<=>?@ACDEFGHJLMNPQRSTUWYZ[]^_`abcdegijklmnoqrstuvwxyz|~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ЁЂЃЄЅІЇЈЉЊЋЌ­ЎЏАБВГДЕЖЗИЙЛНОПРСТУФЧШЩЪЫ !#024BIKOVX\fhp{}КМХЦЭдежЯабвЬзкмнопрстуфхцчшщъыьэюя№йёєіїјљњћќ§ўџ     ѓ~KЮKї L>LnLЂЫ=sБtРEЦLMЂЫ=sБt+M8MЂЫ=sLsSMsMžMРMьM#N`NNХNO0OaO˜OШOP=PoPЇPЭPЂЫљP9QxQЂЫрQR]RЂЫзRтRьR(SЂЫiSЂЫзRтRvSЂЫiSЂЫ‚SЖьRНSЂЫ‚SЖ3TЂЫtTьR†TЂЫtTК€ЂЫtT‚SьRЬTЂЫtT‚SJUЂЫ“UаU‚SьR VЂЫ“UаUпV!WЂЫ“UСWЂЫьRёWЂЫї зRтRЙ#(XЂЫiSї зRтR $OXЂЫiSї tXX‡XžXЂЫiSЂЫфwТXѓX$YЖШ$YtTК€$Y“UСW$YЖШ$YtTК€$Y“UСWUY}YДYxQUYъY Z]RUYзRтRvSЂЫiSUYUZЖ3TUYtTК€UYtTUZJUUY‡ZЛZUZ!WUY‡ZСWUYзRтR $OXЂЫiSUYtXX‡XžXЂЫiSUY}YДYxQUYъY Z]RUYзRтRvSЂЫiSUYUZЖ3TUYtTК€UYtTьZJUUY‡ZЛZUZ!WUY‡ZСWUYзRтR $OXЂЫiSUYtXX‡XžXЂЫiSї [}YДYM[ї [ъY Zт[ї [зRтR‰\ЂЫiSї [UZЖТ\0][ЖZ]0][]UYП]UZЖя]UYП]tTh^UYП]tTUZБ^UYП]‡ZЛZUZ2_UYП]‡Z `ї [зRтR $r`ЂЫiSї [tXX‡XФ`ЂЫiS0]aFava0][]UYвab?bї UYaFaБbщb cUYaFaтcdOdUYaFa#e/e:eЂЫiSUYaFaUZЖ eUYaFatT;fUYaFatTUZІfUYaFa‡ZIgUYП]гgUZЖhUYП]гgtTГhUYП]гgtTUZ4iUYП]гg‡ZЛZUZэiUYП]гg‡Z§jUYaFa#e/e $kЂЫiSUYaFatXX‡XlЂЫiSšl0]šl0]ЪlmЪlm4mП]emŸmП]emЪmnem=nnemї ЖШJJqnqnqnї œnЖ3Tї œnemqnї аnem5qnoUZвaoqnooUZвaХoї xpІpqnЖвaаpqntTвaJUqntTП]UZqqn‡Zвa’qqnЖњqаpqntTњqJUqntTП]UZqqn‡Zњq’qqnЖвaаpqntTвaJUqntTП]UZqqn‡Zвa’qqnЖњqаpqntTњqJUqntTП]UZqqn‡Zњq’qqnЖвaаpqntTвaJUqntTП]UZqqn‡Zвa’qqnЖњqаpqntTњqJUqntTП]UZqqn‡Zњq’q1rвab?b‡ђП]гgtTUZ4i‡ђП]гgtTГh‡ђtTК€‡ђП]гg‡ZЛZUZэi‡ђП]гg‡Z§j‡ђ‡ZСWWrьwьwї П]UZЖя]ї œn‡r?bї œnem5œnКrЭr5tTК€qn sAsxQї us‰sСst tJ qnqnї ї ї ЂЫ•sРE;tЂЫhtžtЮtэtudu–uЂЫ=sБtРEЂЫ=sБtРE=PoP˜:š v-vFvЂЫavŸvФvЂЫўv9wrw‡ђжЈwrw‡ђжЈwЈwрw&xrwрw&xЈwрw&xJx‹xвxrwрw&xўvрw&xyAy’yЪyЂЫ=sБtРEЂЫ=sБtРEoPLz˜:š vzz™zЂЫКzŸvўzЂЫ>{{О{‡ђжњ{О{‡ђжњ{њ{8|&xО{8|&xњ{8|&x„|Ы|вxО{8|&x>{8|&x5Ы|вx5Ы|вx5Ы|вx5Ы|вx5Ы|вx5Ы|вxї }вxї ї ї V}Œ}˜}›}ˆZЎ}ˆZЧ}АЩЂЫк‡iG,‡rІ­ЕОЧЯирш№ј t&SWВКhŠ•ЅИт 5@[rАет=ЋИЯвзюќ -<LPUZgGtЃњVкP€Ž ЂДЕПР~€‹˜™ЃЄа‚Ъб9ysчшЙu+ТBђћТ‚ šЋђџLbю+xПђ2IXBsGOVФЫšЄt-09<BtœЌПѓNczЛ,K_УЦжі‚u›Њ+sТ–ІЙ A\sу>Яєarƒ•ЇЩнёє )eв@@lnЌэюРаўДe!GЂ.ETB7‚†‰№ѕј§tvƒ…ЖОЫЭ  ny„‡‹Ž˜›7Jdgtv(*LQГЕзйіј68UW ЃЅr&’шъ;=лп<–Кпў>an?@Or CCPP\\GGOOVVm ЃЄЅІІшщ()OtОyJ %<a=Ёsђђ!tfŽat гин&+0ЂЇЌгеи136PRVY]_cfkv~‚ˆ“ЪЮ :<‡"#&&)*,269:=ВЕЖИмруфєѕјfmt{‚‰Язрш№ј#;ot~ƒЁБЖЭј  Thn„‹›17V]dv(-2ILip™ЃЎГЕНХвзйтшщёіј"()068AFOUWuz€•–›œž АШк№ћќџ"#„†‹’”˜›ŸЂЂЅЇЇЊЌЌРТ2>ЉАИСЪвлуыѓћ 0GVещгmГЗSsОЭ‘–ІЙщ <AZ\qsГму:>УЪuo„Яu‹Œ| Мќ lo{}ƒ…‰Ž”ќs%&4@LRZbipw~…Œ”œЊБЙТЫгмфьєќ%=L[bЙРгщМtРЧ…sъьЎm0:JQYnx…’ЇЉфх$.:JPX`gnu|ƒŠ’šЇЎЖПШайсщёљ CRC~ГЗѓюmACЋЎЮЎuфцw@З‚Зr-#пу#-9IOV^fmt{‚‰‘™І­ЕНЦЯзрш№ј BQ`"#(*35ЗtЖЛ@R)€Z‘••™ ""#+26::;BIMNNQX\]]ХЧЧбгжилн$&)+.0’””ŸЂЅЇЊЌЧЩЪPSSVZZ]``cggknsvz~‚††ˆˆ‘‘““@u"0368Љ9ТФЦ)mбitггиинн&+0аЂЇЎГ*20<ђ3ТФЦrs диPЎC~~ГЗѓВuщь2aлr#JJJVVVjkluu††˜ЋЋЌ spJVlu†Ћ•••˜ššЅЅЅЉЋЋИМО;@CFY[^apruxВДЕЙКлнотхцч &9;<=?EЄЉТЩзоыђ9>NQ[]etvwˆ‰‰‰ЁЁТТУЦЦцш&(EGGapqwƒ…†Шбддн лs!лt2ЄsћБГЛНЄuЬвЭ# >?Э6 GSt…—ЉЫпѓЭ9О/01235 €ьЅЋЌЎВЕИКНРвд+.’–™œžЁЄЌЎЗК358;EEFFHHILLSWY``aabbhjmpwwxxy†‡ˆŽЏВДЕИИИЙгеилнохььэююѓѓѕѕіјњњћќќџ      ##$))*++1369;<?BBCHHIJРТФЧЩЫазосфыђѕ!jmqtvwx”–šžЁЁЄЎАГЕИКОТТЦЦвдзйнпуцщёѓіјќў#&)1368<>BGGPRUWZ\dgjrz|ƒ…†ˆ ЃЅЭs--99 uˆ‰V6Ф‘щ<ZqГм:УЪuo„жq&>К6m(ъьBBжж))ЅЅƒƒЖmСццVW^^fm‚‰ЕНОЦЦЯз№ј#5;h…ŽŽ’ЁЈЖЛЭццъяј  3899=ST]hmnt†‹›ЏАКТЩггийййпхц %11677?DWdvРЧаф7<ACGLTY]ijjppqqˆ‹””™šš ЎЎГГИИНООввззмнтууёёііћќ"##0166;<ABBOPUUZZddjkllzz€€ˆ  ЈЈЊЦЫуъ  –tКЛцчшGILNOQЈЊЌЕЦШЫЮабвддезъёђіП4/BhЦкю F^+GЄгчŸ,.ИК_7f?D‘•™ ",26:BIMNQX\]ХЧбгжилн$&)+.0’”ŸЂЅЇЊЌЧЪPSVZ]`cgknsvz~‚†ˆ‘“sщыŸt:гейнотхцэёіћџ      "$&&(*137;<=?ACEEGIdgkrz|€…†‰‰Š‹ПtўuИКНвдзй€q"ŒŽ“ž ЅВДИНПУзцыњџ 9v|~ƒ‰‹–˜œЁЃуOV^­ЕНЦjjotyy~ƒˆˆЁБЖХЫбжлррххј $).3389ShmЏггий16PPV]cksz}‚|”Имћ;Z\_ekhЇЩ_adgjruwz|ˆш,Ј(GOVєњ„„‹’˜ŸЅЊРРЧЧЧPPVV]]cckksszz‚‚˜ЂШmѓˆt†ТЩЪSSZZ``gg††ˆˆ‘‘““уё9Б%<1њњћЌЎЖИqr Єќ1s 59BIPXЕЖИєњ)у"7oкюƒф C…††—˜ЉЋЋЌGEQIPПcnйэ #KУ&=№№ЃsCP\ѕћQQлл..ЊЊŽŽЇуф#sЧля Ѓtхэіћ  $*?CI ЁЄЅІcuZЌ~†EIJJLQUVVX^`IJPQXYfjmqtx{Ядзнрхшэoq~€ЁЃЄЋБГГјњћџTVXbhjj+133VZ]`™œЅЇЎААНРШЩвддтхъёѓѓ"%*033ADHORRuwwz||€‚ˆАГЗПССкмнн№№ђѓќŒmp ‚U"#')*,369:ГЕЖИнуєѕјešЋГђџEHL`bjwИьюѓѕњќ  #)+3BHxЅЇАШЩдъѓ*3HRw|ˆЃЅПШђ "#ь(0EQ^|#??IPX_cqщы,ьrCP\ŸЉlsбггихŒsэю t+V[^cЕКНУЦЬŽ’›цшъяяђ9;=IIIMйлпяєј§џ  lnpqrе# U(S[cjqx†ВКУЬднхэѕ§N]lqvртхјћ  ).ЃЅШе|"%5t˜ЉМ№§C^uш&E^Ыеt-4Оq'?ЛМž2>ЉАИСЪвлуыѓћ 0GVещўt…љ'6ЇtnszчtT0mб0t.’“”˜œЈЉЌЛМПъыья№ђѓјћ§џ=>?CN]^ctuzпрс%&,DEKCDDАtЌБ№tY[[^-(*35t7YYtЧЫбu ЃЅІІЇЈХЧШЩЪЫщщщъы  )))*+FGHIJ"hт6u†˜ЊођтRbШ A HITUt…—ЉЫпѓЫt(”pxд‚ (+/01246Tƒ9"#'()()*,469:>?@ДЕЖИЫахцчщъэя№єѕјI_m{‰™ІЧзшј f!"#д sœРх%D‚м”uЈОПУ§6:њћnгдIJ_`mn{|‰Š™šІЇЧШзйшщјљ  x loo{}ƒ…‰‰Ž””јtcxu•вюђѕћС9§!GЂЮњ-С,Сб$ {t358SWhjm„‡‹Ž’›ЅЊ*j Гj37Адѓ3Rw|j*6 ЦjuŽЊuуццГq$<ДИГ‚šЋђџEHL`bwИьюѓѕњќ  #)+BHxПђ3Ы™tГrоруфst$3uћў\"%м027_afœu ЊЋЌ­ЏГЕЗПТЅ ”–™ЅЎАГЕъј*HхЧ79fhххr49?JJLVVX`ijjkluuy††ˆ˜˜šЋЋЌЌЎЯЯууїї#chђš›ЄЋђђћџEFHILMX`abwxИИФЫьэюяѓєѕіњћќ§     #$)*+BCHIšŸЄЉФЫсѕ!/x–ЄЈКХЪЫпшщыў  ()+>FIJarˆЃЅПШннџ%uмптёѓіЮ''ЅВИНУв+>>–œЁЇЌЗчшŽt”˜ŸŽuЈб—5h—Eimpsx—q!9ВЖ9‘‘˜™™   *+,ФХХЪЫЫабб#$$‘’’—˜˜žŸŸjllrtty{{рШ=EQ^e|Œ“žЅВИНУвзцыњџ BIPXlqv|ƒ‰–œЁЇЌЕг#-9IOV^fmt{‚‰‘™І­ЕНЦЯзрш№ј +BQ`joty~ƒˆЁБЖХЫбжлрхј $).38Shm„‹’˜ŸЅЊЏРЧЮги16PV]cksz‚˜ЂЇЌБЖЛРЧафў(-27<AGLTYcip|”™ЎГИНвзмтёіћ"06;AOUZ_djuzŽ ЈЦЫкщџ`•Ч”o`sЬгрф12рtGILI5+/ON^ЮќI€tУЧЫЯзлпуцшыяѓїњќџ  ЇЉOPSV[^c­ЎВЕКНУЦЬjly{ˆŠ’›ртхшъюђ359;=GMгейлпъяPS}~|~‚††‰‰ŒŒ”––ИККмппћўў;>>_aaegknpqr#%Щ‚EH`wИьѓѕњќ  #)BH u …†††С№ђ§Rm)яяЧфsEHJJJKQTVVVWIJPQ’sђцt#;{€…ˆŠЁЄБГЖХЭжлQRu;>AORUWЛ{CЧW[^cfjmq‚†‰ОУЦЬЯдзн№ѕј§567Ž“”••˜˜›ЁЄЅЅЉЉЋЖИММОЫЭцыь   9>?@CCEEIJMTX[^^``bnruuwwy‹Ž˜›АДЕЖИЙКТУФЩЪЫйрстцььяёєѕѕњњ§    "##&&())+7=ABBEEGHHJWZdgtvjmmqvwxyšЁЄЇОСУЦЦЩуцъ#*BHZ\lpqr€‰‰Š‹ ЂЅ{ˆŠŠЛsў;t.šЋђџEHL`bwИьюѓѕњќ  #)+BHV[‹ŒŒŒ­ЎЎЏЏТаюѓѕ {t&+0†ˆТЩаSZ`g†ˆ‘“˜ИН%Waijklrtuuƒ…††•—˜ЇЉЋЋЌЩЫЫЫнпппёѓѓѓ   „m•+Фr "=EQ^)*,6:ѕјu…†э!]_mt яяЏРУЧЪа†‘O Dџџ$ Dџџr Dџџ5 Dџџ n @эђїm 1 эђ: @џџ2  ѓ n @фыїm 1фы n @ нтїm 1нт%n Кк1n@ ННFn@ ОО_n@ ПП~n@ РРšn@ ТЦКn 1!ТЦвn@ "ХХљn@0@%абљn 1'абљn@0@ *ЬЮљn@0@ ,ШЪo@0@/ей8o 11ейTo @5ВЗ› 18ВЗlo @<ЋА_ 1? ЋА)‡ ?6XЈ„o@4?6ZZд‚ 1A7XЈžo@ B7]]Жo@ C7^^бo@ D7__щo@ E7``p@ F7aa!p@ G7bbAp@ H7dd[p@ I7ee{p@ )I8gkšp 1K9gkБp@ (L9jjзpH0@O9ruзpH0@R9mpяp@0@.U9€яp 1W:€яp@0@Z:{}яp@0@\:wy q@0@2_:„ˆ,q 1a;„ˆGq@0@e;Šbq@0@i;”—bq@0@l;’{q@0@p;™œ•q@0@s;žЁ­qH0@u;ЃЇЦq :v<QUЦq 1x=QUиq@ 9y=TTџq =y>JNžm 1{?JNr@ <|?MM5r @?DF5r @‚??A@r @B…?8<•m 1‡@8<Nr @D‹@/5„m 1ŽA/5br @F’A",zm 1”B",mm @џџ—Bbm @џџšBDm @џџBm @џџ Bm @џџЁB m @џџЂBm @џџЃBh @џџЄB  :=?@BDF    !"#$%&')+,./02345678*(-1;9><ACEї ф)pE{E^‡EЂЫ•sРEї ф)pE{EтаEЂЫ•sРEї ф)pE{E FЂЫ•sРE&Fї -FIFkFЂЫб…FЂЫЂFСFЂЫбЂЫуFџFЂЫGЂFСFЂЫб5уFЂF4GЂЫ•sб5уFЂF4GЂЫ•sбЂЫ•ssG”GУGщGH;H3є•=ЂЫб…FgH…HЊHтHњHIЂЫЂFСFЂЫбЂЫуFџFЂЫGЂFСFЂЫбї KIhI‚IтHТIУ<уIтHТIэ*ї KIйJї KII3є@JЂЫ•s(СЂЫ•s(Сї Жђї FёЦ(ї LJVJЂЫ•sї _JiJyJЂЫз*ф*В=”В=JЂЫ•sІJйJлJнJйJлJKйJлJGKйJлJ3є•=ЂЫЂЫEm##+139?D_`ab”ОП'm№q(а‚("##'++89;JMQRTXZ]{…™ЅЋ­ВДНОПРЬжнппфццэяя0mjХ Yчm)mhУтR14mort™›RmbrbmЛ A({C #%&'+‘”–ЅІІ сф!д‚Yjw{{€€……­­ДДКХШЬЬббжжTƒопхцюяє`mDm„m1›Э# іјЭ9К memm:(Ц/146marПЖmdŠ”цmžъnпсцъяјљпq w{€Ѓ­ДШЬб?пссцщяПm34hXgj€„…Ќ­ГДТХабежШmŠa ѕё9 j :ѓЪ01zm#‘У MT^^_`abРm#'dЃЅЅгm”–| Ќ~ 139;ŠŒ™›ž м (ь _mŠ‘”™žОмm™е#u№%m•m9?D ЮežmKRZ]Ўm]^юmЃw љїmпсця@r;€пссцщщъяРmmr$ DџџAџџ_`,Aџџ\]<Aџџ YZKAџџVW<AџџQRAџџOO @AџџJL< @AџџEH, @Aџџ">@K @Aџџ&9<ь )/0: @џџ2)1x *++т *')Т +""фQ Dџџ;,ffЮ Dџџ-UU Dџџ.DDќ Dџџ/88Г @џџ0  ї ЂЋќТќї ЂЋќТќЂ`ЋќфќЂ`ЋќфќЂ`э*ї Ђ{[ї ЂЂ §Ђ3є§+§ї ЂЂ §Ђ3є§+§C§C§П\T§ЙкC§ЂЫЂЫЂЫЂЫ"wmg/w!459>EJOQVY\_x+И5QшB aiё9CjЙej :1Т "//fт'+VY\_CDЛ59EQVYГ9;EG| м 5Rь/ќ78= VYэ!55QQVVYYЭ# l%>5R:5RVY\_fŽreЮ&TUlmпq 049>EJOWZ]`@ Dџџ† Dџџьr DџџЭ5@џџ€ € Њ @ F L œ 1F L &: @џџ2˜ N Ы @> D Œ 1> D ю @  6 < œ 1#6 <  @ (. 4 Œ 1+. 4 *  @1 , { 15 , N  @;  h 1?  t  @Dћ { 1Gћ ”  @Lъ љ h 1Oъ љ Ж  @Tт ш Y 1Xт ш з  @]к р H 1aк р њ  @fв и 1 1iв и "! @nЪ а  1qЪ а L! @vТ Ш  1yТ Ш h! @ ~К Р њ 1 К Р †! @"† В И ф 1‰!В И ­! @$Ž!Њ А Ь 1‘"Њ А ж! @&–"Ђ Ј П 1™#Ђ Ј ё! @(ž#š   А 1Ё$š   " @*І$Œ ‘ ^˜ +1Љ%Œ ‘ : @џџ2Љ– " @-­… ‰ ^˜ +1Џ… ‰ $" @/Д} ‚ й +1З} ‚ 1" @1Лv z й +1Нv z :" @3Ф^ d W +1Ш^ d e" @5ЯM \ > +1гM \ W @+й2 < ‘" @8п* 0 W +1т* 0 И" @:ш ( > +1ы ( р" @<№  7 +1є  љ" @>ћ   +1  # @@ќ   +1 ќ  љ" @Bѓ љ  +1ѓ љ  @+ч ё  @+#л х  @+)Я й # @G/Х Э  +13 Х Э 5# @I8 О Т  +1;!О Т T  @+@!Ж М T  @+E!Џ Д T  @+J!Ј ­ F# @NO!  І T  +1R"  І X# @PX"—   +1\#—  q# @Rd#Œ ” _ +1i$Œ ” •# @Tq$ ˆ _ +1u% ˆ q# @V}%u | _ +1‚&u | Џ# @X‡&l r  +1Š'l r Ф# @Z‘'a i _ +1•(a i ф# @\œ(T ] _ +1Ÿ)T ] _ @+І)F Q _ @+­)9 D _ @+Д), 7 Ф# @aЛ)# * _ +1П*# * њ# @cХ*  +1Щ+ $ @eб+  ы +1ж,  =$ @gо,є  ы +1т-є  $ @iъ-р ё ы +1я.р ё Z$ @kє.Ю н  +1ї/Ю н r$ @mў/Т Ы ы +10Т Ы •$ @o 0Б О ы +1 1Б О r$ @q1ž Ў ы +12ž Ў Ў$ @s2• › Ф +13• › Ю$ @u'3Š ’ Б +1,4Š ’ % @w44| † Б +175| † -% @y?5p y Б +1C6p y Ю$ @{K6g n Б +1P7g n ]% @}U7^ d Ѓ +1X8^ d |% @`8S [  +1e9S [ А% @m9< P  +1q:< P н% @ƒy:/ 9  +1|;/ 9 ў% @…„;# ,  +1ˆ<# , .& @‡< ‚ +1= B& @‰˜=  x +1>  q& @‹Ѕ> x +1Љ? q& @Б?іџx +1Е@іџB& @Н@эєx +1ТAэє•& @‘ЧAфъ‡ +1ЪBфъЈ& @“вBксK +1зCкса& @•пCХзK +1уDХзє& @—ыDИТK +1юEИТа& @™іEЌЕK +1њFЌЕЪ† œњVoЇ '@š4њVrrƒ +1§WoЇ9'$šўWttb'@ šџWvv'@ šWwwР'@ šWxxѓ'@ šWyy$(@ šW{{c(@0@šW‚…c(@0@š W}€›(@0@š W‡ŽЪ(@0@šW“љ(@0@šWšљ(@0@šW•˜))H0@šWŸЂT)4šWЅЅ€)4šWІІЌ) @­Wel› +1XelЧ) @Џ"X\c_ +1%Y\cэ† В%kњYт)@А4%k§§ё‚ +1(lњYT*$А)l}*@ А*lЋ*@ А+lл*@ А,l+@ А-l?+@ А.ll+@0@А1l l+@0@А4l Є+H0@А6lг+@0@А9l+2г+@0@А;l),H0@А>l4<-,4@А@l?GV,4@АBlIT€,4АClVVЌ,4АDlWWе,4АElXXў, ЦEЁї-@Ф4EЄЄЊ +1H€Ёї.@ ФI€ЌЌ0.@ ФJ€­­Q.@ ФK€ЎЎu.@ ФL€ЏЏ›.@ ФM€ААФ.@0@ФP€ЛОФ.@0@ФS€ЖЙФ.@0@ФU€ВДщ.H0@ФW€РУ /H0@ФY€ХЩ//H0@Ф[€ЫЯV/@0@Ф^€змV/@0@Ф`€бе}/@0@Фc€фщ}/@0@Фe€отЄ/H0@Фh€ыюЫ/H0@Фk€№ѓђ/8Фl€іі0 лlPžZ0@й4lVVƒ +1rPžЂ0@ йsZZэ0@ йt\\A1@0@йwbeA1@0@йy^`І1H0@й{gjё1H0@й}lpB2H0@йrv”2@0@й‚~ƒ”2@0@й„x|ц2@0@й‡‹ц2@0@й‰…‰83H0@йŒ’•Š3H0@й—šм38й*4 @ы”GMF +1—‘GMG4 @э›‘?Ec +1ž’?Ed4 @яЂ’7= +1Ѕ“7=€4 @ёЉ“/5& +1Ќ”/5œ4 @ѓА”'-› +1Г•'-Й4 @ѕЗ•%_ +1К–%ж4 @їО–ђ4 +1С—§4 @љХ—5 +1Ш˜!5 ШИƒ :5@њ4ШИ……& +ШУsЙ&+ШУOON5@ ќЩУvvy5@ ќЪУwwЅ5@ ќЫУxxС5@0@ќЮУ…С5@0@ќаУ|р5@0@ќгУ‡ћ5@0@ќеУ’–6@0@ќиУ˜Ѕ26@0@ќкУЇЕM6@0ќлУЗЗe6@0ќмУИИ1 +1оФƒ 6@ њпФˆˆ 6@ њрФ‰‰Ь6@ њсФŠŠё6@ њтФ‹‹7@ њуФŒŒC7@ њфФe7@ њхФŽŽ‰7@ њцФБ7@0@щФš›Б7 њ1ыХš›Б7@0@њюХ•˜Б7@0@њ№Х‘“м7H0@њђХ Ѓћ7@ њѓХІІT8@ њєХЇЇŠ8H0@њіХЉ­Л8@0@њљХЏВј8H0@њћХЕЙ9H0@њ§ХЛОC9@0@њХЦЫC9@0@њХРФi9@0@њХгиi9@0@њХЭб9H0@" ХкоИ9 њ1 Цкой9@0@њЦтцџ9H0@њЦшы$:@0@њЦэёJ:H0@њЦѓіo:H0@њЦјћ•:H0@)Ц§Н: њ1 Ч§н:H0@+#Ч; њ1%Ш';8њ&Ш  I; @.+Ш{€' +1.Щ{€`; @02Щqx +14Ъqxp; @2:Ъ`o  +1=Ы`o‰; @4CЫW^  +1FЬW^Ђ; @6LЬNU  +1OЭNUЛ; @8UЭEL  +1XЮELг; @:[Ю=B +1]Я=Bх; @<bЯ49ь +1eа49љ; @>jа)1ь +1mб)1 < @@rб%ь +1uв%!< @Bzв ь +1}г 7< @Dг ф +1„д L< @F‡д§к +1‰е§]< @H‘еСЧ\ +1”жСЧ|< @JжГПZ +1 зГП< @LЉзЌБZ +1ЌиЌБН< @NГиЄЉ\ +1ЕйЄЉи< @PНй—ЂZ +1Пк—Ђѕ< @RЧк‘•Z +1Щл‘•= @Tал†Ž6 +1гм†Ž)= @Vлм{„E +1он{„C= @XцнtyE +1щоty\= @Zяоkq6 +1ёпkqp= @\јпaiE +1њрai†= @^р[_E +1с[_›= @` сTX +1 тTXЏ= @bтGR* +1уGRХ= @dуAE* +1фAEк= @f"ф8=у +1$х8=к= @h)х16у +1+ц16ю= @j0ц+.у +12ч+.> @l6ч   +19ш > n:щ> +1<ъ(>@ m=ъ> q>ыћџ> +1@ьћџZ>@ pAьўў> tBэѕљ> +1Dюѕљ†>@ sEюјј> wFяяѓ> +1H№яѓГ>@ vI№ђђ> +Jёшык>@ yKёъъ> +Lђтх?@ {Mђфф> +Nѓмп^?@ }Oѓоо> +Pєжй‘?@ Qєии> +RѕЮбО?@ Sѕаа> +TіШЫљ?@ ƒUіЪЪ> +VїТХ.@@ …WїФФ> +XјМП_@@ ‡YјОО> +ZљЖЙŠ@@ ‰[љИИ> +\њАГЙ@@ ‹]њВВ> +^ћЊ­т@@ _ћЌЌ> +`ќЄЇ!A@ aќІІ> +b§žЁZA@ ‘c§  > +dў˜›‡A@ “eўšš> +fџ’•ЎA@ •gџ””> +hŒыA@ —iŽŽ> +j†‰"B@ ™kˆˆ> +l€ƒMB@ ›m‚‚> +nz}rB@ o||> +ptwГB@ Ÿqvv> +rnqюB@ Ёspp> +thkC@ Ѓujj> +vadFC@ Ѕwcc> +x[^}C@ Їy]]> +z SVЎC@ Љ{ UU> +| MPэC@ Ћ} OO> +~ GJ&D@ ­ II> +€ ADaD@ Џ CC> +‚ ;>–D@ Бƒ ==> +„58УD@ Г…77> +†/2ъD@ Е‡11> +ˆ),E@ З‰++> +Š"%BE@ Й‹$$> МŒ> +1Ž‘E@ Л> П> +1’ЪE@ О“F Т”F +1—&F@ С˜F Х™  F +1  ’F@ Фž  F ШŸF +1Ѓ№F@ ЧЄNG ЫЄћ +1ЇћgG@ ЪЈўўŠG ЮЈѕљъ +1­ѕљаG@ ЭЎјј H @бБьђМ +1Г ьђ1H гГ!хъЃ +1Е"хъRH@ вЖ"щщ~H @жК"инE +1М#инŸH @иР#бжE +1У$бжЭH @кЦ$ЦЭ  +1Ш%ЦЭЭH @мЫ%НФ  +1Э&НФЭH @об&ЕЛ  +1г'ЕЛтH @рз'­Г  +1к(­ГЭH @то(ЅЋ  +1р)ЅЋтH @фф)Ѓ  +1ч*ЃI цч.’›Ѕ +1щ/’›&I@ хъ/––ZI@ хы/——ŽI@ хь/™™дI@ хэ/ššJ ью1ŠJ +1№2Š7J@ ыё2ŽŽ—J@ ыђ2K №ђ4‚ˆw +1ѕ5‚ˆ5K@ яі5††vK@ яї5‡‡ФK єј6{€ФK +1њ7{€хK@ ѓћ7-L їћ8tyM +1ў9typL@ іџ9xxаL @њ9kq@ +1:kqфL ќ;diС +1<diM@ ћ<hh6M џ=]b6M +1 >]bZM@ ў >aa–M  ?V[ +1@V[мM@ @ZZ0N +ANRLN@ AQQˆN BFKч +1CFKЖN@ CJJO D>CO +1E>CO@ EBB#O F7<у +1G7<8O@ G;;VO @#G'3Щ +1'H'3yO @+H%Щ +1.I%•O +/JЌO@ 0J%P 0K І +14L MP@ 5L‡P +6M P@ 7M  њP 7Nџ{ +1:OџQ@ ;ONQ @>Oєњ` +1@Pєњ_Q +AVш№qQ@ BVъъІQ@ CVыыдQ@ DVььR@ EVээ8R@ FVююcR@ GVяя_Q +H\оцR@ &I\ррМR@ &J\сссR@ &K\тт S@ &L\уу3S@ &M\ффUS@ &N\хх_Q +ObглyS@ -PbееЃS@ -QbжжЦS@ -RbззюS@ -SbииT@ -Tbйй4T@ -Ubкк_Q +VhЩбVT@ 4WhЫЫT@ 4XhЬЬЅT@ 4YhЭЭЮT@ 4ZhЮЮѕT@ 4[hЯЯU@ 4\hаа_Q +]nПЧ9U@ ;^nССkU@ ;_nТТ–U@ ;`nУУЦU@ ;anФФєU@ ;bnХХV@ ;cnЦЦ_Q +dtЕНFV@ BetЗЗoV@ BftИИ‘V@ BgtЙЙИV@ BhtККнV@ BitЛЛќV@ BjtММ_Q +kzЋГW@ Ilz­­NW@ ImzЎЎxW@ InzЏЏЇW@ IozААдW@ IpzББћW@ IqzВВ_Q +r€ЁЉ$X@ Ps€ЃЃLX@ Pt€ЄЄmX@ Pu€ЅЅ“X@ Pv€ІІЗX@ Pw€ЇЇеX@ Px€ЈЈ_Q +y†—ŸѕX@ Wz†™™(Y@ W{†ššTY@ W|†››…Y@ W}†œœДY@ W~†нY@ W†žž_Q +€Œ•Z@ ^Œ2Z@ ^‚ŒUZ@ ^ƒŒ‘‘}Z@ ^„Œ’’ЃZ@ ^…Œ““УZ@ ^†Œ””_Q +‡’‚ŠхZ@ eˆ’„„[@ e‰’……:[@ eŠ’††f[@ e‹’‡‡[@ eŒ’ˆˆД[@ e’‰‰_Q +Ž˜wк[@ l˜yy \@ l˜zz7\@ l‘˜{{g\@ l’˜||•\@ l“˜}}Н\@ l”˜~~_Q +•žmuч\@ s–žoo]@ s—žpp@]@ s˜žqqn]@ s™žrrš]@ sšžssР]@ s›žtt_Q +œЄckш]@ zЄee^@ zžЄff3^@ zŸЄggZ^@ z Єhh^@ zЁЄiiž^@ zЂЄjj_Q +ЃЊYaП^@ ЄЊ[[щ^@ ЅЊ\\ _@ ІЊ]]4_@ ЇЊ^^Z_@ ЈЊ__z_@ ЉЊ``_Q ‰ЊАNW_Q +1ЌБNWœ_@ ˆ­БQQЫ_@ ˆЎБRRѓ_@ ˆЏБSS `@ ˆАБTTK`@ ˆББUUp`@ ˆВБVV_Q ‘ГЗCL_Q +1ЕИCL—`@ ЖИFFР`@ ЗИGGт`@ ИИHH a@ ЙИII.a@ КИJJMa@ ЛИKKna ™ЛО8AP +1НП8A…a@ ˜ОП;;Џa@ ˜ПП<<вa@ ˜РП==њa@ ˜СП>> b@ ˜ТП??@b@ ˜УП@@bb ЂУР05€b@ 4УР22? +1ХС058 +ХТ*.Юb@Ѓ4ХТ++c ЇХЩ(ў@Ѕ4ХЩ, +1ЫЪ(G™ +1 ю>Gшk @сю3<™ +1я3<шk @уя(1™ +1!№(1шk @х(№&™ +1,ё&l @ч2ёu +15ђl @щ;ђ u +1>ѓ l @ыDѓљu +1Gєљl @эMєюїu +1Pѕюї[ @+Sѕцщl @№Vѕрф[ +1Xірф +XўQp2l@ ёYўVVRl@0@ё\ў]`Rl@0@ё^ўX[sl@0@ёaўbel@0@ёcўgjБlH @џџeўНЧБlH@ёgўllЮlH @џџjўЩнЮlH@ёmўmmщl@0ёnўoo9 +oўЛЛ5+tўAA5+xў::х +xў+-б +xў')З +xў"$ +xўc +xўG +xў/ +xў.5 @џџyўV V 5 @џџzўU U 5 @џџ|ўS S 5 @џџ~ўR R — @џџўm m ’ @џџ€ўl l ‰ @џџўh h € @џџ‚ўg g Ш @џџ…ў№№Ё @џџ‡ўцц“ @џџ‰ўхх† @џџ‹ўнн @џџў'' @џџ“ў%%ђ @џџ—ў##д @џџ™ў!!Л @џџžў” @џџЂў‚ @џџІўp @џџЉўC @џџЊў$ @џџЋў‚ @џџЌўсс… @џџАўk @џџГўььu @џџЗўKKc @џџЙўII^ @џџЛўHHV @џџНўGG @џџОў33є @џџПў00{ @џџРў   "$&(   !#%')*-/13568:<>@BCDEGIJKLNPRTVXZ\]^_acegikmoqsuwy{}ƒ…‡‰‹‘“•—™œ­ЏВЦлыэяёѓѕїљќ§ .02468:<>@BDFHJLNPRTVXZ\^`bdfhjlnqtwy{}ƒ…‡‰‹‘“•—™›ŸЁЃЅЇЉЋ­ЏБГЕЗЙМПТХШЫЮбгжикмортфць№єїњќџ  &-4;BIPW^elsz‰‘™ЂЃЇАЙТЫвгдемкижнпсухчщыэю№ёќ§ўџ,.02479;=?AFHMOQSUWY[`bdfhjlnprtvxz|~€‚„†ˆŠŒŽ’”–˜›žŸ ЁЂЃЄЅІЇЈЉЊЋšЌЎБГДЕЖЗИЙКЛМНОПРСТУАХЧШЩЪЫЬЭЮЯабвгдежзиФкмнопрстуфхцчшщйъью№ђєіјћ     "#$%&')+,ўџњ!(*-/13579;=?ACEGIKMOQSUWY[]_acegikomrpusxvz|~€‚„†ˆŠŒŽ’”–˜šœž ЂЄІЈЊЌЎАВДЖИКНЛРОУСЦФЩЧЬЪЯЭадвезйлнпсучшщъхэюыёђяѕѓјіљ§ћў    !"#$%'()*+,./012356789:<=>?@ACDEFGHJKLMNOQRSTUVXYZ[\]_`abcdfghijkmnopqrtuvwxy{|}~€‚ƒ„…†‡Š‹ŒŽˆ’“”•–—š›œžŸ˜Ё ЄІЈЉЊЋЌ­ЅЏБВГДЕЖЎИКЛМНОПЗСУФХЦЧШРЪЬЭЮЯабЩзйлортфцшъьяђѓєѕіјњћї ]6]6]6‹ђЎИ5 &5?ЂЫ^n~5 &5?ЂЫ^n~5 &‹ЂЫ^n5 &‹ЂЫ^nЅ &5?ЂЫ^n~Ѕ &5?ЂЫ^n~Ѕ &‹ЂЫ^nЅ &‹ЂЫ^nї ОЬйщЂЫ•sї ОЬйщЂЫ•s&.=KYЂЫv‡&.=KYЂЫv‡˜ŸЌИХЂЫн˜ŸЌИХЂЫн&.=KYЂЫv‡&.=KYЂЫv‡˜ŸЌИХЂЫн˜ŸЌИХЂЫньє§ў5јЂЫ•s~ьє§ўўЂЫ•sьє§ў5јЂЫ•s~ьє§ўўЂЫ•s5 &5'ЂЫ^n~5 &5'ЂЫ^n~5Nk‡ЄР5 &ЂЫ^n5 &ЂЫ^nї ОЬйщЂЫ•sї ОЬй@SpЂЫ•sЕї ОЬйЦцЂЫ•sї ОЬйhцpЂЫ•sЕї Й”^7цЯї ”^7ц+ї q”^7ц~ї ОЬйцНЂЫ•sї § йЂЫ7•sї ЙG^7\ї …^7˜ї qН^7ТХї § йЂЫ7•s5 &5?ЂЫ^n~5 &5ЩSоЂЫ^n~&5 &5Цц9ЂЫ^n~5 &5›цЅЂЫ^n~&5 &‹ЂЫ^n5 &ЩSёЂЫ^n&5 &Цц4 ЂЫ^n5Nk‡Цц‘ 5 6 P Ццk 5я   Цц* 5 &›ц™ ЂЫ^n&Ѕ &5?ЂЫ^n~Ѕ &5ЩSоЂЫ^n~&Ѕ &5Цц9ЂЫ^n~Ѕ &5›цЅЂЫ^n~&Ѕ &‹ЂЫ^nЅ &ЩSёЂЫ^n&Ѕ &Цц4 ЂЫ^nЅ &›ц™ ЂЫ^n&&.=KYЂЫv‡&.=Kр ќ S ЂЫv‡e z &.=KЦŽ цЌ ЂЫv‡&.=K! - цA ЂЫv‡e &.=Kр Ђ ц­ ЂЫv‡e z &.=KYЂЫv‡&.=Kр SЂЫv‡e •s˜ŸЌИ! ^ц|ЂЫнe ˜ŸЌИЦтцЂЫн&.=K! тц€ЂЫv‡e ˜ŸЌИХЂЫн˜ŸЌИр ќ SюЂЫнe z ˜ŸЌИЦŽ ц=ЂЫнe ˜ŸЌИ! - ц­ЂЫнe ˜ŸЌИр Ђ ц ЂЫнe z ˜ŸЌИХЂЫн˜ŸЌИр S\ЂЫнe •s˜ŸЌИ! ^ц|ЂЫнe ˜ŸЌИЦтцЂЫн˜ŸЌИ! тцЄЂЫнe ЂЫ=sLs šфw;eЂЫЕіЂЫ^‡ЛШ‡‡‡ђж‡55б5;qЂЫ=sБt5;qЂЫ=sБtЂЫ=sLsеšфw;+ЂЫA‚ЂЫЉ^šю‡ђж 5T‹ї šО5šЂЫѓByЈйЂЫрЂЫ)7ЂЫйAp‡ђжЦ‡ђжЦ5ё(5ё(йЂЫѓ•sRm†ЁйЂЫ)7ЂЫйёќ‡ђжY‡ђжY5Џ5Џй5f’ПЂЫ"5f’ПЂЫ"5f’ПЂЫ"5f’ПЂЫ"5f’ПЂЫ"5f’ПЂЫ"3f’ПЂЫ"lŠ•СЂЫё%[ЂЫЃЂЫТЃЂЫї иќї 9ЂЫёOsЌооDuЂЫ|ЈЂЫбЂЫсяЂЫu‡ђљb ї ˜ д :!g!’!‡ђжК!’!‡ђжК!5|ЈЂЫбК!ф!"’!ф!"К!ф!"’!ф!":!ф!"5|ЈЂЫбV"|ЈЂЫбuї ŸЌ€"Œ"ЂЫнЅ"ŸЌл"ЂЫнї ы"љ"€"Ц#ЂЫёї B#P#€"]#}#ЂЫѓї § €"Й#г#ЂЫ7ї ŸЌ€" $!$ЂЫнS$‹$‘$ЂЫš$ї Љ$ŠЦЕ$ЂЫц$ї ѓ$Š]#џ$ЂЫ0%ї =%ŠЙ#I%ЂЫt%ї %Š $%ЂЫнї %ŠК%ЂЫнЬ%‹$‘$ЂЫš$ї ŸЌ5џ%&+&>&ЂЫн~ї § 5џ%&+&Й#x&ЂЫ7~ї ŸЌ5џ%&+& $Я&ЂЫн~ї ŸЌџ%&+&"'ЂЫнї § џ%&+&Й#W'ЂЫ7ї ŸЌџ%&+& $Љ'ЂЫнї ŸЌ5&+&ї'ЂЫн~ї § 5&+&Й#+(ЂЫ7~ї ŸЌ5&+& $|(ЂЫн~ї ŸЌ&+&Щ(ЂЫнї § &+&Й#ј(ЂЫ7ї ŸЌ&+& $D)ЂЫнї ŸЌ&+&Щ(ЂЫнї ы"љ"&+&ЦŒ)ЂЫёї о)о)]6‹ђ $D)ЂЫнї ф)&+&№)ЂЫ•sї *&+&**ЂЫ•sї X*]6‹ђ`*ЂЫнŠ*Л*С*Ч*ЂЫз*ф*ё*ЂЫ•s +/+ЂЫ•s +B+ЂЫ•s +V+ЂЫ•s +d+ ++ +Ж+ +а+ +ф+ +, +", +:, +L, +b, +r, +˜, +И, +Ь, +к, +ў, +- +.- +:- +b- +„- +š- +Њ- +Ш- +р- +. +&. +H. +d. +x. +†. +œ. +Ќ.т. /ЂЫф*т.*/ЂЫз*т.J/ЂЫз*ф*Œ/щ/ЂЫз*ф*040{0ЂЫз*ф*Џ0Ц0ЂЫз*ф* 1ЂЫз*ф*Џ00т.Н12*2ЂЫš$ЂЫ;2K2ї k2x2Š2ЂЫš$ї Є2Д2Ъ2ЂЫы2§23`3k3ЂЫš$3v3*2ЂЫš$3`3‡3Ж3ЂЫš$3`3ё3ћ3ЂЫš$43v3‡3$4ЂЫš$3v3ё3e4ЂЫš$4ЂЫš$4е4:5В576ЂЫš$%‹$ЂЫš$i6}6Г6О6ЂЫš$Ы6ЂЫš$ї6%72*2ЂЫš$ЂЫš$W7О6ЂЫš$П7ЂЫš$ї6ъ7ЂЫё7 8ЂЫžўЌў’џЂЫ8žўЌў—џ%8ї899$9ЂЫV9f9v9†9ї89#:ЂЫV9f9E:˜:ЂЫП:Ю:н:ь: ;˜:ЂЫП:Ю:ь:E;2*2ЂЫš$};;$$$Ў;С;д;;єєєо;ш;ђ;њ;’Р’Р’Р<"<*<њ;œKœKœK3<<<E<;žLžLžLчйU<e<;йййpl<s<;‹ђ‹ђ‹ђ‚<‘< <;‡ђ‡ђ‡ђРђІ<Ќ<;mѓmѓmѓќђН<Ю<;гOгOгOж<о<І{;ACACACЖђц<№<;===H‹==;,=,=,=8=F=ќw;L>d>ЂЫ~>ЂЫ•s“>Ѕ>~>˜:(СЙ>Й>ќёЂЫ•s“>Ѕ>˜:(СЙ>Й>ќёЂЫ•s“>Ѕ>П>(СЙ>Й>ќёЂЫц>•s†mRљ>?(СЙ>Й>ќёЂЫц>•s†mR?(СЙ>Й>ќё55)?5?B?+&X?ЂЫ~žўЌў55)?Ž?B?+&Ё?ЂЫ~žўЌў55н?5?B?+&я?ЂЫ~žўЌў55н?Ž?B?+&+@ЂЫ~žўЌў5)?5?B?+&m@ЂЫžўЌў5)?Ž?B?+&ž@ЂЫžўЌў5н?5?B?+&е@ЂЫžўЌў5н?Ž?B?+& AЂЫžўЌўIAЃ2*2ЂЫš$K2ЂЫkAˆAЂЫЈAkAˆAЂЫї ї ї ЈAПAї ЈAПA9йAї ]6]6ѓA3ї ј$ј$.ЏЧлъ ъB BчНBBru‰Š‹ŒŽЅІЇЈЉ­ЎЏP'–œЂЋБЗТЩЯжнфъяѕ cinz‡Ž””ЗМТЧгкрчээі9Лr†›…ўr5R S ‚рсщ‚Ь%бБЬћ( C u І ш 1 > K Ѓ Ћ В К ! 6 7 C D S T ‚ kьKgŸ# y ˆ ыЁ Д К Ц Щ е к у ї §   ( z ё і     $ ) є0єфі'@@KV`jt~‰”žЈВМЦакхяŽŽЕјЉЏн7&*3OTos|‡‡’ЋЌИЛТТХЬЭЭЮЮЯгйцO^ahnr„›Ÿмьўh–І(.Іo r † Ž 2‹ Œ B!259<HMNPUW]chmopw~ƒ‰‹Œ“™ ІЈЏЖНФЦVS #+1&(U˜ GGHHььKKLL:˜ Œ•ЇР"FQ I6cЛ 2  Е ј . ; H W ‚ џ Ь a 0Y Š a8еN с;‹”œПЫсž Ђ Т Ч р ф  # & a e u x Œ  J Љ А И Ъѕћў      гX Z \ d Sabbf{}}—˜˜ГЕЕКNPP  Ё Ё О П П гrž   Ё Ё ­ Б Г Д Д Й Н Т Х Ц Ц Ю а б б д и р т у у № є і ї ї ќ         # % % T V V a d d l n n u w w    Œ   — ™ ™    * + + M P P ^ _ _ ъ ь э э № є ћ § ў ў          # ' . 0 0 6 8 8 > @ @ F H H <5V <и';BОСгж 5 8 L N O ‚ … Й М Н д з и ќ џ    № ѓ є       # & ' Мщюю№     „ Ž ‘ š П Ч Я з ƒqt}‚…L‚МW   юqььKKLLюƒDЌЎЎИККОХЧЧгкннхццэяяіјј          / 1 1 5 < > > L Х Ш ѓ ѕ ќ ў    › œ œ Ѓ Є Є Л М М У Ф Ф к н т х w Œ їa wƒ‹—@$гекм№№їїР: шыьэюяттшш@ZahhmmoџнІЇ З Ч з ч   % * ; K РVx}І)ƒ2х2Ћ­­ЎЎАВТУУУФЬгдддейккклВ„†‰2бг2‹5 Iь "&U ЂВЉф` f ф:ф  ­ Г Й Н Х а д и т № і ќ     ь № є §       # ' ффД Э# '(2‹ Э5€ Э9QPMu|–VKR жBMŠVGж'+,1П45f"ЫB Ѕ ч 0 = J г п ы ?1r?‡HKNOUW\beflopv}€ˆ‹’˜›žЅЈЎЕИЛУЦGJPSY\bgjnsv}ЎБВКОПЧЬЭбнрцшяђјћќ      % ( ) * 1 5 6 > C D H V Y ` b i l r u v w ~ ‚ ƒ   — ™ Ё Ѓ Є Ј Љ Ћ Ќ Џ А В Г З И К Л П С   œ ž Є І Ќ Ў Д Ж М О Ф Ц Ь Ю д ж Пч?ЌЏХШкоэ№іљ   # & < ? S W g j p s Š Ž ПЄ €,ˆРЦШЭгетшъэѓѕ[x~€…‹’—Ќбзйофцы№+/479t‡•šˆ$# % % S V V ^ ` ` g i i p r r | ~ ~ Š   • — — Њ Ќ Ќ В Д Д Ъ Ь Ь в д д 5S U V д:б'VSсQAC#$'(авб—™šNњсцяњ)4?і, ЈАИРЩгк ,29BHU\blv}ˆ’˜ЅЎЕУў +6?GPYbs}!)19AI^gЎКЧнцяј   % 1 > V ` i r ~  — Ё Д Ц б у ї  % , 9 F V d n w   ™ Ё Ј Џ Ж П Ш Я л ч ѕ ў   + 2 ? P _ w  † Ž œ Є Ќ Д М Ф Ь д н х э ў  0 8 @ H њМ ƒ Ј Џ З 0QX]]bbgmz˜ЁЗНЩЩсцPUZZmu•ƒKK#$'(Урђ#<<GR\fpz…šЄЎИТЬжсыю№ўŠŠІУ–—C ƒUZ^bЧ Ъ e h  “ , Я л ч Ќ=!#),.479?BDv}‚ˆŒЎЕМУЦу ы ю ї §    w z  †  ’ ™ › Q U W Y ` c   Ž     $ ) @ B H J ьуѕ&??JU_is}ˆ“ЇБЛХЯйфюЛЈЎ,l‚‡ь +6l,‚ƒ,  5:ACKuIJKѕ $/:E5<Phƒ Нuьяњu'б+17=CIOU]cjpv|‚ˆŽ”š ІЌВИОФЪаиофъђјўШ? uџ ѕѕ^Ё І Ї Ћ Д И К Ц Щ б е к у ш щ ю ї ћ §    % ( ) - 1 2 6 : > ? C G K L P V Z [ d g n p w z {  … †  ’ ™ ›  " ' + . 3 6 8 @ C E P S V [ _ b э ё і ў      $ ) 0 2 8 : @ B H J u9 : : ; F G G H ^0^˜h m o ^GHžY^ož ЁЉЌРТХЭЮЮЯбгзйV[^отє%>IT^hr|‡’œІАКФЮиуэŒ§W^hsчGN'}p‹Ё І Ї Ћ Ћ Ќ ­ Д И К Ц Щ б е ж з и к л у ш щ ю ю я № ї ћ §        % ( , 1 2 6 6 9 > ? C C F K L P P V Z [ d g n p q w z  … †  ’ ™ › œ  " " # % ' + . 3 6 8 : @ C E G P S V V W Y [ _ b э ё ђ ѓ є і ї ў              $ % & ' ) * 0 2 3 8 : ; @ B C H J K pIIKKpЫАœ { Y}X{ ƒx™)4?Y Юј$ЏЛР& 2 7 Yх тR"QSXЁ Ѕ Љ Ќ А Г И Л П С Ш Ь а и м ф ш № ѕ ј ў     н п х ч тBMŠЂ(ЂЌЛ# % % S V V _ ` ` g i i p r r | ~ ~ ‚ Š   • — — Ћ Ќ Ќ Г Д Д Ы Ь Ь г д д Ы;‹”œПЫ ;ј  $+17=CIOU]cjpv|‚ˆŽ”š ІЌВИОФЪаиофъђјў   щѓc m Ÿ Ї Џ З K ЎКПЧнршђž І T Ё Ј Џ Ж С ” LL ЬЮдВ+2”йуъѕћ &SW[rЎЫ-ќ ")/5;AGMS[ahntz€†Œ’˜žЄЊАЖМТШЮжмтш№іќ  ”Эд!ЯijЮE Ј ъ ы 3 @ M е с э U §ЛС+ZV} %&'(ЫЬЭЮбв§46Цѕћўџ      † нєщ c š ж л   q œ  /K/vd‹ЁJZо W Ž Ч e  oџ o’˜ЅЈЎЕУЦo8 : : ; E G G H x…Ё Ј Ћ Ќ ­ Д И К М Н Ц Щ б е ж ж к л л у ъ ю я № ї ћ § џ        % ( - 3 6 : @ C G M P V Z [ d g n p q q w z  … †  ’ ™ › œ œ  ! " " # % ' , / 4 7 9 : A D F G Q T V V W Y [ ` c э ё ђ і ї ў            $ % % ) * * 0 2 3 8 : ; ; @ B C H J K K јxfЃ 8*8GHH`bbƒˆ‰Š‹ŒŽ• ІЇЗ 8Ÿx яј    О Ц AўЬ> Сvd‹ЁJQaemoџІІ{С ЎЗC]w“Џ H§Vtав?j *˜šžž ЁЃj јљ#$12op№ё  ъіў *BHWЊЃЌВЖЛЛ3Х[eoy„™Ѓ­ЗСръs!')/179?AGIѓƒ\6яђєњ§џ !#),.479?BD!$),149<ADIL_bhkw y y    † ˆ ˆ Ž   мweŒЂx‡—ššŸЇЏЗПШчЇЇЉЋЏмѕ  \ЅУ'o‹вм  }~ Ш Я л ч ѕ ј ў    п ч œn q w  œ8 H ЅееN N %5U %vхЧЋЌЏБх+љ s  % Ѕ “ŸЇЏЗПТШЫчЇeорW Z S6 C P : G Ž7истщѓєњ $%  *+56FGOPXYab|}TV[­Ц Ш ѓ ѕ ќ ў   л н у х Ю(сѓ$==>HS]gq{†‘›ЅЏЙУЭзть>ru‹‹ŒтшэѓјЇ­Юѕб  —5 м U Œ Ф  c Ž —9:A—Epгекм№№їїЎВГДКОПЧЮгенрцшщщщяђѓјќ§ў         % * + 1 5 6 > E L V Y ` b c c c i l m r w x ~ ‚ ƒ   — ™ š š š œ ž Ÿ Ÿ Є І Ї Ї Ї Ќ Ў Џ Џ Д Ж З З З М О П П Ф Ц Ч Ч Ч Ь Ю Я Я д ж з з з ч   ЂЈЊАВИКРУЩЬWYYPZ\bgnЁЂЅІЇЈЉЌ­ЎЏАЖРЧіy‚П W+ 2 ? _ —m r рJX]bglm|‡’˜ЇНЩUZh‘•› ЕЛРЦЭглтшэѓјў^bglrx~…‹’—ВЖЛРХЫбзофы№ +4?I}‚‡•šŸр5 Iь "&рƒ_+,ABBTUU[\\klltvv†ˆˆ‘’’ЄЅЅЌЎЎСУУ  EGGqrssu{}}ЌЎЎИККХЧЧкннфццэяяіјј         / 1 1 < > > š œ œ Ђ Є Є К М М Т Ф Ф ` іWpЈЦv п ч   р #::;;ACDLNOV~ƒ‰‹І ищHISTTбH 8 9 E F I5ƒ™еЅЗй  . R { ‰ А С г ѓ   S ` ~ ‹ ћ  я  " I€`„‡‰ЩЮЯзйляђєњ§џ !#),.479?BD•–›œлнў"$*,24:<BDJLbc’”—™ЖЗыэ№ђ489:;`bik‡‹w y y    † ˆ ˆ Ž   ‰KKЩ ,щ c š ж л   q œ Ÿ Ї Џ З П Ч Я з ђ ї     % * 3 ; C K   ЈАИРУЩЬх‰h ’k l q Ла м ш {7F{CШ Ы Ы Я а д и л м р ф ч ш ь № ѕ ј ў      н п х ч {{!Л"'),/;бгЛЮ{ "(*028:@BHJ{: ; ; G H H {ў ФKNQD@}‚‰‰šЃЉЉЌГЗФелшim‘•4bn ™ Ф— -:N э mэ№  g j Š Ž Ж<‹”œПЫ6lˆпq }‚ŸŸ ffg‚žŸКЛМпЫ> пюяљњ()34>?7;>?п™ТЫ_еЏ_л$% , 9 F V [ d g p w  †  ’ › 2 : B J Ј: Y\]^_`))//Ј4()34>?uv|}‡ˆ­ЎДЕТУр у є ї    u w   Œ  — ™ O Q ^ ` ~   Ž   > @ F H шЖМc~™ЖQР 7 „ Л ў ) \ { ‡ Јл+VЄЈ ЭЮш -68DFRWhэ  ё9ё‚ќ _`hiБ'пё";;FQ[eoy„™Ѓ­ЗСЫеръѕј"#)*+/01‰‰Ѕ1„ˆ‘•››Їлў!")*129:ABIJБ i r ~ ƒ   ™ Ю ж 1д кюяљњ()34>?7>?BZ’˜ЈЎЕЦкўк^ž   Ё ­ Б Г Д И Й Н Т Х Ц Ю а б д и р т у № є і ї ћ ќ        # % T V Z a d l n u w   … Œ  — ™    * , , N Q Q ^ ` ` ъ ь э № є ћ § ў         # ' . 0 6 8 > @ F H #Y c weŒЂx‹ŽЈИcIБ$#˜у8?Ѓцю№у"$,29Ѓ` q ‚ћў]_`fhiptwxyŠ  }‚ ЎВИУдкin GPYbvЬЌ Œ0 @ е#(SЌ Г Л и ф № е§w UKрс8;<=?@єѕіјV]^adhhkmmot{|‚Š‹’––—Ÿ ЅЇЈ­ЏАЕЗИНПРТЦШЩЫиккьюю№ннххєѕѕ§ўў=>?U ор№ѓ  W Z j m Ž ‘ ўb d € ўью03> . P b p ‡ц % 1 6 > V Y b l Ў Ж љ)+љ.79IТ_жпчёТ#'*,0B\А+м" !"#$%&'(ЫЬЭЮЯабвН з  ) { ѓ   & ЋilНДцчііД BBMMQwŠNy кфыіќ 'RWZltЏХЭцY fў4OЭЯЯ иY X š›кл§ўЛМЁ ціЙ д ќ  №   # :– э2§ C Ф  i k :^нхч№єІ§w ž Ÿ Ÿ Ÿ І Ї Ї Ї Ў Џ Џ Џ Ж З З З О П П П Ц Ч Ч Ч Ю Я Я Я ж з з з п п п ч ч ч ь № ё ђ ђ є і ї ї §                   # $ % % ' ) * * 2 3 3 : ; ; B C C J K K њўўўIX\_`ehiotvxy‡цш№ѕћ $*/5:@E $+.0683žЉРбз“FхѕЋПшш   6 b b ƒ ™ ™ К е е §   [ p p † › › С С  . . / / b b c c ž ž І І Ў Ў Ж Ж О О Ц Ц Ю Ю ж ж ё ё     $ $ 2 2 : : B B J J | 'ќИ И ћ ћ Z Z … …  ! " ' , / 4 7 9 A D F Q T V [ ` c EЩЫеEгк№E\bpv}.5V Ў: ностуфхгжжммЗQ7ƒyЗ "xfЃ""ЗmЩ7 €з249;HKMOUWW\beffgloppv}€‚ˆ‹’˜›ŸЅЈЈЎЕИКМУЦЦGJJPSSY\\bginsvv}ЎБВВГКОПЧЬЭбееенрцшщщяђѓјћќќ§       % ( ) 1 5 6 > C D H N N N V Y ` b c c i l m r u v ~ ‚ ƒ   — ™ š Ё Ѓ Є Є Ѕ Ј Ј Ћ Ќ Ќ Џ Џ В Г Г З З К Л Л П С Ш Ы Ь Я е и л с ф ч э № ѕ ј ў        œ ž Ÿ Ÿ Є І Ї Ї Ќ Ў Џ Џ Д Ж З З М О П Ф Ц Ч Ь Ю Я д ж з н п п х ч ч М и џ  є   ' €f g щ5… ђ3:Aђ#MNŒа[сц$$~ƒŒЁЅ$ѓ і 5R R S S €2 ##+--//68GKPTY]bnuvw}тфшъэяѓѕјњбгдееH L M N N †–†Ž™џn q t € … џЪ œ БнgМРйg l n 1№ѕћ $*/5:@E259<HMNPUW]chmopw~ƒ‰‹Œ“™ ІЈЏЖНФЦџ ­АТУЫЬџ'?Ш №їБМ з џ  ѓ   & Hн Т Dџџ5 @‘F 1‘- 2y’: @џџ2 “R @ ‡‹c 1 ‡‹o @… 1…Š @ {› 1{Ї @ qvе 1qvЗ @#jo# 1&joЬ @*bhF 1-bhу @1Z`c 14Z`њ @8RX 1;RX @?IP& 1BIP1 @FAG› 1IAGH @M9?_ 1P9?k P$6ф 1S%6{@ T%‘@ U%­@ V%Ъ@0@!Y%')Ъ 1\&')Ъ@0@`&"%Ъ@0@b& р@0@e&.2і@0f&44 @0g&55% @(k&е 1m'Ы @џџn'  (   !"#$%& '5є§ўўЂЫ•s5є§ўўЂЫ•s5є§ўўЂЫ•s5є§ўўЂЫ•sї 3ўOўlўЂЫžўЌўКўЯўкўхўЂЫžўЌў5ѓўџ8џЂЫžўЌў5ѓўџ8џЂЫžўЌў5ѓўџ8џЂЫžўЌў5ѓўџ8џЂЫžўЌў5ѓўџ8џЂЫžўЌў5ѓўџ8џЂЫžўЌўЂЫžўЌўvџ’џ—џЂЫœџХџЂЫыџќџЂЫ 1ЂЫї Om’џ—џї ‡’žЂЫ•sЂЫw—–—п"5:;<BCDJKLSTU[\]cdekllnrss"#ln€.P€а‚{||‚‚‡ˆˆŽŽ #**115>>OOa•ё9 I€")**.01<>>DFLNOOUW]_egsu|~‚„ˆŠŽщj :“к"49;<ACDIKLRTUZ\]bdejllnqss+м #**004>>NNOOЫ')()#l| \;>>CFKNOOTW\_dgsu|~‚„ˆŠŽф"));<CDKLTU\]delnssєЭ# –е.01su "#ln-y:01*p Dџџ$ DџџEEЂ• n~Д•@4nn—• [lц @4[[: @џџ2 =A: @џџ2 G€Ф•@ hhФ•@ ggл•@ iiѓ•@ {{ѓ•@ zz–@ ||Ž• IYц @4II>–@VV>–@UUQ–@WW  @џџ*9e–@,,{–H--’–H ..Љ–H#//Л–H&00Ы–H(11п–4)33ђ–4*44—-55—0662—477H—788%•@џџ8((• @џџ8#&c—@0!9$$|—@0!:%%фQ D;;??фQ D;<??ы” @џџ=     $%"#ЂЫЋ~У~ЂЫо~0+ЂЫЂЫ!ЂЫoњ0+ЂЫЂЫCYЂЫr0+ЂЫЂЫ5”Љ5”Љ‡ђ”Љј$Оћј$Ђ€ЂЫ”Љ€”Љј$'€9€]€ї †€’€Ё€ЂВ€Х€Х€ЂЫ4wСgˆБ •%р-./0156LORUVW^adghiqtwz{|•$i•4‰K]pЩq˜­Љ LMU^_gqrzŒЁЂЕЖЂ• nqttwz{{|БЕВ –Ћы”;•-./56|%•(0­ Х  -./0178I[nі”F•07~•8Ž• ILOORUVVWˆŒ‘ЖІО f4;џ”?•/—•[^aadghhinruЁІВЖСяZ0пqŒ‘ЁІ? OPabtu•#%(07X•1И a•3aРё9=G…jњ78 :A€КŠxs•7Г Ѓ  *,-./556678?  IMP[_b‰žЂl Dџџьr Dџџ# Dџџд DџџI˜  ln˜@4 mm: @џџ2 : @џџ2/ŽГ˜@ ppژ@ qrф˜@ ssќ˜@0@„‡ќ˜@0@ ‚ќ˜@0@ z}ќ˜@0@ux™H0@‰ŒF™ Ag_™@4CCZ˜ 1Ags™@ GKœ™ 1GKН™@ JJэ™@0@Xaэ™@0@MVš@0@ cf5š #4>˜ 1%4>§—'11Aџџ-+-,Aџџ3')<Aџџ9#%KAџџ?!р— ? Kš@0 @=˜ @џџA-˜ @џџC˜ @џџE№— @џџFз— @џџG      !1w™Зrmqр— $(,1№—U`‘˜’рXcuz„‰р5@R„‰‹”№qR]а‚459ACMMQUUXX\``cc0mJљ—I˜lpuz„щ/I€z{mq)mHЛ#Q\ AR]{C MOPQUXZ[\`>!%д‚CMMXXcc§—1-˜e“=˜”э!##Э# ˜Э9il:  $(,R]ЖmMXc˜™пq)-Or’’““_x<И#€pzXGJШmca—ё9 /Z˜BJimqjњ5M :Žs  $(,cC„…sгmMX˜5| Ќ~579<ce€м R]ьMXc%55^еt…‹Ю#'+1Ўmrv{€…з—Гš Dџџ Dџџ*p DџџяЂ @ѓњ: @џџ2ћяЂ @щ№ћЂ @нцхЂ 1 нц Ѓ @ ек Ѓ @% ЭвЃ @ , ПЪгЂ 1. ПЪо< .&9Л)Ѓ@ /&<<<Ѓ@ 0&==PЃ@ 1&>>bЃ@ 2&??uЃB 7&BBuЃB ;&AAЃB >&CCЅЃB C&DDРЃ@0@ G&PXРЃ@0@ J&FNгЃ@0@ L&Z]чЃ@0@ P&_dњЃH0@ R&fi ЄH0@ T&kn ЄH0@ V&ps4ЄH0@ X&uxFЄH0@ Z&z}ZЄH0@ \&‚oЄH0@ ^&„‚ЄH0@ `&‘ž—ЄH0@ b& ЃЋЄH0@ d&ЅЈОЄH0@ f&Њ­жЄ4 g&ЕЕцЄ4 h&ЗЗіЄ4 i&ИИЅ4 j&ЙЙЅ4 k&КК#Ђ k,24Ѕ@0@)n,4Ѕ@0@)q,GЅ@0@)s,"[Ѕ@0@)v,$)pЅH0@)x,+.‚Ѕ4)y,11Јš @џџz,   )   !"#$%&'(*+,-./3єп‰№‰ŠŠ-Š”†3єTŠbŠ oŠ-ŠД‡3єЫ€‚Šc€ŠЄŠФŠЂЫ=s‡ђ‹‹ŠŠ-Šр†‡ђя   oŠ-Šє‡‡ђN€5‹c€ŠЄŠI‹ЂЫ=s™‹Љ‹К‹Щ‹ї 틇ђј$э‹ї н‹ј$Œї н‹4ŒGŒн‹‡ђј$э‹ЂЫWŒ^ŒъЂЫoŒ0+ЂЫGŒWŒ^ŒъY~†ŒžŒЗŒЮŒмŒј$ј$ј$ј$‡ђєŒY~Y~Y~Y~ЂЫЂЫ6{[ЂЫEЂЂЂЫQчqbЂz08ф№qLVpРФФХЧЩЭбейоуффъъяєєљYЂDcKЂC\Є;HRэ‘LVbэ я]Ё=ЂABMWнЂЯбзйэяїљЭ# 78МўЭ99&Œ™ЖGQА:?Ж<HRЕЏ| ==pŸ kmoЂPW_cМўџ_x!Š—ЈšЈ prhЁ„†ЈЂ X ъєxСФФХЧЩЮбжйптфьяіљqЁ‘“a §/zё9с;Еj  <<kТЯзрэїК ЊЌjЂ FKMPUW_acšЂ‰ŒŒЗj њ!ъєz9ABCD :ћ#Ђ $$'??гЂРЭе<Г ПРРССнооппфф,Ђ!&&'-1| 7Ќ~ †‡‰Š“”–—ќ СФЩЮбжйптьяіљ5Ђ+хЂощѓЅффе# 8ѕРФЩЭбейоуфъыяєѕљеtŒ™оыѕо<9ABCDDFPZ_‰–ТЯзрэї— >>uЧЂЙw џw!РЭеощѓ Ёй Ђ–™™Ир$+FPZ_fkpuz„‘ ЅЊ@RfЗИЙК)ЁљI€$&'В uwrЂ_ВЂЅ{ЂfЛЂГЛотущѓ{Cтуфхф б„ЂhКїо Dџџ› DџџZ DџџЁ@џџxx|Ё@џџ rtqЁ@џџ qqhЁ@џџpp]Ё@џџooSЁ@џџhhIЁ@џџgg=Ё@џџef2Ё@џџ"dd)Ё@џџ)`b Ё@џџ0^_Ё@џџ6\]Ё@џџ:[[Ё@џџ>ZZэ @џџEWYф @џџLUVн @џџQSTз @џџVRRб @џџ[QQШ @џџbOPК @џџdMMВ @џџfKKЈ @џџhJJŸ @џџjII—  @џџjBFŸЁ@0kDDЎЁ@0lEE  @џџl:@НЁ@0m<<ЮЁ@0n==пЁ@0o>>ёЁ@0p??j  @џџp48Ђ@0#q66Ђ@0#r77c  @џџs22W  @џџt11O  @џџu00D  @џџv//8  @џџw../  @џџx--$  @џџy,,  @џџ{++  @џџ|))   @џџ}((  @џџ~''њŸ @џџ&&яŸ @џџ€%%уŸ @џџ$$кŸ @џџ‚##ЯŸ @џџƒ""ШŸ @џџ„!!ФŸ @џџ…РŸ @џџ†МŸ @џџ‡ИŸ @џџˆДŸ @џџ‰АŸ @џџŠЌŸ @џџ‹ЈŸ @џџŒŸŸ @џџ›Ÿ @џџŽћš @џџ !"$%&‹ђэ*3єFё…ј$­…ЂИ…FёFёЂACACђ…†ACACђ…†]6]6]6ж<ђ…"†гOACђ…†3єb†t†]6]6ƒ†”†‡ђ]6]6]6]6ƒ†р†‡ђFёAC8‡D‡T‡‡ђ‡ђђ…‡‡ђ‡ђђ…‡3є™‡Ј‡ј$ј$ƒ†Д‡‡ђј$ј$ј$ј$ƒ†є‡жПј$Fœй@ˆœKј$Fœй@ˆ’Рј$Fœй@ˆ‡ђЖђј$3є8‡D‡_ˆ‡ђ ˆЈˆВˆžL‹ђžL‹ђЛˆ‡ђžL‹ђЩˆпˆѕˆ‰‰2‰E‰Z‰ђm‰ИТo‰Ž…v‰‰‰–‰–…Ё‰І‰­‰Д‰Л‰Т‰Щ‰а‰й‰ˆ…ЂЫo'АŸ ?y 7=EiY:lљ=P\y\yp 'ДŸд O”\н S=Ёe]Ёo†ЁssfQRSЯŸ",яŸ%// -O 0Ёx|˜›'ИŸ8 .8 \X XaСsta {С\j 48IVY_bj j:nwŠ\s 6<DSЁhЌŸМŸќ XXaa|Ёr| L: )2ЁZ^›"~›%Ё[~++оYbt> sЮKO\ž\W›!W 1— BFKP]з RЁ\w |—9IJMQRSUWZ[^`deghРŸ Ё^€\i›#‰›&  (1‰ >)Ё`IЁg .xЉ\ ftr›$В K2Ёdђ3IJMQRSUWZ[^`deghћš›Ÿ +,-./012ЛtЛOW`rsФŸ$ ,D /ф Uэ Wі XYabv:juyЖ\ŸŸ  :@JZ[dfghŸ IџopqrhЈŸШŸ!Ј JШ OhЁpб QqЁqБкŸ#-њŸ&0К Mњ!XaЃŸуŸ$.c 2И Dџџž@џџppџ@џџooъ@џџ nnн@џџ kkЮ@џџjjК@џџiiЏ@џџhhЅ@џџgg‘@џџff/ @џџ:Mž@0 ;;2ž@0 <<Gž@0 ==Wž@0 >>nž@0  ??…ž@0 !@@žž@0 "AAЗž@0 #BBЫž@0 $CCрž@0 %DDѕž@0 &EE Ÿ@0 'FFŸ@0 (GG4Ÿ@0 )HHJŸ@0 *II_Ÿ@0 +JJuŸ@0 ,KKˆŸ@0 -LLПœ @џџ.ccm @џџ/bbJ @џџ0aa( @џџ1`` @џџ2__ьœ @џџ3^^вœ @џџ4]]Ÿ› @џџ5NN˜› @џџ655‘› @џџ744‰› @џџ822~› @џџ911r› @џџ:00i› @џџ;//^› @џџ<..W› @џџ=--K› @џџ>   ї хЩк&aQn…ъ&ї хЩк&aQn…ъ&єђFёaQn…ъ‡ђЏСжFёFёFёFёFёFёFёFёFёFёу›?ѓ›@s gvМ›<\œGьœ^Œb|мCgjkopvœAЅgЅ\_Ѕ_rx^›.~›1Ў›;ЎœVWЮjoоjoW›-4œB‡œJЗœW_w€w/fghijv@œEi›/‰›25 .ijknopщЫUr›02œDвœ]fЭ @џџ##\Э @џџ""RЭ @џџ!!HЭ @џџ =Э @џџ2Э @џџ#Э @џџЭ @џџ Э @џџ Э @џџ ъ­ѕ­Ў Ў*V/VЎ4V9VЂЫИЭ!HЭ ­Хa 1AЅ\Н\ Э =Э ІОВ\Ц\Э.Э2Э#RЭ!fЭ#Г#Э"\Э"  Dџџ   Хі @4 ЦЦ: @џџ2 ї; @ ЩЩP @ ЪЪd @ ЫЫx @ ЬЬŒ @0@ гкŒ @0@ ЮбЁ @2@ моЗ H0@руШ @0@хшк @0@ъэщ H0@яђћ 4ѕѕљ –Т @4——8 @0@ŸІ8 @0@šO @2@ ЈЊg H0@"ЌЏy @0@%БДŒ @0@'ЖЙœ H0@)ЛОЏ 4*ССю *#j“С @4*#kkэ @0@.#~э @0@1#y|э @0@5#twэ @0@8#or @2@:#ƒ… H0@<#‡Š. @0@>#Œ> 4?#’’" ?@gP @$4?@~ @ $ ?D  & @DГ  & ADЪ  & BDт  & CDћ @ $DD @0@$HDjm @0@$MDdh @0@$QD?B @0@$UD8; @0@$ZD15 @0@$_D)- @0@$cD!' @0@$fD. @2@$hDEHJ @0@$kDJW_ @0@$mDY]q H0@$oD_b† :@$rDpЉ :@$uDЋЖЕ :@$wDИЧЭ :@$|DЩѓу :@$€Dѕљ 8@$†D9 8@$ˆD;F! $$ ˆE]_@  ? ‰E__W 4$ŠEaan 4$‹Ebb† 4$ŒEccž 4$EddЕ 4$ŽEeeЫ 4$Eff @џџE     $ !"#%&+,-./0123456789:;<=>?ABCDEF'()*@%uЇДЩeн\{Є­­ЎДКМНООФХбзмоџ|&“”?@fœLNRTvw‘˜Џ $=Edо8?y~о‚ЪЫЬЬбгежинухчщіїїџ  ЁЁЃдеезЉ Ьжнуї ЁеоЯечоPUaЂоUdЅOUbwћюjoty~ƒр(!)18?EJY_djpЋИЩѕ;oty~ƒ‡ŒšŸЈЌБЖЛЮгмрхъяр)18?_adjatŸЛгя „itгхIоГмiоPUœЂо5ђфЬбїџЁеЛ !e{C),148:?Adgjl%&***tu~ŸЃгз„—›Ђ’JLRБГхчФ pruЇЋ­ЎДД-˜–Bл Ыбжнуіџ э!*+.345Э# /06=>Cњ 5YŒŽЖИъьЭ9 €Щдзийккмсцшщъыыьюёђљ§   -оPUaattЂЄООТУЮЮЯнушьњњћ  Dv$ ХЮгмжЩдзцшљљЬ–t |€„ˆ‰ŠœЃMLNRTw=Eџ„„…†ˆЖ{|™шнuЇ_!%П€%&a~Ђ@Z /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__GMP_WITHIN_GMP/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/errorReport:prompt/D_M_X86 /Zi /errorReport:prompt /D_M_X86f\/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_gmp_gc\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Т…C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_gmp_gc\‹h  у оhс/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TP/errorReport:prompt/D_M_X86errorReport:prompt /D_M_X86ПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"k‚C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\мpрЎю 3qщ/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\gmpxx.pdb/W3/nologo/c/Wp64/ZI/TP/errorReport:prompt/D_M_X86errorReport:prompt /D_M_X86r[/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmpxx\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ws„C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmpxx\Ьu€”я !vЬ/Od/I..\..\\/I..\Win32\\/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TP/errorReport:prompt/D_M_X86eport:prompt /D_M_X86эvZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"GxƒC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_mpfr\ХЇhPї Ј)/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TP/errorReport:prompt/D_M_X86/Zi /TP /errorReport:prompt /D_M_X86CЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ЊƒC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\@ЌР’~ ™Ќн/Od/I..\..\\/I..\Win32\\/D_DEBUG/D_LIB/D_WIN32/DWIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/errorReport:prompt/D_M_X86errorReport:prompt /D_M_X86v­\/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp_gc\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"вЎ…C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp_gc\3АH0 ŠАЪ/O2/GL/I..\..\\/DWIN32/DNDEBUG/D_CONSOLE/D_UNICODE/DUNICODE/FD/EHsc/MD/FoWin32\Release\\/FdWin32\Release\vc80.pdb/W3/nologo/c/Wp64/TP/errorReport:prompt/D_M_X86eport:prompt /D_M_X86TБ[/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\gen-bases\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ЏВ„C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\gen-bases\3Г(ф ŠАЪ/O2/GL/I..\..\\/DWIN32/DNDEBUG/D_CONSOLE/D_UNICODE/DUNICODE/FD/EHsc/MD/FoWin32\Release\\/FdWin32\Release\vc80.pdb/W3/nologo/c/Wp64/TP/errorReport:prompt/D_M_X86eport:prompt /D_M_X86ŒГ\/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\gen-fac_ui\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"шД…C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\gen-fac_ui\mЕd‚ ŠАЪ/O2/GL/I..\..\\/DWIN32/DNDEBUG/D_CONSOLE/D_UNICODE/DUNICODE/FD/EHsc/MD/FoWin32\Release\\/FdWin32\Release\vc80.pdb/W3/nologo/c/Wp64/TP/errorReport:prompt/D_M_X86eport:prompt /D_M_X86РЕY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\gen-fib\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"З‚C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\gen-fib\›З х‚ ŠАЪ/O2/GL/I..\..\\/DWIN32/DNDEBUG/D_CONSOLE/D_UNICODE/DUNICODE/FD/EHsc/MD/FoWin32\Release\\/FdWin32\Release\vc80.pdb/W3/nologo/c/Wp64/TP/errorReport:prompt/D_M_X86eport:prompt /D_M_X86№ЗZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\gen-psqr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"JЙƒC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\gen-psqr\ЭЙhƒ (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86ЮЛb/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\assign\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"0Н‹C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\assign\ЛН0„ (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86Оb/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\binary\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"xП‹C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\binary\Р0Ž„ (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86ZР`/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\cast\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"КС‰C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\cast\CТ@… (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86 Тc/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\tdiv_ui\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ФŒC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\tdiv_ui\ФhА… (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86цФ`/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\tdiv\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"FЦ‰C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\tdiv\ЯЦ;† (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86*Чb/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\constr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ŒШ‹C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\constr\ЩpШ† (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86tЩc/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\headers\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"зЪŒC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\headers\cЫ0V‡ (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86ОЫb/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\locale\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727" Э‹C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\locale\ЋЭXт‡ (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86Юc/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\istream\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"kЯŒC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\istream\їЯЈsˆ (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86Nа`/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\misc\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Ўб‰C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\misc\7в ‰ (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86Œв_/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\ops\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ыгˆC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\ops\sд8‰ (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86адc/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\ostream\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"3жŒC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\ostream\Пж`Š (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86з`/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\prec\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"vи‰C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\prec\џиHЈŠ (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86Vй`/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\rand\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Жк‰C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\rand\?лp4‹ (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86œлc/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\ternary\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"џмŒC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\ternary\‹н˜Р‹ (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86фнa/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\unary\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"EпŠC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\unary\ЯпјMŒ (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86,рc/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\aorsmul\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"сŒC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\aorsmul\трнŒ (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86pт_/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\bit\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ЯуˆC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\bit\Wф`r (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86Ўф`/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\dive\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ц‰C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\dive\—цpŽ (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86єцc/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\dive_ui\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"WшŒC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\dive_ui\уш№‘Ž (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86@щc/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\convert\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ЃъŒC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\convert\/ы€) (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86‚ы^/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\io\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"рь‡C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\io\gэД (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86Рэa/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\logic\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"!яŠC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\logic\Ћя`C (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86№a/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\reuse\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"eёŠC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\reuse\дѓ в (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X861єc/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\cdiv_ui\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"”ѕŒC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\cdiv_ui\ іЈ\‘ (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86{іb/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\addsub\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"нї‹C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\addsub\hјpш‘ (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86Нј_/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\cmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"њˆC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\cmp\Єњ@x’ (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86§њa/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\cmp_d\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"^ќŠC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\cmp_d\шќ`“ (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86=§_/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\bin\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"œўˆC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\bin\$џp““ (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86џb/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\cmp_si\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"с‹C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\cmp_si\l,” (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86У`/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\cong\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"#‰C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\cong\ЌˆХ” (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86 e/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\cong_2exp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"rŽC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\cong_2exp\@T• (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86_d/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\div_2exp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"УC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\div_2exp\P`у• (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86Љa/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\divis\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727" ŠC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\divis\” ˆr– (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86ї f/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\divis_2exp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"] C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\divis_2exp\ь Ј— (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86G b/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\export\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Љ‹C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\export\4’— (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86b/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\fac_ui\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ё‹C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\fac_ui\|и!˜ (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86г`/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\fdiv\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"3‰C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\fdiv\МјА˜ (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86c/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\fdiv_ui\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"|ŒC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\fdiv_ui\@™ (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86cb/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\fib_ui\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Х‹C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\fib_ui\P˜а™ (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86Ї`/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\fits\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"‰C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\fits\ fš (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86х_/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\gcd\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"DˆC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\gcd\ЬHѕš (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86'b/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\gcd_ui\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"‰‹C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\gcd_ui\h„› (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86ma/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\get_d\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Ю ŠC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\get_d\X!ˆœ (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86Л!f/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\get_d_2exp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"!#C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\get_d_2exp\А#ЈЂœ (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86 $b/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\get_si\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"m%‹C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\get_si\ј%3 (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86U&c/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\inp_str\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"И'ŒC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\inp_str\D(иФ (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86Ÿ(b/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\io_raw\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"*‹C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\io_raw\Œ*јSž (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86с*_/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\jac\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"@,ˆC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\jac\Ш, уž (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86-_/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\lcm\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"|.ˆC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\lcm\/ sŸ (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86e/e/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\lucnum_ui\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Ъ0ŽC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\lucnum_ui\X1и  (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86­1_/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\mul\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727" 3ˆC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\mul\”3ј’  (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86э3a/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\mul_i\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"N5ŠC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\mul_i\и5 "Ё (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X8656c/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\oddeven\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"˜7ŒC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\oddeven\$8@БЁ 8І/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86':c/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\perfsqr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Š;ŒC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\perfsqr\< LЂ (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86u<d/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\popcount\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"й=C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\popcount\f>€мЂ (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86Л>_/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\pow\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"@ˆC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\pow\Ђ@˜uЃ (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86љ@`/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\powm\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"YB‰C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\powm\тBHЄ (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86?Cc/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\powm_ui\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ЂDŒC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\powm_ui\.Eh”Є (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86Ed/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\pprime_p\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ёFC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\pprime_p\~Gш$Ѕ (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86еG`/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\root\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"5I‰C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\root\ОI(ЙЅ (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86J`/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\scan\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"uK‰C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\scan\ўKаJІ (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86WLa/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\set_d\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ИMŠC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\set_d\BN оІ (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86›Na/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\set_f\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ќOŠC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\set_f\†PШmЇ (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86сPb/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\set_si\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"CR‹C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\set_si\ЮRИЈ (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86+Sc/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\set_str\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ŽTŒC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\set_str\U’Ј (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86}Uf/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\sizeinbase\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"уVC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\sizeinbase\rWш!Љ (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86ЯWc/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\sqrtrem\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"2YŒC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\sqrtrem\ОYБЉ (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86Zc/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\hamdist\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"~[ŒC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\hamdist\ \ˆIЊ (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86e\b/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\import\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Ч]‹C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\import\R^акЊ (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86Ў^c/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\misc\printf\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"`ŒC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\misc\printf\`№nЋ (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86ї`b/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\misc\scanf\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Yb‹C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\misc\scanf\фbўЋ (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X869c]/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\bswap\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"–d†C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\bswap\eр‘Ќ (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86yea/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\constants\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"кfŠC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\constants\dgЈ%­ (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86Хgc/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\count_zeros\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"(iŒC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\count_zeros\ДiЙ­ (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86 j^/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\gmpmax\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ik‡C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\gmpmax\№kШNЎ (КІ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt/D_M_X86I /errorReport:prompt /D_M_X86Olb/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\hightomask\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Бm‹C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\hightomask\BDSUY[kmqs~Ÿc !џџЋ "џџя #џџ; $џџ‚ %џџЪ &џџ 'џџW %X~zE(џџ чX~zE)џџ\`}ЁЊЎщ *џџ1 +џџu ,џџЛ -џџ .џџH /џџ 0џџи 1џџ 2џџe 3џџБ 4џџј 5џџ< 6џџ‚ 7џџЯ 8џџ 9џџ] :џџ­ ;џџі <џџ>B)D=џџ> Ъї 2tБYD=џџ?N?=>$(*+-@Bhlru ЃЈЋЌЏБЙПТУЦсц#+35:<UWdfiluw…‡ŸЉЌЖИСЦезрт№ѓјњNPSUacfhkmpruwˆŠ’”ž BDGILNfhkmЮаухшъ.0|~ЙЛВДЗЙХЧ!#NTˆwœСШ0@KЪбЦМ„”&3C=џџ@HJMP Z> ­ЖсьЪ4,1F”&3C=џџAF ?L,@џ @џ @џ @џ @џ @џ @џ @џ @џ @џ @џ @џ @џ @џ @џ @џ @џ @џ @џ @џ @џ @џ @џ @џ @ џ @ џ @!џ @!џ @"џ @"џ !@"џ "@#џ #@#џ $@#џ %@$џ &@$џ '@$џ (@%џ )@%џ *@%џ +@&џ ,@&џ -@&џ .@'џ  ,.02гЪ†гб”&3C=џџBEF@HJNMN\"%(*<>UWX_prŒ’—п№.8?DMVZ\acfotwˆŠ‘“˜šŸЛРЭк!4AEЇИЩблфэѕќўЫЎ№?k”&3C=џџC:D•APCT8;@A_FIOU:BDGK7$&(+246<ŒЇ­ВДМОЦЭлоцшю№іјў ,.248:CEJLMOWYZ_lnvy‚†‘˜š›ŸЄІЌЎМОФЫЮажйсшъя№ђњќ "(*@JMORTѓGKлнсучщэђ_ЫюБЎ”&3C=џџB:тцїТЭЯёь”&3C=џџGB• *,029;CEGQVbjyy……Џ ]”&3C=џџAFmprgt~ ”&3C=џџBGў@ 9<=?KNadz|‹Ž”—АВОРЩЫзйнрфц’”№є  DGSWbmy|˜ЁЄЈЊJ 1у”&3C=џџDFў57 2#”&3C=џџAI ?QHџ Hџ Hџ Hџ Hџ Hџ Hџ Hџ Hџ Hџ Hџ Hџ Hџ Hџ Hџ Hџ Hџ Hџ Hџ Hџ Hџ Hџ Hџ  P2Х ”&3C=џџBH ? !'[]adhj’ЧЪЮауцъьNQUWъ=<89I”&3C=џџAK?8Jџ Jџ Jџ Jџ Jџ Jџ Jџ Jџ Jџ Jџ Jџ Jџ Jџ Jџ Jџ Jџ Jџ J џ J џ J џ J!џ J!џ J!џ J"џ J"џ J"џ J#џ J#џ J#џ J$џ !J$џ "J$џ #J%џ $J%џ %J%џ &J&џ 'J&џ (J&џ )J'џ *J'џ +J'џ ,J(џ -J(џ .J(џ /J)џ 0J)џ 1J)џ 2J*џ 3J*џ 4J*џ 5J+џ 6J+џ 7J+џ 8J,џ 9J,џ :J,џ .>i:§”&3C=џџBL~^J-468:GKMOT…ŽžЄІ­ЗЙСУбг$*.PUЊЊХ?Gkm™e~ŸЂІЈЎБХOž s> @”&3C=џџDK~,еX/Œ”&3C=џџN ]?S[#1CGY”&3C=џџAO M >?Nџ Nџ  _YA”&3C=џџBN "248@BF [’ія”&3C=џџBY? \!BEGJacdfž ЁЃОAOQU[‘“­ЦШђњ<>>BBFNy‰‹œЛУѓћ§ 4Swƒ QџџЩ Rџџ Sџџ` TџџЇ Uџџя Vџџ7 Wџџ~ XџџЫ Yџџ ZџџW [џџŸ \џџъ ]џџ7 ^џџ _џџУ `џџ  aџџO bџџ˜ cџџр dџџ. eџџƒО fџџЯО gџџ{ hџџЫ iџџ  jџџQ kџџ‘ lџџв mџџ nџџY oџџš pџџм qџџ# rџџ_ sџџž tџџр uџџ! vџџZ! wџџ˜! xџџз! yџџ" zџџR" {џџ“" |џџв" }џџ# ~џџJ# џџŒ# €џџЯ# џџ$ ‚џџU$ ƒџџ˜$ „џџм$ …џџ% †џџ]% ‡џџЂ% ˆџџт% ‰џџ!& Šџџa& ‹џџ & Œџџн& џџ' Žџџ[' џџ™' џџж' ‘џџ( ’џџU( “џџ–( ”џџж( •џџ) –џџS) —џџ’) ˜џџЮ) ™џџ* šџџM* ›џџ* œџџЭ* џџ + žџџG+ ŸџџŒ+  џџЬ+ Ёџџ, ЂџџN, Ѓџџ, ЄџџЭ, Ѕџџ - ІџџJ- Їџџ‡- ЈџџФ- Љџџ. Њџџ@. Ћџџ. ЌџџМ. ­џџњ. Ўџџ9/ Џџџx/ АџџЙ/ Бџџ1 Вџџ=1 Гџџ‚1 ДџџР1 Еџџќ1 Жџџ;2 Зџџz2 ИџџЖ2 Йџџє2 Кџџ23 Лџџr3 МџџВ3 Нџџђ3 Оџџ/4 Пџџo4 РџџЋ4 Сџџы4 Тџџ'5 Уџџc5 ФџџЃ5 Хџџп5 Цџџ6 Чџџ]6 Шџџ›6 Щџџл6 Ъџџ7 ЫџџZ7 Ьџџ™7 Эџџз7 Юџџ8 Яџџa9 аџџ9 бџџм9 вџџ: гџџX: дџџš: еџџн: жџџ; зџџ]; иџџœ; йџџо; кџџ< лџџa< мџџ < нџџт< оџџ"= пџџg= рџџЌ= сџџъ= тџџ)> уџџe> фџџЃ> хџџт> цџџ!? чџџ`? шџџЁ? щџџу? ъџџ@ ыџџ^@ ьџџ›@ эџџн@ юџџA яџџ]A №џџA ёџџоA ђџџB ѓџџ_B єџџ B ѕџџнB іџџC їџџ[C јџџšC љџџмC њџџD ћџџ_D ќџџžD §џџрD ўџџ E џџџ`E џџŸE џџсE џџ$F џџhF џџЊF џџэF џџ1G џџmG џџЌG  џџыG  џџ)H  џџlH  џџЋH  џџыH џџ*I џџkI џџЋI џџъI џџ'J џџeJ џџЅJ џџхJ џџ$K џџ`K џџK џџмK џџL џџ]L џџL џџмL џџM џџZM  џџ™M !џџиM "џџN #џџSN $џџ–N %џџиN &џџO 'џџXO (џџ”O )џџеO *џџP +џџSP ,џџ”P -џџаP .џџQ /џџRQ 0џџ’Q 1џџвQ 2џџR 3џџSR 4џџ’R 5џџЯR 6џџS 7џџPS 8џџS 9џџЯS :џџT ;џџPT <џџT =џџЬT >џџ U ?џџMU @џџ‹U AџџЩU BџџV`˜†~DCџџELMWXeCV DџџV EџџПV FџџўV Gџџ>W Hџџ}W IџџМW JџџљW KџџZ\‘“ЅЫЭљ;ikСУTz?УКP$)D9џџF:“У>mя ”&3C9џџB;N 9=?&,8;=?lvŸЁІЉмртшјќў)/69;DPX[my…‡ЅЏАМ6K—šž ЙФХбеиѕјќў%(йУ#"q”&3C9џџBM: #NUXZh…тм œP$)D<џџFFн)BУŒ$)D=џџF:SUў† >џџЈо.ymdWD?џџ@AF:IBD(F. !$%'Y[glx|ГКХЩешёџчо‚kо”&3C?џџB^? #%-/=?НПХЧвди";;VmrMуP”&3C?џџB?=JOR_g}фЉгФ”&3C?џџBC? ЃЇЇЋЕИтфТфB”&3C?џџBBbэd“”&3C?џџBLE ?( *04:?ACFHKMRT[bilrЧЩуцІэ $т”&3C?џџD RiёKGWD?џџGHЇaЈ?.$&RYЄІЉё Й”&3C?џџBF QТТщ&ђ96кY”&3C?џџIFЇїЂNvjђb_ь@”&3C?џџJHaKqsz•œj~ЏђZTмі”&3C?џџKI!Fz|ƒѓѕєђ<9й”&3C?џџLJžЇ5ѓ€oбм ”&3C?џџM@NOKP`zѓ”&3C?џџA;LQYПѓ# +”&3C?џџA: W]LNџ Nџ Nџ Nџ Nџ Nџ Nџ Nџ Nџ Nџ Nџ Nџ Nџ Nџ Nџ Nџ Nџ Nџ Nџ Nџ Nџ Nџ Nџ Nџ Nџ Nџ Nџ Nџ Nџ Nџ !Nџ  ўєSPЦm”&3C?џџPLБИEѕШ ”&3C?џџQ`OжнєіSV‹ѕЈцЙ”&3C?џџMHR[\ ] P]_ьютф Ё аѕ,(4К”&3C?џџSVQ &,@FX^pvˆŽЅЋПХзняѕљ і%2”&3C?џџMT U!RXW[ESШџ SШџ SШџ SШџ SШџ !SШџ  #%'028:@BGORYКЬЯг/?E^dnq^і`”&3C?џџBS &+-2ORTWлї/Sм”&3C?џџBS! %'ILSnp~€Ž˜ЂЅЛННПжнёірћ7І”&3C?џџWR\-;%ќOBЄ4”&3C?џџNSXYV\jќ0i”&3C?џџSWXfџ !i§&ўРU”&3C?џџMZPWBDIЉЩгђљй м   > J p s ѕ ј    ( + X ^ ` g i l n w { } ‚ ‡ Џ§*'nч”&3C?џџ?Ye~'=Н”&3C?џџMSEQ$[?џ %[?џ !KT]fpyƒМб€'GУ”&3C?џџAPWVQ •š„1,zB”&3C?џџ^NMQ АДр„Bв”&3C?џџ@_K] (….>ƒ”&3C?џџB^#)UXryЅ­ ”&3C?џџP8кHEд”&3C?џџIFЈb Ѕ ћїМ†–щTљєм ђМp§Иš|чќ?цТ?№­ўбќс/~юџ‡эк?яьКgР_ПџМXє№ЮнџзCаП И§џуШПЄџ?Л…rў„ф§ћЏ єџ0Іw§AОўЇm•џG" џ‡є|ў9ойѓўr „ЉF|‰ h}T;,ЂZ$‚8Я(’P+9ŒЩй”щDћL<л@ы"˜љ# r$%ќW'`g)H )œ /4П1+9ˆК9Є)Э,ЅЮ€œаP.б б€\еXMж(•еŒЬккмм$…н@юмLм”ьр uрDўт<от˜ќтм<р„^ъ]ы4ТыHёœ ђЄ,ѕXOі<ѕ`jљ ўєOџ„­ёD1В.]_}‰Н  j -І U?)–Q/Э ‘н YN%†Aя!vM Eџ•э"=п ™§'5У(…_*I0 4YP6Ѕ-7^:Ё;ak<]`=1Г>=;…Ў@}ŽEѕPFFн=H/H‰ОJ-ЇJevMU@QkR S)—RQ0RžUЮY‘оZ!wZM ]%‡]A№_YO`Ea9а]•юc !c5ФbэDf™ўg=рiёFi§YkIqYQqx…ЏxЁzЅ._}‚1ДƒQ…al†‡-Ј‰ew‹UA‹ѕQŽ Ž‰П0‘l’)˜’Q1”Ÿ”Я˜!x™M!š‘пš•я9бAёŸEЂ%ˆЃ5ХЅ­`ІэEЇ™џЉёGЋ "Ќ=сЋIЏ EАYRБЏ§ZЕЁЖ…АО}ПЅ/Р1ЕТУ`Ф-ЉШexЩRЪ ЩUBЩamЮ)™аѕRб вmвQ2в‰Реy€з!yи1иM"заз‘рм9ви•№оAђп5ЦсEт%‰ъ=Jъ=тъIы™я #ѓЁ єYSіњ…Бќ1Ж§ў}‘џЅ0 .ЊVCfy Ъ> a 2H*š‚ЁbnR3zN#Sn"z:гŠСŽбBѓ6Ч’с2–ё!&ŠіS$F&ђH'J(š)>у.>K4Ђ!6ZT7†В86ž8кa;$;2З;~’? @.Ћ?І1CVDKЪ?L‚ЂM*›ObP2IR"{SN$SR4SboRz‚TŠТX:дYoVŽвU’тV–ђ]6Ш^іT_Bє`Ta&‹e3e>фeJhFfšjђIe~[s>LvZUw v†Гy~“z2Иwž| }Ђ".ЌVE‚%ƒОf‚І2Š‚Ѓ*œЪ@zƒ‘^a’R5“"|’ŠУ”Žг–N%“’у˜c––ѓšp›6Щš:еšbp &Œ BѕЃ>хЃšЅJЇUЈо?ЊFЏђJБ4Д†ДЕ Ж2ЙЙZVК К~”М.­МžОЂ#ПVFТІ3Ч‚ЄЪ&Э*Эz„ЯОgЯR6в"}гЪAгŽдд’фжŠФж–єиN&и^bл6Ъмqн&н:жнBірdпbqт>цтšхJчо@эFяVђ†Еє є2Кі єђKј5јZWњ.Ўљ~•ќžћЂ$ўVGў†>Ї4ƒЅ +ž [P {…#~'S7е“х‹Х—ѕЫB7Ы'Ž;зCїO'_c!?ч#cr$K(›.e1G23Л1‡Ж4 5ѓL7W9/Џ9–9Ѓ%<6<[X>WH?У9@П7AŸBƒІEЇ5GG+ŸJ#KgzM{†MуAPS8RжT‹ЦW(XO(X“цZ7Ь['[Cј];и]_d_ЫC`?ш`KW—іfcsi›mGp‡Зr3Мs x/Аy—yЃ&{hzѓM}WI~X~[YƒЇŸ‚7‡Ї6Š{‡Œ#€Œ+ Žg{S9’П8“з”O)•‹Ч“У:™'™7ЭšCљœ;йKš“чš—ї )Ё?щ _eЈ›ЋctЌЌG Б‡ИВ3НЙ/БЙ˜ЙЃ'МWJО[ZПѓNРŸСƒЈШ{ˆЫYЬ+ЁЮg|Я8Я#ЯS:д‹ШеO*ж'‘з7ЮйУ;кил“шмCњмKо;клїUрћVт—ју?ъу_fшщ*щ›ыG яcuђ3Оє‡ЙљWKќЃ(§[[ў™$ЧWЏм/Od/I..\..\\/I..\Win32\\/D_DEBUG/D_LIB/D_WIN32/DWIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpn\\/FdWin32\Debug\mpn\\/W3/nologo/c/Wp64/Zi/errorReport:promptp64 /Zi /errorReport:promptv­\/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp_gc\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Ч‚ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"аP2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Й/Rmр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpq\\/FdWin32\Debug\mpq\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ЙX2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ЙZ2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Й Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ЙЃ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"‚WЏм/Od/I..\..\\/I..\Win32\\/D_DEBUG/D_LIB/D_WIN32/DWIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpn\\/FdWin32\Debug\mpn\\/W3/nologo/c/Wp64/Zi/errorReport:promptp64 /Zi /errorReport:promptv­\/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp_gc\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"‚WЏм/Od/I..\..\\/I..\Win32\\/D_DEBUG/D_LIB/D_WIN32/DWIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpn\\/FdWin32\Debug\mpn\\/W3/nologo/c/Wp64/Zi/errorReport:promptp64 /Zi /errorReport:promptv­\/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp_gc\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"‚1Rmр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpq\\/FdWin32\Debug\mpq\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"‚І Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"kI2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"]WЏм/Od/I..\..\\/I..\Win32\\/D_DEBUG/D_LIB/D_WIN32/DWIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpn\\/FdWin32\Debug\mpn\\/W3/nologo/c/Wp64/Zi/errorReport:promptp64 /Zi /errorReport:promptv­\/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp_gc\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"]%rlр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpf\\/FdWin32\Debug\mpf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"]6Rmр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpq\\/FdWin32\Debug\mpq\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"];2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"]A2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"]L2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"]_oц/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\printf\\/FdWin32\Debug\printf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"]• Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"#rlр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpf\\/FdWin32\Debug\mpf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"S2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"T2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"‚ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"˜WЏм/Od/I..\..\\/I..\Win32\\/D_DEBUG/D_LIB/D_WIN32/DWIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpn\\/FdWin32\Debug\mpn\\/W3/nologo/c/Wp64/Zi/errorReport:promptp64 /Zi /errorReport:promptv­\/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp_gc\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"˜!rlр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpf\\/FdWin32\Debug\mpf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"˜$rlр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpf\\/FdWin32\Debug\mpf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727":2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"” Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"a&rlр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpf\\/FdWin32\Debug\mpf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"a92nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"a<2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"сE2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Ъ škи/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ЪWЏм/Od/I..\..\\/I..\Win32\\/D_DEBUG/D_LIB/D_WIN32/DWIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpn\\/FdWin32\Debug\mpn\\/W3/nologo/c/Wp64/Zi/errorReport:promptp64 /Zi /errorReport:promptv­\/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp_gc\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"J#rlр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpf\\/FdWin32\Debug\mpf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"J-rlр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpf\\/FdWin32\Debug\mpf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Jeћsљ/Od/I..\\/I..\..\\/I..\..\mpn\generic/I..\Win32\\/D_WIN32/DWIN32/D_DEBUG/D_LIB/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TP/errorReport:prompt/Wp64 /Zi /TP /errorReport:promptr[/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmpxx\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Ъx Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"S)rlр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpf\\/FdWin32\Debug\mpf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"SN2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"SP2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"SR2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Sboц/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\printf\\/FdWin32\Debug\printf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"гŽ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"<WЏм/Od/I..\..\\/I..\Win32\\/D_DEBUG/D_LIB/D_WIN32/DWIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpn\\/FdWin32\Debug\mpn\\/W3/nologo/c/Wp64/Zi/errorReport:promptp64 /Zi /errorReport:promptv­\/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp_gc\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"М.rlр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpf\\/FdWin32\Debug\mpf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"МW2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727")H2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727")œ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"23Rmр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpq\\/FdWin32\Debug\mpq\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"В3Rmр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpq\\/FdWin32\Debug\mpq\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"'rlр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpf\\/FdWin32\Debug\mpf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"›6Rmр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpq\\/FdWin32\Debug\mpq\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"›@2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"M2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"› Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"›” Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"M*rlр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpf\\/FdWin32\Debug\mpf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Э*rlр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpf\\/FdWin32\Debug\mpf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Э,rlр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpf\\/FdWin32\Debug\mpf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"MU2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Эz Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"M{ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ж'rlр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpf\\/FdWin32\Debug\mpf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ж(rlр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpf\\/FdWin32\Debug\mpf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"жŠ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"VŽ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"V– Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ж– Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"? škи/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ПV2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"?\2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"П\2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ПЅ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"?І Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"WЏм/Od/I..\..\\/I..\Win32\\/D_DEBUG/D_LIB/D_WIN32/DWIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpn\\/FdWin32\Debug\mpn\\/W3/nologo/c/Wp64/Zi/errorReport:promptp64 /Zi /errorReport:promptv­\/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp_gc\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"‘јoф/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\scanf\\/FdWin32\Debug\scanf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"‘^oц/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\printf\\/FdWin32\Debug\printf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"њ.rlр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpf\\/FdWin32\Debug\mpf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"z2Rmр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpq\\/FdWin32\Debug\mpq\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"њ… Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"zЅ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"УWЏм/Od/I..\..\\/I..\Win32\\/D_DEBUG/D_LIB/D_WIN32/DWIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpn\\/FdWin32\Debug\mpn\\/W3/nologo/c/Wp64/Zi/errorReport:promptp64 /Zi /errorReport:promptv­\/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp_gc\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"CV2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"У| Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"C„ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Ќškи/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Ќ=2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ЌG2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Еškи/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ЕЁ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ž rlр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpf\\/FdWin32\Debug\mpf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"!rlр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpf\\/FdWin32\Debug\mpf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"<2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"žD2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"g=2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"p‡ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Yјoф/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\scanf\\/FdWin32\Debug\scanf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Y‘ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Ђ%rlр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpf\\/FdWin32\Debug\mpf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727""=2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727""˜ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"‹ WЏм/Od/I..\..\\/I..\Win32\\/D_DEBUG/D_LIB/D_WIN32/DWIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpn\\/FdWin32\Debug\mpn\\/W3/nologo/c/Wp64/Zi/errorReport:promptp64 /Zi /errorReport:promptv­\/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp_gc\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"‹U2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"82nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"N2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"”O2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"P2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"”P2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"” Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Œ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"”Œ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"” Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"”Ž Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"“ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"§škи/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"}W2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"§[2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"}  Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"}Ђ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Fškи/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"/4Rmр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpq\\/FdWin32\Debug\mpq\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Џœ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"8škи/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"V2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Ÿ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ъWЏм/Od/I..\..\\/I..\Win32\\/D_DEBUG/D_LIB/D_WIN32/DWIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpn\\/FdWin32\Debug\mpn\\/W3/nologo/c/Wp64/Zi/errorReport:promptp64 /Zi /errorReport:promptv­\/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp_gc\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ъ=2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ъI2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"jœ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"sškи/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ѓЁ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"мrlр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpf\\/FdWin32\Debug\mpf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"м$rlр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpf\\/FdWin32\Debug\mpf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"м92nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"мC2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"мK2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"мL2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"\ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"м” Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ЅJ2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Ž škи/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"*rlр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpf\\/FdWin32\Debug\mpf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Žgћsљ/Od/I..\\/I..\..\\/I..\..\mpn\generic/I..\Win32\\/D_WIN32/DWIN32/D_DEBUG/D_LIB/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TP/errorReport:prompt/Wp64 /Zi /TP /errorReport:promptr[/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmpxx\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Ž‰ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727" škи/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"WЏм/Od/I..\..\\/I..\Win32\\/D_DEBUG/D_LIB/D_WIN32/DWIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpn\\/FdWin32\Debug\mpn\\/W3/nologo/c/Wp64/Zi/errorReport:promptp64 /Zi /errorReport:promptv­\/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp_gc\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"јoф/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\scanf\\/FdWin32\Debug\scanf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Š Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Ž Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"`škи/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"`WЏм/Od/I..\..\\/I..\Win32\\/D_DEBUG/D_LIB/D_WIN32/DWIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpn\\/FdWin32\Debug\mpn\\/W3/nologo/c/Wp64/Zi/errorReport:promptp64 /Zi /errorReport:promptv­\/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp_gc\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"рWЏм/Od/I..\..\\/I..\Win32\\/D_DEBUG/D_LIB/D_WIN32/DWIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpn\\/FdWin32\Debug\mpn\\/W3/nologo/c/Wp64/Zi/errorReport:promptp64 /Zi /errorReport:promptv­\/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp_gc\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"р rlр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpf\\/FdWin32\Debug\mpf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"`?2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"рD2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"`E2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"`K2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ЩWЏм/Od/I..\..\\/I..\Win32\\/D_DEBUG/D_LIB/D_WIN32/DWIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpn\\/FdWin32\Debug\mpn\\/W3/nologo/c/Wp64/Zi/errorReport:promptp64 /Zi /errorReport:promptv­\/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp_gc\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ЩU2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Щaoц/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\printf\\/FdWin32\Debug\printf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"R škи/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"вјoф/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\scanf\\/FdWin32\Debug\scanf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"R"rlр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpf\\/FdWin32\Debug\mpf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"в"rlр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpf\\/FdWin32\Debug\mpf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"RQ2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"вQ2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Rz Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"R Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"в‰ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"R Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727";WЏм/Od/I..\..\\/I..\Win32\\/D_DEBUG/D_LIB/D_WIN32/DWIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpn\\/FdWin32\Debug\mpn\\/W3/nologo/c/Wp64/Zi/errorReport:promptp64 /Zi /errorReport:promptv­\/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp_gc\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ЛWЏм/Od/I..\..\\/I..\Win32\\/D_DEBUG/D_LIB/D_WIN32/DWIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpn\\/FdWin32\Debug\mpn\\/W3/nologo/c/Wp64/Zi/errorReport:promptp64 /Zi /errorReport:promptv­\/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp_gc\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727";2Rmр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpq\\/FdWin32\Debug\mpq\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727";aoц/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\printf\\/FdWin32\Debug\printf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727";~ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727";… Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727" škи/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727".rlр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpf\\/FdWin32\Debug\mpf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"„| Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Ї Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"эF2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"mG2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"і WЏм/Od/I..\..\\/I..\Win32\\/D_DEBUG/D_LIB/D_WIN32/DWIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpn\\/FdWin32\Debug\mpn\\/W3/nologo/c/Wp64/Zi/errorReport:promptp64 /Zi /errorReport:promptv­\/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp_gc\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"іWЏм/Od/I..\..\\/I..\Win32\\/D_DEBUG/D_LIB/D_WIN32/DWIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpn\\/FdWin32\Debug\mpn\\/W3/nologo/c/Wp64/Zi/errorReport:promptp64 /Zi /errorReport:promptv­\/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp_gc\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"vZ2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"v† Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"і Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"_ rlр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpf\\/FdWin32\Debug\mpf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"п5Rmр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpq\\/FdWin32\Debug\mpq\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"_B2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"_D2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"пboц/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\printf\\/FdWin32\Debug\printf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"(š Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"(› Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Ј› Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"1WЏм/Od/I..\..\\/I..\Win32\\/D_DEBUG/D_LIB/D_WIN32/DWIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpn\\/FdWin32\Debug\mpn\\/W3/nologo/c/Wp64/Zi/errorReport:promptp64 /Zi /errorReport:promptv­\/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp_gc\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"БWЏм/Od/I..\..\\/I..\Win32\\/D_DEBUG/D_LIB/D_WIN32/DWIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpn\\/FdWin32\Debug\mpn\\/W3/nologo/c/Wp64/Zi/errorReport:promptp64 /Zi /errorReport:promptv­\/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp_gc\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"1G2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"1‡ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Б‡ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Б Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727" WЏм/Od/I..\..\\/I..\Win32\\/D_DEBUG/D_LIB/D_WIN32/DWIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpn\\/FdWin32\Debug\mpn\\/W3/nologo/c/Wp64/Zi/errorReport:promptp64 /Zi /errorReport:promptv­\/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp_gc\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"šјoф/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\scanf\\/FdWin32\Debug\scanf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"%rlр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpf\\/FdWin32\Debug\mpf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"7Rmр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpq\\/FdWin32\Debug\mpq\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"š:2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"šC2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"_oц/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\printf\\/FdWin32\Debug\printf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"šboц/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\printf\\/FdWin32\Debug\printf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"š‘ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"š“ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"š• Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"š— Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"c WЏм/Od/I..\..\\/I..\Win32\\/D_DEBUG/D_LIB/D_WIN32/DWIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpn\\/FdWin32\Debug\mpn\\/W3/nologo/c/Wp64/Zi/errorReport:promptp64 /Zi /errorReport:promptv­\/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp_gc\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"c5Rmр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpq\\/FdWin32\Debug\mpq\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"у?2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"у_oц/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\printf\\/FdWin32\Debug\printf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"c˜ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Ь+rlр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpf\\/FdWin32\Debug\mpf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ЬT2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Lhћsљ/Od/I..\\/I..\..\\/I..\..\mpn\generic/I..\Win32\\/D_WIN32/DWIN32/D_DEBUG/D_LIB/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TP/errorReport:prompt/Wp64 /Zi /TP /errorReport:promptr[/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmpxx\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"L‚ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"U$rlр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpf\\/FdWin32\Debug\mpf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"U(rlр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpf\\/FdWin32\Debug\mpf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"еO2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"еy Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"еŒ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"U Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"U’ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727">WЏм/Od/I..\..\\/I..\Win32\\/D_DEBUG/D_LIB/D_WIN32/DWIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpn\\/FdWin32\Debug\mpn\\/W3/nologo/c/Wp64/Zi/errorReport:promptp64 /Zi /errorReport:promptv­\/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp_gc\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727">W2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"О[2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"О} Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ОЂ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"‡-rlр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpf\\/FdWin32\Debug\mpf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"fєtи/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/ZI/TP/errorReport:prompt/ZI /TP /errorReport:promptr[/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmpxx\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"| Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"‡Ї Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"WЏм/Od/I..\..\\/I..\Win32\\/D_DEBUG/D_LIB/D_WIN32/DWIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpn\\/FdWin32\Debug\mpn\\/W3/nologo/c/Wp64/Zi/errorReport:promptp64 /Zi /errorReport:promptv­\/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp_gc\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"WЏм/Od/I..\..\\/I..\Win32\\/D_DEBUG/D_LIB/D_WIN32/DWIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpn\\/FdWin32\Debug\mpn\\/W3/nologo/c/Wp64/Zi/errorReport:promptp64 /Zi /errorReport:promptv­\/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp_gc\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727",rlр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpf\\/FdWin32\Debug\mpf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"boц/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\printf\\/FdWin32\Debug\printf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727" Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"љW2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"yX2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"y~ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"љ~ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"y Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"љ  Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"yЃ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Тškи/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Bƒ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ТІ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Ћ WЏм/Od/I..\..\\/I..\Win32\\/D_DEBUG/D_LIB/D_WIN32/DWIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpn\\/FdWin32\Debug\mpn\\/W3/nologo/c/Wp64/Zi/errorReport:promptp64 /Zi /errorReport:promptv­\/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp_gc\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Ћ4Rmр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpq\\/FdWin32\Debug\mpq\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ЋH2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ЋI2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Ћcoц/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\printf\\/FdWin32\Debug\printf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"4škи/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"4Y2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Д† Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"4Ђ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ДЄ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"škи/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"6Rmр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpq\\/FdWin32\Debug\mpq\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"92nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"A2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"A2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"K2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"L2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"fcoц/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\printf\\/FdWin32\Debug\printf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"f™ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"fš Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ЯWЏм/Od/I..\..\\/I..\Win32\\/D_DEBUG/D_LIB/D_WIN32/DWIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpn\\/FdWin32\Debug\mpn\\/W3/nologo/c/Wp64/Zi/errorReport:promptp64 /Zi /errorReport:promptv­\/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp_gc\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"OWЏм/Od/I..\..\\/I..\Win32\\/D_DEBUG/D_LIB/D_WIN32/DWIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpn\\/FdWin32\Debug\mpn\\/W3/nologo/c/Wp64/Zi/errorReport:promptp64 /Zi /errorReport:promptv­\/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp_gc\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Я#rlр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpf\\/FdWin32\Debug\mpf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ЯR2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ЯS2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"иWЏм/Od/I..\..\\/I..\Win32\\/D_DEBUG/D_LIB/D_WIN32/DWIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpn\\/FdWin32\Debug\mpn\\/W3/nologo/c/Wp64/Zi/errorReport:promptp64 /Zi /errorReport:promptv­\/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp_gc\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"X:2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"иM2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"иN2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"XO2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"и^oц/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\printf\\/FdWin32\Debug\printf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"X“ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"и• Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"!&rlр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpf\\/FdWin32\Debug\mpf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"!?2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Ё?2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Š{ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Š€ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Š‚ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"“"rlр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpf\\/FdWin32\Debug\mpf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"$rlр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpf\\/FdWin32\Debug\mpf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"z Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"“ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"“’ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"| škи/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ќ1Rmр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpq\\/FdWin32\Debug\mpq\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"|ˆ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ќž Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ќЃ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"E WЏм/Od/I..\..\\/I..\Win32\\/D_DEBUG/D_LIB/D_WIN32/DWIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpn\\/FdWin32\Debug\mpn\\/W3/nologo/c/Wp64/Zi/errorReport:promptp64 /Zi /errorReport:promptv­\/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp_gc\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"E| Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"E€ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"EЇ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727".WЏм/Od/I..\..\\/I..\Win32\\/D_DEBUG/D_LIB/D_WIN32/DWIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpn\\/FdWin32\Debug\mpn\\/W3/nologo/c/Wp64/Zi/errorReport:promptp64 /Zi /errorReport:promptv­\/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp_gc\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"7WЏм/Od/I..\..\\/I..\Win32\\/D_DEBUG/D_LIB/D_WIN32/DWIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpn\\/FdWin32\Debug\mpn\\/W3/nologo/c/Wp64/Zi/errorReport:promptp64 /Zi /errorReport:promptv­\/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp_gc\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"7WЏм/Od/I..\..\\/I..\Win32\\/D_DEBUG/D_LIB/D_WIN32/DWIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpn\\/FdWin32\Debug\mpn\\/W3/nologo/c/Wp64/Zi/errorReport:promptp64 /Zi /errorReport:promptv­\/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp_gc\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"7† Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"1Rmр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpq\\/FdWin32\Debug\mpq\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"]2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"  Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"щWЏм/Od/I..\..\\/I..\Win32\\/D_DEBUG/D_LIB/D_WIN32/DWIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpn\\/FdWin32\Debug\mpn\\/W3/nologo/c/Wp64/Zi/errorReport:promptp64 /Zi /errorReport:promptv­\/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp_gc\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"i› Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"щ› Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"r3Rmр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpq\\/FdWin32\Debug\mpq\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ђ3Rmр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpq\\/FdWin32\Debug\mpq\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ђ† Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ђЄ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"['rlр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpf\\/FdWin32\Debug\mpf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"л6Rmр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpq\\/FdWin32\Debug\mpq\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"[C2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"л“ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"$škи/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"$F2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"$K2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Є˜ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"*rlр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpf\\/FdWin32\Debug\mpf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727",rlр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpf\\/FdWin32\Debug\mpf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727" hћsљ/Od/I..\\/I..\..\\/I..\..\mpn\generic/I..\Win32\\/D_WIN32/DWIN32/D_DEBUG/D_LIB/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TP/errorReport:prompt/Wp64 /Zi /TP /errorReport:promptr[/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmpxx\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727" { Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"WЏм/Od/I..\..\\/I..\Win32\\/D_DEBUG/D_LIB/D_WIN32/DWIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpn\\/FdWin32\Debug\mpn\\/W3/nologo/c/Wp64/Zi/errorReport:promptp64 /Zi /errorReport:promptv­\/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp_gc\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727""rlр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpf\\/FdWin32\Debug\mpf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"–(rlр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpf\\/FdWin32\Debug\mpf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"–N2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"’ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"–– Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"WЏм/Od/I..\..\\/I..\Win32\\/D_DEBUG/D_LIB/D_WIN32/DWIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpn\\/FdWin32\Debug\mpn\\/W3/nologo/c/Wp64/Zi/errorReport:promptp64 /Zi /errorReport:promptv­\/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp_gc\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727".rlр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpf\\/FdWin32\Debug\mpf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"} Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ƒ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"џ„ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"џЅ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"HWЏм/Od/I..\..\\/I..\Win32\\/D_DEBUG/D_LIB/D_WIN32/DWIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpn\\/FdWin32\Debug\mpn\\/W3/nologo/c/Wp64/Zi/errorReport:promptp64 /Zi /errorReport:promptv­\/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp_gc\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Шeћsљ/Od/I..\\/I..\..\\/I..\..\mpn\generic/I..\Win32\\/D_WIN32/DWIN32/D_DEBUG/D_LIB/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TP/errorReport:prompt/Wp64 /Zi /TP /errorReport:promptr[/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmpxx\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Ш{ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"H‰ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"б WЏм/Od/I..\..\\/I..\Win32\\/D_DEBUG/D_LIB/D_WIN32/DWIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpn\\/FdWin32\Debug\mpn\\/W3/nologo/c/Wp64/Zi/errorReport:promptp64 /Zi /errorReport:promptv­\/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp_gc\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Qјoф/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\scanf\\/FdWin32\Debug\scanf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"б Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"К škи/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"К~ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727":Ё Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ƒWЏм/Od/I..\..\\/I..\Win32\\/D_DEBUG/D_LIB/D_WIN32/DWIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpn\\/FdWin32\Debug\mpn\\/W3/nologo/c/Wp64/Zi/errorReport:promptp64 /Zi /errorReport:promptv­\/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp_gc\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ƒ„ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"lH2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"uWЏм/Od/I..\..\\/I..\Win32\\/D_DEBUG/D_LIB/D_WIN32/DWIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpn\\/FdWin32\Debug\mpn\\/W3/nologo/c/Wp64/Zi/errorReport:promptp64 /Zi /errorReport:promptv­\/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp_gc\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ѕX2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ѕ`oц/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\printf\\/FdWin32\Debug\printf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"о;2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"^@2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"оA2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ЇWЏм/Od/I..\..\\/I..\Win32\\/D_DEBUG/D_LIB/D_WIN32/DWIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpn\\/FdWin32\Debug\mpn\\/W3/nologo/c/Wp64/Zi/errorReport:promptp64 /Zi /errorReport:promptv­\/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp_gc\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"'5Rmр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpq\\/FdWin32\Debug\mpq\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"'J2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"'`oц/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\printf\\/FdWin32\Debug\printf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Ї™ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"АY2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"0 Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"™'rlр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpf\\/FdWin32\Debug\mpf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"™7Rmр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpq\\/FdWin32\Debug\mpq\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"™M2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727" Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"‘ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"– Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"т%rlр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpf\\/FdWin32\Debug\mpf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"т<2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"т>2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"т— Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"т˜ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"тš Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ЫWЏм/Od/I..\..\\/I..\Win32\\/D_DEBUG/D_LIB/D_WIN32/DWIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpn\\/FdWin32\Debug\mpn\\/W3/nologo/c/Wp64/Zi/errorReport:promptp64 /Zi /errorReport:promptv­\/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp_gc\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Ыјoф/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\scanf\\/FdWin32\Debug\scanf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Kgћsљ/Od/I..\\/I..\..\\/I..\..\mpn\generic/I..\Win32\\/D_WIN32/DWIN32/D_DEBUG/D_LIB/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TP/errorReport:prompt/Wp64 /Zi /TP /errorReport:promptr[/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmpxx\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"TŠ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"T‹ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"д‹ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"TŒ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"д’ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"=1Rmр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpq\\/FdWin32\Debug\mpq\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"†škи/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"я WЏм/Od/I..\..\\/I..\Win32\\/D_DEBUG/D_LIB/D_WIN32/DWIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpn\\/FdWin32\Debug\mpn\\/W3/nologo/c/Wp64/Zi/errorReport:promptp64 /Zi /errorReport:promptv­\/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp_gc\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"яWЏм/Od/I..\..\\/I..\Win32\\/D_DEBUG/D_LIB/D_WIN32/DWIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpn\\/FdWin32\Debug\mpn\\/W3/nologo/c/Wp64/Zi/errorReport:promptp64 /Zi /errorReport:promptv­\/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp_gc\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"o4Rmр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpq\\/FdWin32\Debug\mpq\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"яcћsљ/Od/I..\\/I..\..\\/I..\..\mpn\generic/I..\Win32\\/D_WIN32/DWIN32/D_DEBUG/D_LIB/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TP/errorReport:prompt/Wp64 /Zi /TP /errorReport:promptr[/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmpxx\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"яё3ђЁ/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/Za/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt /Wp64 /ZI /errorReport:prompt№a/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\reuse\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"јWЏм/Od/I..\..\\/I..\Win32\\/D_DEBUG/D_LIB/D_WIN32/DWIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpn\\/FdWin32\Debug\mpn\\/W3/nologo/c/Wp64/Zi/errorReport:promptp64 /Zi /errorReport:promptv­\/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp_gc\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"x/rlр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpf\\/FdWin32\Debug\mpf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"јZ2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"x… Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"xЁ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Сƒ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"С„ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"AŸ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ЊF2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"*I2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Г`oц/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\printf\\/FdWin32\Debug\printf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727";2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"œ;2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"B2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"C2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"D2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"L2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"O2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"• Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"eWЏм/Od/I..\..\\/I..\Win32\\/D_DEBUG/D_LIB/D_WIN32/DWIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpn\\/FdWin32\Debug\mpn\\/W3/nologo/c/Wp64/Zi/errorReport:promptp64 /Zi /errorReport:promptv­\/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp_gc\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"e>2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"eJ2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"хJ2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Ю)rlр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpf\\/FdWin32\Debug\mpf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"N,rlр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpf\\/FdWin32\Debug\mpf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Юgћsљ/Od/I..\\/I..\..\\/I..\..\mpn\generic/I..\Win32\\/D_WIN32/DWIN32/D_DEBUG/D_LIB/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TP/errorReport:prompt/Wp64 /Zi /TP /errorReport:promptr[/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmpxx\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Ю€ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"WWЏм/Od/I..\..\\/I..\Win32\\/D_DEBUG/D_LIB/D_WIN32/DWIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpn\\/FdWin32\Debug\mpn\\/W3/nologo/c/Wp64/Zi/errorReport:promptp64 /Zi /errorReport:promptv­\/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp_gc\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"WWЏм/Od/I..\..\\/I..\Win32\\/D_DEBUG/D_LIB/D_WIN32/DWIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpn\\/FdWin32\Debug\mpn\\/W3/nologo/c/Wp64/Zi/errorReport:promptp64 /Zi /errorReport:promptv­\/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp_gc\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"з!rlр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpf\\/FdWin32\Debug\mpf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"з7Rmр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpq\\/FdWin32\Debug\mpq\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"з Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"з‘ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"W— Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727" WЏм/Od/I..\..\\/I..\Win32\\/D_DEBUG/D_LIB/D_WIN32/DWIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpn\\/FdWin32\Debug\mpn\\/W3/nologo/c/Wp64/Zi/errorReport:promptp64 /Zi /errorReport:promptv­\/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp_gc\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727" &rlр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpf\\/FdWin32\Debug\mpf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727" <2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727" B2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727" E2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727" _oц/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\printf\\/FdWin32\Debug\printf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727" ™ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727" WЏм/Od/I..\..\\/I..\Win32\\/D_DEBUG/D_LIB/D_WIN32/DWIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpn\\/FdWin32\Debug\mpn\\/W3/nologo/c/Wp64/Zi/errorReport:promptp64 /Zi /errorReport:promptv­\/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp_gc\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727" +rlр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpf\\/FdWin32\Debug\mpf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"‰eћsљ/Od/I..\\/I..\..\\/I..\..\mpn\generic/I..\Win32\\/D_WIN32/DWIN32/D_DEBUG/D_LIB/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TP/errorReport:prompt/Wp64 /Zi /TP /errorReport:promptr[/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmpxx\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727")rlр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpf\\/FdWin32\Debug\mpf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"’)rlр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpf\\/FdWin32\Debug\mpf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Q2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"’Q2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"R2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"’R2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"’Š Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727" Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"{јoф/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\scanf\\/FdWin32\Debug\scanf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ћЂ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Ф-rlр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpf\\/FdWin32\Debug\mpf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"­WЏм/Od/I..\..\\/I..\Win32\\/D_DEBUG/D_LIB/D_WIN32/DWIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpn\\/FdWin32\Debug\mpn\\/W3/nologo/c/Wp64/Zi/errorReport:promptp64 /Zi /errorReport:promptv­\/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp_gc\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Ж2Rmр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpq\\/FdWin32\Debug\mpq\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"6Z2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Ж… Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"6ž Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"6Ѕ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"WЏм/Od/I..\..\\/I..\Win32\\/D_DEBUG/D_LIB/D_WIN32/DWIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpn\\/FdWin32\Debug\mpn\\/W3/nologo/c/Wp64/Zi/errorReport:promptp64 /Zi /errorReport:promptv­\/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp_gc\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ŸWЏм/Od/I..\..\\/I..\Win32\\/D_DEBUG/D_LIB/D_WIN32/DWIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpn\\/FdWin32\Debug\mpn\\/W3/nologo/c/Wp64/Zi/errorReport:promptp64 /Zi /errorReport:promptv­\/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp_gc\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"@2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ŸE2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"шškи/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"hF2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"qY2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ёœ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"q Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"кškи/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Z!rlр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpf\\/FdWin32\Debug\mpf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Z7Rmр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpq\\/FdWin32\Debug\mpq\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ZM2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"к Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"к Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Z” Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"# rlр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpf\\/FdWin32\Debug\mpf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Ѓ5Rmр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpq\\/FdWin32\Debug\mpq\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Ѓ>2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"#coц/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\printf\\/FdWin32\Debug\printf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Ѓš Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Œškи/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727" škи/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727" јoф/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\scanf\\/FdWin32\Debug\scanf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Œ#rlр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpf\\/FdWin32\Debug\mpf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Œ+rlр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpf\\/FdWin32\Debug\mpf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727" -rlр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpf\\/FdWin32\Debug\mpf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727" U2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"(rlр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpf\\/FdWin32\Debug\mpf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"‹ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"•‹ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727" Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"— Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ў†?‡/Od/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\/IC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests/DWIN32/D_DEBUG/D_CONSOLE/DWANT_ASSERT/D_UNICODE/DUNICODE/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\vc80.pdb/W3/nologo/c/Wp64/ZI/errorReport:prompt /Wp64 /ZI /errorReport:prompt…_/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpf\add\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"~WЏм/Od/I..\..\\/I..\Win32\\/D_DEBUG/D_LIB/D_WIN32/DWIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpn\\/FdWin32\Debug\mpn\\/W3/nologo/c/Wp64/Zi/errorReport:promptp64 /Zi /errorReport:promptv­\/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp_gc\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ўV2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"~[2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"~\2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ў} Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ў Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"Gškи/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"G+rlр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpf\\/FdWin32\Debug\mpf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"PS2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"PT2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"9/rlр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpf\\/FdWin32\Debug\mpf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"9 Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"9ˆ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"9Ѓ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"9Є Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"WЏм/Od/I..\..\\/I..\Win32\\/D_DEBUG/D_LIB/D_WIN32/DWIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpn\\/FdWin32\Debug\mpn\\/W3/nologo/c/Wp64/Zi/errorReport:promptp64 /Zi /errorReport:promptv­\/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp_gc\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"} Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"„ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ы4Rmр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpq\\/FdWin32\Debug\mpq\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ыG2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ыH2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"ы™ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"єškи/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"є2Rmр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpq\\/FdWin32\Debug\mpq\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"єY2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"є‡ Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"н&rlр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpf\\/FdWin32\Debug\mpf\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"н:2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"н@2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"нB2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"S2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"T2nр/Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_LIB/D_WIN32/DHAVE_CONFIG_H/D_MBCS/Gm/EHsc/RTC1/MTd/FoWin32\Debug\mpz\\/FdWin32\Debug\mpz\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/Zi /TC /errorReport:promptПiY/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"z Ћ /Od/I..\..\\/I..\Win32\\/DWIN32/D_DEBUG/D_WIN32/DHAVE_CONFIG_H/D__GMP_LIBGMP_DLL/D__MPFR_LIBGMP_DLL/D__MPFR_WITHIN_MPFR/D_WINDLL/D_MBCS/Gm/EHsc/RTC1/MDd/FoWin32\Debug\\/FdWin32\Debug\\/W3/nologo/c/Wp64/Zi/TC/errorReport:prompt/c /Wp64 /Zi /TC /errorReport:promptCЉZ/ACWDc:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\include-IC:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include-IC:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include-AIC:\WINDOWS\Microsoft.NET\Framework\v2.0.50727rk\v2.0.50727"м ёЯ"а sвzвИ= Ы+\АЉрњђ3ћщжщгџ"Т/фтCw!ытю“!"‹#6"ц#k" "е" #0#V#$ƒ$U,У$ё$у&'%D%F'v'l%Љ'ж'—%П%(3(ъ%&=&e&&И&c(Œ(K-И(Ж*ч*с( )ц,-6)+I+b)‹)z+Ј+З)р) *5*a*Š*` M.aФJ5узѕ—LЊ,ЧОv№о| ВЌ<hOџ8хƒ‰:GEатїegщ)#ЕУыгЁЋ%^ЩЕ•‘аcG­№—zuАF€f50)HЃ’šsЭоL5‹щxƒ[БЩ3ѓesЛ!МбяЏ0 Jѕ §5ž.5ъ0™Hљjљ—љ0œ€˜OšП“”Ў”І™з”ћ”mšЫ˜Kœš#šH˜p””—”ъ˜y™:™–Н˜ОœI—Я› šФš№š!›M›p››Џ›Ф–Б№™К”иœѓœШD™S™—™я›œc™…šвВхВћВГ(Г=ГRГjГƒГ™ГБГЬГуГіГД4ДZДДЃДЩДшДџДЕBЕgЕ‚ЕœЕЖЕЭЕуЕ§ЕЖ>ЖbЖ†ЖЅЖТЖлЖѓЖЗ$З;ЗUЗoЗŠЗЁЗЖЗиЗ§ЗИ<ИTИnИˆИ ИЖИЫИуИњИЙ'Й=ЙUЙnЙ‰ЙuНАРаНЃРyТЖНiТН‹НZТъ͘РОdНEТ7Т'ТТ ТџСёСтСгСХСИС­С С“С{СkС^СJС<С-ССССіРчР€НРнН€РкРУНЪРЛРЎЏеЏёЏА$А;АUАkАƒААъАбАЖАББ3БJБ]БuББИБЯБфБ§БВ/ВIВcВ}•ŒВОВQžxžŽžЇžУžмžіžŸ.ŸIŸgŸˆŸЅŸУŸрŸўŸ < U m ƒ ˜ И в ы Ё$Ё=ЁSЁ™ЁqЁФЁчЁЂ{Ђ*ЂPЂœЂГЂЬЂхЂЃ$ЃAЃ_Ѓ|ЃšЃЛЃиЃ ЄђЃ+ЄOЄuЄšЄкЄЅМXЅnЅ‡ЅŸЅЛЅиЅђЅ І>ІsІІЄІКІдІѓІЇ9Ї]Ї|Ї—ЇБЇЧЇнЇ Ј/Ј•ЈЋЈєЈдЈЉ1ЉOЉgЉ‚Љ›ЉБЉоЉћЉЊ9ЊeЊЋЊпЊіЊЋ0ЋQЋkЋ.ž‡ЋЂЋЙЋбЋэЋЌЌ3ЌHЌ_ЌvЌЄЌОЌиЌёЌTЈ­8­S­k­‚­˜­Ъ­ц­Ў2ЎPЎqЎŽЎЌЎЩЎчЎЏЎ$ЏyЈ@ЏБ­^Џ{Џ“Џ6”Р$Р;РwСв) С c   Ц Ў S і~  Ђ J оs [Учџ#_ v С €  ѕ % ™ P № Л g ­ h п  … 8 п І  а  е ˜ Auр“р‰р^^G^ѓШ-7аа?аZ–U—/–й•cх8 K • B  Ц O ђ я q  э – Ъ k > ƒ ,  Ў ? о о X й ~ Л X ) 2 д Ї Џ Ѕ\3\’ƒa\‚ќ+й+,­awcŠ5Z@LэбвА Э %яр•%•›FяX MLвсVдV=Mд‚Ї@CъxиxŒxvxyјxHy,y}y`yБxœxл}ТxЩ х Ќ ˜ к\Œ œ!w8w"w€6Шг=х=4иUијЦMиjиŠе’е‰д–дDи_иЈŸWйЦ<7<r3rЖ\!vvеќдфд;j:L:Y:ЧЦаџwІqГqОq јії jb`b“Ё†œЦюШœрЖрХрŒч чcv…ЌюЌŸj G4ЬХЛХПœ‘ш Љ\№щ#чч„ЦјШПгm€–U‰zUXЮ3šbЮDmAЦžд!ЛtГзZsсЦJvі №[ЪЙDЇЯxЯ}vfs'qOsГЯяP!$х‘9ЧХRiяjWD#t4tmt‚t€*R08a8 88ўжњгн/шєкEsо4A\9 N{`н|є}†{л9нtuHuтuМu—usuіtћsчsгsНs]u„srs—stћuЉs0uE{’~}q}Ѕ{‹|u{Ы|!|шzџgh9Э9Xщ{в{П{Ёv3|E|Z|u|ДvM!ћ{a!d{R{Й|–{Ÿ||3{жzњz {!{˜уюуИф<фIуvуЭу‘фф%уd:Фpcд6RГяЈя—№Œ№Gп Ыз— фщZЂbcќbKcЌb!cУbйbИbЬbэюФхЯхcuk…p$‚”CЛдђ‚qr˜-˜х9@rѓ`ф`АŸТя€№Š\ьœ(mSЯDЯ†щšщ}щФщнХЧбяНzЋzизз*шCшЅшcш™ш}шoшŠш rвœJv::ч<М<‘в} :qЉХk–ХТ дMxAx†:>m}O\B ииzBŒOчN›BPNрHBE@ЮBO;aыBCйвpыЗыыЋыУылыѓычыЯыыы„ъ4ыЯъsъЊъєъыыМъръ–ъ$ъ];m;_ч’GНFGЊGѕNSC_NђH›OЉO0vUxнЗyЌy 1 вCЦCЙODеO˜Z‡Z!BЖaЦaЧODцOz zлJ*JчJѕJїOQMDM.и&и~ КдюпбїюRqЮв‡ vб§в&гkEЄв2Gбќ & я:я5 Lгdг8гИвOOŸ Ј В 5zК hЁVzzzЁ0DqЁ§№]ЁQDБNrbwc=Ozb†c2Ё=ЁOI>I84Б4ь—шямяЌ№ №ЭQf4…4П4v4™4Х 0   % 9 ю  t Y G B љ K o Z С\>s–tАtЂtЦ Ч‡ЧхЬиЬЭЭ9Э0ЭnеdеЈd”dРЬЕЬQщ\щUvє2sит<п7‡тЖЫK›Й €ХкђЭeсq@dЫRЏLЂюrёЧbZ>№qU№ž ш№Л и 0яЦU4§eAЁMрVрЁaрjрIЁ ^SЁ ^‰!—qшї№Aы”Oяy№юЬЭBЭеvеЛdАdШЬфё:Р:D;"ззшcпcѕХPnNb–cјDnOРŸy\“Ї%9< Ы^`9фb/ccYcяb`H`S`\`f`p`Њeœeыaђab2b&b;bћaЕHЋceПfГfѕUеfЩf`M§yRfGNјжї xЧіЧrШТЫЬјЫЪЪьABJBЮёМяНюХюБньЅЦЈЧЉЦЗЧ}ШxШ‘ё‰ёэљжё[хcхqх~х†х•хЁхЉхИхыцчњ`€ё*еcЯm… ٘йЦ;ьIьhь›ь]ь‚ьŽьtь‰вA@ЦŽ Aq– ЫЯљЮЎЦЩЧƒШћwŠнЂнВЦќЧˆШnн}нOнUBIPйgB‚B‡BŽB•BSPЅBВBйH#I6мz@з@ЧBЧШŽШлхухяхљхццц)ц1ц@цLцZцdц\PЗЦ Ш•Ш1м-Cф@%CŸэ"южэ“эЛэёэ§эюШэтэЌэ*Aь3CCCMCeP]CыH7IhCŠC_xЅC›CЧЩ›ШПCЖCьCфCDъg]IfIDš– šц•Џ•<fјS<–и™tbXјЪВнВ№В ГГ5ГHГ_ГxÑêГСГкГяГД#ДHДoД’ДЗДоДѕД Е-ЕZЕwЕЕЋЕФЕйЕ№Е Ж.ЖQЖvЖ™ЖДЖгЖцЖЗЗ/ЗJЗ —cЗ~З™ЗЌЗУЗ№З И2ИIИbИжљ}И–И‚О­ИТИзИў–ђИЙЙg–Рј3ЙJЙcЙ|Й™ЙЯХлЙFёЙКЁњИњ%К6КјОVКoКŸГ“КŸКЏКСКеКщКћК ЛЛ'Л7Л]ЛsЛƒЛЁЛГЛЧЛйЛщЛљЛ М!МћcМyМtј˜ј~јАј‰јІЏЭЏрЏААиОХОЭ™cАvА“АрАХАЊАїАБ'БBБUБhБ…БР™ЌБ—ЧБкБёБ В#В>ВWВыљrВ‹ВŒО—ЂВЕВC–ЪјIžpžƒžœžЕžдžчžŸ!Ÿ>ŸWŸzŸ™ŸДŸеŸюŸ 0 K b { Ž ЗО”Ор љ Ё5ЁHЁ„ЁaЁБЁNПzПaПкЁїЁfЂЂ=ЂVПlП“ЂžЏњњ3њAњэОЈЂСЂкЂѓЂЃ5ЃPЃqЃŠЃ­ЃЬЃЄчЃЄ>ЄcЄŠЄЩЄ ЅPЅcЅ|Ѕ•ЅЌЅЭЅцЅІ1ІgІ‚І›ІАІЧІфІWњЇ(ЇMЇpЇ‹ЇІЇПЇвЇыЇљЇЈЈ ЈЙЈхЈЦЈ П'ПП3ПЉПBП)Љ‡П<ЉGЉZЉwЉЉЉЉfњаЉуОяЉ Њ%ЊPЊžЊtњдЊэЊЋЋі–FЋ_Ћ=žzЋ—ЋАЋХЋрЋ§ЋЌ+Ќ>ЌUЌ‚њlЌ™ЌВЌŒњЭЌцЌxОCЈџЌ)­J­_­ы–z­­П­и­ї­э•'Ў@ЎcЎ‚ЎЎОЎзЎњЎ ЎдјојЏhЈ2ЏІ­QЏnЏ‹ЏннънuнЏЪDн”сwм Aмa]qЫй;Я~ФkФtРhР,K<D„Щ/P ёьїь§ьkD7ЩЦЦеЪрЧЭШьмїмямtо[’DЊ-Й- ›D DБйЈDsP IIоджд<тжзЯ:ннЬькьтьдь!xыњљњћћ$ћ/ћ>ћPћ|ћaћћšћГћЬћхћѕћќќ'ќBќSќhќxќˆќ˜ќЈќИќШќиќщќіќ§§*§8§C§X§l§y§Ÿ§’§…§И§г§я§ўў(ў9ўIўZўoўgџˆў{ў–ўЇўЖўХўиўхўѓўџџ7џKџšџЎџЛџЩџyџ‡џмџщџїџ-<IeWrƒ“ЊЮмыў .D^rŒšЅЦбДоыљ +:HZn’ ­ЙЬкчђ.L`<œtˆаDзDExP ЭгEEеЫЫЫМ@Х@Ю@žШ?E§ђЅ7EfЭ\ЭHЭRЭЬЬўс‡состюсцсісЧсЯсОсЇс с™с-тЎсЖсЪЦ­ЧЩЮЦНЧзШвШ—Эж“љљ-љљˆFEjм–м…ммЦ№ЧнШђнФжХEМEŠa ь:ZA&:MASA_SVSšSfSИUОSOS>STБUbTWT№РUySШUЅT›T­TеTЫTЯU€SˆSиUёTљTрUчU UUаж(UUHыж­љюUgUэLээ3эeэpээ?эWэ%эИйЪLИIfM\Mƒйй8PзFЫ%.гЦВЧзЦУЧшШуШAPО?Ќlі;ї>іžіЉіџіїюі/ї[іHіЛіпіЮі{іcїЋїwїŒї2і-P/–-Iюc пё1Щ fј@FF)F FсEрнм=р^^ шёs№пЫAЬў”ЬмЪfЬНй!'ЩъRз0FIEПљ'Ь87F@FŽI˜IKFSFiF]FFЇEмLУIЄI­IwZmZЦgМgVVV%V­W5V,V§І]цpьгљ§њџџЫƒ?№ЗЗOџ<<ёџРЗ_~h›Mљ|ьi>љW§?ьЯГПїўќMўbч‹uќяћ ўфўбз4;xћwў\|ƒЈяч•чЙгзOЅ?кšќnЉЙ`FтЦ8OЧ;“:№Ї•Њљw”[Хyђё=С7МІЊЏЃ хЫ~™o?і—9ј‹Fђ~оˆ›ќ~ТД№si{сџяІљŸњœтоnч Ÿў™џЕ§џѕџ"Зя…Э}>ўeљџ§Uџј§“Ї|пўƒWƒџПїœ|7џўџoAўџ§ьЯзы—ыdž=о+ўмягэЁџаЗnIозяYТŸѕŸžњџуяžџ—џЎ§~ЗулЧ?§мэ>ИџыЏщŸTкяЃ7gўOјўЋч=Ђџ‰џаЮЏ•§bПўйФ}ЄЯьЁћгбплЇЭћ‘ѓпПБп+њє]њ}о~хЛYџ)яшяЃѓžїѓ8ќРц‹|јўЇџПЏџўяё§џѓзџљЩџŽѓпсŸТџ‹;ЮпїЛћёјчяуŠ~ŽџїЇ%џы§џыУћŸчћ[іїxў§љћППЏПїјџЗgП?~ђћџчЏэ?_ДџљП_ўпЯЛяюїџџнычћрчџжч§яп7њП§эўи2уџџЯ~<ўя—ѓћ>ўљН{ё‡ЧџЯяџџџНпўпїлўЗўўћžІў?_јџлјќЪŠ|uѓI?ьMг‘ПО|ƒЧ~њЇќЗф}pуƒlјрЧxx|ЬпpўёTŸоepЖёa`N*оNк1ќ$faz^ч˜KФч)O‘=ИEЮ<ОБВ ф—вт­ёУУУЅф`ќHGoгђg№ЙцŸзGа‰ч(ž”ПˆќчЄ`=œ‡%1ї<РћЖ’y0:‚ХфТ/ЬЄ'ѕ#†™—||.'-меzžЛ_Xœ†љ”0Юиžў?hŸŽдє'Чвў ћuq;ОGл•ˆNlр”љxЊžUХЎ˜žBћвŽJйј;ч§гљчЧЏєУџ3]Т?g1јŒ5-цМгfУKjЄ)цёОЫŸ‰ƒрё…п/Б?ѕ;љСЯ№?™ш—яђќјQиЧМ›{Gўю Ў‡ўJЪs]•WЅ‰_џoІ{јптЖр?˜О ~Зѓћ\x~ЬyУЖ>АѓRЖƘkўˆзУію—ЙГЦ;rњ\љ€нёO~-ŸOџяП•Пь:gЗOц‹ћgGnю—gоЃ>ѓ™|к/Žo™спм~ю-ѓјнњщ/~уЏѕ]}oзFуџqёљ§мЯ§mју'ћc(ПSДž2dƒ/q8фГ ўкkто>.h€џЃІ•ыuiјZžшј"‚|9pКЅ <шЦї“=Вiѓѓъ%;%NœО=aŽ#—ЎCЦ[+:pьіѓxmQќ˜ŠцбшюёпжД.ьеGіЗШ‡7œы_нSpƒ?xdЭ‘\Ÿ \ScN"/…ІгђeяX~0LШЃДгЁ˜ЈЋ№…? —Ъ }$ё3x-Ё B#ЩУŒТ$б38 ђЋ3ЂФ˜тЈ 4†StDJИ№ј†бpХЏX"ёy- чHѓФgј=Г‘МЎЙќјЮ˜лЧ:у8Ў1?ƒ‹<OЈ€wСaТ3`' 8ьЪЁ,џ@T"ь‚o H„а 8Bђ8 1cСŠzœС'Ќ@шЩр•"‚‡iСHИ‹†ƒX„?1˜3Ё<\)ђЬђJЌЧ9‰“M`№FєJѕGѕ'Ё/х|цоуП3ўŒx|mФГ4(й?—В‰/6ёЃЦњѓФФ=cEГКzЯљУ~ŸŸ+…wЬкјёП72?žќПв™УѕžлuОѕWщёјЭЅъТхUъОf˜їрџЏ4ХЮпХщwцыrўЛWхћџь„пќ‰Оыxџ&Пм‡aƒPЇšNѓŸD!џ ќiP&—ј9рс3.ЖЌи<‘њ‘T, ЋQžхS\Іч3"„e‚€I]Ю“жhz\ђяѓ?с–ѓwшƒ~нdП`х  ()C?*fKDgџwFFTЬ;;3BКЫŠQQ  ()=C ?D™и>>1fKD]Ь;;9fKD oØ\мўIyџuFFfЬ;;S™з>>ЁeДYAfKD”2уYфY  дЫ‹QpЬ;IfKD83B‡џsFFc™ж>>* RfJK[DKD|Ь;;ژ \цЫQЁQ†Ь;s™>ўўIaf 1KD2KDKDŠЬ;;šџqFF< i> ()>C?F) y™е>> ”Ь;;mf3KDKDF ф˜ \§Ы‘Q Q†™>]3 BЎџoFFжeЕYŸЬ;wfKDES`> ()>CF{fKDЛџmFF џIZ F—™д>>‚fKLDEq3!B^ FЬ’QŸQˆf -KD.KDKLD>ќ˜ \ \ \\b_> ()>?FЕЬ;;ЩџkFFІ™г>>l FНЬ;”f/KDKLDOц2хYцYp F„3"BРЬ ;; t ^> ()>C?Fžf+KDJKDШЬ ;;мџiFF.Ь“QžQfЖYИ™>~ (>DP7=?F^Їf*KDKD€ бЬ;IџI™\Р™в>>… ˜3&BщџgFFиЬ ;;Š Гf (KD)KDKD Ы™>Э™б>>EЬ”QQсЬ;” GхЬ ;; їџeFFПf&KDKD˜ и™а>>юЬ ;; Ÿ =Г3'BЩf $K D%KDKDcFFЃ F™\јЬ;6fЗY_Ь•QœQtџIеf"K DKDЭ;;№™=>>Fпf KD K DKLDК Ю3„AA Э;FЭ;;$F83чY_™\ыf!K DKLD'FХГ> >zЬ–Q›Qк3ƒAALPQЭ;;-aFFѕfKDЯД> > šЯ>>\fКY"Э;s™\œџI<_FFй ’Ь—QšQђ3‚AALSVY^0Э;;I]FF#š<>>9Э;;№ BЭ;;W[FF 4AAЌЬ˜Qћ’> >LЭ;ФџIœ™\eYFF>šЮ>>4€AA“> >VЭ;НЬP•fЛY[Э;rWFF C%4AA  ?Oš;>>@ABEHJMNC?CGN^cšЭ>>) @SgLL/ “TFFmš:>>G4}AA$ ]gKK7 79<= 79<=ЧfМY< 79<=7yšЬ>>egKJKA 79<=7U4|AAkgKJKF7 DP79?—Э;;HŽ: :N…š9>>rg ?KPHIJKLPQ_4AЊRFFэ™\\Э ``1 Ow: P:NSU Э;;ygKJKf4 {AAMJPQRS[IV “šЫ>>gK:ЊЭ;[ ьF @F79<=?ОF Э``DˆgK:b()v4zAA š8>>м3щYЭ``3 gKKKЙЭ;ЮPFFm((o#Э``2 š\…4yAA>ўfНYЏšЪ>>?›gKмOFFЪЭ;ЃgK.Э`2Э`P`I IЉgK…((u™4xAA ыNFFФš7>>=Э``2 кЭ;ВgKJKМgKKK5š\HЭ``1 ўMFFыЭ;Б4wA@AHJNNЦgKJKŸ(Ћ>(>лšЩ>>?RЭ``1 l!IЮgKKK>3gОY\Э``1 П4vAAVY Ќ()>FќЭ;KFFЏ()FKš!\кg KJKГ(F№š6>>*4ъYЖ(fЭ``1 Й(>PC?FЛ()>7<=?pЭЦPPН() Ю;фg KJKР() IFFъg KJKУ()>PC=FOз4AХ()<=?bšQ{ЭХPP№gK‘"Iо4 CAC›Ш>>?Ь(ѓgKіg KJKЮ;.GFFG4ьY‡ЭФPPtoўgKPы4AbgПYhK K?JK/Ю;DEFF•ЭУPP hKуѓ>()>? hK?JK!›5>>hKЕ#IЂЭТPP5uA YAY?Ю;ё(hKd4юYhK hK?JK 5>AM?FYa8^CFFАЭСPP5tAYAYOЮ;(hK=›Ч>>?()>=?F(,hK5sAYAYМЭРPP€4№Y“gРYЈš0]]rAFF`Ю;M›4>>ХЭПPP%5APCQY\(й$IГš]?hK()ЯЭОPP> .5rAYAY@FFrЮ;_›Ц>>œ4ђY%(мЭНPP<5AYPhKŒ?FF/(фЭМPP4()p›3>>I5qAAVY„Ю;ьЭЛPPў%Iš>FFchKDŒЮ;@()єЭPU5pAA Ѕ<FFЙ4єY•Ю;њЭКPPƒ›Х>>vh#K DŸЮ;Д;FFмgУYR(›2>> ЮPW(k5AЉЮ;"&I'IЮЙPPћšA^^@ж4іY‰h'KDВЮ;Ÿ›Ф>>?Ц:FFЮP›^ЮИPPб8FFОЮ;p(„5oAAЏ›1>>œh,KDЧЮ;,ЮPо6FFђ4їY2ЮЗPPаЮ;—5 nA?AIOQVY„ѕ>()>С›У>>?N(IЏh0KDы4FFйЮ;§4јY@ЮP’ђ>()>?Я›0>>FЮЖPPуЮ;љ2FFТh5KPDЏ5mAA>QЮЕPP5 /H1H3H5H7HиVђVљYюЮ; ))п›Т>>Эh6KQD 0FFљЮ<::!5њY_ЮДPP8hФYK›-__1 иh7KRDГ)Њ>)>я›/>>{)IЯ;::F.FFW›,_^_Э5YAYnЮГPPфh8KSD^›+_^_Р)>F:5ћYЏYИYЪYУ)Я9::œС>>?Ц)>FyЮ‚PPFi№h9KTDЩ)+,FFЮPр5APCQY\i›*_^_r›)_^_ћh:KUDœ.>>щ5AY‹ЮP%Я:::*FFЂ*IN5ўY~›(_^_/Я:i;KVDс)ф)H)FFч)#œР>>›ЮPъ);Я:::Fi<KWD‰›'_^_6lAA>№)ЅЮP‘›&__2 0œ->>DЯ8::Z(FFi=KXD˜›%_^_ЎЮLPћ)Ÿ›$__Щ+Iy5џY?œП>> ЗЮKIKP;SЯ::F,i>K:hХYОЮKJKPZЯ: )n'FFЎ›L_Kœ,>>_Я:ЦЮKKLPEcЯ::N*6ARViЯ ::)&FFаЮKKLP>YœО>>М›L_36kAAqЯ ::N%)йЮKKLPJxЯ6::№,IЪ›L_Ѕ5Y’%FFуЮKKLP0ё>)>lœ>г›_ыЮKHJKLPˆЯ:biCK:№Ю KKP #FF>)іЮKKLPV6AQRV“Я:œ>–Я:::у›_\6jAA ­!FFС5YYџЮKKP‰œН>>N)Я KJKLPŸЯ7::FwiIK:ЯKJKLP-IЙFFѓ›_ ЯKKLPЇЯ::Y)чhЦYœ>ЯKKLPc)x6>AГЯ::‹i^KX:œ_ЯKKLP}6>Aj=ЬFF€6hPAPUр5YОЯў::&ЯP‰6iAAQiiKc:ГœМ>>кFF-ЯHJKLPJЪЯ:œ_ЯЯћ::хFОœ+>>чFFћ5Y9ЯJKLP­imKg:зЯ5::$œ_T.IђFFЫœЛ>>CЯKLPрЯ:2œ_МiqKk:цЯ4:p@:@Ћ6hA?ANЯPиœ*>>FF@œ_ёЯљ:@:@WЯPЫiŽK6YчœК>>Ќj>>aЯHIJKPFFФ6APœ_?iЧYањ:@:@iЯHILPЖ>ABCDFGIKOP8:=@ABDFGLTU[_ѓœ)>>мi–KЭ6gAAV26YpЯHIJLPє F\œ_а:Т>Z'FxЯHIJKPЙ>>Ž/Iьi—K.FFЯPjœ_т6fAAV"ај:@:@>ќi˜K‰ЯPM6Y<FFyœ_“ЯPИ>> j™K7а3::LFFЯP§6eAAV‡œ_ЁЯPa=а9:@FU?а2::,>ЅЯPe6YEа1::–œ_ЋЯPjšKТ0I`FF;З>>Oа0::ЕЯPЂœ_‘iШY44?@ACDEFGHIJKLMNOP:;@ABCDEGHIJKLMNOPQRSTUVWXYZ[\]^_`a7dAAV/j›K6 YZа/:: а??G>РЯPЎœ_t FFЧЯP##?@BFGHJKLMNDEHIJKLNOPQRSTUVWXYZ[\]asucа.::?jœKЗœ_UЖ>>аЯPnа-::?L37cAAч1IПœ__2 ˆ FFкЯPac>wа,::FPjKоЯIJPa 6 YтЯPD7A?Fвœ#__1 I7>AFsЕ>>ьЯJLPM7>AF ‡а+::ajžKœ FFQ7AFѕЯHIJKLPW7bAA€>–а*::ЊF§ЯOPaAsjŸKьœ"__ 3I2IаIJOPaД>>h7aAA Ѕа)::ЗFЬ6 YхiЩYаPПF…j Kš(>>аPc3@@ Еа(::{7AY!__2 ЇГ>> l @HJNMN\ аP—jЂKБ'>>Ца'::,аPё6 YŽ7`AAD4IНВ>>ЊjЃK:аPиа&::I( __2 jЬYШ&>>саї::IаKPЉ7AJНjЄKеБ>>Ў7_AA) RаOP8HH>ѓаі::7Yс>\аOPбjЅK HaJ__2 x5IБ…AAM^eаPяА>> Ъ7^AA ИAFIKOP8:;@ABCDGTU_mаP б:њ>rаPцjІKбѕ::h^_}аPžЏ>>C7Ym__1 \jЭYљjЇKˆаPž>ь7]AA>(б:Љ6I—аP kЈK!žЎ>>C<бє::ЁаKPQaIIche7YŒ_‘ __2 .ž%>>ЉаIJP[I kЉKЎаKP8\AA џ­BBFIKOP8:@ABDGSTUY^_A=ž­>>ЗаKPЅ__1  ABEFKMP:@ABDSYWбѓ::ПаHIJKP@ >ABPDSYIžЌ>>г7I4kЊKЏ_L]_‰7YšjЮYШаPQž>>ЌBBК__2 08[A?AQ]aaгаIJP\ž>IkЋK# BCDFIKDUY:иаPvбђ::FмаP*BBЮ__1 C8ASї8IчаPpžЋ>><=H8AS^kЌKБ7YYYYxž$>>Q8ASђаHIJLP YJJ н__1 јаPX8ДIAIK•б:ƒžЊ>>9ЊJъ__2 џаPskЎKa8ZA?ALYнjЯYRBBŽž#>>9I бP†kЏKџ__2 œžЉ>>u8ЂIAIKВб:м7YбKPбKPЇž">> 8YA?AМбю::ž__) %бLP™kАK=:I;I<I=I>I?I@IAIBICIDIEIFIGIHIIIJIЧб#::ЕžЈ>>/бPž _“8KAK€ŽBB5бPббэ::Fћ7Y­kБKУž!>>oы;KK>8XA?AёKCбPпбь::kаY2ž _дžЇ>>ТkВKQбHIJLPВ8KAKэбы::Iмž >>g KILIMINIOIPIWбPІ>BD=DS[`Gž _]бPН8ЕIAHIK?FчžІ>>ћб"::­BDDS[`еkГKФ8ЁIAHIKГBDDS[`gбPWž_ИBDDS[`Ь8KAJKHіž>>въ:::qбHIJKLOP7 ОBDD[`д8KAJKH‰QIRIшkДKв!::xбPХBDCDS[`н8A~бKOPŸЅ>>в:YkбYЯB„бKOPnž_6LLќkЕKŸ>>(в:бP@LQYT8Y3в:˜бPхB!ŸЄ>>ЏSIlЖK…ž_ŸбP?в:ЅбP.Ÿ>>ЊбPљBCLв:%lЗKžž_ГбPB>ŸЃ>>ЗбPНбPZв:–kзYдTIIŸ>>СбP%9EEB:lИKŠ8Yfв:Зž_WŸЂ>>гбIJP39E…MMsвщ::ибPOlКKzвш::gŸ>>пбPLW]ЖkйYЫž_вч::F9EњUIшбP\lЛKJ9E‰в::zŸЁ>>ђбPрž_‘вц::ilМKїбPЛ8YаkлYњбPšвх::ˆŸ>>`9WAAwlНKh9VAASUэCC  вPЄвт::VIѕž_шkоYрYтYфY™Ÿ >>†lОKАвф::cьCCвPz9UAAPQ]Ивс::ЅŸ>>“lПK Ÿ_m>ABC"вPд"NN:‰9TAAХву::+вPx XCXДŸŸ>> lРKоLlцYшYъYьY1вIJKPЮво::IGWI€BCј8YŸ_—9SAALY^9вKPЎlСKУŸ>>йвр::ŠCAвPlяYрв:GвPМlТKЉ9RAAV4Ÿ_KвP˜ >ABCDM789:?FJRSYеŸž>>šыCCOвPывп::SвPЁъCCWвPрŸ>>ЫlУKів:[вPnXI9Y2lђYЋщCCJŸ_С9 ?AHIJKLOQV§ви::IюŸ>>gвPкlФKЗшCCЭ9 QA?AHIJKLPQVWY\]a г:rвP_Ÿ_щlЦKТчCCўŸ>>%ROOJRlѓYєYл9PA?A‘YIгн::C9YY1O‚вPацCCх9OAAQљlЧK œ>>&гз::uŸ_ё9NA?@AHJMNHIJKLNOPQRSVWXYZ[\]a5рхCC•вP1гм::K >> mШKslѕYшфCCќ9A8гж::ˆŸ_ЗZIi9Y Y:) ?@AAHJMNHIJKLNOPQRSSVW X+YZ[[\\]a>AMFPQVWXZ\]ѓуCC0 ›>>ЇвP :MA?@AHJMNHIJKLNOPQRSVWXYZ[\]aPDгл::mЩK›Ÿ@^Q^Lге:::LAAYтCC< >>ŸŸ?^Q^lіY:KAAY,mЪKКвPЃŸ^ЈŸ>^Q^Zгк::ЌŸ=^Q^ CK š>>9<=?АŸ<^Q^&:YA л[IсCCdгд::>-:JAAYДŸ;^Q^ИŸ:^Q^МŸ9^Q^‚P9!YРŸ8^Q^rгй::LmЬK9:IAA& >ACKP?FHLQUV]b ™>> мв PФŸ7^Q^БlїYјY+рCC|г:A:@AHJNNШŸ6^^@ЯŸ5^^m >>]mЭKL:HAAL^\IкŸ4^Q^Œг:=пCC{ ˜>>79<єв PИ9"YЮlљYњYуŸ3^^Y:GAAL^"nmЮKƒ >>—г:JоCCяŸ2^L^d:FAA$ Ž —>>Ѓг: г Pj:EAAL^^€mЯKњŸ1^^#]I^I\нCC ˜ >>щlћYБг:v:DAAL^ЧЇQQKй9#Y 0^^@Ѕ >:’mаK  /^^@ г PбQnмCCПг ::Ќ –>>†:CAA> .^^@vлCCШг:mMWW|кCCИ >>:BAA" Яг:G_IЄmѓK mLWW ƒйCC$ ,^Q^9гP -^^2 mKWWџ9$YЦ •>>ž:AAA$ мг:>ACPUЖm.K/ +^Q^mJWW ’иCCЈ:%AAIJLYYв >>LгPщгг::Ў:@AAIJLY:8 *^Q^'mWзCC)mVW\O%mWk`Iр ”>> И:AЭm/KD )^Q^0mVW\WЊжCC њг::`гPР:?AAIJLY6mVWы  >>O (^Q^$:%Y+RRЫ:>AK:@UИЭCCW '^Q^DmIWW љ “>>sгPд:>AA$ д:GTYщm0KУЬCC$RWX[c &^Q^RmVWЁ >>п:Aд:’Hj #^]^ да::…гPšHJ:&Ys ^&дЯ::?NQbmHWW y ^Ё’>>ЃH,дЮ:::ё:=AAоCQn1K ^Q]^mmGWWчЫCC$Ё >>§:A‰ Q^ гPzmFWW@д:L Q^Gд:@BP n2K5Ё‘>>— ^LQ]^;<AA@„mDWVWMдЫ::ХHHџеCC;;AAL=Ё >>o:'YmVWTд:Ÿ ^]^k$SS5 МгPЈ ^Q]^•mBWWHЁ>> ;:AAL5n3KдCCВ ^LQ]^wSžm=WW SЁ >>ЫгP-;9AALhд:AуHК ^]^•:(Ynд:Jn5K#гCCЎmVW\aЁ>>:;$AA xд:Ш ^Q^ЖmHLVW\QргP#SSD;#AAб ^^‚д:N3 ѓQBCHIJKQ˜SqЁ>>РmWз ^^@9вCC‰дЧ::O;8A@Adn6K H HHžTSTШmVW\Pн ^^@‘дЦ::NігPV;"FAFKф ^]^Н:)Y–дХ::гmVW\„ЁŽ>>];QFAFJбCCЌTSTэ ^]^žд::мmWі ^m;7ARF?@AFО TST[аCCƒn7K™Ё>>дP'HHHАдФ::цmWv;@AFюmHVW ШTSTy;>AFK:Ё^Q^н:*Yќ ^~;1@6A@AКд:lCїmWW WWKЁ^Q^Пд:†;@AFKз TSTuЯCCБЁ>>Ё^Q^,дPŒ;0@5A@AЂn8KnVWЮдУ::N“;@AFK nWW WIHHH Ё ^]^˜;/@4A@AждТ::ъTSTФЁ>>)Ё ^]^Ÿ;@AFKCодС::=N;+YЄ;3AAQ]6ѕS2Ё ^Q^фдР::KдPРn9K%n W›ЮCCБ;2AA кЁŒ>>=Ё ^Q^jHH Hѕд:1n WIЁ ^Q^О;1AAPчЁ>>ќдП::FЏЪCCиn:KeдP';,YSЁ^Q^Ы;0AAYИЩCCPUX\Fn WїЁ‹>> е:]Ё^]^СШCBCFIKOP8:@ABDGSTU^_еО::з;/AA‹"H$H&HЦЧCCFKzдP№n<KhЁ^]^Ђ>>с;AAY]I;-YвЦCCF:#е:7TTщ;A_nWqЁ^]^*еЈ:Н::N?TT |Ё^^@о ХCCFGIKP8:DS]^_aЂŠ>>”дPѓ;A.е: o=Kх CC>­(H*H,H†Ё^`;/Y9е:<A*Ђ>>R TT Ё^^<A~nWЉдP P!PіФCCFIK:FеМ::?Np;1YMеК:Л::<A]ŸЁ^=Ђ‰>>)o>KfT УCCF:Йд"PVеЖ:З::ЯF <A^еД::šnWЎЁ^‰;3Y ТCCPЂ>>dеГ::Ыд#P$P%P}T СCC/<AНЁ^nеВ::Ho?K7<.AAPQvеБ::) РCCfЂˆ>>од&PЂ;5YКnWC<A“TеА::ЮЁ ^8  ПCCFKOP8:DGU^эд'PŠеЏ::P<A> ОCCFIK:DQ^{Ђ>>fo@KпЁ!^’еЎ::Л;7YY<AвnWћд(PЋTK НCCFœе­::LGaaJёЁ"^ е)P“Ђ‡>>X МCCKDQ]^j<AІеЌ::~oAKг;9Y"$aaIТ TTœЂ>>t<AВеЋ::LЂ$^е*P+P,P/a|<Aj ?CJQVЈЂ†>>НеЊ::–oCKљnWWWWх;;Yq ЛCCж TTЂ%^:aГЂџ>>-е-P.P<AЪеЉ::NDaЯе:љ;=Yƒ КCCKYге:СЂ…>>­oDKзеІ:Ї::œ<A=е/P0PюTT5 oW#Ђ)]]K,Ђ]UaпеЄ::ЬЂў>>Ma• ЙCC хеЃ::N <?YLе1P5Ђ]a_aыеЂ::=Ђ]кЂ„>> [T[ЩoEKЖ<AIJOY]jaєеЁ::Ї  ИCCFGIK:DLS_М<-AAPQ>хЂ§>>]е2P3P T8oW!<AYўе ::Џ ЗCCFIKP:KЂ]taЦ<,AALQ|aѓЂƒ>> TYЂ] жŸ::Л ЖCCFIK:DSƒaqе4P5PхoFK7<CYе<AKP:& TT5 ‹aжž::Ѓќ>> ToWЪ ЕCCFо< ]ALQ]jЂ]е6P’aoЂ]5 TT "ж::Nч<+AALQrЂQ]L<EYœapGKй ДCCЃ‚>>)ж:{ЂQ]Ѕa’е7Pє<*AA E TTloW„Ђ]]<GYЏFa$Ѓћ>>9жœ::э ГCCЂе8PpHKЂL]ЖaCжš:›::X TT =AПa„oW5Ѓ>>šЂ]Nж:Ге9P Ђ] ВCC*p?S[]Шa|<IYAЃњ>>ЈЂL]m Tбa=AУе:Ps SВЂL]žo WPЃ€>> БCCdж:лaтaЛЂ]lж˜::Nцaге;P3=Aъa_Ѓљ>>uж–:—::юaFa<KYЧЂ]) АCCЖo!W?=AљaFa2 ЏCCƒж”::гЂ ]]qЃ>>яе<P aa?нЂ]? ЎCC|Ѓј>> S=Aж“::NW=A”ж:бo"WН<MYopMM>хЂ]] a_= AAOж=PŠЃ~>>O ­CC ж:ypM^f=AяЂ]]Й .UU Їж:p>MћЂ]щo#WšЃї>>_ ЌCCFIK8DUr=Aж>PХ -UU Dи<OYДж’::g ЋCCKL~=A Ѓ] ]в U­Ѓ}>>; aФж‘::Nv ЊCC:Š=AIJOp$WЃ ]Ъж:/ж?Pѕ<QY’=AЛЃі>>аж::Nф U… ЉCCзж::P a)Ѓ ]ю +UU"" =AAж@PЬЃ|>>Ѕ=AA сж::љ *UU!p%W™ ЈCC=SYыжŒ::?NиЃѕ>>Б=AФpNNHSжAP )UU8<Ѓ]d aѓж‹::Юp>NчЃ{>> (UU <­ ЇCC:Т=Aўж::еpN)=UYfжBPPЃ]x aAp&WђЃє>> 'UUotг=AAС ІCCvжCPзŠ::NЄz>>% &UU bЃ]л=A?AJQRKŒ a aзˆ:‰::C=WY1 %UU[p'W Єѓ>>х=)AA"з†::е ЅCCIKŠжDPuЃ]]< $UUth)зƒ::Ё  aя=(AAQRп ЄCCIKЄy>>2з…::NG #UU \=YYљ=KAJK^9з:Ѓ]+Єђ>>№ ЃCC:>'AA ?з‚::qOO {p(WЉжEPY UUЗ  ap=[YKз„::'qO%:O:>&AA\ ЂCC>Єx>>c UШ  aUз:ЅЃ]k U ЁCCšp)W†=]YФжFP%>MAMX:qOё:O:OЄё>>dз€:::t UUd=к  a->AAqO$:O:~  UU  CCoз:GqO№:O:РЃ]]щ a›=_YБp*WcЄw>>Œ UUPRqOя:O:ржGPз:0 ŸCCF>A– UгЃ]]qOOћ aЏ=aYuЄ№>>= žCCP:UX! fqOP?Fз~::NhqO=FjqOЄ "UU aљжHPчЃ]™з|:}::J CCFIKP8:@ADTUY_sqO`> A­ !UUŠЄv>>зp+W,WХ=cYS œCCKИ UU ~qOЇзz::њЃ]šЄ>>зIPˆqOЦ  UUtFc ›CCIKГз::Uяp-W.W/W0Wк=eYgY~> A Є]—qMMIJLQV8 aa­Є>%зJPs  šCCFIKP:Q\_aю=iYл UUioЂqMЫз:: q1W~ ™CCІqMM Є]­qMззC:D::œ> A AO aГqMMIJLQV>kYЩЄu>>BзKPпз: ˜CCK:є U4Є]ОqMMIJLQVЋ>Aќ UUenьз:кЄ>>>1--mYnYpYqYsYtYvYwYyY{Y}YYYƒY…Y‡Y‰Y‹YYY‘Y“Y•Y—Y™Y›YYŸYЁYЃYЅYЇYЉYЋY­YЏYБYГYЕYЗYЙYЛYМYОYПY,q2WЩqMMPRS[%Ђ —CCѓз:g aFЄ]Л>A\зLPаq>Mћз:  UU Ў –CCжqMMJLPQV(>oYy aюЄ>Щ>Aпq  MMPQRSWXY[\иA::ZЄ]Gq3Wи?:@::чqMMQR]"  UUС •CCwзMPŒ aй>Aи:юq>M89?FYY№qMMPQW\]0  UU Ѕt>> и=::oЄ]д ”CCKP:BDU^ќqMS&и;:<::9  UU bq4W5Wэ>Aœ arMSзNPо “CBCK:.и9::B UUctЅ>> rMMQZ>rY4и8::‚Є ]K UUЏ a<и:Y?Aя ’CCI:ЃзOPT  JYKYLYNYLUYYrMMP{q6WDи7::2Ѕ>Z UU—Є!]С a#rMMи6:: ‘CCK:?AЖзPP(rM+rMPU AUи5::d U•q7W3rMMPo UU$(ЋЄ"]†>uY_и4::ЦзQPPЅs>>y U CCIK:+?A@r MMWjи3:: UXЅя>>ОЄ#]­q8W‡ UUtи2::LrMэ aaaacЅr>>OrM?FLV\>?AпзRP, CCKY{и:Sr MMSYr MMLQnЅю>>‚и1::˜ UUlsжЄ$]K?AAA‰и/:0::Цq9W:WГ>xYdrM  aђзSP|Ѕq>> B ŽCCIK•и-::nr MM цЄ%]\?AЌ UU‡Ѕэ>> tr MMиq;WŸи:иTP{rMM !aіЄ&]X CCIKP:•Ѕp>>n?AAAƒrM‡rMУ UиUPк>zYŸЅь>>Ги:Щ UUPIŽrMX. "aЅ']k ŒCCK:Ни,::ЌЅo>>%иVP„?A Aџq<WХи+::žrMM > #aп UЭи*::~ ‹CCЛЅы>>Ѕ(]5иWPЉrMх UUin­rMš?!Aзи)::r>WP %aни(::ЗrMMJRDиXPЭЅn>>4Ѕ*]+]хи'::– ŠCCНrMMћ UUUsЎ?"Aыи&::иЅъ>>UиYPЪrMM" ѓи$:%:: U?|YGЅ,]5r?W@WцЅm>> UС? @9<=?Ў ‰CCеrMMIJOQй"::eиZP@rAW UUђЅщ>>~ &a й: ::фrMM[Ѕ-]vи[P' UUьr?Y\Іl>>Ц ˆCCNrCWй!::. U І>>pЅ.]†и\P7 U#й: 'abrEWо ‡CCІ>1й::‚Ѕ/]I UqrVVK7й:œи]P^?~YГ (aS Uђ †CC@fFFDй ::•Ѕ™QQJ1Іk>>‡rVV` UБи^PАPžЅQ@B@B>І>>Rй:Ъ )ai U …CCFKP:UЇЅQ@eFFWй ::2s‘PP]й:ЏЅQФи_PЏP#@dFFv U „CCNІ>rV>sMPP*@cFFИЅQhй:‘?€Yт *aМЅQEsPPƒ U4@bFFСЅQrй:зи`PЎP% ƒCCOsPPШЅ‡QQQxй ::Ž UgІj>>Зr VHLQV\A@aF?FaГrVй/Y1Y:YE@`F>FKZsŽPPвЅLQƒй::еЅQъиaPЋPsІш>>œ U8 ‚CCFФrѕVVћ +aнЅQfsPPS@FKй::Ј UY@FK‚Іi>>О?‚Y˜й ::rsŒPPъЅQйbPЊP_@FKй ::лrVP CCЕ UђЅLQІч>> h@FKЂй::  ,a-a.a/a0a1a2a3aЇй::јЅLQхrV„s‹PPp@FKЌй::›Іh>>79<=?ІQБй::ьrVVШ UйcPЉPz@!F>@FKІLQh €CCЄІц>> @_FFИй::Нй::ІQ—sŠPP. 4aУй:АІg>>" й UІQ‰@^FFsVЫй::КІх>>3йdPЈP ІQЉs‰PP€ CC”@]FFвй:љ?„YsVJ 5aэ S@\FFЧІf>>9/ІQsVѕ SS4ІQНsˆPP>HйePЇPЈ@F˜ ~CCIKдІф>>#sV_ 6a "SS6 >ІQВ@F+sRV1sлVVбІ }CC[йfPІPфІe>>М@[FFq 7aгs‡PP KІQ SRS[Х@ZFFBsVVѓІу>>XІQ SnйgPЅPЛ |CCFЮ@YFFк#:.@†Yчs†PP † 8a% Sз@XFFgІQSsЮVRVЇd>>/ Sк.:йhPЄPа {CC5 LSф@WFFћs…PPtІQ`sгVV: 9aЇт>>ю@VFF? S[~ІQп zCC“йiPЁPE RS.к::lsVј@UFFJ SS:t„PPrsV_@ˆYŠІQ(Їc>>ATFFR S=к>:ysVЕ :a“ІQsVѕ yCC A SF?FGIKOP:?@DSVW\_ЌйjP P…sV#tLPPœІ‰QQI9Їс>> A7FFKLкB:ŒsVh SJSЄІQ’sVVPЭ ;a xCC4tKPP ЌІQТйkPŸPA FFK[к{:MЇb>>9<=Š@ŠYЕІQ*AF?@F{ SЁsVЄsVwCCу <a1A >FIKP8:=@BDU`FtPПІQpк:]Їр>>ййlPžPŠ S:AMFFK)vCCЫІQЛsVYtP‚к‡:љ =apЇa>>еІQ5uCC PSMAPFFKяйmPPЃ S|Їп>>SA OFFK79<=?’к•:уІQЭsVmtƒPPЉ PRS[ZA NFFK79<=?# HtCCЙ@ŒY >aьІQaALFFВ PRS[‹Ї`>>лsVёІQкnPšPiAFBPЛ SSЇк™:! ?a‚t‚PPћІKLPQ[sCC—Їо>>oAKFFЇQvAFBPЩ SS ЇQ|AJFFІЇ_>>ЙкЅ: кoP™Pт@ŽY–tPPƒAFЇKLOPQaќsLPQVaPsrCCБЇн>>ЇQ‰AIFFм SSWX\ШкЕ:Ђt€PP>tVAFBPAptV@ @a tVц  RRSS[[ПЇ^>>–AHFF9кpP˜PtHLV'ЇLQАtPP AFBP/CзкЙ:‹qCCЧЇм>>-ЇLQtVЃAGFFW Aaѕ S S S SЛtJPP!tV6ЇQвЇ]>>ЌAFBPчкв:ВAFFF?ЇQTкqP—PнЇл>>>ЫtPЃpCCЙAFBP="  S0tIVn BaIЇQ5tVПAEFF!AYыЇ\>>;tVQЇQЦAFBPнt~PP jкrP–PBtVXЇQЬADFFЛoCC:D  SљЇ[>>GtV† Ca`ЇQдACFFлќ:OtVкAFBPKЩnCCђtPрAFYtVіt}PP Јк>>ƒкsP•PqЇŒQQ6S$л§:atVъAFBPž Da{ЇQ№ABFFitPVaKоmCCmtHVFS‚ЇІQQЈZ>>˜кtP”PZA’YstVuPŠЇQ;лџ:u|PPЕ EaŽЇQ{tVBFKP:@_“ЇЅQHIJKLQѓlCCYS/Јй>>BFF˜ЇQtLVBFKQYœЇOQLл:ВкuP“PˆtV ЇQBFFkCCŽtV,uPЫ FaЇЇ…QLQ0u{PPCЈY>>nSSB ?FIK:@IJKLOQV–tVa!BFF‡A”Y`л:ХкvP’PВЇQŸtV)BFKP:ЃtVjCCTЈи>>р ?FЇtVDuPНЇQƒSHuzPP3BFKP:Oaqл:икwP‘PХЇLQ9BFKАtVЗtVhЈX>>ЭЇQ.iCCABF@Fє Fј FМtVПtVдЇЄQLQ]uyPP" ™SыкxPPJBFF…л:ЎA–Y<hCCKyЈз>>ЫtVрЇQUBF@FFхЇQ–л:\BFFщЇQеtLQRV\]suxPP LgCCэЇƒQQ<лyPPFЈW>>ЖSgB FFлtVрtVљЇLQ•Јж>>nBFKЊл:чtVўЇKQafCCЈQuP ЈV>>лzPŽPzBFF№tV ЈЃQLQЛл :јtQV‚BF@F—uwPPдR\ЋЈе>>5F‡BF@FўtVыA˜YЈ€QQveCC,л{PPuVŽBF@F?ЙЈU>>E F uVал :!ЈQ•BF@F uV%ЈЂQLQ›BFFuVВuPЦЈT>>uVол :Cл|PŒP0Ј}QQdCCЅBF@FX?МuvPPuVдЈд>>>­BFIJO%uV;ЈQыл:ВBF@Fj?DЈQИBFIK:3uV\л}P‹PхЈS>>ЊcCCјл:p?MЈQТBFIKDGLQV"BšYиuPЧBFFм999UЈQ}?VVєЈг>>@uVтuuPPЮBFF‚?]ЈQ#V\tл~PŠPм99жBFIKP:UcЈQФbCCRuVjЈ!QQЉR>>м9!м9š?ћutPPшBFIK:SUXMBœY&м9wЈQcuVлP‰PzЈQЉв>>+м9YZZоaCCѓBFFPІ?1м<<es‚ЈQjuV6м<<vsPP ˆЈQќBFPГ?xuV)ЉQ>>ЈQЄл€PˆPCFKP@м<<vPѕ`CC1Љб>>‚uV!vrPPJм<rBžYЈQCFIK:SUX% Х?<ЉP>>Pм<ŽuVhNWWЭ?КлPC FF0vqPPWм<=а?GЉO>>9 _CC”uVЎЈQ_м(==œuV%C FFrWOЉа>>>79<=3C  F@F79<=?ЊuVJvoPP ЎuVь?ВuVЧЈQ;CFGKPDwм%==gЉЯ>>UvnPPЙuVVул„PаЈQCC FFј?5]CC…м$==СuVџ?MCF@FcvmPPмЈQwЉM>>ГB YSCFFхЈiQQ‚ЉЮ>>њл…P–м#==7qvlPP]CF@FэЈQM\CCcC FIKP:HIJLQR\??мuVГXXPЉL>>79=}vIPPhCF@FЙXљЈQnCFЌм"==ТXX:›ЉЭ>>`[CCм†P'?ЉQŽvP{C?FGIK:HIJLOQUVWY\]aЗм!==ЮXXP ЉQ3?ЉЉK>>?‚CFKP:#м‡PРм ==ЉQ7?sZCCFKБЉ>>ŠCFFЉJOPQaюBЂYЁvHPPvVVЉQЬм==’CFIK:SJ3м›PМЉ>тXX:"ЉQƒYCC›CFFь XX Q?*ЉQДvBPPнм==ЅCF@F[?аЉJ>>5ЉQ v VKмœPќXX СvPšXCC­CFKьм==a??ЉLQям==оЉЬ>>ЖCџFFDЉQCЄYЮvPїм==\мЂPr?ПCF@FMЉQжvPVXYБWCCЦCўFFяЉI>>! н==нvPUЉQQXXBƒ? н==вCFFћЉЫ>> uмЃPdЉQQэvPмCFIK8:@D_н==9ЭVCC ЊH>>79<=oЉQфC§F@FљvkP,UPU†мЌP—?œ?uЉQ%н=F5WьCќF@FЁ?ЊЪ>>{ЉQfv V-н=ђCFP:UЅ?wUPUЉQЊ?FCІYњCF‡ЉQщUCC%ЊG>>žм­P:н==7ЉQDћF@FwiPP“ЉQDњFFDн==7™ЉHIQ"wjPPЏмБP†v V9ЊЩ>>DљFFŸЉQOн==У?Ц?Щ?ЅЉQTCC/wPDјF@FXн=F}CЈYЌЉQ#DїF@F8wgPPF`н=QPЊF>>ЕЉQ(DіF@Feн=Ђv V{%YYЛЉQЯмВPEwdPP0DѕFFnн==D!SCC†YKwPУЉQuн ==QwPeЊ>>=DѓFєFF>рмOUwcPPЮЉQ}н ==DDFIKL:DEO3RCCKP:\wbPP щмIJOЎCЊYзЉQLDёF@FbwP8Šн ==ШvVQD№FFgwaPPємIJOa}Њ>уЉQWDAFF:љмOanw`PP˜н=twP8LQCCюЉQнIJOн=yw_PP>Ђн ==9kDяF@F:>€w^PPљЉHIJKQ нO†wPџЉQrDFIK:Бн'==žЊE>>=‹w]PP нKOePCCzDюFFёvVЊQЫ)ZZZ’w\PPнO‚DэFFЋЊ>>˜wPе V Z(ZVYZYЊQТн=w[PPF*нIO‰DFK:xOCCШн=эCЌYпYZЄwZPPIЊKQ’DыFFЛЊ>3нOЬн=фZYZЋwYPP $ЊKQ8нOгн=›DъF@FкYZщZ*ЊQГwXPP> DщF@FAнOнн ==wVєZКwWPP’NCC 4ЊQЈDшF@F7>KнIJOдЊD>>­DчFFТwVPP ън==YZ>ЊQSнIOГDFЩwUPPђн==пЊШ>>XнOЙD@FFZбwTPP ZKЊHIKQЌMCCK_нOўн==&DЎYиwSPPэЊC>>RЊQeнOaZjнOaZрwRPPDwVіЊЧ>>\ЊQаDцF@FОLCCчwQPP tнIO#ZZОзDхF@Fо=ЋB>>яw5PPFо==iЊQ}нOоDFK-ZZЌ5ZЋЦ>>ћw <P:<?FKtЊQ§wP<‡нOџw4PPзKCCыDFK%о=,о=‘нOkwVЋA>>unF  H HHыYZZ xy:P:NU‚ЊHIJKQ—нOјDфFF6о=aDАYx3PPžнHIJOEуFFЊQ>о=RZ№JCCЅнOEтF@F0ЋХ>>Eо=–ЊQxP=?F!xv:P:NUEсFFЏнIOœЊ QQc HHHэYZZ)x2PPEоFFЙнOaWо=ЉЊQFЋ@>>ПнOEрF@FYо=QICC7xu:P:U#EнFFaо=ЦнOaœwVoZQЋФ>> ИЊQAx1PP .EпFF HHHяYZZанO–DВY_Ћ?>>знIOMxUPU7EиF@Ftо==QŠ ZЩЊ Qzо=пнO,HCCUx0PP?EмF@F?OkЋУ>>~о=FEлFF‚о=шнOa_x x:P:NQSU\]› #H%H'HW­YѓY ZZУwVянOadx/PPzЋ>>>SEFЇ ZјнJOXEкFF”о=oxUPUъЊ QJGCC‡ЋТ>>ўнOvx.PPУDДYоOЗ ZІо=kEйFF оO—Ћ=>>ыwVŠxP9:?@FU[оOŒxs:P:UCЕо=ЂЋС>>hFCCIKЬZоOa~EжFзFF2 Ћ Q$оOъDЖYœx-PP АЋ<>>9ŠEКFЛFFШо=-оOa|ECCЙЋР>>2оOуZ Ћ Q—EFIK:LQVY:оOaxVБxq:P:UХЋ;>>EгFдFFL@оOно=2ЋQЇEЕFЖFFбЋП>>IоOa—DCCњZТx,PP>OоOaВEбFFTоOaEИYрЋ:>>?ZоOїо?^МEЮFFZcоOaиx(PPэЋО>>ВCCCХEаF@FTЋQiоOaCxVЬEЭFFnоO§Ћ9>>ъxt:P:U& HH!HёYZvоOиEЯFFЧBCC~оOЌН>>BEКY1ZтEЪFFјx+PP>…оOwЋQ›QЧQЌ8>>оOэEЬFFjxVЋQœQШQђQ•оOЌМ>>уACC іEЩFF™оOHZоOyP<п@@Gyr:P:UЁоOЋ L.L\LQ!Q"Q+Ќ7>>=ЅоOFЫFFЉоO3ЌЛ>>Gпr@@FFЧFF_ )H+H-HWЏYѕYZџ@CCЂЋQ>Ќ6>C>C,y*PPЖоIJOFШF@FVпK@@kZ•xVОоOOOHЌК>> FХFЦFF_пJ@@?CCЕЋQ)FУF@F{ZUЌ5>>jпI@@‘EНY0FТF@FHyo:P:Urпl@H@@_ЌЙ>>7FСF@F%>CCFЦЋQ@FРFF}пG@@‘ZlЌ4>>бЋQQ5=CCK:…пk@F@@KFПF@F`y)PPvЌ>>юоOЦxVSFОFFрЋQпE@@G<CCƒЌ>]FМFF˜пj@D@@­ZЪEРYЃпC@@}yn:P:UiFНFFЋпi@B@@ќЋQ™Ќ3>>^;CCsFИFFпOЖпA@@ђxVЄЌИ>> }FЗFFЪ Z!Z"Z#Z–yOPPПпh@@@@ЌQˆFГF@F=u:CCВЌ2>>?ЃyUPUFВF@FЫп?@@р$ZОЌЗ>>#ЌQЌyNPP™FБFFгпg@>@@>п OF СYТYФYХYЧYШYоп=@@ЗyUPUЄFАFF‘9CCЭЌ1>>79=?7 yVі%ZОy'PP цпf@<@@<ЌQиЌЖ>>АFЏFFёп;@@Ъy&PPНFЎFFцЌ0>>=љпe@:@@ &Z­8CCжyP&FУYPЌ Q1Qhп OёЌЕ>>ШF­FFр9@@тyP рd@8@@вFЌFF`Ќ"QLyVъy%PP>џЌ/>>%'Zр7@@Щ7CCнFЋFF/YYJ­>>nЌ#QїyPрc@6@@њyP§y$PPAщFЊFF­>*р5@@”п OєFЉFF2рb@4@@ z#PP GYVY…Ќ$Qх6CCGЈFF)­.>>79==р3@?@QzP~yVzE:P:Eр2@@Qї5CC GЇFFœЌ%Q8­Д>>&z"PPFMрa@1@@cYYGІFFVр0@@5z!PPJ­->>4CCХп Oaр`@/@@ГЌ&QS­Г>>AzPjр.@@’FЦY2GЅFFIz PP_­,>>uр_@-@@)3CCЖyV V!V"V#V$V%V&V'V(V)V*V+V,V-V.V/VYYЬЌ'Q(QVzPPk­В>>р^@,@@KGЄFF‰р\@+@@юп OczPz­+>>7UGЃFF“р[@*@@lzPP>‚­Б>>G2CCшЌ)Q*Qœр@@aGЂFF­*>>9=zzPPЗYYIфy0V2V4VmGЁFFЉрo@@˜­А>>ŠzPрOxG FFe1CCЖр@@­+QІ­)>>бYY…GŸFFšzPPБ­Џ>>Хрn@@№FЩY­-Q,Q’GžFFхџYVYЋzPP>ƒ0CCП­(>>гр@QGFFйрm@@z1V3V5V@рOOЪ­Ў>>є$YVYЙzP2­.QНzИ:P:ЊGœFFчр@ырX@@и­'>>ЧzPPёYVYЁ/CCЗG›FFірW@@ц­­>>жz?PPУGšFFP­/QсT@?@#YVYЕ.CCAz6VkрOOсS@@ї­&>>бG™FFшz@PPсR@@&ќY§YYHЎЌ>>сQ@@j­0QпG–FFс?а-CC Ў%>>њz>PP5§YўYYNGЪYьG˜FFЎЋ>>­2QDY–рOїG—FFpz7V {=PPы,CC'Ў$>>79QYgGЬYH“FFV"YY2ЎЊ>>!{<PP™­3Q^!YYYH•FFc YVY+CC@Ў#>>=H”FF3{;PP РрOpYz8VŠGЭYuYYPЎЉ>>eсAAЗ­4Q,H’FF*CCE{PPPƒYqсAAK8H‘FF‰YcЎ">>R{6PPYFHFFе­5QqЎЈ>>щрO8)CC‡сAAžVYd{PPSHFFЭz9V”сAA‚Ў!>>ЋY™сAAu{PPbHŒFFO(CC сAAŽЎЇ>>ЗVYѕ­6Q7QЇсA?AFаGЯYсOpHŽFF†{PP ЎсAABСќYVYЎ >>=f'CCL^ЖсAA|HFFѓz:V;V<V–{PPЎ8QЌЎІ>>Ос AAŠH‰FFЧс AAмVYz&CCЅ{PP Яс AAОЎ>>9сO™H‹FF'Ў9QЩЎЅ>>ос A?AІHŠFF{=V>V?VјY•%CCцс AAП{PPзЎ>>=юсAAVYAЎ:QЕH8FFKісAA HаY Yв{PPчЎЄ>>aсOўсAAА$CCХH ?F€@?FK@QYЪHFKP@тAA1HвY\Ў;QаHˆFFKњЎ>>тAL{ @VAVCVDVEVFVGVHVщ{PP#VYйH‡FFJK*YЏЃ>>рH†FFK2OYтAAа#CCћ{PPˆсO9ќYVYыH…FFJKyЎ<QRHдYЏ>>ђH„FFK-тA?AF4тA|PP $ЏЂ>>§H<FƒFFJKt{BVOY<тAAIF‚FFJK№"CCUIJYBт?”Ў=Q2Џ>>7[юY№YYY I;F€FFJK!|PPЎсOI~FFFJK@ЏЁ>>~HеYI}FFJKkYY3| PP>ЏЎ>Q!CC#I|FFJKu чYщYыYэYYQЏ>>?*IFIKLP:DЁ{IVKVQYE| PP…YY^Џ >>зсO7I{FFJKŸHзY>IyFzFFKЬЎ?QW|P0 CC”YZ| PPnЏ>>GIFIK:D™ пYсYуYхYY‡тЈBBOIwFFK{ЏŸ>>VIvFFK’тBЯ{JVLVЈYцЎ@QFCCЌY§сO]IuFFJKu| PP ВY‹Џ>>fItFFKЭHйYлYнYсY“Џž>>qIsFFJKСмYVYЏAQžЏ>>‹| PPcCCyIrFFKІЏ>>тHпYуYј{ MVNVPVQVRVSVTVUVƒIqFFK$тOднYYJЎЏ>>Ÿ|9PPЏBQŽIpFFJKЙЏ>€CC˜IoFFKшкYVYит CC>IхYЄInFFJKЙ|PPЭЏ>>фт CC> |OV6ЏCQ—CCеЏ>>NтO­ImFFK§иYYђтCЫ|PPрЏ>>ИIkFlFFGK&IчYУIhFiFFGKPЏDQџтCQуCжYVYн|APP ЕCCёЏœ>> ЯIfFFKuтOM|VVXVь|PуCлIeFFKА>>lЏEQ3еYVYј|PгCCА›>>шIcFdFFK%у CC }P|ЏFQА>>ѕIFIK:ZIшYEдYY}PщCC$Аš>>т O{|WVYVJ`FaFFK/А>>}:PP YгYWYIу CC ;А™>>J^FFK*}PІЏGQCCJ]FFKIА>>6}PУт!OuвYWY*J\FFKŽIщYЄ| ZV[V]V^V_V`VaVbVcVdVeVUА˜>>B}PКЏHQmуC6J[FFK#CCvуCC>cА>>ŽYAJZFFKkА—>>”YY}PIJQY?вЏIQщт"OYvА>>NJYFFKЬ|\VтЏ JQKQLQMQNQOQPQQQRQЈЫYVYECCZJXFFKƒА–>>˜уCC q}8PPБVYёЏSQfJWFFK“А >>€}Pу#OдIъYsJVFFKУVWYАTQА•>>Œ}PgCCКуCЮVWY€JUFFKљ|fVhVЊА >>š}fPPТуCАUQЖА”>>ŽJTFFKЄ}PЭуCC>оYЉ}ePP!АVQ7у$O™JSFFKьVWY\‰CCХА >>Е}PєVWYІJRFFK3АWQбА“>>Т}P'}gViVўІYСYYюуCC ГJQFFKJыYьYЪ}PрА >>  ТYYGАXQ]у%OЋCCд}PПJPFFKъА’>>л}p:P:U˜ЭJOFFKЙYY[АYQїА >>фC7JэY%АYYLУCCP}jVkVlVэ}PБ‘>>лJNFFKфCCD,ЇYVYkАZQє}7PP‚у&OчJMFFK8ЃYYБ>>zА[Q~P?ЂYYБ>>ѕJLFFKтCC~PˆА\Q'Б>><фCCKw}mVP™YYKKFFK~P:U:Ју'O3Б>>KJFFK`YVY)~P:UmCЁА]QCCjQYBБ>>KIFFKoYJБŽ>>ЏА^Q9~P:U8aфCž} nVoVqVrVsVtVuVvVwVxVyVzVuY{YYUБ>>B~P:UPICCЭу(O.KHFFKiфC—JюY]Б>>J~P:U?rфCША_Q>U~P:ƒфCVеА`QJKFFFGKˆфCuБŒ>>:CCЧ}pV Yѓу)Oi~P:‘фCCІYYXKEFFGK…Б>>r~PБ>>ђАaQgKDFFKЛYZ CC˜Б>†~PТYvKCFFGKdCБbQф*OЩYYYЂИфCCѕ}{V}V’~PPm CC ЌБ>>…KBFFKжYž~PБcQнYИБ‹>>’KAFFKЇ~Pу YY‚ CCчYYЌ~ PLOPQSUVW\]aБ~PQ)БdQЧБ>>>ф+O   CBCFIKP8:@BDU_OЁK@FFKпфCИ~PKяYЯБŠ>>шфC$~|V~VУ~P;БeQ›CCкБ>>БK>FFKYђфCIOPQaЬ~PЅCCѕфCфБ‰>>РK?FFKMБfQќфCАCCdф,Oл~PхCёБџ>>ЭK<FFKYYЛCCFGKD^ хC5KёYч~P_БgQ§Бˆ>>N~V€VхCё~PнK=FFKЫCC Вў>>qБhQћ~P$хЇBBжCC‹ф-OыKFKВ‡>>@њYYIPƒБiQ#В§>>u~V‚VMїYYыCC>хB PXPXX\/В†>>•БjQ L>FFGK§CCВф.OvKђY>Вќ>>,P XX\ЇБkQlY CACL;FFKIВ…>>[хІBBš~ƒV„VcхЅBB< XPPXX\)LFKw№YYЙБlQWВћ>>? ABEFIKP:@QUVY\oхBF5L:FFGKqхЄB?BK XPX\$BEcВ„>>мф/OЪБmQ@L9FFK~хЃBBXCP–YrВњ>>†хЂBBТ~…V†V9BEML8FFGKсБnQ}Вƒ>>ЅцYY•хЁBB[LFGKsDPФKѓYєY‹Вљ>>х0OeLFЁх BBTBEљБoQ•В‚>>>ЉхŸBBш~‡VˆVУY‰EPЂВј>>hBEC ИхžBB ВpQlBEхKѕYЊВ>>бYqBEФхBBžFP+х1O2OЕВї>>zBEпYBE[ ‰VŠVBEОВ€>>ЯхœBB'ВqQ‰ 7<BE7<[лх›BBЪВі>>BEухšBBМGP–BEC вВ>>ЏL GG›BEPх3OџYях™BBŸBEC>нВѕ>> Ѓ>BE[DВrQ  кYмYоYрYтYфYYЈBEљх˜BBхВ~>>9‹VТLGжЬ??Pa>­BEВBEVY№Вє>>-LіYЪLGGFGJKц—BBр Ы??IJLOPainVYМBEц–BBгLGћВ}>>ыЪ???УBEeВsQtQwх4OЧBEмLGGFGJK№Щ??IJOaЪBEKPVц•BB Гѓ>>2Yј?аBEцLGъLGGFGKГ|>>dŒV)ц”BB;Y€Ж??нBEВuQ€ ?IJKOQVYZ\1ц“BBіLGGFGKГђ>>EжYиYY € ?IJLOQVYaLц BDEKP8:BDGUY€?(Г{>> х5O6OюBEM7FFKP@ц’BB€?іBE€?PQpLјY MFK5Гё>>_VYLц‘BB§BEžВvQ‹V(€?=Гz>>M6FFK-€?ZцBBHГ№>> $M5FFKЦх7O;€?dцBBRГy>>A€?Oa 2M2FFKoцŽBBОВwQxQI€ ?HKPQSVYZ\]VBE_Гя>>‚YYБŽV>DM1FFK4BE…цŒBBях8OxГю>>QM3FFKнВyQzQЃгYVYj€?“ц‹BBƒГw>>\M.FFKr€?œцŠBBйVPBDE8BGUfM0FFJK{€Ю??‘Гэ>>МбYVYY BDEIKP8BGUnM-FFKаLљYЌц‰BBќВ{Q|Q™Гv>>a//>?ABDFIKLMOP8:;=?@ABDEGHIJKLOPQRSTUVWXYZ[\]^_`aЦWYц9OЪWY{M/FFK€?ЙцˆBBj##ЋB D?ABDFKMP8:DGHIJKLOPQRSTUVWXYZ[\]^_a“€Э?? ЄГь>>фLћYЮY†M*FFKТц‡BBџVБГu>>w##?ABDFKMP8:DGHIJKLOPQRSTUVWXYZ[\]^_asuмYГ}Q|((?ABDFGIKLMP8:BDEGHIJKLOPQRSTUVWXYZ[\]^_a’M,FFKІ€Г??OPaBGвц†BBСГы>>ъЮYYœM)FFKА€В??M§Yпц…BBPЬГt>>Cц:OЛ€Б?? ЊM+FFK9Г~QQыцCB?B)€‘V’VкГъ>>ЖM&FFKѕц„BBуГs>> lYWYПM(FFJKе€А??) ЫYYЦM%FFKчBBBяГщ>>WГ€Qmц;OіГr>> чBBвM'FFK6MўYџY$YYДш>>Q€“VчB?Bэ€h??мM$FFKЧ DDAхM"FFK6TYZYY#чBBг DBDDYДq>>џ€?xГQиBDDYяM#FFK.чBUоD“ц<OCYYZMYїM FFKф DBDY>#Дч>>8чBB ?HIJKLOQVY\]N!FFK{€”V  š??HIJKLOV\>GчB˜Г‚Q N=FFK:ї >?BDO;CDUY4Дp>>\HYNYY%?IKLOQYaўDBDO:LYUчBBКц=O/?HIJKOYa DBDKHДц>>) pYY"NFFK:>_чBB8?IJKOaВГƒQ„Q…Q+NFFKhчBBЄ€•VA?IJKOYa=!!?ABDEFGKLP8:@ADEHIJKLOPQRSTUVXY[^}YZДo>>3NFFK–MY‚YYJ?QsчB%ABDK8O”YYGNFFK\?HQVYZoДх>>8D>BDFGKb?OVPNFFKŒчƒBBe?Ы€–Vh?HQV@DDДn>>ЈY•ч‚BBp?QY]_NFFKK>DFMDOюГ‡QŸчBBx?QVY]’Дф>> ч?O€?LOQVWYЛYYnNFFKЋчB^ >BDFIKMO:DQY‡‘Y?VYYŒ?VЕч€BBё€—Vd >DFIKOP:=DLUЃДm>>iD~NFKмMY”?QV ДˆQдYIJLQVYУчBsDDŸ?OPVYЗДу>>ЭчBBЅ?VD3ч@OуfYhYjYYЊ?˜NFK@›NFIK@Џ?)Д‰QŠQžNFKкчBЩДl>>˜VЃN:FFKЗ?HIJOYDђYYLфч~BB™DФ?HIJOYaJБN9FFKYLQVYœDDЪ?HIOѓчBоДт>>ЅDF:=UY]FД‹Q[чAOПNFK@ЌD§ч}BBж?HIJOYшДk>>`YY@™VšV›VœVЖ ABDP:ABGT]0NY шBт?HIJOPYѕДс>> YYНDц?ш|BBџДj>>ю?лNFhДŒQШD*bYdYYY‚чBOуNF; шBбD Ер>>чN6FFLNY§?8Y*ш{BBfVžVŸV V?LOQVWYкDBDGЕi>>ѕN5FFE VYXY\Y^YY ‚ ?HIJKOQVYшDD9шB‹ДQŽQ‚]??O4FFSY-Еп>>CшzBBєDDGЇчCOZ JYLYPYRYY*O3FFDD>QшyBBЁVЂVЃVЄVBЕh>>O2FFYшB  >DFIKM:AGU4‚?­ДQQoY((?ABDFGIKLMP8:BDEGHIJKLOPQRSTUVWXYZ[\]^_aˆNY:‚?cшxBBЉBBC-O1FFA‚?PQЭчDOYZЕо>>oшwBBH‚?"ЊBB†YY=O0FFR‚?gЕg>>}шvBBЯД‘QМЅVІVЇVЈV“YY2 BFIKO:GUVY_‚?9ЇBBPNO/FFŠшuBBBwЕн>>ЁYYЖNYg‚Z??ѕчEOCЈBB‚Еf>>™шtBB_OFKO:ABNBFGIK8:cO.FFяД’Q“QДYЕм>>ЅшsBBVABFP;YXІBBInO-FFПWY„‚Q??ъЉVЊVЋVЌVœЕe>>ВшrB?BШYY{OFPFgЅBABOSX[}OFFКшBшFOЕ”QpABEMSЋЕл>>š‚O??) ФшqBBкFYYŒOFFЖЕd>>ЭшBЄBBFIK:SфDYYЋ‚?›OFFзшpBBФЕк>>ь <Y>Y@YBYY0Г‚C??OVO Y YO YршB‚­VЎVЏVАV2Е•Q“BЭЕc>>ЉOFFEшGOѕYљY§YъшoBBТ‚ I?K?M??OVйЕй>>:YYёшBЩ‚B?E?G??VЙOFFуЕb>>а‚?8VWYZ\  2Y4Y6Y8YYћшnBBд‚ @?W?HLVW\ЌB#O YЧOFFщmBBSЕ–Q—Qо‚  P>??HIJKLOPa№Еи>>YnшHO0YY щBч‚=?K?IJK8OYеOFF§Еa>>O‚БV'.YVYщlBBЦ ЃBABP:ASTё‚;?ВY?ILYщkBBЮЂBAB\^1 YVY Жз>>цOFF$щBtЕ˜QзЁBBSƒ9?œY?JLY.щjBBVOYр B?ABIJKLOPQRSVY[\]aЖ`>>BYїO FF—шIO5щBw‚ ВVГVДVЕVЖVЗVPY?щiBBƒ 7?O?IJKOYP FFѓ ABEGK8@LSXPQWY\.Жж>>GщB˜Е™Qњ ŸB?ABHIJKLPQVY[\aŸ_ RYTYVYZY\Y]Y^Y_YaYYSPFQщhBB)ƒ5?I?HIY>Ж_>>yOYfYlYPFОшJO\щgBB ABA7ƒ 3?$J?HIJKYsY%PF ‚ИVžBBS[*PFЖЕšQQЖе>>{Y/P,FFkщfBBEƒ1?I?I•OYƒлYY"B?BQVsщB8P+FFbЖ^>>+ABTƒ?HQVWLAP FFP}щeBBхшKOвЕQ[ƒ/??) ЌOYIP FF†щdBBvЖд>>;BЂYSPFFщBЯ‚ЙVkƒ-?? CœBBЊЦYY\PFFщЕžQšщcBB†Ж]>>LBДIKOVYePFFVBGP:Tƒ+??) щLOnPFFРY™Жг>>sPFFЖŸQc›BBxPFFЅЖ\>>~PFКщB“ƒ)?? ЯYФщbBBƒКVwšBBДЖв>>мYP_FрIJKYІƒ'??Ж QЁQ5щMOшYТЖ[>>эHIYŠ  ™BABFIK:;DESДƒ%??ƒЛVѓHIJKYaЅPbF2ЖЂQфщaBBљYгЖб>>Уƒ#?? џYaлЖZ>>№щ BBPYXYYЃBЙPgF HIOY]щNOвƒ!?? ћщ BBLЖЃQHIJOYJцЖа>>%PYYѓЖY>>ЬPjF ъBрƒ?LQYМBцƒ/L?IL$KƒМV$YъBюƒ?LY9gЖЄQЅQ,HJYЗЯ>>оPxFъBЪ˜BABFKB# ѕƒL?JL2HIJOY,…щOOЗX>>$ъ BB§ƒ?Q8JYMPYeƒНVюPДF?Y-ъ`BB„??оBЗЮ>> „??aЖІQЇQфBCYKK “Y•Y—Y™YY$ЗW>>„?>?aQЙF<ъ_BBя  —BBFGIK:BDEUY„?>?a/ЗЭ>>Hъ^BBЎщPO#„??a›ЖЈQЉQ;ЗV>>QФFeYƒОV,„??BmYZъ]BB6„?F?FJЗЬ>>$QвF‡PYГЖЊQ–BBIKx ‰Y‹YYYYUЗU>>D„?F?FmъBP‚‡YY5QеFsъ\BBзщQOPYˆYcЗЫ>>R„??ЗƒПV YYƒY…YYЮЖЋQЌQ€ъB3BHQђF„ъ[BBoЗT>>_„??g„??Ѓ}YYYVQ#F’ъB~ЗЪ>>–ъZBBчЖ­Qp„??ъ{LLБ uYwYyY{YY>ŠЗS>>cQ$FP•BB:DUнƒРVy„?? ъzLLІъB„??) ЊъYBBъyLLpQ%F™ЗЩ>>†„??ФsYYъxLLЗЎQЁЗR>>ИъB‘„?? ~Q&FъwLLМъXBBгYpBЌЗШ>>š„??%ъ~LLкYŒQ'F„СVЖЗQ>>ЫъBЃ„??,ъLЗЏQЯъWBB0ъL5ъ}LLњPYсY­„ ?? šQ(FУЗЧ>>ы eYgYiYmYoYqYYY=ъ|LLмъBръVBBИ„ ?? ѕQY]=3ЗАQБQ‘”BBPUFъLЋQ)FќQVY]Nъ]LLиЗP>>Ч„ ??№ъB-„ТVYWъLєъUBBQYЛQ*FcYkYYKЗВQ­Bж„ ??cъLыBIYHJKY№ЗЦ>>ыTBB >Y@YBYCYDYEYGYYOЭQ2@@ф„ ??) tъL§ЗO>>$Yэ„??) eЗГQыBT„УV,YыSBBЬ“BBї„??фQЉЅЅ@@@@@@ @ @ @ @ @@@@@@@@@@@@@@@@@@@ @!@"@#@$@%@&@'@(@)@*@+@,@-@.@HHHHHH H H H H HHHHHHHHHHHHHJJJJJJ J J J J JJJJJJJJJJJJJJJJJJJ J!J"J#J$J%J&J'J(J)J*J+J,J-J.J/J0J1J2J3J4J5J6J7J8J9J:JNNNNNNNN N N N N NNNNNNNNNNNNNNNNNNN N!NSSSS S!SX$[%[ ИХ>>…ъL7<YYNQY…??>5Y:YY>ёQ?Q~ЗДQ‘ъL0ыB …?ИN>>4ыRBB›ъL_QY&Y-Y4Y;YBYIYPYWY^YeYlYsYzYYˆY‰YY‘Y…?ыB{„ФVя ’BBK:@DS_…?W3Y6Y8YYЈъLEыB–ЗЕQЖQ2ИФ>> …?IыBBqQ Y§BБъLPыBB(…?<ИM>>VыBB1…?НъLoYIИУ>>ЎЗЗQaыBB:… ?uYЩъLЂ„ХV{ILQVYOBiыBBTИL>>€ YYQгъLpыBB!‘BB8:@U86RHHB‰ YYNbИТ>>?yыBоъLЫЗИQ@R  VHFLPQRV\]ІQ!YW…"?’ YYыPBBnИK>>GRH?4BшъL— YYYьъZLLœYёъYLLыOBBAB}ИС>>Я„ЦVїъVLLІYHBCщЗЙQКQLBыNBBu…$?ˆИJ>>А(YYSBыLWB–ИР>>ЋыMBBыHLП&YYдQ"YaBыL ИI>>ИЛQМQЗыLBBf>BCHIQi BBFIK8:@DЬ$YYP“…&?!ыILќ„ЧV­ИП>>%ыKLУыKBBRФIIЖИH>>.ыLЯыJBB€B5ыLф"YY#ИНQ™RТIIТИО>>А…(?лыIBB@ыLЫИG>>R#YЉRУII!…ШVЩVчыHBBKыLњ YYšBFK:;DUIзИН>>OыL>ИОQПQSыLЖRСIsKIKѓыGBBЂBZыLуИF>> YYЋŒBBD_ыLХRРIIьFBBй…*?hыLYYђИМ>>> ьEBBYИРQЛ##>?@BFGHIJKLNOP:?DEFILNOPQSUVWXY\]^aebI…ЪVњИE>>qыL8R$YьDBBТ‹BBйRКII|ыLЙЛ>>ьBB€ыLтR IK:IJLQVWY1YYIчR`IЙI?HIL$ьABBг5BBFIK:KЙD>>wИСQ‹ыLюRИII†,?лŠBB/ь@BB”ыLЙК>>їRI:HYYr…ЫVšыL§RI:;ь?BB'ЙC>>э4BBKUЂыLSЗIIcR%Y“ИТQУQЉыLі‰BB3ЙЙ>>YYYIь>BBSЖI?HIY­ыLБыLSГI?HIY=ЙB>>ЖыLhYYY-†.?Vь=BBSВII 3BBNOWY]ь<BBš…ЬVЏИФQ$SБII JЙИ>>УыL BDYЩыJL{YYY,SЏIIhь;BBUЙA>>ЭыLR'YдыL6SАIItь:BB$ ˆBBВ…ЭVcЙЗ>>ŒY YY>S­IЎIISS†I0?пыLЮИХQфыL‚ь9BBGSIK:nЙ@>>щыL6 2B?BFJK@Ф…ЯVœY YYюыLOSЋIHI=S= 1BBK@Žь8BB|ЙЖ>>єыLVSЉIЊIIМR(YF BKLCDEчИЦQњыLq†"J2?ЊY_SЇIHI›ь7BBй…аV‰Й?>>ьLfSІIHI7<Іь6BBX BCmSIK­ь5BBўИЩQsSIK_ BCFэ…бV™ЙЕ>> c ,BBKL?CDEьLyS ЅI?HI?JQSaŽ†I4?Зь4BBЁЙ>ЅЙ>j BFK:;DЫY€SЄII  ьLсR)YЙЪQˆSЃIIХь3BB†вV,ьLЬь2BB} ‡BBS’S IIPЙЙ>4ьLЋ†O6?дь1BBK#ЙЫQšSdIŸIHIПЙ>:ьLкь0BBю Y†дVЁSžIIBŽ 0BBS@ьLть/BBFьL S*YЊSII–  /BBFIKLOP:BDESUKьLеЙ>ъь.BB:ЙЬQЭQž †BBDГSœIIлЙВ>>ёь-BBЪ†šY8?UьLїь,BB  YОS›IHI7†еVJЙЮQ§ь+BBшЙ>bьLА .BBKDЦSšII>э*BBёЙБ>>jьLЛ …BBDpьLбS™II э)BB_ЙЯQ3S+Y§Й>э†АY:?zьLлS˜II*  Yэ(BBКА>>Э -BBKD\†жV К>чS—III‡ьL%э'BBuЙаQбQК>и „BBDьLёS–IIUS,Y3э&BB™ьL‡K<?§S•IIŠЙвQгQш ƒBBIK%КЏ>>N Y?э%BB|† .H0H2H4H6HзVёVЅьLT”II і ‚BBK6КЎ>>Lэ$BBАьLŸЙдQеQT“IHIL)‡W??ЖьLyS.YWэ#BBTIKHК>СьL L8‡A?D?F?†йV&TI‘IIВЙжQ!BB:eэ"BBt YVК­>>!€BBG2T’IIpэ!BBH‡H?J?L?cК>F.!BBX‡N?э BB” YoКЌ>>ITIKФ†кVмЙйQёь LzК>WTŒIII“эBBК>r‡P?M!~BB:UbTŽIHI: ŸэBBŠК>ЦS0YЖ YѓЙкQkTIK“КЉ>>Y!BЌэBBэ LsT‰IŠII›К>a!}BB:UŸКЈ>>}T‡IIі†мVЛэBB‘‡R? КлQn!ABЉК>…T…I†IIЏКЇ>>з YюS1Yw! |BABFGIKLP8@EQSUX]ШэBBКмQнQ/э L‘TƒIIКК>!{BBСКІ>>жэBB›TI‚II‰!zBB,КоQЅTIHIтэBB“!yBBFIKDЭК>њ Y#‡нV­T~IHIеКЅ>>Nэ LT2YХ‡S?T?V?W?ЕT}IIёэBBAКпQсК>ПT|II §эBBщКЄ>>ЫTzI{IIєК>YКрQЙ!BnэLф‡U?4T3Y"!YюBBћКЃ>>еTxIHIХ!BS‡оVнTvIIЛ>mКсQЯ!B ЛЂ>>"юBBшTwIIЛ>и!BFIK:S‹эLЛЁ>>ёTcIuIHIн!ABVT5Y€КтQ2ю?ф!ABW4 љTbItIHI!Л>L!Y'Л >>UsIIэ! ?BFIKP:DHOQUVX\a“КуQфQѓ!>B UrIHIEю?1Л>ЇэLLIюE?EQњ!>AB]^7ЛŸ>> UaIqIHI$ˆX?Nю?‡пV"xBBIKDUIKh!YT6YUoIIЋКхQцQ^ю?LЛ>ЦэL(UpIHI/UIKHI]Лž>>6UIKP:УКчQшQ†!!Y'"B?UmInIIЅT7YjЛ>/"BчэLР‡рVIUkII_6"wBBFIK:IsЛ>>йКщQQUiIjII}Л>oˆY?ƒЛœ>>]UgII ­!#YЂюcDDgUfIHIђКъQыQю LLLLLLLLЮT8Y”Л>oUeIIЌюbDDF\"Bd"BЁЛ›>>zUПII ЛьQk"vBBFKј‡сVНюYDD#ю LLLL L!L"L#LЌЛ>ж!%YХю`DDГЛš>>ѕT9Y–UОII>#ЛэQдюJDDDПЛ>ЧЛ™>>Еˆ[?Aю$Lё!'Y‘"BтюNDDЊUIK86ЛюQвЛ>­UI™"B(ˆтVБU_IIPэю_DDйЛ˜>> "uBBK:U:YИU^IIїюIDDуЛ>^ю%L")YРU]IIщЛ—>>QЛяQШU\IIяMDDFѓЛ>",YЯU[IIDљЛ–>>я^DD$".Y9U<YиUZII eЛ№QQЦ"BяHDD{ю&LМ>рUYII1"0YZˆуVфVЮ"B М•>>чUXII%яLDDvЛёQе"tBBK::"2YюUWIIМ>0я]DDѕUЛIIKƒЛєQ˜ю'L!М”>>‰\?:яGDD)М>-М>VVIIKPkU=YFяKDDVTIUIIK›ЛѕQіQћ"BOя\DDЕю(Le"4YVRIIJKW#BAМ>WяD“ˆхVV IQIIJK #sBBK:ЌЛїQGМ>%VPIIJKaяD9‰^?,VNIOIIKбю)L–U>Y5VLIIJKТЛјQ]М>cМ‘>>KVIIIKйЛљQњQЦˆцVюю*LyМ>>SVHIIKяDPi‰_?–яDDEDD]VFIGIIK…М>ЦU?YяЛћQќQ яFDDМ>gVDIIJKИ"9YV#qBBK:Јя@DADDE•М>oVCIIJKя+LМ>>wVAIBIIKГяBDDEМ§QўQМя>DD8V?IIJKњˆчVшVТя=DDEš‰`?‰V I>IIJKБМ>9?FГМ>МџQ-я,L3L|#B‘V I=IIJKЮяDEКМ>р";YєU@Y„#B™V<IIJK еяDEТМ>‹#pBBFK V I;IIJKмя;DDEЪМ>0МQQFя-LЇV9IIKљ"=YAYвМ>шя<DDEАV:IIJK>кМ>ђя9DDEЗV6I7IIK.‰щVъVEМQVAY[я0Lг‰a?b?чМ>УV8IIK№:DDEяМ>#?YFYЭVIKЙ#B]МQQ№8DDћМ>дV2I3IIKФ#ABUzя1L№7DDНŽ>>сV4IIKЭ# ?ABFGIKLM:BEHIJKLMOPQRSUVWXYZ\]aFVCYqМQ5#HY#№Dе#ABFGIKL:BEHMOPQSVWY]aNb‰ыVН>ьV0IIKН>F-№5D6DDн#BFKŠc?Н>FѕV/IIKН>F—я2LF#MYц#oBBFK‡МQ8№3DD$Н>F'Н>FW.IIKA№1D2DD-Н>X#OY W-IIKoVDY6Н>L№/DDFœМQ;Н>=Ея4LW+IIK>Н>U№.DDE–‰ьVFН>!W,IIK]№-DDEq#QYUYАМ Q QNН>$nBBK:*W*IIKg№,DDE>Šd?SН>‘VEY2W(IIKдя5L^Н>=s№DDФМ Q>DW&I'IIK€№*DDE•#SYuН>>NW$IIKŒ№'D(DDEЩ‰эVнМ Q№я6L@$BFIK:SYИVFYVW"I#IIK€НŒ>>E$B:—№)DDEЏ#WYbW IIK‹Н‹>> №$DDEyŠe?P$B:їМ QQlWIIIKY$B №7L8LЌ№%DDE™Н>œН>Ф#YY`YvWIIKc$B:ŸН>нVGYЖ№"DDE~WIIIKЇН>Cl$BKP:ЋН>НQQ§‰юVяVs$BK:Х№#DDEŠWIKU1"БН>x$BK:Q)№9LЂŠf?€?ЖНŠ>>WIIK~$BK:Fф#[Yв№!DDEƒ$mBBFIKDќVHYšWIIJKУН‰>>АŠg??™?)НQQм№ DDEЂWIIKаНˆ>>I№:Lњ#bYш№DDE­WIIJKЧŠi?№№DЕWIIK@НQнН‡>>0Š№VWJYЋ$BРWIIK§№DDъН†>>$dYhYi№ ;L<L=L>L?L@LALBLCLDLELЪWIIK ёDZНQЙ$BѕН>QќН>жWIIKУ$TBBёDDюŠj?О„>>рWIIKƒ№ FLGLHLILJLKLLLMLNLOLPL"ёDrНQQО>NWKYьWIIKdŠѓVО>=$fY,ёD‹k?О>їWIIKŠНQ'О> №QLю$BXНIIKё$lBBIK0О>Z$jY$‹l?<О>xWLY‘ŠєVЅНQEО>X IIKPП№RLr$lYpY%XМIIKQО>,XIIK@‹m?КНQ%RBBIKYО>4XIIKrё EE>cО>=XIIKо№SL`LЭНQЇWMY€ё EE>EXIIKmО>•$nY\‹n?LXIIK‰ёEExОƒ>>=?ђ№TLSXIIK‘ёEE>D%kBB€О>ZXIIK—ёEE‚О‚>>Ў$rYaXIIKŠО>B ёEE>x‹o?ђНQŒО>> ёULjXIЇёEEK”О€>>дWNYГёEE ŸО>ЂО>}XIёWLЮ$tYzYl%QBBНёEE–‹p?q?ФёEELОQŽX!IЗО>>ЮёZDDћWOYжёDDТО>А‹r?ХО~>>ЁX%IпёDDFёXL ‹іVаО>—%jBBшёDDдО>иО}>>ВX1Iяё&DЦ‹s? %vYуО|>>JОQ$XQYђ0DЦX5IэО{>>9м‹t?oё[LјОz>> П%PBB ђ4DйX@IS‹їVП>F-%xYё^L Пy>>ї‹u?LXRY%ђ?DъXEIПx>>€ОQKQПw>>ћXMI7ђCDŒv?ŠО QLQhQъ%iBBK:'Пv>>œё_LmXSY YSIHђ ?3Пu>>]%|YœО#Q‹‹јV)Œw?ЗёaLBПt>>YhI&OBBNПs>>|%~Y.YlIЛО$QDŒx?VПr>>“XTYжёbLaПq>>?YyIаО%QlПp>>\Œy?ˆђJFFPY€I=&hBBK:zПo>>Ы‹љVЗXUYѕёcL”ђFфО&Q‡Пn>>tŒz?aY„IА%€Y”П>>њО'QђdLеXVYtYˆIe&NBBЃП>>Œ{? П(Q…Y‹I*ђeLŒњVн%‚YѕXXY П)Q—YIТП>>ЏŒ|?кђGG &gBBK:DђfLgLhLЊYЈIцђGў%„Y;П*QяђGнП>>КYЌIЮŒ}?^ђiL§ђGFG(YYYѓGЪY?WП+QИ&MBBBŒћVјП>> ѓGG>wђjLѓGG эŒ~?.&†YѓGGKpП,QРm>>)ѓG?-ѓG’ђkLB&ˆYŽYTYZY1ѓGу&fBBF5ѓG‡П-Q$Рl>>9ѓGxŒќV=ѓGAѓGЉђlL‚?Z;JJGNѓG;Рk>>ZJЃП.QWѓGZJ^q&ŠYŒY^ѓG…Y[Y'LBBFK=ƒ?ЫђmLiѓGWР>ТП/QtѓGG>АŒ§VhР HI I I III> > >ѓG•&Y_„?tР HJJJJJJJJJ!J > > >эђnLДY\YоП0Q’ѓG€Р>Ј&’YF'eBBšѓGbZ~KKР>ЃѓG ѓoL€…?mZ}KKјП1Q˜Р>wZ|KK ГѓGнY]YЃР>а&”Y˜YZK;ОѓGљŒўVџV‡Z{KKАР>(ѓpLv'KBBFKФѓGЁ†?ЪѓGЛР >аѓG˜ZIKKжѓG&Р2QмѓGЁZtKKЪР!>є&–YEѓqLтѓGZ_YшѓGТ‡?кР">юѓGЖZBKKBєѓG\ѓrLЉ'dBBKњѓGчР#> '›YХZKєG>VTР3QЬZKєGіР$>2Z`Yхˆ?‰?єGwѓsLиZKєGС%>єGфZK$єG9'Yж'JBBС&>ŒѓtLяZKM8FQ[+єGŽŠ?UZaYєZ;KK2єGС'>…Р4Q9єGwV@єG-С(>[4KKЉѓuLEєGŽ‹?KєGb'žY<С)>PєG[-KKUєG(cBB}ZbYZєGJС*>_єGХѓvL:ŽŒ?'[zKKFdєGЙР5QjєG4[yKKpєG^С+>БVVvєGЃZcYрѓHJK|єG'ŸYkС,>D[xKKцѓIJKa3(IBB‚єGZŽ?ьѓIJKˆєGP[љKKёѓK{С->єG”єGћѓK^[wKKFšєGУZdYэР6QєIJKyŽŽ?ЂєGєKi[јKK“С.>ЈєGєKР' Y­єGыVVv[vKKGc(bBB С/>єKГєGЗєGєKЛєGхZfY–Ž?ПєG­С0>…[ёKKУєG*єKЧєGЫєGИС1>3єKЯєG С7Q–[uKKCгєGзєG<єIJKХС2>лєGŒ(HBBЖŽ?CєKKЄ[юKKсєGѓ'ЁYцєGгС3>%ŽVOєKK>ыєG[gYД[№KK№єGѕєGтС4>ZєKKћєGгŽ‘?KС8QХ[эKKfєKKѕGёС5>ѕGИ(aBBpє KK  ѕG$(ЂYе[яKK:[hYџС6>ѕGyє KK№Ž’?ѕGG ƒє KK Т7>у[ьKK_ŽVwС9Q*ѕG?FGТ8>єK№[rK@K@с(FBB2ѕG?G“?єK:ѕG'Т9>f[iY\K@7Т:>MѕGc(ЃYЄYЇС:QМєKEТ;>\qK~@K@˜ŽV )`BB@5”?`ѕG+\+KO@K@[jYZТ<>3\,KP@K@sѕGмєKiТ=>A\pK}@K@Y•?6)EBBIK†ѕ GжС;Q›(ЅYД[kYyТ>>Y\*KN@K@вŽ V VќєK™ѕ G†ТF>a\)KM@K@}–?—ТG>p\(KL@K@Ќѕ Gb)_BBк[mYy\oK|@K@^PЪ(ІYТ<QѕK€\nK{@K@^™—?‡\KP:@_ВТH>Š\mKz@K@^Шѕ G‘\KP@  V”\lKy@K@^›\K@ž\kKx@K@^1 ‹)DBBAѕ KЬТI>Ѕ\KP@_`рѕ GЙ˜?2Т=Q>Q?QЉ\jKw@K@^" љ(ЇYЈY \nYВ\KP@P_`Ж\iKv@K@^2 Ь›?іѕGН\K@P`С\hKu@K@^8Ц\K@P`gѕ!KёТJ>Ъ\gKt@K@З)^BBE V7\oYд\K@PіGъœ?bТ@Q))ЉYк\fKs@K@с\K@BPч\eKq@K@Šѕ"K*іIF?F?р)CBBУK>ї\'K)@K@2і-?EF?F]&K(@K@>і,?DF?Fg\pYT)ЊY’ТAQ V ]%K'@K@­ѕ#KHіCF?F$ž?<УM>]$K&@K@[іBF?F *]BB!]#K%@K@MУR>*]"K$@K@AŸ?аѕ%K&K$KlіAFF€)ЋY•\qY^УS>6]!K#@K@УТBQ?] K"@K@{і?FF:ЙV5*BBBK]K!@K@` ?Ё?ŒіFyУT>єѕ'KU]K @K@•іFН\rYЌ)ЌYb]K@K@žі=FFёТCQ{Ђ?k]K@K@”УU>Љі;FFa*\BBw]K@K@Ч)ЎYі(K)KђV’Ѓ?Лі9FF€]K@K@ч\tYЎУV>Œ]K@K@Юі+?7F?FУDQт)БY•]K@K@ЉЄ?9і*K+KŠ*ABBЦУZ>Ё]K@K@пі*?6F?FЊ]K@K@зУ[>ХЅ?юі?5F?F+V]uYЖ]K@K@\і,KП]K@K@NУEQџі?4F?FёУ\>Ж*[BBЫ]K@K@рІ?д]K@K@ї?3F?F@]vY~і-K.Kр]K@K@ Фd>љЇ?щ]K@K@eV/ї?2F?FФe>є]K@K@УFQч*@BBœі/K0K;ї?1F?F‘Ј?^K@K@T*ГYn]wY ^ K@K@8Фf>Oї0F?F^ K@K@.‘Љ?Мі1KYї/F?F ^ K @K@cїHFFГУGQŸVSФg>,^ K @K@}*ДY+ZBB:G‘Њ?5^K@T\š]xY;^ K @K@мі2K3Kwї ?.F?FkФ==G^Z@K @K@c‘Ћ?Œї ?,F?FR^V@K @K@~Ф==ћі4KЋ*ЕYI+=BB^^Y@K@K@еVьУHQР]yY ї?FФ==h^U@K@K@Ћї ?-F?F„‘Ќ?s^K@K@ї5K}^dKKЈФC?FНїFш]{YБФC?л*ЖYz+YBBKŽ^KKPЄ‘­? ‘VОФC—^KKP"ФIQжї)??F<ї6KЧФCЁ^KKP^|YиФCFФ‘Ў?В^KKлФCоФCѓїFК^KP:[ї7KЈ+<BB:+ЗYР^џKK=‘VШ^ўKKм‘Џ?VФJQјFєФC3^}Yа^cKK н^§KK€ї8K ХC?!јGFFц^Kј‘Д?Х?ХCй+XBBFK?+ИYђ^ќKKZ^~YƒФMQ5јF’Е?t‘V%ХC?§^ћKKFю+B+ХC?Єї9K_ыKK>јFFF/ХC ’З?_њKKќ+WBBFIK:D8ХC?<Х7_K^YXј+FFl+ЙYКYЌФNQ7’И?Й?,VBBK:Цї:K'_Kfј*FF1_KЉ‘RRRtј)FF%,UBBIN’К?Л?ž^€Y=_їKKЕ‘'RRA~ј'FFF_іKKшїXJHIJеФOQ6,BТ‘#RR‰ј&FFO_єKѕKKf’М?Є+ЛYіїWJIJ€ХД88.”јFF,BZ_K˜ј%FFг‘RRП^‚YŠХ8јIJR,Bh_ђKKU,SBBKр‘RQR јVJHIJЇјF€’Н?–ХГ88q_KАј#FFэ‘RPQR]јJХPQ{_KјIJЉХ˜88Fћ‘RRРј"FFг+МYНY†_Kщ^ƒY)јJДХ8Ъј FF1јHIJ  ’ RRDЛХВ88–_ъKKƒ,BK8јJJ JIJдјFFЊ’О?П?_щKK>јHIJ,BBјJојFFЬХ•88Ѕ_bKK_’,B’RRIHјJ0ХQQ _„YеХ8MјJщјFF&’PRRRRјJЧ’Р?,ОYЁ,BнХБ88mЖ_шKK_єјFF\јJхХА888aјJТ_KY_ыХЏ88rљFF9’RВ,BGgјJЗ,BЬ_`KKѕХЎ88mјJљFF4_…Yх’С?sјHJљFF_ХRQЦ­88:xјJJ JJ8}јJJ JJ о_чKKЦЌ888V’R-,ПY‚јJљFFЦЋ88Ѕц_цKKЦЊ88gя_хKKF“Т?-љFFЦ”88Z_†Y—ј J Ц8ј_фKKц,?BBt’ R:љ(?F?F'Ц8ХSQ`уKKV,РY `тKKЋј JHљ'?F?F “У?8ЦЉ88ˆ’ R`Kz_‡Y`сKK AЦЈ8:8:Пј JJJJJJ!`рKKœ’ RГХTQdљ?FRЦ 8082838“8Э:8:N->BBFK+`пKK>“Ф?VЦ8:Bjљ&?F?F€,СYYЦ’8Ь:8:N- дјJJJ J4`оKK^Ц8/8‘88œ_ŠYcЦ8.888Е’ R>`нKKhЦ8-888mЦ8,8Ž88H`мKK\“Ц?sЦ8B‡љ?FvЦЇ8QB8BяјI#JкХUQS`лKKљ?FЯ’R—љ%?F?F„Ц8 B8B\`кKKЌ,ТYK-GBBu“Ч?ŽЦ8BC f`йKKЫ_‹Y љ%J–Ц8Bp`иKK­љ$? F?FœЦŒ8 B8B№’R“Ш?ЦVQ{`aK:K:Иљ?FЅЦ8*8‹88ЉЦ8)8Š88cПљ? F?Fе,УYЎЦ8(8‰88?ВЦ8'8ˆ88Чљ? F?Fy-BFKЗЦ 8%8‡88i0љ&J`зKV:K:ѓ_ŒY-BBBmМЦ 8"8†878Ј“>РЦ 8!8…88o™`_K]@K@жљ?F?F“RЦЦ 888818„88ЪЦ88ƒ88K/ЦWQЮЦ88‚88П_–-+BBгЦ8888\П“і>>ў,ФYзЦ88€88ћњА`K@ыљ?F?FмЦ88888Uљ'JсЦІ8:8:1“R `YЊ-*BBж“є>>њ?F?FХ`K@Ш`^KK-ХYѓЦ~8Ъ:8:NЙ-)BB[ЦXQјЦ}8Щ:8: њ?Fч“>њ?Fз`жKKЧ|888yљ(JQ“R R$R(RШ-(BB>њ?FЧ8о`еKKњ?F?Fї“>ф`]KK Ч8+8{88ћ“>K`ŽYb“Rз-%BBЧ8&8z88”>Ч 8$8y88ѓ`дKKG ”>CЦYQZQ3њ?F?F Чx88. ”>њ`гKK”о>>щ-B@љ)J'Чw88a\KK+Чv88:{“Rё-BAњ?F?F/Чu88”№>>3Ч 8#8t88Dp`Yљ-$BBaвKK9ЧЅ88e(”я>>aбKKWњ"?ўF?FaTKK .  #BBFGIK8:@D^_•“RЌЦ[QСљ*J+J6”ю>>NЧs888.;BB*aХKKfњ?ќF?FA”>WЧ8PЇ“R2aK—`’Y_Ч8 8r88tњ?њF?F%.BB9aKO”>=dЧq88hЧp888@aK..BЙ“RlЧo88T”>=‚њ#?їF?F[”>=pЧn88HaKзЦ\Q8.Bэљ,Jb”>=Œњ?ѕF?FQaKA.BXaKЧ8@_2 д“Rp”э>>Р`“YK.BB‡Чm888_aKQ.BBЁњ ?єF?FЧQ888gaKY.:BB•ЧP88oaK”ь>>›ЧO88Вњ?FЧ]QxaKЁЧN88vњ-JЕњ?FИњ!?ђF?F№“!Rт`”Yk.BЈЧL88FaK—”ы>>­ЧC888t.BВЧ@888ŠaЙKKШњ?№F?FЗЧK888a­KK ”"R€.BНЧB888šaЁKKУЧ?888Ў”ъ>>књ?яF?F,Ч^QЩЧJ888Ž.BAњ.JЅa•KKЮЧG88šuК”щ>> a•YгЧF888˜.B­a[KKыњюFF'”%Rž. QQBKLOPQкЧE888Ч”>ЖaZKKрЧD88\Ѕ.BЮ”>хЧ8:LVYKНaKљњэFF.ЧY­.BыЧ8з”ш>>ЦaYKK№ЧA88hњ/JUЧ_QЗ.BћыFF.a–YіЧM88аaKJ”&RќЧS88tУ.Bэ”>ШI88cћщFFмaXKKЬ.B@ ШH88тaWKK0.ШYШR88o$ћшFFћ”ч>> Ma—Yз.BыaVKKШ8њ0Jђa”KK/ћчFFЧ`Qn”)R!Ш8ћaUKKF•>ы.BQ.ЩY>ћхFF+Ш8b“KK2Ш8•>na˜YJћFbKў.B‰”*RPћуFF>Ш8,•>Књ1JbKGШ8­ЧaQ6•>…ašY/ _BBL]_&b’KKOШ8aћсFFu.ЪY/BЅ”QB•>YШl882b‘KK_Шk888K•>'/B;bSKKeШj888wћF|ћрFFT•>./B@kШi88u5/BrШh88JbK]•>›.ЫYкЧbQЏa›YC/Bm•>ƒШe88šћнFFˆШd88`bKKKP/BBŽШc88+ѕjbKK~•>•Шb88ЊћFвaœY^/B›Шa88rbQKŒKKЎћFФ.ЬYЭYЮYГћлFFы”&[[ЂШ8zbPK‹KK>•ц>>і”[ЊШ`88ƒbRKŠKK ШcQџ”[БШ_88ž•>w/9BBFIK:_‹bK:-ћ3JЖШ^88bOK‰KKЬћйFF•![[НШ8њaYщ.ЯYšbˆKK зћFЏ•h>>‰/BЧШ]88c•[Ђb‡KKоћFЭШ\88 •[хћзFFвШ[88Ќb†KKР•>%• [[зШZ888?ШdQнШY88\ђћFЪ•>ИbƒKKFѕћеFFІ/ 8BBFIKP:D уШX88 /аY bžYг•>шШW88aћ4JУb…KKF;•[й•c>>юШV888ќгFF?•[И/BЬb‚KKF•[јШU88ц•b>>ќFТ/7BBUйb„KKќбFFЩT88э•a>>79<=?@bŸYѓ•>//бYX•[ Щ8nШeQа/BфbKKЩ8†ћ5Jљ•>a•[ЩЄ88'ќЯFF–х>>яb€KKн/6BBЩЃ88i•[ЩЂ8887ќFќbKKщ/ >ABKP:AL\8bb Y'ЩЁ88s•[ю/B–]>>BќЭFFV/вYгYc~KK1Щ 88–ШfQqQ–>~•[7ЩŸ88o'–>=Щž88Жћ7J6Jc}KKSќЫFFŽ•[Q[/–Y>>€bЁYEЩ>88i—•[[=!c|KKJЩ=8880BOЩ<88.cќF<–X>>Ђ•[[PhќЩFFUЩ;88ИШgQ/c{KKXЩ:88.C–W>>}/дYеY[Щ988I–>^Щ888aЩ788vdЩ688Д•[ућ8JZ–Q>>30BpЩ8жШjQsЩ8KcyKKˆќХFFФ•[ [g–P>>Є/жYYcxKKm–O>>˜ќУFF…Щ8л• [hcwKKЮbЄYЈќСFFY0 B‚–N>>ќ9J›Щ8ЩkQŸЩ8wcvKKЫ/зYИќПFFѓ• [ [’–L>>ЇЩ8†cuKKАЩ8ШќНFF –>ЖЩ8{0 BНЩ8–ctKKЉ–>ТЩ8иќЛFFБ–>,ЩlQЩЩ8ђ/иYcЅYИ–>Eќ:J– [ЇcKаЩ8ЋcMK:K:™0 BщќЙFFзЩ8Ф–E>>оЩ8іќЗFFМc rKl:sKm:K:щЩ8ФcK:0йY>–[[л–D>>?F§ЕFFёЩ8VЩmQЫcpKj:K:бc nKh:oKi:K:ћЩ48Т0 Bvќ;J§ДFFйclKf:K:ы–C>>?F>C?FшchKb:K:ў–A>>FxЩnQЪ—8*§ГFFяcgKa:JK:e–[ —@>>?FіcK:!Ъ™88§ВFF—?>>FўcfK`:K: ќ<J{–[ѓ0 BdeK_:JK:C§АFFP2Ъš8—>>>?FZ0кYddK^:K:$—>›ЩoQdcK]:JK:’–[CЪ›8X§ЏFF!dbK\:K:†cЉYУќ=J7—ф>>TЪœ8,d]KW:KP:l§­FFЉ–[I—ƒ}}}у> FFFFFFFF F"F$F+F-F/F1F3F5F7F9F=FBFDFFFHFJFLFQFSFUFXFZF\F^F`FbFdFfFhFjFlFnFpFrFtFvFxFzF|F~F€F‚F„F†FˆF‹FFF‘F”F–F˜FšFœFžF FЂFЄFІFЈFЊFЌFЎFБFЖFИFКFМFОFРFТFФFЦFШFЪFЬFЮFаFвFдFжFиFкFмFпFтFфFцFъFьFёFѓFіFљFћF§FџFFFF F FFFFFF!F$F(F8F:F<F>F@F>?FТЩpQ7daK[:K:%1BeЪ8y§ЋFF@d _KY:`KZ:K:U—т>>Л–[цќ>J[—>…§ЉFFKdK:c—>xЪ79<=Ђ0мYЫ–[’§ЇFFWdK:k—>Ъ 77CшЩrQsQt—>Ÿ§ЅFFЩcЊYп–[Ъ 77}—> §?J@JAJBJCJDJEJFJGJHJIJJJKJLJMJNJOJjd\KU:K:X1Bpd[KT:K:‡—>В§FxdZKS:K:ђ–[И§ЃFF‘—>ІЪ 77~dYKR:K:ЪtQ†dXKQ:K:ЏЪ 77—>ŒdWKP:K:—[4§PJ”dVKO:K:г§ЁFF­—>УЪ77э0нYždK:Œ1B—[ЈdUKN:K:6ЪuQеЪ 77?dЋYУ—>АdTKM:K:я§ŸFFмЪ77V§QJЭ—>тЪ7<7<ЛdSKL:K:2—[ыЪ79<=А1BФdRKK:K:к—>ўFFЬdQKJ:K:ѕЪ79<=H—[^ЪvQжdPKI:K:џЪ7?FLYь—с>>z§RJЫ79<=ў›FFрdOKH:K:б1BЫ7<7<Q§—>c—"[Ыб:79:<=NьdNKG:K:(ў™FFЫ Ш:79:<=?NA1оYпYWdЌY˜>Ы9=?NїdMKF:K:ƒЪwQ9ў—FFž§SJTJeLK:K:|—#[є1B˜>Iў•FF%˜>eLK:KP:“—QЈЪxQZў“FF!eKP:Т§UJ9˜>+e JK:KK:K:oў’FF 2BH˜р>>—d­Y8eK:dЫ=::{ўFFЮЪyQDeK:ц§IZ˜>pЫ:M^˜*Y-Y>:Yь§IˆўŽFFb˜>PeHK:K:ѕ§IІ1рY“ўF–ўŒFF[eGK:K:§§IK2Bз—&\\deK:ўIр— \Q\ ўIЇўŠFF€˜п>јF>FјЪzQoeFK:K:ўIўIйdЎY№—%\LOPQ\aze DK:EK:K:Жў‰FFўHHHI•˜>љ—\§—\Q\'ўHIˆeK:Хў‡FFv2BЖЫ";;Ѓ˜>eBK:K:2ўI!Ы{Q˜$\OPQ\9ўIТЫ!;;Ќ˜>8œe ?K:@K:K:иў…FFБ˜>џdБYAўI.Ы|QЫЫ ;;˜\Q\ё1сY”2BхўƒFFЊeAK:K:KўI͘н>>еЫ;;PўI@Ы~Q-˜#\L\aЖeK:пЫ;;YѓўFFۘм>>\ўIщЫ;_MЫQcўIџF=˜"\Q\ШeK:џFFlўIп˜>М2BјЫ;;qўI_ЫQ8eВYI˜\\Pъ˜л>>иeK:Ь;;LYyўIўIџ}FF Ь;:;QmЫ‚QZ˜\\L…ўI‹ўHIЬ;;IэeK:л2B™>‘ўIB2тY€Ы„QЬ;;I—ўIIII *n˜\šўI7џ{FF§eKKaDKD™>'Ь;;LjeГY1Ь;;I f 4KODJKDE^ЌўII I I fKDњ2BKџyFF˜Ы†QŽQ9Ь;;IafKDAЬ;;LfKD0™к>>ЊЫˆQСўIIJЬ;?"fKD:™й>>EсC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_gmp_gc\dll_gmp_gc.vcproj/Od /I "..\..\\" /I "..\Win32\\" /D "WIN32" /D "_DEBUG" /D "_WIN32" /D "HAVE_CONFIG_H" /D "__GMP_LIBGMP_DLL" /D "__GMP_WITHIN_GMP" /D "_WINDLL" /D "_MBCS" /Gm /EHsc /RTC1 /MDd /Fo"Win32\Debug\\" /Fd"Win32\Debug\\" /W3 /nologo /c /Wp64 /Zi /errorReport:prompt /D_M_X86/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_gmp_gc\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_gmp_gc\c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\assert.c/Od /I "..\..\\" /I "..\Win32\\" /D "WIN32" /D "_DEBUG" /D "_WIN32" /D "HAVE_CONFIG_H" /D "__GMP_LIBGMP_DLL" /D "__GMP_WITHIN_GMP" /D "_WINDLL" /D "_MBCS" /Gm /EHsc /RTC1 /MDd /Fo"Win32\Debug\\" /Fd"Win32\Debug/vc80.pdb" /W3 /nologo /c /Wp64 /Zi /errorReport:promptc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\compat.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\dump.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\errno.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\extract-dbl.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\invalid.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\memory.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mp_bpl.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mp_clz_tab.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mp_dv_tab.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mp_get_fns.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mp_minv_tab.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mp_set_fns.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\rand.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\randbui.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\randclr.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\randdef.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\randiset.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\randlc2s.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\randlc2x.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\randmt.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\randmts.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\randmui.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\rands.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\randsd.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\randsdui.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\tal-reent.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\version.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\add.c/Od /I "..\..\\" /I "..\Win32\\" /D "WIN32" /D "_DEBUG" /D "_WIN32" /D "HAVE_CONFIG_H" /D "__GMP_LIBGMP_DLL" /D "__GMP_WITHIN_GMP" /D "_WINDLL" /D "_MBCS" /Gm /EHsc /RTC1 /MDd /Fo"Win32\Debug\mpn\\" /Fd"Win32\Debug\mpn\\" /W3 /nologo /c /Wp64 /Zi /errorReport:promptc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\add_1.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\add_n.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\addmul_1.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\addsub_n.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\bdivmod.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\cmp.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\dc_divrem_n.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\dive_1.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\diveby3.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\divis.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\divrem.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\divrem_1.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\divrem_2.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\fib2_ui.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\gcd.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\gcd_1.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\gcdext.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\get_d.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\get_str.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\jacbase.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\lshift.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\mod_1.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\mod_34lsub1.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\mode1o.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\mul.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\mul_1.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\mul_basecase.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\mul_fft.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\mul_n.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\mullow_basecase.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\mullow_n.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\perfsqr.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\popham.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\pow_1.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\pre_divrem_1.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\pre_mod_1.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\random.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\random2.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\rootrem.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\rshift.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\sb_divrem_mn.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\scan0.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\scan1.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\set_str.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\sizeinbase.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\sqr_basecase.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\sqrtrem.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\sub.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\sub_1.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\sub_n.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\submul_1.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\tdiv_qr.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\win32\fib_table.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\win32\mp_bases.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\scanf\doscan.c/Od /I "..\..\\" /I "..\Win32\\" /D "WIN32" /D "_DEBUG" /D "_WIN32" /D "HAVE_CONFIG_H" /D "__GMP_LIBGMP_DLL" /D "__GMP_WITHIN_GMP" /D "_WINDLL" /D "_MBCS" /Gm /EHsc /RTC1 /MDd /Fo"Win32\Debug\scanf\\" /Fd"Win32\Debug\scanf\\" /W3 /nologo /c /Wp64 /Zi /errorReport:promptc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\scanf\fscanf.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\scanf\fscanffuns.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\scanf\scanf.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\scanf\sscanf.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\scanf\sscanffuns.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\scanf\vfscanf.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\scanf\vscanf.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\scanf\vsscanf.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\abs.c/Od /I "..\..\\" /I "..\Win32\\" /D "WIN32" /D "_DEBUG" /D "_WIN32" /D "HAVE_CONFIG_H" /D "__GMP_LIBGMP_DLL" /D "__GMP_WITHIN_GMP" /D "_WINDLL" /D "_MBCS" /Gm /EHsc /RTC1 /MDd /Fo"Win32\Debug\mpf\\" /Fd"Win32\Debug\mpf\\" /W3 /nologo /c /Wp64 /Zi /errorReport:promptc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\add.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\add_ui.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\ceilfloor.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\clear.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\cmp.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\cmp_d.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\cmp_si.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\cmp_ui.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\div.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\div_2exp.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\div_ui.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\dump.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\eq.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\fits_sint.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\fits_slong.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\fits_sshort.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\fits_uint.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\fits_ulong.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\fits_ushort.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\get_d.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\get_d_2exp.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\get_dfl_prec.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\get_prc.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\get_si.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\get_str.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\get_ui.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\init.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\init2.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\inp_str.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\int_p.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\iset.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\iset_d.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\iset_si.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\iset_str.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\iset_ui.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\mul.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\mul_2exp.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\mul_ui.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\neg.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\out_str.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\pow_ui.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\random2.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\reldiff.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\set.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\set_d.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\set_dfl_prec.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\set_prc.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\set_prc_raw.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\set_q.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\set_si.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\set_str.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\set_ui.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\set_z.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\size.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\sqrt.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\sqrt_ui.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\sub.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\sub_ui.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\swap.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\trunc.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\ui_div.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\ui_sub.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\urandomb.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpq\abs.c/Od /I "..\..\\" /I "..\Win32\\" /D "WIN32" /D "_DEBUG" /D "_WIN32" /D "HAVE_CONFIG_H" /D "__GMP_LIBGMP_DLL" /D "__GMP_WITHIN_GMP" /D "_WINDLL" /D "_MBCS" /Gm /EHsc /RTC1 /MDd /Fo"Win32\Debug\mpq\\" /Fd"Win32\Debug\mpq\\" /W3 /nologo /c /Wp64 /Zi /errorReport:promptc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpq\aors.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpq\canonicalize.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpq\clear.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpq\cmp.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpq\cmp_si.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpq\cmp_ui.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpq\div.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpq\equal.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpq\get_d.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpq\get_den.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpq\get_num.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpq\get_str.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpq\init.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpq\inp_str.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpq\inv.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpq\md_2exp.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpq\mul.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpq\neg.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpq\out_str.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpq\set.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpq\set_d.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpq\set_den.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpq\set_f.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpq\set_num.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpq\set_si.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpq\set_str.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpq\set_ui.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpq\set_z.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpq\swap.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\abs.c/Od /I "..\..\\" /I "..\Win32\\" /D "WIN32" /D "_DEBUG" /D "_WIN32" /D "HAVE_CONFIG_H" /D "__GMP_LIBGMP_DLL" /D "__GMP_WITHIN_GMP" /D "_WINDLL" /D "_MBCS" /Gm /EHsc /RTC1 /MDd /Fo"Win32\Debug/mpz/" /Fd"Win32\Debug/mpz/vc80.pdb" /W3 /nologo /c /Wp64 /Zi /errorReport:promptc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\add.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\add_ui.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\and.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\aorsmul.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\aorsmul_i.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\array_init.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\bin_ui.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\bin_uiui.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\cdiv_q.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\cdiv_q_ui.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\cdiv_qr.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\cdiv_qr_ui.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\cdiv_r.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\cdiv_r_ui.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\cdiv_ui.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\cfdiv_q_2exp.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\cfdiv_r_2exp.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\clear.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\clrbit.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\cmp.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\cmp_d.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\cmp_si.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\cmp_ui.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\cmpabs.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\cmpabs_d.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\cmpabs_ui.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\com.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\combit.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\cong.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\cong_2exp.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\cong_ui.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\dive_ui.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\divegcd.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\divexact.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\divis.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\divis_2exp.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\divis_ui.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\dump.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\export.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\fac_ui.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\fdiv_q.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\fdiv_q_ui.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\fdiv_qr.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\fdiv_qr_ui.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\fdiv_r.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\fdiv_r_ui.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\fdiv_ui.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\fib2_ui.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\fib_ui.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\fits_sint.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\fits_slong.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\fits_sshort.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\fits_uint.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\fits_ulong.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\fits_ushort.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\gcd.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\gcd_ui.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\gcdext.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\get_d.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\get_d_2exp.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\get_si.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\get_str.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\get_ui.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\getlimbn.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\hamdist.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\import.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\init.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\init2.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\inp_raw.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\inp_str.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\invert.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\ior.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\iset.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\iset_d.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\iset_si.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\iset_str.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\iset_ui.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\jacobi.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\kronsz.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\kronuz.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\kronzs.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\kronzu.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\lcm.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\lcm_ui.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\lucnum2_ui.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\lucnum_ui.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\millerrabin.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\mod.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\mul.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\mul_2exp.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\mul_si.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\mul_ui.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\n_pow_ui.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\neg.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\nextprime.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\out_raw.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\out_str.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\perfpow.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\perfsqr.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\popcount.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\pow_ui.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\powm.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\powm_ui.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\pprime_p.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\random.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\random2.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\realloc.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\realloc2.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\remove.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\root.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\rootrem.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\rrandomb.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\scan0.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\scan1.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\set.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\set_d.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\set_f.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\set_q.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\set_si.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\set_str.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\set_ui.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\setbit.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\size.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\sizeinbase.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\sqrt.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\sqrtrem.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\sub.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\sub_ui.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\swap.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\tdiv_q.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\tdiv_q_2exp.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\tdiv_q_ui.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\tdiv_qr.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\tdiv_qr_ui.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\tdiv_r.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\tdiv_r_2exp.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\tdiv_r_ui.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\tdiv_ui.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\tstbit.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\ui_pow_ui.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\ui_sub.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\urandomb.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\urandomm.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\xor.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\printf\asprintf.c/Od /I "..\..\\" /I "..\Win32\\" /D "WIN32" /D "_DEBUG" /D "_WIN32" /D "HAVE_CONFIG_H" /D "__GMP_LIBGMP_DLL" /D "__GMP_WITHIN_GMP" /D "_WINDLL" /D "_MBCS" /Gm /EHsc /RTC1 /MDd /Fo"Win32\Debug\printf\\" /Fd"Win32\Debug\printf\\" /W3 /nologo /c /Wp64 /Zi /errorReport:promptc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\printf\asprntffuns.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\printf\doprnt.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\printf\doprntf.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\printf\doprnti.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\printf\fprintf.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\printf\obprintf.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\printf\obprntffuns.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\printf\obvprintf.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\printf\printf.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\printf\printffuns.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\printf\repl-vsnprintf.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\printf\snprintf.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\printf\snprntffuns.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\printf\sprintf.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\printf\sprintffuns.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\printf\vasprintf.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\printf\vfprintf.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\printf\vprintf.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\printf\vsnprintf.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\printf\vsprintf.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\cxx\isfuns.cc/Od /I "..\..\\" /I "..\Win32\\" /D "__GMP_WITHIN_GMPXX" /D "WIN32" /D "_DEBUG" /D "_WIN32" /D "HAVE_CONFIG_H" /D "__GMP_LIBGMP_DLL" /D "__GMP_WITHIN_GMP" /D "_WINDLL" /D "_MBCS" /Gm /EHsc /RTC1 /MDd /Fo"Win32\Debug\\" /Fd"Win32\Debug\\" /W3 /nologo /c /Wp64 /Zi /errorReport:promptc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\cxx\ismpf.ccc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\cxx\ismpq.ccc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\cxx\ismpz.ccc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\cxx\ismpznw.cc/Od /I "..\..\\" /I "..\Win32\\" /D "WIN32" /D "_DEBUG" /D "_WIN32" /D "HAVE_CONFIG_H" /D "__GMP_LIBGMP_DLL" /D "__GMP_WITHIN_GMP" /D "_WINDLL" /D "_MBCS" /Gm /EHsc /RTC1 /MDd /Fo"Win32\Debug\\" /Fd"Win32\Debug\\" /W3 /nologo /c /Wp64 /Zi /errorReport:promptc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\cxx\osdoprnti.ccc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\cxx\osfuns.ccc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\cxx\osmpf.ccc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\cxx\osmpq.ccc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\cxx\osmpz.ccC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\lib_gmp.vcproj/Od /I "..\..\\" /I "..\Win32\\" /D "WIN32" /D "_DEBUG" /D "_LIB" /D "_WIN32" /D "HAVE_CONFIG_H" /D "_MBCS" /Gm /EHsc /RTC1 /MTd /Fo"Win32\Debug\\" /Fd"Win32\Debug\\" /W3 /nologo /c /Wp64 /Zi /TP /errorReport:prompt /D_M_X86/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\/Od /I "..\..\\" /I "..\Win32\\" /D "WIN32" /D "_DEBUG" /D "_LIB" /D "_WIN32" /D "HAVE_CONFIG_H" /D "_MBCS" /Gm /EHsc /RTC1 /MTd /Fo"Win32\Debug\\" /Fd"Win32\Debug\\" /W3 /nologo /c /Wp64 /Zi /TC /errorReport:prompt/Od /I "..\..\\" /I "..\Win32\\" /D "WIN32" /D "_DEBUG" /D "_LIB" /D "_WIN32" /D "HAVE_CONFIG_H" /D "_MBCS" /Gm /EHsc /RTC1 /MTd /Fo"Win32\Debug\mpf\\" /Fd"Win32\Debug\mpf\\" /W3 /nologo /c /Wp64 /Zi /TC /errorReport:prompt/Od /I "..\..\\" /I "..\Win32\\" /D "WIN32" /D "_DEBUG" /D "_LIB" /D "_WIN32" /D "HAVE_CONFIG_H" /D "_MBCS" /Gm /EHsc /RTC1 /MTd /Fo"Win32\Debug\mpq\\" /Fd"Win32\Debug\mpq\\" /W3 /nologo /c /Wp64 /Zi /TC /errorReport:prompt/Od /I "..\..\\" /I "..\Win32\\" /D "WIN32" /D "_DEBUG" /D "_LIB" /D "_WIN32" /D "HAVE_CONFIG_H" /D "_MBCS" /Gm /EHsc /RTC1 /MTd /Fo"Win32\Debug\mpz\\" /Fd"Win32\Debug\mpz\\" /W3 /nologo /c /Wp64 /Zi /TC /errorReport:prompt/Od /I "..\..\\" /I "..\Win32\\" /D "WIN32" /D "_DEBUG" /D "_LIB" /D "_WIN32" /D "HAVE_CONFIG_H" /D "_MBCS" /Gm /EHsc /RTC1 /MTd /Fo"Win32\Debug\printf\\" /Fd"Win32\Debug\printf\\" /W3 /nologo /c /Wp64 /Zi /TC /errorReport:prompt/Od /I "..\..\\" /I "..\Win32\\" /D "WIN32" /D "_DEBUG" /D "_LIB" /D "_WIN32" /D "HAVE_CONFIG_H" /D "_MBCS" /Gm /EHsc /RTC1 /MTd /Fo"Win32\Debug\scanf\\" /Fd"Win32\Debug\scanf\\" /W3 /nologo /c /Wp64 /Zi /TC /errorReport:promptC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmpxx\lib_gmpxx.vcproj/Od /I "..\..\\" /I "..\Win32\\" /D "WIN32" /D "_DEBUG" /D "_LIB" /D "_WIN32" /D "HAVE_CONFIG_H" /D "_MBCS" /Gm /EHsc /RTC1 /MTd /Fo"Win32\Debug\\" /Fd"Win32\Debug\gmpxx.pdb" /W3 /nologo /c /Wp64 /ZI /TP /errorReport:prompt /D_M_X86/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmpxx\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmpxx\/Od /I "..\\" /I "..\..\\" /I "..\..\mpn\generic" /I "..\Win32\\" /D "_WIN32" /D "WIN32" /D "_DEBUG" /D "_LIB" /D "HAVE_CONFIG_H" /D "_MBCS" /Gm /EHsc /RTC1 /MTd /Fo"Win32\Debug\\" /Fd"Win32\Debug\\" /W3 /nologo /c /Wp64 /Zi /TP /errorReport:prompt/Od /I "..\..\\" /I "..\Win32\\" /D "WIN32" /D "_DEBUG" /D "_LIB" /D "_WIN32" /D "HAVE_CONFIG_H" /D "_MBCS" /Gm /EHsc /RTC1 /MTd /Fo"Win32\Debug\\" /Fd"Win32\Debug\\" /W3 /nologo /c /Wp64 /ZI /TP /errorReport:promptC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_mpfr\lib_mpfr.vcproj/Od /I "..\..\\" /I "..\Win32\\" /D "_DEBUG" /D "_WIN32" /D "HAVE_CONFIG_H" /D "_MBCS" /Gm /EHsc /RTC1 /MTd /Fo"Win32\Debug\\" /Fd"Win32\Debug\\" /W3 /nologo /c /Wp64 /Zi /TP /errorReport:prompt /D_M_X86/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_mpfr\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_mpfr\c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\abort_prec_max.c/Od /I "..\..\\" /I "..\Win32\\" /D "_DEBUG" /D "_WIN32" /D "HAVE_CONFIG_H" /D "_MBCS" /Gm /EHsc /RTC1 /MTd /Fo"Win32\Debug\\" /Fd"Win32\Debug\\" /W3 /nologo /c /Wp64 /Zi /TC /errorReport:promptc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\acos.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\acosh.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\add.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\add1.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\add1sp.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\add_ui.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\agm.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\asin.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\asinh.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\atan.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\atan2.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\atanh.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\cache.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\cbrt.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\check.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\clear.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\clears.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\cmp.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\cmp2.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\cmp_abs.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\cmp_d.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\cmp_ld.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\cmp_si.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\cmp_ui.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\comparisons.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\const_catalan.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\const_euler.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\const_log2.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\const_pi.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\constant.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\copysign.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\cos.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\cosh.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\cot.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\coth.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\csc.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\csch.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\dim.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\div.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\div_2exp.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\div_2si.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\div_2ui.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\div_ui.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\dump.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\eint.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\eq.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\erf.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\erfc.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\exceptions.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\exp.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\exp10.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\exp2.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\exp3.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\exp_2.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\expm1.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\extract.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\factorial.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\fits_intmax.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\fits_sint.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\fits_slong.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\fits_sshort.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\fits_uint.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\fits_uintmax.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\fits_ulong.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\fits_ushort.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\fma.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\frac.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\free_cache.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\gamma.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\get_d.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\get_exp.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\get_f.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\get_ld.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\get_si.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\get_sj.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\get_str.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\get_ui.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\get_uj.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\get_z.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\get_z_exp.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\gmp_op.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\hypot.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\init.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\init2.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\inits.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\inits2.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\inp_str.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\int_ceil_log2.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\isinf.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\isinteger.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\isnan.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\isnum.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\isqrt.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\iszero.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\lngamma.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\log.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\log10.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\log1p.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\log2.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\logging.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\minmax.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\mp_clz_tab.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\mpfr-gmp.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\mpn_exp.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\mul.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\mul_2exp.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\mul_2si.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\mul_2ui.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\mul_ui.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\mulders.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\neg.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\next.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\out_str.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\pow.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\pow_si.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\pow_ui.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\pow_z.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\powerof2.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\print_raw.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\print_rnd_mode.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\random.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\random2.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\reldiff.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\rint.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\root.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\round_near_x.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\round_p.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\round_prec.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\sec.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\sech.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\set.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\set_d.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\set_dfl_prec.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\set_exp.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\set_f.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\set_inf.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\set_ld.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\set_nan.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\set_prc_raw.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\set_prec.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\set_q.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\set_rnd.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\set_si.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\set_si_2exp.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\set_sj.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\set_str.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\set_str_raw.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\set_ui.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\set_ui_2exp.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\set_uj.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\set_z.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\setmax.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\setmin.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\sgn.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\si_op.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\sin.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\sin_cos.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\sinh.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\sqr.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\sqrt.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\sqrt_ui.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\stack_interface.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\strtofr.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\sub.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\sub1.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\sub1sp.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\sub_ui.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\subnormal.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\sum.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\swap.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\tan.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\tanh.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\uceil_exp2.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\uceil_log2.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\ufloor_log2.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\ui_div.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\ui_pow.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\ui_pow_ui.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\ui_sub.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\urandomb.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\version.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\volatile.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\zeta.cC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\dll_mpfr.vcproj/Od /I "..\..\\" /I "..\Win32\\" /D "WIN32" /D "_DEBUG" /D "_WIN32" /D "HAVE_CONFIG_H" /D "__GMP_LIBGMP_DLL" /D "__MPFR_LIBGMP_DLL" /D "__MPFR_WITHIN_MPFR" /D "_WINDLL" /D "_MBCS" /Gm /EHsc /RTC1 /MDd /Fo"Win32\Debug\\" /Fd"Win32\Debug\\" /W3 /nologo /c /Wp64 /Zi /TP /errorReport:prompt /D_M_X86/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\/Od /I "..\..\\" /I "..\Win32\\" /D "WIN32" /D "_DEBUG" /D "_WIN32" /D "HAVE_CONFIG_H" /D "__GMP_LIBGMP_DLL" /D "__MPFR_LIBGMP_DLL" /D "__MPFR_WITHIN_MPFR" /D "_WINDLL" /D "_MBCS" /Gm /EHsc /RTC1 /MDd /Fo"Win32\Debug\\" /Fd"Win32\Debug\\" /W3 /nologo /c /Wp64 /Zi /TC /errorReport:promptC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp_gc\lib_gmp_gc.vcproj/Od /I "..\..\\" /I "..\Win32\\" /D "_DEBUG" /D "_LIB" /D "_WIN32" /D "WIN32" /D "HAVE_CONFIG_H" /D "_MBCS" /Gm /EHsc /RTC1 /MTd /Fo"Win32\Debug\\" /Fd"Win32\Debug\\" /W3 /nologo /c /Wp64 /Zi /errorReport:prompt /D_M_X86/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp_gc\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp_gc\/Od /I "..\..\\" /I "..\Win32\\" /D "_DEBUG" /D "_LIB" /D "_WIN32" /D "WIN32" /D "HAVE_CONFIG_H" /D "_MBCS" /Gm /EHsc /RTC1 /MTd /Fo"Win32\Debug\mpn\\" /Fd"Win32\Debug\mpn\\" /W3 /nologo /c /Wp64 /Zi /errorReport:promptC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\gen-bases\gen-bases.vcproj/O2 /GL /I "..\..\\" /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_UNICODE" /D "UNICODE" /FD /EHsc /MD /Fo"Win32\Release\\" /Fd"Win32\Release\vc80.pdb" /W3 /nologo /c /Wp64 /TP /errorReport:prompt /D_M_X86/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\gen-bases\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\gen-bases\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\gen-fac_ui\gen-fac_ui.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\gen-fac_ui\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\gen-fac_ui\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\gen-fib\gen-fib.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\gen-fib\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\gen-fib\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\gen-psqr\gen-psqr.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\gen-psqr\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\gen-psqr\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\assign\assign.vcproj/Od /I "C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\" /I "C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\" /I "C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests" /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "WANT_ASSERT" /D "_UNICODE" /D "UNICODE" /Gm /EHsc /RTC1 /MTd /Fo"Win32\Debug\\" /Fd"Win32\Debug\vc80.pdb" /W3 /nologo /c /Wp64 /ZI /errorReport:prompt /D_M_X86/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\assign\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\assign\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\binary\binary.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\binary\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\binary\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\cast\cast.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\cast\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\cast\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\tdiv_ui\tdiv_ui.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\tdiv_ui\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\tdiv_ui\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\tdiv\tdiv.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\tdiv\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\tdiv\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\constr\constr.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\constr\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\constr\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\headers\headers.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\headers\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\headers\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\locale\locale.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\locale\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\locale\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\istream\istream.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\istream\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\istream\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\misc\misc.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\misc\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\misc\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\ops\ops.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\ops\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\ops\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\ostream\ostream.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\ostream\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\ostream\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\prec\prec.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\prec\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\prec\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\rand\rand.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\rand\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\rand\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\ternary\ternary.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\ternary\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\ternary\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\unary\unary.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\unary\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\unary\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\aorsmul\aorsmul.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\aorsmul\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\aorsmul\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\bit\bit.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\bit\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\bit\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\dive\dive.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\dive\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\dive\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\dive_ui\dive_ui.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\dive_ui\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\dive_ui\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\convert\convert.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\convert\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\convert\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\io\io.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\io\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\io\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\logic\logic.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\logic\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\logic\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\reuse\reuse.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\reuse\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\reuse\c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\tests\mpz\reuse.c/Od /I "C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\" /I "C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\" /I "C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests" /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "WANT_ASSERT" /D "_UNICODE" /D "UNICODE" /Gm /EHsc /RTC1 /MTd /Za /Fo"Win32\Debug\\" /Fd"Win32\Debug\vc80.pdb" /W3 /nologo /c /Wp64 /ZI /errorReport:promptC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\cdiv_ui\cdiv_ui.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\cdiv_ui\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\cdiv_ui\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\addsub\addsub.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\addsub\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\addsub\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\cmp\cmp.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\cmp\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\cmp\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\cmp_d\cmp_d.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\cmp_d\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\cmp_d\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\bin\bin.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\bin\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\bin\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\cmp_si\cmp_si.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\cmp_si\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\cmp_si\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\cong\cong.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\cong\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\cong\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\cong_2exp\cong_2exp.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\cong_2exp\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\cong_2exp\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\div_2exp\div_2exp.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\div_2exp\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\div_2exp\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\divis\divis.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\divis\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\divis\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\divis_2exp\divis_2exp.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\divis_2exp\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\divis_2exp\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\export\export.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\export\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\export\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\fac_ui\fac_ui.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\fac_ui\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\fac_ui\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\fdiv\fdiv.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\fdiv\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\fdiv\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\fdiv_ui\fdiv_ui.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\fdiv_ui\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\fdiv_ui\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\fib_ui\fib_ui.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\fib_ui\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\fib_ui\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\fits\fits.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\fits\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\fits\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\gcd\gcd.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\gcd\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\gcd\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\gcd_ui\gcd_ui.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\gcd_ui\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\gcd_ui\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\get_d\get_d.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\get_d\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\get_d\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\get_d_2exp\get_d_2exp.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\get_d_2exp\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\get_d_2exp\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\get_si\get_si.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\get_si\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\get_si\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\inp_str\inp_str.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\inp_str\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\inp_str\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\io_raw\io_raw.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\io_raw\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\io_raw\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\jac\jac.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\jac\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\jac\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\lcm\lcm.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\lcm\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\lcm\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\lucnum_ui\lucnum_ui.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\lucnum_ui\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\lucnum_ui\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\mul\mul.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\mul\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\mul\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\mul_i\mul_i.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\mul_i\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\mul_i\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\oddeven\oddeven.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\oddeven\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\oddeven\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\perfsqr\perfsqr.vcproj/Od /I "C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\" /I "C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\" /I "C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests" /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "WANT_ASSERT" /D "_UNICODE" /D "UNICODE" /Gm /EHsc /RTC1 /MTd /Fo"Win32\Debug\\" /Fd"Win32\Debug\vc80.pdb" /W3 /nologo /c /Wp64 /ZI /errorReport:prompt /D_M_X86/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\perfsqr\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\perfsqr\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\popcount\popcount.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\popcount\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\popcount\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\pow\pow.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\pow\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\pow\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\powm\powm.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\powm\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\powm\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\powm_ui\powm_ui.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\powm_ui\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\powm_ui\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\pprime_p\pprime_p.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\pprime_p\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\pprime_p\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\root\root.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\root\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\root\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\scan\scan.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\scan\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\scan\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\set_d\set_d.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\set_d\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\set_d\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\set_f\set_f.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\set_f\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\set_f\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\set_si\set_si.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\set_si\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\set_si\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\set_str\set_str.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\set_str\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\set_str\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\sizeinbase\sizeinbase.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\sizeinbase\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\sizeinbase\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\sqrtrem\sqrtrem.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\sqrtrem\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\sqrtrem\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\hamdist\hamdist.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\hamdist\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\hamdist\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\import\import.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\import\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\import\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\misc\printf\printf.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\misc\printf\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\misc\printf\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\misc\scanf\scanf.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\misc\scanf\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\misc\scanf\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\bswap\bswap.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\bswap\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\bswap\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\constants\constants.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\constants\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\constants\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\count_zeros\count_zeros.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\count_zeros\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\count_zeros\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\gmpmax\gmpmax.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\gmpmax\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\gmpmax\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\hightomask\hightomask.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\hightomask\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\hightomask\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\modlinv\modlinv.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\modlinv\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\modlinv\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\parity\parity.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\parity\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\parity\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\popc\popc.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\popc\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\popc\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\subc\subc.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\subc\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\subc\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\rand\iset\iset.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\rand\iset\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\rand\iset\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\rand\lc2exp\lc2exp.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\rand\lc2exp\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\rand\lc2exp\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\rand\mt\mt.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\rand\mt\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\rand\mt\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\rand\urbui\urbui.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\rand\urbui\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\rand\urbui\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\rand\urmui\urmui.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\rand\urmui\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\rand\urmui\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\rand\urndmm\urndmm.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\rand\urndmm\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\rand\urndmm\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpf\add\add.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpf\add\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpf\add\c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\tests\memory.c/Od /I "C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\\" /I "C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\Win32\\" /I "C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\..\tests" /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "WANT_ASSERT" /D "_UNICODE" /D "UNICODE" /Gm /EHsc /RTC1 /MTd /Fo"Win32\Debug\\" /Fd"Win32\Debug\vc80.pdb" /W3 /nologo /c /Wp64 /ZI /errorReport:promptC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpf\conv\conv.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpf\conv\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpf\conv\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpf\div\div.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpf\div\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpf\div\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpf\dm2exp\dm2exp.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpf\dm2exp\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpf\dm2exp\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpf\get_ui\get_ui.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpf\get_ui\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpf\get_ui\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpf\gsprec\gsprec.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpf\gsprec\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpf\gsprec\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpf\int_p\int_p.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpf\int_p\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpf\int_p\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpf\mul_ui\mul_ui.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpf\mul_ui\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpf\mul_ui\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpf\muldiv\muldiv.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpf\muldiv\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpf\muldiv\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpf\set\set.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpf\set\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpf\set\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpf\set_q\set_q.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpf\set_q\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpf\set_q\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpf\set_ui\set_ui.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpf\set_ui\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpf\set_ui\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpf\sqrt\sqrt.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpf\sqrt\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpf\sqrt\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpf\sqrt_ui\sqrt_ui.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpf\sqrt_ui\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpf\sqrt_ui\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpf\sub\sub.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpf\sub\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpf\sub\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpf\trunc\trunc.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpf\trunc\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpf\trunc\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpf\ui_div\ui_div.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpf\ui_div\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpf\ui_div\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpn\aors_1\aors_1.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpn\aors_1\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpn\aors_1\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpn\asmtype\asmtype.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpn\asmtype\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpn\asmtype\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpn\divrem_1\divrem_1.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpn\divrem_1\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpn\divrem_1\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpn\fat\fat.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpn\fat\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpn\fat\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpn\instrument\instrument.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpn\instrument\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpn\instrument\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpn\iord_u\iord_u.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpn\iord_u\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpn\iord_u\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpn\mp_bases\mp_bases.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpn\mp_bases\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpn\mp_bases\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpq\aors\aors.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpq\aors\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpq\aors\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpq\cmp_ui\cmp_ui.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpq\cmp_ui\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpq\cmp_ui\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpq\equal\equal.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpq\equal\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpq\equal\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpq\get_str\get_str.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpq\get_str\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpq\get_str\C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpq\md_2exp\md_2exp.vcproj/ACWD "c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpq\md_2exp\" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\VC\PlatformSDK\include" -I "C:\Archivos de programa\Microsoft Visual Studio 8\SDK\v2.0\include" -AI "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727"C:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\;c:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpq\md_2exp\mp_limb_tmp_ptr r1pmp_ptr r2pmp_srcptr s1pmp_srcptr s2pmp_size_t n (mp_ptr, mp_ptr, mp_srcptr, mp_srcptr, mp_size_t)(L1_CACHE_SIZE / BYTES_PER_MP_LIMB / 6)8192mp_ptr qpmp_size_t qxnmp_srcptr upmp_size_t unmp_limb_t d (mp_ptr, mp_size_t, mp_srcptr, mp_size_t, mp_limb_t)0mp_ptr npmp_size_t nnmp_srcptr dp (mp_ptr, mp_size_t, mp_ptr, mp_size_t, mp_srcptr)c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\gmp.hc:\archivos de programa\microsoft visual studio 8\vc\include\iosfwdc:\archivos de programa\microsoft visual studio 8\vc\include\cstdioc:\archivos de programa\microsoft visual studio 8\vc\include\yvals.hc:\archivos de programa\microsoft visual studio 8\vc\include\crtdefs.hc:\archivos de programa\microsoft visual studio 8\vc\include\sal.hexpr__inner_fallthrough__inner_data_entrypoint()category__inner_control_entrypoint()__inner_blocksOn()resource__inner_callback__inner_override__inner_typefix()ctype__inner_checkReturn__pre __null__readableTo(sentinel(0))__inner_success()__deref_opt_inout_bcount_opt()size__deref_opt_inout_ecount_opt()__deref_opt_inout_opt__deref_opt_inout_bcount_opt() __pre __deref __nullterminated __post __deref __nullterminated__deref_opt_inout_ecount_opt() __pre __deref __nullterminated __post __deref __nullterminated__deref_opt_inout_opt __pre __deref __nullterminated __post __deref __nullterminated__deref_inout_bcount_full_opt() __exceptthat __maybenull__deref_inout_ecount_full_opt() __exceptthat __maybenull__deref_inout_bcount_part_opt(,) __exceptthat __maybenulllength__deref_inout_ecount_part_opt(,) __exceptthat __maybenull__deref_inout_bcount_opt() __exceptthat __maybenull__deref_inout_ecount_opt() __exceptthat __maybenull__deref_inout_opt __exceptthat __maybenull__deref_opt_out_bcount_opt()__deref_opt_out_ecount_opt()__deref_opt_out_opt__deref_opt_out_bcount_opt() __post __deref __nullterminated__deref_opt_out_ecount_opt() __post __deref __nullterminated__post __deref __valid __refparam __exceptthat __maybenull __pre __deref __exceptthat __maybenull __post __deref __exceptthat __maybenull __post __deref __nullterminated__deref_out_bcount_full_opt() __exceptthat __maybenull__deref_out_ecount_full_opt() __exceptthat __maybenull__deref_out_bcount_part_opt(,) __exceptthat __maybenull__deref_out_ecount_part_opt(,) __exceptthat __maybenull__deref_out_bcount_opt() __exceptthat __maybenull__deref_out_ecount_opt() __exceptthat __maybenull__deref_out_opt __exceptthat __maybenull__deref_bcount_opt() __exceptthat __maybenull__deref_ecount_opt() __exceptthat __maybenull__deref_opt_inout_bcount()__deref_opt_inout_ecount()__deref_opt_inout__deref_opt_inout_bcount() __pre __deref __nullterminated __post __deref __nullterminated__deref_opt_inout_ecount() __pre __deref __nullterminated __post __deref __nullterminated__deref_opt_inout __pre __deref __nullterminated __post __deref __nullterminated__deref_inout_bcount_full() __exceptthat __maybenull__deref_inout_ecount_full() __exceptthat __maybenull__deref_inout_bcount_part(,) __exceptthat __maybenull__deref_inout_ecount_part(,) __exceptthat __maybenull__deref_inout_bcount() __exceptthat __maybenull__deref_inout_ecount() __exceptthat __maybenull__deref_inout __exceptthat __maybenull__deref_out_bcount_full() __exceptthat __maybenull__deref_out_ecount_full() __exceptthat __maybenull__deref_out_bcount_part(,) __exceptthat __maybenull__deref_out_ecount_part(,) __exceptthat __maybenull__deref_out_bcount() __exceptthat __maybenull__deref_out_ecount() __exceptthat __maybenull__deref_opt_out __post __deref __nullterminated__deref_out __exceptthat __maybenull__deref_bcount() __exceptthat __maybenull__deref_ecount() __exceptthat __maybenull__deref_inout_bcount_opt()__deref_inout_ecount_opt()__deref_inout_opt__deref_inout_bcount_opt() __pre __deref __nullterminated __post __deref __nullterminated__deref_inout_ecount_opt() __pre __deref __nullterminated __post __deref __nullterminated__deref_inout_opt __pre __deref __nullterminated __post __deref __nullterminated__deref_inout_bcount_full() __pre __deref __exceptthat __maybenull __post __deref __exceptthat __maybenull__deref_inout_ecount_full() __pre __deref __exceptthat __maybenull __post __deref __exceptthat __maybenull__deref_inout_bcount_part(,) __pre __deref __exceptthat __maybenull __post __deref __exceptthat __maybenull__deref_inout_ecount_part(,) __pre __deref __exceptthat __maybenull __post __deref __exceptthat __maybenull__deref_inout_bcount() __pre __deref __exceptthat __maybenull __post __deref __exceptthat __maybenull__deref_inout_ecount() __pre __deref __exceptthat __maybenull __post __deref __exceptthat __maybenull__deref_inout __pre __deref __exceptthat __maybenull __post __deref __exceptthat __maybenull__deref_out_bcount_opt()__deref_out_ecount_opt()__deref_out_opt__deref_out_bcount_opt() __post __deref __nullterminated__deref_out_ecount_opt() __post __deref __nullterminated__post __deref __valid __refparam __execeptthat __maybenull __post __deref __nullterminated__deref_out_bcount_full() __post __deref __exceptthat __maybenull__deref_out_ecount_full() __post __deref __exceptthat __maybenull__deref_out_bcount_part(,) __post __deref __exceptthat __maybenull__deref_out_ecount_part(,) __post __deref __exceptthat __maybenull__deref_out_bcount() __post __deref __exceptthat __maybenull__deref_out_ecount() __post __deref __exceptthat __maybenull__deref_out __post __deref __exceptthat __maybenull__deref_bcount() __post __deref __exceptthat __maybenull__deref_ecount() __post __deref __exceptthat __maybenull__deref_inout_ecount()__deref_inout__deref_inout_ecount() __pre __deref __nullterminated __post __deref __nullterminated__deref_inout_bcount_part(,)__deref_inout_ecount_part(,)__deref_inout_bcount() __pre __deref __byte_readableTo() __post __deref __byte_readableTo()__deref_inout_ecount() __pre __deref __elem_readableTo() __post __deref __elem_readableTo()__deref_inout __pre __deref __byte_writableTo() __post __deref __byte_writableTo()__deref_inout __pre __deref __elem_writableTo() __post __deref __elem_writableTo()__deref_inout __pre __deref __nullterminated __post __deref __nullterminated__notnull __elem_readableTo(1) __pre __deref __valid __post __deref __valid __refparam__deref_out_ecount()__deref_out__deref_out_ecount() __post __deref __nullterminated__post __deref __valid __refparam __post __deref __nullterminated__deref_out_bcount_part(,)__deref_out_ecount_part(,)__deref_out_bcount() __post __deref __byte_readableTo()__deref_out_ecount() __post __deref __elem_readableTo()__deref_bcount() __post __deref __valid __refparam__deref_ecount() __post __deref __valid __refparam__deref_ecount(1) __post __deref __valid __refparam__ecount(1) __post __elem_readableTo(1) __post __deref __notnull __post __deref __byte_writableTo()__ecount(1) __post __elem_readableTo(1) __post __deref __notnull __post __deref __elem_writableTo()__inout_bcount_opt()__inout_ecount_opt()__inout_opt__inout_ecount_opt() __pre __nullterminated __post __nullterminated__inout_opt __pre __nullterminated __post __nullterminated__inout_bcount_full() __exceptthat __maybenull__inout_ecount_full() __exceptthat __maybenull__inout_bcount_part(,) __exceptthat __maybenull__inout_ecount_part(,) __exceptthat __maybenull__inout_bcount() __exceptthat __maybenull__inout_ecount() __exceptthat __maybenull__inout __exceptthat __maybenull__out_bcount_opt() __post __nullterminated__out_ecount_opt() __post __nullterminated__out_bcount_full_opt() __post __nullterminated__out_ecount_full_opt() __post __nullterminated__out_bcount_part_opt(,) __post __nullterminated__out_ecount_part_opt(,) __post __nullterminated__out_bcount_full() __exceptthat __maybenull__out_ecount_full() __exceptthat __maybenull__out_bcount_part(,) __exceptthat __maybenull__out_ecount_part(,) __exceptthat __maybenull__out_bcount() __exceptthat __maybenull__out_ecount() __exceptthat __maybenull__out __exceptthat __maybenull__in_bcount_opt()__in_ecount_opt()__in_opt__in_bcount_opt() __pre __nullterminated__in_ecount_opt() __pre __nullterminated__in_opt __pre __nullterminated__in_bcount() __exceptthat __maybenull__in_ecount() __exceptthat __maybenull__in __exceptthat __maybenull__bcount() __exceptthat __maybenull__ecount() __exceptthat __maybenull__inout_bcount()__inout_ecount()__inout__inout_bcount() __pre __nullterminated __post __nullterminated__inout_ecount() __pre __nullterminated __post __nullterminated__inout __pre __nullterminated __post __nullterminated__inout_bcount_part(,)__inout_ecount_part(,)__out_bcount_part(,) __pre __valid __pre __byte_readableTo()__out_ecount_part(,) __pre __valid __pre __elem_readableTo()__out_bcount() __pre __valid__out_ecount() __pre __valid__pre __valid __post __valid __refparam__bcount() __post __valid __refparam__ecount() __post __valid __refparam__post __valid __refparam __post __exceptthat __maybenull__post __valid __refparam __post__out_bcount_full() __post __nullterminated__out_ecount_full() __post __nullterminated__out_bcount_part(,) __post __nullterminated__out_ecount_part(,) __post __nullterminated__bcount() __post __valid __refparam __post __nullterminated__ecount() __post __valid __refparam __post __nullterminated__post __valid __refparam __post __nullterminated __exceptthat __maybenull__post __valid __refparam __post __nullterminated__out_bcount_part(,)__out_ecount_part(,)__out_bcount() __post __byte_readableTo()__out_ecount() __post __elem_readableTo()__ecount(1) __post __valid __refparam__in_bcount()__in_ecount()__in__in_bcount() __pre __nullterminated__in_ecount() __pre __nullterminated__in __pre __nullterminated__in __pre __byte_readableTo()__in __pre __elem_readableTo()__pre __valid __pre __deref __readonly__notnull __byte_writableTo()__notnull __elem_writableTo()extent__declspec(nothrow)c:\archivos de programa\microsoft visual studio 8\vc\include\vadefs.hchar *__w64 unsigned int(  = (va_list)0 )ap( *( *)(( += _INTSIZEOF()) - _INTSIZEOF()) )t(  = (va_list)_ADDRESSOF() + _INTSIZEOF() )v( (sizeof() + sizeof(int) - 1) & ~(sizeof(int) - 1) )n(__alignof())(sizeof())( &reinterpret_cast() )__w648struct threadlocaleinfostructintunsigned intunsigned long [6]LC_ID [6]wchar_t *int *threadlocaleinfostruct::__unnamed_0042_1 [6]lconv *unsigned short *const unsigned short *const unsigned char *__lc_time_data *struct tagLC_ID *struct tagLC_IDunsigned shortstruct localeinfo_struct *struct localeinfo_structpthreadlocinfopthreadmbcinfostruct threadmbcinfostruct *struct threadlocaleinfostruct *__time64_t__int64__w64 long__w64 intsize_t(void)x_CRT_INSECURE_DEPRECATE()  size_t __cdecl ( *,  ,   ,   );_DeclSpec_FuncName_SecureFuncName_SecureDstType_DstType_Dst_TType1_TArg1_TType2_TArg2_TType3_TArg3_CRT_INSECURE_DEPRECATE()  size_t __cdecl ( *,  ,   );_CRT_INSECURE_DEPRECATE(_s)   __cdecl ( *,   ,   , ...); _CRT_INSECURE_DEPRECATE(_s)   __cdecl ( *,   ,   , va_list _Args);_ReturnType_ReturnPolicy_VFuncName_CRT_INSECURE_DEPRECATE(_s)   __cdecl ( *,   ,   , ...); _CRT_INSECURE_DEPRECATE(_s)   __cdecl ( *,   ,   , va_list _Args);_CRT_INSECURE_DEPRECATE()   __cdecl ( * ,   , ...); _CRT_INSECURE_DEPRECATE()   __cdecl ( * ,   , va_list _Args);_SecureVFuncName_CRT_INSECURE_DEPRECATE()   __cdecl ( ,   ,  * );_HType1_HArg1_HType2_HArg2_CRT_INSECURE_DEPRECATE()   __cdecl ( ,  * ,   );_CRT_INSECURE_DEPRECATE()   __cdecl ( *,   ,   ,   ,  );_TType4_TArg4_CRT_INSECURE_DEPRECATE()   __cdecl ( *,   ,   ,   );_CRT_INSECURE_DEPRECATE()   __cdecl ( *,   ,   );_CRT_INSECURE_DEPRECATE()   __cdecl ( *,   );_CRT_INSECURE_DEPRECATE(_s)   __cdecl ( *);_CRT_INSECURE_DEPRECATE()   __cdecl ( *);_CRT_INSECURE_DEPRECATE(_s)   __cdecl ( * ,   ,   , ...); _CRT_INSECURE_DEPRECATE()   __cdecl ( * ,   ,   , va_list _Args);_CRT_INSECURE_DEPRECATE(_s)   __cdecl ( *);_FunctionCall__DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_3_SIZE_EX(, , _s, , , , , , , ,  ,  )__DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_2_SIZE_EX(, , _s, , , , , , , )__DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_1_ARGLIST_EX(, , , , _s, , _s, , , ,  )__DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_2_0_EX(, , , , _s, , , , ,  ,  )__DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_1_1_EX(, , , , _s, , , , ,  ,  )__DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_4_EX(, , , , _s, , , , ,  ,  ,  ,  ,  , )__DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_3_EX(, , , , _s, , , , ,  ,  ,  ,  )__DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_2_EX(, , , , _s, , , , , ,  ,  )__DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_1_EX(, , , , _s, , , , )__DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_0_EX(, , , , _s, , )__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_3_SIZE_EX(, , _s, , , , , , , ,  ,  )__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_2_SIZE_EX(, , _s, , , , , , , )__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_2_ARGLIST_EX(, , , , , _s, , , , ,  ,  ,  )__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_1_ARGLIST_EX(, , , , _s, , _s, , , ,  )__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_2_0_EX(, , , , _s, , , , ,  ,  )__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_1_1_EX(, , , , _s, , , , ,  ,  )__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_4_EX(, , , , _s, , , , ,  ,  ,  ,  ,  , )__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_3_EX(, , , , _s, , , , ,  ,  ,  ,  )__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_2_EX(, , , , _s, , , , , ,  ,  )__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_1_EX(, , , , _s, , , , )__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_0_EX(, , , , _s, , )extern "C++" { template inline  __CRTDECL (__in const  *, __out_ecount_opt(_DriveSize)  (&_Drive)[_DriveSize], __out_ecount_opt(_DirSize)  (&_Dir)[_DirSize], __out_ecount_opt(_NameSize)  (&_Name)[_NameSize], __out_ecount_opt(_ExtSize)  (&_Ext)[_ExtSize]) { return (, _Drive, _DriveSize, _Dir, _DirSize, _Name, _NameSize, _Ext, _ExtSize); } }_Srcextern "C++" { __pragma(warning(push)); __pragma(warning(disable: 4793)); template inline  __CRTDECL ( (&)[_Size],  ,   , ...) { va_list _ArgList; _crt_va_start(_ArgList,  ); return (, _Size, ,  , _ArgList); } __pragma(warning(pop)); }extern "C++" { __pragma(warning(push)); __pragma(warning(disable: 4793)); template inline  __CRTDECL ( (&)[_Size],  , ...) { va_list _ArgList; _crt_va_start(_ArgList, ); return (, _Size, , _ArgList); } __pragma(warning(pop)); }extern "C++" { template inline  __CRTDECL ( ,  ,  (&)[_Size]) { return (, , , _Size); } }extern "C++" { template inline  __CRTDECL ( ,  (&)[_Size],  ,   ,   ) { return (, , _Size, ,  ,  ); } }extern "C++" { template inline  __CRTDECL ( ,  (&)[_Size],  ,   ) { return (, , _Size, ,  ); } }extern "C++" { template inline  __CRTDECL ( ,  (&)[_Size],  ) { return (, , _Size, ); } }extern "C++" { template inline  __CRTDECL ( (&)[_Size],  ,  ,   ,   ) { return (, _Size, , ,  ,  ); } }extern "C++" { template inline  __CRTDECL ( (&)[_Size],  ,  ,   ) { return (, _Size, , ,  ); } }extern "C++" { template inline  __CRTDECL ( (&)[_Size],  ,  ) { return (, _Size, , ); } }extern "C++" { template inline  __CRTDECL ( (&)[_Size],  ) { return (, _Size, ); } }extern "C++" { template inline  __CRTDECL ( (&)[_Size]) { return (, _Size); } }((size_t)-1)100__cdecl__declspec(restrict)__declspec(noalias)__declspec(align())const_CRT_DEPRECATE_TEXT("The POSIX name for this item is deprecated. Instead, use the ISO C++ conformant name: "  ". See online help for details.")_NewName1_CRT_DEPRECATE_TEXT("This function or variable has been superceded by newer library or operating system functionality. Consider using"  "instead. See online help for details.")_NewItem0xFD_CRT_INSECURE_DEPRECATE()_Replacement_CRT_DEPRECATE_TEXT("This function or variable may be unsafe. Consider using "  " instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details.")__declspec(deprecated())_Text__STDC_SECURE_LIB__200411L_CRTIMP__declspec(dllimport)__CRT_WIDE()_StringL__CRT_STRINGIZE()_Valuec:\archivos de programa\microsoft visual studio 8\vc\include\use_ansi.hvoidvoid (*)(void) (void (*)(void)) ()std::_Init_locks * (std::_Init_locks *)const std::_Mutex & (const std::_Mutex &)std::_Mutex * (std::_Mutex *)std::_Mutex &void *const std::_Lockit & (const std::_Lockit &) (int)std::_Lockit * (std::_Lockit *, int) (std::_Lockit *)std::_Lockit &unsigned __int64bool_THROW1(...)templatembstate_t  = {0}}{ _Locinfo ;_VarName{ _STD _Lockit _Lock();_Kind432_cnt_ptr_base((long)())fp_iobuf36320xffffffffffffffff0x7fffffffffffffffrestrictextern "C" {::::stdext::namespace stdext {::std::namespace std {_CRT_DEPRECATE_TEXT("This is an obsolete part of the Standard C++ Library Implementation. Do not use it.")_CRTIMP2_MRTIMP2_NPURE_MRTIMP2::wmemmove_s((), (), (), ())destdestsizesourcecount::wmemcpy_s((), (), (), ())::memmove_s((), (), (), ())::memcpy_s((), (), (), ()){ __pragma(warning(push)); __pragma(warning(disable: 4127)); if (_SECURE_VALIDATION) { _SCL_SECURE_OUT_OF_RANGE } __pragma(warning(pop)); }{ __pragma(warning(push)); __pragma(warning(disable: 4127)); if (_SECURE_VALIDATION) { _SCL_SECURE_INVALID_ARGUMENT } __pragma(warning(pop)); }{ __pragma(warning(push)); __pragma(warning(disable: 4127)); if (_SECURE_VALIDATION) { _SCL_SECURE_VALIDATE_RANGE() } __pragma(warning(pop)); }cond{ __pragma(warning(push)); __pragma(warning(disable: 4127)); if (_SECURE_VALIDATION) { _SCL_SECURE_VALIDATE() } __pragma(warning(pop)); }true_Secure_validation((), (), (), ())funcdstsrc{ _ASSERTE(("Standard C++ Libraries Out of Range", 0)); _SCL_SECURE_OUT_OF_RANGE_NO_ASSERT; }{ _ASSERTE(("Standard C++ Libraries Invalid Argument", 0)); _SCL_SECURE_INVALID_ARGUMENT_NO_ASSERT; }{ if (!()) { _ASSERTE((, 0)); _SCL_SECURE_OUT_OF_RANGE_NO_ASSERT; } __analysis_assume(); }{ if (!()) { _ASSERTE((, 0)); _SCL_SECURE_INVALID_ARGUMENT_NO_ASSERT; } __analysis_assume(); }{ if (!()) { _ASSERTE((, 0)); _SCL_SECURE_INVALID_PARAMETER(); return (); } }retvalue{ if (!()) { _ASSERTE((, 0)); _SCL_SECURE_OUT_OF_RANGE_NO_ASSERT; } }{ if (!()) { _ASSERTE((, 0)); _SCL_SECURE_INVALID_ARGUMENT_NO_ASSERT; } }_SCL_SECURE_INVALID_PARAMETER("out of range")_SCL_SECURE_INVALID_PARAMETER("invalid argument")::_invalid_parameter(__STR2WSTR(), __FUNCTIONW__, __FILEW__, __LINE__, 0)_CRT_DEPRECATE_TEXT("You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library")_STR2WSTR(__FUNCTION__)_STR2WSTR(__FILE__)__STR2WSTR()str__declspec(thread)405c:\archivos de programa\microsoft visual studio 8\vc\include\stdio.hc:\archivos de programa\microsoft visual studio 8\vc\include\swprintf.inlwchar_t *_Stringconst wchar_t *_Format_locale_t _Plocinfova_list _Ap (wchar_t *, const wchar_t *, localeinfo_struct, char)... (wchar_t *, const wchar_t *, localeinfo_struct, ...) (wchar_t *, const wchar_t *, char) (wchar_t *, const wchar_t *, ...)size_t _Count (wchar_t *, unsigned int, const wchar_t *, localeinfo_struct, char) (wchar_t *, unsigned int, const wchar_t *, localeinfo_struct, ...) (wchar_t *, unsigned int, const wchar_t *, char) (wchar_t *, unsigned int, const wchar_t *, ...)int _ChFILE *_File (int, _iobuf *) (_iobuf *)FILE *int _FileHandleconst char *_Format (int, const char *)const char *_Directoryconst char *_FilePrefix (const char *, const char *)const void *_DstBufsize_t _Size (const void *, unsigned int, unsigned int, _iobuf *)__int64 _Offsetint _Origin (_iobuf *, __int64, int)longlong _Offset (_iobuf *, long, int)void *_DstBufsize_t _DstSizesize_t _ElementSize (void *, unsigned int, unsigned int, unsigned int, _iobuf *) (void *, unsigned int, unsigned int, _iobuf *)wint_twint_t _Ch (unsigned short, _iobuf *)wchar_t _Ch (wchar_t, _iobuf *)wchar_t *_Buffer (wchar_t *)errno_twchar_t (&_Buffer)[_Size] (wchar_t (&)[_Size])wchar_t *_DstBufsize_t _SizeInWords (wchar_t *, unsigned int)const wchar_t *_Filename (const wchar_t *)const wchar_t *_Commandconst wchar_t *_Mode (const wchar_t *, const wchar_t *)const wchar_t *_ErrMsgFILE **_FileFILE *_OldFile (_iobuf **, const wchar_t *, const wchar_t *, _iobuf *) (const wchar_t *, const wchar_t *, _iobuf *) (_iobuf **, const wchar_t *, const wchar_t *) (int, const wchar_t *)_locale_t _Locale (const wchar_t *, localeinfo_struct, ...) (const wchar_t *, ...)const wchar_t *_Srcsize_t _MaxCount (const wchar_t *, unsigned int, const wchar_t *, localeinfo_struct, ...) (const wchar_t *, unsigned int, const wchar_t *, ...) (const wchar_t *, const wchar_t *, localeinfo_struct, ...) (const wchar_t *, const wchar_t *, ...) (_iobuf *, const wchar_t *, localeinfo_struct, ...) (_iobuf *, const wchar_t *, ...)va_list _ArgList (const wchar_t *, localeinfo_struct, char) (const wchar_t *, char)const wchar_t *_Directoryconst wchar_t *_FilePrefixwchar_t *_Destva_list _Args (wchar_t *, unsigned int, unsigned int, const wchar_t *, localeinfo_struct, char) (wchar_t *, unsigned int, unsigned int, const wchar_t *, localeinfo_struct, ...) (_iobuf *, const wchar_t *, localeinfo_struct, char) (_iobuf *, const wchar_t *, char)wchar_t (&_Dest)[_Size] (wchar_t (&)[_Size], unsigned int, const wchar_t *, char)size_t _DstSizeInWords (wchar_t *, unsigned int, unsigned int, const wchar_t *, char) (wchar_t (&)[_Size], unsigned int, const wchar_t *, ...) (wchar_t *, unsigned int, unsigned int, const wchar_t *, ...) (wchar_t (&)[_Size], const wchar_t *, char)wchar_t *_Dst (wchar_t (&)[_Size], const wchar_t *, ...)const wchar_t *_Strwchar_t (&_String)[_Size]wchar_t *_Str (const wchar_t *, _iobuf *)int _SizeInWords (wchar_t *, int, _iobuf *)wchar_t _C (wchar_t)int _ShFlag (const wchar_t *, const wchar_t *, int)char *_DstBuf (char *, unsigned int, unsigned int, const char *, localeinfo_struct, char)const char * (char *, unsigned int, const char *, localeinfo_struct, char) (char *, unsigned int, unsigned int, const char *, localeinfo_struct, ...) (char *, unsigned int, const char *, localeinfo_struct, ...) (const char *, localeinfo_struct, char) (const char *, localeinfo_struct, ...)_locale_t (char *, const char *, localeinfo_struct, char) (char *, const char *, localeinfo_struct, ...) (_iobuf *, const char *, localeinfo_struct, char) (_iobuf *, const char *, localeinfo_struct, ...)int _Value (const char *, char) (const char *, ...)char *_Dst (char *, unsigned int, const char *, char) (_iobuf *, const char *, char) (char *, unsigned int, const char *, ...) (_iobuf *, const char *, ...)char *_Dest (char *, const char *, char) (char *, const char *, ...)char (&_Dest)[_Size] (char (&)[_Size], const char *, char) (char (&)[_Size], unsigned int, const char *, char) (char *, unsigned int, unsigned int, const char *, char)char *_Buffer (char *)char (&_Buf)[_Size] (char (&)[_Size])char *_Bufrsize_t _Size (char *, unsigned int) (_iobuf **)const char *_Src (const char *, unsigned int, const char *, localeinfo_struct, ...) (const char *, unsigned int, const char *, ...) (const char *, const char *, localeinfo_struct, ...) (const char *, const char *, ...) (char (&)[_Size], const char *, ...) (char (&)[_Size], unsigned int, const char *, ...) (char *, unsigned int, unsigned int, const char *, ...)int _Mode (_iobuf *, char *, int, unsigned int)unsigned int _Format (unsigned int)int _Max (_iobuf *, char *)const char *_Filename (const char *)const char *_OldFilenameconst char *_NewFilenameint _Wordconst char *_Strconst char *_Commandconst char *_Modeconst char *_ErrMsgchar (&_Buffer)[_Size]const void *_Strconst fpos_t *_Pos (_iobuf *, const __int64 *) (_iobuf **, const char *, const char *, _iobuf *) (const char *, const char *, _iobuf *) (const char *, _iobuf *) (_iobuf **, const char *, const char *)const char *_DirNameint _MaxCount (char *, int, _iobuf *)fpos_t *_Pos (_iobuf *, __int64 *) (const char *, const char *, int)struct _iobuf_SYS_OPEN_P_tmpdirc_putwc_nolock((),stdout)_c_getwc_nolock(stdin)_putc_nolock((),stdout)_getc_nolock(stdin)_fputc_nolock(, )_stream_fgetc_nolock()(--()->_cnt >= 0 ? 0xff & (*()->_ptr++ = (char)()) : _flsbuf((),()))(--()->_cnt >= 0 ? 0xff & *()->_ptr++ : _filbuf())_fgetwc_nolock()_stm_fputwc_nolock(,)fputwc(,)fgetwc()_CRT_DEPRECATE_TEXT("swprintf has been changed to conform with the ISO C standard, adding an extra character count parameter. To use traditional Microsoft swprintf, set _CRT_NON_CONFORMING_SWPRINTFS.")(wint_t)(0xFFFF)0x10x00800x00400x00200x00100x00080x00040x00000x00020x0001(&__iob_func()[2])(&__iob_func()[1])(&__iob_func()[0])21474836473276720260(sizeof(_P_tmpdir) + 16)(sizeof(_P_tmpdir) + 12)L"\\""\\"(-1)512_NSTREAM_::size_t::fpos_t::FILE::clearerr::fclose::feof::ferror::fflush::fgetc::fgetpos::fgets::fopen::fprintf::fputc::fputs::fread::freopen::fscanf::fseek::fsetpos::ftell::fwrite::getc::getchar::gets::perror::putc::putchar::printf::puts::remove::rename::rewind::scanf::setbuf::setvbuf::sprintf::sscanf::tmpfile::tmpnam::ungetc::vfprintf::vprintf::vsprintfc:\archivos de programa\microsoft visual studio 8\vc\include\cstringc:\archivos de programa\microsoft visual studio 8\vc\include\string.hconst wchar_t *_Str1const wchar_t *_Str2wchar_t _Val (wchar_t *, wchar_t) (wchar_t *, wchar_t, unsigned int) (const wchar_t *, const wchar_t *, unsigned int)const wchar_t *_SubStr (wchar_t *, const wchar_t *)const wchar_t *_Control (const wchar_t *, const wchar_t *, unsigned int, localeinfo_struct) (const wchar_t *, const wchar_t *, localeinfo_struct) (wchar_t *, const wchar_t *, unsigned int, localeinfo_struct) (wchar_t *, const wchar_t *, unsigned int) (wchar_t *, localeinfo_struct) (wchar_t (&)[_Size], localeinfo_struct) (wchar_t *, unsigned int, localeinfo_struct) (wchar_t *, unsigned int, wchar_t) (wchar_t *, unsigned int, wchar_t, unsigned int)const wchar_t *_ErrorMessage (wchar_t (&)[_Size], const wchar_t *) (wchar_t *, unsigned int, const wchar_t *)int _Error (wchar_t (&)[_Size], int)wchar_t *_Bufint _ErrNum (wchar_t *, unsigned int, int)const wchar_t *_Delimwchar_t **_Context (wchar_t *, const wchar_t *, wchar_t **)const wchar_t * (const wchar_t *, wchar_t)const wchar_t *_Source (wchar_t (&)[_Size], const wchar_t *, unsigned int)rsize_t _DstSizersize_t _MaxCount (wchar_t *, unsigned int, const wchar_t *, unsigned int) (const wchar_t *, unsigned int)char *_Strint _Val (char *, int) (char *, int, unsigned int)const char *_Str1 (const char *, const char *, unsigned int)const char *_Str2void *_Pvint _Csize_t _N (void *, int, unsigned int)const char *_SubStr (char *, const char *)const char *_Control (char *, const char *, unsigned int, localeinfo_struct) (char *, const char *, unsigned int)char *_String (char *, localeinfo_struct)char (&_String)[_Size] (char (&)[_Size], localeinfo_struct) (char *, unsigned int, localeinfo_struct)const char *_Delimchar **_Context (char *, const char *, char **) (const char *, int) (char *, unsigned int, int, unsigned int)const char *_Source (char (&)[_Size], const char *, unsigned int) (char *, unsigned int, const char *, unsigned int) (const char *, const char *, unsigned int, localeinfo_struct)int _ErrorMessage (char (&)[_Size], int)size_t _SizeInBytes (char *, unsigned int, int)const char *_ErrorMessage (char (&)[_Size], const char *) (char *, unsigned int, const char *) (const char *, const char *, localeinfo_struct)void *_Dstconst void *_Src (void *, const void *, unsigned int) (void *, unsigned int, const void *, unsigned int) (const char *, unsigned int)const void *_Buf1const void *_Buf2 (const void *, const void *, unsigned int) (void *, const void *, int, unsigned int) (const void *, const void *, unsigned int, localeinfo_struct)const void *const void *_Buf (const void *, int, unsigned int)wcsstr_CONST_RETURN::memchr::memcmp::memcpy::memmove::memset::strcat::strchr::strcmp::strcoll::strcpy::strcspn::strerror::strlen::strncat::strncmp::strncpy::strpbrk::strrchr::strspn::strstr::strtok::strxfrmc:\archivos de programa\microsoft visual studio 8\vc\include\cwcharc:\archivos de programa\microsoft visual studio 8\vc\include\wchar.hc:\archivos de programa\microsoft visual studio 8\vc\include\wtime.inlconst time_t *_Time (wchar_t *, unsigned int, const __int64 *) (const __int64 *)wchar_t *_Swchar_t *_S1rsize_t _N1const wchar_t *_S2rsize_t _Nconst wchar_t *_S1const wchar_t *_S (const wchar_t *, wchar_t, unsigned int)const mbstate_t *_P (const int *)FILE *_Fint _M (_iobuf *, int)wint_t _WCh (unsigned short)const wchar_t **_PSourcembstate_t *_State (char *, const wchar_t **, unsigned int, int *)size_t *_Retvalconst wchar_t **_PSrc (unsigned int *, char (&)[_Size], const wchar_t **, unsigned int, int *)const wchar_t **_Src (unsigned int *, char *, unsigned int, const wchar_t **, unsigned int, int *)wchar_t _Source (char *, wchar_t, int *) (unsigned int *, char (&)[_Size], wchar_t, int *) (unsigned int *, char *, unsigned int, wchar_t, int *)const char **_PSrc (wchar_t *, const char **, unsigned int, int *)const char **_PSource (unsigned int *, wchar_t (&)[_Size], const char **, unsigned int, int *) (unsigned int *, wchar_t *, unsigned int, const char **, unsigned int, int *)wchar_t *_DstChconst char *_SrcCh (wchar_t *, const char *, unsigned int, int *)const char *_Ch (const char *, unsigned int, int *)wchar_tconst __time64_t *_Time (wchar_t (&)[_Size], const __int64 *)const tm *_Tm (wchar_t *, unsigned int, const wchar_t *, const tm *, localeinfo_struct) (wchar_t *, unsigned int, const wchar_t *, const tm *)const __time32_t *_Time (wchar_t (&)[_Size], const long *) (wchar_t *, unsigned int, const long *) (const long *)const tm *_Time (wchar_t (&)[_Size], const tm *) (wchar_t *, unsigned int, const tm *) (const tm *)const wchar_t *_Pathwchar_t (&_Drive)[_DriveSize]wchar_t (&_Dir)[_DirSize]wchar_t (&_Name)[_NameSize]wchar_t (&_Ext)[_ExtSize] (const wchar_t *, wchar_t (&)[_DriveSize], wchar_t (&)[_DirSize], wchar_t (&)[_NameSize], wchar_t (&)[_ExtSize])size_t _DriveSizesize_t _DirSizesize_t _NameSizesize_t _ExtSizeconst wchar_t *_FullPathwchar_t *_Drivesize_t _DriveSizeInWordswchar_t *_Dirsize_t _DirSizeInWordswchar_t *_Filenamesize_t _FilenameSizeInWordswchar_t *_Extsize_t _ExtSizeInWords (const wchar_t *, wchar_t *, unsigned int, wchar_t *, unsigned int, wchar_t *, unsigned int, wchar_t *, unsigned int) (const wchar_t *, wchar_t *, wchar_t *, wchar_t *, wchar_t *)const wchar_t *_EnvVarwchar_t *_ResultPath (const wchar_t *, const wchar_t *, wchar_t *)wchar_t (&_ResultPath)[_Size] (const wchar_t *, const wchar_t *, wchar_t (&)[_Size]) (const wchar_t *, const wchar_t *, wchar_t *, unsigned int)const wchar_t *_Nameconst wchar_t *_Valueconst wchar_t *_EnvStringconst wchar_t *_Driveconst wchar_t *_Dirconst wchar_t *_Ext (wchar_t *, const wchar_t *, const wchar_t *, const wchar_t *, const wchar_t *) (wchar_t (&)[_Size], const wchar_t *, const wchar_t *, const wchar_t *, const wchar_t *)wchar_t *_PathResult (wchar_t *, unsigned int, const wchar_t *, const wchar_t *, const wchar_t *, const wchar_t *)wchar_t *_FullPathwchar_t **_EndPtrint _Radix (const wchar_t *, wchar_t **, int, localeinfo_struct) (const wchar_t *, wchar_t **, int) (const wchar_t *, localeinfo_struct)unsigned __int64 _Val (unsigned __int64, wchar_t *, int) (unsigned __int64, wchar_t *, unsigned int, int)__int64 _Val (__int64, wchar_t *, int) (__int64, wchar_t *, unsigned int, int)doublewchar_t **_Buffersize_t *_BufferSizeInWordsconst wchar_t *_VarName (wchar_t **, unsigned int *, const wchar_t *)size_t *_ReturnSize (unsigned int *, wchar_t (&)[_Size], const wchar_t *) (unsigned int *, wchar_t *, unsigned int, const wchar_t *)unsigned long (const wchar_t *, wchar_t **, localeinfo_struct) (const wchar_t *, wchar_t **)unsigned long _Value (unsigned long, wchar_t *, int) (unsigned long, wchar_t (&)[_Size], int)unsigned long _Val (unsigned long, wchar_t *, unsigned int, int)long _Value (long, wchar_t *, int) (long, wchar_t (&)[_Size], int)long _Val (long, wchar_t *, unsigned int, int) (int, wchar_t *, int) (int, wchar_t (&)[_Size], int) (int, wchar_t *, unsigned int, int)wchar_t _WChconst wchar_t *_Stringsize_t *_Size (wchar_t (&)[_Size], unsigned int *)size_t *_SizeRead (wchar_t *, unsigned int, unsigned int *)_stat64 *_Stat (const wchar_t *, _stat64 *)_stat64i32 *_Stat (const wchar_t *, _stat64i32 *)_stat32i64 *_Stat (const wchar_t *, _stat32i64 *)_stat32 *_Stat (const wchar_t *, _stat32 *)_dev_t_ino_tshort_off_t__time32_ttime_tintptr_tconst wchar_t *const *_ArgListconst wchar_t *const *_Env (int, const wchar_t *, const wchar_t *const *, const wchar_t *const *) (int, const wchar_t *, const wchar_t *const *)const wchar_t *_ArgList (int, const wchar_t *, const wchar_t *, ...) (const wchar_t *, const wchar_t *const *, const wchar_t *const *) (const wchar_t *, const wchar_t *const *)int _Categoryconst wchar_t *_Localeint _OpenFlagint _ShareFlagint _PermissionMode = 0 (const wchar_t *, int, int, int) (const wchar_t *, int, int)int *_FileHandleint _PermissionFlag (int *, const wchar_t *, int, int, int)intptr_t _FindHandle_wfinddata64_t *_FindData (int, _wfinddata64_t *)_wfinddata64i32_t *_FindData (int, _wfinddata64i32_t *)_wfinddata32i64_t *_FindData (int, _wfinddata32i64_t *) (const wchar_t *, _wfinddata64_t *) (const wchar_t *, _wfinddata64i32_t *) (const wchar_t *, _wfinddata32i64_t *)wchar_t *_TemplateNamewchar_t (&_TemplateName)[_Size]const wchar_t *_NewFilenameconst wchar_t *_OldFilename_wfinddata32_t *_FindData (int, _wfinddata32_t *) (const wchar_t *, _wfinddata32_t *)int _PermissionMode (const wchar_t *, int)int _AccessModeint _Drive (wchar_t *, int)wint_t _Cwctype_t _Type (unsigned short, unsigned short) (unsigned short, localeinfo_struct) (unsigned short, unsigned short, localeinfo_struct) (int, localeinfo_struct)const wctype_t *const unsigned short []wchar_t [260]_fsize_t_ungetwch_nolock()_getwche_nolock()_getwch_nolock()_putwch_nolock()_wstat64_wstat64i32_stat64_stat64i32_fstat64_fstat64i32(0x0100|_UPPER|_LOWER)0x80000x800x400x200x100x80x40x2__pctype_func()_wfindnext64_wfindfirst64_wfindnext64i32_wfindfirst64i32_wfinddata64_t_wfinddata64i32_t0xffff::mbstate_t::tm::wint_t::btowc::fgetwc::fgetws::fputwc::fputws::fwide::fwprintf::fwscanf::getwc::getwchar::mbrlen::mbrtowc::mbsrtowcs::mbsinit::putwc::putwchar::swprintf::swscanf::ungetwc::vfwprintf::vswprintf::vwprintf::wcrtomb::wprintf::wscanf::wcsrtombs::wcstol::wcscat::wcschr::wcscmp::wcscoll::wcscpy::wcscspn::wcslen::wcsncat::wcsncmp::wcsncpy::wcspbrk::wcsrchr::wcsspn::wcstod::wcstoul::wcsstr::wcstok::wcsxfrm::wctob::wmemchr::wmemcmp::wmemcpy::wmemmove::wmemset::wcsftimec:\archivos de programa\microsoft visual studio 8\vc\include\xstddefc:\archivos de programa\microsoft visual studio 8\vc\include\cstddefc:\archivos de programa\microsoft visual studio 8\vc\include\stddef.hint *_Value (int *)(size_t)&reinterpret_cast(((( *)0)->))sm(*_errno())::ptrdiff_tstd::_STD_END_STD_BEGINclstynamestatic const   = ()()val= , y= protected()->~()ptrTytypedef int Enum_THROW(, )throw ()throw (...)throw ()throwthrow ()} catch (...) {} catch () {try {c:\archivos de programa\microsoft visual studio 8\vc\include\crtdbg.hvoid *_P (void *, int, const char *, int) (void *) (unsigned int, int, const char *, int)int _CheckCountconst _CrtMemState *_State (const _CrtMemState *)_CrtMemState *_Stateconst _CrtMemState *_OldStateconst _CrtMemState *_NewState (_CrtMemState *, const _CrtMemState *, const _CrtMemState *) (_CrtMemState *)_CRT_DUMP_CLIENT_CRT_DUMP_CLIENT _PFnNewDump (void)const void *_Memory (const void *)unsigned int _Byteslong *_RequestNumberchar **_Filenameint *_LineNumber (const void *, unsigned int, long *, char **, int *)const void *_HeapPtrconst void *_Ptrint _ReadWrite (const void *, unsigned int, int)void (*_PFn)(void *, void *)void *_Context (void (*)(void *, void *), void *)int _NewFlag_CRT_ALLOC_HOOK_CRT_ALLOC_HOOK _PfnNewHookwchar_t **_PBuffersize_t *_PBufferSizeInWordsint _BlockTypeint _LineNumber (wchar_t **, unsigned int *, const wchar_t *, int, const char *, int)char **_PBuffersize_t *_PBufferSizeInBytesconst char *_VarName (char **, unsigned int *, const char *, int, const char *, int) (int, wchar_t *, int, int, const char *, int)int _SizeInBytes (int, char *, int, int, const char *, int) (wchar_t *, int, int, const char *, int) (char *, int, int, const char *, int) (wchar_t *, const wchar_t *, unsigned int, int, const char *, int)char *_FullPathconst char *_Path (char *, const char *, unsigned int, int, const char *, int)const wchar_t *_DirName (const wchar_t *, const wchar_t *, int, const char *, int) (const char *, const char *, int, const char *, int) (const wchar_t *, int, const char *, int) (const char *, int, const char *, int)void *_Memorysize_t _NumOfElementssize_t _SizeOfElementssize_t _Alignmentsize_t _Offset (void *, unsigned int, unsigned int, unsigned int, unsigned int, const char *, int) (void *, unsigned int, unsigned int, unsigned int, const char *, int) (unsigned int, unsigned int, unsigned int, const char *, int) (void *, unsigned int, unsigned int, const char *, int) (unsigned int, unsigned int, const char *, int) (void *, int)size_t _NewSize (void *, unsigned int, int, const char *, int) (void *, unsigned int, unsigned int, int, const char *, int) (unsigned int, unsigned int, int, const char *, int)long _BreakAlloc (long)int _ReportTypeconst wchar_t *_ModuleName (int, const wchar_t *, int, const wchar_t *, const wchar_t *, ...)size_t _NewDebugFillThresholdint _Linenumberconst char *_ModuleName (int, const char *, int, const char *, const char *, ...)_HFILE_HFILE _ReportFile (int, void)int _ReportMode (int, int)_CRT_REPORT_HOOKW _PFnNewHook_CRT_REPORT_HOOK _PFnNewHook_CRT_REPORT_HOOK_CrtMemBlockHeader *size_t [5]void (* )(void *, size_t)int (* )(int, void *, size_t, int, long, const unsigned char *, int)int (* )(int, wchar_t *, int *)int (* )(int, char *, int *)_free_dbg(, )p_malloc_dbg(, , , )fl__debugbreak()_RPT_BASE_W((, _CRT_WIDE(__FILE__), __LINE__, NULL, , , , , ))rptnomsgarg1arg2arg3arg4_RPT_BASE((, __FILE__, __LINE__, NULL, , , , , ))_RPT_BASE_W((, _CRT_WIDE(__FILE__), __LINE__, NULL, , , , ))_RPT_BASE((, __FILE__, __LINE__, NULL, , , , ))_RPT_BASE_W((, _CRT_WIDE(__FILE__), __LINE__, NULL, , , ))_RPT_BASE((, __FILE__, __LINE__, NULL, , , ))_RPT_BASE_W((, _CRT_WIDE(__FILE__), __LINE__, NULL, , ))_RPT_BASE((, __FILE__, __LINE__, NULL, , ))_RPT_BASE_W((, _CRT_WIDE(__FILE__), __LINE__, NULL, L"%s", ))_RPT_BASE((, __FILE__, __LINE__, NULL, "%s", ))_RPT_BASE_W((, NULL, 0, NULL, , , , , ))_RPT_BASE((, NULL, 0, NULL, , , , , ))_RPT_BASE_W((, NULL, 0, NULL, , , , ))_RPT_BASE((, NULL, 0, NULL, , , , ))_RPT_BASE_W((, NULL, 0, NULL, , , ))_RPT_BASE((, NULL, 0, NULL, , , ))_RPT_BASE_W((, NULL, 0, NULL, , ))_RPT_BASE((, NULL, 0, NULL, , ))_RPT_BASE_W((, NULL, 0, NULL, L"%s", ))_RPT_BASE((, NULL, 0, NULL, "%s", ))(void) ((1 != _CrtDbgReportW ) || (_CrtDbgBreak(), 0))args(void) ((1 != _CrtDbgReport ) || (_CrtDbgBreak(), 0))_ASSERT_EXPR_ASSERT_EXPR((), _CRT_WIDE())_ASSERT_EXPR((), NULL)(void) ((!!()) || (1 != _CrtDbgReportW(_CRT_ASSERT, _CRT_WIDE(__FILE__), __LINE__, NULL, )) || (_CrtDbgBreak(), 0))typedef char __static_assert_t[ () ]5( >> 16 & 0xFFFF)block( & 0xFFFF)-10x040000000x008000000x001000000x080x040x020x01((_HFILE)-6)((_HFILE)-5)((_HFILE)-4)((_HFILE)-2)((_HFILE)-1)class std::basic_fstream<__wchar_t,char_traits<__wchar_t> >class std::basic_ofstream<__wchar_t,char_traits<__wchar_t> >class std::basic_ifstream<__wchar_t,char_traits<__wchar_t> >class std::basic_filebuf<__wchar_t,char_traits<__wchar_t> >class std::basic_stringstream<__wchar_t,char_traits<__wchar_t>,allocator<__wchar_t> >class std::basic_ostringstream<__wchar_t,char_traits<__wchar_t>,allocator<__wchar_t> >class std::basic_istringstream<__wchar_t,char_traits<__wchar_t>,allocator<__wchar_t> >class std::basic_stringbuf<__wchar_t,char_traits<__wchar_t>,allocator<__wchar_t> >class std::basic_iostream<__wchar_t,char_traits<__wchar_t> >class std::basic_ostream<__wchar_t,char_traits<__wchar_t> >class std::basic_istream<__wchar_t,char_traits<__wchar_t> >class std::basic_streambuf<__wchar_t,char_traits<__wchar_t> >class std::basic_ios<__wchar_t,char_traits<__wchar_t> >class std::basic_fstream >class std::basic_ofstream >class std::basic_ifstream >class std::basic_filebuf >class std::basic_stringstream,allocator >class std::basic_ostringstream,allocator >class std::basic_istringstream,allocator >class std::basic_stringbuf,allocator >class std::basic_iostream >class std::basic_ostream >class std::basic_istream >class std::basic_streambuf >class std::basic_ios >typename _Elemtypename _Traits = char_traits<_Elem>typename _Alloc = allocator<_Elem>typename _Tytypename _Traits::char_type *typename _Traits::char_type *_First1const typename _Traits::char_type *_First2std::_Unsecure_char_traits_tag (typename _Traits::char_type *, unsigned int, const typename _Traits::char_type *, unsigned int, std::_Unsecure_char_traits_tag)typename _Traitsstd::_Secure_char_traits_tag (typename _Traits::char_type *, unsigned int, const typename _Traits::char_type *, unsigned int, std::_Secure_char_traits_tag) (typename _Traits::char_type *, unsigned int, const typename _Traits::char_type *, unsigned int)typename std::_Char_traits_category<_Traits>::_Secure_char_traitstypename std::_Char_traits_category_helper<_Traits,_Inherits_from_char_traits_base<_Traits>::_Exists>::_Secure_char_traits<_Traits,true>typename _Traits::_Secure_char_traits,true>struct std::_Secure_char_traits_tagbool _Inherits_from_char_traits_basestruct std::_Unsecure_char_traits_tagcharchar [2]_Inherits_from_char_traits_base<_Traits>::_False (...)_Inherits_from_char_traits_base<_Traits>::_Truestd::_Char_traits_base (std::_Char_traits_base)_Traits"UNKNOWN VALUE"std::char_traits::_Elemstd::streamposstd::streamoff_Mbstatetstd::char_traits::_Elem *std::char_traits::_Elem *_Firststd::char_traits::_Elem _Ch (char *, unsigned int, char)std::char_traits::_Elem &_Leftconst std::char_traits::_Elem &_Right (char &, const char &)const std::char_traits::_Elem &_Left (const char &, const char &)const std::char_traits::_Elem *_First1const std::char_traits::_Elem *_First2const std::char_traits::_Elem *_Firststd::char_traits::_Elem *_First1size_t _Size_in_bytesconst std::char_traits::_Elem *const std::char_traits::_Elem &_Ch (const char *, unsigned int, const char &)const std::char_traits::int_type &_Meta (const int &)std::char_traits::int_type (const char &)const std::char_traits::int_type &_Leftconst std::char_traits::int_type &_Right (const int &, const int &)<__wchar_t>std::char_traits<__wchar_t>::_Elemstd::char_traits<__wchar_t>::_Elem *std::char_traits<__wchar_t>::_Elem *_Firststd::char_traits<__wchar_t>::_Elem _Chstd::char_traits<__wchar_t>::_Elem &_Leftconst std::char_traits<__wchar_t>::_Elem &_Right (wchar_t &, const wchar_t &)const std::char_traits<__wchar_t>::_Elem &_Left (const wchar_t &, const wchar_t &)const std::char_traits<__wchar_t>::_Elem *_First1const std::char_traits<__wchar_t>::_Elem *_First2const std::char_traits<__wchar_t>::_Elem *_Firststd::char_traits<__wchar_t>::_Elem *_First1size_t _Size_in_wordsconst std::char_traits<__wchar_t>::_Elem *const std::char_traits<__wchar_t>::_Elem &_Ch (const wchar_t *, unsigned int, const wchar_t &)const std::char_traits<__wchar_t>::int_type &_Meta (const unsigned short &)std::char_traits<__wchar_t>::int_type (const wchar_t &)const std::char_traits<__wchar_t>::int_type &_Leftconst std::char_traits<__wchar_t>::int_type &_Right (const unsigned short &, const unsigned short &)_Elem_Elem *_Elem *_First_Elem _Ch (_Elem *, unsigned int, _Elem)_Elem &_Leftconst _Elem &_Right (_Elem &, const _Elem &)const _Elem &_Left (const _Elem &, const _Elem &)const _Elem *_First1const _Elem *_First2 (const _Elem *, const _Elem *, unsigned int)const _Elem *_First (const _Elem *)_Elem *_First1 (_Elem *, const _Elem *, unsigned int)size_t _Dest_size (_Elem *, unsigned int, const _Elem *, unsigned int)const _Elem *const _Elem &_Ch (const _Elem *, unsigned int, const _Elem &)const char_traits<_Elem>::int_type &_Meta (const long &)char_traits<_Elem>::int_type (const _Elem &)const char_traits<_Elem>::int_type &_Leftconst char_traits<_Elem>::int_type &_Right (const long &, const long &)class std::fpos<_Mbstatet>const _Statetypetypename _Statetypeclass std::fpos<_Statetype>_Statetype _Statefpos_t _Fileposition (_Statetype, __int64)std::streamoff _Off = 0 (_Statetype)_Statetypefpos_ttypename fpos<_Statetype>::_Mytstd::streamoff _Offconst typename fpos<_Statetype>::_Myt &_Right (const std::fpos<_Statetype> &)typename fpos<_Statetype>::_Myt &const std::streamoff.state()pos.seekpos()(, )postypestatepositionstd::istream &mpf_ptr (std::basic_istream > &, __unnamed_003e_3)mpq_ptr (std::basic_istream > &, __unnamed_003e_2)mpz_ptr (std::basic_istream > &, __unnamed_003e_1)std::ostream &mpf_srcptr (std::basic_ostream > &, const __unnamed_003e_3)mpq_srcptr (std::basic_ostream > &, const __unnamed_003e_2)mpz_srcptr (std::basic_ostream > &, const __unnamed_003e_1)mp_ptr __gmp_dstmp_srcptr __gmp_srcmp_size_t __gmp_sizemp_limb_t __gmp_n (unsigned long, const unsigned long, long, unsigned long)mp_ptr __gmp_wpmp_srcptr __gmp_xpmp_size_t __gmp_xsizemp_srcptr __gmp_ypmp_size_t __gmp_ysize (unsigned long, const unsigned long, long, const unsigned long, long) (const unsigned long, const unsigned long, long)mpq_ptr __gmp_wmpq_srcptr __gmp_u (__unnamed_003e_2, const __unnamed_003e_2)mpz_srcptr __gmp_z (const __unnamed_003e_1)mpz_ptr __gmp_w (__unnamed_003e_1, const __unnamed_003e_2)mpz_srcptr __gmp_umpz_srcptr __gmp_a (__unnamed_003e_1, const __unnamed_003e_1)mp_size_t __gmp_n (const __unnamed_003e_1, long)mp_ptrmp_size_tmp_srcptr (unsigned long, unsigned long, long, const unsigned long, long, const unsigned long, long) (unsigned long, const unsigned long, const unsigned long, long) (unsigned long, unsigned long, const unsigned long, long) (unsigned long, const unsigned char *, unsigned int, int) (const unsigned long, unsigned long) (unsigned long, const unsigned long, long, unsigned int) (unsigned long, long) (const unsigned long, long, unsigned long, unsigned long) (unsigned long, const unsigned long, long, unsigned long, unsigned long) (const unsigned long, long) (const unsigned long, long, unsigned long)unsigned char * (unsigned char *, int, unsigned long, long)mp_size_t * (unsigned long, unsigned long, long *, unsigned long, long, unsigned long, long) (unsigned long, unsigned long, long, unsigned long, long) (unsigned long, long, unsigned long, long, const unsigned long) (unsigned long, long, const unsigned long, long, unsigned long) (unsigned long, long, unsigned long, long, const unsigned long, long) (unsigned long, unsigned long, long, const unsigned long, long, unsigned long)mpf_tgmp_randstate_t (__unnamed_003e_3, __unnamed_003e_5, unsigned long) (__unnamed_003e_3, unsigned long, const __unnamed_003e_3) (__unnamed_003e_3, const __unnamed_003e_3) (__unnamed_003e_3, __unnamed_003e_3) (__unnamed_003e_3, const __unnamed_003e_3, unsigned long) (__unnamed_003e_3, const __unnamed_003e_3, const __unnamed_003e_3) (__unnamed_003e_3, unsigned long) (const __unnamed_003e_3) (__unnamed_003e_3, const __unnamed_003e_1) (__unnamed_003e_3, const char *, int) (__unnamed_003e_3, long) (__unnamed_003e_3, const __unnamed_003e_2) (unsigned long) (__unnamed_003e_3, double)mp_exp_t (__unnamed_003e_3, long, long) (_iobuf *, int, unsigned int, const __unnamed_003e_3) (__unnamed_003e_3, _iobuf *, int) (__unnamed_003e_3)mp_exp_t * (char *, long *, int, unsigned int, const __unnamed_003e_3)long * (long *, const __unnamed_003e_3) (const __unnamed_003e_3, const __unnamed_003e_3, unsigned long) (const __unnamed_003e_3, unsigned long) (const __unnamed_003e_3, long) (const __unnamed_003e_3, double) (const __unnamed_003e_3, const __unnamed_003e_3) (__unnamed_003e_2, __unnamed_003e_2) (__unnamed_003e_2, const __unnamed_003e_2, const __unnamed_003e_2) (__unnamed_003e_2, const __unnamed_003e_1) (__unnamed_003e_2, unsigned long, unsigned long) (__unnamed_003e_2, const char *, int) (__unnamed_003e_2, long, unsigned long) (__unnamed_003e_2, const __unnamed_003e_3) (__unnamed_003e_2, double) (_iobuf *, int, const __unnamed_003e_2) (__unnamed_003e_2, const __unnamed_003e_2, unsigned long) (__unnamed_003e_2, _iobuf *, int) (__unnamed_003e_2) (char *, int, const __unnamed_003e_2) (const __unnamed_003e_2) (const __unnamed_003e_2, const __unnamed_003e_2) (const __unnamed_003e_2, unsigned long, unsigned long) (const __unnamed_003e_2, long, unsigned long) (__unnamed_003e_1, const __unnamed_003e_1, const __unnamed_003e_1) (__unnamed_003e_1, __unnamed_003e_5, const __unnamed_003e_1) (__unnamed_003e_1, __unnamed_003e_5, unsigned long) (__unnamed_003e_1, unsigned long, unsigned long) (const __unnamed_003e_1, unsigned long) (__unnamed_003e_1, const __unnamed_003e_1, unsigned long) (__unnamed_003e_1, __unnamed_003e_1, const __unnamed_003e_1, unsigned long) (__unnamed_003e_1, __unnamed_003e_1, const __unnamed_003e_1, const __unnamed_003e_1) (__unnamed_003e_1, __unnamed_003e_1) (__unnamed_003e_1, unsigned long, const __unnamed_003e_1) (__unnamed_003e_1, __unnamed_003e_1, const __unnamed_003e_1) (const __unnamed_003e_1, int) (__unnamed_003e_1, unsigned long) (__unnamed_003e_1, const char *, int) (__unnamed_003e_1, long) (__unnamed_003e_1, const __unnamed_003e_3) (__unnamed_003e_1, double) (__unnamed_003e_1, const __unnamed_003e_1, unsigned long, const __unnamed_003e_1) (__unnamed_003e_1, const __unnamed_003e_1, const __unnamed_003e_1, const __unnamed_003e_1) (_iobuf *, int, const __unnamed_003e_1) (_iobuf *, const __unnamed_003e_1) (__unnamed_003e_1, const __unnamed_003e_1, long) (__unnamed_003e_1, __unnamed_003e_1, unsigned long) (unsigned long, const __unnamed_003e_1) (long, const __unnamed_003e_1) (const __unnamed_003e_1, const __unnamed_003e_1) (__unnamed_003e_1, _iobuf *, int) (__unnamed_003e_1, _iobuf *) (__unnamed_003e_1) (__unnamed_003e_1, unsigned int, int, unsigned int, int, unsigned int, const void *) (char *, int, const __unnamed_003e_1) (long *, const __unnamed_003e_1) (__unnamed_003e_1, __unnamed_003e_1, __unnamed_003e_1, const __unnamed_003e_1, const __unnamed_003e_1)size_t * (void *, unsigned int *, int, unsigned int, int, unsigned int, const __unnamed_003e_1) (const __unnamed_003e_1, unsigned long, unsigned long) (const __unnamed_003e_1, const __unnamed_003e_1, unsigned long) (const __unnamed_003e_1, const __unnamed_003e_1, const __unnamed_003e_1) (const __unnamed_003e_1, double) (__unnamed_003e_1, long, long)char ** (char **, const char *, ...) (__unnamed_003e_5, unsigned long) (__unnamed_003e_5) (__unnamed_003e_5, const __unnamed_003e_1)const __gmp_randstate_struct * (__unnamed_003e_5, const __unnamed_003e_5 *) (__unnamed_003e_5, const __unnamed_003e_1, unsigned long, unsigned long)gmp_randalg_t (__unnamed_003e_5, __unnamed_003e_4, ...)const char *constconst intvoid *(**)(size_t)void *(**)(void *, size_t, size_t)void (**)(void *, size_t) (void *(**)(unsigned int), void *(**)(void *, unsigned int, unsigned int), void (**)(void *, unsigned int))void *(*)(size_t)void *(*)(void *, size_t, size_t)void (*)(void *, size_t) (void *(*)(unsigned int), void *(*)(void *, unsigned int, unsigned int), void (*)(void *, unsigned int))__mpq_struct *const __mpq_struct *__mpf_struct *const __mpf_struct *__mpz_struct *const __mpz_struct *__gmp_randstate_struct [1]__unnamed_003e_5mpz_t__unnamed_003e_5::__unnamed_003e_5_1__unnamed_003e_4__mpf_struct [1]__unnamed_003e_3mp_limb_t *__mpq_struct [1]__mpq_struct__unnamed_003e_2__mpz_structconst mp_limb_t *__mpz_struct [1]__unnamed_003e_1mpz_fdiv_r_2expmpz_fdiv_q_2expmpz_fdiv_qr_uimpz_fdiv_q_uimpz_fdiv_qrmpz_fdiv_q((() == 0) ? mpz_fdiv_ui (,) : mpz_fdiv_r_ui (,,))rd((() == 0) ? mpz_fdiv_q_ui (,,) : mpz_fdiv_qr_ui (,,,))qmpz_fdiv_rmpn_divrem (, __GMP_CAST (mp_size_t, 0), , , , )qpnpnsizedpdsize(! mpz_odd_p ())z((()->_mp_size != 0) & __GMP_CAST (int, ()->_mp_d[0]))_mpq_cmp_si(,,)_mpq_cmp_ui (,,)QNUIDUI_mpz_cmp_si (,)ZUI_mpz_cmp_ui (,)(()->_mp_num._mp_size < 0 ? -1 : ()->_mp_num._mp_size > 0)(()->_mp_size < 0 ? -1 : ()->_mp_size > 0)F__GMPN_COPY_REST (, , , 0)do { mp_size_t __gmp_j; __GMP_CRAY_Pragma ("_CRI ivdep"); for (__gmp_j = (); __gmp_j < (); __gmp_j++) ()[__gmp_j] = ()[__gmp_j]; } while (0)startdo { mp_size_t __gmp_i; mp_limb_t __gmp_x, __gmp_y; () = 0; __gmp_i = (); while (--__gmp_i >= 0) { __gmp_x = ()[__gmp_i]; __gmp_y = ()[__gmp_i]; if (__gmp_x != __gmp_y) { () = (__gmp_x > __gmp_y ? 1 : -1); break; } } } while (0)resultxpyp__GMPN_AORS_1(, , , , , -, __GMPN_SUBCB)cout__GMPN_AORS_1(, , , , , +, __GMPN_ADDCB)(() < ())(() < ())do { mp_size_t __gmp_i; mp_limb_t __gmp_x, __gmp_r; __gmp_x = ()[0]; __gmp_r = __gmp_x  (); ()[0] = __gmp_r; if ( (__gmp_r, __gmp_x, ())) { () = 1; for (__gmp_i = 1; __gmp_i < ();) { __gmp_x = ()[__gmp_i]; __gmp_r = __gmp_x  1; ()[__gmp_i] = __gmp_r; ++__gmp_i; if (! (__gmp_r, __gmp_x, 1)) { if (() != ()) __GMPN_COPY_REST (, , , __gmp_i); () = 0; break; } } } else { if (() != ()) __GMPN_COPY_REST (, , , 1); () = 0; } } while (0)OPCB__GMPN_AORS (, , , , , , mpn_sub_n, ((()[__gmp_i++] = (__gmp_x - 1) & GMP_NUMB_MASK), __gmp_x == 0))wpxsizeysize__GMPN_AORS (, , , , , , mpn_add_n, ((()[__gmp_i++] = (__gmp_x + 1) & GMP_NUMB_MASK) == 0))do { mp_size_t __gmp_i; mp_limb_t __gmp_x; __gmp_i = (); if (__gmp_i != 0) { if ( (, , , __gmp_i)) { do { if (__gmp_i >= ()) { () = 1; goto __gmp_done; } __gmp_x = ()[__gmp_i]; } while (); } } if (() != ()) __GMPN_COPY_REST (, , , __gmp_i); () = 0; __gmp_done: ; } while (0)FUNCTIONTESTmp_size_t __gmp_n = ->_mp_size; mp_ptr __gmp_p = ->_mp_d; return (__gmp_n == 0 || (__gmp_n == 1 && __gmp_p[0] <= ));maxval__MPN(tdiv_qr)__MPN(submul_1)__MPN(sub_n)__MPN(sub_1)__MPN(sub)__MPN(sqrtrem)__MPN(set_str)__MPN(scan1)__MPN(scan0)__MPN(rshift)__MPN(random2)__MPN(random)__MPN(preinv_mod_1)__MPN(pow_1)__MPN(popcount)__MPN(perfect_square_p)__MPN(mul_n)__MPN(mul_1)__MPN(mul)__MPN(mod_1)__MPN(lshift)__MPN(hamdist)__MPN(get_str)__MPN(gcdext)__MPN(gcd_1)__MPN(gcd)__MPN(divrem_2)__MPN(divrem_1)__MPN(divrem)mpn_divrem_1 (, __GMP_CAST (mp_size_t, 0), , , )dlimb__MPN(divexact_by3c)mpn_divexact_by3c (, , , __GMP_CAST (mp_limb_t, 0))__MPN(cmp)__MPN(bdivmod)__MPN(addmul_1)__MPN(add_n)__MPN(add_1)__MPN(add)__gmpf_urandomb__gmpf_ui_sub__gmpf_ui_div__gmpf_trunc__gmpf_swap__gmpf_sub_ui__gmpf_sub__gmpf_sqrt_ui__gmpf_sqrt__gmpf_size__gmpf_set_z__gmpf_set_ui__gmpf_set_str__gmpf_set_si__gmpf_set_q__gmpf_set_prec_raw__gmpf_set_prec__gmpf_set_default_prec__gmpf_set_d__gmpf_set__gmpf_reldiff__gmpf_random2__gmpf_pow_ui__gmpf_out_str__gmpf_neg__gmpf_mul_ui__gmpf_mul_2exp__gmpf_mul__gmpf_integer_p__gmpf_inp_str__gmpf_init_set_ui__gmpf_init_set_str__gmpf_init_set_si__gmpf_init_set_d__gmpf_init_set__gmpf_init2__gmpf_init__gmpf_get_ui__gmpf_get_str__gmpf_get_si__gmpf_get_prec__gmpf_get_default_prec__gmpf_get_d_2exp__gmpf_get_d__gmpf_floor__gmpf_fits_ushort_p__gmpf_fits_ulong_p__gmpf_fits_uint_p__gmpf_fits_sshort_p__gmpf_fits_slong_p__gmpf_fits_sint_p__gmpf_eq__gmpf_dump__gmpf_div_ui__gmpf_div_2exp__gmpf_div__gmpf_cmp_ui__gmpf_cmp_si__gmpf_cmp_d__gmpf_cmp__gmpf_clear__gmpf_ceil__gmpf_add_ui__gmpf_add__gmpf_abs__gmpq_swap__gmpq_sub__gmpq_set_z__gmpq_set_ui__gmpq_set_str__gmpq_set_si__gmpq_set_num__gmpq_set_f__gmpq_set_den__gmpq_set_d__gmpq_set__gmpq_out_str__gmpq_neg__gmpq_mul_2exp__gmpq_mul__gmpq_inv__gmpq_inp_str__gmpq_init__gmpq_get_str__gmpq_get_d__gmpq_get_den__gmpq_get_num__gmpq_equal__gmpq_div_2exp__gmpq_div__gmpq_cmp_ui__gmpq_cmp_si__gmpq_cmp__gmpq_clear__gmpq_canonicalize__gmpq_add__gmpq_abs__gmpz_xor__gmpz_urandomm__gmpz_urandomb__gmpz_ui_pow_ui__gmpz_tstbit__gmpz_tdiv_r_ui__gmpz_tdiv_r_2exp__gmpz_tdiv_r__gmpz_tdiv_qr_ui__gmpz_tdiv_qr__gmpz_tdiv_q_ui__gmpz_tdiv_q_2exp__gmpz_tdiv_q__gmpz_tdiv_ui__gmpz_swap__gmpz_submul_ui__gmpz_submul__gmpz_ui_sub__gmpz_sub_ui__gmpz_sub__gmpz_sqrtrem__gmpz_sqrt__gmpz_sizeinbase__gmpz_size__gmpz_setbit__gmpz_set_ui__gmpz_set_str__gmpz_set_si__gmpz_set_q__gmpz_set_f__gmpz_set_d__gmpz_set__gmpz_scan1__gmpz_scan0__gmpz_rrandomb__gmpz_rootrem__gmpz_root__gmpz_remove__gmpz_realloc2__gmpz_random2__gmpz_random__gmpz_probab_prime_p__gmpz_powm_ui__gmpz_powm__gmpz_pow_ui__gmpz_popcount__gmpz_perfect_square_p__gmpz_perfect_power_p__gmpz_out_str__gmpz_out_raw__gmpz_nextprime__gmpz_neg__gmpz_mul_ui__gmpz_mul_si__gmpz_mul_2exp__gmpz_mulmpz_fdiv_r_ui__gmpz_mod__gmpz_millerrabin__gmpz_lucnum2_ui__gmpz_lucnum_uimpz_jacobi__gmpz_lcm_ui__gmpz_lcm__gmpz_ui_kronecker__gmpz_si_kronecker__gmpz_kronecker_ui__gmpz_kronecker_si__gmpz_jacobi__gmpz_ior__gmpz_invert__gmpz_inp_str__gmpz_inp_raw__gmpz_init_set_ui__gmpz_init_set_str__gmpz_init_set_si__gmpz_init_set_d__gmpz_init_set__gmpz_init2__gmpz_init__gmpz_import__gmpz_hamdist__gmpz_getlimbn__gmpz_get_ui__gmpz_get_str__gmpz_get_si__gmpz_get_d_2exp__gmpz_get_d__gmpz_gcdext__gmpz_gcd_ui__gmpz_gcd__gmpz_fits_ushort_p__gmpz_fits_ulong_p__gmpz_fits_uint_p__gmpz_fits_sshort_p__gmpz_fits_slong_p__gmpz_fits_sint_p__gmpz_fib2_ui__gmpz_fib_ui__gmpz_fdiv_ui__gmpz_fdiv_r_ui__gmpz_fdiv_r_2exp__gmpz_fdiv_r__gmpz_fdiv_qr_ui__gmpz_fdiv_qr__gmpz_fdiv_q_ui__gmpz_fdiv_q_2exp__gmpz_fdiv_q__gmpz_fac_ui__gmpz_export__gmpz_dump__gmpz_divisible_2exp_p__gmpz_divisible_ui_p__gmpz_divisible_p__gmpz_divexact_ui__gmpz_divexact__gmpz_congruent_ui_p__gmpz_congruent_2exp_p__gmpz_congruent_p__gmpz_combit__gmpz_com__gmpz_cmpabs_ui__gmpz_cmpabs_d__gmpz_cmpabs__gmpz_cmp_ui__gmpz_cmp_si__gmpz_cmp_d__gmpz_cmp__gmpz_clrbit__gmpz_clear__gmpz_cdiv_ui__gmpz_cdiv_r_ui__gmpz_cdiv_r_2exp__gmpz_cdiv_r__gmpz_cdiv_qr_ui__gmpz_cdiv_qr__gmpz_cdiv_q_ui__gmpz_cdiv_q_2exp__gmpz_cdiv_q__gmpz_bin_uiui__gmpz_bin_ui__gmpz_array_init__gmpz_and__gmpz_addmul_ui__gmpz_addmul__gmpz_add_ui__gmpz_add__gmpz_abs__gmpz_realloc__gmp_vsscanf__gmp_vscanf__gmp_vfscanf__gmp_sscanf__gmp_scanf__gmp_fscanf__gmp_vsprintf__gmp_vsnprintf__gmp_vprintf__gmp_vfprintf__gmp_vasprintf__gmp_sprintf__gmp_snprintf__gmp_printf__gmp_obstack_vprintf__gmp_obstack_printf__gmp_fprintf__gmp_asprintf__gmp_urandomm_ui__gmp_urandomb_ui__gmp_randclear__gmp_randseed_ui__gmp_randseed__gmp_randinit_set__gmp_randinit_mt__gmp_randinit_lc_2exp_size__gmp_randinit_lc_2exp__gmp_randinit_default__gmp_randinit__gmp_version__gmp_errno__gmp_bits_per_limb__gmp_get_memory_functions__gmp_set_memory_functions(&(()->_mp_den))(&(()->_mp_num))()((unsigned short) ~0)(~ (unsigned long) 0)(~ (unsigned) 0)(() > () ? () : ())hi(() >= 0 ? () : -())inline(static_cast<> ())typemajmin__gmpn___declspec(dllexport)signed(~ GMP_NUMB_MASK)GMP_NUMB_MASK((~ __GMP_CAST (mp_limb_t, 0)) >> GMP_NAIL_BITS)(GMP_LIMB_BITS - GMP_NAIL_BITS)c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\x64\fib_table.cc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\x64\mp_bases.cmpz_ptr rdouble d (mpz_ptr, double)c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\gen-bases\gen-bases.cc:\archivos de programa\microsoft visual studio 8\vc\include\math.hlong doublelong double _X (long double)int _Y (long double, int)long double _Y (long double, long double)long double *_Y (long double, long double *)int *_Y (long double, int *)floatfloat _X (float) (float, int)float _Y (float, float)float *_Y (float, float *) (float, int *)double _X (double, int) (double)long _X_Ty_Ty _X (_Ty, int)int _Xdouble _Y (int, double) (double, double)_complex _X (_complex)long double _Numberlong double _Signint _Flagdouble *_Y (double, double *)_exception *_Except (_exception *) (double, int *)_complex _Complexconst char *_String (const char *, localeinfo_struct)double _Numberdouble _Sign_matherr_PLOSS_TLOSS_UNDERFLOW_OVERFLOW_SING_DOMAIN_HUGE34336int argcchar **argv (int, char **)int limb_bitsint nail_bitsint base (int, int, int)unsigned int x((() & (() - 1)) == 0)c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\gen-fac_ui\gen-fac_ui.cc:\archivos de programa\microsoft visual studio 8\vc\include\stdlib.hc:\archivos de programa\microsoft visual studio 8\vc\include\limits.hSIZE_MAXUINT_MAX0xffffffffffffffffui649223372036854775807i64(-9223372036854775807i64 - 1)0xffffffffui322147483647i32(-2147483647i32 - 1)0xffffui1632767i16(-32767i16 - 1)0xffui8127i8(-127i8 - 1)0xffffffffUL2147483647L(-2147483647L - 1)0xffffffff(-2147483647 - 1)(-32768)SCHAR_MAXSCHAR_MIN0xff127(-128)_onexit_t_onexit_t _Funcchar *_Dstbuf (unsigned long, char *, int)char *_Buf1char *_Buf2 (char *, char *, int)const char *_EnvString (long, char *, int) (int, char *, int)double _Valint _NumOfDigits (double, int, char *)int _NumOfDecint *_PtDecint *_PtSign (double, int, int *, int *)unsigned long _Durationunsigned int _Frequencyunsigned int _Duration (unsigned int, unsigned int)const char *_Destchar (&_Drive)[_DriveSize]char (&_Dir)[_DirSize]char (&_Name)[_NameSize]char (&_Ext)[_ExtSize] (const char *, char (&)[_DriveSize], char (&)[_DirSize], char (&)[_NameSize], char (&)[_ExtSize])const char *_FullPathchar *_Drivechar *_Dirchar *_Filenamesize_t _FilenameSizechar *_Ext (const char *, char *, unsigned int, char *, unsigned int, char *, unsigned int, char *, unsigned int) (const char *, char *, char *, char *, char *)const char *_EnvVarchar *_ResultPath (const char *, const char *, char *)char (&_ResultPath)[_Size] (const char *, const char *, char (&)[_Size]) (const char *, const char *, char *, unsigned int)int _Shift (unsigned __int64, int)unsigned int _Val (unsigned int, int)const char *_Nameconst char *_Valuechar *_Pathconst char *_Driveconst char *_Dirconst char *_Ext (char *, const char *, const char *, const char *, const char *)char (&_Path)[_Size] (char (&)[_Size], const char *, const char *, const char *, const char *)char *_PathResult (char *, unsigned int, const char *, const char *, const char *, const char *) (unsigned long, int)_CRT_FLOAT *_Result (__unnamed_023a_3 *, char *, localeinfo_struct)_LDOUBLE *_Result (__unnamed_023a_1 *, char *, localeinfo_struct)_CRT_DOUBLE *_Result (__unnamed_023a_2 *, char *, localeinfo_struct) (__unnamed_023a_3 *, char *) (__unnamed_023a_1 *, char *) (__unnamed_023a_2 *, char *)double _Value (char (&)[_Size], double, int) (char *, unsigned int, double, int) (char (&)[_Size], double, int, int *, int *) (char *, unsigned int, double, int, int *, int *)int _NumOfDights (void *, unsigned int, unsigned int, unsigned int, unsigned int) (void *, unsigned int, unsigned int, unsigned int) (void *, unsigned int, unsigned int) (unsigned int, unsigned int, unsigned int) (void *, unsigned int) (char *, const wchar_t *, unsigned int, localeinfo_struct)size_t *_PtNumOfCharConverted (unsigned int *, char (&)[_Size], const wchar_t *, unsigned int, localeinfo_struct)size_t _DstSizeInBytessize_t _MaxCountInBytes (unsigned int *, char *, unsigned int, const wchar_t *, unsigned int, localeinfo_struct) (char *, const wchar_t *, unsigned int) (unsigned int *, char (&)[_Size], const wchar_t *, unsigned int) (unsigned int *, char *, unsigned int, const wchar_t *, unsigned int)int *_SizeConvertedchar *_MbCh (int *, char *, unsigned int, wchar_t, localeinfo_struct)rsize_t _SizeInBytes (int *, char *, unsigned int, wchar_t) (char *, wchar_t, localeinfo_struct) (char *, wchar_t) (unsigned long, char (&)[_Size], int) (unsigned long, char *, unsigned int, int)char **_EndPtr (const char *, char **, int, localeinfo_struct) (const char *, char **, int) (const char *, char **, localeinfo_struct) (const char *, char **)unsigned int _Seed (wchar_t *, const char *, unsigned int, localeinfo_struct) (unsigned int *, wchar_t (&)[_Size], const char *, unsigned int, localeinfo_struct)const char *_SrcBuf (unsigned int *, wchar_t *, unsigned int, const char *, unsigned int, localeinfo_struct) (wchar_t *, const char *, unsigned int) (unsigned int *, wchar_t (&)[_Size], const char *, unsigned int) (unsigned int *, wchar_t *, unsigned int, const char *, unsigned int)size_t _SrcSizeInBytes (const char *, unsigned int, localeinfo_struct) (long, char (&)[_Size], int) (long, char *, unsigned int, int)ldiv_tlong _A1long _A2 (long, long)long _Numeratorlong _Denominator (unsigned __int64, char *, int) (unsigned __int64, char *, unsigned int, int) (__int64, char *, int) (__int64, char *, unsigned int, int) (int, char (&)[_Size], int) (int, char *, unsigned int, int) (char **, unsigned int *, const char *) (unsigned int *, char (&)[_Size], const char *) (unsigned int *, char *, unsigned int, const char *)div_tint _Numeratorint _Denominatorunsigned __int64 _Int64 (unsigned __int64)unsigned long _Longunsigned short _Shortvoid *_Baseint (*_PtFuncCompare)(const void *, const void *) (void *, unsigned int, unsigned int, int (*)(const void *, const void *))rsize_t _NumOfElementsrsize_t _SizeOfElementsint (*_PtFuncCompare)(void *, const void *, const void *) (void *, unsigned int, unsigned int, int (*)(void *, const void *, const void *), void *)const void *_Keyconst void *_Base (const void *, const void *, unsigned int, unsigned int, int (*)(const void *, const void *)) (const void *, const void *, unsigned int, unsigned int, int (*)(void *, const void *, const void *), void *) (__int64)unsigned int _Flagsunsigned int _Maskint _Codechar (* )[_SizeOfArray]_CountofType (&_Array)[_SizeOfArray] (_CountofType (&)[_SizeOfArray])typename _CountofTypesize_t _SizeOfArrayunsigned int *_Value (unsigned int *)int *_PModewchar_t **_Value (wchar_t **)char **_Value (char **)wchar_t **unsigned long *_Value (unsigned long *)unsigned long *_invalid_parameter_handler_invalid_parameter_handler _Handlervoid (* )(const wchar_t *, const wchar_t *, const wchar_t *, unsigned int, uintptr_t)_purecall_handler_purecall_handler _Handlervoid (* )(void) (localeinfo_struct)__unnamed_023a_5unsigned char [12]__unnamed_023a_4__unnamed_023a_3__unnamed_023a_2__unnamed_023a_1unsigned char [10]struct _ldiv_tstruct _div_tint (* )(void)_environ_sys_nerr_sys_errlist(309+40)sizeof(*__countof_helper())_Array(*__sys_nerr())(__sys_errlist())(*__doserrno())256((() < ()) ? () : ())ab((() > ()) ? () : ())__mb_cur_max0x7fff((unsigned char *)(&()->ld))char *argv[] (int, char *[])int numbint nailint limbmpz_t xmpz_t yint z (mpz_t, mpz_t, int)c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\gen-fib\gen-fib.cint numb_bitsmpz_t *c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\gen-psqr\gen-psqr.cmpz_t maskint m (mpz_t, int)int nint pconst void *pargconst void *qarg (const void *, const void *)factor_t *rawfactor_t *char [128]do { mem_copyi ((char *) &()[], (char *) &()[+1], (()-(()+1)) * sizeof ([0])); ()--; } while (0)arrayidxnarrayc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\tests\misc.cc:\archivos de programa\microsoft visual studio 8\vc\include\ctype.hint _Mask (localeinfo_struct, int, int)int _Type (int, int, localeinfo_struct)__iscsym__iscsymf__toascii__isascii(_iswalnum_l(, ) || (() == '_'))_p(_iswalpha_l(, ) || (() == '_'))(_isalnum_l(, ) || (() == '_'))(_isalpha_l(, ) || (() == '_'))(iswalnum() || (() == '_'))(iswalpha() || (() == '_'))(isalnum() || (() == '_'))(isalpha() || (() == '_'))( () & 0x7f )_Char( (unsigned)() < 0x80 )( ()-'a'+'A' )( ()-'A'+'a' )_ischartype_l(, _CONTROL, )_Locale_ischartype_l(, _PUNCT|_ALPHA|_DIGIT, )_ischartype_l(, _BLANK|_PUNCT|_ALPHA|_DIGIT, )_ischartype_l(, _ALPHA|_DIGIT, )_ischartype_l(, _PUNCT, )_ischartype_l(, _SPACE, )_ischartype_l(, _HEX, )_ischartype_l(, _DIGIT, )_ischartype_l(, _LOWER, )_ischartype_l(, _UPPER, )_ischartype_l(, _ALPHA, )( (()!=NULL && (((_locale_t)())->locinfo->mb_cur_max) > 1) ? _isctype_l(, (), ) : _chvalidchk_l(,,))_Flag_chvalidator_l(, , )_chvalidator(,)___mb_cur_max_func()c:\archivos de programa\microsoft visual studio 8\vc\include\signal.hint _SigNumvoid (* )(int)void (*_Func)(int) (int, void (*)(int))(void (__cdecl *)(int))-1(void (__cdecl *)(int))4(void (__cdecl *)(int))3(void (__cdecl *)(int))2(void (__cdecl *)(int))1(void (__cdecl *)(int))02221151123c:\archivos de programa\microsoft visual studio 8\vc\include\float.hc:\archivos de programa\microsoft visual studio 8\vc\include\crtwrn.hIterator debugging not supported in retail builds.\n Setting _HAS_ITERATOR_DEBUGGING=01005Special transfer of control routines not defined for this platform1004_USE_32BIT_TIME_T ignored. You cannot use 32-bit time_t with _WIN641003'explicit' keyword not recognized1002_vcclrit.h is deprecated1001__CRT_WARNING( _CRTWRN_WNUMBER_, _CRTWRN_MESSAGE_ )_Idmessage("" __FILE__ "(" _CRT_STRINGIZE(__LINE__) ") : " "warning CRT" _CRT_STRINGIZE() ": " _CRT_STRINGIZE())_Number_Descriptionlong _Y (double, long)unsigned int _NewValueunsigned int *_X86_cwunsigned int *_Sse2_cw (unsigned int, unsigned int, unsigned int *, unsigned int *)unsigned int *_X86_statusunsigned int *_SSE2_status (unsigned int *, unsigned int *)unsigned int *_CurrentState (unsigned int *, unsigned int, unsigned int)_FPE_EXPLICITGEN_FPE_STACKUNDERFLOW_FPE_STACKOVERFLOW_FPE_SQRTNEG_FPE_UNEMULATED_FPE_INEXACT_FPE_UNDERFLOW_FPE_OVERFLOW_FPE_ZERODIVIDE_FPE_DENORMAL_FPE_INVALID_SW_STACKUNDERFLOW_SW_STACKOVERFLOW_SW_SQRTNEG_SW_UNEMULATED_SW_INEXACT_SW_UNDERFLOW_SW_OVERFLOW_SW_ZERODIVIDE_SW_DENORMAL_SW_INVALID_CW_DEFAULT_PC_64_PC_53_PC_24_MCW_PC_RC_NEAR_RC_DOWN_RC_UP_RC_CHOP_MCW_RC_IC_PROJECTIVE_IC_AFFINE_MCW_IC_EM_INEXACT_EM_UNDERFLOW_EM_OVERFLOW_EM_ZERODIVIDE_EM_DENORMAL_EM_INVALID_MCW_EM_EM_AMBIGUOUS_LDBL_ROUNDS_LDBL_RADIX_DBL_ROUNDS_DBL_RADIX_control87_status87_clear870x02000x01000x8c0x8b0x8a0x880x870x860x850x840x830x820x810x0400( _RC_NEAR + _PC_53 + _EM_INVALID + _EM_ZERODIVIDE + _EM_OVERFLOW + _EM_UNDERFLOW + _EM_INEXACT + _EM_DENORMAL)0x030000000x020000000x010000000x000000000x000400000x000200000x000100000x000300000x000003000x000002000x000001000x000800000x000000100x000000080x000000040x000000020x000000010x0008001f0x80000000_statusfp_clearfpDBL_ROUNDSDBL_RADIXDBL_MIN_EXPDBL_MIN_10_EXPDBL_MINDBL_MAX_EXPDBL_MAX_10_EXPDBL_MAXDBL_MANT_DIGDBL_EPSILONDBL_DIG(-125)(-37)1.175494351e-38F128383.402823466e+38F241.192092896e-07F(-1021)(-307)2.2250738585072014e-30810243081.7976931348623158e+308532.2204460492503131e-016c:\archivos de programa\microsoft visual studio 8\vc\include\time.hc:\archivos de programa\microsoft visual studio 8\vc\include\time.inltime_t *_Time (__int64 *)tm *_Tm (tm *) (tm *, const __int64 *)tm * (char *, unsigned int, const __int64 *)time_t _Time1time_t _Time2 (__int64, __int64)char * [2]unsigned int _MilliSec (tm *, unsigned int)__time64_t *_Time (char (&)[_Size], const __int64 *)__time64_t _Time1__time64_t _Time2__time32_t *_Time (long *)size_t _Max_size (char *, unsigned int, const char *, const tm *, localeinfo_struct) (char *, unsigned int, const char *, const tm *) (tm *, const long *)__time32_t _Time1__time32_t _Time2clock_t (char (&)[_Size], const long *) (char *, unsigned int, const long *) (char (&)[_Size], const tm *) (char *, unsigned int, const tm *)size_t *_ReturnValueint _Index (unsigned int *, char *, unsigned int, int)long *_Timezonelong *_Daylight_savings_biasint *_DaylightCLOCKS_PER_SEC(__tzname())(*__timezone())(*__dstbias())(*__daylight())1000c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\tests\tests.hc:\archivos de programa\microsoft visual studio 8\vc\include\setjmp.hjmp_buf _Bufint [16]struct __JUMP_BUFFER16_setjmpc:\archivos de programa\microsoft visual studio 8\vc\include\stringc:\archivos de programa\microsoft visual studio 8\vc\include\istreamc:\archivos de programa\microsoft visual studio 8\vc\include\ostreamc:\archivos de programa\microsoft visual studio 8\vc\include\iosc:\archivos de programa\microsoft visual studio 8\vc\include\xlocnumc:\archivos de programa\microsoft visual studio 8\vc\include\climitsc:\archivos de programa\microsoft visual studio 8\vc\include\cstdlib::div_t::ldiv_t::abort::abs::atexit::atof::atoi::atol::bsearch::calloc::div::exit::free::getenv::labs::ldiv::malloc::mblen::mbstowcs::mbtowc::qsort::rand::realloc::srand::strtod::strtol::strtoul::system::wcstombs::wctombc:\archivos de programa\microsoft visual studio 8\vc\include\streambufc:\archivos de programa\microsoft visual studio 8\vc\include\xiosbasec:\archivos de programa\microsoft visual studio 8\vc\include\xlocalec:\archivos de programa\microsoft visual studio 8\vc\include\stdexceptc:\archivos de programa\microsoft visual studio 8\vc\include\exceptionc:\archivos de programa\microsoft visual studio 8\vc\include\eh.h_se_translator_function_se_translator_function _NewPtFuncunexpected_functionunexpected_function _NewPtFuncterminate_functionterminate_function _NewPtFuncconst type_info &_Type_EXCEPTION_POINTERS *_ExceptionPtr (const type_info &, _EXCEPTION_POINTERS *)void (* )(unsigned int, struct _EXCEPTION_POINTERS *)c:\archivos de programa\microsoft visual studio 8\vc\include\malloc.hvoid *_Ptrunsigned int _Markerchar [(sizeof(unsigned int)<=8)]size_t *_Usedsize_t *_Commit_HEAPINFO *_EntryInfo (_heapinfo *)unsigned int _Fillsize_t *_Valuesize_t _Valuesize_t _NewValueunsigned long _NewValuestruct _heapinfo_alloca__pragma(warning(suppress: 6255)) _MarkAllocaS(malloc(() + _ALLOCA_S_MARKER_SIZE), _ALLOCA_S_HEAP_MARKER)0xDDDD0xCCCC60000_aligned_malloc(, )_aligned_free()(-6)(-5)(-4)(-3)(-2)0xFFFFFFE0const std::exception & (const std::exception &)const char *const & (const char *const &, int) (const char *const &)std::exception &const char *_Messageconst char *_Message = "bad exception"void (* )(const class std::exception &)::set_terminate::terminate_handler::terminate::set_unexpected::unexpected_handler::unexpected::strcpy_s((), (), ())using ::set_terminate; using ::terminate_handler; using ::terminate; using ::set_unexpected; using ::unexpected_handler; using ::unexpected;c:\archivos de programa\microsoft visual studio 8\vc\include\xstringc:\archivos de programa\microsoft visual studio 8\vc\include\xmemoryc:\archivos de programa\microsoft visual studio 8\vc\include\newconst std::nothrow_t & (void *, const std::nothrow_t &) (unsigned int, const std::nothrow_t &) (void *, void *)void *_Where (unsigned int, void *)std::new_handlerconst std::nothrow_tc:\archivos de programa\microsoft visual studio 8\vc\include\xutilityc:\archivos de programa\microsoft visual studio 8\vc\include\utilityconst _Ty &_Leftconst _Ty &_Right (const _Ty &, const _Ty &)std::pair<_Ty1,_Ty2> &_Leftstd::pair<_Ty1,_Ty2> &_Right (std::pair<_Ty1,_Ty2> &, std::pair<_Ty1,_Ty2> &)typename _Ty1typename _Ty2std::pair<_Ty1,_Ty2>_Ty1 _Val1_Ty2 _Val2 (_Ty1, _Ty2)const std::pair<_Ty1,_Ty2> &_Leftconst std::pair<_Ty1,_Ty2> &_Right (const std::pair<_Ty1,_Ty2> &, const std::pair<_Ty1,_Ty2> &)struct std::pair<_Ty1,_Ty2>_Ty1_Ty2const std::pair<_Other1,_Other2> &_Right (const std::pair<_Other1,_Other2> &)typename _Other1typename _Other2const _Ty1 &_Val1const _Ty2 &_Val2 (const _Ty1 &, const _Ty2 &)pair<_Ty1,_Ty2>::_Myt &_Right (std::pair<_Ty1,_Ty2> &)_Ty &_Left_Ty &_Right (_Ty &, _Ty &)uintptr_t (const wchar_t *, const wchar_t *, const wchar_t *, unsigned int, unsigned int)_InIt1 _First1_InIt1 _Last1_InIt2 _First2_Pr _Pred (_InIt1, _InIt1, _InIt2, _Pr)typename _InIt1typename _InIt2typename _Pr (_InIt1, _InIt1, _InIt2)std::pair<_InIt1,_InIt2>_OutIt _First_Diff _Countconst _Ty &_Val (_OutIt, _Diff, const _Ty &)typename _OutIttypename _Diff_BidIt2_BidIt1 _First_BidIt1 _Last_BidIt2 _Dest (_BidIt1, _BidIt1, _BidIt2)typename _BidIt1typename _BidIt2_OutIt_InIt _First_InIt _Last_OutIt _Dest (_InIt, _InIt, _OutIt)typename _InItconst _Ty & (const _Ty &, const _Ty &, _Pr)_InIt2 _Last2 (_InIt1, _InIt1, _InIt2, _InIt2, _Pr)const unsigned char *_First1const unsigned char *_Last1const unsigned char *_First2const unsigned char *_Last2 (const unsigned char *, const unsigned char *, const unsigned char *, const unsigned char *) (_InIt1, _InIt1, _InIt2, _InIt2)_OutCat _First_catstd::_Unchecked_iterator_tag (_OutIt, _Diff, const _Ty &, _OutCat, std::_Unchecked_iterator_tag)typename _OutCatstd::random_access_iterator_tagstd::_Range_checked_iterator_tag (_OutIt, _Diff, const _Ty &, std::random_access_iterator_tag, std::_Range_checked_iterator_tag)_OutCat (_OutIt, _Diff, const _Ty &, _OutCat, std::_Range_checked_iterator_tag)unsigned char *_First (unsigned char *, unsigned int, int, std::_Range_checked_iterator_tag)signed char *_First (signed char *, unsigned int, int, std::_Range_checked_iterator_tag)char *_First (char *, unsigned int, int, std::_Range_checked_iterator_tag) (_OutIt, _Diff, const _Ty &, std::_Range_checked_iterator_tag)_FwdIt _First_FwdIt _Last (_FwdIt, _FwdIt, const _Ty &)typename _FwdItunsigned char *_Last (unsigned char *, unsigned char *, int)signed char *_Last (signed char *, signed char *, int)char *_Last_InItCats _InIt_cats (_InIt1, _InIt1, _InIt2, _Pr, _InItCats, std::_Unchecked_iterator_tag)typename _InItCats (_InIt1, _InIt1, _InIt2, _Pr, std::random_access_iterator_tag, std::_Range_checked_iterator_tag)_InItCats (_InIt1, _InIt1, _InIt2, _Pr, _InItCats, std::_Range_checked_iterator_tag) (_InIt1, _InIt1, _InIt2, _InItCats, std::_Unchecked_iterator_tag) (_InIt1, _InIt1, _InIt2, std::random_access_iterator_tag, std::_Range_checked_iterator_tag) (const unsigned char *, const unsigned char *, const unsigned char *, std::random_access_iterator_tag, std::_Range_checked_iterator_tag)const signed char *_First1const signed char *_Last1const signed char *_First2 (const signed char *, const signed char *, const signed char *, std::random_access_iterator_tag, std::_Range_checked_iterator_tag)const char *_First1const char *_Last1const char *_First2 (const char *, const char *, const char *, std::random_access_iterator_tag, std::_Range_checked_iterator_tag) (_InIt1, _InIt1, _InIt2, _InItCats, std::_Range_checked_iterator_tag)_InOutItCat _First_dest_cat_MoveCatTy _Move_cat (_BidIt1, _BidIt1, _BidIt2, _InOutItCat, _MoveCatTy, std::_Unchecked_iterator_tag)typename _InOutItCattypename _MoveCatTystd::_Swap_move_tag _Move_cat (_BidIt1, _BidIt1, _BidIt2, std::random_access_iterator_tag, std::_Swap_move_tag, std::_Range_checked_iterator_tag)_InOutItCatstd::_Swap_move_tag (_BidIt1, _BidIt1, _BidIt2, _InOutItCat, std::_Swap_move_tag, std::_Range_checked_iterator_tag)_MoveCatTy (_BidIt1, _BidIt1, _BidIt2, _InOutItCat, _MoveCatTy, std::_Range_checked_iterator_tag)_Ty _PtrCat (_BidIt1, _BidIt1, _BidIt2, _InOutItCat, _Ty, std::_Unchecked_iterator_tag)std::_Scalar_ptr_iterator_tag (_InIt, _InIt, _OutIt, _InOutItCat, std::_Scalar_ptr_iterator_tag, std::_Range_checked_iterator_tag)std::_Nonscalar_ptr_iterator_tag (_InIt, _InIt, _OutIt, std::random_access_iterator_tag, std::_Nonscalar_ptr_iterator_tag, std::_Range_checked_iterator_tag) (_BidIt1, _BidIt1, _BidIt2, _InOutItCat, std::_Nonscalar_ptr_iterator_tag, std::_Range_checked_iterator_tag) (_InIt, _InIt, _OutIt, _InOutItCat, _MoveCatTy, std::_Unchecked_iterator_tag) (_InIt, _InIt, _OutIt, std::random_access_iterator_tag, std::_Swap_move_tag, std::_Range_checked_iterator_tag) (_InIt, _InIt, _OutIt, _InOutItCat, std::_Swap_move_tag, std::_Range_checked_iterator_tag) (_InIt, _InIt, _OutIt, _InOutItCat, _MoveCatTy, std::_Range_checked_iterator_tag) (_InIt, _InIt, _OutIt, _InOutItCat, _Ty, std::_Unchecked_iterator_tag) (_InIt, _InIt, _OutIt, _InOutItCat, std::_Nonscalar_ptr_iterator_tag, std::_Range_checked_iterator_tag)class std::ostreambuf_iterator<_Elem,_Traits>class std::basic_streambuf<_Elem,_Traits>class std::basic_ostream<_Elem,_Traits>struct std::_Range_checked_iterator_tagtypename ostreambuf_iterator<_Elem,_Traits>::ostream_type &_Ostr (std::basic_ostream<_Elem,_Traits> &)typename ostreambuf_iterator<_Elem,_Traits>::streambuf_type *_Sb (std::basic_streambuf<_Elem,_Traits> *)typename ostreambuf_iterator<_Elem,_Traits>::_Myt &_Elem _Right (_Elem)ostreambuf_iterator<_Elem,_Traits>::streambuf_type *const std::istreambuf_iterator<_Elem,_Traits> &_Leftconst std::istreambuf_iterator<_Elem,_Traits> &_Right (const std::istreambuf_iterator<_Elem,_Traits> &, const std::istreambuf_iterator<_Elem,_Traits> &)class std::istreambuf_iterator<_Elem,_Traits>class std::basic_istream<_Elem,_Traits>traits_type::int_typetypename istreambuf_iterator<_Elem,_Traits>::istream_type &_Istr (std::basic_istream<_Elem,_Traits> &)typename istreambuf_iterator<_Elem,_Traits>::streambuf_type *_Sb = 0typename istreambuf_iterator<_Elem,_Traits>::_Myttypename istreambuf_iterator<_Elem,_Traits>::_Myt &const istreambuf_iterator<_Elem,_Traits>::_Myt &_Right (const std::istreambuf_iterator<_Elem,_Traits> &)istreambuf_iterator<_Elem,_Traits>::streambuf_type *typename _BidIttypename _BidIt2 = _BidItclass std::_Revbidit<_BidIt,_BidIt2>typename std::iterator_traits<_BidIt>::difference_typetypename std::iterator_traits<_BidIt>::pointertypename std::iterator_traits<_BidIt>::reference_BidItconst std::_Revbidit<_BidIt2> &_Other (const std::_Revbidit<_BidIt2> &)_BidIt _Right (_BidIt)typename _Revbidit<_BidIt,_BidIt2>::_Referencetypename _Revbidit<_BidIt,_BidIt2>::_Pointertypename _Revbidit<_BidIt,_BidIt2>::_Myttypename _Revbidit<_BidIt,_BidIt2>::_Myt &const typename _Revbidit<_BidIt,_BidIt2>::_Myt &_Right (const std::_Revbidit<_BidIt,_BidIt2> &)typename _Reference = _Ty&typename _Pointer = _Ty*typename _Diff = ptrdiff_tclass std::reverse_bidirectional_iterator<_BidIt,_Ty,_Reference,_Pointer,_Diff>_Reference_Pointertypename reverse_bidirectional_iterator<_BidIt,_Ty,_Reference,_Pointer,_Diff>::_Myttypename reverse_bidirectional_iterator<_BidIt,_Ty,_Reference,_Pointer,_Diff>::_Myt &const typename reverse_bidirectional_iterator<_BidIt,_Ty,_Reference,_Pointer,_Diff>::_Myt &_Right (const std::reverse_bidirectional_iterator<_BidIt,_Ty,_Reference,_Pointer,_Diff> &)const std::reverse_iterator<_RanIt1> &_Leftconst std::reverse_iterator<_RanIt2> &_Right (const std::reverse_iterator<_RanIt1> &, const std::reverse_iterator<_RanIt2> &)typename _RanIt1typename _RanIt2typename std::reverse_iterator<_RanIt1>::difference_typestd::reverse_iterator<_RanIt>_Diff _Offconst std::reverse_iterator<_RanIt> &_Right (_Diff, const std::reverse_iterator<_RanIt> &)typename _RanItstruct std::_Unchecked_iterator_tagstruct std::_Unchanged_checked_iterator_base_type_tagstruct std::_Undefined_inner_type_tagconst std::_Iterator_base &_Right (const std::_Iterator_base &)std::_Iterator_base &const std::_Container_base *_Parent (const std::_Container_base *)const std::_Container_base *std::_Iterator_base *class std::reverse_iterator<_RanIt>typename std::iterator_traits<_RanIt>::iterator_categorytypename std::iterator_traits<_RanIt>::value_typetypename std::iterator_traits<_RanIt>::difference_typetypename std::iterator_traits<_RanIt>::pointertypename std::iterator_traits<_RanIt>::reference_RanItconst std::reverse_iterator<_Other> &_Right (const std::reverse_iterator<_Other> &)typename _Other_RanIt _Right (_RanIt)class std::reverse_iterator::_Checked_iterator_base_type>reverse_iterator<_RanIt>::_Checked_iterator_base_typereverse_iterator<_RanIt>::_Checked_iterator_base_type _Base (std::reverse_iterator::_Checked_iterator_base_type>)typename reverse_iterator<_RanIt>::referencetypename reverse_iterator<_RanIt>::pointertypename reverse_iterator<_RanIt>::_Myttypename reverse_iterator<_RanIt>::_Myt &typename reverse_iterator<_RanIt>::difference_type _Off (typename std::iterator_traits<_RanIt>::difference_type)reverse_iterator<_RanIt>::difference_type_Diff &_Off (_InIt, _InIt, _Diff &)typename std::iterator_traits<_InIt>::difference_type (_InIt, _InIt)_RanIt _First_RanIt _Last (_RanIt, _RanIt, _Diff &, std::random_access_iterator_tag)_BidIt _First_BidIt _Laststd::bidirectional_iterator_tag (_BidIt, _BidIt, _Diff &, std::bidirectional_iterator_tag)std::forward_iterator_tag (_FwdIt, _FwdIt, _Diff &, std::forward_iterator_tag)std::input_iterator_tag (_InIt, _InIt, _Diff &, std::input_iterator_tag)typename std::iterator_traits<_Iter>::difference_type *_Iter (_Iter)typename _Iter_RI &_Where (_RI &, _Diff, std::random_access_iterator_tag)typename _RI_BI &_Where (_BI &, _Diff, std::bidirectional_iterator_tag)typename _BI_FI &_Where (_FI &, _Diff, std::forward_iterator_tag)typename _FI_InIt &_Where (_InIt &, _Diff, std::input_iterator_tag) (_InIt &, _Diff)typename std::iterator_traits<_Iter>::value_type *bool _IsFirstIterationconst wchar_t *_Fileunsigned int _Line (_InIt, _InIt, _Pr, bool, const wchar_t *, unsigned int) (_FwdIt, _FwdIt, _Pr, bool, const wchar_t *, unsigned int, std::forward_iterator_tag) (_InIt, _InIt, _Pr, bool, const wchar_t *, unsigned int, std::input_iterator_tag) (_InIt, _InIt, bool, const wchar_t *, unsigned int) (_FwdIt, _FwdIt, bool, const wchar_t *, unsigned int, std::forward_iterator_tag) (_InIt, _InIt, bool, const wchar_t *, unsigned int, std::input_iterator_tag) (_InIt, _InIt, _Pr, const wchar_t *, unsigned int) (_FwdIt, _FwdIt, _Pr, const wchar_t *, unsigned int, std::forward_iterator_tag) (_InIt, _InIt, _Pr, const wchar_t *, unsigned int, std::input_iterator_tag) (_InIt, _InIt, const wchar_t *, unsigned int) (_FwdIt, _FwdIt, const wchar_t *, unsigned int, std::forward_iterator_tag) (_InIt, _InIt, const wchar_t *, unsigned int, std::input_iterator_tag) (_RanIt, _RanIt, const wchar_t *, unsigned int, std::random_access_iterator_tag)_InIt_Ty *_First (_Ty *, const wchar_t *, unsigned int)const _Ty *_First (const _Ty *, const wchar_t *, unsigned int)_InIt & (_InIt &, const wchar_t *, unsigned int)typename std::_Ptr_cat_helper<_T1,_T2>::_Ptr_cat_T1 &_T2 & (_T1 &, _T2 &)typename _T1typename _T2<_Ty*const*,const _Ty**>struct std::_Scalar_ptr_iterator_tag<_Ty*const*,_Ty**><_Ty**,const _Ty**><_Ty**,_Ty**><__int64*,__int64*><__wchar_t*,__wchar_t*><_Bool*,_Bool*><_Undefined_inner_type_tag,_Undefined_inner_type_tag>struct std::_Nonscalar_ptr_iterator_tag<_Undefined_inner_type_tag,_T2><_T1,_Undefined_inner_type_tag><_T1,_T2,_Range_checked_iterator_tag,_Range_checked_iterator_tag>typename std::_Ptr_cat_helper::_Ptr_cat<_T1,_T2,_Range_checked_iterator_tag,_Checked_Cat2>typename _Checked_Cat2typename std::_Ptr_cat_helper::_Ptr_cat<_T1,_T2,_Checked_Cat1,_Range_checked_iterator_tag>typename _Checked_Cat1typename std::_Ptr_cat_helper<_T1,typename _T2::_Inner_type>::_Ptr_cattypename std::_Ptr_cat_with_checked_cat_helper<_T1,_T2,typename _Checked_iterator_category<_T1>::_Checked_cat,typename _Checked_iterator_category<_T2>::_Checked_cat>::_Ptr_cattypename std::_Move_operation_category::value_type>::_Move_catconst _Iter & (const _Iter &)typename _Valuestruct std::_Undefined_move_tag_Iter &_Destconst _Iter &_Src (_Iter &, const _Iter &)_DstIter &_Destconst _BaseIter &_Src (_DstIter &, const _BaseIter &)typename _DstItertypename _BaseItertypename std::_Checked_iterator_base_helper<_Iter>::_Checked_iterator_base_type_Iter &_It (_Iter &)const _Iter &_Itstd::_Unchanged_checked_iterator_base_type_tag (_Iter &, std::_Unchanged_checked_iterator_base_type_tag)_Base_tag (_Iter &, _Base_tag)typename _Base_tag (const _Iter &, std::_Unchanged_checked_iterator_base_type_tag) (const _Iter &, _Base_tag)class std::_Checked_iterator_base_helper2<_Iter,__is_base_of(_Iterator_base,_Iter)>class std::_Checked_iterator_base_helper1<_Iter,typename _Base_helper2::_Checked_iterator_base_type>typename std::_Checked_iterator_base_helper1<_Iter,typename _Base_helper2::_Checked_iterator_base_type>::_Base_type_tagtypename std::_Checked_iterator_base_helper1<_Iter,typename _Base_helper2::_Checked_iterator_base_type>::_Checked_iterator_base_type<_Iter,_Unchanged_checked_iterator_base_type_tag>typename _Base_typestruct std::_Different_checked_iterator_base_type_tag_Base_type<_Iter,true>typename _Iter::_Checked_iterator_base_typebool _Inherits_from_iterator_basetypename std::_Checked_iterator_category<_Iter>::_Checked_cattypename std::_Checked_iterator_category_helper<_Iter,__is_base_of(_Iterator_base,_Iter)>::_Checked_cattypename _Iter::_Checked_iterator_categorybool _Secure_validationbool _Condtypename std::_Iter_random_helper3::iterator_category,typename iterator_traits<_Iter2>::iterator_category,typename iterator_traits<_Iter3>::iterator_category>::_Iter_random_catconst _Iter1 &const _Iter2 &const _Iter3 & (const _Iter1 &, const _Iter2 &, const _Iter3 &)typename _Iter1typename _Iter2typename _Iter3typename std::_Iter_random_helper::iterator_category,typename iterator_traits<_Iter2>::iterator_category>::_Iter_random_cat (const _Iter1 &, const _Iter2 &)struct std::random_access_iterator_tagtypename _Cat1typename _Cat2typename _Cat3struct std::forward_iterator_tagtypename std::iterator_traits<_Iter>::iterator_categorystruct std::_Int_iterator_tagunsigned __int64 *unsigned __int64 &<__int64>__int64 *__int64 &struct std::_Float_iterator_tagfloat *float &double *double &unsigned long &long &unsigned int *unsigned int &int &unsigned short &short *short &wchar_t &unsigned charunsigned char &signed charsigned char *signed char &char &<_Bool>std::_Boolstd::_Bool *std::_Bool &ptrdiff_tconst _Ty *<_Ty*>_Ty *_Ty &typename _Iter::iterator_categorytypename _Iter::value_typetypename _Iter::difference_typetypename iterator_traits<_Iter>::difference_typetypename _Iter::pointertypename _Iter::referencetypename _Base_classtypename _Pointertypename _Reference_Diffstruct std::bidirectional_iterator_tagtypename _Categorytypename _Base_class = _Iterator_base_Category_Ty1 &_Left_Ty2 &_Rightconst wchar_t *_Where (_Pr, _Ty1 &, _Ty2 &, const wchar_t *, unsigned int)const _Ty2 &_Right (_Pr, _Ty1 &, const _Ty2 &, const wchar_t *, unsigned int)const _Ty1 &_Left (_Pr, const _Ty1 &, _Ty2 &, const wchar_t *, unsigned int) (_Pr, const _Ty1 &, const _Ty2 &, const wchar_t *, unsigned int) (_Ty1 &, _Ty2 &, const wchar_t *, unsigned int) (_Ty1 &, const _Ty2 &, const wchar_t *, unsigned int) (const _Ty1 &, _Ty2 &, const wchar_t *, unsigned int) (const _Ty1 &, const _Ty2 &, const wchar_t *, unsigned int)const std::_Iterator_base &_Whereconst std::_Container_base & (const std::_Container_base &)std::_Container_base & (std::_Container_base &)class std::_Iterator_baseunsigned int line(min)(max)max_STD _Checked_assign_from_base(, )_Desttypename _STD _Checked_iterator_base_helper<>::_Checked_iterator_base_type_Iter_type_STD _Checked_base()_STD _Checked_cat()_Debug_range(, , , )firstlastfilewline_Debug_range(, , __FILEW__, __LINE__)_Debug_pointer(, , )_Debug_pointer(, __FILEW__,__LINE__)_DEBUG_ORDER_SINGLE_IMPL(, , , , __FILEW__, __LINE__)predis_first_iteration_DEBUG_ORDER_SINGLE_IMPL(, , , __FILEW__, __LINE__)_DEBUG_ORDER_IMPL(, , , __FILEW__, __LINE__)_DEBUG_ORDER_IMPL(, , __FILEW__, __LINE__)_Debug_order_single_Debug_order_Undefined_move_tag_Debug_lt_pred(, , , __FILEW__, __LINE__)_Debug_lt(, , __FILEW__, __LINE__)_Debug_message(L, , )mesglinew_DEBUG_ERROR2(, __FILEW__, __LINE__)_VAL()((_Iterator_base *)-3)((const _Container_base *)-2)_Ty *_Last_Alloc &_Al (_Ty *, _Ty *, _Alloc &, std::_Scalar_ptr_iterator_tag)typename _Alloc (_Ty *, _Ty *, _Alloc &, std::_Nonscalar_ptr_iterator_tag) (_Ty *, _Ty *, _Alloc &)std::allocator::_Ty *const std::allocator::_Ty *std::allocator::_Tyclass std::allocator<_Other>const std::allocator<_Other> & (const std::allocator<_Other> &)const std::allocator<_Ty> & (const std::allocator<_Ty> &)std::allocator<_Ty> & (const std::allocator<_Ty> &, const std::allocator<_Other> &)struct std::_Allocator_base<_Ty>typename std::_Allocator_base<_Ty>::value_typetypename allocator<_Ty>::value_type *typename allocator<_Ty>::value_type &const typename allocator<_Ty>::value_type *const typename allocator<_Ty>::value_type &allocator<_Ty>::const_pointerallocator<_Ty>::const_reference _Val (const typename std::_Allocator_base<_Ty>::value_type)allocator<_Ty>::pointerallocator<_Ty>::reference _Val (typename std::_Allocator_base<_Ty>::value_type)allocator<_Ty>::pointer _Ptrallocator<_Ty>::size_type (typename std::_Allocator_base<_Ty>::value_type, unsigned int)allocator<_Ty>::size_type _Count (unsigned int, const void *) (typename std::_Allocator_base<_Ty>::value_type, const _Ty &)_Ty *_Ptr (_Ty *)_T1 *_Ptrconst _T2 &_Val (_T1 *, const _T2 &) (unsigned int, _Ty *)typename ::template rebind<>::other::referenceTAtypename ::template rebind<>::other::pointertypename ::template rebind<>::other::const_referencetypename ::template rebind<>::other::const_pointerclass std::basic_string<__wchar_t,char_traits<__wchar_t>,allocator<__wchar_t> >class std::basic_string,allocator >std::basic_string<_Elem,_Traits,_Alloc> &_Leftstd::basic_string<_Elem,_Traits,_Alloc> &_Right (std::basic_string<_Elem,_Traits,_Alloc> &, std::basic_string<_Elem,_Traits,_Alloc> &)const typename std::basic_string<_Elem,_Traits,_Alloc>::size_type >typename _Axstruct std::_Swap_move_tagtypename _Ax = allocator<_Elem>class std::basic_string<_Elem,_Traits,_Ax>class std::_String_val<_Elem,_Ax>typename std::_String_val<_Elem,_Ax>::_Altytypename std::_String_val<_Elem,_Ax>::_Alty::size_typetypename std::_String_val<_Elem,_Ax>::_Alty::difference_typetypename basic_string<_Elem,_Traits,_Ax>::_Difttypename std::_String_val<_Elem,_Ax>::_Alty::pointertypename std::_String_val<_Elem,_Ax>::_Alty::const_pointertypename basic_string<_Elem,_Traits,_Ax>::_Tptrtypename basic_string<_Elem,_Traits,_Ax>::_Ctptrtypename std::_String_val<_Elem,_Ax>::_Alty::referencetypename basic_string<_Elem,_Traits,_Ax>::_Refttypename std::_String_val<_Elem,_Ax>::_Alty::const_referencetypename std::_String_val<_Elem,_Ax>::_Alty::value_typeclass std::_String_iterator<_Elem,_Traits,_Alloc>class std::_String_const_iterator<_Elem,_Traits,_Alloc>class std::reverse_iteratorclass std::reverse_iteratortypename basic_string<_Elem,_Traits,_Ax>::const_iterator _Firsttypename basic_string<_Elem,_Traits,_Ax>::const_iterator _Last (std::_String_const_iterator<_Elem,_Traits,_Alloc>, std::_String_const_iterator<_Elem,_Traits,_Alloc>)typename basic_string<_Elem,_Traits,_Ax>::const_pointer _Firsttypename basic_string<_Elem,_Traits,_Ax>::const_pointer _Last (typename std::_String_val<_Elem,_Ax>::_Alty::const_pointer, typename std::_String_val<_Elem,_Ax>::_Alty::const_pointer)_It _First_It _Lastconst typename basic_string<_Elem,_Traits,_Ax>::_Alloc &_Al (_It, _It, const typename std::_String_val<_Elem,_Ax>::_Alty &)typename _It (_It, _It)typename basic_string<_Elem,_Traits,_Ax>::size_type _Count (typename std::_String_val<_Elem,_Ax>::_Alty::size_type, _Elem, const typename std::_String_val<_Elem,_Ax>::_Alty &) (typename std::_String_val<_Elem,_Ax>::_Alty::size_type, _Elem)const _Elem *_Ptr (const _Elem *, const typename std::_String_val<_Elem,_Ax>::_Alty &) (const _Elem *, typename std::_String_val<_Elem,_Ax>::_Alty::size_type, const typename std::_String_val<_Elem,_Ax>::_Alty &) (const _Elem *, typename std::_String_val<_Elem,_Ax>::_Alty::size_type)const typename basic_string<_Elem,_Traits,_Ax>::_Myt &_Righttypename basic_string<_Elem,_Traits,_Ax>::size_type _Roff (const std::basic_string<_Elem,_Traits,_Ax> &, typename std::_String_val<_Elem,_Ax>::_Alty::size_type, typename std::_String_val<_Elem,_Ax>::_Alty::size_type, const typename std::_String_val<_Elem,_Ax>::_Alty &)typename basic_string<_Elem,_Traits,_Ax>::size_type _Count = npos (const std::basic_string<_Elem,_Traits,_Ax> &, typename std::_String_val<_Elem,_Ax>::_Alty::size_type, typename std::_String_val<_Elem,_Ax>::_Alty::size_type) (const std::basic_string<_Elem,_Traits,_Ax> &) (const typename std::_String_val<_Elem,_Ax>::_Alty &) (_It, _It, std::forward_iterator_tag) (_It, _It, std::input_iterator_tag)_It _Count_It _Chstd::_Int_iterator_tag (_It, _It, std::_Int_iterator_tag)typename basic_string<_Elem,_Traits,_Ax>::_Allocconst basic_string<_Elem,_Traits,_Ax>::size_typetypename basic_string<_Elem,_Traits,_Ax>::_Myt &basic_string<_Elem,_Traits,_Ax>::_Myt &basic_string<_Elem,_Traits,_Ax>::const_iterator _Firstbasic_string<_Elem,_Traits,_Ax>::const_iterator _Lastbasic_string<_Elem,_Traits,_Ax>::const_pointer _Firstbasic_string<_Elem,_Traits,_Ax>::const_pointer _Lastbasic_string<_Elem,_Traits,_Ax>::size_type _Countconst basic_string<_Elem,_Traits,_Ax>::_Myt &_Rightbasic_string<_Elem,_Traits,_Ax>::size_type _Roffbasic_string<_Elem,_Traits,_Ax>::size_type _Numbasic_string<_Elem,_Traits,_Ax>::iterator _Where (std::_String_iterator<_Elem,_Traits,_Alloc>, std::_String_const_iterator<_Elem,_Traits,_Alloc>, std::_String_const_iterator<_Elem,_Traits,_Alloc>) (std::_String_iterator<_Elem,_Traits,_Alloc>, typename std::_String_val<_Elem,_Ax>::_Alty::const_pointer, typename std::_String_val<_Elem,_Ax>::_Alty::const_pointer) (std::_String_iterator<_Elem,_Traits,_Alloc>, _It, _It) (std::_String_iterator<_Elem,_Traits,_Alloc>, typename std::_String_val<_Elem,_Ax>::_Alty::size_type, _Elem)basic_string<_Elem,_Traits,_Ax>::iterator (std::_String_iterator<_Elem,_Traits,_Alloc>, _Elem) (std::_String_iterator<_Elem,_Traits,_Alloc>)basic_string<_Elem,_Traits,_Ax>::size_type _Off (typename std::_String_val<_Elem,_Ax>::_Alty::size_type, typename std::_String_val<_Elem,_Ax>::_Alty::size_type, _Elem) (typename std::_String_val<_Elem,_Ax>::_Alty::size_type, const _Elem *) (typename std::_String_val<_Elem,_Ax>::_Alty::size_type, const _Elem *, typename std::_String_val<_Elem,_Ax>::_Alty::size_type) (typename std::_String_val<_Elem,_Ax>::_Alty::size_type, const std::basic_string<_Elem,_Traits,_Ax> &, typename std::_String_val<_Elem,_Ax>::_Alty::size_type, typename std::_String_val<_Elem,_Ax>::_Alty::size_type) (typename std::_String_val<_Elem,_Ax>::_Alty::size_type, const std::basic_string<_Elem,_Traits,_Ax> &) (std::_String_iterator<_Elem,_Traits,_Alloc>, _It, _It, std::input_iterator_tag) (std::_String_iterator<_Elem,_Traits,_Alloc>, _It, _It, std::_Int_iterator_tag)basic_string<_Elem,_Traits,_Ax>::iterator _Firstbasic_string<_Elem,_Traits,_Ax>::iterator _Last (std::_String_iterator<_Elem,_Traits,_Alloc>, std::_String_iterator<_Elem,_Traits,_Alloc>)basic_string<_Elem,_Traits,_Ax>::size_type _Off = 0basic_string<_Elem,_Traits,_Ax>::size_type _Count = npos (typename std::_String_val<_Elem,_Ax>::_Alty::size_type, typename std::_String_val<_Elem,_Ax>::_Alty::size_type)basic_string<_Elem,_Traits,_Ax>::const_iterator _First2basic_string<_Elem,_Traits,_Ax>::const_iterator _Last2 (std::_String_iterator<_Elem,_Traits,_Alloc>, std::_String_iterator<_Elem,_Traits,_Alloc>, std::_String_const_iterator<_Elem,_Traits,_Alloc>, std::_String_const_iterator<_Elem,_Traits,_Alloc>)basic_string<_Elem,_Traits,_Ax>::const_pointer _First2basic_string<_Elem,_Traits,_Ax>::const_pointer _Last2 (std::_String_iterator<_Elem,_Traits,_Alloc>, std::_String_iterator<_Elem,_Traits,_Alloc>, typename std::_String_val<_Elem,_Ax>::_Alty::const_pointer, typename std::_String_val<_Elem,_Ax>::_Alty::const_pointer)_It _First2_It _Last2 (std::_String_iterator<_Elem,_Traits,_Alloc>, std::_String_iterator<_Elem,_Traits,_Alloc>, _It, _It) (std::_String_iterator<_Elem,_Traits,_Alloc>, std::_String_iterator<_Elem,_Traits,_Alloc>, typename std::_String_val<_Elem,_Ax>::_Alty::size_type, _Elem) (std::_String_iterator<_Elem,_Traits,_Alloc>, std::_String_iterator<_Elem,_Traits,_Alloc>, const _Elem *) (std::_String_iterator<_Elem,_Traits,_Alloc>, std::_String_iterator<_Elem,_Traits,_Alloc>, const _Elem *, typename std::_String_val<_Elem,_Ax>::_Alty::size_type) (std::_String_iterator<_Elem,_Traits,_Alloc>, std::_String_iterator<_Elem,_Traits,_Alloc>, const std::basic_string<_Elem,_Traits,_Ax> &)basic_string<_Elem,_Traits,_Ax>::size_type _N0 (typename std::_String_val<_Elem,_Ax>::_Alty::size_type, typename std::_String_val<_Elem,_Ax>::_Alty::size_type, typename std::_String_val<_Elem,_Ax>::_Alty::size_type, _Elem) (typename std::_String_val<_Elem,_Ax>::_Alty::size_type, typename std::_String_val<_Elem,_Ax>::_Alty::size_type, const _Elem *) (typename std::_String_val<_Elem,_Ax>::_Alty::size_type, typename std::_String_val<_Elem,_Ax>::_Alty::size_type, const _Elem *, typename std::_String_val<_Elem,_Ax>::_Alty::size_type) (typename std::_String_val<_Elem,_Ax>::_Alty::size_type, typename std::_String_val<_Elem,_Ax>::_Alty::size_type, const std::basic_string<_Elem,_Traits,_Ax> &, typename std::_String_val<_Elem,_Ax>::_Alty::size_type, typename std::_String_val<_Elem,_Ax>::_Alty::size_type) (typename std::_String_val<_Elem,_Ax>::_Alty::size_type, typename std::_String_val<_Elem,_Ax>::_Alty::size_type, const std::basic_string<_Elem,_Traits,_Ax> &) (std::_String_iterator<_Elem,_Traits,_Alloc>, std::_String_iterator<_Elem,_Traits,_Alloc>, _It, _It, std::input_iterator_tag) (std::_String_iterator<_Elem,_Traits,_Alloc>, std::_String_iterator<_Elem,_Traits,_Alloc>, _It, _It, std::_Int_iterator_tag)basic_string<_Elem,_Traits,_Ax>::const_iteratorbasic_string<_Elem,_Traits,_Ax>::const_reverse_iteratorbasic_string<_Elem,_Traits,_Ax>::reverse_iteratorbasic_string<_Elem,_Traits,_Ax>::const_reference (typename std::_String_val<_Elem,_Ax>::_Alty::size_type)basic_string<_Elem,_Traits,_Ax>::referencetypename basic_string<_Elem,_Traits,_Ax>::const_referencetypename basic_string<_Elem,_Traits,_Ax>::size_type _Offtypename basic_string<_Elem,_Traits,_Ax>::referencebasic_string<_Elem,_Traits,_Ax>::size_typebasic_string<_Elem,_Traits,_Ax>::size_type _Newsizebasic_string<_Elem,_Traits,_Ax>::size_type _Newcap = 0_Elem *_Dest (_Elem *, typename std::_String_val<_Elem,_Ax>::_Alty::size_type, typename std::_String_val<_Elem,_Ax>::_Alty::size_type)basic_string<_Elem,_Traits,_Ax>::size_type _Dest_size (_Elem *, typename std::_String_val<_Elem,_Ax>::_Alty::size_type, typename std::_String_val<_Elem,_Ax>::_Alty::size_type, typename std::_String_val<_Elem,_Ax>::_Alty::size_type)basic_string<_Elem,_Traits,_Ax>::_Myt &_Right (std::basic_string<_Elem,_Traits,_Ax> &) (_Elem, typename std::_String_val<_Elem,_Ax>::_Alty::size_type) (const _Elem *, typename std::_String_val<_Elem,_Ax>::_Alty::size_type, typename std::_String_val<_Elem,_Ax>::_Alty::size_type) (const std::basic_string<_Elem,_Traits,_Ax> &, typename std::_String_val<_Elem,_Ax>::_Alty::size_type)basic_string<_Elem,_Traits,_Ax>::size_type _Off = nposbasic_string<_Elem,_Traits,_Ax>::_Mytbasic_string<_Elem,_Traits,_Ax>::allocator_typebasic_string<_Elem,_Traits,_Ax>::size_type _Oldlenbool _Trim = false (typename std::_String_val<_Elem,_Ax>::_Alty::size_type, bool)basic_string<_Elem,_Traits,_Ax>::const_iterator _P2basic_string<_Elem,_Traits,_Ax>::const_iterator _P1bool _Built = falsebasic_string<_Elem,_Traits,_Ax>::size_type _Newsize = 0 (bool, typename std::_String_val<_Elem,_Ax>::_Alty::size_type)_Elem [_BUF_SIZE]basic_string<_Elem,_Traits,_Ax>::_Bxtytypename _Alloc::template rebind<_Ty>::othertypename _String_val<_Ty,_Alloc>::_Alty _Al = _Alty() (typename _Alloc::template rebind<_Ty>::other)_String_val<_Ty,_Alloc>::_Altystd::_String_iterator<_Elem,_Traits,_Alloc>typename std::_String_iterator<_Elem,_Traits,_Alloc>::difference_type _Offstd::_String_iterator<_Elem,_Traits,_Alloc> _Next (typename std::_String_iterator<_Elem,_Traits,_Alloc>::difference_type, std::_String_iterator<_Elem,_Traits,_Alloc>)typename _Alloc::difference_typetypename _Alloc::pointertypename _Alloc::referencetypename _String_iterator<_Elem,_Traits,_Alloc>::pointer _Ptrconst std::_Container_base *_Pstring (typename _Alloc::pointer, const std::_Container_base *)typename _String_iterator<_Elem,_Traits,_Alloc>::referencetypename _String_iterator<_Elem,_Traits,_Alloc>::pointertypename _String_iterator<_Elem,_Traits,_Alloc>::_Myttypename _String_iterator<_Elem,_Traits,_Alloc>::_Myt &typename _String_iterator<_Elem,_Traits,_Alloc>::difference_type _Off (typename _Alloc::difference_type)typename _String_iterator<_Elem,_Traits,_Alloc>::difference_typeconst typename _String_iterator<_Elem,_Traits,_Alloc>::_Mybase &_Right (const std::_String_const_iterator<_Elem,_Traits,_Alloc> &)std::_String_const_iterator<_Elem,_Traits,_Alloc>typename std::_String_const_iterator<_Elem,_Traits,_Alloc>::difference_type _Offstd::_String_const_iterator<_Elem,_Traits,_Alloc> _Next (typename std::_String_const_iterator<_Elem,_Traits,_Alloc>::difference_type, std::_String_const_iterator<_Elem,_Traits,_Alloc>)class std::basic_string<_Elem,_Traits,_Alloc>typename _Alloc::const_pointertypename _Alloc::const_referencetypename _String_const_iterator<_Elem,_Traits,_Alloc>::pointer _Ptr (typename _Alloc::const_pointer, const std::_Container_base *)typename _String_const_iterator<_Elem,_Traits,_Alloc>::referencetypename _String_const_iterator<_Elem,_Traits,_Alloc>::pointertypename _String_const_iterator<_Elem,_Traits,_Alloc>::_Myttypename _String_const_iterator<_Elem,_Traits,_Alloc>::_Myt &typename _String_const_iterator<_Elem,_Traits,_Alloc>::difference_type _Offtypename _String_const_iterator<_Elem,_Traits,_Alloc>::difference_typeconst typename _String_const_iterator<_Elem,_Traits,_Alloc>::_Myt &_Rightconst _String_const_iterator<_Elem,_Traits,_Alloc>::_Myt &_Right_String_const_iterator<_Elem,_Traits,_Alloc>::pointer()._Myptrititerator(, this)const_iterator(, this)_No_debug_placeholder = _No_debug_placeholder()const std::string &_Message (const std::basic_string,allocator > &)std::stringc:\archivos de programa\microsoft visual studio 8\vc\include\typeinfoconst std::bad_typeid & (const std::bad_typeid &)const char *_Message = "bad typeid"const std::__non_rtti_object & (const std::__non_rtti_object &)const std::bad_cast & (const std::bad_cast &)const char *_Message = "bad cast"const type_info &rhs (const type_info &)__type_info_node *__ptype_info_node = &__type_info_root_node (__type_info_node *)char [1]type_info &const type_info *__type_info_node *__ptype_info_node (const type_info *, __type_info_node *)type_info * (type_info *)__type_info_node__type_info_node *::type_infoc:\archivos de programa\microsoft visual studio 8\vc\include\xdebugclass std::_DebugHeapStringclass std::basic_string,_DebugHeapAllocator >const std::string &_Strconst std::_DebugHeapString::_Elem *_Ptrconst std::_DebugHeapString::_Myt &_Right (const std::_DebugHeapString &)class std::_DebugHeapAllocator<_Other>typename std::allocator<_Ty>::pointertypename std::allocator<_Ty>::size_type _Count (typename std::allocator<_Ty>::size_type) (typename std::allocator<_Ty>::size_type, const void *)typename std::allocator<_Ty>::pointer _Ptrtypename std::allocator<_Ty>::size_type (typename std::allocator<_Ty>::pointer, typename std::allocator<_Ty>::size_type)const std::_DebugHeapTag_t & (void *, const std::_DebugHeapTag_t &, char *, int) (unsigned int, const std::_DebugHeapTag_t &, char *, int)_DebugHeapStringstd::_DebugHeapDelete((void *))std::_DebugHeapDelete()new(std::_DebugHeapTag_func(), __FILE__, __LINE__)c:\archivos de programa\microsoft visual studio 8\vc\include\xlocinfoc:\archivos de programa\microsoft visual studio 8\vc\include\xlocinfo.hc:\archivos de programa\microsoft visual studio 8\vc\include\locale.hconst char *_Locale0x2000x100LC_TIMELC_ALLsize_t _Maxsizeconst tm * (char *, unsigned int, const char *, const tm *, void *)const _Ctypevec * (wchar_t, const _Ctypevec *) (const wchar_t *, const wchar_t *, short *, const _Ctypevec *)wchar_t *_String1wchar_t *_End1const _Collvec * (wchar_t *, wchar_t *, const wchar_t *, const wchar_t *, const _Collvec *) (const wchar_t *, const wchar_t *, const wchar_t *, const wchar_t *, const _Collvec *)mbstate_t *const _Cvtvec * (char *, wchar_t, int *, const _Cvtvec *) (int, const _Ctypevec *)char *_String1char *_End1 (char *, char *, const char *, const char *, const _Collvec *) (const char *, const char *, const char *, const char *, const _Collvec *) (const char *, char **, long) (wchar_t *, const char *, unsigned int, int *, const _Cvtvec *)_Cvtvec_Ctypevec_Collvecconst short *(_CATMASK(_NCAT) - 1)_CATMASK(_X_MESSAGES)_CATMASK(_X_TIME)_CATMASK(_X_NUMERIC)_CATMASK(_X_MONETARY)_CATMASK(_X_CTYPE)_CATMASK(_X_COLLATE)((1 << ()) >> 1)7LC_MAXLC_NUMERICLC_MONETARYLC_CTYPELC_COLLATE_HEX_UPPER_BLANK_PUNCT_LOWER_DIGIT_SPACE_CONTROL0x000wchar_t *_First1wchar_t *_Last1const wchar_t *_First2const wchar_t *_Last2const std::_Locinfo::_Collvec *_Vectorchar *_First1char *_Last1const char *_Last2_Elem *_Last1const _Elem *_Last2const std::_Locinfo::_Collvec * (_Elem *, _Elem *, const _Elem *, const _Elem *, const _Collvec *)const wchar_t *_First1const wchar_t *_Last1const _Elem *_Last1 (const _Elem *, const _Elem *, const _Elem *, const _Elem *, const _Collvec *)struct _Collvecstruct _Ctypevecstruct _Cvtvecclass std::_Timevecstd::_Locinfo * (std::_Locinfo *, int, const char *) (std::_Locinfo *, const char *) (std::_Locinfo *)std::_Locinfo &int _Iconst char *_Pchconst char *_Pch = "C"std::_Locinfo::_Collvecstd::_Locinfo::_Ctypevecstd::_Locinfo::_Cvtvecconst lconv *std::_Locinfo::_Timevecstd::_Lockitconst std::_Timevec &_Right (const std::_Timevec &)void *_Ptr = 0std::_Timevec &const char *_Locnamesize_t _Refs = 0const std::locale::id & (const std::locale::id &)size_t _Val = 0std::locale::id &const std::locale::facet ** = 0 (const std::locale::facet **)std::locale::facet *const std::_DebugHeapTag_t &_Tagchar *_Fileint _Lineconst std::locale::facet & (const std::locale::facet &)size_t _Initrefs = 0 (std::locale::facet *)std::locale::facet &std::locale::_Locimp * (std::locale::_Locimp *)const std::locale::_Locimp & (std::locale::_Locimp *, const std::locale::_Locimp &) (std::locale::_Locimp *, std::locale::facet *, unsigned int)const std::locale::_Locimp &_Right (const std::locale::_Locimp &)bool _Transparent = false (bool)std::locale::facet *_Pfacetsize_t _Id (std::locale::facet *, unsigned int)const std::_Locinfo &std::locale::categoryconst std::locale * (const std::_Locinfo &, int, std::locale::_Locimp *, const std::locale *)std::locale::facet **std::_DebugHeapStringstd::locale::_Locimp *&std::locale::_Locimp &std::locale &std::locale::facet *_Facsize_t _Catmask (std::locale::facet *, unsigned int, unsigned int)const std::basic_string<_Elem,_Traits,_Alloc> &_Leftconst std::basic_string<_Elem,_Traits,_Alloc> &_Right (const std::basic_string<_Elem,_Traits,_Alloc> &, const std::basic_string<_Elem,_Traits,_Alloc> &)std::localeconst std::locale &_Loc (const std::locale &)typename _Facetstd::locale::_Locimp *_Ptrimpstd::locale::category _Cat (const std::locale &, const char *, int)std::locale::category _Cat = allconst std::locale &_Other (const std::locale &, const std::locale &, int)const std::locale &_Rightstd::_Uninitialized (std::_Uninitialized)const _Facet *_Facptr (const std::locale &, const _Facet *)const std::locale::facet *const std::locale &72471279259263class std::ctypestd::ctype::_Elemconst std::ctype::_Elem *const std::ctype::_Elem *_Firstconst std::ctype::_Elem *_Laststd::ctype_base::mask *_Dest (const unsigned short *, const unsigned short *, short *)std::ctype_base::mask _Maskvalstd::ctype::_Elem _Ch (short, unsigned short) (short, const unsigned short *, const unsigned short *)std::ctype::_Elem *_First (unsigned short *, const unsigned short *)const char *_Firstconst char *_Laststd::ctype::_Elem *_Dest (const char *, const char *, unsigned short *)char _Byte (char) (const char *, const char *, unsigned short *, unsigned int)char _Dflt (const unsigned short *, const unsigned short *, char, char *)char _Dflt = 0 (unsigned short, char) (const unsigned short *, const unsigned short *, char, char *, unsigned int)std::locale::idconst std::_Locinfo &_Lobj (const std::_Locinfo &, unsigned int)const std::locale::facet **_Ppf = 0 (const std::_Locinfo &)class std::ctype<__wchar_t>std::ctype<__wchar_t>::_Elemconst std::ctype<__wchar_t>::_Elem *const std::ctype<__wchar_t>::_Elem *_Firstconst std::ctype<__wchar_t>::_Elem *_Last (const wchar_t *, const wchar_t *, short *)std::ctype<__wchar_t>::_Elem _Ch (short, wchar_t) (short, const wchar_t *, const wchar_t *)std::ctype<__wchar_t>::_Elem *_Firststd::ctype<__wchar_t>::_Elem *_Dest (const char *, const char *, wchar_t *) (const char *, const char *, wchar_t *, unsigned int) (const wchar_t *, const wchar_t *, char, char *) (wchar_t, char) (const wchar_t *, const wchar_t *, char, char *, unsigned int)class std::ctypestd::ctype::_Elemconst std::ctype::_Elem *const std::ctype::_Elem *_Firstconst std::ctype::_Elem *_Last (const char *, const char *, short *)std::ctype::_Elem _Ch (short, char) (short, const char *, const char *)std::ctype::_Elem *_Firststd::ctype::_Elem *_Dest (const char *, const char *, char, char *) (char, char) (const char *, const char *, char, char *, unsigned int)const std::ctype_base::mask *_Table = 0bool _Deletetable = false (const short *, bool, unsigned int)const size_tconst std::ctype_base::mask *const _Elem *_Last (const _Elem *, const _Elem *, short *) (short, _Elem) (short, const _Elem *, const _Elem *) (_Elem *, const _Elem *) (const char *, const char *, _Elem *) (const char *, const char *, _Elem *, unsigned int) (const _Elem *, const _Elem *, char, char *) (_Elem, char) (const _Elem *, const _Elem *, char, char *, unsigned int)typename _Bytetypename _Statypestd::codecvt::_Elemstd::codecvt::_Bytestd::codecvt::_Statypestd::codecvt_base::resultstd::codecvt::_Statype &_Stateconst std::codecvt::_Byte *_First1const std::codecvt::_Byte *_Last1const std::codecvt::_Byte *&_Mid1std::codecvt::_Elem *_First2std::codecvt::_Elem *_Last2std::codecvt::_Elem *&_Mid2 (int &, const char *, const char *, const char *&, unsigned short *, unsigned short *, unsigned short *&)const std::codecvt::_Elem *_First1const std::codecvt::_Elem *_Last1const std::codecvt::_Elem *&_Mid1std::codecvt::_Byte *_First2std::codecvt::_Byte *_Last2std::codecvt::_Byte *&_Mid2 (int &, const unsigned short *, const unsigned short *, const unsigned short *&, char *, char *, char *&) (int &, char *, char *, char *&)const std::codecvt::_Statype &_State (const int &, const char *, const char *, unsigned int)<__wchar_t,char,_Mbstatet>std::codecvt<__wchar_t,char,_Mbstatet>::_Elemstd::codecvt<__wchar_t,char,_Mbstatet>::_Bytestd::codecvt<__wchar_t,char,_Mbstatet>::_Statypestd::codecvt<__wchar_t,char,_Mbstatet>::_Statype &_Stateconst std::codecvt<__wchar_t,char,_Mbstatet>::_Byte *_First1const std::codecvt<__wchar_t,char,_Mbstatet>::_Byte *_Last1const std::codecvt<__wchar_t,char,_Mbstatet>::_Byte *&_Mid1std::codecvt<__wchar_t,char,_Mbstatet>::_Elem *_First2std::codecvt<__wchar_t,char,_Mbstatet>::_Elem *_Last2std::codecvt<__wchar_t,char,_Mbstatet>::_Elem *&_Mid2 (int &, const char *, const char *, const char *&, wchar_t *, wchar_t *, wchar_t *&)const std::codecvt<__wchar_t,char,_Mbstatet>::_Elem *_First1const std::codecvt<__wchar_t,char,_Mbstatet>::_Elem *_Last1const std::codecvt<__wchar_t,char,_Mbstatet>::_Elem *&_Mid1std::codecvt<__wchar_t,char,_Mbstatet>::_Byte *_First2std::codecvt<__wchar_t,char,_Mbstatet>::_Byte *_Last2std::codecvt<__wchar_t,char,_Mbstatet>::_Byte *&_Mid2 (int &, const wchar_t *, const wchar_t *, const wchar_t *&, char *, char *, char *&)const std::codecvt<__wchar_t,char,_Mbstatet>::_Statype &_State_Byte_Statype_Statype &_Stateconst _Byte *_First1const _Byte *_Last1const _Byte *&_Mid1_Elem *_First2_Elem *_Last2_Elem *&_Mid2 (_Statype &, const _Byte *, const _Byte *, const _Byte *&, _Elem *, _Elem *, _Elem *&)const _Elem *&_Mid1_Byte *_First2_Byte *_Last2_Byte *&_Mid2 (_Statype &, const _Elem *, const _Elem *, const _Elem *&, _Byte *, _Byte *, _Byte *&) (_Statype &, _Byte *, _Byte *, _Byte *&)const _Statype &_State (const _Statype &, const _Byte *, const _Byte *, unsigned int)_Statype &const _Byte *_Byte *const _Statype &const char *_Ptrconst std::_Locinfo::_Cvtvec &_Cvt (const char *, wchar_t *, const _Cvtvec &)const std::_Locinfo::_Cvtvec & (const char *, _Elem *, const _Cvtvec &) (char, wchar_t *, const _Cvtvec &) (char, _Elem *, const _Cvtvec &)wchar_t _Char (wchar_t, const _Cvtvec &)_Elem _Char (_Elem, const _Cvtvec &)_InIt &_First_InIt &_Lastsize_t _Numfields (_InIt &, _InIt &, unsigned int, const _Elem *)const _Facet &const _Facet *bool = false (const std::locale &, const _Facet *, bool)std::locale _Loc (std::locale, const _Facet *)typename _Dummy_Maklocstr(, ( *)0, )_Str_Cvt_Maklocchr(, ( *)0, )Elemchrcvt_Maklocbyte((_Elem), )use_facet< >()locfaclocale(, )pfacc:\archivos de programa\microsoft visual studio 8\vc\include\share.h_SH_DENYNO_SH_DENYRD_SH_DENYWR_SH_DENYRW0x30void (* )(enum std::ios_base::event, class std::ios_base &, int)std::ios_base::Init * (std::ios_base::Init *)std::ios_base &const std::ios_base &_Right (const std::ios_base &)std::ios_base::io_state _Statestd::ios_base::iostate _State = goodbitstd::ios_base::iostate _Statebool _Reraise (int, bool)std::ios_base::iostatebool _Exreraisestd::ios_base::iostate _Newexceptstd::ios_base::fmtflagsstd::ios_base::fmtflags _Newfmtflagsstd::ios_base::fmtflags _Maskstd::streamsizestd::streamsize _Newprecisionstd::streamsize _Newwidthint _Idxvoid *&std::ios_base::event_callback _Pfn (void, int)const std::ios_base &_Otherbool _Newsync = truestd::ios_base * (std::ios_base *)std::ios_base::_Iosarray *_Link (int, std::ios_base::_Iosarray *)std::ios_base::_Iosarray *std::ios_base::event_callback _Pnewstd::ios_base::_Fnarray *_Link (int, void, std::ios_base::_Fnarray *)std::ios_base::_Fnarray *std::ios_base::event_callbackstd::ios_base::event _Ev (std::ios_base::event)std::ios_base::_Iosarray &std::locale *bool &const typename std::_Iosb<_Dummy>::_Seekdirconst typename std::_Iosb<_Dummy>::_Openmodeconst typename std::_Iosb<_Dummy>::_Iostateconst typename std::_Iosb<_Dummy>::_Fmtflags65535const _Iosb<_Dummy>::_Fmtflagsconst _Iosb<_Dummy>::_Iostate255const _Iosb<_Dummy>::_Openmodeconst _Iosb<_Dummy>::_Seekdir640x40000x30000x20000x10000x0800const std::basic_streambuf<_Elem,_Traits> & (const std::basic_streambuf<_Elem,_Traits> &)std::basic_streambuf<_Elem,_Traits> &typename _Traits::int_typetypename _Traits::pos_typetypename _Traits::off_typebasic_streambuf<_Elem,_Traits>::pos_typebasic_streambuf<_Elem,_Traits>::off_type _Offstd::ios_base::seek_dir _Waystd::ios_base::open_mode _Mode (typename _Traits::off_type, unsigned int, unsigned int)std::ios_base::seekdir _Waystd::ios_base::openmode _Mode = ios_base::in|ios_base::out (typename _Traits::off_type, int, int)basic_streambuf<_Elem,_Traits>::pos_type _Pos (typename _Traits::pos_type, unsigned int) (typename _Traits::pos_type, int)basic_streambuf<_Elem,_Traits>::_Myt *_Elem *_Bufferstd::streamsize _Count (_Elem *, int)const std::locale &_Newlocalebasic_streambuf<_Elem,_Traits>::int_type_Elem *_Ptrsize_t _Ptr_size (_Elem *, unsigned int, int) (const _Elem *, int)int _Off_Elem *_Next_Elem *_Last (_Elem *, _Elem *, _Elem *) (_Elem *, _Elem *)_Elem **_Gf_Elem **_Gnint *_Gc_Elem **_Pf_Elem **_Pnint *_Pc (_Elem **, _Elem **, int *, _Elem **, _Elem **, int *)basic_streambuf<_Elem,_Traits>::int_type = _Traits::eof() (typename _Traits::int_type)basic_streambuf<_Elem,_Traits>::off_typestd::ios_base::seekdirstd::ios_base::openmode = ios_base::in|ios_base::outstd::_Mutex_Elem **typename _OutIt = ostreambuf_iterator<_Elem,char_traits<_Elem> >class std::numpunct<_Elem>class std::basic_string<_Elem,char_traits<_Elem>,allocator<_Elem> >std::ios_base &_Iosbase_Elem _Fillconst void *_Val (_OutIt, std::ios_base &, _Elem, const void *)long double _Val (_OutIt, std::ios_base &, _Elem, long double) (_OutIt, std::ios_base &, _Elem, double) (_OutIt, std::ios_base &, _Elem, unsigned __int64) (_OutIt, std::ios_base &, _Elem, __int64) (_OutIt, std::ios_base &, _Elem, unsigned long) (_OutIt, std::ios_base &, _Elem, long)std::_Bool _Val (_OutIt, std::ios_base &, _Elem, bool)char *_Fmtchar _Specstd::ios_base::fmtflags _Flags (char *, char, int)const char *_Bufsize_t _Beforepointsize_t _Afterpointsize_t _Trailing (_OutIt, std::ios_base &, _Elem, const char *, unsigned int, unsigned int, unsigned int, unsigned int)const char *_Spec (char *, const char *, int) (_OutIt, std::ios_base &, _Elem, char *, unsigned int) (_OutIt, const _Elem *, unsigned int) (_OutIt, const char *, unsigned int)_Elem _Kseparator (_OutIt, const char *, unsigned int, _Elem) (_OutIt, _Elem, unsigned int)typename _InIt = istreambuf_iterator<_Elem,char_traits<_Elem> >std::ios_base::iostate &_Statevoid *&_Val (_InIt, _InIt, std::ios_base &, int &, void *&)long double &_Val (_InIt, _InIt, std::ios_base &, int &, long double &)double &_Val (_InIt, _InIt, std::ios_base &, int &, double &)float &_Val (_InIt, _InIt, std::ios_base &, int &, float &)unsigned __int64 &_Val (_InIt, _InIt, std::ios_base &, int &, unsigned __int64 &)__int64 &_Val (_InIt, _InIt, std::ios_base &, int &, __int64 &)unsigned long &_Val (_InIt, _InIt, std::ios_base &, int &, unsigned long &)long &_Val (_InIt, _InIt, std::ios_base &, int &, long &)unsigned int &_Val (_InIt, _InIt, std::ios_base &, int &, unsigned int &)unsigned short &_Val (_InIt, _InIt, std::ios_base &, int &, unsigned short &)std::_Bool &_Val (_InIt, _InIt, std::ios_base &, int &, bool &)char *_Acstd::ios_base::fmtflags _Basefield (char *, _InIt &, _InIt &, int, const std::locale &) (char *, _InIt &, _InIt &, const std::locale &)class std::numpunct<__wchar_t>class std::numpunctnumpunct<_Elem>::string_type (const char *, char **, long, int *) (const char *, char **, int, int *)virtual_strtoui64(, , )bufbaseperr_strtoi64(, , ) (std::ios_base &)class std::basic_ios<_Elem,_Traits>class std::ctype<_Elem>const typename basic_ios<_Elem,_Traits>::_Myt & (const std::basic_ios<_Elem,_Traits> &)typename basic_ios<_Elem,_Traits>::_Mysb *_Strbufbool _Reraise = falsebasic_ios<_Elem,_Traits>::_Myt &const basic_ios<_Elem,_Traits>::_Myt &_Rightbasic_ios<_Elem,_Traits>::_Myos *basic_ios<_Elem,_Traits>::_Myos *_Newtie (std::basic_ostream<_Elem,_Traits> *)basic_ios<_Elem,_Traits>::_Mysb *basic_ios<_Elem,_Traits>::_Mysb *_Strbuf_Elem _Newfillbasic_ios<_Elem,_Traits>::_Mysb *_Strbuf = 0bool _Isstd = false (std::basic_streambuf<_Elem,_Traits> *, bool)typename basic_ios<_Elem,_Traits>::_Myt &std::basic_ostream<__wchar_t,char_traits<__wchar_t> > &std::basic_ostream<__wchar_t,char_traits<__wchar_t> > &_Ostr (std::basic_ostream<__wchar_t,char_traits<__wchar_t> > &)std::basic_ostream > &std::basic_ostream > &_Ostr (std::basic_ostream > &)std::basic_ostream<_Elem,_Traits> &std::basic_ostream<_Elem,_Traits> &_Ostrstd::basic_ostream &std::basic_ostream &_Ostrunsigned char _Ch (std::basic_ostream &, unsigned char)const unsigned char *_Val (std::basic_ostream &, const unsigned char *)signed char _Ch (std::basic_ostream &, signed char)const signed char *_Val (std::basic_ostream &, const signed char *) (std::basic_ostream<_Elem,_Traits> &, _Elem)const _Elem *_Val (std::basic_ostream<_Elem,_Traits> &, const _Elem *)char _Ch (std::basic_ostream &, char)const char *_Val (std::basic_ostream &, const char *) (std::basic_ostream<_Elem,_Traits> &, char) (std::basic_ostream<_Elem,_Traits> &, const char *)class std::num_put<_Elem,_Iter>std::basic_streambuf<_Elem,_Traits> *_Strbuftypename basic_ostream<_Elem,_Traits>::_Myt &_Ostrbasic_ostream<_Elem,_Traits>::_Myt &const typename basic_ostream<_Elem,_Traits>::sentry & (const basic_ostream<_Elem,_Traits>::sentry &)typename basic_ostream<_Elem,_Traits>::sentry &typename basic_ostream<_Elem,_Traits>::_Myt &typename basic_ostream<_Elem,_Traits>::_Mysb *_Strbuffloat _Val__w64 unsigned long _Val (__w64 unsigned long)__w64 unsigned int _Val (__w64 unsigned int)unsigned short _Valshort _Val (short)std::ios_base &(*_Pfn)(std::ios_base &) (std::ios_base &(*)(std::ios_base &))typename basic_ostream<_Elem,_Traits>::_Myios &(*_Pfn)(basic_ostream<_Elem,_Traits>::_Myios &) (std::basic_ios<_Elem,_Traits> &(*)(std::basic_ios<_Elem,_Traits> &))typename basic_ostream<_Elem,_Traits>::_Myt &(*_Pfn)(basic_ostream<_Elem,_Traits>::_Myt &) (std::basic_ostream<_Elem,_Traits> &(*)(std::basic_ostream<_Elem,_Traits> &))const _Elem *_Strbasic_ostream<_Elem,_Traits>::off_type _Off (typename _Traits::off_type, int)basic_ostream<_Elem,_Traits>::pos_type _Pos (typename _Traits::pos_type)basic_ostream<_Elem,_Traits>::pos_type_CATCH_ALL ().setstate(ios_base::badbit, true); _CATCH_END_CATCH_ALL _Myios::setstate(ios_base::badbit, true); _CATCH_END_TRY_BEGINstd::basic_istream<__wchar_t,char_traits<__wchar_t> > &std::basic_istream<__wchar_t,char_traits<__wchar_t> > &_Istr (std::basic_istream<__wchar_t,char_traits<__wchar_t> > &)std::basic_istream > &std::basic_istream > &_Istr (std::basic_istream > &)std::basic_istream<_Elem,_Traits> &std::basic_istream<_Elem,_Traits> &_Istrstd::basic_istream &std::basic_istream &_Istrunsigned char &_Ch (std::basic_istream &, unsigned char &)unsigned char *_Str (std::basic_istream &, unsigned char *)signed char &_Ch (std::basic_istream &, signed char &)signed char *_Str (std::basic_istream &, signed char *)_Elem &_Ch (std::basic_istream<_Elem,_Traits> &, _Elem &)_Elem *_Str (std::basic_istream<_Elem,_Traits> &, _Elem *)class std::num_get<_Elem,_Iter>typename basic_istream<_Elem,_Traits>::_Mysb *_Strbuftypename basic_istream<_Elem,_Traits>::_Myt &_Istrbasic_istream<_Elem,_Traits>::_Myt &const typename basic_istream<_Elem,_Traits>::sentry & (const basic_istream<_Elem,_Traits>::sentry &)bool _Noskip = false (std::basic_istream<_Elem,_Traits> &, bool)typename basic_istream<_Elem,_Traits>::sentry &typename basic_istream<_Elem,_Traits>::_Myt & (void *&) (long double &) (double &) (float &) (unsigned __int64 &) (__int64 &)__w64 unsigned long &_Val (__w64 unsigned long &) (long &) (unsigned int &)int &_Val (int &) (unsigned short &)short &_Val (short &) (bool &)typename basic_istream<_Elem,_Traits>::_Myios &(*_Pfn)(basic_istream<_Elem,_Traits>::_Myios &)typename basic_istream<_Elem,_Traits>::_Myt &(*_Pfn)(basic_istream<_Elem,_Traits>::_Myt &) (std::basic_istream<_Elem,_Traits> &(*)(std::basic_istream<_Elem,_Traits> &))basic_istream<_Elem,_Traits>::_Mysb &_Strbuf_Elem _Delim (std::basic_streambuf<_Elem,_Traits> &, _Elem) (std::basic_streambuf<_Elem,_Traits> &) (_Elem &) (_Elem *, int, _Elem)basic_istream<_Elem,_Traits>::int_typestd::streamsize _Count = 1basic_istream<_Elem,_Traits>::int_type _Metadelim = _Traits::eof() (int, typename _Traits::int_type)size_t _Str_sizebasic_istream<_Elem,_Traits>::off_type _Offbasic_istream<_Elem,_Traits>::pos_type _Posbasic_istream<_Elem,_Traits>::pos_typeconst std::basic_string<_Elem,_Traits,_Alloc> &_Str (std::basic_ostream<_Elem,_Traits> &, const std::basic_string<_Elem,_Traits,_Alloc> &)std::basic_string<_Elem,_Traits,_Alloc> &_Str (std::basic_istream<_Elem,_Traits> &, std::basic_string<_Elem,_Traits,_Alloc> &)const _Elem _Delim (std::basic_istream<_Elem,_Traits> &, std::basic_string<_Elem,_Traits,_Alloc> &, const _Elem)const _Elem *_Right (const std::basic_string<_Elem,_Traits,_Alloc> &, const _Elem *)const _Elem *_Left (const _Elem *, const std::basic_string<_Elem,_Traits,_Alloc> &)std::basic_string<_Elem,_Traits,_Alloc>const _Elem _Right (const std::basic_string<_Elem,_Traits,_Alloc> &, const _Elem)const _Elem _Left (const _Elem, const std::basic_string<_Elem,_Traits,_Alloc> &)c:\archivos de programa\microsoft visual studio 8\vc\include\strstreamchar *_Ptr (char *, int, int)std::strstreambuf *bool _Freezeit = truestd::strstreambufint _Countconst signed char *_Getptr (const signed char *, int)signed char *_Getptrsigned char *_Putptr = 0 (signed char *, int, signed char *)const unsigned char *_Getptr (const unsigned char *, int)const char *_Getptrunsigned char *_Getptrunsigned char *_Putptr = 0 (unsigned char *, int, unsigned char *)char *_Getptrchar *_Putptr = 0 (char *, int, char *)void *(*_Allocfunc)(size_t)void (*_Freefunc)(void *) (void *(*)(unsigned int), void (*)(void *))std::streamsize _Count = 0int _Meta = (-1)std::ios_base::openmode _Which = ios_base::in|ios_base::out (long, int, int)std::streampos _Sp (std::fpos<_Mbstatet>, int)char *_Gp = 0char *_Pp = 0std::strstreambuf::_Strstate _Mode = (_Strstate)0 (int, char *, char *, int)std::strstreambuf::_Strstatevoid *(* )(size_t)void (* )(void *)const char *sjmp_bufRETSIGTYPEfunction(signal (SIGFPE, tests_sigfpe_handler), setjmp (tests_sigfpe_target))int sigint modempz_ptr ropgmp_randstate_t rstate (mpz_ptr, gmp_randstate_t)unsigned long nbits (mpz_ptr, gmp_randstate_t, unsigned long)mpz_srcptr z (mpz_srcptr)mpf_ptr fconst char *str (mpf_ptr, const char *, int)mpq_ptr q (mpq_ptr, const char *, int)mpz_ptr z (mpz_ptr, const char *, int)const void *p1const void *p2mp_size_t size (const void *, const void *, mp_size_t)mp_srcptr p1mp_srcptr p2 (mp_srcptr, mp_srcptr, mp_size_t)mp_srcptr p (mpz_ptr, mp_srcptr, mp_size_t)char *s_origvoid *ptrsize_t oldsizesize_t newsizesize_t bytessize_t alignvoid *pFEACP aborted because NCB getEarlyExit() returned truepcgordoc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\gmp.ncbš’ŠИr\xE9м9XЈAЏ €ЪЋЯОс{иЏRЖ№gЏЪЯtЌРqщkнЇsK#\1ћ4Œд:ц›є… ѕє’c,СШnk|Р^Œ [ŒлЈ›c Г6bЊLsQˆЄЋ”ТQзq01 іц•}зХ=<–фDї8Ї'OXшц,АqnОUТX ТJVЋЪGЉ];˜РЯxАѓЉї…Ъ+ ;‘ О‡Ж̘GЊЁTtЩoŒЮДл_Ф'!рьTЊzЋ!1’щ„шjZы™žЫ?ЈwrwЇ™ЇWш; іцˆ8БМсНЏUјСuо;мЇF џіѕЈˆе‚“иБКI|IЇPшБйЄВўлW™уDO<[dушЊелН6Ѕ~[М&ђŒЊТС;'ЧѓеŽ“^•:ЁУд­…Щ‰БЁф)r‚>р&Р›/Й—TX? у„-Ї|тП-м8џЌ’9ПчМ1˜БЂЛѕZіЬ•˜ђ6Ы‹U^7€Ћ АP|ИпJЌЇъ=S) +2OЬАdlU’№}ОлїdЖГТ*<{EЪЬЋпШ~ђѕНЌ мBтŽD~vё'С€ul1 Њф*ЂЫ#гWUhFн:ŽКИэЈС‹ѕЖ4 З:,b-€"АЩ} ЁŸHlИТgђЬ#š“YBTЗФžТ ЭБEжЗ \FЦ%лЩЫ"ъыЙ>К)Л$Є2ЬTЏђзЖщGem‰УG]%Uз›NLЄv­kВ‚Ќ=ъTё)м+мc-:Ё}щ‹fЃЁНЃН‹щb–f§Yђ‚1mf„Ёв‰8ЁЋцћYЌё^ЂРˆ” рёCєhZcєЁ|ЂY-y~Žgр ƒ@в0ЮупbИ(Ї™ŒХk2йJхлYље6мГъфєѓє"еєвлJFј3ж†aђ–‰5—ГKЪxєТj ya№<‰Œ™МЈнBр ЫэЫчЉaи'мЖшаEzЩpИРD0Н $_ОSБоъзєI%Ў~њ,т˜Џœ(žєqС;2dёY 6гpжЮUпўvа `N+Ы™'мШ]SW• Ф`ѓ оm’љрZдŽd3)W€Я`KЙЋ=nй u=iђќzцГыѓaQnИGŠИ'{=:eŒрЫаŒOašшyZЌ ЉшЮ:ЊHŽ (Eі-­Е"˜(Б@З5•|З|XЦ АузТБЅЦДШ(0ьлyёvПm6Fv B%]_9ЇРXžЛu;&эb,і0dD* AЁОюRQpŒд‹hmЕГЋў0 Zc5oњќђЩќзqьЮ‚ЛsGеДвяЮ)LZ{ТГйтмgЌйO/‚‚<sЗЗ™zУж 2$ c_Вn`-њaC4лФ•"™ ˆUUфЋMOўш‚єЏљр ЪЌЗ” f01Щ8ЯWьЂ`ЖќE'№ ZЄ˜§Mя’гпtзихВЪXr2О4Іђ Ц' _’qЉ$qё7ИœМХіњ#ЈоуНжцЛ[Zй–­ЈЄ†1rТ;НBЌ.тЊР1cy’š+LцйИMщš)>mПAHкНSав]A№[ вšїЦ/э!Њƒсn&#ФС/d.€NаёХъENœоНРL‰з’9ћчСƒ_ Ї’3ВѓИ„=ƒWLAн|U( X7ХLZєW‚ye§м!6ЙЪ*РЫ“рд‹П\x&г#…aрQрЂ~№Л8џЅrК=зЛ8ZЇzG8d7Эх“бХєuЌЏХO‚еГќякюьEЇGWРЕНщ}ƒЌгбbе—б v5^ќ%ЦюUDН<0LJ3о рО{;E4YU ’ /з7ю‘)йАЄ ШРр§fMU EŽ—ШВ.sM›БРD;lœœ 0Яп~V}0]7U$ЊFЗє”л"Ž?р#|rsavт WЏFСBƒ4№ЧВА(ЇŽвфUžZёW_хњ;]€Љ‹Б`Мџс"=g=`С|юrF=ЇнИРL|8=šАŽЫ{г)œяжTХЇад’x€ ТuV%„­Ј•=CЏОЊХБtАhofМдтг ВЪS4VBEPЎЦЭхўн`Яуо~ 366ЦЛ№щШ†“‚… ЋPмšnЬ7lЋ(К]ХжбДY ™ЈП]ъЩЕьдЮ,пИСSMипe e>4ЭЉ‡ fмљ аЌ+мv fL‚VЮі2ЌђАСsЗ’є§6пZ!ДaЮн:}ЉёыK} &“хж^њЫб1лwRЮ=:З;М‡e-wˆНЛНfљ—)щŒ+FЩ š$ќи}}}ЂъIђ3ДpM˜SJcјЖ3V9f9v9/–1•J?ЃУЛ­аc‰6чйНЄћOE:U<~DЛГс])aАрšžLМd‰ЦЋtI:]#‘ЛXщw‘ЉkUд—џ!ЏдЙ_]Џ€-Ж"†oЙћHщfЭаB+ыСУ~ћТkЭlмќЏ`^ЬЉѕ` sоя&ї†Ю†š— №К!Ё€Г•$ѓмЌpOЈє?xbŸтš_JЁ‰[ЙЦaлn–вЎзуЏФ@ь gЦUКљя-–CгЪ |ˆйХ:Ž‰Д+TБ%$*V‹љТ\ГЈCЌћЂ`Iiь­ь~фн{ƒ††Œx’.ЕЪ0FРАЭ Џ}PIЏ”3ЗVP8š-pП'SxžЌх–u(у2_ `К€РэЂ Гh3А8’Хъ‡п№З' ЂиqНZ/ы”ШŽŽ>&1Zz ќž%BЮфЛЃ›ЖхфЃ™•Япƒ‡– jЦ(хл[{ЯžeЊ5бƒи†.Оi›UZшKКўq<Еы\t%™Јж<Eѕ)qгOо<кikСі1{іњ{FнЃъ{0‘­ИкTu<žM4ЬЋдЎ}зЊёF‹нЅl‚S2‘v‰fЭZ5IыЮŒ"Ѓ uЂBчxŸ(iу:Й#:ТШВW‚ТT‹mгќСь:Jд‘<В§ЧlgH§њ{Tx.бљe4”Џѕ­хк {ЕиШŸ>нд˜Dя?&ч}В:+д‹мЙСaєЧМpeЁм›W˜ Ћќ81Є•~(Jэї эtFU‹$]•pEФ]ВЫŽ_B^— яО№’zЅR<фЉCBТЗмПмОА'ЃЬOъ7 Т’НЦзКr~\H†у2ї}Њ5юJ-tЦx/Ц0;Э*лљƒЌZЬэаБŽ#˜Sнэ№ƒwСАЃ5ищV1МWžtŠЛ*W5ЩUП>^nпТ $УFšл%Юz ‘љюЌM^ЌЂNЭмЙZƒ}#“7б71vŽkОЧ_œ)šр†|+WЬ]':ТHйт—т%ŒГg!9ž‚Г]LБxlт=W_6]]шЅЊ0€тHяc&Ћы"„ŸNЊlHє›{іИноѓX9Ѓ–(bр(XVїЃСбЌ"n3™‹рžfё]йGэ3иzЯR^№ˆ‡ЇD|ГВ{4f’КYЋВЎЉTmœSћdeТ™y›aOЩ(%ˆс‘Љ23нP *zвPњ–‡ђ_ЫЄЙЎЪ†Яwž,М”Ž GЛЧєйAVšjBN5)ђЪЯWJц<аvџeщ-­”ьŠ§ЯЬTЙМ€;иЦYчЁрЎ}ч”ў7јfар‡ЎаС:єБ’ПЖкpU‚…u№ЬЩо4 Œg”Иђ†Љ=1аnЈў}{аtРІ0Нь-{,ђšCц$Йє­[ыlœ.JxPјлD)>ўяаŸЦюYџмzz4šФˆГšp YR"ЦИOM№ДБ(…~яЎ|'˜,oлЇхЭrд9 Ъ+§ДО[~G€ЦWЅ>нJnL“Р1A[иNАЛ.ExQАї|MАхъ^Ф…jz\8ƒпЅЮлIC[fжЏПнa!`r,FЁ#п`VЉяaЁо7†Аa] Ѕ7Ч]р ѓЁЗМ_ј6b†њH†€N9€Ѓœќџш‘”J „їpзRŠ—’€И‰­%XSц(Л ШїЌ#e+р=ц‘[CђВ“=31ђOЕ5“ММžŒ/КAŸ†йД–ЫЏAJШЊПџьПиАThE‘уЏГ“R™_СЂ\ўKЬч6  §lў“_‘^_Е*/&?з‘Ѕ“!vЮŸmЎ;~ПКGЂE?]Rт[]?bЅ ЄŠl’Ч*BЗJЪПвЅЖаUХЏмKК>+=€–ЩЩMЉз}_G a}(ьС”И§њ ѓ| q†Њ-№рћ Ш-їЉ듧ІыНЏ|pЦAбFМWžўЌўжља‰\ЩAєR Шe•sіЦжЩ.>7зAC:5ќ˜7кўЈг’ŸyШg„бїлњЕ/+ќwЋc” ŸЌм™ЏНјP3+(ђVЛ’=щv3BФ—оd+ВZ79wS­kУŠn™юjКЂ%хlњqІйС*pUЉpА—!эz Ы6A #yТеИ,їеГ?‚ІЙHЉ%'Ь,jЧ#_їЯ)&ўєœлНЧ?бГєЮg дзReXK*оА#‘.‹WшЊž‹ЗФ{,ОIpq"'унхJњš+єoxіКЄњ)?эЭЌž3Га_щ0юDПњ.žШЉШY=PS Nхsњ\“"@ˆf~>5 1QщсЕIx E[œўЊлxлР1Ќ oЭz4ЮК:!DГtTBŸ№рсаxЪwmѓD‚ыєђуFžЯй‰ЪGЌ<х!?uыы‰СШя]‰ТEŽврКE‰4oн@Чн@Х€Ь0нR$GKЊз*чН“„­u0НJ”rцН[№лы;Гщ†ъифW”ѕ‡`оиюЬ ЖПyCeэJИЙJЕРM|О(В{ВšгD1Ћ4ЩЋЭ7вsд?л4Ђ ­}Wf?Cl1чМ›ЎУт<Iщ”Ђ+џW~h~ЂтЙJлr?СМ.„љБBѓўpтN†3Ъwеˆ№ХЇOЅY’п‰ˆлnсЂ˜дZф!€,=ЌћђB"Ц(>Ъй6ћЗ™…Hт.„ TЬЅпўЅіWЗЎ<ШвaCXцљehф@+v1шД–…8‡WƒЃVЮзЈаpP[(šUы&Ь­ыr+,hЂу_Ђ@>Ў 1г}›аT=UF0Р ъ•ЯєYUY#9ф(•ЪѓŸ…1r­Ш+„СV"ЙX8 ˆЊl3СиUgэџ\рV.–VnХв?ѕД…нldˆиЫwЙјЛЬнP=|ѓ9fCxрIУу7І{r3ђг}ПШ‰"АЯR—ъdgрOŸU˜х№БmbЬZ]дыВШк[ВВ9ЊЖ sAsŒВM{žкl№!WСWэi§jX“і #фтёњg‡гФЕˆСљ"ЮKОлТрT§Б0ЕЗЗБ•,Аoj; Цђe`Э5Pм-}  Ј”Fм3q.2n ЏСeS$Z&Эя‘би^œN3Mi‘rЎєД“ЙЛУ/ЩшгеA4 О‘UежŽSR’џ*е’0П,іРкьxp@‘P2йx…Й§Щгњ kv­ЄЙЋЙqYŽSxПƒнmŸДыьВТ#ѓЁiГcР+v†Ж5ъ мнЌюыВˆЋ2/Бhм”*дŒ| ГчР2ўƒ.-*ЩшKГ"{Џ§‡ѕ­™“^lэЗнУјZjGƒ№ЄqyаK^Н­ОЉяёОьduŸXМгЬ)eЉ–W7FаDЬЇА1G3іп4т;fќжжrlŸvсPБ‡‡гAw˜Кx2e#Д‡кZп+Ь+К]R2ƒЧЙФvУШm4уЧ56№'PE<йecŠ\‰Цgu №цRˆZ~ъKK6Q,@В-9V(СŽTVЋІƒјЃ–jЧ5­УŠ*MXˆ…Ѕ"HfPьЬЎОйbЩпŸM†ЁњQеOмЁГљ~(Г1Dмe~B”ШСr F5ђ˜}NїtфЏ0їUЩљцК Jлk<<1њдyнjЕ'И'J**Ž…––МBЫЩ‹вT§В^і‡3ѓAX›t$Ўњ…&n=s>зШpNн&Дi“­: pц>ъ5`Ў,зќ в"7Д§ж’]НD„lГЎД*A-@JЂ BlD W'0b 5З$ЌjЧpаRmщЪЪћVЉљP‚Š(­%а]‘Зl›”tНыGмˆ‘$eZ”іЙјжњЕGзЪшв$~Хє2%|3šм$$Y_ХJр$у] BREtCЩLдќъКъ=Ш+ЯТЕKS њžЮмбHњэ›еM* ‡9ˆ1Ђв9З”Ъl‰Š{Л=9dЂQЖ`Ђ^@с2АюS•ЂчСFС§РKNgtBрмLО=d “РK2ЦYФЁЊZь˜1ЊИю …TSг8у002‰“UF”p‡$љ JšBUЪjTЮЋђr`оkIї%з=xЁvф–Д†ixLге4шЮТtSЧyїН1$О‰s7Lhвx`˜7ЋкАљœnbŠ™с ,т „‚ <zЗ(ЅЇъ‘рПѓ3ђЌLу…Ш{Х| ъ”†I‹иM4бЋбКТbCcfъщt ЃˆтcџRЧ=XчХg>К•БЩWXpW„—,јŒШ<™7‚р%; ™к€НKѓ^рБ^ь–Bд -IЮЛгg4эТї'Т?%ХДЄЮtY<}С…X9еBN‡Eš8MТІшеGБIAW*2р„oчОŠ2УЩ­ѕх`ыИыЃЫїњџ$љ>X:AјК‹5Ї’я јМьЬ%‹ЃZк3nтЇХoRтƒ-­1<еЊ2YRсЁ;tW­ЛDЛфнЗŸ/d3яњ&Sbђh;эŽ:”>”У<X ŸЃ,№kpДX"ИЯЗsT7ЭP'€\†ё-С-vўV;п EИqx…eёо§DЅN­JЙ/eKєћФ{хZ*ГLЌўэ1^йУqјм™_Œ/жб€мАђЄeњ3ИжрЗД“D!н№сІј_5ѓ-рбЉЅ№=гЧ}9€н‹GŒ xš`?^ќ Т093ƒ„шFыO”ЈэWЗВ5іЁ№хсєœЌ|МЪ "щ&œЋ=ЂD$kлпЁ­Ќ№џСFсЭFaЯъІ‰RT~А‡ь"|w/wЄ;1ЏЏНєз˜јй-нє7Й>зЮєг@Ь…Нж–)єЪm”e\Кщo,U[лš•л–‰х.JКх фџ%жр†TЫ‡4=ПzE Пi <‘ wS“Њ „+эќOA\`ECвЩR-03д§д60вДБ?hXСђ;ZVfš›lІКqєШ27Рру‹qoжПё3Чю:Ч$9руšŠžeWд ‰Ц‘\˜OіЈh^ЗбА@}‘ЦПeЕХршKRРХL;МdъoГFjšbЉ'—јчА%ќ’)ŠАдi6”PНДЌ.ДЎРEр‚ М wн'5ŽЬDА}N&F‚Ч0”ё)Ѕ ъ­и•м07е<№ЁьAA6ЅL›ЦškьZЦЪ0ak€]нЄCVы?‡\ уI# Ю%/аЫПˆДїнхЙoŠ1єЈl]\#шћZ"ŒHІpa9Kъ˜bэ…YХhШсѕшХž–2гьyЃфќИДE­nфЭ7”иЊоAхsqRРoFю…M hЪxЎS­o.Sb-FJХў†є*IЧљЎу?ЌХP*]­ЦTŠ№)œq9!­%]внvцСн1Ÿ<яš:њ/Ÿ‚І<Њ@эIЯЭЙwŸmOHРђКпшэР.щ ƒSŸ#ЂRА єШЯ)Мk&.G џи`еѕ|ѕЄђщЏФћ‡К› К<дЫ€›ЛнXDQŽЌаPRzNиЧм­Ю­ кЖоЎЁнЕнЄCZРjІВжЁ?—џєГIє‡Ј‡м9ŒФ­vбfсdƒn…}YЪК‘ 8|ю~Š& ѓP†PYbŽAБbAyЃщї“ŠёйКlюh$^юšйJ/4m_Z 0 BoZќф]щ!ЃМЖ+`wё”ŒкШPЯVьєˆ:ѕЫШЖs§рDЫ|zфЕТУ|ЖiXGэ|кИлЙŸmА­оеH-П+ЖфB>LЛZз ­АлћЧЪVV+ьэъєфВm@‡НГлыj7†xЕoй<щддjœA›ukр?ЛдЋн?^JГvSPiЄЫ˜љН‚Л`Да<!l?CЕDziЙGќп—25?ЎЬ< <7"Јйь0BњB‹xT‡•$ЊСЃуVьякя–ЫГzaMЦоЬNёПzГЙкf™Эv‘p$K3œюi№цœжPС? Ьж+O-Е ”­Іц6sLWфQжA eOŠ)ј“zљW^EEё•˜Œ}Ю&ь…V Ю`žXъ=яfhI3ThPž$ƒoьУ~мѕˆцД‰,єћs7діCч3•ЎѓEЩˆб вЁfX!"лЁdmcОЁ?ЭЈ\КџYЇЇЁЇ#NГ`y˜ћє;оRlЫ@П9cdХ.zв'кaЩШO›6+&$ŽZMаdЛ/ЬИВX*5ёо)ьUа5УФ‘–Ўt/X§[6$CТЯп.кт—цушдѓhјшќgVМј%Œ*Ш,X1и5$8zTf>тBЮRrWОYЫўТ„‹› ЄXІhЏlдИіДќУHЦЬЁЋђІ€Š€Žт,рЂ ЈЫАYЯ#$F‡}СШNTпЮ”i§бŸ?s<ЦL‡Z+Ў\ЋЎ’їOўЁїЄЎєS73є0O’yСЦ#Vђ…OSпˆМžЧЅœэ)‚љPЏ…Е&iлЕ3Шй=šboбЮЖ4вЌъ40Ž‰”jг{~zЏ5)wsмp­оhyšО,‹kыУыJU4i–о™M|КЋ &о…[a<ДКс L>ї”GТ‰ ЗнМ“йчнQэ7чDџ)ЕтЈђ^—ѓwЏ–.' ЏВъ^IgГeї(<ыяыџŠ’Р<"<l<DЭ ЖХЊХX‹љ@˜Щ’;aдЂЬЌCНўи=пI~['ЁXЖ2ѓЗ+MРРFИыЧпЂFeп{бZˆCЉrы2Rш“>Р'pыгу?ёœGxOчH3ўщb”WЧƒuЇ–NЖ…pЏT‚4G[i~˜ZТою~BŽ Ьљ…эЯœЇаUЛїŽе{ЯгƒОKg ?}ф<] ъ;“Ol]ЯжВ=%ЛQш‡уr“Д/š@ЌLЋkFф+;ƒ2›"=-F4йš…Ў^іђФp• лTŒŒй шя§ОюФЦTИyєoPЫbќЌГw‹БЧ/‡Й%бъЩ^бXЬ:*­UИ[ЦТќГз!гщHНъѕеX;2’#­Ї8кт>2 ў єЈ UрајoЙBРMK„QиD—а+д фcy}БŠчџјЭ@[­wЖ>ЦЮ•8#д#‘пŸ…FРŸ›Здът­R=ї@нЯ1кГнєG=ЋXЏЫ*ЖЮ>щ›ВЩ Œ<˜ѕ‚хrЋЕЮѓ]@Н…щџг‚ щМCКФtЛя ™ЌmЊМєђ4WУЩм яћНя>ЃšEgЛъ1Ф?’їйE<ЁЉЬщƒЙ/˜$„|<Аї6вЪ8E€ё”ЗŽюмьЛ‰ЉэЊ ЗЩaЯОэFt†дєŒ`š„Р=ЬЅ_п[KIЫПВЗ?У—ь”Q?ŸёЧН (ОVFёг#ЧїЖ№+FœG+ЎXм„њчŒ +…WV‘јБОsГЎб–lп5?е@=P”†9O "ž`3Кџ\аЯœы1­рчјщНйd_}ЕŠ;т@Œяе;“ЮжeŠ{\ћ!Д–„бlEА8ЮЋIЂьтыЖ!їхwr…ИK1)HяBел\1Ї*Wr-Оеэ~[Z7ПжВ=;…>W%И=Ћњ{Э,\йMё}k3Кр„0CЉy№‰­яЇ9;…ЩЃQ ГC’$ПŒв>Te/4}ьpъqЊ†№ЏСŽТь‹ий{йћ3KЙокЅмJŽiJЕЁј(žDЎфkйХNСуВъ@Жди•n%Ю Г40$Cёе/Ег6 ЌG!ј—g7Gњ_ˆpтУТ§љ-‹АФ›^ЕŠZ‰­о`*Nw‚ˆ=”4ЏXјЎd.иЉЛЮЦ:›ЅJ2с'ЉљG/4ж(!^ RЯЮы4P#љщХ.єКM['Лсопƒ†XOЫZ{Ь?ЖcЫзьЖ“’в‘YД Ўdжф4œм,ж7Л_гПЕ˜ощ]№zЄd>FДѕСВ3€ЬєxЅVЬv7ЋH3 ˜O„|eJ‚};!&­‚ MуXъ юM)Eп}Ф›п-яіz0ЕФяѕзьM[п„™ПѓБЏМЩаЦгŽУ”OЬY› ЭВjВ‘NЕ^“§чДVФ0%}шЕзY~sбС„И0ъBлуоL™‡§8c€)БŠK­Pwk љaГаHE;мŒЧ‚X$Х1гф­ŸEЪ2ГОP 2?qўќЃуњ:ЙБ5Џ˜Рu­Ќщ ­ћ=а(>VF…J#ЩFV /|.-BV„щ€l*6Г+Й‹lаВ1! 9ђХvыйыš‘,™•‹ЅНƒж‘пЅїY™ѕ/’Q=юš„˜NјKм:5бРƒЕъВ &ь‚I(=ъщHФцК%J:с{Н“Ус„" z™F)~сЫŸL[Ž+NБ*IВІfі/вQцМa&Ѕ_uRДеGvЎт$УыHk”ЭтJltЖ-Ю$ я pišББaД[–ЯЬ!яіL”Х™ћoQnрИЂaџˆєЯъ—№Ь[К~sХЇBбА№ЯS‰й1Є/Л)U1В/Й/Ю/цщSNяМЋ/дd)ŠПZrvaOdИ…ьR›ŸЪyєaЦъЯvз>=Ÿуи* VОЫ+яБгu?ЁH:ТыБЄ›НИмC@ xл(Зo4 VЭ2М оlŒкeЊ—ыьƒŸ(Їл'mючŠ‹ЯўVFU&ТI™АљЙЎёћТхТ/8њ_ БЯIŠ‚вБ к,_млі-Ъ(Фй™В55ZŒZ—чoгЕАЕЌмсuKѕJX,ГЃ(ё Ћ+КиЙккўzќoБyЎ>fЋ$rУцSE.ь№БчD‡2EЋ‰\6„<„YD(ўTЩчФаѕжјyDSаЎЃЖTєЦ СiеNь%вф-К.W—6žфM=sёуyоУM„П\Ѓš+„<м/’Й 6кwOєєч5тєQPTНбЅ•ЌH.zѓ‡XЦ1D%_ž Х u`WŒŠоkAБъAи[e<†ŸRоо3є9Л Ёю!љО‚EєŒыњыО†PyсC‘орwдйэOŠТYвW'пV žŒЦЊL,ЩpЮvи­и l+ЇIFuЈ0‹ЅЎ)ъ@ 6CRЯе ьоАЉ‚р”NешTћэ‹‹Ў3‰иV ёŸ=’)D‹^ЌdtЎА7Ч’Ќу?˜:0++Ш“ШЇœEVŽьtГмАЊЁ]™ž ›} о˜!@,Д2ЭЧФЌЛЭВк9ьнїtXс“\'ё–0ќ1VŸъŒъО}sXЃ>ƒ?\J.ЄЏс,š:с<ž@-ŠСЛШјаєu—­JdIќПЅАЊ@9/2­7П]ѓ%8р=лŒ#JЯфwј$сEЮ€“у)ћYgzюё*:ЊOЅЅvSБ=]6ПеBP?РsЎмЯ–gšщEфbгVРЛŠ=д;gЗ)kс† ‡+Зžкca9&xšљ–‰ї`+QќёМ1ЮŒЂыщЯ)т1rадЕТљ–Aє‡рЪф4КСN^Я›*ЧаИ`ё•ЬС0JeœKZJѕFec=˜ИЋн5цbLЯЩB=-„›U6emGŒьБ=dхЉЦC'`<ЩЃзІНˆAFFpшƒ@.,В1ж’RnэЭЋыemщбŠДBз‘;ѕXzŠЉgЫц9Ьuй­йbE я?|^чо,…ў,o‰*—c / 8ъYпКпЊРQЉ‹ щœоЕXŠ€&Z{­TБhєІэіTŠ+ЊC~z2Ръщ„кNlS„ž„р-˜-}Uњ—;МbпцФ"@?ІYЩІJзН|(СРm%Ќєєїњ>Iшљe12я:ѓxzМщo#”BBSЛˆл6ЙЃс*ьЕц8ё76РЗЅ№ПVVJrБЄТ‡rŠкN,І—Ри[=/VэЕ$Гі3ЋДЩЫLжХ”У!#‰ЭГу/yJœџjќеy(АщЗŒ$4+њY[Л)1ЗH@щщЌ‡Ьц$џяїTЩкъГZщ–н жЌТ Иф0E&?Э()Џ‚?ї1ь–dтRЫ3Л>Ё1 C*/=Z`МЫИа]нm@!W3<ѕBяёйA—Xfcšl Ж(›4|•œžjвpRъЦ•ћЅ,Н&Rюœ“еО6§:xЛj­œ;иЩ№ЋжK &П:Љus№С eБYЮt–}FУM3„Ц--<ьХ№8ш#єЏ_D@ ЯU?u'B9QY‘…ФОЂПЈгЛ!‰e’ЃрˆПгМE|jђ6Z"(ХнЎйъFД†мї‰ГY‘В€}А9ЄЛL:єо5 =щ”єџFёЛГЃЗ3ТИєКЖ‡Э,чДЛЃБDr;ŽВ;ВЁmЭэoАжŠiёc 3RcLКеŒœО‘Юwю!4ЂЊИЕu†QѕD_p=(Sv|i $S,_ЗЄє)љрсўяўяЮgmp.hgmp-impl.hL1_CACHE_SIZEPART_SIZEBYTES_PER_MP_LIMBmp_limb_tmpn_addsub_nmp_ptrr1pr2pmp_srcptrs1ps2pmp_size_tnacynacyoscynscyooffthis_nMINHAVE_NATIVE_mpn_add_ncmpn_add_ncmpn_add_nmpn_add_1HAVE_NATIVE_mpn_sub_ncmpn_sub_ncmpn_sub_nmpn_sub_1tpMPN_COPYMAINstdlibhstdiocputimemainargcargvtstrtolmallocTIMEprintflonglong.hDIVREM_1_NORM_THRESHOLDDIVREM_1_UNNORM_THRESHOLDmpn_divrem_1qpqxnupundin1n0rASSERTMPN_SAME_OR_SEPARATE_PGMP_NAIL_BITSGMP_LIMB_HIGHBITqBELOW_THRESHOLDplainudiv_qrnndCNST_LIMBdinvinvert_limbudiv_qrnnd_preinvnormUDIV_NEEDS_NORMALIZATIONcount_leading_zerosGMP_LIMB_BITSGMP_NUMB_BITSDIVREM_2_THRESHOLDmpn_divrem_2npnndpmost_significant_q_limbn2d1d0d1invuse_preinvGMP_NUMB_HIGHBITMPN_OVERLAP_PASSERT_MPNsub_ddmmssGMP_NUMB_MASKABOVE_THRESHOLDadd_ssaaaaumul_ppmmq_testc:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\gmp.h__GMP_H____cplusplusc:\archivos de programa\microsoft visual studio 8\vc\include\iosfwdonce_IOSFWD_RC_INVOKEDc:\archivos de programa\microsoft visual studio 8\vc\include\cstdio_CSTDIO_c:\archivos de programa\microsoft visual studio 8\vc\include\yvals.h_YVALSc:\archivos de programa\microsoft visual studio 8\vc\include\crtdefs.h_CRTIMP_DLLdllimport_INC_CRTDEFS__midl_CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_COUNT_CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES_WIN32ERROROnlyWin32targetsupported_CRT_NOFORCE_MANIFEST_CRT_FORCE_MANIFESTmessage_VC_NODEFAULTLIBc:\archivos de programa\microsoft visual studio 8\vc\include\sal.h__specstrings__nothrow__declspecnothrow_PREFAST_SPECSTRINGIZEx__null__notnull__maybenull__readonly__notreadonly__maybereadonly__valid__notvalid__maybevalid__readableToextent__elem_readableTosize__byte_readableTo__writableTo__elem_writableTo__byte_writableTo__deref__pre__post__precondexpr__postcond__exceptthat__execeptthat__refparam__inner_control_entrypointcategory__inner_data_entrypoint__inner_success__inner_checkReturn__inner_typefixctype__inner_override__inner_callback__inner_blocksOnresource__inner_fallthrough_dec__FallThrough__inner_fallthrough__ecount__bcount__in__in_ecount__in_bcount__in_z__nullterminated__in_ecount_z__in_bcount_z__in_nz__in_ecount_nz__in_bcount_nz__out__out_ecount__out_bcount__out_ecount_partlength__out_bcount_part__out_ecount_full__out_bcount_full__out_z__out_z_opt__out_ecount_z__out_bcount_z__out_ecount_part_z__out_bcount_part_z__out_ecount_full_z__out_bcount_full_z__out_nz__out_nz_opt__out_ecount_nz__out_bcount_nz__inout__inout_ecount__inout_bcount__inout_ecount_part__inout_bcount_part__inout_ecount_full__inout_bcount_full__inout_z__inout_ecount_z__inout_bcount_z__inout_nz__inout_ecount_nz__inout_bcount_nz__ecount_opt__bcount_opt__in_opt__in_ecount_opt__in_bcount_opt__in_z_opt__in_ecount_z_opt__in_bcount_z_opt__in_nz_opt__in_ecount_nz_opt__in_bcount_nz_opt__out_opt__out_ecount_opt__out_bcount_opt__out_ecount_part_opt__out_bcount_part_opt__out_ecount_full_opt__out_bcount_full_opt__out_ecount_z_opt__out_bcount_z_opt__out_ecount_part_z_opt__out_bcount_part_z_opt__out_ecount_full_z_opt__out_bcount_full_z_opt__out_ecount_nz_opt__out_bcount_nz_opt__inout_opt__inout_ecount_opt__inout_bcount_opt__inout_ecount_part_opt__inout_bcount_part_opt__inout_ecount_full_opt__inout_bcount_full_opt__inout_z_opt__inout_ecount_z_opt__inout_bcount_z_opt__inout_nz_opt__inout_ecount_nz_opt__inout_bcount_nz_opt__deref_ecount__deref_bcount__deref_out__deref_out_ecount__deref_out_bcount__deref_out_ecount_part__deref_out_bcount_part__deref_out_ecount_full__deref_out_bcount_full__deref_out_z__deref_out_ecount_z__deref_out_bcount_z__deref_out_nz__deref_out_ecount_nz__deref_out_bcount_nz__deref_inout__deref_inout_z__deref_inout_ecount__deref_inout_bcount__deref_inout_ecount_part__deref_inout_bcount_part__deref_inout_ecount_full__deref_inout_bcount_full__deref_inout_ecount_z__deref_inout_bcount_z__deref_inout_nz__deref_inout_ecount_nz__deref_inout_bcount_nz__deref_ecount_opt__deref_bcount_opt__deref_out_opt__deref_out_ecount_opt__deref_out_bcount_opt__deref_out_ecount_part_opt__deref_out_bcount_part_opt__deref_out_ecount_full_opt__deref_out_bcount_full_opt__deref_out_z_opt__deref_out_ecount_z_opt__deref_out_bcount_z_opt__deref_out_nz_opt__deref_out_ecount_nz_opt__deref_out_bcount_nz_opt__deref_inout_opt__deref_inout_ecount_opt__deref_inout_bcount_opt__deref_inout_ecount_part_opt__deref_inout_bcount_part_opt__deref_inout_ecount_full_opt__deref_inout_bcount_full_opt__deref_inout_z_opt__deref_inout_ecount_z_opt__deref_inout_bcount_z_opt__deref_inout_nz_opt__deref_inout_ecount_nz_opt__deref_inout_bcount_nz_opt__deref_opt_ecount__deref_opt_bcount__deref_opt_out__deref_opt_out_z__deref_opt_out_ecount__deref_opt_out_bcount__deref_opt_out_ecount_part__deref_opt_out_bcount_part__deref_opt_out_ecount_full__deref_opt_out_bcount_full__deref_opt_inout__deref_opt_inout_ecount__deref_opt_inout_bcount__deref_opt_inout_ecount_part__deref_opt_inout_bcount_part__deref_opt_inout_ecount_full__deref_opt_inout_bcount_full__deref_opt_inout_z__deref_opt_inout_ecount_z__deref_opt_inout_bcount_z__deref_opt_inout_nz__deref_opt_inout_ecount_nz__deref_opt_inout_bcount_nz__deref_opt_ecount_opt__deref_opt_bcount_opt__deref_opt_out_opt__deref_opt_out_ecount_opt__deref_opt_out_bcount_opt__deref_opt_out_ecount_part_opt__deref_opt_out_bcount_part_opt__deref_opt_out_ecount_full_opt__deref_opt_out_bcount_full_opt__deref_opt_out_z_opt__deref_opt_out_ecount_z_opt__deref_opt_out_bcount_z_opt__deref_opt_out_nz_opt__deref_opt_out_ecount_nz_opt__deref_opt_out_bcount_nz_opt__deref_opt_inout_opt__deref_opt_inout_ecount_opt__deref_opt_inout_bcount_opt__deref_opt_inout_ecount_part_opt__deref_opt_inout_bcount_part_opt__deref_opt_inout_ecount_full_opt__deref_opt_inout_bcount_full_opt__deref_opt_inout_z_opt__deref_opt_inout_ecount_z_opt__deref_opt_inout_bcount_z_opt__deref_opt_inout_nz_opt__deref_opt_inout_ecount_nz_opt__deref_opt_inout_bcount_nz_opt__successsentinel__nullnullterminated__reserved__checkReturn__typefix__override__callback__format_string__blocksOn__control_entrypoint__data_entrypoint__fallthrough__analysis_assume_DEBUG_CRT_MANIFEST_RETAIL_CRT_MANIFEST_INCONSISTENT_CRT_MANIFEST_DEBUGYouhaveincludedsomeClibraryheaderfileswithandnotThiswillworkcorrectlyPleasesetorclearconsistentlycrtassem_M_IX86commentlinker__LIBRARIES_ASSEMBLY_NAME_PREFIX_CRT_ASSEMBLY_VERSION_VC_ASSEMBLY_PUBLICKEYTOKEN_M_AMD64_M_IA64_MSC_VER_CRT_PACKINGpackpushc:\archivos de programa\microsoft visual studio 8\vc\include\vadefs.h_INC_VADEFS_W64_X86___w64_UINTPTR_T_DEFINED_WIN64uintptr_t_VA_LIST_DEFINED_M_CEE_PURESystemArgIteratorva_list_ADDRESSOFvreinterpret_castconstchar_VA_ALIGN_SLOTSIZEOF_VA_STRUCT_ALIGN_ALIGNOFap_APALIGNsizeof__alignof_M_CEE__va_start__va_arg__va_end_crt_va_start_crt_va_arg_crt_va_end_INTSIZEOFintpop_CRT_STRINGIZE__CRT_STRINGIZE_Value_CRT_WIDE__CRT_WIDE_StringL_CRTIMP_NOIA64_CRTIMP2_STATIC_CPPLIB_CRTIMP_ALTERNATIVE_CRT_ALTERNATIVE_INLINES_CRT_ALTERNATIVE_IMPORTED_MRTIMP_MRTIMP2_MCRTIMP__CLR_OR_THIS_CALLMRTDLL__CLRCALL_OR_CDECL__cdecl_CRTIMP_PURE_PGLOBAL__cplusplus_cliprocess_AGLOBALappdomain_M_CEE_MIXED__STDC_SECURE_LIB____GOT_SECURE_LIB____STDC_WANT_SECURE_LIB___CRT_SECURE_NO_DEPRECATE_MSC_FULL_VER_CRT_DEPRECATE_TEXT_Textdeprecated_CRT_INSECURE_DEPRECATE_Replacement_CRT_INSECURE_DEPRECATE_MEMORY_CRT_SECURE_DEPRECATE_MEMORY_CRT_INSECURE_DEPRECATE_GLOBALS_CRT_SECURE_NO_DEPRECATE_GLOBALS_CRT_MANAGED_HEAP_DEPRECATE_CRT_MANAGED_HEAP_NO_DEPRECATE_SECURECRT_FILL_BUFFER_PATTERNxFD_CRT_OBSOLETE_CRT_OBSOLETE_NO_DEPRECATE_NewItem_CRT_JIT_INTRINSICjitintrinsicCannotuseSecureCRToverloadswhenis_CRT_NONSTDC_DEPRECATE_CRT_NONSTDC_NO_DEPRECATE_POSIX__NewName_SIZE_T_DEFINEDsize_t_RSIZE_T_DEFINEDrsize_t_INTPTR_T_DEFINEDintptr_t_PTRDIFF_T_DEFINEDptrdiff_t_WCHAR_T_DEFINED_WCTYPE_T_DEFINEDwint_twctype_t_USE_32BIT_TIME_Tcannotbittime_t_INTEGRAL_MAX_BITS_ERRCODE_DEFINEDerrcodeerrno_t_TIME32_T_DEFINED__time32_t_TIME64_T_DEFINED__time64_t_TIME_T_DEFINED_CONST_RETURN_CRT_CONST_CORRECT_OVERLOADSUNALIGNED_CRT_ALIGNalign_MSC_VER_GREATER_THEN_13102050_CRTNOALIASnoalias_CRTRESTRICTrestrict__CRTDECL_ARGMAX_TRUNCATE__DEFINE_CPP_OVERLOAD_SECURE_FUNC_0_0_ReturnType_FuncName_DstType_Dstexterntemplate_Sizeinlinereturn__DEFINE_CPP_OVERLOAD_SECURE_FUNC_0_1_TType1_TArg1__DEFINE_CPP_OVERLOAD_SECURE_FUNC_0_2_TType2_TArg2__DEFINE_CPP_OVERLOAD_SECURE_FUNC_0_3_TType3_TArg3__DEFINE_CPP_OVERLOAD_SECURE_FUNC_0_4_TType4_TArg4__DEFINE_CPP_OVERLOAD_SECURE_FUNC_1_1_HType1_HArg1__DEFINE_CPP_OVERLOAD_SECURE_FUNC_1_2__DEFINE_CPP_OVERLOAD_SECURE_FUNC_1_3__DEFINE_CPP_OVERLOAD_SECURE_FUNC_2_0_HType2_HArg2__DEFINE_CPP_OVERLOAD_SECURE_FUNC_0_1_ARGLIST_VFuncName__pragmawarningdisable_ArgList__DEFINE_CPP_OVERLOAD_SECURE_FUNC_0_2_ARGLIST__DEFINE_CPP_OVERLOAD_SECURE_FUNC_SPLITPATH_Src_DriveSize_DirSize_NameSize_ExtSize_Drive_Dir_Name_Ext__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_0_ReturnPolicy_DeclSpec__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_0_EX_s__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_1__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_1_EX__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_2__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_2_EX__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_3__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_3_EX__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_4__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_4_EX__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_1_1__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_1_1_EX__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_2_0__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_2_0_EX__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_1_ARGLIST__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_1_ARGLIST_EX__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_2_ARGLIST__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_2_ARGLIST_EX__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_2_SIZE__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_2_SIZE_EX__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_3_SIZE__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_3_SIZE_EX__DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_0__DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_0_EX__DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_1__DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_1_EX__DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_2__DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_2_EX__DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_3__DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_3_EX__DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_4__DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_4_EX__DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_1_1__DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_1_1_EX__DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_2_0__DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_2_0_EX__DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_1_ARGLIST__DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_1_ARGLIST_EX__DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_2_SIZE__DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_2_SIZE_EX__DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_3_SIZE__DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_3_SIZE_EX__RETURN_POLICY_SAME_FunctionCall__RETURN_POLICY_DST__RETURN_POLICY_VOID__EMPTY_DECLSPEC_SecureFuncName__insecure__T__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_0_CGETS_SizeRead_Err_SecureDstType_SecureVFuncName_Ret__DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_0_CGETS__DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_2_ARGLIST__DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_2_ARGLIST_EX__DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_0_GETS_Argsthreadlocaleinfostructthreadmbcinfostructpthreadlocinfopthreadmbcinfo__lc_time_datalocaleinfo_structlocinfombcinfo_locale_tstruct_locale_t_TAGLC_ID_DEFINEDtagLC_IDwLanguagewCountrywCodePageLC_IDLPLC_ID_THREADLOCALEINFOrefcountlc_codepagelc_collate_cplc_handlelc_idlocalewlocalewrefcountlc_categorylc_clikemb_cur_maxlconv_intl_refcountlconv_num_refcountlconv_mon_refcountlconvctype1_refcountctype1pctypepclmappcumaplc_time_currthreadlocinfo_PFT_SHOULD_CHECK_RETURN__checkReturn_opt_PFT_SHOULD_CHECK_RETURN_WAT__checkReturn_watMIDL_PASS__crt_typefix_NO_INLINING_CRT_UNUSEDvoidthreadlocaleinfostruct::refcountthreadlocaleinfostruct::lc_codepagethreadlocaleinfostruct::lc_collate_cpthreadlocaleinfostruct::lc_handlethreadlocaleinfostruct::lc_idthreadlocaleinfostruct::__unnamed_0042_1threadlocaleinfostruct::__unnamed_0042_1::localethreadlocaleinfostruct::__unnamed_0042_1::wlocalethreadlocaleinfostruct::__unnamed_0042_1::refcountthreadlocaleinfostruct::__unnamed_0042_1::wrefcountthreadlocaleinfostruct::lc_categorythreadlocaleinfostruct::lc_clikethreadlocaleinfostruct::mb_cur_maxthreadlocaleinfostruct::lconv_intl_refcountthreadlocaleinfostruct::lconv_num_refcountthreadlocaleinfostruct::lconv_mon_refcountthreadlocaleinfostruct::lconvthreadlocaleinfostruct::ctype1_refcountthreadlocaleinfostruct::ctype1threadlocaleinfostruct::pctypethreadlocaleinfostruct::pclmapthreadlocaleinfostruct::pcumapthreadlocaleinfostruct::lc_time_currtagLC_ID::wLanguagetagLC_ID::wCountrytagLC_ID::wCodePagelocaleinfo_struct::locinfolocaleinfo_struct::mbcinfo_CPPLIB_VER__PURE_APPDOMAIN_GLOBAL__CLRCALL_PURE_OR_CDECL_WIN32_C_LIB_MULTI_THREAD_IOSTREAM_OP_LOCKS_GLOBAL_LOCALE_COMPILER_TLS_TLS_QUALthread_HAS_EXCEPTIONS_HAS_NAMESPACE_HAS_IMMUTABLE_SETS_HAS_STRICT_CONFORMANCE_GLOBAL_USING_HAS_ITERATOR_DEBUGGINGcrtwrn_CRT_WARNING_NO_ITERATOR_DEBUGGING__STR2WSTRstr_STR2WSTR__FILEW____FILE____FUNCTIONW____FUNCTION___SECURE_SCL_SECURE_SCL_DEPRECATE_SCL_SECURE_NO_DEPRECATE_SECURE_SCL_THROWS_SCL_INSECURE_DEPRECATE_SCL_SECURE_INVALID_PARAMETER_invalid_parameter__LINE___invalid_parameter_noinfo_SCL_SECURE_INVALID_ARGUMENT_NO_ASSERT_Xinvarg_SCL_SECURE_OUT_OF_RANGE_NO_ASSERT_Xran_SCL_SECURE_ALWAYS_VALIDATEcondif_ASSERTE_SCL_SECURE_ALWAYS_VALIDATE_RANGE_SCL_SECURE_CRT_VALIDATEretvalue_SCL_SECURE_VALIDATE_SCL_SECURE_VALIDATE_RANGE_SCL_SECURE_INVALID_ARGUMENT_SCL_SECURE_OUT_OF_RANGE_SCL_SECURE_MOVEfuncdstsrccount_SCL_SECURE_COPY_SECURE_VALIDATION_Secure_validation_SECURE_VALIDATION_DEFAULTtrue_SCL_SECURE_TRAITS_VALIDATE_SCL_SECURE_TRAITS_VALIDATE_RANGE_SCL_SECURE_TRAITS_INVALID_ARGUMENT_SCL_SECURE_TRAITS_OUT_OF_RANGE_CRT_SECURE_MEMCPYdestdestsizesourcememcpy_s_CRT_SECURE_MEMMOVEmemmove_s_CRT_SECURE_WMEMCPYwmemcpy_s_CRT_SECURE_WMEMMOVEwmemmove_smemcpymemmovewmemcpywmemmovec:\archivos de programa\microsoft visual studio 8\vc\include\use_ansi.h_USE_ANSI_CPP_CRT_NOPRAGMA_LIBSlib_STL_NOFORCE_MANIFEST_VC6SP2_CRTIMP2_NCEEPURE_MRTIMP2_NPURE_MRTIMP2_NCEE_MRTIMP2_NCEEPURE_MRTIMP2_NPURE_NCEEPURE_DLL_CPPLIB_CRTIMP2_PURE_CRTDATA2_DEPRECATED_STD_BEGINnamespacestd_STD_END_STD_STDEXT_BEGINstdext_STDEXT_END_STDEXT_STD_USING_C_STD_BEGIN_C_STD_END_CSTD_C_LIB_DECL_END_C_LIB_DECL_EXTERN_C_END_EXTERN_C_Restrict_Bool_LONGLONG__int64_ULONGLONGunsigned_LLONG_MAXx7fffffffffffffff_ULLONG_MAXxffffffffffffffff_C2_MAX_EXP_DIG_MAX_INT_DIG_MAX_SIG_DIG_Longlong_ULonglong_Filet_iobuf_FPOS_T_DEFINED_FPOSOFFfplong_IOBASE_base_IOPTR_ptr_IOCNT_cnt_LOCK_LOCALE_LOCK_MALLOC_LOCK_STREAM_LOCK_DEBUG_MAX_LOCK_Lockit_Locktype_Lockit_ctor_Kind_Lockit_dtor_EmptyLockit_M_CEE_FINALLYfinally_BEGIN_LOCK_TmpTestTypeToString_MustReleaseLock_LockKindRuntimeCompilerServicesRuntimeHelpersPrepareConstrainedRegions_Lock_END_LOCK_BEGIN_LOCINFO_VarName_Locinfo_END_LOCINFO_RELIABILITY_CONTRACTConstrainedExecutionReliabilityContractConsistencyWillNotCorruptStateCerSuccess_Mutex_Mutex_ctor_Mutex_dtor_Mutex_Lock_Unlock_Mutex_Unlock_Mtx_Init_locks_Init_locks_ctor_Init_locks_dtor_Atexit_Mbstatet_ATEXIT_T_Mbstinitmbstate_t_EXTERN_TEMPLATE_THROW_BAD_ALLOC_THROW1_Init_locks::_Init_locks_Init_locks::~_Init_locks_Init_locks::_Init_locks_ctor_Init_locks::_Init_locks_dtor_Mutex::_Mutex_Mutex::~_Mutex_Mutex::_Lock_Mutex::_Unlock_Mutex::_Mutex_ctor_Mutex::_Mutex_dtor_Mutex::_Mutex_Lock_Mutex::_Mutex_Unlock_Mutex::operator =_Mutex::_Mtx_Lockit::_Lockit_Lockit::~_Lockit_Lockit::_Lockit_ctor_Lockit::_Lockit_dtor_Lockit::operator =_Lockit::_Locktypec:\archivos de programa\microsoft visual studio 8\vc\include\stdio.h_INC_STDIOsalvadefsBUFSIZ_NFILE_NSTREAM__IOB_ENTRIESEOF_FILE_DEFINED_flag_file_charbuf_bufsiz_tmpfnameFILE_P_tmpdir_wP_tmpdirL_tmpnamL_tmpnam_sL_ctermidL_cuseridSEEK_CURSEEK_ENDSEEK_SETFILENAME_MAXFOPEN_MAX_SYS_OPENTMP_MAX_TMP_MAX_SNULL_STDIO_DEFINED__iob_funcfpos_t__STDC___STDSTREAM_DEFINEDstdinstdoutstderr_IOREADx0001_IOWRTx0002_IOFBFx0000_IOLBFx0040_IONBFx0004_IOMYBUFx0008_IOEOFx0010_IOERRx0020_IOSTRG_IORWx0080_IOAPPENDx0200_TWO_DIGIT_EXPONENTx1_filbuf_File_flsbuf_Ch_fsopen_Filename_Mode_ShFlagclearerrclearerr_sfclose_fcloseallfdopen_FileHandle_fdopenfeofferrorfflushfgetc_fgetcharfgetpos_Posfgets_MaxCount_Buffileno_fileno_CRTDBG_MAP_ALLOCpush_macro_tempnam_DirName_FilePrefixpop_macro_flushallfopen_sfopenfprintf_Formatfprintf_sfputc_fputcharfputs_Strfread_ElementSize_Count_DstBuffread_s_DstSizefreopen_sfreopen_OldFilefscanf_sfscanf_fscanf_s_l_fscanf_l_Localefsetposfseek_Offset_Originftell_fseeki64_ftelli64fwritegetcgetchar_getmaxstdiogets_s_Buffergets_getw_CRT_PERROR_DEFINEDperror_ErrMsg_pclose_popen_Commandprintf_sputcputcharputs_putw_Word_CRT_DIRECTORY_DEFINEDremoverename_OldFilename_NewFilename_unlinkunlinkrewind_rmtmpscanf_sscanf_scanf_s_l_scanf_lsetvbufsetbuf_setmaxstdio_Max_set_output_format_get_output_format_snprintf_s_vsnprintf_s_Destsprintf_svsprintf_s_scprintfsscanf_ssscanf_sscanf_s_l_sscanf_l_snscanf_s_snscanf_snscanf_s_l_snscanf_ltmpfile_stmpfiletmpnam_stmpnamungetcvfprintfvfprintf_svprintfvprintf_svsnprintf_svsnprintf_snprintf_vsnprintfsprintfvsprintf_vscprintf_snprintf_c_vsnprintf_c_fprintf_p_printf_p_sprintf_p_vfprintf_p_vprintf_p_vsprintf_p_scprintf_p_vscprintf_p_set_printf_count_output_get_printf_count_output_printf_l_printf_p_l_printf_s_l_vprintf_l_vprintf_p_l_vprintf_s_l_fprintf_l_fprintf_p_l_fprintf_s_l_vfprintf_l_vfprintf_p_l_vfprintf_s_l_sprintf_s_l_sprintf_l_sprintf_p_l_vsprintf_s_l_vsprintf_l_vsprintf_p_l_scprintf_l_scprintf_p_l_vscprintf_l_vscprintf_p_l_snprintf_s_l_snprintf_l_snprintf_c_l_vsnprintf_s_l_vsnprintf_l_vsnprintf_c_l_WSTDIO_DEFINEDWEOFxFFFF_wfsopenfgetwc_fgetwcharfputwc_fputwchargetwcgetwcharputwcputwcharungetwcfgetws_SizeInWordsfputws_getws_swchar_t_getws_putwsfwprintffwprintf_swprintfwprintf_s_scwprintfvfwprintfvfwprintf_svwprintfvwprintf_sswprintf_svswprintf_s_swprintf_c_vswprintf_c_snwprintf_s_DstSizeInWords_vsnwprintf_s_snwprintf_vsnwprintf_fwprintf_p_wprintf_p_vfwprintf_p_vwprintf_p_swprintf_p_vswprintf_p_scwprintf_p_vscwprintf_p_wprintf_l_wprintf_p_l_wprintf_s_l_vwprintf_l_vwprintf_p_l_vwprintf_s_l_fwprintf_l_fwprintf_p_l_fwprintf_s_l_vfwprintf_l_vfwprintf_p_l_vfwprintf_s_l_swprintf_c_l_swprintf_p_l_swprintf_s_l_vswprintf_c_l_vswprintf_p_l_vswprintf_s_l_scwprintf_l_scwprintf_p_l_vscwprintf_p_l_snwprintf_s_l_snwprintf_l_vsnwprintf_s_l_vsnwprintf_l_CRT_NON_CONFORMING_SWPRINTFS_SWPRINTFS_DEPRECATED_swprintf_swprintf_s_vswprintf__swprintf_l__vswprintf_l_Plocinfoc:\archivos de programa\microsoft visual studio 8\vc\include\swprintf.inl_INC_SWPRINTF_INL_managedswprintf_Arglistvswprintf_Ap_swprintf_l_vswprintf_l_wtempnam_Directory_vscwprintf_vscwprintf_lfwscanf_sfwscanf_fwscanf_s_l_fwscanf_lswscanf_sswscanf_swscanf_s_l_swscanf_l_snwscanf_s_snwscanf_snwscanf_s_l_snwscanf_lwscanf_swscanf_wscanf_s_l_wscanf_l_wfdopen_wfopen_s_wfopen_wfreopen_s_wfreopen_CRT_WPERROR_DEFINED_wperror_wpopen_wremove_wtmpnam_s_wtmpnam_fgetwc_nolock_fputwc_nolock_ungetwc_nolock_CRT_GETPUTWCHAR_NOINLINE_c_C_stm_putwc_nolock_getwc_nolock_CRT_DISABLE_PERFCRIT_LOCKS_streamxff_fgetc_nolock_fputc_nolock_getc_nolock_putc_nolock_getchar_nolock_putchar_nolock_getwchar_nolock_putwchar_nolock_MT_lock_file_unlock_filec_fclose_nolock_fflush_nolock_fread_nolock_fread_nolock_s_fseek_nolock_ftell_nolock_fseeki64_nolock_ftelli64_nolock_fwrite_nolock_ungetc_nolock_offset_origin_buf_sizP_tmpdirSYS_OPENtempnamfcloseallfgetcharflushallfputchargetwputwrmtmp_wtmpnam_s<_Size>_vsnwprintf_s<_Size>_snwprintf_s<_Size>vswprintf_s<_Size>swprintf_s<_Size>_getws_s<_Size>vsprintf_s<_Size>_vsnprintf_s<_Size>tmpnam_s<_Size>sprintf_s<_Size>_snprintf_s<_Size>gets_s<_Size>_iobuf::_ptr_iobuf::_cnt_iobuf::_base_iobuf::_flag_iobuf::_file_iobuf::_charbuf_iobuf::_bufsiz_iobuf::_tmpfname_HAS_CONVENTIONAL_CLIB__using_declc:\archivos de programa\microsoft visual studio 8\vc\include\cstring_CSTRING_stringc:\archivos de programa\microsoft visual studio 8\vc\include\string.h_INC_STRING_NLSCMP_DEFINED_NLSCMPERROR_WConst_return_CRT_MEMORY_DEFINED_memccpy_Valmemchr_memicmp_Buf1_Buf2_memicmp_lmemcmpmemsetmemccpymemicmp_strset_s_strsetstrcpy_s_Sourcestrcpystrcat_sstrcatstrcmp_Str1_Str2strlenstrnlenstrnlen_s_strdupstrchr_stricmp_strcmpi_stricmp_lstrcoll_strcoll_l_stricoll_stricoll_l_strncoll_strncoll_l_strnicoll_strnicoll_lstrcspn_Control_strerror_s_strerror_SizeInBytes_ErrorMessagestrerror_sstrerror_ErrNum_strlwr_s_strlwr_strlwr_s_l_strlwr_lstrncat_sstrncatstrncmp_strnicmp_strnicmp_lstrncpy_sstrncpy_strnset_s_strnsetstrpbrkstrrchr_strrevstrspnstrstr_SubStrstrtok_sstrtok_Delim_Context_strupr_s_strupr_strupr_s_l_strupr_lstrxfrm_strxfrm_l_CPP_NARROW_INLINES_DEFINED_CPP_MEMCHR_DEFINED_N_Pvstrdupstrcmpistricmpstrlwrstrnicmpstrnsetstrrevstrsetstrupr_WSTRING_DEFINED_wcsdupwcscat_swcscatwcschrwcscmpwcscpy_swcscpywcscspnwcslenwcsnlenwcsnlen_swcsncat_swcsncatwcsncmpwcsncpy_swcsncpywcspbrkwcsrchrwcsspnwcsstrwcstok_swcstok_wcserror_s_wcserror_Error__wcserror_s__wcserror_wcsicmp_wcsicmp_l_wcsnicmp_wcsnicmp_l_wcsnset_s_wcsnset_wcsrev_wcsset_s_wcsset_wcslwr_s_wcslwr_wcslwr_s_l_wcslwr_l_wcsupr_s_wcsupr_wcsupr_s_l_size_wcsupr_lwcsxfrm_wcsxfrm_lwcscoll_wcscoll_l_wcsicoll_wcsicoll_l_wcsncoll_wcsncoll_l_wcsnicoll_wcsnicoll_l_CPP_WIDE_INLINES_DEFINEDwcsdupwcswcswcsicmpwcsnicmpwcsnsetwcsrevwcssetwcslwrwcsuprwcsicoll_wcsupr_s_l<_Size>_wcsupr_s<_Size>_wcslwr_s_l<_Size>_wcslwr_s<_Size>__wcserror_s<_Size>_wcserror_s<_Size>wcsncpy_s<_Size>wcsncat_s<_Size>wcscpy_s<_Size>wcscat_s<_Size>_strupr_s_l<_Size>_strupr_s<_Size>strncpy_s<_Size>strncat_s<_Size>_strlwr_s_l<_Size>_strlwr_s<_Size>strerror_s<_Size>_strerror_s<_Size>strcat_s<_Size>strcpy_s<_Size>c:\archivos de programa\microsoft visual studio 8\vc\include\cwchar_CWCHAR_wcharc:\archivos de programa\microsoft visual studio 8\vc\include\wchar.h_INC_WCHARWCHAR_MINWCHAR_MAXxffff_FSIZE_T_DEFINED_fsize_t_WFINDDATA_T_DEFINED_wfinddata32_tattribtime_createtime_accesstime_writename_wfinddata32i64_t_wfinddata64i32_t_wfinddata64_t_wfinddata_t_wfinddatai64_t_wfindfirst_wfindfirst32_wfindnext_wfindnext32_wfindfirsti64_wfindfirst32i64_wfindnexti64_wfindnext32i64_wfindfirst64i32_wfindnext64i32_wfindfirst64_wfindnext64_CRT_CTYPEDATA_DEFINED_CTYPE_DISABLE_MACROS__PCTYPE_FUNC_pctype__pctype_func_CRT_WCTYPEDATA_DEFINED_wctype__pwctype_func_pwctype_UPPER_LOWERx2_DIGITx4_SPACEx8_PUNCTx10_CONTROLx20_BLANKx40_HEXx80_LEADBYTEx8000_ALPHAx0100_WCTYPE_DEFINEDiswalpha_iswalpha_liswupper_iswupper_liswlower_iswlower_liswdigit_iswdigit_liswxdigit_iswxdigit_liswspace_iswspace_liswpunct_iswpunct_liswalnum_iswalnum_liswprint_iswprint_liswgraph_iswgraph_liswcntrl_iswcntrl_liswasciiisleadbyte_isleadbyte_ltowupper_towupper_ltowlower_towlower_liswctype_Type_iswctype_l__iswcsymf_iswcsymf_l__iswcsym_iswcsym_lis_wctype_WDIRECT_DEFINED_wgetcwd_wgetdcwd_wgetdcwd_nolock_wchdir_Path_wmkdir_wrmdir_WIO_DEFINED_waccess_AccessMode_waccess_s_wchmod_wsopen_s_wcreat_PermissionMode_FindData_FindHandle_wunlink_wrename_wmktemp_s_TemplateName_wmktemp_OpenFlag_ShareFlag_PermissionFlag_wopen_wsopen_WLOCALE_DEFINED_wsetlocale_Category_WPROCESS_DEFINED_wexecl_wexecle_wexeclp_wexeclpe_wexecv_wexecve_Env_wexecvp_wexecvpe_wspawnl_wspawnle_wspawnlp_wspawnlpe_wspawnv_wspawnve_wspawnvp_wspawnvpe_CRT_WSYSTEM_DEFINED_wsystem_WCTYPE_INLINE_DEFINED_CRT_WCTYPE_NOINLINE_p_INO_T_DEFINED_ino_tino_t_DEV_T_DEFINED_dev_tdev_t_OFF_T_DEFINED_off_toff_t_STAT_DEFINED_stat32st_devst_inost_modest_nlinkst_uidst_gidst_rdevst_sizest_atimest_mtimest_ctimestat_stat32i64_stat64i32_stat64__stat64_fstat_fstat32_fstati64_fstat32i64_stat_stati64_wstat_wstat32_wstati64_wstat32i64_fstat64i32_fstat64_wstat64i32_wstat64_WSTAT_DEFINED_Stat_WCONIO_DEFINED_cgetws_s_cgetws_getwch_getwche_putwch_WCh_ungetwch_cputws_cwprintf_cwprintf_s_cwscanf_s_cwscanf_cwscanf_s_l_cwscanf_l_vcwprintf_vcwprintf_s_cwprintf_p_vcwprintf_p_cwprintf_l_cwprintf_s_l_vcwprintf_l_vcwprintf_s_l_cwprintf_p_l_vcwprintf_p_l_putwch_nolock_getwch_nolock_getwche_nolock_ungetwch_nolockinl_WSTDLIB_DEFINED_itow_s_Radix_itow_ltow_s_ltow_ultow_s_ultowwcstod_EndPtr_wcstod_lwcstol_wcstol_lwcstoul_wcstoul_l_wdupenv_s_wgetenv_wgetenv_s_ReturnSize_BufferSizeInWords_wtof_wtof_l_wtoi_wtoi_l_wtol_wtol_l_i64tow_s_i65tow_s_i64tow_ui64tow_s_ui64tow_wtoi64_wtoi64_l_wcstoi64_wcstoi64_l_wcstoui64_wcstoui64_l_WSTDLIBP_DEFINED_wfullpath_FullPath_wmakepath_s_PathResult_ResultPath_wmakepath_wputenv_EnvString_wputenv_s_wsearchenv_s_EnvVar_wsearchenv_wsplitpath_s_wsplitpath_DriveSizeInWords_DirSizeInWords_FilenameSizeInWords_ExtSizeInWords_TM_DEFINEDtmtm_sectm_mintm_hourtm_mdaytm_montm_yeartm_wdaytm_ydaytm_isdst_WTIME_DEFINED_wasctime_s_wasctime_Tmstruct_Time_wctime32_s_wctime32wcsftime_wcsftime_l_wstrdate_s_wstrdate_wstrtime_s_wstrtime_wctime64_s_wctime64c:\archivos de programa\microsoft visual studio 8\vc\include\wtime.inl_INC_WTIME_INL_wctime_wctime_s_Wint_tbtowcmbrlen_Statembrtowc_DstCh_SrcChmbsrtowcs_s_Retval_PSrc_PSourcembsrtowcswcrtomb_swcrtombwcsrtombs_swcsrtombswctobfwide_F_Mmbsinit_Pwmemchr_Swmemcmp_S1_S2_N1wmemset_Suwcsrtombs_s<_Size>wcrtomb_s<_Size>mbsrtowcs_s<_Size>_wctime64_s<_Size>_wstrtime_s<_Size>_wstrdate_s<_Size>_wctime32_s<_Size>_wasctime_s<_Size>tm::tm_sectm::tm_mintm::tm_hourtm::tm_mdaytm::tm_montm::tm_yeartm::tm_wdaytm::tm_ydaytm::tm_isdst_wsplitpath_s<_DriveSize,_DirSize,_NameSize,_ExtSize>_wsearchenv_s<_Size>_wmakepath_s<_Size>_wgetenv_s<_Size>_ultow_s<_Size>_ltow_s<_Size>_itow_s<_Size>_cgetws_s<_Size>_stat64::st_dev_stat64::st_ino_stat64::st_mode_stat64::st_nlink_stat64::st_uid_stat64::st_gid_stat64::st_rdev_stat64::st_size_stat64::st_atime_stat64::st_mtime_stat64::st_ctime_stat64i32::st_dev_stat64i32::st_ino_stat64i32::st_mode_stat64i32::st_nlink_stat64i32::st_uid_stat64i32::st_gid_stat64i32::st_rdev_stat64i32::st_size_stat64i32::st_atime_stat64i32::st_mtime_stat64i32::st_ctime_stat32i64::st_dev_stat32i64::st_ino_stat32i64::st_mode_stat32i64::st_nlink_stat32i64::st_uid_stat32i64::st_gid_stat32i64::st_rdev_stat32i64::st_size_stat32i64::st_atime_stat32i64::st_mtime_stat32i64::st_ctimestat::st_devstat::st_inostat::st_modestat::st_nlinkstat::st_uidstat::st_gidstat::st_rdevstat::st_sizestat::st_atimestat::st_mtimestat::st_ctime_stat32::st_dev_stat32::st_ino_stat32::st_mode_stat32::st_nlink_stat32::st_uid_stat32::st_gid_stat32::st_rdev_stat32::st_size_stat32::st_atime_stat32::st_mtime_stat32::st_ctime_wmktemp_s<_Size>_wfinddata64_t::attrib_wfinddata64_t::time_create_wfinddata64_t::time_access_wfinddata64_t::time_write_wfinddata64_t::size_wfinddata64_t::name_wfinddata64i32_t::attrib_wfinddata64i32_t::time_create_wfinddata64i32_t::time_access_wfinddata64i32_t::time_write_wfinddata64i32_t::size_wfinddata64i32_t::name_wfinddata32i64_t::attrib_wfinddata32i64_t::time_create_wfinddata32i64_t::time_access_wfinddata32i64_t::time_write_wfinddata32i64_t::size_wfinddata32i64_t::name_wfinddata32_t::attrib_wfinddata32_t::time_create_wfinddata32_t::time_access_wfinddata32_t::time_write_wfinddata32_t::size_wfinddata32_t::namec:\archivos de programa\microsoft visual studio 8\vc\include\xstddef_XSTDDEF_yvalsc:\archivos de programa\microsoft visual studio 8\vc\include\cstddef_CSTDDEF_stddefc:\archivos de programa\microsoft visual studio 8\vc\include\stddef.h_INC_STDDEF_CRT_ERRNO_DEFINED_errnoerrno_set_errno_get_errnooffsetofsmvolatile__threadid_threadid__threadhandle_TRY_BEGINtry_CATCHcatch_CATCH_ALL_CATCH_END_RAISEthrow_RERAISE_THROW0_THROWy_THROW_NCEE_Throw_Raise_EMPTY_ARGUMENT_BITMASKEnumTytypedef_BITMASK_OPS_DESTRUCTORtyptr_MESG_PROTECTEDprotected_TDEF_TDEF2_STCONSvalstatic_MSC_EXTENSIONS_STCONSDEFclsselectany_XSTD_X_STD_BEGIN_X_STD_END_Uninitialized_Noinitc:\archivos de programa\microsoft visual studio 8\vc\include\crtdbg.h_INC_CRTDBG_HFILE_CRT_WARN_CRT_ERROR_CRT_ASSERT_CRT_ERRCNT_CRTDBG_MODE_FILE_CRTDBG_MODE_DEBUG_CRTDBG_MODE_WNDW_CRTDBG_REPORT_MODE_CRTDBG_INVALID_HFILE_CRTDBG_HFILE_ERROR_CRTDBG_FILE_STDOUT_CRTDBG_FILE_STDERR_CRTDBG_REPORT_FILE_CRT_REPORT_HOOK_CRT_REPORT_HOOKW_CRT_REPORT_HOOK_M_CRT_REPORT_HOOKW_M_CRT_RPTHOOK_INSTALL_CRT_RPTHOOK_REMOVE_HOOK_ALLOC_HOOK_REALLOC_HOOK_FREE_CRT_ALLOC_HOOK_CRT_ALLOC_HOOK_M_CRTDBG_ALLOC_MEM_DFx01_CRTDBG_DELAY_FREE_MEM_DFx02_CRTDBG_CHECK_ALWAYS_DFx04_CRTDBG_RESERVED_DFx08_CRTDBG_CHECK_CRT_DF_CRTDBG_LEAK_CHECK_DF_CRTDBG_CHECK_EVERY_16_DFx00100000_CRTDBG_CHECK_EVERY_128_DFx00800000_CRTDBG_CHECK_EVERY_1024_DFx04000000_CRTDBG_CHECK_DEFAULT_DF_CRTDBG_REPORT_FLAG_BLOCK_TYPEblock_BLOCK_SUBTYPE_FREE_BLOCK_NORMAL_BLOCK_CRT_BLOCK_IGNORE_BLOCK_CLIENT_BLOCK_MAX_BLOCKS_CRT_DUMP_CLIENT_CRT_DUMP_CLIENT_M_CrtMemBlockHeader_CrtMemStatepBlockHeaderlCountslSizeslHighWaterCountlTotalCount_STATIC_ASSERT__static_assert_t_ASSERT_ASSERT_EXPRexpr_str_ASSERT_BASE_RPT0rptnomsg_RPTW0_RPT1arg1_RPTW1_RPT2arg2_RPTW2_RPT3arg3_RPTW3_RPT4arg4_RPTW4_RPTF0_RPTFW0_RPTF1_RPTFW1_RPTF2_RPTFW2_RPTF3_RPTFW3_RPTF4_RPTFW4_malloc_dbgfl_calloc_dbgcalloc_realloc_dbgprealloc_recalloc_dbg_recalloc_expand_dbg_expand_free_dbgfree_msize_dbg_msize_aligned_malloc_dbga_aligned_malloc_aligned_realloc_dbg_aligned_realloc_aligned_recalloc_dbg_aligned_free_dbg_aligned_free_aligned_offset_malloc_dbgo_aligned_offset_malloc_aligned_offset_realloc_dbg_aligned_offset_realloc_aligned_offset_recalloc_dbg_aligned_offset_recalloc_malloca_dbg_malloca_freea_dbg_freea_strdup_dbg_wcsdup_dbg_mbsdup_dbg_mbsdup_tempnam_dbgs1s2_wtempnam_dbg_fullpath_dbgle_fullpath_wfullpath_dbg_getcwd_dbg_getcwd_wgetcwd_dbg_getdcwd_dbg_getdcwd_wgetdcwd_dbg_getdcwd_lk_dbg_getdcwd_nolock_wgetdcwd_lk_dbg_dupenv_s_dbgps1_dupenv_s_wdupenv_s_dbg_CrtSetReportHook_CrtGetReportHook_CrtSetReportHook2_CrtSetReportHookW2_CrtSetReportMode_CrtSetReportFile_CrtDbgBreak_CrtSetBreakAlloc_CrtSetAllocHook_CrtGetAllocHook_CrtCheckMemory_CrtSetDbgFlag_CrtDoForAllClientObjects_CrtIsValidPointer_CrtIsValidHeapPointer_CrtIsMemoryBlock_CrtReportBlockType_CrtSetDumpClient_CrtGetDumpClient_CrtMemCheckpoint_CrtMemDifferences3_CrtMemDumpAllObjectsSince_CrtMemDumpStatistics_CrtDumpMemoryLeaks_CrtSetDebugFillThreshold_CrtSetCheckCount_CrtGetCheckCount_crtAssertBusy_PFnNewHook_ReportType_ReportMode_ReportFile_CrtDbgReport_Linenumber_ModuleName_NewDebugFillThreshold_NATIVE_WCHAR_T_DEFINED_CrtDbgReportW_LineNumber_CRT_PORTABLE_RPT_BASEargs_RPT_BASE_W__debugbreak__breakintrinsicx80016_aligned_recallocgetcwd_crtBreakAlloc_BreakAlloc_BlockType_NumOfElements_SizeOfElements_NewSize_Memory_Alignment_PBufferSizeInBytes_PBuffer_PBufferSizeInWords_PfnNewHook_crtDbgFlag_NewFlag_PFn_Ptr_Bytes_ReadWrite_HeapPtr_RequestNumber_PFnNewDump_OldState_NewState_CheckCount_MFC_OVERRIDES_NEWoperator delete[]operator deleteoperator new[]operator new_CrtMemState::pBlockHeader_CrtMemState::lCounts_CrtMemState::lSizes_CrtMemState::lHighWaterCount_CrtMemState::lTotalCountstreamoffstreamsize_Fpz_BADOFF_Statetypefpos_Myt_Off_Myoff_Fpos_Mystate_Stz_Filepositionstateseekpos_Right_Tmp_POS_TYPE_FROM_STATEpostypeposition_POS_TYPE_TO_FPOS_Tpos_POS_TYPE_TO_STATEstreamposwstreampos_Unsecure_char_traits_tag_Secure_char_traits_tag_Char_traits_base_Secure_char_traits_Elemchar_traitschar_typeint_typepos_typeoff_typestate_typeassign_Lefteqltcompare_First1_First2_Firstcopy_Copy_s_Dest_size_Nextfindmove_Move_sto_char_type_Metato_int_typeeq_int_typeeofnot_eof_Size_in_words_Size_in_bytes_Traits_Inherits_from_char_traits_base_True_False_Dummy_Inherits_Make_traits_Exists_Char_traits_category_helper_Char_traits_category_Char_traits_cat_Secure_Traits_helpercopy_smove_s_Tyallocatorios_basebasic_iosistreambuf_iteratorostreambuf_iteratorbasic_streambufbasic_istreambasic_ostreambasic_iostream_Allocbasic_stringbufbasic_istringstreambasic_ostringstreambasic_stringstreambasic_filebufbasic_ifstreambasic_ofstreambasic_fstream_InItnum_get_OutItnum_putcollateiosstreambufistreamostreamiostreamstringbufistringstreamostringstreamstringstreamfilebufifstreamofstreamfstreamwioswstreambufwistreamwostreamwiostreamwstringbufwistringstreamwostringstreamwstringstreamwfilebufwifstreamwofstreamwfstreamnumgetwnumgetnumputwnumputncollatewcollatebasic_fstream<_Elem,_Traits>basic_ofstream<_Elem,_Traits>basic_ifstream<_Elem,_Traits>basic_filebuf<_Elem,_Traits>basic_stringstream<_Elem,_Traits,_Alloc>basic_ostringstream<_Elem,_Traits,_Alloc>basic_istringstream<_Elem,_Traits,_Alloc>basic_stringbuf<_Elem,_Traits,_Alloc>basic_iostream<_Elem,_Traits>basic_ostream<_Elem,_Traits>basic_istream<_Elem,_Traits>basic_streambuf<_Elem,_Traits>ostreambuf_iterator<_Elem,_Traits>istreambuf_iterator<_Elem,_Traits>basic_ios<_Elem,_Traits>allocator<_Ty>move_s<_Traits>copy_s<_Traits>_Char_traits_cat<_Traits>_Char_traits_category<_Traits>_Char_traits_category<_Traits>::_Secure_char_traits_Char_traits_category_helper<>_Char_traits_category_helper<_Traits,true>::_Secure_char_traits_Char_traits_category_helper,true>::_Secure_char_traits_Char_traits_category_helper<_Traits,_Inherits_from_char_traits_base>_Char_traits_category_helper<_Traits,_Inherits_from_char_traits_base>::_Secure_char_traits_Inherits_from_char_traits_base<_Traits>_Inherits_from_char_traits_base<_Traits>::_True_Inherits_from_char_traits_base<_Traits>::_False_Inherits_from_char_traits_base<_Traits>::_False::_Dummy_Inherits_from_char_traits_base<_Traits>::_Inherits_Inherits_from_char_traits_base<_Traits>::_Make_traits_Inherits_from_char_traits_base<_Traits>::__unnamed_003f_1_Inherits_from_char_traits_base::_Existschar_traits<>std::_Char_traits_base_Char_traits_base::_Secure_char_traitschar_traits::_Elemchar_traits::char_typechar_traits::int_typechar_traits::pos_typechar_traits::off_typechar_traits::state_typechar_traits::assignchar_traits::eqchar_traits::ltchar_traits::comparechar_traits::lengthchar_traits::copychar_traits::_Copy_schar_traits::findchar_traits::movechar_traits::_Move_schar_traits::to_char_typechar_traits::to_int_typechar_traits::eq_int_typechar_traits::eofchar_traits::not_eofchar_traits<__wchar_t>::_Elemchar_traits<__wchar_t>::char_typechar_traits<__wchar_t>::int_typechar_traits<__wchar_t>::pos_typechar_traits<__wchar_t>::off_typechar_traits<__wchar_t>::state_typechar_traits<__wchar_t>::assignchar_traits<__wchar_t>::eqchar_traits<__wchar_t>::ltchar_traits<__wchar_t>::comparechar_traits<__wchar_t>::lengthchar_traits<__wchar_t>::copychar_traits<__wchar_t>::_Copy_schar_traits<__wchar_t>::findchar_traits<__wchar_t>::movechar_traits<__wchar_t>::_Move_schar_traits<__wchar_t>::to_char_typechar_traits<__wchar_t>::to_int_typechar_traits<__wchar_t>::eq_int_typechar_traits<__wchar_t>::eofchar_traits<__wchar_t>::not_eofchar_traits<_Elem>char_traits<_Elem>::char_typechar_traits<_Elem>::int_typechar_traits<_Elem>::pos_typechar_traits<_Elem>::off_typechar_traits<_Elem>::state_typechar_traits<_Elem>::assignchar_traits<_Elem>::eqchar_traits<_Elem>::ltchar_traits<_Elem>::comparechar_traits<_Elem>::lengthchar_traits<_Elem>::copychar_traits<_Elem>::_Copy_schar_traits<_Elem>::findchar_traits<_Elem>::movechar_traits<_Elem>::_Move_schar_traits<_Elem>::to_char_typechar_traits<_Elem>::to_int_typechar_traits<_Elem>::eq_int_typechar_traits<_Elem>::eofchar_traits<_Elem>::not_eoffpos<_Statetype>::_Stzfpos<_Statetype>fpos<_Statetype>::_Mytfpos<_Statetype>::fposfpos<_Statetype>::statefpos<_Statetype>::seekposfpos<_Statetype>::operator std::streamofffpos<_Statetype>::operator -fpos<_Statetype>::operator +=fpos<_Statetype>::operator -=fpos<_Statetype>::operator +fpos<_Statetype>::operator ==fpos<_Statetype>::operator !=fpos<_Statetype>::_Myofffpos<_Statetype>::_Fposfpos<_Statetype>::_Mystate__GMP_WITHIN_CONFIGURE__GMP_BITS_PER_MP_LIMBSIZEOF_MP_LIMB_T_LONG_LONG_LIMBthewrongversionofgmp__GMP_CASTGMP_NUMB_MAXGMP_NAIL_MASK__GNU_MP____need_size_t_AIX__DECC__mips_SYSTYPE_SVR4__GMP_HAVE_CONST__GMP_HAVE_PROTOTYPES__GMP_HAVE_TOKEN_PASTE__gmp_const__gmp_signedsigned__GNUC____GMP_DECLSPEC_EXPORT__dllexport____GMP_DECLSPEC_IMPORT__dllimport____BORLANDC__dllexport__WATCOMC____export__import__IBMC___Export_Import__GMP_LIBGMP_DLL__GMP_WITHIN_GMP__GMP_DECLSPEC__GMP_SHORT_LIMBmp_limb_signed_t_mp_alloc_mp_size_mp_d__mpz_structMP_INTmpz_t_CRAY_CRAYMPP__GMP_MP_SIZE_T_INTmp_exp_t_mp_num_mp_den__mpq_structMP_RATmpq_t_mp_prec_mp_exp__mpf_structmpf_tGMP_RAND_ALG_DEFAULTGMP_RAND_ALG_LCgmp_randalg_t_mp_seed_mp_alg_mp_lc_mp_algdata__gmp_randstate_structgmp_randstate_tmpz_srcptrmpz_ptrmpf_srcptrmpf_ptrmpq_srcptrmpq_ptr__GMP_WITHIN_GMPXX__GMP_DECLSPEC_XX__GMP_PROTO__MPN__gmpn_H_STDIO_H_STDIO_STDIO_H_STDIO_H___STDIO_H__STDIO_H___STDIO_INCLUDED__dj_include_stdio_h___STDIO___MSL_STDIO_H_STDIO_H_INCLUDED_GMP_H_HAVE_FILE_OBSTACK_H_GMP_H_HAVE_OBSTACKva_start_GMP_H_HAVE_VA_LIST__GNUC_MINOR____GMP_GNUC_PREREQmajmin__GMP_NO_ATTRIBUTE_CONST_PURE__GMP_ATTRIBUTE_PURE__attribute____pure__typestatic_cast__GMP_NOTHROW__GMP_EXTERN_INLINE__inline____GMP_INLINE_PROTOTYPES__SCO_VERSION____GMP_WITHIN_CONFIGURE_INLINE__GMP_ABS__GMP_MAX__GMP_UINT_MAX__GMP_ULONG_MAX__GMP_USHRT_MAXshort__GMP_LIKELY__builtin_expect__GMP_UNLIKELY__GMP_CRAY_Pragma_Pragmampq_numrefQmpq_denrefmp_set_memory_functions__gmp_set_memory_functionsmp_get_memory_functions__gmp_get_memory_functionsmp_bits_per_limb__gmp_bits_per_limbgmp_errno__gmp_errnogmp_version__gmp_versiongmp_randinit__gmp_randinitgmp_randinit_default__gmp_randinit_defaultgmp_randinit_lc_2exp__gmp_randinit_lc_2expgmp_randinit_lc_2exp_size__gmp_randinit_lc_2exp_sizegmp_randinit_mt__gmp_randinit_mtgmp_randinit_set__gmp_randinit_setgmp_randseed__gmp_randseedgmp_randseed_ui__gmp_randseed_uigmp_randclear__gmp_randcleargmp_urandomb_ui__gmp_urandomb_uigmp_urandomm_ui__gmp_urandomm_uigmp_asprintf__gmp_asprintfgmp_fprintf__gmp_fprintfgmp_obstack_printf__gmp_obstack_printfobstackgmp_obstack_vprintf__gmp_obstack_vprintfgmp_printf__gmp_printfgmp_snprintf__gmp_snprintfgmp_sprintf__gmp_sprintfgmp_vasprintf__gmp_vasprintfgmp_vfprintf__gmp_vfprintfgmp_vprintf__gmp_vprintfgmp_vsnprintf__gmp_vsnprintfgmp_vsprintf__gmp_vsprintfgmp_fscanf__gmp_fscanfgmp_scanf__gmp_scanfgmp_sscanf__gmp_sscanfgmp_vfscanf__gmp_vfscanfgmp_vscanf__gmp_vscanfgmp_vsscanf__gmp_vsscanf_mpz_realloc__gmpz_reallocmpz_reallocmpz_abs__gmpz_abs__GMP_FORCE_mpz_absmpz_add__gmpz_addmpz_add_ui__gmpz_add_uimpz_addmul__gmpz_addmulmpz_addmul_ui__gmpz_addmul_uimpz_and__gmpz_andmpz_array_init__gmpz_array_initmpz_bin_ui__gmpz_bin_uimpz_bin_uiui__gmpz_bin_uiuimpz_cdiv_q__gmpz_cdiv_qmpz_cdiv_q_2exp__gmpz_cdiv_q_2expmpz_cdiv_q_ui__gmpz_cdiv_q_uimpz_cdiv_qr__gmpz_cdiv_qrmpz_cdiv_qr_ui__gmpz_cdiv_qr_uimpz_cdiv_r__gmpz_cdiv_rmpz_cdiv_r_2exp__gmpz_cdiv_r_2expmpz_cdiv_r_ui__gmpz_cdiv_r_uimpz_cdiv_ui__gmpz_cdiv_uimpz_clear__gmpz_clearmpz_clrbit__gmpz_clrbitmpz_cmp__gmpz_cmpmpz_cmp_d__gmpz_cmp_ddouble_mpz_cmp_si__gmpz_cmp_si_mpz_cmp_ui__gmpz_cmp_uimpz_cmpabs__gmpz_cmpabsmpz_cmpabs_d__gmpz_cmpabs_dmpz_cmpabs_ui__gmpz_cmpabs_uimpz_com__gmpz_commpz_combit__gmpz_combitmpz_congruent_p__gmpz_congruent_pmpz_congruent_2exp_p__gmpz_congruent_2exp_pmpz_congruent_ui_p__gmpz_congruent_ui_pmpz_divexact__gmpz_divexactmpz_divexact_ui__gmpz_divexact_uimpz_divisible_p__gmpz_divisible_pmpz_divisible_ui_p__gmpz_divisible_ui_pmpz_divisible_2exp_p__gmpz_divisible_2exp_pmpz_dump__gmpz_dumpmpz_export__gmpz_exportmpz_fac_ui__gmpz_fac_uimpz_fdiv_q__gmpz_fdiv_qmpz_fdiv_q_2exp__gmpz_fdiv_q_2expmpz_fdiv_q_ui__gmpz_fdiv_q_uimpz_fdiv_qr__gmpz_fdiv_qrmpz_fdiv_qr_ui__gmpz_fdiv_qr_uimpz_fdiv_r__gmpz_fdiv_rmpz_fdiv_r_2exp__gmpz_fdiv_r_2expmpz_fdiv_r_ui__gmpz_fdiv_r_uimpz_fdiv_ui__gmpz_fdiv_uimpz_fib_ui__gmpz_fib_uimpz_fib2_ui__gmpz_fib2_uimpz_fits_sint_p__gmpz_fits_sint_pmpz_fits_slong_p__gmpz_fits_slong_pmpz_fits_sshort_p__gmpz_fits_sshort_pmpz_fits_uint_p__gmpz_fits_uint_p__GMP_FORCE_mpz_fits_uint_pmpz_fits_ulong_p__gmpz_fits_ulong_p__GMP_FORCE_mpz_fits_ulong_pmpz_fits_ushort_p__gmpz_fits_ushort_p__GMP_FORCE_mpz_fits_ushort_pmpz_gcd__gmpz_gcdmpz_gcd_ui__gmpz_gcd_uimpz_gcdext__gmpz_gcdextmpz_get_d__gmpz_get_dmpz_get_d_2exp__gmpz_get_d_2expmpz_get_si__gmpz_get_simpz_get_str__gmpz_get_strmpz_get_ui__gmpz_get_ui__GMP_FORCE_mpz_get_uimpz_getlimbn__gmpz_getlimbn__GMP_FORCE_mpz_getlimbnmpz_hamdist__gmpz_hamdistmpz_import__gmpz_importmpz_init__gmpz_initmpz_init2__gmpz_init2mpz_init_set__gmpz_init_setmpz_init_set_d__gmpz_init_set_dmpz_init_set_si__gmpz_init_set_simpz_init_set_str__gmpz_init_set_strmpz_init_set_ui__gmpz_init_set_uimpz_inp_raw__gmpz_inp_rawmpz_inp_str__gmpz_inp_strmpz_invert__gmpz_invertmpz_ior__gmpz_iormpz_jacobi__gmpz_jacobimpz_kroneckermpz_kronecker_si__gmpz_kronecker_simpz_kronecker_ui__gmpz_kronecker_uimpz_si_kronecker__gmpz_si_kroneckermpz_ui_kronecker__gmpz_ui_kroneckermpz_lcm__gmpz_lcmmpz_lcm_ui__gmpz_lcm_uimpz_legendrempz_lucnum_ui__gmpz_lucnum_uimpz_lucnum2_ui__gmpz_lucnum2_uimpz_millerrabin__gmpz_millerrabinmpz_mod__gmpz_modmpz_mod_uimpz_mul__gmpz_mulmpz_mul_2exp__gmpz_mul_2expmpz_mul_si__gmpz_mul_simpz_mul_ui__gmpz_mul_uimpz_neg__gmpz_neg__GMP_FORCE_mpz_negmpz_nextprime__gmpz_nextprimempz_out_raw__gmpz_out_rawmpz_out_str__gmpz_out_strmpz_perfect_power_p__gmpz_perfect_power_pmpz_perfect_square_p__gmpz_perfect_square_p__GMP_FORCE_mpz_perfect_square_pmpz_popcount__gmpz_popcount__GMP_FORCE_mpz_popcountmpz_pow_ui__gmpz_pow_uimpz_powm__gmpz_powmmpz_powm_ui__gmpz_powm_uimpz_probab_prime_p__gmpz_probab_prime_pmpz_random__gmpz_randommpz_random2__gmpz_random2mpz_realloc2__gmpz_realloc2mpz_remove__gmpz_removempz_root__gmpz_rootmpz_rootrem__gmpz_rootremmpz_rrandomb__gmpz_rrandombmpz_scan0__gmpz_scan0mpz_scan1__gmpz_scan1mpz_set__gmpz_setmpz_set_d__gmpz_set_dmpz_set_f__gmpz_set_fmpz_set_q__gmpz_set_q__GMP_FORCE_mpz_set_qmpz_set_si__gmpz_set_simpz_set_str__gmpz_set_strmpz_set_ui__gmpz_set_uimpz_setbit__gmpz_setbitmpz_size__gmpz_size__GMP_FORCE_mpz_sizempz_sizeinbase__gmpz_sizeinbasempz_sqrt__gmpz_sqrtmpz_sqrtrem__gmpz_sqrtremmpz_sub__gmpz_submpz_sub_ui__gmpz_sub_uimpz_ui_sub__gmpz_ui_submpz_submul__gmpz_submulmpz_submul_ui__gmpz_submul_uimpz_swap__gmpz_swapmpz_tdiv_ui__gmpz_tdiv_uimpz_tdiv_q__gmpz_tdiv_qmpz_tdiv_q_2exp__gmpz_tdiv_q_2expmpz_tdiv_q_ui__gmpz_tdiv_q_uimpz_tdiv_qr__gmpz_tdiv_qrmpz_tdiv_qr_ui__gmpz_tdiv_qr_uimpz_tdiv_r__gmpz_tdiv_rmpz_tdiv_r_2exp__gmpz_tdiv_r_2expmpz_tdiv_r_ui__gmpz_tdiv_r_uimpz_tstbit__gmpz_tstbitmpz_ui_pow_ui__gmpz_ui_pow_uimpz_urandomb__gmpz_urandombmpz_urandomm__gmpz_urandommmpz_xor__gmpz_xormpz_eormpq_abs__gmpq_abs__GMP_FORCE_mpq_absmpq_add__gmpq_addmpq_canonicalize__gmpq_canonicalizempq_clear__gmpq_clearmpq_cmp__gmpq_cmp_mpq_cmp_si__gmpq_cmp_si_mpq_cmp_ui__gmpq_cmp_uimpq_div__gmpq_divmpq_div_2exp__gmpq_div_2expmpq_equal__gmpq_equalmpq_get_num__gmpq_get_nummpq_get_den__gmpq_get_denmpq_get_d__gmpq_get_dmpq_get_str__gmpq_get_strmpq_init__gmpq_initmpq_inp_str__gmpq_inp_strmpq_inv__gmpq_invmpq_mul__gmpq_mulmpq_mul_2exp__gmpq_mul_2expmpq_neg__gmpq_neg__GMP_FORCE_mpq_negmpq_out_str__gmpq_out_strmpq_set__gmpq_setmpq_set_d__gmpq_set_dmpq_set_den__gmpq_set_denmpq_set_f__gmpq_set_fmpq_set_num__gmpq_set_nummpq_set_si__gmpq_set_simpq_set_str__gmpq_set_strmpq_set_ui__gmpq_set_uimpq_set_z__gmpq_set_zmpq_sub__gmpq_submpq_swap__gmpq_swapmpf_abs__gmpf_absmpf_add__gmpf_addmpf_add_ui__gmpf_add_uimpf_ceil__gmpf_ceilmpf_clear__gmpf_clearmpf_cmp__gmpf_cmpmpf_cmp_d__gmpf_cmp_dmpf_cmp_si__gmpf_cmp_simpf_cmp_ui__gmpf_cmp_uimpf_div__gmpf_divmpf_div_2exp__gmpf_div_2expmpf_div_ui__gmpf_div_uimpf_dump__gmpf_dumpmpf_eq__gmpf_eqmpf_fits_sint_p__gmpf_fits_sint_pmpf_fits_slong_p__gmpf_fits_slong_pmpf_fits_sshort_p__gmpf_fits_sshort_pmpf_fits_uint_p__gmpf_fits_uint_pmpf_fits_ulong_p__gmpf_fits_ulong_pmpf_fits_ushort_p__gmpf_fits_ushort_pmpf_floor__gmpf_floormpf_get_d__gmpf_get_dmpf_get_d_2exp__gmpf_get_d_2expmpf_get_default_prec__gmpf_get_default_precmpf_get_prec__gmpf_get_precmpf_get_si__gmpf_get_simpf_get_str__gmpf_get_strmpf_get_ui__gmpf_get_uimpf_init__gmpf_initmpf_init2__gmpf_init2mpf_init_set__gmpf_init_setmpf_init_set_d__gmpf_init_set_dmpf_init_set_si__gmpf_init_set_simpf_init_set_str__gmpf_init_set_strmpf_init_set_ui__gmpf_init_set_uimpf_inp_str__gmpf_inp_strmpf_integer_p__gmpf_integer_pmpf_mul__gmpf_mulmpf_mul_2exp__gmpf_mul_2expmpf_mul_ui__gmpf_mul_uimpf_neg__gmpf_negmpf_out_str__gmpf_out_strmpf_pow_ui__gmpf_pow_uimpf_random2__gmpf_random2mpf_reldiff__gmpf_reldiffmpf_set__gmpf_setmpf_set_d__gmpf_set_dmpf_set_default_prec__gmpf_set_default_precmpf_set_prec__gmpf_set_precmpf_set_prec_raw__gmpf_set_prec_rawmpf_set_q__gmpf_set_qmpf_set_si__gmpf_set_simpf_set_str__gmpf_set_strmpf_set_ui__gmpf_set_uimpf_set_z__gmpf_set_zmpf_size__gmpf_sizempf_sqrt__gmpf_sqrtmpf_sqrt_ui__gmpf_sqrt_uimpf_sub__gmpf_submpf_sub_ui__gmpf_sub_uimpf_swap__gmpf_swapmpf_trunc__gmpf_truncmpf_ui_div__gmpf_ui_divmpf_ui_sub__gmpf_ui_submpf_urandomb__gmpf_urandombmpn_addadd__GMP_FORCE_mpn_addadd_1__GMP_FORCE_mpn_add_1add_nmpn_addmul_1addmul_1mpn_bdivmodbdivmodmpn_cmpcmp__GMP_FORCE_mpn_cmpmpn_divexact_by3mpn_divexact_by3cdivexact_by3cmpn_divmod_1nsizedlimbmpn_divremdivremdivrem_1divrem_2mpn_gcdgcdmpn_gcd_1gcd_1mpn_gcdextgcdextmpn_get_strget_strmpn_hamdisthamdistmpn_lshiftlshiftmpn_mod_1mod_1mpn_mulmulmpn_mul_1mul_1mpn_mul_nmul_nmpn_perfect_square_pperfect_square_pmpn_popcountpopcountmpn_pow_1pow_1mpn_preinv_mod_1preinv_mod_1mpn_randomrandommpn_random2random2mpn_rshiftrshiftmpn_scan0scan0mpn_scan1scan1mpn_set_strset_strmpn_sqrtremsqrtremmpn_subsub__GMP_FORCE_mpn_subsub_1__GMP_FORCE_mpn_sub_1sub_nmpn_submul_1submul_1mpn_tdiv_qrtdiv_qr__gmp_w__gmp_u__GMPZ_FITS_UTYPE_Pzmaxval__gmp_n__gmp_p__gmp_z__gmp_l__gmp_result__gmp_a__gmp_asize__gmp_usize__GMPN_AORScoutwpxpxsizeypysizeFUNCTIONTESTdo__gmp_i__gmp_xgoto__gmp_donewhile__GMPN_COPY_REST__GMPN_ADD__GMPN_SUB__GMPN_AORS_1OPCB__gmp_rforbreakelse__GMPN_ADDCB__GMPN_SUBCB__GMPN_ADD_1__GMPN_SUB_1__GMPN_CMPresult__gmp_y__GMPN_COPYstart__gmp_j__gmp_wp__gmp_xp__gmp_xsize__gmp_yp__gmp_ysize__gmp_c__gmp_dst__gmp_src__gmp_sizempz_sgnZmpf_sgnFmpq_sgnmpz_cmp_uiUI__builtin_constant_pmpz_cmp_siSImpq_cmp_uiNUIDUImpq_cmp_simpz_odd_pmpz_even_pmpn_divmoddsizempz_mdivmpz_mdivmodmpz_mmodmpz_mdiv_uimpz_mdivmod_uimpz_mmod_uimpz_divmpz_divmodmpz_div_uimpz_divmod_uimpz_div_2expmpz_mod_2expGMP_ERROR_NONEGMP_ERROR_UNSUPPORTED_ARGUMENTGMP_ERROR_DIVISION_BY_ZEROGMP_ERROR_SQRT_OF_NEGATIVEGMP_ERROR_INVALID_ARGUMENT__GNU_MP_VERSION__GNU_MP_VERSION_MINOR__GNU_MP_VERSION_PATCHLEVEL__unnamed_003e_6operator >>operator <<__gmpn_sub_1__gmpn_sub__gmpn_cmp__gmpn_add_1__gmpn_add__gmpn_tdiv_qr__gmpn_submul_1__gmpn_sub_n__gmpn_sqrtrem__gmpn_set_str__gmpn_scan1__gmpn_scan0__gmpn_rshift__gmpn_random2__gmpn_random__gmpn_preinv_mod_1__gmpn_pow_1__gmpn_popcount__gmpn_perfect_square_p__gmpn_mul_n__gmpn_mul_1__gmpn_mul__gmpn_mod_1__gmpn_lshift__gmpn_hamdist__gmpn_get_str__gmpn_gcdext__gmpn_gcd_1__gmpn_gcd__gmpn_divrem_2__gmpn_divrem_1__gmpn_divrem__gmpn_divexact_by3c__gmpn_bdivmod__gmpn_addmul_1__gmpn_add_n__unnamed_003e_5__unnamed_003e_5::_mp_seed__unnamed_003e_5::_mp_alg__unnamed_003e_5::__unnamed_003e_5_1__unnamed_003e_5::__unnamed_003e_5_1::_mp_lc__unnamed_003e_5::_mp_algdata__unnamed_003e_4__unnamed_003e_3__unnamed_003e_3::_mp_prec__unnamed_003e_3::_mp_size__unnamed_003e_3::_mp_exp__unnamed_003e_3::_mp_d__unnamed_003e_2__unnamed_003e_2::_mp_num__unnamed_003e_2::_mp_den__unnamed_003e_1__unnamed_003e_1::_mp_alloc__unnamed_003e_1::_mp_size__unnamed_003e_1::_mp_dOPERATION_popcountOPERATION_hamdist..\mpn\generic\popham.cconfig.hHAVE_FLOAT_HnegativeLIMBS_PER_DOUBLErprnDOUBLE_NAN_INF_ACTION__gmp_invalid_operationABS__gmp_extract_doubleALLOCPTRMPN_ZEROSIZc:\archivos de programa\microsoft visual studio 8\vc\include\math.h_INC_MATH__assembler_EXCEPTION_DEFINED_exceptionretval_COMPLEX_DEFINED_complexcomplex_DOMAIN_SING_OVERFLOW_UNDERFLOW_TLOSS_PLOSSEDOMERANGE_HUGEDoublePositiveInfinityHUGE_VAL_CRT_ABS_DEFINEDabs_Xlabsacosasinatanatan2_Y_SIGN_DEFINED_copysign_Number_Sign_chgsigncoscoshexpfabsfmodloglog10powsinsinhtantanhsqrt_CRT_ATOF_DEFINEDatof_atof_l_cabs_Complexceilfloorfrexp_hypot_j0_j1_jnldexp_CRT_MATHERR_DEFINED_matherr_Exceptmodf_y0_y1_yn_set_SSE2_enable_Flag_hypotfacosfasinfatanfatan2fcosfsinftanfcoshfsinhftanhfexpflogflog10fmodffpowf_Base_Expsqrtfceilffabsffloorffmodfldexpf_copysignf_chgsignf_logbf_nextafterf_finitef_isnanf_fpclassfacoslasinlatanlatan2lceillcoslcoshlexplfabslfloorlfmodlfrexpl_hypotlldexpllogllog10l_matherrlmodflpowlsinlsinhlsqrtltanltanhl_chgsignl_copysignlfrexpf_Di_DfDOMAINSINGOVERFLOWUNDERFLOWTLOSSPLOSSmatherrHUGEcabshypotj0j1jny0y1yn_Pow_int_Z_USE_MATH_DEFINES_MATH_DEFINES_DEFINEDM_EM_LOG2EM_LOG10EM_LN2M_LN10M_PIM_PI_2M_PI_4M_1_PIM_2_PIM_2_SQRTPIM_SQRT2M_SQRT1_2_Pow_int<_Ty>_complex::x_complex::y_exception::type_exception::name_exception::arg1_exception::arg2_exception::retvaldumbmp.cchars_per_limbchars_per_bit_exactlybig_basenormalization_stepsbig_base_invertedPOW2_Pulog2generatelimb_bitsnail_bitsbasenumb_bitstableexitatoic:\archivos de programa\microsoft visual studio 8\vc\include\stdlib.h_INC_STDLIBc:\archivos de programa\microsoft visual studio 8\vc\include\limits.h_INC_LIMITSCHAR_BITSCHAR_MINSCHAR_MAXUCHAR_MAX_CHAR_UNSIGNEDCHAR_MINCHAR_MAXMB_LEN_MAXSHRT_MINSHRT_MAXUSHRT_MAXINT_MININT_MAXUINT_MAXxffffffffLONG_MINLONG_MAXULONG_MAXxffffffffULLLONG_MAXi64LLONG_MINULLONG_MAXxffffffffffffffffui64_I8_MINi8_I8_MAX_UI8_MAXxffui8_I16_MINi16_I16_MAX_UI16_MAXxffffui16_I32_MINi32_I32_MAX_UI32_MAXxffffffffui32_I64_MIN_I64_MAX_UI64_MAX_I128_MINi128_I128_MAX_UI128_MAXxffffffffffffffffffffffffffffffffui128SIZE_MAXRSIZE_MAX_POSIX_ARG_MAX_POSIX_CHILD_MAX_POSIX_LINK_MAX_POSIX_MAX_CANON_POSIX_MAX_INPUT_POSIX_NAME_MAX_POSIX_NGROUPS_MAX_POSIX_OPEN_MAX_POSIX_PATH_MAX_POSIX_PIPE_BUF_POSIX_SSIZE_MAX_POSIX_STREAM_MAX_POSIX_TZNAME_MAXARG_MAXLINK_MAXMAX_CANONMAX_INPUTNAME_MAXNGROUPS_MAXOPEN_MAXPATH_MAXPIPE_BUFSSIZE_MAXSTREAM_MAXTZNAME_MAXEXIT_SUCCESSEXIT_FAILURE_ONEXIT_T_DEFINED_onexit_t_onexit_m_tonexit_t_DIV_T_DEFINED_div_tquotremdiv_t_ldiv_tldiv_t_CRT_DOUBLE_DEC_LDSUPPORTld_LDOUBLE_PTR_LD_CRT_DOUBLE_CRT_FLOAT_LONGDOUBLEld12_LDBL12RAND_MAXx7fffMB_CUR_MAX___mb_cur_max_func__mb_cur_max__p___mb_cur_max___mb_cur_max_l_func__maxb__min_MAX_PATH_MAX_DRIVE_MAX_DIR_MAX_FNAME_MAX_EXT_OUT_TO_DEFAULT_OUT_TO_STDERR_OUT_TO_MSGBOX_REPORT_ERRMODE_WRITE_ABORT_MSG_CALL_REPORTFAULT_MAX_ENV_purecall_handler_set_purecall_handler_Handler_get_purecall_handler_purecall_handler_m_invalid_parameter_handler_set_invalid_parameter_handler_get_invalid_parameter_handler_invalid_parameter_handler_m_Handlerh__doserrno_doserrno_set_doserrno_get_doserrno__sys_errlist_sys_errlist__sys_nerr_sys_nerr__p___argc__p___argv__p___wargv__p__environ__p__wenviron__p__pgmptr__p__wpgmptr__argc__argv__wargvenviron_environ_wenviron_get_pgmptr_pgmptr_get_wpgmptr_wpgmptr_get_fmode_fmode__p__fmode_set_fmode_PMode_get_osplatformGetVersionEx_osplatform_get_osver_osver_get_winver_winver_get_winmajor_winmajor_get_winminor_winminor__p__osplatform__p__osver__p__winver__p__winmajor__p__winminor_countof_Array_CountofType_SizeOfArray__countof_helper_CRT_TERMINATE_DEFINEDnoreturn_Code_exitabort_set_abort_behavior_Flags_Mask_abs64_atexit_m_appdomain_Func_atexit_m_Functionatexit_atoi_latol_atol_l_CRT_ALGO_DEFINEDbsearch_s_Key_PtFuncComparebsearchqsort_sqsort_byteswap_ushort_Short_byteswap_ulong_Long_byteswap_uint64_Int64div_Numerator_Denominatorgetenvgetenv_s_itoa_s_itoa_i64toa_s_i64toa_ui64toa_s_ui64toa_atoi64_atoi64_l_strtoi64_strtoi64_l_strtoui64_strtoui64_lldiv_A1_A2_ltoa_s_ltoamblen_mblen_l_mbstrlen_mbstrlen_l_mbstrnlen_mbstrnlen_lmbtowc_SrcSizeInBytes_mbtowc_lmbstowcs_s_PtNumOfCharConverted_SrcBufmbstowcs_mbstowcs_s_l_mbstowcs_lrand_CRT_RAND_Srand_s_RandomValue_set_error_modesrand_Seedstrtod_strtod_l_strtol_lstrtoul_strtoul_l_CRT_SYSTEM_DEFINEDsystem_ultoa_s_ultoawctomb_swctomb_MbCh_wctomb_s_l_wctomb_l_SizeConvertedwcstombs_s_DstSizeInBytes_MaxCountInByteswcstombs_wcstombs_s_l_wcstombs_l_CRT_ALLOCATION_DEFINED_CVTBUFSIZE_ecvt_s_NumOfDights_PtDec_PtSign_NumOfDigits_ecvt_fcvt_s_NumOfDec_fcvt_gcvt_s_gcvt_atodbl_Result_atoldbl_atoflt_atodbl_l_atoldbl_l_atoflt_l_lrotl_Shift_lrotr_makepath_s_makepath_onexit_m_appdomain_onexit_m_onexit_putenv_putenv_s_rotl_rotl64_rotr_rotr64_searchenv_s_searchenv_splitpath_s_splitpath_FilenameSize_swabSetErrorMode_seterrormodeBeep_beep_Frequency_DurationSleep_sleepmaxsys_errlistsys_nerrecvtfcvtgcvtitoaltoaputenvswabultoa_Dstbufonexit_splitpath_s<_DriveSize,_DirSize,_NameSize,_ExtSize>_searchenv_s<_Size>_makepath_s<_Size>_gcvt_s<_Size>_fcvt_s<_Size>_ecvt_s<_Size>_wcstombs_s_l<_Size>wcstombs_s<_Size>_ultoa_s<_Size>_mbstowcs_s_l<_Size>mbstowcs_s<_Size>_ltoa_s<_Size>_itoa_s<_Size>getenv_s<_Size>__countof_helper<_CountofType,_SizeOfArray>__unnamed_023a_5__unnamed_023a_5::ld12__unnamed_023a_4__unnamed_023a_4::x__unnamed_023a_3__unnamed_023a_3::f__unnamed_023a_2__unnamed_023a_2::x__unnamed_023a_1__unnamed_023a_1::ld_ldiv_t::quot_ldiv_t::rem_div_t::quot_div_t::remodd_productsgen_constsnumbnaillimbfirstfnumfib_limitluc_limitlimitfallocxmallocHAVE_CONSTsq_res_0x100nsq_res_0x100sq_res_0x100_numsq_res_0x100_fractionmod34_bitsmod_bitsmax_divisormax_divisor_bitstotal_fractionpppp_normpp_invertedmod_maskmod34_excuserawfactor_tdivisormultiplicityrawfactornrawfactorfactor_tinversemaskfractionfactornfactorfactor_allocf_cmp_divisorpargqargf_cmp_fractionCOLLAPSE_ELEMENTarrayidxnarraymem_copyimul_2exp_modneg_modsquare_maskgenerate_sq_res_0x100resgenerate_moduse_pplog2_ceilisprimenew_ppmpz_preinv_invertjcombinempz_invert_ui_2expprintmhimlofactor_t::divisorfactor_t::inversefactor_t::maskfactor_t::fractionrawfactor_t::divisorrawfactor_t::multiplicityc:\archivos de programa\microsoft visual studio 8\vc\include\ctype.h_INC_CTYPE_CTYPE_DEFINED_isctype_isctype_lisalpha_isalpha_lisupper_isupper_lislower_islower_lisdigit_isdigit_lisxdigit_isxdigit_lisspace_isspace_lispunct_ispunct_lisalnum_isalnum_lisprint_isprint_lisgraph_isgraph_liscntrl_iscntrl_ltouppertolower_tolower_tolower_l_toupper_toupper_l__isascii__toascii__iscsymf__iscsym_chvalidator__chvalidchk_chvalidator_l_chvalidchk_l_Char_ischartype_lx7f_iscsymf_l_iscsym_lisasciitoasciiiscsymfiscsymc:\archivos de programa\microsoft visual studio 8\vc\include\signal.h_INC_SIGNAL_SIG_ATOMIC_T_DEFINEDsig_atomic_tNSIGSIGINTSIGILLSIGFPESIGSEGVSIGTERMSIGBREAKSIGABRTSIGABRT_COMPATSIG_DFLSIG_IGNSIG_GETSIG_SGESIG_ACKSIG_ERR__pxcptinfoptrs_pxcptinfoptrssignal_SigNumraisec:\archivos de programa\microsoft visual studio 8\vc\include\float.h_INC_FLOATc:\archivos de programa\microsoft visual studio 8\vc\include\crtwrn.h_INC_CRTWRN__CRT_WARNING_Description_Id_CRTWRN_WNUMBER__CRTWRN_MESSAGE__CRTWRN_WNUMBER__VCCLRIT_DEPRECATED_CRTWRN_MESSAGE__VCCLRIT_DEPRECATED_vcclrit_CRTWRN_WNUMBER__EXPLICIT_KEYWORD_CRTWRN_MESSAGE__EXPLICIT_KEYWORDkeywordrecognized_CRTWRN_WNUMBER__NO_32BIT_TIME_T_CRTWRN_MESSAGE__NO_32BIT_TIME_Tignored_CRTWRN_WNUMBER__NO_SPECIAL_TRANSFER_CRTWRN_MESSAGE__NO_SPECIAL_TRANSFERSpecialtransfercontrolroutinesthisplatform_CRTWRN_WNUMBER__NO_ITERATOR_DEBUGGING_CRTWRN_MESSAGE__NO_ITERATOR_DEBUGGINGIteratordebugginginretailbuildsSetting_HAS_ITERATOR_DEBUGGING_CRT_MANAGED_FP_DEPRECATE_CRT_MANAGED_FP_NO_DEPRECATEDBL_DIGDBL_EPSILONeDBL_MANT_DIGDBL_MAXDBL_MAX_10_EXPDBL_MAX_EXPDBL_MINDBL_MIN_10_EXPDBL_MIN_EXP_DBL_RADIX_DBL_ROUNDSFLT_DIGFLT_EPSILONFLT_GUARDFLT_MANT_DIGFLT_MAXFLT_MAX_10_EXPFLT_MAX_EXPFLT_MINFLT_MIN_10_EXPFLT_MIN_EXPFLT_NORMALIZEFLT_RADIXFLT_ROUNDSLDBL_DIGLDBL_EPSILONLDBL_MANT_DIGLDBL_MAXLDBL_MAX_10_EXPLDBL_MAX_EXPLDBL_MINLDBL_MIN_10_EXPLDBL_MIN_EXP_LDBL_RADIXDBL_RADIX_LDBL_ROUNDSDBL_ROUNDS_clearfp_controlfp_s_controlfp_NewValue_set_controlfp_CurrentState_statusfp_fpreset_statusfp2_X86_status_SSE2_status_clear87_status87_SW_INEXACTx00000001_SW_UNDERFLOWx00000002_SW_OVERFLOWx00000004_SW_ZERODIVIDEx00000008_SW_INVALIDx00000010_SW_DENORMALx00080000_EM_AMBIGUIOUSx80000000_EM_AMBIGUOUS_MCW_EMx0008001f_EM_INEXACT_EM_UNDERFLOW_EM_OVERFLOW_EM_ZERODIVIDE_EM_INVALID_EM_DENORMAL_MCW_RCx00000300_RC_NEARx00000000_RC_DOWNx00000100_RC_UPx00000200_RC_CHOP_MCW_PCx00030000_PC_64_PC_53x00010000_PC_24x00020000_MCW_ICx00040000_IC_AFFINE_IC_PROJECTIVE_MCW_DNx03000000_DN_SAVE_DN_FLUSHx01000000_DN_FLUSH_OPERANDS_SAVE_RESULTSx02000000_DN_SAVE_OPERANDS_FLUSH_RESULTS_CW_DEFAULT_control87__control87_2_X86_cw_Sse2_cw__fpecode_fpecode_SW_UNEMULATED_SW_SQRTNEG_SW_STACKOVERFLOW_SW_STACKUNDERFLOWx0400_FPE_INVALIDx81_FPE_DENORMALx82_FPE_ZERODIVIDEx83_FPE_OVERFLOWx84_FPE_UNDERFLOWx85_FPE_INEXACTx86_FPE_UNEMULATEDx87_FPE_SQRTNEGx88_FPE_STACKOVERFLOWx8a_FPE_STACKUNDERFLOWx8b_FPE_EXPLICITGENx8c_scalb_logb_nextafter_finite_isnan_fpclass_scalbf_FPCLASS_SNAN_FPCLASS_QNAN_FPCLASS_NINF_FPCLASS_NN_FPCLASS_ND_FPCLASS_NZ_FPCLASS_PZ_FPCLASS_PD_FPCLASS_PN_FPCLASS_PINFclear87status87control87fpresetLDBL_RADIXLDBL_ROUNDSEM_AMBIGUIOUSEM_AMBIGUOUSMCW_EMEM_INVALIDEM_DENORMALEM_ZERODIVIDEEM_OVERFLOWEM_UNDERFLOWEM_INEXACTMCW_ICIC_AFFINEIC_PROJECTIVEMCW_RCRC_CHOPRC_UPRC_DOWNRC_NEARMCW_PCPC_24PC_53PC_64CW_DEFAULTSW_INVALIDSW_DENORMALSW_ZERODIVIDESW_OVERFLOWSW_UNDERFLOWSW_INEXACTSW_UNEMULATEDSW_SQRTNEGSW_STACKOVERFLOWSW_STACKUNDERFLOWFPE_INVALIDFPE_DENORMALFPE_ZERODIVIDEFPE_OVERFLOWFPE_UNDERFLOWFPE_INEXACTFPE_UNEMULATEDFPE_SQRTNEGFPE_STACKOVERFLOWFPE_STACKUNDERFLOWFPE_EXPLICITGENTIME_WITH_SYS_TIMEsystimeHAVE_SYS_TIME_Hc:\archivos de programa\microsoft visual studio 8\vc\include\time.h_INC_TIME_CLOCK_T_DEFINEDclock_tCLOCKS_PER_SEC_get_daylight__daylight_daylight_get_dstbias__dstbias_dstbias_get_timezone__timezone_timezone_get_tzname__tzname_tzname_Daylight_Daylight_savings_bias_Timezone_ReturnValue_Indexasctime_sasctime_ctime32_s_ctime32clock_difftime32_Time1_Time2_gmtime32_s_gmtime32_localtime32_s_localtime32strftime_strftime_l_Max_size_strdate_s_strdate_strtime_s_strtime_time32_mktime32_mkgmtime32tzset_tzset_difftime64_ctime64_s_ctime64_gmtime64_s_gmtime64_localtime64_s_localtime64_mktime64_mkgmtime64_time64GetLocalTime_getsystimeSetLocalTime_setsystime_MilliSecc:\archivos de programa\microsoft visual studio 8\vc\include\time.inl_INC_TIME_INLdifftimectime_sctimegmtime_sgmtimelocaltime_slocaltimemktime_mkgmtimeCLK_TCKdaylighttimezonetzname_ctime64_s<_Size>_strtime_s<_Size>_strdate_s<_Size>_ctime32_s<_Size>asctime_s<_Size>c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\tests\tests.h__TESTS_H__c:\archivos de programa\microsoft visual studio 8\vc\include\setjmp.h_INC_SETJMPsetjmpex_INC_SETJMPEXsetjmp_setjmp_JBLEN_JBTYPE__JUMP_BUFFEREbpEbxEdiEsiEspEipRegistrationTryLevelCookieUnwindFuncUnwindData_JUMP_BUFFER_SETJMP_FLOAT128LowPartHighPartSETJMP_FLOAT128iAReservedFltS0FltS1FltS2FltS3FltS4FltS5FltS6FltS7FltS8FltS9FltS10FltS11FltS12FltS13FltS14FltS15FltS16FltS17FltS18FltS19FPSRStIIPBrS0BrS1BrS2BrS3BrS4IntS0IntS1IntS2IntS3RsBSPRsPFSApUNATApLCIntSpIntNatsPredsPartFrameRbxRspRbpRsiRdiR12R13R14R15RipSpareXmm6Xmm7Xmm8Xmm9Xmm10Xmm11Xmm12Xmm13Xmm14Xmm15_JMP_BUF_DEFINEDjmp_buflongjmp__JUMP_BUFFER::Ebp__JUMP_BUFFER::Ebx__JUMP_BUFFER::Edi__JUMP_BUFFER::Esi__JUMP_BUFFER::Esp__JUMP_BUFFER::Eip__JUMP_BUFFER::Registration__JUMP_BUFFER::TryLevel__JUMP_BUFFER::Cookie__JUMP_BUFFER::UnwindFunc__JUMP_BUFFER::UnwindDataANYARGStests_starttests_endtests_memory_starttests_memory_endtests_allocatetests_reallocateold_sizenew_sizetests_freetests_free_nosizetests_memory_validtests_rand_starttests_rand_endtests_infinity_dtests_hardware_getroundtests_hardware_setroundtests_isinftests_dbl_mant_bitsx86_fldcwx86_fstcwtests_setjmp_sigfpetests_sigfpe_handlertests_sigfpe_targetRETSIGTYPEtests_sigfpe_doneHAVE_CALLING_CONVENTIONScalling_conventions_functioncalling_conventionscalling_conventions_checkCALLING_CONVENTIONSfunctionCALLING_CONVENTIONS_CHECKmp_trace_basemp_limb_tracempn_tracempn_traceampn_tracennummpn_trace_filefilenamempn_tracea_filempf_tracempq_tracempz_tracempz_tracenbyte_tracebyte_tracend_tracespinnerspinner_countspinner_wantedspinner_tickalign_pointer__gmp_allocate_func_alignedbytes__gmp_allocate_or_reallocateoldsizenewsize__gmp_allocate_strdupstrtouppers_origurandomcall_rand_algsmpf_set_str_or_abortmpq_set_str_or_abortmpz_erandombroprstatenbitsmpz_erandomb_nonzerompz_errandombmpz_errandomb_nonzerompz_init_set_nmpz_negrandommpz_pow2abs_pmpz_set_nmpz_set_str_or_abortmpn_diff_highestp1p2mpn_diff_lowestbyte_diff_highestbyte_diff_lowestref_addc_limbref_bswap_limbref_popc_limbref_subc_limbrefmpf_addrefmpf_add_ulprefmpf_fillvaluerefmpf_normalizerefmpf_set_prec_limbsprecrefmpf_set_overlaprefmpf_subrefmpf_validategotwantrefmpf_validate_divisionrefmpn_adds1sizes2sizerefmpn_add_1sprefmpn_add_nrefmpn_add_nccarryrefmpn_addlsh1_nrefmpn_addmul_1multiplierrefmpn_addmul_1crefmpn_addmul_2multrefmpn_addmul_3refmpn_addmul_4refmpn_addmul_5refmpn_addmul_6refmpn_addmul_7refmpn_addmul_8refmpn_addsub_nrefmpn_addsub_ncrefmpn_and_nrefmpn_andn_nrefmpn_big_baserefmpn_chars_per_limbrefmpn_clrbitrefmpn_cmprefmpn_cmp_allowzerorefmpn_cmp_twosizesrefmpn_com_nrefmpn_copyrefmpn_copyirefmpn_copydrefmpn_copy_extendwsizerefmpn_count_leading_zerosrefmpn_count_trailing_zerosrefmpn_divexact_by3refmpn_divexact_by3crefmpn_divmod_1refmpn_divmod_1crefmpn_divrem_1refmpn_divrem_1crefmpn_equal_anynailrefmpn_fillrefmpn_gcd_1refmpn_gcdgprefmpn_gcd_findarefmpn_get_strrefmpn_hamdistrefmpn_invert_limbrefmpn_ior_nrefmpn_iorn_nrefmpn_lshiftshiftrefmpn_lshift_or_copyrefmpn_lshift_or_copy_anyrefmpn_malloc_limbsrefmpn_malloc_limbs_alignedrefmpn_free_limbsrefmpn_msbonerefmpn_msbone_maskrefmpn_memdup_limbsrefmpn_mod_1refmpn_mod_1crefmpn_mod_34lsub1refmpn_mul_1refmpn_mul_1crefmpn_mul_2refmpn_mul_basecaseprodpusizevpvsizerefmpn_mul_anyrefmpn_mul_nrefmpn_nand_nrefmpn_nior_nrefmpn_neg_nrefmpn_normalizerefmpn_popcountrefmpn_preinv_divrem_1refmpn_preinv_mod_1divisor_inverserefmpn_randomrefmpn_random2refmpn_random_limbrefmpn_rsh1add_nrefmpn_rsh1sub_nrefmpn_rshiftrefmpn_rshift_or_copyrefmpn_rshift_or_copy_anyrefmpn_sb_divrem_mnrefmpn_scan0refmpn_scan1refmpn_setbitrefmpn_sqrrefmpn_sqrtremrefmpn_sub_ddmmssrefmpn_subrefmpn_sub_1refmpn_sub_nrefmpn_sub_ncrefmpn_sublsh1_nrefmpn_submul_1refmpn_submul_1crefmpn_tdiv_qrrefmpn_tstbitrefmpn_udiv_qrnndrefmpn_udiv_qrnnd_rrefmpn_umul_ppmmrefmpn_umul_ppmm_rrefmpn_xnor_nrefmpn_xor_nrefmpn_zerorefmpn_zero_extendrefmpn_zero_prefmpq_addwrefmpq_subrefmpz_combitrefmpz_hamdistrefmpz_kroneckera_origb_origrefmpz_jacobirefmpz_legendrerefmpz_kronecker_sirefmpz_kronecker_uirefmpz_si_kroneckerrefmpz_ui_kroneckerrefmpz_pow_uiHAVE_SSTREAMsstreamc:\archivos de programa\microsoft visual studio 8\vc\include\string_STRING_c:\archivos de programa\microsoft visual studio 8\vc\include\istream_ISTREAM_c:\archivos de programa\microsoft visual studio 8\vc\include\ostream_OSTREAM_c:\archivos de programa\microsoft visual studio 8\vc\include\ios_IOS_c:\archivos de programa\microsoft visual studio 8\vc\include\xlocnum_XLOCNUM_c:\archivos de programa\microsoft visual studio 8\vc\include\climits_CLIMITS_c:\archivos de programa\microsoft visual studio 8\vc\include\cstdlib_CSTDLIB_c:\archivos de programa\microsoft visual studio 8\vc\include\streambuf_STREAMBUF_c:\archivos de programa\microsoft visual studio 8\vc\include\xiosbase_XIOSBASE_c:\archivos de programa\microsoft visual studio 8\vc\include\xlocale_XLOCALE_c:\archivos de programa\microsoft visual studio 8\vc\include\stdexcept_STDEXCEPT_c:\archivos de programa\microsoft visual studio 8\vc\include\exception_EXCEPTION__CRT_EXCEPTION_NO_MALLOC_USE_EXusingset_terminateterminate_handlerterminateset_unexpectedunexpected_handlerunexpectedc:\archivos de programa\microsoft visual studio 8\vc\include\eh.h_INC_EHterminate_functionunexpected_function__terminate_function_m__terminate_handler_m__unexpected_function_m__unexpected_handler_m_EXCEPTION_POINTERS_se_translator_function_is_exception_typeoftype_info_ExceptionPtr_NewPtFunc_get_terminate_get_unexpected_set_se_translator__uncaught_exception_Zeroc:\archivos de programa\microsoft visual studio 8\vc\include\malloc.h_INC_MALLOC_HEAP_MAXREQxFFFFFFFFFFFFFFE0xFFFFFFE0_HEAPEMPTY_HEAPOK_HEAPBADBEGIN_HEAPBADNODE_HEAPEND_HEAPBADPTR_FREEENTRY_USEDENTRY_HEAPINFO_DEFINED_heapinfo_pentry_useflag_HEAPINFO_get_amblksiz_amblksiz__p__amblksiz_mm_free_mm_malloc_resetstkoflw_MAX_WAIT_MALLOC_CRT_set_malloc_crt_max_wait_alloca_get_sbh_threshold_set_sbh_threshold_set_amblksiz_heapadd_heapchk_heapmin_heapset_Fill_heapwalk_EntryInfo_heapused_Used_Commit_get_heap_handle_ALLOCA_S_THRESHOLD_ALLOCA_S_STACK_MARKERxCCCC_ALLOCA_S_HEAP_MARKERxDDDD_ALLOCA_S_MARKER_SIZE_MarkAllocaS_Markersuppress_FREEA_INLINEallocaHEAPHOOK_HEAPHOOK_DEFINED_HEAPHOOK_setheaphook_NewHook_HEAP_MALLOC_HEAP_CALLOC_HEAP_FREE_HEAP_REALLOC_HEAP_MSIZE_HEAP_EXPAND_heapinfo::_pentry_heapinfo::_size_heapinfo::_useflagtargets__exString_CRT_SECURE_STRCPYexception_m_what_m_doFree_What_Buf_size_Thatwhat_Prhand_uncaught_exception_muncaught_exception_Raise_handler_Set_raise_handler_Pnew_Pold_Message_Doraisebad_exception_bad_alloc_Messagebad_allocstd::exceptionexception::exceptionexception::operator =exception::~exceptionexception::whatexception::_m_whatexception::_m_doFreebad_alloc::bad_allocbad_alloc::~bad_allocbad_exception::bad_exceptionbad_exception::~bad_exceptionc:\archivos de programa\microsoft visual studio 8\vc\include\xstring_XSTRING_c:\archivos de programa\microsoft visual studio 8\vc\include\xmemory_XMEMORY_c:\archivos de programa\microsoft visual studio 8\vc\include\new_NEW__INC_NEWnew_handler__NOTHROW_T_DEFINEDnothrow_tset_new_handler__PLACEMENT_NEW_INLINE_Where__PLACEMENT_VEC_NEW_INLINEc:\archivos de programa\microsoft visual studio 8\vc\include\xutility_XUTILITY_c:\archivos de programa\microsoft visual studio 8\vc\include\utility_UTILITY_swap_Ty1_Ty2pairfirst_typesecond_typesecond_Val1_Val2_Other1_Other2make_pairrel_opsoperator >=<_Ty>operator >=operator <=<_Ty>operator <=operator ><_Ty>operator >operator !=<_Ty>operator !=swap<_Ty1,_Ty2>make_pair<_Ty1,_Ty2>operator >=<_Ty1,_Ty2>operator <=<_Ty1,_Ty2>operator ><_Ty1,_Ty2>operator <<_Ty1,_Ty2>operator <operator !=<_Ty1,_Ty2>operator ==<_Ty1,_Ty2>operator ==pair<_Ty1,_Ty2>pair<_Ty1,_Ty2>::_Mytpair<_Ty1,_Ty2>::first_typepair<_Ty1,_Ty2>::second_typepair<_Ty1,_Ty2>::pairpair<_Ty1,_Ty2>::swappair<_Ty1,_Ty2>::firstpair<_Ty1,_Ty2>::secondswap<_Ty>_Unchecked_iterator_tag_Range_checked_iterator_tag_Unchanged_checked_iterator_base_type_tag_Different_checked_iterator_base_type_tag_Undefined_inner_type_tag_Undefined_move_tag_Swap_move_tag_IGNORE_MYCONT_Container_base_IGNORE_MYITERLIST_Iterator_base_Debug_message_CLI_MEMORY_line_STRIZE_VAL_DEBUG_ERRORmesg_DEBUG_ERROR2filewlinew_Move_category_Myfirstiter_Orphan_all_Swap_all_Checked_iterator_category_Checked_iterator_base_type_Inner_type_Mycont_Mynextiter_Orphan_me_Adopt_Parent_Pnext_Iterator_base_secure_Temp_Iter_Debug_get_cont_DEBUG_LT_Debug_lt_Line_DEBUG_LT_PREDpred_Debug_lt_pred_Pr_Pred_ITERATOR_BASEinput_iterator_tagoutput_iterator_tagforward_iterator_tagbidirectional_iterator_tagrandom_access_iterator_tag_Int_iterator_tag_Float_iterator_tag_Nonscalar_ptr_iterator_tag_Scalar_ptr_iterator_tag_Diff_Pointer_Referenceiteratoriterator_categoryvalue_typedifference_typedistance_typepointerreference_Base_class_Iterator_with_base_Bidit_Ranit_Ranit_base_Outit_Outit_with_baseiterator_traits_Iter_cat_Cat_Cat1_Cat2_Iter_random_helper_Iter_random_cat_Cat3_Iter_random_helper3_Iter1_Iter2_Iter_random_Iter3_Cond_If_Secure_validation_helper_Inherits_from_iterator_base_Checked_iterator_category_helper_Checked_cat_Checked_iterator_base_helper2_Base_type_Checked_iterator_base_helper1_Base_type_tag_Checked_iterator_base_helper_Base_helper2_Base_helper1_Checked_iterator_base_type_tag_Base_tag_Checked_base_It_Checked_iterator_base_DstIter_BaseIter_Checked_assign_from_base_Checked_iterator_assign_from_base_DEFAULT_MOVE_OPERATION_CATEGORY_Move_operation_category_Move_cat_T1_T2_Checked_Cat1_Checked_Cat2_Ptr_cat_with_checked_cat_helper_Ptr_cat_Ptr_cat_helper_DEBUG_ORDER_IMPL_Debug_order_DEBUG_ORDER_SINGLE_IMPL_Debug_order_single_DEBUG_ORDERlast_DEBUG_ORDER_PRED_DEBUG_ORDER_SINGLEis_first_iteration_DEBUG_ORDER_SINGLE_PRED_DEBUG_POINTER_Debug_pointer_DEBUG_POINTER2_DEBUG_RANGE_Debug_range_DEBUG_RANGE2_Debug_range2_RanIt_Last_Debug_order2_FwdIt_Debug_order_single2_IsFirstIterationfile_CHECKED_CAT_CHECKED_BASE_CHECKED_BASE_TYPE_Iter_typetypename_ASSIGN_FROM_BASE_Val_typeadvance_Advance_FI_BI_RI_Dist_type_Distance2_BidItdistance_Distancereverse_iteratoriterator_typecurrent_Other_Equal_Less_Minus_RanIt1_RanIt2reverse_bidirectional_iterator_BidIt2_Revbidittraits_typestreambuf_typeistream_type_Sb_Strbuf_Got_Istrrdbuf_Peek_Incequalsbumpcsgetcostream_type_Failed_Ostrsputcfailed_InOutItCat_Copy_opt_First_dest_cat_PtrCat_MoveCatTy_Move_opt_Move_BidIt1_Copy_backward_optcopy_backward_Move_backward_opt_Move_backward_InIt1_InIt2_InItCats_Mismatch_Last1_Last2_InIt_catsmismatchfill_Fill_n_OutCat_First_catfill_n_Lexicographical_comparelexicographical_compare_Num1_Num2_Ans_cpp_max_cpp_min_MAX_MIN_IMPL_MAX_IMPL_MINunchecked_copychecked_copyunchecked_copy_backwardchecked_copy_backward_Unchecked_move_Checked_move_Unchecked_move_backward_Checked_move_backwardunchecked_fill_nchecked_fill_nunchecked_mismatchchecked_mismatchunchecked_equalchecked_equalchecked_equal<_InIt1,_InIt2,_Pr>unchecked_equal<_InIt1,_InIt2,_Pr>checked_equal<_InIt1,_InIt2>unchecked_equal<_InIt1,_InIt2>checked_mismatch<_InIt1,_InIt2,_Pr>unchecked_mismatch<_InIt1,_InIt2,_Pr>checked_mismatch<_InIt1,_InIt2>unchecked_mismatch<_InIt1,_InIt2>checked_fill_n<_OutIt,_Diff,_Ty>unchecked_fill_n<_OutIt,_Diff,_Ty>_Checked_move_backward<_BidIt1,_BidIt2>_Unchecked_move_backward<_BidIt1,_BidIt2>_Checked_move<_InIt,_OutIt>_Unchecked_move<_InIt,_OutIt>checked_copy_backward<_BidIt1,_BidIt2>unchecked_copy_backward<_BidIt1,_BidIt2>checked_copy<_InIt,_OutIt>unchecked_copy<_InIt,_OutIt>min<_Ty,_Pr>min<_Ty>max<_Ty,_Pr>max<_Ty>lexicographical_compare<_InIt1,_InIt2,_Pr>_Lexicographical_compare<_InIt1,_InIt2,_Pr>lexicographical_compare<_InIt1,_InIt2>_Lexicographical_compare<_InIt1,_InIt2>fill_n<_OutIt,_Diff,_Ty>_Fill_n<_OutIt,_Diff,_Ty,_OutCat>_Fill_n<_OutIt,_Diff,_Ty>fill<_FwdIt,_Ty>_Fill<_FwdIt,_Ty>equal<_InIt1,_InIt2,_Pr>_Equal<_InIt1,_InIt2,_Pr,_InItCats>_Equal<_InIt1,_InIt2,_Pr>equal<_InIt1,_InIt2>_Equal<_InIt1,_InIt2,_InItCats>_Equal<_InIt1,_InIt2>mismatch<_InIt1,_InIt2,_Pr>_Mismatch<_InIt1,_InIt2,_Pr,_InItCats>_Mismatch<_InIt1,_InIt2,_Pr>mismatch<_InIt1,_InIt2>_Mismatch<_InIt1,_InIt2,_InItCats>_Mismatch<_InIt1,_InIt2>_Move_backward<_BidIt1,_BidIt2>_Move_backward_opt<_BidIt1,_BidIt2,_InOutItCat,_MoveCatTy>_Move_backward_opt<_BidIt1,_BidIt2>_Move_backward_opt<_BidIt1,_BidIt2,_InOutItCat>copy_backward<_BidIt1,_BidIt2>_Copy_backward_opt<_BidIt1,_BidIt2,_InOutItCat,_Ty>_Copy_backward_opt<_InIt,_OutIt,_InOutItCat>_Copy_backward_opt<_InIt,_OutIt>_Copy_backward_opt<_BidIt1,_BidIt2,_InOutItCat>_Move<_InIt,_OutIt>_Move_opt<_InIt,_OutIt,_InOutItCat,_MoveCatTy>_Move_opt<_InIt,_OutIt,_InOutItCat>copy<_InIt,_OutIt>_Copy_opt<_InIt,_OutIt,_InOutItCat,_Ty>_Copy_opt<_InIt,_OutIt,_InOutItCat>_Copy_opt<_InIt,_OutIt>std::_Outit_with_base<_Iterator_base_secure>ostreambuf_iterator<_Elem,_Traits>::_Mytostreambuf_iterator<_Elem,_Traits>::char_typeostreambuf_iterator<_Elem,_Traits>::traits_typeostreambuf_iterator<_Elem,_Traits>::streambuf_typeostreambuf_iterator<_Elem,_Traits>::ostream_typeostreambuf_iterator<_Elem,_Traits>::_Checked_iterator_categoryostreambuf_iterator<_Elem,_Traits>::ostreambuf_iteratorostreambuf_iterator<_Elem,_Traits>::operator =ostreambuf_iterator<_Elem,_Traits>::operator *ostreambuf_iterator<_Elem,_Traits>::operator ++ostreambuf_iterator<_Elem,_Traits>::failedostreambuf_iterator<_Elem,_Traits>::_Failedostreambuf_iterator<_Elem,_Traits>::_Strbufoperator !=<_Elem,_Traits>operator ==<_Elem,_Traits>std::_Iterator_with_baseistreambuf_iterator<_Elem,_Traits>::_Mytistreambuf_iterator<_Elem,_Traits>::char_typeistreambuf_iterator<_Elem,_Traits>::traits_typeistreambuf_iterator<_Elem,_Traits>::streambuf_typeistreambuf_iterator<_Elem,_Traits>::istream_typeistreambuf_iterator<_Elem,_Traits>::int_typeistreambuf_iterator<_Elem,_Traits>::istreambuf_iteratoristreambuf_iterator<_Elem,_Traits>::operator *istreambuf_iterator<_Elem,_Traits>::operator ++istreambuf_iterator<_Elem,_Traits>::equalistreambuf_iterator<_Elem,_Traits>::_Incistreambuf_iterator<_Elem,_Traits>::_Peekistreambuf_iterator<_Elem,_Traits>::_Strbufistreambuf_iterator<_Elem,_Traits>::_Gotistreambuf_iterator<_Elem,_Traits>::_Val_Revbidit<_BidIt,_BidIt2>std::iterator::iterator_category,typename iterator_traits<_BidIt>::value_type,typename iterator_traits<_BidIt>::difference_type,typename iterator_traits<_BidIt>::pointer,typename iterator_traits<_BidIt>::reference>_Revbidit<_BidIt,_BidIt2>::_Myt_Revbidit<_BidIt,_BidIt2>::_Diff_Revbidit<_BidIt,_BidIt2>::_Pointer_Revbidit<_BidIt,_BidIt2>::_Reference_Revbidit<_BidIt,_BidIt2>::iterator_type_Revbidit<_BidIt,_BidIt2>::_Revbidit_Revbidit<_BidIt,_BidIt2>::base_Revbidit<_BidIt,_BidIt2>::operator *_Revbidit<_BidIt,_BidIt2>::operator ->_Revbidit<_BidIt,_BidIt2>::operator ++_Revbidit<_BidIt,_BidIt2>::operator --_Revbidit<_BidIt,_BidIt2>::operator ==_Revbidit<_BidIt,_BidIt2>::operator !=_Revbidit<_BidIt,_BidIt2>::currentreverse_bidirectional_iterator<_BidIt,_Ty,_Reference,_Pointer,_Diff>std::iteratorreverse_bidirectional_iterator<_BidIt,_Ty,_Reference,_Pointer,_Diff>::_Mytreverse_bidirectional_iterator<_BidIt,_Ty,_Reference,_Pointer,_Diff>::iterator_typereverse_bidirectional_iterator<_BidIt,_Ty,_Reference,_Pointer,_Diff>::reverse_bidirectional_iteratorreverse_bidirectional_iterator<_BidIt,_Ty,_Reference,_Pointer,_Diff>::basereverse_bidirectional_iterator<_BidIt,_Ty,_Reference,_Pointer,_Diff>::operator *reverse_bidirectional_iterator<_BidIt,_Ty,_Reference,_Pointer,_Diff>::operator ->reverse_bidirectional_iterator<_BidIt,_Ty,_Reference,_Pointer,_Diff>::operator ++reverse_bidirectional_iterator<_BidIt,_Ty,_Reference,_Pointer,_Diff>::operator --reverse_bidirectional_iterator<_BidIt,_Ty,_Reference,_Pointer,_Diff>::operator ==reverse_bidirectional_iterator<_BidIt,_Ty,_Reference,_Pointer,_Diff>::operator !=reverse_bidirectional_iterator<_BidIt,_Ty,_Reference,_Pointer,_Diff>::currentoperator >=<_RanIt1,_RanIt2>operator <=<_RanIt1,_RanIt2>operator ><_RanIt1,_RanIt2>operator <<_RanIt1,_RanIt2>operator !=<_RanIt1,_RanIt2>operator ==<_RanIt1,_RanIt2>operator -<_RanIt1,_RanIt2>operator -operator +<_RanIt,_Diff>operator +reverse_iterator<_RanIt>std::_Iterator_base_Iterator_base::_Checked_iterator_category_Iterator_base::_Checked_iterator_base_type_Iterator_base::_Inner_type_Iterator_base::_Iterator_base_Iterator_base::operator =_Iterator_base::~_Iterator_base_Iterator_base::_Adopt_Iterator_base::_Orphan_me_Iterator_base::_Mycont_Iterator_base::_Mynextiterreverse_iterator<_RanIt>::_Mytreverse_iterator<_RanIt>::iterator_categoryreverse_iterator<_RanIt>::value_typereverse_iterator<_RanIt>::difference_typereverse_iterator<_RanIt>::distance_typereverse_iterator<_RanIt>::pointerreverse_iterator<_RanIt>::referencereverse_iterator<_RanIt>::iterator_typereverse_iterator<_RanIt>::reverse_iteratorreverse_iterator<_RanIt>::basereverse_iterator<_RanIt>::typename std::_Checked_iterator_category<_RanIt>::_Checked_catreverse_iterator<_RanIt>::_Checked_iterator_base_typereverse_iterator<_RanIt>::_Checked_iterator_basereverse_iterator<_RanIt>::_Checked_iterator_assign_from_basereverse_iterator<_RanIt>::operator *reverse_iterator<_RanIt>::operator ->reverse_iterator<_RanIt>::operator ++reverse_iterator<_RanIt>::operator --reverse_iterator<_RanIt>::_Equal<_Other>reverse_iterator<_RanIt>::_Equalreverse_iterator<_RanIt>::operator +=reverse_iterator<_RanIt>::operator +reverse_iterator<_RanIt>::operator -=reverse_iterator<_RanIt>::operator -reverse_iterator<_RanIt>::operator []reverse_iterator<_RanIt>::_Less<_Other>reverse_iterator<_RanIt>::_Lessreverse_iterator<_RanIt>::_Minus<_Other>reverse_iterator<_RanIt>::_Minusreverse_iterator<_RanIt>::current_Distance<_InIt,_Diff>distance<_InIt>_Distance2<_RanIt,_Diff>_Distance2<_BidIt,_Diff>_Distance2<_FwdIt,_Diff>_Distance2<_InIt,_Diff>_Dist_type<_Iter>_Advance<_RI,_Diff>_Advance<_BI,_Diff>_Advance<_FI,_Diff>_Advance<_InIt,_Diff>advance<_InIt,_Diff>_Val_type<_Iter>_Debug_order_single<_InIt,_Pr>_Debug_order_single2<_FwdIt,_Pr>_Debug_order_single2<_InIt,_Pr>_Debug_order_single<_InIt>_Debug_order_single2<_FwdIt>_Debug_order_single2<_InIt>_Debug_order<_InIt,_Pr>_Debug_order2<_FwdIt,_Pr>_Debug_order2<_InIt,_Pr>_Debug_order<_InIt>_Debug_order2<_FwdIt>_Debug_order2<_InIt>_Debug_range<_InIt>_Debug_range2<_RanIt>_Debug_range2<_InIt>_Debug_pointer<_Ty>_Debug_pointer<_InIt>_Ptr_cat<_T1,_T2>_Ptr_cat_helper<>_Ptr_cat_helper<_Ty*const*,const _Ty**>::_Ptr_cat_Ptr_cat_helper<_Ty*const*,_Ty**>::_Ptr_cat_Ptr_cat_helper<_Ty**,const _Ty**>::_Ptr_cat_Ptr_cat_helper<_Ty**,_Ty**>::_Ptr_cat_Ptr_cat_helper::_Ptr_cat_Ptr_cat_helper::_Ptr_cat_Ptr_cat_helper::_Ptr_cat_Ptr_cat_helper<__int64*,__int64*>::_Ptr_cat_Ptr_cat_helper::_Ptr_cat_Ptr_cat_helper::_Ptr_cat_Ptr_cat_helper::_Ptr_cat_Ptr_cat_helper::_Ptr_cat_Ptr_cat_helper::_Ptr_cat_Ptr_cat_helper::_Ptr_cat_Ptr_cat_helper::_Ptr_cat_Ptr_cat_helper::_Ptr_cat_Ptr_cat_helper::_Ptr_cat_Ptr_cat_helper::_Ptr_cat_Ptr_cat_helper::_Ptr_cat_Ptr_cat_helper::_Ptr_cat_Ptr_cat_helper::_Ptr_cat_Ptr_cat_helper::_Ptr_cat_Ptr_cat_helper::_Ptr_cat_Ptr_cat_helper::_Ptr_cat_Ptr_cat_helper::_Ptr_cat_Ptr_cat_helper::_Ptr_cat_Ptr_cat_helper::_Ptr_cat_Ptr_cat_helper<__wchar_t*,__wchar_t*>::_Ptr_cat_Ptr_cat_helper::_Ptr_cat_Ptr_cat_helper::_Ptr_cat_Ptr_cat_helper::_Ptr_cat_Ptr_cat_helper::_Ptr_cat_Ptr_cat_helper::_Ptr_cat_Ptr_cat_helper::_Ptr_cat_Ptr_cat_helper::_Ptr_cat_Ptr_cat_helper<_Bool*,_Bool*>::_Ptr_cat_Ptr_cat_helper<_Undefined_inner_type_tag,_Undefined_inner_type_tag>::_Ptr_cat_Ptr_cat_helper<_Undefined_inner_type_tag,_T2>::_Ptr_cat_Ptr_cat_helper<_T1,_Undefined_inner_type_tag>::_Ptr_cat_Ptr_cat_with_checked_cat_helper<>_Ptr_cat_with_checked_cat_helper<_T1,_T2,_Range_checked_iterator_tag,_Range_checked_iterator_tag>::_Ptr_cat_Ptr_cat_with_checked_cat_helper<_T1,_T2,_Range_checked_iterator_tag,_Checked_Cat2>::_Ptr_cat_Ptr_cat_with_checked_cat_helper<_T1,_T2,_Checked_Cat1,_Range_checked_iterator_tag>::_Ptr_cat_Ptr_cat_helper<_T1,_T2>_Ptr_cat_helper<_T1,_T2>::_Ptr_cat_Ptr_cat_with_checked_cat_helper<_T1,_T2,_Checked_Cat1,_Checked_Cat2>_Ptr_cat_with_checked_cat_helper<_T1,_T2,_Checked_Cat1,_Checked_Cat2>::_Ptr_cat_Move_cat<_Iter>_Move_operation_category<_Value>_Move_operation_category<_Value>::_Move_cat_Checked_assign_from_base<_Iter>_Checked_assign_from_base<_DstIter,_BaseIter>_Checked_base<_Iter>_Checked_base<_Iter,_Base_tag>_Checked_iterator_base_helper<_Iter>_Checked_iterator_base_helper<_Iter>::_Base_helper2_Checked_iterator_base_helper<_Iter>::_Base_helper1_Checked_iterator_base_helper<_Iter>::_Checked_iterator_base_type_tag_Checked_iterator_base_helper<_Iter>::_Checked_iterator_base_type_Checked_iterator_base_helper1<>_Checked_iterator_base_helper1<_Iter,_Unchanged_checked_iterator_base_type_tag>::_Base_type_tag_Checked_iterator_base_helper1<_Iter,_Unchanged_checked_iterator_base_type_tag>::_Checked_iterator_base_type_Checked_iterator_base_helper1<_Iter,_Base_type>_Checked_iterator_base_helper1<_Iter,_Base_type>::_Base_type_tag_Checked_iterator_base_helper1<_Iter,_Base_type>::_Checked_iterator_base_type_Checked_iterator_base_helper2<>_Checked_iterator_base_helper2<_Iter,true>::_Checked_iterator_base_type_Checked_iterator_base_helper2<_Iter,_Inherits_from_iterator_base>_Checked_iterator_base_helper2<_Iter,_Inherits_from_iterator_base>::_Checked_iterator_base_type_Checked_cat<_Iter>_Checked_iterator_category<_Iter>_Checked_iterator_category<_Iter>::_Checked_cat_Checked_iterator_category_helper<>_Checked_iterator_category_helper<_Iter,true>::_Checked_cat_Checked_iterator_category_helper<_Iter,_Inherits_from_iterator_base>_Checked_iterator_category_helper<_Iter,_Inherits_from_iterator_base>::_Checked_cat_Secure_validation_helper<>_Secure_validation_helper::_Checked_iterator_category_Secure_validation_helper<_Secure_validation>_Secure_validation_helper<_Secure_validation>::_Checked_iterator_category_If<>_If::_Result_If<_Cond,_Ty1,_Ty2>_If<_Cond,_Ty1,_Ty2>::_Result_Iter_random<_Iter1,_Iter2,_Iter3>_Iter_random<_Iter1,_Iter2>_Iter_random_helper3<>_Iter_random_helper3::_Iter_random_cat_Iter_random_helper3<_Cat1,_Cat2,_Cat3>_Iter_random_helper3<_Cat1,_Cat2,_Cat3>::_Iter_random_cat_Iter_random_helper<>_Iter_random_helper::_Iter_random_cat_Iter_random_helper<_Cat1,_Cat2>_Iter_random_helper<_Cat1,_Cat2>::_Iter_random_cat_Iter_cat<_Iter>iterator_traits<>iterator_traits::iterator_categoryiterator_traits::value_typeiterator_traits::difference_typeiterator_traits::distance_typeiterator_traits::pointeriterator_traits::referenceiterator_traits<__int64>::iterator_categoryiterator_traits<__int64>::value_typeiterator_traits<__int64>::difference_typeiterator_traits<__int64>::distance_typeiterator_traits<__int64>::pointeriterator_traits<__int64>::referenceiterator_traits::iterator_categoryiterator_traits::value_typeiterator_traits::difference_typeiterator_traits::distance_typeiterator_traits::pointeriterator_traits::referenceiterator_traits::iterator_categoryiterator_traits::value_typeiterator_traits::difference_typeiterator_traits::distance_typeiterator_traits::pointeriterator_traits::referenceiterator_traits::iterator_categoryiterator_traits::value_typeiterator_traits::difference_typeiterator_traits::distance_typeiterator_traits::pointeriterator_traits::referenceiterator_traits::iterator_categoryiterator_traits::value_typeiterator_traits::difference_typeiterator_traits::distance_typeiterator_traits::pointeriterator_traits::referenceiterator_traits::iterator_categoryiterator_traits::value_typeiterator_traits::difference_typeiterator_traits::distance_typeiterator_traits::pointeriterator_traits::referenceiterator_traits::iterator_categoryiterator_traits::value_typeiterator_traits::difference_typeiterator_traits::distance_typeiterator_traits::pointeriterator_traits::referenceiterator_traits::iterator_categoryiterator_traits::value_typeiterator_traits::difference_typeiterator_traits::distance_typeiterator_traits::pointeriterator_traits::referenceiterator_traits::iterator_categoryiterator_traits::value_typeiterator_traits::difference_typeiterator_traits::distance_typeiterator_traits::pointeriterator_traits::referenceiterator_traits<__wchar_t>::iterator_categoryiterator_traits<__wchar_t>::value_typeiterator_traits<__wchar_t>::difference_typeiterator_traits<__wchar_t>::distance_typeiterator_traits<__wchar_t>::pointeriterator_traits<__wchar_t>::referenceiterator_traits::iterator_categoryiterator_traits::value_typeiterator_traits::difference_typeiterator_traits::distance_typeiterator_traits::pointeriterator_traits::referenceiterator_traits::iterator_categoryiterator_traits::value_typeiterator_traits::difference_typeiterator_traits::distance_typeiterator_traits::pointeriterator_traits::referenceiterator_traits::iterator_categoryiterator_traits::value_typeiterator_traits::difference_typeiterator_traits::distance_typeiterator_traits::pointeriterator_traits::referenceiterator_traits<_Bool>::iterator_categoryiterator_traits<_Bool>::value_typeiterator_traits<_Bool>::difference_typeiterator_traits<_Bool>::distance_typeiterator_traits<_Bool>::pointeriterator_traits<_Bool>::referenceiterator_traits::iterator_categoryiterator_traits::value_typeiterator_traits::difference_typeiterator_traits::distance_typeiterator_traits::pointeriterator_traits::referenceiterator_traits<_Ty*>::iterator_categoryiterator_traits<_Ty*>::value_typeiterator_traits<_Ty*>::difference_typeiterator_traits<_Ty*>::distance_typeiterator_traits<_Ty*>::pointeriterator_traits<_Ty*>::referenceiterator_traits<_Iter>iterator_traits<_Iter>::iterator_categoryiterator_traits<_Iter>::value_typeiterator_traits<_Iter>::difference_typeiterator_traits<_Iter>::distance_typeiterator_traits<_Iter>::pointeriterator_traits<_Iter>::reference_Outit_with_base<_Base_class>std::_Iterator_with_basestd::iterator_Ranit_base<_Ty,_Diff,_Pointer,_Reference,_Base_class>_Ranit_base<_Ty,_Diff,_Pointer,_Reference,_Base_class>::iterator_category_Ranit_base<_Ty,_Diff,_Pointer,_Reference,_Base_class>::value_type_Ranit_base<_Ty,_Diff,_Pointer,_Reference,_Base_class>::difference_type_Ranit_base<_Ty,_Diff,_Pointer,_Reference,_Base_class>::distance_type_Ranit_base<_Ty,_Diff,_Pointer,_Reference,_Base_class>::pointer_Ranit_base<_Ty,_Diff,_Pointer,_Reference,_Base_class>::reference_Ranit<_Ty,_Diff,_Pointer,_Reference>_Ranit<_Ty,_Diff,_Pointer,_Reference>::iterator_category_Ranit<_Ty,_Diff,_Pointer,_Reference>::value_type_Ranit<_Ty,_Diff,_Pointer,_Reference>::difference_type_Ranit<_Ty,_Diff,_Pointer,_Reference>::distance_type_Ranit<_Ty,_Diff,_Pointer,_Reference>::pointer_Ranit<_Ty,_Diff,_Pointer,_Reference>::reference_Bidit<_Ty,_Diff,_Pointer,_Reference>_Bidit<_Ty,_Diff,_Pointer,_Reference>::iterator_category_Bidit<_Ty,_Diff,_Pointer,_Reference>::value_type_Bidit<_Ty,_Diff,_Pointer,_Reference>::difference_type_Bidit<_Ty,_Diff,_Pointer,_Reference>::distance_type_Bidit<_Ty,_Diff,_Pointer,_Reference>::pointer_Bidit<_Ty,_Diff,_Pointer,_Reference>::reference_Iterator_with_base<_Category,_Ty,_Diff,_Pointer,_Reference,_Base_class>_Iterator_with_base<_Category,_Ty,_Diff,_Pointer,_Reference,_Base_class>::iterator_category_Iterator_with_base<_Category,_Ty,_Diff,_Pointer,_Reference,_Base_class>::value_type_Iterator_with_base<_Category,_Ty,_Diff,_Pointer,_Reference,_Base_class>::difference_type_Iterator_with_base<_Category,_Ty,_Diff,_Pointer,_Reference,_Base_class>::distance_type_Iterator_with_base<_Category,_Ty,_Diff,_Pointer,_Reference,_Base_class>::pointer_Iterator_with_base<_Category,_Ty,_Diff,_Pointer,_Reference,_Base_class>::referenceiterator<_Category,_Ty,_Diff,_Pointer,_Reference>iterator<_Category,_Ty,_Diff,_Pointer,_Reference>::iterator_categoryiterator<_Category,_Ty,_Diff,_Pointer,_Reference>::value_typeiterator<_Category,_Ty,_Diff,_Pointer,_Reference>::difference_typeiterator<_Category,_Ty,_Diff,_Pointer,_Reference>::distance_typeiterator<_Category,_Ty,_Diff,_Pointer,_Reference>::pointeriterator<_Category,_Ty,_Diff,_Pointer,_Reference>::referencestd::bidirectional_iterator_tagstd::forward_iterator_tagstd::input_iterator_tag_Debug_lt_pred<_Pr,_Ty1,_Ty2>_Debug_lt<_Ty1,_Ty2>_Debug_get_cont<_Iter>_Container_base::_Move_category_Container_base::_Container_base_Container_base::operator =_Container_base::~_Container_base_Container_base::_Orphan_all_Container_base::_Swap_all_Container_base::_Myfirstiter_FARQ_PDFT_SIZT_CPOINTER_XTArebindotherconst_pointer_CREFERENCE_Xconst_reference_POINTER_X_REFERENCE_X_Allocate_Construct_Vptr_Destroy_Allocator_base_Mybasesize_typeaddressdeallocateallocateconstructdestroymax_size_Destroy_range_Al_Destroy_range<_Ty,_Alloc>allocator<>allocator::_Tyallocator::pointerallocator::const_pointerallocator::value_typeallocator::rebind<_Other>allocator::rebindallocator::rebind<_Other>::otherallocator::allocatorallocator::operator =<_Other>allocator::operator =operator !=<_Ty,_Other>operator ==<_Ty,_Other>std::_Allocator_base<_Ty>allocator<_Ty>::_Mybaseallocator<_Ty>::value_typeallocator<_Ty>::pointerallocator<_Ty>::referenceallocator<_Ty>::const_pointerallocator<_Ty>::const_referenceallocator<_Ty>::size_typeallocator<_Ty>::difference_typeallocator<_Ty>::rebind<_Other>allocator<_Ty>::rebindallocator<_Ty>::rebind<_Other>::otherallocator<_Ty>::addressallocator<_Ty>::allocatorallocator<_Ty>::operator =<_Other>allocator<_Ty>::operator =allocator<_Ty>::deallocateallocator<_Ty>::allocateallocator<_Ty>::constructallocator<_Ty>::destroyallocator<_Ty>::max_size_Allocator_base<>_Allocator_base::value_type_Allocator_base<_Ty>_Allocator_base<_Ty>::value_type_Destroy<>_Destroy<_Ty>_Construct<_T1,_T2>_Allocate<_Ty>_DEFINE_DLL_OVERLOADS_NO_DEBUG_PLACEHOLDER_No_debug_placeholder_Axbasic_string_String_const_iterator_Mystring_Myptr_STRING_CONST_ITERATORconst_iterator_Pstring_Mysize_Compat_Xlen_String_iterator_STRING_ITERATOR_String_base_String_val_Alty_Alval_Dift_Tptr_Ctptr_Reft_STR_ITER_BASEitconst_reverse_iterator_Size_type_nosscl_Has_debug_it_DEFINE_EMPTY_STRING_CONSTRUCTOR_Tidy_Hdinpos_Roffappendreserveallocator_type_Num_Grow_Myres_Eos_Inside_Chassign_Appendreplaceenderase_Assignbegininsert_Pdif_Insert_Newsize_N0_Nm_Replacerbeginrendat_SpecialOffpush_backc_strdataresizecapacity_Newcapempty_Bxty_Tbx_Bx_Tlen_Tres_Uptrrfindfind_first_offind_last_offind_first_not_offind_last_not_ofsubstrget_allocator_BUF_SIZE_ALLOC_MASK_Copy_Oldlen_Newres_Trim_P2_P1_Builtwstringswap<_Elem,_Traits,_Alloc>basic_string<_Elem,_Traits,_Alloc>::npos_Move_operation_category<>_Move_operation_category >::_Move_catbasic_string<_Elem,_Traits,_Ax>std::_String_val<_Elem,_Ax>basic_string<_Elem,_Traits,_Ax>::_Mytbasic_string<_Elem,_Traits,_Ax>::_Mybasebasic_string<_Elem,_Traits,_Ax>::_Allocbasic_string<_Elem,_Traits,_Ax>::size_typebasic_string<_Elem,_Traits,_Ax>::_Diftbasic_string<_Elem,_Traits,_Ax>::difference_typebasic_string<_Elem,_Traits,_Ax>::_Tptrbasic_string<_Elem,_Traits,_Ax>::_Ctptrbasic_string<_Elem,_Traits,_Ax>::pointerbasic_string<_Elem,_Traits,_Ax>::const_pointerbasic_string<_Elem,_Traits,_Ax>::_Reftbasic_string<_Elem,_Traits,_Ax>::referencebasic_string<_Elem,_Traits,_Ax>::const_referencebasic_string<_Elem,_Traits,_Ax>::value_typebasic_string<_Elem,_Traits,_Ax>::iteratorbasic_string<_Elem,_Traits,_Ax>::const_iteratorbasic_string<_Elem,_Traits,_Ax>::reverse_iteratorbasic_string<_Elem,_Traits,_Ax>::const_reverse_iteratorbasic_string<_Elem,_Traits,_Ax>::basic_stringbasic_string<_Elem,_Traits,_Ax>::_Construct<_It>basic_string<_Elem,_Traits,_Ax>::_Constructbasic_string<_Elem,_Traits,_Ax>::~basic_stringbasic_string<_Elem,_Traits,_Ax>::traits_typebasic_string<_Elem,_Traits,_Ax>::allocator_typebasic_string<_Elem,_Traits,_Ax>::nposbasic_string<_Elem,_Traits,_Ax>::operator =basic_string<_Elem,_Traits,_Ax>::operator +=basic_string<_Elem,_Traits,_Ax>::appendbasic_string<_Elem,_Traits,_Ax>::append<_It>basic_string<_Elem,_Traits,_Ax>::_Append<_It>basic_string<_Elem,_Traits,_Ax>::_Appendbasic_string<_Elem,_Traits,_Ax>::assignbasic_string<_Elem,_Traits,_Ax>::assign<_It>basic_string<_Elem,_Traits,_Ax>::_Assign<_It>basic_string<_Elem,_Traits,_Ax>::_Assignbasic_string<_Elem,_Traits,_Ax>::insertbasic_string<_Elem,_Traits,_Ax>::insert<_It>basic_string<_Elem,_Traits,_Ax>::_Insert<_It>basic_string<_Elem,_Traits,_Ax>::_Insertbasic_string<_Elem,_Traits,_Ax>::erasebasic_string<_Elem,_Traits,_Ax>::clearbasic_string<_Elem,_Traits,_Ax>::replacebasic_string<_Elem,_Traits,_Ax>::replace<_It>basic_string<_Elem,_Traits,_Ax>::_Replace<_It>basic_string<_Elem,_Traits,_Ax>::_Replacebasic_string<_Elem,_Traits,_Ax>::beginbasic_string<_Elem,_Traits,_Ax>::endbasic_string<_Elem,_Traits,_Ax>::rbeginbasic_string<_Elem,_Traits,_Ax>::rendbasic_string<_Elem,_Traits,_Ax>::atbasic_string<_Elem,_Traits,_Ax>::operator []basic_string<_Elem,_Traits,_Ax>::push_backbasic_string<_Elem,_Traits,_Ax>::c_strbasic_string<_Elem,_Traits,_Ax>::databasic_string<_Elem,_Traits,_Ax>::lengthbasic_string<_Elem,_Traits,_Ax>::sizebasic_string<_Elem,_Traits,_Ax>::max_sizebasic_string<_Elem,_Traits,_Ax>::resizebasic_string<_Elem,_Traits,_Ax>::capacitybasic_string<_Elem,_Traits,_Ax>::reservebasic_string<_Elem,_Traits,_Ax>::emptybasic_string<_Elem,_Traits,_Ax>::copybasic_string<_Elem,_Traits,_Ax>::_Copy_sbasic_string<_Elem,_Traits,_Ax>::swapbasic_string<_Elem,_Traits,_Ax>::findbasic_string<_Elem,_Traits,_Ax>::rfindbasic_string<_Elem,_Traits,_Ax>::find_first_ofbasic_string<_Elem,_Traits,_Ax>::find_last_ofbasic_string<_Elem,_Traits,_Ax>::find_first_not_ofbasic_string<_Elem,_Traits,_Ax>::find_last_not_ofbasic_string<_Elem,_Traits,_Ax>::substrbasic_string<_Elem,_Traits,_Ax>::comparebasic_string<_Elem,_Traits,_Ax>::get_allocatorbasic_string<_Elem,_Traits,_Ax>::__unnamed_0256_1basic_string::_BUF_SIZEbasic_string<_Elem,_Traits,_Ax>::__unnamed_0256_2basic_string::_ALLOC_MASKbasic_string<_Elem,_Traits,_Ax>::_Chassignbasic_string<_Elem,_Traits,_Ax>::_Copybasic_string<_Elem,_Traits,_Ax>::_Eosbasic_string<_Elem,_Traits,_Ax>::_Growbasic_string<_Elem,_Traits,_Ax>::_Insidebasic_string<_Elem,_Traits,_Ax>::_Pdifbasic_string<_Elem,_Traits,_Ax>::_Tidybasic_string<_Elem,_Traits,_Ax>::_Bxtybasic_string<_Elem,_Traits,_Ax>::_Bxty::_Bufbasic_string<_Elem,_Traits,_Ax>::_Bxty::_Ptrbasic_string<_Elem,_Traits,_Ax>::_Bxbasic_string<_Elem,_Traits,_Ax>::_Myptrbasic_string<_Elem,_Traits,_Ax>::_Mysizebasic_string<_Elem,_Traits,_Ax>::_Myres_String_val<_Ty,_Alloc>std::_String_basestd::_Container_base_String_base::_Xlen_String_base::_Xran_String_base::_Xinvarg_String_val<_Ty,_Alloc>::_Alty_String_val<_Ty,_Alloc>::_String_val_String_val<_Ty,_Alloc>::_Alvaloperator +<_Elem,_Traits,_Alloc>_String_iterator<_Elem,_Traits,_Alloc>std::_String_const_iterator<_Elem,_Traits,_Alloc>_String_iterator<_Elem,_Traits,_Alloc>::_Myt_String_iterator<_Elem,_Traits,_Alloc>::_Mybase_String_iterator<_Elem,_Traits,_Alloc>::iterator_category_String_iterator<_Elem,_Traits,_Alloc>::value_type_String_iterator<_Elem,_Traits,_Alloc>::difference_type_String_iterator<_Elem,_Traits,_Alloc>::pointer_String_iterator<_Elem,_Traits,_Alloc>::reference_String_iterator<_Elem,_Traits,_Alloc>::_String_iterator_String_iterator<_Elem,_Traits,_Alloc>::operator *_String_iterator<_Elem,_Traits,_Alloc>::operator ->_String_iterator<_Elem,_Traits,_Alloc>::operator ++_String_iterator<_Elem,_Traits,_Alloc>::operator --_String_iterator<_Elem,_Traits,_Alloc>::operator +=_String_iterator<_Elem,_Traits,_Alloc>::operator +_String_iterator<_Elem,_Traits,_Alloc>::operator -=_String_iterator<_Elem,_Traits,_Alloc>::operator -_String_iterator<_Elem,_Traits,_Alloc>::operator []_String_const_iterator<_Elem,_Traits,_Alloc>std::_Ranit_base<_Elem,typename _Alloc::difference_type,typename _Alloc::const_pointer,typename _Alloc::const_reference,_Iterator_base_secure>_String_const_iterator<_Elem,_Traits,_Alloc>::_Myt_String_const_iterator<_Elem,_Traits,_Alloc>::_Mystring_String_const_iterator<_Elem,_Traits,_Alloc>::iterator_category_String_const_iterator<_Elem,_Traits,_Alloc>::value_type_String_const_iterator<_Elem,_Traits,_Alloc>::difference_type_String_const_iterator<_Elem,_Traits,_Alloc>::pointer_String_const_iterator<_Elem,_Traits,_Alloc>::reference_String_const_iterator<_Elem,_Traits,_Alloc>::_Checked_iterator_category_String_const_iterator<_Elem,_Traits,_Alloc>::_String_const_iterator_String_const_iterator<_Elem,_Traits,_Alloc>::operator *_String_const_iterator<_Elem,_Traits,_Alloc>::operator ->_String_const_iterator<_Elem,_Traits,_Alloc>::operator ++_String_const_iterator<_Elem,_Traits,_Alloc>::operator --_String_const_iterator<_Elem,_Traits,_Alloc>::operator +=_String_const_iterator<_Elem,_Traits,_Alloc>::operator +_String_const_iterator<_Elem,_Traits,_Alloc>::operator -=_String_const_iterator<_Elem,_Traits,_Alloc>::operator -_String_const_iterator<_Elem,_Traits,_Alloc>::operator []_String_const_iterator<_Elem,_Traits,_Alloc>::operator ==_String_const_iterator<_Elem,_Traits,_Alloc>::operator !=_String_const_iterator<_Elem,_Traits,_Alloc>::operator <_String_const_iterator<_Elem,_Traits,_Alloc>::operator >_String_const_iterator<_Elem,_Traits,_Alloc>::operator <=_String_const_iterator<_Elem,_Traits,_Alloc>::operator >=_String_const_iterator<_Elem,_Traits,_Alloc>::_Compat_String_const_iterator<_Elem,_Traits,_Alloc>::_Xlen_String_const_iterator<_Elem,_Traits,_Alloc>::_Xran_String_const_iterator<_Elem,_Traits,_Alloc>::_Xinvarg_String_const_iterator<_Elem,_Traits,_Alloc>::_Myptrlogic_errordomain_errorinvalid_argumentlength_errorout_of_rangeruntime_erroroverflow_errorunderflow_errorrange_errorstd::runtime_errorruntime_error::runtime_errorruntime_error::~runtime_errorruntime_error::whatruntime_error::_Strrange_error::range_errorrange_error::~range_errorunderflow_error::underflow_errorunderflow_error::~underflow_erroroverflow_error::overflow_erroroverflow_error::~overflow_errorstd::logic_errorlogic_error::logic_errorlogic_error::~logic_errorlogic_error::whatlogic_error::_Strout_of_range::out_of_rangeout_of_range::~out_of_rangelength_error::length_errorlength_error::~length_errorinvalid_argument::invalid_argumentinvalid_argument::~invalid_argumentdomain_error::domain_errordomain_error::~domain_errorc:\archivos de programa\microsoft visual studio 8\vc\include\typeinfo_TYPEINFO_requirescompiler__type_info_nodememPtrnext__type_info_root_noderhsbefore__ptype_info_noderaw_name_m_data_m_d_name_Name_base_Type_info_dtorbad_castbad_typeid__non_rtti_objectstd::bad_typeidbad_typeid::bad_typeidbad_typeid::~bad_typeid__non_rtti_object::__non_rtti_object__non_rtti_object::~__non_rtti_objectbad_cast::bad_castbad_cast::~bad_casttype_info::~type_infotype_info::operator ==type_info::operator !=type_info::beforetype_info::nametype_info::raw_nametype_info::_m_datatype_info::_m_d_nametype_info::type_infotype_info::operator =type_info::_Name_basetype_info::_Type_info_dtor__type_info_node::memPtr__type_info_node::nextc:\archivos de programa\microsoft visual studio 8\vc\include\xdebug_XDEBUG__DebugHeapTag_t_NEW_CRTnew_DebugHeapTag_func_DELETE_CRT_DebugHeapDelete_DELETE_CRT_VEC_STRING_CRT_DebugHeapString_DebugHeapAllocatorstd::basic_string,_DebugHeapAllocator >_DebugHeapString::_Myt_DebugHeapString::_Mybase_DebugHeapString::_Elem_DebugHeapString::_DebugHeapString_DebugHeapString::operator std::string_DebugHeapAllocator<_Ty>std::allocator<_Ty>_DebugHeapAllocator<_Ty>::rebind<_Other>_DebugHeapAllocator<_Ty>::rebind_DebugHeapAllocator<_Ty>::rebind<_Other>::other_DebugHeapAllocator<_Ty>::allocate_DebugHeapAllocator<_Ty>::deallocate_DebugHeapDelete<_Ty>_DebugHeapTag_t::_Typec:\archivos de programa\microsoft visual studio 8\vc\include\xlocinfo_XLOCINFO_c:\archivos de programa\microsoft visual studio 8\vc\include\xlocinfo.h_XLOCINFOc:\archivos de programa\microsoft visual studio 8\vc\include\locale.h_INC_LOCALELC_ALLLC_COLLATELC_CTYPELC_MONETARYLC_NUMERICLC_TIMELC_MINLC_MAX_LCONV_DEFINEDdecimal_pointthousands_sepgroupingint_curr_symbolcurrency_symbolmon_decimal_pointmon_thousands_sepmon_groupingpositive_signnegative_signint_frac_digitsfrac_digitsp_cs_precedesp_sep_by_spacen_cs_precedesn_sep_by_spacep_sign_posnn_sign_posn_charmax__dummy_CONFIG_LOCALE_SWT_ENABLE_PER_THREAD_LOCALE_DISABLE_PER_THREAD_LOCALE_ENABLE_PER_THREAD_LOCALE_GLOBAL_DISABLE_PER_THREAD_LOCALE_GLOBAL_ENABLE_PER_THREAD_LOCALE_NEWx100_DISABLE_PER_THREAD_LOCALE_NEWx200_configthreadlocalesetlocalelocaleconv_get_current_locale_create_locale_free_locale__get_current_locale__create_locale__free_localelconv::decimal_pointlconv::thousands_seplconv::groupinglconv::int_curr_symbollconv::currency_symbollconv::mon_decimal_pointlconv::mon_thousands_seplconv::mon_groupinglconv::positive_signlconv::negative_signlconv::int_frac_digitslconv::frac_digitslconv::p_cs_precedeslconv::p_sep_by_spacelconv::n_cs_precedeslconv::n_sep_by_spacelconv::p_sign_posnlconv::n_sign_posn_XA_XSx000_BB_CN_DI_LO_PU_SP_UP_XD_X_ALL_X_COLLATE_X_CTYPE_X_MONETARY_X_NUMERIC_X_TIME_X_MAX_X_MESSAGES_NCAT_CATMASK_M_COLLATE_M_CTYPE_M_MONETARY_M_NUMERIC_M_TIME_M_MESSAGES_M_ALL_Collvec_Hand_Page_Ctypevec_Table_Delfl_Cvtvec_Getcoll_Getctype_Getcvt_Getdateorder_Mbrtowc_Stof_Stod_Stold_Strcoll_Strxfrm_End1_String1_Tolower_Toupper_Wcrtomb_Wcscoll_Wcsxfrm_Getwctype_Getwctypes_Towlower_Towupper_Gettnames_Getdays_Getmonths_Strftime_Maxsize_GetLocaleForCP_Cvtvec::_Hand_Cvtvec::_Page_Ctypevec::_Hand_Ctypevec::_Page_Ctypevec::_Table_Ctypevec::_Delfl_Collvec::_Hand_Collvec::_Page_Timevec_Timeptr_Getptr_Locinfo_ctor_Locinfo_dtor_Locinfo_Addcats_Pch_I_Addcats_Getname_Newlocname_Getlconv_Days_Months_Getfalse_Gettrue_Empty_lock_Oldlocname_LStrcoll_Vector_LStrxfrm_LStrxfrm<>_LStrxfrm<_Elem>_LStrcoll<>_LStrcoll<_Elem>_Locinfo::_Collvec_Locinfo::_Ctypevec_Locinfo::_Cvtvec_Locinfo::_Timevec_Locinfo::_Locinfo_ctor_Locinfo::_Locinfo_dtor_Locinfo::_Locinfo_Addcats_Locinfo::_Locinfo_Locinfo::~_Locinfo_Locinfo::_Addcats_Locinfo::_Getname_Locinfo::_Getcoll_Locinfo::_Getctype_Locinfo::_Getcvt_Locinfo::_Getlconv_Locinfo::_Gettnames_Locinfo::_Getdays_Locinfo::_Getmonths_Locinfo::_Getfalse_Locinfo::_Gettrue_Locinfo::_Getdateorder_Locinfo::_Lock_Locinfo::_Days_Locinfo::_Months_Locinfo::_Oldlocname_Locinfo::_Newlocname_Timevec::_Timevec_Timevec::~_Timevec_Timevec::operator =_Timevec::_Getptr_Timevec::_Timeptr_Locbasemonetarynumericmessagesallnone_Facetuse_facetid_Id_cnt_Id_cnt_func_Locimpfacet_Getcat_Incref_Refs_Decref_Registerfacet_Register_Tag_Initrefs_Locimp_dtor_Locimp_ctor_Locimp_Addfac_Transparent_Facetvec_Facetcount_Catmask_Xparent_Addfac_Pfacet_Makeloc_Makewloc_Makeushloc_Makexloc_Clocptr_func_Clocptr_Fac_Coll_fac_Loc_Facptr_Newimp_Init_Getgloballocale_Lobj_Locname_Hadname_Getfacetclassicglobal_Ptrimp_Setgloballocale_Facetptr_Psave_ADDFAClocpfac_USEfac_Pf_Pfmod_Getloctxt_Numfields_Column_Prefix_Field_MAKLOCBYTEElemchrcvt_Maklocbyte_Cvt_Byte_Mbst1_MAKLOCCHR_Maklocchr_Wc_MAKLOCSTR_Maklocstr_Ptrdest_Ptrnext_Count1_Wchars_Ptr1_Mbst2codecvt_baseokpartialerrornoconvalways_noconvdo_always_noconvmax_lengthdo_max_lengthencodingdo_encoding_Statypecodecvtintern_typeextern_type_Mid1_Mid2do_inoutdo_outunshiftdo_unshiftdo_length_Ppf_Id_func_Stsavecodecvt_bynamectype_basealnumalphacntrldigitgraphlowerpunctspaceupperxdigit_Maskvaldo_isscan_isdo_scan_isscan_notdo_scan_notdo_tolowerdo_toupperwidendo_widen_Widen_s_Do_widen_snarrow_Dfltdo_narrow_Narrow_s_Do_narrow_s_Ctype_Donarrow_Deletetabletable_sizeclassic_table_Ctype_fac_Dowiden_Mbstctype_bynamectype_byname<>std::ctypectype_byname::ctype_bynamectype_byname::~ctype_bynamectype_byname<_Elem>std::ctype<_Elem>ctype_byname<_Elem>::ctype_bynamectype_byname<_Elem>::~ctype_bynamectype<>std::ctype_basestd::locale::facetstd::_Locbaselocale::categorylocale::idlocale::id::idlocale::id::operator size_tlocale::id::operator =locale::id::_Idlocale::id::_Id_cnt_funclocale::id::_Id_cntlocale::_Locimplocale::facetlocale::facet::_Getcatlocale::facet::_Increflocale::facet::_Decreflocale::facet::_Registerlocale::facet::operator newlocale::facet::operator deletelocale::facet::~facetlocale::facet::facetlocale::facet::facet_Registerlocale::facet::operator =locale::facet::_Refslocale::_Locimp::~_Locimplocale::_Locimp::_Locimp_dtorlocale::_Locimp::_Locimp_ctorlocale::_Locimp::_Locimp_Addfaclocale::_Locimp::_Locimplocale::_Locimp::_Addfaclocale::_Locimp::_Makeloclocale::_Locimp::_Makewloclocale::_Locimp::_Makeushloclocale::_Locimp::_Makexloclocale::_Locimp::_Facetveclocale::_Locimp::_Facetcountlocale::_Locimp::_Catmasklocale::_Locimp::_Xparentlocale::_Locimp::_Namelocale::_Locimp::_Clocptr_funclocale::_Locimp::_Clocptrlocale::_Locimp::operator =locale::_Addfaclocale::operator ()<_Elem,_Traits,_Alloc>locale::operator ()locale::combine<_Facet>locale::combinelocale::localelocale::~localelocale::operator =locale::namelocale::_Getfacetlocale::operator ==locale::operator !=locale::classiclocale::globallocale::emptylocale::_Getgloballocalelocale::_Initlocale::_Setgloballocalelocale::_Ptrctype_base::__unnamed_0251_1ctype_base::xdigitctype_base::upperctype_base::spacectype_base::punctctype_base::printctype_base::lowerctype_base::graphctype_base::digitctype_base::cntrlctype_base::alphactype_base::alnumctype_base::maskctype_base::ctype_basectype_base::~ctype_basectype_base::_Xranctype::_Mytctype::_Elemctype::char_typectype::isctype::scan_isctype::scan_notctype::tolowerctype::toupperctype::widenctype::_Widen_sctype::narrowctype::_Narrow_sctype::_Id_funcctype::idctype::ctypectype::_Getcatctype::~ctypectype::_Initctype::do_isctype::do_scan_isctype::do_scan_notctype::do_tolowerctype::do_toupperctype::_Dowidenctype::do_widenctype::_Do_widen_sctype::_Donarrowctype::do_narrowctype::_Do_narrow_sctype::_Ctypectype::_Cvtctype<__wchar_t>::_Mytctype<__wchar_t>::_Elemctype<__wchar_t>::char_typectype<__wchar_t>::isctype<__wchar_t>::scan_isctype<__wchar_t>::scan_notctype<__wchar_t>::tolowerctype<__wchar_t>::toupperctype<__wchar_t>::widenctype<__wchar_t>::_Widen_sctype<__wchar_t>::narrowctype<__wchar_t>::_Narrow_sctype<__wchar_t>::_Id_funcctype<__wchar_t>::idctype<__wchar_t>::ctypectype<__wchar_t>::_Getcatctype<__wchar_t>::~ctypectype<__wchar_t>::_Initctype<__wchar_t>::do_isctype<__wchar_t>::do_scan_isctype<__wchar_t>::do_scan_notctype<__wchar_t>::do_tolowerctype<__wchar_t>::do_toupperctype<__wchar_t>::_Dowidenctype<__wchar_t>::do_widenctype<__wchar_t>::_Do_widen_sctype<__wchar_t>::_Donarrowctype<__wchar_t>::do_narrowctype<__wchar_t>::_Do_narrow_sctype<__wchar_t>::_Ctypectype<__wchar_t>::_Cvtctype::_Mytctype::_Elemctype::char_typectype::isctype::scan_isctype::scan_notctype::tolowerctype::toupperctype::widenctype::_Widen_sctype::narrowctype::_Narrow_sctype::_Id_funcctype::idctype::ctypectype::_Getcatctype::table_sizectype::~ctypectype::_Initctype::_Tidyctype::do_tolowerctype::do_toupperctype::do_widenctype::_Do_widen_sctype::do_narrowctype::_Do_narrow_sctype::tablectype::classic_tablectype::_Ctypectype<_Elem>::idctype<_Elem>ctype<_Elem>::char_typectype<_Elem>::isctype<_Elem>::scan_isctype<_Elem>::scan_notctype<_Elem>::tolowerctype<_Elem>::toupperctype<_Elem>::widenctype<_Elem>::_Widen_sctype<_Elem>::narrowctype<_Elem>::_Narrow_sctype<_Elem>::ctypectype<_Elem>::_Getcatctype<_Elem>::~ctypectype<_Elem>::_Initctype<_Elem>::do_isctype<_Elem>::do_scan_isctype<_Elem>::do_scan_notctype<_Elem>::do_tolowerctype<_Elem>::do_toupperctype<_Elem>::do_widenctype<_Elem>::_Do_widen_sctype<_Elem>::_Donarrowctype<_Elem>::do_narrowctype<_Elem>::_Do_narrow_sctype<_Elem>::_Ctypectype<_Elem>::_Cvtcodecvt_byname<_Elem,_Byte,_Statype>std::codecvt<_Elem,_Byte,_Statype>codecvt_byname<_Elem,_Byte,_Statype>::codecvt_bynamecodecvt_byname<_Elem,_Byte,_Statype>::~codecvt_bynamecodecvt<>std::codecvt_basecodecvt_base::__unnamed_0251_1codecvt_base::noconvcodecvt_base::errorcodecvt_base::partialcodecvt_base::okcodecvt_base::resultcodecvt_base::codecvt_basecodecvt_base::always_noconvcodecvt_base::max_lengthcodecvt_base::encodingcodecvt_base::~codecvt_basecodecvt_base::do_always_noconvcodecvt_base::do_max_lengthcodecvt_base::do_encodingcodecvt::_Elemcodecvt::_Bytecodecvt::_Statypecodecvt::intern_typecodecvt::extern_typecodecvt::state_typecodecvt::incodecvt::outcodecvt::unshiftcodecvt::lengthcodecvt::_Id_funccodecvt::idcodecvt::codecvtcodecvt::_Getcatcodecvt::~codecvtcodecvt::_Initcodecvt::do_incodecvt::do_outcodecvt::do_unshiftcodecvt::do_lengthcodecvt::do_always_noconvcodecvt::do_max_lengthcodecvt::do_encodingcodecvt::_Cvtcodecvt<__wchar_t,char,_Mbstatet>::_Elemcodecvt<__wchar_t,char,_Mbstatet>::_Bytecodecvt<__wchar_t,char,_Mbstatet>::_Statypecodecvt<__wchar_t,char,_Mbstatet>::intern_typecodecvt<__wchar_t,char,_Mbstatet>::extern_typecodecvt<__wchar_t,char,_Mbstatet>::state_typecodecvt<__wchar_t,char,_Mbstatet>::incodecvt<__wchar_t,char,_Mbstatet>::outcodecvt<__wchar_t,char,_Mbstatet>::unshiftcodecvt<__wchar_t,char,_Mbstatet>::lengthcodecvt<__wchar_t,char,_Mbstatet>::_Id_funccodecvt<__wchar_t,char,_Mbstatet>::idcodecvt<__wchar_t,char,_Mbstatet>::codecvtcodecvt<__wchar_t,char,_Mbstatet>::_Getcatcodecvt<__wchar_t,char,_Mbstatet>::~codecvtcodecvt<__wchar_t,char,_Mbstatet>::_Initcodecvt<__wchar_t,char,_Mbstatet>::do_incodecvt<__wchar_t,char,_Mbstatet>::do_outcodecvt<__wchar_t,char,_Mbstatet>::do_unshiftcodecvt<__wchar_t,char,_Mbstatet>::do_lengthcodecvt<__wchar_t,char,_Mbstatet>::do_always_noconvcodecvt<__wchar_t,char,_Mbstatet>::do_max_lengthcodecvt<__wchar_t,char,_Mbstatet>::do_encodingcodecvt<__wchar_t,char,_Mbstatet>::_Cvtcodecvt<_Elem,_Byte,_Statype>::idcodecvt<_Elem,_Byte,_Statype>codecvt<_Elem,_Byte,_Statype>::intern_typecodecvt<_Elem,_Byte,_Statype>::extern_typecodecvt<_Elem,_Byte,_Statype>::state_typecodecvt<_Elem,_Byte,_Statype>::incodecvt<_Elem,_Byte,_Statype>::outcodecvt<_Elem,_Byte,_Statype>::unshiftcodecvt<_Elem,_Byte,_Statype>::lengthcodecvt<_Elem,_Byte,_Statype>::codecvtcodecvt<_Elem,_Byte,_Statype>::_Getcatcodecvt<_Elem,_Byte,_Statype>::~codecvtcodecvt<_Elem,_Byte,_Statype>::_Initcodecvt<_Elem,_Byte,_Statype>::do_incodecvt<_Elem,_Byte,_Statype>::do_outcodecvt<_Elem,_Byte,_Statype>::do_unshiftcodecvt<_Elem,_Byte,_Statype>::do_length_Maklocstr<>_Maklocstr<_Elem>_Maklocchr<>_Maklocchr<_Elem>_Maklocbyte<>_Maklocbyte<_Elem>_Getloctxt<_Elem,_InIt>use_facet<_Facet>_Addfac<_Facet>_Facetptr<_Facet>::_Psave_Facetptr<_Facet>_Locbase<_Dummy>::none_Locbase<_Dummy>::all_Locbase<_Dummy>::messages_Locbase<_Dummy>::time_Locbase<_Dummy>::numeric_Locbase<_Dummy>::monetary_Locbase<_Dummy>::ctype_Locbase<_Dummy>::collate_Locbase<_Dummy>c:\archivos de programa\microsoft visual studio 8\vc\include\share.h_INC_SHARE_SH_DENYRW_SH_DENYWR_SH_DENYRDx30_SH_DENYNO_SH_SECURESH_DENYRWSH_DENYWRSH_DENYRDSH_DENYNO_IOSskipws_IOSunitbuf_IOSuppercase_IOSshowbase_IOSshowpoint_IOSshowpos_IOSleft_IOSright_IOSinternal_IOSdec_IOSoct_IOShexx0800_IOSscientificx1000_IOSfixedx2000_IOShexfloatx3000_IOSboolalphax4000_IOS_Stdio_IOS_Nocreate_IOS_Noreplace_IOSbinary_Iosb_Dummy_enum_Dummy_enum_val_Fmtflags_Fmtmask_Fmtzeroskipwsunitbufuppercaseshowbaseshowpointshowposleftrightinternaldecocthexscientificfixedboolalpha_Stdioadjustfieldbasefieldfloatfield_Iostate_Statmaskgoodbiteofbitfailbitbadbit_Hardfail_Openmode_Openmaskateapptrunc_Nocreate_Noreplacebinary_Seekdir_Seekmaskbegcur_Openprotfmtflagsiostateopenmodeseekdireventerase_eventimbue_eventcopyfmt_eventevent_callbackio_stateopen_modeseek_dirfailureInit_Init_ctor_Init_dtor_Init_cnt_func_Init_cntcopyfmtfail_Reraiserdstatesetstate_Exreraisegoodbadexceptions_Newexceptflags_Fmtfl_Newfmtflags_Oldfmtflagssetfunsetfprecision_Prec_Newprecision_Oldprecisionwidth_Wide_Newwidth_Oldwidthgetloc_Plocimbue_Oldlocale_Callfnsxallociword_Idx_Findarr_Lopword_Vpregister_callback_Pfn_Calls_Fnarray_Iosarray_Arr_Q_Ios_base_dtorsync_with_stdio_Newsync_Oldsync_Sync_Addstd_Stdstr_Link_Ev_Q1_Q2_Q3_Q4_Index_func_Sync_funcstd::_Iosbios_base::fmtflagsios_base::iostateios_base::openmodeios_base::seekdirios_base::eventios_base::copyfmt_eventios_base::imbue_eventios_base::erase_eventios_base::event_callbackios_base::io_stateios_base::open_modeios_base::seek_dirios_base::failureios_base::failure::failureios_base::failure::~failureios_base::Initios_base::Init::Initios_base::Init::~Initios_base::Init::_Init_ctorios_base::Init::_Init_dtorios_base::Init::_Init_cnt_funcios_base::Init::_Init_cntios_base::operator =ios_base::operator void *ios_base::operator !ios_base::clearios_base::rdstateios_base::setstateios_base::goodios_base::eofios_base::failios_base::badios_base::exceptionsios_base::flagsios_base::setfios_base::unsetfios_base::precisionios_base::widthios_base::getlocios_base::imbueios_base::xallocios_base::iwordios_base::pwordios_base::register_callbackios_base::copyfmtios_base::~ios_baseios_base::sync_with_stdioios_base::_Addstdios_base::_Stdstrios_base::ios_baseios_base::_Initios_base::_Iosarrayios_base::_Iosarray::_Iosarrayios_base::_Iosarray::_Nextios_base::_Iosarray::_Indexios_base::_Iosarray::_Loios_base::_Iosarray::_Vpios_base::_Fnarrayios_base::_Fnarray::_Fnarrayios_base::_Fnarray::_Nextios_base::_Fnarray::_Indexios_base::_Fnarray::_Pfnios_base::_Callfnsios_base::_Findarrios_base::_Tidyios_base::_Ios_base_dtorios_base::_Mystateios_base::_Exceptios_base::_Fmtflios_base::_Precios_base::_Wideios_base::_Arrios_base::_Callsios_base::_Plocios_base::_Indexios_base::_Syncios_base::_Index_funcios_base::_Sync_func_Iosb<_Dummy>::end_Iosb<_Dummy>::cur_Iosb<_Dummy>::beg_Iosb<_Dummy>::binary_Iosb<_Dummy>::_Noreplace_Iosb<_Dummy>::_Nocreate_Iosb<_Dummy>::trunc_Iosb<_Dummy>::app_Iosb<_Dummy>::ate_Iosb<_Dummy>::out_Iosb<_Dummy>::in_Iosb<_Dummy>::_Hardfail_Iosb<_Dummy>::badbit_Iosb<_Dummy>::failbit_Iosb<_Dummy>::eofbit_Iosb<_Dummy>::goodbit_Iosb<_Dummy>::floatfield_Iosb<_Dummy>::basefield_Iosb<_Dummy>::adjustfield_Iosb<_Dummy>::_Stdio_Iosb<_Dummy>::boolalpha_Iosb<_Dummy>::fixed_Iosb<_Dummy>::scientific_Iosb<_Dummy>::hex_Iosb<_Dummy>::oct_Iosb<_Dummy>::dec_Iosb<_Dummy>::internal_Iosb<_Dummy>::right_Iosb<_Dummy>::left_Iosb<_Dummy>::showpos_Iosb<_Dummy>::showpoint_Iosb<_Dummy>::showbase_Iosb<_Dummy>::uppercase_Iosb<_Dummy>::unitbuf_Iosb<_Dummy>::skipws_Iosb<_Dummy>_Iosb<_Dummy>::_Dummy_enum_Iosb::_Dummy_enum_val_Iosb<_Dummy>::_Fmtflags_Iosb::_Fmtzero_Iosb::_Fmtmask_Iosb<_Dummy>::_Iostate_Iosb::_Statmask_Iosb<_Dummy>::_Openmode_Iosb::_Openmask_Iosb<_Dummy>::_Seekdir_Iosb::_Seekmask_Iosb<_Dummy>::__unnamed_0250_1_Iosb::_Openprot_Plocalepubseekoff_Wayseekoffpubseekpospubsetbufpubimbue_Newlocalein_avail_Res_Gnavailshowmanycpubsyncsync_Gnincuflowgptrunderflow_Sgetn_s_Ptr_size_Xsgetn_ssgetnxsgetnsnextc_Gnpreincsputbackceback_Gndecpbackfailstosscsungetc_Pnavail_Pnincoverflowsputnxsputn_Mylock_IGfirst_IGnextpbase_IPfirstpptr_IPnextegptr_IGcountgbumpsetgepptr_IPcountpbumpsetp_Gfirst_Pfirst_Gnext_Gcount_Pcount_Gf_Gn_Gc_Pn_Pc_Stream_size_Copiedbasic_streambuf<_Elem,_Traits>::basic_streambufbasic_streambuf<_Elem,_Traits>::operator =basic_streambuf<_Elem,_Traits>::_Mytbasic_streambuf<_Elem,_Traits>::char_typebasic_streambuf<_Elem,_Traits>::traits_typebasic_streambuf<_Elem,_Traits>::~basic_streambufbasic_streambuf<_Elem,_Traits>::int_typebasic_streambuf<_Elem,_Traits>::pos_typebasic_streambuf<_Elem,_Traits>::off_typebasic_streambuf<_Elem,_Traits>::pubseekoffbasic_streambuf<_Elem,_Traits>::pubseekposbasic_streambuf<_Elem,_Traits>::pubsetbufbasic_streambuf<_Elem,_Traits>::pubimbuebasic_streambuf<_Elem,_Traits>::getlocbasic_streambuf<_Elem,_Traits>::in_availbasic_streambuf<_Elem,_Traits>::pubsyncbasic_streambuf<_Elem,_Traits>::sbumpcbasic_streambuf<_Elem,_Traits>::sgetcbasic_streambuf<_Elem,_Traits>::_Sgetn_sbasic_streambuf<_Elem,_Traits>::sgetnbasic_streambuf<_Elem,_Traits>::snextcbasic_streambuf<_Elem,_Traits>::sputbackcbasic_streambuf<_Elem,_Traits>::stosscbasic_streambuf<_Elem,_Traits>::sungetcbasic_streambuf<_Elem,_Traits>::sputcbasic_streambuf<_Elem,_Traits>::sputnbasic_streambuf<_Elem,_Traits>::_Lockbasic_streambuf<_Elem,_Traits>::_Unlockbasic_streambuf<_Elem,_Traits>::ebackbasic_streambuf<_Elem,_Traits>::gptrbasic_streambuf<_Elem,_Traits>::pbasebasic_streambuf<_Elem,_Traits>::pptrbasic_streambuf<_Elem,_Traits>::egptrbasic_streambuf<_Elem,_Traits>::gbumpbasic_streambuf<_Elem,_Traits>::setgbasic_streambuf<_Elem,_Traits>::epptrbasic_streambuf<_Elem,_Traits>::_Gndecbasic_streambuf<_Elem,_Traits>::_Gnincbasic_streambuf<_Elem,_Traits>::_Gnpreincbasic_streambuf<_Elem,_Traits>::_Gnavailbasic_streambuf<_Elem,_Traits>::pbumpbasic_streambuf<_Elem,_Traits>::setpbasic_streambuf<_Elem,_Traits>::_Pnincbasic_streambuf<_Elem,_Traits>::_Pnavailbasic_streambuf<_Elem,_Traits>::_Initbasic_streambuf<_Elem,_Traits>::overflowbasic_streambuf<_Elem,_Traits>::pbackfailbasic_streambuf<_Elem,_Traits>::showmanycbasic_streambuf<_Elem,_Traits>::underflowbasic_streambuf<_Elem,_Traits>::uflowbasic_streambuf<_Elem,_Traits>::xsgetnbasic_streambuf<_Elem,_Traits>::_Xsgetn_sbasic_streambuf<_Elem,_Traits>::xsputnbasic_streambuf<_Elem,_Traits>::seekoffbasic_streambuf<_Elem,_Traits>::seekposbasic_streambuf<_Elem,_Traits>::setbufbasic_streambuf<_Elem,_Traits>::syncbasic_streambuf<_Elem,_Traits>::imbuebasic_streambuf<_Elem,_Traits>::_Mylockbasic_streambuf<_Elem,_Traits>::_Gfirstbasic_streambuf<_Elem,_Traits>::_Pfirstbasic_streambuf<_Elem,_Traits>::_IGfirstbasic_streambuf<_Elem,_Traits>::_IPfirstbasic_streambuf<_Elem,_Traits>::_Gnextbasic_streambuf<_Elem,_Traits>::_Pnextbasic_streambuf<_Elem,_Traits>::_IGnextbasic_streambuf<_Elem,_Traits>::_IPnextbasic_streambuf<_Elem,_Traits>::_Gcountbasic_streambuf<_Elem,_Traits>::_Pcountbasic_streambuf<_Elem,_Traits>::_IGcountbasic_streambuf<_Elem,_Traits>::_IPcountbasic_streambuf<_Elem,_Traits>::_Plocale_Stolx_Stoulx_Stofx_Stodx_Stoldx_STOLLbufperr_STOULL_VIRTUALvirtualnumpunctstring_typedo_decimal_pointdo_thousands_sepdo_groupingfalsenamedo_falsenametruenamedo_truename_Kseparator_Grouping_Falsename_Truename_Dp_Npc_Npwcnumpunct_byname_Mypunct_Mystriter_typeget_Iosbasedo_get_Mystrsize_Punct_fac_Ac_Ep_Errno_Ulo_Getifld_Getffld_Basefield_E0_Seendigit_Nonzero_Dlen_Groups_Group_Pe_Pg_Bad_Significant_Ptenputdo_put_Fillcount_Rep_Put_Fmt_Iput_Ifmt_Precision_Significance_Beforepoint_Afterpoint_Signed_Fput_Ffmt_Spec_Ffl_Trailing_Groupstring_Enders_Eptr_Pointptr_Adjustfield_Putc_Fracoffset_Putgrouped_Expoffset_Pend_Groupsizenum_put<_Elem,_OutIt>::idnum_put<_Elem,_OutIt>num_put<_Elem,_OutIt>::_Mypunctnum_put<_Elem,_OutIt>::_Mystrnum_put<_Elem,_OutIt>::_Getcatnum_put<_Elem,_OutIt>::~num_putnum_put<_Elem,_OutIt>::_Initnum_put<_Elem,_OutIt>::_Cvtnum_put<_Elem,_OutIt>::num_putnum_put<_Elem,_OutIt>::char_typenum_put<_Elem,_OutIt>::iter_typenum_put<_Elem,_OutIt>::putnum_put<_Elem,_OutIt>::do_putnum_put<_Elem,_OutIt>::_Ffmtnum_put<_Elem,_OutIt>::_Fputnum_put<_Elem,_OutIt>::_Ifmtnum_put<_Elem,_OutIt>::_Iputnum_put<_Elem,_OutIt>::_Putnum_put<_Elem,_OutIt>::_Putcnum_put<_Elem,_OutIt>::_Putgroupednum_put<_Elem,_OutIt>::_Repnum_get<_Elem,_InIt>::idnum_get<_Elem,_InIt>num_get<_Elem,_InIt>::_Mypunctnum_get<_Elem,_InIt>::_Mystrnum_get<_Elem,_InIt>::_Getcatnum_get<_Elem,_InIt>::~num_getnum_get<_Elem,_InIt>::_Initnum_get<_Elem,_InIt>::_Cvtnum_get<_Elem,_InIt>::num_getnum_get<_Elem,_InIt>::char_typenum_get<_Elem,_InIt>::iter_typenum_get<_Elem,_InIt>::getnum_get<_Elem,_InIt>::do_getnum_get<_Elem,_InIt>::_Getifldnum_get<_Elem,_InIt>::_Getffldnumpunct<_Elem>::idnumpunct_byname<_Elem>std::numpunct<_Elem>numpunct_byname<_Elem>::numpunct_bynamenumpunct_byname<_Elem>::~numpunct_bynamenumpunct<_Elem>numpunct<_Elem>::string_typenumpunct<_Elem>::char_typenumpunct<_Elem>::decimal_pointnumpunct<_Elem>::thousands_sepnumpunct<_Elem>::groupingnumpunct<_Elem>::falsenamenumpunct<_Elem>::truenamenumpunct<_Elem>::numpunctnumpunct<_Elem>::_Getcatnumpunct<_Elem>::~numpunctnumpunct<_Elem>::_Initnumpunct<_Elem>::do_decimal_pointnumpunct<_Elem>::do_thousands_sepnumpunct<_Elem>::do_groupingnumpunct<_Elem>::do_falsenamenumpunct<_Elem>::do_truenamenumpunct<_Elem>::_Tidynumpunct<_Elem>::_Groupingnumpunct<_Elem>::_Dpnumpunct<_Elem>::_Kseparatornumpunct<_Elem>::_Falsenamenumpunct<_Elem>::_Truename_Myos_Mysbinit_Mystrbuf_Tiestrtie_Fillch_Newtie_Oldtie_Oldstrbuf_Newfill_Oldfill_Isstdnoboolalphanoshowbasenoshowpointnoshowposnoskipwsnounitbufnouppercasestd::ios_basebasic_ios<_Elem,_Traits>::_Mytbasic_ios<_Elem,_Traits>::_Myosbasic_ios<_Elem,_Traits>::_Mysbbasic_ios<_Elem,_Traits>::_Ctypebasic_ios<_Elem,_Traits>::char_typebasic_ios<_Elem,_Traits>::traits_typebasic_ios<_Elem,_Traits>::int_typebasic_ios<_Elem,_Traits>::pos_typebasic_ios<_Elem,_Traits>::off_typebasic_ios<_Elem,_Traits>::basic_iosbasic_ios<_Elem,_Traits>::~basic_iosbasic_ios<_Elem,_Traits>::clearbasic_ios<_Elem,_Traits>::setstatebasic_ios<_Elem,_Traits>::copyfmtbasic_ios<_Elem,_Traits>::tiebasic_ios<_Elem,_Traits>::rdbufbasic_ios<_Elem,_Traits>::imbuebasic_ios<_Elem,_Traits>::fillbasic_ios<_Elem,_Traits>::narrowbasic_ios<_Elem,_Traits>::widenbasic_ios<_Elem,_Traits>::initbasic_ios<_Elem,_Traits>::operator =basic_ios<_Elem,_Traits>::_Mystrbufbasic_ios<_Elem,_Traits>::_Tiestrbasic_ios<_Elem,_Traits>::_Fillch_TRY_IO_BEGIN_CATCH_IO_END_Myios_CATCH_IO__Nput_Sentry_base_Myostrsentryflush_Ok_Osfxopfxosfx_Nput_fac_Bflwriteseekptellp_Padendlendsflush<_Elem,_Traits>ends<_Elem,_Traits>endl<_Elem,_Traits>operator <<<_Traits>operator <<<_Elem,_Traits>std::basic_ios<_Elem,_Traits>basic_ostream<_Elem,_Traits>::_Mytbasic_ostream<_Elem,_Traits>::_Myiosbasic_ostream<_Elem,_Traits>::_Mysbbasic_ostream<_Elem,_Traits>::_Iterbasic_ostream<_Elem,_Traits>::_Nputbasic_ostream<_Elem,_Traits>::basic_ostreambasic_ostream<_Elem,_Traits>::~basic_ostreambasic_ostream<_Elem,_Traits>::int_typebasic_ostream<_Elem,_Traits>::pos_typebasic_ostream<_Elem,_Traits>::off_typebasic_ostream<_Elem,_Traits>::_Sentry_basebasic_ostream<_Elem,_Traits>::_Sentry_base::_Sentry_basebasic_ostream<_Elem,_Traits>::_Sentry_base::~_Sentry_basebasic_ostream<_Elem,_Traits>::_Sentry_base::_Myostrbasic_ostream<_Elem,_Traits>::sentrystd::basic_ostream<_Elem,_Traits>::_Sentry_basebasic_ostream<_Elem,_Traits>::sentry::sentrybasic_ostream<_Elem,_Traits>::sentry::~sentrybasic_ostream<_Elem,_Traits>::sentry::operator boolbasic_ostream<_Elem,_Traits>::sentry::operator =basic_ostream<_Elem,_Traits>::sentry::_Okbasic_ostream<_Elem,_Traits>::opfxbasic_ostream<_Elem,_Traits>::osfxbasic_ostream<_Elem,_Traits>::_Osfxbasic_ostream<_Elem,_Traits>::operator <<basic_ostream<_Elem,_Traits>::putbasic_ostream<_Elem,_Traits>::writebasic_ostream<_Elem,_Traits>::flushbasic_ostream<_Elem,_Traits>::seekpbasic_ostream<_Elem,_Traits>::tellp_Nget_Chcount_Myistr_Noskip_Ipfxipfxisfx_Nget_facgetline_Metadelimignore_Read_s_Str_sizeread_Readsome_sgcountreadsomepeekputbackungetseekgtellg_Myis_Str0wsws<_Elem,_Traits>operator >><_Traits>operator >><_Elem,_Traits>std::basic_istream<_Elem,_Traits>std::basic_ostream<_Elem,_Traits>basic_iostream<_Elem,_Traits>::char_typebasic_iostream<_Elem,_Traits>::traits_typebasic_iostream<_Elem,_Traits>::int_typebasic_iostream<_Elem,_Traits>::pos_typebasic_iostream<_Elem,_Traits>::off_typebasic_iostream<_Elem,_Traits>::basic_iostreambasic_iostream<_Elem,_Traits>::~basic_iostreambasic_istream<_Elem,_Traits>::_Mytbasic_istream<_Elem,_Traits>::_Myiosbasic_istream<_Elem,_Traits>::_Mysbbasic_istream<_Elem,_Traits>::_Iterbasic_istream<_Elem,_Traits>::_Ctypebasic_istream<_Elem,_Traits>::_Ngetbasic_istream<_Elem,_Traits>::basic_istreambasic_istream<_Elem,_Traits>::~basic_istreambasic_istream<_Elem,_Traits>::int_typebasic_istream<_Elem,_Traits>::pos_typebasic_istream<_Elem,_Traits>::off_typebasic_istream<_Elem,_Traits>::_Sentry_basebasic_istream<_Elem,_Traits>::_Sentry_base::_Sentry_basebasic_istream<_Elem,_Traits>::_Sentry_base::~_Sentry_basebasic_istream<_Elem,_Traits>::_Sentry_base::_Myistrbasic_istream<_Elem,_Traits>::sentrystd::basic_istream<_Elem,_Traits>::_Sentry_basebasic_istream<_Elem,_Traits>::sentry::sentrybasic_istream<_Elem,_Traits>::sentry::operator boolbasic_istream<_Elem,_Traits>::sentry::operator =basic_istream<_Elem,_Traits>::sentry::_Okbasic_istream<_Elem,_Traits>::_Ipfxbasic_istream<_Elem,_Traits>::ipfxbasic_istream<_Elem,_Traits>::isfxbasic_istream<_Elem,_Traits>::operator >>basic_istream<_Elem,_Traits>::getbasic_istream<_Elem,_Traits>::getlinebasic_istream<_Elem,_Traits>::ignorebasic_istream<_Elem,_Traits>::_Read_sbasic_istream<_Elem,_Traits>::readbasic_istream<_Elem,_Traits>::_Readsome_sbasic_istream<_Elem,_Traits>::readsomebasic_istream<_Elem,_Traits>::peekbasic_istream<_Elem,_Traits>::putbackbasic_istream<_Elem,_Traits>::ungetbasic_istream<_Elem,_Traits>::gcountbasic_istream<_Elem,_Traits>::syncbasic_istream<_Elem,_Traits>::seekgbasic_istream<_Elem,_Traits>::tellgbasic_istream<_Elem,_Traits>::_Chcount_Mysizt_Changedoperator <<<_Elem,_Traits,_Alloc>getline<_Elem,_Traits,_Alloc>operator >><_Elem,_Traits,_Alloc>operator >=<_Elem,_Traits,_Alloc>operator <=<_Elem,_Traits,_Alloc>operator ><_Elem,_Traits,_Alloc>operator <<_Elem,_Traits,_Alloc>operator !=<_Elem,_Traits,_Alloc>operator ==<_Elem,_Traits,_Alloc>c:\archivos de programa\microsoft visual studio 8\vc\include\strstream_STRSTREAM_strstreambuf_Allocated_Constant_Dynamic_Frozen_Strstate_Allocfunc_Freefunc_Palloc_Pfree_Putptrfreeze_Freezeit_Strmode_Pendsavepcount_Oldsize_Minsize_MINSIZE_Seekhigh_Which_Sp_Gp_Ppistrstreamostrstreamstrstreamstd::basic_iostream >strstream::char_typestrstream::int_typestrstream::pos_typestrstream::off_typestrstream::strstreamstrstream::~strstreamstrstream::rdbufstrstream::freezestrstream::strstrstream::pcountstrstream::_Mysbstd::basic_ostream >ostrstream::ostrstreamostrstream::~ostrstreamostrstream::rdbufostrstream::freezeostrstream::strostrstream::pcountostrstream::_Mysbstd::basic_istream >istrstream::istrstreamistrstream::~istrstreamistrstream::rdbufistrstream::stristrstream::_Mysbstd::basic_streambuf >strstreambuf::__unnamed_0261_1strstreambuf::_Frozenstrstreambuf::_Dynamicstrstreambuf::_Constantstrstreambuf::_Allocatedstrstreambuf::_Strstatestrstreambuf::strstreambufstrstreambuf::~strstreambufstrstreambuf::freezestrstreambuf::strstrstreambuf::pcountstrstreambuf::overflowstrstreambuf::pbackfailstrstreambuf::underflowstrstreambuf::seekoffstrstreambuf::seekposstrstreambuf::_Initstrstreambuf::_Tidystrstreambuf::__unnamed_0261_2strstreambuf::_MINSIZEstrstreambuf::_Minsizestrstreambuf::_Pendsavestrstreambuf::_Seekhighstrstreambuf::_Strmodestrstreambuf::_Pallocstrstreambuf::_Pfree__gmp_allocate_funcret__gmp_free_funcstd::istrstreamistringstream::istringstreamstd::ostrstreamostringstream::strgmp_randstate_ptrrandsperform_seedseed__gmp_rands_initialized__gmp_randsHAVE_STRTOULHAVE_GETTIMEOFDAYtimevaltvgettimeofdaytv_sectv_usecRANDS_CLEAR_PROTO__gmp_reallocate_funclenMPN_NORMALIZEMPZ_REALLOCMAX__GMP_ALLOCATE_FUNC_LIMBS_gmp_randRANDSBITS_PER_MP_LIMB_GMP_IEEE_FLOATSieee_double_extractmanlmanhsigmodeHAVE_HOST_CPU_FAMILY_x86rccwxC00h/кЯфЭXЩ-ЇІ€ьfvje_­sœёз”&iFK?‰AПN…j…ЩЌЧgЕ4`І€БнчМхеў#њY-LqIёЏт№№Ÿэ•ўсv'Г>s№Яе)НŠGJАдЬ{`W7žГ(ЇTїR@лsыРnœез@2Tљ X‡Нё:\“ўж2bчр–л н‹iI G‘mЉIŸЪLVИ§3З“5xˆŸ•бъ…Ќ)М3=;З8o‚јd –дФ†ЃgЉw!П—KcПM2Ё`9кLN†иИСZi№%C5QФМ•вњЋљ na%,ЯŸp„ )ŒS™ыр]ЗƒО‘ŠУtьчэЩџ­rззБxe6мwlLк;Нzв яoVsuЛЅm­ЧжС&Яb”€їƒ$‰(…^[˜ќˆїyL<ѓЖf›(Nѓj џ”.5’ѓ@НЅTЁЛш\‹ ЪЦйX#D™šЃ0Fжe7Ѕ_хўдФ…>ZЃПAвњskЗrMЇЯБзиБwИуЮ$~A№fф` ЫИЄIз  №мuўєѕf#@_Л \§^Ї~м№Г8­3мюШлЖз одЪБЂєг§чЖ‚оЏ=ЉрЁ^Z 'Пxu­iеrSV­qџ†ЁыђЛ> MhjqМЭЕЊG€wE€6‹§ЫžъиƒфNOš…€}ШŽIs$^ЩФšFtШU,ј{Љ9UBtЫєD ˜ЇЉ6НЅьg НaFДa Ч”зЉ\Œ@ЛЊў№ŽЪЪЬ6X1™ HјAoцГЇўЗVбSѕч6ІJFьјПrВ–‹Йц?›ChР%mЦKЂНњ U50ŠM|ƒФ‚V<5ИюŸУIЎЁ€.зp•Ш{ЂoёЖфщЪѓвn‹wUXeOlp=…aУŸъžЉgќkЕ >ћЈќAю7Лcк=РKїо@]шбјh ž\ї„оRvурЧA‚|<№tЧ’вHŠ@ Ъ(8 qўc—іgЂbЪВЙ+\'ЎUА€ –%4тЪ•ЅтЏNJc ЙйxWгъŠzžХкKG’F9TоЯr‡ЮЁЭVгрыЮ‚Єц_Œ(‘Г{–;bЉŸп›эЎœ:™cЯљжe8№ёС0tWdhc‰рoxЌЎЙPd:зИЅаЊ№&ОUvЌмХЇ2Ю:а+ЖЇcБМ^˜ЉO‰^HSФzЬ39qvй<ЌMat„брЯЃŸŒуilљœџzg–›ь~@dqQд\…МЫt[ps™AМGNYшm;њ2нЋЩ &г}Нf+5,//Lе5 й…_чNGoПT2—пбZMїъjxЧ€ёр AxNІХп‚ЇЖћІ “wiЖШ 5%nƒйWбgбВ > ё€{Ї–аѕXEя› „ J Cш€ЛЃbg№FИњэ™ŸЈ\Ў•\JЙБА‹'к Ф‘JŒч\іЕяk.dЉZЯdцЩШgKƒ3ЌЦ‹3Sv аЮ,HљŒЂеЈ:Лп “ўђнюоš‰AКšakШЙz™И jп@ьš~дЈ %KІO 7й S%Ž лI;лвƒJBй>^k<р5Цї гчtгнЕ Ÿs­aјЫSќтy>ВВњќ+“Аі h-нѓ)зH`WЯ{ГS3^ВЦьІ5'ЛыиёЏдОA\ЩъеkšQsвPh-еу&Х­ 4 ‡ПUxцЭmЃУ-ћTЬТЭћоъ ЧBаОGдJБю вY$&’жёјЦZ|Є€ћЉсКЧЯ шƒnЋы вŠCWР_…Љ7}ИТ§%ъ’Cа7мml§#O-†БФЌAІођ3_4]q%5ююa!pЭ›ЄsЂйx‹ЪњОљєZ]МЭиŽ7с(šћ8eЭ9ОВй“ЉVQLэœ_ямЛ(zПйЛХ№xЩиЧU2 И 2œшAJ I…QЖ Г)ЊŸЩї‹чјПЪГfэљѕNПF,Ў$’еŒіSЁ ПŠн‰7Чє3ЙАŸ\!<йКiТєVzfЂ"ЉќЋnИъR„Нб=рАt2юПLX]щ>–tъ‡A}FNЯщЩ@дсRіГDг<Ѓg‚/–ƒЌ)Q€C8V>ŸяЛuкњˆbš… рѕƒжю0Јях'/yљt{њ3нПC,Ђ9~ыЏ5ѓУ~$QўЭчцЅ—jž'ВYd4WПЕ}mБЇ о(ў_ыаН{CAПЇrНфцІьЈЂвЇ 'lж) еЪћš1ЛOё!нK~E/АK.ѕŠЗS‘нИ„ц^Q.ыЧ`bAњЛЂ>ІEъ2ШЈaфЁЉыгє}C§еІrнjВЧж9єVеБlпЫzUмaћwщ< щhКл|#Јaя’кmќ Й4ЙЏjuёІ`ЌдЫ^ЏЩ kЋЏАQщБ7€КМг$ЗЕH§yHuoAЌ›Bтu(ˆC<ZаAPP F#шї&bŒ yšsJuЉыLrКМdxјлЇW‘iж„pЖсГЌ­љ=›зшP<[ЫiГqИ&˜­юq‚ПІ ЋЊSй•иљTе,Њк>-№Њб7<‚ФЁЦˆйw Љ–BЭ\PааЯЅЙW|.@„Ю~ З…K`ПЌ№CЈ)ƒpЧЉ0v“дЄ/ј0tн‚ь№hч ИЧЮльUЇвqыЫTИ–OвIюјЬЈ–-Їл~xŒeэЬХы4Ь:™сKмЈу! .&Ш qЎѓ_тH F%я пc'}n]"ж˜Nщ…ъЪ\“С ЬЬћU /cШўgЛ€jb0œ\ўt<ЋdnWЯ Цїю$ˆЖoёУХ@g kTyМфђ–aсЉЉН8Zг1…ЋјP$%X@цНеЇ%Хєіќ6}uЄ=Ж*.иDœЌ hЊMр AЦzфј|ЄІ:ККЖaчwhќЅшаGќv4—JR,sъШш!MУАЛ gІън…Tљ iѓhњОњY0л~2ЩЎ U ПЉЮ•Б^ю/'ЙPЂ„';.иU‡ ЗAњёЙрƒIsеœ :…џСr…ГY! qЃ­ѕ..st@uпfРјаc 5L нK кOЯВA8Х+r> —рЏЉ˜ГшkrBкAtYЃy›\иn…ц nЮХЋЊЭ Uh_mt‚9ЯшBЬЂQ“% p@fєVcї–“й_ЧK8ВgФхм‘књС Ѓ‹‹9ћє?Ы:аоХѓу1йP5bwиxФ#МёшМRZAП%4ЄщoПœХб УЗ—^й Z–,hCcCŽ†?Yq Ўџє1pHЬP_Й^/WъЩIоГћ .ьCJХьbИƒžЊлвM\=Ч}ю+UзЇЇfpL!р"фQY.уГ№ъЕž;‡r–ŽЛџ­ДP^?ЯДі7ЩVпіѕ+N:ьZМ›‘‡Ў?/ћa8œиЛРdYkћдJмщ/HЉ‘ћ~j жё.KU€ŠЇ/hБ<Љ‚єО;-„жW‘ž~НШUЙхMСWвєСГ‘VˆЯ“X‡аl+3GћЩСбnMˆNK1nІŒыњџтхЧјx˜йK›ыfŠКoUoЂ‚Ѕc“КOёЯУыоћГBpДv€ЫнНЭzЭQoMр,qБVŒЮх’—ёзУXнэђя§єИхАвз`AqЊЫТ/ЋwЊUˆєтСПoхІq3‡ZCЯУ—IЌ DЯћЂЗt–_Хтэ™" 3џДЩС b'шk./нЇBŒт ЊuЈ+!…іЧpžx =!BZўeВ#Г‚ѓ!œМъhљ"dеЭ#ГЯ'Б!x)ЁЎ­Qб‹ф{іУ 9˜Тй5#‘Ѓ˜€йрaaћњяpЌЦŽrсжГеC/S­уШsF~Pй†vяђ@LЊА26–œKдv[? рˆtР'T•щl{ HђрАн^ШeŸијЅiЊХвkE†!шяыкюыz§ЦЈК ЧљЕЉпƒ,oˆУтњz2br бб*aK7’F9цƒ.юсхцЎМя6Ъ}а­јѓS‡NQзщЊYhqА`яa*йЮАХ ІƒрUЉлS!{›TЮ џqд:?щівРŸJС $ ѓзъБUEw6-їА}^C§№“шIД!AФ,uШmwvењ#E1Іr›[ЅvэПf†ЬŽЎВ@LАМ{“”Ло4'Нˆў2ѕ)Šе7Iбc*нДYѓЦ]m€РцЯˆИDижШОЮz+є št ОquУD=&њGвBEАdљЂWЌйd8џё-‰hbЄ[X88ФЭЅ€Щq%ЊŸ›иќ'дAЫ_EЬ‡ЉшШHіОЯН:€ъ—q1LЭ$оЌЛˆфd{B&а/ЕЯЦžЯ‚Ыc2ИЪyзи U№ŽЦˆFm?]œЂзћВз‘вЏЫз–ХpЯ§ЫШѕяgв{іР}9ў”ј˜ZџukFnДYlE| г= љЇG4ЇЩPbЇзЯВX% ­WЕЬ&F/<УфІѕTVS“L|‹НGьУЯргfжAЎDwВМЦLDyI7аш]’ђ/U@ ,SWѓДzоw]ЙDt‘$РЇ Di›pМ`ѕЧŠрЧсFНЌэ›.PЃ№’m IЖЫг+т)EМA1=еR ЮЮi[[йъg ЅЂ0Ѕ АVЧЛBПъDЌW›"юєФе€{H‚’wЋпЭЇpк‘—Џ›) Щ§RFCЬbМlCбМєѕ; џ€ё‚<?а]ЬjdVьŒsЌ,ŠВе4ЪЯвВОс•Bb“šвы”ўЇžме" ёnьѓNНЫ,V€5щŽ єLвnNgѕуйcжqМtFfвGМšЄЂš?:eи \р№яУbДƒЦ <ЬЯU<О\w†_жvП“+`5щR{“š Є+вЦэ,i§—WњМ2§—Q,Ю™з0DЅTШ3ЧћНЇ ЄЖрq_G6)WЏЪMеfЋїAбw7—*ы"ƒrНz^УЌІіЮёч<§§LгbHЭhŠІ9:8OT*ЋЯЧfШАV/O од˜I“р’=эьVCБНјн‡œ?Uƒv Ё† чЃ “ыo•“КЫ…оuтЫѕ'ЦšWжїЌМEztјUміЧOУе”ХА€О–K-ЋР™ЂnЃРъ˜Е‘™Љ/бдя„яГ ЭTо1f%ЏЪ†NхЈ1A.‰кђбЋТП Ит`WГcзс<ЁхЖ]ТxљpQќ„%Ј9МУ^_xНr…RЭТф!ЉаcМI№<Uє|ЪEЅaщџ'Т}ЊVриаёT§Й4XЊ І7 ЭсИБ?з Є–ўи!ЂыхZі4_›=mыaGžaыы–е­!e$XЏШлЗаЩћsC<~W6ЇPЂ|%'ЮTPЃIЇfцѓі`zmRЊ‡ЋЂ•юЮ<и—№"Эйd[Э-}Z[орwiВЇUЩоP`;Žt П4ь—}н2ЭЬ“8W уЂњZŽ­hыаЈjкЎ§ь@aъXТ_D[ЕWVх;УwуЕЃП2GюBНѕ ? @Џ­ШŸџ'ЬгвЕ!Мј $žВJ%эхё$Жлм ~оUиХ>Швa„?>Иё’фБgІoз§p”ѕЪђHЙ|„Ђюпн cК nh@єЈsЛ<єgЩ:lЮb,XUљrёзШAhЧлЙ‰;Дi~aj“…чЎiЙк’тOSПљУЉ VПБыTo ФмC9'Њ=ъИ"mКљ;‘ЁXЅЮmъ@о”щ іссО,h6Ugтюз4/PQD]ЛuŸеЏЁЗ]Fвй xїWZ0иh/э™ГœОiЙЋЉѓrs,5ЁЋ6єјд‚c—ЦXцЌќєємЗ.iК5udљ:СьzдФŸ‚uIЁщ8нЁа|Ѓ№gA—•“ЯœƒЛ№—ЭЋ†ждЙЈ&IbЃqЇ@рыЯY@С\ЬЃЁЪжяйЃ{pАŒШэбо`/ХsT0мpQЛ­И€}сЋяZ>ѕ}§z_jї\yТUrbm (r}‰, uж2žoХЭєtŒЩ‚н8GB KdяQwАЭ,„d"С Ы]ЪёЁ{ R‚кЄcОФІЇЙ@ЖЦNПZAнЅŸ|!dГ ЕІ{’mO”ApЯI— zАI3rS†э…?ЇI5ЃѓKСjьЫ’–в\lG^”є’ДА€˜Ы‹Юф#ёѓ џеръиЃ.к“€В  zzOыeЙuёь?+sl§Е†{РлšƒА{MšzWћoe*іšѓБ383ПЛхЂ!cЦзмг‰Ц ЕrаСvg *р”@Џaрмј‘‡Ўщ§SZˆ7ТˆЈŸ;yS9шcАййњлxГ_Яы”2ГЖOШЗlG4†dб1xГђбР‡Ю"”ЧЇ†:СсЬуј8YЂy;­qш~ чЄ;F•Э „mЯ.щnЅ˜юŠZ˜™ЖIА”ŸЁUЗ=_и )@œRlsгEќ=Ÿ§—u8фдJ9ŒOˆŸTƒHгL‘\žX•Ёфч‘*е~і№Ч™шПЙЋКо %9 <ё~Шг\†36т6^д}š›ЩЅ Ш^b‰к8RˆeR^ФѓKgИљ •meЊ%˜TРЦнэЋуЛ‚І—аKœteШ„#—ЭКnšSs!Є}ыжЦM:‚\"ЊъШv4X аD яs^S˜Р=‚Ўі–cЄžr]Vgџа‚eЌŸЭшЗ+XЇƒГЋ* 2UBВuЕRГMc$ЊЃZЫl4kœUа QЮ`нвЏиBјіTкЦ"э•Iž,ъœMђ4~H­Ч”ьiчЁ6Л4‚ьџ9ѓ—sЦНКІњЎя нTЗ ­з;6„жУКЗž›Ч ЖЉђgBIYШнХф„Іеj ƒ•ЮrЖ<оДЏ•УGД•,дхВpЬТЩ8хш?Ю ВЫђ­BUЇк@ыНё}9 бŽЇUБпq-ъўHGt™RЫ–ŒО,˜Е@ЄІ.еU]šўр ‚‹)Х=Hщ]ЙдsЯЯ&DіžХ% ƒ‚CЬ_‡ЧўннМž}ЛЦУЫђфys0ОЩщ СXІoa.aЂ;Кщл=|ЙЪ`‘E§ђкч'ЇЅc ОБеК#ЇзЕ84оѓхиuНk $Џ83jљос$л Д к…§иФ~хс\?#„^ѓט iо mS\j™0ŠЙЅЖ­‘?г\јїMо m•ыХАŠЯБK™Кш†ѕ %за^nQUŒъЩЊЙљvOїPєƒ PœЋг kчаЛ;ЫœYИМfJэбЧЂšbШж“М„ъ›ЖєЄї‘„ ЪЙЭв[х?œїdђН#юЕњбcєЭcRЂђC@rЙЛcх;їЖ_g№– ЁјRѕє‘ф:љIь:Žит—`I;яMj`ЇОФvM›„o_nˆSцjЦ\–Иџ§чs$S:Й%V _!ЛВЂъ‰ё6ЃД8 S›Ÿи”и™AfЇБг‘]UОSB<тЬABЕdŠС?ІqЕВФЕ ЋNQ5sЩc„^vh_нћ К^п–[їЪ­ šКІsqянXaВ-%B}№6fцЅйH<шёK`ЖmEq Oн{žd[j€Ф.{ЭvєЏLˆа)€ЎЦђКйbšєRйљjEр‚и-:HЌ_єеХЪе•=XЁ)ј3BЁSжBѓЙШкfмаHoZ$iTwї'"љЛ\аљњ1HLЛЄлќBЅБШчРЃгчh16R->-ѓ˜ {txNWЪВЯ’ЌЉљЇu“кŸ‹ўXKˆf§БєUЯгйNэ,К#оП5rЩЧ!vСљ-Ša}TЌюƒŒї\œ4KЊ2Ѕб:ог…щMЈнY5V• ћ5€S@,›ШЋ­ qхtІГPыkwEаиqЖeа/ьњбе[пЁ!W …vЖзеЬГч\ рФшьЯан ЎF икР—ТђnЮњИеXл#%КРр§wаD аSr8 ЭљSFW=mЌў{OЎсЖЮbZЯГЌ uRЦм ЉЅбє&ИфЛd-СrШcЅѕд R–yŽsЖm4t&ZфwаЖь" ’SтRшcЗїmrйЫъЪWЪ•УžвЛŸŒQЊВ@RWdLmI—‚чИфb7вМMЉ’vжгСќbщ5kрaGАRј–…žПј№[t’е#}*љЈ$…г^^PjПдЌ {sOЩ(вЬ8{•Ѕ4ЅћuіЊlПy\–A@bfЬОЮgcо~ M6§68e о;ь3(кБђa7уNУ“;§7dЙAЧІЮЗм2sэЊls[euŠЄю/œ>+Ч$M=кі”ћз@іЮjКwЅЉŽXЬ|–kн=Ё Їˆсэ0д]ЈaypMЏ W{иcъьПєПtуœ УчЃŸ…šбG ёћ‘фrgZЄЮЉоDDWцФ•IfxќИŸv;~oЌЛ ТН/ЦИ9Ё]ŸаЮКњZЉйRЖЩќq ЧpdCж=ЁhЁC7ЁeЖNћXёьh^С'ЧNWЙ$2zЈr•$ЖkЛНЙн/опдWIыь“g—-ŸЅŠWUьFЊg\эCz­щlJxdбЋMБeдлjмЈ“dє›ІМЉмЭО^lЫдJЙ†мЁ L{ТїьPэюF_AѕT”д“gŸєея_Ё#IˆШЈC9Ею9жЃиЬ с˜wZв~QVI х;А С›E ёРЬ?Сw/nCЕа&д‹аqЃз™мLšџSЕЄmэЈCЪюRЛ–џџаЃ fчеH8Ѕ5deeЗpьŸHqЯHъ&uБ5Ђ2MGq"MЫ%{|tл?EѕVŸЬ†ЗёХО9гаVЩe'Щ(YBsннB›ЮѓЅŸcux|є›]3qМr€Яєэ!Т}ЈръxCxЖyѓzКдн: ŽhЦAЬ™Ќ:я.ЇeЪНїzяUS=‘"|˜ pЭк[l%Р^ј1ЉQ7пёЗ,QMЂОa•ЄЌ˜Їј…лLUчTдню$кЧЯъWD?ЭHuНF9Г#Л>п-яŽжљцђbЗ/Ю+Ќ>Њрѓф Ђq*Ђs œЦк\xŠEeЭ„Iz!`эЇЪYЫгeнЖы‹Д9aЙ -CoVщг“Ђ ZДЎAЇйГЎm!|t—џcvLSPЇСмџ8H mћіѓЂ‚fpLћ ^ю_NA”Žu5zЈлФO=˜ЫtОоз—-МЏщЗ V’aЯЗЧёSм7hЧkUСљIўќЭЦ­Є'D7TИыŸtg h–[;#Э9ЬхK Ђj:c[L<–†l6•Ю’†>‡ПлtЙ“ˆq†Pe+‡\дь$—qБb˜"в:Пн4[іE}­ ]ез6АЩ5KгеЇESsѕХbўеWб3u#b Y:EDнЧyЄГзwV’%жН\/j‰YЦБ4Њ”ђ’K=ЂинПиЅёv€У>žЏЧФ$ћ шtие ю}ВВ§>tоQ8JЩ7EЯ!†щž^EчOяwЋт1s_Ѓ–ШЯЭ0Ћ хдјЈD‰Й›€ыЊМі…ўšкЭV6š‚+sЮЪ. tYхзЩФdў ь<шTГ3'ќФио‚Иmt8Ц8•хNЧѕU’ЬgV—™dЩП{1 ~$%P”оыЭ†Z^дјEш"5ЃaјЪ "! гo†=шУ!5,d'_]ЇЦxePЋчќy ќ [іфыЋЕŠО!ŸzŸDŒMqсˆќ&:ЧбЌЅ‡—dЧŠ=/І(UqrЙЭуvxO_Б~пG^ЪЪ› a‹Їl§ч №В№Ю­ь—Ї}јбjlœ;мя‰›/ 7FщК•#ZA~q_ИVсБDMэ”й ]uГwfqbь8г>Ќ@Юї­|ЏЉд-НkƒO –tьre;РWіЄp$"№Е}щѓЛѓBМЅЗЮьзŒ1—ЋУЪ’~Œг^ес\A$ pы‘QЋЮідЊ>ЁАВЮЖ А…ѓІз-ѕž‡љІЏљпбАжdњ!/ЗP€§:8 ІьЊkщІ­MищЫ ВŸЯэ Zыv ЖЕи чSПпмž #йъЅЅ\/y$<ХЯ„‹|ф.‘6Jж4чžхћвЅЁоєвiэ}Š8љ—šы5*>š(€|Ї{Сю,ЧїМРЅЯczв ’Л џіЂ v2лNyыЋQл9ШЅœuэ†_мlЛ8ЌБ’Žь{Љ0#2ЪЖп;ПЙФ6k"Љ–œ™ кМ]~ •ъ%0™јœSёэуГз‚D”AzpС9ќV‚Њћƒљ(ЊШц N–Њч‚Эs“ц_Ќ—яLDD™4НйZН‚ЈНsЋНYœШЖCžNу '1= e"Н<tаоФлJqЁ0ЭdКМЬвF љ0яГХЬн~ЗЧU”жнШщ;Ф#\`мMЃA3| ЈxPїSH!ƒЌЄ|§ЋькЁAM7ѕНФёжэeƒAБг€]Я^ђ“љх{ЂЉr$§ЖН$тЎ яw 3ПwЈ]б—”$Н€˜МВГНЬ.ЫOЉх=DШUђзOšQОV#ГМњѓнЂpЅБ‘VFV#еИвЈ›N~Nšpaо#Ќэv]№Т‘ TЋ*ђЁЙ#sDuОВpЇnаЫ/:"Q–(буІјЪтЎХ[\щˆЙ:[0 VЦKыРmš}Љ\zЋ*AœЊ)ѓщм§сf=šЂCцŽ Ь7џїџЉЦbqSн0NгsПA§4ЖZц2~nЉdrц•^'qН­.T[АC+ЄЩДОѓ2ЖёSOrt)цwмРмБЅЗ‚B д №jЉУЧ ж$(*pVW:Aы3й}/fњFъ‡тбюaым3AЃ2ЏYt•ВИє=ѓкЧK•л\ЊVOТkяŸЮЖ—јЅпз>Є—шЌIkђЃ’ъ6M7чJ~ЗJ­%†;nеѕСЂ‰ЯЮpЎ›ЭJ}y Ÿ€)рƒ…YK]KVbVЩcyœ_ yЎ‚уё;БEѓЬВ2єМi f#фgюмgзЦрЋЯ”пф@„ЁŠшkйœЇЕTНjВшrЮmц>іpЩšщe‹эУVHКђ Т~ЅW…уЉwЙЬ~иErDЙЈљжxvWйЕОyDVjнk— бгЧ?№ВpєЋzЬEUZ,m#Дџђы'АBтьч*{ўЇўИ’тy цсcЛэаО”dЯГKнD–M ЦрŸ†K4.Ь†Ж­єvб(ѓ"B\B@rЌO!tКН(D‡r_SzbJћy ХхЂр5…РAB#šKwэ>#ч] ІŒ 1јој6Кr•x ЈБХюAѓоCлoў щКBёТœНТLž.єF8ч‘ё­„kА бфцЙ#Ottw.чкЭН?YcѕIсрžlW7<ъНV§Eол vЛfi•FўfєTЈŸ ™ѕР[Ц˜јёъtџ zx ЅЦЗы*f9ЭmЦя=€Н\мNъ9вR Ѓ:нvїЁ@…Чp#Иa*IB•“Їк*@яc0ХRnmЎаОЌЉ'jЈѓъдwѓдЇыЪ•МГDЬ Эч~“Кxб—љGщ)БnэЃSc_иЉrкГ/№юSdз˜кwZƒA% gч\(ƒ[Ќ>ј#tЬ—Eqбt_=ГяЮвdНjЂчымN~ ч“KўS ZЕ[”ЎЗwRB~FЅPhЈ žfУƒh7ѓ•/жйвaЩІ/,G k5АcъТОЃ ц eн+хMCеЅОœы. ьЈ ЦаGŠ\ƒb)_‰!’‡џ0ыy№mй•itП^§nPУНnO3\є}tОшМctњ?h$ьюmЮ}6ыФpEє€ОDйћ№š?iцпP­ћКЂШМъњlўЌс;Їž§оywњy|ЅаЉ‚–Kp\Јєѓ0’ТИ>ІаT„UЧ{€ыц/<)B& уŸТЛЦхœwљ=Ћ\ѓоpz—#DuN џЌфZЉR˜ƒВ^рAШ “эIаЊšžдKvЅB5јц,KšЎснnЏфLюпфмRubmЅџЮЯыЌ~•ЇBт!мчYrєНЁфyюIџlљмq ’П­-тcВœ,^< <E{ ь5{_‚в›ЉЛђI`>}XапнcЦ4§рtЦgcИ™K Ѕ{rЩЩ|—Зб™ь<їѕё~#rL‹Џš„Eы@мвШœцHй•fxй Њ4ІАьRmБІЁgU‰ј `эDХСegFя‚чЙ“`Ÿ>`)ЃŸьœьdп˜ЬТ;t~ј”ыеФg„Нюю=ˆА˜юœ<шzџ9 ЛySkФўpФж€ Ё,mXШЙ%иц|ыVКvЌeЛЩыт<ъMLзкD–Dн|ИЅ’M—СК8P”лхЭ ќд€,lKєzeЗr%1 ЕW ЦS%PЊjq#7†aћ!Ј_ЫD% СjрцќБГ ЮMxu.д]mfžЛtЎ:Ув{rЁ'э ЇžGЛяЂMPyУvиЊчЄ иu‘vоЂЏЅS`FёЉіжѓvяМъЊUЌjГЦн Є‘ђт’D–ЦџdНиюUуPЊubЊ’‚ЕаЩ@$sЗœ–рnrѓ'Ѕ=;ЯчUVфтЭШ­ыGЉj­ѕфљЧЈ 3вФcЭЌЈя гHђ/y™”Ьc‘ `р qдк—)ДSA!јDи<С$:ЬZ%"wЩfГѓLгSEќф–tšј‡р)№щ‚A.SXUw Шw`Ю HСЅзœž;€Œ;ТB…пњы€ћ„5рqлQшЭ—ј_sK2ЁMtЕj‹;Р$А„Р]™о†~œ*6В,л–х98з.ŽШ?Ђt=$ЅНыєZsc(ŽBOаф ј@PЌ6ол2ы 08. Б;‹#kgwђ“lН™ЛsбFЮKFѕ‘TЎЮkАиаn!Б­?вЊmуu4ы™k[ƒ xяг•_aу[ТJ~ХиШ-ЃNыЇPDВоЭч|гя‰ZIіDђ–мu…›DСѓї—%9Ї^Цмѓу›ŸЉ$шc5/ХOоѓа8.РUЬмaЁfsЗ2l jЁsE@Кц‰œŒњж!` _ŽТ6мЏИ@™ oЗшЩМэ€•о;^7ƒ%РCє2aOI чЂЋtѓХ`s‰иNжxј‚њnЌ­СŽž–ъЦћaz9‰9H‡эEDe1г(>н#‰6єFоnJЗБЉге–{5š2Ћь;$КуzўŸ :i TUЈыwГУеO^НЪЏм–c*шХEо” Љо9ељиe{rкьXщYО —c ?ШПгчRJ”+м?•€щ.DЉП№Ѓtаa8ѕ EƒmЫ ”ОЄ|ЙБ[іc@F_ЮќВ>фSC~dИIхrzьјt№ !p`y‹0Х]ьС5Љs‰ ХўЬ.ћѓЗД5tGчЯсЧыaбЬфкмъ…ІQ˜уМgж1иZY6qеj<ШFƒѓыэдеf,ьA@zыvќœІiфщЛ)жCCюЄУ˜нН\6,Оо_Мяћ7jЛh!Юg ЧKџn”цO™­§З~бH˜CT30~оъшS@rпЅ”2рSНmОE$Сў"xžxЯe&.ыžžsЦSЁZ_;Ј7Jcќ3њVы>“Ћ ‹:qpd VФm ~›˜Б.Ÿ\з}—}н{ю—ўрW%ulДŸ-ъyn˜q}э0h9чЩТЫBзhCГё ПЏ знр€4ђ/"d Я­D[вƒ№žoYюЉRїGkcš6 ŒHЭaDп к35ЉолЁЯЎћ~yzККY§ЯиЗЦaШнh2­`HДœЪ ЄwaГбзЉ})‡ХрvKО'–FHB2yŠЭ6Е’‚tњЭPЅ)ЉФЎ ГЛ6OжЄрЋєК3ч{0ЅяјкЈ&№єBд8Sпе}Щ>5< lзж)Fд ”ЦBБВб‰DаkvA^Y!ЫИЙРтЯ)­щрѓчЌц{їмэдІhьOs•=ЂAж№ул—н<бŒѓ јќуG-Ц[Їч?=@94и‰V;Ё{J:ž:…саWйFУТъААј_ŸЖИ;CшѓиО–UЭуВ\ƒкЗXуИй+„ЫпГи)m™OsЉХ˜UGЁ3{9гœ и‰рЇбoТ‚ЦUЃ„УќYК"N7uнA:Д[nB6m3g“ЯcЎхн!ЈŸ9Ћ‚sІР`ёБЪј•ˆђљ|0ъLлaПЏКwc№hљ?†„њŸ'Вк’GV;5Г0 =ž|ЬюPАtF™sSX§фrмЈЏ К”9U КaY#№љ™V яЅо[ЩT)фHГеt‰/a-ЕЈъ€№_зŠЃхЯД3є– –е€ї—YЖoД>Š[чОЎWм“ЖMЫ\fчЗP Ю@Œ№XXнDm]IKь8§y„д_БРЦџЉY ЂВ§eeИдž€4тл*лђ^G2о9’ђИ#ыHƒєt чœk­ё1Ь‚.ž!ЦЮpєRаьршfoВ….!œxЋ$ГšN5Рј=Э)~ЯхКKЗpэБ=ЦCk]Їс†ћdЫT рd2о<хХофCJр—Ј НЧn‚крU%•ѓўЏŒnžwзях˜›~sƒŸ›ыA2Е™ŸOЮжЁZFе)=TЪ­RqgG”У|H5loЪМп ЗОыK АЋюЬWŸчќНИќlЌmšВEEОѕ§AА1H—MhдXE•і†bTIŸЮkDPЏ%ђˆ’‚яlnШ tШа ]г$–ЯZEЩ$9іќ9sŽv>ј—5ѓgЦ уKзщFNю/В е.чP}3БЎC’–У§ƒašnхoЉхЗW^›˜;щ-sѕMѕ'ЎЮд_I–>ЖнЅЉЊќ•ч2зxс4ŸwырРЃ­C‚д…Ym–*дю'mалдVŒ™Ё,Ќ~еMA  *w €ЛЉ*є3NШоэ„Туžн­IУыWž"ёJvт@ЮUxЫ|№іtпб—9гŽš]гmЌyєъaъухЂZvK К››37ЁЧ |Мۘ™йЛ0МЏнYоБиo:эОƒ З–ЗJœhШ`a\ѓ`нЏЎь§нFХZВBЖўЭігŠЬIЊ-f4оЎЏсг;эe“цђ4е(”Вu0љЉо№хi–on›ЩIUфX І€\ъєh\MSы‚­E нмGRnЙТяТцЇto ѓ›ПАFŽжщ{ю@П$хЖЕd 6€J*§ЩwЮ”5_ Y} mIЇцЫНQЇ…Н~І€m‡BЧсєЛєRТ=VxЯ№qЁ•q#Й2Ў/ЯЇфщЕђ№—dЎЖ№ М`ђxRЅ.qЁбЅнЮPЎžіІ†cјD˜.ж=IИЂюиw)№9ўєЌ†kСћ”}v%.КвмємMž•Zw‡P˜п@ЦSŽ њгћВJл•TKвЫ™Y\ѓЮ$ЈdЭKе<5ы} ўЧzђя šcnдx6,д9сJкЂœ+Шh ё6Œ ZєxaМ<Ы€F„‘_  GC=’§HaяbEXГЂЕчšЗyлr]у‰@_Г-,HљцЄ сЬbЖБ–•Ч,›кg_QЈ@ЇН{ЏcOЕоБЁu~I…s\–y1"х ЛлZТ’Тй…5ZщІъcя­.E kvАcQЈšf[мф!ы4ьељlsPsч_OQЏкХy5Œ]Т0=ГФж>]йyS=$œъAж' VІ1aX№З>SќipАЇэœі%о\mmSg:н—ь7f’ъЄЌйЮ•ЈАџwоЕD;ѕћяё‘в fSгЖ еœeЏЫІыoЉEТДХ{%ы ћ œWВfI3E ц#и­[щ^ йГtЊ>?u|,ynwF'љ‡с‰внƒЏ)ITNMB?j0uЉК ЭБъ…ФјХ!„ЂŠoЄмвЉ \œ%[єѓŽ•кћhЂЪ}jє”сšБњ ŸКЈЪ"з№nћб1цŒdЋc /t”2|AmyўњPyєМuПаѓœхЬгО,•˜нtƒШ‘"ЂЋЗ­U­!Ǻ͘ГJвjћ“z LЬьржєыЏх=pPўž хеp­Ѓw1_<И™FGх‡т]%-˜|ћ2іtr 3CmGZєhЫ;(!l$є<WT€’ЈЂ$`•:­TЙO^}п<п8hžЅF9кылjXЄFТ™`мЙ њ$ъ •гЃкlЉ‹ВФ8u{юуЦXZъuтXЅP[э †Т*WЖАБbPмѕЯЪРђћWэHy/їѕдQsј[—zDšj№УZЎu;•є|ЁЮя3АЛХрвVЭЃеАŠѕmјxШПJ­kуОЦqP€bjиШ ЛОMјщтЂн7ќЌтE>х9Ч4”.1ŸhГEхh uИМ/IЂ*!Ђ"У'зИ/names/ncb/targetinfo/ncb/moduleinfo/ncb/modulecommandlines/ncb/iinstdefs/ncb/auxnamemap/ncb/directorywatch/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\assert.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\compat.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\dump.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\errno.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\extract-dbl.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\invalid.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\memory.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mp_bpl.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mp_clz_tab.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mp_dv_tab.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mp_get_fns.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mp_minv_tab.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mp_set_fns.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\rand.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\randbui.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\randclr.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\randdef.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\randiset.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\randlc2s.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\randlc2x.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\randmt.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\randmts.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\randmui.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\rands.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\randsd.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\randsdui.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\tal-reent.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\version.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\add.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\add_1.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\add_n.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\addmul_1.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\addsub_n.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\bdivmod.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\cmp.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\dc_divrem_n.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\dive_1.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\diveby3.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\divis.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\divrem.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\divrem_1.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\divrem_2.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\fib2_ui.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\gcd.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\gcd_1.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\gcdext.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\get_d.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\get_str.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\jacbase.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\lshift.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\mod_1.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\mod_34lsub1.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\mode1o.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\mul.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\mul_1.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\mul_basecase.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\mul_fft.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\mul_n.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\mullow_basecase.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\mullow_n.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\perfsqr.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\popham.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\gmp.h/ncb/module/c:\archivos de programa\microsoft visual studio 8\vc\include\iosfwd/ncb/module/c:\archivos de programa\microsoft visual studio 8\vc\include\cstdio/ncb/module/c:\archivos de programa\microsoft visual studio 8\vc\include\yvals.h/ncb/module/c:\archivos de programa\microsoft visual studio 8\vc\include\crtdefs.h/ncb/module/c:\archivos de programa\microsoft visual studio 8\vc\include\sal.h/ncb/module/c:\archivos de programa\microsoft visual studio 8\vc\include\vadefs.h/ncb/module/c:\archivos de programa\microsoft visual studio 8\vc\include\use_ansi.h/ncb/module/c:\archivos de programa\microsoft visual studio 8\vc\include\stdio.h/ncb/module/c:\archivos de programa\microsoft visual studio 8\vc\include\swprintf.inl/ncb/module/c:\archivos de programa\microsoft visual studio 8\vc\include\cstring/ncb/module/c:\archivos de programa\microsoft visual studio 8\vc\include\string.h/ncb/module/c:\archivos de programa\microsoft visual studio 8\vc\include\cwchar/ncb/module/c:\archivos de programa\microsoft visual studio 8\vc\include\wchar.h/ncb/module/c:\archivos de programa\microsoft visual studio 8\vc\include\wtime.inl/ncb/module/c:\archivos de programa\microsoft visual studio 8\vc\include\xstddef/ncb/module/c:\archivos de programa\microsoft visual studio 8\vc\include\cstddef/ncb/module/c:\archivos de programa\microsoft visual studio 8\vc\include\stddef.h/ncb/module/c:\archivos de programa\microsoft visual studio 8\vc\include\crtdbg.h/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\pow_1.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\pre_divrem_1.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\pre_mod_1.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\random.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\random2.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\rootrem.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\rshift.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\sb_divrem_mn.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\scan0.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\scan1.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\set_str.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\sizeinbase.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\sqr_basecase.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\sqrtrem.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\sub.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\sub_1.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\sub_n.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\submul_1.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpn\generic\tdiv_qr.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\win32\fib_table.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\win32\mp_bases.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\x64\fib_table.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\x64\mp_bases.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\scanf\doscan.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\scanf\fscanf.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\scanf\fscanffuns.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\scanf\scanf.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\scanf\sscanf.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\scanf\sscanffuns.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\scanf\vfscanf.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\scanf\vscanf.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\scanf\vsscanf.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\abs.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\add.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\add_ui.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\ceilfloor.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\clear.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\cmp.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\cmp_d.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\cmp_si.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\cmp_ui.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\div.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\div_2exp.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\div_ui.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\dump.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\eq.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\fits_sint.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\fits_slong.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\fits_sshort.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\fits_uint.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\fits_ulong.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\fits_ushort.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\get_d.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\get_d_2exp.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\get_dfl_prec.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\get_prc.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\get_si.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\get_str.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\get_ui.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\init.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\init2.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\inp_str.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\int_p.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\iset.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\iset_d.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\iset_si.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\iset_str.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\iset_ui.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\mul.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\mul_2exp.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\mul_ui.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\neg.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\out_str.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\pow_ui.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\random2.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\reldiff.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\set.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\set_d.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\set_dfl_prec.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\set_prc.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\set_prc_raw.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\set_q.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\set_si.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\set_str.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\set_ui.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\set_z.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\size.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\sqrt.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\sqrt_ui.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\sub.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\sub_ui.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\swap.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\trunc.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\ui_div.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\ui_sub.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpf\urandomb.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpq\abs.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpq\aors.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpq\canonicalize.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpq\clear.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpq\cmp.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpq\cmp_si.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpq\cmp_ui.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpq\div.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpq\equal.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpq\get_d.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpq\get_den.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpq\get_num.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpq\get_str.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpq\init.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpq\inp_str.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpq\inv.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpq\md_2exp.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpq\mul.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpq\neg.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpq\out_str.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpq\set.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpq\set_d.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpq\set_den.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpq\set_f.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpq\set_num.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpq\set_si.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpq\set_str.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpq\set_ui.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpq\set_z.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpq\swap.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\abs.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\add.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\add_ui.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\and.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\aorsmul.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\aorsmul_i.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\array_init.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\bin_ui.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\bin_uiui.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\cdiv_q.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\cdiv_q_ui.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\cdiv_qr.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\cdiv_qr_ui.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\cdiv_r.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\cdiv_r_ui.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\cdiv_ui.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\cfdiv_q_2exp.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\cfdiv_r_2exp.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\clear.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\clrbit.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\cmp.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\cmp_d.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\cmp_si.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\cmp_ui.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\cmpabs.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\cmpabs_d.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\cmpabs_ui.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\com.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\combit.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\cong.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\cong_2exp.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\cong_ui.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\dive_ui.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\divegcd.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\divexact.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\divis.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\divis_2exp.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\divis_ui.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\dump.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\export.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\fac_ui.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\fdiv_q.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\fdiv_q_ui.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\fdiv_qr.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\fdiv_qr_ui.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\fdiv_r.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\fdiv_r_ui.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\fdiv_ui.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\fib2_ui.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\fib_ui.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\fits_sint.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\fits_slong.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\fits_sshort.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\fits_uint.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\fits_ulong.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\fits_ushort.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\gcd.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\gcd_ui.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\gcdext.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\get_d.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\get_d_2exp.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\get_si.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\get_str.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\get_ui.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\getlimbn.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\hamdist.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\import.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\init.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\init2.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\inp_raw.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\inp_str.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\invert.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\ior.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\iset.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\iset_d.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\iset_si.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\iset_str.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\iset_ui.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\jacobi.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\kronsz.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\kronuz.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\kronzs.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\kronzu.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\lcm.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\lcm_ui.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\lucnum2_ui.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\lucnum_ui.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\millerrabin.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\mod.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\mul.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\mul_2exp.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\mul_si.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\mul_ui.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\n_pow_ui.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\neg.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\nextprime.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\out_raw.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\out_str.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\perfpow.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\perfsqr.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\popcount.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\pow_ui.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\powm.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\powm_ui.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\pprime_p.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\random.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\random2.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\realloc.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\realloc2.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\remove.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\root.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\rootrem.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\rrandomb.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\scan0.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\scan1.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\set.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\set_d.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\set_f.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\set_q.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\set_si.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\set_str.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\set_ui.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\setbit.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\size.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\sizeinbase.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\sqrt.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\sqrtrem.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\sub.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\sub_ui.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\swap.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\tdiv_q.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\tdiv_q_2exp.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\tdiv_q_ui.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\tdiv_qr.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\tdiv_qr_ui.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\tdiv_r.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\tdiv_r_2exp.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\tdiv_r_ui.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\tdiv_ui.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\tstbit.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\ui_pow_ui.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\ui_sub.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\urandomb.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\urandomm.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpz\xor.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\printf\asprintf.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\printf\asprntffuns.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\printf\doprnt.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\printf\doprntf.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\printf\doprnti.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\printf\fprintf.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\printf\obprintf.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\printf\obprntffuns.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\printf\obvprintf.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\printf\printf.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\printf\printffuns.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\printf\repl-vsnprintf.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\printf\snprintf.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\printf\snprntffuns.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\printf\sprintf.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\printf\sprintffuns.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\printf\vasprintf.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\printf\vfprintf.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\printf\vprintf.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\printf\vsnprintf.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\printf\vsprintf.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\cxx\isfuns.cc/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\cxx\ismpf.cc/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\cxx\ismpq.cc/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\cxx\ismpz.cc/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\cxx\ismpznw.cc/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\cxx\osdoprnti.cc/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\cxx\osfuns.cc/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\cxx\osmpf.cc/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\cxx\osmpq.cc/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\cxx\osmpz.cc/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\abort_prec_max.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\acos.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\acosh.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\add.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\add1.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\add1sp.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\add_ui.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\agm.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\asin.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\asinh.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\atan.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\atan2.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\atanh.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\cache.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\cbrt.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\check.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\clear.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\clears.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\cmp.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\cmp2.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\cmp_abs.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\cmp_d.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\cmp_ld.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\cmp_si.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\cmp_ui.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\comparisons.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\const_catalan.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\const_euler.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\const_log2.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\const_pi.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\constant.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\copysign.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\cos.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\cosh.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\cot.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\coth.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\csc.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\csch.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\dim.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\div.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\div_2exp.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\div_2si.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\div_2ui.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\div_ui.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\dump.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\eint.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\eq.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\erf.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\erfc.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\exceptions.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\exp.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\exp10.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\exp2.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\exp3.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\exp_2.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\expm1.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\extract.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\factorial.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\fits_intmax.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\fits_sint.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\fits_slong.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\fits_sshort.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\fits_uint.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\fits_uintmax.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\fits_ulong.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\fits_ushort.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\fma.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\frac.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\free_cache.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\gamma.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\get_d.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\get_exp.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\get_f.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\get_ld.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\get_si.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\get_sj.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\get_str.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\get_ui.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\get_uj.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\get_z.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\get_z_exp.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\gmp_op.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\hypot.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\init.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\init2.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\inits.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\inits2.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\inp_str.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\int_ceil_log2.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\isinf.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\isinteger.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\isnan.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\isnum.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\isqrt.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\iszero.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\lngamma.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\log.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\log10.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\log1p.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\log2.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\logging.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\minmax.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\mp_clz_tab.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\mpfr-gmp.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\mpn_exp.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\mul.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\mul_2exp.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\mul_2si.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\mul_2ui.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\mul_ui.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\mulders.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\neg.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\next.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\out_str.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\pow.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\pow_si.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\pow_ui.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\pow_z.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\powerof2.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\print_raw.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\print_rnd_mode.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\random.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\random2.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\reldiff.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\rint.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\root.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\round_near_x.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\round_p.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\round_prec.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\sec.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\sech.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\set.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\set_d.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\set_dfl_prec.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\set_exp.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\set_f.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\set_inf.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\set_ld.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\set_nan.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\set_prc_raw.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\set_prec.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\set_q.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\set_rnd.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\set_si.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\set_si_2exp.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\set_sj.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\set_str.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\set_str_raw.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\set_ui.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\set_ui_2exp.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\set_uj.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\set_z.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\setmax.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\setmin.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\sgn.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\si_op.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\sin.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\sin_cos.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\sinh.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\sqr.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\sqrt.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\sqrt_ui.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\stack_interface.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\strtofr.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\sub.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\sub1.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\sub1sp.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\sub_ui.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\subnormal.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\sum.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\swap.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\tan.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\tanh.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\uceil_exp2.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\uceil_log2.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\ufloor_log2.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\ui_div.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\ui_pow.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\ui_pow_ui.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\ui_sub.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\urandomb.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\version.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\volatile.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\mpfr\zeta.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\gen-bases\gen-bases.c/ncb/module/c:\archivos de programa\microsoft visual studio 8\vc\include\math.h/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\gen-fac_ui\gen-fac_ui.c/ncb/module/c:\archivos de programa\microsoft visual studio 8\vc\include\stdlib.h/ncb/module/c:\archivos de programa\microsoft visual studio 8\vc\include\limits.h/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\gen-fib\gen-fib.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\gen-psqr\gen-psqr.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\tests\memory.c/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\tests\misc.c/ncb/module/c:\archivos de programa\microsoft visual studio 8\vc\include\ctype.h/ncb/module/c:\archivos de programa\microsoft visual studio 8\vc\include\signal.h/ncb/module/c:\archivos de programa\microsoft visual studio 8\vc\include\float.h/ncb/module/c:\archivos de programa\microsoft visual studio 8\vc\include\crtwrn.h/ncb/module/c:\archivos de programa\microsoft visual studio 8\vc\include\time.h/ncb/module/c:\archivos de programa\microsoft visual studio 8\vc\include\time.inl/ncb/module/c:\unix\cygwin\home\juanjo\src\ecl\msvc\gmp-4.2.1\tests\tests.h/ncb/module/c:\archivos de programa\microsoft visual studio 8\vc\include\setjmp.h/ncb/module/c:\archivos de programa\microsoft visual studio 8\vc\include\string/ncb/module/c:\archivos de programa\microsoft visual studio 8\vc\include\istream/ncb/module/c:\archivos de programa\microsoft visual studio 8\vc\include\ostream/ncb/module/c:\archivos de programa\microsoft visual studio 8\vc\include\ios/ncb/module/c:\archivos de programa\microsoft visual studio 8\vc\include\xlocnum/ncb/module/c:\archivos de programa\microsoft visual studio 8\vc\include\climits/ncb/module/c:\archivos de programa\microsoft visual studio 8\vc\include\cstdlib/ncb/module/c:\archivos de programa\microsoft visual studio 8\vc\include\streambuf/ncb/module/c:\archivos de programa\microsoft visual studio 8\vc\include\xiosbase/ncb/module/c:\archivos de programa\microsoft visual studio 8\vc\include\xlocale/ncb/module/c:\archivos de programa\microsoft visual studio 8\vc\include\stdexcept/ncb/module/c:\archivos de programa\microsoft visual studio 8\vc\include\exception/ncb/module/c:\archivos de programa\microsoft visual studio 8\vc\include\eh.h/ncb/module/c:\archivos de programa\microsoft visual studio 8\vc\include\malloc.h/ncb/module/c:\archivos de programa\microsoft visual studio 8\vc\include\xstring/ncb/module/c:\archivos de programa\microsoft visual studio 8\vc\include\xmemory/ncb/module/c:\archivos de programa\microsoft visual studio 8\vc\include\new/ncb/module/c:\archivos de programa\microsoft visual studio 8\vc\include\xutility/ncb/module/c:\archivos de programa\microsoft visual studio 8\vc\include\utility/ncb/module/c:\archivos de programa\microsoft visual studio 8\vc\include\typeinfo/ncb/module/c:\archivos de programa\microsoft visual studio 8\vc\include\xdebug/ncb/module/c:\archivos de programa\microsoft visual studio 8\vc\include\xlocinfo/ncb/module/c:\archivos de programa\microsoft visual studio 8\vc\include\xlocinfo.h/ncb/module/c:\archivos de programa\microsoft visual studio 8\vc\include\locale.h/ncb/module/c:\archivos de programa\microsoft visual studio 8\vc\include\share.h/ncb/module/c:\archivos de programa\microsoft visual studio 8\vc\include\strstream/ncb/targetmap/ncb/filenameimodmap/ncb/moduleinfofreelist/ncb/versioninfomвО§X4ћўаўчїџг—ёXО‡N<ŸŽ\Нџ9Iј”CџслžъmХ+Њаuўљф?_…имџџџ.џ‚6сpїёПфХџбщџ{­Р[ѓџџњџ‡љџЮˆ@`€џуКя?Ш{ЈaHЎ €џџџ‰ѓџћџїП@„ћТџџGч‹ивŠз#P=ВŽфrˆИЅ”ј’ёoLрЃ+ЎЅ1%r„Ш$iœƒAсM 37ИlА +Фыš@о Еbе%шZNЯJГ–џя—=’№*‘оFѓ7^kPjjynGeZKQ›ŒнŽ<аЈp‡cT!/Ђў4ЖY”ї…•ћџ"Ѓs‰aMCц:<€yѓWфK§…ЧwБ?‡Ы†ž:[у0Јј'ŠЙI-W*N #ŸДPЖZ6ъ{ЅЈ€ЕЦ1Ћ.АIN ыš ХnyRUцЗkŒлN†Ш^…ХŠИmП?лВM вlи r4dšCш7Н†Щ5$}ŽтŽ^C—V(њЏRЛ™ gŽу…ŠжлƒРё9Чц;0Ѕ.­I†eX-‚Є-œАT-ВYГ‚МмІ54AрR`I2Ќa]?”heф~Џ~LXš u}Њ0HL—_gaкAPŒм§jmI5Зќ‚Н’e[Ї-;Iћˆ&…oz.?йКJ1R%Ї6ЎzЁОˆаŸ+–ВU%Œ$QЧaNh'ˆЩ8УЬmv38Сж<б‡ЬfBф§E№#ˆЮ+1ЉtЋDЁ‰гў–ђ%ƒN …ФžЖg+rnxQ~­‘ь  Њ  ГdXкqƒ'}Љ4aTšQѓS0п$ЋCЂ 4kZ59žпbO+”+GєdVl=г&f]FXРw—xЌGЩRЃHљф[:Ќ]@c‚Лuw–M?лe\p} Hї–[9 ,S+•ю Eэ>Y1сЉ?Z4fM ”Зj=:ШњЅ2;˜u1Њ€ qXsˆд.ЁQхQ7?ї 5 =вујЈ< x˜ /‹T!Œ\УW,›~ЎцNŸ#{q„ТН>ЗKknЧГ^йDє€Жњgc•(Œ“Љ>(“ѓЉ .š S,mtyGѕ•v“(U#ЮAт-›Щ,šLц [7'—Yuэ#|q‚rr…хŒоŽ3Б4Dъ+Eф>и~8Т…DыРВП“ѕшCщ ”і@ЗiHFёi™™ИnП6М=&„LАS› 7р`jdWw?кAЁ"–0jЯЄ.{­JИo|иf"vбВ[Хii.щКЎN!4Г@.ŸйЁ$хž`JmЂ&Фf_њzЂKV'тшм5Й[€Д€ГЦИp;•њŠ@bO9Фщkpѕ]A},™ƒhq“єЎИo"nw xš ‰б?T ЌЈ;ˆlrЁ#_Б'‰КДaдI§P7Ов:ЪЭo›—Жu–Ѓ*\ЏP…CЅ/ uŽ0вЌHvf^ЂVЊjl|!t#Г\;|ІўU&8lqпhfr6ЛмБXtГ]YRKяHњЗ!„Oй‡Эп>R#zf"wLЖfѓ-žzmu€k' pо]b2­3)Žxihf;Ь[bPл’ђ@9э 8мGгO“Fђјp€О_G[ *3,˜‚)жT"в)`Ј:й^DвcU{ъЉSK0ІQ`%g–ў}$~^ —0Ї[9Хи3ВxW+j‹йе˜MЃ)эАU‹БWЉЕdРMё‘яq_Fы7РЩ!uЄ‘юF{ЃZjkЭLv‘@мˆ˜Ќ2ЎkEюbЅ0Ш\=ЎL$mГ"xД_/!sхСr†—чmJџ>еWp~В;ЭsˆЯˆbškoY ЊgbЅbQжY3’І4Œ. O{р—{ЄћЕeM>ж9Šеэ‰д№bRzŸgo{рv”ŽY2œЖ=д;Ыї2Џ™Kя†Ъ­…Ц*w•jug`Ј9.Њ@ЁX/VX.>БVЖP~ВZOCчbz IІ3Bt‹М*“JўhД`Ѕ9Ц™T 0A^BGЉ=oŸюsŠМŸа&†Ux™ŒtŒZ‘э›—N NKПЇ8Чс )Kv’'‡F(‹зtK 6|\<О„Уg'Ѓ(Й Ъyž\Еcлls'6К’5И‹|ЇЈ 15aLBуDq `Hх(,BЈ%‚ГEя-igC3Ађ”љ"Ђ%%_EKЦЊBюЖh6O’:™>з,gЖ4Еo UHј&„СM4›ЖЂ'й|ЈЁš 7yœъ+—њ 2k*’oЇ7ыx›r Е‹кЎЏQв•ќR@нДBх&V‰вЏSqяЬ‚ЭЉž‰Л.dьЙ_ЎšДŒЃ,,мЂ§l0<2а_жŽд4 2sЈˆn~/ь j*ˆšUV€к ‚Œ"LXи*"9Zо€!0žќ1zоNF(кlPЖ P”ЎfЈ 6ž@ Ќ њј`Lм ѓєѕіїјљњћќ§ўџ      !"#$%&?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ЁЂЃЄЅІЇЈЉЊЋЌ­ЎЏАБВГДЕЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯабвгдежзийклмнопрстуфхцчшщъыьэюя№ёђ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžГДЕЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯабвгделмнопрстуфхцчшщъыьэюя№ёђѓєѕіїјљњћќ§ўџ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ЁЂЃЄЅІЇЈЉЊЋЌ­ЎЏАБВГДЕЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯабвгдежзийклмнопрстуфхцчшщъыьэюя№ёђѓєѕіїјљњћќ§ўџ      !"#$%&'(*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ЁЂЃЄЅІЇЈЉЊЋЌ­ЎЏАБВГДЕЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯабвгдежзийклмнопрстуфхцчшщъыьэюя№ёђѓєѕіїјљњћќ§ўџ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ЁЂЃЄЅІЇЈЉЊЋЌ­ЎЏАБВГДЕЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯабвгдежзийклмнопрстуфхцчшщъыьэюя№ёђѓєѕіїјљњћќ§ўџ      !"#$%&'()*+,-./0123456789:;<=)  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ЁЂЃЄЅІЇЈЉЊЋЌ­ЎЏАБВГДЕЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯабвгдежзийклмнопрстуфхцчшщъыьэюя№ёђѓєѕіїјљњћќ§ўџ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ЁЂЃЄЅІЇЈЉЊЋЌ­ЎЏАБВГДЕЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯабвгдежзийклмнопрстуфхцчшщъыьэюя№ёђѓєѕіїјљњћќ§ўџ     Ÿ ЁЂЃЄЅІЇЈЉЊЋЌ­ЎЏАБВжзийк>'()*+,-./0ecl-16.1.2/msvc/gmp/build.vc8/gmp.sln000077500000000000000000004076401266352375300172300ustar00rootroot00000000000000Microsoft Visual Studio Solution File, Format Version 9.00 # Visual Studio 2005 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "dll_gmp_gc", "dll_gmp_gc\dll_gmp_gc.vcproj", "{7DA5BAD1-B5CF-4F53-8560-E96C07DE023D}" ProjectSection(ProjectDependencies) = postProject {0412953E-06CE-4A60-9DCD-CA5CAC3A46CC} = {0412953E-06CE-4A60-9DCD-CA5CAC3A46CC} {001E0D42-4AF4-44B8-A8B2-3CD46D537DBE} = {001E0D42-4AF4-44B8-A8B2-3CD46D537DBE} {2297FA81-6D9D-4DC3-BA42-04E93F397047} = {2297FA81-6D9D-4DC3-BA42-04E93F397047} {D3C6D6B7-CD38-4D49-9BA7-1FBB35F77223} = {D3C6D6B7-CD38-4D49-9BA7-1FBB35F77223} EndProjectSection EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "lib_gmp", "lib_gmp\lib_gmp.vcproj", "{FA999C2A-A4D2-4331-8D63-E3A8B05EC58F}" ProjectSection(ProjectDependencies) = postProject {0412953E-06CE-4A60-9DCD-CA5CAC3A46CC} = {0412953E-06CE-4A60-9DCD-CA5CAC3A46CC} {001E0D42-4AF4-44B8-A8B2-3CD46D537DBE} = {001E0D42-4AF4-44B8-A8B2-3CD46D537DBE} {2297FA81-6D9D-4DC3-BA42-04E93F397047} = {2297FA81-6D9D-4DC3-BA42-04E93F397047} {D3C6D6B7-CD38-4D49-9BA7-1FBB35F77223} = {D3C6D6B7-CD38-4D49-9BA7-1FBB35F77223} EndProjectSection EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "lib_gmpxx", "lib_gmpxx\lib_gmpxx.vcproj", "{C82A62DB-DDB4-4072-832F-6DD841C6D80E}" ProjectSection(ProjectDependencies) = postProject {FA999C2A-A4D2-4331-8D63-E3A8B05EC58F} = {FA999C2A-A4D2-4331-8D63-E3A8B05EC58F} EndProjectSection EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "lib_mpfr", "lib_mpfr\lib_mpfr.vcproj", "{96DA1C71-3895-49FA-A4F1-2775C650AF3D}" ProjectSection(ProjectDependencies) = postProject {FA999C2A-A4D2-4331-8D63-E3A8B05EC58F} = {FA999C2A-A4D2-4331-8D63-E3A8B05EC58F} EndProjectSection EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "dll_mpfr", "dll_mpfr\dll_mpfr.vcproj", "{8A1EB575-B721-4891-B5BD-17CC45D0103C}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "lib_gmp_gc", "lib_gmp_gc\lib_gmp_gc.vcproj", "{4AF4FD03-C169-456A-966A-081DE6BB71C7}" ProjectSection(ProjectDependencies) = postProject {0412953E-06CE-4A60-9DCD-CA5CAC3A46CC} = {0412953E-06CE-4A60-9DCD-CA5CAC3A46CC} {001E0D42-4AF4-44B8-A8B2-3CD46D537DBE} = {001E0D42-4AF4-44B8-A8B2-3CD46D537DBE} {2297FA81-6D9D-4DC3-BA42-04E93F397047} = {2297FA81-6D9D-4DC3-BA42-04E93F397047} {D3C6D6B7-CD38-4D49-9BA7-1FBB35F77223} = {D3C6D6B7-CD38-4D49-9BA7-1FBB35F77223} EndProjectSection EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "lib_gmp_p0", "lib_gmp_p0\lib_gmp_p0.vcproj", "{AF57F91F-EB17-4989-B98F-FD59409FA4EC}" ProjectSection(ProjectDependencies) = postProject {001E0D42-4AF4-44B8-A8B2-3CD46D537DBE} = {001E0D42-4AF4-44B8-A8B2-3CD46D537DBE} {2297FA81-6D9D-4DC3-BA42-04E93F397047} = {2297FA81-6D9D-4DC3-BA42-04E93F397047} {D3C6D6B7-CD38-4D49-9BA7-1FBB35F77223} = {D3C6D6B7-CD38-4D49-9BA7-1FBB35F77223} {0412953E-06CE-4A60-9DCD-CA5CAC3A46CC} = {0412953E-06CE-4A60-9DCD-CA5CAC3A46CC} {FA999C2A-A4D2-4331-8D63-E3A8B05EC58F} = {FA999C2A-A4D2-4331-8D63-E3A8B05EC58F} EndProjectSection EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "lib_gmp_p3", "lib_gmp_p3\lib_gmp_p3.vcproj", "{8A2E028B-6E13-4E8A-B0F5-9A58C30BFB11}" ProjectSection(ProjectDependencies) = postProject {FA999C2A-A4D2-4331-8D63-E3A8B05EC58F} = {FA999C2A-A4D2-4331-8D63-E3A8B05EC58F} {0412953E-06CE-4A60-9DCD-CA5CAC3A46CC} = {0412953E-06CE-4A60-9DCD-CA5CAC3A46CC} {001E0D42-4AF4-44B8-A8B2-3CD46D537DBE} = {001E0D42-4AF4-44B8-A8B2-3CD46D537DBE} {2297FA81-6D9D-4DC3-BA42-04E93F397047} = {2297FA81-6D9D-4DC3-BA42-04E93F397047} {D3C6D6B7-CD38-4D49-9BA7-1FBB35F77223} = {D3C6D6B7-CD38-4D49-9BA7-1FBB35F77223} EndProjectSection EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "lib_gmp_p4", "lib_gmp_p4\lib_gmp_p4.vcproj", "{51A9B98F-FBB4-43B7-9029-2DCC3D9BD0E6}" ProjectSection(ProjectDependencies) = postProject {001E0D42-4AF4-44B8-A8B2-3CD46D537DBE} = {001E0D42-4AF4-44B8-A8B2-3CD46D537DBE} {2297FA81-6D9D-4DC3-BA42-04E93F397047} = {2297FA81-6D9D-4DC3-BA42-04E93F397047} {D3C6D6B7-CD38-4D49-9BA7-1FBB35F77223} = {D3C6D6B7-CD38-4D49-9BA7-1FBB35F77223} {0412953E-06CE-4A60-9DCD-CA5CAC3A46CC} = {0412953E-06CE-4A60-9DCD-CA5CAC3A46CC} {FA999C2A-A4D2-4331-8D63-E3A8B05EC58F} = {FA999C2A-A4D2-4331-8D63-E3A8B05EC58F} EndProjectSection EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "dll_gmp_p4", "dll_gmp_p4\dll_gmp_p4.vcproj", "{E1695434-494C-4FCD-804D-F2409528DC1F}" ProjectSection(ProjectDependencies) = postProject {0412953E-06CE-4A60-9DCD-CA5CAC3A46CC} = {0412953E-06CE-4A60-9DCD-CA5CAC3A46CC} {001E0D42-4AF4-44B8-A8B2-3CD46D537DBE} = {001E0D42-4AF4-44B8-A8B2-3CD46D537DBE} {2297FA81-6D9D-4DC3-BA42-04E93F397047} = {2297FA81-6D9D-4DC3-BA42-04E93F397047} {D3C6D6B7-CD38-4D49-9BA7-1FBB35F77223} = {D3C6D6B7-CD38-4D49-9BA7-1FBB35F77223} EndProjectSection EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "dll_gmp_p0", "dll_gmp_p0\dll_gmp_p0.vcproj", "{B5917427-4096-4AE9-833C-D9129C08C2B7}" ProjectSection(ProjectDependencies) = postProject {0412953E-06CE-4A60-9DCD-CA5CAC3A46CC} = {0412953E-06CE-4A60-9DCD-CA5CAC3A46CC} {001E0D42-4AF4-44B8-A8B2-3CD46D537DBE} = {001E0D42-4AF4-44B8-A8B2-3CD46D537DBE} {2297FA81-6D9D-4DC3-BA42-04E93F397047} = {2297FA81-6D9D-4DC3-BA42-04E93F397047} {D3C6D6B7-CD38-4D49-9BA7-1FBB35F77223} = {D3C6D6B7-CD38-4D49-9BA7-1FBB35F77223} EndProjectSection EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "dll_gmp_p3", "dll_gmp_p3\dll_gmp_p3.vcproj", "{9A3A242F-1472-4776-9839-CC62474B7F54}" ProjectSection(ProjectDependencies) = postProject {0412953E-06CE-4A60-9DCD-CA5CAC3A46CC} = {0412953E-06CE-4A60-9DCD-CA5CAC3A46CC} {001E0D42-4AF4-44B8-A8B2-3CD46D537DBE} = {001E0D42-4AF4-44B8-A8B2-3CD46D537DBE} {2297FA81-6D9D-4DC3-BA42-04E93F397047} = {2297FA81-6D9D-4DC3-BA42-04E93F397047} {D3C6D6B7-CD38-4D49-9BA7-1FBB35F77223} = {D3C6D6B7-CD38-4D49-9BA7-1FBB35F77223} EndProjectSection EndProject Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{60188E81-124C-4824-B346-F38B4146F742}" ProjectSection(SolutionItems) = preProject file_copy.bat = file_copy.bat gmp_prebuild.bat = gmp_prebuild.bat readme-vc8.txt = readme-vc8.txt EndProjectSection EndProject Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "DLLs", "DLLs", "{4192A2FD-D361-4C91-AE03-9C29DE78C952}" EndProject Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "LIBs", "LIBs", "{0B59A1DA-6449-47CB-8540-C0A8BD86645D}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "dll_gmp_amd64", "dll_gmp_amd64\dll_gmp_amd64.vcproj", "{AE325872-A6F2-4554-9CF1-076499597BA6}" ProjectSection(ProjectDependencies) = postProject {0412953E-06CE-4A60-9DCD-CA5CAC3A46CC} = {0412953E-06CE-4A60-9DCD-CA5CAC3A46CC} {001E0D42-4AF4-44B8-A8B2-3CD46D537DBE} = {001E0D42-4AF4-44B8-A8B2-3CD46D537DBE} {2297FA81-6D9D-4DC3-BA42-04E93F397047} = {2297FA81-6D9D-4DC3-BA42-04E93F397047} {D3C6D6B7-CD38-4D49-9BA7-1FBB35F77223} = {D3C6D6B7-CD38-4D49-9BA7-1FBB35F77223} EndProjectSection EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "lib_gmp_amd64", "lib_gmp_amd64\lib_gmp_amd64.vcproj", "{AD4D498B-ACAB-42A9-9414-335B44BB2F8D}" ProjectSection(ProjectDependencies) = postProject {001E0D42-4AF4-44B8-A8B2-3CD46D537DBE} = {001E0D42-4AF4-44B8-A8B2-3CD46D537DBE} {2297FA81-6D9D-4DC3-BA42-04E93F397047} = {2297FA81-6D9D-4DC3-BA42-04E93F397047} {D3C6D6B7-CD38-4D49-9BA7-1FBB35F77223} = {D3C6D6B7-CD38-4D49-9BA7-1FBB35F77223} {0412953E-06CE-4A60-9DCD-CA5CAC3A46CC} = {0412953E-06CE-4A60-9DCD-CA5CAC3A46CC} {FA999C2A-A4D2-4331-8D63-E3A8B05EC58F} = {FA999C2A-A4D2-4331-8D63-E3A8B05EC58F} EndProjectSection EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gen-bases", "gen-bases\gen-bases.vcproj", "{2297FA81-6D9D-4DC3-BA42-04E93F397047}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gen-fac_ui", "gen-fac_ui\gen-fac_ui.vcproj", "{001E0D42-4AF4-44B8-A8B2-3CD46D537DBE}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gen-fib", "gen-fib\gen-fib.vcproj", "{D3C6D6B7-CD38-4D49-9BA7-1FBB35F77223}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gen-psqr", "gen-psqr\gen-psqr.vcproj", "{0412953E-06CE-4A60-9DCD-CA5CAC3A46CC}" EndProject Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Tests", "Tests", "{D7D30070-3829-41C0-89EA-E25DE6B392E9}" EndProject Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "cxx", "cxx", "{1543B8E5-4E63-47A1-A4C5-3E864D51E4A3}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "assign", "tests\cxx\assign\assign.vcproj", "{9A0DCCB2-7C15-4C79-AF77-DB6BE7E428A4}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "binary", "tests\cxx\binary\binary.vcproj", "{43FDB176-8A70-4C03-8F67-3EDD796B8EDA}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "cast", "tests\cxx\cast\cast.vcproj", "{2A2FBA68-8B49-42C5-AC8C-4A33F7951FB4}" EndProject Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "mpz", "mpz", "{D212AB5B-F446-410E-B593-7565B3970F81}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "tdiv_ui", "tests\mpz\tdiv_ui\tdiv_ui.vcproj", "{46ED3730-4921-45D1-8FEF-4CE29745FB25}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "tdiv", "tests\mpz\tdiv\tdiv.vcproj", "{AB3F038D-936E-40E6-914C-D2F1A2352FCF}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "constr", "tests\cxx\constr\constr.vcproj", "{FB8E3538-C2D1-4A13-994A-D32593300F77}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "headers", "tests\cxx\headers\headers.vcproj", "{7DFBC4AB-9BE2-4F0A-B2F5-38FB0B2D2DB5}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "locale", "tests\cxx\locale\locale.vcproj", "{9FDDFF38-0A83-40D3-B492-02846102F8F8}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "istream", "tests\cxx\istream\istream.vcproj", "{9A0FA918-A2DF-4C5E-80EB-583173AC1341}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "misc", "tests\cxx\misc\misc.vcproj", "{D885564A-E7CA-4493-A9BB-B451049CFA73}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "ops", "tests\cxx\ops\ops.vcproj", "{A4B8BD41-C07F-4913-82A4-D24D6DD73377}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "ostream", "tests\cxx\ostream\ostream.vcproj", "{330F7738-C84C-4DEE-AA13-1324A7118F29}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "prec", "tests\cxx\prec\prec.vcproj", "{1B9F8C94-3D66-4734-BBDA-43B1A1360BA9}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "rand", "tests\cxx\rand\rand.vcproj", "{B313A86A-CFE8-4E56-A7FA-AD1B962EC96B}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "ternary", "tests\cxx\ternary\ternary.vcproj", "{0CE3F5B5-CC35-4DF3-8457-489C843A7843}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "unary", "tests\cxx\unary\unary.vcproj", "{20050A94-78F8-4783-B66A-88905E32CA7E}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "aorsmul", "tests\mpz\aorsmul\aorsmul.vcproj", "{F79CF60D-6FC3-4A24-935C-D09665B13400}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "bit", "tests\mpz\bit\bit.vcproj", "{E78109FE-AFFD-47B5-B077-7405F12EBF4B}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "dive", "tests\mpz\dive\dive.vcproj", "{40EAB710-54A7-4C3B-B264-12BF4AD0C752}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "dive_ui", "tests\mpz\dive_ui\dive_ui.vcproj", "{46D51B2B-C319-4858-ADF0-476074188070}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "convert", "tests\mpz\convert\convert.vcproj", "{BB201B0D-07F7-42AA-B16C-D8BD0F19CC98}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "io", "tests\mpz\io\io.vcproj", "{AA40EBEE-F2EC-4DFA-A1C9-D58734BCBEA8}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "logic", "tests\mpz\logic\logic.vcproj", "{26B8A115-120B-4D62-B593-3FD7FD4CA75E}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "reuse", "tests\mpz\reuse\reuse.vcproj", "{D0AB4F75-48A7-4673-AA53-9134DFBD2956}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "cdiv_ui", "tests\mpz\cdiv_ui\cdiv_ui.vcproj", "{2EB4F888-8048-4283-AAF9-B9419774F7A1}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "addsub", "tests\mpz\addsub\addsub.vcproj", "{F7350B52-3C26-4F8D-87F5-46461CF9AA21}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "cmp", "tests\mpz\cmp\cmp.vcproj", "{93A2A9CB-18E3-4EF0-8186-A5C1C49271F9}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "cmp_d", "tests\mpz\cmp_d\cmp_d.vcproj", "{AC29CE01-373A-4DAF-94A8-51477B18242B}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "bin", "tests\mpz\bin\bin.vcproj", "{898194CA-8687-478A-AF8C-AD6D02280B8E}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "cmp_si", "tests\mpz\cmp_si\cmp_si.vcproj", "{23CBED72-0007-4671-BDCC-817403C2FDAB}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "cong", "tests\mpz\cong\cong.vcproj", "{B134B8F2-AE55-4046-902A-D282147C992F}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "cong_2exp", "tests\mpz\cong_2exp\cong_2exp.vcproj", "{D5F1FFDA-34DF-4A89-9767-924D39D35CCC}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "div_2exp", "tests\mpz\div_2exp\div_2exp.vcproj", "{1862DC50-4B23-4941-A190-C4838C0A49AE}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "divis", "tests\mpz\divis\divis.vcproj", "{6CDD5B46-39A7-49FD-B8C6-476C4958CAAF}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "divis_2exp", "tests\mpz\divis_2exp\divis_2exp.vcproj", "{8B1D4E3F-1125-4BDA-B81E-20E022C03538}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "export", "tests\mpz\export\export.vcproj", "{05F1AFCD-A715-46A2-AEAB-89BC60FFCF2C}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "fac_ui", "tests\mpz\fac_ui\fac_ui.vcproj", "{88385AFF-169F-4B40-98A3-CA0B59BB9451}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "fdiv", "tests\mpz\fdiv\fdiv.vcproj", "{EC4EF28D-919C-4B13-89BC-29D063D408A0}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "fdiv_ui", "tests\mpz\fdiv_ui\fdiv_ui.vcproj", "{205C829A-29D9-46AC-BC71-BE513794ECBE}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "fib_ui", "tests\mpz\fib_ui\fib_ui.vcproj", "{A5B79959-9B49-4021-90F4-EE776D9863AC}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "fits", "tests\mpz\fits\fits.vcproj", "{8C67CBCA-C127-49FE-8CF4-DA38B66B5186}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gcd", "tests\mpz\gcd\gcd.vcproj", "{94A2A4AC-186D-4403-BB02-A81077F4717B}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gcd_ui", "tests\mpz\gcd_ui\gcd_ui.vcproj", "{F2B48C2D-B7A6-4AF7-A1B6-95023F7185E2}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "get_d", "tests\mpz\get_d\get_d.vcproj", "{5A0DC446-207D-4A16-BBE1-2F6FBBE5FA32}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "get_d_2exp", "tests\mpz\get_d_2exp\get_d_2exp.vcproj", "{808F86D0-5256-4673-8623-669BDF077406}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "get_si", "tests\mpz\get_si\get_si.vcproj", "{57ED741A-DA02-48BF-B6B0-43230EEFF83D}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "inp_str", "tests\mpz\inp_str\inp_str.vcproj", "{C320625B-D86E-46DD-B08B-AE4328BF3FDB}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "io_raw", "tests\mpz\io_raw\io_raw.vcproj", "{DC53ACFA-DEEE-441C-AEE6-E96F1D6DB68B}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "jac", "tests\mpz\jac\jac.vcproj", "{6DDED97E-BEBC-447B-A102-4B14CCD62C9F}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "lcm", "tests\mpz\lcm\lcm.vcproj", "{72DC8986-697E-4EA1-B2A1-86453C2E6BFD}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "lucnum_ui", "tests\mpz\lucnum_ui\lucnum_ui.vcproj", "{C5FB18BB-0572-407A-8FE7-F919A59D2ADC}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "mul", "tests\mpz\mul\mul.vcproj", "{2800452A-552F-4330-95EB-AB394CAF463B}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "mul_i", "tests\mpz\mul_i\mul_i.vcproj", "{4E5C40F6-9CC6-4242-A12E-6105D3C37988}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "oddeven", "tests\mpz\oddeven\oddeven.vcproj", "{3FD72315-A289-40B6-B42D-A4CB88A4E63B}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "perfsqr", "tests\mpz\perfsqr\perfsqr.vcproj", "{7FB29BE2-6C9C-42DE-A73D-2D860785C1FA}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "popcount", "tests\mpz\popcount\popcount.vcproj", "{877FBBB2-F0F4-411E-9438-4576D1B08F94}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "pow", "tests\mpz\pow\pow.vcproj", "{D7E69275-F85F-47E7-A1C0-5B1914BBE79F}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "powm", "tests\mpz\powm\powm.vcproj", "{480E426C-C2AF-4C46-9AE6-6A93FA005C18}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "powm_ui", "tests\mpz\powm_ui\powm_ui.vcproj", "{04D5A0F5-82D8-4095-AC67-A691F9CEB768}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "pprime_p", "tests\mpz\pprime_p\pprime_p.vcproj", "{D5CA1B70-2D03-4794-B15A-E030ED92CB64}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "root", "tests\mpz\root\root.vcproj", "{8B162257-3A6F-401C-905A-5A616B8945F2}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "scan", "tests\mpz\scan\scan.vcproj", "{71102476-03D2-401E-B6F6-301E984CB7DD}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "set_d", "tests\mpz\set_d\set_d.vcproj", "{7C625DDB-7776-4752-8B52-29E2983A4E95}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "set_f", "tests\mpz\set_f\set_f.vcproj", "{19C4F045-3877-4320-9200-B97EC40996E2}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "set_si", "tests\mpz\set_si\set_si.vcproj", "{008BCDED-1DD5-4B9D-B6B3-461B9BFE41A5}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "set_str", "tests\mpz\set_str\set_str.vcproj", "{7681DE2C-1FE2-4B7B-98CD-9D25C4107340}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "sizeinbase", "tests\mpz\sizeinbase\sizeinbase.vcproj", "{042E07FE-5174-4FB9-9469-516E20F53FE5}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "sqrtrem", "tests\mpz\sqrtrem\sqrtrem.vcproj", "{E6671DBC-D0C3-4493-89CA-B6EBF8B60AB9}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "hamdist", "tests\mpz\hamdist\hamdist.vcproj", "{3E1AE893-E6E6-4E09-807A-148360C538AF}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "import", "tests\mpz\import\import.vcproj", "{4BBD77B6-48C2-4551-A874-327A414C3A35}" EndProject Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "misc", "misc", "{E2D74770-F7DB-4807-A12F-2363F1F08CCE}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "locale", "tests\misc\locale\locale.vcproj", "{A0DCC844-F0FB-420C-9B41-E557845411AC}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "printf", "tests\misc\printf\printf.vcproj", "{5E8E3F00-79A9-4635-AE04-452B7D5497F6}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "scanf", "tests\misc\scanf\scanf.vcproj", "{6A036179-4726-40C2-89C9-2E18D4030E28}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "bswap", "tests\bswap\bswap.vcproj", "{50EFC9E8-FB88-44C3-9F30-075547E22992}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "constants", "tests\constants\constants.vcproj", "{5495242E-29D4-4C4E-9176-4A69F8CBD667}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "count_zeros", "tests\count_zeros\count_zeros.vcproj", "{8E9450F9-5523-4164-A1C9-F04103F2AA92}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gmpmax", "tests\gmpmax\gmpmax.vcproj", "{080D15EE-2C04-44A1-94DE-B70917E64E85}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "hightomask", "tests\hightomask\hightomask.vcproj", "{D9399AF5-90FC-4010-ABFC-408314AB04A9}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "modlinv", "tests\modlinv\modlinv.vcproj", "{2961C03E-0B57-483D-A4A6-622D07337E5B}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "parity", "tests\parity\parity.vcproj", "{7FB77E83-219A-42D6-98D0-66C13F38A221}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "popc", "tests\popc\popc.vcproj", "{8FC64DB6-5DCC-446C-8FEC-DA8D76756523}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "subc", "tests\subc\subc.vcproj", "{378F2D05-7A71-4AC3-A045-C8416D965C94}" EndProject Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "rand", "rand", "{AAB83BC2-6410-4114-AE0D-BFF15C9FF59B}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "iset", "tests\rand\iset\iset.vcproj", "{551E7C9B-9844-415F-8D65-DAEA5DFF3279}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "lc2exp", "tests\rand\lc2exp\lc2exp.vcproj", "{9D169447-3B5B-41DA-96C2-EB40DE0A96D7}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "mt", "tests\rand\mt\mt.vcproj", "{7CC8AB03-9D9F-4001-B99A-AA8D24487043}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "rand", "tests\rand\rand\rand.vcproj", "{D0CB0D23-2B7B-4D17-BC1C-6A698010503B}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "urbui", "tests\rand\urbui\urbui.vcproj", "{55883549-B725-41B7-900D-28EDC4757B76}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "urmui", "tests\rand\urmui\urmui.vcproj", "{AE7429E9-F7AD-4B49-9E6E-8615003DD8AF}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "urndmm", "tests\rand\urndmm\urndmm.vcproj", "{8D10D126-A641-40DC-B8FC-1407F3FAFA55}" EndProject Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "mpf", "mpf", "{C2B287D4-B0F5-473A-88ED-E79F0C2956B8}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "reuse", "tests\mpf\reuse\reuse.vcproj", "{210299CF-6040-4F8E-88D1-BAEC0E9C9FEE}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "add", "tests\mpf\add\add.vcproj", "{7B2432C6-051D-4667-94E4-0521B4B3821D}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "cmp_d", "tests\mpf\cmp_d\cmp_d.vcproj", "{50B96CD6-FE47-4DEE-B15B-B86E7F46872E}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "cmp_si", "tests\mpf\cmp_si\cmp_si.vcproj", "{12F90F29-06C8-4EE1-AC2C-C8B9F902C32E}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "conv", "tests\mpf\conv\conv.vcproj", "{AEF3C73D-9952-45D6-949E-7CFE0D3BE892}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "div", "tests\mpf\div\div.vcproj", "{825A5F4A-CF89-4A29-B778-E035B442225A}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "dm2exp", "tests\mpf\dm2exp\dm2exp.vcproj", "{489480B1-F26B-412F-8A36-70D07159E5BC}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "fits", "tests\mpf\fits\fits.vcproj", "{BEFC2B0F-67E8-4637-A4D8-B977654F25D8}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "get_d", "tests\mpf\get_d\get_d.vcproj", "{FC3B266B-F1B4-4495-B348-5FDABCA36D99}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "get_d_2exp", "tests\mpf\get_d_2exp\get_d_2exp.vcproj", "{B74F08C9-D7DF-46E9-9583-A82ACE4809AB}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "get_si", "tests\mpf\get_si\get_si.vcproj", "{41011670-B1AC-4B77-ABB3-AE6568674A37}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "get_ui", "tests\mpf\get_ui\get_ui.vcproj", "{9643E4ED-1F10-4A16-890D-E20240ADC190}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gsprec", "tests\mpf\gsprec\gsprec.vcproj", "{3831E9F2-FDAA-4C48-B394-9F3A1CEC5759}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "inp_str", "tests\mpf\inp_str\inp_str.vcproj", "{7C40A774-EEF0-4681-A453-A38F67B460D2}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "int_p", "tests\mpf\int_p\int_p.vcproj", "{A8A8CD5C-54F4-4F22-B01E-A6985A0CC263}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "mul_ui", "tests\mpf\mul_ui\mul_ui.vcproj", "{6635CF18-5122-4950-A395-5AC8AFAC5B6C}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "muldiv", "tests\mpf\muldiv\muldiv.vcproj", "{D3711C7C-8B57-49D4-89AB-B7EFE4CFD734}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "set", "tests\mpf\set\set.vcproj", "{7A4352A7-59A4-43D5-9DB1-5B8FFEDBA487}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "set_q", "tests\mpf\set_q\set_q.vcproj", "{96006E4E-6BA3-45D3-BD0C-1C6948A7B190}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "set_si", "tests\mpf\set_si\set_si.vcproj", "{CBB339EA-F9A1-4E40-9E17-CFC2410D0C38}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "set_ui", "tests\mpf\set_ui\set_ui.vcproj", "{D96A11B7-CBA8-492B-BAB0-2176930A7B2D}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "sqrt", "tests\mpf\sqrt\sqrt.vcproj", "{BCEEA3E0-567A-4946-A47F-8E300920BA24}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "sqrt_ui", "tests\mpf\sqrt_ui\sqrt_ui.vcproj", "{6C478B62-1737-4F87-B54C-89363C4FA5D8}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "sub", "tests\mpf\sub\sub.vcproj", "{3869AF45-1841-47C8-B6FA-10FF36EB43D4}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "trunc", "tests\mpf\trunc\trunc.vcproj", "{55E03CF1-A4CE-415A-AF58-9708A9037B73}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "ui_div", "tests\mpf\ui_div\ui_div.vcproj", "{FED2FE89-EBD6-4A98-A854-8336288241C5}" EndProject Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "mpn", "mpn", "{7E02621E-E197-4EA1-951E-CE83908C89A6}" EndProject Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "mpq", "mpq", "{FBC8CB90-B99F-458E-9633-84AAF5E66864}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "aors_1", "tests\mpn\aors_1\aors_1.vcproj", "{9CCB91C8-CE8A-43E7-B818-C50B69CBEA52}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "asmtype", "tests\mpn\asmtype\asmtype.vcproj", "{83284438-103B-4D2C-A1F3-9A10F2856893}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "divrem_1", "tests\mpn\divrem_1\divrem_1.vcproj", "{9B1DFC22-D63F-41C0-8A1E-DE1D7E9A0E9A}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "fat", "tests\mpn\fat\fat.vcproj", "{F9D71C21-F737-423C-9005-CB3A22D31F28}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "get_d", "tests\mpn\get_d\get_d.vcproj", "{463F78C3-F5E5-4D64-9F7E-B3B6C6635238}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "instrument", "tests\mpn\instrument\instrument.vcproj", "{C56DAF55-9456-4E18-9E81-6A637F402B21}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "iord_u", "tests\mpn\iord_u\iord_u.vcproj", "{DA880260-0151-4AA4-83B8-F2EE9A398621}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "mp_bases", "tests\mpn\mp_bases\mp_bases.vcproj", "{06BD0427-4DB1-4EDC-8E57-DDFF92918E17}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "perfsqr", "tests\mpn\perfsqr\perfsqr.vcproj", "{2285C976-4710-4A60-85BC-49086DF1A2FF}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "scan", "tests\mpn\scan\scan.vcproj", "{1E489EFC-9E68-4C46-9EF7-29BA7B7E5C76}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "aors", "tests\mpq\aors\aors.vcproj", "{6A53F65C-D46D-41F8-8E0F-AF7372067EA8}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "cmp", "tests\mpq\cmp\cmp.vcproj", "{71A7F1E1-72A8-40FD-B2F5-1CE1D0121370}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "cmp_si", "tests\mpq\cmp_si\cmp_si.vcproj", "{4AAE926D-951C-48A0-A868-F0D205BED488}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "cmp_ui", "tests\mpq\cmp_ui\cmp_ui.vcproj", "{8AE05377-17AE-4898-9A0F-85797908901D}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "equal", "tests\mpq\equal\equal.vcproj", "{1F954DB3-3957-43D3-B27D-A2A49552D3E9}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "get_d", "tests\mpq\get_d\get_d.vcproj", "{BF459A20-A1BA-41B9-A4A9-54938F08434E}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "get_str", "tests\mpq\get_str\get_str.vcproj", "{89BB9690-8656-4A53-AACF-721D4B50A0DC}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "inp_str", "tests\mpq\inp_str\inp_str.vcproj", "{36577F9B-0E3C-4962-86DB-E65711488D06}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "md_2exp", "tests\mpq\md_2exp\md_2exp.vcproj", "{7559AA0F-D574-4810-AB5B-6A4F6E6D600E}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "set_f", "tests\mpq\set_f\set_f.vcproj", "{FD75348C-4A4F-4167-A730-67EE3B986619}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "set_str", "tests\mpq\set_str\set_str.vcproj", "{21C2CA09-DF0A-48A1-B12C-C8630A355CA1}" ProjectSection(ProjectDependencies) = postProject {FA999C2A-A4D2-4331-8D63-E3A8B05EC58F} = {FA999C2A-A4D2-4331-8D63-E3A8B05EC58F} EndProjectSection EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Win32 = Debug|Win32 Debug|x64 = Debug|x64 Release|Win32 = Release|Win32 Release|x64 = Release|x64 EndGlobalSection GlobalSection(ProjectConfigurationPlatforms) = postSolution {7DA5BAD1-B5CF-4F53-8560-E96C07DE023D}.Debug|Win32.ActiveCfg = Debug|Win32 {7DA5BAD1-B5CF-4F53-8560-E96C07DE023D}.Debug|Win32.Build.0 = Debug|Win32 {7DA5BAD1-B5CF-4F53-8560-E96C07DE023D}.Debug|x64.ActiveCfg = Debug|x64 {7DA5BAD1-B5CF-4F53-8560-E96C07DE023D}.Debug|x64.Build.0 = Debug|x64 {7DA5BAD1-B5CF-4F53-8560-E96C07DE023D}.Release|Win32.ActiveCfg = Release|Win32 {7DA5BAD1-B5CF-4F53-8560-E96C07DE023D}.Release|Win32.Build.0 = Release|Win32 {7DA5BAD1-B5CF-4F53-8560-E96C07DE023D}.Release|x64.ActiveCfg = Release|x64 {7DA5BAD1-B5CF-4F53-8560-E96C07DE023D}.Release|x64.Build.0 = Release|x64 {FA999C2A-A4D2-4331-8D63-E3A8B05EC58F}.Debug|Win32.ActiveCfg = Debug|Win32 {FA999C2A-A4D2-4331-8D63-E3A8B05EC58F}.Debug|Win32.Build.0 = Debug|Win32 {FA999C2A-A4D2-4331-8D63-E3A8B05EC58F}.Debug|x64.ActiveCfg = Debug|x64 {FA999C2A-A4D2-4331-8D63-E3A8B05EC58F}.Debug|x64.Build.0 = Debug|x64 {FA999C2A-A4D2-4331-8D63-E3A8B05EC58F}.Release|Win32.ActiveCfg = Release|Win32 {FA999C2A-A4D2-4331-8D63-E3A8B05EC58F}.Release|Win32.Build.0 = Release|Win32 {FA999C2A-A4D2-4331-8D63-E3A8B05EC58F}.Release|x64.ActiveCfg = Release|x64 {FA999C2A-A4D2-4331-8D63-E3A8B05EC58F}.Release|x64.Build.0 = Release|x64 {C82A62DB-DDB4-4072-832F-6DD841C6D80E}.Debug|Win32.ActiveCfg = Debug|Win32 {C82A62DB-DDB4-4072-832F-6DD841C6D80E}.Debug|Win32.Build.0 = Debug|Win32 {C82A62DB-DDB4-4072-832F-6DD841C6D80E}.Debug|x64.ActiveCfg = Debug|x64 {C82A62DB-DDB4-4072-832F-6DD841C6D80E}.Debug|x64.Build.0 = Debug|x64 {C82A62DB-DDB4-4072-832F-6DD841C6D80E}.Release|Win32.ActiveCfg = Release|Win32 {C82A62DB-DDB4-4072-832F-6DD841C6D80E}.Release|Win32.Build.0 = Release|Win32 {C82A62DB-DDB4-4072-832F-6DD841C6D80E}.Release|x64.ActiveCfg = Release|x64 {C82A62DB-DDB4-4072-832F-6DD841C6D80E}.Release|x64.Build.0 = Release|x64 {96DA1C71-3895-49FA-A4F1-2775C650AF3D}.Debug|Win32.ActiveCfg = Debug|Win32 {96DA1C71-3895-49FA-A4F1-2775C650AF3D}.Debug|Win32.Build.0 = Debug|Win32 {96DA1C71-3895-49FA-A4F1-2775C650AF3D}.Debug|x64.ActiveCfg = Debug|x64 {96DA1C71-3895-49FA-A4F1-2775C650AF3D}.Debug|x64.Build.0 = Debug|x64 {96DA1C71-3895-49FA-A4F1-2775C650AF3D}.Release|Win32.ActiveCfg = Release|Win32 {96DA1C71-3895-49FA-A4F1-2775C650AF3D}.Release|Win32.Build.0 = Release|Win32 {96DA1C71-3895-49FA-A4F1-2775C650AF3D}.Release|x64.ActiveCfg = Release|x64 {96DA1C71-3895-49FA-A4F1-2775C650AF3D}.Release|x64.Build.0 = Release|x64 {8A1EB575-B721-4891-B5BD-17CC45D0103C}.Debug|Win32.ActiveCfg = Debug|Win32 {8A1EB575-B721-4891-B5BD-17CC45D0103C}.Debug|Win32.Build.0 = Debug|Win32 {8A1EB575-B721-4891-B5BD-17CC45D0103C}.Debug|x64.ActiveCfg = Debug|x64 {8A1EB575-B721-4891-B5BD-17CC45D0103C}.Debug|x64.Build.0 = Debug|x64 {8A1EB575-B721-4891-B5BD-17CC45D0103C}.Release|Win32.ActiveCfg = Release|Win32 {8A1EB575-B721-4891-B5BD-17CC45D0103C}.Release|Win32.Build.0 = Release|Win32 {8A1EB575-B721-4891-B5BD-17CC45D0103C}.Release|x64.ActiveCfg = Release|x64 {8A1EB575-B721-4891-B5BD-17CC45D0103C}.Release|x64.Build.0 = Release|x64 {4AF4FD03-C169-456A-966A-081DE6BB71C7}.Debug|Win32.ActiveCfg = Debug|Win32 {4AF4FD03-C169-456A-966A-081DE6BB71C7}.Debug|Win32.Build.0 = Debug|Win32 {4AF4FD03-C169-456A-966A-081DE6BB71C7}.Debug|x64.ActiveCfg = Debug|x64 {4AF4FD03-C169-456A-966A-081DE6BB71C7}.Debug|x64.Build.0 = Debug|x64 {4AF4FD03-C169-456A-966A-081DE6BB71C7}.Release|Win32.ActiveCfg = Release|Win32 {4AF4FD03-C169-456A-966A-081DE6BB71C7}.Release|Win32.Build.0 = Release|Win32 {4AF4FD03-C169-456A-966A-081DE6BB71C7}.Release|x64.ActiveCfg = Release|x64 {4AF4FD03-C169-456A-966A-081DE6BB71C7}.Release|x64.Build.0 = Release|x64 {AF57F91F-EB17-4989-B98F-FD59409FA4EC}.Debug|Win32.ActiveCfg = Debug|Win32 {AF57F91F-EB17-4989-B98F-FD59409FA4EC}.Debug|Win32.Build.0 = Debug|Win32 {AF57F91F-EB17-4989-B98F-FD59409FA4EC}.Debug|x64.ActiveCfg = Debug|Win32 {AF57F91F-EB17-4989-B98F-FD59409FA4EC}.Release|Win32.ActiveCfg = Release|Win32 {AF57F91F-EB17-4989-B98F-FD59409FA4EC}.Release|Win32.Build.0 = Release|Win32 {AF57F91F-EB17-4989-B98F-FD59409FA4EC}.Release|x64.ActiveCfg = Release|Win32 {8A2E028B-6E13-4E8A-B0F5-9A58C30BFB11}.Debug|Win32.ActiveCfg = Debug|Win32 {8A2E028B-6E13-4E8A-B0F5-9A58C30BFB11}.Debug|Win32.Build.0 = Debug|Win32 {8A2E028B-6E13-4E8A-B0F5-9A58C30BFB11}.Debug|x64.ActiveCfg = Debug|Win32 {8A2E028B-6E13-4E8A-B0F5-9A58C30BFB11}.Release|Win32.ActiveCfg = Release|Win32 {8A2E028B-6E13-4E8A-B0F5-9A58C30BFB11}.Release|Win32.Build.0 = Release|Win32 {8A2E028B-6E13-4E8A-B0F5-9A58C30BFB11}.Release|x64.ActiveCfg = Release|Win32 {51A9B98F-FBB4-43B7-9029-2DCC3D9BD0E6}.Debug|Win32.ActiveCfg = Debug|Win32 {51A9B98F-FBB4-43B7-9029-2DCC3D9BD0E6}.Debug|Win32.Build.0 = Debug|Win32 {51A9B98F-FBB4-43B7-9029-2DCC3D9BD0E6}.Debug|x64.ActiveCfg = Debug|Win32 {51A9B98F-FBB4-43B7-9029-2DCC3D9BD0E6}.Release|Win32.ActiveCfg = Release|Win32 {51A9B98F-FBB4-43B7-9029-2DCC3D9BD0E6}.Release|Win32.Build.0 = Release|Win32 {51A9B98F-FBB4-43B7-9029-2DCC3D9BD0E6}.Release|x64.ActiveCfg = Release|Win32 {E1695434-494C-4FCD-804D-F2409528DC1F}.Debug|Win32.ActiveCfg = Debug|Win32 {E1695434-494C-4FCD-804D-F2409528DC1F}.Debug|Win32.Build.0 = Debug|Win32 {E1695434-494C-4FCD-804D-F2409528DC1F}.Debug|x64.ActiveCfg = Debug|Win32 {E1695434-494C-4FCD-804D-F2409528DC1F}.Release|Win32.ActiveCfg = Release|Win32 {E1695434-494C-4FCD-804D-F2409528DC1F}.Release|Win32.Build.0 = Release|Win32 {E1695434-494C-4FCD-804D-F2409528DC1F}.Release|x64.ActiveCfg = Release|Win32 {B5917427-4096-4AE9-833C-D9129C08C2B7}.Debug|Win32.ActiveCfg = Debug|Win32 {B5917427-4096-4AE9-833C-D9129C08C2B7}.Debug|Win32.Build.0 = Debug|Win32 {B5917427-4096-4AE9-833C-D9129C08C2B7}.Debug|x64.ActiveCfg = Debug|Win32 {B5917427-4096-4AE9-833C-D9129C08C2B7}.Release|Win32.ActiveCfg = Release|Win32 {B5917427-4096-4AE9-833C-D9129C08C2B7}.Release|Win32.Build.0 = Release|Win32 {B5917427-4096-4AE9-833C-D9129C08C2B7}.Release|x64.ActiveCfg = Release|Win32 {9A3A242F-1472-4776-9839-CC62474B7F54}.Debug|Win32.ActiveCfg = Debug|Win32 {9A3A242F-1472-4776-9839-CC62474B7F54}.Debug|Win32.Build.0 = Debug|Win32 {9A3A242F-1472-4776-9839-CC62474B7F54}.Debug|x64.ActiveCfg = Debug|Win32 {9A3A242F-1472-4776-9839-CC62474B7F54}.Release|Win32.ActiveCfg = Release|Win32 {9A3A242F-1472-4776-9839-CC62474B7F54}.Release|Win32.Build.0 = Release|Win32 {9A3A242F-1472-4776-9839-CC62474B7F54}.Release|x64.ActiveCfg = Release|Win32 {AE325872-A6F2-4554-9CF1-076499597BA6}.Debug|Win32.ActiveCfg = Debug|x64 {AE325872-A6F2-4554-9CF1-076499597BA6}.Debug|x64.ActiveCfg = Debug|x64 {AE325872-A6F2-4554-9CF1-076499597BA6}.Debug|x64.Build.0 = Debug|x64 {AE325872-A6F2-4554-9CF1-076499597BA6}.Release|Win32.ActiveCfg = Release|x64 {AE325872-A6F2-4554-9CF1-076499597BA6}.Release|x64.ActiveCfg = Release|x64 {AE325872-A6F2-4554-9CF1-076499597BA6}.Release|x64.Build.0 = Release|x64 {AD4D498B-ACAB-42A9-9414-335B44BB2F8D}.Debug|Win32.ActiveCfg = Debug|x64 {AD4D498B-ACAB-42A9-9414-335B44BB2F8D}.Debug|x64.ActiveCfg = Debug|x64 {AD4D498B-ACAB-42A9-9414-335B44BB2F8D}.Debug|x64.Build.0 = Debug|x64 {AD4D498B-ACAB-42A9-9414-335B44BB2F8D}.Release|Win32.ActiveCfg = Release|x64 {AD4D498B-ACAB-42A9-9414-335B44BB2F8D}.Release|x64.ActiveCfg = Release|x64 {AD4D498B-ACAB-42A9-9414-335B44BB2F8D}.Release|x64.Build.0 = Release|x64 {2297FA81-6D9D-4DC3-BA42-04E93F397047}.Debug|Win32.ActiveCfg = Release|Win32 {2297FA81-6D9D-4DC3-BA42-04E93F397047}.Debug|Win32.Build.0 = Release|Win32 {2297FA81-6D9D-4DC3-BA42-04E93F397047}.Debug|x64.ActiveCfg = Release|Win32 {2297FA81-6D9D-4DC3-BA42-04E93F397047}.Debug|x64.Build.0 = Release|Win32 {2297FA81-6D9D-4DC3-BA42-04E93F397047}.Release|Win32.ActiveCfg = Release|Win32 {2297FA81-6D9D-4DC3-BA42-04E93F397047}.Release|Win32.Build.0 = Release|Win32 {2297FA81-6D9D-4DC3-BA42-04E93F397047}.Release|x64.ActiveCfg = Release|Win32 {2297FA81-6D9D-4DC3-BA42-04E93F397047}.Release|x64.Build.0 = Release|Win32 {001E0D42-4AF4-44B8-A8B2-3CD46D537DBE}.Debug|Win32.ActiveCfg = Release|Win32 {001E0D42-4AF4-44B8-A8B2-3CD46D537DBE}.Debug|Win32.Build.0 = Release|Win32 {001E0D42-4AF4-44B8-A8B2-3CD46D537DBE}.Debug|x64.ActiveCfg = Release|Win32 {001E0D42-4AF4-44B8-A8B2-3CD46D537DBE}.Debug|x64.Build.0 = Release|Win32 {001E0D42-4AF4-44B8-A8B2-3CD46D537DBE}.Release|Win32.ActiveCfg = Release|Win32 {001E0D42-4AF4-44B8-A8B2-3CD46D537DBE}.Release|Win32.Build.0 = Release|Win32 {001E0D42-4AF4-44B8-A8B2-3CD46D537DBE}.Release|x64.ActiveCfg = Release|Win32 {001E0D42-4AF4-44B8-A8B2-3CD46D537DBE}.Release|x64.Build.0 = Release|Win32 {D3C6D6B7-CD38-4D49-9BA7-1FBB35F77223}.Debug|Win32.ActiveCfg = Release|Win32 {D3C6D6B7-CD38-4D49-9BA7-1FBB35F77223}.Debug|Win32.Build.0 = Release|Win32 {D3C6D6B7-CD38-4D49-9BA7-1FBB35F77223}.Debug|x64.ActiveCfg = Release|Win32 {D3C6D6B7-CD38-4D49-9BA7-1FBB35F77223}.Debug|x64.Build.0 = Release|Win32 {D3C6D6B7-CD38-4D49-9BA7-1FBB35F77223}.Release|Win32.ActiveCfg = Release|Win32 {D3C6D6B7-CD38-4D49-9BA7-1FBB35F77223}.Release|Win32.Build.0 = Release|Win32 {D3C6D6B7-CD38-4D49-9BA7-1FBB35F77223}.Release|x64.ActiveCfg = Release|Win32 {D3C6D6B7-CD38-4D49-9BA7-1FBB35F77223}.Release|x64.Build.0 = Release|Win32 {0412953E-06CE-4A60-9DCD-CA5CAC3A46CC}.Debug|Win32.ActiveCfg = Release|Win32 {0412953E-06CE-4A60-9DCD-CA5CAC3A46CC}.Debug|Win32.Build.0 = Release|Win32 {0412953E-06CE-4A60-9DCD-CA5CAC3A46CC}.Debug|x64.ActiveCfg = Release|Win32 {0412953E-06CE-4A60-9DCD-CA5CAC3A46CC}.Debug|x64.Build.0 = Release|Win32 {0412953E-06CE-4A60-9DCD-CA5CAC3A46CC}.Release|Win32.ActiveCfg = Release|Win32 {0412953E-06CE-4A60-9DCD-CA5CAC3A46CC}.Release|Win32.Build.0 = Release|Win32 {0412953E-06CE-4A60-9DCD-CA5CAC3A46CC}.Release|x64.ActiveCfg = Release|Win32 {0412953E-06CE-4A60-9DCD-CA5CAC3A46CC}.Release|x64.Build.0 = Release|Win32 {9A0DCCB2-7C15-4C79-AF77-DB6BE7E428A4}.Debug|Win32.ActiveCfg = Debug|Win32 {9A0DCCB2-7C15-4C79-AF77-DB6BE7E428A4}.Debug|Win32.Build.0 = Debug|Win32 {9A0DCCB2-7C15-4C79-AF77-DB6BE7E428A4}.Debug|x64.ActiveCfg = Debug|x64 {9A0DCCB2-7C15-4C79-AF77-DB6BE7E428A4}.Debug|x64.Build.0 = Debug|x64 {9A0DCCB2-7C15-4C79-AF77-DB6BE7E428A4}.Release|Win32.ActiveCfg = Release|Win32 {9A0DCCB2-7C15-4C79-AF77-DB6BE7E428A4}.Release|Win32.Build.0 = Release|Win32 {9A0DCCB2-7C15-4C79-AF77-DB6BE7E428A4}.Release|x64.ActiveCfg = Release|x64 {9A0DCCB2-7C15-4C79-AF77-DB6BE7E428A4}.Release|x64.Build.0 = Release|x64 {43FDB176-8A70-4C03-8F67-3EDD796B8EDA}.Debug|Win32.ActiveCfg = Debug|Win32 {43FDB176-8A70-4C03-8F67-3EDD796B8EDA}.Debug|Win32.Build.0 = Debug|Win32 {43FDB176-8A70-4C03-8F67-3EDD796B8EDA}.Debug|x64.ActiveCfg = Debug|x64 {43FDB176-8A70-4C03-8F67-3EDD796B8EDA}.Debug|x64.Build.0 = Debug|x64 {43FDB176-8A70-4C03-8F67-3EDD796B8EDA}.Release|Win32.ActiveCfg = Release|Win32 {43FDB176-8A70-4C03-8F67-3EDD796B8EDA}.Release|Win32.Build.0 = Release|Win32 {43FDB176-8A70-4C03-8F67-3EDD796B8EDA}.Release|x64.ActiveCfg = Release|x64 {43FDB176-8A70-4C03-8F67-3EDD796B8EDA}.Release|x64.Build.0 = Release|x64 {2A2FBA68-8B49-42C5-AC8C-4A33F7951FB4}.Debug|Win32.ActiveCfg = Debug|Win32 {2A2FBA68-8B49-42C5-AC8C-4A33F7951FB4}.Debug|Win32.Build.0 = Debug|Win32 {2A2FBA68-8B49-42C5-AC8C-4A33F7951FB4}.Debug|x64.ActiveCfg = Debug|x64 {2A2FBA68-8B49-42C5-AC8C-4A33F7951FB4}.Debug|x64.Build.0 = Debug|x64 {2A2FBA68-8B49-42C5-AC8C-4A33F7951FB4}.Release|Win32.ActiveCfg = Release|Win32 {2A2FBA68-8B49-42C5-AC8C-4A33F7951FB4}.Release|Win32.Build.0 = Release|Win32 {2A2FBA68-8B49-42C5-AC8C-4A33F7951FB4}.Release|x64.ActiveCfg = Release|x64 {2A2FBA68-8B49-42C5-AC8C-4A33F7951FB4}.Release|x64.Build.0 = Release|x64 {46ED3730-4921-45D1-8FEF-4CE29745FB25}.Debug|Win32.ActiveCfg = Debug|Win32 {46ED3730-4921-45D1-8FEF-4CE29745FB25}.Debug|Win32.Build.0 = Debug|Win32 {46ED3730-4921-45D1-8FEF-4CE29745FB25}.Debug|x64.ActiveCfg = Debug|x64 {46ED3730-4921-45D1-8FEF-4CE29745FB25}.Debug|x64.Build.0 = Debug|x64 {46ED3730-4921-45D1-8FEF-4CE29745FB25}.Release|Win32.ActiveCfg = Release|Win32 {46ED3730-4921-45D1-8FEF-4CE29745FB25}.Release|Win32.Build.0 = Release|Win32 {46ED3730-4921-45D1-8FEF-4CE29745FB25}.Release|x64.ActiveCfg = Release|x64 {46ED3730-4921-45D1-8FEF-4CE29745FB25}.Release|x64.Build.0 = Release|x64 {AB3F038D-936E-40E6-914C-D2F1A2352FCF}.Debug|Win32.ActiveCfg = Debug|Win32 {AB3F038D-936E-40E6-914C-D2F1A2352FCF}.Debug|Win32.Build.0 = Debug|Win32 {AB3F038D-936E-40E6-914C-D2F1A2352FCF}.Debug|x64.ActiveCfg = Debug|x64 {AB3F038D-936E-40E6-914C-D2F1A2352FCF}.Debug|x64.Build.0 = Debug|x64 {AB3F038D-936E-40E6-914C-D2F1A2352FCF}.Release|Win32.ActiveCfg = Release|Win32 {AB3F038D-936E-40E6-914C-D2F1A2352FCF}.Release|Win32.Build.0 = Release|Win32 {AB3F038D-936E-40E6-914C-D2F1A2352FCF}.Release|x64.ActiveCfg = Release|x64 {AB3F038D-936E-40E6-914C-D2F1A2352FCF}.Release|x64.Build.0 = Release|x64 {FB8E3538-C2D1-4A13-994A-D32593300F77}.Debug|Win32.ActiveCfg = Debug|Win32 {FB8E3538-C2D1-4A13-994A-D32593300F77}.Debug|Win32.Build.0 = Debug|Win32 {FB8E3538-C2D1-4A13-994A-D32593300F77}.Debug|x64.ActiveCfg = Debug|x64 {FB8E3538-C2D1-4A13-994A-D32593300F77}.Debug|x64.Build.0 = Debug|x64 {FB8E3538-C2D1-4A13-994A-D32593300F77}.Release|Win32.ActiveCfg = Release|Win32 {FB8E3538-C2D1-4A13-994A-D32593300F77}.Release|Win32.Build.0 = Release|Win32 {FB8E3538-C2D1-4A13-994A-D32593300F77}.Release|x64.ActiveCfg = Release|x64 {FB8E3538-C2D1-4A13-994A-D32593300F77}.Release|x64.Build.0 = Release|x64 {7DFBC4AB-9BE2-4F0A-B2F5-38FB0B2D2DB5}.Debug|Win32.ActiveCfg = Debug|Win32 {7DFBC4AB-9BE2-4F0A-B2F5-38FB0B2D2DB5}.Debug|Win32.Build.0 = Debug|Win32 {7DFBC4AB-9BE2-4F0A-B2F5-38FB0B2D2DB5}.Debug|x64.ActiveCfg = Debug|x64 {7DFBC4AB-9BE2-4F0A-B2F5-38FB0B2D2DB5}.Debug|x64.Build.0 = Debug|x64 {7DFBC4AB-9BE2-4F0A-B2F5-38FB0B2D2DB5}.Release|Win32.ActiveCfg = Release|Win32 {7DFBC4AB-9BE2-4F0A-B2F5-38FB0B2D2DB5}.Release|Win32.Build.0 = Release|Win32 {7DFBC4AB-9BE2-4F0A-B2F5-38FB0B2D2DB5}.Release|x64.ActiveCfg = Release|x64 {7DFBC4AB-9BE2-4F0A-B2F5-38FB0B2D2DB5}.Release|x64.Build.0 = Release|x64 {9FDDFF38-0A83-40D3-B492-02846102F8F8}.Debug|Win32.ActiveCfg = Debug|Win32 {9FDDFF38-0A83-40D3-B492-02846102F8F8}.Debug|Win32.Build.0 = Debug|Win32 {9FDDFF38-0A83-40D3-B492-02846102F8F8}.Debug|x64.ActiveCfg = Debug|x64 {9FDDFF38-0A83-40D3-B492-02846102F8F8}.Debug|x64.Build.0 = Debug|x64 {9FDDFF38-0A83-40D3-B492-02846102F8F8}.Release|Win32.ActiveCfg = Release|Win32 {9FDDFF38-0A83-40D3-B492-02846102F8F8}.Release|Win32.Build.0 = Release|Win32 {9FDDFF38-0A83-40D3-B492-02846102F8F8}.Release|x64.ActiveCfg = Release|x64 {9FDDFF38-0A83-40D3-B492-02846102F8F8}.Release|x64.Build.0 = Release|x64 {9A0FA918-A2DF-4C5E-80EB-583173AC1341}.Debug|Win32.ActiveCfg = Debug|Win32 {9A0FA918-A2DF-4C5E-80EB-583173AC1341}.Debug|Win32.Build.0 = Debug|Win32 {9A0FA918-A2DF-4C5E-80EB-583173AC1341}.Debug|x64.ActiveCfg = Debug|x64 {9A0FA918-A2DF-4C5E-80EB-583173AC1341}.Debug|x64.Build.0 = Debug|x64 {9A0FA918-A2DF-4C5E-80EB-583173AC1341}.Release|Win32.ActiveCfg = Release|Win32 {9A0FA918-A2DF-4C5E-80EB-583173AC1341}.Release|Win32.Build.0 = Release|Win32 {9A0FA918-A2DF-4C5E-80EB-583173AC1341}.Release|x64.ActiveCfg = Release|x64 {9A0FA918-A2DF-4C5E-80EB-583173AC1341}.Release|x64.Build.0 = Release|x64 {D885564A-E7CA-4493-A9BB-B451049CFA73}.Debug|Win32.ActiveCfg = Debug|Win32 {D885564A-E7CA-4493-A9BB-B451049CFA73}.Debug|Win32.Build.0 = Debug|Win32 {D885564A-E7CA-4493-A9BB-B451049CFA73}.Debug|x64.ActiveCfg = Debug|x64 {D885564A-E7CA-4493-A9BB-B451049CFA73}.Debug|x64.Build.0 = Debug|x64 {D885564A-E7CA-4493-A9BB-B451049CFA73}.Release|Win32.ActiveCfg = Release|Win32 {D885564A-E7CA-4493-A9BB-B451049CFA73}.Release|Win32.Build.0 = Release|Win32 {D885564A-E7CA-4493-A9BB-B451049CFA73}.Release|x64.ActiveCfg = Release|x64 {D885564A-E7CA-4493-A9BB-B451049CFA73}.Release|x64.Build.0 = Release|x64 {A4B8BD41-C07F-4913-82A4-D24D6DD73377}.Debug|Win32.ActiveCfg = Debug|Win32 {A4B8BD41-C07F-4913-82A4-D24D6DD73377}.Debug|Win32.Build.0 = Debug|Win32 {A4B8BD41-C07F-4913-82A4-D24D6DD73377}.Debug|x64.ActiveCfg = Debug|x64 {A4B8BD41-C07F-4913-82A4-D24D6DD73377}.Debug|x64.Build.0 = Debug|x64 {A4B8BD41-C07F-4913-82A4-D24D6DD73377}.Release|Win32.ActiveCfg = Release|Win32 {A4B8BD41-C07F-4913-82A4-D24D6DD73377}.Release|Win32.Build.0 = Release|Win32 {A4B8BD41-C07F-4913-82A4-D24D6DD73377}.Release|x64.ActiveCfg = Release|x64 {A4B8BD41-C07F-4913-82A4-D24D6DD73377}.Release|x64.Build.0 = Release|x64 {330F7738-C84C-4DEE-AA13-1324A7118F29}.Debug|Win32.ActiveCfg = Debug|Win32 {330F7738-C84C-4DEE-AA13-1324A7118F29}.Debug|Win32.Build.0 = Debug|Win32 {330F7738-C84C-4DEE-AA13-1324A7118F29}.Debug|x64.ActiveCfg = Debug|x64 {330F7738-C84C-4DEE-AA13-1324A7118F29}.Debug|x64.Build.0 = Debug|x64 {330F7738-C84C-4DEE-AA13-1324A7118F29}.Release|Win32.ActiveCfg = Release|Win32 {330F7738-C84C-4DEE-AA13-1324A7118F29}.Release|Win32.Build.0 = Release|Win32 {330F7738-C84C-4DEE-AA13-1324A7118F29}.Release|x64.ActiveCfg = Release|x64 {330F7738-C84C-4DEE-AA13-1324A7118F29}.Release|x64.Build.0 = Release|x64 {1B9F8C94-3D66-4734-BBDA-43B1A1360BA9}.Debug|Win32.ActiveCfg = Debug|Win32 {1B9F8C94-3D66-4734-BBDA-43B1A1360BA9}.Debug|Win32.Build.0 = Debug|Win32 {1B9F8C94-3D66-4734-BBDA-43B1A1360BA9}.Debug|x64.ActiveCfg = Debug|x64 {1B9F8C94-3D66-4734-BBDA-43B1A1360BA9}.Debug|x64.Build.0 = Debug|x64 {1B9F8C94-3D66-4734-BBDA-43B1A1360BA9}.Release|Win32.ActiveCfg = Release|Win32 {1B9F8C94-3D66-4734-BBDA-43B1A1360BA9}.Release|Win32.Build.0 = Release|Win32 {1B9F8C94-3D66-4734-BBDA-43B1A1360BA9}.Release|x64.ActiveCfg = Release|x64 {1B9F8C94-3D66-4734-BBDA-43B1A1360BA9}.Release|x64.Build.0 = Release|x64 {B313A86A-CFE8-4E56-A7FA-AD1B962EC96B}.Debug|Win32.ActiveCfg = Debug|Win32 {B313A86A-CFE8-4E56-A7FA-AD1B962EC96B}.Debug|Win32.Build.0 = Debug|Win32 {B313A86A-CFE8-4E56-A7FA-AD1B962EC96B}.Debug|x64.ActiveCfg = Debug|x64 {B313A86A-CFE8-4E56-A7FA-AD1B962EC96B}.Debug|x64.Build.0 = Debug|x64 {B313A86A-CFE8-4E56-A7FA-AD1B962EC96B}.Release|Win32.ActiveCfg = Release|Win32 {B313A86A-CFE8-4E56-A7FA-AD1B962EC96B}.Release|Win32.Build.0 = Release|Win32 {B313A86A-CFE8-4E56-A7FA-AD1B962EC96B}.Release|x64.ActiveCfg = Release|x64 {B313A86A-CFE8-4E56-A7FA-AD1B962EC96B}.Release|x64.Build.0 = Release|x64 {0CE3F5B5-CC35-4DF3-8457-489C843A7843}.Debug|Win32.ActiveCfg = Debug|Win32 {0CE3F5B5-CC35-4DF3-8457-489C843A7843}.Debug|Win32.Build.0 = Debug|Win32 {0CE3F5B5-CC35-4DF3-8457-489C843A7843}.Debug|x64.ActiveCfg = Debug|x64 {0CE3F5B5-CC35-4DF3-8457-489C843A7843}.Debug|x64.Build.0 = Debug|x64 {0CE3F5B5-CC35-4DF3-8457-489C843A7843}.Release|Win32.ActiveCfg = Release|Win32 {0CE3F5B5-CC35-4DF3-8457-489C843A7843}.Release|Win32.Build.0 = Release|Win32 {0CE3F5B5-CC35-4DF3-8457-489C843A7843}.Release|x64.ActiveCfg = Release|x64 {0CE3F5B5-CC35-4DF3-8457-489C843A7843}.Release|x64.Build.0 = Release|x64 {20050A94-78F8-4783-B66A-88905E32CA7E}.Debug|Win32.ActiveCfg = Debug|Win32 {20050A94-78F8-4783-B66A-88905E32CA7E}.Debug|Win32.Build.0 = Debug|Win32 {20050A94-78F8-4783-B66A-88905E32CA7E}.Debug|x64.ActiveCfg = Debug|x64 {20050A94-78F8-4783-B66A-88905E32CA7E}.Debug|x64.Build.0 = Debug|x64 {20050A94-78F8-4783-B66A-88905E32CA7E}.Release|Win32.ActiveCfg = Release|Win32 {20050A94-78F8-4783-B66A-88905E32CA7E}.Release|Win32.Build.0 = Release|Win32 {20050A94-78F8-4783-B66A-88905E32CA7E}.Release|x64.ActiveCfg = Release|x64 {20050A94-78F8-4783-B66A-88905E32CA7E}.Release|x64.Build.0 = Release|x64 {F79CF60D-6FC3-4A24-935C-D09665B13400}.Debug|Win32.ActiveCfg = Debug|Win32 {F79CF60D-6FC3-4A24-935C-D09665B13400}.Debug|Win32.Build.0 = Debug|Win32 {F79CF60D-6FC3-4A24-935C-D09665B13400}.Debug|x64.ActiveCfg = Debug|x64 {F79CF60D-6FC3-4A24-935C-D09665B13400}.Debug|x64.Build.0 = Debug|x64 {F79CF60D-6FC3-4A24-935C-D09665B13400}.Release|Win32.ActiveCfg = Release|Win32 {F79CF60D-6FC3-4A24-935C-D09665B13400}.Release|Win32.Build.0 = Release|Win32 {F79CF60D-6FC3-4A24-935C-D09665B13400}.Release|x64.ActiveCfg = Release|x64 {F79CF60D-6FC3-4A24-935C-D09665B13400}.Release|x64.Build.0 = Release|x64 {E78109FE-AFFD-47B5-B077-7405F12EBF4B}.Debug|Win32.ActiveCfg = Debug|Win32 {E78109FE-AFFD-47B5-B077-7405F12EBF4B}.Debug|Win32.Build.0 = Debug|Win32 {E78109FE-AFFD-47B5-B077-7405F12EBF4B}.Debug|x64.ActiveCfg = Debug|x64 {E78109FE-AFFD-47B5-B077-7405F12EBF4B}.Debug|x64.Build.0 = Debug|x64 {E78109FE-AFFD-47B5-B077-7405F12EBF4B}.Release|Win32.ActiveCfg = Release|Win32 {E78109FE-AFFD-47B5-B077-7405F12EBF4B}.Release|Win32.Build.0 = Release|Win32 {E78109FE-AFFD-47B5-B077-7405F12EBF4B}.Release|x64.ActiveCfg = Release|x64 {E78109FE-AFFD-47B5-B077-7405F12EBF4B}.Release|x64.Build.0 = Release|x64 {40EAB710-54A7-4C3B-B264-12BF4AD0C752}.Debug|Win32.ActiveCfg = Debug|Win32 {40EAB710-54A7-4C3B-B264-12BF4AD0C752}.Debug|Win32.Build.0 = Debug|Win32 {40EAB710-54A7-4C3B-B264-12BF4AD0C752}.Debug|x64.ActiveCfg = Debug|x64 {40EAB710-54A7-4C3B-B264-12BF4AD0C752}.Debug|x64.Build.0 = Debug|x64 {40EAB710-54A7-4C3B-B264-12BF4AD0C752}.Release|Win32.ActiveCfg = Release|Win32 {40EAB710-54A7-4C3B-B264-12BF4AD0C752}.Release|Win32.Build.0 = Release|Win32 {40EAB710-54A7-4C3B-B264-12BF4AD0C752}.Release|x64.ActiveCfg = Release|x64 {40EAB710-54A7-4C3B-B264-12BF4AD0C752}.Release|x64.Build.0 = Release|x64 {46D51B2B-C319-4858-ADF0-476074188070}.Debug|Win32.ActiveCfg = Debug|Win32 {46D51B2B-C319-4858-ADF0-476074188070}.Debug|Win32.Build.0 = Debug|Win32 {46D51B2B-C319-4858-ADF0-476074188070}.Debug|x64.ActiveCfg = Debug|x64 {46D51B2B-C319-4858-ADF0-476074188070}.Debug|x64.Build.0 = Debug|x64 {46D51B2B-C319-4858-ADF0-476074188070}.Release|Win32.ActiveCfg = Release|Win32 {46D51B2B-C319-4858-ADF0-476074188070}.Release|Win32.Build.0 = Release|Win32 {46D51B2B-C319-4858-ADF0-476074188070}.Release|x64.ActiveCfg = Release|x64 {46D51B2B-C319-4858-ADF0-476074188070}.Release|x64.Build.0 = Release|x64 {BB201B0D-07F7-42AA-B16C-D8BD0F19CC98}.Debug|Win32.ActiveCfg = Debug|Win32 {BB201B0D-07F7-42AA-B16C-D8BD0F19CC98}.Debug|Win32.Build.0 = Debug|Win32 {BB201B0D-07F7-42AA-B16C-D8BD0F19CC98}.Debug|x64.ActiveCfg = Debug|x64 {BB201B0D-07F7-42AA-B16C-D8BD0F19CC98}.Debug|x64.Build.0 = Debug|x64 {BB201B0D-07F7-42AA-B16C-D8BD0F19CC98}.Release|Win32.ActiveCfg = Release|Win32 {BB201B0D-07F7-42AA-B16C-D8BD0F19CC98}.Release|Win32.Build.0 = Release|Win32 {BB201B0D-07F7-42AA-B16C-D8BD0F19CC98}.Release|x64.ActiveCfg = Release|x64 {BB201B0D-07F7-42AA-B16C-D8BD0F19CC98}.Release|x64.Build.0 = Release|x64 {AA40EBEE-F2EC-4DFA-A1C9-D58734BCBEA8}.Debug|Win32.ActiveCfg = Debug|Win32 {AA40EBEE-F2EC-4DFA-A1C9-D58734BCBEA8}.Debug|Win32.Build.0 = Debug|Win32 {AA40EBEE-F2EC-4DFA-A1C9-D58734BCBEA8}.Debug|x64.ActiveCfg = Debug|x64 {AA40EBEE-F2EC-4DFA-A1C9-D58734BCBEA8}.Debug|x64.Build.0 = Debug|x64 {AA40EBEE-F2EC-4DFA-A1C9-D58734BCBEA8}.Release|Win32.ActiveCfg = Release|Win32 {AA40EBEE-F2EC-4DFA-A1C9-D58734BCBEA8}.Release|Win32.Build.0 = Release|Win32 {AA40EBEE-F2EC-4DFA-A1C9-D58734BCBEA8}.Release|x64.ActiveCfg = Release|x64 {AA40EBEE-F2EC-4DFA-A1C9-D58734BCBEA8}.Release|x64.Build.0 = Release|x64 {26B8A115-120B-4D62-B593-3FD7FD4CA75E}.Debug|Win32.ActiveCfg = Debug|Win32 {26B8A115-120B-4D62-B593-3FD7FD4CA75E}.Debug|Win32.Build.0 = Debug|Win32 {26B8A115-120B-4D62-B593-3FD7FD4CA75E}.Debug|x64.ActiveCfg = Debug|x64 {26B8A115-120B-4D62-B593-3FD7FD4CA75E}.Debug|x64.Build.0 = Debug|x64 {26B8A115-120B-4D62-B593-3FD7FD4CA75E}.Release|Win32.ActiveCfg = Release|Win32 {26B8A115-120B-4D62-B593-3FD7FD4CA75E}.Release|Win32.Build.0 = Release|Win32 {26B8A115-120B-4D62-B593-3FD7FD4CA75E}.Release|x64.ActiveCfg = Release|x64 {26B8A115-120B-4D62-B593-3FD7FD4CA75E}.Release|x64.Build.0 = Release|x64 {D0AB4F75-48A7-4673-AA53-9134DFBD2956}.Debug|Win32.ActiveCfg = Debug|Win32 {D0AB4F75-48A7-4673-AA53-9134DFBD2956}.Debug|Win32.Build.0 = Debug|Win32 {D0AB4F75-48A7-4673-AA53-9134DFBD2956}.Debug|x64.ActiveCfg = Debug|x64 {D0AB4F75-48A7-4673-AA53-9134DFBD2956}.Debug|x64.Build.0 = Debug|x64 {D0AB4F75-48A7-4673-AA53-9134DFBD2956}.Release|Win32.ActiveCfg = Release|Win32 {D0AB4F75-48A7-4673-AA53-9134DFBD2956}.Release|Win32.Build.0 = Release|Win32 {D0AB4F75-48A7-4673-AA53-9134DFBD2956}.Release|x64.ActiveCfg = Release|x64 {D0AB4F75-48A7-4673-AA53-9134DFBD2956}.Release|x64.Build.0 = Release|x64 {2EB4F888-8048-4283-AAF9-B9419774F7A1}.Debug|Win32.ActiveCfg = Debug|Win32 {2EB4F888-8048-4283-AAF9-B9419774F7A1}.Debug|Win32.Build.0 = Debug|Win32 {2EB4F888-8048-4283-AAF9-B9419774F7A1}.Debug|x64.ActiveCfg = Debug|x64 {2EB4F888-8048-4283-AAF9-B9419774F7A1}.Debug|x64.Build.0 = Debug|x64 {2EB4F888-8048-4283-AAF9-B9419774F7A1}.Release|Win32.ActiveCfg = Release|Win32 {2EB4F888-8048-4283-AAF9-B9419774F7A1}.Release|Win32.Build.0 = Release|Win32 {2EB4F888-8048-4283-AAF9-B9419774F7A1}.Release|x64.ActiveCfg = Release|x64 {2EB4F888-8048-4283-AAF9-B9419774F7A1}.Release|x64.Build.0 = Release|x64 {F7350B52-3C26-4F8D-87F5-46461CF9AA21}.Debug|Win32.ActiveCfg = Debug|Win32 {F7350B52-3C26-4F8D-87F5-46461CF9AA21}.Debug|Win32.Build.0 = Debug|Win32 {F7350B52-3C26-4F8D-87F5-46461CF9AA21}.Debug|x64.ActiveCfg = Debug|x64 {F7350B52-3C26-4F8D-87F5-46461CF9AA21}.Debug|x64.Build.0 = Debug|x64 {F7350B52-3C26-4F8D-87F5-46461CF9AA21}.Release|Win32.ActiveCfg = Release|Win32 {F7350B52-3C26-4F8D-87F5-46461CF9AA21}.Release|Win32.Build.0 = Release|Win32 {F7350B52-3C26-4F8D-87F5-46461CF9AA21}.Release|x64.ActiveCfg = Release|x64 {F7350B52-3C26-4F8D-87F5-46461CF9AA21}.Release|x64.Build.0 = Release|x64 {93A2A9CB-18E3-4EF0-8186-A5C1C49271F9}.Debug|Win32.ActiveCfg = Debug|Win32 {93A2A9CB-18E3-4EF0-8186-A5C1C49271F9}.Debug|Win32.Build.0 = Debug|Win32 {93A2A9CB-18E3-4EF0-8186-A5C1C49271F9}.Debug|x64.ActiveCfg = Debug|x64 {93A2A9CB-18E3-4EF0-8186-A5C1C49271F9}.Debug|x64.Build.0 = Debug|x64 {93A2A9CB-18E3-4EF0-8186-A5C1C49271F9}.Release|Win32.ActiveCfg = Release|Win32 {93A2A9CB-18E3-4EF0-8186-A5C1C49271F9}.Release|Win32.Build.0 = Release|Win32 {93A2A9CB-18E3-4EF0-8186-A5C1C49271F9}.Release|x64.ActiveCfg = Release|x64 {93A2A9CB-18E3-4EF0-8186-A5C1C49271F9}.Release|x64.Build.0 = Release|x64 {AC29CE01-373A-4DAF-94A8-51477B18242B}.Debug|Win32.ActiveCfg = Debug|Win32 {AC29CE01-373A-4DAF-94A8-51477B18242B}.Debug|Win32.Build.0 = Debug|Win32 {AC29CE01-373A-4DAF-94A8-51477B18242B}.Debug|x64.ActiveCfg = Debug|x64 {AC29CE01-373A-4DAF-94A8-51477B18242B}.Debug|x64.Build.0 = Debug|x64 {AC29CE01-373A-4DAF-94A8-51477B18242B}.Release|Win32.ActiveCfg = Release|Win32 {AC29CE01-373A-4DAF-94A8-51477B18242B}.Release|Win32.Build.0 = Release|Win32 {AC29CE01-373A-4DAF-94A8-51477B18242B}.Release|x64.ActiveCfg = Release|x64 {AC29CE01-373A-4DAF-94A8-51477B18242B}.Release|x64.Build.0 = Release|x64 {898194CA-8687-478A-AF8C-AD6D02280B8E}.Debug|Win32.ActiveCfg = Debug|Win32 {898194CA-8687-478A-AF8C-AD6D02280B8E}.Debug|Win32.Build.0 = Debug|Win32 {898194CA-8687-478A-AF8C-AD6D02280B8E}.Debug|x64.ActiveCfg = Debug|x64 {898194CA-8687-478A-AF8C-AD6D02280B8E}.Debug|x64.Build.0 = Debug|x64 {898194CA-8687-478A-AF8C-AD6D02280B8E}.Release|Win32.ActiveCfg = Release|Win32 {898194CA-8687-478A-AF8C-AD6D02280B8E}.Release|Win32.Build.0 = Release|Win32 {898194CA-8687-478A-AF8C-AD6D02280B8E}.Release|x64.ActiveCfg = Release|x64 {898194CA-8687-478A-AF8C-AD6D02280B8E}.Release|x64.Build.0 = Release|x64 {23CBED72-0007-4671-BDCC-817403C2FDAB}.Debug|Win32.ActiveCfg = Debug|Win32 {23CBED72-0007-4671-BDCC-817403C2FDAB}.Debug|Win32.Build.0 = Debug|Win32 {23CBED72-0007-4671-BDCC-817403C2FDAB}.Debug|x64.ActiveCfg = Debug|x64 {23CBED72-0007-4671-BDCC-817403C2FDAB}.Debug|x64.Build.0 = Debug|x64 {23CBED72-0007-4671-BDCC-817403C2FDAB}.Release|Win32.ActiveCfg = Release|Win32 {23CBED72-0007-4671-BDCC-817403C2FDAB}.Release|Win32.Build.0 = Release|Win32 {23CBED72-0007-4671-BDCC-817403C2FDAB}.Release|x64.ActiveCfg = Release|x64 {23CBED72-0007-4671-BDCC-817403C2FDAB}.Release|x64.Build.0 = Release|x64 {B134B8F2-AE55-4046-902A-D282147C992F}.Debug|Win32.ActiveCfg = Debug|Win32 {B134B8F2-AE55-4046-902A-D282147C992F}.Debug|Win32.Build.0 = Debug|Win32 {B134B8F2-AE55-4046-902A-D282147C992F}.Debug|x64.ActiveCfg = Debug|x64 {B134B8F2-AE55-4046-902A-D282147C992F}.Debug|x64.Build.0 = Debug|x64 {B134B8F2-AE55-4046-902A-D282147C992F}.Release|Win32.ActiveCfg = Release|Win32 {B134B8F2-AE55-4046-902A-D282147C992F}.Release|Win32.Build.0 = Release|Win32 {B134B8F2-AE55-4046-902A-D282147C992F}.Release|x64.ActiveCfg = Release|x64 {B134B8F2-AE55-4046-902A-D282147C992F}.Release|x64.Build.0 = Release|x64 {D5F1FFDA-34DF-4A89-9767-924D39D35CCC}.Debug|Win32.ActiveCfg = Debug|Win32 {D5F1FFDA-34DF-4A89-9767-924D39D35CCC}.Debug|Win32.Build.0 = Debug|Win32 {D5F1FFDA-34DF-4A89-9767-924D39D35CCC}.Debug|x64.ActiveCfg = Debug|x64 {D5F1FFDA-34DF-4A89-9767-924D39D35CCC}.Debug|x64.Build.0 = Debug|x64 {D5F1FFDA-34DF-4A89-9767-924D39D35CCC}.Release|Win32.ActiveCfg = Release|Win32 {D5F1FFDA-34DF-4A89-9767-924D39D35CCC}.Release|Win32.Build.0 = Release|Win32 {D5F1FFDA-34DF-4A89-9767-924D39D35CCC}.Release|x64.ActiveCfg = Release|x64 {D5F1FFDA-34DF-4A89-9767-924D39D35CCC}.Release|x64.Build.0 = Release|x64 {1862DC50-4B23-4941-A190-C4838C0A49AE}.Debug|Win32.ActiveCfg = Debug|Win32 {1862DC50-4B23-4941-A190-C4838C0A49AE}.Debug|Win32.Build.0 = Debug|Win32 {1862DC50-4B23-4941-A190-C4838C0A49AE}.Debug|x64.ActiveCfg = Debug|x64 {1862DC50-4B23-4941-A190-C4838C0A49AE}.Debug|x64.Build.0 = Debug|x64 {1862DC50-4B23-4941-A190-C4838C0A49AE}.Release|Win32.ActiveCfg = Release|Win32 {1862DC50-4B23-4941-A190-C4838C0A49AE}.Release|Win32.Build.0 = Release|Win32 {1862DC50-4B23-4941-A190-C4838C0A49AE}.Release|x64.ActiveCfg = Release|x64 {1862DC50-4B23-4941-A190-C4838C0A49AE}.Release|x64.Build.0 = Release|x64 {6CDD5B46-39A7-49FD-B8C6-476C4958CAAF}.Debug|Win32.ActiveCfg = Debug|Win32 {6CDD5B46-39A7-49FD-B8C6-476C4958CAAF}.Debug|Win32.Build.0 = Debug|Win32 {6CDD5B46-39A7-49FD-B8C6-476C4958CAAF}.Debug|x64.ActiveCfg = Debug|x64 {6CDD5B46-39A7-49FD-B8C6-476C4958CAAF}.Debug|x64.Build.0 = Debug|x64 {6CDD5B46-39A7-49FD-B8C6-476C4958CAAF}.Release|Win32.ActiveCfg = Release|Win32 {6CDD5B46-39A7-49FD-B8C6-476C4958CAAF}.Release|Win32.Build.0 = Release|Win32 {6CDD5B46-39A7-49FD-B8C6-476C4958CAAF}.Release|x64.ActiveCfg = Release|x64 {6CDD5B46-39A7-49FD-B8C6-476C4958CAAF}.Release|x64.Build.0 = Release|x64 {8B1D4E3F-1125-4BDA-B81E-20E022C03538}.Debug|Win32.ActiveCfg = Debug|Win32 {8B1D4E3F-1125-4BDA-B81E-20E022C03538}.Debug|Win32.Build.0 = Debug|Win32 {8B1D4E3F-1125-4BDA-B81E-20E022C03538}.Debug|x64.ActiveCfg = Debug|x64 {8B1D4E3F-1125-4BDA-B81E-20E022C03538}.Debug|x64.Build.0 = Debug|x64 {8B1D4E3F-1125-4BDA-B81E-20E022C03538}.Release|Win32.ActiveCfg = Release|Win32 {8B1D4E3F-1125-4BDA-B81E-20E022C03538}.Release|Win32.Build.0 = Release|Win32 {8B1D4E3F-1125-4BDA-B81E-20E022C03538}.Release|x64.ActiveCfg = Release|x64 {8B1D4E3F-1125-4BDA-B81E-20E022C03538}.Release|x64.Build.0 = Release|x64 {05F1AFCD-A715-46A2-AEAB-89BC60FFCF2C}.Debug|Win32.ActiveCfg = Debug|Win32 {05F1AFCD-A715-46A2-AEAB-89BC60FFCF2C}.Debug|Win32.Build.0 = Debug|Win32 {05F1AFCD-A715-46A2-AEAB-89BC60FFCF2C}.Debug|x64.ActiveCfg = Debug|x64 {05F1AFCD-A715-46A2-AEAB-89BC60FFCF2C}.Debug|x64.Build.0 = Debug|x64 {05F1AFCD-A715-46A2-AEAB-89BC60FFCF2C}.Release|Win32.ActiveCfg = Release|Win32 {05F1AFCD-A715-46A2-AEAB-89BC60FFCF2C}.Release|Win32.Build.0 = Release|Win32 {05F1AFCD-A715-46A2-AEAB-89BC60FFCF2C}.Release|x64.ActiveCfg = Release|x64 {05F1AFCD-A715-46A2-AEAB-89BC60FFCF2C}.Release|x64.Build.0 = Release|x64 {88385AFF-169F-4B40-98A3-CA0B59BB9451}.Debug|Win32.ActiveCfg = Debug|Win32 {88385AFF-169F-4B40-98A3-CA0B59BB9451}.Debug|Win32.Build.0 = Debug|Win32 {88385AFF-169F-4B40-98A3-CA0B59BB9451}.Debug|x64.ActiveCfg = Debug|x64 {88385AFF-169F-4B40-98A3-CA0B59BB9451}.Debug|x64.Build.0 = Debug|x64 {88385AFF-169F-4B40-98A3-CA0B59BB9451}.Release|Win32.ActiveCfg = Release|Win32 {88385AFF-169F-4B40-98A3-CA0B59BB9451}.Release|Win32.Build.0 = Release|Win32 {88385AFF-169F-4B40-98A3-CA0B59BB9451}.Release|x64.ActiveCfg = Release|x64 {88385AFF-169F-4B40-98A3-CA0B59BB9451}.Release|x64.Build.0 = Release|x64 {EC4EF28D-919C-4B13-89BC-29D063D408A0}.Debug|Win32.ActiveCfg = Debug|Win32 {EC4EF28D-919C-4B13-89BC-29D063D408A0}.Debug|Win32.Build.0 = Debug|Win32 {EC4EF28D-919C-4B13-89BC-29D063D408A0}.Debug|x64.ActiveCfg = Debug|x64 {EC4EF28D-919C-4B13-89BC-29D063D408A0}.Debug|x64.Build.0 = Debug|x64 {EC4EF28D-919C-4B13-89BC-29D063D408A0}.Release|Win32.ActiveCfg = Release|Win32 {EC4EF28D-919C-4B13-89BC-29D063D408A0}.Release|Win32.Build.0 = Release|Win32 {EC4EF28D-919C-4B13-89BC-29D063D408A0}.Release|x64.ActiveCfg = Release|x64 {EC4EF28D-919C-4B13-89BC-29D063D408A0}.Release|x64.Build.0 = Release|x64 {205C829A-29D9-46AC-BC71-BE513794ECBE}.Debug|Win32.ActiveCfg = Debug|Win32 {205C829A-29D9-46AC-BC71-BE513794ECBE}.Debug|Win32.Build.0 = Debug|Win32 {205C829A-29D9-46AC-BC71-BE513794ECBE}.Debug|x64.ActiveCfg = Debug|x64 {205C829A-29D9-46AC-BC71-BE513794ECBE}.Debug|x64.Build.0 = Debug|x64 {205C829A-29D9-46AC-BC71-BE513794ECBE}.Release|Win32.ActiveCfg = Release|Win32 {205C829A-29D9-46AC-BC71-BE513794ECBE}.Release|Win32.Build.0 = Release|Win32 {205C829A-29D9-46AC-BC71-BE513794ECBE}.Release|x64.ActiveCfg = Release|x64 {205C829A-29D9-46AC-BC71-BE513794ECBE}.Release|x64.Build.0 = Release|x64 {A5B79959-9B49-4021-90F4-EE776D9863AC}.Debug|Win32.ActiveCfg = Debug|Win32 {A5B79959-9B49-4021-90F4-EE776D9863AC}.Debug|Win32.Build.0 = Debug|Win32 {A5B79959-9B49-4021-90F4-EE776D9863AC}.Debug|x64.ActiveCfg = Debug|x64 {A5B79959-9B49-4021-90F4-EE776D9863AC}.Debug|x64.Build.0 = Debug|x64 {A5B79959-9B49-4021-90F4-EE776D9863AC}.Release|Win32.ActiveCfg = Release|Win32 {A5B79959-9B49-4021-90F4-EE776D9863AC}.Release|Win32.Build.0 = Release|Win32 {A5B79959-9B49-4021-90F4-EE776D9863AC}.Release|x64.ActiveCfg = Release|x64 {A5B79959-9B49-4021-90F4-EE776D9863AC}.Release|x64.Build.0 = Release|x64 {8C67CBCA-C127-49FE-8CF4-DA38B66B5186}.Debug|Win32.ActiveCfg = Debug|Win32 {8C67CBCA-C127-49FE-8CF4-DA38B66B5186}.Debug|Win32.Build.0 = Debug|Win32 {8C67CBCA-C127-49FE-8CF4-DA38B66B5186}.Debug|x64.ActiveCfg = Debug|x64 {8C67CBCA-C127-49FE-8CF4-DA38B66B5186}.Debug|x64.Build.0 = Debug|x64 {8C67CBCA-C127-49FE-8CF4-DA38B66B5186}.Release|Win32.ActiveCfg = Release|Win32 {8C67CBCA-C127-49FE-8CF4-DA38B66B5186}.Release|Win32.Build.0 = Release|Win32 {8C67CBCA-C127-49FE-8CF4-DA38B66B5186}.Release|x64.ActiveCfg = Release|x64 {8C67CBCA-C127-49FE-8CF4-DA38B66B5186}.Release|x64.Build.0 = Release|x64 {94A2A4AC-186D-4403-BB02-A81077F4717B}.Debug|Win32.ActiveCfg = Debug|Win32 {94A2A4AC-186D-4403-BB02-A81077F4717B}.Debug|Win32.Build.0 = Debug|Win32 {94A2A4AC-186D-4403-BB02-A81077F4717B}.Debug|x64.ActiveCfg = Debug|x64 {94A2A4AC-186D-4403-BB02-A81077F4717B}.Debug|x64.Build.0 = Debug|x64 {94A2A4AC-186D-4403-BB02-A81077F4717B}.Release|Win32.ActiveCfg = Release|Win32 {94A2A4AC-186D-4403-BB02-A81077F4717B}.Release|Win32.Build.0 = Release|Win32 {94A2A4AC-186D-4403-BB02-A81077F4717B}.Release|x64.ActiveCfg = Release|x64 {94A2A4AC-186D-4403-BB02-A81077F4717B}.Release|x64.Build.0 = Release|x64 {F2B48C2D-B7A6-4AF7-A1B6-95023F7185E2}.Debug|Win32.ActiveCfg = Debug|Win32 {F2B48C2D-B7A6-4AF7-A1B6-95023F7185E2}.Debug|Win32.Build.0 = Debug|Win32 {F2B48C2D-B7A6-4AF7-A1B6-95023F7185E2}.Debug|x64.ActiveCfg = Debug|x64 {F2B48C2D-B7A6-4AF7-A1B6-95023F7185E2}.Debug|x64.Build.0 = Debug|x64 {F2B48C2D-B7A6-4AF7-A1B6-95023F7185E2}.Release|Win32.ActiveCfg = Release|Win32 {F2B48C2D-B7A6-4AF7-A1B6-95023F7185E2}.Release|Win32.Build.0 = Release|Win32 {F2B48C2D-B7A6-4AF7-A1B6-95023F7185E2}.Release|x64.ActiveCfg = Release|x64 {F2B48C2D-B7A6-4AF7-A1B6-95023F7185E2}.Release|x64.Build.0 = Release|x64 {5A0DC446-207D-4A16-BBE1-2F6FBBE5FA32}.Debug|Win32.ActiveCfg = Debug|Win32 {5A0DC446-207D-4A16-BBE1-2F6FBBE5FA32}.Debug|Win32.Build.0 = Debug|Win32 {5A0DC446-207D-4A16-BBE1-2F6FBBE5FA32}.Debug|x64.ActiveCfg = Debug|x64 {5A0DC446-207D-4A16-BBE1-2F6FBBE5FA32}.Debug|x64.Build.0 = Debug|x64 {5A0DC446-207D-4A16-BBE1-2F6FBBE5FA32}.Release|Win32.ActiveCfg = Release|Win32 {5A0DC446-207D-4A16-BBE1-2F6FBBE5FA32}.Release|Win32.Build.0 = Release|Win32 {5A0DC446-207D-4A16-BBE1-2F6FBBE5FA32}.Release|x64.ActiveCfg = Release|x64 {5A0DC446-207D-4A16-BBE1-2F6FBBE5FA32}.Release|x64.Build.0 = Release|x64 {808F86D0-5256-4673-8623-669BDF077406}.Debug|Win32.ActiveCfg = Debug|Win32 {808F86D0-5256-4673-8623-669BDF077406}.Debug|Win32.Build.0 = Debug|Win32 {808F86D0-5256-4673-8623-669BDF077406}.Debug|x64.ActiveCfg = Debug|x64 {808F86D0-5256-4673-8623-669BDF077406}.Debug|x64.Build.0 = Debug|x64 {808F86D0-5256-4673-8623-669BDF077406}.Release|Win32.ActiveCfg = Release|Win32 {808F86D0-5256-4673-8623-669BDF077406}.Release|Win32.Build.0 = Release|Win32 {808F86D0-5256-4673-8623-669BDF077406}.Release|x64.ActiveCfg = Release|x64 {808F86D0-5256-4673-8623-669BDF077406}.Release|x64.Build.0 = Release|x64 {57ED741A-DA02-48BF-B6B0-43230EEFF83D}.Debug|Win32.ActiveCfg = Debug|Win32 {57ED741A-DA02-48BF-B6B0-43230EEFF83D}.Debug|Win32.Build.0 = Debug|Win32 {57ED741A-DA02-48BF-B6B0-43230EEFF83D}.Debug|x64.ActiveCfg = Debug|x64 {57ED741A-DA02-48BF-B6B0-43230EEFF83D}.Debug|x64.Build.0 = Debug|x64 {57ED741A-DA02-48BF-B6B0-43230EEFF83D}.Release|Win32.ActiveCfg = Release|Win32 {57ED741A-DA02-48BF-B6B0-43230EEFF83D}.Release|Win32.Build.0 = Release|Win32 {57ED741A-DA02-48BF-B6B0-43230EEFF83D}.Release|x64.ActiveCfg = Release|x64 {57ED741A-DA02-48BF-B6B0-43230EEFF83D}.Release|x64.Build.0 = Release|x64 {C320625B-D86E-46DD-B08B-AE4328BF3FDB}.Debug|Win32.ActiveCfg = Debug|Win32 {C320625B-D86E-46DD-B08B-AE4328BF3FDB}.Debug|Win32.Build.0 = Debug|Win32 {C320625B-D86E-46DD-B08B-AE4328BF3FDB}.Debug|x64.ActiveCfg = Debug|x64 {C320625B-D86E-46DD-B08B-AE4328BF3FDB}.Debug|x64.Build.0 = Debug|x64 {C320625B-D86E-46DD-B08B-AE4328BF3FDB}.Release|Win32.ActiveCfg = Release|Win32 {C320625B-D86E-46DD-B08B-AE4328BF3FDB}.Release|Win32.Build.0 = Release|Win32 {C320625B-D86E-46DD-B08B-AE4328BF3FDB}.Release|x64.ActiveCfg = Release|x64 {C320625B-D86E-46DD-B08B-AE4328BF3FDB}.Release|x64.Build.0 = Release|x64 {DC53ACFA-DEEE-441C-AEE6-E96F1D6DB68B}.Debug|Win32.ActiveCfg = Debug|Win32 {DC53ACFA-DEEE-441C-AEE6-E96F1D6DB68B}.Debug|Win32.Build.0 = Debug|Win32 {DC53ACFA-DEEE-441C-AEE6-E96F1D6DB68B}.Debug|x64.ActiveCfg = Debug|x64 {DC53ACFA-DEEE-441C-AEE6-E96F1D6DB68B}.Debug|x64.Build.0 = Debug|x64 {DC53ACFA-DEEE-441C-AEE6-E96F1D6DB68B}.Release|Win32.ActiveCfg = Release|Win32 {DC53ACFA-DEEE-441C-AEE6-E96F1D6DB68B}.Release|Win32.Build.0 = Release|Win32 {DC53ACFA-DEEE-441C-AEE6-E96F1D6DB68B}.Release|x64.ActiveCfg = Release|x64 {DC53ACFA-DEEE-441C-AEE6-E96F1D6DB68B}.Release|x64.Build.0 = Release|x64 {6DDED97E-BEBC-447B-A102-4B14CCD62C9F}.Debug|Win32.ActiveCfg = Debug|Win32 {6DDED97E-BEBC-447B-A102-4B14CCD62C9F}.Debug|Win32.Build.0 = Debug|Win32 {6DDED97E-BEBC-447B-A102-4B14CCD62C9F}.Debug|x64.ActiveCfg = Debug|x64 {6DDED97E-BEBC-447B-A102-4B14CCD62C9F}.Debug|x64.Build.0 = Debug|x64 {6DDED97E-BEBC-447B-A102-4B14CCD62C9F}.Release|Win32.ActiveCfg = Release|Win32 {6DDED97E-BEBC-447B-A102-4B14CCD62C9F}.Release|Win32.Build.0 = Release|Win32 {6DDED97E-BEBC-447B-A102-4B14CCD62C9F}.Release|x64.ActiveCfg = Release|x64 {6DDED97E-BEBC-447B-A102-4B14CCD62C9F}.Release|x64.Build.0 = Release|x64 {72DC8986-697E-4EA1-B2A1-86453C2E6BFD}.Debug|Win32.ActiveCfg = Debug|Win32 {72DC8986-697E-4EA1-B2A1-86453C2E6BFD}.Debug|Win32.Build.0 = Debug|Win32 {72DC8986-697E-4EA1-B2A1-86453C2E6BFD}.Debug|x64.ActiveCfg = Debug|x64 {72DC8986-697E-4EA1-B2A1-86453C2E6BFD}.Debug|x64.Build.0 = Debug|x64 {72DC8986-697E-4EA1-B2A1-86453C2E6BFD}.Release|Win32.ActiveCfg = Release|Win32 {72DC8986-697E-4EA1-B2A1-86453C2E6BFD}.Release|Win32.Build.0 = Release|Win32 {72DC8986-697E-4EA1-B2A1-86453C2E6BFD}.Release|x64.ActiveCfg = Release|x64 {72DC8986-697E-4EA1-B2A1-86453C2E6BFD}.Release|x64.Build.0 = Release|x64 {C5FB18BB-0572-407A-8FE7-F919A59D2ADC}.Debug|Win32.ActiveCfg = Debug|Win32 {C5FB18BB-0572-407A-8FE7-F919A59D2ADC}.Debug|Win32.Build.0 = Debug|Win32 {C5FB18BB-0572-407A-8FE7-F919A59D2ADC}.Debug|x64.ActiveCfg = Debug|x64 {C5FB18BB-0572-407A-8FE7-F919A59D2ADC}.Debug|x64.Build.0 = Debug|x64 {C5FB18BB-0572-407A-8FE7-F919A59D2ADC}.Release|Win32.ActiveCfg = Release|Win32 {C5FB18BB-0572-407A-8FE7-F919A59D2ADC}.Release|Win32.Build.0 = Release|Win32 {C5FB18BB-0572-407A-8FE7-F919A59D2ADC}.Release|x64.ActiveCfg = Release|x64 {C5FB18BB-0572-407A-8FE7-F919A59D2ADC}.Release|x64.Build.0 = Release|x64 {2800452A-552F-4330-95EB-AB394CAF463B}.Debug|Win32.ActiveCfg = Debug|Win32 {2800452A-552F-4330-95EB-AB394CAF463B}.Debug|Win32.Build.0 = Debug|Win32 {2800452A-552F-4330-95EB-AB394CAF463B}.Debug|x64.ActiveCfg = Debug|x64 {2800452A-552F-4330-95EB-AB394CAF463B}.Debug|x64.Build.0 = Debug|x64 {2800452A-552F-4330-95EB-AB394CAF463B}.Release|Win32.ActiveCfg = Release|Win32 {2800452A-552F-4330-95EB-AB394CAF463B}.Release|Win32.Build.0 = Release|Win32 {2800452A-552F-4330-95EB-AB394CAF463B}.Release|x64.ActiveCfg = Release|x64 {4E5C40F6-9CC6-4242-A12E-6105D3C37988}.Debug|Win32.ActiveCfg = Debug|Win32 {4E5C40F6-9CC6-4242-A12E-6105D3C37988}.Debug|Win32.Build.0 = Debug|Win32 {4E5C40F6-9CC6-4242-A12E-6105D3C37988}.Debug|x64.ActiveCfg = Debug|x64 {4E5C40F6-9CC6-4242-A12E-6105D3C37988}.Debug|x64.Build.0 = Debug|x64 {4E5C40F6-9CC6-4242-A12E-6105D3C37988}.Release|Win32.ActiveCfg = Release|Win32 {4E5C40F6-9CC6-4242-A12E-6105D3C37988}.Release|Win32.Build.0 = Release|Win32 {4E5C40F6-9CC6-4242-A12E-6105D3C37988}.Release|x64.ActiveCfg = Release|x64 {4E5C40F6-9CC6-4242-A12E-6105D3C37988}.Release|x64.Build.0 = Release|x64 {3FD72315-A289-40B6-B42D-A4CB88A4E63B}.Debug|Win32.ActiveCfg = Debug|Win32 {3FD72315-A289-40B6-B42D-A4CB88A4E63B}.Debug|Win32.Build.0 = Debug|Win32 {3FD72315-A289-40B6-B42D-A4CB88A4E63B}.Debug|x64.ActiveCfg = Debug|x64 {3FD72315-A289-40B6-B42D-A4CB88A4E63B}.Debug|x64.Build.0 = Debug|x64 {3FD72315-A289-40B6-B42D-A4CB88A4E63B}.Release|Win32.ActiveCfg = Release|Win32 {3FD72315-A289-40B6-B42D-A4CB88A4E63B}.Release|Win32.Build.0 = Release|Win32 {3FD72315-A289-40B6-B42D-A4CB88A4E63B}.Release|x64.ActiveCfg = Release|x64 {3FD72315-A289-40B6-B42D-A4CB88A4E63B}.Release|x64.Build.0 = Release|x64 {7FB29BE2-6C9C-42DE-A73D-2D860785C1FA}.Debug|Win32.ActiveCfg = Debug|Win32 {7FB29BE2-6C9C-42DE-A73D-2D860785C1FA}.Debug|Win32.Build.0 = Debug|Win32 {7FB29BE2-6C9C-42DE-A73D-2D860785C1FA}.Debug|x64.ActiveCfg = Debug|x64 {7FB29BE2-6C9C-42DE-A73D-2D860785C1FA}.Debug|x64.Build.0 = Debug|x64 {7FB29BE2-6C9C-42DE-A73D-2D860785C1FA}.Release|Win32.ActiveCfg = Release|Win32 {7FB29BE2-6C9C-42DE-A73D-2D860785C1FA}.Release|Win32.Build.0 = Release|Win32 {7FB29BE2-6C9C-42DE-A73D-2D860785C1FA}.Release|x64.ActiveCfg = Release|x64 {7FB29BE2-6C9C-42DE-A73D-2D860785C1FA}.Release|x64.Build.0 = Release|x64 {877FBBB2-F0F4-411E-9438-4576D1B08F94}.Debug|Win32.ActiveCfg = Debug|Win32 {877FBBB2-F0F4-411E-9438-4576D1B08F94}.Debug|Win32.Build.0 = Debug|Win32 {877FBBB2-F0F4-411E-9438-4576D1B08F94}.Debug|x64.ActiveCfg = Debug|x64 {877FBBB2-F0F4-411E-9438-4576D1B08F94}.Debug|x64.Build.0 = Debug|x64 {877FBBB2-F0F4-411E-9438-4576D1B08F94}.Release|Win32.ActiveCfg = Release|Win32 {877FBBB2-F0F4-411E-9438-4576D1B08F94}.Release|Win32.Build.0 = Release|Win32 {877FBBB2-F0F4-411E-9438-4576D1B08F94}.Release|x64.ActiveCfg = Release|x64 {877FBBB2-F0F4-411E-9438-4576D1B08F94}.Release|x64.Build.0 = Release|x64 {D7E69275-F85F-47E7-A1C0-5B1914BBE79F}.Debug|Win32.ActiveCfg = Debug|Win32 {D7E69275-F85F-47E7-A1C0-5B1914BBE79F}.Debug|Win32.Build.0 = Debug|Win32 {D7E69275-F85F-47E7-A1C0-5B1914BBE79F}.Debug|x64.ActiveCfg = Debug|x64 {D7E69275-F85F-47E7-A1C0-5B1914BBE79F}.Debug|x64.Build.0 = Debug|x64 {D7E69275-F85F-47E7-A1C0-5B1914BBE79F}.Release|Win32.ActiveCfg = Release|Win32 {D7E69275-F85F-47E7-A1C0-5B1914BBE79F}.Release|Win32.Build.0 = Release|Win32 {D7E69275-F85F-47E7-A1C0-5B1914BBE79F}.Release|x64.ActiveCfg = Release|x64 {D7E69275-F85F-47E7-A1C0-5B1914BBE79F}.Release|x64.Build.0 = Release|x64 {480E426C-C2AF-4C46-9AE6-6A93FA005C18}.Debug|Win32.ActiveCfg = Debug|Win32 {480E426C-C2AF-4C46-9AE6-6A93FA005C18}.Debug|Win32.Build.0 = Debug|Win32 {480E426C-C2AF-4C46-9AE6-6A93FA005C18}.Debug|x64.ActiveCfg = Debug|x64 {480E426C-C2AF-4C46-9AE6-6A93FA005C18}.Debug|x64.Build.0 = Debug|x64 {480E426C-C2AF-4C46-9AE6-6A93FA005C18}.Release|Win32.ActiveCfg = Release|Win32 {480E426C-C2AF-4C46-9AE6-6A93FA005C18}.Release|Win32.Build.0 = Release|Win32 {480E426C-C2AF-4C46-9AE6-6A93FA005C18}.Release|x64.ActiveCfg = Release|x64 {480E426C-C2AF-4C46-9AE6-6A93FA005C18}.Release|x64.Build.0 = Release|x64 {04D5A0F5-82D8-4095-AC67-A691F9CEB768}.Debug|Win32.ActiveCfg = Debug|Win32 {04D5A0F5-82D8-4095-AC67-A691F9CEB768}.Debug|Win32.Build.0 = Debug|Win32 {04D5A0F5-82D8-4095-AC67-A691F9CEB768}.Debug|x64.ActiveCfg = Debug|x64 {04D5A0F5-82D8-4095-AC67-A691F9CEB768}.Debug|x64.Build.0 = Debug|x64 {04D5A0F5-82D8-4095-AC67-A691F9CEB768}.Release|Win32.ActiveCfg = Release|Win32 {04D5A0F5-82D8-4095-AC67-A691F9CEB768}.Release|Win32.Build.0 = Release|Win32 {04D5A0F5-82D8-4095-AC67-A691F9CEB768}.Release|x64.ActiveCfg = Release|x64 {04D5A0F5-82D8-4095-AC67-A691F9CEB768}.Release|x64.Build.0 = Release|x64 {D5CA1B70-2D03-4794-B15A-E030ED92CB64}.Debug|Win32.ActiveCfg = Debug|Win32 {D5CA1B70-2D03-4794-B15A-E030ED92CB64}.Debug|Win32.Build.0 = Debug|Win32 {D5CA1B70-2D03-4794-B15A-E030ED92CB64}.Debug|x64.ActiveCfg = Debug|x64 {D5CA1B70-2D03-4794-B15A-E030ED92CB64}.Debug|x64.Build.0 = Debug|x64 {D5CA1B70-2D03-4794-B15A-E030ED92CB64}.Release|Win32.ActiveCfg = Release|Win32 {D5CA1B70-2D03-4794-B15A-E030ED92CB64}.Release|Win32.Build.0 = Release|Win32 {D5CA1B70-2D03-4794-B15A-E030ED92CB64}.Release|x64.ActiveCfg = Release|x64 {D5CA1B70-2D03-4794-B15A-E030ED92CB64}.Release|x64.Build.0 = Release|x64 {8B162257-3A6F-401C-905A-5A616B8945F2}.Debug|Win32.ActiveCfg = Debug|Win32 {8B162257-3A6F-401C-905A-5A616B8945F2}.Debug|Win32.Build.0 = Debug|Win32 {8B162257-3A6F-401C-905A-5A616B8945F2}.Debug|x64.ActiveCfg = Debug|x64 {8B162257-3A6F-401C-905A-5A616B8945F2}.Debug|x64.Build.0 = Debug|x64 {8B162257-3A6F-401C-905A-5A616B8945F2}.Release|Win32.ActiveCfg = Release|Win32 {8B162257-3A6F-401C-905A-5A616B8945F2}.Release|Win32.Build.0 = Release|Win32 {8B162257-3A6F-401C-905A-5A616B8945F2}.Release|x64.ActiveCfg = Release|x64 {8B162257-3A6F-401C-905A-5A616B8945F2}.Release|x64.Build.0 = Release|x64 {71102476-03D2-401E-B6F6-301E984CB7DD}.Debug|Win32.ActiveCfg = Debug|Win32 {71102476-03D2-401E-B6F6-301E984CB7DD}.Debug|Win32.Build.0 = Debug|Win32 {71102476-03D2-401E-B6F6-301E984CB7DD}.Debug|x64.ActiveCfg = Debug|x64 {71102476-03D2-401E-B6F6-301E984CB7DD}.Debug|x64.Build.0 = Debug|x64 {71102476-03D2-401E-B6F6-301E984CB7DD}.Release|Win32.ActiveCfg = Release|Win32 {71102476-03D2-401E-B6F6-301E984CB7DD}.Release|Win32.Build.0 = Release|Win32 {71102476-03D2-401E-B6F6-301E984CB7DD}.Release|x64.ActiveCfg = Release|x64 {71102476-03D2-401E-B6F6-301E984CB7DD}.Release|x64.Build.0 = Release|x64 {7C625DDB-7776-4752-8B52-29E2983A4E95}.Debug|Win32.ActiveCfg = Debug|Win32 {7C625DDB-7776-4752-8B52-29E2983A4E95}.Debug|Win32.Build.0 = Debug|Win32 {7C625DDB-7776-4752-8B52-29E2983A4E95}.Debug|x64.ActiveCfg = Debug|x64 {7C625DDB-7776-4752-8B52-29E2983A4E95}.Debug|x64.Build.0 = Debug|x64 {7C625DDB-7776-4752-8B52-29E2983A4E95}.Release|Win32.ActiveCfg = Debug|Win32 {7C625DDB-7776-4752-8B52-29E2983A4E95}.Release|Win32.Build.0 = Debug|Win32 {7C625DDB-7776-4752-8B52-29E2983A4E95}.Release|x64.ActiveCfg = Release|x64 {7C625DDB-7776-4752-8B52-29E2983A4E95}.Release|x64.Build.0 = Release|x64 {19C4F045-3877-4320-9200-B97EC40996E2}.Debug|Win32.ActiveCfg = Debug|Win32 {19C4F045-3877-4320-9200-B97EC40996E2}.Debug|Win32.Build.0 = Debug|Win32 {19C4F045-3877-4320-9200-B97EC40996E2}.Debug|x64.ActiveCfg = Debug|x64 {19C4F045-3877-4320-9200-B97EC40996E2}.Debug|x64.Build.0 = Debug|x64 {19C4F045-3877-4320-9200-B97EC40996E2}.Release|Win32.ActiveCfg = Release|Win32 {19C4F045-3877-4320-9200-B97EC40996E2}.Release|Win32.Build.0 = Release|Win32 {19C4F045-3877-4320-9200-B97EC40996E2}.Release|x64.ActiveCfg = Release|x64 {19C4F045-3877-4320-9200-B97EC40996E2}.Release|x64.Build.0 = Release|x64 {008BCDED-1DD5-4B9D-B6B3-461B9BFE41A5}.Debug|Win32.ActiveCfg = Debug|Win32 {008BCDED-1DD5-4B9D-B6B3-461B9BFE41A5}.Debug|Win32.Build.0 = Debug|Win32 {008BCDED-1DD5-4B9D-B6B3-461B9BFE41A5}.Debug|x64.ActiveCfg = Debug|x64 {008BCDED-1DD5-4B9D-B6B3-461B9BFE41A5}.Debug|x64.Build.0 = Debug|x64 {008BCDED-1DD5-4B9D-B6B3-461B9BFE41A5}.Release|Win32.ActiveCfg = Release|Win32 {008BCDED-1DD5-4B9D-B6B3-461B9BFE41A5}.Release|Win32.Build.0 = Release|Win32 {008BCDED-1DD5-4B9D-B6B3-461B9BFE41A5}.Release|x64.ActiveCfg = Release|x64 {008BCDED-1DD5-4B9D-B6B3-461B9BFE41A5}.Release|x64.Build.0 = Release|x64 {7681DE2C-1FE2-4B7B-98CD-9D25C4107340}.Debug|Win32.ActiveCfg = Debug|Win32 {7681DE2C-1FE2-4B7B-98CD-9D25C4107340}.Debug|Win32.Build.0 = Debug|Win32 {7681DE2C-1FE2-4B7B-98CD-9D25C4107340}.Debug|x64.ActiveCfg = Debug|x64 {7681DE2C-1FE2-4B7B-98CD-9D25C4107340}.Debug|x64.Build.0 = Debug|x64 {7681DE2C-1FE2-4B7B-98CD-9D25C4107340}.Release|Win32.ActiveCfg = Release|Win32 {7681DE2C-1FE2-4B7B-98CD-9D25C4107340}.Release|Win32.Build.0 = Release|Win32 {7681DE2C-1FE2-4B7B-98CD-9D25C4107340}.Release|x64.ActiveCfg = Release|x64 {7681DE2C-1FE2-4B7B-98CD-9D25C4107340}.Release|x64.Build.0 = Release|x64 {042E07FE-5174-4FB9-9469-516E20F53FE5}.Debug|Win32.ActiveCfg = Debug|Win32 {042E07FE-5174-4FB9-9469-516E20F53FE5}.Debug|Win32.Build.0 = Debug|Win32 {042E07FE-5174-4FB9-9469-516E20F53FE5}.Debug|x64.ActiveCfg = Debug|x64 {042E07FE-5174-4FB9-9469-516E20F53FE5}.Debug|x64.Build.0 = Debug|x64 {042E07FE-5174-4FB9-9469-516E20F53FE5}.Release|Win32.ActiveCfg = Release|Win32 {042E07FE-5174-4FB9-9469-516E20F53FE5}.Release|Win32.Build.0 = Release|Win32 {042E07FE-5174-4FB9-9469-516E20F53FE5}.Release|x64.ActiveCfg = Release|x64 {042E07FE-5174-4FB9-9469-516E20F53FE5}.Release|x64.Build.0 = Release|x64 {E6671DBC-D0C3-4493-89CA-B6EBF8B60AB9}.Debug|Win32.ActiveCfg = Debug|Win32 {E6671DBC-D0C3-4493-89CA-B6EBF8B60AB9}.Debug|Win32.Build.0 = Debug|Win32 {E6671DBC-D0C3-4493-89CA-B6EBF8B60AB9}.Debug|x64.ActiveCfg = Debug|x64 {E6671DBC-D0C3-4493-89CA-B6EBF8B60AB9}.Debug|x64.Build.0 = Debug|x64 {E6671DBC-D0C3-4493-89CA-B6EBF8B60AB9}.Release|Win32.ActiveCfg = Release|Win32 {E6671DBC-D0C3-4493-89CA-B6EBF8B60AB9}.Release|Win32.Build.0 = Release|Win32 {E6671DBC-D0C3-4493-89CA-B6EBF8B60AB9}.Release|x64.ActiveCfg = Release|x64 {E6671DBC-D0C3-4493-89CA-B6EBF8B60AB9}.Release|x64.Build.0 = Release|x64 {3E1AE893-E6E6-4E09-807A-148360C538AF}.Debug|Win32.ActiveCfg = Debug|Win32 {3E1AE893-E6E6-4E09-807A-148360C538AF}.Debug|Win32.Build.0 = Debug|Win32 {3E1AE893-E6E6-4E09-807A-148360C538AF}.Debug|x64.ActiveCfg = Debug|x64 {3E1AE893-E6E6-4E09-807A-148360C538AF}.Debug|x64.Build.0 = Debug|x64 {3E1AE893-E6E6-4E09-807A-148360C538AF}.Release|Win32.ActiveCfg = Release|Win32 {3E1AE893-E6E6-4E09-807A-148360C538AF}.Release|Win32.Build.0 = Release|Win32 {3E1AE893-E6E6-4E09-807A-148360C538AF}.Release|x64.ActiveCfg = Release|x64 {3E1AE893-E6E6-4E09-807A-148360C538AF}.Release|x64.Build.0 = Release|x64 {4BBD77B6-48C2-4551-A874-327A414C3A35}.Debug|Win32.ActiveCfg = Debug|Win32 {4BBD77B6-48C2-4551-A874-327A414C3A35}.Debug|Win32.Build.0 = Debug|Win32 {4BBD77B6-48C2-4551-A874-327A414C3A35}.Debug|x64.ActiveCfg = Debug|x64 {4BBD77B6-48C2-4551-A874-327A414C3A35}.Debug|x64.Build.0 = Debug|x64 {4BBD77B6-48C2-4551-A874-327A414C3A35}.Release|Win32.ActiveCfg = Release|Win32 {4BBD77B6-48C2-4551-A874-327A414C3A35}.Release|Win32.Build.0 = Release|Win32 {4BBD77B6-48C2-4551-A874-327A414C3A35}.Release|x64.ActiveCfg = Release|x64 {4BBD77B6-48C2-4551-A874-327A414C3A35}.Release|x64.Build.0 = Release|x64 {A0DCC844-F0FB-420C-9B41-E557845411AC}.Debug|Win32.ActiveCfg = Debug|Win32 {A0DCC844-F0FB-420C-9B41-E557845411AC}.Debug|Win32.Build.0 = Debug|Win32 {A0DCC844-F0FB-420C-9B41-E557845411AC}.Debug|x64.ActiveCfg = Debug|x64 {A0DCC844-F0FB-420C-9B41-E557845411AC}.Debug|x64.Build.0 = Debug|x64 {A0DCC844-F0FB-420C-9B41-E557845411AC}.Release|Win32.ActiveCfg = Release|Win32 {A0DCC844-F0FB-420C-9B41-E557845411AC}.Release|Win32.Build.0 = Release|Win32 {A0DCC844-F0FB-420C-9B41-E557845411AC}.Release|x64.ActiveCfg = Release|x64 {A0DCC844-F0FB-420C-9B41-E557845411AC}.Release|x64.Build.0 = Release|x64 {5E8E3F00-79A9-4635-AE04-452B7D5497F6}.Debug|Win32.ActiveCfg = Debug|Win32 {5E8E3F00-79A9-4635-AE04-452B7D5497F6}.Debug|Win32.Build.0 = Debug|Win32 {5E8E3F00-79A9-4635-AE04-452B7D5497F6}.Debug|x64.ActiveCfg = Debug|x64 {5E8E3F00-79A9-4635-AE04-452B7D5497F6}.Debug|x64.Build.0 = Debug|x64 {5E8E3F00-79A9-4635-AE04-452B7D5497F6}.Release|Win32.ActiveCfg = Release|Win32 {5E8E3F00-79A9-4635-AE04-452B7D5497F6}.Release|Win32.Build.0 = Release|Win32 {5E8E3F00-79A9-4635-AE04-452B7D5497F6}.Release|x64.ActiveCfg = Release|x64 {5E8E3F00-79A9-4635-AE04-452B7D5497F6}.Release|x64.Build.0 = Release|x64 {6A036179-4726-40C2-89C9-2E18D4030E28}.Debug|Win32.ActiveCfg = Debug|Win32 {6A036179-4726-40C2-89C9-2E18D4030E28}.Debug|Win32.Build.0 = Debug|Win32 {6A036179-4726-40C2-89C9-2E18D4030E28}.Debug|x64.ActiveCfg = Debug|x64 {6A036179-4726-40C2-89C9-2E18D4030E28}.Debug|x64.Build.0 = Debug|x64 {6A036179-4726-40C2-89C9-2E18D4030E28}.Release|Win32.ActiveCfg = Release|Win32 {6A036179-4726-40C2-89C9-2E18D4030E28}.Release|Win32.Build.0 = Release|Win32 {6A036179-4726-40C2-89C9-2E18D4030E28}.Release|x64.ActiveCfg = Release|x64 {6A036179-4726-40C2-89C9-2E18D4030E28}.Release|x64.Build.0 = Release|x64 {50EFC9E8-FB88-44C3-9F30-075547E22992}.Debug|Win32.ActiveCfg = Debug|Win32 {50EFC9E8-FB88-44C3-9F30-075547E22992}.Debug|Win32.Build.0 = Debug|Win32 {50EFC9E8-FB88-44C3-9F30-075547E22992}.Debug|x64.ActiveCfg = Debug|x64 {50EFC9E8-FB88-44C3-9F30-075547E22992}.Debug|x64.Build.0 = Debug|x64 {50EFC9E8-FB88-44C3-9F30-075547E22992}.Release|Win32.ActiveCfg = Release|Win32 {50EFC9E8-FB88-44C3-9F30-075547E22992}.Release|Win32.Build.0 = Release|Win32 {50EFC9E8-FB88-44C3-9F30-075547E22992}.Release|x64.ActiveCfg = Release|x64 {50EFC9E8-FB88-44C3-9F30-075547E22992}.Release|x64.Build.0 = Release|x64 {5495242E-29D4-4C4E-9176-4A69F8CBD667}.Debug|Win32.ActiveCfg = Debug|Win32 {5495242E-29D4-4C4E-9176-4A69F8CBD667}.Debug|Win32.Build.0 = Debug|Win32 {5495242E-29D4-4C4E-9176-4A69F8CBD667}.Debug|x64.ActiveCfg = Debug|x64 {5495242E-29D4-4C4E-9176-4A69F8CBD667}.Debug|x64.Build.0 = Debug|x64 {5495242E-29D4-4C4E-9176-4A69F8CBD667}.Release|Win32.ActiveCfg = Release|Win32 {5495242E-29D4-4C4E-9176-4A69F8CBD667}.Release|Win32.Build.0 = Release|Win32 {5495242E-29D4-4C4E-9176-4A69F8CBD667}.Release|x64.ActiveCfg = Release|x64 {5495242E-29D4-4C4E-9176-4A69F8CBD667}.Release|x64.Build.0 = Release|x64 {8E9450F9-5523-4164-A1C9-F04103F2AA92}.Debug|Win32.ActiveCfg = Debug|Win32 {8E9450F9-5523-4164-A1C9-F04103F2AA92}.Debug|Win32.Build.0 = Debug|Win32 {8E9450F9-5523-4164-A1C9-F04103F2AA92}.Debug|x64.ActiveCfg = Debug|x64 {8E9450F9-5523-4164-A1C9-F04103F2AA92}.Debug|x64.Build.0 = Debug|x64 {8E9450F9-5523-4164-A1C9-F04103F2AA92}.Release|Win32.ActiveCfg = Release|Win32 {8E9450F9-5523-4164-A1C9-F04103F2AA92}.Release|Win32.Build.0 = Release|Win32 {8E9450F9-5523-4164-A1C9-F04103F2AA92}.Release|x64.ActiveCfg = Release|x64 {8E9450F9-5523-4164-A1C9-F04103F2AA92}.Release|x64.Build.0 = Release|x64 {080D15EE-2C04-44A1-94DE-B70917E64E85}.Debug|Win32.ActiveCfg = Debug|Win32 {080D15EE-2C04-44A1-94DE-B70917E64E85}.Debug|Win32.Build.0 = Debug|Win32 {080D15EE-2C04-44A1-94DE-B70917E64E85}.Debug|x64.ActiveCfg = Debug|x64 {080D15EE-2C04-44A1-94DE-B70917E64E85}.Debug|x64.Build.0 = Debug|x64 {080D15EE-2C04-44A1-94DE-B70917E64E85}.Release|Win32.ActiveCfg = Release|Win32 {080D15EE-2C04-44A1-94DE-B70917E64E85}.Release|Win32.Build.0 = Release|Win32 {080D15EE-2C04-44A1-94DE-B70917E64E85}.Release|x64.ActiveCfg = Release|x64 {080D15EE-2C04-44A1-94DE-B70917E64E85}.Release|x64.Build.0 = Release|x64 {D9399AF5-90FC-4010-ABFC-408314AB04A9}.Debug|Win32.ActiveCfg = Debug|Win32 {D9399AF5-90FC-4010-ABFC-408314AB04A9}.Debug|Win32.Build.0 = Debug|Win32 {D9399AF5-90FC-4010-ABFC-408314AB04A9}.Debug|x64.ActiveCfg = Debug|x64 {D9399AF5-90FC-4010-ABFC-408314AB04A9}.Debug|x64.Build.0 = Debug|x64 {D9399AF5-90FC-4010-ABFC-408314AB04A9}.Release|Win32.ActiveCfg = Release|Win32 {D9399AF5-90FC-4010-ABFC-408314AB04A9}.Release|Win32.Build.0 = Release|Win32 {D9399AF5-90FC-4010-ABFC-408314AB04A9}.Release|x64.ActiveCfg = Release|x64 {D9399AF5-90FC-4010-ABFC-408314AB04A9}.Release|x64.Build.0 = Release|x64 {2961C03E-0B57-483D-A4A6-622D07337E5B}.Debug|Win32.ActiveCfg = Debug|Win32 {2961C03E-0B57-483D-A4A6-622D07337E5B}.Debug|Win32.Build.0 = Debug|Win32 {2961C03E-0B57-483D-A4A6-622D07337E5B}.Debug|x64.ActiveCfg = Debug|x64 {2961C03E-0B57-483D-A4A6-622D07337E5B}.Debug|x64.Build.0 = Debug|x64 {2961C03E-0B57-483D-A4A6-622D07337E5B}.Release|Win32.ActiveCfg = Release|Win32 {2961C03E-0B57-483D-A4A6-622D07337E5B}.Release|Win32.Build.0 = Release|Win32 {2961C03E-0B57-483D-A4A6-622D07337E5B}.Release|x64.ActiveCfg = Release|x64 {2961C03E-0B57-483D-A4A6-622D07337E5B}.Release|x64.Build.0 = Release|x64 {7FB77E83-219A-42D6-98D0-66C13F38A221}.Debug|Win32.ActiveCfg = Debug|Win32 {7FB77E83-219A-42D6-98D0-66C13F38A221}.Debug|Win32.Build.0 = Debug|Win32 {7FB77E83-219A-42D6-98D0-66C13F38A221}.Debug|x64.ActiveCfg = Debug|x64 {7FB77E83-219A-42D6-98D0-66C13F38A221}.Debug|x64.Build.0 = Debug|x64 {7FB77E83-219A-42D6-98D0-66C13F38A221}.Release|Win32.ActiveCfg = Release|Win32 {7FB77E83-219A-42D6-98D0-66C13F38A221}.Release|Win32.Build.0 = Release|Win32 {7FB77E83-219A-42D6-98D0-66C13F38A221}.Release|x64.ActiveCfg = Release|x64 {7FB77E83-219A-42D6-98D0-66C13F38A221}.Release|x64.Build.0 = Release|x64 {8FC64DB6-5DCC-446C-8FEC-DA8D76756523}.Debug|Win32.ActiveCfg = Debug|Win32 {8FC64DB6-5DCC-446C-8FEC-DA8D76756523}.Debug|Win32.Build.0 = Debug|Win32 {8FC64DB6-5DCC-446C-8FEC-DA8D76756523}.Debug|x64.ActiveCfg = Debug|x64 {8FC64DB6-5DCC-446C-8FEC-DA8D76756523}.Debug|x64.Build.0 = Debug|x64 {8FC64DB6-5DCC-446C-8FEC-DA8D76756523}.Release|Win32.ActiveCfg = Release|Win32 {8FC64DB6-5DCC-446C-8FEC-DA8D76756523}.Release|Win32.Build.0 = Release|Win32 {8FC64DB6-5DCC-446C-8FEC-DA8D76756523}.Release|x64.ActiveCfg = Release|x64 {8FC64DB6-5DCC-446C-8FEC-DA8D76756523}.Release|x64.Build.0 = Release|x64 {378F2D05-7A71-4AC3-A045-C8416D965C94}.Debug|Win32.ActiveCfg = Debug|Win32 {378F2D05-7A71-4AC3-A045-C8416D965C94}.Debug|Win32.Build.0 = Debug|Win32 {378F2D05-7A71-4AC3-A045-C8416D965C94}.Debug|x64.ActiveCfg = Debug|x64 {378F2D05-7A71-4AC3-A045-C8416D965C94}.Debug|x64.Build.0 = Debug|x64 {378F2D05-7A71-4AC3-A045-C8416D965C94}.Release|Win32.ActiveCfg = Release|Win32 {378F2D05-7A71-4AC3-A045-C8416D965C94}.Release|Win32.Build.0 = Release|Win32 {378F2D05-7A71-4AC3-A045-C8416D965C94}.Release|x64.ActiveCfg = Release|x64 {378F2D05-7A71-4AC3-A045-C8416D965C94}.Release|x64.Build.0 = Release|x64 {551E7C9B-9844-415F-8D65-DAEA5DFF3279}.Debug|Win32.ActiveCfg = Debug|Win32 {551E7C9B-9844-415F-8D65-DAEA5DFF3279}.Debug|Win32.Build.0 = Debug|Win32 {551E7C9B-9844-415F-8D65-DAEA5DFF3279}.Debug|x64.ActiveCfg = Debug|x64 {551E7C9B-9844-415F-8D65-DAEA5DFF3279}.Debug|x64.Build.0 = Debug|x64 {551E7C9B-9844-415F-8D65-DAEA5DFF3279}.Release|Win32.ActiveCfg = Release|Win32 {551E7C9B-9844-415F-8D65-DAEA5DFF3279}.Release|Win32.Build.0 = Release|Win32 {551E7C9B-9844-415F-8D65-DAEA5DFF3279}.Release|x64.ActiveCfg = Release|x64 {551E7C9B-9844-415F-8D65-DAEA5DFF3279}.Release|x64.Build.0 = Release|x64 {9D169447-3B5B-41DA-96C2-EB40DE0A96D7}.Debug|Win32.ActiveCfg = Debug|Win32 {9D169447-3B5B-41DA-96C2-EB40DE0A96D7}.Debug|Win32.Build.0 = Debug|Win32 {9D169447-3B5B-41DA-96C2-EB40DE0A96D7}.Debug|x64.ActiveCfg = Debug|x64 {9D169447-3B5B-41DA-96C2-EB40DE0A96D7}.Debug|x64.Build.0 = Debug|x64 {9D169447-3B5B-41DA-96C2-EB40DE0A96D7}.Release|Win32.ActiveCfg = Release|Win32 {9D169447-3B5B-41DA-96C2-EB40DE0A96D7}.Release|Win32.Build.0 = Release|Win32 {9D169447-3B5B-41DA-96C2-EB40DE0A96D7}.Release|x64.ActiveCfg = Release|x64 {9D169447-3B5B-41DA-96C2-EB40DE0A96D7}.Release|x64.Build.0 = Release|x64 {7CC8AB03-9D9F-4001-B99A-AA8D24487043}.Debug|Win32.ActiveCfg = Debug|Win32 {7CC8AB03-9D9F-4001-B99A-AA8D24487043}.Debug|Win32.Build.0 = Debug|Win32 {7CC8AB03-9D9F-4001-B99A-AA8D24487043}.Debug|x64.ActiveCfg = Debug|x64 {7CC8AB03-9D9F-4001-B99A-AA8D24487043}.Debug|x64.Build.0 = Debug|x64 {7CC8AB03-9D9F-4001-B99A-AA8D24487043}.Release|Win32.ActiveCfg = Release|Win32 {7CC8AB03-9D9F-4001-B99A-AA8D24487043}.Release|Win32.Build.0 = Release|Win32 {7CC8AB03-9D9F-4001-B99A-AA8D24487043}.Release|x64.ActiveCfg = Release|x64 {7CC8AB03-9D9F-4001-B99A-AA8D24487043}.Release|x64.Build.0 = Release|x64 {D0CB0D23-2B7B-4D17-BC1C-6A698010503B}.Debug|Win32.ActiveCfg = Debug|Win32 {D0CB0D23-2B7B-4D17-BC1C-6A698010503B}.Debug|Win32.Build.0 = Debug|Win32 {D0CB0D23-2B7B-4D17-BC1C-6A698010503B}.Debug|x64.ActiveCfg = Debug|x64 {D0CB0D23-2B7B-4D17-BC1C-6A698010503B}.Debug|x64.Build.0 = Debug|x64 {D0CB0D23-2B7B-4D17-BC1C-6A698010503B}.Release|Win32.ActiveCfg = Release|Win32 {D0CB0D23-2B7B-4D17-BC1C-6A698010503B}.Release|Win32.Build.0 = Release|Win32 {D0CB0D23-2B7B-4D17-BC1C-6A698010503B}.Release|x64.ActiveCfg = Release|x64 {D0CB0D23-2B7B-4D17-BC1C-6A698010503B}.Release|x64.Build.0 = Release|x64 {55883549-B725-41B7-900D-28EDC4757B76}.Debug|Win32.ActiveCfg = Debug|Win32 {55883549-B725-41B7-900D-28EDC4757B76}.Debug|Win32.Build.0 = Debug|Win32 {55883549-B725-41B7-900D-28EDC4757B76}.Debug|x64.ActiveCfg = Debug|x64 {55883549-B725-41B7-900D-28EDC4757B76}.Debug|x64.Build.0 = Debug|x64 {55883549-B725-41B7-900D-28EDC4757B76}.Release|Win32.ActiveCfg = Release|Win32 {55883549-B725-41B7-900D-28EDC4757B76}.Release|Win32.Build.0 = Release|Win32 {55883549-B725-41B7-900D-28EDC4757B76}.Release|x64.ActiveCfg = Release|x64 {55883549-B725-41B7-900D-28EDC4757B76}.Release|x64.Build.0 = Release|x64 {AE7429E9-F7AD-4B49-9E6E-8615003DD8AF}.Debug|Win32.ActiveCfg = Debug|Win32 {AE7429E9-F7AD-4B49-9E6E-8615003DD8AF}.Debug|Win32.Build.0 = Debug|Win32 {AE7429E9-F7AD-4B49-9E6E-8615003DD8AF}.Debug|x64.ActiveCfg = Debug|x64 {AE7429E9-F7AD-4B49-9E6E-8615003DD8AF}.Debug|x64.Build.0 = Debug|x64 {AE7429E9-F7AD-4B49-9E6E-8615003DD8AF}.Release|Win32.ActiveCfg = Release|Win32 {AE7429E9-F7AD-4B49-9E6E-8615003DD8AF}.Release|Win32.Build.0 = Release|Win32 {AE7429E9-F7AD-4B49-9E6E-8615003DD8AF}.Release|x64.ActiveCfg = Release|x64 {AE7429E9-F7AD-4B49-9E6E-8615003DD8AF}.Release|x64.Build.0 = Release|x64 {8D10D126-A641-40DC-B8FC-1407F3FAFA55}.Debug|Win32.ActiveCfg = Debug|Win32 {8D10D126-A641-40DC-B8FC-1407F3FAFA55}.Debug|Win32.Build.0 = Debug|Win32 {8D10D126-A641-40DC-B8FC-1407F3FAFA55}.Debug|x64.ActiveCfg = Debug|x64 {8D10D126-A641-40DC-B8FC-1407F3FAFA55}.Debug|x64.Build.0 = Debug|x64 {8D10D126-A641-40DC-B8FC-1407F3FAFA55}.Release|Win32.ActiveCfg = Release|Win32 {8D10D126-A641-40DC-B8FC-1407F3FAFA55}.Release|Win32.Build.0 = Release|Win32 {8D10D126-A641-40DC-B8FC-1407F3FAFA55}.Release|x64.ActiveCfg = Release|x64 {8D10D126-A641-40DC-B8FC-1407F3FAFA55}.Release|x64.Build.0 = Release|x64 {210299CF-6040-4F8E-88D1-BAEC0E9C9FEE}.Debug|Win32.ActiveCfg = Debug|Win32 {210299CF-6040-4F8E-88D1-BAEC0E9C9FEE}.Debug|Win32.Build.0 = Debug|Win32 {210299CF-6040-4F8E-88D1-BAEC0E9C9FEE}.Debug|x64.ActiveCfg = Debug|x64 {210299CF-6040-4F8E-88D1-BAEC0E9C9FEE}.Debug|x64.Build.0 = Debug|x64 {210299CF-6040-4F8E-88D1-BAEC0E9C9FEE}.Release|Win32.ActiveCfg = Release|Win32 {210299CF-6040-4F8E-88D1-BAEC0E9C9FEE}.Release|Win32.Build.0 = Release|Win32 {210299CF-6040-4F8E-88D1-BAEC0E9C9FEE}.Release|x64.ActiveCfg = Release|x64 {210299CF-6040-4F8E-88D1-BAEC0E9C9FEE}.Release|x64.Build.0 = Release|x64 {7B2432C6-051D-4667-94E4-0521B4B3821D}.Debug|Win32.ActiveCfg = Debug|Win32 {7B2432C6-051D-4667-94E4-0521B4B3821D}.Debug|Win32.Build.0 = Debug|Win32 {7B2432C6-051D-4667-94E4-0521B4B3821D}.Debug|x64.ActiveCfg = Debug|x64 {7B2432C6-051D-4667-94E4-0521B4B3821D}.Debug|x64.Build.0 = Debug|x64 {7B2432C6-051D-4667-94E4-0521B4B3821D}.Release|Win32.ActiveCfg = Release|Win32 {7B2432C6-051D-4667-94E4-0521B4B3821D}.Release|Win32.Build.0 = Release|Win32 {7B2432C6-051D-4667-94E4-0521B4B3821D}.Release|x64.ActiveCfg = Release|x64 {7B2432C6-051D-4667-94E4-0521B4B3821D}.Release|x64.Build.0 = Release|x64 {50B96CD6-FE47-4DEE-B15B-B86E7F46872E}.Debug|Win32.ActiveCfg = Debug|Win32 {50B96CD6-FE47-4DEE-B15B-B86E7F46872E}.Debug|Win32.Build.0 = Debug|Win32 {50B96CD6-FE47-4DEE-B15B-B86E7F46872E}.Debug|x64.ActiveCfg = Debug|x64 {50B96CD6-FE47-4DEE-B15B-B86E7F46872E}.Debug|x64.Build.0 = Debug|x64 {50B96CD6-FE47-4DEE-B15B-B86E7F46872E}.Release|Win32.ActiveCfg = Release|Win32 {50B96CD6-FE47-4DEE-B15B-B86E7F46872E}.Release|Win32.Build.0 = Release|Win32 {50B96CD6-FE47-4DEE-B15B-B86E7F46872E}.Release|x64.ActiveCfg = Release|x64 {50B96CD6-FE47-4DEE-B15B-B86E7F46872E}.Release|x64.Build.0 = Release|x64 {12F90F29-06C8-4EE1-AC2C-C8B9F902C32E}.Debug|Win32.ActiveCfg = Debug|Win32 {12F90F29-06C8-4EE1-AC2C-C8B9F902C32E}.Debug|Win32.Build.0 = Debug|Win32 {12F90F29-06C8-4EE1-AC2C-C8B9F902C32E}.Debug|x64.ActiveCfg = Debug|x64 {12F90F29-06C8-4EE1-AC2C-C8B9F902C32E}.Debug|x64.Build.0 = Debug|x64 {12F90F29-06C8-4EE1-AC2C-C8B9F902C32E}.Release|Win32.ActiveCfg = Release|Win32 {12F90F29-06C8-4EE1-AC2C-C8B9F902C32E}.Release|Win32.Build.0 = Release|Win32 {12F90F29-06C8-4EE1-AC2C-C8B9F902C32E}.Release|x64.ActiveCfg = Release|x64 {12F90F29-06C8-4EE1-AC2C-C8B9F902C32E}.Release|x64.Build.0 = Release|x64 {AEF3C73D-9952-45D6-949E-7CFE0D3BE892}.Debug|Win32.ActiveCfg = Debug|Win32 {AEF3C73D-9952-45D6-949E-7CFE0D3BE892}.Debug|Win32.Build.0 = Debug|Win32 {AEF3C73D-9952-45D6-949E-7CFE0D3BE892}.Debug|x64.ActiveCfg = Debug|x64 {AEF3C73D-9952-45D6-949E-7CFE0D3BE892}.Debug|x64.Build.0 = Debug|x64 {AEF3C73D-9952-45D6-949E-7CFE0D3BE892}.Release|Win32.ActiveCfg = Release|Win32 {AEF3C73D-9952-45D6-949E-7CFE0D3BE892}.Release|Win32.Build.0 = Release|Win32 {AEF3C73D-9952-45D6-949E-7CFE0D3BE892}.Release|x64.ActiveCfg = Release|x64 {AEF3C73D-9952-45D6-949E-7CFE0D3BE892}.Release|x64.Build.0 = Release|x64 {825A5F4A-CF89-4A29-B778-E035B442225A}.Debug|Win32.ActiveCfg = Debug|Win32 {825A5F4A-CF89-4A29-B778-E035B442225A}.Debug|Win32.Build.0 = Debug|Win32 {825A5F4A-CF89-4A29-B778-E035B442225A}.Debug|x64.ActiveCfg = Debug|x64 {825A5F4A-CF89-4A29-B778-E035B442225A}.Debug|x64.Build.0 = Debug|x64 {825A5F4A-CF89-4A29-B778-E035B442225A}.Release|Win32.ActiveCfg = Release|Win32 {825A5F4A-CF89-4A29-B778-E035B442225A}.Release|Win32.Build.0 = Release|Win32 {825A5F4A-CF89-4A29-B778-E035B442225A}.Release|x64.ActiveCfg = Release|x64 {825A5F4A-CF89-4A29-B778-E035B442225A}.Release|x64.Build.0 = Release|x64 {489480B1-F26B-412F-8A36-70D07159E5BC}.Debug|Win32.ActiveCfg = Debug|Win32 {489480B1-F26B-412F-8A36-70D07159E5BC}.Debug|Win32.Build.0 = Debug|Win32 {489480B1-F26B-412F-8A36-70D07159E5BC}.Debug|x64.ActiveCfg = Debug|x64 {489480B1-F26B-412F-8A36-70D07159E5BC}.Debug|x64.Build.0 = Debug|x64 {489480B1-F26B-412F-8A36-70D07159E5BC}.Release|Win32.ActiveCfg = Release|Win32 {489480B1-F26B-412F-8A36-70D07159E5BC}.Release|Win32.Build.0 = Release|Win32 {489480B1-F26B-412F-8A36-70D07159E5BC}.Release|x64.ActiveCfg = Release|x64 {489480B1-F26B-412F-8A36-70D07159E5BC}.Release|x64.Build.0 = Release|x64 {BEFC2B0F-67E8-4637-A4D8-B977654F25D8}.Debug|Win32.ActiveCfg = Debug|Win32 {BEFC2B0F-67E8-4637-A4D8-B977654F25D8}.Debug|Win32.Build.0 = Debug|Win32 {BEFC2B0F-67E8-4637-A4D8-B977654F25D8}.Debug|x64.ActiveCfg = Debug|x64 {BEFC2B0F-67E8-4637-A4D8-B977654F25D8}.Debug|x64.Build.0 = Debug|x64 {BEFC2B0F-67E8-4637-A4D8-B977654F25D8}.Release|Win32.ActiveCfg = Release|Win32 {BEFC2B0F-67E8-4637-A4D8-B977654F25D8}.Release|Win32.Build.0 = Release|Win32 {BEFC2B0F-67E8-4637-A4D8-B977654F25D8}.Release|x64.ActiveCfg = Release|x64 {BEFC2B0F-67E8-4637-A4D8-B977654F25D8}.Release|x64.Build.0 = Release|x64 {FC3B266B-F1B4-4495-B348-5FDABCA36D99}.Debug|Win32.ActiveCfg = Debug|Win32 {FC3B266B-F1B4-4495-B348-5FDABCA36D99}.Debug|Win32.Build.0 = Debug|Win32 {FC3B266B-F1B4-4495-B348-5FDABCA36D99}.Debug|x64.ActiveCfg = Debug|x64 {FC3B266B-F1B4-4495-B348-5FDABCA36D99}.Debug|x64.Build.0 = Debug|x64 {FC3B266B-F1B4-4495-B348-5FDABCA36D99}.Release|Win32.ActiveCfg = Release|Win32 {FC3B266B-F1B4-4495-B348-5FDABCA36D99}.Release|Win32.Build.0 = Release|Win32 {FC3B266B-F1B4-4495-B348-5FDABCA36D99}.Release|x64.ActiveCfg = Release|x64 {FC3B266B-F1B4-4495-B348-5FDABCA36D99}.Release|x64.Build.0 = Release|x64 {B74F08C9-D7DF-46E9-9583-A82ACE4809AB}.Debug|Win32.ActiveCfg = Debug|Win32 {B74F08C9-D7DF-46E9-9583-A82ACE4809AB}.Debug|Win32.Build.0 = Debug|Win32 {B74F08C9-D7DF-46E9-9583-A82ACE4809AB}.Debug|x64.ActiveCfg = Debug|x64 {B74F08C9-D7DF-46E9-9583-A82ACE4809AB}.Debug|x64.Build.0 = Debug|x64 {B74F08C9-D7DF-46E9-9583-A82ACE4809AB}.Release|Win32.ActiveCfg = Release|Win32 {B74F08C9-D7DF-46E9-9583-A82ACE4809AB}.Release|Win32.Build.0 = Release|Win32 {B74F08C9-D7DF-46E9-9583-A82ACE4809AB}.Release|x64.ActiveCfg = Release|x64 {B74F08C9-D7DF-46E9-9583-A82ACE4809AB}.Release|x64.Build.0 = Release|x64 {41011670-B1AC-4B77-ABB3-AE6568674A37}.Debug|Win32.ActiveCfg = Debug|Win32 {41011670-B1AC-4B77-ABB3-AE6568674A37}.Debug|Win32.Build.0 = Debug|Win32 {41011670-B1AC-4B77-ABB3-AE6568674A37}.Debug|x64.ActiveCfg = Debug|x64 {41011670-B1AC-4B77-ABB3-AE6568674A37}.Debug|x64.Build.0 = Debug|x64 {41011670-B1AC-4B77-ABB3-AE6568674A37}.Release|Win32.ActiveCfg = Release|Win32 {41011670-B1AC-4B77-ABB3-AE6568674A37}.Release|Win32.Build.0 = Release|Win32 {41011670-B1AC-4B77-ABB3-AE6568674A37}.Release|x64.ActiveCfg = Release|x64 {41011670-B1AC-4B77-ABB3-AE6568674A37}.Release|x64.Build.0 = Release|x64 {9643E4ED-1F10-4A16-890D-E20240ADC190}.Debug|Win32.ActiveCfg = Debug|Win32 {9643E4ED-1F10-4A16-890D-E20240ADC190}.Debug|Win32.Build.0 = Debug|Win32 {9643E4ED-1F10-4A16-890D-E20240ADC190}.Debug|x64.ActiveCfg = Debug|x64 {9643E4ED-1F10-4A16-890D-E20240ADC190}.Debug|x64.Build.0 = Debug|x64 {9643E4ED-1F10-4A16-890D-E20240ADC190}.Release|Win32.ActiveCfg = Release|Win32 {9643E4ED-1F10-4A16-890D-E20240ADC190}.Release|Win32.Build.0 = Release|Win32 {9643E4ED-1F10-4A16-890D-E20240ADC190}.Release|x64.ActiveCfg = Release|x64 {9643E4ED-1F10-4A16-890D-E20240ADC190}.Release|x64.Build.0 = Release|x64 {3831E9F2-FDAA-4C48-B394-9F3A1CEC5759}.Debug|Win32.ActiveCfg = Debug|Win32 {3831E9F2-FDAA-4C48-B394-9F3A1CEC5759}.Debug|Win32.Build.0 = Debug|Win32 {3831E9F2-FDAA-4C48-B394-9F3A1CEC5759}.Debug|x64.ActiveCfg = Debug|x64 {3831E9F2-FDAA-4C48-B394-9F3A1CEC5759}.Debug|x64.Build.0 = Debug|x64 {3831E9F2-FDAA-4C48-B394-9F3A1CEC5759}.Release|Win32.ActiveCfg = Release|Win32 {3831E9F2-FDAA-4C48-B394-9F3A1CEC5759}.Release|Win32.Build.0 = Release|Win32 {3831E9F2-FDAA-4C48-B394-9F3A1CEC5759}.Release|x64.ActiveCfg = Release|x64 {3831E9F2-FDAA-4C48-B394-9F3A1CEC5759}.Release|x64.Build.0 = Release|x64 {7C40A774-EEF0-4681-A453-A38F67B460D2}.Debug|Win32.ActiveCfg = Debug|Win32 {7C40A774-EEF0-4681-A453-A38F67B460D2}.Debug|Win32.Build.0 = Debug|Win32 {7C40A774-EEF0-4681-A453-A38F67B460D2}.Debug|x64.ActiveCfg = Debug|x64 {7C40A774-EEF0-4681-A453-A38F67B460D2}.Debug|x64.Build.0 = Debug|x64 {7C40A774-EEF0-4681-A453-A38F67B460D2}.Release|Win32.ActiveCfg = Release|Win32 {7C40A774-EEF0-4681-A453-A38F67B460D2}.Release|Win32.Build.0 = Release|Win32 {7C40A774-EEF0-4681-A453-A38F67B460D2}.Release|x64.ActiveCfg = Release|x64 {7C40A774-EEF0-4681-A453-A38F67B460D2}.Release|x64.Build.0 = Release|x64 {A8A8CD5C-54F4-4F22-B01E-A6985A0CC263}.Debug|Win32.ActiveCfg = Debug|Win32 {A8A8CD5C-54F4-4F22-B01E-A6985A0CC263}.Debug|Win32.Build.0 = Debug|Win32 {A8A8CD5C-54F4-4F22-B01E-A6985A0CC263}.Debug|x64.ActiveCfg = Debug|x64 {A8A8CD5C-54F4-4F22-B01E-A6985A0CC263}.Debug|x64.Build.0 = Debug|x64 {A8A8CD5C-54F4-4F22-B01E-A6985A0CC263}.Release|Win32.ActiveCfg = Release|Win32 {A8A8CD5C-54F4-4F22-B01E-A6985A0CC263}.Release|Win32.Build.0 = Release|Win32 {A8A8CD5C-54F4-4F22-B01E-A6985A0CC263}.Release|x64.ActiveCfg = Release|x64 {A8A8CD5C-54F4-4F22-B01E-A6985A0CC263}.Release|x64.Build.0 = Release|x64 {6635CF18-5122-4950-A395-5AC8AFAC5B6C}.Debug|Win32.ActiveCfg = Debug|Win32 {6635CF18-5122-4950-A395-5AC8AFAC5B6C}.Debug|Win32.Build.0 = Debug|Win32 {6635CF18-5122-4950-A395-5AC8AFAC5B6C}.Debug|x64.ActiveCfg = Debug|x64 {6635CF18-5122-4950-A395-5AC8AFAC5B6C}.Debug|x64.Build.0 = Debug|x64 {6635CF18-5122-4950-A395-5AC8AFAC5B6C}.Release|Win32.ActiveCfg = Release|Win32 {6635CF18-5122-4950-A395-5AC8AFAC5B6C}.Release|Win32.Build.0 = Release|Win32 {6635CF18-5122-4950-A395-5AC8AFAC5B6C}.Release|x64.ActiveCfg = Release|x64 {6635CF18-5122-4950-A395-5AC8AFAC5B6C}.Release|x64.Build.0 = Release|x64 {D3711C7C-8B57-49D4-89AB-B7EFE4CFD734}.Debug|Win32.ActiveCfg = Debug|Win32 {D3711C7C-8B57-49D4-89AB-B7EFE4CFD734}.Debug|Win32.Build.0 = Debug|Win32 {D3711C7C-8B57-49D4-89AB-B7EFE4CFD734}.Debug|x64.ActiveCfg = Debug|x64 {D3711C7C-8B57-49D4-89AB-B7EFE4CFD734}.Debug|x64.Build.0 = Debug|x64 {D3711C7C-8B57-49D4-89AB-B7EFE4CFD734}.Release|Win32.ActiveCfg = Release|Win32 {D3711C7C-8B57-49D4-89AB-B7EFE4CFD734}.Release|Win32.Build.0 = Release|Win32 {D3711C7C-8B57-49D4-89AB-B7EFE4CFD734}.Release|x64.ActiveCfg = Release|x64 {D3711C7C-8B57-49D4-89AB-B7EFE4CFD734}.Release|x64.Build.0 = Release|x64 {7A4352A7-59A4-43D5-9DB1-5B8FFEDBA487}.Debug|Win32.ActiveCfg = Debug|Win32 {7A4352A7-59A4-43D5-9DB1-5B8FFEDBA487}.Debug|Win32.Build.0 = Debug|Win32 {7A4352A7-59A4-43D5-9DB1-5B8FFEDBA487}.Debug|x64.ActiveCfg = Debug|x64 {7A4352A7-59A4-43D5-9DB1-5B8FFEDBA487}.Debug|x64.Build.0 = Debug|x64 {7A4352A7-59A4-43D5-9DB1-5B8FFEDBA487}.Release|Win32.ActiveCfg = Release|Win32 {7A4352A7-59A4-43D5-9DB1-5B8FFEDBA487}.Release|Win32.Build.0 = Release|Win32 {7A4352A7-59A4-43D5-9DB1-5B8FFEDBA487}.Release|x64.ActiveCfg = Release|x64 {7A4352A7-59A4-43D5-9DB1-5B8FFEDBA487}.Release|x64.Build.0 = Release|x64 {96006E4E-6BA3-45D3-BD0C-1C6948A7B190}.Debug|Win32.ActiveCfg = Debug|Win32 {96006E4E-6BA3-45D3-BD0C-1C6948A7B190}.Debug|Win32.Build.0 = Debug|Win32 {96006E4E-6BA3-45D3-BD0C-1C6948A7B190}.Debug|x64.ActiveCfg = Debug|x64 {96006E4E-6BA3-45D3-BD0C-1C6948A7B190}.Debug|x64.Build.0 = Debug|x64 {96006E4E-6BA3-45D3-BD0C-1C6948A7B190}.Release|Win32.ActiveCfg = Release|Win32 {96006E4E-6BA3-45D3-BD0C-1C6948A7B190}.Release|Win32.Build.0 = Release|Win32 {96006E4E-6BA3-45D3-BD0C-1C6948A7B190}.Release|x64.ActiveCfg = Release|x64 {96006E4E-6BA3-45D3-BD0C-1C6948A7B190}.Release|x64.Build.0 = Release|x64 {CBB339EA-F9A1-4E40-9E17-CFC2410D0C38}.Debug|Win32.ActiveCfg = Debug|Win32 {CBB339EA-F9A1-4E40-9E17-CFC2410D0C38}.Debug|Win32.Build.0 = Debug|Win32 {CBB339EA-F9A1-4E40-9E17-CFC2410D0C38}.Debug|x64.ActiveCfg = Debug|x64 {CBB339EA-F9A1-4E40-9E17-CFC2410D0C38}.Debug|x64.Build.0 = Debug|x64 {CBB339EA-F9A1-4E40-9E17-CFC2410D0C38}.Release|Win32.ActiveCfg = Release|Win32 {CBB339EA-F9A1-4E40-9E17-CFC2410D0C38}.Release|Win32.Build.0 = Release|Win32 {CBB339EA-F9A1-4E40-9E17-CFC2410D0C38}.Release|x64.ActiveCfg = Release|x64 {CBB339EA-F9A1-4E40-9E17-CFC2410D0C38}.Release|x64.Build.0 = Release|x64 {D96A11B7-CBA8-492B-BAB0-2176930A7B2D}.Debug|Win32.ActiveCfg = Debug|Win32 {D96A11B7-CBA8-492B-BAB0-2176930A7B2D}.Debug|Win32.Build.0 = Debug|Win32 {D96A11B7-CBA8-492B-BAB0-2176930A7B2D}.Debug|x64.ActiveCfg = Debug|x64 {D96A11B7-CBA8-492B-BAB0-2176930A7B2D}.Debug|x64.Build.0 = Debug|x64 {D96A11B7-CBA8-492B-BAB0-2176930A7B2D}.Release|Win32.ActiveCfg = Release|Win32 {D96A11B7-CBA8-492B-BAB0-2176930A7B2D}.Release|Win32.Build.0 = Release|Win32 {D96A11B7-CBA8-492B-BAB0-2176930A7B2D}.Release|x64.ActiveCfg = Release|x64 {D96A11B7-CBA8-492B-BAB0-2176930A7B2D}.Release|x64.Build.0 = Release|x64 {BCEEA3E0-567A-4946-A47F-8E300920BA24}.Debug|Win32.ActiveCfg = Debug|Win32 {BCEEA3E0-567A-4946-A47F-8E300920BA24}.Debug|Win32.Build.0 = Debug|Win32 {BCEEA3E0-567A-4946-A47F-8E300920BA24}.Debug|x64.ActiveCfg = Debug|x64 {BCEEA3E0-567A-4946-A47F-8E300920BA24}.Debug|x64.Build.0 = Debug|x64 {BCEEA3E0-567A-4946-A47F-8E300920BA24}.Release|Win32.ActiveCfg = Release|Win32 {BCEEA3E0-567A-4946-A47F-8E300920BA24}.Release|Win32.Build.0 = Release|Win32 {BCEEA3E0-567A-4946-A47F-8E300920BA24}.Release|x64.ActiveCfg = Release|x64 {BCEEA3E0-567A-4946-A47F-8E300920BA24}.Release|x64.Build.0 = Release|x64 {6C478B62-1737-4F87-B54C-89363C4FA5D8}.Debug|Win32.ActiveCfg = Debug|Win32 {6C478B62-1737-4F87-B54C-89363C4FA5D8}.Debug|Win32.Build.0 = Debug|Win32 {6C478B62-1737-4F87-B54C-89363C4FA5D8}.Debug|x64.ActiveCfg = Debug|x64 {6C478B62-1737-4F87-B54C-89363C4FA5D8}.Debug|x64.Build.0 = Debug|x64 {6C478B62-1737-4F87-B54C-89363C4FA5D8}.Release|Win32.ActiveCfg = Release|Win32 {6C478B62-1737-4F87-B54C-89363C4FA5D8}.Release|Win32.Build.0 = Release|Win32 {6C478B62-1737-4F87-B54C-89363C4FA5D8}.Release|x64.ActiveCfg = Release|x64 {6C478B62-1737-4F87-B54C-89363C4FA5D8}.Release|x64.Build.0 = Release|x64 {3869AF45-1841-47C8-B6FA-10FF36EB43D4}.Debug|Win32.ActiveCfg = Debug|Win32 {3869AF45-1841-47C8-B6FA-10FF36EB43D4}.Debug|Win32.Build.0 = Debug|Win32 {3869AF45-1841-47C8-B6FA-10FF36EB43D4}.Debug|x64.ActiveCfg = Debug|x64 {3869AF45-1841-47C8-B6FA-10FF36EB43D4}.Debug|x64.Build.0 = Debug|x64 {3869AF45-1841-47C8-B6FA-10FF36EB43D4}.Release|Win32.ActiveCfg = Release|Win32 {3869AF45-1841-47C8-B6FA-10FF36EB43D4}.Release|Win32.Build.0 = Release|Win32 {3869AF45-1841-47C8-B6FA-10FF36EB43D4}.Release|x64.ActiveCfg = Release|x64 {3869AF45-1841-47C8-B6FA-10FF36EB43D4}.Release|x64.Build.0 = Release|x64 {55E03CF1-A4CE-415A-AF58-9708A9037B73}.Debug|Win32.ActiveCfg = Debug|Win32 {55E03CF1-A4CE-415A-AF58-9708A9037B73}.Debug|Win32.Build.0 = Debug|Win32 {55E03CF1-A4CE-415A-AF58-9708A9037B73}.Debug|x64.ActiveCfg = Debug|x64 {55E03CF1-A4CE-415A-AF58-9708A9037B73}.Debug|x64.Build.0 = Debug|x64 {55E03CF1-A4CE-415A-AF58-9708A9037B73}.Release|Win32.ActiveCfg = Release|Win32 {55E03CF1-A4CE-415A-AF58-9708A9037B73}.Release|Win32.Build.0 = Release|Win32 {55E03CF1-A4CE-415A-AF58-9708A9037B73}.Release|x64.ActiveCfg = Release|x64 {55E03CF1-A4CE-415A-AF58-9708A9037B73}.Release|x64.Build.0 = Release|x64 {FED2FE89-EBD6-4A98-A854-8336288241C5}.Debug|Win32.ActiveCfg = Debug|Win32 {FED2FE89-EBD6-4A98-A854-8336288241C5}.Debug|Win32.Build.0 = Debug|Win32 {FED2FE89-EBD6-4A98-A854-8336288241C5}.Debug|x64.ActiveCfg = Debug|x64 {FED2FE89-EBD6-4A98-A854-8336288241C5}.Debug|x64.Build.0 = Debug|x64 {FED2FE89-EBD6-4A98-A854-8336288241C5}.Release|Win32.ActiveCfg = Release|Win32 {FED2FE89-EBD6-4A98-A854-8336288241C5}.Release|Win32.Build.0 = Release|Win32 {FED2FE89-EBD6-4A98-A854-8336288241C5}.Release|x64.ActiveCfg = Release|x64 {FED2FE89-EBD6-4A98-A854-8336288241C5}.Release|x64.Build.0 = Release|x64 {9CCB91C8-CE8A-43E7-B818-C50B69CBEA52}.Debug|Win32.ActiveCfg = Debug|Win32 {9CCB91C8-CE8A-43E7-B818-C50B69CBEA52}.Debug|Win32.Build.0 = Debug|Win32 {9CCB91C8-CE8A-43E7-B818-C50B69CBEA52}.Debug|x64.ActiveCfg = Debug|x64 {9CCB91C8-CE8A-43E7-B818-C50B69CBEA52}.Debug|x64.Build.0 = Debug|x64 {9CCB91C8-CE8A-43E7-B818-C50B69CBEA52}.Release|Win32.ActiveCfg = Release|Win32 {9CCB91C8-CE8A-43E7-B818-C50B69CBEA52}.Release|Win32.Build.0 = Release|Win32 {9CCB91C8-CE8A-43E7-B818-C50B69CBEA52}.Release|x64.ActiveCfg = Release|x64 {9CCB91C8-CE8A-43E7-B818-C50B69CBEA52}.Release|x64.Build.0 = Release|x64 {83284438-103B-4D2C-A1F3-9A10F2856893}.Debug|Win32.ActiveCfg = Debug|Win32 {83284438-103B-4D2C-A1F3-9A10F2856893}.Debug|Win32.Build.0 = Debug|Win32 {83284438-103B-4D2C-A1F3-9A10F2856893}.Debug|x64.ActiveCfg = Debug|x64 {83284438-103B-4D2C-A1F3-9A10F2856893}.Debug|x64.Build.0 = Debug|x64 {83284438-103B-4D2C-A1F3-9A10F2856893}.Release|Win32.ActiveCfg = Release|Win32 {83284438-103B-4D2C-A1F3-9A10F2856893}.Release|Win32.Build.0 = Release|Win32 {83284438-103B-4D2C-A1F3-9A10F2856893}.Release|x64.ActiveCfg = Release|x64 {83284438-103B-4D2C-A1F3-9A10F2856893}.Release|x64.Build.0 = Release|x64 {9B1DFC22-D63F-41C0-8A1E-DE1D7E9A0E9A}.Debug|Win32.ActiveCfg = Debug|Win32 {9B1DFC22-D63F-41C0-8A1E-DE1D7E9A0E9A}.Debug|Win32.Build.0 = Debug|Win32 {9B1DFC22-D63F-41C0-8A1E-DE1D7E9A0E9A}.Debug|x64.ActiveCfg = Debug|x64 {9B1DFC22-D63F-41C0-8A1E-DE1D7E9A0E9A}.Debug|x64.Build.0 = Debug|x64 {9B1DFC22-D63F-41C0-8A1E-DE1D7E9A0E9A}.Release|Win32.ActiveCfg = Release|Win32 {9B1DFC22-D63F-41C0-8A1E-DE1D7E9A0E9A}.Release|Win32.Build.0 = Release|Win32 {9B1DFC22-D63F-41C0-8A1E-DE1D7E9A0E9A}.Release|x64.ActiveCfg = Release|x64 {9B1DFC22-D63F-41C0-8A1E-DE1D7E9A0E9A}.Release|x64.Build.0 = Release|x64 {F9D71C21-F737-423C-9005-CB3A22D31F28}.Debug|Win32.ActiveCfg = Debug|Win32 {F9D71C21-F737-423C-9005-CB3A22D31F28}.Debug|Win32.Build.0 = Debug|Win32 {F9D71C21-F737-423C-9005-CB3A22D31F28}.Debug|x64.ActiveCfg = Debug|x64 {F9D71C21-F737-423C-9005-CB3A22D31F28}.Debug|x64.Build.0 = Debug|x64 {F9D71C21-F737-423C-9005-CB3A22D31F28}.Release|Win32.ActiveCfg = Release|Win32 {F9D71C21-F737-423C-9005-CB3A22D31F28}.Release|Win32.Build.0 = Release|Win32 {F9D71C21-F737-423C-9005-CB3A22D31F28}.Release|x64.ActiveCfg = Release|x64 {F9D71C21-F737-423C-9005-CB3A22D31F28}.Release|x64.Build.0 = Release|x64 {463F78C3-F5E5-4D64-9F7E-B3B6C6635238}.Debug|Win32.ActiveCfg = Debug|Win32 {463F78C3-F5E5-4D64-9F7E-B3B6C6635238}.Debug|Win32.Build.0 = Debug|Win32 {463F78C3-F5E5-4D64-9F7E-B3B6C6635238}.Debug|x64.ActiveCfg = Debug|x64 {463F78C3-F5E5-4D64-9F7E-B3B6C6635238}.Debug|x64.Build.0 = Debug|x64 {463F78C3-F5E5-4D64-9F7E-B3B6C6635238}.Release|Win32.ActiveCfg = Release|Win32 {463F78C3-F5E5-4D64-9F7E-B3B6C6635238}.Release|Win32.Build.0 = Release|Win32 {463F78C3-F5E5-4D64-9F7E-B3B6C6635238}.Release|x64.ActiveCfg = Release|x64 {463F78C3-F5E5-4D64-9F7E-B3B6C6635238}.Release|x64.Build.0 = Release|x64 {C56DAF55-9456-4E18-9E81-6A637F402B21}.Debug|Win32.ActiveCfg = Debug|Win32 {C56DAF55-9456-4E18-9E81-6A637F402B21}.Debug|Win32.Build.0 = Debug|Win32 {C56DAF55-9456-4E18-9E81-6A637F402B21}.Debug|x64.ActiveCfg = Debug|x64 {C56DAF55-9456-4E18-9E81-6A637F402B21}.Debug|x64.Build.0 = Debug|x64 {C56DAF55-9456-4E18-9E81-6A637F402B21}.Release|Win32.ActiveCfg = Release|Win32 {C56DAF55-9456-4E18-9E81-6A637F402B21}.Release|Win32.Build.0 = Release|Win32 {C56DAF55-9456-4E18-9E81-6A637F402B21}.Release|x64.ActiveCfg = Release|x64 {C56DAF55-9456-4E18-9E81-6A637F402B21}.Release|x64.Build.0 = Release|x64 {DA880260-0151-4AA4-83B8-F2EE9A398621}.Debug|Win32.ActiveCfg = Debug|Win32 {DA880260-0151-4AA4-83B8-F2EE9A398621}.Debug|Win32.Build.0 = Debug|Win32 {DA880260-0151-4AA4-83B8-F2EE9A398621}.Debug|x64.ActiveCfg = Debug|x64 {DA880260-0151-4AA4-83B8-F2EE9A398621}.Debug|x64.Build.0 = Debug|x64 {DA880260-0151-4AA4-83B8-F2EE9A398621}.Release|Win32.ActiveCfg = Release|Win32 {DA880260-0151-4AA4-83B8-F2EE9A398621}.Release|Win32.Build.0 = Release|Win32 {DA880260-0151-4AA4-83B8-F2EE9A398621}.Release|x64.ActiveCfg = Release|x64 {DA880260-0151-4AA4-83B8-F2EE9A398621}.Release|x64.Build.0 = Release|x64 {06BD0427-4DB1-4EDC-8E57-DDFF92918E17}.Debug|Win32.ActiveCfg = Debug|Win32 {06BD0427-4DB1-4EDC-8E57-DDFF92918E17}.Debug|Win32.Build.0 = Debug|Win32 {06BD0427-4DB1-4EDC-8E57-DDFF92918E17}.Debug|x64.ActiveCfg = Debug|x64 {06BD0427-4DB1-4EDC-8E57-DDFF92918E17}.Debug|x64.Build.0 = Debug|x64 {06BD0427-4DB1-4EDC-8E57-DDFF92918E17}.Release|Win32.ActiveCfg = Release|Win32 {06BD0427-4DB1-4EDC-8E57-DDFF92918E17}.Release|Win32.Build.0 = Release|Win32 {06BD0427-4DB1-4EDC-8E57-DDFF92918E17}.Release|x64.ActiveCfg = Release|x64 {06BD0427-4DB1-4EDC-8E57-DDFF92918E17}.Release|x64.Build.0 = Release|x64 {2285C976-4710-4A60-85BC-49086DF1A2FF}.Debug|Win32.ActiveCfg = Debug|Win32 {2285C976-4710-4A60-85BC-49086DF1A2FF}.Debug|Win32.Build.0 = Debug|Win32 {2285C976-4710-4A60-85BC-49086DF1A2FF}.Debug|x64.ActiveCfg = Debug|x64 {2285C976-4710-4A60-85BC-49086DF1A2FF}.Debug|x64.Build.0 = Debug|x64 {2285C976-4710-4A60-85BC-49086DF1A2FF}.Release|Win32.ActiveCfg = Release|Win32 {2285C976-4710-4A60-85BC-49086DF1A2FF}.Release|Win32.Build.0 = Release|Win32 {2285C976-4710-4A60-85BC-49086DF1A2FF}.Release|x64.ActiveCfg = Release|x64 {2285C976-4710-4A60-85BC-49086DF1A2FF}.Release|x64.Build.0 = Release|x64 {1E489EFC-9E68-4C46-9EF7-29BA7B7E5C76}.Debug|Win32.ActiveCfg = Debug|Win32 {1E489EFC-9E68-4C46-9EF7-29BA7B7E5C76}.Debug|Win32.Build.0 = Debug|Win32 {1E489EFC-9E68-4C46-9EF7-29BA7B7E5C76}.Debug|x64.ActiveCfg = Debug|x64 {1E489EFC-9E68-4C46-9EF7-29BA7B7E5C76}.Debug|x64.Build.0 = Debug|x64 {1E489EFC-9E68-4C46-9EF7-29BA7B7E5C76}.Release|Win32.ActiveCfg = Release|Win32 {1E489EFC-9E68-4C46-9EF7-29BA7B7E5C76}.Release|Win32.Build.0 = Release|Win32 {1E489EFC-9E68-4C46-9EF7-29BA7B7E5C76}.Release|x64.ActiveCfg = Release|x64 {1E489EFC-9E68-4C46-9EF7-29BA7B7E5C76}.Release|x64.Build.0 = Release|x64 {6A53F65C-D46D-41F8-8E0F-AF7372067EA8}.Debug|Win32.ActiveCfg = Debug|Win32 {6A53F65C-D46D-41F8-8E0F-AF7372067EA8}.Debug|Win32.Build.0 = Debug|Win32 {6A53F65C-D46D-41F8-8E0F-AF7372067EA8}.Debug|x64.ActiveCfg = Debug|x64 {6A53F65C-D46D-41F8-8E0F-AF7372067EA8}.Debug|x64.Build.0 = Debug|x64 {6A53F65C-D46D-41F8-8E0F-AF7372067EA8}.Release|Win32.ActiveCfg = Release|Win32 {6A53F65C-D46D-41F8-8E0F-AF7372067EA8}.Release|Win32.Build.0 = Release|Win32 {6A53F65C-D46D-41F8-8E0F-AF7372067EA8}.Release|x64.ActiveCfg = Release|x64 {6A53F65C-D46D-41F8-8E0F-AF7372067EA8}.Release|x64.Build.0 = Release|x64 {71A7F1E1-72A8-40FD-B2F5-1CE1D0121370}.Debug|Win32.ActiveCfg = Debug|Win32 {71A7F1E1-72A8-40FD-B2F5-1CE1D0121370}.Debug|Win32.Build.0 = Debug|Win32 {71A7F1E1-72A8-40FD-B2F5-1CE1D0121370}.Debug|x64.ActiveCfg = Debug|x64 {71A7F1E1-72A8-40FD-B2F5-1CE1D0121370}.Debug|x64.Build.0 = Debug|x64 {71A7F1E1-72A8-40FD-B2F5-1CE1D0121370}.Release|Win32.ActiveCfg = Release|Win32 {71A7F1E1-72A8-40FD-B2F5-1CE1D0121370}.Release|Win32.Build.0 = Release|Win32 {71A7F1E1-72A8-40FD-B2F5-1CE1D0121370}.Release|x64.ActiveCfg = Release|x64 {71A7F1E1-72A8-40FD-B2F5-1CE1D0121370}.Release|x64.Build.0 = Release|x64 {4AAE926D-951C-48A0-A868-F0D205BED488}.Debug|Win32.ActiveCfg = Debug|Win32 {4AAE926D-951C-48A0-A868-F0D205BED488}.Debug|Win32.Build.0 = Debug|Win32 {4AAE926D-951C-48A0-A868-F0D205BED488}.Debug|x64.ActiveCfg = Debug|x64 {4AAE926D-951C-48A0-A868-F0D205BED488}.Debug|x64.Build.0 = Debug|x64 {4AAE926D-951C-48A0-A868-F0D205BED488}.Release|Win32.ActiveCfg = Release|Win32 {4AAE926D-951C-48A0-A868-F0D205BED488}.Release|Win32.Build.0 = Release|Win32 {4AAE926D-951C-48A0-A868-F0D205BED488}.Release|x64.ActiveCfg = Release|x64 {4AAE926D-951C-48A0-A868-F0D205BED488}.Release|x64.Build.0 = Release|x64 {8AE05377-17AE-4898-9A0F-85797908901D}.Debug|Win32.ActiveCfg = Debug|Win32 {8AE05377-17AE-4898-9A0F-85797908901D}.Debug|Win32.Build.0 = Debug|Win32 {8AE05377-17AE-4898-9A0F-85797908901D}.Debug|x64.ActiveCfg = Debug|x64 {8AE05377-17AE-4898-9A0F-85797908901D}.Debug|x64.Build.0 = Debug|x64 {8AE05377-17AE-4898-9A0F-85797908901D}.Release|Win32.ActiveCfg = Release|Win32 {8AE05377-17AE-4898-9A0F-85797908901D}.Release|Win32.Build.0 = Release|Win32 {8AE05377-17AE-4898-9A0F-85797908901D}.Release|x64.ActiveCfg = Release|x64 {8AE05377-17AE-4898-9A0F-85797908901D}.Release|x64.Build.0 = Release|x64 {1F954DB3-3957-43D3-B27D-A2A49552D3E9}.Debug|Win32.ActiveCfg = Debug|Win32 {1F954DB3-3957-43D3-B27D-A2A49552D3E9}.Debug|Win32.Build.0 = Debug|Win32 {1F954DB3-3957-43D3-B27D-A2A49552D3E9}.Debug|x64.ActiveCfg = Debug|x64 {1F954DB3-3957-43D3-B27D-A2A49552D3E9}.Debug|x64.Build.0 = Debug|x64 {1F954DB3-3957-43D3-B27D-A2A49552D3E9}.Release|Win32.ActiveCfg = Release|Win32 {1F954DB3-3957-43D3-B27D-A2A49552D3E9}.Release|Win32.Build.0 = Release|Win32 {1F954DB3-3957-43D3-B27D-A2A49552D3E9}.Release|x64.ActiveCfg = Release|x64 {1F954DB3-3957-43D3-B27D-A2A49552D3E9}.Release|x64.Build.0 = Release|x64 {BF459A20-A1BA-41B9-A4A9-54938F08434E}.Debug|Win32.ActiveCfg = Debug|Win32 {BF459A20-A1BA-41B9-A4A9-54938F08434E}.Debug|Win32.Build.0 = Debug|Win32 {BF459A20-A1BA-41B9-A4A9-54938F08434E}.Debug|x64.ActiveCfg = Debug|x64 {BF459A20-A1BA-41B9-A4A9-54938F08434E}.Debug|x64.Build.0 = Debug|x64 {BF459A20-A1BA-41B9-A4A9-54938F08434E}.Release|Win32.ActiveCfg = Release|Win32 {BF459A20-A1BA-41B9-A4A9-54938F08434E}.Release|Win32.Build.0 = Release|Win32 {BF459A20-A1BA-41B9-A4A9-54938F08434E}.Release|x64.ActiveCfg = Release|x64 {BF459A20-A1BA-41B9-A4A9-54938F08434E}.Release|x64.Build.0 = Release|x64 {89BB9690-8656-4A53-AACF-721D4B50A0DC}.Debug|Win32.ActiveCfg = Debug|Win32 {89BB9690-8656-4A53-AACF-721D4B50A0DC}.Debug|Win32.Build.0 = Debug|Win32 {89BB9690-8656-4A53-AACF-721D4B50A0DC}.Debug|x64.ActiveCfg = Debug|x64 {89BB9690-8656-4A53-AACF-721D4B50A0DC}.Debug|x64.Build.0 = Debug|x64 {89BB9690-8656-4A53-AACF-721D4B50A0DC}.Release|Win32.ActiveCfg = Release|Win32 {89BB9690-8656-4A53-AACF-721D4B50A0DC}.Release|Win32.Build.0 = Release|Win32 {89BB9690-8656-4A53-AACF-721D4B50A0DC}.Release|x64.ActiveCfg = Release|x64 {89BB9690-8656-4A53-AACF-721D4B50A0DC}.Release|x64.Build.0 = Release|x64 {36577F9B-0E3C-4962-86DB-E65711488D06}.Debug|Win32.ActiveCfg = Debug|Win32 {36577F9B-0E3C-4962-86DB-E65711488D06}.Debug|Win32.Build.0 = Debug|Win32 {36577F9B-0E3C-4962-86DB-E65711488D06}.Debug|x64.ActiveCfg = Debug|x64 {36577F9B-0E3C-4962-86DB-E65711488D06}.Debug|x64.Build.0 = Debug|x64 {36577F9B-0E3C-4962-86DB-E65711488D06}.Release|Win32.ActiveCfg = Release|Win32 {36577F9B-0E3C-4962-86DB-E65711488D06}.Release|Win32.Build.0 = Release|Win32 {36577F9B-0E3C-4962-86DB-E65711488D06}.Release|x64.ActiveCfg = Release|x64 {36577F9B-0E3C-4962-86DB-E65711488D06}.Release|x64.Build.0 = Release|x64 {7559AA0F-D574-4810-AB5B-6A4F6E6D600E}.Debug|Win32.ActiveCfg = Debug|Win32 {7559AA0F-D574-4810-AB5B-6A4F6E6D600E}.Debug|Win32.Build.0 = Debug|Win32 {7559AA0F-D574-4810-AB5B-6A4F6E6D600E}.Debug|x64.ActiveCfg = Debug|x64 {7559AA0F-D574-4810-AB5B-6A4F6E6D600E}.Debug|x64.Build.0 = Debug|x64 {7559AA0F-D574-4810-AB5B-6A4F6E6D600E}.Release|Win32.ActiveCfg = Release|Win32 {7559AA0F-D574-4810-AB5B-6A4F6E6D600E}.Release|Win32.Build.0 = Release|Win32 {7559AA0F-D574-4810-AB5B-6A4F6E6D600E}.Release|x64.ActiveCfg = Release|x64 {7559AA0F-D574-4810-AB5B-6A4F6E6D600E}.Release|x64.Build.0 = Release|x64 {FD75348C-4A4F-4167-A730-67EE3B986619}.Debug|Win32.ActiveCfg = Debug|Win32 {FD75348C-4A4F-4167-A730-67EE3B986619}.Debug|Win32.Build.0 = Debug|Win32 {FD75348C-4A4F-4167-A730-67EE3B986619}.Debug|x64.ActiveCfg = Debug|x64 {FD75348C-4A4F-4167-A730-67EE3B986619}.Debug|x64.Build.0 = Debug|x64 {FD75348C-4A4F-4167-A730-67EE3B986619}.Release|Win32.ActiveCfg = Release|Win32 {FD75348C-4A4F-4167-A730-67EE3B986619}.Release|Win32.Build.0 = Release|Win32 {FD75348C-4A4F-4167-A730-67EE3B986619}.Release|x64.ActiveCfg = Release|x64 {FD75348C-4A4F-4167-A730-67EE3B986619}.Release|x64.Build.0 = Release|x64 {21C2CA09-DF0A-48A1-B12C-C8630A355CA1}.Debug|Win32.ActiveCfg = Debug|Win32 {21C2CA09-DF0A-48A1-B12C-C8630A355CA1}.Debug|Win32.Build.0 = Debug|Win32 {21C2CA09-DF0A-48A1-B12C-C8630A355CA1}.Debug|x64.ActiveCfg = Debug|x64 {21C2CA09-DF0A-48A1-B12C-C8630A355CA1}.Debug|x64.Build.0 = Debug|x64 {21C2CA09-DF0A-48A1-B12C-C8630A355CA1}.Release|Win32.ActiveCfg = Release|Win32 {21C2CA09-DF0A-48A1-B12C-C8630A355CA1}.Release|Win32.Build.0 = Release|Win32 {21C2CA09-DF0A-48A1-B12C-C8630A355CA1}.Release|x64.ActiveCfg = Release|x64 {21C2CA09-DF0A-48A1-B12C-C8630A355CA1}.Release|x64.Build.0 = Release|x64 EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE EndGlobalSection GlobalSection(NestedProjects) = preSolution {8A1EB575-B721-4891-B5BD-17CC45D0103C} = {4192A2FD-D361-4C91-AE03-9C29DE78C952} {E1695434-494C-4FCD-804D-F2409528DC1F} = {4192A2FD-D361-4C91-AE03-9C29DE78C952} {B5917427-4096-4AE9-833C-D9129C08C2B7} = {4192A2FD-D361-4C91-AE03-9C29DE78C952} {9A3A242F-1472-4776-9839-CC62474B7F54} = {4192A2FD-D361-4C91-AE03-9C29DE78C952} {7DA5BAD1-B5CF-4F53-8560-E96C07DE023D} = {4192A2FD-D361-4C91-AE03-9C29DE78C952} {AE325872-A6F2-4554-9CF1-076499597BA6} = {4192A2FD-D361-4C91-AE03-9C29DE78C952} {C82A62DB-DDB4-4072-832F-6DD841C6D80E} = {0B59A1DA-6449-47CB-8540-C0A8BD86645D} {96DA1C71-3895-49FA-A4F1-2775C650AF3D} = {0B59A1DA-6449-47CB-8540-C0A8BD86645D} {4AF4FD03-C169-456A-966A-081DE6BB71C7} = {0B59A1DA-6449-47CB-8540-C0A8BD86645D} {AF57F91F-EB17-4989-B98F-FD59409FA4EC} = {0B59A1DA-6449-47CB-8540-C0A8BD86645D} {8A2E028B-6E13-4E8A-B0F5-9A58C30BFB11} = {0B59A1DA-6449-47CB-8540-C0A8BD86645D} {51A9B98F-FBB4-43B7-9029-2DCC3D9BD0E6} = {0B59A1DA-6449-47CB-8540-C0A8BD86645D} {AD4D498B-ACAB-42A9-9414-335B44BB2F8D} = {0B59A1DA-6449-47CB-8540-C0A8BD86645D} {1543B8E5-4E63-47A1-A4C5-3E864D51E4A3} = {D7D30070-3829-41C0-89EA-E25DE6B392E9} {D212AB5B-F446-410E-B593-7565B3970F81} = {D7D30070-3829-41C0-89EA-E25DE6B392E9} {E2D74770-F7DB-4807-A12F-2363F1F08CCE} = {D7D30070-3829-41C0-89EA-E25DE6B392E9} {50EFC9E8-FB88-44C3-9F30-075547E22992} = {D7D30070-3829-41C0-89EA-E25DE6B392E9} {5495242E-29D4-4C4E-9176-4A69F8CBD667} = {D7D30070-3829-41C0-89EA-E25DE6B392E9} {8E9450F9-5523-4164-A1C9-F04103F2AA92} = {D7D30070-3829-41C0-89EA-E25DE6B392E9} {080D15EE-2C04-44A1-94DE-B70917E64E85} = {D7D30070-3829-41C0-89EA-E25DE6B392E9} {D9399AF5-90FC-4010-ABFC-408314AB04A9} = {D7D30070-3829-41C0-89EA-E25DE6B392E9} {2961C03E-0B57-483D-A4A6-622D07337E5B} = {D7D30070-3829-41C0-89EA-E25DE6B392E9} {7FB77E83-219A-42D6-98D0-66C13F38A221} = {D7D30070-3829-41C0-89EA-E25DE6B392E9} {8FC64DB6-5DCC-446C-8FEC-DA8D76756523} = {D7D30070-3829-41C0-89EA-E25DE6B392E9} {378F2D05-7A71-4AC3-A045-C8416D965C94} = {D7D30070-3829-41C0-89EA-E25DE6B392E9} {AAB83BC2-6410-4114-AE0D-BFF15C9FF59B} = {D7D30070-3829-41C0-89EA-E25DE6B392E9} {C2B287D4-B0F5-473A-88ED-E79F0C2956B8} = {D7D30070-3829-41C0-89EA-E25DE6B392E9} {7E02621E-E197-4EA1-951E-CE83908C89A6} = {D7D30070-3829-41C0-89EA-E25DE6B392E9} {FBC8CB90-B99F-458E-9633-84AAF5E66864} = {D7D30070-3829-41C0-89EA-E25DE6B392E9} {9A0DCCB2-7C15-4C79-AF77-DB6BE7E428A4} = {1543B8E5-4E63-47A1-A4C5-3E864D51E4A3} {43FDB176-8A70-4C03-8F67-3EDD796B8EDA} = {1543B8E5-4E63-47A1-A4C5-3E864D51E4A3} {2A2FBA68-8B49-42C5-AC8C-4A33F7951FB4} = {1543B8E5-4E63-47A1-A4C5-3E864D51E4A3} {FB8E3538-C2D1-4A13-994A-D32593300F77} = {1543B8E5-4E63-47A1-A4C5-3E864D51E4A3} {7DFBC4AB-9BE2-4F0A-B2F5-38FB0B2D2DB5} = {1543B8E5-4E63-47A1-A4C5-3E864D51E4A3} {9FDDFF38-0A83-40D3-B492-02846102F8F8} = {1543B8E5-4E63-47A1-A4C5-3E864D51E4A3} {9A0FA918-A2DF-4C5E-80EB-583173AC1341} = {1543B8E5-4E63-47A1-A4C5-3E864D51E4A3} {D885564A-E7CA-4493-A9BB-B451049CFA73} = {1543B8E5-4E63-47A1-A4C5-3E864D51E4A3} {A4B8BD41-C07F-4913-82A4-D24D6DD73377} = {1543B8E5-4E63-47A1-A4C5-3E864D51E4A3} {330F7738-C84C-4DEE-AA13-1324A7118F29} = {1543B8E5-4E63-47A1-A4C5-3E864D51E4A3} {1B9F8C94-3D66-4734-BBDA-43B1A1360BA9} = {1543B8E5-4E63-47A1-A4C5-3E864D51E4A3} {B313A86A-CFE8-4E56-A7FA-AD1B962EC96B} = {1543B8E5-4E63-47A1-A4C5-3E864D51E4A3} {0CE3F5B5-CC35-4DF3-8457-489C843A7843} = {1543B8E5-4E63-47A1-A4C5-3E864D51E4A3} {20050A94-78F8-4783-B66A-88905E32CA7E} = {1543B8E5-4E63-47A1-A4C5-3E864D51E4A3} {46ED3730-4921-45D1-8FEF-4CE29745FB25} = {D212AB5B-F446-410E-B593-7565B3970F81} {AB3F038D-936E-40E6-914C-D2F1A2352FCF} = {D212AB5B-F446-410E-B593-7565B3970F81} {F79CF60D-6FC3-4A24-935C-D09665B13400} = {D212AB5B-F446-410E-B593-7565B3970F81} {E78109FE-AFFD-47B5-B077-7405F12EBF4B} = {D212AB5B-F446-410E-B593-7565B3970F81} {40EAB710-54A7-4C3B-B264-12BF4AD0C752} = {D212AB5B-F446-410E-B593-7565B3970F81} {46D51B2B-C319-4858-ADF0-476074188070} = {D212AB5B-F446-410E-B593-7565B3970F81} {BB201B0D-07F7-42AA-B16C-D8BD0F19CC98} = {D212AB5B-F446-410E-B593-7565B3970F81} {AA40EBEE-F2EC-4DFA-A1C9-D58734BCBEA8} = {D212AB5B-F446-410E-B593-7565B3970F81} {26B8A115-120B-4D62-B593-3FD7FD4CA75E} = {D212AB5B-F446-410E-B593-7565B3970F81} {D0AB4F75-48A7-4673-AA53-9134DFBD2956} = {D212AB5B-F446-410E-B593-7565B3970F81} {2EB4F888-8048-4283-AAF9-B9419774F7A1} = {D212AB5B-F446-410E-B593-7565B3970F81} {F7350B52-3C26-4F8D-87F5-46461CF9AA21} = {D212AB5B-F446-410E-B593-7565B3970F81} {93A2A9CB-18E3-4EF0-8186-A5C1C49271F9} = {D212AB5B-F446-410E-B593-7565B3970F81} {AC29CE01-373A-4DAF-94A8-51477B18242B} = {D212AB5B-F446-410E-B593-7565B3970F81} {898194CA-8687-478A-AF8C-AD6D02280B8E} = {D212AB5B-F446-410E-B593-7565B3970F81} {23CBED72-0007-4671-BDCC-817403C2FDAB} = {D212AB5B-F446-410E-B593-7565B3970F81} {B134B8F2-AE55-4046-902A-D282147C992F} = {D212AB5B-F446-410E-B593-7565B3970F81} {D5F1FFDA-34DF-4A89-9767-924D39D35CCC} = {D212AB5B-F446-410E-B593-7565B3970F81} {1862DC50-4B23-4941-A190-C4838C0A49AE} = {D212AB5B-F446-410E-B593-7565B3970F81} {6CDD5B46-39A7-49FD-B8C6-476C4958CAAF} = {D212AB5B-F446-410E-B593-7565B3970F81} {8B1D4E3F-1125-4BDA-B81E-20E022C03538} = {D212AB5B-F446-410E-B593-7565B3970F81} {05F1AFCD-A715-46A2-AEAB-89BC60FFCF2C} = {D212AB5B-F446-410E-B593-7565B3970F81} {88385AFF-169F-4B40-98A3-CA0B59BB9451} = {D212AB5B-F446-410E-B593-7565B3970F81} {EC4EF28D-919C-4B13-89BC-29D063D408A0} = {D212AB5B-F446-410E-B593-7565B3970F81} {205C829A-29D9-46AC-BC71-BE513794ECBE} = {D212AB5B-F446-410E-B593-7565B3970F81} {A5B79959-9B49-4021-90F4-EE776D9863AC} = {D212AB5B-F446-410E-B593-7565B3970F81} {8C67CBCA-C127-49FE-8CF4-DA38B66B5186} = {D212AB5B-F446-410E-B593-7565B3970F81} {94A2A4AC-186D-4403-BB02-A81077F4717B} = {D212AB5B-F446-410E-B593-7565B3970F81} {F2B48C2D-B7A6-4AF7-A1B6-95023F7185E2} = {D212AB5B-F446-410E-B593-7565B3970F81} {5A0DC446-207D-4A16-BBE1-2F6FBBE5FA32} = {D212AB5B-F446-410E-B593-7565B3970F81} {808F86D0-5256-4673-8623-669BDF077406} = {D212AB5B-F446-410E-B593-7565B3970F81} {57ED741A-DA02-48BF-B6B0-43230EEFF83D} = {D212AB5B-F446-410E-B593-7565B3970F81} {C320625B-D86E-46DD-B08B-AE4328BF3FDB} = {D212AB5B-F446-410E-B593-7565B3970F81} {DC53ACFA-DEEE-441C-AEE6-E96F1D6DB68B} = {D212AB5B-F446-410E-B593-7565B3970F81} {6DDED97E-BEBC-447B-A102-4B14CCD62C9F} = {D212AB5B-F446-410E-B593-7565B3970F81} {72DC8986-697E-4EA1-B2A1-86453C2E6BFD} = {D212AB5B-F446-410E-B593-7565B3970F81} {C5FB18BB-0572-407A-8FE7-F919A59D2ADC} = {D212AB5B-F446-410E-B593-7565B3970F81} {2800452A-552F-4330-95EB-AB394CAF463B} = {D212AB5B-F446-410E-B593-7565B3970F81} {4E5C40F6-9CC6-4242-A12E-6105D3C37988} = {D212AB5B-F446-410E-B593-7565B3970F81} {3FD72315-A289-40B6-B42D-A4CB88A4E63B} = {D212AB5B-F446-410E-B593-7565B3970F81} {7FB29BE2-6C9C-42DE-A73D-2D860785C1FA} = {D212AB5B-F446-410E-B593-7565B3970F81} {877FBBB2-F0F4-411E-9438-4576D1B08F94} = {D212AB5B-F446-410E-B593-7565B3970F81} {D7E69275-F85F-47E7-A1C0-5B1914BBE79F} = {D212AB5B-F446-410E-B593-7565B3970F81} {480E426C-C2AF-4C46-9AE6-6A93FA005C18} = {D212AB5B-F446-410E-B593-7565B3970F81} {04D5A0F5-82D8-4095-AC67-A691F9CEB768} = {D212AB5B-F446-410E-B593-7565B3970F81} {D5CA1B70-2D03-4794-B15A-E030ED92CB64} = {D212AB5B-F446-410E-B593-7565B3970F81} {8B162257-3A6F-401C-905A-5A616B8945F2} = {D212AB5B-F446-410E-B593-7565B3970F81} {71102476-03D2-401E-B6F6-301E984CB7DD} = {D212AB5B-F446-410E-B593-7565B3970F81} {7C625DDB-7776-4752-8B52-29E2983A4E95} = {D212AB5B-F446-410E-B593-7565B3970F81} {19C4F045-3877-4320-9200-B97EC40996E2} = {D212AB5B-F446-410E-B593-7565B3970F81} {008BCDED-1DD5-4B9D-B6B3-461B9BFE41A5} = {D212AB5B-F446-410E-B593-7565B3970F81} {7681DE2C-1FE2-4B7B-98CD-9D25C4107340} = {D212AB5B-F446-410E-B593-7565B3970F81} {042E07FE-5174-4FB9-9469-516E20F53FE5} = {D212AB5B-F446-410E-B593-7565B3970F81} {E6671DBC-D0C3-4493-89CA-B6EBF8B60AB9} = {D212AB5B-F446-410E-B593-7565B3970F81} {3E1AE893-E6E6-4E09-807A-148360C538AF} = {D212AB5B-F446-410E-B593-7565B3970F81} {4BBD77B6-48C2-4551-A874-327A414C3A35} = {D212AB5B-F446-410E-B593-7565B3970F81} {A0DCC844-F0FB-420C-9B41-E557845411AC} = {E2D74770-F7DB-4807-A12F-2363F1F08CCE} {5E8E3F00-79A9-4635-AE04-452B7D5497F6} = {E2D74770-F7DB-4807-A12F-2363F1F08CCE} {6A036179-4726-40C2-89C9-2E18D4030E28} = {E2D74770-F7DB-4807-A12F-2363F1F08CCE} {551E7C9B-9844-415F-8D65-DAEA5DFF3279} = {AAB83BC2-6410-4114-AE0D-BFF15C9FF59B} {9D169447-3B5B-41DA-96C2-EB40DE0A96D7} = {AAB83BC2-6410-4114-AE0D-BFF15C9FF59B} {7CC8AB03-9D9F-4001-B99A-AA8D24487043} = {AAB83BC2-6410-4114-AE0D-BFF15C9FF59B} {D0CB0D23-2B7B-4D17-BC1C-6A698010503B} = {AAB83BC2-6410-4114-AE0D-BFF15C9FF59B} {55883549-B725-41B7-900D-28EDC4757B76} = {AAB83BC2-6410-4114-AE0D-BFF15C9FF59B} {AE7429E9-F7AD-4B49-9E6E-8615003DD8AF} = {AAB83BC2-6410-4114-AE0D-BFF15C9FF59B} {8D10D126-A641-40DC-B8FC-1407F3FAFA55} = {AAB83BC2-6410-4114-AE0D-BFF15C9FF59B} {210299CF-6040-4F8E-88D1-BAEC0E9C9FEE} = {C2B287D4-B0F5-473A-88ED-E79F0C2956B8} {7B2432C6-051D-4667-94E4-0521B4B3821D} = {C2B287D4-B0F5-473A-88ED-E79F0C2956B8} {50B96CD6-FE47-4DEE-B15B-B86E7F46872E} = {C2B287D4-B0F5-473A-88ED-E79F0C2956B8} {12F90F29-06C8-4EE1-AC2C-C8B9F902C32E} = {C2B287D4-B0F5-473A-88ED-E79F0C2956B8} {AEF3C73D-9952-45D6-949E-7CFE0D3BE892} = {C2B287D4-B0F5-473A-88ED-E79F0C2956B8} {825A5F4A-CF89-4A29-B778-E035B442225A} = {C2B287D4-B0F5-473A-88ED-E79F0C2956B8} {489480B1-F26B-412F-8A36-70D07159E5BC} = {C2B287D4-B0F5-473A-88ED-E79F0C2956B8} {BEFC2B0F-67E8-4637-A4D8-B977654F25D8} = {C2B287D4-B0F5-473A-88ED-E79F0C2956B8} {FC3B266B-F1B4-4495-B348-5FDABCA36D99} = {C2B287D4-B0F5-473A-88ED-E79F0C2956B8} {B74F08C9-D7DF-46E9-9583-A82ACE4809AB} = {C2B287D4-B0F5-473A-88ED-E79F0C2956B8} {41011670-B1AC-4B77-ABB3-AE6568674A37} = {C2B287D4-B0F5-473A-88ED-E79F0C2956B8} {9643E4ED-1F10-4A16-890D-E20240ADC190} = {C2B287D4-B0F5-473A-88ED-E79F0C2956B8} {3831E9F2-FDAA-4C48-B394-9F3A1CEC5759} = {C2B287D4-B0F5-473A-88ED-E79F0C2956B8} {7C40A774-EEF0-4681-A453-A38F67B460D2} = {C2B287D4-B0F5-473A-88ED-E79F0C2956B8} {A8A8CD5C-54F4-4F22-B01E-A6985A0CC263} = {C2B287D4-B0F5-473A-88ED-E79F0C2956B8} {6635CF18-5122-4950-A395-5AC8AFAC5B6C} = {C2B287D4-B0F5-473A-88ED-E79F0C2956B8} {D3711C7C-8B57-49D4-89AB-B7EFE4CFD734} = {C2B287D4-B0F5-473A-88ED-E79F0C2956B8} {7A4352A7-59A4-43D5-9DB1-5B8FFEDBA487} = {C2B287D4-B0F5-473A-88ED-E79F0C2956B8} {96006E4E-6BA3-45D3-BD0C-1C6948A7B190} = {C2B287D4-B0F5-473A-88ED-E79F0C2956B8} {CBB339EA-F9A1-4E40-9E17-CFC2410D0C38} = {C2B287D4-B0F5-473A-88ED-E79F0C2956B8} {D96A11B7-CBA8-492B-BAB0-2176930A7B2D} = {C2B287D4-B0F5-473A-88ED-E79F0C2956B8} {BCEEA3E0-567A-4946-A47F-8E300920BA24} = {C2B287D4-B0F5-473A-88ED-E79F0C2956B8} {6C478B62-1737-4F87-B54C-89363C4FA5D8} = {C2B287D4-B0F5-473A-88ED-E79F0C2956B8} {3869AF45-1841-47C8-B6FA-10FF36EB43D4} = {C2B287D4-B0F5-473A-88ED-E79F0C2956B8} {55E03CF1-A4CE-415A-AF58-9708A9037B73} = {C2B287D4-B0F5-473A-88ED-E79F0C2956B8} {FED2FE89-EBD6-4A98-A854-8336288241C5} = {C2B287D4-B0F5-473A-88ED-E79F0C2956B8} {9CCB91C8-CE8A-43E7-B818-C50B69CBEA52} = {7E02621E-E197-4EA1-951E-CE83908C89A6} {83284438-103B-4D2C-A1F3-9A10F2856893} = {7E02621E-E197-4EA1-951E-CE83908C89A6} {9B1DFC22-D63F-41C0-8A1E-DE1D7E9A0E9A} = {7E02621E-E197-4EA1-951E-CE83908C89A6} {F9D71C21-F737-423C-9005-CB3A22D31F28} = {7E02621E-E197-4EA1-951E-CE83908C89A6} {463F78C3-F5E5-4D64-9F7E-B3B6C6635238} = {7E02621E-E197-4EA1-951E-CE83908C89A6} {C56DAF55-9456-4E18-9E81-6A637F402B21} = {7E02621E-E197-4EA1-951E-CE83908C89A6} {DA880260-0151-4AA4-83B8-F2EE9A398621} = {7E02621E-E197-4EA1-951E-CE83908C89A6} {06BD0427-4DB1-4EDC-8E57-DDFF92918E17} = {7E02621E-E197-4EA1-951E-CE83908C89A6} {2285C976-4710-4A60-85BC-49086DF1A2FF} = {7E02621E-E197-4EA1-951E-CE83908C89A6} {1E489EFC-9E68-4C46-9EF7-29BA7B7E5C76} = {7E02621E-E197-4EA1-951E-CE83908C89A6} {6A53F65C-D46D-41F8-8E0F-AF7372067EA8} = {FBC8CB90-B99F-458E-9633-84AAF5E66864} {71A7F1E1-72A8-40FD-B2F5-1CE1D0121370} = {FBC8CB90-B99F-458E-9633-84AAF5E66864} {4AAE926D-951C-48A0-A868-F0D205BED488} = {FBC8CB90-B99F-458E-9633-84AAF5E66864} {8AE05377-17AE-4898-9A0F-85797908901D} = {FBC8CB90-B99F-458E-9633-84AAF5E66864} {1F954DB3-3957-43D3-B27D-A2A49552D3E9} = {FBC8CB90-B99F-458E-9633-84AAF5E66864} {BF459A20-A1BA-41B9-A4A9-54938F08434E} = {FBC8CB90-B99F-458E-9633-84AAF5E66864} {89BB9690-8656-4A53-AACF-721D4B50A0DC} = {FBC8CB90-B99F-458E-9633-84AAF5E66864} {36577F9B-0E3C-4962-86DB-E65711488D06} = {FBC8CB90-B99F-458E-9633-84AAF5E66864} {7559AA0F-D574-4810-AB5B-6A4F6E6D600E} = {FBC8CB90-B99F-458E-9633-84AAF5E66864} {FD75348C-4A4F-4167-A730-67EE3B986619} = {FBC8CB90-B99F-458E-9633-84AAF5E66864} {21C2CA09-DF0A-48A1-B12C-C8630A355CA1} = {FBC8CB90-B99F-458E-9633-84AAF5E66864} EndGlobalSection EndGlobal ecl-16.1.2/msvc/gmp/build.vc8/gmp.suo000077500000000000000000003510001266352375300172260ustar00rootroot00000000000000аЯрЁБс>ўџ ўџџџ€џџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ§џџџўџџџўџџџД   !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~Root Entryџџџџџџџџ=”ђ^=ЧРProjInfoExџџџџџџџџProperty Manager"џџџџTaskListUserTasks$ џџџџўџџџўџџџўџџџўџџџўџџџўџџџўџџџўџџџ ўџџџўџџџўџџџўџџџўџџџўџџџўџџџўџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџбŸqьgЂGЛ”Нє§ŸYШ№C zC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\VsToolboxService"џџџџџџџџXmlPackageOptions$џџџџџџџџџџџџDebuggerWatches џџџџDebuggerBreakpoints(џџџџџџџџџџџџ†’C:\Archivos de programa\Microsoft Visual Studio 8\Common7\IDE\vc7\atlmfcŒC:\Archivos de programa\Microsoft Visual Studio 8\Common7\IDE\vc7\crtDebuggerExceptions& џџџџ DebuggerFindSource&џџџџџџџџџџџџ :DebuggerFindSymbol& џџџџўџџџDebuggerMemoryWindows, џџџџTdMultiStartupProj=;4{7DA5BC:\unix\cygwin\home\Juanjo\sr$Bookmarks V001.01\build.vc8\tXЯ \mpf\add\add.vcprojЖC:\unix\cygwin\home\Juanjo\src\ecl\mExternalFilesProjectContents:џџџџџџџџџџџџўџџџDocumentWindowPositions0 џџџџ DocumentWindowUserData.џџџџџџџџSolutionConfiguration,џџџџџџџџџџџџжS11}.dwStartupOpt=;?{8A2E028B-6E13-4E8A-B0F5-9A58C30BFB11}.Release|Win32.fBatchBld=;={8A2E028B-6E13-4E8A-B0F5-9A58C30BFB11}.Debug|Win32.fBatchBld=;4{51A9B98F-FBB4-43B7-9029-2DCC3D9BD0E6}.dwStartupOpt=;?{51A9B98F-FBB4-43B7-9029-2DCC3D9BD0E6}.Release|Win32.fBatchBld=;={51A9B98F-FBB4-43B7-9029-2DCC3D9BD0E6}.Debug|Win32.fBatchBld=;4{E1695434-494C-4FCD-804D-F2409528DC1F}.dwStartupOpt=;?{E1695434-494C-4FCD-804D-F2409528DC1F}.Release|Win32.fBatchBld=;={E1695434-494C-4FCD-804D-F2409528DC1F}.Debug|Win32.fBatchBld=;4{B5917427-4096-4AE9-833C-D9129C08C2B7}.dwStartupOpt=;?{B5917427-4096-4AE9-833C-D9129C08C2B7}.Release|Win32.fBatchBld=;={B5917427-4096-4AE9-833C-D9129C08C2B7}.Debug|Win32.fBatchBld=;4{9A3A242F-1472-4776-9839-CC62474B7F54}.dwStartupOpt=;?{9A3A242F-1472-4776-9839-CC62474B7F54}.Release|Win32.fBatchBld=;={9A3A242F-1472-4776-9839-CC62474B7F54}.Debug|Win32.fBatchBld=;4{60188E81-124C-4824-B346-F38B4146F742}.dwStartupOpt=;4{4192A2FD-D361-4C91-AE03-9C29DE78C952}.dwStartupOpt=;4{0B59A1DA-6449-47CB-8540-C0A8BD86645D}.dwStartupOpt=;4{AE325872-A6F2-4554-9CF1-076499597BA6}.dwStartupOpt=;={AE325872-A6F2-4554-9CF1-076499597BA6}.Release|x64.fBatchBld=;;{AE325872-A6F2-4554-9CF1-076499597BA6}.Debug|x64.fBatchBld=;4{AD4D498B-ACAB-42A9-9414-335B44BB2F8D}.dwStartupOpt=;={AD4D498B-ACAB-42A9-9414-335B44BB2F8D}.Release|x64.fBatchBld=;;{AD4D498B-ACAB-42A9-9414-335B44BB2F8D}.Debug|x64.fBatchBld=;4{2297FA81-6D9D-4DC3-BA42-04E93F397047}.dwStartupOpt=;?{2297FA81-6D9D-4DC3-BA42-04E93F397047}.Release|Win32.fBatchBld=;={2297FA81-6D9D-4DC3-BA42-04E93F397047}.Debug|Win32.fBatchBld=;4{001E0D42-4AF4-44B8-A8B2-3CD46D537DBE}.dwStartupOpt=;?{001E0D42-4AF4-44B8-A8B2-3CD46D537DBE}.Release|Win32.fBatchBld=;={001E0D42-4AF4-44B8-A8B2-3CD46D537DBE}.Debug|Win32.fBatchBld=;4{D3C6D6B7-CD38-4D49-9BA7-1FBB35F77223}.dwStartupOpt=;?{D3C6D6B7-CD38-4D49-9BA7-1FBB35F77223}.Release|Win32.fBatchBld=;={D3C6D6B7-CDMultiStartupProj=;4{7DA5BAD1-B5CF-4F53-8560-E96C07DE023D}.dwStartupOpt=;StartupProject=&{7DA5BAD1-B5CF-4F53-8560-E96C07DE023D};={7DA5BAD1-B5CF-4F53-8560-E96C07DE023D}.Release|x64.fBatchBld=;;{7DA5BAD1-B5CF-4F53-8560-E96C07DE023D}.Debug|x64.fBatchBld=;?{7DA5BAD1-B5CF-4F53-8560-E96C07DE023D}.Release|Win32.fBatchBld=;={7DA5BAD1-B5CF-4F53-8560-E96C07DE023D}.Debug|Win32.fBatchBld=;4{FA999C2A-A4D2-4331-8D63-E3A8B05EC58F}.dwStartupOpt=;={FA999C2A-A4D2-4331-8D63-E3A8B05EC58F}.Release|x64.fBatchBld=;;{FA999C2A-A4D2-4331-8D63-E3A8B05EC58F}.Debug|x64.fBatchBld=;?{FA999C2A-A4D2-4331-8D63-E3A8B05EC58F}.Release|Win32.fBatchBld=;={FA999C2A-A4D2-4331-8D63-E3A8B05EC58F}.Debug|Win32.fBatchBld=;4{C82A62DB-DDB4-4072-832F-6DD841C6D80E}.dwStartupOpt=;={C82A62DB-DDB4-4072-832F-6DD841C6D80E}.Release|x64.fBatchBld=;;{C82A62DB-DDB4-4072-832F-6DD841C6D80E}.Debug|x64.fBatchBld=;?{C82A62DB-DDB4-4072-832F-6DD841C6D80E}.Release|Win32.fBatchBld=;={C82A62DB-DDB4-4072-832F-6DD841C6D80E}.Debug|Win32.fBatchBld=;4{96DA1C71-3895-49FA-A4F1-2775C650AF3D}.dwStartupOpt=;={96DA1C71-3895-49FA-A4F1-2775C650AF3D}.Release|x64.fBatchBld=;;{96DA1C71-3895-49FA-A4F1-2775C650AF3D}.Debug|x64.fBatchBld=;?{96DA1C71-3895-49FA-A4F1-2775C650AF3D}.Release|Win32.fBatchBld=;={96DA1C71-3895-49FA-A4F1-2775C650AF3D}.Debug|Win32.fBatchBld=;4{8A1EB575-B721-4891-B5BD-17CC45D0103C}.dwStartupOpt=;={8A1EB575-B721-4891-B5BD-17CC45D0103C}.Release|x64.fBatchBld=;;{8A1EB575-B721-4891-B5BD-17CC45D0103C}.Debug|x64.fBatchBld=;?{8A1EB575-B721-4891-B5BD-17CC45D0103C}.Release|Win32.fBatchBld=;={8A1EB575-B721-4891-B5BD-17CC45D0103C}.Debug|Win32.fBatchBld=;4{4AF4FD03-C169-456A-966A-081DE6BB71C7}.dwStartupOpt=;={4AF4FD03-C169-456A-966A-081DE6BB71C7}.Release|x64.fBatchBld=;;{4AF4FD03-C169-456A-966A-081DE6BB71C7}.Debug|x64.fBatchBld=;?{4AF4FD03-C169-456A-966A-081DE6BB71C7}.Release|Win32.fBatchBld=;={4AF4FD03-C169-456A-966A-081DE6BB71C7}.Debug|Win32.fBatchBld=;4{AF57F91F-EB17-4989-B98F-FD59409FA4EC}.dwStartupOpt=;?{AF57F91F-EB17-4989-B98F-FD59409FA4EC}.Release|Win32.fBatchBld=;={AF57F91F-EB17-4989-B98F-FD59409FA4EC}.Debug|Win32.fBatchBld=;4{8A2E028B-6E13-4E8A-B0F5-9A58C30BFB38-4D49-9BA7-1FBB35F77223}.Debug|Win32.fBatchBld=;4{0412953E-06CE-4A60-9DCD-CA5CAC3A46CC}.dwStartupOpt=;?{0412953E-06CE-4A60-9DCD-CA5CAC3A46CC}.Release|Win32.fBatchBld=;={0412953E-06CE-4A60-9DCD-CA5CAC3A46CC}.Debug|Win32.fBatchBld=;4{D7D30070-3829-41C0-89EA-E25DE6B392E9}.dwStartupOpt=;4{1543B8E5-4E63-47A1-A4C5-3E864D51E4A3}.dwStartupOpt=;4{9A0DCCB2-7C15-4C79-AF77-DB6BE7E428A4}.dwStartupOpt=;={9A0DCCB2-7C15-4C79-AF77-DB6BE7E428A4}.Release|x64.fBatchBld=;;{9A0DCCB2-7C15-4C79-AF77-DB6BE7E428A4}.Debug|x64.fBatchBld=;?{9A0DCCB2-7C15-4C79-AF77-DB6BE7E428A4}.Release|Win32.fBatchBld=;={9A0DCCB2-7C15-4C79-AF77-DB6BE7E428A4}.Debug|Win32.fBatchBld=;4{43FDB176-8A70-4C03-8F67-3EDD796B8EDA}.dwStartupOpt=;={43FDB176-8A70-4C03-8F67-3EDD796B8EDA}.Release|x64.fBatchBld=;;{43FDB176-8A70-4C03-8F67-3EDD796B8EDA}.Debug|x64.fBatchBld=;?{43FDB176-8A70-4C03-8F67-3EDD796B8EDA}.Release|Win32.fBatchBld=;={43FDB176-8A70-4C03-8F67-3EDD796B8EDA}.Debug|Win32.fBatchBld=;4{2A2FBA68-8B49-42C5-AC8C-4A33F7951FB4}.dwStartupOpt=;={2A2FBA68-8B49-42C5-AC8C-4A33F7951FB4}.Release|x64.fBatchBld=;;{2A2FBA68-8B49-42C5-AC8C-4A33F7951FB4}.Debug|x64.fBatchBld=;?{2A2FBA68-8B49-42C5-AC8C-4A33F7951FB4}.Release|Win32.fBatchBld=;={2A2FBA68-8B49-42C5-AC8C-4A33F7951FB4}.Debug|Win32.fBatchBld=;4{D212AB5B-F446-410E-B593-7565B3970F81}.dwStartupOpt=;4{46ED3730-4921-45D1-8FEF-4CE29745FB25}.dwStartupOpt=;={46ED3730-4921-45D1-8FEF-4CE29745FB25}.Release|x64.fBatchBld=;;{46ED3730-4921-45D1-8FEF-4CE29745FB25}.Debug|x64.fBatchBld=;?{46ED3730-4921-45D1-8FEF-4CE29745FB25}.Release|Win32.fBatchBld=;={46ED3730-4921-45D1-8FEF-4CE29745FB25}.Debug|Win32.fBatchBld=;4{AB3F038D-936E-40E6-914C-D2F1A2352FCF}.dwStartupOpt=;={AB3F038D-936E-40E6-914C-D2F1A2352FCF}.Release|x64.fBatchBld=;;{AB3F038D-936E-40E6-914C-D2F1A2352FCF}.Debug|x64.fBatchBld=;?{AB3F038D-936E-40E6-914C-D2F1A2352FCF}.Release|Win32.fBatchBld=;={AB3F038D-936E-40E6-914C-D2F1A2352FCF}.Debug|Win32.fBatchBld=;4{FB8E3538-C2D1-4A13-994A-D32593300F77}.dwStartupOpt=;={FB8E3538-C2D1-4A13-994A-D32593300F77}.Release|x64.fBatchBld=;;{FB8E3538-C2D1-4A13-994A-D32593300F77}.Debug|x64.fBatchBld=;?{FB8E3538-C2D1-4A13-994A-D32593300F77}.Release|Win32.fBatchBld=;={FB8E3538-C2D1-4A13-994A-D32593300F77}.Debug|Win32.fBatchBld=;4{7DFBC4AB-9BE2-4F0A-B2F5-38FB0B2D2DB5}.dwStartupOpt=;={7DFBC4AB-9BE2-4F0A-B2F5-38FB0B2D2DB5}.Release|x64.fBatchBld=;;{7DFBC4AB-9BE2-4F0A-B2F5-38FB0B2D2DB5}.Debug|x64.fBatchBld=;?{7DFBC4AB-9BE2-4F0A-B2F5-38FB0B2D2DB5}.Release|Win32.fBatchBld=;={7DFBC4AB-9BE2-4F0A-B2F5-38FB0B2D2DB5}.Debug|Win32.fBatchBld=;4{9FDDFF38-0A83-40D3-B492-02846102F8F8}.dwStartupOpt=;={9FDDFF38-0A83-40D3-B492-02846102F8F8}.Release|x64.fBatchBld=;;{9FDDFF38-0A83-40D3-B492-02846102F8F8}.Debug|x64.fBatchBld=;?{9FDDFF38-0A83-40D3-B492-02846102F8F8}.Release|Win32.fBatchBld=;={9FDDFF38-0A83-40D3-B492-02846102F8F8}.Debug|Win32.fBatchBld=;4{9A0FA918-A2DF-4C5E-80EB-583173AC1341}.dwStartupOpt=;={9A0FA918-A2DF-4C5E-80EB-583173AC1341}.Release|x64.fBatchBld=;;{9A0FA918-A2DF-4C5E-80EB-583173AC1341}.Debug|x64.fBatchBld=;?{9A0FA918-A2DF-4C5E-80EB-583173AC1341}.Release|Win32.fBatchBld=;={9A0FA918-A2DF-4C5E-80EB-583173AC1341}.Debug|Win32.fBatchBld=;4{D885564A-E7CA-4493-A9BB-B451049CFA73}.dwStartupOpt=;={D885564A-E7CA-4493-A9BB-B451049CFA73}.Release|x64.fBatchBld=;;{D885564A-E7CA-4493-A9BB-B451049CFA73}.Debug|x64.fBatchBld=;?{D885564A-E7CA-4493-A9BB-B451049CFA73}.Release|Win32.fBatchBld=;={D885564A-E7CA-4493-A9BB-B451049CFA73}.Debug|Win32.fBatchBld=;4{A4B8BD41-C07F-4913-82A4-D24D6DD73377}.dwStartupOpt=;={A4B8BD41-C07F-4913-82A4-D24D6DD73377}.Release|x64.fBatchBld=;;{A4B8BD41-C07F-4913-82A4-D24D6DD73377}.Debug|x64.fBatchBld=;?{A4B8BD41-C07F-4913-82A4-D24D6DD73377}.Release|Win32.fBatchBld=;={A4B8BD41-C07F-4913-82A4-D24D6DD73377}.Debug|Win32.fBatchBld=;4{330F7738-C84C-4DEE-AA13-1324A7118F29}.dwStartupOpt=;={330F7738-C84C-4DEE-AA13-1324A7118F29}.Release|x64.fBatchBld=;;{330F7738-C84C-4DEE-AA13-1324A7118F29}.Debug|x64.fBatchBld=;?{330F7738-C84C-4DEE-AA13-1324A7118F29}.Release|Win32.fBatchBld=;={330F7738-C84C-4DEE-AA13-1324A7118F29}.Debug|Win32.fBatchBld=;4{1B9F8C94-3D66-4734-BBDA-43B1A1360BA9}.dwStartupOpt=;={1B9F8C94-3D66-4734-BBDA-43B1A1360BA9}.Release|x64.fBatchBld=;;{1B9F8C94-3D66-4734-BBDA-43B1A1360BA9}.Debug|x64.fBatchBld=;?{1B9F8C94-3D66-4734-BBDA-43B1A1360BA9}.Release|Win32.fBatchBld=;={1B9F8C94-3D66-4734-BBDA-43B1A1360BA9}.Debug|Win32.fBatchBld=;4{B313A86A-CFE8-4E56-A7FA-AD1B962EC96B}.dwStartupOpt=;={B313A86A-CFE8-4E56-A7FA-AD1B962EC96B}.Release|x64.fBatchBld=;;{B313A86A-CFE8-4E56-A7FA-AD1B962EC96B}.Debug|x64.fBatchBld=;?{B313A86A-CFE8-4E56-A7FA-AD1B962EC96B}.Release|Win32.fBatchBld=;={B313A86A-CFE8-4E56-A7FA-AD1B962EC96B}.Debug|Win32.fBatchBld=;4{0CE3F5B5-CC35-4DF3-8457-489C843A7843}.dwStartupOpt=;={0CE3F5B5-CC35-4DF3-8457-489C843A7843}.Release|x64.fBatchBld=;;{0CE3F5B5-CC35-4DF3-8457-489C843A7843}.Debug|x64.fBatchBld=;?{0CE3F5B5-CC35-4DF3-8457-489C843A7843}.Release|Win32.fBatchBld=;={0CE3F5B5-CC35-4DF3-8457-489C843A7843}.Debug|Win32.fBatchBld=;4{20050A94-78F8-4783-B66A-88905E32CA7E}.dwStartupOpt=;={20050A94-78F8-4783-B66A-88905E32CA7E}.Release|x64.fBatchBld=;;{20050A94-78F8-4783-B66A-88905E32CA7E}.Debug|x64.fBatchBld=;?{20050A94-78F8-4783-B66A-88905E32CA7E}.Release|Win32.fBatchBld=;={20050A94-78F8-4783-B66A-88905E32CA7E}.Debug|Win32.fBatchBld=;4{F79CF60D-6FC3-4A24-935C-D09665B13400}.dwStartupOpt=;={F79CF60D-6FC3-4A24-935C-D09665B13400}.Release|x64.fBatchBld=;;{F79CF60D-6FC3-4A24-935C-D09665B13400}.Debug|x64.fBatchBld=;?{F79CF60D-6FC3-4A24-935C-D09665B13400}.Release|Win32.fBatchBld=;={F79CF60D-6FC3-4A24-935C-D09665B13400}.Debug|Win32.fBatchBld=;4{E78109FE-AFFD-47B5-B077-7405F12EBF4B}.dwStartupOpt=;={E78109FE-AFFD-47B5-B077-7405F12EBF4B}.Release|x64.fBatchBld=;;{E78109FE-AFFD-47B5-B077-7405F12EBF4B}.Debug|x64.fBatchBld=;?{E78109FE-AFFD-47B5-B077-7405F12EBF4B}.Release|Win32.fBatchBld=;={E78109FE-AFFD-47B5-B077-7405F12EBF4B}.Debug|Win32.fBatchBld=;4{40EAB710-54A7-4C3B-B264-12BF4AD0C752}.dwStartupOpt=;={40EAB710-54A7-4C3B-B264-12BF4AD0C752}.Release|x64.fBatchBld=;;{40EAB710-54A7-4C3B-B264-12BF4AD0C752}.Debug|x64.fBatchBld=;?{40EAB710-54A7-4C3B-B264-12BF4AD0C752}.Release|Win32.fBatchBld=;={40EAB710-54A7-4C3B-B264-12BF4AD0C752}.Debug|Win32.fBatchBld=;4{46D51B2B-C319-4858-ADF0-476074188070}.dwStartupOpt=;={46D51B2B-C319-4858-ADF0-476074188070}.Release|x64.fBatchBld=;;{46D51B2B-C319-4858-ADF0-476074188070}.Debug|x64.fBatchBld=;?{46D51B2B-C319-4858-ADF0-476074188070}.Release|Win32.fBatchBld=;={46D51B2B-C319-4858-ADF0-476074188070}.Debug|Win32.fBatchBld=;4{BB201B0D-07F7-42AA-B16C-D8BD0F19CC98}.dwStartupOpt=;={BB201B0D-07F7-42AA-B16C-D8BD0F19CC98}.Release|x64.fBatchBld=;;{BB201B0D-07F7-42AA-B16C-D8BD0F19CC98}.Debug|x64.fBatchBld=;?{BB201B0D-07F7-42AA-B16C-D8BD0F19CC98}.Release|Win32.fBatchBld=;={BB201B0D-07F7-42AA-B16C-D8BD0F19CC98}.Debug|Win32.fBatchBld=;4{AA40EBEE-F2EC-4DFA-A1C9-D58734BCBEA8}.dwStartupOpt=;={AA40EBEE-F2EC-4DFA-A1C9-D58734BCBEA8}.Release|x64.fBatchBld=;;{AA40EBEE-F2EC-4DFA-A1C9-D58734BCBEA8}.Debug|x64.fBatchBld=;?{AA40EBEE-F2EC-4DFA-A1C9-D58734BCBEA8}.Release|Win32.fBatchBld=;={AA40EBEE-F2EC-4DFA-A1C9-D58734BCBEA8}.Debug|Win32.fBatchBld=;4{26B8A115-120B-4D62-B593-3FD7FD4CA75E}.dwStartupOpt=;={26B8A115-120B-4D62-B593-3FD7FD4CA75E}.Release|x64.fBatchBld=;;{26B8A115-120B-4D62-B593-3FD7FD4CA75E}.Debug|x64.fBatchBld=;?{26B8A115-120B-4D62-B593-3FD7FD4CA75E}.Release|Win32.fBatchBld=;={26B8A115-120B-4D62-B593-3FD7FD4CA75E}.Debug|Win32.fBatchBld=;4{D0AB4F75-48A7-4673-AA53-9134DFBD2956}.dwStartupOpt=;={D0AB4F75-48A7-4673-AA53-9134DFBD2956}.Release|x64.fBatchBld=;;{D0AB4F75-48A7-4673-AA53-9134DFBD2956}.Debug|x64.fBatchBld=;?{D0AB4F75-48A7-4673-AA53-9134DFBD2956}.Release|Win32.fBatchBld=;={D0AB4F75-48A7-4673-AA53-9134DFBD2956}.Debug|Win32.fBatchBld=;4{2EB4F888-8048-4283-AAF9-B9419774F7A1}.dwStartupOpt=;={2EB4F888-8048-4283-AAF9-B9419774F7A1}.Release|x64.fBatchBld=;;{2EB4F888-8048-4283-AAF9-B9419774F7A1}.Debug|x64.fBatchBld=;?{2EB4F888-8048-4283-AAF9-B9419774F7A1}.Release|Win32.fBatchBld=;={2EB4F888-8048-4283-AAF9-B9419774F7A1}.Debug|Win32.fBatchBld=;4{F7350B52-3C26-4F8D-87F5-46461CF9AA21}.dwStartupOpt=;={F7350B52-3C26-4F8D-87F5-46461CF9AA21}.Release|x64.fBatchBld=;;{F7350B52-3C26-4F8D-87F5-46461CF9AA21}.Debug|x64.fBatchBld=;?{F7350B52-3C26-4F8D-87F5-46461CF9AA21}.Release|Win32.fBatchBld=;={F7350B52-3C26-4F8D-87F5-46461CF9AA21}.Debug|Win32.fBatchBld=;4{93A2A9CB-18E3-4EF0-8186-A5C1C49271F9}.dwStartupOpt=;={93A2A9CB-18E3-4EF0-8186-A5C1C49271F9}.Release|x64.fBatchBld=;;{93A2A9CB-18E3-4EF0-8186-A5C1C49271F9}.Debug|x64.fBatchBld=;?{93A2A9CB-18E3-4EF0-8186-A5C1C49271F9}.Release|Win32.fBatchBld=;={93A2A9CB-18E3-4EF0-8186-A5C1C49271F9}.Debug|Win32.fBatchBld=;4{AC29CE01-373A-4DAF-94A8-51477B18242B}.dwStartupOpt=;={AC29CE01-373A-4DAF-94A8-51477B18242B}.Release|x64.fBatchBld=;;{AC29CE01-373A-4DAF-94A8-51477B18242B}.Debug|x64.fBatchBld=;?{AC29CE01-373A-4DAF-94A8-51477B18242B}.Release|Win32.fBatchBld=;={AC29CE01-373A-4DAF-94A8-51477B18242B}.Debug|Win32.fBatchBld=;4{898194CA-8687-478A-AF8C-AD6D02280B8E}.dwStartupOpt=;={898194CA-8687-478A-AF8C-AD6D02280B8E}.Release|x64.fBatchBld=;;{898194CA-8687-478A-AF8C-AD6D02280B8E}.Debug|x64.fBatchBld=;?{898194CA-8687-478A-AF8C-AD6D02280B8E}.Release|Win32.fBatchBld=;={898194CA-8687-478A-AF8C-AD6D02280B8E}.Debug|Win32.fBatchBld=;4{23CBED72-0007-4671-BDCC-817403C2FDAB}.dwStartupOpt=;={23CBED72-0007-4671-BDCC-817403C2FDAB}.Release|x64.fBatchBld=;;{23CBED72-0007-4671-BDCC-817403C2FDAB}.Debug|x64.fBatchBld=;?{23CBED72-0007-4671-BDCC-817403C2FDAB}.Release|Win32.fBatchBld=;={23CBED72-0007-4671-BDCC-817403C2FDAB}.Debug|Win32.fBatchBld=;4{B134B8F2-AE55-4046-902A-D282147C992F}.dwStartupOpt=;={B134B8F2-AE55-4046-902A-D282147C992F}.Release|x64.fBatchBld=;;{B134B8F2-AE55-4046-902A-D282147C992F}.Debug|x64.fBatchBld=;?{B134B8F2-AE55-4046-902A-D282147C992F}.Release|Win32.fBatchBld=;={B134B8F2-AE55-4046-902A-D282147C992F}.Debug|Win32.fBatchBld=;4{D5F1FFDA-34DF-4A89-9767-924D39D35CCC}.dwStartupOpt=;={D5F1FFDA-34DF-4A89-9767-924D39D35CCC}.Release|x64.fBatchBld=;;{D5F1FFDA-34DF-4A89-9767-924D39D35CCC}.Debug|x64.fBatchBld=;?{D5F1FFDA-34DF-4A89-9767-924D39D35CCC}.Release|Win32.fBatchBld=;={D5F1FFDA-34DF-4A89-9767-924D39D35CCC}.Debug|Win32.fBatchBld=;4{1862DC50-4B23-4941-A190-C4838C0A49AE}.dwStartupOpt=;={1862DC50-4B23-4941-A190-C4838C0A49AE}.Release|x64.fBatchBld=;;{1862DC50-4B23-4941-A190-C4838C0A49AE}.Debug|x64.fBatchBld=;?{1862DC50-4B23-4941-A190-C4838C0A49AE}.Release|Win32.fBatchBld=;={1862DC50-4B23-4941-A190-C4838C0A49AE}.Debug|Win32.fBatchBld=;4{6CDD5B46-39A7-49FD-B8C6-476C4958CAAF}.dwStartupOpt=;={6CDD5B46-39A7-49FD-B8C6-476C4958CAAF}.Release|x64.fBatchBld=;;{6CDD5B46-39A7-49FD-B8C6-476C4958CAAF}.Debug|x64.fBatchBld=;?{6CDD5B46-39A7-49FD-B8C6-476C4958CAAF}.Release|Win32.fBatchBld=;={6CDD5B46-39A7-49FD-B8C6-476C4958CAAF}.Debug|Win32.fBatchBld=;4{8B1D4E3F-1125-4BDA-B81E-20E022C03538}.dwStartupOpt=;={8B1D4E3F-1125-4BDA-B81E-20E022C03538}.Release|x64.fBatchBld=;;{8B1D4E3F-1125-4BDA-B81E-20E022C03538}.Debug|x64.fBatchBld=;?{8B1D4E3F-1125-4BDA-B81E-20E022C03538}.Release|Win32.fBatchBld=;={8B1D4E3F-1125-4BDA-B81E-20E022C03538}.Debug|Win32.fBatchBld=;4{05F1AFCD-A715-46A2-AEAB-89BC60FFCF2C}.dwStartupOpt=;={05F1AFCD-A715-46A2-AEAB-89BC60FFCF2C}.Release|x64.fBatchBld=;;{05F1AFCD-A715-46A2-AEAB-89BC60FFCF2C}.Debug|x64.fBatchBld=;?{05F1AFCD-A715-46A2-AEAB-89BC60FFCF2C}.Release|Win32.fBatchBld=;={05F1AFCD-A715-46A2-AEAB-89BC60FFCF2C}.Debug|Win32.fBatchBld=;4{88385AFF-169F-4B40-98A3-CA0B59BB9451}.dwStartupOpt=;={88385AFF-169F-4B40-98A3-CA0B59BB9451}.Release|x64.fBatchBld=;;{88385AFF-169F-4B40-98A3-CA0B59BB9451}.Debug|x64.fBatchBld=;?{88385AFF-169F-4B40-98A3-CA0B59BB9451}.Release|Win32.fBatchBld=;={88385AFF-169F-4B40-98A3-CA0B59BB9451}.Debug|Win32.fBatchBld=;4{EC4EF28D-919C-4B13-89BC-29D063D408A0}.dwStartupOpt=;={EC4EF28D-919C-4B13-89BC-29D063D408A0}.Release|x64.fBatchBld=;;{EC4EF28D-919C-4B13-89BC-29D063D408A0}.Debug|x64.fBatchBld=;?{EC4EF28D-919C-4B13-89BC-29D063D408A0}.Release|Win32.fBatchBld=;={EC4EF28D-919C-4B13-89BC-29D063D408A0}.Debug|Win32.fBatchBld=;4{205C829A-29D9-46AC-BC71-BE513794ECBE}.dwStartupOpt=;={205C829A-29D9-46AC-BC71-BE513794ECBE}.Release|x64.fBatchBld=;;{205C829A-29D9-46AC-BC71-BE513794ECBE}.Debug|x64.fBatchBld=;?{205C829A-29D9-46AC-BC71-BE513794ECBE}.Release|Win32.fBatchBld=;={205C829A-29D9-46AC-BC71-BE513794ECBE}.Debug|Win32.fBatchBld=;4{A5B79959-9B49-4021-90F4-EE776D9863AC}.dwStartupOpt=;={A5B79959-9B49-4021-90F4-EE776D9863AC}.Release|x64.fBatchBld=;;{A5B79959-9B49-4021-90F4-EE776D9863AC}.Debug|x64.fBatchBld=;?{A5B79959-9B49-4021-90F4-EE776D9863AC}.Release|Win32.fBatchBld=;={A5B79959-9B49-4021-90F4-EE776D9863AC}.Debug|Win32.fBatchBld=;4{8C67CBCA-C127-49FE-8CF4-DA38B66B5186}.dwStartupOpt=;={8C67CBCA-C127-49FE-8CF4-DA38B66B5186}.Release|x64.fBatchBld=;;{8C67CBCA-C127-49FE-8CF4-DA38B66B5186}.Debug|x64.fBatchBld=;?{8C67CBCA-C127-49FE-8CF4-DA38B66B5186}.Release|Win32.fBatchBld=;={8C67CBCA-C127-49FE-8CF4-DA38B66B5186}.Debug|Win32.fBatchBld=;4{94A2A4AC-186D-4403-BB02-A81077F4717B}.dwStartupOpt=;={94A2A4AC-186D-4403-BB02-A81077F4717B}.Release|x64.fBatchBld=;;{94A2A4AC-186D-4403-BB02-A81077F4717B}.Debug|x64.fBatchBld=;?{94A2A4AC-186D-4403-BB02-A81077F4717B}.Release|Win32.fBatchBld=;={94A2A4AC-186D-4403-BB02-A81077F4717B}.Debug|Win32.fBatchBld=;4{F2B48C2D-B7A6-4AF7-A1B6-95023F7185E2}.dwStartupOpt=;={F2B48C2D-B7A6-4AF7-A1B6-95023F7185E2}.Release|x64.fBatchBld=;;{F2B48C2D-B7A6-4AF7-A1B6-95023F7185E2}.Debug|x64.fBatchBld=;?{F2B48C2D-B7A6-4AF7-A1B6-95023F7185E2}.Release|Win32.fBatchBld=;={F2B48C2D-B7A6-4AF7-A1B6-95023F7185E2}.Debug|Win32.fBatchBld=;4{5A0DC446-207D-4A16-BBE1-2F6FBBE5FA32}.dwStartupOpt=;={5A0DC446-207D-4A16-BBE1-2F6FBBE5FA32}.Release|x64.fBatchBld=;;{5A0DC446-207D-4A16-BBE1-2F6FBBE5FA32}.Debug|x64.fBatchBld=;?{5A0DC446-207D-4A16-BBE1-2F6FBBE5FA32}.Release|Win32.fBatchBld=;={5A0DC446-207D-4A16-BBE1-2F6FBBE5FA32}.Debug|Win32.fBatchBld=;4{808F86D0-5256-4673-8623-669BDF077406}.dwStartupOpt=;={808F86D0-5256-4673-8623-669BDF077406}.Release|x64.fBatchBld=;;{808F86D0-5256-4673-8623-669BDF077406}.Debug|x64.fBatchBld=;?{808F86D0-5256-4673-8623-669BDF077406}.Release|Win32.fBatchBld=;={808F86D0-5256-4673-8623-669BDF077406}.Debug|Win32.fBatchBld=;4{57ED741A-DA02-48BF-B6B0-43230EEFF83D}.dwStartupOpt=;={57ED741A-DA02-48BF-B6B0-43230EEFF83D}.Release|x64.fBatchBld=;;{57ED741A-DA02-48BF-B6B0-43230EEFF83D}.Debug|x64.fBatchBld=;?{57ED741A-DA02-48BF-B6B0-43230EEFF83D}.Release|Win32.fBatchBld=;={57ED741A-DA02-48BF-B6B0-43230EEFF83D}.Debug|Win32.fBatchBld=;4{C320625B-D86E-46DD-B08B-AE4328BF3FDB}.dwStartupOpt=;={C320625B-D86E-46DD-B08B-AE4328BF3FDB}.Release|x64.fBatchBld=;;{C320625B-D86E-46DD-B08B-AE4328BF3FDB}.Debug|x64.fBatchBld=;?{C320625B-D86E-46DD-B08B-AE4328BF3FDB}.Release|Win32.fBatchBld=;={C320625B-D86E-46DD-B08B-AE4328BF3FDB}.Debug|Win32.fBatchBld=;4{DC53ACFA-DEEE-441C-AEE6-E96F1D6DB68B}.dwStartupOpt=;={DC53ACFA-DEEE-441C-AEE6-E96F1D6DB68B}.Release|x64.fBatchBld=;;{DC53ACFA-DEEE-441C-AEE6-E96F1D6DB68B}.Debug|x64.fBatchBld=;?{DC53ACFA-DEEE-441C-AEE6-E96F1D6DB68B}.Release|Win32.fBatchBld=;={DC53ACFA-DEEE-441C-AEE6-E96F1D6DB68B}.Debug|Win32.fBatchBld=;4{6DDED97E-BEBC-447B-A102-4B14CCD62C9F}.dwStartupOpt=;={6DDED97E-BEBC-447B-A102-4B14CCD62C9F}.Release|x64.fBatchBld=;;{6DDED97E-BEBC-447B-A102-4B14CCD62C9F}.Debug|x64.fBatchBld=;?{6DDED97E-BEBC-447B-A102-4B14CCD62C9F}.Release|Win32.fBatchBld=;={6DDED97E-BEBC-447B-A102-4B14CCD62C9F}.Debug|Win32.fBatchBld=;4{72DC8986-697E-4EA1-B2A1-86453C2E6BFD}.dwStartupOpt=;={72DC8986-697E-4EA1-B2A1-86453C2E6BFD}.Release|x64.fBatchBld=;;{72DC8986-697E-4EA1-B2A1-86453C2E6BFD}.Debug|x64.fBatchBld=;?{72DC8986-697E-4EA1-B2A1-86453C2E6BFD}.Release|Win32.fBatchBld=;={72DC8986-697E-4EA1-B2A1-86453C2E6BFD}.Debug|Win32.fBatchBld=;4{C5FB18BB-0572-407A-8FE7-F919A59D2ADC}.dwStartupOpt=;={C5FB18BB-0572-407A-8FE7-F919A59D2ADC}.Release|x64.fBatchBld=;;{C5FB18BB-0572-407A-8FE7-F919A59D2ADC}.Debug|x64.fBatchBld=;?{C5FB18BB-0572-407A-8FE7-F919A59D2ADC}.Release|Win32.fBatchBld=;={C5FB18BB-0572-407A-8FE7-F919A59D2ADC}.Debug|Win32.fBatchBld=;4{2800452A-552F-4330-95EB-AB394CAF463B}.dwStartupOpt=;={2800452A-552F-4330-95EB-AB394CAF463B}.Release|x64.fBatchBld=;;{2800452A-552F-4330-95EB-AB394CAF463B}.Debug|x64.fBatchBld=;?{2800452A-552F-4330-95EB-AB394CAF463B}.Release|Win32.fBatchBld=;={2800452A-552F-4330-95EB-AB394CAF463B}.Debug|Win32.fBatchBld=;4{4E5C40F6-9CC6-4242-A12E-6105D3C37988}.dwStartupOpt=;={4E5C40F6-9CC6-4242-A12E-6105D3C37988}.Release|x64.fBatchBld=;;{4E5C40F6-9CC6-4242-A12E-6105D3C37988}.Debug|x64.fBatchBld=;?{4E5C40F6-9CC6-4242-A12E-6105D3C37988}.Release|Win32.fBatchBld=;={4E5C40F6-9CC6-4242-A12E-6105D3C37988}.Debug|Win32.fBatchBld=;4{3FD72315-A289-40B6-B42D-A4CB88A4E63B}.dwStartupOpt=;={3FD72315-A289-40B6-B42D-A4CB88A4E63B}.Release|x64.fBatchBld=;;{3FD72315-A289-40B6-B42D-A4CB88A4E63B}.Debug|x64.fBatchBld=;?{3FD72315-A289-40B6-B42D-A4CB88A4E63B}.Release|Win32.fBatchBld=;={3FD72315-A289-40B6-B42D-A4CB88A4E63B}.Debug|Win32.fBatchBld=;4{7FB29BE2-6C9C-42DE-A73D-2D860785C1FA}.dwStartupOpt=;={7FB29BE2-6C9C-42DE-A73D-2D860785C1FA}.Release|x64.fBatchBld=;;{7FB29BE2-6C9C-42DE-A73D-2D860785C1FA}.Debug|x64.fBatchBld=;?{7FB29BE2-6C9C-42DE-A73D-2D860785C1FA}.Release|Win32.fBatchBld=;={7FB29BE2-6C9C-42DE-A73D-2D860785C1FA}.Debug|Win32.fBatchBld=;4{877FBBB2-F0F4-411E-9438-4576D1B08F94}.dwStartupOpt=;={877FBBB2-F0F4-411E-9438-4576D1B08F94}.Release|x64.fBatchBld=;;{877FBBB2-F0F4-411E-9438-4576D1B08F94}.Debug|x64.fBatchBld=;?{877FBBB2-F0F4-411E-9438-4576D1B08F94}.Release|Win32.fBatchBld=;={877FBBB2-F0F4-411E-9438-4576D1B08F94}.Debug|Win32.fBatchBld=;4{D7E69275-F85F-47E7-A1C0-5B1914BBE79F}.dwStartupOpt=;={D7E69275-F85F-47E7-A1C0-5B1914BBE79F}.Release|x64.fBatchBld=;;{D7E69275-F85F-47E7-A1C0-5B1914BBE79F}.Debug|x64.fBatchBld=;?{D7E69275-F85F-47E7-A1C0-5B1914BBE79F}.Release|Win32.fBatchBld=;={D7E69275-F85F-47E7-A1C0-5B1914BBE79F}.Debug|Win32.fBatchBld=;4{480E426C-C2AF-4C46-9AE6-6A93FA005C18}.dwStartupOpt=;={480E426C-C2AF-4C46-9AE6-6A93FA005C18}.Release|x64.fBatchBld=;;{480E426C-C2AF-4C46-9AE6-6A93FA005C18}.Debug|x64.fBatchBld=;?{480E426C-C2AF-4C46-9AE6-6A93FA005C18}.Release|Win32.fBatchBld=;={480E426C-C2AF-4C46-9AE6-6A93FA005C18}.Debug|Win32.fBatchBld=;4{04D5A0F5-82D8-4095-AC67-A691F9CEB768}.dwStartupOpt=;={04D5A0F5-82D8-4095-AC67-A691F9CEB768}.Release|x64.fBatchBld=;;{04D5A0F5-82D8-4095-AC67-A691F9CEB768}.Debug|x64.fBatchBld=;?{04D5A0F5-82D8-4095-AC67-A691F9CEB768}.Release|Win32.fBatchBld=;={04D5A0F5-82D8-4095-AC67-A691F9CEB768}.Debug|Win32.fBatchBld=;4{D5CA1B70-2D03-4794-B15A-E030ED92CB64}.dwStartupOpt=;={D5CA1B70-2D03-4794-B15A-E030ED92CB64}.Release|x64.fBatchBld=;;{D5CA1B70-2D03-4794-B15A-E030ED92CB64}.Debug|x64.fBatchBld=;?{D5CA1B70-2D03-4794-B15A-E030ED92CB64}.Release|Win32.fBatchBld=;={D5CA1B70-2D03-4794-B15A-E030ED92CB64}.Debug|Win32.fBatchBld=;4{8B162257-3A6F-401C-905A-5A616B8945F2}.dwStartupOpt=;={8B162257-3A6F-401C-905A-5A616B8945F2}.Release|x64.fBatchBld=;;{8B162257-3A6F-401C-905A-5A616B8945F2}.Debug|x64.fBatchBld=;?{8B162257-3A6F-401C-905A-5A616B8945F2}.Release|Win32.fBatchBld=;={8B162257-3A6F-401C-905A-5A616B8945F2}.Debug|Win32.fBatchBld=;4{71102476-03D2-401E-B6F6-301E984CB7DD}.dwStartupOpt=;={71102476-03D2-401E-B6F6-301E984CB7DD}.Release|x64.fBatchBld=;;{71102476-03D2-401E-B6F6-301E984CB7DD}.Debug|x64.fBatchBld=;?{71102476-03D2-401E-B6F6-301E984CB7DD}.Release|Win32.fBatchBld=;={71102476-03D2-401E-B6F6-301E984CB7DD}.Debug|Win32.fBatchBld=;4{7C625DDB-7776-4752-8B52-29E2983A4E95}.dwStartupOpt=;={7C625DDB-7776-4752-8B52-29E2983A4E95}.Release|x64.fBatchBld=;;{7C625DDB-7776-4752-8B52-29E2983A4E95}.Debug|x64.fBatchBld=;?{7C625DDB-7776-4752-8B52-29E2983A4E95}.Release|Win32.fBatchBld=;={7C625DDB-7776-4752-8B52-29E2983A4E95}.Debug|Win32.fBatchBld=;4{19C4F045-3877-4320-9200-B97EC40996E2}.dwStartupOpt=;={19C4F045-3877-4320-9200-B97EC40996E2}.Release|x64.fBatchBld=;;{19C4F045-3877-4320-9200-B97EC40996E2}.Debug|x64.fBatchBld=;?{19C4F045-3877-4320-9200-B97EC40996E2}.Release|Win32.fBatchBld=;={19C4F045-3877-4320-9200-B97EC40996E2}.Debug|Win32.fBatchBld=;4{008BCDED-1DD5-4B9D-B6B3-461B9BFE41A5}.dwStartupOpt=;={008BCDED-1DD5-4B9D-B6B3-461B9BFE41A5}.Release|x64.fBatchBld=;;{008BCDED-1DD5-4B9D-B6B3-461B9BFE41A5}.Debug|x64.fBatchBld=;?{008BCDED-1DD5-4B9D-B6B3-461B9BFE41A5}.Release|Win32.fBatchBld=;={008BCDED-1DD5-4B9D-B6B3-461B9BFE41A5}.Debug|Win32.fBatchBld=;4{7681DE2C-1FE2-4B7B-98CD-9D25C4107340}.dwStartupOpt=;={7681DE2C-1FE2-4B7B-98CD-9D25C4107340}.Release|x64.fBatchBld=;;{7681DE2C-1FE2-4B7B-98CD-9D25C4107340}.Debug|x64.fBatchBld=;?{7681DE2C-1FE2-4B7B-98CD-9D25C4107340}.Release|Win32.fBatchBld=;={7681DE2C-1FE2-4B7B-98CD-9D25C4107340}.Debug|Win32.fBatchBld=;4{042E07FE-5174-4FB9-9469-516E20F53FE5}.dwStartupOpt=;={042E07FE-5174-4FB9-9469-516E20F53FE5}.Release|x64.fBatchBld=;;{042E07FE-5174-4FB9-9469-516E20F53FE5}.Debug|x64.fBatchBld=;?{042E07FE-5174-4FB9-9469-516E20F53FE5}.Release|Win32.fBatchBld=;={042E07FE-5174-4FB9-9469-516E20F53FE5}.Debug|Win32.fBatchBld=;4{E6671DBC-D0C3-4493-89CA-B6EBF8B60AB9}.dwStartupOpt=;={E6671DBC-D0C3-4493-89CA-B6EBF8B60AB9}.Release|x64.fBatchBld=;;{E6671DBC-D0C3-4493-89CA-B6EBF8B60AB9}.Debug|x64.fBatchBld=;?{E6671DBC-D0C3-4493-89CA-B6EBF8B60AB9}.Release|Win32.fBatchBld=;={E6671DBC-D0C3-4493-89CA-B6EBF8B60AB9}.Debug|Win32.fBatchBld=;4{3E1AE893-E6E6-4E09-807A-148360C538AF}.dwStartupOpt=;={3E1AE893-E6E6-4E09-807A-148360C538AF}.Release|x64.fBatchBld=;;{3E1AE893-E6E6-4E09-807A-148360C538AF}.Debug|x64.fBatchBld=;?{3E1AE893-E6E6-4E09-807A-148360C538AF}.Release|Win32.fBatchBld=;={3E1AE893-E6E6-4E09-807A-148360C538AF}.Debug|Win32.fBatchBld=;4{4BBD77B6-48C2-4551-A874-327A414C3A35}.dwStartupOpt=;={4BBD77B6-48C2-4551-A874-327A414C3A35}.Release|x64.fBatchBld=;;{4BBD77B6-48C2-4551-A874-327A414C3A35}.Debug|x64.fBatchBld=;?{4BBD77B6-48C2-4551-A874-327A414C3A35}.Release|Win32.fBatchBld=;={4BBD77B6-48C2-4551-A874-327A414C3A35}.Debug|Win32.fBatchBld=;4{E2D74770-F7DB-4807-A12F-2363F1F08CCE}.dwStartupOpt=;4{5E8E3F00-79A9-4635-AE04-452B7D5497F6}.dwStartupOpt=;={5E8E3F00-79A9-4635-AE04-452B7D5497F6}.Release|x64.fBatchBld=;;{5E8E3F00-79A9-4635-AE04-452B7D5497F6}.Debug|x64.fBatchBld=;?{5E8E3F00-79A9-4635-AE04-452B7D5497F6}.Release|Win32.fBatchBld=;={5E8E3F00-79A9-4635-AE04-452B7D5497F6}.Debug|Win32.fBatchBld=;4{6A036179-4726-40C2-89C9-2E18D4030E28}.dwStartupOpt=;={6A036179-4726-40C2-89C9-2E18D4030E28}.Release|x64.fBatchBld=;;{6A036179-4726-40C2-89C9-2E18D4030E28}.Debug|x64.fBatchBld=;?{6A036179-4726-40C2-89C9-2E18D4030E28}.Release|Win32.fBatchBld=;={6A036179-4726-40C2-89C9-2E18D4030E28}.Debug|Win32.fBatchBld=;4{50EFC9E8-FB88-44C3-9F30-075547E22992}.dwStartupOpt=;={50EFC9E8-FB88-44C3-9F30-075547E22992}.Release|x64.fBatchBld=;;{50EFC9E8-FB88-44C3-9F30-075547E22992}.Debug|x64.fBatchBld=;?{50EFC9E8-FB88-44C3-9F30-075547E22992}.Release|Win32.fBatchBld=;={50EFC9E8-FB88-44C3-9F30-075547E22992}.Debug|Win32.fBatchBld=;4{5495242E-29D4-4C4E-9176-4A69F8CBD667}.dwStartupOpt=;={5495242E-29D4-4C4E-9176-4A69F8CBD667}.Release|x64.fBatchBld=;;{5495242E-29D4-4C4E-9176-4A69F8CBD667}.Debug|x64.fBatchBld=;?{5495242E-29D4-4C4E-9176-4A69F8CBD667}.Release|Win32.fBatchBld=;={5495242E-29D4-4C4E-9176-4A69F8CBD667}.Debug|Win32.fBatchBld=;4{8E9450F9-5523-4164-A1C9-F04103F2AA92}.dwStartupOpt=;={8E9450F9-5523-4164-A1C9-F04103F2AA92}.Release|x64.fBatchBld=;;{8E9450F9-5523-4164-A1C9-F04103F2AA92}.Debug|x64.fBatchBld=;?{8E9450F9-5523-4164-A1C9-F04103F2AA92}.Release|Win32.fBatchBld=;={8E9450F9-5523-4164-A1C9-F04103F2AA92}.Debug|Win32.fBatchBld=;4{080D15EE-2C04-44A1-94DE-B70917E64E85}.dwStartupOpt=;={080D15EE-2C04-44A1-94DE-B70917E64E85}.Release|x64.fBatchBld=;;{080D15EE-2C04-44A1-94DE-B70917E64E85}.Debug|x64.fBatchBld=;?{080D15EE-2C04-44A1-94DE-B70917E64E85}.Release|Win32.fBatchBld=;={080D15EE-2C04-44A1-94DE-B70917E64E85}.Debug|Win32.fBatchBld=;4{D9399AF5-90FC-4010-ABFC-408314AB04A9}.dwStartupOpt=;={D9399AF5-90FC-4010-ABFC-408314AB04A9}.Release|x64.fBatchBld=;;{D9399AF5-90FC-4010-ABFC-408314AB04A9}.Debug|x64.fBatchBld=;?{D9399AF5-90FC-4010-ABFC-408314AB04A9}.Release|Win32.fBatchBld=;={D9399AF5-90FC-4010-ABFC-408314AB04A9}.Debug|Win32.fBatchBld=;4{2961C03E-0B57-483D-A4A6-622D07337E5B}.dwStartupOpt=;={2961C03E-0B57-483D-A4A6-622D07337E5B}.Release|x64.fBatchBld=;;{2961C03E§џџџ‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ЁЂЃЄЅІЇЈЉЊЋЌ­ЎЏАБВГўџџџчЖЗИЙКЛМЦОПРСТУФХЕЧШЩЪЫЬЭЮЯабвгдежзийклмнопрстуфхцўџџџўџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ-0B57-483D-A4A6-622D07337E5B}.Debug|x64.fBatchBld=;?{2961C03E-0B57-483D-A4A6-622D07337E5B}.Release|Win32.fBatchBld=;={2961C03E-0B57-483D-A4A6-622D07337E5B}.Debug|Win32.fBatchBld=;4{7FB77E83-219A-42D6-98D0-66C13F38A221}.dwStartupOpt=;={7FB77E83-219A-42D6-98D0-66C13F38A221}.Release|x64.fBatchBld=;;{7FB77E83-219A-42D6-98D0-66C13F38A221}.Debug|x64.fBatchBld=;?{7FB77E83-219A-42D6-98D0-66C13F38A221}.Release|Win32.fBatchBld=;={7FB77E83-219A-42D6-98D0-66C13F38A221}.Debug|Win32.fBatchBld=;4{8FC64DB6-5DCC-446C-8FEC-DA8D76756523}.dwStartupOpt=;={8FC64DB6-5DCC-446C-8FEC-DA8D76756523}.Release|x64.fBatchBld=;;{8FC64DB6-5DCC-446C-8FEC-DA8D76756523}.Debug|x64.fBatchBld=;?{8FC64DB6-5DCC-446C-8FEC-DA8D76756523}.Release|Win32.fBatchBld=;={8FC64DB6-5DCC-446C-8FEC-DA8D76756523}.Debug|Win32.fBatchBld=;4{378F2D05-7A71-4AC3-A045-C8416D965C94}.dwStartupOpt=;={378F2D05-7A71-4AC3-A045-C8416D965C94}.Release|x64.fBatchBld=;;{378F2D05-7A71-4AC3-A045-C8416D965C94}.Debug|x64.fBatchBld=;?{378F2D05-7A71-4AC3-A045-C8416D965C94}.Release|Win32.fBatchBld=;={378F2D05-7A71-4AC3-A045-C8416D965C94}.Debug|Win32.fBatchBld=;4{AAB83BC2-6410-4114-AE0D-BFF15C9FF59B}.dwStartupOpt=;4{551E7C9B-9844-415F-8D65-DAEA5DFF3279}.dwStartupOpt=;={551E7C9B-9844-415F-8D65-DAEA5DFF3279}.Release|x64.fBatchBld=;;{551E7C9B-9844-415F-8D65-DAEA5DFF3279}.Debug|x64.fBatchBld=;?{551E7C9B-9844-415F-8D65-DAEA5DFF3279}.Release|Win32.fBatchBld=;={551E7C9B-9844-415F-8D65-DAEA5DFF3279}.Debug|Win32.fBatchBld=;4{9D169447-3B5B-41DA-96C2-EB40DE0A96D7}.dwStartupOpt=;={9D169447-3B5B-41DA-96C2-EB40DE0A96D7}.Release|x64.fBatchBld=;;{9D169447-3B5B-41DA-96C2-EB40DE0A96D7}.Debug|x64.fBatchBld=;?{9D169447-3B5B-41DA-96C2-EB40DE0A96D7}.Release|Win32.fBatchBld=;={9D169447-3B5B-41DA-96C2-EB40DE0A96D7}.Debug|Win32.fBatchBld=;4{7CC8AB03-9D9F-4001-B99A-AA8D24487043}.dwStartupOpt=;={7CC8AB03-9D9F-4001-B99A-AA8D24487043}.Release|x64.fBatchBld=;;{7CC8AB03-9D9F-4001-B99A-AA8D24487043}.Debug|x64.fBatchBld=;?{7CC8AB03-9D9F-4001-B99A-AA8D24487043}.Release|Win32.fBatchBld=;={7CC8AB03-9D9F-4001-B99A-AA8D24487043}.Debug|Win32.fBatchBld=;4{55883549-B725-41B7-900D-28EDC4757B76}.dwStartupOpt=;={55883549-B725-41B7-900D-28EDC4757B76}.Release|x64.fBatchBld=;;{55883549-B725-41B7-900D-28EDC4757B76}.Debug|x64.fBatchBld=;?{55883549-B725-41B7-900D-28EDC4757B76}.Release|Win32.fBatchBld=;={55883549-B725-41B7-900D-28EDC4757B76}.Debug|Win32.fBatchBld=;4{AE7429E9-F7AD-4B49-9E6E-8615003DD8AF}.dwStartupOpt=;={AE7429E9-F7AD-4B49-9E6E-8615003DD8AF}.Release|x64.fBatchBld=;;{AE7429E9-F7AD-4B49-9E6E-8615003DD8AF}.Debug|x64.fBatchBld=;?{AE7429E9-F7AD-4B49-9E6E-8615003DD8AF}.Release|Win32.fBatchBld=;={AE7429E9-F7AD-4B49-9E6E-8615003DD8AF}.Debug|Win32.fBatchBld=;4{8D10D126-A641-40DC-B8FC-1407F3FAFA55}.dwStartupOpt=;={8D10D126-A641-40DC-B8FC-1407F3FAFA55}.Release|x64.fBatchBld=;;{8D10D126-A641-40DC-B8FC-1407F3FAFA55}.Debug|x64.fBatchBld=;?{8D10D126-A641-40DC-B8FC-1407F3FAFA55}.Release|Win32.fBatchBld=;={8D10D126-A641-40DC-B8FC-1407F3FAFA55}.Debug|Win32.fBatchBld=;4{C2B287D4-B0F5-473A-88ED-E79F0C2956B8}.dwStartupOpt=;4{7B2432C6-051D-4667-94E4-0521B4B3821D}.dwStartupOpt=;={7B2432C6-051D-4667-94E4-0521B4B3821D}.Release|x64.fBatchBld=;;{7B2432C6-051D-4667-94E4-0521B4B3821D}.Debug|x64.fBatchBld=;?{7B2432C6-051D-4667-94E4-0521B4B3821D}.Release|Win32.fBatchBld=;={7B2432C6-051D-4667-94E4-0521B4B3821D}.Debug|Win32.fBatchBld=;4{AEF3C73D-9952-45D6-949E-7CFE0D3BE892}.dwStartupOpt=;={AEF3C73D-9952-45D6-949E-7CFE0D3BE892}.Release|x64.fBatchBld=;;{AEF3C73D-9952-45D6-949E-7CFE0D3BE892}.Debug|x64.fBatchBld=;?{AEF3C73D-9952-45D6-949E-7CFE0D3BE892}.Release|Win32.fBatchBld=;={AEF3C73D-9952-45D6-949E-7CFE0D3BE892}.Debug|Win32.fBatchBld=;4{825A5F4A-CF89-4A29-B778-E035B442225A}.dwStartupOpt=;={825A5F4A-CF89-4A29-B778-E035B442225A}.Release|x64.fBatchBld=;;{825A5F4A-CF89-4A29-B778-E035B442225A}.Debug|x64.fBatchBld=;?{825A5F4A-CF89-4A29-B778-E035B442225A}.Release|Win32.fBatchBld=;={825A5F4A-CF89-4A29-B778-E035B442225A}.Debug|Win32.fBatchBld=;4{489480B1-F26B-412F-8A36-70D07159E5BC}.dwStartupOpt=;={489480B1-F26B-412F-8A36-70D07159E5BC}.Release|x64.fBatchBld=;;{489480B1-F26B-412F-8A36-70D07159E5BC}.Debug|x64.fBatchBld=;?{489480B1-F26B-412F-8A36-70D07159E5BC}.Release|Win32.fBatchBld=;={489480B1-F26B-412F-8A36-70D07159E5BC}.Debug|Win32.fBatchBld=;4{9643E4ED-1F10-4A16-890D-E20240ADC190}.dwStartupOpt=;={9643E4ED-1F10-4A16-890D-E20240ADC190}.Release|x64.fBatchBld=;;{9643E4ED-1F10-4A16-890D-E20240ADC190}.Debug|x64.fBatchBld=;?{9643E4ED-1F10-4A16-890D-E20240ADC190}.Release|Win32.fBatchBld=;={9643E4ED-1F10-4A16-890D-E20240ADC190}.Debug|Win32.fBatchBld=;4{3831E9F2-FDAA-4C48-B394-9F3A1CEC5759}.dwStartupOpt=;={3831E9F2-FDAA-4C48-B394-9F3A1CEC5759}.Release|x64.fBatchBld=;;{3831E9F2-FDAA-4C48-B394-9F3A1CEC5759}.Debug|x64.fBatchBld=;?{3831E9F2-FDAA-4C48-B394-9F3A1CEC5759}.Release|Win32.fBatchBld=;={3831E9F2-FDAA-4C48-B394-9F3A1CEC5759}.Debug|Win32.fBatchBld=;4{A8A8CD5C-54F4-4F22-B01E-A6985A0CC263}.dwStartupOpt=;={A8A8CD5C-54F4-4F22-B01E-A6985A0CC263}.Release|x64.fBatchBld=;;{A8A8CD5C-54F4-4F22-B01E-A6985A0CC263}.Debug|x64.fBatchBld=;?{A8A8CD5C-54F4-4F22-B01E-A6985A0CC263}.Release|Win32.fBatchBld=;={A8A8CD5C-54F4-4F22-B01E-A6985A0CC263}.Debug|Win32.fBatchBld=;4{6635CF18-5122-4950-A395-5AC8AFAC5B6C}.dwStartupOpt=;={6635CF18-5122-4950-A395-5AC8AFAC5B6C}.Release|x64.fBatchBld=;;{6635CF18-5122-4950-A395-5AC8AFAC5B6C}.Debug|x64.fBatchBld=;?{6635CF18-5122-4950-A395-5AC8AFAC5B6C}.Release|Win32.fBatchBld=;={6635CF18-5122-4950-A395-5AC8AFAC5B6C}.Debug|Win32.fBatchBld=;4{D3711C7C-8B57-49D4-89AB-B7EFE4CFD734}.dwStartupOpt=;={D3711C7C-8B57-49D4-89AB-B7EFE4CFD734}.Release|x64.fBatchBld=;;{D3711C7C-8B57-49D4-89AB-B7EFE4CFD734}.Debug|x64.fBatchBld=;?{D3711C7C-8B57-49D4-89AB-B7EFE4CFD734}.Release|Win32.fBatchBld=;={D3711C7C-8B57-49D4-89AB-B7EFE4CFD734}.Debug|Win32.fBatchBld=;4{7A4352A7-59A4-43D5-9DB1-5B8FFEDBA487}.dwStartupOpt=;={7A4352A7-59A4-43D5-9DB1-5B8FFEDBA487}.Release|x64.fBatchBld=;;{7A4352A7-59A4-43D5-9DB1-5B8FFEDBA487}.Debug|x64.fBatchBld=;?{7A4352A7-59A4-43D5-9DB1-5B8FFEDBA487}.Release|Win32.fBatchBld=;={7A4352A7-59A4-43D5-9DB1-5B8FFEDBA487}.Debug|Win32.fBatchBld=;4{96006E4E-6BA3-45D3-BD0C-1C6948A7B190}.dwStartupOpt=;={96006E4E-6BA3-45D3-BD0C-1C6948A7B190}.Release|x64.fBatchBld=;;{96006E4E-6BA3-45D3-BD0C-1C6948A7B190}.Debug|x64.fBatchBld=;?{96006E4E-6BA3-45D3-BD0C-1C6948A7B190}.Release|Win32.fBatchBld=;={96006E4E-6BA3-45D3-BD0C-1C6948A7B190}.Debug|Win32.fBatchBld=;4{D96A11B7-CBA8-492B-BAB0-2176930A7B2D}.dwStartupOpt=;={D96A11B7-CBA8-492B-BAB0-2176930A7B2D}.Release|x64.fBatchBld=;;{D96A11B7-CBA8-492B-BAB0-2176930A7B2D}.Debug|x64.fBatchBld=;?{D96A11B7-CBA8-492B-BAB0-2176930A7B2D}.Release|Win32.fBatchBld=;={D96A11B7-CBA8-492B-BAB0-2176930A7B2D}.Debug|Win32.fBatchBld=;4{BCEEA3E0-567A-4946-A47F-8E300920BA24}.dwStartupOpt=;={BCEEA3E0-567A-4946-A47F-8E300920BA24}.Release|x64.fBatchBld=;;{BCEEA3E0-567A-4946-A47F-8E300920BA24}.Debug|x64.fBatchBld=;?{BCEEA3E0-567A-4946-A47F-8E300920BA24}.Release|Win32.fBatchBld=;={BCEEA3E0-567A-4946-A47F-8E300920BA24}.Debug|Win32.fBatchBld=;4{6C478B62-1737-4F87-B54C-89363C4FA5D8}.dwStartupOpt=;={6C478B62-1737-4F87-B54C-89363C4FA5D8}.Release|x64.fBatchBld=;;{6C478B62-1737-4F87-B54C-89363C4FA5D8}.Debug|x64.fBatchBld=;?{6C478B62-1737-4F87-B54C-89363C4FA5D8}.Release|Win32.fBatchBld=;={6C478B62-1737-4F87-B54C-89363C4FA5D8}.Debug|Win32.fBatchBld=;4{3869AF45-1841-47C8-B6FA-10FF36EB43D4}.dwStartupOpt=;={3869AF45-1841-47C8-B6FA-10FF36EB43D4}.Release|x64.fBatchBld=;;{3869AF45-1841-47C8-B6FA-10FF36EB43D4}.Debug|x64.fBatchBld=;?{3869AF45-1841-47C8-B6FA-10FF36EB43D4}.Release|Win32.fBatchBld=;={3869AF45-1841-47C8-B6FA-10FF36EB43D4}.Debug|Win32.fBatchBld=;4{55E03CF1-A4CE-415A-AF58-9708A9037B73}.dwStartupOpt=;={55E03CF1-A4CE-415A-AF58-9708A9037B73}.Release|x64.fBatchBld=;;{55E03CF1-A4CE-415A-AF58-9708A9037B73}.Debug|x64.fBatchBld=;?{55E03CF1-A4CE-415A-AF58-9708A9037B73}.Release|Win32.fBatchBld=;={55E03CF1-A4CE-415A-AF58-9708A9037B73}.Debug|Win32.fBatchBld=;4{FED2FE89-EBD6-4A98-A854-8336288241C5}.dwStartupOpt=;={FED2FE89-EBD6-4A98-A854-8336288241C5}.Release|x64.fBatchBld=;;{FED2FE89-EBD6-4A98-A854-8336288241C5}.Debug|x64.fBatchBld=;?{FED2FE89-EBD6-4A98-A854-8336288241C5}.Release|Win32.fBatchBld=;={FED2FE89-EBD6-4A98-A854-8336288241C5}.Debug|Win32.fBatchBld=;4{7E02621E-E197-4EA1-951E-CE83908C89A6}.dwStartupOpt=;4{FBC8CB90-B99F-458E-9633-84AAF5E66864}.dwStartupOpt=;4{9CCB91C8-CE8A-43E7-B818-C50B69CBEA52}.dwStartupOpt=;={9CCB91C8-CE8A-43E7-B818-C50B69CBEA52}.Release|x64.fBatchBld=;;{9CCB91C8-CE8A-43E7-B818-C50B69CBEA52}.Debug|x64.fBatchBld=;?{9CCB91C8-CE8A-43E7-B818-C50B69CBEA52}.Release|Win32.fBatchBld=;={9CCB91C8-CE8A-43E7-B818-C50B69CBEA52}.Debug|Win32.fBatchBld=;4{83284438-103B-4D2C-A1F3-9A10F2856893}.dwStartupOpt=;={83284438-103B-4D2C-A1F3-9A10F2856893}.Release|x64.fBatchBld=;;{83284438-103B-4D2C-A1F3-9A10F2856893}.Debug|x64.fBatchBld=;?{83284438-103B-4D2C-A1F3-9A10F2856893}.Release|Win32.fBatchBld=;={83284438-103B-4D2C-A1F3-9A10F2856893}.Debug|Win32.fBatchBld=;4{9B1DFC22-D63F-41C0-8A1E-DE1D7E9A0E9A}.dwStartupOpt=;={9B1DFC22-D63F-41C0-8A1E-DE1D7E9A0E9A}.Release|x64.fBatchBld=;;{9B1DFC22-D63F-41C0-8A1E-DE1D7E9A0E9A}.Debug|x64.fBatchBld=;?{9B1DFC22-D63F-41C0-8A1E-DE1D7E9A0E9A}.Release|Win32.fBatchBld=;={9B1DFC22-D63F-41C0-8A1E-DE1D7E9A0E9A}.Debug|Win32.fBatchBld=;4{F9D71C21-F737-423C-9005-CB3A22D31F28}.dwStartupOpt=;={F9D71C21-F737-423C-9005-CB3A22D31F28}.Release|x64.fBatchBld=;;{F9D71C21-F737-423C-9005-CB3A22D31F28}.Debug|x64.fBatchBld=;?{F9D71C21-F737-423C-9005-CB3A22D31F28}.Release|Win32.fBatchBld=;={F9D71C21-F737-423C-9005-CB3A22D31F28}.Debug|Win32.fBatchBld=;4{C56DAF55-9456-4E18-9E81-6A637F402B21}.dwStartupOpt=;={C56DAF55-9456-4E18-9E81-6A637F402B21}.Release|x64.fBatchBld=;;{C56DAF55-9456-4E18-9E81-6A637F402B21}.Debug|x64.fBatchBld=;?{C56DAF55-9456-4E18-9E81-6A637F402B21}.Release|Win32.fBatchBld=;={C56DAF55-9456-4E18-9E81-6A637F402B21}.Debug|Win32.fBatchBld=;4{DA880260-0151-4AA4-83B8-F2EE9A398621}.dwStartupOpt=;={DA880260-0151-4AA4-83B8-F2EE9A398621}.Release|x64.fBatchBld=;;{DA880260-0151-4AA4-83B8-F2EE9A398621}.Debug|x64.fBatchBld=;?{DA880260-0151-4AA4-83B8-F2EE9A398621}.Release|Win32.fBatchBld=;={DA880260-0151-4AA4-83B8-F2EE9A398621}.Debug|Win32.fBatchBld=;4{06BD0427-4DB1-4EDC-8E57-DDFF92918E17}.dwStartupOpt=;={06BD0427-4DB1-4EDC-8E57-DDFF92918E17}.Release|x64.fBatchBld=;;{06BD0427-4DB1-4EDC-8E57-DDFF92918E17}.Debug|x64.fBatchBld=;?{06BD0427-4DB1-4EDC-8E57-DDFF92918E17}.Release|Win32.fBatchBld=;={06BD0427-4DB1-4EDC-8E57-DDFF92918E17}.Debug|Win32.fBatchBld=;4{6A53F65C-D46D-41F8-8E0F-AF7372067EA8}.dwStartupOpt=;={6A53F65C-D46D-41F8-8E0F-AF7372067EA8}.Release|x64.fBatchBld=;;{6A53F65C-D46D-41F8-8E0F-AF7372067EA8}.Debug|x64.fBatchBld=;?{6A53F65C-D46D-41F8-8E0F-AF7372067EA8}.Release|Win32.fBatchBld=;={6A53F65C-D46D-41F8-8E0F-AF7372067EA8}.Debug|Win32.fBatchBld=;4{8AE05377-17AE-4898-9A0F-85797908901D}.dwStartupOpt=;={8AE05377-17AE-4898-9A0F-85797908901D}.Release|x64.fBatchBld=;;{8AE05377-17AE-4898-9A0F-85797908901D}.Debug|x64.fBatchBld=;?{8AE05377-17AE-4898-9A0F-85797908901D}.Release|Win32.fBatchBld=;={8AE05377-17AE-4898-9A0F-85797908901D}.Debug|Win32.fBatchBld=;4{1F954DB3-3957-43D3-B27D-A2A49552D3E9}.dwStartupOpt=;={1F954DB3-3957-43D3-B27D-A2A49552D3E9}.Release|x64.fBatchBld=;;{1F954DB3-3957-43D3-B27D-A2A49552D3E9}.Debug|x64.fBatchBld=;?{1F954DB3-3957-43D3-B27D-A2A49552D3E9}.Release|Win32.fBatchBld=;={1F954DB3-3957-43D3-B27D-A2A49552D3E9}.Debug|Win32.fBatchBld=;4{89BB9690-8656-4A53-AACF-721D4B50A0DC}.dwStartupOpt=;={89BB9690-8656-4A53-AACF-721D4B50A0DC}.Release|x64.fBatchBld=;;{89BB9690-8656-4A53-AACF-721D4B50A0DC}.Debug|x64.fBatchBld=;?{89BB9690-8656-4A53-AACF-721D4B50A0DC}.Release|Win32.fBatchBld=;={89BB9690-8656-4A53-AACF-721D4B50A0DC}.Debug|Win32.fBatchBld=;4{7559AA0F-D574-4810-AB5B-6A4F6E6D600E}.dwStartupOpt=;={7559AA0F-D574-4810-AB5B-6A4F6E6D600E}.Release|x64.fBatchBld=;;{7559AA0F-D574-4810-AB5B-6A4F6E6D600E}.Debug|x64.fBatchBld=;?{7559AA0F-D574-4810-AB5B-6A4F6E6D600E}.Release|Win32.fBatchBld=;={7559AA0F-D574-4810-AB5B-6A4F6E6D600E}.Debug|Win32.fBatchBld=; ActiveCfg= Debug|Win32;ObjMgrContentsV8"џџџџџџџџClassViewContents$џџџџўџџџProjExplorerState$џџџџНcUnloadedProjects"џџџџџџџџџџџџўџџџ.1\build.vc8\tests\mpf\div\div.vcprojОC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\div_2exp\div_2exp.vcprojЎC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\dive\dive.vcprojКC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\dive_ui\dive_ui.vcprojВC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\divis\divis.vcprojЦC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\divis_2exp\divis_2exp.vcprojОC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpn\divrem_1\divrem_1.vcprojВC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_gmp_gc\dll_gmp_gc.vcprojЊC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_mpfr\dll_mpfr.vcprojЖC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpf\dm2exp\dm2exp.vcprojВC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpq\equal\equal.vcprojЖC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\export\export.vcprojЖC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\fac_ui\fac_ui.vcprojЊC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpn\fat\fat.vcprojЎC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\fdiv\fdiv.vcprojКC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\fdiv_ui\fdiv_ui.vcprojЖC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\fib_ui\fib_ui.vcprojЎC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\fits\fits.vcprojЊC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\gcd\gcd.vcprojЖC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\gcd_ui\gcd_ui.vcprojЎC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\gen-bases\gen-bases.vcprojВC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\gen-fac_ui\gen-fac_ui.vcprojІC:\unix\cygwin\home\Juanjo\src\ecQ ЊC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpf\add\add.vcprojЖC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\addsub\addsub.vcprojЎC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpq\aors\aors.vcprojЖC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpn\aors_1\aors_1.vcprojКC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\aorsmul\aorsmul.vcprojКC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpn\asmtype\asmtype.vcprojЖC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\assign\assign.vcprojЊC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\bin\bin.vcprojЖC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\binary\binary.vcprojЊC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\bit\bit.vcprojЊC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\bswap\bswap.vcprojЎC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\cast\cast.vcprojКC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\cdiv_ui\cdiv_ui.vcprojЊC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\cmp\cmp.vcprojВC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\cmp_d\cmp_d.vcprojЖC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\cmp_si\cmp_si.vcprojЖC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpq\cmp_ui\cmp_ui.vcprojЎC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\cong\cong.vcprojТC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\cong_2exp\cong_2exp.vcprojКC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\constants\constants.vcprojЖC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\constr\constr.vcprojЎC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpf\conv\conv.vcprojКC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\convert\convert.vcprojТC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\count_zeros\count_zeros.vcprojЊC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2l\msvc\gmp-4.2.1\build.vc8\gen-fib\gen-fib.vcprojЊC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\gen-psqr\gen-psqr.vcprojВC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\get_d\get_d.vcprojЦC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\get_d_2exp\get_d_2exp.vcprojЖC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\get_si\get_si.vcprojКC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpq\get_str\get_str.vcprojЖC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpf\get_ui\get_ui.vcprojЎC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\gmpmax\gmpmax.vcprojЖC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpf\gsprec\gsprec.vcprojКC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\hamdist\hamdist.vcprojКC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\headers\headers.vcprojОC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\hightomask\hightomask.vcprojЖC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\import\import.vcprojКC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\inp_str\inp_str.vcprojЦC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpn\instrument\instrument.vcprojВC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpf\int_p\int_p.vcprojІC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\io\io.vcprojЖC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\io_raw\io_raw.vcprojЖC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpn\iord_u\iord_u.vcprojАC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\rand\iset\iset.vcprojКC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\istream\istream.vcprojЊC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\jac\jac.vcprojИC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\rand\lc2exp\lc2exp.vcprojЊC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\lcm\lcm.vcprojІC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp\lib_gmp.vcprojВC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp_gc\lib_gmp_gc.vcprojЎC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmpxx\lib_gmpxx.vcprojЊC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_mpfr\lib_mpfr.vcprojЖC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\locale\locale.vcprojВC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\logic\logic.vcprojТC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\lucnum_ui\lucnum_ui.vcprojКC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpq\md_2exp\md_2exp.vcprojЎC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\misc\misc.vcprojВC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\modlinv\modlinv.vcprojОC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpn\mp_bases\mp_bases.vcprojЈC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\rand\mt\mt.vcprojЊC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\mul\mul.vcprojВC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\mul_i\mul_i.vcprojЖC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpf\mul_ui\mul_ui.vcprojЖC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpf\muldiv\muldiv.vcprojКC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\oddeven\oddeven.vcprojЊC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\ops\ops.vcprojКC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\ostream\ostream.vcprojЎC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\parity\parity.vcprojКC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\perfsqr\perfsqr.vcprojІC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\popc\popc.vcprojОC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\popcount\popcount.vcprojЊC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\pow\pow.vcprojЎC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\powm\powm.vcprojКC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\powm_ui\powm_ui.vcprojОC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\pprime_p\pprime_p.vcprojЎC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\prec\prec.vcprojИC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\misc\printf\printf.vcprojЎC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\rand\rand.vcprojВC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\reuse\reuse.vcprojЎC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\root\root.vcprojЎC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\scan\scan.vcprojДC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\misc\scanf\scanf.vcprojЊC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpf\set\set.vcprojВC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\set_d\set_d.vcprojВC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\set_f\set_f.vcprojВC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpf\set_q\set_q.vcprojЖC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\set_si\set_si.vcprojКC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\set_str\set_str.vcprojЖC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpf\set_ui\set_ui.vcprojЦC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\sizeinbase\sizeinbase.vcprojЎC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpf\sqrt\sqrt.vcprojКC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpf\sqrt_ui\sqrt_ui.vcprojКC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\sqrtrem\sqrtrem.vcprojЊC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpf\sub\sub.vcprojІC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\subc\subc.vcprojЎC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\tdiv\tdiv.vcprojКC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpz\tdiv_ui\tdiv_ui.vcprojКC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\ternary\ternary.vcprojВC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpf\trunc\trunc.vcprojЖC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\mpf\ui_div\ui_div.vcprojВC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\cxx\unary\unary.vcprojДC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\rand\urbui\urbui.vcprojДC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\rand\urmui\urmui.vcprojИC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\tests\rand\urndmm\urndmm.vcprojcxxОC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_gmp_amd64\dll_gmp_amd64.vcprojВC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_gmp_p0\dll_gmp_p0.vcprojВC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_gmp_p3\dll_gmp_p3.vcprojВC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\dll_gmp_p4\dll_gmp_p4.vcproj DLLsОC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp_amd64\lib_gmp_amd64.vcprojВC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp_p0\lib_gmp_p0.vcprojВC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp_p3\lib_gmp_p3.vcprojВC:\unix\cygwin\home\Juanjo\src\ecl\msvc\gmp-4.2.1\build.vc8\lib_gmp_p4\lib_gmp_p4.vcproj LIBs miscmpfmpnmpqmpz randSolution Items TestsHiddenSlnFolders"џџџџџџџџџџџџўџџџOutliningStateDir$џџџџџџџџџџџџBookmarkStateџџџџџџџџџџџџ(TaskListShortcuts$џџџџџџџџџџџџecl-16.1.2/msvc/gmp/build.vc8/gmp_prebuild.bat000077500000000000000000000012421266352375300210540ustar00rootroot00000000000000echo configuring for a %2 bit build if not exist %1 (echo creating directory %1 && md %1) if not exist %1\mp_bases.h (echo creating %1\mp_bases.h && ..\gen-bases header %2 0 >%1\mp_bases.h) if not exist %1\mp_bases.c (echo creating %1\mp_bases.c && ..\gen-bases table %2 0 >%1\mp_bases.c) if not exist %1\fac_ui.h (echo creating %1\fac_ui.h && ..\gen-fac_ui %2 0 >%1\fac_ui.h) if not exist %1\fib_table.h (echo creating %1\fib_table.h && ..\gen-fib header %2 0 >%1\fib_table.h) if not exist %1\fib_table.c (echo creating %1\fib_table.c && ..\gen-fib table %2 0 >%1\fib_table.c) if not exist %1\perfsqr.h (echo creating %1\perfsqr.h && ..\gen-psqr %2 0 >%1\perfsqr.h) ecl-16.1.2/msvc/gmp/build.vc8/lib_gmp/000077500000000000000000000000001266352375300173225ustar00rootroot00000000000000ecl-16.1.2/msvc/gmp/build.vc8/lib_gmp/lib_gmp.vcproj000077500000000000000000013266101266352375300221740ustar00rootroot00000000000000 ecl-16.1.2/msvc/gmp/build.vc8/lib_gmp_amd64/000077500000000000000000000000001266352375300203155ustar00rootroot00000000000000ecl-16.1.2/msvc/gmp/build.vc8/lib_gmp_amd64/lib_gmp_amd64.vcproj000077500000000000000000001237501266352375300241610ustar00rootroot00000000000000 ecl-16.1.2/msvc/gmp/build.vc8/lib_gmp_gc/000077500000000000000000000000001266352375300177735ustar00rootroot00000000000000ecl-16.1.2/msvc/gmp/build.vc8/lib_gmp_gc/lib_gmp_gc.vcproj000077500000000000000000001747101266352375300233170ustar00rootroot00000000000000 ecl-16.1.2/msvc/gmp/build.vc8/lib_gmp_p0/000077500000000000000000000000001266352375300177215ustar00rootroot00000000000000ecl-16.1.2/msvc/gmp/build.vc8/lib_gmp_p0/lib_gmp_p0.vcproj000077500000000000000000001044641266352375300231720ustar00rootroot00000000000000 ecl-16.1.2/msvc/gmp/build.vc8/lib_gmp_p3/000077500000000000000000000000001266352375300177245ustar00rootroot00000000000000ecl-16.1.2/msvc/gmp/build.vc8/lib_gmp_p3/lib_gmp_p3.vcproj000077500000000000000000000764651266352375300232110ustar00rootroot00000000000000 ecl-16.1.2/msvc/gmp/build.vc8/lib_gmp_p4/000077500000000000000000000000001266352375300177255ustar00rootroot00000000000000ecl-16.1.2/msvc/gmp/build.vc8/lib_gmp_p4/lib_gmp_p4.vcproj000077500000000000000000001053331266352375300231760ustar00rootroot00000000000000 ecl-16.1.2/msvc/gmp/build.vc8/lib_gmpxx/000077500000000000000000000000001266352375300177025ustar00rootroot00000000000000ecl-16.1.2/msvc/gmp/build.vc8/lib_gmpxx/lib_gmpxx.vcproj000077500000000000000000000550631266352375300231340ustar00rootroot00000000000000 ecl-16.1.2/msvc/gmp/build.vc8/lib_mpfr/000077500000000000000000000000001266352375300175035ustar00rootroot00000000000000ecl-16.1.2/msvc/gmp/build.vc8/lib_mpfr/lib_mpfr.vcproj000077500000000000000000006147541266352375300225460ustar00rootroot00000000000000 ecl-16.1.2/msvc/gmp/build.vc8/popham.c000077500000000000000000000023471266352375300173520ustar00rootroot00000000000000/* mpn_popcount, mpn_hamdist -- mpn bit population count/hamming distance. Copyright 1994, 1996, 2000, 2001, 2002, 2005 Free Software Foundation, Inc. This file is part of the GNU MP Library. The GNU MP Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU MP Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU MP Library; see the file COPYING.LIB. If not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ #include "gmp.h" #include "gmp-impl.h" #define OPERATION_popcount 1 #define OPERATION_hamdist 0 #include "..\mpn\generic\popham.c" #undef OPERATION_popcount #undef OPERATION_hamdist #undef FNAME #undef POPHAM #define OPERATION_popcount 0 #define OPERATION_hamdist 1 #include "..\mpn\generic\popham.c" ecl-16.1.2/msvc/gmp/build.vc8/readme-vc8.txt000077500000000000000000000346551266352375300204250ustar00rootroot00000000000000 ===================================================== A. Compiling GMP and MPFR with the Visual Studio 2005 ===================================================== These VC++ build projects are based on GMP 4.2.1 and MPFR 2.2.1. Some files in GMP 4.2.1 need to be modified to compile with VC++. These have been moved into the vc8 build directory to avoid making changes to GMP files. But this means that these files may need to be updated if the related GMP files change. Building MPFR is optional as this is no longer ditributed with GMP. STEP ONE ======== First obtain the GMP and MPFR distributions, named gmp- and mpfr- where are the versions being used. Unzip the gmp- files in the ZIP archive into a directory tree with the gmp- directory as its root. Unzip the MPFR files so that the root mpfr- directory is within the gmp- directory. That is, the directories mpfr and mpfr- are at the same level in the directory tree. Then delete the mpfr directory and rename the directory mpfr- to mpfr. You should then apply any patches that are needed for either or both GMP and MPFR. Then rename the mparam_h.in file in the mpfr distribution to mparam.h. Unzip the files in this distribution so that they are merged into the above directory tree with the directories build.vc8 -- build files for gmp and mpfr mpn/x86i -- the YASM x86 assembler files (Pentium family) mpn/amd64i -- the YASM x64 assembler files (AMD64) within the gmp root directory gmp-. STEP TWO ======== If you wish to use the assembler files you will also need the YASM open source x86 assembler (r1438 or later) for Windows which can be obtained from: http://www.tortall.net/projects/yasm/ This assembler should be placed in the bin directory used by VC++, which, for Visual Stduio 2005, is typically: C:\Program Files (x86)\Microsoft Visual Studio 8\VC\bin You will also need to move the yasm.rules file from this distribution into the directory where Visual Studio 2005 expects to find it, which is typically: C:\Program Files (x86)\Microsoft Visual Studio 8\VC\VCProjectDefaults Alternatively you can configure the path for rules files in the VC++ configuration dialogue. The NASM assembler is no longer supported as it cannot assemble 64-bit instructions and also has problems with include file directory handling. STEP THREE ========== Visual Studiio 2005 can be started for building the 32 or 64 bit versions of GMP and MPFR by clicking on the *.sln file in the build.vc8 directory. GMP and MPFR are built using the appropriate build projects. Select the desired library and then set the desired configuration: win32 or x64 release or debug To build GMP dynamic link libraries (DLLs) choose one (or more) of: dll_gmp_amd64 - GMP DLL using AMD64 assembler (x64) dll_gmp_gc - GMP DLL using generic C (win32 & x64) dll_gmp_p0 - GMP DLL using Pentium assembler (win32) dll_gmp_p3 - GMP DLL using Pentium III assembler (win32) dll_gmp_p4 - GMP DLL using Pentium IV assembler (win32) To build GMP static libraries choose one (or more) of: lib_gmp_amd64 - GMP library using AMD64 assembler (x64) lib_gmp_gc - GMP library using generic C (win32 & x64) lib_gmp_p0 - GMP library using Pentium assembler (win32) lib_gmp_p3 - GMP library using Pentium III assembler (win32 lib_gmp_p4 - GMP library using Pentium IV assembler (win32) Before any of these libraries is built the appropriate GMP configuration file is automatically copied into config.h. After a static library is built it is then copied to the file gmp.lib in the 'lib' sub-directory within the VC++ solution folder (build.vc8). Simlarly when a DLL is built, the resulting DLL, its export libraries and its debug symbol file are copied to the files gmp.dll, gmp.exp, gmp.lib and gmp.pdb within the 'dll' sub-directory. This means that the 'dll' and 'lib' sub-directories respectively contain the last GMP DLLs and static libraries built. These are then the libraries used to build the MPFR and GMPXX libraries described later. The GMP DLL projects include the C++ files. If you do not want these the relevent files needed to be excluded from the DLL(s) you want to build. Go to the 'cpp' subdirectory of their build project in the IDE and exclude all the files in this subdirectory from the build process. All the DLLs and static libraries are multi-threaded and are linked to the multi-threaded Microsoft run-time libraries (DLLs are linked to DLL run time libraries and static libraries are linked to run time static libraries). Within the 'dll' and 'lib' sub-directories used for output the structure is: DLL or LIB Win32 Release Debug x64 Release Debug in order to enable the appropriate library for the desired target platform to be located. STEP FOUR ========= After a GMP library has been built, other libraries can be built. These always use the last GMP library (of the same type) that has been built. To build the MPFR DLL use: dll_mpfr - MPFR DLL using generic C (win32 & x64) To build the MPFR static library use: lib_mpfr - MPFR static library (win32 & x64) To build the GMP C+ library wrapper use: lib_gmpxx - GMP C++ wrapper static library (win32 & x64) The MPFR static library build assumes that this is intended to work with the lib_gmp or lib_gmpxx static libraries. If more than one gmp DLL is built, please remember that when the MPFR DLL is built it will be linked to the last gmp DLL that is built. Alternatively you can edit the MPFR linker property page to link to a specific export library. The debug versions of these DLLs and libraries are built in the same way. STEP FIVE (Tests) ================= All the remaining projects are for GMP testing. In Vusual Studio 2005 these are in the Tests project folder and its sub-folders but Visual C++ Express doesn't support project folders so they have to be identified manually. These test cover only GMP at the moment and must be built and run manually. The tests can only be built with the static libraries because they use internal symbols that are not exported by the DLLs. ===================== B. Using GMP and MPFR ===================== Many applications that rely on GMP and MPFR also include the gmp.h and mpfr.h header files but it is impossible to be certain that these will match the versions of GMP and MPFR that are built by this distribution. Hence when this distribution is being used with a GMP based application it is important to ensure that any GMP and MPFR header files used by such an application are those that are supplied here and not those that might have been supplied with the application itself. This will often be only gmp.h and mpfr.h but some other header files may also be involved. The static libraries and DLLs built here use the _cdecl calling convention in which exported symbols have their C names prefixed with an extra '_' character. Some applications expect the _stdcall convention to be used in which there is an underscore prefix and a suffix of '@n' where n is the number of bytes used for the function arguments on the stack. Such applications will need to be modified to work with the GMP and MPFR DLLs and libraries provided here. The alternative of attempting to build GMP and MPFR using the _stdcall convention is not recommended (and won't work with the assembler based builds anyway). This is further complicated if the builds for x64 are used since the conventions here are different once again. 1. Using the Static Libraries ============================= To build a GMP C or C++ based application using the the static libraries all that needs to be done is to add the GMP or GMPXX static libraries to the application build process. To build an MPFR based application add the MPFR library and the GMP or GMPXX library as appropriate. It is, of course, important to ensure that any libraries that are used have been built for the target platform. 2. Using the DLL Export Libraries ================================= There are two ways of linking to a DLL. The first way is to use one or more of the DLL export libraries built as described earlier (note that these are not the same as static libraries although they are used in a similar way when an application is built). If you intend to use the DLL export libraries in an application you need to: a. ensure that the application can locate the GMP and/or the MPFR DLLs in question when it is run. This involves putting the DLL(s) on a recognised directory path. b. define __GMP_LIBGMP_DLL and/or __MPFR_LIBGMP_DLL when the application is built in order to ensure that GMP and/or MPFR symbols, which are DLL export symbols, are properly recognised as such. 3. Using DLL Dynamic loading ============================ The second way of linking to a DLL is to use dynamic loading. This is more complex and will not be discussed here. The VC++ documentation describes how to use DLLs in this way. ============================== KNOWN BUILD ISSUES FOR VC++ v8 ============================== 1. A few test files require minor modifications to compile in this build as follows; File: tests\tests.h 25 25 26 26 #include "config.h" 27 27 28 28 #include /* for jmp_buf */ 29 29 30 30 #if defined (__cplusplus) -------------------------------------------- 31 using namespace std; /* BRG */ -------------------------------------------- 31 32 extern "C" { 32 33 #endif -------------------------------------------- 33 -------------------------------------------- 34 34 35 35 #ifdef __cplusplus 36 36 #define ANYARGS ... 37 37 #else 38 38 #define ANYARGS 39 39 #endif -------------------------------------------- File: tests\misc.c 24 24 #include 25 25 #include 26 26 #include 27 27 #include /* for getenv */ 28 28 #include 29 29 ------------------------------------------------------------------------ 30 #if HAVE_FLOAT_H ------------------------------------------------------------------------ 30 #if HAVE_FLOAT_H || defined( _MSC_VER ) /* BRG */ ------------------------------------------------------------------------ 31 31 #include /* for DBL_MANT_DIG */ 32 32 #endif 33 33 34 34 #if TIME_WITH_SYS_TIME 35 35 # include /* for struct timeval */ 36 36 # include ------------------------------------------------------------------------ ------------------------------------------------------------------------ 474 474 case 1: rc = 3; break; /* tozero */ 475 475 case 2: rc = 2; break; /* up */ 476 476 case 3: rc = 1; break; /* down */ 477 477 default: 478 478 return 0; 479 479 } ------------------------------------------------------------------------ 480 #if defined( _MSC_VER ) 481 { unsigned int cw; 482 _controlfp_s(&cw, 0, 0); 483 _controlfp_s(&cw, (cw & ~0xC00) | (rc << 10), _MCW_RC); 484 } 485 #else ------------------------------------------------------------------------ 480 486 x86_fldcw ((x86_fstcw () & ~0xC00) | (rc << 10)); ------------------------------------------------------------------------ 487 #endif ------------------------------------------------------------------------ 481 488 return 1; 482 489 #endif 483 490 484 491 return 0; 485 492 } 486 493 487 494 /* Return the hardware floating point rounding mode, or -1 if unknown. */ 488 495 int 489 496 tests_hardware_getround (void) 490 497 { 491 498 #if HAVE_HOST_CPU_FAMILY_x86 ------------------------------------------------------------------------ 492 switch ((x86_fstcw () & ~0xC00) >> 10) { ------------------------------------------------------------------------ 499 unsigned int cw; 500 #if defined( _MSC_VER ) 501 _controlfp_s(&cw, 0, 0); 502 #else 503 cw = x86_fstcw(); 504 #endif 505 506 switch ((cw & ~0xC00) >> 10) { ------------------------------------------------------------------------ 493 507 case 0: return 0; break; /* nearest */ 494 508 case 1: return 3; break; /* down */ 495 509 case 2: return 2; break; /* up */ 496 510 case 3: return 1; break; /* tozero */ 497 511 } 498 512 #endif ------------------------------------------------------------------------ File: tests\mpz\t-perfsqr.c 23 23 #include 24 24 25 25 #include "gmp.h" 26 26 #include "gmp-impl.h" 27 27 #include "tests.h" 28 28 ------------------------------------------------------------------------ 29 #ifdef _MSC_VER /* BRG */ 30 #include "perfsqr.h" 31 #else ------------------------------------------------------------------------ 29 32 #include "mpn/perfsqr.h" ------------------------------------------------------------------------ 30 ------------------------------------------------------------------------ 33 #endif ------------------------------------------------------------------------ 31 34 32 35 /* check_modulo() exercises mpz_perfect_square_p on squares which cover each 33 36 possible quadratic residue to each divisor used within 34 37 mpn_perfect_square_p, ensuring those residues aren't incorrectly claimed 35 38 to be non-residues. 36 39 ------------------------------------------------------------------------ File: tests\mpn\t-perfsqr.c 23 23 #include 24 24 25 25 #include "gmp.h" 26 26 #include "gmp-impl.h" 27 27 #include "tests.h" 28 28 ------------------------------------------------------------------------ 29 #ifdef _MSC_VER /* BRG */ 30 #include "perfsqr.h" 31 #else ------------------------------------------------------------------------ 29 32 #include "mpn/perfsqr.h" ------------------------------------------------------------------------ 30 ------------------------------------------------------------------------ 33 #endif ------------------------------------------------------------------------ 31 34 32 35 #define PERFSQR_MOD_MASK ((CNST_LIMB(1) << PERFSQR_MOD_BITS) - 1) 33 36 34 37 void 35 38 check_mod_2 (mp_limb_t d, mp_limb_t inv, mp_limb_t got_hi, mp_limb_t got_lo) 36 39 { ------------------------------------------------------------------------ ================ Acknowledgements ================ My thanks to: 1. The GMP team for their work on GMP and the MPFR team for their work on MPFR 2. Sam Krasnik and Mike Loehr for suggestions on how to improve and correct errors in earlier releases. 3. Patrick Pelissier and Vincent Lefшvre for helping to resolve VC++ issues in MPFR. Brian Gladman, December 2006 ecl-16.1.2/msvc/gmp/build.vc8/unistd.h000077500000000000000000000001761266352375300173770ustar00rootroot00000000000000 #ifndef __UNISTD_H__ #define __UNISTD_H__ #include #include "getopt.h" #define random rand #define SIGHUP 1 #endif ecl-16.1.2/msvc/gmp/build.vc8/yasm.rules000077500000000000000000000060051266352375300177420ustar00rootroot00000000000000яЛП ecl-16.1.2/msvc/gmp/mpn/000077500000000000000000000000001266352375300147055ustar00rootroot00000000000000ecl-16.1.2/msvc/gmp/mpn/amd64i/000077500000000000000000000000001266352375300157715ustar00rootroot00000000000000ecl-16.1.2/msvc/gmp/mpn/amd64i/amd64i.inc000077500000000000000000000017511266352375300175570ustar00rootroot00000000000000 ; the symbol 'frame' keeps track of how much stack space is ; being used locally in order to be able to track where the ; routine parameters arew relative to the current value of ; the stack pointer in rsp ; save registers on the stack and adjust 'frame' accordingly %macro f_push 1-* %rep %0 push %1 %rotate 1 %assign frame frame + 8 %endrep %endmacro ; restore a register from the stack and adjust 'frame' accordingly %macro f_pop 1 %rep %0 %rotate -1 pop %1 %endrep %assign frame frame - 8 %endmacro ; restore registers from the stack at the end of a routine where ; 'frame' does not need to be adjusted because it won't be used ; again %macro f_pop 2-* %rep %0 %rotate -1 pop %1 %endrep %endmacro ; obtain some local space on the stack %macro f_add 1 sub rsp,%1 %assign frame frame + %1 %endmacro ; return local space on the stack at the end of a routine without the ; need to adjust 'frame' %macro f_sub 1 add rsp,%1 %endmacro %assign frame 0 %define x86_regs rbx,rsi,rdi,rbp ecl-16.1.2/msvc/gmp/mpn/amd64i/aors_n.asm000077500000000000000000000075201266352375300177630ustar00rootroot00000000000000; ; AMD64 mpn_add_n/mpn_sub_n -- mpn add or subtract. ; ; Copyright 1999, 2000, 2001, 2002 Free Software Foundation, Inc. ; ; This file is part of the GNU MP Library. ; ; The GNU MP Library is free software; you can redistribute it and/or ; modify it under the terms of the GNU Lesser General Public License as ; published by the Free Software Foundation; either version 2.1 of the ; License, or (at your option) any later version. ; ; The GNU MP Library is distributed in the hope that it will be useful, ; but WITHOUT ANY WARRANTY; without even the implied warranty of ; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ; Lesser General Public License for more details. ; ; You should have received a copy of the GNU Lesser General Public ; License along with the GNU MP Library; see the file COPYING.LIB. If ; not, write to the Free Software Foundation, Inc., 59 Temple Place - ; Suite 330, Boston, MA 02111-1307, USA. ; ; Adapted by Brian Gladman AMD64 using the Microsoft VC++ v8 64-bit ; compiler and the YASM assembler. ; ; Calling interface: ; ; mp_limb_t __gmpn__n( = add OR sub ; mp_ptr dst, ecx ; mp_srcptr src1, rdx ; mp_srcptr src2, r8 ; mp_size_t len r9 ; ) ; ; mp_limb_t __gmpn__nc( = add OR sub ; mp_ptr dst, ecx ; mp_srcptr src1, rdx ; mp_srcptr src2, r8 ; mp_size_t len, r9 ; mp_limb_t carry [rsp+0x28] ; ) ; ; Calculate src1[size] plus(minus) src2[size] and store the result in ; dst[size]. The return value is the carry bit from the top of the result ; (1 or 0). The _nc version accepts 1 or 0 for an initial carry into the ; low limb of the calculation. Note values other than 1 or 0 here will ; lead to garbage results. %define dst rcx ; destination pointer %define sr1 rdx ; source 1 pointer %define sr2 r8 ; source 2 pointer %define len r9 ; number of limbs %define cry [rsp+0x28] ; carry value %define r_jmp r10 ; temporary for jump table entry %define r_cnt r11 ; temporary for loop count %define UNROLL_LOG2 4 %define UNROLL_COUNT (1 << UNROLL_LOG2) %define UNROLL_MASK (UNROLL_COUNT - 1) %define UNROLL_BYTES (8 * UNROLL_COUNT) %define UNROLL_THRESHOLD 8 %if UNROLL_BYTES >= 256 %error unroll count is too large %elif UNROLL_BYTES >= 128 %define off 128 %else %define off 0 %endif %macro mac_sub 4 global %1%4 global %1%3 %ifdef DLL export %1%4 export %1%3 %define PIC %endif %1%4: mov rax,[rsp+0x28] jmp %%0 %1%3: xor rax,rax %%0: movsxd len,r9d cmp len,UNROLL_THRESHOLD jae %%2 lea sr1,[sr1+len*8] lea sr2,[sr2+len*8] lea dst,[dst+len*8] neg len shr rax,1 %%1: mov rax,[sr1+len*8] mov r10,[sr2+len*8] %2 rax,r10 mov [dst+len*8],rax inc len jnz %%1 mov rax,dword 0 setc al ret %%2: mov r_cnt,1 and r_cnt,len push r_cnt and len,-2 mov r_cnt,len dec r_cnt shr r_cnt,UNROLL_LOG2 neg len and len,UNROLL_MASK lea r_jmp,[len*4] neg len lea sr1,[sr1+len*8+off] lea sr2,[sr2+len*8+off] lea dst,[dst+len*8+off] shr rax,1 %ifdef PIC lea r_jmp,[r_jmp+r_jmp*2] lea rax,[%%3 wrt rip] lea r_jmp,[r_jmp+rax] %else lea r_jmp,[r_jmp+r_jmp*2+%%3] %endif jmp r_jmp %%3: %define CHUNK_COUNT 2 %assign i 0 %rep UNROLL_COUNT / CHUNK_COUNT %assign disp0 8 * i * CHUNK_COUNT - off mov r_jmp,[byte sr1+disp0] ; len and r_jmp registers mov len,[byte sr1+disp0+8] ; now not needed %2 r_jmp,[byte sr2+disp0] mov [byte dst+disp0],r_jmp %2 len,[byte sr2+disp0+8] mov [byte dst+disp0+8],len %assign i i + 1 %endrep dec r_cnt lea sr1,[sr1+UNROLL_BYTES] lea sr2,[sr2+UNROLL_BYTES] lea dst,[dst+UNROLL_BYTES] jns %%3 pop rax dec rax js %%5 mov len,[sr1-off] %2 len,[sr2-off] mov [dst-off],len %%5:mov rax,dword 0 setc al ret %endmacro bits 64 text mac_sub __g,adc,mpn_add_n,mpn_add_nc mac_sub __g,sbb,mpn_sub_n,mpn_sub_nc end ecl-16.1.2/msvc/gmp/mpn/amd64i/aorsmul_1.asm000077500000000000000000000123131266352375300204000ustar00rootroot00000000000000; ; AMD64 mpn_add_n/mpn_sub_n -- mpn add or subtract. ; ; Copyright 1999, 2000, 2001, 2002 Free Software Foundation, Inc. ; ; This file is part of the GNU MP Library. ; ; The GNU MP Library is free software; you can redistribute it and/or ; modify it under the terms of the GNU Lesser General Public License as ; published by the Free Software Foundation; either version 2.1 of the ; License, or (at your option) any later version. ; ; The GNU MP Library is distributed in the hope that it will be useful, ; but WITHOUT ANY WARRANTY; without even the implied warranty of ; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ; Lesser General Public License for more details. ; ; You should have received a copy of the GNU Lesser General Public ; License along with the GNU MP Library; see the file COPYING.LIB. If ; not, write to the Free Software Foundation, Inc., 59 Temple Place - ; Suite 330, Boston, MA 02111-1307, USA. ; ; Adapted by Brian Gladman AMD64 using the Microsoft VC++ v8 64-bit ; compiler and the YASM assembler. ; ; Calling interface: ; ; mp_limb_t __gmpn_mul_1( = add or sub ; mp_ptr dst, ecx ; mp_srcptr src, edx ; mp_size_t size, r8 ; mp_limb_t mult r9 ; ) ; ; mp_limb_t __gmpn_mul_1c( ; mp_ptr dst, ecx ; mp_srcptr src, edx ; mp_size_t size, r8 ; mp_limb_t mult, r9 ; mp_limb_t carry [rsp+0x28] ; ) ; ; Calculate src[size] multiplied by mult[1] and add to /subtract from dst[size] and ; return the carry or borrow from the top of the result %define dst rcx %define len r8 %define mlt r9 %define src r10 %define cry r11 %define UNROLL_LOG2 4 %define UNROLL_COUNT (1 << UNROLL_LOG2) %define UNROLL_MASK (UNROLL_COUNT - 1) %define UNROLL_BYTES (8 * UNROLL_COUNT) %define UNROLL_THRESHOLD 9 %if UNROLL_BYTES >= 256 %error unroll count is too large %elif UNROLL_BYTES >= 128 %define off 128 %else %define off 0 %endif %macro mac_sub 4 global %1%3 global %1%4 %ifdef DLL export %1%3 export %1%4 %define PIC %endif %1%3: movsxd len,r8d mov src,rdx ; source ptr xor cry,cry ; carry = 0 dec len ; test for one limb only jnz %%0 ; if more than one mov rax,[src] ; get limb value mul mlt ; rax * mlt -> rdx (hi), rax (lo) %2 [dst],rax ; add/sub from destination adc rdx,byte 0 ; add any carry into high word mov rax,rdx ; and return the carry value ret %1%4: movsxd len,r8d mov src,rdx ; source pointer mov cry,[rsp+0x28] ; carry value dec len ; test for one limb jnz %%0 ; if more than one mov rax,[src] ; get limb value mul mlt ; rax * mlt -> rdx (hi), rax (lo) add rax,cry ; add in input carry adc rdx,byte 0 ; propagate it into rdx %2 [dst],rax ; add or subtract rax from dest limb adc rdx,byte 0 ; propagate carry into high word mov rax,rdx ret %%0: cmp len,byte UNROLL_THRESHOLD mov rax,[src] ; first limb of source ja %%2 ; unroll for many limbs lea src,[src+len*8+8] ; next source limb lea dst,[dst+len*8] ; current dst limb neg len %%1: mul mlt ; multiply current src limb -> rxx, rax add rax,cry ; add in carry adc rdx,byte 0 ; propagate carry into rdx %2 [dst+len*8],rax ; add or subtract rax from dest limb mov rax,[src+len*8] ; get next source limb adc rdx,byte 0 ; add carry or borrow into high word inc len ; go to next limb mov cry,rdx ; high word -> carry jnz %%1 mul mlt ; one more limb to do add rax,cry adc rdx,byte 0 %2 [dst],rax adc rdx,byte 0 mov rax,rdx ; return carry value as a limb ret %define jmp_val rbp ; jump into code sequence %define rep_cnt rbx ; repeats for full sequence %define cry_hi rsi ; second carry for alternate block %%2: push rbp push rbx push rsi lea rep_cnt,[len-2] dec len shr rep_cnt,UNROLL_LOG2 neg len and len,UNROLL_MASK mov jmp_val,len mov cry_hi,len ; cry_hi and jmp_val are temporary shl jmp_val,2 ; values for calculating the jump shl cry_hi,4 ; offset into the unrolled code %ifdef PIC lea cry_hi,[cry_hi+jmp_val] lea jmp_val,[%%3 wrt rip] lea jmp_val,[jmp_val+cry_hi] %else lea jmp_val,[cry_hi+jmp_val+%%3] %endif neg len mul mlt add cry,rax ; initial carry, becomes low carry adc rdx,byte 0 mov cry_hi,rdx test len,1 mov rax,[src+8] ; src second limb lea src,[src+len*8+off+16] lea dst,[dst+len*8+off] cmovnz cry_hi,cry ; high, low carry other way around cmovnz cry,rdx xor len,len jmp jmp_val %%3: %define CHUNK_COUNT 2 %assign i 0 %rep UNROLL_COUNT / CHUNK_COUNT %assign disp0 8 * i * CHUNK_COUNT - off mul mlt %2 [byte dst+disp0],cry mov cry,len ; len = 0 adc cry_hi,rax mov rax,[byte src+disp0] adc cry,rdx mul mlt %2 [byte dst+disp0+8],cry_hi mov cry_hi,len ; len = 0 adc cry,rax mov rax,[byte src+disp0+8] adc cry_hi,rdx %assign i i + 1 %endrep dec rep_cnt lea src,[src+UNROLL_BYTES] lea dst,[dst+UNROLL_BYTES] jns %%3 mul mlt %2 [dst-off],cry adc rax,cry_hi adc rdx,len %2 [dst-off+8],rax adc rdx,len mov rax,rdx pop rsi pop rbx pop rbp ret %endmacro bits 64 text mac_sub __g,add,mpn_addmul_1,mpn_addmul_1c mac_sub __g,sub,mpn_submul_1,mpn_submul_1c end ecl-16.1.2/msvc/gmp/mpn/amd64i/copyd.asm000077500000000000000000000053721266352375300176230ustar00rootroot00000000000000 ; AMD64 mpn_copyd -- decrementing copy limb vector ; ; Copyright 1999, 2000, 2001, 2002 Free Software Foundation, Inc. ; ; This file is part of the GNU MP Library. ; ; The GNU MP Library is free software; you can redistribute it and/or ; modify it under the terms of the GNU Lesser General Public License as ; published by the Free Software Foundation; either version 2.1 of the ; License, or (at your option) any later version. ; ; The GNU MP Library is distributed in the hope that it will be useful, ; but WITHOUT ANY WARRANTY; without even the implied warranty of ; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ; Lesser General Public License for more details. ; ; You should have received a copy of the GNU Lesser General Public ; License along with the GNU MP Library; see the file COPYING.LIB. If ; not, write to the Free Software Foundation, Inc., 59 Temple Place - ; Suite 330, Boston, MA 02111-1307, USA. ; ; Provided by Brian Gladman AMD64 using the Microsoft VC++ v8 64-bit ; compiler and the YASM assembler. ; ; Calling interface: ; ; void mpn_copyd( ; mp_ptr dst, rcx ; mp_srcptr src, rdx ; mp_size_t size r8 ; ) %define UNROLL_THRESHOLD 16 %define d_ptr rcx %define s_ptr rdx %define s_len r8 bits 64 text global __gmpn_copyd %ifdef DLL export __gmpn_copyd %endif __gmpn_copyd: movsxd s_len,r8d cmp s_len,byte UNROLL_THRESHOLD jge .2 ; if many limbs to move dec s_len jl .1 .0: mov rax,[s_ptr+s_len*8] ; short move via rax mov [d_ptr+s_len*8],rax dec s_len jge .0 ; avoid single byte ret that .1: rep ret ; interferes with branch prediction .2: mov rax,s_ptr ; find relative alignment of xor rax,d_ptr ; source and destination (min test al,8 jnz .7 ; not 16 byte aligned lea rax,[s_ptr+s_len*8] test al,8 ; see if src is on 16 byte jz .3 ; boundary dec s_len mov rax,[rax-8] ; if not do a one limb copy mov [d_ptr+s_len*8],rax .3: lea s_len,[s_len-4] ; now 16 byte aligned .4: prefetchnta [s_ptr+s_len*8+16-3*64] ; should this be -4*64 ?? movdqa xmm0,[s_ptr+s_len*8+16] ; move 32 bytes at a time movntdq [d_ptr+s_len*8+16],xmm0 movdqa xmm0,[s_ptr+s_len*8] movntdq [d_ptr+s_len*8],xmm0 sub s_len,4 jge .4 sfence test s_len,2 jz .5 movdqa xmm0,[s_ptr+s_len*8+16] ; move 16 bytes if necessary movdqa [d_ptr+s_len*8+16],xmm0 .5 test s_len,1 jz .6 movq xmm0,[s_ptr] ; move 8 bytes if necessary movq [d_ptr],xmm0 .6: ret .7: lea s_len,[s_len-2] ; move 8 bytes at a time .8: movq xmm0,[s_ptr+s_len*8+8] movq xmm1,[s_ptr+s_len*8] movq [d_ptr+s_len*8+8],xmm0 movq [d_ptr+s_len*8],xmm1 sub s_len,2 jge .8 test s_len,1 jz .9 movq xmm0,[s_ptr] movq [d_ptr],xmm0 .9: ret end ecl-16.1.2/msvc/gmp/mpn/amd64i/copyi.asm000077500000000000000000000056361266352375300176330ustar00rootroot00000000000000 ; AMD64 mpn_copyi -- incrementing copy limb vector ; ; Copyright 1999, 2000, 2001, 2002 Free Software Foundation, Inc. ; ; This file is part of the GNU MP Library. ; ; The GNU MP Library is free software; you can redistribute it and/or ; modify it under the terms of the GNU Lesser General Public License as ; published by the Free Software Foundation; either version 2.1 of the ; License, or (at your option) any later version. ; ; The GNU MP Library is distributed in the hope that it will be useful, ; but WITHOUT ANY WARRANTY; without even the implied warranty of ; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ; Lesser General Public License for more details. ; ; You should have received a copy of the GNU Lesser General Public ; License along with the GNU MP Library; see the file COPYING.LIB. If ; not, write to the Free Software Foundation, Inc., 59 Temple Place - ; Suite 330, Boston, MA 02111-1307, USA. ; ; Provided by Brian Gladman AMD64 using the Microsoft VC++ v8 64-bit ; compiler and the YASM assembler. ; ; Calling interface: ; ; void mpn_copyi( ; mp_ptr dst, rcx ; mp_srcptr src, rdx ; mp_size_t size r8 ; ) %define UNROLL_THRESHOLD 16 %define d_ptr rcx %define s_ptr rdx %define s_len r8 bits 64 text global __gmpn_copyi %ifdef DLL export __gmpn_copyi %endif __gmpn_copyi: movsxd s_len,r8d or s_len,s_len ; none to move? jz .1 mov rax,s_ptr ; find relative alignment of xor rax,d_ptr ; source and destination (min mov r9,s_ptr ; 8-byte alignment assumed) lea s_ptr,[s_ptr+s_len*8] lea d_ptr,[d_ptr+s_len*8] neg s_len cmp s_len,byte -UNROLL_THRESHOLD jbe .2 ; if many limbs to move .0: mov rax,[s_ptr+s_len*8] ; short move via rax mov [d_ptr+s_len*8],rax inc s_len jnz .0 ; avoid single byte ret that .1: rep ret ; interferes with branch prediction .2: test al,8 jnz .7 ; not 16 byte aligned test r9,8 ; see if src is on 16 byte jz .3 ; boundary mov rax,[s_ptr+s_len*8] ; if not do a one limb copy mov [d_ptr+s_len*8],rax inc s_len .3: lea s_len,[s_len+3] ; now 16 byte aligned .4: prefetchnta [s_ptr+s_len*8-24+3*64] ; should this be +4*64 ?? movdqa xmm0,[s_ptr+s_len*8-24] ; move 32 bytes at a time movntdq [d_ptr+s_len*8-24],xmm0 movdqa xmm0,[s_ptr+s_len*8-8] movntdq [d_ptr+s_len*8-8],xmm0 add s_len,4 jl .4 sfence test s_len,2 jnz .5 movdqa xmm0,[s_ptr+s_len*8-24] ; move 16 bytes if necessary movdqa [d_ptr+s_len*8-24],xmm0 add s_len,2 .5 test s_len,1 jnz .6 movq xmm0,[s_ptr+s_len*8-24] ; move 8 bytes if necessary movq [d_ptr+s_len*8-24],xmm0 .6: ret .7: lea s_len,[s_len+1] ; move 8 bytes at a time .8: movq xmm0,[s_ptr+s_len*8-8] movq xmm1,[s_ptr+s_len*8] movq [d_ptr+s_len*8-8],xmm0 movq [d_ptr+s_len*8],xmm1 add s_len,2 jl .8 test s_len,1 jnz .9 movq xmm0,[s_ptr-8] movq [d_ptr-8],xmm0 .9: ret end ecl-16.1.2/msvc/gmp/mpn/amd64i/dive_1.asm000077500000000000000000000072271266352375300176550ustar00rootroot00000000000000; ; AMD64 mpn_divexact_1 -- mpn by limb exact division ; ; Copyright 1999, 2000, 2001, 2002 Free Software Foundation, Inc. ; ; This file is part of the GNU MP Library. ; ; The GNU MP Library is free software; you can redistribute it and/or ; modify it under the terms of the GNU Lesser General Public License as ; published by the Free Software Foundation; either version 2.1 of the ; License, or (at your option) any later version. ; ; The GNU MP Library is distributed in the hope that it will be useful, ; but WITHOUT ANY WARRANTY; without even the implied warranty of ; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ; Lesser General Public License for more details. ; ; You should have received a copy of the GNU Lesser General Public ; License along with the GNU MP Library; see the file COPYING.LIB. If ; not, write to the Free Software Foundation, Inc., 59 Temple Place - ; Suite 330, Boston, MA 02111-1307, USA. ; ; Adapted by Brian Gladman AMD64 using the Microsoft VC++ v8 64-bit ; compiler and the YASM assembler. ; ; Calling interface: ; ; void mpn_divexact_1( ; mp_ptr dst, rcx ; mp_srcptr src, rdx ; mp_size_t size, r8 ; mp_limb_t divisor r9 ; ) ; ; since the inverse takes a while to setup,plain division is used for small ; Multiplying works out faster for size>=3 when the divisor is odd or size>=4 ; when the divisor is even. bits 64 text extern __gmp_modlimb_invert_table global __gmpn_divexact_1 %ifdef DLL export __gmpn_divexact_1 %endif __gmpn_divexact_1: movsxd r8,r8d mov r10,rdx mov rax,r9 and rax,byte 1 add rax,r8 cmp rax,byte 4 jae L_mul_by_inverse xor rdx,rdx L_div_top: mov rax,[r10+r8*8-8] div r9 mov [rcx+r8*8-8],rax dec r8 jnz L_div_top rep ret ; avoid single byte return L_mul_by_inverse: push rsi push rdi mov rsi,rdx ; src pointer mov rdi,rcx ; dst pointer mov rax,r9 stc sbb rcx,rcx ; -1 -> rcx, r11 mov r11,rcx L_strip_twos: shr rax,1 inc rcx jnc L_strip_twos lea r9,[rax+rax+1] and rax,byte 127 lea rdx,[__gmp_modlimb_invert_table wrt rip] movzx rax,byte [rdx+rax] ; If f(x) = 0, then x[n+1] = x[n] - f(x) / f'(x) is Newton's iteration for a ; root. With f(x) = 1/x - v we obtain x[n + 1] = 2 * x[n] - v * x[n] * x[n] ; as an iteration for x = 1 / v. This provides quadratic convergence so ; that the number of bits of precision doubles on each iteration. The ; iteration starts with 8-bit precision. lea edx, [rax+rax] imul eax, eax imul eax, r9d sub edx, eax ; inv -> rdx (16-bit approx) lea eax, [rdx+rdx] imul edx, edx imul edx, r9d sub eax, edx ; inv -> rcx (32-bit approx) lea rdx, [rax+rax] imul rax, rax imul rax, r9 sub rdx, rax ; inv -> rcx (64-bit approx) mov r8,r8 lea rsi,[rsi+r8*8] lea rdi,[rdi+r8*8] neg r8 mov r10,rdx xor r11,r11 mov rax,[rsi+r8*8] or rcx,rcx mov rdx,[rsi+r8*8+8] jz L_odd_entry shrd rax,rdx,cl inc r8 jmp L_even_entry L_odd_top: mul r9 mov rax,[rsi+r8*8] sub rdx,r11 sub rax,rdx sbb r11,r11 L_odd_entry: imul rax,r10 mov [rdi+r8*8],rax inc r8 jnz L_odd_top pop rdi pop rsi ret L_even_top: mul r9 sub rdx,r11 mov rax,[rsi+r8*8-8] mov r11,[rsi+r8*8] shrd rax,r11,cl sub rax,rdx sbb r11,r11 L_even_entry: imul rax,r10 mov [rdi+r8*8-8],rax inc r8 jnz L_even_top mul r9 mov rax,[rsi-8] sub rdx,r11 shr rax,cl sub rax,rdx imul rax,r10 mov [rdi-8],rax pop rdi pop rsi ret end ecl-16.1.2/msvc/gmp/mpn/amd64i/gmp-mparam.h000077500000000000000000000030701266352375300202030ustar00rootroot00000000000000/* Generic x86 gmp-mparam.h -- Compiler/machine parameter header file. Copyright 1991, 1993, 1994, 2000, 2001, 2002 Free Software Foundation, Inc. This file is part of the GNU MP Library. The GNU MP Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU MP Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU MP Library; see the file COPYING.LIB. If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #ifndef GMP_MPARAM_H #define GMP_MPARAM_H #ifndef BITS_PER_MP_LIMB #define BITS_PER_MP_LIMB 64 #elif BITS_PER_MP_LIMB != 64 #error Bad configuration in gmp-mparam.h #endif #ifndef BYTES_PER_MP_LIMB #define BYTES_PER_MP_LIMB 8 #elif BYTES_PER_MP_LIMB != 8 #error Bad configuration in gmp-mparam.h #endif /* Generic x86 mpn_divexact_1 is faster than generic x86 mpn_divrem_1 on all of p5, p6, k6 and k7, so use it always. It's probably slower on 386 and 486, but that's too bad. */ #define DIVEXACT_1_THRESHOLD 0 #define SQR_KARATSUBA_THRESHOLD 33 #define MUL_KARATSUBA_THRESHOLD 26 #define MUL_TOOM3_THRESHOLD 298 #endif ecl-16.1.2/msvc/gmp/mpn/amd64i/lshift.asm000077500000000000000000000035701266352375300177740ustar00rootroot00000000000000 ; AMD64 mpn_lshift -- mpn left shift ; ; Copyright 1999, 2000, 2001, 2002 Free Software Foundation, Inc. ; ; This file is part of the GNU MP Library. ; ; The GNU MP Library is free software; you can redistribute it and/or ; modify it under the terms of the GNU Lesser General Public License as ; published by the Free Software Foundation; either version 2.1 of the ; License, or (at your option) any later version. ; ; The GNU MP Library is distributed in the hope that it will be useful, ; but WITHOUT ANY WARRANTY; without even the implied warranty of ; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ; Lesser General Public License for more details. ; ; You should have received a copy of the GNU Lesser General Public ; License along with the GNU MP Library; see the file COPYING.LIB. If ; not, write to the Free Software Foundation, Inc., 59 Temple Place - ; Suite 330, Boston, MA 02111-1307, USA. ; ; Adapted by Brian Gladman AMD64 using the Microsoft VC++ v8 64-bit ; compiler and the YASM assembler. ; ; Calling interface: ; ; mp_limb_t mpn_lshift( ; mp_ptr dst, rcx ; mp_srcptr src, rdx ; mp_size_t size, r8 ; unsigned shift r9 ; ) %define s_len r8 %define r_tmp r9 %define d_ptr r10 %define s_ptr r11 bits 64 text global __gmpn_lshift %ifdef DLL export __gmpn_lshift %endif __gmpn_lshift: movsxd s_len,r8d or s_len,s_len jz .0 mov d_ptr,rcx mov s_ptr,rdx mov rcx,r9 cmp s_len,byte 2 jge .1 or s_len,s_len mov rax,[s_ptr] mov r_tmp,rax shl r_tmp,cl neg cl mov [d_ptr],r_tmp shr rax,cl .0: ret .1: dec s_len mov rdx,[s_ptr+s_len*8] push rdx .2: mov rax,[s_ptr+s_len*8-8] mov r_tmp,rax shl rdx,cl neg cl shr r_tmp,cl neg cl or r_tmp,rdx mov rdx,rax mov [d_ptr+s_len*8],r_tmp dec s_len jnz .2 shl rax,cl mov [d_ptr],rax neg cl pop rax shr rax,cl ret ecl-16.1.2/msvc/gmp/mpn/amd64i/mode1o.asm000077500000000000000000000103761266352375300176710ustar00rootroot00000000000000; AMD64 mpn_modexact_1_odd -- exact division style remainder. ; Copyright 2000, 2001, 2002, 2003, 2004, 2005, 2006 Free Software ; Foundation, Inc. ; ; This file is part of the GNU MP Library. ; ; The GNU MP Library is free software; you can redistribute it and/or ; modify it under the terms of the GNU Lesser General Public License as ; published by the Free Software Foundation; either version 2.1 of the ; License, or (at your option) any later version. ; ; The GNU MP Library is distributed in the hope that it will be useful, ; but WITHOUT ANY WARRANTY; without even the implied warranty of ; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ; Lesser General Public License for more details. ; ; You should have received a copy of the GNU Lesser General Public ; License along with the GNU MP Library; see the file COPYING.LIB. If ; not, write to the Free Software Foundation, Inc., 51 Franklin Street, ; Fifth Floor, Boston, MA 02110-1301, USA. ; ; cycles/limb ; Hammer: 10 ; Prescott/Nocona: 33 ; mp_limb_t mpn_modexact_1_odd (mp_srcptr src, mp_size_t size, ; mp_limb_t divisor); ; mp_limb_t mpn_modexact_1c_odd (mp_srcptr src, mp_size_t size, ; mp_limb_t divisor, mp_limb_t carry); ; ; The dependent chain in the main loop is ; ; cycles ; subq %r8, %rax 1 ; imulq %r9, %rax 4 ; mulq %rsi 5 ; ---- ; total 10 ; ; The movq load from src seems to need to be scheduled back before the jz to ; achieve this speed, out-of-order execution apparently can't completely ; hide the latency otherwise. ; ; The l=src[i]-cbit step is rotated back too, since that allows us to avoid ; it for the first iteration (where there's no cbit). ; ; The code alignment used (32-byte) for the loop also seems necessary. ; Without that the non-PIC case has adcq crossing the 0x60 offset, ; apparently making it run at 11 cycles instead of 10. ; ; Not done: ; ; divq for size==1 was measured at about 79 cycles, compared to the inverse ; at about 25 cycles (both including function call overheads), so that's not ; used. ; ; Enhancements: ; ; For PIC, we shouldn't really need the GOT fetch for modlimb_invert_table, ; it'll be in rodata or text in libgmp.so and can be accessed directly %rip ; relative. This would be for small model only (something we don't ; presently detect, but which is all that gcc 3.3.3 supports), since 8-byte ; PC-relative relocations are apparently not available. Some rough ; experiments with binutils 2.13 looked worrylingly like it might come out ; with an unwanted text segment relocation though, even with ".protected". ; mp_limb_t mpn_modexact_1_odd ( ; mp_srcptr src, rcx ; mp_size_t size, rdx ; mp_limb_t divisor r8 ; ); ; mp_limb_t mpn_modexact_1c_odd ( ; mp_srcptr src, rcx ; mp_size_t size, rdx ; mp_limb_t divisor, r8 ; mp_limb_t carry r10 ; ); bits 64 text align 32 global __gmpn_modexact_1_odd global __gmpn_modexact_1c_odd extern __gmp_modlimb_invert_table %ifdef DLL export __gmpn_modexact_1_odd export __gmpn_modexact_1c_odd %endif __gmpn_modexact_1_odd: mov r9d, 0 ; carry __gmpn_modexact_1c_odd: push rsi push rdi mov rsi, rdx mov rdx, r8 shr edx, 1 ; div / 2 lea r10, [__gmp_modlimb_invert_table wrt rip] and edx, 127 movzx edx, byte [rdx+r10] ; inv -> rdx (8-bit approx) mov rax, [rcx] lea r11, [rcx+rsi*8] ; pointer to top of src mov rdi, r8 ; save divisor lea ecx, [rdx+rdx] imul edx, edx neg rsi ; limb offset from top of drc imul edx, edi sub ecx, edx ; inv -> rcx (16-bit approx) lea edx, [rcx+rcx] imul ecx, ecx imul ecx, edi sub edx, ecx ; inv -> rdx (32-bit approx) xor ecx, ecx lea r10, [rdx+rdx] imul rdx, rdx imul rdx, r8 sub r10, rdx ; inv -> r10 (64-bit approx) mov rdx, r9 ; intial carry -> rdx inc rsi ; adjust limb offset jz .1 align 16 .0: sub rax, rdx adc rcx, 0 imul rax, r10 mul r8 mov rax, [r11+8*rsi] sub rax, rcx setc cl inc rsi jnz .0 .1: sub rax, rdx adc rcx, 0 imul rax, r10 mul r8 lea rax, [rcx+rdx] pop rdi pop rsi ret end ecl-16.1.2/msvc/gmp/mpn/amd64i/mul_1.asm000077500000000000000000000102341266352375300175130ustar00rootroot00000000000000; ; AMD64 mpn_mul_1 -- mpn by limb multiply. ; ; Copyright 1999, 2000, 2001, 2002 Free Software Foundation, Inc. ; ; This file is part of the GNU MP Library. ; ; The GNU MP Library is free software; you can redistribute it and/or ; modify it under the terms of the GNU Lesser General Public License as ; published by the Free Software Foundation; either version 2.1 of the ; License, or (at your option) any later version. ; ; The GNU MP Library is distributed in the hope that it will be useful, ; but WITHOUT ANY WARRANTY; without even the implied warranty of ; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ; Lesser General Public License for more details. ; ; You should have received a copy of the GNU Lesser General Public ; License along with the GNU MP Library; see the file COPYING.LIB. If ; not, write to the Free Software Foundation, Inc., 59 Temple Place - ; Suite 330, Boston, MA 02111-1307, USA. ; ; Adapted by Brian Gladman AMD64 using the Microsoft VC++ v8 64-bit ; compiler and the YASM assembler. ; ; Calling interface: ; mp_limb_t mpn_mul_1 ( ; mp_ptr dst, rcx ; mp_srcptr src, rdx ; mp_size_t size, r8 ; mp_limb_t multiplier r9 ; ) ; ; mp_limb_t mpn_mul_1c ( ; mp_ptr dst, rcx ; mp_srcptr src, rdx ; mp_size_t size, r8 ; mp_limb_t multiplier, r9 ; mp_limb_t carry [rsp+0x28] ; ) ; ; Multiply src[size] by mult and store the result in dst[size]. Return the ; carry limb from the top of the result. ; ; mpn_mul_1c() accepts an initial carry for the calculation, it's added into ; the low limb of the destination. ; Maximum possible UNROLL_COUNT with the current code is 64. %if 1 %define dst rcx %define len r8 %define mlt r9 %define cry [rsp+0x28] %define src r10 ; from rdx on input %define cnt rbx ; loop count %define UNROLL_LOG2 4 %define UNROLL_COUNT (1 << UNROLL_LOG2) %define UNROLL_MASK (UNROLL_COUNT - 1) %define UNROLL_BYTES 8 * UNROLL_COUNT %if UNROLL_BYTES >= 256 %error unroll count is too large %elif UNROLL_BYTES >= 128 %define off 128 %else %define off 0 %endif %define UNROLL_THRESHOLD 7 bits 64 text global __gmpn_mul_1 global __gmpn_mul_1c %ifdef DLL export __gmpn_mul_1 export __gmpn_mul_1c %define PIC %endif __gmpn_mul_1c: mov r11,[rsp+0x28] jmp start __gmpn_mul_1: xor r11,r11 start: movsxd len,r8d mov src,rdx cmp len,UNROLL_THRESHOLD jae .1 lea src,[src+len*8] lea dst,[dst+len*8] neg len .0: mov rax,[src+len*8] mul mlt add rax,r11 mov r11,dword 0 adc r11,rdx mov [dst+len*8],rax inc len jnz .0 mov rax,r11 ret ; The mov to load the next source limb is done well ahead of the mul, this ; is necessary for full speed. It leads to one limb handled separately ; after the loop. ; ; When unrolling to 32 or more, an offset of +4 is used on the src pointer, ; to avoid having an 0x80 displacement in the code for the last limb in the ; unrolled loop. This is for a fair comparison between 16 and 32 unrolling. .1: push rbx lea cnt,[len-2] lea len,[len-1] neg len shr cnt,UNROLL_LOG2 and len,UNROLL_MASK mov rdx,len shl rdx,4 %ifdef PIC lea rax,[.3 wrt rip] lea rdx,[rdx+len*4] lea rdx,[rdx+rax] %else lea rdx,[rdx+len*4+.3] %endif mov rax,[src] neg len lea src,[src+len*8+off] lea dst,[dst+len*8+off] xor len,len ; len now zero jmp rdx .3: %assign i 0 %rep UNROLL_COUNT %define disp 8 * i - off mul mlt ; 20 bytes per block add r11,rax mov rax,[byte src+disp+8] mov [byte dst+disp],r11 mov r11,len adc r11,rdx %assign i i + 1 %endrep dec cnt lea src,[src+UNROLL_BYTES] lea dst,[dst+UNROLL_BYTES] jns .3 mul mlt add r11,rax mov rax,len mov [dst-off],r11 adc rax,rdx pop rbx ret %else bits 64 text global __gmpn_mul_1 global __gmpn_mul_1c %ifdef DLL export __gmpn_mul_1 export __gmpn_mul_1c %endif __gmpn_mul_1c: mov r11, [rsp+0x28] jmp start align 16 nop nop __gmpn_mul_1: xor r11, r11 start: lea r10, [rdx+8*r8] lea rcx, [rcx+8*r8] neg r8 .1: mov rax, [r10+8*r8] mul r9 add rax, r11 mov r11d, 0 adc r11, rdx mov [rcx+8*r8], rax inc r8 jne .1 mov rax, r11 ret %endif end ecl-16.1.2/msvc/gmp/mpn/amd64i/mul_basecase.asm000077500000000000000000000155171266352375300211320ustar00rootroot00000000000000; ; AMD64 mpn_mul_basecase -- multiply two mpn numbers. ; ; Copyright 1999, 2000, 2001, 2002 Free Software Foundation, Inc. ; ; This file is part of the GNU MP Library. ; ; The GNU MP Library is free software; you can redistribute it and/or ; modify it under the terms of the GNU Lesser General Public License as ; published by the Free Software Foundation; either version 2.1 of the ; License, or (at your option) any later version. ; ; The GNU MP Library is distributed in the hope that it will be useful, ; but WITHOUT ANY WARRANTY; without even the implied warranty of ; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ; Lesser General Public License for more details. ; ; You should have received a copy of the GNU Lesser General Public ; License along with the GNU MP Library; see the file COPYING.LIB. If ; not, write to the Free Software Foundation, Inc., 59 Temple Place - ; Suite 330, Boston, MA 02111-1307, USA. ; ; Adapted by Brian Gladman AMD64 using the Microsoft VC++ v8 64-bit ; compiler and the YASM assembler. ; ; Calling interface: ; ; void __gmpn_mul_basecase( ; mp_ptr rp, rcx ; mp_srcptr xp, rdx ; mp_size_t xn, r8 ; mp_srcptr yp, r9 ; mp_size_t yn [rsp+0x28] as a *** 32-bit *** word ; ) ; ; Multiply up[un] by vp[vn] and write the result to rp[un+vn] with un >= vn on ; entry. %include "amd64i.inc" %define UNROLL_LOG2 4 %define UNROLL_COUNT (1 << UNROLL_LOG2) %define UNROLL_MASK (UNROLL_COUNT - 1) %define UNROLL_BYTES (8 * UNROLL_COUNT) %define UNROLL_THRESHOLD 5 bits 64 text %define v_par rsp + 16 %define v_adj rsp + 8 %define v_xlo rsp %define v_len 24 %define r_ptr rcx %define x_ptr r11 %define x_len r8 %define y_ptr r9 %define y_len r10 %define v_ctr r8 ; x_len reused %define v_jmp r11 ; x_ptr reused %define reg_list x86_regs,r12 global __gmpn_mul_basecase %ifdef DLL export __gmpn_mul_basecase %define PIC %endif __gmpn_mul_basecase: movsxd x_len,r8d mov rax,[y_ptr] cmp x_len,2 ja mul_m_by_n je mul_2_by_n mul qword [rdx] mov [r_ptr],rax mov [r_ptr+8],rdx ret mul_2_by_n: movsxd r10,dword[rsp+0x28] ; load as a 32-bit integer mov x_ptr,rdx dec qword y_len jnz mul_2_by_2 mov r8,rax ; y[0] -> r8 (was x_len) mov rax,[x_ptr] mul r8 mov [r_ptr],rax mov rax,[x_ptr+8] mov r9,rdx ; carry -> r9 (was y_ptr) mul r8 add r9,rax mov [r_ptr+8],r9 adc rdx,y_len ; note: r10 = 0 (was y_len) mov [r_ptr+16],rdx ret mul_2_by_2: ; r8 (x_len) and r10 (y_len) free mov r10,[x_ptr] ; x[0] mul r10 ; y[0] * x[0] mov [r_ptr],rax mov r8,rdx ; cry = { 0, r8 } mov rax,[y_ptr+8] ; y[1] mul r10 ; y[1] * x[0] add r8,rax adc rdx,byte 0 mov r10,[x_ptr+8] ; x[1] - r11 (x_ptr) now free mov r11,rdx ; cry = { r11, r8 } mov rax,[y_ptr] ; y[0] mul r10 ; y[0] * x[1] add r8,rax adc r11,rdx mov [r_ptr+8],r8 mov r8,dword 0 adc r8,r8 ; cry = { r8, r11 } mov rax,[y_ptr+8] ; y[1] mul r10 ; x[1] * y[1] add rax,r11 adc rdx,r8 mov [r_ptr+16],rax mov [r_ptr+24],rdx ret ; do first multiply of y[0] * x[n] as it can simply be stored mul_m_by_n: mov r10d,dword[rsp+0x28] ; load as a 32-bit integer f_push reg_list mov x_ptr,rdx mov r12,x_len mov rbp,rax ; y[0] -> rbp xor rbx,rbx ; for carry lea rsi,[x_ptr+r12*8] ; past end of x[] lea rdi,[r_ptr+r12*8] ; past end of r[] neg r12 .0: mov rax,[rsi+r12*8] ; x[n] mul rbp ; x[n] * y[0] add rax,rbx ; add carry from previous round mov [rdi+r12*8],rax ; store r[n] mov rbx,dword 0 ; propagate carry adc rbx,rdx inc r12 ; next iteration jnz .0 mov [rdi],rbx ; store final digit in carry mov rdx,y_len ; done if y_len is 1 dec rdx jnz .1 ; more to do f_pop reg_list ret .1: cmp x_len,UNROLL_THRESHOLD ; unroll if many loops jae L_unroll lea y_ptr,[y_ptr+rdx*8+8] ; pointer to end limb of y[] neg x_len ; negative counter for x[n] neg rdx ; negative counter for y[n] mov rax,[rsi+x_len*8] ; x[0] -> rax mov y_len,rdx ; now -(y_len - 1) inc x_len ; negative counter for x[1] xor rbx,rbx ; for carry mov rcx,x_len ; now -(x_len - 1) -> rcx (was r_ptr) mov rbp,[y_ptr+rdx*8] ; y[n] -> rbp jmp .3 .2: mov rcx,x_len ; restore x[] counter xor rbx,rbx ; clear carry add rdi,8 ; increase end of r[] pointer mov rbp,[y_ptr+y_len*8] ; y[n] -> rbp mov rax,[rsi+rcx*8-8] ; x[m] -> rax .3: mul rbp ; x[m] * y[n] add rbx,rax ; add carry adc rdx,byte 0 add [rdi+rcx*8],rbx ; add into r[] mov rax,[rsi+rcx*8] ; next x[m] ->rax adc rdx,byte 0 ; add carry to rdx inc rcx ; got to next limb of x[] mov rbx,rdx ; move carry into rbx jnz .3 ; got to next limb of x[] mul rbp ; do last limb add rbx,rax ; propagate carry adc rdx,byte 0 add [rdi],rbx ; add into r[] adc rdx,byte 0 ; add add in any carry inc y_len mov [rdi+8],rdx ; move (not add) carry into r[] jnz .2 ; go to next limb of y[] f_pop reg_list ret L_unroll: f_add v_len mov rdi,r_ptr mov rcx,x_len mov rsi,x_ptr mov rbp,[y_ptr+8] lea y_ptr,[y_ptr+rdx*8+8] neg rdx mov y_len,rdx lea rbx,[UNROLL_COUNT-2+rcx] dec rcx mov rax,[rsi] ; x[0] and rbx,-UNROLL_MASK-1 neg rcx neg rbx and rcx,UNROLL_MASK mov [v_par],rcx mov [v_adj],rbx mov rdx,rcx shl rcx,3 %ifdef PIC lea rcx,[rcx+rcx*2] lea v_jmp,[.4 wrt rip] lea v_jmp,[v_jmp+rcx] %else lea v_jmp,[rcx+rcx*2+.4] %endif neg rdx mov [v_xlo],rax lea rdi,[rdi+rdx*8+8] lea rsi,[rsi+rdx*8+8] jmp .3 .2: mov rbx,[v_adj] mov rax,[v_xlo] lea rdi,[rdi+rbx*8+8] lea rsi,[rsi+rbx*8] mov rbp,[y_ptr+y_len*8] .3: mul rbp sar rbx,UNROLL_LOG2 mov rcx,[v_par] mov v_ctr,rbx test cl,1 ; low word of product + carry mov rbx,dword 0 ; is in rcx on even rounds and mov rcx,dword 0 ; rbx on odd rounds - we must cmovz rcx,rax ; put low word of first product cmovnz rbx,rax ; in the right register here jmp v_jmp .4: %define CHUNK_COUNT 2 %assign i 0 %rep UNROLL_COUNT / CHUNK_COUNT %define disp0 8 * i * CHUNK_COUNT mov rax,[byte rsi+disp0] adc rbx,rdx mul rbp add [byte rdi+disp0],rcx mov rcx,dword 0 adc rbx,rax mov rax,[byte rsi+disp0+8] adc rcx,rdx mul rbp add [byte rdi+disp0+8],rbx mov rbx,dword 0 adc rcx,rax %assign i i + 1 %endrep inc v_ctr lea rsi,[UNROLL_BYTES+rsi] lea rdi,[UNROLL_BYTES+rdi] jnz .4 adc rdx,byte 0 add [rdi],rcx adc rdx,byte 0 inc y_len mov [rdi+8],rdx jnz .2 f_sub v_len f_pop reg_list ret end ecl-16.1.2/msvc/gmp/mpn/amd64i/rshift.asm000077500000000000000000000036571266352375300200100ustar00rootroot00000000000000 ; AMD64 mpn_rshift -- mpn right shift ; ; Copyright 1999, 2000, 2001, 2002 Free Software Foundation, Inc. ; ; This file is part of the GNU MP Library. ; ; The GNU MP Library is free software; you can redistribute it and/or ; modify it under the terms of the GNU Lesser General Public License as ; published by the Free Software Foundation; either version 2.1 of the ; License, or (at your option) any later version. ; ; The GNU MP Library is distributed in the hope that it will be useful, ; but WITHOUT ANY WARRANTY; without even the implied warranty of ; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ; Lesser General Public License for more details. ; ; You should have received a copy of the GNU Lesser General Public ; License along with the GNU MP Library; see the file COPYING.LIB. If ; not, write to the Free Software Foundation, Inc., 59 Temple Place - ; Suite 330, Boston, MA 02111-1307, USA. ; ; Adapted by Brian Gladman AMD64 using the Microsoft VC++ v8 64-bit ; compiler and the YASM assembler. ; ; Calling interface: ; ; mp_limb_t mpn_rshift( ; mp_ptr dst, rcx ; mp_srcptr src, rdx ; mp_size_t size, r8 ; unsigned shift r9 ; ) %define s_len r8 %define r_tmp r9 %define d_ptr r10 %define s_ptr r11 bits 64 text global __gmpn_rshift %ifdef DLL export __gmpn_rshift %endif __gmpn_rshift: movsxd s_len,r8d or s_len,s_len jz .0 mov d_ptr,rcx mov s_ptr,rdx mov rcx,r9 cmp s_len,byte 2 jge .1 mov rax,[s_ptr] mov r_tmp,rax shr r_tmp,cl neg cl mov [d_ptr],r_tmp shl rax,cl .0: ret .1: lea s_ptr,[s_ptr+s_len*8] lea d_ptr,[d_ptr+s_len*8] neg s_len mov rdx,[s_ptr+s_len*8] push rdx shr rdx,cl neg cl inc s_len .2: mov rax,[s_ptr+s_len*8] mov r_tmp,rax shl r_tmp,cl neg cl xor r_tmp,rdx shr rax,cl neg cl mov rdx,rax mov [d_ptr+s_len*8-8],r_tmp inc s_len jnz .2 mov [d_ptr-8],rax pop rax shl rax,cl ret ecl-16.1.2/msvc/gmp/mpn/amd64i/sqr_basecase.asm000077500000000000000000000140201266352375300211260ustar00rootroot00000000000000; ; AMD64 mpn_sqr_basecase -- square an mpn number. ; ; Copyright 1999, 2000, 2001, 2002 Free Software Foundation, Inc. ; ; This file is part of the GNU MP Library. ; ; The GNU MP Library is free software; you can redistribute it and/or ; modify it under the terms of the GNU Lesser General Public License as ; published by the Free Software Foundation; either version 2.1 of the ; License, or (at your option) any later version. ; ; The GNU MP Library is distributed in the hope that it will be useful, ; but WITHOUT ANY WARRANTY; without even the implied warranty of ; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ; Lesser General Public License for more details. ; ; You should have received a copy of the GNU Lesser General Public ; License along with the GNU MP Library; see the file COPYING.LIB. If ; not, write to the Free Software Foundation, Inc., 59 Temple Place - ; Suite 330, Boston, MA 02111-1307, USA. ; ; Adapted by Brian Gladman AMD64 using the Microsoft VC++ v8 64-bit ; compiler and the YASM assembler. ; ; Calling interface: ; ; void mpn_sqr_basecase( ; mp_ptr dst, rcx ; mp_srcptr src, rdx ; mp_size_t size r8 ; ) ; %include "amd64i.inc" %define UNROLL_COUNT 31 %define CODE_BYTES_PER_LIMB 25 ; must be odd %if UNROLL_COUNT > 15 %define off (UNROLL_COUNT - 15) * 8 %else %define off 0 %endif %define reg_list_2 x86_regs,r12,r13 %define r_ptr r10 %define x_ptr r9 %define x_len r8 %define v_ctr r12 %define v_jmp r13 bits 64 text global __gmpn_sqr_basecase %ifdef DLL export __gmpn_sqr_basecase %define PIC %endif __gmpn_sqr_basecase: movsxd x_len,r8d cmp x_len,2 je sqr_2 ja sqr_3_plus mov rax,[rdx] mul rax mov [rcx+8],rdx mov [rcx],rax ret sqr_2: mov r_ptr,rcx mov x_ptr,rdx mov r8,[x_ptr] mov r9,[x_ptr+8] mov rax,r8 mul r8 mov [r_ptr],rax mov [r_ptr+8],rdx mov rax,r9 mul r9 mov [r_ptr+16],rax mov [r_ptr+24],rdx xor rcx,rcx mov rax,r8 mul r9 add rax,rax adc rdx,rdx adc rcx,rcx add [r_ptr+8],rax adc [r_ptr+16],rdx adc [r_ptr+24],rcx ret sqr_3_plus: mov r_ptr,rcx mov x_ptr,rdx cmp x_len,4 jae sqr_4_plus f_push x86_regs mov rax,[x_ptr] mul rax mov [r_ptr],rax mov rax,[x_ptr+8] mov [r_ptr+8],rdx mul rax mov [r_ptr+16],rax mov rax,[x_ptr+16] mov [r_ptr+24],rdx mul rax mov [r_ptr+32],rax mov rax,[x_ptr] mov [r_ptr+40],rdx mul qword [x_ptr+8] mov rsi,rax mov rax,[x_ptr] mov rdi,rdx mul qword [x_ptr+16] add rdi,rax mov rbp,dword 0 mov rax,[x_ptr+8] adc rbp,rdx mul qword [x_ptr+16] xor x_ptr,x_ptr add rbp,rax adc rdx,dword 0 adc rdx,dword 0 add rsi,rsi adc rdi,rdi mov rax,[r_ptr+8] adc rbp,rbp adc rdx,rdx adc x_ptr,dword 0 add rsi,rax mov rax,[r_ptr+16] adc rdi,rax mov rax,[r_ptr+24] mov [r_ptr+8],rsi adc rbp,rax mov rax,[r_ptr+32] mov [r_ptr+16],rdi adc rdx,rax mov rax,[r_ptr+40] mov [r_ptr+24],rbp adc rax,x_ptr mov [r_ptr+32],rdx mov [r_ptr+40],rax f_pop x86_regs ret sqr_4_plus: f_push reg_list_2 mov rcx,x_len lea rdi,[r_ptr+rcx*8] lea rsi,[x_ptr+rcx*8] mov rbp,[x_ptr] mov rbx,dword 0 dec rcx neg rcx .0: mov rax,[rsi+rcx*8] mul rbp add rax,rbx mov [rdi+rcx*8],rax mov rbx,dword 0 adc rbx,rdx inc rcx jnz .0 mov rcx,x_len mov [rdi],rbx sub rcx,4 jz L_corner neg rcx %if off != 0 sub rdi,off sub rsi,off %endif mov rdx,rcx shl rcx,3 lea rcx,[rcx+rcx*2] %ifdef PIC lea v_jmp,[.3 wrt rip] lea rcx,[rcx+rdx+(UNROLL_COUNT - 2) * CODE_BYTES_PER_LIMB] lea rcx,[rcx+v_jmp] %else lea rcx,[rcx+rdx+(UNROLL_COUNT - 2) * CODE_BYTES_PER_LIMB+.3] %endif .2: lea v_jmp,[rcx+CODE_BYTES_PER_LIMB] mov rbp,[rsi+rdx*8-24+off] mov rax,[rsi+rdx*8-16+off] mov v_ctr,rdx mul rbp test cl,1 mov rbx,rdx mov rcx,rax %if (UNROLL_COUNT % 2) cmovnz rbx,rax cmovnz rcx,rdx %else cmovz rbx,rax cmovz rcx,rdx %endif xor rdx,rdx lea rdi,[rdi+8] jmp v_jmp align 2 .3: %assign i UNROLL_COUNT %rep UNROLL_COUNT %define disp_src off - 8 * i %if disp_src < -120 || disp_src >= 128 %error source dispacement too large %endif %if (i % 2) = 0 ; 25 bytes of code per limb nop mov rax,[byte rsi + disp_src] adc rbx,rdx mul rbp add [byte rdi + disp_src - 8],rcx mov rcx,dword 0 adc rbx,rax %else nop mov rax,[byte rsi + disp_src] adc rcx,rdx mul rbp add [byte rdi + disp_src - 8],rbx %if i != 1 mov rbx,dword 0 %endif adc rcx,rax %endif %assign i i - 1 %endrep adc rdx,dword 0 add [rdi-8+off],rcx mov rcx,v_jmp adc rdx,dword 0 mov [rdi+off],rdx mov rdx,v_ctr inc rdx jnz .2 %if off != 0 add rsi,off add rdi,off %endif L_corner: mov rbp,[rsi-24] mov rax,[rsi-16] mov rcx,rax mul rbp add [rdi-8],rax mov rax,[rsi-8] adc rdx,dword 0 mov rbx,rdx mov rsi,rax mul rbp add rax,rbx adc rdx,dword 0 add [rdi],rax mov rax,rsi adc rdx,dword 0 mov rbx,rdx mul rcx add rax,rbx mov [rdi+8],rax adc rdx,dword 0 mov [rdi+16],rdx mov rax,x_len ; start of shift mov rdi,r_ptr xor rcx,rcx lea r11,[rax+rax] lea rdi,[rdi+r11*8] not rax lea rax,[rax+2] .0: lea r11,[rax+rax] rcl qword [rdi+r11*8-8],1 rcl qword [rdi+r11*8],1 inc rax jnz .0 setc al mov rsi,x_ptr mov [rdi-8],rax mov rcx,x_len mov rax,[rsi] mul rax lea rsi,[rsi+rcx*8] neg rcx lea r11,[rcx+rcx] mov [rdi+r11*8],rax inc rcx .1: lea r11,[rcx+rcx] mov rax,[rsi+rcx*8] mov rbx,rdx mul rax add [rdi+r11*8-8],rbx adc [rdi+r11*8],rax adc rdx,dword 0 inc rcx jnz .1 add [rdi-8],rdx f_pop reg_list_2 ret end ecl-16.1.2/msvc/gmp/mpn/generic/000077500000000000000000000000001266352375300163215ustar00rootroot00000000000000ecl-16.1.2/msvc/gmp/mpn/generic/addsub_n.c000077500000000000000000000121051266352375300202460ustar00rootroot00000000000000/* mpn_addsub_n -- Add and Subtract two limb vectors of equal, non-zero length. Copyright 1999, 2000, 2001 Free Software Foundation, Inc. This file is part of the GNU MP Library. The GNU MP Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU MP Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU MP Library; see the file COPYING.LIB. If not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ #include "gmp.h" #include "gmp-impl.h" #ifndef L1_CACHE_SIZE #define L1_CACHE_SIZE 8192 /* only 68040 has less than this */ #endif #define PART_SIZE (L1_CACHE_SIZE / BYTES_PER_MP_LIMB / 6) /* mpn_addsub_n. r1[] = s1[] + s2[] r2[] = s1[] - s2[] All operands have n limbs. In-place operations allowed. */ mp_limb_t mpn_addsub_n (mp_ptr r1p, mp_ptr r2p, mp_srcptr s1p, mp_srcptr s2p, mp_size_t n) { mp_limb_t acyn, acyo; /* carry for add */ mp_limb_t scyn, scyo; /* carry for subtract */ mp_size_t off; /* offset in operands */ mp_size_t this_n; /* size of current chunk */ /* We alternatingly add and subtract in chunks that fit into the (L1) cache. Since the chunks are several hundred limbs, the function call overhead is insignificant, but we get much better locality. */ /* We have three variant of the inner loop, the proper loop is chosen depending on whether r1 or r2 are the same operand as s1 or s2. */ if (r1p != s1p && r1p != s2p) { /* r1 is not identical to either input operand. We can therefore write to r1 directly, without using temporary storage. */ acyo = 0; scyo = 0; for (off = 0; off < n; off += PART_SIZE) { this_n = MIN (n - off, PART_SIZE); #if HAVE_NATIVE_mpn_add_nc acyo = mpn_add_nc (r1p + off, s1p + off, s2p + off, this_n, acyo); #else acyn = mpn_add_n (r1p + off, s1p + off, s2p + off, this_n); acyo = acyn + mpn_add_1 (r1p + off, r1p + off, this_n, acyo); #endif #if HAVE_NATIVE_mpn_sub_nc scyo = mpn_sub_nc (r2p + off, s1p + off, s2p + off, this_n, scyo); #else scyn = mpn_sub_n (r2p + off, s1p + off, s2p + off, this_n); scyo = scyn + mpn_sub_1 (r2p + off, r2p + off, this_n, scyo); #endif } } else if (r2p != s1p && r2p != s2p) { /* r2 is not identical to either input operand. We can therefore write to r2 directly, without using temporary storage. */ acyo = 0; scyo = 0; for (off = 0; off < n; off += PART_SIZE) { this_n = MIN (n - off, PART_SIZE); #if HAVE_NATIVE_mpn_sub_nc scyo = mpn_sub_nc (r2p + off, s1p + off, s2p + off, this_n, scyo); #else scyn = mpn_sub_n (r2p + off, s1p + off, s2p + off, this_n); scyo = scyn + mpn_sub_1 (r2p + off, r2p + off, this_n, scyo); #endif #if HAVE_NATIVE_mpn_add_nc acyo = mpn_add_nc (r1p + off, s1p + off, s2p + off, this_n, acyo); #else acyn = mpn_add_n (r1p + off, s1p + off, s2p + off, this_n); acyo = acyn + mpn_add_1 (r1p + off, r1p + off, this_n, acyo); #endif } } else { /* r1 and r2 are identical to s1 and s2 (r1==s1 and r2==s2 or vice versa) Need temporary storage. */ mp_limb_t tp[PART_SIZE]; acyo = 0; scyo = 0; for (off = 0; off < n; off += PART_SIZE) { this_n = MIN (n - off, PART_SIZE); #if HAVE_NATIVE_mpn_add_nc acyo = mpn_add_nc (tp, s1p + off, s2p + off, this_n, acyo); #else acyn = mpn_add_n (tp, s1p + off, s2p + off, this_n); acyo = acyn + mpn_add_1 (tp, tp, this_n, acyo); #endif #if HAVE_NATIVE_mpn_sub_nc scyo = mpn_sub_nc (r2p + off, s1p + off, s2p + off, this_n, scyo); #else scyn = mpn_sub_n (r2p + off, s1p + off, s2p + off, this_n); scyo = scyn + mpn_sub_1 (r2p + off, r2p + off, this_n, scyo); #endif MPN_COPY (r1p + off, tp, this_n); } } return 2 * acyo + scyo; } #ifdef MAIN #include #include #include "timing.h" long cputime (); int main (int argc, char **argv) { mp_ptr r1p, r2p, s1p, s2p; double t; mp_size_t n; n = strtol (argv[1], 0, 0); r1p = malloc (n * BYTES_PER_MP_LIMB); r2p = malloc (n * BYTES_PER_MP_LIMB); s1p = malloc (n * BYTES_PER_MP_LIMB); s2p = malloc (n * BYTES_PER_MP_LIMB); TIME (t,(mpn_add_n(r1p,s1p,s2p,n),mpn_sub_n(r1p,s1p,s2p,n))); printf (" separate add and sub: %.3f\n", t); TIME (t,mpn_addsub_n(r1p,r2p,s1p,s2p,n)); printf ("combined addsub separate variables: %.3f\n", t); TIME (t,mpn_addsub_n(r1p,r2p,r1p,s2p,n)); printf (" combined addsub r1 overlap: %.3f\n", t); TIME (t,mpn_addsub_n(r1p,r2p,r1p,s2p,n)); printf (" combined addsub r2 overlap: %.3f\n", t); TIME (t,mpn_addsub_n(r1p,r2p,r1p,r2p,n)); printf (" combined addsub in-place: %.3f\n", t); return 0; } #endif ecl-16.1.2/msvc/gmp/mpn/generic/divrem_1.c000077500000000000000000000155531266352375300202070ustar00rootroot00000000000000/* mpn_divrem_1 -- mpn by limb division. Copyright 1991, 1993, 1994, 1996, 1998, 1999, 2000, 2002, 2003 Free Software Foundation, Inc. This file is part of the GNU MP Library. The GNU MP Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU MP Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU MP Library; see the file COPYING.LIB. If not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ #include "gmp.h" #include "gmp-impl.h" #include "longlong.h" /* The size where udiv_qrnnd_preinv should be used rather than udiv_qrnnd, meaning the quotient size where that should happen, the quotient size being how many udiv divisions will be done. The default is to use preinv always, CPUs where this doesn't suit have tuned thresholds. Note in particular that preinv should certainly be used if that's the only division available (USE_PREINV_ALWAYS). */ #ifndef DIVREM_1_NORM_THRESHOLD #define DIVREM_1_NORM_THRESHOLD 0 #endif #ifndef DIVREM_1_UNNORM_THRESHOLD #define DIVREM_1_UNNORM_THRESHOLD 0 #endif /* If the cpu only has multiply-by-inverse division (eg. alpha), then NORM and UNNORM thresholds are 0 and only the inversion code is included. If multiply-by-inverse is never viable, then NORM and UNNORM thresholds will be MP_SIZE_T_MAX and only the plain division code is included. Otherwise mul-by-inverse is better than plain division above some threshold, and best results are obtained by having code for both present. The main reason for separating the norm and unnorm cases is that not all CPUs give zero for "n0 >> BITS_PER_MP_LIMB" which would arise in the unnorm code used on an already normalized divisor. If UDIV_NEEDS_NORMALIZATION is false then plain division uses the same non-shifting code for both the norm and unnorm cases, though with different criteria for skipping a division, and with different thresholds of course. And in fact if inversion is never viable, then that simple non-shifting division would be all that's left. The NORM and UNNORM thresholds might not differ much, but if there's going to be separate code for norm and unnorm then it makes sense to have separate thresholds. One thing that's possible is that the mul-by-inverse might be better only for normalized divisors, due to that case not needing variable bit shifts. Notice that the thresholds are tested after the decision to possibly skip one divide step, so they're based on the actual number of divisions done. For the unnorm case, it would be possible to call mpn_lshift to adjust the dividend all in one go (into the quotient space say), rather than limb-by-limb in the loop. This might help if mpn_lshift is a lot faster than what the compiler can generate for EXTRACT. But this is left to CPU specific implementations to consider, especially since EXTRACT isn't on the dependent chain. */ mp_limb_t mpn_divrem_1 (mp_ptr qp, mp_size_t qxn, mp_srcptr up, mp_size_t un, mp_limb_t d) { mp_size_t n; mp_size_t i; mp_limb_t n1, n0; mp_limb_t r = 0; ASSERT (qxn >= 0); ASSERT (un >= 0); ASSERT (d != 0); /* FIXME: What's the correct overlap rule when qxn!=0? */ ASSERT (MPN_SAME_OR_SEPARATE_P (qp+qxn, up, un)); n = un + qxn; if (n == 0) return 0; d <<= GMP_NAIL_BITS; qp += (n - 1); /* Make qp point at most significant quotient limb */ if ((d & GMP_LIMB_HIGHBIT) != 0) { if (un != 0) { /* High quotient limb is 0 or 1, skip a divide step. */ mp_limb_t q; r = up[un - 1] << GMP_NAIL_BITS; q = (r >= d); *qp-- = q; r -= (d & -q); r >>= GMP_NAIL_BITS; n--; un--; } if (BELOW_THRESHOLD (n, DIVREM_1_NORM_THRESHOLD)) { plain: for (i = un - 1; i >= 0; i--) { n0 = up[i] << GMP_NAIL_BITS; udiv_qrnnd (*qp, r, r, n0, d); r >>= GMP_NAIL_BITS; qp--; } for (i = qxn - 1; i >= 0; i--) { udiv_qrnnd (*qp, r, r, CNST_LIMB(0), d); r >>= GMP_NAIL_BITS; qp--; } return r; } else { /* Multiply-by-inverse, divisor already normalized. */ mp_limb_t dinv; invert_limb (dinv, d); for (i = un - 1; i >= 0; i--) { n0 = up[i] << GMP_NAIL_BITS; udiv_qrnnd_preinv (*qp, r, r, n0, d, dinv); r >>= GMP_NAIL_BITS; qp--; } for (i = qxn - 1; i >= 0; i--) { udiv_qrnnd_preinv (*qp, r, r, CNST_LIMB(0), d, dinv); r >>= GMP_NAIL_BITS; qp--; } return r; } } else { /* Most significant bit of divisor == 0. */ int norm; /* Skip a division if high < divisor (high quotient 0). Testing here before normalizing will still skip as often as possible. */ if (un != 0) { n1 = up[un - 1] << GMP_NAIL_BITS; if (n1 < d) { r = n1 >> GMP_NAIL_BITS; *qp-- = 0; n--; if (n == 0) return r; un--; } } if (! UDIV_NEEDS_NORMALIZATION && BELOW_THRESHOLD (n, DIVREM_1_UNNORM_THRESHOLD)) goto plain; count_leading_zeros (norm, d); d <<= norm; r <<= norm; if (UDIV_NEEDS_NORMALIZATION && BELOW_THRESHOLD (n, DIVREM_1_UNNORM_THRESHOLD)) { if (un != 0) { n1 = up[un - 1] << GMP_NAIL_BITS; r |= (n1 >> (GMP_LIMB_BITS - norm)); for (i = un - 2; i >= 0; i--) { n0 = up[i] << GMP_NAIL_BITS; udiv_qrnnd (*qp, r, r, (n1 << norm) | (n0 >> (GMP_NUMB_BITS - norm)), d); r >>= GMP_NAIL_BITS; qp--; n1 = n0; } udiv_qrnnd (*qp, r, r, n1 << norm, d); r >>= GMP_NAIL_BITS; qp--; } for (i = qxn - 1; i >= 0; i--) { udiv_qrnnd (*qp, r, r, CNST_LIMB(0), d); r >>= GMP_NAIL_BITS; qp--; } return r >> norm; } else { mp_limb_t dinv; invert_limb (dinv, d); if (un != 0) { n1 = up[un - 1] << GMP_NAIL_BITS; r |= (n1 >> (GMP_LIMB_BITS - norm)); for (i = un - 2; i >= 0; i--) { n0 = up[i] << GMP_NAIL_BITS; udiv_qrnnd_preinv (*qp, r, r, ((n1 << norm) | (n0 >> (GMP_NUMB_BITS - norm))), d, dinv); r >>= GMP_NAIL_BITS; qp--; n1 = n0; } udiv_qrnnd_preinv (*qp, r, r, n1 << norm, d, dinv); r >>= GMP_NAIL_BITS; qp--; } for (i = qxn - 1; i >= 0; i--) { udiv_qrnnd_preinv (*qp, r, r, CNST_LIMB(0), d, dinv); r >>= GMP_NAIL_BITS; qp--; } return r >> norm; } } } ecl-16.1.2/msvc/gmp/mpn/generic/divrem_2.c000077500000000000000000000115411266352375300202010ustar00rootroot00000000000000/* mpn_divrem_2 -- Divide natural numbers, producing both remainder and quotient. The divisor is two limbs. THIS FILE CONTAINS INTERNAL FUNCTIONS WITH MUTABLE INTERFACES. IT IS ONLY SAFE TO REACH THEM THROUGH DOCUMENTED INTERFACES. IN FACT, IT IS ALMOST GUARANTEED THAT THEY'LL CHANGE OR DISAPPEAR IN A FUTURE GNU MP RELEASE. Copyright 1993, 1994, 1995, 1996, 1999, 2000, 2001, 2002 Free Software Foundation, Inc. This file is part of the GNU MP Library. The GNU MP Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU MP Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU MP Library; see the file COPYING.LIB. If not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ #include "gmp.h" #include "gmp-impl.h" #include "longlong.h" /* The size where udiv_qrnnd_preinv should be used rather than udiv_qrnnd, meaning the quotient size where that should happen, the quotient size being how many udiv divisions will be done. The default is to use preinv always, CPUs where this doesn't suit have tuned thresholds. Note in particular that preinv should certainly be used if that's the only division available (USE_PREINV_ALWAYS). */ #ifndef DIVREM_2_THRESHOLD #define DIVREM_2_THRESHOLD 0 #endif /* Divide num (NP/NSIZE) by den (DP/2) and write the NSIZE-2 least significant quotient limbs at QP and the 2 long remainder at NP. If QEXTRA_LIMBS is non-zero, generate that many fraction bits and append them after the other quotient limbs. Return the most significant limb of the quotient, this is always 0 or 1. Preconditions: 0. NSIZE >= 2. 1. The most significant bit of the divisor must be set. 2. QP must either not overlap with the input operands at all, or QP + 2 >= NP must hold true. (This means that it's possible to put the quotient in the high part of NUM, right after the remainder in NUM. 3. NSIZE >= 2, even if QEXTRA_LIMBS is non-zero. */ mp_limb_t mpn_divrem_2 (mp_ptr qp, mp_size_t qxn, mp_ptr np, mp_size_t nn, mp_srcptr dp) { mp_limb_t most_significant_q_limb = 0; mp_size_t i; mp_limb_t n1, n0, n2; mp_limb_t d1, d0; mp_limb_t d1inv; int use_preinv; ASSERT (nn >= 2); ASSERT (qxn >= 0); ASSERT (dp[1] & GMP_NUMB_HIGHBIT); ASSERT (! MPN_OVERLAP_P (qp, nn-2+qxn, np, nn) || qp+2 >= np); ASSERT_MPN (np, nn); ASSERT_MPN (dp, 2); np += nn - 2; d1 = dp[1]; d0 = dp[0]; n1 = np[1]; n0 = np[0]; if (n1 >= d1 && (n1 > d1 || n0 >= d0)) { #if GMP_NAIL_BITS == 0 sub_ddmmss (n1, n0, n1, n0, d1, d0); #else n0 = n0 - d0; n1 = n1 - d1 - (n0 >> GMP_LIMB_BITS - 1); n0 &= GMP_NUMB_MASK; #endif most_significant_q_limb = 1; } use_preinv = ABOVE_THRESHOLD (qxn + nn - 2, DIVREM_2_THRESHOLD); if (use_preinv) invert_limb (d1inv, d1); for (i = qxn + nn - 2 - 1; i >= 0; i--) { mp_limb_t q; mp_limb_t r; if (i >= qxn) np--; else np[0] = 0; if (n1 == d1) { /* Q should be either 111..111 or 111..110. Need special handling of this rare case as normal division would give overflow. */ q = GMP_NUMB_MASK; r = (n0 + d1) & GMP_NUMB_MASK; if (r < d1) /* Carry in the addition? */ { #if GMP_NAIL_BITS == 0 add_ssaaaa (n1, n0, r - d0, np[0], 0, d0); #else n0 = np[0] + d0; n1 = (r - d0 + (n0 >> GMP_NUMB_BITS)) & GMP_NUMB_MASK; n0 &= GMP_NUMB_MASK; #endif qp[i] = q; continue; } n1 = d0 - (d0 != 0); n0 = -d0 & GMP_NUMB_MASK; } else { if (use_preinv) udiv_qrnnd_preinv (q, r, n1, n0, d1, d1inv); else udiv_qrnnd (q, r, n1, n0 << GMP_NAIL_BITS, d1 << GMP_NAIL_BITS); r >>= GMP_NAIL_BITS; umul_ppmm (n1, n0, d0, q << GMP_NAIL_BITS); n0 >>= GMP_NAIL_BITS; } n2 = np[0]; q_test: if (n1 > r || (n1 == r && n0 > n2)) { /* The estimated Q was too large. */ q--; #if GMP_NAIL_BITS == 0 sub_ddmmss (n1, n0, n1, n0, 0, d0); #else n0 = n0 - d0; n1 = n1 - (n0 >> GMP_LIMB_BITS - 1); n0 &= GMP_NUMB_MASK; #endif r += d1; if (r >= d1) /* If not carry, test Q again. */ goto q_test; } qp[i] = q; #if GMP_NAIL_BITS == 0 sub_ddmmss (n1, n0, r, n2, n1, n0); #else n0 = n2 - n0; n1 = r - n1 - (n0 >> GMP_LIMB_BITS - 1); n0 &= GMP_NUMB_MASK; #endif } np[1] = n1; np[0] = n0; return most_significant_q_limb; } ecl-16.1.2/msvc/gmp/mpn/generic/popham2.c000077500000000000000000000023111266352375300200330ustar00rootroot00000000000000/* mpn_popcount, mpn_hamdist -- mpn bit population count/hamming distance. Copyright 1994, 1996, 2000, 2001, 2002, 2005 Free Software Foundation, Inc. This file is part of the GNU MP Library. The GNU MP Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU MP Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU MP Library; see the file COPYING.LIB. If not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ #include "gmp.h" #include "gmp-impl.h" #define OPERATION_popcount 1 #define OPERATION_hamdist 0 #include "popham.c" #undef OPERATION_popcount #undef OPERATION_hamdist #undef FNAME #undef POPHAM #define OPERATION_popcount 0 #define OPERATION_hamdist 1 #include "popham.c" ecl-16.1.2/msvc/gmp/mpn/x86i/000077500000000000000000000000001266352375300155035ustar00rootroot00000000000000ecl-16.1.2/msvc/gmp/mpn/x86i/aors_n.asm000066400000000000000000000106761266352375300175000ustar00rootroot00000000000000 ; Copyright 1992, 1994, 1995, 1996, 1999, 2000, 2001, 2002 Free Software ; Foundation, Inc. ; ; This file is part of the GNU MP Library. ; ; The GNU MP Library is free software; you can redistribute it and/or ; modify it under the terms of the GNU Lesser General Public License as ; published by the Free Software Foundation; either version 2.1 of the ; License, or (at your option) any later version. ; ; The GNU MP Library is distributed in the hope that it will be useful, ; but WITHOUT ANY WARRANTY; without even the implied warranty of ; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ; Lesser General Public License for more details. ; ; You should have received a copy of the GNU Lesser General Public ; License along with the GNU MP Library; see the file COPYING.LIB. If ; not, write to the Free Software Foundation, Inc., 59 Temple Place - ; Suite 330, Boston, MA 02111-1307, USA. ; ; Translation of AT&T syntax code by Brian Gladman %include "x86i.inc" ; mp_limb_t M4_function_n (mp_ptr dst,mp_srcptr src1,mp_srcptr src2, ; mp_size_t size); ; mp_limb_t M4_function_nc (mp_ptr dst,mp_srcptr src1,mp_srcptr src2, ; mp_size_t size,mp_limb_t carry); %define PARAM_SPACE 20 %define PARAM_CARRY esp+frame+20 %define PARAM_SIZE esp+frame+16 %define PARAM_SRC2 esp+frame+12 %define PARAM_SRC1 esp+frame+8 %define PARAM_DST esp+frame+4 %macro mac_sub 4 global %1%4 %ifdef DLL export %1%4 %endif align 8 %1%4: %assign frame 0 FR_push edi FR_push esi mov edi,[PARAM_DST] mov esi,[PARAM_SRC1] mov edx,[PARAM_SRC2] mov ecx,[PARAM_SIZE] mov eax,ecx shr ecx,3 ; compute count for unrolled %%4 neg eax and eax,7 ; get index where to start %%4 jz %%3 ; necessary special case for 0 inc ecx ; adjust %%4 count shl eax,2 ; adjustment for pointers... sub edi,eax ; ... since they are offset ... sub esi,eax ; ... by a constant when we ... sub edx,eax ; ... enter the %%4 shr eax,2 ; restore previous value ; Calculate start address in %%4 %ifdef PIC call %%1 %%1: lea eax,[%%4-%%1-3+eax+eax*8] add eax,[esp] add esp,4 %else lea eax,[%%4-3+eax+eax*8] %endif ; These lines initialize carry from the 5th parameter. Should be ; possible to simplify. FR_push ebp mov ebp,[PARAM_CARRY] shr ebp,1 ; shift bit 0 into carry FR_pop ebp jmp eax ; jump into %%4 global %1%3 %ifdef DLL export %1%3 %endif align 8 %1%3: %assign frame 0 FR_push edi FR_push esi mov edi,[PARAM_DST] mov esi,[PARAM_SRC1] mov edx,[PARAM_SRC2] mov ecx,[PARAM_SIZE] mov eax,ecx shr ecx,3 ; compute count for unrolled %%4 neg eax and eax,7 ; get index where to start %%4 jz %%4 ; necessary special case for 0 inc ecx ; adjust %%4 count shl eax,2 ; adjustment for pointers... sub edi,eax ; ... since they are offset ... sub esi,eax ; ... by a constant when we ... sub edx,eax ; ... enter the %%4 shr eax,2 ; restore previous value ; Calculate start address in %%4 for PIC. ; Due to limitations in some assemblers,%%4-%%2-3 ; cannot be put into the leal %ifdef PIC call %%2 %%2: lea eax,[%%4-%%2-3+eax+eax*8] add eax,[esp] add esp,4 %else lea eax,[%%4-3+eax+eax*8] %endif jmp eax ; jump into %%4 %%3: FR_push ebp mov ebp,[PARAM_CARRY] shr ebp,1 ; shift bit 0 into carry FR_pop ebp align 8 %%4: mov eax,[esi] %2 eax,[edx] mov [edi],eax mov eax,[4+esi] %2 eax,[edx+4] mov [4+edi],eax mov eax,[8+esi] %2 eax,[edx+8] mov [8+edi],eax mov eax,[12+esi] %2 eax,[edx+12] mov [12+edi],eax mov eax,[16+esi] %2 eax,[edx+16] mov [16+edi],eax mov eax,[20+esi] %2 eax,[edx+20] mov [20+edi],eax mov eax,[24+esi] %2 eax,[edx+24] mov [24+edi],eax mov eax,[28+esi] %2 eax,[edx+28] mov [28+edi],eax lea edi,[32+edi] lea esi,[32+esi] lea edx,[32+edx] dec ecx jnz %%4 sbb eax,eax neg eax pop esi pop edi ret %endmacro section .text mac_sub ___g,adc,mpn_add_n,mpn_add_nc mac_sub ___g,sbb,mpn_sub_n,mpn_sub_nc end ecl-16.1.2/msvc/gmp/mpn/x86i/aorsmul_1.asm000066400000000000000000000052341266352375300201130ustar00rootroot00000000000000 ; Copyright 1992, 1994, 1997, 1999, 2000, 2001, 2002 Free Software ; Foundation, Inc. ; ; This file is part of the GNU MP Library. ; ; The GNU MP Library is free software; you can redistribute it and/or ; modify it under the terms of the GNU Lesser General Public License as ; published by the Free Software Foundation; either version 2.1 of the ; License, or (at your option) any later version. ; ; The GNU MP Library is distributed in the hope that it will be useful, ; but WITHOUT ANY WARRANTY; without even the implied warranty of ; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ; Lesser General Public License for more details. ; ; You should have received a copy of the GNU Lesser General Public ; License along with the GNU MP Library; see the file COPYING.LIB. If ; not, write to the Free Software Foundation, Inc., 59 Temple Place - ; Suite 330, Boston, MA 02111-1307, USA. ; ; Translation of AT&T syntax code by Brian Gladman %include "x86i.inc" %define PARAM_MULTIPLIER esp+frame+16 %define PARAM_SIZE esp+frame+12 %define PARAM_SRC esp+frame+8 %define PARAM_DST esp+frame+4 %assign frame 16 %macro mac_sub 3 global %1%3 %ifdef DLL export %1%3 %endif align 8 %1%3: push edi push esi push ebx push ebp mov edi,[PARAM_DST] mov esi,[PARAM_SRC] mov ecx,[PARAM_SIZE] xor ebx,ebx and ecx,3 jz %%2 %%1: mov eax,[esi] mul dword [PARAM_MULTIPLIER] lea esi,[4+esi] add eax,ebx mov ebx,0 adc edx,ebx %2 [edi],eax adc ebx,edx ; propagate carry into cylimb lea edi,[4+edi] dec ecx jnz %%1 %%2: mov ecx,[PARAM_SIZE] shr ecx,2 jz %%4 align 8 %%3: mov eax,[esi] mul dword [PARAM_MULTIPLIER] add ebx,eax mov ebp,0 adc ebp,edx mov eax,[4+esi] mul dword [PARAM_MULTIPLIER] %2 [edi],ebx adc ebp,eax ; new lo + cylimb mov ebx,0 adc ebx,edx mov eax,[8+esi] mul dword [PARAM_MULTIPLIER] %2 [4+edi],ebp adc ebx,eax ; new lo + cylimb mov ebp,0 adc ebp,edx mov eax,[12+esi] mul dword [PARAM_MULTIPLIER] %2 [8+edi],ebx adc ebp,eax ; new lo + cylimb mov ebx,0 adc ebx,edx %2 [12+edi],ebp adc ebx,0 ; propagate carry into cylimb lea esi,[16+esi] lea edi,[16+edi] dec ecx jnz %%3 %%4: mov eax,ebx pop ebp pop ebx pop esi pop edi ret %endmacro section .text mac_sub ___g,add,mpn_addmul_1 mac_sub ___g,sub,mpn_submul_1 end ecl-16.1.2/msvc/gmp/mpn/x86i/copyd.asm000066400000000000000000000030571266352375300173300ustar00rootroot00000000000000 ; Copyright 1999, 2000, 2001, 2002 Free Software Foundation, Inc. ; ; This file is part of the GNU MP Library. ; ; The GNU MP Library is free software; you can redistribute it and/or ; modify it under the terms of the GNU Lesser General Public License as ; published by the Free Software Foundation; either version 2.1 of the ; License, or (at your option) any later version. ; ; The GNU MP Library is distributed in the hope that it will be useful, ; but WITHOUT ANY WARRANTY; without even the implied warranty of ; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ; Lesser General Public License for more details. ; ; You should have received a copy of the GNU Lesser General Public ; License along with the GNU MP Library; see the file COPYING.LIB. If ; not, write to the Free Software Foundation, Inc., 59 Temple Place - ; Suite 330, Boston, MA 02111-1307, USA. ; ; Translation of AT&T syntax code by Brian Gladman %include "x86i.inc" global ___gmpn_copyd %ifdef DLL export ___gmpn_copyd %endif %define PARAM_SIZE esp+frame+12 %define PARAM_SRC esp+frame+8 %define PARAM_DST esp+frame+4 %assign frame 0 ; eax saved esi ; ebx ; ecx counter ; edx saved edi ; esi src ; edi dst ; ebp section .text align 32 ___gmpn_copyd: mov ecx,[PARAM_SIZE] mov eax,esi mov esi,[PARAM_SRC] mov edx,edi mov edi,[PARAM_DST] lea esi,[-4+esi+ecx*4] lea edi,[-4+edi+ecx*4] std rep movsd cld mov esi,eax mov edi,edx ret end ecl-16.1.2/msvc/gmp/mpn/x86i/copyi.asm000066400000000000000000000030311266352375300173250ustar00rootroot00000000000000 ; Copyright 1999, 2000, 2001, 2002 Free Software Foundation, Inc. ; ; This file is part of the GNU MP Library. ; ; The GNU MP Library is free software; you can redistribute it and/or ; modify it under the terms of the GNU Lesser General Public License as ; published by the Free Software Foundation; either version 2.1 of the ; License, or (at your option) any later version. ; ; The GNU MP Library is distributed in the hope that it will be useful, ; but WITHOUT ANY WARRANTY; without even the implied warranty of ; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ; Lesser General Public License for more details. ; ; You should have received a copy of the GNU Lesser General Public ; License along with the GNU MP Library; see the file COPYING.LIB. If ; not, write to the Free Software Foundation, Inc., 59 Temple Place - ; Suite 330, Boston, MA 02111-1307, USA. ; ; Translation of AT&T syntax code by Brian Gladman %include "x86i.inc" global ___gmpn_copyi %ifdef DLL export ___gmpn_copyi %endif %define PARAM_SIZE esp+frame+12 %define PARAM_SRC esp+frame+8 %define PARAM_DST esp+frame+4 %assign frame 0 section .text align 32 ; eax saved esi ; ebx ; ecx counter ; edx saved edi ; esi src ; edi dst ; ebp ___gmpn_copyi: mov ecx,[PARAM_SIZE] mov eax,esi mov esi,[PARAM_SRC] mov edx,edi mov edi,[PARAM_DST] cld ; better safe than sorry,see mpn/x86/README rep movsd mov esi,eax mov edi,edx ret end ecl-16.1.2/msvc/gmp/mpn/x86i/dive_1.asm000066400000000000000000000071271266352375300173630ustar00rootroot00000000000000 ; Copyright 2001, 2002 Free Software Foundation, Inc. ; ; This file is part of the GNU MP Library. ; ; The GNU MP Library is free software; you can redistribute it and/or ; modify it under the terms of the GNU Lesser General Public License as ; published by the Free Software Foundation; either version 2.1 of the ; License, or (at your option) any later version. ; ; The GNU MP Library is distributed in the hope that it will be useful, ; but WITHOUT ANY WARRANTY; without even the implied warranty of ; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ; Lesser General Public License for more details. ; ; You should have received a copy of the GNU Lesser General Public ; License along with the GNU MP Library; see the file COPYING.LIB. If ; not, write to the Free Software Foundation, Inc., 59 Temple Place - ; Suite 330, Boston, MA 02111-1307, USA. ; ; Translation of AT&T syntax code by Brian Gladman %include "x86i.inc" %define PARAM_DIVISOR esp+frame+16 %define PARAM_SIZE esp+frame+12 %define PARAM_SRC esp+frame+8 %define PARAM_DST esp+frame+4 %define VAR_INVERSE PARAM_SRC %assign frame 0 section .text extern ___gmp_modlimb_invert_table global ___gmpn_divexact_1 %ifdef DLL export ___gmpn_divexact_1 %endif align 16 ___gmpn_divexact_1: mov eax,[PARAM_DIVISOR] FR_push ebp mov ebp,[PARAM_SIZE] FR_push edi FR_push ebx mov ecx,-1 ; shift count FR_push esi Lstrip_twos: inc ecx shr eax,1 jnc Lstrip_twos lea ebx,[1+eax+eax] ; d without twos and eax,127 ; d/2,7 bits %ifdef PIC call Lmovl_eip_edx add edx,_GLOBAL_OFFSET_TABLE_ mov edx,[___gmp_modlimb_invert_table+edx] movzx eax,byte [eax+edx] ; inv 8 bits %else movzx eax,byte [___gmp_modlimb_invert_table+eax] ; inv 8 bits %endif lea edx,[eax+eax] ; 2*inv mov [PARAM_DIVISOR],ebx ; d without twos imul eax,eax ; inv*inv mov esi,[PARAM_SRC] mov edi,[PARAM_DST] imul eax,ebx ; inv*inv*d sub edx,eax ; inv = 2*inv - inv*inv*d lea eax,[edx+edx] ; 2*inv imul edx,edx ; inv*inv lea esi,[esi+ebp*4] ; src end lea edi,[edi+ebp*4] ; dst end neg ebp ; -size imul edx,ebx ; inv*inv*d sub eax,edx ; inv = 2*inv - inv*inv*d %ifdef ASSERT FR_push eax imul eax,[PARAM_DIVISOR] cmp eax,1 FR_pop eax %endif mov [VAR_INVERSE],eax mov eax,[esi+ebp*4] ; src[0] xor ebx,ebx xor edx,edx inc ebp jz Lone mov edx,[esi+ebp*4] ; src[1] shrd eax,edx,cl mov edx,[VAR_INVERSE] jmp Lentry align 8 nop ; k6 code alignment nop ; eax q ; ebx carry bit,0 or -1 ; ecx shift ; edx carry limb ; esi src end ; edi dst end ; ebp counter,limbs,negative Ltop: mov eax,[-4+esi+ebp*4] sub edx,ebx ; accumulate carry bit mov ebx,[esi+ebp*4] shrd eax,ebx,cl sub eax,edx ; apply carry limb mov edx,[VAR_INVERSE] sbb ebx,ebx Lentry: imul eax,edx mov [-4+edi+ebp*4],eax mov edx,[PARAM_DIVISOR] mul edx inc ebp jnz Ltop mov eax,[-4+esi] ; src high limb Lone: shr eax,cl FR_pop esi add eax,ebx ; apply carry bit FR_pop ebx sub eax,edx ; apply carry limb imul eax,[VAR_INVERSE] mov [-4+edi],eax pop edi pop ebp ret %ifdef PIC Lmovl_eip_edx: mov edx,[esp] ret %endif end ecl-16.1.2/msvc/gmp/mpn/x86i/diveby3.asm000066400000000000000000000044121266352375300175530ustar00rootroot00000000000000 ; Copyright 2000, 2001, 2002 Free Software Foundation, Inc. ; ; This file is part of the GNU MP Library. ; ; The GNU MP Library is free software; you can redistribute it and/or ; modify it under the terms of the GNU Lesser General Public License as ; published by the Free Software Foundation; either version 2.1 of the ; License, or (at your option) any later version. ; ; The GNU MP Library is distributed in the hope that it will be useful, ; but WITHOUT ANY WARRANTY; without even the implied warranty of ; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ; Lesser General Public License for more details. ; ; You should have received a copy of the GNU Lesser General Public ; License along with the GNU MP Library; see the file COPYING.LIB. If ; not, write to the Free Software Foundation, Inc., 59 Temple Place - ; Suite 330, Boston, MA 02111-1307, USA. ; ; Translation of AT&T syntax code by Brian Gladman %include "x86i.inc" %define PARAM_CARRY esp+frame+16 %define PARAM_SIZE esp+frame+12 %define PARAM_SRC esp+frame+8 %define PARAM_DST esp+frame+4 %assign frame 0 ; multiplicative inverse of 3,modulo 2^32 ; ceil(b/3) and ceil(b*2/3) where b=2^32 %define INVERSE_3 0xAAAAAAAB %define ONE_THIRD_CEIL 0x55555556 %define TWO_THIRDS_CEIL 0xAAAAAAAB section .text global ___gmpn_divexact_by3c %ifdef DLL export ___gmpn_divexact_by3c %endif align 8 ___gmpn_divexact_by3c: mov ecx,[PARAM_SRC] FR_push ebp mov ebp,[PARAM_SIZE] FR_push edi mov edi,[PARAM_DST] FR_push esi mov esi,INVERSE_3 FR_push ebx lea ecx,[ecx+ebp*4] mov ebx,[PARAM_CARRY] lea edi,[edi+ebp*4] neg ebp ; eax scratch,low product ; ebx carry limb (0 to 3) ; ecx &src[size] ; edx scratch,high product ; esi multiplier ; edi &dst[size] ; ebp counter,limbs,negative align 8 Ltop: mov eax,[ecx+ebp*4] sub eax,ebx setc bl imul esi cmp eax,ONE_THIRD_CEIL mov [edi+ebp*4],eax sbb ebx,-1 ; +1 if eax>=ceil(b/3) cmp eax,TWO_THIRDS_CEIL sbb ebx,-1 ; +1 if eax>=ceil(b*2/3) inc ebp jnz Ltop mov eax,ebx pop ebx pop esi pop edi pop ebp ret end ecl-16.1.2/msvc/gmp/mpn/x86i/divrem_1.asm000066400000000000000000000063541266352375300177230ustar00rootroot00000000000000 ; Copyright 1999, 2000, 2001, 2002 Free Software Foundation, Inc. ; ; This file is part of the GNU MP Library. ; ; The GNU MP Library is free software; you can redistribute it and/or ; modify it under the terms of the GNU Lesser General Public License as ; published by the Free Software Foundation; either version 2.1 of the ; License, or (at your option) any later version. ; ; The GNU MP Library is distributed in the hope that it will be useful, ; but WITHOUT ANY WARRANTY; without even the implied warranty of ; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ; Lesser General Public License for more details. ; ; You should have received a copy of the GNU Lesser General Public ; License along with the GNU MP Library; see the file COPYING.LIB. If ; not, write to the Free Software Foundation, Inc., 59 Temple Place - ; Suite 330, Boston, MA 02111-1307, USA. ; ; Translation of AT&T syntax code by Brian Gladman %include "x86i.inc" %define PARAM_CARRY esp+frame+24 %define PARAM_DIVISOR esp+frame+20 %define PARAM_SIZE esp+frame+16 %define PARAM_SRC esp+frame+12 %define PARAM_XSIZE esp+frame+8 %define PARAM_DST esp+frame+4 section .text global ___gmpn_divrem_1c %ifdef DLL export ___gmpn_divrem_1c %endif align 16 ___gmpn_divrem_1c: %assign frame 0 mov ecx,[PARAM_SIZE] FR_push edi mov edi,[PARAM_SRC] FR_push esi mov esi,[PARAM_DIVISOR] FR_push ebx mov ebx,[PARAM_DST] FR_push ebp mov ebp,[PARAM_XSIZE] or ecx,ecx mov edx,[PARAM_CARRY] jz Lfraction lea ebx,[-4+ebx+ebp*4] ; dst one limb below integer part jmp Linteger_top global ___gmpn_divrem_1 %ifdef DLL export ___gmpn_divrem_1 %endif align 16 ___gmpn_divrem_1: %assign frame 0 mov ecx,[PARAM_SIZE] FR_push edi mov edi,[PARAM_SRC] FR_push esi mov esi,[PARAM_DIVISOR] or ecx,ecx jz Lsize_zero FR_push ebx mov eax,[-4+edi+ecx*4] ; src high limb xor edx,edx mov ebx,[PARAM_DST] FR_push ebp mov ebp,[PARAM_XSIZE] cmp eax,esi lea ebx,[-4+ebx+ebp*4] ; dst one limb below integer part jae Linteger_entry ; highdst,since in that case it's a requirement of the ; parameters that src>=dst+size*4,and hence the ; regions are disjoint ; ; eax prev high limb ; ebx ; ecx counter,size-3 down to 0 or -1,inclusive,by 2s ; edx prev low limb ; esi src ; edi dst ; ebp lea edx,[edi+ecx*4] cmp esi,edi jae Luse_movsl ; src >= dst cmp edx,edi mov edx,[4+esi+ecx*4] ; src[size-2] again jbe Luse_movsl ; src+4*size <= dst Ltop: mov [8+edi+ecx*4],eax mov eax,[esi+ecx*4] mov [4+edi+ecx*4],edx mov edx,[-4+esi+ecx*4] sub ecx,2 jnbe Ltop Ldone_loop: mov [8+edi+ecx*4],eax mov [4+edi+ecx*4],edx ; copy low limb (needed if size was odd,but will already have been ; done in the loop if size was even) mov eax,[esi] Lone: mov [edi],eax mov edi,[SAVE_EDI] mov esi,[SAVE_ESI] ret Luse_movsl: add ecx,3 cld rep movsd Lzero: mov esi,[SAVE_ESI] mov edi,[SAVE_EDI] ret end ecl-16.1.2/msvc/gmp/mpn/x86i/p6/dive_1.asm000066400000000000000000000116241266352375300177050ustar00rootroot00000000000000 ; Copyright 2001, 2002 Free Software Foundation, Inc. ; ; This file is part of the GNU MP Library. ; ; The GNU MP Library is free software; you can redistribute it and/or ; modify it under the terms of the GNU Lesser General Public License as ; published by the Free Software Foundation; either version 2.1 of the ; License, or (at your option) any later version. ; ; The GNU MP Library is distributed in the hope that it will be useful, ; but WITHOUT ANY WARRANTY; without even the implied warranty of ; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ; Lesser General Public License for more details. ; ; You should have received a copy of the GNU Lesser General Public ; License along with the GNU MP Library; see the file COPYING.LIB. If ; not, write to the Free Software Foundation, Inc., 59 Temple Place - ; Suite 330, Boston, MA 02111-1307, USA. ; ; Translation of AT&T syntax code by Brian Gladman %include "..\x86i.inc" extern ___gmp_modlimb_invert_table global ___gmpn_divexact_1 %ifdef DLL export ___gmpn_divexact_1 %endif %define PARAM_DIVISOR esp+frame+16 %define PARAM_SIZE esp+frame+12 %define PARAM_SRC esp+frame+8 %define PARAM_DST esp+frame+4 %define SAVE_EBX esp+frame-4 %define SAVE_ESI esp+frame-8 %define SAVE_EDI esp+frame-12 %define SAVE_EBP esp+frame-16 %define VAR_INVERSE esp+frame-20 %define STACK_SPACE 20 %define frame 0 section .text align 16 ___gmpn_divexact_1: mov eax,[PARAM_DIVISOR] sub esp,STACK_SPACE FR_sesp STACK_SPACE mov [SAVE_ESI],esi mov esi,[PARAM_SRC] mov [SAVE_EBX],ebx mov ebx,[PARAM_SIZE] bsf ecx,eax ; trailing twos mov [SAVE_EBP],ebp shr eax,cl ; d without twos mov edx,eax shr eax,1 ; d/2 without twos mov [PARAM_DIVISOR],edx and eax,127 %ifdef PIC call Lmovl_eip_ebp add ebp,_GLOBAL_OFFSET_TABLE_ mov ebp,[___gmp_modlimb_invert_table+edx+ebp] movzx ebp,byte [eax+ebp] ; inv 8 bits %else movzx ebp,byte [___gmp_modlimb_invert_table+eax] ; inv 8 bits %endif lea eax,[ebp+ebp] ; 2*inv imul ebp,ebp ; inv*inv mov [SAVE_EDI],edi mov edi,[PARAM_DST] lea esi,[esi+ebx*4] ; src end imul ebp,[PARAM_DIVISOR] ; inv*inv*d sub eax,ebp ; inv = 2*inv - inv*inv*d lea ebp,[eax+eax] ; 2*inv imul eax,eax ; inv*inv lea edi,[edi+ebx*4] ; dst end neg ebx ; -size mov [PARAM_DST],edi imul eax,[PARAM_DIVISOR] ; inv*inv*d sub ebp,eax ; inv = 2*inv - inv*inv*d mov [VAR_INVERSE],ebp mov eax,[esi+ebx*4] ; src[0] or ecx,ecx jnz Leven jmp Lodd_entry ; ecx initial carry is zero ; The dependent chain here is ; ; subl %edx,%eax 1 ; imull %ebp,%eax 4 ; mull PARAM_DIVISOR 5 ; ---- ; total 10 ; ; and this is the measured speed. No special scheduling is necessary,out ; of order execution hides the load latency. ; ; eax scratch (src limb) ; ebx counter,limbs,negative ; ecx carry bit ; edx carry limb,high of last product ; esi &src[size] ; edi &dst[size] Lodd_top: mul dword [PARAM_DIVISOR] mov eax,[esi+ebx*4] sub eax,ecx sbb ecx,ecx sub eax,edx sbb ecx,0 Lodd_entry: imul eax,[VAR_INVERSE] mov [edi+ebx*4],eax neg ecx inc ebx jnz Lodd_top mov esi,[SAVE_ESI] mov edi,[SAVE_EDI] mov ebp,[SAVE_EBP] mov ebx,[SAVE_EBX] add esp,STACK_SPACE ret ; eax src[0] ; ebx counter,limbs,negative ; ecx shift Leven: xor ebp,ebp ; initial carry bit xor edx,edx ; initial carry limb (for size==1) inc ebx jz Leven_one mov edi,[esi+ebx*4] ; src[1] shrd eax,edi,cl jmp Leven_entry ; eax scratch ; ebx counter,limbs,negative ; ecx shift ; edx scratch ; esi &src[size] ; edi &dst[size] and scratch ; ebp carry bit Leven_top: mov edi,[esi+ebx*4] mul dword [PARAM_DIVISOR] mov eax,[-4+esi+ebx*4] shrd eax,edi,cl sub eax,ebp sbb ebp,ebp sub eax,edx sbb ebp,0 Leven_entry: imul eax,[VAR_INVERSE] mov edi,[PARAM_DST] neg ebp mov [-4+edi+ebx*4],eax inc ebx jnz Leven_top mul dword [PARAM_DIVISOR] mov eax,[-4+esi] Leven_one: shr eax,cl mov esi,[SAVE_ESI] sub eax,ebp mov ebp,[SAVE_EBP] sub eax,edx mov ebx,[SAVE_EBX] imul eax,[VAR_INVERSE] mov [-4+edi],eax mov edi,[SAVE_EDI] add esp,STACK_SPACE ret %ifdef PIC Lmovl_eip_ebp: mov ebp,[esp] ret %endif end ecl-16.1.2/msvc/gmp/mpn/x86i/p6/diveby3.asm000066400000000000000000000112131266352375300200750ustar00rootroot00000000000000 ; Copyright 2000, 2002 Free Software Foundation, Inc. ; ; This file is part of the GNU MP Library. ; ; The GNU MP Library is free software; you can redistribute it and/or ; modify it under the terms of the GNU Lesser General Public License as ; published by the Free Software Foundation; either version 2.1 of the ; License, or (at your option) any later version. ; ; The GNU MP Library is distributed in the hope that it will be useful, ; but WITHOUT ANY WARRANTY; without even the implied warranty of ; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ; Lesser General Public License for more details. ; ; You should have received a copy of the GNU Lesser General Public ; License along with the GNU MP Library; see the file COPYING.LIB. If ; not, write to the Free Software Foundation, Inc., 59 Temple Place - ; Suite 330, Boston, MA 02111-1307, USA. ; ; Translation of AT&T syntax code by Brian Gladman %include "..\x86i.inc" global ___gmpn_divexact_by3c %ifdef DLL export ___gmpn_divexact_by3c %endif %define PARAM_CARRY esp+frame+16 %define PARAM_SIZE esp+frame+12 %define PARAM_SRC esp+frame+8 %define PARAM_DST esp+frame+4 %define frame 0 ; multiplicative inverse of 3,modulo 2^32 ; ceil(b/3),ceil(b*2/3) and floor(b*2/3) where b=2^32 %define INVERSE_3 0xAAAAAAAB %define ONE_THIRD_CEIL 0x55555556 %define TWO_THIRDS_CEIL 0xAAAAAAAB %define TWO_THIRDS_FLOOR 0xAAAAAAAA section .text align 8 ___gmpn_divexact_by3c: mov ecx,[PARAM_SRC] mov edx,[PARAM_SIZE] dec edx jnz Ltwo_or_more mov edx,[ecx] mov eax,[PARAM_CARRY] ; risk of cache bank clash here mov ecx,[PARAM_DST] sub edx,eax sbb eax,eax ; 0 or -1 imul edx,edx,INVERSE_3 neg eax ; 0 or 1 cmp edx,ONE_THIRD_CEIL sbb eax,-1 ; +1 if edx>=ceil(b/3) cmp edx,TWO_THIRDS_CEIL sbb eax,-1 ; +1 if edx>=ceil(b*2/3) mov [ecx],edx ret ; eax ; ebx ; ecx src ; edx size-1 ; esi ; edi ; ebp Ltwo_or_more: FR_push ebx FR_push esi FR_push edi FR_push ebp mov edi,[PARAM_DST] mov esi,[PARAM_CARRY] mov eax,[ecx] ; src low limb xor ebx,ebx sub eax,esi mov esi,TWO_THIRDS_FLOOR lea ecx,[ecx+edx*4] ; &src[size-1] lea edi,[edi+edx*4] ; &dst[size-1] adc ebx,0 ; carry,0 or 1 neg edx ; -(size-1) ; The loop needs a source limb ready at the top,which leads to one limb ; handled separately at the end,and the special case above for size==1. ; There doesn't seem to be any scheduling that would keep the speed but move ; the source load and carry subtract up to the top. ; ; The destination cache line prefetching adds 1 cycle to the loop but is ; considered worthwhile. The slowdown is a factor of 1.07,but will prevent ; repeated write-throughs if the destination isn't in L1. A version using ; an outer loop to prefetch only every 8 limbs (a cache line) proved to be ; no faster,due to unavoidable branch mispreditions in the inner loop. ; ; setc is 2 cycles on P54,so an adcl is used instead. If the movl $0,%ebx ; could be avoided then the src limb fetch could pair up and save a cycle. ; This would probably mean going to a two limb loop with the carry limb ; alternately positive or negative,since an sbbl %ebx,%ebx will leave a ; value which is in the opposite sense to the preceding sbbl/adcl %ebx,%eax. ; ; A register is used for TWO_THIRDS_FLOOR because a cmp can't be done as ; "cmpl %edx,$n" with the immediate as the second operand. ; ; The "4" source displacement is in the loop rather than the setup because ; this gets Ltop aligned to 8 bytes at no cost. ; eax source limb,carry subtracted ; ebx carry (0 or 1) ; ecx &src[size-1] ; edx counter,limbs,negative ; esi TWO_THIRDS_FLOOR ; edi &dst[size-1] ; ebp scratch (result limb) align 8 Ltop: imul ebp,eax,INVERSE_3 cmp ebp,ONE_THIRD_CEIL mov eax,[edi+edx*4] ; dst cache line prefetch sbb ebx,-1 ; +1 if ebp>=ceil(b/3) cmp esi,ebp mov eax,[4+ecx+edx*4] ; next src limb sbb eax,ebx ; and further -1 if ebp>=ceil(b*2/3) mov ebx,0 adc ebx,0 ; new carry mov [edi+edx*4],ebp inc edx jnz Ltop imul edx,eax,INVERSE_3 cmp edx,ONE_THIRD_CEIL mov [edi],edx sbb ebx,-1 ; +1 if edx>=ceil(b/3) cmp edx,TWO_THIRDS_CEIL sbb ebx,-1 ; +1 if edx>=ceil(b*2/3) pop ebp mov eax,ebx pop edi pop esi pop ebx ret end ecl-16.1.2/msvc/gmp/mpn/x86i/p6/mmx/000077500000000000000000000000001266352375300166315ustar00rootroot00000000000000ecl-16.1.2/msvc/gmp/mpn/x86i/p6/mmx/divrem_1.asm000066400000000000000000000332541266352375300210500ustar00rootroot00000000000000 ; Copyright 1999, 2000, 2001, 2002 Free Software Foundation, Inc. ; ; This file is part of the GNU MP Library. ; ; The GNU MP Library is free software; you can redistribute it and/or ; modify it under the terms of the GNU Lesser General Public License as ; published by the Free Software Foundation; either version 2.1 of the ; License, or (at your option) any later version. ; ; The GNU MP Library is distributed in the hope that it will be useful, ; but WITHOUT ANY WARRANTY; without even the implied warranty of ; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ; Lesser General Public License for more details. ; ; You should have received a copy of the GNU Lesser General Public ; License along with the GNU MP Library; see the file COPYING.LIB. If ; not, write to the Free Software Foundation, Inc., 59 Temple Place - ; Suite 330, Boston, MA 02111-1307, USA. ; ; Translation of AT&T syntax code by Brian Gladman %include "..\..\x86i.inc" global ___gmpn_preinv_divrem_1 global ___gmpn_divrem_1c global ___gmpn_divrem_1 %ifdef DLL export ___gmpn_divrem_1c export ___gmpn_divrem_1 %endif %define MUL_THRESHOLD 4 %define PARAM_PREINV_SHIFT esp+frame+28 %define PARAM_PREINV_INVERSE esp+frame+24 %define PARAM_CARRY esp+frame+24 %define PARAM_DIVISOR esp+frame+20 %define PARAM_SIZE esp+frame+16 %define PARAM_SRC esp+frame+12 %define PARAM_XSIZE esp+frame+8 %define PARAM_DST esp+frame+4 %define SAVE_EBX esp+frame-4 %define SAVE_ESI esp+frame-8 %define SAVE_EDI esp+frame-12 %define SAVE_EBP esp+frame-16 %define VAR_NORM esp+frame-20 %define VAR_INVERSE esp+frame-24 %define VAR_SRC esp+frame-28 %define VAR_DST esp+frame-32 %define VAR_DST_STOP esp+frame-36 %define STACK_SPACE 36 %define frame 0 section .text align 16 ___gmpn_preinv_divrem_1: mov ecx,[PARAM_XSIZE] sub esp,STACK_SPACE FR_sesp STACK_SPACE mov [SAVE_ESI],esi mov esi,[PARAM_SRC] mov [SAVE_EBX],ebx mov ebx,[PARAM_SIZE] mov [SAVE_EBP],ebp mov ebp,[PARAM_DIVISOR] mov [SAVE_EDI],edi mov edx,[PARAM_DST] mov eax,[-4+esi+ebx*4] ; src high limb xor edi,edi ; initial carry (if can't skip a div) lea edx,[8+edx+ecx*4] ; &dst[xsize+2] xor ecx,ecx mov [VAR_DST_STOP],edx ; &dst[xsize+2] cmp eax,ebp ; high cmp divisor cmovc edi,eax cmovnc ecx,eax ; (the latter in case src==dst) mov [-12+edx+ebx*4],ecx ; dst high limb sbb ebx,0 ; skip one division if high n2 lea edx,[ebp+esi] cmovc edi,edx movd esi,mm0 sbb ebx,0 ; q sub ecx,4 mov [ecx],ebx cmp ecx,eax mov [VAR_DST],ecx jne Linteger_top Linteger_loop_done: ; Here,and in integer_one_left below,an sbbl $0 is used rather than a jz ; q1_ff special case. This make the code a bit smaller and simpler,and ; costs only 2 cycles (each). ; eax scratch ; ebx scratch (nadj,q1) ; ecx scratch (src,dst) ; edx scratch ; esi n10 ; edi n2 ; ebp divisor ; ; mm7 rshift Linteger_two_left: mov eax,esi mov ebx,ebp sar eax,31 ; -n1 mov ecx,[PARAM_SRC] and ebx,eax ; -n1 & d neg eax ; n1 add ebx,esi ; nadj = n10 + (-n1 & d),ignoring overflow add eax,edi ; n2+n1 mul dword [VAR_INVERSE] ; m*(n2+n1) movd mm0,[ecx] ; src low limb mov ecx,[VAR_DST_STOP] add eax,ebx ; m*(n2+n1) + nadj,low giving carry flag lea ebx,[1+edi] ; n2+1 mov eax,ebp ; d adc ebx,edx ; 1 + high(n2<<32 + m*(n2+n1) + nadj) = q1+1 sbb ebx,0 mul ebx ; (q1+1)*d psllq mm0,32 psrlq mm0,mm7 sub esi,eax sbb edi,edx ; n - (q1+1)*d mov edi,esi ; remainder -> n2 lea edx,[ebp+esi] cmovc edi,edx movd esi,mm0 sbb ebx,0 ; q mov [-4+ecx],ebx ; eax scratch ; ebx scratch (nadj,q1) ; ecx scratch (dst) ; edx scratch ; esi n10 ; edi n2 ; ebp divisor ; ; mm7 rshift Linteger_one_left: mov eax,esi mov ebx,ebp sar eax,31 ; -n1 mov ecx,[VAR_DST_STOP] and ebx,eax ; -n1 & d neg eax ; n1 add ebx,esi ; nadj = n10 + (-n1 & d),ignoring overflow add eax,edi ; n2+n1 mul dword [VAR_INVERSE] ; m*(n2+n1) add eax,ebx ; m*(n2+n1) + nadj,low giving carry flag lea ebx,[1+edi] ; n2+1 mov eax,ebp ; d adc ebx,edx ; 1 + high(n2<<32 + m*(n2+n1) + nadj) = q1+1 sbb ebx,0 ; q1 if q1+1 overflowed mul ebx sub esi,eax mov eax,[PARAM_XSIZE] sbb edi,edx ; n - (q1+1)*d mov edi,esi ; remainder -> n2 lea edx,[ebp+esi] cmovc edi,edx sbb ebx,0 ; q mov [-8+ecx],ebx sub ecx,8 or eax,eax ; xsize jnz Lfraction_some mov eax,edi Lfraction_done: mov ecx,[VAR_NORM] Lzero_done: mov ebp,[SAVE_EBP] mov edi,[SAVE_EDI] mov esi,[SAVE_ESI] mov ebx,[SAVE_EBX] add esp,STACK_SPACE shr eax,cl emms ret ; Special case for q1=0xFFFFFFFF,giving q=0xFFFFFFFF meaning the low dword ; of q*d is simply -d and the remainder n-q*d = n10+d ; ; eax (divisor) ; ebx (q1+1 == 0) ; ecx ; edx ; esi n10 ; edi n2 ; ebp divisor Lq1_ff: mov ecx,[VAR_DST] mov edx,[VAR_DST_STOP] sub ecx,4 mov [VAR_DST],ecx psrlq mm0,mm7 lea edi,[ebp+esi] ; n-q*d remainder -> next n2 mov [ecx],dword -1 movd esi,mm0 ; next n10 cmp edx,ecx jne Linteger_top jmp Linteger_loop_done ; ; In the current implementation,the following successively dependent ; micro-ops seem to exist. ; ; uops ; mul 5 ; q1+1 1 (addl) ; mul 5 ; sub 3 (negl/sbbl) ; addback 2 (cmov) ; --- ; 16 ; ; The loop in fact runs at about 17.5 cycles. Using a sarl/andl/addl for ; the addback was found to be a touch slower. ; eax ; ebx ; ecx ; edx ; esi ; edi carry ; ebp divisor align 16 Lfraction_some: mov esi,[PARAM_DST] mov ecx,[VAR_DST_STOP] ; &dst[xsize+2] mov eax,edi sub ecx,8 ; &dst[xsize] ; eax n2,then scratch ; ebx scratch (nadj,q1) ; ecx dst,decrementing ; edx scratch ; esi dst stop point ; edi n2 ; ebp divisor align 16 Lfraction_top: mul dword [VAR_INVERSE] ; m*n2 mov eax,ebp ; d sub ecx,4 ; dst lea ebx,[edi+1] add ebx,edx ; 1 + high(n2<<32 + m*n2) = q1+1 mul ebx ; (q1+1)*d neg eax ; low of n - (q1+1)*d sbb edi,edx ; high of n - (q1+1)*d,caring only about carry lea edx,[ebp+eax] cmovc eax,edx sbb ebx,0 ; q mov edi,eax ; remainder->n2 cmp ecx,esi mov [ecx],ebx ; previous q jne Lfraction_top jmp Lfraction_done end ecl-16.1.2/msvc/gmp/mpn/x86i/p6/mmx/lshift.asm000066400000000000000000000204511266352375300206260ustar00rootroot00000000000000 ; Copyright 2001 Free Software Foundation, Inc. ; ; This file is part of the GNU MP Library. ; ; The GNU MP Library is free software; you can redistribute it and/or ; modify it under the terms of the GNU Lesser General Public License as ; published by the Free Software Foundation; either version 2.1 of the ; License, or (at your option) any later version. ; ; The GNU MP Library is distributed in the hope that it will be useful, ; but WITHOUT ANY WARRANTY; without even the implied warranty of ; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ; Lesser General Public License for more details. ; ; You should have received a copy of the GNU Lesser General Public ; License along with the GNU MP Library; see the file COPYING.LIB. If ; not, write to the Free Software Foundation, Inc., 59 Temple Place - ; Suite 330, Boston, MA 02111-1307, USA. ; ; Translation of AT&T syntax code by Brian Gladman %include "..\..\x86i.inc" global ___gmpn_lshift %ifdef DLL export ___gmpn_lshift %endif %define PARAM_SHIFT esp+frame+16 %define PARAM_SIZE esp+frame+12 %define PARAM_SRC esp+frame+8 %define PARAM_DST esp+frame+4 %define frame 8 ; minimum 5,because the unrolled loop can't handle less %define UNROLL_THRESHOLD 5 section .text align 8 ___gmpn_lshift: push ebx push edi mov eax,[PARAM_SIZE] mov edx,[PARAM_DST] mov ebx,[PARAM_SRC] mov ecx,[PARAM_SHIFT] cmp eax,UNROLL_THRESHOLD jae Lunroll mov edi,[-4+ebx+eax*4] ; src high limb dec eax jnz Lsimple shld eax,edi,cl shl edi,cl mov [edx],edi ; dst low limb pop edi ; risk of data cache bank clash pop ebx ret ; eax size-1 ; ebx src ; ecx shift ; edx dst ; esi ; edi ; ebp Lsimple: movd mm5,[ebx+eax*4] ; src high limb movd mm6,ecx ; lshift neg ecx psllq mm5,mm6 add ecx,32 movd mm7,ecx psrlq mm5,32 ; retval ; eax counter,limbs,negative ; ebx src ; ecx ; edx dst ; esi ; edi ; ; mm0 scratch ; mm5 return value ; mm6 shift ; mm7 32-shift Lsimple_top: movq mm0,[ebx+eax*4-4] dec eax psrlq mm0,mm7 movd [4+edx+eax*4],mm0 jnz Lsimple_top movd mm0,[ebx] movd eax,mm5 psllq mm0,mm6 pop edi pop ebx movd [edx],mm0 emms ret ; eax size ; ebx src ; ecx shift ; edx dst ; esi ; edi ; ebp align 8 Lunroll: movd mm5,[ebx+eax*4-4] ; src high limb lea edi,[ebx+eax*4] movd mm6,ecx ; lshift and edi,4 psllq mm5,mm6 jz Lstart_src_aligned ; src isn't aligned,process high limb separately (marked xxx) to ; make it so. ; ; source -8(ebx,%eax,4) ; | ; +-------+-------+-------+-- ; | | ; +-------+-------+-------+-- ; 0mod8 4mod8 0mod8 ; ; dest ; -4(edx,%eax,4) ; | ; +-------+-------+-- ; | xxx | | ; +-------+-------+-- movq mm0,[ebx+eax*4-8] ; unaligned load psllq mm0,mm6 dec eax psrlq mm0,32 movd [edx+eax*4],mm0 Lstart_src_aligned: movq mm1,[ebx+eax*4-8] ; src high qword lea edi,[edx+eax*4] and edi,4 psrlq mm5,32 ; return value movq mm3,[ebx+eax*4-16] ; src second highest qword jz Lstart_dst_aligned ; dst isn't aligned,subtract 4 to make it so,and pretend the shift ; is 32 bits extra. High limb of dst (marked xxx) handled here ; separately. ; ; source -8(ebx,%eax,4) ; | ; +-------+-------+-- ; | mm1 | ; +-------+-------+-- ; 0mod8 4mod8 ; ; dest ; -4(edx,%eax,4) ; | ; +-------+-------+-------+-- ; | xxx | | ; +-------+-------+-------+-- ; 0mod8 4mod8 0mod8 movq mm0,mm1 add ecx,32 ; new shift psllq mm0,mm6 movd mm6,ecx psrlq mm0,32 ; wasted cycle here waiting for %mm0 movd [-4+edx+eax*4],mm0 sub edx,4 Lstart_dst_aligned: psllq mm1,mm6 neg ecx ; -shift add ecx,64 ; 64-shift movq mm2,mm3 movd mm7,ecx sub eax,8 ; size-8 psrlq mm3,mm7 por mm3,mm1 ; mm3 ready to store jc Lfinish ; The comments in mpn_rshift apply here too. ; eax counter,limbs ; ebx src ; ecx ; edx dst ; esi ; edi ; ; mm0 ; mm1 ; mm2 src qword from 16(%ebx,%eax,4) ; mm3 dst qword ready to store to 24(%edx,%eax,4) ; ; mm5 return value ; mm6 lshift ; mm7 rshift align 8 Lunroll_loop: movq mm0,[ebx+eax*4+8] psllq mm2,mm6 movq mm1,mm0 psrlq mm0,mm7 movq [24+edx+eax*4],mm3 por mm0,mm2 movq mm3,[ebx+eax*4] psllq mm1,mm6 movq [16+edx+eax*4],mm0 movq mm2,mm3 psrlq mm3,mm7 sub eax,4 por mm3,mm1 jnc Lunroll_loop Lfinish: ; eax -4 to -1 representing respectively 0 to 3 limbs remaining test al,2 jz Lfinish_no_two movq mm0,[ebx+eax*4+8] psllq mm2,mm6 movq mm1,mm0 psrlq mm0,mm7 movq [24+edx+eax*4],mm3 ; prev por mm0,mm2 movq mm2,mm1 movq mm3,mm0 sub eax,2 Lfinish_no_two: ; eax -4 or -3 representing respectively 0 or 1 limbs remaining ; mm2 src prev qword,from 16(%ebx,%eax,4) ; mm3 dst qword,for 24(%edx,%eax,4) test al,1 movd eax,mm5 ; retval pop edi jz Lfinish_zero ; One extra src limb,destination was aligned. ; ; source ebx ; --+---------------+-------+ ; | mm2 | | ; --+---------------+-------+ ; ; dest edx+12 edx+4 edx ; --+---------------+---------------+-------+ ; | mm3 | | | ; --+---------------+---------------+-------+ ; ; mm6 = shift ; mm7 = ecx = 64-shift ; One extra src limb,destination was unaligned. ; ; source ebx ; --+---------------+-------+ ; | mm2 | | ; --+---------------+-------+ ; ; dest edx+12 edx+4 ; --+---------------+---------------+ ; | mm3 | | ; --+---------------+---------------+ ; ; mm6 = shift+32 ; mm7 = ecx = 64-(shift+32) ; In both cases there's one extra limb of src to fetch and combine ; with mm2 to make a qword at 4(%edx),and in the aligned case ; there's an extra limb of dst to be formed from that extra src limb ; left shifted. movd mm0,[ebx] psllq mm2,mm6 movq [12+edx],mm3 psllq mm0,32 movq mm1,mm0 psrlq mm0,mm7 por mm0,mm2 psllq mm1,mm6 movq [4+edx],mm0 psrlq mm1,32 and ecx,32 pop ebx jz Lfinish_one_unaligned movd [edx],mm1 Lfinish_one_unaligned: emms ret Lfinish_zero: ; No extra src limbs,destination was aligned. ; ; source ebx ; --+---------------+ ; | mm2 | ; --+---------------+ ; ; dest edx+8 edx ; --+---------------+---------------+ ; | mm3 | | ; --+---------------+---------------+ ; ; mm6 = shift ; mm7 = ecx = 64-shift ; No extra src limbs,destination was unaligned. ; ; source ebx ; --+---------------+ ; | mm2 | ; --+---------------+ ; ; dest edx+8 edx+4 ; --+---------------+-------+ ; | mm3 | | ; --+---------------+-------+ ; ; mm6 = shift+32 ; mm7 = ecx = 64-(shift+32) ; The movd for the unaligned case writes the same data to 4(%edx) ; that the movq does for the aligned case. movq [8+edx],mm3 and ecx,32 psllq mm2,mm6 jz Lfinish_zero_unaligned movq [edx],mm2 Lfinish_zero_unaligned: psrlq mm2,32 pop ebx movd eax,mm5 ; retval movd [4+edx],mm2 emms ret end ecl-16.1.2/msvc/gmp/mpn/x86i/p6/mmx/popham.asm000066400000000000000000000075111266352375300206230ustar00rootroot00000000000000 ; Copyright 2000, 2002 Free Software Foundation, Inc. ; ; This file is part of the GNU MP Library. ; ; The GNU MP Library is free software; you can redistribute it and/or ; modify it under the terms of the GNU Lesser General Public License as ; published by the Free Software Foundation; either version 2.1 of the ; License, or (at your option) any later version. ; ; The GNU MP Library is distributed in the hope that it will be useful, ; but WITHOUT ANY WARRANTY; without even the implied warranty of ; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ; Lesser General Public License for more details. ; ; You should have received a copy of the GNU Lesser General Public ; License along with the GNU MP Library; see the file COPYING.LIB. If ; not, write to the Free Software Foundation, Inc., 59 Temple Place - ; Suite 330, Boston, MA 02111-1307, USA. ; ; Translation of AT&T syntax code by Brian Gladman %include "..\..\x86i.inc" %define REG_AAAAAAAAAAAAAAAA mm7 %define REG_3333333333333333 mm6 %define REG_0F0F0F0F0F0F0F0F mm5 %define REG_000000FF000000FF mm4 %ifndef PIC section .data align 8 Lrodata_AAAAAAAAAAAAAAAA: dd 0AAAAAAAAh dd 0AAAAAAAAh Lrodata_3333333333333333: dd 033333333h dd 033333333h Lrodata_0F0F0F0F0F0F0F0F: dd 00F0F0F0Fh dd 00F0F0F0Fh Lrodata_000000FF000000FF: dd 0000000FFh dd 0000000FFh %endif %macro ph_fun 3 section .text align 32 global %1%2 %ifdef DLL export %1%2 %endif %if %3 == 0 %ifdef PIC nop ; avoid shrl crossing a 32-byte boundary %endif %endif %1%2: mov ecx, [PARAM_SIZE] %ifdef PIC mov eax, 0xAAAAAAAA mov edx, 0x33333333 movd mm7,eax movd mm6,edx mov eax, 0x0F0F0F0F mov edx, 0x000000FF punpckldq mm7,mm7 punpckldq mm6,mm6 movd mm5,eax movd mm4,edx punpckldq mm5,mm5 punpckldq mm4,mm4 %else movq mm7,[Lrodata_AAAAAAAAAAAAAAAA] movq mm6,[Lrodata_3333333333333333] movq mm5,[Lrodata_0F0F0F0F0F0F0F0F] movq mm4,[Lrodata_000000FF000000FF] %endif mov eax,[PARAM_SRC] %if %3 == 1 mov edx,[PARAM_SRC2] %endif pxor mm2,mm2 shr ecx,1 jnc %%Ltop movd mm1,[eax+ecx*8] ; Zdisp( movd,0,(%eax,%ecx,8),%mm1) %if %3 == 1 movd mm0,[edx+ecx*8] ; Zdisp( movd,0,(%edx,%ecx,8),%mm0)" pxor mm1,mm0 %endif inc ecx jmp %%Lloaded align 16 %if %3 == 0 nop %endif ; eax src ; ebx ; ecx counter,qwords,decrementing ; edx [hamdist] src2 ; ; mm0 (scratch) ; mm1 (scratch) ; mm2 total (low dword) ; mm3 ; mm4 \ ; mm5 | special constants ; mm6 | ; mm7 / %%Ltop: movq mm1,[eax+ecx*8-8] %if %3 == 1 pxor mm1,[edx+ecx*8-8] %endif %%Lloaded: movq mm0,mm1 pand mm1,REG_AAAAAAAAAAAAAAAA psrlq mm1,1 %if %3 == 1 nop %endif psubd mm0,mm1 ; bit pairs %if %3 == 1 nop %endif movq mm1,mm0 psrlq mm0,2 pand mm0,REG_3333333333333333 pand mm1,REG_3333333333333333 paddd mm0,mm1 ; nibbles movq mm1,mm0 psrlq mm0,4 pand mm0,REG_0F0F0F0F0F0F0F0F pand mm1,REG_0F0F0F0F0F0F0F0F paddd mm0,mm1 ; bytes movq mm1,mm0 psrlq mm0,8 paddb mm0,mm1 ; words movq mm1,mm0 psrlq mm0,16 paddd mm0,mm1 ; dwords pand mm0,REG_000000FF000000FF paddd mm2,mm0 ; low to total psrlq mm0,32 paddd mm2,mm0 ; high to total loop %%Ltop movd eax,mm2 emms ret %endmacro %define PARAM_SIZE esp+frame+8 %define PARAM_SRC esp+frame+4 %define frame 0 ph_fun ___g,mpn_popcount,0 %define PARAM_SIZE esp+frame+12 %define PARAM_SRC2 esp+frame+8 %define PARAM_SRC esp+frame+4 %define frame 0 ph_fun ___g,mpn_hamdist,1 end ecl-16.1.2/msvc/gmp/mpn/x86i/p6/mmx/rshift.asm000066400000000000000000000213151266352375300206340ustar00rootroot00000000000000 ; Copyright 2001 Free Software Foundation, Inc. ; ; This file is part of the GNU MP Library. ; ; The GNU MP Library is free software; you can redistribute it and/or ; modify it under the terms of the GNU Lesser General Public License as ; published by the Free Software Foundation; either version 2.1 of the ; License, or (at your option) any later version. ; ; The GNU MP Library is distributed in the hope that it will be useful, ; but WITHOUT ANY WARRANTY; without even the implied warranty of ; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ; Lesser General Public License for more details. ; ; You should have received a copy of the GNU Lesser General Public ; License along with the GNU MP Library; see the file COPYING.LIB. If ; not, write to the Free Software Foundation, Inc., 59 Temple Place - ; Suite 330, Boston, MA 02111-1307, USA. ; ; Translation of AT&T syntax code by Brian Gladman %include "..\..\x86i.inc" global ___gmpn_rshift %ifdef DLL export ___gmpn_rshift %endif %define PARAM_SHIFT esp+frame+16 %define PARAM_SIZE esp+frame+12 %define PARAM_SRC esp+frame+8 %define PARAM_DST esp+frame+4 %define frame 8 ; Minimum 5,because the unrolled loop can't handle less. %define UNROLL_THRESHOLD 5 section .text align 8 ___gmpn_rshift: push ebx push edi mov eax,[PARAM_SIZE] mov edx,[PARAM_DST] mov ebx,[PARAM_SRC] mov ecx,[PARAM_SHIFT] cmp eax,UNROLL_THRESHOLD jae Lunroll dec eax mov edi,[ebx] ; src low limb jnz Lsimple shrd eax,edi,cl shr edi,cl mov [edx],edi ; dst low limb pop edi ; risk of data cache bank clash pop ebx ret ; eax size-1 ; ebx src ; ecx shift ; edx dst ; esi ; edi ; ebp align 8 Lsimple: movd mm5,[ebx] ; src[0] lea ebx,[ebx+eax*4] ; &src[size-1] movd mm6,ecx ; rshift lea edx,[-4+edx+eax*4] ; &dst[size-2] psllq mm5,32 neg eax ; This loop is 5 or 8 cycles,with every second load unaligned and a wasted ; cycle waiting for the mm0 result to be ready. For comparison a shrdl is 4 ; cycles and would be 8 in a simple loop. Using mmx helps the return value ; and last limb calculations too. ; eax counter,limbs,negative ; ebx &src[size-1] ; ecx return value ; edx &dst[size-2] ; ; mm0 scratch ; mm5 return value ; mm6 shift Lsimple_top: movq mm0,[ebx+eax*4] inc eax psrlq mm0,mm6 movd [edx+eax*4],mm0 jnz Lsimple_top movd mm0,[ebx] psrlq mm5,mm6 ; return value psrlq mm0,mm6 pop edi movd eax,mm5 pop ebx movd [4+edx],mm0 emms ret ; eax size ; ebx src ; ecx shift ; edx dst ; esi ; edi ; ebp align 8 Lunroll: movd mm5,[ebx] ; src[0] mov edi,4 movd mm6,ecx ; rshift test ebx,edi psllq mm5,32 jz Lstart_src_aligned ; src isn't aligned,process low limb separately (marked xxx) and ; step src and dst by one limb,making src aligned. ; ; source ebx ; --+-------+-------+-------+ ; | xxx | ; --+-------+-------+-------+ ; 4mod8 0mod8 4mod8 ; ; dest edx ; --+-------+-------+ ; | | xxx | ; --+-------+-------+ movq mm0,[ebx] ; unaligned load psrlq mm0,mm6 add ebx,4 dec eax movd [edx],mm0 add edx,4 Lstart_src_aligned: movq mm1,[ebx] test edx,edi psrlq mm5,mm6 ; retval jz Lstart_dst_aligned ; dst isn't aligned,add 4 to make it so,and pretend the shift is ; 32 bits extra. Low limb of dst (marked xxx) handled here ; separately. ; ; source ebx ; --+-------+-------+ ; | mm1 | ; --+-------+-------+ ; 4mod8 0mod8 ; ; dest edx ; --+-------+-------+-------+ ; | xxx | ; --+-------+-------+-------+ ; 4mod8 0mod8 4mod8 movq mm0,mm1 add ecx,32 ; new shift psrlq mm0,mm6 movd mm6,ecx movd [edx],mm0 add edx,4 Lstart_dst_aligned: movq mm3,[8+ebx] neg ecx movq mm2,mm3 ; mm2 src qword add ecx,64 movd mm7,ecx psrlq mm1,mm6 lea ebx,[-12+ebx+eax*4] lea edx,[-20+edx+eax*4] psllq mm3,mm7 sub eax,7 ; size-7 por mm3,mm1 ; mm3 ready to store neg eax ; -(size-7) jns Lfinish ; This loop is the important bit,the rest is just support. Careful ; instruction scheduling achieves the claimed 1.75 c/l. The ; relevant parts of the pairing rules are: ; ; - mmx loads and stores execute only in the U pipe ; - only one mmx shift in a pair ; - wait one cycle before storing an mmx register result ; - the usual address generation interlock ; ; Two qword calculations are slightly interleaved. The instructions ; marked "C" belong to the second qword,and the "C prev" one is for ; the second qword from the previous iteration. ; eax counter,limbs,negative ; ebx &src[size-12] ; ecx ; edx &dst[size-12] ; esi ; edi ; ; mm0 ; mm1 ; mm2 src qword from -8(%ebx,%eax,4) ; mm3 dst qword ready to store to -8(%edx,%eax,4) ; ; mm5 return value ; mm6 rshift ; mm7 lshift align 8 Lunroll_loop: movq mm0,[ebx+eax*4] psrlq mm2,mm6 movq mm1,mm0 psllq mm0,mm7 movq [-8+edx+eax*4],mm3 por mm0,mm2 movq mm3,[ebx+eax*4+8] psrlq mm1,mm6 movq [edx+eax*4],mm0 movq mm2,mm3 psllq mm3,mm7 add eax,4 por mm3,mm1 js Lunroll_loop Lfinish: ; eax 0 to 3 representing respectively 3 to 0 limbs remaining test al,2 jnz Lfinish_no_two movq mm0,[ebx+eax*4] psrlq mm2,mm6 movq mm1,mm0 psllq mm0,mm7 movq [-8+edx+eax*4],mm3 ; prev por mm0,mm2 movq mm2,mm1 movq mm3,mm0 add eax,2 Lfinish_no_two: ; eax 2 or 3 representing respectively 1 or 0 limbs remaining ; ; mm2 src prev qword,from -8(%ebx,%eax,4) ; mm3 dst qword,for -8(%edx,%eax,4) test al,1 pop edi movd eax,mm5 ; retval jnz Lfinish_zero ; One extra limb,destination was aligned. ; ; source ebx ; +-------+---------------+-- ; | | mm2 | ; +-------+---------------+-- ; ; dest edx ; +-------+---------------+---------------+-- ; | | | mm3 | ; +-------+---------------+---------------+-- ; ; mm6 = shift ; mm7 = ecx = 64-shift ; One extra limb,destination was unaligned. ; ; source ebx ; +-------+---------------+-- ; | | mm2 | ; +-------+---------------+-- ; ; dest edx ; +---------------+---------------+-- ; | | mm3 | ; +---------------+---------------+-- ; ; mm6 = shift+32 ; mm7 = ecx = 64-(shift+32) ; In both cases there's one extra limb of src to fetch and combine ; with mm2 to make a qword at 8(%edx),and in the aligned case ; there's a further extra limb of dst to be formed. movd mm0,[8+ebx] psrlq mm2,mm6 movq mm1,mm0 psllq mm0,mm7 movq [edx],mm3 por mm0,mm2 psrlq mm1,mm6 and ecx,32 pop ebx jz Lfinish_one_unaligned ; dst was aligned,must store one extra limb movd [16+edx],mm1 Lfinish_one_unaligned: movq [8+edx],mm0 emms ret Lfinish_zero: ; No extra limbs,destination was aligned. ; ; source ebx ; +---------------+-- ; | mm2 | ; +---------------+-- ; ; dest edx+4 ; +---------------+---------------+-- ; | | mm3 | ; +---------------+---------------+-- ; ; mm6 = shift ; mm7 = ecx = 64-shift ; No extra limbs,destination was unaligned. ; ; source ebx ; +---------------+-- ; | mm2 | ; +---------------+-- ; ; dest edx+4 ; +-------+---------------+-- ; | | mm3 | ; +-------+---------------+-- ; ; mm6 = shift+32 ; mm7 = 64-(shift+32) ; The movd for the unaligned case is clearly the same data as the ; movq for the aligned case,it's just a choice between whether one ; or two limbs should be written. movq [4+edx],mm3 psrlq mm2,mm6 movd [12+edx],mm2 and ecx,32 pop ebx jz Lfinish_zero_unaligned movq [12+edx],mm2 Lfinish_zero_unaligned: emms ret end ecl-16.1.2/msvc/gmp/mpn/x86i/p6/mod_1.asm000066400000000000000000000205341266352375300175350ustar00rootroot00000000000000 ; Copyright 1999, 2000, 2002 Free Software Foundation, Inc. ; ; This file is part of the GNU MP Library. ; ; The GNU MP Library is free software; you can redistribute it and/or ; modify it under the terms of the GNU Lesser General Public License as ; published by the Free Software Foundation; either version 2.1 of the ; License, or (at your option) any later version. ; ; The GNU MP Library is distributed in the hope that it will be useful, ; but WITHOUT ANY WARRANTY; without even the implied warranty of ; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ; Lesser General Public License for more details. ; ; You should have received a copy of the GNU Lesser General Public ; License along with the GNU MP Library; see the file COPYING.LIB. If ; not, write to the Free Software Foundation, Inc., 59 Temple Place - ; Suite 330, Boston, MA 02111-1307, USA. ; ; Translation of AT&T syntax code by Brian Gladman %include "..\x86i.inc" global ___gmpn_preinv_mod_1 global ___gmpn_mod_1c global ___gmpn_mod_1 %ifdef DLL export ___gmpn_mod_1c export ___gmpn_mod_1 %endif %define MUL_NORM_THRESHOLD 4 %define MUL_UNNORM_THRESHOLD 5 %define MUL_NORM_DELTA MUL_NORM_THRESHOLD - MUL_UNNORM_THRESHOLD %define PARAM_INVERSE esp+frame+16 %define PARAM_CARRY esp+frame+16 %define PARAM_DIVISOR esp+frame+12 %define PARAM_SIZE esp+frame+8 %define PARAM_SRC esp+frame+4 %define SAVE_EBX esp+frame-4 %define SAVE_ESI esp+frame-8 %define SAVE_EDI esp+frame-12 %define SAVE_EBP esp+frame-16 %define VAR_NORM esp+frame-20 %define VAR_INVERSE esp+frame-24 %define STACK_SPACE 24 section .text align 16 %define frame 0 ___gmpn_preinv_mod_1: mov edx,[PARAM_SRC] sub esp,STACK_SPACE FR_sesp STACK_SPACE mov [SAVE_EBX],ebx mov ebx,[PARAM_SIZE] mov [SAVE_EBP],ebp mov ebp,[PARAM_DIVISOR] mov [SAVE_ESI],esi mov eax,[PARAM_INVERSE] mov [SAVE_EDI],edi mov edi,[-4+edx+ebx*4] ; src high limb mov [VAR_NORM],dword 0 lea ecx,[-8+edx+ebx*4] ; &src[size-2] mov esi,edi sub edi,ebp ; high-divisor cmovc edi,esi dec ebx jnz Lpreinv_entry jmp Ldone_edi align 16 %define frame 0 ___gmpn_mod_1c: mov ecx,[PARAM_SIZE] sub esp,STACK_SPACE FR_sesp STACK_SPACE mov [SAVE_EBP],ebp mov eax,[PARAM_DIVISOR] mov [SAVE_ESI],esi mov edx,[PARAM_CARRY] mov esi,[PARAM_SRC] or ecx,ecx jz Ldone_edx ; result==carry if size==0 sar eax,31 mov ebp,[PARAM_DIVISOR] and eax,MUL_NORM_DELTA add eax,MUL_UNNORM_THRESHOLD cmp ecx,eax jb Ldivide_top ; The carry parameter pretends to be the src high limb. mov [SAVE_EBX],ebx lea ebx,[1+ecx] ; size+1 mov eax,edx ; carry jmp Lmul_by_inverse_1c align 16 %define frame 0 ___gmpn_mod_1: mov ecx,[PARAM_SIZE] sub esp,STACK_SPACE FR_sesp STACK_SPACE mov edx,0 ; initial carry (if can't skip a div) mov [SAVE_ESI],esi mov eax,[PARAM_SRC] mov [SAVE_EBP],ebp mov ebp,[PARAM_DIVISOR] mov esi,[PARAM_DIVISOR] or ecx,ecx jz Ldone_edx mov eax,[-4+eax+ecx*4] ; src high limb sar ebp,31 and ebp,MUL_NORM_DELTA add ebp,MUL_UNNORM_THRESHOLD cmp eax,esi ; carry flag if high n2 sub eax,ebp cmovnc edi,eax mov eax,-1 mov edx,-1 sub edx,ebp ; (b-d)-1 so edx:eax = b*(b-d)-1 lea ecx,[-8+esi+ebx*4] ; &src[size-2] div ebp ; floor (b*(b-d)-1) / d Lpreinv_entry: mov [VAR_INVERSE],eax ; No special scheduling of loads is necessary in this loop,out of order ; execution hides the latencies already. ; ; The way q1+1 is generated in %ebx and d is moved to %eax for the multiply ; seems fastest. The obvious change to generate q1+1 in %eax and then just ; multiply by %ebp (as per mpn/x86/pentium/mod_1.asm in fact) runs 1 cycle ; slower,for no obvious reason. ; eax n10 (then scratch) ; ebx scratch (nadj,q1) ; ecx src pointer,decrementing ; edx scratch ; esi n10 ; edi n2 ; ebp divisor align 16 Linverse_top: mov eax,[ecx] ; next src limb mov esi,eax sar eax,31 ; -n1 mov ebx,ebp and ebx,eax ; -n1 & d neg eax ; n1 add eax,edi ; n2+n1 mul dword [VAR_INVERSE] ; m*(n2+n1) add ebx,esi ; nadj = n10 + (-n1 & d),ignoring overflow sub ecx,4 add eax,ebx ; m*(n2+n1) + nadj,low giving carry flag lea ebx,[1+edi] ; n2+1 mov eax,ebp ; d adc ebx,edx ; 1 + high(n2<<32 + m*(n2+n1) + nadj) = q1+1 jz Lq1_ff mul ebx ; (q1+1)*d sub esi,eax ; low n - (q1+1)*d sbb edi,edx ; high n - (q1+1)*d,0 or -1 and edi,ebp ; d if underflow add edi,esi ; remainder with addback if necessary cmp ecx,[PARAM_SRC] jae Linverse_top ; %edi is the remainder modulo d*2^n and now must be reduced to ; 0<=r next n2 cmp ecx,[PARAM_SRC] jae Linverse_top jmp Linverse_loop_done end ecl-16.1.2/msvc/gmp/mpn/x86i/p6/mode1o.asm000066400000000000000000000071241266352375300177220ustar00rootroot00000000000000 ; Copyright 2000, 2001, 2002 Free Software Foundation, Inc. ; ; This file is part of the GNU MP Library. ; ; The GNU MP Library is free software; you can redistribute it and/or ; modify it under the terms of the GNU Lesser General Public License as ; published by the Free Software Foundation; either version 2.1 of the ; License, or (at your option) any later version. ; ; The GNU MP Library is distributed in the hope that it will be useful, ; but WITHOUT ANY WARRANTY; without even the implied warranty of ; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ; Lesser General Public License for more details. ; ; You should have received a copy of the GNU Lesser General Public ; License along with the GNU MP Library; see the file COPYING.LIB. If ; not, write to the Free Software Foundation, Inc., 59 Temple Place - ; Suite 330, Boston, MA 02111-1307, USA. ; ; Translation of AT&T syntax code by Brian Gladman %include "..\x86i.inc" extern ___gmp_modlimb_invert_table global ___gmpn_modexact_1c_odd global ___gmpn_modexact_1_odd %ifdef DLL export ___gmpn_modexact_1c_odd export ___gmpn_modexact_1_odd %endif %define PARAM_CARRY esp+frame+16 %define PARAM_DIVISOR esp+frame+12 %define PARAM_SIZE esp+frame+8 %define PARAM_SRC esp+frame+4 ; Not enough room under modexact_1 to make these re-use the parameter ; space,unfortunately. %define SAVE_EBX esp+frame-4 %define SAVE_ESI esp+frame-8 %define SAVE_EDI esp+frame-12 %define STACK_SPACE 12 %define frame 0 section .text align 16 ___gmpn_modexact_1c_odd: mov ecx,[PARAM_CARRY] jmp Lstart_1c align 16 ___gmpn_modexact_1_odd: xor ecx,ecx Lstart_1c: mov eax,[PARAM_DIVISOR] sub esp,STACK_SPACE FR_sesp STACK_SPACE mov [SAVE_ESI],esi mov esi,[PARAM_SRC] shr eax,1 ; d/2 mov [SAVE_EDI],edi and eax,127 %ifdef PIC call Lmovl_eip_edi add edi,_GLOBAL_OFFSET_TABLE_ mov edi,[___gmp_modlimb_invert_table+edi] movzx edi,byte [eax+edi] ; inv 8 bits %else movzx edi,byte [___gmp_modlimb_invert_table+eax] ; inv 8 bits %endif xor edx,edx ; initial extra carry lea eax,[edi+edi] ; 2*inv imul edi,edi ; inv*inv mov [SAVE_EBX],ebx mov ebx,[PARAM_SIZE] imul edi,[PARAM_DIVISOR] ; inv*inv*d sub eax,edi ; inv = 2*inv - inv*inv*d lea edi,[eax+eax] ; 2*inv imul eax,eax ; inv*inv imul eax,[PARAM_DIVISOR] ; inv*inv*d lea esi,[esi+ebx*4] ; src end neg ebx ; -size sub edi,eax ; inv = 2*inv - inv*inv*d ; The dependent chain here is ; ; subl %edx,%eax 1 ; imull %edi,%eax 4 ; mull PARAM_DIVISOR 5 ; ---- ; total 10 ; ; and this is the measured speed. No special scheduling is necessary,out ; of order execution hides the load latency. ; ; eax scratch (src limb) ; ebx counter,limbs,negative ; ecx carry bit,0 or 1 ; edx carry limb,high of last product ; esi &src[size] ; edi inverse ; ebp Ltop: mov eax,[esi+ebx*4] sub eax,ecx sbb ecx,ecx sub eax,edx sbb ecx,0 imul eax,edi neg ecx mul dword [PARAM_DIVISOR] inc ebx jnz Ltop mov esi,[SAVE_ESI] lea eax,[ecx+edx] mov edi,[SAVE_EDI] mov ebx,[SAVE_EBX] add esp,STACK_SPACE ret %ifdef PIC Lmovl_eip_edi: mov edi,[esp] ret %endif end ecl-16.1.2/msvc/gmp/mpn/x86i/p6/p3mmx/000077500000000000000000000000001266352375300170745ustar00rootroot00000000000000ecl-16.1.2/msvc/gmp/mpn/x86i/p6/p3mmx/popham.asm000066400000000000000000000063071266352375300210700ustar00rootroot00000000000000 ; Copyright 2000, 2002 Free Software Foundation, Inc. ; ; This file is part of the GNU MP Library. ; ; The GNU MP Library is free software; you can redistribute it and/or ; modify it under the terms of the GNU Lesser General Public License as ; published by the Free Software Foundation; either version 2.1 of the ; License, or (at your option) any later version. ; ; The GNU MP Library is distributed in the hope that it will be useful, ; but WITHOUT ANY WARRANTY; without even the implied warranty of ; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ; Lesser General Public License for more details. ; ; You should have received a copy of the GNU Lesser General Public ; License along with the GNU MP Library; see the file COPYING.LIB. If ; not, write to the Free Software Foundation, Inc., 59 Temple Place - ; Suite 330, Boston, MA 02111-1307, USA. ; ; Translation of AT&T syntax code by Brian Gladman %define REG_AAAAAAAAAAAAAAAA mm7 %define REG_3333333333333333 mm6 %define REG_0F0F0F0F0F0F0F0F mm5 %define REG_0000000000000000 mm4 %ifndef PIC section .data align 8 Lrodata_AAAAAAAAAAAAAAAA: dd 0AAAAAAAAh dd 0AAAAAAAAh Lrodata_3333333333333333: dd 033333333h dd 033333333h Lrodata_0F0F0F0F0F0F0F0F: dd 00F0F0F0Fh dd 00F0F0F0Fh %endif %macro ph_fun 3 align 32 global %1%2 %ifdef DLL export %1%2 %endif %1%2: mov ecx,[PARAM_SIZE] %ifdef PIC mov eax,0xAAAAAAAA mov edx,0x33333333 movd mm7,eax movd mm6,edx mov eax,0x0F0F0F0F punpckldq mm7,mm7 punpckldq mm6,mm6 movd mm5,eax movd mm4,edx punpckldq mm5,mm5 %else movq mm7,[Lrodata_AAAAAAAAAAAAAAAA] movq mm6,[Lrodata_3333333333333333] movq mm5,[Lrodata_0F0F0F0F0F0F0F0F] %endif pxor mm4,mm4 mov eax,[PARAM_SRC] %if %3 == 1 mov edx,[PARAM_SRC2] %endif pxor mm2,mm2 shr ecx,1 jnc %%Ltop movd mm1,[eax+ecx*8] %if %3 == 1 movd mm0,[edx+ecx*8] pxor mm1,mm0 %endif or ecx,ecx jmp %%Lloaded ; eax src ; ebx ; ecx counter,qwords,decrementing ; edx [hamdist] src2 ; ; mm0 (scratch) ; mm1 (scratch) ; mm2 total (low dword) ; mm3 ; mm4 \ ; mm5 | special constants ; mm6 | ; mm7 / align 16 %%Ltop: movq mm1,[eax+ecx*8-8] %if %3 == 1 pxor mm1,[edx+ecx*8-8] %endif dec ecx %%Lloaded: movq mm0,mm1 pand mm1,REG_AAAAAAAAAAAAAAAA psrlq mm1,1 psubd mm0,mm1 ; bit pairs movq mm1,mm0 psrlq mm0,2 pand mm0,REG_3333333333333333 pand mm1,REG_3333333333333333 paddd mm0,mm1 ; nibbles movq mm1,mm0 psrlq mm0,4 pand mm0,REG_0F0F0F0F0F0F0F0F pand mm1,REG_0F0F0F0F0F0F0F0F paddd mm0,mm1 ; bytes psadbw mm0,mm4 paddd mm2,mm0 ; add to total jnz %%Ltop movd eax,mm2 emms ret %endmacro section .text %define PARAM_SIZE esp+frame+8 %define PARAM_SRC esp+frame+4 %define frame 0 ph_fun ___g,mpn_popcount,0 %define PARAM_SIZE esp+frame+12 %define PARAM_SRC2 esp+frame+8 %define PARAM_SRC esp+frame+4 %define frame 0 ph_fun ___g,mpn_hamdist,1 end ecl-16.1.2/msvc/gmp/mpn/x86i/p6/sqr_basecase.asm000066400000000000000000000262711266352375300211750ustar00rootroot00000000000000 ; Copyright 1999, 2000, 2002 Free Software Foundation, Inc. ; ; This file is part of the GNU MP Library. ; ; The GNU MP Library is free software; you can redistribute it and/or ; modify it under the terms of the GNU Lesser General Public License as ; published by the Free Software Foundation; either version 2.1 of the ; License, or (at your option) any later version. ; ; The GNU MP Library is distributed in the hope that it will be useful, ; but WITHOUT ANY WARRANTY; without even the implied warranty of ; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ; Lesser General Public License for more details. ; ; You should have received a copy of the GNU Lesser General Public ; License along with the GNU MP Library; see the file COPYING.LIB. If ; not, write to the Free Software Foundation, Inc., 59 Temple Place - ; Suite 330, Boston, MA 02111-1307, USA. ; ; Translation of AT&T syntax code by Brian Gladman %include "..\x86i.inc" global ___gmpn_sqr_basecase %ifdef DLL export ___gmpn_sqr_basecase %endif %define UNROLL_COUNT 64 ; seems to be maximum required (I hope!) %define PARAM_SIZE esp+frame+12 %define PARAM_SRC esp+frame+8 %define PARAM_DST esp+frame+4 %define frame 0 section .text align 32 ___gmpn_sqr_basecase: mov edx,[PARAM_SIZE] mov eax,[PARAM_SRC] cmp edx,2 mov ecx,[PARAM_DST] je Ltwo_limbs mov eax,[eax] ja Lthree_or_more ; one limb only ; eax src limb ; ebx ; ecx dst ; edx mul eax mov [ecx],eax mov [4+ecx],edx ret ; eax src ; ebx ; ecx dst ; edx %define SAVE_ESI esp+frame-4 %define SAVE_EBX esp+frame-8 %define SAVE_EDI esp+frame-12 %define SAVE_EBP esp+frame-16 %define frame 16 Ltwo_limbs: sub esp,frame mov [SAVE_ESI],esi mov esi,eax mov eax,[eax] mul eax ; src[0]^2 mov [ecx],eax ; dst[0] mov eax,[4+esi] mov [SAVE_EBX],ebx mov ebx,edx ; dst[1] mul eax ; src[1]^2 mov [SAVE_EDI],edi mov edi,eax ; dst[2] mov eax,[esi] mov [SAVE_EBP],ebp mov ebp,edx ; dst[3] mul dword [4+esi] ; src[0]*src[1] add ebx,eax mov esi,[SAVE_ESI] adc edi,edx adc ebp,0 add eax,ebx mov ebx,[SAVE_EBX] adc edx,edi mov edi,[SAVE_EDI] adc ebp,0 mov [4+ecx],eax mov [12+ecx],ebp mov ebp,[SAVE_EBP] mov [8+ecx],edx add esp,frame ret ; eax src low limb ; ebx ; ecx dst ; edx size Lthree_or_more: sub esp,frame mov [SAVE_ESI],esi cmp edx,4 mov esi,[PARAM_SRC] jae Lfour_or_more ; three limbs ; eax src low limb ; ebx ; ecx dst ; edx ; esi src ; edi ; ebp mov [SAVE_EBP],ebp mov [SAVE_EDI],edi mul eax ; src[0] ^ 2 mov [ecx],eax mov [4+ecx],edx mov eax,[4+esi] xor ebp,ebp mul eax ; src[1] ^ 2 mov [8+ecx],eax mov [12+ecx],edx mov eax,[8+esi] mov [SAVE_EBX],ebx mul eax ; src[2] ^ 2 mov [16+ecx],eax mov [20+ecx],edx mov eax,[esi] mul dword [4+esi] ; src[0] * src[1] mov ebx,eax mov edi,edx mov eax,[esi] mul dword [8+esi] ; src[0] * src[2] add edi,eax mov ebp,edx adc ebp,0 mov eax,[4+esi] mul dword [8+esi] ; src[1] * src[2] xor esi,esi add ebp,eax ; eax ; ebx dst[1] ; ecx dst ; edx dst[4] ; esi zero,will be dst[5] ; edi dst[2] ; ebp dst[3] adc edx,0 add ebx,ebx adc edi,edi adc ebp,ebp adc edx,edx mov eax,[4+ecx] adc esi,0 add eax,ebx mov [4+ecx],eax mov eax,[8+ecx] adc eax,edi mov ebx,[12+ecx] adc ebx,ebp mov edi,[16+ecx] mov [8+ecx],eax mov ebp,[SAVE_EBP] mov [12+ecx],ebx mov ebx,[SAVE_EBX] adc edi,edx mov eax,[20+ecx] mov [16+ecx],edi mov edi,[SAVE_EDI] adc eax,esi ; no carry out of this mov esi,[SAVE_ESI] mov [20+ecx],eax add esp,frame ret ; eax src low limb ; ebx ; ecx ; edx size ; esi src ; edi ; ebp ; First multiply src[0]*src[1..size-1] and store at dst[1..size]. %define VAR_COUNTER esp+frame-20 %define VAR_JMP esp+frame-24 %define STACK_SPACE 24 Lfour_or_more: sub esp,STACK_SPACE-frame %define frame STACK_SPACE mov ecx,1 mov [SAVE_EDI],edi mov edi,[PARAM_DST] mov [SAVE_EBX],ebx sub ecx,edx ; -(size-1) mov [SAVE_EBP],ebp mov ebx,0 ; initial carry lea esi,[esi+edx*4] ; &src[size] mov ebp,eax ; multiplier lea edi,[-4+edi+edx*4] ; &dst[size-1] ; This loop runs at just over 6 c/l. ; eax scratch ; ebx carry ; ecx counter,limbs,negative,-(size-1) to -1 ; edx scratch ; esi &src[size] ; edi &dst[size-1] ; ebp multiplier Lmul_1: mov eax,ebp mul dword [esi+ecx*4] add eax,ebx mov ebx,0 adc ebx,edx mov [4+edi+ecx*4],eax inc ecx jnz Lmul_1 mov [4+edi],ebx ; Addmul src[n]*src[n+1..size-1] at dst[2*n-1...],for each n=1..size-2. ; ; The last two addmuls,which are the bottom right corner of the product ; triangle,are left to the end. These are src[size-3]*src[size-2,size-1] ; and src[size-2]*src[size-1]. If size is 4 then it's only these corner ; cases that need to be done. ; ; The unrolled code is the same as mpn_addmul_1(),see that routine for some ; comments. ; ; VAR_COUNTER is the outer loop,running from -(size-4) to -1,inclusive. ; ; VAR_JMP is the computed jump into the unrolled code,stepped by one code ; chunk each outer loop. ; ; This is also hard-coded in the address calculation below. ; ; With &src[size] and &dst[size-1] pointers,the displacements in the ; unrolled code fit in a byte for UNROLL_COUNT values up to 32,but above ; that an offset must be added to them. ; ; eax ; ebx carry ; ecx ; edx ; esi &src[size] ; edi &dst[size-1] ; ebp %define CODE_BYTES_PER_LIMB 15 %if UNROLL_COUNT > 32 %define OFFSET 4*(UNROLL_COUNT-32) %else %define OFFSET 0 %endif mov ecx,[PARAM_SIZE] sub ecx,4 jz Lcorner mov edx,ecx neg ecx shl ecx,4 %if OFFSET != 0 sub esi,OFFSET %endif %ifdef PIC call Lhere Lhere: add ecx,[esp] add ecx,Lunroll_inner_end-Lhere-(2*CODE_BYTES_PER_LIMB) add ecx,edx add esp,4 %else lea ecx,[Lunroll_inner_end-2*CODE_BYTES_PER_LIMB+ecx+edx] %endif neg edx %if OFFSET != 0 sub edi,OFFSET %endif ; The calculated jump mustn't be before the start of the available ; code. This is the limit that UNROLL_COUNT puts on the src operand ; size,but checked here using the jump address directly. ; ASSERT(ae,movl_text_address( Lunroll_inner_start,%eax) cmpl %eax,%ecx) %ifdef ASSERT mov eax,Lunroll_inner_start cmp ecx,eax jae Lunroll_outer_top jmp exit %endif ; eax ; ebx high limb to store ; ecx VAR_JMP ; edx VAR_COUNTER,limbs,negative ; esi &src[size],constant ; edi dst ptr,second highest limb of last addmul ; ebp %if UNROLL_COUNT % 2 == 1 %define cmovX cmovz %else %define cmovX cmovnz %endif align 16 Lunroll_outer_top: mov ebp,[-12+OFFSET+esi+edx*4] ; multiplier mov [VAR_COUNTER],edx mov eax,[-8+OFFSET+esi+edx*4] ; first limb of multiplicand mul ebp test cl,1 mov ebx,edx ; high carry lea edi,[4+edi] mov edx,ecx ; jump mov ecx,eax ; low carry lea edx,[CODE_BYTES_PER_LIMB+edx] cmovX ecx,ebx cmovX ebx,eax mov [VAR_JMP],edx jmp edx ; Must be on an even address here so the low bit of the jump address ; will indicate which way around ecx/ebx should start. ; eax scratch ; ebx carry high ; ecx carry low ; edx scratch ; esi src pointer ; edi dst pointer ; ebp multiplier ; ; 15 code bytes each limb ; ecx/ebx reversed on each chunk align 2 Lunroll_inner_start: %assign i UNROLL_COUNT %rep UNROLL_COUNT %assign disp_src OFFSET-4*i %assign disp_dst disp_src ; m4_assert(disp_src>=-128 && disp_src<128) ; m4_assert(disp_dst>=-128 && disp_dst<128) mov eax,[byte disp_src+esi] mul ebp %if i % 2 == 0 add [byte disp_dst+edi],ebx adc ecx,eax mov ebx,edx adc ebx,0 %else add [byte disp_dst+edi],ecx adc ebx,eax mov ecx,edx adc ecx,0 %endif %assign i i-1 %endrep Lunroll_inner_end: add [OFFSET+edi],ebx mov edx,[VAR_COUNTER] adc ecx,0 mov [OFFSET+4+edi],ecx mov ecx,[VAR_JMP] inc edx jnz Lunroll_outer_top %if OFFSET != 0 add esi,OFFSET add edi,OFFSET %endif ; eax ; ebx ; ecx ; edx ; esi &src[size] ; edi &dst[2*size-5] ; ebp align 16 Lcorner: mov eax,[-12+esi] mul dword [-8+esi] add [edi],eax mov eax,[-12+esi] mov ebx,0 adc ebx,edx mul dword [-4+esi] add ebx,eax mov eax,[-8+esi] adc edx,0 add [4+edi],ebx mov ebx,0 adc ebx,edx mul dword [-4+esi] mov ecx,[PARAM_SIZE] add eax,ebx adc edx,0 mov [8+edi],eax mov [12+edi],edx mov edi,[PARAM_DST] ; Left shift of dst[1..2*size-2],the bit shifted out becomes dst[2*size-1]. sub ecx,1 ; size-1 xor eax,eax ; ready for final adcl,and clear carry mov edx,ecx mov esi,[PARAM_SRC] ; eax ; ebx ; ecx counter,size-1 to 1 ; edx size-1 (for later use) ; esi src (for later use) ; edi dst,incrementing ; ebp Llshift: rcl dword [4+edi],1 rcl dword [8+edi],1 lea edi,[8+edi] dec ecx jnz Llshift adc eax,eax mov [4+edi],eax ; dst most significant limb mov eax,[esi] ; src[0] lea esi,[4+esi+edx*4] ; &src[size] sub ecx,edx ; -(size-1) ; Now add in the squares on the diagonal,src[0]^2,src[1]^2,..., ; src[size-1]^2. dst[0] hasn't yet been set at all yet,and just gets the ; low limb of src[0]^2. mul eax mov [edi+ecx*8],eax ; dst[0] ; eax scratch ; ebx scratch ; ecx counter,negative ; edx carry ; esi &src[size] ; edi dst[2*size-2] ; ebp Ldiag: mov eax,[esi+ecx*4] mov ebx,edx mul eax add [4+edi+ecx*8],ebx adc [8+edi+ecx*8],eax adc edx,0 inc ecx jnz Ldiag mov esi,[SAVE_ESI] mov ebx,[SAVE_EBX] add [4+edi],edx ; dst most significant limb mov edi,[SAVE_EDI] mov ebp,[SAVE_EBP] add esp,frame ret end ecl-16.1.2/msvc/gmp/mpn/x86i/p6/sqr_basecase.old.asm000066400000000000000000000275051266352375300217530ustar00rootroot00000000000000 ; Intel P6 mpn_sqr_basecase -- square an mpn number. ; ; Copyright 1999,2000,2002 Free Software Foundation,Inc. ; ; This file is part of the GNU MP Library. ; ; The GNU MP Library is free software; you can redistribute it and/or ; modify it under the terms of the GNU Lesser General Public License as ; published by the Free Software Foundation; either version 2.1 of the ; License,or (at your option) any later version. ; ; The GNU MP Library is distributed in the hope that it will be useful, ; but WITHOUT ANY WARRANTY; without even the implied warranty of ; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ; Lesser General Public License for more details. ; ; You should have received a copy of the GNU Lesser General Public ; License along with the GNU MP Library; see the file COPYING.LIB. If ; not,write to the Free Software Foundation,Inc.,59 Temple Place - ; Suite 330,Boston,MA 02111-1307,USA. ; ; P6: approx 4.0 cycles per cross product,or 7.75 cycles per triangular ; product (measured on the speed difference between 20 and 40 limbs, ; which is the Karatsuba recursing range). ; ; These are the same as in mpn/x86/k6/sqr_basecase.asm,see that file for ; a description. The only difference here is that UNROLL_COUNT can go up ; to 64 (not 63) making SQR_KARATSUBA_THRESHOLD_MAX 67. ; ; void mpn_sqr_basecase (mp_ptr dst,mp_srcptr src,mp_size_t size); ; ; The algorithm is basically the same as mpn/generic/sqr_basecase.c,but a ; lot of function call overheads are avoided,especially when the given size ; is small. ; ; The code size might look a bit excessive,but not all of it is executed so ; it won't all get into the code cache. The 1x1,2x2 and 3x3 special cases ; clearly apply only to those sizes; mid sizes like 10x10 only need part of ; the unrolled addmul; and big sizes like 40x40 that do use the full ; unrolling will least be making good use of it,because 40x40 will take ; something like 7000 cycles. %include "..\\x86i.inc" %define SQR_KARATSUBA_THRESHOLD 10 %define SQR_KARATSUBA_THRESHOLD_MAX 67 %ifdef SQR_KARATSUBA_THRESHOLD_OVERRIDE %define SQR_KARATSUBA_THRESHOLD SQR_KARATSUBA_THRESHOLD_OVERRIDE %endif %define UNROLL_COUNT SQR_KARATSUBA_THRESHOLD-3 FR_def PARAM_SIZE,12 FR_def PARAM_SRC,8 FR_def PARAM_DST,4 section .text global ___gmpn_sqr_basecase align 32 ___gmpn_sqr_basecase: mov edx,[PARAM_SIZE] mov eax,[PARAM_SRC] cmp edx,2 mov ecx,[PARAM_DST] je Ltwo_limbs mov eax,[eax] ja Lthree_or_more ; one limb only ; eax src limb ; ebx ; ecx dst ; edx mul eax mov [ecx],eax mov [4+ecx],edx ret ; eax src ; ebx ; ecx dst ; edx FR_def SAVE_ESI, -4 FR_def SAVE_EBX, -8 FR_def SAVE_EDI,-12 FR_def SAVE_EBP,-16 %define STACK_SPACE 16 %define frame 16 Ltwo_limbs: sub esp,frame mov [SAVE_ESI],esi mov esi,eax mov eax,[eax] mul eax ; src[0]^2 mov [ecx],eax ; dst[0] mov eax,[4+esi] mov [SAVE_EBX],ebx mov ebx,edx ; dst[1] mul eax ; src[1]^2 mov [SAVE_EDI],edi mov edi,eax ; dst[2] mov eax,[esi] mov [SAVE_EBP],ebp mov ebp,edx ; dst[3] mul dword [4+esi] ; src[0]*src[1] add ebx,eax mov esi,[SAVE_ESI] adc edi,edx adc ebp,0 add eax,ebx mov ebx,[SAVE_EBX] adc edx,edi mov edi,[SAVE_EDI] adc ebp,0 mov [4+ecx],eax mov [12+ecx],ebp mov ebp,[SAVE_EBP] mov [8+ecx],edx add esp,frame ret ; eax src low limb ; ebx ; ecx dst ; edx size %define frame 0 Lthree_or_more: FR_push esi cmp edx,4 mov esi,[PARAM_SRC] jae Lfour_or_more ; three limbs ; ; eax src low limb ; ebx ; ecx dst ; edx ; esi src ; edi ; ebp %undef SAVE_EBP %undef SAVE_EDI %undef SAVE_EBX FR_push ebp,SAVE_EBP FR_push edi,SAVE_EDI mul eax ; src[0] ^ 2 mov [ecx],eax mov [4+ecx],edx mov eax,[4+esi] xor ebp,ebp mul eax ; src[1] ^ 2 mov [8+ecx],eax mov [12+ecx],edx mov eax,[8+esi] FR_push ebx,SAVE_EBX mul eax ; src[2] ^ 2 mov [16+ecx],eax mov [20+ecx],edx mov eax,[esi] mul dword [4+esi] ; src[0] * src[1] mov ebx,eax mov edi,edx mov eax,[esi] mul dword [8+esi] ; src[0] * src[2] add edi,eax mov ebp,edx adc ebp,0 mov eax,[4+esi] mul dword [8+esi] ; src[1] * src[2] xor esi,esi add ebp,eax ; eax ; ebx dst[1] ; ecx dst ; edx dst[4] ; esi zero,will be dst[5] ; edi dst[2] ; ebp dst[3] adc edx,0 add ebx,ebx adc edi,edi adc ebp,ebp adc edx,edx mov eax,[4+ecx] adc esi,0 add eax,ebx mov [4+ecx],eax mov eax,[8+ecx] adc eax,edi mov ebx,[12+ecx] adc ebx,ebp mov edi,[16+ecx] mov [8+ecx],eax mov ebp,[SAVE_EBP] mov [12+ecx],ebx mov ebx,[SAVE_EBX] adc edi,edx mov eax,[20+ecx] mov [16+ecx],edi mov edi,[SAVE_EDI] adc eax,esi ; no carry out of this mov esi,[SAVE_ESI] mov [20+ecx],eax add esp,frame ret ; eax src low limb ; ebx ; ecx ; edx size ; esi src ; edi ; ebp %define VAR_COUNTER esp+frame-20 %define VAR_JMP esp+frame-24 %define STACK_SPACE 24 %define frame 4 ; First multiply src[0]*src[1..size-1] and store at dst[1..size]. Lfour_or_more: sub esp,STACK_SPACE-frame %define frame STACK_SPACE mov ecx,1 mov [SAVE_EDI],edi mov edi,[PARAM_DST] mov [SAVE_EBX],ebx sub ecx,edx ; -(size-1) mov [SAVE_EBP],ebp mov ebx,0 ; initial carry lea esi,[esi+edx*4] ; &src[size] mov ebp,eax ; multiplier lea edi,[-4+edi+edx*4] ; &dst[size-1] ; This loop runs at just over 6 c/l. ; ; eax scratch ; ebx carry ; ecx counter,limbs,negative,-(size-1) to -1 ; edx scratch ; esi &src[size] ; edi &dst[size-1] ; ebp multiplier Lmul_1: mov eax,ebp mul dword [esi+ecx*4] add eax,ebx mov ebx,0 adc ebx,edx mov [4+edi+ecx*4],eax inc ecx jnz Lmul_1 mov [4+edi],ebx ; Addmul src[n]*src[n+1..size-1] at dst[2*n-1...],for each n=1..size-2. ; ; The last two addmuls,which are the bottom right corner of the product ; triangle,are left to the end. These are src[size-3]*src[size-2,size-1] ; and src[size-2]*src[size-1]. If size is 4 then it's only these corner ; cases that need to be done. ; ; The unrolled code is the same as mpn_addmul_1(),see that routine for some ; comments. ; ; VAR_COUNTER is the outer loop,running from -(size-4) to -1,inclusive. ; ; VAR_JMP is the computed jump into the unrolled code,stepped by one code ; chunk each outer loop. ; ; This is also hard-coded in the address calculation below. ; ; With &src[size] and &dst[size-1] pointers,the displacements in the ; unrolled code fit in a byte for UNROLL_COUNT values up to 32,but above ; that an offset must be added to them. ; ; eax ; ebx carry ; ecx ; edx ; esi &src[size] ; edi &dst[size-1] ; ebp %define CODE_BYTES_PER_LIMB 15 %if UNROLL_COUNT > 32 %define OFFSET UNROLL_COUNT-32 %else %define OFFSET 0 %endif mov ecx,[PARAM_SIZE] sub ecx,4 jz Lcorner mov edx,ecx neg ecx shl ecx,4 %if OFFSET != 0 sub esi,OFFSET %endif %ifdef PIC call Lhere Lhere: add ecx,[esp] add ecx,Lunroll_inner_end-Lhere-2*CODE_BYTES_PER_LIMB add ecx,edx add esp,4 %else lea ecx,[Lunroll_inner_end-2*CODE_BYTES_PER_LIMB+ecx+edx] %endif neg edx %if OFFSET != 0 sub edi,OFFSET %endif ; The calculated jump mustn't be before the start of the available ; code. This is the limit that UNROLL_COUNT puts on the src operand ; size,but checked here using the jump address directly. %ifdef ASSERT mov eax,Lunroll_inner_start cmp ecx,eax jae Lunroll_outer_top jmp exit %endif ; eax ; ebx high limb to store ; ecx VAR_JMP ; edx VAR_COUNTER,limbs,negative ; esi &src[size],constant ; edi dst ptr,second highest limb of last addmul ; ebp align 16 Lunroll_outer_top: mov ebp,[-12+OFFSET+esi+edx*4] ; multiplier mov [VAR_COUNTER],edx mov eax,[-8+OFFSET+esi+edx*4] ; first limb of multiplicand mul ebp %if UNROLL_COUNT % 2 == 1 %define cmovX cmovz %else %define cmovX cmovnz %endif test cl,1 mov ebx,edx ; high carry lea edi,[4+edi] mov edx,ecx ; jump mov ecx,eax ; low carry lea edx,[CODE_BYTES_PER_LIMB+edx] cmovX ecx,ebx cmovX ebx,eax mov [VAR_JMP],edx jmp edx ; Must be on an even address here so the low bit of the jump address ; will indicate which way around ecx/ebx should start. ; eax scratch ; ebx carry high ; ecx carry low ; edx scratch ; esi src pointer ; edi dst pointer ; ebp multiplier ; ; 15 code bytes each limb ; ecx/ebx reversed on each chunk align 2 Lunroll_inner_start: %assign i UNROLL_COUNT %rep UNROLL_COUNT %assign disp OFFSET-4*i %if i % 2 == 0 mov eax,[byte disp+esi] mul ebp add [byte disp+edi],ebx adc ecx,eax mov ebx,edx adc ebx,0 %else ; this one comes out last mov eax,[byte disp+esi] mul ebp add [byte disp+edi],ecx adc ebx,eax mov ecx,edx adc ecx,0 %endif %assign i i-1 %endrep Lunroll_inner_end: add [OFFSET+edi],ebx mov edx,[VAR_COUNTER] adc ecx,0 mov [OFFSET+4+edi],ecx mov ecx,[VAR_JMP] inc edx jnz Lunroll_outer_top %if OFFSET != 0 add esi,OFFSET add edi,OFFSET %endif ; eax ; ebx ; ecx ; edx ; esi &src[size] ; edi &dst[2*size-5] ; ebp align 16 Lcorner: mov eax,[-12+esi] mul dword [-8+esi] add [edi],eax mov eax,[-12+esi] mov ebx,0 adc ebx,edx mul dword [-4+esi] add ebx,eax mov eax,[-8+esi] adc edx,0 add [4+edi],ebx mov ebx,0 adc ebx,edx mul dword [-4+esi] mov ecx,[PARAM_SIZE] add eax,ebx adc edx,0 mov [8+edi],eax mov [12+edi],edx mov edi,[PARAM_DST] ; Left shift of dst[1..2*size-2],the bit shifted out becomes dst[2*size-1]. sub ecx,1 ; size-1 xor eax,eax ; ready for final adcl,and clear carry mov edx,ecx mov esi,[PARAM_SRC] ; eax ; ebx ; ecx counter,size-1 to 1 ; edx size-1 (for later use) ; esi src (for later use) ; edi dst,incrementing ; ebp Llshift: rcl dword [4+edi],1 rcl dword [8+edi],1 lea edi,[8+edi] dec ecx jnz Llshift adc eax,eax mov [4+edi],eax ; dst most significant limb mov eax,[esi] ; src[0] lea esi,[4+esi+edx*4] ; &src[size] sub ecx,edx ; -(size-1) ; Now add in the squares on the diagonal,src[0]^2,src[1]^2,..., ; src[size-1]^2. dst[0] hasn't yet been set at all yet,and just gets the ; low limb of src[0]^2. mul eax mov [edi+ecx*8],eax ; dst[0] ; eax scratch ; ebx scratch ; ecx counter,negative ; edx carry ; esi &src[size] ; edi dst[2*size-2] ; ebp Ldiag: mov eax,[esi+ecx*4] mov ebx,edx mul eax add [4+edi+ecx*8],ebx adc [8+edi+ecx*8],eax adc edx,0 inc ecx jnz Ldiag mov esi,[SAVE_ESI] mov ebx,[SAVE_EBX] add [4+edi],edx ; dst most significant limb mov edi,[SAVE_EDI] mov ebp,[SAVE_EBP] add esp,frame ret end ecl-16.1.2/msvc/gmp/mpn/x86i/pentium4/000077500000000000000000000000001266352375300172505ustar00rootroot00000000000000ecl-16.1.2/msvc/gmp/mpn/x86i/pentium4/copyd.asm000066400000000000000000000024611266352375300210730ustar00rootroot00000000000000 ; Copyright 1999, 2000, 2001 Free Software Foundation, Inc. ; ; This file is part of the GNU MP Library. ; ; The GNU MP Library is free software; you can redistribute it and/or ; modify it under the terms of the GNU Lesser General Public License as ; published by the Free Software Foundation; either version 2.1 of the ; License, or (at your option) any later version. ; ; The GNU MP Library is distributed in the hope that it will be useful, ; but WITHOUT ANY WARRANTY; without even the implied warranty of ; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ; Lesser General Public License for more details. ; ; You should have received a copy of the GNU Lesser General Public ; License along with the GNU MP Library; see the file COPYING.LIB. If ; not, write to the Free Software Foundation, Inc., 59 Temple Place - ; Suite 330, Boston, MA 02111-1307, USA. ; ; Translation of AT&T syntax code by Brian Gladman section .text global ___gmpn_copyd %ifdef DLL export ___gmpn_copyd %endif align 8 ___gmpn_copyd: mov ecx,[12+esp] mov eax,[8+esp] mov edx,[4+esp] mov [12+esp],ebx add ecx,-1 js nd oop: mov ebx,[eax+ecx*4] mov [edx+ecx*4],ebx add ecx,-1 jns oop nd: mov ebx,[12+esp] ret end ecl-16.1.2/msvc/gmp/mpn/x86i/pentium4/copyi.asm000066400000000000000000000030751266352375300211020ustar00rootroot00000000000000 ; Copyright 1999, 2000, 2001 Free Software Foundation, Inc. ; ; This file is part of the GNU MP Library. ; ; The GNU MP Library is free software; you can redistribute it and/or ; modify it under the terms of the GNU Lesser General Public License as ; published by the Free Software Foundation; either version 2.1 of the ; License, or (at your option) any later version. ; ; The GNU MP Library is distributed in the hope that it will be useful, ; but WITHOUT ANY WARRANTY; without even the implied warranty of ; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ; Lesser General Public License for more details. ; ; You should have received a copy of the GNU Lesser General Public ; License along with the GNU MP Library; see the file COPYING.LIB. If ; not, write to the Free Software Foundation, Inc., 59 Temple Place - ; Suite 330, Boston, MA 02111-1307, USA. ; ; Translation of AT&T syntax code by Brian Gladman %include "..\x86i.inc" section .text global ___gmpn_copyi %ifdef DLL export ___gmpn_copyi %endif align 8 ___gmpn_copyi: mov ecx, [12+esp] cmp ecx, 150 jg rm mov eax, [8+esp] mov edx, [4+esp] mov [12+esp],ebx test ecx,ecx jz nd oop: mov ebx, [eax] lea eax, [4+eax] add ecx, -1 mov [edx],ebx lea edx, [4+edx] jnz oop nd: mov ebx, [12+esp] ret rm: cld mov eax,esi mov esi, [8+esp] mov edx,edi mov edi, [4+esp] rep movsd mov esi,eax mov edi,edx ret end ecl-16.1.2/msvc/gmp/mpn/x86i/pentium4/mmx/000077500000000000000000000000001266352375300200515ustar00rootroot00000000000000ecl-16.1.2/msvc/gmp/mpn/x86i/pentium4/mmx/lshift.asm000066400000000000000000000204461266352375300220520ustar00rootroot00000000000000 ; Copyright 2001 Free Software Foundation, Inc. ; ; This file is part of the GNU MP Library. ; ; The GNU MP Library is free software; you can redistribute it and/or ; modify it under the terms of the GNU Lesser General Public License as ; published by the Free Software Foundation; either version 2.1 of the ; License, or (at your option) any later version. ; ; The GNU MP Library is distributed in the hope that it will be useful, ; but WITHOUT ANY WARRANTY; without even the implied warranty of ; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ; Lesser General Public License for more details. ; ; You should have received a copy of the GNU Lesser General Public ; License along with the GNU MP Library; see the file COPYING.LIB. If ; not, write to the Free Software Foundation, Inc., 59 Temple Place - ; Suite 330, Boston, MA 02111-1307, USA. ; ; Translation of AT&T syntax code by Brian Gladman %include "..\..\x86i.inc" %define PARAM_SHIFT esp+frame+16 %define PARAM_SIZE esp+frame+12 %define PARAM_SRC esp+frame+8 %define PARAM_DST esp+frame+4 %define frame 8 ; minimum 5,because the unrolled loop can't handle less %define UNROLL_THRESHOLD 5 section .text global ___gmpn_lshift %ifdef DLL export ___gmpn_lshift %endif align 8 ___gmpn_lshift: push ebx push edi mov eax,[PARAM_SIZE] mov edx,[PARAM_DST] mov ebx,[PARAM_SRC] mov ecx,[PARAM_SHIFT] cmp eax,UNROLL_THRESHOLD jae Lunroll mov edi,[-4+ebx+eax*4] ; src high limb dec eax jnz Lsimple shld eax,edi,cl shl edi,cl mov [edx],edi ; dst low limb pop edi ; risk of data cache bank clash pop ebx ret ; eax size-1 ; ebx src ; ecx shift ; edx dst ; esi ; edi ; ebp Lsimple: movd mm5,[ebx+eax*4] ; src high limb movd mm6,ecx ; lshift neg ecx psllq mm5,mm6 add ecx,32 movd mm7,ecx psrlq mm5,32 ; retval ; eax counter,limbs,negative ; ebx src ; ecx ; edx dst ; esi ; edi ; ; mm0 scratch ; mm5 return value ; mm6 shift ; mm7 32-shift Lsimple_top: movq mm0,[ebx+eax*4-4] dec eax psrlq mm0,mm7 movd [4+edx+eax*4],mm0 jnz Lsimple_top movd mm0,[ebx] movd eax,mm5 psllq mm0,mm6 pop edi pop ebx movd [edx],mm0 emms ret ; eax size ; ebx src ; ecx shift ; edx dst ; esi ; edi ; ebp align 8 Lunroll: movd mm5,[ebx+eax*4-4] ; src high limb lea edi,[ebx+eax*4] movd mm6,ecx ; lshift and edi,4 psllq mm5,mm6 jz Lstart_src_aligned ; src isn't aligned,process high limb separately (marked xxx) to ; make it so. ; ; source -8(ebx,%eax,4) ; | ; +-------+-------+-------+-- ; | | ; +-------+-------+-------+-- ; 0mod8 4mod8 0mod8 ; ; dest ; -4(edx,%eax,4) ; | ; +-------+-------+-- ; | xxx | | ; +-------+-------+-- movq mm0,[ebx+eax*4-8] ; unaligned load psllq mm0,mm6 dec eax psrlq mm0,32 movd [edx+eax*4],mm0 Lstart_src_aligned: movq mm1,[ebx+eax*4-8] ; src high qword lea edi,[edx+eax*4] and edi,4 psrlq mm5,32 ; return value movq mm3,[ebx+eax*4-16] ; src second highest qword jz Lstart_dst_aligned ; dst isn't aligned,subtract 4 to make it so,and pretend the shift ; is 32 bits extra. High limb of dst (marked xxx) handled here ; separately. ; ; source -8(ebx,%eax,4) ; | ; +-------+-------+-- ; | mm1 | ; +-------+-------+-- ; 0mod8 4mod8 ; ; dest ; -4(edx,%eax,4) ; | ; +-------+-------+-------+-- ; | xxx | | ; +-------+-------+-------+-- ; 0mod8 4mod8 0mod8 movq mm0,mm1 add ecx,32 ; new shift psllq mm0,mm6 movd mm6,ecx psrlq mm0,32 ; wasted cycle here waiting for %mm0 movd [-4+edx+eax*4],mm0 sub edx,4 Lstart_dst_aligned: psllq mm1,mm6 neg ecx ; -shift add ecx,64 ; 64-shift movq mm2,mm3 movd mm7,ecx sub eax,8 ; size-8 psrlq mm3,mm7 por mm3,mm1 ; mm3 ready to store jc Lfinish ; The comments in mpn_rshift apply here too. ; eax counter,limbs ; ebx src ; ecx ; edx dst ; esi ; edi ; ; mm0 ; mm1 ; mm2 src qword from 16(%ebx,%eax,4) ; mm3 dst qword ready to store to 24(%edx,%eax,4) ; ; mm5 return value ; mm6 lshift ; mm7 rshift align 8 Lunroll_loop: movq mm0,[ebx+eax*4+8] psllq mm2,mm6 movq mm1,mm0 psrlq mm0,mm7 movq [24+edx+eax*4],mm3 por mm0,mm2 movq mm3,[ebx+eax*4] psllq mm1,mm6 movq [16+edx+eax*4],mm0 movq mm2,mm3 psrlq mm3,mm7 sub eax,4 por mm3,mm1 jnc Lunroll_loop Lfinish: ; eax -4 to -1 representing respectively 0 to 3 limbs remaining test al,2 jz Lfinish_no_two movq mm0,[ebx+eax*4+8] psllq mm2,mm6 movq mm1,mm0 psrlq mm0,mm7 movq [24+edx+eax*4],mm3 ; prev por mm0,mm2 movq mm2,mm1 movq mm3,mm0 sub eax,2 Lfinish_no_two: ; eax -4 or -3 representing respectively 0 or 1 limbs remaining ; mm2 src prev qword,from 16(%ebx,%eax,4) ; mm3 dst qword,for 24(%edx,%eax,4) test al,1 movd eax,mm5 ; retval pop edi jz Lfinish_zero ; One extra src limb,destination was aligned. ; ; source ebx ; --+---------------+-------+ ; | mm2 | | ; --+---------------+-------+ ; ; dest edx+12 edx+4 edx ; --+---------------+---------------+-------+ ; | mm3 | | | ; --+---------------+---------------+-------+ ; ; mm6 = shift ; mm7 = ecx = 64-shift ; One extra src limb,destination was unaligned. ; ; source ebx ; --+---------------+-------+ ; | mm2 | | ; --+---------------+-------+ ; ; dest edx+12 edx+4 ; --+---------------+---------------+ ; | mm3 | | ; --+---------------+---------------+ ; ; mm6 = shift+32 ; mm7 = ecx = 64-(shift+32) ; In both cases there's one extra limb of src to fetch and combine ; with mm2 to make a qword at 4(%edx),and in the aligned case ; there's an extra limb of dst to be formed from that extra src limb ; left shifted. movd mm0,[ebx] psllq mm2,mm6 movq [12+edx],mm3 psllq mm0,32 movq mm1,mm0 psrlq mm0,mm7 por mm0,mm2 psllq mm1,mm6 movq [4+edx],mm0 psrlq mm1,32 and ecx,32 pop ebx jz Lfinish_one_unaligned movd [edx],mm1 Lfinish_one_unaligned: emms ret Lfinish_zero: ; No extra src limbs,destination was aligned. ; ; source ebx ; --+---------------+ ; | mm2 | ; --+---------------+ ; ; dest edx+8 edx ; --+---------------+---------------+ ; | mm3 | | ; --+---------------+---------------+ ; ; mm6 = shift ; mm7 = ecx = 64-shift ; No extra src limbs,destination was unaligned. ; ; source ebx ; --+---------------+ ; | mm2 | ; --+---------------+ ; ; dest edx+8 edx+4 ; --+---------------+-------+ ; | mm3 | | ; --+---------------+-------+ ; ; mm6 = shift+32 ; mm7 = ecx = 64-(shift+32) ; The movd for the unaligned case writes the same data to 4(%edx) ; that the movq does for the aligned case. movq [8+edx],mm3 and ecx,32 psllq mm2,mm6 jz Lfinish_zero_unaligned movq [edx],mm2 Lfinish_zero_unaligned: psrlq mm2,32 pop ebx movd eax,mm5 ; retval movd [4+edx],mm2 emms ret end ecl-16.1.2/msvc/gmp/mpn/x86i/pentium4/mmx/popham.asm000066400000000000000000000051311266352375300220370ustar00rootroot00000000000000 ; Copyright 2000, 2001, 2002 Free Software Foundation, Inc. ; ; This file is part of the GNU MP Library. ; ; The GNU MP Library is free software; you can redistribute it and/or ; modify it under the terms of the GNU Lesser General Public License as ; published by the Free Software Foundation; either version 2.1 of the ; License, or (at your option) any later version. ; ; The GNU MP Library is distributed in the hope that it will be useful, ; but WITHOUT ANY WARRANTY; without even the implied warranty of ; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ; Lesser General Public License for more details. ; ; You should have received a copy of the GNU Lesser General Public ; License along with the GNU MP Library; see the file COPYING.LIB. If ; not, write to the Free Software Foundation, Inc., 59 Temple Place - ; Suite 330, Boston, MA 02111-1307, USA. ; ; Translation of AT&T syntax code by Brian Gladman %macro ph_fun 1 %ifdef PIC mov edx,0xAAAAAAAA movd mm7,edx punpckldq mm7,mm7 mov edx,0x33333333 movd mm6,edx punpckldq mm6,mm6 mov edx,0x0F0F0F0F movd mm5,edx punpckldq mm5,mm5 %else movq mm7,[L_AA] movq mm6,[L_33] movq mm5,[L_0F] %endif mov ecx,[esp+PARAM_SIZE] mov eax,[esp+PARAM_SRC] %if %1 == 1 mov edx,[esp+PARAM_SRC2] %endif pxor mm4,mm4 pxor mm0,mm0 sub ecx,1 ja %%L_top %%L_last: movd mm1,[eax+ecx*4] %if %1 == 1 movd mm2,[edx+ecx*4] pxor mm1,mm2 %endif jmp %%L_loaded %%L_top: movd mm1,[eax] movd mm2,[eax+4] punpckldq mm1,mm2 add eax,8 %if %1 == 1 movd mm2,[edx] movd mm3,[edx+4] punpckldq mm2,mm3 pxor mm1,mm2 add edx,8 %endif %%L_loaded: movq mm2,mm7 pand mm2,mm1 psrlq mm2,1 psubd mm1,mm2 movq mm2,mm6 pand mm2,mm1 psrlq mm1,2 pand mm1,mm6 paddd mm1,mm2 movq mm2,mm5 pand mm2,mm1 psrlq mm1,4 pand mm1,mm5 paddd mm1,mm2 psadbw mm1,mm4 paddd mm0,mm1 sub ecx,2 jg %%L_top jz %%L_last movd eax,mm0 emms ret %endmacro %ifndef PIC data align 8 L_AA: dq 0xAAAAAAAAAAAAAAAA L_33: dq 0x3333333333333333 L_0F: dq 0x0F0F0F0F0F0F0F0F %endif text %define PARAM_SIZE 8 %define PARAM_SRC 4 global ___gmpn_popcount %ifdef DLL export ___gmpn_popcount %endif align 16 ___gmpn_popcount: ph_fun 0 %define PARAM_SIZE 12 %define PARAM_SRC2 8 %define PARAM_SRC 4 global ___gmpn_hamdist %ifdef DLL export ___gmpn_hamdist %endif align 16 ___gmpn_hamdist: ph_fun 1 end ecl-16.1.2/msvc/gmp/mpn/x86i/pentium4/mmx/rshift.asm000066400000000000000000000213111266352375300220500ustar00rootroot00000000000000 ; Copyright 2001 Free Software Foundation, Inc. ; ; This file is part of the GNU MP Library. ; ; The GNU MP Library is free software; you can redistribute it and/or ; modify it under the terms of the GNU Lesser General Public License as ; published by the Free Software Foundation; either version 2.1 of the ; License, or (at your option) any later version. ; ; The GNU MP Library is distributed in the hope that it will be useful, ; but WITHOUT ANY WARRANTY; without even the implied warranty of ; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ; Lesser General Public License for more details. ; ; You should have received a copy of the GNU Lesser General Public ; License along with the GNU MP Library; see the file COPYING.LIB. If ; not, write to the Free Software Foundation, Inc., 59 Temple Place - ; Suite 330, Boston, MA 02111-1307, USA. ; ; Translation of AT&T syntax code by Brian Gladman %include "..\..\x86i.inc" %define PARAM_SHIFT esp+frame+16 %define PARAM_SIZE esp+frame+12 %define PARAM_SRC esp+frame+8 %define PARAM_DST esp+frame+4 %define frame 8 ; Minimum 5,because the unrolled loop can't handle less. %define UNROLL_THRESHOLD 5 section .text global ___gmpn_rshift %ifdef DLL export ___gmpn_rshift %endif align 8 ___gmpn_rshift: push ebx push edi mov eax,[PARAM_SIZE] mov edx,[PARAM_DST] mov ebx,[PARAM_SRC] mov ecx,[PARAM_SHIFT] cmp eax,UNROLL_THRESHOLD jae Lunroll dec eax mov edi,[ebx] ; src low limb jnz Lsimple shrd eax,edi,cl shr edi,cl mov [edx],edi ; dst low limb pop edi ; risk of data cache bank clash pop ebx ret ; eax size-1 ; ebx src ; ecx shift ; edx dst ; esi ; edi ; ebp align 8 Lsimple: movd mm5,[ebx] ; src[0] lea ebx,[ebx+eax*4] ; &src[size-1] movd mm6,ecx ; rshift lea edx,[-4+edx+eax*4] ; &dst[size-2] psllq mm5,32 neg eax ; This loop is 5 or 8 cycles,with every second load unaligned and a wasted ; cycle waiting for the mm0 result to be ready. For comparison a shrdl is 4 ; cycles and would be 8 in a simple loop. Using mmx helps the return value ; and last limb calculations too. ; eax counter,limbs,negative ; ebx &src[size-1] ; ecx return value ; edx &dst[size-2] ; ; mm0 scratch ; mm5 return value ; mm6 shift Lsimple_top: movq mm0,[ebx+eax*4] inc eax psrlq mm0,mm6 movd [edx+eax*4],mm0 jnz Lsimple_top movd mm0,[ebx] psrlq mm5,mm6 ; return value psrlq mm0,mm6 pop edi movd eax,mm5 pop ebx movd [4+edx],mm0 emms ret ; eax size ; ebx src ; ecx shift ; edx dst ; esi ; edi ; ebp align 8 Lunroll: movd mm5,[ebx] ; src[0] mov edi,4 movd mm6,ecx ; rshift test ebx,edi psllq mm5,32 jz Lstart_src_aligned ; src isn't aligned,process low limb separately (marked xxx) and ; step src and dst by one limb,making src aligned. ; ; source ebx ; --+-------+-------+-------+ ; | xxx | ; --+-------+-------+-------+ ; 4mod8 0mod8 4mod8 ; ; dest edx ; --+-------+-------+ ; | | xxx | ; --+-------+-------+ movq mm0,[ebx] ; unaligned load psrlq mm0,mm6 add ebx,4 dec eax movd [edx],mm0 add edx,4 Lstart_src_aligned: movq mm1,[ebx] test edx,edi psrlq mm5,mm6 ; retval jz Lstart_dst_aligned ; dst isn't aligned,add 4 to make it so,and pretend the shift is ; 32 bits extra. Low limb of dst (marked xxx) handled here ; separately. ; ; source ebx ; --+-------+-------+ ; | mm1 | ; --+-------+-------+ ; 4mod8 0mod8 ; ; dest edx ; --+-------+-------+-------+ ; | xxx | ; --+-------+-------+-------+ ; 4mod8 0mod8 4mod8 movq mm0,mm1 add ecx,32 ; new shift psrlq mm0,mm6 movd mm6,ecx movd [edx],mm0 add edx,4 Lstart_dst_aligned: movq mm3,[8+ebx] neg ecx movq mm2,mm3 ; mm2 src qword add ecx,64 movd mm7,ecx psrlq mm1,mm6 lea ebx,[-12+ebx+eax*4] lea edx,[-20+edx+eax*4] psllq mm3,mm7 sub eax,7 ; size-7 por mm3,mm1 ; mm3 ready to store neg eax ; -(size-7) jns Lfinish ; This loop is the important bit,the rest is just support. Careful ; instruction scheduling achieves the claimed 1.75 c/l. The ; relevant parts of the pairing rules are: ; ; - mmx loads and stores execute only in the U pipe ; - only one mmx shift in a pair ; - wait one cycle before storing an mmx register result ; - the usual address generation interlock ; ; Two qword calculations are slightly interleaved. The instructions ; marked "C" belong to the second qword,and the "C prev" one is for ; the second qword from the previous iteration. ; eax counter,limbs,negative ; ebx &src[size-12] ; ecx ; edx &dst[size-12] ; esi ; edi ; ; mm0 ; mm1 ; mm2 src qword from -8(%ebx,%eax,4) ; mm3 dst qword ready to store to -8(%edx,%eax,4) ; ; mm5 return value ; mm6 rshift ; mm7 lshift align 8 Lunroll_loop: movq mm0,[ebx+eax*4] psrlq mm2,mm6 movq mm1,mm0 psllq mm0,mm7 movq [-8+edx+eax*4],mm3 por mm0,mm2 movq mm3,[ebx+eax*4+8] psrlq mm1,mm6 movq [edx+eax*4],mm0 movq mm2,mm3 psllq mm3,mm7 add eax,4 por mm3,mm1 js Lunroll_loop Lfinish: ; eax 0 to 3 representing respectively 3 to 0 limbs remaining test al,2 jnz Lfinish_no_two movq mm0,[ebx+eax*4] psrlq mm2,mm6 movq mm1,mm0 psllq mm0,mm7 movq [-8+edx+eax*4],mm3 ; prev por mm0,mm2 movq mm2,mm1 movq mm3,mm0 add eax,2 Lfinish_no_two: ; eax 2 or 3 representing respectively 1 or 0 limbs remaining ; ; mm2 src prev qword,from -8(%ebx,%eax,4) ; mm3 dst qword,for -8(%edx,%eax,4) test al,1 pop edi movd eax,mm5 ; retval jnz Lfinish_zero ; One extra limb,destination was aligned. ; ; source ebx ; +-------+---------------+-- ; | | mm2 | ; +-------+---------------+-- ; ; dest edx ; +-------+---------------+---------------+-- ; | | | mm3 | ; +-------+---------------+---------------+-- ; ; mm6 = shift ; mm7 = ecx = 64-shift ; One extra limb,destination was unaligned. ; ; source ebx ; +-------+---------------+-- ; | | mm2 | ; +-------+---------------+-- ; ; dest edx ; +---------------+---------------+-- ; | | mm3 | ; +---------------+---------------+-- ; ; mm6 = shift+32 ; mm7 = ecx = 64-(shift+32) ; In both cases there's one extra limb of src to fetch and combine ; with mm2 to make a qword at 8(%edx),and in the aligned case ; there's a further extra limb of dst to be formed. movd mm0,[8+ebx] psrlq mm2,mm6 movq mm1,mm0 psllq mm0,mm7 movq [edx],mm3 por mm0,mm2 psrlq mm1,mm6 and ecx,32 pop ebx jz Lfinish_one_unaligned ; dst was aligned,must store one extra limb movd [16+edx],mm1 Lfinish_one_unaligned: movq [8+edx],mm0 emms ret Lfinish_zero: ; No extra limbs,destination was aligned. ; ; source ebx ; +---------------+-- ; | mm2 | ; +---------------+-- ; ; dest edx+4 ; +---------------+---------------+-- ; | | mm3 | ; +---------------+---------------+-- ; ; mm6 = shift ; mm7 = ecx = 64-shift ; No extra limbs,destination was unaligned. ; ; source ebx ; +---------------+-- ; | mm2 | ; +---------------+-- ; ; dest edx+4 ; +-------+---------------+-- ; | | mm3 | ; +-------+---------------+-- ; ; mm6 = shift+32 ; mm7 = 64-(shift+32) ; The movd for the unaligned case is clearly the same data as the ; movq for the aligned case,it's just a choice between whether one ; or two limbs should be written. movq [4+edx],mm3 psrlq mm2,mm6 movd [12+edx],mm2 and ecx,32 pop ebx jz Lfinish_zero_unaligned movq [12+edx],mm2 Lfinish_zero_unaligned: emms ret end ecl-16.1.2/msvc/gmp/mpn/x86i/pentium4/sse2/000077500000000000000000000000001266352375300201245ustar00rootroot00000000000000ecl-16.1.2/msvc/gmp/mpn/x86i/pentium4/sse2/add_n.asm000066400000000000000000000041041266352375300216720ustar00rootroot00000000000000 ; Copyright 2001, 2002 Free Software Foundation, Inc. ; ; This file is part of the GNU MP Library. ; ; The GNU MP Library is free software; you can redistribute it and/or ; modify it under the terms of the GNU Lesser General Public License as ; published by the Free Software Foundation; either version 2.1 of the ; License, or (at your option) any later version. ; ; The GNU MP Library is distributed in the hope that it will be useful, ; but WITHOUT ANY WARRANTY; without even the implied warranty of ; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ; Lesser General Public License for more details. ; ; You should have received a copy of the GNU Lesser General Public ; License along with the GNU MP Library; see the file COPYING.LIB. If ; not, write to the Free Software Foundation, Inc., 59 Temple Place - ; Suite 330, Boston, MA 02111-1307, USA. ; ; Translation of AT&T syntax code by Brian Gladman %include "..\..\x86i.inc" section .text global ___gmpn_add_nc %ifdef DLL export ___gmpn_add_nc %endif align 8 ___gmpn_add_nc: movd mm0,[20+esp] mov eax,[8+esp] mov [8+esp],ebx mov ebx,[12+esp] mov edx,[4+esp] mov ecx,[16+esp] lea eax,[eax+ecx*4] lea ebx,[ebx+ecx*4] lea edx,[edx+ecx*4] neg ecx t1: movd mm1,[eax+ecx*4] movd mm2,[ebx+ecx*4] paddq mm1,mm2 paddq mm0,mm1 movd [edx+ecx*4],mm0 psrlq mm0,32 add ecx,1 jnz t1 movd eax,mm0 mov ebx,[8+esp] emms ret global ___gmpn_add_n %ifdef DLL export ___gmpn_add_n %endif align 8 ___gmpn_add_n: pxor mm0,mm0 mov eax,[8+esp] mov [8+esp],ebx mov ebx,[12+esp] mov edx,[4+esp] mov ecx,[16+esp] lea eax,[eax+ecx*4] lea ebx,[ebx+ecx*4] lea edx,[edx+ecx*4] neg ecx t2: movd mm1,[eax+ecx*4] movd mm2,[ebx+ecx*4] paddq mm1,mm2 paddq mm0,mm1 movd [edx+ecx*4],mm0 psrlq mm0,32 add ecx,1 jnz t2 movd eax,mm0 mov ebx,[8+esp] emms ret end ecl-16.1.2/msvc/gmp/mpn/x86i/pentium4/sse2/addmul_1.asm000066400000000000000000000030321266352375300223120ustar00rootroot00000000000000 ; Copyright 2001, 2002 Free Software Foundation, Inc. ; ; This file is part of the GNU MP Library. ; ; The GNU MP Library is free software; you can redistribute it and/or ; modify it under the terms of the GNU Lesser General Public License as ; published by the Free Software Foundation; either version 2.1 of the ; License, or (at your option) any later version. ; ; The GNU MP Library is distributed in the hope that it will be useful, ; but WITHOUT ANY WARRANTY; without even the implied warranty of ; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ; Lesser General Public License for more details. ; ; You should have received a copy of the GNU Lesser General Public ; License along with the GNU MP Library; see the file COPYING.LIB. If ; not, write to the Free Software Foundation, Inc., 59 Temple Place - ; Suite 330, Boston, MA 02111-1307, USA. ; ; Translation of AT&T syntax code by Brian Gladman section .text global ___gmpn_addmul_1 global ___gmpn_addmul_1c %ifdef DLL export ___gmpn_addmul_1 export ___gmpn_addmul_1c %endif align 16 ___gmpn_addmul_1c: movd mm0,[20+esp] jmp start_1c align 16 ___gmpn_addmul_1: pxor mm0,mm0 start_1c: mov eax,[8+esp] mov ecx,[12+esp] mov edx,[4+esp] movd mm7,[16+esp] oop: movd mm1,[eax] lea eax,[4+eax] movd mm2,[edx] pmuludq mm1,mm7 paddq mm2,mm1 paddq mm0,mm2 sub ecx,1 movd [edx],mm0 psrlq mm0,32 lea edx,[4+edx] jnz oop movd eax,mm0 emms ret end ecl-16.1.2/msvc/gmp/mpn/x86i/pentium4/sse2/dive_1.asm000066400000000000000000000046211266352375300220000ustar00rootroot00000000000000 ; Copyright 2001, 2002 Free Software Foundation, Inc. ; ; This file is part of the GNU MP Library. ; ; The GNU MP Library is free software; you can redistribute it and/or ; modify it under the terms of the GNU Lesser General Public License as ; published by the Free Software Foundation; either version 2.1 of the ; License, or (at your option) any later version. ; ; The GNU MP Library is distributed in the hope that it will be useful, ; but WITHOUT ANY WARRANTY; without even the implied warranty of ; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ; Lesser General Public License for more details. ; ; You should have received a copy of the GNU Lesser General Public ; License along with the GNU MP Library; see the file COPYING.LIB. If ; not, write to the Free Software Foundation, Inc., 59 Temple Place - ; Suite 330, Boston, MA 02111-1307, USA. ; ; Translation of AT&T syntax code by Brian Gladman %include "..\..\x86i.inc" %define p_space 16 extern ___gmp_modlimb_invert_table section .text global ___gmpn_divexact_1 %ifdef DLL export ___gmpn_divexact_1 %endif align 16 ___gmpn_divexact_1: mov edx,[12+esp] mov eax,[8+esp] mov ecx,[16+esp] sub edx,1 jnz two_or_more mov eax,[eax] xor edx,edx div ecx mov ecx,[4+esp] mov [ecx],eax ret two_or_more: mov eax,ecx bsf ecx,ecx shr eax,cl movd mm6,eax movd mm7,ecx shr eax,1 and eax,127 movzx eax,byte [___gmp_modlimb_invert_table+eax] movd mm5,eax movd mm0,eax pmuludq mm5,mm5 pmuludq mm5,mm6 paddd mm0,mm0 psubd mm0,mm5 pxor mm5,mm5 paddd mm5,mm0 pmuludq mm0,mm0 pcmpeqd mm4,mm4 psrlq mm4,32 pmuludq mm0,mm6 paddd mm5,mm5 mov eax,[8+esp] mov ecx,[4+esp] pxor mm1,mm1 psubd mm5,mm0 pxor mm0,mm0 top: movd mm2,[eax] movd mm3,[4+eax] add eax,4 punpckldq mm2,mm3 psrlq mm2,mm7 pand mm2,mm4 psubq mm2,mm0 psubq mm2,mm1 movq mm0,mm2 psrlq mm0,63 pmuludq mm2,mm5 movd [ecx],mm2 add ecx,4 movq mm1,mm6 pmuludq mm1,mm2 psrlq mm1,32 sub edx,1 jnz top done: movd mm2,[eax] psrlq mm2,mm7 psubq mm2,mm0 psubq mm2,mm1 pmuludq mm2,mm5 movd [ecx],mm2 emms ret end ecl-16.1.2/msvc/gmp/mpn/x86i/pentium4/sse2/diveby3.asm000066400000000000000000000032201266352375300221700ustar00rootroot00000000000000 ; Copyright 2001, 2002 Free Software Foundation, Inc. ; ; This file is part of the GNU MP Library. ; ; The GNU MP Library is free software; you can redistribute it and/or ; modify it under the terms of the GNU Library General Public License as ; published by the Free Software Foundation; either version 2 of the ; License, or (at your option) any later version. ; ; The GNU MP Library is distributed in the hope that it will be useful, ; but WITHOUT ANY WARRANTY; without even the implied warranty of ; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ; Library General Public License for more details. ; ; You should have received a copy of the GNU Library General Public ; License along with the GNU MP Library; see the file COPYING.LIB. If ; not, write to the Free Software Foundation, Inc., 59 Temple Place - ; Suite 330, Boston, MA 02111-1307, USA. ; ; Translation of AT&T syntax code by Brian Gladman section .text global ___gmpn_divexact_by3c %ifdef DLL export ___gmpn_divexact_by3c %endif align 16 ___gmpn_divexact_by3c: mov eax,[8+esp] pxor mm0,mm0 movd mm1,[16+esp] pcmpeqd mm6,mm6 movd mm7,[val] mov edx,[4+esp] psrlq mm6,32 mov ecx,[12+esp] top: movd mm2,[eax] add eax,4 psubq mm2,mm0 psubq mm2,mm1 movq mm0,mm2 psrlq mm0,63 pmuludq mm2,mm7 movd [edx],mm2 add edx,4 movq mm1,mm6 pand mm1,mm2 pand mm2,mm6 psllq mm1,1 paddq mm1,mm2 psrlq mm1,32 sub ecx,1 jnz top paddd mm0,mm1 movd eax,mm0 emms ret section .data val: dd 0xAAAAAAAB end ecl-16.1.2/msvc/gmp/mpn/x86i/pentium4/sse2/mod_34lsub1.asm000066400000000000000000000044141266352375300226650ustar00rootroot00000000000000 ; Copyright 2000, 2001, 2002 Free Software Foundation, Inc. ; ; This file is part of the GNU MP Library. ; ; The GNU MP Library is free software; you can redistribute it and/or ; modify it under the terms of the GNU Lesser General Public License as ; published by the Free Software Foundation; either version 2.1 of the ; License, or (at your option) any later version. ; ; The GNU MP Library is distributed in the hope that it will be useful, ; but WITHOUT ANY WARRANTY; without even the implied warranty of ; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ; Lesser General Public License for more details. ; ; You should have received a copy of the GNU Lesser General Public ; License along with the GNU MP Library; see the file COPYING.LIB. If ; not, write to the Free Software Foundation, Inc., 59 Temple Place - ; Suite 330, Boston, MA 02111-1307, USA. ; ; Translation of AT&T syntax code by Brian Gladman section .text global ___gmpn_mod_34lsub1 %ifdef DLL export ___gmpn_mod_34lsub1 %endif align 16 ___gmpn_mod_34lsub1: mov ecx,[8+esp] mov edx,[4+esp] mov eax,[edx] sub ecx,2 ja three_or_more jne one mov edx,[4+edx] mov ecx,eax shr eax,24 and ecx,0x00FFFFFF add eax,ecx mov ecx,edx shl edx,8 shr ecx,16 add eax,ecx and edx,0x00FFFF00 add eax,edx one:ret three_or_more: pxor mm0,mm0 pxor mm1,mm1 pxor mm2,mm2 pcmpeqd mm7,mm7 psrlq mm7,32 pcmpeqd mm6,mm6 psrlq mm6,40 top: movd mm3,[edx] paddq mm0,mm3 movd mm3,[4+edx] paddq mm1,mm3 movd mm3,[8+edx] paddq mm2,mm3 add edx,12 sub ecx,3 ja top add ecx,1 js combine movd mm3,[edx] paddq mm0,mm3 jz combine movd mm3,[4+edx] paddq mm1,mm3 combine: movq mm3,mm7 pand mm3,mm0 movq mm4,mm7 pand mm4,mm1 movq mm5,mm7 pand mm5,mm2 psrlq mm0,32 psrlq mm1,32 psrlq mm2,32 paddq mm4,mm0 paddq mm5,mm1 paddq mm3,mm2 psllq mm4,8 psllq mm5,16 paddq mm3,mm4 paddq mm3,mm5 pand mm6,mm3 psrlq mm3,24 paddq mm3,mm6 movd eax,mm3 emms ret end ecl-16.1.2/msvc/gmp/mpn/x86i/pentium4/sse2/mode1o.asm000066400000000000000000000037521266352375300220210ustar00rootroot00000000000000 ; Copyright 2001, 2002 Free Software Foundation, Inc. ; ; This file is part of the GNU MP Library. ; ; The GNU MP Library is free software; you can redistribute it and/or ; modify it under the terms of the GNU Lesser General Public License as ; published by the Free Software Foundation; either version 2.1 of the ; License, or (at your option) any later version. ; ; The GNU MP Library is distributed in the hope that it will be useful, ; but WITHOUT ANY WARRANTY; without even the implied warranty of ; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ; Lesser General Public License for more details. ; ; You should have received a copy of the GNU Lesser General Public ; License along with the GNU MP Library; see the file COPYING.LIB. If ; not, write to the Free Software Foundation, Inc., 59 Temple Place - ; Suite 330, Boston, MA 02111-1307, USA. ; ; Translation of AT&T syntax code by Brian Gladman section .text extern ___gmp_modlimb_invert_table global ___gmpn_modexact_1_odd global ___gmpn_modexact_1c_odd %ifdef DLL export ___gmpn_modexact_1_odd export ___gmpn_modexact_1c_odd %endif align 16 ___gmpn_modexact_1c_odd: movd mm1,[16+esp] jmp start_1c align 16 ___gmpn_modexact_1_odd: pxor mm1,mm1 start_1c: mov eax,[12+esp] movd mm7,[12+esp] shr eax,1 and eax,127 movzx eax,byte [___gmp_modlimb_invert_table+eax] movd mm6,eax movd mm0,eax pmuludq mm6,mm6 pmuludq mm6,mm7 paddd mm0,mm0 psubd mm0,mm6 pxor mm6,mm6 paddd mm6,mm0 pmuludq mm0,mm0 pmuludq mm0,mm7 paddd mm6,mm6 mov eax,[4+esp] mov ecx,[8+esp] psubd mm6,mm0 pxor mm0,mm0 top: movd mm2,[eax] add eax,4 psubq mm2,mm0 psubq mm2,mm1 movq mm0,mm2 psrlq mm0,63 pmuludq mm2,mm6 movq mm1,mm7 pmuludq mm1,mm2 psrlq mm1,32 sub ecx,1 jnz top done: paddq mm0,mm1 movd eax,mm0 emms ret end ecl-16.1.2/msvc/gmp/mpn/x86i/pentium4/sse2/mul_1.asm000066400000000000000000000027611266352375300216510ustar00rootroot00000000000000 ; Copyright 2001, 2002 Free Software Foundation, Inc. ; ; This file is part of the GNU MP Library. ; ; The GNU MP Library is free software; you can redistribute it and/or ; modify it under the terms of the GNU Lesser General Public License as ; published by the Free Software Foundation; either version 2.1 of the ; License, or (at your option) any later version. ; ; The GNU MP Library is distributed in the hope that it will be useful, ; but WITHOUT ANY WARRANTY; without even the implied warranty of ; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ; Lesser General Public License for more details. ; ; You should have received a copy of the GNU Lesser General Public ; License along with the GNU MP Library; see the file COPYING.LIB. If ; not, write to the Free Software Foundation, Inc., 59 Temple Place - ; Suite 330, Boston, MA 02111-1307, USA. ; ; Translation of AT&T syntax code by Brian Gladman section .text global ___gmpn_mul_1 global ___gmpn_mul_1c %ifdef DLL export ___gmpn_mul_1 export ___gmpn_mul_1c %endif align 16 ___gmpn_mul_1c: movd mm0,[20+esp] jmp start_1c align 16 ___gmpn_mul_1: pxor mm0,mm0 start_1c: mov eax,[8+esp] movd mm7,[16+esp] mov edx,[4+esp] mov ecx,[12+esp] top: movd mm1,[eax] add eax,4 pmuludq mm1,mm7 paddq mm0,mm1 movd [edx],mm0 add edx,4 psrlq mm0,32 sub ecx,1 jnz top movd eax,mm0 emms ret end ecl-16.1.2/msvc/gmp/mpn/x86i/pentium4/sse2/mul_basecase.asm000066400000000000000000000042051266352375300232520ustar00rootroot00000000000000 ; Copyright 2001, 2002 Free Software Foundation, Inc. ; ; This file is part of the GNU MP Library. ; ; The GNU MP Library is free software; you can redistribute it and/or ; modify it under the terms of the GNU Lesser General Public License as ; published by the Free Software Foundation; either version 2.1 of the ; License, or (at your option) any later version. ; ; The GNU MP Library is distributed in the hope that it will be useful, ; but WITHOUT ANY WARRANTY; without even the implied warranty of ; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ; Lesser General Public License for more details. ; ; You should have received a copy of the GNU Lesser General Public ; License along with the GNU MP Library; see the file COPYING.LIB. If ; not, write to the Free Software Foundation, Inc., 59 Temple Place - ; Suite 330, Boston, MA 02111-1307, USA. ; ; Translation of AT&T syntax code by Brian Gladman section .text global ___gmpn_mul_basecase %ifdef DLL export ___gmpn_mul_basecase %endif align 8 ___gmpn_mul_basecase: mov eax,[8+esp] mov [8+esp],ebx pxor mm0,mm0 mov edx,[16+esp] mov [16+esp],esi mov ebx,[4+esp] mov [4+esp],ebp mov esi,eax movd mm7,[edx] mov ecx,[12+esp] mov ebp,[20+esp] mov [20+esp],edi mov edi,ebx mul1: movd mm1,[eax] add eax,4 pmuludq mm1,mm7 paddq mm0,mm1 movd [ebx],mm0 add ebx,4 psrlq mm0,32 sub ecx,1 jnz mul1 movd [ebx],mm0 sub ebp,1 jz done outer: mov eax,esi lea ebx,[4+edi] add edi,4 movd mm7,[4+edx] add edx,4 pxor mm0,mm0 mov ecx,[12+esp] inner: movd mm1,[eax] lea eax,[4+eax] movd mm2,[ebx] pmuludq mm1,mm7 paddq mm1,mm2 paddq mm0,mm1 sub ecx,1 movd [ebx],mm0 psrlq mm0,32 lea ebx,[4+ebx] jnz inner movd [ebx],mm0 sub ebp,1 jnz outer done: mov ebx,[8+esp] mov esi,[16+esp] mov edi,[20+esp] mov ebp,[4+esp] emms ret end ecl-16.1.2/msvc/gmp/mpn/x86i/pentium4/sse2/sqr_basecase.asm000066400000000000000000000076521266352375300232730ustar00rootroot00000000000000; Copyright 2001, 2002 Free Software Foundation, Inc. ; ; This file is part of the GNU MP Library. ; ; The GNU MP Library is free software; you can redistribute it and/or ; modify it under the terms of the GNU Lesser General Public License as ; published by the Free Software Foundation; either version 2.1 of the ; License, or (at your option) any later version. ; ; The GNU MP Library is distributed in the hope that it will be useful, ; but WITHOUT ANY WARRANTY; without even the implied warranty of ; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ; Lesser General Public License for more details. ; ; You should have received a copy of the GNU Lesser General Public ; License along with the GNU MP Library; see the file COPYING.LIB. If ; not, write to the Free Software Foundation, Inc., 59 Temple Place - ; Suite 330, Boston, MA 02111-1307, USA. ; ; Translation of AT&T syntax code by Brian Gladman section .text global ___gmpn_sqr_basecase %ifdef DLL export ___gmpn_sqr_basecase %endif align 8 ___gmpn_sqr_basecase: mov edx,[12+esp] mov eax,[8+esp] mov ecx,[4+esp] cmp edx,2 je two_limbs ja three_or_more mov eax,[eax] mul eax mov [ecx],eax mov [4+ecx],edx ret two_limbs: movd mm1,[eax] movd mm0,[4+eax] pmuludq mm0,mm1 pmuludq mm1,mm1 movd mm2,[4+eax] pmuludq mm2,mm2 movd [ecx],mm1 psrlq mm1,32 pcmpeqd mm3,mm3 psrlq mm3,32 pand mm3,mm0 psrlq mm0,32 psllq mm3,1 paddq mm1,mm3 movd [4+ecx],mm1 pcmpeqd mm4,mm4 psrlq mm4,32 pand mm4,mm2 psrlq mm2,32 psllq mm0,1 psrlq mm1,32 paddq mm0,mm1 paddq mm0,mm4 movd [8+ecx],mm0 psrlq mm0,32 paddq mm0,mm2 movd [12+ecx],mm0 emms ret three_or_more: sub esp,12 pxor mm0,mm0 movd mm7,[eax] mov [8+esp],esi mov [4+esp],edi mov [esp],ebp mov esi,eax mov edi,ecx sub edx,1 mul1: movd mm1,[4+eax] add eax,4 pmuludq mm1,mm7 paddq mm0,mm1 movd [4+ecx],mm0 add ecx,4 psrlq mm0,32 sub edx,1 jnz mul1 mov ebp,[24+esp] sub ebp,3 jz corner outer: movd mm7,[4+esi] movd [4+ecx],mm0 lea eax,[8+esi] add esi,4 lea ecx,[8+edi] add edi,8 lea edx,[1+ebp] pxor mm0,mm0 inner: movd mm1,[eax] lea eax,[4+eax] movd mm2,[4+ecx] pmuludq mm1,mm7 paddq mm1,mm2 paddq mm0,mm1 sub edx,1 movd [4+ecx],mm0 psrlq mm0,32 lea ecx,[4+ecx] jnz inner sub ebp,1 jnz outer corner: movd mm1,[4+esi] movd mm2,[8+esi] pmuludq mm1,mm2 mov eax,[20+esp] movd mm2,[eax] pmuludq mm2,mm2 pcmpeqd mm7,mm7 psrlq mm7,32 mov edx,[16+esp] movd mm3,[4+edx] paddq mm0,mm1 movd [12+edi],mm0 psrlq mm0,32 movd [16+edi],mm0 movd [edx],mm2 psrlq mm2,32 psllq mm3,1 paddq mm2,mm3 movd [4+edx],mm2 psrlq mm2,32 mov ecx,[24+esp] sub ecx,2 diag: movd mm0,[4+eax] add eax,4 pmuludq mm0,mm0 movq mm1,mm7 pand mm1,mm0 psrlq mm0,32 movd mm3,[8+edx] psllq mm3,1 paddq mm1,mm3 paddq mm2,mm1 movd [8+edx],mm2 psrlq mm2,32 movd mm3,[12+edx] psllq mm3,1 paddq mm0,mm3 paddq mm2,mm0 movd [12+edx],mm2 add edx,8 psrlq mm2,32 sub ecx,1 jnz diag movd mm0,[4+eax] pmuludq mm0,mm0 pand mm7,mm0 psrlq mm0,32 movd mm3,[8+edx] psllq mm3,1 paddq mm7,mm3 paddq mm2,mm7 movd [8+edx],mm2 psrlq mm2,32 paddq mm2,mm0 movd [12+edx],mm2 mov esi,[8+esp] mov edi,[4+esp] mov ebp,[esp] add esp,12 emms ret end ecl-16.1.2/msvc/gmp/mpn/x86i/pentium4/sse2/sub_n.asm000066400000000000000000000035721266352375300217430ustar00rootroot00000000000000 ; Copyright 2001, 2002 Free Software Foundation, Inc. ; ; This file is part of the GNU MP Library. ; ; The GNU MP Library is free software; you can redistribute it and/or ; modify it under the terms of the GNU Lesser General Public License as ; published by the Free Software Foundation; either version 2.1 of the ; License, or (at your option) any later version. ; ; The GNU MP Library is distributed in the hope that it will be useful, ; but WITHOUT ANY WARRANTY; without even the implied warranty of ; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ; Lesser General Public License for more details. ; ; You should have received a copy of the GNU Lesser General Public ; License along with the GNU MP Library; see the file COPYING.LIB. If ; not, write to the Free Software Foundation, Inc., 59 Temple Place - ; Suite 330, Boston, MA 02111-1307, USA. ; ; Translation of AT&T syntax code by Brian Gladman section .text global ___gmpn_sub_nc global ___gmpn_sub_n %ifdef DLL export ___gmpn_sub_nc export ___gmpn_sub_n %endif align 8 ___gmpn_sub_nc: movd mm0,[20+esp] jmp start_nc align 8 ___gmpn_sub_n: pxor mm0,mm0 start_nc: mov eax,[8+esp] mov [8+esp],ebx mov ebx,[12+esp] mov edx,[4+esp] mov ecx,[16+esp] lea eax,[eax+ecx*4] lea ebx,[ebx+ecx*4] lea edx,[edx+ecx*4] neg ecx top: movd mm1,[eax+ecx*4] movd mm2,[ebx+ecx*4] psubq mm1,mm2 psubq mm1,mm0 movd [edx+ecx*4],mm1 psrlq mm1,63 add ecx,1 jz done_mm1 movd mm0,[eax+ecx*4] movd mm2,[ebx+ecx*4] psubq mm0,mm2 psubq mm0,mm1 movd [edx+ecx*4],mm0 psrlq mm0,63 add ecx,1 jnz top movd eax,mm0 mov ebx,[8+esp] emms ret done_mm1: movd eax,mm1 mov ebx,[8+esp] emms ret end ecl-16.1.2/msvc/gmp/mpn/x86i/pentium4/sse2/submul_1.asm000066400000000000000000000042301266352375300223540ustar00rootroot00000000000000 ; Copyright 2001, 2002 Free Software Foundation, Inc. ; ; This file is part of the GNU MP Library. ; ; The GNU MP Library is free software; you can redistribute it and/or ; modify it under the terms of the GNU Lesser General Public License as ; published by the Free Software Foundation; either version 2.1 of the ; License, or (at your option) any later version. ; ; The GNU MP Library is distributed in the hope that it will be useful, ; but WITHOUT ANY WARRANTY; without even the implied warranty of ; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ; Lesser General Public License for more details. ; ; You should have received a copy of the GNU Lesser General Public ; License along with the GNU MP Library; see the file COPYING.LIB. If ; not, write to the Free Software Foundation, Inc., 59 Temple Place - ; Suite 330, Boston, MA 02111-1307, USA. ; ; Translation of AT&T syntax code by Brian Gladman %include "..\..\x86i.inc" section .text global ___gmpn_submul_1c %ifdef DLL export ___gmpn_submul_1c %endif align 16 ___gmpn_submul_1c: movd mm1,[20+esp] mov eax,[8+esp] pcmpeqd mm0,mm0 movd mm7,[16+esp] pcmpeqd mm6,mm6 mov edx,[4+esp] psrlq mm0,32 mov ecx,[12+esp] psllq mm6,32 psubq mm6,mm0 psubq mm0,mm1 oop1: movd mm1,[eax] lea eax,[4+eax] movd mm2,[edx] paddq mm2,mm6 pmuludq mm1,mm7 psubq mm2,mm1 paddq mm0,mm2 sub ecx,1 movd [edx],mm0 psrlq mm0,32 lea edx,[4+edx] jnz oop1 movd eax,mm0 not eax emms ret global ___gmpn_submul_1 %ifdef DLL export ___gmpn_submul_1 %endif align 16 ___gmpn_submul_1: pxor mm1,mm1 mov eax,[8+esp] pcmpeqd mm0,mm0 movd mm7,[16+esp] pcmpeqd mm6,mm6 mov edx,[4+esp] psrlq mm0,32 mov ecx,[12+esp] psllq mm6,32 psubq mm6,mm0 psubq mm0,mm1 oop2: movd mm1,[eax] lea eax,[4+eax] movd mm2,[edx] paddq mm2,mm6 pmuludq mm1,mm7 psubq mm2,mm1 paddq mm0,mm2 sub ecx,1 movd [edx],mm0 psrlq mm0,32 lea edx,[4+edx] jnz oop2 movd eax,mm0 not eax emms ret end ecl-16.1.2/msvc/gmp/mpn/x86i/rshift.asm000066400000000000000000000045151266352375300175110ustar00rootroot00000000000000 ; Copyright 1992, 1994, 1996, 1999, 2000, 2001, 2002 Free Software ; Foundation, Inc. ; ; This file is part of the GNU MP Library. ; ; The GNU MP Library is free software; you can redistribute it and/or ; modify it under the terms of the GNU Lesser General Public License as ; published by the Free Software Foundation; either version 2.1 of the ; License, or (at your option) any later version. ; ; The GNU MP Library is distributed in the hope that it will be useful, ; but WITHOUT ANY WARRANTY; without even the implied warranty of ; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ; Lesser General Public License for more details. ; ; You should have received a copy of the GNU Lesser General Public ; License along with the GNU MP Library; see the file COPYING.LIB. If ; not, write to the Free Software Foundation, Inc., 59 Temple Place - ; Suite 330, Boston, MA 02111-1307, USA. ; ; Translation of AT&T syntax code by Brian Gladman %include "x86i.inc" %define PARAM_SHIFT esp+frame+16 %define PARAM_SIZE esp+frame+12 %define PARAM_SRC esp+frame+8 %define PARAM_DST esp+frame+4 %assign frame frame+12 section .text global ___gmpn_rshift %ifdef DLL export ___gmpn_rshift %endif align 8 ___gmpn_rshift: push edi push esi push ebx mov edi,[PARAM_DST] mov esi,[PARAM_SRC] mov edx,[PARAM_SIZE] mov ecx,[PARAM_SHIFT] lea edi,[-4+edi+edx*4] lea esi,[esi+edx*4] neg edx mov ebx,[esi+edx*4] ; read least significant limb xor eax,eax shrd eax,ebx,cl inc edx jz Lend push eax ; push carry limb onto stack test dl,1 jnz L1 ; enter Lop in the middle mov eax,ebx align 8 Lop: mov ebx,[esi+edx*4] ; load next higher limb shrd eax,ebx,cl mov [edi+edx*4],eax ; store it inc edx L1: mov eax,[esi+edx*4] shrd ebx,eax,cl mov [edi+edx*4],ebx inc edx jnz Lop shr eax,cl ; compute most significant limb mov [edi],eax ; store it pop eax ; pop carry limb pop ebx pop esi pop edi ret Lend: shr ebx,cl ; compute most significant limb mov [edi],ebx ; store it pop ebx pop esi pop edi ret end ecl-16.1.2/msvc/gmp/mpn/x86i/udiv.asm000066400000000000000000000025731266352375300171630ustar00rootroot00000000000000 ; Copyright 1999, 2000, 2002 Free Software Foundation, Inc. ; ; This file is part of the GNU MP Library. ; ; The GNU MP Library is free software; you can redistribute it and/or ; modify it under the terms of the GNU Lesser General Public License as ; published by the Free Software Foundation; either version 2.1 of the ; License, or (at your option) any later version. ; ; The GNU MP Library is distributed in the hope that it will be useful, ; but WITHOUT ANY WARRANTY; without even the implied warranty of ; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ; Lesser General Public License for more details. ; ; You should have received a copy of the GNU Lesser General Public ; License along with the GNU MP Library; see the file COPYING.LIB. If ; not, write to the Free Software Foundation, Inc., 59 Temple Place - ; Suite 330, Boston, MA 02111-1307, USA. ; ; Translation of AT&T syntax code by Brian Gladman %include "x86i.inc" %define PARAM_DIVISOR esp+frame+16 %define PARAM_LOW esp+frame+12 %define PARAM_HIGH esp+frame+8 %define PARAM_REMPTR esp+frame+4 %assign frame 0 section .text global ___gmpn_udiv_qrnnd %ifdef DLL export ___gmpn_udiv_qrnnd %endif align 8 ___gmpn_udiv_qrnnd: mov eax,[PARAM_LOW] mov edx,[PARAM_HIGH] div dword [PARAM_DIVISOR] mov ecx,[PARAM_REMPTR] mov [ecx],edx ret end ecl-16.1.2/msvc/gmp/mpn/x86i/umul.asm000066400000000000000000000025031266352375300171670ustar00rootroot00000000000000 ; Copyright 1999, 2000, 2002 Free Software Foundation, Inc. ; ; This file is part of the GNU MP Library. ; ; The GNU MP Library is free software; you can redistribute it and/or ; modify it under the terms of the GNU Lesser General Public License as ; published by the Free Software Foundation; either version 2.1 of the ; License, or (at your option) any later version. ; ; The GNU MP Library is distributed in the hope that it will be useful, ; but WITHOUT ANY WARRANTY; without even the implied warranty of ; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ; Lesser General Public License for more details. ; ; You should have received a copy of the GNU Lesser General Public ; License along with the GNU MP Library; see the file COPYING.LIB. If ; not, write to the Free Software Foundation, Inc., 59 Temple Place - ; Suite 330, Boston, MA 02111-1307, USA. ; ; Translation of AT&T syntax code by Brian Gladman %include "x86i.inc" %define PARAM_M2 esp+frame+12 %define PARAM_M1 esp+frame+8 %define PARAM_LOWPTR esp+frame+4 %assign frame 0 section .text global ___gmpn_umul_ppmm %ifdef DLL export ___gmpn_umul_ppmm %endif align 8 ___gmpn_umul_ppmm: mov ecx,[PARAM_LOWPTR] mov eax,[PARAM_M1] mul dword [PARAM_M2] mov [ecx],eax mov eax,edx ret end ecl-16.1.2/msvc/gmp/mpn/x86i/x86i.inc000066400000000000000000000007051266352375300167760ustar00rootroot00000000000000 %macro FR_push 1 push %1 %assign frame frame+4 %endmacro %macro FR_pop 1 pop %1 %assign frame frame-4 %endmacro %macro FR_sesp 1 %assign frame frame+%1 %endmacro %macro FR_aesp 1 %assign frame frame-%1 %endmacro %assign frame 0 %macro do_name 2 %ifdef DLL export %1 %else export %1@%2 %endif %ifndef STDCALL global %1 %1: %else global %1@%2 %1@%2: %endif %endmacro %macro do_ret 1 %ifndef STDCALL ret %else ret %1 %endif %endmacro ecl-16.1.2/msvc/gmp/mpz/000077500000000000000000000000001266352375300147215ustar00rootroot00000000000000ecl-16.1.2/msvc/gmp/mpz/set_d.c000077500000000000000000000053211266352375300161670ustar00rootroot00000000000000/* mpz_set_d(integer, val) -- Assign INTEGER with a double value VAL. Copyright 1995, 1996, 2000, 2001, 2002, 2003 Free Software Foundation, Inc. This file is part of the GNU MP Library. The GNU MP Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU MP Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU MP Library; see the file COPYING.LIB. If not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ #include "config.h" #if HAVE_FLOAT_H #include /* for DBL_MAX */ #endif #include "gmp.h" #include "gmp-impl.h" /* We used to have a special case for d < MP_BASE_AS_DOUBLE, just casting double -> limb. Unfortunately gcc 3.3 on powerpc970-apple-darwin6.8.5 got this wrong. (It assumed __fixunsdfdi returned its result in a single 64-bit register, where instead that function followed the calling conventions and gave the result in two parts r3 and r4.) Hence the use of __gmp_extract_double in all cases. */ void mpz_set_d (mpz_ptr r, double d) { int negative; mp_limb_t tp[LIMBS_PER_DOUBLE]; mp_ptr rp; mp_size_t rn; DOUBLE_NAN_INF_ACTION (d, __gmp_invalid_operation (), __gmp_invalid_operation ()); negative = d < 0; d = ABS (d); rn = __gmp_extract_double (tp, d); if (ALLOC(r) < rn) _mpz_realloc (r, rn); if(rn <= 0) rn = 0; rp = PTR (r); switch (rn) { default: MPN_ZERO (rp, rn - LIMBS_PER_DOUBLE); rp += rn - LIMBS_PER_DOUBLE; /* fall through */ #if LIMBS_PER_DOUBLE == 2 case 2: rp[1] = tp[1], rp[0] = tp[0]; break; case 1: rp[0] = tp[1]; break; #endif #if LIMBS_PER_DOUBLE == 3 case 3: rp[2] = tp[2], rp[1] = tp[1], rp[0] = tp[0]; break; case 2: rp[1] = tp[2], rp[0] = tp[1]; break; case 1: rp[0] = tp[2]; break; #endif #if LIMBS_PER_DOUBLE == 4 case 4: rp[3] = tp[3], rp[2] = tp[2], rp[1] = tp[1], rp[0] = tp[0]; break; case 3: rp[2] = tp[3], rp[1] = tp[2], rp[0] = tp[1]; break; case 2: rp[1] = tp[3], rp[0] = tp[2]; break; case 1: rp[0] = tp[3]; break; #endif case 0: break; } SIZ(r) = negative ? -rn : rn; } ecl-16.1.2/msvc/tests/000077500000000000000000000000001266352375300144725ustar00rootroot00000000000000ecl-16.1.2/msvc/tests/Makefile000077500000000000000000000015701266352375300161400ustar00rootroot00000000000000top_srcdir=..\.. ECLDIR=../package/ ECL=..\package\ecl.exe all: show-fails .PHONY: do-regressions cleanup clean-sources update config.lsp: $(top_srcdir)\src\tests\config.lsp.in ..\c\cut.exe Makefile ..\c\cut.exe "@builddir@" "./" \ "@top_srcdir@" "../.." \ < $(top_srcdir)\src\tests\config.lsp.in > config.lsp output.ecl\regressions.log: config.lsp $(MAKE) do-regressions do-regressions: regressions config.lsp set ECLDIR=$(ECLDIR) $(ECL) -norc -load config.lsp -eval "(ecl-tests::run-regressions-tests)" -eval "(ext:quit)" show-fails: regressions.log type regressions.log # # Create directories # regressions.log: config.lsp $(MAKE) do-regressions # # Cleanup # clean: rm -rf output* clean-sources: test -f config.lsp.in || rm -rf bugs rm -rf ansi-tests quicklisp distclean: clean-sources clean rm -rf cache update: clean-sources $(MAKE) regressions ecl-16.1.2/msvc/util/000077500000000000000000000000001266352375300143055ustar00rootroot00000000000000ecl-16.1.2/msvc/util/ecl-cc.bat000066400000000000000000000006671266352375300161340ustar00rootroot00000000000000@ECHO OFF REM Script to compile/link a C file with ECL REM (Michael Goffioul) set CMDTYPE=%1 set CMDARGS= :LOOP shift IF NOT "%1" == "" ( set CMDARGS=%CMDARGS% %1 goto LOOP ) IF %CMDTYPE% == --compile ( cl @ECL_CFLAGS@ -I@includedir@ %CMDARGS% GOTO END ) ELSE IF %CMDTYPE% == --link ( cl %CMDARGS% @LDFLAGS@ @libdir@/ecl.lib GOTO END ) ECHO Usage: %0 [OPTIONS] [ARGS*] ECHO Options: ECHO [--compile] ECHO [--link] :END ecl-16.1.2/msvc/util/ecl-config.bat000066400000000000000000000005021266352375300170000ustar00rootroot00000000000000@ECHO OFF REM Script converted from ecl-config REM (Michael Goffioul) IF %1 == --cflags ( ECHO @ECL_CFLAGS@ -I@includedir@ GOTO END ) ELSE IF %1 == --libs ( ECHO @LDFLAGS@ /link /LIBPATH:@libdir@ ecl.lib @CLIBS@ GOTO END ) ECHO Usage: ecl-config [OPTIONS] ECHO Options: ECHO [--cflags] ECHO [--libs] :END ecl-16.1.2/msvc/util/ecl_nsi.bat000077500000000000000000000016741266352375300164240ustar00rootroot00000000000000REM @ECHO off REM Converted from ecl_nsi.sh SETLOCAL SET source=%1 SET where=%2 CD %where% SET dest=ecl.nsi SET version=%3 type %source%1 | ..\c\cut.exe "@ECLDIR@" "%where%" "@ECLVERSION@" "%version%" > %dest% dir /b /a:-d | ..\c\cut.exe "ecl.exe" "/DELETE/" "ecl.nsi" "/DELETE/" "%where%\\" "" > ../aux_files dir /b /a:d | ..\c\cut.exe "ecl.exe" "/DELETE/" "ecl.nsi" "/DELETE/" "%where%\\" "" > ../aux_dirs echo HOLA for /f %%i in (../aux_dirs) do @echo %%i for /f %%i in (../aux_dirs) do @echo File /r "${ECLDIR}\%%i" >> %dest% for /f %%i in (../aux_files) do @echo File "${ECLDIR}\%%i" >> %dest% if exist ecl.exe.manifest @echo File "${ECLDIR}\ecl.exe.manifest" >> %dest% type %source%2 >> %dest% if exist ecl.exe.manifest @echo Delete "${ECLDIR}\ecl.exe.manifest" >> %dest% for /f %%i in (../aux_files) do @echo Delete "$INSTDIR\%%i" >> %dest% for /f %%i in (../aux_dirs) do @echo RMDir /r "$INSTDIR\%%i" >> %dest% type %source%3 >> %dest% ENDLOCAL ecl-16.1.2/src/000077500000000000000000000000001266352375300131475ustar00rootroot00000000000000ecl-16.1.2/src/Makefile.in000066400000000000000000000224641266352375300152240ustar00rootroot00000000000000# -*- Mode: Makefile; indent-tabs-mode: nil -*- # vim: set filetype=makefile tabstop=8 shiftwidth=4 expandtab: # # Makefile for ECoLisp # top_srcdir= @top_srcdir@ srcdir = @srcdir@ mandir=@mandir@ manext=1 # Programs used by "make": # @SET_MAKE@ CC = @ECL_CC@ LIBS = @LIBS@ FASL_LIBS = @FASL_LIBS@ CORE_LIBS = @CORE_LIBS@ LDFLAGS = @LDFLAGS@ RM = @RM@ LN_S = @LN_S@ EXE = @EXEEXT@ ETAGS = @ETAGS@ # ==================== Where To Install Things ==================== # The default location for installation. Everything is placed in # subdirectories of this directory. The default values for many of # the variables below are expressed in terms of this one, so you may # not need to change them. This defaults to /usr/local. prefix=@prefix@ exec_prefix=@exec_prefix@ bindir=@bindir@/ libdir=@libdir@/ includedir=@includedir@/ ecldir=@ecldir@/ # Programs used by "make install": # SHELL = @SHELL@ INSTALL = @INSTALL@ INSTALL_PROGRAM = @INSTALL_PROGRAM@ INSTALL_SCRIPT = @INSTALL_SCRIPT@ INSTALL_LIBRARY = $(INSTALL_SCRIPT) INSTALL_DATA = @INSTALL_DATA@ mkinstalldirs = $(top_srcdir)/bdwgc/install-sh -d # Files SUBDIRS = @SUBDIRS@ LIBRARIES = @LIBRARIES@ LSP_LIBRARIES = @LSP_LIBRARIES@ TARGETS = @TARGETS@ ECL_CMPDIR = @ECL_CMPDIR@ all: $(TARGETS) bin/ecl-config .git/tags TAGS .PHONY: all %Makefile: $(srcdir)/%Makefile.in config.status ./config.status # # When compiling the library itself, we have to remove the dllimport # declarations, because the variables that they mark are in the # in the library and can be referenced without indirection. # c/ecl/external.h: $(top_srcdir)/h/external.h test -d c/ecl || mkdir c/ecl sed 's,__declspec(dllimport),,g' $(top_srcdir)/h/external.h > $@ ecl/external.h: c/ecl/external.h c/ecl/external.h cp -rf $(srcdir)/h/*.h $(srcdir)/h/impl ecl/ bin/ecl$(EXE): ecl_min$(EXE) compile.lsp ecl/external.h build-stamp $(top_srcdir)/lsp/*.lsp $(top_srcdir)/clos/*.lsp $(top_srcdir)/*cmp/*.lsp if [ -f CROSS-COMPILER ]; then \ ./CROSS-COMPILER compile; \ else \ ECLDIR=`pwd`/ ./ecl_min$(EXE) compile; \ fi if [ "x@SONAME@" != "x" -a -f "@SONAME@" ]; then \ ( mv @SONAME@ @SONAME3@ && \ $(RM) -f @SONAME2@ @SONAME1@ @SONAME@ && \ $(LN_S) @SONAME3@ @SONAME2@ && \ $(LN_S) @SONAME3@ @SONAME1@ && \ $(LN_S) @SONAME3@ @SONAME@ ) \ fi ecl_min$(EXE): $(LIBRARIES) .gdbinit @LIBPREFIX@eclmin.@LIBEXT@ if [ -f CROSS-COMPILER ]; then \ touch $@; \ else \ $(CC) $(LDFLAGS) -o $@ cinit.o c/all_symbols.o -L./ @LIBPREFIX@eclmin.@LIBEXT@ $(CORE_LIBS) $(FASL_LIBS) $(LIBS);\ fi mini_ecl: ecl_min$(EXE) bare2.lsp (echo '#!/bin/sh'; echo './ecl_min bare2.lsp') > $@ chmod +x $@ bare2.lsp: echo '(load "bare")(si::top-level)' > $@ .gdbinit: $(srcdir)/util/gdbinit cp $(srcdir)/util/gdbinit $@ lsp/config.lsp: lsp/config.pre sed -e 's,@ecldir\\@,$(ecldir),g' < lsp/config.pre > lsp/config.lsp $(ECL_CMPDIR)/cmpdefs.lsp: $(ECL_CMPDIR)/cmpdefs.pre sed -e 's,@ecldir\\@,"$(ecldir)",g' \ -e 's,@libdir\\@,"$(libdir)",g' \ -e 's,@includedir\\@,"$(includedir)",g' < $(ECL_CMPDIR)/cmpdefs.pre > $@ compile.lsp: compile.pre sed -e 's,@ecldir\\@,$(ecldir),g' \ -e 's,@libdir\\@,$(libdir),g' < compile.pre > compile.lsp bin/ecl-config: bin/ecl-config.pre sed -e 's,@libdir\\@,$(libdir),' \ -e 's,@includedir\\@,$(includedir),' \ -e 's,~A,$(libdir),' bin/ecl-config.pre > bin/ecl-config @LIBPREFIX@eclmin.@LIBEXT@: @LIBPREFIX@eclgmp.@LIBEXT@ @LIBPREFIX@eclatomic.@LIBEXT@ @LIBPREFIX@eclgc.@LIBEXT@ @LIBPREFIX@eclffi.@LIBEXT@ lsp/config.lsp $(ECL_CMPDIR)/cmpdefs.lsp ecl/external.h $(top_srcdir)/c/*.d cd c; $(MAKE) @LIBPREFIX@eclgc.@LIBEXT@: @LIBPREFIX@eclatomic.@LIBEXT@ test -d ecl/gc || mkdir ecl/gc test -d ecl/gc/private || mkdir ecl/gc/private if (echo $(SUBDIRS) | grep gc); then \ cd gc && $(MAKE) install && cd .. && \ cp -rf $(srcdir)/@ECL_GC_DIR@/include/private/*.h ecl/gc/private/ && \ mv @LIBPREFIX@gc.@LIBEXT@ @LIBPREFIX@eclgc.@LIBEXT@; \ fi @LIBPREFIX@eclffi.@LIBEXT@: if (echo $(SUBDIRS) | grep libffi); then \ cd libffi && $(MAKE) install && cd .. && \ sed -e 's, ecl/foo.h && \ rm ecl/ffi.h && mv ecl/foo.h ecl/ffi.h && \ mv @LIBPREFIX@ffi.@LIBEXT@ @LIBPREFIX@eclffi.@LIBEXT@; \ fi @LIBPREFIX@eclatomic.@LIBEXT@: if (echo $(SUBDIRS) | grep atomic); then \ cd atomic && $(MAKE) && $(MAKE) install && cd .. && \ $(RM) -rf share ecl/atomic_ops_stack.h ecl/atomic_ops_malloc.h *atomic*gpl* && \ mv @LIBPREFIX@atomic_ops.@LIBEXT@ @LIBPREFIX@eclatomic.@LIBEXT@; \ fi @LIBPREFIX@eclgmp.@LIBEXT@: if (echo $(SUBDIRS) | grep gmp); then \ cd gmp && $(MAKE) install && \ cd .. && mv include/gmp.h ecl/ && rmdir include && \ mv ./@LIBPREFIX@gmp.@LIBEXT@ ./@LIBPREFIX@eclgmp.@LIBEXT@; \ fi rt.lisp: cp $(srcdir)/../contrib/rt/rt.lisp ./ build-stamp: config.status echo "#" `uname -a` > $@ head -8 config.log | tail -6 >> $@ install: # Here we would use the option -s but the install program in sourceforge-solaris # is broken. $(mkinstalldirs) $(DESTDIR)$(bindir) $(DESTDIR)$(libdir) \ $(DESTDIR)$(ecldir) $(DESTDIR)$(includedir) $(DESTDIR)$(includedir)/ecl for i in $(TARGETS); do \ $(INSTALL_PROGRAM) $$i $(DESTDIR)$(bindir); \ done if [ -d encodings ]; then \ $(mkinstalldirs) $(DESTDIR)$(ecldir)/encodings; \ for i in ./encodings/*; do \ $(INSTALL_DATA) $$i $(DESTDIR)$(ecldir)/encodings; \ done \ fi sed '/-CUT-/,$$d' ./ecl/config.h > ./ecl/config-install.h $(mkinstalldirs) $(DESTDIR)$(includedir)/ecl for i in `(cd ecl && find . -type d)`; do \ k="$(DESTDIR)$(includedir)/ecl/$$i"; \ test -d "$$k" || $(mkinstalldirs) $$k; \ done for i in `(cd ecl && find . -name '*.h')`; do echo $$i; \ $(INSTALL_DATA) ecl/$$i $(DESTDIR)$(includedir)/ecl/$$i; \ done $(RM) -f $(DESTDIR)$(includedir)/ecl/config.h mv $(DESTDIR)$(includedir)/ecl/config-install.h $(DESTDIR)$(includedir)/ecl/config.h $(INSTALL_SCRIPT) bin/ecl-config $(DESTDIR)$(bindir) for i in build-stamp help.doc TAGS ; do \ $(INSTALL_DATA) $$i $(DESTDIR)$(ecldir); \ done for i in $(LSP_LIBRARIES) $(LIBRARIES); do \ if test -s $$i ; then \ if echo $$i | grep dll; then \ $(INSTALL_LIBRARY) $$i $(DESTDIR)$(bindir); \ fi; \ $(INSTALL_LIBRARY) $$i $(DESTDIR)$(libdir); \ fi \ done if [ "x@SONAME3@" != "x" -a -f "@SONAME3@" ]; then \ ( $(INSTALL_LIBRARY) @SONAME3@ $(DESTDIR)$(libdir) && \ cd $(DESTDIR)$(libdir) && $(RM) -f @SONAME2@ @SONAME1@ @SONAME@ && \ $(LN_S) @SONAME3@ @SONAME2@ && \ $(LN_S) @SONAME3@ @SONAME1@ && \ $(LN_S) @SONAME3@ @SONAME@ ) \ fi $(INSTALL_PROGRAM) c/dpp$(EXE) $(DESTDIR)$(ecldir) $(INSTALL_PROGRAM) ecl_min$(EXE) $(DESTDIR)$(ecldir) for i in `cat modules`; do \ case $$i in \ *.fas) $(INSTALL_PROGRAM) $$i $(DESTDIR)$(ecldir);; \ *) $(INSTALL_DATA) $$i $(DESTDIR)$(ecldir);; \ esac \ done for i in Copyright LGPL; do \ $(INSTALL_DATA) $(top_srcdir)/../$$i $(DESTDIR)$(ecldir); \ done $(mkinstalldirs) $(DESTDIR)$(mandir)/man$(manext) $(INSTALL_DATA) doc/ecl.man $(DESTDIR)$(mandir)/man$(manext)/ecl.$(manext) $(INSTALL_DATA) doc/ecl-config.man $(DESTDIR)$(mandir)/man$(manext)/ecl-config.$(manext) flatinstall: build-stamp $(MAKE) DESTDIR=$(DESTDIR) bindir=$(prefix) libdir=$(prefix) \ includedir=$(prefix) ecldir=$(prefix) install uninstall: for i in $(TARGETS) ecl-config; do $(RM) $(DESTDIR)$(bindir)/$$i; done $(RM) -r $(DESTDIR)$(includedir)/ecl $(DESTDIR)$(ecldir) for i in $(LSP_LIBRARIES) $(LIBRARIES) Copyright LGPL; do \ $(RM) $(DESTDIR)$(libdir)/$$i || : ; \ done $(RM) -f $(DESTDIR)$(mandir)/man$(manext)/ecl.$(manext) $(RM) -f $(DESTDIR)$(mandir)/man$(manext)/ecl-config.$(manext) clean: mostlyclean $(RM) -r * mostlyclean: clean_lisp (cd tests && $(MAKE) clean) for i in $(SUBDIRS); do (test -d $$i && cd $$i && $(MAKE) clean); done $(RM) ecl_min$(EXE) bin/ecl$(EXE) help.doc core a.out TAGS $(RM) config.version config.log config.cache $(RM) *.c *.o *.a *.eclh *.h *.data *.fas *.dat *.la *.so *.dylib clean_lisp: -$(RM) help.doc $(TARGETS) -for i in lsp cmp clos clx tk ext; do $(RM) lib$$i.a $$i/?*.{o,eclh,data,c,sdat,h,fas}; done distclean: clean realclean: distclean # # Rebuild ECL using recent changes and compare # test_changes: test -d old || mkdir old cp -rf lsp clos cmp old/ $(MAKE) clean_lisp; $(MAKE) -C c clean; $(RM) -f bin/ecl$(EXE) $(MAKE) for i in lsp clos cmp; do diff --exclude=\*.o $$i old/$$i; done # # Run test suite # check: cd tests && $(MAKE) recheck: cd tests && $(MAKE) clean && $(MAKE) # # Rebuild ECL using its own image and compare. Does not work # right now. # selfbuild: exit 2 test -d stage2 || mkdir stage2 cp -rf lsp clos cmp stage2 -for i in lsp cmp clos clx tk; do test -f lib$$i.a && mv lib$$i.a stage2; done $(MAKE) clean_lisp ./ecl compile -for i in lsp clos cmp clx tk; do test -d $$i && diff --exclude=\*.o $$i stage2/$$i; done | less # Make sure to also include *.d files; and match DPP's idiosyncracies # like "@si::foo" and "@(defun si::foo". # This rule is allowed to fail when etags does not exist. .git/tags: cd $(srcdir)/../.git && ctags -o tags -R --langmap=c:+.d ../src || true TAGS: -if test "x$(ETAGS)" != "x"; then \ srcfiles=`find $(srcdir)/c $(srcdir)/h -name '*.[chd]'` && \ $(ETAGS) --language=c -o $@ $$srcfiles && \ $(ETAGS) --language=none -o $@ --append \ --regex='/@\([-:*a-zA-z]+\)/\1/' \ --regex='/@(defun \([-:*a-zA-z]+\)/\1/' \ $$srcfiles; \ fi touch $@ ecl-16.1.2/src/aclocal.m4000066400000000000000000001117471266352375300150220ustar00rootroot00000000000000dnl -*- autoconf -*- dnl -------------------------------------------------------------- dnl check existence of long double and supporting functions AC_DEFUN([ECL_LONG_DOUBLE],[ if test "$enable_longdouble" != "no" ; then AC_CHECK_TYPES([long double],[enable_longdouble=yes],[enable_longdouble=no]) if test "$enable_longdouble" != "no" ; then AC_CHECK_FUNCS([sinl cosl tanl logl expl],[],[enable_longdouble=no; break]) if test "$enable_longdouble" != "no" ; then AC_DEFINE([ECL_LONG_FLOAT], [], [ECL_LONG_FLOAT]) fi fi fi ]) dnl -------------------------------------------------------------- dnl http://autoconf-archive.cryp.to/ac_c_long_long_.html dnl Provides a test for the existance of the long long int type and defines HAVE_LONG_LONG if it is found. AC_DEFUN([ECL_LONG_LONG], [AC_MSG_CHECKING(size of long long) if test "x$ECL_LONG_LONG_BITS" = "xno"; then AC_MSG_RESULT(not available) ac_cv_c_long_long=no ECL_LONG_LONG_BITS="" else if test "$GCC" = yes; then ac_cv_c_long_long=yes else AC_COMPILE_IFELSE([AC_LANG_PROGRAM(,[[long long int i;]])], ac_cv_c_long_long=yes, ac_cv_c_long_long=no) fi fi if test $ac_cv_c_long_long = yes; then if test "x$ECL_LONG_LONG_BITS" = "x"; then AC_RUN_IFELSE([AC_LANG_SOURCE([[#include int main() { const char *int_type; int bits; unsigned long long x = 1; FILE *f=fopen("conftestval", "w"); if (!f) exit(1); for (bits = 0; x; bits++) { x <<= 1; } fprintf(f,"ECL_LONG_LONG_BITS='%d'",bits); exit(0); }]])],[eval "`cat conftestval`"],[],[]) fi fi if test "x$ECL_LONG_LONG_BITS" = "x"; then AC_MSG_RESULT(not available) else AC_MSG_RESULT([$ECL_LONG_LONG_BITS]) AC_DEFINE([ecl_long_long_t], [long long], [compiler understands long long]) AC_DEFINE([ecl_ulong_long_t], [unsigned long long], [compiler understands long long]) AC_DEFINE_UNQUOTED([ECL_LONG_LONG_BITS],[$ECL_LONG_LONG_BITS], [ECL_LOING_LONG_BITS])dnl last param needs to be on a new line. -evrim. fi ]) dnl -------------------------------------------------------------- dnl Add *feature* for conditional compilation. AC_DEFUN([ECL_ADD_FEATURE], [ LSP_FEATURES="(cons :$1 ${LSP_FEATURES})" ]) dnl -------------------------------------------------------------- dnl Add lisp module to compile; if second argument is given, dnl compile module into Lisp library if we don't support shared dnl libraries. dnl AC_DEFUN([ECL_ADD_LISP_MODULE], [ ECL_ADD_FEATURE([wants-$1]) ]) dnl -------------------------------------------------------------- dnl Add lisp module and build it into the compiler. dnl AC_DEFUN([ECL_ADD_BUILTIN_MODULE], [ ECL_ADD_FEATURE([builtin-$1]) ]) dnl -------------------------------------------------------------- dnl Set up a configuration file for the case when we are cross- dnl compiling dnl AC_DEFUN(ECL_CROSS_CONFIG,[ if test "x${cross_compiling}" = "xyes"; then if test -n "${with_cross_config}" -a -f "${with_cross_config}"; then . ${with_cross_config} elif test -f ./cross_config; then . ./cross_config elif test -n "${srcdir}" -a -f ${srcdir}/cross_config; then . ${srcdir}/cross_config else test -z ${with_cross_config} && cross_config=`pwd`/cross_config cat > ${with_cross_config} <_IO_read_end - (f)->_IO_read_ptr ### 2 = (f)->_r ### 3 = (f)->_cnt ECL_FILE_CNT=0 ### ### 1.6) Other integer types (set to 'no' to disable) ### ECL_STDINT_HEADER="#include " ECL_UINT8_T=uint8_t ECL_UINT16_T=uint16_t ECL_UINT32_T=uint32_t ECL_UINT64_T=no ECL_INT8_T=int8_t ECL_INT16_T=int16_t ECL_INT32_T=int32_t ECL_INT64_T=no ECL_LONG_LONG_BITS=no ### ### 1.7) Other features (set to 'no' to disable) ### ECL_WORKING_ENVIRON=yes ### 2) To cross-compile ECL so that it runs on the system ### ${host} ### you need to first compile ECL on the system in which you are building ### the cross-compiled files, that is ### ${build} ### By default we assume that ECL can be accessed from some directory in ### the path. ECL_TO_RUN=`which ecl` EOF cat ${with_cross_config} AC_MSG_ERROR(Configuration aborted) fi if test "${ECL_TO_RUN}" = "failed"; then AC_MSG_ERROR(The program ECL is not installed in your system) fi ECL_MIN_TO_RUN=`${ECL_TO_RUN} -norc -eval '(progn (print (truename "sys:ecl_min")) (si:quit))' \ | grep '\#\P' | sed 's,#P"\(.*\)",\1,'` if test -z "${ECL_MIN_TO_RUN}" -o "${ECL_MIN_TO_RUN}" = "failed" ; then AC_MSG_ERROR(The program ECL-MIN is not installed in your system) fi DPP_TO_RUN=`${ECL_TO_RUN} -norc -eval '(progn (print (truename "sys:dpp")) (si:quit))' \ | grep '\#\P' | sed 's,#P"\(.*\)",\1,'` if test -z "${DPP_TO_RUN}" -o "${DPP_TO_RUN}" = "failed" ; then AC_MSG_ERROR(The program DPP is not installed in your system) fi dnl (echo '#!/bin/sh'; echo exec ${ECL_TO_RUN} -eval "'"'(push :cross *features*)'"'" '$''*') > CROSS-COMPILER (echo '#!/bin/sh'; echo exec ${ECL_MIN_TO_RUN} '$''*') > CROSS-COMPILER (echo '#!/bin/sh'; echo exec ${DPP_TO_RUN} '$''*') > CROSS-DPP chmod +x CROSS-COMPILER CROSS-DPP ECL_ADD_FEATURE([cross]) fi ]) dnl -------------------------------------------------------------- dnl Make srcdir absolute, if it isn't already. It's important to dnl avoid running the path through pwd unnecessarily, since pwd can dnl give you automounter prefixes, which can go away. dnl AC_DEFUN(ECL_MAKE_ABSOLUTE_SRCDIR,[ AC_SUBST(true_srcdir) AC_SUBST(true_builddir) PWDCMD="pwd"; case "${srcdir}" in /* | ?:/* ) ;; * ) srcdir="`(cd ${srcdir}; ${PWDCMD})`"; esac if uname -a | grep -i 'mingw32' > /dev/null; then true_srcdir=`(cd ${srcdir}; pwd -W)` true_builddir=`pwd -W` else true_srcdir=`(cd ${srcdir}; pwd)` true_builddir=`pwd` fi ]) dnl dnl -------------------------------------------------------------- dnl Define a name for this operating system and set some defaults dnl AC_DEFUN(ECL_GUESS_HOST_OS,[ #### Some command variations: AC_SUBST(CP) AC_SUBST(RM) AC_SUBST(MV) AC_SUBST(EXE_SUFFIX) RM="rm -f" CP="cp" MV="mv" ### Guess the operating system AC_SUBST(ARCHITECTURE)dnl Type of processor for which this is compiled AC_SUBST(SOFTWARE_TYPE)dnl Type of operating system AC_SUBST(SOFTWARE_VERSION)dnl Version number of operating system AC_SUBST(MACHINE_VERSION)dnl Version of the machine AC_SUBST(ECL_LDRPATH)dnl Sometimes the path for finding DLLs must be hardcoded. AC_SUBST(LIBPREFIX)dnl Name components of a statically linked library AC_SUBST(LIBEXT) AC_SUBST(SHAREDEXT)dnl Name components of a dynamically linked library AC_SUBST(SHAREDPREFIX) AC_SUBST(OBJEXT)dnl These are set by autoconf AC_SUBST(EXEEXT) AC_SUBST(INSTALL_TARGET)dnl Which type of installation: flat directory or unix like. AC_SUBST(thehost) AC_SUBST(ECL_GC_DIR)dnl Which version of the Boehm-Weiser library to use ECL_GC_DIR=bdwgc ECL_LDRPATH='' SHAREDEXT='so' SHAREDPREFIX='lib' LIBPREFIX='lib' LIBEXT='a' PICFLAG='-fPIC' THREAD_CFLAGS='' THREAD_LIBS='' THREAD_GC_FLAGS='--enable-threads=posix' INSTALL_TARGET='install' THREAD_OBJ="$THREAD_OBJ threads/process threads/queue threads/mutex threads/condition_variable threads/semaphore threads/barrier threads/mailbox" clibs='' SONAME='' SONAME_LDFLAGS='' case "${host_os}" in linux-androideabi) thehost='android' THREAD_CFLAGS='-D_THREAD_SAFE' # THREAD_LIBS='-lpthread' SHARED_LDFLAGS="-shared ${LDFLAGS}" BUNDLE_LDFLAGS="-shared ${LDFLAGS}" ECL_LDRPATH='-Wl,--rpath,~A' clibs="-ldl" # Maybe CFLAGS="-D_ISOC99_SOURCE ${CFLAGS}" ??? CFLAGS="-D_GNU_SOURCE -D_FILE_OFFSET_BITS=64 -DANDROID -DPLATFORM_ANDROID -DUSE_GET_STACKBASE_FOR_MAIN -DIGNORE_DYNAMIC_LOADING -DAO_REQUIRE_CAS ${CFLAGS}" SONAME="${SHAREDPREFIX}ecl.${SHAREDEXT}.SOVERSION" SONAME_LDFLAGS="-Wl,-soname,SONAME" ECL_ADD_FEATURE([android]) ;; # libdir may have a dollar expression inside linux*) thehost='linux' THREAD_CFLAGS='-D_THREAD_SAFE' THREAD_LIBS='-lpthread' SHARED_LDFLAGS="-shared ${LDFLAGS}" BUNDLE_LDFLAGS="-shared ${LDFLAGS}" ECL_LDRPATH='-Wl,--rpath,~A' clibs="-ldl" # Maybe CFLAGS="-D_ISOC99_SOURCE ${CFLAGS}" ??? CFLAGS="-D_GNU_SOURCE -D_FILE_OFFSET_BITS=64 ${CFLAGS}" SONAME="${SHAREDPREFIX}ecl.${SHAREDEXT}.SOVERSION" SONAME_LDFLAGS="-Wl,-soname,SONAME" ;; gnu*) thehost='gnu' THREAD_CFLAGS='-D_THREAD_SAFE' THREAD_LIBS='-lpthread' SHARED_LDFLAGS="-shared ${LDFLAGS}" BUNDLE_LDFLAGS="-shared ${LDFLAGS}" ECL_LDRPATH='-Wl,--rpath,~A' clibs="-ldl" CFLAGS="-D_GNU_SOURCE ${CFLAGS}" SONAME="${SHAREDPREFIX}ecl.${SHAREDEXT}.SOVERSION" SONAME_LDFLAGS="-Wl,-soname,SONAME" ;; kfreebsd*-gnu) thehost='kfreebsd' THREAD_CFLAGS='-D_THREAD_SAFE' THREAD_LIBS='-lpthread' SHARED_LDFLAGS="-shared ${LDFLAGS}" BUNDLE_LDFLAGS="-shared ${LDFLAGS}" ECL_LDRPATH='-Wl,--rpath,~A' clibs="-ldl" CFLAGS="-D_GNU_SOURCE ${CFLAGS}" SONAME="${SHAREDPREFIX}ecl.${SHAREDEXT}.SOVERSION" SONAME_LDFLAGS="-Wl,-soname,SONAME" ;; dragonfly*) thehost='dragonfly' THREAD_LIBS='-lpthread' SHARED_LDFLAGS="-shared ${LDFLAGS}" BUNDLE_LDFLAGS="-shared ${LDFLAGS}" ECL_LDRPATH="-Wl,--rpath,~A" clibs="" SONAME="${SHAREDPREFIX}ecl.${SHAREDEXT}.SOVERSION" SONAME_LDFLAGS="-Wl,-soname,SONAME" ;; freebsd*) thehost='freebsd' THREAD_LIBS='-lpthread' SHARED_LDFLAGS="-shared ${LDFLAGS}" BUNDLE_LDFLAGS="-shared ${LDFLAGS}" ECL_LDRPATH="-Wl,--rpath,~A" clibs="" SONAME="${SHAREDPREFIX}ecl.${SHAREDEXT}.SOVERSION" SONAME_LDFLAGS="-Wl,-soname,SONAME" ;; netbsd*) thehost='netbsd' THREAD_LIBS='-lpthread' SHARED_LDFLAGS="-shared ${LDFLAGS}" BUNDLE_LDFLAGS="-shared ${LDFLAGS}" ECL_LDRPATH="-Wl,--rpath,~A" clibs="" SONAME="${SHAREDPREFIX}ecl.${SHAREDEXT}.SOVERSION" SONAME_LDFLAGS="-Wl,-soname,SONAME" ;; openbsd*) thehost='openbsd' THREAD_CFLAGS='' THREAD_LIBS='' SHARED_LDFLAGS="-shared ${LDFLAGS}" BUNDLE_LDFLAGS="-shared ${LDFLAGS}" ECL_LDRPATH="-Wl,--rpath,~A" clibs="-lpthread -lm" SONAME="${SHAREDPREFIX}ecl.${SHAREDEXT}.SOVERSION" SONAME_LDFLAGS="-Wl,-soname,SONAME" ;; solaris*) thehost='sun4sol2' THREAD_LIBS='-lrt -lpthread' SHARED_LDFLAGS="-dy -G ${LDFLAGS}" BUNDLE_LDFLAGS="-dy -G ${LDFLAGS}" ECL_LDRPATH='-Wl,-R,~A' TCPLIBS='-lsocket -lnsl -lintl' clibs='-ldl' SONAME="${SHAREDPREFIX}ecl.${SHAREDEXT}.SOVERSION" SONAME_LDFLAGS="-Wl,-soname,SONAME" if test "x$GCC" = "xyes"; then CFLAGS="${CFLAGS} -std=gnu99 -D_XOPEN_SOURCE=600 -D__EXTENSIONS__" SHARED_LDFLAGS="-shared $SHARED_LDFLAGS" BUNDLE_LDFLAGS="-shared $BUNDLE_LDFLAGS" fi ;; cygwin*) enable_threads='no' thehost='cygwin' shared='yes' THREAD_CFLAGS='-D_THREAD_SAFE' THREAD_LIBS='-lpthread' SHARED_LDFLAGS="-shared ${LDFLAGS}" BUNDLE_LDFLAGS="-shared ${LDFLAGS}" SHAREDPREFIX='' SHAREDEXT='dll' PICFLAG='' if test "x$host_cpu" = "xx86_64" ; then # Our GMP library is too old and does not support # Windows64 calling conventions. with_c_gmp=yes fi ;; mingw*) thehost='mingw32' clibs='' shared='yes' enable_threads='yes' THREAD_CFLAGS='-D_THREAD_SAFE' THREAD_GC_FLAGS='--enable-threads=win32' SHARED_LDFLAGS='' BUNDLE_LDFLAGS='' SHAREDPREFIX='' SHAREDEXT='dll' PICFLAG='' INSTALL_TARGET='flatinstall' TCPLIBS='-lws2_32' ;; darwin*) thehost='darwin' shared='yes' SHAREDEXT='dylib' PICFLAG='-fPIC -fno-common' SHARED_LDFLAGS="-dynamiclib -flat_namespace -undefined suppress ${LDFLAGS}" BUNDLE_LDFLAGS="-bundle ${LDFLAGS}" ECL_LDRPATH='' THREAD_CFLAGS='-D_THREAD_SAFE' THREAD_LIBS='-lpthread' # The GMP library has not yet been ported to Intel-OSX case "`uname -m`" in i386*|x86_64) gmp_build=none-apple-${host_os};; *) ABI=32;; esac if test "x$ABI" = "x64"; then if echo "$CFLAGS" | grep -v '[ ]*-m64' >/dev/null ; then CFLAGS="-m64 $CFLAGS" LDFLAGS="-m64 $LDFLAGS" fi # Needed when building the old version of GMP. # Should be removed when moving to MPIR ABI="long" fi if test "x$ABI" = "x32"; then ABI="long" fi # The Boehm-Weiser GC library shipped with Fink does not work # well with our signal handler. # enable_boehm=included if test `uname -r | cut -d '.' -f 1` -ge 11; then ECL_GC_DIR=bdwgc fi SONAME="${SHAREDPREFIX}ecl.SOVERSION.${SHAREDEXT}" SONAME_LDFLAGS="-Wl,-install_name,@libdir\@/SONAME -Wl,-compatibility_version,${PACKAGE_VERSION}" ;; nsk*) # HP Non-Stop platform thehost='nonstop' shared='yes' PICFLAG='-call_shared' THREAD_CFLAGS='-spthread' SHARED_LDFLAGS="-shared ${LDFLAGS}" BUNDLE_LDFLAGS="-shared ${LDFLAGS}" ECL_LDRPATH='-Wld=\"-rld_l ~A\"' clibs="-Wld=-lrld" ;; *) thehost="$host_os" shared="no" ;; esac case "${host}" in *-nacl) thehost='linux' THREAD_CFLAGS='-D_THREAD_SAFE' THREAD_LIBS='-lpthread' SHARED_LDFLAGS="-shared ${LDFLAGS}" BUNDLE_LDFLAGS="-shared ${LDFLAGS}" ECL_LDRPATH='-Wl,--rpath,~A' CFLAGS="-D_GNU_SOURCE -D_FILE_OFFSET_BITS=64 ${CFLAGS}" SONAME="${SHAREDPREFIX}ecl.${SHAREDEXT}.SOVERSION" SONAME_LDFLAGS="-Wl,-soname,SONAME" ECL_ADD_FEATURE([nacl]) ;; *-pnacl) thehost='linux' THREAD_CFLAGS='-D_THREAD_SAFE' THREAD_LIBS='-lpthread' dnl SHARED_LDFLAGS="-shared ${LDFLAGS}" dnl BUNDLE_LDFLAGS="-shared ${LDFLAGS}" dnl ECL_LDRPATH='-Wl,--rpath,~A' CFLAGS="-D_GNU_SOURCE -D_FILE_OFFSET_BITS=64 ${CFLAGS}" dnl SONAME="${SHAREDPREFIX}ecl.${SHAREDEXT}.SOVERSION" dnl SONAME_LDFLAGS="-Wl,-soname,SONAME" ECL_ADD_FEATURE([nacl]) ECL_ADD_FEATURE([pnacl]) ;; i686*-android*) THREAD_LIBS='' CFLAGS="-D_GNU_SOURCE -D_FILE_OFFSET_BITS=64 -DANDROID -DPLATFORM_ANDROID -DUSE_GET_STACKBASE_FOR_MAIN -DIGNORE_DYNAMIC_LOADING -DNO_GETCONTEXT -DHAVE_GETTIMEOFDAY -DHAVE_SIGPROCMASK ${CFLAGS}" ECL_ADD_FEATURE([android]) ;; esac case "${host_cpu}" in alpha*) CFLAGS="${CFLAGS} -mieee";; esac ECL_CFLAGS="-D${thehost}" AC_MSG_CHECKING(for ld flags when building shared libraries) if test "${enable_shared}" = "yes"; then AC_MSG_RESULT([${SHARED_LDFLAGS}]) CFLAGS="${CFLAGS} ${PICFLAG}" else shared="no"; AC_MSG_RESULT(cannot build) fi LIBS="${clibs} ${LIBS}" AC_MSG_CHECKING(for required libraries) AC_MSG_RESULT([${clibs}]) AC_MSG_CHECKING(for architecture) ARCHITECTURE=`echo "${host_cpu}" | tr a-z A-Z` # i386 -> I386 AC_MSG_RESULT([${ARCHITECTURE}]) AC_MSG_CHECKING(for software type) SOFTWARE_TYPE="$thehost" SOFTWARE_VERSION="" AC_MSG_RESULT([${SOFTWARE_TYPE} / ${SOFTWARE_VERSION}]) ]) dnl dnl -------------------------------------------------------------- dnl Check whether the FILE structure has a field with the number of dnl characters left in the buffer. dnl AC_DEFUN(ECL_FILE_STRUCTURE,[ AC_SUBST(ECL_FILE_CNT) if test -z "${ECL_FILE_CNT}"; then ECL_FILE_CNT=0 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include ]], [[ FILE *f = fopen("conftestval","w"); if ((f)->_IO_read_end - (f)->_IO_read_ptr) return 1; ]])],[ECL_FILE_CNT=1],[]) AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include ]], [[ FILE *f = fopen("conftestval","w"); if ((f)->_r) return 1; ]])],[ECL_FILE_CNT=2],[]) AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include ]], [[ FILE *f = fopen("conftestval","w"); if ((f)->_cnt) return 1; ]])],[ECL_FILE_CNT=3],[]) fi ]) dnl --------------------------------------------------------------------- dnl Check availability of standard sized integer types of a given width. dnl On success, define the global variables ECL_INTx_T and ECL_UNITx_T to dnl hold the names of the corresponding standard C integer types. AC_DEFUN(ECL_CHECK_SIZED_INTEGER_TYPE,[ AC_TYPE_INT$1_T AC_TYPE_UINT$1_T if test "x$ac_cv_c_int$1_t" = xyes; then eval ECL_INT$1_T="int$1_t" eval ECL_UINT$1_T="uint$1_t" AC_DEFINE_UNQUOTED([ecl_int$1_t], [int$1_t], [ecl_int$1_t]) AC_DEFINE_UNQUOTED([ecl_uint$1_t], [uint$1_t], [ecl_uint$1_t]) fi]) dnl dnl -------------------------------------------------------------- dnl Check the existence of different integer types and that they dnl have the right size; dnl AC_DEFUN(ECL_INTEGER_TYPES,[ AC_SUBST(ECL_STDINT_HEADER) AC_CHECK_HEADER([stdint.h],[AC_DEFINE(HAVE_STDINT_H) ECL_STDINT_HEADER="#include "],[]) if test -z "${ECL_STDINT_HEADER}"; then AC_CHECK_HEADER([inttypes.h],[AC_DEFINE(HAVE_INTTYPES_H) ECL_STDINT_HEADER="#include "],[]) fi ECL_CHECK_SIZED_INTEGER_TYPE(8) ECL_CHECK_SIZED_INTEGER_TYPE(16) ECL_CHECK_SIZED_INTEGER_TYPE(32) ECL_CHECK_SIZED_INTEGER_TYPE(64) if test "${ECL_UINT32_T}${CL_FIXNUM_BITS}" = "32"; then ECL_UINT32_T="cl_index" ECL_INT32_T="cl_fixnum" fi if test "${ECL_UINT64_T}${CL_FIXNUM_BITS}" = "64"; then ECL_UINT64_T="cl_index" ECL_INT64_T="cl_fixnum" fi if test "${ECL_UINT16_T}${CL_FIXNUM_BITS}" = "16"; then ECL_UINT16_T=$ECL_UINT32_T ECL_INT16_T=$ECL_INT32_T fi if test "x${ECL_UINT8_T}" = "x" -o "x${ECL_UINT8_T}" = xno; then AC_MSG_ERROR(Can not build ECL without byte types) fi ]) dnl dnl -------------------------------------------------------------- dnl Check the direction to which the stack grows (for garbage dnl collection). dnl AC_DEFUN(ECL_STACK_DIRECTION,[ AC_MSG_CHECKING(whether stack growns downwards) if test -z "${ECL_STACK_DIR}" ; then AC_RUN_IFELSE([AC_LANG_SOURCE([[ #include #include ptrdiff_t f2(const char *d) { char c[2]; return c-d; } ptrdiff_t f1(const char *d) { char c[2]; return c+1-d; } typedef ptrdiff_t (*f_ptr)(const char *); f_ptr f[2] = { f1, f2 }; ptrdiff_t signo() { char d[1]; return f[rand() & 1](d); } int main() { if (signo() > 0) return 1; else return 0; } ]])],[ECL_STACK_DIR=down],[ECL_STACK_DIR=up],[]) fi case "${ECL_STACK_DIR}" in down|DOWN) AC_MSG_RESULT(yes); AC_DEFINE([ECL_DOWN_STACK], [1], [Stack grows downwards]) ;; up|UP) AC_MSG_RESULT(no) ;; *) AC_MSG_ERROR(Unable to determine stack growth direction) esac]) dnl dnl ------------------------------------------------------------ dnl Find out a setjmp() that does not save signals. It is called dnl in several architectures. AC_DEFUN(ECL_FIND_SETJMP,[ AC_SUBST(ECL_SETJMP) AC_SUBST(ECL_LONGJMP) AC_CHECK_FUNC(_longjmp, ECL_SETJMP="_setjmp";ECL_LONGJMP="_longjmp", ECL_SETJMP="setjmp";ECL_LONGJMP="longjmp")]) dnl dnl -------------------------------------------------------------- dnl Guess the right type and size for cl_fixnum. It must be large dnl enough that convertion back and forth to pointer implies no dnl loss of information. AC_DEFUN(ECL_FIXNUM_TYPE,[ AC_SUBST(CL_FIXNUM_TYPE) AC_SUBST(CL_FIXNUM_BITS) AC_SUBST(CL_FIXNUM_MAX) AC_SUBST(CL_FIXNUM_MIN) AC_SUBST(CL_INT_BITS) AC_SUBST(CL_LONG_BITS) AC_MSG_CHECKING(appropiate type for fixnums) if test -z "${CL_FIXNUM_TYPE}" ; then AC_RUN_IFELSE([AC_LANG_SOURCE([[#include int main() { const char *int_type; int bits; FILE *f=fopen("conftestval", "w"); if (!f) exit(1); if (sizeof(int) >= sizeof(void*)) { unsigned int t = 1; signed int l = 0; int_type="int"; for (bits=1; ((t << 1) >> 1) == t; bits++, t <<= 1); l = (~l) << (bits - 3); #if 1 fprintf(f,"CL_FIXNUM_MIN='%d';",l); fprintf(f,"CL_FIXNUM_MAX='%d';",-(l+1)); #else l++; fprintf(f,"CL_FIXNUM_MIN='%d';",l); fprintf(f,"CL_FIXNUM_MAX='%d';",-l); #endif } else if (sizeof(long) >= sizeof(void*)) { unsigned long int t = 1; signed long int l = 0; int_type="long int"; for (bits=1; ((t << 1) >> 1) == t; bits++, t <<= 1); l = (~l) << (bits - 3); #if 1 fprintf(f,"CL_FIXNUM_MIN='%ldL';",l); fprintf(f,"CL_FIXNUM_MAX='%ldL';",-(l+1)); #else l++; fprintf(f,"CL_FIXNUM_MIN='%ldL';",l); fprintf(f,"CL_FIXNUM_MAX='%ldL';",-l); #endif #ifdef ECL_LONG_LONG_BITS } else if (sizeof(long long) >= sizeof(void*)) { unsigned long long int t = 1; signed long long int l = 0; int_type="long long"; for (bits=1; ((t << 1) >> 1) == t; bits++, t <<= 1); l = (~l) << (bits - 3); # if 1 fprintf(f,"CL_FIXNUM_MIN='%lldLL';",l); fprintf(f,"CL_FIXNUM_MAX='%lldLL';",-(l+1)); # else l++; fprintf(f,"CL_FIXNUM_MIN='%lldLL';",l); fprintf(f,"CL_FIXNUM_MAX='%lldLL';",-l); # endif #endif } else { exit(1); } fprintf(f,"CL_FIXNUM_TYPE='%s';",int_type); fprintf(f,"CL_FIXNUM_BITS='%d';",bits); { unsigned int x = 1; for (bits = 0; x; bits++) { x <<= 1; } fprintf(f,"CL_INT_BITS='%d';",bits); } { unsigned long x = 1; for (bits = 0; x; bits++) { x <<= 1; } fprintf(f,"CL_LONG_BITS='%d'",bits); } exit(0); }]])],[eval "`cat conftestval`"],[],[]) fi if test -z "${CL_FIXNUM_TYPE}" ; then AC_MSG_ERROR(There is no appropiate integer type for the cl_fixnum type) fi AC_MSG_RESULT([${CL_FIXNUM_TYPE}])]) dnl dnl ------------------------------------------------------------ dnl Find out what is written for every '\n' character, when dnl opening a text file. dnl AC_DEFUN(ECL_LINEFEED_MODE,[ AC_MSG_CHECKING(character sequence for end of line) if test -z "${ECL_NEWLINE}" ; then AC_RUN_IFELSE([AC_LANG_SOURCE([[#include int main() { FILE *f = fopen("conftestval","w"); int c1, c2; char *output; if (f == NULL) exit(1); fprintf(f, "\n"); fclose(f); f = fopen("conftestval","rb"); if (f == NULL) exit(1); c1 = fgetc(f); c2 = fgetc(f); fclose(f); f = fopen("conftestval","w"); if (f == NULL) exit(1); if (c1 == '\r') if (c2 == EOF) output="CR"; else output="CRLF"; else output="LF"; fclose(f); f = fopen("conftestval","w"); if (f == NULL) exit(1); fprintf(f, output); fclose(f); exit(0); } ]])],[ECL_NEWLINE=`cat conftestval`],[],[]) fi case "${ECL_NEWLINE}" in LF) AC_MSG_RESULT(lf) ;; CR) AC_MSG_RESULT(cr); AC_DEFINE([ECL_NEWLINE_IS_CR], [1], [Define if your newline is CR]) ;; CRLF) AC_MSG_RESULT(cr+lf); AC_DEFINE([ECL_NEWLINE_IS_CRLF], [1], [Define if your newline is CRLF]) ;; *) AC_MSG_ERROR(Unable to determine linefeed mode) ;; esac ]) dnl dnl ------------------------------------------------------------ dnl Find out which program we can use to install INFO files dnl AC_DEFUN(ECL_INSTALL_INFO,[ AC_SUBST(INSTALL_INFO) AC_PATH_PROG(INSTALL_INFO, install-info, [/sbin/install-info], [$PATH:/usr/bin:/usr/sbin:/usr/etc:/usr/libexec]) ]) dnl dnl ------------------------------------------------------------ dnl Use the configuration scripts in the GMP library for dnl configuring ECL in a compatible way. dnl AC_DEFUN(ECL_GMP_BASED_CONFIG,[ AC_MSG_CHECKING([Using the GMP library to guess good compiler/linker flags]) if test ! -f gmp/config.status; then AC_MSG_ERROR([Cannot find GMP's configuration file. Aborting]) fi GMP_CFLAGS=`grep '^s,@CFLAGS@' gmp/config.status| sed 's&s,@CFLAGS@,\(.*\),;t t&\1&'` GMP_LDFLAGS=`grep '^s,@GMP_LDFLAGS@' gmp/config.status| sed 's&s,@GMP_LDFLAGS@,\(.*\),;t t&\1&'`; # Notice that GMP_LDFLAGS is designed to be passed to libtool, and therefore # some options could be prefixed by -Wc, which means "flag for the compiler". LDFLAGS=`echo ${LDFLAGS} ${GMP_LDFLAGS} | sed 's%-Wc,%%g'` CFLAGS=`echo ${CFLAGS} ${GMP_CFLAGS} | sed 's%-Wc,%%g'` GMP_CFLAGS="" GMP_LDFLAGS="" #host=`grep '^s,@host@' config.status | sed 's&s,@host@,\(.*\),;t t&\1&'` AC_MSG_CHECKING([C/C++ compiler flags]) AC_MSG_RESULT([${CFLAGS}]) AC_MSG_CHECKING([Linker flags]) AC_MSG_RESULT([${LDFLAGS}]) ]) dnl -------------------------------------------------------------- dnl Provides a test for the existance of the __thread declaration and dnl defines WITH___THREAD if it is found AC_DEFUN([ECL___THREAD],[ AC_CACHE_CHECK(for __thread local data, ac_cv_ecl___thread, AC_COMPILE_IFELSE([AC_LANG_PROGRAM(,[[static __thread void *data;]])], ac_cv_ecl___thread=yes, ac_cv_ecl___thread=no)) dnl We deactivate this test because it seems to slow down ECL A LOT!!! ]) dnl -------------------------------------------------------------- dnl Determine whether GCC supports backtraces dnl AC_DEFUN([ECL_GCC_BACKTRACE],[ if test "x${cross_compiling}" != "xyes"; then AC_RUN_IFELSE( [AC_LANG_SOURCE([[ void *foo() { return __builtin_return_address(1); } int main() { return (foo() == 0); }]])], [AC_DEFINE([HAVE___BUILTIN_RETURN_ADDRESS], [], [HAVE___BUILTIN_RETURN_ADDRESS])], []) fi ]) dnl ---------------------------------------------------------------------- dnl Choose the type of code to detect floating point exceptions and dnl raise them. dnl AC_DEFUN([ECL_FPE_MODEL], [AC_MSG_CHECKING([for code to detect FP exceptions]) case "${host_cpu}" in i686 | i586 | pentium* | athlon* ) ECL_FPE_CODE="arch/fpe_x86.c" AC_MSG_RESULT([x86]) ;; x86_64* ) ECL_FPE_CODE="arch/fpe_x86.c" AC_MSG_RESULT([x86_64]) ;; *) ECL_FPE_CODE="arch/fpe_none.c" AC_MSG_RESULT([not available]) ;; esac AC_SUBST(ECL_FPE_CODE) ]) dnl ---------------------------------------------------------------------- dnl Decide whether ECL should export SSE intrinsics dnl AC_DEFUN([ECL_SSE],[ if test "x$with_sse" = xyes; then AC_MSG_CHECKING([for SSE intrinsics]) AC_LINK_IFELSE([AC_LANG_PROGRAM([[ #include #include ]],[[__m128 value; _mm_getcsr();]])],[sse_included=yes],[sse_included=no]) if test "$sse_included" = "no"; then OLD_CFLAGS="$CFLAGS" CFLAGS="$CFLAGS -msse2" AC_LINK_IFELSE([AC_LANG_PROGRAM([[ #include #include ]],[[__m128 value; _mm_getcsr();]])],[sse_included=yes],[sse_included=no]) if test "$sse_included" = "no"; then CFLAGS="$OLD_CFLAGS" with_sse=no fi fi if test "x$with_sse" = xyes; then AC_DEFINE([ECL_SSE2], [], [ECL_SSE2]) AC_MSG_RESULT([yes]) else AC_MSG_RESULT([no]) fi fi ]) dnl ---------------------------------------------------------------------- dnl Check whether we have POSIX read/write locks are available AC_DEFUN([ECL_POSIX_RWLOCK],[ AC_CHECK_FUNC( [pthread_rwlock_init], [ AC_DEFINE([ECL_RWLOCK], [], [ECL_RWLOCK]) AC_DEFINE([HAVE_POSIX_RWLOCK], [], [HAVE_POSIX_RWLOCK]) ], []) THREAD_OBJ="$THREAD_OBJ threads/rwlock" ]) dnl ---------------------------------------------------------------------- dnl Check "char **environ" is available AC_DEFUN([ECL_POSIX_ENVIRON],[ AC_MSG_CHECKING(working environ) if test -z "$ECL_WORKING_ENVIRON"; then AC_RUN_IFELSE([AC_LANG_SOURCE([[ #include extern char **environ; int main() { if (environ) exit(0); exit(1); }]])],[ECL_WORKING_ENVIRON=yes],[ECL_WORKING_ENVIRON=no],[]) fi AC_MSG_RESULT([$ECL_WORKING_ENVIRON]) if test $ECL_WORKING_ENVIRON = yes ; then AC_DEFINE([HAVE_ENVIRON], [], [HAVE_ENVIRON]) fi ]) dnl ---------------------------------------------------------------------- dnl Configure libatomic-ops dnl AC_DEFUN([ECL_LIBATOMIC_OPS],[ case "${enable_libatomic}" in auto|system|included) ;; *) AC_MSG_ERROR( [Invalid value of --enable-libatomic: ${enable_libatomic}] );; esac if test "x${enable_threads}" != "xno"; then AC_CHECK_HEADER([atomic_ops.h],[system_libatomic=yes],[system_libatomic=no],[]) AC_MSG_CHECKING( [libatomic-ops version] ) if test "${enable_libatomic}" = auto; then if test "${system_libatomic}" = yes; then enable_libatomic=system else enable_libatomic=included fi fi if test "${enable_libatomic}" = system; then if test "${system_libatomic}" = no; then AC_MSG_ERROR( [Cannot find libatomic-ops in the system] ) enable_libatomic=included fi fi AC_MSG_RESULT( [${enable_libatomic}] ) if test "${enable_libatomic}" = included; then test -d atomic || mkdir atomic (destdir=`${PWDCMD}`; cd atomic && CC="${CC} ${PICFLAG}" \ $srcdir/${ECL_GC_DIR}/libatomic*/configure --disable-shared \ --prefix=${destdir} infodir=${destdir}/doc \ --includedir=${destdir}/ecl --with-pic \ --libdir=${destdir} --build=${build_alias} --host=${host_alias} \ CFLAGS="$CFLAGS" LDFLAGS="$LDFLAGS" CPPFLAGS="$CPPFLAGS" CC="${CC} \ ${PICFLAG}") SUBDIRS="${SUBDIRS} atomic" if test "${enable_shared}" = "no"; then LIBRARIES="${LIBRARIES} ${LIBPREFIX}eclatomic.${LIBEXT}" fi AC_DEFINE([ECL_LIBATOMIC_OPS_H], [], [ECL_LIBATOMIC_OPS_H]) CORE_LIBS="-leclatomic ${CORE_LIBS}" else CORE_LIBS="-latomic_ops ${CORE_LIBS}" fi fi ]) dnl ---------------------------------------------------------------------- dnl Configure included Boehm GC if needed AC_DEFUN([ECL_BOEHM_GC],[ AC_SUBST(ECL_BOEHM_GC_HEADER) case "${enable_boehm}" in yes) enable_boehm=auto;; auto|system|included) ;; *) AC_MSG_ERROR( [Invalid value of --enable-boehm: ${enable_boehm}] );; esac if test "${enable_boehm}" = auto -o "${enable_boehm}" = system; then dnl dnl Try first with the prebuilt versions, if installed and accessible dnl system_boehm=yes if test "${enable_threads}" = no; then AC_CHECK_LIB( [gc], [GC_malloc], [], [system_boehm="no"] ) else AC_CHECK_LIB( [gc], [GC_get_thr_restart_signal], [], [system_boehm="no"] ) AC_CHECK_LIB( [gc], [GC_register_my_thread], [], [system_boehm="no"] ) fi if test "${system_boehm}" = yes; then AC_CHECK_HEADER([gc.h],[ECL_BOEHM_GC_HEADER='gc.h'],[],[]) if test -z "$ECL_BOEHM_GC_HEADER"; then AC_CHECK_HEADER([gc/gc.h],[ECL_BOEHM_GC_HEADER='gc/gc.h'], [system_boehm=no],[]) fi fi if test "${system_boehm}" = "yes"; then AC_CHECK_LIB( [gc], [GC_set_start_callback], [AC_DEFINE([HAVE_GC_SET_START_CALLBACK], [], [HAVE_GC_SET_START_CALLBACK])], [] ) else AC_DEFINE([HAVE_GC_SET_START_CALLBACK], [], [HAVE_GC_SET_START_CALLBACK]) fi AC_MSG_CHECKING( [whether we can use the existing Boehm-Weiser library] ) AC_MSG_RESULT( [${system_boehm}] ) if test "${system_boehm}" = "no"; then if test "${enable_boehm}" = "auto" -o "${enable_boehm}" = "included"; then enable_boehm="included"; else AC_MSG_ERROR([System Boehm GC library requested but not found.]) fi else FASL_LIBS="${FASL_LIBS} -lgc" EXTRA_OBJS="${EXTRA_OBJS} alloc_2.${OBJEXT}" AC_DEFINE(GBC_BOEHM, [1], [Use Boehm's garbage collector]) fi fi if test "${enable_boehm}" = "included"; then dnl dnl Try here with the version shipped with ECL. Note that we have to use dnl the same compiler flags and that we will not export this library: it dnl is installed in the build directory. dnl AC_MSG_NOTICE([Configuring included Boehm GC library:]) test -d gc && rm -rf gc currentdir=`${PWDCMD}` cd $srcdir/${ECL_GC_DIR}; if test -d configure; then autoreconf -vif automake --add-missing fi; cd $currentdir; if mkdir gc; then if (destdir=`${PWDCMD}`; cd gc; \ $srcdir/${ECL_GC_DIR}/configure --disable-shared --prefix=${destdir} \ --includedir=${destdir}/ecl/ --libdir=${destdir} \ --build=${build_alias} --host=${host_alias} --enable-large-config \ CC="${CC} ${PICFLAG}" \ CFLAGS="$CFLAGS" LDFLAGS="$LDFLAGS" \ CPPFLAGS="$CPPFLAGS -I${destdir}/ecl" \ ${boehm_configure_flags}); then ECL_BOEHM_GC_HEADER='ecl/gc/gc.h' SUBDIRS="${SUBDIRS} gc" CORE_LIBS="-leclgc ${CORE_LIBS}" EXTRA_OBJS="${EXTRA_OBJS} alloc_2.${OBJEXT}" if test "${enable_shared}" = "no"; then LIBRARIES="${LIBRARIES} ${LIBPREFIX}eclgc.${LIBEXT}" fi AC_DEFINE(GBC_BOEHM, [0], [Use Boehm's garbage collector]) fi fi if test -z "${ECL_BOEHM_GC_HEADER}"; then AC_MSG_ERROR([Unable to configure Boehm-Weiser GC]) fi fi if test "${enable_gengc}" != "no" ; then AC_DEFINE([GBC_BOEHM_GENGC], [], [GBC_BOEHM_GENGC]) fi AC_MSG_CHECKING([if we use Boehm-Demers-Weiser precise garbage collector]); if test "${enable_precisegc}" != "no" ; then AC_DEFINE([GBC_BOEHM_PRECISE], [], [GBC_BOEHM_PRECISE]) AC_MSG_RESULT([yes]) else AC_MSG_RESULT([no]) fi ]) dnl ---------------------------------------------------------------------- dnl Configure included Boehm GC if needed AC_DEFUN([ECL_LIBFFI],[ AC_SUBST(ECL_LIBFFI_HEADER) case "${enable_libffi}" in yes) enable_libffi=auto;; no|auto|system|included) ;; *) AC_MSG_ERROR( [Invalid value of --enable-dffi: ${enable_libffi}] );; esac if test "${enable_libffi}" = auto -o "${enable_libffi}" = system; then dnl dnl Try first with the prebuilt versions, if installed and accessible dnl AC_CHECK_LIB( ffi, ffi_closure_alloc, [system_libffi=yes], [system_libffi=no] ) if test "${system_libffi}" = yes; then AC_CHECK_HEADER([ffi/ffi.h],[ECL_LIBFFI_HEADER='ffi/ffi.h'],[],[]) if test -z "$ECL_LIBFFI_HEADER"; then AC_CHECK_HEADER([ffi.h],[ECL_LIBFFI_HEADER='ffi.h'],[system_libffi=no],[]) fi fi AC_MSG_CHECKING( [whether we can use the existing libffi library] ) AC_MSG_RESULT( [${system_libffi}] ) if test "${system_libffi}" = "no"; then if test "${enable_libffi}" = "auto"; then enable_libffi="included"; else AC_MSG_ERROR([System libffi library requested but not found.]) fi else FASL_LIBS="${FASL_LIBS} -lffi" fi fi if test "${enable_libffi}" = "included"; then dnl dnl Try here with the version shipped with ECL. Note that we have to use dnl the same compiler flags and that we will not export this library: it dnl is installed in the build directory. dnl AC_MSG_NOTICE([Configuring included libffi library:]) test -d libffi && rm -rf libffi if mkdir libffi; then if (destdir=`${PWDCMD}`; cd libffi; \ $srcdir/libffi/configure --disable-shared --prefix=${destdir} \ --includedir=${destdir}/ecl/ --libdir=${destdir} --build=${build_alias} \ --host=${host_alias} \ CC="${CC} ${PICFLAG}" CFLAGS="$CFLAGS" \ LDFLAGS="$LDFLAGS" CPPFLAGS="$CPPFLAGS"); then ECL_LIBFFI_HEADER='ecl/ffi.h' SUBDIRS="${SUBDIRS} libffi" CORE_LIBS="-leclffi ${CORE_LIBS}" EXTRA_OBJS="${EXTRA_OBJS} alloc_2.${OBJEXT}" if test "${enable_shared}" = "no"; then LIBRARIES="${LIBRARIES} ${LIBPREFIX}eclffi.${LIBEXT}" fi fi fi fi if test -z "${ECL_LIBFFI_HEADER}"; then AC_MSG_WARN([Unable to configure or find libffi library; disabling dynamic FFI]) else AC_DEFINE([HAVE_LIBFFI], [], [HAVE_LIBFFI]) fi ]) ecl-16.1.2/src/bare.lsp.in000066400000000000000000000156771266352375300152250ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;; @configure_input@ ;;; ;;; This file can be loaded either in ECL_MIN or in the final executable ;;; ECL. In both cases, it ensures that we have a working Common-Lisp ;;; environment (either interpreted, as in ECL_MIN, or compiled, as in ECL), ;;; that the compiler is loaded, that we use the headers in this directory, ;;; etc. ;;; ;;; * By redefining "SYS:" ECL will be able to ;;; find headers and libraries in the build directory. ;;; (princ " ;;; ;;; Welcome to bare.lsp. Let's bring this instance up! ;;;") (sys:*make-constant '+ecl-optimization-settings+ '((optimize (safety 2) (speed 1) (debug 1) (space 1)) (ext:check-arguments-type nil))) (sys:*make-constant '+ecl-unsafe-declarations+ '(optimize (safety 0) (speed 3) (debug 0) (space 0))) (sys:*make-constant '+ecl-safe-declarations+ '(optimize (safety 2) (speed 1) (debug 1) (space 1))) (si::pathname-translations "SRC" `(("**;*.*.*" "@true_srcdir@/**/*.*"))) (si::pathname-translations "EXT" `(("**;*.*.*" "@true_srcdir@/../contrib/**/*.*"))) (si::pathname-translations "BUILD" `(("**;*.*.*" "@true_builddir@/**/*.*"))) (si::pathname-translations "SYS" '(("**;*.*.*" "@true_builddir@/**/*.*"))) ;;; ;;; * Set ourselves in the 'SYSTEM package ;;; (setq *package* (find-package "SYSTEM")) (setq si::*keep-definitions* nil) ;;; ;;; * Create bogus commit version number ;;; (setq si::+commit-id+ "UNKNOWN") ;;; ;;; * Load Common-Lisp base library ;;; (princ " ;;; ;;; About to load lsp/load.lsp ;;; ") (if (or (member "ECL-MIN" *features* :test #'string-equal) (member "CROSS" *features* :test #'string-equal)) (load "lsp/load.lsp" :verbose nil)) (defun si::process-command-args () ) ;;; ;;; * Load PCL-based Common-Lisp Object System ;;; (setf sys::*gc-verbose* nil) #+(or ecl-min cross) (progn (terpri) (princ ";;; Loading clos/load.lsp") (load "clos/load.lsp" :verbose nil)) #+cmu-format (progn (terpri) (princ ";;; Loading lsp/format.lsp") (load "src:lsp;format.lsp" :verbose nil)) ;;; ;;; * Load the compiler. ;;; ;; Make sure compiler sees what it should see. #-:wants-dlopen (setq *features* (delete :dlopen *features*)) #+:wants-dlopen (push :dlopen *features*) (terpri) (princ #+(or cross ecl-min) ";;; About to load cmp/load.lsp" #-(or cross ecl-min) ";;; About to load cmp.so") (load #+(or cross ecl-min) "@ECL_CMPDIR@/load.lsp" #-(or cross ecl-min) "cmp.so") ;;; ;;; * Change the place where temporary files go to ;;; (si::pathname-translations "TMP" '(("**;*.*.*" "@true_builddir@/**/*.*"))) ;;; ;;; * Remove documentation from compiled files ;;; (setq si::*keep-documentation* nil) ;;; ;;; * Timed compilation facility. ;;; (defun compile-if-old (destdir sources &rest options) (ensure-directories-exist destdir :mode #o0777) (mapcar #'(lambda (source) (let ((object (merge-pathnames destdir (compile-file-pathname source :type :object)))) (unless (and (probe-file object) (>= (file-write-date object) (file-write-date source))) (format t "~&(compile-file ~S :output-file ~S~{ ~S~})~%" source object options) (apply #'compile-file source :output-file object options)) object)) sources)) (defvar *module-symbols* nil) (defvar *module-files* nil) (defun build-fake-module (name lisp-files) (let* ((output (make-pathname :type "fasc" :defaults name)) (files '())) (unwind-protect (let ((ext:*source-location* nil)) (loop for i in lisp-files do (push (open i :direction :input) files)) (setf files (nreverse files)) (let ((joined (apply #'make-concatenated-stream files))) (ext::bc-compile-file joined :output-file output))) (mapc #'close files)) output)) (make-package "ASDF") (defun build-fake-asdf (name static-library compiled-filename &key depends-on) (let ((path (make-pathname :name name :type "asd")) (compiled (make-pathname :host "SYS" :name (pathname-name compiled-filename) :type (pathname-type compiled-filename))) (library (make-pathname :host "SYS" :name (pathname-name static-library) :type (pathname-type static-library)))) (with-open-file (*standard-output* path :direction :output :if-exists :supersede :if-does-not-exist :create) (format t " (defsystem ~S :class asdf::prebuilt-system :lib ~S :depends-on ~S :components ((:compiled-file ~S :pathname ~S)))" name library depends-on (string name) compiled)) path)) (defun build-module (name sources &key additional-files depends-on (builtin nil) (dir "build:") ((:prefix si::*init-function-prefix*) "EXT")) (mapc #'proclaim +ecl-optimization-settings+) (let* ((name (string-downcase name))) (when additional-files (setf *module-files* (append additional-files *module-files*))) (let* ((objects (compile-if-old dir sources :system-p t :c-file t :data-file t :h-file t)) (compiled-file-name (string name)) (static-library (c::build-static-library name :lisp-files objects))) (push static-library *module-files*) (when builtin (push (intern name) *module-symbols*)) #-:wants-dlopen (push (build-fake-module name sources) *module-files*) #+:wants-dlopen (push (setf compiled-file-name (c::build-fasl name :lisp-files objects)) *module-files*) (push (if (equalp name "asdf") (build-fake-asdf "prebuilt-asdf" static-library compiled-file-name :depends-on '("cmp")) (build-fake-asdf name static-library compiled-file-name :depends-on depends-on)) *module-files*) ))) ;;; ;;; * Update version number now that SI:SYSTEM is available ;;; (let ((commit-id (probe-file "@true_srcdir@/../.git/logs/HEAD"))) (when commit-id (let ((last nil)) (with-open-file (file commit-id :direction :input :element-type :default :external-format :default) (loop for l = (read-line file nil nil nil) while l do (setf last l))) (when last (handler-case (let* ((start (position #\Space last))) (when start (let ((end (position #\Space last :start (incf start)))) (when end (setq si::+commit-id+ (subseq last start end)))))) (serious-condition ())))))) ;;; ;;; * Go back to build directory to start compiling ;;; #+ecl-min (setq *features* (cons :stage1 (remove :ecl-min *features*))) (terpri) (princ ";;; ;;; Now we are in shape to do something useful. ;;; End of bare.lsp") (terpri) (setf c::*compiler-break-enable* t) ecl-16.1.2/src/bdwgc/000077500000000000000000000000001266352375300142355ustar00rootroot00000000000000ecl-16.1.2/src/bdwgc/.gitattributes000066400000000000000000000005411266352375300171300ustar00rootroot00000000000000# Git repo attributes. # Ensure all text files have normalized (LF) line endings in the repository. * text=auto # These files should use CR/LF line ending: /BCC_MAKEFILE -text /digimars.mak -text # Note: "core.eol" configuration variable controls which line endings to use # for the normalized files in the working directory (the default is native). ecl-16.1.2/src/bdwgc/.gitignore000066400000000000000000000032401266352375300162240ustar00rootroot00000000000000# Ignored files in bdwgc Git repo. # Binary files (in root dir, cord, tests): *.dll *.exe *.gcda *.gch *.gcno *.la *.lib *.lo *.o *.obj .dirstamp /*.gc.log /*_bench.log /*_bench.trs /*test.log /*test.trs /.libs/ /Makefile /add_gc_prefix /base_lib /bdw-gc.pc /c++ /config.cache /config.log /config.status /cord/cordtest /cord/de /cord/de_win.rbj /cord/de_win.res /cord/tests/de_win.res /cordtest /core /de /disclaim_bench /disclaim_test /gc-* /gc.a /gc.log /gcname /gctest /hugetest /if_mach /if_not_there /initsecondarythread_test /leaktest /libtool /middletest /realloc_test /setjmp_test /smashtest /staticrootstest /subthreadcreate_test /test-suite.log /test_cpp /test_cpp.log /test_cpp.trs /threadkey_test /threadleaktest /threadlibs /tracetest # Config, dependency and stamp files generated by configure: .deps/ config.h config.h.in~ stamp-h1 # External library (without trailing slash to allow symlinks): # /libatomic_ops* # /pthreads-w32* # These files are generated by autoreconf: # /Makefile.in # /aclocal.m4 # /autom4te.cache/ # /compile # /config.guess # /config.sub # /configure # /depcomp # /include/config.h.in # /install-sh # /ltmain.sh # /m4/libtool.m4 # /m4/ltoptions.m4 # /m4/ltsugar.m4 # /m4/ltversion.m4 # /m4/lt~obsolete.m4 # /missing # /mkinstalldirs # /test-driver # These files are generated by CMake: /*.vcxproj /*.vcxproj.filters /CMakeCache.txt /CMakeFiles/ /cmake_install.cmake /gc.sln /tests/*.vcxproj /tests/*.vcxproj.filters /tests/CMakeFiles/ /tests/Makefile /tests/cmake_install.cmake # Rarely generated files (mostly by some Win/DOS compilers): /*.bsc /*.csm /*.err /*.exp /*.lb1 /*.lnk /*.map /*.out /*.pdb /*.rbj /*.res /*.sbr /*.stackdump /*.sym /*.tmp ecl-16.1.2/src/bdwgc/AUTHORS000066400000000000000000000317771266352375300153240ustar00rootroot00000000000000This is an attempt to acknowledge contributions to the garbage collector. Early contributions also mentioned (duplicated) in ChangeLog file; details of later ones should be in "git log". HISTORY - Early versions of this collector were developed as a part of research projects supported in part by the National Science Foundation and the Defense Advance Research Projects Agency. The garbage collector originated as part of the run-time system for the Russell programming language implementation. The first version of the garbage collector was written primarily by Alan Demers. It was then refined and mostly rewritten, primarily by Hans-J. Boehm, at Cornell U., the University of Washington, Rice University (where it was first used for C and assembly code), Xerox PARC, SGI, and HP Labs. However, significant contributions have also been made by many others. Other contributors (my apologies for any omissions): Adam Megacz Adnan Ali Adrian Bunk Akira Tagoh Alain Novak Alan Dosser Alan J. Demers Aleksey Demakov Alexander Belchenko Alexander Gavrilov Alexander Herz Alexandr Petrosian Alexandr Shadchin Alexandre Oliva Alistair G. Crooks Allan Hsu Andre Leiradella Andreas Jaeger Andreas Tobler Andrei Polushin Andrej Cedilnik Andrew Begel Andrew Gray Andrew Haley Andrew Horton Andrew McKinlay Andrew Pinski Andrew Stitcher Andrew Stone Andy Wingo Anselm Baird-Smith Anthony Green Antoine de Maricourt Ari Huttunen Arrigo Triulzi Ashley Bone Assar Westerlund Barry DeFreese Baruch Siach Ben A. Mesander Ben Cottrell Ben Hutchings Ben Maurer Benjamin Lerman Bernd Edlinger Bernie Solomon Bill Janssen Bo Thorsen Bradley D. LaRonde Bradley Smith Brent Benson Brian Alliet Brian Beuning Brian Burton Brian D. Carlstrom Brian F. Dennis Brian Lewis Bruce Hoult Bruce Mitchener Bruno Haible Bryce McKinlay Burkhard Linke Cesar Eduardo Barros Charles Fiterman Charles Mills Chris Dodd Chris Lingard Christian Joensson Christian Limpach Christian Thalinger Christoffe Raffali Clay Spence Colin LeMahieu Craig McDaniel Dai Sato Dan Bonachea Dan Fandrich Dan Sullivan Daniel R. Grayson Danny Smith Darrell Schiebel Dave Barrett Dave Detlefs Dave Korn Dave Love David Ayers David Brownlee David Butenhof David Chase David Daney David Grove David Leonard David Miller David Mossberger David Peroutka David Pickens David Stes Davide Angelocola Dick Porter Dietmar Planitzer Dimitris Vyzovitis Dimitry Andric Djamel Magri Doug Kaufman Doug Moen Douglas Steel Elijah Taylor Elvenlord Elrond Emmanual Stumpf Eric Benson Eric Holk Fabian Thylman Fergus Henderson Franklin Chen Fred Gilham Fred Stearns Friedrich Dominicus Gary Leavens Geoff Norton George Talbot Gerard A Allan Glauco Masotti Grzegorz Jakacki Gustavo Rodriguez-Rivera H.J. Lu Hannes Mehnert Hanno Boeck Hans Boehm Hans-Peter Nilsson Henning Makholm Henrik Theiling Hironori Sakamoto Hiroshi Kawashima Hubert Garavel Iain Sandoe Ian Piumarta Ian Searle Igor Khavkine Ivan Demakov Ivan Maidanski Jaap Boender Jack Andrews Jacob Navia Jakub Jelinek James Clark James Dominy Jan Alexander Steffens Jan Wielemaker Jani Kajala Jean-Baptiste Nivois Jean-Claude Beaudoin Jean-Daniel Fekete Jeff Sturm Jeffrey Hsu Jeffrey Mark Siskind Jeremy Fitzhardinge Jesper Peterson Jesse Hull Jesse Jones Jesse Rosenstock Ji-Yong Chung Jie Liu Jim Marshall Jim Meyering Joerg Sonnenberger Johannes Schmidt Johannes Totz John Bowman John Clements John Ellis John Merryweather Cooper Jon Moore Jonathan Bachrach Jonathan Chambers Jonathan Clark Jonathan Pryor Juan Jose Garcia-Ripoll Kai Tietz Kaz Kojima Kazu Hirata Kazuhiro Inaoka Kenjiro Taura Kenneth Schalk Kevin Kenny Kevin Tew Kevin Warne Kjetil S. Matheussen Klaus Treichel Knut Tvedten Krister Walfridsson Kristian Kristensen Kumar Srikantan Kurt Miller Lars Farm Laurent Morichetti Linas Vepstas Loren J. Rittle Louis Zhuang Ludovic Courtes Maarten Thibaut Manuel A. Fernandez Montecelo Manuel Serrano Marc Recht Marco Maggi Marcos Dione Marcus Herbert Margaret Fleck Mark Boulter Mark Mitchell Mark Reichert Mark Sibly Mark Weiser Martin Hirzel Martin Tauchmann Matt Austern Matthew Flatt Matthias Andree Matthias Drochner Maurizio Vairani Melissa O'Neill Michael Arnoldus Michael Smith Michael Spertus Michel Schinz Miguel de Icaza Mike Gran Mike McGaughey Mike Stump Mitch Harris Mohan Embar Nathanael Nerode Neale Ferguson Neil Sharman Nicolas Cannasse Niibe Yutaka Niklas Therning Noah Lavine Nobuyuki Hikichi Oliver Kurth Ondrej Bilka Paolo Molaro Parag Patel Patrick Bridges Patrick C. Beard Patrick Doyle Paul Brook Paul Graham Paul Nash Per Bothner Peter Bigot Peter Chubb Peter Colson Peter Housel Peter Monks Peter Ross Peter Seebach Peter Wang Petr Krajca Petr Salinger Petter Urkedal Philip Brown Philipp Tomsich Philippe Queinnec Phillip Musumeci Phong Vo Pierre de Rop Pontus Rydin Radek Polak Rainer Orth Ranjit Mathew Rauli Ruohonen Regis Cridlig Reimer Behrends Renaud Blanch Rene Girard Rex Dieter Reza Shahidi Richard Earnshaw Richard Henderson Richard Sandiford Rob Haack Robert Brazile Roger Sayle Roland McGrath Roman Hodek Romano Paolo Tenca Rutger Ovidius Ryan Murray Salvador Eduardo Tropea Samuel Thibault Scott Ananian Scott Schwartz Shawn Wagner Shiro Kawai Simon Gornall Simon Posnjak Slava Sysoltsev Stefan Ring Stefano Rivera Sugioka Toshinobu Suzuki Toshiya Sven Hartrumpf Sven Verdoolaege Takis Psarogiannakopoulos Tatsuya Bizenn Thiemo Seufer Thomas Funke Thomas Klausner Thomas Maier Thorsten Glaser Tilman Vogel Tim Bingham Timothy N. Newsham Tom Tromey Tommaso Tagliapietra Toralf Foerster Toshio Endo Tsugutomo Enami Tum Nguyen Tyson Dowd Uchiyama Yasushi Ulrich Drepper Ulrich Weigand Uros Bizjak Vernon Lee Victor Ivrii Vitaly Magerya Vladimir Tsichevski Walter Bright Walter Underwood Wilson Ho Wink Saville Xi Wang Xiaokun Zhu Yann Dirson Yannis Bres Yusuke Suzuki Yvan Roux Zach Saw Zhiying Chen Zhong Shao Zoltan Varga ecl-16.1.2/src/bdwgc/BCC_MAKEFILE000066400000000000000000000045761266352375300160200ustar00rootroot00000000000000# Makefile for Borland C++ 5.5 on NT # If you have the Borland assembler, remove "-DUSE_GENERIC" # bc= c:\Borland\BCC55 bcbin= $(bc)\bin bclib= $(bc)\lib bcinclude= $(bc)\include gcinclude1 = $(bc)\gc6.2\include gcinclude2 = $(bc)\gc6.2\cord cc= $(bcbin)\bcc32 rc= $(bcbin)\brc32 lib= $(bcbin)\tlib link= $(bcbin)\ilink32 cflags= -O2 -R -v- -vi -H -H=gc.csm -I$(bcinclude);$(gcinclude1);$(gcinclude2) -L$(bclib) \ -w-pro -w-aus -w-par -w-ccc -w-rch -a4 defines= -DALL_INTERIOR_POINTERS -DUSE_GENERIC -DNO_GETENV -DJAVA_FINALIZATION -DGC_OPERATOR_NEW_ARRAY .c.obj: $(cc) @&&| $(cdebug) $(cflags) $(cvars) $(defines) -o$* -c $*.c | .cpp.obj: $(cc) @&&| $(cdebug) $(cflags) $(cvars) $(defines) -o$* -c $*.cpp | .rc.res: $(rc) -i$(bcinclude) -r -fo$* $*.rc XXXOBJS= XXXalloc.obj XXXreclaim.obj XXXallchblk.obj XXXmisc.obj \ XXXmach_dep.obj XXXos_dep.obj XXXmark_rts.obj XXXheaders.obj XXXmark.obj \ XXXobj_map.obj XXXblacklst.obj XXXfinalize.obj XXXnew_hblk.obj \ XXXdbg_mlc.obj XXXmalloc.obj XXXstubborn.obj XXXdyn_load.obj \ XXXtypd_mlc.obj XXXptr_chck.obj XXXgc_cpp.obj XXXmallocx.obj \ XXXfnlz_mlc.obj OBJS= $(XXXOBJS:XXX=) all: gctest.exe cord\de.exe test_cpp.exe $(OBJS) test.obj: include\private\gc_priv.h include\private\gc_hdrs.h include\gc.h include\private\gcconfig.h MAKEFILE gc.lib: $(OBJS) del gc.lib $(lib) $* @&&| $(XXXOBJS:XXX=+) | gctest.exe: tests\test.obj gc.lib $(cc) @&&| $(cflags) -W -e$* tests\test.obj gc.lib | cord\tests\de.obj cord\tests\de_win.obj: include\cord.h \ include\cord_pos.h cord\tests\de_win.h cord\tests\de_cmds.h cord\de.exe: cord\cordbscs.obj cord\cordxtra.obj cord\tests\de.obj \ cord\tests\de_win.obj cord\tests\de_win.res gc.lib $(cc) @&&| $(cflags) -W -e$* cord\cordbscs.obj cord\cordxtra.obj \ cord\tests\de.obj cord\tests\de_win.obj gc.lib | $(rc) cord\tests\de_win.res cord\de.exe gc_cpp.obj: include\gc_cpp.h include\gc.h gc_cpp.cpp: gc_cpp.cc copy gc_cpp.cc gc_cpp.cpp test_cpp.cpp: tests\test_cpp.cc copy tests\test_cpp.cc test_cpp.cpp test_cpp.exe: test_cpp.obj include\gc_cpp.h include\gc.h gc.lib $(cc) @&&| $(cflags) -W -e$* test_cpp.obj gc.lib | scratch: -del *.obj *.res *.exe *.csm cord\*.obj cord\*.res cord\*.exe cord\*.csm clean: del gc.lib del *.obj del tests\test.obj ecl-16.1.2/src/bdwgc/CMakeLists.txt000066400000000000000000000207721266352375300170050ustar00rootroot00000000000000# # Copyright (c) 1994 by Xerox Corporation. All rights reserved. # Copyright (c) 1996 by Silicon Graphics. All rights reserved. # Copyright (c) 1998 by Fergus Henderson. All rights reserved. # Copyright (c) 2000-2010 by Hewlett-Packard Company. All rights reserved. ## # THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED # OR IMPLIED. ANY USE IS AT YOUR OWN RISK. ## # Permission is hereby granted to use or copy this program # for any purpose, provided the above notices are retained on all copies. # Permission to modify the code and to distribute modified code is granted, # provided the above notices are retained, and a notice that the code was # modified is included with the above copyright notice. ## # # get cmake and run: # cmake -G "Visual Studio 8 2005" # in the same dir as this file # this will generate gc.sln # SET(CMAKE_LEGACY_CYGWIN_WIN32 0) # Remove when CMake >= 2.8.4 is required PROJECT(gc) CMAKE_MINIMUM_REQUIRED(VERSION 2.6) ADD_DEFINITIONS("-D_CRT_SECURE_NO_DEPRECATE -DALL_INTERIOR_POINTERS") IF(APPLE) IF("${CMAKE_OSX_ARCHITECTURES}" STREQUAL "") SET(CMAKE_OSX_ARCHITECTURES "ppc;i386;x86_64" CACHE STRING "Build architectures for Mac OS X" FORCE) ENDIF() ENDIF(APPLE) #LIBATOMIC #TODO #ADD_LIBRARY(atomic_ops STATIC ) #SET_TARGET_PROPERTIES(atomic_ops PROPERTIES COMPILE_FLAGS -DNO_DEBUGGING) #LIBGC INCLUDE_DIRECTORIES(include) INCLUDE_DIRECTORIES(libatomic_ops/src) SET(SRC alloc.c reclaim.c allchblk.c misc.c mach_dep.c os_dep.c mark_rts.c headers.c mark.c obj_map.c blacklst.c finalize.c new_hblk.c dbg_mlc.c malloc.c stubborn.c dyn_load.c typd_mlc.c ptr_chck.c gc_cpp.cc mallocx.c checksums.c thread_local_alloc.c) SET(LIBS) OPTION(enable_threads "TODO" NO) IF(enable_threads) FIND_PACKAGE(Threads REQUIRED) MESSAGE("Thread Model: ${CMAKE_THREAD_LIBS_INIT}" ) INCLUDE_DIRECTORIES(${Threads_INCLUDE_DIR}) SET(LIBS ${LIBS} ${Threads_LIBRARIES}) ENDIF(enable_threads) OPTION(enable_parallel_mark "Parallelize marking and free list construction" NO) #IF(Threads_FOUND) # ADD_DEFINITIONS("") #ELSE # MESSAGE("Parallel mark requires enable_threads ON" ) #ENDIF(Threads_FOUND) IF(enable_parallel_mark) ENDIF(enable_parallel_mark) OPTION(enable_cplusplus "install C++ support" NO) SET(_HOST ${CMAKE_HOST_SYSTEM_PROCESSOR}--${CMAKE_SYSTEM}) #FIXME missing the vendor field.Use lowercase STRING(TOLOWER ${_HOST} HOST) MESSAGE("HOST = ${HOST}") #Thread Detection. Relying on cmake for lib an includes. #TODO check cmake detection IF(CMAKE_USE_PTHREADS_INIT) SET(SRC ${SRC} pthread_start.c pthread_support.c pthread_stop_world.c) IF( "HOST" MATCHES x86-.*-linux.*|ia64-.*-linux.*|i586-.*-linux.*|i686-.*-linux.*|x86_64-.*-linux.*|alpha-.*-linux.*|sparc.*-.*-linux.*) ADD_DEFINITIONS("-DGC_LINUX_THREADS") ADD_DEFINITIONS("-D_REENTRANT") IF (${enable_parallel_mark}) ADD_DEFINITIONS("-DPARALLEL_MARK") ENDIF() ADD_DEFINITIONS("-DTHREAD_LOCAL_ALLOC") MESSAGE("Explicit GC_INIT() calls may be required.") ENDIF() IF ( "HOST" MATCHES .*-.*-linux.*) ADD_DEFINITIONS("-DGC_LINUX_THREADS") ADD_DEFINITIONS("-D_REENTRANT") ENDIF() IF ( "HOST" MATCHES .*-.*-aix.*) ADD_DEFINITIONS("-DGC_AIX_THREADS") ADD_DEFINITIONS("-D_REENTRANT") ENDIF() IF ( "HOST" MATCHES .*-.*-hpux11.*) MESSAGE("Only HP/UX 11 POSIX threads are supported.") ADD_DEFINITIONS("-DGC_HPUX_THREADS") ADD_DEFINITIONS("-D_POSIX_C_SOURCE=199506L") #TODO test -DVAR=value. Alternative is COMPILE_DEFINITIONS property IF (${enable_parallel_mark}) ADD_DEFINITIONS("-DPARALLEL_MARK") ENDIF() MESSAGE("Explicit GC_INIT() calls may be required.") ADD_DEFINITIONS("-D_REENTRANT") #TODO ENDIF() IF ( "HOST" MATCHES .*-.*-hpux10.*) MESSAGE("Only HP/UX 11 POSIX threads are supported.") ENDIF() IF ( "HOST" MATCHES .*-.*-openbsd.*) ADD_DEFINITIONS("-DGC_OPENBSD_THREADS") ENDIF() IF ( "HOST" MATCHES .*-.*-freebsd.*) MESSAGE("FreeBSD does not yet fully support threads with Boehm GC.") ADD_DEFINITIONS("-DGC_FREEBSD_THREADS") ENDIF() IF ( "HOST" MATCHES .*-.*-kfreebsd.*-gnu) ADD_DEFINITIONS("-DGC_FREEBSD_THREADS") ADD_DEFINITIONS("-D_REENTRANT") IF (${enable_parallel_mark}) ADD_DEFINITIONS("-DPARALLEL_MARK") ENDIF() ADD_DEFINITIONS("-DTHREAD_LOCAL_ALLOC") ADD_DEFINITIONS("-DUSE_COMPILER_TLS") ENDIF() IF ( "HOST" MATCHES .*-.*-gnu.*) ADD_DEFINITIONS("-DGC_GNU_THREADS") ADD_DEFINITIONS("-D_REENTRANT") ADD_DEFINITIONS("-DTHREAD_LOCAL_ALLOC") ENDIF() IF ( "HOST" MATCHES .*-.*-netbsd.*) MESSAGE("Only on NetBSD 2.0 or later.") ADD_DEFINITIONS("-DGC_NETBSD_THREADS") ADD_DEFINITIONS("-D_REENTRANT") ADD_DEFINITIONS("-D_PTHREADS") ENDIF() IF ( "HOST" MATCHES .*-.*-solaris.*) ADD_DEFINITIONS("-DGC_SOLARIS_THREADS") ADD_DEFINITIONS("-DTHREAD_LOCAL_ALLOC") #TODO # if test "$GCC" != yes; then # CFLAGS="$CFLAGS -O" # need_atomic_ops_asm=true # fi ENDIF() IF ( "HOST" MATCHES .*-.*-irix.*) ADD_DEFINITIONS("-DGC_IRIX_THREADS") ENDIF() IF ( "HOST" MATCHES .*-.*-cygwin.*) ADD_DEFINITIONS("-DGC_THREADS") IF (${enable_parallel_mark}) ADD_DEFINITIONS("-DPARALLEL_MARK") ENDIF() ADD_DEFINITIONS("-DTHREAD_LOCAL_ALLOC") #TODO # win32_threads=true ENDIF() IF ( "HOST" MATCHES .*-.*-darwin.*) ADD_DEFINITIONS("-DGC_DARWIN_THREADS") ADD_DEFINITIONS("-DTHREAD_LOCAL_ALLOC") MESSAGE("Explicit GC_INIT() calls may be required.") SET(SRC ${SRC} darwin_stop_world.c) IF (${enable_parallel_mark}) ADD_DEFINITIONS("-DPARALLEL_MARK") ENDIF() #TODO #darwin_threads=true ENDIF() IF ( "HOST" MATCHES .*-.*-osf*) ADD_DEFINITIONS("-DGC_OSF1_THREADS") IF (${enable_parallel_mark}) ADD_DEFINITIONS("-DPARALLEL_MARK") ADD_DEFINITIONS("-DTHREAD_LOCAL_ALLOC") MESSAGE("Explicit GC_INIT() calls may be required.") # May want to enable it in other cases, too. # Measurements haven't yet been done. ENDIF() ENDIF() IF ( "HOST" MATCHES .*-.*-linux.*) ADD_DEFINITIONS("-DGC_LINUX_THREADS") ADD_DEFINITIONS("-D_REENTRANT") ENDIF() ENDIF(CMAKE_USE_PTHREADS_INIT) IF(CMAKE_USE_WIN32_THREADS_INIT) ADD_DEFINITIONS("-DGC_THREADS") #win32_threads=true TODO IF (${enable_parallel_mark}) ADD_DEFINITIONS("-DPARALLEL_MARK") ADD_DEFINITIONS("-DTHREAD_LOCAL_ALLOC") ENDIF() ADD_DEFINITIONS("-DEMPTY_GETENV_RESULTS") #TODO test SET(SRC ${SRC} win32_threads.c) ENDIF(CMAKE_USE_WIN32_THREADS_INIT) OPTION(enable_gcj_support "Support for gcj" NO) IF(enable_gcj_support) ADD_DEFINITIONS("-DGC_GCJ_SUPPORT") ENDIF(enable_gcj_support) ADD_LIBRARY( gc-lib STATIC ${SRC}) SET_TARGET_PROPERTIES(gc-lib PROPERTIES COMPILE_DEFINITIONS GC_NOT_DLL) #TODO TARGET_LINK_LIBRARIES(... ... ${LIBS}) ADD_LIBRARY( gcmt-lib STATIC ${SRC}) SET_TARGET_PROPERTIES(gcmt-lib PROPERTIES COMPILE_DEFINITIONS GC_NOT_DLL) ADD_LIBRARY( gcmt-dll SHARED ${SRC}) IF(WIN32) ADD_EXECUTABLE(cord cord/cordbscs.c cord/cordxtra.c cord/tests/de.c cord/tests/de_win.c) SET_TARGET_PROPERTIES(cord PROPERTIES WIN32_EXECUTABLE TRUE) SET_TARGET_PROPERTIES(cord PROPERTIES COMPILE_DEFINITIONS GC_NOT_DLL) TARGET_LINK_LIBRARIES(cord gc-lib) TARGET_LINK_LIBRARIES(cord gdi32) ENDIF(WIN32) ADD_SUBDIRECTORY(tests) ecl-16.1.2/src/bdwgc/ChangeLog000066400000000000000000014344671266352375300160320ustar00rootroot00000000000000 == [7.5.0] (development) == * Add API function to set/modify GC log file descriptor (Unix). * Add alloc_size attribute to GC_generic_malloc. * Added instructions to README.md for building from git. * Allow to force GC_dump_regularly set on at compilation. * Change 'cord' no-argument functions declaration style to ANSI C. * Define ROUNDUP_PAGESIZE, ROUNDUP_GRANULE_SIZE macros (code refactoring). * Define public GC_GENERIC_OR_SPECIAL_MALLOC and GC_get_kind_and_size. * Eliminate redundant *flh check for null in GC_allocobj. * GC_scratch_alloc code refactoring (and WARN message improvement). * Group all compact fields of GC_arrays to fit in single page. * Improve documentation for disappearing links in gc.h. * Make heap growth more conservative after GC_gcollect_and_unmap call. * New macro (GC_ALWAYS_MULTITHREADED) to set multi-threaded mode implicitly. * Refine description in README how to build from source repository. * Remove 'opp' local variable in GC_malloc_X. * Remove hb_large_block field (use 1 extra bit of hb_flags instead). * Remove obsolete BACKING_STORE_ALIGNMENT/DISPLACEMENT macros for Linux/IA64. * Remove redundant casts in GC_generic_or_special_malloc and similar. * Use magic header on objects to improve disclaim_test. Also, includes 7.4.2 changes. == [7.4.2] 2014-06-03 == * Add config option to use STGRTMIN-based signals for thread suspend/resume. * Allow parallel mark to be enabled on powerpc-linux systems. * Check for Fujitsu compiler in builtin_unwind logic (enable FX10/K-Computer). * Fix 'Array subscript is above array bounds' GCC warning in GC_new_kind/proc. * Fix 'attribute declaration must precede definition' warning (clang-3.1). * Fix (enable) Cygwin-64 build. * Fix GC_finalized_malloc failure on disclaim_test. * Fix GC_sig_suspend initialization when non-constant SIGRTMIN used. * Fix MS VC redefinition warning for functions declared with GC_ATTR_MALLOC. * Fix TEXT() usage for concatenated strings in GC_CreateLogFile (Win32). * Fix data roots registration for Android/x86 and NDK ARM 'gold' linker. * Fix find stackbottom on BlueGene P/Q systems. * Fix machdep .lo files path in configure (SPARC, IA-64). * Fix ok_init assignment (missing cast) in GC_new_kind_inner. * Fix typos in names in AUTHORS and ChangeLog files. * Remove barrett_diagram file duplicated by tree.html. * Remove non-existing DISCARD_WORDS from GC data structure ASCII diagram. * Restore contribution information for ancient releases in ChangeLog. Also, includes 7.2f changes. == [7.4.0] 2013-11-17 == * Add 'bytes reclaimed' counters to public GC_prof_stats_s. * Add AArch64 (64-bit ARM) target support. * Add GC_LONG_REFS_NOT_NEEDED ifdefs to exclude long link functionality. * Add GC_get_prof_stats[_unsafe]() to GC public API. * Add GC_push_all/conditional() to GC public API. * Add assertion on number_of_objs to GC_extend_size_map. * Add assertion to GC_enable() ensuring no counter underflow. * Add assertion to LOCK definition that lock is not already held. * Add assertion to LONG_MULT and remove useless assert in PUSH_CONTENTS_HDR. * Add double-lock assertion to GC_acquire_mark_lock. * Add manual POSIX fork handling support (Android). * Add note about 'pkg-config' solving problem with autoconf 2.68 or older. * Add public GC_set/get_abort_func to replace default GC_on_abort. * Add public GC_start_mark_threads() to allow parallel marker in fork child. * Add public setter and getter for GC_push_other_roots. * Add support of Android logger. * Add tests for GC_register/move/unregister_long_link. * Add thread suspend/resume signals public setters (POSIX threads). * Added long weakref support. * Adjust GC_dont_expand/gc/precollect and GC_print_stats type to match gc.h. * Adjust README.md title and references to doc .html files in it. * Adjust build scripts to enable additional test library in staticrootstest. * Adjust logged messages in start_mark_threads and GC_thr_init. * Adjust printf format specifiers in GC_print_trace. * Allow not to rely on __data_start value (Linux). * Allow pthread_kill error code logging in GC_suspend/resume (debugging). * Allow to compile GC_inner_start_routine aside from extra/gc.c. * Allow to omit libc atexit() call. * Avoid LOCK/UNLOCK hard-coding in gc_locks.h for PS3 target. * Better document GC_warn_proc in gc.h. * Call GC_on_abort (with NULL argument) on exit(1). * Call GC_stats/verbose_log_printf instead of GC_log_printf if print_stats. * Change policy regarding version numbers ("micro" part instead of "alpha"). * Changed C99-style designated init of GC_dl_hashtbl struct to use C89-style. * Check GC_base result in GC_print_all_smashed_proc. * Check that SIG_SUSPEND and SIG_THR_RESTART are different (Pthreads). * Check traceable_allocator.allocate result before dereference in test_cpp. * Code refactoring of GC_x_printf (move shared code to macro). * Convert readme to markdown. * Default to use libc_stack_end in single-threaded GC on glibc targets. * Define GC_VSNPRINTF internal macro in misc.c (code refactoring). * Define functions in darwin_semaphore.h as inline instead of static. * Define old_bus_handler static variable only if used (Unix). * Detect dladdr() presence by configure. * Disable find-leak GC_gcollect on GC abnormal EXIT. * Do not define _setjmp/_longjmp macros in mach_dep.c. * Do not duplicate android_log_write output to GC log file (Android). * Do not include sigcontext.h if NO_SIGCONTEXT_H (Linux). * Do not set GC_lock_holder by call_with_alloc_lock if assertions disabled. * Do not use pthread_getattr_np if NO_PTHREAD_GETATTR_NP specified. * Elaborate comment on dependencies in autogen.sh. * Eliminate 'cast from int to pointer' warning in GC_exclude_static_roots. * Eliminate 'missing exception specification' warning in gc_cpp.cc (Clang). * Eliminate 'uninitialized variable use' warning in test_printf (cord). * Eliminate 'unused result' compiler warning in main() of test_cpp. * Eliminate 'unused value' compiler warning in GC_stop_world (Pthreads). * Eliminate 'unused variable' compiler warning in start_mark_threads (HP/UX). * Eliminate Clang warning for GC_pthread_exit attribute. * Eliminate GCC warning about uninitialized 'hhdr' in GC_allochblk_nth. * Eliminate GCC warning in GC_get_main_stack_base (OpenBSD). * Eliminate GCC warnings in setjmp_t.c, test_cpp and cord 'de' app. * Eliminate GC_first_nonempty atomic value reload in GC_mark_local assertion. * Eliminate SIGBUS-related dead code in GC_write_fault_handler (Linux). * Eliminate warning and simplify expression in GC_init_explicit_typing. * Enable 'force GC at every GC_malloc' debug-related functionality. * Enable on-demand debug logging in GC_FindTopOfStack (Darwin). * Enable prefetch operations by default (GCC 3.0+). * Enable staticrootstest for the case of GC shared library build. * Enable thread-local allocation support for Clang on Cygwin. * Explicitly specify that Darwin, Linux and Solaris platforms have dladdr. * Fix ABORT definition for mingw32ce (WinCE). * Fix AM_CONFIG_HEADER in configure for autoconf-2.69-1. * Fix GC_CreateThread and GC_beginthreadex definition for Cygwin. * Fix GC_INIT_CONF_ROOTS in gc.h for Android. * Fix GC_INLINE definition to comply with ISO C90 standard (GCC). * Fix GC_remove_all_threads_but_me for Android (fork support). * Fix debug_register_displacement calls from GC_debug_generic_malloc_inner. * Fix dyn_load.c compilation for Android 4.3. * Fix make disclaim_test to link with new GNU ld linking rules. * Improve GC error printing atomicity in GC_debug_X and GC_print_obj. * Improve GC output atomicity in GC_print_obj, GC_print_all_errors. * Improve debug-only messages of add/remove_roots and init_linux_data_start. * Improve fork test logging in gctest. * Improve logged messages about heap size and usage. * Improve logging for Android differentiating messages by log level. * Improve staticrootstest (add global data to library, add lib w/o GC_INIT). * Improve staticrootstest checks (tests). * Include "config.h" instead of "private/config.h" on HAVE_CONFIG_H. * Include proper header file in 'tools' for configuration macros. * Include pthread_np.h from pthread_stop_world.c on OpenBSD. * Log error messages to stderr instead of stdout in tests. * Make GC_generic_malloc_ignore_off_page() public. * Make GC_mark_lock_holder variable static. * Make GC_print_trace always thread-safe and remove 'lock' argument. * Mark GC_started_thread_while_stopped() as GC_INNER. * Minimize code duplication in GC_mark_and_push. * Move 'include setjmp.h' from mach_dep.c to gc_priv.h. * Move GC_OPENBSD_UTHREADS definition to private/gcconfig.h (OpenBSD). * Move GC_get_suspend/thr_restart_signal to misc.c for NaCl and OpenBSD. * Move LOCK/UNLOCK from GC_unregister_disappearing_link_inner outer. * Port BDWGC to Android/x86. * Postpone the suspend signal in GC_dirty_init only if used to stop world. * Prepend '#' symbol to GC number in logged messages. * Prevent POSIX fork if mprotect_thread is started (Darwin). * Prevent abort on GC_err/warn_printf write failure. * Prevent misleading AC_MSG_ERROR/AS_IF errors reported in configure.ac. * Put gc_cpp symbols into 'boehmgc' namespace if GC_NAMESPACE defined. * Recognize GC_DONT_GC macro in gc.h (causes GC_INIT to turn off GC). * Recognize GC_SIG_SUSPEND and GC_SIG_THR_RESTART tuning macros in gc.h. * Redirect WRITE to __android_log_write if GC_ANDROID_LOG (Android). * Refine comment of GC_is_heap_ptr and GC_thread_is_registered in gc.h. * Register dynamic libraries via dl_iterate_phdr on Android and OpenBSD. * Remove DebugBreak on WriteFile failure (Win32). * Remove GC_BUILD definition from build scripts. * Remove abort on open log failure from GC_write (Win32). * Remove configure.ac outdated revision number. * Remove nested EXPECT in GC_core_finalized_malloc. * Remove nested always-false ifdef for HPUX and FREEBSD. * Remove redundant GC_err_printf before abort. * Remove unused UTHREAD_SP_OFFSET macro (OpenBSD). * Rename subthread_create to subthreadcreate_test (Makefile). * Replace GC_COND_LOG_PRINTF calls with WARN for allocation failure messages. * Replace GC_log/err_printf() followed by ABORT with ABORT_ARGn(). * Replace GC_stats_log_printf with GC_DBG/INFOLOG_PRINTF. * Replace SIG_SUSPEND/THR_RESTART macros to variables in pthread_stop_world. * Replace Win32 GC_delete_gc_thread with GC_delete_gc_thread_no_free. * Replace conditional GC_log_printf calls with GC_COND/VERBOSE_LOG_PRINTF. * Replace sprintf with defensive snprintf. * Replace var-args GC_noop with GC_noop6 (to eliminate Clang warning). * Simplify LOCK/UNLOCK macro definition for static code analysis tools. * Specify GC_malloc result is unused in some tests. * Specify GC_pthread_join result is unused in threadkey_test. * Specify LT_INIT in configure.ac. * Start of port to QNX. * Support rthreads introduced in OpenBSD 5.2+. * Suppress 'GC_dont_gc deprecated' warning in gc.h if GC_DONT_GC. * Tag GC malloc routines with alloc_size attribute for Clang 3.2+. * Test NO_WRAP_MARK_SOME macro to suppress WRAP_MARK_SOME-specific code. * Turn off GC_LOOP_ON_ABORT functionality if GC compiled with NO_DEBUGGING. * Turn on world-stop delay logging at debug level by default for Android. * Use EXPECT in GC_COND/VERBOSE_LOG_PRINTF. * Use GC_log_printf for logging instead of GC_[err_]printf. * Use compiler TLS for Android NDK gcc/arm. * Use memcpy (BCOPY) instead of strcpy (to suppress GCC warning). * Use pthread API to operate thread-local data on Linux if no compiler TLS. * Workaround 'ELF_DATA/EM_ALPHA redefined' warning in Android linker.h. * Workaround 'unresolved __tls_get_addr' error for Android NDK Clang. Also, includes 7.2e, 7.2d, 7.2c, 7.2b changes. == [7.3alpha2] 2012-05-11 == * Add 'const' qualifier to pointer argument of some API functions. * Add GC_UNDERSCORE_STDCALL, UNICODE macro templates to configure (Win32). * Add GC_get_thr_restart_signal, GC_thread_is_registered to GC API. * Add GC_is_heap_ptr, GC_move_disappearing_link to GC API. * Add SHORT_DBG_HDRS macro template to configure. * Add Symbian port to mainline (porting done by Djamel Magri). * Add TODO file. * Add assertion ensuring proper alignment of 'pushed' GC symbols. * Add assertion in GC_getspecific on qtid. * Add assertion to GC_incremental_protection_needs, refine documentation. * Add assertion to check GC_large_free_bytes by GC_finish_collection. * Add configure option to compile all library .c files into single gc.o. * Add cordtest to make check. * Add disclaim callbacks for efficient finalization (ENABLE_DISCLAIM). * Add finalization.html to 'doc' folder. * Add javaxfc.h to the installation set of GC header files (configure). * Add on-heap-resize event notification to API. * Adjust GC_log_printf format specifiers (regarding signed/unsigned long). * Adjust GC_requested_heapsize on GC_init if GC_INITIAL_HEAP_SIZE given. * Allow GC_exclude_static_roots() region start to be unaligned. * Allow Win32 DllMain chaining on the client side. * Allow to exclude finalization support by GC_NO_FINALIZATION macro. * Allow to get memory via Win32 VirtualAlloc (USE_WINALLOC) on Cygwin. * Avoid unnecessary GC_find_limit invocation if GC_no_dls. * Avoid use of deprecated GC_dont_gc and GC_stackbottom in gctest. * Cast pointers to word (instead of unsigned long) in specific.h. * Changed the order in autogen.sh so ltmain exists in time for automake. * Declare privately and use handy GC_base_C() for constant object pointers. * Define GC_DLL if DLL_EXPORT at GC build (for Cygwin/MinGW). * Define GC_READ_ENV_FILE in configure for WinCE unless gc-debug is off. * Do not compile backgraph.c unless configure '--enable-gc-debug'. * Do not compile pthread_stop_world.c for Cygwin/Darwin (configure). * Do not install ancient new_gc_alloc.h broken for modern STL (configure). * Enable GC_MIN_MARKERS to set minimal number of pthread-based markers. * Enable PARALLEL_MARK and THREAD_LOCAL_ALLOC for FreeBSD in configure. * Enable parallel mark by default in configure (Darwin/Linux/Solaris/Win32). * Export GC_is_marked, GC_clear/set_mark_bit (for mark-bit manipulation). * Extend thread-related debug messages. * Fix 'configure --enable-cplusplus' for Cygwin/MinGW. * Fix DATASTART (and other minor improvements) for NaCl target. * Fix GC_setspecific to prevent garbage collection inside. * Fix compiler warning in cordtest. * Fix minor warnings reported by GCC with '-pedantic' option. * Fix static data roots registration on Android (if GC is shared). * Implement GC_get_stack_base for Darwin for single-threaded mode. * Improve GC_allochblk algorithm of block splitting when unmapping enabled. * Improve GC_collect_or_expand algorithm for many finalizers registered case. * In tests, print a message in case a test is a no-op. * Instruct configure to hide internal libgc.so symbols if supported by GCC. * Log amount of unmapped memory (if enabled) on marking-for-collection. * Make __data_start a weak symbol to allow loading modules on mips. * Move "cord" library tests to "cord/tests" folder. * Move asm machine-dependent files to "src" folder. * Move build tools sources to "tools" folder. * Move cord_pos.h to public headers folder. * Open log file in APPEND mode on Win32 (similar that on Unix/Cygwin). * Optimize some functions by moving pthread_self calls out of LOCK section. * Place only major per-release changes description to ChangeLog (this file). * Prevent compiler warnings in GC_FindTopOfStack and GC_ports (Darwin). * Recognize GC_LOG_TO_FILE_ALWAYS macro to log to 'gc.log' by default. * Remove all auto-generated files from the repo. * Remove binary icon file for de_win. * Remove cordtest from "cord" library. * Remove duplicate MacOS_Test_config.h file. * Remove gc_amiga_redirects.h (included internally) from public headers. * Remove obsolete Makefile.DLL (superseded by Cygwin/MinGW configure). * Remove obsolete unused asm files for ALPHA, HPUX, SGI, RS6000, ULTRIX. * Remove unsupported MMAP_STACKS (specific to Solaris threads). * Remove unused ancient SILENT, __STDC__, NO_SIGNALS macros. * Replace ARGSUSED comment-based annotation with GCC 'unused' attribute. * Replace GC_ms_entry declaration with opaque definition for public API. * Replace long GC_markers global variable with int GC_markers_m1. * Replace pointer relational comparisons with non-pointer ones. * Replace printf PRIxMAX specifier with '%p' for thread id debug output. * Require autoconf 2.61 instead of v2.64. * Simplify autogen.sh (use autoreconf). * Split GC_abort with GC_on_abort and abort() invoked from ABORT. * Support GC_ATTR_MALLOC for MS VisualStudio. * Tag auxiliary malloc-like API functions with 'malloc' attribute. * Tag deprecated variables in GC API. * Tag must-be-non-null arguments of GC API functions. * Turn on "extra" GCC warnings. * Turn on unused-parameter checking for GCC. * Update AUTHORS file. * Use EXPECT for checking various 'initialized' boolean variables. * Use USE_COMPILER_TLS on Cygwin. * Use pthread_key for thread-local storage on FreeBSD. * Use union of AO_t and word to favor strict-aliasing compiler optimization. Also, includes 7.2 changes. == [7.2f] 2014-06-03 == * Fix 'Bad signal in suspend_handler' abort on FreeBSD-9.2. * Fix 'source file in a subdirectory' Automake warnings. * Fix ABORT message in GC_restart_handler. * Fix ADD_DEFINITION in CMakeLists.txt for kFreeBSD. * Fix CMakeLists.txt: do not override CMAKE_OSX_ARCHITECTURES. * Fix GC_alloc_large by bumping GC_collect_at_heapsize in GC_add_to_heap. * Fix GC_scratch_last_end_ptr update on GC_scratch_alloc failure. * Fix GET_MEM argument rounding in GC_scratch_alloc and similar. * Fix PARALLEL_MARK for Windows 7+. * Fix build (broken by fenv.h inclusion) on Linux/x86_64 under uClibc. * Fix crash when using GC_malloc_many() as first allocation call. * Fix mark stack excessive growth during parallel mark. * Fix or remove broken URLs in documentation. * Fix out-of-memory case in new_back_edges, push_in_progress (backgraph). * Fix typo in GC_collect_or_expand comment. * Fix typos in GC overview file, gc_config_macros.h, gc_cpp.h, README.changes. * Regenerate configure files by automake 1.14.1, libtool 2.4.2.418. * Update emails/links due to project site and ML transition. == [7.2e] 2013-11-10 == * Add weak attribute to avoid __data_start undefined messages (s390x). * Add weak stubs for pthread_cancel API. * Adjust 'pthread_[un]register_cancel undefined ref' workaround (Pthreads). * Append _test suffix to 'initsecondarythread' binary file names. * Enable PARALLEL_MARK and THREAD_LOCAL_ALLOC for FreeBSD in configure. * Fix 'stack section' pointer passed to push_all_stack_sections (Pthreads). * Fix GC_CreateThread 'dwStackSize' argument type for Win64. * Fix GC_PTHREAD_PTRVAL definition for GC_PTHREADS_PARAMARK (Win32). * Fix GC_clear_stack by declaring 'dummy' local array as volatile. * Fix GC_get_stack_base assembly code (Cygwin/Clang). * Fix GC_malloc_explicitly_typed_ignore_off_page for large allocations. * Fix GC_marker_Id elements initialization (WinCE). * Fix GC_print_trace missing unlock. * Fix GC_unix_mmap_get_mem for open of /dev/zero failure. * Fix GC_win32_free_heap compilation error for Cygwin. * Fix GC_win32_free_heap to prevent memory leak if USE_GLOBAL_ALLOC. * Fix Win32 GC_write preventing potential infinite recursion at abort. * Fix assertion violation in GC_mark_from prefetch loop. * Fix collection of objects referenced only from GC_mark_stack_X variables. * Fix dwSize argument of VirtualFree call in detect_GetWriteWatch (Win32). * Fix heap sections overflow for Win32/Cygwin with enabled parallel marker. * Fix min_bytes_allocd preventing potential infinite loop in GC_allocobj. * Fix missing tabs in SMakefile.amiga file. * Fix null-pointer dereference in CORD_substr_closure. * Fix old_segv/bus_act variables initialization for FreeBSD. * Fix potential double fclose in test_extras (cordtest). * Fix pthread_attr_t resource leak in pthread_create. * Fix race in GC_print_all_errors regarding GC_leaked. * Fix sizeof in GC_push_thread_structures. * Fix stackbottom/stack_end assignment in GC_call_with_gc_active. * Fix tests makefile to link with new GNU ld linking rules. * Fix typos in comments and documentation. * Fix unportable '==' test operators in configure. * Fix vsprintf_args cleanup in CORD_vsprintf. * Merge FreeBSD New ports collection for boehm-gc v7.2d. * Replace GC_DBG_RA with GC_DBG_EXTRAS macro. * Replace deprecated [CXX]INCLUDES to AM_C[PP]FLAGS in configure.ac file. * Use __builtin_extract_return_addr in GC_RETURN_ADDR_PARENT (gcc/x86). == [7.2d] 2012-08-09 == * Fix GC_call_with_stack_base to prevent its tail-call optimization. * Fix all address-of-dummy operations by using GC_approx_sp() instead. * Fix stop_info.stack_ptr assignment in GC_suspend_all for OpenBSD. * Fix test_cpp (ensure the collector recognizes pointers to interiors). * Fix thread-related tests for pthreads-w32. * test_cpp: Fix WinMain to prevent SEGV if zero arguments passed (MinGW). == [7.2c] 2012-06-11 == * Fix CORD_cat_char_star to prevent SEGV in case of out-of-memory. * Fix GC_FirstDLOpenedLinkMap() for NetBSD 6 release. * Fix GC_scratch_alloc and GC_get_maps invocations to prevent SEGV. * Fix visibility of GC_clear/set_mark_bit (unhide symbols). * Fix visibility of GC_push_all/conditional, GC_push_other_roots symbols. == [7.2b] 2012-05-23 == * Fix assertion in GC_malloc_[atomic_]uncollectable (THREADS case only). == [7.2] 2012-05-11 == * Abort in GC_thr_init on pthread_atfork failure (POSIX threads). * Add GC_WIN32_PTHREADS target in configure. * Add GC_is_disabled new function to GC API. * Add info that getcontext() resets FPE mask no longer on Linux/x86_64. * Add public GC_set_handle_fork to control forked child handling support. * Add realloc_test.c test. * Add support for Hexagon target. * Add thread-safe GC_get_heap_usage_safe to GC API. * Change GC_check_fl_marks prototype and implementation. * Check pthread_create/join result in test. * Define GC_DLL (in configure) if building only dynamic libraries. * Define NO_DEBUGGING (in configure) if "--disable-gc-debug" is set. * Disable incremental mode on Darwin if fork handling requested. * Enable parallel marker in configure for Solaris. * Fix "comparison of signed and unsigned values" compiler warnings. * Fix 'volatile' keyword placement in GC_SysVGetDataStart. * Fix ALIGNMENT, CPP_WORDSZ, GC_GRANULE_BYTES/WORDS for x32 target. * Fix GC_READ_ENV_FILE code for Cygwin. * Fix GC_add_roots_inner for Mac OS X (align segment start). * Fix GC_check_fl_marks regarding concurrent access. * Fix GC_finalizer_nested size to workaround alignment problem in Watcom. * Fix GC_find_limit_with_bound to always reset fault handler on return. * Fix GC_init static assertion for clang/x64 (Darwin). * Fix GC_init[_lib_bounds] and GC_get_main_stack_base for malloc redirection. * Fix GC_push_all/selected boundaries check. * Fix GC_register_my_thread marking thread as detached (Cygwin/pthreads-w32). * Fix GC_remove_all_threads_but_me to cleanup thread-specific data storage. * Fix GC_restart_handler to preserve errno if needed. * Fix GC_root_size update in GC_add_roots_inner (Win32). * Fix GC_unregister_my_thread to ensure no ongoing incremental GC (Win32). * Fix GC_with_callee_saves_pushed for clang (disable __builtin_unwind_init). * Fix calloc, GC_generic_malloc to check for allocation size overflows. * Fix compiler warning in GC_dyld_image_add/remove (Darwin). * Fix configure --enable-cplusplus make install. * Fix configure to disable GCC aliasing optimization unless forced to. * Fix duplicate definitions in gcconfig.h for NetBSD. * Fix fork() support on Cygwin and Darwin targets. * Fix gc.h compatibility regression regarding GC_PTR, GC_I_HIDE_POINTERS. * Fix gc_cpp.cc for Cygwin (remove duplicate function definition). * Fix gcconfig.h to define USE_GET_STACKBASE_FOR_MAIN for Android. * Fix gcconfig.h to handle mips64-linux target. * Fix gctest (for Win32) to avoid GC_print_stats internal variable usage. * Fix mach_dep.c to include sys/ucontext.h on Mac OS X 10.6. * Fix tests to check GC_malloc result for NULL (out-of-memory). * Fix thread model in configure for MinGW ("win32" instead of "posix"). * Fix various warnings reported by LINT-like tools. * Fix visibility of some GC internal symbols used by GNU GCJ currently. * Port some thread tests to Win32. * Refine API GC setters and getter comments regarding locking. * Refine GC_stackbottom description in gc.h. * Remove duplicate calls in GC_register_dynamic_libraries. * Remove locking in API GC_get_bytes_since_gc and friends. * Remove newly-added GC_get_heap_size/free_bytes_inner from API. * Remove some local variables that are unused. * Support multi-threading for RTEMS target. * Use global GC_noop_sink variable in GC_noop1 to suppress compiler warning. * Use pkg-config to pick up libatomic_ops, etc. * Workaround some Linux/arm kernels bug to get correct GC_nprocs value. == [7.2alpha6] 2011-06-14 == * configure_atomic_ops.sh: Remove. * Makefile.direct (dist gc.tar): Remove configure_atomic_ops.sh. * Makefile.am (EXTRA_DIST): Add autogen.sh. * NT_STATIC_THREADS_MAKEFILE (.cpp.obj): Remove duplicate .cpp filename passed. * NT_X64_THREADS_MAKEFILE (.cpp.obj): Use lowercase file extension. * NT_X64_STATIC_THREADS_MAKEFILE (.cpp.obj): Likewise. * NT_MAKEFILE (.cpp.obj): Likewise. * alloc.c (GC_add_current_malloc_heap, GC_build_back_graph, GC_traverse_back_graph): Move prototype to gc_priv.h. * checksums.c (GC_page_was_ever_dirty): Likewise. * dbg_mlc.c (GC_default_print_heap_obj_proc): Likewise. * dyn_load.c (GC_parse_map_entry, GC_get_maps, GC_segment_is_thread_stack, GC_roots_present, GC_is_heap_base, GC_get_next_stack): Likewise. * finalize.c (GC_reset_finalizer_nested, GC_check_finalizer_nested): Likewise. * gcj_mlc.c (GC_start_debugging, GC_store_debug_info): Likewise. * malloc.c (GC_extend_size_map, GC_text_mapping): Likewise. * mark_rts.c (GC_mark_thread_local_free_lists): Likewise. * misc.c (GC_register_main_static_data, GC_init_win32, GC_setpagesize, GC_init_linux_data_start, GC_set_and_save_fault_handler, GC_init_dyld, GC_init_netbsd_elf, GC_initialize_offsets, GC_bl_init, GC_do_blocking_inner, GC_bl_init_no_interiors): Likewise. * os_dep.c (GC_greatest_stack_base_below, GC_push_all_stacks): Likewise. * reclaim.c (GC_check_leaked): Likewise. * win32_threads.c (GC_gww_dirty_init): Likewise. * darwin_stop_world.c (GC_is_mach_marker, GC_mprotect_stop, GC_mprotect_resume): Move prototype to darwin_stop_world.h. * pthread_support.c (GC_FindTopOfStack): Likewise. * dyn_load.c (GC_cond_add_roots): Merge adjacent definitions. * mark.c (GC_page_was_ever_dirty): Remove (as already declared). * mark_rts.c (GC_roots_present): Change return type to void pointer (to match the prototype); return NULL instead of FALSE. * mark_rts.c (GC_add_roots_inner): Cast GC_roots_present() result. * os_dep.c (NEED_PROC_MAPS): Move definition to gcconfig.h. * os_dep.c (GC_write_fault_handler): Make STATIC. * os_dep.c (GC_set_write_fault_handler): New function (only if GC_WIN32_THREADS). * pthread_start.c (GC_start_rtn_prepare_thread, GC_thread_exit_proc): Move prototype to pthread_support.h. * pthread_support.c (GC_nacl_initialize_gc_thread, GC_nacl_shutdown_gc_thread, GC_unblock_gc_signals): Likewise. * pthread_support.c (GC_stop_init): Move prototype to pthread_stop_world.h. * win32_threads.c (GC_write_fault_handler): Remove prototype. * win32_threads.c (GC_register_my_thread_inner): Call GC_set_write_fault_handler instead of SetUnhandledExceptionFilter (only if MPROTECT_VDB). * doc/README.win32: Add information about DMC. * include/private/gc_priv.h (GC_set_write_fault_handler): New prototype (only if GC_WIN32_THREADS and MPROTECT_VDB). * misc.c (vsnprintf): Redirect to vsprintf() if NO_VSNPRINTF. * win32_threads.c (GC_unregister_my_thread): Use KNOWN_FINISHED() instead of FINISHED macro. * tests/test.c (check_heap_stats): Round up max_heap_sz value for Win32 (same as for USE_MMAP). * tests/test.c (check_heap_stats): Adjust printf format specifier for max_heap_sz; cast max_heap_sz accordingly. * doc/README.solaris2: Add note. * configure.ac (SOLARIS25_PROC_VDB_BUG_FIXED): Don't define for Solaris/x86 2.10+. * tests/threadkey_test.c (SKIP_THREADKEY_TEST): Skip the test if defined; explicitly define for some targets. * mark.c (GC_dirty): Add prototype (only if MANUAL_VDB). * stubborn.c (GC_dirty): Likewise. * include/private/gcconfig.h (GWW_VDB, MPROTECT_VDB, PCR_VDB, PROC_VDB): Undefine if MANUAL_VDB. * include/private/gcconfig.h (DEFAULT_VDB): Don't define if MANUAL_VDB. * os_dep.c (async_set_pht_entry_from_index): Define for MANUAL_VDB. * os_dep.c (GC_read_dirty): Set GC_dirty_maintained only if success; if ioctl() failed then just print warning instead of aborting. * include/private/gc_priv.h (GC_ASSERT): Use "%d" (instead of %ld) for line number printing. * os_dep.c (GC_read_dirty): Add debug logging if DEBUG_DIRTY_BITS (for PROC_VDB only); print errors via GC_err_printf; rename "ps" and "np" local variables to npages and pagesize, respectively; remove "current_addr" local variable. * os_dep.c (GC_get_main_stack_base): Convert to GC_get_stack_base for BeOS and OS/2; define HAVE_GET_STACK_BASE. * os_dep.c (GET_MAIN_STACKBASE_SPECIAL): Define when a specific GC_get_main_stack_base implementation is defined. * os_dep.c (GC_get_main_stack_base): Define that based on GC_get_stack_base() in a single place (only if GET_MAIN_STACKBASE_SPECIAL is unset); check GC_get_stack_base() result. * mark.c (GC_push_selected): Remove "push_fn" argument (use GC_push_all directly); update the documentation. * mark.c (GC_push_conditional): Simplify the code (for better readability). * mark.c (alloc_mark_stack): Use FALSE/TRUE (instead of 0/1) for boolean local variables. * doc/README.macros (GC_PREFER_MPROTECT_VDB): Update. * os_dep.c (GC_page_was_dirty, GC_page_was_ever_dirty, GC_remove_protection): Define for GWW_VDB and PROC_VDB in a single place. * os_dep.c (GC_page_was_dirty, GC_page_was_ever_dirty): Compute PHT_HASH(h) only once (store result to a local variable). * doc/README.solaris2: Update. * include/private/gcconfig.h (end, InitStackBottom): Declare extern variable for RTEMS. * include/private/gcconfig.h (DATASTART, DATAEND, STACKBOTTOM): Update (for RTEMS). * include/private/gcconfig.h (DATAEND): Fix a typo in the macro name (for RTEMS). * tests/test.c (CONFIGURE_APPLICATION_DOES_NOT_NEED_CLOCK_DRIVER): Replace with CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER (for RTEMS). * include/private/gcconfig.h (MPROTECT_VDB): Enable for Solaris in single-threaded environment. * include/private/gcconfig.h (MPROTECT_VDB): Undefine if PROC_VDB. * tests/test.c (NUMBER_ROUND_UP): New macro. * tests/test.c (check_heap_stats): Round up total expected heap size to the nearest 4 MiB bound. * tests/test.c (check_heap_stats): Print the current and expected heap sizes in case of failure. * checksums.c (GC_check_blocks, GC_check_dirty): Do log printing only if GC_print_stats; print errors using GC_err_printf. * checksums.c (GC_check_blocks): Join adjacent printf() calls into a single one. * pthread_support.c (pthread_join): Add assertion (check thread is finished). * pthread_support.c (GC_register_my_thread): Don't detach the thread if invoked from the thread destructor. * win32_threads.c (GC_register_my_thread): Likewise. * win32_threads.c (GC_unregister_my_thread): Don't delete the thread (just set FINISHED) if the thread is not detached (only if GC_PTHREADS); add assertion (check the thread is not finished). * tests/threadkey_test.c (main): Join some created threads. * pthread_support.c (GC_delete_gc_thread): Rename "gc_id" local variable to "t". * win32_threads.c (GC_delete_gc_thread): Likewise. * pthread_support.c (pthread_join, pthread_detach, pthread_cancel): Rename "thread_gc_id" local variable to "t". * win32_threads.c (GC_pthread_detach): Likewise. * win32_threads.c (GC_delete_gc_thread): Remove "gc_nvid" local variable. * win32_threads.c (GC_pthread_join): Rename "joinee" local variable to "t". * pthread_stop_world.c (pthread_sigmask): Undefine even if not DEBUG_THREADS. * pthread_stop_world.c (GC_unblock_gc_signals): New function (only if GC_EXPLICIT_SIGNALS_UNBLOCK). * pthread_support.c (GC_unblock_gc_signals): New prototype. * pthread_support.c (GC_register_my_thread_inner, GC_register_my_thread): Call GC_unblock_gc_signals (only if GC_EXPLICIT_SIGNALS_UNBLOCK); add comment. * include/private/gcconfig.h (GC_EXPLICIT_SIGNALS_UNBLOCK): New macro. * pthread_stop_world.c (GC_suspend_handler_inner): Remove "dummy", "sig" local variables; rename my_thread local variable to "self". * tests/threadkey_test.c (LIMIT): Use smaller value (don't create more than 30 in parallel by default). * tests/threadkey_test.c (key_once, main): Work around for Solaris PTHREAD_ONCE_INIT. * tests/threadkey_test.c (LIMIT): Use smaller value for Solaris. * dyn_load.c (GC_FirstDLOpenedLinkMap): Remove unused "r" local variable. * pthread_support.c (GC_unregister_my_thread_inner): Revert back GC_remove_specific invocation; add a comment. * include/private/thread_local_alloc.h (GC_remove_specific): Revert back. * specific.c (slow_getspecific): Cast qtid to AO_t. * include/private/specific.h (key_create, setspecific, remove_specific): Remove "extern" keyword. * include/private/specific.h (getspecific): Change type of "qtid" local variable to unsigned long. * pthread_support.c (GC_check_tls): Fix "#endif" comment. * include/gc.h (GC_REDIRECT_TO_LOCAL): Remove deprecated comment. * include/private/thread_local_alloc.h (THREAD_LOCAL_ALLOC): Remove redundant test of the macro. * backgraph.c (add_edge): Recognize DEBUG_PRINT_BIG_N_EDGES macro. * os_dep.c (GC_set_and_save_fault_handler): Recognize SIGACTION_FLAGS_NODEFER_HACK macro. * pthread_support.c (mark_mutex): Recognize GLIBC_2_1_MUTEX_HACK macro. * pthread_support.c (GC_acquire_mark_lock): Remove commented out code. * include/private/gc_priv.h (SUNOS5SIGS): Don't include sys/siginfo.h on Linux. * include/private/gcconfig.h (FORCE_WRITE_PREFETCH): New macro recognized, force PREFETCH_FOR_WRITE to be defined on x86. * include/private/gcconfig.h (USE_HPUX_FIXED_STACKBOTTOM): New macro recognized (for HP/UX). * os_dep.c (GC_gww_page_was_ever_dirty): Fix comment (for GWW_VDB). * os_dep.c (GC_dirty_init): Use memset() for GC_written_pages resetting (for PROC_VDB). * tests/threadkey_test.c: New file. * tests/tests.am (TESTS, check_PROGRAMS): Add 'threadkey_test'. * tests/tests.am (threadkey_test_SOURCES, threadkey_test_LDADD): New variable. * pthread_support.c (GC_unregister_my_thread_inner): Don't call GC_remove_specific. * include/private/thread_local_alloc.h (GC_remove_specific): Remove (since it is empty for all targets). * pthread_support.c (GC_record_stack_base): New inline function. * win32_threads.c (GC_record_stack_base): Likewise. * pthread_support.c (GC_register_my_thread_inner): Invoke GC_record_stack_base. * win32_threads.c (GC_register_my_thread_inner): Likewise. * pthread_support.c (GC_register_my_thread): If thread is FINISHED then call GC_record_stack_base, clear FINISHED, initialize thread-local list and return success. * win32_threads.c (GC_register_my_thread): Likewise. * include/gc.h (GC_register_my_thread): Update documentation. * include/private/thread_local_alloc.h (GC_thread_key): Likewise. * thread_local_alloc.c (GC_malloc, GC_malloc_atomic): Join adjacent "#ifdef". * thread_local_alloc.c (GC_malloc_atomic): Call GC_core_malloc_atomic (instead of GC_core_malloc). * pthread_start.c (GC_start_rtn_prepare_thread): Change return type to GC_thread. * pthread_start.c (GC_inner_start_routine): Pass the current thread descriptor to pthread_cleanup_push (same as in win32_threads.c). * pthread_stop_world.c (GC_push_all_stacks): Rename "me" local variable to "self". * win32_threads.c (GC_push_all_stacks): Likewise. * pthread_stop_world.c (GC_suspend_all, GC_start_world): Rename "my_thread" local variable to "self". * pthread_support.c (GC_unregister_my_thread_inner): New static function. * pthread_support.c (GC_unregister_my_thread, GC_thread_exit_proc): Use GC_unregister_my_thread_inner. * win32_threads.c (GC_register_my_thread, GC_unregister_my_thread, GC_do_blocking_inner): Rename "t" local variable to "thread_id". * win32_threads.c (GC_wait_marker, GC_notify_all_marker): Rename "id" local variable to "thread_id". * pthread_support.c (GC_unregister_my_thread): Call pthread_self only once. * win32_threads.c (GC_pthread_start_inner): Likewise. * pthread_support.c (GC_unregister_my_thread): Add debug output. * win32_threads.c (GC_unregister_my_thread): Likewise. * pthread_support.c (GC_register_my_thread, GC_start_rtn_prepare_thread): Rename "my_pthread" local variable to "self". * include/gc.h (GC_HIDE_POINTER, GC_REVEAL_POINTER): Define unconditionally (do not test GC_I_HIDE_POINTERS); update the comment. * include/gc.h (HIDE_POINTER, REVEAL_POINTER): Define as alias to GC_HIDE/REVEAL_POINTER, respectively. * include/private/gc_pmark.h (GC_I_HIDE_POINTERS): Do not define. * include/private/gc_priv.h (GC_I_HIDE_POINTERS): Likewise. * include/gc.h (GC_register_my_thread): Refine the comment. * include/gc_inline.h (GC_MALLOC_WORDS, GC_CONS): Add missing parentheses. * include/gc_typed.h (GC_get_bit, GC_set_bit, GC_CALLOC_EXPLICITLY_TYPED): Likewise. * include/private/gcconfig.h (NO_GETCONTEXT): Add missing ')'. * include/private/gcconfig.h (NO_GETCONTEXT): Do not use getcontext(2) on m68k because it is not implemented there. * alloc.c (GC_clear_a_few_frames): Use BZERO(). * mark_rts.c (GC_clear_roots, GC_rebuild_root_index): Likewise. * reclaim.c (GC_start_reclaim): Likewise. * blacklst.c (total_stack_black_listed): Remove "len" local variable. * dbg_mlc.c (GC_generate_random_valid_address): Replace "for" statement with "do-while" one. * dyn_load.c (GC_register_dynamic_libraries, GC_register_dynlib_callback): Remove redundant parentheses. * cord/cordxtra.c (CORD_from_file_lazy_inner): Suppress "unused result" compiler warning for fread(). * os_dep.c (GC_write_fault_handler): Break when in_allocd_block is set to true. * dbg_mlc.c (GC_has_other_debug_info): Change return type to int; return -1 if the object has (or had) debugging info but was marked deallocated. * include/private/dbg_mlc.h (GC_has_other_debug_info): Likewise. * dbg_mlc.c (GC_has_other_debug_info): Update documentation; remove "ohdr" local variable. * dbg_mlc.c (GC_debug_free): Don't call GC_free if the object has probably been deallocated. * dbg_mlc.c (GC_debug_free): Don't actually free the object even in the leak-finding mode if GC_findleak_delay_free. * dbg_mlc.c (GC_check_leaked): New function (only unless SHORT_DBG_HDRS). * doc/README.environment (GC_FINDLEAK_DELAY_FREE): Document. * doc/README.macros (GC_FINDLEAK_DELAY_FREE): Likewise. * include/private/dbg_mlc.h (START_FLAG, END_FLAG): Use GC_WORD_C on 64-bit architectures. * include/private/dbg_mlc.h (NOT_MARKED): Remove redundant parentheses. * include/private/dbg_mlc.h (GC_HAS_DEBUG_INFO): Update (due to GC_has_other_debug_info change). * include/private/gc_priv.h (GC_findleak_delay_free): New global variable declaration (unless SHORT_DBG_HDRS). * misc.c (GC_findleak_delay_free): New global variable; recognize GC_FINDLEAK_DELAY_FREE. * misc.c (GC_init): Recognize GC_FINDLEAK_DELAY_FREE environment variable (unless SHORT_DBG_HDRS). * reclaim.c (GC_check_leaked): Declare (unless SHORT_DBG_HDRS). * reclaim.c (GC_add_leaked): Don't add the object to leaked list if marked as deallocated. * dbg_mlc.c (GC_has_other_debug_info): Fix punctuation in the comment. * dbg_mlc.c (GC_FREED_MEM_MARKER): New macro. * dbg_mlc.c (GC_debug_free): Use GC_FREED_MEM_MARKER. * dbg_mlc.c (GC_smashed): Refine documentation. * mark.c (GC_push_selected): Change dirty_fn return type to GC_bool. * os_dep.c (GC_page_was_ever_dirty): Make GC_INNER. * reclaim.c (GC_reclaim_small_nonempty_block): Remove "kind" local variable. * reclaim.c (GC_reclaim_block): Pass true constant to GC_reclaim_small_nonempty_block (instead of report_if_found). * doc/README.autoconf: Update; fix a typo. * include/private/gcconfig.h (GC_WORD_C): New macro. * dbg_mlc.c (GC_store_debug_info_inner): Cast "linenum". * dbg_mlc.c (GC_check_annotated_obj): Fix punctuation in the comment. * dbg_mlc.c (GC_print_smashed_obj): Add (and print) "msg" argument. * dbg_mlc.c (GC_debug_free, GC_print_all_smashed_proc): Pass message to GC_print_smashed_obj. * dbg_mlc.c (GC_debug_free): Call GC_size once. * dbg_mlc.c (GC_debug_realloc): Calculate old_sz only if allocation succeeded; remove unnecessary check for object is smashed (since this is done in GC_debug_free); remove "clobbered" local variable. * dbg_mlc.c (GC_store_debug_info_inner, GC_store_debug_info): Rename "integer" argument to "linenum"; change the type of the argument to int. * gcj_mlc.c (GC_store_debug_info): Likewise. * dbg_mlc.c (GET_OH_LINENUM): New macro. * dbg_mlc.c (GC_print_obj, GC_print_smashed_obj): Use GET_OH_LINENUM; adjust print format specifier. * dbg_mlc.c (GC_debug_malloc, GC_debug_malloc_ignore_off_page, GC_debug_malloc_atomic_ignore_off_page, GC_debug_generic_malloc_inner, GC_debug_generic_malloc_inner_ignore_off_page, GC_debug_malloc_stubborn, GC_debug_malloc_atomic, GC_debug_malloc_uncollectable, GC_debug_malloc_atomic_uncollectable): Remove unnecessary cast of "i". * gcj_mlc.c (GC_debug_gcj_malloc): Likewise. * os_dep.c (GC_linux_stack_base): Rename to GC_linux_main_stack_base. * os_dep.c (GC_freebsd_stack_base): Rename to GC_freebsd_main_stack_base; adjust error message. * pthread_stop_world.c (GC_stop_init): Use GC_SEM_INIT_PSHARED as an argument for sem_init(). * pthread_support.c (pthread_create): Likewise. * pthread_support.c (pthread_create): Abort in case sem_init() fails. * include/private/gc_priv.h (GC_SEM_INIT_PSHARED): Define. * tests/initsecondarythread.c: Include gcconfig.h; call GC_INIT from main() if it should be done from the primordial thread only. * alloc.c: Don't include sys/types.h for ArmCC. * dyn_load.c: Likewise. * os_dep.c: Likewise. * mach_dep.c (_setjmp, _longjmp): Redirect to setjmp/longjmp for ArmCC. * mark.c (GC_noop): Define specially for ArmCC. * include/private/gc_priv.h (GC_noop): Likewise. * misc.c (GC_init): Don't test pointers comparison for ArmCC. * misc.c: Don't include unistd.h for ArmCC. * os_dep.c (pages_executable): Rename to GC_pages_executable; make STATIC. * os_dep.c (GC_unix_mmap_get_mem): Don't define for ArmCC. * ptr_chck.c (GC_is_visible): Explicitly cast (GC_DS_PER_OBJECT-GC_INDIR_PER_OBJ_BIAS) to word (to suppress a compiler warning). * include/private/gcconfig.h: Recognize __arm. * include/private/gcconfig.h (HBLKPTR): Define for ArmCC. * include/private/gcconfig.h (HBLKPTR): Add parentheses for "bytes" argument. * pthread_support.c (GC_get_nprocs): Don't define for Android. * pthread_support.c (GC_dummy_thread_local): Don't test GC_LINUX_THREADS. * include/gc_config_macros.h (GC_ADD_CALLER, GC_RETURN_ADDR): Define for Android. * mach_dep.c (NO_GETCONTEXT): Move to gcconfig.h. * os_dep.c (GC_write_fault_handler): Don't include ucontext.h if NO_GETCONTEXT. * include/private/gcconfig.h (GETPAGESIZE): Define as a sysconf call for Android. * include/private/gc_locks.h (WIN32_LEAN_AND_MEAN, NOSERVICE): Define before including windows.h. * include/private/gc_priv.h (WIN32_LEAN_AND_MEAN, NOSERVICE): Likewise. * include/private/thread_local_alloc.h (WIN32_LEAN_AND_MEAN, NOSERVICE): Likewise. * include/private/gc_priv.h (MS_TIME_DIFF): Avoid floating-point arithmetics; add a comment. * mark.c (GC_clear_hdr_marks): Don't test USE_MARK_BYTES. * extra/setjmp_t.c (main): Don't test USE_MARK_BITS. * include/private/gc_pmark.h (SET_MARK_BIT_EXIT_IF_SET): Likewise. * include/private/gc_pmark.h (SET_MARK_BIT_EXIT_IF_SET): Remove "mark_byte" local variable. * include/private/gc_pmark.h (OR_WORD_EXIT_IF_SET): Add a comment about that AO_or() is not used by GC unless USE_MARK_BITS explicitly set. * include/private/gc_priv.h (OR_WORD): Likewise. * include/private/gc_pmark.h (INCR_MARKS): Remove trailing ';', add parentheses. * include/private/gc_priv.h (ONES): Define before use by MAKE_COOLER. * include/private/gc_priv.h (MARK_BITS_SZ): Define where used. * include/private/gc_priv.h (OR_WORD): Don't define if USE_MARK_BYTES. * include/private/gcconfig.h (USE_MARK_BYTES); Remove duplicate definition; simplify expression. * os_dep.c (GC_get_maps): Always close the file. * pthread_support.c (GC_get_nprocs): Likewise. * os_dep.c (READ): Define similarly across the file (without parameters). * pthread_support.c (GC_get_nprocs): Use signed int type for "i" and "len" local variables (since read() may return -1). * include/private/gc_pmark.h (LONG_MULT): Add prefix/suffix double underscore; add "volatile" for asm. * include/private/gc_pmark.h (LONG_MULT): Add missing parentheses. * include/private/gc_priv.h (OR_WORD): Likewise. * include/private/gc_priv.h (OR_WORD): Remove unnecessary brackets and ';' symbol. * os_dep.c (GC_get_stack_base): Implement for Android (same as for Linux). * pthread_support.c (GC_get_nprocs): Return 1 (instead of -1) if failed to open "stat" file (not to issue a warning twice); update the comment. * pthread_support.c (GC_thr_init): Call sysconf() on Android to get the number of CPUs. * include/private/gc_priv.h (_GNU_SOURCE): Revert one of the recent patches regarding this macro as the macro should be set (to 1) before including any other system header. * doc/README.environment (GC_INITIAL_HEAP_SIZE, GC_MAXIMUM_HEAP_SIZE): Update. * misc.c (GC_parse_mem_size_arg): Allow 'k', 'M', 'G' suffixes in heap size specifier; return 0 if not a valid one. * include/gc_cpp.h: Explicitly define inline one-argument delete operator for Cygwin (as a workaround). * tests/test_cpp.cc (main): Suppress compiler warnings about "assigned value is unused". * misc.c (GC_parse_mem_size_arg): New function. * misc.c (GC_init): Use GC_parse_mem_size_arg(). * pthread_stop_world.c (tkill): Declare for Android. * include/private/gc_priv.h (_GNU_SOURCE): Include features.h first (except for NaCl) and then define the macro to 1 if not yet. * tests/tests.am (TESTS, check_PROGRAMS): Add 'initsecondarythread'. * tests/tests.am (initsecondarythread_SOURCES, initsecondarythread_LDADD): New variable. * dbg_mlc.c (GC_store_debug_info_inner): Always define; add "const" to its string argument. * dbg_mlc.c (GC_store_debug_info): Call GC_store_debug_info_inner. * dbg_mlc.c (GC_debug_free): Set GC_have_errors in case of smashed or previously deallocated found. * dbg_mlc.c (GC_check_heap_block): Replace while loop with a for one. * reclaim.c (GC_reclaim_check): Likewise. * dbg_mlc.c (GC_check_heap_proc): Remove redundant cast to word. * os_dep.c (GC_get_stack_base): Don't initialize stackbase_main_self/ss_sp on Solaris if thr_main() is zero (thus calling GC_INIT() from a non-primordial thread is possible now). * reclaim.c (GC_add_leaked): Turn into an inline one. * reclaim.c (GC_reclaim_small_nonempty_block): Change report_if_found type from int/word to boolean. * include/private/gc_priv.h (GC_start_reclaim): Likewise. * include/private/gc_priv.h (set_mark_bit_from_hdr, clear_mark_bit_from_hdr): Place closing parenthesis properly. * os_dep.c (GC_get_main_stack_base): Try to use pthread_attr_getstack first for Linux if THREADS. * doc/README.macros (USE_GET_STACKBASE_FOR_MAIN): Adjust text alignment. * dbg_mlc.c (GC_generate_random_backtrace_no_gc): Fix a message typo. * dbg_mlc.c (GC_debug_malloc): Add a comment (about zero size). * dbg_mlc.c (GC_strdup): Call GC_err_printf instead of WARN (in case of NULL argument). * dbg_mlc.c (GC_free): In case of NULL argument, just return (without any warning printed); eliminate "uncollectable" local variable. * configure.ac (THREADDLLIBS): Use alternate thread library on Solaris 8. * configure.ac (need_atomic_ops_asm): Set to true only for SPARC Solaris. * configure.ac: Don't use libdl on mips-sgi-irix6. * mach_dep.c (NO_GETCONTEXT); Define for RTEMS. * mach_dep.c (GC_with_callee_saves_pushed): Don't call __builtin_unwind_init() for RTEMS; use setjmp() without the leading underscore (for RTEMS). * tests/test.c (BIG): Use smaller value for RTEMS. * tests/test.c (main): Customize for RTEMS. * configure.host: Remove doubled words in comments. * os_dep.c: Likewise. * doc/README: Likewise. * extra/setjmp_t.c: Likewise. * tests/huge_test.c: Likewise. * extra/setjmp_t.c (getpagesize, nested_sp, main, g): Replace the K&R-style function definition with the ANSI C one. * extra/setjmp_t.c (nested_sp): Implement in the same way as GC_approx_sp. * dyn_load.c (GC_dyld_sections): Add more sctions. * dyn_load.c (GC_dyld_add_sect_fmts): New static varaible. * dyn_load.c (L2_MAX_OFILE_ALIGNMENT): New macro. * dyn_load.c (GC_dyld_image_add, GC_dyld_image_remove): Improve logging; add support for on-demand sections. * gcj_mlc.c (GC_gcj_malloc_initialized): Use STATIC unless GC_ASSERTIONS. * include/private/gc_priv.h (GC_gcj_malloc_initialized): Don't declare (as external) unless GC_ASSERTIONS. * os_dep.c (GC_win32_free_heap): Clear GC_heap_bases[] also for Cygwin; add FIXME. * include/private/gcconfig.h: Include for RTEMS. * include/private/gcconfig.h: Add "#error" for every "-->" mark. * include/private/gcconfig.h (CLEAR_DOUBLE): Turn the code into an expression. * include/private/pthread_support.h (SUSPENDED_EXT): Add new flag (which existed previously as SUSPENDED and still exists in GCJ). * include/private/pthread_support.h (DISABLED_GC): Change the value (as it is already used by SUSPENDED_EXT). * tests/test.c (reverse_test): Modify count (BIG) for ppc64-darwin. * reclaim.c (GC_print_all_errors): Recognize new GC_ABORT_ON_LEAK macro and environment variable; abort if any error has been printed provided the environment variable (or macro) is set. * doc/README.environment (GC_ABORT_ON_LEAK): Document. * doc/README.macros (GC_ABORT_ON_LEAK): Likewise. * os_dep.c (GC_unix_sbrk_get_mem, GC_unix_get_mem): Don't define for RTEMS. * include/private/gcconfig.h (RTEMS): Add support for. * include/private/gcconfig.h (GET_MEM): Use calloc() for RTEMS. * mallocx.c (GC_malloc_uncollectable): Move to malloc.c (since it is used internally in some places). * dbg_mlc.c (GC_register_finalizer_no_order): Remove redundant declaration. * dbg_mlc.c (GC_debug_malloc_replacement, GC_debug_realloc_replacement): Rename RA to GC_DBG_RA. * malloc.c (GC_debug_malloc_replacement): Likewise. * mallocx.c (GC_debug_realloc_replacement): Likewise. * dbg_mlc.c (GC_store_debug_info): Move proto from dbg_mlc.h. * malloc.c (GC_strdup, GC_strndup, GC_wcsdup): Move to mallocx.c. * malloc.c: Include errno.h only REDIRECT_MALLOC; remove redundant includes of string.h. * mallocx.c: Include string.h (for GC_strdup). * include/private/dbg_mlc.h (GC_store_debug_info): Move declaration to dbg_mlc.c. * include/private/gc_locks.h (UNCOND_LOCK, UNCOND_UNLOCK): Remove redundant trailing ';'. * include/private/gc_priv.h (START_WORLD, COND_DUMP): Likewise. * include/private/gc_locks.h (LOCK, UNLOCK): Place opening '{' properly. * include/private/gc_priv.h (GC_DBG_RA): Move from dbg_mlc.c, malloc.c, mallocx.c. * alloc.c (GC_check_heap, GC_print_all_smashed): Move the definition from misc.c. * dbg_mlc.c (GC_debug_malloc_atomic_uncollectable): Define as public. * include/gc.h (GC_debug_malloc_atomic_uncollectable): Declare. * include/gc.h (GC_MALLOC_ATOMIC_UNCOLLECTABLE): Define new public macro. * dbg_mlc.c (MAX_SMASHED): Don't define if already set. * reclaim.c (MAX_LEAKED): Likewise. * dbg_mlc.c (GC_add_smashed): Add FIXME about the concurrent access to the global array. * reclaim.c (GC_add_leaked): Likewise. * misc.c (GC_print_back_height): Set on if GC_PRINT_BACK_HEIGHT (new macro) is defined. * doc/README.macros (GC_PRINT_BACK_HEIGHT): Document. * misc.c (GC_dump_regularly, GC_init): Replace 0/1 for GC_dump_regularly and GC_print_back_height variables with FALSE/TRUE. * reclaim.c (GC_print_all_errors): Refine the comment. * tests/test.c (reverse_test_inner): Undo one of the previous patches which shifts "c" and "d" pointers only if ALL_INTERIOR_POINTERS (since interior pointers are always recognized in stacks). * misc.c (GC_stdout, GC_stderr): Move the definition to the place where GC_log is defined (Unix only). * misc.c (GC_init): Recognize "GC_ONLY_LOG_TO_FILE" environment variable and the similar macro; redirect GC_stdout and GC_stderr to GC_log if "GC_LOG_FILE" environment variable is set unless prohibited by GC_ONLY_LOG_TO_FILE (Unix only). * doc/README.environment (GC_ONLY_LOG_TO_FILE): Document. * doc/README.macros (GC_ONLY_LOG_TO_FILE): Likewise. * misc.c (GC_stdout, GC_write): Rename GC_stdout to GC_log (Win32 only). * misc.c (GC_write): Add for MacOS (and OS/2); change WRITE() accordingly. * misc.c (GC_printf): Check GC_quiet before va_start(). * allchblk.c (GC_freehblk): Use GC_log_printf instead of GC_printf inside "if (GC_print_stats)" branch. * alloc.c (GC_collect_or_expand): Likewise. * dyn_load.c (GC_register_dynamic_libraries): Likewise. * headers.c (GC_scratch_alloc): Likewise. * os_dep.c (GC_get_maps, GC_remap, PROTECT, GC_write_fault_handler, GC_dirty_init, GC_mprotect_thread): Likewise. * alloc.c (min_bytes_allocd): Use GC_log_printf instead of GC_printf for DEBUG_THREADS output. * darwin_stop_world.c (GC_stack_range_for, GC_suspend_thread_list, GC_stop_world, GC_thread_resume, GC_start_world): Likewise. * pthread_start.c (GC_inner_start_routine): Likewise. * pthread_stop_world.c (GC_suspend_handler, GC_restart_handler, GC_push_all_stacks, GC_suspend_all, GC_stop_world, GC_start_world): Likewise. * pthread_support.c (GC_mark_thread, GC_get_nprocs, GC_start_rtn_prepare_thread, pthread_create): Likewise. * checksums.c (GC_update_check_page): Use GC_printf() instead of GC_err_printf() for error printing. * checksums.c (GC_check_blocks, GC_check_dirty): Use GC_log_printf instead of GC_printf for logging purposes. * dyn_load.c (sys_errlist, sys_nerr, errno): Move declaration of external variable outside from GC_register_dynamic_libraries. * dyn_load.c (GC_register_dynamic_libraries): Don't use sys_errlist value if errno equals to sys_nerr. * dyn_load.c (GC_register_dynamic_libraries): Use GC_log_printf instead of GC_printf for DL_VERBOSE output. * dyn_load.c (GC_dyld_image_add, GC_dyld_image_remove, GC_init_dyld): Use GC_log_printf instead of GC_printf for DARWIN_DEBUG output. * os_dep.c (catch_exception_raise): Use GC_log_printf instead of GC_printf for DEBUG_EXCEPTION_HANDLING output. * reclaim.c (GC_print_free_list): Move "n" increment out of GC_printf() call. * win32_threads.c (DEBUG_CYGWIN_THREADS, DEBUG_WIN32_PTHREADS, DEBUG_WIN32_THREADS): Remove. * win32_threads.c (GC_register_my_thread_inner, GC_win32_start_inner): Use GC_log_printf instead of GC_printf inside "if (GC_print_stats)" branch. * win32_threads.c (GC_PTHREAD_PTRVAL): New macro (defined only if GC_PTHREADS). * win32_threads.c (GC_delete_gc_thread, NUMERIC_THREAD_ID, GC_pthread_join, GC_pthread_create): Use GC_PTHREAD_PTRVAL macro. * win32_threads.c (GC_push_stack_for, GC_mark_thread, GC_CreateThread, GC_beginthreadex, GC_pthread_join, GC_pthread_create, GC_pthread_start_inner, GC_thread_exit_proc, GC_mark_thread_local_free_lists): Use GC_log_printf instead of GC_printf for DEBUG_THREADS output. * win32_threads.c (GC_win32_start_inner, GC_CreateThread, GC_beginthreadex, GC_pthread_join, GC_pthread_create, GC_pthread_start_inner, GC_thread_exit_proc): Cast GetCurrentThreadId result to long; don't cast value of pthread_t type to int; adjust printf format specifiers. * doc/README.win32 (DEBUG_WIN32_PTHREADS): Remove obsolete information. * tests/test.c (cons, small_cons, gcj_cons, check_ints, check_uncollectable_ints, print_int_list, check_marks_int_list, fork_a_thread, finalizer, mktree, chktree, alloc8bytes, alloc_small, tree_test, typed_test, check_heap_stats, WinMain, test, main): Remove unnecessary casts of GC_printf calls to void. * allchblk.c (GC_print_hblkfreelist): Adjust (make uniform across BDWGC) printed message (adjust letters case, terminating dot and new line symbols). * alloc.c (GC_check_fl_marks): Likewise. * backgraph.c (new_back_edges): Likewise. * checksums.c (GC_check_dirty): Likewise. * darwin_stop_world.c (GC_push_all_stacks, GC_suspend_thread_list): Likewise. * dbg_mlc.c (GC_print_type, GC_debug_free, GC_debug_realloc, store_old): Likewise. * dyn_load.c (GC_register_dynamic_libraries): Likewise. * mark.c (GC_initiate_gc, GC_mark_some, GC_mark_from, GC_push_all, GC_push_selected, GC_push_next_marked_dirty): Likewise. * mark_rts.c (GC_exclude_static_roots_inner): Likewise. * os_dep.c (GC_remap, GC_default_push_other_roots, GC_push_thread_structures, GC_dirty_init, GC_read_dirty, catch_exception_raise_state, catch_exception_raise_state_identity, GC_mprotect_thread_notify, GC_mprotect_thread, catch_exception_raise): Likewise. * pthread_stop_world.c (GC_print_sig_mask, GC_push_all_stacks, GC_stop_world, GC_stop_init): Likewise. * pthread_support.c (GC_thr_init, GC_register_my_thread_inner, GC_start_routine): Likewise. * win32_threads.c (GC_register_my_thread_inner, GC_push_all_stacks, GC_win32_start_inner, GC_pthread_join, GC_pthread_start_inner): Likewise. * alloc.c (GC_expand_hp_inner): Realign the code. * mark.c (GC_mark_from, GC_mark_local, GC_do_parallel_mark): Likewise. * misc.c (GC_init): Likewise. * os_dep.c (GC_dirty_init, GC_read_dirty): Likewise. * include/private/gc_pmark.h (PUSH_CONTENTS_HDR): Likewise. * tests/test.c (run_one_test): Likewise. * misc.c (GC_err_puts): Document. * misc.c (GC_err_write): Remove. * os_dep.c (dump_maps): Likewise. * include/private/gc_priv.h (GC_err_write): Likewise. * os_dep.c (GC_print_address_map): Call GC_err_puts() instead of dump_maps() and GC_err_write(). * os_dep.c (GC_read_dirty): Remove redundant brackets. * tests/test.c (reverse_test_inner): Test interior pointer recognition only if ALL_INTERIOR_POINTERS. * tests/test.c (run_one_test): Replace GC_all_interior_pointers with GC_get_all_interior_pointers(); simplify the expression. * tests/test.c (check_heap_stats): Replace GC_bytes_allocd and GC_bytes_allocd_before_gc with GC_get_total_bytes(). * tests/test.c (main): Replace GC_gc_no with GC_get_gc_no(). * dbg_mlc.c (GC_debug_strdup, GC_debug_free): Output a portability warning if the argument is NULL and GC is in leaks detection mode. * dbg_mlc.c (GC_debug_strndup, GC_debug_wcsdup): New public function definition. * malloc.c (GC_strndup, GC_wcsdup, strndup): Likewise. * mallocx.c (GC_posix_memalign): Likewise. * malloc.c (strdup): Fix string size value; rename "len" to "lb". * mallocx.c: Include errno.h unless WinCE (otherwise include windows.h for Win32 error constants). * win32_threads.c: Define WIN32_LEAN_AND_MEAN and NOSERVICE before windows.h inclusion. * misc.c (GC_init): Register at-exit callback if GC_find_leak (even if GC_FIND_LEAK macro is unset). * pthread_stop_world.c (NACL_STORE_REGS, __nacl_suspend_thread_if_needed, GC_nacl_initialize_gc_thread): Use BCOPY() instead of memcpy(). * pthread_support.c (GC_init_real_syms): Likewise. * doc/README.macros (GC_DEBUG_REPLACEMENT, GC_REQUIRE_WCSDUP): Document new macro. * doc/README.macros (REDIRECT_MALLOC): Update documentation. * include/gc.h (GC_strndup, GC_posix_memalign, GC_debug_strndup): New API function prototype. * include/gc.h (GC_MALLOC, GC_REALLOC): Redirect to GC_debug_malloc/realloc_replacement() if GC_DEBUG_REPLACEMENT. * include/gc.h (GC_STRDUP): Remove redundant parentheses. * include/leak_detector.h (realloc, strdup): Likewise. * include/gc.h (GC_STRNDUP): New API macro. * include/gc.h (GC_NEW, GC_NEW_ATOMIC, GC_NEW_STUBBORN, GC_NEW_UNCOLLECTABLE): Add missing parentheses. * include/gc.h (GC_wcsdup, GC_debug_wcsdup): New API function prototype (only if GC_REQUIRE_WCSDUP). * include/gc.h (GC_WCSDUP): New API macro (only if GC_REQUIRE_WCSDUP). * include/leak_detector.h: Include stdlib.h and string.h after gc.h (unless GC_DONT_INCLUDE_STDLIB). * include/leak_detector.h (malloc, calloc, free, realloc): Undefine symbol before its redefinition. * include/leak_detector.h (strndup, memalign, posix_memalign): Redefine to the corresponding GC function. * include/leak_detector.h (wcsdup): Redefine to GC_WCSDUP (only if GC_REQUIRE_WCSDUP). * include/leak_detector.h (CHECK_LEAKS): Add comment; don't define the macro if already defined. * misc.c (GC_abort): Use _exit() (instead of DebugBreak) on Win32 when doing code static analysis (to inform the tool that the function is a no-return one). * os_dep.c (GC_linux_stack_base): Remove a duplicate validation of the length of "stat" file; use signed int type for "i", "buf_offset" and "len" local variables (since read() may return -1). * blacklst.c (GC_bl_init_no_interiors): New function (the code moved from GC_bl_init). * blacklst.c (GC_bl_init): Invoke GC_bl_init_no_interiors unless GC_all_interior_pointers mode; remove unnecessarily parameter cast for GC_scratch_alloc call. * include/private/gc_priv.h (GC_bl_init): Move the function declaration to misc.c file. * misc.c (GC_bl_init_no_interiors): Add a prototype. * misc.c (GC_set_all_interior_pointers): Allow values other than 0 and 1; allow altering GC_set_all_interior_pointers value even after GC initialization. * obj_map.c (GC_initialize_offsets): Clear GC_valid_offsets and GC_modws_valid_offsets if GC_all_interior_pointers is off. * misc.c (GC_init): Don't call GC_initialize_offsets() unless GC_all_interior_pointers mode. * alloc.c (GC_finish_collection): Remove redundant brackets; adjust code indentation. * blacklst.c (GC_add_to_black_list_normal): Simplify expression (to improve code readability). * blacklst.c (GC_is_black_listed): Join nested "if" (into a single conditional expression); initialize "nblocks" just before the loop beginning. * misc.c (GC_init): Don't compute initial_heap_sz if GC is already initialized. * include/private/gc_priv.h (GC_initialize_offsets): Move the function declaration to misc.c file. * obj_map.c (GC_initialize_offsets): Remove offsets_initialized static variable since the function is called only once. * tests/middle.c (main): Use setter for GC_all_interior_pointers; adjust printf format specifier (and cast the value passed to). * doc/README.macros (SMALL_CONFIG, LARGE_CONFIG): Refine the documentation. * include/private/gc_hdrs.h (LOG_BOTTOM_SZ): Ignore SMALL_CONFIG if LARGE_CONFIG is defined. * include/private/gc_priv.h (CPP_LOG_HBLKSIZE): Likewise. * alloc.c (GC_finish_collection): Replace "#else #ifdef" with "#elif". * include/private/gc_priv.h (CPP_LOG_HBLKSIZE, LOG_PHT_ENTRIES, MAX_ROOT_SETS, MAX_HEAP_SECTS): Likewise. * alloc.c (GC_expand_hp_inner): Check for GC_collect_at_heapsize overflow even if not LARGE_CONFIG. * dbg_mlc.c (GC_check_heap_proc): Check "oh" size even if SMALL_CONFIG. * finalize.c (GC_print_finalization_stats): Fix "#endif" comment. * doc/README.environment (GC_LOG_FILE, GC_PRINT_VERBOSE_STATS, GC_FULL_FREQUENCY): Refine the documentation. * extra/msvc_dbg.c: Test _MSC_VER macro; include "gc.h" (for GC_word). * extra/msvc_dbg.c (ULONG_PTR): Replace with GC_ULONG_PTR; define as word. * dbg_mlc.c (GC_get_back_ptr_info, GC_print_obj, GC_print_smashed_obj, GC_debug_free_inner): Add a code for a LINT-like tool to instruct it that the function is invoked only with valid parameters (otherwise a SEGV is ok); recognize LINT2 new macro. * misc.c (GC_abort): Instruct a LINT-like tool that the function never returns in fact. * os_dep.c (GC_linux_stack_base): Check for read buffer overflow; close the file immediately after read; use STRTOULL() instead of decoding the address number manually. * include/private/gc_priv.h (EXPECT): Don't specify outcome for a LINT-like tool. * include/private/gc_priv.h (GC_all_interior_pointers): Instruct a LINT-like tool that the value is restricted to zero and one only (required since the variable is global and its value is used as a part of array index expression is some places). * dbg_mlc.c (GC_make_closure): Fix SEGV in case GC_malloc returns NULL. * dbg_mlc.c (GC_debug_register_finalizer, GC_debug_register_finalizer_no_order, GC_debug_register_finalizer_unreachable, GC_debug_register_finalizer_ignore_self): Handle out of memory case properly (similar to GC_register_finalizer_inner). * headers.c (GC_install_header): Handle the case when alloc_hdr() returns NULL. * os_dep.c (GC_get_maps_len): Defend against missing "maps" file. * pthread_support.c (GC_mark_thread): Place a dummy return statement (which uses "id" argument) before the actual use of "id" as an array index (to suppress a warning produced by some static code analysis tools). * win32_threads.c (GC_mark_thread): Likewise. * pthread_support.c (GC_thr_init): Abort (with the appropriate message) if out of memory. * finalize.c (GC_register_finalizer_inner): Fix a typo in a comment. *include/private/gcconfig.h (STACKBOTTOM): Likewise. * gcj_mlc.c (GC_core_gcj_malloc): Replace 0/1 with TRUE/FALSE in EXPECT (the 2nd argument). * malloc.c (GC_core_malloc_atomic, GC_core_malloc, GC_free): Likewise. * mark.c (GC_mark_and_push, GC_mark_and_push_stack): Likewise. * thread_local_alloc.c (GC_malloc, GC_malloc_atomic): Likewise. * include/private/gc_hdrs.h (HC_GET_HDR): Likewise. * include/private/gc_priv.h (SMALL_OBJ): Likewise. * include/private/specific.h (getspecific): Likewise. * pthread_support.c (LOCK_STATS): Add a comment. * include/gc_pthread_redirects.h (GC_NO_DLOPEN, GC_NO_PTHREAD_SIGMASK, GC_PTHREAD_CREATE_CONST, GC_PTHREAD_EXIT_ATTRIBUTE, GC_NO_PTHREAD_CANCEL): Move the definition to gc_config_macros. * pthread_support.c (pthread_cancel, GC_pthread_cancel_t, GC_pthread_cancel): Test GC_NO_PTHREAD_CANCEL (instead of NACL and GC_PTHREAD_EXIT_ATTRIBUTE). * include/gc_pthread_redirects.h (GC_pthread_cancel, pthread_cancel): Likewise. * pthread_support.c (GC_pthread_create, GC_pthread_sigmask, GC_pthread_join, GC_pthread_detach, GC_pthread_cancel): Realign code. * include/gc_pthread_redirects.h (GC_PTHREAD_EXIT_ATTRIBUTE): Define as empty for NaCl. * include/gc_pthread_redirects.h (GC_NO_PTHREAD_CANCEL): New macro defined. * dyn_load.c (GC_init_dyld): Do not invoke _dyld_bind_fully_image_containing_address() if GC_no_dls (as it is not required to register the main data segment in that case). * include/gc.h (GC_no_dls): Adjust the comment. * dyn_load.c (GC_MUST_RESTORE_REDEFINED_DLOPEN): Test GC_NO_DLOPEN. * gc_dlopen.c: Likewise. * include/gc_pthread_redirects.h (GC_dlopen, dlopen): Likewise. * gc_dlopen.c: Don't include dlfcn.h (as it is included in gc_pthread_redirects.h). * pthread_support.c (pthread_sigmask, GC_pthread_sigmask_t, GC_pthread_sigmask): Test GC_NO_PTHREAD_SIGMASK (instead of GC_DARWIN_THREADS, GC_OPENBSD_THREADS and NACL). * include/gc_pthread_redirects.h (GC_pthread_sigmask, pthread_sigmask): Likewise. * win32_threads.c (pthread_sigmask, GC_pthread_sigmask): Test GC_NO_PTHREAD_SIGMASK (instead of GC_WIN32_PTHREADS). * pthread_support.c (pthread_create, GC_pthread_create_t, GC_pthread_create): Rename GC_PTHREAD_CONST to GC_PTHREAD_CREATE_CONST. * win32_threads.c (GC_pthread_create): Likewise. * include/gc_pthread_redirects.h: Likewise. * include/gc_pthread_redirects.h (GC_NO_DLOPEN, GC_NO_PTHREAD_SIGMASK): New macro defined. * include/gc_pthread_redirects.h (GC_PTHREAD_CREATE_CONST): Set to empty for NaCl. * include/gc_pthread_redirects.h (GC_PTHREAD_EXIT_ATTRIBUTE): Do not define for Android (as CANCEL_SAFE is not defined). * include/gc.h (GC_ADD_CALLER, GC_RETURN_ADDR, GC_HAVE_BUILTIN_BACKTRACE, GC_CAN_SAVE_CALL_STACKS): Move definition to gc_config_macros.h file. * include/gc_config_macros.h: Check the file is included from gc.h file. * include/gc_version.h: Likewise. * gc_dlopen.c: Empty unit for NaCl. * os_dep.c: Include fcntl.h for NaCl. * os_dep.c (GC_get_main_stack_base): Ignore USE_GET_STACKBASE_FOR_MAIN macro for NaCl. * os_dep.c (GC_get_stack_base): Return GC_UNIMPLEMENTED for NaCl. * os_dep.c (GC_remap): Use mmap (instead of mprotect) for NaCl. * pthread_start.c (GC_inner_start_routine): Don't invoke pthread_cleanup_push/pop for NaCl. * pthread_stop_world.c (GC_nacl_num_gc_threads, GC_nacl_thread_idx, GC_nacl_park_threads_now, GC_nacl_thread_parker, GC_nacl_gc_thread_self, GC_nacl_thread_parked, GC_nacl_thread_used, GC_nacl_thread_parking_inited, GC_nacl_thread_alloc_lock): New variable (fo NaCl only). * pthread_stop_world.c (GC_remove_allowed_signals, suspend_handler_mask, GC_stop_count, GC_world_is_stopped, GC_retry_signals, SIG_THR_RESTART, GC_suspend_ack_sem, GC_restart_ack_sem, GC_suspend_handler_inner, GC_suspend_handler, GC_restart_handler): Don't define for NaCl. * pthread_support.c (GC_get_nprocs): Likewise. * include/private/gc_priv.h (SIG_SUSPEND): Likewise. * include/private/gcconfig.h (LINUX): Likewise. * pthread_stop_world.c (GC_push_all_stacks): Push register storage for NaCl. * pthread_stop_world.c (GC_suspend_all, GC_stop_world, GC_start_world): Implement for NaCl. * pthread_stop_world.c (GC_stop_world): Don't define unused "i" local variable for OpenBSD (and NaCl). * pthread_stop_world.c (NACL_STORE_REGS): New macro definition for NaCl. * pthread_stop_world.c (nacl_pre_syscall_hook, __nacl_suspend_thread_if_needed, nacl_post_syscall_hook, GC_nacl_initialize_gc_thread, GC_nacl_shutdown_gc_thread): New function (for NaCl only). * pthread_stop_world.c (GC_stop_init): Empty for NaCl. * pthread_support.c (pthread_cancel, pthread_sigmask): Don't redirect for NaCl. * include/gc_pthread_redirects.h (pthread_cancel, pthread_sigmask): Likewise. * pthread_support.c (GC_nacl_initialize_gc_thread, GC_nacl_shutdown_gc_thread): New internal prototype (NaCl only). * pthread_support.c (GC_new_thread, GC_delete_thread): Initialize and shutdown thread for NaCl. * pthread_support.c (GC_thr_init): Call sysconf for NaCl. * pthread_support.c (GC_pthread_exit): Call GC_thread_exit_proc for NaCl. * include/gc.h: Don't include features.h for NaCl. * include/gc_pthread_redirects.h (GC_PTHREAD_CONST): New macro. * include/gc_pthread_redirects.h (GC_pthread_create): Use GC_PTHREAD_CONST instead of const. * win32_threads.c (GC_pthread_create): Likewise. * pthread_support.c (GC_pthread_create_t, GC_pthread_create, pthread_create): Likewise. * include/private/gcconfig.h (NACL): Recognize NaCl. * include/private/gcconfig.h (GC_LINUX_THREADS): Valid for NaCl. * include/private/pthread_stop_world.h (thread_stop_info): Add reg_storage member; define NACL_GC_REG_STORAGE_SIZE macro (for NaCl only). * include/private/pthread_support.h (GC_nacl_gc_thread_self): Declare internal variable (for NaCl only). * mach_dep.c (GC_with_callee_saves_pushed): Fix FE_ALL_EXCEPT macro. * mark.c (GC_mark_some): Prefix and suffix "asm" and "volatile" keywords with double underscore. * os_dep.c (catch_exception_raise, catch_exception_raise_state, catch_exception_raise_state_identity): Add GC_API_OSCALL to function definition. * os_dep.c (catch_exception_raise_state, catch_exception_raise_state_identity): Move definition to be before GC_ports. * os_dep.c (catch_exception_raise): Declare to have the symbol defined before GC_ports. * os_dep.c (GC_ports): Store references to catch_exception_raise, catch_exception_raise_state, catch_exception_raise_state_identity (to prevent stripping these symbols as dead). * os_dep.c (catch_exception_raise, catch_exception_raise_state, catch_exception_raise_state_identity): Mark these symbols as "referenced dynamically" via an assembler directive (unless NO_DESC_CATCH_EXCEPTION_RAISE). * include/private/gc_priv.h (GC_API_OSCALL): New macro (defined similar to GC_API but as if GC_DLL is always defined). * os_dep.c: Don't include signal.h for GC_write_fault_handler on Win32. * os_dep.c (SIG_OK): Don't return true unless SIGSEGV or SIGBUS on FreeBSD. * os_dep.c (CODE_OK): Use SEGV_ACCERR on FreeBSD (define SEGV_ACCERR for older FreeBSD releases). * dyn_load.c (GC_register_map_entries, GC_register_dynamic_libraries_dl_iterate_phdr): Calculate DATASTART only once if DATASTART_IS_FUNC. * dyn_load.c (GC_register_dynamic_libraries_dl_iterate_phdr): Calculate DATAEND only once if DATAEND_IS_FUNC. * dyn_load.c: Add comment to some endif; realign some code. * dyn_load.c (GC_init_dyld): Don't use _dyld_bind_fully_image_containing_address if NO_DYLD_BIND_FULLY_IMAGE defined; add FIXME. * include/private/gcconfig.h (GC_data_start, GC_find_limit): Declare if used by DATASTART/DATAEND, respectively. * include/private/gcconfig.h (DATASTART_IS_FUNC, DATAEND_IS_FUNC): Define if DATASTART/DATAEND is a function, respectively. * include/private/gcconfig.h (GETPAGESIZE, NO_PTHREAD_TRYLOCK, NO_DYLD_BIND_FULLY_IMAGE): Define for Darwin/arm as well; include unistd.h. * os_dep.c (GC_setpagesize, GC_task_self, PROTECT, UNPROTECT): Reorder to remove redundant ifdef for Win32. * os_dep.c: Add comment to some endif. * os_dep.c: Include pthread.h (for Linux even if single-threaded) if USE_GET_STACKBASE_FOR_MAIN; also include it for Darwin. * os_dep.c (STACKBOTTOM): Redefine for Darwin (unless prohibited for some reason). * os_dep.c (GC_get_main_stack_base): Allow USE_GET_STACKBASE_FOR_MAIN for Linux even if single-threaded; add assertion for the returned result. * os_dep.c (GC_get_stack_base): Define for Darwin if multi-threaded. * os_dep.c (SIG_OK, CODE_OK): Add comment (for FreeBSD). * os_dep.c (ID_STOP, ID_RESUME): Define only if threads. * os_dep.c (catch_exception_raise): Remove redundant parentheses; refine the documentation. * NT_MAKEFILE: Define _CRT_SECURE_NO_DEPRECATE for C++ files as well. * NT_STATIC_THREADS_MAKEFILE: Likewise. * doc/README.macros (USE_GET_STACKBASE_FOR_MAIN): Refine. * include/gc.h (GC_INIT): Document. * include/private/gc_priv.h (GC_MACH_HEADER, GC_MACH_SECTION, GC_GETSECTBYNAME): Define depending only on the word size (i.e., define these macros also for ARM). * tests/test.c (check_heap_stats): Print main thread stack bottom as well (only if verbose mode is on). * mach_dep.c (GC_with_callee_saves_pushed): Fix and improve code introduced by the previous patch (if GETCONTEXT_FPU_EXCMASK_BUG and X86_64). * darwin_stop_world.c (GC_FindTopOfStack): Prefix and suffix "volatile" keyword with double underscore. * mach_dep.c (GETCONTEXT_FPU_EXCMASK_BUG): Recognize new macro and include fenv.h if defined (unless NO_GETCONTEXT or HAVE_PUSH_REGS). * mach_dep.c (GC_with_callee_saves_pushed): Restore FPU exception mask corrupted by getcontext if GETCONTEXT_FPU_EXCMASK_BUG. * include/private/gcconfig.h (GETCONTEXT_FPU_EXCMASK_BUG): Define for Linux/amd64 (since its GLibc getcontext currently has the bug). * allchblk.c (GC_use_entire_heap): Change type to int (as declared in gc.h); set the default value depending on new GC_USE_ENTIRE_HEAP macro. * misc.c (GC_init): Test GC_USE_ENTIRE_HEAP environment variable to alter the default value of GC_use_entire_heap. * doc/README.environment (GC_USE_ENTIRE_HEAP): Document. * doc/README.macros (GC_USE_ENTIRE_HEAP): Likewise. * include/private/gcconfig.h (PARALLEL_MARK): Do not make it cause MPROTECT_VDB undefining. * include/private/gcconfig.h (DYNAMIC_LOADING): Fix filename in the comment. * include/private/gc_priv.h (_GC_arrays): Move the conditional macro definitions (shortcuts for GC_arrays members) into the structure body. * darwin_stop_world.c (GC_mach_handler_thread, GC_use_mach_handler_thread, GC_darwin_register_mach_handler_thread): Define only if MPROTECT_VDB. * darwin_stop_world.c (GC_suspend_thread_list): Use GC_mach_handler_thread and GC_use_mach_handler_thread only if MPROTECT_VDB. * darwin_stop_world.c (GC_stop_world): Reset GC_mach_threads_count only if defined (i.e. unless GC_NO_THREADS_DISCOVERY). * misc.c (GC_init): Fix comment for GWW_VDB. * os_dep.c (DARWIN_EXC_STATE, DARWIN_EXC_STATE_COUNT, DARWIN_EXC_STATE_T, DARWIN_EXC_STATE_DAR): New macros. * os_dep.c (catch_exception_raise): Use DARWIN_EXC_STATE, DARWIN_EXC_STATE_COUNT, DARWIN_EXC_STATE_T, DARWIN_EXC_STATE_DAR. * pthread_support.c (GC_thr_init): Define "dummy" local variable only unless GC_DARWIN_THREADS. * include/private/gcconfig.h (MPROTECT_VDB): Define for Darwin even in the single-threaded mode; define for iPhone/iPad. * include/private/gcconfig.h (IA64): Remove unnecessary "ifdef" around "undef". * include/private/gcconfig.h (HEURISTIC1): Remove unused for Cygwin. * include/private/gcconfig.h (STACKBOTTOM): Use fixed address for Darwin/arm (instead of HEURISTIC1). * misc.c (GC_write): Replace multiple "ifdef/endif" with "elif" (for ECOS and NOSYS). * os_dep.c (GC_get_main_stack_base): Likewise. * os_dep.c (GC_get_main_stack_base): Check USE_GET_STACKBASE_FOR_MAIN macro before checking STACKBOTTOM one; remove "dummy" variable (use result one instead). * doc/README.macros (SN_TARGET_PS3): Document. * extra/threadlibs.c (main): Don't output "-lpthread" (and "-ldl") for Android. * include/private/pthread_support.h: Fix comment for "endif". * misc.c (GC_allocate_ml): Define global variable if SN_TARGET_PS3. * misc.c (GC_init): Initialize GC_allocate_ml if SN_TARGET_PS3. * os_dep.c (SIGSEGV): Define to dummy zero if SN_TARGET_PS3. * os_dep.c (GC_unix_mmap_get_mem): Don't define if SN_TARGET_PS3. * os_dep.c (GC_default_push_other_roots, GC_push_thread_structures): Define for SN_TARGET_PS3. * include/private/gc_locks.h (GC_allocate_ml, LOCK, UNLOCK): Define for SN_TARGET_PS3. * include/private/gcconfig.h (SN_TARGET_PS3): Recognize new macro (Sony PS/3 target). * include/private/gcconfig.h (THREADS): Define unconditionally if SN_TARGET_PS3. * include/private/gcconfig.h (GET_MEM): Define for SN_TARGET_PS3. * alloc.c (GC_collect_or_expand): Replace NIL with NULL in message. * dbg_mlc.c (GC_debug_malloc, GC_debug_malloc_ignore_off_page, GC_debug_malloc_atomic_ignore_off_page, GC_debug_generic_malloc_inner, GC_generic_malloc_inner_ignore_off_page, GC_debug_malloc_stubborn, GC_debug_malloc_atomic, GC_debug_malloc_uncollectable, GC_debug_malloc_atomic_uncollectable): Likewise. * gcj_mlc.c (GC_debug_gcj_malloc): Likewise. * dbg_mlc.c (GC_check_annotated_obj): Replace NIL with NULL in a comment. * dyn_load.c (GC_FirstDLOpenedLinkMap): Likewise. * mark_rts.c (GC_roots_present): Likewise. * doc/README: Likewise. * include/private/gc_hdrs.h (IS_FORWARDING_ADDR_OR_NIL): Likewise. * include/private/gc_priv.h (_GC_arrays): Likewise. * configure.ac: Use AC_CHECK_LIB() to check for pthread instead of just blindly linking to -lpthread, as Android includes pthread support within libc and does not provide a separate libpthread. * dyn_load.c (GC_register_dynamic_libraries): Skip current link map entry if l_addr is NULL (Android/bionic only). * pthread_stop_world.c (android_thread_kill): New internal function (Android only). * pthread_stop_world.c (GC_suspend_all, GC_start_world): Call android_thread_kill (based on tkill) instead of pthread_kill on Android (since pthread_kill cannot be used safely on the platform). * pthread_support.c (GC_new_thread): Store thread Id (obtained from gettid) for use by android_thread_kill (Android only). * include/private/pthread_support.h (GC_Thread_Rep): Add kernel_id structure member (Android only). * include/private/gcconfig.h: Recognize __x86_64 macro as a synonym of __x86_64__ (Darwin); define __environ macro (Android on M68K). * allchblk.c (GC_freehblk): Print extended error message (done via GC_printf() before aborting with a short message) only if GC_print_stats. * dyn_load.c (GC_register_dynamic_libraries): Likewise. * os_dep.c (GC_get_maps, GC_register_data_segments, GC_remap, PROTECT, GC_write_fault_handler, GC_mprotect_thread): Likewise. * pthread_stop_world.c (GC_start_world): Likewise. * win32_threads.c (GC_register_my_thread_inner): Likewise. * os_dep.c (GC_get_main_stack_base, GC_register_data_segments, GC_dirty_init): Remove redundant print of an error message before aborting with the same message. * os_dep.c (GC_register_data_segments): Remove format specifier from the string passed to GC_err_puts(); use ABORT instead of EXIT (if invalid executable type). * os_dep.c (GC_remap): Adjust printf format specifier (for long type). * os_dep.c (GC_dirty_init): Print a message about SIG_IGN detected (for SIGSEGV/BUS) only if GC_print_stats. * os_dep.c (catch_exception_raise): Join 2 adjacent GC_err_printf calls. * tests/test.c (main): Print the relevant message if GWW_VDB. * include/private/gcconfig.h: Don't define MPROTECT_VDB for Win32 on x64 if compiled by GCC. * tests/staticrootstest.c: Include string.h for memset() prototype. * tests/thread_leak_test.c (main): Fix printf() format specifiers. * CMakeLists.txt: Check enable_parallel_mark on Darwin. * configure.ac: Likewise. * darwin_stop_world.c (DARWIN_SUSPEND_GC_THREADS, DARWIN_QUERY_TASK_THREADS): Rename to GC_NO_THREADS_DISCOVERY and GC_DISCOVER_TASK_THREADS, respectively. * os_dep.c (DARWIN_SUSPEND_GC_THREADS): Likewise. * pthread_support.c (DARWIN_SUSPEND_GC_THREADS): Likewise. * darwin_stop_world.c (DARWIN_QUERY_TASK_THREADS): Don't define (and remove FIXME). * darwin_stop_world.c (GC_use_threads_discovery): Add GC_API; comment; remove FIXME. * win32_threads.c (GC_NO_DLLMAIN): Rename to GC_NO_THREADS_DISCOVERY. * tests/test.c (GC_NO_DLLMAIN): Likewise. * doc/README.macros (GC_NO_DLLMAIN): Likewise. * doc/README.win32 (GC_NO_DLLMAIN): Likewise. * doc/README.macros (GC_NO_THREADS_DISCOVERY): Update the comment. * win32_threads.c (GC_win32_dll_threads): Define as macro to true if GC_DISCOVER_TASK_THREADS (and not GC_NO_THREADS_DISCOVERY); update the comment. * win32_threads.c (GC_use_DllMain): Rename to GC_use_threads_discovery; do not set GC_win32_dll_threads if GC_DISCOVER_TASK_THREADS. * win32_threads.c (GC_started_thread_while_stopped, GC_lookup_thread_inner, UNPROTECT_THREAD, GC_lookup_pthread, GC_thr_init, GC_pthread_create, DllMain): Rewrite some expressions which use GC_win32_dll_threads to minimize the possibility of an "unreachable code" compiler warning when GC_win32_dll_threads is defined as a macro. * win32_threads.c (GC_unregister_my_thread): Don't call GC_delete_thread() if GC_win32_dll_threads and THREAD_LOCAL_ALLOC (since can't happen); use "t" local variable only if not GC_win32_dll_threads. * doc/README.macros (GC_DISCOVER_TASK_THREADS): Document. * include/gc.h (GC_use_DllMain): Rename to GC_use_threads_discovery but keep old name as a macro definition. * include/gc.h (GC_use_threads_discovery): Declare also for Darwin; update the comment. * tests/test.c (main): Call GC_use_threads_discovery for Darwin (to test the mode if possible). * darwin_stop_world.c (DARWIN_SUSPEND_GC_THREADS, DARWIN_QUERY_TASK_THREADS): New macro recognized. * darwin_stop_world.c (GC_query_task_threads): add STATIC; initialize to false; define as macro if DARWIN_SUSPEND_GC_THREADS or DARWIN_QUERY_TASK_THREADS; remove FIXME. * darwin_stop_world.c (GC_use_threads_discovery): New function (for setting GC_query_task_threads value). * darwin_stop_world.c (GC_mach_handler_thread, GC_use_mach_handler_thread, GC_mach_thread, GC_MAX_MACH_THREADS, GC_mach_threads, GC_mach_threads_count, GC_suspend_thread_list, GC_darwin_register_mach_handler_thread): Define only if not DARWIN_SUSPEND_GC_THREADS. * darwin_stop_world.c (GC_stop_world, GC_start_world): Exclude the code for GC_query_task_threads case from compilation unless DARWIN_SUSPEND_GC_THREADS. * os_dep.c (GC_darwin_register_mach_handler_thread): Declared only if Darwin threads and not DARWIN_SUSPEND_GC_THREADS. * os_dep.c (GC_mprotect_thread): Call GC_darwin_register_mach_handler_thread only if THREADS and not DARWIN_SUSPEND_GC_THREADS. * pthread_support.c (marker_mach_threads): Don't define if DARWIN_SUSPEND_GC_THREADS. * pthread_support.c (GC_mark_thread): Don't fill in marker_mach_threads if DARWIN_SUSPEND_GC_THREADS. * include/private/gc_locks.h (GC_need_to_lock): Always declare for THREADS case. * darwin_stop_world.c (GC_query_task_threads): Don't define to false for DARWIN_DONT_PARSE_STACK case; unconditionally initialize the variable to false (for now). * darwin_stop_world.c (GC_push_all_stacks): Call task_threads() only if not DARWIN_DONT_PARSE_STACK. * darwin_stop_world.c (GC_stop_world, GC_start_world): Use the approach based on task_threads() only if GC_query_task_threads else use GC_threads table. * darwin_stop_world.c (GC_mach_threads): Remove static qualifier. * darwin_stop_world.c (GC_stop_init): Remove (as we do not need to really clear GC_mach_threads[]). * darwin_stop_world.c (GC_stop_world): Reset GC_mach_threads_count (instead of calling GC_stop_init). * include/private/pthread_support.h (GC_stop_init): Remove proto. * pthread_support.c (GC_stop_init): Add proto (unless Darwin). * pthread_support.c (GC_thr_init): Don't call GC_stop_init() if GC_DARWIN_THREADS. * darwin_stop_world.c (GC_stack_range_for): New static function (move the code from GC_push_all_stacks). * darwin_stop_world.c (GC_push_all_stacks): Call GC_stack_range_for(); rename kern_return local variable to kern_result. * darwin_stop_world.c (GC_is_mach_marker): Change argument type from mach_port_t to thread_act_t. * pthread_support.c (GC_is_mach_marker): Likewise. * darwin_stop_world.c (GC_push_all_stacks): Fix "my_task" local variable initialization (always call current_task()). * pthread_support.c (GC_thr_init, GC_register_my_thread_inner): Don't set thread's stop_info.stack_ptr value for Darwin. * include/private/darwin_stop_world.h (thread_stop_info): Update the comment for stack_ptr. * darwin_stop_world.c (GC_push_all_stacks): Rename "r", "me" local variables to "kern_return" and "my_thread" ones, respectively; call mach_port_deallocate() unconditionally. * darwin_stop_world.c (GC_stop_world): Don't call mach_thread_self if DEBUG_THREADS. * darwin_stop_world.c (GC_mach_thread): Move from darwin_stop_world.h. * include/private/darwin_stop_world.h (GC_mach_thread): Remove. * win32_threads.c (GC_start_world): Define "thread_id" local variable only if GC_ASSERTIONS; decide whether to resume a thread based on its "suspended" field value; assert that suspended thread stack_base is non-zero and the thread is not our one. * darwin_stop_world.c (GC_thread_resume): New inline function (move code from GC_thread_resume). * darwin_stop_world.c (GC_start_world): Check result of task_threads(); call GC_thread_resume(). * os_dep.c (GC_malloc_heap_l, GC_is_malloc_heap_base): Define only if not CYGWIN32. * os_dep.c (GC_is_heap_base): Call GC_is_malloc_heap_base() only if not CYGWIN32. * darwin_stop_world.c (FindTopOfStack): Change return type to ptr_t (from long); make GC_INNER; add GC_ prefix. * darwin_stop_world.c (GC_push_all_stacks): Add thread_blocked local variable (initialized from the corresponding GC_thread field unless GC_query_task_threads); add assertion that our thread is not blocked; prefix FindTopOfStack with GC_ and remove no longer needed cast to ptr_t of the result; handle thread blocked case (and remove FIXME); use GC_push_all_stack_sections unless GC_query_task_threads (and remove FIXME). * pthread_support.c (GC_FindTopOfStack): Declare (if needed). * pthread_support.c (GC_do_blocking_inner): Call GC_save_regs_in_stack (if needed) before acquiring the lock. * win32_threads.c (GC_do_blocking_inner): Likewise. * pthread_support.c (GC_do_blocking_inner): Set/clear topOfStack field of GC_thread (Darwin only). * include/private/pthread_support.h (GC_thread): Add topOfStack field for Darwin (unless DARWIN_DONT_PARSE_STACK). * finalize.c (GC_check_finalizer_nested): Change return type to char pointer (instead of int pointer); use explicit cast for GC_finalizer_nested assignment. * pthread_support.c (GC_check_finalizer_nested): Likewise. * win32_threads.c (GC_check_finalizer_nested): Likewise. * finalize.c (GC_finalizer_nested): Change type to unsigned char. * finalize.c (GC_notify_or_invoke_finalizers): Change type of "pnested" local variable to char pointer. * pthread_support.c (GC_do_blocking_inner, GC_call_with_gc_active): Use explicit cast for "thread_blocked" field assignment. * win32_threads.c (GC_lookup_pthread): Use explicit cast for "suspended" field assignment. * win32_threads.c (GC_Thread_Rep): Use short type for finalizer_skipped; use char type for finalizer_nested and flags fields and reorder some fields (to minimize GC_Thread_Rep structure size). * include/private/pthread_support.h (GC_Thread_Rep): Likewise. * win32_threads.c (GC_Thread_Rep): Use char type for suspended field (instead of GC_bool). * include/private/pthread_support.h (GC_Thread_Rep): Use char type for thread_blocked field (instead of short). * darwin_stop_world.c (GC_query_task_threads): New variable (or macro). * darwin_stop_world.c (GC_push_all_stacks): Use GC_query_task_threads (to choose between algorithms based on kernel task_threads and based on GC_threads table); update FIXME; remove commented out GC_push_one statements. * pthread_support.c (GC_thr_init, GC_do_blocking_inner, GC_call_with_gc_active, GC_register_my_thread_inner): Initialize stack_ptr field for all platforms. * pthread_support.c (GC_call_with_gc_active): Initialize saved_stack_ptr field for all platforms. * include/private/darwin_stop_world.h (thread_stop_info): Add stack_ptr field; change type of already_suspended from int to GC_bool. * darwin_stop_world.c (GC_MAX_MACH_THREADS): New macro. * darwin_stop_world.c (GC_mach_threads, GC_stop_init): Use GC_MAX_MACH_THREADS instead of THREAD_TABLE_SZ. * darwin_stop_world.c (GC_mach_threads): Add FIXME. * darwin_stop_world.c (GC_stop_init, GC_suspend_thread_list, GC_stop_world): Use FALSE and TRUE for already_suspended field and "changed", "found" variables. * darwin_stop_world.c (GC_is_mach_marker): New prototype (only if PARALLEL_MARK). * darwin_stop_world.c (GC_suspend_thread_list): Change return type to GC_bool; change type of "changed", "found" to GC_bool; make "my_thread" as an argument (instead of acquiring/deallocating it locally); do not add my_thread, GC_mach_handler_thread and marker threads to GC_mach_threads table; check for overflow of GC_mach_threads table; increase GC_mach_threads_count if "found" is true and info.suspend_count is non-zero. * darwin_stop_world.c (GC_suspend_thread_list, GC_start_world): Adjust "thread" format specifiers for GC_printf(); search thread in "old_list" starting from the previous found one. * darwin_stop_world.c (GC_stop_world): Rename "changes" to "changed" local variable; remove "result" variable; adjust GC_printf debugging message. * darwin_stop_world.c (GC_start_world): Do not check for my_thread and GC_use_mach_handler_thread (since they are not added to GC_mach_threads table); call thread_info() only if DEBUG_THREADS or GC_ASSERTIONS. * pthread_support.c (marker_mach_threads): New static variable (if Darwin). * pthread_support.c (GC_is_mach_marker): New function (if Darwin). * pthread_support.c (GC_mark_thread): Fill in marker_mach_threads table (if Darwin). * alloc.c (GC_parallel): Define only if THREADS. * misc.c (GC_get_parallel): Likewise. * include/gc.h (GC_parallel, GC_get_parallel, GC_get_suspend_signal, GC_allow_register_threads, GC_register_my_thread, GC_unregister_my_thread): Define only if GC_THREADS. * include/gc.h (GC_get_heap_size): Fix a typo in a comment. * configure.ac: Use `AC_C_INLINE'. * include/private/gc_priv.h (GC_INLINE): Use "inline" keyword (determined by configure AC_C_INLINE) if HAVE_CONFIG_H is defined. * dyn_load.c (DL_ITERATE_PHDR_STRONG): New macro (define for FreeBSD). * dyn_load.c (GC_register_main_static_data): Move the definition above GC_register_dynamic_libraries_dl_iterate_phdr one (FreeBSD case); unconditionally return FALSE if DL_ITERATE_PHDR_STRONG. * dyn_load.c (GC_register_dynamic_libraries_dl_iterate_phdr): Test GC_register_main_static_data() result (instead of direct testing of dl_iterate_phdr (to prevent a compiler warning). * os_dep.c (CODE_OK): Test si_code also for the value of 2 (FreeBSD case; required for FreeBSD v7+). * os_dep.c (CODE_OK): Properly use parentheses (HPUX case). * include/private/gcconfig.h (DATASTART): Cast etext argument in GC_FreeBSDGetDataStart() call; remove unnecessary "&" (FreeBSD case). * include/private/specific.h (quick_thread_id): Define thru GC_approx_sp(); define as a macro. * include/private/specific.h (getspecific): Use GC_INLINE instead of __inline__ (to work around Sun CC which does not recognize inline keyword surrounded with underscores). * darwin_stop_world.c (FindTopOfStack): Simplify condition expressions. * darwin_stop_world.c (GC_push_all_stacks): Merge two variants of this function (DARWIN_DONT_PARSE_STACK). * darwin_stop_world.c (GC_push_all_stacks): Add a check for our thread is found (same as in pthread_stop_world.c). * darwin_stop_world.c (GC_push_all_stacks): Print the number of scanned threads if verbose (same as in pthread_stop_world.c). * darwin_stop_world.c (GC_push_all_stacks): Reset thread_state_count value before every thread_get_state call; refine the comment for thread_state_count. * darwin_stop_world.c (GC_push_all_stacks): Ignore rsp, rip/eip, rflags, cs, fs, gs, ss, ds, es, __pc registers; uncomment ebp register pushing. * darwin_stop_world.c (GC_push_all_stacks): Set outCount to GC_MACH_THREAD_STATE_COUNT (instead of THREAD_STATE_MAX). * darwin_stop_world.c (GC_push_all_stacks): Remove FIXME and WARN for i386. * doc/README.macros (DARWIN_DONT_PARSE_STACK): Fix a typo. * darwin_stop_world.c (GC_use_mach_handler_thread): Change type to GC_bool. * darwin_stop_world.c (GC_suspend_thread_list, GC_start_world): Simplify the expressions involving GC_use_mach_handler_thread. * darwin_stop_world.c (GC_darwin_register_mach_handler_thread): Initialize GC_use_mach_handler_thread to TRUE (instead of 1). * include/gc_pthread_redirects.h (GC_pthread_sigmask, GC_dlopen, pthread_sigmask, dlopen): Don't define for Win32 pthreads (and don't include signal.h and dlfcn.h). * dyn_load.c (GC_register_dynlib_callback): Add FIXME. * include/private/gcconfig.h: Add support for FreeBSD on ppc64. * os_dep.c (PROTECT, UNPROTECT): Correct VM_PROT_EXEC to VM_PROT_EXECUTE. * os_dep.c (os2_alloc): Don't set PAG_EXECUTE unless pages_executable is on. * os_dep.c (os2_alloc): Add FIXME (for recursion). * os_dep.c (UNPROTECT): Abort with a more informative message if pages_executable is on ("mprotect" case). * os_dep.c (PROTECT, UNPROTECT): Set VM_PROT_EXEC if pages_executable is on (Darwin case). * pthread_support.c (GC_init_real_syms): Abort with an informative message if libgc is linked after libpthread. * dyn_load.c (GC_register_dynlib_callback): Adjust "start" pointer for 64-bit targets. * pthread_support.c (start_mark_threads): Expand PTHREAD_CREATE macro. * pthread_support.c (start_mark_threads): Call INIT_REAL_SYMS() since REAL(pthread_create) is used. * pthread_support.c (PTHREAD_CREATE): Remove unused. * extra/threadlibs.c (main): Remove --wrap for "read" (since not wrapped anymore). * doc/README.linux (GC_USE_LD_WRAP): Likewise. * os_dep.c (__wrap_read): Likewise. * include/gc_pthread_redirects.h: Test GC_PTHREADS and GC_H at the beginning of the file. * include/gc_pthread_redirects.h (GC_PTHREAD_EXIT_ATTRIBUTE): New macro (defined only for Linux and Solaris). * include/gc_pthread_redirects.h (GC_pthread_cancel, GC_pthread_exit): Declare new API function (only if GC_PTHREAD_EXIT_ATTRIBUTE). * include/gc_pthread_redirects.h (pthread_cancel, pthread_exit): Redirect (if GC_PTHREAD_EXIT_ATTRIBUTE). * include/private/pthread_support.h (DISABLED_GC): New macro. * pthread_support.c (pthread_cancel, pthread_exit): Restore original definition or declare "real" function (if needed and GC_PTHREAD_EXIT_ATTRIBUTE). * pthread_support.c (GC_pthread_cancel_t, GC_pthread_exit_t): Declare new types if needed. * pthread_support.c (GC_pthread_cancel, GC_pthread_exit): New function definition (only if GC_PTHREAD_EXIT_ATTRIBUTE). * pthread_support.c (GC_init_real_syms): Initialize pointers to the "real" pthread_cancel and pthread_exit (only if GC_PTHREAD_EXIT_ATTRIBUTE). * pthread_support.c (GC_unregister_my_thread): Enable collections if DISABLED_GC was set (only if GC_PTHREAD_EXIT_ATTRIBUTE). * pthread_support.c (pthread_cancel, pthread_exit): New wrapped function definition (only if GC_PTHREAD_EXIT_ATTRIBUTE defined). * pthread_support.c (GC_start_routine): Refine the comment. * extra/threadlibs.c (main): Adjust --wrap (add "read", "pthread_exit", "pthread_cancel" but remove "sleep"). * doc/README.linux (GC_USE_LD_WRAP): Likewise. * include/gc.h (GC_MALLOC_STUBBORN): Remove trailing ';' in the macro definition. * include/gc.h (GC_reachable_here): Likewise. * include/gc.h (GC_reachable_here): Prefix and postfix "volatile" with double '_'. * pthread_start.c: New file. * CMakeLists.txt (SRC): Add pthread_start.c. * Makefile.am (libgc_la_SOURCES): Likewise. * Makefile.direct (CSRCS): Likewise. * Makefile.direct (OBJS): Add pthread_start.obj. * extra/gc.c: Add a comment; include pthread_start.c. * pthread_support.c (start_info): Move the struct definition down closer to its usage. * pthread_support.c (GC_thread_exit_proc): Replace STATIC with GC_INNER. * pthread_support.c (GC_inner_start_routine): Move to the definition to pthread_start.c; leave only the prototype; remove STATIC. * pthread_support.c (GC_start_rtn_prepare_thread): New function (contains parts of the original GC_inner_start_routine). * configure.ac (NO_EXECUTE_PERMISSION): Add comment. * doc/README.macros (NO_EXECUTE_PERMISSION): Update the documentation. * include/gc.h (GC_set_pages_executable, GC_get_pages_executable): New API function declaration. * os_dep.c (OPT_PROT_EXEC): Remove (superseded by pages_executable). * os_dep.c (pages_executable): New static variable. * os_dep.c (IGNORE_PAGES_EXECUTABLE): New macro (used by GC_get_pages_executable only). * os_dep.c (GC_unix_mmap_get_mem, GC_remap, PROTECT, UNPROTECT): Replace OPT_PROT_EXEC with pages_executable. * os_dep.c (GC_unix_mmap_get_mem, GC_remap, GC_win32_get_mem, GC_wince_get_mem, UNPROTECT): Undefine IGNORE_PAGES_EXECUTABLE. * os_dep.c (GC_win32_get_mem, GC_wince_get_mem, GC_remap, PROTECT, UNPROTECT): Use PAGE_EXECUTE_... only if pages_executable is on. * os_dep.c (GC_set_pages_executable, GC_get_pages_executable): New API function definition. * tests/test.c (check_heap_stats): Increase max_heap_sz by 20% for 64-bit CPUs (to prevent "Unexpected heap growth" failure on Win64, at least). * tests/test.c (check_heap_stats): Increase max_heap_sz by 25% for 32-bit CPUs (to prevent "Unexpected heap growth" failure). * gc_dlopen.c (dlopen): Prototype REAL_DLFUNC if GC_USE_LD_WRAP. * pthread_support.c (pthread_create, pthread_join, pthread_detach, pthread_sigmask): Likewise. * gc_dlopen.c (dlopen): Remove cast (redundant since the prototype is added). * gc_dlopen.c (GC_dlopen): Fix return type. * pthread_support.c (GC_init_real_syms): Don't define LIBPTHREAD_NAME, LIBPTHREAD_NAME_LEN, len, namebuf and libpthread_name if RTLD_NEXT. * gc_dlopen.c (disable_gc_for_dlopen): Update the comment. * gc_dlopen.c (dlopen): Likewise. * include/gc.h (GC_enable_incremental): Refine the comment. * include/gc.h (DECLSPEC_NORETURN): Define macro as empty if missing (only for Win32). * include/gc.h (GC_ExitThread): Use DECLSPEC_NORETURN. * win32_threads.c (GC_ExitThread): Likewise. * include/gc.h (GC_endthreadex): Add a comment. * include/cord.h: Fix typos. * Makefile.am (EXTRA_DIST): Add "CMakeLists.txt" and "tests/CMakeLists.txt". * doc/doc.am (dist_pkgdata_DATA): Add "doc/README.cmake". * mach_dep.c (NO_GETCONTEXT): Also define if AVR32. * include/private/gcconfig.h (AVR32): New macro (also define the supplementary macros for the target). * include/private/thread_local_alloc (USE_COMPILER_TLS): Don't define for AVR32. * tests/leak_test.c (main): Explicitly define as returning int (to prevent a spurious test failure on some Linux/alpha targets). * tests/thread_leak_test.c (main): Likewise. * tests/thread_leak_test.c: Initialize GC_find_leak in the main thread (before GC_INIT) only. * tests/leak_test.c (main): Use GC_set_find_leak() instead of accessing GC_find_leak directly. * tests/thread_leak_test.c (main): Likewise. * include/gc.h (GC_find_leak, GC_finalize_on_demand, GC_java_finalization, GC_dont_expand, GC_no_dls, GC_dont_precollect): Simplify the comment (remove the information about data races since the value is boolean). * os_dep.c (GC_get_stack_base, GC_get_main_stack_base): New Solaris-specific implementation (based on thr_stksegment). * os_dep.c (stackbase_main_self, stackbase_main_ss_sp): New static variable used by the Solaris-specific GC_get_stack_base(). * pthread_support.c (GC_mark_thread_local_free_lists, GC_check_tls): Mark (and check) only for live threads (in case of GC_destroy_thread_local() is called already but GC_delete_thread() is not yet). * win32_threads.c (GC_mark_thread_local_free_lists, GC_check_tls): Likewise. * NT_MAKEFILE: Remove the comment about DLL and Win32S. * NT_STATIC_THREADS_MAKEFILE: Likewise. * NT_X64_STATIC_THREADS_MAKEFILE: Likewise. * NT_MAKEFILE: Add ".SUFFIXES" directive (to handle gc_cpp.cc properly on VS 2005+). * NT_MAKEFILE: Update GC log file name in comments. * NT_STATIC_THREADS_MAKEFILE: Likewise. * NT_X64_STATIC_THREADS_MAKEFILE: Likewise. * NT_X64_THREADS_MAKEFILE: Likewise. * doc/README.win32: Likewise. * NT_MAKEFILE: Remove ":full" for "-debug" option (since no longer supported by VS). * NT_STATIC_THREADS_MAKEFILE: Likewise. * NT_MAKEFILE: Commented out copying of gc_cpp.cc to gc_cpp.cpp. * NT_STATIC_THREADS_MAKEFILE: Likewise. * NT_X64_STATIC_THREADS_MAKEFILE: Likewise. * NT_X64_THREADS_MAKEFILE: Likewise. * NT_STATIC_THREADS_MAKEFILE: Add -D PARALLEL_MARK option. * NT_STATIC_THREADS_MAKEFILE: Increase stack size for gctest.exe. * NT_X64_STATIC_THREADS_MAKEFILE: Remove "-stack" option (use the default stack size limit). * NT_X64_THREADS_MAKEFILE: Rename "gc64_dll.dll" to "gc64.dll". * win32_threads.c (GC_get_next_stack): Always define (since it is also used for Cygwin now). * alloc.c (GC_maybe_gc): Move GC_notify_full_gc() call upper to be just before GC_clear_marks() call. * include/gc_mark.h (GC_start_callback_proc): Refine the comment. * Makefile.am (check_LTLIBRARIES): Initialize to empty. * tests/tests.am (TESTS, check_PROGRAMS): Add staticrootstest. * tests/tests.am (staticrootstest_SOURCES, staticrootstest_LDADD, libstaticrootslib_la_SOURCES, libstaticrootslib_la_LIBADD, libstaticrootslib_la_LDFLAGS, libstaticrootslib_la_DEPENDENCIES): Define. * tests/tests.am (check_LTLIBRARIES): Add libstaticrootslib.la. * tests/staticrootstest.c: New file. * tests/staticrootslib.c: Likewise. * dyn_load.c (GC_get_next_stack, GC_cond_add_roots): Define for Cygwin as well as other win32 targets. * dyn_load.c (GC_wnt): Define to constant true. * dyn_load.c (GC_register_dynamic_libraries): Define for Cygwin as well as other win32 targets. * mark_rts.c (rt_hash, GC_roots_present, add_roots_to_index): Don't define for Cygwin, as on other win32. * mark_rts.c (GC_add_roots_inner, GC_clear_roots): Handle on Cygwin as for other win32 targets. * mark_rts.c (GC_rebuild_root_index): Don't declare on Cygwin, as other win32. * mark_rts.c (GC_remove_tmp_roots): Do declare on Cygwin as on other win32. * mark_rts.c (GC_remove_roots, GC_remove_roots_inner): Don't declare on Cygwin as on other win32. * mark_rts.c (GC_is_tmp_root): Do declare on Cygwin when !NO_DEBUGGING, as on other win32 targets. * mark_rts.c (GC_cond_register_dynamic_libraries): Handle on Cygwin as for other win32 targets. * os_dep.c (GC_setpagesize): Handle on Cygwin as on other win32. * os_dep.c (GC_get_main_stack_base): Don't declare on Cygwin, as other win32. * os_dep.c (GC_sysinfo): Declare on Cygwin, as other win32. * os_dep.c (GC_win32_get_mem): Declare on Cygwin, as on other Win32, but call GC_unix_get_mem instead of GlobalAlloc. * os_dep.c (GC_win32_free_heap): Declare on Cygwin (as empty). * ptr_chck.c (GC_is_visible): Register dynamic libraries on Cygwin as on other win32 platforms. * win32_threads.c (GC_get_next_stack): Define on Cygwin as well as for dynamic loading targets. * include/private/gc_priv.h (GC_INNER): Don't try to use visibility on Cygwin which does not support it. * include/private/gc_priv.h (struct roots): Don't declare r_next member on Cygwin as on other windows hosts. * include/private/gc_priv.h (LOG_RT_SIZE, RT_SIZE): Don't define likewise. * include/private/gc_priv.h (struct _GC_arrays): Do declare _heap_bases[] member and don't declare _root_index likewise. * include/private/gc_priv.h (GC_heap_bases): Do define likewise. * include/private/gc_priv.h (_SYSTEM_INFO): Do forward-declare likewise. * include/private/gc_priv.h (GC_sysinfo): Do declare extern likewise. * include/private/gcconfig.h (GC_win32_get_mem, GET_MEM): Do prototype on Cygwin as other win32 platforms. * os_dep.c (GC_get_main_stack_base): Use pthread_getattr_np() and pthread_attr_getstack() instead of GC_get_stack_base() (and check returned stackaddr for NULL); output a warning on failure. * alloc.c (GC_start_call_back): Replace the definition type to GC_start_callback_proc. * alloc.c (GC_set_start_callback, GC_get_start_callback): New setter/getter function. * alloc.c (GC_try_to_collect_inner): Call GC_notify_full_gc() unconditionally (because GC_try_to_collect_inner always does full GC). * include/gc_mark.h (GC_start_callback_proc): New type. * include/gc_mark.h (GC_set_start_callback, GC_get_start_callback): New API function declaration. * doc/README.macros (USE_GET_STACKBASE_FOR_MAIN): Document. * os_dep.c (GC_get_main_stack_base): Recognize USE_GET_STACKBASE_FOR_MAIN (only if THREADS and LINUX_STACKBOTTOM) and use GC_get_stack_base() in this case. * os_dep.c (GC_get_stack_base): Add LOCK/UNLOCK() (since GC_find_limit_with_bound() should be called with the lock held). * backgraph.c (FOR_EACH_PRED): Fix a typo. * alloc.c (GC_set_stop_func, GC_get_stop_func): Add DCL_LOCK_STATE. * finalize.c (GC_notify_or_invoke_finalizers): Likewise. * gc_dlopen.c (disable_gc_for_dlopen): Likewise. * gcj_mlc.c (maybe_finalize, GC_debug_gcj_malloc): Likewise. * mark.c (GC_print_trace): Likewise. * misc.c (GC_set_warn_proc, GC_get_warn_proc, GC_enable, GC_disable, GC_new_free_list, GC_new_kind, GC_new_proc, GC_set_oom_fn, GC_get_oom_fn, GC_set_finalizer_notifier, GC_get_finalizer_notifier): Likewise. * os_dep.c (GC_get_stack_base, GC_print_callers): Likewise. * pthread_support.c (GC_is_thread_tsd_valid, GC_wait_for_gc_completion, GC_init_parallel, GC_do_blocking_inner, GC_call_with_gc_active, GC_unregister_my_thread, pthread_join, pthread_detach, GC_register_my_thread, GC_inner_start_routine, pthread_create): Likewise. * reclaim.c (GC_print_all_errors): Likewise. * win32_threads.c (GC_is_thread_tsd_valid, GC_register_my_thread, GC_unregister_my_thread, GC_do_blocking_inner, GC_call_with_gc_active, GC_lookup_pthread, GC_pthread_join, GC_pthread_start_inner, GC_thread_exit_proc, GC_pthread_detach, GC_init_parallel): Likewise. * doc/README.darwin: Update. * CMakeLists.txt: Adjust INCLUDE_DIRECTORIES and SRC (to make it usable on Mac OS X). * doc/README.cmake: Update. * CMakeLists.txt: New file (adding CMake support). * tests/CMakeLists.txt: Likewise. * doc/README.cmake: Likewise. * configure.ac (darwin): Don't define HAS_PPC_THREAD_STATE... macros. * include/private/gc_priv.h (THREAD_FLD): Recognize __DARWIN_UNIX03 instead of HAS_PPC_THREAD_STATE... macros. * pthread_support.c: Include and for OpenBSD. * pthread_support.c (get_ncpu): Define also for Darwin, NetBSD and OpenBSD. * pthread_support.c (GC_thr_init): Use get_ncpu() for Darwin, NetBSD and OpenBSD. * mallocx.c (GC_generic_malloc_many, GC_malloc_many): Define even if THREADS is undefined. * include/gc.h (GC_malloc_many): Update the comment. * include/gc_cpp.h (GC_PLACEMENT_DELETE): Define for Embarcadero (formerly known as Borland) C++ compiler v6.21+. * include/gc_cpp.h (GC_NO_OPERATOR_NEW_ARRAY): Define for ancient VC++ compilers. * win32_threads.c (GC_register_my_thread_inner, GC_pthread_start_inner): Undo the previous commit changes for the thread flags and DETACHED state (since the state is only tested in GC_thread_exit_proc). * include/gc.h (GC_unregister_my_thread): Fix a typo; update the comment. * pthread_support.c (GC_delete_thread): Allow to delete the main thread (don't call GC_INTERNAL_FREE for it); update the comment. * win32_threads.c (GC_delete_thread): Likewise. * pthread_support.c (GC_unregister_my_thread): Add an assertion for FINISHED flag is unset. * tests/test.c (check_heap_stats): Test the main thread unregistering (only if THREADS). * win32_threads.c (GC_register_my_thread_inner): Set flags to DETACHED (only if GC_PTHREADS). * win32_threads.c (GC_unregister_my_thread): Add FIXME (for GC_wait_for_gc_completion). * win32_threads.c (GC_pthread_start_inner): Clear flags detached state if needed; set pthread_id and flags while holding the lock. * include/private/gc_priv.h (SIG_SUSPEND): Don't define for OpenBSD and Darwin. * include/gc.h: Recognize _M_X64 (as an alias for _AMD64_). * test.c (main, WinMain): Consistently don't invoke GC_enable_incremental() if MAKE_BACKGRAPH is defined, but do invoke it even if parallel marking is enabled. * tests/test.c (reverse_test): Comment out a check for MSWIN32 (when determing BIG value) assuming outdated win32S. * tests/test.c (reverse_test): Rename to reverse_test_inner; change the declaration (to be of GC_fn_type); call itself thru GC_call_with_gc_active() if the argument is zero. * tests/test.c (reverse_test): New function added calling reverse_test_inner thru GC_do_blocking (to test GC_do_blocking and GC_call_with_gc_active). * doc/README.macros (IGNORE_DYNAMIC_LOADING, PLATFORM_ANDROID): Document. * dyn_load.c: Don't include if PLATFORM_ANDROID. * dyn_load.c: Include bionic (instead of ) if PLATFORM_ANDROID. * include/private/gcconfig.h (LINUX): Define also if PLATFORM_ANDROID (for the windows-based toolkit). * include/private/gcconfig.h (SEARCH_FOR_DATA_START): Explicitly define for Android/x86 platform. * include/private/gcconfig.h (IGNORE_DYNAMIC_LOADING): Recognize new macro (undefine DYNAMIC_LOADING in this case). * include/private/gcconfig.h (CANCEL_SAFE): Don't define if PLATFORM_ANDROID. * include/private/gcconfig.h (IF_CANCEL): Fix definition for the explicitly defined CANCEL_SAFE. * allchblk.c (GC_allochblk_nth): Don't call GC_remove_protection() if GC_DISABLE_INCREMENTAL. * reclaim.c (GC_reclaim_generic): Likewise. * checksums.c (GC_page_was_ever_dirty): Add prototype. * include/private/gc_locks.h (GC_mark_lock_holder): Don't declare unless PARALLEL_MARK. * include/private/gc_priv.h (GC_dirty_maintained, GC_page_was_dirty, GC_remove_protection, GC_dirty_init): Don't declare if GC_DISABLE_INCREMENTAL. * include/private/gc_priv.h (GC_print_finalization_stats): Don't declare if SMALL_CONFIG. * include/private/gcconfig.h (CHECKSUMS): Explicitly undefine if GC_DISABLE_INCREMENTAL (since nothing to check). * include/private/gcconfig.h (DEFAULT_VDB): Don't define if GC_DISABLE_INCREMENTAL. * os_dep.c (GC_dirty_maintained): Likewise. * mark.c (GC_initiate_gc): Don't call GC_read_dirty() if GC_DISABLE_INCREMENTAL. * os_dep.c (GC_gww_page_was_ever_dirty, GC_page_was_ever_dirty): Uncomment; define only if CHECKSUMS. * darwin_stop_world.c (GC_push_all_stacks): Fix a bug (call GC_push_all_stack() instead of GC_push_all_stack_frames()). * include/private/gc_priv.h (GC_push_all_stack_frames, GC_push_all_register_frames): Rename to GC_push_all_stack_sections and GC_push_all_register_sections, respectively. * mark_rts.c (GC_push_all_stack_frames, GC_push_all_register_frames, GC_push_all_stack_part_eager_frames, GC_push_current_stack): Likewise. * pthread_stop_world.c (GC_push_all_stacks): Likewise. * win32_threads.c (GC_push_stack_for): Likewise. * misc.c (GC_call_with_gc_active): Rename "frame" local variable to "stacksect". * pthread_support.c (GC_call_with_gc_active): Likewise. * win32_threads.c (GC_call_with_gc_active): Likewise. * pthread_support.c (GC_call_with_gc_active): Update FIXME for Darwin. * win32_threads.c (GC_Thread_Rep): Update the comment for traced_stack_sect. * darwin_stop_world.c (GC_push_all_stacks): Rename activation_frame to traced_stack_sect. * include/private/gc_priv.h (GC_push_all_stack_frames, GC_push_all_register_frames): Likewise. * include/private/pthread_support.h (GC_Thread_Rep): Likewise. * mark_rts.c (GC_push_all_register_frames, GC_push_all_stack_frames, GC_push_all_stack_part_eager_frames, GC_push_current_stack): Likewise. * pthread_stop_world.c (GC_push_all_stacks): Likewise. * pthread_support.c (GC_call_with_gc_active): Likewise. * win32_threads.c (GC_Thread_Rep, GC_call_with_gc_active, GC_push_stack_for): Likewise. * include/private/gc_priv.h (GC_activation_frame_s): Rename to GC_traced_stack_sect_s. * include/private/gc_priv.h (GC_activation_frame): Rename to GC_traced_stack_sect. * misc.c (GC_activation_frame, GC_call_with_gc_active): Likewise. * doc/README.macros (UNICODE): Document. * doc/README.macros (GC_READ_ENV_FILE): Document (new macro). * include/private/gc_priv.h (GETENV): Recognize GC_READ_ENV_FILE; declare and use GC_envfile_getenv(). * misc.c (GC_envfile_content, GC_envfile_length): New static variable (only if GC_READ_ENV_FILE). * misc.c (GC_ENVFILE_MAXLEN): New macro (used in GC_envfile_init). * misc.c (GC_envfile_init, GC_envfile_getenv): New function (only if GC_READ_ENV_FILE). * misc.c (GC_init): Call GC_envfile_init() (before using GETENV) if GC_READ_ENV_FILE. * misc.c (GC_init): Move GC_setpagesize() and GC_init_win32() calls to be just before GC_envfile_init() one (since the latter uses GET_MEM). * misc.c (GC_abort): use ExitProcess() (instead of DebugBreak) for WinCE if NO_DEBUGGING; add a comment for DebugBreak() (for WinCE). * mark_rts.c (GC_add_roots_inner): Remove redundant trailing '\n' from the ABORT message. * misc.c (GC_init): Likewise. * os_dep.c (GC_get_main_stack_base, GC_register_data_segments): Likewise. * pthread_stop_world.c (GC_push_all_stacks): Likewise. * pthread_support.c (GC_init_real_syms, start_mark_threads): Likewise. * win32_threads.c (GC_get_next_stack): Don't define for Cygwin (since unused for now). * dyn_load.c (HAVE_REGISTER_MAIN_STATIC_DATA): Don't define unless GC_register_main_static_data() is defined. * dyn_load.c (GC_register_dynamic_libraries): Define only if used (if DYNAMIC_LOADING or PCR or Win32/CE). * dyn_load.c (GC_register_main_static_data): Define the default one only if DYNAMIC_LOADING. * include/private/gc_priv.h (GC_register_dynamic_libraries): Declare only if used (to prevent compiler warning). * mark_rts.c (GC_approx_sp): Add a comment (for GCC). == [7.2alpha4] 2009-12-01 == * configure.ac (AC_CONFIG_COMMANDS): Quote srcdir value. * include/gc.h (GC_get_suspend_signal): New function declaration. * misc.c (GC_get_suspend_signal): New API function (only if THREADS). * alloc.c (min_bytes_allocd): Multiply GC_free_space_divisor by two if GC_incremental (instead of TRUE_INCREMENTAL). * sparc_mach_dep.S (GC_push_regs): Remove the reference. * os_dep.c (SIZE_T, PULONG_PTR): Remove. * os_dep.c (ULONG_PTR): Replace with GC_ULONG_PTR (defined as GC "word"); add the comment. * os_dep.c (GetWriteWatch_type, detect_GetWriteWatch, GC_gww_read_dirty): Prefix ULONG_PTR with "GC_". * win32_threads.c (THREAD_TABLE_SZ): Change back to a power-of-two const value (for speed). * win32_threads.c (THREAD_TABLE_INDEX): New macro. * win32_threads.c (GC_new_thread, GC_lookup_thread_inner, GC_delete_gc_thread, GC_delete_thread, GC_lookup_pthread): Use THREAD_TABLE_INDEX instead of THREAD_TABLE_SZ. * win32_threads.c (PTHREAD_MAP_HASH): Rename to PTHREAD_MAP_INDEX. * win32_threads.c (THREAD_TABLE_SZ): Make the const value prime. * backgraph.c: Remove apostrophe char from "#error". * doc/README.macros (GC_DISABLE_INCREMENTAL): Document. * include/private/gcconfig.h (GC_DISABLE_INCREMENTAL): Recognize new macro; implicitly define it if SMALL_CONFIG. * alloc.c (GC_incremental, GC_timeout_stop_func): Check for GC_DISABLE_INCREMENTAL instead of SMALL_CONFIG. * include/private/gc_priv.h (GC_incremental, TRUE_INCREMENTAL, GC_push_conditional): Likewise. * mark.c (GC_push_next_marked_dirty, GC_push_selected, GC_push_conditional, GC_block_was_dirty): Likewise. * misc.c (GC_enable_incremental): Likewise. * misc.c (GC_init): Likewise. * dyn_load.c (WIN32_LEAN_AND_MEAN): Guard with ifndef. * misc.c (WIN32_LEAN_AND_MEAN): Likewise. * os_dep.c (WIN32_LEAN_AND_MEAN): Likewise. * allchblk.c (GC_allochblk_nth): Fix a minor typo (don't/doesn't) in a comment. * backgraph.c: Likewise. * dyn_load.c (GC_register_dynamic_libraries): Likewise. * extra/threadlibs.c (main): Likewise. * pthread_support.c (pthread_join): Likewise. * tests/test.c (main): Likewise. * mach_dep.c (GC_push_regs): Remove STATIC (just to catch a duplicate symbol definition linker error). * misc.c (GC_clear_stack_inner): Likewise. * sparc_mach_dep.S (GC_push_regs): Comment out the reference. * include/private/gc_priv.h (GC_write_disabled): New variable declaration (only if GC_ASSERTIONS and Win32 threads). * misc.c (GC_write): Add assertion for GC_write_disabled value is not on (only if THREADS). * win32_threads.c (GC_write_disabled): New variable (only if GC_ASSERTIONS and not Cygwin). * win32_threads.c (GC_stop_world): Set and clear GC_write_disabled (while holding GC_write_cs). * win32_threads.c (GC_please_stop): If DllMain-based thread registration is not compiled in then define GC_please_stop as a non-volatile variable for assertion only. * win32_threads.c (GC_stop_world): Set and clear only if defined. * win32_threads.c (GC_stop_world): Add the comment for GC_printf() usage (while holding GC_write_cs). * win32_threads.c (GC_delete_gc_thread): Likewise. * os_dep.c (GC_remove_protection): Likewise. * pthread_support.c (GC_inner_start_routine): Join 3 sequential GC_printf() calls into a single one (for DEBUG_THREADS). * include/private/gc_priv.h (GC_total_stacksize): New variable declaration (only if THREADS). * alloc.c (GC_total_stacksize): New variable (only if THREADS). * alloc.c (min_bytes_allocd): Calculate stack_size using GC_stackbottom only in the single-threaded case; otherwise use GC_total_stacksize; print GC_total_stacksize value if DEBUG_THREADS. * darwin_stop_world.c (GC_push_all_stacks): Use "%p" printf type specifier for lo/hi values (instead of "%lx"). * darwin_stop_world.c (GC_push_all_stacks): Use GC_push_all_stack_frames() instead of GC_push_all_stack(). * darwin_stop_world.c (GC_push_all_stacks): Recalculate GC_total_stacksize value. * pthread_stop_world.c (GC_push_all_stacks): Likewise. * win32_threads.c (GC_push_all_stacks): Likewise. * win32_threads.c (GC_push_stack_for): Pass "me" argument; return stack size; don't check for non-zero value of thread->stack_base. * win32_threads.c (GC_push_all_stacks): Don't call GC_push_stack_for() and don't check for "t->id == me" if thread->stack_base is zero. * dyn_load.c (GC_dump_meminfo): Prefix "%lx" printf type specifier with "0x". * os_dep.c (PROTECT): Likewise. * win32_threads.c (GC_mark_thread_local_free_lists): Cast p->id to int (to match printf type specifier). * tests/test.c (check_heap_stats): Take into account the unmapped memory size when checking for "Unexpected heap growth"; remove FIXME. * alloc.c: Revert last change. * include/private/gcconfig.h (STACKBOTTOM): Add a presence check for eCos/NOSYS. * misc.c (GC_write): Comment out _Jv_diag_write() call (since no longer defined in GCJ). * os_dep.c (brk): Rename to ecos_gc_brk. * alloc.c (min_bytes_allocd): Use GC_stackbottom value to compute stack_size even if THREADS. * doc/README.macros (DEBUG_THREADS): Document. * pthread_support.c (DEBUG_THREADS): Remove the commented out definition. * win32_threads.c (DEBUG_WIN32_THREADS): Remove duplicate definition. * win32_threads.c: Include errno.h (except for WinCE). * win32_threads.c (GC_win32_start_inner): Copy "start" and "param" to local variables, and free "arg" parameter before "start" invocation. * win32_threads.c (GC_beginthreadex): Set errno to EAGAIN on error (instead of calling SetLastError(ERROR_NOT_ENOUGH_MEMORY)). * win32_threads.c (GC_beginthreadex): Return 0 on error (instead of -1). * darwin_stop_world.c (GC_darwin_register_mach_handler_thread): Use GC_INNER for the function definition. * include/private/darwin_stop_world.h (GC_darwin_register_mach_handler_thread): Remove the prototype. * os_dep.c (GC_darwin_register_mach_handler_thread): Use GC_INNER for the function prototype. * include/private/gc_priv.h (NDEBUG): Explicitly define if NO_DEBUGGING and not GC_ASSERTIONS (before the standard headers inclusion). * include/private/gcconfig.h: Move DebugBreak() workaround (for x86mingw32ce toolchain) to gc_priv.h (after windows.h inclusion). * allchblk.c (GC_unmap_old, GC_merge_unmapped, GC_allochblk, GC_freehblk): Use GC_INNER for the function definition. * alloc.c (GC_never_stop_func, GC_should_collect, GC_try_to_collect_inner, GC_collect_a_little_inner, GC_set_fl_marks, GC_add_to_our_memory, GC_add_to_heap, GC_expand_hp_inner, GC_collect_or_expand, GC_allocobj): Likewise. * backgraph.c (GC_build_back_graph, GC_traverse_back_graph): Likewise. * blacklst.c (GC_default_print_heap_obj_proc, GC_bl_init, GC_promote_black_lists, GC_unpromote_black_lists, GC_add_to_black_list_normal, GC_add_to_black_list_stack, GC_is_black_listed): Likewise. * darwin_stop_world.c (GC_push_all_stacks, GC_push_all_stacks, GC_stop_init, GC_stop_world, GC_start_world): Likewise. * dbg_mlc.c (GC_has_other_debug_info, GC_store_back_pointer, GC_marked_for_finalization, GC_generate_random_backtrace_no_gc, GC_store_debug_info, GC_start_debugging, GC_debug_generic_malloc_inner, GC_debug_generic_malloc_inner_ignore_off_page, GC_debug_malloc_uncollectable, GC_debug_free_inner): Likewise. * dyn_load.c (GC_register_dynamic_libraries, GC_register_main_static_data, GC_init_dyld): Likewise. * finalize.c (GC_push_finalizer_structures, GC_finalize, GC_notify_or_invoke_finalizers, GC_print_finalization_stats): Likewise. * gcj_mlc.c (GC_core_gcj_malloc): Likewise. * headers.c (GC_find_header, GC_header_cache_miss, GC_scratch_alloc, GC_init_headers, GC_install_header, GC_install_counts, GC_remove_header, GC_remove_counts, GC_next_used_block, GC_prev_block): Likewise. * mach_dep.c (GC_with_callee_saves_pushed): Likewise. * malloc.c (GC_collect_or_expand, GC_alloc_large, GC_generic_malloc_inner, GC_generic_malloc_inner_ignore_off_page, GC_core_malloc_atomic, GC_core_malloc, GC_free_inner): Likewise. * mallocx.c (GC_generic_malloc_ignore_off_page): Likewise. * mark.c (GC_collection_in_progress, GC_clear_hdr_marks, GC_set_hdr_marks, GC_set_mark_bit, GC_clear_mark_bit, GC_clear_marks, GC_initiate_gc, GC_mark_some, GC_mark_stack_empty, GC_invalidate_mark_state, GC_signal_mark_stack_overflow, GC_mark_from, GC_help_marker, GC_mark_init, GC_push_all, GC_push_conditional, GC_mark_and_push_stack, GC_push_all_eager, GC_push_all_stack): Likewise. * mark_rts.c (GC_is_static_root, GC_roots_present, GC_approx_sp, GC_exclude_static_roots_inner, GC_push_all_register_frames, GC_push_all_stack_frames, GC_cond_register_dynamic_libraries, GC_push_roots): Likewise. * misc.c (GC_extend_size_map, GC_clear_stack, GC_err_write): Likewise. * new_hblk.c (GC_build_fl, GC_new_hblk): Likewise. * obj_map.c (GC_register_displacement_inner, GC_add_map_entry, GC_initialize_offsets): Likewise. * os_dep.c (GC_get_maps, GC_parse_map_entry, GC_text_mapping, GC_init_linux_data_start, GC_init_netbsd_elf, GC_setpagesize, GC_set_and_save_fault_handler, GC_setup_temporary_fault_handler, GC_reset_fault_handler, GC_get_register_stack_base, GC_init_win32, GC_add_current_malloc_heap, GC_is_heap_base, GC_unmap, GC_remap, GC_unmap_gap, GC_push_all_stacks, GC_gww_dirty_init, GC_dirty_init, GC_read_dirty, GC_page_was_dirty, GC_page_was_ever_dirty, GC_remove_protection, GC_write_fault_handler, GC_mprotect_stop, GC_mprotect_resume, GC_save_callers, GC_print_callers): Likewise. * pthread_stop_world.c (GC_push_all_stacks, GC_stop_world, GC_start_world, GC_stop_init): Likewise. * pthread_support.c (GC_mark_thread_local_free_lists, GC_lookup_thread, GC_reset_finalizer_nested, GC_check_finalizer_nested, GC_segment_is_thread_stack, GC_greatest_stack_base_below, GC_thr_init, GC_init_parallel, GC_do_blocking_inner, GC_lock, GC_acquire_mark_lock, GC_release_mark_lock, GC_wait_for_reclaim, GC_notify_all_builder, GC_wait_marker, GC_notify_all_marker): Likewise. * reclaim.c (GC_print_all_errors, GC_block_empty, GC_reclaim_generic, GC_start_reclaim, GC_continue_reclaim, GC_reclaim_all): Likewise. * thread_local_alloc.c (GC_init_thread_local, GC_destroy_thread_local, GC_mark_thread_local_fls_for): Likewise. * win32_threads.c (GC_reset_finalizer_nested, GC_check_finalizer_nested, GC_do_blocking_inner, GC_stop_world, GC_start_world, GC_push_all_stacks, GC_get_next_stack, GC_acquire_mark_lock, GC_release_mark_lock, GC_wait_for_reclaim, GC_notify_all_builder, GC_wait_marker, GC_notify_all_marker, GC_thr_init, GC_init_parallel, GC_lock, GC_mark_thread_local_free_lists): Likewise. * alloc.c (GC_add_current_malloc_heap, GC_build_back_graph, GC_traverse_back_graph): Use GC_INNER for the function prototype. * darwin_stop_world.c (GC_mprotect_stop, GC_mprotect_resume): Likewise. * dbg_mlc.c (GC_default_print_heap_obj_proc): Likewise. * dyn_load.c (GC_parse_map_entry, GC_get_maps, GC_segment_is_thread_stack, GC_roots_present, GC_is_heap_base, GC_get_next_stack): Likewise. * finalize.c (GC_reset_finalizer_nested, GC_check_finalizer_nested): Likewise. * gcj_mlc.c (GC_start_debugging): Likewise. * include/private/dbg_mlc.h (GC_save_callers, GC_print_callers, GC_has_other_debug_info, GC_store_debug_info): Likewise. * include/private/gc_hdrs.h (GC_header_cache_miss): Likewise. * include/private/gc_locks.h (GC_lock): Likewise. * include/private/gc_pmark.h (GC_signal_mark_stack_overflow, GC_mark_from): Likewise. * include/private/pthread_support.h (GC_lookup_thread, GC_stop_init): Likewise. * include/private/thread_local_alloc.h (GC_init_thread_local, GC_destroy_thread_local, GC_mark_thread_local_fls_for): Likewise. * malloc.c (GC_extend_size_map, GC_text_mapping): Likewise. * mark.c (GC_page_was_ever_dirty): Likewise. * mark_rts.c (GC_mark_thread_local_free_lists): Likewise. * misc.c (GC_register_main_static_data, GC_init_win32, GC_setpagesize, GC_init_linux_data_start, GC_set_and_save_fault_handler, GC_init_dyld, GC_init_netbsd_elf, GC_do_blocking_inner): Likewise. * os_dep.c (GC_greatest_stack_base_below): Likewise. * win32_threads.c (GC_write_fault_handler, GC_gww_dirty_init): Likewise. * include/private/gc_priv.h: Likewise. * include/private/gc_priv.h (GC_INNER): Update the comment. * doc/README.macros (GC_DLL): Update. * alloc.c (GC_collection_in_progress): Move the prototype to gc_priv.h. * gc_dlopen.c (GC_collection_in_progress): Likewise. * pthread_support.c (GC_collection_in_progress): Likewise. * misc.c (GC_init_parallel): Likewise. * pthread_support.c (GC_init_parallel): Likewise. * win32_threads.c (GC_init_parallel): Likewise. * darwin_stop_world.c (GC_thr_init): Likewise. * misc.c (GC_thr_init): Likewise. * pthread_stop_world.c (GC_thr_init): Likewise. * pthread_support.c (GC_thr_init): Likewise. * blacklst.c (GC_clear_bl, GC_copy_bl, GC_number_stack_black_listed): Make STATIC. * dbg_mlc.c (GC_print_obj, GC_make_closure, GC_debug_invoke_finalizer): Likewise. * malloc.c (GC_alloc_large_and_clear): Likewise. * mark.c (GC_push_selected, GC_push_marked1, GC_push_marked2, GC_push_marked4, GC_push_marked, GC_push_next_marked, GC_push_next_marked_dirty, GC_push_next_marked_uncollectable): Likewise. * misc.c (GC_clear_stack_inner): Likewise. * os_dep.c (GC_repeat_read, GC_default_push_other_roots): Likewise. * darwin_stop_world.c (FindTopOfStack): Make static; define only if not DARWIN_DONT_PARSE_STACK. * dbg_mlc.c (GC_debug_free_inner): Define only if DBG_HDRS_ALL. * dyn_load.c (GC_repeat_read): Remove unused prototype. * include/private/gc_pmark.h (GC_find_start): Likewise. * misc.c (GC_read, GC_register_finalizer_no_order): Likewise. * dyn_load.c (GC_segment_is_thread_stack): Add prototype (only if THREADS). * dyn_load.c (GC_register_main_static_data): Define only if DYNAMIC_LOADING. * finalize.c (GC_enqueue_all_finalizers): Remove unnecessary tail "return" statement. * gc_dlopen.c (GC_SOLARIS_THREADS): Don't recognize (since implies GC_PTHREADS). * include/gc.h: Fix a typo. * include/gc_inline.h (GC_ASSERT): Define (if not defined) since the header is public. * include/gc_inline.h (GC_generic_malloc_many): New public function declaration. * mallocx.c (GC_generic_malloc_many): Make public. * include/private/gc_priv.h (GC_INNER): Use visibility attribute (if available). * include/private/gc_priv.h (GC_EXTERN): Define using GC_INNER. * include/private/gc_priv.h: Include atomic_ops.h if THREADS and MPROTECT_VDB. * os_dep.c: Don't include atomic_ops.h * win32_threads.c: Likewise. * include/private/gc_priv.h (GC_push_selected, GC_push_regs, GC_push_marked, GC_number_stack_black_listed, GC_alloc_large_and_clear, GC_reclaim_or_delete_all, GC_generic_malloc_many, GC_make_closure, GC_debug_invoke_finalizer, GC_print_obj, GC_page_was_ever_dirty): Remove the prototype. * mark.c (GC_page_was_ever_dirty): Add prototype (only if PROC_VDB). * include/private/gc_priv.h (GC_push_next_marked_dirty, GC_push_next_marked, GC_push_next_marked_uncollectable): Move the prototype to mark.c. * include/private/gc_priv.h (GC_is_static_root): Declare only if not THREADS. * include/private/gc_priv.h (GC_free_inner): Declare only if THREADS. * include/private/gc_priv.h (GC_debug_free_inner): Declare only if THREADS and DBG_HDRS_ALL. * include/private/gc_priv.h (GC_markers): Declare GC_markers only if PARALLEL_MARK. * include/private/gc_priv.h (GC_register_main_static_data): Move the prototype to misc.c. * mach_dep.c (GC_push_regs): Make STATIC; define only along with HAVE_PUSH_REGS definition. * mach_dep.c (GC_clear_stack_inner): Replace K&R-style function definition with the ANSI C one. * mark.c (GC_started_thread_while_stopped): Declared only if not GNU C. * win32_threads.c (GC_started_thread_while_stopped): Don't define if GNU C. * mark.c (GC_mark_from): Avoid unbalanced brackets in #if-#else-#endif blocks. * mark_rts.c (GC_is_static_root): Define only if not THREADS. * os_dep.c (GC_get_stack_base): Make public (for OpenBSD). * os_dep.c (GC_page_was_ever_dirty): Comment out the function except for PROC_VDB. * tests/test.c (main): Don't reference GC_print_obj, GC_make_closure, GC_debug_invoke_finalizer, GC_page_was_ever_dirty, GC_is_fresh (in GC_noop). * thread_local_alloc.c: Don't include "gc_inline.h". * win32_threads.c (GC_write_fault_handler): Declare only if MPROTECT_VDB. * allchblk.c (DEBUG): Remove macro (since unused). * allchblk.c: Include private/gc_priv.h before other includes and definitions. * alloc.c: Likewise. * gc_dlopen.c: Likewise. * headers.c: Likewise. * mallocx.c: Likewise. * mark_rts.c: Likewise. * new_hblk.c: Likewise. * reclaim.c: Likewise. * mark.c: Include private/gc_pmark.h before other includes. * misc.c: Likewise. * dyn_load.c (_GNU_SOURCE): Move the definition to gc_priv.h. * pthread_support.c (_USING_POSIX4A_DRAFT10): Likewise. * pthread_support.c (_POSIX4A_DRAFT10_SOURCE): Remove (since already defined in gc_config_macros.h). * dyn_load.c (GC_init_dyld): Remove parameter cast for _dyld_register_func_for_add_image() and _dyld_register_func_for_remove_image(); add the comment about possible warnings; add FIXME for the deprecated _dyld_bind_fully_image_containing_address(). * include/private/gc_priv.h: Include gc.h before the standard headers inclusion. * tests/test.c: Likewise. * include/private/gcconfig.h (DebugBreak): Update the comment. * typd_mlc.c (ED_INITIAL_SIZE): Remove ';'. * configure.ac (openbsd): Define GC_OPENBSD_THREADS. * configure.ac: Add AM_CONDITIONAL(OPENBSD_THREADS). * configure.ac: Add sparc-openbsd case. * doc/README.macros (GC_NETBSD_THREADS, GC_OPENBSD_THREADS): Document. * tests/test.c (main): Handle OpenBSD case. * include/private/pthread_stop_world.h: Likewise. * extra/threadlibs.c (main): Replace K&R-style function definition with the ANSI C one. * extra/threadlibs.c (main): Handle GC_OPENBSD_THREADS case. * dyn_load.c (OPENBSD): Recognize (similar to NETBSD). * include/gc_config_macros.h (GC_SOLARIS_THREADS): Recognize; define it for OpenBSD. * include/gc_pthread_redirects.h (GC_pthread_sigmask, pthread_sigmask): Don't declare and redefine for OpenBSD. * include/private/gcconfig.h: Handle OpenBSD (on arm, sh, i386, amd64, powerpc). * mach_dep.c (NO_GETCONTEXT): Likewise. * include/private/pthread_stop_world.h (thread_stop_info): Don't define last_stop_count field if OpenBSD. * misc.c (GC_init_dyld): Add declaration (if NetBSD). * misc.c (GC_init): Don't call GC_init_netbsd_elf() for OpenBSD. * os_dep.c (GC_init_netbsd_elf): Don't define for OpenBSD. * os_dep.c (old_segv_act, GC_jmp_buf_openbsd): New static variable (only if OpenBSD). * os_dep.c (GC_fault_handler_openbsd, GC_find_limit_openbsd, GC_skip_hole_openbsd): New static function (only if OpenBSD). * os_dep.c (GC_get_stack_base, GC_get_main_stack_base, GC_register_data_segments): Define specially for OpenBSD case. * os_dep.c (GC_fault_handler_lock): Initialize to AO_TS_INITIALIZER (instead of 0). * pthread_support.c (GC_allocate_lock): Likewise. * pthread_stop_world.c (NSIG, GC_print_sig_mask, GC_remove_allowed_signals, suspend_handler_mask, GC_stop_count, GC_world_is_stopped, GC_retry_signals, SIG_THR_RESTART, GC_suspend_ack_sem, GC_suspend_handler_inner, GC_suspend_handler, GC_restart_handler): Don't define and use if OpenBSD. * pthread_stop_world.c (GC_suspend_all, GC_stop_world, GC_start_world): Handle OpenBSD case. * pthread_stop_world.c (GC_stop_init): Define as empty if OpenBSD. * pthread_support.c (pthread_sigmask): Don't undefine the macro and don't define the wrapper function if OpenBSD. * pthread_support.c (GC_thr_init): Handle OpenBSD case. * dyn_load.c: Move the inclusion of private/gc_priv.h below definition of a feature macro (_GNU_SOURCE). * include/gc.h (REVEAL_POINTER): Remove redundant parentheses. * include/gc.h (GC_HIDE_POINTER, GC_REVEAL_POINTER): New macros (only if GC_I_HIDE_POINTERS). * backgraph.c (GET_OH_BG_PTR): Prefix REVEAL_POINTER() with "GC_". * dbg_mlc.c (GC_get_back_ptr_info): Likewise. * finalize.c (GC_grow_table, GC_dump_finalization, GC_finalize, GC_enqueue_all_finalizers): Likewise. * backgraph.c (SET_OH_BG_PTR): Prefix HIDE_POINTER() with "GC_". * finalize.c (GC_general_register_disappearing_link, GC_unregister_disappearing_link, GC_register_finalizer_inner, GC_finalize): Likewise. * include/private/dbg_mlc.h (HIDE_BACK_PTR): Likewise. * include/private/dbg_mlc.h (GC_I_HIDE_POINTERS): Define instead of I_HIDE_POINTERS. * include/private/gc_priv.h (GC_I_HIDE_POINTERS): Likewise. * include/gc.h (_GC_H): Strip leading underscore. * include/gc_backptr.h (_GC_H): Likewise. * include/gc_gcj.h (_GC_H): Likewise. * include/gc_mark.h (_GC_H): Likewise. * include/gc_typed.h (_GC_TYPED_H, _GC_H): Likewise. * include/javaxfc.h (_GC_H): Likewise. * include/new_gc_alloc.h (__GC_SPECIALIZE): Likewise. * include/private/dbg_mlc.h (_GC_H): Likewise. * include/private/gc_priv.h (_GC_H): Likewise. * gc_cpp.cc: Include "gc_cpp.h" instead of . * include/private/gc_priv.h (GC_INNER): New macro (for GC-scope variable definitions). * include/private/gc_priv.h (GC_EXTERN): Update the comment. * allchblk.c (GC_unmap_threshold): Define as GC_INNER. * alloc.c (GC_incremental, GC_world_stopped, GC_n_heap_sects, GC_n_memory, GC_fail_count): Likewise. * blacklst.c (GC_black_list_spacing, GC_print_heap_obj): Likewise. * gcj_mlc.c (GC_gcj_malloc_initialized, GC_gcjobjfreelist): Likewise. * mach_dep.c (GC_save_regs_ret_val): Likewise. * mark.c (GC_n_mark_procs, GC_obj_kinds, GC_n_kinds, GC_mark_stack, GC_mark_stack_limit, GC_mark_stack_size, GC_mark_stack_top, GC_mark_state, GC_mark_stack_too_small, GC_mark_no, GC_markers): Likewise. * mark_rts.c (GC_root_size, GC_push_typed_structures): Likewise. * misc.c (GC_allocate_ml, GC_debugging_started, GC_check_heap, GC_print_all_smashed, GC_print_back_height, GC_dump_regularly, GC_backtraces, GC_force_unmap_on_gcollect, GC_large_alloc_warn_interval, GC_is_initialized, GC_write_cs, GC_current_warn_proc, GC_blocked_sp, GC_activation_frame): Likewise. * os_dep.c (GC_page_size, GC_dont_query_stack_min, GC_no_win32_dlls, GC_wnt, GC_sysinfo, GC_push_other_roots, GC_dirty_maintained, GC_fault_handler_lock): Likewise. * pthread_support.c (GC_allocate_ml, GC_lock_holder, GC_need_to_lock, GC_thr_initialized, GC_threads, GC_in_thread_creation, GC_collecting, GC_allocate_lock, GC_mark_lock_holder): Likewise. * reclaim.c (GC_bytes_found, GC_fl_builder_count, GC_have_errors): Likewise. * win32_threads.c (GC_allocate_ml, GC_lock_holder, GC_need_to_lock, GC_mark_lock_holder, GC_collecting): Likewise. * extra/gc.c (GC_INNER, GC_EXTERN): Define as STATIC. * mach_dep.c (GC_with_callee_saves_pushed): Remove redundant {}. * include/private/gc_priv.h (GC_bytes_allocd, GC_objfreelist, GC_aobjfreelist): Replace GC_EXTERN to extern for SEPARATE_GLOBALS case (since they are not defined inside GC at present). * include/private/gc_priv.h (GC_objects_are_marked): Remove the declaration (since made static). * mark.c (GC_objects_are_marked): Define as STATIC. * win32_threads.c (GC_thr_initialized, GC_in_thread_creation): Likewise. * mark.c (GC_N_KINDS_INITIAL_VALUE): New macro (defined and used to initialize GC_n_kinds). * win32_threads.c (start_mark_threads): Adjust the comment. * alloc.c (GC_notify_full_gc): Use GC_INLINE for a tiny static function. * backgraph.c (pop_in_progress, GC_apply_to_each_object): Likewise. * mark_rts.c (add_roots_to_index): Likewise. * extra/gc.c: New file. * Makefile.am (EXTRA_DIST): Add "extra/gc.c". * misc.c (GC_log): Remove the declaration; move the definition (to the place where it is used); make STATIC. * misc.c (GC_init): Use GC_err_printf() instead of GC_log_printf() to print open log failure. * misc.c (GC_write): Don't abort on open log failure if the GC is compiled with GC_PRINT_VERBOSE_STATS (useful for WinCE). * include/private/gcconfig.h (USE_MMAP): Guard with ifndef. * allchblk.c (GC_fail_count, GC_large_alloc_warn_interval): Move the variable declaration to gc_priv.h. * alloc.c (GC_bytes_found, GC_unmap_threshold, GC_force_unmap_on_gcollect): Likewise. * dyn_load.c (GC_no_win32_dlls, GC_wnt): Likewise. * finalize.c (GC_fail_count): Likewise. * include/private/gc_locks.h (GC_allocate_ml, GC_lock_holder, GC_collecting, GC_mark_lock_holder, GC_need_to_lock): Likewise. * include/private/gc_pmark.h (GC_n_mark_procs, GC_mark_stack_size, GC_mark_stack_limit, GC_mark_stack_top, GC_mark_stack, GC_mark_stack_too_small, GC_mark_state): Likewise. * include/private/pthread_support.h (GC_threads, GC_thr_initialized, GC_in_thread_creation): Likewise. * mallocx.c (GC_bytes_found): Likewise. * mark_rts.c (GC_save_regs_ret_val, GC_world_stopped): Likewise. * misc.c (GC_unmap_threshold): Likewise. * os_dep.c (GC_unmap_threshold): Likewise. * pthread_support.c (GC_markers): Likewise. * thread_local_alloc.c (GC_gcjobjfreelist, GC_gcj_malloc_initialized, GC_gcj_kind): Likewise. * win32_threads.c (GC_fault_handler_lock, GC_write_cs, GC_dont_query_stack_min, GC_markers, GC_wnt): Likewise. * include/private/gc_priv.h (GC_EXTERN): New macro (used mostly as a tag for now); defined after "gcconfig.h" inclusion. * include/private/gc_priv.h: Use GC_EXTERN instead of "extern" keyword for most global variables. * alloc.c (GC_copyright): Add the comment about the symbol visibility. * finalize.c (GC_fo_entries): Likewise. * include/private/gc_priv.h (GC_print_stats): Likewise. * misc.c (GC_quiet): Likewise. * mallocx.c (GC_bytes_allocd_tmp): Make the volatile variable STATIC. * pthread_support.c (GC_threads): Add explicit zero initializer (to make the variable definition differ from the declaration). * backgraph.c (GC_quiet): Remove the declaration (not needed anymore since gc_priv.h is always included). * checksums.c (GC_quiet): Likewise. * gcj_mlc.c (GC_quiet): Likewise. * headers.c (GC_hdr_cache_hits, GC_hdr_cache_misses): Add the comment. * include/private/gc_hdrs.h (GC_hdr_cache_hits, GC_hdr_cache_misses): Likewise. * mark.c (GC_first_nonempty): Make the volatile variable STATIC. * pthread_stop_world.c (GC_stop_count, GC_world_is_stopped): Likewise. * win32_threads.c (GC_please_stop, GC_max_thread_index, GC_mark_mutex_waitcnt): Likewise. * pthread_support.c (GC_USE_LD_WRAP): Fix a typo (swapped 'L' and 'D') in the name. * gc_dlopen.c (GC_MUST_RESTORE_REDEFINED_DLOPEN): Define if dlopen redirection is turned off; turn it on later when dlopen real symbol is no longer needed (according to the comment and the same as in dyn_load.c). * gc_dlopen.c (WRAP_FUNC, REAL_FUNC): Rename to WRAP_DLFUNC and REAL_DLFUNC, respectively (to have unique names since the definitions may differ from that of the similar ones in pthread_support.c). * mark.c (source): Undefine the macro when no longer needed. * os_dep.c (handler): Rename the type to GC_fault_handler_t (to have the unique name across the project). * os_dep.c (STAT_BUF_SIZE, STAT_READ); Guard with ifndef; add the comment. * pthread_support.c (STAT_BUF_SIZE, STAT_READ): Likewise. * os_dep.c (sbrk): Undo sbrk() redirection (for ECOS) when no longer needed. * pthread_stop_world.c (pthread_sigmask): Undefine before using in GC_print_sig_mask() (only if DEBUG_THREADS); add the comment. * win32_threads.c (dlopen, _beginthread): Don't undefine (since neither redirected nor used here). * win32_threads.c (GC_Thread_Rep): Rename "table_management" to "tm" for short; remove "tm_" prefix. * win32_threads.c (in_use, next): Don't define the macros; use tm.in_use and tm.next fields, respectively (to ease debugging). * win32_threads.c (HASH): Rename to PTHREAD_MAP_HASH (to have unique name across the project). * include/private/gc_priv.h (I_HIDE_POINTERS): Define before gc.h inclusion. * include/private/gc_pmark.h (I_HIDE_POINTERS): Define if gc.h is not included yet. * finalize.c (I_HIDE_POINTERS): Don't define. * include/private/dbg_mlc.h (I_HIDE_POINTERS): Likewise. * misc.c (I_HIDE_POINTERS): Likewise. * include/private/dbg_mlc.h (HIDE_POINTER, REVEAL_POINTER, GC_hidden_pointer): Don't define if HIDE_POINTER is undefined. * include/private/gc_pmark.h: Remove the comment about gc_priv.h inclusion order. * dyn_load.c: Include gc_priv.h before using configuration information (MACOS). * dyn_load.c (GC_must_restore_redefined_dlopen): Rename to GC_MUST_RESTORE_REDEFINED_DLOPEN. * backgraph.c (SET_OH_BG_PTR): Place outermost parenthesis properly. * darwin_stop_world.c: Replace "if DEBUG_THREADS" with "ifdef DEBUG_THREADS". * pthread_stop_world.c: Likewise. * pthread_support.c: Likewise. * include/gc_inline.h: Guard with GC_INLINE_H. * alloc.c (GC_copyright): Define as const. * alloc.c (GC_collect_at_heapsize): Replace "static" with "STATIC" (since the name starts with "GC_" prefix). * dbg_mlc.c (GC_describe_type_fns): Likewise. * dyn_load.c (GC_FirstDLOpenedLinkMap, GC_register_dynlib_callback, GC_dyld_sections, GC_dyld_name_for_hdr, GC_dyld_image_add, GC_dyld_image_remove): Likewise. * malloc.c (GC_libpthread_start, GC_libpthread_end, GC_libld_start, GC_libld_end): Likewise. * mark_rts.c (GC_remove_root_at_pos, GC_rebuild_root_index): Likewise. * os_dep.c (GC_gww_read_dirty, GC_gww_page_was_dirty, GC_gww_page_was_ever_dirty, GC_mprotect_thread_notify, GC_mprotect_thread_reply, GC_mprotect_thread, GC_darwin_sigbus, GC_forward_exception): Likewise. * pthread_support.c (GC_syms_initialized): Likewise. * typd_mlc.c (GC_push_typed_structures_proc): Likewise. * win32_threads.c (GC_win32_dll_threads, GC_register_my_thread_inner, GC_lookup_pthread, GC_get_stack_min, GC_waitForSingleObjectInfinite): Likewise. * darwin_stop_world.c (GC_use_mach_handler_thread, GC_use_mach_handler_thread, GC_mach_threads_count): Replace "static" with "STATIC" and add zero initializer. * os_dep.c (GC_task_self, GC_ports, GC_mprotect_state, GC_sigbus_count): Likewise. * headers.c (free_hdr): Replace "static" with GC_INLINE. * misc.c (GC_tmp): Rename static variable to fwrite_gc_res. * os_dep.c (memory): Rename static variable to ecos_gc_memory. * os_dep.c (async_set_pht_entry_from_index): Make static (for MPROTECT_VDB case). * pthread_support.c (GC_real_pthread_create, GC_real_pthread_sigmask, GC_real_pthread_join, GC_real_pthread_detach, GC_init_real_syms): Use REAL_FUNC() macro for static GC_real_XXX symbols. * win32_threads.c (GC_may_be_in_stack): Remove "GC_" prefix. * alloc.c (GC_finish_collection): Replace getenv() with GETENV(). * dyn_load.c (GC_init_dyld): Likewise. * os_dep.c (GC_print_callers): Likewise. * dyn_load.c (GC_dyld_name_for_hdr): Cast _dyld_get_image_name() result (since it's always of "struct mach_header" type). * dyn_load.c (GC_init_dyld): Cast GC_dyld_image_add and GC_dyld_image_remove (to always have the first argument of "struct mach_header" pointer type). * configure.ac: Add threads support for OpenBSD case (threads may not work correctly for it). * acinclude.m4: Rename to m4/gc_set_version.m4. * m4/libtool.m4: Delete the file. * m4/lt~obsolete.m4: Likewise. * m4/ltoptions.m4: Likewise. * m4/ltsugar.m4: Likewise. * m4/ltversion.m4: Likewise. * include/private/gcconfig.h: Define DebugBreak() as _exit(-1) for x86mingw32ce toolchain to workaround the incorrect DebugBreak() declaration in winbase.h (the workaround would turn into a no-op when DebugBreak() will be defined as a macro in the toolchain). * include/private/gcconfig.h: Recognize __i386__ if WinCE (for x86mingw32ce toolchain). * include/private/gcconfig.h (NO_GETENV): Don't define for CeGCC toolchain (or if already defined). * include/private/gcconfig.h (NO_GETENV_WIN32): New macro (always defined for WinCE or if NO_GETENV is defined). * misc.c (GC_CreateLogFile): Use NO_GETENV_WIN32 macro instead of NO_GETENV one. * configure.ac: Add AC_CONFIG_MACRO_DIR([m4]). * Makefile.am: Add "ACLOCAL_AMFLAGS = -I m4". * libtool.m4: Remove. * m4/libtool.m4: New file (generated). * m4/lt~obsolete.m4: Likewise. * m4/ltoptions.m4: Likewise. * m4/ltsugar.m4: Likewise. * m4/ltversion.m4: Likewise. * include/gc.h (GC_UNDERSCORE_STDCALL): Recognize new macro; prefix GC_CreateThread and GC_ExitThread with '_' if defined. * doc/README.macros (GC_UNDERSCORE_STDCALL): Document. * alloc.c (GC_collect_or_expand): Add "retry" argument; add the comments; don't use "default" stop_func on a retry if GC_dont_expand. * alloc.c (GC_allocobj): Pass "retry" argument to GC_collect_or_expand(). * malloc.c (GC_alloc_large): Likewise. * include/private/gc_priv.h (GC_collect_or_expand): Move the declaration to malloc.c; add "retry" argument. * alloc.c (GC_start_call_back): Move the variable definition from misc.c. * include/private/gc_priv.h (GC_start_call_back): Remove the declaration. * alloc.c (GC_notify_full_gc): Remove unnecessary cast of 0. * alloc.c (GC_try_to_collect_inner): Also call stop_func at the beginning of the function. * include/gc.h (GC_try_to_collect): Refine the comment about stop_func. * alloc.c (GC_default_stop_func, GC_try_to_collect_general, GC_gcollect): Add the comment. * alloc.c (GC_try_to_collect_general): Move the assertion on stop_func != 0 to GC_try_to_collect(). * alloc.c (GC_try_to_collect_general): If stop_func == 0 then use GC_default_stop_func instead (holding the lock). * alloc.c (GC_gcollect): Pass 0 as stop_func instead of GC_default_stop_func (to prevent data races). * Makefile.direct: Move "define arguments" documentation to doc/README.macros; add reference to doc/README.macros. * Makefile.dj: Change the documentation reference to doc/README.macros. * README.QUICK: Likewise. * configure.ac: Likewise. * allchblk.c: Remove unnecessary "-D" from the comment. * doc/README.macros: Likewise. * README.environment: Likewise. * include/gc.h: Likewise. * include/gc_inline.h: Likewise. * include/private/gcconfig.h: Likewise. * README.QUICK: Fix a typo. * misc.c (GC_CreateLogFile): Use FILE_ATTRIBUTE_NORMAL for CreateFile(); don't immediately flush every write if very verbose. * doc/README.win32: Replace ".exe.log" to ".gc.log". * doc/README.win64: Likewise. * doc/README.win64: Fix a typo. * misc.c (GC_CreateLogFile): Strip executable file extension for the log file; use ".gc.log" extension (instead of ".log"). * include/gc_config_macros.h: Avoid the redefinition of GC_xxx_THREADS macros. * alloc.c (GC_try_to_collect_general): Change the type of "result" local variable to GC_bool. * include/gc_config_macros.h: Use old behavior for FreeBSD and NetBSD platform detection code (check that other GC_xxx_THREADS are undefined); add FIXME. * include/gc_config_macros.h: Rearrange the platform detection code (GC_WIN32_PTHREADS implies GC_WIN32_THREADS; define GC_THREADS first if GC_XXX_THREADS already set; define proper GC_XXX_THREADS if GC_THREADS; define GC_PTHREADS in a single place; define _REENTRANT if posix threads except for Win32). * alloc.c (GC_try_to_collect_general): New function (move the code from GC_try_to_collect, pass force_unmap argument). * alloc.c (GC_try_to_collect, GC_gcollect): Call GC_try_to_collect_general(). * alloc.c (GC_gcollect_and_unmap): New public function. * include/gc.h (GC_gcollect_and_unmap): New function declaration. * tests/test.c (window_proc): Call GC_gcollect_and_unmap() on WM_HIBERNATE event (instead of GC_set_force_unmap_on_gcollect() and GC_gcollect()). * include/gc.h (GC_allow_register_threads, GC_register_my_thread, GC_unregister_my_thread, GC_malloc_many): Refine the comment. * include/gc.h (GC_malloc_many, GC_NEXT): Declare unconditionally (that is, don't depend on GC_THREADS macro). * include/gc.h: Don't check for __CYGWIN32__ and __CYGWIN__ along with a check for GC_PTHREADS (since the former implies the latter). * include/gc.h (GC_SOLARIS_THREADS): Don't check for. * include/gc.h (GC_MIN, GC_MAX): Don't define. * mallocx.c (GC_malloc_many): Add comment to #endif. * configure.ac: Drop the subdir-objects Automake option, since it's incompatible with picking source files from libatomic_ops. * allchblk.c (GC_fail_count, GC_large_alloc_warn_interval): Add "extern" keyword to a global variable declaration (some compilers require it). * alloc.c (GC_bytes_found, GC_unmap_threshold, GC_force_unmap_on_gcollect): Likewise. * dyn_load.c (GC_no_win32_dlls, GC_wnt): Likewise. * finalize.c (GC_fail_count): Likewise. * include/private/gc_hdrs.h (GC_hdr_cache_hits, GC_hdr_cache_misses): Likewise. * mallocx.c (GC_bytes_found): Likewise. * mark_rts.c (GC_save_regs_ret_val, GC_world_stopped): Likewise. * misc.c (GC_unmap_threshold): Likewise. * os_dep.c (GC_unmap_threshold, GC_old_allocator): Likewise. * pthread_support.c (GC_markers): Likewise. * thread_local_alloc.c (GC_gcjobjfreelist, GC_gcj_malloc_initialized, GC_gcj_kind): Likewise. * win32_threads.c (GC_fault_handler_lock, GC_write_cs, GC_dont_query_stack_min, GC_markers, GC_wnt): Likewise. * tests/huge_test.c: Define GC_IGNORE_WARN (if not defined) to suppress misleading GC "Out of Memory!" warning printed on every GC_MALLOC(LONG_MAX) call. * tests/huge_test.c: Include "gc.h" instead of . * tests/huge_test.c (main): Replace K&R-style function definition with the ANSI C one. * dyn_load.c (GC_register_dynamic_libraries): Always use lpMaximumApplicationAddress value for WinCE (even for old versions). * os_dep.c (VER_PLATFORM_WIN32_CE): Define if not in winbase.h. * os_dep.c (GC_dont_query_stack_min): New global variable (only if WinCE and THREADS). * os_dep.c (GC_setpagesize): Adjust lpMaximumApplicationAddress for WinCE (prior to version 6) if not _WIN32_WCE_EMULATION; set GC_dont_query_stack_min for older WinCE (prior to version 5). * win32_threads.c (GC_dont_query_stack_min): Declare. * win32_threads.c (GC_get_stack_min): Rename the macro to GC_wince_evaluate_stack_min for WinCE; update the comment. * win32_threads.c (GC_push_stack_for, GC_get_next_stack): Use GC_wince_evaluate_stack_min() instead of GC_get_stack_min() for WinCE and don't update thread's last_stack_min value (only if GC_dont_query_stack_min). * win32_threads.c (GC_push_stack_for): Skip assertion for WinCE if GC_dont_query_stack_min (since the evaluated stack_min value may be incorrect if the stack is bigger than 64 KiB). * gc_dlopen.c (GC_dlopen): Add function redirector (only if GC_USE_LD_WRAP). * include/gc.h: Include "gc_pthread_redirects.h" even if GC_USE_LD_WRAP or GC_NO_THREAD_REDIRECTS. * include/gc_pthread_redirects.h (GC_PTHREAD_REDIRECTS_H): Don't define and check for (since included only from gc.h). * include/gc_pthread_redirects.h: Declare "GC_" symbols even if GC_USE_LD_WRAP or GC_NO_THREAD_REDIRECTS. * include/gc_pthread_redirects.h: Include signal.h only to get sigset_t definition. * Makefile.direct: Document GC_REGISTER_MEM_PRIVATE. * mark_rts.c (GC_is_tmp_root): Define also for WinCE unless NO_DEBUGGING (that is, replace _WIN32_WCE_EMULATION with MSWINCE). * os_dep.c (GC_sysinfo): Remove explicit global variable initialization to "{0}" (revert back the previous change) since it might produce a warning. * allchblk.c (GC_large_alloc_warn_interval): Move declaration from gc_priv.h. * allchblk.c (GC_large_alloc_warn_suppressed): Move definition from misc.c; define as STATIC. * include/private/gc_priv.h (GC_large_alloc_warn_interval, GC_large_alloc_warn_suppressed): Remove declaration. * alloc.c (GC_bytes_found): Add "defined in" comment. * mallocx.c (GC_bytes_found): Likewise. * misc.c (GC_unmap_threshold): Likewise. * os_dep.c (GC_old_allocator): Likewise. * pthread_support.c (GC_markers): Likewise. * thread_local_alloc.c (GC_gcjobjfreelist, GC_gcj_malloc_initialized, GC_gcj_kind): Likewise. * win32_threads.c (GC_markers): Likewise. * alloc.c (GC_start_time): Explicitly initialize to 0 or NULL (to be distinctive from a variable declaration). * backgraph.c (GC_max_height, GC_deepest_obj): Likewise. * blacklst.c (GC_old_normal_bl, GC_incomplete_normal_bl, GC_old_stack_bl, GC_incomplete_stack_bl): Likewise. * checksums.c (GC_faulted, GC_n_dirty_errors, GC_n_faulted_dirty_errors, GC_n_changed_errors, GC_n_clean, GC_n_dirty, GC_bytes_in_used_blocks): Likewise. * dbg_mlc.c (GC_smashed): Likewise. * finalize.c (GC_old_dl_entries): Likewise. * gcj_mlc.c (GC_gcj_kind, GC_gcj_debug_kind, GC_gcjobjfreelist, GC_gcjdebugobjfreelist): Likewise. * mach_dep.c (GC_save_regs_ret_val): Likewise. * mark.c (GC_n_rescuing_pages, GC_mark_stack, GC_mark_stack_limit, GC_mark_stack_top): Likewise. * misc.c (GC_min_sp, GC_high_water, GC_bytes_allocd_at_reset): Likewise. * os_dep.c (GC_data_start, GC_page_size, GC_sysinfo, GC_old_segv_handler, GC_old_bus_handler, GC_old_bus_handler_used_si, GC_old_segv_handler_used_si, GC_proc_buf, GC_proc_fd, GC_vd_base): Likewise. * pthread_stop_world.c (GC_stop_count, GC_stopping_pid): Likewise. * reclaim.c (GC_leaked): Likewise. * typd_mlc.c (GC_explicit_kind, GC_array_kind, GC_ext_descriptors, GC_typed_mark_proc_index, GC_array_mark_proc_index, GC_eobjfreelist, GC_arobjfreelist): Likewise. * win32_threads.c (GC_pthread_map_cache, GC_marker_cv, GC_marker_Id): Likewise. * dbg_mlc.c (GC_smashed, GC_n_smashed): Define as STATIC. * gcj_mlc.c (GC_gcjdebugobjfreelist): Likewise. * os_dep.c (GC_vd_base): Likewise. * pthread_support.c (GC_mark_threads): Likewise. * reclaim.c (GC_leaked): Likewise. * typd_mlc.c (GC_bm_table): Likewise. * mark_rts.c (GC_save_regs_ret_val): Change declaration type to that of definition; add "defined in" comment. * mark_rts.c (GC_push_current_stack): Remove unnecessary cast for GC_save_regs_ret_val. * misc.c (GC_check_heap, GC_print_all_smashed, GC_start_call_back): Remove unnecessary cast (of 0). * misc.c (GC_LARGE_ALLOC_WARN_INTERVAL): New tuning macro. * misc.c (GC_large_alloc_warn_interval): Initialize to GC_LARGE_ALLOC_WARN_INTERVAL value. * misc.c (GC_tmp): Change to "static". * os_dep.c (GC_mprotect_state): Define as static. * pthread_support.c (dummy_thread_local): Prefix with "GC_". * win32_threads.c (WinMain): Remove FIXME for WinCE. * os_dep.c (PROTECT, UNPROTECT): Use distinct ABORT messages. * configure.ac: Rewrite the tests for external or internal libatomic_ops. * configure.ac: In particular, drop the symbolic links. Add option --with-libatomic-ops for forced selection. * Makefile.am: Adjust the path of source files from libatomic_ops to not use the links. * Makefile.am (libgc_la_LIBADD): Add $(ATOMIC_OPS_LIBS). This will be empty if we use the bundled AO sources. * Makefile.am: Strip version suffix for libatomic_ops directory. * build_atomic_ops.sh: Likewise. * build_atomic_ops.sh.cygwin: Likewise. * configure_atomic_ops.sh: Likewise. * Makefile.direct: Remove AO_VERSION definition; strip version suffix for libatomic_ops directory. * NT_STATIC_THREADS_MAKEFILE: Likewise. * NT_X64_STATIC_THREADS_MAKEFILE: Likewise. * NT_X64_THREADS_MAKEFILE: Likewise. * gc.mak: Likewise. * libatomic_ops: Rename from "libatomic_ops-1.2". * alloc.c (GC_version): Add "const" keyword. * alloc.c (GC_get_version): New public function. * include/gc.h (GC_get_version): New function declaration; update the comment for the GC version. * include/private/gc_locks.h (GC_allocate_ml, GC_lock_holder, GC_collecting, GC_mark_lock_holder, GC_need_to_lock): Use "extern" (for the global variable declaration) again. * include/private/gc_pmark.h (GC_n_mark_procs, GC_mark_stack_size, GC_mark_stack_limit, GC_mark_stack_top, GC_mark_stack, GC_mark_stack_too_small, GC_mark_state): Likewise. * include/private/gcconfig.h (GC_register_stackbottom): Likewise. * include/private/pthread_support.h (GC_threads, GC_thr_initialized, GC_in_thread_creation): Likewise. * include/private/gc_priv.h: Likewise. * real_malloc.c: Include private/config.h if HAVE_CONFIG_H. * allchblk.c (GC_hblkfreelist): Define as STATIC. * blacklst.c (GC_total_stack_black_listed): Likewise. * include/private/gc_priv.h (GC_hblkfreelist, GC_stopped_mark, GC_total_stack_black_listed, GC_push_stubborn_structures): Remove declaration. * mark_rts.c (GC_stopped_mark): Add declaration (only if THREAD_LOCAL_ALLOC). * allchblk.c (GC_fail_count): Move the declaration out of GC_allochblk_nth(); remove "extern". * alloc.c (IF_THREADS): Remove unused macro. * alloc.c (GC_world_stopped): Define only if THREAD_LOCAL_ALLOC. * alloc.c (GC_stopped_mark): Set GC_world_stopped value only if THREAD_LOCAL_ALLOC. * alloc.c (GC_bytes_found, GC_collection_in_progress, GC_check_tls, GC_unmap_threshold, GC_force_unmap_on_gcollect): Remove K&R-style "extern" for the declaration. * dbg_mlc.c (GC_free_inner): Likewise. * dyn_load.c (GC_repeat_read, GC_roots_present, GC_is_heap_base, GC_get_next_stack, GC_no_win32_dlls, GC_wnt): Likewise. * finalize.c (GC_fail_count): Likewise. * include/private/gc_hdrs.h (GC_hdr_cache_hits, GC_hdr_cache_misses): Likewise. * include/private/gc_locks.h (GC_allocate_ml, GC_lock_holder, GC_lock, GC_collecting, GC_mark_lock_holder, GC_need_to_lock): Likewise. * include/private/gc_pmark.h (GC_mark_procs, GC_n_mark_procs, GC_mark_stack_size, GC_mark_stack_limit, GC_mark_stack_top, GC_mark_stack, GC_mark_stack_too_small, GC_mark_state): Likewise. * include/private/gc_priv.h (GC_current_warn_proc, GC_obj_kinds, GC_n_kinds, GC_fo_entries, GC_n_heap_sects, GC_n_memory, GC_page_size, GC_sysinfo, GC_black_list_spacing, GC_objects_are_marked, GC_incremental, GC_dirty_maintained, GC_root_size, GC_debugging_started, GC_large_alloc_warn_interval, GC_large_alloc_warn_suppressed, GC_blocked_sp, GC_activation_frame, GC_push_other_roots, GC_push_finalizer_structures, GC_push_thread_structures, GC_push_typed_structures, GC_start_call_back, GC_is_initialized, GC_check_heap, GC_print_all_smashed, GC_print_all_errors, GC_print_heap_obj, GC_have_errors, GC_print_stats, GC_dump_regularly, GC_backtraces, GC_print_back_height, GC_debug_generic_malloc_inner, GC_debug_generic_malloc_inner_ignore_off_page, GC_fl_builder_count, GC_mark_no, GC_help_marker, GC_setup_temporary_fault_handler, GC_reset_fault_handler): Likewise. * include/private/gcconfig.h (GC_SysVGetDataStart, GC_FreeBSDGetDataStart, GC_register_stackbottom, GC_MacTemporaryNewPtr, GC_amiga_get_mem): Likewise. * include/private/pthread_support.h (GC_threads, GC_thr_initialized, GC_in_thread_creation): Likewise. * malloc.c (GC_text_mapping): Likewise. * mallocx.c (GC_bytes_found): Likewise. * mark.c (GC_check_dirty, GC_started_thread_while_stopped): Likewise. * mark_rts.c (GC_save_regs_ret_val): Likewise. * misc.c (GC_clear_stack_inner, GC_init_parallel, GC_init_win32, GC_setpagesize, GC_init_linux_data_start, GC_set_and_save_fault_handler, GC_unmap_threshold): Likewise. * os_dep.c (GC_unmap_threshold, GC_push_all_stacks, GC_darwin_register_mach_handler_thread): Likewise. * pthread_support.c (GC_markers, GC_collection_in_progress): Likewise. * tests/test.c (GC_amiga_free_all_mem): Likewise. * thread_local_alloc.c (GC_gcjobjfreelist, GC_gcj_malloc_initialized, GC_gcj_kind): Likewise. * win32_threads.c (GC_write_fault_handler, GC_gww_dirty_init, GC_fault_handler_lock, GC_write_cs, GC_markers): Likewise. * misc.c (GC_read, GC_register_finalizer_no_order, GC_init_dyld): Move the declaration out of GC_init(); remove "extern". * os_dep.c (GC_abort): Add the comment; add workaround to suppress compiler "unreachable code" warnings for ABORT callers (where ABORT is followed by a dummy return statement). * os_dep.c (GC_old_allocator): Move the declaration out of GC_default_push_other_roots(); remove "extern". * darwin_stop_world.c (GC_mprotect_stop, GC_mprotect_resume): Move the declaration out of GC_stop_world() and GC_start_world() (only if MPROTECT_VDB); remove "extern". * win32_threads.c (GC_get_stack_min, GC_push_stack_for, GC_get_next_stack): Recognize _WIN32_WCE_EMULATION macro (used for WinCE emulation and for custom WinCE 6 devices); add the comment. * win32_threads.c (GC_get_stack_min): Cast pointer to word instead of DWORD. * win32_threads.c (GC_get_next_stack): Don't use and maintain the latest known stack_min value for WinCE (if GC_get_stack_min is defined as a macro); update the comments. * win32_threads.c (GC_wnt): Don't declare for WinCE. * Makefile.direct: Document EMPTY_GETENV_RESULTS. * gcj_mlc.c (GC_clear_stack): Remove declaration. * malloc.c (GC_clear_stack): Likewise. * mallocx.c (GC_clear_stack): Likewise. * typd_mlc.c (GC_clear_stack): Likewise. * gcj_mlc.c (GENERAL_MALLOC, GENERAL_MALLOC_IOP): Rename to GENERAL_MALLOC_INNER and GENERAL_MALLOC_INNER_IOP, respectively; remove "lb" unnecessary cast to word. * include/private/gc_priv.h (GC_clear_stack): Add declaration. * include/private/gc_priv.h (GENERAL_MALLOC, GENERAL_MALLOC_IOP): Move common declaration from typd_mlc.c and malloc.c; remove unnecessary result and "lb" parameter casts. * include/private/thread_local_alloc.h: Guard against duplicate header file inclusion. * os_dep.c (USE_MUNMAP): Replace "-->" with an error directive for the case when USE_MMAP is not defined. * pthread_support.c (GC_is_thread_tsd_valid): New internal function (only if GC_ASSERTIONS and THREAD_LOCAL_ALLOC); move the code from thread-local GC_malloc(); add FIXME for the condition. * win32_threads.c (GC_is_thread_tsd_valid): Likewise. * thread_local_alloc.c (GC_gcjobjfreelist): Change the type (to match that of its definition). * thread_local_alloc.c (GC_destroy_thread_local): Add a cast for GC_gcjobjfreelist. * thread_local_alloc.c (GC_lookup_thread, GC_lookup_thread_inner): Remove unused declaration; don't include pthread.h. * thread_local_alloc.c (GC_is_thread_tsd_valid): New declaration (only if GC_ASSERTIONS). * thread_local_alloc.c (GC_malloc): Use GC_is_thread_tsd_valid() instead of GC_lookup_thread(). * win32_threads.c (GC_lookup_thread_inner): Define as STATIC. * win32_threads.c (UNPROTECT): Rename to UNPROTECT_THREAD (to have id different from that in os_dep.c). * allchblk.c (GC_enough_large_bytes_left): Replace "inline static" with GC_INLINE. * include/private/gc_priv.h (fixed_getenv): Likewise. * alloc.c (GC_max, GC_min): Replace "static INLINE" with GC_INLINE. * mark_rts.c (rt_hash): Likewise. * win32_threads.c (GC_get_max_thread_index): Likewise. * include/private/gc_priv.h (INLINE): Prefix with "GC_"; include "static"; define for Sun CC; define for VC++ (and other compilers). * pthread_support.c: Don't define __inline__ for non-GNU compilers (not needed anymore). * NT_THREADS_MAKEFILE: Remove file (since it duplicates gc.mak). * Makefile.in: Remove reference to NT_THREADS_MAKEFILE. * Makefile.am: Likewise. * Makefile.dj: Likewise. * Makefile.direct: Likewise. * doc/README.win32: Add reference to gc.mak. * NT_X64_THREADS_MAKEFILE: Likewise. * Makefile.direct: Remove references to acinclude.m4, libtool.m4. * autogen.sh: Update. * Makefile.am: Don't add libtool.m4 to EXTRA_DIST. * acinclude.m4: Fix underquoting of GC_SET_VERSION. * README.QUICK: Update information for Makefile. * Makefile.am: Do not distribute the substituted bdw-gc.pc. * configure.ac: Add AM conditional analog to KEEP_BACK_PTRS. * tests/tests.am: Use it here to conditionally enable tracetest when possible. * dyn_load.c (GC_wnt): Update the comment. * dyn_load.c (GC_register_dynamic_libraries): Add the comment for _WIN32_WCE_EMULATION; recognize GC_REGISTER_MEM_PRIVATE (new macro); call GC_is_heap_base() only if check for Type succeeded. * mark_rts.c (GC_is_tmp_root): Don't define unless NO_DEBUGGING; update the comment. * include/private/gc_priv.h (GC_is_tmp_root): Remove declaration. * include/private/gcconfig.h (CANCEL_SAFE, IF_CANCEL): new macros. * include/private/gc_priv.h (DISABLE_CANCEL, RESTORE_CANCEL, ASSERT_CANCEL_DISABLED): New macros. * alloc.c (GC_maybe_gc): Assert cancellation disabled. (GC_collect_a_little_inner,GC_try_to_collect, GC_collect_or_expand): Disable cancellation. (GC_add_to_our_memory): Check for overflow. * misc.c (GC_cancel_disable_count): declare. (GC_init, GC_write): Disable cancellation. (GC_init): Remove redundant GC_is_initialized test. * os_dep.c (GC_repeat_read): Assert cancellation disabled. (GC_get_stack_base): Disable cancellation. * pthread_stop_world.c (GC_suspend_handler_inner): Disable cancellation. * pthread_support.c (GC_mark_thread): Permanently disable cancellation. (GC_wait_for_gc_completion, GC_wait_builder, GC_wait_marker): Assert cancellation disabled. (fork handling): Disable cancellation, fix comment. (GC_pthread_create): Disable cancellation. (GC_unregister_my_thread): Disable cancellation. * Makefile.direct: Document NO_CANCEL_SAFE. * Makefile: Remove outdated file (Makefile.direct should be used instead). * include/gc.h (GC_use_DllMain): Refine the comment. * configure.ac: Add documentation to AC_DEFINE for GC_THREADS and EMPTY_GETENV_RESULTS. * configure.ac: Fix a typo. * Makefile.am: Likewise. * checksums.c (GC_checksum, GC_update_check_page): Remove "register" keyword in local variable declarations (for the code used only for debugging or which is not time-critical). * dbg_mlc.c (GC_has_other_debug_info, GC_store_debug_info, GC_store_debug_info_inner, GC_check_annotated_obj, GC_print_obj, GC_print_smashed_obj, GC_debug_end_stubborn_change, GC_debug_invoke_finalizer): Likewise. * dyn_load.c (GC_register_dynamic_libraries): Likewise. * mallocx.c (GC_realloc): Likewise. * mark_rts.c (GC_print_static_roots, GC_is_static_root, GC_clear_roots): Likewise. * misc.c (GC_write): Likewise. * os_dep.c (GC_print_callers): Likewise. * dyn_load.c (GC_register_dynamic_libraries): Rename "i" local variable to "j" for the nested loop (just not to hide the similar variable in the outer one). * mark_rts.c (GC_print_static_roots): Output an error message using GC_err_printf() (instead of GC_printf()). * configure.ac: Move include flag from ${INCLUDE} ... * Makefile.am: ... to AM_CPPFLAGS and also add the build directory. * configure.ac: Call AM_CONFIG_HEADER([include/private/config.h]). * configure.ac: Add documentation to all AC_DEFINE either directly or using AH_TEMPLATE. * win32_threads.c (GC_waitForSingleObjectInfinite): New static function (only if GC_WINMAIN_REDIRECT). * win32_threads.c (WinMain): Call GC_waitForSingleObjectInfinite() thru GC_do_blocking() instead of calling WaitForSingleObject() directly. * pthread_support.c (start_mark_threads): Refine printed message. * win32_threads.c (GC_thr_init): Likewise. * Makefile.direct (GC_WINMAIN_REDIRECT): Add the comment for. * Makefile.direct (NO_GETENV): Update the comment. * include/gc.h (GC_WINMAIN_WINCE_LPTSTR): Remove macro. * include/gc.h (GC_WinMain): Remove declaration. * include/gc.h (WinMain): Define (as GC_WinMain) if and only if GC_WINMAIN_REDIRECT. * tests/test.c (GC_COND_INIT): Define as GC_INIT() also in case of WinCE target unless GC_WINMAIN_REDIRECT is defined. * tests/test.c (WINMAIN_LPTSTR): New macro. * tests/test.c (WinMain): Use WINMAIN_LPTSTR instead of LP[W]STR and GC_WINMAIN_WINCE_LPTSTR. * win32_threads.c (start_mark_threads): Add the comment for MARK_THREAD_STACK_SIZE. * win32_threads.c: Recognize new GC_WINMAIN_REDIRECT macro. * win32_threads.c (WINMAIN_LPTSTR, WINMAIN_THREAD_STACK_SIZE): New macro (only if GC_WINMAIN_REDIRECT). * win32_threads.c: Undefine WinMain macro if GC_WINMAIN_REDIRECT. * win32_threads.c (GC_WinMain): Add prototype (only if GC_WINMAIN_REDIRECT). * win32_threads.c (main_thread_args, WinMain): Rename GC_WINMAIN_WINCE_LPTSTR to WINMAIN_LPTSTR. * win32_threads.c (WinMain): Call GC_INIT() instead of GC_init(); use WINMAIN_THREAD_STACK_SIZE. * win32_threads.c (WinMain): Call GC_deinit() and DeleteCriticalSection() only if WinCE; add FIXME. * os_dep.c (GC_get_main_stack_base): add assertion for mem_base value returned by GC_get_stack_base(). * Makefile.direct (MUNMAP_THRESHOLD, GC_FORCE_UNMAP_ON_GCOLLECT): Add the comment for. * alloc.c (GC_unmap_threshold, GC_force_unmap_on_gcollect): Declare external variable (only if USE_MUNMAP). * alloc.c (GC_try_to_collect): Temporarily set GC_unmap_threshold value to 1 if GC_force_unmap_on_gcollect and restore it before unlocking (only if USE_MUNMAP). * doc/README.environment (GC_FORCE_UNMAP_ON_GCOLLECT): Add information for. * include/gc.h (GC_set_force_unmap_on_gcollect, GC_get_force_unmap_on_gcollect): New public function prototype. * include/gc.h (GC_FORCE_UNMAP_ON_GCOLLECT): New macro is recognized. * misc.c (GC_FORCE_UNMAP_ON_GCOLLECT): Likewise. * include/gc.h (GC_INIT_CONF_FORCE_UNMAP_ON_GCOLLECT): New internal macro (used by GC_INIT only). * misc.c (GC_force_unmap_on_gcollect): New global variable. * misc.c (GC_init): Recognize new "GC_FORCE_UNMAP_ON_GCOLLECT" environment variable (and set GC_force_unmap_on_gcollect). * misc.c (GC_set_force_unmap_on_gcollect, GC_get_force_unmap_on_gcollect): New public function. * tests/test.c (window_proc): Call GC_set_force_unmap_on_gcollect to force the mode on if WM_HIBERNATE; restore the mode after GC_gcollect(). * Makefile.direct (LARGE_CONFIG): Update information. * include/gc.h (GC_stop_func): Refine the comment. * configure.ac: Use EMPTY_GETENV_RESULTS instead of NO_GETENV for Win32 (workaround for Wine bug). * allchblk.c (GC_freehblk): Adjust local variables indentation. * mallocx.c (GC_generic_malloc_many): Likewise. * typd_mlc.c (GC_malloc_explicitly_typed_ignore_off_page, GC_calloc_explicitly_typed): Likewise. * typd_mlc.c (GC_make_array_descriptor): Remove unnecessary brackets. * configure.ac: Replace GC_WIN32_THREADS with GC_THREADS. * configure.ac: Process enable_parallel_mark option for Cygwin and Win32; define THREAD_LOCAL_ALLOC for Win32. * include/private/gc_priv.h: Define AO_ASSUME_WINDOWS98 if PARALLEL_MARK (required for VC++ x86). * dbg_mlc.c (GC_generate_random_backtrace): Call GC_try_to_collect(GC_never_stop_func) instead of GC_gcollect(); if GC is disabled then print error message and return. * include/gc.h (GC_try_to_collect): Refine the comment. * include/private/gc_priv.h (GC_never_stop_func): Fix return type; refine the comment. * add_gc_prefix.c: Move the file to the new "extra" directory. * AmigaOS.c: Likewise. * gcname.c: Likewise. * if_mach.c: Likewise. * if_not_there.c: Likewise. * MacOS.c: Likewise. * msvc_dbg.c: Likewise. * setjmp_t.c: Likewise. * threadlibs.c: Likewise. * EMX_MAKEFILE: Prepend setjmp_t.c with "extra" directory. * Makefile: Prepend AmigaOS.c, MacOS.c, add_gc_prefix.c, gcname.c, if_mach.c, if_not_there.c, msvc_dbg.c, setjmp_t.c, threadlibs.c with "extra" directory. * Makefile.am: Likewise. * Makefile.direct: Likewise. * Makefile.dj: Likewise. * Makefile.in: Likewise. * NT_MAKEFILE: Prepend msvc_dbg.obj with "extra" directory. * NT_STATIC_THREADS_MAKEFILE: Likewise. * NT_X64_STATIC_THREADS_MAKEFILE: Likewise. * NT_X64_THREADS_MAKEFILE: Likewise. * NT_THREADS_MAKEFILE: Prepend msvc_dbg.c with "extra" directory. * gc.mak: Likewise. * PCR-Makefile: Prepend if_mach.c, if_not_there.c with "extra" directory. * SMakefile.amiga: Prepend AmigaOS.c, setjmp_t.c with "extra" directory. * doc/simple_example.html: Update for threadlibs.c. * os_dep.c: Prepend included AmigaOS.c with "extra" directory. * include/gc.h (GC_do_blocking, GC_call_with_gc_active): New function prototype. * include/private/gc_priv.h (STOP_WORLD): Replace a no-op (for the single-threaded case) with an assertion check for the state to be not a "do-blocking" one. * include/private/gc_priv.h (blocking_data): Move the structure definition from pthread_support.c; change "fn" return type to void pointer. * include/private/gc_priv.h (GC_activation_frame_s): New structure type. * include/private/gc_priv.h (GC_push_all_stack_frames): New function declaration (only if THREADS). * include/private/gc_priv.h (GC_world_stopped): Don't declare unless THREADS. * include/private/gc_priv.h (GC_blocked_sp, GC_activation_frame_s): New declaration (only if not THREADS). * include/private/gc_priv.h (GC_push_all_register_frames): New function declaration (only for IA-64). * include/private/gc_priv.h (NURSERY, GC_push_proc): Remove obsolete (unused) symbols. * include/private/gc_priv.h (GC_push_all_stack_partially_eager): Remove declaration (since it is static now). * mark_rts.c (GC_push_all_stack_partially_eager): Move from mark.c (for code locality) and make STATIC. * mark_rts.c (GC_push_all_register_frames): New function (only for IA-64). * mark_rts.c (GC_push_all_stack_frames): New function (only if THREADS). * mark_rts.c (GC_add_trace_entry): New function prototype (used by GC_push_all_stack_partially_eager(), only if TRACE_BUF). * mark_rts.c (GC_push_all_stack_part_eager_frames): New function. * mar_rts.c (GC_save_regs_ret_val): Move the declaration out of a function body (only for IA-64). * mark_rts.c (GC_push_current_stack): Call GC_push_all_stack_part_eager_frames() instead of GC_push_all_stack_partially_eager(). * mark_rts.c (GC_push_current_stack): Call GC_push_all_register_frames() instead of GC_push_all_eager() for IA-64 backing store. * misc.c (GC_do_blocking_inner): Declare function (if THREADS only). * misc.c (GC_blocked_sp, GC_blocked_register_sp, GC_activation_frame): New global variables (only if not THREADS). * misc.c (GC_call_with_gc_active, GC_do_blocking_inner): New API function (only if not THREADS). * misc.c (GC_do_blocking): Move the function from pthread_support.c. * include/private/pthread_support.h (GC_Thread_Rep): Add "activation_frame" field. * pthread_stop_world.c (GC_push_all_stacks): Call GC_push_all_stack_frames() and GC_push_all_register_frames instead of GC_push_all_stack() and/or GC_push_all_eager(); don't check for STACK_GROWS_UP here. * pthread_support.c (GC_do_blocking_inner): Remove "static"; store "fn" result back to "client_data" field. * pthread_support.c (GC_call_with_gc_active): New API function. * win32_threads.c (GC_call_with_gc_active): Likewise. * win32_threads.c (GC_Thread_Rep): Add "thread_blocked_sp" and "activation_frame" fields. * win32_threads.c (GC_new_thread): Add assertion checking for thread_blocked_sp is NULL. * win32_threads.c (GC_do_blocking_inner): New function. * win32_threads.c (GC_stop_world): Don't suspend a thread if its thread_blocked_sp is non-NULL. * win32_threads.c (GC_push_stack_for): Use thread "activation_frame" (if non-NULL); use "thread_blocked_sp" if non-NULL (instead of calling GetThreadContext()); "UNPROTECT" the thread before modifying its last_stack_min; call GC_push_all_stack_frames() instead of GC_push_all_stack(); update the comments. * alloc.c (GC_default_stop_func): New static variable (initialized to GC_never_stop_func). * alloc.c (GC_set_stop_func, GC_get_stop_func): New function. * alloc.c (GC_timeout_stop_func): Define as GC_default_stop_func (instead of GC_never_stop_func) if SMALL_CONFIG (or NO_CLOCK), else call GC_default_stop_func() before getting "current_time". * alloc.c (GC_maybe_gc): Expand GC_gcollect_inner() macro (for FIXME comment). * alloc.c (GC_maybe_gc, GC_collect_a_little_inner): add FIXME for replacing GC_never_stop_func with GC_default_stop_func (if possible). * alloc.c (GC_gcollect): Use GC_default_stop_func. * alloc.c (GC_collect_or_expand): Use GC_default_stop_func (instead of GC_never_stop_func) unless it is trigged due to out of memory; don't increment GC_fail_count and don't output warning (before trying to collect again) in case the collection has been interrupted (by GC_default_stop_func) and the heap expansion has failed too. * include/gc.h (GC_set_stop_func, GC_get_stop_func): New function prototypes. * os_dep.c (GC_get_stack_base): Add FIXME; add assertion for GC_get_writable_length() result. * configure.ac: Don't use -lpthread -ldl for Cygwin. * NT_THREADS_MAKEFILE: Make it back equal to gc.mak. * include/private/gcconfig.h (GWW_VDB): Undefine if USE_GLOBAL_ALLOC (since incompatible). * os_dep.c (GetWriteWatch_alloc_flag): Define as 0 unless GWW_VDB is defined. * os_dep.c (GC_unmap_threshold): Declare (for use in GC_init_win32) if USE_MUNMAP. * os_dep.c (GC_init_win32): Turn off memory unmapping if GlobalAlloc() is used. * os_dep.c (GC_win32_get_mem): Define and use new VIRTUAL_ALLOC_PAD macro; don't waste a extra memory page unless MPROTECT_VDB is in use. * Makefile: Replace "version.h" with "include/gc_version.h". * include/gc_version.h: Likewise. * alloc.c (GC_collect_or_expand): Output heap size in WARN() (before returning FALSE) for convenience. * allchblk.c (GC_allochblk_nth): Use GC_PRIdPTR in WARN() format string. * pthread_support.c (start_mark_threads, GC_thr_init): Likewise. * win32_threads.c (GC_delete_thread): Likewise. * include/private/gc_priv.h (GC_PRIdPTR): New macro. * pthread_stop_world.c (GC_suspend_handler_inner): Remove unnecessary cast for WARN argument. * pthread_support.c (start_mark_threads): if pthread_create() failed then don't try to create other marker threads and (after printing a warning) adjust GC_markers and GC_parallel values; log GC_markers value (possibly adjusted) after that. * win32_threads.c (start_mark_threads): if pthread_create() is failed then don't try to create other marker threads and (after printing a warning) adjust GC_markers and GC_parallel values. * win32_threads.c (mark_mutex_event, builder_cv, mark_cv): Move the definition upper (to be visible in start_mark_threads()). * win32_threads.c (start_mark_threads): if CreateThread() or _beginthreadex() is failed then don't try to create other marker threads and (after printing a warning) adjust GC_markers, GC_parallel values, and destroy the event objects (either only some for the uncreated threads if DONT_USE_SIGNALANDWAIT or all if not a single thread is created). * win32_threads.c (GC_thr_init): Log GC_markers value (possibly adjusted) after start_mark_threads() call. * Makefile.am: Back remove "GC_" prefix for PTHREADS, DARWIN_THREADS, WIN32_THREADS (for configure.ac). * include/private/gc_priv.h: Change include of config.h to private/config.h. * include/private/gc_pmark.h: Likewise. * gc_cpp.cc: Likewise. * tests/test.c: Likewise. * tests/test_cpp.cc: Include private/config.h (if HAVE_CONFIG_H); undefine GC_BUILD. * finalize.c (GC_general_register_disappearing_link): Return GC_SUCCESS, GC_DUPLICATE, GC_NO_MEMORY (instead of 0, 1 and 2, respectively). * include/gc.h (GC_NO_MEMORY): New macro (defined as 2). * include/gc.h (GC_register_disappearing_link, GC_general_register_disappearing_link): Update the comment. * typd_mlc.c (GC_calloc_explicitly_typed): Use GC_NO_MEMORY macro. * finalize.c (GC_general_register_disappearing_link, GC_register_finalizer_inner): Recalculate the hash table index after GC_oom_fn succeeded (since the table may grow while not holding the lock) and check again that the entry is still not in the table (free the unused entry otherwise unless DBG_HDRS_ALL). * finalize.c (GC_register_finalizer_inner): Initialize "hhdr" local variable (to prevent a compiler warning). * finalize.c (GC_register_finalizer_inner): Don't modify the data pointed by "ocd" and "ofn" in GC_register_finalizer_inner() failed (due to out of memory). * alloc.c (GC_set_fl_marks, GC_clear_fl_marks): Transform loop to suppress compiler "variable might be uninitialized" warnings. * Makefile.direct (DONT_USE_SIGNALANDWAIT): Add the comment for. * win32_threads.c (DONT_USE_SIGNALANDWAIT): Always define for WinCE. * win32_threads.c (THREAD_HANDLE): Cast Id (of DWORD type) to HANDLE thru word type (to avoid a compiler warning) for WinCE. * win32_threads.c (GC_marker_cv, GC_marker_Id): New static array (only if DONT_USE_SIGNALANDWAIT). * win32_threads.c (start_mark_threads): Initialize GC_marker_Id and GC_marker_cv for each helper thread (only if DONT_USE_SIGNALANDWAIT). * win32_threads.c (GC_mark_mutex_state): New static variable (only if DONT_USE_SIGNALANDWAIT). * win32_threads.c (GC_mark_mutex_waitcnt, signalObjectAndWait_func): Don't define if DONT_USE_SIGNALANDWAIT. * win32_threads.c (GC_acquire_mark_lock, GC_release_mark_lock): Use InterlockedExchange() over GC_mark_mutex_state (instead of AO_fetch_and_add()) if DONT_USE_SIGNALANDWAIT. * win32_threads.c (GC_wait_marker, GC_notify_all_marker): Implement wait/broadcast primitives using Win32 multiple events (one for each marker thread) if DONT_USE_SIGNALANDWAIT (instead of using Win32 SignalObjectAndWait). * win32_threads.c (GC_thr_init): Don't declare hK32 local variable, don't check for GC_wnt, and don't initialize signalObjectAndWait_func if DONT_USE_SIGNALANDWAIT. * alloc.c (GC_finish_collection): Call GC_print_finalization_stats if GC_print_stats (after getting "done_time"). * finalize.c (GC_old_dl_entries): New static variable (only if not SMALL_CONFIG). * finalize.c (GC_finalize): Save current GC_dl_entries value (only if not SMALL_CONFIG). * finalize.c (GC_print_finalization_stats): Define if and only if not SMALL_CONFIG; use GC_old_dl_entries value; use GC_log_printf() instead of GC_printf(); use "%lu" (instead of "%u") print format specifier; use unsigned long type for "ready" counter (for LP64 targets). * misc.c (GC_dump): No longer call GC_print_finalization_stats() here (since it is called from GC_finish_collection()). * misc.c (STACKBASE): Remove unused macro undef (for NOSYS and ECOS). * alloc.c (GC_expand_hp): Replace GC_init_inner() call with GC_init() one. * malloc.c (GC_alloc_large, GC_generic_malloc_inner): Likewise. * mallocx.c (GC_generic_malloc_many): Likewise. * misc.c (GC_enable_incremental): Likewise. * alloc.c (GC_expand_hp): Update the comment. * mark.c (GC_obj_kinds): Likewise. * win32_threads.c (GC_allow_register_threads): Likewise. * private/gc_priv.h (GC_init_inner): Remove function declaration. * misc.c (GC_init_inner): Replace with public GC_init(). * gcj_mlc.c (GC_gcj_fake_mark_proc): New static function. * gcj_mlc.c (GC_init_gcj_malloc): If mp is 0 then supply GC_gcj_fake_mark_proc (aborting with the appropriate message) instead. * os_dep.c (GC_wince_get_mem): If VirtualAlloc() returns NULL (due to out of memory) then don't increment GC_n_heap_bases and don't call VirtualAlloc() again (with MEM_COMMIT). * os_dep.c (GC_remap): Abort with a more informatory message if VirtualAlloc() fails due to out of memory; update FIXME. * Makefile: Fix typo for msvc_dbg.c. * Makefile.direct: Likewise. * Makefile.am: Prefix PTHREADS, DARWIN_THREADS, WIN32_THREADS with "GC_". * Makefile.dj: Don't reference remove files (nursery.c, gc_nursery.h, gc_copy_descr.h). * NT_MAKEFILE: Don't define __STDC__ macro (no longer used). * NT_STATIC_THREADS_MAKEFILE: Likewise. * NT_THREADS_MAKEFILE: Likewise. * NT_X64_STATIC_THREADS_MAKEFILE: Likewise. * NT_X64_THREADS_MAKEFILE: Likewise. * gc.mak: Likewise. * NT_MAKEFILE: Remove unnecessary -DGC_BUILD (since it is always defined in the source files). * NT_THREADS_MAKEFILE: Likewise. * NT_X64_THREADS_MAKEFILE: Likewise. * gc.mak: Likewise. * NT_X64_THREADS_MAKEFILE: Fix typo for -DGC_NOT_DLL. * NT_STATIC_THREADS_MAKEFILE: Replace GC_WIN32_THREADS with GC_THREADS. * NT_THREADS_MAKEFILE: Likewise. * NT_X64_STATIC_THREADS_MAKEFILE: Likewise. * NT_X64_THREADS_MAKEFILE: Likewise. * gc.mak: Likewise. * NT_MAKEFILE: Define _CRT_SECURE_NO_DEPRECATE to suppress the compiler warnings. * NT_STATIC_THREADS_MAKEFILE: Likewise. * NT_X64_STATIC_THREADS_MAKEFILE: Place -D_CRT_SECURE_NO_DEPRECATE before "$*.C" (and "$*.CPP"). * NT_X64_THREADS_MAKEFILE: Likewise. * doc/README.solaris2: Replace GC_SOLARIS_THREADS with GC_THREADS. * doc/README.win32: Replace GC_WIN32_THREADS with GC_THREADS. * doc/README.win64: Add info about mingw-w64; add note for VC++ warnings suppression. * os_dep.c (GC_forward_exception): Fix logic in several places. (OSX-specific) * include/private/gc_priv.h (MAX_HEAP_SECTS): Guard with ifndef. * Makefile.direct: Copy missing information for -DSHORT_DBG_HDRS from Makefile. * Makefile: Remove the information about "define arguments" (which is incomplete and outdated compared to that in Makefile.direct); add help reference to Makefile.direct. * Makefile.dj: Likewise. * alloc.c (world_stopped_total_time, world_stopped_total_divisor): Replace "STATIC" with "static" in the definition (since the symbols aren't prefixed with "GC_"). * win32_threads.c (marker_sp, marker_bsp, marker_last_stack_min, start_mark_threads, mark_mutex, builder_cv, mark_cv, mark_mutex_event, signalObjectAndWait_func, main_thread_start): Likewise. * pthread_support.c (GC_wait_builder): Define as STATIC. * win32_threads.c (GC_wait_builder): Likewise. * misc.c (GC_get_heap_size_inner, GC_get_free_bytes_inner): New API function. * include/gc_pmark.h (GC_get_heap_size_inner, GC_get_free_bytes_inner): New function declaration. * include/gc.h: Recognize __CEGCC__ (as a synonym for _WIN32_WCE). * include/gc_config_macros.h: Likewise. * include/gc.h (GC_MAXIMUM_HEAP_SIZE): Recognize new macro. * include/gc.h (GC_INIT_CONF_MAXIMUM_HEAP_SIZE): New macro (for internal use). * include/gc_config_macros.h: Always include stddef.h if GCC. * include/gc_config_macros.h (GC_API): Define for CeGCC in the same way as for MinGW. * include/gc_config_macros.h (GC_API): Group the definition for all cases together (check for GC_DLL only once). * include/gc_pthread_redirects.h: Group non-Darwin code together. * tests/test.c: Recognize GC_PRINT_VERBOSE_STATS (only if GC_DLL). * Makefile.direct (GC_PTHREADS_PARAMARK, GC_IGNORE_GCJ_INFO, GC_PRINT_VERBOSE_STATS, GC_DONT_EXPAND, GC_INITIAL_HEAP_SIZE, GC_FREE_SPACE_DIVISOR, GC_TIME_LIMIT, GC_FULL_FREQ): Add the comment for. * misc.c (GC_init_inner): Recognize GC_PRINT_VERBOSE_STATS (new macro). * dyn_load.c (GC_wnt): Change definition to TRUE for WinCE; add FIXME and the comment for WinCE. * gcj_mlc.c (GC_init_gcj_malloc): Recognize GC_IGNORE_GCJ_INFO (new macro). * include/gc.h (GC_HAVE_BUILTIN_BACKTRACE): Don't define for VC++ WinCE (since backtrace() is unimplemented). * include/private/gc_priv.h (GC_n_heap_bases): Remove declaration (since static). * os_dep.c (GC_n_heap_bases): Define as STATIC; move the definition to be above GC_is_heap_base(). * include/private/gcconfig.h: Don't define NOSYS for WinCE on ARM (both for MinGW and CeGCC toolchains). * include/private/gcconfig.h: Recognize __CEGCC__ and __MINGW32CE__ (as synonyms for __WIN32_WCE). * include/private/gcconfig.h: If SH4 then don't set config parameters for SH. * include/private/thread_local_alloc.h (GC_key_create): Don't abort on failures, just return -1 in these cases (this also prevents compilation error for targets where ABORT is defined indirectly as an inline assembler sequence). * mark.c (WRAP_MARK_SOME): Also define for WinCE; add FIXME for the GCC-based cross-compiler. * mark.c (ext_ex_regn, mark_ex_handler): Don't define unless WRAP_MARK_SOME is defined; define also for WinCE case; don't check for _WIN64 (since WRAP_MARK_SOME is undefined for it). * mark.c (GC_mark_some): Use __try/__except also for WinCE; update the comment. * misc.c: Include signal.h after gc_pmark.h included; check for MSWINCE instead of _WIN32_WCE. * misc.c (GC_init_inner): Remove duplicate GC_setpagesize() call. * misc.c: Don't include for WinCE targets. * misc.c (GC_write): Define _MAX_PATH if undefined (workaround for CeGCC toolchain). * misc.c (GC_write): Use OutputDebugStringW() instead of _CrtDbgReport() for WinCE targets. * os_dep.c (GC_least_described_address): Define as STATIC. * os_dep.c (GC_register_data_segments): Fix code indentation. * os_dep.c (GC_wince_get_mem): Initialize "result" local variable (to prevent a compiler warning). * os_dep.c (GC_dirty_init): Add comment for WinCE target. * tests/test.c: Don't include winbase.h directly if GCC for WinCE, include assert.h instead. * tests/test.c (tiny_reverse_test): Define and use TINY_REVERSE_UPPER_VALUE macro (4 if VERY_SMALL_CONFIG else 10); useful for WinCE. * win32_threads.c (GC_Thread_Rep): Don't declare "handle" field for WinCE (since thread Id is used as a "real" thread handle). * win32_threads.c (THREAD_HANDLE): New macro. * win32_threads.c (GC_register_my_thread_inner): Don't recognize DONT_IMPORT_GETCURTHREAD anymore; don't record thread handle on WinCE. * Makefile.direct (DONT_IMPORT_GETCURTHREAD): Remove comment for. * win32_threads.c (UNPROTECT, GC_fault_handler_lock): Don't check for MSWINCE. * win32_threads.c (GC_delete_gc_thread, GC_delete_thread): Don't close thread handle on WinCE (since it's a thread Id). * win32_threads.c (GC_suspend): Don't check for MSWINCE in the MPROTECT-related code (for the case if MPROTECT_VDB would be implemented for WinCE). * win32_threads.c (GC_suspend, GC_start_world, GC_push_stack_for): Use THREAD_HANDLE(t) to obtain thread handle. * win32_threads.c (GC_PTHREADS_PARAMARK): New macro recognized; implicitly define GC_PTHREADS_PARAMARK if GC_PTHREADS; include pthread.h; define NUMERIC_THREAD_ID(id) if undefined yet; replace GC_PTHREADS with GC_PTHREADS_PARAMARK where appropriate (for the parallel mark support). * win32_threads.c (start_mark_threads): Use int type for "i" local variable (instead of "unsigned") to prevent a compiler warning. * win32_threads.c (start_mark_threads): Don't check CreateThread() result for -1; call CloseHandle() for the handle created by CreateThread() (on WinCE); don't use errno (since errno.h is missing on some targets like WinCE) when printing warning on a marker thread creation failure. * win32_threads.c (signalObjectAndWait_func): Define for WinCE. * win32_threads.c (GC_wait_marker): Remove unnecessary assertion for non-zero signalObjectAndWait_func (to make the code compilable for WinCE). * win32_threads.c (GC_thr_init): Allow PARALLEL_MARK for WinCE; use GC_sysinfo to get processors count if WinCE; don't check for SignalObjectAndWait() if WinCE; replace GC_PTHREADS with GC_PTHREADS_PARAMARK. * win32_threads.c (GC_thr_init): Recognize GC_MIN_MARKERS new macro (useful for testing parallel marking on WinCE). * win32_threads.c (GC_win32_start, main_thread_start): Define as STATIC. * win32_threads.c: Don't define main_thread_args, main_thread_start(), WinMain() for WinCE if GC_DLL. * win32_threads.c (WINCE_MAIN_STACK_SIZE): Remove useless macro (since the stack size parameter is ignored on WinCE). * win32_threads.c (main_thread_start): Remove forward declaration; place its definition before WinMain() one. * win32_threads.c (WinMain): Abort if GC_CreateThread() or WaitForSingleObject() failed (for the main thread). * allchblk.c (MUNMAP_THRESHOLD): Move macro definition out of a function. * allchblk.c (GC_unmap_threshold): New global variable definition (initialized to MUNMAP_THRESHOLD). * allchblk.c (GC_unmap_old): Use GC_unmap_threshold instead of MUNMAP_THRESHOLD; skip unmapping if GC_unmap_threshold is 0. * doc/README.environment (GC_UNMAP_THRESHOLD): Add information. * misc.c (GC_unmap_threshold): New variable declaration. * misc.c (GC_init_inner): Recognize "GC_UNMAP_THRESHOLD" environment variable to set GC_unmap_threshold value (only if USE_MUNMAP). * dbg_mlc.c (OFN_UNSET): New macro (to detect GC_register_finalizer() failures). * dbg_mlc.c (store_old): Add a check for register_finalizer() failure caused by an out-of-memory event (leave *ofn and *ocd unmodified in that case). * dbg_mlc.c (GC_debug_register_finalizer, GC_debug_register_finalizer_no_order, GC_debug_register_finalizer_unreachable, GC_debug_register_finalizer_ignore_self): Initialize my_old_fn to OFN_UNSET; clear *ocd and *ofn for non-heap objects (the same as in GC_register_finalizer_inner()). * Makefile.direct (GC_DLL): Add the comment for. * doc/README.macros: Fix a typo. * doc/README.macros (_DLL, GC_DLL, GC_NOT_DLL): Update info. * doc/README.macros (__STDC__): Remove info. * dbg_mlc.c (GC_get_back_ptr_info, GC_generate_random_heap_address, GC_generate_random_valid_address, GC_print_backtrace, GC_generate_random_backtrace, GC_register_describe_type_fn): Add GC_API and GC_CALL to function definition. * malloc.c (GC_generic_malloc): Likewise. * mallocx.c (GC_incr_bytes_allocd, GC_incr_bytes_freed): Likewise. * mark.c (GC_mark_and_push): Likewise. * misc.c (GC_new_free_list_inner, GC_new_free_list, GC_new_kind_inner, GC_new_kind, GC_new_proc_inner, GC_new_proc): Likewise. * include/gc_backptr.h (GC_get_back_ptr_info, GC_generate_random_heap_address, GC_generate_random_valid_address, GC_generate_random_backtrace, GC_print_backtrace): Add GC_API and GC_CALL to function prototype. * include/gc_mark.h (GC_mark_and_push, GC_new_free_list, GC_new_free_list_inner, GC_new_kind, GC_new_kind_inner, GC_new_proc, GC_new_proc_inner, GC_generic_malloc, GC_register_describe_type_fn): Likewise. * include/new_gc_alloc.h (GC_incr_bytes_allocd, GC_incr_mem_freed, GC_generic_malloc_words_small): Likewise. * gc_cpp.cc: Include "config.h" (if HAVE_CONFIG_H defined). * include/private/gc_pmark.h: Likewise. * include/private/gc_priv.h: Likewise. * tests/test.c: Likewise. * gc_cpp.cc: Define GC_BUILD. * include/private/gc_pmark.h: Likewise. * include/private/gc_priv.h: Likewise. * gc_dlopen.c (WRAP_FUNC, REAL_FUNC): New macro. * gc_dlopen.c (dlopen): Add GC_API to the wrapper function definition. * pthread_support.c (GC_pthread_create, GC_pthread_sigmask, GC_pthread_join, GC_pthread_detach, pthread_sigmask, pthread_join, pthread_detach, pthread_create): Likewise. * win32_threads.c (GC_pthread_join, GC_pthread_create, GC_pthread_sigmask, GC_pthread_detach): Likewise. * gc_dlopen.c (dlopen): Use WRAP_FUNC and REAL_FUNC macros. * include/gc_backptr.h: Include "gc.h". * include/gc_backptr.h: Use extern "C" for the exported functions. * include/gc_mark.h: Likewise. * include/gc_config_macros.h (GC_THREADS): Define the macro if any GC_XXX_THREADS is defined. * include/gc_config_macros.h (_PTHREADS, _POSIX4A_DRAFT10_SOURCE): Move the definitions below the place where GC_NETBSD_THREADS and GC_DGUX386_THREADS are defined. * include/gc_config_macros.h (GC_DLL): Don't define (even if _DLL is defined) for GCC. * include/gc_config_macros.h (GC_API): Define for Cygwin (in the same way as for VC++); define for GCC v4+ (other than already recognized MinGW/Cygwin) as a "default" visibility attribute if GC_DLL is defined. * include/gc_config_macros.h (GC_ATTR_MALLOC, GC_ATTR_ALLOC_SIZE): New macro. * include/gc.h (GC_malloc, GC_malloc_atomic, GC_strdup, GC_malloc_uncollectable, GC_malloc_stubborn, GC_memalign, GC_malloc_atomic_uncollectable, GC_malloc_ignore_off_page, GC_malloc_atomic_ignore_off_page, GC_debug_malloc, GC_debug_malloc_atomic, GC_debug_strdup, GC_debug_malloc_uncollectable, GC_debug_malloc_stubborn, GC_debug_malloc_ignore_off_page, GC_debug_malloc_atomic_ignore_off_page, GC_debug_malloc_replacement): Add GC_ATTR_MALLOC attribute. * include/gc_gcj.h (GC_gcj_malloc, GC_debug_gcj_malloc, GC_gcj_malloc_ignore_off_page): Likewise. * include/gc.h (GC_malloc, GC_malloc_atomic, GC_malloc_uncollectable, GC_malloc_stubborn, GC_malloc_atomic_uncollectable, GC_malloc_ignore_off_page, GC_malloc_atomic_ignore_off_page, GC_debug_malloc, GC_debug_malloc_atomic, GC_debug_malloc_uncollectable, GC_debug_malloc_stubborn, GC_debug_malloc_ignore_off_page, GC_debug_malloc_atomic_ignore_off_page, GC_debug_malloc_replacement: Add GC_ATTR_ALLOC_SIZE attribute (for the first argument). * include/gc_gcj.h (GC_gcj_malloc, GC_debug_gcj_malloc, GC_gcj_malloc_ignore_off_page): Likewise. * include/gc.h (GC_memalign, GC_realloc, GC_debug_realloc, GC_debug_realloc_replacement): Add GC_ATTR_ALLOC_SIZE attribute (for the second argument). * include/gc.h (GC_malloc, GC_malloc_atomic, GC_strdup, GC_malloc_uncollectable, GC_malloc_stubborn, GC_memalign, GC_malloc_atomic_uncollectable, GC_free, GC_base, GC_size, GC_realloc, GC_expand_hp, GC_set_max_heap_size, GC_exclude_static_roots, GC_add_roots, GC_remove_roots, GC_register_displacement, GC_debug_register_displacement, GC_try_to_collect, GC_malloc_ignore_off_page, GC_malloc_atomic_ignore_off_page, GC_debug_malloc, GC_debug_malloc_atomic, GC_debug_strdup, GC_debug_malloc_uncollectable, GC_debug_malloc_stubborn, GC_debug_malloc_ignore_off_page, GC_debug_malloc_atomic_ignore_off_page, GC_debug_free, GC_debug_realloc, GC_debug_malloc_replacement, GC_debug_realloc_replacement, GC_finalization_proc, GC_register_finalizer, GC_debug_register_finalizer, GC_register_finalizer_ignore_self, GC_debug_register_finalizer_ignore_self, GC_register_finalizer_no_order, GC_debug_register_finalizer_no_order, GC_register_finalizer_unreachable, GC_debug_register_finalizer_unreachable, GC_register_disappearing_link, GC_general_register_disappearing_link, GC_unregister_disappearing_link, GC_noop1, GC_warn_proc, GC_set_warn_proc, GC_ignore_warn_proc, GC_fn_type, GC_call_with_alloc_lock, GC_stack_base_func, GC_call_with_stack_base, GC_same_obj, GC_pre_incr, GC_post_incr, GC_is_visible, GC_is_valid_displacement, GC_same_obj_print_proc, GC_is_valid_displacement_print_proc, GC_is_visible_print_proc, GC_malloc_many, GC_CreateThread, GC_beginthreadex, GC_endthreadex): Comment out (or remove if single and meaningless) function argument names (to avoid identifiers out of the name space). * include/gc_gcj.h (GC_init_gcj_malloc, GC_gcj_malloc, GC_debug_gcj_malloc, GC_gcj_malloc_ignore_off_page): Likewise. * include/gc.h (GC_try_to_collect): Update the comment. * include/gc.h (GC_size, GC_register_my_thread): Add const qualifier for the argument referent. * misc.c (GC_size): Likewise. * pthread_support.c (GC_register_my_thread_inner, GC_register_my_thread): Likewise. * win32_threads.c (GC_register_my_thread_inner, GC_register_my_thread): Likewise. * include/gc.h (GC_INIT_CONF_ROOTS): New macro for internal use (define instead of GC_INIT() for Cygwin and AIX). * include/gc.h (GC_DONT_EXPAND, GC_MAX_RETRIES, GC_FREE_SPACE_DIVISOR, GC_FULL_FREQ, GC_TIME_LIMIT, GC_IGNORE_WARN, GC_INITIAL_HEAP_SIZE): Recognize new macro. * include/gc.h (GC_INIT_CONF_DONT_EXPAND, GC_INIT_CONF_MAX_RETRIES, GC_INIT_CONF_FREE_SPACE_DIVISOR, GC_INIT_CONF_FULL_FREQ, GC_INIT_CONF_TIME_LIMIT, GC_INIT_CONF_IGNORE_WARN, GC_INIT_CONF_INITIAL_HEAP_SIZE): New macro for internal use. * include/gc.h (GC_INIT): Use GC_INIT_CONF_XXX macros. * include/gc_mark.h: Prefix GC_H with '_'. * include/gc_mark.h (GC_least_plausible_heap_addr, GC_greatest_plausible_heap_addr, GC_debug_header_size): Use GC_API for the public variable declaration. * include/new_gc_alloc.h (GC_objfreelist_ptr, GC_aobjfreelist_ptr, GC_uobjfreelist_ptr, GC_auobjfreelist_ptr): Likewise. * include/gc_pthread_redirects.h (GC_pthread_create, GC_pthread_sigmask, GC_dlopen, GC_pthread_join, GC_pthread_detach): Use GC_API for the wrapper prototype. * include/gc_pthread_redirects.h (pthread_create, pthread_join, pthread_detach, pthread_sigmask, dlopen): Undefine unconditionally before redirecting. * include/new_gc_alloc.h: Replace GC_incr_mem_freed() with GC_incr_bytes_freed(); remove FIXME. * include/private/gc_priv.h (GC_make_closure, GC_debug_invoke_finalizer, GC_noop): Remove GC_API for the private function. * tests/test.c (GC_print_stats): Handle GC_DLL case regardless of the target. * finalize.c (GC_general_register_disappearing_link, GC_register_finalizer_inner): Remove unnecessary "ifdef THREADS" guard for LOCK/UNLOCK(). * finalize.c (GC_general_register_disappearing_link, GC_register_finalizer_inner): Get GC_oom_fn value before releasing the lock (to prevent data races). * gcj_mlc.c (GC_gcj_malloc, GC_debug_gcj_malloc, GC_gcj_malloc_ignore_off_page): Likewise. * mallocx.c (GC_generic_malloc_ignore_off_page): Likewise. * include/gc_inline.h (GC_FAST_MALLOC_GRANS): Use GC_get_oom_fn() instead of GC_oom_fn (to prevent data races). * malloc.c (GC_generic_malloc): Likewise. * mallocx.c (GC_memalign): Likewise. * pthread_support.c (pthread_create): Likewise. * gcj_mlc.c (maybe_finalize): Acquire the lock before setting last_finalized_no value to prevent data races. * include/gc.h (GC_gc_no, GC_get_gc_no, GC_oom_fn, GC_set_oom_fn, GC_set_find_leak, GC_set_finalize_on_demand, GC_set_java_finalization, GC_set_finalizer_notifier, GC_set_dont_expand, GC_set_full_freq, GC_set_non_gc_bytes, GC_set_no_dls, GC_set_free_space_divisor, GC_set_max_retries, GC_set_dont_precollect, GC_set_time_limit, GC_warn_proc): Refine the comment. * misc.c (GC_set_oom_fn): Likewise. * include/gc.h (GC_general_register_disappearing_link): Refine the comment (replace "soft" word with "weak"). * misc.c (GC_oom_fn, GC_get_gc_no, GC_get_parallel, GC_set_finalizer_notifier, GC_set_find_leak): Add the comment. * misc.c (GC_set_oom_fn, GC_get_oom_fn, GC_set_finalizer_notifier, GC_get_finalizer_notifier): Use LOCK/UNLOCK to prevent data races. * dbg_mlc.c: Guard include with ifndef MSWINCE; include "private/dbg_mlc.h" before it. * malloc.c: Likewise. * dbg_mlc.c (GC_debug_strdup): Use memcpy() instead of strcpy() for WinCE (since deprecated); evaluate strlen() only once; don't set errno for WinCE. * malloc.c (GC_strdup): Likewise. * dyn_load.c (GC_wnt): Define as macro (FALSE) for WinCE. * include/gc.h (GC_unregister_my_thread): Refine the comment. * include/gc.h (GC_uintptr_t, GC_beginthreadex, GC_endthreadex): Don't declare for WinCE. * include/gc.h (GC_WINMAIN_WINCE_LPTSTR): New macro (WinCE only). * include/gc.h (GC_WinMain): Remove GC_API. * include/gc.h (GC_WinMain): Use GC_WINMAIN_WINCE_LPTSTR for lpCmdLine. * tests/test.c (GC_WinMain): Likewise. * win32_threads.c (main_thread_args, GC_WinMain): Likewise. * include/gc_config_macros.h (ptrdiff_t): Guard with ifndef _PTRDIFF_T_DEFINED; define _PTRDIFF_T_DEFINED macro. * include/private/gc_locks.h: Guard include "atomic_ops.h" with ifdef GC_PTHREADS (and not GC_WIN32_THREADS). * mark.c: Include "atomic_ops.h" if PARALLEL_MARK. * thread_local_alloc.c: Include "atomic_ops.h" if GC_GCJ_SUPPORT. * win32_threads.c: Include "atomic_ops.h" if MPROTECT_VDB. * include/private/gc_locks.h: Use include "atomic_ops.h" instead of include . * include/private/gc_priv.h: Likewise. * include/private/gc_locks.h (GC_allocate_ml, GC_need_to_lock): Don't export (replace GC_API to "extern"). * win32_threads.c (GC_allocate_ml): Don't export. * include/private/gc_priv.h (DebugBreak): Define as macro for WinCE (if not UNDER_CE and DebugBreak is not defined yet). * include/private/gc_priv.h (UNALIGNED): Rename to UNALIGNED_PTRS (since "UNALIGNED" is defined in winnt.h of WinCE). * mark.c (UNALIGNED): Likewise. * include/private/gcconfig.h (ARM32): Recognize _M_ARM and _ARM_. * include/private/gcconfig.h (ALIGNMENT): Check always defined. * include/private/gcconfig.h: Allow GC_WIN32_THREADS for WinCE. * include/private/thread_local_alloc.h: Define USE_WIN32_SPECIFIC for WinCE (since __declspec(thread) is unsupported). * include/private/thread_local_alloc.h (TLS_OUT_OF_INDEXES): Define for WinCE (if undefined). * malloc.c (GC_malloc): Remove outdated comment about disabling signals. * misc.c: Don't include (since not used anymore and may break TEXT() macro defined in winnt.h). * misc.c (GC_init_inner): Don't use GetModuleHandle() and InitializeCriticalSectionAndSpinCount() for WinCE. * misc.c (GC_init_inner): Replace GetModuleHandleA() with GetModuleHandle() (and use TEXT() macro controlled by UNICODE). * misc.c (LOG_FILE): Remove unused macro; don't use _T() macro. * misc.c (GC_CreateLogFile): New static function (Win32/WinCE only); move the code from GC_write(); replace GETENV() with GetEnvironmentVariable(); replace CreateFileA() with CreateFile(); use TEXT() macro (for Unicode support); replace strcat() with memcpy() (since deprecated in WinCE). * misc.c (GC_write): Define as STATIC. * win32_threads.c (GC_attached_thread): Likewise. * misc.c (GC_write): Use GC_CreateLogFile(). * misc.c: Define vsnprintf macro as StringCchVPrintfA for WinCE. * misc.c (GC_abort): Try to invoke MessageBoxA() dynamically (Win32 only) if DONT_USE_USER32_DLL is defined. * misc.c (GC_abort): Duplicate msg to GC log file (for Win32 and WinCE). * misc.c (GC_abort): Use a more user-friendly abort if NO_DEBUGGING (Win32 only). * os_dep.c: Include "atomic_ops.h" only if MPROTECT_VDB (and THREADS). * os_dep.c (detect_GetWriteWatch): Use TEXT() for GetModuleHandle (for Unicode support); check GetModuleHandle() result. * tests/test.c: Don't define assert for WinCE (since may be redefined by "assert.h" included from libatomic_ops). * tests/test.c (FAIL): Define as ABORT for all targets (except for PCR). * tests/test.c (n_tests): Don't use AO_t. * tests/test.c (check_heap_stats): Don't cast n_tests. * tests/test.c (inc_int_counter): New function (for n_tests atomic incrementation). * tests/test.c (run_one_test): Test GC_memalign() for all targets. * tests/test.c (run_one_test): Avoid unbalanced brackets in #if-#else-#endif blocks. * tests/test.c (run_one_test): Replace AO_fetch_and_add1() and private LOCK/UNLOCK with GC_call_with_alloc_lock(inc_int_counter). * tests/test.c (check_heap_stats): Replace "if (sizeof(char *) > 4)" with "#if CPP_WORDSZ == 64" to suppress "unreachable code" compiler warning. * tests/test.c (WinMain): Set cmd type to LPWSTR (for WinCE "UNDER_CE" mode); else use LPSTR type (for Win32 and WinCE). * tests/test.c (thr_window): Replace "L" string prefix with TEXT(). * thread_local_alloc.c: Check THREADS is defined (to prevent other compiler errors and warnings otherwise). * tests/test.c (WinMain): Recognize GC_NO_DLLMAIN macro (for GC_use_DllMain()). * Makefile.direct (GC_NO_DLLMAIN, DONT_IMPORT_GETCURTHREAD): Add the comments for. * win32_threads.c (GC_register_my_thread_inner): Recognize DONT_IMPORT_GETCURTHREAD macro. * win32_threads.c: Recognize GC_NO_DLLMAIN macro (to exclude DllMain support if needed). * win32_threads.c (GC_NO_DLLMAIN): Define implicitly if DllMain thread registration is unsupported for a given configuration. * win32_threads.c (GC_use_DllMain): Update the comment; refine ABORT message. * win32_threads.c (GC_use_DllMain, GC_started_thread_while_stopped, GC_register_my_thread_inner, GC_lookup_thread_inner, GC_delete_gc_thread, GC_allow_register_threads, GC_lookup_pthread, GC_push_thread_structures, GC_stop_world, GC_push_all_stacks): Check for GC_NO_DLLMAIN. * win32_threads.c (GC_Thread_Rep.tm_in_use, GC_attached_thread, DllMain): Don't define if GC_NO_DLLMAIN. * win32_threads.c (GC_stop_world): Declare "i" and "max" local variables only if not GC_NO_DLLMAIN (to suppress compiler warning). * win32_threads.c (GC_mark_thread, start_mark_threads): Use CreateThread() instead of _beginthreadex() for WinCE. * win32_threads.c (MARK_THREAD_STACK_SIZE, WINCE_MAIN_STACK_SIZE): New macros defined (used by start_mark_threads(), WinMain()). * win32_threads.c (GC_thr_init): Exclude parallel-specific code on WinCE for now (since getenv(), GetProcessAffinityMask() and SignalObjectAndWait() are missing on WinCE). * win32_threads.c (GC_thr_init): replace GetModuleHandleA() with GetModuleHandle(); replace CreateEventA() with CreateEvent(); use TEXT() macro (for Unicode support). * include/gc.h (GC_has_static_roots_func): New typedef (user filter callback). * include/gc.h (GC_register_has_static_roots_callback): Use GC_has_static_roots_func type. * dyn_load.c (GC_has_static_roots, GC_register_has_static_roots_callback): Likewise. * dyn_load.c (GC_has_static_roots, GC_register_has_static_roots_callback): Define on all platforms. * dyn_load.c (GC_register_dynlib_callback, GC_register_dynamic_libraries, GC_init_dyld): Replace K&R-style functions definition with the ANSI C one. * dyn_load.c (GC_register_dynlib_callback): Use new local variable "callback" (initialized from GC_has_static_roots) to minimize data races. * dyn_load.c (GC_register_dynamic_libraries_dl_iterate_phdr, GC_cond_add_roots): Define as STATIC. * mark_rts.c (GC_remove_roots_inner): Likewise. * dyn_load.c (GC_dyld_image_add): Don't call GC_add_roots() for sections smaller than pointer size (just to avoid acquiring the lock unnecessarily). * dyn_load.c (GC_dyld_name_for_hdr): Define unconditionally (not only for DARWIN_DEBUG). * dyn_load.c (GC_dyld_image_add): Replace GC_add_roots() call with LOCK + GC_add_roots_inner() + UNLOCK. * dyn_load.c (GC_dyld_image_add): Call GC_has_static_roots() user callback (if set) holding the lock; if it returns 0 then don't call GC_add_roots_inner() for that region. * dyn_load.c (GC_register_has_static_roots_callback): Put "callback" value to GC_has_static_roots on all platforms. * dyn_load.c (GC_has_static_roots): Update the comments. * include/gc.h (GC_exclude_static_roots, GC_add_roots, GC_remove_roots, GC_register_has_static_roots_callback): Likewise. * include/private/gc_priv.h (struct roots): Likewise. * include/private/gc_priv.h (GC_remove_roots_inner): Move prototype to mark_rts.c and declare it as STATIC. * include/private/gc_priv.h (GC_exclude_static_roots_inner): New prototype. * dyn_load.c (GC_register_dynamic_libraries_dl_iterate_phdr): Use GC_exclude_static_roots_inner() instead of GC_exclude_static_roots. * misc.c (GC_init_inner): Likewise. * mark_rts.c (GC_exclude_static_roots_inner): New function (move all the code from GC_exclude_static_roots(); add the comment. * mark_rts.c (GC_add_roots_inner, GC_exclude_static_roots_inner): add alignment assertion for the lower bound; add assertion for the lower bound to be less than the upper one. * mark_rts.c (GC_add_roots_inner, GC_exclude_static_roots): Adjust the upper bound (round down to be of a pointer-aligned value); return in case of an empty range. * mark_rts.c (GC_exclude_static_roots): Acquire the lock and call GC_exclude_static_roots_inner(). * mark_rts.c (GC_remove_roots): Quickly check the bounds and return in case of a do-nothing case (before acquiring the lock). * finalize.c (GC_fail_count): New external variable declaration. * finalize.c (GC_reset_finalizer_nested, GC_check_finalizer_nested): New function declarations (if THREADS only). * finalize.c (GC_finalizer_nested, GC_finalizer_skipped): New static global variables (used internally by GC_finalize() and GC_check_finalizer_nested()). * finalize.c (GC_check_finalizer_nested): New static function definition (only if not THREADS, used internally by GC_notify_or_invoke_finalizers() to minimize the probability of a deep recursion when a client finalizer tries to allocate GC memory). * finalize.c (GC_finalize): Reset GC_finalizer_nested value (or call GC_reset_finalizer_nested()) if last heap expansion failed. * finalize.c (GC_notify_or_invoke_finalizers): Access GC_gc_no, GC_finalizer_now, GC_finalize_on_demand, GC_finalizer_notifier, last_finalizer_notification variables holding the lock (to avoid data races). * finalize.c (GC_finalizer_notifier): Add comment. * finalize.c (GC_notify_or_invoke_finalizers): Add "quick" check for an empty finalization queue (only if THREADS and not KEEP_BACK_PTRS/MAKE_BACK_GRAPH). * finalize.c (GC_notify_or_invoke_finalizers): Call GC_check_finalizer_nested() and skip GC_invoke_finalizers() call if appropriate. * include/private/pthread_support.h (GC_Thread_Rep): Add unsigned finalizer_nested and finalizer_skipped fields (for internal use by the multi-threaded GC_check_finalizer_nested()). * win32_threads.c (GC_Thread_Rep): Likewise. * pthread_support.c (GC_reset_finalizer_nested, GC_check_finalizer_nested): New function definitions (the multi-threaded variants of that in finalize.c). * win32_threads.c (GC_reset_finalizer_nested, GC_check_finalizer_nested): Likewise. * alloc.c (GC_stopped_mark): Remove GC_log_printf("") (not needed anymore and GCC produces a warning for it). * alloc.c (GC_stopped_mark): Adjust printf argument type specifier. * backgraph.c: Include dbg_mlc.h before ifdef MAKE_BACK_GRAPH (for the case when the configuration information comes from aconfig file). * checksums.c: Likewise. * include/gc_allocator.h (GC_ATTR_UNUSED): Use "__unused__" keyword instead of "unused". * include/gc_allocator.h: Fix typos in comments. * thread_local_alloc.c: Likewise. * include/javaxfc.h (GC_finalize_all): Update comment. * include/private/gc_priv.h (GC_API_PRIV): New macro (defined as GC_API and serves only as a marker for the private but exported symbols used by test.c only). * include/private/gc_priv.h (GC_abort, GC_arrays, GC_is_marked, GC_printf, GC_err_printf, GC_log_printf): Replace GC_API decl with GC_API_PRIV one. * include/private/gc_priv.h (GC_fo_entries): Don't export it outside a DLL. * include/private/gc_priv.h (GC_ATTR_FORMAT_PRINTF): New macro designated to check the arguments correctness of printf-like functions (currently works only for GCC v3+). * include/private/gc_priv.h (GC_printf, GC_err_printf, GC_log_printf): Use GC_ATTR_FORMAT_PRINTF attribute. * dyn_load.c (HAVE_DL_ITERATE_PHDR): Break definition from use. Define for FreeBSD 7.0+. * mach_dep.c: Don't include ucontext.h with NO_GETCONTEXT. * include/gc_gcj.h (GC_init_gcj_malloc): Improve descriptive comment. * allchblk.c (GC_merge_unmapped): Don't assume that adjacent free blocks have different mapping status. Correctly handle gap between blocks. (GC_split_block): Remove dead code setting hb_flags. Add comment. (GC_allochblk): Split blocks also in generational-only mode. * os_dep.c (GC_unmap_gap): Don't really use munmap. * include/private/gc_priv.h (GC_unmapped_bytes): Define as 0 for not USE_MUNMAP case. * Makefile.direct (MARK_BIT_PER_OBJ, PRINT_BLACK_LIST, USE_PROC_FOR_LIBRARIES): Fix typo in the comments. * Makefile.direct (USE_MMAP, USE_MUNMAP, THREAD_LOCAL_ALLOC, PARALLEL_MARK, STATIC): Update the comments. * include/private/gcconfig.h (GC_PREFER_MPROTECT_VDB): New macro recognized (only if MPROTECT_VDB). * Makefile.direct (DONT_USE_USER32_DLL, GC_PREFER_MPROTECT_VDB): Add the comments for. * os_dep.c (detect_GetWriteWatch): Recognize "GC_USE_GETWRITEWATCH" environment variable (only if MPROTECT_VDB, if the variable is unset when GC_PREFER_MPROTECT_VDB macro controls the strategy). * doc/README.environment (GC_USE_GETWRITEWATCH): New variable. * include/private/gcconfig.h (MPROTECT_VDB): Add FIXME for USE_MUNMAP and PARALLEL_MARK cases (to relax the conditions in the future). * misc.c (GC_get_heap_size, GC_get_free_bytes): Ignore the memory space returned to OS (GC_unmapped_bytes). * include/gc.h (GC_get_heap_size, GC_get_free_bytes): Update the comments. * misc.c (GC_get_unmapped_bytes): New API function. * include/gc.h (GC_get_unmapped_bytes): New API prototype. * os_dep.c (GC_dirty_init): Move "ifdef GWW_VDB" block out of "ifdef MSWIN32" one (for Cygwin). * pthread_support.c (GC_allow_register_threads): New API function. * win32_threads.c (GC_allow_register_threads): Likewise. * include/gc.h (GC_allow_register_threads): New API prototype. * include/gc.h (GC_register_my_thread, GC_unregister_my_thread): Update the comments. * pthread_support.c (GC_register_my_thread): Check the collector is in the multi-threaded mode. * win32_threads.c (GC_register_my_thread): Likewise. * finalize.c (GC_finalize_all): Always call GC_invoke_finalizers instead, following Ivan's original patch. * allchblk.c (GC_allochblk_nth): Add assertion. * checksums.c: Add GC_record_fault, GC_was_faulted, CC_n_faulted_dirty_errors. (GC_check_dirty): Remove register declarations, print dirty bit errors on faulted pages. * os_dep.c (GC_write_fault_handler): Call GC_record_fault(). * os_dep.c (GC_remove_protection): Compute index correctly. == [7.2alpha2] 2009-06-12 == * dbg_mlc.c (GC_print_smashed_obj): Convert a group of printf() calls into a single one (for output atomicity). * typd_mlc.c (GC_calloc_explicitly_typed): Don't declare and use GC_finalization_failures variable; check the result of GC_general_register_disappearing_link() (for lack of memory) instead. * finalize.c (GC_finalization_failures): Remove unused global variable. * finalize.c (GC_general_register_disappearing_link, GC_general_register_disappearing_link): Don't update the value of GC_finalization_failures (since unused). * include/private/gc_pmark.h (PUSH_ONE_CHECKED_STACK, GC_PUSH_ONE_STACK, GC_PUSH_ONE_HEAP): The first parameter is of word type now (as FIXUP_POINTER requires numeric argument). * finalize.c (GC_ignore_self_finalize_mark_proc): GC_PUSH_ONE_HEAP requires the first parameter of word type. * mark.c (PUSH_GRANULE): Likewise. * mark.c (GC_push_one, GC_push_all_eager): Likewise. * finalize.c (GC_finalize_all): Call GC_invoke_finalizers() or GC_finalizer_notifier directly, instead of GC_INVOKE_FINALIZERS() to prevent infinite looping. * include/javaxfc.h: Clarify GC_finalize_all comment. * gcj_mlc.c: Include gc_pmark.h before "ifdef GC_GCJ_SUPPORT" (not after) for configuration information. * gcj_mlc.c (GC_gcj_malloc_ignore_off_page): Add comment. * gcj_mlc.c (GC_gcj_malloc_ignore_off_page): Check "op" local variable for NULL before dereferencing it, return GC_oom_fn() in this case. * typd_mlc.c (GC_malloc_explicitly_typed, GC_malloc_explicitly_typed_ignore_off_page): Transform the code to suppress compiler warning (for uninitialized "lg" variable). * win32_threads.c (GC_unregister_my_thread): add false assertion in unreachable code. * pthread_support.c (GC_inner_start_routine): Don't release the GC lock between GC_register_my_thread_inner() and GC_init_thread_local() calls (post the "registered" even after calling GC_init_thread_local()). * win32_threads.c (GC_register_my_thread, GC_unregister_my_thread): Use GC_lookup_thread_inner() instead of GC_lookup_thread() and acquire the GC lock only once. * win32_threads.c (GC_thr_init): Call GC_register_my_thread_inner() directly instead of GC_register_my_thread() since I_HOLD_LOCK and our (main) thread is not registered yet (add assertion for it). * win32_threads.c (GC_init_parallel): Call GC_lookup_thread_inner() directly instead of GC_lookup_thread() (since I_HOLD_LOCK). * win32_threads.c (GC_lookup_thread): Remove unused function. * win32_threads.c: Remove "#error GC_DLL untested with Cygwin". * win32_threads.c (GC_win32_dll_threads): Define as FALSE macro also if THREAD_LOCAL_ALLOC or GC_PTHREADS. * win32_threads.c (GC_use_DllMain): Call ABORT also if GC_PTHREADS (for Cygwin). * win32_threads.c (GC_push_stack_for): Add parentheses around "&&" (inside GC_ASSERT) to prevent compiler warning. * win32_threads.c (GC_push_all_stacks): Remove FIXME for PARALLEL_MARK. * win32_threads.c (MAX_MARKERS, GC_markers): Move the definitions to a place before GC_get_next_stack(). * win32_threads.c (marker_sp, marker_bsp): New static arrays (same as in pthread_support.c). * win32_threads.c (marker_last_stack_min): New static arrays (the same semantics as for last_stack_min of GC_Thread_Rep). * win32_threads.c (GC_get_next_stack): Handle marker threads. * win32_threads.c (GC_mark_thread): Save the current stack pointer to marker_[b]sp. * win32_threads.c (start_mark_threads): Initialize marker_last_stack_min elements (to "unset" value). * misc.c (GC_set_oom_fn, GC_set_all_interior_pointers, GC_set_finalize_on_demand, GC_set_java_finalization, GC_set_finalizer_notifier, GC_set_dont_expand, GC_set_full_freq, GC_set_no_dls, GC_set_free_space_divisor, GC_set_max_retries, GC_set_dont_precollect, GC_set_time_limit, GC_set_warn_proc): Change return type to void (these API functions no longer return the old value). * include/gc.h: Likewise. * tests/test.c (main, WinMain, test): Remove explicit cast to void for GC_set_warn_proc(). * misc.c (GC_get_oom_fn, GC_get_all_interior_pointers, GC_get_finalize_on_demand, GC_get_java_finalization, GC_get_finalizer_notifier, GC_get_dont_expand, GC_get_full_freq, GC_get_no_dls, GC_get_free_space_divisor, GC_get_max_retries, GC_get_dont_precollect, GC_get_time_limit, GC_get_warn_proc): New API functions (to get the current value of the corresponding R/W public variables). * include/gc.h: Likewise. * include/gc.h (GC_set_warn_proc, GC_set_free_space_divisor): Update the comment. * misc.c (GC_ignore_warn_proc): New API call-back function. * include/gc.h (GC_ignore_warn_proc): Likewise. * misc.c (GC_set_find_leak, GC_get_find_leak, GC_set_non_gc_bytes, GC_get_non_gc_bytes): New API setter and getter functions (for the public GC_find_leak and GC_non_gc_bytes variables, respectively). * include/gc.h: Likewise. * include/gc.h (GC_memalign): Add proto to GC API. * mallocx.c (GC_memalign): Use GC_API, GC_CALL for the definition. * tests/test.c (run_one_test): Test GC_memalign() on Win32 too, remove GC_memalign() proto. * misc.c (GC_write): Use multi-byte (A) variants of Win32 GetModuleFileName() and CreateFile(). * tests/test.c (main): Replace K&R-style function definition with the ANSI C one. * include/private/gcconfig.h (PLATFORM_ANDROID): New macro recognized (for Linux on ARM32 without glibc). * include/private/gcconfig.h (STRTOULL): Define for all targets (define as "strtoul" for most targets except for LLP64/Win64). * misc.c (GC_init_inner): Use STRTOULL instead of atoi/atol() (cast the result to word type) to decode values of "GC_TRACE", "GC_INITIAL_HEAP_SIZE", "GC_MAXIMUM_HEAP_SIZE" environment variables. * include/gc_allocator.h: Add gc_allocator_ignore_off_page. * tests/test_cpp.cc: Add call to gc_allocator_ignore_off_page. * win32_threads.c (GC_release_mark_lock): Correct misspelling of AO_load in assertion. * win32_threads.c (MAX_THREADS): Define as 1 if GC_win32_dll_threads is defined as FALSE (otherwise the size of dll_thread_table is near 200 KiB for 32-bit). * win32_threads.c (GC_use_DllMain): Optimize for THREAD_LOCAL_ALLOC. * win32_threads.c (GC_Thread_Rep): Add backing_store_end and backing_store_ptr fields for IA64 support. * win32_threads.c (GC_register_my_thread_inner): Set backing_store_end field to reg_base value for IA64 (same as in pthread_support.c). * win32_threads.c (SET_PTHREAD_MAP_CACHE): Put parentheses in the "right" places, remove ';'. * win32_threads.c (GC_fault_handler_lock): Declare only if MPROTECT_VDB (and not WinCE). * win32_threads.c (GC_suspend): Acquire and release GC_fault_handler_lock only if MPROTECT_VDB (and not WinCE). * win32_threads.c (GC_suspend): Define as STATIC. * win32_threads.c (GC_push_stack_for): Fix WARN() format specifier (should be word-compliant, "%p" is used w/o "0x"), don't cast sp. * win32_threads.c (GC_push_all_stacks): Convert a group of printf() calls into a single one (for output atomicity). * win32_threads.c (GC_get_next_stack): Unprotect thread descriptor before altering its last_stack_min ("thread" variable is added). * win32_threads.c (GC_get_next_stack): Remove unnecessary checks for "s" is non-NULL. * win32_threads.c (GC_get_next_stack): Don't call GC_may_be_in_stack if WinCE. * win32_threads.c (GC_get_next_stack): Pass current_min value to GC_get_stack_min as-is (without -1). * win32_threads.c (GC_wait_marker): Remove FIXME and use "release" version of AO_fetch_and_sub1(). * win32_threads.c (GC_win32_start_inner, GC_win32_start): convert int to pointer (and vice versa) thru word type to suppress warnings. * win32_threads.c (GC_mark_mutex_waitcnt): Fix comment, always access atomically. * misc.c: Change GC_THREADS tests back to THREADS. * allchblk.c (GC_print_hblkfreelist, GC_dump_regions): Convert a group of printf() calls into a single one (for output atomicity). * include/gc.h (GC_set_all_interior_pointers, GC_set_full_freq, GC_set_time_limit): New prototypes. * misc.c (GC_set_all_interior_pointers, GC_set_full_freq, GC_set_time_limit): New public setter/getter functions. * include/gc.h: Fix (and remove outdated) comments for thread-local allocation. * include/gc.h: Fix typos in comments. * misc.c (GC_init_inner, GC_printf): Likewise. * include/gc.h (GC_unregister_disappearing_link): Refine comment. * include/gc.h (GC_stack_base): Recognize _M_IA64 macro. * misc.c (GC_stack_last_cleared, GC_min_sp, GC_high_water, GC_bytes_allocd_at_reset, DEGRADE_RATE): Define only if THREADS. * misc.c (GC_stack_last_cleared, GC_min_sp, GC_high_water, GC_bytes_allocd_at_reset): Define as STATIC. * misc.c (GC_get_heap_size, GC_get_free_bytes, GC_get_bytes_since_gc, GC_get_total_bytes): Acquire the GC lock to avoid data races. * misc.c (GC_write_cs): Define only if THREADS (Win32/WinCE only). * misc.c (GC_init_inner): Initialize GC_write_cs only if THREADS. * misc.c (GC_init_inner): Use GC_INITIAL_HEAP_SIZE (if available) to set the default initial value of initial_heap_sz. * misc.c (GC_deinit): Destroy GC_write_cs only if THREADS. * misc.c (GC_init_inner): Fix WARN() format specifier (should be word-compliant, "%p" is used w/o "0x"). * misc.c (GC_init_inner): Don't recognize "GC_PAUSE_TIME_TARGET" environment variable if SMALL_CONFIG. * misc.c (GC_init_inner): Recognize "GC_FULL_FREQUENCY" environment variable to set initial GC_full_freq value (if not SMALL_CONFIG). * doc/README.environment (GC_FULL_FREQUENCY): Add information. * doc/README.environment (GC_MARKERS): Refine information. * misc.c (GC_init_inner): Change GC_ASSERT to GC_STATIC_ASSERT where possible. * misc.c (IF_NEED_TO_LOCK): New macro (instead of GC_need_to_lock). * misc.c (GC_write): Use IF_NEED_TO_LOCK for handling GC_write_cs. * misc.c (GC_abort): Don't define if SMALL_CONFIG. * misc.c (GC_abort): Directly use WRITE() instead of GC_err_printf() (to prevent possible infinite recursion). * finalize.c (finalization_mark_proc): Replace K&R-style declaration with ANSI C one. * finalize.c (GC_grow_table, GC_register_finalizer_inner, GC_enqueue_all_finalizers): Remove outdated comments about disabling signals. * finalize.c (GC_general_register_disappearing_link): Fix assertion to catch NULL "obj" value. * finalize.c (GC_unregister_disappearing_link): Check "link" alignment before gaining the lock. * finalize.c (GC_finalize): Refine comment. * finalize.c (GC_finalize): Fix WARN() format specifier (should be word-compliant, "%p" is used w/o "0x"). * finalize.c (GC_invoke_finalizers): Initialize "bytes_freed_before" variable (to 0) to suppress compiler warning. * include/gc_gcj.h (MARK_DESCR_OFFSET): Move to private/gc_pmark.h. * include/gc_gcj.h: add "extern C" header and tail. * include/private/gc_pmark.h: Remove GC_do_parallel_mark(), GC_help_wanted, GC_helper_count, GC_active_count declarations (move the comments to the place where these symbols are defined in mark.c). * mark.c: Add STATIC GC_do_parallel_mark() declaration (for use by GC_mark_some_inner, if PARALLEL_MARK only). * mark.c (GC_mark_some_inner, GC_help_wanted, GC_helper_count, GC_active_count, GC_do_parallel_mark): Define as STATIC. * pthread_support.c (GC_mark_thread): Likewise. * typd_mlc.c (GC_explicit_typing_initialized, GC_explicit_kind, GC_array_kind, GC_ext_descriptors, GC_ed_size, GC_avail_descr, GC_typed_mark_proc_index, GC_array_mark_proc_index, GC_eobjfreelist, GC_arobjfreelist): Likewise. * include/private/gc_pmark.h (PUSH_CONTENTS_HDR): Change GC_ASSERT for HBLKSIZE to GC_STATIC_ASSERT. * mark.c (GC_noop): Define for Borland C the same as for Watcom. * mark.c (GC_noop, GC_mark_and_push): Add ARGSUSED tag. * pthread_support.c (GC_do_blocking_inner): Likewise. * mark.c (GC_mark_from): Initialize "limit" (to 0) in the default switch branch to suppress compiler warning. * mark.c (GC_return_mark_stack): Append new-line to printf message. * mark.c: Remove unused GC_true_func(), GC_PUSH_ALL(). * pthread_support.c (GC_mark_thread): Add dummy "return 0" to suppress compiler warning. * pthread_support.c (start_mark_threads): Move the code limiting "GC_markers" value (and printing a warning) to GC_thr_init(). * pthread_support.c (GC_thr_init): Silently limit "GC_markers" value if based on the number of CPUs. * pthread_support.c (GC_thr_init): Treat incorrect "GC_markers" values as one. * pthread_support.c (GC_register_my_thread_inner): Add a check for "stack_end" is non-NULL (the same as in win32_threads.c). * pthread_support.c (pthread_create): Call GC_oom_fn before giving up with ENOMEM. * thread_local_alloc.c (return_single_freelist): Convert "for" loop to "while" one to suppress "possible extraneous ';'" warning. * darwin_stop_world.c (GC_push_all_stacks): Recognize ARM32. * include/private/gc_priv.h (GC_THREAD_STATE_T): Define for ARM32 (Darwin only). * include/private/gcconfig.h: Add machine-specific part for DARWIN. * include/private/gcconfig.h (ARM32): Define config parameters for DARWIN (iPhone). * alloc.c (GC_FULL_FREQ, GC_DONT_EXPAND, GC_FREE_SPACE_DIVISOR, GC_TIME_LIMIT): New macros (used to control the default initial values of GC_full_freq variable, GC_dont_expand, GC_free_space_divisor, GC_time_limit respectively). * include/private/gc_priv.h (TIME_LIMIT): Remove macro (replaced with GC_TIME_LIMIT in alloc.c). * alloc.c (GC_need_full_gc, GC_stopped_mark, GC_finish_collection): Define as STATIC. * mark_rts.c (GC_push_current_stack, GC_push_gc_structures): Likewise. * include/private/gc_priv.h (GC_stopped_mark, GC_finish_collection): Move the prototypes to alloc.c, make STATIC. * include/private/gc_priv.h (GC_push_current_stack, GC_push_gc_structures, GC_push_regs_and_stack): Remove prototypes (move the comments to the places where these functions are defined). * mach_dep.c (GC_push_regs_and_stack): Move to mark_rts.c and define as STATIC. * alloc.c (GC_timeout_stop_func, GC_stopped_mark, GC_print_heap_sects): Convert a group of printf() calls into a single one (for output atomicity). * mark_rts.c (GC_print_static_roots): Likewise. * alloc.c (GC_stopped_mark): Output blank line (when logging) for convenience to delimit collections. * alloc.c (GC_clear_a_few_frames): Rename NWORDS to CLEAR_NWORDS; make "frames" local variable volatile (to prevent optimization). * alloc.c (GC_try_to_collect_inner, GC_stopped_mark, GC_finish_collection, GC_allocobj): Remove outdated comments about disabling signals. * include/private/gc_priv.h (GC_register_displacement_inner, GC_gcollect_inner): Likewise. * alloc.c (GC_try_to_collect_inner, GC_stopped_mark, GC_finish_collection): Initialize "start_time" local variable (to 0) to suppress compiler warning. * mark_rts.c (GC_add_roots_inner): Likewise. * alloc.c (GC_RATE, MAX_PRIOR_ATTEMPTS): Guard with "ifndef". * include/private/gc_priv.h (clock, GC_stop_world, GC_start_world, GC_acquire_mark_lock, GC_release_mark_lock, GC_notify_all_builder, GC_wait_for_reclaim, GC_notify_all_marker, GC_wait_marker): Replace K&R-style function prototypes with ANSI C one. * include/private/gc_priv.h (ABORT): Define as DebugBreak() for Win32/WinCE if SMALL_CONFIG (the same as in GC_abort()). * include/private/gc_priv.h (ROUNDED_UP_WORDS, abs): Remove unused macros. * include/private/gc_priv.h (GC_noop): Declare for Borland C the same as for Watcom. * mark_rts.c (GC_push_conditional_with_exclusions): Add ARGSUSED tag. * dbg_mlc.c (GC_store_debug_info, GC_store_debug_info_inner): Remove outdated comment about disabling signals. * mallocx.c (GC_malloc_uncollectable, GC_malloc_atomic_uncollectable): Likewise. * os_dep.c: Likewise. * dbg_mlc.c (GC_debug_change_stubborn, GC_debug_end_stubborn_change): Add ARGSUSED tag. * pthread_stop_world.c (GC_suspend_handler, GC_suspend_handler_inner): Likewise. * dbg_mlc.c (GC_debug_free, GC_debug_realloc): Fix printf message. * dbg_mlc.c (GC_debug_realloc): Set "result" to NULL in the default switch branch to suppress compiler warning. * dyn_load.c (GC_init_dyld): Use ABORT() instead of GC_abort(). * include/private/darwin_semaphore.h (sem_init): Likewise. * include/javaxfc.h: Replace "GC_H" with "_GC_H". * include/private/dbg_mlc.h (GC_has_other_debug_info, GC_store_debug_info): Replace K&R-style function prototypes with ANSI C one. * include/private/gcconfig.h (GC_FreeBSDGetDataStart, real_malloc, GC_win32_get_mem, GC_wince_get_mem, GC_unix_get_mem): Likewise. * include/private/pthread_support.h (GC_stop_init): Likewise. * include/private/gcconfig.h: Refine comment about setting GC_stackbottom. * include/private/gcconfig.h (FIXUP_POINTER): Put parentheses in the "right" places. * include/private/pthread_support.h (GC_Thread_Rep): Refine comment for "stack_end" field. * mallocx.c (GC_malloc_uncollectable, GC_malloc_atomic_uncollectable): Remove cast to undefined "hbklk". * os_dep.c (GC_USE_MEM_TOP_DOWN): New macro (for setting GC_mem_top_down to MEM_TOP_DOWN for debug purposes). * os_dep.c (GC_gww_read_dirty, catch_exception_raise): Fix WARN() format specifier (should be word-compliant, "%p" is used w/o "0x"). * pthread_stop_world.c (GC_suspend_handler_inner): Likewise. * os_dep.c (GC_dirty_init): Append new-line to printf messages. * os_dep.c (GC_mprotect_thread): Fix GC_err_printf message. * os_dep.c (GC_save_callers): Change GC_ASSERT to GC_STATIC_ASSERT. * pthread_stop_world.c (GC_retry_signals, GC_suspend_ack_sem): Define as STATIC. * pthread_stop_world.c (GC_push_all_stacks): Add assertion for that "thread_blocked" is not set for the current thread. * real_malloc.c: Add "extern GC_quiet" to suppress compiler warning. * reclaim.c (GC_reclaim_all): Initialize "start_time" (to 0) to suppress compiler warning. * tests/test.c (check_heap_stats): Avoid unbalanced brackets in ifdef. * win32_threads.c: restructure parallel marking mutex initialization. * win32_threads.c, alloc.c, darwin_stop_world.c, mallocx.c, mark.c, pthread_stop_world.c, pthread_support.c: Add runtime conditions on GC_parallel were appropriate. * pthread_support.c: Condition marker_bsp on ia64. (GC_segment_is_thread_stack): Fix loop upper bound. * reclaim.c: Limit some assertions to PARALLEL_MARK. * pthread_support.c: Don't acquire mark lock for thread-local allocation. * include/private/gc_priv.h: Don't define parallel mark sync support just for THREAD_LOCAL_ALLOC. * include/private/gcconfig.h: refine MINGW32 test. * mark.c: Add win64/gcc tests. * test.c (fork_a_thread, reverse_test, alloc8bytes, tree_test, typed_test, run_one_test, check_heap_stats, main, test): Replace all K&R-style function definitions with ANSI C ones. * trace_test.c (main): Likewise. * test.c (GC_COND_INIT): Define as GC_INIT() also in case of THREAD_LOCAL_ALLOC. * test.c (reverse_test): Call fork_a_thread() only if GC_PTHREADS or GC_WIN32_THREADS; remove fork_a_thread() macros definition. * test.c (reverse_test): Use "volatile" when clearing "b" and "c" local variables (to suppress "assigned value is never used" compiler warning). * test.c (tree_test): Use public GC_noop1() instead of private GC_noop(). * test.c (typed_test): Likewise. * test.c (check_heap_stats): Define and assign value to "late_finalize_count" local variable only if its value is used (if FINALIZE_ON_DEMAND defined). * test.c (main): Remove DJGPP-specific initialization of GC_stackbottom (not needed anymore, handled in gcconfig.h). * trace_test.c: Guard #define GC_DEBUG with #ifndef. * trace_test.c: Include "gc_backptr.h". * trace_test.c (main): Call GC_INIT(). * trace_test.c (main): Add "return 0" statement. * dyn_load.c (GC_register_dynlib_callback): Use new index j instead of i in the inner loop. * tests/test.c: Increment n_tests with fetch_and_add when possible, avoiding need to export lock. * include/gc_pthread_redirects.h: - dlfcn.h is included for dlopen() proto before undefining "dlopen" (so, it's possible now to include dlfcn.h after gc.h from user code); - GC_dlopen() proto is added (except for Darwin as it's missing there); - "dlopen" is explicitly undefined (before its redefinition). * include/gc.h: - "process.h" is included besides "windows.h" (for _beginthreadex/_endthreadex); win32 only. - GC_NO_THREAD_DECLS is moved to the right place (before closing "extern C"). * pthread_support.c: Fix out of memory handling for Thread_Reps. * win32_threads.c: Don't include process.h on winCE, improve out of memory handling for thread structures, don't define GC_beginthreadex and GC_endthreadex for winCE. * tests/test.c: Change gcj vtable decriptor type from size_t to GC_word. * gcj_mlc.c: Add comment. * tests/test.c: Change NTEST to NTHREADS. Fork 5 threads by default. Run reverse_test a second time in each thread.Add comments. Don't rely on AO_fetch_and_add. * dyn_load.c (GC_register_dynlib_callback, GC_register_dynamic_libraries_dl_iterate_phdr): Add support for GNU_PT_RELRO relocations. * Makefile, Makefile.direct: GC_SOLARIS_PTHREADS was replaced by GC_SOLARIS_THREADS. * include/gc.h: Improve finalizer documentation. * mips_sgi_mach_dep.s: Replace _MIPS_SIM_ABI32 with _ABIO32. * pthread_stop_world.c, Makefile.dj: Fix typos. * win32_threads.c (GC_new_thread): Make first_thread visible to the whole file. (UNPROTECT): New macro. (GC_push_stack_for, GC_suspend, GC_start_world): unprotect thread structures before writing. (GC_suspend): Acquire GC_fault_handler_lock before suspending thread. * os_dep.c: export GC_fault_handler_lock. (GC_remove_protection): Check if already unprotected. * doc/README.win32: Add OpenWatcom warning. * include/private/gcconfig.h: Really check it in. * os_dep.c (GC_get_stack_base, windows): Replace with Dave Korn's code from gcc version. * os_dep.c: make gc compilable (optionally) for Cygwin with GetWriteWatch-based virtual dirty bit implementation ("os_dep.c" file). * os_dep.c: Make non-win32 GC_write_fault_handler STATIC. * mark.c (GC_noop): fix declaration definition mismatch for DMC. * include/private/gcconfig.h: Enable MPROTECT_VDB and GWW_VDB for Watcom (Win32 only). It works. * mach_dep.c: Don't use __builtin_unwind_init for register state on PowerPC/Darwin. * doc/gcdescr.html: Improve description of object freelist structure. * include/private/gc_priv.h: Fix comment for _size_map. * os_dep.c (GC_linux_stack_base): Relax sanity test. * include/private/gc_pmark.h (PUSH_CONTENTS_HDR for MARK_BIT_PER_OBJ): Add missing backslash before eoln. * misc.c (GC_set_warn_proc): Implicitly intialize GC on non-Cygwin win32. * configure.ac: Enable thread-local allocation for sparc-linux. * alloc.c (GC_try_to_collect): Remove duplicate initialization check. * malloc.c (GC_generic_malloc): Remove lw to eliminate single- threaded warnings. * mallocx.c (GC_generic_malloc_ignore_off_page): Likewise. * allchblk.c, backgraph.c, dbg_mlc.c, dyn_load.c, finalize.c, include/private/gc_pmark.h, malloc.c, mark.c, os_dep.c, pthread_stop_world.c, pthread_support.c, reclaim.c, thread_local_alloc.c. * misc.c: Refine comment. * os_dep.c: Define GC_GWW_BUF_LEN more intelligently. Add FIXME comment. * win32_threads.c (GC_push_stack_for): Yet another attempt at the stack_min finding logic. Try to clean up the existing code while minimizing VirtualQuery calls. (GC_win32_start_inner): Register thread before GC_printf. Produce more output with DEBUG_THREADS. *include/gc.h: Update obsolete comments. * tests/test.c: (gcj_class_struct2): Use cast instead of l suffix. Cast GetLastError to int in various places. Avoid unused result warning from incr/decr macros. Add cast for fake_gcj_mark_proc. Cast GC_gc_no to unsigned in printf. * include/gc.h: Fix two typos in comments. * finalize.c: Fix typo in comment. * blacklst.c (GC_print_source_pointer): Don't call GC_print_heap_obj with lock. * reclaim.c: (GC_reclaim_block): Scan even nearly full blocks if we are checking for leaks. * win32_threads.c: Remove mark lock spinning. * win32_threads.c, pthread_support.c: Update GC_unlocked_count, GC_spin_count, and GC_block_count using atomic operations. * tests/test.c: Declare n_tests as AO_t only if we have threads. * win32_threads.c: Support PARALLEL_MARK. Make printf arg types agree with format specifiers. Add STATIC for GC_threads. * include/private/gcconfig.h: Add FIXME comment. * tests/test.c (run_ine_test): Replace LOCK/UNLOCK use with AO_fetch_and_add1_full. Declare n_tests as AO_t. (WinMain): Don't call GC_use_DllMain. with PARALLEL_MARK or THREAD_LOCAL_ALLOC. * alloc.c (GC_try_to_collect_inner): Don't print redundant GC_bytes_allocd and GC_gc_no. (GC_stopped_mark): Print average world stop time. * include/private/gc_priv.h (MS_TIME_DIFF): Add cast. * misc.c, doc/README.environment: Add support for GC_FREE_SPACE_DIVISOR and GC-disable-incremental. * include/gc.h: Make GC_set_free_space_divisor correspond to (somewhat unfortunate) reality. (Mostly improves LLP64 support.) * backgraph.c, checksums.c, dbg_mlc.c, finalize.c, mark.c, misc.c, reclaim.c: Changed some int and long type to word or size_t (and vice versa where appropriate) * gcj_mlc.c, include/private/dbg_mlc.h, include/private/gcconfig.h, include/private/thread_local_alloc.h, mark.c, misc.c, thread_local_alloc.c, win32_threads.c: Added intermediate casts to word type when casting from int to pointer (or pointer to int, or data pointer to code pointer) - just to remove the corresponding compiler warning. * ptr_chck.c (GC_is_visible): cast int const to word type to prevent left shift overflow. * os_dep.c: change the type of GC_mem_top_down global variable (containing a flag) to DWORD. * include/gc_config_macros.h: define GC_SOLARIS_THREADS if GC_THREADS is defined on SunOS x86_64. * misc.c (GC_init_size_map): Ifdef out GC_ASSERT as a workaround for VC++ 2008 amd64 (v15.00.21022.08 for x64) compiler bug (the compiler gets hung if invoked with -Ox -D ALL_INTERIOR_POINTERS -D GC_ASSERTIONS) * backgraph.c: cast GC_gc_no value to unsigned short when assigned/compared to height_gc_no field of back_edges. * os_dep.c (GC_remove_protection): Add ARGSUSED. * win32_threads.c (GC_thread_exit_proc): Remove unused local variable. * mark.c (GC_check_dirty): Move declaration out of func body. * doc/gcinterface.html: Improve REDIRECT_MALLOC documentation. * include/gc.h (GC_register_my_thread): Improve comment. * Makefile.direct: Add comment for -DCHECKSUMS. * thread_local_alloc.c, include/private/thread_local_alloc.h: Fix typos in comments. * finalize.c: Declare mark_procs and GC_register_finalizer_inner STATIC. * malloc.c (GC_free): Move size calculation below assertion. * win32_threads.c (GC_get_stack_min, GC_may_be_in_stack): Add one entry VirtualQuery cache, I_HOLD_LOCK assertions. (GC_push_stack_for, GC_get_next_stack) : Hopefully fix WINCE support. * finalize.c (GC_general_register_disappearing_link): Add assertion. * malloc.c (GC_generic_malloc): Round lb to granules, not words. * mallocx.c (GC_generic_malloc_ignore_off_page): Round lb to granules, not words. * mach_dep.c (NO_GETCONTEXT): Define for sparc linux. * configure.ac: Define mach_dep for sparc-linux. * mark_rts.c (GC_approx_sp): Use volatile to avoid common warning. * dyn_load.c (GC_cond_add_roots): Fix GC_get_next_stack argument order. * alloc.c, dbg_mlc.c, dyn_load.c, finalize.c, gcj_mlc.c, include/gc.h, include/gc_config_macros.h, include/gc_cpp.h, include/gc_gcj.h, include/gc_mark.h, include/gc_typed.h, include/javaxfc.h, include/private/gc_locks.h, include/private/gc_priv.h, malloc.c, mallocx.c, mark.c, mark_rts.c, misc.c, obj_map.c, os_dep.c, pthread_support.c, ptr_chck.c, stubborn.c, tests/test.c, thread_local_alloc.c, typd_mlc.c win32_threads.c: Add GC_CALL and GC_CALLBACK macro invocations. * test.c: Remove some old K&R code. * win32_threads.c (GC_may_be_in_stack): New. (GC_Thread_Rep): Add last_stack_min. (GC_push_stack_for): Use last_stack_min. (GC_get_next_stack): Add limit argument, use_last_stack_min. (GC_suspend): make stack_base assignment conditional. * dyn_load.c (win32 GC_cod_add_roots): Pass limit to GC_get_next_stack. * configure_atomic_ops.sh: Remove. * build_atomic_ops.sh, build_atomic_ops.sh.cygwin, doc/README.win32, Makefile.direct: Partially support build directories whose path name contains blanks. * Makefile.am: Support new files (build_atomic_ops.sh, build_atomic_ops.sh.cygwin) * include/private/gc_locks.h, include/private/gc_pmark.h, include/private/gc_priv.h, include/private/gcconfig.h, mach_dep.c, mark_rts.c, misc.c, os_dep.c, pthread_stop_world.c, pthread_support.c, thread_local_alloc.c, typd_mlc.c, win32_threads.c: Fix comments. * pthread_support.c: Comment out LOCK_STATS. * include/gc.h: Fix comments. * misc.c (GC_init_inner): Enable GC_LOG_FILE on Cygwin. * include/private/gcconfig.h: Consider USE_MMAP for Cygwin. * os_dep.c (GC_get_main_stack_base): Use alternate definition with USE_MMAP. * include/private/gc_priv.h: Sometimes define SETJMP on Cygwin. * doc/README: Make it clearer when Makefile.direct is assumed. * cord/cord.am: install include/cord.h. * win32_threads.c (GC_pthread_join, GC_pthread_start_inner): Remove unused variables. * darwin_stop_world.c: Always declare GC_thr_init(). * dbg_mlc.c (GC_debug_free_inner): Don't touch oh_sz if SHORT_DBG_HDRS is defined. * include/private/gc_pmark.h (OR_WORD_EXIT_IF_SET, parallel mark, USE_MARK_BITS version): Refer to correct parameter name. * finalize.c (GC_general_register_disappearing_link): Remove redundant code. * gcj_mlc.c (GC_init_gcj_malloc): Add cast to signed. * os_dep.c: (GC_write_fault_handler): Remove remaining references to deleted variable "code". Remove redundant FREEBSD definitions. * include/private/gcconfig.h (GWW_VDB): Define for X86_64 when defined for X86. (STATIC): Define as "static" with NO_DEBUGGING. * include/private/gc_priv.h: Update MAX_HEAP_SECTS. * dbg_mlc.c (GC_print_smashed_obj): Increase robustness with smashed string, (GC_debug_free_inner): Mark as free. * mallocx.c (GC_malloc_many): Always clear new block if GC_debugging_started. * reclaim.c: Move GC_debugging_started from GC_reclaim_small_nonempty_block() to GC_reclaim_generic(), which is also called directly. * doc/README: Fix spelling error. Update license summary. * include/gc.h (GC_PRE_INCR3, GC_POST_INCR3): add (void **) casts. * tests/test.c: Don't define GC_DEBUG if already defined. * doc/simple_example.html: update --enable-full-debug reference, Make HTML formatting standards compliant. * doc/debugging.html, doc/leak.html: Fix HTML formatting bugs. * doc/gcinterface.html: specify encoding. * doc/simple_example.html: Update thread-local allocation description. * configure.ac: Check for gc-debug earlier; replace remaining full-debug tests. * include/gc.h, ptr_chck.c (GC_pre_incr, GC_post_incr): Use signed offset type. Use ptr_t internally. * doc/gcinterface.html: Update LOCAL_MALLOC description. * doc/README.autoconf, doc/leak.html, doc/README.DGUX386: Fix full-debug reference. * include/gc.h: Rewrite GC_..._INCR and friends. * tests/test.c: Minimally test GC_..._INCR and friends. * mark.c: (GC_push_next_marked, GC_push_next_marked_dirty, GC_push_next_marked_uncollectable): Never invoke GC_push_marked on free hblk. * headers.c: Test COUNT_HDR_CACHE_HITS not USE_HDR_CACHE. (GC_header_cache_miss): Always blacklist pointers for free hblks. Add assertion and comment. * pthread_support.c (GC_register_my_thread): Fix #if indentation. * include/private/gc_hdrs.h: USE_HDR_CACHE is no longer tested. Delete it. * include/private/gc_pmark.h: (PUSH_OBJ): Add assertion. * alloc.c, include/gc_mark.h, Makefile.direct: Improve comments. * configure.ac: Set win32_threads on MinGW. Ivan's description of the patch follows. Note that a few pieces like the GC_malloc(0) patch, were not applied since an alternate had been previously applied. A few differed stylistically from the rest of the code (mostly casts to void * instead of target type), or were classified as too minor to bother. Note that all of Ivan's static declarations which did not correct outright naming bugs (as a few did), where replaced by STATIC, which is ignored by default. - minor bug fixing (for FreeBSD, for THREAD_LOCAL_ALLOC and for GC_malloc(0)); - addition of missing getter/setter functions for public variables (may be useful if compiled as Win32 DLL); - addition of missing GC_API for some exported functions; - addition of missing "static" declarator for internal functions and variables (where possible); - replacement of all remaining K&R-style definitions with ANSI C ones (__STDC__ macro is not used anymore); - addition of some Win32 macro definitions (that may be missing in the standard headers supplied with a compiler) for GWW_VDB mode; - elimination of most compiler warnings (except for "uninitialized data" warning); - several typos correction; - missing parenthesis addition in macros in some header files of "libatomic_ops" module. My highlights based on reading the patch: * allchblk.c: Remove GC_freehblk_ptr decl. Make free_list_index_of() static. * include/gc.h: Use __int64 on win64, define GC_oom_func, GC_finalizer_notifier_proc, GC_finalizer_notifier_proc, add getter and setters: GC_get_gc_no, GC_get_parallel, GC_set_oom_fn, GC_set_finalize_on_demand, GC_set_java_finalization, GC_set_dont_expand, GC_set_no_dls, GC_set_max_retries, GC_set_dont_precollect, GC_set_finalizer_notifier. Always define GC_win32_free_heap. gc_config_macros.h: Define _REENTRANT after processing GC_THREADS. * include/gc_cpp.h: Improve GC_PLACEMENT_DELETE test, handling of operator new[] for old Windows compilers. * include/gc_inline.h (GC_MALLOC_FAST_GRANS): Add parentheses around arguments. * dbg_mlc.c, malloc.c, misc.c: Add many GC_API specs. * mark.c (GC_mark_and_push_stack): Fix source argument for blacklist printing. * misc.c: Fix log file naming based on environment variable for Windows. Make GC_set_warn_proc and GC_set_free_space_divisor just return current value with 0 argument. Add DONT_USE_USER32_DLL. Add various getters and setters as in gc.h. * os_dep.c: Remove no longer used GC_disable/enable_signals implementations. (GC_get_stack_base): Add pthread_attr_destroy call. No longer set GC_old_bus_handler in DARWIN workaround. * pthread_support.c: GC_register_my_thread must also call GC_init_thread_local. * Makefile.direct, mach_dep.c: Add support for NO_GETCONTEXT. * mach_dep.c: Include signal.h. * gc_priv.h: Factor out INLINE declaration. * include/private/gcconfig.h: Update MIPS/LINUX config. * doc/gcdescr.html: Fix typo. * mach_dep.c (GC_with_callee_saves_pushed): Don't rely on getcontext for MIPS/LINUX. * configure.ac: SPARC fixes. * thread_local_alloc.c(GC_mark_thread_local_fls_for): Include size 0, except for gcj. * doc/gc.man: Expand C++ cautions. * include/gc_inline.h: Fix comments. == [7.1] 2008-05-03 == * doc/gcinterface.html: Improve C++ interface documentation. * allchblk.c (GC_allochblk): Check for overflow during size rounding. * tests/huge_test.c: New. * Makefile.direct, tests/tests.am: Add huge_test.c * pthread_support.c: Fix typo in comment. * os_dep.c (GC_win32_get_mem): Add heap section only if allocation succeeded. * malloc.c: (free replacement) Fix caller address space check. * finalize.c (GC_grow_table): Dereference table in null-check. * win32_threads.c (GC_delete_gc_thread, GC_delete_thread): Consistently call CloseHandle. (GC_suspend): Call GC_delete_gc_thread. * tests/test.c: Don't reference GC_print_stats if not exported. * tests/test.c (run_one_test): Don't mention pthread_self(). * misc.c: Declare GC_thr_init(). * allchblk.c (add_to_fl): disable assertions with USE_MUNMAP, and refine assertions to handle huge unmergable blocks. (GC_allochblk_nth): Add comment. * include/private/gcconfig.h: Add missing FREEBSD macro consistency test. * allchblk.c (GC_enough_large_bytes_left): No longer take parameters; return free list index bound. (GC_merge_unmapped): Don't access nexthdr until after null test. (Fixes bug in 1/29/08 check-in.) (GC_allochblk): Calculate when splitting is allowable only once here, not when considering each block. (GC_allchblk_nth): Accept new may_split parameter. Avoid some redundant tests for exact size matches. * alloc.c (GC_should_collect): Cache min_bytes_allocd. (GC_maybe_gc): Make locking assertion testable. * mark_rts.c: Fix indentation. * pthread_stop_world.c: Replace old GC_err_printf1 reference. * tests/test.c: Remove (void) casts. Optionally print some timing information. * windows-untested/gc.def: Remove CreateThread line. * windows-untested/README: New file. * win32_threads.c (GC_use_DllMain): Force collector initialization. * include/gc.h (GC_use_DllMain): Clarify usage rules in comment. * mark.c (GC_mark_from): Slightly simplify GC_DS_PER_OBJECT code. * include/gc_cpp.h: Add matching placement delete overloads everywhere. * include/private/gc_locks.h (NO_THREAD): Add cast. * include/private/gcconfig.h: Add test for __HP_aCC. * configure.ac, tests/tests.am: Avoid libgccpp on HP/UX. * doc/README.win32: Fix typo. * configure.ac: Fix printing of enable-shared result. * misc.c (GC_init_inner): Assert !GC_need_to_lock only when defined. (GC_call_with_stack_base): Add GC_API. * os_dep.c (GC_get_stack_base): Add GC_API. * win32_threads.c: (GC_register_my_thread, GC_unregister_my_thread): Add GC_API. * include/gc.h: Add GC_API annotations. * include/private/gc_locks.h: Define UNCOND_LOCK etc. also for PCR. * include/private/gc_pmark.h: Fix comments. * include/private/gc_priv.h, mark_rts.c, typd_mlc.c: Add GC_push_typed_structures() to push GC_ext_descriptors. * tests/test.c: Call GC_INIT for DARWIN; test system type using gcconfig.h-defined macros. * allchblk.c (GC_merge_unmapped, GC_freehblk): Refuse to create blocks large enough that their size, when interpreted as a signed value, would be negative. * include/private/gc_priv.h: Comment hb_sz range limit. * mark.c (GC_push_next_marked): correct comment. * Makefile.direct: document NO_PROC_STAT. * include/private/gcconfig.h: Accomodate NO_PROC_STAT. == [7.1alpha2] 2008-01-10 == * Makefile.am: Mention atomic_ops.c and atomic_ops_sysdeps.S again. Refer to build directory as ".". * configure.ac: Ignore --enable-parallel-mark on Darwin for now. * darwin_stop_world.c: Add FIXME comment for parallel marker. * include/private/gc_priv.h: Update MAX_ROOT_SETS and LOG_PHT_ENTRIES to handle larger heaps. * include/gc.h (GC_INIT,GC_init): Update comments. * allchblk.c, alloc.c, include/private/gc_priv.h: Track GC_bytes_dropped and use in GC triggering decisions. * alloc.c (min_bytes_allocd): Weight atomic blocks less. * alloc.c (GC_add_to_heap): Call GC_install_header(p) AFTER adjusting p. * Makefile.am: Add NT_X64_THREADS_MAKEFILE. * NT_X64_STATIC_THREADS_MAKEFILE: Clean up obsolete comment. * alloc.c: Add declaration for GC_add_current_malloc_heap. * win32_threads.c (GC_beginthreadex): Clean up error return code. * doc/README.win64, NT_X64_THREADS_MAKEFILE, Makefile.direct: Add NT_X64_THREADS_MAKEFILE. * alloc.c: Define GC_version instead of in version.h. * version.h: Remove. * include/gc_version.h: Move most of version.h here. * include/gc.h: Include gc_version.h. * gcname.c, add_gc_prefix.c: include gc.h instead of version.h. * Makefile.direct, Makefile.dj, Makefile.am, include/include.am: Adjust for version.h rename. * configure.ac: Put libatomic_ops links in build directory. * Makefile.am: Don't mention atomic_ops.c and atomic_ops_sysdeps.S as nodist sources. * include/gc.h, doc/README.macros: Add GC_NO_THREAD_REDIRECTS, GC_NO_THREAD_DECLS, don't test explicitly for GC_SOLARIS_THREADS. * alloc.c: Deal correctly with address wrapping for GC_greatest_plausible_heap_addr and GC_least_plausible_heap_addr. * finalize.c, include/gc.h (GC_register_disappearing_link, GC_register_finalizer_inner): Improve out-of-memory handling. * include/private/gc_pmark.h: Fix comment spelling. * include/gc_inline.h, include/gc_tiny_fl.h: cleanups to make usable in other contexts. * include/gc.h: Don't define GC_HAVE_BUILTIN_BACKTRACE for uclibc. * gc_cpp.cc: Don't include gc_cpp.h from local directory. * allchblk.c, configure.ac (add --enable-munmap) * dyn_load.c (GC_dyld_image_add): Remove ifdef clause and use the macro GC_GETSECTBYNAME instead. * include/private/gc_priv.h: Define GC_GETSECTBYNAME according to the architecture (Darwin). * reclaim.c (GC_bytes_found): Expand comment. * thread_local_alloc.c (GC_malloc_atomic, GC_gcj_malloc): Pass granules, not bytes, to GC_FAST_MALLOC_GRANS. * include/gc.h: Never include gc_local_alloc.h. * tests/test.c: Add size zero allocation tests. * malloc.c: Update GC_large_allocd_bytes on explicit deallocation. * allchblk.c: Sanity check GC_max_large_allocd_bytes. * Makefile.direct: Invoke $(MAKE) instead of make. * doc/scale.html: Reflect gc7 thread local allocation behavior. * include/extra/gc.h, include/extra/gc_cpp.h: New. * include/include.am: Install gc.h and gc_cpp.h in $(prefix)/include again. * pthread_support.c (GC_thr_init): Use sysconf(_SC_NPROCESSORS_ONLN) for HURD. * include/private/gcconfig.h: Add Linux/mips-64 support. * dbg_mlc.c: Use random() on all glibc systems. * mach_dep.c (GC_with_callee_saves_pushed): Don't use getcontext() on HURD. Add comment. * pthread_stop_world.c (GC_suspend_handler, GC_stop_init): Accomodate systems without SA_SIGINFO. * include/gc.h (GC_PTR_STORE): Fix non-DEBUG parentheses. * tests/test.c (run_one_test): Add GC_PTR_STORE test. No longer test for RS6000. * alloc.c, backgraph.c, headers.c, include/private/gc_priv.h: Maintain GC_our_memory and GC_n_memory. * dbg_mlc.c (GC_print_smashed_obj): Improve message. (GC_print_all_smashed_proc): Pass client object address instead of base. * dyn_load.c (sort_heap_sects): New. (GC_register_map_entries): Register sections that are contiguous and merged with our heap. * malloc.c, os_dep.c (GC_text_mapping): Check for just base name of libraries. * malloc.c (calloc): Check for special callers even with USE_PROC_FOR_LIBRARIES. Move assertion. Add rudimentary malloc/free tracing. * misc.c: No longer call GC_init_lib_bounds explicitly. * thread_local_alloc.c (GC_malloc, GC_malloc_atomic): Always initialize on demand. * tests/test.c: Call GC_INIT only when required. * Makefile.direct: Remove comment fragment. * tests/tests.am: Add smashtest. * configure.ac: Define GC_USE_DLOPEN_WRAP with redirect-malloc. * pthread_support.c: Fix comment spelling. * include/private/gcconfig.h: Define USE_PROC_FOR_LIBRARIES with GC_LINUX_THREADS and REDIRECT_MALLOC. * tests/smash_test.c: Initial check-in. * obj_map.c: Print log entry to correct file. * include/private/thread_local_alloc.h: Add TlsAlloc error check. * alloc.c (GC_stopped_mark): Call GC_add_current_malloc_heap() while world is still running. * os_dep.c (GC_is_heap_base): Don't call GC_add_current_malloc_heap() with world stopped. * include/gc.h (GC_INIT for cygwin): Always call GC_add_roots. * misc.c (GC_init/GC_init_inner): Perform all work in GC_init_inner. * Makefile.direct: Expand -DUSE_MUNMAP comment. * include/gc.h: Define uintptr_t explicitly for VC++6. * msvc_dbg.c (GetModuleBase): Revert to strcat if strcat_s doesn't exist. == [7.0] 2007-07-02 == * include/gc_config_macros.h: Also check for IA64 when setting GC_HPUX_THREADS. * mallocx.c: Change my_bytes_allocd to signed_word. * include/gc_pthread_redirects.h: Remove obsolete Solaris threads (as opposed to pthreads) support. * mach_dep.c (GC_with_callee_saves_pushed): Don't use getcontext() on ARM/Linux. Check getcontext() return value. * backgraph.c (per_object_func): Make argument types consistent. (GC_traverse_back_graph): Mark GC_deepest_obj. * finalize.c (GC_finalize): Change dl_size and fo_size to size_t. * os_dep.c (GC_win32_get_mem): Add GC_mem_top_down option. * doc/README.win32, doc/README, README.QUICK: Fix some of the worst anachronisms. * dyn_load.c: Partially support cygwin, but don't enable it yet. * Makefile.am: Use -no-undefined for libgc. * Makefile.direct: Document USE_PROC_FOR_LIBRARIES. * dyn_load.c (GC_register_map_entries): Rename prot_buf to prot consistently. * misc.c: Fix some WARN calls. Move GC_is_initialized setting and GC_thr_init() call. * os_dep.c: Consistently use WARN where appropriate. * thread_local_alloc.c: Revert change to GC_WIN32_THREADS test. Instead remove inappropriate pthread.h include. * doc/README.linux: Remove some anachronisms. * alloc.c: Also use GC_check_tls on non-Linux systems. * mallocx.c (GC_reclaim_generic): Remove bogus declaration. * include/private/gc_priv.h (GC_reclaim_generic): Declare correctly with prototype. * alloc.c (GC_adj_bytes_allocd): Avoid (long) casts, fix comment. (GC_print_heap_sects): Use size_t instead of unsigned long. * thread_local_alloc.c (GC_lookup_thread): Define in the correct context. * win32_threads.c, include/gc_config_macros.h: The last of Romano Paolo Tenca's patch. Move stdint.h include to gc_config_macros.h. * include/gc_inline.h: Avoid gc_priv.h dependencies. * tests/test.c (check_heap_stats): Replace unsigned long with size_t. * NT_X64_STATIC_THREADS_MAKEFILE: Replace obsolete -debugtype:cv. * mark_rts.c (GC_push_roots): Fix kind type. * doc/README.win64: New file. * doc/doc.am, Makefile.direct: Add README.win64. * Makefile.am, Makefile.direct: Add NT_X64_STATIC_THREADS_MAKEFILE. * NT_X64_STATIC_THREADS_MAKEFILE: Fix warning flags. * allochblk.c, alloc.c, blacklst.c, dbg_mlc.c, dyn_load.c, finalize.c, headers.c, mach_dep.c, malloc.c, mark.c, misc.c, obj_map.c, os_dep.c, ptr_chck.c, reclaim.c, typd_mlc.c, win32_threads.c, cord/de_win.c, include/gc_mark.h, include/private/gc_hdrs.h, include/private/gc_pmark.h, include/private/gc_priv.h, tests/test_cpp.cc: Replace old style function declarations. Clean up integral types. Remove register declarations. The change in malloc.c and the "int descr" declaration in mark.c are the most likely to have been real bugs outside of win64. * msvc_dbg.c: Disable on win64. * win32_threads.c: Add AMD64 support. * include/gc.h: no backtrace on AMD64 for now. * msvc_dbg.c(GetModuleBase): Replace strcat with strcat_s. * include/gc.h: (GC_word, GC_signed_word): Fix win64 definitions. Don't include windows.h in an extern "C" context. * include/private/gcconfig.h: Fix win64/X86_64 configuration. * tests/test.c: Eliminate more old style function definitions. Cleanup pointer and integer casts for win64. * tests/test_cpp.cc: Don't include gc_priv.h. * NT_STATIC_THREADS_MAKEFILE: Restrict suffixes for VC++ 2005. * NT_X64_STATIC_THREADS_MAKEFILE: New. * win32_threads.c: Separate out DEBUG_WIN32_PTHREADS_STACK. Ignore FINISHED threads for suspension. (GC_pthread_join): Add pthread_self() cast. (GC_pthread_start_inner): Execute cleanup handler when popping it. * include/private/gc_locks.h: Inline THREAD_EQUAL for GC_WIN32_PTHREADS. Define USE_PTHREAD_LOCKS only if we have pthreads. * gc_dlopen.c, thread_local_alloc.c, threadlibs.c, win32_threads.c, tests/test.c: Accomodate GC_WIN32_PTHREADS. * include/gc.h: Don't include windows.h for GC_WIN32_PTHREADS. * include/gc_config_macros.h: Define both PTHREADS and GC_WIN32_THREADS. * include/private/gc_locks.h: Nonstandard definitions of NUMERIC_THREAD_ID for GC_WIN32_PTHREADS. * doc/README.win32, Makefile.direct: Include documentation for GC_WIN32_PTHREADS. * Makefile.direct: Remove some anachronisms in the documentation. * Makefile.am: Move includes to bottom. Add better library dependencies. Increment library version. Remove "SUBDIRS += .". * cord/cord.am, tests/tests.am: Add better library dependencies. Remove now unnecessary dependencies. * include/gc.h (GC_beginthreadex, GC_endthreadex, GC_ExitThread): Move to define on all Windows platforms. (_beginthread): define to generate error if used. * include/private/gc_locks.h: Format to 80 columns. * malloc.c(GC_free): Ignore bad frees on MSWIN32 with REDIRECT_MALLOC. * NT_MAKEFILE: msvc_dbg.h is in include/private. Don't use cvars rc. * misc.c (WIN32 GC_write): Define GC_need_to_lock in single-threaded case. * win32_threads.c: Test for __MINGW32__ in addition to _MINGW_VER. (GC_CreateThread, GC_beginthreadex): Deallocate args even if we fail. * include/gc.h: Add GC_reachable_here(). (GC_WinMain): Add GC_API. (GC_beginthreadex, GC_endthreadex, GC_ExitThread): Declare. * tests/test.c: Add GC_reachable_here() call. * alloc.c (GC_try_to_collect): Call GC_init if necessary. * tests/thread_leak_test.c: Don't unconditionally define GC_LINUX_THREADS. * Makefile.am: Remove extra_ldflags_libgc definition. * include/private/gc_priv.h: Define AO_REQUIRE_CAS. * finalize.c (GC_unreachable_finalize_mark_proc): Don't return void value. == [7.0alpha9] 2007-05-15 == * Some gc6.9 changes. * Change FindTopOfStack decl in darwin_stop_world.c. * Move some static tests from misc.c to gcconfig.h. Use #error. * Add GC_print_free_list() function (thanks to Bruce Hoult). * Add GC_GNU_THREADS support on HURD (thanks to Aleksey Demakov, Barry DeFreese, and possibly other Debian maintainers). * __GNUC__ was misspelled as __GNUC in thread_local_alloc.h (thanks to Peter Wang). * Integrated various MacOSX patches and tried to reconcile them (thanks to Allan Hsu, several contributors at Apple, and probably others). * Added some casts to powerpc.h in libatomic_ops to silence warnings. * Makefile.am: Include NT_STSTIC_THREADS_MAKEFILE in dist. * include/private/gc_locks.h: GC_compare_and_exchange, GC_atomic_add: remove. NUMERIC_THREAD_ID, THREAD_EQUAL: New. GC_lock_holder: now unsigned long. I_DONT_HOLD_LOCK, I_HOLD_LOCK: Update. * pthread_stop_world.c, pthread_support.c, win32_threads.c: Use NUMERIC_THREAD_ID, THREAD_EQUAL. * include/private/gcconfig.h: GENERIC_COMPARE_AND_SWAP: Remove. * include/private/thread_local_alloc.h: Don't USE_COMPILER_TLS on ARM. * dbg_mlc.c, include/gc.h, finalize.c: Merge Alexandre Oliva's GC_debug_register_finalizer_unreachable() patch from gcc tree. * thread_local_alloc.c (GC_malloc, GC_malloc_atomic): Add assertions to check GC has been initialized. * include/gc_cpp.h: Documentation updates. * include/gc_config_macros.h: Don't check for __ppc__ to set DARWIN_THREADS. * Makefile.am: Include configure_atomic_ops.sh in dist. * Makefile.am: Don't distribute copied atomic_ops files. Include libatomic_ops with "make dist". * configure.ac: Enable THREAD_LOCAL_ALLOC for Cygwin with threads. * win32_threads.c: Report error for Cygwin + GC_DLL. * Makefile.direct: Update THREAD_LOCAL_ALLOC documentation. * cord/de_win.c: Rename and move AboutBox. Call GC_INIT. Remove MakeProcInstance anachronism. * doc/README.macros: Officially remove elif prohibition. Remove documentation for defunct SRC_M3 support. * include/gc.h: Remove more SRC_M3 references. * include/private/gcconfig.h: Remove still more SRC_M3 references. GC_SOLARIS_THREADS no longer needs to be checked separately. * thread_local_alloc.c, include/private/thread_local_alloc.h: Spell __declspec correctly. * NT_STATIC_THREADS_MAKEFILE: Enable thread-local allocation. * doc/README.win32: Adjust GC_win32_dll_threads rules again. * mark.c (GC_mark_some wrapper): Restructure for readability, handle GC_started_thread_while_stopped. * misc.c (Win32 GC_write): Lock GC_write_cs only if needed. * win32_threads.c: (client_has_run): remove, GC_started_thread_while_stopped, GC_attached_thread: add. (GC_push_all_stacks): Add verbose output. (DllMain): Avoid initializing collector or the like. Never update both thread tables. * doc/README.win32: Adjust GC_win32_dll_threads rules. * pthread_stop_world.c (GC_push_all_stacks): Print thread count with GC_PRINT_VERBOSE_STATS. * configure.ac: Comment out redundant AC_DEFINE(NO_EXECUTE_PERMISSION). * sparc_mach_dep.S: Remove single quote in comment. * include/private/gcconfig.h: Fix DATAEND for NONSTOP. * win32_threads.c: Include stdint.h for Mingw. Add GC_API for DllMain. (GC_use_DllMain): Fix assertion. * configure.ac: Introduce extra_ldflags_libgc. Use it for Darwin. * Makefile.am (libgc_la_LDFLAGS): Use extra_ldflags_libgc. * include/private/gcconfig.h: Enable MPROTECT_VDB for all Darwin targets. Remove comments. Prepare ppc64 support for Darwin. * darwin_stop_world.c (GC_push_all_stacks): Fix compiler warnings. Make i unsigned. (GC_stop_world): Likewise. Remove unused GC_thread p. (GC_start_world): Likewise. * os_dep.c: Define GC_darwin_register_mach_handler_thread extern. Remove double SIG_HNDLR_PTR definition. (GC_forward_exception): Fix compiler warnings, make i unsigned. Initialize thread_state to NULL. (catch_exception_raise): Fix compiler warnings, make i unsigned. * include/private/gc_priv.h (NEED_FIND_LIMIT, FREEBSD variant): also define for X86_64. * configure.ac: Move generic gnu (Hurd) case to below kfreebsd case. * README.changes: Point to ChangeLog. * darwin_stop_world.c: Move THREAD_FLD defines to ... * include/private/gc_priv.h: ... here. Fix THREAD_STATE definitions for ppc64. * os_dep.c (catch_exception_raise): Use THREAD_FLD for exc_state member access. * configure.ac (i586-darwin): Replaced HAS_I386_THREAD_STATE_* with HAS_X86_THREAD_STATE32_*. (x86_64-*-darwin*): Extended the above check for x86_64-*-darwin* with HAS_X86_THREAD_STATE64_*. Added value 1 in the above AC_DEFINE's. Important for the upcoming Leopard. * include/private/gcconfig.h: Modified X86_64 define for Darwin. Removed __x86_64__ check in POWERPC section. Added base definitions for the X86_64 Darwin port. * include/private/gc_priv.h: Added GC_MACH_HEADER and GC_MACH_SECTION to distinguish between 32 and 64-bit applications. Added definitions for X86_64 Darwin. * darwin_stop_world.c: Added HAS_X86_THREAD_STATE64___RAX. And replaced HAS_I386_THREAD_STATE___EAX with HAS_X86_THREAD_STATE32___EAX. (GC_push_all_stacks): Added code for X86_64 Darwin. Even for the !DARWIN_DONT_PARSE_STACK. Maybe obsolete. * dyn_load.c (GC_dyld_name_for_hdr): Use GC_MACH_HEADER. (GC_dyld_image_add): Use GC_MACH_HEADER and GC_MACH_SECTION. Distinguish between getsectbynamefromheader_64 and getsectbynamefromheader. * os_dep.c (catch_exception_raise): Introduce exception definition for X86_64 Darwin. Replaced old i386_EXCEPTION_STATE_* definition with x86_EXCEPTION_STATE32_*. Add X86_64 for exc_state.faultvaddr. == [7.0alpha7] 2006-09-19 == * More 6.7 changes. * Declare GC_dump() in gc.h. * Add --enable-large-config, which just defines the LARGE_CONFIG macro. * Make GlobalAlloc address alignment a bit more intuitive (thanks to Charles Mills). * Use #elif in the definitions of GET_MEM. * Overhaul porting.html. Remove corresponding text from README. * Fix typo in DARWIN section of gcconfig.h. * Fix Darwin thread memory leak (thanks to Bruce Mitchener). * Update x86 AO_test_and_set implementation to use "=q". * Add $(EXEEXT) to many tests in tests/tests.am. (Corresponds to a 6.7 fix, which no longer applied.) * Fix Darwin/PPC port. * Fix Cygwin/threads port. * Fix gcj malloc support. * For GNU-style make, don't build libatomic_ops unless threads are requested. This should allow single-threaded builds on platforms which do not currently support libatomic_ops. * Clean up and hopefully fix the CFLAGS calculation for GNU build. (Substantially improves things on HP/UX.) * Integrated Andrei Polushin's Visual C++ patches. These provide for stack traces, better C++ debug support, and better log file handling. Note that these change the location of the log file to a the path of the executable with a .log extension. To get the old behavior back, define OLD_WIN32_LOG_FILE. For the time being, I'm checking his project files and the like into a windows-untested subdirectory. They are almost certainly already out of date, but better than what we had before. * Fixed some win32 threads bugs, and added support for _beginthreadex. * Fix zero size thread local allocation so that explicit deallocation works correctly. * Removed serious bug in GC_malloc_uncollectable(large size). * Do not try to do thread-local gcj allocation in incremental mode. There are races in setting up the descriptor. * Add GC_INIT() to middle.c, fix some more GC_printfn calls. * Some assertions erroneously used I_HOLD_LOCK() negatively, even though it can now spuriously return TRUE. * Rename SUNOS5 macro and OS name to SOLARIS and SUNOS5DL to SOLARISDL. * On Linux and some Un*x variants, allocate memory by first trying sbrk, and then switching to mmap if that fails. * Fixed /proc/x/maps reading to deal with asynchronous deletions. * Fix REDIRECT_MALLOC with threads on Linux. It now usually seems to work with ugly hacks that include having calloc behave differently when it is called from ld.so or the pthreads library. A reasonable amount of infrastructure was added to support some of this. (Thanks to Roland McGrath for ideas and information.) * Import various updated build scripts. * Add GC_register_has_static_roots_callback (thanks to Andrew Haley). * Fix serious bugs in GC_malloc_atomic_uncollectable(). * Return GC_SUCCESS form GC_get_stack_base(). * Fix several atomic_ops problems on IA64 with HP Compiler. * Update to atomic_ops-1.2. * Fix hb_n_marks description and reclaim.c assertion. * Various additional win32 threads fixes. * Enable GC_ASSERTIONS for Debug build with NT_THREADS_MAKEFILE. == [7.0alpha5] 2005-09-29 == * More 6.6, 6.7 changes. * Some Solaris fixes, including some more general changes in how the assembly pieces of mach_dep.c are handled. * Removed a lot of SOLARIS_THREADS-specific code that was only needed with the old implementation. This included many (mostly no-op) versions of GC_is_fresh. * Don't use atomic_ops in gc_locks.h unless we need threads. * Fixed USE_MARK_BITS, which is once again the default without PARALLEL_MARK. * Removed Solaris GC_INIT hack. It's a workaround for a long dead bug, and it seemed to be wrong anyway. * Changed win32_threads.c to require preprocessor-based interception of thread routines by default. A client call to GC_use_DllMain is now required to get the old behavior in which DllMain is used to implicitly register threads. This was done for uniformity with other platforms, and because the DllMain solution seemed to require very tricky code which, at least in the past, imposed hard bounds on the number of threads. * Many small changes to make thread support work again on Cygwin. * Moved definition of allocator lock etc. to pthread_support.c and win32_threads.c for those two cases. * Got rid of the FASTLOCK() machinery. It doesn't seem useful on modern platforms. * Cleaned up the uncollectible allocation routines, speeding up the slower paths. The code did enough unnecessary work off the critical path that the underlying logic was getting hard to extract. * No longer turn off THREAD_LOCAL_ALLOC with DBG_HDRS_ALL. Indications are it just works, and I think the reasons for it not working disappeared a while ago. * Fixed bugs in hb_n_marks calculation and assertion. * Don't use __builtin_expect for pre-3.0 gcc. * Define GWW_VDB only for recent Microsoft tool chains. * Add overview.html to doc directory. * Fix NT_STATIC_THREADS_MAKEFILE, various compiler warnings. * Made thread local allocation sort of work with Cygwin. The code should be there to deal with other Windows variants, But non-Cygwin Windows threads need more bug fixes. == [7.0alpha4] 2005-08-02 == * Various 6.5, 6.6 changes. * Removed GC_brief_async_signal_safe_sleep and used atomic_ops instead (thanks to Ben Maurer). * Integrated build patches from Davide Angelocola and Petter Urkedal. * Fix dynamic-linker-based pthread call redirection. * Renamed RS6000 to POWERPC/AIX. * Allow recovery from SIGSEGV in marker on Linux. This works around a race in thread stack marking if /proc is used to find roots. We do that by default with malloc redirection and threads. This involved moving some GC_find_limit and SETJMP related declarations to gc_priv.h. * Added doc/porting.html file. * Added ADD_HEAP_GUARD_PAGES for sbrk/*nix platforms to debug extreme memory overwrite errors. * Added trivial NO_INCREMENTAL flag to facilitate debugging. * Added GC_getattr_np-based GC_get_stack_base (untested). * Separated thread local allocation into a separate file and added the beginning of win32 support for that. == [7.0alpha3] 2005-04-28 == * Added support for dlopen-based interception of pthread functions. This is only half done. The gc.h redefinitions currently interfere. * Integrated major automake overhaul from Petter Urkedal. == [7.0alpha2] 2005-04-07 == * GC_bytes_allocd was incremented by a possibly uninitialized variable in GC_generic_malloc_inner. (Bug introduced in gc7.0alpha1. Thanks to Ben Hutchings for tracking it down.) * Win32 fixes (thanks to Ben Hutchings and Maurizio Vairani). * Integrated Ben Hutchings' GetWriteWatch-based virtual dirty bit implementation for win32. * Removed pc_gc.tar and floppy targets in Makefile.direct. Removed pc_excludes file. * No longer include GC_bytes_wasted when evaluating allocation progress. Since we are now counting live memory, it no longer makes sense. * Applied Davide Angelocola's configure patch. There are now separate Makefile.am's in the cord and tests subdirectory, more tests, etc. * Renamed configure.in to configure.ac. * Merged a very small number of Nathanael Nerode's configure.ac cleanups from the gcc tree. Unfortunately, that file is a bit different from ours. * Changed EINTR handling in sem_wait slightly. * Restructure the root marking code. Remove all traces of USE_GENERIC_PUSH_REGS, and effectively make it the default. Make it easier to pass a context pointer to the mark routine, in case we ever want to do precise stack marking. * Replace GC_start_blocking() and GC_end_blocking() with GC_do_blocking(). This remains undocumented, and only implemented for pthreads. But it removes an otherwise unavoidable race with stores of callee-save registers. * Fix GC_n_mark_bits for the default MARK_BIT_PER_GRANULE case. This resulted in bogus complaints in heap dumps. * Upgrade to libatomic_ops-1.0, and update build structure to match. * Remove SRC_M3 support. Clean up lock initialization code in misc.c. * Removed gc_local_alloc.h. If THREAD_LOCAL_ALLOC is defined, the thread local allocation routines are now called automatically. * Renamed gc_inl.h back to gc_inline.h. Changed the interface appreciably since locking has turned into a dominant issue, and in-line allocation only makes sense if it's no worse than thread-local allocation. Gc_inline.h is now also used to implement thread-local allocation. * Finished replacing stubborn allocation with manual write barrier. Untested. * Use thread-local allocation code by default. * Added GC_register_my_thread and friends for Posix and win32. * Patch for GWW_VDB from Ben Hutchings. * Removed explicit THREAD_LOCAL_ALLOC tests, since that now always redefines GC_malloc. * Removed now unused AIX memory allocation code. * Various minor fixes for bugs introduced in 7.0alpha1. == [7.0alpha1] 2004-11-09 == * Remove GC_PROTO, VOLATILE, GC_PTR, and GC_CONST. Assume ANSI C compiler and use ANSI constructs unconditionally. * Introduce #elif and #error in some of the appropriate places. * Remove GC_printf cruft. Use stdargs. * Remove separate Solaris threads support. Use the more generic Posix implementation. * Use atomic_ops for atomic operations and memory barriers. * Clean up MPROTECT_VDB implementation. Use SA_SIGINFO wherever possible. * Remove broken SIGNALS stuff. * Use size_t instead of word, where appropriate. * Add .S.o rule to Makefile.am. * Officially discontinue SunOS4, several old flavors of M68K (SunOS4, A/UX, HP), IBM PC/RTs and RISCOS/Irix4. (I doubt the old code worked. If anyone cares, these should be easy to resurrect.) * Add EXPECT() in some critical places. * Redefined hb_sz and hb_body to deal with bytes rather than words. This affected a great deal of code. I would like to consistently use byte offsets and sizes where there's not a convincing reason to do otherwise. * Redefined several other variables (GC_mem_found, GC_words_allocd) etc. to use units of bytes. Most of these were also renamed to reflect that fact. * Killed as many "register" declarations as possible. * Partially replaced stubborn allocation with manual write barrier. It's currently broken. * Restructured mark code, to allow mark bits to be kept either on a per allocation granule or per object basis. The emphasis is now on the -DUSE_MARK_BYTES option, since individual bits perform quite badly on hyper-threaded P4s, and are probably suboptimal on other architectures. -DUSE_MARK_BITS is currently broken, and may be resurrected only for the single-threaded case. This significantly reduced the cache footprint required by auxiliary GC data structures. It also reduces space overhead for small heaps. It probably slows things down slightly if interior pointers are very common. * As part of the above, we now maintain an approximate count of set mark bits in each heap block. * As part of the above, the semantics of hb_map changed drastically. For MARK_BIT_PER_OBJ, it doesn't exist. For MARK_BIT_PER_GRANULE, it is purely a way to replace a mod instruction with a table lookup. (Somewhat to my surprise, this still wins on modern hardware.) * Removed PRINTSTATS, GATHERSTATS, and SILENT macros. Everything is now controlled by GC_print_stats variable and GC_PRINT_STATS and new GC_PRINT_VERBOSE_STATS environment variables. * Add GC_log_printf and use it consistently for logging output. * Unconditionally count the objects we reclaim in the sweep phase. For thread local allocation, we need that anyway, and we expect that's increasingly the only case that matters. And it simplifies the code. In general expect minor performance hacks that benefit only the single-threaded case to disappear. * Remove GC_quiet from gc.h and elsewhere. * Changed the heap expansion heuristic, and the definition of GC_free_space_divisor, to refer to live data size, instead of total heap size. I believe this is much more robust. It wasn't previously possible, because we didn't have access to live data size. * Thread local allocation added the extra byte in twice: Once in thread_local_alloc, and once in malloc_many. * Removed GC_malloc_words_small and GC_gcj_fast_malloc. A new mechanism based on the thread local allocation data structures is expected to be added instead. This should allow inlined code that is both fast and doesn't rely on collector internals. * Changed both free lists and reclaim lists to be indexed by granules instead of words, norming halving their size. * MERGE_SIZE is now the only option, and the macro was removed. (Without it, we need a memory reference to GC_all_interior_pointers anyway. Thus it costs us nothing.) * Change GC_size_map to map to granules instead of words. Make sure that every possible size up to TINY_FREELISTS is present. * Split of macros need for fast inline allocation into gc_tiny_fl.h in anticipation of a new inline allocator that doesn't rely on GC internals. * Changed thread local allocation to use GRANULE_BYTES and TINY_FREELISTS in anticipation of a merge with the inline allocation code. * Removed ALIGN_DOUBLE. This is mostly handled by GRANULE_BYTES. * Make locking on most platforms conditional on GC_need_to_lock. == [6.9] == * Fix typo in PREFETCH implementation for X86_64 (thanks to Peter Wang). * Fix M68K LINUX port (thanks to Debian packagers). * __GNUC__ was misspelled as __GNUC in new_gc_alloc.h (thanks to Peter Wang). * Integrated Allan Hsu's patch for OS X VM deallocation problems. * Applied FreeBSD/X86_64 patch. == [6.8] 2006-07-08 == * Added some support for Dragonfly BSD (thanks to Joerg Sonnenberger and Thomas Klausner). * Improvements to the HP/UX section of configure.in/configure.ac (thanks to Andreas Tobler). * GC_unix_get_mem could neglect to release the malloc lock on Irix, under extremely unlikely circumstances. (Thanks to Jean-Baptiste Nivois for some careful code inspection.) * Added support for kFreeBSD + glibc (thanks to Petr Salinger). * Fix more MacOS threads memory leaks (thanks to Allan Hsu). * Added initial Solaris/X86-64 support (thanks to Rainer Orth). == [6.7] 2006-03-03 == * Add "int" to Solaris "end" and "etext" declaration in gc.h. Declared the symbols with underscores and as arrays, since that's what's actually used. Perhaps this could all just be removed. (Thanks to John Bowman.) * Fixed ARM GC_test_and_set code (thanks to Kazu Hirata and Paul Brook). * Added casts for assignments to hb_last_reclaimed, which truncate the value. Added a cast to GC_adj_words_allocd. Use GetModuleHandleA when retrieving a handle to kernel32.dll under win32. * Added Tandem S-Series support. (Thanks to Craig McDaniel. A modified version of his patch was applied, and hence breakage is probably not his fault.) * Remove spurious gc:: qualifier for operator delete[] in gc_cpp.h (thanks to Hanno Boeck). * Changed a test for LINUX in config_macros.h to one for __linux__. * Add prototypes for GC_finalizer_notifier and GC_thr_init (thanks to David Ayers). * Use ld instead of nonexistent ldz instruction in Darwin FindTopOfStack (thanks to Andreas Tobler). * Add support for Darwin/X86 (thanks to Geoff Norton and the Mono developers). * Merge in some recent gcc fixes. Add ppc64 asm code. (Thanks to Bryce McKinlay and other GCJ developers.) * Scan MEM_PRIVATE sections under Windows ME and predecessors. * Interior pointers with some largish offsets into large objects could be ignored, if GC_all_interior_pointers was set. (Oddly this worked correctly for stack references if it was not set. Otherwise it failed for both stack and heap references. Thanks to Andrew McKinlay for the critical test case.) * Integrated Tatsuya Bizenn's NETBSD threads support, with some untested changes. * Added GC_strdup and friends to make leak detection work correctly for strdup clients (thanks to Jon Moore). Fixed the existing strdup with malloc redirection to handle a null malloc return correctly. == [6.6] 2005-09-09 == * Fix CPU count detection for Irix and FreeBSD (thanks to Dan Bonachea). * Integrate Dan Bonachea's patch for the IBM XLC compiler on Darwin. * Integrated Andreas Tobler's FreeBSD/PowerPC patch. * Don't access the GC thread structure from the restart handler. It's unsafe, since the handler may run too late. (Thanks to Ben Maurer for tracking this down.) * Applied Christian Thalinger's patch to change comment syntax in alpha_mach_dep.S. * Added test for GC_no_dls in GC_dyld_image_add for DARWIN (thanks to Juan Jose Garcia-Ripoll). * Use LINUX_STACKBOTTOM for Linux/SH and LINUX/ARM (thanks to Sugioka Toshinobu and Christian Thalinger). * Rewrote GC_parse_map_entry. This assumed a fixed column layout of /proc/self/maps on Linux. This ceased to be true about 2 years ago. The old code is probably quite problematic with -DREDIRECT_MALLOC. It is also used by default for IA64, though I haven't seen actual failures there. * More consistently define HBLKSIZE to 4096 on 64 bit architectures with 4K pages (thanks to Andrew Haley). * With win32 threads, GC_stop_world needs to acquire GC_write_cs (thanks to Ben Hutchings for the observation and patch). * Move up struct callinfo declaration to make gcc 4.0.2 happy. == [6.5] 2005-05-22 == * Integrated Paolo Molaro's patch to deal with EINTR in sem_wait. * Make GC_approx_sp() write to dummy location to ensure that stack is grown here, when sp looks reasonable, rather than later, when it might look like a bad memory reference. (Problem was never observed that I know of. But on rereading the code it seemed dubious.) * Separate out GC_with_callee_saves_pushed and sometimes call it from GC_suspend_handler in pthread_stop_world.c. Callee-save register values sometimes failed to get traced under HP/UX on PA-RISC. Linux/IA64 had the same problem, though non-stacked callee-save registers seem to be so rarely used there that nobody ever noticed. * Integrated an ancient Darwin powerpc_darwin_machine_dep.s patch from Andreas Tobler, which I had lost. * Fix compare_and_exchange implementation for gcc/IA64 to deal with pickier compiler versions. * Fixed Itanium 32-bit ABI support (HP/UX). In particular, the compare_and_exchange implementation didn't consider that possibility. * Undefine GC_pthread_detach in win32_threads.c (thanks to Tommaso Tagliapietra). * Fixed inclusion of frame.h for NETBSD in os_dep.c. * Applied Dan Bonachea's patch to use mmap on AIX. * Several fixes to resurrect the Irix port on recent OS versions. * Change ALPHA to use LINUX_STACKBOTTOM. * Change SPARC64/LINUX to also use LINUX_STACKBOTTOM. Deal with potential bad values of __libc_stack_end on that platform (thanks to David Miller). * Relax gctest to allow larger heap if ALIGN_DOUBLE isn't set. (Unnecessary in 7.0) * Force a define of __STDC__=0 for the IBM compiler on AIX, so that we get prototypes. (Unnecessary in 7.0) * GC_INIT definition for AIX and CYGWIN referred to DATASTART and DATAEND which are only defined in private include files. * Integrated some small gcconfig.h patches from Dan Bonachea. Also relaxed assertion about FreeBSD stack size in pthread_support.c. * Integrated Andrew Begel's darwin_stop_world.c patch for 64-bit support. This may need additional work. * Avoided potentially infinite recursion in GC_save_callers if the system backtrace calls malloc. The workaround currently requires __thread support if this code is used with threads. * Avoided another similar infinite recursion by conditionally invoking GC_save_callers in alloc.c (thanks to Matthias Andree for helping to track down both of these). * Removed all traces of aix_irix_threads.c. AIX and Irix now use pthread_support.c and pthread_stop_world.c. The old code appeared to be unreliable for AIX, and was not regularly maintained. * On Irix, ignore segments with MA_FETCHOP or MA_NOTCACHED attributed; they're not always safe to read. * Fixed a previously vacuous assertion (diagnosed by the SGI compiler) in GC_remove_from_fl. * Fix stack_size assertion in GC_pthread_create. * Fix assertion in GC_steal_mark_stack. == [6.4] 2004-12-21 == * Merge gcconfig.h changes from gcc tree. * Unconditionally include gc_priv.h in solaris_pthreads.c, win32_threads.h, aix_irix_threads.c, and solaris_threads.c to get thread definitions. * Start marker threads in GC_thr_init, so that they get started even if no other threads are ever started. (Oddly enough, the parallel collector worked correctly, though not well, with no helper threads.) * Go ahead and split large blocks in GC_allochblk_nth if GC_dont_gc is set (thanks to Alexander Petrossian). * GC_PRINT_BACK_HEIGHT would deadlock with thread support. * Let in_progress_space in backgraph.s grow dynamically. * Fix README.solaris2. The GC_thr_init() hack doesn't work anymore. * Convert GC_finalizer_mem_freed to bytes in allchblk.c. * Add missing declaration for GC_generic_malloc_words_small_inner. Without it, s390x breaks. (Thanks to Ulrich Weigand.) * Applied several MacOSX patches to support older tool chains (thanks to Stefan Ring). * Bug fix for NetBSD/amd64 (thanks to Marc Recht). * Add NetBSD/sh3 support (thanks to Uchiyama Yasushi). * Fixed an uninitialized variable in cordprnt.c. * Eliminated some, but not all, gcc -Wall warnings. * Changed some old style casts to reinterpret_cast in new_gc_alloc.h (thanks to Dan Grayson). * GC_extend_size_map shouldn't adjust for GC_all_interior_pointers if GC_DONT_ADD_BYTE_AT_END is set. * Changed some (long) casts to (word) in preparation for win64 (thanks to Peter Colson). * Changed "int stack_size" declaration in pthread_support.c to use size_t. (Only mattered with GC_ASSERTIONS enabled.) * Added CRIS (etrax) support (thanks to Simon Posnjak and Hans-Peter Nilsson). * Removed GC_IGNORE_FB frame buffer recognition, and replaced it with a check that the mapping type is MEM_IMAGE. In theory, this should work much better, but it is a high risk change for win32. (Thanks to Ashley Bone for the crucial experimental data behind this, and to Rutger Ovidius for some further experiments.) * GC_allochblk_nth incremented GC_words_wasted by bytes rather than words. * Consider GC_words_wasted in GC_adj_words_allocd only if it is within reason. (A hack to avoid some extremely unlikely scenarios in which we manage to allocate only "wasted" space. 7.0 has a better fix.) * Changed PowerPC GC_clear implementation to use lwsync instead of eieio, since the documentation recommends against eieio, and it seems to be incorrect if the preceding memory op is a load. * Fixed print_block_list to print the correct kind number for STUBBORN (thanks to Rutger Ovidius). * Have configure.in generate an error if it is asked to support pthreads, but doesn't know how to. * Added Kazuhiro Inaoka's patch for Renesas M32R support. * Have the GNU build mechanism link with -ldl. Rename THREADLIBS to THREADDLLIBS to reflect this. (Thanks to Sven Verdoolaege.) * Added Hannes Mehnert's patch for FreeBSD/SPARC support. * Merged some FreeBSD specific patches to threadlibs.c and dyn_load.c. (Thanks to John Merryweather Cooper.) * Define MPROTECT_VDB on MACOSX only if threads are being used, since the dirty page tracking mechanism uses threads. (This avoids an undefined reference to _GC_darwin_register_mach_handler_thread.) * By popular demand, use __libc symbols only if we are built with USE_LIBC_PRIVATES, which is off by default, and not otherwise documented. * Ignore GC_enable_incremental() requests when KEEP_BACK_PTRS is set. The GC itself will dirty lots of pages in this cases, probably making it counterproductive on all platforms. And the DARWIN port crashes. == [6.3] 2004-07-08 == * Compile test_cpp.cc with CXXCOMPILE instead of COMPILE. * Very large allocations could cause a collector hang. Correct calculation of GC_collect_at_heapsize. * GC_print_hblkfreelist printed some bogus results if USE_MUNMAP was defined. * Include gc_config_macros.h in threadlibs.c. * Correct MacOSX thread stop code (thanks to Dick Porter). * SMALL_OBJ definition was off by one. This could cause crashes at startup. (Thanks to Zoltan Varga for narrowing this down to a trivial test case.) * Integrate Paolo Molaro's patch to deal with a race in the Darwin thread stopping code. * Changed X86_64 implementation to use SA_SIGINFO in the MPROTECT_VDB implementation. The old approach appears to have been broken by recent kernels. * Added GC_ATTR_UNUSED to eliminate a warning in gc_allocator.h (thanks to Andrew Begel). * Fix GC_task_self declaration in os_dep.c (thanks to Andrew Pinski). * Increase INITIAL_BUF_SZ in os_dep.c for Solaris /proc reads. == [6.3alpha6] 2004-05-06 == * Define USE_GENERIC_PUSH_REGS for NetBSD/M68K. * Fixed the X86_64 PREFETCH macros to correctly handle ia32e (which uses different prefetch instructions from AMD64). (Thanks to H.J. Lu.) * GC_config_macros.h did not correctly define GC_WIN32_THREADS from GC_THREADS. * Added simple_example.html. * Merged Andrew Gray's patch to correctly restore signal handlers on FreeBSD. * Merged a patch from Andreas Jaeger to deal with prefetch-related warnings on x86-64. Added some other casts so that the PREFETCH macros always get a ptr_t argument. Removed some casts in the PREFETCH implementations. * Added a header guard for gc_allocator.h and changed GC_debug_free to clobber contents of deallocated object (suggested by Jesse Jones). * The signal masking code in pthread_stop_world.c contained some errors. In particular SIGSEGV was masked in the handler, in spite of the fact that it wrote to the heap. This could lead to an uncaught SIGSEGV, which apparently became much more likely in Linux 2.6. Also fixed some typos, and reduced code duplication in the same area. * Remove ltconfig, clean up configure messages for DG/UX (thanks to Adrian Bunk for the patches). * Integrated NetBSD/OpenBSD patches from Marc Recht and Matthias Drochner. == [6.3alpha5] 2004-03-30 == * Fix & vs && typo in GC_generic_malloc and GC_generic_malloc_ignore_off_page. (Propagated from the gcc tree.) * Removed SA_NODEFER hack from NetBSD and Solaris write-protect handler. (According to Christian Limpach, the NetBSD problem is fixed. Presumably so is the Solaris 2.3 problem.) * Removed placement delete from gc_cpp.h for the SGI compiler (thanks to Simon Gornall for the patch). * Changed semantics of the GC_IGNORE_FB environment variable, based on experimentation by Nicolas Cannasse pointing out that the old interpretation was useless. We still need help in identifying win32 graphics memory mappings. The current "solution" is a hack. * Removed "MAKEOVERRIDES =" from Makefile.am and thus Makefile.in. It probably made more sense in the gcc context. * Explicitly ensure that NEED_FIND_LIMIT is defined for {Open,Net}BSD/ELF. * Replaced USE_HPUX_TLS macro by USE_COMPILER_TLS, since gcc often supports the same extension on various platforms. * Added some basic (completely untested) defines for win64, in support of future work. * Declared GC_jmp_buf in os_dep.s as JMP_BUF instead of jmp_buf, fixing a memory overwrite bug on Solaris and perhaps other platforms. * Added 0 != __libc_stack_end test to GC_linux_stack_base (thanks to Jakub Jelinek for the patch and explaining the problem). Otherwise pre-linking could cause the collector to fail. * Changed default thread local storage implementation to USE_PTHREAD_SPECIFIC for HP/UX with gcc. The compiler-based implementation appears to work only with the vendor compiler. * Export GC_debug_header_size and GC_USR_PTR_FROM_BASE from gc_mark.h, making client mark code cleaner and less dependent on GC version. * Export several new procedures and GC_generic_malloc from gc_mark.h to support user-defined kinds. Use the new procedures to replace existing code in gcj_mlc.c and typd_mlc.c. * Added support for GC_BACKTRACES. * Fixed a remaining problem in CORD_str with signed characters (thanks to Alexandr Petrosian for the patch). * Removed supposedly redundant, but very buggy, definitions of finalizer macros from javaxfc.h. Fortunately this file probably has no users. The correct declarations were already in gc.h. * Also need to set GC_in_thread_creation while waiting for GC during thread termination, since it is also possible to collect from an unregistered thread in that case. * Define NO_GETENV for Windows CE, since getenv doesn't appear to exist. Plus some other minor WinCE fixes (thanks to Alain Novak). * Added GC_register_describe_type_fn. * Arrange for debugging finalizer registration to ignore non-heap registrations, since the regular version of the routine also behaves that way. * GC_gcj_malloc and friends need to check for finalizers waiting to be run. One of the more obscure allocation routines with missing a LOCK() call. * Fixed cvtres invocations in NT_MAKEFILE and NT_STATIC_THREADS_MAKEFILE to work with VS.NET. * Cleaned up GC_INIT calls in test. Updated gc.man to encourage GC_INIT use in portable code. * Taught the GC to use libunwind if --enable-full-debug is specified on IA64 and libunwind is present. * The USE_MUNMAP code could get confused about the age of a block and prematurely unmap it. GC_unmap_old had a bug related to wrapping of GC_gc_no. GC_freehblk and GC_merge_unmapped didn't maintain hb_last_reclaimed reasonably when blocks were merged. The code was fixed to reflect original intent, but that may not always be an improvement. == [6.3alpha4] 2004-01-01 == * USE_MMAP was broken by confusion in the code dealing with USE_MMAP_ANON. * Darwin support was broken in alpha3 as a result of my mis-integration of Andrew Begel's patches. Fixed with another patch from Andrew Begel. * A new sanity check in pthread_stop_world.c:GC_push_all_stacks() was overly aggressive. We may collect from an unregistered thread during thread creation. Fixed by explicitly checking for that case. (Added GC_in_thread_creation.) == [6.3alpha3] 2003-12-20 == * Removed -DSMALL_CONFIG from BCC_MAKEFILE. * Changed macros to test for an ARM processor (Patch from Richard Earnshaw.) * Mostly applied a DJGPP patch from Doug Kaufman. Especially Makefile.dj had suffered from serious bit rot. * Rewrote GC_apply_to_maps, eliminating an off-by-one subscript error, and a call to alloca (for lcc compatibility). * Changed USE_MUNMAP behavior on POSIX platforms to immediately remap the memory with PROT_NONE instead of unmapping it. The latter risks an intervening mmap grabbing the address space out from underneath us. Updated this code to reflect a cleaner patch from Ulrich Drepper. * Replaced _T with _Tp in new_gc_alloc.h to avoid a MACOS X conflict. (Patch from Andrew Begel.) * Dynamically choose whether or not lock should spin on win32 (thanks to Maurizio Vairani for the patch). This may be a significant performance improvement for win32. * Fix Makefile.direct to actually include NT_STATIC_THREADS_MAKEFILE in the distribution (thanks to Maurizio Vairani). * Maybe_install_looping_handler() was accidentally exported, violating our name space convention. * Made os_dep.c use sigsetjmp and SA_NODEFER for NetBSD. (Thanks to Christian Limpach. I generalized the patch to use sigsetjmp on all UNIX_LIKE platforms, admittedly a slightly risky move. But it may avoid similar problems on some other platforms. I also cleaned up the definition of UNIX_LIKE a bit.) * Integrated Andrew Begel's Darwin threads patch, adjusted according to some of Fergus Hendersons's comments. (Patch didn't apply cleanly, errors are possible.) * Added another test or two for the Intel 8.0 compiler to avoid confusing it with gcc. The single-threaded collector should now build with icc, at least on ia64. == [6.3alpha2] 2003-11-04 == * Re-enabled I_HOLD_LOCK assertion in aix_irix_threads.h. * Put back the WINABI qualifier for GC_CreateThread. (Thanks to Danny Smith for the patch. 6.3alpha1 had the qualifier in one place but not elsewhere, which was clearly wrong.) * Sometimes explicitly define __private_extern__ before DARWIN dyld.h include. (Thanks to Andreas Tobler for posting the patch.) * Included signal.h from pthread_support.c. Removed GC_looping_handler, which was dead code. * GC_find_start was misdeclared by gc_pmark.h if PRINT_BLACK_LIST was defined (thanks to Glauco Masotti for testing and reporting this). Changed GC_find_start to never just return 0. According to its comment it doesn't, and it's unclear that's correct. * GC_alloc_large had several largely compensating bugs in the computation of GC_words_wasted. (It was confused about bytes vs. words in two places.) * Integrated Slava Sysoltsev's patch to support more recent versions of the Intel compiler on IA64/Linux. * Changed win32 spinlock initialization to conditionally set a spin count. (Emmanual Stumpf pointed out that enabling this makes a large performance difference on win32 multiprocessors.) Also cleaned up the win32 spinlock initialization code a bit. * Fixed thread support for HP/UX/IA64. The register backing store base for the main thread was sometimes not set correctly. (Thanks to Laurent Morichetti.) * Added -DEMPTY_GETENV_RESULTS flag to work around Wine problem. * Declare GC_stack_alloc and GC_stack_free in solaris_threads.h to avoid 64-bit size mismatches (thanks to Bernie Solomon). * Fixed GC_generic_push_regs to avoid a potential and very unfortunate tail call optimization. This could lead to prematurely reclaimed objects on configurations that used the generic routine and the new build infrastructure (which potentially optimizes mach_dep.c). This was a serious bug, but it's unclear whether it has resulted in any real failures. * Fixed CORD_str to deal with signed characters (thanks to Alexandr Petrosian for noticing the problem and supplying the patch). * Merged a couple of NOSYS/ECOS tests into os_dep.c from gcj (thanks to Anthony Green). * Partially merged a win32 patch from Ben Hutchings, and substantially revised other parts of win32_threads.c. It had several problems. Under MinGW with a statically linked library, the main thread was not registered. Cygwin detached threads leaked thread descriptors. There were several race conditions. For now, unfortunately the static threads limit remains, though we increased it, and made table traversal cost depend on the actual thread count. There is also still some code duplication with pthread_support.c. (Thread descriptors did become much smaller, since Ben Hutchings removed the thread context from them.) * Integrated a Solaris configure.in patch from Rainer Orth. * Added GC_IGNORE_FB and associated warning to very partially address the issue of the collector treating a mapped frame buffer as part of the root set. (Thanks to David Peroutka for providing some insight. More would be helpful. Is there anything that can be used to at least partially identify such memory segments?) == [6.3alpha1] 2003-07-26 == * Integrated some NetBSD patches by Marc Recht. These were already in the NetBSD package. * GC_pthread_create waited for the semaphore even if pthread_create failed. (Thanks to Dick Porter for the pthread_support.c patch.) Applied the analogous fix for aix_irix_threads.c. * Added Rainer Orth's Tru64 fixes. * The check for exceeding the thread table size in win32 threadDetach was incorrect (thanks to Alexandr Petrosian for the patch). * Applied Andrew Begel's patch to correct some reentrancy issues with dynamic loading on Darwin. * GC_CreateThread() was neglecting to duplicate the thread handle in the table (thanks to Tum Nguyen for the patch). * Pass +ESdbgasm only on PA-RISC machines with vendor compiler (thanks to Roger Sayle for the patch). * Applied more AIX threads patches from Scott Ananian. == [6.2] 2003-06-21 == * Integrated a second round of Irix/AIX patches from Dan Bonachea. Renamed mips_sgi_mach_dep.S back to mips_sgi_mach_dep.s, since it requires the Irix assembler to do the C preprocessing; gcc -E doesn't work. * Fixed Makefile.direct for DARWIN (thanks to Manuel Serrano). * There was a race between GC_pthread_detach and thread exit that could result in a thread structure being deallocated by GC_pthread_detach even though it was still needed by the thread exit code (thanks to Dick Porter for the small test case that allowed this to be debugged). * Fixed version parsing for non-alpha versions in acinclude.m4 and version checking in version.h. * Issues identified (not yet fixed): - A dynamic libgc.so references dlopen unconditionally, but doesn't link against libdl. - GC_proc_fd for Solaris is not correctly updated in response to a fork() call. Thus incremental collection in the child won't work correctly. (Thanks to Ben Cottrell for pointing this out.) - --enable-redirect-malloc is mostly untested and known not to work on some platforms. - There seem to be outstanding issues on Solaris/X86, possibly with finding the data segment starting address. - Very large root set sizes (> 16 MB or so) could cause the collector to abort with an unexpected mark stack overflow. (Thanks to Peter Chubb.) NOT YET FIXED. Workaround is to increase the initial size. - The SGI version of the collector marks from mmapped pages, even if they are not part of dynamic library static data areas. This causes performance problems with some SGI libraries that use mmap as a bitmap allocator. NOT YET FIXED. It may be possible to turn off DYNAMIC_LOADING in the collector as a workaround. It may also be possible to conditionally intercept mmap and use GC_exclude_static_roots. The real fix is to walk rld data structures, which looks possible. - Incremental collector should handle large objects better. Currently, it looks like the whole object is treated as dirty if any part of it is. == [6.2alpha6] 2003-06-05 == * There was an extra underscore in the name of GC_save_registers_in_stack for NetBSD/SPARC (thanks to Jaap Boender for the patch). * Integrated Brian Alliet's patch for Darwin. This restructured the linuxthreads/pthreads support to separate generic pthreads support from more the system-dependent thread-stopping code. I believe this should make it easier to eliminate the code duplication between pthreads platforms in the future. The patch included some other code cleanups. * Integrated Dan Bonachea's patch to support AIX threads. This required substantial manual integration, mostly due to conflicts with other recent threads changes. It may take another iteration to get it to work. * Removed HPUX/PA-RISC support from aix_irix_threads.c. It wasn't used anyway and it cluttered up the code. And anything we can do to migrate towards generic pthreads support is a good thing. * Added a more explicit test for tracing of function arguments to test.c. * Added Akira Tagoh's PowerPC64 patch. * Fixed some bit rot in the Cygwin port (thanks to Dan Bonachea for pointing it out). gc.h now includes just windows.h, not winbase.h. * Declared GC_save_regs_in_stack() in gc_priv.h. Remove other declarations. * Changed --enable-cplusplus to use automake consistently. The old way confused libtool. "Make install" didn't work correctly for the old version. Previously --enable-cplusplus was broken on cygwin. * Changed the C version of GC_push_regs to fail at compile time if it is generated with an empty body. This seems to have been the cause of one or two subtle failures on unusual platforms. Those failures should now occur at build time and be easily fixable. == [6.2alpha5] 2003-05-14 == * GC_invoke_finalizers could, under rare conditions, set GC_finalizer_mem_freed to an essentially random value. This could possibly cause unbounded heap growth for long-running applications under some conditions. (The bug was introduced in 6.1alpha5, and is not in gcc3.3.) * Attempted to sanitize the various DLL macros. GC_USE_DLL disappeared. GC_DLL is used instead. All internal tests are now on GC_DLL. README.macros is now more precise about the intended meaning. * Include DllMain in the multi-threaded win32 version only if the collector is actually built as a dll (thanks to Mohan Embar for a version of the patch). * Hide the cygwin threadAttach/Detach functions. They were violating our namespace rules. * Fixed an assertion in GC_check_heap_proc. Added GC_STATIC_ASSERT (thanks again to Ben Hutchings). * Removed some obsolete definitions for Linux/PowerPC in gcconfig.h. * CORD_cat was not rebalancing unbalanced trees in some cases, violating a CORD invariant. Also tweaked the re-balancing rule for CORD_cat_char_star. (Thanks to Alexandr Petrosian for the bug report and patch.) * Added hand-coded structured exception handling support to mark.c. This should enable support of dynamic libraries under win32 with gcc-compiled code. (Thanks to Ranjit Mathew for the patch.) Turned on dynamic library scanning for win32/gcc. * Removed some remnants of read wrapping (thanks to Kenneth Schalk). GC_USE_LD_WRAP ws probably broken in recent versions. * The build could fail on some platforms since gcconfig.h could include declarations mentioning ptr_t, which was not defined, e.g. when if_mach was built (thanks to Yann Dirson for pointing this out). Also cleaned up tests for GC_PRIVATE_H in gcconfig.h a bit. * The GC_LOOP_ON_ABORT environment variable interfered with incremental collection, since the write fault handler was erroneously overridden. Handlers are now set up in the correct order. * It used to be possible to call GC_mark_thread_local_free_lists() while the world was not stopped during an incremental GC. This was not safe. Fortunately, it was also unnecessary. Added GC_world_stopped flag to avoid it. (This caused occasional crashes in GC_set_fl_marks with thread local allocation and incremental GC. This probably happened primarily on old, slow multiprocessors.) * Allowed overriding of MAX_THREADS in win32_threads.c from the build command line (thanks to Yannis Bres for the patch). * Taught the IA64/linux code to determine the register backing store base from /proc/self/maps after checking the __libc symbol, but before guessing. (__libc symbols are on the endangered list, and the guess is likely to not always be right for 2.6 kernels.) Restructured the code to read and parse /proc/self/maps so it only exists in one place (all platforms). * The -DUSE_PROC_FOR_LIBRARIES code was broken on Linux. It claimed that it also registered the main data segment, but didn't actually do so. (I don't think anyone actually uses this configuration, but ...) * Made another attempt to get --enablecplusplus to do the right thing. Since there are unavoidable problems with C programs linking against a dynamic library that includes C++ code, I separated out the c++ code into libgccpp. == [6.2alpha4] 2003-03-10 == * Use LINUX_STACKBOTTOM for >= glibc2.2 on Linux/MIPS. (See Debian bug # 177204) * Integrated Jeff Sturm and Jesse Rosenstock's MACOSX threads patches. * Integrated Grzegorz Jakacki's substantial GNU build patch. "Make dist" should now work for the GNU build process. Documentation files are installed under share/gc. * Tweaked gc_cpp.h to again support the Borland compiler (thanks to Rene Girard for pointing out the problems). * Updated BCC_MAKEFILE (thanks to Rene Girard). * Added GC_ASSERT check for minimum thread stack size. * Added --enable-gc-assertions. * Added some web documentation to the distribution. Updated it in the process. * Separate gc_conf_macros.h from gc.h. * Added generic GC_THREADS client-defined macro to set the appropriate GC_XXX_THREADS internal macro. (gc_config_macros.h.) * Add debugging versions of _ignore_off_page allocation primitves. * Moved declarations of GC_make_closure and GC_debug_invoke_finalizer from gc.h to gc_priv.h. * Reset GC_fail_count even if only a small allocation succeeds. * Integrated Brian Alliet's patch for dynamic library support on Darwin. * gc_cpp.h's gc_cleanup destructor called GC_REGISTER_FINALIZER_IGNORE_SELF when it should have called the lower case version, since it was explicitly computing a base pointer. == [6.2alpha3] 2003-01-30 == * Don't include execinfo.h in os_dep.c when it's not needed, and may not exist. == [6.2alpha2] == * Fixed the completely broken FreeBSD code in 6.2alpha1 (thanks to Hironori Sakamoto for the patch). * Changed IRIX reference in dbg_mlc.c to IRIX5 (thanks to Marcus Herbert). * Attempted to work around the problems with .S filenames and the SGI compiler. (Untested.) * Worked around an HP/UX make issue with the GNU-style build process. * Fixed the --enable-cplusplus build machinery to allow builds without a C++ compiler. (That was always the intent ...) * Changed the debugging allocation macros to explicitly pass the return address for Linux and XXXBSD on hardware for which we can't get stack traces. Use __builtin_return_address(0) to generate it when possible. Some of the configuration work was cleaned up (good) and moved to gc.h (bad, but necessary). This should make leak detection more useful on a number of platforms. (Thanks to Fabian Thylman for the suggestion.) * Fixed compilation problems in dbg_mlc.c with GC_ADD_CALLER. * Bumped revision number for dynamic library. == [6.2alpha1] 2003-01-23 == * Guard the test for GC_DUMP_REGULARLY in misc.c with "#ifndef NO_DEBUGGING". Otherwise it fails to build with NO_DEBUGGING defined. (Thanks to Manuel Serrano.) * Message about retrying suspend signals was incorrectly generated even when flag was not set. * Cleaned up MACOSX/NEXT root registration code. There was apparently a separate ifdef case in GC_register_data_segments() for no reason. * Removed MPROTECT_VDB for MACOSX port, based on one negative report. * Arrange for gc.h and friends to be correctly installed with GNU-style "make install". * Enable the GNU-style build facility include C++ support in the library with --enable-cplusplus (thanks to Thomas Maier for some of the patch). * Mark from GC_thread_key in linux_threads.c, in case that's allocated from the garbage collected heap, as it is with our own thread-specific storage implementation (thanks to Jeff Sturm). * Mark all free list header blocks if they are heap allocated. This avoids some unnecessary tracing. And it remains correct if we clear the root set. (Thanks to Jeff Sturm for identifying the bug.) * Improved S390/Linux support. Add S390/Linux 64-bit support (thanks to Ulrich Weigand). * Corrected the spelling of GC_{M,C}ALLOC_EXPLICTLY_TYPED to GC_{M,C}ALLOC_EXPLICITLY_TYPED in gc_typed.h. This is technically an interface change. Based on the fact that nobody reported this, I suspect/hope there were no clients. * Cleaned up gc_typed.h so that (1) it adds an extern "C" declaration when appropriate, (2) doesn't generate references to undefined internal macros, and (3) allows easier manual construction of descriptors. * Close the file descriptor used by GC_print_address_map(). * Set the "close-on-exec" bit for various file descriptors maintained for the collector's internal use. * Added a hack to find memory segments owned by the system allocator under win32. Based on my tests, this tends to eventually find all segments, though it may take a while. There appear to be cleaner, but slower solutions under NT/XP. But they rely on an API that's unsupported under 9X. * Changed Linux PowerPC stack finding to LINUX_STACKBOTTOM. (Thanks to Akira Tagoh for pointing out that HEURISTIC1 does not work on 64-bit kernels.) * Added GC_set_free_space_divisor to avoid some Windows dll issues. * Added FIXUP_POINTER, POINTER_SHIFT, POINTER_MASK to allow preprocessing of candidate pointers for tagging, etc. * Always lock around GC_notify_full_gc(). Simplified code for invoking GC_notify_full_gc(). * Changed the way DATASTART is defined on FreeBSD to be robust against an unmapped page after etext. (Thanks to Hironori Sakamoto for tracking down the intermittent failure.) * Made GC_enable() and GC_disable() official. Deprecated direct update of GC_dont_gc. Changed GC_gcollect to be a noop when garbage collection is disabled. * Call GC_register_dynamic_libraries before stopping the world on Linux, in order to avoid a potential deadlock due to the dl_iterate_phdr lock. * Introduced a more general mechanism for platform-dependent code to decide whether the main data segment should be handled separately from dynamic libraries, or registered by GC_register_dynamic_libraries. The latter is more reliable and easier on Linux with dl_iterate_phdr. == [6.1] == * Added GC_MAXIMUM_HEAP_SIZE environment variable. * Fix configure.in for MIPS/LINUX (thanks to H.J. Lu). * Double page hash table size for -DLARGE_CONFIG. * Integrated Bo Thorsen's X86-64 support. * STACKBOTTOM definition for LINUX/MIPS was partially changed back (thanks to H.J. Lu and Hiroshi Kawashima for resolving this). * Replaced all occurrences of LINUX_DATA_START in gcconfig.h with SEARCH_FOR_DATA_START. It doesn't hurt to fall back to a search. And __data_start doesn't seem to get defined correctly of the GC library is loaded with LD_PRELOAD, e.g. for leak detection. * If the GC_find_leak environment variable is set, do a atexit(GC_gcollect) to give us at least one chance to detect leaks. This may report some very benign leaks, but ... * Addeded REDIRECT_FREE. It's necessary if we want leak detection with LD_PRELOAD. * Defer printing of leaked objects, as for smashed objects. * Fixed process and descriptor leak in GC_print_callers. Try for line number even if we got function name.) * Ported parallel GC support and thread local allocation to Alpha. Not yet well-tested. * Added GC_DUMP_REGULARLY and added finalization statistics to GC_dump(). * Fixed Makefile.am to mention alpha_mach_dep.S instead of the defunct alpha_mach_dep.s. * Incorporated a change to new_gc_alloc.h, which should make it work with gcc3.1. * Use alpha_mach_dep.S only on Linux. (It's not clear that this is optimal, but it otherwise didn't build on Tru64. Thanks to Fergus Henderson.) * Added ifdef to guard free() in os_dep.c. Otherwise we get a compilation error on Irix (thanks to Dai Sato). * Added an experimental version of GC_memalign to mallocx.c. This can't always work, since we don't handle alignment requests in the hblk-level allocator, and we can't handle arbitrary pointer displacements unless GC_all_interior_pointers is enabled. But it should work for alignment requests up to HBLKSIZE. This is not yet documented in the standard places. * Finally debugged the OSF1/Tru64 thread support. This needs more testing, since I needed to add a somewhat unconvincing workaround for signal delivery issues that I don't yet completely understand. But it does pass my tests, even in parallel GC mode. Incremental GC support is disabled if thread support is enabled, due to the signal issues. * Eliminated name-space-incorrect definition of _cdecl from gc_cpp.h. * Added GC_debug_malloc_replacement and GC_debug_realloc_replacement declarations to gc.h. On IA64, this is required for REDIRECT_MALLOC to work correctly with these. * Fixed Linux USE_PROC_FOR_LIBRARIES to work with a 64-bit /proc format. == [6.1alpha5] 2002-06-19 == * Added GC_finalizer_mem_freed, and changed some of the code that decided on heap expansion to look at it. Memory explicitly deallocated by finalizers essentially needs to be counted as reclaimed by the GC. Otherwise there are cases in which the heap can grow infinitely. (Thanks to Mark Reichert for the test case.) * Integrated Adam Megacz patches to not scan dynamic libraries if we are compiling with gcc on win32. Otherwise we need structured exception handling to deal with asynchronously unmapped root segments, and gcc doesn't directly support that. * Integrated Anthony Green's patch to support Wine. * GC_OPERATOR_NEW_ARRAY was misspelled OPERATOR_NEW_ARRAY in several places, including gc_cpp.cc (thanks to Wink Saville for pointing this out). * Integrated Loren J. Rittle's Alpha FreeBSD patches. These also changed the declarations of symbols like _end on many platforms to that they wouldn't mistakenly be declared as short data symbols (suggested by Richard Henderson). * Integrated changes from the Debian distribution (thanks to Ryan Murray for pointing these out). Fix C++ comments in POWERPC port. Add ARM32 incremental GC support. Get rid of USE_GENERIC_PUSH_REGS for alpha/Linux, this time for real. Use va_copy to get rid of cord printf problems (finally). * Close file descriptor used to count CPUs (thanks to Jeff Sturm for pointing out the omission). * Don't just drop gcj free lists in GC_start_reclaim, since that can eventually cause the marker to see a bogus mark descriptor in the dropped objects. The usual symptom was a very intermittent segmentation fault in the marker. This mattered only if one of the GC_gcj_malloc variants was used (thanks to Michael Smith, Jeff Sturm, Bryce McKinlay and Tom Tromey for helping to track this down). * Fixed Linux and Solaris/64 SPARC configuration (thanks to David Miller, Jeff Sturm, Tom Tromey, and Christian Joensson). * Fixed a typo in strdup definition (thanks to Gerard A Allan). * Changed Makefile.direct to invoke $(CC) to assemble alpha_mach_dep.S. This is needed on Linux. I'm not sure whether it's better or worse on Tru64. * Changed gc_cpp.h once more to declare operator new and friends only in a Microsoft environment. This may need further fine tuning (thanks to Johannes Schmidt for pointing out that the older code breaks on gcc3.0.4). * Don't ever override strdup if it's already macro defined (thanks to Adnan Ali for pointing out the problem). * Changed gc_cpp.h yet again to also overload placement new. Due to the C++ overloading rules, the other overloaded new operations otherwise hide placement new, which causes many STL uses to break (thanks to Reza Shahidi for reporting this, and to Matt Austern for proposing a fix). * Integrated cygwin pthreads support from Dan Bonachea. * Turn on DYNAMIC_LOADING for NetBSD (thanks to Krister Walfridsson). * Changed printing code to print more complete GC times. * Applied Mark Mitchell's Irix patch to correct some bit rot. * Clarified which object-printing routines in dbg_mlc.c should hold the allocation lock. Restructured the code to allow reasonable object printing with -DREDIRECT_MALLOC. * Fix the Linux mmap code to always start with 0x1000 as the initial hint. Minor patches for 64-bit AIX, particularly to STACKBOTTOM (thanks to Jeffrey Mark Siskind). * Renamed "SUSPENDED" flag for Solaris threads support to avoid a conflict with a system header (thanks to Philip Brown). * Cause win32_threads.c to handle an out of range stack pointer correctly, though currently with a warning. (Thanks to Jonathan Clark for observing that win32 applications may temporarily use the stack pointer for other purposes, and suggesting a fix. Unfortunately, it's not clear that there is a complete solution to this problem.) == [6.1alpha4] 2002-06-16 == * Fixed typo in sparc_mach_dep.S, preventing the 64-bit version from building. Increased 64-bit heap size limit in test.c slightly, since a functional SPARC collector seems to slightly exceed the old limits. * Use NPRGREG in solaris_threads.c, thus printing all registers if things go wrong. * Added GC_MARKERS environment variable to allow use of a single marker thread on an MP without confusing the lock implementation. * Collect much less aggressively in incremental mode with GC_TIME_UNLIMITED. This is really a purely generational mode, and we can afford to postpone the collection until the heap is (nearly) full. * Remove read() wrapper for MPROTECT_VDB. It was causing more harm than good. It is often no longer needed if system calls avoid writing to pointerfull heap objects. * Fix MACOSX test in gcconfig.h (thanks to John Clements). * Change GC_test_and_set so that it consistently has one argument. Add spaces to ::: in powerpc assembly code in gc_locks.h (thanks to Ryan Murray). * Fixed a formatting error in dbg_mlc.c. Added prototype to GC_abort() declaration (thanks to Michael Smith). * Removed "source" argument to GC_find_start(). Eliminate GC_FIND_START(). * Added win32 recognition code in configure.in. Changed some of the dllimport/export defines in gc.h (thanks to Adam Megacz). * GC_malloc_many didn't set hb_last_reclaimed when it called GC_reclaim_generic. (I'm not sure this matters much, but ...) * Allocating uncollectible objects with debug information sometimes allocated objects that were one byte too small, since uncollectible objects don't have the extra byte added at the end (thanks to Wink Saville for pointing this out). * Added a bit more assertion checking to make sure that gcj objects on free lists never have a nonzero second word. * Replaced BCC_MAKEFILE with an up-to-date one (thanks to Andre Leiradella). * Upgraded libtool, cinfigure.in and some related files to hopefully support NetBSD/SPARC (thanks to Adrian Bunk). Unfortunately, libtool 1.4.2 seemed to be buggy due to missing quotes in several "test" invocations. Fixed those in the ltmain.sh script. * Some win32-specific patches, including the introduction of GC_CreateThread (thanks to Adam Megacz). * Merged in gcj changes from Anthony Green to support embedded systems. * Tried to consistently rename preprocessed assembly files with a capital .S extension. * Use alpha_mach_dep.S on ALPHA again. It doesn't really matter, but this makes our distribution consistent with the gcc one, avoiding future merge problems. * Move GET_MEM definition into gcconfig.h. Include gcconfig.h slightly later in gc_priv.h to avoid forward references to ptr_t. * Add some testing of local allocation to test.c. * Change definition of INVALID_QTID in specific.h. The -1 value was used inconsistently, and too likely to collide with a valid stack address. Some general clean-up of specific.[ch]. Added assertions. (Thanks to Michael Smith for tracking down an intermittent bug to this general area. I'm not sure it has been squashed yet, however.) * On Pthread systems it was not safe to call GC_malloc() between fork() and exec(). According to the applicable standards, it doesn't appear to be safe to call malloc() or many other libc functions either, thus it's not clear this is fixable. Added experimental support for -DHANDLE_FORK in linux_threads.c which tries to support it. It may succeed if libc does the right thing. I'm not sure whether it does. (Thanks to Kenneth Schalk for pointing out this issue.) * Documented thread local allocation primitives to require an explicit GC_init call. GC_init_parallel is no longer declared to be a constructor function, since that isn't portable and often seems to lead to initialization order problems. * Changed gc_cpp.cc and gc_cpp.h in one more attempt to make them compatible with Visual C++ 6 (thanks to Wink Saville for the patch). * Some more patches for Linux on HP PA-RISC. * Added include/gc_allocator.h. It implements (hopefully) standard conforming (as opposed to SGI-style) allocators that allocate collectible (gc_allocator) or GC-traceable, but not collectible (traceable_allocator) objects. This borrows heavily from libstc++, which borrows heavily from the SGI implementation, this part of which was written by Matt Austern. Changed test_cpp.cc to very minimally test this. * On Linux/X86, retry mmap with a different start argument. That should allow the collector to use more (closer to 3GB) of the address space. * Force 64 bit alignment with GCJ support (reflects Bryce McKinlay's patch to the gcc tree). * Refined the choice of sa_handler vs. sa_sigaction in GC_dirty_init to accommodate some glibc5 systems (thanks to Dan Fandrich for the patch). * Compensated for the fact that current versions of glibc set __libc_stack_end incorrectly on Linux/IA64 while initialization code is running. This could cause the collector to miss 16 bytes of the memory stack if GC_malloc or friends where called before main(). * Mostly integrated Takis Psarogiannakopoulos' port to DG/UX Inix 86. This will probably take another iteration to work, since his patch conflicted with the libtool upgrade. * Added README.arm.cross containing some information about cross- compiling to an ARM processor from Margaret Fleck (original code provided by Bradley D. LaRonde; edited by Andrej Cedilnik using some of solutions by Tilman Vogel; also ported for iPAQ by Oliver Kurth). == [6.1alpha3] 2002-02-07 == * Minor cleanup on the gcconfig.h section for SPARC. * Minor fix to support Intel compiler for I386/Linux (thanks to Sven Hartrumpf). * Added SPARC V9 (64-bit) support (thanks to Jeff Sturm). * Restructured the way in which we determine whether or not to keep call stacks for debug allocation. By default SAVE_CALL_COUNT is now zero on all platforms. Added SAVE_CALL_NARGS parameters. If possible, use execinfo.h to capture call stack. (This should add support for a number of new platforms, though often at considerable runtime expense.) * Try to print symbolic information for call stacks. On Linux, we do this with a combination of execinfo.h and running addr2line in a separate process. This is both much more expensive and much more useful. Amazingly, it seems to be fast enough for most purposes. * Redefined strdup if -DREDIRECT_MALLOC is given. * Changed incremental collector and MPROTECT_VDB implementation so that, under favorable conditions, pointer-free objects are not protected. Added GC_incremental_protection_needs() to determine ahead of time whether pointer-free objects may be protected. Replaced GC_write_hint() with GC_remove_protection(). * Added test for GC_ENABLE_INCREMENTAL environment variable. * Made GC_time_limit runtime configurable. Added GC_PAUSE_TIME_TARGET environment variable. * Eliminated GC_page_sz, a duplicate of GC_page_size. * Caused the Solaris and Irix thread creation primitives to call GC_init_inner(). == [6.1alpha2] 2001-12-20 == * No longer wrap read by default in multi-threaded applications. It was pointed out on the libgcj list that this holds the allocation lock for way too long if the read blocks. For now, reads into the heap are broken with incremental collection. It's possible to turn this back on if you make sure that read calls don't block (e.g. by calling select first). * Fix ifdef in Solaris_threads.h to refer to GC_SOLARIS_THREADS. * Added check for environment variable GC_IGNORE_GCJ_INFO. * Added printing of stop-the-world GC times if GC_PRINT_STATS environment variable is set. * The calloc definition in leak_detector.h was missing parentheses, and realloc was missing a second argument to GC_REALLOC (thanks to Elvenlord Elrond). * Added GC_PRINT_BACK_HEIGHT environment variable and associated code, mostly in the new file backgraph.c. See doc/README.environment. * Added -DUSE_GLOBAL_ALLOC to work around a Windows NT issue (thanks to Jonathan Clark). * Integrated port to NEC EWS4800 (MIPS-based workstation, with somewhat different address-space layout). This may help for other machines with holes in the data segment. (Thanks to Hironori Sakamoto.) * Changed the order in which GC_push_roots and friends push things onto the mark stack. GC_push_all calls need to come first, since we can't necessarily recover if those overflow the mark stack. (Thanks to Matthew Flatt for tracking down the problem.) * Some minor cleanups to mostly support the Intel compiler on Linux/IA64. == [6.1alpha1] 2001-09-22 == * Non-debug, atomic allocations could result in bogus smashed object reports with debugging on (thanks to Patrick Doyle for the small test case). * Fixed GC_get_register_stack_base (Itanium only) to work around a glibc 2.2.4 bug. * Initial port to HP/UX on Itanium. Thread support and both 32 and 64 bit ABIs appear to work. Parallel mark support doesn't yet, due to some inline assembly code issues. Thread local allocation does appear to work. * ifdef'ed out glibc2.1/Itanium workaround. I suspect nobody is using that combination anymore. * Added a patch to make new_gc_alloc.h usable with gcc3.0 (thanks to Dimitris Vyzovitis for the patch). * Debugged 64-bit support on HP/UX PA-RISC. * Turned on dynamic loading support for FreeBSD/ELF (thanks to Peter Housel). * Unregistering of finalizers with debugging allocation was broken (thanks to Jani Kajala for the test case). * Old finalizers were not returned correctly from GC_debug_register_finalizer. * Disabled MPROTECT_VDB for Linux/M68K based on a report that it doesn't work. * Cleaned up some statistics gathering code in reclaim.c (thanks to Walter Bright). * Added some support for OpenBSD/ELF/Linux (thanks to Suzuki Toshiya). * Added Jakub Jelinek's patch to use dl_iterate_phdr for dynamic library traversal to dyn_load.c. Changed it to weakly reference dl_iterate_phdr, so that the old code is still used with old versions of glibc. * Cleaned up feature test macros for various threads packages and integrated (partially functional) FreeBSD threads code from Loren J. Rittle. It's likely that the cleanup broke something, since it touched lots of code. It's also likely that it fixed some unreported bugs in the less common thread implementations, since some of the original code didn't stand up to close scrutiny. Support for the next pthreads implementation should be easier to add. == [6.0] 2001-07-26 == * Two more bug fixes for KEEP_BACK_PTRS and DBG_HDRS_ALL. * Fixed a stack clearing problem that resulted in SIGILL with a misaligned stack pointer for multi-threaded SPARC builds. * Integrated another HURD patch (thanks to Igor Khavkine). == [6.0alpha9] == * added README.macros. * Made gc.mak a symbolic link to work around winzip's tendency to ignore hard links. * Simplified the setting of NEED_FIND_LIMIT in os_dep.c, possibly breaking it on untested platforms. * Integrated initial GNU HURD port (thanks to Chris Lingard and Igor Khavkine). * A few more fixes for Digital Mars compiler (by Walter Bright). * Fixed gcc version recognition. Renamed OPERATOR_NEW_ARRAY to GC_OPERATOR_NEW_ARRAY. Changed GC_OPERATOR_NEW_ARRAY to be the default. It can be overridden with -DGC_NO_OPERATOR_NEW_ARRAY (thanks to Cesar Eduardo Barros). * Changed the byte size to free-list mapping in thread local allocation so that size 0 allocations are handled correctly. * Fixed Linux/MIPS stackbottom for new toolchain (thanks to Ryan Murray). * Changed finalization registration to invoke GC_oom_fn when it runs out of memory. * Removed lvalue cast in finalize.c. This caused some debug configurations not to build with some non-gcc compilers. == [6.0alpha8] 2001-06-15 == * Changed GC_debug_malloc_replacement and GC_debug_realloc_replacement so that they compile under Irix (thanks to Dave Love). * Updated powerpc_macosx_mach_dep.s so that it works if the collector is in a dynamic library (thanks to Andrew Begel). * Transformed README.debugging into debugging.html, updating and expanding it in the process. Added gcdescr.html and tree.html from the web site to the GC distribution. * Fixed several problems related to PRINT_BLACK_LIST. This involved restructuring some of the marker macros. * Fixed some problems with the sizing of objects with debug information. Finalization was broken KEEP_BACK_PTRS or PRINT_BLACK_LIST. Reduced the object size with SHORT_DEBUG_HDRS by another word. * The "Needed to allocate blacklisted ..." warning had inadvertently been turned off by default, due to a buggy test in allchblk.c. Turned it back on. * Removed the marker macros to deal with 2 pointers in interleaved fashion. They were messy and the performance improvement seemed minimal. We'll leave such scheduling issues to the compiler. * Changed Linux/PowerPC test to also check for __powerpc__ in response to a discussion on the gcc mailing list. * Removed the "static" from the jmp_buf declaration in GC_generic_push_regs (suggested by Matthew Flatt). This was causing problems in systems that register all of their own roots. It looks far more correct to me without the "static" anyway. * Fixed several problems with thread local allocation of pointer-free or typed objects. The collector was reclaiming thread-local free lists, since it wasn't following the link fields. * There was apparently a long-standing race condition related to multi-threaded incremental collection. A collection could be started and a thread stopped between the memory unprotect system call and the setting of the corresponding dirt bit. I believe this did not affect Solaris or PCR, which use a different dirty-bit implementation. Fixed this by installing signal handlers with sigaction instead of signal, and disabling the thread suspend signal while in the write-protect handler. (It is unclear whether this scenario ever actually occurred.) * Incremental collection did not cooperate correctly with the PARALLEL_MARK implementation of GC_malloc_many or the local_malloc primitives. It still doesn't work well, but it shouldn't lose memory anymore. * Integrated some changes from the gcc source tree that I had previously missed (thanks to Bryce McKinlay for the reminder and patch). * Added Makefile.direct as a copy of the default Makefile, which would normally be overwritten if configure is run. * Changed the gc.tar target in Makefile.direct to embed the version number in the gc directory name. This will affect future tar file distributions. * Changed the Irix dynamic library finding code to no longer try to eliminate writable text segments under Irix6.x, since that is probably no longer necessary, and can apparently be unsafe on occasion (thanks to Shiro Kawai for pointing this out). * GC_cleanup with GC_DEBUG enabled passed a real object base address to GC_debug_register_finalizer_ignore_self, which expected a pointer past the debug header. Call GC_register_finalizer_ignore_self instead, even with debugging enabled (thanks to Jean-Daniel Fekete for catching this). * The collector didn't build with call chain saving enabled but NARGS=0. * Fixed up the GNU-style build files enough so that they work in some obvious cases (thanks to Maarten Thibaut). * Added initial port to Digital Mars compiler for win32 (thanks to Walter Bright). == [6.0alpha7] 2001-04-19 == * Added GC_finalizer_notifier. Fixed GC_finalize_on_demand. (The variable actually wasn't being tested at the right points. The build-time flag was.) * Added Tom Tromey's S390 Linux patch. * Added code to push GC_finalize_now in GC_push_finalizer_structures (thanks to Matthew Flatt). * Added GC_push_gc_structures() to push all GC internal roots. * Integrated some FreeBSD changes from Matthew Flatt. * It looks like USRSTACK is not always correctly defined under Solaris. Hacked gcconfig.h to attempt to work around the problem. The result is not well tested. (Thanks again to Matthew Flatt for pointing this out.) * Added Ji-Yong Chung's win32 threads and C++ fixes. * Arranged for hpux_test_and_clear.s to no longer be needed or built. It was causing build problems with gas, and it's not clear this is better than the pthreads alternative on this platform. * Some MINGW32 fixes from Hubert Garavel. * Added initial Hitachi SH4 port from Kaz Kojima. * Ported thread-local allocation and parallel mark code to HP/UX on PA_RISC. * Made include/gc_mark.h more public and separated out the really private pieces. This is probably still not quite sufficient for clients that want to supply their own kind of type information. But it's a start. This involved lots of identifier renaming to make it namespace clean. * Added GC_dont_precollect for clients that need complete control over the root set. * GC_is_visible didn't do the right thing with gcj objects. (Not that many people are likely to care, but ...) * Don't redefine read with GC_USE_LD_WRAP. * Initial port to LINUX/HP_PA. Incremental collection and threads are not yet supported. (Incremental collection should work if you have the right kernel. Threads may work with a sufficiently patched pthread library.) * Changed gcconfig.h to recognize __i386__ as an alternative to i386 in many places (thanks to Benjamin Lerman). * Made win32_threads.c more tolerant of detaching a thread that it didn't know about (thanks to Paul Nash). * Added Makefile.am and configure.in from gcc to the distribution, with minimal changes. For the moment, those are just placeholders. In the future, we're planning to switch to a GNU-style build environment for Un*x-like systems, though the old Makefile will remain as a backup. * Turned off STUBBORN_ALLOC by default, and added it back as a Makefile option. * Redistributed some functions between malloc.c and mallocx.c, so that simple statically linked apps no longer pull in mallocx.o. * Changed large object allocation to clear the first and last few words of each block before releasing the lock. Otherwise the marker could see objects with nonsensical type descriptors. * Fixed a couple of subtle problems that could result in not recognizing interior pointers from the stack. (I believe these were introduced in 6.0alpha6.) * GC_debug_free_inner called GC_free, which tried to reacquire the allocator lock, and hence deadlocked. (DBG_HDRS_ALL probably never worked with threads.) * Fixed several problems with back traces. Accidental references to a free list could cause the free list pointer to be overwritten by a back pointer. There seemed to be some problems with the encoding of root and finalizer references. == [6.0alpha6] == * Changed the definition of DATASTART on ALPHA and IA64, where data_start and __data_start are not defined by earlier versions of glibc. This might need to be fixed on other platforms as well. * Changed the way the stack base and backing store base are found on IA64. This should now remain reliable on future kernels. But since it relies on /proc, it will no longer work in the simulated NUE environment. * Made the call to random() in dbg_mlc.c with -DKEEP_BACK_PTRS dependent on the OS. On non-Unix systems, rand() should be used instead. Handled small RAND_MAX (thanks to Peter Ross for pointing this out). * Fixed the cord make rules to create the cord subdirectory, if necessary (thanks to Doug Moen). * Changed fo_object_size calculation in finalize.c. Turned finalization of non-heap object into a no-op. Removed anachronism from GC_size() implementation. * Changed GC_push_dirty call in solaris_threads.c to GC_push_selected. It was missed in a previous renaming (thanks to Vladimir Tsichevski for pointing this out). * Arranged to not mask SIGABRT in linux_threads.c (thanks to Bryce McKinlay). * Added GC_no_dls hook for applications that want to register their own roots. * Integrated Kjetil Matheussen's Amiga changes. * Added FREEBSD_STACKBOTTOM. Changed the X86/FreeBSD port to use it (thanks to Matthew Flatt). * Added pthread_detach interception for platforms supported by linux_threads.c and irix_threads.c. * Changed the USE_MMAP code to check for the case in which we got the high end of the address space, i.e. mem_ptr + mem_sz == 0. It appears that this can happen under Solaris 7. It seems to be allowed by what I would claim is an oversight in the mmap specification. (Thanks to Toshio Endo for pointing out the problem.) * Cleanup of linux_threads.c. Some code was originally cloned from irix_threads.c and now unnecessary. Some comments were obviously wrong. * (Mostly) fixed a longstanding problem with setting of dirty bits from a signal handler. In the presence of threads, dirty bits could get lost, since the etting of a bit in the bit vector was not atomic with respect to other updates. The fix is 100% correct only for platforms for which GC_test_and_set is defined. The goal is to make that all platforms with thread support. Matters only if incremental GC and threads are both enabled. * made GC_all_interior_pointers (a.k.a. ALL_INTERIOR_POINTERS) an initialization time, instead of build-time option. This is a nontrivial, high risk change. It should slow down the code measurably only if MERGE_SIZES is not defined, which is a very nonstandard configuration. * Added doc/README.environment, and implemented what it describes. This allows a number of additional configuration options to be set through the environment. It documents a few previously undocumented options. * Integrated Eric Benson's leak testing improvements. * Removed the option to throw away the beginning of each page (DISCARD_WORDS). This became less and less useful as processors enforce stricter alignment. And it hadn't been tested in ages, and was thus probably broken anyway. == [6.0alpha5] == * Changed the definition of GC_pause in linux_threads.c to use a volatile asm. Some versions of gcc apparently optimize away writes to local volatile variables. This caused poor locking behavior starting at about 4 processors. * Added GC_start_blocking(), GC_end_blocking() calls and wrapper for sleep to linux_threads.c. The first two calls could be used to generally avoid sending GC signals to blocked threads, avoiding both premature wakeups and unnecessary overhead. * Fixed a serious bug in thread-local allocation. At thread termination, GC_free could get called on small integers. Changed the code for thread termination to more efficiently return left-over free-lists. * Integrated Kjetil Matheussen's BeOS support. * Rearranged the directory structure to create the doc and tests subdirectories. * Sort of integrated Eric Benson's patch for OSF1. This provided basic OSF1 thread support by suitably extending hpux_irix_threads.c. Based on earlier email conversations with David Butenhof, I suspect that it will be more reliable in the long run to base this on linux_threads.c instead. Thus I attempted to patch up linux_threads.c based on Eric's code. The result is almost certainly broken, but hopefully close enough that someone with access to a machine can pick it up. * Integrated lots of minor changes from the NetBSD distribution. (These were supplied by David Brownlee. I'm not sure about the original authors.) * Hacked a bit more on the HP/UX thread-support in linux_threads.c. It now appears to work in the absence of incremental collection. Renamed hpux_irix_threads.c back to irix_threads.c, and removed the attempt to support HPUX there. * Changed gc.h to define _REENTRANT in cases in which it should already have been defined. It is still safer to also define it on the command line. == [6.0alpha4] == * Moved up the detection of mostly full blocks to the initiation of the sweep phase. This eliminates some lock contention in the PARALLEL_MARK case, as multiple threads try to look at mostly full blocks concurrently. * Restored the code in GC_malloc_many that grabs a prefix of the global free list. This avoids the case in which every GC_malloc_many call tries and fails to allocate a new heap block, and the returns a single object from the global free list. * Some minor fixes in new_hblk.c. (Attempted to build free lists in order of increasing addresses instead of decreasing addresses for cache performance reasons. But this seems to be only a very minor gain with -DEAGER_SWEEP, and a loss in other cases. So the change was backed out.) * Fixed some of the documentation (thanks in large part to Fergus Henderson). * Fixed the Linux USE_PROC_FOR_LIBRARIES code to deal with apps that perform large numbers of mmaps (thanks to Eric Benson). Also fixed that code to deal with short reads. * Added GC_get_total_bytes(). * Fixed leak detection mode to avoid spurious messages under linuxthreads. (This should also now be easy for the other supported threads packages. But the code is tricky enough that I'm hesitant to do it without being able to test. Everything allocated in the GC thread support itself should be explicitly deallocated.) * Made it possible (with luck) to redirect malloc to GC_local_malloc. == [6.0alpha3] 2000-09-26 == * Fixed the /proc/self/maps code to not seek, since that apparently is not reliable across all interesting kernels. * Fixed some compilation problems in the absence of PARALLEL_MARK (introduced in alpha2). * Fixed an algorithmic problem with PARALLEL_MARK. If work needs to be given back to the main mark "stack", the BOTTOM entries of the local stack should be given away, not the top ones. This has substantial performance impact, especially for > 2 processors, from what I can tell. * Extracted gc_lock.h from gc_priv.h. This should eventually make it a bit easier to avoid including gc_priv.h in clients. * Moved all include files to include/ and removed duplicate links to the same file. The old scheme was a bad idea because it was too easy to get the copies out of sync, and many systems don't support hard links. Unfortunately, it's likely that I broke some of the non-Unix Makefiles in the process, although I tried to update them appropriately. * Removed the partial support for a copied nursery. It's not clear that this would be a tremendous win, since we don't consistently lose to generational copying collectors. And it would significantly complicate many things. May be reintroduced if/when it really turns out to win. * Removed references to IRIX_JDK_THREADS, since I believe there never were and never will be any clients. * Added some code to linux_threads.c to possibly support HPUX threads using the Linux code. Unfortunately, it doesn't work yet, and is currently disabled. * Added support under Linux/X86 for saving the call chain, both in (debug) objects for client debugging, and in GC_arrays._last_stack for GC debugging. This was previously supported only under Solaris. It is not enabled by default under X86, since it requires that code be compiled to explicitly gave frame pointers on the call stack. (With gcc this currently happens by default, but is often turned off explicitly.) To turn it on, define SAVE_CALL_CHAIN. == [6.0alpha2] == * Added USE_MARK_BYTES to reduce the need for compare-and-swap on platforms for which that's expensive. * Fixed a locking bug ib GC_gcj_malloc and some locking assertion problems. * Added a missing volatile to OR_WORD and renamed the parameter to GC_compare_and_swap so it's not a C++ reserved word (thanks to Toshio Endo for pointing out both of those). * Changed Linux dynamic library registration code to look at /proc/self/maps instead of the rld data structures when REDIRECT_MALLOC is defined. Otherwise some of the rld data data structures may be prematurely garbage collected. * Fixed USE_LD_WRAP a bit more, so it should now work without threads. * Renamed XXX_THREADS macros to GC_XXX_THREADS for namespace correctness. Temporarily added some backward compatibility definitions. Renamed USE_LD_WRAP to GC_USE_LD_WRAP. * Many MACOSX POWERPC changes, some additions to the gctest output, and a few minor generic bug fixes (thanks to Dietmar Planitzer). == [6.0alpha1] == * Added HP/PA prefetch support. * Added -DDBG_HDRS_ALL and -DSHORT_DBG_HDRS to reduce the cost and improve the reliability of generating pointer backtrace information, e.g. in the Bigloo environment. * Added parallel marking support (-DPARALLEL_MARK). This currently works only under IA32 and IA64 Linux, but it shouldn't be hard to adapt to other platforms. This is intended to be a lighter-weight (less new code, probably not as scalable) solution than the work by Toshio Endo et al, at the University of Tokyo. A number of their ideas were reused, though the code wasn't, and the underlying data structure is significantly different. In particular, we keep the global mark stack as a single shared data structure, but most of the work is done on smaller thread-local mark stacks. * Changed GC_malloc_many to be cheaper, and to require less mutual exclusion with -DPARALLEL_MARK. * Added full support for thread local allocation under Linux (-DTHREAD_LOCAL_ALLOC). This is a thin veneer on GC_malloc_many, and should be easily portable to other platforms, especially those that support pthreads. * CLEAR_DOUBLE was not always getting invoked when it should have been. * GC_gcj_malloc and friends used different out of memory handling than everything else, probably because I forgot about one when I implemented the other. They now both call GC_oom_fn(), not GC_oom_action(). * Integrated Jakub Jelinek's fixes for Linux/SPARC. * Moved GC_objfreelist, GC_aobjfreelist, and GC_words_allocd out of GC_arrays, and separately registered the first two as excluded roots. This makes code compiled with gc_inl.h less dependent on the collector version. (It would be nice to remove the inclusion of gc_priv.h by gc_inl.h completely, but we're not there yet. The locking definitions in gc_priv.h are still referenced.) This change was later conditioned on SEPARATE_GLOBALS, which is not defined by default, since it involves a performance hit. * Register GC_obj_kinds separately as an excluded root region. The attempt to register it with GC_arrays was usually failing. (This wasn't serious, but seemed to generate some confusion.) * Moved backptr.h to gc_backptr.h. == [5.4] == * Fixed a typo that prevented compilation with -DUSE_3DNOW_PREFETCH (thanks to Shawn Wagner for actually testing this). * Fixed GC_is_thread_stack in solaris_threads.c. It forgot to return a value in the common case. * Fixed another silly syntax problem in GC_double_descr (thanks to Fergus Henderson for finding it). * Fixed a GC_gcj_malloc bug: It tended to release the allocator lock twice. == [5.3] 2000-09-24 == * Fixed _end declaration for OSF1. * There were lots of spurious leak reports in leak detection mode, caused by the fact that some pages were not being swept, and hence unmarked objects weren't making it onto free lists. (This bug dated back to 5.0.) * Fixed a typo in the liblinuxgc.so Makefile rule. * Added the GetExitCodeThread to Win32 GC_stop_world to (mostly) work around a Windows 95 GetOpenFileName problem (thanks to Jacob Navia). == [5.2] == * dyn_load.c declared GC_scratch_last_end_ptr as an extern even if it was defined as a macro. This prevented the collector from building on Irix. * We quietly assumed that indirect mark descriptors were never 0. Our own typed allocation interface violated that. This could result in segmentation faults in the marker with typed allocation. * Fixed a _DUSE_MUNMAP bug in the heap block allocation code (thanks to Ben Hutchings for the patch). * Taught the collector about VC++ handling array operator new (thanks to Ben Hutchings for the patch). * The two copies of gc_hdrs.h had diverged. Made one a link to the other again. == [5.1] == * Fixed a gc.h header bug which showed up under Irix (thanks to Dan Sullivan). * Fixed a typo in GC_double_descr in typd_mlc.c. This probably could result in objects described by array descriptors not getting traced correctly (thanks to Ben Hutchings for pointing this out). * The block nearly full tests in reclaim.c were not correct for 64 bit environments. This could result in unnecessary heap growth under unlikely conditions. == [5.0] == * Fixed threadlibs.c for linux threads. -DUSE_LD_WRAP was broken and -ldl was omitted. Fixed Linux stack finding code to handle -DUSE_LD_WRAP correctly. * Added MSWIN32 exception handler around marker, so that the collector can recover from root segments that are unmapped during the collection. This caused occasional failures under Windows 98, and may also be an issue under Windows NT/2000. == [5.0alpha7] == * -DREDIRECT_MALLOC was broken in alpha6. Fixed. * Cleaned up gc_ccp.h slightly, thus also causing the HP C++ compiler to accept it. * Removed accidental reference to dbg_mlc.c, which caused dbg_mlc.o to be linked into every executable. * Added PREFETCH to bitmap marker. Changed it to use the header cache. * GC_push_marked sometimes pushed one object too many, resulting in a segmentation fault in GC_mark_from_mark_stack. This was probably an old bug. It finally showed up in gctest on win32. * Gc_priv.h erroneously #defined GC_incremental to be TRUE instead of FALSE when SMALL_CONFIG was defined. This was no doubt a major performance bug for the default win32 configuration. * Removed -DSMALL_CONFIG from NT_MAKEFILE. It seemed like an anachronism now that the average PC has 64MB or so. * Integrated Bryce McKinlay's patches for linux threads and dynamic loading from the libgcj tree. Turned on dynamic loading support for Linux/PPC. * Changed the stack finding code to use environ on HP/UX (thanks to Gustavo Rodriguez-Rivera for the suggestion). This should probably be done on other platforms, too. Since I can't test those, that'll wait until after 5.0. == [5.0alpha6] == * GC_malloc_explicitly_typed and friends sometimes failed to initialize first word. * Added allocation routines and support in the marker for mark descriptors in a type structure referenced by the first word of an object. This was introduced to support gcj, but hopefully in a way that makes it generically useful. * Added GC_requested_heapsize, and inhibited collections in non-incremental mode if the actual used heap size is less than what was explicitly requested. * The Solaris pthreads version of GC_pthread_create didn't handle a NULL attribute pointer. Solaris thread support used the wrong default thread stack size (thanks to Melissa O'Neill for the patch). * Changed PUSH_CONTENTS macro to no longer modify first parameter. This usually doesn't matter, but it was certainly an accident waiting to happen ... * Added GC_register_finalizer_no_order and friends to gc.h. They're needed by Java implementations. * Integrated a fix for a win32 deadlock resulting from clock() calling malloc (thanks to Chris Dodd). * Integrated Hiroshi Kawashima's port to Linux/MIPS. This was designed for a handheld platform, and may or may not be sufficient for other machines. * Fixed a va_arg problem with the %c specifier in cordprnt.c. It appears that this was always broken, but recent versions of gcc are the first to report the (statically detectable) bug. * Added an attempt at a more general solution to dlopen races/deadlocks. GC_dlopen now temporarily disables collection. Still not ideal, but ... * Added -DUSE_I686_PREFETCH, -DUSE_3DNOW_PREFETCH, and support for IA64 prefetch instructions. May improve performance measurably, but I'm not sure the code will run correctly on processors that don't support the instruction. Won't build except with very recent gcc. * Added caching for header lookups in the marker. This seems to result in a barely measurable performance gain. Added support for interleaved lookups of two pointers, but unconfigured that since the performance gain is currently near zero, and it adds to code size. * Changed Linux DATA_START definition to check both data_start and __data_start, since nothing else seems to be portable. * Added -DUSE_LD_WRAP to optionally take advantage of the GNU ld function wrapping mechanism. Probably currently useful only on Linux. * Moved some variables for the scratch allocator into GC_arrays (suggested by Martin Hirzel). * Fixed a win32 threads bug that caused the collector to not look for interior pointers from one of the thread stacks without ALL_INTERIOR_POINTERS (thanks to Jeff Sturm). * Added Mingw32 support (thanks to Jeff Sturm for the patch). * Changed the alpha port to use the generic register scanning code instead of alpha_mach_dep.s. Alpha_mach_dep.s doesn't look for pointers in fp registers, but gcc sometimes spills pointers there (thanks to Manuel Serrano for helping debug this). Changed the IA64 code to do something similar for similar reasons. == [5.0alpha4] 1999-10-30 == * Added protection fault handling patch for Linux/M68K from Fergus Henderson and Roman Hodek. * Removed the tests for SGI_SOURCE in new_gc_alloc.h. This was causing that interface to fail on non-SGI platforms. * Changed the Linux stack finding code to use /proc, after changing it to use HEURISTIC1 (thanks to David Mossberger for pointing out /proc hook). * Added HP/UX incremental GC support and HP/UX 11 thread support. Thread support is currently still flaky. * Added basic Linux/IA64 support. * Integrated Anthony Green's PicoJava support. * Integrated Scott Ananian's StrongARM/NetBSD support. * Fixed some fairly serious performance bugs in the incremental collector. These have probably been there essentially forever. (Mark bits were sometimes set before scanning dirty pages. The reclaim phase unnecessarily dirtied full small object pages.) * Changed the reclaim phase to ignore nearly full pages to avoid touching them. * Limited GC_black_list_spacing to roughly the heap growth increment. * Changed full collection triggering heuristic to decrease full GC frequency by default, but to explicitly trigger full GCs during heap growth. This doesn't always improve things, but on average it's probably a win. * GC_debug_free(0, ...) failed (thanks to Fergus Henderson for the bug report and fix). == [5.0alpha3] 1999-09-15 == (Also known as 4.15alpha3.) * Added some highly incomplete code to support a copied young generation. Comments on nursery.h are appreciated. * Changed -DFIND_LEAK, -DJAVA_FINALIZATION, and -DFINALIZE_ON_DEMAND, so the same effect could be obtained with a runtime switch. This is a step towards standardizing on a single dynamic GC library. * Significantly changed the way leak detection is handled, as a consequence of the above. == [5.0alpha2] 1999-07-23 == * Fixed bugs introduced in alpha1 (OpenBSD & large block initialization). * Added -DKEEP_BACK_PTRS and backptr.h interface. (The implementation idea came from Alan Demers.) == [5.0alpha1] 1999-06-30 == (Also known as 4.15alpha1.) * Reworked large block allocator. Now uses multiple doubly linked free lists to approximate best fit. * Changed heap expansion heuristic. Entirely free blocks are no longer counted towards the heap size. This seems to have a major impact on heap size stability; the old version could expand the heap way too much in the presence of large block fragmentation. * added -DGC_ASSERTIONS and some simple assertions inside the collector. This is mainlyt for collector debugging. * added -DUSE_MUNMAP to allow the heap to shrink. Supported on only a few UNIX-like platforms for now. * added GC_dump_regions() for debugging of fragmentation issues. * Changed PowerPC pointer alignment under Linux to 4. * Changed the Linux/Alpha port to walk the data segment backwards until it encounters a SIGSEGV. The old way to find the start of the data segment broke with a recent release. * cordxtra.c needed to call GC_REGISTER_FINALIZER instead of GC_register_finalizer, so that it would continue to work with GC_DEBUG. * allochblk sometimes cleared the wrong block for debugging purposes when it dropped blacklisted blocks. This could result in spurious error reports with GC_DEBUG. * added MACOS X Server support (thanks to Andrew Stone). * Changed the Solaris threads code to ignore stack limits > 8 MB with a warning. Empirically, it is not safe to access arbitrary pages in such large stacks. And the dirty bit implementation does not guarantee that none of them will be accessed. * Integrated Martin Tauchmann's Amiga changes. * Integrated James Dominy's OpenBSD/SPARC port. == [4.14] 1999-04-16 == * changed STACKBOTTOM for DJGPP (thanks to Salvador Eduardo Tropea). == [4.14alpha2] 1999-03-26 == * -DSMALL_CONFIG did not work reliably with large (> 4K) pages. Recycling the mark stack during expansion could result in a size zero heap segment, which confused things. (This was probably also an issue with the normal config and huge pages.) * Did more work to make sure that callee-save registers were scanned completely, even with the setjmp-based code. Added USE_GENERIC_PUSH_REGS macro to facilitate testing on machines I have access to. * Added code to explicitly push register contents for win32 threads. This seems to be necessary. (Thanks to Pierre de Rop.) == [4.14alpha1] 1999-03-10 == * Fixed GC_print_source_ptr to not use a prototype. * generalized CYGWIN test. * gc::new did the wrong thing with PointerFreeGC placement (thanks to Rauli Ruohonen). * In the ALL_INTERIOR_POINTERS (default) case, some callee-save register values could fail to be scanned if the register was saved and reused in a GC frame. This showed up in verbose mode with gctest compiled with an unreleased SGI compiler. I vaguely recall an old bug report that may have been related. The bug was probably quite old. (The problem was that the stack scanning could be deferred until after the relevant frame was overwritten, and the new save location might be outside the scanned area. Fixed by more eager stack scanning.) * PRINT_BLACK_LIST had some problems. A few source addresses were garbage. * Replaced Makefile.dj and added -I flags to cord make targets (thanks to Gary Leavens). * GC_try_to_collect was broken with the non-incremental collector. * gc_cleanup destructors could pass the wrong address to GC_register_finalizer_ignore_self in the presence of multiple inheritance (thanks to Darrell Schiebel). * Changed PowerPC Linux stack finding code. == [4.13] 1999-02-19 == * Fixed a crucial bug in the Watcom port. There was a redundant declaration of GC_push_one in gc_priv.h. * Added FINALIZE_ON_DEMAND. * Fixed some pre-ANSI cc problems in test.c. * Removed getpagesize() use for Solaris. It seems to be missing in one or two versions. * Fixed bool handling for SPARCCompiler version 4.2. * Fixed some files in include that had gotten unlinked from the main copy. * Some RS/6000 fixes (missing casts). (Thanks to Toralf Foerster.) * Fixed several problems in GC_debug_realloc, affecting mostly the FIND_LEAK case. * GC_exclude_static_roots contained a buggy unsigned comparison to terminate a loop (thanks to Wilson Ho). * CORD_str failed if the substring occurred at the last possible position. (Only affects cord users.) * Fixed Linux code to deal with RedHat 5.0 and integrated Peter Bigot's os_dep.c code for dealing with various Linux versions. * Added workaround for Irix pthreads sigaction bug and possible signal misdirection problems. == [4.13alpha3] 1998-12-08 == * Fixed MSWIN32 recognition test, which interfered with cygwin. * Removed unnecessary gc_watcom.asm from distribution. Removed some obsolete README.win32 text. * Added Alpha Linux incremental GC support (thanks to Philipp Tomsich for code for retrieving the fault address in a signal handler). Changed Linux signal handler context argument to be a pointer. * Took care of some new warnings generated by the 7.3 SGI compiler. * Integrated Phillip Musumeci's FreeBSD/ELF fixes. * -DIRIX_THREADS was broken with the -o32 ABI (typo in gc_priv.h). == [4.13alpha2] 1998-08-08 == * Fixed more Linux threads problems. * Changed default GC_free_space_divisor to 3 with new large block allocation (thanks to Matthew Flatt for some measurements that suggest the old value sometimes favors space too much over time). * More CYGWIN32 fixes. * Integrated Tyson Dowd's Linux-M68K port. * Minor HP PA and DEC UNIX fixes from Fergus Henderson. * Integrated Christoffe Raffali's Linux-SPARC changes. * Allowed for one more GC fixup iteration after a full GC in incremental mode. Some quick measurements suggested that this significantly reduces pause times even with smaller GC_RATE values. * Moved some more GC data structures into GC_arrays. This decreases pause times and GC overhead, but makes debugging slightly less convenient. * Fixed namespace pollution problem ("excl_table"). * Made GC_incremental a constant for -DSMALL_CONFIG, hopefully shrinking that slightly. * Added some win32 threads fixes. * Integrated Ivan Demakov and David Stes' Watcom fixes. * Various other minor fixes contributed by many people. * Renamed config.h to gcconfig.h, since config.h tends to be used for many other things. * Integrated Matthew Flatt's support for 68K MacOS "far globals". * Fixed up some of the dynamic library Makefile targets for consistency across platforms. * Fixed a USE_MMAP typo that caused out-of-memory handling to fail on Solaris. * Added code to test.c to test thread creation a bit more. * Integrated GC_win32_free_heap (as suggested by Ivan Demakov). * Fixed Solaris 2.7 stack base finding problem. (This may actually have been done in an earlier alpha release.) == [4.13alpha1] 1998-02-17 == * Changed RS6000 STACKBOTTOM. * Integrated Patrick Beard's Mac changes. * Alpha1 didn't compile on Irix m.n, m < 6. * Replaced Makefile.dj with a new one from Gary Leavens. * Added Andrew Stitcher's changes to support SCO OpenServer. * Added PRINT_BLACK_LIST, to allow debugging of high densities of false pointers. * Added code to debug allocator to keep track of return address in GC_malloc caller, thus giving a bit more context. * Changed default behavior of large block allocator to more aggressively avoid fragmentation. This is likely to slow down the collector when it succeeds at reducing space cost. * Integrated Fergus Henderson's CYGWIN32 changes. They are untested, but needed for newer versions. * USE_MMAP had some serious bugs. This caused the collector to fail consistently on Solaris with -DSMALL_CONFIG. * Added Linux threads support (thanks to Fergus Henderson). == [4.12] 1997-08-26 == * Fixed ElfW definition in dyn_load.c. This prevented the dynamic library support from compiling on some older ELF Linux systems. * Fixed UTS4 port (which I apparently mangled during the integration). (Thanks to Alistair Crooks.) * "Make C++" failed on Suns with SC4.0, due to a problem with "bool". Fixed in gc_priv.h. * Added more pieces for GNU win32 (thanks to Timothy N. Newsham). The current state of things should suffice for at least some applications. * Changed the out of memory retry count handling. (This matters only if GC_max_retries > 0, which is no longer the default.) * If a /proc read failed repeatedly, GC_written_pages was not updated correctly (thanks to Peter Chubb for diagnosing this). * Under unlikely circumstances, the allocator could infinite loop in an out of memory situation (thanks to Kenjiro Taura for identifying the problem and supplying a fix). * Fixed a syntactic error in the DJGPP code. Also fixed a test program problem with DJGPP (thanks to Fergus Henderson and Peter Monks). * Atomic uncollectible objects were not treated correctly by the incremental collector. This resulted in weird log statistics and occasional performance problems (thanks to Peter Chubb for pointing this out). * Fixed some problems resulting from compilers that don't define __STDC__. In this case void * and char * were used inconsistently in some cases. (Void * should not have been used at all. If you have an ANSI superset compiler that does not define __STDC__, please compile with -D__STDC__=0. Thanks to Manuel Serrano and others for pointing out the problem.) * Fixed a compilation problem on Irix with -n32 and -DIRIX_THREADS. Also fixed some other IRIX_THREADS problems which may or may not have had observable symptoms. * Fixed an HP PA compilation problem in dyn_load.c (thanks to Philippe Queinnec). * SEGV fault handlers sometimes did not get reset correctly (thanks to David Pickens). * Added a fix for SOLARIS_THREADS on Intel (thanks to David Pickens). This probably needs more work to become functional. * Fixed struct sigcontext_struct in os_dep.c for compilation under Linux 2.1.X (thanks to Fergus Henderson). * Changed the DJGPP STACKBOTTOM and DATASTART values to those ones suggested (by Kristian Kristensen). These may still not be right, but it is it is likely to work more often than what was there before. They may even be exactly right. * Added a #include to test_cpp.cc. This appears to help with HP/UX and gcc (thanks to Assar Westerlund). * Version 4.11 failed to run in incremental mode on recent 64-bit Irix kernels. This was a problem related to page unaligned heap segments. Changed the code to page align heap sections on all platforms. (I had mistakenly identified this as a kernel problem earlier. It was not.) * Version 4.11 did not make allocated storage executable, except on one or two platforms, due to a bug in a #if test (thanks to David Grove for pointing this out). * Added sparc_sunos4_mach_dep.s to support Sun's compilers under SunOS4. * Added GC_exclude_static_roots. * Fixed the object size mapping algorithm. This shouldn't matter, but the old code was ugly. * Heap checking code could die if one of the allocated objects was larger than its base address. (Unsigned underflow problem. Thanks to Clay Spence for isolating the problem.) * Added RS6000 (AIX) dynamic library support and fixed STACK_BOTTOM (thanks to Fred Stearns). * Added Fergus Henderson's patches for improved robustness with large heaps and lots of blacklisting. * Added Peter Chubb's changes to support Solaris Pthreads, to support MMAP allocation in Solaris, to allow Solaris to find dynamic libraries through /proc, to add malloc_typed_ignore_off_page, and a few other minor features and bug fixes. * The Solaris 2 port should not use sbrk. I received confirmation from Sun that the use of sbrk and malloc in the same program is not supported. The collector now defines USE_MMAP by default on Solaris. * Replaced the djgpp makefile with Gary Leavens' version. * Fixed MSWIN32 detection test. * Added Fergus Henderson's patches to allow putting the collector into a DLL under GNU win32. * Added Ivan V. Demakov's port to Watcom C on X86. * Added Ian Piumarta's Linux/PowerPC port. * Added PointerFreeGC to the placement options in gc_cpp.h (suggested by Brian Burton). This is of course unsafe, and may be controversial. On the other hand, it seems to be needed often enough that it's worth adding as a standard facility. * Add Lars Farm's suggestions on building the collector for MacOS. == [4.12alpha2] == (Changes not specified.) == [4.11] 1996-12-03 == * Rationalized (hopefully) GC_try_to_collect in an incremental collection environment. It appeared to not handle a call while a collection was in progress, and was otherwise too conservative. * Merged GC_reclaim_or_delete_all into GC_reclaim_all to get rid of some code. * Added Patrick Beard's Mac fixes, with substantial completely untested modifications. * Fixed the MPROTECT_VDB code to deal with large pages and imprecise fault addresses (as on an UltraSPARC running Solaris 2.5). Note that this was not a problem in the default configuration, which uses PROC_VDB. * The DEC Alpha assembly code needed to restore $gp between calls (thanks to Fergus Henderson for tracking this down and supplying a patch). * The write command for "de" was completely broken for large files. I used the easiest portable fix, which involved changing the semantics so that f.new is written instead of overwriting f. That's safer anyway. * Added README.solaris2 with a discussion of the possible problems of mixing the collector's sbrk allocation with malloc/realloc. * Changed the data segment starting address for SGI machines. The old code failed under IRIX6. * Required double word alignment for MIPS. * Various minor fixes to remove warnings. * Attempted to fix some Solaris threads problems (reported by Zhiying Chen). In particular, the collector could try to fork a thread with the world stopped as part of GC_thr_init. It also failed to deal with the case in which the original thread terminated before the whole process did. * Added -DNO_EXECUTE_PERMISSION. This has a major performance impact on the incremental collector under Irix, and perhaps under other operating systems. * Added some code to support allocating the heap with mmap. This may be preferable under some circumstances. * Integrated dynamic library support for HP (thanks to Knut Tvedten). * Integrated James Clark's win32 threads support, and made a number of changes to it (many of which suggested by Pontus Rydin). This is still not 100% solid. * Integrated Alistair G. Crooks' support for UTS4 running on an Amdahl 370-class machine. * Fixed a serious bug in explicitly typed allocation. Objects requiring large descriptors where handled in a way that usually resulted in a segmentation fault in the marker (thanks to Jeremy Fitzhardinge for helping to track this down). * Added partial support for GNU win32 development (thanks to Fergus Henderson). * Added optional support for Java-style finalization semantics (thanks to Patrick Bridges). This is recommended only for Java implementations. * GC_malloc_uncollectable faulted instead of returning 0 when out of memory (thanks to Daniel R. Grayson for noticing). * Calls to GC_base before the collector was initialized failed on a DEC Alpha (thanks to Matthew Flatt). * Added base pointer checking to GC_REGISTER_FINALIZER in debugging mode (thanks to Jeremy Fitzhardinge). * GC_debug_realloc failed for uncollectible objects (thanks to Jeremy Fitzhardinge). * Explicitly typed allocation could crash if it ran out of memory (thanks to Jeremy Fitzhardinge). * Added minimal support for a DEC Alpha running Linux. * Fixed a problem with allocation of objects whose size overflowed ptrdiff_t. (This now fails unconditionally, as it should.) * Added the beginning of Irix pthread support. * Integrated Xiaokun Zhu's fixes for djgpp 2.01. * Added SGI-style STL allocator support (gc_alloc.h). * Fixed a serious bug in README.solaris2. Multi-threaded programs must include gc.h with SOLARIS_THREADS defined. * Changed GC_free so it actually deallocates uncollectible objects (thanks to Peter Chubb for pointing out the problem). * Added Linux ELF support for dynamic libraries (thanks to Patrick Bridges). * Changed the Borland cc configuration so that the assembler is not required. * Fixed a bug in the C++ test that caused it to fail in 64-bit environments. == [4.10t3] 1996-11-18 == Some changes related to threads support. == [4.10] 1996-02-19 == * Fixed a typo around a call to GC_collect_or_expand in alloc.c. It broke handling of out of memory. (Thanks to Patrick C. Beard for noticing.) == [4.9] 1996-02-12 == * More README.debugging fixes. * Objects ready for finalization, but not finalized in the same GC cycle, could be prematurely collected. This occasionally happened in test_cpp. * Too little memory was obtained from the system for very large objects. That could cause a heap explosion if these objects were not contiguous (e.g. under PCR), and too much of them was blacklisted. * Due to an improper initialization, the collector was too hesitant to allocate blacklisted objects immediately after system startup. * Moved GC_arrays from the data into the bss segment by not explicitly initializing it to zero. This significantly reduces the size of executables, and probably avoids some disk accesses on program startup. It's conceivable that it might break a port that I didn't test. * Fixed EMX_MAKEFILE to reflect the gc_c++.h to gc_cpp.h renaming which occurred a while ago. == [4.8] 1995-11-20 == * Changed a "comment" in a MacOS specific part of mach_dep.c that caused gcc to fail on other platforms. == [4.7] 1995-11-18 == * Fixed some compilation problems with -DCHECKSUMS (thanks to Ian Searle). * Updated some Mac specific files (to synchronize with Patrick C. Beard). * Fixed a serious bug for machines with non-word-aligned pointers. (Thanks to Patrick C. Beard for pointing out the problem. The collector should fail almost any conceivable test immediately on such machines.) == [4.6] 1995-11-09 == * Added Linux ELF support (thanks to Arrigo Triulzi). * GC_base crashed if it was called before any other GC_ routines. This could happen if a gc_cleanup object was allocated outside the heap before any heap allocation. * The heap expansion heuristic was not stable if all objects had finalization enabled. Fixed finalize.c to count memory in finalization queue and avoid explicit deallocation. Changed alloc.c to also consider this count. (This is still not recommended. It's expensive if nothing else. Thanks to John Ellis for pointing this out.) * GC_malloc_uncollectable(0) was broken (thanks to Phong Vo for pointing this out). * The collector didn't compile under Linux 1.3.X (thanks to Fred Gilham for pointing this out). The current workaround is ugly, but expected to be temporary. * Fixed a formatting problem for SPARC stack traces. * Fixed some '=='s in os_dep.c that should have been assignments. Fortunately these were in code that should never be executed anyway (thanks to Fergus Henderson). * Fixed the heap block allocator to only drop blacklisted blocks in small chunks. Made BL_LIMIT self adjusting. (Both of these were in response to heap growth observed by Paul Graham.) * Fixed the Metrowerks/68K Mac code to also mark from a6 (thanks to Patrick C. Beard). * Significantly updated README.debugging. * Fixed some problems with longjmps out of signal handlers, especially under Solaris. Added a workaround for the fact that siglongjmp doesn't appear to do the right thing with -lthread under Solaris. * Added MSDOS/djgpp port (thanks to Mitch Harris). * Added "make reserved_namespace" and "make user_namespace". The first renames ALL "GC_xxx" identifiers as "_GC_xxx". The second is the inverse transformation. Note that doing this is guaranteed to break all clients written for the other names. * descriptor field for kind NORMAL in GC_obj_kinds with ADD_BYTE_AT_END defined should be -ALIGNMENT not WORDS_TO_BYTES(-1). This is a serious bug on machines with pointer alignment of less than a word. * GC_ignore_self_finalize_mark_proc didn't handle pointers to very near the end of the object correctly. Caused failures of the C++ test on a DEC Alpha with g++. * gc_inl.h still had problems. Partially fixed. Added warnings at the beginning to hopefully specify the remaining dangers. * Added DATAEND definition to config.h. * Fixed some of the .h file organization. Fixed "make floppy". == [4.5] 1995-06-14 == * Fixed many minor and one major README bugs (thanks to Franklin Chen for pointing out many of them). * Fixed ALPHA/OSF/1 dynamic library support (thanks to Jonathan Bachrach). * Added incremental GC support (MPROTECT_VDB) for Linux (with some help from Bruno Haible). * Altered SPARC recognition tests in gc.h and config.h (mostly as suggested by Fergus Henderson). * Added basic incremental GC support for win32, as implemented by Windows NT and Windows 95. GC_enable_incremental is a no-op under win32s, which doesn't implement enough of the VM interface. * Added -DLARGE_CONFIG. * Fixed GC_..._ignore_off_page to also function without -DALL_INTERIOR_POINTERS. * (Hopefully) fixed RS/6000 port. (Only the test was broken.) * Fixed a performance bug in the non-incremental collector running on machines supporting incremental collection with MPROTECT_VDB (e.g. SunOS 4, DEC AXP). This turned into a correctness bug under win32s with win32 incremental collection. (Not all memory protection was disabled.) * Fixed some ppcr related bit rot. * Caused dynamic libraries to be unregistered before re-registering. The old way turned out to be a performance bug on some machines. * GC_root_size was not properly maintained under MSWIN32. * Added -DNO_DEBUGGING and GC_dump. * Fixed a couple of bugs arising with SOLARIS_THREADS + REDIRECT_MALLOC. * Added NetBSD/M68K port (thanks to Peter Seebach). * Fixed a serious realloc bug. For certain object sizes, the collector wouldn't scan the expanded part of the object. (Thanks to Clay Spence for noticing the problem, and helping me to track it down.) == [4.4] 1995-02-18 == * ASM_CLEAR_CODE was erroneously defined for HP PA machines, resulting in a compile error. * Fixed OS/2 Makefile to create a library (thanks to Mark Boulter). * Gc_cleanup objects didn't work if they were created on the stack. Fixed. * One copy of Gc_cpp.h in the distribution was out of synch, and failed to document some known compiler problems with explicit destructor invocation. Partially fixed. There are probably other compilers on which gc_cleanup is miscompiled. * Fixed Makefile to pass C compiler flags to C++ compiler. * Added Mac fixes. * Fixed os_dep.c to work around what appears to be a new and different VirtualQuery bug under newer versions of win32S. * GC_non_gc_bytes was not correctly maintained by GC_free. Fixed (thanks to James Clark). * Added GC_set_max_heap_size. * Changed allocation code to ignore blacklisting if it is preventing use of a very large block of memory. This has the advantage that naive code allocating very large objects is much more likely to work. The downside is you might no longer find out that such code should really use GC_malloc_ignore_off_page. * Changed GC_printf under win32 to close and reopen the file between calls. FAT file systems otherwise make the log file useless for debugging. * Added GC_try_to_collect and GC_get_bytes_since_gc. These allow starting an abortable collection during idle times. This facility does not require special OS support. (Thanks to Michael Spertus of Geodesic Systems for suggesting this. It was actually an easy addition. Kumar Srikantan previously added a similar facility to a now ancient version of the collector. At the time this was much harder, and the result was less convincing.) * Added some support for the Borland development environment (thanks to John Ellis and Michael Spertus). * Removed a misfeature from checksums.c that caused unexpected heap growth (thanks to Scott Schwartz). * Changed finalize.c to call WARN if it encounters a finalization cycle. WARN is defined in gc_priv.h to write a message, usually to stdout. In many environments, this may be inappropriate. * Renamed NO_PARAMS in gc.h to GC_NO_PARAMS, thus adhering to my own naming convention. * Added GC_set_warn_proc to intercept warnings. * Fixed Amiga port (thanks to Michel Schinz). * Fixed a bug in mark.c that could result in an access to unmapped memory from GC_mark_from_mark_stack on machines with unaligned pointers. * Fixed a win32 specific performance bug that could result in scanning of objects allocated with the system malloc. * Added REDIRECT_MALLOC. == [4.3] 1994-12-23 == * Fixed SPARC alignment problem with GC_DEBUG. * Fixed Solaris threads /proc workaround. The real problem was an interaction with mprotect. * Incorporated fix from Patrick Beard for gc_c++.h (now gc_cpp.h). * Slightly improved allocator space utilization by fixing the GC_size_map mechanism. * Integrated some Sony News and MIPS RISCos 4.51 patches (thanks to Nobuyuki Hikichi at Software Research Associates, Inc., Japan). * Fixed HP_PA alignment problem (thanks to Brian F. Dennis). * Added GC_same_obj and friends. Changed GC_base to return 0 for pointers past the end of large objects. Improved GC_base performance with ALL_INTERIOR_POINTERS on machines with a slow integer mod operation. Added GC_PTR_ADD, GC_PTR_STORE, etc. to prepare for preprocessor. * changed the default on most UNIX machines to be that signals are not disabled during critical GC operations. This is still ANSI-conforming, though somewhat dangerous in the presence of signal handlers. But the performance cost of the alternative is sometimes problematic. Can be changed back with a minor Makefile edit. * renamed IS_STRING in gc.h, to CORD_IS_STRING, thus following my own naming convention. Added the function CORD_to_const_char_star. * Fixed a gross bug in GC_finalize. Symptom: occasional address faults in that function (thanks to Anselm Baird-Smith). * Added port to ICL DRS6000 running DRS/NX. Restructured things a bit to factor out common code, and remove obsolete code. Collector should now run under SUNOS5 with either mprotect or /proc dirty bits. (Thanks to Douglas Steel.) * More bug fixes and workarounds for Solaris 2.X. (These were mostly related to putting the collector in a dynamic library, which didn't really work before. Also SOLARIS_THREADS didn't interact well with dl_open.) (Thanks to Brian Lewis.) * Fixed a serious performance bug on the DEC Alpha. The text segment was getting registered as part of the root set. (Amazingly, the result was still fast enough that the bug was not conspicuous.) The fix works on OSF/1, version 1.3. Hopefully it also works on other versions of OSF/1 ... * Fixed a bug in GC_clear_roots. * Fixed a bug in GC_generic_malloc_words_small that broke gc_inl.h (reported by Antoine de Maricourt). * Fixed some problems with cord/de under Linux. * Fixed some cord problems, notably with CORD_riter4. * Added DG/UX port (thanks to Ben A. Mesander). * Added finalization registration routines with weaker ordering constraints. (This is necessary for C++ finalization with multiple inheritance, since the compiler often adds self-cycles.) * Filled the holes in the SCO port (thanks to Michael Arnoldus). * Completely rewritten the documentation in the interface gc_c++.h (later renamed gc_cpp.h) making it both clearer and more precise (done by John Ellis). * The definition of accessibility now ignores pointers from a finalizable object (an object with a clean-up function) to itself (done by John Ellis). This allows objects with virtual base classes to be finalizable by the collector. Compilers typically implement virtual base classes using pointers from an object to itself, which under the old definition of accessibility prevented objects with virtual base classes from ever being collected or finalized. * gc_cleanup now includes gc as a virtual base. This was enabled by the change in the definition of accessibility (by John Ellis). * Added support for operator new[] (by John Ellis). Since most compilers don't yet support operator new[], it is conditionalized on -DOPERATOR_NEW_ARRAY. The code is untested, but its trivial and looks correct. * The test program test_gc_c++ (later renamed test_cpp.cc) tries to test for the C++-specific functionality not tested by the other programs. * Added unistd.h include to misc.c. (Needed for ppcr.) * Added PowerMac port (thanks to Patrick C. Beard). * Fixed "srcdir"-related Makefile problems. Changed things so that all externally visible include files always appear in the include subdirectory of the source. Made gc.h directly includable from C++ code (thanks to Per Bothner). * Changed Intel code to also mark from ebp (thanks to Kevin Warne). * Renamed C++ related files so they could live in a FAT file system (thanks to Charles Fiterman). * Changed Windows NT Makefile to include C++ support in gc.lib. Added C++ test as Makefile target. == [4.2] 1994-08-03 == * Multiple bug fixes/workarounds in the Solaris threads version. (It occasionally failed to locate some register contents for marking. It also turns out that thr_suspend and friends are unreliable in Solaris 2.3. Dirty bit reads appear to be unreliable under some weird circumstances. My stack marking code contained a serious performance bug. The new code is extremely defensive, and has not failed in several CPU hours of testing. But no guarantees ...) * Added MacOS support. (Thanks to Patrick C. Beard. David Chase suggested several improvements.) * Fixed several syntactic bugs in gc_c++.h and friends. (These didn't bother g++, but did bother most other compilers.) Fixed gc_c++.h finalization interface. * 64 bit alignment for allocated objects was not guaranteed in a few cases in which it should have been. * Added GC_malloc_atomic_ignore_off_page. * Added GC_collect_a_little. * Added some prototypes to gc.h. * Some other minor bug fixes (notably in Makefile). * Fixed OS/2 / EMX port (thanks to Ari Huttunen). * Fixed AmigaDOS port (thanks to Michel Schinz). * Fixed the DATASTART definition under Solaris. There was a 1 in 16K chance of the collector missing the first 64K of static data (and thus crashing). * Fixed some blatant anachronisms in the README file. * Fixed PCR-Makefile for upcoming PPCR release. == [4.1] 1994-05-20 == * Changed finalization implementation to guarantee that finalization procedures are called outside of the allocation lock, making direct use of the interface a little less dangerous. MAY BREAK EXISTING CLIENTS that assume finalizers are protected by a lock. Since there seem to be few multi-threaded clients that use finalization, this is hopefully not much of a problem. * Fixed a gross bug in CORD_prev. * Fixed a bug in blacklst.c that could result in unbounded heap growth during startup on machines that do not clear memory obtained from the OS (e.g. win32S). * Ported de editor to win32/win32S. (This is now the only version with a mouse-sensitive UI. Thanks to Rob Haack for the implementation based on the generic Windows application template.) * Added GC_malloc_ignore_off_page to allocate large arrays in the presence of ALL_INTERIOR_POINTERS. * Changed GC_call_with_alloc_lock to not disable signals in the single-threaded case. * Reduced retry count in GC_collect_or_expand for garbage collecting when out of memory. * Made uncollectible allocations bypass black-listing, as they should. * Fixed a bug in typed_test in test.c that could cause (legitimate) GC crashes. * Fixed some potential synchronization problems in finalize.c * Fixed a real locking problem in typd_mlc.c. * Worked around an AIX 3.2 compiler feature that results in out of bounds memory references. * Partially worked around an IRIX5.2 beta problem (which may or may not persist to the final release). * Fixed a bug in the heap integrity checking code that could result in explicitly deallocated objects being identified as smashed. Fixed a bug in the dbg_mlc stack saving code that caused old argument pointers to be considered live. * Fixed a bug in CORD_ncmp (and hence CORD_str). * Repaired the OS2 port, which had suffered from bit rot in 4.0. Worked around what appears to be CSet/2 V1.0 optimizer bug. * Fixed a Makefile bug for target "c++". == [4.0] 1994-04-07 == * Added support for Solaris threads (which was possible only by reimplementing some fraction of Solaris threads, since Sun doesn't currently make the thread debugging interface available). * Added non-threads win32 and win32S support. * (Grudgingly, with suitable muttering of obscenities) renamed files so that the collector distribution could live on a FAT file system. Files that are guaranteed to be useless on a PC still have long names. Gc_inline.h and gc_private.h still exist, but now just include gc_inl.h and gc_priv.h. * Fixed a really obscure bug in finalization that could cause undetected mark stack overflows. (I would be surprised if any real code ever tickled this one.) * Changed finalization code to dynamically resize the hash tables it maintains. (This probably does not matter for well- -written code. It no doubt does for C++ code that overuses destructors.) * Added typed allocation primitives. Rewrote the marker to accommodate them with more reasonable efficiency. This change should also speed up marking for GC_malloc allocated objects a little. See gc_typed.h for new primitives. (Thanks to Zhong Shao performed much of the experimentation that led to the current typed allocation facility.) * Improved debugging facilities slightly. Allocation time stack traces are now kept by default on SPARC/SUNOS4. (Thanks to Scott Schwartz.) * Added better support for small heap applications. * Significantly extended cord package. Fixed a bug in the implementation of lazily read files. Printf and friends now have cord variants. Cord traversals are a bit faster. * Made ALL_INTERIOR_POINTERS recognition the default. * Fixed de so that it can run in constant space, independent of file size. Added simple string searching to cords and de. * Added the Hull-Ellis C++ interface (supplied by Jesse Hull and John Ellis). * Added dynamic library support for OSF/1 (thanks to Alan Dosser and Tim Bingham at DEC). * Changed argument to GC_expand_hp to be expressed in units of bytes instead of heap blocks. (Necessary since the heap block size now varies depending on configuration. The old version was never very clean.) * Added GC_get_heap_size(). The previous "equivalent" was broken. * Restructured the Makefile a bit. * Added FreeBSD port (provided by Jeffrey Hsu). == [3.7] 1994-03-15 == * Added a workaround for an HP/UX compiler bug. * Fixed another stack clearing performance bug. Reworked that code once more. == [3.6] 1994-01-14 == * fixed a bug in the mark stack growth code that was introduced in 3.4. * fixed Makefile to work around DEC AXP compiler tail recursion bug. == [3.5] == * Minor collections now mark from roots only once, if that doesn't cause an excessive pause. * The stack clearing heuristic was refined to prevent anomalies with very heavily recursive programs and sparse stacks. * Fixed a bug that prevented mark stack growth in some cases. GC_objects_are_marked should be set to TRUE after a call to GC_push_roots and as part of GC_push_marked, since both can now set mark bits. I think this is only a performance bug, but I wouldn't bet on it. It's certainly very hard to argue that the old version was correct. * Fixed an incremental collection bug that prevented it from working at all when HBLKSIZE != getpagesize() * Changed dynamic_loading.c to include gc_priv.h before testing DYNAMIC_LOADING. SunOS dynamic library scanning must have been broken in 3.4. * Object size rounding now adapts to program behavior. * Added a workaround (provided by Manuel Serrano and colleagues) to a long-standing SunOS 4.X (and 3.X) ld bug that I had incorrectly assumed to have been squished. The collector was broken if the text segment size was within 32 bytes of a multiple of 8K bytes, and if the beginning of the data segment contained interesting roots. The workaround assumes a demand-loadable executable. The original may have have "worked" in some other cases. * Added dynamic library support under IRIX5. * Added support for EMX under OS/2 (thanks to Ari Huttunen). * Added support of Motorola 88K processor running CX/UX (by Brent Benson). == [3.4] == * Fixed a performance bug in GC_realloc. * Updated the amiga port. * Added NetBSD and 386BSD ports (supplied by Alistair G. Crooks). * Added cord library. * Added trivial performance enhancement for ALL_INTERIOR_POINTERS (do not scan last word). == [3.3] 1993-10-02 == * PCR-specific bugs (thanks to Neil Sharman). * Missing locking in GC_free, redundant FASTUNLOCK in GC_malloc_stubborn, and 2 bugs in GC_unregister_disappearing_link (pointed out by Neil Sharman). * Common symbols allocated by the SunOS4.X dynamic loader were not included in the root set. * Bug in GC_finalize (reported by Brian Beuning and Alan Dosser). * Merged Amiga port from Jesper Peterson (untested). * Merged NeXT port from Thomas Funke (significantly modified and untested). (Also thanks to Brian D. Carlstrom for the supplied the NeXT ports.) == [3.2] == Fixed a serious and not entirely repeatable bug in the incremental collector. It appeared only when dirty bit info on the roots was available, which is normally only under Solaris. It also added GC_general_register_disappearing_link, and some testing code. Interface.c disappeared. == [3.1] == * A workaround for a SunOS 4.X SPARC C compiler misfeature that caused problems when the collector was turned into a dynamic library. * A fix for a bug in GC_base that could result in a memory fault. * A fix for a performance bug (and several other misfeatures) pointed out by Dave Detlefs and Alan Dosser. * Use of dirty bit information for static data under Solaris 2.X. * DEC Alpha/OSF1 support (thanks to Alan Dosser). * Incremental collection on more platforms. * A more refined heap expansion policy. Less space usage by default. * Various minor enhancements to reduce space usage, and to reduce the amount of memory scanned by the collector. * Uncollectible allocation without per object overhead. * More conscientious handling of out-of-memory conditions. * Fixed a bug in debugging stubborn allocation. * Fixed a bug that resulted in occasional erroneous reporting of smashed objects with debugging allocation. * Fixed bogus leak reports of size 4096 blocks with FIND_LEAK. == [3.0] == Added generational/incremental collection and stubborn objects. == [2.6] 1993-04-27 == (Changes not specified.) == [2.5] == * Removed an explicit call to exit(1) * Fixed calls to GC_printf and GC_err_printf, so the correct number of arguments are always supplied. The OS/2 C compiler gets confused if the number of actuals and the number of formals differ. (ANSI C doesn't require this to work. The ANSI sanctioned way of doing things causes too many compatibility problems.) == [2.4] 1993-01-26 == Added GC_free_space_divisor as a tuning knob, added support for OS/2 and linux, and fixed the following bugs: * On machines with unaligned pointers (e.g. Sun 3), every 128th word could fail to be considered for marking. * Dynamic_load.c erroneously added 4 bytes to the length of the data and bss sections of the dynamic library. This could result in a bad memory reference if the actual length was a multiple of a page. (Observed on Sun 3. Can probably also happen on a Sun 4.) (Thanks to Robert Brazile for pointing out that the Sun 3 version was broken. Dynamic library handling is still broken on Sun 3s under 4.1.1U1, but apparently not 4.1.1. If you have such a machine, use -Bstatic.) == [2.3] == * Added ALL_INTERIOR_POINTERS. * Missing declaration of etext in the A/UX version. * Some PCR root-finding problems. * Blacklisting was not 100% effective, because the plausible future heap bounds were being miscalculated. * GC_realloc didn't handle out-of-memory correctly. * GC_base could return a nonzero value for addresses inside free blocks. * test.c wasn't really thread safe, and could erroneously report failure in a multi-threaded environment. (The locking primitives need to be replaced for other threads packages.) * GC_CONS was thoroughly broken. * On a SPARC with dynamic linking, signals stayed disabled while the client code was running (thanks to Manuel Serrano). == [2.2] == * GC_realloc could fail to extend the size of the object for certain large object sizes. * A blatant subscript range error in GC_printf, which unfortunately wasn't exercised on machines with sufficient stack alignment constraints. * GC_register_displacement did the wrong thing if it was called after any allocation had taken place. * The leak finding code would eventually break after 2048 byte byte objects leaked. * interface.c didn't compile. * The heap size remained much too small for large stacks. * The stack clearing code behaved badly for large stacks, and perhaps on HP/PA machines. == [2.1] == * The first stable version since 1.9. * Added support for PPCR. == [2.0] == * Introduced a consistent naming convention for collector routines and added support for registering dynamic library data segments in the standard mark_roots.c (original code supporting the SunOS dynamic loader provided by Bill Janssen). Most of the data structures were revamped. The treatment of interior pointers was completely changed. Finalization was added. Support for locking was added. Object kinds were added. We added a black listing facility to avoid allocating at addresses known to occur as integers somewhere in the address space. Much of this was accomplished by adapting ideas and code from the PCR collector. The test program was changed and expanded. == [1.9] 1992-01-29 == * fixed a major bug in gc_realloc. == [1.8] == * added ULTRIX support in gc_private.h. (Robert Brazile originally supplied the ULTRIX code. Alan Dosser and Regis Cridlig subsequently provided updates and information on variation between ULTRIX systems.) == [1.5] == * ensure 8 byte alignment for objects allocated on a sparc based machine. == [1.4] == * Does not use compile time determined values for the stack base. This no longer works on Sun 3s, since Sun 3/80s use a different stack base. We now use a straightforward heuristic on all machines on which it is known to work (incl. Sun 3s) and compile-time determined values for the rest. There should really be library calls to determine such values. == [1.3] == * Fixed spurious assembly language assignments to TMP_SP. Only the assignment in the PC/RT code is necessary. On other machines, with certain compiler options, the assignments can lead to an unsaved register being overwritten. Known to cause problems under SunOS 3.5 WITHOUT the -O option. (With -O the compiler recognizes it as dead code. It probably shouldn't, but that's another story.) The SPARC-specific code was originally contributed by Mark Weiser. The Encore Multimax modifications were supplied by Kevin Kenny. The adaptation to the IBM PC/RT is largely due to Vernon Lee, on machines made available to Rice by IBM. Much of the HP specific code and a number of good suggestions for improving the generic code are due to Walter Underwood. Parag Patel supplied the A/UX code. Manuel Serrano supplied linux and Sony News specific code. ecl-16.1.2/src/bdwgc/EMX_MAKEFILE000066400000000000000000000077611266352375300160610ustar00rootroot00000000000000# # OS/2 specific Makefile for the EMX environment # # You need GNU Make 3.71, gcc 2.5.7, emx 0.8h and GNU fileutils 3.9 # or similar tools. C++ interface and de.exe weren't tested. # # Primary targets: # gc.a - builds basic library # c++ - adds C++ interface to library and include directory # cords - adds cords (heavyweight strings) to library and include directory # test - prints porting information, then builds basic version of gc.a, and runs # some tests of collector and cords. Does not add cords or c++ interface to gc.a # cord/de.exe - builds dumb editor based on cords. CC= gcc CXX=g++ # Needed only for "make c++", which adds the c++ interface CFLAGS= -O -DALL_INTERIOR_POINTERS -I$(srcdir)/include # Setjmp_test may yield overly optimistic results when compiled # without optimization. CXXFLAGS= $(CFLAGS) AR= ar RANLIB= ar s # Redefining srcdir allows object code for the nonPCR version of the collector # to be generated in different directories srcdir = . VPATH = $(srcdir) OBJS= alloc.o reclaim.o allchblk.o misc.o mach_dep.o os_dep.o mark_rts.o headers.o mark.o obj_map.o blacklst.o finalize.o new_hblk.o dyn_load.o dbg_mlc.o fnlz_mlc.o malloc.o stubborn.o checksums.o typd_mlc.o ptr_chck.o mallocx.o CORD_OBJS= cord/cordbscs.o cord/cordxtra.o cord/cordprnt.o CORD_INCLUDE_FILES= $(srcdir)/include/gc.h $(srcdir)/include/cord.h \ $(srcdir)/include/ec.h $(srcdir)/include/cord_pos.h # Libraries needed for curses applications. Only needed for de. CURSES= -lcurses -ltermlib SPECIALCFLAGS = -I$(srcdir)/include # Alternative flags to the C compiler for mach_dep.c. # Mach_dep.c often doesn't like optimization, and it's # not time-critical anyway. all: gc.a gctest.exe $(OBJS) test.o: $(srcdir)/include/private/gc_priv.h \ $(srcdir)/include/private/gc_hdrs.h $(srcdir)/include/gc.h \ $(srcdir)/include/private/gcconfig.h $(srcdir)/include/gc_typed.h # The dependency on Makefile is needed. Changing # options affects the size of GC_arrays, # invalidating all .o files that rely on gc_priv.h mark.o typd_mlc.o finalize.o: $(srcdir)/include/gc_mark.h $(srcdir)/include/private/gc_pmark.h gc.a: $(OBJS) $(AR) ru gc.a $(OBJS) $(RANLIB) gc.a cords: $(CORD_OBJS) cord/cordtest.exe $(AR) ru gc.a $(CORD_OBJS) $(RANLIB) gc.a gc_cpp.o: $(srcdir)/gc_cpp.cc $(srcdir)/include/gc_cpp.h $(CXX) -c $(CXXFLAGS) $(srcdir)/gc_cpp.cc c++: gc_cpp.o $(srcdir)/include/gc_cpp.h $(AR) ru gc.a gc_cpp.o $(RANLIB) gc.a mach_dep.o: $(srcdir)/mach_dep.c $(CC) -o mach_dep.o -c $(SPECIALCFLAGS) $(srcdir)/mach_dep.c mark_rts.o: $(srcdir)/mark_rts.c $(CC) -o mark_rts.o -c $(CFLAGS) $(srcdir)/mark_rts.c cord/cordbscs.o: $(srcdir)/cord/cordbscs.c $(CORD_INCLUDE_FILES) $(CC) $(CFLAGS) -c $(srcdir)/cord/cordbscs.c -o cord/cordbscs.o cord/cordxtra.o: $(srcdir)/cord/cordxtra.c $(CORD_INCLUDE_FILES) $(CC) $(CFLAGS) -c $(srcdir)/cord/cordxtra.c -o cord/cordxtra.o cord/cordprnt.o: $(srcdir)/cord/cordprnt.c $(CORD_INCLUDE_FILES) $(CC) $(CFLAGS) -c $(srcdir)/cord/cordprnt.c -o cord/cordprnt.o cord/cordtest.exe: $(srcdir)/cord/tests/cordtest.c $(CORD_OBJS) gc.a $(CC) $(CFLAGS) -o cord/cordtest.exe $(srcdir)/cord/tests/cordtest.c $(CORD_OBJS) gc.a cord/de.exe: $(srcdir)/cord/tests/de.c $(srcdir)/cord/cordbscs.o $(srcdir)/cord/cordxtra.o gc.a $(CC) $(CFLAGS) -o cord/de.exe $(srcdir)/cord/tests/de.c $(srcdir)/cord/cordbscs.o $(srcdir)/cord/cordxtra.o gc.a $(CURSES) clean: rm -f gc.a tests/test.o gctest.exe output-local output-diff $(OBJS) \ setjmp_test mon.out gmon.out a.out core \ $(CORD_OBJS) cord/cordtest.exe cord/de.exe -rm -f *~ gctest.exe: tests/test.o gc.a $(CC) $(CFLAGS) -o gctest.exe tests/test.o gc.a # If an optimized setjmp_test generates a segmentation fault, # odds are your compiler is broken. Gctest may still work. # Try compiling setjmp_t.c unoptimized. setjmp_test.exe: $(srcdir)/tools/setjmp_t.c $(srcdir)/include/gc.h $(CC) $(CFLAGS) -o setjmp_test.exe $(srcdir)/tools/setjmp_t.c test: setjmp_test.exe gctest.exe ./setjmp_test ./gctest make cord/cordtest.exe cord/cordtest ecl-16.1.2/src/bdwgc/Makefile.am000066400000000000000000000137221266352375300162760ustar00rootroot00000000000000# Copyright (c) 1999-2001 by Red Hat, Inc. All rights reserved. # # THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED # OR IMPLIED. ANY USE IS AT YOUR OWN RISK. # # Permission is hereby granted to use or copy this program # for any purpose, provided the above notices are retained on all copies. # Permission to modify the code and to distribute modified code is granted, # provided the above notices are retained, and a notice that the code was # modified is included with the above copyright notice. ## Process this file with automake to produce Makefile.in. ## FIXME: `make distcheck' in this directory will not currently work. ## This is most likely to the explicit flags passed to submakes. # We currently use the source files directly from libatomic_ops, if we # use the internal version. This is done since libatomic_ops doesn't # use libtool, since it has no real use for it. But that seems to make # it hard to use either the resulting object files or libraries. # Thus there seems too be no real reason to recursively build in the # libatomic_ops directory. # if USE_INTERNAL_LIBATOMICS_OPS # SUBDIRS = @maybe_libatomic_ops@ # else # SUBDIRS = # endif SUBDIRS = ACLOCAL_AMFLAGS = -I m4 AM_CPPFLAGS = \ -I$(top_builddir)/include -I$(top_srcdir)/include \ $(ATOMIC_OPS_CFLAGS) # Initialize variables so that we can declare files locally. EXTRA_DIST = lib_LTLIBRARIES = include_HEADERS = pkginclude_HEADERS = dist_noinst_HEADERS = check_PROGRAMS = check_LTLIBRARIES = TESTS = pkgconfigdir = $(libdir)/pkgconfig pkgconfig_DATA = bdw-gc.pc # C Library # --------- lib_LTLIBRARIES += libgc.la if SINGLE_GC_OBJ libgc_la_SOURCES = extra/gc.c else EXTRA_DIST += extra/gc.c libgc_la_SOURCES = \ allchblk.c alloc.c blacklst.c checksums.c dbg_mlc.c \ dyn_load.c finalize.c gc_dlopen.c gcj_mlc.c headers.c \ mach_dep.c malloc.c mallocx.c mark.c mark_rts.c misc.c new_hblk.c \ obj_map.c os_dep.c pcr_interface.c ptr_chck.c real_malloc.c reclaim.c \ specific.c stubborn.c thread_local_alloc.c typd_mlc.c # C Library: Architecture Dependent # --------------------------------- if WIN32_THREADS libgc_la_SOURCES += win32_threads.c else if PTHREADS libgc_la_SOURCES += pthread_start.c pthread_support.c if DARWIN_THREADS libgc_la_SOURCES += darwin_stop_world.c else libgc_la_SOURCES += pthread_stop_world.c endif endif endif if MAKE_BACK_GRAPH libgc_la_SOURCES += backgraph.c endif if ENABLE_DISCLAIM libgc_la_SOURCES += fnlz_mlc.c endif endif if USE_INTERNAL_LIBATOMIC_OPS nodist_libgc_la_SOURCES = libatomic_ops/src/atomic_ops.c endif if NEED_ATOMIC_OPS_ASM nodist_libgc_la_SOURCES = libatomic_ops/src/atomic_ops_sysdeps.S endif # Include THREADDLLIBS here to ensure that the correct versions of # linuxthread semaphore functions get linked: libgc_la_LIBADD = @addobjs@ $(THREADDLLIBS) $(UNWINDLIBS) $(ATOMIC_OPS_LIBS) libgc_la_DEPENDENCIES = @addobjs@ libgc_la_LDFLAGS = $(extra_ldflags_libgc) -version-info 1:3:0 -no-undefined EXTRA_libgc_la_SOURCES = ia64_save_regs_in_stack.s sparc_mach_dep.S \ sparc_netbsd_mach_dep.s sparc_sunos4_mach_dep.s # C++ Interface # ------------- if CPLUSPLUS lib_LTLIBRARIES += libgccpp.la pkginclude_HEADERS += include/gc_cpp.h include_HEADERS += include/extra/gc_cpp.h libgccpp_la_SOURCES = gc_cpp.cc libgccpp_la_LIBADD = ./libgc.la libgccpp_la_LDFLAGS = -version-info 1:3:0 -no-undefined endif # FIXME: If Visual C++ users use Makefile.am, this should go into # pkginclude_HEADERS with proper AM_CONDITIONALization. Otherwise # delete this comment. EXTRA_DIST += gc_cpp.cpp # Misc # ---- AM_CXXFLAGS = @GC_CFLAGS@ AM_CFLAGS = @GC_CFLAGS@ ## FIXME: relies on internal code generated by automake. ## FIXME: ./configure --enable-dependency-tracking should be used #all_objs = @addobjs@ $(libgc_la_OBJECTS) #$(all_objs) : include/private/gcconfig.h include/private/gc_priv.h \ #include/private/gc_hdrs.h include/gc.h include/gc_gcj.h \ #include/gc_pthread_redirects.h include/gc_config_macros.h \ #include/private/thread_local_alloc.h include/private_support.h \ #include/private/pthread_stop_world.h \ #include/gc_mark.h @addincludes@ ## FIXME: we shouldn't have to do this, but automake forces us to. ## We use -Wp,-P to strip #line directives. Irix `as' chokes on ## these. if ASM_WITH_CPP_UNSUPPORTED ASM_CPP_OPTIONS = else ASM_CPP_OPTIONS = -Wp,-P -x assembler-with-cpp endif .s.lo: $(LTCOMPILE) $(ASM_CPP_OPTIONS) -c $< .S.lo: $(LTCOMPILE) $(ASM_CPP_OPTIONS) -c $< ## We need to add DEFS to assembler flags ## :FIXME: what if assembler does not accept -D... ? ## (use Autoconf to prepare ASDEFS?) CCASFLAGS += $(DEFS) # headers which are not installed # (see include/include.am for more) # # documentation which is not installed # EXTRA_DIST += README.QUICK TODO # other makefiles # :GOTCHA: deliberately we do not include 'Makefile' EXTRA_DIST += BCC_MAKEFILE NT_MAKEFILE \ OS2_MAKEFILE PCR-Makefile digimars.mak EMX_MAKEFILE \ Makefile.direct SMakefile.amiga WCC_MAKEFILE autogen.sh \ NT_STATIC_THREADS_MAKEFILE NT_X64_STATIC_THREADS_MAKEFILE \ NT_X64_THREADS_MAKEFILE CMakeLists.txt tests/CMakeLists.txt # files used by makefiles other than Makefile.am # EXTRA_DIST += tools/add_gc_prefix.c tools/gcname.c tools/if_mach.c \ tools/if_not_there.c tools/setjmp_t.c tools/threadlibs.c \ gc.mak extra/MacOS.c extra/AmigaOS.c \ extra/symbian/global_end.cpp extra/symbian/global_start.cpp \ extra/symbian/init_global_static_roots.cpp extra/symbian.cpp \ build/s60v3/bld.inf build/s60v3/libgc.mmp \ extra/Mac_files/datastart.c extra/Mac_files/dataend.c \ extra/Mac_files/MacOS_config.h \ include/private/msvc_dbg.h extra/msvc_dbg.c tools/callprocs.sh # # :GOTCHA: GNU make rule for making .s out of .S is flawed, # it will not remove dest if building fails .S.s: if $(CPP) $< >$@ ; then :; else rm -f $@; fi include include/include.am include cord/cord.am include tests/tests.am include doc/doc.am # Putting these at the top causes cord to be built first, and not find libgc.a # on HP/UX. There may be a better fix. ecl-16.1.2/src/bdwgc/Makefile.direct000066400000000000000000000444201266352375300171520ustar00rootroot00000000000000# This is the original manually generated Makefile. It may still be used # to build the collector. # # Primary targets: # gc.a - builds basic library # c++ - adds C++ interface to library # cords - adds cords (heavyweight strings) to library # test - prints porting information, then builds basic version of gc.a, # and runs some tests of collector and cords. Does not add cords or # c++ interface to gc.a # cord/de - builds dumb editor based on cords. ABI_FLAG= # ABI_FLAG should be the cc flag that specifies the ABI. On most # platforms this will be the empty string. Possible values: # +DD64 for 64-bit executable on HP/UX. # -n32, -n64, -o32 for SGI/MIPS ABIs. AS_ABI_FLAG=$(ABI_FLAG) # ABI flag for assembler. On HP/UX this is +A64 for 64 bit # executables. CC=cc $(ABI_FLAG) CXX=g++ $(ABI_FLAG) AS=as $(AS_ABI_FLAG) # The above doesn't work with gas, which doesn't run cpp. # Define AS as `gcc -c -x assembler-with-cpp' instead. # Redefining srcdir allows object code for the nonPCR version of the collector # to be generated in different directories. srcdir= . VPATH= $(srcdir) # Path to atomic_ops source. AO_SRC_DIR=$(srcdir)/libatomic_ops CFLAGS_EXTRA= CFLAGS= -O -I$(srcdir)/include -I$(AO_SRC_DIR)/src \ -DATOMIC_UNCOLLECTABLE -DNO_EXECUTE_PERMISSION -DALL_INTERIOR_POINTERS \ $(CFLAGS_EXTRA) # To build the parallel collector on Linux, add to the above: # -DGC_LINUX_THREADS -DPARALLEL_MARK -DTHREAD_LOCAL_ALLOC # To build the thread-capable preload library that intercepts # malloc, add -DGC_USE_DLOPEN_WRAP -DREDIRECT_MALLOC=GC_malloc -fpic # To build the parallel collector in a static library on HP/UX, # add to the above: # -DGC_HPUX_THREADS -DTHREAD_LOCAL_ALLOC -D_POSIX_C_SOURCE=199506L -mt # FIXME: PARALLEL_MARK currently broken on HP/UX. # To build the thread-safe collector on Tru64, add to the above: # -pthread -DGC_OSF1_THREADS # HOSTCC and HOSTCFLAGS are used to build executables that will be run as # part of the build process, i.e. on the build machine. These will usually # be the same as CC and CFLAGS, except in a cross-compilation environment. # Note that HOSTCFLAGS should include any -D flags that affect thread support. HOSTCC=$(CC) HOSTCFLAGS=$(CFLAGS) # For dynamic library builds, it may be necessary to add flags to generate # PIC code, e.g. -fPIC on Linux. # Setjmp_test may yield overly optimistic results when compiled # without optimization. # Look into doc/README.macros for the description of the "define arguments" # influencing the collector configuration. CXXFLAGS= $(CFLAGS) AR= ar RANLIB= ranlib OBJS= alloc.o reclaim.o allchblk.o misc.o mach_dep.o os_dep.o mark_rts.o \ headers.o mark.o obj_map.o blacklst.o finalize.o new_hblk.o dbg_mlc.o \ malloc.o stubborn.o checksums.o pthread_support.o pthread_stop_world.o \ darwin_stop_world.o typd_mlc.o ptr_chck.o mallocx.o gcj_mlc.o specific.o \ gc_dlopen.o backgraph.o win32_threads.o pthread_start.o \ thread_local_alloc.o fnlz_mlc.o atomic_ops.o atomic_ops_sysdeps.o CSRCS= reclaim.c allchblk.c misc.c alloc.c mach_dep.c os_dep.c mark_rts.c \ headers.c mark.c obj_map.c pcr_interface.c blacklst.c finalize.c \ new_hblk.c real_malloc.c dyn_load.c dbg_mlc.c malloc.c stubborn.c \ checksums.c pthread_support.c pthread_stop_world.c darwin_stop_world.c \ typd_mlc.c ptr_chck.c mallocx.c gcj_mlc.c specific.c gc_dlopen.c \ backgraph.c win32_threads.c pthread_start.c thread_local_alloc.c fnlz_mlc.c CORD_SRCS= cord/cordbscs.c cord/cordxtra.c cord/cordprnt.c cord/tests/de.c \ cord/tests/cordtest.c include/cord.h include/ec.h \ include/cord_pos.h cord/tests/de_win.c cord/tests/de_win.h \ cord/tests/de_cmds.h cord/tests/de_win.rc CORD_OBJS= cord/cordbscs.o cord/cordxtra.o cord/cordprnt.o SRCS= $(CSRCS) \ include/gc.h include/gc_typed.h include/gc_tiny_fl.h \ include/gc_version.h include/private/gc_hdrs.h include/private/gc_priv.h \ include/private/gcconfig.h include/private/gc_pmark.h \ include/gc_inline.h include/gc_mark.h include/gc_disclaim.h \ tools/threadlibs.c \ tools/if_mach.c tools/if_not_there.c gc_cpp.cc include/gc_cpp.h \ tools/gcname.c include/weakpointer.h include/private/gc_locks.h \ include/new_gc_alloc.h include/gc_allocator.h \ include/javaxfc.h \ include/gc_backptr.h include/gc_gcj.h include/private/dbg_mlc.h \ include/private/specific.h include/leak_detector.h \ include/gc_pthread_redirects.h \ include/gc_config_macros.h include/private/pthread_support.h \ include/private/pthread_stop_world.h include/private/darwin_semaphore.h \ include/private/darwin_stop_world.h include/private/thread_local_alloc.h \ ia64_save_regs_in_stack.s sparc_mach_dep.S \ sparc_netbsd_mach_dep.s sparc_sunos4_mach_dep.s $(CORD_SRCS) DOC_FILES= README.QUICK TODO doc/README.Mac doc/README.OS2 \ doc/README.amiga doc/README.cords doc/debugging.html \ doc/finalization.html doc/porting.html doc/overview.html \ doc/README.hp doc/README.linux doc/README.rs6000 \ doc/README.sgi doc/README.solaris2 doc/README.uts \ doc/README.symbian doc/README.win32 README.md AUTHORS doc/gc.man \ doc/README.environment doc/tree.html doc/gcdescr.html \ doc/README.autoconf doc/README.macros doc/README.ews4800 \ doc/README.DGUX386 doc/README.arm.cross doc/leak.html \ doc/scale.html doc/gcinterface.html doc/README.darwin \ doc/simple_example.html doc/README.win64 TESTS= tests/test.c tests/test_cpp.cc tests/trace_test.c \ tests/leak_test.c tests/thread_leak_test.c tests/middle.c \ tests/smash_test.c tests/huge_test.c GNU_BUILD_FILES= configure.ac Makefile.am configure install-sh Makefile.in \ aclocal.m4 config.sub config.guess \ include/include.am doc/doc.am \ ltmain.sh mkinstalldirs depcomp missing \ cord/cord.am tests/tests.am autogen.sh \ bdw-gc.pc.in compile OTHER_MAKEFILES= OS2_MAKEFILE NT_MAKEFILE gc.mak \ BCC_MAKEFILE EMX_MAKEFILE WCC_MAKEFILE PCR-Makefile SMakefile.amiga \ digimars.mak Makefile.direct NT_STATIC_THREADS_MAKEFILE \ NT_X64_STATIC_THREADS_MAKEFILE NT_X64_THREADS_MAKEFILE OTHER_FILES= tools/setjmp_t.c tools/callprocs.sh extra/MacOS.c \ extra/Mac_files/datastart.c extra/Mac_files/dataend.c \ extra/Mac_files/MacOS_config.h tools/add_gc_prefix.c gc_cpp.cpp \ extra/symbian/global_end.cpp extra/symbian/global_start.cpp \ extra/symbian/init_global_static_roots.cpp extra/symbian.cpp \ build/s60v3/bld.inf build/s60v3/libgc.mmp \ extra/AmigaOS.c extra/msvc_dbg.c include/private/msvc_dbg.h \ $(TESTS) $(GNU_BUILD_FILES) $(OTHER_MAKEFILES) CORD_INCLUDE_FILES= $(srcdir)/include/gc.h $(srcdir)/include/cord.h \ $(srcdir)/include/ec.h $(srcdir)/include/cord_pos.h UTILS= if_mach if_not_there threadlibs # Libraries needed for curses applications. Only needed for de. CURSES= -lcurses -ltermlib # The following is irrelevant on most systems. But a few # versions of make otherwise fork the shell specified in # the SHELL environment variable. SHELL= /bin/sh SPECIALCFLAGS = -I$(srcdir)/include -I$(AO_SRC_DIR)/src # Alternative flags to the C compiler for mach_dep.c. # Mach_dep.c often doesn't like optimization, and it's # not time-critical anyway. # Set SPECIALCFLAGS to -q nodirect_code on Encore. all: gc.a gctest atomic_ops.o: $(AO_SRC_DIR)/src/atomic_ops.c $(CC) $(CFLAGS) -c -o $@ $< atomic_ops_sysdeps.o: $(AO_SRC_DIR)/src/atomic_ops_sysdeps.S $(CC) $(CFLAGS) -c -o $@ $< LEAKFLAGS=$(CFLAGS) -DFIND_LEAK BSD-pkg-all: bsd-libgc.a bsd-libleak.a bsd-libgc.a: $(MAKE) CFLAGS="$(CFLAGS)" clean c++-t mv gc.a bsd-libgc.a bsd-libleak.a: $(MAKE) -f Makefile.direct CFLAGS="$(LEAKFLAGS)" clean c++-nt mv gc.a bsd-libleak.a BSD-pkg-install: BSD-pkg-all ${CP} bsd-libgc.a libgc.a ${INSTALL_DATA} libgc.a ${PREFIX}/lib ${INSTALL_DATA} gc.h gc_cpp.h ${PREFIX}/include ${INSTALL_MAN} doc/gc.man ${PREFIX}/man/man3/gc.3 pcr: PCR-Makefile include/private/gc_private.h include/private/gc_hdrs.h \ include/private/gc_locks.h include/gc.h include/private/gcconfig.h \ mach_dep.o $(SRCS) $(MAKE) -f PCR-Makefile depend $(MAKE) -f PCR-Makefile $(OBJS) tests/test.o dyn_load.o dyn_load_sunos53.o: \ $(srcdir)/include/private/gc_priv.h \ $(srcdir)/include/private/gc_hdrs.h $(srcdir)/include/private/gc_locks.h \ $(srcdir)/include/gc.h $(srcdir)/include/gc_pthread_redirects.h \ $(srcdir)/include/private/gcconfig.h $(srcdir)/include/gc_typed.h \ $(srcdir)/include/gc_config_macros.h mark.o typd_mlc.o finalize.o ptr_chck.o: $(srcdir)/include/gc_mark.h \ $(srcdir)/include/private/gc_pmark.h specific.o pthread_support.o thread_local_alloc.o win32_threads.o: \ $(srcdir)/include/private/specific.h $(srcdir)/include/gc_inline.h \ $(srcdir)/include/private/thread_local_alloc.h dbg_mlc.o gcj_mlc.o: $(srcdir)/include/private/dbg_mlc.h tests/test.o: tests $(srcdir)/tests/test.c $(CC) $(CFLAGS) -c $(srcdir)/tests/test.c mv test.o tests/test.o tests: mkdir tests base_lib gc.a: $(OBJS) dyn_load.o $(UTILS) echo > base_lib rm -f dont_ar_1 ./if_mach SPARC SOLARIS touch dont_ar_1 ./if_mach SPARC SOLARIS $(AR) rus gc.a $(OBJS) dyn_load.o ./if_mach M68K AMIGA touch dont_ar_1 ./if_mach M68K AMIGA $(AR) -vrus gc.a $(OBJS) dyn_load.o ./if_not_there dont_ar_1 $(AR) ru gc.a $(OBJS) dyn_load.o ./if_not_there dont_ar_1 $(RANLIB) gc.a || cat /dev/null # ignore ranlib failure; that usually means it doesn't exist, and isn't needed cords: $(CORD_OBJS) cord/cordtest $(UTILS) rm -f dont_ar_3 ./if_mach SPARC SOLARIS touch dont_ar_3 ./if_mach SPARC SOLARIS $(AR) rus gc.a $(CORD_OBJS) ./if_mach M68K AMIGA touch dont_ar_3 ./if_mach M68K AMIGA $(AR) -vrus gc.a $(CORD_OBJS) ./if_not_there dont_ar_3 $(AR) ru gc.a $(CORD_OBJS) ./if_not_there dont_ar_3 $(RANLIB) gc.a || cat /dev/null gc_cpp.o: $(srcdir)/gc_cpp.cc $(srcdir)/include/gc_cpp.h $(srcdir)/include/gc.h $(CXX) -c $(CXXFLAGS) $(srcdir)/gc_cpp.cc test_cpp: $(srcdir)/tests/test_cpp.cc $(srcdir)/include/gc_cpp.h gc_cpp.o $(srcdir)/include/gc.h \ base_lib $(UTILS) rm -f test_cpp ./if_mach HP_PA HPUX $(CXX) $(CXXFLAGS) -o test_cpp $(srcdir)/tests/test_cpp.cc gc_cpp.o gc.a -ldld `./threadlibs` ./if_not_there test_cpp $(CXX) $(CXXFLAGS) -o test_cpp $(srcdir)/tests/test_cpp.cc gc_cpp.o gc.a `./threadlibs` c++-t: c++ ./test_cpp 1 c++-nt: c++ @echo "Use ./test_cpp 1 to test the leak library" c++: gc_cpp.o $(srcdir)/include/gc_cpp.h test_cpp rm -f dont_ar_4 ./if_mach SPARC SOLARIS touch dont_ar_4 ./if_mach SPARC SOLARIS $(AR) rus gc.a gc_cpp.o ./if_mach M68K AMIGA touch dont_ar_4 ./if_mach M68K AMIGA $(AR) -vrus gc.a gc_cpp.o ./if_not_there dont_ar_4 $(AR) ru gc.a gc_cpp.o ./if_not_there dont_ar_4 $(RANLIB) gc.a || cat /dev/null ./test_cpp 1 echo > c++ dyn_load_sunos53.o: dyn_load.c $(CC) $(CFLAGS) -DSUNOS53_SHARED_LIB -c $(srcdir)/dyn_load.c -o $@ # SunOS5 shared library version of the collector sunos5gc.so: $(OBJS) dyn_load_sunos53.o $(CC) -G -o sunos5gc.so $(OBJS) dyn_load_sunos53.o -ldl ln sunos5gc.so libgc.so # Alpha/OSF shared library version of the collector libalphagc.so: $(OBJS) ld -shared -o libalphagc.so $(OBJS) dyn_load.o -lc ln libalphagc.so libgc.so # IRIX shared library version of the collector libirixgc.so: $(OBJS) dyn_load.o ld -shared $(ABI_FLAG) -o libirixgc.so $(OBJS) dyn_load.o -lc ln libirixgc.so libgc.so # Linux shared library version of the collector liblinuxgc.so: $(OBJS) dyn_load.o gcc -shared -o liblinuxgc.so $(OBJS) dyn_load.o ln liblinuxgc.so libgc.so # Build gctest with dynamic library dyn_test: $(CC) $(CFLAGS) -o gctest tests/test.c libgc.so `./threadlibs` ./gctest # Alternative Linux rule. This is preferable, but is likely to break the # Makefile for some non-linux platforms. # LIBOBJS= $(patsubst %.o, %.lo, $(OBJS)) # #.SUFFIXES: .lo $(SUFFIXES) # #.c.lo: # $(CC) $(CFLAGS) $(CPPFLAGS) -fPIC -c $< -o $@ # # liblinuxgc.so: $(LIBOBJS) dyn_load.lo # gcc -shared -Wl,-soname=libgc.so.0 -o libgc.so.0 $(LIBOBJS) dyn_load.lo # touch liblinuxgc.so mach_dep.o: $(srcdir)/mach_dep.c $(srcdir)/sparc_mach_dep.S \ $(srcdir)/sparc_sunos4_mach_dep.s \ $(srcdir)/ia64_save_regs_in_stack.s \ $(srcdir)/sparc_netbsd_mach_dep.s $(UTILS) rm -f mach_dep.o ./if_mach SPARC SOLARIS $(CC) -c -o mach_dep2.o $(srcdir)/sparc_mach_dep.S ./if_mach SPARC OPENBSD $(AS) -o mach_dep2.o $(srcdir)/sparc_sunos4_mach_dep.s ./if_mach SPARC NETBSD $(AS) -o mach_dep2.o $(srcdir)/sparc_netbsd_mach_dep.s ./if_mach SPARC "" $(CC) -c -o mach_dep1.o $(SPECIALCFLAGS) $(srcdir)/mach_dep.c ./if_mach SPARC "" ld -r -o mach_dep.o mach_dep1.o mach_dep2.o ./if_mach IA64 "" as $(AS_ABI_FLAG) -o ia64_save_regs_in_stack.o $(srcdir)/ia64_save_regs_in_stack.s ./if_mach IA64 "" $(CC) -c -o mach_dep1.o $(SPECIALCFLAGS) $(srcdir)/mach_dep.c ./if_mach IA64 "" ld -r -o mach_dep.o mach_dep1.o ia64_save_regs_in_stack.o ./if_not_there mach_dep.o $(CC) -c $(SPECIALCFLAGS) $(srcdir)/mach_dep.c mark_rts.o: $(srcdir)/mark_rts.c $(UTILS) rm -f mark_rts.o -./if_mach ALPHA OSF1 $(CC) -c $(CFLAGS) -Wo,-notail $(srcdir)/mark_rts.c ./if_not_there mark_rts.o $(CC) -c $(CFLAGS) $(srcdir)/mark_rts.c # Work-around for DEC optimizer tail recursion elimination bug. # The ALPHA-specific line should be removed if gcc is used. alloc.o: include/gc_version.h cord: mkdir cord cord/cordbscs.o: cord $(srcdir)/cord/cordbscs.c $(CORD_INCLUDE_FILES) $(CC) $(CFLAGS) -c -I$(srcdir) $(srcdir)/cord/cordbscs.c mv cordbscs.o cord/cordbscs.o # not all compilers understand -o filename cord/cordxtra.o: cord $(srcdir)/cord/cordxtra.c $(CORD_INCLUDE_FILES) $(CC) $(CFLAGS) -c -I$(srcdir) $(srcdir)/cord/cordxtra.c mv cordxtra.o cord/cordxtra.o cord/cordprnt.o: cord $(srcdir)/cord/cordprnt.c $(CORD_INCLUDE_FILES) $(CC) $(CFLAGS) -c -I$(srcdir) $(srcdir)/cord/cordprnt.c mv cordprnt.o cord/cordprnt.o cord/cordtest: $(srcdir)/cord/tests/cordtest.c $(CORD_OBJS) gc.a $(UTILS) rm -f cord/cordtest ./if_mach SPARC DRSNX $(CC) $(CFLAGS) -o cord/cordtest $(srcdir)/cord/tests/cordtest.c $(CORD_OBJS) gc.a -lucb ./if_mach HP_PA HPUX $(CC) $(CFLAGS) -o cord/cordtest $(srcdir)/cord/tests/cordtest.c $(CORD_OBJS) gc.a -ldld `./threadlibs` ./if_mach M68K AMIGA $(CC) $(CFLAGS) -UGC_AMIGA_MAKINGLIB -o cord/cordtest $(srcdir)/cord/tests/cordtest.c $(CORD_OBJS) gc.a `./threadlibs` ./if_not_there cord/cordtest $(CC) $(CFLAGS) -o cord/cordtest $(srcdir)/cord/tests/cordtest.c $(CORD_OBJS) gc.a `./threadlibs` cord/de: $(srcdir)/cord/tests/de.c cord/cordbscs.o cord/cordxtra.o gc.a $(UTILS) rm -f cord/de ./if_mach SPARC DRSNX $(CC) $(CFLAGS) -o cord/de $(srcdir)/cord/tests/de.c cord/cordbscs.o cord/cordxtra.o gc.a $(CURSES) -lucb `./threadlibs` ./if_mach HP_PA HPUX $(CC) $(CFLAGS) -o cord/de $(srcdir)/cord/tests/de.c cord/cordbscs.o cord/cordxtra.o gc.a $(CURSES) -ldld `./threadlibs` ./if_mach POWERPC AIX $(CC) $(CFLAGS) -o cord/de $(srcdir)/cord/tests/de.c cord/cordbscs.o cord/cordxtra.o gc.a -lcurses ./if_mach POWERPC DARWIN $(CC) $(CFLAGS) -o cord/de $(srcdir)/cord/tests/de.c cord/cordbscs.o cord/cordxtra.o gc.a ./if_mach I386 LINUX $(CC) $(CFLAGS) -o cord/de $(srcdir)/cord/tests/de.c cord/cordbscs.o cord/cordxtra.o gc.a -lcurses `./threadlibs` ./if_mach ALPHA LINUX $(CC) $(CFLAGS) -o cord/de $(srcdir)/cord/tests/de.c cord/cordbscs.o cord/cordxtra.o gc.a -lcurses `./threadlibs` ./if_mach IA64 LINUX $(CC) $(CFLAGS) -o cord/de $(srcdir)/cord/tests/de.c cord/cordbscs.o cord/cordxtra.o gc.a -lcurses `./threadlibs` ./if_mach M68K AMIGA $(CC) $(CFLAGS) -UGC_AMIGA_MAKINGLIB -o cord/de $(srcdir)/cord/tests/de.c cord/cordbscs.o cord/cordxtra.o gc.a -lcurses ./if_not_there cord/de $(CC) $(CFLAGS) -o cord/de $(srcdir)/cord/tests/de.c cord/cordbscs.o cord/cordxtra.o gc.a $(CURSES) `./threadlibs` if_mach: $(srcdir)/tools/if_mach.c $(srcdir)/include/private/gcconfig.h $(HOSTCC) $(HOSTCFLAGS) -o if_mach $(srcdir)/tools/if_mach.c threadlibs: $(srcdir)/tools/threadlibs.c $(srcdir)/include/private/gcconfig.h $(HOSTCC) $(HOSTCFLAGS) -o threadlibs $(srcdir)/tools/threadlibs.c if_not_there: $(srcdir)/tools/if_not_there.c $(HOSTCC) $(HOSTCFLAGS) -o if_not_there $(srcdir)/tools/if_not_there.c clean: rm -f gc.a *.o *.exe tests/*.o gctest gctest_dyn_link test_cpp \ setjmp_test mon.out gmon.out a.out core if_not_there if_mach \ base_lib c++ threadlibs $(CORD_OBJS) cord/cordtest cord/de -rm -f *~ gctest: tests/test.o gc.a $(UTILS) rm -f gctest ./if_mach SPARC DRSNX $(CC) $(CFLAGS) -o gctest tests/test.o gc.a -lucb ./if_mach HP_PA HPUX $(CC) $(CFLAGS) -o gctest tests/test.o gc.a -ldld `./threadlibs` ./if_mach M68K AMIGA $(CC) $(CFLAGS) -UGC_AMIGA_MAKINGLIB -o gctest tests/test.o gc.a `./threadlibs` ./if_not_there gctest $(CC) $(CFLAGS) -o gctest tests/test.o gc.a `./threadlibs` # If an optimized setjmp_test generates a segmentation fault, # odds are your compiler is broken. Gctest may still work. # Try compiling setjmp_t.c unoptimized. setjmp_test: $(srcdir)/tools/setjmp_t.c $(srcdir)/include/gc.h $(UTILS) $(CC) $(CFLAGS) -o setjmp_test $(srcdir)/tools/setjmp_t.c test: KandRtest cord/cordtest cord/cordtest # Those tests that work even with a K&R C compiler: KandRtest: setjmp_test gctest ./setjmp_test ./gctest add_gc_prefix: $(srcdir)/tools/add_gc_prefix.c $(srcdir)/include/gc_version.h $(CC) -o add_gc_prefix $(srcdir)/tools/add_gc_prefix.c gcname: $(srcdir)/tools/gcname.c $(srcdir)/include/gc_version.h $(CC) -o gcname $(srcdir)/tools/gcname.c #We assume this is being done from source directory. dist gc.tar: $(SRCS) $(DOC_FILES) $(OTHER_FILES) add_gc_prefix gcname rm -f `./gcname` ln -s . `./gcname` ./add_gc_prefix $(SRCS) $(DOC_FILES) $(OTHER_FILES) > /tmp/gc.tar-files tar cvfh gc.tar `cat /tmp/gc.tar-files` cp gc.tar `./gcname`.tar gzip `./gcname`.tar rm `./gcname` gc.tar.Z: gc.tar compress gc.tar gc.tar.gz: gc.tar gzip gc.tar lint: $(CSRCS) tests/test.c lint -DLINT $(CSRCS) tests/test.c | egrep -v "possible pointer alignment problem|abort|exit|sbrk|mprotect|syscall|change in ANSI|improper alignment" # BTL: added to test shared library version of collector. # Currently works only under SunOS5. Requires GC_INIT call from statically # loaded client code. ABSDIR = `pwd` gctest_dyn_link: tests/test.o libgc.so $(CC) -L$(ABSDIR) -R$(ABSDIR) -o gctest_dyn_link tests/test.o -lgc -ldl -lthread gctest_irix_dyn_link: tests/test.o libirixgc.so $(CC) -L$(ABSDIR) -o gctest_irix_dyn_link tests/test.o -lirixgc SYM_PREFIX-libgc=GC reserved_namespace: $(SRCS) for file in $(SRCS) tests/test.c tests/test_cpp.cc; do \ sed s/GC_/_GC_/g < $$file > tmp; \ cp tmp $$file; \ done user_namespace: $(SRCS) for file in $(SRCS) tests/test.c tests/test_cpp.cc; do \ sed s/_GC_/GC_/g < $$file > tmp; \ cp tmp $$file; \ done ecl-16.1.2/src/bdwgc/Makefile.in000066400000000000000000003130351266352375300163070ustar00rootroot00000000000000# Makefile.in generated by automake 1.15 from Makefile.am. # @configure_input@ # Copyright (C) 1994-2014 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@ # Copyright (c) 1999-2001 by Red Hat, Inc. All rights reserved. # # THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED # OR IMPLIED. ANY USE IS AT YOUR OWN RISK. # # Permission is hereby granted to use or copy this program # for any purpose, provided the above notices are retained on all copies. # Permission to modify the code and to distribute modified code is granted, # provided the above notices are retained, and a notice that the code was # modified is included with the above copyright notice. # # THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED # OR IMPLIED. ANY USE IS AT YOUR OWN RISK. # # Permission is hereby granted to use or copy this program # for any purpose, provided the above notices are retained on all copies. # Permission to modify the code and to distribute modified code is granted, # provided the above notices are retained, and a notice that the code was # modified is included with the above copyright notice. # # THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED # OR IMPLIED. ANY USE IS AT YOUR OWN RISK. # # Permission is hereby granted to use or copy this program # for any purpose, provided the above notices are retained on all copies. # Permission to modify the code and to distribute modified code is granted, # provided the above notices are retained, and a notice that the code was # modified is included with the above copyright notice. # # THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED # OR IMPLIED. ANY USE IS AT YOUR OWN RISK. # # Permission is hereby granted to use or copy this program # for any purpose, provided the above notices are retained on all copies. # Permission to modify the code and to distribute modified code is granted, # provided the above notices are retained, and a notice that the code was # modified is included with the above copyright notice. VPATH = @srcdir@ am__is_gnu_make = { \ if test -z '$(MAKELEVEL)'; then \ false; \ elif test -n '$(MAKE_HOST)'; then \ true; \ elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \ true; \ else \ false; \ fi; \ } am__make_running_with_option = \ case $${target_option-} in \ ?) ;; \ *) echo "am__make_running_with_option: internal error: invalid" \ "target option '$${target_option-}' specified" >&2; \ exit 1;; \ esac; \ has_opt=no; \ sane_makeflags=$$MAKEFLAGS; \ if $(am__is_gnu_make); then \ sane_makeflags=$$MFLAGS; \ else \ case $$MAKEFLAGS in \ *\\[\ \ ]*) \ bs=\\; \ sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \ | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \ esac; \ fi; \ skip_next=no; \ strip_trailopt () \ { \ flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \ }; \ for flg in $$sane_makeflags; do \ test $$skip_next = yes && { skip_next=no; continue; }; \ case $$flg in \ *=*|--*) continue;; \ -*I) strip_trailopt 'I'; skip_next=yes;; \ -*I?*) strip_trailopt 'I';; \ -*O) strip_trailopt 'O'; skip_next=yes;; \ -*O?*) strip_trailopt 'O';; \ -*l) strip_trailopt 'l'; skip_next=yes;; \ -*l?*) strip_trailopt 'l';; \ -[dEDm]) skip_next=yes;; \ -[JT]) skip_next=yes;; \ esac; \ case $$flg in \ *$$target_option*) has_opt=yes; break;; \ esac; \ done; \ test $$has_opt = yes am__make_dryrun = (target_option=n; $(am__make_running_with_option)) am__make_keepgoing = (target_option=k; $(am__make_running_with_option)) 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@ target_triplet = @target@ check_PROGRAMS = cordtest$(EXEEXT) gctest$(EXEEXT) leaktest$(EXEEXT) \ middletest$(EXEEXT) smashtest$(EXEEXT) hugetest$(EXEEXT) \ realloc_test$(EXEEXT) staticrootstest$(EXEEXT) $(am__EXEEXT_1) \ $(am__EXEEXT_2) $(am__EXEEXT_3) $(am__EXEEXT_4) TESTS = cordtest$(EXEEXT) gctest$(EXEEXT) leaktest$(EXEEXT) \ middletest$(EXEEXT) smashtest$(EXEEXT) hugetest$(EXEEXT) \ realloc_test$(EXEEXT) staticrootstest$(EXEEXT) \ $(am__append_12) $(am__append_14) $(am__append_16) \ $(am__EXEEXT_4) @SINGLE_GC_OBJ_FALSE@am__append_1 = extra/gc.c # C Library: Architecture Dependent # --------------------------------- @SINGLE_GC_OBJ_FALSE@@WIN32_THREADS_TRUE@am__append_2 = win32_threads.c @PTHREADS_TRUE@@SINGLE_GC_OBJ_FALSE@@WIN32_THREADS_FALSE@am__append_3 = pthread_start.c pthread_support.c @DARWIN_THREADS_TRUE@@PTHREADS_TRUE@@SINGLE_GC_OBJ_FALSE@@WIN32_THREADS_FALSE@am__append_4 = darwin_stop_world.c @DARWIN_THREADS_FALSE@@PTHREADS_TRUE@@SINGLE_GC_OBJ_FALSE@@WIN32_THREADS_FALSE@am__append_5 = pthread_stop_world.c @MAKE_BACK_GRAPH_TRUE@@SINGLE_GC_OBJ_FALSE@am__append_6 = backgraph.c @ENABLE_DISCLAIM_TRUE@@SINGLE_GC_OBJ_FALSE@am__append_7 = fnlz_mlc.c # C++ Interface # ------------- @CPLUSPLUS_TRUE@am__append_8 = libgccpp.la @CPLUSPLUS_TRUE@am__append_9 = include/gc_cpp.h @CPLUSPLUS_TRUE@am__append_10 = include/extra/gc_cpp.h @THREADS_TRUE@am__append_11 = $(THREADDLLIBS) @KEEP_BACK_PTRS_TRUE@am__append_12 = tracetest$(EXEEXT) @KEEP_BACK_PTRS_TRUE@am__append_13 = tracetest @THREADS_TRUE@am__append_14 = threadleaktest$(EXEEXT) \ @THREADS_TRUE@ threadkey_test$(EXEEXT) \ @THREADS_TRUE@ subthreadcreate_test$(EXEEXT) \ @THREADS_TRUE@ initsecondarythread_test$(EXEEXT) @THREADS_TRUE@am__append_15 = threadleaktest threadkey_test \ @THREADS_TRUE@ subthreadcreate_test initsecondarythread_test @CPLUSPLUS_TRUE@am__append_16 = test_cpp$(EXEEXT) @CPLUSPLUS_TRUE@am__append_17 = test_cpp @ENABLE_DISCLAIM_TRUE@am__append_18 = disclaim_test disclaim_bench @ENABLE_DISCLAIM_TRUE@am__append_19 = disclaim_test disclaim_bench @ENABLE_DISCLAIM_TRUE@@THREADS_TRUE@am__append_20 = $(THREADDLLIBS) subdir = . 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) DIST_COMMON = $(srcdir)/Makefile.am $(top_srcdir)/configure \ $(am__configure_deps) $(dist_pkgdata_DATA) \ $(dist_noinst_HEADERS) $(am__include_HEADERS_DIST) \ $(am__pkginclude_HEADERS_DIST) $(am__DIST_COMMON) am__CONFIG_DISTCLEAN_FILES = config.status config.cache config.log \ configure.lineno config.status.lineno mkinstalldirs = $(install_sh) -d CONFIG_HEADER = $(top_builddir)/include/config.h CONFIG_CLEAN_FILES = bdw-gc.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)$(pkgdatadir)" \ "$(DESTDIR)$(pkgconfigdir)" "$(DESTDIR)$(includedir)" \ "$(DESTDIR)$(pkgincludedir)" LTLIBRARIES = $(lib_LTLIBRARIES) libcord_la_DEPENDENCIES = $(top_builddir)/libgc.la am__dirstamp = $(am__leading_dot)dirstamp am_libcord_la_OBJECTS = cord/libcord_la-cordbscs.lo \ cord/libcord_la-cordprnt.lo cord/libcord_la-cordxtra.lo libcord_la_OBJECTS = $(am_libcord_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 = libcord_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \ $(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \ $(libcord_la_LDFLAGS) $(LDFLAGS) -o $@ am__DEPENDENCIES_1 = am__libgc_la_SOURCES_DIST = allchblk.c alloc.c blacklst.c checksums.c \ dbg_mlc.c dyn_load.c finalize.c gc_dlopen.c gcj_mlc.c \ headers.c mach_dep.c malloc.c mallocx.c mark.c mark_rts.c \ misc.c new_hblk.c obj_map.c os_dep.c pcr_interface.c \ ptr_chck.c real_malloc.c reclaim.c specific.c stubborn.c \ thread_local_alloc.c typd_mlc.c win32_threads.c \ pthread_start.c pthread_support.c darwin_stop_world.c \ pthread_stop_world.c backgraph.c fnlz_mlc.c extra/gc.c @SINGLE_GC_OBJ_FALSE@@WIN32_THREADS_TRUE@am__objects_1 = \ @SINGLE_GC_OBJ_FALSE@@WIN32_THREADS_TRUE@ win32_threads.lo @PTHREADS_TRUE@@SINGLE_GC_OBJ_FALSE@@WIN32_THREADS_FALSE@am__objects_2 = pthread_start.lo \ @PTHREADS_TRUE@@SINGLE_GC_OBJ_FALSE@@WIN32_THREADS_FALSE@ pthread_support.lo @DARWIN_THREADS_TRUE@@PTHREADS_TRUE@@SINGLE_GC_OBJ_FALSE@@WIN32_THREADS_FALSE@am__objects_3 = darwin_stop_world.lo @DARWIN_THREADS_FALSE@@PTHREADS_TRUE@@SINGLE_GC_OBJ_FALSE@@WIN32_THREADS_FALSE@am__objects_4 = pthread_stop_world.lo @MAKE_BACK_GRAPH_TRUE@@SINGLE_GC_OBJ_FALSE@am__objects_5 = \ @MAKE_BACK_GRAPH_TRUE@@SINGLE_GC_OBJ_FALSE@ backgraph.lo @ENABLE_DISCLAIM_TRUE@@SINGLE_GC_OBJ_FALSE@am__objects_6 = \ @ENABLE_DISCLAIM_TRUE@@SINGLE_GC_OBJ_FALSE@ fnlz_mlc.lo @SINGLE_GC_OBJ_FALSE@am_libgc_la_OBJECTS = allchblk.lo alloc.lo \ @SINGLE_GC_OBJ_FALSE@ blacklst.lo checksums.lo dbg_mlc.lo \ @SINGLE_GC_OBJ_FALSE@ dyn_load.lo finalize.lo gc_dlopen.lo \ @SINGLE_GC_OBJ_FALSE@ gcj_mlc.lo headers.lo mach_dep.lo \ @SINGLE_GC_OBJ_FALSE@ malloc.lo mallocx.lo mark.lo mark_rts.lo \ @SINGLE_GC_OBJ_FALSE@ misc.lo new_hblk.lo obj_map.lo os_dep.lo \ @SINGLE_GC_OBJ_FALSE@ pcr_interface.lo ptr_chck.lo \ @SINGLE_GC_OBJ_FALSE@ real_malloc.lo reclaim.lo specific.lo \ @SINGLE_GC_OBJ_FALSE@ stubborn.lo thread_local_alloc.lo \ @SINGLE_GC_OBJ_FALSE@ typd_mlc.lo $(am__objects_1) \ @SINGLE_GC_OBJ_FALSE@ $(am__objects_2) $(am__objects_3) \ @SINGLE_GC_OBJ_FALSE@ $(am__objects_4) $(am__objects_5) \ @SINGLE_GC_OBJ_FALSE@ $(am__objects_6) @SINGLE_GC_OBJ_TRUE@am_libgc_la_OBJECTS = extra/gc.lo $(am__objects_1) \ @SINGLE_GC_OBJ_TRUE@ $(am__objects_2) $(am__objects_3) \ @SINGLE_GC_OBJ_TRUE@ $(am__objects_4) $(am__objects_5) \ @SINGLE_GC_OBJ_TRUE@ $(am__objects_6) @NEED_ATOMIC_OPS_ASM_FALSE@@USE_INTERNAL_LIBATOMIC_OPS_TRUE@nodist_libgc_la_OBJECTS = libatomic_ops/src/atomic_ops.lo @NEED_ATOMIC_OPS_ASM_TRUE@nodist_libgc_la_OBJECTS = libatomic_ops/src/atomic_ops_sysdeps.lo libgc_la_OBJECTS = $(am_libgc_la_OBJECTS) $(nodist_libgc_la_OBJECTS) libgc_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \ $(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \ $(libgc_la_LDFLAGS) $(LDFLAGS) -o $@ @CPLUSPLUS_TRUE@libgccpp_la_DEPENDENCIES = ./libgc.la am__libgccpp_la_SOURCES_DIST = gc_cpp.cc @CPLUSPLUS_TRUE@am_libgccpp_la_OBJECTS = gc_cpp.lo libgccpp_la_OBJECTS = $(am_libgccpp_la_OBJECTS) libgccpp_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \ $(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \ $(CXXFLAGS) $(libgccpp_la_LDFLAGS) $(LDFLAGS) -o $@ @CPLUSPLUS_TRUE@am_libgccpp_la_rpath = -rpath $(libdir) am__DEPENDENCIES_2 = $(top_builddir)/libgc.la $(am__DEPENDENCIES_1) libstaticrootslib2_test_la_DEPENDENCIES = $(am__DEPENDENCIES_2) am_libstaticrootslib2_test_la_OBJECTS = \ tests/libstaticrootslib2_test_la-staticrootslib.lo libstaticrootslib2_test_la_OBJECTS = \ $(am_libstaticrootslib2_test_la_OBJECTS) libstaticrootslib2_test_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC \ $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CCLD) \ $(libstaticrootslib2_test_la_CFLAGS) $(CFLAGS) \ $(libstaticrootslib2_test_la_LDFLAGS) $(LDFLAGS) -o $@ am_libstaticrootslib_test_la_OBJECTS = tests/staticrootslib.lo libstaticrootslib_test_la_OBJECTS = \ $(am_libstaticrootslib_test_la_OBJECTS) libstaticrootslib_test_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC \ $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CCLD) \ $(AM_CFLAGS) $(CFLAGS) $(libstaticrootslib_test_la_LDFLAGS) \ $(LDFLAGS) -o $@ @KEEP_BACK_PTRS_TRUE@am__EXEEXT_1 = tracetest$(EXEEXT) @THREADS_TRUE@am__EXEEXT_2 = threadleaktest$(EXEEXT) \ @THREADS_TRUE@ threadkey_test$(EXEEXT) \ @THREADS_TRUE@ subthreadcreate_test$(EXEEXT) \ @THREADS_TRUE@ initsecondarythread_test$(EXEEXT) @CPLUSPLUS_TRUE@am__EXEEXT_3 = test_cpp$(EXEEXT) @ENABLE_DISCLAIM_TRUE@am__EXEEXT_4 = disclaim_test$(EXEEXT) \ @ENABLE_DISCLAIM_TRUE@ disclaim_bench$(EXEEXT) am_cordtest_OBJECTS = cord/tests/cordtest.$(OBJEXT) cordtest_OBJECTS = $(am_cordtest_OBJECTS) cordtest_DEPENDENCIES = $(top_builddir)/libgc.la \ $(top_builddir)/libcord.la am__disclaim_bench_SOURCES_DIST = tests/disclaim_bench.c @ENABLE_DISCLAIM_TRUE@am_disclaim_bench_OBJECTS = \ @ENABLE_DISCLAIM_TRUE@ tests/disclaim_bench.$(OBJEXT) disclaim_bench_OBJECTS = $(am_disclaim_bench_OBJECTS) @ENABLE_DISCLAIM_TRUE@disclaim_bench_DEPENDENCIES = \ @ENABLE_DISCLAIM_TRUE@ $(am__DEPENDENCIES_2) am__disclaim_test_SOURCES_DIST = tests/disclaim_test.c @ENABLE_DISCLAIM_TRUE@am_disclaim_test_OBJECTS = \ @ENABLE_DISCLAIM_TRUE@ tests/disclaim_test.$(OBJEXT) disclaim_test_OBJECTS = $(am_disclaim_test_OBJECTS) @ENABLE_DISCLAIM_TRUE@@THREADS_TRUE@am__DEPENDENCIES_3 = \ @ENABLE_DISCLAIM_TRUE@@THREADS_TRUE@ $(am__DEPENDENCIES_1) @ENABLE_DISCLAIM_TRUE@disclaim_test_DEPENDENCIES = \ @ENABLE_DISCLAIM_TRUE@ $(am__DEPENDENCIES_2) \ @ENABLE_DISCLAIM_TRUE@ $(am__DEPENDENCIES_3) am_gctest_OBJECTS = tests/test.$(OBJEXT) gctest_OBJECTS = $(am_gctest_OBJECTS) @THREADS_TRUE@am__DEPENDENCIES_4 = $(am__DEPENDENCIES_1) am_hugetest_OBJECTS = tests/huge_test.$(OBJEXT) hugetest_OBJECTS = $(am_hugetest_OBJECTS) hugetest_DEPENDENCIES = $(am__DEPENDENCIES_2) am__initsecondarythread_test_SOURCES_DIST = \ tests/initsecondarythread.c @THREADS_TRUE@am_initsecondarythread_test_OBJECTS = \ @THREADS_TRUE@ tests/initsecondarythread.$(OBJEXT) initsecondarythread_test_OBJECTS = \ $(am_initsecondarythread_test_OBJECTS) @THREADS_TRUE@initsecondarythread_test_DEPENDENCIES = \ @THREADS_TRUE@ $(am__DEPENDENCIES_2) $(am__DEPENDENCIES_1) am_leaktest_OBJECTS = tests/leak_test.$(OBJEXT) leaktest_OBJECTS = $(am_leaktest_OBJECTS) leaktest_DEPENDENCIES = $(am__DEPENDENCIES_2) am_middletest_OBJECTS = tests/middle.$(OBJEXT) middletest_OBJECTS = $(am_middletest_OBJECTS) middletest_DEPENDENCIES = $(am__DEPENDENCIES_2) am_realloc_test_OBJECTS = tests/realloc_test.$(OBJEXT) realloc_test_OBJECTS = $(am_realloc_test_OBJECTS) realloc_test_DEPENDENCIES = $(am__DEPENDENCIES_2) am_smashtest_OBJECTS = tests/smash_test.$(OBJEXT) smashtest_OBJECTS = $(am_smashtest_OBJECTS) smashtest_DEPENDENCIES = $(am__DEPENDENCIES_2) am_staticrootstest_OBJECTS = \ tests/staticrootstest-staticrootstest.$(OBJEXT) staticrootstest_OBJECTS = $(am_staticrootstest_OBJECTS) staticrootstest_DEPENDENCIES = $(am__DEPENDENCIES_2) \ libstaticrootslib_test.la libstaticrootslib2_test.la staticrootstest_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC \ $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CCLD) \ $(staticrootstest_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) $(LDFLAGS) \ -o $@ am__subthreadcreate_test_SOURCES_DIST = tests/subthread_create.c @THREADS_TRUE@am_subthreadcreate_test_OBJECTS = \ @THREADS_TRUE@ tests/subthread_create.$(OBJEXT) subthreadcreate_test_OBJECTS = $(am_subthreadcreate_test_OBJECTS) @THREADS_TRUE@subthreadcreate_test_DEPENDENCIES = \ @THREADS_TRUE@ $(am__DEPENDENCIES_2) $(am__DEPENDENCIES_1) am__test_cpp_SOURCES_DIST = tests/test_cpp.cc @CPLUSPLUS_TRUE@am_test_cpp_OBJECTS = tests/test_cpp.$(OBJEXT) test_cpp_OBJECTS = $(am_test_cpp_OBJECTS) @AVOID_CPP_LIB_FALSE@@CPLUSPLUS_TRUE@test_cpp_DEPENDENCIES = \ @AVOID_CPP_LIB_FALSE@@CPLUSPLUS_TRUE@ libgccpp.la \ @AVOID_CPP_LIB_FALSE@@CPLUSPLUS_TRUE@ $(am__DEPENDENCIES_2) \ @AVOID_CPP_LIB_FALSE@@CPLUSPLUS_TRUE@ $(am__DEPENDENCIES_1) @AVOID_CPP_LIB_TRUE@@CPLUSPLUS_TRUE@test_cpp_DEPENDENCIES = gc_cpp.o \ @AVOID_CPP_LIB_TRUE@@CPLUSPLUS_TRUE@ $(am__DEPENDENCIES_2) \ @AVOID_CPP_LIB_TRUE@@CPLUSPLUS_TRUE@ $(am__DEPENDENCIES_1) am__threadkey_test_SOURCES_DIST = tests/threadkey_test.c @THREADS_TRUE@am_threadkey_test_OBJECTS = \ @THREADS_TRUE@ tests/threadkey_test.$(OBJEXT) threadkey_test_OBJECTS = $(am_threadkey_test_OBJECTS) @THREADS_TRUE@threadkey_test_DEPENDENCIES = $(am__DEPENDENCIES_2) \ @THREADS_TRUE@ $(am__DEPENDENCIES_1) am__threadleaktest_SOURCES_DIST = tests/thread_leak_test.c @THREADS_TRUE@am_threadleaktest_OBJECTS = \ @THREADS_TRUE@ tests/thread_leak_test.$(OBJEXT) threadleaktest_OBJECTS = $(am_threadleaktest_OBJECTS) @THREADS_TRUE@threadleaktest_DEPENDENCIES = $(am__DEPENDENCIES_2) \ @THREADS_TRUE@ $(am__DEPENDENCIES_1) am__tracetest_SOURCES_DIST = tests/trace_test.c @KEEP_BACK_PTRS_TRUE@am_tracetest_OBJECTS = \ @KEEP_BACK_PTRS_TRUE@ tests/trace_test.$(OBJEXT) tracetest_OBJECTS = $(am_tracetest_OBJECTS) @KEEP_BACK_PTRS_TRUE@tracetest_DEPENDENCIES = $(am__DEPENDENCIES_2) 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 = depcomp = $(SHELL) $(top_srcdir)/depcomp am__depfiles_maybe = depfiles am__mv = mv -f CPPASCOMPILE = $(CCAS) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \ $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CCASFLAGS) $(CCASFLAGS) LTCPPASCOMPILE = $(LIBTOOL) $(AM_V_lt) $(AM_LIBTOOLFLAGS) \ $(LIBTOOLFLAGS) --mode=compile $(CCAS) $(DEFS) \ $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \ $(AM_CCASFLAGS) $(CCASFLAGS) AM_V_CPPAS = $(am__v_CPPAS_@AM_V@) am__v_CPPAS_ = $(am__v_CPPAS_@AM_DEFAULT_V@) am__v_CPPAS_0 = @echo " CPPAS " $@; am__v_CPPAS_1 = COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \ $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) LTCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \ $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) \ $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \ $(AM_CFLAGS) $(CFLAGS) AM_V_CC = $(am__v_CC_@AM_V@) am__v_CC_ = $(am__v_CC_@AM_DEFAULT_V@) am__v_CC_0 = @echo " CC " $@; am__v_CC_1 = CCLD = $(CC) LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \ $(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \ $(AM_LDFLAGS) $(LDFLAGS) -o $@ AM_V_CCLD = $(am__v_CCLD_@AM_V@) am__v_CCLD_ = $(am__v_CCLD_@AM_DEFAULT_V@) am__v_CCLD_0 = @echo " CCLD " $@; am__v_CCLD_1 = 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 = CCASCOMPILE = $(CCAS) $(AM_CCASFLAGS) $(CCASFLAGS) LTCCASCOMPILE = $(LIBTOOL) $(AM_V_lt) $(AM_LIBTOOLFLAGS) \ $(LIBTOOLFLAGS) --mode=compile $(CCAS) $(AM_CCASFLAGS) \ $(CCASFLAGS) AM_V_CCAS = $(am__v_CCAS_@AM_V@) am__v_CCAS_ = $(am__v_CCAS_@AM_DEFAULT_V@) am__v_CCAS_0 = @echo " CCAS " $@; am__v_CCAS_1 = SOURCES = $(libcord_la_SOURCES) $(libgc_la_SOURCES) \ $(EXTRA_libgc_la_SOURCES) $(nodist_libgc_la_SOURCES) \ $(libgccpp_la_SOURCES) $(libstaticrootslib2_test_la_SOURCES) \ $(libstaticrootslib_test_la_SOURCES) $(cordtest_SOURCES) \ $(disclaim_bench_SOURCES) $(disclaim_test_SOURCES) \ $(gctest_SOURCES) $(hugetest_SOURCES) \ $(initsecondarythread_test_SOURCES) $(leaktest_SOURCES) \ $(middletest_SOURCES) $(realloc_test_SOURCES) \ $(smashtest_SOURCES) $(staticrootstest_SOURCES) \ $(subthreadcreate_test_SOURCES) $(test_cpp_SOURCES) \ $(threadkey_test_SOURCES) $(threadleaktest_SOURCES) \ $(tracetest_SOURCES) DIST_SOURCES = $(libcord_la_SOURCES) $(am__libgc_la_SOURCES_DIST) \ $(EXTRA_libgc_la_SOURCES) $(am__libgccpp_la_SOURCES_DIST) \ $(libstaticrootslib2_test_la_SOURCES) \ $(libstaticrootslib_test_la_SOURCES) $(cordtest_SOURCES) \ $(am__disclaim_bench_SOURCES_DIST) \ $(am__disclaim_test_SOURCES_DIST) $(gctest_SOURCES) \ $(hugetest_SOURCES) \ $(am__initsecondarythread_test_SOURCES_DIST) \ $(leaktest_SOURCES) $(middletest_SOURCES) \ $(realloc_test_SOURCES) $(smashtest_SOURCES) \ $(staticrootstest_SOURCES) \ $(am__subthreadcreate_test_SOURCES_DIST) \ $(am__test_cpp_SOURCES_DIST) \ $(am__threadkey_test_SOURCES_DIST) \ $(am__threadleaktest_SOURCES_DIST) \ $(am__tracetest_SOURCES_DIST) RECURSIVE_TARGETS = all-recursive check-recursive cscopelist-recursive \ ctags-recursive dvi-recursive html-recursive info-recursive \ install-data-recursive install-dvi-recursive \ install-exec-recursive install-html-recursive \ install-info-recursive install-pdf-recursive \ install-ps-recursive install-recursive installcheck-recursive \ installdirs-recursive pdf-recursive ps-recursive \ tags-recursive uninstall-recursive am__can_run_installinfo = \ case $$AM_UPDATE_INFO_DIR in \ n|no|NO) false;; \ *) (install-info --version) >/dev/null 2>&1;; \ esac DATA = $(dist_pkgdata_DATA) $(pkgconfig_DATA) am__include_HEADERS_DIST = include/extra/gc_cpp.h include/extra/gc.h am__pkginclude_HEADERS_DIST = include/gc_cpp.h include/gc.h \ include/gc_allocator.h include/gc_backptr.h \ include/gc_config_macros.h include/gc_disclaim.h \ include/gc_gcj.h include/gc_inline.h include/gc_mark.h \ include/gc_pthread_redirects.h include/gc_tiny_fl.h \ include/gc_typed.h include/gc_version.h include/javaxfc.h \ include/leak_detector.h include/weakpointer.h include/cord.h \ include/cord_pos.h include/ec.h HEADERS = $(dist_noinst_HEADERS) $(include_HEADERS) \ $(pkginclude_HEADERS) RECURSIVE_CLEAN_TARGETS = mostlyclean-recursive clean-recursive \ distclean-recursive maintainer-clean-recursive am__recursive_targets = \ $(RECURSIVE_TARGETS) \ $(RECURSIVE_CLEAN_TARGETS) \ $(am__extra_recursive_targets) AM_RECURSIVE_TARGETS = $(am__recursive_targets:-recursive=) TAGS CTAGS \ cscope check recheck distdir dist dist-all distcheck am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP) # Read a list of newline-separated strings from the standard input, # and print each of them once, without duplicates. Input order is # *not* preserved. am__uniquify_input = $(AWK) '\ BEGIN { nonempty = 0; } \ { items[$$0] = 1; nonempty = 1; } \ END { if (nonempty) { for (i in items) print i; }; } \ ' # Make sure the list of sources is unique. This is necessary because, # e.g., the same source file might be shared among _SOURCES variables # for different programs/libraries. am__define_uniq_tagged_files = \ list='$(am__tagged_files)'; \ unique=`for i in $$list; do \ if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ done | $(am__uniquify_input)` ETAGS = etags CTAGS = ctags CSCOPE = cscope am__tty_colors_dummy = \ mgn= red= grn= lgn= blu= brg= std=; \ am__color_tests=no am__tty_colors = { \ $(am__tty_colors_dummy); \ if test "X$(AM_COLOR_TESTS)" = Xno; then \ am__color_tests=no; \ elif test "X$(AM_COLOR_TESTS)" = Xalways; then \ am__color_tests=yes; \ elif test "X$$TERM" != Xdumb && { test -t 1; } 2>/dev/null; then \ am__color_tests=yes; \ fi; \ if test $$am__color_tests = yes; then \ red=''; \ grn=''; \ lgn=''; \ blu=''; \ mgn=''; \ brg=''; \ std=''; \ fi; \ } am__recheck_rx = ^[ ]*:recheck:[ ]* am__global_test_result_rx = ^[ ]*:global-test-result:[ ]* am__copy_in_global_log_rx = ^[ ]*:copy-in-global-log:[ ]* # A command that, given a newline-separated list of test names on the # standard input, print the name of the tests that are to be re-run # upon "make recheck". am__list_recheck_tests = $(AWK) '{ \ recheck = 1; \ while ((rc = (getline line < ($$0 ".trs"))) != 0) \ { \ if (rc < 0) \ { \ if ((getline line2 < ($$0 ".log")) < 0) \ recheck = 0; \ break; \ } \ else if (line ~ /$(am__recheck_rx)[nN][Oo]/) \ { \ recheck = 0; \ break; \ } \ else if (line ~ /$(am__recheck_rx)[yY][eE][sS]/) \ { \ break; \ } \ }; \ if (recheck) \ print $$0; \ close ($$0 ".trs"); \ close ($$0 ".log"); \ }' # A command that, given a newline-separated list of test names on the # standard input, create the global log from their .trs and .log files. am__create_global_log = $(AWK) ' \ function fatal(msg) \ { \ print "fatal: making $@: " msg | "cat >&2"; \ exit 1; \ } \ function rst_section(header) \ { \ print header; \ len = length(header); \ for (i = 1; i <= len; i = i + 1) \ printf "="; \ printf "\n\n"; \ } \ { \ copy_in_global_log = 1; \ global_test_result = "RUN"; \ while ((rc = (getline line < ($$0 ".trs"))) != 0) \ { \ if (rc < 0) \ fatal("failed to read from " $$0 ".trs"); \ if (line ~ /$(am__global_test_result_rx)/) \ { \ sub("$(am__global_test_result_rx)", "", line); \ sub("[ ]*$$", "", line); \ global_test_result = line; \ } \ else if (line ~ /$(am__copy_in_global_log_rx)[nN][oO]/) \ copy_in_global_log = 0; \ }; \ if (copy_in_global_log) \ { \ rst_section(global_test_result ": " $$0); \ while ((rc = (getline line < ($$0 ".log"))) != 0) \ { \ if (rc < 0) \ fatal("failed to read from " $$0 ".log"); \ print line; \ }; \ printf "\n"; \ }; \ close ($$0 ".trs"); \ close ($$0 ".log"); \ }' # Restructured Text title. am__rst_title = { sed 's/.*/ & /;h;s/./=/g;p;x;s/ *$$//;p;g' && echo; } # Solaris 10 'make', and several other traditional 'make' implementations, # pass "-e" to $(SHELL), and POSIX 2008 even requires this. Work around it # by disabling -e (using the XSI extension "set +e") if it's set. am__sh_e_setup = case $$- in *e*) set +e;; esac # Default flags passed to test drivers. am__common_driver_flags = \ --color-tests "$$am__color_tests" \ --enable-hard-errors "$$am__enable_hard_errors" \ --expect-failure "$$am__expect_failure" # To be inserted before the command running the test. Creates the # directory for the log if needed. Stores in $dir the directory # containing $f, in $tst the test, in $log the log. Executes the # developer- defined test setup AM_TESTS_ENVIRONMENT (if any), and # passes TESTS_ENVIRONMENT. Set up options for the wrapper that # will run the test scripts (or their associated LOG_COMPILER, if # thy have one). am__check_pre = \ $(am__sh_e_setup); \ $(am__vpath_adj_setup) $(am__vpath_adj) \ $(am__tty_colors); \ srcdir=$(srcdir); export srcdir; \ case "$@" in \ */*) am__odir=`echo "./$@" | sed 's|/[^/]*$$||'`;; \ *) am__odir=.;; \ esac; \ test "x$$am__odir" = x"." || test -d "$$am__odir" \ || $(MKDIR_P) "$$am__odir" || exit $$?; \ if test -f "./$$f"; then dir=./; \ elif test -f "$$f"; then dir=; \ else dir="$(srcdir)/"; fi; \ tst=$$dir$$f; log='$@'; \ if test -n '$(DISABLE_HARD_ERRORS)'; then \ am__enable_hard_errors=no; \ else \ am__enable_hard_errors=yes; \ fi; \ case " $(XFAIL_TESTS) " in \ *[\ \ ]$$f[\ \ ]* | *[\ \ ]$$dir$$f[\ \ ]*) \ am__expect_failure=yes;; \ *) \ am__expect_failure=no;; \ esac; \ $(AM_TESTS_ENVIRONMENT) $(TESTS_ENVIRONMENT) # A shell command to get the names of the tests scripts with any registered # extension removed (i.e., equivalently, the names of the test logs, with # the '.log' extension removed). The result is saved in the shell variable # '$bases'. This honors runtime overriding of TESTS and TEST_LOGS. Sadly, # we cannot use something simpler, involving e.g., "$(TEST_LOGS:.log=)", # since that might cause problem with VPATH rewrites for suffix-less tests. # See also 'test-harness-vpath-rewrite.sh' and 'test-trs-basic.sh'. am__set_TESTS_bases = \ bases='$(TEST_LOGS)'; \ bases=`for i in $$bases; do echo $$i; done | sed 's/\.log$$//'`; \ bases=`echo $$bases` RECHECK_LOGS = $(TEST_LOGS) TEST_SUITE_LOG = test-suite.log TEST_EXTENSIONS = @EXEEXT@ .test LOG_DRIVER = $(SHELL) $(top_srcdir)/test-driver LOG_COMPILE = $(LOG_COMPILER) $(AM_LOG_FLAGS) $(LOG_FLAGS) am__set_b = \ case '$@' in \ */*) \ case '$*' in \ */*) b='$*';; \ *) b=`echo '$@' | sed 's/\.log$$//'`; \ esac;; \ *) \ b='$*';; \ esac am__test_logs1 = $(TESTS:=.log) am__test_logs2 = $(am__test_logs1:@EXEEXT@.log=.log) TEST_LOGS = $(am__test_logs2:.test.log=.log) TEST_LOG_DRIVER = $(SHELL) $(top_srcdir)/test-driver TEST_LOG_COMPILE = $(TEST_LOG_COMPILER) $(AM_TEST_LOG_FLAGS) \ $(TEST_LOG_FLAGS) DIST_SUBDIRS = $(SUBDIRS) am__DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/bdw-gc.pc.in \ $(srcdir)/cord/cord.am $(srcdir)/doc/doc.am \ $(srcdir)/include/include.am $(srcdir)/tests/tests.am \ $(top_srcdir)/include/config.h.in AUTHORS ChangeLog TODO \ compile config.guess config.sub depcomp install-sh ltmain.sh \ missing test-driver 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) am__relativize = \ dir0=`pwd`; \ sed_first='s,^\([^/]*\)/.*$$,\1,'; \ sed_rest='s,^[^/]*/*,,'; \ sed_last='s,^.*/\([^/]*\)$$,\1,'; \ sed_butlast='s,/*[^/]*$$,,'; \ while test -n "$$dir1"; do \ first=`echo "$$dir1" | sed -e "$$sed_first"`; \ if test "$$first" != "."; then \ if test "$$first" = ".."; then \ dir2=`echo "$$dir0" | sed -e "$$sed_last"`/"$$dir2"; \ dir0=`echo "$$dir0" | sed -e "$$sed_butlast"`; \ else \ first2=`echo "$$dir2" | sed -e "$$sed_first"`; \ if test "$$first2" = "$$first"; then \ dir2=`echo "$$dir2" | sed -e "$$sed_rest"`; \ else \ dir2="../$$dir2"; \ fi; \ dir0="$$dir0"/"$$first"; \ fi; \ fi; \ dir1=`echo "$$dir1" | sed -e "$$sed_rest"`; \ done; \ reldir="$$dir2" DIST_ARCHIVES = $(distdir).tar.gz $(distdir).tar.bz2 GZIP_ENV = --best DIST_TARGETS = dist-bzip2 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_CFLAGS = @GC_CFLAGS@ AM_CPPFLAGS = \ -I$(top_builddir)/include -I$(top_srcdir)/include \ $(ATOMIC_OPS_CFLAGS) AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@ AR = @AR@ ATOMIC_OPS_CFLAGS = @ATOMIC_OPS_CFLAGS@ ATOMIC_OPS_LIBS = @ATOMIC_OPS_LIBS@ AUTOCONF = @AUTOCONF@ AUTOHEADER = @AUTOHEADER@ AUTOMAKE = @AUTOMAKE@ AWK = @AWK@ CC = @CC@ CCAS = @CCAS@ CCASDEPMODE = @CCASDEPMODE@ CCASFLAGS = @CCASFLAGS@ $(DEFS) CCDEPMODE = @CCDEPMODE@ CFLAGS = @CFLAGS@ CPP = @CPP@ CPPFLAGS = @CPPFLAGS@ CXX = @CXX@ CXXCPP = @CXXCPP@ CXXDEPMODE = @CXXDEPMODE@ CXXFLAGS = @CXXFLAGS@ CXXLIBS = @CXXLIBS@ 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@ EXTRA_TEST_LIBS = @EXTRA_TEST_LIBS@ FGREP = @FGREP@ GC_CFLAGS = @GC_CFLAGS@ GC_VERSION = @GC_VERSION@ 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@ LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@ 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@ PKG_CONFIG = @PKG_CONFIG@ PKG_CONFIG_LIBDIR = @PKG_CONFIG_LIBDIR@ PKG_CONFIG_PATH = @PKG_CONFIG_PATH@ RANLIB = @RANLIB@ SED = @SED@ SET_MAKE = @SET_MAKE@ SHELL = @SHELL@ STRIP = @STRIP@ THREADDLLIBS = @THREADDLLIBS@ UNWINDLIBS = @UNWINDLIBS@ 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@ addlibs = @addlibs@ addobjs = @addobjs@ 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@ extra_ldflags_libgc = @extra_ldflags_libgc@ 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@ subdirs = @subdirs@ sysconfdir = @sysconfdir@ target = @target@ target_alias = @target_alias@ target_all = @target_all@ target_cpu = @target_cpu@ target_os = @target_os@ target_vendor = @target_vendor@ top_build_prefix = @top_build_prefix@ top_builddir = @top_builddir@ top_srcdir = @top_srcdir@ # We currently use the source files directly from libatomic_ops, if we # use the internal version. This is done since libatomic_ops doesn't # use libtool, since it has no real use for it. But that seems to make # it hard to use either the resulting object files or libraries. # Thus there seems too be no real reason to recursively build in the # libatomic_ops directory. # if USE_INTERNAL_LIBATOMICS_OPS # SUBDIRS = @maybe_libatomic_ops@ # else # SUBDIRS = # endif SUBDIRS = ACLOCAL_AMFLAGS = -I m4 # Initialize variables so that we can declare files locally. # FIXME: If Visual C++ users use Makefile.am, this should go into # pkginclude_HEADERS with proper AM_CONDITIONALization. Otherwise # delete this comment. # headers which are not installed # (see include/include.am for more) # # documentation which is not installed # # other makefiles # :GOTCHA: deliberately we do not include 'Makefile' # files used by makefiles other than Makefile.am # EXTRA_DIST = $(am__append_1) gc_cpp.cpp README.QUICK TODO BCC_MAKEFILE \ NT_MAKEFILE OS2_MAKEFILE PCR-Makefile digimars.mak \ EMX_MAKEFILE Makefile.direct SMakefile.amiga WCC_MAKEFILE \ autogen.sh NT_STATIC_THREADS_MAKEFILE \ NT_X64_STATIC_THREADS_MAKEFILE NT_X64_THREADS_MAKEFILE \ CMakeLists.txt tests/CMakeLists.txt tools/add_gc_prefix.c \ tools/gcname.c tools/if_mach.c tools/if_not_there.c \ tools/setjmp_t.c tools/threadlibs.c gc.mak extra/MacOS.c \ extra/AmigaOS.c extra/symbian/global_end.cpp \ extra/symbian/global_start.cpp \ extra/symbian/init_global_static_roots.cpp extra/symbian.cpp \ build/s60v3/bld.inf build/s60v3/libgc.mmp \ extra/Mac_files/datastart.c extra/Mac_files/dataend.c \ extra/Mac_files/MacOS_config.h include/private/msvc_dbg.h \ extra/msvc_dbg.c tools/callprocs.sh cord/tests/de.c \ cord/tests/de_cmds.h cord/tests/de_win.c cord/tests/de_win.h \ cord/tests/de_win.rc # C Library # --------- lib_LTLIBRARIES = libgc.la $(am__append_8) libcord.la # unprefixed header include_HEADERS = $(am__append_10) include/extra/gc.h # installed headers # pkginclude_HEADERS = $(am__append_9) include/gc.h \ include/gc_allocator.h include/gc_backptr.h \ include/gc_config_macros.h include/gc_disclaim.h \ include/gc_gcj.h include/gc_inline.h include/gc_mark.h \ include/gc_pthread_redirects.h include/gc_tiny_fl.h \ include/gc_typed.h include/gc_version.h include/javaxfc.h \ include/leak_detector.h include/weakpointer.h include/cord.h \ include/cord_pos.h include/ec.h # headers which are not installed # dist_noinst_HEADERS = include/cord.h include/cord_pos.h include/ec.h \ include/new_gc_alloc.h include/private/darwin_semaphore.h \ include/private/darwin_stop_world.h include/private/dbg_mlc.h \ include/private/gc_hdrs.h include/private/gc_locks.h \ include/private/gc_pmark.h include/private/gc_priv.h \ include/private/gcconfig.h include/private/msvc_dbg.h \ include/private/pthread_stop_world.h \ include/private/pthread_support.h include/private/specific.h \ include/private/thread_local_alloc.h check_LTLIBRARIES = libstaticrootslib_test.la \ libstaticrootslib2_test.la pkgconfigdir = $(libdir)/pkgconfig pkgconfig_DATA = bdw-gc.pc @SINGLE_GC_OBJ_FALSE@libgc_la_SOURCES = allchblk.c alloc.c blacklst.c \ @SINGLE_GC_OBJ_FALSE@ checksums.c dbg_mlc.c dyn_load.c \ @SINGLE_GC_OBJ_FALSE@ finalize.c gc_dlopen.c gcj_mlc.c \ @SINGLE_GC_OBJ_FALSE@ headers.c mach_dep.c malloc.c mallocx.c \ @SINGLE_GC_OBJ_FALSE@ mark.c mark_rts.c misc.c new_hblk.c \ @SINGLE_GC_OBJ_FALSE@ obj_map.c os_dep.c pcr_interface.c \ @SINGLE_GC_OBJ_FALSE@ ptr_chck.c real_malloc.c reclaim.c \ @SINGLE_GC_OBJ_FALSE@ specific.c stubborn.c \ @SINGLE_GC_OBJ_FALSE@ thread_local_alloc.c typd_mlc.c \ @SINGLE_GC_OBJ_FALSE@ $(am__append_2) $(am__append_3) \ @SINGLE_GC_OBJ_FALSE@ $(am__append_4) $(am__append_5) \ @SINGLE_GC_OBJ_FALSE@ $(am__append_6) $(am__append_7) @SINGLE_GC_OBJ_TRUE@libgc_la_SOURCES = extra/gc.c $(am__append_2) \ @SINGLE_GC_OBJ_TRUE@ $(am__append_3) $(am__append_4) \ @SINGLE_GC_OBJ_TRUE@ $(am__append_5) $(am__append_6) \ @SINGLE_GC_OBJ_TRUE@ $(am__append_7) @NEED_ATOMIC_OPS_ASM_TRUE@nodist_libgc_la_SOURCES = libatomic_ops/src/atomic_ops_sysdeps.S @USE_INTERNAL_LIBATOMIC_OPS_TRUE@nodist_libgc_la_SOURCES = libatomic_ops/src/atomic_ops.c # Include THREADDLLIBS here to ensure that the correct versions of # linuxthread semaphore functions get linked: libgc_la_LIBADD = @addobjs@ $(THREADDLLIBS) $(UNWINDLIBS) $(ATOMIC_OPS_LIBS) libgc_la_DEPENDENCIES = @addobjs@ libgc_la_LDFLAGS = $(extra_ldflags_libgc) -version-info 1:3:0 -no-undefined EXTRA_libgc_la_SOURCES = ia64_save_regs_in_stack.s sparc_mach_dep.S \ sparc_netbsd_mach_dep.s sparc_sunos4_mach_dep.s @CPLUSPLUS_TRUE@libgccpp_la_SOURCES = gc_cpp.cc @CPLUSPLUS_TRUE@libgccpp_la_LIBADD = ./libgc.la @CPLUSPLUS_TRUE@libgccpp_la_LDFLAGS = -version-info 1:3:0 -no-undefined # Misc # ---- AM_CXXFLAGS = @GC_CFLAGS@ @ASM_WITH_CPP_UNSUPPORTED_FALSE@ASM_CPP_OPTIONS = -Wp,-P -x assembler-with-cpp #all_objs = @addobjs@ $(libgc_la_OBJECTS) #$(all_objs) : include/private/gcconfig.h include/private/gc_priv.h \ #include/private/gc_hdrs.h include/gc.h include/gc_gcj.h \ #include/gc_pthread_redirects.h include/gc_config_macros.h \ #include/private/thread_local_alloc.h include/private_support.h \ #include/private/pthread_stop_world.h \ #include/gc_mark.h @addincludes@ @ASM_WITH_CPP_UNSUPPORTED_TRUE@ASM_CPP_OPTIONS = libcord_la_LIBADD = $(top_builddir)/libgc.la libcord_la_LDFLAGS = -version-info 1:3:0 -no-undefined libcord_la_CPPFLAGS = $(AM_CPPFLAGS) libcord_la_SOURCES = \ cord/cordbscs.c \ cord/cordprnt.c \ cord/cordxtra.c cordtest_SOURCES = cord/tests/cordtest.c cordtest_LDADD = $(top_builddir)/libgc.la $(top_builddir)/libcord.la # Common libs to _LDADD for all tests. test_ldadd = $(top_builddir)/libgc.la $(EXTRA_TEST_LIBS) gctest_SOURCES = tests/test.c gctest_LDADD = $(test_ldadd) $(am__append_11) gctest_DEPENDENCIES = $(top_builddir)/libgc.la leaktest_SOURCES = tests/leak_test.c leaktest_LDADD = $(test_ldadd) middletest_SOURCES = tests/middle.c middletest_LDADD = $(test_ldadd) smashtest_SOURCES = tests/smash_test.c smashtest_LDADD = $(test_ldadd) hugetest_SOURCES = tests/huge_test.c hugetest_LDADD = $(test_ldadd) realloc_test_SOURCES = tests/realloc_test.c realloc_test_LDADD = $(test_ldadd) staticrootstest_SOURCES = tests/staticrootstest.c staticrootstest_CFLAGS = -DSTATICROOTSLIB2 staticrootstest_LDADD = $(test_ldadd) libstaticrootslib_test.la \ libstaticrootslib2_test.la libstaticrootslib_test_la_SOURCES = tests/staticrootslib.c libstaticrootslib_test_la_LIBADD = $(test_ldadd) libstaticrootslib_test_la_LDFLAGS = -version-info 1:3:0 -no-undefined \ -rpath /nowhere libstaticrootslib_test_la_DEPENDENCIES = $(top_builddir)/libgc.la libstaticrootslib2_test_la_SOURCES = tests/staticrootslib.c libstaticrootslib2_test_la_LIBADD = $(test_ldadd) libstaticrootslib2_test_la_CFLAGS = -DSTATICROOTSLIB2 libstaticrootslib2_test_la_LDFLAGS = -version-info 1:3:0 -no-undefined \ -rpath /nowhere @KEEP_BACK_PTRS_TRUE@tracetest_SOURCES = tests/trace_test.c @KEEP_BACK_PTRS_TRUE@tracetest_LDADD = $(test_ldadd) @THREADS_TRUE@threadleaktest_SOURCES = tests/thread_leak_test.c @THREADS_TRUE@threadleaktest_LDADD = $(test_ldadd) $(THREADDLLIBS) @THREADS_TRUE@threadkey_test_SOURCES = tests/threadkey_test.c @THREADS_TRUE@threadkey_test_LDADD = $(test_ldadd) $(THREADDLLIBS) @THREADS_TRUE@subthreadcreate_test_SOURCES = tests/subthread_create.c @THREADS_TRUE@subthreadcreate_test_LDADD = $(test_ldadd) $(THREADDLLIBS) @THREADS_TRUE@initsecondarythread_test_SOURCES = tests/initsecondarythread.c @THREADS_TRUE@initsecondarythread_test_LDADD = $(test_ldadd) $(THREADDLLIBS) @CPLUSPLUS_TRUE@test_cpp_SOURCES = tests/test_cpp.cc @AVOID_CPP_LIB_FALSE@@CPLUSPLUS_TRUE@test_cpp_LDADD = libgccpp.la $(test_ldadd) $(CXXLIBS) @AVOID_CPP_LIB_TRUE@@CPLUSPLUS_TRUE@test_cpp_LDADD = gc_cpp.o $(test_ldadd) $(CXXLIBS) @ENABLE_DISCLAIM_TRUE@disclaim_test_SOURCES = tests/disclaim_test.c @ENABLE_DISCLAIM_TRUE@disclaim_test_LDADD = $(test_ldadd) \ @ENABLE_DISCLAIM_TRUE@ $(am__append_20) @ENABLE_DISCLAIM_TRUE@disclaim_bench_SOURCES = tests/disclaim_bench.c @ENABLE_DISCLAIM_TRUE@disclaim_bench_LDADD = $(test_ldadd) # installed documentation # dist_pkgdata_DATA = \ AUTHORS \ README.md \ doc/README.DGUX386 \ doc/README.Mac \ doc/README.OS2 \ doc/README.amiga \ doc/README.arm.cross \ doc/README.autoconf \ doc/README.cmake \ doc/README.cords \ doc/README.darwin \ doc/README.environment \ doc/README.ews4800 \ doc/README.hp \ doc/README.linux \ doc/README.macros \ doc/README.rs6000 \ doc/README.sgi \ doc/README.solaris2 \ doc/README.symbian \ doc/README.uts \ doc/README.win32 \ doc/README.win64 \ doc/debugging.html \ doc/finalization.html \ doc/gc.man \ doc/gcdescr.html \ doc/gcinterface.html \ doc/leak.html \ doc/overview.html \ doc/porting.html \ doc/scale.html \ doc/simple_example.html \ doc/tree.html all: all-recursive .SUFFIXES: .SUFFIXES: .S .c .cc .lo .log .o .obj .s .test .test$(EXEEXT) .trs am--refresh: Makefile @: $(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.am $(srcdir)/include/include.am $(srcdir)/cord/cord.am $(srcdir)/tests/tests.am $(srcdir)/doc/doc.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 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; $(srcdir)/include/include.am $(srcdir)/cord/cord.am $(srcdir)/tests/tests.am $(srcdir)/doc/doc.am $(am__empty): $(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): include/config.h: include/stamp-h1 @test -f $@ || rm -f include/stamp-h1 @test -f $@ || $(MAKE) $(AM_MAKEFLAGS) include/stamp-h1 include/stamp-h1: $(top_srcdir)/include/config.h.in $(top_builddir)/config.status @rm -f include/stamp-h1 cd $(top_builddir) && $(SHELL) ./config.status include/config.h $(top_srcdir)/include/config.h.in: @MAINTAINER_MODE_TRUE@ $(am__configure_deps) ($(am__cd) $(top_srcdir) && $(AUTOHEADER)) rm -f include/stamp-h1 touch $@ distclean-hdr: -rm -f include/config.h include/stamp-h1 bdw-gc.pc: $(top_builddir)/config.status $(srcdir)/bdw-gc.pc.in cd $(top_builddir) && $(SHELL) ./config.status $@ clean-checkLTLIBRARIES: -test -z "$(check_LTLIBRARIES)" || rm -f $(check_LTLIBRARIES) @list='$(check_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}; \ } 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}; \ } cord/$(am__dirstamp): @$(MKDIR_P) cord @: > cord/$(am__dirstamp) cord/$(DEPDIR)/$(am__dirstamp): @$(MKDIR_P) cord/$(DEPDIR) @: > cord/$(DEPDIR)/$(am__dirstamp) cord/libcord_la-cordbscs.lo: cord/$(am__dirstamp) \ cord/$(DEPDIR)/$(am__dirstamp) cord/libcord_la-cordprnt.lo: cord/$(am__dirstamp) \ cord/$(DEPDIR)/$(am__dirstamp) cord/libcord_la-cordxtra.lo: cord/$(am__dirstamp) \ cord/$(DEPDIR)/$(am__dirstamp) libcord.la: $(libcord_la_OBJECTS) $(libcord_la_DEPENDENCIES) $(EXTRA_libcord_la_DEPENDENCIES) $(AM_V_CCLD)$(libcord_la_LINK) -rpath $(libdir) $(libcord_la_OBJECTS) $(libcord_la_LIBADD) $(LIBS) extra/$(am__dirstamp): @$(MKDIR_P) extra @: > extra/$(am__dirstamp) extra/$(DEPDIR)/$(am__dirstamp): @$(MKDIR_P) extra/$(DEPDIR) @: > extra/$(DEPDIR)/$(am__dirstamp) extra/gc.lo: extra/$(am__dirstamp) extra/$(DEPDIR)/$(am__dirstamp) libatomic_ops/src/$(am__dirstamp): @$(MKDIR_P) libatomic_ops/src @: > libatomic_ops/src/$(am__dirstamp) libatomic_ops/src/$(DEPDIR)/$(am__dirstamp): @$(MKDIR_P) libatomic_ops/src/$(DEPDIR) @: > libatomic_ops/src/$(DEPDIR)/$(am__dirstamp) libatomic_ops/src/atomic_ops_sysdeps.lo: \ libatomic_ops/src/$(am__dirstamp) \ libatomic_ops/src/$(DEPDIR)/$(am__dirstamp) libatomic_ops/src/atomic_ops.lo: libatomic_ops/src/$(am__dirstamp) \ libatomic_ops/src/$(DEPDIR)/$(am__dirstamp) libgc.la: $(libgc_la_OBJECTS) $(libgc_la_DEPENDENCIES) $(EXTRA_libgc_la_DEPENDENCIES) $(AM_V_CCLD)$(libgc_la_LINK) -rpath $(libdir) $(libgc_la_OBJECTS) $(libgc_la_LIBADD) $(LIBS) libgccpp.la: $(libgccpp_la_OBJECTS) $(libgccpp_la_DEPENDENCIES) $(EXTRA_libgccpp_la_DEPENDENCIES) $(AM_V_CXXLD)$(libgccpp_la_LINK) $(am_libgccpp_la_rpath) $(libgccpp_la_OBJECTS) $(libgccpp_la_LIBADD) $(LIBS) tests/$(am__dirstamp): @$(MKDIR_P) tests @: > tests/$(am__dirstamp) tests/$(DEPDIR)/$(am__dirstamp): @$(MKDIR_P) tests/$(DEPDIR) @: > tests/$(DEPDIR)/$(am__dirstamp) tests/libstaticrootslib2_test_la-staticrootslib.lo: \ tests/$(am__dirstamp) tests/$(DEPDIR)/$(am__dirstamp) libstaticrootslib2_test.la: $(libstaticrootslib2_test_la_OBJECTS) $(libstaticrootslib2_test_la_DEPENDENCIES) $(EXTRA_libstaticrootslib2_test_la_DEPENDENCIES) $(AM_V_CCLD)$(libstaticrootslib2_test_la_LINK) $(libstaticrootslib2_test_la_OBJECTS) $(libstaticrootslib2_test_la_LIBADD) $(LIBS) tests/staticrootslib.lo: tests/$(am__dirstamp) \ tests/$(DEPDIR)/$(am__dirstamp) libstaticrootslib_test.la: $(libstaticrootslib_test_la_OBJECTS) $(libstaticrootslib_test_la_DEPENDENCIES) $(EXTRA_libstaticrootslib_test_la_DEPENDENCIES) $(AM_V_CCLD)$(libstaticrootslib_test_la_LINK) $(libstaticrootslib_test_la_OBJECTS) $(libstaticrootslib_test_la_LIBADD) $(LIBS) clean-checkPROGRAMS: @list='$(check_PROGRAMS)'; test -n "$$list" || exit 0; \ echo " rm -f" $$list; \ rm -f $$list || exit $$?; \ test -n "$(EXEEXT)" || exit 0; \ list=`for p in $$list; do echo "$$p"; done | sed 's/$(EXEEXT)$$//'`; \ echo " rm -f" $$list; \ rm -f $$list cord/tests/$(am__dirstamp): @$(MKDIR_P) cord/tests @: > cord/tests/$(am__dirstamp) cord/tests/$(DEPDIR)/$(am__dirstamp): @$(MKDIR_P) cord/tests/$(DEPDIR) @: > cord/tests/$(DEPDIR)/$(am__dirstamp) cord/tests/cordtest.$(OBJEXT): cord/tests/$(am__dirstamp) \ cord/tests/$(DEPDIR)/$(am__dirstamp) cordtest$(EXEEXT): $(cordtest_OBJECTS) $(cordtest_DEPENDENCIES) $(EXTRA_cordtest_DEPENDENCIES) @rm -f cordtest$(EXEEXT) $(AM_V_CCLD)$(LINK) $(cordtest_OBJECTS) $(cordtest_LDADD) $(LIBS) tests/disclaim_bench.$(OBJEXT): tests/$(am__dirstamp) \ tests/$(DEPDIR)/$(am__dirstamp) disclaim_bench$(EXEEXT): $(disclaim_bench_OBJECTS) $(disclaim_bench_DEPENDENCIES) $(EXTRA_disclaim_bench_DEPENDENCIES) @rm -f disclaim_bench$(EXEEXT) $(AM_V_CCLD)$(LINK) $(disclaim_bench_OBJECTS) $(disclaim_bench_LDADD) $(LIBS) tests/disclaim_test.$(OBJEXT): tests/$(am__dirstamp) \ tests/$(DEPDIR)/$(am__dirstamp) disclaim_test$(EXEEXT): $(disclaim_test_OBJECTS) $(disclaim_test_DEPENDENCIES) $(EXTRA_disclaim_test_DEPENDENCIES) @rm -f disclaim_test$(EXEEXT) $(AM_V_CCLD)$(LINK) $(disclaim_test_OBJECTS) $(disclaim_test_LDADD) $(LIBS) tests/test.$(OBJEXT): tests/$(am__dirstamp) \ tests/$(DEPDIR)/$(am__dirstamp) gctest$(EXEEXT): $(gctest_OBJECTS) $(gctest_DEPENDENCIES) $(EXTRA_gctest_DEPENDENCIES) @rm -f gctest$(EXEEXT) $(AM_V_CCLD)$(LINK) $(gctest_OBJECTS) $(gctest_LDADD) $(LIBS) tests/huge_test.$(OBJEXT): tests/$(am__dirstamp) \ tests/$(DEPDIR)/$(am__dirstamp) hugetest$(EXEEXT): $(hugetest_OBJECTS) $(hugetest_DEPENDENCIES) $(EXTRA_hugetest_DEPENDENCIES) @rm -f hugetest$(EXEEXT) $(AM_V_CCLD)$(LINK) $(hugetest_OBJECTS) $(hugetest_LDADD) $(LIBS) tests/initsecondarythread.$(OBJEXT): tests/$(am__dirstamp) \ tests/$(DEPDIR)/$(am__dirstamp) initsecondarythread_test$(EXEEXT): $(initsecondarythread_test_OBJECTS) $(initsecondarythread_test_DEPENDENCIES) $(EXTRA_initsecondarythread_test_DEPENDENCIES) @rm -f initsecondarythread_test$(EXEEXT) $(AM_V_CCLD)$(LINK) $(initsecondarythread_test_OBJECTS) $(initsecondarythread_test_LDADD) $(LIBS) tests/leak_test.$(OBJEXT): tests/$(am__dirstamp) \ tests/$(DEPDIR)/$(am__dirstamp) leaktest$(EXEEXT): $(leaktest_OBJECTS) $(leaktest_DEPENDENCIES) $(EXTRA_leaktest_DEPENDENCIES) @rm -f leaktest$(EXEEXT) $(AM_V_CCLD)$(LINK) $(leaktest_OBJECTS) $(leaktest_LDADD) $(LIBS) tests/middle.$(OBJEXT): tests/$(am__dirstamp) \ tests/$(DEPDIR)/$(am__dirstamp) middletest$(EXEEXT): $(middletest_OBJECTS) $(middletest_DEPENDENCIES) $(EXTRA_middletest_DEPENDENCIES) @rm -f middletest$(EXEEXT) $(AM_V_CCLD)$(LINK) $(middletest_OBJECTS) $(middletest_LDADD) $(LIBS) tests/realloc_test.$(OBJEXT): tests/$(am__dirstamp) \ tests/$(DEPDIR)/$(am__dirstamp) realloc_test$(EXEEXT): $(realloc_test_OBJECTS) $(realloc_test_DEPENDENCIES) $(EXTRA_realloc_test_DEPENDENCIES) @rm -f realloc_test$(EXEEXT) $(AM_V_CCLD)$(LINK) $(realloc_test_OBJECTS) $(realloc_test_LDADD) $(LIBS) tests/smash_test.$(OBJEXT): tests/$(am__dirstamp) \ tests/$(DEPDIR)/$(am__dirstamp) smashtest$(EXEEXT): $(smashtest_OBJECTS) $(smashtest_DEPENDENCIES) $(EXTRA_smashtest_DEPENDENCIES) @rm -f smashtest$(EXEEXT) $(AM_V_CCLD)$(LINK) $(smashtest_OBJECTS) $(smashtest_LDADD) $(LIBS) tests/staticrootstest-staticrootstest.$(OBJEXT): \ tests/$(am__dirstamp) tests/$(DEPDIR)/$(am__dirstamp) staticrootstest$(EXEEXT): $(staticrootstest_OBJECTS) $(staticrootstest_DEPENDENCIES) $(EXTRA_staticrootstest_DEPENDENCIES) @rm -f staticrootstest$(EXEEXT) $(AM_V_CCLD)$(staticrootstest_LINK) $(staticrootstest_OBJECTS) $(staticrootstest_LDADD) $(LIBS) tests/subthread_create.$(OBJEXT): tests/$(am__dirstamp) \ tests/$(DEPDIR)/$(am__dirstamp) subthreadcreate_test$(EXEEXT): $(subthreadcreate_test_OBJECTS) $(subthreadcreate_test_DEPENDENCIES) $(EXTRA_subthreadcreate_test_DEPENDENCIES) @rm -f subthreadcreate_test$(EXEEXT) $(AM_V_CCLD)$(LINK) $(subthreadcreate_test_OBJECTS) $(subthreadcreate_test_LDADD) $(LIBS) tests/test_cpp.$(OBJEXT): tests/$(am__dirstamp) \ tests/$(DEPDIR)/$(am__dirstamp) test_cpp$(EXEEXT): $(test_cpp_OBJECTS) $(test_cpp_DEPENDENCIES) $(EXTRA_test_cpp_DEPENDENCIES) @rm -f test_cpp$(EXEEXT) $(AM_V_CXXLD)$(CXXLINK) $(test_cpp_OBJECTS) $(test_cpp_LDADD) $(LIBS) tests/threadkey_test.$(OBJEXT): tests/$(am__dirstamp) \ tests/$(DEPDIR)/$(am__dirstamp) threadkey_test$(EXEEXT): $(threadkey_test_OBJECTS) $(threadkey_test_DEPENDENCIES) $(EXTRA_threadkey_test_DEPENDENCIES) @rm -f threadkey_test$(EXEEXT) $(AM_V_CCLD)$(LINK) $(threadkey_test_OBJECTS) $(threadkey_test_LDADD) $(LIBS) tests/thread_leak_test.$(OBJEXT): tests/$(am__dirstamp) \ tests/$(DEPDIR)/$(am__dirstamp) threadleaktest$(EXEEXT): $(threadleaktest_OBJECTS) $(threadleaktest_DEPENDENCIES) $(EXTRA_threadleaktest_DEPENDENCIES) @rm -f threadleaktest$(EXEEXT) $(AM_V_CCLD)$(LINK) $(threadleaktest_OBJECTS) $(threadleaktest_LDADD) $(LIBS) tests/trace_test.$(OBJEXT): tests/$(am__dirstamp) \ tests/$(DEPDIR)/$(am__dirstamp) tracetest$(EXEEXT): $(tracetest_OBJECTS) $(tracetest_DEPENDENCIES) $(EXTRA_tracetest_DEPENDENCIES) @rm -f tracetest$(EXEEXT) $(AM_V_CCLD)$(LINK) $(tracetest_OBJECTS) $(tracetest_LDADD) $(LIBS) mostlyclean-compile: -rm -f *.$(OBJEXT) -rm -f cord/*.$(OBJEXT) -rm -f cord/*.lo -rm -f cord/tests/*.$(OBJEXT) -rm -f extra/*.$(OBJEXT) -rm -f extra/*.lo -rm -f libatomic_ops/src/*.$(OBJEXT) -rm -f libatomic_ops/src/*.lo -rm -f tests/*.$(OBJEXT) -rm -f tests/*.lo distclean-compile: -rm -f *.tab.c @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/allchblk.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/alloc.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/backgraph.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/blacklst.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/checksums.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/darwin_stop_world.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/dbg_mlc.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/dyn_load.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/finalize.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fnlz_mlc.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/gc_cpp.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/gc_dlopen.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/gcj_mlc.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/headers.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/mach_dep.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/malloc.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/mallocx.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/mark.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/mark_rts.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/misc.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/new_hblk.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/obj_map.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/os_dep.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pcr_interface.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pthread_start.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pthread_stop_world.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pthread_support.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ptr_chck.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/real_malloc.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/reclaim.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/sparc_mach_dep.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/specific.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/stubborn.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/thread_local_alloc.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/typd_mlc.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/win32_threads.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@cord/$(DEPDIR)/libcord_la-cordbscs.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@cord/$(DEPDIR)/libcord_la-cordprnt.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@cord/$(DEPDIR)/libcord_la-cordxtra.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@cord/tests/$(DEPDIR)/cordtest.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@extra/$(DEPDIR)/gc.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@libatomic_ops/src/$(DEPDIR)/atomic_ops.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@libatomic_ops/src/$(DEPDIR)/atomic_ops_sysdeps.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@tests/$(DEPDIR)/disclaim_bench.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@tests/$(DEPDIR)/disclaim_test.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@tests/$(DEPDIR)/huge_test.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@tests/$(DEPDIR)/initsecondarythread.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@tests/$(DEPDIR)/leak_test.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@tests/$(DEPDIR)/libstaticrootslib2_test_la-staticrootslib.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@tests/$(DEPDIR)/middle.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@tests/$(DEPDIR)/realloc_test.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@tests/$(DEPDIR)/smash_test.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@tests/$(DEPDIR)/staticrootslib.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@tests/$(DEPDIR)/staticrootstest-staticrootstest.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@tests/$(DEPDIR)/subthread_create.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@tests/$(DEPDIR)/test.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@tests/$(DEPDIR)/test_cpp.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@tests/$(DEPDIR)/thread_leak_test.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@tests/$(DEPDIR)/threadkey_test.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@tests/$(DEPDIR)/trace_test.Po@am__quote@ .S.o: @am__fastdepCCAS_TRUE@ $(AM_V_CPPAS)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\ @am__fastdepCCAS_TRUE@ $(CPPASCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\ @am__fastdepCCAS_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po @AMDEP_TRUE@@am__fastdepCCAS_FALSE@ $(AM_V_CPPAS)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCCAS_FALSE@ DEPDIR=$(DEPDIR) $(CCASDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCCAS_FALSE@ $(AM_V_CPPAS@am__nodep@)$(CPPASCOMPILE) -c -o $@ $< .S.obj: @am__fastdepCCAS_TRUE@ $(AM_V_CPPAS)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.obj$$||'`;\ @am__fastdepCCAS_TRUE@ $(CPPASCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\ @am__fastdepCCAS_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po @AMDEP_TRUE@@am__fastdepCCAS_FALSE@ $(AM_V_CPPAS)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCCAS_FALSE@ DEPDIR=$(DEPDIR) $(CCASDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCCAS_FALSE@ $(AM_V_CPPAS@am__nodep@)$(CPPASCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'` .c.o: @am__fastdepCC_TRUE@ $(AM_V_CC)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\ @am__fastdepCC_TRUE@ $(COMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\ @am__fastdepCC_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(COMPILE) -c -o $@ $< .c.obj: @am__fastdepCC_TRUE@ $(AM_V_CC)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.obj$$||'`;\ @am__fastdepCC_TRUE@ $(COMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\ @am__fastdepCC_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(COMPILE) -c -o $@ `$(CYGPATH_W) '$<'` .c.lo: @am__fastdepCC_TRUE@ $(AM_V_CC)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.lo$$||'`;\ @am__fastdepCC_TRUE@ $(LTCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\ @am__fastdepCC_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Plo @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(LTCOMPILE) -c -o $@ $< cord/libcord_la-cordbscs.lo: cord/cordbscs.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcord_la_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT cord/libcord_la-cordbscs.lo -MD -MP -MF cord/$(DEPDIR)/libcord_la-cordbscs.Tpo -c -o cord/libcord_la-cordbscs.lo `test -f 'cord/cordbscs.c' || echo '$(srcdir)/'`cord/cordbscs.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) cord/$(DEPDIR)/libcord_la-cordbscs.Tpo cord/$(DEPDIR)/libcord_la-cordbscs.Plo @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='cord/cordbscs.c' object='cord/libcord_la-cordbscs.lo' libtool=yes @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcord_la_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o cord/libcord_la-cordbscs.lo `test -f 'cord/cordbscs.c' || echo '$(srcdir)/'`cord/cordbscs.c cord/libcord_la-cordprnt.lo: cord/cordprnt.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcord_la_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT cord/libcord_la-cordprnt.lo -MD -MP -MF cord/$(DEPDIR)/libcord_la-cordprnt.Tpo -c -o cord/libcord_la-cordprnt.lo `test -f 'cord/cordprnt.c' || echo '$(srcdir)/'`cord/cordprnt.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) cord/$(DEPDIR)/libcord_la-cordprnt.Tpo cord/$(DEPDIR)/libcord_la-cordprnt.Plo @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='cord/cordprnt.c' object='cord/libcord_la-cordprnt.lo' libtool=yes @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcord_la_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o cord/libcord_la-cordprnt.lo `test -f 'cord/cordprnt.c' || echo '$(srcdir)/'`cord/cordprnt.c cord/libcord_la-cordxtra.lo: cord/cordxtra.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcord_la_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT cord/libcord_la-cordxtra.lo -MD -MP -MF cord/$(DEPDIR)/libcord_la-cordxtra.Tpo -c -o cord/libcord_la-cordxtra.lo `test -f 'cord/cordxtra.c' || echo '$(srcdir)/'`cord/cordxtra.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) cord/$(DEPDIR)/libcord_la-cordxtra.Tpo cord/$(DEPDIR)/libcord_la-cordxtra.Plo @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='cord/cordxtra.c' object='cord/libcord_la-cordxtra.lo' libtool=yes @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcord_la_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o cord/libcord_la-cordxtra.lo `test -f 'cord/cordxtra.c' || echo '$(srcdir)/'`cord/cordxtra.c tests/libstaticrootslib2_test_la-staticrootslib.lo: tests/staticrootslib.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libstaticrootslib2_test_la_CFLAGS) $(CFLAGS) -MT tests/libstaticrootslib2_test_la-staticrootslib.lo -MD -MP -MF tests/$(DEPDIR)/libstaticrootslib2_test_la-staticrootslib.Tpo -c -o tests/libstaticrootslib2_test_la-staticrootslib.lo `test -f 'tests/staticrootslib.c' || echo '$(srcdir)/'`tests/staticrootslib.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) tests/$(DEPDIR)/libstaticrootslib2_test_la-staticrootslib.Tpo tests/$(DEPDIR)/libstaticrootslib2_test_la-staticrootslib.Plo @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='tests/staticrootslib.c' object='tests/libstaticrootslib2_test_la-staticrootslib.lo' libtool=yes @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libstaticrootslib2_test_la_CFLAGS) $(CFLAGS) -c -o tests/libstaticrootslib2_test_la-staticrootslib.lo `test -f 'tests/staticrootslib.c' || echo '$(srcdir)/'`tests/staticrootslib.c tests/staticrootstest-staticrootstest.o: tests/staticrootstest.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(staticrootstest_CFLAGS) $(CFLAGS) -MT tests/staticrootstest-staticrootstest.o -MD -MP -MF tests/$(DEPDIR)/staticrootstest-staticrootstest.Tpo -c -o tests/staticrootstest-staticrootstest.o `test -f 'tests/staticrootstest.c' || echo '$(srcdir)/'`tests/staticrootstest.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) tests/$(DEPDIR)/staticrootstest-staticrootstest.Tpo tests/$(DEPDIR)/staticrootstest-staticrootstest.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='tests/staticrootstest.c' object='tests/staticrootstest-staticrootstest.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(staticrootstest_CFLAGS) $(CFLAGS) -c -o tests/staticrootstest-staticrootstest.o `test -f 'tests/staticrootstest.c' || echo '$(srcdir)/'`tests/staticrootstest.c tests/staticrootstest-staticrootstest.obj: tests/staticrootstest.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(staticrootstest_CFLAGS) $(CFLAGS) -MT tests/staticrootstest-staticrootstest.obj -MD -MP -MF tests/$(DEPDIR)/staticrootstest-staticrootstest.Tpo -c -o tests/staticrootstest-staticrootstest.obj `if test -f 'tests/staticrootstest.c'; then $(CYGPATH_W) 'tests/staticrootstest.c'; else $(CYGPATH_W) '$(srcdir)/tests/staticrootstest.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) tests/$(DEPDIR)/staticrootstest-staticrootstest.Tpo tests/$(DEPDIR)/staticrootstest-staticrootstest.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='tests/staticrootstest.c' object='tests/staticrootstest-staticrootstest.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(staticrootstest_CFLAGS) $(CFLAGS) -c -o tests/staticrootstest-staticrootstest.obj `if test -f 'tests/staticrootstest.c'; then $(CYGPATH_W) 'tests/staticrootstest.c'; else $(CYGPATH_W) '$(srcdir)/tests/staticrootstest.c'; fi` .cc.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 $@ $< .cc.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) '$<'` .cc.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 $@ $< .s.o: $(AM_V_CCAS)$(CCASCOMPILE) -c -o $@ $< .s.obj: $(AM_V_CCAS)$(CCASCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'` mostlyclean-libtool: -rm -f *.lo clean-libtool: -rm -rf .libs _libs -rm -rf cord/.libs cord/_libs -rm -rf extra/.libs extra/_libs -rm -rf libatomic_ops/src/.libs libatomic_ops/src/_libs -rm -rf tests/.libs tests/_libs distclean-libtool: -rm -f libtool config.lt install-dist_pkgdataDATA: $(dist_pkgdata_DATA) @$(NORMAL_INSTALL) @list='$(dist_pkgdata_DATA)'; test -n "$(pkgdatadir)" || list=; \ if test -n "$$list"; then \ echo " $(MKDIR_P) '$(DESTDIR)$(pkgdatadir)'"; \ $(MKDIR_P) "$(DESTDIR)$(pkgdatadir)" || 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)$(pkgdatadir)'"; \ $(INSTALL_DATA) $$files "$(DESTDIR)$(pkgdatadir)" || exit $$?; \ done uninstall-dist_pkgdataDATA: @$(NORMAL_UNINSTALL) @list='$(dist_pkgdata_DATA)'; test -n "$(pkgdatadir)" || list=; \ files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \ dir='$(DESTDIR)$(pkgdatadir)'; $(am__uninstall_files_from_dir) 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-includeHEADERS: $(include_HEADERS) @$(NORMAL_INSTALL) @list='$(include_HEADERS)'; test -n "$(includedir)" || list=; \ if test -n "$$list"; then \ echo " $(MKDIR_P) '$(DESTDIR)$(includedir)'"; \ $(MKDIR_P) "$(DESTDIR)$(includedir)" || 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)$(includedir)'"; \ $(INSTALL_HEADER) $$files "$(DESTDIR)$(includedir)" || exit $$?; \ done uninstall-includeHEADERS: @$(NORMAL_UNINSTALL) @list='$(include_HEADERS)'; test -n "$(includedir)" || list=; \ files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \ dir='$(DESTDIR)$(includedir)'; $(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) # This directory's subdirectories are mostly independent; you can cd # into them and run 'make' without going through this Makefile. # To change the values of 'make' variables: instead of editing Makefiles, # (1) if the variable is set in 'config.status', edit 'config.status' # (which will cause the Makefiles to be regenerated when you run 'make'); # (2) otherwise, pass the desired values on the 'make' command line. $(am__recursive_targets): @fail=; \ if $(am__make_keepgoing); then \ failcom='fail=yes'; \ else \ failcom='exit 1'; \ fi; \ dot_seen=no; \ target=`echo $@ | sed s/-recursive//`; \ case "$@" in \ distclean-* | maintainer-clean-*) list='$(DIST_SUBDIRS)' ;; \ *) list='$(SUBDIRS)' ;; \ esac; \ for subdir in $$list; do \ echo "Making $$target in $$subdir"; \ if test "$$subdir" = "."; then \ dot_seen=yes; \ local_target="$$target-am"; \ else \ local_target="$$target"; \ fi; \ ($(am__cd) $$subdir && $(MAKE) $(AM_MAKEFLAGS) $$local_target) \ || eval $$failcom; \ done; \ if test "$$dot_seen" = "no"; then \ $(MAKE) $(AM_MAKEFLAGS) "$$target-am" || exit 1; \ fi; test -z "$$fail" ID: $(am__tagged_files) $(am__define_uniq_tagged_files); mkid -fID $$unique tags: tags-recursive TAGS: tags tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) set x; \ here=`pwd`; \ if ($(ETAGS) --etags-include --version) >/dev/null 2>&1; then \ include_option=--etags-include; \ empty_fix=.; \ else \ include_option=--include; \ empty_fix=; \ fi; \ list='$(SUBDIRS)'; for subdir in $$list; do \ if test "$$subdir" = .; then :; else \ test ! -f $$subdir/TAGS || \ set "$$@" "$$include_option=$$here/$$subdir/TAGS"; \ fi; \ done; \ $(am__define_uniq_tagged_files); \ 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-recursive CTAGS: ctags ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) $(am__define_uniq_tagged_files); \ 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: cscopelist-recursive cscopelist-am: $(am__tagged_files) list='$(am__tagged_files)'; \ 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 # Recover from deleted '.trs' file; this should ensure that # "rm -f foo.log; make foo.trs" re-run 'foo.test', and re-create # both 'foo.log' and 'foo.trs'. Break the recipe in two subshells # to avoid problems with "make -n". .log.trs: rm -f $< $@ $(MAKE) $(AM_MAKEFLAGS) $< # Leading 'am--fnord' is there to ensure the list of targets does not # expand to empty, as could happen e.g. with make check TESTS=''. am--fnord $(TEST_LOGS) $(TEST_LOGS:.log=.trs): $(am__force_recheck) am--force-recheck: @: $(TEST_SUITE_LOG): $(TEST_LOGS) @$(am__set_TESTS_bases); \ am__f_ok () { test -f "$$1" && test -r "$$1"; }; \ redo_bases=`for i in $$bases; do \ am__f_ok $$i.trs && am__f_ok $$i.log || echo $$i; \ done`; \ if test -n "$$redo_bases"; then \ redo_logs=`for i in $$redo_bases; do echo $$i.log; done`; \ redo_results=`for i in $$redo_bases; do echo $$i.trs; done`; \ if $(am__make_dryrun); then :; else \ rm -f $$redo_logs && rm -f $$redo_results || exit 1; \ fi; \ fi; \ if test -n "$$am__remaking_logs"; then \ echo "fatal: making $(TEST_SUITE_LOG): possible infinite" \ "recursion detected" >&2; \ elif test -n "$$redo_logs"; then \ am__remaking_logs=yes $(MAKE) $(AM_MAKEFLAGS) $$redo_logs; \ fi; \ if $(am__make_dryrun); then :; else \ st=0; \ errmsg="fatal: making $(TEST_SUITE_LOG): failed to create"; \ for i in $$redo_bases; do \ test -f $$i.trs && test -r $$i.trs \ || { echo "$$errmsg $$i.trs" >&2; st=1; }; \ test -f $$i.log && test -r $$i.log \ || { echo "$$errmsg $$i.log" >&2; st=1; }; \ done; \ test $$st -eq 0 || exit 1; \ fi @$(am__sh_e_setup); $(am__tty_colors); $(am__set_TESTS_bases); \ ws='[ ]'; \ results=`for b in $$bases; do echo $$b.trs; done`; \ test -n "$$results" || results=/dev/null; \ all=` grep "^$$ws*:test-result:" $$results | wc -l`; \ pass=` grep "^$$ws*:test-result:$$ws*PASS" $$results | wc -l`; \ fail=` grep "^$$ws*:test-result:$$ws*FAIL" $$results | wc -l`; \ skip=` grep "^$$ws*:test-result:$$ws*SKIP" $$results | wc -l`; \ xfail=`grep "^$$ws*:test-result:$$ws*XFAIL" $$results | wc -l`; \ xpass=`grep "^$$ws*:test-result:$$ws*XPASS" $$results | wc -l`; \ error=`grep "^$$ws*:test-result:$$ws*ERROR" $$results | wc -l`; \ if test `expr $$fail + $$xpass + $$error` -eq 0; then \ success=true; \ else \ success=false; \ fi; \ br='==================='; br=$$br$$br$$br$$br; \ result_count () \ { \ if test x"$$1" = x"--maybe-color"; then \ maybe_colorize=yes; \ elif test x"$$1" = x"--no-color"; then \ maybe_colorize=no; \ else \ echo "$@: invalid 'result_count' usage" >&2; exit 4; \ fi; \ shift; \ desc=$$1 count=$$2; \ if test $$maybe_colorize = yes && test $$count -gt 0; then \ color_start=$$3 color_end=$$std; \ else \ color_start= color_end=; \ fi; \ echo "$${color_start}# $$desc $$count$${color_end}"; \ }; \ create_testsuite_report () \ { \ result_count $$1 "TOTAL:" $$all "$$brg"; \ result_count $$1 "PASS: " $$pass "$$grn"; \ result_count $$1 "SKIP: " $$skip "$$blu"; \ result_count $$1 "XFAIL:" $$xfail "$$lgn"; \ result_count $$1 "FAIL: " $$fail "$$red"; \ result_count $$1 "XPASS:" $$xpass "$$red"; \ result_count $$1 "ERROR:" $$error "$$mgn"; \ }; \ { \ echo "$(PACKAGE_STRING): $(subdir)/$(TEST_SUITE_LOG)" | \ $(am__rst_title); \ create_testsuite_report --no-color; \ echo; \ echo ".. contents:: :depth: 2"; \ echo; \ for b in $$bases; do echo $$b; done \ | $(am__create_global_log); \ } >$(TEST_SUITE_LOG).tmp || exit 1; \ mv $(TEST_SUITE_LOG).tmp $(TEST_SUITE_LOG); \ if $$success; then \ col="$$grn"; \ else \ col="$$red"; \ test x"$$VERBOSE" = x || cat $(TEST_SUITE_LOG); \ fi; \ echo "$${col}$$br$${std}"; \ echo "$${col}Testsuite summary for $(PACKAGE_STRING)$${std}"; \ echo "$${col}$$br$${std}"; \ create_testsuite_report --maybe-color; \ echo "$$col$$br$$std"; \ if $$success; then :; else \ echo "$${col}See $(subdir)/$(TEST_SUITE_LOG)$${std}"; \ if test -n "$(PACKAGE_BUGREPORT)"; then \ echo "$${col}Please report to $(PACKAGE_BUGREPORT)$${std}"; \ fi; \ echo "$$col$$br$$std"; \ fi; \ $$success || exit 1 check-TESTS: @list='$(RECHECK_LOGS)'; test -z "$$list" || rm -f $$list @list='$(RECHECK_LOGS:.log=.trs)'; test -z "$$list" || rm -f $$list @test -z "$(TEST_SUITE_LOG)" || rm -f $(TEST_SUITE_LOG) @set +e; $(am__set_TESTS_bases); \ log_list=`for i in $$bases; do echo $$i.log; done`; \ trs_list=`for i in $$bases; do echo $$i.trs; done`; \ log_list=`echo $$log_list`; trs_list=`echo $$trs_list`; \ $(MAKE) $(AM_MAKEFLAGS) $(TEST_SUITE_LOG) TEST_LOGS="$$log_list"; \ exit $$?; recheck: all $(check_LTLIBRARIES) $(check_PROGRAMS) @test -z "$(TEST_SUITE_LOG)" || rm -f $(TEST_SUITE_LOG) @set +e; $(am__set_TESTS_bases); \ bases=`for i in $$bases; do echo $$i; done \ | $(am__list_recheck_tests)` || exit 1; \ log_list=`for i in $$bases; do echo $$i.log; done`; \ log_list=`echo $$log_list`; \ $(MAKE) $(AM_MAKEFLAGS) $(TEST_SUITE_LOG) \ am__force_recheck=am--force-recheck \ TEST_LOGS="$$log_list"; \ exit $$? cordtest.log: cordtest$(EXEEXT) @p='cordtest$(EXEEXT)'; \ b='cordtest'; \ $(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \ --log-file $$b.log --trs-file $$b.trs \ $(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \ "$$tst" $(AM_TESTS_FD_REDIRECT) gctest.log: gctest$(EXEEXT) @p='gctest$(EXEEXT)'; \ b='gctest'; \ $(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \ --log-file $$b.log --trs-file $$b.trs \ $(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \ "$$tst" $(AM_TESTS_FD_REDIRECT) leaktest.log: leaktest$(EXEEXT) @p='leaktest$(EXEEXT)'; \ b='leaktest'; \ $(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \ --log-file $$b.log --trs-file $$b.trs \ $(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \ "$$tst" $(AM_TESTS_FD_REDIRECT) middletest.log: middletest$(EXEEXT) @p='middletest$(EXEEXT)'; \ b='middletest'; \ $(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \ --log-file $$b.log --trs-file $$b.trs \ $(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \ "$$tst" $(AM_TESTS_FD_REDIRECT) smashtest.log: smashtest$(EXEEXT) @p='smashtest$(EXEEXT)'; \ b='smashtest'; \ $(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \ --log-file $$b.log --trs-file $$b.trs \ $(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \ "$$tst" $(AM_TESTS_FD_REDIRECT) hugetest.log: hugetest$(EXEEXT) @p='hugetest$(EXEEXT)'; \ b='hugetest'; \ $(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \ --log-file $$b.log --trs-file $$b.trs \ $(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \ "$$tst" $(AM_TESTS_FD_REDIRECT) realloc_test.log: realloc_test$(EXEEXT) @p='realloc_test$(EXEEXT)'; \ b='realloc_test'; \ $(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \ --log-file $$b.log --trs-file $$b.trs \ $(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \ "$$tst" $(AM_TESTS_FD_REDIRECT) staticrootstest.log: staticrootstest$(EXEEXT) @p='staticrootstest$(EXEEXT)'; \ b='staticrootstest'; \ $(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \ --log-file $$b.log --trs-file $$b.trs \ $(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \ "$$tst" $(AM_TESTS_FD_REDIRECT) tracetest.log: tracetest$(EXEEXT) @p='tracetest$(EXEEXT)'; \ b='tracetest'; \ $(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \ --log-file $$b.log --trs-file $$b.trs \ $(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \ "$$tst" $(AM_TESTS_FD_REDIRECT) threadleaktest.log: threadleaktest$(EXEEXT) @p='threadleaktest$(EXEEXT)'; \ b='threadleaktest'; \ $(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \ --log-file $$b.log --trs-file $$b.trs \ $(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \ "$$tst" $(AM_TESTS_FD_REDIRECT) threadkey_test.log: threadkey_test$(EXEEXT) @p='threadkey_test$(EXEEXT)'; \ b='threadkey_test'; \ $(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \ --log-file $$b.log --trs-file $$b.trs \ $(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \ "$$tst" $(AM_TESTS_FD_REDIRECT) subthreadcreate_test.log: subthreadcreate_test$(EXEEXT) @p='subthreadcreate_test$(EXEEXT)'; \ b='subthreadcreate_test'; \ $(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \ --log-file $$b.log --trs-file $$b.trs \ $(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \ "$$tst" $(AM_TESTS_FD_REDIRECT) initsecondarythread_test.log: initsecondarythread_test$(EXEEXT) @p='initsecondarythread_test$(EXEEXT)'; \ b='initsecondarythread_test'; \ $(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \ --log-file $$b.log --trs-file $$b.trs \ $(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \ "$$tst" $(AM_TESTS_FD_REDIRECT) test_cpp.log: test_cpp$(EXEEXT) @p='test_cpp$(EXEEXT)'; \ b='test_cpp'; \ $(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \ --log-file $$b.log --trs-file $$b.trs \ $(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \ "$$tst" $(AM_TESTS_FD_REDIRECT) disclaim_test.log: disclaim_test$(EXEEXT) @p='disclaim_test$(EXEEXT)'; \ b='disclaim_test'; \ $(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \ --log-file $$b.log --trs-file $$b.trs \ $(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \ "$$tst" $(AM_TESTS_FD_REDIRECT) disclaim_bench.log: disclaim_bench$(EXEEXT) @p='disclaim_bench$(EXEEXT)'; \ b='disclaim_bench'; \ $(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \ --log-file $$b.log --trs-file $$b.trs \ $(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \ "$$tst" $(AM_TESTS_FD_REDIRECT) .test.log: @p='$<'; \ $(am__set_b); \ $(am__check_pre) $(TEST_LOG_DRIVER) --test-name "$$f" \ --log-file $$b.log --trs-file $$b.trs \ $(am__common_driver_flags) $(AM_TEST_LOG_DRIVER_FLAGS) $(TEST_LOG_DRIVER_FLAGS) -- $(TEST_LOG_COMPILE) \ "$$tst" $(AM_TESTS_FD_REDIRECT) @am__EXEEXT_TRUE@.test$(EXEEXT).log: @am__EXEEXT_TRUE@ @p='$<'; \ @am__EXEEXT_TRUE@ $(am__set_b); \ @am__EXEEXT_TRUE@ $(am__check_pre) $(TEST_LOG_DRIVER) --test-name "$$f" \ @am__EXEEXT_TRUE@ --log-file $$b.log --trs-file $$b.trs \ @am__EXEEXT_TRUE@ $(am__common_driver_flags) $(AM_TEST_LOG_DRIVER_FLAGS) $(TEST_LOG_DRIVER_FLAGS) -- $(TEST_LOG_COMPILE) \ @am__EXEEXT_TRUE@ "$$tst" $(AM_TESTS_FD_REDIRECT) 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 @list='$(DIST_SUBDIRS)'; for subdir in $$list; do \ if test "$$subdir" = .; then :; else \ $(am__make_dryrun) \ || test -d "$(distdir)/$$subdir" \ || $(MKDIR_P) "$(distdir)/$$subdir" \ || exit 1; \ dir1=$$subdir; dir2="$(distdir)/$$subdir"; \ $(am__relativize); \ new_distdir=$$reldir; \ dir1=$$subdir; dir2="$(top_distdir)"; \ $(am__relativize); \ new_top_distdir=$$reldir; \ echo " (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) top_distdir="$$new_top_distdir" distdir="$$new_distdir" \\"; \ echo " am__remove_distdir=: am__skip_length_check=: am__skip_mode_fix=: distdir)"; \ ($(am__cd) $$subdir && \ $(MAKE) $(AM_MAKEFLAGS) \ top_distdir="$$new_top_distdir" \ distdir="$$new_distdir" \ am__remove_distdir=: \ am__skip_length_check=: \ am__skip_mode_fix=: \ distdir) \ || 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 @echo WARNING: "Support for distribution archives compressed with" \ "legacy program 'compress' is deprecated." >&2 @echo WARNING: "It will be removed altogether in Automake 2.0" >&2 tardir=$(distdir) && $(am__tar) | compress -c >$(distdir).tar.Z $(am__post_remove_distdir) dist-shar: distdir @echo WARNING: "Support for shar distribution archives is" \ "deprecated." >&2 @echo WARNING: "It will be removed altogether in Automake 2.0" >&2 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 $(distdir)/_build/sub $(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/sub \ && ../../configure \ $(AM_DISTCHECK_CONFIGURE_FLAGS) \ $(DISTCHECK_CONFIGURE_FLAGS) \ --srcdir=../.. --prefix="$$dc_install_base" \ && $(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 $(MAKE) $(AM_MAKEFLAGS) $(check_LTLIBRARIES) $(check_PROGRAMS) $(MAKE) $(AM_MAKEFLAGS) check-TESTS check: check-recursive all-am: Makefile $(LTLIBRARIES) $(DATA) $(HEADERS) installdirs: installdirs-recursive installdirs-am: for dir in "$(DESTDIR)$(libdir)" "$(DESTDIR)$(pkgdatadir)" "$(DESTDIR)$(pkgconfigdir)" "$(DESTDIR)$(includedir)" "$(DESTDIR)$(pkgincludedir)"; do \ test -z "$$dir" || $(MKDIR_P) "$$dir"; \ done install: install-recursive install-exec: install-exec-recursive install-data: install-data-recursive uninstall: uninstall-recursive install-am: all-am @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am installcheck: installcheck-recursive 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: -test -z "$(TEST_LOGS)" || rm -f $(TEST_LOGS) -test -z "$(TEST_LOGS:.log=.trs)" || rm -f $(TEST_LOGS:.log=.trs) -test -z "$(TEST_SUITE_LOG)" || rm -f $(TEST_SUITE_LOG) 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 cord/$(DEPDIR)/$(am__dirstamp) -rm -f cord/$(am__dirstamp) -rm -f cord/tests/$(DEPDIR)/$(am__dirstamp) -rm -f cord/tests/$(am__dirstamp) -rm -f extra/$(DEPDIR)/$(am__dirstamp) -rm -f extra/$(am__dirstamp) -rm -f libatomic_ops/src/$(DEPDIR)/$(am__dirstamp) -rm -f libatomic_ops/src/$(am__dirstamp) -rm -f tests/$(DEPDIR)/$(am__dirstamp) -rm -f tests/$(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-recursive clean-am: clean-checkLTLIBRARIES clean-checkPROGRAMS clean-generic \ clean-libLTLIBRARIES clean-libtool mostlyclean-am distclean: distclean-recursive -rm -f $(am__CONFIG_DISTCLEAN_FILES) -rm -rf ./$(DEPDIR) cord/$(DEPDIR) cord/tests/$(DEPDIR) extra/$(DEPDIR) libatomic_ops/src/$(DEPDIR) tests/$(DEPDIR) -rm -f Makefile distclean-am: clean-am distclean-compile distclean-generic \ distclean-hdr distclean-libtool distclean-tags dvi: dvi-recursive dvi-am: html: html-recursive html-am: info: info-recursive info-am: install-data-am: install-dist_pkgdataDATA install-includeHEADERS \ install-pkgconfigDATA install-pkgincludeHEADERS install-dvi: install-dvi-recursive install-dvi-am: install-exec-am: install-libLTLIBRARIES install-html: install-html-recursive install-html-am: install-info: install-info-recursive install-info-am: install-man: install-pdf: install-pdf-recursive install-pdf-am: install-ps: install-ps-recursive install-ps-am: installcheck-am: maintainer-clean: maintainer-clean-recursive -rm -f $(am__CONFIG_DISTCLEAN_FILES) -rm -rf $(top_srcdir)/autom4te.cache -rm -rf ./$(DEPDIR) cord/$(DEPDIR) cord/tests/$(DEPDIR) extra/$(DEPDIR) libatomic_ops/src/$(DEPDIR) tests/$(DEPDIR) -rm -f Makefile maintainer-clean-am: distclean-am maintainer-clean-generic mostlyclean: mostlyclean-recursive mostlyclean-am: mostlyclean-compile mostlyclean-generic \ mostlyclean-libtool pdf: pdf-recursive pdf-am: ps: ps-recursive ps-am: uninstall-am: uninstall-dist_pkgdataDATA uninstall-includeHEADERS \ uninstall-libLTLIBRARIES uninstall-pkgconfigDATA \ uninstall-pkgincludeHEADERS .MAKE: $(am__recursive_targets) check-am install-am install-strip .PHONY: $(am__recursive_targets) CTAGS GTAGS TAGS all all-am \ am--refresh check check-TESTS check-am clean \ clean-checkLTLIBRARIES clean-checkPROGRAMS clean-cscope \ clean-generic clean-libLTLIBRARIES clean-libtool cscope \ cscopelist-am ctags ctags-am 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-dist_pkgdataDATA install-dvi install-dvi-am \ install-exec install-exec-am install-html install-html-am \ install-includeHEADERS 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 installdirs-am maintainer-clean \ maintainer-clean-generic mostlyclean mostlyclean-compile \ mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \ recheck tags tags-am uninstall uninstall-am \ uninstall-dist_pkgdataDATA uninstall-includeHEADERS \ uninstall-libLTLIBRARIES uninstall-pkgconfigDATA \ uninstall-pkgincludeHEADERS .PRECIOUS: Makefile .s.lo: $(LTCOMPILE) $(ASM_CPP_OPTIONS) -c $< .S.lo: $(LTCOMPILE) $(ASM_CPP_OPTIONS) -c $< # # :GOTCHA: GNU make rule for making .s out of .S is flawed, # it will not remove dest if building fails .S.s: if $(CPP) $< >$@ ; then :; else rm -f $@; fi # Putting these at the top causes cord to be built first, and not find libgc.a # on HP/UX. There may be a better fix. # 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: ecl-16.1.2/src/bdwgc/NT_MAKEFILE000066400000000000000000000056611266352375300157460ustar00rootroot00000000000000# Makefile for Windows NT. Assumes Microsoft compiler, and a single thread. # Use "nmake nodebug=1 all" for optimized versions of library, gctest and editor. MY_CPU=X86 CPU=$(MY_CPU) !include # Make sure that .cc is not viewed as a suffix. It is for VC++2005, but # not earlier versions. We can deal with either, but not inconsistency. .SUFFIXES: .SUFFIXES: .obj .cpp .c OBJS= alloc.obj reclaim.obj allchblk.obj misc.obj mach_dep.obj os_dep.obj mark_rts.obj headers.obj mark.obj obj_map.obj blacklst.obj finalize.obj new_hblk.obj dbg_mlc.obj fnlz_mlc.obj malloc.obj stubborn.obj dyn_load.obj typd_mlc.obj ptr_chck.obj gc_cpp.obj mallocx.obj extra\msvc_dbg.obj all: gctest.exe cord\de.exe test_cpp.exe .c.obj: $(cc) $(cdebug) $(cflags) $(cvars) -Iinclude -DALL_INTERIOR_POINTERS -DGC_NOT_DLL -D_CRT_SECURE_NO_DEPRECATE $*.c /Fo$*.obj .cpp.obj: $(cc) $(cdebug) $(cflags) $(cvars) -Iinclude -DALL_INTERIOR_POINTERS -DGC_NOT_DLL -D_CRT_SECURE_NO_DEPRECATE $*.cpp /Fo$*.obj $(OBJS) tests\test.obj: include\private\gc_priv.h include\private\gc_hdrs.h include\gc.h include\private\gcconfig.h include\private\gc_locks.h include\private\gc_pmark.h include\gc_mark.h include\gc_disclaim.h include\private\msvc_dbg.h gc.lib: $(OBJS) lib /MACHINE:i386 /out:gc.lib $(OBJS) # The original NT SDK used lib32 instead of lib gctest.exe: tests\test.obj gc.lib # The following works for win32 debugging. For win32s debugging use debugtype:coff # and add mapsympe line. # This produces a "GUI" applications that opens no windows and writes to the log file # "gctest.gc.log". This is done to make the result runnable under win32s. $(link) -debug -debugtype:cv $(guiflags) -stack:131072 -out:$*.exe tests\test.obj $(guilibs) gc.lib # mapsympe -n -o gctest.sym gctest.exe cord\de_win.rbj: cord\de_win.res cvtres /MACHINE:$(MY_CPU) /OUT:cord\de_win.rbj cord\de_win.res cord\tests\de.obj cord\tests\de_win.obj: include\cord.h include\cord_pos.h cord\tests\de_win.h cord\tests\de_cmds.h cord\de_win.res: cord\tests\de_win.rc cord\tests\de_win.h cord\tests\de_cmds.h $(rc) $(rcvars) -r -fo cord\de_win.res cord\tests\de_win.rc # Cord/de is a real win32 gui application. cord\de.exe: cord\cordbscs.obj cord\cordxtra.obj cord\tests\de.obj cord\tests\de_win.obj cord\de_win.rbj gc.lib $(link) -debug -debugtype:cv $(guiflags) -stack:16384 -out:cord\de.exe cord\cordbscs.obj cord\cordxtra.obj cord\tests\de.obj cord\tests\de_win.obj cord\de_win.rbj gc.lib $(guilibs) gc_cpp.obj: include\gc_cpp.h include\gc.h gc_cpp.cpp: gc_cpp.cc # copy gc_cpp.cc gc_cpp.cpp test_cpp.cpp: tests\test_cpp.cc copy tests\test_cpp.cc test_cpp.cpp # This generates the C++ test executable. The executable expects # a single numeric argument, which is the number of iterations. # The output appears in the file "test_cpp.gc.log". test_cpp.exe: test_cpp.obj include\gc_cpp.h include\gc.h gc.lib $(link) -debug -debugtype:cv $(guiflags) -stack:16384 -out:test_cpp.exe test_cpp.obj gc.lib $(guilibs) ecl-16.1.2/src/bdwgc/NT_STATIC_THREADS_MAKEFILE000066400000000000000000000066371266352375300201730ustar00rootroot00000000000000# Makefile for Windows NT. Assumes Microsoft compiler. # Use "nmake nodebug=1 all" for optimized versions of library, gctest and editor. MY_CPU=X86 CPU=$(MY_CPU) !include # Make sure that .cc is not viewed as a suffix. It is for VC++2005, but # not earlier versions. We can deal with either, but not inconsistency. .SUFFIXES: .SUFFIXES: .obj .cpp .c # Atomic_ops installation directory. For win32, the source directory # should do, since we only need the headers. # We assume this was manually unpacked, since I'm not sure there is # a Windows standard command line tool to do this. AO_SRC_DIR=libatomic_ops/src AO_INCLUDE_DIR=$(AO_SRC_DIR) OBJS= alloc.obj reclaim.obj allchblk.obj misc.obj mach_dep.obj os_dep.obj mark_rts.obj headers.obj mark.obj obj_map.obj blacklst.obj finalize.obj new_hblk.obj dbg_mlc.obj fnlz_mlc.obj malloc.obj stubborn.obj dyn_load.obj typd_mlc.obj ptr_chck.obj gc_cpp.obj mallocx.obj win32_threads.obj extra\msvc_dbg.obj thread_local_alloc.obj all: gctest.exe cord\de.exe test_cpp.exe .c.obj: $(cc) $(cdebug) $(cflags) $(cvarsmt) -Iinclude -I$(AO_INCLUDE_DIR) -DALL_INTERIOR_POINTERS -DGC_NOT_DLL -DGC_THREADS -DTHREAD_LOCAL_ALLOC -DPARALLEL_MARK -D_CRT_SECURE_NO_DEPRECATE $*.c /Fo$*.obj .cpp.obj: $(cc) $(cdebug) $(cflags) $(cvarsmt) -Iinclude -I$(AO_INCLUDE_DIR) -DALL_INTERIOR_POINTERS -DGC_NOT_DLL -DGC_THREADS -DTHREAD_LOCAL_ALLOC -D_CRT_SECURE_NO_DEPRECATE $*.cpp /Fo$*.obj $(OBJS) tests\test.obj: include\private\gc_priv.h include\private\gc_hdrs.h include\gc.h include\private\gcconfig.h include\private\gc_locks.h include\private\gc_pmark.h include\gc_mark.h include\gc_disclaim.h include\private\msvc_dbg.h gc.lib: $(OBJS) lib /MACHINE:i386 /out:gc.lib $(OBJS) # The original NT SDK used lib32 instead of lib gctest.exe: tests\test.obj gc.lib # The following works for win32 debugging. For win32s debugging use debugtype:coff # and add mapsympe line. # This produces a "GUI" applications that opens no windows and writes to the log file # "gctest.gc.log". This is done to make the result runnable under win32s. $(link) -debug -debugtype:cv $(guiflags) -stack:262144 -out:$*.exe tests\test.obj $(guilibs) gc.lib # mapsympe -n -o gctest.sym gctest.exe cord\de_win.rbj: cord\de_win.res cvtres /MACHINE:$(MY_CPU) /OUT:cord\de_win.rbj cord\de_win.res cord\tests\de.obj cord\tests\de_win.obj: include\cord.h include\cord_pos.h cord\tests\de_win.h cord\tests\de_cmds.h cord\de_win.res: cord\tests\de_win.rc cord\tests\de_win.h cord\tests\de_cmds.h $(rc) $(rcvars) -r -fo cord\de_win.res cord\tests\de_win.rc # Cord/de is a real win32 gui application. cord\de.exe: cord\cordbscs.obj cord\cordxtra.obj cord\tests\de.obj cord\tests\de_win.obj cord\de_win.rbj gc.lib $(link) -debug -debugtype:cv $(guiflags) -stack:16384 -out:cord\de.exe cord\cordbscs.obj cord\cordxtra.obj cord\tests\de.obj cord\tests\de_win.obj cord\de_win.rbj gc.lib $(guilibs) gc_cpp.obj: include\gc_cpp.h include\gc.h gc_cpp.cpp: gc_cpp.cc # copy gc_cpp.cc gc_cpp.cpp test_cpp.cpp: tests\test_cpp.cc copy tests\test_cpp.cc test_cpp.cpp # This generates the C++ test executable. The executable expects # a single numeric argument, which is the number of iterations. # The output appears in the file "test_cpp.gc.log". test_cpp.exe: test_cpp.obj include\gc_cpp.h include\gc.h gc.lib $(link) -debug -debugtype:cv $(guiflags) -stack:16384 -out:test_cpp.exe test_cpp.obj gc.lib $(guilibs) AO_SCR_DIR: tar xvfz $(AO_SRC_DIR).tar.gz; ecl-16.1.2/src/bdwgc/NT_X64_STATIC_THREADS_MAKEFILE000066400000000000000000000065121266352375300206240ustar00rootroot00000000000000# Makefile for Windows NT. Assumes Microsoft compiler. # Use "nmake nodebug=1 all" for optimized versions of library, gctest and editor. MY_CPU=AMD64 CPU=$(MY_CPU) !include # Make sure that .cc is not viewed as a suffix. It is for VC++2005, but # not earlier versions. We can deal with either, but not inconsistency. .SUFFIXES: .SUFFIXES: .obj .cpp .c # Atomic_ops installation directory. For win32, the source directory # should do, since we only need the headers. # We assume this was manually unpacked, since I'm not sure there is # a Windows standard command line tool to do this. AO_SRC_DIR=libatomic_ops/src AO_INCLUDE_DIR=$(AO_SRC_DIR) OBJS= alloc.obj reclaim.obj allchblk.obj misc.obj mach_dep.obj os_dep.obj mark_rts.obj headers.obj mark.obj obj_map.obj blacklst.obj finalize.obj new_hblk.obj dbg_mlc.obj fnlz_mlc.obj malloc.obj stubborn.obj dyn_load.obj typd_mlc.obj ptr_chck.obj gc_cpp.obj mallocx.obj win32_threads.obj extra\msvc_dbg.obj thread_local_alloc.obj all: gctest.exe cord\de.exe test_cpp.exe .c.obj: $(cc) $(cdebug) $(cflags) $(cvarsmt) -Iinclude -I$(AO_INCLUDE_DIR) -DALL_INTERIOR_POINTERS -DGC_NOT_DLL -DGC_THREADS -DTHREAD_LOCAL_ALLOC -D_CRT_SECURE_NO_DEPRECATE $*.c /Fo$*.obj /wd4701 # Disable "may not be initialized" warnings. They're too approximate. # Disable crt security warnings, since unfortunately they warn about all sorts # of safe uses of strncpy. It would be nice to leave the rest enabled. .cpp.obj: $(cc) $(cdebug) $(cflags) $(cvarsmt) -Iinclude -I$(AO_INCLUDE_DIR) -DALL_INTERIOR_POINTERS -DGC_NOT_DLL -DGC_THREADS -DTHREAD_LOCAL_ALLOC -D_CRT_SECURE_NO_DEPRECATE $*.cpp /Fo$*.obj $(OBJS) tests\test.obj: include\private\gc_priv.h include\private\gc_hdrs.h include\gc.h include\private\gcconfig.h include\private\gc_locks.h include\private\gc_pmark.h include\gc_mark.h include\gc_disclaim.h include\private\msvc_dbg.h gc.lib: $(OBJS) lib /MACHINE:X64 /out:gc.lib $(OBJS) gctest.exe: tests\test.obj gc.lib # This produces a "GUI" applications that opens no windows and writes to # the log file "gctest.gc.log". $(link) $(ldebug) $(guiflags) -out:$*.exe tests\test.obj $(guilibs) gc.lib cord\de_win.rbj: cord\de_win.res cvtres /MACHINE:$(MY_CPU) /OUT:cord\de_win.rbj cord\de_win.res cord\tests\de.obj cord\tests\de_win.obj: include\cord.h include\cord_pos.h cord\tests\de_win.h cord\tests\de_cmds.h cord\de_win.res: cord\tests\de_win.rc cord\tests\de_win.h cord\tests\de_cmds.h $(rc) $(rcvars) -r -fo cord\de_win.res cord\tests\de_win.rc # Cord/de is a real win32 gui application. cord\de.exe: cord\cordbscs.obj cord\cordxtra.obj cord\tests\de.obj cord\tests\de_win.obj cord\de_win.rbj gc.lib $(link) $(ldebug) $(guiflags) -stack:16384 -out:cord\de.exe cord\cordbscs.obj cord\cordxtra.obj cord\tests\de.obj cord\tests\de_win.obj cord\de_win.rbj gc.lib $(guilibs) gc_cpp.obj: include\gc_cpp.h include\gc.h gc_cpp.cpp: gc_cpp.cc # copy gc_cpp.cc gc_cpp.cpp test_cpp.cpp: tests\test_cpp.cc copy tests\test_cpp.cc test_cpp.cpp # This generates the C++ test executable. The executable expects # a single numeric argument, which is the number of iterations. # The output appears in the file "test_cpp.gc.log". test_cpp.exe: test_cpp.obj include\gc_cpp.h include\gc.h gc.lib $(link) $(ldebug) $(guiflags) -stack:16384 -out:test_cpp.exe test_cpp.obj gc.lib $(guilibs) AO_SCR_DIR: tar xvfz $(AO_SRC_DIR).tar.gz; ecl-16.1.2/src/bdwgc/NT_X64_THREADS_MAKEFILE000066400000000000000000000077231266352375300175620ustar00rootroot00000000000000# Makefile for Windows NT. Assumes Microsoft compiler. # modified 2007 August by Friedrich Dominicus: # - copied from NT_X64_STATIC_THREADS_MAKEFILES # - checked agaist gc.mak (NT_THREADS_MAKEFILE) # - added changes to integrate the tools # - currently just with debug information # problems can be sent to # frido at q-software-solutions.de # # or the mailing list MY_CPU=AMD64 CPU=$(MY_CPU) !include # Make sure that .cc is not viewed as a suffix. It is for VC++2005, but # not earlier versions. We can deal with either, but not inconsistency. .SUFFIXES: .SUFFIXES: .obj .cpp .c # Atomic_ops installation directory. For win32, the source directory # should do, since we only need the headers. # We assume this was manually unpacked, since I'm not sure there is # a Windows standard command line tool to do this. AO_SRC_DIR=libatomic_ops/src AO_INCLUDE_DIR=$(AO_SRC_DIR) OBJS= alloc.obj reclaim.obj allchblk.obj misc.obj mach_dep.obj os_dep.obj mark_rts.obj headers.obj mark.obj obj_map.obj blacklst.obj finalize.obj new_hblk.obj dbg_mlc.obj fnlz_mlc.obj malloc.obj stubborn.obj dyn_load.obj typd_mlc.obj ptr_chck.obj gc_cpp.obj mallocx.obj win32_threads.obj extra\msvc_dbg.obj thread_local_alloc.obj all: gc64.dll gctest.exe cord\de.exe test_cpp.exe .c.obj: $(cc) $(cdebug) $(cflags) $(cvarsmt) -Iinclude -I$(AO_INCLUDE_DIR) -DALL_INTERIOR_POINTERS -DGC_DLL -DGC_THREADS -D_CRT_SECURE_NO_DEPRECATE $*.c /Fo$*.obj /wd4701 # Disable "may not be initialized" warnings. They're too approximate. # Disable crt security warnings, since unfortunately they warn about all sorts # of safe uses of strncpy. It would be nice to leave the rest enabled. .cpp.obj: $(cc) $(cdebug) $(cflags) $(cvarsmt) -Iinclude -I$(AO_INCLUDE_DIR) -DALL_INTERIOR_POINTERS -DGC_DLL -DGC_THREADS -D_CRT_SECURE_NO_DEPRECATE $*.cpp /Fo$*.obj $(OBJS) tests\test.obj: include\private\gc_priv.h include\private\gc_hdrs.h include\gc.h include\private\gcconfig.h include\private\gc_locks.h include\private\gc_pmark.h include\gc_mark.h include\gc_disclaim.h include\private\msvc_dbg.h LINK64=link.exe LINK64_FLAGS=kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib \ shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo \ /subsystem:windows /dll /incremental:no /pdb:"gc.pdb" /machine:X64 /out:"gc64.dll" \ /implib:"gc64_dll.lib" gc64.dll : $(OBJS) $(LINK64) $(ldebug) $(LINK64_FLAGS) $(OBJS) gctest.exe: tests\test.obj gc64_dll.lib # This produces a "GUI" applications that opens no windows and writes to # the log file "gctest.gc.log". $(link) $(ldebug) $(guiflags) -out:$*.exe tests\test.obj $(guilibs) gc64_dll.lib cord\de_win.rbj: cord\de_win.res cvtres /MACHINE:$(MY_CPU) /OUT:cord\de_win.rbj cord\de_win.res cord\tests\de.obj cord\tests\de_win.obj: include\cord.h include\cord_pos.h cord\tests\de_win.h cord\tests\de_cmds.h cord\de_win.res: cord\tests\de_win.rc cord\tests\de_win.h cord\tests\de_cmds.h $(rc) $(rcvars) -r -fo cord\de_win.res cord\tests\de_win.rc # Cord/de is a real win32 gui application. cord\de.exe: cord\cordbscs.obj cord\cordxtra.obj cord\tests\de.obj cord\tests\de_win.obj cord\de_win.rbj gc64_dll.lib $(link) $(ldebug) $(guiflags) -stack:16384 -out:cord\de.exe cord\cordbscs.obj cord\cordxtra.obj cord\tests\de.obj cord\tests\de_win.obj cord\de_win.rbj gc64_dll.lib $(guilibs) gc_cpp.obj: include\gc_cpp.h include\gc.h gc_cpp.cpp: gc_cpp.cc # copy gc_cpp.cc gc_cpp.cpp test_cpp.cpp: tests\test_cpp.cc copy tests\test_cpp.cc test_cpp.cpp # This generates the C++ test executable. The executable expects # a single numeric argument, which is the number of iterations. # The output appears in the file "test_cpp.gc.log". test_cpp.exe: test_cpp.obj include\gc_cpp.h include\gc.h gc64_dll.lib $(link) $(ldebug) $(guiflags) -stack:16384 -out:test_cpp.exe test_cpp.obj gc64_dll.lib $(guilibs) AO_SCR_DIR: tar xvfz $(AO_SRC_DIR).tar.gz; clean: del *.obj gc64_dll.lib gc64.dll ecl-16.1.2/src/bdwgc/OS2_MAKEFILE000066400000000000000000000037311266352375300160240ustar00rootroot00000000000000# Makefile for OS/2. Assumes IBM's compiler, static linking, and a single thread. # Adding dynamic linking support seems easy, but takes a little bit of work. # Adding thread support may be nontrivial, since we haven't yet figured out how to # look at another thread's registers. # Significantly revised for GC version 4.4 by Mark Boulter (Jan 1994). OBJS= alloc.obj reclaim.obj allchblk.obj misc.obj mach_dep.obj os_dep.obj mark_rts.obj headers.obj mark.obj obj_map.obj blacklst.obj finalize.obj new_hblk.obj dbg_mlc.obj fnlz_mlc.obj malloc.obj stubborn.obj typd_mlc.obj ptr_chck.obj mallocx.obj CORDOBJS= cord\cordbscs.obj cord\cordxtra.obj cord\cordprnt.obj CC= icc CFLAGS= /O /Q /DSMALL_CONFIG /DALL_INTERIOR_POINTERS # Use /Ti instead of /O for debugging # Setjmp_test may yield overly optimistic results when compiled # without optimization. all: $(OBJS) gctest.exe cord\cordtest.exe $(OBJS) test.obj: include\private\gc_priv.h include\private\gc_hdrs.h include\gc.h include\private\gcconfig.h ## ERASE THE LIB FIRST - if it is already there then this command will fail ## (make sure its there or erase will fail!) gc.lib: $(OBJS) echo . > gc.lib erase gc.lib LIB gc.lib $(OBJS), gc.lst mach_dep.obj: mach_dep.c $(CC) $(CFLAGS) /C mach_dep.c gctest.exe: test.obj gc.lib $(CC) $(CFLAGS) /B"/STACK:524288" /Fegctest test.obj gc.lib cord\cordbscs.obj: cord\cordbscs.c include\cord.h include\cord_pos.h $(CC) $(CFLAGS) /C /Focord\cordbscs cord\cordbscs.c cord\cordxtra.obj: cord\cordxtra.c include\cord.h include\cord_pos.h include\ec.h $(CC) $(CFLAGS) /C /Focord\cordxtra cord\cordxtra.c cord\cordprnt.obj: cord\cordprnt.c include\cord.h include\cord_pos.h include\ec.h $(CC) $(CFLAGS) /C /Focord\cordprnt cord\cordprnt.c cord\cordtest.exe: cord\tests\cordtest.c include\cord.h include\cord_pos.h include\ec.h $(CORDOBJS) gc.lib $(CC) $(CFLAGS) /B"/STACK:65536" /Fecord\cordtest cord\tests\cordtest.c gc.lib $(CORDOBJS) ecl-16.1.2/src/bdwgc/PCR-Makefile000066400000000000000000000024041266352375300163170ustar00rootroot00000000000000# # Default target # default: gc.o include ../config/common.mk # # compilation flags, etc. # CPPFLAGS = $(INCLUDE) $(CONFIG_CPPFLAGS) \ -DPCR_NO_RENAME -DPCR_NO_HOSTDEP_ERR #CFLAGS = -DPCR $(CONFIG_CFLAGS) CFLAGS = -DPCR $(CONFIG_CFLAGS) SPECIALCFLAGS = # For code involving asm's ASPPFLAGS = $(INCLUDE) $(CONFIG_ASPPFLAGS) \ -DPCR_NO_RENAME -DPCR_NO_HOSTDEP_ERR -DASM ASFLAGS = $(CONFIG_ASFLAGS) LDRFLAGS = $(CONFIG_LDRFLAGS) LDFLAGS = $(CONFIG_LDFLAGS) # # BEGIN PACKAGE-SPECIFIC PART # # Fix to point to local pcr installation directory. PCRDIR= .. COBJ= alloc.o reclaim.o allchblk.o misc.o os_dep.o mark_rts.o headers.o mark.o obj_map.o pcr_interface.o blacklst.o finalize.o new_hblk.o real_malloc.o dyn_load.o dbg_mlc.o fnlz_mlc.o malloc.o stubborn.o checksums.o solaris_threads.o typd_mlc.o ptr_chck.o mallocx.o CSRC= reclaim.c allchblk.c misc.c alloc.c mach_dep.c os_dep.c mark_rts.c headers.c mark.c obj_map.c pcr_interface.c blacklst.c finalize.c new_hblk.c real_malloc.c dyn_load.c dbg_mlc.c fnlz_mlc.c malloc.c stubborn.c checksums.c solaris_threads.c typd_mlc.c ptr_chck.c mallocx.c SHELL= /bin/sh default: gc.o gc.o: $(COBJ) mach_dep.o $(LDR) $(CONFIG_LDRFLAGS) -o gc.o $(COBJ) mach_dep.o mach_dep.o: mach_dep.c $(CC) -c $(SPECIALCFLAGS) mach_dep.c ecl-16.1.2/src/bdwgc/README.QUICK000066400000000000000000000100671266352375300157740ustar00rootroot00000000000000Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers Copyright (c) 1991-1995 by Xerox Corporation. All rights reserved. Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. Copyright (c) 1999-2001 by Hewlett-Packard. All rights reserved. THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED OR IMPLIED. ANY USE IS AT YOUR OWN RISK. Permission is hereby granted to use or copy this program for any purpose, provided the above notices are retained on all copies. Permission to modify the code and to distribute modified code is granted, provided the above notices are retained, and a notice that the code was modified is included with the above copyright notice. A few files have other copyright holders. A few of the files needed to use the GNU-style build procedure come with a modified GPL license that appears not to significantly restrict use of the collector, though use of those files for a purpose other than building the collector may require the resulting code to be covered by the GPL. For more details and the names of other contributors, see the README.md, doc/README.*, AUTHORS and include/gc.h files. These files describe typical use of the collector on a machine that is already supported. For the version number, see README.md or include/gc_version.h files. INSTALLATION: Under UN*X, Linux: Alternative 1 (the old way): type "make test" in this directory. Link against gc.a. With the most recent GC distributions you may have to type "make -f Makefile.direct test" or copy Makefile.direct to Makefile first. Alternative 2 (the new way): type "./configure --prefix=; make; make check; make install". Link against /lib/libgc.a or /lib/libgc.so. See doc/README.autoconf for details Under Windows 95, 98, Me, NT, or 2000: copy the appropriate makefile to MAKEFILE, read it, and type "nmake test". (Under Windows, this assumes you have Microsoft command-line tools installed, and suitably configured.) Read the machine specific README.XXX in the doc directory if one exists. If you need thread support, you will need to follow the special platform-dependent instructions (win32), or define GC_THREADS as described in doc/README.macros, or possibly use --enable-threads=posix when running the configure script. If you wish to use the cord (structured string) library with the stand-alone Makefile.direct, type "make cords", after copying to "Makefile". (This requires an ANSI C compiler. You may need to redefine CC in the Makefile. The CORD_printf implementation in cordprnt.c is known to be less than perfectly portable. The rest of the package should still work.) See include/cord.h for the API. If you wish to use the collector from C++, type "make c++", or use --enable-cplusplus with the configure script. With Makefile.direct, these ones add further files to gc.a and to the include subdirectory. With the alternate build process, this generates libgccpp. See include/gc_cpp.h. TYPICAL USE: Include "gc.h" from the include subdirectory. Link against the appropriate library ("gc.a" under UN*X). Replace calls to malloc by calls to GC_MALLOC, and calls to realloc by calls to GC_REALLOC. If the object is known to never contain pointers, use GC_MALLOC_ATOMIC instead of GC_MALLOC. Define GC_DEBUG before including gc.h for additional checking. More documentation on the collector interface can be found in README.md, doc/gcinterface.html, include/gc.h, and other files in the doc directory. WARNINGS: Do not store the only pointer to an object in memory allocated with system malloc, since the collector usually does not scan memory allocated in this way. Use with threads may be supported on your system, but requires the collector to be built with thread support. See Makefile. The collector does not guarantee to scan thread-local storage (e.g. of the kind accessed with pthread_getspecific()). The collector does scan thread stacks though, so generally the best solution is to ensure that any pointers stored in thread-local storage are also stored on the thread's stack for the duration of their lifetime. ecl-16.1.2/src/bdwgc/README.md000066400000000000000000000702021266352375300155150ustar00rootroot00000000000000# Boehm-Demers-Weiser Garbage Collector This is version 7.5.0 (next release development) of a conservative garbage collector for C and C++. You might find a more recent version [here](http://www.hboehm.info/gc/), or [here](https://github.com/ivmai/bdwgc). ## Overview This is intended to be a general purpose, garbage collecting storage allocator. The algorithms used are described in: * Boehm, H., and M. Weiser, "Garbage Collection in an Uncooperative Environment", Software Practice & Experience, September 1988, pp. 807-820. * Boehm, H., A. Demers, and S. Shenker, "Mostly Parallel Garbage Collection", Proceedings of the ACM SIGPLAN '91 Conference on Programming Language Design and Implementation, SIGPLAN Notices 26, 6 (June 1991), pp. 157-164. * Boehm, H., "Space Efficient Conservative Garbage Collection", Proceedings of the ACM SIGPLAN '91 Conference on Programming Language Design and Implementation, SIGPLAN Notices 28, 6 (June 1993), pp. 197-206. * Boehm H., "Reducing Garbage Collector Cache Misses", Proceedings of the 2000 International Symposium on Memory Management. Possible interactions between the collector and optimizing compilers are discussed in * Boehm, H., and D. Chase, "A Proposal for GC-safe C Compilation", The Journal of C Language Translation 4, 2 (December 1992). and * Boehm H., "Simple GC-safe Compilation", Proceedings of the ACM SIGPLAN '96 Conference on Programming Language Design and Implementation. Unlike the collector described in the second reference, this collector operates either with the mutator stopped during the entire collection (default) or incrementally during allocations. (The latter is supported on fewer machines.) On the most common platforms, it can be built with or without thread support. On a few platforms, it can take advantage of a multiprocessor to speed up garbage collection. Many of the ideas underlying the collector have previously been explored by others. Notably, some of the run-time systems developed at Xerox PARC in the early 1980s conservatively scanned thread stacks to locate possible pointers (cf. Paul Rovner, "On Adding Garbage Collection and Runtime Types to a Strongly-Typed Statically Checked, Concurrent Language" Xerox PARC CSL 84-7). Doug McIlroy wrote a simpler fully conservative collector that was part of version 8 UNIX (tm), but appears to not have received widespread use. Rudimentary tools for use of the collector as a [leak detector](http://www.hboehm.info/gc/leak.html) are included, as is a fairly sophisticated string package "cord" that makes use of the collector. (See doc/README.cords and H.-J. Boehm, R. Atkinson, and M. Plass, "Ropes: An Alternative to Strings", Software Practice and Experience 25, 12 (December 1995), pp. 1315-1330. This is very similar to the "rope" package in Xerox Cedar, or the "rope" package in the SGI STL or the g++ distribution.) Further collector documentation can be found [here](http://www.hboehm.info/gc/). ## General Description This is a garbage collecting storage allocator that is intended to be used as a plug-in replacement for C's malloc. Since the collector does not require pointers to be tagged, it does not attempt to ensure that all inaccessible storage is reclaimed. However, in our experience, it is typically more successful at reclaiming unused memory than most C programs using explicit deallocation. Unlike manually introduced leaks, the amount of unreclaimed memory typically stays bounded. In the following, an "object" is defined to be a region of memory allocated by the routines described below. Any objects not intended to be collected must be pointed to either from other such accessible objects, or from the registers, stack, data, or statically allocated bss segments. Pointers from the stack or registers may point to anywhere inside an object. The same is true for heap pointers if the collector is compiled with `ALL_INTERIOR_POINTERS` defined, or `GC_all_interior_pointers` is otherwise set, as is now the default. Compiling without `ALL_INTERIOR_POINTERS` may reduce accidental retention of garbage objects, by requiring pointers from the heap to the beginning of an object. But this no longer appears to be a significant issue for most programs occupying a small fraction of the possible address space. There are a number of routines which modify the pointer recognition algorithm. `GC_register_displacement` allows certain interior pointers to be recognized even if `ALL_INTERIOR_POINTERS` is nor defined. `GC_malloc_ignore_off_page` allows some pointers into the middle of large objects to be disregarded, greatly reducing the probability of accidental retention of large objects. For most purposes it seems best to compile with `ALL_INTERIOR_POINTERS` and to use `GC_malloc_ignore_off_page` if you get collector warnings from allocations of very large objects. See doc/debugging.html for details. _WARNING_: pointers inside memory allocated by the standard `malloc` are not seen by the garbage collector. Thus objects pointed to only from such a region may be prematurely deallocated. It is thus suggested that the standard `malloc` be used only for memory regions, such as I/O buffers, that are guaranteed not to contain pointers to garbage collectible memory. Pointers in C language automatic, static, or register variables, are correctly recognized. (Note that `GC_malloc_uncollectable` has semantics similar to standard malloc, but allocates objects that are traced by the collector.) _WARNING_: the collector does not always know how to find pointers in data areas that are associated with dynamic libraries. This is easy to remedy IF you know how to find those data areas on your operating system (see `GC_add_roots`). Code for doing this under SunOS, IRIX 5.X and 6.X, HP/UX, Alpha OSF/1, Linux, and win32 is included and used by default. (See doc/README.win32 for Win32 details.) On other systems pointers from dynamic library data areas may not be considered by the collector. If you're writing a program that depends on the collector scanning dynamic library data areas, it may be a good idea to include at least one call to `GC_is_visible` to ensure that those areas are visible to the collector. Note that the garbage collector does not need to be informed of shared read-only data. However if the shared library mechanism can introduce discontiguous data areas that may contain pointers, then the collector does need to be informed. Signal processing for most signals may be deferred during collection, and during uninterruptible parts of the allocation process. Like standard ANSI C mallocs, by default it is unsafe to invoke malloc (and other GC routines) from a signal handler while another malloc call may be in progress. The allocator/collector can also be configured for thread-safe operation. (Full signal safety can also be achieved, but only at the cost of two system calls per malloc, which is usually unacceptable.) _WARNING_: the collector does not guarantee to scan thread-local storage (e.g. of the kind accessed with `pthread_getspecific`). The collector does scan thread stacks, though, so generally the best solution is to ensure that any pointers stored in thread-local storage are also stored on the thread's stack for the duration of their lifetime. (This is arguably a longstanding bug, but it hasn't been fixed yet.) ## Installation and Portability As distributed, the collector operates silently In the event of problems, this can usually be changed by defining the `GC_PRINT_STATS` or `GC_PRINT_VERBOSE_STATS` environment variables. This will result in a few lines of descriptive output for each collection. (The given statistics exhibit a few peculiarities. Things don't appear to add up for a variety of reasons, most notably fragmentation losses. These are probably much more significant for the contrived program "test.c" than for your application.) On most Unix-like platforms, the collector can be built either using a GNU autoconf-based build infrastructure (type `./configure; make` in the simplest case), or with a classic makefile by itself (type `make -f Makefile.direct`). Please note that the collector source repository does not contain configure and similar auto-generated files, thus the full procedure of autoconf-based build of `master` branch of the collector (using `master` branch of libatomic_ops source repository as well) could look like: git clone git://github.com/ivmai/bdwgc.git cd bdwgc git clone git://github.com/ivmai/libatomic_ops.git autoreconf -vif automake --add-missing ./configure make make check Below we focus on the collector build using classic makefile. For the Makefile.direct-based process, typing `make test` instead of `make` will automatically build the collector and then run `setjmp_test` and `gctest`. `Setjmp_test` will give you information about configuring the collector, which is useful primarily if you have a machine that's not already supported. Gctest is a somewhat superficial test of collector functionality. Failure is indicated by a core dump or a message to the effect that the collector is broken. Gctest takes about a second to two to run on reasonable 2007 vintage desktops. It may use up to about 30MB of memory. (The multi-threaded version will use more. 64-bit versions may use more.) `make test` will also, as its last step, attempt to build and test the "cord" string library.) Makefile.direct will generate a library gc.a which you should link against. Typing "make cords" will add the cord library to gc.a. The GNU style build process understands the usual targets. `make check` runs a number of tests. `make install` installs at least libgc, and libcord. Try `./configure --help` to see the configuration options. It is currently not possible to exercise all combinations of build options this way. It is suggested that if you need to replace a piece of the collector (e.g. GC_mark_rts.c) you simply list your version ahead of gc.a on the ld command line, rather than replacing the one in gc.a. (This will generate numerous warnings under some versions of AIX, but it still works.) All include files that need to be used by clients will be put in the include subdirectory. (Normally this is just gc.h. `make cords` adds "cord.h" and "ec.h".) The collector currently is designed to run essentially unmodified on machines that use a flat 32-bit or 64-bit address space. That includes the vast majority of Workstations and X86 (X >= 3) PCs. (The list here was deleted because it was getting too long and constantly out of date.) In a few cases (Amiga, OS/2, Win32, MacOS) a separate makefile or equivalent is supplied. Many of these have separate README.system files. Dynamic libraries are completely supported only under SunOS/Solaris, (and even that support is not functional on the last Sun 3 release), Linux, FreeBSD, NetBSD, IRIX 5&6, HP/UX, Win32 (not Win32S) and OSF/1 on DEC AXP machines plus perhaps a few others listed near the top of dyn_load.c. On other machines we recommend that you do one of the following: 1) Add dynamic library support (and send us the code). 2) Use static versions of the libraries. 3) Arrange for dynamic libraries to use the standard malloc. This is still dangerous if the library stores a pointer to a garbage collected object. But nearly all standard interfaces prohibit this, because they deal correctly with pointers to stack allocated objects. (Strtok is an exception. Don't use it.) In all cases we assume that pointer alignment is consistent with that enforced by the standard C compilers. If you use a nonstandard compiler you may have to adjust the alignment parameters defined in gc_priv.h. Note that this may also be an issue with packed records/structs, if those enforce less alignment for pointers. A port to a machine that is not byte addressed, or does not use 32 bit or 64 bit addresses will require a major effort. A port to plain MSDOS or win16 is hard. For machines not already mentioned, or for nonstandard compilers, some porting suggestions are provided in doc/porting.html. ## The C Interface to the Allocator The following routines are intended to be directly called by the user. Note that usually only `GC_malloc` is necessary. `GC_clear_roots` and `GC_add_roots` calls may be required if the collector has to trace from nonstandard places (e.g. from dynamic library data areas on a machine on which the collector doesn't already understand them.) On some machines, it may be desirable to set `GC_stacktop` to a good approximation of the stack base. (This enhances code portability on HP PA machines, since there is no good way for the collector to compute this value.) Client code may include "gc.h", which defines all of the following, plus many others. 1) `GC_malloc(nbytes)` - Allocate an object of size nbytes. Unlike malloc, the object is cleared before being returned to the user. `GC_malloc` will invoke the garbage collector when it determines this to be appropriate. GC_malloc may return 0 if it is unable to acquire sufficient space from the operating system. This is the most probable consequence of running out of space. Other possible consequences are that a function call will fail due to lack of stack space, or that the collector will fail in other ways because it cannot maintain its internal data structures, or that a crucial system process will fail and take down the machine. Most of these possibilities are independent of the malloc implementation. 2) `GC_malloc_atomic(nbytes)` - Allocate an object of size nbytes that is guaranteed not to contain any pointers. The returned object is not guaranteed to be cleared. (Can always be replaced by `GC_malloc`, but results in faster collection times. The collector will probably run faster if large character arrays, etc. are allocated with `GC_malloc_atomic` than if they are statically allocated.) 3) `GC_realloc(object, new_size)` - Change the size of object to be `new_size`. Returns a pointer to the new object, which may, or may not, be the same as the pointer to the old object. The new object is taken to be atomic if and only if the old one was. If the new object is composite and larger than the original object,then the newly added bytes are cleared (we hope). This is very likely to allocate a new object, unless `MERGE_SIZES` is defined in gc_priv.h. Even then, it is likely to recycle the old object only if the object is grown in small additive increments (which, we claim, is generally bad coding practice.) 4) `GC_free(object)` - Explicitly deallocate an object returned by `GC_malloc` or `GC_malloc_atomic`. Not necessary, but can be used to minimize collections if performance is critical. Probably a performance loss for very small objects (<= 8 bytes). 5) `GC_expand_hp(bytes)` - Explicitly increase the heap size. (This is normally done automatically if a garbage collection failed to `GC_reclaim` enough memory. Explicit calls to `GC_expand_hp` may prevent unnecessarily frequent collections at program startup.) 6) `GC_malloc_ignore_off_page(bytes)` - Identical to `GC_malloc`, but the client promises to keep a pointer to the somewhere within the first 256 bytes of the object while it is live. (This pointer should normally be declared volatile to prevent interference from compiler optimizations.) This is the recommended way to allocate anything that is likely to be larger than 100 Kbytes or so. (`GC_malloc` may result in failure to reclaim such objects.) 7) `GC_set_warn_proc(proc)` - Can be used to redirect warnings from the collector. Such warnings should be rare, and should not be ignored during code development. 8) `GC_enable_incremental()` - Enables generational and incremental collection. Useful for large heaps on machines that provide access to page dirty information. Some dirty bit implementations may interfere with debugging (by catching address faults) and place restrictions on heap arguments to system calls (since write faults inside a system call may not be handled well). 9) Several routines to allow for registration of finalization code. User supplied finalization code may be invoked when an object becomes unreachable. To call `(*f)(obj, x)` when obj becomes inaccessible, use `GC_register_finalizer(obj, f, x, 0, 0);` For more sophisticated uses, and for finalization ordering issues, see gc.h. The global variable `GC_free_space_divisor` may be adjusted up from it default value of 3 to use less space and more collection time, or down for the opposite effect. Setting it to 1 will almost disable collections and cause all allocations to simply grow the heap. The variable `GC_non_gc_bytes`, which is normally 0, may be changed to reflect the amount of memory allocated by the above routines that should not be considered as a candidate for collection. Careless use may, of course, result in excessive memory consumption. Some additional tuning is possible through the parameters defined near the top of gc_priv.h. If only `GC_malloc` is intended to be used, it might be appropriate to define: #define malloc(n) GC_malloc(n) #define calloc(m,n) GC_malloc((m)*(n)) For small pieces of VERY allocation intensive code, gc_inl.h includes some allocation macros that may be used in place of `GC_malloc` and friends. All externally visible names in the garbage collector start with `GC_`. To avoid name conflicts, client code should avoid this prefix, except when accessing garbage collector routines or variables. There are provisions for allocation with explicit type information. This is rarely necessary. Details can be found in gc_typed.h. ## The C++ Interface to the Allocator The Ellis-Hull C++ interface to the collector is included in the collector distribution. If you intend to use this, type `make c++` after the initial build of the collector is complete. See gc_cpp.h for the definition of the interface. This interface tries to approximate the Ellis-Detlefs C++ garbage collection proposal without compiler changes. Very often it will also be necessary to use gc_allocator.h and the allocator declared there to construct STL data structures. Otherwise subobjects of STL data structures will be allocated using a system allocator, and objects they refer to may be prematurely collected. ## Use as Leak Detector The collector may be used to track down leaks in C programs that are intended to run with malloc/free (e.g. code with extreme real-time or portability constraints). To do so define `FIND_LEAK` in Makefile. This will cause the collector to invoke the `report_leak` routine defined near the top of reclaim.c whenever an inaccessible object is found that has not been explicitly freed. Such objects will also be automatically reclaimed. If all objects are allocated with `GC_DEBUG_MALLOC` (see next section), then the default version of report_leak will report at least the source file and line number at which the leaked object was allocated. This may sometimes be sufficient. (On a few machines, it will also report a cryptic stack trace. If this is not symbolic, it can sometimes be called into a symbolic stack trace by invoking program "foo" with "tools/callprocs.sh foo". It is a short shell script that invokes adb to expand program counter values to symbolic addresses. It was largely supplied by Scott Schwartz.) Note that the debugging facilities described in the next section can sometimes be slightly LESS effective in leak finding mode, since in leak finding mode, `GC_debug_free` actually results in reuse of the object. (Otherwise the object is simply marked invalid.) Also note that the test program is not designed to run meaningfully in `FIND_LEAK` mode. Use "make gc.a" to build the collector. ## Debugging Facilities The routines `GC_debug_malloc`, `GC_debug_malloc_atomic`, `GC_debug_realloc`, and `GC_debug_free` provide an alternate interface to the collector, which provides some help with memory overwrite errors, and the like. Objects allocated in this way are annotated with additional information. Some of this information is checked during garbage collections, and detected inconsistencies are reported to stderr. Simple cases of writing past the end of an allocated object should be caught if the object is explicitly deallocated, or if the collector is invoked while the object is live. The first deallocation of an object will clear the debugging info associated with an object, so accidentally repeated calls to `GC_debug_free` will report the deallocation of an object without debugging information. Out of memory errors will be reported to stderr, in addition to returning `NULL`. `GC_debug_malloc` checking during garbage collection is enabled with the first call to `GC_debug_malloc`. This will result in some slowdown during collections. If frequent heap checks are desired, this can be achieved by explicitly invoking `GC_gcollect`, e.g. from the debugger. `GC_debug_malloc` allocated objects should not be passed to `GC_realloc` or `GC_free`, and conversely. It is however acceptable to allocate only some objects with `GC_debug_malloc`, and to use `GC_malloc` for other objects, provided the two pools are kept distinct. In this case, there is a very low probability that `GC_malloc` allocated objects may be misidentified as having been overwritten. This should happen with probability at most one in 2**32. This probability is zero if `GC_debug_malloc` is never called. `GC_debug_malloc`, `GC_malloc_atomic`, and `GC_debug_realloc` take two additional trailing arguments, a string and an integer. These are not interpreted by the allocator. They are stored in the object (the string is not copied). If an error involving the object is detected, they are printed. The macros `GC_MALLOC`, `GC_MALLOC_ATOMIC`, `GC_REALLOC`, `GC_FREE`, and `GC_REGISTER_FINALIZER` are also provided. These require the same arguments as the corresponding (nondebugging) routines. If gc.h is included with `GC_DEBUG` defined, they call the debugging versions of these functions, passing the current file name and line number as the two extra arguments, where appropriate. If gc.h is included without `GC_DEBUG` defined, then all these macros will instead be defined to their nondebugging equivalents. (`GC_REGISTER_FINALIZER` is necessary, since pointers to objects with debugging information are really pointers to a displacement of 16 bytes form the object beginning, and some translation is necessary when finalization routines are invoked. For details, about what's stored in the header, see the definition of the type oh in debug_malloc.c) ## Incremental/Generational Collection The collector normally interrupts client code for the duration of a garbage collection mark phase. This may be unacceptable if interactive response is needed for programs with large heaps. The collector can also run in a "generational" mode, in which it usually attempts to collect only objects allocated since the last garbage collection. Furthermore, in this mode, garbage collections run mostly incrementally, with a small amount of work performed in response to each of a large number of `GC_malloc` requests. This mode is enabled by a call to `GC_enable_incremental`. Incremental and generational collection is effective in reducing pause times only if the collector has some way to tell which objects or pages have been recently modified. The collector uses two sources of information: 1. Information provided by the VM system. This may be provided in one of several forms. Under Solaris 2.X (and potentially under other similar systems) information on dirty pages can be read from the /proc file system. Under other systems (currently SunOS4.X) it is possible to write-protect the heap, and catch the resulting faults. On these systems we require that system calls writing to the heap (other than read) be handled specially by client code. See os_dep.c for details. 2. Information supplied by the programmer. We define "stubborn" objects to be objects that are rarely changed. Such an object can be allocated (and enabled for writing) with `GC_malloc_stubborn`. Once it has been initialized, the collector should be informed with a call to `GC_end_stubborn_change`. Subsequent writes that store pointers into the object must be preceded by a call to `GC_change_stubborn`. This mechanism performs best for objects that are written only for initialization, and such that only one stubborn object is writable at once. It is typically not worth using for short-lived objects. Stubborn objects are treated less efficiently than pointer-free (atomic) objects. A rough rule of thumb is that, in the absence of VM information, garbage collection pauses are proportional to the amount of pointerful storage plus the amount of modified "stubborn" storage that is reachable during the collection. Initial allocation of stubborn objects takes longer than allocation of other objects, since other data structures need to be maintained. We recommend against random use of stubborn objects in client code, since bugs caused by inappropriate writes to stubborn objects are likely to be very infrequently observed and hard to trace. However, their use may be appropriate in a few carefully written library routines that do not make the objects themselves available for writing by client code. ## Bugs Any memory that does not have a recognizable pointer to it will be reclaimed. Exclusive-or'ing forward and backward links in a list doesn't cut it. Some C optimizers may lose the last undisguised pointer to a memory object as a consequence of clever optimizations. This has almost never been observed in practice. This is not a real-time collector. In the standard configuration, percentage of time required for collection should be constant across heap sizes. But collection pauses will increase for larger heaps. They will decrease with the number of processors if parallel marking is enabled. (On 2007 vintage machines, GC times may be on the order of 5 msecs per MB of accessible memory that needs to be scanned and processor. Your mileage may vary.) The incremental/generational collection facility may help in some cases. Please address bug reports [here](mailto:bdwgc@lists.opendylan.org). If you are contemplating a major addition, you might also send mail to ask whether it's already been done (or whether we tried and discarded it). ## Copyright & Warranty * Copyright (c) 1988, 1989 Hans-J. Boehm, Alan J. Demers * Copyright (c) 1991-1996 by Xerox Corporation. All rights reserved. * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. * Copyright (c) 1999-2011 by Hewlett-Packard Development Company. The file linux_threads.c is also * Copyright (c) 1998 by Fergus Henderson. All rights reserved. The files Makefile.am, and configure.in are * Copyright (c) 2001 by Red Hat Inc. All rights reserved. Several files supporting GNU-style builds are copyrighted by the Free Software Foundation, and carry a different license from that given below. The files included in the libatomic_ops distribution (included here) use either the license below, or a similar MIT-style license, or, for some files not actually used by the garbage-collector library, the GPL. THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED OR IMPLIED. ANY USE IS AT YOUR OWN RISK. Permission is hereby granted to use or copy this program for any purpose, provided the above notices are retained on all copies. Permission to modify the code and to distribute modified code is granted, provided the above notices are retained, and a notice that the code was modified is included with the above copyright notice. A few of the files needed to use the GNU-style build procedure come with slightly different licenses, though they are all similar in spirit. A few are GPL'ed, but with an exception that should cover all uses in the collector. (If you are concerned about such things, I recommend you look at the notice in config.guess or ltmain.sh.) The atomic_ops library contains some code that is covered by the GNU General Public License, but is not needed by, nor linked into the collector library. It is included here only because the atomic_ops distribution is, for simplicity, included in its entirety. ecl-16.1.2/src/bdwgc/SMakefile.amiga000066400000000000000000000100421266352375300170720ustar00rootroot00000000000000 # Rewritten smakefile for amiga / sas/c. -Kjetil M. # Dont use the cord-package if you define parm=both or parm=reg. #----------------TOOLS-------------------------------- CC=sc LINKER=slink LIBER=oml #----------------CPU OPTIONS-------------------------- CPU=68060 #----------------FPU OPTIONS-------------------------- MATH=8 MATHLIB=LIB:scm881.lib #----------------COMPILER OPTIONS--------------------- IGNORE= IGNORE=85 IGNORE=154 IGNORE=161 IGNORE=100 OPTIMIZE=optimize optimizetime optglobal optimizerdepth=100 optimizerpeephole optloop OPTSCHED optimizerinlocal optimizerrecurdepth=100 # optimizerinline optimizercomplexity=100 OPT= $(OPTIMIZE) CPU=$(CPU) math=$(MATH) NOSTACKCHECK VERBOSE \ MAPHUNK NOVERSION NOICONS nodebug \ parm=reg \ DEFINE __USE_SYSBASE SOPT= $(OPT) $(IGNORE) \ DEFINE AMIGA_SKIP_SEG \ DEFINE ATOMIC_UNCOLLECTABLE \ DEFINE GC_AMIGA_FASTALLOC \ DEFINE GC_AMIGA_RETRY \ DEFINE GC_AMIGA_PRINTSTATS \ DEFINE GC_AMIGA_GC #DEFINE ALL_INTERIOR_POINTERS \ SCOPT= $(SOPT) define GC_AMIGA_MAKINGLIB CSCOPT= $(OPT) DEFINE AMIGA IGNORE=100 IGNORE=161 #------------------LINKING---------------------------- all: gctest setjmp_t cord/cordtest clean: delete *.lib gctest setjmp_t *.o *.lnk cord/*.o cord/*.lib cord/*.lnk cord/cordtest smake test: setjmp_t gctest cord/cordtest setjmp_t gctest cord/cordtest gctest: gc$(CPU).lib GCAmigaOS$(CPU).lib test.o $(LINKER) LIB:c.o test.o TO gctest LIB gc$(CPU).lib LIB:sc.lib $(MATHLIB) setjmp_t: setjmp_t.o gc.h $(LINKER) LIB:c.o setjmp_t.o to setjmp_t lib LIB:sc.lib cord/cordtest: cord/cordtest.o cord/cord$(CPU).lib gc$(CPU).lib slink LIB:c.o cord/cordtest.o LIB $(MATHLIB) gc$(CPU).lib cord/cord$(CPU).lib LIB:sc.lib TO cord/cordtest #------------------LIBBING---------------------------- OBJS= alloc.o reclaim.o allchblk.o misc.o mach_dep.o os_dep.o mark_rts.o headers.o mark.o obj_map.o blacklst.o finalize.o new_hblk.o real_malloc.o dyn_load.o dbg_mlc.o malloc.o stubborn.o checksums.o typd_mlc.o ptr_chck.o mallocx.o fnlz_mlc.o gc$(CPU).lib: $(OBJS) $(LIBER) gc$(CPU).lib r $(OBJS) COBJS = cord/cordbscs.o cord/cordprnt.o cord/cordxtra.o cord/cord$(CPU).lib: $(COBJS) oml cord/cord$(CPU).lib r $(COBJS) #------------------COMPILING-------------------------- INC= gc_private.h gc_hdrs.h gc.h gcconfig.h alloc.o : alloc.c $(INC) $(CC) alloc.c $(SCOPT) ignore=7 reclaim.o : reclaim.c $(INC) $(CC) reclaim.c $(SCOPT) allchblk.o : allchblk.c $(INC) $(CC) allchblk.c $(SCOPT) misc.o : misc.c $(INC) $(CC) misc.c $(SCOPT) os_dep.o : os_dep.c $(INC) extra/AmigaOS.c $(CC) os_dep.c $(SCOPT) mark_rts.o : mark_rts.c $(INC) $(CC) mark_rts.c $(SCOPT) headers.o : headers.c $(INC) $(CC) headers.c $(SCOPT) mark.o : mark.c $(INC) $(CC) mark.c $(SCOPT) obj_map.o : obj_map.c $(INC) $(CC) obj_map.c $(SCOPT) blacklst.o : blacklst.c $(INC) $(CC) blacklst.c $(SCOPT) finalize.o : finalize.c $(INC) $(CC) finalize.c $(SCOPT) noopt # Could sas/c still have problems with this one? Gctest sometimes fails to finalize all. new_hblk.o : new_hblk.c $(INC) $(CC) new_hblk.c $(SCOPT) real_malloc.o : real_malloc.c $(INC) $(CC) real_malloc.c $(SCOPT) dyn_load.o : dyn_load.c $(INC) $(CC) dyn_load.c $(SCOPT) dbg_mlc.o : dbg_mlc.c $(INC) $(CC) dbg_mlc.c $(SCOPT) fnlz_mlc.o : fnlz_mlc.c $(INC) $(CC) fnlz_mlc.c $(SCOPT) malloc.o : malloc.c $(INC) $(CC) malloc.c $(SCOPT) mallocx.o : mallocx.c $(INC) $(CC) mallocx.c $(SCOPT) stubborn.o : stubborn.c $(INC) $(CC) stubborn.c $(SCOPT) checksums.o : checksums.c $(INC) $(CC) checksums.c $(SCOPT) typd_mlc.o: typd_mlc.c $(INC) $(CC) typd_mlc.c $(SCOPT) mach_dep.o : mach_dep.c $(INC) $(CC) mach_dep.c $(SCOPT) ptr_chck.o: ptr_chck.c $(INC) $(CC) ptr_chck.c $(SCOPT) test.o : test.c $(INC) $(CC) test.c $(SOPT) setjmp_t: tools/setjmp_t.c gc.h $(CC) tools/setjmp_t.c $(SOPT) # cords: cord/cordbscs.o: cord/cordbscs.c sc cord/cordbscs.c $(CSCOPT) cord/cordprnt.o: cord/cordprnt.c sc cord/cordprnt.c $(CSCOPT) cord/cordxtra.o: cord/cordxtra.c sc cord/cordxtra.c $(CSCOPT) cord/cordtest.o: cord/tests/cordtest.c sc cord/tests/cordtest.c $(CSCOPT) ecl-16.1.2/src/bdwgc/TODO000066400000000000000000000074361266352375300147370ustar00rootroot00000000000000== TODO tasks == tests/CMakeLists.txt: Add more executables (see tests.am). Use C++0x ATM (atomic memory operations) if available (either from the compiler runtime, provided it is reliable, or from the future libatomic_ops). Add a test for libatomic_ops minimal version required (at compile time). windows-untested: Remove if CMake can generate MS Visual Studio 6.0, 7.0, 8.0 project files. BCC_MAKEFILE: Remove if CMake can generate Makefile for this compiler. (Same for WCC_MAKEFILE, OS2_MAKEFILE, NT_MAKEFILE, NT_STATIC_THREADS_MAKEFILE, NT_X64_STATIC_THREADS_MAKEFILE, NT_X64_THREADS_MAKEFILE, digimars.mak, gc.mak.) BCC_MAKEFILE, EMX_MAKEFILE, OS2_MAKEFILE, PCR-Makefile, WCC_MAKEFILE, SMakefile.amiga, digimars.mak: move to "build" folder. Do type-punning via union (instead of pointer type cast) to enable safe '-fstrict-aliasing' compiler optimization option. Support CAN_HANDLE_FORK if USE_WINALLOC for Cygwin. Use madvise() on Unix/Cygwin. Use Linux VM pressure notifications to force GC and unmapping. Filter overlaps in GC_add_roots for Unix (same as for Win32). Do not resume parallel markers if only 1 core is active at GC mark start. Enable GC_set_handle_fork(1) for Darwin with GC_dirty_maintained on (both single and multi-threaded modes). Add more fields to GC_prof_stats_s (potential candidates are: requested_heapsize, max_large_allocd_bytes, large_allocd_bytes, bytes_dropped, bytes_finalized, bytes_freed, finalizer_bytes_freed, composite_in_use, atomic_in_use, GC_n_heap_sects, GC_n_memory, GC_black_list_spacing, GC_root_size, GC_max_root_size, n_root_sets, GC_total_stacksize, GC_collect_at_heapsize, GC_fail_count, GC_mark_stack_size, last_fo_entries, last_bytes_finalized, last_finalizer_notification_no, GC_dl_entries, GC_old_dl_entries, GC_used_heap_size_after_full, GC_total_stack_black_listed, signed_log_dl_table_size, GC_n_rescuing_pages, signed_log_fo_table_size, GC_excl_table_entries, GC_stack_last_cleared, GC_bytes_allocd_at_reset, GC_n_heap_bases, registered_threads_cnt, GC_max_thread_index, GC_block_count, GC_unlocked_count, GC_hdr_cache_hits, GC_hdr_cache_misses, GC_spin_count). Support musl libc (on sabotage linux). == FIXME tasks == Solaris + GCC: make check fails with the message: libc.so.1: gctest: fatal: libgcc_s.so.1: open failed: No such file or directory Solaris/x86[_64]: gctest fails if PROC_VDB. Sun C++ 5.11: test_cpp.cc:237: Error: Too few arguments in call to "operator delete(void*, GCPlacement, extern "C" void(*)(void*,void*), void*)". Darwin/x86_64: deadlock might occur between: dlclose() -> GC_dyld_image_remove() -> GC_lock() and GC_inner_start_routine()+LOCK -> dyld_stub_binder_(). HP-UX 11.00 with the vendor cc fails: Perhaps GC_push_regs was configured incorrectly? FAIL: gctest. Linux/mips64el (N32): threadleaktest crashes once every 3-4 runs (SIGSEGV in GC_delete_gc_thread(t=0) called from GC_pthread_join) if configured with --disable-shared. FreeBSD 9.0/x86_64 (gcc-4.2.1-20070831): gctest segfaults sometimes in GC_typed_mark_proc if configured with --enable-threads=pthreads. OpenBSD 5.1/i386: leaktest fails rarely (unless logging redirected to file): cannot write to stderr from GC_gcollect invoked from 'atexit' hook. NetBSD 5.1/x86: threadkey_test hangs sometimes. Cygwin: subthread_create: exception STATUS_ACCESS_VIOLATION. Cygwin: gctest: assertion failure at UNLOCK in GC_fork_parent_proc. Mingw-w32: gctest: "SuspendThread failed" sometimes occurs (if GC_DLL+GC_THREADS+GC_ASSERTIONS). Mingw: gctest (compiled with PARALLEL_MARK): launched in gdb with breakpoint at GC_mark_local, after several breakpoint hits, crashes with the messages "Caught ACCESS_VIOLATION in marker; memory mapping disappeared" and "Tried to start parallel mark in bad state", or enters deadlock. Mingw: test_cpp: crashes at some iteration if big argument (e.g., 1000) given. ecl-16.1.2/src/bdwgc/WCC_MAKEFILE000066400000000000000000000116241266352375300160350ustar00rootroot00000000000000# Makefile for Watcom C/C++ 10.5, 10.6, 11.0 on NT, OS2 and DOS4GW. # May work with Watcom 10.0. # Uncoment one of the lines below for cross compilation. SYSTEM=MSWIN32 #SYSTEM=DOS4GW #SYSTEM=OS2 # The collector can be built either as dynamic or as static library. # Select the library type you need. #MAKE_AS_DLL=1 MAKE_AS_LIB=1 # Select calling conventions. # Possible choices are r and s. CALLING=s # Select target CPU. # Possible choices are 3, 4, 5, and 6. # The last choice available only since version 11.0. CPU=5 # Set optimization options. # Watcom before 11.0 does not support option "-oh". OPTIM=-oneatx -s #OPTIM=-ohneatx -s DEFS=-DALL_INTERIOR_POINTERS #-DSMALL_CONFIG #-DGC_DEBUG ##### !ifndef SYSTEM !ifdef __MSDOS__ SYSTEM=DOS4GW !else ifdef __NT__ SYSTEM=MSWIN32 !else ifdef __OS2__ SYSTEM=OS2 !else SYSTEM=Unknown !endif !endif !define $(SYSTEM) !ifdef DOS4GW SYSFLAG=-DDOS4GW -bt=dos !else ifdef MSWIN32 SYSFLAG=-DMSWIN32 -bt=nt !else ifdef OS2 SYSFLAG=-DOS2 -bt=os2 !else !error undefined or unsupported target platform: $(SYSTEM) !endif !ifdef MAKE_AS_DLL DLLFLAG=-bd -DGC_DLL TEST_DLLFLAG=-DGC_DLL !else ifdef MAKE_AS_LIB DLLFLAG= TEST_DLLFLAG= !else !error Either MAKE_AS_LIB or MAKE_AS_DLL should be defined !endif CC=wcc386 CXX=wpp386 # -DUSE_GENERIC is required ! CFLAGS=-$(CPU)$(CALLING) $(OPTIM) -zp4 -zc $(SYSFLAG) $(DLLFLAG) -DUSE_GENERIC $(DEFS) CXXFLAGS= $(CFLAGS) TEST_CFLAGS=-$(CPU)$(CALLING) $(OPTIM) -zp4 -zc $(SYSFLAG) $(TEST_DLLFLAG) $(DEFS) TEST_CXXFLAGS= $(TEST_CFLAGS) OBJS= alloc.obj reclaim.obj allchblk.obj misc.obj & mach_dep.obj os_dep.obj mark_rts.obj headers.obj mark.obj & obj_map.obj blacklst.obj finalize.obj new_hblk.obj & dbg_mlc.obj malloc.obj stubborn.obj dyn_load.obj & typd_mlc.obj ptr_chck.obj mallocx.obj fnlz_mlc.obj all: gc.lib gctest.exe test_cpp.exe !ifdef MAKE_AS_DLL gc.lib: gc.dll gc_cpp.obj *wlib -b -c -n -p=512 $@ +gc.dll +gc_cpp.obj gc.dll: $(OBJS) .AUTODEPEND @%create $*.lnk !ifdef DOS4GW @%append $*.lnk sys os2v2_dll !else ifdef MSWIN32 @%append $*.lnk sys nt_dll !else ifdef OS2 @%append $*.lnk sys os2v2_dll !endif @%append $*.lnk name $* @for %i in ($(OBJS)) do @%append $*.lnk file '%i' !ifeq CALLING s @%append $*.lnk export GC_is_marked @%append $*.lnk export GC_incr_bytes_allocd @%append $*.lnk export GC_incr_bytes_freed @%append $*.lnk export GC_generic_malloc_words_small !else @%append $*.lnk export GC_is_marked_ @%append $*.lnk export GC_incr_bytes_allocd_ @%append $*.lnk export GC_incr_bytes_freed_ @%append $*.lnk export GC_generic_malloc_words_small_ !endif *wlink @$*.lnk !else gc.lib: $(OBJS) gc_cpp.obj @%create $*.lb1 @for %i in ($(OBJS)) do @%append $*.lb1 +'%i' @%append $*.lb1 +'gc_cpp.obj' *wlib -b -c -n -p=512 $@ @$*.lb1 !endif gctest.exe: test.obj gc.lib %create $*.lnk !ifdef DOS4GW @%append $*.lnk sys dos4g !else ifdef MSWIN32 @%append $*.lnk sys nt !else ifdef OS2 @%append $*.lnk sys os2v2 !endif @%append $*.lnk op case @%append $*.lnk op stack=256K @%append $*.lnk name $* @%append $*.lnk file test.obj @%append $*.lnk library gc.lib !ifdef MAKE_AS_DLL !ifeq CALLING s @%append $*.lnk import GC_is_marked gc !else @%append $*.lnk import GC_is_marked_ gc !endif !endif *wlink @$*.lnk test_cpp.exe: test_cpp.obj gc.lib %create $*.lnk !ifdef DOS4GW @%append $*.lnk sys dos4g !else ifdef MSWIN32 @%append $*.lnk sys nt !else ifdef OS2 @%append $*.lnk sys os2v2 !endif @%append $*.lnk op case @%append $*.lnk op stack=256K @%append $*.lnk name $* @%append $*.lnk file test_cpp.obj @%append $*.lnk library gc.lib !ifdef MAKE_AS_DLL !ifeq CALLING s @%append $*.lnk import GC_incr_bytes_allocd gc @%append $*.lnk import GC_incr_bytes_freed gc @%append $*.lnk import GC_generic_malloc_words_small gc !else @%append $*.lnk import GC_incr_bytes_allocd_ gc @%append $*.lnk import GC_incr_bytes_freed_ gc @%append $*.lnk import GC_generic_malloc_words_small_ gc !endif !endif *wlink @$*.lnk gc_cpp.obj: gc_cpp.cc .AUTODEPEND $(CXX) $(TEST_CXXFLAGS) -iinclude $*.cc test.obj: tests\test.c .AUTODEPEND $(CC) $(TEST_CFLAGS) $*.c test_cpp.obj: tests\test_cpp.cc .AUTODEPEND $(CXX) $(TEST_CXXFLAGS) -iinclude $*.cc .c.obj: .AUTODEPEND $(CC) $(CFLAGS) $*.c .cc.obj: .AUTODEPEND $(CXX) $(CXXFLAGS) $*.cc clean : .SYMBOLIC @if exist *.obj del *.obj @if exist *.map del *.map @if exist *.lnk del *.lnk @if exist *.lb1 del *.lb1 @if exist *.sym del *.sym @if exist *.err del *.err @if exist *.tmp del *.tmp @if exist *.lst del *.lst @if exist *.exe del *.exe @if exist *.log del *.log @if exist *.lib del *.lib @if exist *.dll del *.dll ecl-16.1.2/src/bdwgc/aclocal.m4000066400000000000000000001464421266352375300161100ustar00rootroot00000000000000# generated automatically by aclocal 1.15 -*- Autoconf -*- # Copyright (C) 1996-2014 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_CONFIG_MACRO_DIRS], [m4_defun([_AM_CONFIG_MACRO_DIRS], [])m4_defun([AC_CONFIG_MACRO_DIRS], [_AM_CONFIG_MACRO_DIRS($@)])]) 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'.])]) # pkg.m4 - Macros to locate and utilise pkg-config. -*- Autoconf -*- # serial 1 (pkg-config-0.24) # # Copyright ТЉ 2004 Scott James Remnant . # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, but # WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. # # As a special exception to the GNU General Public License, if you # distribute this file as part of a program that contains a # configuration script generated by Autoconf, you may include it under # the same distribution terms that you use for the rest of that program. # PKG_PROG_PKG_CONFIG([MIN-VERSION]) # ---------------------------------- AC_DEFUN([PKG_PROG_PKG_CONFIG], [m4_pattern_forbid([^_?PKG_[A-Z_]+$]) m4_pattern_allow([^PKG_CONFIG(_(PATH|LIBDIR|SYSROOT_DIR|ALLOW_SYSTEM_(CFLAGS|LIBS)))?$]) m4_pattern_allow([^PKG_CONFIG_(DISABLE_UNINSTALLED|TOP_BUILD_DIR|DEBUG_SPEW)$]) AC_ARG_VAR([PKG_CONFIG], [path to pkg-config utility]) AC_ARG_VAR([PKG_CONFIG_PATH], [directories to add to pkg-config's search path]) AC_ARG_VAR([PKG_CONFIG_LIBDIR], [path overriding pkg-config's built-in search path]) if test "x$ac_cv_env_PKG_CONFIG_set" != "xset"; then AC_PATH_TOOL([PKG_CONFIG], [pkg-config]) fi if test -n "$PKG_CONFIG"; then _pkg_min_version=m4_default([$1], [0.9.0]) AC_MSG_CHECKING([pkg-config is at least version $_pkg_min_version]) if $PKG_CONFIG --atleast-pkgconfig-version $_pkg_min_version; then AC_MSG_RESULT([yes]) else AC_MSG_RESULT([no]) PKG_CONFIG="" fi fi[]dnl ])# PKG_PROG_PKG_CONFIG # PKG_CHECK_EXISTS(MODULES, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND]) # # Check to see whether a particular set of modules exists. Similar # to PKG_CHECK_MODULES(), but does not set variables or print errors. # # Please remember that m4 expands AC_REQUIRE([PKG_PROG_PKG_CONFIG]) # only at the first occurence in configure.ac, so if the first place # it's called might be skipped (such as if it is within an "if", you # have to call PKG_CHECK_EXISTS manually # -------------------------------------------------------------- AC_DEFUN([PKG_CHECK_EXISTS], [AC_REQUIRE([PKG_PROG_PKG_CONFIG])dnl if test -n "$PKG_CONFIG" && \ AC_RUN_LOG([$PKG_CONFIG --exists --print-errors "$1"]); then m4_default([$2], [:]) m4_ifvaln([$3], [else $3])dnl fi]) # _PKG_CONFIG([VARIABLE], [COMMAND], [MODULES]) # --------------------------------------------- m4_define([_PKG_CONFIG], [if test -n "$$1"; then pkg_cv_[]$1="$$1" elif test -n "$PKG_CONFIG"; then PKG_CHECK_EXISTS([$3], [pkg_cv_[]$1=`$PKG_CONFIG --[]$2 "$3" 2>/dev/null` test "x$?" != "x0" && pkg_failed=yes ], [pkg_failed=yes]) else pkg_failed=untried fi[]dnl ])# _PKG_CONFIG # _PKG_SHORT_ERRORS_SUPPORTED # ----------------------------- AC_DEFUN([_PKG_SHORT_ERRORS_SUPPORTED], [AC_REQUIRE([PKG_PROG_PKG_CONFIG]) if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then _pkg_short_errors_supported=yes else _pkg_short_errors_supported=no fi[]dnl ])# _PKG_SHORT_ERRORS_SUPPORTED # PKG_CHECK_MODULES(VARIABLE-PREFIX, MODULES, [ACTION-IF-FOUND], # [ACTION-IF-NOT-FOUND]) # # # Note that if there is a possibility the first call to # PKG_CHECK_MODULES might not happen, you should be sure to include an # explicit call to PKG_PROG_PKG_CONFIG in your configure.ac # # # -------------------------------------------------------------- AC_DEFUN([PKG_CHECK_MODULES], [AC_REQUIRE([PKG_PROG_PKG_CONFIG])dnl AC_ARG_VAR([$1][_CFLAGS], [C compiler flags for $1, overriding pkg-config])dnl AC_ARG_VAR([$1][_LIBS], [linker flags for $1, overriding pkg-config])dnl pkg_failed=no AC_MSG_CHECKING([for $1]) _PKG_CONFIG([$1][_CFLAGS], [cflags], [$2]) _PKG_CONFIG([$1][_LIBS], [libs], [$2]) m4_define([_PKG_TEXT], [Alternatively, you may set the environment variables $1[]_CFLAGS and $1[]_LIBS to avoid the need to call pkg-config. See the pkg-config man page for more details.]) if test $pkg_failed = yes; then AC_MSG_RESULT([no]) _PKG_SHORT_ERRORS_SUPPORTED if test $_pkg_short_errors_supported = yes; then $1[]_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors --cflags --libs "$2" 2>&1` else $1[]_PKG_ERRORS=`$PKG_CONFIG --print-errors --cflags --libs "$2" 2>&1` fi # Put the nasty error message in config.log where it belongs echo "$$1[]_PKG_ERRORS" >&AS_MESSAGE_LOG_FD m4_default([$4], [AC_MSG_ERROR( [Package requirements ($2) were not met: $$1_PKG_ERRORS Consider adjusting the PKG_CONFIG_PATH environment variable if you installed software in a non-standard prefix. _PKG_TEXT])[]dnl ]) elif test $pkg_failed = untried; then AC_MSG_RESULT([no]) m4_default([$4], [AC_MSG_FAILURE( [The pkg-config script could not be found or is too old. Make sure it is in your PATH or set the PKG_CONFIG environment variable to the full path to pkg-config. _PKG_TEXT To get pkg-config, see .])[]dnl ]) else $1[]_CFLAGS=$pkg_cv_[]$1[]_CFLAGS $1[]_LIBS=$pkg_cv_[]$1[]_LIBS AC_MSG_RESULT([yes]) $3 fi[]dnl ])# PKG_CHECK_MODULES # PKG_INSTALLDIR(DIRECTORY) # ------------------------- # Substitutes the variable pkgconfigdir as the location where a module # should install pkg-config .pc files. By default the directory is # $libdir/pkgconfig, but the default can be changed by passing # DIRECTORY. The user can override through the --with-pkgconfigdir # parameter. AC_DEFUN([PKG_INSTALLDIR], [m4_pushdef([pkg_default], [m4_default([$1], ['${libdir}/pkgconfig'])]) m4_pushdef([pkg_description], [pkg-config installation directory @<:@]pkg_default[@:>@]) AC_ARG_WITH([pkgconfigdir], [AS_HELP_STRING([--with-pkgconfigdir], pkg_description)],, [with_pkgconfigdir=]pkg_default) AC_SUBST([pkgconfigdir], [$with_pkgconfigdir]) m4_popdef([pkg_default]) m4_popdef([pkg_description]) ]) dnl PKG_INSTALLDIR # PKG_NOARCH_INSTALLDIR(DIRECTORY) # ------------------------- # Substitutes the variable noarch_pkgconfigdir as the location where a # module should install arch-independent pkg-config .pc files. By # default the directory is $datadir/pkgconfig, but the default can be # changed by passing DIRECTORY. The user can override through the # --with-noarch-pkgconfigdir parameter. AC_DEFUN([PKG_NOARCH_INSTALLDIR], [m4_pushdef([pkg_default], [m4_default([$1], ['${datadir}/pkgconfig'])]) m4_pushdef([pkg_description], [pkg-config arch-independent installation directory @<:@]pkg_default[@:>@]) AC_ARG_WITH([noarch-pkgconfigdir], [AS_HELP_STRING([--with-noarch-pkgconfigdir], pkg_description)],, [with_noarch_pkgconfigdir=]pkg_default) AC_SUBST([noarch_pkgconfigdir], [$with_noarch_pkgconfigdir]) m4_popdef([pkg_default]) m4_popdef([pkg_description]) ]) dnl PKG_NOARCH_INSTALLDIR # PKG_CHECK_VAR(VARIABLE, MODULE, CONFIG-VARIABLE, # [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND]) # ------------------------------------------- # Retrieves the value of the pkg-config variable for the given module. AC_DEFUN([PKG_CHECK_VAR], [AC_REQUIRE([PKG_PROG_PKG_CONFIG])dnl AC_ARG_VAR([$1], [value of $3 for $2, overriding pkg-config])dnl _PKG_CONFIG([$1], [variable="][$3]["], [$2]) AS_VAR_COPY([$1], [pkg_cv_][$1]) AS_VAR_IF([$1], [""], [$5], [$4])dnl ])# PKG_CHECK_VAR # Copyright (C) 2002-2014 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. # 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.15' 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.15], [], [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.15])dnl m4_ifndef([AC_AUTOCONF_VERSION], [m4_copy([m4_PACKAGE_VERSION], [AC_AUTOCONF_VERSION])])dnl _AM_AUTOCONF_VERSION(m4_defn([AC_AUTOCONF_VERSION]))]) # Figure out how to run the assembler. -*- Autoconf -*- # Copyright (C) 2001-2014 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. # AM_PROG_AS # ---------- AC_DEFUN([AM_PROG_AS], [# By default we simply use the C compiler to build assembly code. AC_REQUIRE([AC_PROG_CC]) test "${CCAS+set}" = set || CCAS=$CC test "${CCASFLAGS+set}" = set || CCASFLAGS=$CFLAGS AC_ARG_VAR([CCAS], [assembler compiler command (defaults to CC)]) AC_ARG_VAR([CCASFLAGS], [assembler compiler flags (defaults to CFLAGS)]) _AM_IF_OPTION([no-dependencies],, [_AM_DEPENDENCIES([CCAS])])dnl ]) # AM_AUX_DIR_EXPAND -*- Autoconf -*- # Copyright (C) 2001-2014 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. # 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], [AC_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT])dnl # Expand $ac_aux_dir to an absolute path. am_aux_dir=`cd "$ac_aux_dir" && pwd` ]) # AM_CONDITIONAL -*- Autoconf -*- # Copyright (C) 1997-2014 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. # 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-2014 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. # 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-2014 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. # _AM_OUTPUT_DEPENDENCY_COMMANDS # ------------------------------ AC_DEFUN([_AM_OUTPUT_DEPENDENCY_COMMANDS], [{ # Older Autoconf 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-2014 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 macro actually does too much. Some checks are only needed if # your package does certain things. But this isn't really a big deal. dnl Redefine AC_PROG_CC to automatically invoke _AM_PROG_CC_C_O. m4_define([AC_PROG_CC], m4_defn([AC_PROG_CC]) [_AM_PROG_CC_C_O ]) # 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.65])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.]) 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 (and possibly the TAP driver). 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 AC_PROVIDE_IFELSE([AC_PROG_OBJCXX], [_AM_DEPENDENCIES([OBJCXX])], [m4_define([AC_PROG_OBJCXX], m4_defn([AC_PROG_OBJCXX])[_AM_DEPENDENCIES([OBJCXX])])])dnl ]) AC_REQUIRE([AM_SILENT_RULES])dnl dnl The testsuite driver may need to know about EXEEXT, so add the dnl 'am__EXEEXT' conditional if _AM_COMPILER_EXEEXT was seen. This dnl macro 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 # POSIX will say in a future version that running "rm -f" with no argument # is OK; and we want to be able to make that assumption in our Makefile # recipes. So use an aggressive probe to check that the usage we want is # actually supported "in the wild" to an acceptable degree. # See automake bug#10828. # To make any issue more visible, cause the running configure to be aborted # by default if the 'rm' program in use doesn't match our expectations; the # user can still override this though. if rm -f && rm -fr && rm -rf; then : OK; else cat >&2 <<'END' Oops! Your 'rm' program seems unable to run without file operands specified on the command line, even when the '-f' option is present. This is contrary to the behaviour of most rm programs out there, and not conforming with the upcoming POSIX standard: Please tell bug-automake@gnu.org about your system, including the value of your $PATH and any error possibly output before this message. This can help us improve future automake versions. END if test x"$ACCEPT_INFERIOR_RM_PROGRAM" = x"yes"; then echo 'Configuration will proceed anyway, since you have set the' >&2 echo 'ACCEPT_INFERIOR_RM_PROGRAM variable to "yes"' >&2 echo >&2 else cat >&2 <<'END' Aborting the configuration process, to ensure you take notice of the issue. You can download and install GNU coreutils to get an 'rm' implementation that behaves properly: . If you want to complete the configuration process using your problematic 'rm' anyway, export the environment variable ACCEPT_INFERIOR_RM_PROGRAM to "yes", and re-run configure. END AC_MSG_ERROR([Your 'rm' program is bad, sorry.]) fi fi dnl The trailing newline in this macro's definition is deliberate, for dnl backward compatibility and to allow trailing 'dnl'-style comments dnl after the AM_INIT_AUTOMAKE invocation. See automake bug#16841. ]) 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-2014 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. # 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+set}" != 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-2014 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. # 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-2014 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. # 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 ] ) # Check to see how 'make' treats includes. -*- Autoconf -*- # Copyright (C) 2001-2014 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. # 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-2014 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. # 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 is modern enough. # If it is, 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 --is-lightweight"; then am_missing_run="$MISSING " else am_missing_run= AC_MSG_WARN(['missing' script is too old or missing]) fi ]) # Helper functions for option handling. -*- Autoconf -*- # Copyright (C) 2001-2014 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. # _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])]) # Copyright (C) 1999-2014 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. # _AM_PROG_CC_C_O # --------------- # Like AC_PROG_CC_C_O, but changed for automake. We rewrite AC_PROG_CC # to automatically call this. AC_DEFUN([_AM_PROG_CC_C_O], [AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl AC_REQUIRE_AUX_FILE([compile])dnl AC_LANG_PUSH([C])dnl AC_CACHE_CHECK( [whether $CC understands -c and -o together], [am_cv_prog_cc_c_o], [AC_LANG_CONFTEST([AC_LANG_PROGRAM([])]) # Make sure it works both with $CC and with simple cc. # Following AC_PROG_CC_C_O, we do the test twice because some # compilers refuse to overwrite an existing .o file with -o, # though they will create one. am_cv_prog_cc_c_o=yes for am_i in 1 2; do if AM_RUN_LOG([$CC -c conftest.$ac_ext -o conftest2.$ac_objext]) \ && test -f conftest2.$ac_objext; then : OK else am_cv_prog_cc_c_o=no break fi done rm -f core conftest* unset am_i]) if test "$am_cv_prog_cc_c_o" != yes; then # Losing compiler, so override with the script. # FIXME: It is wrong to rewrite CC. # 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__CC in this case, # and then we could set am__CC="\$(top_srcdir)/compile \$(CC)" CC="$am_aux_dir/compile $CC" fi AC_LANG_POP([C])]) # For backward compatibility. AC_DEFUN_ONCE([AM_PROG_CC_C_O], [AC_REQUIRE([AC_PROG_CC])]) # Copyright (C) 2001-2014 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. # AM_RUN_LOG(COMMAND) # ------------------- # Run COMMAND, save the exit status in ac_status, and log it. # (This has been adapted from Autoconf's _AC_RUN_LOG macro.) AC_DEFUN([AM_RUN_LOG], [{ echo "$as_me:$LINENO: $1" >&AS_MESSAGE_LOG_FD ($1) >&AS_MESSAGE_LOG_FD 2>&AS_MESSAGE_LOG_FD ac_status=$? echo "$as_me:$LINENO: \$? = $ac_status" >&AS_MESSAGE_LOG_FD (exit $ac_status); }]) # Check to make sure that the build environment is sane. -*- Autoconf -*- # Copyright (C) 1996-2014 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. # 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-2014 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. # 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-2014 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. # 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-2014 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. # _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-2014 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. # _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}']) # We'll loop over all known methods to create a tar archive until one works. _am_tools='gnutar m4_if([$1], [ustar], [plaintar]) pax cpio none' m4_if([$1], [v7], [am__tar='$${TAR-tar} chof - "$$tardir"' am__untar='$${TAR-tar} xf -'], [m4_case([$1], [ustar], [# The POSIX 1988 'ustar' format is defined with fixed-size fields. # There is notably a 21 bits limit for the UID and the GID. In fact, # the 'pax' utility can hang on bigger UID/GID (see automake bug#8343 # and bug#13588). am_max_uid=2097151 # 2^21 - 1 am_max_gid=$am_max_uid # The $UID and $GID variables are not portable, so we need to resort # to the POSIX-mandated id(1) utility. Errors in the 'id' calls # below are definitely unexpected, so allow the users to see them # (that is, avoid stderr redirection). am_uid=`id -u || echo unknown` am_gid=`id -g || echo unknown` AC_MSG_CHECKING([whether UID '$am_uid' is supported by ustar format]) if test $am_uid -le $am_max_uid; then AC_MSG_RESULT([yes]) else AC_MSG_RESULT([no]) _am_tools=none fi AC_MSG_CHECKING([whether GID '$am_gid' is supported by ustar format]) if test $am_gid -le $am_max_gid; then AC_MSG_RESULT([yes]) else AC_MSG_RESULT([no]) _am_tools=none fi], [pax], [], [m4_fatal([Unknown tar format])]) AC_MSG_CHECKING([how to create a $1 tar archive]) # Go ahead even if we have the value already cached. We do so because we # need to set the values for the 'am__tar' and 'am__untar' variables. _am_tools=${am_cv_prog_tar_$1-$_am_tools} 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]) ecl-16.1.2/src/bdwgc/allchblk.c000066400000000000000000001007311266352375300161570ustar00rootroot00000000000000/* * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. * Copyright (c) 1998-1999 by Silicon Graphics. All rights reserved. * Copyright (c) 1999 by Hewlett-Packard Company. All rights reserved. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. */ #include "private/gc_priv.h" #include #ifdef GC_USE_ENTIRE_HEAP int GC_use_entire_heap = TRUE; #else int GC_use_entire_heap = FALSE; #endif /* * Free heap blocks are kept on one of several free lists, * depending on the size of the block. Each free list is doubly linked. * Adjacent free blocks are coalesced. */ # define MAX_BLACK_LIST_ALLOC (2*HBLKSIZE) /* largest block we will allocate starting on a black */ /* listed block. Must be >= HBLKSIZE. */ # define UNIQUE_THRESHOLD 32 /* Sizes up to this many HBLKs each have their own free list */ # define HUGE_THRESHOLD 256 /* Sizes of at least this many heap blocks are mapped to a */ /* single free list. */ # define FL_COMPRESSION 8 /* In between sizes map this many distinct sizes to a single */ /* bin. */ # define N_HBLK_FLS ((HUGE_THRESHOLD - UNIQUE_THRESHOLD) / FL_COMPRESSION \ + UNIQUE_THRESHOLD) #ifndef GC_GCJ_SUPPORT STATIC #endif struct hblk * GC_hblkfreelist[N_HBLK_FLS+1] = { 0 }; /* List of completely empty heap blocks */ /* Linked through hb_next field of */ /* header structure associated with */ /* block. Remains externally visible */ /* as used by GNU GCJ currently. */ #ifndef GC_GCJ_SUPPORT STATIC #endif word GC_free_bytes[N_HBLK_FLS+1] = { 0 }; /* Number of free bytes on each list. Remains visible to GCJ. */ /* Return the largest n such that the number of free bytes on lists */ /* n .. N_HBLK_FLS is greater or equal to GC_max_large_allocd_bytes */ /* minus GC_large_allocd_bytes. If there is no such n, return 0. */ GC_INLINE int GC_enough_large_bytes_left(void) { int n; word bytes = GC_large_allocd_bytes; GC_ASSERT(GC_max_large_allocd_bytes <= GC_heapsize); for (n = N_HBLK_FLS; n >= 0; --n) { bytes += GC_free_bytes[n]; if (bytes >= GC_max_large_allocd_bytes) return n; } return 0; } /* Map a number of blocks to the appropriate large block free list index. */ STATIC int GC_hblk_fl_from_blocks(word blocks_needed) { if (blocks_needed <= UNIQUE_THRESHOLD) return (int)blocks_needed; if (blocks_needed >= HUGE_THRESHOLD) return N_HBLK_FLS; return (int)(blocks_needed - UNIQUE_THRESHOLD)/FL_COMPRESSION + UNIQUE_THRESHOLD; } # define PHDR(hhdr) HDR((hhdr) -> hb_prev) # define NHDR(hhdr) HDR((hhdr) -> hb_next) # ifdef USE_MUNMAP # define IS_MAPPED(hhdr) (((hhdr) -> hb_flags & WAS_UNMAPPED) == 0) # else # define IS_MAPPED(hhdr) TRUE # endif /* !USE_MUNMAP */ #if !defined(NO_DEBUGGING) || defined(GC_ASSERTIONS) /* Should return the same value as GC_large_free_bytes. */ GC_INNER word GC_compute_large_free_bytes(void) { struct hblk * h; hdr * hhdr; word total_free = 0; unsigned i; for (i = 0; i <= N_HBLK_FLS; ++i) { for (h = GC_hblkfreelist[i]; h != 0; h = hhdr->hb_next) { hhdr = HDR(h); total_free += hhdr->hb_sz; } } return total_free; } #endif /* !NO_DEBUGGING || GC_ASSERTIONS */ # if !defined(NO_DEBUGGING) void GC_print_hblkfreelist(void) { struct hblk * h; hdr * hhdr; unsigned i; word total; for (i = 0; i <= N_HBLK_FLS; ++i) { h = GC_hblkfreelist[i]; if (0 != h) GC_printf("Free list %u (total size %lu):\n", i, (unsigned long)GC_free_bytes[i]); while (h != 0) { hhdr = HDR(h); GC_printf("\t%p size %lu %s black listed\n", (void *)h, (unsigned long) hhdr -> hb_sz, GC_is_black_listed(h, HBLKSIZE) != 0 ? "start" : GC_is_black_listed(h, hhdr -> hb_sz) != 0 ? "partially" : "not"); h = hhdr -> hb_next; } } GC_printf("GC_large_free_bytes: %lu\n", (unsigned long)GC_large_free_bytes); if ((total = GC_compute_large_free_bytes()) != GC_large_free_bytes) GC_err_printf("GC_large_free_bytes INCONSISTENT!! Should be: %lu\n", (unsigned long)total); } /* Return the free list index on which the block described by the header */ /* appears, or -1 if it appears nowhere. */ static int free_list_index_of(hdr *wanted) { struct hblk * h; hdr * hhdr; int i; for (i = 0; i <= N_HBLK_FLS; ++i) { h = GC_hblkfreelist[i]; while (h != 0) { hhdr = HDR(h); if (hhdr == wanted) return i; h = hhdr -> hb_next; } } return -1; } void GC_dump_regions(void) { unsigned i; ptr_t start, end; ptr_t p; size_t bytes; hdr *hhdr; for (i = 0; i < GC_n_heap_sects; ++i) { start = GC_heap_sects[i].hs_start; bytes = GC_heap_sects[i].hs_bytes; end = start + bytes; /* Merge in contiguous sections. */ while (i+1 < GC_n_heap_sects && GC_heap_sects[i+1].hs_start == end) { ++i; end = GC_heap_sects[i].hs_start + GC_heap_sects[i].hs_bytes; } GC_printf("***Section from %p to %p\n", start, end); for (p = start; (word)p < (word)end; ) { hhdr = HDR(p); if (IS_FORWARDING_ADDR_OR_NIL(hhdr)) { GC_printf("\t%p Missing header!!(%p)\n", p, (void *)hhdr); p += HBLKSIZE; continue; } if (HBLK_IS_FREE(hhdr)) { int correct_index = GC_hblk_fl_from_blocks( divHBLKSZ(hhdr -> hb_sz)); int actual_index; GC_printf("\t%p\tfree block of size 0x%lx bytes%s\n", p, (unsigned long)(hhdr -> hb_sz), IS_MAPPED(hhdr) ? "" : " (unmapped)"); actual_index = free_list_index_of(hhdr); if (-1 == actual_index) { GC_printf("\t\tBlock not on free list %d!!\n", correct_index); } else if (correct_index != actual_index) { GC_printf("\t\tBlock on list %d, should be on %d!!\n", actual_index, correct_index); } p += hhdr -> hb_sz; } else { GC_printf("\t%p\tused for blocks of size 0x%lx bytes\n", p, (unsigned long)(hhdr -> hb_sz)); p += HBLKSIZE * OBJ_SZ_TO_BLOCKS(hhdr -> hb_sz); } } } } # endif /* NO_DEBUGGING */ /* Initialize hdr for a block containing the indicated size and */ /* kind of objects. */ /* Return FALSE on failure. */ static GC_bool setup_header(hdr * hhdr, struct hblk *block, size_t byte_sz, int kind, unsigned flags) { word descr; # ifdef MARK_BIT_PER_GRANULE size_t granules; if (byte_sz > MAXOBJBYTES) flags |= LARGE_BLOCK; # endif # ifdef ENABLE_DISCLAIM if (GC_obj_kinds[kind].ok_disclaim_proc) flags |= HAS_DISCLAIM; if (GC_obj_kinds[kind].ok_mark_unconditionally) flags |= MARK_UNCONDITIONALLY; # endif /* Set size, kind and mark proc fields */ hhdr -> hb_sz = byte_sz; hhdr -> hb_obj_kind = (unsigned char)kind; hhdr -> hb_flags = (unsigned char)flags; hhdr -> hb_block = block; descr = GC_obj_kinds[kind].ok_descriptor; if (GC_obj_kinds[kind].ok_relocate_descr) descr += byte_sz; hhdr -> hb_descr = descr; # ifdef MARK_BIT_PER_OBJ /* Set hb_inv_sz as portably as possible. */ /* We set it to the smallest value such that sz * inv_sz > 2**32 */ /* This may be more precision than necessary. */ if (byte_sz > MAXOBJBYTES) { hhdr -> hb_inv_sz = LARGE_INV_SZ; } else { word inv_sz; # if CPP_WORDSZ == 64 inv_sz = ((word)1 << 32)/byte_sz; if (((inv_sz*byte_sz) >> 32) == 0) ++inv_sz; # else /* 32 bit words */ GC_ASSERT(byte_sz >= 4); inv_sz = ((unsigned)1 << 31)/byte_sz; inv_sz *= 2; while (inv_sz*byte_sz > byte_sz) ++inv_sz; # endif hhdr -> hb_inv_sz = inv_sz; } # else /* MARK_BIT_PER_GRANULE */ granules = BYTES_TO_GRANULES(byte_sz); if (EXPECT(!GC_add_map_entry(granules), FALSE)) { /* Make it look like a valid block. */ hhdr -> hb_sz = HBLKSIZE; hhdr -> hb_descr = 0; hhdr -> hb_flags |= LARGE_BLOCK; hhdr -> hb_map = 0; return FALSE; } hhdr -> hb_map = GC_obj_map[(hhdr -> hb_flags & LARGE_BLOCK) != 0 ? 0 : granules]; # endif /* MARK_BIT_PER_GRANULE */ /* Clear mark bits */ GC_clear_hdr_marks(hhdr); hhdr -> hb_last_reclaimed = (unsigned short)GC_gc_no; return(TRUE); } /* Remove hhdr from the free list (it is assumed to specified by index). */ STATIC void GC_remove_from_fl_at(hdr *hhdr, int index) { GC_ASSERT(((hhdr -> hb_sz) & (HBLKSIZE-1)) == 0); if (hhdr -> hb_prev == 0) { GC_ASSERT(HDR(GC_hblkfreelist[index]) == hhdr); GC_hblkfreelist[index] = hhdr -> hb_next; } else { hdr *phdr; GET_HDR(hhdr -> hb_prev, phdr); phdr -> hb_next = hhdr -> hb_next; } /* We always need index to maintain free counts. */ GC_ASSERT(GC_free_bytes[index] >= hhdr -> hb_sz); GC_free_bytes[index] -= hhdr -> hb_sz; if (0 != hhdr -> hb_next) { hdr * nhdr; GC_ASSERT(!IS_FORWARDING_ADDR_OR_NIL(NHDR(hhdr))); GET_HDR(hhdr -> hb_next, nhdr); nhdr -> hb_prev = hhdr -> hb_prev; } } /* Remove hhdr from the appropriate free list (we assume it is on the */ /* size-appropriate free list). */ GC_INLINE void GC_remove_from_fl(hdr *hhdr) { GC_remove_from_fl_at(hhdr, GC_hblk_fl_from_blocks(divHBLKSZ(hhdr->hb_sz))); } /* Return a pointer to the free block ending just before h, if any. */ STATIC struct hblk * GC_free_block_ending_at(struct hblk *h) { struct hblk * p = h - 1; hdr * phdr; GET_HDR(p, phdr); while (0 != phdr && IS_FORWARDING_ADDR_OR_NIL(phdr)) { p = FORWARDED_ADDR(p,phdr); phdr = HDR(p); } if (0 != phdr) { if(HBLK_IS_FREE(phdr)) { return p; } else { return 0; } } p = GC_prev_block(h - 1); if (0 != p) { phdr = HDR(p); if (HBLK_IS_FREE(phdr) && (ptr_t)p + phdr -> hb_sz == (ptr_t)h) { return p; } } return 0; } /* Add hhdr to the appropriate free list. */ /* We maintain individual free lists sorted by address. */ STATIC void GC_add_to_fl(struct hblk *h, hdr *hhdr) { int index = GC_hblk_fl_from_blocks(divHBLKSZ(hhdr -> hb_sz)); struct hblk *second = GC_hblkfreelist[index]; hdr * second_hdr; # if defined(GC_ASSERTIONS) && !defined(USE_MUNMAP) struct hblk *next = (struct hblk *)((word)h + hhdr -> hb_sz); hdr * nexthdr = HDR(next); struct hblk *prev = GC_free_block_ending_at(h); hdr * prevhdr = HDR(prev); GC_ASSERT(nexthdr == 0 || !HBLK_IS_FREE(nexthdr) || (signed_word)GC_heapsize < 0); /* In the last case, blocks may be too large to merge. */ GC_ASSERT(prev == 0 || !HBLK_IS_FREE(prevhdr) || (signed_word)GC_heapsize < 0); # endif GC_ASSERT(((hhdr -> hb_sz) & (HBLKSIZE-1)) == 0); GC_hblkfreelist[index] = h; GC_free_bytes[index] += hhdr -> hb_sz; GC_ASSERT(GC_free_bytes[index] <= GC_large_free_bytes); hhdr -> hb_next = second; hhdr -> hb_prev = 0; if (0 != second) { GET_HDR(second, second_hdr); second_hdr -> hb_prev = h; } hhdr -> hb_flags |= FREE_BLK; } #ifdef USE_MUNMAP # ifndef MUNMAP_THRESHOLD # define MUNMAP_THRESHOLD 6 # endif GC_INNER int GC_unmap_threshold = MUNMAP_THRESHOLD; /* Unmap blocks that haven't been recently touched. This is the only way */ /* way blocks are ever unmapped. */ GC_INNER void GC_unmap_old(void) { struct hblk * h; hdr * hhdr; int i; if (GC_unmap_threshold == 0) return; /* unmapping disabled */ for (i = 0; i <= N_HBLK_FLS; ++i) { for (h = GC_hblkfreelist[i]; 0 != h; h = hhdr -> hb_next) { hhdr = HDR(h); if (!IS_MAPPED(hhdr)) continue; if ((unsigned short)GC_gc_no - hhdr -> hb_last_reclaimed > (unsigned short)GC_unmap_threshold) { GC_unmap((ptr_t)h, hhdr -> hb_sz); hhdr -> hb_flags |= WAS_UNMAPPED; } } } } /* Merge all unmapped blocks that are adjacent to other free */ /* blocks. This may involve remapping, since all blocks are either */ /* fully mapped or fully unmapped. */ GC_INNER void GC_merge_unmapped(void) { struct hblk * h, *next; hdr * hhdr, *nexthdr; word size, nextsize; int i; for (i = 0; i <= N_HBLK_FLS; ++i) { h = GC_hblkfreelist[i]; while (h != 0) { GET_HDR(h, hhdr); size = hhdr->hb_sz; next = (struct hblk *)((word)h + size); GET_HDR(next, nexthdr); /* Coalesce with successor, if possible */ if (0 != nexthdr && HBLK_IS_FREE(nexthdr) && (signed_word) (size + (nextsize = nexthdr->hb_sz)) > 0 /* no pot. overflow */) { /* Note that we usually try to avoid adjacent free blocks */ /* that are either both mapped or both unmapped. But that */ /* isn't guaranteed to hold since we remap blocks when we */ /* split them, and don't merge at that point. It may also */ /* not hold if the merged block would be too big. */ if (IS_MAPPED(hhdr) && !IS_MAPPED(nexthdr)) { /* make both consistent, so that we can merge */ if (size > nextsize) { GC_remap((ptr_t)next, nextsize); } else { GC_unmap((ptr_t)h, size); GC_unmap_gap((ptr_t)h, size, (ptr_t)next, nextsize); hhdr -> hb_flags |= WAS_UNMAPPED; } } else if (IS_MAPPED(nexthdr) && !IS_MAPPED(hhdr)) { if (size > nextsize) { GC_unmap((ptr_t)next, nextsize); GC_unmap_gap((ptr_t)h, size, (ptr_t)next, nextsize); } else { GC_remap((ptr_t)h, size); hhdr -> hb_flags &= ~WAS_UNMAPPED; hhdr -> hb_last_reclaimed = nexthdr -> hb_last_reclaimed; } } else if (!IS_MAPPED(hhdr) && !IS_MAPPED(nexthdr)) { /* Unmap any gap in the middle */ GC_unmap_gap((ptr_t)h, size, (ptr_t)next, nextsize); } /* If they are both unmapped, we merge, but leave unmapped. */ GC_remove_from_fl_at(hhdr, i); GC_remove_from_fl(nexthdr); hhdr -> hb_sz += nexthdr -> hb_sz; GC_remove_header(next); GC_add_to_fl(h, hhdr); /* Start over at beginning of list */ h = GC_hblkfreelist[i]; } else /* not mergable with successor */ { h = hhdr -> hb_next; } } /* while (h != 0) ... */ } /* for ... */ } #endif /* USE_MUNMAP */ /* * Return a pointer to a block starting at h of length bytes. * Memory for the block is mapped. * Remove the block from its free list, and return the remainder (if any) * to its appropriate free list. * May fail by returning 0. * The header for the returned block must be set up by the caller. * If the return value is not 0, then hhdr is the header for it. */ STATIC struct hblk * GC_get_first_part(struct hblk *h, hdr *hhdr, size_t bytes, int index) { word total_size = hhdr -> hb_sz; struct hblk * rest; hdr * rest_hdr; GC_ASSERT((total_size & (HBLKSIZE-1)) == 0); GC_remove_from_fl_at(hhdr, index); if (total_size == bytes) return h; rest = (struct hblk *)((word)h + bytes); rest_hdr = GC_install_header(rest); if (0 == rest_hdr) { /* FIXME: This is likely to be very bad news ... */ WARN("Header allocation failed: Dropping block.\n", 0); return(0); } rest_hdr -> hb_sz = total_size - bytes; rest_hdr -> hb_flags = 0; # ifdef GC_ASSERTIONS /* Mark h not free, to avoid assertion about adjacent free blocks. */ hhdr -> hb_flags &= ~FREE_BLK; # endif GC_add_to_fl(rest, rest_hdr); return h; } /* * H is a free block. N points at an address inside it. * A new header for n has already been set up. Fix up h's header * to reflect the fact that it is being split, move it to the * appropriate free list. * N replaces h in the original free list. * * Nhdr is not completely filled in, since it is about to allocated. * It may in fact end up on the wrong free list for its size. * That's not a disaster, since n is about to be allocated * by our caller. * (Hence adding it to a free list is silly. But this path is hopefully * rare enough that it doesn't matter. The code is cleaner this way.) */ STATIC void GC_split_block(struct hblk *h, hdr *hhdr, struct hblk *n, hdr *nhdr, int index /* Index of free list */) { word total_size = hhdr -> hb_sz; word h_size = (word)n - (word)h; struct hblk *prev = hhdr -> hb_prev; struct hblk *next = hhdr -> hb_next; /* Replace h with n on its freelist */ nhdr -> hb_prev = prev; nhdr -> hb_next = next; nhdr -> hb_sz = total_size - h_size; nhdr -> hb_flags = 0; if (0 != prev) { HDR(prev) -> hb_next = n; } else { GC_hblkfreelist[index] = n; } if (0 != next) { HDR(next) -> hb_prev = n; } GC_ASSERT(GC_free_bytes[index] > h_size); GC_free_bytes[index] -= h_size; # ifdef USE_MUNMAP hhdr -> hb_last_reclaimed = (unsigned short)GC_gc_no; # endif hhdr -> hb_sz = h_size; GC_add_to_fl(h, hhdr); nhdr -> hb_flags |= FREE_BLK; } STATIC struct hblk * GC_allochblk_nth(size_t sz /* bytes */, int kind, unsigned flags, int n, int may_split); #define AVOID_SPLIT_REMAPPED 2 /* * Allocate (and return pointer to) a heap block * for objects of size sz bytes, searching the nth free list. * * NOTE: We set obj_map field in header correctly. * Caller is responsible for building an object freelist in block. * * The client is responsible for clearing the block, if necessary. */ GC_INNER struct hblk * GC_allochblk(size_t sz, int kind, unsigned flags/* IGNORE_OFF_PAGE or 0 */) { word blocks; int start_list; struct hblk *result; int may_split; int split_limit; /* Highest index of free list whose blocks we */ /* split. */ GC_ASSERT((sz & (GRANULE_BYTES - 1)) == 0); blocks = OBJ_SZ_TO_BLOCKS(sz); if ((signed_word)(blocks * HBLKSIZE) < 0) { return 0; } start_list = GC_hblk_fl_from_blocks(blocks); /* Try for an exact match first. */ result = GC_allochblk_nth(sz, kind, flags, start_list, FALSE); if (0 != result) return result; may_split = TRUE; if (GC_use_entire_heap || GC_dont_gc || USED_HEAP_SIZE < GC_requested_heapsize || GC_incremental || !GC_should_collect()) { /* Should use more of the heap, even if it requires splitting. */ split_limit = N_HBLK_FLS; } else if (GC_finalizer_bytes_freed > (GC_heapsize >> 4)) { /* If we are deallocating lots of memory from */ /* finalizers, fail and collect sooner rather */ /* than later. */ split_limit = 0; } else { /* If we have enough large blocks left to cover any */ /* previous request for large blocks, we go ahead */ /* and split. Assuming a steady state, that should */ /* be safe. It means that we can use the full */ /* heap if we allocate only small objects. */ split_limit = GC_enough_large_bytes_left(); # ifdef USE_MUNMAP if (split_limit > 0) may_split = AVOID_SPLIT_REMAPPED; # endif } if (start_list < UNIQUE_THRESHOLD) { /* No reason to try start_list again, since all blocks are exact */ /* matches. */ ++start_list; } for (; start_list <= split_limit; ++start_list) { result = GC_allochblk_nth(sz, kind, flags, start_list, may_split); if (0 != result) break; } return result; } STATIC long GC_large_alloc_warn_suppressed = 0; /* Number of warnings suppressed so far. */ /* The same, but with search restricted to nth free list. Flags is */ /* IGNORE_OFF_PAGE or zero. sz is in bytes. The may_split flag */ /* indicates whether it is OK to split larger blocks (if set to */ /* AVOID_SPLIT_REMAPPED then memory remapping followed by splitting */ /* should be generally avoided). */ STATIC struct hblk * GC_allochblk_nth(size_t sz, int kind, unsigned flags, int n, int may_split) { struct hblk *hbp; hdr * hhdr; /* Header corr. to hbp */ struct hblk *thishbp; hdr * thishdr; /* Header corr. to thishbp */ signed_word size_needed; /* number of bytes in requested objects */ signed_word size_avail; /* bytes available in this block */ size_needed = HBLKSIZE * OBJ_SZ_TO_BLOCKS(sz); /* search for a big enough block in free list */ for (hbp = GC_hblkfreelist[n];; hbp = hhdr -> hb_next) { if (NULL == hbp) return NULL; GET_HDR(hbp, hhdr); /* set hhdr value */ size_avail = hhdr->hb_sz; if (size_avail < size_needed) continue; if (size_avail != size_needed) { signed_word next_size; if (!may_split) continue; /* If the next heap block is obviously better, go on. */ /* This prevents us from disassembling a single large */ /* block to get tiny blocks. */ thishbp = hhdr -> hb_next; if (thishbp != 0) { GET_HDR(thishbp, thishdr); next_size = (signed_word)(thishdr -> hb_sz); if (next_size < size_avail && next_size >= size_needed && !GC_is_black_listed(thishbp, (word)size_needed)) { continue; } } } if (!IS_UNCOLLECTABLE(kind) && (kind != PTRFREE || size_needed > (signed_word)MAX_BLACK_LIST_ALLOC)) { struct hblk * lasthbp = hbp; ptr_t search_end = (ptr_t)hbp + size_avail - size_needed; signed_word orig_avail = size_avail; signed_word eff_size_needed = (flags & IGNORE_OFF_PAGE) != 0 ? (signed_word)HBLKSIZE : size_needed; while ((word)lasthbp <= (word)search_end && (thishbp = GC_is_black_listed(lasthbp, (word)eff_size_needed)) != 0) { lasthbp = thishbp; } size_avail -= (ptr_t)lasthbp - (ptr_t)hbp; thishbp = lasthbp; if (size_avail >= size_needed) { if (thishbp != hbp) { # ifdef USE_MUNMAP /* Avoid remapping followed by splitting. */ if (may_split == AVOID_SPLIT_REMAPPED && !IS_MAPPED(hhdr)) continue; # endif thishdr = GC_install_header(thishbp); if (0 != thishdr) { /* Make sure it's mapped before we mangle it. */ # ifdef USE_MUNMAP if (!IS_MAPPED(hhdr)) { GC_remap((ptr_t)hbp, hhdr -> hb_sz); hhdr -> hb_flags &= ~WAS_UNMAPPED; } # endif /* Split the block at thishbp */ GC_split_block(hbp, hhdr, thishbp, thishdr, n); /* Advance to thishbp */ hbp = thishbp; hhdr = thishdr; /* We must now allocate thishbp, since it may */ /* be on the wrong free list. */ } } } else if (size_needed > (signed_word)BL_LIMIT && orig_avail - size_needed > (signed_word)BL_LIMIT) { /* Punt, since anything else risks unreasonable heap growth. */ if (++GC_large_alloc_warn_suppressed >= GC_large_alloc_warn_interval) { WARN("Repeated allocation of very large block " "(appr. size %" WARN_PRIdPTR "):\n" "\tMay lead to memory leak and poor performance.\n", size_needed); GC_large_alloc_warn_suppressed = 0; } size_avail = orig_avail; } else if (size_avail == 0 && size_needed == HBLKSIZE && IS_MAPPED(hhdr)) { if (!GC_find_leak) { static unsigned count = 0; /* The block is completely blacklisted. We need */ /* to drop some such blocks, since otherwise we spend */ /* all our time traversing them if pointer-free */ /* blocks are unpopular. */ /* A dropped block will be reconsidered at next GC. */ if ((++count & 3) == 0) { /* Allocate and drop the block in small chunks, to */ /* maximize the chance that we will recover some */ /* later. */ word total_size = hhdr -> hb_sz; struct hblk * limit = hbp + divHBLKSZ(total_size); struct hblk * h; struct hblk * prev = hhdr -> hb_prev; GC_large_free_bytes -= total_size; GC_bytes_dropped += total_size; GC_remove_from_fl_at(hhdr, n); for (h = hbp; (word)h < (word)limit; h++) { if (h != hbp) { hhdr = GC_install_header(h); } if (NULL != hhdr) { (void)setup_header(hhdr, h, HBLKSIZE, PTRFREE, 0); /* Can't fail. */ if (GC_debugging_started) { BZERO(h, HBLKSIZE); } } } /* Restore hbp to point at free block */ hbp = prev; if (0 == hbp) { return GC_allochblk_nth(sz, kind, flags, n, may_split); } hhdr = HDR(hbp); } } } } if( size_avail >= size_needed ) { # ifdef USE_MUNMAP if (!IS_MAPPED(hhdr)) { GC_remap((ptr_t)hbp, hhdr -> hb_sz); hhdr -> hb_flags &= ~WAS_UNMAPPED; /* Note: This may leave adjacent, mapped free blocks. */ } # endif /* hbp may be on the wrong freelist; the parameter n */ /* is important. */ hbp = GC_get_first_part(hbp, hhdr, size_needed, n); break; } } if (0 == hbp) return 0; /* Add it to map of valid blocks */ if (!GC_install_counts(hbp, (word)size_needed)) return(0); /* This leaks memory under very rare conditions. */ /* Set up header */ if (!setup_header(hhdr, hbp, sz, kind, flags)) { GC_remove_counts(hbp, (word)size_needed); return(0); /* ditto */ } # ifndef GC_DISABLE_INCREMENTAL /* Notify virtual dirty bit implementation that we are about to */ /* write. Ensure that pointer-free objects are not protected */ /* if it is avoidable. This also ensures that newly allocated */ /* blocks are treated as dirty. Necessary since we don't */ /* protect free blocks. */ GC_ASSERT((size_needed & (HBLKSIZE-1)) == 0); GC_remove_protection(hbp, divHBLKSZ(size_needed), (hhdr -> hb_descr == 0) /* pointer-free */); # endif /* We just successfully allocated a block. Restart count of */ /* consecutive failures. */ GC_fail_count = 0; GC_large_free_bytes -= size_needed; GC_ASSERT(IS_MAPPED(hhdr)); return( hbp ); } /* * Free a heap block. * * Coalesce the block with its neighbors if possible. * * All mark words are assumed to be cleared. */ GC_INNER void GC_freehblk(struct hblk *hbp) { struct hblk *next, *prev; hdr *hhdr, *prevhdr, *nexthdr; word size; GET_HDR(hbp, hhdr); size = HBLKSIZE * OBJ_SZ_TO_BLOCKS(hhdr->hb_sz); if ((signed_word)size <= 0) ABORT("Deallocating excessively large block. Too large an allocation?"); /* Probably possible if we try to allocate more than half the address */ /* space at once. If we don't catch it here, strange things happen */ /* later. */ GC_remove_counts(hbp, size); hhdr->hb_sz = size; # ifdef USE_MUNMAP hhdr -> hb_last_reclaimed = (unsigned short)GC_gc_no; # endif /* Check for duplicate deallocation in the easy case */ if (HBLK_IS_FREE(hhdr)) { ABORT_ARG1("Duplicate large block deallocation", " of %p", (void *)hbp); } GC_ASSERT(IS_MAPPED(hhdr)); hhdr -> hb_flags |= FREE_BLK; next = (struct hblk *)((ptr_t)hbp + size); GET_HDR(next, nexthdr); prev = GC_free_block_ending_at(hbp); /* Coalesce with successor, if possible */ if(0 != nexthdr && HBLK_IS_FREE(nexthdr) && IS_MAPPED(nexthdr) && (signed_word)(hhdr -> hb_sz + nexthdr -> hb_sz) > 0 /* no overflow */) { GC_remove_from_fl(nexthdr); hhdr -> hb_sz += nexthdr -> hb_sz; GC_remove_header(next); } /* Coalesce with predecessor, if possible. */ if (0 != prev) { prevhdr = HDR(prev); if (IS_MAPPED(prevhdr) && (signed_word)(hhdr -> hb_sz + prevhdr -> hb_sz) > 0) { GC_remove_from_fl(prevhdr); prevhdr -> hb_sz += hhdr -> hb_sz; # ifdef USE_MUNMAP prevhdr -> hb_last_reclaimed = (unsigned short)GC_gc_no; # endif GC_remove_header(hbp); hbp = prev; hhdr = prevhdr; } } /* FIXME: It is not clear we really always want to do these merges */ /* with USE_MUNMAP, since it updates ages and hence prevents */ /* unmapping. */ GC_large_free_bytes += size; GC_add_to_fl(hbp, hhdr); } ecl-16.1.2/src/bdwgc/alloc.c000066400000000000000000001335371266352375300155070ustar00rootroot00000000000000/* * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers * Copyright (c) 1991-1996 by Xerox Corporation. All rights reserved. * Copyright (c) 1998 by Silicon Graphics. All rights reserved. * Copyright (c) 1999-2004 Hewlett-Packard Development Company, L.P. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. * */ #include "private/gc_priv.h" #include #if !defined(MACOS) && !defined(MSWINCE) # include # if !defined(__CC_ARM) # include # endif #endif /* * Separate free lists are maintained for different sized objects * up to MAXOBJBYTES. * The call GC_allocobj(i,k) ensures that the freelist for * kind k objects of size i points to a non-empty * free list. It returns a pointer to the first entry on the free list. * In a single-threaded world, GC_allocobj may be called to allocate * an object of (small) size lb as follows: * * lg = GC_size_map[lb]; * op = GC_objfreelist[lg]; * if (NULL == op) { * op = GENERAL_MALLOC(lb, NORMAL); * } else { * GC_objfreelist[lg] = obj_link(op); * } * * Note that this is very fast if the free list is non-empty; it should * only involve the execution of 4 or 5 simple instructions. * All composite objects on freelists are cleared, except for * their first word. */ /* * The allocator uses GC_allochblk to allocate large chunks of objects. * These chunks all start on addresses which are multiples of * HBLKSZ. Each allocated chunk has an associated header, * which can be located quickly based on the address of the chunk. * (See headers.c for details.) * This makes it possible to check quickly whether an * arbitrary address corresponds to an object administered by the * allocator. */ word GC_non_gc_bytes = 0; /* Number of bytes not intended to be collected */ word GC_gc_no = 0; #ifndef GC_DISABLE_INCREMENTAL GC_INNER int GC_incremental = 0; /* By default, stop the world. */ #endif #ifdef THREADS int GC_parallel = FALSE; /* By default, parallel GC is off. */ #endif #ifndef GC_FULL_FREQ # define GC_FULL_FREQ 19 /* Every 20th collection is a full */ /* collection, whether we need it */ /* or not. */ #endif int GC_full_freq = GC_FULL_FREQ; STATIC GC_bool GC_need_full_gc = FALSE; /* Need full GC do to heap growth. */ #ifdef THREAD_LOCAL_ALLOC GC_INNER GC_bool GC_world_stopped = FALSE; #endif STATIC word GC_used_heap_size_after_full = 0; /* GC_copyright symbol is externally visible. */ char * const GC_copyright[] = {"Copyright 1988,1989 Hans-J. Boehm and Alan J. Demers ", "Copyright (c) 1991-1995 by Xerox Corporation. All rights reserved. ", "Copyright (c) 1996-1998 by Silicon Graphics. All rights reserved. ", "Copyright (c) 1999-2009 by Hewlett-Packard Company. All rights reserved. ", "THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY", " EXPRESSED OR IMPLIED. ANY USE IS AT YOUR OWN RISK.", "See source code for details." }; /* Version macros are now defined in gc_version.h, which is included by */ /* gc.h, which is included by gc_priv.h. */ #ifndef GC_NO_VERSION_VAR const unsigned GC_version = ((GC_VERSION_MAJOR << 16) | (GC_VERSION_MINOR << 8) | GC_VERSION_MICRO); #endif GC_API unsigned GC_CALL GC_get_version(void) { return (GC_VERSION_MAJOR << 16) | (GC_VERSION_MINOR << 8) | GC_VERSION_MICRO; } /* some more variables */ #ifdef GC_DONT_EXPAND int GC_dont_expand = TRUE; #else int GC_dont_expand = FALSE; #endif #ifndef GC_FREE_SPACE_DIVISOR # define GC_FREE_SPACE_DIVISOR 3 /* must be > 0 */ #endif word GC_free_space_divisor = GC_FREE_SPACE_DIVISOR; GC_INNER int GC_CALLBACK GC_never_stop_func(void) { return(0); } #ifndef GC_TIME_LIMIT # define GC_TIME_LIMIT 50 /* We try to keep pause times from exceeding */ /* this by much. In milliseconds. */ #endif unsigned long GC_time_limit = GC_TIME_LIMIT; #ifndef NO_CLOCK STATIC CLOCK_TYPE GC_start_time = 0; /* Time at which we stopped world. */ /* used only in GC_timeout_stop_func. */ #endif STATIC int GC_n_attempts = 0; /* Number of attempts at finishing */ /* collection within GC_time_limit. */ STATIC GC_stop_func GC_default_stop_func = GC_never_stop_func; /* accessed holding the lock. */ GC_API void GC_CALL GC_set_stop_func(GC_stop_func stop_func) { DCL_LOCK_STATE; GC_ASSERT(stop_func != 0); LOCK(); GC_default_stop_func = stop_func; UNLOCK(); } GC_API GC_stop_func GC_CALL GC_get_stop_func(void) { GC_stop_func stop_func; DCL_LOCK_STATE; LOCK(); stop_func = GC_default_stop_func; UNLOCK(); return stop_func; } #if defined(GC_DISABLE_INCREMENTAL) || defined(NO_CLOCK) # define GC_timeout_stop_func GC_default_stop_func #else STATIC int GC_CALLBACK GC_timeout_stop_func (void) { CLOCK_TYPE current_time; static unsigned count = 0; unsigned long time_diff; if ((*GC_default_stop_func)()) return(1); if ((count++ & 3) != 0) return(0); GET_TIME(current_time); time_diff = MS_TIME_DIFF(current_time,GC_start_time); if (time_diff >= GC_time_limit) { GC_COND_LOG_PRINTF( "Abandoning stopped marking after %lu msecs (attempt %d)\n", time_diff, GC_n_attempts); return(1); } return(0); } #endif /* !GC_DISABLE_INCREMENTAL */ #ifdef THREADS GC_INNER word GC_total_stacksize = 0; /* updated on every push_all_stacks */ #endif /* Return the minimum number of bytes that must be allocated between */ /* collections to amortize the collection cost. Should be non-zero. */ static word min_bytes_allocd(void) { word result; # ifdef STACK_NOT_SCANNED word stack_size = 0; # elif defined(STACK_GROWS_UP) word stack_size = GC_approx_sp() - GC_stackbottom; /* GC_stackbottom is used only for a single-threaded case. */ # else word stack_size = GC_stackbottom - GC_approx_sp(); # endif word total_root_size; /* includes double stack size, */ /* since the stack is expensive */ /* to scan. */ word scan_size; /* Estimate of memory to be scanned */ /* during normal GC. */ # ifdef THREADS if (GC_need_to_lock) { /* We are multi-threaded... */ stack_size = GC_total_stacksize; /* For now, we just use the value computed during the latest GC. */ # ifdef DEBUG_THREADS GC_log_printf("Total stacks size: %lu\n", (unsigned long)stack_size); # endif } # endif total_root_size = 2 * stack_size + GC_root_size; scan_size = 2 * GC_composite_in_use + GC_atomic_in_use / 4 + total_root_size; result = scan_size / GC_free_space_divisor; if (GC_incremental) { result /= 2; } return result > 0 ? result : 1; } STATIC word GC_non_gc_bytes_at_gc = 0; /* Number of explicitly managed bytes of storage */ /* at last collection. */ /* Return the number of bytes allocated, adjusted for explicit storage */ /* management, etc.. This number is used in deciding when to trigger */ /* collections. */ STATIC word GC_adj_bytes_allocd(void) { signed_word result; signed_word expl_managed = (signed_word)GC_non_gc_bytes - (signed_word)GC_non_gc_bytes_at_gc; /* Don't count what was explicitly freed, or newly allocated for */ /* explicit management. Note that deallocating an explicitly */ /* managed object should not alter result, assuming the client */ /* is playing by the rules. */ result = (signed_word)GC_bytes_allocd + (signed_word)GC_bytes_dropped - (signed_word)GC_bytes_freed + (signed_word)GC_finalizer_bytes_freed - expl_managed; if (result > (signed_word)GC_bytes_allocd) { result = GC_bytes_allocd; /* probably client bug or unfortunate scheduling */ } result += GC_bytes_finalized; /* We count objects enqueued for finalization as though they */ /* had been reallocated this round. Finalization is user */ /* visible progress. And if we don't count this, we have */ /* stability problems for programs that finalize all objects. */ if (result < (signed_word)(GC_bytes_allocd >> 3)) { /* Always count at least 1/8 of the allocations. We don't want */ /* to collect too infrequently, since that would inhibit */ /* coalescing of free storage blocks. */ /* This also makes us partially robust against client bugs. */ return(GC_bytes_allocd >> 3); } else { return(result); } } /* Clear up a few frames worth of garbage left at the top of the stack. */ /* This is used to prevent us from accidentally treating garbage left */ /* on the stack by other parts of the collector as roots. This */ /* differs from the code in misc.c, which actually tries to keep the */ /* stack clear of long-lived, client-generated garbage. */ STATIC void GC_clear_a_few_frames(void) { # ifndef CLEAR_NWORDS # define CLEAR_NWORDS 64 # endif volatile word frames[CLEAR_NWORDS]; BZERO((word *)frames, CLEAR_NWORDS * sizeof(word)); } /* Heap size at which we need a collection to avoid expanding past */ /* limits used by blacklisting. */ STATIC word GC_collect_at_heapsize = (word)(-1); /* Have we allocated enough to amortize a collection? */ GC_INNER GC_bool GC_should_collect(void) { static word last_min_bytes_allocd; static word last_gc_no; if (last_gc_no != GC_gc_no) { last_gc_no = GC_gc_no; last_min_bytes_allocd = min_bytes_allocd(); } return(GC_adj_bytes_allocd() >= last_min_bytes_allocd || GC_heapsize >= GC_collect_at_heapsize); } /* STATIC */ GC_start_callback_proc GC_start_call_back = 0; /* Called at start of full collections. */ /* Not called if 0. Called with the allocation */ /* lock held. Not used by GC itself. */ GC_API void GC_CALL GC_set_start_callback(GC_start_callback_proc fn) { DCL_LOCK_STATE; LOCK(); GC_start_call_back = fn; UNLOCK(); } GC_API GC_start_callback_proc GC_CALL GC_get_start_callback(void) { GC_start_callback_proc fn; DCL_LOCK_STATE; LOCK(); fn = GC_start_call_back; UNLOCK(); return fn; } GC_INLINE void GC_notify_full_gc(void) { if (GC_start_call_back != 0) { (*GC_start_call_back)(); } } STATIC GC_bool GC_is_full_gc = FALSE; STATIC GC_bool GC_stopped_mark(GC_stop_func stop_func); STATIC void GC_finish_collection(void); /* * Initiate a garbage collection if appropriate. * Choose judiciously * between partial, full, and stop-world collections. */ STATIC void GC_maybe_gc(void) { static int n_partial_gcs = 0; GC_ASSERT(I_HOLD_LOCK()); ASSERT_CANCEL_DISABLED(); if (GC_should_collect()) { if (!GC_incremental) { /* FIXME: If possible, GC_default_stop_func should be used here */ GC_try_to_collect_inner(GC_never_stop_func); n_partial_gcs = 0; return; } else { # ifdef PARALLEL_MARK if (GC_parallel) GC_wait_for_reclaim(); # endif if (GC_need_full_gc || n_partial_gcs >= GC_full_freq) { GC_COND_LOG_PRINTF( "***>Full mark for collection #%lu after %lu allocd bytes\n", (unsigned long)GC_gc_no + 1, (unsigned long)GC_bytes_allocd); GC_promote_black_lists(); (void)GC_reclaim_all((GC_stop_func)0, TRUE); GC_notify_full_gc(); GC_clear_marks(); n_partial_gcs = 0; GC_is_full_gc = TRUE; } else { n_partial_gcs++; } } /* We try to mark with the world stopped. */ /* If we run out of time, this turns into */ /* incremental marking. */ # ifndef NO_CLOCK if (GC_time_limit != GC_TIME_UNLIMITED) { GET_TIME(GC_start_time); } # endif /* FIXME: If possible, GC_default_stop_func should be */ /* used instead of GC_never_stop_func here. */ if (GC_stopped_mark(GC_time_limit == GC_TIME_UNLIMITED? GC_never_stop_func : GC_timeout_stop_func)) { # ifdef SAVE_CALL_CHAIN GC_save_callers(GC_last_stack); # endif GC_finish_collection(); } else { if (!GC_is_full_gc) { /* Count this as the first attempt */ GC_n_attempts++; } } } } /* * Stop the world garbage collection. Assumes lock held. If stop_func is * not GC_never_stop_func then abort if stop_func returns TRUE. * Return TRUE if we successfully completed the collection. */ GC_INNER GC_bool GC_try_to_collect_inner(GC_stop_func stop_func) { # ifndef SMALL_CONFIG CLOCK_TYPE start_time = 0; /* initialized to prevent warning. */ CLOCK_TYPE current_time; # endif ASSERT_CANCEL_DISABLED(); if (GC_dont_gc || (*stop_func)()) return FALSE; if (GC_incremental && GC_collection_in_progress()) { GC_COND_LOG_PRINTF( "GC_try_to_collect_inner: finishing collection in progress\n"); /* Just finish collection already in progress. */ while(GC_collection_in_progress()) { if ((*stop_func)()) return(FALSE); GC_collect_a_little_inner(1); } } GC_notify_full_gc(); # ifndef SMALL_CONFIG if (GC_print_stats) { GET_TIME(start_time); GC_log_printf("Initiating full world-stop collection!\n"); } # endif GC_promote_black_lists(); /* Make sure all blocks have been reclaimed, so sweep routines */ /* don't see cleared mark bits. */ /* If we're guaranteed to finish, then this is unnecessary. */ /* In the find_leak case, we have to finish to guarantee that */ /* previously unmarked objects are not reported as leaks. */ # ifdef PARALLEL_MARK if (GC_parallel) GC_wait_for_reclaim(); # endif if ((GC_find_leak || stop_func != GC_never_stop_func) && !GC_reclaim_all(stop_func, FALSE)) { /* Aborted. So far everything is still consistent. */ return(FALSE); } GC_invalidate_mark_state(); /* Flush mark stack. */ GC_clear_marks(); # ifdef SAVE_CALL_CHAIN GC_save_callers(GC_last_stack); # endif GC_is_full_gc = TRUE; if (!GC_stopped_mark(stop_func)) { if (!GC_incremental) { /* We're partially done and have no way to complete or use */ /* current work. Reestablish invariants as cheaply as */ /* possible. */ GC_invalidate_mark_state(); GC_unpromote_black_lists(); } /* else we claim the world is already still consistent. We'll */ /* finish incrementally. */ return(FALSE); } GC_finish_collection(); # ifndef SMALL_CONFIG if (GC_print_stats) { GET_TIME(current_time); GC_log_printf("Complete collection took %lu msecs\n", MS_TIME_DIFF(current_time,start_time)); } # endif return(TRUE); } /* * Perform n units of garbage collection work. A unit is intended to touch * roughly GC_RATE pages. Every once in a while, we do more than that. * This needs to be a fairly large number with our current incremental * GC strategy, since otherwise we allocate too much during GC, and the * cleanup gets expensive. */ #ifndef GC_RATE # define GC_RATE 10 #endif #ifndef MAX_PRIOR_ATTEMPTS # define MAX_PRIOR_ATTEMPTS 1 #endif /* Maximum number of prior attempts at world stop marking */ /* A value of 1 means that we finish the second time, no matter */ /* how long it takes. Doesn't count the initial root scan */ /* for a full GC. */ STATIC int GC_deficit = 0;/* The number of extra calls to GC_mark_some */ /* that we have made. */ GC_INNER void GC_collect_a_little_inner(int n) { int i; IF_CANCEL(int cancel_state;) if (GC_dont_gc) return; DISABLE_CANCEL(cancel_state); if (GC_incremental && GC_collection_in_progress()) { for (i = GC_deficit; i < GC_RATE*n; i++) { if (GC_mark_some((ptr_t)0)) { /* Need to finish a collection */ # ifdef SAVE_CALL_CHAIN GC_save_callers(GC_last_stack); # endif # ifdef PARALLEL_MARK if (GC_parallel) GC_wait_for_reclaim(); # endif if (GC_n_attempts < MAX_PRIOR_ATTEMPTS && GC_time_limit != GC_TIME_UNLIMITED) { # ifndef NO_CLOCK GET_TIME(GC_start_time); # endif if (!GC_stopped_mark(GC_timeout_stop_func)) { GC_n_attempts++; break; } } else { /* FIXME: If possible, GC_default_stop_func should be */ /* used here. */ (void)GC_stopped_mark(GC_never_stop_func); } GC_finish_collection(); break; } } if (GC_deficit > 0) GC_deficit -= GC_RATE*n; if (GC_deficit < 0) GC_deficit = 0; } else { GC_maybe_gc(); } RESTORE_CANCEL(cancel_state); } GC_INNER void (*GC_check_heap)(void) = 0; GC_INNER void (*GC_print_all_smashed)(void) = 0; GC_API int GC_CALL GC_collect_a_little(void) { int result; DCL_LOCK_STATE; LOCK(); GC_collect_a_little_inner(1); result = (int)GC_collection_in_progress(); UNLOCK(); if (!result && GC_debugging_started) GC_print_all_smashed(); return(result); } #ifndef SMALL_CONFIG /* Variables for world-stop average delay time statistic computation. */ /* "divisor" is incremented every world-stop and halved when reached */ /* its maximum (or upon "total_time" overflow). */ static unsigned world_stopped_total_time = 0; static unsigned world_stopped_total_divisor = 0; # ifndef MAX_TOTAL_TIME_DIVISOR /* We shall not use big values here (so "outdated" delay time */ /* values would have less impact on "average" delay time value than */ /* newer ones). */ # define MAX_TOTAL_TIME_DIVISOR 1000 # endif #endif #ifdef USE_MUNMAP # define IF_USE_MUNMAP(x) x # define COMMA_IF_USE_MUNMAP(x) /* comma */, x #else # define IF_USE_MUNMAP(x) /* empty */ # define COMMA_IF_USE_MUNMAP(x) /* empty */ #endif /* * Assumes lock is held. We stop the world and mark from all roots. * If stop_func() ever returns TRUE, we may fail and return FALSE. * Increment GC_gc_no if we succeed. */ STATIC GC_bool GC_stopped_mark(GC_stop_func stop_func) { unsigned i; # ifndef SMALL_CONFIG CLOCK_TYPE start_time = 0; /* initialized to prevent warning. */ CLOCK_TYPE current_time; # endif # if !defined(REDIRECT_MALLOC) && defined(USE_WINALLOC) GC_add_current_malloc_heap(); # endif # if defined(REGISTER_LIBRARIES_EARLY) GC_cond_register_dynamic_libraries(); # endif # ifndef SMALL_CONFIG if (GC_PRINT_STATS_FLAG) GET_TIME(start_time); # endif STOP_WORLD(); # ifdef THREAD_LOCAL_ALLOC GC_world_stopped = TRUE; # endif /* Output blank line for convenience here */ GC_COND_LOG_PRINTF( "\n--> Marking for collection #%lu after %lu allocated bytes\n", (unsigned long)GC_gc_no + 1, (unsigned long) GC_bytes_allocd); # ifdef MAKE_BACK_GRAPH if (GC_print_back_height) { GC_build_back_graph(); } # endif /* Mark from all roots. */ /* Minimize junk left in my registers and on the stack */ GC_clear_a_few_frames(); GC_noop6(0,0,0,0,0,0); GC_initiate_gc(); for (i = 0;;i++) { if ((*stop_func)()) { GC_COND_LOG_PRINTF("Abandoned stopped marking after" " %u iterations\n", i); GC_deficit = i; /* Give the mutator a chance. */ # ifdef THREAD_LOCAL_ALLOC GC_world_stopped = FALSE; # endif START_WORLD(); return(FALSE); } if (GC_mark_some(GC_approx_sp())) break; } GC_gc_no++; GC_DBGLOG_PRINTF("GC #%lu freed %ld bytes, heap %lu KiB" IF_USE_MUNMAP(" (+ %lu KiB unmapped)") "\n", (unsigned long)GC_gc_no, (long)GC_bytes_found, TO_KiB_UL(GC_heapsize - GC_unmapped_bytes) /*, */ COMMA_IF_USE_MUNMAP(TO_KiB_UL(GC_unmapped_bytes))); /* Check all debugged objects for consistency */ if (GC_debugging_started) { (*GC_check_heap)(); } # ifdef THREAD_LOCAL_ALLOC GC_world_stopped = FALSE; # endif START_WORLD(); # ifndef SMALL_CONFIG if (GC_PRINT_STATS_FLAG) { unsigned long time_diff; unsigned total_time, divisor; GET_TIME(current_time); time_diff = MS_TIME_DIFF(current_time,start_time); /* Compute new world-stop delay total time */ total_time = world_stopped_total_time; divisor = world_stopped_total_divisor; if ((int)total_time < 0 || divisor >= MAX_TOTAL_TIME_DIVISOR) { /* Halve values if overflow occurs */ total_time >>= 1; divisor >>= 1; } total_time += time_diff < (((unsigned)-1) >> 1) ? (unsigned)time_diff : ((unsigned)-1) >> 1; /* Update old world_stopped_total_time and its divisor */ world_stopped_total_time = total_time; world_stopped_total_divisor = ++divisor; GC_ASSERT(divisor != 0); GC_log_printf( "World-stopped marking took %lu msecs (%u in average)\n", time_diff, total_time / divisor); } # endif return(TRUE); } /* Set all mark bits for the free list whose first entry is q */ GC_INNER void GC_set_fl_marks(ptr_t q) { struct hblk *h, *last_h; hdr *hhdr; IF_PER_OBJ(size_t sz;) unsigned bit_no; if (q != NULL) { h = HBLKPTR(q); last_h = h; hhdr = HDR(h); IF_PER_OBJ(sz = hhdr->hb_sz;) for (;;) { bit_no = MARK_BIT_NO((ptr_t)q - (ptr_t)h, sz); if (!mark_bit_from_hdr(hhdr, bit_no)) { set_mark_bit_from_hdr(hhdr, bit_no); ++hhdr -> hb_n_marks; } q = obj_link(q); if (q == NULL) break; h = HBLKPTR(q); if (h != last_h) { last_h = h; hhdr = HDR(h); IF_PER_OBJ(sz = hhdr->hb_sz;) } } } } #if defined(GC_ASSERTIONS) && defined(THREADS) && defined(THREAD_LOCAL_ALLOC) /* Check that all mark bits for the free list whose first entry is */ /* (*pfreelist) are set. Check skipped if points to a special value. */ void GC_check_fl_marks(void **pfreelist) { # ifdef AO_HAVE_load_acquire_read AO_t *list = (AO_t *)AO_load_acquire_read((AO_t *)pfreelist); /* Atomic operations are used because the world is running. */ AO_t *prev; AO_t *p; if ((word)list <= HBLKSIZE) return; prev = (AO_t *)pfreelist; for (p = list; p != NULL;) { AO_t *next; if (!GC_is_marked(p)) { ABORT_ARG2("Unmarked local free list entry", ": object %p on list %p", (void *)p, (void *)list); } /* While traversing the free-list, it re-reads the pointer to */ /* the current node before accepting its next pointer and */ /* bails out if the latter has changed. That way, it won't */ /* try to follow the pointer which might be been modified */ /* after the object was returned to the client. It might */ /* perform the mark-check on the just allocated object but */ /* that should be harmless. */ next = (AO_t *)AO_load_acquire_read(p); if (AO_load(prev) != (AO_t)p) break; prev = p; p = next; } # else /* FIXME: Not implemented (just skipped). */ (void)pfreelist; # endif } #endif /* GC_ASSERTIONS && THREAD_LOCAL_ALLOC */ /* Clear all mark bits for the free list whose first entry is q */ /* Decrement GC_bytes_found by number of bytes on free list. */ STATIC void GC_clear_fl_marks(ptr_t q) { struct hblk *h, *last_h; hdr *hhdr; size_t sz; unsigned bit_no; if (q != NULL) { h = HBLKPTR(q); last_h = h; hhdr = HDR(h); sz = hhdr->hb_sz; /* Normally set only once. */ for (;;) { bit_no = MARK_BIT_NO((ptr_t)q - (ptr_t)h, sz); if (mark_bit_from_hdr(hhdr, bit_no)) { size_t n_marks = hhdr -> hb_n_marks - 1; clear_mark_bit_from_hdr(hhdr, bit_no); # ifdef PARALLEL_MARK /* Appr. count, don't decrement to zero! */ if (0 != n_marks || !GC_parallel) { hhdr -> hb_n_marks = n_marks; } # else hhdr -> hb_n_marks = n_marks; # endif } GC_bytes_found -= sz; q = obj_link(q); if (q == NULL) break; h = HBLKPTR(q); if (h != last_h) { last_h = h; hhdr = HDR(h); sz = hhdr->hb_sz; } } } } #if defined(GC_ASSERTIONS) && defined(THREADS) && defined(THREAD_LOCAL_ALLOC) void GC_check_tls(void); #endif GC_on_heap_resize_proc GC_on_heap_resize = 0; /* Used for logging only. */ GC_INLINE int GC_compute_heap_usage_percent(void) { word used = GC_composite_in_use + GC_atomic_in_use; word heap_sz = GC_heapsize - GC_unmapped_bytes; return used >= heap_sz ? 0 : used < ((word)-1) / 100 ? (int)((used * 100) / heap_sz) : (int)(used / (heap_sz / 100)); } /* Finish up a collection. Assumes mark bits are consistent, lock is */ /* held, but the world is otherwise running. */ STATIC void GC_finish_collection(void) { # ifndef SMALL_CONFIG CLOCK_TYPE start_time = 0; /* initialized to prevent warning. */ CLOCK_TYPE finalize_time = 0; CLOCK_TYPE done_time; # endif # if defined(GC_ASSERTIONS) && defined(THREADS) \ && defined(THREAD_LOCAL_ALLOC) && !defined(DBG_HDRS_ALL) /* Check that we marked some of our own data. */ /* FIXME: Add more checks. */ GC_check_tls(); # endif # ifndef SMALL_CONFIG if (GC_print_stats) GET_TIME(start_time); # endif # ifndef GC_GET_HEAP_USAGE_NOT_NEEDED if (GC_bytes_found > 0) GC_reclaimed_bytes_before_gc += (word)GC_bytes_found; # endif GC_bytes_found = 0; # if defined(LINUX) && defined(__ELF__) && !defined(SMALL_CONFIG) if (GETENV("GC_PRINT_ADDRESS_MAP") != 0) { GC_print_address_map(); } # endif COND_DUMP; if (GC_find_leak) { /* Mark all objects on the free list. All objects should be */ /* marked when we're done. */ word size; /* current object size */ unsigned kind; ptr_t q; for (kind = 0; kind < GC_n_kinds; kind++) { for (size = 1; size <= MAXOBJGRANULES; size++) { q = GC_obj_kinds[kind].ok_freelist[size]; if (q != 0) GC_set_fl_marks(q); } } GC_start_reclaim(TRUE); /* The above just checks; it doesn't really reclaim anything. */ } # ifndef GC_NO_FINALIZATION GC_finalize(); # endif # ifdef STUBBORN_ALLOC GC_clean_changing_list(); # endif # ifndef SMALL_CONFIG if (GC_print_stats) GET_TIME(finalize_time); # endif if (GC_print_back_height) { # ifdef MAKE_BACK_GRAPH GC_traverse_back_graph(); # elif !defined(SMALL_CONFIG) GC_err_printf("Back height not available: " "Rebuild collector with -DMAKE_BACK_GRAPH\n"); # endif } /* Clear free list mark bits, in case they got accidentally marked */ /* (or GC_find_leak is set and they were intentionally marked). */ /* Also subtract memory remaining from GC_bytes_found count. */ /* Note that composite objects on free list are cleared. */ /* Thus accidentally marking a free list is not a problem; only */ /* objects on the list itself will be marked, and that's fixed here. */ { word size; /* current object size */ ptr_t q; /* pointer to current object */ unsigned kind; for (kind = 0; kind < GC_n_kinds; kind++) { for (size = 1; size <= MAXOBJGRANULES; size++) { q = GC_obj_kinds[kind].ok_freelist[size]; if (q != 0) GC_clear_fl_marks(q); } } } GC_VERBOSE_LOG_PRINTF("Bytes recovered before sweep - f.l. count = %ld\n", (long)GC_bytes_found); /* Reconstruct free lists to contain everything not marked */ GC_start_reclaim(FALSE); GC_DBGLOG_PRINTF("In-use heap: %d%% (%lu KiB pointers + %lu KiB other)\n", GC_compute_heap_usage_percent(), TO_KiB_UL(GC_composite_in_use), TO_KiB_UL(GC_atomic_in_use)); if (GC_is_full_gc) { GC_used_heap_size_after_full = USED_HEAP_SIZE; GC_need_full_gc = FALSE; } else { GC_need_full_gc = USED_HEAP_SIZE - GC_used_heap_size_after_full > min_bytes_allocd(); } GC_VERBOSE_LOG_PRINTF("Immediately reclaimed %ld bytes, heapsize:" " %lu bytes" IF_USE_MUNMAP(" (%lu unmapped)") "\n", (long)GC_bytes_found, (unsigned long)GC_heapsize /*, */ COMMA_IF_USE_MUNMAP((unsigned long) GC_unmapped_bytes)); /* Reset or increment counters for next cycle */ GC_n_attempts = 0; GC_is_full_gc = FALSE; GC_bytes_allocd_before_gc += GC_bytes_allocd; GC_non_gc_bytes_at_gc = GC_non_gc_bytes; GC_bytes_allocd = 0; GC_bytes_dropped = 0; GC_bytes_freed = 0; GC_finalizer_bytes_freed = 0; IF_USE_MUNMAP(GC_unmap_old()); # ifndef SMALL_CONFIG if (GC_print_stats) { GET_TIME(done_time); # ifndef GC_NO_FINALIZATION /* A convenient place to output finalization statistics. */ GC_print_finalization_stats(); # endif GC_log_printf("Finalize plus initiate sweep took %lu + %lu msecs\n", MS_TIME_DIFF(finalize_time,start_time), MS_TIME_DIFF(done_time,finalize_time)); } # endif } /* If stop_func == 0 then GC_default_stop_func is used instead. */ STATIC GC_bool GC_try_to_collect_general(GC_stop_func stop_func, GC_bool force_unmap GC_ATTR_UNUSED) { GC_bool result; IF_USE_MUNMAP(int old_unmap_threshold;) IF_CANCEL(int cancel_state;) DCL_LOCK_STATE; if (!EXPECT(GC_is_initialized, TRUE)) GC_init(); if (GC_debugging_started) GC_print_all_smashed(); GC_INVOKE_FINALIZERS(); LOCK(); DISABLE_CANCEL(cancel_state); # ifdef USE_MUNMAP old_unmap_threshold = GC_unmap_threshold; if (force_unmap || (GC_force_unmap_on_gcollect && old_unmap_threshold > 0)) GC_unmap_threshold = 1; /* unmap as much as possible */ # endif ENTER_GC(); /* Minimize junk left in my registers */ GC_noop6(0,0,0,0,0,0); result = GC_try_to_collect_inner(stop_func != 0 ? stop_func : GC_default_stop_func); EXIT_GC(); IF_USE_MUNMAP(GC_unmap_threshold = old_unmap_threshold); /* restore */ RESTORE_CANCEL(cancel_state); UNLOCK(); if (result) { if (GC_debugging_started) GC_print_all_smashed(); GC_INVOKE_FINALIZERS(); } return(result); } /* Externally callable routines to invoke full, stop-the-world collection. */ GC_API int GC_CALL GC_try_to_collect(GC_stop_func stop_func) { GC_ASSERT(stop_func != 0); return (int)GC_try_to_collect_general(stop_func, FALSE); } GC_API void GC_CALL GC_gcollect(void) { /* 0 is passed as stop_func to get GC_default_stop_func value */ /* while holding the allocation lock (to prevent data races). */ (void)GC_try_to_collect_general(0, FALSE); if (GC_have_errors) GC_print_all_errors(); } STATIC word GC_heapsize_at_forced_unmap = 0; GC_API void GC_CALL GC_gcollect_and_unmap(void) { /* Record current heap size to make heap growth more conservative */ /* afterwards (as if the heap is growing from zero size again). */ GC_heapsize_at_forced_unmap = GC_heapsize; /* Collect and force memory unmapping to OS. */ (void)GC_try_to_collect_general(GC_never_stop_func, TRUE); } GC_INNER word GC_n_heap_sects = 0; /* Number of sections currently in heap. */ #ifdef USE_PROC_FOR_LIBRARIES GC_INNER word GC_n_memory = 0; /* Number of GET_MEM allocated memory sections. */ #endif #ifdef USE_PROC_FOR_LIBRARIES /* Add HBLKSIZE aligned, GET_MEM-generated block to GC_our_memory. */ /* Defined to do nothing if USE_PROC_FOR_LIBRARIES not set. */ GC_INNER void GC_add_to_our_memory(ptr_t p, size_t bytes) { if (0 == p) return; if (GC_n_memory >= MAX_HEAP_SECTS) ABORT("Too many GC-allocated memory sections: Increase MAX_HEAP_SECTS"); GC_our_memory[GC_n_memory].hs_start = p; GC_our_memory[GC_n_memory].hs_bytes = bytes; GC_n_memory++; } #endif /* * Use the chunk of memory starting at p of size bytes as part of the heap. * Assumes p is HBLKSIZE aligned, and bytes is a multiple of HBLKSIZE. */ GC_INNER void GC_add_to_heap(struct hblk *p, size_t bytes) { hdr * phdr; word endp; if (GC_n_heap_sects >= MAX_HEAP_SECTS) { ABORT("Too many heap sections: Increase MAXHINCR or MAX_HEAP_SECTS"); } while ((word)p <= HBLKSIZE) { /* Can't handle memory near address zero. */ ++p; bytes -= HBLKSIZE; if (0 == bytes) return; } endp = (word)p + bytes; if (endp <= (word)p) { /* Address wrapped. */ bytes -= HBLKSIZE; if (0 == bytes) return; endp -= HBLKSIZE; } phdr = GC_install_header(p); if (0 == phdr) { /* This is extremely unlikely. Can't add it. This will */ /* almost certainly result in a 0 return from the allocator, */ /* which is entirely appropriate. */ return; } GC_ASSERT(endp > (word)p && endp == (word)p + bytes); GC_heap_sects[GC_n_heap_sects].hs_start = (ptr_t)p; GC_heap_sects[GC_n_heap_sects].hs_bytes = bytes; GC_n_heap_sects++; phdr -> hb_sz = bytes; phdr -> hb_flags = 0; GC_freehblk(p); GC_heapsize += bytes; /* Normally the caller calculates a new GC_collect_at_heapsize, * but this is also called directly from alloc_mark_stack, so * adjust here. It will be recalculated when called from * GC_expand_hp_inner. */ GC_collect_at_heapsize += bytes; if (GC_collect_at_heapsize < GC_heapsize /* wrapped */) GC_collect_at_heapsize = (word)(-1); if ((word)p <= (word)GC_least_plausible_heap_addr || GC_least_plausible_heap_addr == 0) { GC_least_plausible_heap_addr = (void *)((ptr_t)p - sizeof(word)); /* Making it a little smaller than necessary prevents */ /* us from getting a false hit from the variable */ /* itself. There's some unintentional reflection */ /* here. */ } if ((word)p + bytes >= (word)GC_greatest_plausible_heap_addr) { GC_greatest_plausible_heap_addr = (void *)endp; } } #if !defined(NO_DEBUGGING) void GC_print_heap_sects(void) { unsigned i; GC_printf("Total heap size: %lu" IF_USE_MUNMAP(" (%lu unmapped)") "\n", (unsigned long)GC_heapsize /*, */ COMMA_IF_USE_MUNMAP((unsigned long)GC_unmapped_bytes)); for (i = 0; i < GC_n_heap_sects; i++) { ptr_t start = GC_heap_sects[i].hs_start; size_t len = GC_heap_sects[i].hs_bytes; struct hblk *h; unsigned nbl = 0; for (h = (struct hblk *)start; (word)h < (word)(start + len); h++) { if (GC_is_black_listed(h, HBLKSIZE)) nbl++; } GC_printf("Section %d from %p to %p %lu/%lu blacklisted\n", i, start, start + len, (unsigned long)nbl, (unsigned long)(len/HBLKSIZE)); } } #endif void * GC_least_plausible_heap_addr = (void *)ONES; void * GC_greatest_plausible_heap_addr = 0; GC_INLINE word GC_max(word x, word y) { return(x > y? x : y); } GC_INLINE word GC_min(word x, word y) { return(x < y? x : y); } STATIC word GC_max_heapsize = 0; GC_API void GC_CALL GC_set_max_heap_size(GC_word n) { GC_max_heapsize = n; } GC_word GC_max_retries = 0; /* This explicitly increases the size of the heap. It is used */ /* internally, but may also be invoked from GC_expand_hp by the user. */ /* The argument is in units of HBLKSIZE (tiny values are rounded up). */ /* Returns FALSE on failure. */ GC_INNER GC_bool GC_expand_hp_inner(word n) { word bytes; struct hblk * space; word expansion_slop; /* Number of bytes by which we expect the */ /* heap to expand soon. */ if (n < MINHINCR) n = MINHINCR; bytes = ROUNDUP_PAGESIZE(n * HBLKSIZE); if (GC_max_heapsize != 0 && GC_heapsize + bytes > GC_max_heapsize) { /* Exceeded self-imposed limit */ return(FALSE); } space = GET_MEM(bytes); GC_add_to_our_memory((ptr_t)space, bytes); if (space == 0) { WARN("Failed to expand heap by %" WARN_PRIdPTR " bytes\n", bytes); return(FALSE); } GC_INFOLOG_PRINTF("Grow heap to %lu KiB after %lu bytes allocated\n", TO_KiB_UL(GC_heapsize + bytes), (unsigned long)GC_bytes_allocd); /* Adjust heap limits generously for blacklisting to work better. */ /* GC_add_to_heap performs minimal adjustment needed for */ /* correctness. */ expansion_slop = min_bytes_allocd() + 4*MAXHINCR*HBLKSIZE; if ((GC_last_heap_addr == 0 && !((word)space & SIGNB)) || (GC_last_heap_addr != 0 && (word)GC_last_heap_addr < (word)space)) { /* Assume the heap is growing up */ word new_limit = (word)space + bytes + expansion_slop; if (new_limit > (word)space) { GC_greatest_plausible_heap_addr = (void *)GC_max((word)GC_greatest_plausible_heap_addr, (word)new_limit); } } else { /* Heap is growing down */ word new_limit = (word)space - expansion_slop; if (new_limit < (word)space) { GC_least_plausible_heap_addr = (void *)GC_min((word)GC_least_plausible_heap_addr, (word)space - expansion_slop); } } GC_prev_heap_addr = GC_last_heap_addr; GC_last_heap_addr = (ptr_t)space; GC_add_to_heap(space, bytes); /* Force GC before we are likely to allocate past expansion_slop */ GC_collect_at_heapsize = GC_heapsize + expansion_slop - 2*MAXHINCR*HBLKSIZE; if (GC_collect_at_heapsize < GC_heapsize /* wrapped */) GC_collect_at_heapsize = (word)(-1); if (GC_on_heap_resize) (*GC_on_heap_resize)(GC_heapsize); return(TRUE); } /* Really returns a bool, but it's externally visible, so that's clumsy. */ /* Arguments is in bytes. Includes GC_init() call. */ GC_API int GC_CALL GC_expand_hp(size_t bytes) { int result; DCL_LOCK_STATE; LOCK(); if (!EXPECT(GC_is_initialized, TRUE)) GC_init(); result = (int)GC_expand_hp_inner(divHBLKSZ((word)bytes)); if (result) GC_requested_heapsize += bytes; UNLOCK(); return(result); } word GC_fo_entries = 0; /* used also in extra/MacOS.c */ GC_INNER unsigned GC_fail_count = 0; /* How many consecutive GC/expansion failures? */ /* Reset by GC_allochblk. */ static word last_fo_entries = 0; static word last_bytes_finalized = 0; /* Collect or expand heap in an attempt make the indicated number of */ /* free blocks available. Should be called until the blocks are */ /* available (setting retry value to TRUE unless this is the first call */ /* in a loop) or until it fails by returning FALSE. */ GC_INNER GC_bool GC_collect_or_expand(word needed_blocks, GC_bool ignore_off_page, GC_bool retry) { GC_bool gc_not_stopped = TRUE; word blocks_to_get; IF_CANCEL(int cancel_state;) DISABLE_CANCEL(cancel_state); if (!GC_incremental && !GC_dont_gc && ((GC_dont_expand && GC_bytes_allocd > 0) || (GC_fo_entries > (last_fo_entries + 500) && (last_bytes_finalized | GC_bytes_finalized) != 0) || GC_should_collect())) { /* Try to do a full collection using 'default' stop_func (unless */ /* nothing has been allocated since the latest collection or heap */ /* expansion is disabled). */ gc_not_stopped = GC_try_to_collect_inner( GC_bytes_allocd > 0 && (!GC_dont_expand || !retry) ? GC_default_stop_func : GC_never_stop_func); if (gc_not_stopped == TRUE || !retry) { /* Either the collection hasn't been aborted or this is the */ /* first attempt (in a loop). */ last_fo_entries = GC_fo_entries; last_bytes_finalized = GC_bytes_finalized; RESTORE_CANCEL(cancel_state); return(TRUE); } } blocks_to_get = (GC_heapsize - GC_heapsize_at_forced_unmap) / (HBLKSIZE * GC_free_space_divisor) + needed_blocks; if (blocks_to_get > MAXHINCR) { word slop; /* Get the minimum required to make it likely that we can satisfy */ /* the current request in the presence of black-listing. */ /* This will probably be more than MAXHINCR. */ if (ignore_off_page) { slop = 4; } else { slop = 2 * divHBLKSZ(BL_LIMIT); if (slop > needed_blocks) slop = needed_blocks; } if (needed_blocks + slop > MAXHINCR) { blocks_to_get = needed_blocks + slop; } else { blocks_to_get = MAXHINCR; } } if (!GC_expand_hp_inner(blocks_to_get) && (blocks_to_get == needed_blocks || !GC_expand_hp_inner(needed_blocks))) { if (gc_not_stopped == FALSE) { /* Don't increment GC_fail_count here (and no warning). */ GC_gcollect_inner(); GC_ASSERT(GC_bytes_allocd == 0); } else if (GC_fail_count++ < GC_max_retries) { WARN("Out of Memory! Trying to continue ...\n", 0); GC_gcollect_inner(); } else { # if !defined(AMIGA) || !defined(GC_AMIGA_FASTALLOC) WARN("Out of Memory! Heap size: %" WARN_PRIdPTR " MiB." " Returning NULL!\n", (GC_heapsize - GC_unmapped_bytes) >> 20); # endif RESTORE_CANCEL(cancel_state); return(FALSE); } } else if (GC_fail_count) { GC_COND_LOG_PRINTF("Memory available again...\n"); } RESTORE_CANCEL(cancel_state); return(TRUE); } /* * Make sure the object free list for size gran (in granules) is not empty. * Return a pointer to the first object on the free list. * The object MUST BE REMOVED FROM THE FREE LIST BY THE CALLER. * Assumes we hold the allocator lock. */ GC_INNER ptr_t GC_allocobj(size_t gran, int kind) { void ** flh = &(GC_obj_kinds[kind].ok_freelist[gran]); GC_bool tried_minor = FALSE; GC_bool retry = FALSE; if (gran == 0) return(0); while (*flh == 0) { ENTER_GC(); /* Do our share of marking work */ if(TRUE_INCREMENTAL) GC_collect_a_little_inner(1); /* Sweep blocks for objects of this size */ GC_continue_reclaim(gran, kind); EXIT_GC(); if (*flh == 0) { GC_new_hblk(gran, kind); if (*flh == 0) { ENTER_GC(); if (GC_incremental && GC_time_limit == GC_TIME_UNLIMITED && !tried_minor) { GC_collect_a_little_inner(1); tried_minor = TRUE; } else { if (!GC_collect_or_expand(1, FALSE, retry)) { EXIT_GC(); return(0); } retry = TRUE; } EXIT_GC(); } } } /* Successful allocation; reset failure count. */ GC_fail_count = 0; return(*flh); } ecl-16.1.2/src/bdwgc/autogen.sh000077500000000000000000000013171266352375300162400ustar00rootroot00000000000000#!/bin/sh set -e # This script creates (or regenerates) configure (as well as aclocal.m4, # config.h.in, Makefile.in, etc.) missing in the source repository. # # If you compile from a distribution tarball, you can skip this. Otherwise, # make sure that you have Autoconf, Automake, Libtool, and pkg-config # installed on your system, and that the corresponding *.m4 files are visible # to the aclocal. The latter can be achieved by using packages shipped by # your OS, or by installing custom versions of all four packages to the same # prefix. Otherwise, you may need to invoke autoreconf with the appropriate # -I options to locate the required *.m4 files. autoreconf -i echo echo "Ready to run './configure'." ecl-16.1.2/src/bdwgc/backgraph.c000066400000000000000000000424521266352375300163320ustar00rootroot00000000000000/* * Copyright (c) 2001 by Hewlett-Packard Company. All rights reserved. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. * */ #include "private/dbg_mlc.h" /* * This implements a full, though not well-tuned, representation of the * backwards points-to graph. This is used to test for non-GC-robust * data structures; the code is not used during normal garbage collection. * * One restriction is that we drop all back-edges from nodes with very * high in-degree, and simply add them add them to a list of such * nodes. They are then treated as permanent roots. Id this by itself * doesn't introduce a space leak, then such nodes can't contribute to * a growing space leak. */ #ifdef MAKE_BACK_GRAPH #define MAX_IN 10 /* Maximum in-degree we handle directly */ /* #include */ #if !defined(DBG_HDRS_ALL) || (ALIGNMENT != CPP_WORDSZ/8) /* || !defined(UNIX_LIKE) */ # error The configuration does not support MAKE_BACK_GRAPH #endif /* We store single back pointers directly in the object's oh_bg_ptr field. */ /* If there is more than one ptr to an object, we store q | FLAG_MANY, */ /* where q is a pointer to a back_edges object. */ /* Every once in a while we use a back_edges object even for a single */ /* pointer, since we need the other fields in the back_edges structure to */ /* be present in some fraction of the objects. Otherwise we get serious */ /* performance issues. */ #define FLAG_MANY 2 typedef struct back_edges_struct { word n_edges; /* Number of edges, including those in continuation */ /* structures. */ unsigned short flags; # define RETAIN 1 /* Directly points to a reachable object; */ /* retain for next GC. */ unsigned short height_gc_no; /* If height > 0, then the GC_gc_no value when it */ /* was computed. If it was computed this cycle, then */ /* it is current. If it was computed during the */ /* last cycle, then it represents the old height, */ /* which is only saved for live objects referenced by */ /* dead ones. This may grow due to refs from newly */ /* dead objects. */ signed_word height; /* Longest path through unreachable nodes to this node */ /* that we found using depth first search. */ # define HEIGHT_UNKNOWN ((signed_word)(-2)) # define HEIGHT_IN_PROGRESS ((signed_word)(-1)) ptr_t edges[MAX_IN]; struct back_edges_struct *cont; /* Pointer to continuation structure; we use only the */ /* edges field in the continuation. */ /* also used as free list link. */ } back_edges; /* Allocate a new back edge structure. Should be more sophisticated */ /* if this were production code. */ #define MAX_BACK_EDGE_STRUCTS 100000 static back_edges *back_edge_space = 0; STATIC int GC_n_back_edge_structs = 0; /* Serves as pointer to never used */ /* back_edges space. */ static back_edges *avail_back_edges = 0; /* Pointer to free list of deallocated */ /* back_edges structures. */ static back_edges * new_back_edges(void) { if (0 == back_edge_space) { back_edge_space = (back_edges *)GET_MEM( ROUNDUP_PAGESIZE_IF_MMAP(MAX_BACK_EDGE_STRUCTS * sizeof(back_edges))); if (NULL == back_edge_space) ABORT("Insufficient memory for back edges"); GC_add_to_our_memory((ptr_t)back_edge_space, MAX_BACK_EDGE_STRUCTS*sizeof(back_edges)); } if (0 != avail_back_edges) { back_edges * result = avail_back_edges; avail_back_edges = result -> cont; result -> cont = 0; return result; } if (GC_n_back_edge_structs >= MAX_BACK_EDGE_STRUCTS - 1) { ABORT("Needed too much space for back edges: adjust " "MAX_BACK_EDGE_STRUCTS"); } return back_edge_space + (GC_n_back_edge_structs++); } /* Deallocate p and its associated continuation structures. */ static void deallocate_back_edges(back_edges *p) { back_edges *last = p; while (0 != last -> cont) last = last -> cont; last -> cont = avail_back_edges; avail_back_edges = p; } /* Table of objects that are currently on the depth-first search */ /* stack. Only objects with in-degree one are in this table. */ /* Other objects are identified using HEIGHT_IN_PROGRESS. */ /* FIXME: This data structure NEEDS IMPROVEMENT. */ #define INITIAL_IN_PROGRESS 10000 static ptr_t * in_progress_space = 0; static size_t in_progress_size = 0; static size_t n_in_progress = 0; static void push_in_progress(ptr_t p) { if (n_in_progress >= in_progress_size) { if (in_progress_size == 0) { in_progress_size = ROUNDUP_PAGESIZE_IF_MMAP(INITIAL_IN_PROGRESS * sizeof(ptr_t)) / sizeof(ptr_t); in_progress_space = (ptr_t *)GET_MEM(in_progress_size * sizeof(ptr_t)); GC_add_to_our_memory((ptr_t)in_progress_space, in_progress_size * sizeof(ptr_t)); } else { ptr_t * new_in_progress_space; in_progress_size *= 2; new_in_progress_space = (ptr_t *) GET_MEM(in_progress_size * sizeof(ptr_t)); GC_add_to_our_memory((ptr_t)new_in_progress_space, in_progress_size * sizeof(ptr_t)); if (new_in_progress_space != NULL) BCOPY(in_progress_space, new_in_progress_space, n_in_progress * sizeof(ptr_t)); in_progress_space = new_in_progress_space; /* FIXME: This just drops the old space. */ } } if (in_progress_space == 0) ABORT("MAKE_BACK_GRAPH: Out of in-progress space: " "Huge linear data structure?"); in_progress_space[n_in_progress++] = p; } static GC_bool is_in_progress(ptr_t p) { size_t i; for (i = 0; i < n_in_progress; ++i) { if (in_progress_space[i] == p) return TRUE; } return FALSE; } GC_INLINE void pop_in_progress(ptr_t p GC_ATTR_UNUSED) { --n_in_progress; GC_ASSERT(in_progress_space[n_in_progress] == p); } #define GET_OH_BG_PTR(p) \ (ptr_t)GC_REVEAL_POINTER(((oh *)(p)) -> oh_bg_ptr) #define SET_OH_BG_PTR(p,q) (((oh *)(p)) -> oh_bg_ptr = GC_HIDE_POINTER(q)) /* Execute s once for each predecessor q of p in the points-to graph. */ /* s should be a bracketed statement. We declare q. */ #define FOR_EACH_PRED(q, p, s) \ do { \ ptr_t q = GET_OH_BG_PTR(p); \ if (!((word)q & FLAG_MANY)) { \ if (q && !((word)q & 1)) s \ /* !((word)q & 1) checks for a misinterpreted freelist link */ \ } else { \ back_edges *orig_be_ = (back_edges *)((word)q & ~FLAG_MANY); \ back_edges *be_ = orig_be_; \ int local_; \ word total_; \ word n_edges_ = be_ -> n_edges; \ for (total_ = 0, local_ = 0; total_ < n_edges_; ++local_, ++total_) { \ if (local_ == MAX_IN) { \ be_ = be_ -> cont; \ local_ = 0; \ } \ q = be_ -> edges[local_]; s \ } \ } \ } while (0) /* Ensure that p has a back_edges structure associated with it. */ static void ensure_struct(ptr_t p) { ptr_t old_back_ptr = GET_OH_BG_PTR(p); if (!((word)old_back_ptr & FLAG_MANY)) { back_edges *be = new_back_edges(); be -> flags = 0; if (0 == old_back_ptr) { be -> n_edges = 0; } else { be -> n_edges = 1; be -> edges[0] = old_back_ptr; } be -> height = HEIGHT_UNKNOWN; be -> height_gc_no = (unsigned short)(GC_gc_no - 1); GC_ASSERT((word)be >= (word)back_edge_space); SET_OH_BG_PTR(p, (word)be | FLAG_MANY); } } /* Add the (forward) edge from p to q to the backward graph. Both p */ /* q are pointers to the object base, i.e. pointers to an oh. */ static void add_edge(ptr_t p, ptr_t q) { ptr_t old_back_ptr = GET_OH_BG_PTR(q); back_edges * be, *be_cont; word i; static unsigned random_number = 13; # define GOT_LUCKY_NUMBER (((++random_number) & 0x7f) == 0) /* A not very random number we use to occasionally allocate a */ /* back_edges structure even for a single backward edge. This */ /* prevents us from repeatedly tracing back through very long */ /* chains, since we will have some place to store height and */ /* in_progress flags along the way. */ GC_ASSERT(p == GC_base(p) && q == GC_base(q)); if (!GC_HAS_DEBUG_INFO(q) || !GC_HAS_DEBUG_INFO(p)) { /* This is really a misinterpreted free list link, since we saw */ /* a pointer to a free list. Don't overwrite it! */ return; } if (0 == old_back_ptr) { SET_OH_BG_PTR(q, p); if (GOT_LUCKY_NUMBER) ensure_struct(q); return; } /* Check whether it was already in the list of predecessors. */ FOR_EACH_PRED(pred, q, { if (p == pred) return; }); ensure_struct(q); old_back_ptr = GET_OH_BG_PTR(q); be = (back_edges *)((word)old_back_ptr & ~FLAG_MANY); for (i = be -> n_edges, be_cont = be; i > MAX_IN; i -= MAX_IN) be_cont = be_cont -> cont; if (i == MAX_IN) { be_cont -> cont = new_back_edges(); be_cont = be_cont -> cont; i = 0; } be_cont -> edges[i] = p; be -> n_edges++; # ifdef DEBUG_PRINT_BIG_N_EDGES if (GC_print_stats == VERBOSE && be -> n_edges == 100) { GC_err_printf("The following object has big in-degree:\n"); GC_print_heap_obj(q); } # endif } typedef void (*per_object_func)(ptr_t p, size_t n_bytes, word gc_descr); static void per_object_helper(struct hblk *h, word fn) { hdr * hhdr = HDR(h); size_t sz = hhdr -> hb_sz; word descr = hhdr -> hb_descr; per_object_func f = (per_object_func)fn; int i = 0; do { f((ptr_t)(h -> hb_body + i), sz, descr); i += (int)sz; } while ((word)i + sz <= BYTES_TO_WORDS(HBLKSIZE)); } GC_INLINE void GC_apply_to_each_object(per_object_func f) { GC_apply_to_all_blocks(per_object_helper, (word)f); } static void reset_back_edge(ptr_t p, size_t n_bytes GC_ATTR_UNUSED, word gc_descr GC_ATTR_UNUSED) { /* Skip any free list links, or dropped blocks */ if (GC_HAS_DEBUG_INFO(p)) { ptr_t old_back_ptr = GET_OH_BG_PTR(p); if ((word)old_back_ptr & FLAG_MANY) { back_edges *be = (back_edges *)((word)old_back_ptr & ~FLAG_MANY); if (!(be -> flags & RETAIN)) { deallocate_back_edges(be); SET_OH_BG_PTR(p, 0); } else { GC_ASSERT(GC_is_marked(p)); /* Back edges may point to objects that will not be retained. */ /* Delete them for now, but remember the height. */ /* Some will be added back at next GC. */ be -> n_edges = 0; if (0 != be -> cont) { deallocate_back_edges(be -> cont); be -> cont = 0; } GC_ASSERT(GC_is_marked(p)); /* We only retain things for one GC cycle at a time. */ be -> flags &= ~RETAIN; } } else /* Simple back pointer */ { /* Clear to avoid dangling pointer. */ SET_OH_BG_PTR(p, 0); } } } static void add_back_edges(ptr_t p, size_t n_bytes, word gc_descr) { word *currentp = (word *)(p + sizeof(oh)); /* For now, fix up non-length descriptors conservatively. */ if((gc_descr & GC_DS_TAGS) != GC_DS_LENGTH) { gc_descr = n_bytes; } while ((word)currentp < (word)(p + gc_descr)) { word current = *currentp++; FIXUP_POINTER(current); if (current >= (word)GC_least_plausible_heap_addr && current <= (word)GC_greatest_plausible_heap_addr) { ptr_t target = GC_base((void *)current); if (0 != target) { add_edge(p, target); } } } } /* Rebuild the representation of the backward reachability graph. */ /* Does not examine mark bits. Can be called before GC. */ GC_INNER void GC_build_back_graph(void) { GC_apply_to_each_object(add_back_edges); } /* Return an approximation to the length of the longest simple path */ /* through unreachable objects to p. We refer to this as the height */ /* of p. */ static word backwards_height(ptr_t p) { word result; ptr_t back_ptr = GET_OH_BG_PTR(p); back_edges *be; if (0 == back_ptr) return 1; if (!((word)back_ptr & FLAG_MANY)) { if (is_in_progress(p)) return 0; /* DFS back edge, i.e. we followed */ /* an edge to an object already */ /* on our stack: ignore */ push_in_progress(p); result = backwards_height(back_ptr)+1; pop_in_progress(p); return result; } be = (back_edges *)((word)back_ptr & ~FLAG_MANY); if (be -> height >= 0 && be -> height_gc_no == (unsigned short)GC_gc_no) return be -> height; /* Ignore back edges in DFS */ if (be -> height == HEIGHT_IN_PROGRESS) return 0; result = (be -> height > 0? be -> height : 1); be -> height = HEIGHT_IN_PROGRESS; FOR_EACH_PRED(q, p, { word this_height; if (GC_is_marked(q) && !(FLAG_MANY & (word)GET_OH_BG_PTR(p))) { GC_COND_LOG_PRINTF("Found bogus pointer from %p to %p\n", q, p); /* Reachable object "points to" unreachable one. */ /* Could be caused by our lax treatment of GC descriptors. */ this_height = 1; } else { this_height = backwards_height(q); } if (this_height >= result) result = this_height + 1; }); be -> height = result; be -> height_gc_no = (unsigned short)GC_gc_no; return result; } STATIC word GC_max_height = 0; STATIC ptr_t GC_deepest_obj = NULL; /* Compute the maximum height of every unreachable predecessor p of a */ /* reachable object. Arrange to save the heights of all such objects p */ /* so that they can be used in calculating the height of objects in the */ /* next GC. */ /* Set GC_max_height to be the maximum height we encounter, and */ /* GC_deepest_obj to be the corresponding object. */ static void update_max_height(ptr_t p, size_t n_bytes GC_ATTR_UNUSED, word gc_descr GC_ATTR_UNUSED) { if (GC_is_marked(p) && GC_HAS_DEBUG_INFO(p)) { word p_height = 0; ptr_t p_deepest_obj = 0; ptr_t back_ptr; back_edges *be = 0; /* If we remembered a height last time, use it as a minimum. */ /* It may have increased due to newly unreachable chains pointing */ /* to p, but it can't have decreased. */ back_ptr = GET_OH_BG_PTR(p); if (0 != back_ptr && ((word)back_ptr & FLAG_MANY)) { be = (back_edges *)((word)back_ptr & ~FLAG_MANY); if (be -> height != HEIGHT_UNKNOWN) p_height = be -> height; } FOR_EACH_PRED(q, p, { if (!GC_is_marked(q) && GC_HAS_DEBUG_INFO(q)) { word q_height; q_height = backwards_height(q); if (q_height > p_height) { p_height = q_height; p_deepest_obj = q; } } }); if (p_height > 0) { /* Remember the height for next time. */ if (be == 0) { ensure_struct(p); back_ptr = GET_OH_BG_PTR(p); be = (back_edges *)((word)back_ptr & ~FLAG_MANY); } be -> flags |= RETAIN; be -> height = p_height; be -> height_gc_no = (unsigned short)GC_gc_no; } if (p_height > GC_max_height) { GC_max_height = p_height; GC_deepest_obj = p_deepest_obj; } } } STATIC word GC_max_max_height = 0; GC_INNER void GC_traverse_back_graph(void) { GC_max_height = 0; GC_apply_to_each_object(update_max_height); if (0 != GC_deepest_obj) GC_set_mark_bit(GC_deepest_obj); /* Keep it until we can print it. */ } void GC_print_back_graph_stats(void) { GC_printf("Maximum backwards height of reachable objects at GC %lu is %lu\n", (unsigned long) GC_gc_no, (unsigned long)GC_max_height); if (GC_max_height > GC_max_max_height) { GC_max_max_height = GC_max_height; GC_err_printf( "The following unreachable object is last in a longest chain " "of unreachable objects:\n"); GC_print_heap_obj(GC_deepest_obj); } GC_COND_LOG_PRINTF("Needed max total of %d back-edge structs\n", GC_n_back_edge_structs); GC_apply_to_each_object(reset_back_edge); GC_deepest_obj = 0; } #endif /* MAKE_BACK_GRAPH */ ecl-16.1.2/src/bdwgc/bdw-gc.pc.in000066400000000000000000000004051266352375300163300ustar00rootroot00000000000000prefix=@prefix@ exec_prefix=@exec_prefix@ libdir=@libdir@ includedir=@includedir@ Name: Boehm-Demers-Weiser Conservative Garbage Collector Description: A garbage collector for C and C++ Version: @PACKAGE_VERSION@ Libs: -L${libdir} -lgc Cflags: -I${includedir} ecl-16.1.2/src/bdwgc/blacklst.c000066400000000000000000000240351266352375300162040ustar00rootroot00000000000000/* * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. */ #include "private/gc_priv.h" /* * We maintain several hash tables of hblks that have had false hits. * Each contains one bit per hash bucket; If any page in the bucket * has had a false hit, we assume that all of them have. * See the definition of page_hash_table in gc_private.h. * False hits from the stack(s) are much more dangerous than false hits * from elsewhere, since the former can pin a large object that spans the * block, even though it does not start on the dangerous block. */ /* * Externally callable routines are: * GC_add_to_black_list_normal * GC_add_to_black_list_stack * GC_promote_black_lists * GC_is_black_listed * * All require that the allocator lock is held. */ /* Pointers to individual tables. We replace one table by another by */ /* switching these pointers. */ STATIC word * GC_old_normal_bl = NULL; /* Nonstack false references seen at last full */ /* collection. */ STATIC word * GC_incomplete_normal_bl = NULL; /* Nonstack false references seen since last */ /* full collection. */ STATIC word * GC_old_stack_bl = NULL; STATIC word * GC_incomplete_stack_bl = NULL; STATIC word GC_total_stack_black_listed = 0; /* Number of bytes on stack blacklist. */ GC_INNER word GC_black_list_spacing = MINHINCR * HBLKSIZE; /* Initial rough guess. */ STATIC void GC_clear_bl(word *); GC_INNER void GC_default_print_heap_obj_proc(ptr_t p) { ptr_t base = GC_base(p); int kind = HDR(base)->hb_obj_kind; GC_err_printf("object at %p of appr. %lu bytes (%s)\n", base, (unsigned long)GC_size(base), kind == PTRFREE ? "atomic" : IS_UNCOLLECTABLE(kind) ? "uncollectable" : "composite"); } GC_INNER void (*GC_print_heap_obj)(ptr_t p) = GC_default_print_heap_obj_proc; #ifdef PRINT_BLACK_LIST STATIC void GC_print_blacklisted_ptr(word p, ptr_t source, const char *kind_str) { ptr_t base = GC_base(source); if (0 == base) { GC_err_printf("Black listing (%s) %p referenced from %p in %s\n", kind_str, (ptr_t)p, source, NULL != source ? "root set" : "register"); } else { /* FIXME: We can't call the debug version of GC_print_heap_obj */ /* (with PRINT_CALL_CHAIN) here because the lock is held and */ /* the world is stopped. */ GC_err_printf("Black listing (%s) %p referenced from %p in" " object at %p of appr. %lu bytes\n", kind_str, (ptr_t)p, source, base, (unsigned long)GC_size(base)); } } #endif /* PRINT_BLACK_LIST */ GC_INNER void GC_bl_init_no_interiors(void) { if (GC_incomplete_normal_bl == 0) { GC_old_normal_bl = (word *)GC_scratch_alloc(sizeof(page_hash_table)); GC_incomplete_normal_bl = (word *)GC_scratch_alloc( sizeof(page_hash_table)); if (GC_old_normal_bl == 0 || GC_incomplete_normal_bl == 0) { GC_err_printf("Insufficient memory for black list\n"); EXIT(); } GC_clear_bl(GC_old_normal_bl); GC_clear_bl(GC_incomplete_normal_bl); } } GC_INNER void GC_bl_init(void) { if (!GC_all_interior_pointers) { GC_bl_init_no_interiors(); } GC_old_stack_bl = (word *)GC_scratch_alloc(sizeof(page_hash_table)); GC_incomplete_stack_bl = (word *)GC_scratch_alloc(sizeof(page_hash_table)); if (GC_old_stack_bl == 0 || GC_incomplete_stack_bl == 0) { GC_err_printf("Insufficient memory for black list\n"); EXIT(); } GC_clear_bl(GC_old_stack_bl); GC_clear_bl(GC_incomplete_stack_bl); } STATIC void GC_clear_bl(word *doomed) { BZERO(doomed, sizeof(page_hash_table)); } STATIC void GC_copy_bl(word *old, word *new) { BCOPY(old, new, sizeof(page_hash_table)); } static word total_stack_black_listed(void); /* Signal the completion of a collection. Turn the incomplete black */ /* lists into new black lists, etc. */ GC_INNER void GC_promote_black_lists(void) { word * very_old_normal_bl = GC_old_normal_bl; word * very_old_stack_bl = GC_old_stack_bl; GC_old_normal_bl = GC_incomplete_normal_bl; GC_old_stack_bl = GC_incomplete_stack_bl; if (!GC_all_interior_pointers) { GC_clear_bl(very_old_normal_bl); } GC_clear_bl(very_old_stack_bl); GC_incomplete_normal_bl = very_old_normal_bl; GC_incomplete_stack_bl = very_old_stack_bl; GC_total_stack_black_listed = total_stack_black_listed(); GC_VERBOSE_LOG_PRINTF( "%lu bytes in heap blacklisted for interior pointers\n", (unsigned long)GC_total_stack_black_listed); if (GC_total_stack_black_listed != 0) { GC_black_list_spacing = HBLKSIZE*(GC_heapsize/GC_total_stack_black_listed); } if (GC_black_list_spacing < 3 * HBLKSIZE) { GC_black_list_spacing = 3 * HBLKSIZE; } if (GC_black_list_spacing > MAXHINCR * HBLKSIZE) { GC_black_list_spacing = MAXHINCR * HBLKSIZE; /* Makes it easier to allocate really huge blocks, which otherwise */ /* may have problems with nonuniform blacklist distributions. */ /* This way we should always succeed immediately after growing the */ /* heap. */ } } GC_INNER void GC_unpromote_black_lists(void) { if (!GC_all_interior_pointers) { GC_copy_bl(GC_old_normal_bl, GC_incomplete_normal_bl); } GC_copy_bl(GC_old_stack_bl, GC_incomplete_stack_bl); } /* P is not a valid pointer reference, but it falls inside */ /* the plausible heap bounds. */ /* Add it to the normal incomplete black list if appropriate. */ #ifdef PRINT_BLACK_LIST GC_INNER void GC_add_to_black_list_normal(word p, ptr_t source) #else GC_INNER void GC_add_to_black_list_normal(word p) #endif { if (GC_modws_valid_offsets[p & (sizeof(word)-1)]) { word index = PHT_HASH((word)p); if (HDR(p) == 0 || get_pht_entry_from_index(GC_old_normal_bl, index)) { # ifdef PRINT_BLACK_LIST if (!get_pht_entry_from_index(GC_incomplete_normal_bl, index)) { GC_print_blacklisted_ptr(p, source, "normal"); } # endif set_pht_entry_from_index(GC_incomplete_normal_bl, index); } /* else this is probably just an interior pointer to an allocated */ /* object, and isn't worth black listing. */ } } /* And the same for false pointers from the stack. */ #ifdef PRINT_BLACK_LIST GC_INNER void GC_add_to_black_list_stack(word p, ptr_t source) #else GC_INNER void GC_add_to_black_list_stack(word p) #endif { word index = PHT_HASH((word)p); if (HDR(p) == 0 || get_pht_entry_from_index(GC_old_stack_bl, index)) { # ifdef PRINT_BLACK_LIST if (!get_pht_entry_from_index(GC_incomplete_stack_bl, index)) { GC_print_blacklisted_ptr(p, source, "stack"); } # endif set_pht_entry_from_index(GC_incomplete_stack_bl, index); } } /* * Is the block starting at h of size len bytes black listed? If so, * return the address of the next plausible r such that (r, len) might not * be black listed. (R may not actually be in the heap. We guarantee only * that every smaller value of r after h is also black listed.) * If (h,len) is not black listed, return 0. * Knows about the structure of the black list hash tables. */ struct hblk * GC_is_black_listed(struct hblk *h, word len) { word index = PHT_HASH((word)h); word i; word nblocks; if (!GC_all_interior_pointers && (get_pht_entry_from_index(GC_old_normal_bl, index) || get_pht_entry_from_index(GC_incomplete_normal_bl, index))) { return (h+1); } nblocks = divHBLKSZ(len); for (i = 0;;) { if (GC_old_stack_bl[divWORDSZ(index)] == 0 && GC_incomplete_stack_bl[divWORDSZ(index)] == 0) { /* An easy case */ i += WORDSZ - modWORDSZ(index); } else { if (get_pht_entry_from_index(GC_old_stack_bl, index) || get_pht_entry_from_index(GC_incomplete_stack_bl, index)) { return(h+i+1); } i++; } if (i >= nblocks) break; index = PHT_HASH((word)(h+i)); } return(0); } /* Return the number of blacklisted blocks in a given range. */ /* Used only for statistical purposes. */ /* Looks only at the GC_incomplete_stack_bl. */ STATIC word GC_number_stack_black_listed(struct hblk *start, struct hblk *endp1) { register struct hblk * h; word result = 0; for (h = start; (word)h < (word)endp1; h++) { word index = PHT_HASH((word)h); if (get_pht_entry_from_index(GC_old_stack_bl, index)) result++; } return(result); } /* Return the total number of (stack) black-listed bytes. */ static word total_stack_black_listed(void) { register unsigned i; word total = 0; for (i = 0; i < GC_n_heap_sects; i++) { struct hblk * start = (struct hblk *) GC_heap_sects[i].hs_start; struct hblk * endp1 = start + GC_heap_sects[i].hs_bytes/HBLKSIZE; total += GC_number_stack_black_listed(start, endp1); } return(total * HBLKSIZE); } ecl-16.1.2/src/bdwgc/checksums.c000066400000000000000000000151441266352375300163730ustar00rootroot00000000000000/* * Copyright (c) 1992-1994 by Xerox Corporation. All rights reserved. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. */ #include "private/gc_priv.h" #ifdef CHECKSUMS /* This is debugging code intended to verify the results of dirty bit */ /* computations. Works only in a single threaded environment. */ /* We assume that stubborn objects are changed only when they are */ /* enabled for writing. (Certain kinds of writing are actually */ /* safe under other conditions.) */ #define NSUMS 10000 #define OFFSET 0x10000 typedef struct { GC_bool new_valid; word old_sum; word new_sum; struct hblk * block; /* Block to which this refers + OFFSET */ /* to hide it from collector. */ } page_entry; page_entry GC_sums[NSUMS]; STATIC word GC_faulted[NSUMS] = { 0 }; /* Record of pages on which we saw a write fault. */ STATIC size_t GC_n_faulted = 0; void GC_record_fault(struct hblk * h) { word page = ROUNDUP_PAGESIZE((word)h); if (GC_n_faulted >= NSUMS) ABORT("write fault log overflowed"); GC_faulted[GC_n_faulted++] = page; } STATIC GC_bool GC_was_faulted(struct hblk *h) { size_t i; word page = ROUNDUP_PAGESIZE((word)h); for (i = 0; i < GC_n_faulted; ++i) { if (GC_faulted[i] == page) return TRUE; } return FALSE; } STATIC word GC_checksum(struct hblk *h) { word *p = (word *)h; word *lim = (word *)(h+1); word result = 0; while ((word)p < (word)lim) { result += *p++; } return(result | 0x80000000 /* doesn't look like pointer */); } #ifdef STUBBORN_ALLOC /* Check whether a stubborn object from the given block appears on */ /* the appropriate free list. */ STATIC GC_bool GC_on_free_list(struct hblk *h) { hdr * hhdr = HDR(h); size_t sz = BYTES_TO_WORDS(hhdr -> hb_sz); ptr_t p; if (sz > MAXOBJWORDS) return(FALSE); for (p = GC_sobjfreelist[sz]; p != 0; p = obj_link(p)) { if (HBLKPTR(p) == h) return(TRUE); } return(FALSE); } #endif int GC_n_dirty_errors = 0; int GC_n_faulted_dirty_errors = 0; int GC_n_changed_errors = 0; int GC_n_clean = 0; int GC_n_dirty = 0; STATIC void GC_update_check_page(struct hblk *h, int index) { page_entry *pe = GC_sums + index; hdr * hhdr = HDR(h); struct hblk *b; if (pe -> block != 0 && pe -> block != h + OFFSET) ABORT("goofed"); pe -> old_sum = pe -> new_sum; pe -> new_sum = GC_checksum(h); # if !defined(MSWIN32) && !defined(MSWINCE) if (pe -> new_sum != 0x80000000 && !GC_page_was_ever_dirty(h)) { GC_err_printf("GC_page_was_ever_dirty(%p) is wrong\n", (void *)h); } # endif if (GC_page_was_dirty(h)) { GC_n_dirty++; } else { GC_n_clean++; } b = h; while (IS_FORWARDING_ADDR_OR_NIL(hhdr) && hhdr != 0) { b -= (word)hhdr; hhdr = HDR(b); } if (pe -> new_valid && hhdr != 0 && hhdr -> hb_descr != 0 /* may contain pointers */ && pe -> old_sum != pe -> new_sum) { if (!GC_page_was_dirty(h) || !GC_page_was_ever_dirty(h)) { GC_bool was_faulted = GC_was_faulted(h); /* Set breakpoint here */GC_n_dirty_errors++; if (was_faulted) GC_n_faulted_dirty_errors++; } # ifdef STUBBORN_ALLOC if (!HBLK_IS_FREE(hhdr) && hhdr -> hb_obj_kind == STUBBORN && !GC_page_was_changed(h) && !GC_on_free_list(h)) { /* if GC_on_free_list(h) then reclaim may have touched it */ /* without any allocations taking place. */ /* Set breakpoint here */GC_n_changed_errors++; } # endif } pe -> new_valid = TRUE; pe -> block = h + OFFSET; } word GC_bytes_in_used_blocks = 0; STATIC void GC_add_block(struct hblk *h, word dummy GC_ATTR_UNUSED) { hdr * hhdr = HDR(h); size_t bytes = hhdr -> hb_sz; bytes += HBLKSIZE-1; bytes &= ~(HBLKSIZE-1); GC_bytes_in_used_blocks += bytes; } STATIC void GC_check_blocks(void) { word bytes_in_free_blocks = GC_large_free_bytes; GC_bytes_in_used_blocks = 0; GC_apply_to_all_blocks(GC_add_block, (word)0); GC_COND_LOG_PRINTF("GC_bytes_in_used_blocks = %lu," " bytes_in_free_blocks = %lu, heapsize = %lu\n", (unsigned long)GC_bytes_in_used_blocks, (unsigned long)bytes_in_free_blocks, (unsigned long)GC_heapsize); if (GC_bytes_in_used_blocks + bytes_in_free_blocks != GC_heapsize) { GC_err_printf("LOST SOME BLOCKS!!\n"); } } /* Should be called immediately after GC_read_dirty and GC_read_changed. */ void GC_check_dirty(void) { int index; unsigned i; struct hblk *h; ptr_t start; GC_check_blocks(); GC_n_dirty_errors = 0; GC_n_faulted_dirty_errors = 0; GC_n_changed_errors = 0; GC_n_clean = 0; GC_n_dirty = 0; index = 0; for (i = 0; i < GC_n_heap_sects; i++) { start = GC_heap_sects[i].hs_start; for (h = (struct hblk *)start; (word)h < (word)(start + GC_heap_sects[i].hs_bytes); h++) { GC_update_check_page(h, index); index++; if (index >= NSUMS) goto out; } } out: GC_COND_LOG_PRINTF("Checked %lu clean and %lu dirty pages\n", (unsigned long)GC_n_clean, (unsigned long)GC_n_dirty); if (GC_n_dirty_errors > 0) { GC_err_printf("Found %d dirty bit errors (%d were faulted)\n", GC_n_dirty_errors, GC_n_faulted_dirty_errors); } if (GC_n_changed_errors > 0) { GC_err_printf("Found %lu changed bit errors\n", (unsigned long)GC_n_changed_errors); GC_err_printf( "These may be benign (provoked by nonpointer changes)\n"); # ifdef THREADS GC_err_printf( "Also expect 1 per thread currently allocating a stubborn obj\n"); # endif } for (i = 0; i < GC_n_faulted; ++i) { GC_faulted[i] = 0; /* Don't expose block pointers to GC */ } GC_n_faulted = 0; } #endif /* CHECKSUMS */ ecl-16.1.2/src/bdwgc/compile000077500000000000000000000162451266352375300156230ustar00rootroot00000000000000#! /bin/sh # Wrapper for compilers which do not understand '-c -o'. scriptversion=2012-10-14.11; # UTC # Copyright (C) 1999-2014 Free Software Foundation, Inc. # Written by Tom Tromey . # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2, or (at your option) # any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . # As a special exception to the GNU General Public License, if you # distribute this file as part of a program that contains a # configuration script generated by Autoconf, you may include it under # the same distribution terms that you use for the rest of that program. # This file is maintained in Automake, please report # bugs to or send patches to # . nl=' ' # We need space, tab and new line, in precisely that order. Quoting is # there to prevent tools from complaining about whitespace usage. IFS=" "" $nl" file_conv= # func_file_conv build_file lazy # Convert a $build file to $host form and store it in $file # Currently only supports Windows hosts. If the determined conversion # type is listed in (the comma separated) LAZY, no conversion will # take place. func_file_conv () { file=$1 case $file in / | /[!/]*) # absolute file, and not a UNC file if test -z "$file_conv"; then # lazily determine how to convert abs files case `uname -s` in MINGW*) file_conv=mingw ;; CYGWIN*) file_conv=cygwin ;; *) file_conv=wine ;; esac fi case $file_conv/,$2, in *,$file_conv,*) ;; mingw/*) file=`cmd //C echo "$file " | sed -e 's/"\(.*\) " *$/\1/'` ;; cygwin/*) file=`cygpath -m "$file" || echo "$file"` ;; wine/*) file=`winepath -w "$file" || echo "$file"` ;; esac ;; esac } # func_cl_dashL linkdir # Make cl look for libraries in LINKDIR func_cl_dashL () { func_file_conv "$1" if test -z "$lib_path"; then lib_path=$file else lib_path="$lib_path;$file" fi linker_opts="$linker_opts -LIBPATH:$file" } # func_cl_dashl library # Do a library search-path lookup for cl func_cl_dashl () { lib=$1 found=no save_IFS=$IFS IFS=';' for dir in $lib_path $LIB do IFS=$save_IFS if $shared && test -f "$dir/$lib.dll.lib"; then found=yes lib=$dir/$lib.dll.lib break fi if test -f "$dir/$lib.lib"; then found=yes lib=$dir/$lib.lib break fi if test -f "$dir/lib$lib.a"; then found=yes lib=$dir/lib$lib.a break fi done IFS=$save_IFS if test "$found" != yes; then lib=$lib.lib fi } # func_cl_wrapper cl arg... # Adjust compile command to suit cl func_cl_wrapper () { # Assume a capable shell lib_path= shared=: linker_opts= for arg do if test -n "$eat"; then eat= else case $1 in -o) # configure might choose to run compile as 'compile cc -o foo foo.c'. eat=1 case $2 in *.o | *.[oO][bB][jJ]) func_file_conv "$2" set x "$@" -Fo"$file" shift ;; *) func_file_conv "$2" set x "$@" -Fe"$file" shift ;; esac ;; -I) eat=1 func_file_conv "$2" mingw set x "$@" -I"$file" shift ;; -I*) func_file_conv "${1#-I}" mingw set x "$@" -I"$file" shift ;; -l) eat=1 func_cl_dashl "$2" set x "$@" "$lib" shift ;; -l*) func_cl_dashl "${1#-l}" set x "$@" "$lib" shift ;; -L) eat=1 func_cl_dashL "$2" ;; -L*) func_cl_dashL "${1#-L}" ;; -static) shared=false ;; -Wl,*) arg=${1#-Wl,} save_ifs="$IFS"; IFS=',' for flag in $arg; do IFS="$save_ifs" linker_opts="$linker_opts $flag" done IFS="$save_ifs" ;; -Xlinker) eat=1 linker_opts="$linker_opts $2" ;; -*) set x "$@" "$1" shift ;; *.cc | *.CC | *.cxx | *.CXX | *.[cC]++) func_file_conv "$1" set x "$@" -Tp"$file" shift ;; *.c | *.cpp | *.CPP | *.lib | *.LIB | *.Lib | *.OBJ | *.obj | *.[oO]) func_file_conv "$1" mingw set x "$@" "$file" shift ;; *) set x "$@" "$1" shift ;; esac fi shift done if test -n "$linker_opts"; then linker_opts="-link$linker_opts" fi exec "$@" $linker_opts exit 1 } eat= case $1 in '') echo "$0: No command. Try '$0 --help' for more information." 1>&2 exit 1; ;; -h | --h*) cat <<\EOF Usage: compile [--help] [--version] PROGRAM [ARGS] Wrapper for compilers which do not understand '-c -o'. Remove '-o dest.o' from ARGS, run PROGRAM with the remaining arguments, and rename the output as expected. If you are trying to build a whole package this is not the right script to run: please start by reading the file 'INSTALL'. Report bugs to . EOF exit $? ;; -v | --v*) echo "compile $scriptversion" exit $? ;; cl | *[/\\]cl | cl.exe | *[/\\]cl.exe ) func_cl_wrapper "$@" # Doesn't return... ;; esac ofile= cfile= for arg do if test -n "$eat"; then eat= else case $1 in -o) # configure might choose to run compile as 'compile cc -o foo foo.c'. # So we strip '-o arg' only if arg is an object. eat=1 case $2 in *.o | *.obj) ofile=$2 ;; *) set x "$@" -o "$2" shift ;; esac ;; *.c) cfile=$1 set x "$@" "$1" shift ;; *) set x "$@" "$1" shift ;; esac fi shift done if test -z "$ofile" || test -z "$cfile"; then # If no '-o' option was seen then we might have been invoked from a # pattern rule where we don't need one. That is ok -- this is a # normal compilation that the losing compiler can handle. If no # '.c' file was seen then we are probably linking. That is also # ok. exec "$@" fi # Name of file we expect compiler to create. cofile=`echo "$cfile" | sed 's|^.*[\\/]||; s|^[a-zA-Z]:||; s/\.c$/.o/'` # Create the lock directory. # Note: use '[/\\:.-]' here to ensure that we don't use the same name # that we are using for the .o file. Also, base the name on the expected # object file name, since that is what matters with a parallel build. lockdir=`echo "$cofile" | sed -e 's|[/\\:.-]|_|g'`.d while true; do if mkdir "$lockdir" >/dev/null 2>&1; then break fi sleep 1 done # FIXME: race condition here if user kills between mkdir and trap. trap "rmdir '$lockdir'; exit 1" 1 2 15 # Run the compile. "$@" ret=$? if test -f "$cofile"; then test "$cofile" = "$ofile" || mv "$cofile" "$ofile" elif test -f "${cofile}bj"; then test "${cofile}bj" = "$ofile" || mv "${cofile}bj" "$ofile" fi rmdir "$lockdir" exit $ret # Local Variables: # mode: shell-script # sh-indentation: 2 # eval: (add-hook 'write-file-hooks 'time-stamp) # time-stamp-start: "scriptversion=" # time-stamp-format: "%:y-%02m-%02d.%02H" # time-stamp-time-zone: "UTC" # time-stamp-end: "; # UTC" # End: ecl-16.1.2/src/bdwgc/config.guess000077500000000000000000001236721266352375300165700ustar00rootroot00000000000000#! /bin/sh # Attempt to guess a canonical system name. # Copyright 1992-2014 Free Software Foundation, Inc. timestamp='2014-11-04' # This file is free software; you can redistribute it and/or modify it # under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 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 . # # As a special exception to the GNU General Public License, if you # distribute this file as part of a program that contains a # configuration script generated by Autoconf, you may include it under # the same distribution terms that you use for the rest of that # program. This Exception is an additional permission under section 7 # of the GNU General Public License, version 3 ("GPLv3"). # # Originally written by Per Bothner; maintained since 2000 by Ben Elliston. # # You can get the latest version of this script from: # http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.guess;hb=HEAD # # Please send patches to . me=`echo "$0" | sed -e 's,.*/,,'` usage="\ Usage: $0 [OPTION] Output the configuration name of the system \`$me' is run on. Operation modes: -h, --help print this help, then exit -t, --time-stamp print date of last modification, then exit -v, --version print version number, then exit Report bugs and patches to ." version="\ GNU config.guess ($timestamp) Originally written by Per Bothner. Copyright 1992-2014 Free Software Foundation, Inc. This is free software; see the source for copying conditions. There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE." help=" Try \`$me --help' for more information." # Parse command line while test $# -gt 0 ; do case $1 in --time-stamp | --time* | -t ) echo "$timestamp" ; exit ;; --version | -v ) echo "$version" ; exit ;; --help | --h* | -h ) echo "$usage"; exit ;; -- ) # Stop option processing shift; break ;; - ) # Use stdin as input. break ;; -* ) echo "$me: invalid option $1$help" >&2 exit 1 ;; * ) break ;; esac done if test $# != 0; then echo "$me: too many arguments$help" >&2 exit 1 fi trap 'exit 1' 1 2 15 # CC_FOR_BUILD -- compiler used by this script. Note that the use of a # compiler to aid in system detection is discouraged as it requires # temporary files to be created and, as you can see below, it is a # headache to deal with in a portable fashion. # Historically, `CC_FOR_BUILD' used to be named `HOST_CC'. We still # use `HOST_CC' if defined, but it is deprecated. # Portable tmp directory creation inspired by the Autoconf team. set_cc_for_build=' trap "exitcode=\$?; (rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null) && exit \$exitcode" 0 ; trap "rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null; exit 1" 1 2 13 15 ; : ${TMPDIR=/tmp} ; { tmp=`(umask 077 && mktemp -d "$TMPDIR/cgXXXXXX") 2>/dev/null` && test -n "$tmp" && test -d "$tmp" ; } || { test -n "$RANDOM" && tmp=$TMPDIR/cg$$-$RANDOM && (umask 077 && mkdir $tmp) ; } || { tmp=$TMPDIR/cg-$$ && (umask 077 && mkdir $tmp) && echo "Warning: creating insecure temp directory" >&2 ; } || { echo "$me: cannot create a temporary directory in $TMPDIR" >&2 ; exit 1 ; } ; dummy=$tmp/dummy ; tmpfiles="$dummy.c $dummy.o $dummy.rel $dummy" ; case $CC_FOR_BUILD,$HOST_CC,$CC in ,,) echo "int x;" > $dummy.c ; for c in cc gcc c89 c99 ; do if ($c -c -o $dummy.o $dummy.c) >/dev/null 2>&1 ; then CC_FOR_BUILD="$c"; break ; fi ; done ; if test x"$CC_FOR_BUILD" = x ; then CC_FOR_BUILD=no_compiler_found ; fi ;; ,,*) CC_FOR_BUILD=$CC ;; ,*,*) CC_FOR_BUILD=$HOST_CC ;; esac ; set_cc_for_build= ;' # This is needed to find uname on a Pyramid OSx when run in the BSD universe. # (ghazi@noc.rutgers.edu 1994-08-24) if (test -f /.attbin/uname) >/dev/null 2>&1 ; then PATH=$PATH:/.attbin ; export PATH fi UNAME_MACHINE=`(uname -m) 2>/dev/null` || UNAME_MACHINE=unknown UNAME_RELEASE=`(uname -r) 2>/dev/null` || UNAME_RELEASE=unknown UNAME_SYSTEM=`(uname -s) 2>/dev/null` || UNAME_SYSTEM=unknown UNAME_VERSION=`(uname -v) 2>/dev/null` || UNAME_VERSION=unknown case "${UNAME_SYSTEM}" in Linux|GNU|GNU/*) # If the system lacks a compiler, then just pick glibc. # We could probably try harder. LIBC=gnu eval $set_cc_for_build cat <<-EOF > $dummy.c #include #if defined(__UCLIBC__) LIBC=uclibc #elif defined(__dietlibc__) LIBC=dietlibc #else LIBC=gnu #endif EOF eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep '^LIBC' | sed 's, ,,g'` ;; esac # Note: order is significant - the case branches are not exclusive. case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in *:NetBSD:*:*) # NetBSD (nbsd) targets should (where applicable) match one or # more of the tuples: *-*-netbsdelf*, *-*-netbsdaout*, # *-*-netbsdecoff* and *-*-netbsd*. For targets that recently # switched to ELF, *-*-netbsd* would select the old # object file format. This provides both forward # compatibility and a consistent mechanism for selecting the # object file format. # # Note: NetBSD doesn't particularly care about the vendor # portion of the name. We always set it to "unknown". sysctl="sysctl -n hw.machine_arch" UNAME_MACHINE_ARCH=`(/sbin/$sysctl 2>/dev/null || \ /usr/sbin/$sysctl 2>/dev/null || echo unknown)` case "${UNAME_MACHINE_ARCH}" in armeb) machine=armeb-unknown ;; arm*) machine=arm-unknown ;; sh3el) machine=shl-unknown ;; sh3eb) machine=sh-unknown ;; sh5el) machine=sh5le-unknown ;; *) machine=${UNAME_MACHINE_ARCH}-unknown ;; esac # The Operating System including object format, if it has switched # to ELF recently, or will in the future. case "${UNAME_MACHINE_ARCH}" in arm*|i386|m68k|ns32k|sh3*|sparc|vax) eval $set_cc_for_build if echo __ELF__ | $CC_FOR_BUILD -E - 2>/dev/null \ | grep -q __ELF__ then # Once all utilities can be ECOFF (netbsdecoff) or a.out (netbsdaout). # Return netbsd for either. FIX? os=netbsd else os=netbsdelf fi ;; *) os=netbsd ;; esac # The OS release # Debian GNU/NetBSD machines have a different userland, and # thus, need a distinct triplet. However, they do not need # kernel version information, so it can be replaced with a # suitable tag, in the style of linux-gnu. case "${UNAME_VERSION}" in Debian*) release='-gnu' ;; *) release=`echo ${UNAME_RELEASE}|sed -e 's/[-_].*/\./'` ;; esac # Since CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM: # contains redundant information, the shorter form: # CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM is used. echo "${machine}-${os}${release}" exit ;; *:Bitrig:*:*) UNAME_MACHINE_ARCH=`arch | sed 's/Bitrig.//'` echo ${UNAME_MACHINE_ARCH}-unknown-bitrig${UNAME_RELEASE} exit ;; *:OpenBSD:*:*) UNAME_MACHINE_ARCH=`arch | sed 's/OpenBSD.//'` echo ${UNAME_MACHINE_ARCH}-unknown-openbsd${UNAME_RELEASE} exit ;; *:ekkoBSD:*:*) echo ${UNAME_MACHINE}-unknown-ekkobsd${UNAME_RELEASE} exit ;; *:SolidBSD:*:*) echo ${UNAME_MACHINE}-unknown-solidbsd${UNAME_RELEASE} exit ;; macppc:MirBSD:*:*) echo powerpc-unknown-mirbsd${UNAME_RELEASE} exit ;; *:MirBSD:*:*) echo ${UNAME_MACHINE}-unknown-mirbsd${UNAME_RELEASE} exit ;; alpha:OSF1:*:*) case $UNAME_RELEASE in *4.0) UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $3}'` ;; *5.*) UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $4}'` ;; esac # According to Compaq, /usr/sbin/psrinfo has been available on # OSF/1 and Tru64 systems produced since 1995. I hope that # covers most systems running today. This code pipes the CPU # types through head -n 1, so we only detect the type of CPU 0. ALPHA_CPU_TYPE=`/usr/sbin/psrinfo -v | sed -n -e 's/^ The alpha \(.*\) processor.*$/\1/p' | head -n 1` case "$ALPHA_CPU_TYPE" in "EV4 (21064)") UNAME_MACHINE="alpha" ;; "EV4.5 (21064)") UNAME_MACHINE="alpha" ;; "LCA4 (21066/21068)") UNAME_MACHINE="alpha" ;; "EV5 (21164)") UNAME_MACHINE="alphaev5" ;; "EV5.6 (21164A)") UNAME_MACHINE="alphaev56" ;; "EV5.6 (21164PC)") UNAME_MACHINE="alphapca56" ;; "EV5.7 (21164PC)") UNAME_MACHINE="alphapca57" ;; "EV6 (21264)") UNAME_MACHINE="alphaev6" ;; "EV6.7 (21264A)") UNAME_MACHINE="alphaev67" ;; "EV6.8CB (21264C)") UNAME_MACHINE="alphaev68" ;; "EV6.8AL (21264B)") UNAME_MACHINE="alphaev68" ;; "EV6.8CX (21264D)") UNAME_MACHINE="alphaev68" ;; "EV6.9A (21264/EV69A)") UNAME_MACHINE="alphaev69" ;; "EV7 (21364)") UNAME_MACHINE="alphaev7" ;; "EV7.9 (21364A)") UNAME_MACHINE="alphaev79" ;; esac # A Pn.n version is a patched version. # A Vn.n version is a released version. # A Tn.n version is a released field test version. # A Xn.n version is an unreleased experimental baselevel. # 1.2 uses "1.2" for uname -r. echo ${UNAME_MACHINE}-dec-osf`echo ${UNAME_RELEASE} | sed -e 's/^[PVTX]//' | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` # Reset EXIT trap before exiting to avoid spurious non-zero exit code. exitcode=$? trap '' 0 exit $exitcode ;; Alpha\ *:Windows_NT*:*) # How do we know it's Interix rather than the generic POSIX subsystem? # Should we change UNAME_MACHINE based on the output of uname instead # of the specific Alpha model? echo alpha-pc-interix exit ;; 21064:Windows_NT:50:3) echo alpha-dec-winnt3.5 exit ;; Amiga*:UNIX_System_V:4.0:*) echo m68k-unknown-sysv4 exit ;; *:[Aa]miga[Oo][Ss]:*:*) echo ${UNAME_MACHINE}-unknown-amigaos exit ;; *:[Mm]orph[Oo][Ss]:*:*) echo ${UNAME_MACHINE}-unknown-morphos exit ;; *:OS/390:*:*) echo i370-ibm-openedition exit ;; *:z/VM:*:*) echo s390-ibm-zvmoe exit ;; *:OS400:*:*) echo powerpc-ibm-os400 exit ;; arm:RISC*:1.[012]*:*|arm:riscix:1.[012]*:*) echo arm-acorn-riscix${UNAME_RELEASE} exit ;; arm*:riscos:*:*|arm*:RISCOS:*:*) echo arm-unknown-riscos exit ;; SR2?01:HI-UX/MPP:*:* | SR8000:HI-UX/MPP:*:*) echo hppa1.1-hitachi-hiuxmpp exit ;; Pyramid*:OSx*:*:* | MIS*:OSx*:*:* | MIS*:SMP_DC-OSx*:*:*) # akee@wpdis03.wpafb.af.mil (Earle F. Ake) contributed MIS and NILE. if test "`(/bin/universe) 2>/dev/null`" = att ; then echo pyramid-pyramid-sysv3 else echo pyramid-pyramid-bsd fi exit ;; NILE*:*:*:dcosx) echo pyramid-pyramid-svr4 exit ;; DRS?6000:unix:4.0:6*) echo sparc-icl-nx6 exit ;; DRS?6000:UNIX_SV:4.2*:7* | DRS?6000:isis:4.2*:7*) case `/usr/bin/uname -p` in sparc) echo sparc-icl-nx7; exit ;; esac ;; s390x:SunOS:*:*) echo ${UNAME_MACHINE}-ibm-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` exit ;; sun4H:SunOS:5.*:*) echo sparc-hal-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` exit ;; sun4*:SunOS:5.*:* | tadpole*:SunOS:5.*:*) echo sparc-sun-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` exit ;; i86pc:AuroraUX:5.*:* | i86xen:AuroraUX:5.*:*) echo i386-pc-auroraux${UNAME_RELEASE} exit ;; i86pc:SunOS:5.*:* | i86xen:SunOS:5.*:*) eval $set_cc_for_build SUN_ARCH="i386" # If there is a compiler, see if it is configured for 64-bit objects. # Note that the Sun cc does not turn __LP64__ into 1 like gcc does. # This test works for both compilers. if [ "$CC_FOR_BUILD" != 'no_compiler_found' ]; then if (echo '#ifdef __amd64'; echo IS_64BIT_ARCH; echo '#endif') | \ (CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) | \ grep IS_64BIT_ARCH >/dev/null then SUN_ARCH="x86_64" fi fi echo ${SUN_ARCH}-pc-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` exit ;; sun4*:SunOS:6*:*) # According to config.sub, this is the proper way to canonicalize # SunOS6. Hard to guess exactly what SunOS6 will be like, but # it's likely to be more like Solaris than SunOS4. echo sparc-sun-solaris3`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` exit ;; sun4*:SunOS:*:*) case "`/usr/bin/arch -k`" in Series*|S4*) UNAME_RELEASE=`uname -v` ;; esac # Japanese Language versions have a version number like `4.1.3-JL'. echo sparc-sun-sunos`echo ${UNAME_RELEASE}|sed -e 's/-/_/'` exit ;; sun3*:SunOS:*:*) echo m68k-sun-sunos${UNAME_RELEASE} exit ;; sun*:*:4.2BSD:*) UNAME_RELEASE=`(sed 1q /etc/motd | awk '{print substr($5,1,3)}') 2>/dev/null` test "x${UNAME_RELEASE}" = "x" && UNAME_RELEASE=3 case "`/bin/arch`" in sun3) echo m68k-sun-sunos${UNAME_RELEASE} ;; sun4) echo sparc-sun-sunos${UNAME_RELEASE} ;; esac exit ;; aushp:SunOS:*:*) echo sparc-auspex-sunos${UNAME_RELEASE} exit ;; # The situation for MiNT is a little confusing. The machine name # can be virtually everything (everything which is not # "atarist" or "atariste" at least should have a processor # > m68000). The system name ranges from "MiNT" over "FreeMiNT" # to the lowercase version "mint" (or "freemint"). Finally # the system name "TOS" denotes a system which is actually not # MiNT. But MiNT is downward compatible to TOS, so this should # be no problem. atarist[e]:*MiNT:*:* | atarist[e]:*mint:*:* | atarist[e]:*TOS:*:*) echo m68k-atari-mint${UNAME_RELEASE} exit ;; atari*:*MiNT:*:* | atari*:*mint:*:* | atarist[e]:*TOS:*:*) echo m68k-atari-mint${UNAME_RELEASE} exit ;; *falcon*:*MiNT:*:* | *falcon*:*mint:*:* | *falcon*:*TOS:*:*) echo m68k-atari-mint${UNAME_RELEASE} exit ;; milan*:*MiNT:*:* | milan*:*mint:*:* | *milan*:*TOS:*:*) echo m68k-milan-mint${UNAME_RELEASE} exit ;; hades*:*MiNT:*:* | hades*:*mint:*:* | *hades*:*TOS:*:*) echo m68k-hades-mint${UNAME_RELEASE} exit ;; *:*MiNT:*:* | *:*mint:*:* | *:*TOS:*:*) echo m68k-unknown-mint${UNAME_RELEASE} exit ;; m68k:machten:*:*) echo m68k-apple-machten${UNAME_RELEASE} exit ;; powerpc:machten:*:*) echo powerpc-apple-machten${UNAME_RELEASE} exit ;; RISC*:Mach:*:*) echo mips-dec-mach_bsd4.3 exit ;; RISC*:ULTRIX:*:*) echo mips-dec-ultrix${UNAME_RELEASE} exit ;; VAX*:ULTRIX*:*:*) echo vax-dec-ultrix${UNAME_RELEASE} exit ;; 2020:CLIX:*:* | 2430:CLIX:*:*) echo clipper-intergraph-clix${UNAME_RELEASE} exit ;; mips:*:*:UMIPS | mips:*:*:RISCos) eval $set_cc_for_build sed 's/^ //' << EOF >$dummy.c #ifdef __cplusplus #include /* for printf() prototype */ int main (int argc, char *argv[]) { #else int main (argc, argv) int argc; char *argv[]; { #endif #if defined (host_mips) && defined (MIPSEB) #if defined (SYSTYPE_SYSV) printf ("mips-mips-riscos%ssysv\n", argv[1]); exit (0); #endif #if defined (SYSTYPE_SVR4) printf ("mips-mips-riscos%ssvr4\n", argv[1]); exit (0); #endif #if defined (SYSTYPE_BSD43) || defined(SYSTYPE_BSD) printf ("mips-mips-riscos%sbsd\n", argv[1]); exit (0); #endif #endif exit (-1); } EOF $CC_FOR_BUILD -o $dummy $dummy.c && dummyarg=`echo "${UNAME_RELEASE}" | sed -n 's/\([0-9]*\).*/\1/p'` && SYSTEM_NAME=`$dummy $dummyarg` && { echo "$SYSTEM_NAME"; exit; } echo mips-mips-riscos${UNAME_RELEASE} exit ;; Motorola:PowerMAX_OS:*:*) echo powerpc-motorola-powermax exit ;; Motorola:*:4.3:PL8-*) echo powerpc-harris-powermax exit ;; Night_Hawk:*:*:PowerMAX_OS | Synergy:PowerMAX_OS:*:*) echo powerpc-harris-powermax exit ;; Night_Hawk:Power_UNIX:*:*) echo powerpc-harris-powerunix exit ;; m88k:CX/UX:7*:*) echo m88k-harris-cxux7 exit ;; m88k:*:4*:R4*) echo m88k-motorola-sysv4 exit ;; m88k:*:3*:R3*) echo m88k-motorola-sysv3 exit ;; AViiON:dgux:*:*) # DG/UX returns AViiON for all architectures UNAME_PROCESSOR=`/usr/bin/uname -p` if [ $UNAME_PROCESSOR = mc88100 ] || [ $UNAME_PROCESSOR = mc88110 ] then if [ ${TARGET_BINARY_INTERFACE}x = m88kdguxelfx ] || \ [ ${TARGET_BINARY_INTERFACE}x = x ] then echo m88k-dg-dgux${UNAME_RELEASE} else echo m88k-dg-dguxbcs${UNAME_RELEASE} fi else echo i586-dg-dgux${UNAME_RELEASE} fi exit ;; M88*:DolphinOS:*:*) # DolphinOS (SVR3) echo m88k-dolphin-sysv3 exit ;; M88*:*:R3*:*) # Delta 88k system running SVR3 echo m88k-motorola-sysv3 exit ;; XD88*:*:*:*) # Tektronix XD88 system running UTekV (SVR3) echo m88k-tektronix-sysv3 exit ;; Tek43[0-9][0-9]:UTek:*:*) # Tektronix 4300 system running UTek (BSD) echo m68k-tektronix-bsd exit ;; *:IRIX*:*:*) echo mips-sgi-irix`echo ${UNAME_RELEASE}|sed -e 's/-/_/g'` exit ;; ????????:AIX?:[12].1:2) # AIX 2.2.1 or AIX 2.1.1 is RT/PC AIX. echo romp-ibm-aix # uname -m gives an 8 hex-code CPU id exit ;; # Note that: echo "'`uname -s`'" gives 'AIX ' i*86:AIX:*:*) echo i386-ibm-aix exit ;; ia64:AIX:*:*) if [ -x /usr/bin/oslevel ] ; then IBM_REV=`/usr/bin/oslevel` else IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE} fi echo ${UNAME_MACHINE}-ibm-aix${IBM_REV} exit ;; *:AIX:2:3) if grep bos325 /usr/include/stdio.h >/dev/null 2>&1; then eval $set_cc_for_build sed 's/^ //' << EOF >$dummy.c #include main() { if (!__power_pc()) exit(1); puts("powerpc-ibm-aix3.2.5"); exit(0); } EOF if $CC_FOR_BUILD -o $dummy $dummy.c && SYSTEM_NAME=`$dummy` then echo "$SYSTEM_NAME" else echo rs6000-ibm-aix3.2.5 fi elif grep bos324 /usr/include/stdio.h >/dev/null 2>&1; then echo rs6000-ibm-aix3.2.4 else echo rs6000-ibm-aix3.2 fi exit ;; *:AIX:*:[4567]) IBM_CPU_ID=`/usr/sbin/lsdev -C -c processor -S available | sed 1q | awk '{ print $1 }'` if /usr/sbin/lsattr -El ${IBM_CPU_ID} | grep ' POWER' >/dev/null 2>&1; then IBM_ARCH=rs6000 else IBM_ARCH=powerpc fi if [ -x /usr/bin/lslpp ] ; then IBM_REV=`/usr/bin/lslpp -Lqc bos.rte.libc | awk -F: '{ print $3 }' | sed s/[0-9]*$/0/` else IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE} fi echo ${IBM_ARCH}-ibm-aix${IBM_REV} exit ;; *:AIX:*:*) echo rs6000-ibm-aix exit ;; ibmrt:4.4BSD:*|romp-ibm:BSD:*) echo romp-ibm-bsd4.4 exit ;; ibmrt:*BSD:*|romp-ibm:BSD:*) # covers RT/PC BSD and echo romp-ibm-bsd${UNAME_RELEASE} # 4.3 with uname added to exit ;; # report: romp-ibm BSD 4.3 *:BOSX:*:*) echo rs6000-bull-bosx exit ;; DPX/2?00:B.O.S.:*:*) echo m68k-bull-sysv3 exit ;; 9000/[34]??:4.3bsd:1.*:*) echo m68k-hp-bsd exit ;; hp300:4.4BSD:*:* | 9000/[34]??:4.3bsd:2.*:*) echo m68k-hp-bsd4.4 exit ;; 9000/[34678]??:HP-UX:*:*) HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'` case "${UNAME_MACHINE}" in 9000/31? ) HP_ARCH=m68000 ;; 9000/[34]?? ) HP_ARCH=m68k ;; 9000/[678][0-9][0-9]) if [ -x /usr/bin/getconf ]; then sc_cpu_version=`/usr/bin/getconf SC_CPU_VERSION 2>/dev/null` sc_kernel_bits=`/usr/bin/getconf SC_KERNEL_BITS 2>/dev/null` case "${sc_cpu_version}" in 523) HP_ARCH="hppa1.0" ;; # CPU_PA_RISC1_0 528) HP_ARCH="hppa1.1" ;; # CPU_PA_RISC1_1 532) # CPU_PA_RISC2_0 case "${sc_kernel_bits}" in 32) HP_ARCH="hppa2.0n" ;; 64) HP_ARCH="hppa2.0w" ;; '') HP_ARCH="hppa2.0" ;; # HP-UX 10.20 esac ;; esac fi if [ "${HP_ARCH}" = "" ]; then eval $set_cc_for_build sed 's/^ //' << EOF >$dummy.c #define _HPUX_SOURCE #include #include int main () { #if defined(_SC_KERNEL_BITS) long bits = sysconf(_SC_KERNEL_BITS); #endif long cpu = sysconf (_SC_CPU_VERSION); switch (cpu) { case CPU_PA_RISC1_0: puts ("hppa1.0"); break; case CPU_PA_RISC1_1: puts ("hppa1.1"); break; case CPU_PA_RISC2_0: #if defined(_SC_KERNEL_BITS) switch (bits) { case 64: puts ("hppa2.0w"); break; case 32: puts ("hppa2.0n"); break; default: puts ("hppa2.0"); break; } break; #else /* !defined(_SC_KERNEL_BITS) */ puts ("hppa2.0"); break; #endif default: puts ("hppa1.0"); break; } exit (0); } EOF (CCOPTS= $CC_FOR_BUILD -o $dummy $dummy.c 2>/dev/null) && HP_ARCH=`$dummy` test -z "$HP_ARCH" && HP_ARCH=hppa fi ;; esac if [ ${HP_ARCH} = "hppa2.0w" ] then eval $set_cc_for_build # hppa2.0w-hp-hpux* has a 64-bit kernel and a compiler generating # 32-bit code. hppa64-hp-hpux* has the same kernel and a compiler # generating 64-bit code. GNU and HP use different nomenclature: # # $ CC_FOR_BUILD=cc ./config.guess # => hppa2.0w-hp-hpux11.23 # $ CC_FOR_BUILD="cc +DA2.0w" ./config.guess # => hppa64-hp-hpux11.23 if echo __LP64__ | (CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) | grep -q __LP64__ then HP_ARCH="hppa2.0w" else HP_ARCH="hppa64" fi fi echo ${HP_ARCH}-hp-hpux${HPUX_REV} exit ;; ia64:HP-UX:*:*) HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'` echo ia64-hp-hpux${HPUX_REV} exit ;; 3050*:HI-UX:*:*) eval $set_cc_for_build sed 's/^ //' << EOF >$dummy.c #include int main () { long cpu = sysconf (_SC_CPU_VERSION); /* The order matters, because CPU_IS_HP_MC68K erroneously returns true for CPU_PA_RISC1_0. CPU_IS_PA_RISC returns correct results, however. */ if (CPU_IS_PA_RISC (cpu)) { switch (cpu) { case CPU_PA_RISC1_0: puts ("hppa1.0-hitachi-hiuxwe2"); break; case CPU_PA_RISC1_1: puts ("hppa1.1-hitachi-hiuxwe2"); break; case CPU_PA_RISC2_0: puts ("hppa2.0-hitachi-hiuxwe2"); break; default: puts ("hppa-hitachi-hiuxwe2"); break; } } else if (CPU_IS_HP_MC68K (cpu)) puts ("m68k-hitachi-hiuxwe2"); else puts ("unknown-hitachi-hiuxwe2"); exit (0); } EOF $CC_FOR_BUILD -o $dummy $dummy.c && SYSTEM_NAME=`$dummy` && { echo "$SYSTEM_NAME"; exit; } echo unknown-hitachi-hiuxwe2 exit ;; 9000/7??:4.3bsd:*:* | 9000/8?[79]:4.3bsd:*:* ) echo hppa1.1-hp-bsd exit ;; 9000/8??:4.3bsd:*:*) echo hppa1.0-hp-bsd exit ;; *9??*:MPE/iX:*:* | *3000*:MPE/iX:*:*) echo hppa1.0-hp-mpeix exit ;; hp7??:OSF1:*:* | hp8?[79]:OSF1:*:* ) echo hppa1.1-hp-osf exit ;; hp8??:OSF1:*:*) echo hppa1.0-hp-osf exit ;; i*86:OSF1:*:*) if [ -x /usr/sbin/sysversion ] ; then echo ${UNAME_MACHINE}-unknown-osf1mk else echo ${UNAME_MACHINE}-unknown-osf1 fi exit ;; parisc*:Lites*:*:*) echo hppa1.1-hp-lites exit ;; C1*:ConvexOS:*:* | convex:ConvexOS:C1*:*) echo c1-convex-bsd exit ;; C2*:ConvexOS:*:* | convex:ConvexOS:C2*:*) if getsysinfo -f scalar_acc then echo c32-convex-bsd else echo c2-convex-bsd fi exit ;; C34*:ConvexOS:*:* | convex:ConvexOS:C34*:*) echo c34-convex-bsd exit ;; C38*:ConvexOS:*:* | convex:ConvexOS:C38*:*) echo c38-convex-bsd exit ;; C4*:ConvexOS:*:* | convex:ConvexOS:C4*:*) echo c4-convex-bsd exit ;; CRAY*Y-MP:*:*:*) echo ymp-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' exit ;; CRAY*[A-Z]90:*:*:*) echo ${UNAME_MACHINE}-cray-unicos${UNAME_RELEASE} \ | sed -e 's/CRAY.*\([A-Z]90\)/\1/' \ -e y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/ \ -e 's/\.[^.]*$/.X/' exit ;; CRAY*TS:*:*:*) echo t90-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' exit ;; CRAY*T3E:*:*:*) echo alphaev5-cray-unicosmk${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' exit ;; CRAY*SV1:*:*:*) echo sv1-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' exit ;; *:UNICOS/mp:*:*) echo craynv-cray-unicosmp${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' exit ;; F30[01]:UNIX_System_V:*:* | F700:UNIX_System_V:*:*) FUJITSU_PROC=`uname -m | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'` FUJITSU_REL=`echo ${UNAME_RELEASE} | sed -e 's/ /_/'` echo "${FUJITSU_PROC}-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}" exit ;; 5000:UNIX_System_V:4.*:*) FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'` FUJITSU_REL=`echo ${UNAME_RELEASE} | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/ /_/'` echo "sparc-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}" exit ;; i*86:BSD/386:*:* | i*86:BSD/OS:*:* | *:Ascend\ Embedded/OS:*:*) echo ${UNAME_MACHINE}-pc-bsdi${UNAME_RELEASE} exit ;; sparc*:BSD/OS:*:*) echo sparc-unknown-bsdi${UNAME_RELEASE} exit ;; *:BSD/OS:*:*) echo ${UNAME_MACHINE}-unknown-bsdi${UNAME_RELEASE} exit ;; *:FreeBSD:*:*) UNAME_PROCESSOR=`/usr/bin/uname -p` case ${UNAME_PROCESSOR} in amd64) echo x86_64-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;; *) echo ${UNAME_PROCESSOR}-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;; esac exit ;; i*:CYGWIN*:*) echo ${UNAME_MACHINE}-pc-cygwin exit ;; *:MINGW64*:*) echo ${UNAME_MACHINE}-pc-mingw64 exit ;; *:MINGW*:*) echo ${UNAME_MACHINE}-pc-mingw32 exit ;; *:MSYS*:*) echo ${UNAME_MACHINE}-pc-msys exit ;; i*:windows32*:*) # uname -m includes "-pc" on this system. echo ${UNAME_MACHINE}-mingw32 exit ;; i*:PW*:*) echo ${UNAME_MACHINE}-pc-pw32 exit ;; *:Interix*:*) case ${UNAME_MACHINE} in x86) echo i586-pc-interix${UNAME_RELEASE} exit ;; authenticamd | genuineintel | EM64T) echo x86_64-unknown-interix${UNAME_RELEASE} exit ;; IA64) echo ia64-unknown-interix${UNAME_RELEASE} exit ;; esac ;; [345]86:Windows_95:* | [345]86:Windows_98:* | [345]86:Windows_NT:*) echo i${UNAME_MACHINE}-pc-mks exit ;; 8664:Windows_NT:*) echo x86_64-pc-mks exit ;; i*:Windows_NT*:* | Pentium*:Windows_NT*:*) # How do we know it's Interix rather than the generic POSIX subsystem? # It also conflicts with pre-2.0 versions of AT&T UWIN. Should we # UNAME_MACHINE based on the output of uname instead of i386? echo i586-pc-interix exit ;; i*:UWIN*:*) echo ${UNAME_MACHINE}-pc-uwin exit ;; amd64:CYGWIN*:*:* | x86_64:CYGWIN*:*:*) echo x86_64-unknown-cygwin exit ;; p*:CYGWIN*:*) echo powerpcle-unknown-cygwin exit ;; prep*:SunOS:5.*:*) echo powerpcle-unknown-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` exit ;; *:GNU:*:*) # the GNU system echo `echo ${UNAME_MACHINE}|sed -e 's,[-/].*$,,'`-unknown-${LIBC}`echo ${UNAME_RELEASE}|sed -e 's,/.*$,,'` exit ;; *:GNU/*:*:*) # other systems with GNU libc and userland echo ${UNAME_MACHINE}-unknown-`echo ${UNAME_SYSTEM} | sed 's,^[^/]*/,,' | tr '[A-Z]' '[a-z]'``echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`-${LIBC} exit ;; i*86:Minix:*:*) echo ${UNAME_MACHINE}-pc-minix exit ;; aarch64:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-${LIBC} exit ;; aarch64_be:Linux:*:*) UNAME_MACHINE=aarch64_be echo ${UNAME_MACHINE}-unknown-linux-${LIBC} exit ;; alpha:Linux:*:*) case `sed -n '/^cpu model/s/^.*: \(.*\)/\1/p' < /proc/cpuinfo` in EV5) UNAME_MACHINE=alphaev5 ;; EV56) UNAME_MACHINE=alphaev56 ;; PCA56) UNAME_MACHINE=alphapca56 ;; PCA57) UNAME_MACHINE=alphapca56 ;; EV6) UNAME_MACHINE=alphaev6 ;; EV67) UNAME_MACHINE=alphaev67 ;; EV68*) UNAME_MACHINE=alphaev68 ;; esac objdump --private-headers /bin/sh | grep -q ld.so.1 if test "$?" = 0 ; then LIBC="gnulibc1" ; fi echo ${UNAME_MACHINE}-unknown-linux-${LIBC} exit ;; arc:Linux:*:* | arceb:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-${LIBC} exit ;; arm*:Linux:*:*) eval $set_cc_for_build if echo __ARM_EABI__ | $CC_FOR_BUILD -E - 2>/dev/null \ | grep -q __ARM_EABI__ then echo ${UNAME_MACHINE}-unknown-linux-${LIBC} else if echo __ARM_PCS_VFP | $CC_FOR_BUILD -E - 2>/dev/null \ | grep -q __ARM_PCS_VFP then echo ${UNAME_MACHINE}-unknown-linux-${LIBC}eabi else echo ${UNAME_MACHINE}-unknown-linux-${LIBC}eabihf fi fi exit ;; avr32*:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-${LIBC} exit ;; cris:Linux:*:*) echo ${UNAME_MACHINE}-axis-linux-${LIBC} exit ;; crisv32:Linux:*:*) echo ${UNAME_MACHINE}-axis-linux-${LIBC} exit ;; frv:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-${LIBC} exit ;; hexagon:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-${LIBC} exit ;; i*86:Linux:*:*) echo ${UNAME_MACHINE}-pc-linux-${LIBC} exit ;; ia64:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-${LIBC} exit ;; m32r*:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-${LIBC} exit ;; m68*:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-${LIBC} exit ;; mips:Linux:*:* | mips64:Linux:*:*) eval $set_cc_for_build sed 's/^ //' << EOF >$dummy.c #undef CPU #undef ${UNAME_MACHINE} #undef ${UNAME_MACHINE}el #if defined(__MIPSEL__) || defined(__MIPSEL) || defined(_MIPSEL) || defined(MIPSEL) CPU=${UNAME_MACHINE}el #else #if defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB) || defined(MIPSEB) CPU=${UNAME_MACHINE} #else CPU= #endif #endif EOF eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep '^CPU'` test x"${CPU}" != x && { echo "${CPU}-unknown-linux-${LIBC}"; exit; } ;; openrisc*:Linux:*:*) echo or1k-unknown-linux-${LIBC} exit ;; or32:Linux:*:* | or1k*:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-${LIBC} exit ;; padre:Linux:*:*) echo sparc-unknown-linux-${LIBC} exit ;; parisc64:Linux:*:* | hppa64:Linux:*:*) echo hppa64-unknown-linux-${LIBC} exit ;; parisc:Linux:*:* | hppa:Linux:*:*) # Look for CPU level case `grep '^cpu[^a-z]*:' /proc/cpuinfo 2>/dev/null | cut -d' ' -f2` in PA7*) echo hppa1.1-unknown-linux-${LIBC} ;; PA8*) echo hppa2.0-unknown-linux-${LIBC} ;; *) echo hppa-unknown-linux-${LIBC} ;; esac exit ;; ppc64:Linux:*:*) echo powerpc64-unknown-linux-${LIBC} exit ;; ppc:Linux:*:*) echo powerpc-unknown-linux-${LIBC} exit ;; ppc64le:Linux:*:*) echo powerpc64le-unknown-linux-${LIBC} exit ;; ppcle:Linux:*:*) echo powerpcle-unknown-linux-${LIBC} exit ;; s390:Linux:*:* | s390x:Linux:*:*) echo ${UNAME_MACHINE}-ibm-linux-${LIBC} exit ;; sh64*:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-${LIBC} exit ;; sh*:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-${LIBC} exit ;; sparc:Linux:*:* | sparc64:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-${LIBC} exit ;; tile*:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-${LIBC} exit ;; vax:Linux:*:*) echo ${UNAME_MACHINE}-dec-linux-${LIBC} exit ;; x86_64:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-${LIBC} exit ;; xtensa*:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-${LIBC} exit ;; i*86:DYNIX/ptx:4*:*) # ptx 4.0 does uname -s correctly, with DYNIX/ptx in there. # earlier versions are messed up and put the nodename in both # sysname and nodename. echo i386-sequent-sysv4 exit ;; i*86:UNIX_SV:4.2MP:2.*) # Unixware is an offshoot of SVR4, but it has its own version # number series starting with 2... # I am not positive that other SVR4 systems won't match this, # I just have to hope. -- rms. # Use sysv4.2uw... so that sysv4* matches it. echo ${UNAME_MACHINE}-pc-sysv4.2uw${UNAME_VERSION} exit ;; i*86:OS/2:*:*) # If we were able to find `uname', then EMX Unix compatibility # is probably installed. echo ${UNAME_MACHINE}-pc-os2-emx exit ;; i*86:XTS-300:*:STOP) echo ${UNAME_MACHINE}-unknown-stop exit ;; i*86:atheos:*:*) echo ${UNAME_MACHINE}-unknown-atheos exit ;; i*86:syllable:*:*) echo ${UNAME_MACHINE}-pc-syllable exit ;; i*86:LynxOS:2.*:* | i*86:LynxOS:3.[01]*:* | i*86:LynxOS:4.[02]*:*) echo i386-unknown-lynxos${UNAME_RELEASE} exit ;; i*86:*DOS:*:*) echo ${UNAME_MACHINE}-pc-msdosdjgpp exit ;; i*86:*:4.*:* | i*86:SYSTEM_V:4.*:*) UNAME_REL=`echo ${UNAME_RELEASE} | sed 's/\/MP$//'` if grep Novell /usr/include/link.h >/dev/null 2>/dev/null; then echo ${UNAME_MACHINE}-univel-sysv${UNAME_REL} else echo ${UNAME_MACHINE}-pc-sysv${UNAME_REL} fi exit ;; i*86:*:5:[678]*) # UnixWare 7.x, OpenUNIX and OpenServer 6. case `/bin/uname -X | grep "^Machine"` in *486*) UNAME_MACHINE=i486 ;; *Pentium) UNAME_MACHINE=i586 ;; *Pent*|*Celeron) UNAME_MACHINE=i686 ;; esac echo ${UNAME_MACHINE}-unknown-sysv${UNAME_RELEASE}${UNAME_SYSTEM}${UNAME_VERSION} exit ;; i*86:*:3.2:*) if test -f /usr/options/cb.name; then UNAME_REL=`sed -n 's/.*Version //p' /dev/null >/dev/null ; then UNAME_REL=`(/bin/uname -X|grep Release|sed -e 's/.*= //')` (/bin/uname -X|grep i80486 >/dev/null) && UNAME_MACHINE=i486 (/bin/uname -X|grep '^Machine.*Pentium' >/dev/null) \ && UNAME_MACHINE=i586 (/bin/uname -X|grep '^Machine.*Pent *II' >/dev/null) \ && UNAME_MACHINE=i686 (/bin/uname -X|grep '^Machine.*Pentium Pro' >/dev/null) \ && UNAME_MACHINE=i686 echo ${UNAME_MACHINE}-pc-sco$UNAME_REL else echo ${UNAME_MACHINE}-pc-sysv32 fi exit ;; pc:*:*:*) # Left here for compatibility: # uname -m prints for DJGPP always 'pc', but it prints nothing about # the processor, so we play safe by assuming i586. # Note: whatever this is, it MUST be the same as what config.sub # prints for the "djgpp" host, or else GDB configury will decide that # this is a cross-build. echo i586-pc-msdosdjgpp exit ;; Intel:Mach:3*:*) echo i386-pc-mach3 exit ;; paragon:*:*:*) echo i860-intel-osf1 exit ;; i860:*:4.*:*) # i860-SVR4 if grep Stardent /usr/include/sys/uadmin.h >/dev/null 2>&1 ; then echo i860-stardent-sysv${UNAME_RELEASE} # Stardent Vistra i860-SVR4 else # Add other i860-SVR4 vendors below as they are discovered. echo i860-unknown-sysv${UNAME_RELEASE} # Unknown i860-SVR4 fi exit ;; mini*:CTIX:SYS*5:*) # "miniframe" echo m68010-convergent-sysv exit ;; mc68k:UNIX:SYSTEM5:3.51m) echo m68k-convergent-sysv exit ;; M680?0:D-NIX:5.3:*) echo m68k-diab-dnix exit ;; M68*:*:R3V[5678]*:*) test -r /sysV68 && { echo 'm68k-motorola-sysv'; exit; } ;; 3[345]??:*:4.0:3.0 | 3[34]??A:*:4.0:3.0 | 3[34]??,*:*:4.0:3.0 | 3[34]??/*:*:4.0:3.0 | 4400:*:4.0:3.0 | 4850:*:4.0:3.0 | SKA40:*:4.0:3.0 | SDS2:*:4.0:3.0 | SHG2:*:4.0:3.0 | S7501*:*:4.0:3.0) OS_REL='' test -r /etc/.relid \ && OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid` /bin/uname -p 2>/dev/null | grep 86 >/dev/null \ && { echo i486-ncr-sysv4.3${OS_REL}; exit; } /bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \ && { echo i586-ncr-sysv4.3${OS_REL}; exit; } ;; 3[34]??:*:4.0:* | 3[34]??,*:*:4.0:*) /bin/uname -p 2>/dev/null | grep 86 >/dev/null \ && { echo i486-ncr-sysv4; exit; } ;; NCR*:*:4.2:* | MPRAS*:*:4.2:*) OS_REL='.3' test -r /etc/.relid \ && OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid` /bin/uname -p 2>/dev/null | grep 86 >/dev/null \ && { echo i486-ncr-sysv4.3${OS_REL}; exit; } /bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \ && { echo i586-ncr-sysv4.3${OS_REL}; exit; } /bin/uname -p 2>/dev/null | /bin/grep pteron >/dev/null \ && { echo i586-ncr-sysv4.3${OS_REL}; exit; } ;; m68*:LynxOS:2.*:* | m68*:LynxOS:3.0*:*) echo m68k-unknown-lynxos${UNAME_RELEASE} exit ;; mc68030:UNIX_System_V:4.*:*) echo m68k-atari-sysv4 exit ;; TSUNAMI:LynxOS:2.*:*) echo sparc-unknown-lynxos${UNAME_RELEASE} exit ;; rs6000:LynxOS:2.*:*) echo rs6000-unknown-lynxos${UNAME_RELEASE} exit ;; PowerPC:LynxOS:2.*:* | PowerPC:LynxOS:3.[01]*:* | PowerPC:LynxOS:4.[02]*:*) echo powerpc-unknown-lynxos${UNAME_RELEASE} exit ;; SM[BE]S:UNIX_SV:*:*) echo mips-dde-sysv${UNAME_RELEASE} exit ;; RM*:ReliantUNIX-*:*:*) echo mips-sni-sysv4 exit ;; RM*:SINIX-*:*:*) echo mips-sni-sysv4 exit ;; *:SINIX-*:*:*) if uname -p 2>/dev/null >/dev/null ; then UNAME_MACHINE=`(uname -p) 2>/dev/null` echo ${UNAME_MACHINE}-sni-sysv4 else echo ns32k-sni-sysv fi exit ;; PENTIUM:*:4.0*:*) # Unisys `ClearPath HMP IX 4000' SVR4/MP effort # says echo i586-unisys-sysv4 exit ;; *:UNIX_System_V:4*:FTX*) # From Gerald Hewes . # How about differentiating between stratus architectures? -djm echo hppa1.1-stratus-sysv4 exit ;; *:*:*:FTX*) # From seanf@swdc.stratus.com. echo i860-stratus-sysv4 exit ;; i*86:VOS:*:*) # From Paul.Green@stratus.com. echo ${UNAME_MACHINE}-stratus-vos exit ;; *:VOS:*:*) # From Paul.Green@stratus.com. echo hppa1.1-stratus-vos exit ;; mc68*:A/UX:*:*) echo m68k-apple-aux${UNAME_RELEASE} exit ;; news*:NEWS-OS:6*:*) echo mips-sony-newsos6 exit ;; R[34]000:*System_V*:*:* | R4000:UNIX_SYSV:*:* | R*000:UNIX_SV:*:*) if [ -d /usr/nec ]; then echo mips-nec-sysv${UNAME_RELEASE} else echo mips-unknown-sysv${UNAME_RELEASE} fi exit ;; BeBox:BeOS:*:*) # BeOS running on hardware made by Be, PPC only. echo powerpc-be-beos exit ;; BeMac:BeOS:*:*) # BeOS running on Mac or Mac clone, PPC only. echo powerpc-apple-beos exit ;; BePC:BeOS:*:*) # BeOS running on Intel PC compatible. echo i586-pc-beos exit ;; BePC:Haiku:*:*) # Haiku running on Intel PC compatible. echo i586-pc-haiku exit ;; x86_64:Haiku:*:*) echo x86_64-unknown-haiku exit ;; SX-4:SUPER-UX:*:*) echo sx4-nec-superux${UNAME_RELEASE} exit ;; SX-5:SUPER-UX:*:*) echo sx5-nec-superux${UNAME_RELEASE} exit ;; SX-6:SUPER-UX:*:*) echo sx6-nec-superux${UNAME_RELEASE} exit ;; SX-7:SUPER-UX:*:*) echo sx7-nec-superux${UNAME_RELEASE} exit ;; SX-8:SUPER-UX:*:*) echo sx8-nec-superux${UNAME_RELEASE} exit ;; SX-8R:SUPER-UX:*:*) echo sx8r-nec-superux${UNAME_RELEASE} exit ;; Power*:Rhapsody:*:*) echo powerpc-apple-rhapsody${UNAME_RELEASE} exit ;; *:Rhapsody:*:*) echo ${UNAME_MACHINE}-apple-rhapsody${UNAME_RELEASE} exit ;; *:Darwin:*:*) UNAME_PROCESSOR=`uname -p` || UNAME_PROCESSOR=unknown eval $set_cc_for_build if test "$UNAME_PROCESSOR" = unknown ; then UNAME_PROCESSOR=powerpc fi if test `echo "$UNAME_RELEASE" | sed -e 's/\..*//'` -le 10 ; then if [ "$CC_FOR_BUILD" != 'no_compiler_found' ]; then if (echo '#ifdef __LP64__'; echo IS_64BIT_ARCH; echo '#endif') | \ (CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) | \ grep IS_64BIT_ARCH >/dev/null then case $UNAME_PROCESSOR in i386) UNAME_PROCESSOR=x86_64 ;; powerpc) UNAME_PROCESSOR=powerpc64 ;; esac fi fi elif test "$UNAME_PROCESSOR" = i386 ; then # Avoid executing cc on OS X 10.9, as it ships with a stub # that puts up a graphical alert prompting to install # developer tools. Any system running Mac OS X 10.7 or # later (Darwin 11 and later) is required to have a 64-bit # processor. This is not true of the ARM version of Darwin # that Apple uses in portable devices. UNAME_PROCESSOR=x86_64 fi echo ${UNAME_PROCESSOR}-apple-darwin${UNAME_RELEASE} exit ;; *:procnto*:*:* | *:QNX:[0123456789]*:*) UNAME_PROCESSOR=`uname -p` if test "$UNAME_PROCESSOR" = "x86"; then UNAME_PROCESSOR=i386 UNAME_MACHINE=pc fi echo ${UNAME_PROCESSOR}-${UNAME_MACHINE}-nto-qnx${UNAME_RELEASE} exit ;; *:QNX:*:4*) echo i386-pc-qnx exit ;; NEO-?:NONSTOP_KERNEL:*:*) echo neo-tandem-nsk${UNAME_RELEASE} exit ;; NSE-*:NONSTOP_KERNEL:*:*) echo nse-tandem-nsk${UNAME_RELEASE} exit ;; NSR-?:NONSTOP_KERNEL:*:*) echo nsr-tandem-nsk${UNAME_RELEASE} exit ;; *:NonStop-UX:*:*) echo mips-compaq-nonstopux exit ;; BS2000:POSIX*:*:*) echo bs2000-siemens-sysv exit ;; DS/*:UNIX_System_V:*:*) echo ${UNAME_MACHINE}-${UNAME_SYSTEM}-${UNAME_RELEASE} exit ;; *:Plan9:*:*) # "uname -m" is not consistent, so use $cputype instead. 386 # is converted to i386 for consistency with other x86 # operating systems. if test "$cputype" = "386"; then UNAME_MACHINE=i386 else UNAME_MACHINE="$cputype" fi echo ${UNAME_MACHINE}-unknown-plan9 exit ;; *:TOPS-10:*:*) echo pdp10-unknown-tops10 exit ;; *:TENEX:*:*) echo pdp10-unknown-tenex exit ;; KS10:TOPS-20:*:* | KL10:TOPS-20:*:* | TYPE4:TOPS-20:*:*) echo pdp10-dec-tops20 exit ;; XKL-1:TOPS-20:*:* | TYPE5:TOPS-20:*:*) echo pdp10-xkl-tops20 exit ;; *:TOPS-20:*:*) echo pdp10-unknown-tops20 exit ;; *:ITS:*:*) echo pdp10-unknown-its exit ;; SEI:*:*:SEIUX) echo mips-sei-seiux${UNAME_RELEASE} exit ;; *:DragonFly:*:*) echo ${UNAME_MACHINE}-unknown-dragonfly`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` exit ;; *:*VMS:*:*) UNAME_MACHINE=`(uname -p) 2>/dev/null` case "${UNAME_MACHINE}" in A*) echo alpha-dec-vms ; exit ;; I*) echo ia64-dec-vms ; exit ;; V*) echo vax-dec-vms ; exit ;; esac ;; *:XENIX:*:SysV) echo i386-pc-xenix exit ;; i*86:skyos:*:*) echo ${UNAME_MACHINE}-pc-skyos`echo ${UNAME_RELEASE}` | sed -e 's/ .*$//' exit ;; i*86:rdos:*:*) echo ${UNAME_MACHINE}-pc-rdos exit ;; i*86:AROS:*:*) echo ${UNAME_MACHINE}-pc-aros exit ;; x86_64:VMkernel:*:*) echo ${UNAME_MACHINE}-unknown-esx exit ;; esac cat >&2 < in order to provide the needed information to handle your system. config.guess timestamp = $timestamp 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` /bin/uname -X = `(/bin/uname -X) 2>/dev/null` hostinfo = `(hostinfo) 2>/dev/null` /bin/universe = `(/bin/universe) 2>/dev/null` /usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null` /bin/arch = `(/bin/arch) 2>/dev/null` /usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null` /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null` UNAME_MACHINE = ${UNAME_MACHINE} UNAME_RELEASE = ${UNAME_RELEASE} UNAME_SYSTEM = ${UNAME_SYSTEM} UNAME_VERSION = ${UNAME_VERSION} EOF exit 1 # Local variables: # eval: (add-hook 'write-file-hooks 'time-stamp) # time-stamp-start: "timestamp='" # time-stamp-format: "%:y-%02m-%02d" # time-stamp-end: "'" # End: ecl-16.1.2/src/bdwgc/config.sub000077500000000000000000001062231266352375300162240ustar00rootroot00000000000000#! /bin/sh # Configuration validation subroutine script. # Copyright 1992-2014 Free Software Foundation, Inc. timestamp='2014-12-03' # This file is free software; you can redistribute it and/or modify it # under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 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 . # # As a special exception to the GNU General Public License, if you # distribute this file as part of a program that contains a # configuration script generated by Autoconf, you may include it under # the same distribution terms that you use for the rest of that # program. This Exception is an additional permission under section 7 # of the GNU General Public License, version 3 ("GPLv3"). # Please send patches to . # # Configuration subroutine to validate and canonicalize a configuration type. # Supply the specified configuration type as an argument. # If it is invalid, we print an error message on stderr and exit with code 1. # Otherwise, we print the canonical config type on stdout and succeed. # You can get the latest version of this script from: # http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.sub;hb=HEAD # This file is supposed to be the same for all GNU packages # and recognize all the CPU types, system types and aliases # that are meaningful with *any* GNU software. # Each package is responsible for reporting which valid configurations # it does not support. The user should be able to distinguish # a failure to support a valid configuration from a meaningless # configuration. # The goal of this file is to map all the various variations of a given # machine specification into a single specification in the form: # CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM # or in some cases, the newer four-part form: # CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM # It is wrong to echo any other type of specification. me=`echo "$0" | sed -e 's,.*/,,'` usage="\ Usage: $0 [OPTION] CPU-MFR-OPSYS $0 [OPTION] ALIAS Canonicalize a configuration name. Operation modes: -h, --help print this help, then exit -t, --time-stamp print date of last modification, then exit -v, --version print version number, then exit Report bugs and patches to ." version="\ GNU config.sub ($timestamp) Copyright 1992-2014 Free Software Foundation, Inc. This is free software; see the source for copying conditions. There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE." help=" Try \`$me --help' for more information." # Parse command line while test $# -gt 0 ; do case $1 in --time-stamp | --time* | -t ) echo "$timestamp" ; exit ;; --version | -v ) echo "$version" ; exit ;; --help | --h* | -h ) echo "$usage"; exit ;; -- ) # Stop option processing shift; break ;; - ) # Use stdin as input. break ;; -* ) echo "$me: invalid option $1$help" exit 1 ;; *local*) # First pass through any local machine types. echo $1 exit ;; * ) break ;; esac done case $# in 0) echo "$me: missing argument$help" >&2 exit 1;; 1) ;; *) echo "$me: too many arguments$help" >&2 exit 1;; esac # Separate what the user gave into CPU-COMPANY and OS or KERNEL-OS (if any). # Here we must recognize all the valid KERNEL-OS combinations. maybe_os=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\2/'` case $maybe_os in nto-qnx* | linux-gnu* | linux-android* | linux-dietlibc | linux-newlib* | \ linux-musl* | linux-uclibc* | uclinux-uclibc* | uclinux-gnu* | kfreebsd*-gnu* | \ knetbsd*-gnu* | netbsd*-gnu* | \ kopensolaris*-gnu* | \ storm-chaos* | os2-emx* | rtmk-nova*) os=-$maybe_os basic_machine=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'` ;; android-linux) os=-linux-android basic_machine=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'`-unknown ;; *) basic_machine=`echo $1 | sed 's/-[^-]*$//'` if [ $basic_machine != $1 ] then os=`echo $1 | sed 's/.*-/-/'` else os=; fi ;; esac ### Let's recognize common machines as not being operating systems so ### that things like config.sub decstation-3100 work. We also ### recognize some manufacturers as not being operating systems, so we ### can provide default operating systems below. case $os in -sun*os*) # Prevent following clause from handling this invalid input. ;; -dec* | -mips* | -sequent* | -encore* | -pc532* | -sgi* | -sony* | \ -att* | -7300* | -3300* | -delta* | -motorola* | -sun[234]* | \ -unicom* | -ibm* | -next | -hp | -isi* | -apollo | -altos* | \ -convergent* | -ncr* | -news | -32* | -3600* | -3100* | -hitachi* |\ -c[123]* | -convex* | -sun | -crds | -omron* | -dg | -ultra | -tti* | \ -harris | -dolphin | -highlevel | -gould | -cbm | -ns | -masscomp | \ -apple | -axis | -knuth | -cray | -microblaze*) os= basic_machine=$1 ;; -bluegene*) os=-cnk ;; -sim | -cisco | -oki | -wec | -winbond) os= basic_machine=$1 ;; -scout) ;; -wrs) os=-vxworks basic_machine=$1 ;; -chorusos*) os=-chorusos basic_machine=$1 ;; -chorusrdb) os=-chorusrdb basic_machine=$1 ;; -hiux*) os=-hiuxwe2 ;; -sco6) os=-sco5v6 basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -sco5) os=-sco3.2v5 basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -sco4) os=-sco3.2v4 basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -sco3.2.[4-9]*) os=`echo $os | sed -e 's/sco3.2./sco3.2v/'` basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -sco3.2v[4-9]*) # Don't forget version if it is 3.2v4 or newer. basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -sco5v6*) # Don't forget version if it is 3.2v4 or newer. basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -sco*) os=-sco3.2v2 basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -udk*) basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -isc) os=-isc2.2 basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -clix*) basic_machine=clipper-intergraph ;; -isc*) basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -lynx*178) os=-lynxos178 ;; -lynx*5) os=-lynxos5 ;; -lynx*) os=-lynxos ;; -ptx*) basic_machine=`echo $1 | sed -e 's/86-.*/86-sequent/'` ;; -windowsnt*) os=`echo $os | sed -e 's/windowsnt/winnt/'` ;; -psos*) os=-psos ;; -mint | -mint[0-9]*) basic_machine=m68k-atari os=-mint ;; esac # Decode aliases for certain CPU-COMPANY combinations. case $basic_machine in # Recognize the basic CPU types without company name. # Some are omitted here because they have special meanings below. 1750a | 580 \ | a29k \ | aarch64 | aarch64_be \ | alpha | alphaev[4-8] | alphaev56 | alphaev6[78] | alphapca5[67] \ | alpha64 | alpha64ev[4-8] | alpha64ev56 | alpha64ev6[78] | alpha64pca5[67] \ | am33_2.0 \ | arc | arceb \ | arm | arm[bl]e | arme[lb] | armv[2-8] | armv[3-8][lb] | armv7[arm] \ | avr | avr32 \ | be32 | be64 \ | bfin \ | c4x | c8051 | clipper \ | d10v | d30v | dlx | dsp16xx \ | epiphany \ | fido | fr30 | frv \ | h8300 | h8500 | hppa | hppa1.[01] | hppa2.0 | hppa2.0[nw] | hppa64 \ | hexagon \ | i370 | i860 | i960 | ia64 \ | ip2k | iq2000 \ | k1om \ | le32 | le64 \ | lm32 \ | m32c | m32r | m32rle | m68000 | m68k | m88k \ | maxq | mb | microblaze | microblazeel | mcore | mep | metag \ | mips | mipsbe | mipseb | mipsel | mipsle \ | mips16 \ | mips64 | mips64el \ | mips64octeon | mips64octeonel \ | mips64orion | mips64orionel \ | mips64r5900 | mips64r5900el \ | mips64vr | mips64vrel \ | mips64vr4100 | mips64vr4100el \ | mips64vr4300 | mips64vr4300el \ | mips64vr5000 | mips64vr5000el \ | mips64vr5900 | mips64vr5900el \ | mipsisa32 | mipsisa32el \ | mipsisa32r2 | mipsisa32r2el \ | mipsisa32r6 | mipsisa32r6el \ | mipsisa64 | mipsisa64el \ | mipsisa64r2 | mipsisa64r2el \ | mipsisa64r6 | mipsisa64r6el \ | mipsisa64sb1 | mipsisa64sb1el \ | mipsisa64sr71k | mipsisa64sr71kel \ | mipsr5900 | mipsr5900el \ | mipstx39 | mipstx39el \ | mn10200 | mn10300 \ | moxie \ | mt \ | msp430 \ | nds32 | nds32le | nds32be \ | nios | nios2 | nios2eb | nios2el \ | ns16k | ns32k \ | open8 | or1k | or1knd | or32 \ | pdp10 | pdp11 | pj | pjl \ | powerpc | powerpc64 | powerpc64le | powerpcle \ | pyramid \ | riscv32 | riscv64 \ | rl78 | rx \ | score \ | sh | sh[1234] | sh[24]a | sh[24]aeb | sh[23]e | sh[34]eb | sheb | shbe | shle | sh[1234]le | sh3ele \ | sh64 | sh64le \ | sparc | sparc64 | sparc64b | sparc64v | sparc86x | sparclet | sparclite \ | sparcv8 | sparcv9 | sparcv9b | sparcv9v \ | spu \ | tahoe | tic4x | tic54x | tic55x | tic6x | tic80 | tron \ | ubicom32 \ | v850 | v850e | v850e1 | v850e2 | v850es | v850e2v3 \ | visium \ | we32k \ | x86 | xc16x | xstormy16 | xtensa \ | z8k | z80) basic_machine=$basic_machine-unknown ;; c54x) basic_machine=tic54x-unknown ;; c55x) basic_machine=tic55x-unknown ;; c6x) basic_machine=tic6x-unknown ;; leon|leon[3-9]) basic_machine=sparc-$basic_machine ;; m6811 | m68hc11 | m6812 | m68hc12 | m68hcs12x | nvptx | picochip) basic_machine=$basic_machine-unknown os=-none ;; m88110 | m680[12346]0 | m683?2 | m68360 | m5200 | v70 | w65 | z8k) ;; ms1) basic_machine=mt-unknown ;; strongarm | thumb | xscale) basic_machine=arm-unknown ;; xgate) basic_machine=$basic_machine-unknown os=-none ;; xscaleeb) basic_machine=armeb-unknown ;; xscaleel) basic_machine=armel-unknown ;; # We use `pc' rather than `unknown' # because (1) that's what they normally are, and # (2) the word "unknown" tends to confuse beginning users. i*86 | x86_64) basic_machine=$basic_machine-pc ;; # Object if more than one company name word. *-*-*) echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2 exit 1 ;; # Recognize the basic CPU types with company name. 580-* \ | a29k-* \ | aarch64-* | aarch64_be-* \ | alpha-* | alphaev[4-8]-* | alphaev56-* | alphaev6[78]-* \ | alpha64-* | alpha64ev[4-8]-* | alpha64ev56-* | alpha64ev6[78]-* \ | alphapca5[67]-* | alpha64pca5[67]-* | arc-* | arceb-* \ | arm-* | armbe-* | armle-* | armeb-* | armv*-* \ | avr-* | avr32-* \ | be32-* | be64-* \ | bfin-* | bs2000-* \ | c[123]* | c30-* | [cjt]90-* | c4x-* \ | c8051-* | clipper-* | craynv-* | cydra-* \ | d10v-* | d30v-* | dlx-* \ | elxsi-* \ | f30[01]-* | f700-* | fido-* | fr30-* | frv-* | fx80-* \ | h8300-* | h8500-* \ | hppa-* | hppa1.[01]-* | hppa2.0-* | hppa2.0[nw]-* | hppa64-* \ | hexagon-* \ | i*86-* | i860-* | i960-* | ia64-* \ | ip2k-* | iq2000-* \ | k1om-* \ | le32-* | le64-* \ | lm32-* \ | m32c-* | m32r-* | m32rle-* \ | m68000-* | m680[012346]0-* | m68360-* | m683?2-* | m68k-* \ | m88110-* | m88k-* | maxq-* | mcore-* | metag-* \ | microblaze-* | microblazeel-* \ | mips-* | mipsbe-* | mipseb-* | mipsel-* | mipsle-* \ | mips16-* \ | mips64-* | mips64el-* \ | mips64octeon-* | mips64octeonel-* \ | mips64orion-* | mips64orionel-* \ | mips64r5900-* | mips64r5900el-* \ | mips64vr-* | mips64vrel-* \ | mips64vr4100-* | mips64vr4100el-* \ | mips64vr4300-* | mips64vr4300el-* \ | mips64vr5000-* | mips64vr5000el-* \ | mips64vr5900-* | mips64vr5900el-* \ | mipsisa32-* | mipsisa32el-* \ | mipsisa32r2-* | mipsisa32r2el-* \ | mipsisa32r6-* | mipsisa32r6el-* \ | mipsisa64-* | mipsisa64el-* \ | mipsisa64r2-* | mipsisa64r2el-* \ | mipsisa64r6-* | mipsisa64r6el-* \ | mipsisa64sb1-* | mipsisa64sb1el-* \ | mipsisa64sr71k-* | mipsisa64sr71kel-* \ | mipsr5900-* | mipsr5900el-* \ | mipstx39-* | mipstx39el-* \ | mmix-* \ | mt-* \ | msp430-* \ | nds32-* | nds32le-* | nds32be-* \ | nios-* | nios2-* | nios2eb-* | nios2el-* \ | none-* | np1-* | ns16k-* | ns32k-* \ | open8-* \ | or1k*-* \ | orion-* \ | pdp10-* | pdp11-* | pj-* | pjl-* | pn-* | power-* \ | powerpc-* | powerpc64-* | powerpc64le-* | powerpcle-* \ | pyramid-* \ | rl78-* | romp-* | rs6000-* | rx-* \ | sh-* | sh[1234]-* | sh[24]a-* | sh[24]aeb-* | sh[23]e-* | sh[34]eb-* | sheb-* | shbe-* \ | shle-* | sh[1234]le-* | sh3ele-* | sh64-* | sh64le-* \ | sparc-* | sparc64-* | sparc64b-* | sparc64v-* | sparc86x-* | sparclet-* \ | sparclite-* \ | sparcv8-* | sparcv9-* | sparcv9b-* | sparcv9v-* | sv1-* | sx?-* \ | tahoe-* \ | tic30-* | tic4x-* | tic54x-* | tic55x-* | tic6x-* | tic80-* \ | tile*-* \ | tron-* \ | ubicom32-* \ | v850-* | v850e-* | v850e1-* | v850es-* | v850e2-* | v850e2v3-* \ | vax-* \ | visium-* \ | we32k-* \ | x86-* | x86_64-* | xc16x-* | xps100-* \ | xstormy16-* | xtensa*-* \ | ymp-* \ | z8k-* | z80-*) ;; # Recognize the basic CPU types without company name, with glob match. xtensa*) basic_machine=$basic_machine-unknown ;; # Recognize the various machine names and aliases which stand # for a CPU type and a company and sometimes even an OS. 386bsd) basic_machine=i386-unknown os=-bsd ;; 3b1 | 7300 | 7300-att | att-7300 | pc7300 | safari | unixpc) basic_machine=m68000-att ;; 3b*) basic_machine=we32k-att ;; a29khif) basic_machine=a29k-amd os=-udi ;; abacus) basic_machine=abacus-unknown ;; adobe68k) basic_machine=m68010-adobe os=-scout ;; alliant | fx80) basic_machine=fx80-alliant ;; altos | altos3068) basic_machine=m68k-altos ;; am29k) basic_machine=a29k-none os=-bsd ;; amd64) basic_machine=x86_64-pc ;; amd64-*) basic_machine=x86_64-`echo $basic_machine | sed 's/^[^-]*-//'` ;; amdahl) basic_machine=580-amdahl os=-sysv ;; amiga | amiga-*) basic_machine=m68k-unknown ;; amigaos | amigados) basic_machine=m68k-unknown os=-amigaos ;; amigaunix | amix) basic_machine=m68k-unknown os=-sysv4 ;; apollo68) basic_machine=m68k-apollo os=-sysv ;; apollo68bsd) basic_machine=m68k-apollo os=-bsd ;; aros) basic_machine=i386-pc os=-aros ;; aux) basic_machine=m68k-apple os=-aux ;; balance) basic_machine=ns32k-sequent os=-dynix ;; blackfin) basic_machine=bfin-unknown os=-linux ;; blackfin-*) basic_machine=bfin-`echo $basic_machine | sed 's/^[^-]*-//'` os=-linux ;; bluegene*) basic_machine=powerpc-ibm os=-cnk ;; c54x-*) basic_machine=tic54x-`echo $basic_machine | sed 's/^[^-]*-//'` ;; c55x-*) basic_machine=tic55x-`echo $basic_machine | sed 's/^[^-]*-//'` ;; c6x-*) basic_machine=tic6x-`echo $basic_machine | sed 's/^[^-]*-//'` ;; c90) basic_machine=c90-cray os=-unicos ;; cegcc) basic_machine=arm-unknown os=-cegcc ;; convex-c1) basic_machine=c1-convex os=-bsd ;; convex-c2) basic_machine=c2-convex os=-bsd ;; convex-c32) basic_machine=c32-convex os=-bsd ;; convex-c34) basic_machine=c34-convex os=-bsd ;; convex-c38) basic_machine=c38-convex os=-bsd ;; cray | j90) basic_machine=j90-cray os=-unicos ;; craynv) basic_machine=craynv-cray os=-unicosmp ;; cr16 | cr16-*) basic_machine=cr16-unknown os=-elf ;; crds | unos) basic_machine=m68k-crds ;; crisv32 | crisv32-* | etraxfs*) basic_machine=crisv32-axis ;; cris | cris-* | etrax*) basic_machine=cris-axis ;; crx) basic_machine=crx-unknown os=-elf ;; da30 | da30-*) basic_machine=m68k-da30 ;; decstation | decstation-3100 | pmax | pmax-* | pmin | dec3100 | decstatn) basic_machine=mips-dec ;; decsystem10* | dec10*) basic_machine=pdp10-dec os=-tops10 ;; decsystem20* | dec20*) basic_machine=pdp10-dec os=-tops20 ;; delta | 3300 | motorola-3300 | motorola-delta \ | 3300-motorola | delta-motorola) basic_machine=m68k-motorola ;; delta88) basic_machine=m88k-motorola os=-sysv3 ;; dicos) basic_machine=i686-pc os=-dicos ;; djgpp) basic_machine=i586-pc os=-msdosdjgpp ;; dpx20 | dpx20-*) basic_machine=rs6000-bull os=-bosx ;; dpx2* | dpx2*-bull) basic_machine=m68k-bull os=-sysv3 ;; ebmon29k) basic_machine=a29k-amd os=-ebmon ;; elxsi) basic_machine=elxsi-elxsi os=-bsd ;; encore | umax | mmax) basic_machine=ns32k-encore ;; es1800 | OSE68k | ose68k | ose | OSE) basic_machine=m68k-ericsson os=-ose ;; fx2800) basic_machine=i860-alliant ;; genix) basic_machine=ns32k-ns ;; gmicro) basic_machine=tron-gmicro os=-sysv ;; go32) basic_machine=i386-pc os=-go32 ;; h3050r* | hiux*) basic_machine=hppa1.1-hitachi os=-hiuxwe2 ;; h8300hms) basic_machine=h8300-hitachi os=-hms ;; h8300xray) basic_machine=h8300-hitachi os=-xray ;; h8500hms) basic_machine=h8500-hitachi os=-hms ;; harris) basic_machine=m88k-harris os=-sysv3 ;; hp300-*) basic_machine=m68k-hp ;; hp300bsd) basic_machine=m68k-hp os=-bsd ;; hp300hpux) basic_machine=m68k-hp os=-hpux ;; hp3k9[0-9][0-9] | hp9[0-9][0-9]) basic_machine=hppa1.0-hp ;; hp9k2[0-9][0-9] | hp9k31[0-9]) basic_machine=m68000-hp ;; hp9k3[2-9][0-9]) basic_machine=m68k-hp ;; hp9k6[0-9][0-9] | hp6[0-9][0-9]) basic_machine=hppa1.0-hp ;; hp9k7[0-79][0-9] | hp7[0-79][0-9]) basic_machine=hppa1.1-hp ;; hp9k78[0-9] | hp78[0-9]) # FIXME: really hppa2.0-hp basic_machine=hppa1.1-hp ;; hp9k8[67]1 | hp8[67]1 | hp9k80[24] | hp80[24] | hp9k8[78]9 | hp8[78]9 | hp9k893 | hp893) # FIXME: really hppa2.0-hp basic_machine=hppa1.1-hp ;; hp9k8[0-9][13679] | hp8[0-9][13679]) basic_machine=hppa1.1-hp ;; hp9k8[0-9][0-9] | hp8[0-9][0-9]) basic_machine=hppa1.0-hp ;; hppa-next) os=-nextstep3 ;; hppaosf) basic_machine=hppa1.1-hp os=-osf ;; hppro) basic_machine=hppa1.1-hp os=-proelf ;; i370-ibm* | ibm*) basic_machine=i370-ibm ;; i*86v32) basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'` os=-sysv32 ;; i*86v4*) basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'` os=-sysv4 ;; i*86v) basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'` os=-sysv ;; i*86sol2) basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'` os=-solaris2 ;; i386mach) basic_machine=i386-mach os=-mach ;; i386-vsta | vsta) basic_machine=i386-unknown os=-vsta ;; iris | iris4d) basic_machine=mips-sgi case $os in -irix*) ;; *) os=-irix4 ;; esac ;; isi68 | isi) basic_machine=m68k-isi os=-sysv ;; leon-*|leon[3-9]-*) basic_machine=sparc-`echo $basic_machine | sed 's/-.*//'` ;; m68knommu) basic_machine=m68k-unknown os=-linux ;; m68knommu-*) basic_machine=m68k-`echo $basic_machine | sed 's/^[^-]*-//'` os=-linux ;; m88k-omron*) basic_machine=m88k-omron ;; magnum | m3230) basic_machine=mips-mips os=-sysv ;; merlin) basic_machine=ns32k-utek os=-sysv ;; microblaze*) basic_machine=microblaze-xilinx ;; mingw64) basic_machine=x86_64-pc os=-mingw64 ;; mingw32) basic_machine=i686-pc os=-mingw32 ;; mingw32ce) basic_machine=arm-unknown os=-mingw32ce ;; miniframe) basic_machine=m68000-convergent ;; *mint | -mint[0-9]* | *MiNT | *MiNT[0-9]*) basic_machine=m68k-atari os=-mint ;; mips3*-*) basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'` ;; mips3*) basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'`-unknown ;; monitor) basic_machine=m68k-rom68k os=-coff ;; morphos) basic_machine=powerpc-unknown os=-morphos ;; moxiebox) basic_machine=moxie-unknown os=-moxiebox ;; msdos) basic_machine=i386-pc os=-msdos ;; ms1-*) basic_machine=`echo $basic_machine | sed -e 's/ms1-/mt-/'` ;; msys) basic_machine=i686-pc os=-msys ;; mvs) basic_machine=i370-ibm os=-mvs ;; nacl) basic_machine=le32-unknown os=-nacl ;; ncr3000) basic_machine=i486-ncr os=-sysv4 ;; netbsd386) basic_machine=i386-unknown os=-netbsd ;; netwinder) basic_machine=armv4l-rebel os=-linux ;; news | news700 | news800 | news900) basic_machine=m68k-sony os=-newsos ;; news1000) basic_machine=m68030-sony os=-newsos ;; news-3600 | risc-news) basic_machine=mips-sony os=-newsos ;; necv70) basic_machine=v70-nec os=-sysv ;; next | m*-next ) basic_machine=m68k-next case $os in -nextstep* ) ;; -ns2*) os=-nextstep2 ;; *) os=-nextstep3 ;; esac ;; nh3000) basic_machine=m68k-harris os=-cxux ;; nh[45]000) basic_machine=m88k-harris os=-cxux ;; nindy960) basic_machine=i960-intel os=-nindy ;; mon960) basic_machine=i960-intel os=-mon960 ;; nonstopux) basic_machine=mips-compaq os=-nonstopux ;; np1) basic_machine=np1-gould ;; neo-tandem) basic_machine=neo-tandem ;; nse-tandem) basic_machine=nse-tandem ;; nsr-tandem) basic_machine=nsr-tandem ;; op50n-* | op60c-*) basic_machine=hppa1.1-oki os=-proelf ;; openrisc | openrisc-*) basic_machine=or32-unknown ;; os400) basic_machine=powerpc-ibm os=-os400 ;; OSE68000 | ose68000) basic_machine=m68000-ericsson os=-ose ;; os68k) basic_machine=m68k-none os=-os68k ;; pa-hitachi) basic_machine=hppa1.1-hitachi os=-hiuxwe2 ;; paragon) basic_machine=i860-intel os=-osf ;; parisc) basic_machine=hppa-unknown os=-linux ;; parisc-*) basic_machine=hppa-`echo $basic_machine | sed 's/^[^-]*-//'` os=-linux ;; pbd) basic_machine=sparc-tti ;; pbb) basic_machine=m68k-tti ;; pc532 | pc532-*) basic_machine=ns32k-pc532 ;; pc98) basic_machine=i386-pc ;; pc98-*) basic_machine=i386-`echo $basic_machine | sed 's/^[^-]*-//'` ;; pentium | p5 | k5 | k6 | nexgen | viac3) basic_machine=i586-pc ;; pentiumpro | p6 | 6x86 | athlon | athlon_*) basic_machine=i686-pc ;; pentiumii | pentium2 | pentiumiii | pentium3) basic_machine=i686-pc ;; pentium4) basic_machine=i786-pc ;; pentium-* | p5-* | k5-* | k6-* | nexgen-* | viac3-*) basic_machine=i586-`echo $basic_machine | sed 's/^[^-]*-//'` ;; pentiumpro-* | p6-* | 6x86-* | athlon-*) basic_machine=i686-`echo $basic_machine | sed 's/^[^-]*-//'` ;; pentiumii-* | pentium2-* | pentiumiii-* | pentium3-*) basic_machine=i686-`echo $basic_machine | sed 's/^[^-]*-//'` ;; pentium4-*) basic_machine=i786-`echo $basic_machine | sed 's/^[^-]*-//'` ;; pn) basic_machine=pn-gould ;; power) basic_machine=power-ibm ;; ppc | ppcbe) basic_machine=powerpc-unknown ;; ppc-* | ppcbe-*) basic_machine=powerpc-`echo $basic_machine | sed 's/^[^-]*-//'` ;; ppcle | powerpclittle | ppc-le | powerpc-little) basic_machine=powerpcle-unknown ;; ppcle-* | powerpclittle-*) basic_machine=powerpcle-`echo $basic_machine | sed 's/^[^-]*-//'` ;; ppc64) basic_machine=powerpc64-unknown ;; ppc64-*) basic_machine=powerpc64-`echo $basic_machine | sed 's/^[^-]*-//'` ;; ppc64le | powerpc64little | ppc64-le | powerpc64-little) basic_machine=powerpc64le-unknown ;; ppc64le-* | powerpc64little-*) basic_machine=powerpc64le-`echo $basic_machine | sed 's/^[^-]*-//'` ;; ps2) basic_machine=i386-ibm ;; pw32) basic_machine=i586-unknown os=-pw32 ;; rdos | rdos64) basic_machine=x86_64-pc os=-rdos ;; rdos32) basic_machine=i386-pc os=-rdos ;; rom68k) basic_machine=m68k-rom68k os=-coff ;; rm[46]00) basic_machine=mips-siemens ;; rtpc | rtpc-*) basic_machine=romp-ibm ;; s390 | s390-*) basic_machine=s390-ibm ;; s390x | s390x-*) basic_machine=s390x-ibm ;; sa29200) basic_machine=a29k-amd os=-udi ;; sb1) basic_machine=mipsisa64sb1-unknown ;; sb1el) basic_machine=mipsisa64sb1el-unknown ;; sde) basic_machine=mipsisa32-sde os=-elf ;; sei) basic_machine=mips-sei os=-seiux ;; sequent) basic_machine=i386-sequent ;; sh) basic_machine=sh-hitachi os=-hms ;; sh5el) basic_machine=sh5le-unknown ;; sh64) basic_machine=sh64-unknown ;; sparclite-wrs | simso-wrs) basic_machine=sparclite-wrs os=-vxworks ;; sps7) basic_machine=m68k-bull os=-sysv2 ;; spur) basic_machine=spur-unknown ;; st2000) basic_machine=m68k-tandem ;; stratus) basic_machine=i860-stratus os=-sysv4 ;; strongarm-* | thumb-*) basic_machine=arm-`echo $basic_machine | sed 's/^[^-]*-//'` ;; sun2) basic_machine=m68000-sun ;; sun2os3) basic_machine=m68000-sun os=-sunos3 ;; sun2os4) basic_machine=m68000-sun os=-sunos4 ;; sun3os3) basic_machine=m68k-sun os=-sunos3 ;; sun3os4) basic_machine=m68k-sun os=-sunos4 ;; sun4os3) basic_machine=sparc-sun os=-sunos3 ;; sun4os4) basic_machine=sparc-sun os=-sunos4 ;; sun4sol2) basic_machine=sparc-sun os=-solaris2 ;; sun3 | sun3-*) basic_machine=m68k-sun ;; sun4) basic_machine=sparc-sun ;; sun386 | sun386i | roadrunner) basic_machine=i386-sun ;; sv1) basic_machine=sv1-cray os=-unicos ;; symmetry) basic_machine=i386-sequent os=-dynix ;; t3e) basic_machine=alphaev5-cray os=-unicos ;; t90) basic_machine=t90-cray os=-unicos ;; tile*) basic_machine=$basic_machine-unknown os=-linux-gnu ;; tx39) basic_machine=mipstx39-unknown ;; tx39el) basic_machine=mipstx39el-unknown ;; toad1) basic_machine=pdp10-xkl os=-tops20 ;; tower | tower-32) basic_machine=m68k-ncr ;; tpf) basic_machine=s390x-ibm os=-tpf ;; udi29k) basic_machine=a29k-amd os=-udi ;; ultra3) basic_machine=a29k-nyu os=-sym1 ;; v810 | necv810) basic_machine=v810-nec os=-none ;; vaxv) basic_machine=vax-dec os=-sysv ;; vms) basic_machine=vax-dec os=-vms ;; vpp*|vx|vx-*) basic_machine=f301-fujitsu ;; vxworks960) basic_machine=i960-wrs os=-vxworks ;; vxworks68) basic_machine=m68k-wrs os=-vxworks ;; vxworks29k) basic_machine=a29k-wrs os=-vxworks ;; w65*) basic_machine=w65-wdc os=-none ;; w89k-*) basic_machine=hppa1.1-winbond os=-proelf ;; xbox) basic_machine=i686-pc os=-mingw32 ;; xps | xps100) basic_machine=xps100-honeywell ;; xscale-* | xscalee[bl]-*) basic_machine=`echo $basic_machine | sed 's/^xscale/arm/'` ;; ymp) basic_machine=ymp-cray os=-unicos ;; z8k-*-coff) basic_machine=z8k-unknown os=-sim ;; z80-*-coff) basic_machine=z80-unknown os=-sim ;; none) basic_machine=none-none os=-none ;; # Here we handle the default manufacturer of certain CPU types. It is in # some cases the only manufacturer, in others, it is the most popular. w89k) basic_machine=hppa1.1-winbond ;; op50n) basic_machine=hppa1.1-oki ;; op60c) basic_machine=hppa1.1-oki ;; romp) basic_machine=romp-ibm ;; mmix) basic_machine=mmix-knuth ;; rs6000) basic_machine=rs6000-ibm ;; vax) basic_machine=vax-dec ;; pdp10) # there are many clones, so DEC is not a safe bet basic_machine=pdp10-unknown ;; pdp11) basic_machine=pdp11-dec ;; we32k) basic_machine=we32k-att ;; sh[1234] | sh[24]a | sh[24]aeb | sh[34]eb | sh[1234]le | sh[23]ele) basic_machine=sh-unknown ;; sparc | sparcv8 | sparcv9 | sparcv9b | sparcv9v) basic_machine=sparc-sun ;; cydra) basic_machine=cydra-cydrome ;; orion) basic_machine=orion-highlevel ;; orion105) basic_machine=clipper-highlevel ;; mac | mpw | mac-mpw) basic_machine=m68k-apple ;; pmac | pmac-mpw) basic_machine=powerpc-apple ;; *-unknown) # Make sure to match an already-canonicalized machine name. ;; *) echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2 exit 1 ;; esac # Here we canonicalize certain aliases for manufacturers. case $basic_machine in *-digital*) basic_machine=`echo $basic_machine | sed 's/digital.*/dec/'` ;; *-commodore*) basic_machine=`echo $basic_machine | sed 's/commodore.*/cbm/'` ;; *) ;; esac # Decode manufacturer-specific aliases for certain operating systems. if [ x"$os" != x"" ] then case $os in # First match some system type aliases # that might get confused with valid system types. # -solaris* is a basic system type, with this one exception. -auroraux) os=-auroraux ;; -solaris1 | -solaris1.*) os=`echo $os | sed -e 's|solaris1|sunos4|'` ;; -solaris) os=-solaris2 ;; -svr4*) os=-sysv4 ;; -unixware*) os=-sysv4.2uw ;; -gnu/linux*) os=`echo $os | sed -e 's|gnu/linux|linux-gnu|'` ;; # First accept the basic system types. # The portable systems comes first. # Each alternative MUST END IN A *, to match a version number. # -sysv* is not here because it comes later, after sysvr4. -gnu* | -bsd* | -mach* | -minix* | -genix* | -ultrix* | -irix* \ | -*vms* | -sco* | -esix* | -isc* | -aix* | -cnk* | -sunos | -sunos[34]*\ | -hpux* | -unos* | -osf* | -luna* | -dgux* | -auroraux* | -solaris* \ | -sym* | -kopensolaris* | -plan9* \ | -amigaos* | -amigados* | -msdos* | -newsos* | -unicos* | -aof* \ | -aos* | -aros* \ | -nindy* | -vxsim* | -vxworks* | -ebmon* | -hms* | -mvs* \ | -clix* | -riscos* | -uniplus* | -iris* | -rtu* | -xenix* \ | -hiux* | -386bsd* | -knetbsd* | -mirbsd* | -netbsd* \ | -bitrig* | -openbsd* | -solidbsd* \ | -ekkobsd* | -kfreebsd* | -freebsd* | -riscix* | -lynxos* \ | -bosx* | -nextstep* | -cxux* | -aout* | -elf* | -oabi* \ | -ptx* | -coff* | -ecoff* | -winnt* | -domain* | -vsta* \ | -udi* | -eabi* | -lites* | -ieee* | -go32* | -aux* \ | -chorusos* | -chorusrdb* | -cegcc* \ | -cygwin* | -msys* | -pe* | -psos* | -moss* | -proelf* | -rtems* \ | -mingw32* | -mingw64* | -linux-gnu* | -linux-android* \ | -linux-newlib* | -linux-musl* | -linux-uclibc* \ | -uxpv* | -beos* | -mpeix* | -udk* | -moxiebox* \ | -interix* | -uwin* | -mks* | -rhapsody* | -darwin* | -opened* \ | -openstep* | -oskit* | -conix* | -pw32* | -nonstopux* \ | -storm-chaos* | -tops10* | -tenex* | -tops20* | -its* \ | -os2* | -vos* | -palmos* | -uclinux* | -nucleus* \ | -morphos* | -superux* | -rtmk* | -rtmk-nova* | -windiss* \ | -powermax* | -dnix* | -nx6 | -nx7 | -sei* | -dragonfly* \ | -skyos* | -haiku* | -rdos* | -toppers* | -drops* | -es* | -tirtos*) # Remember, each alternative MUST END IN *, to match a version number. ;; -qnx*) case $basic_machine in x86-* | i*86-*) ;; *) os=-nto$os ;; esac ;; -nto-qnx*) ;; -nto*) os=`echo $os | sed -e 's|nto|nto-qnx|'` ;; -sim | -es1800* | -hms* | -xray | -os68k* | -none* | -v88r* \ | -windows* | -osx | -abug | -netware* | -os9* | -beos* | -haiku* \ | -macos* | -mpw* | -magic* | -mmixware* | -mon960* | -lnews*) ;; -mac*) os=`echo $os | sed -e 's|mac|macos|'` ;; -linux-dietlibc) os=-linux-dietlibc ;; -linux*) os=`echo $os | sed -e 's|linux|linux-gnu|'` ;; -sunos5*) os=`echo $os | sed -e 's|sunos5|solaris2|'` ;; -sunos6*) os=`echo $os | sed -e 's|sunos6|solaris3|'` ;; -opened*) os=-openedition ;; -os400*) os=-os400 ;; -wince*) os=-wince ;; -osfrose*) os=-osfrose ;; -osf*) os=-osf ;; -utek*) os=-bsd ;; -dynix*) os=-bsd ;; -acis*) os=-aos ;; -atheos*) os=-atheos ;; -syllable*) os=-syllable ;; -386bsd) os=-bsd ;; -ctix* | -uts*) os=-sysv ;; -nova*) os=-rtmk-nova ;; -ns2 ) os=-nextstep2 ;; -nsk*) os=-nsk ;; # Preserve the version number of sinix5. -sinix5.*) os=`echo $os | sed -e 's|sinix|sysv|'` ;; -sinix*) os=-sysv4 ;; -tpf*) os=-tpf ;; -triton*) os=-sysv3 ;; -oss*) os=-sysv3 ;; -svr4) os=-sysv4 ;; -svr3) os=-sysv3 ;; -sysvr4) os=-sysv4 ;; # This must come after -sysvr4. -sysv*) ;; -ose*) os=-ose ;; -es1800*) os=-ose ;; -xenix) os=-xenix ;; -*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*) os=-mint ;; -aros*) os=-aros ;; -zvmoe) os=-zvmoe ;; -dicos*) os=-dicos ;; -nacl*) ;; -none) ;; *) # Get rid of the `-' at the beginning of $os. os=`echo $os | sed 's/[^-]*-//'` echo Invalid configuration \`$1\': system \`$os\' not recognized 1>&2 exit 1 ;; esac else # Here we handle the default operating systems that come with various machines. # The value should be what the vendor currently ships out the door with their # machine or put another way, the most popular os provided with the machine. # Note that if you're going to try to match "-MANUFACTURER" here (say, # "-sun"), then you have to tell the case statement up towards the top # that MANUFACTURER isn't an operating system. Otherwise, code above # will signal an error saying that MANUFACTURER isn't an operating # system, and we'll never get to this point. case $basic_machine in score-*) os=-elf ;; spu-*) os=-elf ;; *-acorn) os=-riscix1.2 ;; arm*-rebel) os=-linux ;; arm*-semi) os=-aout ;; c4x-* | tic4x-*) os=-coff ;; c8051-*) os=-elf ;; hexagon-*) os=-elf ;; tic54x-*) os=-coff ;; tic55x-*) os=-coff ;; tic6x-*) os=-coff ;; # This must come before the *-dec entry. pdp10-*) os=-tops20 ;; pdp11-*) os=-none ;; *-dec | vax-*) os=-ultrix4.2 ;; m68*-apollo) os=-domain ;; i386-sun) os=-sunos4.0.2 ;; m68000-sun) os=-sunos3 ;; m68*-cisco) os=-aout ;; mep-*) os=-elf ;; mips*-cisco) os=-elf ;; mips*-*) os=-elf ;; or32-*) os=-coff ;; *-tti) # must be before sparc entry or we get the wrong os. os=-sysv3 ;; sparc-* | *-sun) os=-sunos4.1.1 ;; *-be) os=-beos ;; *-haiku) os=-haiku ;; *-ibm) os=-aix ;; *-knuth) os=-mmixware ;; *-wec) os=-proelf ;; *-winbond) os=-proelf ;; *-oki) os=-proelf ;; *-hp) os=-hpux ;; *-hitachi) os=-hiux ;; i860-* | *-att | *-ncr | *-altos | *-motorola | *-convergent) os=-sysv ;; *-cbm) os=-amigaos ;; *-dg) os=-dgux ;; *-dolphin) os=-sysv3 ;; m68k-ccur) os=-rtu ;; m88k-omron*) os=-luna ;; *-next ) os=-nextstep ;; *-sequent) os=-ptx ;; *-crds) os=-unos ;; *-ns) os=-genix ;; i370-*) os=-mvs ;; *-next) os=-nextstep3 ;; *-gould) os=-sysv ;; *-highlevel) os=-bsd ;; *-encore) os=-bsd ;; *-sgi) os=-irix ;; *-siemens) os=-sysv4 ;; *-masscomp) os=-rtu ;; f30[01]-fujitsu | f700-fujitsu) os=-uxpv ;; *-rom68k) os=-coff ;; *-*bug) os=-coff ;; *-apple) os=-macos ;; *-atari*) os=-mint ;; *) os=-none ;; esac fi # Here we handle the case where we know the os, and the CPU type, but not the # manufacturer. We pick the logical manufacturer. vendor=unknown case $basic_machine in *-unknown) case $os in -riscix*) vendor=acorn ;; -sunos*) vendor=sun ;; -cnk*|-aix*) vendor=ibm ;; -beos*) vendor=be ;; -hpux*) vendor=hp ;; -mpeix*) vendor=hp ;; -hiux*) vendor=hitachi ;; -unos*) vendor=crds ;; -dgux*) vendor=dg ;; -luna*) vendor=omron ;; -genix*) vendor=ns ;; -mvs* | -opened*) vendor=ibm ;; -os400*) vendor=ibm ;; -ptx*) vendor=sequent ;; -tpf*) vendor=ibm ;; -vxsim* | -vxworks* | -windiss*) vendor=wrs ;; -aux*) vendor=apple ;; -hms*) vendor=hitachi ;; -mpw* | -macos*) vendor=apple ;; -*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*) vendor=atari ;; -vos*) vendor=stratus ;; esac basic_machine=`echo $basic_machine | sed "s/unknown/$vendor/"` ;; esac echo $basic_machine$os exit # Local variables: # eval: (add-hook 'write-file-hooks 'time-stamp) # time-stamp-start: "timestamp='" # time-stamp-format: "%:y-%02m-%02d" # time-stamp-end: "'" # End: ecl-16.1.2/src/bdwgc/configure000077500000000000000000023330671266352375300161620ustar00rootroot00000000000000#! /bin/sh # Guess values for system-dependent variables and create Makefiles. # Generated by GNU Autoconf 2.69 for gc 7.5.0. # # Report bugs to . # # # 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 and $0: bdwgc@lists.opendylan.org about your system, including $0: any error possibly output before this message. Then $0: install a modern shell, or manually run the script $0: 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='gc' PACKAGE_TARNAME='gc' PACKAGE_VERSION='7.5.0' PACKAGE_STRING='gc 7.5.0' PACKAGE_BUGREPORT='bdwgc@lists.opendylan.org' PACKAGE_URL='' ac_unique_file="gcj_mlc.c" # 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" enable_option_checking=no ac_subst_vars='am__EXEEXT_FALSE am__EXEEXT_TRUE LTLIBOBJS LIBOBJS NEED_ATOMIC_OPS_ASM_FALSE NEED_ATOMIC_OPS_ASM_TRUE USE_INTERNAL_LIBATOMIC_OPS_FALSE USE_INTERNAL_LIBATOMIC_OPS_TRUE subdirs ATOMIC_OPS_LIBS ATOMIC_OPS_CFLAGS PKG_CONFIG_LIBDIR PKG_CONFIG_PATH PKG_CONFIG SINGLE_GC_OBJ_FALSE SINGLE_GC_OBJ_TRUE USE_LIBDIR_FALSE USE_LIBDIR_TRUE UNWINDLIBS ENABLE_DISCLAIM_FALSE ENABLE_DISCLAIM_TRUE KEEP_BACK_PTRS_FALSE KEEP_BACK_PTRS_TRUE MAKE_BACK_GRAPH_FALSE MAKE_BACK_GRAPH_TRUE addlibs addobjs CXXLIBS AM_CPPFLAGS AM_CFLAGS CPLUSPLUS_FALSE CPLUSPLUS_TRUE target_all EXTRA_TEST_LIBS extra_ldflags_libgc AVOID_CPP_LIB_FALSE AVOID_CPP_LIB_TRUE ASM_WITH_CPP_UNSUPPORTED_FALSE ASM_WITH_CPP_UNSUPPORTED_TRUE WIN32_THREADS_FALSE WIN32_THREADS_TRUE DARWIN_THREADS_FALSE DARWIN_THREADS_TRUE PTHREADS_FALSE PTHREADS_TRUE THREADS_FALSE THREADS_TRUE THREADDLLIBS GC_CFLAGS CXXCPP CPP LT_SYS_LIBRARY_PATH OTOOL64 OTOOL LIPO NMEDIT DSYMUTIL MANIFEST_TOOL RANLIB ac_ct_AR AR DLLTOOL OBJDUMP LN_S NM ac_ct_DUMPBIN DUMPBIN LD FGREP EGREP GREP SED LIBTOOL am__fastdepCCAS_FALSE am__fastdepCCAS_TRUE CCASDEPMODE CCASFLAGS CCAS am__fastdepCXX_FALSE am__fastdepCXX_TRUE CXXDEPMODE ac_ct_CXX CXXFLAGS CXX 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 GC_VERSION MAINT MAINTAINER_MODE_FALSE MAINTAINER_MODE_TRUE 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_os target_vendor target_cpu target host_os host_vendor host_cpu host build_os build_vendor build_cpu build 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_maintainer_mode enable_dependency_tracking enable_shared enable_static with_pic enable_fast_install with_aix_soname with_gnu_ld with_sysroot enable_libtool_lock enable_threads enable_parallel_mark enable_cplusplus with_ecos with_target_subdir with_cross_host enable_gcj_support enable_sigrt_signals enable_gc_debug enable_java_finalization enable_atomic_uncollectable enable_redirect_malloc enable_disclaim enable_large_config enable_handle_fork enable_gc_assertions enable_munmap enable_single_obj_compilation with_libatomic_ops ' ac_precious_vars='build_alias host_alias target_alias CC CFLAGS LDFLAGS LIBS CPPFLAGS CXX CXXFLAGS CCC CCAS CCASFLAGS LT_SYS_LIBRARY_PATH CPP CXXCPP PKG_CONFIG PKG_CONFIG_PATH PKG_CONFIG_LIBDIR ATOMIC_OPS_CFLAGS ATOMIC_OPS_LIBS' ac_subdirs_all='libatomic_ops' # 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 gc 7.5.0 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/gc] --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] --target=TARGET configure for building compilers for TARGET [HOST] _ACEOF fi if test -n "$ac_init_help"; then case $ac_init_help in short | recursive ) echo "Configuration of gc 7.5.0:";; 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-maintainer-mode enable make rules and dependencies not useful (and sometimes confusing) to the casual installer --enable-dependency-tracking do not reject slow dependency extractors --disable-dependency-tracking speeds up one-time build --enable-shared[=PKGS] build shared libraries [default=yes] --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-threads=TYPE choose threading package --enable-parallel-mark parallelize marking and free list construction --enable-cplusplus install C++ support --disable-gcj-support Disable support for gcj. --enable-sigrt-signals Force GC to use SIGRTMIN-based signals for thread suspend/resume --enable-gc-debug include full support for pointer backtracing etc. --disable-java-finalization Disable support for java finalization. --disable-atomic-uncollectible Disable support for atomic uncollectible allocation. --enable-redirect-malloc Redirect malloc and friends to GC routines --disable-disclaim Disable alternative (more efficient) finalization interface. --enable-large-config Optimize for large (> 100 MB) heap or root set --enable-handle-fork Attempt to ensure a usable collector after fork() in multi-threaded programs. --enable-gc-assertions collector-internal assertion checking --enable-munmap=N return page to the os if empty for N collections --enable-single-obj-compilation Compile all library .c files into single .o Optional Packages: --with-PACKAGE[=ARG] use PACKAGE [ARG=yes] --without-PACKAGE do not use PACKAGE (same as --with-PACKAGE=no) --with-pic[=PKGS] try to use only PIC/non-PIC objects [default=use both] --with-aix-soname=aix|svr4|both shared library versioning (aka "SONAME") variant to provide on AIX, [default=aix]. --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). --with-ecos enable runtime eCos target support --with-target-subdir=SUBDIR configuring with a cross compiler --with-cross-host=HOST configuring with a cross compiler --with-libatomic-ops=yes|no|check Use a external libatomic_ops? (default: check) 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 CXX C++ compiler command CXXFLAGS C++ compiler flags CCAS assembler compiler command (defaults to CC) CCASFLAGS assembler compiler flags (defaults to CFLAGS) LT_SYS_LIBRARY_PATH User-defined run-time library search path. CPP C preprocessor CXXCPP C++ preprocessor PKG_CONFIG path to pkg-config utility PKG_CONFIG_PATH directories to add to pkg-config's search path PKG_CONFIG_LIBDIR path overriding pkg-config's built-in search path ATOMIC_OPS_CFLAGS C compiler flags for ATOMIC_OPS, overriding pkg-config ATOMIC_OPS_LIBS linker flags for ATOMIC_OPS, overriding pkg-config 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 . _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 gc configure 7.5.0 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_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_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_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 # ac_fn_c_check_header_mongrel LINENO HEADER VAR INCLUDES # ------------------------------------------------------- # Tests whether HEADER exists, giving a warning if it cannot be compiled using # the include files in INCLUDES and setting the cache variable VAR # accordingly. ac_fn_c_check_header_mongrel () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack if eval \${$3+:} false; then : { $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 fi eval ac_res=\$$3 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 $as_echo "$ac_res" >&6; } else # Is the header compilable? { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5 $as_echo_n "checking $2 usability... " >&6; } cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $4 #include <$2> _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_header_compiler=yes else ac_header_compiler=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5 $as_echo "$ac_header_compiler" >&6; } # Is the header present? { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5 $as_echo_n "checking $2 presence... " >&6; } cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include <$2> _ACEOF if ac_fn_c_try_cpp "$LINENO"; then : ac_header_preproc=yes else ac_header_preproc=no fi rm -f conftest.err conftest.i conftest.$ac_ext { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5 $as_echo "$ac_header_preproc" >&6; } # So? What about this header? case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in #(( yes:no: ) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5 $as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;} { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5 $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;} ;; no:yes:* ) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5 $as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;} { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: check for missing prerequisite headers?" >&5 $as_echo "$as_me: WARNING: $2: check for missing prerequisite headers?" >&2;} { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5 $as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;} { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: section \"Present But Cannot Be Compiled\"" >&5 $as_echo "$as_me: WARNING: $2: section \"Present But Cannot Be Compiled\"" >&2;} { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5 $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;} ( $as_echo "## ---------------------------------------- ## ## Report this to bdwgc@lists.opendylan.org ## ## ---------------------------------------- ##" ) | sed "s/^/$as_me: WARNING: /" >&2 ;; esac { $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 eval "$3=\$ac_header_compiler" fi eval ac_res=\$$3 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 $as_echo "$ac_res" >&6; } fi eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno } # ac_fn_c_check_header_mongrel 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 gc $as_me 7.5.0, 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 ## version must conform to [0-9]+[.][0-9]+[.][0-9]+ ac_aux_dir= for ac_dir in "$srcdir" "$srcdir/.." "$srcdir/../.."; do if test -f "$ac_dir/install-sh"; then ac_aux_dir=$ac_dir ac_install_sh="$ac_aux_dir/install-sh -c" break elif test -f "$ac_dir/install.sh"; then ac_aux_dir=$ac_dir ac_install_sh="$ac_aux_dir/install.sh -c" break 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 \"$srcdir\" \"$srcdir/..\" \"$srcdir/../..\"" "$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. # 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 { $as_echo "$as_me:${as_lineno-$LINENO}: checking target system type" >&5 $as_echo_n "checking target system type... " >&6; } if ${ac_cv_target+:} false; then : $as_echo_n "(cached) " >&6 else if test "x$target_alias" = x; then ac_cv_target=$ac_cv_host else ac_cv_target=`$SHELL "$ac_aux_dir/config.sub" $target_alias` || as_fn_error $? "$SHELL $ac_aux_dir/config.sub $target_alias failed" "$LINENO" 5 fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_target" >&5 $as_echo "$ac_cv_target" >&6; } case $ac_cv_target in *-*-*) ;; *) as_fn_error $? "invalid value of canonical target" "$LINENO" 5;; esac target=$ac_cv_target ac_save_IFS=$IFS; IFS='-' set x $ac_cv_target shift target_cpu=$1 target_vendor=$2 shift; shift # Remember, the first character of IFS is used to create $*, # except with old shells: target_os=$* IFS=$ac_save_IFS case $target_os in *\ *) target_os=`echo "$target_os" | sed 's/ /-/g'`;; esac # The aliases save the names the user supplied, while $host etc. # will get canonicalized. test -n "$target_alias" && test "$program_prefix$program_suffix$program_transform_name" = \ NONENONEs,x,x, && program_prefix=${target_alias}- GC_SET_VERSION am__api_version='1.15' # 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 --is-lightweight"; then am_missing_run="$MISSING " 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+set}" != 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='gc' VERSION='7.5.0' 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 (and possibly the TAP driver). 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}' # We'll loop over all known methods to create a tar archive until one works. _am_tools='gnutar pax cpio none' am__tar='$${TAR-tar} chof - "$$tardir"' am__untar='$${TAR-tar} xf -' # POSIX will say in a future version that running "rm -f" with no argument # is OK; and we want to be able to make that assumption in our Makefile # recipes. So use an aggressive probe to check that the usage we want is # actually supported "in the wild" to an acceptable degree. # See automake bug#10828. # To make any issue more visible, cause the running configure to be aborted # by default if the 'rm' program in use doesn't match our expectations; the # user can still override this though. if rm -f && rm -fr && rm -rf; then : OK; else cat >&2 <<'END' Oops! Your 'rm' program seems unable to run without file operands specified on the command line, even when the '-f' option is present. This is contrary to the behaviour of most rm programs out there, and not conforming with the upcoming POSIX standard: Please tell bug-automake@gnu.org about your system, including the value of your $PATH and any error possibly output before this message. This can help us improve future automake versions. END if test x"$ACCEPT_INFERIOR_RM_PROGRAM" = x"yes"; then echo 'Configuration will proceed anyway, since you have set the' >&2 echo 'ACCEPT_INFERIOR_RM_PROGRAM variable to "yes"' >&2 echo >&2 else cat >&2 <<'END' Aborting the configuration process, to ensure you take notice of the issue. You can download and install GNU coreutils to get an 'rm' implementation that behaves properly: . If you want to complete the configuration process using your problematic 'rm' anyway, export the environment variable ACCEPT_INFERIOR_RM_PROGRAM to "yes", and re-run configure. END as_fn_error $? "Your 'rm' program is bad, sorry." "$LINENO" 5 fi fi ac_config_headers="$ac_config_headers include/config.h" { $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 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 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 $CC understands -c and -o together" >&5 $as_echo_n "checking whether $CC understands -c and -o together... " >&6; } if ${am_cv_prog_cc_c_o+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF # Make sure it works both with $CC and with simple cc. # Following AC_PROG_CC_C_O, we do the test twice because some # compilers refuse to overwrite an existing .o file with -o, # though they will create one. am_cv_prog_cc_c_o=yes for am_i in 1 2; do if { echo "$as_me:$LINENO: $CC -c conftest.$ac_ext -o conftest2.$ac_objext" >&5 ($CC -c conftest.$ac_ext -o conftest2.$ac_objext) >&5 2>&5 ac_status=$? echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } \ && test -f conftest2.$ac_objext; then : OK else am_cv_prog_cc_c_o=no break fi done rm -f core conftest* unset am_i fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_prog_cc_c_o" >&5 $as_echo "$am_cv_prog_cc_c_o" >&6; } if test "$am_cv_prog_cc_c_o" != yes; then # Losing compiler, so override with the script. # FIXME: It is wrong to rewrite CC. # 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__CC in this case, # and then we could set am__CC="\$(top_srcdir)/compile \$(CC)" CC="$am_aux_dir/compile $CC" 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 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 # By default we simply use the C compiler to build assembly code. test "${CCAS+set}" = set || CCAS=$CC test "${CCASFLAGS+set}" = set || CCASFLAGS=$CFLAGS depcc="$CCAS" 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_CCAS_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_CCAS_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 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_CCAS_dependencies_compiler_type=$depmode break fi fi done cd .. rm -rf conftest.dir else am_cv_CCAS_dependencies_compiler_type=none fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_CCAS_dependencies_compiler_type" >&5 $as_echo "$am_cv_CCAS_dependencies_compiler_type" >&6; } CCASDEPMODE=depmode=$am_cv_CCAS_dependencies_compiler_type if test "x$enable_dependency_tracking" != xno \ && test "$am_cv_CCAS_dependencies_compiler_type" = gcc3; then am__fastdepCCAS_TRUE= am__fastdepCCAS_FALSE='#' else am__fastdepCCAS_TRUE='#' am__fastdepCCAS_FALSE= fi 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.6' macro_revision='2.4.6' ltmain=$ac_aux_dir/ltmain.sh # 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 no = "$withval" || with_gnu_ld=yes else with_gnu_ld=no fi ac_prog=ld if test yes = "$GCC"; 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 yes = "$with_gnu_ld"; 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 # MSYS converts /dev/null to NUL, MinGW nm treats NUL as empty case $build_os in mingw*) lt_bad_file=conftest.nm/nofile ;; *) lt_bad_file=/dev/null ;; esac case `"$tmp_nm" -B $lt_bad_file 2>&1 | sed '1q'` in *$lt_bad_file* | *'Invalid file or object type'*) lt_cv_path_NM="$tmp_nm -B" break 2 ;; *) case `"$tmp_nm" -p /dev/null 2>&1 | sed '1q'` in */dev/null*) lt_cv_path_NM="$tmp_nm -p" break 2 ;; *) 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 no != "$lt_cv_path_NM"; 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 -headers /dev/null 2>&1 | sed '1q'` in *COFF*) DUMPBIN="$DUMPBIN -symbols -headers" ;; *) 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; ;; bitrig* | darwin* | dragonfly* | freebsd* | netbsd* | openbsd*) # 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 ;; os2*) # The test takes a long time on OS/2. lt_cv_sys_max_cmd_len=8192 ;; 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" && \ test undefined != "$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`env echo "$teststring$teststring" 2>/dev/null` \ = "X$teststring$teststring"; } >/dev/null 2>&1 && test 17 != "$i" # 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"} 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 yes != "$GCC"; then reload_cmds=false fi ;; darwin*) if test yes = "$GCC"; 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 # that 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. if ( 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 ;; 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 glibc/ELF. linux* | k*bsd*-gnu | kopensolaris*-gnu | 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* | bitrig*) if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`"; 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 ;; os2*) 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 one 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 0 -eq "$ac_status"; 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 0 -ne "$ac_status"; 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 no = "$lt_cv_ar_at_file"; 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 bitrig* | openbsd*) old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB -t \$tool_oldlib" ;; *) old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB \$tool_oldlib" ;; esac old_archive_cmds="$old_archive_cmds~\$RANLIB \$tool_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 ia64 = "$host_cpu"; 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 if test "$lt_cv_nm_interface" = "MS dumpbin"; then # Gets list of data symbols to import. lt_cv_sys_global_symbol_to_import="sed -n -e 's/^I .* \(.*\)$/\1/p'" # Adjust the below global symbol transforms to fixup imported variables. lt_cdecl_hook=" -e 's/^I .* \(.*\)$/extern __declspec(dllimport) char \1;/p'" lt_c_name_hook=" -e 's/^I .* \(.*\)$/ {\"\1\", (void *) 0},/p'" lt_c_name_lib_hook="\ -e 's/^I .* \(lib.*\)$/ {\"\1\", (void *) 0},/p'\ -e 's/^I .* \(.*\)$/ {\"lib\1\", (void *) 0},/p'" else # Disable hooks by default. lt_cv_sys_global_symbol_to_import= lt_cdecl_hook= lt_c_name_hook= lt_c_name_lib_hook= fi # 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"\ $lt_cdecl_hook\ " -e 's/^T .* \(.*\)$/extern int \1();/p'"\ " -e 's/^$symcode$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"\ $lt_c_name_hook\ " -e 's/^: \(.*\) .*$/ {\"\1\", (void *) 0},/p'"\ " -e 's/^$symcode$symcode* .* \(.*\)$/ {\"\1\", (void *) \&\1},/p'" # Transform an extracted symbol line into symbol name with lib prefix and # symbol address. lt_cv_sys_global_symbol_to_c_name_address_lib_prefix="sed -n"\ $lt_c_name_lib_hook\ " -e 's/^: \(.*\) .*$/ {\"\1\", (void *) 0},/p'"\ " -e 's/^$symcode$symcode* .* \(lib.*\)$/ {\"\1\", (void *) \&\1},/p'"\ " -e 's/^$symcode$symcode* .* \(.*\)$/ {\"lib\1\", (void *) \&\1},/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, # D for any global variable and I for any imported 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};"\ " /^COFF SYMBOL TABLE/{for(i in hide) delete hide[i]};"\ " /Section length .*#relocs.*(pick any)/{hide[last_section]=1};"\ " /^ *Symbol name *: /{split(\$ 0,sn,\":\"); si=substr(sn[2],2)};"\ " /^ *Type *: code/{print \"T\",si,substr(si,length(prfx))};"\ " /^ *Type *: data/{print \"I\",si,substr(si,length(prfx))};"\ " \$ 0!~/External *\|/{next};"\ " / 0+ UNDEF /{next}; / UNDEF \([^|]\)*()/{next};"\ " {if(hide[section]) next};"\ " {f=\"D\"}; \$ 0~/\(\).*\|/{f=\"T\"};"\ " {split(\$ 0,a,/\||\r/); split(a[2],s)};"\ " s[1]~/^[@?]/{print f,s[1],s[1]; next};"\ " s[1]~prfx {split(s[1],t,\"@\"); print f,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 can'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* .* \(.*\)$/ {\"\1\", (void *) \&\1},/" < "$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 yes = "$pipe_works"; 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 yes = "$GCC"; 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; } { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a working dd" >&5 $as_echo_n "checking for a working dd... " >&6; } if ${ac_cv_path_lt_DD+:} false; then : $as_echo_n "(cached) " >&6 else printf 0123456789abcdef0123456789abcdef >conftest.i cat conftest.i conftest.i >conftest2.i : ${lt_DD:=$DD} if test -z "$lt_DD"; then ac_path_lt_DD_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 dd; do for ac_exec_ext in '' $ac_executable_extensions; do ac_path_lt_DD="$as_dir/$ac_prog$ac_exec_ext" as_fn_executable_p "$ac_path_lt_DD" || continue if "$ac_path_lt_DD" bs=32 count=1 conftest.out 2>/dev/null; then cmp -s conftest.i conftest.out \ && ac_cv_path_lt_DD="$ac_path_lt_DD" ac_path_lt_DD_found=: fi $ac_path_lt_DD_found && break 3 done done done IFS=$as_save_IFS if test -z "$ac_cv_path_lt_DD"; then : fi else ac_cv_path_lt_DD=$lt_DD fi rm -f conftest.i conftest2.i conftest.out fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_lt_DD" >&5 $as_echo "$ac_cv_path_lt_DD" >&6; } { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to truncate binary pipes" >&5 $as_echo_n "checking how to truncate binary pipes... " >&6; } if ${lt_cv_truncate_bin+:} false; then : $as_echo_n "(cached) " >&6 else printf 0123456789abcdef0123456789abcdef >conftest.i cat conftest.i conftest.i >conftest2.i lt_cv_truncate_bin= if "$ac_cv_path_lt_DD" bs=32 count=1 conftest.out 2>/dev/null; then cmp -s conftest.i conftest.out \ && lt_cv_truncate_bin="$ac_cv_path_lt_DD bs=4096 count=1" fi rm -f conftest.i conftest2.i conftest.out test -z "$lt_cv_truncate_bin" && lt_cv_truncate_bin="$SED -e 4q" fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_truncate_bin" >&5 $as_echo "$lt_cv_truncate_bin" >&6; } # Calculate cc_basename. Skip known compiler wrappers and cross-prefix. func_cc_basename () { for cc_temp in $*""; do case $cc_temp in compile | *[\\/]compile | ccache | *[\\/]ccache ) ;; distcc | *[\\/]distcc | purify | *[\\/]purify ) ;; \-*) ;; *) break;; esac done func_cc_basename_result=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"` } # Check whether --enable-libtool-lock was given. if test "${enable_libtool_lock+set}" = set; then : enableval=$enable_libtool_lock; fi test no = "$enable_libtool_lock" || 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 what ABI is being produced by ac_compile, and set mode # options accordingly. 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 what ABI is being produced by ac_compile, and set linker # options accordingly. 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 yes = "$lt_cv_prog_gnu_ld"; 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* ;; mips64*-*linux*) # Find out what ABI is being produced by ac_compile, and set linker # options accordingly. 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 emul=elf case `/usr/bin/file conftest.$ac_objext` in *32-bit*) emul="${emul}32" ;; *64-bit*) emul="${emul}64" ;; esac case `/usr/bin/file conftest.$ac_objext` in *MSB*) emul="${emul}btsmip" ;; *LSB*) emul="${emul}ltsmip" ;; esac case `/usr/bin/file conftest.$ac_objext` in *N32*) emul="${emul}n32" ;; esac LD="${LD-ld} -m $emul" fi rm -rf conftest* ;; x86_64-*kfreebsd*-gnu|x86_64-*linux*|powerpc*-*linux*| \ s390*-*linux*|s390*-*tpf*|sparc*-*linux*) # Find out what ABI is being produced by ac_compile, and set linker # options accordingly. Note that the listed cases only cover the # situations where additional linker options are needed (such as when # doing 32-bit compilation for a host where ld defaults to 64-bit, or # vice versa); the common cases where no linker options are needed do # not appear in the list. 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*) case `/usr/bin/file conftest.o` in *x86-64*) LD="${LD-ld} -m elf32_x86_64" ;; *) LD="${LD-ld} -m elf_i386" ;; esac ;; powerpc64le-*linux*) LD="${LD-ld} -m elf32lppclinux" ;; 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" ;; powerpcle-*linux*) LD="${LD-ld} -m elf64lppc" ;; 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 yes != "$lt_cv_cc_needs_belf"; then # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf CFLAGS=$SAVE_CFLAGS fi ;; *-*solaris*) # Find out what ABI is being produced by ac_compile, and set linker # options accordingly. 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*) case $host in i?86-*-solaris*|x86_64-*-solaris*) LD="${LD-ld} -m elf_x86_64" ;; sparc*-*-solaris*) LD="${LD-ld} -m elf64_sparc" ;; esac # GNU ld 2.21 introduced _sol2 emulations. Use them if available. if ${LD-ld} -V | grep _sol2 >/dev/null 2>&1; then LD=${LD-ld}_sol2 fi ;; *) 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 yes != "$lt_cv_path_mainfest_tool"; 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 there is a non-empty error log, and "single_module" # appears in it, assume the flag caused a linker warning if test -s conftest.err && $GREP single_module conftest.err; then cat conftest.err >&5 # Otherwise, if the output was created with a 0 exit code from # the compiler, it worked. elif test -f libconftest.dylib && test 0 = "$_lt_result"; 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 -s conftest.err && $GREP force_load conftest.err; then cat conftest.err >&5 elif test -f conftest && test 0 = "$_lt_result" && $GREP forced_load conftest >/dev/null 2>&1; 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 yes = "$lt_cv_apple_cc_single_mod"; then _lt_dar_single_mod='$single_module' fi if test yes = "$lt_cv_ld_exported_symbols_list"; 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 no = "$lt_cv_ld_force_load"; then _lt_dsymutil='~$DSYMUTIL $lib || :' else _lt_dsymutil= fi ;; esac # func_munge_path_list VARIABLE PATH # ----------------------------------- # VARIABLE is name of variable containing _space_ separated list of # directories to be munged by the contents of PATH, which is string # having a format: # "DIR[:DIR]:" # string "DIR[ DIR]" will be prepended to VARIABLE # ":DIR[:DIR]" # string "DIR[ DIR]" will be appended to VARIABLE # "DIRP[:DIRP]::[DIRA:]DIRA" # string "DIRP[ DIRP]" will be prepended to VARIABLE and string # "DIRA[ DIRA]" will be appended to VARIABLE # "DIR[:DIR]" # VARIABLE will be replaced by "DIR[ DIR]" func_munge_path_list () { case x$2 in x) ;; *:) eval $1=\"`$ECHO $2 | $SED 's/:/ /g'` \$$1\" ;; x:*) eval $1=\"\$$1 `$ECHO $2 | $SED 's/:/ /g'`\" ;; *::*) eval $1=\"\$$1\ `$ECHO $2 | $SED -e 's/.*:://' -e 's/:/ /g'`\" eval $1=\"`$ECHO $2 | $SED -e 's/::.*//' -e 's/:/ /g'`\ \$$1\" ;; *) eval $1=\"`$ECHO $2 | $SED 's/:/ /g'`\" ;; 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 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 # Set options enable_dlopen=no enable_win32_dll=no # 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=yes fi # 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; lt_p=${PACKAGE-default} case $withval in yes|no) pic_mode=$withval ;; *) pic_mode=default # Look at the argument we got. We use all the common list separators. lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR, for lt_pkg in $withval; do IFS=$lt_save_ifs if test "X$lt_pkg" = "X$lt_p"; then pic_mode=yes fi done IFS=$lt_save_ifs ;; esac else pic_mode=default fi # 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 shared_archive_member_spec= case $host,$enable_shared in power*-*-aix[5-9]*,yes) { $as_echo "$as_me:${as_lineno-$LINENO}: checking which variant of shared library versioning to provide" >&5 $as_echo_n "checking which variant of shared library versioning to provide... " >&6; } # Check whether --with-aix-soname was given. if test "${with_aix_soname+set}" = set; then : withval=$with_aix_soname; case $withval in aix|svr4|both) ;; *) as_fn_error $? "Unknown argument to --with-aix-soname" "$LINENO" 5 ;; esac lt_cv_with_aix_soname=$with_aix_soname else if ${lt_cv_with_aix_soname+:} false; then : $as_echo_n "(cached) " >&6 else lt_cv_with_aix_soname=aix fi with_aix_soname=$lt_cv_with_aix_soname fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $with_aix_soname" >&5 $as_echo "$with_aix_soname" >&6; } if test aix != "$with_aix_soname"; then # For the AIX way of multilib, we name the shared archive member # based on the bitwidth used, traditionally 'shr.o' or 'shr_64.o', # and 'shr.imp' or 'shr_64.imp', respectively, for the Import File. # Even when GNU compilers ignore OBJECT_MODE but need '-maix64' flag, # the AIX toolchain works better with OBJECT_MODE set (default 32). if test 64 = "${OBJECT_MODE-32}"; then shared_archive_member_spec=shr_64 else shared_archive_member_spec=shr fi fi ;; *) with_aix_soname=aix ;; esac # 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 set != "${COLLECT_NAMES+set}"; 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 func_cc_basename $compiler cc_basename=$func_cc_basename_result # 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 yes = "$GCC"; 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" ## exclude from sc_useless_quotes_in_assignment # 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 yes = "$lt_cv_prog_compiler_rtti_exceptions"; 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 yes = "$GCC"; then lt_prog_compiler_wl='-Wl,' lt_prog_compiler_static='-static' case $host_os in aix*) # All AIX code is PIC. if test ia64 = "$host_cpu"; then # AIX 5 now supports IA64 processor lt_prog_compiler_static='-Bstatic' fi lt_prog_compiler_pic='-fPIC' ;; 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' case $host_os in os2*) lt_prog_compiler_static='$wl-static' ;; esac ;; 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 ' if test -n "$lt_prog_compiler_pic"; then lt_prog_compiler_pic="-Xcompiler $lt_prog_compiler_pic" fi ;; 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 ia64 = "$host_cpu"; then # AIX 5 now supports IA64 processor lt_prog_compiler_static='-Bstatic' else lt_prog_compiler_static='-bnso -bI:/lib/syscalls.exp' fi ;; darwin* | rhapsody*) # PIC is the default on this platform # Common symbols not allowed in MH_DYLIB files lt_prog_compiler_pic='-fno-common' case $cc_basename in nagfor*) # NAG Fortran compiler lt_prog_compiler_wl='-Wl,-Wl,,' lt_prog_compiler_pic='-PIC' lt_prog_compiler_static='-Bstatic' ;; esac ;; 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' case $host_os in os2*) lt_prog_compiler_static='$wl-static' ;; esac ;; 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 | 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' ;; tcc*) # Fabrice Bellard et al's Tiny C Compiler lt_prog_compiler_wl='-Wl,' lt_prog_compiler_pic='-fPIC' lt_prog_compiler_static='-static' ;; 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\ Ceres\ Fortran* | *Sun*Fortran*\ [1-7].* | *Sun*Fortran*\ 8.[0-3]*) # 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\ F* | *Sun*Fortran*) lt_prog_compiler_pic='-KPIC' lt_prog_compiler_static='-Bstatic' lt_prog_compiler_wl='-Qoption ld ' ;; *Sun\ C*) # Sun C 5.9 lt_prog_compiler_pic='-KPIC' lt_prog_compiler_static='-Bstatic' lt_prog_compiler_wl='-Wl,' ;; *Intel*\ [CF]*Compiler*) lt_prog_compiler_wl='-Wl,' lt_prog_compiler_pic='-fPIC' lt_prog_compiler_static='-static' ;; *Portland\ Group*) lt_prog_compiler_wl='-Wl,' lt_prog_compiler_pic='-fpic' lt_prog_compiler_static='-Bstatic' ;; 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 that 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" ## exclude from sc_useless_quotes_in_assignment # 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 yes = "$lt_cv_prog_compiler_pic_works"; 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 yes = "$lt_cv_prog_compiler_static_works"; 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 no = "$lt_cv_prog_compiler_c_o" && test no != "$need_locks"; 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 no = "$hard_links"; 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_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 yes != "$GCC"; then with_gnu_ld=no fi ;; interix*) # we just hope/assume this is gcc and not c89 (= MSVC++) with_gnu_ld=yes ;; openbsd* | bitrig*) 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 yes = "$with_gnu_ld"; 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 yes = "$lt_use_gnu_ld_interface"; 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 | $SED -e 's/(^)\+)\s\+//' 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 ia64 != "$host_cpu"; 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, use it as # is; otherwise, prepend EXPORTS... archive_expsym_cmds='if test DEF = "`$SED -n -e '\''s/^[ ]*//'\'' -e '\''/^\(;.*\)*$/d'\'' -e '\''s/^\(EXPORTS\|LIBRARY\)\([ ].*\)*$/DEF/p'\'' -e q $export_symbols`" ; 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 ;; os2*) hardcode_libdir_flag_spec='-L$libdir' hardcode_minus_L=yes allow_undefined_flag=unsupported shrext_cmds=.dll archive_cmds='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~ $ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~ $ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~ $ECHO EXPORTS >> $output_objdir/$libname.def~ emxexp $libobjs | $SED /"_DLL_InitTerm"/d >> $output_objdir/$libname.def~ $CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~ emximp -o $lib $output_objdir/$libname.def' archive_expsym_cmds='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~ $ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~ $ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~ $ECHO EXPORTS >> $output_objdir/$libname.def~ prefix_cmds="$SED"~ if test EXPORTS = "`$SED 1q $export_symbols`"; then prefix_cmds="$prefix_cmds -e 1d"; fi~ prefix_cmds="$prefix_cmds -e \"s/^\(.*\)$/_\1/g\""~ cat $export_symbols | $prefix_cmds >> $output_objdir/$libname.def~ $CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~ emximp -o $lib $output_objdir/$libname.def' old_archive_From_new_cmds='emximp -o $output_objdir/${libname}_dll.a $output_objdir/$libname.def' enable_shared_with_static_runtimes=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 linux-dietlibc = "$host_os"; 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 no = "$tmp_diet" 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' ;; nagfor*) # NAGFOR 5.3 tmp_sharedflag='-Wl,-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 yes = "$supports_anon_versioning"; 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 tcc*) export_dynamic_flag_spec='-rdynamic' ;; 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='$wl-rpath $wl$libdir' archive_cmds='$LD -shared $libobjs $deplibs $linker_flags -soname $soname -o $lib' if test yes = "$supports_anon_versioning"; 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 cannot *** 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 no = "$ld_shlibs"; 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 yes = "$GCC" && 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 ia64 = "$host_cpu"; 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 GNU nm, but means don't demangle to AIX nm. # Without the "-l" option, or with the "-B" option, AIX nm treats # weak defined symbols like other global defined symbols, whereas # GNU nm marks them as "W". # While the 'weak' keyword is ignored in the Export File, we need # it in the Import File for the 'aix-soname' feature, so we have # to replace the "-B" option with "-P" for AIX nm. 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) != ".")) { if (\$ 2 == "W") { print \$ 3 " weak" } else { print \$ 3 } } }'\'' | sort -u > $export_symbols' else export_symbols_cmds='`func_echo_all $NM | $SED -e '\''s/B\([^B]*\)$/P\1/'\''` -PCpgl $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) && (substr(\$ 1,1,1) != ".")) { if ((\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) { print \$ 1 " weak" } else { print \$ 1 } } }'\'' | 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 # have runtime linking enabled, and use it for executables. # For shared libraries, we enable/disable runtime linking # depending on the kind of the shared library created - # when "with_aix_soname,aix_use_runtimelinking" is: # "aix,no" lib.a(lib.so.V) shared, rtl:no, for executables # "aix,yes" lib.so shared, rtl:yes, for executables # lib.a static archive # "both,no" lib.so.V(shr.o) shared, rtl:yes # lib.a(lib.so.V) shared, rtl:no, for executables # "both,yes" lib.so.V(shr.o) shared, rtl:yes, for executables # lib.a(lib.so.V) shared, rtl:no # "svr4,*" lib.so.V(shr.o) shared, rtl:yes, for executables # lib.a static archive case $host_os in aix4.[23]|aix4.[23].*|aix[5-9]*) for ld_flag in $LDFLAGS; do if (test x-brtl = "x$ld_flag" || test x-Wl,-brtl = "x$ld_flag"); then aix_use_runtimelinking=yes break fi done if test svr4,no = "$with_aix_soname,$aix_use_runtimelinking"; then # With aix-soname=svr4, we create the lib.so.V shared archives only, # so we don't have lib.a shared libs to link our executables. # We have to force runtime linking in this case. aix_use_runtimelinking=yes LDFLAGS="$LDFLAGS -Wl,-brtl" fi ;; 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,' case $with_aix_soname,$aix_use_runtimelinking in aix,*) ;; # traditional, no import file svr4,* | *,yes) # use import file # The Import File defines what to hardcode. hardcode_direct=no hardcode_direct_absolute=no ;; esac if test yes = "$GCC"; 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 yes = "$aix_use_runtimelinking"; then shared_flag="$shared_flag "'$wl-G' fi # Need to ensure runtime linking is disabled for the traditional # shared library, or the linker may eventually find shared libraries # /with/ Import File - we do not want to mix them. shared_flag_aix='-shared' shared_flag_svr4='-shared $wl-G' else # not using gcc if test ia64 = "$host_cpu"; 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 yes = "$aix_use_runtimelinking"; then shared_flag='$wl-G' else shared_flag='$wl-bM:SRE' fi shared_flag_aix='$wl-bM:SRE' shared_flag_svr4='$wl-G' 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,yes = "$with_aix_soname,$aix_use_runtimelinking"; 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 set = "${lt_cv_aix_libpath+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 -n "$allow_undefined_flag"; then func_echo_all "$wl$allow_undefined_flag"; else :; fi` $wl'$exp_sym_flag:\$export_symbols' '$shared_flag else if test ia64 = "$host_cpu"; 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 set = "${lt_cv_aix_libpath+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 yes = "$with_gnu_ld"; 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 archive_expsym_cmds='$RM -r $output_objdir/$realname.d~$MKDIR $output_objdir/$realname.d' # -brtl affects multiple linker settings, -berok does not and is overridden later compiler_flags_filtered='`func_echo_all "$compiler_flags " | $SED -e "s%-brtl\\([, ]\\)%-berok\\1%g"`' if test svr4 != "$with_aix_soname"; then # This is similar to how AIX traditionally builds its shared libraries. archive_expsym_cmds="$archive_expsym_cmds"'~$CC '$shared_flag_aix' -o $output_objdir/$realname.d/$soname $libobjs $deplibs $wl-bnoentry '$compiler_flags_filtered'$wl-bE:$export_symbols$allow_undefined_flag~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$realname.d/$soname' fi if test aix != "$with_aix_soname"; then archive_expsym_cmds="$archive_expsym_cmds"'~$CC '$shared_flag_svr4' -o $output_objdir/$realname.d/$shared_archive_member_spec.o $libobjs $deplibs $wl-bnoentry '$compiler_flags_filtered'$wl-bE:$export_symbols$allow_undefined_flag~$STRIP -e $output_objdir/$realname.d/$shared_archive_member_spec.o~( func_echo_all "#! $soname($shared_archive_member_spec.o)"; if test shr_64 = "$shared_archive_member_spec"; then func_echo_all "# 64"; else func_echo_all "# 32"; fi; cat $export_symbols ) > $output_objdir/$realname.d/$shared_archive_member_spec.imp~$AR $AR_FLAGS $output_objdir/$soname $output_objdir/$realname.d/$shared_archive_member_spec.o $output_objdir/$realname.d/$shared_archive_member_spec.imp' else # used by -dlpreopen to get the symbols archive_expsym_cmds="$archive_expsym_cmds"'~$MV $output_objdir/$realname.d/$soname $output_objdir' fi archive_expsym_cmds="$archive_expsym_cmds"'~$RM -r $output_objdir/$realname.d' 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,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~linknames=' archive_expsym_cmds='if test DEF = "`$SED -n -e '\''s/^[ ]*//'\'' -e '\''/^\(;.*\)*$/d'\'' -e '\''s/^\(EXPORTS\|LIBRARY\)\([ ].*\)*$/DEF/p'\'' -e q $export_symbols`" ; then cp "$export_symbols" "$output_objdir/$soname.def"; echo "$tool_output_objdir$soname.def" > "$output_objdir/$soname.exp"; else $SED -e '\''s/^/-link -EXPORT:/'\'' < $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 exclude_expsyms='_NULL_IMPORT_DESCRIPTOR|_IMPORT_DESCRIPTOR_.*' 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 yes = "$lt_cv_ld_force_load"; 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*|nagfor*) _lt_dar_can_shared=yes ;; *) _lt_dar_can_shared=$GCC ;; esac if test yes = "$_lt_dar_can_shared"; 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 ;; # 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 yes = "$GCC"; 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 "x$output_objdir/$soname" = "x$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 "x$output_objdir/$soname" = "x$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 yes,no = "$GCC,$with_gnu_ld"; 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 no = "$with_gnu_ld"; then hardcode_libdir_flag_spec='$wl+b $wl$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 yes,no = "$GCC,$with_gnu_ld"; 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 yes = "$lt_cv_prog_compiler__b"; 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 no = "$with_gnu_ld"; 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 yes = "$GCC"; 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 yes = "$lt_cv_irix_exported_symbol"; 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 ;; linux*) case $cc_basename in tcc*) # Fabrice Bellard et al's Tiny C Compiler ld_shlibs=yes archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags' ;; esac ;; 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* | bitrig*) 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__`"; 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 archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags' hardcode_libdir_flag_spec='$wl-rpath,$libdir' fi else ld_shlibs=no fi ;; os2*) hardcode_libdir_flag_spec='-L$libdir' hardcode_minus_L=yes allow_undefined_flag=unsupported shrext_cmds=.dll archive_cmds='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~ $ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~ $ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~ $ECHO EXPORTS >> $output_objdir/$libname.def~ emxexp $libobjs | $SED /"_DLL_InitTerm"/d >> $output_objdir/$libname.def~ $CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~ emximp -o $lib $output_objdir/$libname.def' archive_expsym_cmds='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~ $ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~ $ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~ $ECHO EXPORTS >> $output_objdir/$libname.def~ prefix_cmds="$SED"~ if test EXPORTS = "`$SED 1q $export_symbols`"; then prefix_cmds="$prefix_cmds -e 1d"; fi~ prefix_cmds="$prefix_cmds -e \"s/^\(.*\)$/_\1/g\""~ cat $export_symbols | $prefix_cmds >> $output_objdir/$libname.def~ $CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~ emximp -o $lib $output_objdir/$libname.def' old_archive_From_new_cmds='emximp -o $output_objdir/${libname}_dll.a $output_objdir/$libname.def' enable_shared_with_static_runtimes=yes ;; osf3*) if test yes = "$GCC"; 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 yes = "$GCC"; 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 yes = "$GCC"; 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 yes = "$GCC"; 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 sequent = "$host_vendor"; 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 yes = "$GCC"; 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 CANNOT 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 yes = "$GCC"; 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 sni = "$host_vendor"; 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 no = "$ld_shlibs" && 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 yes,yes = "$GCC,$enable_shared"; 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 yes = "$GCC"; 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` # ...but if some path component already ends with the multilib dir we assume # that all is fine and trust -print-search-dirs as is (GCC 4.2? or newer). case "$lt_multi_os_dir; $lt_search_path_spec " in "/; "* | "/.; "* | "/./; "* | *"$lt_multi_os_dir "* | *"$lt_multi_os_dir/ "*) lt_multi_os_dir= ;; esac 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" elif test -n "$lt_multi_os_dir"; then 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 # correct to gnu/linux during the next big refactor 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 # correct to gnu/linux during the next big refactor need_lib_prefix=no need_version=no hardcode_into_libs=yes if test ia64 = "$host_cpu"; 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 # Using Import Files as archive members, it is possible to support # filename-based versioning of shared library archives on AIX. While # this would work for both with and without runtime linking, it will # prevent static linking of such archives. So we do filename-based # shared library versioning with .so extension only, which is used # when both runtime linking and shared linking is enabled. # Unfortunately, runtime linking may impact performance, so we do # not want this to be the default eventually. Also, we use the # versioned .so libs for executables only if there is the -brtl # linker flag in LDFLAGS as well, or --with-aix-soname=svr4 only. # To allow for filename-based versioning support, we need to create # libNAME.so.V as an archive file, containing: # *) an Import File, referring to the versioned filename of the # archive as well as the shared archive member, telling the # bitwidth (32 or 64) of that shared object, and providing the # list of exported symbols of that shared object, eventually # decorated with the 'weak' keyword # *) the shared object with the F_LOADONLY flag set, to really avoid # it being seen by the linker. # At run time we better use the real file rather than another symlink, # but for link time we create the symlink libNAME.so -> libNAME.so.V case $with_aix_soname,$aix_use_runtimelinking in # AIX (on Power*) has no versioning support, so currently we cannot hardcode correct # soname into executable. Probably we can add versioning support to # collect2, so additional links can be useful in future. aix,yes) # traditional libtool dynamic_linker='AIX unversionable lib.so' # 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' ;; aix,no) # traditional AIX only dynamic_linker='AIX lib.a(lib.so.V)' # 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' ;; svr4,*) # full svr4 only dynamic_linker="AIX lib.so.V($shared_archive_member_spec.o)" library_names_spec='$libname$release$shared_ext$major $libname$shared_ext' # We do not specify a path in Import Files, so LIBPATH fires. shlibpath_overrides_runpath=yes ;; *,yes) # both, prefer svr4 dynamic_linker="AIX lib.so.V($shared_archive_member_spec.o), lib.a(lib.so.V)" library_names_spec='$libname$release$shared_ext$major $libname$shared_ext' # unpreferred sharedlib libNAME.a needs extra handling postinstall_cmds='test -n "$linkname" || linkname="$realname"~func_stripname "" ".so" "$linkname"~$install_shared_prog "$dir/$func_stripname_result.$libext" "$destdir/$func_stripname_result.$libext"~test -z "$tstripme" || test -z "$striplib" || $striplib "$destdir/$func_stripname_result.$libext"' postuninstall_cmds='for n in $library_names $old_library; do :; done~func_stripname "" ".so" "$n"~test "$func_stripname_result" = "$n" || func_append rmfiles " $odir/$func_stripname_result.$libext"' # We do not specify a path in Import Files, so LIBPATH fires. shlibpath_overrides_runpath=yes ;; *,no) # both, prefer aix dynamic_linker="AIX lib.a(lib.so.V), lib.so.V($shared_archive_member_spec.o)" library_names_spec='$libname$release.a $libname.a' soname_spec='$libname$release$shared_ext$major' # unpreferred sharedlib libNAME.so.V and symlink libNAME.so need extra handling postinstall_cmds='test -z "$dlname" || $install_shared_prog $dir/$dlname $destdir/$dlname~test -z "$tstripme" || test -z "$striplib" || $striplib $destdir/$dlname~test -n "$linkname" || linkname=$realname~func_stripname "" ".a" "$linkname"~(cd "$destdir" && $LN_S -f $dlname $func_stripname_result.so)' postuninstall_cmds='test -z "$dlname" || func_append rmfiles " $odir/$dlname"~for n in $old_library $library_names; do :; done~func_stripname "" ".a" "$n"~func_append rmfiles " $odir/$func_stripname_result.so"' ;; esac 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%'\''`; $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 # correct to gnu/linux during the next big refactor 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 # correct to gnu/linux during the next big refactor 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 ;; 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[23].*) 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$major $libname$shared_ext' soname_spec='$libname$release$shared_ext$major' 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 ;; haiku*) version_type=linux # correct to gnu/linux during the next big refactor 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=no 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 32 = "$HPUX_IA64_MODE"; then sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib" sys_lib_dlsearch_path_spec=/usr/lib/hpux32 else sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64" sys_lib_dlsearch_path_spec=/usr/lib/hpux64 fi ;; 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 # correct to gnu/linux during the next big refactor 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 yes = "$lt_cv_prog_gnu_ld"; then version_type=linux # correct to gnu/linux during the next big refactor 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 ;; linux*android*) version_type=none # Android doesn't support versioned libraries. need_lib_prefix=no need_version=no library_names_spec='$libname$release$shared_ext' soname_spec='$libname$release$shared_ext' finish_cmds= shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=yes # 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 dynamic_linker='Android linker' # Don't embed -rpath directories since the linker doesn't support them. hardcode_libdir_flag_spec='-L$libdir' ;; # This must be glibc/ELF. linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*) version_type=linux # correct to gnu/linux during the next big refactor 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 # Ideally, we could use ldconfig to report *all* directores which are # searched for libraries, however this is still not possible. Aside from not # being certain /sbin/ldconfig is available, command # 'ldconfig -N -X -v | grep ^/' on 64bit Fedora does not report /usr/lib64, # even though it is searched at run-time. Try to do the best guess by # appending ld.so.conf contents (and includes) 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="/lib /usr/lib $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 # correct to gnu/linux during the next big refactor 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* | bitrig*) version_type=sunos sys_lib_dlsearch_path_spec=/usr/lib need_lib_prefix=no if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`"; then need_version=no else need_version=yes fi 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 shlibpath_overrides_runpath=yes ;; os2*) libname_spec='$name' version_type=windows shrext_cmds=.dll need_version=no need_lib_prefix=no # OS/2 can only load a DLL with a base name of 8 characters or less. soname_spec='`test -n "$os2dllname" && libname="$os2dllname"; v=$($ECHO $release$versuffix | tr -d .-); n=$($ECHO $libname | cut -b -$((8 - ${#v})) | tr . _); $ECHO $n$v`$shared_ext' library_names_spec='${libname}_dll.$libext' dynamic_linker='OS/2 ld.exe' shlibpath_var=BEGINLIBPATH sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib" sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec 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' ;; 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 # correct to gnu/linux during the next big refactor 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 yes = "$with_gnu_ld"; then need_lib_prefix=no fi need_version=yes ;; sysv4 | sysv4.3*) version_type=linux # correct to gnu/linux during the next big refactor 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 # correct to gnu/linux during the next big refactor 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=sco 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 yes = "$with_gnu_ld"; 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 # correct to gnu/linux during the next big refactor 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 # correct to gnu/linux during the next big refactor 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 no = "$dynamic_linker" && can_build_shared=no variables_saved_for_relink="PATH $shlibpath_var $runpath_var" if test yes = "$GCC"; then variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH" fi if test set = "${lt_cv_sys_lib_search_path_spec+set}"; then sys_lib_search_path_spec=$lt_cv_sys_lib_search_path_spec fi if test set = "${lt_cv_sys_lib_dlsearch_path_spec+set}"; then sys_lib_dlsearch_path_spec=$lt_cv_sys_lib_dlsearch_path_spec fi # remember unaugmented sys_lib_dlsearch_path content for libtool script decls... configure_time_dlsearch_path=$sys_lib_dlsearch_path_spec # ... but it needs LT_SYS_LIBRARY_PATH munging for other configure-time code func_munge_path_list sys_lib_dlsearch_path_spec "$LT_SYS_LIBRARY_PATH" # to be used as default LT_SYS_LIBRARY_PATH value in generated libtool configure_time_lt_sys_library_path=$LT_SYS_LIBRARY_PATH { $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 yes = "$hardcode_automatic"; then # We can hardcode non-existent directories. if test no != "$hardcode_direct" && # 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 no != "$_LT_TAGVAR(hardcode_shlibpath_var, )" && test no != "$hardcode_minus_L"; 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 relink = "$hardcode_action" || test yes = "$inherit_rpath"; then # Fast installation is not supported enable_fast_install=no elif test yes = "$shlibpath_overrides_runpath" || test no = "$enable_shared"; then # Fast installation is not necessary enable_fast_install=needless fi if test yes != "$enable_dlopen"; 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 ;; tpf*) # Don't try to run any link tests for TPF. We know it's impossible # because TPF is a cross-compiler, and we know how we open DSOs. lt_cv_dlopen=dlopen lt_cv_dlopen_libs= lt_cv_dlopen_self=no ;; *) 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 no = "$lt_cv_dlopen"; then enable_dlopen=no else enable_dlopen=yes fi case $lt_cv_dlopen in dlopen) save_CPPFLAGS=$CPPFLAGS test yes = "$ac_cv_header_dlfcn_h" && 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 yes = "$cross_compiling"; 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 -fvisibility=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 yes = "$lt_cv_dlopen_self"; 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 yes = "$cross_compiling"; 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 -fvisibility=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 what 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 no = "$can_build_shared" && 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 yes = "$enable_shared" && enable_static=no if test -n "$RANLIB"; then archive_cmds="$archive_cmds~\$RANLIB \$lib" postinstall_cmds='$RANLIB $lib' fi ;; aix[4-9]*) if test ia64 != "$host_cpu"; then case $enable_shared,$with_aix_soname,$aix_use_runtimelinking in yes,aix,yes) ;; # shared object as lib.so file only yes,svr4,*) ;; # shared object as lib.so archive member only yes,*) enable_static=no ;; # shared object in lib.a archive as well esac 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 yes = "$enable_shared" || 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 if test -n "$CXX" && ( test no != "$CXX" && ( (test g++ = "$CXX" && `g++ -v >/dev/null 2>&1` ) || (test g++ != "$CXX"))); 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_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 yes != "$_lt_caught_CXX_error"; 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 func_cc_basename $compiler cc_basename=$func_cc_basename_result if test -n "$compiler"; then # We don't want -fno-exception when compiling C++ code, so set the # no_builtin_flag separately if test yes = "$GXX"; then lt_prog_compiler_no_builtin_flag_CXX=' -fno-builtin' else lt_prog_compiler_no_builtin_flag_CXX= fi if test yes = "$GXX"; 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 no = "$withval" || with_gnu_ld=yes else with_gnu_ld=no fi ac_prog=ld if test yes = "$GCC"; 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 yes = "$with_gnu_ld"; 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 yes = "$with_gnu_ld"; 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 ia64 = "$host_cpu"; 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 # have runtime linking enabled, and use it for executables. # For shared libraries, we enable/disable runtime linking # depending on the kind of the shared library created - # when "with_aix_soname,aix_use_runtimelinking" is: # "aix,no" lib.a(lib.so.V) shared, rtl:no, for executables # "aix,yes" lib.so shared, rtl:yes, for executables # lib.a static archive # "both,no" lib.so.V(shr.o) shared, rtl:yes # lib.a(lib.so.V) shared, rtl:no, for executables # "both,yes" lib.so.V(shr.o) shared, rtl:yes, for executables # lib.a(lib.so.V) shared, rtl:no # "svr4,*" lib.so.V(shr.o) shared, rtl:yes, for executables # lib.a static archive 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 if test svr4,no = "$with_aix_soname,$aix_use_runtimelinking"; then # With aix-soname=svr4, we create the lib.so.V shared archives only, # so we don't have lib.a shared libs to link our executables. # We have to force runtime linking in this case. aix_use_runtimelinking=yes LDFLAGS="$LDFLAGS -Wl,-brtl" fi ;; 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,' case $with_aix_soname,$aix_use_runtimelinking in aix,*) ;; # no import file svr4,* | *,yes) # use import file # The Import File defines what to hardcode. hardcode_direct_CXX=no hardcode_direct_absolute_CXX=no ;; esac if test yes = "$GXX"; 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 yes = "$aix_use_runtimelinking"; then shared_flag=$shared_flag' $wl-G' fi # Need to ensure runtime linking is disabled for the traditional # shared library, or the linker may eventually find shared libraries # /with/ Import File - we do not want to mix them. shared_flag_aix='-shared' shared_flag_svr4='-shared $wl-G' else # not using gcc if test ia64 = "$host_cpu"; 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 yes = "$aix_use_runtimelinking"; then shared_flag='$wl-G' else shared_flag='$wl-bM:SRE' fi shared_flag_aix='$wl-bM:SRE' shared_flag_svr4='$wl-G' 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,yes = "$with_aix_soname,$aix_use_runtimelinking"; then # Warning - without using the other runtime loading flags (-brtl), # -berok will link without error, but may produce a broken library. # The "-G" linker flag allows undefined symbols. no_undefined_flag_CXX='-bernotok' # Determine the default libpath from the value encoded in an empty # executable. if test set = "${lt_cv_aix_libpath+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 -n "$allow_undefined_flag"; then func_echo_all "$wl$allow_undefined_flag"; else :; fi` $wl'$exp_sym_flag:\$export_symbols' '$shared_flag else if test ia64 = "$host_cpu"; 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 set = "${lt_cv_aix_libpath+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 yes = "$with_gnu_ld"; 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 archive_expsym_cmds_CXX='$RM -r $output_objdir/$realname.d~$MKDIR $output_objdir/$realname.d' # -brtl affects multiple linker settings, -berok does not and is overridden later compiler_flags_filtered='`func_echo_all "$compiler_flags " | $SED -e "s%-brtl\\([, ]\\)%-berok\\1%g"`' if test svr4 != "$with_aix_soname"; then # This is similar to how AIX traditionally builds its shared # libraries. Need -bnortl late, we may have -brtl in LDFLAGS. archive_expsym_cmds_CXX="$archive_expsym_cmds_CXX"'~$CC '$shared_flag_aix' -o $output_objdir/$realname.d/$soname $libobjs $deplibs $wl-bnoentry '$compiler_flags_filtered'$wl-bE:$export_symbols$allow_undefined_flag~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$realname.d/$soname' fi if test aix != "$with_aix_soname"; then archive_expsym_cmds_CXX="$archive_expsym_cmds_CXX"'~$CC '$shared_flag_svr4' -o $output_objdir/$realname.d/$shared_archive_member_spec.o $libobjs $deplibs $wl-bnoentry '$compiler_flags_filtered'$wl-bE:$export_symbols$allow_undefined_flag~$STRIP -e $output_objdir/$realname.d/$shared_archive_member_spec.o~( func_echo_all "#! $soname($shared_archive_member_spec.o)"; if test shr_64 = "$shared_archive_member_spec"; then func_echo_all "# 64"; else func_echo_all "# 32"; fi; cat $export_symbols ) > $output_objdir/$realname.d/$shared_archive_member_spec.imp~$AR $AR_FLAGS $output_objdir/$soname $output_objdir/$realname.d/$shared_archive_member_spec.o $output_objdir/$realname.d/$shared_archive_member_spec.imp' else # used by -dlpreopen to get the symbols archive_expsym_cmds_CXX="$archive_expsym_cmds_CXX"'~$MV $output_objdir/$realname.d/$soname $output_objdir' fi archive_expsym_cmds_CXX="$archive_expsym_cmds_CXX"'~$RM -r $output_objdir/$realname.d' 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,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~linknames=' archive_expsym_cmds_CXX='if test DEF = "`$SED -n -e '\''s/^[ ]*//'\'' -e '\''/^\(;.*\)*$/d'\'' -e '\''s/^\(EXPORTS\|LIBRARY\)\([ ].*\)*$/DEF/p'\'' -e q $export_symbols`" ; then cp "$export_symbols" "$output_objdir/$soname.def"; echo "$tool_output_objdir$soname.def" > "$output_objdir/$soname.exp"; else $SED -e '\''s/^/-link -EXPORT:/'\'' < $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, use it as # is; otherwise, prepend EXPORTS... archive_expsym_cmds_CXX='if test DEF = "`$SED -n -e '\''s/^[ ]*//'\'' -e '\''/^\(;.*\)*$/d'\'' -e '\''s/^\(EXPORTS\|LIBRARY\)\([ ].*\)*$/DEF/p'\'' -e q $export_symbols`" ; 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 yes = "$lt_cv_ld_force_load"; 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*|nagfor*) _lt_dar_can_shared=yes ;; *) _lt_dar_can_shared=$GCC ;; esac if test yes = "$_lt_dar_can_shared"; 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 yes != "$lt_cv_apple_cc_single_mod"; 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 ;; os2*) hardcode_libdir_flag_spec_CXX='-L$libdir' hardcode_minus_L_CXX=yes allow_undefined_flag_CXX=unsupported shrext_cmds=.dll archive_cmds_CXX='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~ $ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~ $ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~ $ECHO EXPORTS >> $output_objdir/$libname.def~ emxexp $libobjs | $SED /"_DLL_InitTerm"/d >> $output_objdir/$libname.def~ $CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~ emximp -o $lib $output_objdir/$libname.def' archive_expsym_cmds_CXX='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~ $ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~ $ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~ $ECHO EXPORTS >> $output_objdir/$libname.def~ prefix_cmds="$SED"~ if test EXPORTS = "`$SED 1q $export_symbols`"; then prefix_cmds="$prefix_cmds -e 1d"; fi~ prefix_cmds="$prefix_cmds -e \"s/^\(.*\)$/_\1/g\""~ cat $export_symbols | $prefix_cmds >> $output_objdir/$libname.def~ $CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~ emximp -o $lib $output_objdir/$libname.def' old_archive_From_new_cmds_CXX='emximp -o $output_objdir/${libname}_dll.a $output_objdir/$libname.def' enable_shared_with_static_runtimes_CXX=yes ;; 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 ;; freebsd2.*) # 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 ;; 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 "x$output_objdir/$soname" = "x$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 yes = "$GXX"; 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 "x$output_objdir/$soname" = "x$lib" || mv $output_objdir/$soname $lib' else # FIXME: insert proper C++ library support ld_shlibs_CXX=no fi ;; esac ;; hpux10*|hpux11*) if test no = "$with_gnu_ld"; 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 yes = "$GXX"; then if test no = "$with_gnu_ld"; 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 yes = "$GXX"; then if test no = "$with_gnu_ld"; 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 | 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 yes = "$supports_anon_versioning"; 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 ;; openbsd* | bitrig*) 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__`"; 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 yes,no = "$GXX,$with_gnu_ld"; 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 yes,no = "$GXX,$with_gnu_ld"; 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 $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 $wl-h $wl$soname -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 $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 $wl-h $wl$soname -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 CANNOT 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 no = "$ld_shlibs_CXX" && 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" ;; *\ -fuse-linker-plugin*\ *) CFLAGS="$CFLAGS -fno-use-linker-plugin" ;; 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 x-L = "$p" || test x-R = "$p"; 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 no = "$pre_test_object_deps_done"; 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 no = "$pre_test_object_deps_done"; 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= ;; 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 yes = "$GXX"; 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 ia64 = "$host_cpu"; then # AIX 5 now supports IA64 processor lt_prog_compiler_static_CXX='-Bstatic' fi lt_prog_compiler_pic_CXX='-fPIC' ;; 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' case $host_os in os2*) lt_prog_compiler_static_CXX='$wl-static' ;; esac ;; 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 ia64 = "$host_cpu"; 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 ia64 != "$host_cpu"; 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 | 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 that 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" ## exclude from sc_useless_quotes_in_assignment # 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 yes = "$lt_cv_prog_compiler_pic_works_CXX"; 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 yes = "$lt_cv_prog_compiler_static_works_CXX"; 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 no = "$lt_cv_prog_compiler_c_o_CXX" && test no != "$need_locks"; 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 no = "$hard_links"; 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 GNU nm, but means don't demangle to AIX nm. # Without the "-l" option, or with the "-B" option, AIX nm treats # weak defined symbols like other global defined symbols, whereas # GNU nm marks them as "W". # While the 'weak' keyword is ignored in the Export File, we need # it in the Import File for the 'aix-soname' feature, so we have # to replace the "-B" option with "-P" for AIX nm. 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) != ".")) { if (\$ 2 == "W") { print \$ 3 " weak" } else { print \$ 3 } } }'\'' | sort -u > $export_symbols' else export_symbols_cmds_CXX='`func_echo_all $NM | $SED -e '\''s/B\([^B]*\)$/P\1/'\''` -PCpgl $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) && (substr(\$ 1,1,1) != ".")) { if ((\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) { print \$ 1 " weak" } else { print \$ 1 } } }'\'' | sort -u > $export_symbols' fi ;; pw32*) export_symbols_cmds_CXX=$ltdll_cmds ;; cygwin* | mingw* | cegcc*) case $cc_basename in cl*) exclude_expsyms_CXX='_NULL_IMPORT_DESCRIPTOR|_IMPORT_DESCRIPTOR_.*' ;; *) 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 no = "$ld_shlibs_CXX" && 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 yes,yes = "$GCC,$enable_shared"; 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 # correct to gnu/linux during the next big refactor 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 # correct to gnu/linux during the next big refactor need_lib_prefix=no need_version=no hardcode_into_libs=yes if test ia64 = "$host_cpu"; 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 # Using Import Files as archive members, it is possible to support # filename-based versioning of shared library archives on AIX. While # this would work for both with and without runtime linking, it will # prevent static linking of such archives. So we do filename-based # shared library versioning with .so extension only, which is used # when both runtime linking and shared linking is enabled. # Unfortunately, runtime linking may impact performance, so we do # not want this to be the default eventually. Also, we use the # versioned .so libs for executables only if there is the -brtl # linker flag in LDFLAGS as well, or --with-aix-soname=svr4 only. # To allow for filename-based versioning support, we need to create # libNAME.so.V as an archive file, containing: # *) an Import File, referring to the versioned filename of the # archive as well as the shared archive member, telling the # bitwidth (32 or 64) of that shared object, and providing the # list of exported symbols of that shared object, eventually # decorated with the 'weak' keyword # *) the shared object with the F_LOADONLY flag set, to really avoid # it being seen by the linker. # At run time we better use the real file rather than another symlink, # but for link time we create the symlink libNAME.so -> libNAME.so.V case $with_aix_soname,$aix_use_runtimelinking in # AIX (on Power*) has no versioning support, so currently we cannot hardcode correct # soname into executable. Probably we can add versioning support to # collect2, so additional links can be useful in future. aix,yes) # traditional libtool dynamic_linker='AIX unversionable lib.so' # 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' ;; aix,no) # traditional AIX only dynamic_linker='AIX lib.a(lib.so.V)' # 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' ;; svr4,*) # full svr4 only dynamic_linker="AIX lib.so.V($shared_archive_member_spec.o)" library_names_spec='$libname$release$shared_ext$major $libname$shared_ext' # We do not specify a path in Import Files, so LIBPATH fires. shlibpath_overrides_runpath=yes ;; *,yes) # both, prefer svr4 dynamic_linker="AIX lib.so.V($shared_archive_member_spec.o), lib.a(lib.so.V)" library_names_spec='$libname$release$shared_ext$major $libname$shared_ext' # unpreferred sharedlib libNAME.a needs extra handling postinstall_cmds='test -n "$linkname" || linkname="$realname"~func_stripname "" ".so" "$linkname"~$install_shared_prog "$dir/$func_stripname_result.$libext" "$destdir/$func_stripname_result.$libext"~test -z "$tstripme" || test -z "$striplib" || $striplib "$destdir/$func_stripname_result.$libext"' postuninstall_cmds='for n in $library_names $old_library; do :; done~func_stripname "" ".so" "$n"~test "$func_stripname_result" = "$n" || func_append rmfiles " $odir/$func_stripname_result.$libext"' # We do not specify a path in Import Files, so LIBPATH fires. shlibpath_overrides_runpath=yes ;; *,no) # both, prefer aix dynamic_linker="AIX lib.a(lib.so.V), lib.so.V($shared_archive_member_spec.o)" library_names_spec='$libname$release.a $libname.a' soname_spec='$libname$release$shared_ext$major' # unpreferred sharedlib libNAME.so.V and symlink libNAME.so need extra handling postinstall_cmds='test -z "$dlname" || $install_shared_prog $dir/$dlname $destdir/$dlname~test -z "$tstripme" || test -z "$striplib" || $striplib $destdir/$dlname~test -n "$linkname" || linkname=$realname~func_stripname "" ".a" "$linkname"~(cd "$destdir" && $LN_S -f $dlname $func_stripname_result.so)' postuninstall_cmds='test -z "$dlname" || func_append rmfiles " $odir/$dlname"~for n in $old_library $library_names; do :; done~func_stripname "" ".a" "$n"~func_append rmfiles " $odir/$func_stripname_result.so"' ;; esac 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%'\''`; $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 # correct to gnu/linux during the next big refactor 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 # correct to gnu/linux during the next big refactor 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 ;; 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[23].*) 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$major $libname$shared_ext' soname_spec='$libname$release$shared_ext$major' 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 ;; haiku*) version_type=linux # correct to gnu/linux during the next big refactor 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=no 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 32 = "$HPUX_IA64_MODE"; then sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib" sys_lib_dlsearch_path_spec=/usr/lib/hpux32 else sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64" sys_lib_dlsearch_path_spec=/usr/lib/hpux64 fi ;; 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 # correct to gnu/linux during the next big refactor 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 yes = "$lt_cv_prog_gnu_ld"; then version_type=linux # correct to gnu/linux during the next big refactor 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 ;; linux*android*) version_type=none # Android doesn't support versioned libraries. need_lib_prefix=no need_version=no library_names_spec='$libname$release$shared_ext' soname_spec='$libname$release$shared_ext' finish_cmds= shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=yes # 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 dynamic_linker='Android linker' # Don't embed -rpath directories since the linker doesn't support them. hardcode_libdir_flag_spec_CXX='-L$libdir' ;; # This must be glibc/ELF. linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*) version_type=linux # correct to gnu/linux during the next big refactor 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 # Ideally, we could use ldconfig to report *all* directores which are # searched for libraries, however this is still not possible. Aside from not # being certain /sbin/ldconfig is available, command # 'ldconfig -N -X -v | grep ^/' on 64bit Fedora does not report /usr/lib64, # even though it is searched at run-time. Try to do the best guess by # appending ld.so.conf contents (and includes) 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="/lib /usr/lib $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 # correct to gnu/linux during the next big refactor 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* | bitrig*) version_type=sunos sys_lib_dlsearch_path_spec=/usr/lib need_lib_prefix=no if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`"; then need_version=no else need_version=yes fi 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 shlibpath_overrides_runpath=yes ;; os2*) libname_spec='$name' version_type=windows shrext_cmds=.dll need_version=no need_lib_prefix=no # OS/2 can only load a DLL with a base name of 8 characters or less. soname_spec='`test -n "$os2dllname" && libname="$os2dllname"; v=$($ECHO $release$versuffix | tr -d .-); n=$($ECHO $libname | cut -b -$((8 - ${#v})) | tr . _); $ECHO $n$v`$shared_ext' library_names_spec='${libname}_dll.$libext' dynamic_linker='OS/2 ld.exe' shlibpath_var=BEGINLIBPATH sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib" sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec 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' ;; 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 # correct to gnu/linux during the next big refactor 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 yes = "$with_gnu_ld"; then need_lib_prefix=no fi need_version=yes ;; sysv4 | sysv4.3*) version_type=linux # correct to gnu/linux during the next big refactor 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 # correct to gnu/linux during the next big refactor 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=sco 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 yes = "$with_gnu_ld"; 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 # correct to gnu/linux during the next big refactor 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 # correct to gnu/linux during the next big refactor 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 no = "$dynamic_linker" && can_build_shared=no variables_saved_for_relink="PATH $shlibpath_var $runpath_var" if test yes = "$GCC"; then variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH" fi if test set = "${lt_cv_sys_lib_search_path_spec+set}"; then sys_lib_search_path_spec=$lt_cv_sys_lib_search_path_spec fi if test set = "${lt_cv_sys_lib_dlsearch_path_spec+set}"; then sys_lib_dlsearch_path_spec=$lt_cv_sys_lib_dlsearch_path_spec fi # remember unaugmented sys_lib_dlsearch_path content for libtool script decls... configure_time_dlsearch_path=$sys_lib_dlsearch_path_spec # ... but it needs LT_SYS_LIBRARY_PATH munging for other configure-time code func_munge_path_list sys_lib_dlsearch_path_spec "$LT_SYS_LIBRARY_PATH" # to be used as default LT_SYS_LIBRARY_PATH value in generated libtool configure_time_lt_sys_library_path=$LT_SYS_LIBRARY_PATH { $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 yes = "$hardcode_automatic_CXX"; then # We can hardcode non-existent directories. if test no != "$hardcode_direct_CXX" && # 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 no != "$_LT_TAGVAR(hardcode_shlibpath_var, CXX)" && test no != "$hardcode_minus_L_CXX"; 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 relink = "$hardcode_action_CXX" || test yes = "$inherit_rpath_CXX"; then # Fast installation is not supported enable_fast_install=no elif test yes = "$shlibpath_overrides_runpath" || test no = "$enable_shared"; 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 yes != "$_lt_caught_CXX_error" 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_config_commands="$ac_config_commands libtool" # Only expand once: # Note: If Autoconf reports that LIBTOOL (or AC_ENABLE_SHARED, or # AC_PROG_LIBTOOL) is undefined, Libtool installation should be checked. # Special CFLAGS to use when building gc_cflags="" # gc_use_mmap Set to "yes" on platforms where mmap should be used instead # of sbrk. This will define USE_MMAP. gc_use_mmap="" # We should set -fexceptions if we are using gcc and might be used # inside something like gcj. This is the zeroth approximation: if test :"$GCC": = :yes: ; then gc_cflags="${gc_cflags} -fexceptions" else case "$host" in hppa*-*-hpux* ) if test :$GCC: != :"yes": ; then gc_cflags="${gc_flags} +ESdbgasm" fi # :TODO: actaully we should check using Autoconf if # the compiler supports this option. ;; esac fi case "${host}" in *-linux*) # FIXME: This seems to be no longer needed as configured in gcconfig.h #gc_use_mmap=yes ;; esac # target_optspace --enable-target-optspace ("yes", "no", "") case "${target_optspace}:${host}" in yes:*) gc_cflags="${gc_cflags} -Os" ;; :m32r-* | :d10v-* | :d30v-*) gc_cflags="${gc_cflags} -Os" ;; no:* | :*) # Nothing. ;; esac # Set any host dependent compiler flags. case "${host}" in mips-tx39-*|mipstx39-unknown-*) gc_cflags="${gc_cflags} -G 0" ;; *) ;; esac GC_CFLAGS=${gc_cflags} # Check whether --enable-threads was given. if test "${enable_threads+set}" = set; then : enableval=$enable_threads; THREADS=$enableval else { $as_echo "$as_me:${as_lineno-$LINENO}: checking for thread model used by GCC" >&5 $as_echo_n "checking for thread model used by GCC... " >&6; } THREADS=`$CC -v 2>&1 | sed -n 's/^Thread model: //p'` if test -z "$THREADS"; then THREADS=no fi if test "$THREADS" = "posix"; then case "$host" in *-*-mingw*) # Adjust thread model if cross-compiling for MinGW. THREADS=win32 ;; esac fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $THREADS" >&5 $as_echo "$THREADS" >&6; } fi # Check whether --enable-parallel-mark was given. if test "${enable_parallel_mark+set}" = set; then : enableval=$enable_parallel_mark; case "$THREADS" in no | none | single) if test "${enable_parallel_mark}" != no; then as_fn_error $? "Parallel mark requires --enable-threads=x spec" "$LINENO" 5 fi ;; esac fi # Check whether --enable-cplusplus was given. if test "${enable_cplusplus+set}" = set; then : enableval=$enable_cplusplus; fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking for inline" >&5 $as_echo_n "checking for inline... " >&6; } if ${ac_cv_c_inline+:} false; then : $as_echo_n "(cached) " >&6 else ac_cv_c_inline=no for ac_kw in inline __inline__ __inline; do cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #ifndef __cplusplus typedef int foo_t; static $ac_kw foo_t static_foo () {return 0; } $ac_kw foo_t foo () {return 0; } #endif _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_cv_c_inline=$ac_kw fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext test "$ac_cv_c_inline" != no && break done fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_inline" >&5 $as_echo "$ac_cv_c_inline" >&6; } case $ac_cv_c_inline in inline | yes) ;; *) case $ac_cv_c_inline in no) ac_val=;; *) ac_val=$ac_cv_c_inline;; esac cat >>confdefs.h <<_ACEOF #ifndef __cplusplus #define inline $ac_val #endif _ACEOF ;; esac THREADDLLIBS= need_atomic_ops_asm=false ## Libraries needed to support dynamic loading and/or threads. case "$THREADS" in no | none | single) THREADS=none ;; posix | pthreads) THREADS=posix { $as_echo "$as_me:${as_lineno-$LINENO}: checking for pthread_self in -lpthread" >&5 $as_echo_n "checking for pthread_self in -lpthread... " >&6; } if ${ac_cv_lib_pthread_pthread_self+:} false; then : $as_echo_n "(cached) " >&6 else ac_check_lib_save_LIBS=$LIBS LIBS="-lpthread $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 pthread_self (); int main () { return pthread_self (); ; return 0; } _ACEOF if ac_fn_c_try_link "$LINENO"; then : ac_cv_lib_pthread_pthread_self=yes else ac_cv_lib_pthread_pthread_self=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_pthread_pthread_self" >&5 $as_echo "$ac_cv_lib_pthread_pthread_self" >&6; } if test "x$ac_cv_lib_pthread_pthread_self" = xyes; then : THREADDLLIBS="-lpthread" fi case "$host" in x86-*-linux* | ia64-*-linux* | i586-*-linux* | i686-*-linux* \ | x86_64-*-linux* | alpha-*-linux* | powerpc*-*-linux* | sparc*-*-linux*) $as_echo "#define GC_LINUX_THREADS 1" >>confdefs.h $as_echo "#define _REENTRANT 1" >>confdefs.h if test "${enable_parallel_mark}" != no; then $as_echo "#define PARALLEL_MARK 1" >>confdefs.h fi $as_echo "#define THREAD_LOCAL_ALLOC 1" >>confdefs.h { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \"Explicit GC_INIT() calls may be required.\"" >&5 $as_echo "$as_me: WARNING: \"Explicit GC_INIT() calls may be required.\"" >&2;}; ;; *-*-linux*) $as_echo "#define GC_LINUX_THREADS 1" >>confdefs.h $as_echo "#define _REENTRANT 1" >>confdefs.h ;; *-*-aix*) $as_echo "#define GC_AIX_THREADS 1" >>confdefs.h $as_echo "#define _REENTRANT 1" >>confdefs.h ;; *-*-hpux11*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \"Only HP/UX 11 POSIX threads are supported.\"" >&5 $as_echo "$as_me: WARNING: \"Only HP/UX 11 POSIX threads are supported.\"" >&2;} $as_echo "#define GC_HPUX_THREADS 1" >>confdefs.h $as_echo "#define _POSIX_C_SOURCE 199506L" >>confdefs.h if test "${enable_parallel_mark}" = yes; then $as_echo "#define PARALLEL_MARK 1" >>confdefs.h fi $as_echo "#define THREAD_LOCAL_ALLOC 1" >>confdefs.h { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \"Explicit GC_INIT() calls may be required.\"" >&5 $as_echo "$as_me: WARNING: \"Explicit GC_INIT() calls may be required.\"" >&2;}; THREADDLLIBS="-lpthread -lrt" # HPUX needs REENTRANT for the _r calls. $as_echo "#define _REENTRANT 1" >>confdefs.h ;; *-*-hpux10*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \"Only HP-UX 11 POSIX threads are supported.\"" >&5 $as_echo "$as_me: WARNING: \"Only HP-UX 11 POSIX threads are supported.\"" >&2;} ;; *-*-openbsd*) $as_echo "#define GC_OPENBSD_THREADS 1" >>confdefs.h THREADDLLIBS=-pthread AM_CFLAGS="$AM_CFLAGS -pthread" ;; *-*-freebsd*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \"FreeBSD does not yet fully support threads with Boehm GC.\"" >&5 $as_echo "$as_me: WARNING: \"FreeBSD does not yet fully support threads with Boehm GC.\"" >&2;} $as_echo "#define GC_FREEBSD_THREADS 1" >>confdefs.h AM_CFLAGS="$AM_CFLAGS -pthread" if test "${enable_parallel_mark}" = yes; then $as_echo "#define PARALLEL_MARK 1" >>confdefs.h fi $as_echo "#define THREAD_LOCAL_ALLOC 1" >>confdefs.h ;; *-*-kfreebsd*-gnu) $as_echo "#define GC_FREEBSD_THREADS 1" >>confdefs.h AM_CFLAGS="$AM_CFLAGS -pthread" THREADDLLIBS=-pthread $as_echo "#define _REENTRANT 1" >>confdefs.h if test "${enable_parallel_mark}" = yes; then $as_echo "#define PARALLEL_MARK 1" >>confdefs.h fi $as_echo "#define THREAD_LOCAL_ALLOC 1" >>confdefs.h $as_echo "#define USE_COMPILER_TLS 1" >>confdefs.h ;; *-*-gnu*) $as_echo "#define GC_GNU_THREADS 1" >>confdefs.h $as_echo "#define _REENTRANT 1" >>confdefs.h $as_echo "#define THREAD_LOCAL_ALLOC 1" >>confdefs.h ;; *-*-netbsd*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \"Only on NetBSD 2.0 or later.\"" >&5 $as_echo "$as_me: WARNING: \"Only on NetBSD 2.0 or later.\"" >&2;} $as_echo "#define GC_NETBSD_THREADS 1" >>confdefs.h $as_echo "#define _REENTRANT 1" >>confdefs.h $as_echo "#define _PTHREADS 1" >>confdefs.h THREADDLLIBS="-lpthread -lrt" ;; *-*-solaris*) $as_echo "#define GC_SOLARIS_THREADS 1" >>confdefs.h if test "${enable_parallel_mark}" != no; then $as_echo "#define PARALLEL_MARK 1" >>confdefs.h fi $as_echo "#define THREAD_LOCAL_ALLOC 1" >>confdefs.h # Need to use alternate thread library, otherwise gctest hangs # on Solaris 8. multi_os_directory=`$CC -print-multi-os-directory` THREADDLLIBS="-L/usr/lib/lwp/$multi_os_directory \ -R/usr/lib/lwp/$multi_os_directory -lpthread -lrt" ;; *-*-irix*) $as_echo "#define GC_IRIX_THREADS 1" >>confdefs.h ;; *-*-cygwin*) $as_echo "#define GC_WIN32_THREADS 1" >>confdefs.h if test "${enable_parallel_mark}" != no; then $as_echo "#define PARALLEL_MARK 1" >>confdefs.h fi $as_echo "#define THREAD_LOCAL_ALLOC 1" >>confdefs.h # Cygwin doesn't have a real libpthread, so Libtool can't link # against it. THREADDLLIBS="" win32_threads=true ;; *-*-mingw*) $as_echo "#define GC_WIN32_PTHREADS 1" >>confdefs.h # Using pthreads-win32 (or other non-Cygwin pthreads) library. if test "${enable_parallel_mark}" != no; then $as_echo "#define PARALLEL_MARK 1" >>confdefs.h fi $as_echo "#define THREAD_LOCAL_ALLOC 1" >>confdefs.h THREADDLLIBS="-lpthread" win32_threads=true ;; *-*-darwin*) $as_echo "#define GC_DARWIN_THREADS 1" >>confdefs.h { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \"Explicit GC_INIT() calls may be required.\"" >&5 $as_echo "$as_me: WARNING: \"Explicit GC_INIT() calls may be required.\"" >&2;}; # Parallel-mark is not well-tested on Darwin if test "${enable_parallel_mark}" != no; then $as_echo "#define PARALLEL_MARK 1" >>confdefs.h fi $as_echo "#define THREAD_LOCAL_ALLOC 1" >>confdefs.h darwin_threads=true ;; *-*-osf*) $as_echo "#define GC_OSF1_THREADS 1" >>confdefs.h if test "${enable_parallel_mark}" = yes; then $as_echo "#define PARALLEL_MARK 1" >>confdefs.h $as_echo "#define THREAD_LOCAL_ALLOC 1" >>confdefs.h { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \"Explicit GC_INIT() calls may be required.\"" >&5 $as_echo "$as_me: WARNING: \"Explicit GC_INIT() calls may be required.\"" >&2;}; # May want to enable it in other cases, too. # Measurements have not yet been done. fi AM_CFLAGS="$AM_CFLAGS -pthread" THREADDLLIBS="-lpthread -lrt" ;; *) as_fn_error $? "\"Pthreads not supported by the GC on this platform.\"" "$LINENO" 5 ;; esac case "$host" in sparc*-*-solaris*) if test "$GCC" != yes; then need_atomic_ops_asm=true fi ;; esac ;; win32) $as_echo "#define GC_WIN32_THREADS 1" >>confdefs.h if test "${enable_parallel_mark}" != no; then $as_echo "#define PARALLEL_MARK 1" >>confdefs.h $as_echo "#define THREAD_LOCAL_ALLOC 1" >>confdefs.h else if test "${enable_shared}" != yes || test "${enable_static}" != no; then # Imply THREAD_LOCAL_ALLOC unless GC_DLL. $as_echo "#define THREAD_LOCAL_ALLOC 1" >>confdefs.h fi fi if test "${enable_win32_dllmain}" = yes; then $as_echo "#define GC_INSIDE_DLL 1" >>confdefs.h fi win32_threads=true $as_echo "#define EMPTY_GETENV_RESULTS 1" >>confdefs.h ;; dgux386) THREADS=dgux386 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $THREADDLLIBS" >&5 $as_echo "$THREADDLLIBS" >&6; } # Use pthread GCC switch THREADDLLIBS=-pthread if test "${enable_parallel_mark}" = yes; then $as_echo "#define PARALLEL_MARK 1" >>confdefs.h fi $as_echo "#define THREAD_LOCAL_ALLOC 1" >>confdefs.h { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \"Explicit GC_INIT() calls may be required.\"" >&5 $as_echo "$as_me: WARNING: \"Explicit GC_INIT() calls may be required.\"" >&2;}; $as_echo "#define GC_DGUX386_THREADS 1" >>confdefs.h $as_echo "#define DGUX_THREADS 1" >>confdefs.h # Enable _POSIX4A_DRAFT10_SOURCE with flag -pthread AM_CFLAGS="-pthread $AM_CFLAGS" ;; aix) THREADS=posix THREADDLLIBS=-lpthread $as_echo "#define GC_AIX_THREADS 1" >>confdefs.h $as_echo "#define _REENTRANT 1" >>confdefs.h ;; rtems) THREADS=posix $as_echo "#define GC_RTEMS_PTHREADS 1" >>confdefs.h $as_echo "#define THREAD_LOCAL_ALLOC 1" >>confdefs.h ;; decosf1 | irix | mach | os2 | solaris | dce | vxworks) as_fn_error $? "thread package $THREADS not yet supported" "$LINENO" 5 ;; *) as_fn_error $? "$THREADS is an unknown thread package" "$LINENO" 5 ;; esac if test x$THREADS != xnone; then THREADS_TRUE= THREADS_FALSE='#' else THREADS_TRUE='#' THREADS_FALSE= fi if test x$THREADS = xposix; then PTHREADS_TRUE= PTHREADS_FALSE='#' else PTHREADS_TRUE='#' PTHREADS_FALSE= fi if test x$darwin_threads = xtrue; then DARWIN_THREADS_TRUE= DARWIN_THREADS_FALSE='#' else DARWIN_THREADS_TRUE='#' DARWIN_THREADS_FALSE= fi if test x$win32_threads = xtrue; then WIN32_THREADS_TRUE= WIN32_THREADS_FALSE='#' else WIN32_THREADS_TRUE='#' WIN32_THREADS_FALSE= fi compiler_suncc=no case "$host" in powerpc-*-darwin*) powerpc_darwin=true ;; *-*-solaris*) if test "$GCC" != yes; then # Solaris SunCC compiler_suncc=yes CFLAGS="-O $CFLAGS" fi ;; *-*-wince*) if test "$enable_gc_debug" != "no"; then $as_echo "#define GC_READ_ENV_FILE 1" >>confdefs.h fi ;; esac if test "$GCC" = yes; then # Output all warnings. { $as_echo "$as_me:${as_lineno-$LINENO}: checking for gcc -Wextra" >&5 $as_echo_n "checking for gcc -Wextra... " >&6; } old_CFLAGS="$CFLAGS" CFLAGS="-Wextra $CFLAGS" 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_cc_wextra=yes else ac_cv_cc_wextra=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext CFLAGS="$old_CFLAGS" { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_cc_wextra" >&5 $as_echo "$ac_cv_cc_wextra" >&6; } if test "$ac_cv_cc_wextra" = yes; then : WEXTRA="-Wextra" else WEXTRA="-W" fi CFLAGS="-Wall $WEXTRA $CFLAGS" fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking for xlc" >&5 $as_echo_n "checking for xlc... " >&6; } cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { #ifndef __xlC__ # error #endif ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : compiler_xlc=yes else compiler_xlc=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext { $as_echo "$as_me:${as_lineno-$LINENO}: result: $compiler_xlc" >&5 $as_echo "$compiler_xlc" >&6; } if test $compiler_xlc = yes -a "$powerpc_darwin" = true; then # the darwin stack-frame-walking code is completely broken on xlc $as_echo "#define DARWIN_DONT_PARSE_STACK 1" >>confdefs.h fi # XLC neither requires nor tolerates the unnecessary assembler goop. # Similar for the Sun C compiler. if test $compiler_xlc = yes -o $compiler_suncc = yes; then ASM_WITH_CPP_UNSUPPORTED_TRUE= ASM_WITH_CPP_UNSUPPORTED_FALSE='#' else ASM_WITH_CPP_UNSUPPORTED_TRUE='#' ASM_WITH_CPP_UNSUPPORTED_FALSE= fi if test "$GCC" = yes; then # Disable aliasing optimization unless forced to. { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether gcc supports -fno-strict-aliasing" >&5 $as_echo_n "checking whether gcc supports -fno-strict-aliasing... " >&6; } ac_cv_fno_strict_aliasing=no for cflag in $CFLAGS; do case "$cflag" in -fstrict-aliasing) # Opposite option already present ac_cv_fno_strict_aliasing=skipped break ;; esac done if test "$ac_cv_fno_strict_aliasing" != skipped; then old_CFLAGS="$CFLAGS" CFLAGS="$CFLAGS -fno-strict-aliasing" 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_fno_strict_aliasing=yes fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext CFLAGS="$old_CFLAGS" if test "$ac_cv_fno_strict_aliasing" = yes; then : CFLAGS="$CFLAGS -fno-strict-aliasing" fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_fno_strict_aliasing" >&5 $as_echo "$ac_cv_fno_strict_aliasing" >&6; } fi case "$host" in # While IRIX 6 has libdl for the O32 and N32 ABIs, it's missing for N64 # and unnecessary everywhere. mips-sgi-irix6*) ;; # We never want libdl on darwin. It is a fake libdl that just ends up making # dyld calls anyway. The same applies to Cygwin. *-*-darwin*) ;; *-*-cygwin*) ;; *) { $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 : THREADDLLIBS="$THREADDLLIBS -ldl" fi ;; esac case "$host" in *-*-hpux*) avoid_cpp_lib=yes;; *) avoid_cpp_lib=no; ;; esac if test $avoid_cpp_lib = yes; then AVOID_CPP_LIB_TRUE= AVOID_CPP_LIB_FALSE='#' else AVOID_CPP_LIB_TRUE='#' AVOID_CPP_LIB_FALSE= fi # extra LD Flags which are required for targets case "${host}" in *-*-darwin*) extra_ldflags_libgc=-Wl,-single_module ;; esac target_all=libgc.la TARGET_ECOS="no" # Check whether --with-ecos was given. if test "${with_ecos+set}" = set; then : withval=$with_ecos; TARGET_ECOS="$with_ecos" fi addobjs= addlibs= CXXLIBS= case "$TARGET_ECOS" in no) ;; *) $as_echo "#define ECOS 1" >>confdefs.h AM_CPPFLAGS="-I${TARGET_ECOS}/include $AM_CPPFLAGS" addobjs="$addobjs ecos.lo" ;; esac if test "${enable_cplusplus}" = yes; then CPLUSPLUS_TRUE= CPLUSPLUS_FALSE='#' else CPLUSPLUS_TRUE='#' CPLUSPLUS_FALSE= fi if test "$GCC" = yes; then if test "${enable_cplusplus}" = yes; then case "$host" in *-*-cygwin* | *-*-mingw*) { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether libsupc++ required" >&5 $as_echo_n "checking whether libsupc++ required... " >&6; } SUPC="`$CXX -print-file-name=libsupc++.a 2>/dev/null`" if test -n "$SUPC" -a "$SUPC" != "libsupc++.a"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 $as_echo "yes" >&6; } CXXLIBS="-lsupc++" else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi ;; esac fi fi # Configuration of shared libraries # { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to build shared libraries" >&5 $as_echo_n "checking whether to build shared libraries... " >&6; } # 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=yes fi case "$host" in alpha-*-openbsd*) enable_shared=no ;; *) ;; esac { $as_echo "$as_me:${as_lineno-$LINENO}: result: $enable_shared" >&5 $as_echo "$enable_shared" >&6; } # Compile with GC_DLL defined unless building static libraries. if test "${enable_shared}" = yes; then if test "${enable_static}" = no; then $as_echo "#define GC_DLL 1" >>confdefs.h if test "$GCC" = yes; then # Pass -fvisibility=hidden option if supported { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether gcc supports -fvisibility" >&5 $as_echo_n "checking whether gcc supports -fvisibility... " >&6; } old_CFLAGS="$CFLAGS" CFLAGS="-Werror -fvisibility=hidden $CFLAGS" 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_fvisibility_hidden=yes else ac_cv_fvisibility_hidden=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext CFLAGS="$old_CFLAGS" if test "$ac_cv_fvisibility_hidden" = yes; then : CFLAGS="-DGC_VISIBILITY_HIDDEN_SET -fvisibility=hidden $CFLAGS" fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_fvisibility_hidden" >&5 $as_echo "$ac_cv_fvisibility_hidden" >&6; } fi fi fi # Configuration of machine-dependent code # { $as_echo "$as_me:${as_lineno-$LINENO}: checking which machine-dependent code should be used" >&5 $as_echo_n "checking which machine-dependent code should be used... " >&6; } machdep= case "$host" in alpha-*-openbsd*) if test x"${ac_cv_lib_dl_dlopen}" != xyes ; then { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \"OpenBSD/Alpha without dlopen(). Shared library support is disabled.\"" >&5 $as_echo "$as_me: WARNING: \"OpenBSD/Alpha without dlopen(). Shared library support is disabled.\"" >&2;} fi ;; i?86-*-solaris2.[89]) # PROC_VDB appears to work in 2.8 and 2.9 but not in 2.10+ (for now). $as_echo "#define SOLARIS25_PROC_VDB_BUG_FIXED 1" >>confdefs.h ;; mips-*-*) ;; sparc-*-netbsd*) machdep="sparc_netbsd_mach_dep.lo" ;; sparc*-*-linux* | sparc*-*-openbsd* | sparc64-*-freebsd* | sparc64-*-netbsd*) machdep="sparc_mach_dep.lo" ;; sparc-sun-solaris2.3) machdep="sparc_mach_dep.lo" $as_echo "#define SUNOS53_SHARED_LIB 1" >>confdefs.h ;; sparc*-sun-solaris2*) machdep="sparc_mach_dep.lo" ;; ia64-*-*) machdep="ia64_save_regs_in_stack.lo" ;; esac { $as_echo "$as_me:${as_lineno-$LINENO}: result: $machdep" >&5 $as_echo "$machdep" >&6; } addobjs="$addobjs $machdep" # Check whether --with-target-subdir was given. if test "${with_target_subdir+set}" = set; then : withval=$with_target_subdir; fi # Check whether --with-cross-host was given. if test "${with_cross_host+set}" = set; then : withval=$with_cross_host; fi # automake wants to see AC_EXEEXT. But we don't need it. And having # it is actually a problem, because the compiler we're passed can't # necessarily do a full link. So we fool automake here. if false; then # autoconf 2.50 runs AC_EXEEXT by default, and the macro expands # to nothing, so nothing would remain between `then' and `fi' if it # were not for the `:' below. : fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether Solaris gcc optimization fix is necessary" >&5 $as_echo_n "checking whether Solaris gcc optimization fix is necessary... " >&6; } case "$host" in *aix*) if test "$GCC" = yes; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 $as_echo "yes" >&6; } new_CFLAGS= for i in $CFLAGS; do case "$i" in -O*) ;; *) new_CFLAGS="$new_CFLAGS $i" ;; esac done CFLAGS="$new_CFLAGS" 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 $as_echo "#define NO_EXECUTE_PERMISSION 1" >>confdefs.h $as_echo "#define ALL_INTERIOR_POINTERS 1" >>confdefs.h # Check whether --enable-gcj-support was given. if test "${enable_gcj_support+set}" = set; then : enableval=$enable_gcj_support; fi if test x"$enable_gcj_support" != xno; then $as_echo "#define GC_GCJ_SUPPORT 1" >>confdefs.h fi # Check whether --enable-sigrt-signals was given. if test "${enable_sigrt_signals+set}" = set; then : enableval=$enable_sigrt_signals; fi if test x"${enable_sigrt_signals}" = xyes; then $as_echo "#define GC_USESIGRT_SIGNALS 1" >>confdefs.h fi UNWINDLIBS= # Check whether --enable-gc-debug was given. if test "${enable_gc_debug+set}" = set; then : enableval=$enable_gc_debug; if test "$enable_gc_debug" = "yes"; then { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \"Should define GC_DEBUG and use debug alloc in clients.\"" >&5 $as_echo "$as_me: WARNING: \"Should define GC_DEBUG and use debug alloc in clients.\"" >&2;} $as_echo "#define KEEP_BACK_PTRS 1" >>confdefs.h keep_back_ptrs=true $as_echo "#define DBG_HDRS_ALL 1" >>confdefs.h case $host in ia64-*-linux* ) $as_echo "#define MAKE_BACK_GRAPH 1" >>confdefs.h $as_echo "#define SAVE_CALL_COUNT 8" >>confdefs.h { $as_echo "$as_me:${as_lineno-$LINENO}: checking for backtrace in -lunwind" >&5 $as_echo_n "checking for backtrace in -lunwind... " >&6; } if ${ac_cv_lib_unwind_backtrace+:} false; then : $as_echo_n "(cached) " >&6 else ac_check_lib_save_LIBS=$LIBS LIBS="-lunwind $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 backtrace (); int main () { return backtrace (); ; return 0; } _ACEOF if ac_fn_c_try_link "$LINENO"; then : ac_cv_lib_unwind_backtrace=yes else ac_cv_lib_unwind_backtrace=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_unwind_backtrace" >&5 $as_echo "$ac_cv_lib_unwind_backtrace" >&6; } if test "x$ac_cv_lib_unwind_backtrace" = xyes; then : $as_echo "#define GC_HAVE_BUILTIN_BACKTRACE 1" >>confdefs.h UNWINDLIBS=-lunwind { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \"Client code may need to link against libunwind.\"" >&5 $as_echo "$as_me: WARNING: \"Client code may need to link against libunwind.\"" >&2;} fi ;; x86-*-linux* | i586-*-linux* | i686-*-linux* | x86_64-*-linux* ) $as_echo "#define MAKE_BACK_GRAPH 1" >>confdefs.h { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \"Client must not use -fomit-frame-pointer.\"" >&5 $as_echo "$as_me: WARNING: \"Client must not use -fomit-frame-pointer.\"" >&2;} $as_echo "#define SAVE_CALL_COUNT 8" >>confdefs.h ;; i345686-*-dgux*) $as_echo "#define MAKE_BACK_GRAPH 1" >>confdefs.h ;; esac fi fi if test x"$enable_gc_debug" = xyes; then MAKE_BACK_GRAPH_TRUE= MAKE_BACK_GRAPH_FALSE='#' else MAKE_BACK_GRAPH_TRUE='#' MAKE_BACK_GRAPH_FALSE= fi if test x"$keep_back_ptrs" = xtrue; then KEEP_BACK_PTRS_TRUE= KEEP_BACK_PTRS_FALSE='#' else KEEP_BACK_PTRS_TRUE='#' KEEP_BACK_PTRS_FALSE= fi # Check for dladdr (used for debugging). { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dladdr" >&5 $as_echo_n "checking for dladdr... " >&6; } have_dladdr=no cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #define _GNU_SOURCE 1 #include int main () { { Dl_info info; (void)dladdr("", &info); } ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : have_dladdr=yes fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext { $as_echo "$as_me:${as_lineno-$LINENO}: result: $have_dladdr" >&5 $as_echo "$have_dladdr" >&6; } if test x"$have_dladdr" = xyes; then $as_echo "#define HAVE_DLADDR 1" >>confdefs.h fi # Check for AViiON Machines running DGUX ac_is_dgux=no ac_fn_c_check_header_mongrel "$LINENO" "sys/dg_sys_info.h" "ac_cv_header_sys_dg_sys_info_h" "$ac_includes_default" if test "x$ac_cv_header_sys_dg_sys_info_h" = xyes; then : ac_is_dgux=yes; fi ## :GOTCHA: we do not check anything but sys/dg_sys_info.h if test $ac_is_dgux = yes; then dgux_spec_opts="-DDGUX -D_DGUX_SOURCE -Di386 -mno-legend -O2" CFLAGS="$dgux_spec_opts $CFLAGS" CXXFLAGS="$dgux_spec_opts $CXXFLAGS" if test "$enable_gc_debug" = "yes"; then CFLAGS="-g -mstandard $CFLAGS" CXXFLAGS="-g -mstandard $CXXFLAGS" fi fi # Check whether --enable-java-finalization was given. if test "${enable_java_finalization+set}" = set; then : enableval=$enable_java_finalization; fi if test x"$enable_java_finalization" != xno; then $as_echo "#define JAVA_FINALIZATION 1" >>confdefs.h fi # Check whether --enable-atomic-uncollectable was given. if test "${enable_atomic_uncollectable+set}" = set; then : enableval=$enable_atomic_uncollectable; fi if test x"$enable_atomic_uncollectible" != x"no"; then $as_echo "#define ATOMIC_UNCOLLECTABLE 1" >>confdefs.h fi # Check whether --enable-redirect-malloc was given. if test "${enable_redirect_malloc+set}" = set; then : enableval=$enable_redirect_malloc; fi if test "${enable_redirect_malloc}" = yes; then if test "${enable_gc_debug}" = yes; then $as_echo "#define REDIRECT_MALLOC GC_debug_malloc_replacement" >>confdefs.h $as_echo "#define REDIRECT_REALLOC GC_debug_realloc_replacement" >>confdefs.h $as_echo "#define REDIRECT_FREE GC_debug_free" >>confdefs.h else $as_echo "#define REDIRECT_MALLOC GC_malloc" >>confdefs.h fi $as_echo "#define GC_USE_DLOPEN_WRAP 1" >>confdefs.h fi # Check whether --enable-disclaim was given. if test "${enable_disclaim+set}" = set; then : enableval=$enable_disclaim; fi if test x"$enable_disclaim" != xno; then $as_echo "#define ENABLE_DISCLAIM 1" >>confdefs.h fi if test x"$enable_disclaim" != xno; then ENABLE_DISCLAIM_TRUE= ENABLE_DISCLAIM_FALSE='#' else ENABLE_DISCLAIM_TRUE='#' ENABLE_DISCLAIM_FALSE= fi # Check whether --enable-large-config was given. if test "${enable_large_config+set}" = set; then : enableval=$enable_large_config; fi if test "${enable_large_config}" = yes; then $as_echo "#define LARGE_CONFIG 1" >>confdefs.h fi # Check whether --enable-handle-fork was given. if test "${enable_handle_fork+set}" = set; then : enableval=$enable_handle_fork; fi if test "${enable_handle_fork}" = yes; then $as_echo "#define HANDLE_FORK 1" >>confdefs.h elif test "${enable_handle_fork}" = no; then $as_echo "#define NO_HANDLE_FORK 1" >>confdefs.h fi if test -n "${with_cross_host}"; then $as_echo "#define NO_CLOCK 1" >>confdefs.h $as_echo "#define SMALL_CONFIG 1" >>confdefs.h fi if test "$enable_gc_debug" = "no"; then $as_echo "#define NO_DEBUGGING 1" >>confdefs.h fi # Check whether --enable-gc-assertions was given. if test "${enable_gc_assertions+set}" = set; then : enableval=$enable_gc_assertions; fi if test "${enable_gc_assertions}" = yes; then $as_echo "#define GC_ASSERTIONS 1" >>confdefs.h fi # Check whether --enable-munmap was given. if test "${enable_munmap+set}" = set; then : enableval=$enable_munmap; MUNMAP_THRESHOLD=$enableval fi if test "${enable_munmap}" != ""; then $as_echo "#define USE_MMAP 1" >>confdefs.h case "$host" in *-*-cygwin*) # Workaround for Cygwin: use VirtualAlloc since mmap(PROT_NONE) fails $as_echo "#define USE_WINALLOC 1" >>confdefs.h ;; esac $as_echo "#define USE_MUNMAP 1" >>confdefs.h if test "${MUNMAP_THRESHOLD}" = "yes"; then MUNMAP_THRESHOLD=6 fi cat >>confdefs.h <<_ACEOF #define MUNMAP_THRESHOLD ${MUNMAP_THRESHOLD} _ACEOF else if test "${gc_use_mmap}" = "yes"; then $as_echo "#define USE_MMAP 1" >>confdefs.h fi fi if test -z "$with_cross_host"; then USE_LIBDIR_TRUE= USE_LIBDIR_FALSE='#' else USE_LIBDIR_TRUE='#' USE_LIBDIR_FALSE= fi # Check whether --enable-single-obj-compilation was given. if test "${enable_single_obj_compilation+set}" = set; then : enableval=$enable_single_obj_compilation; single_obj_compilation=yes fi if test "$single_obj_compilation" = "yes"; then SINGLE_GC_OBJ_TRUE= SINGLE_GC_OBJ_FALSE='#' else SINGLE_GC_OBJ_TRUE='#' SINGLE_GC_OBJ_FALSE= fi # Atomic Ops # ---------- # Do we want to use an external libatomic_ops? By default use it if it's # found. # Check whether --with-libatomic-ops was given. if test "${with_libatomic_ops+set}" = set; then : withval=$with_libatomic_ops; else with_libatomic_ops=check fi # Check for an external libatomic_ops if the answer was yes or check. If not # found, fail on yes, and convert check to no. # Note: "syntax error near unexpected token ATOMIC_OPS" reported by configure # means Autotools pkg.m4 file was not found during aclocal.m4 generation. missing_libatomic_ops=false if test "x$ac_cv_env_PKG_CONFIG_set" != "xset"; then if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}pkg-config", so it can be a program name with args. set dummy ${ac_tool_prefix}pkg-config; 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_path_PKG_CONFIG+:} false; then : $as_echo_n "(cached) " >&6 else case $PKG_CONFIG in [\\/]* | ?:[\\/]*) ac_cv_path_PKG_CONFIG="$PKG_CONFIG" # Let the user override the test with a path. ;; *) 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_path_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext" $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 ;; esac fi PKG_CONFIG=$ac_cv_path_PKG_CONFIG if test -n "$PKG_CONFIG"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKG_CONFIG" >&5 $as_echo "$PKG_CONFIG" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi fi if test -z "$ac_cv_path_PKG_CONFIG"; then ac_pt_PKG_CONFIG=$PKG_CONFIG # Extract the first word of "pkg-config", so it can be a program name with args. set dummy pkg-config; 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_path_ac_pt_PKG_CONFIG+:} false; then : $as_echo_n "(cached) " >&6 else case $ac_pt_PKG_CONFIG in [\\/]* | ?:[\\/]*) ac_cv_path_ac_pt_PKG_CONFIG="$ac_pt_PKG_CONFIG" # Let the user override the test with a path. ;; *) 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_path_ac_pt_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext" $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 ;; esac fi ac_pt_PKG_CONFIG=$ac_cv_path_ac_pt_PKG_CONFIG if test -n "$ac_pt_PKG_CONFIG"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_pt_PKG_CONFIG" >&5 $as_echo "$ac_pt_PKG_CONFIG" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi if test "x$ac_pt_PKG_CONFIG" = x; then PKG_CONFIG="" 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 PKG_CONFIG=$ac_pt_PKG_CONFIG fi else PKG_CONFIG="$ac_cv_path_PKG_CONFIG" fi fi if test -n "$PKG_CONFIG"; then _pkg_min_version=0.9.0 { $as_echo "$as_me:${as_lineno-$LINENO}: checking pkg-config is at least version $_pkg_min_version" >&5 $as_echo_n "checking pkg-config is at least version $_pkg_min_version... " >&6; } if $PKG_CONFIG --atleast-pkgconfig-version $_pkg_min_version; 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" >&5 $as_echo "no" >&6; } PKG_CONFIG="" fi fi if test x"$with_libatomic_ops" != xno; then : pkg_failed=no { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ATOMIC_OPS" >&5 $as_echo_n "checking for ATOMIC_OPS... " >&6; } if test -n "$ATOMIC_OPS_CFLAGS"; then pkg_cv_ATOMIC_OPS_CFLAGS="$ATOMIC_OPS_CFLAGS" elif test -n "$PKG_CONFIG"; then if test -n "$PKG_CONFIG" && \ { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"atomic_ops\""; } >&5 ($PKG_CONFIG --exists --print-errors "atomic_ops") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; then pkg_cv_ATOMIC_OPS_CFLAGS=`$PKG_CONFIG --cflags "atomic_ops" 2>/dev/null` test "x$?" != "x0" && pkg_failed=yes else pkg_failed=yes fi else pkg_failed=untried fi if test -n "$ATOMIC_OPS_LIBS"; then pkg_cv_ATOMIC_OPS_LIBS="$ATOMIC_OPS_LIBS" elif test -n "$PKG_CONFIG"; then if test -n "$PKG_CONFIG" && \ { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"atomic_ops\""; } >&5 ($PKG_CONFIG --exists --print-errors "atomic_ops") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; then pkg_cv_ATOMIC_OPS_LIBS=`$PKG_CONFIG --libs "atomic_ops" 2>/dev/null` test "x$?" != "x0" && pkg_failed=yes else pkg_failed=yes fi else pkg_failed=untried fi if test $pkg_failed = yes; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then _pkg_short_errors_supported=yes else _pkg_short_errors_supported=no fi if test $_pkg_short_errors_supported = yes; then ATOMIC_OPS_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors --cflags --libs "atomic_ops" 2>&1` else ATOMIC_OPS_PKG_ERRORS=`$PKG_CONFIG --print-errors --cflags --libs "atomic_ops" 2>&1` fi # Put the nasty error message in config.log where it belongs echo "$ATOMIC_OPS_PKG_ERRORS" >&5 missing_libatomic_ops=true elif test $pkg_failed = untried; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } missing_libatomic_ops=true else ATOMIC_OPS_CFLAGS=$pkg_cv_ATOMIC_OPS_CFLAGS ATOMIC_OPS_LIBS=$pkg_cv_ATOMIC_OPS_LIBS { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 $as_echo "yes" >&6; } fi fi if test x$missing_libatomic_ops = xtrue ; then : if test x"$with_libatomic_ops" != xcheck; then : as_fn_error $? "An external libatomic_ops was not found" "$LINENO" 5 fi with_libatomic_ops=no fi # If we have neither an external or an internal version, offer a useful hint # and exit. if test x"$with_libatomic_ops" = xno -a ! -e "$srcdir/libatomic_ops"; then : as_fn_error $? "libatomic_ops is required. You can either install it on your system, or fetch and unpack a recent version into the source directory and link or rename it to libatomic_ops." "$LINENO" 5 fi # Finally, emit the definitions for bundled or external AO. { $as_echo "$as_me:${as_lineno-$LINENO}: checking which libatomic_ops to use" >&5 $as_echo_n "checking which libatomic_ops to use... " >&6; } if test x"$with_libatomic_ops" != xno; then : { $as_echo "$as_me:${as_lineno-$LINENO}: result: external" >&5 $as_echo "external" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: internal" >&5 $as_echo "internal" >&6; } ATOMIC_OPS_CFLAGS='-I$(top_builddir)/libatomic_ops/src -I$(top_srcdir)/libatomic_ops/src' ATOMIC_OPS_LIBS="" subdirs="$subdirs libatomic_ops" fi if test x$with_libatomic_ops = xno -a x"$THREADS" != xnone; then USE_INTERNAL_LIBATOMIC_OPS_TRUE= USE_INTERNAL_LIBATOMIC_OPS_FALSE='#' else USE_INTERNAL_LIBATOMIC_OPS_TRUE='#' USE_INTERNAL_LIBATOMIC_OPS_FALSE= fi if test x$with_libatomic_ops = xno -a x$need_atomic_ops_asm = xtrue; then NEED_ATOMIC_OPS_ASM_TRUE= NEED_ATOMIC_OPS_ASM_FALSE='#' else NEED_ATOMIC_OPS_ASM_TRUE='#' NEED_ATOMIC_OPS_ASM_FALSE= fi ac_config_files="$ac_config_files Makefile bdw-gc.pc" ac_config_commands="$ac_config_commands default" 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 "${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 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 "${am__fastdepCCAS_TRUE}" && test -z "${am__fastdepCCAS_FALSE}"; then as_fn_error $? "conditional \"am__fastdepCCAS\" was never defined. Usually this means the macro was only invoked conditionally." "$LINENO" 5 fi if test -z "${THREADS_TRUE}" && test -z "${THREADS_FALSE}"; then as_fn_error $? "conditional \"THREADS\" was never defined. Usually this means the macro was only invoked conditionally." "$LINENO" 5 fi if test -z "${PTHREADS_TRUE}" && test -z "${PTHREADS_FALSE}"; then as_fn_error $? "conditional \"PTHREADS\" was never defined. Usually this means the macro was only invoked conditionally." "$LINENO" 5 fi if test -z "${DARWIN_THREADS_TRUE}" && test -z "${DARWIN_THREADS_FALSE}"; then as_fn_error $? "conditional \"DARWIN_THREADS\" was never defined. Usually this means the macro was only invoked conditionally." "$LINENO" 5 fi if test -z "${WIN32_THREADS_TRUE}" && test -z "${WIN32_THREADS_FALSE}"; then as_fn_error $? "conditional \"WIN32_THREADS\" was never defined. Usually this means the macro was only invoked conditionally." "$LINENO" 5 fi if test -z "${ASM_WITH_CPP_UNSUPPORTED_TRUE}" && test -z "${ASM_WITH_CPP_UNSUPPORTED_FALSE}"; then as_fn_error $? "conditional \"ASM_WITH_CPP_UNSUPPORTED\" was never defined. Usually this means the macro was only invoked conditionally." "$LINENO" 5 fi if test -z "${AVOID_CPP_LIB_TRUE}" && test -z "${AVOID_CPP_LIB_FALSE}"; then as_fn_error $? "conditional \"AVOID_CPP_LIB\" was never defined. Usually this means the macro was only invoked conditionally." "$LINENO" 5 fi if test -z "${CPLUSPLUS_TRUE}" && test -z "${CPLUSPLUS_FALSE}"; then as_fn_error $? "conditional \"CPLUSPLUS\" was never defined. Usually this means the macro was only invoked conditionally." "$LINENO" 5 fi if test -z "${MAKE_BACK_GRAPH_TRUE}" && test -z "${MAKE_BACK_GRAPH_FALSE}"; then as_fn_error $? "conditional \"MAKE_BACK_GRAPH\" was never defined. Usually this means the macro was only invoked conditionally." "$LINENO" 5 fi if test -z "${KEEP_BACK_PTRS_TRUE}" && test -z "${KEEP_BACK_PTRS_FALSE}"; then as_fn_error $? "conditional \"KEEP_BACK_PTRS\" was never defined. Usually this means the macro was only invoked conditionally." "$LINENO" 5 fi if test -z "${ENABLE_DISCLAIM_TRUE}" && test -z "${ENABLE_DISCLAIM_FALSE}"; then as_fn_error $? "conditional \"ENABLE_DISCLAIM\" was never defined. Usually this means the macro was only invoked conditionally." "$LINENO" 5 fi if test -z "${USE_LIBDIR_TRUE}" && test -z "${USE_LIBDIR_FALSE}"; then as_fn_error $? "conditional \"USE_LIBDIR\" was never defined. Usually this means the macro was only invoked conditionally." "$LINENO" 5 fi if test -z "${SINGLE_GC_OBJ_TRUE}" && test -z "${SINGLE_GC_OBJ_FALSE}"; then as_fn_error $? "conditional \"SINGLE_GC_OBJ\" was never defined. Usually this means the macro was only invoked conditionally." "$LINENO" 5 fi if test -z "${USE_INTERNAL_LIBATOMIC_OPS_TRUE}" && test -z "${USE_INTERNAL_LIBATOMIC_OPS_FALSE}"; then as_fn_error $? "conditional \"USE_INTERNAL_LIBATOMIC_OPS\" was never defined. Usually this means the macro was only invoked conditionally." "$LINENO" 5 fi if test -z "${NEED_ATOMIC_OPS_ASM_TRUE}" && test -z "${NEED_ATOMIC_OPS_ASM_FALSE}"; then as_fn_error $? "conditional \"NEED_ATOMIC_OPS_ASM\" 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 gc $as_me 7.5.0, 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 ." _ACEOF cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`" ac_cs_version="\\ gc config.status 7.5.0 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"`' 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"`' shared_archive_member_spec='`$ECHO "$shared_archive_member_spec" | $SED "$delay_single_quote_subst"`' SHELL='`$ECHO "$SHELL" | $SED "$delay_single_quote_subst"`' ECHO='`$ECHO "$ECHO" | $SED "$delay_single_quote_subst"`' PATH_SEPARATOR='`$ECHO "$PATH_SEPARATOR" | $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"`' OBJDUMP='`$ECHO "$OBJDUMP" | $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"`' DLLTOOL='`$ECHO "$DLLTOOL" | $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_import='`$ECHO "$lt_cv_sys_global_symbol_to_import" | $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"`' lt_cv_nm_interface='`$ECHO "$lt_cv_nm_interface" | $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"`' lt_cv_truncate_bin='`$ECHO "$lt_cv_truncate_bin" | $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_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"`' configure_time_dlsearch_path='`$ECHO "$configure_time_dlsearch_path" | $SED "$delay_single_quote_subst"`' configure_time_lt_sys_library_path='`$ECHO "$configure_time_lt_sys_library_path" | $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_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 SHELL \ ECHO \ PATH_SEPARATOR \ SED \ GREP \ EGREP \ FGREP \ LD \ NM \ LN_S \ lt_SP2NL \ lt_NL2SP \ reload_flag \ OBJDUMP \ deplibs_check_method \ file_magic_cmd \ file_magic_glob \ want_nocaseglob \ DLLTOOL \ 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_import \ lt_cv_sys_global_symbol_to_c_name_address \ lt_cv_sys_global_symbol_to_c_name_address_lib_prefix \ lt_cv_nm_interface \ nm_file_list_spec \ lt_cv_truncate_bin \ 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_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_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\\"\\\`\\\\\\"" ## exclude from sc_prohibit_nested_quotes ;; *) 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 \ configure_time_dlsearch_path \ configure_time_lt_sys_library_path \ 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\\"\\\`\\\\\\"" ## exclude from sc_prohibit_nested_quotes ;; *) eval "lt_\$var=\\\\\\"\\\$\$var\\\\\\"" ;; esac done ac_aux_dir='$ac_aux_dir' # See if we are running on zsh, and set the options that 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' RM='$RM' ofile='$ofile' srcdir="${srcdir}" host=${host} CONFIG_SHELL=${CONFIG_SHELL-/bin/sh} CC="${CC}" DEFS="$DEFS" _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 "include/config.h") CONFIG_HEADERS="$CONFIG_HEADERS include/config.h" ;; "depfiles") CONFIG_COMMANDS="$CONFIG_COMMANDS depfiles" ;; "libtool") CONFIG_COMMANDS="$CONFIG_COMMANDS libtool" ;; "Makefile") CONFIG_FILES="$CONFIG_FILES Makefile" ;; "bdw-gc.pc") CONFIG_FILES="$CONFIG_FILES bdw-gc.pc" ;; "default") CONFIG_COMMANDS="$CONFIG_COMMANDS default" ;; *) 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"" || { # Older Autoconf 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 that 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 # Generated automatically by $as_me ($PACKAGE) $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. # Provide generalized library-building support services. # Written by Gordon Matzigkeit, 1996 # Copyright (C) 2014 Free Software Foundation, Inc. # This is free software; see the source for copying conditions. There is NO # warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. # 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 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 this program. If not, see . # The names of the tagged configurations supported by this script. available_tags='CXX ' # Configured defaults for sys_lib_dlsearch_path munging. : \${LT_SYS_LIBRARY_PATH="$configure_time_lt_sys_library_path"} # ### 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 # 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 # Shared archive member basename,for filename based shared library versioning on AIX. shared_archive_member_spec=$shared_archive_member_spec # Shell to use when invoking shell scripts. SHELL=$lt_SHELL # An echo program that protects backslashes. ECHO=$lt_ECHO # The PATH separator for the build system. PATH_SEPARATOR=$lt_PATH_SEPARATOR # 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 # An object symbol dumper. OBJDUMP=$lt_OBJDUMP # 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 # DLL creation program. DLLTOOL=$lt_DLLTOOL # 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 into a list of symbols to manually relocate. global_symbol_to_import=$lt_lt_cv_sys_global_symbol_to_import # 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 # The name lister interface. nm_interface=$lt_lt_cv_nm_interface # 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 where our libraries should be installed. lt_sysroot=$lt_sysroot # Command to truncate a binary pipe. lt_truncate_bin=$lt_lt_cv_truncate_bin # 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 # Detected run-time system search path for libraries. sys_lib_dlsearch_path_spec=$lt_configure_time_dlsearch_path # Explicit LT_SYS_LIBRARY_PATH set during ./configure time. configure_time_lt_sys_library_path=$lt_configure_time_lt_sys_library_path # 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 # 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 cat <<'_LT_EOF' >> "$cfgfile" # ### BEGIN FUNCTIONS SHARED WITH CONFIGURE # func_munge_path_list VARIABLE PATH # ----------------------------------- # VARIABLE is name of variable containing _space_ separated list of # directories to be munged by the contents of PATH, which is string # having a format: # "DIR[:DIR]:" # string "DIR[ DIR]" will be prepended to VARIABLE # ":DIR[:DIR]" # string "DIR[ DIR]" will be appended to VARIABLE # "DIRP[:DIRP]::[DIRA:]DIRA" # string "DIRP[ DIRP]" will be prepended to VARIABLE and string # "DIRA[ DIRA]" will be appended to VARIABLE # "DIR[:DIR]" # VARIABLE will be replaced by "DIR[ DIR]" func_munge_path_list () { case x$2 in x) ;; *:) eval $1=\"`$ECHO $2 | $SED 's/:/ /g'` \$$1\" ;; x:*) eval $1=\"\$$1 `$ECHO $2 | $SED 's/:/ /g'`\" ;; *::*) eval $1=\"\$$1\ `$ECHO $2 | $SED -e 's/.*:://' -e 's/:/ /g'`\" eval $1=\"`$ECHO $2 | $SED -e 's/::.*//' -e 's/:/ /g'`\ \$$1\" ;; *) eval $1=\"`$ECHO $2 | $SED 's/:/ /g'`\" ;; esac } # Calculate cc_basename. Skip known compiler wrappers and cross-prefix. func_cc_basename () { for cc_temp in $*""; do case $cc_temp in compile | *[\\/]compile | ccache | *[\\/]ccache ) ;; distcc | *[\\/]distcc | purify | *[\\/]purify ) ;; \-*) ;; *) break;; esac done func_cc_basename_result=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"` } # ### END FUNCTIONS SHARED WITH CONFIGURE _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 set != "${COLLECT_NAMES+set}"; 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) 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 # 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 # # CONFIG_SUBDIRS section. # if test "$no_recursion" != yes; then # Remove --cache-file, --srcdir, and --disable-option-checking arguments # so they do not pile up. ac_sub_configure_args= ac_prev= eval "set x $ac_configure_args" shift for ac_arg do if test -n "$ac_prev"; then ac_prev= continue fi case $ac_arg in -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=*) ;; --config-cache | -C) ;; -srcdir | --srcdir | --srcdi | --srcd | --src | --sr) ac_prev=srcdir ;; -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*) ;; -prefix | --prefix | --prefi | --pref | --pre | --pr | --p) ac_prev=prefix ;; -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*) ;; --disable-option-checking) ;; *) case $ac_arg in *\'*) ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;; esac as_fn_append ac_sub_configure_args " '$ac_arg'" ;; esac done # Always prepend --prefix to ensure using the same prefix # in subdir configurations. ac_arg="--prefix=$prefix" case $ac_arg in *\'*) ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;; esac ac_sub_configure_args="'$ac_arg' $ac_sub_configure_args" # Pass --silent if test "$silent" = yes; then ac_sub_configure_args="--silent $ac_sub_configure_args" fi # Always prepend --disable-option-checking to silence warnings, since # different subdirs can have different --enable and --with options. ac_sub_configure_args="--disable-option-checking $ac_sub_configure_args" ac_popdir=`pwd` for ac_dir in : $subdirs; do test "x$ac_dir" = x: && continue # Do not complain, so a configure script can configure whichever # parts of a large source tree are present. test -d "$srcdir/$ac_dir" || continue ac_msg="=== configuring in $ac_dir (`pwd`/$ac_dir)" $as_echo "$as_me:${as_lineno-$LINENO}: $ac_msg" >&5 $as_echo "$ac_msg" >&6 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 cd "$ac_dir" # Check for guested configure; otherwise get Cygnus style configure. if test -f "$ac_srcdir/configure.gnu"; then ac_sub_configure=$ac_srcdir/configure.gnu elif test -f "$ac_srcdir/configure"; then ac_sub_configure=$ac_srcdir/configure elif test -f "$ac_srcdir/configure.in"; then # This should be Cygnus configure. ac_sub_configure=$ac_aux_dir/configure else { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: no configuration information is in $ac_dir" >&5 $as_echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2;} ac_sub_configure= fi # The recursion is here. if test -n "$ac_sub_configure"; then # Make the cache file name correct relative to the subdirectory. case $cache_file in [\\/]* | ?:[\\/]* ) ac_sub_cache_file=$cache_file ;; *) # Relative name. ac_sub_cache_file=$ac_top_build_prefix$cache_file ;; esac { $as_echo "$as_me:${as_lineno-$LINENO}: running $SHELL $ac_sub_configure $ac_sub_configure_args --cache-file=$ac_sub_cache_file --srcdir=$ac_srcdir" >&5 $as_echo "$as_me: running $SHELL $ac_sub_configure $ac_sub_configure_args --cache-file=$ac_sub_cache_file --srcdir=$ac_srcdir" >&6;} # The eval makes quoting arguments work. eval "\$SHELL \"\$ac_sub_configure\" $ac_sub_configure_args \ --cache-file=\"\$ac_sub_cache_file\" --srcdir=\"\$ac_srcdir\"" || as_fn_error $? "$ac_sub_configure failed for $ac_dir" "$LINENO" 5 fi cd "$ac_popdir" done 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 ecl-16.1.2/src/bdwgc/configure.ac000066400000000000000000000740371266352375300165360ustar00rootroot00000000000000# Copyright (c) 1999-2001 by Red Hat, Inc. All rights reserved. # # THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED # OR IMPLIED. ANY USE IS AT YOUR OWN RISK. # # Permission is hereby granted to use or copy this program # for any purpose, provided the above notices are retained on all copies. # Permission to modify the code and to distribute modified code is granted, # provided the above notices are retained, and a notice that the code was # modified is included with the above copyright notice. dnl Process this file with autoconf to produce configure. # Initialization AC_INIT(gc,7.5.0,bdwgc@lists.opendylan.org) ## version must conform to [0-9]+[.][0-9]+[.][0-9]+ AC_CONFIG_SRCDIR(gcj_mlc.c) AC_CONFIG_MACRO_DIR([m4]) AC_CANONICAL_TARGET AC_PREREQ(2.61) GC_SET_VERSION AM_INIT_AUTOMAKE([foreign dist-bzip2 nostdinc subdir-objects]) AC_CONFIG_HEADERS([include/config.h]) AM_MAINTAINER_MODE AC_SUBST(PACKAGE) AC_SUBST(GC_VERSION) AM_PROG_CC_C_O AC_PROG_CXX AM_PROG_AS AC_PROG_INSTALL LT_INIT # Note: If Autoconf reports that LIBTOOL (or AC_ENABLE_SHARED, or # AC_PROG_LIBTOOL) is undefined, Libtool installation should be checked. # Special CFLAGS to use when building gc_cflags="" # gc_use_mmap Set to "yes" on platforms where mmap should be used instead # of sbrk. This will define USE_MMAP. gc_use_mmap="" # We should set -fexceptions if we are using gcc and might be used # inside something like gcj. This is the zeroth approximation: if test :"$GCC": = :yes: ; then gc_cflags="${gc_cflags} -fexceptions" else case "$host" in hppa*-*-hpux* ) if test :$GCC: != :"yes": ; then gc_cflags="${gc_flags} +ESdbgasm" fi # :TODO: actaully we should check using Autoconf if # the compiler supports this option. ;; esac fi case "${host}" in *-linux*) # FIXME: This seems to be no longer needed as configured in gcconfig.h #gc_use_mmap=yes ;; esac # target_optspace --enable-target-optspace ("yes", "no", "") case "${target_optspace}:${host}" in yes:*) gc_cflags="${gc_cflags} -Os" ;; :m32r-* | :d10v-* | :d30v-*) gc_cflags="${gc_cflags} -Os" ;; no:* | :*) # Nothing. ;; esac # Set any host dependent compiler flags. case "${host}" in mips-tx39-*|mipstx39-unknown-*) gc_cflags="${gc_cflags} -G 0" ;; *) ;; esac GC_CFLAGS=${gc_cflags} AC_SUBST(GC_CFLAGS) AC_ARG_ENABLE(threads, [AC_HELP_STRING([--enable-threads=TYPE], [choose threading package])], THREADS=$enableval, [ AC_MSG_CHECKING([for thread model used by GCC]) THREADS=`$CC -v 2>&1 | sed -n 's/^Thread model: //p'` if test -z "$THREADS"; then THREADS=no fi if test "$THREADS" = "posix"; then case "$host" in *-*-mingw*) # Adjust thread model if cross-compiling for MinGW. THREADS=win32 ;; esac fi AC_MSG_RESULT([$THREADS]) ]) AC_ARG_ENABLE(parallel-mark, [AC_HELP_STRING([--enable-parallel-mark], [parallelize marking and free list construction])], [case "$THREADS" in no | none | single) if test "${enable_parallel_mark}" != no; then AC_MSG_ERROR([Parallel mark requires --enable-threads=x spec]) fi ;; esac ] ) AC_ARG_ENABLE(cplusplus, [AC_HELP_STRING([--enable-cplusplus], [install C++ support])]) dnl Features which may be selected in the following thread-detection switch. AH_TEMPLATE([PARALLEL_MARK], [Define to enable parallel marking.]) AH_TEMPLATE([THREAD_LOCAL_ALLOC], [Define to enable thread-local allocation optimization.]) AH_TEMPLATE([USE_COMPILER_TLS], [Define to use of compiler-support for thread-local variables.]) dnl Thread selection macros. AH_TEMPLATE([GC_THREADS], [Define to support platform-specific threads.]) AH_TEMPLATE([GC_AIX_THREADS], [Define to support IBM AIX threads.]) AH_TEMPLATE([GC_DARWIN_THREADS], [Define to support Darwin pthreads.]) AH_TEMPLATE([GC_FREEBSD_THREADS], [Define to support FreeBSD pthreads.]) AH_TEMPLATE([GC_GNU_THREADS], [Define to support GNU pthreads.]) AH_TEMPLATE([GC_HPUX_THREADS], [Define to support HP/UX 11 pthreads.]) AH_TEMPLATE([GC_IRIX_THREADS], [Define to support Irix pthreads.]) AH_TEMPLATE([GC_LINUX_THREADS], [Define to support pthreads on Linux.]) AH_TEMPLATE([GC_NETBSD_THREADS], [Define to support NetBSD pthreads.]) AH_TEMPLATE([GC_OPENBSD_THREADS], [Define to support OpenBSD pthreads.]) AH_TEMPLATE([GC_OSF1_THREADS], [Define to support Tru64 pthreads.]) AH_TEMPLATE([GC_SOLARIS_THREADS], [Define to support Solaris pthreads.]) AH_TEMPLATE([GC_WIN32_THREADS], [Define to support Win32 threads.]) AH_TEMPLATE([GC_WIN32_PTHREADS], [Define to support pthreads-win32 or winpthreads.]) AH_TEMPLATE([GC_RTEMS_PTHREADS], [Define to support rtems-pthreads.]) dnl System header feature requests. AH_TEMPLATE([_POSIX_C_SOURCE], [The POSIX feature macro.]) AH_TEMPLATE([_PTHREADS], [Indicates the use of pthreads (NetBSD).]) dnl Win32-specific API usage controls. AH_TEMPLATE([GC_UNDERSCORE_STDCALL], [Explicitly prefix exported/imported WINAPI symbols with '_'.]) AH_TEMPLATE([UNICODE], [Use Unicode (W) variant of Win32 API instead of ASCII (A) one.]) dnl GC API symbols export control. AH_TEMPLATE([GC_DLL], [Define to build dynamic libraries with only API symbols exposed.]) dnl Check for a flavor of supported inline keyword. AC_C_INLINE THREADDLLIBS= need_atomic_ops_asm=false ## Libraries needed to support dynamic loading and/or threads. case "$THREADS" in no | none | single) THREADS=none ;; posix | pthreads) THREADS=posix AC_CHECK_LIB(pthread, pthread_self, THREADDLLIBS="-lpthread",,) case "$host" in x86-*-linux* | ia64-*-linux* | i586-*-linux* | i686-*-linux* \ | x86_64-*-linux* | alpha-*-linux* | powerpc*-*-linux* | sparc*-*-linux*) AC_DEFINE(GC_LINUX_THREADS) AC_DEFINE(_REENTRANT) if test "${enable_parallel_mark}" != no; then AC_DEFINE(PARALLEL_MARK) fi AC_DEFINE(THREAD_LOCAL_ALLOC) AC_MSG_WARN("Explicit GC_INIT() calls may be required."); ;; *-*-linux*) AC_DEFINE(GC_LINUX_THREADS) AC_DEFINE(_REENTRANT) ;; *-*-aix*) AC_DEFINE(GC_AIX_THREADS) AC_DEFINE(_REENTRANT) ;; *-*-hpux11*) AC_MSG_WARN("Only HP/UX 11 POSIX threads are supported.") AC_DEFINE(GC_HPUX_THREADS) AC_DEFINE(_POSIX_C_SOURCE,199506L) if test "${enable_parallel_mark}" = yes; then AC_DEFINE(PARALLEL_MARK) fi AC_DEFINE(THREAD_LOCAL_ALLOC) AC_MSG_WARN("Explicit GC_INIT() calls may be required."); THREADDLLIBS="-lpthread -lrt" # HPUX needs REENTRANT for the _r calls. AC_DEFINE(_REENTRANT, 1, [Required define if using POSIX threads.]) ;; *-*-hpux10*) AC_MSG_WARN("Only HP-UX 11 POSIX threads are supported.") ;; *-*-openbsd*) AC_DEFINE(GC_OPENBSD_THREADS) THREADDLLIBS=-pthread AM_CFLAGS="$AM_CFLAGS -pthread" ;; *-*-freebsd*) AC_MSG_WARN("FreeBSD does not yet fully support threads with Boehm GC.") AC_DEFINE(GC_FREEBSD_THREADS) AM_CFLAGS="$AM_CFLAGS -pthread" if test "${enable_parallel_mark}" = yes; then AC_DEFINE(PARALLEL_MARK) fi AC_DEFINE(THREAD_LOCAL_ALLOC) ;; *-*-kfreebsd*-gnu) AC_DEFINE(GC_FREEBSD_THREADS) AM_CFLAGS="$AM_CFLAGS -pthread" THREADDLLIBS=-pthread AC_DEFINE(_REENTRANT) if test "${enable_parallel_mark}" = yes; then AC_DEFINE(PARALLEL_MARK) fi AC_DEFINE(THREAD_LOCAL_ALLOC) AC_DEFINE(USE_COMPILER_TLS) ;; *-*-gnu*) AC_DEFINE(GC_GNU_THREADS) AC_DEFINE(_REENTRANT) AC_DEFINE(THREAD_LOCAL_ALLOC) ;; *-*-netbsd*) AC_MSG_WARN("Only on NetBSD 2.0 or later.") AC_DEFINE(GC_NETBSD_THREADS) AC_DEFINE(_REENTRANT) AC_DEFINE(_PTHREADS) THREADDLLIBS="-lpthread -lrt" ;; *-*-solaris*) AC_DEFINE(GC_SOLARIS_THREADS) if test "${enable_parallel_mark}" != no; then AC_DEFINE(PARALLEL_MARK) fi AC_DEFINE(THREAD_LOCAL_ALLOC) # Need to use alternate thread library, otherwise gctest hangs # on Solaris 8. multi_os_directory=`$CC -print-multi-os-directory` THREADDLLIBS="-L/usr/lib/lwp/$multi_os_directory \ -R/usr/lib/lwp/$multi_os_directory -lpthread -lrt" ;; *-*-irix*) AC_DEFINE(GC_IRIX_THREADS) ;; *-*-cygwin*) AC_DEFINE(GC_WIN32_THREADS) if test "${enable_parallel_mark}" != no; then AC_DEFINE(PARALLEL_MARK) fi AC_DEFINE(THREAD_LOCAL_ALLOC) # Cygwin doesn't have a real libpthread, so Libtool can't link # against it. THREADDLLIBS="" win32_threads=true ;; *-*-mingw*) AC_DEFINE(GC_WIN32_PTHREADS) # Using pthreads-win32 (or other non-Cygwin pthreads) library. if test "${enable_parallel_mark}" != no; then AC_DEFINE(PARALLEL_MARK) fi AC_DEFINE(THREAD_LOCAL_ALLOC) THREADDLLIBS="-lpthread" win32_threads=true ;; *-*-darwin*) AC_DEFINE(GC_DARWIN_THREADS) AC_MSG_WARN("Explicit GC_INIT() calls may be required."); # Parallel-mark is not well-tested on Darwin if test "${enable_parallel_mark}" != no; then AC_DEFINE(PARALLEL_MARK) fi AC_DEFINE(THREAD_LOCAL_ALLOC) darwin_threads=true ;; *-*-osf*) AC_DEFINE(GC_OSF1_THREADS) if test "${enable_parallel_mark}" = yes; then AC_DEFINE(PARALLEL_MARK) AC_DEFINE(THREAD_LOCAL_ALLOC) AC_MSG_WARN("Explicit GC_INIT() calls may be required."); # May want to enable it in other cases, too. # Measurements have not yet been done. fi AM_CFLAGS="$AM_CFLAGS -pthread" THREADDLLIBS="-lpthread -lrt" ;; *) AC_MSG_ERROR("Pthreads not supported by the GC on this platform.") ;; esac case "$host" in sparc*-*-solaris*) if test "$GCC" != yes; then need_atomic_ops_asm=true fi ;; esac ;; win32) AC_DEFINE(GC_WIN32_THREADS) if test "${enable_parallel_mark}" != no; then AC_DEFINE(PARALLEL_MARK) AC_DEFINE(THREAD_LOCAL_ALLOC) else if test "${enable_shared}" != yes || test "${enable_static}" != no; then # Imply THREAD_LOCAL_ALLOC unless GC_DLL. AC_DEFINE(THREAD_LOCAL_ALLOC) fi fi if test "${enable_win32_dllmain}" = yes; then AC_DEFINE(GC_INSIDE_DLL, 1, [Enable Win32 DllMain-based approach of threads registering.]) fi win32_threads=true AC_DEFINE([EMPTY_GETENV_RESULTS], [1], [Wine getenv may not return NULL for missing entry.]) ;; dgux386) THREADS=dgux386 AC_MSG_RESULT($THREADDLLIBS) # Use pthread GCC switch THREADDLLIBS=-pthread if test "${enable_parallel_mark}" = yes; then AC_DEFINE(PARALLEL_MARK) fi AC_DEFINE(THREAD_LOCAL_ALLOC) AC_MSG_WARN("Explicit GC_INIT() calls may be required."); AC_DEFINE([GC_DGUX386_THREADS], 1, [Define to enable support for DB/UX threads on i386.]) AC_DEFINE([DGUX_THREADS], 1, [Define to enable support for DB/UX threads.]) # Enable _POSIX4A_DRAFT10_SOURCE with flag -pthread AM_CFLAGS="-pthread $AM_CFLAGS" ;; aix) THREADS=posix THREADDLLIBS=-lpthread AC_DEFINE(GC_AIX_THREADS) AC_DEFINE(_REENTRANT) ;; rtems) THREADS=posix AC_DEFINE(GC_RTEMS_PTHREADS) AC_DEFINE(THREAD_LOCAL_ALLOC) ;; decosf1 | irix | mach | os2 | solaris | dce | vxworks) AC_MSG_ERROR(thread package $THREADS not yet supported) ;; *) AC_MSG_ERROR($THREADS is an unknown thread package) ;; esac AC_SUBST(THREADDLLIBS) AM_CONDITIONAL(THREADS, test x$THREADS != xnone) AM_CONDITIONAL(PTHREADS, test x$THREADS = xposix) AM_CONDITIONAL(DARWIN_THREADS, test x$darwin_threads = xtrue) AM_CONDITIONAL(WIN32_THREADS, test x$win32_threads = xtrue) compiler_suncc=no case "$host" in powerpc-*-darwin*) powerpc_darwin=true ;; *-*-solaris*) if test "$GCC" != yes; then # Solaris SunCC compiler_suncc=yes CFLAGS="-O $CFLAGS" fi ;; *-*-wince*) if test "$enable_gc_debug" != "no"; then AC_DEFINE([GC_READ_ENV_FILE], 1, [Read environment variables from the GC 'env' file.]) fi ;; esac if test "$GCC" = yes; then # Output all warnings. AC_MSG_CHECKING(for gcc -Wextra) old_CFLAGS="$CFLAGS" CFLAGS="-Wextra $CFLAGS" AC_TRY_COMPILE([],[], [ac_cv_cc_wextra=yes], [ac_cv_cc_wextra=no]) CFLAGS="$old_CFLAGS" AC_MSG_RESULT($ac_cv_cc_wextra) AS_IF([test "$ac_cv_cc_wextra" = yes], [WEXTRA="-Wextra"], [WEXTRA="-W"]) CFLAGS="-Wall $WEXTRA $CFLAGS" fi AC_MSG_CHECKING(for xlc) AC_TRY_COMPILE([],[ #ifndef __xlC__ # error #endif ], [compiler_xlc=yes], [compiler_xlc=no]) AC_MSG_RESULT($compiler_xlc) if test $compiler_xlc = yes -a "$powerpc_darwin" = true; then # the darwin stack-frame-walking code is completely broken on xlc AC_DEFINE([DARWIN_DONT_PARSE_STACK], 1, [See doc/README.macros.]) fi # XLC neither requires nor tolerates the unnecessary assembler goop. # Similar for the Sun C compiler. AM_CONDITIONAL([ASM_WITH_CPP_UNSUPPORTED], [test $compiler_xlc = yes -o $compiler_suncc = yes]) if test "$GCC" = yes; then # Disable aliasing optimization unless forced to. AC_MSG_CHECKING([whether gcc supports -fno-strict-aliasing]) ac_cv_fno_strict_aliasing=no for cflag in $CFLAGS; do case "$cflag" in -fstrict-aliasing) # Opposite option already present ac_cv_fno_strict_aliasing=skipped break ;; esac done if test "$ac_cv_fno_strict_aliasing" != skipped; then old_CFLAGS="$CFLAGS" CFLAGS="$CFLAGS -fno-strict-aliasing" AC_TRY_COMPILE([],[], [ac_cv_fno_strict_aliasing=yes], []) CFLAGS="$old_CFLAGS" AS_IF([test "$ac_cv_fno_strict_aliasing" = yes], [CFLAGS="$CFLAGS -fno-strict-aliasing"], []) fi AC_MSG_RESULT($ac_cv_fno_strict_aliasing) fi case "$host" in # While IRIX 6 has libdl for the O32 and N32 ABIs, it's missing for N64 # and unnecessary everywhere. mips-sgi-irix6*) ;; # We never want libdl on darwin. It is a fake libdl that just ends up making # dyld calls anyway. The same applies to Cygwin. *-*-darwin*) ;; *-*-cygwin*) ;; *) AC_CHECK_LIB(dl, dlopen, THREADDLLIBS="$THREADDLLIBS -ldl") ;; esac case "$host" in *-*-hpux*) avoid_cpp_lib=yes;; *) avoid_cpp_lib=no; ;; esac AM_CONDITIONAL(AVOID_CPP_LIB,test $avoid_cpp_lib = yes) # extra LD Flags which are required for targets case "${host}" in *-*-darwin*) extra_ldflags_libgc=-Wl,-single_module ;; esac AC_SUBST(extra_ldflags_libgc) AC_SUBST(EXTRA_TEST_LIBS) target_all=libgc.la AC_SUBST(target_all) dnl If the target is an eCos system, use the appropriate eCos dnl I/O routines. dnl FIXME: this should not be a local option but a global target dnl system; at present there is no eCos target. TARGET_ECOS="no" AC_ARG_WITH(ecos, [ --with-ecos enable runtime eCos target support], TARGET_ECOS="$with_ecos" ) addobjs= addlibs= CXXLIBS= case "$TARGET_ECOS" in no) ;; *) AC_DEFINE([ECOS], 1, [Define to enable eCos target support.]) AM_CPPFLAGS="-I${TARGET_ECOS}/include $AM_CPPFLAGS" addobjs="$addobjs ecos.lo" ;; esac AM_CONDITIONAL(CPLUSPLUS, test "${enable_cplusplus}" = yes) if test "$GCC" = yes; then if test "${enable_cplusplus}" = yes; then case "$host" in *-*-cygwin* | *-*-mingw*) AC_MSG_CHECKING([whether libsupc++ required]) SUPC="`$CXX -print-file-name=libsupc++.a 2>/dev/null`" if test -n "$SUPC" -a "$SUPC" != "libsupc++.a"; then AC_MSG_RESULT(yes) CXXLIBS="-lsupc++" else AC_MSG_RESULT(no) fi ;; esac fi fi AC_SUBST(CXX) AC_SUBST(AM_CFLAGS) AC_SUBST(AM_CPPFLAGS) AC_SUBST(CXXLIBS) # Configuration of shared libraries # AC_MSG_CHECKING(whether to build shared libraries) AC_ENABLE_SHARED case "$host" in alpha-*-openbsd*) enable_shared=no ;; *) ;; esac AC_MSG_RESULT($enable_shared) # Compile with GC_DLL defined unless building static libraries. if test "${enable_shared}" = yes; then if test "${enable_static}" = no; then AC_DEFINE(GC_DLL) if test "$GCC" = yes; then # Pass -fvisibility=hidden option if supported AC_MSG_CHECKING([whether gcc supports -fvisibility]) old_CFLAGS="$CFLAGS" CFLAGS="-Werror -fvisibility=hidden $CFLAGS" AC_TRY_COMPILE([],[], [ac_cv_fvisibility_hidden=yes], [ac_cv_fvisibility_hidden=no]) CFLAGS="$old_CFLAGS" AS_IF([test "$ac_cv_fvisibility_hidden" = yes], [CFLAGS="-DGC_VISIBILITY_HIDDEN_SET -fvisibility=hidden $CFLAGS"]) AC_MSG_RESULT($ac_cv_fvisibility_hidden) fi fi fi # Configuration of machine-dependent code # AC_MSG_CHECKING(which machine-dependent code should be used) machdep= case "$host" in alpha-*-openbsd*) if test x"${ac_cv_lib_dl_dlopen}" != xyes ; then AC_MSG_WARN( "OpenBSD/Alpha without dlopen(). Shared library support is disabled.") fi ;; i?86-*-solaris2.[[89]]) # PROC_VDB appears to work in 2.8 and 2.9 but not in 2.10+ (for now). AC_DEFINE([SOLARIS25_PROC_VDB_BUG_FIXED], 1, [See the comment in gcconfig.h.]) ;; mips-*-*) dnl AC_DEFINE(NO_EXECUTE_PERMISSION) dnl This is now redundant, but it is also important for incremental GC dnl performance under Irix. ;; sparc-*-netbsd*) machdep="sparc_netbsd_mach_dep.lo" ;; sparc*-*-linux* | sparc*-*-openbsd* | sparc64-*-freebsd* | sparc64-*-netbsd*) machdep="sparc_mach_dep.lo" ;; sparc-sun-solaris2.3) machdep="sparc_mach_dep.lo" AC_DEFINE(SUNOS53_SHARED_LIB, 1, [Define to work around a Solaris 5.3 bug (see dyn_load.c).]) ;; sparc*-sun-solaris2*) machdep="sparc_mach_dep.lo" ;; ia64-*-*) machdep="ia64_save_regs_in_stack.lo" ;; esac AC_MSG_RESULT($machdep) addobjs="$addobjs $machdep" AC_SUBST(addobjs) AC_SUBST(addlibs) AC_PROG_LIBTOOL dnl We use these options to decide which functions to include. AC_ARG_WITH(target-subdir, [ --with-target-subdir=SUBDIR configuring with a cross compiler]) AC_ARG_WITH(cross-host, [ --with-cross-host=HOST configuring with a cross compiler]) # automake wants to see AC_EXEEXT. But we don't need it. And having # it is actually a problem, because the compiler we're passed can't # necessarily do a full link. So we fool automake here. if false; then # autoconf 2.50 runs AC_EXEEXT by default, and the macro expands # to nothing, so nothing would remain between `then' and `fi' if it # were not for the `:' below. : AC_EXEEXT fi dnl As of 4.13a2, the collector will not properly work on Solaris when dnl built with gcc and -O. So we remove -O in the appropriate case. dnl Not needed anymore on Solaris. AC_MSG_CHECKING(whether Solaris gcc optimization fix is necessary) case "$host" in *aix*) if test "$GCC" = yes; then AC_MSG_RESULT(yes) new_CFLAGS= for i in $CFLAGS; do case "$i" in -O*) ;; *) new_CFLAGS="$new_CFLAGS $i" ;; esac done CFLAGS="$new_CFLAGS" else AC_MSG_RESULT(no) fi ;; *) AC_MSG_RESULT(no) ;; esac dnl Include defines that have become de facto standard. dnl ALL_INTERIOR_POINTERS and NO_EXECUTE_PERMISSION can be overridden dnl in the startup code. AC_DEFINE([NO_EXECUTE_PERMISSION], [1], [Define to make the collector not allocate executable memory by default.]) AC_DEFINE([ALL_INTERIOR_POINTERS], [1], [Define to recognise all pointers to the interior of objects.]) dnl Interface Selection dnl ------------------- dnl dnl By default, make the library as general as possible. dnl enable_gcj_support=no AC_ARG_ENABLE(gcj-support, [AC_HELP_STRING([--disable-gcj-support], [Disable support for gcj.])]) if test x"$enable_gcj_support" != xno; then AC_DEFINE(GC_GCJ_SUPPORT, 1, [Define to include support for gcj.]) fi dnl Interaction with other programs that might use signals. AC_ARG_ENABLE(sigrt-signals, [AC_HELP_STRING([--enable-sigrt-signals], [Force GC to use SIGRTMIN-based signals for thread suspend/resume])]) if test x"${enable_sigrt_signals}" = xyes; then AC_DEFINE([GC_USESIGRT_SIGNALS], 1, [Force the GC to use signals based on SIGRTMIN+k.]) fi dnl Debugging dnl --------- AH_TEMPLATE([GC_HAVE_BUILTIN_BACKTRACE], [Define if backtrace information is supported.]) AH_TEMPLATE([MAKE_BACK_GRAPH], [See doc/README.macros.]) AH_TEMPLATE([SAVE_CALL_COUNT], [The number of caller frames saved when allocating with the debugging API.]) UNWINDLIBS= AC_ARG_ENABLE(gc-debug, [AC_HELP_STRING([--enable-gc-debug], [include full support for pointer backtracing etc.])], [ if test "$enable_gc_debug" = "yes"; then AC_MSG_WARN("Should define GC_DEBUG and use debug alloc in clients.") AC_DEFINE([KEEP_BACK_PTRS], 1, [Define to save back-pointers in debugging headers.]) keep_back_ptrs=true AC_DEFINE([DBG_HDRS_ALL], 1, [Define to force debug headers on all objects.]) AH_TEMPLATE([SHORT_DBG_HDRS], [Shorten the headers to minimize object size at the expense of checking for writes past the end (see doc/README.macros).]) case $host in ia64-*-linux* ) AC_DEFINE(MAKE_BACK_GRAPH) AC_DEFINE(SAVE_CALL_COUNT, 8) AC_CHECK_LIB(unwind, backtrace, [ AC_DEFINE(GC_HAVE_BUILTIN_BACKTRACE) UNWINDLIBS=-lunwind AC_MSG_WARN("Client code may need to link against libunwind.") ]) ;; x86-*-linux* | i586-*-linux* | i686-*-linux* | x86_64-*-linux* ) AC_DEFINE(MAKE_BACK_GRAPH) AC_MSG_WARN("Client must not use -fomit-frame-pointer.") AC_DEFINE(SAVE_CALL_COUNT, 8) ;; i[3456]86-*-dgux*) AC_DEFINE(MAKE_BACK_GRAPH) ;; esac ] fi) AM_CONDITIONAL([MAKE_BACK_GRAPH], [test x"$enable_gc_debug" = xyes]) AM_CONDITIONAL([KEEP_BACK_PTRS], [test x"$keep_back_ptrs" = xtrue]) # Check for dladdr (used for debugging). AC_MSG_CHECKING(for dladdr) have_dladdr=no AC_TRY_COMPILE([ #define _GNU_SOURCE 1 #include ], [{ Dl_info info; (void)dladdr("", &info); }], [ have_dladdr=yes ]) AC_MSG_RESULT($have_dladdr) if test x"$have_dladdr" = xyes; then AC_DEFINE([HAVE_DLADDR], 1, [Define to use 'dladdr' function.]) fi # Check for AViiON Machines running DGUX ac_is_dgux=no AC_CHECK_HEADER(sys/dg_sys_info.h, [ac_is_dgux=yes;]) ## :GOTCHA: we do not check anything but sys/dg_sys_info.h if test $ac_is_dgux = yes; then dgux_spec_opts="-DDGUX -D_DGUX_SOURCE -Di386 -mno-legend -O2" CFLAGS="$dgux_spec_opts $CFLAGS" CXXFLAGS="$dgux_spec_opts $CXXFLAGS" if test "$enable_gc_debug" = "yes"; then CFLAGS="-g -mstandard $CFLAGS" CXXFLAGS="-g -mstandard $CXXFLAGS" fi AC_SUBST(CFLAGS) AC_SUBST(CXXFLAGS) fi AC_ARG_ENABLE(java-finalization, [AC_HELP_STRING([--disable-java-finalization], [Disable support for java finalization.])]) if test x"$enable_java_finalization" != xno; then AC_DEFINE([JAVA_FINALIZATION], 1, [See doc/README.macros.]) fi AC_ARG_ENABLE(atomic-uncollectable, [AC_HELP_STRING([--disable-atomic-uncollectible], [Disable support for atomic uncollectible allocation.])]) if test x"$enable_atomic_uncollectible" != x"no"; then AC_DEFINE(ATOMIC_UNCOLLECTABLE, 1, [Define to enable atomic uncollectible allocation.]) fi AC_ARG_ENABLE(redirect-malloc, [AC_HELP_STRING([--enable-redirect-malloc], [Redirect malloc and friends to GC routines])]) if test "${enable_redirect_malloc}" = yes; then if test "${enable_gc_debug}" = yes; then AC_DEFINE([REDIRECT_MALLOC], GC_debug_malloc_replacement, [If defined, redirect malloc to this function.]) AC_DEFINE([REDIRECT_REALLOC], GC_debug_realloc_replacement, [If defined, redirect GC_realloc to this function.]) AC_DEFINE([REDIRECT_FREE], GC_debug_free, [If defined, redirect free to this function.]) else AC_DEFINE(REDIRECT_MALLOC, GC_malloc) fi AC_DEFINE([GC_USE_DLOPEN_WRAP], 1, [See doc/README.macros.]) fi AC_ARG_ENABLE(disclaim, [AC_HELP_STRING([--disable-disclaim], [Disable alternative (more efficient) finalization interface.])]) if test x"$enable_disclaim" != xno; then AC_DEFINE(ENABLE_DISCLAIM, 1, [Define to enable alternative finalization interface.]) fi AM_CONDITIONAL(ENABLE_DISCLAIM, [test x"$enable_disclaim" != xno]) AC_ARG_ENABLE(large-config, [AC_HELP_STRING([--enable-large-config], [Optimize for large (> 100 MB) heap or root set])]) if test "${enable_large_config}" = yes; then AC_DEFINE(LARGE_CONFIG, 1, [Define to optimize for large heaps or root sets.]) fi AC_ARG_ENABLE(handle-fork, [AC_HELP_STRING([--enable-handle-fork], [Attempt to ensure a usable collector after fork() in multi-threaded programs.])]) if test "${enable_handle_fork}" = yes; then AC_DEFINE(HANDLE_FORK, 1, [Define to install pthread_atfork() handlers by default.]) elif test "${enable_handle_fork}" = no; then AC_DEFINE(NO_HANDLE_FORK, 1, [Prohibit installation of pthread_atfork() handlers.]) fi dnl This is something of a hack. When cross-compiling we turn off dnl some functionality. We also enable the "small" configuration. dnl These is only correct when targetting an embedded system. FIXME. if test -n "${with_cross_host}"; then AC_DEFINE([NO_CLOCK], 1, [Define to not use system clock (cross compiling).]) AC_DEFINE([SMALL_CONFIG], 1, [Define to tune the collector for small heap sizes.]) fi if test "$enable_gc_debug" = "no"; then AC_DEFINE([NO_DEBUGGING], 1, [Disable debugging, like GC_dump and its callees.]) fi AC_SUBST(UNWINDLIBS) AC_ARG_ENABLE(gc-assertions, [AC_HELP_STRING([--enable-gc-assertions], [collector-internal assertion checking])]) if test "${enable_gc_assertions}" = yes; then AC_DEFINE([GC_ASSERTIONS], 1, [Define to enable internal debug assertions.]) fi AC_ARG_ENABLE(munmap, [AC_HELP_STRING([--enable-munmap=N], [return page to the os if empty for N collections])], MUNMAP_THRESHOLD=$enableval) if test "${enable_munmap}" != ""; then AC_DEFINE([USE_MMAP], 1, [Define to use mmap instead of sbrk to expand the heap.]) case "$host" in *-*-cygwin*) # Workaround for Cygwin: use VirtualAlloc since mmap(PROT_NONE) fails AC_DEFINE([USE_WINALLOC], 1, [Define to use Win32 VirtualAlloc (instead of sbrk or mmap) to expand the heap.]) ;; esac AC_DEFINE([USE_MUNMAP], 1, [Define to return memory to OS with munmap calls (see doc/README.macros).]) if test "${MUNMAP_THRESHOLD}" = "yes"; then MUNMAP_THRESHOLD=6 fi AC_DEFINE_UNQUOTED([MUNMAP_THRESHOLD], [${MUNMAP_THRESHOLD}], [Number of GC cycles to wait before unmapping an unused block.]) else if test "${gc_use_mmap}" = "yes"; then AC_DEFINE([USE_MMAP], 1, [Define to use mmap instead of sbrk to expand the heap.]) fi fi AM_CONDITIONAL(USE_LIBDIR, test -z "$with_cross_host") AC_ARG_ENABLE(single-obj-compilation, [AC_HELP_STRING([--enable-single-obj-compilation], [Compile all library .c files into single .o])], [single_obj_compilation=yes]) AM_CONDITIONAL([SINGLE_GC_OBJ], [test "$single_obj_compilation" = "yes"]) # Atomic Ops # ---------- # Do we want to use an external libatomic_ops? By default use it if it's # found. AC_ARG_WITH([libatomic-ops], [AS_HELP_STRING([--with-libatomic-ops[=yes|no|check]], [Use a external libatomic_ops? (default: check)])], [], [with_libatomic_ops=check]) # Check for an external libatomic_ops if the answer was yes or check. If not # found, fail on yes, and convert check to no. # Note: "syntax error near unexpected token ATOMIC_OPS" reported by configure # means Autotools pkg.m4 file was not found during aclocal.m4 generation. missing_libatomic_ops=false AS_IF([test x"$with_libatomic_ops" != xno], [ PKG_CHECK_MODULES([ATOMIC_OPS], [atomic_ops], [], [ missing_libatomic_ops=true ]) ]) AS_IF([test x$missing_libatomic_ops = xtrue ], [ AS_IF([test x"$with_libatomic_ops" != xcheck], [ AC_MSG_ERROR([An external libatomic_ops was not found]) ]) with_libatomic_ops=no ]) # If we have neither an external or an internal version, offer a useful hint # and exit. AS_IF([test x"$with_libatomic_ops" = xno -a ! -e "$srcdir/libatomic_ops"], [ AC_MSG_ERROR([libatomic_ops is required. You can either install it on your system, or fetch and unpack a recent version into the source directory and link or rename it to libatomic_ops.]) ]) # Finally, emit the definitions for bundled or external AO. AC_MSG_CHECKING([which libatomic_ops to use]) AS_IF([test x"$with_libatomic_ops" != xno], [ AC_MSG_RESULT([external]) ], [ AC_MSG_RESULT([internal]) ATOMIC_OPS_CFLAGS='-I$(top_builddir)/libatomic_ops/src -I$(top_srcdir)/libatomic_ops/src' ATOMIC_OPS_LIBS="" AC_SUBST([ATOMIC_OPS_CFLAGS]) AC_CONFIG_SUBDIRS([libatomic_ops]) ]) AM_CONDITIONAL([USE_INTERNAL_LIBATOMIC_OPS], [test x$with_libatomic_ops = xno -a x"$THREADS" != xnone]) AM_CONDITIONAL([NEED_ATOMIC_OPS_ASM], [test x$with_libatomic_ops = xno -a x$need_atomic_ops_asm = xtrue]) dnl Produce the Files dnl ----------------- AC_CONFIG_FILES([Makefile bdw-gc.pc]) AC_CONFIG_COMMANDS([default],, [ srcdir="${srcdir}" host=${host} CONFIG_SHELL=${CONFIG_SHELL-/bin/sh} CC="${CC}" DEFS="$DEFS" ]) AC_OUTPUT ecl-16.1.2/src/bdwgc/cord/000077500000000000000000000000001266352375300151645ustar00rootroot00000000000000ecl-16.1.2/src/bdwgc/cord/cord.am000066400000000000000000000012711266352375300164330ustar00rootroot00000000000000 lib_LTLIBRARIES += libcord.la libcord_la_LIBADD = $(top_builddir)/libgc.la libcord_la_LDFLAGS = -version-info 1:3:0 -no-undefined libcord_la_CPPFLAGS = $(AM_CPPFLAGS) libcord_la_SOURCES = \ cord/cordbscs.c \ cord/cordprnt.c \ cord/cordxtra.c TESTS += cordtest$(EXEEXT) check_PROGRAMS += cordtest cordtest_SOURCES = cord/tests/cordtest.c cordtest_LDADD = $(top_builddir)/libgc.la $(top_builddir)/libcord.la EXTRA_DIST += \ cord/tests/de.c \ cord/tests/de_cmds.h \ cord/tests/de_win.c \ cord/tests/de_win.h \ cord/tests/de_win.rc pkginclude_HEADERS += \ include/cord.h \ include/cord_pos.h \ include/ec.h ecl-16.1.2/src/bdwgc/cord/cordbscs.c000066400000000000000000000705371266352375300171460ustar00rootroot00000000000000/* * Copyright (c) 1993-1994 by Xerox Corporation. All rights reserved. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. */ #ifdef HAVE_CONFIG_H # include "config.h" #endif #ifndef CORD_BUILD # define CORD_BUILD #endif # include "gc.h" # include "cord.h" # include # include # include /* An implementation of the cord primitives. These are the only */ /* Functions that understand the representation. We perform only */ /* minimal checks on arguments to these functions. Out of bounds */ /* arguments to the iteration functions may result in client functions */ /* invoked on garbage data. In most cases, client functions should be */ /* programmed defensively enough that this does not result in memory */ /* smashes. */ typedef void (* oom_fn)(void); oom_fn CORD_oom_fn = (oom_fn) 0; # define OUT_OF_MEMORY { if (CORD_oom_fn != (oom_fn) 0) (*CORD_oom_fn)(); \ ABORT("Out of memory\n"); } # define ABORT(msg) { fprintf(stderr, "%s\n", msg); abort(); } typedef unsigned long word; typedef union { struct Concatenation { char null; char header; char depth; /* concatenation nesting depth. */ unsigned char left_len; /* Length of left child if it is sufficiently */ /* short; 0 otherwise. */ # define MAX_LEFT_LEN 255 word len; CORD left; /* length(left) > 0 */ CORD right; /* length(right) > 0 */ } concatenation; struct Function { char null; char header; char depth; /* always 0 */ char left_len; /* always 0 */ word len; CORD_fn fn; void * client_data; } function; struct Generic { char null; char header; char depth; char left_len; word len; } generic; char string[1]; } CordRep; # define CONCAT_HDR 1 # define FN_HDR 4 # define SUBSTR_HDR 6 /* Substring nodes are a special case of function nodes. */ /* The client_data field is known to point to a substr_args */ /* structure, and the function is either CORD_apply_access_fn */ /* or CORD_index_access_fn. */ /* The following may be applied only to function and concatenation nodes: */ #define IS_CONCATENATION(s) (((CordRep *)s)->generic.header == CONCAT_HDR) #define IS_FUNCTION(s) ((((CordRep *)s)->generic.header & FN_HDR) != 0) #define IS_SUBSTR(s) (((CordRep *)s)->generic.header == SUBSTR_HDR) #define LEN(s) (((CordRep *)s) -> generic.len) #define DEPTH(s) (((CordRep *)s) -> generic.depth) #define GEN_LEN(s) (CORD_IS_STRING(s) ? strlen(s) : LEN(s)) #define LEFT_LEN(c) ((c) -> left_len != 0? \ (c) -> left_len \ : (CORD_IS_STRING((c) -> left) ? \ (c) -> len - GEN_LEN((c) -> right) \ : LEN((c) -> left))) #define SHORT_LIMIT (sizeof(CordRep) - 1) /* Cords shorter than this are C strings */ /* Dump the internal representation of x to stdout, with initial */ /* indentation level n. */ void CORD_dump_inner(CORD x, unsigned n) { register size_t i; for (i = 0; i < (size_t)n; i++) { fputs(" ", stdout); } if (x == 0) { fputs("NIL\n", stdout); } else if (CORD_IS_STRING(x)) { for (i = 0; i <= SHORT_LIMIT; i++) { if (x[i] == '\0') break; putchar(x[i]); } if (x[i] != '\0') fputs("...", stdout); putchar('\n'); } else if (IS_CONCATENATION(x)) { register struct Concatenation * conc = &(((CordRep *)x) -> concatenation); printf("Concatenation: %p (len: %d, depth: %d)\n", x, (int)(conc -> len), (int)(conc -> depth)); CORD_dump_inner(conc -> left, n+1); CORD_dump_inner(conc -> right, n+1); } else /* function */{ register struct Function * func = &(((CordRep *)x) -> function); if (IS_SUBSTR(x)) printf("(Substring) "); printf("Function: %p (len: %d): ", x, (int)(func -> len)); for (i = 0; i < 20 && i < func -> len; i++) { putchar((*(func -> fn))(i, func -> client_data)); } if (i < func -> len) fputs("...", stdout); putchar('\n'); } } /* Dump the internal representation of x to stdout */ void CORD_dump(CORD x) { CORD_dump_inner(x, 0); fflush(stdout); } CORD CORD_cat_char_star(CORD x, const char * y, size_t leny) { register size_t result_len; register size_t lenx; register int depth; if (x == CORD_EMPTY) return(y); if (leny == 0) return(x); if (CORD_IS_STRING(x)) { lenx = strlen(x); result_len = lenx + leny; if (result_len <= SHORT_LIMIT) { register char * result = GC_MALLOC_ATOMIC(result_len+1); if (result == 0) OUT_OF_MEMORY; memcpy(result, x, lenx); memcpy(result + lenx, y, leny); result[result_len] = '\0'; return((CORD) result); } else { depth = 1; } } else { register CORD right; register CORD left; register char * new_right; register size_t right_len; lenx = LEN(x); if (leny <= SHORT_LIMIT/2 && IS_CONCATENATION(x) && CORD_IS_STRING(right = ((CordRep *)x) -> concatenation.right)) { /* Merge y into right part of x. */ if (!CORD_IS_STRING(left = ((CordRep *)x) -> concatenation.left)) { right_len = lenx - LEN(left); } else if (((CordRep *)x) -> concatenation.left_len != 0) { right_len = lenx - ((CordRep *)x) -> concatenation.left_len; } else { right_len = strlen(right); } result_len = right_len + leny; /* length of new_right */ if (result_len <= SHORT_LIMIT) { new_right = GC_MALLOC_ATOMIC(result_len + 1); if (new_right == 0) OUT_OF_MEMORY; memcpy(new_right, right, right_len); memcpy(new_right + right_len, y, leny); new_right[result_len] = '\0'; y = new_right; leny = result_len; x = left; lenx -= right_len; /* Now fall through to concatenate the two pieces: */ } if (CORD_IS_STRING(x)) { depth = 1; } else { depth = DEPTH(x) + 1; } } else { depth = DEPTH(x) + 1; } result_len = lenx + leny; } { /* The general case; lenx, result_len is known: */ register struct Concatenation * result; result = GC_NEW(struct Concatenation); if (result == 0) OUT_OF_MEMORY; result->header = CONCAT_HDR; result->depth = depth; if (lenx <= MAX_LEFT_LEN) result->left_len = lenx; result->len = result_len; result->left = x; result->right = y; if (depth >= MAX_DEPTH) { return(CORD_balance((CORD)result)); } else { return((CORD) result); } } } CORD CORD_cat(CORD x, CORD y) { register size_t result_len; register int depth; register size_t lenx; if (x == CORD_EMPTY) return(y); if (y == CORD_EMPTY) return(x); if (CORD_IS_STRING(y)) { return(CORD_cat_char_star(x, y, strlen(y))); } else if (CORD_IS_STRING(x)) { lenx = strlen(x); depth = DEPTH(y) + 1; } else { register int depthy = DEPTH(y); lenx = LEN(x); depth = DEPTH(x) + 1; if (depthy >= depth) depth = depthy + 1; } result_len = lenx + LEN(y); { register struct Concatenation * result; result = GC_NEW(struct Concatenation); if (result == 0) OUT_OF_MEMORY; result->header = CONCAT_HDR; result->depth = depth; if (lenx <= MAX_LEFT_LEN) result->left_len = lenx; result->len = result_len; result->left = x; result->right = y; if (depth >= MAX_DEPTH) { return(CORD_balance((CORD)result)); } else { return((CORD) result); } } } CORD CORD_from_fn(CORD_fn fn, void * client_data, size_t len) { if (len <= 0) return(0); if (len <= SHORT_LIMIT) { register char * result; register size_t i; char buf[SHORT_LIMIT+1]; register char c; for (i = 0; i < len; i++) { c = (*fn)(i, client_data); if (c == '\0') goto gen_case; buf[i] = c; } result = GC_MALLOC_ATOMIC(len+1); if (result == 0) OUT_OF_MEMORY; memcpy(result, buf, len); result[len] = '\0'; return((CORD) result); } gen_case: { register struct Function * result; result = GC_NEW(struct Function); if (result == 0) OUT_OF_MEMORY; result->header = FN_HDR; /* depth is already 0 */ result->len = len; result->fn = fn; result->client_data = client_data; return((CORD) result); } } size_t CORD_len(CORD x) { if (x == 0) { return(0); } else { return(GEN_LEN(x)); } } struct substr_args { CordRep * sa_cord; size_t sa_index; }; char CORD_index_access_fn(size_t i, void * client_data) { register struct substr_args *descr = (struct substr_args *)client_data; return(((char *)(descr->sa_cord))[i + descr->sa_index]); } char CORD_apply_access_fn(size_t i, void * client_data) { register struct substr_args *descr = (struct substr_args *)client_data; register struct Function * fn_cord = &(descr->sa_cord->function); return((*(fn_cord->fn))(i + descr->sa_index, fn_cord->client_data)); } /* A version of CORD_substr that simply returns a function node, thus */ /* postponing its work. The fourth argument is a function that may */ /* be used for efficient access to the ith character. */ /* Assumes i >= 0 and i + n < length(x). */ CORD CORD_substr_closure(CORD x, size_t i, size_t n, CORD_fn f) { register struct substr_args * sa = GC_NEW(struct substr_args); CORD result; if (sa == 0) OUT_OF_MEMORY; sa->sa_cord = (CordRep *)x; sa->sa_index = i; result = CORD_from_fn(f, (void *)sa, n); if (result == CORD_EMPTY) return CORD_EMPTY; /* n == 0 */ ((CordRep *)result) -> function.header = SUBSTR_HDR; return (result); } # define SUBSTR_LIMIT (10 * SHORT_LIMIT) /* Substrings of function nodes and flat strings shorter than */ /* this are flat strings. Othewise we use a functional */ /* representation, which is significantly slower to access. */ /* A version of CORD_substr that assumes i >= 0, n > 0, and i + n < length(x).*/ CORD CORD_substr_checked(CORD x, size_t i, size_t n) { if (CORD_IS_STRING(x)) { if (n > SUBSTR_LIMIT) { return(CORD_substr_closure(x, i, n, CORD_index_access_fn)); } else { register char * result = GC_MALLOC_ATOMIC(n+1); if (result == 0) OUT_OF_MEMORY; strncpy(result, x+i, n); result[n] = '\0'; return(result); } } else if (IS_CONCATENATION(x)) { register struct Concatenation * conc = &(((CordRep *)x) -> concatenation); register size_t left_len; register size_t right_len; left_len = LEFT_LEN(conc); right_len = conc -> len - left_len; if (i >= left_len) { if (n == right_len) return(conc -> right); return(CORD_substr_checked(conc -> right, i - left_len, n)); } else if (i+n <= left_len) { if (n == left_len) return(conc -> left); return(CORD_substr_checked(conc -> left, i, n)); } else { /* Need at least one character from each side. */ register CORD left_part; register CORD right_part; register size_t left_part_len = left_len - i; if (i == 0) { left_part = conc -> left; } else { left_part = CORD_substr_checked(conc -> left, i, left_part_len); } if (i + n == right_len + left_len) { right_part = conc -> right; } else { right_part = CORD_substr_checked(conc -> right, 0, n - left_part_len); } return(CORD_cat(left_part, right_part)); } } else /* function */ { if (n > SUBSTR_LIMIT) { if (IS_SUBSTR(x)) { /* Avoid nesting substring nodes. */ register struct Function * f = &(((CordRep *)x) -> function); register struct substr_args *descr = (struct substr_args *)(f -> client_data); return(CORD_substr_closure((CORD)descr->sa_cord, i + descr->sa_index, n, f -> fn)); } else { return(CORD_substr_closure(x, i, n, CORD_apply_access_fn)); } } else { char * result; register struct Function * f = &(((CordRep *)x) -> function); char buf[SUBSTR_LIMIT+1]; register char * p = buf; register char c; register int j; register int lim = i + n; for (j = i; j < lim; j++) { c = (*(f -> fn))(j, f -> client_data); if (c == '\0') { return(CORD_substr_closure(x, i, n, CORD_apply_access_fn)); } *p++ = c; } result = GC_MALLOC_ATOMIC(n+1); if (result == 0) OUT_OF_MEMORY; memcpy(result, buf, n); result[n] = '\0'; return(result); } } } CORD CORD_substr(CORD x, size_t i, size_t n) { register size_t len = CORD_len(x); if (i >= len || n <= 0) return(0); /* n < 0 is impossible in a correct C implementation, but */ /* quite possible under SunOS 4.X. */ if (i + n > len) n = len - i; return(CORD_substr_checked(x, i, n)); } /* See cord.h for definition. We assume i is in range. */ int CORD_iter5(CORD x, size_t i, CORD_iter_fn f1, CORD_batched_iter_fn f2, void * client_data) { if (x == 0) return(0); if (CORD_IS_STRING(x)) { register const char *p = x+i; if (*p == '\0') ABORT("2nd arg to CORD_iter5 too big"); if (f2 != CORD_NO_FN) { return((*f2)(p, client_data)); } else { while (*p) { if ((*f1)(*p, client_data)) return(1); p++; } return(0); } } else if (IS_CONCATENATION(x)) { register struct Concatenation * conc = &(((CordRep *)x) -> concatenation); if (i > 0) { register size_t left_len = LEFT_LEN(conc); if (i >= left_len) { return(CORD_iter5(conc -> right, i - left_len, f1, f2, client_data)); } } if (CORD_iter5(conc -> left, i, f1, f2, client_data)) { return(1); } return(CORD_iter5(conc -> right, 0, f1, f2, client_data)); } else /* function */ { register struct Function * f = &(((CordRep *)x) -> function); register size_t j; register size_t lim = f -> len; for (j = i; j < lim; j++) { if ((*f1)((*(f -> fn))(j, f -> client_data), client_data)) { return(1); } } return(0); } } #undef CORD_iter int CORD_iter(CORD x, CORD_iter_fn f1, void * client_data) { return(CORD_iter5(x, 0, f1, CORD_NO_FN, client_data)); } int CORD_riter4(CORD x, size_t i, CORD_iter_fn f1, void * client_data) { if (x == 0) return(0); if (CORD_IS_STRING(x)) { register const char *p = x + i; register char c; for(;;) { c = *p; if (c == '\0') ABORT("2nd arg to CORD_riter4 too big"); if ((*f1)(c, client_data)) return(1); if (p == x) break; p--; } return(0); } else if (IS_CONCATENATION(x)) { register struct Concatenation * conc = &(((CordRep *)x) -> concatenation); register CORD left_part = conc -> left; register size_t left_len; left_len = LEFT_LEN(conc); if (i >= left_len) { if (CORD_riter4(conc -> right, i - left_len, f1, client_data)) { return(1); } return(CORD_riter4(left_part, left_len - 1, f1, client_data)); } else { return(CORD_riter4(left_part, i, f1, client_data)); } } else /* function */ { register struct Function * f = &(((CordRep *)x) -> function); register size_t j; for (j = i; ; j--) { if ((*f1)((*(f -> fn))(j, f -> client_data), client_data)) { return(1); } if (j == 0) return(0); } } } int CORD_riter(CORD x, CORD_iter_fn f1, void * client_data) { size_t len = CORD_len(x); if (len == 0) return(0); return(CORD_riter4(x, len - 1, f1, client_data)); } /* * The following functions are concerned with balancing cords. * Strategy: * Scan the cord from left to right, keeping the cord scanned so far * as a forest of balanced trees of exponentially decreasing length. * When a new subtree needs to be added to the forest, we concatenate all * shorter ones to the new tree in the appropriate order, and then insert * the result into the forest. * Crucial invariants: * 1. The concatenation of the forest (in decreasing order) with the * unscanned part of the rope is equal to the rope being balanced. * 2. All trees in the forest are balanced. * 3. forest[i] has depth at most i. */ typedef struct { CORD c; size_t len; /* Actual length of c */ } ForestElement; static size_t min_len [ MAX_DEPTH ]; static int min_len_init = 0; int CORD_max_len; typedef ForestElement Forest [ MAX_DEPTH ]; /* forest[i].len >= fib(i+1) */ /* The string is the concatenation */ /* of the forest in order of DECREASING */ /* indices. */ void CORD_init_min_len(void) { register int i; register size_t last, previous, current; min_len[0] = previous = 1; min_len[1] = last = 2; for (i = 2; i < MAX_DEPTH; i++) { current = last + previous; if (current < last) /* overflow */ current = last; min_len[i] = current; previous = last; last = current; } CORD_max_len = last - 1; min_len_init = 1; } void CORD_init_forest(ForestElement * forest, size_t max_len) { register int i; for (i = 0; i < MAX_DEPTH; i++) { forest[i].c = 0; if (min_len[i] > max_len) return; } ABORT("Cord too long"); } /* Add a leaf to the appropriate level in the forest, cleaning */ /* out lower levels as necessary. */ /* Also works if x is a balanced tree of concatenations; however */ /* in this case an extra concatenation node may be inserted above x; */ /* This node should not be counted in the statement of the invariants. */ void CORD_add_forest(ForestElement * forest, CORD x, size_t len) { register int i = 0; register CORD sum = CORD_EMPTY; register size_t sum_len = 0; while (len > min_len[i + 1]) { if (forest[i].c != 0) { sum = CORD_cat(forest[i].c, sum); sum_len += forest[i].len; forest[i].c = 0; } i++; } /* Sum has depth at most 1 greter than what would be required */ /* for balance. */ sum = CORD_cat(sum, x); sum_len += len; /* If x was a leaf, then sum is now balanced. To see this */ /* consider the two cases in which forest[i-1] either is or is */ /* not empty. */ while (sum_len >= min_len[i]) { if (forest[i].c != 0) { sum = CORD_cat(forest[i].c, sum); sum_len += forest[i].len; /* This is again balanced, since sum was balanced, and has */ /* allowable depth that differs from i by at most 1. */ forest[i].c = 0; } i++; } i--; forest[i].c = sum; forest[i].len = sum_len; } CORD CORD_concat_forest(ForestElement * forest, size_t expected_len) { register int i = 0; CORD sum = 0; size_t sum_len = 0; while (sum_len != expected_len) { if (forest[i].c != 0) { sum = CORD_cat(forest[i].c, sum); sum_len += forest[i].len; } i++; } return(sum); } /* Insert the frontier of x into forest. Balanced subtrees are */ /* treated as leaves. This potentially adds one to the depth */ /* of the final tree. */ void CORD_balance_insert(CORD x, size_t len, ForestElement * forest) { register int depth; if (CORD_IS_STRING(x)) { CORD_add_forest(forest, x, len); } else if (IS_CONCATENATION(x) && ((depth = DEPTH(x)) >= MAX_DEPTH || len < min_len[depth])) { register struct Concatenation * conc = &(((CordRep *)x) -> concatenation); size_t left_len = LEFT_LEN(conc); CORD_balance_insert(conc -> left, left_len, forest); CORD_balance_insert(conc -> right, len - left_len, forest); } else /* function or balanced */ { CORD_add_forest(forest, x, len); } } CORD CORD_balance(CORD x) { Forest forest; register size_t len; if (x == 0) return(0); if (CORD_IS_STRING(x)) return(x); if (!min_len_init) CORD_init_min_len(); len = LEN(x); CORD_init_forest(forest, len); CORD_balance_insert(x, len, forest); return(CORD_concat_forest(forest, len)); } /* Position primitives */ /* Private routines to deal with the hard cases only: */ /* P contains a prefix of the path to cur_pos. Extend it to a full */ /* path and set up leaf info. */ /* Return 0 if past the end of cord, 1 o.w. */ void CORD__extend_path(register CORD_pos p) { register struct CORD_pe * current_pe = &(p[0].path[p[0].path_len]); register CORD top = current_pe -> pe_cord; register size_t pos = p[0].cur_pos; register size_t top_pos = current_pe -> pe_start_pos; register size_t top_len = GEN_LEN(top); /* Fill in the rest of the path. */ while(!CORD_IS_STRING(top) && IS_CONCATENATION(top)) { register struct Concatenation * conc = &(((CordRep *)top) -> concatenation); register size_t left_len; left_len = LEFT_LEN(conc); current_pe++; if (pos >= top_pos + left_len) { current_pe -> pe_cord = top = conc -> right; current_pe -> pe_start_pos = top_pos = top_pos + left_len; top_len -= left_len; } else { current_pe -> pe_cord = top = conc -> left; current_pe -> pe_start_pos = top_pos; top_len = left_len; } p[0].path_len++; } /* Fill in leaf description for fast access. */ if (CORD_IS_STRING(top)) { p[0].cur_leaf = top; p[0].cur_start = top_pos; p[0].cur_end = top_pos + top_len; } else { p[0].cur_end = 0; } if (pos >= top_pos + top_len) p[0].path_len = CORD_POS_INVALID; } char CORD__pos_fetch(register CORD_pos p) { /* Leaf is a function node */ struct CORD_pe * pe = &((p)[0].path[(p)[0].path_len]); CORD leaf = pe -> pe_cord; register struct Function * f = &(((CordRep *)leaf) -> function); if (!IS_FUNCTION(leaf)) ABORT("CORD_pos_fetch: bad leaf"); return ((*(f -> fn))(p[0].cur_pos - pe -> pe_start_pos, f -> client_data)); } void CORD__next(register CORD_pos p) { register size_t cur_pos = p[0].cur_pos + 1; register struct CORD_pe * current_pe = &((p)[0].path[(p)[0].path_len]); register CORD leaf = current_pe -> pe_cord; /* Leaf is not a string or we're at end of leaf */ p[0].cur_pos = cur_pos; if (!CORD_IS_STRING(leaf)) { /* Function leaf */ register struct Function * f = &(((CordRep *)leaf) -> function); register size_t start_pos = current_pe -> pe_start_pos; register size_t end_pos = start_pos + f -> len; if (cur_pos < end_pos) { /* Fill cache and return. */ register size_t i; register size_t limit = cur_pos + FUNCTION_BUF_SZ; register CORD_fn fn = f -> fn; register void * client_data = f -> client_data; if (limit > end_pos) { limit = end_pos; } for (i = cur_pos; i < limit; i++) { p[0].function_buf[i - cur_pos] = (*fn)(i - start_pos, client_data); } p[0].cur_start = cur_pos; p[0].cur_leaf = p[0].function_buf; p[0].cur_end = limit; return; } } /* End of leaf */ /* Pop the stack until we find two concatenation nodes with the */ /* same start position: this implies we were in left part. */ { while (p[0].path_len > 0 && current_pe[0].pe_start_pos != current_pe[-1].pe_start_pos) { p[0].path_len--; current_pe--; } if (p[0].path_len == 0) { p[0].path_len = CORD_POS_INVALID; return; } } p[0].path_len--; CORD__extend_path(p); } void CORD__prev(register CORD_pos p) { register struct CORD_pe * pe = &(p[0].path[p[0].path_len]); if (p[0].cur_pos == 0) { p[0].path_len = CORD_POS_INVALID; return; } p[0].cur_pos--; if (p[0].cur_pos >= pe -> pe_start_pos) return; /* Beginning of leaf */ /* Pop the stack until we find two concatenation nodes with the */ /* different start position: this implies we were in right part. */ { register struct CORD_pe * current_pe = &((p)[0].path[(p)[0].path_len]); while (p[0].path_len > 0 && current_pe[0].pe_start_pos == current_pe[-1].pe_start_pos) { p[0].path_len--; current_pe--; } } p[0].path_len--; CORD__extend_path(p); } #undef CORD_pos_fetch #undef CORD_next #undef CORD_prev #undef CORD_pos_to_index #undef CORD_pos_to_cord #undef CORD_pos_valid char CORD_pos_fetch(register CORD_pos p) { if (p[0].cur_start <= p[0].cur_pos && p[0].cur_pos < p[0].cur_end) { return(p[0].cur_leaf[p[0].cur_pos - p[0].cur_start]); } else { return(CORD__pos_fetch(p)); } } void CORD_next(CORD_pos p) { if (p[0].cur_pos < p[0].cur_end - 1) { p[0].cur_pos++; } else { CORD__next(p); } } void CORD_prev(CORD_pos p) { if (p[0].cur_end != 0 && p[0].cur_pos > p[0].cur_start) { p[0].cur_pos--; } else { CORD__prev(p); } } size_t CORD_pos_to_index(CORD_pos p) { return(p[0].cur_pos); } CORD CORD_pos_to_cord(CORD_pos p) { return(p[0].path[0].pe_cord); } int CORD_pos_valid(CORD_pos p) { return(p[0].path_len != CORD_POS_INVALID); } void CORD_set_pos(CORD_pos p, CORD x, size_t i) { if (x == CORD_EMPTY) { p[0].path_len = CORD_POS_INVALID; return; } p[0].path[0].pe_cord = x; p[0].path[0].pe_start_pos = 0; p[0].path_len = 0; p[0].cur_pos = i; CORD__extend_path(p); } ecl-16.1.2/src/bdwgc/cord/cordprnt.c000066400000000000000000000335311266352375300171700ustar00rootroot00000000000000/* * Copyright (c) 1993-1994 by Xerox Corporation. All rights reserved. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. */ /* An sprintf implementation that understands cords. This is probably */ /* not terribly portable. It assumes an ANSI stdarg.h. It further */ /* assumes that I can make copies of va_list variables, and read */ /* arguments repeatedly by applying va_arg to the copies. This */ /* could be avoided at some performance cost. */ /* We also assume that unsigned and signed integers of various kinds */ /* have the same sizes, and can be cast back and forth. */ /* We assume that void * and char * have the same size. */ /* All this cruft is needed because we want to rely on the underlying */ /* sprintf implementation whenever possible. */ #ifdef HAVE_CONFIG_H # include "config.h" #endif #ifndef CORD_BUILD # define CORD_BUILD #endif #include "cord.h" #include "ec.h" #include #include #include #include "gc.h" #define CONV_SPEC_LEN 50 /* Maximum length of a single */ /* conversion specification. */ #define CONV_RESULT_LEN 50 /* Maximum length of any */ /* conversion with default */ /* width and prec. */ static int ec_len(CORD_ec x) { return(CORD_len(x[0].ec_cord) + (x[0].ec_bufptr - x[0].ec_buf)); } /* Possible nonumeric precision values. */ # define NONE -1 # define VARIABLE -2 /* Copy the conversion specification from CORD_pos into the buffer buf */ /* Return negative on error. */ /* Source initially points one past the leading %. */ /* It is left pointing at the conversion type. */ /* Assign field width and precision to *width and *prec. */ /* If width or prec is *, VARIABLE is assigned. */ /* Set *left to 1 if left adjustment flag is present. */ /* Set *long_arg to 1 if long flag ('l' or 'L') is present, or to */ /* -1 if 'h' is present. */ static int extract_conv_spec(CORD_pos source, char *buf, int * width, int *prec, int *left, int * long_arg) { register int result = 0; register int current_number = 0; register int saw_period = 0; register int saw_number = 0; register int chars_so_far = 0; register char current; *width = NONE; buf[chars_so_far++] = '%'; while(CORD_pos_valid(source)) { if (chars_so_far >= CONV_SPEC_LEN) return(-1); current = CORD_pos_fetch(source); buf[chars_so_far++] = current; switch(current) { case '*': saw_number = 1; current_number = VARIABLE; break; case '0': if (!saw_number) { /* Zero fill flag; ignore */ break; } /* otherwise fall through: */ case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': saw_number = 1; current_number *= 10; current_number += current - '0'; break; case '.': saw_period = 1; if(saw_number) { *width = current_number; saw_number = 0; } current_number = 0; break; case 'l': case 'L': *long_arg = 1; current_number = 0; break; case 'h': *long_arg = -1; current_number = 0; break; case ' ': case '+': case '#': current_number = 0; break; case '-': *left = 1; current_number = 0; break; case 'd': case 'i': case 'o': case 'u': case 'x': case 'X': case 'f': case 'e': case 'E': case 'g': case 'G': case 'c': case 'C': case 's': case 'S': case 'p': case 'n': case 'r': goto done; default: return(-1); } CORD_next(source); } return(-1); done: if (saw_number) { if (saw_period) { *prec = current_number; } else { *prec = NONE; *width = current_number; } } else { *prec = NONE; } buf[chars_so_far] = '\0'; return(result); } int CORD_vsprintf(CORD * out, CORD format, va_list args) { CORD_ec result; register int count; register char current; CORD_pos pos; char conv_spec[CONV_SPEC_LEN + 1]; CORD_ec_init(result); for (CORD_set_pos(pos, format, 0); CORD_pos_valid(pos); CORD_next(pos)) { current = CORD_pos_fetch(pos); if (current == '%') { CORD_next(pos); if (!CORD_pos_valid(pos)) return(-1); current = CORD_pos_fetch(pos); if (current == '%') { CORD_ec_append(result, current); } else { int width, prec; int left_adj = 0; int long_arg = 0; CORD arg; size_t len; if (extract_conv_spec(pos, conv_spec, &width, &prec, &left_adj, &long_arg) < 0) { return(-1); } current = CORD_pos_fetch(pos); switch(current) { case 'n': /* Assign length to next arg */ if (long_arg == 0) { int * pos_ptr; pos_ptr = va_arg(args, int *); *pos_ptr = ec_len(result); } else if (long_arg > 0) { long * pos_ptr; pos_ptr = va_arg(args, long *); *pos_ptr = ec_len(result); } else { short * pos_ptr; pos_ptr = va_arg(args, short *); *pos_ptr = ec_len(result); } goto done; case 'r': /* Append cord and any padding */ if (width == VARIABLE) width = va_arg(args, int); if (prec == VARIABLE) prec = va_arg(args, int); arg = va_arg(args, CORD); len = CORD_len(arg); if (prec != NONE && len > (size_t)prec) { if (prec < 0) return(-1); arg = CORD_substr(arg, 0, prec); len = prec; } if (width != NONE && len < (size_t)width) { char * blanks = GC_MALLOC_ATOMIC(width-len+1); memset(blanks, ' ', width-len); blanks[width-len] = '\0'; if (left_adj) { arg = CORD_cat(arg, blanks); } else { arg = CORD_cat(blanks, arg); } } CORD_ec_append_cord(result, arg); goto done; case 'c': if (width == NONE && prec == NONE) { register char c; c = (char)va_arg(args, int); CORD_ec_append(result, c); goto done; } break; case 's': if (width == NONE && prec == NONE) { char * str = va_arg(args, char *); register char c; while ((c = *str++)) { CORD_ec_append(result, c); } goto done; } break; default: break; } /* Use standard sprintf to perform conversion */ { register char * buf; va_list vsprintf_args; int max_size = 0; int res; # ifdef __va_copy __va_copy(vsprintf_args, args); # else # if defined(__GNUC__) && !defined(__DJGPP__) \ && !defined(__EMX__) /* and probably in other cases */ va_copy(vsprintf_args, args); # else vsprintf_args = args; # endif # endif if (width == VARIABLE) width = va_arg(args, int); if (prec == VARIABLE) prec = va_arg(args, int); if (width != NONE) max_size = width; if (prec != NONE && prec > max_size) max_size = prec; max_size += CONV_RESULT_LEN; if (max_size >= CORD_BUFSZ) { buf = GC_MALLOC_ATOMIC(max_size + 1); } else { if (CORD_BUFSZ - (result[0].ec_bufptr-result[0].ec_buf) < max_size) { CORD_ec_flush_buf(result); } buf = result[0].ec_bufptr; } switch(current) { case 'd': case 'i': case 'o': case 'u': case 'x': case 'X': case 'c': if (long_arg <= 0) { (void) va_arg(args, int); } else if (long_arg > 0) { (void) va_arg(args, long); } break; case 's': case 'p': (void) va_arg(args, char *); break; case 'f': case 'e': case 'E': case 'g': case 'G': (void) va_arg(args, double); break; default: # if defined(__va_copy) \ || (defined(__GNUC__) && !defined(__DJGPP__) \ && !defined(__EMX__)) va_end(vsprintf_args); # endif return(-1); } res = vsprintf(buf, conv_spec, vsprintf_args); # if defined(__va_copy) \ || (defined(__GNUC__) && !defined(__DJGPP__) \ && !defined(__EMX__)) va_end(vsprintf_args); # endif len = (size_t)res; if ((char *)(GC_word)res == buf) { /* old style vsprintf */ len = strlen(buf); } else if (res < 0) { return(-1); } if (buf != result[0].ec_bufptr) { register char c; while ((c = *buf++)) { CORD_ec_append(result, c); } } else { result[0].ec_bufptr = buf + len; } } done:; } } else { CORD_ec_append(result, current); } } count = ec_len(result); *out = CORD_balance(CORD_ec_to_cord(result)); return(count); } int CORD_sprintf(CORD * out, CORD format, ...) { va_list args; int result; va_start(args, format); result = CORD_vsprintf(out, format, args); va_end(args); return(result); } int CORD_fprintf(FILE * f, CORD format, ...) { va_list args; int result; CORD out = CORD_EMPTY; /* initialized to prevent compiler warning */ va_start(args, format); result = CORD_vsprintf(&out, format, args); va_end(args); if (result > 0) CORD_put(out, f); return(result); } int CORD_vfprintf(FILE * f, CORD format, va_list args) { int result; CORD out = CORD_EMPTY; result = CORD_vsprintf(&out, format, args); if (result > 0) CORD_put(out, f); return(result); } int CORD_printf(CORD format, ...) { va_list args; int result; CORD out = CORD_EMPTY; va_start(args, format); result = CORD_vsprintf(&out, format, args); va_end(args); if (result > 0) CORD_put(out, stdout); return(result); } int CORD_vprintf(CORD format, va_list args) { int result; CORD out = CORD_EMPTY; result = CORD_vsprintf(&out, format, args); if (result > 0) CORD_put(out, stdout); return(result); } ecl-16.1.2/src/bdwgc/cord/cordxtra.c000066400000000000000000000433351266352375300171660ustar00rootroot00000000000000/* * Copyright (c) 1993-1994 by Xerox Corporation. All rights reserved. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. */ /* * These are functions on cords that do not need to understand their * implementation. They serve also serve as example client code for * cord_basics. */ #ifdef HAVE_CONFIG_H # include "config.h" #endif #ifndef CORD_BUILD # define CORD_BUILD #endif # include # include # include # include # include "cord.h" # include "ec.h" # define I_HIDE_POINTERS /* So we get access to allocation lock. */ /* We use this for lazy file reading, */ /* so that we remain independent */ /* of the threads primitives. */ # include "gc.h" /* For now we assume that pointer reads and writes are atomic, */ /* i.e. another thread always sees the state before or after */ /* a write. This might be false on a Motorola M68K with */ /* pointers that are not 32-bit aligned. But there probably */ /* aren't too many threads packages running on those. */ # define ATOMIC_WRITE(x,y) (x) = (y) # define ATOMIC_READ(x) (*(x)) /* The standard says these are in stdio.h, but they aren't always: */ # ifndef SEEK_SET # define SEEK_SET 0 # endif # ifndef SEEK_END # define SEEK_END 2 # endif # define BUFSZ 2048 /* Size of stack allocated buffers when */ /* we want large buffers. */ typedef void (* oom_fn)(void); # define OUT_OF_MEMORY { if (CORD_oom_fn != (oom_fn) 0) (*CORD_oom_fn)(); \ ABORT("Out of memory\n"); } # define ABORT(msg) { fprintf(stderr, "%s\n", msg); abort(); } #if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) # define CORD_ATTR_UNUSED __attribute__((__unused__)) #else # define CORD_ATTR_UNUSED /* empty */ #endif CORD CORD_cat_char(CORD x, char c) { register char * string; if (c == '\0') return(CORD_cat(x, CORD_nul(1))); string = GC_MALLOC_ATOMIC(2); if (string == 0) OUT_OF_MEMORY; string[0] = c; string[1] = '\0'; return(CORD_cat_char_star(x, string, 1)); } CORD CORD_catn(int nargs, ...) { register CORD result = CORD_EMPTY; va_list args; register int i; va_start(args, nargs); for (i = 0; i < nargs; i++) { register CORD next = va_arg(args, CORD); result = CORD_cat(result, next); } va_end(args); return(result); } typedef struct { size_t len; size_t count; char * buf; } CORD_fill_data; int CORD_fill_proc(char c, void * client_data) { register CORD_fill_data * d = (CORD_fill_data *)client_data; register size_t count = d -> count; (d -> buf)[count] = c; d -> count = ++count; if (count >= d -> len) { return(1); } else { return(0); } } int CORD_batched_fill_proc(const char * s, void * client_data) { register CORD_fill_data * d = (CORD_fill_data *)client_data; register size_t count = d -> count; register size_t max = d -> len; register char * buf = d -> buf; register const char * t = s; while((buf[count] = *t++) != '\0') { count++; if (count >= max) { d -> count = count; return(1); } } d -> count = count; return(0); } /* Fill buf with len characters starting at i. */ /* Assumes len characters are available. */ void CORD_fill_buf(CORD x, size_t i, size_t len, char * buf) { CORD_fill_data fd; fd.len = len; fd.buf = buf; fd.count = 0; (void)CORD_iter5(x, i, CORD_fill_proc, CORD_batched_fill_proc, &fd); } int CORD_cmp(CORD x, CORD y) { CORD_pos xpos; CORD_pos ypos; register size_t avail, yavail; if (y == CORD_EMPTY) return(x != CORD_EMPTY); if (x == CORD_EMPTY) return(-1); if (CORD_IS_STRING(y) && CORD_IS_STRING(x)) return(strcmp(x,y)); CORD_set_pos(xpos, x, 0); CORD_set_pos(ypos, y, 0); for(;;) { if (!CORD_pos_valid(xpos)) { if (CORD_pos_valid(ypos)) { return(-1); } else { return(0); } } if (!CORD_pos_valid(ypos)) { return(1); } if ((avail = CORD_pos_chars_left(xpos)) <= 0 || (yavail = CORD_pos_chars_left(ypos)) <= 0) { register char xcurrent = CORD_pos_fetch(xpos); register char ycurrent = CORD_pos_fetch(ypos); if (xcurrent != ycurrent) return(xcurrent - ycurrent); CORD_next(xpos); CORD_next(ypos); } else { /* process as many characters as we can */ register int result; if (avail > yavail) avail = yavail; result = strncmp(CORD_pos_cur_char_addr(xpos), CORD_pos_cur_char_addr(ypos), avail); if (result != 0) return(result); CORD_pos_advance(xpos, avail); CORD_pos_advance(ypos, avail); } } } int CORD_ncmp(CORD x, size_t x_start, CORD y, size_t y_start, size_t len) { CORD_pos xpos; CORD_pos ypos; register size_t count; register long avail, yavail; CORD_set_pos(xpos, x, x_start); CORD_set_pos(ypos, y, y_start); for(count = 0; count < len;) { if (!CORD_pos_valid(xpos)) { if (CORD_pos_valid(ypos)) { return(-1); } else { return(0); } } if (!CORD_pos_valid(ypos)) { return(1); } if ((avail = CORD_pos_chars_left(xpos)) <= 0 || (yavail = CORD_pos_chars_left(ypos)) <= 0) { register char xcurrent = CORD_pos_fetch(xpos); register char ycurrent = CORD_pos_fetch(ypos); if (xcurrent != ycurrent) return(xcurrent - ycurrent); CORD_next(xpos); CORD_next(ypos); count++; } else { /* process as many characters as we can */ register int result; if (avail > yavail) avail = yavail; count += avail; if (count > len) avail -= (count - len); result = strncmp(CORD_pos_cur_char_addr(xpos), CORD_pos_cur_char_addr(ypos), (size_t)avail); if (result != 0) return(result); CORD_pos_advance(xpos, (size_t)avail); CORD_pos_advance(ypos, (size_t)avail); } } return(0); } char * CORD_to_char_star(CORD x) { register size_t len = CORD_len(x); char * result = GC_MALLOC_ATOMIC(len + 1); if (result == 0) OUT_OF_MEMORY; CORD_fill_buf(x, 0, len, result); result[len] = '\0'; return(result); } CORD CORD_from_char_star(const char *s) { char * result; size_t len = strlen(s); if (0 == len) return(CORD_EMPTY); result = GC_MALLOC_ATOMIC(len + 1); if (result == 0) OUT_OF_MEMORY; memcpy(result, s, len+1); return(result); } const char * CORD_to_const_char_star(CORD x) { if (x == 0) return(""); if (CORD_IS_STRING(x)) return((const char *)x); return(CORD_to_char_star(x)); } char CORD_fetch(CORD x, size_t i) { CORD_pos xpos; CORD_set_pos(xpos, x, i); if (!CORD_pos_valid(xpos)) ABORT("bad index?"); return(CORD_pos_fetch(xpos)); } int CORD_put_proc(char c, void * client_data) { register FILE * f = (FILE *)client_data; return(putc(c, f) == EOF); } int CORD_batched_put_proc(const char * s, void * client_data) { register FILE * f = (FILE *)client_data; return(fputs(s, f) == EOF); } int CORD_put(CORD x, FILE * f) { if (CORD_iter5(x, 0, CORD_put_proc, CORD_batched_put_proc, f)) { return(EOF); } else { return(1); } } typedef struct { size_t pos; /* Current position in the cord */ char target; /* Character we're looking for */ } chr_data; int CORD_chr_proc(char c, void * client_data) { register chr_data * d = (chr_data *)client_data; if (c == d -> target) return(1); (d -> pos) ++; return(0); } int CORD_rchr_proc(char c, void * client_data) { register chr_data * d = (chr_data *)client_data; if (c == d -> target) return(1); (d -> pos) --; return(0); } int CORD_batched_chr_proc(const char *s, void * client_data) { register chr_data * d = (chr_data *)client_data; register char * occ = strchr(s, d -> target); if (occ == 0) { d -> pos += strlen(s); return(0); } else { d -> pos += occ - s; return(1); } } size_t CORD_chr(CORD x, size_t i, int c) { chr_data d; d.pos = i; d.target = c; if (CORD_iter5(x, i, CORD_chr_proc, CORD_batched_chr_proc, &d)) { return(d.pos); } else { return(CORD_NOT_FOUND); } } size_t CORD_rchr(CORD x, size_t i, int c) { chr_data d; d.pos = i; d.target = c; if (CORD_riter4(x, i, CORD_rchr_proc, &d)) { return(d.pos); } else { return(CORD_NOT_FOUND); } } /* Find the first occurrence of s in x at position start or later. */ /* This uses an asymptotically poor algorithm, which should typically */ /* perform acceptably. We compare the first few characters directly, */ /* and call CORD_ncmp whenever there is a partial match. */ /* This has the advantage that we allocate very little, or not at all. */ /* It's very fast if there are few close misses. */ size_t CORD_str(CORD x, size_t start, CORD s) { CORD_pos xpos; size_t xlen = CORD_len(x); size_t slen; register size_t start_len; const char * s_start; unsigned long s_buf = 0; /* The first few characters of s */ unsigned long x_buf = 0; /* Start of candidate substring. */ /* Initialized only to make compilers */ /* happy. */ unsigned long mask = 0; register size_t i; register size_t match_pos; if (s == CORD_EMPTY) return(start); if (CORD_IS_STRING(s)) { s_start = s; slen = strlen(s); } else { s_start = CORD_to_char_star(CORD_substr(s, 0, sizeof(unsigned long))); slen = CORD_len(s); } if (xlen < start || xlen - start < slen) return(CORD_NOT_FOUND); start_len = slen; if (start_len > sizeof(unsigned long)) start_len = sizeof(unsigned long); CORD_set_pos(xpos, x, start); for (i = 0; i < start_len; i++) { mask <<= 8; mask |= 0xff; s_buf <<= 8; s_buf |= (unsigned char)s_start[i]; x_buf <<= 8; x_buf |= (unsigned char)CORD_pos_fetch(xpos); CORD_next(xpos); } for (match_pos = start; ; match_pos++) { if ((x_buf & mask) == s_buf) { if (slen == start_len || CORD_ncmp(x, match_pos + start_len, s, start_len, slen - start_len) == 0) { return(match_pos); } } if ( match_pos == xlen - slen ) { return(CORD_NOT_FOUND); } x_buf <<= 8; x_buf |= (unsigned char)CORD_pos_fetch(xpos); CORD_next(xpos); } } void CORD_ec_flush_buf(CORD_ec x) { register size_t len = x[0].ec_bufptr - x[0].ec_buf; char * s; if (len == 0) return; s = GC_MALLOC_ATOMIC(len+1); memcpy(s, x[0].ec_buf, len); s[len] = '\0'; x[0].ec_cord = CORD_cat_char_star(x[0].ec_cord, s, len); x[0].ec_bufptr = x[0].ec_buf; } void CORD_ec_append_cord(CORD_ec x, CORD s) { CORD_ec_flush_buf(x); x[0].ec_cord = CORD_cat(x[0].ec_cord, s); } char CORD_nul_func(size_t i CORD_ATTR_UNUSED, void * client_data) { return((char)(unsigned long)client_data); } CORD CORD_chars(char c, size_t i) { return(CORD_from_fn(CORD_nul_func, (void *)(unsigned long)c, i)); } CORD CORD_from_file_eager(FILE * f) { register int c; CORD_ec ecord; CORD_ec_init(ecord); for(;;) { c = getc(f); if (c == 0) { /* Append the right number of NULs */ /* Note that any string of NULs is represented in 4 words, */ /* independent of its length. */ register size_t count = 1; CORD_ec_flush_buf(ecord); while ((c = getc(f)) == 0) count++; ecord[0].ec_cord = CORD_cat(ecord[0].ec_cord, CORD_nul(count)); } if (c == EOF) break; CORD_ec_append(ecord, c); } (void) fclose(f); return(CORD_balance(CORD_ec_to_cord(ecord))); } /* The state maintained for a lazily read file consists primarily */ /* of a large direct-mapped cache of previously read values. */ /* We could rely more on stdio buffering. That would have 2 */ /* disadvantages: */ /* 1) Empirically, not all fseek implementations preserve the */ /* buffer whenever they could. */ /* 2) It would fail if 2 different sections of a long cord */ /* were being read alternately. */ /* We do use the stdio buffer for read ahead. */ /* To guarantee thread safety in the presence of atomic pointer */ /* writes, cache lines are always replaced, and never modified in */ /* place. */ # define LOG_CACHE_SZ 14 # define CACHE_SZ (1 << LOG_CACHE_SZ) # define LOG_LINE_SZ 9 # define LINE_SZ (1 << LOG_LINE_SZ) typedef struct { size_t tag; char data[LINE_SZ]; /* data[i%LINE_SZ] = ith char in file if tag = i/LINE_SZ */ } cache_line; typedef struct { FILE * lf_file; size_t lf_current; /* Current file pointer value */ cache_line * volatile lf_cache[CACHE_SZ/LINE_SZ]; } lf_state; # define MOD_CACHE_SZ(n) ((n) & (CACHE_SZ - 1)) # define DIV_CACHE_SZ(n) ((n) >> LOG_CACHE_SZ) # define MOD_LINE_SZ(n) ((n) & (LINE_SZ - 1)) # define DIV_LINE_SZ(n) ((n) >> LOG_LINE_SZ) # define LINE_START(n) ((n) & ~(LINE_SZ - 1)) typedef struct { lf_state * state; size_t file_pos; /* Position of needed character. */ cache_line * new_cache; } refill_data; /* Executed with allocation lock. */ static char refill_cache(refill_data * client_data) { register lf_state * state = client_data -> state; register size_t file_pos = client_data -> file_pos; FILE *f = state -> lf_file; size_t line_start = LINE_START(file_pos); size_t line_no = DIV_LINE_SZ(MOD_CACHE_SZ(file_pos)); cache_line * new_cache = client_data -> new_cache; if (line_start != state -> lf_current && fseek(f, line_start, SEEK_SET) != 0) { ABORT("fseek failed"); } if (fread(new_cache -> data, sizeof(char), LINE_SZ, f) <= file_pos - line_start) { ABORT("fread failed"); } new_cache -> tag = DIV_LINE_SZ(file_pos); /* Store barrier goes here. */ ATOMIC_WRITE(state -> lf_cache[line_no], new_cache); state -> lf_current = line_start + LINE_SZ; return(new_cache->data[MOD_LINE_SZ(file_pos)]); } char CORD_lf_func(size_t i, void * client_data) { register lf_state * state = (lf_state *)client_data; register cache_line * volatile * cl_addr = &(state -> lf_cache[DIV_LINE_SZ(MOD_CACHE_SZ(i))]); register cache_line * cl = (cache_line *)ATOMIC_READ(cl_addr); if (cl == 0 || cl -> tag != DIV_LINE_SZ(i)) { /* Cache miss */ refill_data rd; rd.state = state; rd.file_pos = i; rd.new_cache = GC_NEW_ATOMIC(cache_line); if (rd.new_cache == 0) OUT_OF_MEMORY; return((char)(GC_word) GC_call_with_alloc_lock((GC_fn_type) refill_cache, &rd)); } return(cl -> data[MOD_LINE_SZ(i)]); } void CORD_lf_close_proc(void * obj, void * client_data CORD_ATTR_UNUSED) { if (fclose(((lf_state *)obj) -> lf_file) != 0) { ABORT("CORD_lf_close_proc: fclose failed"); } } CORD CORD_from_file_lazy_inner(FILE * f, size_t len) { register lf_state * state = GC_NEW(lf_state); register int i; if (state == 0) OUT_OF_MEMORY; if (len != 0) { /* Dummy read to force buffer allocation. */ /* This greatly increases the probability */ /* of avoiding deadlock if buffer allocation */ /* is redirected to GC_malloc and the */ /* world is multi-threaded. */ char buf[1]; if (fread(buf, 1, 1, f) > 1) { /* Just to suppress "unused result" compiler warning. */ ABORT("fread unexpected result"); } rewind(f); } state -> lf_file = f; for (i = 0; i < CACHE_SZ/LINE_SZ; i++) { state -> lf_cache[i] = 0; } state -> lf_current = 0; GC_REGISTER_FINALIZER(state, CORD_lf_close_proc, 0, 0, 0); return(CORD_from_fn(CORD_lf_func, state, len)); } CORD CORD_from_file_lazy(FILE * f) { register long len; if (fseek(f, 0l, SEEK_END) != 0) { ABORT("Bad fd argument - fseek failed"); } if ((len = ftell(f)) < 0) { ABORT("Bad fd argument - ftell failed"); } rewind(f); return(CORD_from_file_lazy_inner(f, (size_t)len)); } # define LAZY_THRESHOLD (128*1024 + 1) CORD CORD_from_file(FILE * f) { register long len; if (fseek(f, 0l, SEEK_END) != 0) { ABORT("Bad fd argument - fseek failed"); } if ((len = ftell(f)) < 0) { ABORT("Bad fd argument - ftell failed"); } rewind(f); if (len < LAZY_THRESHOLD) { return(CORD_from_file_eager(f)); } else { return(CORD_from_file_lazy_inner(f, (size_t)len)); } } ecl-16.1.2/src/bdwgc/cord/tests/000077500000000000000000000000001266352375300163265ustar00rootroot00000000000000ecl-16.1.2/src/bdwgc/cord/tests/cordtest.c000066400000000000000000000217211266352375300203240ustar00rootroot00000000000000/* * Copyright (c) 1993-1994 by Xerox Corporation. All rights reserved. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. */ # include "gc.h" /* For GC_INIT() only */ # include "cord.h" # include # include # include /* This is a very incomplete test of the cord package. It knows about */ /* a few internals of the package (e.g. when C strings are returned) */ /* that real clients shouldn't rely on. */ # define ABORT(string) \ { int x = 0; fprintf(stderr, "FAILED: %s\n", string); x = 1 / x; abort(); } int count; int test_fn(char c, void * client_data) { if (client_data != (void *)13) ABORT("bad client data"); if (count < 64*1024+1) { if ((count & 1) == 0) { if (c != 'b') ABORT("bad char"); } else { if (c != 'a') ABORT("bad char"); } count++; return(0); } else { if (c != 'c') ABORT("bad char"); count++; return(1); } } char id_cord_fn(size_t i, void * client_data) { if (client_data != 0) ABORT("id_cord_fn: bad client data"); return((char)i); } void test_basics(void) { CORD x = CORD_from_char_star("ab"); register int i; char c; CORD y; CORD_pos p; x = CORD_cat(x,x); if (x == CORD_EMPTY) ABORT("CORD_cat(x,x) returned empty cord"); if (!CORD_IS_STRING(x)) ABORT("short cord should usually be a string"); if (strcmp(x, "abab") != 0) ABORT("bad CORD_cat result"); for (i = 1; i < 16; i++) { x = CORD_cat(x,x); } x = CORD_cat(x,"c"); if (CORD_len(x) != 128*1024+1) ABORT("bad length"); count = 0; if (CORD_iter5(x, 64*1024-1, test_fn, CORD_NO_FN, (void *)13) == 0) { ABORT("CORD_iter5 failed"); } if (count != 64*1024 + 2) ABORT("CORD_iter5 failed"); count = 0; CORD_set_pos(p, x, 64*1024-1); while(CORD_pos_valid(p)) { (void) test_fn(CORD_pos_fetch(p), (void *)13); CORD_next(p); } if (count != 64*1024 + 2) ABORT("Position based iteration failed"); y = CORD_substr(x, 1023, 5); if (!y) ABORT("CORD_substr returned NULL"); if (!CORD_IS_STRING(y)) ABORT("short cord should usually be a string"); if (strcmp(y, "babab") != 0) ABORT("bad CORD_substr result"); y = CORD_substr(x, 1024, 8); if (!y) ABORT("CORD_substr returned NULL"); if (!CORD_IS_STRING(y)) ABORT("short cord should usually be a string"); if (strcmp(y, "abababab") != 0) ABORT("bad CORD_substr result"); y = CORD_substr(x, 128*1024-1, 8); if (!y) ABORT("CORD_substr returned NULL"); if (!CORD_IS_STRING(y)) ABORT("short cord should usually be a string"); if (strcmp(y, "bc") != 0) ABORT("bad CORD_substr result"); x = CORD_balance(x); if (CORD_len(x) != 128*1024+1) ABORT("bad length"); count = 0; if (CORD_iter5(x, 64*1024-1, test_fn, CORD_NO_FN, (void *)13) == 0) { ABORT("CORD_iter5 failed"); } if (count != 64*1024 + 2) ABORT("CORD_iter5 failed"); y = CORD_substr(x, 1023, 5); if (!y) ABORT("CORD_substr returned NULL"); if (!CORD_IS_STRING(y)) ABORT("short cord should usually be a string"); if (strcmp(y, "babab") != 0) ABORT("bad CORD_substr result"); y = CORD_from_fn(id_cord_fn, 0, 13); i = 0; CORD_set_pos(p, y, i); while(CORD_pos_valid(p)) { c = CORD_pos_fetch(p); if(c != i) ABORT("Traversal of function node failed"); CORD_next(p); i++; } if (i != 13) ABORT("Bad apparent length for function node"); } void test_extras(void) { # define FNAME1 "cordtst1.tmp" /* short name (8+3) for portability */ # define FNAME2 "cordtst2.tmp" register int i; CORD y = "abcdefghijklmnopqrstuvwxyz0123456789"; CORD x = "{}"; CORD w, z; FILE *f; FILE *f1a, *f1b, *f2; w = CORD_cat(CORD_cat(y,y),y); z = CORD_catn(3,y,y,y); if (CORD_cmp(w,z) != 0) ABORT("CORD_catn comparison wrong"); for (i = 1; i < 100; i++) { x = CORD_cat(x, y); } z = CORD_balance(x); if (CORD_cmp(x,z) != 0) ABORT("balanced string comparison wrong"); if (CORD_cmp(x,CORD_cat(z, CORD_nul(13))) >= 0) ABORT("comparison 2"); if (CORD_cmp(CORD_cat(x, CORD_nul(13)), z) <= 0) ABORT("comparison 3"); if (CORD_cmp(x,CORD_cat(z, "13")) >= 0) ABORT("comparison 4"); if ((f = fopen(FNAME1, "w")) == 0) ABORT("open failed"); if (CORD_put(z,f) == EOF) ABORT("CORD_put failed"); if (fclose(f) == EOF) ABORT("fclose failed"); f1a = fopen(FNAME1, "rb"); if (!f1a) ABORT("Unable to open " FNAME1); w = CORD_from_file(f1a); if (CORD_len(w) != CORD_len(z)) ABORT("file length wrong"); if (CORD_cmp(w,z) != 0) ABORT("file comparison wrong"); if (CORD_cmp(CORD_substr(w, 50*36+2, 36), y) != 0) ABORT("file substr wrong"); f1b = fopen(FNAME1, "rb"); if (!f1b) ABORT("2nd open failed: " FNAME1); z = CORD_from_file_lazy(f1b); if (CORD_cmp(w,z) != 0) ABORT("File conversions differ"); if (CORD_chr(w, 0, '9') != 37) ABORT("CORD_chr failed 1"); if (CORD_chr(w, 3, 'a') != 38) ABORT("CORD_chr failed 2"); if (CORD_rchr(w, CORD_len(w) - 1, '}') != 1) ABORT("CORD_rchr failed"); x = y; for (i = 1; i < 14; i++) { x = CORD_cat(x,x); } if ((f = fopen(FNAME2, "w")) == 0) ABORT("2nd open failed"); # ifdef __DJGPP__ /* FIXME: DJGPP workaround. Why does this help? */ if (fflush(f) != 0) ABORT("fflush failed"); # endif if (CORD_put(x,f) == EOF) ABORT("CORD_put failed"); if (fclose(f) == EOF) ABORT("fclose failed"); f2 = fopen(FNAME2, "rb"); if (!f2) ABORT("Unable to open " FNAME2); w = CORD_from_file(f2); if (CORD_len(w) != CORD_len(x)) ABORT("file length wrong"); if (CORD_cmp(w,x) != 0) ABORT("file comparison wrong"); if (CORD_cmp(CORD_substr(w, 1000*36, 36), y) != 0) ABORT("file substr wrong"); if (strcmp(CORD_to_char_star(CORD_substr(w, 1000*36, 36)), y) != 0) ABORT("char * file substr wrong"); if (strcmp(CORD_substr(w, 1000*36, 2), "ab") != 0) ABORT("short file substr wrong"); if (CORD_str(x,1,"9a") != 35) ABORT("CORD_str failed 1"); if (CORD_str(x,0,"9abcdefghijk") != 35) ABORT("CORD_str failed 2"); if (CORD_str(x,0,"9abcdefghijx") != CORD_NOT_FOUND) ABORT("CORD_str failed 3"); if (CORD_str(x,0,"9>") != CORD_NOT_FOUND) ABORT("CORD_str failed 4"); /* Note: f1a, f1b, f2 handles are closed lazily by CORD library. */ /* TODO: Propose and use CORD_fclose. */ *(CORD volatile *)&w = CORD_EMPTY; *(CORD volatile *)&z = CORD_EMPTY; GC_gcollect(); GC_invoke_finalizers(); /* Of course, this does not guarantee the files are closed. */ if (remove(FNAME1) != 0) { /* On some systems, e.g. OS2, this may fail if f1 is still open. */ /* But we cannot call fclose as it might lead to double close. */ fprintf(stderr, "WARNING: remove(FNAME1) failed\n"); } if (remove(FNAME2) != 0) { fprintf(stderr, "WARNING: remove(FNAME2) failed\n"); } } #if defined(__DJGPP__) || defined(__STRICT_ANSI__) /* snprintf is missing in DJGPP (v2.0.3) */ #else # if defined(_MSC_VER) # if defined(_WIN32_WCE) /* _snprintf is deprecated in WinCE */ # define GC_SNPRINTF StringCchPrintfA # else # define GC_SNPRINTF _snprintf # endif # else # define GC_SNPRINTF snprintf # endif #endif void test_printf(void) { CORD result; char result2[200]; long l = -1; short s = (short)-1; CORD x; if (CORD_sprintf(&result, "%7.2f%ln", 3.14159F, &l) != 7) ABORT("CORD_sprintf failed 1"); if (CORD_cmp(result, " 3.14") != 0)ABORT("CORD_sprintf goofed 1"); if (l != 7) ABORT("CORD_sprintf goofed 2"); if (CORD_sprintf(&result, "%-7.2s%hn%c%s", "abcd", &s, 'x', "yz") != 10) ABORT("CORD_sprintf failed 2"); if (CORD_cmp(result, "ab xyz") != 0)ABORT("CORD_sprintf goofed 3"); if (s != 7) ABORT("CORD_sprintf goofed 4"); x = "abcdefghij"; x = CORD_cat(x,x); x = CORD_cat(x,x); x = CORD_cat(x,x); if (CORD_sprintf(&result, "->%-120.78r!\n", x) != 124) ABORT("CORD_sprintf failed 3"); # ifdef GC_SNPRINTF (void)GC_SNPRINTF(result2, sizeof(result2), "->%-120.78s!\n", CORD_to_char_star(x)); # else (void)sprintf(result2, "->%-120.78s!\n", CORD_to_char_star(x)); # endif result2[sizeof(result2) - 1] = '\0'; if (CORD_cmp(result, result2) != 0)ABORT("CORD_sprintf goofed 5"); } int main(void) { # ifdef THINK_C printf("cordtest:\n"); # endif GC_INIT(); test_basics(); test_extras(); test_printf(); CORD_fprintf(stdout, "SUCCEEDED\n"); return(0); } ecl-16.1.2/src/bdwgc/cord/tests/de.c000066400000000000000000000424321266352375300170670ustar00rootroot00000000000000/* * Copyright (c) 1993-1994 by Xerox Corporation. All rights reserved. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. */ /* * A really simple-minded text editor based on cords. * Things it does right: * No size bounds. * Inbounded undo. * Shouldn't crash no matter what file you invoke it on (e.g. /vmunix) * (Make sure /vmunix is not writable before you try this.) * Scrolls horizontally. * Things it does wrong: * It doesn't handle tabs reasonably (use "expand" first). * The command set is MUCH too small. * The redisplay algorithm doesn't let curses do the scrolling. * The rule for moving the window over the file is suboptimal. */ #include #include "gc.h" #include "cord.h" #ifdef THINK_C #define MACINTOSH #include #endif #if (defined(__BORLANDC__) || defined(__CYGWIN__)) && !defined(WIN32) /* If this is DOS or win16, we'll fail anyway. */ /* Might as well assume win32. */ # define WIN32 #endif #if defined(WIN32) # include # include "de_win.h" #elif defined(MACINTOSH) # include /* curses emulation. */ # define initscr() # define endwin() # define nonl() # define noecho() csetmode(C_NOECHO, stdout) # define cbreak() csetmode(C_CBREAK, stdout) # define refresh() # define addch(c) putchar(c) # define standout() cinverse(1, stdout) # define standend() cinverse(0, stdout) # define move(line,col) cgotoxy(col + 1, line + 1, stdout) # define clrtoeol() ccleol(stdout) # define de_error(s) { fprintf(stderr, s); getchar(); } # define LINES 25 # define COLS 80 #else # include # define de_error(s) { fprintf(stderr, s); sleep(2); } #endif #include "de_cmds.h" /* List of line number to position mappings, in descending order. */ /* There may be holes. */ typedef struct LineMapRep { int line; size_t pos; struct LineMapRep * previous; } * line_map; /* List of file versions, one per edit operation */ typedef struct HistoryRep { CORD file_contents; struct HistoryRep * previous; line_map map; /* Invalid for first record "now" */ } * history; history now = 0; CORD current; /* == now -> file_contents. */ size_t current_len; /* Current file length. */ line_map current_map = 0; /* Current line no. to pos. map */ size_t current_map_size = 0; /* Number of current_map entries. */ /* Not always accurate, but reset */ /* by prune_map. */ # define MAX_MAP_SIZE 3000 /* Current display position */ int dis_line = 0; int dis_col = 0; # define ALL -1 # define NONE - 2 int need_redisplay = 0; /* Line that needs to be redisplayed. */ /* Current cursor position. Always within file. */ int line = 0; int col = 0; size_t file_pos = 0; /* Character position corresponding to cursor. */ /* Invalidate line map for lines > i */ void invalidate_map(int i) { while(current_map -> line > i) { current_map = current_map -> previous; current_map_size--; } } /* Reduce the number of map entries to save space for huge files. */ /* This also affects maps in histories. */ void prune_map(void) { line_map map = current_map; int start_line = map -> line; current_map_size = 0; do { current_map_size++; if (map -> line < start_line - LINES && map -> previous != 0) { map -> previous = map -> previous -> previous; } map = map -> previous; } while (map != 0); } /* Add mapping entry */ void add_map(int line, size_t pos) { line_map new_map = GC_NEW(struct LineMapRep); if (current_map_size >= MAX_MAP_SIZE) prune_map(); new_map -> line = line; new_map -> pos = pos; new_map -> previous = current_map; current_map = new_map; current_map_size++; } /* Return position of column *c of ith line in */ /* current file. Adjust *c to be within the line.*/ /* A 0 pointer is taken as 0 column. */ /* Returns CORD_NOT_FOUND if i is too big. */ /* Assumes i > dis_line. */ size_t line_pos(int i, int *c) { int j; size_t cur; size_t next; line_map map = current_map; while (map -> line > i) map = map -> previous; if (map -> line < i - 2) /* rebuild */ invalidate_map(i); for (j = map -> line, cur = map -> pos; j < i;) { cur = CORD_chr(current, cur, '\n'); if (cur == current_len-1) return(CORD_NOT_FOUND); cur++; if (++j > current_map -> line) add_map(j, cur); } if (c != 0) { next = CORD_chr(current, cur, '\n'); if (next == CORD_NOT_FOUND) next = current_len - 1; if (next < cur + *c) { *c = next - cur; } cur += *c; } return(cur); } void add_hist(CORD s) { history new_file = GC_NEW(struct HistoryRep); new_file -> file_contents = current = s; current_len = CORD_len(s); new_file -> previous = now; if (now != 0) now -> map = current_map; now = new_file; } void del_hist(void) { now = now -> previous; current = now -> file_contents; current_map = now -> map; current_len = CORD_len(current); } /* Current screen_contents; a dynamically allocated array of CORDs */ CORD * screen = 0; int screen_size = 0; # ifndef WIN32 /* Replace a line in the curses stdscr. All control characters are */ /* displayed as upper case characters in standout mode. This isn't */ /* terribly appropriate for tabs. */ void replace_line(int i, CORD s) { register int c; CORD_pos p; # if !defined(MACINTOSH) size_t len = CORD_len(s); # endif if (screen == 0 || LINES > screen_size) { screen_size = LINES; screen = (CORD *)GC_MALLOC(screen_size * sizeof(CORD)); } # if !defined(MACINTOSH) /* A gross workaround for an apparent curses bug: */ if (i == LINES-1 && len == COLS) { s = CORD_substr(s, 0, len - 1); } # endif if (CORD_cmp(screen[i], s) != 0) { move(i, 0); clrtoeol(); move(i,0); CORD_FOR (p, s) { c = CORD_pos_fetch(p) & 0x7f; if (iscntrl(c)) { standout(); addch(c + 0x40); standend(); } else { addch(c); } } screen[i] = s; } } #else # define replace_line(i,s) invalidate_line(i) #endif /* Return up to COLS characters of the line of s starting at pos, */ /* returning only characters after the given column. */ CORD retrieve_line(CORD s, size_t pos, unsigned column) { CORD candidate = CORD_substr(s, pos, column + COLS); /* avoids scanning very long lines */ size_t eol = CORD_chr(candidate, 0, '\n'); int len; if (eol == CORD_NOT_FOUND) eol = CORD_len(candidate); len = (int)eol - (int)column; if (len < 0) len = 0; return(CORD_substr(s, pos + column, len)); } # ifdef WIN32 # define refresh(); CORD retrieve_screen_line(int i) { register size_t pos; invalidate_map(dis_line + LINES); /* Prune search */ pos = line_pos(dis_line + i, 0); if (pos == CORD_NOT_FOUND) return(CORD_EMPTY); return(retrieve_line(current, pos, dis_col)); } # endif /* Display the visible section of the current file */ void redisplay(void) { register int i; invalidate_map(dis_line + LINES); /* Prune search */ for (i = 0; i < LINES; i++) { if (need_redisplay == ALL || need_redisplay == i) { register size_t pos = line_pos(dis_line + i, 0); if (pos == CORD_NOT_FOUND) break; replace_line(i, retrieve_line(current, pos, dis_col)); if (need_redisplay == i) goto done; } } for (; i < LINES; i++) replace_line(i, CORD_EMPTY); done: refresh(); need_redisplay = NONE; } int dis_granularity; /* Update dis_line, dis_col, and dis_pos to make cursor visible. */ /* Assumes line, col, dis_line, dis_pos are in bounds. */ void normalize_display(void) { int old_line = dis_line; int old_col = dis_col; dis_granularity = 1; if (LINES > 15 && COLS > 15) dis_granularity = 2; while (dis_line > line) dis_line -= dis_granularity; while (dis_col > col) dis_col -= dis_granularity; while (line >= dis_line + LINES) dis_line += dis_granularity; while (col >= dis_col + COLS) dis_col += dis_granularity; if (old_line != dis_line || old_col != dis_col) { need_redisplay = ALL; } } # if defined(WIN32) # elif defined(MACINTOSH) # define move_cursor(x,y) cgotoxy(x + 1, y + 1, stdout) # else # define move_cursor(x,y) move(y,x) # endif /* Adjust display so that cursor is visible; move cursor into position */ /* Update screen if necessary. */ void fix_cursor(void) { normalize_display(); if (need_redisplay != NONE) redisplay(); move_cursor(col - dis_col, line - dis_line); refresh(); # ifndef WIN32 fflush(stdout); # endif } /* Make sure line, col, and dis_pos are somewhere inside file. */ /* Recompute file_pos. Assumes dis_pos is accurate or past eof */ void fix_pos(void) { int my_col = col; if ((size_t)line > current_len) line = current_len; file_pos = line_pos(line, &my_col); if (file_pos == CORD_NOT_FOUND) { for (line = current_map -> line, file_pos = current_map -> pos; file_pos < current_len; line++, file_pos = CORD_chr(current, file_pos, '\n') + 1); line--; file_pos = line_pos(line, &col); } else { col = my_col; } } #if defined(WIN32) # define beep() Beep(1000 /* Hz */, 300 /* msecs */) #elif defined(MACINTOSH) # define beep() SysBeep(1) #else /* * beep() is part of some curses packages and not others. * We try to match the type of the builtin one, if any. */ int beep(void) { putc('\007', stderr); return(0); } #endif /* !WIN32 && !MACINTOSH */ # define NO_PREFIX -1 # define BARE_PREFIX -2 int repeat_count = NO_PREFIX; /* Current command prefix. */ int locate_mode = 0; /* Currently between 2 ^Ls */ CORD locate_string = CORD_EMPTY; /* Current search string. */ char * arg_file_name; #ifdef WIN32 /* Change the current position to whatever is currently displayed at */ /* the given SCREEN coordinates. */ void set_position(int c, int l) { line = l + dis_line; col = c + dis_col; fix_pos(); move_cursor(col - dis_col, line - dis_line); } #endif /* WIN32 */ /* Perform the command associated with character c. C may be an */ /* integer > 256 denoting a windows command, one of the above control */ /* characters, or another ASCII character to be used as either a */ /* character to be inserted, a repeat count, or a search string, */ /* depending on the current state. */ void do_command(int c) { int i; int need_fix_pos; FILE * out; if ( c == '\r') c = '\n'; if (locate_mode) { size_t new_pos; if (c == LOCATE) { locate_mode = 0; locate_string = CORD_EMPTY; return; } locate_string = CORD_cat_char(locate_string, (char)c); new_pos = CORD_str(current, file_pos - CORD_len(locate_string) + 1, locate_string); if (new_pos != CORD_NOT_FOUND) { need_redisplay = ALL; new_pos += CORD_len(locate_string); for (;;) { file_pos = line_pos(line + 1, 0); if (file_pos > new_pos) break; line++; } col = new_pos - line_pos(line, 0); file_pos = new_pos; fix_cursor(); } else { locate_string = CORD_substr(locate_string, 0, CORD_len(locate_string) - 1); beep(); } return; } if (c == REPEAT) { repeat_count = BARE_PREFIX; return; } else if (c < 0x100 && isdigit(c)){ if (repeat_count == BARE_PREFIX) { repeat_count = c - '0'; return; } else if (repeat_count != NO_PREFIX) { repeat_count = 10 * repeat_count + c - '0'; return; } } if (repeat_count == NO_PREFIX) repeat_count = 1; if (repeat_count == BARE_PREFIX && (c == UP || c == DOWN)) { repeat_count = LINES - dis_granularity; } if (repeat_count == BARE_PREFIX) repeat_count = 8; need_fix_pos = 0; for (i = 0; i < repeat_count; i++) { switch(c) { case LOCATE: locate_mode = 1; break; case TOP: line = col = file_pos = 0; break; case UP: if (line != 0) { line--; need_fix_pos = 1; } break; case DOWN: line++; need_fix_pos = 1; break; case LEFT: if (col != 0) { col--; file_pos--; } break; case RIGHT: if (CORD_fetch(current, file_pos) == '\n') break; col++; file_pos++; break; case UNDO: del_hist(); need_redisplay = ALL; need_fix_pos = 1; break; case BS: if (col == 0) { beep(); break; } col--; file_pos--; /* fall through: */ case DEL: if (file_pos == current_len-1) break; /* Can't delete trailing newline */ if (CORD_fetch(current, file_pos) == '\n') { need_redisplay = ALL; need_fix_pos = 1; } else { need_redisplay = line - dis_line; } add_hist(CORD_cat( CORD_substr(current, 0, file_pos), CORD_substr(current, file_pos+1, current_len))); invalidate_map(line); break; case WRITE: { CORD name = CORD_cat(CORD_from_char_star(arg_file_name), ".new"); if ((out = fopen(CORD_to_const_char_star(name), "wb")) == NULL || CORD_put(current, out) == EOF) { de_error("Write failed\n"); need_redisplay = ALL; } else { fclose(out); } } break; default: { CORD left_part = CORD_substr(current, 0, file_pos); CORD right_part = CORD_substr(current, file_pos, current_len); add_hist(CORD_cat(CORD_cat_char(left_part, (char)c), right_part)); invalidate_map(line); if (c == '\n') { col = 0; line++; file_pos++; need_redisplay = ALL; } else { col++; file_pos++; need_redisplay = line - dis_line; } break; } } } if (need_fix_pos) fix_pos(); fix_cursor(); repeat_count = NO_PREFIX; } /* OS independent initialization */ void generic_init(void) { FILE * f; CORD initial; if ((f = fopen(arg_file_name, "rb")) == NULL) { initial = "\n"; } else { initial = CORD_from_file(f); if (initial == CORD_EMPTY || CORD_fetch(initial, CORD_len(initial)-1) != '\n') { initial = CORD_cat(initial, "\n"); } } add_map(0,0); add_hist(initial); now -> map = current_map; now -> previous = now; /* Can't back up further: beginning of the world */ need_redisplay = ALL; fix_cursor(); } #ifndef WIN32 main(argc, argv) int argc; char ** argv; { int c; #if defined(MACINTOSH) console_options.title = "\pDumb Editor"; cshow(stdout); argc = ccommand(&argv); #endif GC_INIT(); if (argc != 2) goto usage; arg_file_name = argv[1]; setvbuf(stdout, GC_MALLOC_ATOMIC(8192), _IOFBF, 8192); initscr(); noecho(); nonl(); cbreak(); generic_init(); while ((c = getchar()) != QUIT) { if (c == EOF) break; do_command(c); } done: move(LINES-1, 0); clrtoeol(); refresh(); nl(); echo(); endwin(); exit(0); usage: fprintf(stderr, "Usage: %s file\n", argv[0]); fprintf(stderr, "Cursor keys: ^B(left) ^F(right) ^P(up) ^N(down)\n"); fprintf(stderr, "Undo: ^U Write to .new: ^W"); fprintf(stderr, "Quit:^D Repeat count: ^R[n]\n"); fprintf(stderr, "Top: ^T Locate (search, find): ^L text ^L\n"); exit(1); } #endif /* !WIN32 */ ecl-16.1.2/src/bdwgc/cord/tests/de_cmds.h000066400000000000000000000017331266352375300201010ustar00rootroot00000000000000/* * Copyright (c) 1994 by Xerox Corporation. All rights reserved. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. */ #ifndef DE_CMDS_H # define DE_CMDS_H # define UP 16 /* ^P */ # define DOWN 14 /* ^N */ # define LEFT 2 /* ^B */ # define RIGHT 6 /* ^F */ # define DEL 127 /* ^? */ # define BS 8 /* ^H */ # define UNDO 21 /* ^U */ # define WRITE 23 /* ^W */ # define QUIT 4 /* ^D */ # define REPEAT 18 /* ^R */ # define LOCATE 12 /* ^L */ # define TOP 20 /* ^T */ #endif ecl-16.1.2/src/bdwgc/cord/tests/de_win.c000066400000000000000000000254571266352375300177540ustar00rootroot00000000000000/* * Copyright (c) 1994 by Xerox Corporation. All rights reserved. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. */ /* * The MS Windows specific part of de. * This started as the generic Windows application template * but significant parts didn't survive to the final version. * * This was written by a nonexpert windows programmer. */ #include "windows.h" #include "gc.h" #include "cord.h" #include "de_cmds.h" #include "de_win.h" int LINES = 0; int COLS = 0; #define szAppName TEXT("DE") HWND hwnd; void de_error(char *s) { (void)MessageBoxA(hwnd, s, "Demonstration Editor", MB_ICONINFORMATION | MB_OK); InvalidateRect(hwnd, NULL, TRUE); } int APIENTRY WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR command_line, int nCmdShow) { MSG msg; WNDCLASS wndclass; HANDLE hAccel; # ifdef THREAD_LOCAL_ALLOC GC_INIT(); /* Required if GC is built with THREAD_LOCAL_ALLOC */ /* Always safe, but this is used as a GC test. */ # endif if (!hPrevInstance) { wndclass.style = CS_HREDRAW | CS_VREDRAW; wndclass.lpfnWndProc = WndProc; wndclass.cbClsExtra = 0; wndclass.cbWndExtra = DLGWINDOWEXTRA; wndclass.hInstance = hInstance; wndclass.hIcon = LoadIcon (hInstance, szAppName); wndclass.hCursor = LoadCursor (NULL, IDC_ARROW); wndclass.hbrBackground = GetStockObject(WHITE_BRUSH); wndclass.lpszMenuName = TEXT("DE"); wndclass.lpszClassName = szAppName; if (RegisterClass (&wndclass) == 0) { char buf[50]; sprintf(buf, "RegisterClass: error code: 0x%X", (unsigned)GetLastError()); de_error(buf); return(0); } } /* Empirically, the command line does not include the command name ... if (command_line != 0) { while (isspace(*command_line)) command_line++; while (*command_line != 0 && !isspace(*command_line)) command_line++; while (isspace(*command_line)) command_line++; } */ if (command_line == 0 || *command_line == 0) { de_error("File name argument required"); return( 0 ); } else { char *p = command_line; while (*p != 0 && !isspace(*(unsigned char *)p)) p++; arg_file_name = CORD_to_char_star( CORD_substr(command_line, 0, p - command_line)); } hwnd = CreateWindow (szAppName, TEXT("Demonstration Editor"), WS_OVERLAPPEDWINDOW | WS_CAPTION, /* Window style */ CW_USEDEFAULT, 0, /* default pos. */ CW_USEDEFAULT, 0, /* default width, height */ NULL, /* No parent */ NULL, /* Window class menu */ hInstance, NULL); if (hwnd == NULL) { char buf[50]; sprintf(buf, "CreateWindow: error code: 0x%X", (unsigned)GetLastError()); de_error(buf); return(0); } ShowWindow (hwnd, nCmdShow); hAccel = LoadAccelerators( hInstance, szAppName ); while (GetMessage (&msg, NULL, 0, 0)) { if( !TranslateAccelerator( hwnd, hAccel, &msg ) ) { TranslateMessage (&msg); DispatchMessage (&msg); } } return msg.wParam; } /* Return the argument with all control characters replaced by blanks. */ char * plain_chars(char * text, size_t len) { char * result = GC_MALLOC_ATOMIC(len + 1); register size_t i; for (i = 0; i < len; i++) { if (iscntrl(((unsigned char *)text)[i])) { result[i] = ' '; } else { result[i] = text[i]; } } result[len] = '\0'; return(result); } /* Return the argument with all non-control-characters replaced by */ /* blank, and all control characters c replaced by c + 32. */ char * control_chars(char * text, size_t len) { char * result = GC_MALLOC_ATOMIC(len + 1); register size_t i; for (i = 0; i < len; i++) { if (iscntrl(((unsigned char *)text)[i])) { result[i] = text[i] + 0x40; } else { result[i] = ' '; } } result[len] = '\0'; return(result); } int char_width; int char_height; void get_line_rect(int line, int win_width, RECT * rectp) { rectp -> top = line * char_height; rectp -> bottom = rectp->top + char_height; rectp -> left = 0; rectp -> right = win_width; } int caret_visible = 0; /* Caret is currently visible. */ int screen_was_painted = 0;/* Screen has been painted at least once. */ void update_cursor(void); INT_PTR CALLBACK AboutBoxCallback( HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam ) { (void)lParam; switch( message ) { case WM_INITDIALOG: SetFocus( GetDlgItem( hDlg, IDOK ) ); break; case WM_COMMAND: switch( wParam ) { case IDOK: EndDialog( hDlg, TRUE ); break; } break; case WM_CLOSE: EndDialog( hDlg, TRUE ); return TRUE; } return FALSE; } LRESULT CALLBACK WndProc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) { static HANDLE hInstance; HDC dc; PAINTSTRUCT ps; RECT client_area; RECT this_line; RECT dummy; TEXTMETRIC tm; register int i; int id; switch (message) { case WM_CREATE: hInstance = ( (LPCREATESTRUCT) lParam)->hInstance; dc = GetDC(hwnd); SelectObject(dc, GetStockObject(SYSTEM_FIXED_FONT)); GetTextMetrics(dc, &tm); ReleaseDC(hwnd, dc); char_width = tm.tmAveCharWidth; char_height = tm.tmHeight + tm.tmExternalLeading; GetClientRect(hwnd, &client_area); COLS = (client_area.right - client_area.left)/char_width; LINES = (client_area.bottom - client_area.top)/char_height; generic_init(); return(0); case WM_CHAR: if (wParam == QUIT) { SendMessage( hwnd, WM_CLOSE, 0, 0L ); } else { do_command((int)wParam); } return(0); case WM_SETFOCUS: CreateCaret(hwnd, NULL, char_width, char_height); ShowCaret(hwnd); caret_visible = 1; update_cursor(); return(0); case WM_KILLFOCUS: HideCaret(hwnd); DestroyCaret(); caret_visible = 0; return(0); case WM_LBUTTONUP: { unsigned xpos = LOWORD(lParam); /* From left */ unsigned ypos = HIWORD(lParam); /* from top */ set_position(xpos / (unsigned)char_width, ypos / (unsigned)char_height); return(0); } case WM_COMMAND: id = LOWORD(wParam); if (id & EDIT_CMD_FLAG) { if (id & REPEAT_FLAG) do_command(REPEAT); do_command(CHAR_CMD(id)); return( 0 ); } else { switch(id) { case IDM_FILEEXIT: SendMessage( hwnd, WM_CLOSE, 0, 0L ); return( 0 ); case IDM_HELPABOUT: if( DialogBox( hInstance, TEXT("ABOUTBOX"), hwnd, AboutBoxCallback ) ) InvalidateRect( hwnd, NULL, TRUE ); return( 0 ); case IDM_HELPCONTENTS: de_error( "Cursor keys: ^B(left) ^F(right) ^P(up) ^N(down)\n" "Undo: ^U Write: ^W Quit:^D Repeat count: ^R[n]\n" "Top: ^T Locate (search, find): ^L text ^L\n"); return( 0 ); } } break; case WM_CLOSE: DestroyWindow( hwnd ); return 0; case WM_DESTROY: PostQuitMessage (0); GC_win32_free_heap(); return 0; case WM_PAINT: dc = BeginPaint(hwnd, &ps); GetClientRect(hwnd, &client_area); COLS = (client_area.right - client_area.left)/char_width; LINES = (client_area.bottom - client_area.top)/char_height; SelectObject(dc, GetStockObject(SYSTEM_FIXED_FONT)); for (i = 0; i < LINES; i++) { get_line_rect(i, client_area.right, &this_line); if (IntersectRect(&dummy, &this_line, &ps.rcPaint)) { CORD raw_line = retrieve_screen_line(i); size_t len = CORD_len(raw_line); char * text = CORD_to_char_star(raw_line); /* May contain embedded NULLs */ char * plain = plain_chars(text, len); char * blanks = CORD_to_char_star(CORD_chars(' ', COLS - len)); char * control = control_chars(text, len); # define RED RGB(255,0,0) SetBkMode(dc, OPAQUE); SetTextColor(dc, GetSysColor(COLOR_WINDOWTEXT)); TextOutA(dc, this_line.left, this_line.top, plain, (int)len); TextOutA(dc, this_line.left + (int)len * char_width, this_line.top, blanks, (int)(COLS - len)); SetBkMode(dc, TRANSPARENT); SetTextColor(dc, RED); TextOutA(dc, this_line.left, this_line.top, control, (int)strlen(control)); } } EndPaint(hwnd, &ps); screen_was_painted = 1; return 0; } return DefWindowProc (hwnd, message, wParam, lParam); } int last_col; int last_line; void move_cursor(int c, int l) { last_col = c; last_line = l; if (caret_visible) update_cursor(); } void update_cursor(void) { SetCaretPos(last_col * char_width, last_line * char_height); ShowCaret(hwnd); } void invalidate_line(int i) { RECT line; if (!screen_was_painted) return; /* Invalidating a rectangle before painting seems result in a */ /* major performance problem. */ get_line_rect(i, COLS*char_width, &line); InvalidateRect(hwnd, &line, FALSE); } ecl-16.1.2/src/bdwgc/cord/tests/de_win.h000066400000000000000000000065161266352375300177540ustar00rootroot00000000000000/* * Copyright (c) 1994 by Xerox Corporation. All rights reserved. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. */ /* cord.h, de_cmds.h, and windows.h should be included before this. */ # define OTHER_FLAG 0x100 # define EDIT_CMD_FLAG 0x200 # define REPEAT_FLAG 0x400 # define CHAR_CMD(i) ((i) & 0xff) /* MENU: DE */ #define IDM_FILESAVE (EDIT_CMD_FLAG + WRITE) #define IDM_FILEEXIT (OTHER_FLAG + 1) #define IDM_HELPABOUT (OTHER_FLAG + 2) #define IDM_HELPCONTENTS (OTHER_FLAG + 3) #define IDM_EDITPDOWN (REPEAT_FLAG + EDIT_CMD_FLAG + DOWN) #define IDM_EDITPUP (REPEAT_FLAG + EDIT_CMD_FLAG + UP) #define IDM_EDITUNDO (EDIT_CMD_FLAG + UNDO) #define IDM_EDITLOCATE (EDIT_CMD_FLAG + LOCATE) #define IDM_EDITDOWN (EDIT_CMD_FLAG + DOWN) #define IDM_EDITUP (EDIT_CMD_FLAG + UP) #define IDM_EDITLEFT (EDIT_CMD_FLAG + LEFT) #define IDM_EDITRIGHT (EDIT_CMD_FLAG + RIGHT) #define IDM_EDITBS (EDIT_CMD_FLAG + BS) #define IDM_EDITDEL (EDIT_CMD_FLAG + DEL) #define IDM_EDITREPEAT (EDIT_CMD_FLAG + REPEAT) #define IDM_EDITTOP (EDIT_CMD_FLAG + TOP) /* Windows UI stuff */ LRESULT CALLBACK WndProc (HWND hwnd, UINT message, UINT wParam, LONG lParam); LRESULT CALLBACK AboutBox( HWND hDlg, UINT message, UINT wParam, LONG lParam ); /* Screen dimensions. Maintained by de_win.c. */ extern int LINES; extern int COLS; /* File being edited. */ extern char * arg_file_name; /* Current display position in file. Maintained by de.c */ extern int dis_line; extern int dis_col; /* Current cursor position in file. */ extern int line; extern int col; /* * Calls from de_win.c to de.c */ CORD retrieve_screen_line(int i); /* Get the contents of i'th screen line. */ /* Relies on COLS. */ void set_position(int x, int y); /* Set column, row. Upper left of window = (0,0). */ void do_command(int); /* Execute an editor command. */ /* Agument is a command character or one */ /* of the IDM_ commands. */ void generic_init(void); /* OS independent initialization */ /* * Calls from de.c to de_win.c */ void move_cursor(int column, int line); /* Physically move the cursor on the display, */ /* so that it appears at */ /* (column, line). */ void invalidate_line(int line); /* Invalidate line i on the screen. */ void de_error(char *s); /* Display error message. */ ecl-16.1.2/src/bdwgc/cord/tests/de_win.rc000066400000000000000000000036071266352375300201270ustar00rootroot00000000000000/* * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to copy this garbage collector for any purpose, * provided the above notices are retained on all copies. */ #include "windows.h" #include "de_cmds.h" #include "de_win.h" ABOUTBOX DIALOG 19, 21, 163, 47 STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU CAPTION "About Demonstration Text Editor" BEGIN /* ICON "DE", -1, 8, 8, 13, 13, WS_CHILD | WS_VISIBLE */ LTEXT "Demonstration Text Editor", -1, 44, 8, 118, 8, WS_CHILD | WS_VISIBLE | WS_GROUP LTEXT "Version 4.1", -1, 44, 16, 60, 8, WS_CHILD | WS_VISIBLE | WS_GROUP PUSHBUTTON "OK", IDOK, 118, 27, 24, 14, WS_CHILD | WS_VISIBLE | WS_TABSTOP END DE MENU BEGIN POPUP "&File" BEGIN MENUITEM "&Save\t^W", IDM_FILESAVE MENUITEM "E&xit\t^D", IDM_FILEEXIT END POPUP "&Edit" BEGIN MENUITEM "Page &Down\t^R^N", IDM_EDITPDOWN MENUITEM "Page &Up\t^R^P", IDM_EDITPUP MENUITEM "U&ndo\t^U", IDM_EDITUNDO MENUITEM "&Locate\t^L ... ^L", IDM_EDITLOCATE MENUITEM "D&own\t^N", IDM_EDITDOWN MENUITEM "U&p\t^P", IDM_EDITUP MENUITEM "Le&ft\t^B", IDM_EDITLEFT MENUITEM "&Right\t^F", IDM_EDITRIGHT MENUITEM "Delete &Backward\tBS", IDM_EDITBS MENUITEM "Delete F&orward\tDEL", IDM_EDITDEL MENUITEM "&Top\t^T", IDM_EDITTOP END POPUP "&Help" BEGIN MENUITEM "&Contents", IDM_HELPCONTENTS MENUITEM "&About...", IDM_HELPABOUT END MENUITEM "Page_&Down", IDM_EDITPDOWN MENUITEM "Page_&Up", IDM_EDITPUP END DE ACCELERATORS BEGIN "^R", IDM_EDITREPEAT "^N", IDM_EDITDOWN "^P", IDM_EDITUP "^L", IDM_EDITLOCATE "^B", IDM_EDITLEFT "^F", IDM_EDITRIGHT "^T", IDM_EDITTOP VK_DELETE, IDM_EDITDEL, VIRTKEY VK_BACK, IDM_EDITBS, VIRTKEY END /* DE ICON cord\de_win.ICO */ ecl-16.1.2/src/bdwgc/darwin_stop_world.c000066400000000000000000000563131266352375300201510ustar00rootroot00000000000000/* * Copyright (c) 1994 by Xerox Corporation. All rights reserved. * Copyright (c) 1996 by Silicon Graphics. All rights reserved. * Copyright (c) 1998 by Fergus Henderson. All rights reserved. * Copyright (c) 2000-2010 by Hewlett-Packard Development Company. * All rights reserved. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. */ #include "private/pthread_support.h" /* This probably needs more porting work to ppc64. */ #if defined(GC_DARWIN_THREADS) #include #include #include /* From "Inside Mac OS X - Mach-O Runtime Architecture" published by Apple Page 49: "The space beneath the stack pointer, where a new stack frame would normally be allocated, is called the red zone. This area as shown in Figure 3-2 may be used for any purpose as long as a new stack frame does not need to be added to the stack." Page 50: "If a leaf procedure's red zone usage would exceed 224 bytes, then it must set up a stack frame just like routines that call other routines." */ #ifdef POWERPC # if CPP_WORDSZ == 32 # define PPC_RED_ZONE_SIZE 224 # elif CPP_WORDSZ == 64 # define PPC_RED_ZONE_SIZE 320 # endif #endif #ifndef DARWIN_DONT_PARSE_STACK typedef struct StackFrame { unsigned long savedSP; unsigned long savedCR; unsigned long savedLR; unsigned long reserved[2]; unsigned long savedRTOC; } StackFrame; GC_INNER ptr_t GC_FindTopOfStack(unsigned long stack_start) { StackFrame *frame; # ifdef POWERPC if (stack_start == 0) { # if CPP_WORDSZ == 32 __asm__ __volatile__ ("lwz %0,0(r1)" : "=r" (frame)); # else __asm__ __volatile__ ("ld %0,0(r1)" : "=r" (frame)); # endif } else # else GC_ASSERT(stack_start != 0); /* not implemented */ # endif /* !POWERPC */ /* else */ { frame = (StackFrame *)stack_start; } # ifdef DEBUG_THREADS_EXTRA GC_log_printf("FindTopOfStack start at sp = %p\n", frame); # endif while (frame->savedSP != 0) { /* if there are no more stack frames, stop */ frame = (StackFrame*)frame->savedSP; /* we do these next two checks after going to the next frame because the LR for the first stack frame in the loop is not set up on purpose, so we shouldn't check it. */ if ((frame->savedLR & ~0x3) == 0 || (frame->savedLR & ~0x3) == ~0x3U) break; /* if the next LR is bogus, stop */ } # ifdef DEBUG_THREADS_EXTRA GC_log_printf("FindTopOfStack finish at sp = %p\n", frame); # endif return (ptr_t)frame; } #endif /* !DARWIN_DONT_PARSE_STACK */ /* GC_query_task_threads controls whether to obtain the list of */ /* the threads from the kernel or to use GC_threads table. */ #ifdef GC_NO_THREADS_DISCOVERY # define GC_query_task_threads FALSE #elif defined(GC_DISCOVER_TASK_THREADS) # define GC_query_task_threads TRUE #else STATIC GC_bool GC_query_task_threads = FALSE; #endif /* !GC_NO_THREADS_DISCOVERY */ /* Use implicit threads registration (all task threads excluding the GC */ /* special ones are stopped and scanned). Should be called before */ /* GC_INIT() (or, at least, before going multi-threaded). Deprecated. */ GC_API void GC_CALL GC_use_threads_discovery(void) { # if defined(GC_NO_THREADS_DISCOVERY) || defined(DARWIN_DONT_PARSE_STACK) ABORT("Darwin task-threads-based stop and push unsupported"); # else # ifndef GC_ALWAYS_MULTITHREADED GC_ASSERT(!GC_need_to_lock); # endif # ifndef GC_DISCOVER_TASK_THREADS GC_query_task_threads = TRUE; # endif GC_init_parallel(); /* just to be consistent with Win32 one */ # endif } #ifndef kCFCoreFoundationVersionNumber_iOS_8_0 # define kCFCoreFoundationVersionNumber_iOS_8_0 1140.1 #endif /* Evaluates the stack range for a given thread. Returns the lower */ /* bound and sets *phi to the upper one. */ STATIC ptr_t GC_stack_range_for(ptr_t *phi, thread_act_t thread, GC_thread p, GC_bool thread_blocked, mach_port_t my_thread) { ptr_t lo; if (thread == my_thread) { GC_ASSERT(!thread_blocked); lo = GC_approx_sp(); # ifndef DARWIN_DONT_PARSE_STACK *phi = GC_FindTopOfStack(0); # endif } else if (thread_blocked) { lo = p->stop_info.stack_ptr; # ifndef DARWIN_DONT_PARSE_STACK *phi = p->topOfStack; # endif } else { /* MACHINE_THREAD_STATE_COUNT does not seem to be defined */ /* everywhere. Hence we use our own version. Alternatively, */ /* we could use THREAD_STATE_MAX (but seems to be not optimal). */ kern_return_t kern_result; GC_THREAD_STATE_T state; # if defined(ARM32) && defined(ARM_THREAD_STATE32) /* Use ARM_UNIFIED_THREAD_STATE on iOS8+ 32-bit targets and on */ /* 64-bit H/W (iOS7+ 32-bit mode). */ size_t size; static cpu_type_t cputype = 0; if (cputype == 0) { sysctlbyname("hw.cputype", &cputype, &size, NULL, 0); } if (cputype == CPU_TYPE_ARM64 || kCFCoreFoundationVersionNumber >= kCFCoreFoundationVersionNumber_iOS_8_0) { arm_unified_thread_state_t unified_state; mach_msg_type_number_t unified_thread_state_count = ARM_UNIFIED_THREAD_STATE_COUNT; kern_result = thread_get_state(thread, ARM_UNIFIED_THREAD_STATE, (natural_t *)&unified_state, &unified_thread_state_count); if (unified_state.ash.flavor != ARM_THREAD_STATE32) { ABORT("unified_state flavor should be ARM_THREAD_STATE32"); } state = unified_state.ts_32; } else # endif /* else */ { mach_msg_type_number_t thread_state_count = GC_MACH_THREAD_STATE_COUNT; /* Get the thread state (registers, etc) */ kern_result = thread_get_state(thread, GC_MACH_THREAD_STATE, (natural_t *)&state, &thread_state_count); } # ifdef DEBUG_THREADS GC_log_printf("thread_get_state returns value = %d\n", kern_result); # endif if (kern_result != KERN_SUCCESS) ABORT("thread_get_state failed"); # if defined(I386) lo = (void *)state.THREAD_FLD(esp); # ifndef DARWIN_DONT_PARSE_STACK *phi = GC_FindTopOfStack(state.THREAD_FLD(esp)); # endif GC_push_one(state.THREAD_FLD(eax)); GC_push_one(state.THREAD_FLD(ebx)); GC_push_one(state.THREAD_FLD(ecx)); GC_push_one(state.THREAD_FLD(edx)); GC_push_one(state.THREAD_FLD(edi)); GC_push_one(state.THREAD_FLD(esi)); GC_push_one(state.THREAD_FLD(ebp)); # elif defined(X86_64) lo = (void *)state.THREAD_FLD(rsp); # ifndef DARWIN_DONT_PARSE_STACK *phi = GC_FindTopOfStack(state.THREAD_FLD(rsp)); # endif GC_push_one(state.THREAD_FLD(rax)); GC_push_one(state.THREAD_FLD(rbx)); GC_push_one(state.THREAD_FLD(rcx)); GC_push_one(state.THREAD_FLD(rdx)); GC_push_one(state.THREAD_FLD(rdi)); GC_push_one(state.THREAD_FLD(rsi)); GC_push_one(state.THREAD_FLD(rbp)); /* GC_push_one(state.THREAD_FLD(rsp)); */ GC_push_one(state.THREAD_FLD(r8)); GC_push_one(state.THREAD_FLD(r9)); GC_push_one(state.THREAD_FLD(r10)); GC_push_one(state.THREAD_FLD(r11)); GC_push_one(state.THREAD_FLD(r12)); GC_push_one(state.THREAD_FLD(r13)); GC_push_one(state.THREAD_FLD(r14)); GC_push_one(state.THREAD_FLD(r15)); # elif defined(POWERPC) lo = (void *)(state.THREAD_FLD(r1) - PPC_RED_ZONE_SIZE); # ifndef DARWIN_DONT_PARSE_STACK *phi = GC_FindTopOfStack(state.THREAD_FLD(r1)); # endif GC_push_one(state.THREAD_FLD(r0)); GC_push_one(state.THREAD_FLD(r2)); GC_push_one(state.THREAD_FLD(r3)); GC_push_one(state.THREAD_FLD(r4)); GC_push_one(state.THREAD_FLD(r5)); GC_push_one(state.THREAD_FLD(r6)); GC_push_one(state.THREAD_FLD(r7)); GC_push_one(state.THREAD_FLD(r8)); GC_push_one(state.THREAD_FLD(r9)); GC_push_one(state.THREAD_FLD(r10)); GC_push_one(state.THREAD_FLD(r11)); GC_push_one(state.THREAD_FLD(r12)); GC_push_one(state.THREAD_FLD(r13)); GC_push_one(state.THREAD_FLD(r14)); GC_push_one(state.THREAD_FLD(r15)); GC_push_one(state.THREAD_FLD(r16)); GC_push_one(state.THREAD_FLD(r17)); GC_push_one(state.THREAD_FLD(r18)); GC_push_one(state.THREAD_FLD(r19)); GC_push_one(state.THREAD_FLD(r20)); GC_push_one(state.THREAD_FLD(r21)); GC_push_one(state.THREAD_FLD(r22)); GC_push_one(state.THREAD_FLD(r23)); GC_push_one(state.THREAD_FLD(r24)); GC_push_one(state.THREAD_FLD(r25)); GC_push_one(state.THREAD_FLD(r26)); GC_push_one(state.THREAD_FLD(r27)); GC_push_one(state.THREAD_FLD(r28)); GC_push_one(state.THREAD_FLD(r29)); GC_push_one(state.THREAD_FLD(r30)); GC_push_one(state.THREAD_FLD(r31)); # elif defined(ARM32) lo = (void *)state.THREAD_FLD(sp); # ifndef DARWIN_DONT_PARSE_STACK *phi = GC_FindTopOfStack(state.THREAD_FLD(sp)); # endif { int j; for (j = 0; j <= 12; j++) { GC_push_one(state.THREAD_FLD(r[j])); } } /* "pc" and "sp" are skipped */ GC_push_one(state.THREAD_FLD(lr)); GC_push_one(state.THREAD_FLD(cpsr)); # elif defined(AARCH64) lo = (void *)state.THREAD_FLD(sp); # ifndef DARWIN_DONT_PARSE_STACK *phi = GC_FindTopOfStack(state.THREAD_FLD(sp)); # endif { int j; for (j = 0; j <= 28; j++) { GC_push_one(state.THREAD_FLD(x[j])); } } /* "cpsr", "pc" and "sp" are skipped */ GC_push_one(state.THREAD_FLD(fp)); GC_push_one(state.THREAD_FLD(lr)); # else # error FIXME for non-x86 || ppc || arm architectures # endif } /* thread != my_thread */ # ifdef DARWIN_DONT_PARSE_STACK /* p is guaranteed to be non-NULL regardless of GC_query_task_threads. */ *phi = (p->flags & MAIN_THREAD) != 0 ? GC_stackbottom : p->stack_end; # endif # ifdef DEBUG_THREADS GC_log_printf("Darwin: Stack for thread %p = [%p,%p)\n", (void *)thread, lo, *phi); # endif return lo; } GC_INNER void GC_push_all_stacks(void) { int i; ptr_t lo, hi; task_t my_task = current_task(); mach_port_t my_thread = mach_thread_self(); GC_bool found_me = FALSE; int nthreads = 0; word total_size = 0; mach_msg_type_number_t listcount = (mach_msg_type_number_t)THREAD_TABLE_SZ; if (!EXPECT(GC_thr_initialized, TRUE)) GC_thr_init(); # ifndef DARWIN_DONT_PARSE_STACK if (GC_query_task_threads) { kern_return_t kern_result; thread_act_array_t act_list = 0; /* Obtain the list of the threads from the kernel. */ kern_result = task_threads(my_task, &act_list, &listcount); if (kern_result != KERN_SUCCESS) ABORT("task_threads failed"); for (i = 0; i < (int)listcount; i++) { thread_act_t thread = act_list[i]; lo = GC_stack_range_for(&hi, thread, NULL, FALSE, my_thread); GC_ASSERT((word)lo <= (word)hi); total_size += hi - lo; GC_push_all_stack(lo, hi); nthreads++; if (thread == my_thread) found_me = TRUE; mach_port_deallocate(my_task, thread); } /* for (i=0; ...) */ vm_deallocate(my_task, (vm_address_t)act_list, sizeof(thread_t) * listcount); } else # endif /* !DARWIN_DONT_PARSE_STACK */ /* else */ { for (i = 0; i < (int)listcount; i++) { GC_thread p; for (p = GC_threads[i]; p != NULL; p = p->next) if ((p->flags & FINISHED) == 0) { thread_act_t thread = (thread_act_t)p->stop_info.mach_thread; lo = GC_stack_range_for(&hi, thread, p, (GC_bool)p->thread_blocked, my_thread); GC_ASSERT((word)lo <= (word)hi); total_size += hi - lo; GC_push_all_stack_sections(lo, hi, p->traced_stack_sect); nthreads++; if (thread == my_thread) found_me = TRUE; } } /* for (i=0; ...) */ } mach_port_deallocate(my_task, my_thread); GC_VERBOSE_LOG_PRINTF("Pushed %d thread stacks\n", nthreads); if (!found_me && !GC_in_thread_creation) ABORT("Collecting from unknown thread"); GC_total_stacksize = total_size; } #ifndef GC_NO_THREADS_DISCOVERY # ifdef MPROTECT_VDB STATIC mach_port_t GC_mach_handler_thread = 0; STATIC GC_bool GC_use_mach_handler_thread = FALSE; GC_INNER void GC_darwin_register_mach_handler_thread(mach_port_t thread) { GC_mach_handler_thread = thread; GC_use_mach_handler_thread = TRUE; } # endif /* MPROTECT_VDB */ # ifndef GC_MAX_MACH_THREADS # define GC_MAX_MACH_THREADS THREAD_TABLE_SZ # endif struct GC_mach_thread { thread_act_t thread; GC_bool already_suspended; }; struct GC_mach_thread GC_mach_threads[GC_MAX_MACH_THREADS]; STATIC int GC_mach_threads_count = 0; /* FIXME: it is better to implement GC_mach_threads as a hash set. */ /* returns true if there's a thread in act_list that wasn't in old_list */ STATIC GC_bool GC_suspend_thread_list(thread_act_array_t act_list, int count, thread_act_array_t old_list, int old_count, mach_port_t my_thread) { int i; int j = -1; GC_bool changed = FALSE; for (i = 0; i < count; i++) { thread_act_t thread = act_list[i]; GC_bool found; struct thread_basic_info info; mach_msg_type_number_t outCount; kern_return_t kern_result; if (thread == my_thread # ifdef MPROTECT_VDB || (GC_mach_handler_thread == thread && GC_use_mach_handler_thread) # endif ) { /* Don't add our and the handler threads. */ continue; } # ifdef PARALLEL_MARK if (GC_is_mach_marker(thread)) continue; /* ignore the parallel marker threads */ # endif # ifdef DEBUG_THREADS GC_log_printf("Attempting to suspend thread %p\n", (void *)thread); # endif /* find the current thread in the old list */ found = FALSE; { int last_found = j; /* remember the previous found thread index */ /* Search for the thread starting from the last found one first. */ while (++j < old_count) if (old_list[j] == thread) { found = TRUE; break; } if (!found) { /* If not found, search in the rest (beginning) of the list. */ for (j = 0; j < last_found; j++) if (old_list[j] == thread) { found = TRUE; break; } if (!found) { /* add it to the GC_mach_threads list */ if (GC_mach_threads_count == GC_MAX_MACH_THREADS) ABORT("Too many threads"); GC_mach_threads[GC_mach_threads_count].thread = thread; /* default is not suspended */ GC_mach_threads[GC_mach_threads_count].already_suspended = FALSE; changed = TRUE; } } } outCount = THREAD_INFO_MAX; kern_result = thread_info(thread, THREAD_BASIC_INFO, (thread_info_t)&info, &outCount); if (kern_result != KERN_SUCCESS) { /* The thread may have quit since the thread_threads() call we */ /* mark already suspended so it's not dealt with anymore later. */ if (!found) GC_mach_threads[GC_mach_threads_count++].already_suspended = TRUE; continue; } # ifdef DEBUG_THREADS GC_log_printf("Thread state for %p = %d\n", (void *)thread, info.run_state); # endif if (info.suspend_count != 0) { /* thread is already suspended. */ if (!found) GC_mach_threads[GC_mach_threads_count++].already_suspended = TRUE; continue; } # ifdef DEBUG_THREADS GC_log_printf("Suspending %p\n", (void *)thread); # endif kern_result = thread_suspend(thread); if (kern_result != KERN_SUCCESS) { /* The thread may have quit since the thread_threads() call we */ /* mark already suspended so it's not dealt with anymore later. */ if (!found) GC_mach_threads[GC_mach_threads_count++].already_suspended = TRUE; continue; } if (!found) GC_mach_threads_count++; } return changed; } #endif /* !GC_NO_THREADS_DISCOVERY */ /* Caller holds allocation lock. */ GC_INNER void GC_stop_world(void) { unsigned i; task_t my_task = current_task(); mach_port_t my_thread = mach_thread_self(); kern_return_t kern_result; # ifdef DEBUG_THREADS GC_log_printf("Stopping the world from thread %p\n", (void *)my_thread); # endif # ifdef PARALLEL_MARK if (GC_parallel) { /* Make sure all free list construction has stopped before we */ /* start. No new construction can start, since free list */ /* construction is required to acquire and release the GC lock */ /* before it starts, and we have the lock. */ GC_acquire_mark_lock(); GC_ASSERT(GC_fl_builder_count == 0); /* We should have previously waited for it to become zero. */ } # endif /* PARALLEL_MARK */ if (GC_query_task_threads) { # ifndef GC_NO_THREADS_DISCOVERY GC_bool changed; thread_act_array_t act_list, prev_list; mach_msg_type_number_t listcount, prevcount; /* Clear out the mach threads list table. We do not need to */ /* really clear GC_mach_threads[] as it is used only in the range */ /* from 0 to GC_mach_threads_count-1, inclusive. */ GC_mach_threads_count = 0; /* Loop stopping threads until you have gone over the whole list */ /* twice without a new one appearing. thread_create() won't */ /* return (and thus the thread stop) until the new thread exists, */ /* so there is no window whereby you could stop a thread, */ /* recognize it is stopped, but then have a new thread it created */ /* before stopping show up later. */ changed = TRUE; prev_list = NULL; prevcount = 0; do { kern_result = task_threads(my_task, &act_list, &listcount); if (kern_result == KERN_SUCCESS) { changed = GC_suspend_thread_list(act_list, listcount, prev_list, prevcount, my_thread); if (prev_list != NULL) { for (i = 0; i < prevcount; i++) mach_port_deallocate(my_task, prev_list[i]); vm_deallocate(my_task, (vm_address_t)prev_list, sizeof(thread_t) * prevcount); } /* Repeat while having changes. */ prev_list = act_list; prevcount = listcount; } } while (changed); GC_ASSERT(prev_list != 0); for (i = 0; i < prevcount; i++) mach_port_deallocate(my_task, prev_list[i]); vm_deallocate(my_task, (vm_address_t)act_list, sizeof(thread_t) * listcount); # endif /* !GC_NO_THREADS_DISCOVERY */ } else { for (i = 0; i < THREAD_TABLE_SZ; i++) { GC_thread p; for (p = GC_threads[i]; p != NULL; p = p->next) { if ((p->flags & FINISHED) == 0 && !p->thread_blocked && p->stop_info.mach_thread != my_thread) { kern_result = thread_suspend(p->stop_info.mach_thread); if (kern_result != KERN_SUCCESS) ABORT("thread_suspend failed"); } } } } # ifdef MPROTECT_VDB if(GC_incremental) { GC_mprotect_stop(); } # endif # ifdef PARALLEL_MARK if (GC_parallel) GC_release_mark_lock(); # endif # ifdef DEBUG_THREADS GC_log_printf("World stopped from %p\n", (void *)my_thread); # endif mach_port_deallocate(my_task, my_thread); } GC_INLINE void GC_thread_resume(thread_act_t thread) { kern_return_t kern_result; # if defined(DEBUG_THREADS) || defined(GC_ASSERTIONS) struct thread_basic_info info; mach_msg_type_number_t outCount = THREAD_INFO_MAX; kern_result = thread_info(thread, THREAD_BASIC_INFO, (thread_info_t)&info, &outCount); if (kern_result != KERN_SUCCESS) ABORT("thread_info failed"); # endif # ifdef DEBUG_THREADS GC_log_printf("Resuming thread %p with state %d\n", (void *)thread, info.run_state); # endif /* Resume the thread */ kern_result = thread_resume(thread); if (kern_result != KERN_SUCCESS) ABORT("thread_resume failed"); } /* Caller holds allocation lock, and has held it continuously since */ /* the world stopped. */ GC_INNER void GC_start_world(void) { task_t my_task = current_task(); int i; # ifdef DEBUG_THREADS GC_log_printf("World starting\n"); # endif # ifdef MPROTECT_VDB if(GC_incremental) { GC_mprotect_resume(); } # endif if (GC_query_task_threads) { # ifndef GC_NO_THREADS_DISCOVERY int j = GC_mach_threads_count; kern_return_t kern_result; thread_act_array_t act_list; mach_msg_type_number_t listcount; kern_result = task_threads(my_task, &act_list, &listcount); if (kern_result != KERN_SUCCESS) ABORT("task_threads failed"); for (i = 0; i < (int)listcount; i++) { thread_act_t thread = act_list[i]; int last_found = j; /* The thread index found during the */ /* previous iteration (count value */ /* means no thread found yet). */ /* Search for the thread starting from the last found one first. */ while (++j < GC_mach_threads_count) { if (GC_mach_threads[j].thread == thread) break; } if (j >= GC_mach_threads_count) { /* If not found, search in the rest (beginning) of the list. */ for (j = 0; j < last_found; j++) { if (GC_mach_threads[j].thread == thread) break; } } if (j != last_found) { /* The thread is found in GC_mach_threads. */ if (GC_mach_threads[j].already_suspended) { # ifdef DEBUG_THREADS GC_log_printf("Not resuming already suspended thread %p\n", (void *)thread); # endif } else { GC_thread_resume(thread); } } mach_port_deallocate(my_task, thread); } vm_deallocate(my_task, (vm_address_t)act_list, sizeof(thread_t) * listcount); # endif /* !GC_NO_THREADS_DISCOVERY */ } else { mach_port_t my_thread = mach_thread_self(); for (i = 0; i < THREAD_TABLE_SZ; i++) { GC_thread p; for (p = GC_threads[i]; p != NULL; p = p->next) { if ((p->flags & FINISHED) == 0 && !p->thread_blocked && p->stop_info.mach_thread != my_thread) GC_thread_resume(p->stop_info.mach_thread); } } mach_port_deallocate(my_task, my_thread); } # ifdef DEBUG_THREADS GC_log_printf("World started\n"); # endif } #endif /* GC_DARWIN_THREADS */ ecl-16.1.2/src/bdwgc/dbg_mlc.c000066400000000000000000001200601266352375300157670ustar00rootroot00000000000000/* * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers * Copyright (c) 1991-1995 by Xerox Corporation. All rights reserved. * Copyright (c) 1997 by Silicon Graphics. All rights reserved. * Copyright (c) 1999-2004 Hewlett-Packard Development Company, L.P. * Copyright (C) 2007 Free Software Foundation, Inc * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. */ #include "private/dbg_mlc.h" #ifndef MSWINCE # include #endif #include #ifndef SHORT_DBG_HDRS /* Check whether object with base pointer p has debugging info. */ /* p is assumed to point to a legitimate object in our part */ /* of the heap. */ /* This excludes the check as to whether the back pointer is */ /* odd, which is added by the GC_HAS_DEBUG_INFO macro. */ /* Note that if DBG_HDRS_ALL is set, uncollectible objects */ /* on free lists may not have debug information set. Thus it's */ /* not always safe to return TRUE (1), even if the client does */ /* its part. Return -1 if the object with debug info has been */ /* marked as deallocated. */ GC_INNER int GC_has_other_debug_info(ptr_t p) { ptr_t body = (ptr_t)((oh *)p + 1); word sz = GC_size(p); if (HBLKPTR(p) != HBLKPTR((ptr_t)body) || sz < DEBUG_BYTES + EXTRA_BYTES) { return 0; } if (((oh *)p) -> oh_sf != (START_FLAG ^ (word)body) && ((word *)p)[BYTES_TO_WORDS(sz)-1] != (END_FLAG ^ (word)body)) { return 0; } if (((oh *)p)->oh_sz == sz) { /* Object may have had debug info, but has been deallocated */ return -1; } return 1; } #endif /* !SHORT_DBG_HDRS */ #ifdef KEEP_BACK_PTRS # include # if defined(__GLIBC__) || defined(SOLARIS) \ || defined(HPUX) || defined(IRIX5) || defined(OSF1) # define RANDOM() random() # else # define RANDOM() (long)rand() # endif /* Store back pointer to source in dest, if that appears to be possible. */ /* This is not completely safe, since we may mistakenly conclude that */ /* dest has a debugging wrapper. But the error probability is very */ /* small, and this shouldn't be used in production code. */ /* We assume that dest is the real base pointer. Source will usually */ /* be a pointer to the interior of an object. */ GC_INNER void GC_store_back_pointer(ptr_t source, ptr_t dest) { if (GC_HAS_DEBUG_INFO(dest)) { ((oh *)dest) -> oh_back_ptr = HIDE_BACK_PTR(source); } } GC_INNER void GC_marked_for_finalization(ptr_t dest) { GC_store_back_pointer(MARKED_FOR_FINALIZATION, dest); } /* Store information about the object referencing dest in *base_p */ /* and *offset_p. */ /* source is root ==> *base_p = address, *offset_p = 0 */ /* source is heap object ==> *base_p != 0, *offset_p = offset */ /* Returns 1 on success, 0 if source couldn't be determined. */ /* Dest can be any address within a heap object. */ GC_API GC_ref_kind GC_CALL GC_get_back_ptr_info(void *dest, void **base_p, size_t *offset_p) { oh * hdr = (oh *)GC_base(dest); ptr_t bp; ptr_t bp_base; # ifdef LINT2 /* Explicitly instruct the code analysis tool that */ /* GC_get_back_ptr_info is not expected to be called with an */ /* incorrect "dest" value. */ if (!hdr) ABORT("Invalid GC_get_back_ptr_info argument"); # endif if (!GC_HAS_DEBUG_INFO((ptr_t) hdr)) return GC_NO_SPACE; bp = GC_REVEAL_POINTER(hdr -> oh_back_ptr); if (MARKED_FOR_FINALIZATION == bp) return GC_FINALIZER_REFD; if (MARKED_FROM_REGISTER == bp) return GC_REFD_FROM_REG; if (NOT_MARKED == bp) return GC_UNREFERENCED; # if ALIGNMENT == 1 /* Heuristically try to fix off by 1 errors we introduced by */ /* insisting on even addresses. */ { ptr_t alternate_ptr = bp + 1; ptr_t target = *(ptr_t *)bp; ptr_t alternate_target = *(ptr_t *)alternate_ptr; if ((word)alternate_target >= (word)GC_least_plausible_heap_addr && (word)alternate_target <= (word)GC_greatest_plausible_heap_addr && ((word)target < (word)GC_least_plausible_heap_addr || (word)target > (word)GC_greatest_plausible_heap_addr)) { bp = alternate_ptr; } } # endif bp_base = GC_base(bp); if (0 == bp_base) { *base_p = bp; *offset_p = 0; return GC_REFD_FROM_ROOT; } else { if (GC_HAS_DEBUG_INFO(bp_base)) bp_base += sizeof(oh); *base_p = bp_base; *offset_p = bp - bp_base; return GC_REFD_FROM_HEAP; } } /* Generate a random heap address. */ /* The resulting address is in the heap, but */ /* not necessarily inside a valid object. */ GC_API void * GC_CALL GC_generate_random_heap_address(void) { size_t i; size_t size; word heap_offset = RANDOM(); if (GC_heapsize > RAND_MAX) { heap_offset *= RAND_MAX; heap_offset += RANDOM(); } heap_offset %= GC_heapsize; /* This doesn't yield a uniform distribution, especially if */ /* e.g. RAND_MAX = 1.5* GC_heapsize. But for typical cases, */ /* it's not too bad. */ for (i = 0;; ++i) { if (i >= GC_n_heap_sects) ABORT("GC_generate_random_heap_address: size inconsistency"); size = GC_heap_sects[i].hs_bytes; if (heap_offset < size) { break; } else { heap_offset -= size; } } return GC_heap_sects[i].hs_start + heap_offset; } /* Generate a random address inside a valid marked heap object. */ GC_API void * GC_CALL GC_generate_random_valid_address(void) { ptr_t result; ptr_t base; do { result = GC_generate_random_heap_address(); base = GC_base(result); } while (base == 0 || !GC_is_marked(base)); return result; } /* Print back trace for p */ GC_API void GC_CALL GC_print_backtrace(void *p) { void *current = p; int i; GC_ref_kind source; size_t offset; void *base; GC_print_heap_obj(GC_base(current)); for (i = 0; ; ++i) { source = GC_get_back_ptr_info(current, &base, &offset); if (GC_UNREFERENCED == source) { GC_err_printf("Reference could not be found\n"); goto out; } if (GC_NO_SPACE == source) { GC_err_printf("No debug info in object: Can't find reference\n"); goto out; } GC_err_printf("Reachable via %d levels of pointers from ", i); switch(source) { case GC_REFD_FROM_ROOT: GC_err_printf("root at %p\n\n", base); goto out; case GC_REFD_FROM_REG: GC_err_printf("root in register\n\n"); goto out; case GC_FINALIZER_REFD: GC_err_printf("list of finalizable objects\n\n"); goto out; case GC_REFD_FROM_HEAP: GC_err_printf("offset %ld in object:\n", (long)offset); /* Take GC_base(base) to get real base, i.e. header. */ GC_print_heap_obj(GC_base(base)); break; default: GC_err_printf("INTERNAL ERROR: UNEXPECTED SOURCE!!!!\n"); goto out; } current = base; } out:; } /* Force a garbage collection and generate/print a backtrace */ /* from a random heap address. */ GC_INNER void GC_generate_random_backtrace_no_gc(void) { void * current; current = GC_generate_random_valid_address(); GC_printf("\n****Chosen address %p in object\n", current); GC_print_backtrace(current); } GC_API void GC_CALL GC_generate_random_backtrace(void) { if (GC_try_to_collect(GC_never_stop_func) == 0) { GC_err_printf("Cannot generate a backtrace: " "garbage collection is disabled!\n"); return; } GC_generate_random_backtrace_no_gc(); } #endif /* KEEP_BACK_PTRS */ # define CROSSES_HBLK(p, sz) \ (((word)((p) + sizeof(oh) + (sz) - 1) ^ (word)(p)) >= HBLKSIZE) /* Store debugging info into p. Return displaced pointer. */ /* This version assumes we do hold the allocation lock. */ STATIC ptr_t GC_store_debug_info_inner(ptr_t p, word sz GC_ATTR_UNUSED, const char *string, int linenum) { word * result = (word *)((oh *)p + 1); GC_ASSERT(GC_size(p) >= sizeof(oh) + sz); GC_ASSERT(!(SMALL_OBJ(sz) && CROSSES_HBLK(p, sz))); # ifdef KEEP_BACK_PTRS ((oh *)p) -> oh_back_ptr = HIDE_BACK_PTR(NOT_MARKED); # endif # ifdef MAKE_BACK_GRAPH ((oh *)p) -> oh_bg_ptr = HIDE_BACK_PTR((ptr_t)0); # endif ((oh *)p) -> oh_string = string; ((oh *)p) -> oh_int = (word)linenum; # ifndef SHORT_DBG_HDRS ((oh *)p) -> oh_sz = sz; ((oh *)p) -> oh_sf = START_FLAG ^ (word)result; ((word *)p)[BYTES_TO_WORDS(GC_size(p))-1] = result[SIMPLE_ROUNDED_UP_WORDS(sz)] = END_FLAG ^ (word)result; # endif return((ptr_t)result); } GC_INNER ptr_t GC_store_debug_info(ptr_t p, word sz, const char *string, int linenum) { ptr_t result; DCL_LOCK_STATE; LOCK(); result = GC_store_debug_info_inner(p, sz, string, linenum); UNLOCK(); return result; } #ifndef SHORT_DBG_HDRS /* Check the object with debugging info at ohdr. */ /* Return NULL if it's OK. Else return clobbered */ /* address. */ STATIC ptr_t GC_check_annotated_obj(oh *ohdr) { ptr_t body = (ptr_t)(ohdr + 1); word gc_sz = GC_size((ptr_t)ohdr); if (ohdr -> oh_sz + DEBUG_BYTES > gc_sz) { return((ptr_t)(&(ohdr -> oh_sz))); } if (ohdr -> oh_sf != (START_FLAG ^ (word)body)) { return((ptr_t)(&(ohdr -> oh_sf))); } if (((word *)ohdr)[BYTES_TO_WORDS(gc_sz)-1] != (END_FLAG ^ (word)body)) { return((ptr_t)((word *)ohdr + BYTES_TO_WORDS(gc_sz)-1)); } if (((word *)body)[SIMPLE_ROUNDED_UP_WORDS(ohdr -> oh_sz)] != (END_FLAG ^ (word)body)) { return((ptr_t)((word *)body + SIMPLE_ROUNDED_UP_WORDS(ohdr->oh_sz))); } return(0); } #endif /* !SHORT_DBG_HDRS */ STATIC GC_describe_type_fn GC_describe_type_fns[MAXOBJKINDS] = {0}; GC_API void GC_CALL GC_register_describe_type_fn(int kind, GC_describe_type_fn fn) { GC_describe_type_fns[kind] = fn; } #define GET_OH_LINENUM(ohdr) ((int)(ohdr)->oh_int) #ifndef SHORT_DBG_HDRS # define IF_NOT_SHORTDBG_HDRS(x) x # define COMMA_IFNOT_SHORTDBG_HDRS(x) /* comma */, x #else # define IF_NOT_SHORTDBG_HDRS(x) /* empty */ # define COMMA_IFNOT_SHORTDBG_HDRS(x) /* empty */ #endif /* Print a human-readable description of the object to stderr. */ /* p points to somewhere inside an object with the debugging info. */ STATIC void GC_print_obj(ptr_t p) { oh * ohdr = (oh *)GC_base(p); ptr_t q; hdr * hhdr; int kind; char *kind_str; char buffer[GC_TYPE_DESCR_LEN + 1]; GC_ASSERT(I_DONT_HOLD_LOCK()); # ifdef LINT2 if (!ohdr) ABORT("Invalid GC_print_obj argument"); # endif q = (ptr_t)(ohdr + 1); /* Print a type description for the object whose client-visible */ /* address is q. */ hhdr = GC_find_header(q); kind = hhdr -> hb_obj_kind; if (0 != GC_describe_type_fns[kind] && GC_is_marked(ohdr)) { /* This should preclude free list objects except with */ /* thread-local allocation. */ buffer[GC_TYPE_DESCR_LEN] = 0; (GC_describe_type_fns[kind])(q, buffer); GC_ASSERT(buffer[GC_TYPE_DESCR_LEN] == 0); kind_str = buffer; } else { switch(kind) { case PTRFREE: kind_str = "PTRFREE"; break; case NORMAL: kind_str = "NORMAL"; break; case UNCOLLECTABLE: kind_str = "UNCOLLECTABLE"; break; # ifdef ATOMIC_UNCOLLECTABLE case AUNCOLLECTABLE: kind_str = "ATOMIC_UNCOLLECTABLE"; break; # endif case STUBBORN: kind_str = "STUBBORN"; break; default: kind_str = NULL; /* The alternative is to use snprintf(buffer) but it is */ /* not quite portable (see vsnprintf in misc.c). */ } } if (NULL != kind_str) { GC_err_printf("%p (%s:%d," IF_NOT_SHORTDBG_HDRS(" sz=%lu,") " %s)\n", (ptr_t)ohdr + sizeof(oh), ohdr->oh_string, GET_OH_LINENUM(ohdr) /*, */ COMMA_IFNOT_SHORTDBG_HDRS((unsigned long)ohdr->oh_sz), kind_str); } else { GC_err_printf("%p (%s:%d," IF_NOT_SHORTDBG_HDRS(" sz=%lu,") " kind=%d descr=0x%lx)\n", (ptr_t)ohdr + sizeof(oh), ohdr->oh_string, GET_OH_LINENUM(ohdr) /*, */ COMMA_IFNOT_SHORTDBG_HDRS((unsigned long)ohdr->oh_sz), kind, (unsigned long)hhdr->hb_descr); } PRINT_CALL_CHAIN(ohdr); } STATIC void GC_debug_print_heap_obj_proc(ptr_t p) { GC_ASSERT(I_DONT_HOLD_LOCK()); if (GC_HAS_DEBUG_INFO(p)) { GC_print_obj(p); } else { GC_default_print_heap_obj_proc(p); } } #ifndef SHORT_DBG_HDRS /* Use GC_err_printf and friends to print a description of the object */ /* whose client-visible address is p, and which was smashed at */ /* clobbered_addr. */ STATIC void GC_print_smashed_obj(const char *msg, ptr_t p, ptr_t clobbered_addr) { oh * ohdr = (oh *)GC_base(p); GC_ASSERT(I_DONT_HOLD_LOCK()); # ifdef LINT2 if (!ohdr) ABORT("Invalid GC_print_smashed_obj argument"); # endif if ((word)clobbered_addr <= (word)(&ohdr->oh_sz) || ohdr -> oh_string == 0) { GC_err_printf( "%s %p in or near object at %p(, appr. sz = %lu)\n", msg, clobbered_addr, p, (unsigned long)(GC_size((ptr_t)ohdr) - DEBUG_BYTES)); } else { GC_err_printf("%s %p in or near object at %p (%s:%d, sz=%lu)\n", msg, clobbered_addr, p, (word)(ohdr -> oh_string) < HBLKSIZE ? "(smashed string)" : ohdr -> oh_string[0] == '\0' ? "EMPTY(smashed?)" : ohdr -> oh_string, GET_OH_LINENUM(ohdr), (unsigned long)(ohdr -> oh_sz)); PRINT_CALL_CHAIN(ohdr); } } #endif #ifndef SHORT_DBG_HDRS STATIC void GC_check_heap_proc (void); STATIC void GC_print_all_smashed_proc (void); #else STATIC void GC_do_nothing(void) {} #endif STATIC void GC_start_debugging_inner(void) { GC_ASSERT(I_HOLD_LOCK()); # ifndef SHORT_DBG_HDRS GC_check_heap = GC_check_heap_proc; GC_print_all_smashed = GC_print_all_smashed_proc; # else GC_check_heap = GC_do_nothing; GC_print_all_smashed = GC_do_nothing; # endif GC_print_heap_obj = GC_debug_print_heap_obj_proc; GC_debugging_started = TRUE; GC_register_displacement_inner((word)sizeof(oh)); } GC_INNER void GC_start_debugging(void) { DCL_LOCK_STATE; LOCK(); GC_start_debugging_inner(); UNLOCK(); } size_t GC_debug_header_size = sizeof(oh); GC_API void GC_CALL GC_debug_register_displacement(size_t offset) { DCL_LOCK_STATE; LOCK(); GC_register_displacement_inner(offset); GC_register_displacement_inner((word)sizeof(oh) + offset); UNLOCK(); } #ifdef GC_ADD_CALLER # if defined(HAVE_DLADDR) && defined(GC_RETURN_ADDR_PARENT) # include STATIC void GC_caller_func_offset(word ad, const char **symp, int *offp) { Dl_info caller; if (ad && dladdr((void *)ad, &caller) && caller.dli_sname != NULL) { *symp = caller.dli_sname; *offp = (int)((char *)ad - (char *)caller.dli_saddr); } if (NULL == *symp) { *symp = "unknown"; } } # else # define GC_caller_func_offset(ad, symp, offp) (void)(*(symp) = "unknown") # endif #endif /* GC_ADD_CALLER */ GC_API GC_ATTR_MALLOC void * GC_CALL GC_debug_malloc(size_t lb, GC_EXTRA_PARAMS) { void * result; /* Note that according to malloc() specification, if size is 0 then */ /* malloc() returns either NULL, or a unique pointer value that can */ /* later be successfully passed to free(). We always do the latter. */ result = GC_malloc(lb + DEBUG_BYTES); # ifdef GC_ADD_CALLER if (s == NULL) { GC_caller_func_offset(ra, &s, &i); } # endif if (result == 0) { GC_err_printf("GC_debug_malloc(%lu) returning NULL (%s:%d)\n", (unsigned long)lb, s, i); return(0); } if (!GC_debugging_started) { GC_start_debugging(); } ADD_CALL_CHAIN(result, ra); return (GC_store_debug_info(result, (word)lb, s, i)); } GC_API GC_ATTR_MALLOC void * GC_CALL GC_debug_malloc_ignore_off_page(size_t lb, GC_EXTRA_PARAMS) { void * result = GC_malloc_ignore_off_page(lb + DEBUG_BYTES); if (result == 0) { GC_err_printf("GC_debug_malloc_ignore_off_page(%lu)" " returning NULL (%s:%d)\n", (unsigned long)lb, s, i); return(0); } if (!GC_debugging_started) { GC_start_debugging(); } ADD_CALL_CHAIN(result, ra); return (GC_store_debug_info(result, (word)lb, s, i)); } GC_API GC_ATTR_MALLOC void * GC_CALL GC_debug_malloc_atomic_ignore_off_page(size_t lb, GC_EXTRA_PARAMS) { void * result = GC_malloc_atomic_ignore_off_page(lb + DEBUG_BYTES); if (result == 0) { GC_err_printf("GC_debug_malloc_atomic_ignore_off_page(%lu)" " returning NULL (%s:%d)\n", (unsigned long)lb, s, i); return(0); } if (!GC_debugging_started) { GC_start_debugging(); } ADD_CALL_CHAIN(result, ra); return (GC_store_debug_info(result, (word)lb, s, i)); } STATIC void * GC_debug_generic_malloc(size_t lb, int knd, GC_EXTRA_PARAMS) { void * result = GC_generic_malloc(lb + DEBUG_BYTES, knd); if (NULL == result) { GC_err_printf( "GC_debug_generic_malloc(%lu, %d) returning NULL (%s:%d)\n", (unsigned long)lb, knd, s, i); return NULL; } if (!GC_debugging_started) { GC_start_debugging(); } ADD_CALL_CHAIN(result, ra); return GC_store_debug_info(result, (word)lb, s, i); } #ifdef DBG_HDRS_ALL /* An allocation function for internal use. Normally internally */ /* allocated objects do not have debug information. But in this */ /* case, we need to make sure that all objects have debug headers. */ /* We assume debugging was started in collector initialization, and */ /* we already hold the GC lock. */ GC_INNER void * GC_debug_generic_malloc_inner(size_t lb, int k) { void * result = GC_generic_malloc_inner(lb + DEBUG_BYTES, k); if (result == 0) { GC_err_printf("GC internal allocation (%lu bytes) returning NULL\n", (unsigned long) lb); return(0); } if (!GC_debugging_started) { GC_start_debugging_inner(); } ADD_CALL_CHAIN(result, GC_RETURN_ADDR); return (GC_store_debug_info_inner(result, (word)lb, "INTERNAL", 0)); } GC_INNER void * GC_debug_generic_malloc_inner_ignore_off_page(size_t lb, int k) { void * result = GC_generic_malloc_inner_ignore_off_page( lb + DEBUG_BYTES, k); if (result == 0) { GC_err_printf("GC internal allocation (%lu bytes) returning NULL\n", (unsigned long) lb); return(0); } if (!GC_debugging_started) { GC_start_debugging_inner(); } ADD_CALL_CHAIN(result, GC_RETURN_ADDR); return (GC_store_debug_info_inner(result, (word)lb, "INTERNAL", 0)); } #endif /* DBG_HDRS_ALL */ #ifdef STUBBORN_ALLOC GC_API GC_ATTR_MALLOC void * GC_CALL GC_debug_malloc_stubborn(size_t lb, GC_EXTRA_PARAMS) { void * result = GC_malloc_stubborn(lb + DEBUG_BYTES); if (result == 0) { GC_err_printf("GC_debug_malloc_stubborn(%lu)" " returning NULL (%s:%d)\n", (unsigned long)lb, s, i); return(0); } if (!GC_debugging_started) { GC_start_debugging(); } ADD_CALL_CHAIN(result, ra); return (GC_store_debug_info(result, (word)lb, s, i)); } GC_API void GC_CALL GC_debug_change_stubborn(const void *p) { const void * q = GC_base_C(p); hdr * hhdr; if (q == 0) { ABORT_ARG1("GC_debug_change_stubborn: bad arg", ": %p", p); } hhdr = HDR(q); if (hhdr -> hb_obj_kind != STUBBORN) { ABORT_ARG1("GC_debug_change_stubborn: arg not stubborn", ": %p", p); } GC_change_stubborn(q); } GC_API void GC_CALL GC_debug_end_stubborn_change(const void *p) { const void * q = GC_base_C(p); hdr * hhdr; if (q == 0) { ABORT_ARG1("GC_debug_end_stubborn_change: bad arg", ": %p", p); } hhdr = HDR(q); if (hhdr -> hb_obj_kind != STUBBORN) { ABORT_ARG1("GC_debug_end_stubborn_change: arg not stubborn", ": %p", p); } GC_end_stubborn_change(q); } #else /* !STUBBORN_ALLOC */ GC_API GC_ATTR_MALLOC void * GC_CALL GC_debug_malloc_stubborn(size_t lb, GC_EXTRA_PARAMS) { return GC_debug_malloc(lb, OPT_RA s, i); } GC_API void GC_CALL GC_debug_change_stubborn( const void * p GC_ATTR_UNUSED) {} GC_API void GC_CALL GC_debug_end_stubborn_change( const void * p GC_ATTR_UNUSED) {} #endif /* !STUBBORN_ALLOC */ GC_API GC_ATTR_MALLOC void * GC_CALL GC_debug_malloc_atomic(size_t lb, GC_EXTRA_PARAMS) { void * result = GC_malloc_atomic(lb + DEBUG_BYTES); if (result == 0) { GC_err_printf("GC_debug_malloc_atomic(%lu) returning NULL (%s:%d)\n", (unsigned long)lb, s, i); return(0); } if (!GC_debugging_started) { GC_start_debugging(); } ADD_CALL_CHAIN(result, ra); return (GC_store_debug_info(result, (word)lb, s, i)); } GC_API GC_ATTR_MALLOC char * GC_CALL GC_debug_strdup(const char *str, GC_EXTRA_PARAMS) { char *copy; size_t lb; if (str == NULL) { if (GC_find_leak) GC_err_printf("strdup(NULL) behavior is undefined\n"); return NULL; } lb = strlen(str) + 1; copy = GC_debug_malloc_atomic(lb, OPT_RA s, i); if (copy == NULL) { # ifndef MSWINCE errno = ENOMEM; # endif return NULL; } BCOPY(str, copy, lb); return copy; } GC_API GC_ATTR_MALLOC char * GC_CALL GC_debug_strndup(const char *str, size_t size, GC_EXTRA_PARAMS) { char *copy; size_t len = strlen(str); /* str is expected to be non-NULL */ if (len > size) len = size; copy = GC_debug_malloc_atomic(len + 1, OPT_RA s, i); if (copy == NULL) { # ifndef MSWINCE errno = ENOMEM; # endif return NULL; } BCOPY(str, copy, len); copy[len] = '\0'; return copy; } #ifdef GC_REQUIRE_WCSDUP # include /* for wcslen() */ GC_API GC_ATTR_MALLOC wchar_t * GC_CALL GC_debug_wcsdup(const wchar_t *str, GC_EXTRA_PARAMS) { size_t lb = (wcslen(str) + 1) * sizeof(wchar_t); wchar_t *copy = GC_debug_malloc_atomic(lb, OPT_RA s, i); if (copy == NULL) { # ifndef MSWINCE errno = ENOMEM; # endif return NULL; } BCOPY(str, copy, lb); return copy; } #endif /* GC_REQUIRE_WCSDUP */ GC_API GC_ATTR_MALLOC void * GC_CALL GC_debug_malloc_uncollectable(size_t lb, GC_EXTRA_PARAMS) { void * result = GC_malloc_uncollectable(lb + UNCOLLECTABLE_DEBUG_BYTES); if (result == 0) { GC_err_printf("GC_debug_malloc_uncollectable(%lu)" " returning NULL (%s:%d)\n", (unsigned long)lb, s, i); return(0); } if (!GC_debugging_started) { GC_start_debugging(); } ADD_CALL_CHAIN(result, ra); return (GC_store_debug_info(result, (word)lb, s, i)); } #ifdef ATOMIC_UNCOLLECTABLE GC_API GC_ATTR_MALLOC void * GC_CALL GC_debug_malloc_atomic_uncollectable(size_t lb, GC_EXTRA_PARAMS) { void * result = GC_malloc_atomic_uncollectable(lb + UNCOLLECTABLE_DEBUG_BYTES); if (result == 0) { GC_err_printf("GC_debug_malloc_atomic_uncollectable(%lu)" " returning NULL (%s:%d)\n", (unsigned long)lb, s, i); return(0); } if (!GC_debugging_started) { GC_start_debugging(); } ADD_CALL_CHAIN(result, ra); return (GC_store_debug_info(result, (word)lb, s, i)); } #endif /* ATOMIC_UNCOLLECTABLE */ #ifndef GC_FREED_MEM_MARKER # if CPP_WORDSZ == 32 # define GC_FREED_MEM_MARKER 0xdeadbeef # else # define GC_FREED_MEM_MARKER GC_WORD_C(0xEFBEADDEdeadbeef) # endif #endif GC_API void GC_CALL GC_debug_free(void * p) { ptr_t base; if (0 == p) return; base = GC_base(p); if (base == 0) { ABORT_ARG1("Invalid pointer passed to free()", ": %p", p); } if ((ptr_t)p - (ptr_t)base != sizeof(oh)) { GC_err_printf( "GC_debug_free called on pointer %p w/o debugging info\n", p); } else { # ifndef SHORT_DBG_HDRS ptr_t clobbered = GC_check_annotated_obj((oh *)base); word sz = GC_size(base); if (clobbered != 0) { GC_have_errors = TRUE; if (((oh *)base) -> oh_sz == sz) { GC_print_smashed_obj( "GC_debug_free: found previously deallocated (?) object at", p, clobbered); return; /* ignore double free */ } else { GC_print_smashed_obj("GC_debug_free: found smashed location at", p, clobbered); } } /* Invalidate size (mark the object as deallocated) */ ((oh *)base) -> oh_sz = sz; # endif /* SHORT_DBG_HDRS */ } if (GC_find_leak # ifndef SHORT_DBG_HDRS && ((ptr_t)p - (ptr_t)base != sizeof(oh) || !GC_findleak_delay_free) # endif ) { GC_free(base); } else { hdr * hhdr = HDR(p); if (hhdr -> hb_obj_kind == UNCOLLECTABLE # ifdef ATOMIC_UNCOLLECTABLE || hhdr -> hb_obj_kind == AUNCOLLECTABLE # endif ) { GC_free(base); } else { size_t i; size_t obj_sz = BYTES_TO_WORDS(hhdr -> hb_sz - sizeof(oh)); for (i = 0; i < obj_sz; ++i) ((word *)p)[i] = GC_FREED_MEM_MARKER; GC_ASSERT((word *)p + i == (word *)(base + hhdr -> hb_sz)); } } /* !GC_find_leak */ } #if defined(THREADS) && defined(DBG_HDRS_ALL) /* Used internally; we assume it's called correctly. */ GC_INNER void GC_debug_free_inner(void * p) { ptr_t base = GC_base(p); GC_ASSERT((ptr_t)p - (ptr_t)base == sizeof(oh)); # ifdef LINT2 if (!base) ABORT("Invalid GC_debug_free_inner argument"); # endif # ifndef SHORT_DBG_HDRS /* Invalidate size */ ((oh *)base) -> oh_sz = GC_size(base); # endif GC_free_inner(base); } #endif GC_API void * GC_CALL GC_debug_realloc(void * p, size_t lb, GC_EXTRA_PARAMS) { void * base; void * result; hdr * hhdr; if (p == 0) { return GC_debug_malloc(lb, OPT_RA s, i); } # ifdef GC_ADD_CALLER if (s == NULL) { GC_caller_func_offset(ra, &s, &i); } # endif base = GC_base(p); if (base == 0) { ABORT_ARG1("Invalid pointer passed to realloc()", ": %p", p); } if ((ptr_t)p - (ptr_t)base != sizeof(oh)) { GC_err_printf( "GC_debug_realloc called on pointer %p w/o debugging info\n", p); return(GC_realloc(p, lb)); } hhdr = HDR(base); switch (hhdr -> hb_obj_kind) { # ifdef STUBBORN_ALLOC case STUBBORN: result = GC_debug_malloc_stubborn(lb, OPT_RA s, i); break; # endif case NORMAL: result = GC_debug_malloc(lb, OPT_RA s, i); break; case PTRFREE: result = GC_debug_malloc_atomic(lb, OPT_RA s, i); break; case UNCOLLECTABLE: result = GC_debug_malloc_uncollectable(lb, OPT_RA s, i); break; # ifdef ATOMIC_UNCOLLECTABLE case AUNCOLLECTABLE: result = GC_debug_malloc_atomic_uncollectable(lb, OPT_RA s, i); break; # endif default: result = NULL; /* initialized to prevent warning. */ ABORT_RET("GC_debug_realloc: encountered bad kind"); } if (result != NULL) { size_t old_sz; # ifdef SHORT_DBG_HDRS old_sz = GC_size(base) - sizeof(oh); # else old_sz = ((oh *)base) -> oh_sz; # endif BCOPY(p, result, old_sz < lb ? old_sz : lb); GC_debug_free(p); } return(result); } GC_API GC_ATTR_MALLOC void * GC_CALL GC_debug_generic_or_special_malloc(size_t lb, int knd, GC_EXTRA_PARAMS) { switch (knd) { # ifdef STUBBORN_ALLOC case STUBBORN: return GC_debug_malloc_stubborn(lb, OPT_RA s, i); # endif case PTRFREE: return GC_debug_malloc_atomic(lb, OPT_RA s, i); case NORMAL: return GC_debug_malloc(lb, OPT_RA s, i); case UNCOLLECTABLE: return GC_debug_malloc_uncollectable(lb, OPT_RA s, i); # ifdef ATOMIC_UNCOLLECTABLE case AUNCOLLECTABLE: return GC_debug_malloc_atomic_uncollectable(lb, OPT_RA s, i); # endif default: return GC_debug_generic_malloc(lb, knd, OPT_RA s, i); } } #ifndef SHORT_DBG_HDRS /* List of smashed (clobbered) locations. We defer printing these, */ /* since we can't always print them nicely with the allocation lock */ /* held. We put them here instead of in GC_arrays, since it may be */ /* useful to be able to look at them with the debugger. */ #ifndef MAX_SMASHED # define MAX_SMASHED 20 #endif STATIC ptr_t GC_smashed[MAX_SMASHED] = {0}; STATIC unsigned GC_n_smashed = 0; STATIC void GC_add_smashed(ptr_t smashed) { GC_ASSERT(GC_is_marked(GC_base(smashed))); /* FIXME: Prevent adding an object while printing smashed list. */ GC_smashed[GC_n_smashed] = smashed; if (GC_n_smashed < MAX_SMASHED - 1) ++GC_n_smashed; /* In case of overflow, we keep the first MAX_SMASHED-1 */ /* entries plus the last one. */ GC_have_errors = TRUE; } /* Print all objects on the list. Clear the list. */ STATIC void GC_print_all_smashed_proc(void) { unsigned i; GC_ASSERT(I_DONT_HOLD_LOCK()); if (GC_n_smashed == 0) return; GC_err_printf("GC_check_heap_block: found %u smashed heap objects:\n", GC_n_smashed); for (i = 0; i < GC_n_smashed; ++i) { ptr_t base = (ptr_t)GC_base(GC_smashed[i]); # ifdef LINT2 if (!base) ABORT("Invalid GC_smashed element"); # endif GC_print_smashed_obj("", base + sizeof(oh), GC_smashed[i]); GC_smashed[i] = 0; } GC_n_smashed = 0; } /* Check all marked objects in the given block for validity */ /* Avoid GC_apply_to_each_object for performance reasons. */ STATIC void GC_check_heap_block(struct hblk *hbp, word dummy GC_ATTR_UNUSED) { struct hblkhdr * hhdr = HDR(hbp); size_t sz = hhdr -> hb_sz; size_t bit_no; char *p, *plim; p = hbp->hb_body; if (sz > MAXOBJBYTES) { plim = p; } else { plim = hbp->hb_body + HBLKSIZE - sz; } /* go through all words in block */ for (bit_no = 0; (word)p <= (word)plim; bit_no += MARK_BIT_OFFSET(sz), p += sz) { if (mark_bit_from_hdr(hhdr, bit_no) && GC_HAS_DEBUG_INFO((ptr_t)p)) { ptr_t clobbered = GC_check_annotated_obj((oh *)p); if (clobbered != 0) GC_add_smashed(clobbered); } } } /* This assumes that all accessible objects are marked, and that */ /* I hold the allocation lock. Normally called by collector. */ STATIC void GC_check_heap_proc(void) { GC_STATIC_ASSERT((sizeof(oh) & (GRANULE_BYTES - 1)) == 0); /* FIXME: Should we check for twice that alignment? */ GC_apply_to_all_blocks(GC_check_heap_block, 0); } GC_INNER GC_bool GC_check_leaked(ptr_t base) { size_t i; size_t obj_sz; word *p; if ( # if defined(KEEP_BACK_PTRS) || defined(MAKE_BACK_GRAPH) (*(word *)base & 1) != 0 && # endif GC_has_other_debug_info(base) >= 0) return TRUE; /* object has leaked */ /* Validate freed object's content. */ p = (word *)(base + sizeof(oh)); obj_sz = BYTES_TO_WORDS(HDR(base)->hb_sz - sizeof(oh)); for (i = 0; i < obj_sz; ++i) if (p[i] != GC_FREED_MEM_MARKER) { GC_set_mark_bit(base); /* do not reclaim it in this cycle */ GC_add_smashed((ptr_t)(&p[i])); /* alter-after-free detected */ break; /* don't report any other smashed locations in the object */ } return FALSE; /* GC_debug_free() has been called */ } #endif /* !SHORT_DBG_HDRS */ #ifndef GC_NO_FINALIZATION struct closure { GC_finalization_proc cl_fn; void * cl_data; }; STATIC void * GC_make_closure(GC_finalization_proc fn, void * data) { struct closure * result = # ifdef DBG_HDRS_ALL (struct closure *) GC_debug_malloc(sizeof (struct closure), GC_EXTRAS); # else (struct closure *) GC_malloc(sizeof (struct closure)); # endif if (result != 0) { result -> cl_fn = fn; result -> cl_data = data; } return((void *)result); } /* An auxiliary fns to make finalization work correctly with displaced */ /* pointers introduced by the debugging allocators. */ STATIC void GC_CALLBACK GC_debug_invoke_finalizer(void * obj, void * data) { struct closure * cl = (struct closure *) data; (*(cl -> cl_fn))((void *)((char *)obj + sizeof(oh)), cl -> cl_data); } /* Special finalizer_proc value to detect GC_register_finalizer() failure. */ #define OFN_UNSET (GC_finalization_proc)(signed_word)-1 /* Set ofn and ocd to reflect the values we got back. */ static void store_old(void *obj, GC_finalization_proc my_old_fn, struct closure *my_old_cd, GC_finalization_proc *ofn, void **ocd) { if (0 != my_old_fn) { if (my_old_fn == OFN_UNSET) { /* register_finalizer() failed; (*ofn) and (*ocd) are unchanged. */ return; } if (my_old_fn != GC_debug_invoke_finalizer) { GC_err_printf("Debuggable object at %p had a non-debug finalizer\n", obj); /* This should probably be fatal. */ } else { if (ofn) *ofn = my_old_cd -> cl_fn; if (ocd) *ocd = my_old_cd -> cl_data; } } else { if (ofn) *ofn = 0; if (ocd) *ocd = 0; } } GC_API void GC_CALL GC_debug_register_finalizer(void * obj, GC_finalization_proc fn, void * cd, GC_finalization_proc *ofn, void * *ocd) { GC_finalization_proc my_old_fn = OFN_UNSET; void * my_old_cd; ptr_t base = GC_base(obj); if (0 == base) { /* We won't collect it, hence finalizer wouldn't be run. */ if (ocd) *ocd = 0; if (ofn) *ofn = 0; return; } if ((ptr_t)obj - base != sizeof(oh)) { GC_err_printf("GC_debug_register_finalizer called with" " non-base-pointer %p\n", obj); } if (0 == fn) { GC_register_finalizer(base, 0, 0, &my_old_fn, &my_old_cd); } else { cd = GC_make_closure(fn, cd); if (cd == 0) return; /* out of memory */ GC_register_finalizer(base, GC_debug_invoke_finalizer, cd, &my_old_fn, &my_old_cd); } store_old(obj, my_old_fn, (struct closure *)my_old_cd, ofn, ocd); } GC_API void GC_CALL GC_debug_register_finalizer_no_order (void * obj, GC_finalization_proc fn, void * cd, GC_finalization_proc *ofn, void * *ocd) { GC_finalization_proc my_old_fn = OFN_UNSET; void * my_old_cd; ptr_t base = GC_base(obj); if (0 == base) { /* We won't collect it, hence finalizer wouldn't be run. */ if (ocd) *ocd = 0; if (ofn) *ofn = 0; return; } if ((ptr_t)obj - base != sizeof(oh)) { GC_err_printf("GC_debug_register_finalizer_no_order called with" " non-base-pointer %p\n", obj); } if (0 == fn) { GC_register_finalizer_no_order(base, 0, 0, &my_old_fn, &my_old_cd); } else { cd = GC_make_closure(fn, cd); if (cd == 0) return; /* out of memory */ GC_register_finalizer_no_order(base, GC_debug_invoke_finalizer, cd, &my_old_fn, &my_old_cd); } store_old(obj, my_old_fn, (struct closure *)my_old_cd, ofn, ocd); } GC_API void GC_CALL GC_debug_register_finalizer_unreachable (void * obj, GC_finalization_proc fn, void * cd, GC_finalization_proc *ofn, void * *ocd) { GC_finalization_proc my_old_fn = OFN_UNSET; void * my_old_cd; ptr_t base = GC_base(obj); if (0 == base) { /* We won't collect it, hence finalizer wouldn't be run. */ if (ocd) *ocd = 0; if (ofn) *ofn = 0; return; } if ((ptr_t)obj - base != sizeof(oh)) { GC_err_printf("GC_debug_register_finalizer_unreachable called with" " non-base-pointer %p\n", obj); } if (0 == fn) { GC_register_finalizer_unreachable(base, 0, 0, &my_old_fn, &my_old_cd); } else { cd = GC_make_closure(fn, cd); if (cd == 0) return; /* out of memory */ GC_register_finalizer_unreachable(base, GC_debug_invoke_finalizer, cd, &my_old_fn, &my_old_cd); } store_old(obj, my_old_fn, (struct closure *)my_old_cd, ofn, ocd); } GC_API void GC_CALL GC_debug_register_finalizer_ignore_self (void * obj, GC_finalization_proc fn, void * cd, GC_finalization_proc *ofn, void * *ocd) { GC_finalization_proc my_old_fn = OFN_UNSET; void * my_old_cd; ptr_t base = GC_base(obj); if (0 == base) { /* We won't collect it, hence finalizer wouldn't be run. */ if (ocd) *ocd = 0; if (ofn) *ofn = 0; return; } if ((ptr_t)obj - base != sizeof(oh)) { GC_err_printf("GC_debug_register_finalizer_ignore_self called with" " non-base-pointer %p\n", obj); } if (0 == fn) { GC_register_finalizer_ignore_self(base, 0, 0, &my_old_fn, &my_old_cd); } else { cd = GC_make_closure(fn, cd); if (cd == 0) return; /* out of memory */ GC_register_finalizer_ignore_self(base, GC_debug_invoke_finalizer, cd, &my_old_fn, &my_old_cd); } store_old(obj, my_old_fn, (struct closure *)my_old_cd, ofn, ocd); } #endif /* !GC_NO_FINALIZATION */ GC_API GC_ATTR_MALLOC void * GC_CALL GC_debug_malloc_replacement(size_t lb) { return GC_debug_malloc(lb, GC_DBG_EXTRAS); } GC_API void * GC_CALL GC_debug_realloc_replacement(void *p, size_t lb) { return GC_debug_realloc(p, lb, GC_DBG_EXTRAS); } ecl-16.1.2/src/bdwgc/depcomp000077500000000000000000000560161266352375300156220ustar00rootroot00000000000000#! /bin/sh # depcomp - compile a program generating dependencies as side-effects scriptversion=2013-05-30.07; # UTC # Copyright (C) 1999-2014 Free Software Foundation, Inc. # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2, or (at your option) # any later version. # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # You should have received a copy of the GNU General Public License # along with this program. If not, see . # As a special exception to the GNU General Public License, if you # distribute this file as part of a program that contains a # configuration script generated by Autoconf, you may include it under # the same distribution terms that you use for the rest of that program. # Originally written by Alexandre Oliva . case $1 in '') echo "$0: No command. Try '$0 --help' for more information." 1>&2 exit 1; ;; -h | --h*) cat <<\EOF Usage: depcomp [--help] [--version] PROGRAM [ARGS] Run PROGRAMS ARGS to compile a file, generating dependencies as side-effects. Environment variables: depmode Dependency tracking mode. source Source file read by 'PROGRAMS ARGS'. object Object file output by 'PROGRAMS ARGS'. DEPDIR directory where to store dependencies. depfile Dependency file to output. tmpdepfile Temporary file to use when outputting dependencies. libtool Whether libtool is used (yes/no). Report bugs to . EOF exit $? ;; -v | --v*) echo "depcomp $scriptversion" exit $? ;; esac # Get the directory component of the given path, and save it in the # global variables '$dir'. Note that this directory component will # be either empty or ending with a '/' character. This is deliberate. set_dir_from () { case $1 in */*) dir=`echo "$1" | sed -e 's|/[^/]*$|/|'`;; *) dir=;; esac } # Get the suffix-stripped basename of the given path, and save it the # global variable '$base'. set_base_from () { base=`echo "$1" | sed -e 's|^.*/||' -e 's/\.[^.]*$//'` } # If no dependency file was actually created by the compiler invocation, # we still have to create a dummy depfile, to avoid errors with the # Makefile "include basename.Plo" scheme. make_dummy_depfile () { echo "#dummy" > "$depfile" } # Factor out some common post-processing of the generated depfile. # Requires the auxiliary global variable '$tmpdepfile' to be set. aix_post_process_depfile () { # If the compiler actually managed to produce a dependency file, # post-process it. if test -f "$tmpdepfile"; then # Each line is of the form 'foo.o: dependency.h'. # Do two passes, one to just change these to # $object: dependency.h # and one to simply output # dependency.h: # which is needed to avoid the deleted-header problem. { sed -e "s,^.*\.[$lower]*:,$object:," < "$tmpdepfile" sed -e "s,^.*\.[$lower]*:[$tab ]*,," -e 's,$,:,' < "$tmpdepfile" } > "$depfile" rm -f "$tmpdepfile" else make_dummy_depfile fi } # A tabulation character. tab=' ' # A newline character. nl=' ' # Character ranges might be problematic outside the C locale. # These definitions help. upper=ABCDEFGHIJKLMNOPQRSTUVWXYZ lower=abcdefghijklmnopqrstuvwxyz digits=0123456789 alpha=${upper}${lower} if test -z "$depmode" || test -z "$source" || test -z "$object"; then echo "depcomp: Variables source, object and depmode must be set" 1>&2 exit 1 fi # Dependencies for sub/bar.o or sub/bar.obj go into sub/.deps/bar.Po. depfile=${depfile-`echo "$object" | sed 's|[^\\/]*$|'${DEPDIR-.deps}'/&|;s|\.\([^.]*\)$|.P\1|;s|Pobj$|Po|'`} tmpdepfile=${tmpdepfile-`echo "$depfile" | sed 's/\.\([^.]*\)$/.T\1/'`} rm -f "$tmpdepfile" # Avoid interferences from the environment. gccflag= dashmflag= # Some modes work just like other modes, but use different flags. We # parameterize here, but still list the modes in the big case below, # to make depend.m4 easier to write. Note that we *cannot* use a case # here, because this file can only contain one case statement. if test "$depmode" = hp; then # HP compiler uses -M and no extra arg. gccflag=-M depmode=gcc fi if test "$depmode" = dashXmstdout; then # This is just like dashmstdout with a different argument. dashmflag=-xM depmode=dashmstdout fi cygpath_u="cygpath -u -f -" if test "$depmode" = msvcmsys; then # This is just like msvisualcpp but w/o cygpath translation. # Just convert the backslash-escaped backslashes to single forward # slashes to satisfy depend.m4 cygpath_u='sed s,\\\\,/,g' depmode=msvisualcpp fi if test "$depmode" = msvc7msys; then # This is just like msvc7 but w/o cygpath translation. # Just convert the backslash-escaped backslashes to single forward # slashes to satisfy depend.m4 cygpath_u='sed s,\\\\,/,g' depmode=msvc7 fi if test "$depmode" = xlc; then # IBM C/C++ Compilers xlc/xlC can output gcc-like dependency information. gccflag=-qmakedep=gcc,-MF depmode=gcc fi case "$depmode" in gcc3) ## gcc 3 implements dependency tracking that does exactly what ## we want. Yay! Note: for some reason libtool 1.4 doesn't like ## it if -MD -MP comes after the -MF stuff. Hmm. ## Unfortunately, FreeBSD c89 acceptance of flags depends upon ## the command line argument order; so add the flags where they ## appear in depend2.am. Note that the slowdown incurred here ## affects only configure: in makefiles, %FASTDEP% shortcuts this. for arg do case $arg in -c) set fnord "$@" -MT "$object" -MD -MP -MF "$tmpdepfile" "$arg" ;; *) set fnord "$@" "$arg" ;; esac shift # fnord shift # $arg done "$@" stat=$? if test $stat -ne 0; then rm -f "$tmpdepfile" exit $stat fi mv "$tmpdepfile" "$depfile" ;; gcc) ## Note that this doesn't just cater to obsosete pre-3.x GCC compilers. ## but also to in-use compilers like IMB xlc/xlC and the HP C compiler. ## (see the conditional assignment to $gccflag above). ## There are various ways to get dependency output from gcc. Here's ## why we pick this rather obscure method: ## - Don't want to use -MD because we'd like the dependencies to end ## up in a subdir. Having to rename by hand is ugly. ## (We might end up doing this anyway to support other compilers.) ## - The DEPENDENCIES_OUTPUT environment variable makes gcc act like ## -MM, not -M (despite what the docs say). Also, it might not be ## supported by the other compilers which use the 'gcc' depmode. ## - Using -M directly means running the compiler twice (even worse ## than renaming). if test -z "$gccflag"; then gccflag=-MD, fi "$@" -Wp,"$gccflag$tmpdepfile" stat=$? if test $stat -ne 0; then rm -f "$tmpdepfile" exit $stat fi rm -f "$depfile" echo "$object : \\" > "$depfile" # The second -e expression handles DOS-style file names with drive # letters. sed -e 's/^[^:]*: / /' \ -e 's/^['$alpha']:\/[^:]*: / /' < "$tmpdepfile" >> "$depfile" ## This next piece of magic avoids the "deleted header file" problem. ## The problem is that when a header file which appears in a .P file ## is deleted, the dependency causes make to die (because there is ## typically no way to rebuild the header). We avoid this by adding ## dummy dependencies for each header file. Too bad gcc doesn't do ## this for us directly. ## Some versions of gcc put a space before the ':'. On the theory ## that the space means something, we add a space to the output as ## well. hp depmode also adds that space, but also prefixes the VPATH ## to the object. Take care to not repeat it in the output. ## Some versions of the HPUX 10.20 sed can't process this invocation ## correctly. Breaking it into two sed invocations is a workaround. tr ' ' "$nl" < "$tmpdepfile" \ | sed -e 's/^\\$//' -e '/^$/d' -e "s|.*$object$||" -e '/:$/d' \ | sed -e 's/$/ :/' >> "$depfile" rm -f "$tmpdepfile" ;; hp) # This case exists only to let depend.m4 do its work. It works by # looking at the text of this script. This case will never be run, # since it is checked for above. exit 1 ;; sgi) if test "$libtool" = yes; then "$@" "-Wp,-MDupdate,$tmpdepfile" else "$@" -MDupdate "$tmpdepfile" fi stat=$? if test $stat -ne 0; then rm -f "$tmpdepfile" exit $stat fi rm -f "$depfile" if test -f "$tmpdepfile"; then # yes, the sourcefile depend on other files echo "$object : \\" > "$depfile" # Clip off the initial element (the dependent). Don't try to be # clever and replace this with sed code, as IRIX sed won't handle # lines with more than a fixed number of characters (4096 in # IRIX 6.2 sed, 8192 in IRIX 6.5). We also remove comment lines; # the IRIX cc adds comments like '#:fec' to the end of the # dependency line. tr ' ' "$nl" < "$tmpdepfile" \ | sed -e 's/^.*\.o://' -e 's/#.*$//' -e '/^$/ d' \ | tr "$nl" ' ' >> "$depfile" echo >> "$depfile" # The second pass generates a dummy entry for each header file. tr ' ' "$nl" < "$tmpdepfile" \ | sed -e 's/^.*\.o://' -e 's/#.*$//' -e '/^$/ d' -e 's/$/:/' \ >> "$depfile" else make_dummy_depfile fi rm -f "$tmpdepfile" ;; xlc) # This case exists only to let depend.m4 do its work. It works by # looking at the text of this script. This case will never be run, # since it is checked for above. exit 1 ;; aix) # The C for AIX Compiler uses -M and outputs the dependencies # in a .u file. In older versions, this file always lives in the # current directory. Also, the AIX compiler puts '$object:' at the # start of each line; $object doesn't have directory information. # Version 6 uses the directory in both cases. set_dir_from "$object" set_base_from "$object" if test "$libtool" = yes; then tmpdepfile1=$dir$base.u tmpdepfile2=$base.u tmpdepfile3=$dir.libs/$base.u "$@" -Wc,-M else tmpdepfile1=$dir$base.u tmpdepfile2=$dir$base.u tmpdepfile3=$dir$base.u "$@" -M fi stat=$? if test $stat -ne 0; then rm -f "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3" exit $stat fi for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3" do test -f "$tmpdepfile" && break done aix_post_process_depfile ;; tcc) # tcc (Tiny C Compiler) understand '-MD -MF file' since version 0.9.26 # FIXME: That version still under development at the moment of writing. # Make that this statement remains true also for stable, released # versions. # It will wrap lines (doesn't matter whether long or short) with a # trailing '\', as in: # # foo.o : \ # foo.c \ # foo.h \ # # It will put a trailing '\' even on the last line, and will use leading # spaces rather than leading tabs (at least since its commit 0394caf7 # "Emit spaces for -MD"). "$@" -MD -MF "$tmpdepfile" stat=$? if test $stat -ne 0; then rm -f "$tmpdepfile" exit $stat fi rm -f "$depfile" # Each non-empty line is of the form 'foo.o : \' or ' dep.h \'. # We have to change lines of the first kind to '$object: \'. sed -e "s|.*:|$object :|" < "$tmpdepfile" > "$depfile" # And for each line of the second kind, we have to emit a 'dep.h:' # dummy dependency, to avoid the deleted-header problem. sed -n -e 's|^ *\(.*\) *\\$|\1:|p' < "$tmpdepfile" >> "$depfile" rm -f "$tmpdepfile" ;; ## The order of this option in the case statement is important, since the ## shell code in configure will try each of these formats in the order ## listed in this file. A plain '-MD' option would be understood by many ## compilers, so we must ensure this comes after the gcc and icc options. pgcc) # Portland's C compiler understands '-MD'. # Will always output deps to 'file.d' where file is the root name of the # source file under compilation, even if file resides in a subdirectory. # The object file name does not affect the name of the '.d' file. # pgcc 10.2 will output # foo.o: sub/foo.c sub/foo.h # and will wrap long lines using '\' : # foo.o: sub/foo.c ... \ # sub/foo.h ... \ # ... set_dir_from "$object" # Use the source, not the object, to determine the base name, since # that's sadly what pgcc will do too. set_base_from "$source" tmpdepfile=$base.d # For projects that build the same source file twice into different object # files, the pgcc approach of using the *source* file root name can cause # problems in parallel builds. Use a locking strategy to avoid stomping on # the same $tmpdepfile. lockdir=$base.d-lock trap " echo '$0: caught signal, cleaning up...' >&2 rmdir '$lockdir' exit 1 " 1 2 13 15 numtries=100 i=$numtries while test $i -gt 0; do # mkdir is a portable test-and-set. if mkdir "$lockdir" 2>/dev/null; then # This process acquired the lock. "$@" -MD stat=$? # Release the lock. rmdir "$lockdir" break else # If the lock is being held by a different process, wait # until the winning process is done or we timeout. while test -d "$lockdir" && test $i -gt 0; do sleep 1 i=`expr $i - 1` done fi i=`expr $i - 1` done trap - 1 2 13 15 if test $i -le 0; then echo "$0: failed to acquire lock after $numtries attempts" >&2 echo "$0: check lockdir '$lockdir'" >&2 exit 1 fi if test $stat -ne 0; then rm -f "$tmpdepfile" exit $stat fi rm -f "$depfile" # Each line is of the form `foo.o: dependent.h', # or `foo.o: dep1.h dep2.h \', or ` dep3.h dep4.h \'. # Do two passes, one to just change these to # `$object: dependent.h' and one to simply `dependent.h:'. sed "s,^[^:]*:,$object :," < "$tmpdepfile" > "$depfile" # Some versions of the HPUX 10.20 sed can't process this invocation # correctly. Breaking it into two sed invocations is a workaround. sed 's,^[^:]*: \(.*\)$,\1,;s/^\\$//;/^$/d;/:$/d' < "$tmpdepfile" \ | sed -e 's/$/ :/' >> "$depfile" rm -f "$tmpdepfile" ;; hp2) # The "hp" stanza above does not work with aCC (C++) and HP's ia64 # compilers, which have integrated preprocessors. The correct option # to use with these is +Maked; it writes dependencies to a file named # 'foo.d', which lands next to the object file, wherever that # happens to be. # Much of this is similar to the tru64 case; see comments there. set_dir_from "$object" set_base_from "$object" if test "$libtool" = yes; then tmpdepfile1=$dir$base.d tmpdepfile2=$dir.libs/$base.d "$@" -Wc,+Maked else tmpdepfile1=$dir$base.d tmpdepfile2=$dir$base.d "$@" +Maked fi stat=$? if test $stat -ne 0; then rm -f "$tmpdepfile1" "$tmpdepfile2" exit $stat fi for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2" do test -f "$tmpdepfile" && break done if test -f "$tmpdepfile"; then sed -e "s,^.*\.[$lower]*:,$object:," "$tmpdepfile" > "$depfile" # Add 'dependent.h:' lines. sed -ne '2,${ s/^ *// s/ \\*$// s/$/:/ p }' "$tmpdepfile" >> "$depfile" else make_dummy_depfile fi rm -f "$tmpdepfile" "$tmpdepfile2" ;; tru64) # The Tru64 compiler uses -MD to generate dependencies as a side # effect. 'cc -MD -o foo.o ...' puts the dependencies into 'foo.o.d'. # At least on Alpha/Redhat 6.1, Compaq CCC V6.2-504 seems to put # dependencies in 'foo.d' instead, so we check for that too. # Subdirectories are respected. set_dir_from "$object" set_base_from "$object" if test "$libtool" = yes; then # Libtool generates 2 separate objects for the 2 libraries. These # two compilations output dependencies in $dir.libs/$base.o.d and # in $dir$base.o.d. We have to check for both files, because # one of the two compilations can be disabled. We should prefer # $dir$base.o.d over $dir.libs/$base.o.d because the latter is # automatically cleaned when .libs/ is deleted, while ignoring # the former would cause a distcleancheck panic. tmpdepfile1=$dir$base.o.d # libtool 1.5 tmpdepfile2=$dir.libs/$base.o.d # Likewise. tmpdepfile3=$dir.libs/$base.d # Compaq CCC V6.2-504 "$@" -Wc,-MD else tmpdepfile1=$dir$base.d tmpdepfile2=$dir$base.d tmpdepfile3=$dir$base.d "$@" -MD fi stat=$? if test $stat -ne 0; then rm -f "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3" exit $stat fi for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3" do test -f "$tmpdepfile" && break done # Same post-processing that is required for AIX mode. aix_post_process_depfile ;; msvc7) if test "$libtool" = yes; then showIncludes=-Wc,-showIncludes else showIncludes=-showIncludes fi "$@" $showIncludes > "$tmpdepfile" stat=$? grep -v '^Note: including file: ' "$tmpdepfile" if test $stat -ne 0; then rm -f "$tmpdepfile" exit $stat fi rm -f "$depfile" echo "$object : \\" > "$depfile" # The first sed program below extracts the file names and escapes # backslashes for cygpath. The second sed program outputs the file # name when reading, but also accumulates all include files in the # hold buffer in order to output them again at the end. This only # works with sed implementations that can handle large buffers. sed < "$tmpdepfile" -n ' /^Note: including file: *\(.*\)/ { s//\1/ s/\\/\\\\/g p }' | $cygpath_u | sort -u | sed -n ' s/ /\\ /g s/\(.*\)/'"$tab"'\1 \\/p s/.\(.*\) \\/\1:/ H $ { s/.*/'"$tab"'/ G p }' >> "$depfile" echo >> "$depfile" # make sure the fragment doesn't end with a backslash rm -f "$tmpdepfile" ;; msvc7msys) # This case exists only to let depend.m4 do its work. It works by # looking at the text of this script. This case will never be run, # since it is checked for above. exit 1 ;; #nosideeffect) # This comment above is used by automake to tell side-effect # dependency tracking mechanisms from slower ones. dashmstdout) # Important note: in order to support this mode, a compiler *must* # always write the preprocessed file to stdout, regardless of -o. "$@" || exit $? # Remove the call to Libtool. if test "$libtool" = yes; then while test "X$1" != 'X--mode=compile'; do shift done shift fi # Remove '-o $object'. IFS=" " for arg do case $arg in -o) shift ;; $object) shift ;; *) set fnord "$@" "$arg" shift # fnord shift # $arg ;; esac done test -z "$dashmflag" && dashmflag=-M # Require at least two characters before searching for ':' # in the target name. This is to cope with DOS-style filenames: # a dependency such as 'c:/foo/bar' could be seen as target 'c' otherwise. "$@" $dashmflag | sed "s|^[$tab ]*[^:$tab ][^:][^:]*:[$tab ]*|$object: |" > "$tmpdepfile" rm -f "$depfile" cat < "$tmpdepfile" > "$depfile" # Some versions of the HPUX 10.20 sed can't process this sed invocation # correctly. Breaking it into two sed invocations is a workaround. tr ' ' "$nl" < "$tmpdepfile" \ | sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' \ | sed -e 's/$/ :/' >> "$depfile" rm -f "$tmpdepfile" ;; dashXmstdout) # This case only exists to satisfy depend.m4. It is never actually # run, as this mode is specially recognized in the preamble. exit 1 ;; makedepend) "$@" || exit $? # Remove any Libtool call if test "$libtool" = yes; then while test "X$1" != 'X--mode=compile'; do shift done shift fi # X makedepend shift cleared=no eat=no for arg do case $cleared in no) set ""; shift cleared=yes ;; esac if test $eat = yes; then eat=no continue fi case "$arg" in -D*|-I*) set fnord "$@" "$arg"; shift ;; # Strip any option that makedepend may not understand. Remove # the object too, otherwise makedepend will parse it as a source file. -arch) eat=yes ;; -*|$object) ;; *) set fnord "$@" "$arg"; shift ;; esac done obj_suffix=`echo "$object" | sed 's/^.*\././'` touch "$tmpdepfile" ${MAKEDEPEND-makedepend} -o"$obj_suffix" -f"$tmpdepfile" "$@" rm -f "$depfile" # makedepend may prepend the VPATH from the source file name to the object. # No need to regex-escape $object, excess matching of '.' is harmless. sed "s|^.*\($object *:\)|\1|" "$tmpdepfile" > "$depfile" # Some versions of the HPUX 10.20 sed can't process the last invocation # correctly. Breaking it into two sed invocations is a workaround. sed '1,2d' "$tmpdepfile" \ | tr ' ' "$nl" \ | sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' \ | sed -e 's/$/ :/' >> "$depfile" rm -f "$tmpdepfile" "$tmpdepfile".bak ;; cpp) # Important note: in order to support this mode, a compiler *must* # always write the preprocessed file to stdout. "$@" || exit $? # Remove the call to Libtool. if test "$libtool" = yes; then while test "X$1" != 'X--mode=compile'; do shift done shift fi # Remove '-o $object'. IFS=" " for arg do case $arg in -o) shift ;; $object) shift ;; *) set fnord "$@" "$arg" shift # fnord shift # $arg ;; esac done "$@" -E \ | sed -n -e '/^# [0-9][0-9]* "\([^"]*\)".*/ s:: \1 \\:p' \ -e '/^#line [0-9][0-9]* "\([^"]*\)".*/ s:: \1 \\:p' \ | sed '$ s: \\$::' > "$tmpdepfile" rm -f "$depfile" echo "$object : \\" > "$depfile" cat < "$tmpdepfile" >> "$depfile" sed < "$tmpdepfile" '/^$/d;s/^ //;s/ \\$//;s/$/ :/' >> "$depfile" rm -f "$tmpdepfile" ;; msvisualcpp) # Important note: in order to support this mode, a compiler *must* # always write the preprocessed file to stdout. "$@" || exit $? # Remove the call to Libtool. if test "$libtool" = yes; then while test "X$1" != 'X--mode=compile'; do shift done shift fi IFS=" " for arg do case "$arg" in -o) shift ;; $object) shift ;; "-Gm"|"/Gm"|"-Gi"|"/Gi"|"-ZI"|"/ZI") set fnord "$@" shift shift ;; *) set fnord "$@" "$arg" shift shift ;; esac done "$@" -E 2>/dev/null | sed -n '/^#line [0-9][0-9]* "\([^"]*\)"/ s::\1:p' | $cygpath_u | sort -u > "$tmpdepfile" rm -f "$depfile" echo "$object : \\" > "$depfile" sed < "$tmpdepfile" -n -e 's% %\\ %g' -e '/^\(.*\)$/ s::'"$tab"'\1 \\:p' >> "$depfile" echo "$tab" >> "$depfile" sed < "$tmpdepfile" -n -e 's% %\\ %g' -e '/^\(.*\)$/ s::\1\::p' >> "$depfile" rm -f "$tmpdepfile" ;; msvcmsys) # This case exists only to let depend.m4 do its work. It works by # looking at the text of this script. This case will never be run, # since it is checked for above. exit 1 ;; none) exec "$@" ;; *) echo "Unknown depmode $depmode" 1>&2 exit 1 ;; esac exit 0 # Local Variables: # mode: shell-script # sh-indentation: 2 # eval: (add-hook 'write-file-hooks 'time-stamp) # time-stamp-start: "scriptversion=" # time-stamp-format: "%:y-%02m-%02d.%02H" # time-stamp-time-zone: "UTC" # time-stamp-end: "; # UTC" # End: ecl-16.1.2/src/bdwgc/digimars.mak000066400000000000000000000037331266352375300165340ustar00rootroot00000000000000# Makefile to build Hans Boehm garbage collector using the Digital Mars # compiler from www.digitalmars.com # Written by Walter Bright DEFINES=-DNDEBUG -D_WINDOWS -DGC_DLL -DALL_INTERIOR_POINTERS -DWIN32_THREADS CFLAGS=-Iinclude $(DEFINES) -wx -g LFLAGS=/ma/implib/co CC=sc .c.obj: $(CC) -c $(CFLAGS) $* .cpp.obj: $(CC) -c $(CFLAGS) -Aa $* OBJS= \ allchblk.obj\ alloc.obj\ blacklst.obj\ checksums.obj\ dbg_mlc.obj\ fnlz_mlc.obj\ dyn_load.obj\ finalize.obj\ gc_cpp.obj\ headers.obj\ mach_dep.obj\ malloc.obj\ mallocx.obj\ mark.obj\ mark_rts.obj\ misc.obj\ new_hblk.obj\ obj_map.obj\ os_dep.obj\ ptr_chck.obj\ reclaim.obj\ stubborn.obj\ typd_mlc.obj\ win32_threads.obj targets: gc.dll gc.lib gctest.exe gc.dll: $(OBJS) gc.def digimars.mak sc -ogc.dll $(OBJS) -L$(LFLAGS) gc.def kernel32.lib user32.lib gc.def: digimars.mak echo LIBRARY GC >gc.def echo DESCRIPTION "Hans Boehm Garbage Collector" >>gc.def echo EXETYPE NT >>gc.def echo EXPORTS >>gc.def echo GC_is_visible_print_proc >>gc.def echo GC_is_valid_displacement_print_proc >>gc.def clean: del gc.def del $(OBJS) gctest.exe : gc.lib tests\test.obj sc -ogctest.exe tests\test.obj gc.lib tests\test.obj : tests\test.c $(CC) -c -g -DNDEBUG -D_WINDOWS -DGC_DLL \ -DALL_INTERIOR_POINTERS -DWIN32_THREADS \ -Iinclude tests\test.c -otests\test.obj allchblk.obj: allchblk.c alloc.obj: alloc.c blacklst.obj: blacklst.c checksums.obj: checksums.c dbg_mlc.obj: dbg_mlc.c dyn_load.obj: dyn_load.c finalize.obj: finalize.c fnlz_mlc.obj: fnlz_mlc.c gc_cpp.obj: gc_cpp.cpp headers.obj: headers.c mach_dep.obj: mach_dep.c malloc.obj: malloc.c mallocx.obj: mallocx.c mark.obj: mark.c mark_rts.obj: mark_rts.c misc.obj: misc.c new_hblk.obj: new_hblk.c obj_map.obj: obj_map.c os_dep.obj: os_dep.c ptr_chck.obj: ptr_chck.c reclaim.obj: reclaim.c stubborn.obj: stubborn.c typd_mlc.obj: typd_mlc.c win32_threads.obj: win32_threads.c ecl-16.1.2/src/bdwgc/doc/000077500000000000000000000000001266352375300150025ustar00rootroot00000000000000ecl-16.1.2/src/bdwgc/doc/README.DGUX386000066400000000000000000000031351266352375300166730ustar00rootroot00000000000000 Garbage Collector (parallel iversion) for ix86 DG/UX Release R4.20MU07 *READ* the file README.QUICK. You need the GCC-3.0.3 rev (DG/UX) compiler to build this tree. This compiler has the new "dgux386" threads package implemented. It also supports the switch "-pthread" needed to link correctly the DG/UX's -lrte -lthread with -lgcc and the system's -lc. Finally we support parralleli-mark for the SMP DG/UX machines. To build the garbage collector do: ./configure --enable-parallel-mark make make gctest Before you run "gctest" you need to set your LD_LIBRARY_PATH correctly so that "gctest" can find the shared library libgc. Alternatively you can do a configuration ./configure --enable-parallel-mark --disable-shared to build only the static version of libgc. To enable debugging messages please do: 1) Add the "--enable-gc-debug" flag during configuration. 2) Edit the file linux-threads.c and uncomment the line: /* #define DEBUG_THREADS 1 */ to ---> #define DEBUG_THREADS 1 Then give "make" as usual. In a machine with 4 CPUs (my own machine) the option parallel mark (aka --enable-parallel-mark) makes a BIG difference. Takis Psarogiannakopoulos Note (HB): The integration of this patch is currently not complete. The following patches against 6.1alpha3 where hard to move to alpha4, and are not integrated. There may also be minor problems with stylistic corrections made by me. [The diff for ltconfig and ltmain.sh was removed from this file on 2011-08-22] ecl-16.1.2/src/bdwgc/doc/README.Mac000066400000000000000000000304261266352375300163660ustar00rootroot00000000000000The contents of this file are old and pertain to pre-MacOSX versions. You probably really wanted README.darwin. --------------------------------------------- Patrick Beard's Notes for building GC v4.12 with CodeWarrior Pro 2: ---------------------------------------------------------------------------- The current build environment for the collector is CodeWarrior Pro 2. Projects for CodeWarrior Pro 2 (and for quite a few older versions) are distributed in the file Mac_projects.sit.hqx. The project file :Mac_projects:gc.prj builds static library versions of the collector. :Mac_projects:gctest.prj builds the GC test suite. Configuring the collector is still done by editing the file :extra:Mac_files:MacOS_config.h. Lars Farm's suggestions on building the collector: ---------------------------------------------------------------------------- Garbage Collection on MacOS - a manual 'MakeFile' ------------------------------------------------- Project files and IDE's are great on the Macintosh, but they do have problems when used as distribution media. This note tries to provide porting instructions in pure TEXT form to avoid those problems. A manual 'makefile' if you like. GC version: 4.12a2 Codewarrior: CWPro1 date: 18 July 1997 The notes may or may not apply to earlier or later versions of the GC/CWPro. Actually, they do apply to earlier versions of both except that until recently a project could only build one target so each target was a separate project. The notes will most likely apply to future versions too. Possibly with minor tweaks. This is just to record my experiences. These notes do not mean I now provide a supported port of the GC to MacOS. It works for me. If it works for you, great. If it doesn't, sorry, try again...;-) Still, if you find errors, please let me know. Porting to MacOS is a bit more complex than it first seems. Which MacOS? 68K/PowerPC? Which compiler? Each supports both 68K and PowerPC and offer a large number of (unique to each environment) compiler settings. Each combination of compiler/68K/PPC/settings require a unique combination of standard libraries. And the IDE's does not select them for you. They don't even check that the library is built with compatible setting and this is the major source of problems when porting the GC (and otherwise too). You will have to make choices when you configure the GC. I've made some choices here, but there are other combinations of settings and #defines that work too. As for target settings the major obstacles may be: - 68K Processor: check "4-byte Ints". - PPC Processor: uncheck "Store Static Data in TOC". What you need to do: 1) Build the GC as a library 2) Test that the library works with 'test.c'. 3) Test that the C++ interface 'gc_cpp.cc/h' works with 'test_cpp.cc'. == 1. The Libraries == I made one project with four targets (68K/PPC tempmem or appheap). One target will suffice if you're able to decide which one you want. I wasn't... Codewarrior allows a large number of compiler/linker settings. I used these: Settings shared by all targets: ------------------------------ o Access Paths: - User Paths: the GC folder - System Paths: {Compiler}:Metrowerks Standard Library: {Compiler}:MacOS Support:Headers: {Compiler}:MacOS Support:MacHeaders: o C/C++ language: - inlining: normal - direct to SOM: off - enable/check: exceptions, RTTI, bool (and if you like pool strings) PowerPC target settings ----------------------- o Target Settings: - name of target - MacOS PPC Linker o PPC Target - name of library o C/C++ language - prefix file as described below o PPC Processor - Struct Alignment: PowerPC - uncheck "Store Static Data in TOC" -- important! I don't think the others matter, I use full optimization and it is OK o PPC Linker - Factory Settings (SYM file with full paths, faster linking, dead-strip static init, Main: __start) 68K target settings ------------------- o Target Settings: - name of target - MacOS 68K Linker o 68K Target - name of library - A5 relative data o C/C++ language - prefix file as described below o 68K Processor - Code model: smart - Struct alignment: 68K - FP: SANE - enable 4-Byte Ints -- important! I don't think the others matter. I selected... - enable: 68020 - enable: global register allocation o IR Optimizer - enable: Optimize Space, Optimize Speed I suppose the others would work too, but haven't tried... o 68K Linker - Factory Settings (New Style MacsBug, SYM file with full paths, A6 Frames, fast link, Merge compiler glue into segment 1, dead-strip static init) Prefix Files to configure the GC sources ---------------------------------------- The Codewarrior equivalent of commandline compilers -DNAME=X is to use prefix-files. A TEXT file that is automatically #included before the first byte of every source file. I used these: ---- ( cut here ) ---- gc_prefix_tempmem.h -- 68K and PPC ----- #include "gc_prefix_common.h" #undef USE_TEMPORARY_MEMORY #define USE_TEMPORARY_MEMORY ---- ( cut here ) ---- gc_prefix_appmem.h -- 68K and PPC ----- #include "gc_prefix_common.h" #undef USE_TEMPORARY_MEMORY // #define USE_TEMPORARY_MEMORY ---- ( cut here ) ---- gc_prefix_common.h -------------------- // gc_prefix_common.h // ------------------ // Codewarrior prefix file to configure the GC libraries // // prefix files are the Codewarrior equivalent of the // command line option -Dname=x frequently seen in makefiles #if !__MWERKS__ #error only tried this with Codewarrior #endif #if macintosh #define MSL_USE_PRECOMPILED_HEADERS 0 #include // See list of #defines to configure the library in: 'MakeFile' // see also README #define ALL_INTERIOR_POINTERS // follows interior pointers. //#define DONT_ADD_BYTE_AT_END // disables the padding if defined. //#define SMALL_CONFIG // whether to use a smaller heap. #define ATOMIC_UNCOLLECTABLE // GC_malloc_atomic_uncollectable() // define either or none as per personal preference // used in malloc.c #define REDIRECT_MALLOC GC_malloc //#define REDIRECT_MALLOC GC_malloc_uncollectable // if REDIRECT_MALLOC is #defined make sure that the GC library // is listed before the ANSI/ISO libs in the Codewarrior // 'Link order' panel //#define IGNORE_FREE // mac specific configs //#define USE_TEMPORARY_MEMORY // use Macintosh temporary memory. //#define SHARED_LIBRARY_BUILD // build for use in a shared library. #else // could build Win32 here too, or in the future // Rhapsody PPC-mach, Rhapsody PPC-MacOS, // Rhapsody Intel-mach, Rhapsody Intel-Win32,... // ... ugh this will get messy ... #endif // make sure ints are at least 32-bit // ( could be set to 16-bit by compiler settings (68K) ) struct gc_private_assert_intsize_{ char x[ sizeof(int)>=4 ? 1 : 0 ]; }; #if __powerc #if __option(toc_data) #error turn off "store static data in TOC" when using GC // ... or find a way to add TOC to the root set...(?) #endif #endif ---- ( cut here ) ---- end of gc_prefix_common.h ----------------- Files to build the GC libraries: -------------------------------- allchblk.c alloc.c blacklst.c checksums.c dbg_mlc.c finalize.c headers.c mach_dep.c MacOS.c -- contains MacOS code malloc.c mallocx.c mark.c mark_rts.c misc.c new_hblk.c obj_map.c os_dep.c -- contains MacOS code ptr_chck.c reclaim.c stubborn.c typd_mlc.c gc++.cc -- this is 'gc_cpp.cc' with less 'inline' and -- throw std::bad_alloc when out of memory -- gc_cpp.cc works just fine too == 2. Test that the library works with 'test.c' == The test app is just an ordinary ANSI-C console app. Make sure settings match the library you're testing. Files ----- test.c the GC library to test -- link order before ANSI libs suitable Mac+ANSI libraries prefix: ------ ---- ( cut here ) ---- gc_prefix_testlib.h -- all libs ----- #define MSL_USE_PRECOMPILED_HEADERS 0 #include #undef NDEBUG #define ALL_INTERIOR_POINTERS /* for GC_priv.h */ ---- ( cut here ) ---- == 3. Test that the C++ interface 'gc_cpp.cc/h' works with 'test_cpp.cc' == The test app is just an ordinary ANSI-C console app. Make sure settings match the library you're testing. Files ----- test_cpp.cc the GC library to test -- link order before ANSI libs suitable Mac+ANSI libraries prefix: ------ same as for test.c For convenience I used one test-project with several targets so that all test apps are build at once. Two for each library to test: test.c and gc_app.cc. When I was satisfied that the libraries were OK. I put the libraries + gc.h + the c++ interface-file in a folder that I then put into the MSL hierarchy so that I don't have to alter access-paths in projects that use the GC. After that, just add the proper GC library to your project and the GC is in action! malloc will call GC_malloc and free GC_free, new/delete too. You don't have to call free or delete. You may have to be a bit cautious about delete if you're freeing other resources than RAM. See gc_cpp.h. You can also keep coding as always with delete/free. That works too. If you want, "include and tweak it's use a bit. == Symantec SPM == It has been a while since I tried the GC in SPM, but I think that the above instructions should be sufficient to guide you through in SPM too. SPM needs to know where the global data is. Use the files 'datastart.c' and 'dataend.c'. Put 'datastart.c' at the top of your project and 'dataend.c' at the bottom of your project so that all data is surrounded. This is not needed in Codewarrior because it provides intrinsic variables __datastart__, __data_end__ that wraps all globals. == Source Changes (GC 4.12a2) == Very few. Just one tiny in the GC, not strictly needed. - test_cpp.cc made the first lines of main() look like this: ------------ int main( int argc, char* argv[] ) { #endif #if macintosh // MacOS char* argv_[] = {"test_cpp","10"}; // doesn't argv=argv_; // have a argc = sizeof(argv_)/sizeof(argv_[0]); // commandline #endif // int i, iters, n; # ifndef __GNUC__ alloc dummy_to_fool_the_compiler_into_doing_things_it_currently_cant_handle; ------------ - config.h [now gcconfig.h] __MWERKS__ does not have to mean MACOS. You can use Codewarrior to build a Win32 or BeOS library and soon a Rhapsody library. You may have to change that #if... It worked for me, hope it works for you. Lars Farm ---------------------------------------------------------------------------- Patrick Beard's instructions (may be dated): v4.3 of the collector now runs under Symantec C++/THINK C v7.0.4, and Metrowerks C/C++ v4.5 both 68K and PowerPC. Project files are provided to build and test the collector under both development systems. Configuration ------------- To configure the collector, under both development systems, a prefix file is used to set preprocessor directives. This file is called "MacOS_config.h". Testing ------- To test the collector (always a good idea), build one of the gctest projects, gctest. (Symantec C++/THINK C), mw/gctest.68K, or mw/gctest.PPC. The test will ask you how many times to run; 1 should be sufficient. Building -------- For your convenience project files for the major Macintosh development systems are provided. For Symantec C++/THINK C, you must build the two projects gclib-1 and gclib-2. It has to be split up because the collector has more than 32k of static data and no library can have more than this in the Symantec environment. (Future versions will probably fix this.) For Metrowerks C/C++ 4.5 you build gc.68K/PPC and the result will be a library called gc.68K.lib/gc.PPC.lib. Using ----- Under Symantec C++/THINK C, you can just add the gclib-1 and gclib-2 projects to your own project. Under Metrowerks, you add gc.68K.lib or gc.PPC.lib and two additional files. You add the files called datastart.c and dataend.c to your project, bracketing all files that use the collector. See mw/gctest for an example. Include the projects/libraries you built above into your own project, #include "gc.h", and call GC_malloc. You don't have to call GC_free. Patrick C. Beard ecl-16.1.2/src/bdwgc/doc/README.OS2000066400000000000000000000005551266352375300162710ustar00rootroot00000000000000The code assumes static linking, and a single thread. The editor de has not been ported. The cord test program has. The supplied OS2_MAKEFILE assumes the IBM C Set/2 environment, but the code shouldn't. Since we haven't figured out hoe to do perform partial links or to build static libraries, clients currently need to link against a long list of executables. ecl-16.1.2/src/bdwgc/doc/README.amiga000066400000000000000000000301531266352375300167410ustar00rootroot00000000000000 Kjetil S. Matheussen's notes (28-11-2000) Compiles under SAS/C again. Should also still compile under other Amiga compilers without big changes. I haven't checked if it still works under gcc, because I don't have gcc for Amiga. But I have updated 'Makefile', and hope it compiles fine. WHATS NEW: 1. Made a pretty big effort in preventing GCs allocating-functions from returning chip-mem. The lower part of the new file AmigaOS.c does this in various ways, mainly by wrapping GC_malloc, GC_malloc_atomic, GC_malloc_uncollectable, GC_malloc_atomic_uncollectable, GC_malloc_stubborn, GC_malloc_ignore_off_page and GC_malloc_atomic_ignore_off_page. GC_realloc is also wrapped, but doesn't do the same effort in preventing to return chip-mem. Other allocating-functions (f.ex. GC_*_typed_) can probably be used without any problems, but beware that the warn hook will not be called. In case of problems, don't define GC_AMIGA_FASTALLOC. Programs using more time actually using the memory allocated (instead of just allocate and free rapidly) have the most to earn on this, but even gctest now normally runs twice as fast and uses less memory, on my poor 8MB machine. The changes have only effect when there is no more fast-mem left. But with the way GC works, it could happen quite often. Beware that an atexit handler had to be added, so using the abort() function will make a big memory-loss. If you absolutely must call abort() instead of exit(), try calling the GC_amiga_free_all_mem function before abort(). New Amiga-specific compilation flags: GC_AMIGA_FASTALLOC - By NOT defining this option, GC will work like before, it will not try to force fast-mem out of the OS, and it will use normal calloc for allocation, and the rest of the following flags will have no effect. GC_AMIGA_ONLYFAST - Makes GC never to return chip-mem. GC_AMIGA_RETRY have no effect if this flag is set. GC_AMIGA_GC - If gc returns NULL, do a GC_gcollect, and try again. This usually is a success with the standard GC configuration. It is also the most important flag to set to prevent GC from returning chip-mem. Beware that it slows down a lot when a program is rapidly allocating/deallocating when theres either very little fast-memory left or verly little chip-memory left. Its not a very common situation, but gctest sometimes (very rare) use many minutes because of this. GC_AMIGA_RETRY - If gc succeed allocating memory, but it is chip-mem, try again and see if it is fast-mem. Most of the time, it will actually return fast-mem for the second try. I have set max number of retries to 9 or size/5000. You can change this if you like. (see GC_amiga_rec_alloc()) GC_AMIGA_PRINTSTATS - Gather some statistics during the execution of a program, and prints out the info when the atexit-handler is called. My reccomendation is to set all this flags, except GC_AMIGA_PRINTSTATS and GC_AMIGA_ONLYFAST. If your program demands high response-time, you should not define GC_AMIGA_GC, and possible also define GC_AMIGA_ONLYFAST. GC_AMIGA_RETRY does not seem to slow down much. Also, when compiling up programs, and GC_AMIGA_FASTALLOC was not defined when compilling gc, you can define GC_AMIGA_MAKINGLIB to avoid having these allocation- functions wrapped. (see gc.h) Note that GC_realloc must not be called before any of the other above mentioned allocating-functions have been called. (shouldn't be any programs doing so either, I hope). Another note. The allocation-function is wrapped when defining GC_AMIGA_FASTALLOC by letting the function go thru the new GC_amiga_allocwrapper_do function-pointer (see gc.h). Means that sending function-pointers, such as GC_malloc, GC_malloc_atomic, etc., for later to be called like f.ex this, (*GC_malloc_function_pointer)(size), will not wrap the function. This is normally not a big problem, unless all allocation function is called like this, which will cause the atexit un-allocating function never to be called. Then you either have to manually add the atexit handler, or call the allocation- functions function-pointer functions like this; (*GC_amiga_allocwrapper_do)(size,GC_malloc_function_pointer). There are probably better ways this problem could be handled, unfortunately, I didn't find any without rewriting or replacing a lot of the GC-code, which I really didn't want to. (Making new GC_malloc_* functions, and just define f.ex GC_malloc as GC_amiga_malloc should work too). New Amiga-specific function: void GC_amiga_set_toany(void (*func)(void)); 'func' is a function that will be called right before gc has to change allocation-method from MEMF_FAST to MEMF_ANY. Ie. when it is likely it will return chip-mem. 2. A few small compiler-specific additions to make it compile with SAS/C again. 3. Updated and rewritten the smakefile, so that it works again and that the "unnecessary" 'SCOPTIONS' files could be removed. Also included the cord-smakefile stuff in the main smakefile, so that the cord smakefile could be removed too. By writing smake -f Smakefile.smk, both gc.lib and cord.lib will be made. STILL MISSING: Programs can not be started from workbench, at least not for SAS/C. (Martin Tauchmanns note about that it now works with workbench is definitely wrong when concerning SAS/C). An iconx-script solves this problem. BEWARE! -To run gctest, set the stack to around 200000 bytes first. -SAS/C-specific: cord will crash if you compile gc.lib with either parm=reg or parm=both. (missing legal prototypes for function-pointers someplace is the reason I guess.). tested with software: Radium, http://www.stud.ifi.uio.no/~ksvalast/radium/ tested with hardware: MC68060 Martin Tauchmann's notes (1-Apr-99) Works now, also with the GNU-C compiler V2.7.2.1. Modify the `Makefile` CC=cc $(ABI_FLAG) to CC=gcc $(ABI_FLAG) TECHNICAL NOTES - `GC_get_stack_base()`, `GC_register_data_segments()` works now with every C compiler; also Workbench. - Removed AMIGA_SKIP_SEG, but the Code-Segment must not be scanned by GC. PROBLEMS - When the Linker, does`t merge all Code-Segments to an single one. LD of GCC do it always. - With ixemul.library V47.3, when an GC program launched from another program (example: `Make` or `if_mach M68K AMIGA gctest`), `GC_register_data_segments()` found the Segment-List of the caller program. Can be fixed, if the run-time initialization code (for C programs, usually *crt0*) support `__data` and `__bss`. - PowerPC Amiga currently not supported. - Dynamic libraries (dyn_load.c) not supported. TESTED WITH SOFTWARE `Optimized Oberon 2 C` (oo2c) TESTED WITH HARDWARE MC68030 Michel Schinz's notes WHO DID WHAT The original Amiga port was made by Jesper Peterson. I (Michel Schinz) modified it slightly to reflect the changes made in the new official distributions, and to take advantage of the new SAS/C 6.x features. I also created a makefile to compile the "cord" package (see the cord subdirectory). TECHNICAL NOTES In addition to Jesper's notes, I have the following to say: - Starting with version 4.3, gctest checks to see if the code segment is added to the root set or not, and complains if it is. Previous versions of this Amiga port added the code segment to the root set, so I tried to fix that. The only problem is that, as far as I know, it is impossible to know which segments are code segments and which are data segments (there are indeed solutions to this problem, like scanning the program on disk or patch the LoadSeg functions, but they are rather complicated). The solution I have chosen (see os_dep.c) is to test whether the program counter is in the segment we are about to add to the root set, and if it is, to skip the segment. The problems are that this solution is rather awkward and that it works only for one code segment. This means that if your program has more than one code segment, all of them but one will be added to the root set. This isn't a big problem in fact, since the collector will continue to work correctly, but it may be slower. Anyway, the code which decides whether to skip a segment or not can be removed simply by not defining AMIGA_SKIP_SEG. But notice that if you do so, gctest will complain (it will say that "GC_is_visible produced wrong failure indication"). However, it may be useful if you happen to have pointers stored in a code segment (you really shouldn't). If anyone has a good solution to the problem of finding, when a program is loaded in memory, whether a segment is a code or a data segment, please let me know. Jesper Peterson's notes ADDITIONAL NOTES FOR AMIGA PORT These notes assume some familiarity with Amiga internals. WHY I PORTED TO THE AMIGA The sole reason why I made this port was as a first step in getting the Sather(*) language on the Amiga. A port of this language will be done as soon as the Sather 1.0 sources are made available to me. Given this motivation, the garbage collection (GC) port is rather minimal. (*) For information on Sather read the comp.lang.sather newsgroup. LIMITATIONS This port assumes that the startup code linked with target programs is that supplied with SAS/C versions 6.0 or later. This allows assumptions to be made about where to find the stack base pointer and data segments when programs are run from WorkBench, as opposed to running from the CLI. The compiler dependent code is all in the GC_get_stack_base() and GC_register_data_segments() functions, but may spread as I add Amiga specific features. Given that SAS/C was assumed, the port is set up to be built with "smake" using the "SMakefile". Compiler options in "SCoptions" can be set with "scopts" program. Both "smake" and "scopts" are part of the SAS/C commercial development system. In keeping with the porting philosophy outlined above, this port will not behave well with Amiga specific code. Especially not inter- process comms via messages, and setting up public structures like Intuition objects or anything else in the system lists. For the time being the use of this library is limited to single threaded ANSI/POSIX compliant or near-complient code. (ie. Stick to stdio for now). Given this limitation there is currently no mechanism for allocating "CHIP" or "PUBLIC" memory under the garbage collector. I'll add this after giving it considerable thought. The major problem is the entire physical address space may have to me scanned, since there is no telling who we may have passed memory to. If you allocate your own stack in client code, you will have to assign the pointer plus stack size to GC_stackbottom. The initial stack size of the target program can be compiled in by setting the __stack symbol (see SAS documentaion). It can be over- ridden from the CLI by running the AmigaDOS "stack" program, or from the WorkBench by setting the stack size in the tool types window. SAS/C COMPILER OPTIONS (SCoptions) You may wish to check the "CPU" code option is appropriate for your intended target system. Under no circumstances set the "StackExtend" code option in either compiling the library or *ANY* client code. All benign compiler warnings have been suppressed. These mainly involve lack of prototypes in the code, and dead assignments detected by the optimizer. THE GOOD NEWS The library as it stands is compatible with the GigaMem commercial virtual memory software, and probably similar PD software. The performance of "gctest" on an Amiga 2630 (68030 @ 25Mhz) compares favourably with an HP9000 with similar architecture (a 325 with a 68030 I think). ----------------------------------------------------------------------- ecl-16.1.2/src/bdwgc/doc/README.arm.cross000066400000000000000000000035341266352375300175750ustar00rootroot00000000000000From: Margaret Fleck Here's the key details of what worked for me, in case anyone else needs them. There may well be better ways to do some of this, but .... -- Margaret The badge4 has a StrongArm-1110 processor and a StrongArm-1111 coprocessor. Assume that the garbage collector distribution is unpacked into /home/arm/gc6.0, which is visible to both the ARM machine and a linux desktop (e.g. via NFS mounting). Assume that you have a file /home/arm/config.site with contents something like the example attached below. Notice that our local ARM toolchain lives in /skiff/local. Go to /home/arm/gc6.0 directory. Do CONFIG_SITE=/home/arm/config.site ./configure --target=arm-linux --prefix=/home/arm/gc6.0 On your desktop, do: make make install The main garbage collector library should now be in ../gc6.0/lib/libgc.so. To test the garbage collector, first do the following on your desktop make gctest ./gctest Then do the following on the ARM machine cd .libs ./lt-gctest Do not try to do "make test" (the usual way of running the test program). This does not work and seems to erase some of the important files. The gctest program claims to have succeeded. Haven't run any further tests with it, though I'll be doing so in the near future. ------------------------------- # config.site for configure HOSTCC=gcc # Names of the cross-compilers CC=/skiff/local/bin/arm-linux-gcc CXX=/skiff/local/bin/arm-linux-gcc # The cross compiler specific options CFLAGS="-O2 -fno-exceptions" CXXFLAGS="-O2 -fno-exceptions" CPPFLAGS="-O2 -fno-exceptions" LDFLAGS="" # Some other programs AR=/skiff/local/bin/arm-linux-ar RANLIB=/skiff/local/bin/arm-linux-ranlib NM=/skiff/local/bin/arm-linux-nm ac_cv_path_NM=/skiff/local/bin/arm-linux-nm ac_cv_func_setpgrp_void=yes x_includes=/skiff/local/arm-linux/include/X11 x_libraries=/skiff/local/arm-linux/lib/X11 ecl-16.1.2/src/bdwgc/doc/README.autoconf000066400000000000000000000045341266352375300175050ustar00rootroot00000000000000Starting from GC v6.0, we support GNU-style builds based on automake, autoconf and libtool. This is based almost entirely on Tom Tromey's work with gcj. To build and install libraries use configure; make; make install The advantages of this process are: 1) It should eventually do a better job of automatically determining the right compiler to use, etc. It probably already does in some cases. 2) It tries to automatically set a good set of default GC parameters for the platform (e.g. thread support). It provides an easier way to configure some of the others. 3) It integrates better with other projects using a GNU-style build process. 4) It builds both dynamic and static libraries. The known disadvantages are: 1) The build scripts are much more complex and harder to debug (though largely standard). I don't understand them all, and there's probably lots of redundant stuff. 2) It probably doesn't work on all Un*x-like platforms yet. It probably will never work on the rest. 3) The scripts are not yet complete. Some of the standard GNU targets don't yet work. (Corrections/additions are very welcome.) The distribution should contain all files needed to run "configure" and "make", as well as the sources needed to regenerate the derived files. (If I missed some, please let me know.) Note that the distribution comes without "Makefile" which is generated by "configure". The distribution also contains "Makefile.direct" which is not always equivalent to the generated one. Important options to configure: --prefix=PREFIX install architecture-independent files in PREFIX [/usr/local] --exec-prefix=EPREFIX install architecture-dependent files in EPREFIX [same as prefix] --enable-threads=TYPE choose threading package --enable-parallel-mark parallelize marking and free list construction --enable-gc-debug (--enable-full-debug before about 7.0) include full support for pointer back-tracing etc. Unless --prefix is set (or --exec-prefix or one of the more obscure options), make install will install libgc.a and libgc.so in /usr/local/bin, which would typically require the "make install" to be run as root. Most commonly --enable-threads=posix or will be needed. --enable-parallel-mark is recommended for multiprocessors if it is supported on the platform. ecl-16.1.2/src/bdwgc/doc/README.cmake000066400000000000000000000022771266352375300167510ustar00rootroot00000000000000 CMAKE ----- Win32 binaries (both 32- and 64-bit) can be built using CMake. CMake is an open-source tool like automake - it generates makefiles. Some preliminary work has been done to make this work on other platforms, but the support is not yet complete. CMake will generate: Borland Makefiles MSYS Makefiles MinGW Makefiles NMake Makefiles Unix Makefiles . Visual Studio project files Visual Studio 6 Visual Studio 7 Visual Studio 7 .NET 2003 Visual Studio 8 2005 Visual Studio 8 2005 Win64 Visual Studio 9 2008 Visual Studio 9 2008 Win64 Watcom WMake BUILD PROCESS ------------- . install cmake (cmake.org) . add directory containing cmake.exe to %PATH% . run cmake from the gc root directory, passing the target with -G: e.g., > cmake -G "Visual Studio 8 2005" use the gc.sln file generated by cmake to build gc . you can also run cmake from a build directory to build outside of the source tree. Just specify the path to the source tree: e.g., > mkdir build > cd build > cmake .. -G "Visual Studio 8 2005" INPUT ----- The main input to cmake are the CMakeLists.txt files in each directory. For help, goto cmake.org. ecl-16.1.2/src/bdwgc/doc/README.cords000066400000000000000000000045711266352375300170020ustar00rootroot00000000000000Copyright (c) 1993-1994 by Xerox Corporation. All rights reserved. THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED OR IMPLIED. ANY USE IS AT YOUR OWN RISK. Permission is hereby granted to use or copy this program for any purpose, provided the above notices are retained on all copies. Permission to modify the code and to distribute modified code is granted, provided the above notices are retained, and a notice that the code was modified is included with the above copyright notice. Please send bug reports to Hans-J. Boehm. This is a string packages that uses a tree-based representation. See cord.h for a description of the functions provided. Ec.h describes "extensible cords", which are essentially output streams that write to a cord. These allow for efficient construction of cords without requiring a bound on the size of a cord. More details on the data structure can be found in Boehm, Atkinson, and Plass, "Ropes: An Alternative to Strings", Software Practice and Experience 25, 12, December 1995, pp. 1315-1330. A fundamentally similar "rope" data structure is also part of SGI's standard template library implementation, and its descendants, which include the GNU C++ library. That uses reference counting by default. There is a short description of that data structure at http://www.sgi.com/tech/stl/ropeimpl.html . All of these are descendants of the "ropes" in Xerox Cedar. cord/tests/de.c is a very dumb text editor that illustrates the use of cords. It maintains a list of file versions. Each version is simply a cord representing the file contents. Nonetheless, standard editing operations are efficient, even on very large files. (Its 3 line "user manual" can be obtained by invoking it without arguments. Note that ^R^N and ^R^P move the cursor by almost a screen. It does not understand tabs, which will show up as highlighted "I"s. Use the UNIX "expand" program first.) To build the editor, type "make cord/de" in the gc directory. This package assumes an ANSI C compiler such as gcc. It will not compile with an old-style K&R compiler. Note that CORD_printf iand friends use C functions with variable numbers of arguments in non-standard-conforming ways. This code is known to break on some platforms, notably PowerPC. It should be possible to build the remainder of the library (everything but cordprnt.c) on any platform that supports the collector. ecl-16.1.2/src/bdwgc/doc/README.darwin000066400000000000000000000145411266352375300171520ustar00rootroot00000000000000Darwin/MacOSX Support - December 16, 2003 == Build Notes == Building can be done with autoconf as normal. If you want to build a Universal library using autoconf, you need to disable dependency tracking and specify your desired architectures in CFLAGS: CFLAGS="-arch ppc -arch i386 -arch x86_64" ./configure --disable-dependency-tracking == Important Usage Notes == GC_init() MUST be called before calling any other GC functions. This is necessary to properly register segments in dynamic libraries. This call is required even if you code does not use dynamic libraries as the dyld code handles registering all data segments. When your use of the garbage collector is confined to dylibs and you cannot call GC_init() before your libraries' static initializers have run and perhaps called GC_malloc(), create an initialization routine for each library to call GC_init(): #include extern "C" void my_library_init() { GC_init(); } Compile this code into a my_library_init.o, and link it into your dylib. When you link the dylib, pass the -init argument with _my_library_init (e.g. gcc -dynamiclib -o my_library.dylib a.o b.o c.o my_library_init.o -init _my_library_init). This causes my_library_init() to be called before any static initializers, and will initialize the garbage collector properly. Note: It doesn't hurt to call GC_init() more than once, so it's best, if you have an application or set of libraries that all use the garbage collector, to create an initialization routine for each of them that calls GC_init(). Better safe than sorry. The incremental collector is still a bit flaky on darwin. It seems to work reliably with workarounds for a few possible bugs in place however these workaround may not work correctly in all cases. There may also be additional problems that I have not found. Thread-local GC allocation will not work with threads that are not created using the GC-provided override of pthread_create(). Threads created without the GC-provided pthread_create() do not have the necessary data structures in the GC to store this data. == Implementation Information == Darwin/MacOSX support is nearly complete. Thread support is reliable on Darwin 6.x (MacOSX 10.2) and there have been reports of success on older Darwin versions (MacOSX 10.1). Shared library support had also been added and the gc can be run from a shared library. Thread support is implemented in terms of mach thread_suspend and thread_resume calls. These provide a very clean interface to thread suspension. This implementation doesn't rely on pthread_kill so the code works on Darwin < 6.0 (MacOSX 10.1). All the code to stop and start the world is located in darwin_stop_world.c. Since not all uses of the GC enable clients to override pthread_create() before threads have been created, the code for stopping the world has been rewritten to look for threads using Mach kernel calls. Each thread identified in this way is suspended and resumed as above. In addition, since Mach kernel threads do not contain pointers to their stacks, a stack-walking function has been written to find the stack limits. Given an initial stack pointer (for the current thread, a pointer to a stack-allocated local variable will do; for a non-active thread, we grab the value of register 1 (on PowerPC)), it will walk the PPC Mach-O-ABI compliant stack chain until it reaches the top of the stack. This appears to work correctly for GCC-compiled C, C++, Objective-C, and Objective-C++ code, as well as for Java programs that use JNI. If you run code that does not follow the stack layout or stack pointer conventions laid out in the PPC Mach-O ABI, then this will likely crash the garbage collector. The original incremental collector support unfortunately no longer works on recent Darwin versions. It also relied on some undocumented kernel structures. Mach, however, does have a very clean interface to exception handing. The current implementation uses Mach's exception handling. Much thanks goes to Andrew Stone, Dietmar Planitzer, Andrew Begel, Jeff Sturm, and Jesse Rosenstock for all their work on the Darwin/OS X port. -Brian Alliet == gc_cpp.h usage == Replacement of operator new and delete is apparently not supported with dynamic libraries. This means that applications using gc_cpp.h (including the built-in test) will probably not work correctly with the collector in a dynamic library, unless special care is taken. See http://article.gmane.org/gmane.comp.programming.garbage-collection.boehmgc/1421 for some details. - Hans Boehm (based on information from Andrew Begel) == Older Information (Most of this no longer applies to the current code) == While the GC should work on MacOS X Server, MacOS X and Darwin, I only tested it on MacOS X Server. I've added a PPC assembly version of GC_push_regs(), thus the setjmp() hack is no longer necessary. Incremental collection is supported via mprotect/signal. The current solution isn't really optimal because the signal handler must decode the faulting PPC machine instruction in order to find the correct heap address. Further, it must poke around in the register state which the kernel saved away in some obscure register state structure before it calls the signal handler - needless to say the layout of this structure is no where documented. Threads and dynamic libraries are not yet supported (adding dynamic library support via the low-level dyld API shouldn't be that hard). The original MacOS X port was brought to you by Andrew Stone. June, 1 2000 Dietmar Planitzer Note from Andrew Begel: One more fix to enable gc.a to link successfully into a shared library for MacOS X. You have to add -fno-common to the CFLAGS in the Makefile. MacOSX disallows common symbols in anything that eventually finds its way into a shared library. (I don't completely understand why, but -fno-common seems to work and doesn't mess up the garbage collector's functionality). Feb 26, 2003 Jeff Sturm and Jesse Rosenstock provided a patch that adds thread support. GC_MACOSX_THREADS should be defined in the build and in clients. Real dynamic library support is still missing, i.e. dynamic library data segments are still not scanned. Code that stores pointers to the garbage collected heap in statically allocated variables should not reside in a dynamic library. This still doesn't appear to be 100% reliable. Mar 10, 2003 Brian Alliet contributed dynamic library support for MacOSX. It could also use more testing. ecl-16.1.2/src/bdwgc/doc/README.environment000066400000000000000000000246311266352375300202330ustar00rootroot00000000000000The garbage collector looks at a number of environment variables which are, then, used to affect its operation. GC_INITIAL_HEAP_SIZE= - Initial heap size in bytes. May speed up process start-up. Optionally, may be specified with a multiplier ('k', 'M' or 'G') suffix. GC_MAXIMUM_HEAP_SIZE= - Maximum collected heap size. Allows a multiplier suffix. GC_LOOP_ON_ABORT - Causes the collector abort routine to enter a tight loop. This may make it easier to debug, such a process, especially for multi-threaded platforms that don't produce usable core files, or if a core file would be too large. On some platforms, this also causes SIGSEGV to be caught and result in an infinite loop in a handler, allowing similar debugging techniques. GC_PRINT_STATS - Turn on GC logging. Not functional with SMALL_CONFIG. GC_LOG_FILE - The name of the log file. Stderr by default. Not functional with SMALL_CONFIG. GC_ONLY_LOG_TO_FILE - Turns off redirection of GC stdout and stderr to the log file specified by GC_LOG_FILE. Has no effect unless GC_LOG_FILE is set. Not functional with SMALL_CONFIG. GC_PRINT_VERBOSE_STATS - Turn on even more logging. Not functional with SMALL_CONFIG. GC_DUMP_REGULARLY - Generate a GC debugging dump GC_dump() on startup and during every collection. Very verbose. Useful if you have a bug to report, but please include only the last complete dump. GC_COLLECT_AT_MALLOC= - Override the default value specified by GC_COLLECT_AT_MALLOC macro. Has no effect unless GC is built with GC_COLLECT_AT_MALLOC defined. GC_BACKTRACES= - Generate n random back-traces (for heap profiling) after each GC. Collector must have been built with KEEP_BACK_PTRS. This won't generate useful output unless most objects in the heap were allocated through debug allocators. This is intended to be only a statistical sample; individual traces may be erroneous due to concurrent heap mutation. GC_PRINT_ADDRESS_MAP - Linux only. Dump /proc/self/maps, i.e. various address maps for the process, to stderr on every GC. Useful for mapping root addresses to source for deciphering leak reports. GC_NPROCS= - Linux w/threads only. Explicitly sets the number of processors that the GC should expect to use. Note that setting this to 1 when multiple processors are available will preserve correctness, but may lead to really horrible performance, since the lock implementation will immediately yield without first spinning. GC_MARKERS= - Only if compiled with PARALLEL_MARK. Set the number of marker threads. This is normally set to the number of processors. It is safer to adjust GC_MARKERS than GC_NPROCS, since GC_MARKERS has no impact on the lock implementation. GC_NO_BLACKLIST_WARNING - Prevents the collector from issuing warnings about allocations of very large blocks. Deprecated. Use GC_LARGE_ALLOC_WARN_INTERVAL instead. GC_LARGE_ALLOC_WARN_INTERVAL= - Print every nth warning about very large block allocations, starting with the nth one. Small values of n are generally benign, in that a bounded number of such warnings generally indicate at most a bounded leak. For best results it should be set at 1 during testing. Default is 5. Very large numbers effectively disable the warning. GC_IGNORE_GCJ_INFO - Ignore the type descriptors implicitly supplied by GC_gcj_malloc and friends. This is useful for debugging descriptor generation problems, and possibly for temporarily working around such problems. It forces a fully conservative scan of all heap objects except those known to be pointer-free, and may thus have other adverse effects. GC_PRINT_BACK_HEIGHT - Print max length of chain through unreachable objects ending in a reachable one. If this number remains bounded, then the program is "GC robust". This ensures that a fixed number of misidentified pointers can only result in a bounded space leak. This currently only works if debugging allocation is used throughout. It increases GC space and time requirements appreciably. This feature is still somewhat experimental, and requires that the collector have been built with MAKE_BACK_GRAPH defined. For details, see Boehm, "Bounding Space Usage of Conservative Garbage Collectors", POPL 2001 (http://www.hpl.hp.com/techreports/2001/HPL-2001-251.html). GC_RETRY_SIGNALS, GC_NO_RETRY_SIGNALS - Try to compensate for lost thread suspend signals in linux_threads.c. On by default for GC_OSF1_THREADS, off otherwise. Note that this does not work around a possible loss of thread restart signals. This seems to be necessary for some versions of Tru64. Since we've previously seen similar issues on some other operating systems, it was turned into a runtime flag to enable last-minute work-arounds. GC_USE_GETWRITEWATCH= - Only if MPROTECT_VDB and GWW_VDB are both defined (Win32 only). Explicitly specify which strategy of keeping track of dirtied pages should be used. If n=0 then GetWriteWatch() is not used (falling back to protecting pages and catching memory faults strategy) else the collector tries to use GetWriteWatch-based strategy (GWW_VDB) first if available. GC_DISABLE_INCREMENTAL - Ignore runtime requests to enable incremental GC. Useful for debugging. The following turn on runtime flags that are also program settable. Checked only during initialization. We expect that they will usually be set through other means, but this may help with debugging and testing: GC_ENABLE_INCREMENTAL - Turn on incremental collection at startup. Note that, depending on platform and collector configuration, this may involve write protecting pieces of the heap to track modifications. These pieces may include pointer-free objects or not. Although this is intended to be transparent, it may cause unintended system call failures. Use with caution. GC_PAUSE_TIME_TARGET - Set the desired garbage collector pause time in msecs. This only has an effect if incremental collection is enabled. If a collection requires appreciably more time than this, the client will be restarted, and the collector will need to do additional work to compensate. The special value "999999" indicates that pause time is unlimited, and the incremental collector will behave completely like a simple generational collector. If the collector is configured for parallel marking, and run on a multiprocessor, incremental collection should only be used with unlimited pause time. GC_FULL_FREQUENCY - Set the desired number of partial collections between full collections. Matters only if GC_incremental is set. Not functional with SMALL_CONFIG. GC_FREE_SPACE_DIVISOR - Set GC_free_space_divisor to the indicated value. Setting it to larger values decreases space consumption and increases GC frequency. GC_UNMAP_THRESHOLD - Set the desired memory blocks unmapping threshold (the number of sequential garbage collections for which a candidate block for unmapping should remain free). The special value "0" completely disables unmapping. GC_FORCE_UNMAP_ON_GCOLLECT - Turn "unmap as much as possible on explicit GC" mode on (overrides the default value). Has no effect on implicitly-initiated garbage collections. Has no effect if memory unmapping is disabled (or not compiled in) or if the unmapping threshold is 1. GC_FIND_LEAK - Turns on GC_find_leak and thus leak detection. Forces a collection at program termination to detect leaks that would otherwise occur after the last GC. GC_FINDLEAK_DELAY_FREE - Turns on deferred freeing of objects in the leak-finding mode (see the corresponding macro description for more information). GC_ABORT_ON_LEAK - Causes the application to be terminated once leaked or smashed objects are found. GC_ALL_INTERIOR_POINTERS - Turns on GC_all_interior_pointers and thus interior pointer recognition. GC_DONT_GC - Turns off garbage collection. Use cautiously. GC_USE_ENTIRE_HEAP - Set desired GC_use_entire_heap value at start-up. See the similar macro description in README.macros. GC_TRACE=addr - Intended for collector debugging. Requires that the collector have been built with ENABLE_TRACE defined. Causes the debugger to log information about the tracing of address ranges containing addr. Typically addr is the address that contains a pointer to an object that mysteriously failed to get marked. Addr must be specified as a hexadecimal integer. ecl-16.1.2/src/bdwgc/doc/README.ews4800000066400000000000000000000040601266352375300167730ustar00rootroot00000000000000GC on EWS4800 ------------- 1. About EWS4800 EWS4800 is 32bit/64bit workstation. Vender: NEC Corporation OS: UX/4800 R9.* - R13.* (SystemV R4.2) CPU: R4000, R4400, R10000 (MIPS) 2. Compiler 32bit: Use ANSI C compiler. CC = /usr/abiccs/bin/cc 64bit: Use 64bit ANSI C compiler. CC = /usr/ccs64/bin/cc AR = /usr/ccs64/bin/ar 3. ELF file format *** Caution: The following infomation is empirical. *** 32bit: ELF file has an unique format. (See a.out(4) and end(3C).) &_start : text segment &etext DATASTART : data segment (initialized) &edata DATASTART2 : data segment (uninitialized) &end Here, DATASTART and DATASTART2 are macros of GC, and are defined as the following equations. (See include/private/gcconfig.h.) The algorithm for DATASTART is similar with the function GC_SysVGetDataStart() in os_dep.c. DATASTART = ((&etext + 0x3ffff) & ~0x3ffff) + (&etext & 0xffff) Dynamically linked: DATASTART2 = (&_gp + 0x8000 + 0x3ffff) & ~0x3ffff Statically linked: DATASTART2 = &edata GC has to check addresses both between DATASTART and &edata, and between DATASTART2 and &end. If a program accesses between &etext and DATASTART, or between &edata and DATASTART2, the segmentation error occurs and the program stops. If a program is statically linked, there is not a gap between &edata and DATASTART2. The global symbol &_DYNAMIC_LINKING is used for the detection. 64bit: ELF file has a simple format. (See end(3C).) _ftext : text segment _etext _fdata = DATASTART : data segment (initialized) _edata _fbss : data segment (uninitialized) _end = DATAEND -- Hironori SAKAMOTO When using the new "configure; make" build process, please run configure with the --disable-shared option. "Make check" does not yet pass with dynamic libraries. Ther reasons for that are not yet understood. (HB, paraphrasing message from Hironori SAKAMOTO.) ecl-16.1.2/src/bdwgc/doc/README.hp000066400000000000000000000015161266352375300162730ustar00rootroot00000000000000Dynamic loading support requires that executables be linked with -ldld. The alternative is to build the collector without defining DYNAMIC_LOADING in gcconfig.h and ensuring that all garbage collectible objects are accessible without considering statically allocated variables in dynamic libraries. The collector should compile with either plain cc or cc -Ae. Cc -Aa fails to define _HPUX_SOURCE and thus will not configure the collector correctly. Incremental collection support was reccently added, and should now work. In spite of past claims, pthread support under HP/UX 11 should now work. Define GC_HPUX_THREADS for the build. Incremental collection still does not work in combination with it. The stack finding code can be confused by putenv calls before collector initialization. Call GC_malloc or GC_init before any putenv calls. ecl-16.1.2/src/bdwgc/doc/README.linux000066400000000000000000000105671266352375300170310ustar00rootroot00000000000000See README.alpha for Linux on DEC AXP info. This file applies mostly to Linux/Intel IA32. Ports to Linux on an M68K, IA64, SPARC, MIPS, Alpha and PowerPC are integrated too. They should behave similarly, except that the PowerPC port lacks incremental GC support, and it is unknown to what extent the Linux threads code is functional. See below for M68K specific notes. Incremental GC is generally supported. Dynamic libraries are supported on an ELF system. A static executable should be linked with the gcc option "-Wl,-defsym,_DYNAMIC=0". The collector appears to work reliably with Linux threads, but beware of older versions of glibc and gdb. The garbage collector uses SIGPWR and SIGXCPU if it is used with Linux threads. These should not be touched by the client program. To use threads, you need to abide by the following requirements: 1) You need to use LinuxThreads or NPTL (which are included in libc6). The collector relies on some implementation details of the LinuxThreads package. This code may not work on other pthread implementations (in particular it will *not* work with MIT pthreads). 2) You must compile the collector with -DGC_LINUX_THREADS (or just -DGC_THREADS) and -D_REENTRANT specified in the Makefile. 3a) Every file that makes thread calls should define GC_LINUX_THREADS and _REENTRANT and then include gc.h. Gc.h redefines some of the pthread primitives as macros which also provide the collector with information it requires. 3b) A new alternative to (3a) is to build the collector and compile GC clients with -DGC_USE_LD_WRAP, and to link the final program with (for ld) --wrap dlopen --wrap pthread_create \ --wrap pthread_join --wrap pthread_detach \ --wrap pthread_sigmask --wrap pthread_exit --wrap pthread_cancel (for gcc) -Wl,--wrap -Wl,dlopen -Wl,--wrap -Wl,pthread_create \ -Wl,--wrap -Wl,pthread_join -Wl,--wrap -Wl,pthread_detach \ -Wl,--wrap -Wl,pthread_sigmask -Wl,--wrap -Wl,pthread_exit \ -Wl,--wrap -Wl,pthread_cancel In any case, _REENTRANT should be defined during compilation. 4) Dlopen() disables collection during its execution. (It can't run concurrently with the collector, since the collector looks at its data structures. It can't acquire the allocator lock, since arbitrary user startup code may run as part of dlopen().) Under unusual conditions, this may cause unexpected heap growth. 5) The combination of GC_LINUX_THREADS, REDIRECT_MALLOC, and incremental collection is probably not fully reliable, though it now seems to work in simple cases. 6) Thread local storage may not be viewed as part of the root set by the collector. This probably depends on the linuxthreads version. For the time being, any collectible memory referenced by thread local storage should also be referenced from elsewhere, or be allocated as uncollectible. (This is really a bug that should be fixed somehow. The current GC version probably gets things right if there are not too many tls locations and if dlopen is not used.) M68K LINUX: (From Richard Zidlicky) The bad news is that it can crash every linux-m68k kernel on a 68040, so an additional test is needed somewhere on startup. I have meanwhile patches to correct the problem in 68040 buserror handler but it is not yet in any standard kernel. Here is a simple test program to detect whether the kernel has the problem. It could be run as a separate check in configure or tested upon startup. If it fails (return !0) than mprotect can't be used on that system. /* * test for bug that may crash 68040 based Linux */ #include #include #include #include #include char *membase; int pagesize=4096; int pageshift=12; int x_taken=0; int sighandler(int sig) { mprotect(membase,pagesize,PROT_READ|PROT_WRITE); x_taken=1; } main() { long l; signal(SIGSEGV,sighandler); l=(long)mmap(NULL,pagesize,PROT_READ,MAP_PRIVATE | MAP_ANON,-1,0); if (l==-1) { perror("mmap/malloc"); abort(); } membase=(char*)l; *(long*)(membase+sizeof(long))=123456789; if (*(long*)(membase+sizeof(long)) != 123456789 ) { fprintf(stderr,"writeback failed !\n"); exit(1); } if (!x_taken) { fprintf(stderr,"exception not taken !\n"); exit(1); } fprintf(stderr,"vmtest Ok\n"); exit(0); } ecl-16.1.2/src/bdwgc/doc/README.macros000066400000000000000000000711131266352375300171500ustar00rootroot00000000000000The collector uses a large amount of conditional compilation in order to deal with platform dependencies. This violates a number of known coding standards. On the other hand, it seems to be the only practical way to support this many platforms without excessive code duplication. A few guidelines have mostly been followed in order to keep this manageable: 1) #if and #ifdef directives are properly indented whenever easily possible. All known C compilers allow whitespace between the "#" and the "if" to make this possible. ANSI C also allows white space before the "#", though we avoid that. It has the known disadvantages that it differs from the normal GNU conventions, and that it makes patches larger than otherwise necessary. In my opinion, it's still well worth it, for the same reason that we indent ordinary "if" statements. 2) Whenever possible, tests are performed on the macros defined in gcconfig.h instead of directly testing platform-specific predefined macros. This makes it relatively easy to adapt to new compilers with a different set of predefined macros. Currently these macros generally identify platforms instead of features. In many cases, this is a mistake. Many of the tested configuration macros are at least somewhat defined in either include/private/gcconfig.h or in Makefile.direct. Here is an attempt at documenting these macros: (Thanks to Walter Bright for suggesting this. This is a work in progress) MACRO EXPLANATION ----- ----------- GC_DEBUG Tested by gc.h. Causes all-upper-case macros to expand to calls to debug versions of collector routines. GC_NAMESPACE Tested by gc_cpp.h. Causes gc_cpp symbols to be defined in "boehmgc" namespace. GC_DEBUG_REPLACEMENT Tested by gc.h. Causes GC_MALLOC/REALLOC() to be defined as GC_debug_malloc/realloc_replacement(). GC_NO_THREAD_REDIRECTS Tested by gc.h. Prevents redirection of thread creation routines etc. to GC_ versions. Requires the programmer to explicitly handle thread registration. GC_NO_THREAD_DECLS Tested by gc.h. MS Windows only. Do not declare Windows thread creation routines and do not include windows.h. GC_UNDERSCORE_STDCALL Tested by gc.h. Explicitly prefix exported/imported WINAPI (__stdcall) symbols with '_' (underscore). Could be used with MinGW (for x86) compiler (in conjunction with GC_DLL) to follow MS conventions for __stdcall symbols naming. _ENABLE_ARRAYNEW #define'd by the Digital Mars C++ compiler when operator new[] and delete[] are separately overloadable. Used in gc_cpp.h. _DLL Tested by gc_config_macros.h. Defined by Visual C++ if runtime dynamic libraries are in use. Used (only if none of GC_DLL, GC_NOT_DLL, __GNUC__ are defined) to test whether __declspec(dllimport) needs to be added to declarations to support the case in which the collector is in a DLL. GC_DLL Defined by user if dynamic libraries are being built or used. Also set by gc.h if _DLL is defined (except for mingw) while GC_NOT_DLL and __GNUC__ are both undefined. This is the macro that is tested internally to determine whether the GC is in its own dynamic library. May need to be set by clients before including gc.h. Note that inside the GC implementation it indicates that the collector is in its own dynamic library, should export its symbols, etc. But in clients it indicates that the GC resides in a different DLL, its entry points should be referenced accordingly, and precautions may need to be taken to properly deal with statically allocated variables in the main program. Used for MS Windows. Also used by GCC v4+ (only when the dynamic shared library is being built) to hide internally used symbols. GC_NOT_DLL User-settable macro that overrides _DLL, e.g. if runtime dynamic libraries are used, but the collector is in a static library. Tested by gc_config_macros.h. GC_REQUIRE_WCSDUP Force GC to export GC_wcsdup() (the Unicode version of GC_strdup); could be useful in the leak-finding mode. These define arguments influence the collector configuration: FIND_LEAK Causes GC_find_leak to be initially set. This causes the collector to assume that all inaccessible objects should have been explicitly deallocated, and reports exceptions. Finalization and the test program are not usable in this mode. GC_FINDLEAK_DELAY_FREE Turns on deferred freeing of objects in the leak-finding mode letting the collector to detect alter-object-after-free errors as well as detect leaked objects sooner (instead of only when program terminates). Has no effect if SHORT_DBG_HDRS. GC_ABORT_ON_LEAK Causes the application to be terminated once leaked or smashed (corrupted on use-after-free) objects are found (after printing the information about that objects). SUNOS5SIGS Solaris-like signal handling. This is probably misnamed, since it really doesn't guarantee much more than POSIX. Currently set only for Solaris2.X, HPUX, and DRSNX. Should probably be set for some other platforms. PCR Set if the collector is being built as part of the Xerox Portable Common Runtime. USE_COMPILER_TLS Assume the existence of __thread-style thread-local storage. Set automatically for thread-local allocation with the HP/UX vendor compiler. Usable with gcc on sufficiently up-to-date ELF platforms. IMPORTANT: Any of the _THREADS options must normally also be defined in the client before including gc.h. This redefines thread primitives to invoke the GC_ versions instead. Alternatively, linker-based symbol interception can be used on a few platforms. GC_THREADS Should set the appropriate one of the below macros, except GC_WIN32_PTHREADS, which must be set explicitly. Tested by gc.h. GC_SOLARIS_THREADS Enables support for Solaris pthreads. Must also define _REENTRANT. GC_IRIX_THREADS Enables support for Irix pthreads. See README.sgi. GC_HPUX_THREADS Enables support for HP/UX 11 pthreads. Also requires _REENTRANT or _POSIX_C_SOURCE=199506L. See README.hp. GC_LINUX_THREADS Enables support for Xavier Leroy's Linux threads or NPTL threads. See README.linux. _REENTRANT may also be required. GC_OSF1_THREADS Enables support for Tru64 pthreads. GC_FREEBSD_THREADS Enables support for FreeBSD pthreads. Appeared to run into some underlying thread problems. GC_NETBSD_THREADS Enables support for NetBSD pthreads. GC_OPENBSD_THREADS Enables support for OpenBSD pthreads. GC_DARWIN_THREADS Enables support for Mac OS X pthreads. GC_AIX_THREADS Enables support for IBM AIX threads. GC_DGUX386_THREADS Enables support for DB/UX on I386 threads. See README.DGUX386. (Probably has not been tested recently.) GC_WIN32_THREADS Enables support for Win32 threads. That makes sense for this Makefile only under Cygwin. GC_WIN32_PTHREADS Enables support for pthreads-win32 (or other non-Cygwin pthreads library for Windows). This cannot be enabled automatically by GC_THREADS, which would assume Win32 native threads. PTW32_STATIC_LIB Causes the static version of the Mingw pthreads library to be used. Requires GC_WIN32_PTHREADS. GC_PTHREADS_PARAMARK Causes pthread-based parallel mark implementation to be used even if GC_WIN32_PTHREADS is undefined. (Useful for WinCE.) ALL_INTERIOR_POINTERS Allows all pointers to the interior of objects to be recognized. (See gc_priv.h for consequences.) Alternatively, GC_all_interior_pointers can be set at process initialization time. SMALL_CONFIG Tries to tune the collector for small heap sizes, usually causing it to use less space in such situations. Incremental collection no longer works in this case. Also, removes some statistic-printing code. Turns off some optimization algorithms (like data prefetching in the mark routine). GC_DISABLE_INCREMENTAL Turn off the incremental collection support. NO_INCREMENTAL Causes the gctest program to not invoke the incremental collector. This has no impact on the generated library, only on the test program. (This is often useful for debugging failures unrelated to incremental GC.) LARGE_CONFIG Tunes the collector for unusually large heaps. Necessary for heaps larger than about 4 GiB on most (64-bit) machines. Recommended for heaps larger than about 500 MiB. Not recommended for embedded systems. Could be used in conjunction with SMALL_CONFIG to generate smaller code (by disabling incremental collection support, statistic printing and some optimization algorithms). DONT_ADD_BYTE_AT_END Meaningful only with ALL_INTERIOR_POINTERS or GC_all_interior_pointers = 1. Normally ALL_INTERIOR_POINTERS causes all objects to be padded so that pointers just past the end of an object can be recognized. This can be expensive. (The padding is normally more than one byte due to alignment constraints.) DONT_ADD_BYTE_AT_END disables the padding. NO_EXECUTE_PERMISSION May cause some or all of the heap to not have execute permission, i.e. it may be impossible to execute code from the heap. Currently this only affects the incremental collector on UNIX machines. It may greatly improve its performance, since this may avoid some expensive cache synchronization. Alternatively, GC_set_pages_executable can be called at the process initialization time. GC_NO_OPERATOR_NEW_ARRAY Declares that the C++ compiler does not support the new syntax "operator new[]" for allocating and deleting arrays. See gc_cpp.h for details. No effect on the C part of the collector. This is defined implicitly in a few environments. Must also be defined by clients that use gc_cpp.h. REDIRECT_MALLOC= Causes malloc to be defined as alias for X. Unless the following macros are defined, realloc is also redirected to GC_realloc, and free is redirected to GC_free. Calloc and str[n]dup are redefined in terms of the new malloc. X should be either GC_malloc or GC_malloc_uncollectable, or GC_debug_malloc_replacement. (The latter invokes GC_debug_malloc with dummy source location information, but still results in properly remembered call stacks on Linux/X86 and Solaris/SPARC. It requires that the following two macros also be used.) The former is occasionally useful for working around leaks in code you don't want to (or can't) look at. It may not work for existing code, but it often does. Neither works on all platforms, since some ports use malloc or calloc to obtain system memory. (Probably works for UNIX, and Win32.) If you build with DBG_HDRS_ALL, you should only use GC_debug_malloc_replacement as a malloc replacement. REDIRECT_REALLOC= Causes GC_realloc to be redirected to X. The canonical use is REDIRECT_REALLOC=GC_debug_realloc_replacement, together with REDIRECT_MALLOC=GC_debug_malloc_replacement to generate leak reports with call stacks for both malloc and realloc. This also requires REDIRECT_FREE. REDIRECT_FREE= Causes free to be redirected to X. The canonical use is REDIRECT_FREE=GC_debug_free. IGNORE_FREE Turns calls to free into a no-op. Only useful with REDIRECT_MALLOC. NO_DEBUGGING Removes GC_dump and the debugging routines it calls. Reduces code size slightly at the expense of debuggability. GC_DUMP_REGULARLY Generate regular debugging dumps. DEBUG_THREADS Turn on printing additional thread-support debugging information. GC_COLLECT_AT_MALLOC= Force garbage collection at every GC_malloc_* call with the size greater than the specified value. (Might be useful for application debugging or in find-leak mode.) JAVA_FINALIZATION Makes it somewhat safer to finalize objects out of order by specifying a nonstandard finalization mark procedure (see finalize.c). Objects reachable from finalizable objects will be marked in a separate post-pass, and hence their memory won't be reclaimed. Not recommended unless you are implementing a language that specifies these semantics. Since 5.0, determines only the initial value of GC_java_finalization variable. FINALIZE_ON_DEMAND Causes finalizers to be run only in response to explicit GC_invoke_finalizers() calls. In 5.0 this became runtime adjustable, and this only determines the initial value of GC_finalize_on_demand. GC_NO_FINALIZATION Exclude finalization support (for smaller code size) ATOMIC_UNCOLLECTABLE Includes code for GC_malloc_atomic_uncollectable. This is useful if either the vendor malloc implementation is poor, or if REDIRECT_MALLOC is used. MARK_BIT_PER_GRANULE Requests that a mark bit (or often byte) be allocated for each allocation granule, as opposed to each object. This often improves speed, possibly at some cost in space and/or cache footprint. Normally it is best to let this decision be made automatically depending on platform. MARK_BIT_PER_OBJ Requests that a mark bit be allocated for each object instead of allocation granule. The opposite of MARK_BIT_PER_GRANULE. HBLKSIZE= Explicitly sets the heap block size (where ddd is a power of 2 between 512 and 16384). Each heap block is devoted to a single size and kind of object. For the incremental collector it makes sense to match the most likely page size. Otherwise large values result in more fragmentation, but generally better performance for large heaps. USE_MMAP Use MMAP instead of sbrk to get new memory. Works for Linux, FreeBSD, Cygwin, Solaris and Irix. USE_MUNMAP Causes memory to be returned to the OS under the right circumstances. This currently disables VM-based incremental collection (except for Win32 with GetWriteWatch() available). Works under some Unix, Linux and Windows versions. Requires USE_MMAP except for Windows. USE_WINALLOC (Cygwin only) Use Win32 VirtualAlloc (instead of sbrk or mmap) to get new memory. Useful if memory unmapping (USE_MUNMAP) is enabled. MUNMAP_THRESHOLD= Set the desired memory blocks unmapping threshold (the number of sequential garbage collections for which a candidate block for unmapping should remain free). GC_FORCE_UNMAP_ON_GCOLLECT Set "unmap as much as possible on explicit GC" mode on by default. The mode could be changed at run-time. Has no effect unless unmapping is turned on. Has no effect on implicitly-initiated garbage collections. PRINT_BLACK_LIST Whenever a black list entry is added, i.e. whenever the garbage collector detects a value that looks almost, but not quite, like a pointer, print both the address containing the value, and the value of the near-bogus-pointer. Can be used to identify regions of memory that are likely to contribute misidentified pointers. KEEP_BACK_PTRS Add code to save back pointers in debugging headers for objects allocated with the debugging allocator. If all objects through GC_MALLOC with GC_DEBUG defined, this allows the client to determine how particular or randomly chosen objects are reachable for debugging/profiling purposes. The gc_backptr.h interface is implemented only if this is defined. GC_ASSERTIONS Enable some internal GC assertion checking. Currently this facility is only used in a few places. It is intended primarily for debugging of the garbage collector itself, but could also... DBG_HDRS_ALL Make sure that all objects have debug headers. Increases the reliability (from 99.9999% to 100% mod. bugs) of some of the debugging code (especially KEEP_BACK_PTRS). Makes SHORT_DBG_HDRS possible. Assumes that all client allocation is done through debugging allocators. SHORT_DBG_HDRS Assume that all objects have debug headers. Shorten the headers to minimize object size, at the expense of checking for writes past the end of an object. This is intended for environments in which most client code is written in a "safe" language, such as Scheme or Java. Assumes that all client allocation is done using the GC_debug_ functions, or through the macros that expand to these, or by redirecting malloc to GC_debug_malloc_replacement. (Also eliminates the field for the requested object size.) Occasionally could be useful for debugging of client code. Slows down the collector somewhat, but not drastically. SAVE_CALL_COUNT= Set the number of call frames saved with objects allocated through the debugging interface. Affects the amount of information generated in leak reports. Only matters on platforms on which we can quickly generate call stacks, currently Linux/(X86 & SPARC) and Solaris/SPARC and platforms that provide execinfo.h. Default is zero. On X86, client code should NOT be compiled with -fomit-frame-pointer. SAVE_CALL_NARGS= Set the number of functions arguments to be saved with each call frame. Default is zero. Ignored if we don't know how to retrieve arguments on the platform. CHECKSUMS Reports on erroneously clear dirty bits, and unexpectedly altered stubborn objects, at substantial performance cost. Use only for debugging of the incremental collector. Not compatible with USE_MUNMAP or threads. GC_GCJ_SUPPORT Includes support for gcj (and possibly other systems that include a pointer to a type descriptor in each allocated object). Building this way requires an ANSI C compiler. USE_I686_PREFETCH Causes the collector to issue Pentium III style prefetch instructions. No effect except on X86 Linux platforms. Assumes a very recent gcc-compatible compiler and assembler. (Gas prefetcht0 support was added around May 1999.) Empirically the code appears to still run correctly on Pentium II processors, though with no performance benefit. May not run on other X86 processors? In some cases this improves performance by 15% or so. USE_3DNOW_PREFETCH Causes the collector to issue AMD 3DNow style prefetch instructions. Same restrictions as USE_I686_PREFETCH. Minimally tested. Didn't appear to be an obvious win on a K6-2/500. USE_PPC_PREFETCH Causes the collector to issue PowerPC style prefetch instructions. No effect except on PowerPC OS X platforms. Performance impact untested. GC_USE_LD_WRAP In combination with the old flags listed in README.linux causes the collector some system and pthread calls in a more transparent fashion than the usual macro-based approach. Requires GNU ld, and currently probably works only with Linux. GC_USE_DLOPEN_WRAP Causes the collector to redefine malloc and intercepted pthread routines with their real names, and causes it to use dlopen and dlsym to refer to the original versions. This makes it possible to build an LD_PRELOADable malloc replacement library. THREAD_LOCAL_ALLOC Defines GC_malloc(), GC_malloc_atomic() and GC_gcj_malloc() to use a per-thread set of free-lists. These then allocate in a way that usually does not involve acquisition of a global lock. Recommended for multiprocessors. Requires explicit GC_INIT() call, unless REDIRECT_MALLOC is defined and GC_malloc is used first. USE_COMPILER_TLS Causes thread local allocation to use the compiler-supported "__thread" thread-local variables. This is the default in HP/UX. It may help performance on recent Linux installations. (It failed for me on RedHat 8, but appears to work on RedHat 9.) PARALLEL_MARK Allows the marker to run in multiple threads. Recommended for multiprocessors. GC_ALWAYS_MULTITHREADED Force multi-threaded mode at GC initialization. (Turns GC_allow_register_threads into a no-op routine.) GC_WINMAIN_REDIRECT (Win32 only) Redirect (rename) an application WinMain to GC_WinMain; implement the "real" WinMain which starts a new thread to call GC_WinMain after initializing the GC. Useful for WinCE. Incompatible with GC_DLL. GC_REGISTER_MEM_PRIVATE (Win32 only) Force to register MEM_PRIVATE R/W sections as data roots. Might be needed for some WinCE 6.0+ custom builds. (May result in numerous "Data Abort" messages logged to WinCE debugging console.) Incompatible with GCC toolchains for WinCE. NO_GETENV Prevents the collector from looking at environment variables. These may otherwise alter its configuration, or turn off GC altogether. I don't know of a reason to disable this, except possibly if the resulting process runs as a privileged user. (This is on by default for WinCE.) EMPTY_GETENV_RESULTS Define to workaround a reputed Wine bug in getenv (getenv() may return an empty string instead of NULL for a missing entry). GC_READ_ENV_FILE (Win32 only) Read environment variables from the GC "env" file (named as the program name plus ".gc.env" extension). Useful for WinCE targets (which have no getenv()). In the file, every variable is specified in a separate line and the format is as "=" (without spaces). A comment line may start with any character except for the Latin letters, the digits and the underscore ('_'). The file encoding is Latin-1. USE_GLOBAL_ALLOC (Win32 only) Use GlobalAlloc() instead of VirtualAlloc() to allocate the heap. May be needed to work around a Windows NT/2000 issue. Incompatible with USE_MUNMAP. See README.win32 for details. MAKE_BACK_GRAPH Enable GC_PRINT_BACK_HEIGHT environment variable. See README.environment for details. Experimental. Limited platform support. Implies DBG_HDRS_ALL. All allocation should be done using the debug interface. GC_PRINT_BACK_HEIGHT Permanently turn on back-height printing mode (useful when NO_GETENV). See the similar environment variable description in README.environment. Requires MAKE_BACK_GRAPH defined. STUBBORN_ALLOC Allows allocation of "hard to change" objects, and thus makes incremental collection easier. Was enabled by default until 6.0. Rarely used, to my knowledge. HANDLE_FORK (Unix and Cygwin only) Attempt by default to make GC_malloc() work in a child process fork()'ed from a multi-threaded parent. Not fully POSIX-compliant and could be disabled at runtime (before GC_INIT). TEST_WITH_SYSTEM_MALLOC Causes gctest to allocate (and leak) large chunks of memory with the standard system malloc. This will cause the root set and collected heap to grow significantly if malloc'ed memory is somehow getting traced by the collector. This has no impact on the generated library; it only affects the test. POINTER_MASK=<0x...> Causes candidate pointers to be AND'ed with the given mask before being considered. If either this or the following macro is defined, it will be assumed that all pointers stored in the heap need to be processed this way. Stack and register pointers will be considered both with and without processing. These macros are normally needed only to support systems that use high-order pointer tags. EXPERIMENTAL. POINTER_SHIFT= Causes the collector to left shift candidate pointers by the indicated amount before trying to interpret them. Applied after POINTER_MASK. EXPERIMENTAL. See also the preceding macro. ENABLE_TRACE Enables the GC_TRACE=addr environment setting to do its job. By default this is not supported in order to keep the marker as fast as possible. DARWIN_DONT_PARSE_STACK Causes the Darwin port to discover thread stack bounds in the same way as other pthread ports, without trying to walk the frames on the stack. This is recommended only as a fall-back for applications that don't support proper stack unwinding. GC_NO_THREADS_DISCOVERY (Darwin and Win32+DLL only) Exclude DllMain-based (on Windows) and task-threads-based (on Darwin) thread registration support. GC_INSIDE_DLL (Win32 only) Enable DllMain-based approach of threads registering even in case GC_DLL is not defined. GC_DISCOVER_TASK_THREADS (Darwin and Win32+DLL only) Compile the collector with the implicitly turned on task-threads-based (on Darwin) or DllMain-based (on Windows) approach of threads registering. Only for compatibility and for the case when it is not possible to call GC_use_threads_discovery() early (before other GC calls). USE_PROC_FOR_LIBRARIES Causes the Linux collector to treat writable memory mappings (as reported by /proc) as roots, if it doesn't have other information about them. It no longer traverses dynamic loader data structures to find dynamic library static data. This may be required for applications that store pointers in mmapped segments without informing the collector. But it typically performs poorly, especially since it will scan inactive but cached NPTL thread stacks completely. IGNORE_DYNAMIC_LOADING Don't define DYNAMIC_LOADING even if supported by the platform (that is, build the collector with disabled tracing of dynamic library data roots). NO_PROC_STAT Causes the collector to avoid relying on Linux "/proc/self/stat". NO_GETCONTEXT Causes the collector to not assume the existence of the getcontext() function on linux-like platforms. This currently happens implicitly on Darwin, Hurd, or ARM or MIPS hardware. It is explicitly needed for some old versions of FreeBSD. STATIC=static Causes various GC_ symbols that could logically be declared static to be declared (this is the default if NO_DEBUGGING is specified). Reduces the number of visible symbols (letting the optimizer do its work better), which is probably cleaner, but may make some kinds of debugging and profiling harder. GC_DLL Build dynamic-link library (or dynamic shared object). For Unix this causes the exported symbols to have 'default' visibility (ignored unless GCC v4+) and the internal ones to have 'hidden' visibility. DONT_USE_USER32_DLL (Win32 only) Don't use "user32" DLL import library (containing MessageBox() entry); useful for a static GC library. GC_PREFER_MPROTECT_VDB Choose MPROTECT_VDB manually in case of multiple virtual dirty bit strategies are implemented (at present useful on Win32 and Solaris to force MPROTECT_VDB strategy instead of the default GWW_VDB or PROC_VDB ones). GC_IGNORE_GCJ_INFO Disable GCJ-style type information (useful for debugging on WinCE). GC_PRINT_VERBOSE_STATS Permanently turn on verbose logging (useful for debugging and profiling on WinCE). GC_ONLY_LOG_TO_FILE Don't redirect GC stdout and stderr to the log file specified by GC_LOG_FILE environment variable. Has effect only when the variable is set (to anything other than "0"). GC_ANDROID_LOG (Android only) Output error/debug information to Android log. GC_DONT_EXPAND Don't expand the heap unless explicitly requested or forced to. GC_USE_ENTIRE_HEAP Causes the non-incremental collector to use the entire heap before collecting. This sometimes results in more large block fragmentation, since very large blocks will tend to get broken up during each GC cycle. It is likely to result in a larger working set, but lower collection frequencies, and hence fewer instructions executed in the collector. This macro controls only the default GC_use_entire_heap value. GC_INITIAL_HEAP_SIZE= Set the desired default initial heap size in bytes. GC_FREE_SPACE_DIVISOR= Set alternate default GC_free_space_divisor value. GC_TIME_LIMIT= Set alternate default GC_time_limit value (setting this to GC_TIME_UNLIMITED will essentially disable incremental collection while leaving generational collection enabled). GC_FULL_FREQ= Set alternate default number of partial collections between full collections (matters only if incremental collection is on). NO_CANCEL_SAFE (Posix platforms with threads only) Don't bother trying to make the collector safe for thread cancellation; cancellation is not used. (Note that if cancellation is used anyway, threads may end up getting cancelled in unexpected places.) Even without this option, PTHREAD_CANCEL_ASYNCHRONOUS is never safe with the collector. (We could argue about its safety without the collector.) UNICODE (Win32 only) Use the Unicode variant ('W') of the Win32 API instead of ANSI/ASCII one ('A'). Useful for WinCE. PLATFORM_ANDROID (or __ANDROID__) Compile for Android NDK platform. SN_TARGET_PS3 Compile for Sony PS/3. USE_GET_STACKBASE_FOR_MAIN (Linux only) Use pthread_attr_getstack() instead of __libc_stack_end (or instead of any hard-coded value) for getting the primordial thread stack base (useful if the client modifies the program's address space). ecl-16.1.2/src/bdwgc/doc/README.rs6000000066400000000000000000000007751266352375300166240ustar00rootroot00000000000000We have so far failed to find a good way to determine the stack base. It is highly recommended that GC_stackbottom be set explicitly on program startup. The supplied value sometimes causes failure under AIX 4.1, though it appears to work under 3.X. HEURISTIC2 seems to work under 4.1, but involves a substantial performance penalty, and will fail if there is no limit on stack size. There is no thread support. (I assume recent versions of AIX provide pthreads? I no longer have access to a machine ...) ecl-16.1.2/src/bdwgc/doc/README.sgi000066400000000000000000000034601266352375300164460ustar00rootroot00000000000000Performance of the incremental collector can be greatly enhanced with -DNO_EXECUTE_PERMISSION. The collector should run with all of the -32, -n32 and -64 ABIs. Remember to define the AS macro in the Makefile to be "as -64", or "as -n32". If you use -DREDIRECT_MALLOC=GC_malloc with C++ code, your code should make at least one explicit call to malloc instead of new to ensure that the proper version of malloc is linked in. Sproc threads are not supported in this version, though there may exist other ports. Pthreads support is provided. This requires that: 1) You compile the collector with -DGC_IRIX_THREADS specified in the Makefile. 2) You have the latest pthreads patches installed. (Though the collector makes only documented pthread calls, it relies on signal/threads interactions working just right in ways that are not required by the standard. It is unlikely that this code will run on other pthreads platforms. But please tell me if it does.) 3) Every file that makes thread calls should define IRIX_THREADS and then include gc.h. Gc.h redefines some of the pthread primitives as macros which also provide the collector with information it requires. 4) pthread_cond_wait and pthread_cond_timed_wait should be prepared for premature wakeups. (I believe the pthreads and realted standards require this anyway. Irix pthreads often terminate a wait if a signal arrives. The garbage collector uses signals to stop threads.) 5) It is expensive to stop a thread waiting in IO at the time the request is initiated. Applications with many such threads may not exhibit acceptable performance with the collector. (Increasing the heap size may help.) 6) The collector should not be compiled with -DREDIRECT_MALLOC. This confuses some library calls made by the pthreads implementation, which expect the standard malloc. ecl-16.1.2/src/bdwgc/doc/README.solaris2000066400000000000000000000076011266352375300174230ustar00rootroot00000000000000The collector supports both incremental collection and threads under Solaris 2. The incremental collector normally retrieves page dirty information through the appropriate /proc calls. But it can also be configured (by defining MPROTECT_VDB instead of PROC_VDB in gcconfig.h) to use mprotect and signals. This may result in shorter pause times, but it is no longer safe to issue arbitrary system calls that write to the heap. Under other UNIX versions, the collector normally obtains memory through sbrk. There is some reason to expect that this is not safe if the client program also calls the system malloc, or especially realloc. The sbrk man page strongly suggests this is not safe: "Many library routines use malloc() internally, so use brk() and sbrk() only when you know that malloc() definitely will not be used by any library routine." This doesn't make a lot of sense to me, since there seems to be no documentation as to which routines can transitively call malloc. Nonetheless, under Solaris2, the collector now allocates memory using mmap by default. (It defines USE_MMAP in gcconfig.h.) You may want to reverse this decisions if you use -DREDIRECT_MALLOC=... Note: Before you run "make check", you need to set your LD_LIBRARY_PATH correctly (e.g., to "/usr/local/lib") so that tests can find the shared library libgcc_s.so.1. Alternatively, you can configure with --disable-shared. SOLARIS THREADS: Threads support is enabled by configure "--enable-threads=posix" option. (In case of GCC compiler, multi-threading support is on by default.) This causes the collector to be compiled with -D GC_THREADS (or -D GC_SOLARIS_THREADS) ensuring thread safety. This assumes use of the pthread_ interface. Old style Solaris threads are no longer supported. Thread-local allocation is now on by default. Parallel marking is on by default starting from GC v7.3 but it could be enabled or disabled manually by the corresponding "--enable/disable-parallel-mark" options. It is also essential that gc.h be included in files that call pthread_create, pthread_join, pthread_detach, or dlopen. gc.h macro defines these to also do GC bookkeeping, etc. gc.h must be included with one or both of these macros defined, otherwise these replacements are not visible. A collector built in this way way only be used by programs that are linked with the threads library. Since 5.0 alpha5, dlopen disables collection temporarily, unless USE_PROC_FOR_LIBRARIES is defined. In some unlikely cases, this can result in unpleasant heap growth. But it seems better than the race/deadlock issues we had before. If threads are used on an X86 processor with malloc redirected to GC_malloc, it is necessary to call GC_INIT explicitly before forking the first thread. (This avoids a deadlock arising from calling GC_thr_init with the allocation lock held.) It appears that there is a problem in using gc_cpp.h in conjunction with Solaris threads and Sun's C++ runtime. Apparently the overloaded new operator is invoked by some iostream initialization code before threads are correctly initialized. As a result, call to thr_self() in garbage collector initialization SEGV faults. Currently the only known workaround is to not invoke the garbage collector from a user defined global operator new, or to have it invoke the garbage-collector's allocators only after main has started. (Note that the latter requires a moderately expensive test in operator delete.) I encountered "symbol : offet .... is non-aligned" errors. These appear to be traceable to the use of the GNU assembler with the Sun linker. The former appears to generate a relocation not understood by the latter. The fix appears to be to use a consistent tool chain. (As a non-Solaris-expert my solution involved hacking the libtool script, but I'm sure you can do something less ugly.) Hans-J. Boehm (The above contains my personal opinions, which are probably not shared by anyone else.) ecl-16.1.2/src/bdwgc/doc/README.symbian000066400000000000000000000011141266352375300173200ustar00rootroot00000000000000Instructions for Symbian: 1. base version: libgc 7.1 2. Build: use libgc.mmp 3. Limitations 3.1.No multi-threaded support 3.2. Be careful with limitation that emulator introduces: Static roots are not dynamically accessible (there are Symbian APIs for this purpose but are just stubs, returning irrelevant values). Consequently, on emulator, you can only use dlls or exe, and retrieve static roots by calling global_init_static_root per dll (or exe). On target, only libs are supported, because static roots are retrieved by linker flags, by calling global_init_static_root in main exe. ecl-16.1.2/src/bdwgc/doc/README.uts000066400000000000000000000001261266352375300164730ustar00rootroot00000000000000Alistair Crooks supplied the port. He used Lexa C version 2.1.3 with -Xa to compile. ecl-16.1.2/src/bdwgc/doc/README.win32000066400000000000000000000235121266352375300166260ustar00rootroot00000000000000The collector has at various times been compiled under Windows 95 & later, NT, and XP, with the original Microsoft SDK, with Visual C++ 2.0, 4.0, and 6, with the GNU win32 tools, with Borland 4.5, with Watcom C, and recently with the Digital Mars compiler. It is likely that some of these have been broken in the meantime. Patches are appreciated. For historical reasons, the collector test program "gctest" is linked as a GUI application, but does not open any windows. Its output normally appears in the file "gctest.gc.log". It may be started from the file manager. The hour glass cursor may appear as long as it's running. If it is started from the command line, it will usually run in the background. Wait a few minutes (a few seconds on a modern machine) before you check the output. You should see either a failure indication or a "Collector appears to work" message. The cord test program has not been ported (but should port easily). A toy editor (cord/de.exe) based on cords (heavyweight strings represented as trees) has been ported and is included. It runs fine under either win32 or win32S. It serves as an example of a true Windows application, except that it was written by a nonexpert Windows programmer. (There are some peculiarities in the way files are displayed. The is displayed explicitly for standard DOS text files. As in the UNIX version, control characters are displayed explicitly, but in this case as red text. This may be suboptimal for some tastes and/or sets of default window colors.) In general -DREDIRECT_MALLOC is unlikely to work unless the application is completely statically linked. The collector normally allocates memory from the OS with VirtualAlloc. This appears to cause problems under Windows NT and Windows 2000 (but not Windows 95/98) if the memory is later passed to CreateDIBitmap. To work around this problem, build the collector with -DUSE_GLOBAL_ALLOC. This is currently incompatible with -DUSE_MUNMAP. (Thanks to Jonathan Clark for tracking this down. There's some chance this may be fixed in 6.1alpha4, since we now separate heap sections with an unused page.) [Threads and incremental collection are discussed near the end, below.] Microsoft Tools --------------- For Microsoft development tools, rename NT_MAKEFILE as MAKEFILE. (Make sure that the CPU environment variable is defined to be i386.) In order to use the gc_cpp.h C++ interface, all client code should include gc_cpp.h. For historical reasons, the collector test program "gctest" is linked as a GUI application, but does not open any windows. Its output appears in the file "gctest.gc.log". It may be started from the file manager. The hour glass cursor may appear as long as it's running. If it is started from the command line, it will usually run in the background. Wait a few minutes (a few seconds on a modern machine) before you check the output. You should see either a failure indication or a "Collector appears to work" message. If you would prefer a VC++ .NET project file, ask Hans Boehm. One has been contributed, but it seems to contain some absolute paths etc., so it can presumably only be a starting point, and is not in the standard distribution. It is unclear (to me, Hans Boehm) whether it is feasible to change that. Clients may need to define GC_NOT_DLL before including gc.h, if the collector was built as a static library (as it normally is in the absence of thread support). GNU Tools --------- The collector should be buildable under Cygwin with the "./configure; make check" machinery. MinGW builds (including for x86_64) are available via cross-compilation, e.g. "./configure --host=i686-pc-mingw32; make check" To build the collector as a DLL, pass "--enable-shared --disable-static" to configure (this will instruct make compile with -D GC_DLL). Parallel marker could be enabled via "--enable-parallel-mark". Memory unmapping could be enabled via "--enable-munmap". Borland Tools ------------- [Rarely tested.] For Borland tools, use BCC_MAKEFILE. Note that Borland's compiler defaults to 1 byte alignment in structures (-a1), whereas Visual C++ appears to default to 8 byte alignment (/Zp8). The garbage collector in its default configuration EXPECTS AT LEAST 4 BYTE ALIGNMENT. Thus the BORLAND DEFAULT MUST BE OVERRIDDEN. (In my opinion, it should usually be anyway. I expect that -a1 introduces major performance penalties on a 486 or Pentium.) Note that this changes structure layouts. (As a last resort, gcconfig.h can be changed to allow 1 byte alignment. But this has significant negative performance implications.) The Makefile is set up to assume Borland 4.5. If you have another version, change the line near the top. By default, it does not require the assembler. If you do have the assembler, I recommend removing the -DUSE_GENERIC. Digital Mars compiler --------------------- Same as MS Visual C++ but might require -DAO_OLD_STYLE_INTERLOCKED_COMPARE_EXCHANGE option to compile with the parallel marker enabled. Watcom compiler --------------- Ivan V. Demakov's README for the Watcom port: The collector has been compiled with Watcom C 10.6 and 11.0. It runs under win32, win32s, and even under msdos with dos4gw dos-extender. It should also run under OS/2, though this isn't tested. Under win32 the collector can be built either as dll or as static library. Note that all compilations were done under Windows 95 or NT. For unknown reason compiling under Windows 3.11 for NT (one attempt has been made) leads to broken executables. Incremental collection is not supported. cord is not ported. Before compiling you may need to edit WCC_MAKEFILE to set target platform, library type (dynamic or static), calling conventions, and optimization options. To compile the collector and testing programs use the command: wmake -f WCC_MAKEFILE All programs using gc should be compiled with 4-byte alignment. For further explanations on this see comments about Borland. If the gc is compiled as dll, the macro "GC_DLL" should be defined before including "gc.h" (for example, with -DGC_DLL compiler option). It's important, otherwise resulting programs will not run. Special note for OpenWatcom users: the C (unlike the C++) compiler (of the latest stable release, not sure for older ones) doesn't force pointer global variables (i.e. not struct fields, not sure for locals) to be aligned unless optimizing for speed (e.g., "-ot" option is set); the "-zp" option (or align pragma) only controls alignment for structs; I don't know whether it's a bug or a feature (see an old report of same kind - http://bugzilla.openwatcom.org/show_bug.cgi?id=664), so You are warned. Incremental Collection ---------------------- There is some support for incremental collection. By default, the collector chooses between explicit page protection, and GetWriteWatch-based write tracking automatically, depending on the platform. The former is slow and interacts poorly with a debugger. Pages are protected. Protection faults are caught by a handler installed at the bottom of the handler stack. Whenever possible, I recommend adding a call to GC_enable_incremental at the last possible moment, after most debugging is complete. No system calls are wrapped by the collector itself. It may be necessary to wrap ReadFile calls that use a buffer in the heap, so that the call does not encounter a protection fault while it's running. (As usual, none of this is an issue unless GC_enable_incremental is called.) Note that incremental collection is disabled with -DSMALL_CONFIG. Threads ------- This version of the collector by default handles threads similarly to other platforms. James Clark's code which tracks threads attached to the collector DLL still exists, but requires that both - the collector is built in a DLL with GC_DLL defined, and - GC_use_threads_discovery() is called before GC initialization, which in turn must happen before creating additional threads. We generally recommend avoiding this if possible, since it seems to be less than 100% reliable. Use gc.mak (a.k.a NT_THREADS_MAKEFILE) instead of NT_MAKEFILE to build a version that supports both kinds of thread tracking. To build the garbage collector test with VC++ from the command line, use nmake /F ".\gc.mak" CFG="gctest - Win32 Release" This requires that the subdirectory gctest\Release exist. The test program and DLL will reside in the Release directory. This version currently supports incremental collection only if it is enabled before any additional threads are created. Since 6.3alpha2, threads are also better supported in static library builds with Microsoft tools (use NT_STATIC_THREADS_MAKEFILE) and with the GNU tools. The collector must be built with GC_THREADS defined. (NT_STATIC_THREADS_MAKEFILE does this implicitly. Under Cygwin, ./configure --enable-threads=posix should be used.) For the normal, non-dll-based thread tracking to work properly, threads should be created with GC_CreateThread or GC_beginthreadex, and exit normally or call GC_endthreadex or GC_ExitThread. (For Cygwin, use standard pthread calls instead.) As in the pthread case, including gc.h will redefine CreateThread, _beginthreadex, _endthreadex, and ExitThread to call the GC_ versions instead. Note that, as usual, GC_CreateThread tends to introduce resource leaks that are avoided by GC_beginthreadex. There is currently no equivalent of _beginthread, and it should not be used. GC_INIT should be called from the main executable before other GC calls. We strongly advise against using the TerminateThread() win32 API call, especially with the garbage collector. Any use is likely to provoke a crash in the GC, since it makes it impossible for the collector to correctly track threads. To build the collector for MinGW pthreads-win32 (or other non-Cygwin pthreads implementation for Windows), use Makefile.direct and explicitly set GC_WIN32_PTHREADS (or pass --enable-threads=pthreads to configure). Use -DPTW32_STATIC_LIB for the static threads library. ecl-16.1.2/src/bdwgc/doc/README.win64000066400000000000000000000022261266352375300166320ustar00rootroot0000000000000064-bit Windows on AMD64/Intel EM64T is somewhat supported in the 7.0 and later release. A collector can be built with Microsoft Visual C++ 2005 or with mingw-w64 gcc. More testing would clearly be helpful. NT_X64_STATIC_THREADS_MAKEFILE has been used in this environment. Copy this file to MAKEFILE, and then type "nmake" in a Visual C++ command line window to build the static library and the usual test programs. To verify that the collector is at least somewhat functional, run gctest.exe. This should create gctest.gc.log after a few seconds. This process is completely analogous to NT_STATIC_THREADS_MAKEFILE for the 32-bit version. A similar procedure using NT_X64_THREADS_MAKEFILE should be usable to build the dynamic library. Test_cpp.exe did not seem to run correctly this way. It seems that we're getting the wrong instances of operator new/delete in some cases. The C tests seemed OK. Note that currently a few warnings are still generated by default, and a number of others have been explicitly turned off in the makefile. VC++ note: to suppress warnings use -D_CRT_SECURE_NO_DEPRECATE. gcc note: -fno-strict-aliasing should be used if optimizing. ecl-16.1.2/src/bdwgc/doc/debugging.html000066400000000000000000000370141266352375300176300ustar00rootroot00000000000000 Debugging Garbage Collector Related Problems

Debugging Garbage Collector Related Problems

This page contains some hints on debugging issues specific to the Boehm-Demers-Weiser conservative garbage collector. It applies both to debugging issues in client code that manifest themselves as collector misbehavior, and to debugging the collector itself.

If you suspect a bug in the collector itself, it is strongly recommended that you try the latest collector release before proceeding.

Bus Errors and Segmentation Violations

If the fault occurred in GC_find_limit, or with incremental collection enabled, this is probably normal. The collector installs handlers to take care of these. You will not see these unless you are using a debugger. Your debugger should allow you to continue. It's often preferable to tell the debugger to ignore SIGBUS and SIGSEGV ("handle SIGSEGV SIGBUS nostop noprint" in gdb, "ignore SIGSEGV SIGBUS" in most versions of dbx) and set a breakpoint in abort. The collector will call abort if the signal had another cause, and there was not other handler previously installed.

We recommend debugging without incremental collection if possible. (This applies directly to UNIX systems. Debugging with incremental collection under win32 is worse. See README.win32.)

If the application generates an unhandled SIGSEGV or equivalent, it may often be easiest to set the environment variable GC_LOOP_ON_ABORT. On many platforms, this will cause the collector to loop in a handler when the SIGSEGV is encountered (or when the collector aborts for some other reason), and a debugger can then be attached to the looping process. This sidesteps common operating system problems related to incomplete core files for multi-threaded applications, etc.

Other Signals

On most platforms, the multi-threaded version of the collector needs one or two other signals for internal use by the collector in stopping threads. It is normally wise to tell the debugger to ignore these. On Linux, the collector currently uses SIGPWR and SIGXCPU by default.

Warning Messages About Needing to Allocate Blacklisted Blocks

The garbage collector generates warning messages of the form 
Needed to allocate blacklisted block at 0x...
or 
Repeated allocation of very large block ...
when it needs to allocate a block at a location that it knows to be referenced by a false pointer. These false pointers can be either permanent (e.g. a static integer variable that never changes) or temporary. In the latter case, the warning is largely spurious, and the block will eventually be reclaimed normally. In the former case, the program will still run correctly, but the block will never be reclaimed. Unless the block is intended to be permanent, the warning indicates a memory leak.
  1. Ignore these warnings while you are using GC_DEBUG. Some of the routines mentioned below don't have debugging equivalents. (Alternatively, write the missing routines and send them to me.)
  2. Replace allocator calls that request large blocks with calls to GC_malloc_ignore_off_page or GC_malloc_atomic_ignore_off_page. You may want to set a breakpoint in GC_default_warn_proc to help you identify such calls. Make sure that a pointer to somewhere near the beginning of the resulting block is maintained in a (preferably volatile) variable as long as the block is needed.
  3. If the large blocks are allocated with realloc, we suggest instead allocating them with something like the following. Note that the realloc size increment should be fairly large (e.g. a factor of 3/2) for this to exhibit reasonable performance. But we all know we should do that anyway. 
    void * big_realloc(void *p, size_t new_size)
{
    size_t old_size = GC_size(p);
    void * result;

    if (new_size <= 10000) return(GC_realloc(p, new_size));
    if (new_size <= old_size) return(p);
    result = GC_malloc_ignore_off_page(new_size);
    if (result == 0) return(0);
    memcpy(result,p,old_size);
    GC_free(p);
    return(result);
}
  4. In the unlikely case that even relatively small object (<20KB) allocations are triggering these warnings, then your address space contains lots of "bogus pointers", i.e. values that appear to be pointers but aren't. Usually this can be solved by using GC_malloc_atomic or the routines in gc_typed.h to allocate large pointer-free regions of bitmaps, etc. Sometimes the problem can be solved with trivial changes of encoding in certain values. It is possible, to identify the source of the bogus pointers by building the collector with -DPRINT_BLACK_LIST, which will cause it to print the "bogus pointers", along with their location.
  5. If you get only a fixed number of these warnings, you are probably only introducing a bounded leak by ignoring them. If the data structures being allocated are intended to be permanent, then it is also safe to ignore them. The warnings can be turned off by calling GC_set_warn_proc with a procedure that ignores these warnings (e.g. by doing absolutely nothing).

The Collector References a Bad Address in GC_malloc

This typically happens while the collector is trying to remove an entry from its free list, and the free list pointer is bad because the free list link in the last allocated object was bad.

With > 99% probability, you wrote past the end of an allocated object. Try setting GC_DEBUG before including gc.h and allocating with GC_MALLOC. This will try to detect such overwrite errors.

Unexpectedly Large Heap

Unexpected heap growth can be due to one of the following:
  1. Data structures that are being unintentionally retained. This is commonly caused by data structures that are no longer being used, but were not cleared, or by caches growing without bounds.
  2. Pointer misidentification. The garbage collector is interpreting integers or other data as pointers and retaining the "referenced" objects. A common symptom is that GC_dump() shows much of the heap as black-listed.
  3. Heap fragmentation. This should never result in unbounded growth, but it may account for larger heaps. This is most commonly caused by allocation of large objects. On some platforms it can be reduced by building with -DUSE_MUNMAP, which will cause the collector to unmap memory corresponding to pages that have not been recently used.
  4. Per object overhead. This is usually a relatively minor effect, but it may be worth considering. If the collector recognizes interior pointers, object sizes are increased, so that one-past-the-end pointers are correctly recognized. The collector can be configured not to do this (-DDONT_ADD_BYTE_AT_END).

    The collector rounds up object sizes so the result fits well into the chunk size (HBLKSIZE, normally 4K on 32 bit machines, 8K on 64 bit machines) used by the collector. Thus it may be worth avoiding objects of size 2K + 1 (or 2K if a byte is being added at the end.)

The last two cases can often be identified by looking at the output of a call to GC_dump(). Among other things, it will print the list of free heap blocks, and a very brief description of all chunks in the heap, the object sizes they correspond to, and how many live objects were found in the chunk at the last collection.

Growing data structures can usually be identified by

  1. Building the collector with -DKEEP_BACK_PTRS,
  2. Preferably using debugging allocation (defining GC_DEBUG before including gc.h and allocating with GC_MALLOC), so that objects will be identified by their allocation site,
  3. Running the application long enough so that most of the heap is composed of "leaked" memory, and
  4. Then calling GC_generate_random_backtrace() from backptr.h a few times to determine why some randomly sampled objects in the heap are being retained.

The same technique can often be used to identify problems with false pointers, by noting whether the reference chains printed by GC_generate_random_backtrace() involve any misidentified pointers. An alternate technique is to build the collector with -DPRINT_BLACK_LIST which will cause it to report values that are almost, but not quite, look like heap pointers. It is very likely that actual false pointers will come from similar sources.

In the unlikely case that false pointers are an issue, it can usually be resolved using one or more of the following techniques:

  1. Use GC_malloc_atomic for objects containing no pointers. This is especially important for large arrays containing compressed data, pseudo-random numbers, and the like. It is also likely to improve GC performance, perhaps drastically so if the application is paging.
  2. If you allocate large objects containing only one or two pointers at the beginning, either try the typed allocation primitives is gc_typed.h, or separate out the pointer-free component.
  3. Consider using GC_malloc_ignore_off_page() to allocate large objects. (See gc.h and above for details. Large means > 100K in most environments.)
  4. If your heap size is larger than 100MB or so, build the collector with -DLARGE_CONFIG. This allows the collector to keep more precise black-list information.
  5. If you are using heaps close to, or larger than, a gigabyte on a 32-bit machine, you may want to consider moving to a platform with 64-bit pointers. This is very likely to resolve any false pointer issues.

Prematurely Reclaimed Objects

The usual symptom of this is a segmentation fault, or an obviously overwritten value in a heap object. This should, of course, be impossible. In practice, it may happen for reasons like the following:
  1. The collector did not intercept the creation of threads correctly in a multi-threaded application, e.g. because the client called pthread_create without including gc.h, which redefines it.
  2. The last pointer to an object in the garbage collected heap was stored somewhere were the collector couldn't see it, e.g. in an object allocated with system malloc, in certain types of mmaped files, or in some data structure visible only to the OS. (On some platforms, thread-local storage is one of these.)
  3. The last pointer to an object was somehow disguised, e.g. by XORing it with another pointer.
  4. Incorrect use of GC_malloc_atomic or typed allocation.
  5. An incorrect GC_free call.
  6. The client program overwrote an internal garbage collector data structure.
  7. A garbage collector bug.
  8. (Empirically less likely than any of the above.) A compiler optimization that disguised the last pointer.
The following relatively simple techniques should be tried first to narrow down the problem:
  1. If you are using the incremental collector try turning it off for debugging.
  2. If you are using shared libraries, try linking statically. If that works, ensure that DYNAMIC_LOADING is defined on your platform.
  3. Try to reproduce the problem with fully debuggable unoptimized code. This will eliminate the last possibility, as well as making debugging easier.
  4. Try replacing any suspect typed allocation and GC_malloc_atomic calls with calls to GC_malloc.
  5. Try removing any GC_free calls (e.g. with a suitable #define).
  6. Rebuild the collector with -DGC_ASSERTIONS.
  7. If the following works on your platform (i.e. if gctest still works if you do this), try building the collector with -DREDIRECT_MALLOC=GC_malloc_uncollectable. This will cause the collector to scan memory allocated with malloc.
If all else fails, you will have to attack this with a debugger. Suggested steps:
  1. Call GC_dump() from the debugger around the time of the failure. Verify that the collectors idea of the root set (i.e. static data regions which it should scan for pointers) looks plausible. If not, i.e. if it doesn't include some static variables, report this as a collector bug. Be sure to describe your platform precisely, since this sort of problem is nearly always very platform dependent.
  2. Especially if the failure is not deterministic, try to isolate it to a relatively small test case.
  3. Set a break point in GC_finish_collection. This is a good point to examine what has been marked, i.e. found reachable, by the collector.
  4. If the failure is deterministic, run the process up to the last collection before the failure. Note that the variable GC_gc_no counts collections and can be used to set a conditional breakpoint in the right one. It is incremented just before the call to GC_finish_collection. If object p was prematurely recycled, it may be helpful to look at *GC_find_header(p) at the failure point. The hb_last_reclaimed field will identify the collection number during which its block was last swept.
  5. Verify that the offending object still has its correct contents at this point. Then call GC_is_marked(p) from the debugger to verify that the object has not been marked, and is about to be reclaimed. Note that GC_is_marked(p) expects the real address of an object (the address of the debug header if there is one), and thus it may be more appropriate to call GC_is_marked(GC_base(p)) instead.
  6. Determine a path from a root, i.e. static variable, stack, or register variable, to the reclaimed object. Call GC_is_marked(q) for each object q along the path, trying to locate the first unmarked object, say r.
  7. If r is pointed to by a static root, verify that the location pointing to it is part of the root set printed by GC_dump(). If it is on the stack in the main (or only) thread, verify that GC_stackbottom is set correctly to the base of the stack. If it is in another thread stack, check the collector's thread data structure (GC_thread[] on several platforms) to make sure that stack bounds are set correctly.
  8. If r is pointed to by heap object s, check that the collector's layout description for s is such that the pointer field will be scanned. Call *GC_find_header(s) to look at the descriptor for the heap chunk. The hb_descr field specifies the layout of objects in that chunk. See gc_mark.h for the meaning of the descriptor. (If it's low order 2 bits are zero, then it is just the length of the object prefix to be scanned. This form is always used for objects allocated with GC_malloc or GC_malloc_atomic.)
  9. If the failure is not deterministic, you may still be able to apply some of the above technique at the point of failure. But remember that objects allocated since the last collection will not have been marked, even if the collector is functioning properly. On some platforms, the collector can be configured to save call chains in objects for debugging. Enabling this feature will also cause it to save the call stack at the point of the last GC in GC_arrays._last_stack.
  10. When looking at GC internal data structures remember that a number of GC_xxx variables are really macro defined to GC_arrays._xxx, so that the collector can avoid scanning them.
ecl-16.1.2/src/bdwgc/doc/doc.am000066400000000000000000000027231266352375300160720ustar00rootroot00000000000000# # THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED # OR IMPLIED. ANY USE IS AT YOUR OWN RISK. # # Permission is hereby granted to use or copy this program # for any purpose, provided the above notices are retained on all copies. # Permission to modify the code and to distribute modified code is granted, # provided the above notices are retained, and a notice that the code was # modified is included with the above copyright notice. ## Process this file with automake to produce Makefile.in. # installed documentation # dist_pkgdata_DATA = \ AUTHORS \ README.md \ doc/README.DGUX386 \ doc/README.Mac \ doc/README.OS2 \ doc/README.amiga \ doc/README.arm.cross \ doc/README.autoconf \ doc/README.cmake \ doc/README.cords \ doc/README.darwin \ doc/README.environment \ doc/README.ews4800 \ doc/README.hp \ doc/README.linux \ doc/README.macros \ doc/README.rs6000 \ doc/README.sgi \ doc/README.solaris2 \ doc/README.symbian \ doc/README.uts \ doc/README.win32 \ doc/README.win64 \ doc/debugging.html \ doc/finalization.html \ doc/gc.man \ doc/gcdescr.html \ doc/gcinterface.html \ doc/leak.html \ doc/overview.html \ doc/porting.html \ doc/scale.html \ doc/simple_example.html \ doc/tree.html ecl-16.1.2/src/bdwgc/doc/finalization.html000066400000000000000000000225261266352375300203660ustar00rootroot00000000000000 Finalization in the Boehm-Demers-Weiser collector

Finalization

Many garbage collectors provide a facility for executing user code just before an object is collected. This can be used to reclaim any system resources or non-garbage-collected memory associated with the object. Experience has shown that this can be a useful facility. It is indispensable in cases in which system resources are embedded in complex data structures (e.g. file descriptors in the cord package).

Our collector provides the necessary functionality through GC_register_finalizer in gc.h, or by inheriting from gc_cleanup in gc_cpp.h.

However, finalization should not be used in the same way as C++ destructors. In well-written programs there will typically be very few uses of finalization. (Garbage collected programs that interact with explicitly memory-managed libraries may be an exception.)

In general the following guidelines should be followed:

  • Actions that must be executed promptly do not belong in finalizers. They should be handled by explicit calls in the code (or C++ destructors if you prefer). If you expect the action to occur at a specific point, this is probably not hard.
  • Finalizers are intended for resource reclamation.
  • Scarce system resources should be managed explicitly whenever convenient. Use finalizers only as a backup mechanism for the cases that would be hard to handle explicitly.
  • If scarce resources are managed with finalization, the allocation routine for that resource (e.g. open for file handles) should force a garbage collection (two if that doesn't suffice) if it finds itself short of the resource.
  • If extremely scarce resources are managed by finalization (e.g. file descriptors on systems which have a limit of 20 open files), it may be necessary to introduce a descriptor caching scheme to hide the resource limit. (E.g., the program would keep real file descriptors for the 20 most recently used logically open files. Any other needed files would be closed after saving their state. They would then be reopened on demand. Finalization would logically close the file, closing the real descriptor only if it happened to be cached.) Note that most modern systems (e.g. Irix®) allow hundreds or thousands of open files, and this is typically not an issue.
  • Finalization code may be run anyplace an allocation or other call to the collector takes place. In multi-threaded programs, finalizers have to obey the normal locking conventions to ensure safety. Code run directly from finalizers should not acquire locks that may be held during allocation. This restriction can be easily circumvented by registering a finalizer which enqueues the real action for execution in a separate thread.

    In single-threaded code, it is also often easiest to have finalizers queue actions, which are then explicitly run during an explicit call by the user's program.

Topologically Ordered Finalization

Our conservative garbage collector supports a form of finalization (with GC_register_finalizer) in which objects are finalized in topological order. If A points to B, and both are registered for finalization, it is guaranteed the A will be finalized first. This usually guarantees that finalization procedures see only unfinalized objects.

This decision is often questioned, particularly since it has an obvious disadvantage. The current implementation finalizes long chains of finalizable objects one per collection. This is hard to avoid, since the first finalizer invoked may store a pointer to the rest of the chain in a global variable, making it accessible again. Or it may mutate the rest of the chain.

Cycles involving one or more finalizable objects are never finalized.

Why topological ordering?

It is important to keep in mind that the choice of finalization ordering matters only in relatively rare cases. In spite of the fact that it has received a lot of discussion, it is not one of the more important decisions in designing a system. Many, especially smaller, applications will never notice the difference. Nonetheless, we believe that topologically ordered finalization is the right choice.

To understand the justification, observe that if As finalization procedure does not refer to B, we could fairly easily have avoided the dependency. We could have split A into A' and A'' such that any references to A become references to A', A' points to A'' but not vice-versa, only fields needed for finalization are stored in A'', and A'' is enabled for finalization. (GC_register_disappearing_link provides an alternative mechanism that does not require breaking up objects.)

Thus assume that A actually does need access to B during finalization. To make things concrete, assume that B is finalizable because it holds a pointer to a C object, which must be explicitly deallocated. (This is likely to be one of the most common uses of finalization.) If B happens to be finalized first, A will see a dangling pointer during its finalization. But a principal goal of garbage collection was to avoid dangling pointers.

Note that the client program could enforce topological ordering even if the system didn't. A pointer to B could be stored in some globally visible place, where it is cleared only by As finalizer. But this puts the burden to ensure safety back on the programmer.

With topologically ordered finalization, the programmer can fail to split an object, thus leaving an accidental cycle. This results in a leak, which is arguably less dangerous than a dangling pointer. More importantly, it is much easier to diagnose, since the garbage collector would have to go out of its way not to notice finalization cycles. It can trivially report them.

Furthermore unordered finalization does not really solve the problem of cycles. Consider the above case in which As finalization procedure depends on B, and thus a pointer to B is stored in a global data structure, to be cleared by As finalizer. If there is an accidental pointer from B back to A, and thus a cycle, neither B nor A will become unreachable. The leak is there, just as in the topologically ordered case, but it is hidden from easy diagnosis.

A number of alternative finalization orderings have been proposed, e.g. based on statically assigned priorities. In our opinion, these are much more likely to require complex programming discipline to use in a large modular system. (Some of them, e.g. Guardians proposed by Dybvig, Bruggeman, and Eby, do avoid some problems which arise in combination with certain other collection algorithms.)

Fundamentally, a garbage collector assumes that objects reachable via pointer chains may be accessed, and thus should be preserved. Topologically ordered finalization simply extends this to object finalization; an finalizable object reachable from another finalizer via a pointer chain is presumed to be accessible by the finalizer, and thus should not be finalized.

Programming with topological finalization

Experience with Cedar has shown that cycles or long chains of finalizable objects are typically not a problem. Finalizable objects are typically rare. There are several ways to reduce spurious dependencies between finalizable objects. Splitting objects as discussed above is one technique. The collector also provides GC_register_disappearing_link, which explicitly nils a pointer before determining finalization ordering.

Some so-called "operating systems" fail to clean up some resources associated with a process. These resources must be deallocated at all cost before process exit whether or not they are still referenced. Probably the best way to deal with those is by not relying exclusively on finalization. They should be registered in a table of weak pointers (implemented as disguised pointers cleared by the finalization procedure that deallocates the resource). If any references are still left at process exit, they can be explicitly deallocated then.

Getting around topological finalization ordering

There are certain situations in which cycles between finalizable objects are genuinely unavoidable. Most notably, C++ compilers introduce self-cycles to represent inheritance. GC_register_finalizer_ignore_self tells the finalization part of the collector to ignore self cycles. This is used by the C++ interface.

Finalize.c actually contains an intentionally undocumented mechanism for registering a finalizable object with user-defined dependencies. The problem is that this dependency information is also used for memory reclamation, not just finalization ordering. Thus misuse can result in dangling pointers even if finalization doesn't create any. The risk of dangling pointers can be eliminated by building the collector with -DJAVA_FINALIZATION. This forces objects reachable from finalizers to be marked, even though this dependency is not considered for finalization ordering. ecl-16.1.2/src/bdwgc/doc/gc.man000066400000000000000000000125621266352375300160760ustar00rootroot00000000000000.TH GC_MALLOC 1L "2 October 2003" .SH NAME GC_malloc, GC_malloc_atomic, GC_free, GC_realloc, GC_enable_incremental, GC_register_finalizer, GC_malloc_ignore_off_page, GC_malloc_atomic_ignore_off_page, GC_set_warn_proc \- Garbage collecting malloc replacement .SH SYNOPSIS #include "gc.h" .br void * GC_malloc(size_t size); .br void GC_free(void *ptr); .br void * GC_realloc(void *ptr, size_t size); .br .sp cc ... gc.a .LP .SH DESCRIPTION .I GC_malloc and .I GC_free are plug-in replacements for standard malloc and free. However, .I GC_malloc will attempt to reclaim inaccessible space automatically by invoking a conservative garbage collector at appropriate points. The collector traverses all data structures accessible by following pointers from the machines registers, stack(s), data, and bss segments. Inaccessible structures will be reclaimed. A machine word is considered to be a valid pointer if it is an address inside an object allocated by .I GC_malloc or friends. .LP In most cases it is preferable to call the macros GC_MALLOC, GC_FREE, etc. instead of calling GC_malloc and friends directly. This allows debugging versions of the routines to be substituted by defining GC_DEBUG before including gc.h. .LP See the documentation in the include files gc_cpp.h and gc_allocator.h, as well as the gcinterface.html file in the distribution, for an alternate, C++ specific interface to the garbage collector. Note that C++ programs generally need to be careful to ensure that all allocated memory (whether via new, malloc, or STL allocators) that may point to garbage collected memory is either itself garbage collected, or at least traced by the collector. .LP Unlike the standard implementations of malloc, .I GC_malloc clears the newly allocated storage. .I GC_malloc_atomic does not. Furthermore, it informs the collector that the resulting object will never contain any pointers, and should therefore not be scanned by the collector. .LP .I GC_free can be used to deallocate objects, but its use is optional, and generally discouraged. .I GC_realloc has the standard realloc semantics. It preserves pointer-free-ness. .I GC_register_finalizer allows for registration of functions that are invoked when an object becomes inaccessible. .LP The garbage collector tries to avoid allocating memory at locations that already appear to be referenced before allocation. (Such apparent ``pointers'' are usually large integers and the like that just happen to look like an address.) This may make it hard to allocate very large objects. An attempt to do so may generate a warning. .LP .I GC_malloc_ignore_off_page and .I GC_malloc_atomic_ignore_off_page inform the collector that the client code will always maintain a pointer to near the beginning of the object (within the first 512 bytes), and that pointers beyond that can be ignored by the collector. This makes it much easier for the collector to place large objects. These are recommended for large object allocation. (Objects expected to be larger than about 100KBytes should be allocated this way.) .LP It is also possible to use the collector to find storage leaks in programs destined to be run with standard malloc/free. The collector can be compiled for thread-safe operation. Unlike standard malloc, it is safe to call malloc after a previous malloc call was interrupted by a signal, provided the original malloc call is not resumed. .LP The collector may, on rare occasion produce warning messages. On UNIX machines these appear on stderr. Warning messages can be filtered, redirected, or ignored with .I GC_set_warn_proc This is recommended for production code. See gc.h for details. .LP Fully portable code should call .I GC_INIT from the main program before making any other GC calls. On most platforms this does nothing and the collector is initialized on first use. On a few platforms explicit initialization is necessary. And it can never hurt. .LP Debugging versions of many of the above routines are provided as macros. Their names are identical to the above, but consist of all capital letters. If GC_DEBUG is defined before gc.h is included, these routines do additional checking, and allow the leak detecting version of the collector to produce slightly more useful output. Without GC_DEBUG defined, they behave exactly like the lower-case versions. .LP On some machines, collection will be performed incrementally after a call to .I GC_enable_incremental. This may temporarily write protect pages in the heap. See the README file for more information on how this interacts with system calls that write to the heap. .LP Other facilities not discussed here include limited facilities to support incremental collection on machines without appropriate VM support, provisions for providing more explicit object layout information to the garbage collector, more direct support for ``weak'' pointers, support for ``abortable'' garbage collections during idle time, etc. .LP .SH "SEE ALSO" The README and gc.h files in the distribution. More detailed definitions of the functions exported by the collector are given there. (The above list is not complete.) .LP The web site at http://www.hboehm.info/gc/ . .LP Boehm, H., and M. Weiser, "Garbage Collection in an Uncooperative Environment", "Software Practice & Experience", September 1988, pp. 807-820. .LP The malloc(3) man page. .LP .SH AUTHOR Hans-J. Boehm (boehm@acm.org). Some of the code was written by others, most notably Alan Demers. ecl-16.1.2/src/bdwgc/doc/gcdescr.html000066400000000000000000000762611266352375300173160ustar00rootroot00000000000000 Conservative GC Algorithmic Overview Hans-J. Boehm, HP Labs (Some of this was written at SGI)

This is under construction, and may always be.

Conservative GC Algorithmic Overview

This is a description of the algorithms and data structures used in our conservative garbage collector. I expect the level of detail to increase with time. For a survey of GC algorithms, see for example Paul Wilson's excellent paper. For an overview of the collector interface, see here.

This description is targeted primarily at someone trying to understand the source code. It specifically refers to variable and function names. It may also be useful for understanding the algorithms at a higher level.

The description here assumes that the collector is used in default mode. In particular, we assume that it used as a garbage collector, and not just a leak detector. We initially assume that it is used in stop-the-world, non-incremental mode, though the presence of the incremental collector will be apparent in the design. We assume the default finalization model, but the code affected by that is very localized.

Introduction

The garbage collector uses a modified mark-sweep algorithm. Conceptually it operates roughly in four phases, which are performed occasionally as part of a memory allocation:
  1. Preparation Each object has an associated mark bit. Clear all mark bits, indicating that all objects are potentially unreachable.
  2. Mark phase Marks all objects that can be reachable via chains of pointers from variables. Often the collector has no real information about the location of pointer variables in the heap, so it views all static data areas, stacks and registers as potentially containing pointers. Any bit patterns that represent addresses inside heap objects managed by the collector are viewed as pointers. Unless the client program has made heap object layout information available to the collector, any heap objects found to be reachable from variables are again scanned similarly.
  3. Sweep phase Scans the heap for inaccessible, and hence unmarked, objects, and returns them to an appropriate free list for reuse. This is not really a separate phase; even in non incremental mode this is operation is usually performed on demand during an allocation that discovers an empty free list. Thus the sweep phase is very unlikely to touch a page that would not have been touched shortly thereafter anyway.
  4. Finalization phase Unreachable objects which had been registered for finalization are enqueued for finalization outside the collector.

The remaining sections describe the memory allocation data structures, and then the last 3 collection phases in more detail. We conclude by outlining some of the additional features implemented in the collector.

Allocation

The collector includes its own memory allocator. The allocator obtains memory from the system in a platform-dependent way. Under UNIX, it uses either malloc, sbrk, or mmap.

Most static data used by the allocator, as well as that needed by the rest of the garbage collector is stored inside the _GC_arrays structure. This allows the garbage collector to easily ignore the collectors own data structures when it searches for root pointers. Other allocator and collector internal data structures are allocated dynamically with GC_scratch_alloc. GC_scratch_alloc does not allow for deallocation, and is therefore used only for permanent data structures.

The allocator allocates objects of different kinds. Different kinds are handled somewhat differently by certain parts of the garbage collector. Certain kinds are scanned for pointers, others are not. Some may have per-object type descriptors that determine pointer locations. Or a specific kind may correspond to one specific object layout. Two built-in kinds are uncollectible. One (STUBBORN) is immutable without special precautions. In spite of that, it is very likely that most C clients of the collector currently use at most two kinds: NORMAL and PTRFREE objects. The gcj runtime also makes heavy use of a kind (allocated with GC_gcj_malloc) that stores type information at a known offset in method tables.

The collector uses a two level allocator. A large block is defined to be one larger than half of HBLKSIZE, which is a power of 2, typically on the order of the page size.

Large block sizes are rounded up to the next multiple of HBLKSIZE and then allocated by GC_allochblk. Recent versions of the collector use an approximate best fit algorithm by keeping free lists for several large block sizes. The actual implementation of GC_allochblk is significantly complicated by black-listing issues (see below).

Small blocks are allocated in chunks of size HBLKSIZE. Each chunk is dedicated to only one object size and kind.

The allocator maintains separate free lists for each size and kind of object. Associated with each kind is an array of free list pointers, with entry freelist[i] pointing to a free list of size i objects. In recent versions of the collector, index i is expressed in granules, which are the minimum allocatable unit, typically 8 or 16 bytes. The free lists themselves are linked through the first word in each object (see obj_link() macro).

Once a large block is split for use in smaller objects, it can only be used for objects of that size, unless the collector discovers a completely empty chunk. Completely empty chunks are restored to the appropriate large block free list.

In order to avoid allocating blocks for too many distinct object sizes, the collector normally does not directly allocate objects of every possible request size. Instead request are rounded up to one of a smaller number of allocated sizes, for which free lists are maintained. The exact allocated sizes are computed on demand, but subject to the constraint that they increase roughly in geometric progression. Thus objects requested early in the execution are likely to be allocated with exactly the requested size, subject to alignment constraints. See GC_init_size_map for details.

The actual size rounding operation during small object allocation is implemented as a table lookup in GC_size_map which maps a requested allocation size in bytes to a number of granules.

Both collector initialization and computation of allocated sizes are handled carefully so that they do not slow down the small object fast allocation path. An attempt to allocate before the collector is initialized, or before the appropriate GC_size_map entry is computed, will take the same path as an allocation attempt with an empty free list. This results in a call to the slow path code (GC_generic_malloc_inner) which performs the appropriate initialization checks.

In non-incremental mode, we make a decision about whether to garbage collect whenever an allocation would otherwise have failed with the current heap size. If the total amount of allocation since the last collection is less than the heap size divided by GC_free_space_divisor, we try to expand the heap. Otherwise, we initiate a garbage collection. This ensures that the amount of garbage collection work per allocated byte remains constant.

The above is in fact an oversimplification of the real heap expansion and GC triggering heuristic, which adjusts slightly for root size and certain kinds of fragmentation. In particular:

  • Programs with a large root set size and little live heap memory will expand the heap to amortize the cost of scanning the roots.
  • Versions 5.x of the collector actually collect more frequently in nonincremental mode. The large block allocator usually refuses to split large heap blocks once the garbage collection threshold is reached. This often has the effect of collecting well before the heap fills up, thus reducing fragmentation and working set size at the expense of GC time. Versions 6.x choose an intermediate strategy depending on how much large object allocation has taken place in the past. (If the collector is configured to unmap unused pages, versions 6.x use the 5.x strategy.)
  • In calculating the amount of allocation since the last collection we give partial credit for objects we expect to be explicitly deallocated. Even if all objects are explicitly managed, it is often desirable to collect on rare occasion, since that is our only mechanism for coalescing completely empty chunks.

It has been suggested that this should be adjusted so that we favor expansion if the resulting heap still fits into physical memory. In many cases, that would no doubt help. But it is tricky to do this in a way that remains robust if multiple application are contending for a single pool of physical memory.

Mark phase

At each collection, the collector marks all objects that are possibly reachable from pointer variables. Since it cannot generally tell where pointer variables are located, it scans the following root segments for pointers:
  • The registers. Depending on the architecture, this may be done using assembly code, or by calling a setjmp-like function which saves register contents on the stack.
  • The stack(s). In the case of a single-threaded application, on most platforms this is done by scanning the memory between (an approximation of) the current stack pointer and GC_stackbottom. (For Itanium, the register stack scanned separately.) The GC_stackbottom variable is set in a highly platform-specific way depending on the appropriate configuration information in gcconfig.h. Note that the currently active stack needs to be scanned carefully, since callee-save registers of client code may appear inside collector stack frames, which may change during the mark process. This is addressed by scanning some sections of the stack "eagerly", effectively capturing a snapshot at one point in time.
  • Static data region(s). In the simplest case, this is the region between DATASTART and DATAEND, as defined in gcconfig.h. However, in most cases, this will also involve static data regions associated with dynamic libraries. These are identified by the mostly platform-specific code in dyn_load.c.
The marker maintains an explicit stack of memory regions that are known to be accessible, but that have not yet been searched for contained pointers. Each stack entry contains the starting address of the block to be scanned, as well as a descriptor of the block. If no layout information is available for the block, then the descriptor is simply a length. (For other possibilities, see gc_mark.h.)

At the beginning of the mark phase, all root segments (as described above) are pushed on the stack by GC_push_roots. (Registers and eagerly processed stack sections are processed by pushing the referenced objects instead of the stack section itself.) If ALL_INTERIOR_PTRS is not defined, then stack roots require special treatment. In this case, the normal marking code ignores interior pointers, but GC_push_all_stack explicitly checks for interior pointers and pushes descriptors for target objects.

The marker is structured to allow incremental marking. Each call to GC_mark_some performs a small amount of work towards marking the heap. It maintains explicit state in the form of GC_mark_state, which identifies a particular sub-phase. Some other pieces of state, most notably the mark stack, identify how much work remains to be done in each sub-phase. The normal progression of mark states for a stop-the-world collection is:

  1. MS_INVALID indicating that there may be accessible unmarked objects. In this case GC_objects_are_marked will simultaneously be false, so the mark state is advanced to
  2. MS_PUSH_UNCOLLECTABLE indicating that it suffices to push uncollectible objects, roots, and then mark everything reachable from them. Scan_ptr is advanced through the heap until all uncollectible objects are pushed, and objects reachable from them are marked. At that point, the next call to GC_mark_some calls GC_push_roots to push the roots. It the advances the mark state to
  3. MS_ROOTS_PUSHED asserting that once the mark stack is empty, all reachable objects are marked. Once in this state, we work only on emptying the mark stack. Once this is completed, the state changes to
  4. MS_NONE indicating that reachable objects are marked.
The core mark routine GC_mark_from, is called repeatedly by several of the sub-phases when the mark stack starts to fill up. It is also called repeatedly in MS_ROOTS_PUSHED state to empty the mark stack. The routine is designed to only perform a limited amount of marking at each call, so that it can also be used by the incremental collector. It is fairly carefully tuned, since it usually consumes a large majority of the garbage collection time.

The fact that it perform a only a small amount of work per call also allows it to be used as the core routine of the parallel marker. In that case it is normally invoked on thread-private mark stacks instead of the global mark stack. More details can be found in scale.html

The marker correctly handles mark stack overflows. Whenever the mark stack overflows, the mark state is reset to MS_INVALID. Since there are already marked objects in the heap, this eventually forces a complete scan of the heap, searching for pointers, during which any unmarked objects referenced by marked objects are again pushed on the mark stack. This process is repeated until the mark phase completes without a stack overflow. Each time the stack overflows, an attempt is made to grow the mark stack. All pieces of the collector that push regions onto the mark stack have to be careful to ensure forward progress, even in case of repeated mark stack overflows. Every mark attempt results in additional marked objects.

Each mark stack entry is processed by examining all candidate pointers in the range described by the entry. If the region has no associated type information, then this typically requires that each 4-byte aligned quantity (8-byte aligned with 64-bit pointers) be considered a candidate pointer.

We determine whether a candidate pointer is actually the address of a heap block. This is done in the following steps:

  • The candidate pointer is checked against rough heap bounds. These heap bounds are maintained such that all actual heap objects fall between them. In order to facilitate black-listing (see below) we also include address regions that the heap is likely to expand into. Most non-pointers fail this initial test.
  • The candidate pointer is divided into two pieces; the most significant bits identify a HBLKSIZE-sized page in the address space, and the least significant bits specify an offset within that page. (A hardware page may actually consist of multiple such pages. HBLKSIZE is usually the page size divided by a small power of two.)
  • The page address part of the candidate pointer is looked up in a table. Each table entry contains either 0, indicating that the page is not part of the garbage collected heap, a small integer n, indicating that the page is part of large object, starting at least n pages back, or a pointer to a descriptor for the page. In the first case, the candidate pointer i not a true pointer and can be safely ignored. In the last two cases, we can obtain a descriptor for the page containing the beginning of the object.
  • The starting address of the referenced object is computed. The page descriptor contains the size of the object(s) in that page, the object kind, and the necessary mark bits for those objects. The size information can be used to map the candidate pointer to the object starting address. To accelerate this process, the page header also contains a pointer to a precomputed map of page offsets to displacements from the beginning of an object. The use of this map avoids a potentially slow integer remainder operation in computing the object start address.
  • The mark bit for the target object is checked and set. If the object was previously unmarked, the object is pushed on the mark stack. The descriptor is read from the page descriptor. (This is computed from information GC_obj_kinds when the page is first allocated.)

    At the end of the mark phase, mark bits for left-over free lists are cleared, in case a free list was accidentally marked due to a stray pointer.

    Sweep phase

    At the end of the mark phase, all blocks in the heap are examined. Unmarked large objects are immediately returned to the large object free list. Each small object page is checked to see if all mark bits are clear. If so, the entire page is returned to the large object free list. Small object pages containing some reachable object are queued for later sweeping, unless we determine that the page contains very little free space, in which case it is not examined further.

    This initial sweep pass touches only block headers, not the blocks themselves. Thus it does not require significant paging, even if large sections of the heap are not in physical memory.

    Nonempty small object pages are swept when an allocation attempt encounters an empty free list for that object size and kind. Pages for the correct size and kind are repeatedly swept until at least one empty block is found. Sweeping such a page involves scanning the mark bit array in the page header, and building a free list linked through the first words in the objects themselves. This does involve touching the appropriate data page, but in most cases it will be touched only just before it is used for allocation. Hence any paging is essentially unavoidable.

    Except in the case of pointer-free objects, we maintain the invariant that any object in a small object free list is cleared (except possibly for the link field). Thus it becomes the burden of the small object sweep routine to clear objects. This has the advantage that we can easily recover from accidentally marking a free list, though that could also be handled by other means. The collector currently spends a fair amount of time clearing objects, and this approach should probably be revisited.

    In most configurations, we use specialized sweep routines to handle common small object sizes. Since we allocate one mark bit per word, it becomes easier to examine the relevant mark bits if the object size divides the word length evenly. We also suitably unroll the inner sweep loop in each case. (It is conceivable that profile-based procedure cloning in the compiler could make this unnecessary and counterproductive. I know of no existing compiler to which this applies.)

    The sweeping of small object pages could be avoided completely at the expense of examining mark bits directly in the allocator. This would probably be more expensive, since each allocation call would have to reload a large amount of state (e.g. next object address to be swept, position in mark bit table) before it could do its work. The current scheme keeps the allocator simple and allows useful optimizations in the sweeper.

    Finalization

    Both GC_register_disappearing_link and GC_register_finalizer add the request to a corresponding hash table. The hash table is allocated out of collected memory, but the reference to the finalizable object is hidden from the collector. Currently finalization requests are processed non-incrementally at the end of a mark cycle.

    The collector makes an initial pass over the table of finalizable objects, pushing the contents of unmarked objects onto the mark stack. After pushing each object, the marker is invoked to mark all objects reachable from it. The object itself is not explicitly marked. This assures that objects on which a finalizer depends are neither collected nor finalized.

    If in the process of marking from an object the object itself becomes marked, we have uncovered a cycle involving the object. This usually results in a warning from the collector. Such objects are not finalized, since it may be unsafe to do so. See the more detailed discussion of finalization semantics.

    Any objects remaining unmarked at the end of this process are added to a queue of objects whose finalizers can be run. Depending on collector configuration, finalizers are dequeued and run either implicitly during allocation calls, or explicitly in response to a user request. (Note that the former is unfortunately both the default and not generally safe. If finalizers perform synchronization, it may result in deadlocks. Nontrivial finalizers generally need to perform synchronization, and thus require a different collector configuration.)

    The collector provides a mechanism for replacing the procedure that is used to mark through objects. This is used both to provide support for Java-style unordered finalization, and to ignore certain kinds of cycles, e.g. those arising from C++ implementations of virtual inheritance.

    Generational Collection and Dirty Bits

    We basically use the concurrent and generational GC algorithm described in "Mostly Parallel Garbage Collection", by Boehm, Demers, and Shenker.

    The most significant modification is that the collector always starts running in the allocating thread. There is no separate garbage collector thread. (If parallel GC is enabled, helper threads may also be woken up.) If an allocation attempt either requests a large object, or encounters an empty small object free list, and notices that there is a collection in progress, it immediately performs a small amount of marking work as described above.

    This change was made both because we wanted to easily accommodate single-threaded environments, and because a separate GC thread requires very careful control over the scheduler to prevent the mutator from out-running the collector, and hence provoking unneeded heap growth.

    In incremental mode, the heap is always expanded when we encounter insufficient space for an allocation. Garbage collection is triggered whenever we notice that more than GC_heap_size/2 * GC_free_space_divisor bytes of allocation have taken place. After GC_full_freq minor collections a major collection is started.

    All collections initially run uninterrupted until a predetermined amount of time (50 msecs by default) has expired. If this allows the collection to complete entirely, we can avoid correcting for data structure modifications during the collection. If it does not complete, we return control to the mutator, and perform small amounts of additional GC work during those later allocations that cannot be satisfied from small object free lists. When marking completes, the set of modified pages is retrieved, and we mark once again from marked objects on those pages, this time with the mutator stopped.

    We keep track of modified pages using one of several distinct mechanisms:

    1. Through explicit mutator cooperation. Currently this requires the use of GC_malloc_stubborn, and is rarely used.
    2. (MPROTECT_VDB) By write-protecting physical pages and catching write faults. This is implemented for many Unix-like systems and for win32. It is not possible in a few environments.
    3. (PROC_VDB) By retrieving dirty bit information from /proc. (Currently only Sun's Solaris supports this. Though this is considerably cleaner, performance may actually be better with mprotect and signals.)
    4. (PCR_VDB) By relying on an external dirty bit implementation, in this case the one in Xerox PCR.
    5. (DEFAULT_VDB) By treating all pages as dirty. This is the default if none of the other techniques is known to be usable, and GC_malloc_stubborn is not used. Practical only for testing, or if the vast majority of objects use GC_malloc_stubborn.

    Black-listing

    The collector implements black-listing of pages, as described in Boehm, ``Space Efficient Conservative Collection'', PLDI '93, also available here.

    During the mark phase, the collector tracks ``near misses'', i.e. attempts to follow a ``pointer'' to just outside the garbage-collected heap, or to a currently unallocated page inside the heap. Pages that have been the targets of such near misses are likely to be the targets of misidentified ``pointers'' in the future. To minimize the future damage caused by such misidentification, they will be allocated only to small pointer-free objects.

    The collector understands two different kinds of black-listing. A page may be black listed for interior pointer references (GC_add_to_black_list_stack), if it was the target of a near miss from a location that requires interior pointer recognition, e.g. the stack, or the heap if GC_all_interior_pointers is set. In this case, we also avoid allocating large blocks that include this page.

    If the near miss came from a source that did not require interior pointer recognition, it is black-listed with GC_add_to_black_list_normal. A page black-listed in this way may appear inside a large object, so long as it is not the first page of a large object.

    The GC_allochblk routine respects black-listing when assigning a block to a particular object kind and size. It occasionally drops (i.e. allocates and forgets) blocks that are completely black-listed in order to avoid excessively long large block free lists containing only unusable blocks. This would otherwise become an issue if there is low demand for small pointer-free objects.

    Thread support

    We support several different threading models. Unfortunately Pthreads, the only reasonably well standardized thread model, supports too narrow an interface for conservative garbage collection. There appears to be no completely portable way to allow the collector to coexist with various Pthreads implementations. Hence we currently support only the more common Pthreads implementations.

    In particular, it is very difficult for the collector to stop all other threads in the system and examine the register contents. This is currently accomplished with very different mechanisms for some Pthreads implementations. The Solaris implementation temporarily disables much of the user-level threads implementation by stopping kernel-level threads ("lwp"s). The Linux/HPUX/OSF1 and Irix implementations sends signals to individual Pthreads and has them wait in the signal handler.

    The Linux and Irix implementations use only documented Pthreads calls, but rely on extensions to their semantics. The Linux implementation linux_threads.c relies on only very mild extensions to the pthreads semantics, and already supports a large number of other Unix-like pthreads implementations. Our goal is to make this the only pthread support in the collector.

    (The Irix implementation is separate only for historical reasons and should clearly be merged. The current Solaris implementation probably performs better in the uniprocessor case, but does not support thread operations in the collector. Hence it cannot support the parallel marker.)

    All implementations must intercept thread creation and a few other thread-specific calls to allow enumeration of threads and location of thread stacks. This is current accomplished with # define's in gc.h (really gc_pthread_redirects.h), or optionally by using ld's function call wrapping mechanism under Linux.

    Recent versions of the collector support several facilities to enhance the processor-scalability and thread performance of the collector. These are discussed in more detail here. We briefly outline the data approach to thread-local allocation in the next section.

    Thread-local allocation

    If thread-local allocation is enabled, the collector keeps separate arrays of free lists for each thread. Thread-local allocation is currently only supported on a few platforms.

    The free list arrays associated with each thread are only used to satisfy requests for objects that are both very small, and belong to one of a small number of well-known kinds. These currently include "normal" and pointer-free objects. Depending on the configuration, "gcj" objects may also be included.

    Thread-local free list entries contain either a pointer to the first element of a free list, or they contain a counter of the number of allocation granules, corresponding to objects of this size, allocated so far. Initially they contain the value one, i.e. a small counter value.

    Thread-local allocation allocates directly through the global allocator, if the object is of a size or kind not covered by the local free lists.

    If there is an appropriate local free list, the allocator checks whether it contains a sufficiently small counter value. If so, the counter is simply incremented by the counter value, and the global allocator is used. In this way, the initial few allocations of a given size bypass the local allocator. A thread that only allocates a handful of objects of a given size will not build up its own free list for that size. This avoids wasting space for unpopular objects sizes or kinds.

    Once the counter passes a threshold, GC_malloc_many is called to allocate roughly HBLKSIZE space and put it on the corresponding local free list. Further allocations of that size and kind then use this free list, and no longer need to acquire the allocation lock. The allocation procedure is otherwise similar to the global free lists. The local free lists are also linked using the first word in the object. In most cases this means they require considerably less time.

    Local free lists are treated buy most of the rest of the collector as though they were in-use reachable data. This requires some care, since pointer-free objects are not normally traced, and hence a special tracing procedure is required to mark all objects on pointer-free and gcj local free lists.

    On thread exit, any remaining thread-local free list entries are transferred back to the global free list.

    Note that if the collector is configured for thread-local allocation, GC versions before 7 do not invoke the thread-local allocator by default. GC_malloc only uses thread-local allocation in version 7 and later.

    For some more details see here, and the technical report entitled "Fast Multiprocessor Memory Allocation and Garbage Collection"

    Comments are appreciated. Please send mail to bdwgc@lists.opendylan.org (GC mailing list) or boehm@acm.org ecl-16.1.2/src/bdwgc/doc/gcinterface.html000066400000000000000000000321621266352375300201460ustar00rootroot00000000000000 Garbage Collector Interface

    C Interface

    On many platforms, a single-threaded garbage collector library can be built to act as a plug-in malloc replacement. (Build with -DREDIRECT_MALLOC=GC_malloc -DIGNORE_FREE.) This is often the best way to deal with third-party libraries which leak or prematurely free objects. -DREDIRECT_MALLOC=GC_malloc is intended primarily as an easy way to adapt old code, not for new development.

    New code should use the interface discussed below.

    Code must be linked against the GC library. On most UNIX platforms, depending on how the collector is built, this will be gc.a or libgc.{a,so}.

    The following describes the standard C interface to the garbage collector. It is not a complete definition of the interface. It describes only the most commonly used functionality, approximately in decreasing order of frequency of use. The full interface is described in gc.h or gc.h in the distribution.

    Clients should include gc.h.

    In the case of multi-threaded code, gc.h should be included after the threads header file, and after defining the appropriate GC_XXXX_THREADS macro. (For 6.2alpha4 and later, simply defining GC_THREADS should suffice.) The header file gc.h must be included in files that use either GC or threads primitives, since threads primitives will be redefined to cooperate with the GC on many platforms.

    Thread users should also be aware that on many platforms objects reachable only from thread-local variables may be prematurely reclaimed. Thus objects pointed to by thread-local variables should also be pointed to by a globally visible data structure. (This is viewed as a bug, but as one that is exceedingly hard to fix without some libc hooks.)

    void * GC_MALLOC(size_t nbytes)
    Allocates and clears nbytes of storage. Requires (amortized) time proportional to nbytes. The resulting object will be automatically deallocated when unreferenced. References from objects allocated with the system malloc are usually not considered by the collector. (See GC_MALLOC_UNCOLLECTABLE, however. Building the collector with -DREDIRECT_MALLOC=GC_malloc_uncollectable is often a way around this.) GC_MALLOC is a macro which invokes GC_malloc by default or, if GC_DEBUG is defined before gc.h is included, a debugging version that checks occasionally for overwrite errors, and the like.
    void * GC_MALLOC_ATOMIC(size_t nbytes)
    Allocates nbytes of storage. Requires (amortized) time proportional to nbytes. The resulting object will be automatically deallocated when unreferenced. The client promises that the resulting object will never contain any pointers. The memory is not cleared. This is the preferred way to allocate strings, floating point arrays, bitmaps, etc. More precise information about pointer locations can be communicated to the collector using the interface in gc_typed.h in the distribution.
    void * GC_MALLOC_UNCOLLECTABLE(size_t nbytes)
    Identical to GC_MALLOC, except that the resulting object is not automatically deallocated. Unlike the system-provided malloc, the collector does scan the object for pointers to garbage-collectible memory, even if the block itself does not appear to be reachable. (Objects allocated in this way are effectively treated as roots by the collector.)
    void * GC_REALLOC(void *old, size_t new_size)
    Allocate a new object of the indicated size and copy (a prefix of) the old object into the new object. The old object is reused in place if convenient. If the original object was allocated with GC_MALLOC_ATOMIC, the new object is subject to the same constraints. If it was allocated as an uncollectible object, then the new object is uncollectible, and the old object (if different) is deallocated.
    void GC_FREE(void *dead)
    Explicitly deallocate an object. Typically not useful for small collectible objects.
    void * GC_MALLOC_IGNORE_OFF_PAGE(size_t nbytes)
    void * GC_MALLOC_ATOMIC_IGNORE_OFF_PAGE(size_t nbytes)
    Analogous to GC_MALLOC and GC_MALLOC_ATOMIC, except that the client guarantees that as long as the resulting object is of use, a pointer is maintained to someplace inside the first 512 bytes of the object. This pointer should be declared volatile to avoid interference from compiler optimizations. (Other nonvolatile pointers to the object may exist as well.) This is the preferred way to allocate objects that are likely to be > 100KBytes in size. It greatly reduces the risk that such objects will be accidentally retained when they are no longer needed. Thus space usage may be significantly reduced.
    void GC_INIT(void)
    On some platforms, it is necessary to invoke this from the main executable, not from a dynamic library, before the initial invocation of a GC routine. It is recommended that this be done in portable code, though we try to ensure that it expands to a no-op on as many platforms as possible. In GC 7.0, it was required if thread-local allocation is enabled in the collector build, and malloc is not redirected to GC_malloc.
    void GC_gcollect(void)
    Explicitly force a garbage collection.
    void GC_enable_incremental(void)
    Cause the garbage collector to perform a small amount of work every few invocations of GC_MALLOC or the like, instead of performing an entire collection at once. This is likely to increase total running time. It will improve response on a platform that either has suitable support in the garbage collector (Linux and most Unix versions, win32 if the collector was suitably built) or if "stubborn" allocation is used (see gc.h). On many platforms this interacts poorly with system calls that write to the garbage collected heap.
    GC_warn_proc GC_set_warn_proc(GC_warn_proc p)
    Replace the default procedure used by the collector to print warnings. The collector may otherwise write to stderr, most commonly because GC_malloc was used in a situation in which GC_malloc_ignore_off_page would have been more appropriate. See gc.h for details.
    void GC_REGISTER_FINALIZER(...)
    Register a function to be called when an object becomes inaccessible. This is often useful as a backup method for releasing system resources (e.g. closing files) when the object referencing them becomes inaccessible. It is not an acceptable method to perform actions that must be performed in a timely fashion. See gc.h for details of the interface. See here for a more detailed discussion of the design.

    Note that an object may become inaccessible before client code is done operating on objects referenced by its fields. Suitable synchronization is usually required. See here or here for details.

    If you are concerned with multiprocessor performance and scalability, you should consider enabling and using thread local allocation.

    If your platform supports it, you should build the collector with parallel marking support (-DPARALLEL_MARK, or --enable-parallel-mark).

    If the collector is used in an environment in which pointer location information for heap objects is easily available, this can be passed on to the collector using the interfaces in either gc_typed.h or gc_gcj.h.

    The collector distribution also includes a string package that takes advantage of the collector. For details see cord.h

    C++ Interface

    The C++ interface is implemented as a thin layer on the C interface. Unfortunately, this thin layer appears to be very sensitive to variations in C++ implementations, particularly since it tries to replace the global ::new operator, something that appears to not be well-standardized. Your platform may need minor adjustments in this layer (gc_cpp.cc, gc_cpp.h, and possibly gc_allocator.h). Such changes do not require understanding of collector internals, though they may require a good understanding of your platform. (Patches enhancing portability are welcome. But it's easy to break one platform by fixing another.)

    Usage of the collector from C++ is also complicated by the fact that there are many "standard" ways to allocate memory in C++. The default ::new operator, default malloc, and default STL allocators allocate memory that is not garbage collected, and is not normally "traced" by the collector. This means that any pointers in memory allocated by these default allocators will not be seen by the collector. Garbage-collectible memory referenced only by pointers stored in such default-allocated objects is likely to be reclaimed prematurely by the collector.

    It is the programmers responsibility to ensure that garbage-collectible memory is referenced by pointers stored in one of

    • Program variables
    • Garbage-collected objects
    • Uncollected but "traceable" objects
    "Traceable" objects are not necessarily reclaimed by the collector, but are scanned for pointers to collectible objects. They are usually allocated by GC_MALLOC_UNCOLLECTABLE, as described above, and through some interfaces described below.

    (On most platforms, the collector may not trace correctly from in-flight exception objects. Thus objects thrown as exceptions should only point to otherwise reachable memory. This is another bug whose proper repair requires platform hooks.)

    The easiest way to ensure that collectible objects are properly referenced is to allocate only collectible objects. This requires that every allocation go through one of the following interfaces, each one of which replaces a standard C++ allocation mechanism. Note that this requires that all STL containers be explicitly instantiated with gc_allocator.

    STL allocators

    Recent versions of the collector include a hopefully standard-conforming allocator implementation in gc_allocator.h. It defines

    • traceable_allocator
    • gc_allocator
    which may be used either directly to allocate memory or to instantiate container templates. The former allocates uncollectible but traced memory. The latter allocates garbage-collected memory.

    These should work with any fully standard-conforming C++ compiler.

    Users of the SGI extended STL or its derivatives (including most g++ versions) may instead be able to include new_gc_alloc.h before including STL header files. This is increasingly discouraged.

    This defines SGI-style allocators

    • alloc
    • single_client_alloc
    • gc_alloc
    • single_client_gc_alloc
    The first two allocate uncollectible but traced memory, while the second two allocate collectible memory. The single_client versions are not safe for concurrent access by multiple threads, but are faster.

    For an example, click here.

    Class inheritance based interface for new-based allocation
    Users may include gc_cpp.h and then cause members of classes to be allocated in garbage collectible memory by having those classes inherit from class gc. For details see gc_cpp.h.

    Linking against libgccpp in addition to the gc library overrides ::new (and friends) to allocate traceable memory but uncollectible memory, making it safe to refer to collectible objects from the resulting memory.

    C interface
    It is also possible to use the C interface from gc.h directly. On platforms which use malloc to implement ::new, it should usually be possible to use a version of the collector that has been compiled as a malloc replacement. It is also possible to replace ::new and other allocation functions suitably, as is done by libgccpp.

    Note that user-implemented small-block allocation often works poorly with an underlying garbage-collected large block allocator, since the collector has to view all objects accessible from the user's free list as reachable. This is likely to cause problems if GC_MALLOC is used with something like the original HP version of STL. This approach works well with the SGI versions of the STL only if the malloc_alloc allocator is used.

    ecl-16.1.2/src/bdwgc/doc/leak.html000066400000000000000000000215151266352375300166100ustar00rootroot00000000000000 Using the Garbage Collector as Leak Detector

    Using the Garbage Collector as Leak Detector

    The garbage collector may be used as a leak detector. In this case, the primary function of the collector is to report objects that were allocated (typically with GC_MALLOC), not deallocated (normally with GC_FREE), but are no longer accessible. Since the object is no longer accessible, there in normally no way to deallocate the object at a later time; thus it can safely be assumed that the object has been "leaked".

    This is substantially different from counting leak detectors, which simply verify that all allocated objects are eventually deallocated. A garbage-collector based leak detector can provide somewhat more precise information when an object was leaked. More importantly, it does not report objects that are never deallocated because they are part of "permanent" data structures. Thus it does not require all objects to be deallocated at process exit time, a potentially useless activity that often triggers large amounts of paging.

    All non-ancient versions of the garbage collector provide leak detection support. Version 5.3 adds the following features:

    1. Leak detection mode can be initiated at run-time by setting GC_find_leak instead of building the collector with FIND_LEAK defined. This variable should be set to a nonzero value at program startup.
    2. Leaked objects should be reported and then correctly garbage collected. Prior versions either reported leaks or functioned as a garbage collector.
    For the rest of this description we will give instructions that work with any reasonable version of the collector.

    To use the collector as a leak detector, follow the following steps:

    1. Build the collector with -DFIND_LEAK. Otherwise use default build options.
    2. Change the program so that all allocation and deallocation goes through the garbage collector.
    3. Arrange to call GC_gcollect at appropriate points to check for leaks. (For sufficiently long running programs, this will happen implicitly, but probably not with sufficient frequency.)
    The second step can usually be accomplished with the -DREDIRECT_MALLOC=GC_malloc option when the collector is built, or by defining malloc, calloc, realloc and free to call the corresponding garbage collector functions. But this, by itself, will not yield very informative diagnostics, since the collector does not keep track of information about how objects were allocated. The error reports will include only object addresses.

    For more precise error reports, as much of the program as possible should use the all uppercase variants of these functions, after defining GC_DEBUG, and then including gc.h. In this environment GC_MALLOC is a macro which causes at least the file name and line number at the allocation point to be saved as part of the object. Leak reports will then also include this information.

    Many collector features (e.g stubborn objects, finalization, and disappearing links) are less useful in this context, and are not fully supported. Their use will usually generate additional bogus leak reports, since the collector itself drops some associated objects.

    The same is generally true of thread support. However, as of 6.0alpha4, correct leak reports should be generated with linuxthreads.

    On a few platforms (currently Solaris/SPARC, Irix, and, with -DSAVE_CALL_CHAIN, Linux/X86), GC_MALLOC also causes some more information about its call stack to be saved in the object. Such information is reproduced in the error reports in very non-symbolic form, but it can be very useful with the aid of a debugger.

    An Example

    The following header file leak_detector.h is included in the "include" subdirectory of the distribution: 
    #define GC_DEBUG
#include "gc.h"
#define malloc(n) GC_MALLOC(n)
#define calloc(m,n) GC_MALLOC((m)*(n))
#define free(p) GC_FREE(p)
#define realloc(p,n) GC_REALLOC((p),(n))
#define CHECK_LEAKS() GC_gcollect()

    Assume the collector has been built with -DFIND_LEAK. (For newer versions of the collector, we could instead add the statement GC_find_leak = 1 as the first statement in main().

    The program to be tested for leaks can then look like: 

    #include "leak_detector.h"

main() {
    int *p[10];
    int i;
    /* GC_find_leak = 1; for new collector versions not         */
    /* compiled with -DFIND_LEAK.                               */
    for (i = 0; i < 10; ++i) {
        p[i] = malloc(sizeof(int)+i);
    }
    for (i = 1; i < 10; ++i) {
        free(p[i]);
    }
    for (i = 0; i < 9; ++i) {
        p[i] = malloc(sizeof(int)+i);
    }
    CHECK_LEAKS();
}

    On an Intel X86 Linux system this produces on the stderr stream: 

    Leaked composite object at 0x806dff0 (leak_test.c:8, sz=4)
    (On most unmentioned operating systems, the output is similar to this. If the collector had been built on Linux/X86 with -DSAVE_CALL_CHAIN, the output would be closer to the Solaris example. For this to work, the program should not be compiled with -fomit_frame_pointer.)

    On Irix it reports 

    Leaked composite object at 0x10040fe0 (leak_test.c:8, sz=4)
        Caller at allocation:
                ##PC##= 0x10004910
    and on Solaris the error report is 
    Leaked composite object at 0xef621fc8 (leak_test.c:8, sz=4)
        Call chain at allocation:
                args: 4 (0x4), 200656 (0x30FD0)
                ##PC##= 0x14ADC
                args: 1 (0x1), -268436012 (0xEFFFFDD4)
                ##PC##= 0x14A64
    In the latter two cases some additional information is given about how malloc was called when the leaked object was allocated. For Solaris, the first line specifies the arguments to GC_debug_malloc (the actual allocation routine), The second the program counter inside main, the third the arguments to main, and finally the program counter inside the caller to main (i.e. in the C startup code).

    In the Irix case, only the address inside the caller to main is given.

    In many cases, a debugger is needed to interpret the additional information. On systems supporting the "adb" debugger, the tools/callprocs.sh script can be used to replace program counter values with symbolic names. As of version 6.1, the collector tries to generate symbolic names for call stacks if it knows how to do so on the platform. This is true on Linux/X86, but not on most other platforms.

    Simplified leak detection under Linux

    Since version 6.1, it should be possible to run the collector in leak detection mode on a program a.out under Linux/X86 as follows:
    1. Ensure that a.out is a single-threaded executable, or you are using a very recent (7.0alpha7+) collector version on Linux. On most platforms this does not work at all for the multi-threaded programs.
    2. If possible, ensure that the addr2line program is installed in /usr/bin. (It comes with most Linux distributions.)
    3. If possible, compile your program, which we'll call a.out, with full debug information. This will improve the quality of the leak reports. With this approach, it is no longer necessary to call GC_ routines explicitly, though that can also improve the quality of the leak reports.
    4. Build the collector and install it in directory foo as follows:
      • configure --prefix=foo --enable-gc-debug --enable-redirect-malloc --disable-threads
      • make
      • make install
      With a very recent collector on Linux, it may sometimes be safe to omit the --disable-threads. But the combination of thread support and malloc replacement is not yet rock solid.
    5. Set environment variables as follows:
      • LD_PRELOAD=foo/lib/libgc.so
      • GC_FIND_LEAK
      • You may also want to set GC_PRINT_STATS (to confirm that the collector is running) and/or GC_LOOP_ON_ABORT (to facilitate debugging from another window if something goes wrong).
    6. Simply run a.out as you normally would. Note that if you run anything else (e.g. your editor) with those environment variables set, it will also be leak tested. This may or may not be useful and/or embarrassing. It can generate mountains of leak reports if the application wasn't designed to avoid leaks, e.g. because it's always short-lived.
    This has not yet been thoroughly tested on large applications, but it's known to do the right thing on at least some small ones. ecl-16.1.2/src/bdwgc/doc/overview.html000066400000000000000000000506161266352375300175460ustar00rootroot00000000000000 A garbage collector for C and C++
    Interface Overview Tutorial Slides FAQ Example Download License

    A garbage collector for C and C++

    [ This is an updated version of the page formerly at www.hpl.hp.com/personal/Hans_Boehm/gc/, before that at http://reality.sgi.com/boehm/gc.html and before that at ftp://ftp.parc.xerox.com/pub/gc/gc.html. ]

    The Boehm-Demers-Weiser conservative garbage collector can be used as a garbage collecting replacement for C malloc or C++ new. It allows you to allocate memory basically as you normally would, without explicitly deallocating memory that is no longer useful. The collector automatically recycles memory when it determines that it can no longer be otherwise accessed. A simple example of such a use is given here.

    The collector is also used by a number of programming language implementations that either use C as intermediate code, want to facilitate easier interoperation with C libraries, or just prefer the simple collector interface. For a more detailed description of the interface, see here.

    Alternatively, the garbage collector may be used as a leak detector for C or C++ programs, though that is not its primary goal.

    Typically several versions will be available. Usually you should first try to use gc_source/gc.tar.gz, which is normally an older, more stable version.

    If that fails, try the latest explicitly numbered version in gc_source/. Later versions may contain additional features, platform support, or bug fixes, but are likely to be less well tested.

    A slightly older version of the garbage collector is now also included as part of the GNU compiler distribution. The source code for that version is available for browsing here.

    The arguments for and against conservative garbage collection in C and C++ are briefly discussed in issues.html. The beginnings of a frequently-asked-questions list are here.

    The garbage collector code is copyrighted by Hans-J. Boehm, Alan J. Demers, Xerox Corporation, Silicon Graphics, and Hewlett-Packard Company. It may be used and copied without payment of a fee under minimal restrictions. See the README file in the distribution or the license for more details. IT IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED OR IMPLIED. ANY USE IS AT YOUR OWN RISK.

    Empirically, this collector works with most unmodified C programs, simply by replacing malloc with GC_malloc calls, replacing realloc with GC_realloc calls, and removing free calls. Exceptions are discussed in issues.html.

    Platforms

    The collector is not completely portable, but the distribution includes ports to most standard PC and UNIX/Linux platforms. The collector should work on Linux, *BSD, recent Windows versions, MacOS X, HP/UX, Solaris, Tru64, Irix and a few other operating systems. Some ports are more polished than others.

    Irix pthreads, Linux threads, Win32 threads, Solaris threads (pthreads only), HP/UX 11 pthreads, Tru64 pthreads, and MacOS X threads are supported in recent versions.

    Separately distributed ports

    For MacOS 9/Classic use, Patrick Beard's latest port is available from http://homepage.mac.com/pcbeard/gc/. (Unfortunately, that's now quite dated. I'm not in a position to test under MacOS. Although I try to incorporate changes, it is impossible for me to update the project file.)

    Precompiled versions of the collector for NetBSD are available here.

    Debian Linux includes prepackaged versions of the collector.

    Scalable multiprocessor versions

    Kenjiro Taura, Toshio Endo, and Akinori Yonezawa have made available a parallel collector based on this one. Their collector takes advantage of multiple processors during a collection. Starting with collector version 6.0alpha1 we also do this, though with more modest processor scalability goals. Our approach is discussed briefly in scale.html.

    Some Collector Details

    The collector uses a mark-sweep algorithm. It provides incremental and generational collection under operating systems which provide the right kind of virtual memory support. (Currently this includes SunOS[45], IRIX, OSF/1, Linux, and Windows, with varying restrictions.) It allows finalization code to be invoked when an object is collected. It can take advantage of type information to locate pointers if such information is provided, but it is usually used without such information. See the README and gc.h files in the distribution for more details.

    For an overview of the implementation, see here.

    The garbage collector distribution includes a C string (cord) package that provides for fast concatenation and substring operations on long strings. A simple curses- and win32-based editor that represents the entire file as a cord is included as a sample application.

    Performance of the nonincremental collector is typically competitive with malloc/free implementations. Both space and time overhead are likely to be only slightly higher for programs written for malloc/free (see Detlefs, Dosser and Zorn's Memory Allocation Costs in Large C and C++ Programs.) For programs allocating primarily very small objects, the collector may be faster; for programs allocating primarily large objects it will be slower. If the collector is used in a multi-threaded environment and configured for thread-local allocation, it may in some cases significantly outperform malloc/free allocation in time.

    We also expect that in many cases any additional overhead will be more than compensated for by decreased copying etc. if programs are written and tuned for garbage collection.

    Further Reading:

    The beginnings of a frequently asked questions list for this collector are here.

    The following provide information on garbage collection in general:

    Paul Wilson's garbage collection ftp archive and GC survey.

    The Ravenbrook Memory Management Reference.

    David Chase's GC FAQ.

    Richard Jones' Garbage Collection Page and his book.

    The following papers describe the collector algorithms we use and the underlying design decisions at a higher level.

    (Some of the lower level details can be found here.)

    The first one is not available electronically due to copyright considerations. Most of the others are subject to ACM copyright.

    Boehm, H., "Dynamic Memory Allocation and Garbage Collection", Computers in Physics 9, 3, May/June 1995, pp. 297-303. This is directed at an otherwise sophisticated audience unfamiliar with memory allocation issues. The algorithmic details differ from those in the implementation. There is a related letter to the editor and a minor correction in the next issue.

    Boehm, H., and M. Weiser, "Garbage Collection in an Uncooperative Environment", Software Practice & Experience, September 1988, pp. 807-820.

    Boehm, H., A. Demers, and S. Shenker, "Mostly Parallel Garbage Collection", Proceedings of the ACM SIGPLAN '91 Conference on Programming Language Design and Implementation, SIGPLAN Notices 26, 6 (June 1991), pp. 157-164.

    Boehm, H., "Space Efficient Conservative Garbage Collection", Proceedings of the ACM SIGPLAN '93 Conference on Programming Language Design and Implementation, SIGPLAN Notices 28, 6 (June 1993), pp. 197-206.

    Boehm, H., "Reducing Garbage Collector Cache Misses", Proceedings of the 2000 International Symposium on Memory Management . Official version. Technical report version. Describes the prefetch strategy incorporated into the collector for some platforms. Explains why the sweep phase of a "mark-sweep" collector should not really be a distinct phase.

    M. Serrano, H. Boehm, "Understanding Memory Allocation of Scheme Programs", Proceedings of the Fifth ACM SIGPLAN International Conference on Functional Programming, 2000, Montreal, Canada, pp. 245-256. Official version. Earlier Technical Report version. Includes some discussion of the collector debugging facilities for identifying causes of memory retention.

    Boehm, H., "Fast Multiprocessor Memory Allocation and Garbage Collection", HP Labs Technical Report HPL 2000-165. Discusses the parallel collection algorithms, and presents some performance results.

    Boehm, H., "Bounding Space Usage of Conservative Garbage Collectors", Proceedings of the 2002 ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, Jan. 2002, pp. 93-100. Official version. Technical report version. Includes a discussion of a collector facility to much more reliably test for the potential of unbounded heap growth.

    The following papers discuss language and compiler restrictions necessary to guaranteed safety of conservative garbage collection.

    We thank John Levine and JCLT for allowing us to make the second paper available electronically, and providing PostScript for the final version.

    Boehm, H., "Simple Garbage-Collector-Safety", Proceedings of the ACM SIGPLAN '96 Conference on Programming Language Design and Implementation.

    Boehm, H., and D. Chase, "A Proposal for Garbage-Collector-Safe C Compilation", Journal of C Language Translation 4, 2 (Decemeber 1992), pp. 126-141.

    Other related information:

    The Detlefs, Dosser and Zorn's Memory Allocation Costs in Large C and C++ Programs. This is a performance comparison of the Boehm-Demers-Weiser collector to malloc/free, using programs written for malloc/free.

    Joel Bartlett's mostly copying conservative garbage collector for C++.

    John Ellis and David Detlef's Safe Efficient Garbage Collection for C++ proposal.

    Henry Baker's paper collection.

    Slides for Hans Boehm's Allocation and GC Myths talk.

    Current users:

    Known current users of some variant of this collector include:

    The runtime system for GCJ, the static GNU java compiler.

    W3m, a text-based web browser.

    Some versions of the Xerox DocuPrint printer software.

    The Mozilla project, as leak detector.

    The Mono project, an open source implementation of the .NET development framework.

    The DotGNU Portable.NET project, another open source .NET implementation.

    The Irssi IRC client.

    The Berkeley Titanium project.

    The NAGWare f90 Fortran 90 compiler.

    Elwood Corporation's Eclipse Common Lisp system, C library, and translator.

    The Bigloo Scheme and Camloo ML compilers written by Manuel Serrano and others.

    Brent Benson's libscheme.

    The MzScheme scheme implementation.

    The University of Washington Cecil Implementation.

    The Berkeley Sather implementation.

    The Berkeley Harmonia Project.

    The Toba Java Virtual Machine to C translator.

    The Gwydion Dylan compiler.

    The GNU Objective C runtime.

    Macaulay 2, a system to support research in algebraic geometry and commutative algebra.

    The Vesta configuration management system.

    Visual Prolog 6.

    Asymptote LaTeX-compatible vector graphics language.

    More collector information at this site

    A simple illustration of how to build and use the collector.

    Description of alternate interfaces to the garbage collector.

    Slides from an ISMM 2004 tutorial about the GC.

    A FAQ (frequently asked questions) list.

    How to use the garbage collector as a leak detector.

    Some hints on debugging garbage collected applications.

    An overview of the implementation of the garbage collector.

    The data structure used for fast pointer lookups.

    Scalability of the collector to multiprocessors.

    Directory containing garbage collector source.

    More background information at this site

    An attempt to establish a bound on space usage of conservative garbage collectors.

    Mark-sweep versus copying garbage collectors and their complexity.

    Pros and cons of conservative garbage collectors, in comparison to other collectors.

    Issues related to garbage collection vs. manual memory management in C/C++.

    An example of a case in which garbage collection results in a much faster implementation as a result of reduced synchronization.

    Slide set discussing performance of nonmoving garbage collectors.

    Slide set discussing Destructors, Finalizers, and Synchronization (POPL 2003).

    Paper corresponding to above slide set ( Technical Report version).

    A Java/Scheme/C/C++ garbage collection benchmark.

    Slides for talk on memory allocation myths.

    Slides for OOPSLA 98 garbage collection talk.

    Related papers.

    Contacts and Mailing List

    We have recently set up two mailing list for collector announcements and discussions:
    • bdwgc-announce@lists.opendylan.org is used for announcements of new versions. Postings are restricted. We expect this to always remain a very low volume list.
    • bdwgc@lists.opendylan.org is used for discussions, bug reports, and the like. Subscribers may post. On-topic posts by nonsubscribers will usually also be accepted, but it may take some time to review them.
    To subscribe to these lists, please visit lists.opendylan.org/mailman/listinfo/bdwgc-announce and lists.opendylan.org/mailman/listinfo/bdwgc, respectively.

    The archives for these lists appear here and here, respectively. The gc list archive may also be read at gmane.org.

    Some prior discussion of the collector has taken place on the gcc java mailing list, whose archives appear here, and also on gclist@iecc.com.

    Comments and bug reports may also be sent to (boehm@acm.org), but the gc mailing list is usually preferred.

    ecl-16.1.2/src/bdwgc/doc/porting.html000066400000000000000000000373121266352375300173600ustar00rootroot00000000000000 Conservative GC Porting Directions

    Conservative GC Porting Directions

    The collector is designed to be relatively easy to port, but is not portable code per se. The collector inherently has to perform operations, such as scanning the stack(s), that are not possible in portable C code.

    All of the following assumes that the collector is being ported to a byte-addressable 32- or 64-bit machine. Currently all successful ports to 64-bit machines involve LP64 targets. The code base includes some provisions for P64 targets (notably win64), but that has not been tested. You are hereby discouraged from attempting a port to non-byte-addressable, or 8-bit, or 16-bit machines.

    The difficulty of porting the collector varies greatly depending on the needed functionality. In the simplest case, only some small additions are needed for the include/private/gcconfig.h file. This is described in the following section. Later sections discuss some of the optional features, which typically involve more porting effort.

    Note that the collector makes heavy use of ifdefs. Unlike some other software projects, we have concluded repeatedly that this is preferable to system dependent files, with code duplicated between the files. However, to keep this manageable, we do strongly believe in indenting ifdefs correctly (for historical reasons usually without the leading sharp sign). (Separate source files are of course fine if they don't result in code duplication.)

    Adding Platforms to gcconfig.h

    If neither thread support, nor tracing of dynamic library data is required, these are often the only changes you will need to make.

    The gcconfig.h file consists of three sections:

    1. A section that defines GC-internal macros that identify the architecture (e.g. IA64 or I386) and operating system (e.g. LINUX or MSWIN32). This is usually done by testing predefined macros. By defining our own macros instead of using the predefined ones directly, we can impose a bit more consistency, and somewhat isolate ourselves from compiler differences.

      It is relatively straightforward to add a new entry here. But please try to be consistent with the existing code. In particular, 64-bit variants of 32-bit architectures general are not treated as a new architecture. Instead we explicitly test for 64-bit-ness in the few places in which it matters. (The notable exception here is I386 and X86_64. This is partially historical, and partially justified by the fact that there are arguably more substantial architecture and ABI differences here than for RISC variants.)

      on GNU-based systems, cpp -dM empty_source_file.c seems to generate a set of predefined macros. On some other systems, the "verbose" compiler option may do so, or the manual page may list them.

    2. A section that defines a small number of platform-specific macros, which are then used directly by the collector. For simple ports, this is where most of the effort is required. We describe the macros below.

      This section contains a subsection for each architecture (enclosed in a suitable ifdef. Each subsection usually contains some architecture-dependent defines, followed by several sets of OS-dependent defines, again enclosed in ifdefs.

    3. A section that fills in defaults for some macros left undefined in the preceding section, and defines some other macros that rarely need adjustment for new platforms. You will typically not have to touch these. If you are porting to an OS that was previously completely unsupported, it is likely that you will need to add another clause to the definition of GET_MEM.
    The following macros must be defined correctly for each architecture and operating system:
    MACH_TYPE
    Defined to a string that represents the machine architecture. Usually just the macro name used to identify the architecture, but enclosed in quotes.
    OS_TYPE
    Defined to a string that represents the operating system name. Usually just the macro name used to identify the operating system, but enclosed in quotes.
    CPP_WORDSZ
    The word size in bits as a constant suitable for preprocessor tests, i.e. without casts or sizeof expressions. Currently always defined as either 64 or 32. For platforms supporting both 32- and 64-bit ABIs, this should be conditionally defined depending on the current ABI. There is a default of 32.
    ALIGNMENT
    Defined to be the largest N, such that all pointer are guaranteed to be aligned on N-byte boundaries. defining it to be 1 will always work, but perform poorly. For all modern 32-bit platforms, this is 4. For all modern 64-bit platforms, this is 8. Whether or not X86 qualifies as a modern architecture here is compiler- and OS-dependent.
    DATASTART
    The beginning of the main data segment. The collector will trace all memory between DATASTART and DATAEND for root pointers. On some platforms, this can be defined to a constant address, though experience has shown that to be risky. Ideally the linker will define a symbol (e.g. _data whose address is the beginning of the data segment. Sometimes the value can be computed using the GC_SysVGetDataStart function. Not used if either the next macro is defined, or if dynamic loading is supported, and the dynamic loading support defines a function GC_register_main_static_data() which returns false.
    SEARCH_FOR_DATA_START
    If this is defined DATASTART will be defined to a dynamically computed value which is obtained by starting with the address of _end and walking backwards until non-addressable memory is found. This often works on Posix-like platforms. It makes it harder to debug client programs, since startup involves generating and catching a segmentation fault, which tends to confuse users.
    DATAEND
    Set to the end of the main data segment. Defaults to end, where that is declared as an array. This works in some cases, since the linker introduces a suitable symbol.
    DATASTART2, DATAEND2
    Some platforms have two discontiguous main data segments, e.g. for initialized and uninitialized data. If so, these two macros should be defined to the limits of the second main data segment.
    STACK_GROWS_UP
    Should be defined if the stack (or thread stacks) grow towards higher addresses. (This appears to be true only on PA-RISC. If your architecture has more than one stack per thread, and is not already supported, you will need to do more work. Grep for "IA64" in the source for an example.)
    STACKBOTTOM
    Defined to be the cool end of the stack, which is usually the highest address in the stack. It must bound the region of the stack that contains pointers into the GC heap. With thread support, this must be the cold end of the main stack, which typically cannot be found in the same way as the other thread stacks. If this is not defined and none of the following three macros is defined, client code must explicitly set GC_stackbottom to an appropriate value before calling GC_INIT() or any other GC_ routine.
    LINUX_STACKBOTTOM
    May be defined instead of STACKBOTTOM. If defined, then the cold end of the stack will be determined Currently we usually read it from /proc.
    HEURISTIC1
    May be defined instead of STACKBOTTOM. STACK_GRAN should generally also be undefined and defined. The cold end of the stack is determined by taking an address inside GC_init's frame, and rounding it up to the next multiple of STACK_GRAN. This works well if the stack base is always aligned to a large power of two. (STACK_GRAN is predefined to 0x1000000, which is rarely optimal.)
    HEURISTIC2
    May be defined instead of STACKBOTTOM. The cold end of the stack is determined by taking an address inside GC_init's frame, incrementing it repeatedly in small steps (decrement if STACK_GROWS_UP), and reading the value at each location. We remember the value when the first Segmentation violation or Bus error is signalled, round that to the nearest plausible page boundary, and use that as the stack base.
    DYNAMIC_LOADING
    Should be defined if dyn_load.c has been updated for this platform and tracing of dynamic library roots is supported.
    MPROTECT_VDB, PROC_VDB
    May be defined if the corresponding "virtual dirty bit" implementation in os_dep.c is usable on this platform. This allows incremental/generational garbage collection. MPROTECT_VDB identifies modified pages by write protecting the heap and catching faults. PROC_VDB uses the /proc primitives to read dirty bits.
    PREFETCH, PREFETCH_FOR_WRITE
    The collector uses PREFETCH(x) to preload the cache with *x. This defaults to a no-op.
    CLEAR_DOUBLE
    If CLEAR_DOUBLE is defined, then CLEAR_DOUBLE(x) is used as a fast way to clear the two words at GC_malloc-aligned address x. By default, word stores of 0 are used instead.
    HEAP_START
    HEAP_START may be defined as the initial address hint for mmap-based allocation.
    ALIGN_DOUBLE
    Should be defined if the architecture requires double-word alignment of GC_malloced memory, e.g. 8-byte alignment with a 32-bit ABI. Most modern machines are likely to require this. This is no longer needed for GC7 and later.

    Additional requirements for a basic port

    In some cases, you may have to add additional platform-specific code to other files. A likely candidate is the implementation of GC_with_callee_saves_pushed in     mach_dep.c. This ensure that register contents that the collector must trace from are copied to the stack. Typically this can be done portably, but on some platforms it may require assembly code, or just tweaking of conditional compilation tests.

    For GC7, if your platform supports getcontext(), then defining the macro UNIX_LIKE for your OS in gcconfig.h (if it isn't defined there already) is likely to solve the problem. otherwise, if you are using gcc, _builtin_unwind_init() will be used, and should work fine. If that is not applicable either, the implementation will try to use setjmp(). This will work if your setjmp implementation saves all possibly pointer-valued registers into the buffer, as opposed to trying to unwind the stack at longjmp time. The setjmp_test test tries to determine this, but often doesn't get it right.

    In GC6.x versions of the collector, tracing of registers was more commonly handled with assembly code. In GC7, this is generally to be avoided.

    Most commonly os_dep.c will not require attention, but see below.

    Thread support

    Supporting threads requires that the collector be able to find and suspend all threads potentially accessing the garbage-collected heap, and locate any state associated with each thread that must be traced.

    The functionality needed for thread support is generally implemented in one or more files specific to the particular thread interface. For example, somewhat portable pthread support is implemented in pthread_support.c and pthread_stop_world.c. The essential functionality consists of

    GC_stop_world()
    Stops all threads which may access the garbage collected heap, other than the caller.
    GC_start_world()
    Restart other threads.
    GC_push_all_stacks()
    Push the contents of all thread stacks (or at least of pointer-containing regions in the thread stacks) onto the mark stack.
    These very often require that the garbage collector maintain its own data structures to track active threads.

    In addition, LOCK and UNLOCK must be implemented in gc_locks.h

    The easiest case is probably a new pthreads platform on which threads can be stopped with signals. In this case, the changes involve:

    1. Introducing a suitable GC_X_THREADS macro, which should be automatically defined by gc_config_macros.h in the right cases. It should also result in a definition of GC_PTHREADS, as for the existing cases.
    2. For GC7+, ensuring that the atomic_ops package at least minimally supports the platform. If incremental GC is needed, or if pthread locks don't perform adequately as the allocation lock, you will probably need to ensure that a sufficient atomic_ops port exists for the platform to provided an atomic test and set operation. (Current GC7 versions require moreatomic_ops support than necessary. This is a bug.) For earlier versions define GC_test_and_set in gc_locks.h.
    3. Making any needed adjustments to pthread_stop_world.c and pthread_support.c. Ideally none should be needed. In fact, not all of this is as well standardized as one would like, and outright bugs requiring workarounds are common.
    Non-preemptive threads packages will probably require further work. Similarly thread-local allocation and parallel marking requires further work in pthread_support.c, and may require better atomic_ops support.

    Dynamic library support

    So long as DATASTART and DATAEND are defined correctly, the collector will trace memory reachable from file scope or static variables defined as part of the main executable. This is sufficient if either the program is statically linked, or if pointers to the garbage-collected heap are never stored in non-stack variables defined in dynamic libraries.

    If dynamic library data sections must also be traced, then

    • DYNAMIC_LOADING must be defined in the appropriate section of gcconfig.h.
    • An appropriate versions of the functions GC_register_dynamic_libraries() should be defined in dyn_load.c. This function should invoke GC_cond_add_roots(region_start, region_end, TRUE) on each dynamic library data section.

    Implementations that scan for writable data segments are error prone, particularly in the presence of threads. They frequently result in race conditions when threads exit and stacks disappear. They may also accidentally trace large regions of graphics memory, or mapped files. On at least one occasion they have been known to try to trace device memory that could not safely be read in the manner the GC wanted to read it.

    It is usually safer to walk the dynamic linker data structure, especially if the linker exports an interface to do so. But beware of poorly documented locking behavior in this case.

    Incremental GC support

    For incremental and generational collection to work, os_dep.c must contain a suitable "virtual dirty bit" implementation, which allows the collector to track which heap pages (assumed to be a multiple of the collectors block size) have been written during a certain time interval. The collector provides several implementations, which might be adapted. The default (DEFAULT_VDB) is a placeholder which treats all pages as having been written. This ensures correctness, but renders incremental and generational collection essentially useless.

    Stack traces for debug support

    If stack traces in objects are need for debug support, GC_dave_callers and GC_print_callers must be implemented.

    Disclaimer

    This is an initial pass at porting guidelines. Some things have no doubt been overlooked. ecl-16.1.2/src/bdwgc/doc/scale.html000066400000000000000000000242451266352375300167660ustar00rootroot00000000000000 Garbage collector scalability

    Garbage collector scalability

    In its default configuration, the Boehm-Demers-Weiser garbage collector is not thread-safe. It can be made thread-safe for a number of environments by building the collector with the appropriate -DXXX-THREADS compilation flag. This has primarily two effects:
    1. It causes the garbage collector to stop all other threads when it needs to see a consistent memory state.
    2. It causes the collector to acquire a lock around essentially all allocation and garbage collection activity.
    Since a single lock is used for all allocation-related activity, only one thread can be allocating or collecting at one point. This inherently limits performance of multi-threaded applications on multiprocessors.

    On most platforms, the allocator/collector lock is implemented as a spin lock with exponential back-off. Longer wait times are implemented by yielding and/or sleeping. If a collection is in progress, the pure spinning stage is skipped. This has the advantage that uncontested and thus most uniprocessor lock acquisitions are very cheap. It has the disadvantage that the application may sleep for small periods of time even when there is work to be done. And threads may be unnecessarily woken up for short periods. Nonetheless, this scheme empirically outperforms native queue-based mutual exclusion implementations in most cases, sometimes drastically so.

    Options for enhanced scalability

    Version 6.0 of the collector adds two facilities to enhance collector scalability on multiprocessors. As of 6.0alpha1, these are supported only under Linux on X86 and IA64 processors, though ports to other otherwise supported Pthreads platforms should be straightforward. They are intended to be used together.
    • Building the collector with -DPARALLEL_MARK allows the collector to run the mark phase in parallel in multiple threads, and thus on multiple processors. The mark phase typically consumes the large majority of the collection time. Thus this largely parallelizes the garbage collector itself, though not the allocation process. Currently the marking is performed by the thread that triggered the collection, together with N-1 dedicated threads, where N is the number of processors detected by the collector. The dedicated threads are created once at initialization time.

      A second effect of this flag is to switch to a more concurrent implementation of GC_malloc_many, so that free lists can be built, and memory can be cleared, by more than one thread concurrently.

    • Building the collector with -DTHREAD_LOCAL_ALLOC adds support for thread local allocation. This causes GC_malloc, GC_malloc_atomic, and GC_gcj_malloc to be redefined to perform thread-local allocation.

      Memory returned from thread-local allocators is completely interchangeable with that returned by the standard allocators. It may be used by other threads. The only difference is that, if the thread allocates enough memory of a certain kind, it will build a thread-local free list for objects of that kind, and allocate from that. This greatly reduces locking. The thread-local free lists are refilled using GC_malloc_many.

      An important side effect of this flag is to replace the default spin-then-sleep lock to be replace by a spin-then-queue based implementation. This reduces performance for the standard allocation functions, though it usually improves performance when thread-local allocation is used heavily, and thus the number of short-duration lock acquisitions is greatly reduced.

    The easiest way to switch an application to thread-local allocation in a pre-version-7.0 collector was to

    1. Define the macro GC_REDIRECT_TO_LOCAL, and then include the gc.h header in each client source file.
    2. Invoke GC_thr_init() before any allocation.
    3. Allocate using GC_MALLOC, GC_MALLOC_ATOMIC, and/or GC_GCJ_MALLOC.

    The Parallel Marking Algorithm

    We use an algorithm similar to that developed by Endo, Taura, and Yonezawa at the University of Tokyo. However, the data structures and implementation are different, and represent a smaller change to the original collector source, probably at the expense of extreme scalability. Some of the refinements they suggest, e.g. splitting large objects, were also incorporated into out approach.

    The global mark stack is transformed into a global work queue. Unlike the usual case, it never shrinks during a mark phase. The mark threads remove objects from the queue by copying them to a local mark stack and changing the global descriptor to zero, indicating that there is no more work to be done for this entry. This removal is done with no synchronization. Thus it is possible for more than one worker to remove the same entry, resulting in some work duplication.

    The global work queue grows only if a marker thread decides to return some of its local mark stack to the global one. This is done if the global queue appears to be running low, or if the local stack is in danger of overflowing. It does require synchronization, but should be relatively rare.

    The sequential marking code is reused to process local mark stacks. Hence the amount of additional code required for parallel marking is minimal.

    It should be possible to use generational collection in the presence of the parallel collector, by calling GC_enable_incremental(). This does not result in fully incremental collection, since parallel mark phases cannot currently be interrupted, and doing so may be too expensive.

    Gcj-style mark descriptors do not currently mix with the combination of local allocation and incremental collection. They should work correctly with one or the other, but not both.

    The number of marker threads is set on startup to the number of available processors (or to the value of the GC_NPROCS environment variable). If only a single processor is detected, parallel marking is disabled.

    Note that setting GC_NPROCS to 1 also causes some lock acquisitions inside the collector to immediately yield the processor instead of busy waiting first. In the case of a multiprocessor and a client with multiple simultaneously runnable threads, this may have disastrous performance consequences (e.g. a factor of 10 slowdown).

    Performance

    We conducted some simple experiments with a version of our GC benchmark that was slightly modified to run multiple concurrent client threads in the same address space. Each client thread does the same work as the original benchmark, but they share a heap. This benchmark involves very little work outside of memory allocation. This was run with GC 6.0alpha3 on a dual processor Pentium III/500 machine under Linux 2.2.12.

    Running with a thread-unsafe collector, the benchmark ran in 9 seconds. With the simple thread-safe collector, built with -DLINUX_THREADS, the execution time increased to 10.3 seconds, or 23.5 elapsed seconds with two clients. (The times for the malloc/ifree version with glibc malloc are 10.51 (standard library, pthreads not linked), 20.90 (one thread, pthreads linked), and 24.55 seconds respectively. The benchmark favors a garbage collector, since most objects are small.)

    The following table gives execution times for the collector built with parallel marking and thread-local allocation support (-DGC_LINUX_THREADS -DPARALLEL_MARK -DTHREAD_LOCAL_ALLOC). We tested the client using either one or two marker threads, and running one or two client threads. Note that the client uses thread local allocation exclusively. With -DTHREAD_LOCAL_ALLOC the collector switches to a locking strategy that is better tuned to less frequent lock acquisition. The standard allocation primitives thus perform slightly worse than without -DTHREAD_LOCAL_ALLOC, and should be avoided in time-critical code.

    (The results using pthread_mutex_lock directly for allocation locking would have been worse still, at least for older versions of linuxthreads. With THREAD_LOCAL_ALLOC, we first repeatedly try to acquire the lock with pthread_mutex_try_lock(), busy_waiting between attempts. After a fixed number of attempts, we use pthread_mutex_lock().)

    These measurements do not use incremental collection, nor was prefetching enabled in the marker. We used the C version of the benchmark. All measurements are in elapsed seconds on an unloaded machine.

    Number of threads1 marker thread (secs.) 2 marker threads (secs.)
    1 client10.457.85
    2 clients19.9512.3
    The execution time for the single threaded case is slightly worse than with simple locking. However, even the single-threaded benchmark runs faster than even the thread-unsafe version if a second processor is available. The execution time for two clients with thread local allocation time is only 1.4 times the sequential execution time for a single thread in a thread-unsafe environment, even though it involves twice the client work. That represents close to a factor of 2 improvement over the 2 client case with the old collector. The old collector clearly still suffered from some contention overhead, in spite of the fact that the locking scheme had been fairly well tuned.

    Full linear speedup (i.e. the same execution time for 1 client on one processor as 2 clients on 2 processors) is probably not achievable on this kind of hardware even with such a small number of processors, since the memory system is a major constraint for the garbage collector, the processors usually share a single memory bus, and thus the aggregate memory bandwidth does not increase in proportion to the number of processors.

    These results are likely to be very sensitive to both hardware and OS issues. Preliminary experiments with an older Pentium Pro machine running an older kernel were far less encouraging. ecl-16.1.2/src/bdwgc/doc/simple_example.html000066400000000000000000000202001266352375300206660ustar00rootroot00000000000000 Using the Garbage Collector: A simple example

    Using the Garbage Collector: A simple example

    The following consists of step-by-step instructions for building and using the collector. We'll assume a Linux/gcc platform and a single-threaded application. The green text contains information about other platforms or scenarios. It can be skipped, especially on first reading.

    Building the collector

    If you haven't already so, unpack the collector and enter the newly created directory with 
    tar xvfz gc<version>.tar.gz
cd gc<version>

    You can configure, build, and install the collector in a private directory, say /home/xyz/gc, with the following commands: 

    ./configure --prefix=/home/xyz/gc --disable-threads
make
make check
make install
    Here the "make check" command is optional, but highly recommended. It runs a basic correctness test which usually takes well under a minute.

    Other platforms

    On non-Unix, non-Linux platforms, the collector is usually built by copying the appropriate makefile (see the platform-specific README in doc/README.xxx in the distribution) to the file "Makefile", and then typing "make" (or "nmake" or ...). This builds the library in the source tree. You may want to move it and the files in the include directory to a more convenient place.

    If you use a makefile that does not require running a configure script, you should first look at the makefile, and adjust any options that are documented there.

    If your platform provides a "make" utility, that is generally preferred to platform- and compiler- dependent "project" files. (At least that is the strong preference of the would-be maintainer of those project files.)

    Threads

    If you need thread support, configure the collector with 
    --enable-threads=posix --enable-thread-local-alloc --enable-parallel-mark
    instead of --disable-threads If your target is a real old-fashioned uniprocessor (no "hyperthreading", etc.) you will want to omit --enable-parallel-mark.

    C++

    You will need to include the C++ support, which unfortunately tends to be among the least portable parts of the collector, since it seems to rely on some corner cases of the language. On Linux, it suffices to add --enable-cplusplus to the configure options.

    Writing the program

    You will need a 
    #include "gc.h"
    at the beginning of every file that allocates memory through the garbage collector. Call GC_MALLOC wherever you would have call malloc. This initializes memory to zero like calloc; there is no need to explicitly clear the result.

    If you know that an object will not contain pointers to the garbage-collected heap, and you don't need it to be initialized, call GC_MALLOC_ATOMIC instead.

    A function GC_FREE is provided but need not be called. For very small objects, your program will probably perform better if you do not call it, and let the collector do its job.

    A GC_REALLOC function behaves like the C library realloc. It allocates uninitialized pointer-free memory if the original object was allocated that way.

    The following program loop.c is a trivial example: 

    #include "gc.h"
#include <assert.h>
#include <stdio.h>

int main()
{
  int i;

  GC_INIT();
  for (i = 0; i < 10000000; ++i)
   {
     int **p = (int **) GC_MALLOC(sizeof(int *));
     int *q = (int *) GC_MALLOC_ATOMIC(sizeof(int));
     assert(*p == 0);
     *p = (int *) GC_REALLOC(q, 2 * sizeof(int));
     if (i % 100000 == 0)
       printf("Heap size = %d\n", GC_get_heap_size());
   }
  return 0;
}

    Interaction with the system malloc

    It is usually best not to mix garbage-collected allocation with the system malloc-free. If you do, you need to be careful not to store pointers to the garbage-collected heap in memory allocated with the system malloc.

    Other Platforms

    On some other platforms it is necessary to call GC_INIT() from the main program, which is presumed to be part of the main executable, not a dynamic library. This can never hurt, and is thus generally good practice.

    Threads

    For a multi-threaded program, some more rules apply:
    • Files that either allocate through the GC or make thread-related calls should first define the macro GC_THREADS, and then include "gc.h". On some platforms this will redefine some threads primitives, e.g. to let the collector keep track of thread creation.
    • To take advantage of fast thread-local allocation in versions before 7.0, use the following instead of including gc.h: 
      #define GC_REDIRECT_TO_LOCAL
#include "gc_local_alloc.h"
      This will cause GC_MALLOC and GC_MALLOC_ATOMIC to keep per-thread allocation caches, and greatly reduce the number of lock acquisitions during allocation. For versions after 7.0, this happens implicitly if the collector is built with thread-local allocation enabled.

    C++

    In the case of C++, you need to be especially careful not to store pointers to the garbage-collected heap in areas that are not traced by the collector. The collector includes some alternate interfaces to make that easier.

    Debugging

    Additional debug checks can be performed by defining GC_DEBUG before including gc.h. Additional options are available if the collector is also built with --enable-gc-debug (--enable-full-debug in some older versions) and all allocations are performed with GC_DEBUG defined.

    What if I can't rewrite/recompile my program?

    You may be able to build the collector with --enable-redirect-malloc and set the LD_PRELOAD environment variable to point to the resulting library, thus replacing the standard malloc with its garbage-collected counterpart. This is rather platform dependent. See the leak detection documentation for some more details.

    Compiling and linking

    The above application loop.c test program can be compiled and linked with 
    cc -I/home/xyz/gc/include loop.c /home/xyz/gc/lib/libgc.a -o loop
    The -I option directs the compiler to the right include directory. In this case, we list the static library directly on the compile line; the dynamic library could have been used instead, provided we arranged for the dynamic loader to find it, e.g. by setting LD_LIBRARY_PATH.

    Threads

    On pthread platforms, you will of course also have to link with -lpthread, and compile with any thread-safety options required by your compiler. On some platforms, you may also need to link with -ldl or -lrt. Looking at tools/threadlibs.c should give you the appropriate list if a plain -lpthread doesn't work.

    Running the executable

    The executable can of course be run normally, e.g. by typing 
    ./loop
    The operation of the collector is affected by a number of environment variables. For example, setting GC_PRINT_STATS produces some GC statistics on stdout. See README.environment in the distribution for details. ecl-16.1.2/src/bdwgc/doc/tree.html000066400000000000000000000242701266352375300166340ustar00rootroot00000000000000 Two-Level Tree Structure for Fast Pointer Lookup Hans-J. Boehm, Silicon Graphics (now at HP)

    Two-Level Tree Structure for Fast Pointer Lookup

    The BDWGC conservative garbage collector uses a 2-level tree data structure to aid in fast pointer identification. This data structure is described in a bit more detail here, since

    1. Variations of the data structure are more generally useful.
    2. It appears to be hard to understand by reading the code.
    3. Some other collectors appear to use inferior data structures to solve the same problem.
    4. It is central to fast collector operation.
    A candidate pointer is divided into three sections, the high, middle, and low bits. The exact division between these three groups of bits is dependent on the detailed collector configuration.

    The high and middle bits are used to look up an entry in the table described here. The resulting table entry consists of either a block descriptor (struct hblkhdr * or hdr *) identifying the layout of objects in the block, or an indication that this address range corresponds to the middle of a large block, together with a hint for locating the actual block descriptor. Such a hint consist of a displacement that can be subtracted from the middle bits of the candidate pointer without leaving the object.

    In either case, the block descriptor (struct hblkhdr) refers to a table of object starting addresses (the hb_map field). The starting address table is indexed by the low bits if the candidate pointer. The resulting entry contains a displacement to the beginning of the object, or an indication that this cannot be a valid object pointer. (If all interior pointer are recognized, pointers into large objects are handled specially, as appropriate.)

    The Tree

    The rest of this discussion focuses on the two level data structure used to map the high and middle bits to the block descriptor.

    The high bits are used as an index into the GC_top_index (really GC_arrays._top_index) array. Each entry points to a bottom_index data structure. This structure in turn consists mostly of an array index indexed by the middle bits of the candidate pointer. The index array contains the actual hdr pointers.

    Thus a pointer lookup consists primarily of a handful of memory references, and can be quite fast:

    1. The appropriate bottom_index pointer is looked up in GC_top_index, based on the high bits of the candidate pointer.
    2. The appropriate hdr pointer is looked up in the bottom_index structure, based on the middle bits.
    3. The block layout map pointer is retrieved from the hdr structure. (This memory reference is necessary since we try to share block layout maps.)
    4. The displacement to the beginning of the object is retrieved from the above map.

    In order to conserve space, not all GC_top_index entries in fact point to distinct bottom_index structures. If no address with the corresponding high bits is part of the heap, then the entry points to GC_all_nils, a single bottom_index structure consisting only of NULL hdr pointers.

    Bottom_index structures contain slightly more information than just hdr pointers. The asc_link field is used to link all bottom_index structures in ascending order for fast traversal. This list is pointed to be GC_all_bottom_indices. It is maintained with the aid of key field that contains the high bits corresponding to the bottom_index.

    64 bit addresses

    In the case of 64 bit addresses, this picture is complicated slightly by the fact that one of the index structures would have to be huge to cover the entire address space with a two level tree. We deal with this by turning GC_top_index into a chained hash table, instead of a simple array. This adds a hash_link field to the bottom_index structure.

    The "hash function" consists of dropping the high bits. This is cheap to compute, and guarantees that there will be no collisions if the heap is contiguous and not excessively large.

    A picture

    The following is an ASCII diagram of the data structure. This was contributed by Dave Barrett several years ago. 

    
                Data Structure used by GC_base in gc3.7:
                              21-Apr-94




    63                  LOG_TOP_SZ[11]  LOG_BOTTOM_SZ[10]   LOG_HBLKSIZE[13]
   +------------------+----------------+------------------+------------------+
 p:|                  |   TL_HASH(hi)  |                  |   HBLKDISPL(p)   |
   +------------------+----------------+------------------+------------------+
    \-----------------------HBLKPTR(p)-------------------/
    \------------hi-------------------/
                      \______ ________/ \________ _______/ \________ _______/
                             V                   V                  V
                             |                   |                  |
           GC_top_index[]    |                   |                  |
 ---      +--------------+   |                   |                  |
  ^       |              |   |                   |                  |
  |       |              |   |                   |                  |
 TOP      +--------------+<--+                   |                  |
 _SZ   +-<|      []      | *                     |                  |
(items)|  +--------------+  if 0 < bi< HBLKSIZE  |                  |
  |    |  |              | then large object     |                  |
  |    |  |              | starts at the bi'th   |                  |
  v    |  |              | HBLK before p.        |             i    |
 ---   |  +--------------+                       |          (word-  |
       v                                         |         aligned) |
   bi= |GET_BI(p){->hash_link}->key==hi          |                  |
       v                                         |                  |
       |   (bottom_index)  \ scratch_alloc'd     |                  |
       |   ( struct  bi )  / by get_index()      |                  |
 ---   +->+--------------+                       |                  |
  ^       |              |                       |                  |
  ^       |              |                       |                  |
 BOTTOM   |              |   ha=GET_HDR_ADDR(p)  |                  |
_SZ(items)+--------------+<----------------------+          +-------+
  |   +--<|   index[]    |                                  |
  |   |   +--------------+                      GC_obj_map: v
  |   |   |              |              from      / +-+-+-----+-+-+-+-+  ---
  v   |   |              |              GC_add   < 0| | |     | | | | |   ^
 ---  |   +--------------+             _map_entry \ +-+-+-----+-+-+-+-+   |
      |   |   asc_link   |                          +-+-+-----+-+-+-+-+ MAXOBJSZ
      |   +--------------+                      +-->| | |  j  | | | | |  +1
      |   |     key      |                      |   +-+-+-----+-+-+-+-+   |
      |   +--------------+                      |   +-+-+-----+-+-+-+-+   |
      |   |  hash_link   |                      |   | | |     | | | | |   v
      |   +--------------+                      |   +-+-+-----+-+-+-+-+  ---
      |                                         |   |<--MAX_OFFSET--->|
      |                                         |         (bytes)
HDR(p)| GC_find_header(p)                       |   |<--MAP_ENTRIES-->|
      |                           \ from        |    =HBLKSIZE/WORDSZ
      |    (hdr) (struct hblkhdr) / alloc_hdr() |    (1024 on Alpha)
      +-->+----------------------+              |    (8/16 bits each)
GET_HDR(p)| word   hb_sz (words) |              |
          +----------------------+              |
          | struct hblk *hb_next |              |
          +----------------------+              |
          |mark_proc hb_mark_proc|              |
          +----------------------+              |
          | char * hb_map        |>-------------+
          +----------------------+
          | ushort hb_obj_kind   |
          +----------------------+
          |   hb_last_reclaimed  |
 ---      +----------------------+
  ^       |                      |
 MARK_BITS|       hb_marks[]     | *if hdr is free, hb_sz
_SZ(words)|                      |  is the size of a heap chunk (struct hblk)
  v       |                      |  of at least MININCR*HBLKSIZE bytes (below),
 ---      +----------------------+  otherwise, size of each object in chunk.

Dynamic data structures above are interleaved throughout the heap in blocks of
size MININCR * HBLKSIZE bytes as done by gc_scratch_alloc which cannot be
freed; free lists are used (e.g. alloc_hdr).  HBLK's below are collected.

              (struct hblk)                                  HDR_BYTES
 ---      +----------------------+ < HBLKSIZE  ---            (bytes)
  ^       +-----hb_body----------+ (and WORDSZ) ^         ---   ---
  |       |                      |   aligned    |          ^     ^
  |       |                      |              |        hb_sz   |
  |       |                      |              |       (words)  |
  |       |      Object 0        |              |          |     |
  |       |                      |            i |(word-    v     |
  |       + - - - - - - - - - - -+ ---   (bytes)|aligned) ---    |
  |       |                      |  ^           |          ^     |
  |       |                      |  j (words)   |          |     |
  n *     |      Object 1        |  v           v        hb_sz BODY_SZ
 HBLKSIZE |                      |---------------          |   (words)
 (bytes)  |                      |                         v   MAX_OFFSET
  |       + - - - - - - - - - - -+                        ---  (bytes)
  |       |                      | !All_INTERIOR_PTRS      ^     |
  |       |                      | sets j only for       hb_sz   |
  |       |      Object N        | valid object offsets.   |     |
  v       |                      | All objects WORDSZ      v     v
 ---      +----------------------+ aligned.               ---   ---
    ecl-16.1.2/src/bdwgc/dyn_load.c000066400000000000000000001472211266352375300162010ustar00rootroot00000000000000/* * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. * Copyright (c) 1997 by Silicon Graphics. All rights reserved. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. */ #include "private/gc_priv.h" /* * This is incredibly OS specific code for tracking down data sections in * dynamic libraries. There appears to be no way of doing this quickly * without groveling through undocumented data structures. We would argue * that this is a bug in the design of the dlopen interface. THIS CODE * MAY BREAK IN FUTURE OS RELEASES. If this matters to you, don't hesitate * to let your vendor know ... * * None of this is safe with dlclose and incremental collection. * But then not much of anything is safe in the presence of dlclose. */ #if !defined(MACOS) && !defined(_WIN32_WCE) && !defined(__CC_ARM) # include #endif /* BTL: avoid circular redefinition of dlopen if GC_SOLARIS_THREADS defined */ #undef GC_MUST_RESTORE_REDEFINED_DLOPEN #if defined(GC_PTHREADS) && !defined(GC_NO_DLOPEN) \ && !defined(GC_NO_THREAD_REDIRECTS) && !defined(GC_USE_LD_WRAP) /* To support threads in Solaris, gc.h interposes on dlopen by */ /* defining "dlopen" to be "GC_dlopen", which is implemented below. */ /* However, both GC_FirstDLOpenedLinkMap() and GC_dlopen() use the */ /* real system dlopen() in their implementation. We first remove */ /* gc.h's dlopen definition and restore it later, after GC_dlopen(). */ # undef dlopen # define GC_MUST_RESTORE_REDEFINED_DLOPEN #endif /* !GC_NO_DLOPEN */ /* A user-supplied routine (custom filter) that might be called to */ /* determine whether a DSO really needs to be scanned by the GC. */ /* 0 means no filter installed. May be unused on some platforms. */ /* FIXME: Add filter support for more platforms. */ STATIC GC_has_static_roots_func GC_has_static_roots = 0; #if (defined(DYNAMIC_LOADING) || defined(MSWIN32) || defined(MSWINCE) \ || defined(CYGWIN32)) && !defined(PCR) #if !defined(SOLARISDL) && !defined(IRIX5) && \ !defined(MSWIN32) && !defined(MSWINCE) && !defined(CYGWIN32) && \ !(defined(ALPHA) && defined(OSF1)) && \ !defined(HPUX) && !(defined(LINUX) && defined(__ELF__)) && \ !defined(AIX) && !defined(SCO_ELF) && !defined(DGUX) && \ !(defined(FREEBSD) && defined(__ELF__)) && \ !(defined(OPENBSD) && (defined(__ELF__) || defined(M68K))) && \ !(defined(NETBSD) && defined(__ELF__)) && !defined(HURD) && \ !defined(DARWIN) && !defined(CYGWIN32) --> We only know how to find data segments of dynamic libraries for the --> above. Additional SVR4 variants might not be too --> hard to add. #endif #include #ifdef SOLARISDL # include # include # include #endif #if defined(NETBSD) # include # include # include # define ELFSIZE ARCH_ELFSIZE #endif #if defined(OPENBSD) # include # if OpenBSD >= 200519 # define HAVE_DL_ITERATE_PHDR # endif #endif /* OPENBSD */ #if defined(SCO_ELF) || defined(DGUX) || defined(HURD) \ || (defined(__ELF__) && (defined(LINUX) || defined(FREEBSD) \ || defined(NETBSD) || defined(OPENBSD))) # include # if !defined(OPENBSD) && !defined(PLATFORM_ANDROID) /* OpenBSD does not have elf.h file; link.h below is sufficient. */ /* Exclude Android because linker.h below includes its own version. */ # include # endif # ifdef PLATFORM_ANDROID /* If you don't need the "dynamic loading" feature, you may build */ /* the collector with -D IGNORE_DYNAMIC_LOADING. */ # ifdef BIONIC_ELFDATA_REDEF_BUG /* Workaround a problem in Bionic (as of Android 4.2) which has */ /* mismatching ELF_DATA definitions in sys/exec_elf.h and */ /* asm/elf.h included from linker.h file (similar to EM_ALPHA). */ # include # include # undef ELF_DATA # undef EM_ALPHA # endif # include # if !defined(GC_DONT_DEFINE_LINK_MAP) /* link_map and r_debug should be defined explicitly, */ /* as only bionic/linker/linker.h defines them but the header */ /* itself is a C++ one starting from Android 4.3. */ struct link_map { uintptr_t l_addr; char* l_name; uintptr_t l_ld; struct link_map* l_next; struct link_map* l_prev; }; struct r_debug { int32_t r_version; struct link_map* r_map; void (*r_brk)(void); int32_t r_state; uintptr_t r_ldbase; }; # endif # else # include # endif #endif /* Newer versions of GNU/Linux define this macro. We * define it similarly for any ELF systems that don't. */ # ifndef ElfW # if defined(FREEBSD) # if __ELF_WORD_SIZE == 32 # define ElfW(type) Elf32_##type # else # define ElfW(type) Elf64_##type # endif # elif defined(NETBSD) || defined(OPENBSD) # if ELFSIZE == 32 # define ElfW(type) Elf32_##type # else # define ElfW(type) Elf64_##type # endif # else # if !defined(ELF_CLASS) || ELF_CLASS == ELFCLASS32 # define ElfW(type) Elf32_##type # else # define ElfW(type) Elf64_##type # endif # endif # endif #if defined(SOLARISDL) && !defined(USE_PROC_FOR_LIBRARIES) #ifdef LINT Elf32_Dyn _DYNAMIC; #endif STATIC struct link_map * GC_FirstDLOpenedLinkMap(void) { extern ElfW(Dyn) _DYNAMIC; ElfW(Dyn) *dp; static struct link_map * cachedResult = 0; static ElfW(Dyn) *dynStructureAddr = 0; /* BTL: added to avoid Solaris 5.3 ld.so _DYNAMIC bug */ # ifdef SUNOS53_SHARED_LIB /* BTL: Avoid the Solaris 5.3 bug that _DYNAMIC isn't being set */ /* up properly in dynamically linked .so's. This means we have */ /* to use its value in the set of original object files loaded */ /* at program startup. */ if( dynStructureAddr == 0 ) { void* startupSyms = dlopen(0, RTLD_LAZY); dynStructureAddr = (ElfW(Dyn)*)dlsym(startupSyms, "_DYNAMIC"); } # else dynStructureAddr = &_DYNAMIC; # endif if (dynStructureAddr == 0) { /* _DYNAMIC symbol not resolved. */ return(0); } if( cachedResult == 0 ) { int tag; for( dp = ((ElfW(Dyn) *)(&_DYNAMIC)); (tag = dp->d_tag) != 0; dp++ ) { if( tag == DT_DEBUG ) { struct link_map *lm = ((struct r_debug *)(dp->d_un.d_ptr))->r_map; if( lm != 0 ) cachedResult = lm->l_next; /* might be NULL */ break; } } } return cachedResult; } #endif /* SOLARISDL ... */ /* BTL: added to fix circular dlopen definition if GC_SOLARIS_THREADS defined */ # ifdef GC_MUST_RESTORE_REDEFINED_DLOPEN # define dlopen GC_dlopen # endif # if defined(SOLARISDL) /* Add dynamic library data sections to the root set. */ # if !defined(PCR) && !defined(GC_SOLARIS_THREADS) && defined(THREADS) --> fix mutual exclusion with dlopen # endif # ifndef USE_PROC_FOR_LIBRARIES GC_INNER void GC_register_dynamic_libraries(void) { struct link_map *lm; for (lm = GC_FirstDLOpenedLinkMap(); lm != 0; lm = lm->l_next) { ElfW(Ehdr) * e; ElfW(Phdr) * p; unsigned long offset; char * start; int i; e = (ElfW(Ehdr) *) lm->l_addr; p = ((ElfW(Phdr) *)(((char *)(e)) + e->e_phoff)); offset = ((unsigned long)(lm->l_addr)); for( i = 0; i < (int)e->e_phnum; i++, p++ ) { switch( p->p_type ) { case PT_LOAD: { if( !(p->p_flags & PF_W) ) break; start = ((char *)(p->p_vaddr)) + offset; GC_add_roots_inner( start, start + p->p_memsz, TRUE ); } break; default: break; } } } } # endif /* !USE_PROC ... */ # endif /* SOLARISDL */ #if defined(SCO_ELF) || defined(DGUX) || defined(HURD) \ || (defined(__ELF__) && (defined(LINUX) || defined(FREEBSD) \ || defined(NETBSD) || defined(OPENBSD))) #ifdef USE_PROC_FOR_LIBRARIES #include #include #include #include #define MAPS_BUF_SIZE (32*1024) /* Sort an array of HeapSects by start address. */ /* Unfortunately at least some versions of */ /* Linux qsort end up calling malloc by way of sysconf, and hence can't */ /* be used in the collector. Hence we roll our own. Should be */ /* reasonably fast if the array is already mostly sorted, as we expect */ /* it to be. */ static void sort_heap_sects(struct HeapSect *base, size_t number_of_elements) { signed_word n = (signed_word)number_of_elements; signed_word nsorted = 1; signed_word i; while (nsorted < n) { while (nsorted < n && (word)base[nsorted-1].hs_start < (word)base[nsorted].hs_start) ++nsorted; if (nsorted == n) break; GC_ASSERT((word)base[nsorted-1].hs_start > (word)base[nsorted].hs_start); i = nsorted - 1; while (i >= 0 && (word)base[i].hs_start > (word)base[i+1].hs_start) { struct HeapSect tmp = base[i]; base[i] = base[i+1]; base[i+1] = tmp; --i; } GC_ASSERT((word)base[nsorted-1].hs_start < (word)base[nsorted].hs_start); ++nsorted; } } STATIC word GC_register_map_entries(char *maps) { char *prot; char *buf_ptr = maps; ptr_t start, end; unsigned int maj_dev; ptr_t least_ha, greatest_ha; unsigned i; ptr_t datastart; # ifdef DATASTART_IS_FUNC static ptr_t datastart_cached = (ptr_t)(word)-1; /* Evaluate DATASTART only once. */ if (datastart_cached == (ptr_t)(word)-1) { datastart_cached = (ptr_t)(DATASTART); } datastart = datastart_cached; # else datastart = (ptr_t)(DATASTART); # endif GC_ASSERT(I_HOLD_LOCK()); sort_heap_sects(GC_our_memory, GC_n_memory); least_ha = GC_our_memory[0].hs_start; greatest_ha = GC_our_memory[GC_n_memory-1].hs_start + GC_our_memory[GC_n_memory-1].hs_bytes; for (;;) { buf_ptr = GC_parse_map_entry(buf_ptr, &start, &end, &prot, &maj_dev, 0); if (buf_ptr == NULL) return 1; if (prot[1] == 'w') { /* This is a writable mapping. Add it to */ /* the root set unless it is already otherwise */ /* accounted for. */ if ((word)start <= (word)GC_stackbottom && (word)end >= (word)GC_stackbottom) { /* Stack mapping; discard */ continue; } # ifdef THREADS /* This may fail, since a thread may already be */ /* unregistered, but its thread stack may still be there. */ /* That can fail because the stack may disappear while */ /* we're marking. Thus the marker is, and has to be */ /* prepared to recover from segmentation faults. */ if (GC_segment_is_thread_stack(start, end)) continue; /* FIXME: NPTL squirrels */ /* away pointers in pieces of the stack segment that we */ /* don't scan. We work around this */ /* by treating anything allocated by libpthread as */ /* uncollectible, as we do in some other cases. */ /* A specifically identified problem is that */ /* thread stacks contain pointers to dynamic thread */ /* vectors, which may be reused due to thread caching. */ /* They may not be marked if the thread is still live. */ /* This specific instance should be addressed by */ /* INCLUDE_LINUX_THREAD_DESCR, but that doesn't quite */ /* seem to suffice. */ /* We currently trace entire thread stacks, if they are */ /* are currently cached but unused. This is */ /* very suboptimal for performance reasons. */ # endif /* We no longer exclude the main data segment. */ if ((word)end <= (word)least_ha || (word)start >= (word)greatest_ha) { /* The easy case; just trace entire segment */ GC_add_roots_inner((char *)start, (char *)end, TRUE); continue; } /* Add sections that don't belong to us. */ i = 0; while ((word)(GC_our_memory[i].hs_start + GC_our_memory[i].hs_bytes) < (word)start) ++i; GC_ASSERT(i < GC_n_memory); if ((word)GC_our_memory[i].hs_start <= (word)start) { start = GC_our_memory[i].hs_start + GC_our_memory[i].hs_bytes; ++i; } while (i < GC_n_memory && (word)GC_our_memory[i].hs_start < (word)end && (word)start < (word)end) { if ((word)start < (word)GC_our_memory[i].hs_start) GC_add_roots_inner((char *)start, GC_our_memory[i].hs_start, TRUE); start = GC_our_memory[i].hs_start + GC_our_memory[i].hs_bytes; ++i; } if ((word)start < (word)end) GC_add_roots_inner((char *)start, (char *)end, TRUE); } } return 1; } GC_INNER void GC_register_dynamic_libraries(void) { if (!GC_register_map_entries(GC_get_maps())) ABORT("Failed to read /proc for library registration"); } /* We now take care of the main data segment ourselves: */ GC_INNER GC_bool GC_register_main_static_data(void) { return FALSE; } # define HAVE_REGISTER_MAIN_STATIC_DATA #else /* !USE_PROC_FOR_LIBRARIES */ /* The following is the preferred way to walk dynamic libraries */ /* for glibc 2.2.4+. Unfortunately, it doesn't work for older */ /* versions. Thanks to Jakub Jelinek for most of the code. */ #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ > 2) \ || (__GLIBC__ == 2 && __GLIBC_MINOR__ == 2 && defined(DT_CONFIG)) \ || defined(PLATFORM_ANDROID) /* Are others OK here, too? */ /* We have the header files for a glibc that includes dl_iterate_phdr. */ /* It may still not be available in the library on the target system. */ /* Thus we also treat it as a weak symbol. */ # define HAVE_DL_ITERATE_PHDR # ifdef PLATFORM_ANDROID /* Android headers might have no such definition for some targets. */ int dl_iterate_phdr(int (*cb)(struct dl_phdr_info *, size_t, void *), void *data); # endif # pragma weak dl_iterate_phdr #endif #if (defined(FREEBSD) && __FreeBSD__ >= 7) /* On the FreeBSD system, any target system at major version 7 shall */ /* have dl_iterate_phdr; therefore, we need not make it weak as above. */ # define HAVE_DL_ITERATE_PHDR # define DL_ITERATE_PHDR_STRONG #endif #if defined(HAVE_DL_ITERATE_PHDR) # ifdef PT_GNU_RELRO /* Instead of registering PT_LOAD sections directly, we keep them */ /* in a temporary list, and filter them by excluding PT_GNU_RELRO */ /* segments. Processing PT_GNU_RELRO sections with */ /* GC_exclude_static_roots instead would be superficially cleaner. But */ /* it runs into trouble if a client registers an overlapping segment, */ /* which unfortunately seems quite possible. */ # define MAX_LOAD_SEGS MAX_ROOT_SETS static struct load_segment { ptr_t start; ptr_t end; /* Room for a second segment if we remove a RELRO segment */ /* from the middle. */ ptr_t start2; ptr_t end2; } load_segs[MAX_LOAD_SEGS]; static int n_load_segs; # endif /* PT_GNU_RELRO */ STATIC int GC_register_dynlib_callback(struct dl_phdr_info * info, size_t size, void * ptr) { const ElfW(Phdr) * p; ptr_t start, end; int i; /* Make sure struct dl_phdr_info is at least as big as we need. */ if (size < offsetof (struct dl_phdr_info, dlpi_phnum) + sizeof (info->dlpi_phnum)) return -1; p = info->dlpi_phdr; for( i = 0; i < (int)info->dlpi_phnum; i++, p++ ) { switch( p->p_type ) { # ifdef PT_GNU_RELRO case PT_GNU_RELRO: /* This entry is known to be constant and will eventually be remapped read-only. However, the address range covered by this entry is typically a subset of a previously encountered "LOAD" segment, so we need to exclude it. */ { int j; start = ((ptr_t)(p->p_vaddr)) + info->dlpi_addr; end = start + p->p_memsz; for (j = n_load_segs; --j >= 0; ) { if ((word)start >= (word)load_segs[j].start && (word)start < (word)load_segs[j].end) { if (load_segs[j].start2 != 0) { WARN("More than one GNU_RELRO segment per load seg\n",0); } else { GC_ASSERT((word)end <= (word)load_segs[j].end); /* Remove from the existing load segment */ load_segs[j].end2 = load_segs[j].end; load_segs[j].end = start; load_segs[j].start2 = end; } break; } if (j == 0) WARN("Failed to find PT_GNU_RELRO segment" " inside PT_LOAD region", 0); } } break; # endif case PT_LOAD: { GC_has_static_roots_func callback = GC_has_static_roots; if( !(p->p_flags & PF_W) ) break; start = ((char *)(p->p_vaddr)) + info->dlpi_addr; end = start + p->p_memsz; if (callback != 0 && !callback(info->dlpi_name, start, p->p_memsz)) break; # ifdef PT_GNU_RELRO if (n_load_segs >= MAX_LOAD_SEGS) ABORT("Too many PT_LOAD segs"); # if CPP_WORDSZ == 64 /* FIXME: GC_push_all eventually does the correct */ /* rounding to the next multiple of ALIGNMENT, so, most */ /* probably, we should remove the corresponding assertion */ /* check in GC_add_roots_inner along with this code line. */ /* start pointer value may require aligning */ start = (ptr_t)((word)start & ~(sizeof(word) - 1)); # endif load_segs[n_load_segs].start = start; load_segs[n_load_segs].end = end; load_segs[n_load_segs].start2 = 0; load_segs[n_load_segs].end2 = 0; ++n_load_segs; # else GC_add_roots_inner(start, end, TRUE); # endif /* PT_GNU_RELRO */ } break; default: break; } } *(int *)ptr = 1; /* Signal that we were called */ return 0; } /* Do we need to separately register the main static data segment? */ GC_INNER GC_bool GC_register_main_static_data(void) { # ifdef DL_ITERATE_PHDR_STRONG /* If dl_iterate_phdr is not a weak symbol then don't test against */ /* zero (otherwise a compiler might issue a warning). */ return FALSE; # else return (dl_iterate_phdr == 0); /* implicit conversion to function ptr */ # endif } /* Return TRUE if we succeed, FALSE if dl_iterate_phdr wasn't there. */ STATIC GC_bool GC_register_dynamic_libraries_dl_iterate_phdr(void) { int did_something; if (GC_register_main_static_data()) return FALSE; # ifdef PT_GNU_RELRO { static GC_bool excluded_segs = FALSE; n_load_segs = 0; if (!EXPECT(excluded_segs, TRUE)) { GC_exclude_static_roots_inner((ptr_t)load_segs, (ptr_t)load_segs + sizeof(load_segs)); excluded_segs = TRUE; } } # endif did_something = 0; dl_iterate_phdr(GC_register_dynlib_callback, &did_something); if (did_something) { # ifdef PT_GNU_RELRO int i; for (i = 0; i < n_load_segs; ++i) { if ((word)load_segs[i].end > (word)load_segs[i].start) { GC_add_roots_inner(load_segs[i].start, load_segs[i].end, TRUE); } if ((word)load_segs[i].end2 > (word)load_segs[i].start2) { GC_add_roots_inner(load_segs[i].start2, load_segs[i].end2, TRUE); } } # endif } else { char *datastart; char *dataend; # ifdef DATASTART_IS_FUNC static ptr_t datastart_cached = (ptr_t)(word)-1; /* Evaluate DATASTART only once. */ if (datastart_cached == (ptr_t)(word)-1) { datastart_cached = (ptr_t)(DATASTART); } datastart = (char *)datastart_cached; # else datastart = DATASTART; # endif # ifdef DATAEND_IS_FUNC { static ptr_t dataend_cached = 0; /* Evaluate DATAEND only once. */ if (dataend_cached == 0) { dataend_cached = (ptr_t)(DATAEND); } dataend = (char *)dataend_cached; } # else dataend = DATAEND; # endif /* dl_iterate_phdr may forget the static data segment in */ /* statically linked executables. */ GC_add_roots_inner(datastart, dataend, TRUE); # if defined(DATASTART2) GC_add_roots_inner(DATASTART2, (char *)(DATAEND2), TRUE); # endif } return TRUE; } # define HAVE_REGISTER_MAIN_STATIC_DATA #else /* !HAVE_DL_ITERATE_PHDR */ /* Dynamic loading code for Linux running ELF. Somewhat tested on * Linux/x86, untested but hopefully should work on Linux/Alpha. * This code was derived from the Solaris/ELF support. Thanks to * whatever kind soul wrote that. - Patrick Bridges */ /* This doesn't necessarily work in all cases, e.g. with preloaded * dynamic libraries. */ # if defined(NETBSD) || defined(OPENBSD) # include /* for compatibility with 1.4.x */ # ifndef DT_DEBUG # define DT_DEBUG 21 # endif # ifndef PT_LOAD # define PT_LOAD 1 # endif # ifndef PF_W # define PF_W 2 # endif # elif !defined(PLATFORM_ANDROID) # include # endif # ifndef PLATFORM_ANDROID # include # endif #endif /* !HAVE_DL_ITERATE_PHDR */ #ifdef __GNUC__ # pragma weak _DYNAMIC #endif extern ElfW(Dyn) _DYNAMIC[]; STATIC struct link_map * GC_FirstDLOpenedLinkMap(void) { ElfW(Dyn) *dp; static struct link_map *cachedResult = 0; if (0 == (ptr_t)_DYNAMIC) { /* _DYNAMIC symbol not resolved. */ return(0); } if( cachedResult == 0 ) { # if defined(NETBSD) && defined(RTLD_DI_LINKMAP) struct link_map *lm = NULL; if (!dlinfo(RTLD_SELF, RTLD_DI_LINKMAP, &lm) && lm != NULL) { /* Now lm points link_map object of libgc. Since it */ /* might not be the first dynamically linked object, */ /* try to find it (object next to the main object). */ while (lm->l_prev != NULL) { lm = lm->l_prev; } cachedResult = lm->l_next; } # else int tag; for( dp = _DYNAMIC; (tag = dp->d_tag) != 0; dp++ ) { if( tag == DT_DEBUG ) { struct link_map *lm = ((struct r_debug *)(dp->d_un.d_ptr))->r_map; if( lm != 0 ) cachedResult = lm->l_next; /* might be NULL */ break; } } # endif /* !NETBSD || !RTLD_DI_LINKMAP */ } return cachedResult; } GC_INNER void GC_register_dynamic_libraries(void) { struct link_map *lm; # ifdef HAVE_DL_ITERATE_PHDR if (GC_register_dynamic_libraries_dl_iterate_phdr()) { return; } # endif for (lm = GC_FirstDLOpenedLinkMap(); lm != 0; lm = lm->l_next) { ElfW(Ehdr) * e; ElfW(Phdr) * p; unsigned long offset; char * start; int i; e = (ElfW(Ehdr) *) lm->l_addr; # ifdef PLATFORM_ANDROID if (e == NULL) continue; # endif p = ((ElfW(Phdr) *)(((char *)(e)) + e->e_phoff)); offset = ((unsigned long)(lm->l_addr)); for( i = 0; i < (int)e->e_phnum; i++, p++ ) { switch( p->p_type ) { case PT_LOAD: { if( !(p->p_flags & PF_W) ) break; start = ((char *)(p->p_vaddr)) + offset; GC_add_roots_inner(start, start + p->p_memsz, TRUE); } break; default: break; } } } } #endif /* !USE_PROC_FOR_LIBRARIES */ #endif /* LINUX */ #if defined(IRIX5) || (defined(USE_PROC_FOR_LIBRARIES) && !defined(LINUX)) #include #include #include #include #include #include /* Only for the following test. */ #ifndef _sigargs # define IRIX6 #endif /* We use /proc to track down all parts of the address space that are */ /* mapped by the process, and throw out regions we know we shouldn't */ /* worry about. This may also work under other SVR4 variants. */ GC_INNER void GC_register_dynamic_libraries(void) { static int fd = -1; char buf[30]; static prmap_t * addr_map = 0; static int current_sz = 0; /* Number of records currently in addr_map */ static int needed_sz; /* Required size of addr_map */ int i; long flags; ptr_t start; ptr_t limit; ptr_t heap_start = HEAP_START; ptr_t heap_end = heap_start; # ifdef SOLARISDL # define MA_PHYS 0 # endif /* SOLARISDL */ if (fd < 0) { (void)snprintf(buf, sizeof(buf), "/proc/%ld", (long)getpid()); buf[sizeof(buf) - 1] = '\0'; /* The above generates a lint complaint, since pid_t varies. */ /* It's unclear how to improve this. */ fd = open(buf, O_RDONLY); if (fd < 0) { ABORT("/proc open failed"); } } if (ioctl(fd, PIOCNMAP, &needed_sz) < 0) { ABORT_ARG2("/proc PIOCNMAP ioctl failed", ": fd = %d, errno = %d", fd, errno); } if (needed_sz >= current_sz) { current_sz = needed_sz * 2 + 1; /* Expansion, plus room for 0 record */ addr_map = (prmap_t *)GC_scratch_alloc( (word)current_sz * sizeof(prmap_t)); if (addr_map == NULL) ABORT("Insufficient memory for address map"); } if (ioctl(fd, PIOCMAP, addr_map) < 0) { ABORT_ARG3("/proc PIOCMAP ioctl failed", ": errcode= %d, needed_sz= %d, addr_map= %p", errno, needed_sz, addr_map); }; if (GC_n_heap_sects > 0) { heap_end = GC_heap_sects[GC_n_heap_sects-1].hs_start + GC_heap_sects[GC_n_heap_sects-1].hs_bytes; if ((word)heap_end < (word)GC_scratch_last_end_ptr) heap_end = GC_scratch_last_end_ptr; } for (i = 0; i < needed_sz; i++) { flags = addr_map[i].pr_mflags; if ((flags & (MA_BREAK | MA_STACK | MA_PHYS | MA_FETCHOP | MA_NOTCACHED)) != 0) goto irrelevant; if ((flags & (MA_READ | MA_WRITE)) != (MA_READ | MA_WRITE)) goto irrelevant; /* The latter test is empirically useless in very old Irix */ /* versions. Other than the */ /* main data and stack segments, everything appears to be */ /* mapped readable, writable, executable, and shared(!!). */ /* This makes no sense to me. - HB */ start = (ptr_t)(addr_map[i].pr_vaddr); if (GC_roots_present(start)) goto irrelevant; if ((word)start < (word)heap_end && (word)start >= (word)heap_start) goto irrelevant; limit = start + addr_map[i].pr_size; /* The following seemed to be necessary for very old versions */ /* of Irix, but it has been reported to discard relevant */ /* segments under Irix 6.5. */ # ifndef IRIX6 if (addr_map[i].pr_off == 0 && strncmp(start, ELFMAG, 4) == 0) { /* Discard text segments, i.e. 0-offset mappings against */ /* executable files which appear to have ELF headers. */ caddr_t arg; int obj; # define MAP_IRR_SZ 10 static ptr_t map_irr[MAP_IRR_SZ]; /* Known irrelevant map entries */ static int n_irr = 0; struct stat buf; register int j; for (j = 0; j < n_irr; j++) { if (map_irr[j] == start) goto irrelevant; } arg = (caddr_t)start; obj = ioctl(fd, PIOCOPENM, &arg); if (obj >= 0) { fstat(obj, &buf); close(obj); if ((buf.st_mode & 0111) != 0) { if (n_irr < MAP_IRR_SZ) { map_irr[n_irr++] = start; } goto irrelevant; } } } # endif /* !IRIX6 */ GC_add_roots_inner(start, limit, TRUE); irrelevant: ; } /* Don't keep cached descriptor, for now. Some kernels don't like us */ /* to keep a /proc file descriptor around during kill -9. */ if (close(fd) < 0) ABORT("Couldn't close /proc file"); fd = -1; } # endif /* USE_PROC || IRIX5 */ # if defined(MSWIN32) || defined(MSWINCE) || defined(CYGWIN32) # ifndef WIN32_LEAN_AND_MEAN # define WIN32_LEAN_AND_MEAN 1 # endif # define NOSERVICE # include # include /* We traverse the entire address space and register all segments */ /* that could possibly have been written to. */ STATIC void GC_cond_add_roots(char *base, char * limit) { # ifdef GC_WIN32_THREADS char * curr_base = base; char * next_stack_lo; char * next_stack_hi; if (base == limit) return; for(;;) { GC_get_next_stack(curr_base, limit, &next_stack_lo, &next_stack_hi); if ((word)next_stack_lo >= (word)limit) break; if ((word)next_stack_lo > (word)curr_base) GC_add_roots_inner(curr_base, next_stack_lo, TRUE); curr_base = next_stack_hi; } if ((word)curr_base < (word)limit) GC_add_roots_inner(curr_base, limit, TRUE); # else char * stack_top = (char *)((word)GC_approx_sp() & ~(GC_sysinfo.dwAllocationGranularity - 1)); if (base == limit) return; if ((word)limit > (word)stack_top && (word)base < (word)GC_stackbottom) { /* Part of the stack; ignore it. */ return; } GC_add_roots_inner(base, limit, TRUE); # endif } #ifdef DYNAMIC_LOADING /* GC_register_main_static_data is not needed unless DYNAMIC_LOADING. */ GC_INNER GC_bool GC_register_main_static_data(void) { # if defined(MSWINCE) || defined(CYGWIN32) /* Do we need to separately register the main static data segment? */ return FALSE; # else return GC_no_win32_dlls; # endif } # define HAVE_REGISTER_MAIN_STATIC_DATA #endif /* DYNAMIC_LOADING */ # ifdef DEBUG_VIRTUALQUERY void GC_dump_meminfo(MEMORY_BASIC_INFORMATION *buf) { GC_printf("BaseAddress = 0x%lx, AllocationBase = 0x%lx," " RegionSize = 0x%lx(%lu)\n", buf -> BaseAddress, buf -> AllocationBase, buf -> RegionSize, buf -> RegionSize); GC_printf("\tAllocationProtect = 0x%lx, State = 0x%lx, Protect = 0x%lx, " "Type = 0x%lx\n", buf -> AllocationProtect, buf -> State, buf -> Protect, buf -> Type); } # endif /* DEBUG_VIRTUALQUERY */ # if defined(MSWINCE) || defined(CYGWIN32) /* FIXME: Should we really need to scan MEM_PRIVATE sections? */ /* For now, we don't add MEM_PRIVATE sections to the data roots for */ /* WinCE because otherwise SEGV fault sometimes happens to occur in */ /* GC_mark_from() (and, even if we use WRAP_MARK_SOME, WinCE prints */ /* a "Data Abort" message to the debugging console). */ /* To workaround that, use -DGC_REGISTER_MEM_PRIVATE. */ # define GC_wnt TRUE # endif GC_INNER void GC_register_dynamic_libraries(void) { MEMORY_BASIC_INFORMATION buf; size_t result; DWORD protect; LPVOID p; char * base; char * limit, * new_limit; # ifdef MSWIN32 if (GC_no_win32_dlls) return; # endif base = limit = p = GC_sysinfo.lpMinimumApplicationAddress; while ((word)p < (word)GC_sysinfo.lpMaximumApplicationAddress) { result = VirtualQuery(p, &buf, sizeof(buf)); # ifdef MSWINCE if (result == 0) { /* Page is free; advance to the next possible allocation base */ new_limit = (char *) (((DWORD) p + GC_sysinfo.dwAllocationGranularity) & ~(GC_sysinfo.dwAllocationGranularity-1)); } else # endif /* else */ { if (result != sizeof(buf)) { ABORT("Weird VirtualQuery result"); } new_limit = (char *)p + buf.RegionSize; protect = buf.Protect; if (buf.State == MEM_COMMIT && (protect == PAGE_EXECUTE_READWRITE || protect == PAGE_READWRITE) && (buf.Type == MEM_IMAGE # ifdef GC_REGISTER_MEM_PRIVATE || (protect == PAGE_READWRITE && buf.Type == MEM_PRIVATE) # else /* There is some evidence that we cannot always */ /* ignore MEM_PRIVATE sections under Windows ME */ /* and predecessors. Hence we now also check for */ /* that case. */ || (!GC_wnt && buf.Type == MEM_PRIVATE) # endif ) && !GC_is_heap_base(buf.AllocationBase)) { # ifdef DEBUG_VIRTUALQUERY GC_dump_meminfo(&buf); # endif if ((char *)p != limit) { GC_cond_add_roots(base, limit); base = p; } limit = new_limit; } } if ((word)p > (word)new_limit /* overflow */) break; p = (LPVOID)new_limit; } GC_cond_add_roots(base, limit); } #endif /* MSWIN32 || MSWINCE || CYGWIN32 */ #if defined(ALPHA) && defined(OSF1) #include extern char *sys_errlist[]; extern int sys_nerr; extern int errno; GC_INNER void GC_register_dynamic_libraries(void) { int status; ldr_process_t mypid; /* module */ ldr_module_t moduleid = LDR_NULL_MODULE; ldr_module_info_t moduleinfo; size_t moduleinfosize = sizeof(moduleinfo); size_t modulereturnsize; /* region */ ldr_region_t region; ldr_region_info_t regioninfo; size_t regioninfosize = sizeof(regioninfo); size_t regionreturnsize; /* Obtain id of this process */ mypid = ldr_my_process(); /* For each module */ while (TRUE) { /* Get the next (first) module */ status = ldr_next_module(mypid, &moduleid); /* Any more modules? */ if (moduleid == LDR_NULL_MODULE) break; /* No more modules */ /* Check status AFTER checking moduleid because */ /* of a bug in the non-shared ldr_next_module stub. */ if (status != 0) { ABORT_ARG3("ldr_next_module failed", ": status= %d, errcode= %d (%s)", status, errno, errno < sys_nerr ? sys_errlist[errno] : ""); } /* Get the module information */ status = ldr_inq_module(mypid, moduleid, &moduleinfo, moduleinfosize, &modulereturnsize); if (status != 0 ) ABORT("ldr_inq_module failed"); /* is module for the main program (i.e. nonshared portion)? */ if (moduleinfo.lmi_flags & LDR_MAIN) continue; /* skip the main module */ # ifdef DL_VERBOSE GC_log_printf("---Module---\n"); GC_log_printf("Module ID\t = %16ld\n", moduleinfo.lmi_modid); GC_log_printf("Count of regions = %16d\n", moduleinfo.lmi_nregion); GC_log_printf("flags for module = %16lx\n", moduleinfo.lmi_flags); GC_log_printf("module pathname\t = \"%s\"\n", moduleinfo.lmi_name); # endif /* For each region in this module */ for (region = 0; region < moduleinfo.lmi_nregion; region++) { /* Get the region information */ status = ldr_inq_region(mypid, moduleid, region, ®ioninfo, regioninfosize, ®ionreturnsize); if (status != 0 ) ABORT("ldr_inq_region failed"); /* only process writable (data) regions */ if (! (regioninfo.lri_prot & LDR_W)) continue; # ifdef DL_VERBOSE GC_log_printf("--- Region ---\n"); GC_log_printf("Region number\t = %16ld\n", regioninfo.lri_region_no); GC_log_printf("Protection flags = %016x\n", regioninfo.lri_prot); GC_log_printf("Virtual address\t = %16p\n", regioninfo.lri_vaddr); GC_log_printf("Mapped address\t = %16p\n", regioninfo.lri_mapaddr); GC_log_printf("Region size\t = %16ld\n", regioninfo.lri_size); GC_log_printf("Region name\t = \"%s\"\n", regioninfo.lri_name); # endif /* register region as a garbage collection root */ GC_add_roots_inner((char *)regioninfo.lri_mapaddr, (char *)regioninfo.lri_mapaddr + regioninfo.lri_size, TRUE); } } } #endif #if defined(HPUX) #include #include extern char *sys_errlist[]; extern int sys_nerr; GC_INNER void GC_register_dynamic_libraries(void) { int status; int index = 1; /* Ordinal position in shared library search list */ struct shl_descriptor *shl_desc; /* Shared library info, see dl.h */ /* For each dynamic library loaded */ while (TRUE) { /* Get info about next shared library */ status = shl_get(index, &shl_desc); /* Check if this is the end of the list or if some error occurred */ if (status != 0) { # ifdef GC_HPUX_THREADS /* I've seen errno values of 0. The man page is not clear */ /* as to whether errno should get set on a -1 return. */ break; # else if (errno == EINVAL) { break; /* Moved past end of shared library list --> finished */ } else { ABORT_ARG3("shl_get failed", ": status= %d, errcode= %d (%s)", status, errno, errno < sys_nerr ? sys_errlist[errno] : ""); } # endif } # ifdef DL_VERBOSE GC_log_printf("---Shared library---\n"); GC_log_printf("\tfilename\t= \"%s\"\n", shl_desc->filename); GC_log_printf("\tindex\t\t= %d\n", index); GC_log_printf("\thandle\t\t= %08x\n", (unsigned long) shl_desc->handle); GC_log_printf("\ttext seg.start\t= %08x\n", shl_desc->tstart); GC_log_printf("\ttext seg.end\t= %08x\n", shl_desc->tend); GC_log_printf("\tdata seg.start\t= %08x\n", shl_desc->dstart); GC_log_printf("\tdata seg.end\t= %08x\n", shl_desc->dend); GC_log_printf("\tref.count\t= %lu\n", shl_desc->ref_count); # endif /* register shared library's data segment as a garbage collection root */ GC_add_roots_inner((char *) shl_desc->dstart, (char *) shl_desc->dend, TRUE); index++; } } #endif /* HPUX */ #ifdef AIX # pragma alloca # include # include GC_INNER void GC_register_dynamic_libraries(void) { int len; char *ldibuf; int ldibuflen; struct ld_info *ldi; ldibuf = alloca(ldibuflen = 8192); while ( (len = loadquery(L_GETINFO,ldibuf,ldibuflen)) < 0) { if (errno != ENOMEM) { ABORT("loadquery failed"); } ldibuf = alloca(ldibuflen *= 2); } ldi = (struct ld_info *)ldibuf; while (ldi) { len = ldi->ldinfo_next; GC_add_roots_inner( ldi->ldinfo_dataorg, (ptr_t)(unsigned long)ldi->ldinfo_dataorg + ldi->ldinfo_datasize, TRUE); ldi = len ? (struct ld_info *)((char *)ldi + len) : 0; } } #endif /* AIX */ #ifdef DARWIN /* __private_extern__ hack required for pre-3.4 gcc versions. */ #ifndef __private_extern__ # define __private_extern__ extern # include # undef __private_extern__ #else # include #endif #include /*#define DARWIN_DEBUG*/ /* Writable sections generally available on Darwin. */ STATIC const struct { const char *seg; const char *sect; } GC_dyld_sections[] = { { SEG_DATA, SECT_DATA }, /* Used by FSF GCC, but not by OS X system tools, so far. */ { SEG_DATA, "__static_data" }, { SEG_DATA, SECT_BSS }, { SEG_DATA, SECT_COMMON }, /* FSF GCC - zero-sized object sections for targets */ /*supporting section anchors. */ { SEG_DATA, "__zobj_data" }, { SEG_DATA, "__zobj_bss" } }; /* Additional writable sections: */ /* GCC on Darwin constructs aligned sections "on demand", where */ /* the alignment size is embedded in the section name. */ /* Furthermore, there are distinctions between sections */ /* containing private vs. public symbols. It also constructs */ /* sections specifically for zero-sized objects, when the */ /* target supports section anchors. */ STATIC const char * const GC_dyld_add_sect_fmts[] = { "__bss%u", "__pu_bss%u", "__zo_bss%u", "__zo_pu_bss%u" }; /* Currently, mach-o will allow up to the max of 2^15 alignment */ /* in an object file. */ #ifndef L2_MAX_OFILE_ALIGNMENT # define L2_MAX_OFILE_ALIGNMENT 15 #endif STATIC const char *GC_dyld_name_for_hdr(const struct GC_MACH_HEADER *hdr) { unsigned long i, c; c = _dyld_image_count(); for (i = 0; i < c; i++) if ((const struct GC_MACH_HEADER *)_dyld_get_image_header(i) == hdr) return _dyld_get_image_name(i); return NULL; } /* This should never be called by a thread holding the lock. */ STATIC void GC_dyld_image_add(const struct GC_MACH_HEADER *hdr, intptr_t slide) { unsigned long start, end; unsigned i, j; const struct GC_MACH_SECTION *sec; const char *name; GC_has_static_roots_func callback = GC_has_static_roots; char secnam[16]; const char *fmt; DCL_LOCK_STATE; if (GC_no_dls) return; # ifdef DARWIN_DEBUG name = GC_dyld_name_for_hdr(hdr); # else name = callback != 0 ? GC_dyld_name_for_hdr(hdr) : NULL; # endif for (i = 0; i < sizeof(GC_dyld_sections)/sizeof(GC_dyld_sections[0]); i++) { sec = GC_GETSECTBYNAME(hdr, GC_dyld_sections[i].seg, GC_dyld_sections[i].sect); if (sec == NULL || sec->size < sizeof(word)) continue; start = slide + sec->addr; end = start + sec->size; LOCK(); /* The user callback is called holding the lock. */ if (callback == 0 || callback(name, (void*)start, (size_t)sec->size)) { # ifdef DARWIN_DEBUG GC_log_printf( "Adding section __DATA,%s at %p-%p (%lu bytes) from image %s\n", GC_dyld_sections[i].sect, (void*)start, (void*)end, (unsigned long)sec->size, name); # endif GC_add_roots_inner((ptr_t)start, (ptr_t)end, FALSE); } UNLOCK(); } /* Sections constructed on demand. */ for (j = 0; j < sizeof(GC_dyld_add_sect_fmts) / sizeof(char *); j++) { fmt = GC_dyld_add_sect_fmts[j]; /* Add our manufactured aligned BSS sections. */ for (i = 0; i <= L2_MAX_OFILE_ALIGNMENT; i++) { (void)snprintf(secnam, sizeof(secnam), fmt, (unsigned)i); secnam[sizeof(secnam) - 1] = '\0'; sec = GC_GETSECTBYNAME(hdr, SEG_DATA, secnam); if (sec == NULL || sec->size == 0) continue; start = slide + sec->addr; end = start + sec->size; # ifdef DARWIN_DEBUG GC_log_printf("Adding on-demand section __DATA,%s at" " %p-%p (%lu bytes) from image %s\n", secnam, (void*)start, (void*)end, (unsigned long)sec->size, name); # endif GC_add_roots((char*)start, (char*)end); } } # ifdef DARWIN_DEBUG GC_print_static_roots(); # endif } /* This should never be called by a thread holding the lock. */ STATIC void GC_dyld_image_remove(const struct GC_MACH_HEADER *hdr, intptr_t slide) { unsigned long start, end; unsigned i, j; const struct GC_MACH_SECTION *sec; char secnam[16]; const char *fmt; for (i = 0; i < sizeof(GC_dyld_sections)/sizeof(GC_dyld_sections[0]); i++) { sec = GC_GETSECTBYNAME(hdr, GC_dyld_sections[i].seg, GC_dyld_sections[i].sect); if (sec == NULL || sec->size == 0) continue; start = slide + sec->addr; end = start + sec->size; # ifdef DARWIN_DEBUG GC_log_printf( "Removing section __DATA,%s at %p-%p (%lu bytes) from image %s\n", GC_dyld_sections[i].sect, (void*)start, (void*)end, (unsigned long)sec->size, GC_dyld_name_for_hdr(hdr)); # endif GC_remove_roots((char*)start, (char*)end); } /* Remove our on-demand sections. */ for (j = 0; j < sizeof(GC_dyld_add_sect_fmts) / sizeof(char *); j++) { fmt = GC_dyld_add_sect_fmts[j]; for (i = 0; i <= L2_MAX_OFILE_ALIGNMENT; i++) { (void)snprintf(secnam, sizeof(secnam), fmt, (unsigned)i); secnam[sizeof(secnam) - 1] = '\0'; sec = GC_GETSECTBYNAME(hdr, SEG_DATA, secnam); if (sec == NULL || sec->size == 0) continue; start = slide + sec->addr; end = start + sec->size; # ifdef DARWIN_DEBUG GC_log_printf("Removing on-demand section __DATA,%s at" " %p-%p (%lu bytes) from image %s\n", secnam, (void*)start, (void*)end, (unsigned long)sec->size, GC_dyld_name_for_hdr(hdr)); # endif GC_remove_roots((char*)start, (char*)end); } } # ifdef DARWIN_DEBUG GC_print_static_roots(); # endif } GC_INNER void GC_register_dynamic_libraries(void) { /* Currently does nothing. The callbacks are setup by GC_init_dyld() The dyld library takes it from there. */ } /* The _dyld_* functions have an internal lock so no _dyld functions can be called while the world is stopped without the risk of a deadlock. Because of this we MUST setup callbacks BEFORE we ever stop the world. This should be called BEFORE any thread in created and WITHOUT the allocation lock held. */ GC_INNER void GC_init_dyld(void) { static GC_bool initialized = FALSE; if (initialized) return; # ifdef DARWIN_DEBUG GC_log_printf("Registering dyld callbacks...\n"); # endif /* Apple's Documentation: When you call _dyld_register_func_for_add_image, the dynamic linker runtime calls the specified callback (func) once for each of the images that is currently loaded into the program. When a new image is added to the program, your callback is called again with the mach_header for the new image, and the virtual memory slide amount of the new image. This WILL properly register already linked libraries and libraries linked in the future. */ _dyld_register_func_for_add_image(GC_dyld_image_add); _dyld_register_func_for_remove_image(GC_dyld_image_remove); /* Ignore 2 compiler warnings here: passing argument 1 of */ /* '_dyld_register_func_for_add/remove_image' from incompatible */ /* pointer type. */ /* Set this early to avoid reentrancy issues. */ initialized = TRUE; # ifdef NO_DYLD_BIND_FULLY_IMAGE /* FIXME: What should we do in this case? */ # else if (GC_no_dls) return; /* skip main data segment registration */ /* When the environment variable is set, the dynamic linker binds */ /* all undefined symbols the application needs at launch time. */ /* This includes function symbols that are normally bound lazily at */ /* the time of their first invocation. */ if (GETENV("DYLD_BIND_AT_LAUNCH") == 0) { /* The environment variable is unset, so we should bind manually. */ # ifdef DARWIN_DEBUG GC_log_printf("Forcing full bind of GC code...\n"); # endif /* FIXME: '_dyld_bind_fully_image_containing_address' is deprecated. */ if (!_dyld_bind_fully_image_containing_address( (unsigned long *)GC_malloc)) ABORT("_dyld_bind_fully_image_containing_address failed"); } # endif } #define HAVE_REGISTER_MAIN_STATIC_DATA GC_INNER GC_bool GC_register_main_static_data(void) { /* Already done through dyld callbacks */ return FALSE; } #endif /* DARWIN */ #elif defined(PCR) # include "il/PCR_IL.h" # include "th/PCR_ThCtl.h" # include "mm/PCR_MM.h" GC_INNER void GC_register_dynamic_libraries(void) { /* Add new static data areas of dynamically loaded modules. */ PCR_IL_LoadedFile * p = PCR_IL_GetLastLoadedFile(); PCR_IL_LoadedSegment * q; /* Skip uncommitted files */ while (p != NIL && !(p -> lf_commitPoint)) { /* The loading of this file has not yet been committed */ /* Hence its description could be inconsistent. */ /* Furthermore, it hasn't yet been run. Hence its data */ /* segments can't possibly reference heap allocated */ /* objects. */ p = p -> lf_prev; } for (; p != NIL; p = p -> lf_prev) { for (q = p -> lf_ls; q != NIL; q = q -> ls_next) { if ((q -> ls_flags & PCR_IL_SegFlags_Traced_MASK) == PCR_IL_SegFlags_Traced_on) { GC_add_roots_inner((char *)(q -> ls_addr), (char *)(q -> ls_addr) + q -> ls_bytes, TRUE); } } } } #endif /* PCR && !DYNAMIC_LOADING && !MSWIN32 */ #if !defined(HAVE_REGISTER_MAIN_STATIC_DATA) && defined(DYNAMIC_LOADING) /* Do we need to separately register the main static data segment? */ GC_INNER GC_bool GC_register_main_static_data(void) { return TRUE; } #endif /* HAVE_REGISTER_MAIN_STATIC_DATA */ /* Register a routine to filter dynamic library registration. */ GC_API void GC_CALL GC_register_has_static_roots_callback( GC_has_static_roots_func callback) { GC_has_static_roots = callback; } ecl-16.1.2/src/bdwgc/extra/000077500000000000000000000000001266352375300153605ustar00rootroot00000000000000ecl-16.1.2/src/bdwgc/extra/AmigaOS.c000066400000000000000000000375041266352375300170150ustar00rootroot00000000000000 /****************************************************************** AmigaOS-specific routines for GC. This file is normally included from os_dep.c ******************************************************************/ #if !defined(GC_AMIGA_DEF) && !defined(GC_AMIGA_SB) && !defined(GC_AMIGA_DS) && !defined(GC_AMIGA_AM) # include "gc_priv.h" # include # include # define GC_AMIGA_DEF # define GC_AMIGA_SB # define GC_AMIGA_DS # define GC_AMIGA_AM #endif #ifdef GC_AMIGA_DEF # ifndef __GNUC__ # include # endif # include # include # include # include #endif #ifdef GC_AMIGA_SB /****************************************************************** Find the base of the stack. ******************************************************************/ ptr_t GC_get_main_stack_base() { struct Process *proc = (struct Process*)SysBase->ThisTask; /* Reference: Amiga Guru Book Pages: 42,567,574 */ if (proc->pr_Task.tc_Node.ln_Type==NT_PROCESS && proc->pr_CLI != NULL) { /* first ULONG is StackSize */ /*longPtr = proc->pr_ReturnAddr; size = longPtr[0];*/ return (char *)proc->pr_ReturnAddr + sizeof(ULONG); } else { return (char *)proc->pr_Task.tc_SPUpper; } } #endif #ifdef GC_AMIGA_DS /****************************************************************** Register data segments. ******************************************************************/ void GC_register_data_segments() { struct Process *proc; struct CommandLineInterface *cli; BPTR myseglist; ULONG *data; int num; # ifdef __GNUC__ ULONG dataSegSize; GC_bool found_segment = FALSE; extern char __data_size[]; dataSegSize=__data_size+8; /* Can`t find the Location of __data_size, because it`s possible that is it, inside the segment. */ # endif proc= (struct Process*)SysBase->ThisTask; /* Reference: Amiga Guru Book Pages: 538ff,565,573 and XOper.asm */ if (proc->pr_Task.tc_Node.ln_Type==NT_PROCESS) { if (proc->pr_CLI == NULL) { myseglist = proc->pr_SegList; } else { /* ProcLoaded 'Loaded as a command: '*/ cli = BADDR(proc->pr_CLI); myseglist = cli->cli_Module; } } else { ABORT("Not a Process."); } if (myseglist == NULL) { ABORT("Arrrgh.. can't find segments, aborting"); } /* xoper hunks Shell Process */ num=0; for (data = (ULONG *)BADDR(myseglist); data != NULL; data = (ULONG *)BADDR(data[0])) { if (((ULONG) GC_register_data_segments < (ULONG) &data[1]) || ((ULONG) GC_register_data_segments > (ULONG) &data[1] + data[-1])) { # ifdef __GNUC__ if (dataSegSize == data[-1]) { found_segment = TRUE; } # endif GC_add_roots_inner((char *)&data[1], ((char *)&data[1]) + data[-1], FALSE); } ++num; } /* for */ # ifdef __GNUC__ if (!found_segment) { ABORT("Can`t find correct Segments.\nSolution: Use an newer version of ixemul.library"); } # endif } #endif #ifdef GC_AMIGA_AM #ifndef GC_AMIGA_FASTALLOC void *GC_amiga_allocwrapper(size_t size,void *(*AllocFunction)(size_t size2)){ return (*AllocFunction)(size); } void *(*GC_amiga_allocwrapper_do)(size_t size,void *(*AllocFunction)(size_t size2)) =GC_amiga_allocwrapper; #else void *GC_amiga_allocwrapper_firsttime(size_t size,void *(*AllocFunction)(size_t size2)); void *(*GC_amiga_allocwrapper_do)(size_t size,void *(*AllocFunction)(size_t size2)) =GC_amiga_allocwrapper_firsttime; /****************************************************************** Amiga-specific routines to obtain memory, and force GC to give back fast-mem whenever possible. These hacks makes gc-programs go many times faster when the Amiga is low on memory, and are therefore strictly necessary. -Kjetil S. Matheussen, 2000. ******************************************************************/ /* List-header for all allocated memory. */ struct GC_Amiga_AllocedMemoryHeader{ ULONG size; struct GC_Amiga_AllocedMemoryHeader *next; }; struct GC_Amiga_AllocedMemoryHeader *GC_AMIGAMEM=(struct GC_Amiga_AllocedMemoryHeader *)(int)~(NULL); /* Type of memory. Once in the execution of a program, this might change to MEMF_ANY|MEMF_CLEAR */ ULONG GC_AMIGA_MEMF = MEMF_FAST | MEMF_CLEAR; /* Prevents GC_amiga_get_mem from allocating memory if this one is TRUE. */ #ifndef GC_AMIGA_ONLYFAST BOOL GC_amiga_dontalloc=FALSE; #endif #ifdef GC_AMIGA_PRINTSTATS int succ=0,succ2=0; int nsucc=0,nsucc2=0; int nullretries=0; int numcollects=0; int chipa=0; int allochip=0; int allocfast=0; int cur0=0; int cur1=0; int cur10=0; int cur50=0; int cur150=0; int cur151=0; int ncur0=0; int ncur1=0; int ncur10=0; int ncur50=0; int ncur150=0; int ncur151=0; #endif /* Free everything at program-end. */ void GC_amiga_free_all_mem(void){ struct GC_Amiga_AllocedMemoryHeader *gc_am=(struct GC_Amiga_AllocedMemoryHeader *)(~(int)(GC_AMIGAMEM)); struct GC_Amiga_AllocedMemoryHeader *temp; #ifdef GC_AMIGA_PRINTSTATS printf("\n\n" "%d bytes of chip-mem, and %d bytes of fast-mem where allocated from the OS.\n", allochip,allocfast ); printf( "%d bytes of chip-mem were returned from the GC_AMIGA_FASTALLOC supported allocating functions.\n", chipa ); printf("\n"); printf("GC_gcollect was called %d times to avoid returning NULL or start allocating with the MEMF_ANY flag.\n",numcollects); printf("%d of them was a success. (the others had to use allocation from the OS.)\n",nullretries); printf("\n"); printf("Succeded forcing %d gc-allocations (%d bytes) of chip-mem to be fast-mem.\n",succ,succ2); printf("Failed forcing %d gc-allocations (%d bytes) of chip-mem to be fast-mem.\n",nsucc,nsucc2); printf("\n"); printf( "Number of retries before succeding a chip->fast force:\n" "0: %d, 1: %d, 2-9: %d, 10-49: %d, 50-149: %d, >150: %d\n", cur0,cur1,cur10,cur50,cur150,cur151 ); printf( "Number of retries before giving up a chip->fast force:\n" "0: %d, 1: %d, 2-9: %d, 10-49: %d, 50-149: %d, >150: %d\n", ncur0,ncur1,ncur10,ncur50,ncur150,ncur151 ); #endif while(gc_am!=NULL){ temp=gc_am->next; FreeMem(gc_am,gc_am->size); gc_am=(struct GC_Amiga_AllocedMemoryHeader *)(~(int)(temp)); } } #ifndef GC_AMIGA_ONLYFAST /* All memory with address lower than this one is chip-mem. */ char *chipmax; /* * Always set to the last size of memory tried to be allocated. * Needed to ensure allocation when the size is bigger than 100000. * */ size_t latestsize; #endif /* * The actual function that is called with the GET_MEM macro. * */ void *GC_amiga_get_mem(size_t size){ struct GC_Amiga_AllocedMemoryHeader *gc_am; #ifndef GC_AMIGA_ONLYFAST if(GC_amiga_dontalloc==TRUE){ // printf("rejected, size: %d, latestsize: %d\n",size,latestsize); return NULL; } // We really don't want to use chip-mem, but if we must, then as little as possible. if(GC_AMIGA_MEMF==(MEMF_ANY|MEMF_CLEAR) && size>100000 && latestsize<50000) return NULL; #endif gc_am=AllocMem((ULONG)(size + sizeof(struct GC_Amiga_AllocedMemoryHeader)),GC_AMIGA_MEMF); if(gc_am==NULL) return NULL; gc_am->next=GC_AMIGAMEM; gc_am->size=size + sizeof(struct GC_Amiga_AllocedMemoryHeader); GC_AMIGAMEM=(struct GC_Amiga_AllocedMemoryHeader *)(~(int)(gc_am)); // printf("Allocated %d (%d) bytes at address: %x. Latest: %d\n",size,tot,gc_am,latestsize); #ifdef GC_AMIGA_PRINTSTATS if((char *)gc_amchipmax || ret==NULL){ if(ret==NULL){ nsucc++; nsucc2+=size; if(rec==0) ncur0++; if(rec==1) ncur1++; if(rec>1 && rec<10) ncur10++; if(rec>=10 && rec<50) ncur50++; if(rec>=50 && rec<150) ncur150++; if(rec>=150) ncur151++; }else{ succ++; succ2+=size; if(rec==0) cur0++; if(rec==1) cur1++; if(rec>1 && rec<10) cur10++; if(rec>=10 && rec<50) cur50++; if(rec>=50 && rec<150) cur150++; if(rec>=150) cur151++; } } #endif if (((char *)ret)<=chipmax && ret!=NULL && (rec<(size>500000?9:size/5000))){ ret=GC_amiga_rec_alloc(size,AllocFunction,rec+1); // GC_free(ret2); } return ret; } #endif /* The allocating-functions defined inside the Amiga-blocks in gc.h is called * via these functions. */ void *GC_amiga_allocwrapper_any(size_t size,void *(*AllocFunction)(size_t size2)){ void *ret,*ret2; GC_amiga_dontalloc=TRUE; // Pretty tough thing to do, but its indeed necessary. latestsize=size; ret=(*AllocFunction)(size); if(((char *)ret) <= chipmax){ if(ret==NULL){ //Give GC access to allocate memory. #ifdef GC_AMIGA_GC if(!GC_dont_gc){ GC_gcollect(); #ifdef GC_AMIGA_PRINTSTATS numcollects++; #endif ret=(*AllocFunction)(size); } #endif if(ret==NULL){ GC_amiga_dontalloc=FALSE; ret=(*AllocFunction)(size); if(ret==NULL){ WARN("Out of Memory! Returning NIL!\n", 0); } } #ifdef GC_AMIGA_PRINTSTATS else{ nullretries++; } if(ret!=NULL && (char *)ret<=chipmax) chipa+=size; #endif } #ifdef GC_AMIGA_RETRY else{ /* We got chip-mem. Better try again and again and again etc., we might get fast-mem sooner or later... */ /* Using gctest to check the effectiveness of doing this, does seldom give a very good result. */ /* However, real programs doesn't normally rapidly allocate and deallocate. */ // printf("trying to force... %d bytes... ",size); if( AllocFunction!=GC_malloc_uncollectable #ifdef ATOMIC_UNCOLLECTABLE && AllocFunction!=GC_malloc_atomic_uncollectable #endif ){ ret2=GC_amiga_rec_alloc(size,AllocFunction,0); }else{ ret2=(*AllocFunction)(size); #ifdef GC_AMIGA_PRINTSTATS if((char *)ret2chipmax){ // printf("Succeeded.\n"); GC_free(ret); ret=ret2; }else{ GC_free(ret2); // printf("But did not succeed.\n"); } } #endif } GC_amiga_dontalloc=FALSE; return ret; } void (*GC_amiga_toany)(void)=NULL; void GC_amiga_set_toany(void (*func)(void)){ GC_amiga_toany=func; } #endif // !GC_AMIGA_ONLYFAST void *GC_amiga_allocwrapper_fast(size_t size,void *(*AllocFunction)(size_t size2)){ void *ret; ret=(*AllocFunction)(size); if(ret==NULL){ // Enable chip-mem allocation. // printf("ret==NULL\n"); #ifdef GC_AMIGA_GC if(!GC_dont_gc){ GC_gcollect(); #ifdef GC_AMIGA_PRINTSTATS numcollects++; #endif ret=(*AllocFunction)(size); } #endif if(ret==NULL){ #ifndef GC_AMIGA_ONLYFAST GC_AMIGA_MEMF=MEMF_ANY | MEMF_CLEAR; if(GC_amiga_toany!=NULL) (*GC_amiga_toany)(); GC_amiga_allocwrapper_do=GC_amiga_allocwrapper_any; return GC_amiga_allocwrapper_any(size,AllocFunction); #endif } #ifdef GC_AMIGA_PRINTSTATS else{ nullretries++; } #endif } return ret; } void *GC_amiga_allocwrapper_firsttime(size_t size,void *(*AllocFunction)(size_t size2)){ atexit(&GC_amiga_free_all_mem); chipmax=(char *)SysBase->MaxLocMem; // For people still having SysBase in chip-mem, this might speed up a bit. GC_amiga_allocwrapper_do=GC_amiga_allocwrapper_fast; return GC_amiga_allocwrapper_fast(size,AllocFunction); } #endif //GC_AMIGA_FASTALLOC /* * The wrapped realloc function. * */ void *GC_amiga_realloc(void *old_object,size_t new_size_in_bytes){ #ifndef GC_AMIGA_FASTALLOC return GC_realloc(old_object,new_size_in_bytes); #else void *ret; latestsize=new_size_in_bytes; ret=GC_realloc(old_object,new_size_in_bytes); if(ret==NULL && GC_AMIGA_MEMF==(MEMF_FAST | MEMF_CLEAR)){ /* Out of fast-mem. */ #ifdef GC_AMIGA_GC if(!GC_dont_gc){ GC_gcollect(); #ifdef GC_AMIGA_PRINTSTATS numcollects++; #endif ret=GC_realloc(old_object,new_size_in_bytes); } #endif if(ret==NULL){ #ifndef GC_AMIGA_ONLYFAST GC_AMIGA_MEMF=MEMF_ANY | MEMF_CLEAR; if(GC_amiga_toany!=NULL) (*GC_amiga_toany)(); GC_amiga_allocwrapper_do=GC_amiga_allocwrapper_any; ret=GC_realloc(old_object,new_size_in_bytes); #endif } #ifdef GC_AMIGA_PRINTSTATS else{ nullretries++; } #endif } if(ret==NULL){ WARN("Out of Memory! Returning NIL!\n", 0); } #ifdef GC_AMIGA_PRINTSTATS if(((char *)ret) 11/22/94 pcb StripAddress the temporary memory handle for 24-bit mode. 11/30/94 pcb Tracking all memory usage so we can deallocate it all at once. 02/10/96 pcb Added routine to perform a final collection when unloading shared library. by Patrick C. Beard. */ /* Boehm, February 15, 1996 2:55 pm PST */ #include #include #include #include #include #include #define GC_BUILD #include "gc.h" #include "gc_priv.h" // use 'CODE' resource 0 to get exact location of the beginning of global space. typedef struct { unsigned long aboveA5; unsigned long belowA5; unsigned long JTSize; unsigned long JTOffset; } *CodeZeroPtr, **CodeZeroHandle; void* GC_MacGetDataStart() { CodeZeroHandle code0 = (CodeZeroHandle)GetResource('CODE', 0); if (code0) { long belowA5Size = (**code0).belowA5; ReleaseResource((Handle)code0); return (LMGetCurrentA5() - belowA5Size); } fprintf(stderr, "Couldn't load the jump table."); exit(-1); return 0; } /* track the use of temporary memory so it can be freed all at once. */ typedef struct TemporaryMemoryBlock TemporaryMemoryBlock, **TemporaryMemoryHandle; struct TemporaryMemoryBlock { TemporaryMemoryHandle nextBlock; char data[]; }; static TemporaryMemoryHandle theTemporaryMemory = NULL; static Boolean firstTime = true; void GC_MacFreeTemporaryMemory(void); Ptr GC_MacTemporaryNewPtr(size_t size, Boolean clearMemory) { static Boolean firstTime = true; OSErr result; TemporaryMemoryHandle tempMemBlock; Ptr tempPtr = nil; tempMemBlock = (TemporaryMemoryHandle)TempNewHandle(size + sizeof(TemporaryMemoryBlock), &result); if (tempMemBlock && result == noErr) { HLockHi((Handle)tempMemBlock); tempPtr = (**tempMemBlock).data; if (clearMemory) memset(tempPtr, 0, size); tempPtr = StripAddress(tempPtr); // keep track of the allocated blocks. (**tempMemBlock).nextBlock = theTemporaryMemory; theTemporaryMemory = tempMemBlock; } # if !defined(SHARED_LIBRARY_BUILD) // install an exit routine to clean up the memory used at the end. if (firstTime) { atexit(&GC_MacFreeTemporaryMemory); firstTime = false; } # endif return tempPtr; } extern word GC_fo_entries; static void perform_final_collection() { unsigned i; word last_fo_entries = 0; /* adjust the stack bottom, because CFM calls us from another stack location. */ GC_stackbottom = (ptr_t)&i; /* try to collect and finalize everything in sight */ for (i = 0; i < 2 || GC_fo_entries < last_fo_entries; i++) { last_fo_entries = GC_fo_entries; GC_gcollect(); } } void GC_MacFreeTemporaryMemory() { # if defined(SHARED_LIBRARY_BUILD) /* if possible, collect all memory, and invoke all finalizers. */ perform_final_collection(); # endif if (theTemporaryMemory != NULL) { long totalMemoryUsed = 0; TemporaryMemoryHandle tempMemBlock = theTemporaryMemory; while (tempMemBlock != NULL) { TemporaryMemoryHandle nextBlock = (**tempMemBlock).nextBlock; totalMemoryUsed += GetHandleSize((Handle)tempMemBlock); DisposeHandle((Handle)tempMemBlock); tempMemBlock = nextBlock; } theTemporaryMemory = NULL; # if !defined(SHARED_LIBRARY_BUILD) if (GC_print_stats) { fprintf(stdout, "[total memory used: %ld bytes.]\n", totalMemoryUsed); fprintf(stdout, "[total collections: %ld.]\n", GC_gc_no); } # endif } } #if __option(far_data) void* GC_MacGetDataEnd() { CodeZeroHandle code0 = (CodeZeroHandle)GetResource('CODE', 0); if (code0) { long aboveA5Size = (**code0).aboveA5; ReleaseResource((Handle)code0); return (LMGetCurrentA5() + aboveA5Size); } fprintf(stderr, "Couldn't load the jump table."); exit(-1); return 0; } #endif /* __option(far_data) */ ecl-16.1.2/src/bdwgc/extra/Mac_files/000077500000000000000000000000001266352375300172425ustar00rootroot00000000000000ecl-16.1.2/src/bdwgc/extra/Mac_files/MacOS_config.h000066400000000000000000000013751266352375300217100ustar00rootroot00000000000000/* MacOS_config.h Configuration flags for Macintosh development systems. 11/16/95 pcb Updated compilation flags to reflect latest 4.6 Makefile. by Patrick C. Beard. */ /* Boehm, November 17, 1995 12:10 pm PST */ #ifdef __MWERKS__ // for CodeWarrior Pro with Metrowerks Standard Library (MSL). // #define MSL_USE_PRECOMPILED_HEADERS 0 #include #endif /* __MWERKS__ */ // these are defined again in gc_priv.h. #undef TRUE #undef FALSE #define ALL_INTERIOR_POINTERS // follows interior pointers. //#define DONT_ADD_BYTE_AT_END // no padding. //#define SMALL_CONFIG // whether to use a smaller heap. #define USE_TEMPORARY_MEMORY // use Macintosh temporary memory. ecl-16.1.2/src/bdwgc/extra/Mac_files/dataend.c000066400000000000000000000002001266352375300207760ustar00rootroot00000000000000/* dataend.c A hack to get the extent of global data for the Macintosh. by Patrick C. Beard. */ long __dataend; ecl-16.1.2/src/bdwgc/extra/Mac_files/datastart.c000066400000000000000000000002041266352375300213710ustar00rootroot00000000000000/* datastart.c A hack to get the extent of global data for the Macintosh. by Patrick C. Beard. */ long __datastart; ecl-16.1.2/src/bdwgc/extra/gc.c000066400000000000000000000056451266352375300161270ustar00rootroot00000000000000/* * Copyright (c) 1994 by Xerox Corporation. All rights reserved. * Copyright (c) 1996 by Silicon Graphics. All rights reserved. * Copyright (c) 1998 by Fergus Henderson. All rights reserved. * Copyright (c) 2000-2009 by Hewlett-Packard Development Company. * All rights reserved. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. */ /* This file could be used for the following purposes: */ /* - get the complete GC as a single link object file (module); */ /* - enable more compiler optimizations. */ /* Tip: to get the highest level of compiler optimizations, the typical */ /* compiler options (GCC) to use are: */ /* -O3 -fno-strict-aliasing -march=native -Wall -fprofile-generate/use */ /* Warning: GCC for Linux (for C++ clients only): Use -fexceptions both */ /* for GC and the client otherwise GC_thread_exit_proc() is not */ /* guaranteed to be invoked (see the comments in pthread_start.c). */ #define GC_INNER STATIC #define GC_EXTERN GC_INNER /* STATIC is defined in gcconfig.h. */ /* Small files go first... */ #include "../backgraph.c" #include "../blacklst.c" #include "../checksums.c" #include "../gcj_mlc.c" #include "../headers.c" #include "../malloc.c" #include "../new_hblk.c" #include "../obj_map.c" #include "../ptr_chck.c" #include "../stubborn.c" #include "gc_inline.h" #include "../allchblk.c" #include "../alloc.c" #include "../dbg_mlc.c" #include "../finalize.c" #include "../fnlz_mlc.c" #include "../mallocx.c" #include "../mark.c" #include "../mark_rts.c" #include "../reclaim.c" #include "../typd_mlc.c" #include "../misc.c" #include "../os_dep.c" #include "../thread_local_alloc.c" /* Most platform-specific files go here... */ #include "../darwin_stop_world.c" #include "../dyn_load.c" #include "../gc_dlopen.c" #include "../mach_dep.c" #include "../pcr_interface.c" #include "../pthread_stop_world.c" #include "../pthread_support.c" #include "../specific.c" #include "../win32_threads.c" #ifndef GC_PTHREAD_START_STANDALONE # include "../pthread_start.c" #endif /* Restore pthread calls redirection (if altered in */ /* pthread_stop_world.c, pthread_support.c or win32_threads.c). */ /* This is only useful if directly included from application */ /* (instead of linking gc). */ #ifndef GC_NO_THREAD_REDIRECTS # define GC_PTHREAD_REDIRECTS_ONLY # include "gc_pthread_redirects.h" #endif /* real_malloc.c, extra/MacOS.c, extra/msvc_dbg.c are not included. */ ecl-16.1.2/src/bdwgc/extra/msvc_dbg.c000066400000000000000000000272601266352375300173170ustar00rootroot00000000000000/* Copyright (c) 2004 Andrei Polushin Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ #if !defined(_M_AMD64) && defined(_MSC_VER) /* X86_64 is currently missing some meachine-dependent code below. */ #define GC_BUILD #include "private/msvc_dbg.h" #include "gc.h" #define WIN32_LEAN_AND_MEAN #include #pragma pack(push, 8) #include #pragma pack(pop) #pragma comment(lib, "dbghelp.lib") #pragma optimize("gy", off) typedef GC_word word; #define GC_ULONG_PTR word #ifdef _WIN64 typedef GC_ULONG_PTR ULONG_ADDR; #else typedef ULONG ULONG_ADDR; #endif static HANDLE GetSymHandle() { static HANDLE symHandle = NULL; if (!symHandle) { BOOL bRet = SymInitialize(symHandle = GetCurrentProcess(), NULL, FALSE); if (bRet) { DWORD dwOptions = SymGetOptions(); dwOptions &= ~SYMOPT_UNDNAME; dwOptions |= SYMOPT_LOAD_LINES; SymSetOptions(dwOptions); } } return symHandle; } static void* CALLBACK FunctionTableAccess(HANDLE hProcess, ULONG_ADDR dwAddrBase) { return SymFunctionTableAccess(hProcess, dwAddrBase); } static ULONG_ADDR CALLBACK GetModuleBase(HANDLE hProcess, ULONG_ADDR dwAddress) { MEMORY_BASIC_INFORMATION memoryInfo; ULONG_ADDR dwAddrBase = SymGetModuleBase(hProcess, dwAddress); if (dwAddrBase) { return dwAddrBase; } if (VirtualQueryEx(hProcess, (void*)(GC_ULONG_PTR)dwAddress, &memoryInfo, sizeof(memoryInfo))) { char filePath[_MAX_PATH]; char curDir[_MAX_PATH]; char exePath[_MAX_PATH]; DWORD size = GetModuleFileNameA((HINSTANCE)memoryInfo.AllocationBase, filePath, sizeof(filePath)); /* Save and restore current directory around SymLoadModule, see KB */ /* article Q189780. */ GetCurrentDirectoryA(sizeof(curDir), curDir); GetModuleFileNameA(NULL, exePath, sizeof(exePath)); #if defined(_MSC_VER) && _MSC_VER == 1200 /* use strcat for VC6 */ strcat(exePath, "\\.."); #else strcat_s(exePath, sizeof(exePath), "\\.."); #endif /* _MSC_VER >= 1200 */ SetCurrentDirectoryA(exePath); #ifdef _DEBUG GetCurrentDirectoryA(sizeof(exePath), exePath); #endif SymLoadModule(hProcess, NULL, size ? filePath : NULL, NULL, (ULONG_ADDR)(GC_ULONG_PTR)memoryInfo.AllocationBase, 0); SetCurrentDirectoryA(curDir); } return (ULONG_ADDR)(GC_ULONG_PTR)memoryInfo.AllocationBase; } static ULONG_ADDR CheckAddress(void* address) { ULONG_ADDR dwAddress = (ULONG_ADDR)(GC_ULONG_PTR)address; GetModuleBase(GetSymHandle(), dwAddress); return dwAddress; } size_t GetStackFrames(size_t skip, void* frames[], size_t maxFrames) { HANDLE hProcess = GetSymHandle(); HANDLE hThread = GetCurrentThread(); CONTEXT context; context.ContextFlags = CONTEXT_FULL; if (!GetThreadContext(hThread, &context)) { return 0; } /* GetThreadContext might return invalid context for the current thread. */ #if defined(_M_IX86) __asm mov context.Ebp, ebp #endif return GetStackFramesFromContext(hProcess, hThread, &context, skip + 1, frames, maxFrames); } size_t GetStackFramesFromContext(HANDLE hProcess, HANDLE hThread, CONTEXT* context, size_t skip, void* frames[], size_t maxFrames) { size_t frameIndex; DWORD machineType; STACKFRAME stackFrame = { 0 }; stackFrame.AddrPC.Mode = AddrModeFlat; #if defined(_M_IX86) machineType = IMAGE_FILE_MACHINE_I386; stackFrame.AddrPC.Offset = context->Eip; stackFrame.AddrStack.Mode = AddrModeFlat; stackFrame.AddrStack.Offset = context->Esp; stackFrame.AddrFrame.Mode = AddrModeFlat; stackFrame.AddrFrame.Offset = context->Ebp; #elif defined(_M_MRX000) machineType = IMAGE_FILE_MACHINE_R4000; stackFrame.AddrPC.Offset = context->Fir; #elif defined(_M_ALPHA) machineType = IMAGE_FILE_MACHINE_ALPHA; stackFrame.AddrPC.Offset = (unsigned long)context->Fir; #elif defined(_M_PPC) machineType = IMAGE_FILE_MACHINE_POWERPC; stackFrame.AddrPC.Offset = context->Iar; #elif defined(_M_IA64) machineType = IMAGE_FILE_MACHINE_IA64; stackFrame.AddrPC.Offset = context->StIIP; #elif defined(_M_ALPHA64) machineType = IMAGE_FILE_MACHINE_ALPHA64; stackFrame.AddrPC.Offset = context->Fir; #else #error Unknown CPU #endif for (frameIndex = 0; frameIndex < maxFrames; ) { BOOL bRet = StackWalk(machineType, hProcess, hThread, &stackFrame, &context, NULL, FunctionTableAccess, GetModuleBase, NULL); if (!bRet) { break; } if (skip) { skip--; } else { frames[frameIndex++] = (void*)(GC_ULONG_PTR)stackFrame.AddrPC.Offset; } } return frameIndex; } size_t GetModuleNameFromAddress(void* address, char* moduleName, size_t size) { if (size) *moduleName = 0; { const char* sourceName; IMAGEHLP_MODULE moduleInfo = { sizeof (moduleInfo) }; if (!SymGetModuleInfo(GetSymHandle(), CheckAddress(address), &moduleInfo)) { return 0; } sourceName = strrchr(moduleInfo.ImageName, '\\'); if (sourceName) { sourceName++; } else { sourceName = moduleInfo.ImageName; } if (size) { strncpy(moduleName, sourceName, size)[size - 1] = 0; } return strlen(sourceName); } } size_t GetModuleNameFromStack(size_t skip, char* moduleName, size_t size) { void* address = NULL; GetStackFrames(skip + 1, &address, 1); if (address) { return GetModuleNameFromAddress(address, moduleName, size); } return 0; } size_t GetSymbolNameFromAddress(void* address, char* symbolName, size_t size, size_t* offsetBytes) { if (size) *symbolName = 0; if (offsetBytes) *offsetBytes = 0; __try { ULONG_ADDR dwOffset = 0; union { IMAGEHLP_SYMBOL sym; char symNameBuffer[sizeof(IMAGEHLP_SYMBOL) + MAX_SYM_NAME]; } u; u.sym.SizeOfStruct = sizeof(u.sym); u.sym.MaxNameLength = sizeof(u.symNameBuffer) - sizeof(u.sym); if (!SymGetSymFromAddr(GetSymHandle(), CheckAddress(address), &dwOffset, &u.sym)) { return 0; } else { const char* sourceName = u.sym.Name; char undName[1024]; if (UnDecorateSymbolName(u.sym.Name, undName, sizeof(undName), UNDNAME_NO_MS_KEYWORDS | UNDNAME_NO_ACCESS_SPECIFIERS)) { sourceName = undName; } else if (SymUnDName(&u.sym, undName, sizeof(undName))) { sourceName = undName; } if (offsetBytes) { *offsetBytes = dwOffset; } if (size) { strncpy(symbolName, sourceName, size)[size - 1] = 0; } return strlen(sourceName); } } __except (EXCEPTION_EXECUTE_HANDLER) { SetLastError(GetExceptionCode()); } return 0; } size_t GetSymbolNameFromStack(size_t skip, char* symbolName, size_t size, size_t* offsetBytes) { void* address = NULL; GetStackFrames(skip + 1, &address, 1); if (address) { return GetSymbolNameFromAddress(address, symbolName, size, offsetBytes); } return 0; } size_t GetFileLineFromAddress(void* address, char* fileName, size_t size, size_t* lineNumber, size_t* offsetBytes) { if (size) *fileName = 0; if (lineNumber) *lineNumber = 0; if (offsetBytes) *offsetBytes = 0; { char* sourceName; IMAGEHLP_LINE line = { sizeof (line) }; GC_ULONG_PTR dwOffset = 0; if (!SymGetLineFromAddr(GetSymHandle(), CheckAddress(address), &dwOffset, &line)) { return 0; } if (lineNumber) { *lineNumber = line.LineNumber; } if (offsetBytes) { *offsetBytes = dwOffset; } sourceName = line.FileName; /* TODO: resolve relative filenames, found in 'source directories' */ /* registered with MSVC IDE. */ if (size) { strncpy(fileName, sourceName, size)[size - 1] = 0; } return strlen(sourceName); } } size_t GetFileLineFromStack(size_t skip, char* fileName, size_t size, size_t* lineNumber, size_t* offsetBytes) { void* address = NULL; GetStackFrames(skip + 1, &address, 1); if (address) { return GetFileLineFromAddress(address, fileName, size, lineNumber, offsetBytes); } return 0; } size_t GetDescriptionFromAddress(void* address, const char* format, char* buffer, size_t size) { char*const begin = buffer; char*const end = buffer + size; size_t line_number = 0; char str[128]; if (size) { *buffer = 0; } buffer += GetFileLineFromAddress(address, buffer, size, &line_number, NULL); size = (GC_ULONG_PTR)end < (GC_ULONG_PTR)buffer ? 0 : end - buffer; if (line_number) { wsprintf(str, "(%d) : ", line_number); if (size) { strncpy(buffer, str, size)[size - 1] = 0; } buffer += strlen(str); size = (GC_ULONG_PTR)end < (GC_ULONG_PTR)buffer ? 0 : end - buffer; } if (size) { strncpy(buffer, "at ", size)[size - 1] = 0; } buffer += strlen("at "); size = (GC_ULONG_PTR)end < (GC_ULONG_PTR)buffer ? 0 : end - buffer; buffer += GetSymbolNameFromAddress(address, buffer, size, NULL); size = (GC_ULONG_PTR)end < (GC_ULONG_PTR)buffer ? 0 : end - buffer; if (size) { strncpy(buffer, " in ", size)[size - 1] = 0; } buffer += strlen(" in "); size = (GC_ULONG_PTR)end < (GC_ULONG_PTR)buffer ? 0 : end - buffer; buffer += GetModuleNameFromAddress(address, buffer, size); size = (GC_ULONG_PTR)end < (GC_ULONG_PTR)buffer ? 0 : end - buffer; return buffer - begin; } size_t GetDescriptionFromStack(void* const frames[], size_t count, const char* format, char* description[], size_t size) { char*const begin = (char*)description; char*const end = begin + size; char* buffer = begin + (count + 1) * sizeof(char*); size_t i; for (i = 0; i < count; ++i) { if (description) description[i] = buffer; size = (GC_ULONG_PTR)end < (GC_ULONG_PTR)buffer ? 0 : end - buffer; buffer += 1 + GetDescriptionFromAddress(frames[i], NULL, buffer, size); } if (description) description[count] = NULL; return buffer - begin; } /* Compatibility with */ int backtrace(void* addresses[], int count) { return GetStackFrames(1, addresses, count); } char** backtrace_symbols(void*const* addresses, int count) { size_t size = GetDescriptionFromStack(addresses, count, NULL, NULL, 0); char** symbols = (char**)malloc(size); GetDescriptionFromStack(addresses, count, NULL, symbols, size); return symbols; } #endif /* !_M_AMD64 */ ecl-16.1.2/src/bdwgc/extra/symbian.cpp000066400000000000000000000017741266352375300175370ustar00rootroot00000000000000 #include #include #include #include #include #include #ifdef __cplusplus extern "C" { #endif int GC_get_main_symbian_stack_base() { TThreadStackInfo aInfo; TInt err = RThread().StackInfo(aInfo); if ( !err ) { return aInfo.iBase; } else { return 0; } } char* GC_get_private_path_and_zero_file() { // always on c: drive RFs fs; fs.Connect(); fs.CreatePrivatePath( EDriveC ); TFileName path; fs.PrivatePath( path ); fs.Close(); _LIT( KCDrive, "c:" ); path.Insert( 0, KCDrive ); //convert to char*, assume ascii TBuf8 path8; path8.Copy( path ); _LIT8( KZero8, "zero" ); path8.Append( KZero8 ); size_t size = path8.Length() + 1; char* copyChar = (char*) malloc( size ); memcpy( copyChar, path8.PtrZ(), size ); return copyChar; // ownership passed } #ifdef __cplusplus } #endif ecl-16.1.2/src/bdwgc/extra/symbian/000077500000000000000000000000001266352375300170225ustar00rootroot00000000000000ecl-16.1.2/src/bdwgc/extra/symbian/global_end.cpp000066400000000000000000000002751266352375300216200ustar00rootroot00000000000000// Symbian-specific file. // INCLUDE FILES #include "private/gcconfig.h" #ifdef __cplusplus extern "C" { #endif int winscw_data_end; #ifdef __cplusplus } #endif // End Of File ecl-16.1.2/src/bdwgc/extra/symbian/global_start.cpp000066400000000000000000000002771266352375300222110ustar00rootroot00000000000000// Symbian-specific file. // INCLUDE FILES #include "private/gcconfig.h" #ifdef __cplusplus extern "C" { #endif int winscw_data_start; #ifdef __cplusplus } #endif // End Of File ecl-16.1.2/src/bdwgc/extra/symbian/init_global_static_roots.cpp000066400000000000000000000013311266352375300246040ustar00rootroot00000000000000// Symbian-specific file. // INCLUDE FILES #include #include "private/gcconfig.h" #include "gc.h" #ifdef __cplusplus extern "C" { #endif void GC_init_global_static_roots() { ptr_t dataStart = NULL; ptr_t dataEnd = NULL; # if defined (__WINS__) extern int winscw_data_start, winscw_data_end; dataStart = ((ptr_t)&winscw_data_start); dataEnd = ((ptr_t)&winscw_data_end); # else extern int Image$$RW$$Limit[], Image$$RW$$Base[]; dataStart = ((ptr_t)Image$$RW$$Base); dataEnd = ((ptr_t)Image$$RW$$Limit); # endif GC_add_roots(dataStart, dataEnd); } #ifdef __cplusplus } #endif ecl-16.1.2/src/bdwgc/finalize.c000066400000000000000000001162661266352375300162160ustar00rootroot00000000000000/* * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers * Copyright (c) 1991-1996 by Xerox Corporation. All rights reserved. * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. * Copyright (C) 2007 Free Software Foundation, Inc * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. */ #include "private/gc_pmark.h" #ifndef GC_NO_FINALIZATION /* Type of mark procedure used for marking from finalizable object. */ /* This procedure normally does not mark the object, only its */ /* descendants. */ typedef void (* finalization_mark_proc)(ptr_t /* finalizable_obj_ptr */); #define HASH3(addr,size,log_size) \ ((((word)(addr) >> 3) ^ ((word)(addr) >> (3 + (log_size)))) \ & ((size) - 1)) #define HASH2(addr,log_size) HASH3(addr, 1 << (log_size), log_size) struct hash_chain_entry { word hidden_key; struct hash_chain_entry * next; }; struct disappearing_link { struct hash_chain_entry prolog; # define dl_hidden_link prolog.hidden_key /* Field to be cleared. */ # define dl_next(x) (struct disappearing_link *)((x) -> prolog.next) # define dl_set_next(x, y) \ (void)((x)->prolog.next = (struct hash_chain_entry *)(y)) word dl_hidden_obj; /* Pointer to object base */ }; struct dl_hashtbl_s { struct disappearing_link **head; signed_word log_size; word entries; }; STATIC struct dl_hashtbl_s GC_dl_hashtbl = { /* head */ NULL, /* log_size */ -1, /* entries */ 0 }; #ifndef GC_LONG_REFS_NOT_NEEDED STATIC struct dl_hashtbl_s GC_ll_hashtbl = { NULL, -1, 0 }; #endif STATIC struct finalizable_object { struct hash_chain_entry prolog; # define fo_hidden_base prolog.hidden_key /* Pointer to object base. */ /* No longer hidden once object */ /* is on finalize_now queue. */ # define fo_next(x) (struct finalizable_object *)((x) -> prolog.next) # define fo_set_next(x,y) ((x)->prolog.next = (struct hash_chain_entry *)(y)) GC_finalization_proc fo_fn; /* Finalizer. */ ptr_t fo_client_data; word fo_object_size; /* In bytes. */ finalization_mark_proc fo_mark_proc; /* Mark-through procedure */ } **GC_fo_head = 0; STATIC struct finalizable_object * GC_finalize_now = 0; /* List of objects that should be finalized now. */ static signed_word log_fo_table_size = -1; GC_INNER void GC_push_finalizer_structures(void) { GC_ASSERT((word)&GC_dl_hashtbl.head % sizeof(word) == 0); GC_ASSERT((word)&GC_fo_head % sizeof(word) == 0); GC_ASSERT((word)&GC_finalize_now % sizeof(word) == 0); # ifndef GC_LONG_REFS_NOT_NEEDED GC_ASSERT((word)&GC_ll_hashtbl.head % sizeof(word) == 0); GC_push_all((ptr_t)(&GC_ll_hashtbl.head), (ptr_t)(&GC_ll_hashtbl.head) + sizeof(word)); # endif GC_push_all((ptr_t)(&GC_dl_hashtbl.head), (ptr_t)(&GC_dl_hashtbl.head) + sizeof(word)); GC_push_all((ptr_t)(&GC_fo_head), (ptr_t)(&GC_fo_head) + sizeof(word)); GC_push_all((ptr_t)(&GC_finalize_now), (ptr_t)(&GC_finalize_now) + sizeof(word)); } /* Double the size of a hash table. *size_ptr is the log of its current */ /* size. May be a no-op. */ /* *table is a pointer to an array of hash headers. If we succeed, we */ /* update both *table and *log_size_ptr. Lock is held. */ STATIC void GC_grow_table(struct hash_chain_entry ***table, signed_word *log_size_ptr) { register word i; register struct hash_chain_entry *p; signed_word log_old_size = *log_size_ptr; signed_word log_new_size = log_old_size + 1; word old_size = ((log_old_size == -1)? 0: (1 << log_old_size)); word new_size = (word)1 << log_new_size; /* FIXME: Power of 2 size often gets rounded up to one more page. */ struct hash_chain_entry **new_table = (struct hash_chain_entry **) GC_INTERNAL_MALLOC_IGNORE_OFF_PAGE( (size_t)new_size * sizeof(struct hash_chain_entry *), NORMAL); if (new_table == 0) { if (*table == 0) { ABORT("Insufficient space for initial table allocation"); } else { return; } } for (i = 0; i < old_size; i++) { p = (*table)[i]; while (p != 0) { ptr_t real_key = GC_REVEAL_POINTER(p -> hidden_key); struct hash_chain_entry *next = p -> next; size_t new_hash = HASH3(real_key, new_size, log_new_size); p -> next = new_table[new_hash]; new_table[new_hash] = p; p = next; } } *log_size_ptr = log_new_size; *table = new_table; } GC_API int GC_CALL GC_register_disappearing_link(void * * link) { ptr_t base; base = (ptr_t)GC_base(link); if (base == 0) ABORT("Bad arg to GC_register_disappearing_link"); return(GC_general_register_disappearing_link(link, base)); } STATIC int GC_register_disappearing_link_inner( struct dl_hashtbl_s *dl_hashtbl, void **link, const void *obj) { struct disappearing_link *curr_dl; size_t index; struct disappearing_link * new_dl; DCL_LOCK_STATE; LOCK(); GC_ASSERT(obj != NULL && GC_base_C(obj) == obj); if (dl_hashtbl -> log_size == -1 || dl_hashtbl -> entries > ((word)1 << dl_hashtbl -> log_size)) { GC_grow_table((struct hash_chain_entry ***)&dl_hashtbl -> head, &dl_hashtbl -> log_size); GC_COND_LOG_PRINTF("Grew dl table to %u entries\n", 1 << (unsigned)dl_hashtbl -> log_size); } index = HASH2(link, dl_hashtbl -> log_size); for (curr_dl = dl_hashtbl -> head[index]; curr_dl != 0; curr_dl = dl_next(curr_dl)) { if (curr_dl -> dl_hidden_link == GC_HIDE_POINTER(link)) { curr_dl -> dl_hidden_obj = GC_HIDE_POINTER(obj); UNLOCK(); return GC_DUPLICATE; } } new_dl = (struct disappearing_link *) GC_INTERNAL_MALLOC(sizeof(struct disappearing_link),NORMAL); if (0 == new_dl) { GC_oom_func oom_fn = GC_oom_fn; UNLOCK(); new_dl = (struct disappearing_link *) (*oom_fn)(sizeof(struct disappearing_link)); if (0 == new_dl) { return GC_NO_MEMORY; } /* It's not likely we'll make it here, but ... */ LOCK(); /* Recalculate index since the table may grow. */ index = HASH2(link, dl_hashtbl -> log_size); /* Check again that our disappearing link not in the table. */ for (curr_dl = dl_hashtbl -> head[index]; curr_dl != 0; curr_dl = dl_next(curr_dl)) { if (curr_dl -> dl_hidden_link == GC_HIDE_POINTER(link)) { curr_dl -> dl_hidden_obj = GC_HIDE_POINTER(obj); UNLOCK(); # ifndef DBG_HDRS_ALL /* Free unused new_dl returned by GC_oom_fn() */ GC_free((void *)new_dl); # endif return GC_DUPLICATE; } } } new_dl -> dl_hidden_obj = GC_HIDE_POINTER(obj); new_dl -> dl_hidden_link = GC_HIDE_POINTER(link); dl_set_next(new_dl, dl_hashtbl -> head[index]); dl_hashtbl -> head[index] = new_dl; dl_hashtbl -> entries++; UNLOCK(); return GC_SUCCESS; } GC_API int GC_CALL GC_general_register_disappearing_link(void * * link, const void * obj) { if (((word)link & (ALIGNMENT-1)) != 0 || NULL == link) ABORT("Bad arg to GC_general_register_disappearing_link"); return GC_register_disappearing_link_inner(&GC_dl_hashtbl, link, obj); } #ifdef DBG_HDRS_ALL # define FREE_DL_ENTRY(curr_dl) dl_set_next(curr_dl, NULL) #else # define FREE_DL_ENTRY(curr_dl) GC_free(curr_dl) #endif /* Unregisters given link and returns the link entry to free. */ /* Assume the lock is held. */ GC_INLINE struct disappearing_link *GC_unregister_disappearing_link_inner( struct dl_hashtbl_s *dl_hashtbl, void **link) { struct disappearing_link *curr_dl; struct disappearing_link *prev_dl = NULL; size_t index = HASH2(link, dl_hashtbl->log_size); for (curr_dl = dl_hashtbl -> head[index]; curr_dl; curr_dl = dl_next(curr_dl)) { if (curr_dl -> dl_hidden_link == GC_HIDE_POINTER(link)) { /* Remove found entry from the table. */ if (NULL == prev_dl) { dl_hashtbl -> head[index] = dl_next(curr_dl); } else { dl_set_next(prev_dl, dl_next(curr_dl)); } dl_hashtbl -> entries--; break; } prev_dl = curr_dl; } return curr_dl; } GC_API int GC_CALL GC_unregister_disappearing_link(void * * link) { struct disappearing_link *curr_dl; DCL_LOCK_STATE; if (((word)link & (ALIGNMENT-1)) != 0) return(0); /* Nothing to do. */ LOCK(); curr_dl = GC_unregister_disappearing_link_inner(&GC_dl_hashtbl, link); UNLOCK(); if (NULL == curr_dl) return 0; FREE_DL_ENTRY(curr_dl); return 1; } #ifndef GC_LONG_REFS_NOT_NEEDED GC_API int GC_CALL GC_register_long_link(void * * link, const void * obj) { if (((word)link & (ALIGNMENT-1)) != 0 || NULL == link) ABORT("Bad arg to GC_register_long_link"); return GC_register_disappearing_link_inner(&GC_ll_hashtbl, link, obj); } GC_API int GC_CALL GC_unregister_long_link(void * * link) { struct disappearing_link *curr_dl; DCL_LOCK_STATE; if (((word)link & (ALIGNMENT-1)) != 0) return(0); /* Nothing to do. */ LOCK(); curr_dl = GC_unregister_disappearing_link_inner(&GC_ll_hashtbl, link); UNLOCK(); if (NULL == curr_dl) return 0; FREE_DL_ENTRY(curr_dl); return 1; } #endif /* !GC_LONG_REFS_NOT_NEEDED */ #ifndef GC_MOVE_DISAPPEARING_LINK_NOT_NEEDED /* Moves a link. Assume the lock is held. */ STATIC int GC_move_disappearing_link_inner( struct dl_hashtbl_s *dl_hashtbl, void **link, void **new_link) { struct disappearing_link *curr_dl, *prev_dl, *new_dl; size_t curr_index, new_index; word curr_hidden_link; word new_hidden_link; /* Find current link. */ curr_index = HASH2(link, dl_hashtbl -> log_size); curr_hidden_link = GC_HIDE_POINTER(link); prev_dl = NULL; for (curr_dl = dl_hashtbl -> head[curr_index]; curr_dl; curr_dl = dl_next(curr_dl)) { if (curr_dl -> dl_hidden_link == curr_hidden_link) break; prev_dl = curr_dl; } if (NULL == curr_dl) { return GC_NOT_FOUND; } if (link == new_link) { return GC_SUCCESS; /* Nothing to do. */ } /* link found; now check new_link not present. */ new_index = HASH2(new_link, dl_hashtbl -> log_size); new_hidden_link = GC_HIDE_POINTER(new_link); for (new_dl = dl_hashtbl -> head[new_index]; new_dl; new_dl = dl_next(new_dl)) { if (new_dl -> dl_hidden_link == new_hidden_link) { /* Target already registered; bail. */ return GC_DUPLICATE; } } /* Remove from old, add to new, update link. */ if (NULL == prev_dl) { dl_hashtbl -> head[curr_index] = dl_next(curr_dl); } else { dl_set_next(prev_dl, dl_next(curr_dl)); } curr_dl -> dl_hidden_link = new_hidden_link; dl_set_next(curr_dl, dl_hashtbl -> head[new_index]); dl_hashtbl -> head[new_index] = curr_dl; return GC_SUCCESS; } GC_API int GC_CALL GC_move_disappearing_link(void **link, void **new_link) { int result; DCL_LOCK_STATE; if (((word)new_link & (ALIGNMENT-1)) != 0 || new_link == NULL) ABORT("Bad new_link arg to GC_move_disappearing_link"); if (((word)link & (ALIGNMENT-1)) != 0) return GC_NOT_FOUND; /* Nothing to do. */ LOCK(); result = GC_move_disappearing_link_inner(&GC_dl_hashtbl, link, new_link); UNLOCK(); return result; } # ifndef GC_LONG_REFS_NOT_NEEDED GC_API int GC_CALL GC_move_long_link(void **link, void **new_link) { int result; DCL_LOCK_STATE; if (((word)new_link & (ALIGNMENT-1)) != 0 || new_link == NULL) ABORT("Bad new_link arg to GC_move_disappearing_link"); if (((word)link & (ALIGNMENT-1)) != 0) return GC_NOT_FOUND; /* Nothing to do. */ LOCK(); result = GC_move_disappearing_link_inner(&GC_ll_hashtbl, link, new_link); UNLOCK(); return result; } # endif /* !GC_LONG_REFS_NOT_NEEDED */ #endif /* !GC_MOVE_DISAPPEARING_LINK_NOT_NEEDED */ /* Possible finalization_marker procedures. Note that mark stack */ /* overflow is handled by the caller, and is not a disaster. */ STATIC void GC_normal_finalize_mark_proc(ptr_t p) { hdr * hhdr = HDR(p); PUSH_OBJ(p, hhdr, GC_mark_stack_top, &(GC_mark_stack[GC_mark_stack_size])); } /* This only pays very partial attention to the mark descriptor. */ /* It does the right thing for normal and atomic objects, and treats */ /* most others as normal. */ STATIC void GC_ignore_self_finalize_mark_proc(ptr_t p) { hdr * hhdr = HDR(p); word descr = hhdr -> hb_descr; ptr_t q; word r; ptr_t scan_limit; ptr_t target_limit = p + hhdr -> hb_sz - 1; if ((descr & GC_DS_TAGS) == GC_DS_LENGTH) { scan_limit = p + descr - sizeof(word); } else { scan_limit = target_limit + 1 - sizeof(word); } for (q = p; (word)q <= (word)scan_limit; q += ALIGNMENT) { r = *(word *)q; if (r < (word)p || r > (word)target_limit) { GC_PUSH_ONE_HEAP(r, q, GC_mark_stack_top); } } } STATIC void GC_null_finalize_mark_proc(ptr_t p GC_ATTR_UNUSED) {} /* Possible finalization_marker procedures. Note that mark stack */ /* overflow is handled by the caller, and is not a disaster. */ /* GC_unreachable_finalize_mark_proc is an alias for normal marking, */ /* but it is explicitly tested for, and triggers different */ /* behavior. Objects registered in this way are not finalized */ /* if they are reachable by other finalizable objects, even if those */ /* other objects specify no ordering. */ STATIC void GC_unreachable_finalize_mark_proc(ptr_t p) { GC_normal_finalize_mark_proc(p); } /* Register a finalization function. See gc.h for details. */ /* The last parameter is a procedure that determines */ /* marking for finalization ordering. Any objects marked */ /* by that procedure will be guaranteed to not have been */ /* finalized when this finalizer is invoked. */ STATIC void GC_register_finalizer_inner(void * obj, GC_finalization_proc fn, void *cd, GC_finalization_proc *ofn, void **ocd, finalization_mark_proc mp) { ptr_t base; struct finalizable_object * curr_fo, * prev_fo; size_t index; struct finalizable_object *new_fo = 0; hdr *hhdr = NULL; /* initialized to prevent warning. */ GC_oom_func oom_fn; DCL_LOCK_STATE; LOCK(); if (log_fo_table_size == -1 || GC_fo_entries > ((word)1 << log_fo_table_size)) { GC_grow_table((struct hash_chain_entry ***)&GC_fo_head, &log_fo_table_size); GC_COND_LOG_PRINTF("Grew fo table to %u entries\n", 1 << (unsigned)log_fo_table_size); } /* in the THREADS case we hold allocation lock. */ base = (ptr_t)obj; for (;;) { index = HASH2(base, log_fo_table_size); prev_fo = 0; curr_fo = GC_fo_head[index]; while (curr_fo != 0) { GC_ASSERT(GC_size(curr_fo) >= sizeof(struct finalizable_object)); if (curr_fo -> fo_hidden_base == GC_HIDE_POINTER(base)) { /* Interruption by a signal in the middle of this */ /* should be safe. The client may see only *ocd */ /* updated, but we'll declare that to be his problem. */ if (ocd) *ocd = (void *) (curr_fo -> fo_client_data); if (ofn) *ofn = curr_fo -> fo_fn; /* Delete the structure for base. */ if (prev_fo == 0) { GC_fo_head[index] = fo_next(curr_fo); } else { fo_set_next(prev_fo, fo_next(curr_fo)); } if (fn == 0) { GC_fo_entries--; /* May not happen if we get a signal. But a high */ /* estimate will only make the table larger than */ /* necessary. */ # if !defined(THREADS) && !defined(DBG_HDRS_ALL) GC_free((void *)curr_fo); # endif } else { curr_fo -> fo_fn = fn; curr_fo -> fo_client_data = (ptr_t)cd; curr_fo -> fo_mark_proc = mp; /* Reinsert it. We deleted it first to maintain */ /* consistency in the event of a signal. */ if (prev_fo == 0) { GC_fo_head[index] = curr_fo; } else { fo_set_next(prev_fo, curr_fo); } } UNLOCK(); # ifndef DBG_HDRS_ALL if (EXPECT(new_fo != 0, FALSE)) { /* Free unused new_fo returned by GC_oom_fn() */ GC_free((void *)new_fo); } # endif return; } prev_fo = curr_fo; curr_fo = fo_next(curr_fo); } if (EXPECT(new_fo != 0, FALSE)) { /* new_fo is returned by GC_oom_fn(), so fn != 0 and hhdr != 0. */ break; } if (fn == 0) { if (ocd) *ocd = 0; if (ofn) *ofn = 0; UNLOCK(); return; } GET_HDR(base, hhdr); if (EXPECT(0 == hhdr, FALSE)) { /* We won't collect it, hence finalizer wouldn't be run. */ if (ocd) *ocd = 0; if (ofn) *ofn = 0; UNLOCK(); return; } new_fo = (struct finalizable_object *) GC_INTERNAL_MALLOC(sizeof(struct finalizable_object),NORMAL); if (EXPECT(new_fo != 0, TRUE)) break; oom_fn = GC_oom_fn; UNLOCK(); new_fo = (struct finalizable_object *) (*oom_fn)(sizeof(struct finalizable_object)); if (0 == new_fo) { /* No enough memory. *ocd and *ofn remains unchanged. */ return; } /* It's not likely we'll make it here, but ... */ LOCK(); /* Recalculate index since the table may grow and */ /* check again that our finalizer is not in the table. */ } GC_ASSERT(GC_size(new_fo) >= sizeof(struct finalizable_object)); if (ocd) *ocd = 0; if (ofn) *ofn = 0; new_fo -> fo_hidden_base = GC_HIDE_POINTER(base); new_fo -> fo_fn = fn; new_fo -> fo_client_data = (ptr_t)cd; new_fo -> fo_object_size = hhdr -> hb_sz; new_fo -> fo_mark_proc = mp; fo_set_next(new_fo, GC_fo_head[index]); GC_fo_entries++; GC_fo_head[index] = new_fo; UNLOCK(); } GC_API void GC_CALL GC_register_finalizer(void * obj, GC_finalization_proc fn, void * cd, GC_finalization_proc *ofn, void ** ocd) { GC_register_finalizer_inner(obj, fn, cd, ofn, ocd, GC_normal_finalize_mark_proc); } GC_API void GC_CALL GC_register_finalizer_ignore_self(void * obj, GC_finalization_proc fn, void * cd, GC_finalization_proc *ofn, void ** ocd) { GC_register_finalizer_inner(obj, fn, cd, ofn, ocd, GC_ignore_self_finalize_mark_proc); } GC_API void GC_CALL GC_register_finalizer_no_order(void * obj, GC_finalization_proc fn, void * cd, GC_finalization_proc *ofn, void ** ocd) { GC_register_finalizer_inner(obj, fn, cd, ofn, ocd, GC_null_finalize_mark_proc); } static GC_bool need_unreachable_finalization = FALSE; /* Avoid the work if this isn't used. */ GC_API void GC_CALL GC_register_finalizer_unreachable(void * obj, GC_finalization_proc fn, void * cd, GC_finalization_proc *ofn, void ** ocd) { need_unreachable_finalization = TRUE; GC_ASSERT(GC_java_finalization); GC_register_finalizer_inner(obj, fn, cd, ofn, ocd, GC_unreachable_finalize_mark_proc); } #ifndef NO_DEBUGGING STATIC void GC_dump_finalization_links( const struct dl_hashtbl_s *dl_hashtbl) { struct disappearing_link *curr_dl; ptr_t real_ptr, real_link; size_t dl_size = dl_hashtbl->log_size == -1 ? 0 : 1 << dl_hashtbl->log_size; size_t i; for (i = 0; i < dl_size; i++) { for (curr_dl = dl_hashtbl -> head[i]; curr_dl != 0; curr_dl = dl_next(curr_dl)) { real_ptr = GC_REVEAL_POINTER(curr_dl -> dl_hidden_obj); real_link = GC_REVEAL_POINTER(curr_dl -> dl_hidden_link); GC_printf("Object: %p, link: %p\n", real_ptr, real_link); } } } void GC_dump_finalization(void) { struct finalizable_object * curr_fo; size_t fo_size = log_fo_table_size == -1 ? 0 : 1 << log_fo_table_size; ptr_t real_ptr; size_t i; GC_printf("Disappearing (short) links:\n"); GC_dump_finalization_links(&GC_dl_hashtbl); # ifndef GC_LONG_REFS_NOT_NEEDED GC_printf("Disappearing long links:\n"); GC_dump_finalization_links(&GC_ll_hashtbl); # endif GC_printf("Finalizers:\n"); for (i = 0; i < fo_size; i++) { for (curr_fo = GC_fo_head[i]; curr_fo != 0; curr_fo = fo_next(curr_fo)) { real_ptr = GC_REVEAL_POINTER(curr_fo -> fo_hidden_base); GC_printf("Finalizable object: %p\n", real_ptr); } } } #endif /* !NO_DEBUGGING */ #ifndef SMALL_CONFIG STATIC word GC_old_dl_entries = 0; /* for stats printing */ # ifndef GC_LONG_REFS_NOT_NEEDED STATIC word GC_old_ll_entries = 0; # endif #endif /* !SMALL_CONFIG */ #ifndef THREADS /* Global variables to minimize the level of recursion when a client */ /* finalizer allocates memory. */ STATIC int GC_finalizer_nested = 0; /* Only the lowest byte is used, the rest is */ /* padding for proper global data alignment */ /* required for some compilers (like Watcom). */ STATIC unsigned GC_finalizer_skipped = 0; /* Checks and updates the level of finalizers recursion. */ /* Returns NULL if GC_invoke_finalizers() should not be called by the */ /* collector (to minimize the risk of a deep finalizers recursion), */ /* otherwise returns a pointer to GC_finalizer_nested. */ STATIC unsigned char *GC_check_finalizer_nested(void) { unsigned nesting_level = *(unsigned char *)&GC_finalizer_nested; if (nesting_level) { /* We are inside another GC_invoke_finalizers(). */ /* Skip some implicitly-called GC_invoke_finalizers() */ /* depending on the nesting (recursion) level. */ if (++GC_finalizer_skipped < (1U << nesting_level)) return NULL; GC_finalizer_skipped = 0; } *(char *)&GC_finalizer_nested = (char)(nesting_level + 1); return (unsigned char *)&GC_finalizer_nested; } #endif /* THREADS */ #define ITERATE_DL_HASHTBL_BEGIN(dl_hashtbl, curr_dl, prev_dl) \ { \ size_t i; \ size_t dl_size = dl_hashtbl->log_size == -1 ? 0 : \ 1 << dl_hashtbl->log_size; \ for (i = 0; i < dl_size; i++) { \ curr_dl = dl_hashtbl -> head[i]; \ prev_dl = NULL; \ while (curr_dl) { #define ITERATE_DL_HASHTBL_END(curr_dl, prev_dl) \ prev_dl = curr_dl; \ curr_dl = dl_next(curr_dl); \ } \ } \ } #define DELETE_DL_HASHTBL_ENTRY(dl_hashtbl, curr_dl, prev_dl, next_dl) \ { \ next_dl = dl_next(curr_dl); \ if (NULL == prev_dl) { \ dl_hashtbl -> head[i] = next_dl; \ } else { \ dl_set_next(prev_dl, next_dl); \ } \ GC_clear_mark_bit(curr_dl); \ dl_hashtbl -> entries--; \ curr_dl = next_dl; \ continue; \ } GC_INLINE void GC_make_disappearing_links_disappear( struct dl_hashtbl_s* dl_hashtbl) { struct disappearing_link *curr, *prev, *next; ptr_t real_ptr, real_link; ITERATE_DL_HASHTBL_BEGIN(dl_hashtbl, curr, prev) real_ptr = GC_REVEAL_POINTER(curr -> dl_hidden_obj); real_link = GC_REVEAL_POINTER(curr -> dl_hidden_link); if (!GC_is_marked(real_ptr)) { *(word *)real_link = 0; GC_clear_mark_bit(curr); DELETE_DL_HASHTBL_ENTRY(dl_hashtbl, curr, prev, next); } ITERATE_DL_HASHTBL_END(curr, prev) } GC_INLINE void GC_remove_dangling_disappearing_links( struct dl_hashtbl_s* dl_hashtbl) { struct disappearing_link *curr, *prev, *next; ptr_t real_link; ITERATE_DL_HASHTBL_BEGIN(dl_hashtbl, curr, prev) real_link = GC_base(GC_REVEAL_POINTER(curr -> dl_hidden_link)); if (NULL != real_link && !GC_is_marked(real_link)) { GC_clear_mark_bit(curr); DELETE_DL_HASHTBL_ENTRY(dl_hashtbl, curr, prev, next); } ITERATE_DL_HASHTBL_END(curr, prev) } /* Called with held lock (but the world is running). */ /* Cause disappearing links to disappear and unreachable objects to be */ /* enqueued for finalization. */ GC_INNER void GC_finalize(void) { struct finalizable_object * curr_fo, * prev_fo, * next_fo; ptr_t real_ptr; size_t i; size_t fo_size = log_fo_table_size == -1 ? 0 : 1 << log_fo_table_size; # ifndef SMALL_CONFIG /* Save current GC_[dl/ll]_entries value for stats printing */ GC_old_dl_entries = GC_dl_hashtbl.entries; # ifndef GC_LONG_REFS_NOT_NEEDED GC_old_ll_entries = GC_ll_hashtbl.entries; # endif # endif GC_make_disappearing_links_disappear(&GC_dl_hashtbl); /* Mark all objects reachable via chains of 1 or more pointers */ /* from finalizable objects. */ GC_ASSERT(GC_mark_state == MS_NONE); for (i = 0; i < fo_size; i++) { for (curr_fo = GC_fo_head[i]; curr_fo != 0; curr_fo = fo_next(curr_fo)) { GC_ASSERT(GC_size(curr_fo) >= sizeof(struct finalizable_object)); real_ptr = GC_REVEAL_POINTER(curr_fo -> fo_hidden_base); if (!GC_is_marked(real_ptr)) { GC_MARKED_FOR_FINALIZATION(real_ptr); GC_MARK_FO(real_ptr, curr_fo -> fo_mark_proc); if (GC_is_marked(real_ptr)) { WARN("Finalization cycle involving %p\n", real_ptr); } } } } /* Enqueue for finalization all objects that are still */ /* unreachable. */ GC_bytes_finalized = 0; for (i = 0; i < fo_size; i++) { curr_fo = GC_fo_head[i]; prev_fo = 0; while (curr_fo != 0) { real_ptr = GC_REVEAL_POINTER(curr_fo -> fo_hidden_base); if (!GC_is_marked(real_ptr)) { if (!GC_java_finalization) { GC_set_mark_bit(real_ptr); } /* Delete from hash table */ next_fo = fo_next(curr_fo); if (prev_fo == 0) { GC_fo_head[i] = next_fo; } else { fo_set_next(prev_fo, next_fo); } GC_fo_entries--; /* Add to list of objects awaiting finalization. */ fo_set_next(curr_fo, GC_finalize_now); GC_finalize_now = curr_fo; /* unhide object pointer so any future collections will */ /* see it. */ curr_fo -> fo_hidden_base = (word)GC_REVEAL_POINTER(curr_fo -> fo_hidden_base); GC_bytes_finalized += curr_fo -> fo_object_size + sizeof(struct finalizable_object); GC_ASSERT(GC_is_marked(GC_base(curr_fo))); curr_fo = next_fo; } else { prev_fo = curr_fo; curr_fo = fo_next(curr_fo); } } } if (GC_java_finalization) { /* make sure we mark everything reachable from objects finalized using the no_order mark_proc */ for (curr_fo = GC_finalize_now; curr_fo != NULL; curr_fo = fo_next(curr_fo)) { real_ptr = (ptr_t)curr_fo -> fo_hidden_base; if (!GC_is_marked(real_ptr)) { if (curr_fo -> fo_mark_proc == GC_null_finalize_mark_proc) { GC_MARK_FO(real_ptr, GC_normal_finalize_mark_proc); } if (curr_fo -> fo_mark_proc != GC_unreachable_finalize_mark_proc) { GC_set_mark_bit(real_ptr); } } } /* now revive finalize-when-unreachable objects reachable from other finalizable objects */ if (need_unreachable_finalization) { curr_fo = GC_finalize_now; prev_fo = 0; while (curr_fo != 0) { next_fo = fo_next(curr_fo); if (curr_fo -> fo_mark_proc == GC_unreachable_finalize_mark_proc) { real_ptr = (ptr_t)curr_fo -> fo_hidden_base; if (!GC_is_marked(real_ptr)) { GC_set_mark_bit(real_ptr); } else { if (prev_fo == 0) GC_finalize_now = next_fo; else fo_set_next(prev_fo, next_fo); curr_fo -> fo_hidden_base = GC_HIDE_POINTER(curr_fo -> fo_hidden_base); GC_bytes_finalized -= curr_fo->fo_object_size + sizeof(struct finalizable_object); i = HASH2(real_ptr, log_fo_table_size); fo_set_next (curr_fo, GC_fo_head[i]); GC_fo_entries++; GC_fo_head[i] = curr_fo; curr_fo = prev_fo; } } prev_fo = curr_fo; curr_fo = next_fo; } } } GC_remove_dangling_disappearing_links(&GC_dl_hashtbl); # ifndef GC_LONG_REFS_NOT_NEEDED GC_make_disappearing_links_disappear(&GC_ll_hashtbl); GC_remove_dangling_disappearing_links(&GC_ll_hashtbl); # endif if (GC_fail_count) { /* Don't prevent running finalizers if there has been an allocation */ /* failure recently. */ # ifdef THREADS GC_reset_finalizer_nested(); # else GC_finalizer_nested = 0; # endif } } #ifndef JAVA_FINALIZATION_NOT_NEEDED /* Enqueue all remaining finalizers to be run - Assumes lock is held. */ STATIC void GC_enqueue_all_finalizers(void) { struct finalizable_object * curr_fo, * prev_fo, * next_fo; ptr_t real_ptr; register int i; int fo_size; fo_size = log_fo_table_size == -1 ? 0 : 1 << log_fo_table_size; GC_bytes_finalized = 0; for (i = 0; i < fo_size; i++) { curr_fo = GC_fo_head[i]; prev_fo = 0; while (curr_fo != 0) { real_ptr = GC_REVEAL_POINTER(curr_fo -> fo_hidden_base); GC_MARK_FO(real_ptr, GC_normal_finalize_mark_proc); GC_set_mark_bit(real_ptr); /* Delete from hash table */ next_fo = fo_next(curr_fo); if (prev_fo == 0) { GC_fo_head[i] = next_fo; } else { fo_set_next(prev_fo, next_fo); } GC_fo_entries--; /* Add to list of objects awaiting finalization. */ fo_set_next(curr_fo, GC_finalize_now); GC_finalize_now = curr_fo; /* unhide object pointer so any future collections will */ /* see it. */ curr_fo -> fo_hidden_base = (word)GC_REVEAL_POINTER(curr_fo -> fo_hidden_base); GC_bytes_finalized += curr_fo -> fo_object_size + sizeof(struct finalizable_object); curr_fo = next_fo; } } } /* Invoke all remaining finalizers that haven't yet been run. * This is needed for strict compliance with the Java standard, * which can make the runtime guarantee that all finalizers are run. * Unfortunately, the Java standard implies we have to keep running * finalizers until there are no more left, a potential infinite loop. * YUCK. * Note that this is even more dangerous than the usual Java * finalizers, in that objects reachable from static variables * may have been finalized when these finalizers are run. * Finalizers run at this point must be prepared to deal with a * mostly broken world. * This routine is externally callable, so is called without * the allocation lock. */ GC_API void GC_CALL GC_finalize_all(void) { DCL_LOCK_STATE; LOCK(); while (GC_fo_entries > 0) { GC_enqueue_all_finalizers(); UNLOCK(); GC_invoke_finalizers(); /* Running the finalizers in this thread is arguably not a good */ /* idea when we should be notifying another thread to run them. */ /* But otherwise we don't have a great way to wait for them to */ /* run. */ LOCK(); } UNLOCK(); } #endif /* !JAVA_FINALIZATION_NOT_NEEDED */ /* Returns true if it is worth calling GC_invoke_finalizers. (Useful if */ /* finalizers can only be called from some kind of "safe state" and */ /* getting into that safe state is expensive.) */ GC_API int GC_CALL GC_should_invoke_finalizers(void) { return GC_finalize_now != 0; } /* Invoke finalizers for all objects that are ready to be finalized. */ /* Should be called without allocation lock. */ GC_API int GC_CALL GC_invoke_finalizers(void) { struct finalizable_object * curr_fo; int count = 0; word bytes_freed_before = 0; /* initialized to prevent warning. */ DCL_LOCK_STATE; while (GC_finalize_now != 0) { # ifdef THREADS LOCK(); # endif if (count == 0) { bytes_freed_before = GC_bytes_freed; /* Don't do this outside, since we need the lock. */ } curr_fo = GC_finalize_now; # ifdef THREADS if (curr_fo != 0) GC_finalize_now = fo_next(curr_fo); UNLOCK(); if (curr_fo == 0) break; # else GC_finalize_now = fo_next(curr_fo); # endif fo_set_next(curr_fo, 0); (*(curr_fo -> fo_fn))((ptr_t)(curr_fo -> fo_hidden_base), curr_fo -> fo_client_data); curr_fo -> fo_client_data = 0; ++count; # ifdef UNDEFINED /* This is probably a bad idea. It throws off accounting if */ /* nearly all objects are finalizable. O.w. it shouldn't */ /* matter. */ GC_free((void *)curr_fo); # endif } /* bytes_freed_before is initialized whenever count != 0 */ if (count != 0 && bytes_freed_before != GC_bytes_freed) { LOCK(); GC_finalizer_bytes_freed += (GC_bytes_freed - bytes_freed_before); UNLOCK(); } return count; } static GC_word last_finalizer_notification = 0; GC_INNER void GC_notify_or_invoke_finalizers(void) { GC_finalizer_notifier_proc notifier_fn = 0; # if defined(KEEP_BACK_PTRS) || defined(MAKE_BACK_GRAPH) static word last_back_trace_gc_no = 1; /* Skip first one. */ # endif DCL_LOCK_STATE; # if defined(THREADS) && !defined(KEEP_BACK_PTRS) \ && !defined(MAKE_BACK_GRAPH) /* Quick check (while unlocked) for an empty finalization queue. */ if (GC_finalize_now == 0) return; # endif LOCK(); /* This is a convenient place to generate backtraces if appropriate, */ /* since that code is not callable with the allocation lock. */ # if defined(KEEP_BACK_PTRS) || defined(MAKE_BACK_GRAPH) if (GC_gc_no > last_back_trace_gc_no) { # ifdef KEEP_BACK_PTRS long i; /* Stops when GC_gc_no wraps; that's OK. */ last_back_trace_gc_no = (word)(-1); /* disable others. */ for (i = 0; i < GC_backtraces; ++i) { /* FIXME: This tolerates concurrent heap mutation, */ /* which may cause occasional mysterious results. */ /* We need to release the GC lock, since GC_print_callers */ /* acquires it. It probably shouldn't. */ UNLOCK(); GC_generate_random_backtrace_no_gc(); LOCK(); } last_back_trace_gc_no = GC_gc_no; # endif # ifdef MAKE_BACK_GRAPH if (GC_print_back_height) { UNLOCK(); GC_print_back_graph_stats(); LOCK(); } # endif } # endif if (GC_finalize_now == 0) { UNLOCK(); return; } if (!GC_finalize_on_demand) { unsigned char *pnested = GC_check_finalizer_nested(); UNLOCK(); /* Skip GC_invoke_finalizers() if nested */ if (pnested != NULL) { (void) GC_invoke_finalizers(); *pnested = 0; /* Reset since no more finalizers. */ # ifndef THREADS GC_ASSERT(GC_finalize_now == 0); # endif /* Otherwise GC can run concurrently and add more */ } return; } /* These variables require synchronization to avoid data races. */ if (last_finalizer_notification != GC_gc_no) { last_finalizer_notification = GC_gc_no; notifier_fn = GC_finalizer_notifier; } UNLOCK(); if (notifier_fn != 0) (*notifier_fn)(); /* Invoke the notifier */ } #ifndef SMALL_CONFIG # ifndef GC_LONG_REFS_NOT_NEEDED # define IF_LONG_REFS_PRESENT_ELSE(x,y) (x) # else # define IF_LONG_REFS_PRESENT_ELSE(x,y) (y) # endif GC_INNER void GC_print_finalization_stats(void) { struct finalizable_object *fo; unsigned long ready = 0; GC_log_printf("%lu finalization entries;" " %lu/%lu short/long disappearing links alive\n", (unsigned long)GC_fo_entries, (unsigned long)GC_dl_hashtbl.entries, (unsigned long)IF_LONG_REFS_PRESENT_ELSE( GC_ll_hashtbl.entries, 0)); for (fo = GC_finalize_now; 0 != fo; fo = fo_next(fo)) ++ready; GC_log_printf("%lu finalization-ready objects;" " %ld/%ld short/long links cleared\n", ready, (long)GC_old_dl_entries - (long)GC_dl_hashtbl.entries, (long)IF_LONG_REFS_PRESENT_ELSE( GC_old_ll_entries - GC_ll_hashtbl.entries, 0)); } #endif /* !SMALL_CONFIG */ #endif /* !GC_NO_FINALIZATION */ ecl-16.1.2/src/bdwgc/fnlz_mlc.c000066400000000000000000000131611266352375300162070ustar00rootroot00000000000000/* * Copyright (c) 2011 by Hewlett-Packard Company. All rights reserved. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. * */ #include "private/gc_priv.h" #ifdef ENABLE_DISCLAIM #include "gc_disclaim.h" #ifdef THREAD_LOCAL_ALLOC # include "private/thread_local_alloc.h" #else STATIC ptr_t * GC_finalized_objfreelist = NULL; #endif /* !THREAD_LOCAL_ALLOC */ STATIC int GC_finalized_kind = 0; STATIC int GC_CALLBACK GC_finalized_disclaim(void *obj) { word fc_word = *(word *)obj; if ((fc_word & 1) != 0) { /* The disclaim function may be passed fragments from the */ /* free-list, on which it should not run finalization. */ /* To recognize this case, we use the fact that the first word */ /* on such fragments are always even (a link to the next */ /* fragment, or NULL). If it is desirable to have a finalizer */ /* which does not use the first word for storing finalization */ /* info, GC_reclaim_with_finalization must be extended to clear */ /* fragments so that the assumption holds for the selected word. */ const struct GC_finalizer_closure *fc = (void *)(fc_word & ~(word)1); (*fc->proc)((word *)obj + 1, fc->cd); } return 0; } static GC_bool done_init = FALSE; GC_API void GC_CALL GC_init_finalized_malloc(void) { DCL_LOCK_STATE; GC_init(); /* In case it's not already done. */ LOCK(); if (done_init) { UNLOCK(); return; } done_init = TRUE; /* The finalizer closure is placed in the first word in order to */ /* use the lower bits to distinguish live objects from objects on */ /* the free list. The downside of this is that we need one-word */ /* offset interior pointers, and that GC_base does not return the */ /* start of the user region. */ GC_register_displacement_inner(sizeof(word)); GC_finalized_objfreelist = (ptr_t *)GC_new_free_list_inner(); GC_finalized_kind = GC_new_kind_inner((void **)GC_finalized_objfreelist, GC_DS_LENGTH, TRUE, TRUE); GC_register_disclaim_proc(GC_finalized_kind, GC_finalized_disclaim, TRUE); UNLOCK(); } GC_API void GC_CALL GC_register_disclaim_proc(int kind, GC_disclaim_proc proc, int mark_unconditionally) { GC_ASSERT((unsigned)kind < MAXOBJKINDS); GC_obj_kinds[kind].ok_disclaim_proc = proc; GC_obj_kinds[kind].ok_mark_unconditionally = (GC_bool)mark_unconditionally; } #ifdef THREAD_LOCAL_ALLOC STATIC void * GC_core_finalized_malloc(size_t lb, const struct GC_finalizer_closure *fclos) #else GC_API GC_ATTR_MALLOC void * GC_CALL GC_finalized_malloc(size_t lb, const struct GC_finalizer_closure *fclos) #endif { ptr_t op; word lg; DCL_LOCK_STATE; lb += sizeof(word); GC_ASSERT(done_init); if (SMALL_OBJ(lb)) { GC_DBG_COLLECT_AT_MALLOC(lb); lg = GC_size_map[lb]; LOCK(); op = GC_finalized_objfreelist[lg]; if (EXPECT(0 == op, FALSE)) { UNLOCK(); op = GC_generic_malloc(lb, GC_finalized_kind); if (NULL == op) return NULL; /* GC_generic_malloc has extended the size map for us. */ lg = GC_size_map[lb]; } else { GC_finalized_objfreelist[lg] = obj_link(op); obj_link(op) = 0; GC_bytes_allocd += GRANULES_TO_BYTES(lg); UNLOCK(); } GC_ASSERT(lg > 0); } else { op = GC_generic_malloc(lb, GC_finalized_kind); if (NULL == op) return NULL; GC_ASSERT(GC_size(op) >= lb); } *(word *)op = (word)fclos | 1; return GC_clear_stack((word *)op + 1); } #ifdef THREAD_LOCAL_ALLOC GC_API GC_ATTR_MALLOC void * GC_CALL GC_finalized_malloc(size_t client_lb, const struct GC_finalizer_closure *fclos) { size_t lb = client_lb + sizeof(word); size_t lg = ROUNDED_UP_GRANULES(lb); GC_tlfs tsd; void *result; void **tiny_fl, **my_fl, *my_entry; void *next; if (EXPECT(lg >= GC_TINY_FREELISTS, FALSE)) return GC_core_finalized_malloc(client_lb, fclos); tsd = GC_getspecific(GC_thread_key); tiny_fl = tsd->finalized_freelists; my_fl = tiny_fl + lg; my_entry = *my_fl; while (EXPECT((word)my_entry <= DIRECT_GRANULES + GC_TINY_FREELISTS + 1, FALSE)) { if ((word)my_entry - 1 < DIRECT_GRANULES) { *my_fl = (ptr_t)my_entry + lg + 1; return GC_core_finalized_malloc(client_lb, fclos); } else { GC_generic_malloc_many(GC_RAW_BYTES_FROM_INDEX(lg), GC_finalized_kind, my_fl); my_entry = *my_fl; if (my_entry == 0) { return (*GC_get_oom_fn())(lb); } } } next = obj_link(my_entry); result = (void *)my_entry; *my_fl = next; obj_link(result) = 0; *(word *)result = (word)fclos | 1; PREFETCH_FOR_WRITE(next); return (word *)result + 1; } #endif /* THREAD_LOCAL_ALLOC */ #endif /* ENABLE_DISCLAIM */ ecl-16.1.2/src/bdwgc/gc.mak000066400000000000000000001543551266352375300153350ustar00rootroot00000000000000# Microsoft Developer Studio Generated NMAKE File, Format Version 4.10 # This has been hand-edited way too many times. # A clean, manually generated makefile would be an improvement. # TARGTYPE "Win32 (x86) Application" 0x0101 # TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102 !IF "$(CFG)" == "" CFG=gctest - Win32 Release !MESSAGE No configuration specified. Defaulting to cord - Win32 Debug. !ENDIF !IF "$(CFG)" != "gc - Win32 Release" && "$(CFG)" != "gc - Win32 Debug" &&\ "$(CFG)" != "gctest - Win32 Release" && "$(CFG)" != "gctest - Win32 Debug" &&\ "$(CFG)" != "cord - Win32 Release" && "$(CFG)" != "cord - Win32 Debug" !MESSAGE Invalid configuration "$(CFG)" specified. !MESSAGE You can specify a configuration when running NMAKE on this makefile !MESSAGE by defining the macro CFG on the command line. For example: !MESSAGE !MESSAGE NMAKE /f "gc.mak" CFG="cord - Win32 Debug" !MESSAGE !MESSAGE Possible choices for configuration are: !MESSAGE !MESSAGE "gc - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library") !MESSAGE "gc - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library") !MESSAGE "gctest - Win32 Release" (based on "Win32 (x86) Application") !MESSAGE "gctest - Win32 Debug" (based on "Win32 (x86) Application") !MESSAGE "cord - Win32 Release" (based on "Win32 (x86) Application") !MESSAGE "cord - Win32 Debug" (based on "Win32 (x86) Application") !MESSAGE !ERROR An invalid configuration is specified. !ENDIF !IF "$(OS)" == "Windows_NT" NULL= !ELSE NULL=nul !ENDIF ################################################################################ # Begin Project # PROP Target_Last_Scanned "gctest - Win32 Debug" !IF "$(CFG)" == "gc - Win32 Release" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 0 # PROP BASE Output_Dir "Release" # PROP BASE Intermediate_Dir "Release" # PROP BASE Target_Dir "" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 0 # PROP Output_Dir "Release" # PROP Intermediate_Dir "Release" # PROP Target_Dir "" OUTDIR=.\Release INTDIR=.\Release ALL : ".\Release\gc.dll" ".\Release\gc.bsc" CLEAN : -@erase ".\Release\allchblk.obj" -@erase ".\Release\allchblk.sbr" -@erase ".\Release\alloc.obj" -@erase ".\Release\alloc.sbr" -@erase ".\Release\blacklst.obj" -@erase ".\Release\blacklst.sbr" -@erase ".\Release\checksums.obj" -@erase ".\Release\checksums.sbr" -@erase ".\Release\dbg_mlc.obj" -@erase ".\Release\dbg_mlc.sbr" -@erase ".\Release\dyn_load.obj" -@erase ".\Release\dyn_load.sbr" -@erase ".\Release\finalize.obj" -@erase ".\Release\finalize.sbr" -@erase ".\Release\fnlz_mlc.obj" -@erase ".\Release\fnlz_mlc.sbr" -@erase ".\Release\gc.bsc" -@erase ".\Release\gc_cpp.obj" -@erase ".\Release\gc_cpp.sbr" -@erase ".\Release\gc.dll" -@erase ".\Release\gc.exp" -@erase ".\Release\gc.lib" -@erase ".\Release\headers.obj" -@erase ".\Release\headers.sbr" -@erase ".\Release\mach_dep.obj" -@erase ".\Release\mach_dep.sbr" -@erase ".\Release\malloc.obj" -@erase ".\Release\malloc.sbr" -@erase ".\Release\mallocx.obj" -@erase ".\Release\mallocx.sbr" -@erase ".\Release\mark.obj" -@erase ".\Release\mark.sbr" -@erase ".\Release\mark_rts.obj" -@erase ".\Release\mark_rts.sbr" -@erase ".\Release\misc.obj" -@erase ".\Release\misc.sbr" -@erase ".\Release\new_hblk.obj" -@erase ".\Release\new_hblk.sbr" -@erase ".\Release\obj_map.obj" -@erase ".\Release\obj_map.sbr" -@erase ".\Release\os_dep.obj" -@erase ".\Release\os_dep.sbr" -@erase ".\Release\ptr_chck.obj" -@erase ".\Release\ptr_chck.sbr" -@erase ".\Release\reclaim.obj" -@erase ".\Release\reclaim.sbr" -@erase ".\Release\stubborn.obj" -@erase ".\Release\stubborn.sbr" -@erase ".\Release\typd_mlc.obj" -@erase ".\Release\typd_mlc.sbr" -@erase ".\Release\win32_threads.obj" -@erase ".\Release\win32_threads.sbr" -@erase ".\Release\msvc_dbg.obj" -@erase ".\Release\msvc_dbg.sbr" "$(OUTDIR)" : if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)" CPP=cl.exe # ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /c # ADD CPP /nologo /MD /W3 /GX /O2 /I include /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "ALL_INTERIOR_POINTERS" /D "GC_THREADS" /FR /YX /c CPP_PROJ=/nologo /MD /W3 /GX /O2 /I include /D "NDEBUG" /D\ "WIN32" /D "_WINDOWS" /D "ALL_INTERIOR_POINTERS" /D "GC_THREADS" \ /FR"$(INTDIR)/" /Fp"$(INTDIR)/gc.pch" \ /I./libatomic_ops/src /YX /Fo"$(INTDIR)/" /c CPP_OBJS=.\Release/ CPP_SBRS=.\Release/ .c{$(CPP_OBJS)}.obj: $(CPP) $(CPP_PROJ) $< .cpp{$(CPP_OBJS)}.obj: $(CPP) $(CPP_PROJ) $< .cxx{$(CPP_OBJS)}.obj: $(CPP) $(CPP_PROJ) $< .c{$(CPP_SBRS)}.sbr: $(CPP) $(CPP_PROJ) $< .cpp{$(CPP_SBRS)}.sbr: $(CPP) $(CPP_PROJ) $< .cxx{$(CPP_SBRS)}.sbr: $(CPP) $(CPP_PROJ) $< MTL=mktyplib.exe # ADD BASE MTL /nologo /D "NDEBUG" /win32 # ADD MTL /nologo /D "NDEBUG" /win32 MTL_PROJ=/nologo /D "NDEBUG" /win32 RSC=rc.exe # ADD BASE RSC /l 0x809 /d "NDEBUG" # ADD RSC /l 0x809 /d "NDEBUG" BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo BSC32_FLAGS=/nologo /o"$(OUTDIR)/gc.bsc" BSC32_SBRS= \ ".\Release\allchblk.sbr" \ ".\Release\alloc.sbr" \ ".\Release\blacklst.sbr" \ ".\Release\checksums.sbr" \ ".\Release\dbg_mlc.sbr" \ ".\Release\dyn_load.sbr" \ ".\Release\finalize.sbr" \ ".\Release\fnlz_mlc.sbr" \ ".\Release\gc_cpp.sbr" \ ".\Release\headers.sbr" \ ".\Release\mach_dep.sbr" \ ".\Release\malloc.sbr" \ ".\Release\mallocx.sbr" \ ".\Release\mark.sbr" \ ".\Release\mark_rts.sbr" \ ".\Release\misc.sbr" \ ".\Release\new_hblk.sbr" \ ".\Release\obj_map.sbr" \ ".\Release\os_dep.sbr" \ ".\Release\ptr_chck.sbr" \ ".\Release\reclaim.sbr" \ ".\Release\stubborn.sbr" \ ".\Release\typd_mlc.sbr" \ ".\Release\msvc_dbg.sbr" \ ".\Release\win32_threads.sbr" ".\Release\gc.bsc" : "$(OUTDIR)" $(BSC32_SBRS) $(BSC32) @<< $(BSC32_FLAGS) $(BSC32_SBRS) << LINK32=link.exe # ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /dll /machine:I386 # ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /dll /machine:I386 LINK32_FLAGS=kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib\ advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib\ odbccp32.lib /nologo /subsystem:windows /dll /incremental:no\ /pdb:"$(OUTDIR)/gc.pdb" /machine:I386 /out:"$(OUTDIR)/gc.dll"\ /implib:"$(OUTDIR)/gc.lib" LINK32_OBJS= \ ".\Release\allchblk.obj" \ ".\Release\alloc.obj" \ ".\Release\blacklst.obj" \ ".\Release\checksums.obj" \ ".\Release\dbg_mlc.obj" \ ".\Release\dyn_load.obj" \ ".\Release\finalize.obj" \ ".\Release\fnlz_mlc.obj" \ ".\Release\gc_cpp.obj" \ ".\Release\headers.obj" \ ".\Release\mach_dep.obj" \ ".\Release\malloc.obj" \ ".\Release\mallocx.obj" \ ".\Release\mark.obj" \ ".\Release\mark_rts.obj" \ ".\Release\misc.obj" \ ".\Release\new_hblk.obj" \ ".\Release\obj_map.obj" \ ".\Release\os_dep.obj" \ ".\Release\ptr_chck.obj" \ ".\Release\reclaim.obj" \ ".\Release\stubborn.obj" \ ".\Release\typd_mlc.obj" \ ".\Release\msvc_dbg.obj" \ ".\Release\win32_threads.obj" ".\Release\gc.dll" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS) $(LINK32) @<< $(LINK32_FLAGS) $(LINK32_OBJS) << !ELSEIF "$(CFG)" == "gc - Win32 Debug" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 1 # PROP BASE Output_Dir "Debug" # PROP BASE Intermediate_Dir "Debug" # PROP BASE Target_Dir "" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 1 # PROP Output_Dir "Debug" # PROP Intermediate_Dir "Debug" # PROP Target_Dir "" OUTDIR=.\Debug INTDIR=.\Debug ALL : ".\Debug\gc.dll" ".\Debug\gc.bsc" CLEAN : -@erase ".\Debug\allchblk.obj" -@erase ".\Debug\allchblk.sbr" -@erase ".\Debug\alloc.obj" -@erase ".\Debug\alloc.sbr" -@erase ".\Debug\blacklst.obj" -@erase ".\Debug\blacklst.sbr" -@erase ".\Debug\checksums.obj" -@erase ".\Debug\checksums.sbr" -@erase ".\Debug\dbg_mlc.obj" -@erase ".\Debug\dbg_mlc.sbr" -@erase ".\Debug\dyn_load.obj" -@erase ".\Debug\dyn_load.sbr" -@erase ".\Debug\finalize.obj" -@erase ".\Debug\finalize.sbr" -@erase ".\Debug\fnlz_mlc.obj" -@erase ".\Debug\fnlz_mlc.sbr" -@erase ".\Debug\gc_cpp.obj" -@erase ".\Debug\gc_cpp.sbr" -@erase ".\Debug\gc.bsc" -@erase ".\Debug\gc.dll" -@erase ".\Debug\gc.exp" -@erase ".\Debug\gc.lib" -@erase ".\Debug\gc.map" -@erase ".\Debug\gc.pdb" -@erase ".\Debug\headers.obj" -@erase ".\Debug\headers.sbr" -@erase ".\Debug\mach_dep.obj" -@erase ".\Debug\mach_dep.sbr" -@erase ".\Debug\malloc.obj" -@erase ".\Debug\malloc.sbr" -@erase ".\Debug\mallocx.obj" -@erase ".\Debug\mallocx.sbr" -@erase ".\Debug\mark.obj" -@erase ".\Debug\mark.sbr" -@erase ".\Debug\mark_rts.obj" -@erase ".\Debug\mark_rts.sbr" -@erase ".\Debug\misc.obj" -@erase ".\Debug\misc.sbr" -@erase ".\Debug\new_hblk.obj" -@erase ".\Debug\new_hblk.sbr" -@erase ".\Debug\obj_map.obj" -@erase ".\Debug\obj_map.sbr" -@erase ".\Debug\os_dep.obj" -@erase ".\Debug\os_dep.sbr" -@erase ".\Debug\ptr_chck.obj" -@erase ".\Debug\ptr_chck.sbr" -@erase ".\Debug\reclaim.obj" -@erase ".\Debug\reclaim.sbr" -@erase ".\Debug\stubborn.obj" -@erase ".\Debug\stubborn.sbr" -@erase ".\Debug\typd_mlc.obj" -@erase ".\Debug\typd_mlc.sbr" -@erase ".\Debug\vc40.idb" -@erase ".\Debug\vc40.pdb" -@erase ".\Debug\win32_threads.obj" -@erase ".\Debug\win32_threads.sbr" -@erase ".\Debug\msvc_dbg.obj" -@erase ".\Debug\msvc_dbg.sbr" "$(OUTDIR)" : if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)" CPP=cl.exe # ADD BASE CPP /nologo /MTd /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /c # ADD CPP /nologo /MDd /W3 /Gm /GX /Zi /Od /I include /D "_DEBUG" /D "WIN32" /D "_WINDOWS" /D "ALL_INTERIOR_POINTERS" /D "GC_THREADS" /FR /YX /c CPP_PROJ=/nologo /MDd /W3 /Gm /GX /Zi /Od /I include /D "_DEBUG"\ /D "WIN32" /D "_WINDOWS" /D "ALL_INTERIOR_POINTERS" \ /D "GC_ASSERTIONS" /D "GC_THREADS" \ /FR"$(INTDIR)/" /Fp"$(INTDIR)/gc.pch" /YX /Fo"$(INTDIR)/"\ /I./libatomic_ops/src /Fd"$(INTDIR)/" /c CPP_OBJS=.\Debug/ CPP_SBRS=.\Debug/ .c{$(CPP_OBJS)}.obj: $(CPP) $(CPP_PROJ) $< .cpp{$(CPP_OBJS)}.obj: $(CPP) $(CPP_PROJ) $< .cxx{$(CPP_OBJS)}.obj: $(CPP) $(CPP_PROJ) $< .c{$(CPP_SBRS)}.sbr: $(CPP) $(CPP_PROJ) $< .cpp{$(CPP_SBRS)}.sbr: $(CPP) $(CPP_PROJ) $< .cxx{$(CPP_SBRS)}.sbr: $(CPP) $(CPP_PROJ) $< MTL=mktyplib.exe # ADD BASE MTL /nologo /D "_DEBUG" /win32 # ADD MTL /nologo /D "_DEBUG" /win32 MTL_PROJ=/nologo /D "_DEBUG" /win32 RSC=rc.exe # ADD BASE RSC /l 0x809 /d "_DEBUG" # ADD RSC /l 0x809 /d "_DEBUG" BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo BSC32_FLAGS=/nologo /o"$(OUTDIR)/gc.bsc" BSC32_SBRS= \ ".\Debug\allchblk.sbr" \ ".\Debug\alloc.sbr" \ ".\Debug\blacklst.sbr" \ ".\Debug\checksums.sbr" \ ".\Debug\dbg_mlc.sbr" \ ".\Debug\dyn_load.sbr" \ ".\Debug\finalize.sbr" \ ".\Debug\fnlz_mlc.sbr" \ ".\Debug\gc_cpp.sbr" \ ".\Debug\headers.sbr" \ ".\Debug\mach_dep.sbr" \ ".\Debug\malloc.sbr" \ ".\Debug\mallocx.sbr" \ ".\Debug\mark.sbr" \ ".\Debug\mark_rts.sbr" \ ".\Debug\misc.sbr" \ ".\Debug\new_hblk.sbr" \ ".\Debug\obj_map.sbr" \ ".\Debug\os_dep.sbr" \ ".\Debug\ptr_chck.sbr" \ ".\Debug\reclaim.sbr" \ ".\Debug\stubborn.sbr" \ ".\Debug\typd_mlc.sbr" \ ".\Debug\msvc_dbg.sbr" \ ".\Debug\win32_threads.sbr" ".\Debug\gc.bsc" : "$(OUTDIR)" $(BSC32_SBRS) $(BSC32) @<< $(BSC32_FLAGS) $(BSC32_SBRS) << LINK32=link.exe # ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /dll /debug /machine:I386 # ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /dll /incremental:no /map /debug /machine:I386 LINK32_FLAGS=kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib\ advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib\ odbccp32.lib /nologo /subsystem:windows /dll /incremental:no\ /pdb:"$(OUTDIR)/gc.pdb" /map:"$(INTDIR)/gc.map" /debug /machine:I386\ /out:"$(OUTDIR)/gc.dll" /implib:"$(OUTDIR)/gc.lib" LINK32_OBJS= \ ".\Debug\allchblk.obj" \ ".\Debug\alloc.obj" \ ".\Debug\blacklst.obj" \ ".\Debug\checksums.obj" \ ".\Debug\dbg_mlc.obj" \ ".\Debug\dyn_load.obj" \ ".\Debug\finalize.obj" \ ".\Debug\fnlz_mlc.obj" \ ".\Debug\gc_cpp.obj" \ ".\Debug\headers.obj" \ ".\Debug\mach_dep.obj" \ ".\Debug\malloc.obj" \ ".\Debug\mallocx.obj" \ ".\Debug\mark.obj" \ ".\Debug\mark_rts.obj" \ ".\Debug\misc.obj" \ ".\Debug\new_hblk.obj" \ ".\Debug\obj_map.obj" \ ".\Debug\os_dep.obj" \ ".\Debug\ptr_chck.obj" \ ".\Debug\reclaim.obj" \ ".\Debug\stubborn.obj" \ ".\Debug\typd_mlc.obj" \ ".\Debug\msvc_dbg.obj" \ ".\Debug\win32_threads.obj" ".\Debug\gc.dll" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS) $(LINK32) @<< $(LINK32_FLAGS) $(LINK32_OBJS) << !ELSEIF "$(CFG)" == "gctest - Win32 Release" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 0 # PROP BASE Output_Dir "gctest\Release" # PROP BASE Intermediate_Dir "gctest\Release" # PROP BASE Target_Dir "gctest" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 0 # PROP Output_Dir "gctest\Release" # PROP Intermediate_Dir "gctest\Release" # PROP Target_Dir "gctest" OUTDIR=.\gctest\Release INTDIR=.\gctest\Release ALL : "gc - Win32 Release" ".\Release\gctest.exe" CLEAN : -@erase ".\gctest\Release\test.obj" -@erase ".\Release\gctest.exe" "$(OUTDIR)" : if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)" test.c : tests\test.c copy tests\test.c test.c CPP=cl.exe # ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /c # ADD CPP /nologo /MD /W3 /GX /O2 /I include /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "ALL_INTERIOR_POINTERS" /D "GC_THREADS" /YX /c CPP_PROJ=/nologo /MD /W3 /GX /O2 /I include /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D\ "ALL_INTERIOR_POINTERS" /D "GC_THREADS" \ /I./libatomic_ops/src /Fp"$(INTDIR)/gctest.pch" \ /YX /Fo"$(INTDIR)/" /c CPP_OBJS=.\gctest\Release/ CPP_SBRS=.\. .c{$(CPP_OBJS)}.obj: $(CPP) $(CPP_PROJ) $< .cpp{$(CPP_OBJS)}.obj: $(CPP) $(CPP_PROJ) $< .cxx{$(CPP_OBJS)}.obj: $(CPP) $(CPP_PROJ) $< .c{$(CPP_SBRS)}.sbr: $(CPP) $(CPP_PROJ) $< .cpp{$(CPP_SBRS)}.sbr: $(CPP) $(CPP_PROJ) $< .cxx{$(CPP_SBRS)}.sbr: $(CPP) $(CPP_PROJ) $< MTL=mktyplib.exe # ADD BASE MTL /nologo /D "NDEBUG" /win32 # ADD MTL /nologo /D "NDEBUG" /win32 MTL_PROJ=/nologo /D "NDEBUG" /win32 RSC=rc.exe # ADD BASE RSC /l 0x809 /d "NDEBUG" # ADD RSC /l 0x809 /d "NDEBUG" BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo BSC32_FLAGS=/nologo /o"$(OUTDIR)/gctest.bsc" BSC32_SBRS= \ LINK32=link.exe # ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386 # ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386 /out:"Release/gctest.exe" LINK32_FLAGS=kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib\ advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib\ odbccp32.lib /nologo /subsystem:windows /incremental:no\ /pdb:"$(OUTDIR)/gctest.pdb" /machine:I386 /out:"Release/gctest.exe" LINK32_OBJS= \ ".\gctest\Release\test.obj" \ ".\Release\gc.lib" ".\Release\gctest.exe" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS) $(LINK32) @<< $(LINK32_FLAGS) $(LINK32_OBJS) << !ELSEIF "$(CFG)" == "gctest - Win32 Debug" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 1 # PROP BASE Output_Dir "gctest\Debug" # PROP BASE Intermediate_Dir "gctest\Debug" # PROP BASE Target_Dir "gctest" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 1 # PROP Output_Dir "gctest\Debug" # PROP Intermediate_Dir "gctest\Debug" # PROP Target_Dir "gctest" OUTDIR=.\gctest\Debug INTDIR=.\gctest\Debug ALL : "gc - Win32 Debug" ".\Debug\gctest.exe" ".\gctest\Debug\gctest.bsc" CLEAN : -@erase ".\Debug\gctest.exe" -@erase ".\gctest\Debug\gctest.bsc" -@erase ".\gctest\Debug\gctest.map" -@erase ".\gctest\Debug\gctest.pdb" -@erase ".\gctest\Debug\test.obj" -@erase ".\gctest\Debug\test.sbr" -@erase ".\gctest\Debug\vc40.idb" -@erase ".\gctest\Debug\vc40.pdb" "$(OUTDIR)" : if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)" CPP=cl.exe # ADD BASE CPP /nologo /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /c # ADD CPP /nologo /MDd /W3 /Gm /GX /Zi /Od /D "_DEBUG" /D "WIN32" /D "_WINDOWS" /D "ALL_INTERIOR_POINTERS" /D "GC_THREADS" /FR /YX /c CPP_PROJ=/nologo /MDd /W3 /Gm /GX /Zi /Od /I include /D "_DEBUG" /D "WIN32" /D "_WINDOWS"\ /D "ALL_INTERIOR_POINTERS" /D "GC_THREADS" /FR"$(INTDIR)/"\ /I./libatomic_ops/src /Fp"$(INTDIR)/gctest.pch" /YX /Fo"$(INTDIR)/" /Fd"$(INTDIR)/" /c CPP_OBJS=.\gctest\Debug/ CPP_SBRS=.\gctest\Debug/ .c{$(CPP_OBJS)}.obj: $(CPP) $(CPP_PROJ) $< .cpp{$(CPP_OBJS)}.obj: $(CPP) $(CPP_PROJ) $< .cxx{$(CPP_OBJS)}.obj: $(CPP) $(CPP_PROJ) $< .c{$(CPP_SBRS)}.sbr: $(CPP) $(CPP_PROJ) $< .cpp{$(CPP_SBRS)}.sbr: $(CPP) $(CPP_PROJ) $< .cxx{$(CPP_SBRS)}.sbr: $(CPP) $(CPP_PROJ) $< MTL=mktyplib.exe # ADD BASE MTL /nologo /D "_DEBUG" /win32 # ADD MTL /nologo /D "_DEBUG" /win32 MTL_PROJ=/nologo /D "_DEBUG" /win32 RSC=rc.exe # ADD BASE RSC /l 0x809 /d "_DEBUG" # ADD RSC /l 0x809 /d "_DEBUG" BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo BSC32_FLAGS=/nologo /o"$(OUTDIR)/gctest.bsc" BSC32_SBRS= \ ".\gctest\Debug\test.sbr" ".\gctest\Debug\gctest.bsc" : "$(OUTDIR)" $(BSC32_SBRS) $(BSC32) @<< $(BSC32_FLAGS) $(BSC32_SBRS) << LINK32=link.exe # ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /debug /machine:I386 # ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /incremental:no /map /debug /machine:I386 /out:"Debug/gctest.exe" LINK32_FLAGS=kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib\ advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib\ odbccp32.lib /nologo /subsystem:windows /incremental:no\ /pdb:"$(OUTDIR)/gctest.pdb" /map:"$(INTDIR)/gctest.map" /debug /machine:I386\ /out:"Debug/gctest.exe" LINK32_OBJS= \ ".\Debug\gc.lib" \ ".\gctest\Debug\test.obj" ".\Debug\gctest.exe" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS) $(LINK32) @<< $(LINK32_FLAGS) $(LINK32_OBJS) << !ELSEIF "$(CFG)" == "cord - Win32 Release" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 0 # PROP BASE Output_Dir "cord\Release" # PROP BASE Intermediate_Dir "cord\Release" # PROP BASE Target_Dir "cord" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 0 # PROP Output_Dir "cord\Release" # PROP Intermediate_Dir "cord\Release" # PROP Target_Dir "cord" OUTDIR=.\cord\Release INTDIR=.\cord\Release ALL : "gc - Win32 Release" ".\Release\de.exe" CLEAN : -@erase ".\cord\Release\cordbscs.obj" -@erase ".\cord\Release\cordxtra.obj" -@erase ".\cord\Release\de.obj" -@erase ".\cord\Release\de_win.obj" -@erase ".\cord\Release\de_win.res" -@erase ".\Release\de.exe" "$(OUTDIR)" : if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)" CPP=cl.exe # ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /c # ADD CPP /nologo /MD /W3 /GX /O2 /I "." /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "ALL_INTERIOR_POINTERS" /YX /c CPP_PROJ=/nologo /MD /W3 /GX /O2 /I "." /I include /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D\ /I./libatomic_ops/src "ALL_INTERIOR_POINTERS" /Fp"$(INTDIR)/cord.pch" /YX /Fo"$(INTDIR)/" /c CPP_OBJS=.\cord\Release/ CPP_SBRS=.\. .c{$(CPP_OBJS)}.obj: $(CPP) $(CPP_PROJ) $< .cpp{$(CPP_OBJS)}.obj: $(CPP) $(CPP_PROJ) $< .cxx{$(CPP_OBJS)}.obj: $(CPP) $(CPP_PROJ) $< .c{$(CPP_SBRS)}.sbr: $(CPP) $(CPP_PROJ) $< .cpp{$(CPP_SBRS)}.sbr: $(CPP) $(CPP_PROJ) $< .cxx{$(CPP_SBRS)}.sbr: $(CPP) $(CPP_PROJ) $< MTL=mktyplib.exe # ADD BASE MTL /nologo /D "NDEBUG" /win32 # ADD MTL /nologo /D "NDEBUG" /win32 MTL_PROJ=/nologo /D "NDEBUG" /win32 RSC=rc.exe # ADD BASE RSC /l 0x809 /d "NDEBUG" # ADD RSC /l 0x809 /d "NDEBUG" RSC_PROJ=/l 0x809 /fo"$(INTDIR)/de_win.res" /d "NDEBUG" BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo BSC32_FLAGS=/nologo /o"$(OUTDIR)/cord.bsc" BSC32_SBRS= \ LINK32=link.exe # ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386 # ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386 /out:"Release/de.exe" LINK32_FLAGS=kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib\ advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib\ odbccp32.lib /nologo /subsystem:windows /incremental:no /pdb:"$(OUTDIR)/de.pdb"\ /machine:I386 /out:"Release/de.exe" LINK32_OBJS= \ ".\cord\Release\cordbscs.obj" \ ".\cord\Release\cordxtra.obj" \ ".\cord\Release\de.obj" \ ".\cord\Release\de_win.obj" \ ".\cord\Release\de_win.res" \ ".\Release\gc.lib" ".\Release\de.exe" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS) $(LINK32) @<< $(LINK32_FLAGS) $(LINK32_OBJS) << !ELSEIF "$(CFG)" == "cord - Win32 Debug" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 1 # PROP BASE Output_Dir "cord\Debug" # PROP BASE Intermediate_Dir "cord\Debug" # PROP BASE Target_Dir "cord" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 1 # PROP Output_Dir "cord\Debug" # PROP Intermediate_Dir "cord\Debug" # PROP Target_Dir "cord" OUTDIR=.\cord\Debug INTDIR=.\cord\Debug ALL : "gc - Win32 Debug" ".\Debug\de.exe" CLEAN : -@erase ".\cord\Debug\cordbscs.obj" -@erase ".\cord\Debug\cordxtra.obj" -@erase ".\cord\Debug\de.obj" -@erase ".\cord\Debug\de.pdb" -@erase ".\cord\Debug\de_win.obj" -@erase ".\cord\Debug\de_win.res" -@erase ".\cord\Debug\vc40.idb" -@erase ".\cord\Debug\vc40.pdb" -@erase ".\Debug\de.exe" -@erase ".\Debug\de.ilk" "$(OUTDIR)" : if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)" CPP=cl.exe # ADD BASE CPP /nologo /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /c # ADD CPP /nologo /MDd /W3 /Gm /GX /Zi /Od /I "." /D "_DEBUG" /D "WIN32" /D "_WINDOWS" /D "ALL_INTERIOR_POINTERS" /YX /c CPP_PROJ=/nologo /MDd /W3 /Gm /GX /Zi /Od /I "." /I include /D "_DEBUG" /D "WIN32" /D\ "_WINDOWS" /D "ALL_INTERIOR_POINTERS" /Fp"$(INTDIR)/cord.pch" /YX\ /I./libatomic_ops/src /Fo"$(INTDIR)/" /Fd"$(INTDIR)/" /c CPP_OBJS=.\cord\Debug/ CPP_SBRS=.\. .c{$(CPP_OBJS)}.obj: $(CPP) $(CPP_PROJ) $< .cpp{$(CPP_OBJS)}.obj: $(CPP) $(CPP_PROJ) $< .cxx{$(CPP_OBJS)}.obj: $(CPP) $(CPP_PROJ) $< .c{$(CPP_SBRS)}.sbr: $(CPP) $(CPP_PROJ) $< .cpp{$(CPP_SBRS)}.sbr: $(CPP) $(CPP_PROJ) $< .cxx{$(CPP_SBRS)}.sbr: $(CPP) $(CPP_PROJ) $< MTL=mktyplib.exe # ADD BASE MTL /nologo /D "_DEBUG" /win32 # ADD MTL /nologo /D "_DEBUG" /win32 MTL_PROJ=/nologo /D "_DEBUG" /win32 RSC=rc.exe # ADD BASE RSC /l 0x809 /d "_DEBUG" # ADD RSC /l 0x809 /d "_DEBUG" RSC_PROJ=/l 0x809 /fo"$(INTDIR)/de_win.res" /d "_DEBUG" BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo BSC32_FLAGS=/nologo /o"$(OUTDIR)/cord.bsc" BSC32_SBRS= \ LINK32=link.exe # ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /debug /machine:I386 # ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /debug /machine:I386 /out:"Debug/de.exe" LINK32_FLAGS=kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib\ advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib\ odbccp32.lib /nologo /subsystem:windows /incremental:yes\ /pdb:"$(OUTDIR)/de.pdb" /debug /machine:I386 /out:"Debug/de.exe" LINK32_OBJS= \ ".\cord\Debug\cordbscs.obj" \ ".\cord\Debug\cordxtra.obj" \ ".\cord\Debug\de.obj" \ ".\cord\Debug\de_win.obj" \ ".\cord\Debug\de_win.res" \ ".\Debug\gc.lib" ".\Debug\de.exe" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS) $(LINK32) @<< $(LINK32_FLAGS) $(LINK32_OBJS) << !ENDIF ################################################################################ # Begin Target # Name "gc - Win32 Release" # Name "gc - Win32 Debug" !IF "$(CFG)" == "gc - Win32 Release" !ELSEIF "$(CFG)" == "gc - Win32 Debug" !ENDIF ################################################################################ # Begin Source File SOURCE=.\gc_cpp.cpp !IF "$(CFG)" == "gc - Win32 Release" DEP_CPP_RECLA=\ ".\include\private\gcconfig.h"\ ".\include\gc.h"\ ".\include\private\gc_hdrs.h"\ ".\include\private\gc_priv.h"\ ".\include\gc_cpp.h"\ {$(INCLUDE)}"\sys\TYPES.H"\ NODEP_CPP_RECLA=\ ".\th\PCR_Th.h"\ ".\th\PCR_ThCrSec.h"\ ".\th\PCR_ThCtl.h"\ ".\Release\gc_cpp.obj" : $(SOURCE) $(DEP_CPP_RECLA) "$(INTDIR)" ".\Release\gc_cpp.sbr" : $(SOURCE) $(DEP_CPP_RECLA) "$(INTDIR)" !ELSEIF "$(CFG)" == "gc - Win32 Debug" DEP_CPP_RECLA=\ ".\include\private\gcconfig.h"\ ".\include\gc.h"\ ".\include\private\gc_hdrs.h"\ ".\include\private\gc_priv.h"\ ".\include\gc_cpp.h"\ {$(INCLUDE)}"\sys\TYPES.H"\ NODEP_CPP_RECLA=\ ".\th\PCR_Th.h"\ ".\th\PCR_ThCrSec.h"\ ".\th\PCR_ThCtl.h"\ ".\Debug\gc_cpp.obj" : $(SOURCE) $(DEP_CPP_RECLA) "$(INTDIR)" ".\Debug\gc_cpp.sbr" : $(SOURCE) $(DEP_CPP_RECLA) "$(INTDIR)" !ENDIF # End Source File ################################################################################ # Begin Source File SOURCE=.\reclaim.c !IF "$(CFG)" == "gc - Win32 Release" DEP_CPP_RECLA=\ ".\include\private\gcconfig.h"\ ".\include\gc.h"\ ".\include\private\gc_hdrs.h"\ ".\include\private\gc_priv.h"\ {$(INCLUDE)}"\sys\TYPES.H"\ NODEP_CPP_RECLA=\ ".\th\PCR_Th.h"\ ".\th\PCR_ThCrSec.h"\ ".\th\PCR_ThCtl.h"\ ".\Release\reclaim.obj" : $(SOURCE) $(DEP_CPP_RECLA) "$(INTDIR)" ".\Release\reclaim.sbr" : $(SOURCE) $(DEP_CPP_RECLA) "$(INTDIR)" !ELSEIF "$(CFG)" == "gc - Win32 Debug" DEP_CPP_RECLA=\ ".\include\private\gcconfig.h"\ ".\include\gc.h"\ ".\include\private\gc_hdrs.h"\ ".\include\private\gc_priv.h"\ {$(INCLUDE)}"\sys\TYPES.H"\ NODEP_CPP_RECLA=\ ".\th\PCR_Th.h"\ ".\th\PCR_ThCrSec.h"\ ".\th\PCR_ThCtl.h"\ ".\Debug\reclaim.obj" : $(SOURCE) $(DEP_CPP_RECLA) "$(INTDIR)" ".\Debug\reclaim.sbr" : $(SOURCE) $(DEP_CPP_RECLA) "$(INTDIR)" !ENDIF # End Source File ################################################################################ # Begin Source File SOURCE=.\os_dep.c !IF "$(CFG)" == "gc - Win32 Release" DEP_CPP_OS_DE=\ ".\include\private\gcconfig.h"\ ".\include\gc.h"\ ".\include\private\gc_hdrs.h"\ ".\include\private\gc_priv.h"\ {$(INCLUDE)}"\sys\STAT.H"\ {$(INCLUDE)}"\sys\TYPES.H"\ NODEP_CPP_OS_DE=\ ".\il\PCR_IL.h"\ ".\mm\PCR_MM.h"\ ".\th\PCR_Th.h"\ ".\th\PCR_ThCrSec.h"\ ".\th\PCR_ThCtl.h"\ ".\vd\PCR_VD.h"\ ".\Release\os_dep.obj" : $(SOURCE) $(DEP_CPP_OS_DE) "$(INTDIR)" ".\Release\os_dep.sbr" : $(SOURCE) $(DEP_CPP_OS_DE) "$(INTDIR)" !ELSEIF "$(CFG)" == "gc - Win32 Debug" DEP_CPP_OS_DE=\ ".\include\private\gcconfig.h"\ ".\include\gc.h"\ ".\include\private\gc_hdrs.h"\ ".\include\private\gc_priv.h"\ {$(INCLUDE)}"\sys\STAT.H"\ {$(INCLUDE)}"\sys\TYPES.H"\ NODEP_CPP_OS_DE=\ ".\il\PCR_IL.h"\ ".\mm\PCR_MM.h"\ ".\th\PCR_Th.h"\ ".\th\PCR_ThCrSec.h"\ ".\th\PCR_ThCtl.h"\ ".\vd\PCR_VD.h"\ ".\Debug\os_dep.obj" : $(SOURCE) $(DEP_CPP_OS_DE) "$(INTDIR)" ".\Debug\os_dep.sbr" : $(SOURCE) $(DEP_CPP_OS_DE) "$(INTDIR)" !ENDIF # End Source File ################################################################################ # Begin Source File SOURCE=.\misc.c !IF "$(CFG)" == "gc - Win32 Release" DEP_CPP_MISC_=\ ".\include\private\gcconfig.h"\ ".\include\gc.h"\ ".\include\private\gc_hdrs.h"\ ".\include\private\gc_priv.h"\ {$(INCLUDE)}"\sys\TYPES.H"\ NODEP_CPP_MISC_=\ ".\il\PCR_IL.h"\ ".\th\PCR_Th.h"\ ".\th\PCR_ThCrSec.h"\ ".\th\PCR_ThCtl.h"\ ".\Release\misc.obj" : $(SOURCE) $(DEP_CPP_MISC_) "$(INTDIR)" ".\Release\misc.sbr" : $(SOURCE) $(DEP_CPP_MISC_) "$(INTDIR)" !ELSEIF "$(CFG)" == "gc - Win32 Debug" DEP_CPP_MISC_=\ ".\include\private\gcconfig.h"\ ".\include\gc.h"\ ".\include\private\gc_hdrs.h"\ ".\include\private\gc_priv.h"\ {$(INCLUDE)}"\sys\TYPES.H"\ NODEP_CPP_MISC_=\ ".\il\PCR_IL.h"\ ".\th\PCR_Th.h"\ ".\th\PCR_ThCrSec.h"\ ".\th\PCR_ThCtl.h"\ ".\Debug\misc.obj" : $(SOURCE) $(DEP_CPP_MISC_) "$(INTDIR)" ".\Debug\misc.sbr" : $(SOURCE) $(DEP_CPP_MISC_) "$(INTDIR)" !ENDIF # End Source File ################################################################################ # Begin Source File SOURCE=.\mark_rts.c !IF "$(CFG)" == "gc - Win32 Release" DEP_CPP_MARK_=\ ".\include\private\gcconfig.h"\ ".\include\gc.h"\ ".\include\private\gc_hdrs.h"\ ".\include\private\gc_priv.h"\ {$(INCLUDE)}"\sys\TYPES.H"\ NODEP_CPP_MARK_=\ ".\th\PCR_Th.h"\ ".\th\PCR_ThCrSec.h"\ ".\th\PCR_ThCtl.h"\ ".\Release\mark_rts.obj" : $(SOURCE) $(DEP_CPP_MARK_) "$(INTDIR)" ".\Release\mark_rts.sbr" : $(SOURCE) $(DEP_CPP_MARK_) "$(INTDIR)" !ELSEIF "$(CFG)" == "gc - Win32 Debug" DEP_CPP_MARK_=\ ".\include\private\gcconfig.h"\ ".\include\gc.h"\ ".\include\private\gc_hdrs.h"\ ".\include\private\gc_priv.h"\ {$(INCLUDE)}"\sys\TYPES.H"\ NODEP_CPP_MARK_=\ ".\th\PCR_Th.h"\ ".\th\PCR_ThCrSec.h"\ ".\th\PCR_ThCtl.h"\ ".\Debug\mark_rts.obj" : $(SOURCE) $(DEP_CPP_MARK_) "$(INTDIR)" ".\Debug\mark_rts.sbr" : $(SOURCE) $(DEP_CPP_MARK_) "$(INTDIR)" !ENDIF # End Source File ################################################################################ # Begin Source File SOURCE=.\mach_dep.c !IF "$(CFG)" == "gc - Win32 Release" DEP_CPP_MACH_=\ ".\include\private\gcconfig.h"\ ".\include\gc.h"\ ".\include\private\gc_hdrs.h"\ ".\include\private\gc_priv.h"\ {$(INCLUDE)}"\sys\TYPES.H"\ NODEP_CPP_MACH_=\ ".\th\PCR_Th.h"\ ".\th\PCR_ThCrSec.h"\ ".\th\PCR_ThCtl.h"\ ".\Release\mach_dep.obj" : $(SOURCE) $(DEP_CPP_MACH_) "$(INTDIR)" ".\Release\mach_dep.sbr" : $(SOURCE) $(DEP_CPP_MACH_) "$(INTDIR)" !ELSEIF "$(CFG)" == "gc - Win32 Debug" DEP_CPP_MACH_=\ ".\include\private\gcconfig.h"\ ".\include\gc.h"\ ".\include\private\gc_hdrs.h"\ ".\include\private\gc_priv.h"\ {$(INCLUDE)}"\sys\TYPES.H"\ NODEP_CPP_MACH_=\ ".\th\PCR_Th.h"\ ".\th\PCR_ThCrSec.h"\ ".\th\PCR_ThCtl.h"\ ".\Debug\mach_dep.obj" : $(SOURCE) $(DEP_CPP_MACH_) "$(INTDIR)" ".\Debug\mach_dep.sbr" : $(SOURCE) $(DEP_CPP_MACH_) "$(INTDIR)" !ENDIF # End Source File ################################################################################ # Begin Source File SOURCE=.\headers.c !IF "$(CFG)" == "gc - Win32 Release" DEP_CPP_HEADE=\ ".\include\private\gcconfig.h"\ ".\include\gc.h"\ ".\include\private\gc_hdrs.h"\ ".\include\private\gc_priv.h"\ {$(INCLUDE)}"\sys\TYPES.H"\ NODEP_CPP_HEADE=\ ".\th\PCR_Th.h"\ ".\th\PCR_ThCrSec.h"\ ".\th\PCR_ThCtl.h"\ ".\Release\headers.obj" : $(SOURCE) $(DEP_CPP_HEADE) "$(INTDIR)" ".\Release\headers.sbr" : $(SOURCE) $(DEP_CPP_HEADE) "$(INTDIR)" !ELSEIF "$(CFG)" == "gc - Win32 Debug" DEP_CPP_HEADE=\ ".\include\private\gcconfig.h"\ ".\include\gc.h"\ ".\include\private\gc_hdrs.h"\ ".\include\private\gc_priv.h"\ {$(INCLUDE)}"\sys\TYPES.H"\ NODEP_CPP_HEADE=\ ".\th\PCR_Th.h"\ ".\th\PCR_ThCrSec.h"\ ".\th\PCR_ThCtl.h"\ ".\Debug\headers.obj" : $(SOURCE) $(DEP_CPP_HEADE) "$(INTDIR)" ".\Debug\headers.sbr" : $(SOURCE) $(DEP_CPP_HEADE) "$(INTDIR)" !ENDIF # End Source File ################################################################################ # Begin Source File SOURCE=.\alloc.c !IF "$(CFG)" == "gc - Win32 Release" DEP_CPP_ALLOC=\ ".\include\private\gcconfig.h"\ ".\include\gc.h"\ ".\include\private\gc_hdrs.h"\ ".\include\private\gc_priv.h"\ {$(INCLUDE)}"\sys\TYPES.H"\ NODEP_CPP_ALLOC=\ ".\th\PCR_Th.h"\ ".\th\PCR_ThCrSec.h"\ ".\th\PCR_ThCtl.h"\ ".\Release\alloc.obj" : $(SOURCE) $(DEP_CPP_ALLOC) "$(INTDIR)" ".\Release\alloc.sbr" : $(SOURCE) $(DEP_CPP_ALLOC) "$(INTDIR)" !ELSEIF "$(CFG)" == "gc - Win32 Debug" DEP_CPP_ALLOC=\ ".\include\private\gcconfig.h"\ ".\include\gc.h"\ ".\include\private\gc_hdrs.h"\ ".\include\private\gc_priv.h"\ {$(INCLUDE)}"\sys\TYPES.H"\ NODEP_CPP_ALLOC=\ ".\th\PCR_Th.h"\ ".\th\PCR_ThCrSec.h"\ ".\th\PCR_ThCtl.h"\ ".\Debug\alloc.obj" : $(SOURCE) $(DEP_CPP_ALLOC) "$(INTDIR)" ".\Debug\alloc.sbr" : $(SOURCE) $(DEP_CPP_ALLOC) "$(INTDIR)" !ENDIF # End Source File ################################################################################ # Begin Source File SOURCE=.\allchblk.c !IF "$(CFG)" == "gc - Win32 Release" DEP_CPP_ALLCH=\ ".\include\private\gcconfig.h"\ ".\include\gc.h"\ ".\include\private\gc_hdrs.h"\ ".\include\private\gc_priv.h"\ {$(INCLUDE)}"\sys\TYPES.H"\ NODEP_CPP_ALLCH=\ ".\th\PCR_Th.h"\ ".\th\PCR_ThCrSec.h"\ ".\th\PCR_ThCtl.h"\ ".\Release\allchblk.obj" : $(SOURCE) $(DEP_CPP_ALLCH) "$(INTDIR)" ".\Release\allchblk.sbr" : $(SOURCE) $(DEP_CPP_ALLCH) "$(INTDIR)" !ELSEIF "$(CFG)" == "gc - Win32 Debug" DEP_CPP_ALLCH=\ ".\include\private\gcconfig.h"\ ".\include\gc.h"\ ".\include\private\gc_hdrs.h"\ ".\include\private\gc_priv.h"\ {$(INCLUDE)}"\sys\TYPES.H"\ NODEP_CPP_ALLCH=\ ".\th\PCR_Th.h"\ ".\th\PCR_ThCrSec.h"\ ".\th\PCR_ThCtl.h"\ ".\Debug\allchblk.obj" : $(SOURCE) $(DEP_CPP_ALLCH) "$(INTDIR)" ".\Debug\allchblk.sbr" : $(SOURCE) $(DEP_CPP_ALLCH) "$(INTDIR)" !ENDIF # End Source File ################################################################################ # Begin Source File SOURCE=.\stubborn.c !IF "$(CFG)" == "gc - Win32 Release" DEP_CPP_STUBB=\ ".\include\private\gcconfig.h"\ ".\include\gc.h"\ ".\include\private\gc_hdrs.h"\ ".\include\private\gc_priv.h"\ {$(INCLUDE)}"\sys\TYPES.H"\ NODEP_CPP_STUBB=\ ".\th\PCR_Th.h"\ ".\th\PCR_ThCrSec.h"\ ".\th\PCR_ThCtl.h"\ ".\Release\stubborn.obj" : $(SOURCE) $(DEP_CPP_STUBB) "$(INTDIR)" ".\Release\stubborn.sbr" : $(SOURCE) $(DEP_CPP_STUBB) "$(INTDIR)" !ELSEIF "$(CFG)" == "gc - Win32 Debug" DEP_CPP_STUBB=\ ".\include\private\gcconfig.h"\ ".\include\gc.h"\ ".\include\private\gc_hdrs.h"\ ".\include\private\gc_priv.h"\ {$(INCLUDE)}"\sys\TYPES.H"\ NODEP_CPP_STUBB=\ ".\th\PCR_Th.h"\ ".\th\PCR_ThCrSec.h"\ ".\th\PCR_ThCtl.h"\ ".\Debug\stubborn.obj" : $(SOURCE) $(DEP_CPP_STUBB) "$(INTDIR)" ".\Debug\stubborn.sbr" : $(SOURCE) $(DEP_CPP_STUBB) "$(INTDIR)" !ENDIF # End Source File ################################################################################ # Begin Source File SOURCE=.\obj_map.c !IF "$(CFG)" == "gc - Win32 Release" DEP_CPP_OBJ_M=\ ".\include\private\gcconfig.h"\ ".\include\gc.h"\ ".\include\private\gc_hdrs.h"\ ".\include\private\gc_priv.h"\ {$(INCLUDE)}"\sys\TYPES.H"\ NODEP_CPP_OBJ_M=\ ".\th\PCR_Th.h"\ ".\th\PCR_ThCrSec.h"\ ".\th\PCR_ThCtl.h"\ ".\Release\obj_map.obj" : $(SOURCE) $(DEP_CPP_OBJ_M) "$(INTDIR)" ".\Release\obj_map.sbr" : $(SOURCE) $(DEP_CPP_OBJ_M) "$(INTDIR)" !ELSEIF "$(CFG)" == "gc - Win32 Debug" DEP_CPP_OBJ_M=\ ".\include\private\gcconfig.h"\ ".\include\gc.h"\ ".\include\private\gc_hdrs.h"\ ".\include\private\gc_priv.h"\ {$(INCLUDE)}"\sys\TYPES.H"\ NODEP_CPP_OBJ_M=\ ".\th\PCR_Th.h"\ ".\th\PCR_ThCrSec.h"\ ".\th\PCR_ThCtl.h"\ ".\Debug\obj_map.obj" : $(SOURCE) $(DEP_CPP_OBJ_M) "$(INTDIR)" ".\Debug\obj_map.sbr" : $(SOURCE) $(DEP_CPP_OBJ_M) "$(INTDIR)" !ENDIF # End Source File ################################################################################ # Begin Source File SOURCE=.\new_hblk.c !IF "$(CFG)" == "gc - Win32 Release" DEP_CPP_NEW_H=\ ".\include\private\gcconfig.h"\ ".\include\gc.h"\ ".\include\private\gc_hdrs.h"\ ".\include\private\gc_priv.h"\ {$(INCLUDE)}"\sys\TYPES.H"\ NODEP_CPP_NEW_H=\ ".\th\PCR_Th.h"\ ".\th\PCR_ThCrSec.h"\ ".\th\PCR_ThCtl.h"\ ".\Release\new_hblk.obj" : $(SOURCE) $(DEP_CPP_NEW_H) "$(INTDIR)" ".\Release\new_hblk.sbr" : $(SOURCE) $(DEP_CPP_NEW_H) "$(INTDIR)" !ELSEIF "$(CFG)" == "gc - Win32 Debug" DEP_CPP_NEW_H=\ ".\include\private\gcconfig.h"\ ".\include\gc.h"\ ".\include\private\gc_hdrs.h"\ ".\include\private\gc_priv.h"\ {$(INCLUDE)}"\sys\TYPES.H"\ NODEP_CPP_NEW_H=\ ".\th\PCR_Th.h"\ ".\th\PCR_ThCrSec.h"\ ".\th\PCR_ThCtl.h"\ ".\Debug\new_hblk.obj" : $(SOURCE) $(DEP_CPP_NEW_H) "$(INTDIR)" ".\Debug\new_hblk.sbr" : $(SOURCE) $(DEP_CPP_NEW_H) "$(INTDIR)" !ENDIF # End Source File ################################################################################ # Begin Source File SOURCE=.\mark.c !IF "$(CFG)" == "gc - Win32 Release" DEP_CPP_MARK_C=\ ".\include\private\gcconfig.h"\ ".\include\gc.h"\ ".\include\private\gc_hdrs.h"\ ".\include\private\gc_pmark.h"\ ".\include\gc_mark.h"\ ".\include\gc_disclaim.h"\ ".\include\private\gc_priv.h"\ {$(INCLUDE)}"\sys\TYPES.H"\ NODEP_CPP_MARK_C=\ ".\th\PCR_Th.h"\ ".\th\PCR_ThCrSec.h"\ ".\th\PCR_ThCtl.h"\ ".\Release\mark.obj" : $(SOURCE) $(DEP_CPP_MARK_C) "$(INTDIR)" ".\Release\mark.sbr" : $(SOURCE) $(DEP_CPP_MARK_C) "$(INTDIR)" !ELSEIF "$(CFG)" == "gc - Win32 Debug" DEP_CPP_MARK_C=\ ".\include\private\gcconfig.h"\ ".\include\gc.h"\ ".\include\private\gc_hdrs.h"\ ".\include\private\gc_pmark.h"\ ".\include\gc_mark.h"\ ".\include\gc_disclaim.h"\ ".\include\private\gc_priv.h"\ {$(INCLUDE)}"\sys\TYPES.H"\ NODEP_CPP_MARK_C=\ ".\th\PCR_Th.h"\ ".\th\PCR_ThCrSec.h"\ ".\th\PCR_ThCtl.h"\ ".\Debug\mark.obj" : $(SOURCE) $(DEP_CPP_MARK_C) "$(INTDIR)" ".\Debug\mark.sbr" : $(SOURCE) $(DEP_CPP_MARK_C) "$(INTDIR)" !ENDIF # End Source File ################################################################################ # Begin Source File SOURCE=.\malloc.c !IF "$(CFG)" == "gc - Win32 Release" DEP_CPP_MALLO=\ ".\include\private\gcconfig.h"\ ".\include\gc.h"\ ".\include\private\gc_hdrs.h"\ ".\include\private\gc_priv.h"\ {$(INCLUDE)}"\sys\TYPES.H"\ NODEP_CPP_MALLO=\ ".\th\PCR_Th.h"\ ".\th\PCR_ThCrSec.h"\ ".\th\PCR_ThCtl.h"\ ".\Release\malloc.obj" : $(SOURCE) $(DEP_CPP_MALLO) "$(INTDIR)" ".\Release\malloc.sbr" : $(SOURCE) $(DEP_CPP_MALLO) "$(INTDIR)" !ELSEIF "$(CFG)" == "gc - Win32 Debug" DEP_CPP_MALLO=\ ".\include\private\gcconfig.h"\ ".\include\gc.h"\ ".\include\private\gc_hdrs.h"\ ".\include\private\gc_priv.h"\ {$(INCLUDE)}"\sys\TYPES.H"\ NODEP_CPP_MALLO=\ ".\th\PCR_Th.h"\ ".\th\PCR_ThCrSec.h"\ ".\th\PCR_ThCtl.h"\ ".\Debug\malloc.obj" : $(SOURCE) $(DEP_CPP_MALLO) "$(INTDIR)" ".\Debug\malloc.sbr" : $(SOURCE) $(DEP_CPP_MALLO) "$(INTDIR)" !ENDIF # End Source File ################################################################################ # Begin Source File SOURCE=.\mallocx.c !IF "$(CFG)" == "gc - Win32 Release" DEP_CPP_MALLX=\ ".\include\private\gcconfig.h"\ ".\include\gc.h"\ ".\include\private\gc_hdrs.h"\ ".\include\private\gc_priv.h"\ {$(INCLUDE)}"\sys\TYPES.H"\ NODEP_CPP_MALLX=\ ".\th\PCR_Th.h"\ ".\th\PCR_ThCrSec.h"\ ".\th\PCR_ThCtl.h"\ ".\Release\mallocx.obj" : $(SOURCE) $(DEP_CPP_MALLX) "$(INTDIR)" ".\Release\mallocx.sbr" : $(SOURCE) $(DEP_CPP_MALLX) "$(INTDIR)" !ELSEIF "$(CFG)" == "gc - Win32 Debug" DEP_CPP_MALLX=\ ".\include\private\gcconfig.h"\ ".\include\gc.h"\ ".\include\private\gc_hdrs.h"\ ".\include\private\gc_priv.h"\ {$(INCLUDE)}"\sys\TYPES.H"\ NODEP_CPP_MALLX=\ ".\th\PCR_Th.h"\ ".\th\PCR_ThCrSec.h"\ ".\th\PCR_ThCtl.h"\ ".\Debug\mallocx.obj" : $(SOURCE) $(DEP_CPP_MALLX) "$(INTDIR)" ".\Debug\mallocx.sbr" : $(SOURCE) $(DEP_CPP_MALLX) "$(INTDIR)" !ENDIF # End Source File ################################################################################ # Begin Source File SOURCE=.\finalize.c !IF "$(CFG)" == "gc - Win32 Release" DEP_CPP_FINAL=\ ".\include\private\gcconfig.h"\ ".\include\gc.h"\ ".\include\private\gc_hdrs.h"\ ".\include\private\gc_pmark.h"\ ".\include\gc_mark.h"\ ".\include\gc_disclaim.h"\ ".\include\private\gc_priv.h"\ {$(INCLUDE)}"\sys\TYPES.H"\ NODEP_CPP_FINAL=\ ".\th\PCR_Th.h"\ ".\th\PCR_ThCrSec.h"\ ".\th\PCR_ThCtl.h"\ ".\Release\finalize.obj" : $(SOURCE) $(DEP_CPP_FINAL) "$(INTDIR)" ".\Release\finalize.sbr" : $(SOURCE) $(DEP_CPP_FINAL) "$(INTDIR)" !ELSEIF "$(CFG)" == "gc - Win32 Debug" DEP_CPP_FINAL=\ ".\include\private\gcconfig.h"\ ".\include\gc.h"\ ".\include\private\gc_hdrs.h"\ ".\include\private\gc_pmark.h"\ ".\include\gc_mark.h"\ ".\include\gc_disclaim.h"\ ".\include\private\gc_priv.h"\ {$(INCLUDE)}"\sys\TYPES.H"\ NODEP_CPP_FINAL=\ ".\th\PCR_Th.h"\ ".\th\PCR_ThCrSec.h"\ ".\th\PCR_ThCtl.h"\ ".\Debug\finalize.obj" : $(SOURCE) $(DEP_CPP_FINAL) "$(INTDIR)" ".\Debug\finalize.sbr" : $(SOURCE) $(DEP_CPP_FINAL) "$(INTDIR)" !ENDIF # End Source File ################################################################################ # Begin Source File SOURCE=.\dbg_mlc.c !IF "$(CFG)" == "gc - Win32 Release" DEP_CPP_DBG_M=\ ".\include\private\gcconfig.h"\ ".\include\gc.h"\ ".\include\private\gc_hdrs.h"\ ".\include\private\gc_priv.h"\ {$(INCLUDE)}"\sys\TYPES.H"\ NODEP_CPP_DBG_M=\ ".\th\PCR_Th.h"\ ".\th\PCR_ThCrSec.h"\ ".\th\PCR_ThCtl.h"\ ".\Release\dbg_mlc.obj" : $(SOURCE) $(DEP_CPP_DBG_M) "$(INTDIR)" ".\Release\dbg_mlc.sbr" : $(SOURCE) $(DEP_CPP_DBG_M) "$(INTDIR)" !ELSEIF "$(CFG)" == "gc - Win32 Debug" DEP_CPP_DBG_M=\ ".\include\private\gcconfig.h"\ ".\include\gc.h"\ ".\include\private\gc_hdrs.h"\ ".\include\private\gc_priv.h"\ {$(INCLUDE)}"\sys\TYPES.H"\ NODEP_CPP_DBG_M=\ ".\th\PCR_Th.h"\ ".\th\PCR_ThCrSec.h"\ ".\th\PCR_ThCtl.h"\ ".\Debug\dbg_mlc.obj" : $(SOURCE) $(DEP_CPP_DBG_M) "$(INTDIR)" ".\Debug\dbg_mlc.sbr" : $(SOURCE) $(DEP_CPP_DBG_M) "$(INTDIR)" !ENDIF # End Source File ################################################################################ # Begin Source File SOURCE=.\fnlz_mlc.c !IF "$(CFG)" == "gc - Win32 Release" DEP_CPP_DBG_M=\ ".\include\private\gcconfig.h"\ ".\include\gc.h"\ ".\include\private\gc_hdrs.h"\ ".\include\private\gc_priv.h"\ {$(INCLUDE)}"\sys\TYPES.H"\ NODEP_CPP_DBG_M=\ ".\th\PCR_Th.h"\ ".\th\PCR_ThCrSec.h"\ ".\th\PCR_ThCtl.h"\ ".\Release\fnlz_mlc.obj" : $(SOURCE) $(DEP_CPP_DBG_M) "$(INTDIR)" ".\Release\fnlz_mlc.sbr" : $(SOURCE) $(DEP_CPP_DBG_M) "$(INTDIR)" !ELSEIF "$(CFG)" == "gc - Win32 Debug" DEP_CPP_DBG_M=\ ".\include\private\gcconfig.h"\ ".\include\gc.h"\ ".\include\private\gc_hdrs.h"\ ".\include\private\gc_priv.h"\ {$(INCLUDE)}"\sys\TYPES.H"\ NODEP_CPP_DBG_M=\ ".\th\PCR_Th.h"\ ".\th\PCR_ThCrSec.h"\ ".\th\PCR_ThCtl.h"\ ".\Debug\fnlz_mlc.obj" : $(SOURCE) $(DEP_CPP_DBG_M) "$(INTDIR)" ".\Debug\fnlz_mlc.sbr" : $(SOURCE) $(DEP_CPP_DBG_M) "$(INTDIR)" !ENDIF # End Source File ################################################################################ # Begin Source File SOURCE=.\blacklst.c !IF "$(CFG)" == "gc - Win32 Release" DEP_CPP_BLACK=\ ".\include\private\gcconfig.h"\ ".\include\gc.h"\ ".\include\private\gc_hdrs.h"\ ".\include\private\gc_priv.h"\ {$(INCLUDE)}"\sys\TYPES.H"\ NODEP_CPP_BLACK=\ ".\th\PCR_Th.h"\ ".\th\PCR_ThCrSec.h"\ ".\th\PCR_ThCtl.h"\ ".\Release\blacklst.obj" : $(SOURCE) $(DEP_CPP_BLACK) "$(INTDIR)" ".\Release\blacklst.sbr" : $(SOURCE) $(DEP_CPP_BLACK) "$(INTDIR)" !ELSEIF "$(CFG)" == "gc - Win32 Debug" DEP_CPP_BLACK=\ ".\include\private\gcconfig.h"\ ".\include\gc.h"\ ".\include\private\gc_hdrs.h"\ ".\include\private\gc_priv.h"\ {$(INCLUDE)}"\sys\TYPES.H"\ NODEP_CPP_BLACK=\ ".\th\PCR_Th.h"\ ".\th\PCR_ThCrSec.h"\ ".\th\PCR_ThCtl.h"\ ".\Debug\blacklst.obj" : $(SOURCE) $(DEP_CPP_BLACK) "$(INTDIR)" ".\Debug\blacklst.sbr" : $(SOURCE) $(DEP_CPP_BLACK) "$(INTDIR)" !ENDIF # End Source File ################################################################################ # Begin Source File SOURCE=.\typd_mlc.c !IF "$(CFG)" == "gc - Win32 Release" DEP_CPP_TYPD_=\ ".\include\private\gcconfig.h"\ ".\include\gc.h"\ ".\include\private\gc_hdrs.h"\ ".\include\private\gc_pmark.h"\ ".\include\gc_mark.h"\ ".\include\gc_disclaim.h"\ ".\include\private\gc_priv.h"\ ".\include\gc_typed.h"\ {$(INCLUDE)}"\sys\TYPES.H"\ NODEP_CPP_TYPD_=\ ".\th\PCR_Th.h"\ ".\th\PCR_ThCrSec.h"\ ".\th\PCR_ThCtl.h"\ ".\Release\typd_mlc.obj" : $(SOURCE) $(DEP_CPP_TYPD_) "$(INTDIR)" ".\Release\typd_mlc.sbr" : $(SOURCE) $(DEP_CPP_TYPD_) "$(INTDIR)" !ELSEIF "$(CFG)" == "gc - Win32 Debug" DEP_CPP_TYPD_=\ ".\include\private\gcconfig.h"\ ".\include\gc.h"\ ".\include\private\gc_hdrs.h"\ ".\include\private\gc_pmark.h"\ ".\include\gc_mark.h"\ ".\include\gc_disclaim.h"\ ".\include\private\gc_priv.h"\ ".\include\gc_typed.h"\ {$(INCLUDE)}"\sys\TYPES.H"\ NODEP_CPP_TYPD_=\ ".\th\PCR_Th.h"\ ".\th\PCR_ThCrSec.h"\ ".\th\PCR_ThCtl.h"\ ".\Debug\typd_mlc.obj" : $(SOURCE) $(DEP_CPP_TYPD_) "$(INTDIR)" ".\Debug\typd_mlc.sbr" : $(SOURCE) $(DEP_CPP_TYPD_) "$(INTDIR)" !ENDIF # End Source File ################################################################################ # Begin Source File SOURCE=.\ptr_chck.c !IF "$(CFG)" == "gc - Win32 Release" DEP_CPP_PTR_C=\ ".\include\private\gcconfig.h"\ ".\include\gc.h"\ ".\include\private\gc_hdrs.h"\ ".\include\private\gc_pmark.h"\ ".\include\gc_mark.h"\ ".\include\gc_disclaim.h"\ ".\include\private\gc_priv.h"\ {$(INCLUDE)}"\sys\TYPES.H"\ NODEP_CPP_PTR_C=\ ".\th\PCR_Th.h"\ ".\th\PCR_ThCrSec.h"\ ".\th\PCR_ThCtl.h"\ ".\Release\ptr_chck.obj" : $(SOURCE) $(DEP_CPP_PTR_C) "$(INTDIR)" ".\Release\ptr_chck.sbr" : $(SOURCE) $(DEP_CPP_PTR_C) "$(INTDIR)" !ELSEIF "$(CFG)" == "gc - Win32 Debug" DEP_CPP_PTR_C=\ ".\include\private\gcconfig.h"\ ".\include\gc.h"\ ".\include\private\gc_hdrs.h"\ ".\include\private\gc_pmark.h"\ ".\include\gc_mark.h"\ ".\include\gc_disclaim.h"\ ".\include\private\gc_priv.h"\ {$(INCLUDE)}"\sys\TYPES.H"\ NODEP_CPP_PTR_C=\ ".\th\PCR_Th.h"\ ".\th\PCR_ThCrSec.h"\ ".\th\PCR_ThCtl.h"\ ".\Debug\ptr_chck.obj" : $(SOURCE) $(DEP_CPP_PTR_C) "$(INTDIR)" ".\Debug\ptr_chck.sbr" : $(SOURCE) $(DEP_CPP_PTR_C) "$(INTDIR)" !ENDIF # End Source File ################################################################################ # Begin Source File SOURCE=.\dyn_load.c !IF "$(CFG)" == "gc - Win32 Release" DEP_CPP_DYN_L=\ ".\include\private\gcconfig.h"\ ".\include\gc.h"\ ".\include\private\gc_hdrs.h"\ ".\include\private\gc_priv.h"\ {$(INCLUDE)}"\sys\STAT.H"\ {$(INCLUDE)}"\sys\TYPES.H"\ NODEP_CPP_DYN_L=\ ".\il\PCR_IL.h"\ ".\mm\PCR_MM.h"\ ".\th\PCR_Th.h"\ ".\th\PCR_ThCrSec.h"\ ".\th\PCR_ThCtl.h"\ ".\Release\dyn_load.obj" : $(SOURCE) $(DEP_CPP_DYN_L) "$(INTDIR)" ".\Release\dyn_load.sbr" : $(SOURCE) $(DEP_CPP_DYN_L) "$(INTDIR)" !ELSEIF "$(CFG)" == "gc - Win32 Debug" DEP_CPP_DYN_L=\ ".\include\private\gcconfig.h"\ ".\include\gc.h"\ ".\include\private\gc_hdrs.h"\ ".\include\private\gc_priv.h"\ {$(INCLUDE)}"\sys\STAT.H"\ {$(INCLUDE)}"\sys\TYPES.H"\ NODEP_CPP_DYN_L=\ ".\il\PCR_IL.h"\ ".\mm\PCR_MM.h"\ ".\th\PCR_Th.h"\ ".\th\PCR_ThCrSec.h"\ ".\th\PCR_ThCtl.h"\ ".\Debug\dyn_load.obj" : $(SOURCE) $(DEP_CPP_DYN_L) "$(INTDIR)" ".\Debug\dyn_load.sbr" : $(SOURCE) $(DEP_CPP_DYN_L) "$(INTDIR)" !ENDIF # End Source File ################################################################################ # Begin Source File SOURCE=.\win32_threads.c !IF "$(CFG)" == "gc - Win32 Release" DEP_CPP_WIN32=\ ".\include\private\gcconfig.h"\ ".\include\gc.h"\ ".\include\private\gc_hdrs.h"\ ".\include\private\gc_priv.h"\ {$(INCLUDE)}"\sys\TYPES.H"\ NODEP_CPP_WIN32=\ ".\th\PCR_Th.h"\ ".\th\PCR_ThCrSec.h"\ ".\th\PCR_ThCtl.h"\ ".\Release\win32_threads.obj" : $(SOURCE) $(DEP_CPP_WIN32) "$(INTDIR)" ".\Release\win32_threads.sbr" : $(SOURCE) $(DEP_CPP_WIN32) "$(INTDIR)" !ELSEIF "$(CFG)" == "gc - Win32 Debug" DEP_CPP_WIN32=\ ".\include\private\gcconfig.h"\ ".\include\gc.h"\ ".\include\private\gc_hdrs.h"\ ".\include\private\gc_priv.h"\ {$(INCLUDE)}"\sys\TYPES.H"\ NODEP_CPP_WIN32=\ ".\th\PCR_Th.h"\ ".\th\PCR_ThCrSec.h"\ ".\th\PCR_ThCtl.h"\ ".\Debug\win32_threads.obj" : $(SOURCE) $(DEP_CPP_WIN32) "$(INTDIR)" ".\Debug\win32_threads.sbr" : $(SOURCE) $(DEP_CPP_WIN32) "$(INTDIR)" !ENDIF # End Source File ################################################################################ # Begin Source File SOURCE=.\extra\msvc_dbg.c !IF "$(CFG)" == "gc - Win32 Release" DEP_CPP_WIN32=\ ".\include\private\gcconfig.h"\ ".\include\gc.h"\ ".\include\private\gc_hdrs.h"\ ".\include\private\gc_priv.h"\ ".\include\private\msvc_dbg.h"\ {$(INCLUDE)}"\sys\TYPES.H"\ NODEP_CPP_WIN32=\ ".\th\PCR_Th.h"\ ".\th\PCR_ThCrSec.h"\ ".\th\PCR_ThCtl.h"\ ".\Release\msvc_dbg.obj" : $(SOURCE) $(DEP_CPP_WIN32) "$(INTDIR)" ".\Release\msvc_dbg.sbr" : $(SOURCE) $(DEP_CPP_WIN32) "$(INTDIR)" !ELSEIF "$(CFG)" == "gc - Win32 Debug" DEP_CPP_WIN32=\ ".\include\private\gcconfig.h"\ ".\include\gc.h"\ ".\include\private\gc_hdrs.h"\ ".\include\private\gc_priv.h"\ ".\include\private\msvc_dbg.h"\ {$(INCLUDE)}"\sys\TYPES.H"\ NODEP_CPP_WIN32=\ ".\th\PCR_Th.h"\ ".\th\PCR_ThCrSec.h"\ ".\th\PCR_ThCtl.h"\ ".\Debug\msvc_dbg.obj" : $(SOURCE) $(DEP_CPP_WIN32) "$(INTDIR)" ".\Debug\msvc_dbg.sbr" : $(SOURCE) $(DEP_CPP_WIN32) "$(INTDIR)" !ENDIF # End Source File ################################################################################ # Begin Source File SOURCE=.\checksums.c !IF "$(CFG)" == "gc - Win32 Release" DEP_CPP_CHECK=\ ".\include\private\gcconfig.h"\ ".\include\gc.h"\ ".\include\private\gc_hdrs.h"\ ".\include\private\gc_priv.h"\ {$(INCLUDE)}"\sys\TYPES.H"\ NODEP_CPP_CHECK=\ ".\th\PCR_Th.h"\ ".\th\PCR_ThCrSec.h"\ ".\th\PCR_ThCtl.h"\ ".\Release\checksums.obj" : $(SOURCE) $(DEP_CPP_CHECK) "$(INTDIR)" ".\Release\checksums.sbr" : $(SOURCE) $(DEP_CPP_CHECK) "$(INTDIR)" !ELSEIF "$(CFG)" == "gc - Win32 Debug" DEP_CPP_CHECK=\ ".\include\private\gcconfig.h"\ ".\include\gc.h"\ ".\include\private\gc_hdrs.h"\ ".\include\private\gc_priv.h"\ {$(INCLUDE)}"\sys\TYPES.H"\ NODEP_CPP_CHECK=\ ".\th\PCR_Th.h"\ ".\th\PCR_ThCrSec.h"\ ".\th\PCR_ThCtl.h"\ ".\Debug\checksums.obj" : $(SOURCE) $(DEP_CPP_CHECK) "$(INTDIR)" ".\Debug\checksums.sbr" : $(SOURCE) $(DEP_CPP_CHECK) "$(INTDIR)" !ENDIF # End Source File # End Target ################################################################################ # Begin Target # Name "gctest - Win32 Release" # Name "gctest - Win32 Debug" !IF "$(CFG)" == "gctest - Win32 Release" !ELSEIF "$(CFG)" == "gctest - Win32 Debug" !ENDIF ################################################################################ # Begin Project Dependency # Project_Dep_Name "gc" !IF "$(CFG)" == "gctest - Win32 Release" "gc - Win32 Release" : $(MAKE) /$(MAKEFLAGS) /F ".\gc.mak" CFG="gc - Win32 Release" !ELSEIF "$(CFG)" == "gctest - Win32 Debug" "gc - Win32 Debug" : $(MAKE) /$(MAKEFLAGS) /F ".\gc.mak" CFG="gc - Win32 Debug" !ENDIF # End Project Dependency ################################################################################ # Begin Source File SOURCE=.\tests\test.c DEP_CPP_TEST_=\ ".\include\private\gcconfig.h"\ ".\include\gc.h"\ ".\include\private\gc_hdrs.h"\ ".\include\private\gc_priv.h"\ ".\include\gc_typed.h"\ {$(INCLUDE)}"\sys\TYPES.H"\ NODEP_CPP_TEST_=\ ".\th\PCR_Th.h"\ ".\th\PCR_ThCrSec.h"\ ".\th\PCR_ThCtl.h"\ !IF "$(CFG)" == "gctest - Win32 Release" ".\gctest\Release\test.obj" : $(SOURCE) $(DEP_CPP_TEST_) "$(INTDIR)" !ELSEIF "$(CFG)" == "gctest - Win32 Debug" ".\gctest\Debug\test.obj" : $(SOURCE) $(DEP_CPP_TEST_) "$(INTDIR)" ".\gctest\Debug\test.sbr" : $(SOURCE) $(DEP_CPP_TEST_) "$(INTDIR)" !ENDIF # End Source File # End Target ################################################################################ # Begin Target # Name "cord - Win32 Release" # Name "cord - Win32 Debug" !IF "$(CFG)" == "cord - Win32 Release" !ELSEIF "$(CFG)" == "cord - Win32 Debug" !ENDIF ################################################################################ # Begin Project Dependency # Project_Dep_Name "gc" !IF "$(CFG)" == "cord - Win32 Release" "gc - Win32 Release" : $(MAKE) /$(MAKEFLAGS) /F ".\gc.mak" CFG="gc - Win32 Release" !ELSEIF "$(CFG)" == "cord - Win32 Debug" "gc - Win32 Debug" : $(MAKE) /$(MAKEFLAGS) /F ".\gc.mak" CFG="gc - Win32 Debug" !ENDIF # End Project Dependency ################################################################################ # Begin Source File SOURCE=.\cord\tests\de_win.c DEP_CPP_DE_WI=\ ".\include\cord.h"\ ".\cord\tests\de_cmds.h"\ ".\cord\tests\de_win.h"\ ".\include\cord_pos.h"\ NODEP_CPP_DE_WI=\ ".\include\gc.h"\ !IF "$(CFG)" == "cord - Win32 Release" ".\cord\Release\de_win.obj" : $(SOURCE) $(DEP_CPP_DE_WI) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) !ELSEIF "$(CFG)" == "cord - Win32 Debug" ".\cord\Debug\de_win.obj" : $(SOURCE) $(DEP_CPP_DE_WI) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) !ENDIF # End Source File ################################################################################ # Begin Source File SOURCE=.\cord\tests\de.c DEP_CPP_DE_C2e=\ ".\include\cord.h"\ ".\cord\tests\de_cmds.h"\ ".\cord\tests\de_win.h"\ ".\include\cord_pos.h"\ NODEP_CPP_DE_C2e=\ ".\include\gc.h"\ !IF "$(CFG)" == "cord - Win32 Release" ".\cord\Release\de.obj" : $(SOURCE) $(DEP_CPP_DE_C2e) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) !ELSEIF "$(CFG)" == "cord - Win32 Debug" ".\cord\Debug\de.obj" : $(SOURCE) $(DEP_CPP_DE_C2e) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) !ENDIF # End Source File ################################################################################ # Begin Source File SOURCE=.\cord\cordxtra.c DEP_CPP_CORDX=\ ".\include\cord.h"\ ".\include\ec.h"\ ".\include\cord_pos.h"\ NODEP_CPP_CORDX=\ ".\include\gc.h"\ !IF "$(CFG)" == "cord - Win32 Release" ".\cord\Release\cordxtra.obj" : $(SOURCE) $(DEP_CPP_CORDX) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) !ELSEIF "$(CFG)" == "cord - Win32 Debug" ".\cord\Debug\cordxtra.obj" : $(SOURCE) $(DEP_CPP_CORDX) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) !ENDIF # End Source File ################################################################################ # Begin Source File SOURCE=.\cord\cordbscs.c DEP_CPP_CORDB=\ ".\include\cord.h"\ ".\include\cord_pos.h"\ NODEP_CPP_CORDB=\ ".\include\gc.h"\ !IF "$(CFG)" == "cord - Win32 Release" ".\cord\Release\cordbscs.obj" : $(SOURCE) $(DEP_CPP_CORDB) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) !ELSEIF "$(CFG)" == "cord - Win32 Debug" ".\cord\Debug\cordbscs.obj" : $(SOURCE) $(DEP_CPP_CORDB) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) !ENDIF # End Source File ################################################################################ # Begin Source File SOURCE=.\cord\tests\de_win.rc !IF "$(CFG)" == "cord - Win32 Release" ".\cord\Release\de_win.res" : $(SOURCE) "$(INTDIR)" $(RSC) /l 0x809 /fo"$(INTDIR)/de_win.res" /i "cord" /d "NDEBUG" $(SOURCE) !ELSEIF "$(CFG)" == "cord - Win32 Debug" ".\cord\Debug\de_win.res" : $(SOURCE) "$(INTDIR)" $(RSC) /l 0x809 /fo"$(INTDIR)/de_win.res" /i "cord" /d "_DEBUG" $(SOURCE) !ENDIF # End Source File # End Target # End Project ################################################################################ ecl-16.1.2/src/bdwgc/gc_cpp.cc000066400000000000000000000051401266352375300157770ustar00rootroot00000000000000/* * Copyright (c) 1994 by Xerox Corporation. All rights reserved. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to copy this code for any purpose, * provided the above notices are retained on all copies. */ /************************************************************************* This implementation module for gc_c++.h provides an implementation of the global operators "new" and "delete" that calls the Boehm allocator. All objects allocated by this implementation will be uncollectible but part of the root set of the collector. You should ensure (using implementation-dependent techniques) that the linker finds this module before the library that defines the default built-in "new" and "delete". **************************************************************************/ #ifdef HAVE_CONFIG_H # include "config.h" #endif #ifndef GC_BUILD # define GC_BUILD #endif #include "gc_cpp.h" #if !defined(GC_NEW_DELETE_NEED_THROW) && defined(__GNUC__) \ && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)) # define GC_NEW_DELETE_NEED_THROW #endif #ifdef GC_NEW_DELETE_NEED_THROW # include /* for std::bad_alloc */ # define GC_DECL_NEW_THROW throw(std::bad_alloc) # define GC_DECL_DELETE_THROW throw() #else # define GC_DECL_NEW_THROW /* empty */ # define GC_DECL_DELETE_THROW /* empty */ #endif /* !GC_NEW_DELETE_NEED_THROW */ void* operator new( size_t size ) GC_DECL_NEW_THROW { return GC_MALLOC_UNCOLLECTABLE(size); } #if !defined(__CYGWIN__) void operator delete( void* obj ) GC_DECL_DELETE_THROW { GC_FREE(obj); } #endif /* !__CYGWIN__ */ #ifdef GC_OPERATOR_NEW_ARRAY void* operator new[]( size_t size ) GC_DECL_NEW_THROW { return GC_MALLOC_UNCOLLECTABLE(size); } void operator delete[]( void* obj ) GC_DECL_DELETE_THROW { GC_FREE(obj); } #endif /* GC_OPERATOR_NEW_ARRAY */ #ifdef _MSC_VER // This new operator is used by VC++ in case of Debug builds! void* operator new( size_t size, int /* nBlockUse */, const char * szFileName, int nLine ) GC_DECL_NEW_THROW { # ifndef GC_DEBUG return GC_malloc_uncollectable(size); # else return GC_debug_malloc_uncollectable(size, szFileName, nLine); # endif } # if _MSC_VER > 1020 // This new operator is used by VC++ 7.0 and later in Debug builds. void* operator new[]( size_t size, int nBlockUse, const char* szFileName, int nLine ) GC_DECL_NEW_THROW { return operator new(size, nBlockUse, szFileName, nLine); } # endif #endif /* _MSC_VER */ ecl-16.1.2/src/bdwgc/gc_cpp.cpp000066400000000000000000000001131266352375300161670ustar00rootroot00000000000000// Visual C++ seems to prefer a .cpp extension to .cc #include "gc_cpp.cc" ecl-16.1.2/src/bdwgc/gc_dlopen.c000066400000000000000000000074461266352375300163460ustar00rootroot00000000000000/* * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. * Copyright (c) 1997 by Silicon Graphics. All rights reserved. * Copyright (c) 2000 by Hewlett-Packard Company. All rights reserved. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. */ #include "private/gc_priv.h" /* This used to be in dyn_load.c. It was extracted into a separate */ /* file to avoid having to link against libdl.{a,so} if the client */ /* doesn't call dlopen. Of course this fails if the collector is in */ /* a dynamic library. -HB */ #if defined(GC_PTHREADS) && !defined(GC_NO_DLOPEN) #undef GC_MUST_RESTORE_REDEFINED_DLOPEN #if defined(dlopen) && !defined(GC_USE_LD_WRAP) /* To support various threads pkgs, gc.h interposes on dlopen by */ /* defining "dlopen" to be "GC_dlopen", which is implemented below. */ /* However, both GC_FirstDLOpenedLinkMap() and GC_dlopen() use the */ /* real system dlopen() in their implementation. We first remove */ /* gc.h's dlopen definition and restore it later, after GC_dlopen(). */ # undef dlopen # define GC_MUST_RESTORE_REDEFINED_DLOPEN #endif /* Make sure we're not in the middle of a collection, and make sure we */ /* don't start any. This is invoked prior to a dlopen call to avoid */ /* synchronization issues. We can't just acquire the allocation lock, */ /* since startup code in dlopen may try to allocate. This solution */ /* risks heap growth (or, even, heap overflow) in the presence of many */ /* dlopen calls in either a multi-threaded environment, or if the */ /* library initialization code allocates substantial amounts of GC'ed */ /* memory. */ #ifndef USE_PROC_FOR_LIBRARIES static void disable_gc_for_dlopen(void) { DCL_LOCK_STATE; LOCK(); while (GC_incremental && GC_collection_in_progress()) { GC_collect_a_little_inner(1000); } ++GC_dont_gc; UNLOCK(); } #endif /* Redefine dlopen to guarantee mutual exclusion with */ /* GC_register_dynamic_libraries. Should probably happen for */ /* other operating systems, too. */ /* This is similar to WRAP/REAL_FUNC() in pthread_support.c. */ #ifdef GC_USE_LD_WRAP # define WRAP_DLFUNC(f) __wrap_##f # define REAL_DLFUNC(f) __real_##f void * REAL_DLFUNC(dlopen)(const char *, int); #else # define WRAP_DLFUNC(f) GC_##f # define REAL_DLFUNC(f) f #endif GC_API void * WRAP_DLFUNC(dlopen)(const char *path, int mode) { void * result; # ifndef USE_PROC_FOR_LIBRARIES /* Disable collections. This solution risks heap growth (or, */ /* even, heap overflow) but there seems no better solutions. */ disable_gc_for_dlopen(); # endif result = REAL_DLFUNC(dlopen)(path, mode); # ifndef USE_PROC_FOR_LIBRARIES GC_enable(); /* undoes disable_gc_for_dlopen */ # endif return(result); } #ifdef GC_USE_LD_WRAP /* Define GC_ function as an alias for the plain one, which will be */ /* intercepted. This allows files which include gc.h, and hence */ /* generate references to the GC_ symbol, to see the right symbol. */ GC_API void *GC_dlopen(const char *path, int mode) { return dlopen(path, mode); } #endif /* GC_USE_LD_WRAP */ #ifdef GC_MUST_RESTORE_REDEFINED_DLOPEN # define dlopen GC_dlopen #endif #endif /* GC_PTHREADS && !GC_NO_DLOPEN */ ecl-16.1.2/src/bdwgc/gcj_mlc.c000066400000000000000000000227371266352375300160120ustar00rootroot00000000000000/* * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. * Copyright (c) 1999-2004 Hewlett-Packard Development Company, L.P. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. * */ #include "private/gc_pmark.h" /* includes gc_priv.h */ #ifdef GC_GCJ_SUPPORT /* * This is an allocator interface tuned for gcj (the GNU static * java compiler). * * Each allocated object has a pointer in its first word to a vtable, * which for our purposes is simply a structure describing the type of * the object. * This descriptor structure contains a GC marking descriptor at offset * MARK_DESCR_OFFSET. * * It is hoped that this interface may also be useful for other systems, * possibly with some tuning of the constants. But the immediate goal * is to get better gcj performance. * * We assume: * 1) Counting on explicit initialization of this interface is OK; * 2) FASTLOCK is not a significant win. */ #include "gc_gcj.h" #include "private/dbg_mlc.h" #ifdef GC_ASSERTIONS GC_INNER /* variable is also used in thread_local_alloc.c */ #else STATIC #endif GC_bool GC_gcj_malloc_initialized = FALSE; int GC_gcj_kind = 0; /* Object kind for objects with descriptors */ /* in "vtable". */ int GC_gcj_debug_kind = 0; /* The kind of objects that is always marked */ /* with a mark proc call. */ GC_INNER ptr_t * GC_gcjobjfreelist = NULL; STATIC ptr_t * GC_gcjdebugobjfreelist = NULL; STATIC struct GC_ms_entry * GC_gcj_fake_mark_proc(word * addr GC_ATTR_UNUSED, struct GC_ms_entry *mark_stack_ptr, struct GC_ms_entry * mark_stack_limit GC_ATTR_UNUSED, word env GC_ATTR_UNUSED) { ABORT_RET("No client gcj mark proc is specified"); return mark_stack_ptr; } /* Caller does not hold allocation lock. */ GC_API void GC_CALL GC_init_gcj_malloc(int mp_index, void * /* really GC_mark_proc */mp) { GC_bool ignore_gcj_info; DCL_LOCK_STATE; if (mp == 0) /* In case GC_DS_PROC is unused. */ mp = (void *)(word)GC_gcj_fake_mark_proc; GC_init(); /* In case it's not already done. */ LOCK(); if (GC_gcj_malloc_initialized) { UNLOCK(); return; } GC_gcj_malloc_initialized = TRUE; # ifdef GC_IGNORE_GCJ_INFO /* This is useful for debugging on platforms with missing getenv(). */ ignore_gcj_info = 1; # else ignore_gcj_info = (0 != GETENV("GC_IGNORE_GCJ_INFO")); # endif if (ignore_gcj_info) { GC_COND_LOG_PRINTF("Gcj-style type information is disabled!\n"); } GC_ASSERT(GC_mark_procs[mp_index] == (GC_mark_proc)0); /* unused */ GC_mark_procs[mp_index] = (GC_mark_proc)(word)mp; if ((unsigned)mp_index >= GC_n_mark_procs) ABORT("GC_init_gcj_malloc: bad index"); /* Set up object kind gcj-style indirect descriptor. */ GC_gcjobjfreelist = (ptr_t *)GC_new_free_list_inner(); if (ignore_gcj_info) { /* Use a simple length-based descriptor, thus forcing a fully */ /* conservative scan. */ GC_gcj_kind = GC_new_kind_inner((void **)GC_gcjobjfreelist, (0 | GC_DS_LENGTH), TRUE, TRUE); } else { GC_gcj_kind = GC_new_kind_inner( (void **)GC_gcjobjfreelist, (((word)(-(signed_word)MARK_DESCR_OFFSET - GC_INDIR_PER_OBJ_BIAS)) | GC_DS_PER_OBJECT), FALSE, TRUE); } /* Set up object kind for objects that require mark proc call. */ if (ignore_gcj_info) { GC_gcj_debug_kind = GC_gcj_kind; GC_gcjdebugobjfreelist = GC_gcjobjfreelist; } else { GC_gcjdebugobjfreelist = (ptr_t *)GC_new_free_list_inner(); GC_gcj_debug_kind = GC_new_kind_inner( (void **)GC_gcjdebugobjfreelist, GC_MAKE_PROC(mp_index, 1 /* allocated with debug info */), FALSE, TRUE); } UNLOCK(); } #define GENERAL_MALLOC_INNER(lb,k) \ GC_clear_stack(GC_generic_malloc_inner(lb, k)) #define GENERAL_MALLOC_INNER_IOP(lb,k) \ GC_clear_stack(GC_generic_malloc_inner_ignore_off_page(lb, k)) /* We need a mechanism to release the lock and invoke finalizers. */ /* We don't really have an opportunity to do this on a rarely executed */ /* path on which the lock is not held. Thus we check at a */ /* rarely executed point at which it is safe to release the lock. */ /* We do this even where we could just call GC_INVOKE_FINALIZERS, */ /* since it's probably cheaper and certainly more uniform. */ /* FIXME - Consider doing the same elsewhere? */ static void maybe_finalize(void) { static word last_finalized_no = 0; DCL_LOCK_STATE; if (GC_gc_no == last_finalized_no || !EXPECT(GC_is_initialized, TRUE)) return; UNLOCK(); GC_INVOKE_FINALIZERS(); LOCK(); last_finalized_no = GC_gc_no; } /* Allocate an object, clear it, and store the pointer to the */ /* type structure (vtable in gcj). */ /* This adds a byte at the end of the object if GC_malloc would.*/ #ifdef THREAD_LOCAL_ALLOC GC_INNER void * GC_core_gcj_malloc(size_t lb, void * ptr_to_struct_containing_descr) #else GC_API GC_ATTR_MALLOC void * GC_CALL GC_gcj_malloc(size_t lb, void * ptr_to_struct_containing_descr) #endif { ptr_t op; word lg; DCL_LOCK_STATE; GC_DBG_COLLECT_AT_MALLOC(lb); if(SMALL_OBJ(lb)) { lg = GC_size_map[lb]; LOCK(); op = GC_gcjobjfreelist[lg]; if(EXPECT(0 == op, FALSE)) { maybe_finalize(); op = (ptr_t)GENERAL_MALLOC_INNER((word)lb, GC_gcj_kind); if (0 == op) { GC_oom_func oom_fn = GC_oom_fn; UNLOCK(); return((*oom_fn)(lb)); } } else { GC_gcjobjfreelist[lg] = obj_link(op); GC_bytes_allocd += GRANULES_TO_BYTES(lg); } *(void **)op = ptr_to_struct_containing_descr; GC_ASSERT(((void **)op)[1] == 0); UNLOCK(); } else { LOCK(); maybe_finalize(); op = (ptr_t)GENERAL_MALLOC_INNER((word)lb, GC_gcj_kind); if (0 == op) { GC_oom_func oom_fn = GC_oom_fn; UNLOCK(); return((*oom_fn)(lb)); } *(void **)op = ptr_to_struct_containing_descr; UNLOCK(); } return((void *) op); } /* Similar to GC_gcj_malloc, but add debug info. This is allocated */ /* with GC_gcj_debug_kind. */ GC_API GC_ATTR_MALLOC void * GC_CALL GC_debug_gcj_malloc(size_t lb, void * ptr_to_struct_containing_descr, GC_EXTRA_PARAMS) { void * result; DCL_LOCK_STATE; /* We're careful to avoid extra calls, which could */ /* confuse the backtrace. */ LOCK(); maybe_finalize(); result = GC_generic_malloc_inner(lb + DEBUG_BYTES, GC_gcj_debug_kind); if (result == 0) { GC_oom_func oom_fn = GC_oom_fn; UNLOCK(); GC_err_printf("GC_debug_gcj_malloc(%lu, %p) returning NULL (%s:%d)\n", (unsigned long)lb, ptr_to_struct_containing_descr, s, i); return((*oom_fn)(lb)); } *((void **)((ptr_t)result + sizeof(oh))) = ptr_to_struct_containing_descr; UNLOCK(); if (!GC_debugging_started) { GC_start_debugging(); } ADD_CALL_CHAIN(result, ra); return (GC_store_debug_info(result, (word)lb, s, i)); } /* There is no THREAD_LOCAL_ALLOC for GC_gcj_malloc_ignore_off_page(). */ GC_API GC_ATTR_MALLOC void * GC_CALL GC_gcj_malloc_ignore_off_page(size_t lb, void * ptr_to_struct_containing_descr) { ptr_t op; word lg; DCL_LOCK_STATE; GC_DBG_COLLECT_AT_MALLOC(lb); if(SMALL_OBJ(lb)) { lg = GC_size_map[lb]; LOCK(); op = GC_gcjobjfreelist[lg]; if (EXPECT(0 == op, FALSE)) { maybe_finalize(); op = (ptr_t)GENERAL_MALLOC_INNER_IOP(lb, GC_gcj_kind); if (0 == op) { GC_oom_func oom_fn = GC_oom_fn; UNLOCK(); return((*oom_fn)(lb)); } } else { GC_gcjobjfreelist[lg] = obj_link(op); GC_bytes_allocd += GRANULES_TO_BYTES(lg); } } else { LOCK(); maybe_finalize(); op = (ptr_t)GENERAL_MALLOC_INNER_IOP(lb, GC_gcj_kind); if (0 == op) { GC_oom_func oom_fn = GC_oom_fn; UNLOCK(); return((*oom_fn)(lb)); } } *(void **)op = ptr_to_struct_containing_descr; UNLOCK(); return((void *) op); } #endif /* GC_GCJ_SUPPORT */ ecl-16.1.2/src/bdwgc/headers.c000066400000000000000000000311621266352375300160170ustar00rootroot00000000000000/* * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. * Copyright (c) 1996 by Silicon Graphics. All rights reserved. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. */ #include "private/gc_priv.h" /* * This implements: * 1. allocation of heap block headers * 2. A map from addresses to heap block addresses to heap block headers * * Access speed is crucial. We implement an index structure based on a 2 * level tree. */ STATIC bottom_index * GC_all_bottom_indices = 0; /* Pointer to first (lowest addr) */ /* bottom_index. */ STATIC bottom_index * GC_all_bottom_indices_end = 0; /* Pointer to last (highest addr) */ /* bottom_index. */ /* Non-macro version of header location routine */ GC_INNER hdr * GC_find_header(ptr_t h) { # ifdef HASH_TL hdr * result; GET_HDR(h, result); return(result); # else return(HDR_INNER(h)); # endif } /* Handle a header cache miss. Returns a pointer to the */ /* header corresponding to p, if p can possibly be a valid */ /* object pointer, and 0 otherwise. */ /* GUARANTEED to return 0 for a pointer past the first page */ /* of an object unless both GC_all_interior_pointers is set */ /* and p is in fact a valid object pointer. */ /* Never returns a pointer to a free hblk. */ GC_INNER hdr * #ifdef PRINT_BLACK_LIST GC_header_cache_miss(ptr_t p, hdr_cache_entry *hce, ptr_t source) #else GC_header_cache_miss(ptr_t p, hdr_cache_entry *hce) #endif { hdr *hhdr; HC_MISS(); GET_HDR(p, hhdr); if (IS_FORWARDING_ADDR_OR_NIL(hhdr)) { if (GC_all_interior_pointers) { if (hhdr != 0) { ptr_t current = p; current = (ptr_t)HBLKPTR(current); do { current = current - HBLKSIZE*(word)hhdr; hhdr = HDR(current); } while(IS_FORWARDING_ADDR_OR_NIL(hhdr)); /* current points to near the start of the large object */ if (hhdr -> hb_flags & IGNORE_OFF_PAGE) return 0; if (HBLK_IS_FREE(hhdr) || p - current >= (ptrdiff_t)(hhdr->hb_sz)) { GC_ADD_TO_BLACK_LIST_NORMAL(p, source); /* Pointer past the end of the block */ return 0; } } else { GC_ADD_TO_BLACK_LIST_NORMAL(p, source); /* And return zero: */ } GC_ASSERT(hhdr == 0 || !HBLK_IS_FREE(hhdr)); return hhdr; /* Pointers past the first page are probably too rare */ /* to add them to the cache. We don't. */ /* And correctness relies on the fact that we don't. */ } else { if (hhdr == 0) { GC_ADD_TO_BLACK_LIST_NORMAL(p, source); } return 0; } } else { if (HBLK_IS_FREE(hhdr)) { GC_ADD_TO_BLACK_LIST_NORMAL(p, source); return 0; } else { hce -> block_addr = (word)(p) >> LOG_HBLKSIZE; hce -> hce_hdr = hhdr; return hhdr; } } } /* Routines to dynamically allocate collector data structures that will */ /* never be freed. */ static ptr_t scratch_free_ptr = 0; /* GC_scratch_last_end_ptr is end point of last obtained scratch area. */ /* GC_scratch_end_ptr is end point of current scratch area. */ GC_INNER ptr_t GC_scratch_alloc(size_t bytes) { ptr_t result = scratch_free_ptr; word bytes_to_get; bytes = ROUNDUP_GRANULE_SIZE(bytes); for (;;) { scratch_free_ptr += bytes; if ((word)scratch_free_ptr <= (word)GC_scratch_end_ptr) { /* Unallocated space of scratch buffer has enough size. */ return result; } if (bytes >= MINHINCR * HBLKSIZE) { bytes_to_get = ROUNDUP_PAGESIZE_IF_MMAP(bytes); result = (ptr_t)GET_MEM(bytes_to_get); GC_add_to_our_memory(result, bytes_to_get); /* Undo scratch free area pointer update; get memory directly. */ scratch_free_ptr -= bytes; if (result != NULL) { /* Update end point of last obtained area (needed only */ /* by GC_register_dynamic_libraries for some targets). */ GC_scratch_last_end_ptr = result + bytes; } return result; } bytes_to_get = ROUNDUP_PAGESIZE_IF_MMAP(MINHINCR * HBLKSIZE); /* round up for safety */ result = (ptr_t)GET_MEM(bytes_to_get); GC_add_to_our_memory(result, bytes_to_get); if (NULL == result) { WARN("Out of memory - trying to allocate requested amount" " (%" WARN_PRIdPTR " bytes)...\n", (word)bytes); scratch_free_ptr -= bytes; /* Undo free area pointer update */ bytes_to_get = ROUNDUP_PAGESIZE_IF_MMAP(bytes); result = (ptr_t)GET_MEM(bytes_to_get); GC_add_to_our_memory(result, bytes_to_get); return result; } /* Update scratch area pointers and retry. */ scratch_free_ptr = result; GC_scratch_end_ptr = scratch_free_ptr + bytes_to_get; GC_scratch_last_end_ptr = GC_scratch_end_ptr; } } static hdr * hdr_free_list = 0; /* Return an uninitialized header */ static hdr * alloc_hdr(void) { register hdr * result; if (hdr_free_list == 0) { result = (hdr *) GC_scratch_alloc((word)(sizeof(hdr))); } else { result = hdr_free_list; hdr_free_list = (hdr *) (result -> hb_next); } return(result); } GC_INLINE void free_hdr(hdr * hhdr) { hhdr -> hb_next = (struct hblk *) hdr_free_list; hdr_free_list = hhdr; } #ifdef COUNT_HDR_CACHE_HITS /* Used for debugging/profiling (the symbols are externally visible). */ word GC_hdr_cache_hits = 0; word GC_hdr_cache_misses = 0; #endif GC_INNER void GC_init_headers(void) { register unsigned i; GC_all_nils = (bottom_index *)GC_scratch_alloc((word)sizeof(bottom_index)); if (GC_all_nils == NULL) { GC_err_printf("Insufficient memory for GC_all_nils\n"); EXIT(); } BZERO(GC_all_nils, sizeof(bottom_index)); for (i = 0; i < TOP_SZ; i++) { GC_top_index[i] = GC_all_nils; } } /* Make sure that there is a bottom level index block for address addr */ /* Return FALSE on failure. */ static GC_bool get_index(word addr) { word hi = (word)(addr) >> (LOG_BOTTOM_SZ + LOG_HBLKSIZE); bottom_index * r; bottom_index * p; bottom_index ** prev; bottom_index *pi; # ifdef HASH_TL word i = TL_HASH(hi); bottom_index * old; old = p = GC_top_index[i]; while(p != GC_all_nils) { if (p -> key == hi) return(TRUE); p = p -> hash_link; } r = (bottom_index*)GC_scratch_alloc((word)(sizeof (bottom_index))); if (r == 0) return(FALSE); BZERO(r, sizeof (bottom_index)); r -> hash_link = old; GC_top_index[i] = r; # else if (GC_top_index[hi] != GC_all_nils) return(TRUE); r = (bottom_index*)GC_scratch_alloc((word)(sizeof (bottom_index))); if (r == 0) return(FALSE); GC_top_index[hi] = r; BZERO(r, sizeof (bottom_index)); # endif r -> key = hi; /* Add it to the list of bottom indices */ prev = &GC_all_bottom_indices; /* pointer to p */ pi = 0; /* bottom_index preceding p */ while ((p = *prev) != 0 && p -> key < hi) { pi = p; prev = &(p -> asc_link); } r -> desc_link = pi; if (0 == p) { GC_all_bottom_indices_end = r; } else { p -> desc_link = r; } r -> asc_link = p; *prev = r; return(TRUE); } /* Install a header for block h. */ /* The header is uninitialized. */ /* Returns the header or 0 on failure. */ GC_INNER struct hblkhdr * GC_install_header(struct hblk *h) { hdr * result; if (!get_index((word) h)) return(0); result = alloc_hdr(); if (result) { SET_HDR(h, result); # ifdef USE_MUNMAP result -> hb_last_reclaimed = (unsigned short)GC_gc_no; # endif } return(result); } /* Set up forwarding counts for block h of size sz */ GC_INNER GC_bool GC_install_counts(struct hblk *h, size_t sz/* bytes */) { struct hblk * hbp; word i; for (hbp = h; (word)hbp < (word)h + sz; hbp += BOTTOM_SZ) { if (!get_index((word) hbp)) return(FALSE); } if (!get_index((word)h + sz - 1)) return(FALSE); for (hbp = h + 1; (word)hbp < (word)h + sz; hbp += 1) { i = HBLK_PTR_DIFF(hbp, h); SET_HDR(hbp, (hdr *)(i > MAX_JUMP? MAX_JUMP : i)); } return(TRUE); } /* Remove the header for block h */ GC_INNER void GC_remove_header(struct hblk *h) { hdr **ha; GET_HDR_ADDR(h, ha); free_hdr(*ha); *ha = 0; } /* Remove forwarding counts for h */ GC_INNER void GC_remove_counts(struct hblk *h, size_t sz/* bytes */) { register struct hblk * hbp; for (hbp = h+1; (word)hbp < (word)h + sz; hbp += 1) { SET_HDR(hbp, 0); } } /* Apply fn to all allocated blocks */ /*VARARGS1*/ void GC_apply_to_all_blocks(void (*fn)(struct hblk *h, word client_data), word client_data) { signed_word j; bottom_index * index_p; for (index_p = GC_all_bottom_indices; index_p != 0; index_p = index_p -> asc_link) { for (j = BOTTOM_SZ-1; j >= 0;) { if (!IS_FORWARDING_ADDR_OR_NIL(index_p->index[j])) { if (!HBLK_IS_FREE(index_p->index[j])) { (*fn)(((struct hblk *) (((index_p->key << LOG_BOTTOM_SZ) + (word)j) << LOG_HBLKSIZE)), client_data); } j--; } else if (index_p->index[j] == 0) { j--; } else { j -= (signed_word)(index_p->index[j]); } } } } /* Get the next valid block whose address is at least h */ /* Return 0 if there is none. */ GC_INNER struct hblk * GC_next_used_block(struct hblk *h) { register bottom_index * bi; register word j = ((word)h >> LOG_HBLKSIZE) & (BOTTOM_SZ-1); GET_BI(h, bi); if (bi == GC_all_nils) { register word hi = (word)h >> (LOG_BOTTOM_SZ + LOG_HBLKSIZE); bi = GC_all_bottom_indices; while (bi != 0 && bi -> key < hi) bi = bi -> asc_link; j = 0; } while(bi != 0) { while (j < BOTTOM_SZ) { hdr * hhdr = bi -> index[j]; if (IS_FORWARDING_ADDR_OR_NIL(hhdr)) { j++; } else { if (!HBLK_IS_FREE(hhdr)) { return((struct hblk *) (((bi -> key << LOG_BOTTOM_SZ) + j) << LOG_HBLKSIZE)); } else { j += divHBLKSZ(hhdr -> hb_sz); } } } j = 0; bi = bi -> asc_link; } return(0); } /* Get the last (highest address) block whose address is */ /* at most h. Return 0 if there is none. */ /* Unlike the above, this may return a free block. */ GC_INNER struct hblk * GC_prev_block(struct hblk *h) { register bottom_index * bi; register signed_word j = ((word)h >> LOG_HBLKSIZE) & (BOTTOM_SZ-1); GET_BI(h, bi); if (bi == GC_all_nils) { register word hi = (word)h >> (LOG_BOTTOM_SZ + LOG_HBLKSIZE); bi = GC_all_bottom_indices_end; while (bi != 0 && bi -> key > hi) bi = bi -> desc_link; j = BOTTOM_SZ - 1; } while(bi != 0) { while (j >= 0) { hdr * hhdr = bi -> index[j]; if (0 == hhdr) { --j; } else if (IS_FORWARDING_ADDR_OR_NIL(hhdr)) { j -= (signed_word)hhdr; } else { return((struct hblk *) (((bi -> key << LOG_BOTTOM_SZ) + j) << LOG_HBLKSIZE)); } } j = BOTTOM_SZ - 1; bi = bi -> desc_link; } return(0); } ecl-16.1.2/src/bdwgc/ia64_save_regs_in_stack.s000066400000000000000000000003771266352375300211040ustar00rootroot00000000000000 .text .align 16 .global GC_save_regs_in_stack .proc GC_save_regs_in_stack GC_save_regs_in_stack: .body flushrs ;; mov r8=ar.bsp br.ret.sptk.few rp .endp GC_save_regs_in_stack ecl-16.1.2/src/bdwgc/include/000077500000000000000000000000001266352375300156605ustar00rootroot00000000000000ecl-16.1.2/src/bdwgc/include/config.h.in000066400000000000000000000147011266352375300177060ustar00rootroot00000000000000/* include/config.h.in. Generated from configure.ac by autoheader. */ /* Define to recognise all pointers to the interior of objects. */ #undef ALL_INTERIOR_POINTERS /* Define to enable atomic uncollectible allocation. */ #undef ATOMIC_UNCOLLECTABLE /* See doc/README.macros. */ #undef DARWIN_DONT_PARSE_STACK /* Define to force debug headers on all objects. */ #undef DBG_HDRS_ALL /* Define to enable support for DB/UX threads. */ #undef DGUX_THREADS /* Define to enable eCos target support. */ #undef ECOS /* Wine getenv may not return NULL for missing entry. */ #undef EMPTY_GETENV_RESULTS /* Define to enable alternative finalization interface. */ #undef ENABLE_DISCLAIM /* Define to support IBM AIX threads. */ #undef GC_AIX_THREADS /* Define to enable internal debug assertions. */ #undef GC_ASSERTIONS /* Define to support Darwin pthreads. */ #undef GC_DARWIN_THREADS /* Define to enable support for DB/UX threads on i386. */ #undef GC_DGUX386_THREADS /* Define to build dynamic libraries with only API symbols exposed. */ #undef GC_DLL /* Define to support FreeBSD pthreads. */ #undef GC_FREEBSD_THREADS /* Define to include support for gcj. */ #undef GC_GCJ_SUPPORT /* Define to support GNU pthreads. */ #undef GC_GNU_THREADS /* Define if backtrace information is supported. */ #undef GC_HAVE_BUILTIN_BACKTRACE /* Define to support HP/UX 11 pthreads. */ #undef GC_HPUX_THREADS /* Enable Win32 DllMain-based approach of threads registering. */ #undef GC_INSIDE_DLL /* Define to support Irix pthreads. */ #undef GC_IRIX_THREADS /* Define to support pthreads on Linux. */ #undef GC_LINUX_THREADS /* Define to support NetBSD pthreads. */ #undef GC_NETBSD_THREADS /* Define to support OpenBSD pthreads. */ #undef GC_OPENBSD_THREADS /* Define to support Tru64 pthreads. */ #undef GC_OSF1_THREADS /* Read environment variables from the GC 'env' file. */ #undef GC_READ_ENV_FILE /* Define to support rtems-pthreads. */ #undef GC_RTEMS_PTHREADS /* Define to support Solaris pthreads. */ #undef GC_SOLARIS_THREADS /* Define to support platform-specific threads. */ #undef GC_THREADS /* Explicitly prefix exported/imported WINAPI symbols with '_'. */ #undef GC_UNDERSCORE_STDCALL /* Force the GC to use signals based on SIGRTMIN+k. */ #undef GC_USESIGRT_SIGNALS /* See doc/README.macros. */ #undef GC_USE_DLOPEN_WRAP /* Define to support pthreads-win32 or winpthreads. */ #undef GC_WIN32_PTHREADS /* Define to support Win32 threads. */ #undef GC_WIN32_THREADS /* Define to install pthread_atfork() handlers by default. */ #undef HANDLE_FORK /* Define to use 'dladdr' function. */ #undef HAVE_DLADDR /* 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 /* See doc/README.macros. */ #undef JAVA_FINALIZATION /* Define to save back-pointers in debugging headers. */ #undef KEEP_BACK_PTRS /* Define to optimize for large heaps or root sets. */ #undef LARGE_CONFIG /* Define to the sub-directory where libtool stores uninstalled libraries. */ #undef LT_OBJDIR /* See doc/README.macros. */ #undef MAKE_BACK_GRAPH /* Number of GC cycles to wait before unmapping an unused block. */ #undef MUNMAP_THRESHOLD /* Define to not use system clock (cross compiling). */ #undef NO_CLOCK /* Disable debugging, like GC_dump and its callees. */ #undef NO_DEBUGGING /* Define to make the collector not allocate executable memory by default. */ #undef NO_EXECUTE_PERMISSION /* Prohibit installation of pthread_atfork() handlers. */ #undef NO_HANDLE_FORK /* 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 enable parallel marking. */ #undef PARALLEL_MARK /* If defined, redirect free to this function. */ #undef REDIRECT_FREE /* If defined, redirect malloc to this function. */ #undef REDIRECT_MALLOC /* If defined, redirect GC_realloc to this function. */ #undef REDIRECT_REALLOC /* The number of caller frames saved when allocating with the debugging API. */ #undef SAVE_CALL_COUNT /* Shorten the headers to minimize object size at the expense of checking for writes past the end (see doc/README.macros). */ #undef SHORT_DBG_HDRS /* Define to tune the collector for small heap sizes. */ #undef SMALL_CONFIG /* See the comment in gcconfig.h. */ #undef SOLARIS25_PROC_VDB_BUG_FIXED /* Define to 1 if you have the ANSI C header files. */ #undef STDC_HEADERS /* Define to work around a Solaris 5.3 bug (see dyn_load.c). */ #undef SUNOS53_SHARED_LIB /* Define to enable thread-local allocation optimization. */ #undef THREAD_LOCAL_ALLOC /* Use Unicode (W) variant of Win32 API instead of ASCII (A) one. */ #undef UNICODE /* Define to use of compiler-support for thread-local variables. */ #undef USE_COMPILER_TLS /* Define to use mmap instead of sbrk to expand the heap. */ #undef USE_MMAP /* Define to return memory to OS with munmap calls (see doc/README.macros). */ #undef USE_MUNMAP /* Define to use Win32 VirtualAlloc (instead of sbrk or mmap) to expand the heap. */ #undef USE_WINALLOC /* Version number of package */ #undef VERSION /* The POSIX feature macro. */ #undef _POSIX_C_SOURCE /* Indicates the use of pthreads (NetBSD). */ #undef _PTHREADS /* Required define if using POSIX threads. */ #undef _REENTRANT /* Define to `__inline__' or `__inline' if that's what the C compiler calls it, or to nothing if 'inline' is not supported under any name. */ #ifndef __cplusplus #undef inline #endif ecl-16.1.2/src/bdwgc/include/cord.h000066400000000000000000000415111266352375300167620ustar00rootroot00000000000000/* * Copyright (c) 1993-1994 by Xerox Corporation. All rights reserved. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. */ /* * Cords are immutable character strings. A number of operations * on long cords are much more efficient than their strings.h counterpart. * In particular, concatenation takes constant time independent of the length * of the arguments. (Cords are represented as trees, with internal * nodes representing concatenation and leaves consisting of either C * strings or a functional description of the string.) * * The following are reasonable applications of cords. They would perform * unacceptably if C strings were used: * - A compiler that produces assembly language output by repeatedly * concatenating instructions onto a cord representing the output file. * - A text editor that converts the input file to a cord, and then * performs editing operations by producing a new cord representing * the file after each character change (and keeping the old ones in an * edit history) * * For optimal performance, cords should be built by * concatenating short sections. * This interface is designed for maximum compatibility with C strings. * ASCII NUL characters may be embedded in cords using CORD_from_fn. * This is handled correctly, but CORD_to_char_star will produce a string * with embedded NULs when given such a cord. * * This interface is fairly big, largely for performance reasons. * The most basic constants and functions: * * CORD - the type of a cord; * CORD_EMPTY - empty cord; * CORD_len(cord) - length of a cord; * CORD_cat(cord1,cord2) - concatenation of two cords; * CORD_substr(cord, start, len) - substring (or subcord); * CORD_pos i; CORD_FOR(i, cord) { ... CORD_pos_fetch(i) ... } - * examine each character in a cord. CORD_pos_fetch(i) is the char. * CORD_fetch(int i) - Retrieve i'th character (slowly). * CORD_cmp(cord1, cord2) - compare two cords. * CORD_from_file(FILE * f) - turn a read-only file into a cord. * CORD_to_char_star(cord) - convert to C string. * (Non-NULL C constant strings are cords.) * CORD_printf (etc.) - cord version of printf. Use %r for cords. */ #ifndef CORD_H #define CORD_H #include #include #ifdef GC_DLL /* Same as for GC_API in gc_config_macros.h. */ # ifdef CORD_BUILD # if defined(__MINGW32__) || defined(__CEGCC__) # define CORD_API __declspec(dllexport) # elif defined(_MSC_VER) || defined(__DMC__) || defined(__BORLANDC__) \ || defined(__CYGWIN__) || defined(__WATCOMC__) # define CORD_API extern __declspec(dllexport) # elif defined(__GNUC__) && (__GNUC__ >= 4 \ || defined(GC_VISIBILITY_HIDDEN_SET)) /* Only matters if used in conjunction with -fvisibility=hidden option. */ # define CORD_API extern __attribute__((__visibility__("default"))) # endif # else # if defined(__MINGW32__) || defined(__CEGCC__) || defined(_MSC_VER) \ || defined(__DMC__) || defined(__BORLANDC__) || defined(__CYGWIN__) # define CORD_API __declspec(dllimport) # elif defined(__WATCOMC__) # define CORD_API extern __declspec(dllimport) # endif # endif /* !CORD_BUILD */ #endif /* GC_DLL */ #ifndef CORD_API # define CORD_API extern #endif /* Cords have type const char *. This is cheating quite a bit, and not */ /* 100% portable. But it means that nonempty character string */ /* constants may be used as cords directly, provided the string is */ /* never modified in place. The empty cord is represented by, and */ /* can be written as, 0. */ typedef const char * CORD; /* An empty cord is always represented as nil */ #define CORD_EMPTY 0 /* Is a nonempty cord represented as a C string? */ #define CORD_IS_STRING(s) (*(s) != '\0') /* Concatenate two cords. If the arguments are C strings, they may */ /* not be subsequently altered. */ CORD_API CORD CORD_cat(CORD x, CORD y); /* Concatenate a cord and a C string with known length. Except for the */ /* empty string case, this is a special case of CORD_cat. Since the */ /* length is known, it can be faster. */ /* The string y is shared with the resulting CORD. Hence it should */ /* not be altered by the caller. */ CORD_API CORD CORD_cat_char_star(CORD x, const char * y, size_t leny); /* Compute the length of a cord */ CORD_API size_t CORD_len(CORD x); /* Cords may be represented by functions defining the ith character */ typedef char (* CORD_fn)(size_t i, void * client_data); /* Turn a functional description into a cord. */ CORD_API CORD CORD_from_fn(CORD_fn fn, void * client_data, size_t len); /* Return the substring (subcord really) of x with length at most n, */ /* starting at position i. (The initial character has position 0.) */ CORD_API CORD CORD_substr(CORD x, size_t i, size_t n); /* Return the argument, but rebalanced to allow more efficient */ /* character retrieval, substring operations, and comparisons. */ /* This is useful only for cords that were built using repeated */ /* concatenation. Guarantees log time access to the result, unless */ /* x was obtained through a large number of repeated substring ops */ /* or the embedded functional descriptions take longer to evaluate. */ /* May reallocate significant parts of the cord. The argument is not */ /* modified; only the result is balanced. */ CORD_API CORD CORD_balance(CORD x); /* The following traverse a cord by applying a function to each */ /* character. This is occasionally appropriate, especially where */ /* speed is crucial. But, since C doesn't have nested functions, */ /* clients of this sort of traversal are clumsy to write. Consider */ /* the functions that operate on cord positions instead. */ /* Function to iteratively apply to individual characters in cord. */ typedef int (* CORD_iter_fn)(char c, void * client_data); /* Function to apply to substrings of a cord. Each substring is a */ /* a C character string, not a general cord. */ typedef int (* CORD_batched_iter_fn)(const char * s, void * client_data); #define CORD_NO_FN ((CORD_batched_iter_fn)0) /* Apply f1 to each character in the cord, in ascending order, */ /* starting at position i. If */ /* f2 is not CORD_NO_FN, then multiple calls to f1 may be replaced by */ /* a single call to f2. The parameter f2 is provided only to allow */ /* some optimization by the client. This terminates when the right */ /* end of this string is reached, or when f1 or f2 return != 0. In the */ /* latter case CORD_iter returns != 0. Otherwise it returns 0. */ /* The specified value of i must be < CORD_len(x). */ CORD_API int CORD_iter5(CORD x, size_t i, CORD_iter_fn f1, CORD_batched_iter_fn f2, void * client_data); /* A simpler version that starts at 0, and without f2: */ CORD_API int CORD_iter(CORD x, CORD_iter_fn f1, void * client_data); #define CORD_iter(x, f1, cd) CORD_iter5(x, 0, f1, CORD_NO_FN, cd) /* Similar to CORD_iter5, but end-to-beginning. No provisions for */ /* CORD_batched_iter_fn. */ CORD_API int CORD_riter4(CORD x, size_t i, CORD_iter_fn f1, void * client_data); /* A simpler version that starts at the end: */ CORD_API int CORD_riter(CORD x, CORD_iter_fn f1, void * client_data); /* Functions that operate on cord positions. The easy way to traverse */ /* cords. A cord position is logically a pair consisting of a cord */ /* and an index into that cord. But it is much faster to retrieve a */ /* character based on a position than on an index. Unfortunately, */ /* positions are big (order of a few 100 bytes), so allocate them with */ /* caution. */ /* Things in cord_pos.h should be treated as opaque, except as */ /* described below. Also note that */ /* CORD_pos_fetch, CORD_next and CORD_prev have both macro and function */ /* definitions. The former may evaluate their argument more than once. */ #include "cord_pos.h" /* Visible definitions from above: typedef CORD_pos[1]; * Extract the cord from a position: CORD CORD_pos_to_cord(CORD_pos p); * Extract the current index from a position: size_t CORD_pos_to_index(CORD_pos p); * Fetch the character located at the given position: char CORD_pos_fetch(CORD_pos p); * Initialize the position to refer to the given cord and index. * Note that this is the most expensive function on positions: void CORD_set_pos(CORD_pos p, CORD x, size_t i); * Advance the position to the next character. * P must be initialized and valid. * Invalidates p if past end: void CORD_next(CORD_pos p); * Move the position to the preceding character. * P must be initialized and valid. * Invalidates p if past beginning: void CORD_prev(CORD_pos p); * Is the position valid, i.e. inside the cord? int CORD_pos_valid(CORD_pos p); */ #define CORD_FOR(pos, cord) \ for (CORD_set_pos(pos, cord, 0); CORD_pos_valid(pos); CORD_next(pos)) /* An out of memory handler to call. May be supplied by client. */ /* Must not return. */ extern void (* CORD_oom_fn)(void); /* Dump the representation of x to stdout in an implementation defined */ /* manner. Intended for debugging only. */ CORD_API void CORD_dump(CORD x); /* The following could easily be implemented by the client. They are */ /* provided in cordxtra.c for convenience. */ /* Concatenate a character to the end of a cord. */ CORD_API CORD CORD_cat_char(CORD x, char c); /* Concatenate n cords. */ CORD_API CORD CORD_catn(int n, /* CORD */ ...); /* Return the character in CORD_substr(x, i, 1) */ CORD_API char CORD_fetch(CORD x, size_t i); /* Return < 0, 0, or > 0, depending on whether x < y, x = y, x > y */ CORD_API int CORD_cmp(CORD x, CORD y); /* A generalization that takes both starting positions for the */ /* comparison, and a limit on the number of characters to be compared. */ CORD_API int CORD_ncmp(CORD x, size_t x_start, CORD y, size_t y_start, size_t len); /* Find the first occurrence of s in x at position start or later. */ /* Return the position of the first character of s in x, or */ /* CORD_NOT_FOUND if there is none. */ CORD_API size_t CORD_str(CORD x, size_t start, CORD s); /* Return a cord consisting of i copies of (possibly NUL) c. Dangerous */ /* in conjunction with CORD_to_char_star. */ /* The resulting representation takes constant space, independent of i. */ CORD_API CORD CORD_chars(char c, size_t i); #define CORD_nul(i) CORD_chars('\0', (i)) /* Turn a file into cord. The file must be seekable. Its contents */ /* must remain constant. The file may be accessed as an immediate */ /* result of this call and/or as a result of subsequent accesses to */ /* the cord. Short files are likely to be immediately read, but */ /* long files are likely to be read on demand, possibly relying on */ /* stdio for buffering. */ /* We must have exclusive access to the descriptor f, i.e. we may */ /* read it at any time, and expect the file pointer to be */ /* where we left it. Normally this should be invoked as */ /* CORD_from_file(fopen(...)) */ /* CORD_from_file arranges to close the file descriptor when it is no */ /* longer needed (e.g. when the result becomes inaccessible). */ /* The file f must be such that ftell reflects the actual character */ /* position in the file, i.e. the number of characters that can be */ /* or were read with fread. On UNIX systems this is always true. On */ /* MS Windows systems, f must be opened in binary mode. */ CORD_API CORD CORD_from_file(FILE * f); /* Equivalent to the above, except that the entire file will be read */ /* and the file pointer will be closed immediately. */ /* The binary mode restriction from above does not apply. */ CORD_API CORD CORD_from_file_eager(FILE * f); /* Equivalent to the above, except that the file will be read on demand.*/ /* The binary mode restriction applies. */ CORD_API CORD CORD_from_file_lazy(FILE * f); /* Turn a cord into a C string. The result shares no structure with */ /* x, and is thus modifiable. */ CORD_API char * CORD_to_char_star(CORD x); /* Turn a C string into a CORD. The C string is copied, and so may */ /* subsequently be modified. */ CORD_API CORD CORD_from_char_star(const char *s); /* Identical to the above, but the result may share structure with */ /* the argument and is thus not modifiable. */ CORD_API const char * CORD_to_const_char_star(CORD x); /* Write a cord to a file, starting at the current position. No */ /* trailing NULs are newlines are added. */ /* Returns EOF if a write error occurs, 1 otherwise. */ CORD_API int CORD_put(CORD x, FILE * f); /* "Not found" result for the following two functions. */ #define CORD_NOT_FOUND ((size_t)(-1)) /* A vague analog of strchr. Returns the position (an integer, not */ /* a pointer) of the first occurrence of (char) c inside x at position */ /* i or later. The value i must be < CORD_len(x). */ CORD_API size_t CORD_chr(CORD x, size_t i, int c); /* A vague analog of strrchr. Returns index of the last occurrence */ /* of (char) c inside x at position i or earlier. The value i */ /* must be < CORD_len(x). */ CORD_API size_t CORD_rchr(CORD x, size_t i, int c); /* The following are also not primitive, but are implemented in */ /* cordprnt.c. They provide functionality similar to the ANSI C */ /* functions with corresponding names, but with the following */ /* additions and changes: */ /* 1. A %r conversion specification specifies a CORD argument. Field */ /* width, precision, etc. have the same semantics as for %s. */ /* (Note that %c, %C, and %S were already taken.) */ /* 2. The format string is represented as a CORD. */ /* 3. CORD_sprintf and CORD_vsprintf assign the result through the 1st */ /* argument. Unlike their ANSI C versions, there is no need to guess */ /* the correct buffer size. */ /* 4. Most of the conversions are implement through the native */ /* vsprintf. Hence they are usually no faster, and */ /* idiosyncrasies of the native printf are preserved. However, */ /* CORD arguments to CORD_sprintf and CORD_vsprintf are NOT copied; */ /* the result shares the original structure. This may make them */ /* very efficient in some unusual applications. */ /* The format string is copied. */ /* All functions return the number of characters generated or -1 on */ /* error. This complies with the ANSI standard, but is inconsistent */ /* with some older implementations of sprintf. */ /* The implementation of these is probably less portable than the rest */ /* of this package. */ #ifndef CORD_NO_IO #include CORD_API int CORD_sprintf(CORD * out, CORD format, ...); CORD_API int CORD_vsprintf(CORD * out, CORD format, va_list args); CORD_API int CORD_fprintf(FILE * f, CORD format, ...); CORD_API int CORD_vfprintf(FILE * f, CORD format, va_list args); CORD_API int CORD_printf(CORD format, ...); CORD_API int CORD_vprintf(CORD format, va_list args); #endif /* CORD_NO_IO */ #endif /* CORD_H */ ecl-16.1.2/src/bdwgc/include/cord_pos.h000066400000000000000000000113241266352375300176420ustar00rootroot00000000000000/* * Copyright (c) 1993-1994 by Xerox Corporation. All rights reserved. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. */ /* This should never be included directly; included only from cord.h. */ #if !defined(CORD_POSITION_H) && defined(CORD_H) #define CORD_POSITION_H /* The representation of CORD_position. This is private to the */ /* implementation, but the size is known to clients. Also */ /* the implementation of some exported macros relies on it. */ /* Don't use anything defined here and not in cord.h. */ # define MAX_DEPTH 48 /* The maximum depth of a balanced cord + 1. */ /* We don't let cords get deeper than MAX_DEPTH. */ struct CORD_pe { CORD pe_cord; size_t pe_start_pos; }; /* A structure describing an entry on the path from the root */ /* to current position. */ typedef struct CORD_Pos { size_t cur_pos; int path_len; # define CORD_POS_INVALID (0x55555555) /* path_len == INVALID <==> position invalid */ const char *cur_leaf; /* Current leaf, if it is a string. */ /* If the current leaf is a function, */ /* then this may point to function_buf */ /* containing the next few characters. */ /* Always points to a valid string */ /* containing the current character */ /* unless cur_end is 0. */ size_t cur_start; /* Start position of cur_leaf */ size_t cur_end; /* Ending position of cur_leaf */ /* 0 if cur_leaf is invalid. */ struct CORD_pe path[MAX_DEPTH + 1]; /* path[path_len] is the leaf corresponding to cur_pos */ /* path[0].pe_cord is the cord we point to. */ # define FUNCTION_BUF_SZ 8 char function_buf[FUNCTION_BUF_SZ]; /* Space for next few chars */ /* from function node. */ } CORD_pos[1]; /* Extract the cord from a position: */ CORD_API CORD CORD_pos_to_cord(CORD_pos p); /* Extract the current index from a position: */ CORD_API size_t CORD_pos_to_index(CORD_pos p); /* Fetch the character located at the given position: */ CORD_API char CORD_pos_fetch(CORD_pos p); /* Initialize the position to refer to the give cord and index. */ /* Note that this is the most expensive function on positions: */ CORD_API void CORD_set_pos(CORD_pos p, CORD x, size_t i); /* Advance the position to the next character. */ /* P must be initialized and valid. */ /* Invalidates p if past end: */ CORD_API void CORD_next(CORD_pos p); /* Move the position to the preceding character. */ /* P must be initialized and valid. */ /* Invalidates p if past beginning: */ CORD_API void CORD_prev(CORD_pos p); /* Is the position valid, i.e. inside the cord? */ CORD_API int CORD_pos_valid(CORD_pos p); CORD_API char CORD__pos_fetch(CORD_pos); CORD_API void CORD__next(CORD_pos); CORD_API void CORD__prev(CORD_pos); #define CORD_pos_fetch(p) \ (((p)[0].cur_end != 0)? \ (p)[0].cur_leaf[(p)[0].cur_pos - (p)[0].cur_start] \ : CORD__pos_fetch(p)) #define CORD_next(p) \ (((p)[0].cur_pos + 1 < (p)[0].cur_end)? \ (p)[0].cur_pos++ \ : (CORD__next(p), 0)) #define CORD_prev(p) \ (((p)[0].cur_end != 0 && (p)[0].cur_pos > (p)[0].cur_start)? \ (p)[0].cur_pos-- \ : (CORD__prev(p), 0)) #define CORD_pos_to_index(p) ((p)[0].cur_pos) #define CORD_pos_to_cord(p) ((p)[0].path[0].pe_cord) #define CORD_pos_valid(p) ((p)[0].path_len != CORD_POS_INVALID) /* Some grubby stuff for performance-critical friends: */ #define CORD_pos_chars_left(p) ((long)((p)[0].cur_end) - (long)((p)[0].cur_pos)) /* Number of characters in cache. <= 0 ==> none */ #define CORD_pos_advance(p,n) ((p)[0].cur_pos += (n) - 1, CORD_next(p)) /* Advance position by n characters */ /* 0 < n < CORD_pos_chars_left(p) */ #define CORD_pos_cur_char_addr(p) \ (p)[0].cur_leaf + ((p)[0].cur_pos - (p)[0].cur_start) /* address of current character in cache. */ #endif ecl-16.1.2/src/bdwgc/include/ec.h000066400000000000000000000040301266352375300164150ustar00rootroot00000000000000# ifndef EC_H # define EC_H # ifndef CORD_H # include "cord.h" # endif /* Extensible cords are strings that may be destructively appended to. */ /* They allow fast construction of cords from characters that are */ /* being read from a stream. */ /* * A client might look like: * * { * CORD_ec x; * CORD result; * char c; * FILE *f; * * ... * CORD_ec_init(x); * while(...) { * c = getc(f); * ... * CORD_ec_append(x, c); * } * result = CORD_balance(CORD_ec_to_cord(x)); * * If a C string is desired as the final result, the call to CORD_balance * may be replaced by a call to CORD_to_char_star. */ # ifndef CORD_BUFSZ # define CORD_BUFSZ 128 # endif typedef struct CORD_ec_struct { CORD ec_cord; char * ec_bufptr; char ec_buf[CORD_BUFSZ+1]; } CORD_ec[1]; /* This structure represents the concatenation of ec_cord with */ /* ec_buf[0 ... (ec_bufptr-ec_buf-1)] */ /* Flush the buffer part of the extended chord into ec_cord. */ /* Note that this is almost the only real function, and it is */ /* implemented in 6 lines in cordxtra.c */ void CORD_ec_flush_buf(CORD_ec x); /* Convert an extensible cord to a cord. */ # define CORD_ec_to_cord(x) (CORD_ec_flush_buf(x), (x)[0].ec_cord) /* Initialize an extensible cord. */ #define CORD_ec_init(x) \ ((x)[0].ec_cord = 0, (void)((x)[0].ec_bufptr = (x)[0].ec_buf)) /* Append a character to an extensible cord. */ #define CORD_ec_append(x, c) \ (((x)[0].ec_bufptr == (x)[0].ec_buf + CORD_BUFSZ ? \ (CORD_ec_flush_buf(x), 0) : 0), \ (void)(*(x)[0].ec_bufptr++ = (c))) /* Append a cord to an extensible cord. Structure remains shared with */ /* original. */ void CORD_ec_append_cord(CORD_ec x, CORD s); # endif /* EC_H */ ecl-16.1.2/src/bdwgc/include/extra/000077500000000000000000000000001266352375300170035ustar00rootroot00000000000000ecl-16.1.2/src/bdwgc/include/extra/gc.h000066400000000000000000000001141266352375300175410ustar00rootroot00000000000000/* This file is installed for backward compatibility. */ #include ecl-16.1.2/src/bdwgc/include/extra/gc_cpp.h000066400000000000000000000001201266352375300204000ustar00rootroot00000000000000/* This file is installed for backward compatibility. */ #include ecl-16.1.2/src/bdwgc/include/gc.h000066400000000000000000003051261266352375300164310ustar00rootroot00000000000000/* * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers * Copyright (c) 1991-1995 by Xerox Corporation. All rights reserved. * Copyright 1996-1999 by Silicon Graphics. All rights reserved. * Copyright 1999 by Hewlett-Packard Company. All rights reserved. * Copyright (C) 2007 Free Software Foundation, Inc * Copyright (c) 2000-2011 by Hewlett-Packard Development Company. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. */ /* * Note that this defines a large number of tuning hooks, which can * safely be ignored in nearly all cases. For normal use it suffices * to call only GC_MALLOC and perhaps GC_REALLOC. * For better performance, also look at GC_MALLOC_ATOMIC, and * GC_enable_incremental. If you need an action to be performed * immediately before an object is collected, look at GC_register_finalizer. * If you are using Solaris threads, look at the end of this file. * Everything else is best ignored unless you encounter performance * problems. */ #ifndef GC_H #define GC_H #include "gc_version.h" /* Define version numbers here to allow test on build machine */ /* for cross-builds. Note that this defines the header */ /* version number, which may or may not match that of the */ /* dynamic library. GC_get_version() can be used to obtain */ /* the latter. */ #include "gc_config_macros.h" #ifdef __cplusplus extern "C" { #endif typedef void * GC_PTR; /* preserved only for backward compatibility */ /* Define word and signed_word to be unsigned and signed types of the */ /* size as char * or void *. There seems to be no way to do this */ /* even semi-portably. The following is probably no better/worse */ /* than almost anything else. */ /* The ANSI standard suggests that size_t and ptrdiff_t might be */ /* better choices. But those had incorrect definitions on some older */ /* systems. Notably "typedef int size_t" is WRONG. */ #ifdef _WIN64 # ifdef __int64 typedef unsigned __int64 GC_word; typedef __int64 GC_signed_word; # else typedef unsigned long long GC_word; typedef long long GC_signed_word; # endif #else typedef unsigned long GC_word; typedef long GC_signed_word; #endif /* Get the GC library version. The returned value is a constant in the */ /* form: ((version_major<<16) | (version_minor<<8) | version_micro). */ GC_API unsigned GC_CALL GC_get_version(void); /* Public read-only variables */ /* The supplied getter functions are preferred for new code. */ GC_API GC_ATTR_DEPRECATED GC_word GC_gc_no; /* Counter incremented per collection. */ /* Includes empty GCs at startup. */ GC_API GC_word GC_CALL GC_get_gc_no(void); /* GC_get_gc_no() is unsynchronized, so */ /* it requires GC_call_with_alloc_lock() to */ /* avoid data races on multiprocessors. */ #ifdef GC_THREADS GC_API GC_ATTR_DEPRECATED int GC_parallel; /* GC is parallelized for performance on */ /* multiprocessors. Currently set only */ /* implicitly if collector is built with */ /* PARALLEL_MARK defined and if either: */ /* Env variable GC_NPROC is set to > 1, or */ /* GC_NPROC is not set and this is an MP. */ /* If GC_parallel is on (non-zero), incremental */ /* collection is only partially functional, */ /* and may not be desirable. The getter does */ /* not use or need synchronization (i.e. */ /* acquiring the GC lock). Starting from */ /* GC v7.3, GC_parallel value is equal to the */ /* number of marker threads minus one (i.e. */ /* number of existing parallel marker threads */ /* excluding the initiating one). */ GC_API int GC_CALL GC_get_parallel(void); #endif /* Public R/W variables */ /* The supplied setter and getter functions are preferred for new code. */ typedef void * (GC_CALLBACK * GC_oom_func)(size_t /* bytes_requested */); GC_API GC_ATTR_DEPRECATED GC_oom_func GC_oom_fn; /* When there is insufficient memory to satisfy */ /* an allocation request, we return */ /* (*GC_oom_fn)(size). By default this just */ /* returns NULL. */ /* If it returns, it must return 0 or a valid */ /* pointer to a previously allocated heap */ /* object. GC_oom_fn must not be 0. */ /* Both the supplied setter and the getter */ /* acquire the GC lock (to avoid data races). */ GC_API void GC_CALL GC_set_oom_fn(GC_oom_func) GC_ATTR_NONNULL(1); GC_API GC_oom_func GC_CALL GC_get_oom_fn(void); typedef void (GC_CALLBACK * GC_on_heap_resize_proc)(GC_word /* new_size */); GC_API GC_ATTR_DEPRECATED GC_on_heap_resize_proc GC_on_heap_resize; /* Invoked when the heap grows or shrinks. */ /* Called with the world stopped (and the */ /* allocation lock held). May be 0. */ GC_API void GC_CALL GC_set_on_heap_resize(GC_on_heap_resize_proc); GC_API GC_on_heap_resize_proc GC_CALL GC_get_on_heap_resize(void); /* Both the supplied setter and the getter */ /* acquire the GC lock (to avoid data races). */ GC_API GC_ATTR_DEPRECATED int GC_find_leak; /* Do not actually garbage collect, but simply */ /* report inaccessible memory that was not */ /* deallocated with GC_free. Initial value */ /* is determined by FIND_LEAK macro. */ /* The value should not typically be modified */ /* after GC initialization (and, thus, it does */ /* not use or need synchronization). */ GC_API void GC_CALL GC_set_find_leak(int); GC_API int GC_CALL GC_get_find_leak(void); GC_API GC_ATTR_DEPRECATED int GC_all_interior_pointers; /* Arrange for pointers to object interiors to */ /* be recognized as valid. Typically should */ /* not be changed after GC initialization (in */ /* case of calling it after the GC is */ /* initialized, the setter acquires the GC lock */ /* (to avoid data races). The initial value */ /* depends on whether the GC is built with */ /* ALL_INTERIOR_POINTERS macro defined or not. */ /* Unless DONT_ADD_BYTE_AT_END is defined, this */ /* also affects whether sizes are increased by */ /* at least a byte to allow "off the end" */ /* pointer recognition. Must be only 0 or 1. */ GC_API void GC_CALL GC_set_all_interior_pointers(int); GC_API int GC_CALL GC_get_all_interior_pointers(void); GC_API GC_ATTR_DEPRECATED int GC_finalize_on_demand; /* If nonzero, finalizers will only be run in */ /* response to an explicit GC_invoke_finalizers */ /* call. The default is determined by whether */ /* the FINALIZE_ON_DEMAND macro is defined */ /* when the collector is built. */ /* The setter and getter are unsynchronized. */ GC_API void GC_CALL GC_set_finalize_on_demand(int); GC_API int GC_CALL GC_get_finalize_on_demand(void); GC_API GC_ATTR_DEPRECATED int GC_java_finalization; /* Mark objects reachable from finalizable */ /* objects in a separate post-pass. This makes */ /* it a bit safer to use non-topologically- */ /* ordered finalization. Default value is */ /* determined by JAVA_FINALIZATION macro. */ /* Enables register_finalizer_unreachable to */ /* work correctly. */ /* The setter and getter are unsynchronized. */ GC_API void GC_CALL GC_set_java_finalization(int); GC_API int GC_CALL GC_get_java_finalization(void); typedef void (GC_CALLBACK * GC_finalizer_notifier_proc)(void); GC_API GC_ATTR_DEPRECATED GC_finalizer_notifier_proc GC_finalizer_notifier; /* Invoked by the collector when there are */ /* objects to be finalized. Invoked at most */ /* once per GC cycle. Never invoked unless */ /* GC_finalize_on_demand is set. */ /* Typically this will notify a finalization */ /* thread, which will call GC_invoke_finalizers */ /* in response. May be 0 (means no notifier). */ /* Both the supplied setter and the getter */ /* acquire the GC lock (to avoid data races). */ GC_API void GC_CALL GC_set_finalizer_notifier(GC_finalizer_notifier_proc); GC_API GC_finalizer_notifier_proc GC_CALL GC_get_finalizer_notifier(void); GC_API # ifndef GC_DONT_GC GC_ATTR_DEPRECATED # endif int GC_dont_gc; /* != 0 ==> Don't collect. In versions 6.2a1+, */ /* this overrides explicit GC_gcollect() calls. */ /* Used as a counter, so that nested enabling */ /* and disabling work correctly. Should */ /* normally be updated with GC_enable() and */ /* GC_disable() calls. Direct assignment to */ /* GC_dont_gc is deprecated. To check whether */ /* GC is disabled, GC_is_disabled() is */ /* preferred for new code. */ GC_API GC_ATTR_DEPRECATED int GC_dont_expand; /* Do not expand the heap unless explicitly */ /* requested or forced to. The setter and */ /* getter are unsynchronized. */ GC_API void GC_CALL GC_set_dont_expand(int); GC_API int GC_CALL GC_get_dont_expand(void); GC_API GC_ATTR_DEPRECATED int GC_use_entire_heap; /* Causes the non-incremental collector to use the */ /* entire heap before collecting. This was the only */ /* option for GC versions < 5.0. This sometimes */ /* results in more large block fragmentation, since */ /* very large blocks will tend to get broken up */ /* during each GC cycle. It is likely to result in a */ /* larger working set, but lower collection */ /* frequencies, and hence fewer instructions executed */ /* in the collector. */ GC_API GC_ATTR_DEPRECATED int GC_full_freq; /* Number of partial collections between */ /* full collections. Matters only if */ /* GC_incremental is set. */ /* Full collections are also triggered if */ /* the collector detects a substantial */ /* increase in the number of in-use heap */ /* blocks. Values in the tens are now */ /* perfectly reasonable, unlike for */ /* earlier GC versions. */ /* The setter and getter are unsynchronized, so */ /* GC_call_with_alloc_lock() is required to */ /* avoid data races (if the value is modified */ /* after the GC is put to multi-threaded mode). */ GC_API void GC_CALL GC_set_full_freq(int); GC_API int GC_CALL GC_get_full_freq(void); GC_API GC_ATTR_DEPRECATED GC_word GC_non_gc_bytes; /* Bytes not considered candidates for */ /* collection. Used only to control scheduling */ /* of collections. Updated by */ /* GC_malloc_uncollectable and GC_free. */ /* Wizards only. */ /* The setter and getter are unsynchronized, so */ /* GC_call_with_alloc_lock() is required to */ /* avoid data races (if the value is modified */ /* after the GC is put to multi-threaded mode). */ GC_API void GC_CALL GC_set_non_gc_bytes(GC_word); GC_API GC_word GC_CALL GC_get_non_gc_bytes(void); GC_API GC_ATTR_DEPRECATED int GC_no_dls; /* Don't register dynamic library data segments. */ /* Wizards only. Should be used only if the */ /* application explicitly registers all roots. */ /* (In some environments like Microsoft Windows */ /* and Apple's Darwin, this may also prevent */ /* registration of the main data segment as part */ /* of the root set.) */ /* The setter and getter are unsynchronized. */ GC_API void GC_CALL GC_set_no_dls(int); GC_API int GC_CALL GC_get_no_dls(void); GC_API GC_ATTR_DEPRECATED GC_word GC_free_space_divisor; /* We try to make sure that we allocate at */ /* least N/GC_free_space_divisor bytes between */ /* collections, where N is twice the number */ /* of traced bytes, plus the number of untraced */ /* bytes (bytes in "atomic" objects), plus */ /* a rough estimate of the root set size. */ /* N approximates GC tracing work per GC. */ /* Initially, GC_free_space_divisor = 3. */ /* Increasing its value will use less space */ /* but more collection time. Decreasing it */ /* will appreciably decrease collection time */ /* at the expense of space. */ /* The setter and getter are unsynchronized, so */ /* GC_call_with_alloc_lock() is required to */ /* avoid data races (if the value is modified */ /* after the GC is put to multi-threaded mode). */ GC_API void GC_CALL GC_set_free_space_divisor(GC_word); GC_API GC_word GC_CALL GC_get_free_space_divisor(void); GC_API GC_ATTR_DEPRECATED GC_word GC_max_retries; /* The maximum number of GCs attempted before */ /* reporting out of memory after heap */ /* expansion fails. Initially 0. */ /* The setter and getter are unsynchronized, so */ /* GC_call_with_alloc_lock() is required to */ /* avoid data races (if the value is modified */ /* after the GC is put to multi-threaded mode). */ GC_API void GC_CALL GC_set_max_retries(GC_word); GC_API GC_word GC_CALL GC_get_max_retries(void); GC_API GC_ATTR_DEPRECATED char *GC_stackbottom; /* Cool end of user stack. */ /* May be set in the client prior to */ /* calling any GC_ routines. This */ /* avoids some overhead, and */ /* potentially some signals that can */ /* confuse debuggers. Otherwise the */ /* collector attempts to set it */ /* automatically. */ /* For multi-threaded code, this is the */ /* cold end of the stack for the */ /* primordial thread. Portable clients */ /* should use GC_get_stack_base(), */ /* GC_call_with_gc_active() and */ /* GC_register_my_thread() instead. */ GC_API GC_ATTR_DEPRECATED int GC_dont_precollect; /* Do not collect as part of GC */ /* initialization. Should be set only */ /* if the client wants a chance to */ /* manually initialize the root set */ /* before the first collection. */ /* Interferes with blacklisting. */ /* Wizards only. The setter and getter */ /* are unsynchronized (and no external */ /* locking is needed since the value is */ /* accessed at GC initialization only). */ GC_API void GC_CALL GC_set_dont_precollect(int); GC_API int GC_CALL GC_get_dont_precollect(void); GC_API GC_ATTR_DEPRECATED unsigned long GC_time_limit; /* If incremental collection is enabled, */ /* We try to terminate collections */ /* after this many milliseconds. Not a */ /* hard time bound. Setting this to */ /* GC_TIME_UNLIMITED will essentially */ /* disable incremental collection while */ /* leaving generational collection */ /* enabled. */ #define GC_TIME_UNLIMITED 999999 /* Setting GC_time_limit to this value */ /* will disable the "pause time exceeded"*/ /* tests. */ /* The setter and getter are unsynchronized, so */ /* GC_call_with_alloc_lock() is required to */ /* avoid data races (if the value is modified */ /* after the GC is put to multi-threaded mode). */ GC_API void GC_CALL GC_set_time_limit(unsigned long); GC_API unsigned long GC_CALL GC_get_time_limit(void); /* Public procedures */ /* Set whether the GC will allocate executable memory pages or not. */ /* A non-zero argument instructs the collector to allocate memory with */ /* the executable flag on. Must be called before the collector is */ /* initialized. May have no effect on some platforms. The default */ /* value is controlled by NO_EXECUTE_PERMISSION macro (if present then */ /* the flag is off). Portable clients should have */ /* GC_set_pages_executable(1) call (before GC_INIT) provided they are */ /* going to execute code on any of the GC-allocated memory objects. */ GC_API void GC_CALL GC_set_pages_executable(int); /* Returns non-zero value if the GC is set to the allocate-executable */ /* mode. The mode could be changed by GC_set_pages_executable (before */ /* GC_INIT) unless the former has no effect on the platform. Does not */ /* use or need synchronization (i.e. acquiring the allocator lock). */ GC_API int GC_CALL GC_get_pages_executable(void); /* Overrides the default handle-fork mode. Non-zero value means GC */ /* should install proper pthread_atfork handlers. Has effect only if */ /* called before GC_INIT. Clients should invoke GC_set_handle_fork */ /* with non-zero argument if going to use fork with GC functions called */ /* in the forked child. (Note that such client and atfork handlers */ /* activities are not fully POSIX-compliant.) GC_set_handle_fork */ /* instructs GC_init to setup GC fork handlers using pthread_atfork, */ /* the latter might fail (or, even, absent on some targets) causing */ /* abort at GC initialization. Starting from 7.3alpha3, problems with */ /* missing (or failed) pthread_atfork() could be avoided by invocation */ /* of GC_set_handle_fork(-1) at application start-up and surrounding */ /* each fork() with the relevant GC_atfork_prepare/parent/child calls. */ GC_API void GC_CALL GC_set_handle_fork(int); /* Routines to handle POSIX fork() manually (no-op if handled */ /* automatically). GC_atfork_prepare should be called immediately */ /* before fork(); GC_atfork_parent should be invoked just after fork in */ /* the branch that corresponds to parent process (i.e., fork result is */ /* non-zero); GC_atfork_child is to be called immediately in the child */ /* branch (i.e., fork result is 0). Note that GC_atfork_child() call */ /* should, of course, precede GC_start_mark_threads call (if any). */ GC_API void GC_CALL GC_atfork_prepare(void); GC_API void GC_CALL GC_atfork_parent(void); GC_API void GC_CALL GC_atfork_child(void); /* Initialize the collector. Portable clients should call GC_INIT() */ /* from the main program instead. */ GC_API void GC_CALL GC_init(void); /* General purpose allocation routines, with roughly malloc calling */ /* conv. The atomic versions promise that no relevant pointers are */ /* contained in the object. The non-atomic versions guarantee that the */ /* new object is cleared. GC_malloc_stubborn promises that no changes */ /* to the object will occur after GC_end_stubborn_change has been */ /* called on the result of GC_malloc_stubborn. GC_malloc_uncollectable */ /* allocates an object that is scanned for pointers to collectible */ /* objects, but is not itself collectible. The object is scanned even */ /* if it does not appear to be reachable. GC_malloc_uncollectable and */ /* GC_free called on the resulting object implicitly update */ /* GC_non_gc_bytes appropriately. */ /* Note that the GC_malloc_stubborn support doesn't really exist */ /* anymore. MANUAL_VDB provides comparable functionality. */ GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1) void * GC_CALL GC_malloc(size_t /* size_in_bytes */); GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1) void * GC_CALL GC_malloc_atomic(size_t /* size_in_bytes */); GC_API GC_ATTR_MALLOC char * GC_CALL GC_strdup(const char *); GC_API GC_ATTR_MALLOC char * GC_CALL GC_strndup(const char *, size_t) GC_ATTR_NONNULL(1); GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1) void * GC_CALL GC_malloc_uncollectable(size_t /* size_in_bytes */); GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1) void * GC_CALL GC_malloc_stubborn(size_t /* size_in_bytes */); /* GC_memalign() is not well tested. */ GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(2) void * GC_CALL GC_memalign(size_t /* align */, size_t /* lb */); GC_API int GC_CALL GC_posix_memalign(void ** /* memptr */, size_t /* align */, size_t /* lb */) GC_ATTR_NONNULL(1); /* Explicitly deallocate an object. Dangerous if used incorrectly. */ /* Requires a pointer to the base of an object. */ /* If the argument is stubborn, it should not be changeable when freed. */ /* An object should not be enabled for finalization (and it should not */ /* contain registered disappearing links of any kind) when it is */ /* explicitly deallocated. */ /* GC_free(0) is a no-op, as required by ANSI C for free. */ GC_API void GC_CALL GC_free(void *); /* Stubborn objects may be changed only if the collector is explicitly */ /* informed. The collector is implicitly informed of coming change */ /* when such an object is first allocated. The following routines */ /* inform the collector that an object will no longer be changed, or */ /* that it will once again be changed. Only non-NULL pointer stores */ /* into the object are considered to be changes. The argument to */ /* GC_end_stubborn_change must be exactly the value returned by */ /* GC_malloc_stubborn or passed to GC_change_stubborn. (In the second */ /* case, it may be an interior pointer within 512 bytes of the */ /* beginning of the objects.) There is a performance penalty for */ /* allowing more than one stubborn object to be changed at once, but it */ /* is acceptable to do so. The same applies to dropping stubborn */ /* objects that are still changeable. */ GC_API void GC_CALL GC_change_stubborn(const void *) GC_ATTR_NONNULL(1); GC_API void GC_CALL GC_end_stubborn_change(const void *) GC_ATTR_NONNULL(1); /* Return a pointer to the base (lowest address) of an object given */ /* a pointer to a location within the object. */ /* I.e., map an interior pointer to the corresponding base pointer. */ /* Note that with debugging allocation, this returns a pointer to the */ /* actual base of the object, i.e. the debug information, not to */ /* the base of the user object. */ /* Return 0 if displaced_pointer doesn't point to within a valid */ /* object. */ /* Note that a deallocated object in the garbage collected heap */ /* may be considered valid, even if it has been deallocated with */ /* GC_free. */ GC_API void * GC_CALL GC_base(void * /* displaced_pointer */); /* Return non-zero (TRUE) if and only if the argument points to */ /* somewhere in GC heap. Primary use is as a fast alternative to */ /* GC_base to check whether the pointed object is allocated by GC */ /* or not. It is assumed that the collector is already initialized. */ GC_API int GC_CALL GC_is_heap_ptr(const void *); /* Given a pointer to the base of an object, return its size in bytes. */ /* The returned size may be slightly larger than what was originally */ /* requested. */ GC_API size_t GC_CALL GC_size(const void * /* obj_addr */) GC_ATTR_NONNULL(1); /* For compatibility with C library. This is occasionally faster than */ /* a malloc followed by a bcopy. But if you rely on that, either here */ /* or with the standard C library, your code is broken. In my */ /* opinion, it shouldn't have been invented, but now we're stuck. -HB */ /* The resulting object has the same kind as the original. */ /* If the argument is stubborn, the result will have changes enabled. */ /* It is an error to have changes enabled for the original object. */ /* Follows ANSI conventions for NULL old_object. */ GC_API void * GC_CALL GC_realloc(void * /* old_object */, size_t /* new_size_in_bytes */) /* 'realloc' attr */ GC_ATTR_ALLOC_SIZE(2); /* Explicitly increase the heap size. */ /* Returns 0 on failure, 1 on success. */ GC_API int GC_CALL GC_expand_hp(size_t /* number_of_bytes */); /* Limit the heap size to n bytes. Useful when you're debugging, */ /* especially on systems that don't handle running out of memory well. */ /* n == 0 ==> unbounded. This is the default. This setter function is */ /* unsynchronized (so it might require GC_call_with_alloc_lock to avoid */ /* data races). */ GC_API void GC_CALL GC_set_max_heap_size(GC_word /* n */); /* Inform the collector that a certain section of statically allocated */ /* memory contains no pointers to garbage collected memory. Thus it */ /* need not be scanned. This is sometimes important if the application */ /* maps large read/write files into the address space, which could be */ /* mistaken for dynamic library data segments on some systems. */ /* Both section start and end are not needed to be pointer-aligned. */ GC_API void GC_CALL GC_exclude_static_roots(void * /* low_address */, void * /* high_address_plus_1 */); /* Clear the set of root segments. Wizards only. */ GC_API void GC_CALL GC_clear_roots(void); /* Add a root segment. Wizards only. */ /* Both segment start and end are not needed to be pointer-aligned. */ /* low_address must not be greater than high_address_plus_1. */ GC_API void GC_CALL GC_add_roots(void * /* low_address */, void * /* high_address_plus_1 */); /* Remove a root segment. Wizards only. */ /* May be unimplemented on some platforms. */ GC_API void GC_CALL GC_remove_roots(void * /* low_address */, void * /* high_address_plus_1 */); /* Add a displacement to the set of those considered valid by the */ /* collector. GC_register_displacement(n) means that if p was returned */ /* by GC_malloc, then (char *)p + n will be considered to be a valid */ /* pointer to p. N must be small and less than the size of p. */ /* (All pointers to the interior of objects from the stack are */ /* considered valid in any case. This applies to heap objects and */ /* static data.) */ /* Preferably, this should be called before any other GC procedures. */ /* Calling it later adds to the probability of excess memory */ /* retention. */ /* This is a no-op if the collector has recognition of */ /* arbitrary interior pointers enabled, which is now the default. */ GC_API void GC_CALL GC_register_displacement(size_t /* n */); /* The following version should be used if any debugging allocation is */ /* being done. */ GC_API void GC_CALL GC_debug_register_displacement(size_t /* n */); /* Explicitly trigger a full, world-stop collection. */ GC_API void GC_CALL GC_gcollect(void); /* Same as above but ignores the default stop_func setting and tries to */ /* unmap as much memory as possible (regardless of the corresponding */ /* switch setting). The recommended usage: on receiving a system */ /* low-memory event; before retrying a system call failed because of */ /* the system is running out of resources. */ GC_API void GC_CALL GC_gcollect_and_unmap(void); /* Trigger a full world-stopped collection. Abort the collection if */ /* and when stop_func returns a nonzero value. Stop_func will be */ /* called frequently, and should be reasonably fast. (stop_func is */ /* called with the allocation lock held and the world might be stopped; */ /* it's not allowed for stop_func to manipulate pointers to the garbage */ /* collected heap or call most of GC functions.) This works even */ /* if virtual dirty bits, and hence incremental collection is not */ /* available for this architecture. Collections can be aborted faster */ /* than normal pause times for incremental collection. However, */ /* aborted collections do no useful work; the next collection needs */ /* to start from the beginning. stop_func must not be 0. */ /* GC_try_to_collect() returns 0 if the collection was aborted (or the */ /* collections are disabled), 1 if it succeeded. */ typedef int (GC_CALLBACK * GC_stop_func)(void); GC_API int GC_CALL GC_try_to_collect(GC_stop_func /* stop_func */) GC_ATTR_NONNULL(1); /* Set and get the default stop_func. The default stop_func is used by */ /* GC_gcollect() and by implicitly trigged collections (except for the */ /* case when handling out of memory). Must not be 0. */ /* Both the setter and getter acquire the GC lock to avoid data races. */ GC_API void GC_CALL GC_set_stop_func(GC_stop_func /* stop_func */) GC_ATTR_NONNULL(1); GC_API GC_stop_func GC_CALL GC_get_stop_func(void); /* Return the number of bytes in the heap. Excludes collector private */ /* data structures. Excludes the unmapped memory (returned to the OS). */ /* Includes empty blocks and fragmentation loss. Includes some pages */ /* that were allocated but never written. */ /* This is an unsynchronized getter, so it should be called typically */ /* with the GC lock held to avoid data races on multiprocessors (the */ /* alternative is to use GC_get_heap_usage_safe or GC_get_prof_stats */ /* API calls instead). */ /* This getter remains lock-free (unsynchronized) for compatibility */ /* reason since some existing clients call it from a GC callback */ /* holding the allocator lock. (This API function and the following */ /* four ones bellow were made thread-safe in GC v7.2alpha1 and */ /* reverted back in v7.2alpha7 for the reason described.) */ GC_API size_t GC_CALL GC_get_heap_size(void); /* Return a lower bound on the number of free bytes in the heap */ /* (excluding the unmapped memory space). This is an unsynchronized */ /* getter (see GC_get_heap_size comment regarding thread-safety). */ GC_API size_t GC_CALL GC_get_free_bytes(void); /* Return the size (in bytes) of the unmapped memory (which is returned */ /* to the OS but could be remapped back by the collector later unless */ /* the OS runs out of system/virtual memory). This is an unsynchronized */ /* getter (see GC_get_heap_size comment regarding thread-safety). */ GC_API size_t GC_CALL GC_get_unmapped_bytes(void); /* Return the number of bytes allocated since the last collection. */ /* This is an unsynchronized getter (see GC_get_heap_size comment */ /* regarding thread-safety). */ GC_API size_t GC_CALL GC_get_bytes_since_gc(void); /* Return the total number of bytes allocated in this process. */ /* Never decreases, except due to wrapping. This is an unsynchronized */ /* getter (see GC_get_heap_size comment regarding thread-safety). */ GC_API size_t GC_CALL GC_get_total_bytes(void); /* Return the heap usage information. This is a thread-safe (atomic) */ /* alternative for the five above getters. (This function acquires */ /* the allocator lock thus preventing data racing and returning the */ /* consistent result.) Passing NULL pointer is allowed for any */ /* argument. Returned (filled in) values are of word type. */ /* (This API function was introduced in GC v7.2alpha7 at the same time */ /* when GC_get_heap_size and the friends were made lock-free again.) */ GC_API void GC_CALL GC_get_heap_usage_safe(GC_word * /* pheap_size */, GC_word * /* pfree_bytes */, GC_word * /* punmapped_bytes */, GC_word * /* pbytes_since_gc */, GC_word * /* ptotal_bytes */); /* Structure used to query GC statistics (profiling information). */ /* More fields could be added in the future. To preserve compatibility */ /* new fields should be added only to the end, and no deprecated fields */ /* should be removed from. */ struct GC_prof_stats_s { GC_word heapsize_full; /* Heap size in bytes (including the area unmapped to OS). */ /* Same as GC_get_heap_size() + GC_get_unmapped_bytes(). */ GC_word free_bytes_full; /* Total bytes contained in free and unmapped blocks. */ /* Same as GC_get_free_bytes() + GC_get_unmapped_bytes(). */ GC_word unmapped_bytes; /* Amount of memory unmapped to OS. Same as the value */ /* returned by GC_get_unmapped_bytes(). */ GC_word bytes_allocd_since_gc; /* Number of bytes allocated since the recent collection. */ /* Same as returned by GC_get_bytes_since_gc(). */ GC_word allocd_bytes_before_gc; /* Number of bytes allocated before the recent garbage */ /* collection. The value may wrap. Same as the result of */ /* GC_get_total_bytes() - GC_get_bytes_since_gc(). */ GC_word non_gc_bytes; /* Number of bytes not considered candidates for garbage */ /* collection. Same as returned by GC_get_non_gc_bytes(). */ GC_word gc_no; /* Garbage collection cycle number. The value may wrap */ /* (and could be -1). Same as returned by GC_get_gc_no(). */ GC_word markers_m1; /* Number of marker threads (excluding the initiating one). */ /* Same as returned by GC_get_parallel (or 0 if the */ /* collector is single-threaded). */ GC_word bytes_reclaimed_since_gc; /* Approximate number of reclaimed bytes after recent GC. */ GC_word reclaimed_bytes_before_gc; /* Approximate number of bytes reclaimed before the recent */ /* garbage collection. The value may wrap. */ }; /* Atomically get GC statistics (various global counters). Clients */ /* should pass the size of the buffer (of GC_prof_stats_s type) to fill */ /* in the values - this is for interoperability between different GC */ /* versions, an old client could have fewer fields, and vice versa, */ /* client could use newer gc.h (with more entries declared in the */ /* structure) than that of the linked libgc binary; in the latter case, */ /* unsupported (unknown) fields are filled in with -1. Return the size */ /* (in bytes) of the filled in part of the structure (excluding all */ /* unknown fields, if any). */ GC_API size_t GC_CALL GC_get_prof_stats(struct GC_prof_stats_s *, size_t /* stats_sz */); #ifdef GC_THREADS /* Same as above but unsynchronized (i.e., not holding the allocation */ /* lock). Clients should call it using GC_call_with_alloc_lock to */ /* avoid data races on multiprocessors. */ GC_API size_t GC_CALL GC_get_prof_stats_unsafe(struct GC_prof_stats_s *, size_t /* stats_sz */); #endif /* Disable garbage collection. Even GC_gcollect calls will be */ /* ineffective. */ GC_API void GC_CALL GC_disable(void); /* Return non-zero (TRUE) if and only if garbage collection is disabled */ /* (i.e., GC_dont_gc value is non-zero). Does not acquire the lock. */ GC_API int GC_CALL GC_is_disabled(void); /* Try to re-enable garbage collection. GC_disable() and GC_enable() */ /* calls nest. Garbage collection is enabled if the number of calls to */ /* both functions is equal. */ GC_API void GC_CALL GC_enable(void); /* Enable incremental/generational collection. Not advisable unless */ /* dirty bits are available or most heap objects are pointer-free */ /* (atomic) or immutable. Don't use in leak finding mode. Ignored if */ /* GC_dont_gc is non-zero. Only the generational piece of this is */ /* functional if GC_parallel is non-zero or if GC_time_limit is */ /* GC_TIME_UNLIMITED. Causes thread-local variant of GC_gcj_malloc() */ /* to revert to locked allocation. Must be called before any such */ /* GC_gcj_malloc() calls. For best performance, should be called as */ /* early as possible. On some platforms, calling it later may have */ /* adverse effects. */ /* Safe to call before GC_INIT(). Includes a GC_init() call. */ GC_API void GC_CALL GC_enable_incremental(void); /* Does incremental mode write-protect pages? Returns zero or */ /* more of the following, or'ed together: */ #define GC_PROTECTS_POINTER_HEAP 1 /* May protect non-atomic objs. */ #define GC_PROTECTS_PTRFREE_HEAP 2 #define GC_PROTECTS_STATIC_DATA 4 /* Currently never. */ #define GC_PROTECTS_STACK 8 /* Probably impractical. */ #define GC_PROTECTS_NONE 0 /* The collector is assumed to be initialized before this call. */ GC_API int GC_CALL GC_incremental_protection_needs(void); /* Perform some garbage collection work, if appropriate. */ /* Return 0 if there is no more work to be done. */ /* Typically performs an amount of work corresponding roughly */ /* to marking from one page. May do more work if further */ /* progress requires it, e.g. if incremental collection is */ /* disabled. It is reasonable to call this in a wait loop */ /* until it returns 0. */ GC_API int GC_CALL GC_collect_a_little(void); /* Allocate an object of size lb bytes. The client guarantees that */ /* as long as the object is live, it will be referenced by a pointer */ /* that points to somewhere within the first 256 bytes of the object. */ /* (This should normally be declared volatile to prevent the compiler */ /* from invalidating this assertion.) This routine is only useful */ /* if a large array is being allocated. It reduces the chance of */ /* accidentally retaining such an array as a result of scanning an */ /* integer that happens to be an address inside the array. (Actually, */ /* it reduces the chance of the allocator not finding space for such */ /* an array, since it will try hard to avoid introducing such a false */ /* reference.) On a SunOS 4.X or MS Windows system this is recommended */ /* for arrays likely to be larger than 100K or so. For other systems, */ /* or if the collector is not configured to recognize all interior */ /* pointers, the threshold is normally much higher. */ GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1) void * GC_CALL GC_malloc_ignore_off_page(size_t /* lb */); GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1) void * GC_CALL GC_malloc_atomic_ignore_off_page(size_t /* lb */); #ifdef GC_ADD_CALLER # define GC_EXTRAS GC_RETURN_ADDR, __FILE__, __LINE__ # define GC_EXTRA_PARAMS GC_word ra, const char * s, int i #else # define GC_EXTRAS __FILE__, __LINE__ # define GC_EXTRA_PARAMS const char * s, int i #endif /* The following is only defined if the library has been suitably */ /* compiled: */ GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1) void * GC_CALL GC_malloc_atomic_uncollectable(size_t /* size_in_bytes */); GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1) void * GC_CALL GC_debug_malloc_atomic_uncollectable(size_t, GC_EXTRA_PARAMS); /* Debugging (annotated) allocation. GC_gcollect will check */ /* objects allocated in this way for overwrites, etc. */ GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1) void * GC_CALL GC_debug_malloc(size_t /* size_in_bytes */, GC_EXTRA_PARAMS); GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1) void * GC_CALL GC_debug_malloc_atomic(size_t /* size_in_bytes */, GC_EXTRA_PARAMS); GC_API GC_ATTR_MALLOC char * GC_CALL GC_debug_strdup(const char *, GC_EXTRA_PARAMS); GC_API GC_ATTR_MALLOC char * GC_CALL GC_debug_strndup(const char *, size_t, GC_EXTRA_PARAMS) GC_ATTR_NONNULL(1); GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1) void * GC_CALL GC_debug_malloc_uncollectable(size_t /* size_in_bytes */, GC_EXTRA_PARAMS); GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1) void * GC_CALL GC_debug_malloc_stubborn(size_t /* size_in_bytes */, GC_EXTRA_PARAMS); GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1) void * GC_CALL GC_debug_malloc_ignore_off_page(size_t /* size_in_bytes */, GC_EXTRA_PARAMS); GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1) void * GC_CALL GC_debug_malloc_atomic_ignore_off_page(size_t /* size_in_bytes */, GC_EXTRA_PARAMS); GC_API void GC_CALL GC_debug_free(void *); GC_API void * GC_CALL GC_debug_realloc(void * /* old_object */, size_t /* new_size_in_bytes */, GC_EXTRA_PARAMS) /* 'realloc' attr */ GC_ATTR_ALLOC_SIZE(2); GC_API void GC_CALL GC_debug_change_stubborn(const void *) GC_ATTR_NONNULL(1); GC_API void GC_CALL GC_debug_end_stubborn_change(const void *) GC_ATTR_NONNULL(1); /* Routines that allocate objects with debug information (like the */ /* above), but just fill in dummy file and line number information. */ /* Thus they can serve as drop-in malloc/realloc replacements. This */ /* can be useful for two reasons: */ /* 1) It allows the collector to be built with DBG_HDRS_ALL defined */ /* even if some allocation calls come from 3rd party libraries */ /* that can't be recompiled. */ /* 2) On some platforms, the file and line information is redundant, */ /* since it can be reconstructed from a stack trace. On such */ /* platforms it may be more convenient not to recompile, e.g. for */ /* leak detection. This can be accomplished by instructing the */ /* linker to replace malloc/realloc with these. */ GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1) void * GC_CALL GC_debug_malloc_replacement(size_t /* size_in_bytes */); GC_API /* 'realloc' attr */ GC_ATTR_ALLOC_SIZE(2) void * GC_CALL GC_debug_realloc_replacement(void * /* object_addr */, size_t /* size_in_bytes */); #ifdef GC_DEBUG_REPLACEMENT # define GC_MALLOC(sz) GC_debug_malloc_replacement(sz) # define GC_REALLOC(old, sz) GC_debug_realloc_replacement(old, sz) #elif defined(GC_DEBUG) # define GC_MALLOC(sz) GC_debug_malloc(sz, GC_EXTRAS) # define GC_REALLOC(old, sz) GC_debug_realloc(old, sz, GC_EXTRAS) #else # define GC_MALLOC(sz) GC_malloc(sz) # define GC_REALLOC(old, sz) GC_realloc(old, sz) #endif /* !GC_DEBUG_REPLACEMENT && !GC_DEBUG */ #ifdef GC_DEBUG # define GC_MALLOC_ATOMIC(sz) GC_debug_malloc_atomic(sz, GC_EXTRAS) # define GC_STRDUP(s) GC_debug_strdup(s, GC_EXTRAS) # define GC_STRNDUP(s, sz) GC_debug_strndup(s, sz, GC_EXTRAS) # define GC_MALLOC_ATOMIC_UNCOLLECTABLE(sz) \ GC_debug_malloc_atomic_uncollectable(sz, GC_EXTRAS) # define GC_MALLOC_UNCOLLECTABLE(sz) \ GC_debug_malloc_uncollectable(sz, GC_EXTRAS) # define GC_MALLOC_IGNORE_OFF_PAGE(sz) \ GC_debug_malloc_ignore_off_page(sz, GC_EXTRAS) # define GC_MALLOC_ATOMIC_IGNORE_OFF_PAGE(sz) \ GC_debug_malloc_atomic_ignore_off_page(sz, GC_EXTRAS) # define GC_FREE(p) GC_debug_free(p) # define GC_REGISTER_FINALIZER(p, f, d, of, od) \ GC_debug_register_finalizer(p, f, d, of, od) # define GC_REGISTER_FINALIZER_IGNORE_SELF(p, f, d, of, od) \ GC_debug_register_finalizer_ignore_self(p, f, d, of, od) # define GC_REGISTER_FINALIZER_NO_ORDER(p, f, d, of, od) \ GC_debug_register_finalizer_no_order(p, f, d, of, od) # define GC_REGISTER_FINALIZER_UNREACHABLE(p, f, d, of, od) \ GC_debug_register_finalizer_unreachable(p, f, d, of, od) # define GC_MALLOC_STUBBORN(sz) GC_debug_malloc_stubborn(sz, GC_EXTRAS) # define GC_CHANGE_STUBBORN(p) GC_debug_change_stubborn(p) # define GC_END_STUBBORN_CHANGE(p) GC_debug_end_stubborn_change(p) # define GC_GENERAL_REGISTER_DISAPPEARING_LINK(link, obj) \ GC_general_register_disappearing_link(link, \ GC_base((/* no const */ void *)(obj))) # define GC_REGISTER_LONG_LINK(link, obj) \ GC_register_long_link(link, GC_base((/* no const */ void *)(obj))) # define GC_REGISTER_DISPLACEMENT(n) GC_debug_register_displacement(n) #else # define GC_MALLOC_ATOMIC(sz) GC_malloc_atomic(sz) # define GC_STRDUP(s) GC_strdup(s) # define GC_STRNDUP(s, sz) GC_strndup(s, sz) # define GC_MALLOC_ATOMIC_UNCOLLECTABLE(sz) GC_malloc_atomic_uncollectable(sz) # define GC_MALLOC_UNCOLLECTABLE(sz) GC_malloc_uncollectable(sz) # define GC_MALLOC_IGNORE_OFF_PAGE(sz) \ GC_malloc_ignore_off_page(sz) # define GC_MALLOC_ATOMIC_IGNORE_OFF_PAGE(sz) \ GC_malloc_atomic_ignore_off_page(sz) # define GC_FREE(p) GC_free(p) # define GC_REGISTER_FINALIZER(p, f, d, of, od) \ GC_register_finalizer(p, f, d, of, od) # define GC_REGISTER_FINALIZER_IGNORE_SELF(p, f, d, of, od) \ GC_register_finalizer_ignore_self(p, f, d, of, od) # define GC_REGISTER_FINALIZER_NO_ORDER(p, f, d, of, od) \ GC_register_finalizer_no_order(p, f, d, of, od) # define GC_REGISTER_FINALIZER_UNREACHABLE(p, f, d, of, od) \ GC_register_finalizer_unreachable(p, f, d, of, od) # define GC_MALLOC_STUBBORN(sz) GC_malloc_stubborn(sz) # define GC_CHANGE_STUBBORN(p) GC_change_stubborn(p) # define GC_END_STUBBORN_CHANGE(p) GC_end_stubborn_change(p) # define GC_GENERAL_REGISTER_DISAPPEARING_LINK(link, obj) \ GC_general_register_disappearing_link(link, obj) # define GC_REGISTER_LONG_LINK(link, obj) \ GC_register_long_link(link, obj) # define GC_REGISTER_DISPLACEMENT(n) GC_register_displacement(n) #endif /* !GC_DEBUG */ /* The following are included because they are often convenient, and */ /* reduce the chance for a misspecified size argument. But calls may */ /* expand to something syntactically incorrect if t is a complicated */ /* type expression. Note that, unlike C++ new operator, these ones */ /* may return NULL (if out of memory). */ #define GC_NEW(t) ((t*)GC_MALLOC(sizeof(t))) #define GC_NEW_ATOMIC(t) ((t*)GC_MALLOC_ATOMIC(sizeof(t))) #define GC_NEW_STUBBORN(t) ((t*)GC_MALLOC_STUBBORN(sizeof(t))) #define GC_NEW_UNCOLLECTABLE(t) ((t*)GC_MALLOC_UNCOLLECTABLE(sizeof(t))) #ifdef GC_REQUIRE_WCSDUP /* This might be unavailable on some targets (or not needed). */ /* wchar_t should be defined in stddef.h */ GC_API GC_ATTR_MALLOC wchar_t * GC_CALL GC_wcsdup(const wchar_t *) GC_ATTR_NONNULL(1); GC_API GC_ATTR_MALLOC wchar_t * GC_CALL GC_debug_wcsdup(const wchar_t *, GC_EXTRA_PARAMS) GC_ATTR_NONNULL(1); # ifdef GC_DEBUG # define GC_WCSDUP(s) GC_debug_wcsdup(s, GC_EXTRAS) # else # define GC_WCSDUP(s) GC_wcsdup(s) # endif #endif /* GC_REQUIRE_WCSDUP */ /* Finalization. Some of these primitives are grossly unsafe. */ /* The idea is to make them both cheap, and sufficient to build */ /* a safer layer, closer to Modula-3, Java, or PCedar finalization. */ /* The interface represents my conclusions from a long discussion */ /* with Alan Demers, Dan Greene, Carl Hauser, Barry Hayes, */ /* Christian Jacobi, and Russ Atkinson. It's not perfect, and */ /* probably nobody else agrees with it. Hans-J. Boehm 3/13/92 */ typedef void (GC_CALLBACK * GC_finalization_proc)(void * /* obj */, void * /* client_data */); GC_API void GC_CALL GC_register_finalizer(void * /* obj */, GC_finalization_proc /* fn */, void * /* cd */, GC_finalization_proc * /* ofn */, void ** /* ocd */) GC_ATTR_NONNULL(1); GC_API void GC_CALL GC_debug_register_finalizer(void * /* obj */, GC_finalization_proc /* fn */, void * /* cd */, GC_finalization_proc * /* ofn */, void ** /* ocd */) GC_ATTR_NONNULL(1); /* When obj is no longer accessible, invoke */ /* (*fn)(obj, cd). If a and b are inaccessible, and */ /* a points to b (after disappearing links have been */ /* made to disappear), then only a will be */ /* finalized. (If this does not create any new */ /* pointers to b, then b will be finalized after the */ /* next collection.) Any finalizable object that */ /* is reachable from itself by following one or more */ /* pointers will not be finalized (or collected). */ /* Thus cycles involving finalizable objects should */ /* be avoided, or broken by disappearing links. */ /* All but the last finalizer registered for an object */ /* is ignored. */ /* Finalization may be removed by passing 0 as fn. */ /* Finalizers are implicitly unregistered when they are */ /* enqueued for finalization (i.e. become ready to be */ /* finalized). */ /* The old finalizer and client data are stored in */ /* *ofn and *ocd. (ofn and/or ocd may be NULL. */ /* The allocation lock is held while *ofn and *ocd are */ /* updated. In case of error (no memory to register */ /* new finalizer), *ofn and *ocd remain unchanged.) */ /* Fn is never invoked on an accessible object, */ /* provided hidden pointers are converted to real */ /* pointers only if the allocation lock is held, and */ /* such conversions are not performed by finalization */ /* routines. */ /* If GC_register_finalizer is aborted as a result of */ /* a signal, the object may be left with no */ /* finalization, even if neither the old nor new */ /* finalizer were NULL. */ /* Obj should be the starting address of an object */ /* allocated by GC_malloc or friends. Obj may also be */ /* NULL or point to something outside GC heap (in this */ /* case, fn is ignored, *ofn and *ocd are set to NULL). */ /* Note that any garbage collectible object referenced */ /* by cd will be considered accessible until the */ /* finalizer is invoked. */ /* Another versions of the above follow. It ignores */ /* self-cycles, i.e. pointers from a finalizable object to */ /* itself. There is a stylistic argument that this is wrong, */ /* but it's unavoidable for C++, since the compiler may */ /* silently introduce these. It's also benign in that specific */ /* case. And it helps if finalizable objects are split to */ /* avoid cycles. */ /* Note that cd will still be viewed as accessible, even if it */ /* refers to the object itself. */ GC_API void GC_CALL GC_register_finalizer_ignore_self(void * /* obj */, GC_finalization_proc /* fn */, void * /* cd */, GC_finalization_proc * /* ofn */, void ** /* ocd */) GC_ATTR_NONNULL(1); GC_API void GC_CALL GC_debug_register_finalizer_ignore_self(void * /* obj */, GC_finalization_proc /* fn */, void * /* cd */, GC_finalization_proc * /* ofn */, void ** /* ocd */) GC_ATTR_NONNULL(1); /* Another version of the above. It ignores all cycles. */ /* It should probably only be used by Java implementations. */ /* Note that cd will still be viewed as accessible, even if it */ /* refers to the object itself. */ GC_API void GC_CALL GC_register_finalizer_no_order(void * /* obj */, GC_finalization_proc /* fn */, void * /* cd */, GC_finalization_proc * /* ofn */, void ** /* ocd */) GC_ATTR_NONNULL(1); GC_API void GC_CALL GC_debug_register_finalizer_no_order(void * /* obj */, GC_finalization_proc /* fn */, void * /* cd */, GC_finalization_proc * /* ofn */, void ** /* ocd */) GC_ATTR_NONNULL(1); /* This is a special finalizer that is useful when an object's */ /* finalizer must be run when the object is known to be no */ /* longer reachable, not even from other finalizable objects. */ /* It behaves like "normal" finalization, except that the */ /* finalizer is not run while the object is reachable from */ /* other objects specifying unordered finalization. */ /* Effectively it allows an object referenced, possibly */ /* indirectly, from an unordered finalizable object to override */ /* the unordered finalization request. */ /* This can be used in combination with finalizer_no_order so */ /* as to release resources that must not be released while an */ /* object can still be brought back to life by other */ /* finalizers. */ /* Only works if GC_java_finalization is set. Probably only */ /* of interest when implementing a language that requires */ /* unordered finalization (e.g. Java, C#). */ GC_API void GC_CALL GC_register_finalizer_unreachable(void * /* obj */, GC_finalization_proc /* fn */, void * /* cd */, GC_finalization_proc * /* ofn */, void ** /* ocd */) GC_ATTR_NONNULL(1); GC_API void GC_CALL GC_debug_register_finalizer_unreachable(void * /* obj */, GC_finalization_proc /* fn */, void * /* cd */, GC_finalization_proc * /* ofn */, void ** /* ocd */) GC_ATTR_NONNULL(1); #define GC_NO_MEMORY 2 /* Failure due to lack of memory. */ /* The following routine may be used to break cycles between */ /* finalizable objects, thus causing cyclic finalizable */ /* objects to be finalized in the correct order. Standard */ /* use involves calling GC_register_disappearing_link(&p), */ /* where p is a pointer that is not followed by finalization */ /* code, and should not be considered in determining */ /* finalization order. */ GC_API int GC_CALL GC_register_disappearing_link(void ** /* link */) GC_ATTR_NONNULL(1); /* Link should point to a field of a heap allocated */ /* object obj. *link will be cleared when obj is */ /* found to be inaccessible. This happens BEFORE any */ /* finalization code is invoked, and BEFORE any */ /* decisions about finalization order are made. */ /* This is useful in telling the finalizer that */ /* some pointers are not essential for proper */ /* finalization. This may avoid finalization cycles. */ /* Note that obj may be resurrected by another */ /* finalizer, and thus the clearing of *link may */ /* be visible to non-finalization code. */ /* There's an argument that an arbitrary action should */ /* be allowed here, instead of just clearing a pointer. */ /* But this causes problems if that action alters, or */ /* examines connectivity. Returns GC_DUPLICATE if link */ /* was already registered, GC_SUCCESS if registration */ /* succeeded, GC_NO_MEMORY if it failed for lack of */ /* memory, and GC_oom_fn did not handle the problem. */ /* Only exists for backward compatibility. See below: */ GC_API int GC_CALL GC_general_register_disappearing_link(void ** /* link */, const void * /* obj */) GC_ATTR_NONNULL(1) GC_ATTR_NONNULL(2); /* A slight generalization of the above. *link is */ /* cleared when obj first becomes inaccessible. This */ /* can be used to implement weak pointers easily and */ /* safely. Typically link will point to a location */ /* holding a disguised pointer to obj. (A pointer */ /* inside an "atomic" object is effectively disguised.) */ /* In this way, weak pointers are broken before any */ /* object reachable from them gets finalized. */ /* Each link may be registered only with one obj value, */ /* i.e. all objects but the last one (link registered */ /* with) are ignored. This was added after a long */ /* email discussion with John Ellis. */ /* link must be non-NULL (and be properly aligned). */ /* obj must be a pointer to the first word of an object */ /* allocated by GC_malloc or friends. A link */ /* disappears when it is unregistered manually, or when */ /* (*link) is cleared, or when the object containing */ /* this link is garbage collected. It is unsafe to */ /* explicitly deallocate the object containing link. */ /* Explicit deallocation of obj may or may not cause */ /* link to eventually be cleared. */ /* This function can be used to implement certain types */ /* of weak pointers. Note, however, this generally */ /* requires that the allocation lock is held (see */ /* GC_call_with_alloc_lock() below) when the disguised */ /* pointer is accessed. Otherwise a strong pointer */ /* could be recreated between the time the collector */ /* decides to reclaim the object and the link is */ /* cleared. Returns GC_SUCCESS if registration */ /* succeeded (a new link is registered), GC_DUPLICATE */ /* if link was already registered (with some object), */ /* GC_NO_MEMORY if registration failed for lack of */ /* memory (and GC_oom_fn did not handle the problem). */ GC_API int GC_CALL GC_move_disappearing_link(void ** /* link */, void ** /* new_link */) GC_ATTR_NONNULL(2); /* Moves a link previously registered via */ /* GC_general_register_disappearing_link (or */ /* GC_register_disappearing_link). Does not change the */ /* target object of the weak reference. Does not */ /* change (*new_link) content. May be called with */ /* new_link equal to link (to check whether link has */ /* been registered). Returns GC_SUCCESS on success, */ /* GC_DUPLICATE if there is already another */ /* disappearing link at the new location (never */ /* returned if new_link is equal to link), GC_NOT_FOUND */ /* if no link is registered at the original location. */ GC_API int GC_CALL GC_unregister_disappearing_link(void ** /* link */); /* Undoes a registration by either of the above two */ /* routines. Returns 0 if link was not actually */ /* registered (otherwise returns 1). */ GC_API int GC_CALL GC_register_long_link(void ** /* link */, const void * /* obj */) GC_ATTR_NONNULL(1) GC_ATTR_NONNULL(2); /* Similar to GC_general_register_disappearing_link but */ /* *link only gets cleared when obj becomes truly */ /* inaccessible. An object becomes truly inaccessible */ /* when it can no longer be resurrected from its */ /* finalizer (e.g. by assigning itself to a pointer */ /* traceable from root). This can be used to implement */ /* long weak pointers easily and safely. */ GC_API int GC_CALL GC_move_long_link(void ** /* link */, void ** /* new_link */) GC_ATTR_NONNULL(2); /* Similar to GC_move_disappearing_link but for a link */ /* previously registered via GC_register_long_link. */ GC_API int GC_CALL GC_unregister_long_link(void ** /* link */); /* Similar to GC_unregister_disappearing_link but for a */ /* registration by either of the above two routines. */ /* Returns !=0 if GC_invoke_finalizers has something to do. */ GC_API int GC_CALL GC_should_invoke_finalizers(void); GC_API int GC_CALL GC_invoke_finalizers(void); /* Run finalizers for all objects that are ready to */ /* be finalized. Return the number of finalizers */ /* that were run. Normally this is also called */ /* implicitly during some allocations. If */ /* GC_finalize_on_demand is nonzero, it must be called */ /* explicitly. */ /* Explicitly tell the collector that an object is reachable */ /* at a particular program point. This prevents the argument */ /* pointer from being optimized away, even it is otherwise no */ /* longer needed. It should have no visible effect in the */ /* absence of finalizers or disappearing links. But it may be */ /* needed to prevent finalizers from running while the */ /* associated external resource is still in use. */ /* The function is sometimes called keep_alive in other */ /* settings. */ #if defined(__GNUC__) && !defined(__INTEL_COMPILER) # define GC_reachable_here(ptr) \ __asm__ __volatile__(" " : : "X"(ptr) : "memory") #else GC_API void GC_CALL GC_noop1(GC_word); # define GC_reachable_here(ptr) GC_noop1((GC_word)(ptr)) #endif /* GC_set_warn_proc can be used to redirect or filter warning messages. */ /* p may not be a NULL pointer. msg is printf format string (arg must */ /* match the format). Both the setter and the getter acquire the GC */ /* lock (to avoid data races). */ typedef void (GC_CALLBACK * GC_warn_proc)(char * /* msg */, GC_word /* arg */); GC_API void GC_CALL GC_set_warn_proc(GC_warn_proc /* p */) GC_ATTR_NONNULL(1); /* GC_get_warn_proc returns the current warn_proc. */ GC_API GC_warn_proc GC_CALL GC_get_warn_proc(void); /* GC_ignore_warn_proc may be used as an argument for GC_set_warn_proc */ /* to suppress all warnings (unless statistics printing is turned on). */ GC_API void GC_CALLBACK GC_ignore_warn_proc(char *, GC_word); /* Change file descriptor of GC log. Unavailable on some targets. */ GC_API void GC_CALL GC_set_log_fd(int); /* abort_func is invoked on GC fatal aborts (just before OS-dependent */ /* abort or exit(1) is called). Must be non-NULL. The default one */ /* outputs msg to stderr provided msg is non-NULL. msg is NULL if */ /* invoked before exit(1) otherwise msg is non-NULL (i.e., if invoked */ /* before abort). Both the setter and getter acquire the GC lock. */ /* Both the setter and getter are defined only if the library has been */ /* compiled without SMALL_CONFIG. */ typedef void (GC_CALLBACK * GC_abort_func)(const char * /* msg */); GC_API void GC_CALL GC_set_abort_func(GC_abort_func) GC_ATTR_NONNULL(1); GC_API GC_abort_func GC_CALL GC_get_abort_func(void); /* The following is intended to be used by a higher level */ /* (e.g. Java-like) finalization facility. It is expected */ /* that finalization code will arrange for hidden pointers to */ /* disappear. Otherwise objects can be accessed after they */ /* have been collected. */ /* Note that putting pointers in atomic objects or in */ /* non-pointer slots of "typed" objects is equivalent to */ /* disguising them in this way, and may have other advantages. */ typedef GC_word GC_hidden_pointer; #define GC_HIDE_POINTER(p) (~(GC_hidden_pointer)(p)) /* Converting a hidden pointer to a real pointer requires verifying */ /* that the object still exists. This involves acquiring the */ /* allocator lock to avoid a race with the collector. */ #define GC_REVEAL_POINTER(p) ((void *)GC_HIDE_POINTER(p)) #if defined(I_HIDE_POINTERS) || defined(GC_I_HIDE_POINTERS) /* This exists only for compatibility (the GC-prefixed symbols are */ /* preferred for new code). */ # define HIDE_POINTER(p) GC_HIDE_POINTER(p) # define REVEAL_POINTER(p) GC_REVEAL_POINTER(p) #endif typedef void * (GC_CALLBACK * GC_fn_type)(void * /* client_data */); GC_API void * GC_CALL GC_call_with_alloc_lock(GC_fn_type /* fn */, void * /* client_data */) GC_ATTR_NONNULL(1); /* These routines are intended to explicitly notify the collector */ /* of new threads. Often this is unnecessary because thread creation */ /* is implicitly intercepted by the collector, using header-file */ /* defines, or linker-based interception. In the long run the intent */ /* is to always make redundant registration safe. In the short run, */ /* this is being implemented a platform at a time. */ /* The interface is complicated by the fact that we probably will not */ /* ever be able to automatically determine the stack base for thread */ /* stacks on all platforms. */ /* Structure representing the base of a thread stack. On most */ /* platforms this contains just a single address. */ struct GC_stack_base { void * mem_base; /* Base of memory stack. */ # if defined(__ia64) || defined(__ia64__) || defined(_M_IA64) void * reg_base; /* Base of separate register stack. */ # endif }; typedef void * (GC_CALLBACK * GC_stack_base_func)( struct GC_stack_base * /* sb */, void * /* arg */); /* Call a function with a stack base structure corresponding to */ /* somewhere in the GC_call_with_stack_base frame. This often can */ /* be used to provide a sufficiently accurate stack base. And we */ /* implement it everywhere. */ GC_API void * GC_CALL GC_call_with_stack_base(GC_stack_base_func /* fn */, void * /* arg */) GC_ATTR_NONNULL(1); #define GC_SUCCESS 0 #define GC_DUPLICATE 1 /* Was already registered. */ #define GC_NO_THREADS 2 /* No thread support in GC. */ /* GC_NO_THREADS is not returned by any GC function anymore. */ #define GC_UNIMPLEMENTED 3 /* Not yet implemented on this platform. */ #define GC_NOT_FOUND 4 /* Requested link not found (returned */ /* by GC_move_disappearing_link). */ #if defined(GC_DARWIN_THREADS) || defined(GC_WIN32_THREADS) /* Use implicit thread registration and processing (via Win32 DllMain */ /* or Darwin task_threads). Deprecated. Must be called before */ /* GC_INIT() and other GC routines. Should be avoided if */ /* GC_pthread_create, GC_beginthreadex (or GC_CreateThread) could be */ /* called instead. Disables parallelized GC on Win32. */ GC_API void GC_CALL GC_use_threads_discovery(void); #endif #ifdef GC_THREADS /* Suggest the GC to use the specific signal to suspend threads. */ /* Has no effect after GC_init and on non-POSIX systems. */ GC_API void GC_CALL GC_set_suspend_signal(int); /* Suggest the GC to use the specific signal to resume threads. */ /* Has no effect after GC_init and on non-POSIX systems. */ GC_API void GC_CALL GC_set_thr_restart_signal(int); /* Return the signal number (constant after initialization) used by */ /* the GC to suspend threads on POSIX systems. Return -1 otherwise. */ GC_API int GC_CALL GC_get_suspend_signal(void); /* Return the signal number (constant after initialization) used by */ /* the garbage collector to restart (resume) threads on POSIX */ /* systems. Return -1 otherwise. */ GC_API int GC_CALL GC_get_thr_restart_signal(void); /* Restart marker threads after POSIX fork in child. Meaningless in */ /* other situations. Should not be called if fork followed by exec. */ GC_API void GC_CALL GC_start_mark_threads(void); /* Explicitly enable GC_register_my_thread() invocation. */ /* Done implicitly if a GC thread-creation function is called (or */ /* implicit thread registration is activated, or the collector is */ /* compiled with GC_ALWAYS_MULTITHREADED defined). Otherwise, it */ /* must be called from the main (or any previously registered) thread */ /* between the collector initialization and the first explicit */ /* registering of a thread (it should be called as late as possible). */ GC_API void GC_CALL GC_allow_register_threads(void); /* Register the current thread, with the indicated stack base, as */ /* a new thread whose stack(s) should be traced by the GC. If it */ /* is not implicitly called by the GC, this must be called before a */ /* thread can allocate garbage collected memory, or assign pointers */ /* to the garbage collected heap. Once registered, a thread will be */ /* stopped during garbage collections. */ /* This call must be previously enabled (see above). */ /* This should never be called from the main thread, where it is */ /* always done implicitly. This is normally done implicitly if GC_ */ /* functions are called to create the thread, e.g. by including gc.h */ /* (which redefines some system functions) before calling the system */ /* thread creation function. Nonetheless, thread cleanup routines */ /* (e.g., pthread key destructor) typically require manual thread */ /* registering (and unregistering) if pointers to GC-allocated */ /* objects are manipulated inside. */ /* It is also always done implicitly on some platforms if */ /* GC_use_threads_discovery() is called at start-up. Except for the */ /* latter case, the explicit call is normally required for threads */ /* created by third-party libraries. */ /* A manually registered thread requires manual unregistering. */ GC_API int GC_CALL GC_register_my_thread(const struct GC_stack_base *) GC_ATTR_NONNULL(1); /* Return non-zero (TRUE) if and only if the calling thread is */ /* registered with the garbage collector. */ GC_API int GC_CALL GC_thread_is_registered(void); /* Unregister the current thread. Only an explicitly registered */ /* thread (i.e. for which GC_register_my_thread() returns GC_SUCCESS) */ /* is allowed (and required) to call this function. (As a special */ /* exception, it is also allowed to once unregister the main thread.) */ /* The thread may no longer allocate garbage collected memory or */ /* manipulate pointers to the garbage collected heap after making */ /* this call. Specifically, if it wants to return or otherwise */ /* communicate a pointer to the garbage-collected heap to another */ /* thread, it must do this before calling GC_unregister_my_thread, */ /* most probably by saving it in a global data structure. Must not */ /* be called inside a GC callback function (except for */ /* GC_call_with_stack_base() one). */ GC_API int GC_CALL GC_unregister_my_thread(void); #endif /* GC_THREADS */ /* Wrapper for functions that are likely to block (or, at least, do not */ /* allocate garbage collected memory and/or manipulate pointers to the */ /* garbage collected heap) for an appreciable length of time. While fn */ /* is running, the collector is said to be in the "inactive" state for */ /* the current thread (this means that the thread is not suspended and */ /* the thread's stack frames "belonging" to the functions in the */ /* "inactive" state are not scanned during garbage collections). It is */ /* allowed for fn to call GC_call_with_gc_active() (even recursively), */ /* thus temporarily toggling the collector's state back to "active". */ GC_API void * GC_CALL GC_do_blocking(GC_fn_type /* fn */, void * /* client_data */) GC_ATTR_NONNULL(1); /* Call a function switching to the "active" state of the collector for */ /* the current thread (i.e. the user function is allowed to call any */ /* GC function and/or manipulate pointers to the garbage collected */ /* heap). GC_call_with_gc_active() has the functionality opposite to */ /* GC_do_blocking() one. It is assumed that the collector is already */ /* initialized and the current thread is registered. fn may toggle */ /* the collector thread's state temporarily to "inactive" one by using */ /* GC_do_blocking. GC_call_with_gc_active() often can be used to */ /* provide a sufficiently accurate stack base. */ GC_API void * GC_CALL GC_call_with_gc_active(GC_fn_type /* fn */, void * /* client_data */) GC_ATTR_NONNULL(1); /* Attempt to fill in the GC_stack_base structure with the stack base */ /* for this thread. This appears to be required to implement anything */ /* like the JNI AttachCurrentThread in an environment in which new */ /* threads are not automatically registered with the collector. */ /* It is also unfortunately hard to implement well on many platforms. */ /* Returns GC_SUCCESS or GC_UNIMPLEMENTED. This function acquires the */ /* GC lock on some platforms. */ GC_API int GC_CALL GC_get_stack_base(struct GC_stack_base *) GC_ATTR_NONNULL(1); /* The following routines are primarily intended for use with a */ /* preprocessor which inserts calls to check C pointer arithmetic. */ /* They indicate failure by invoking the corresponding _print_proc. */ /* Check that p and q point to the same object. */ /* Fail conspicuously if they don't. */ /* Returns the first argument. */ /* Succeeds if neither p nor q points to the heap. */ /* May succeed if both p and q point to between heap objects. */ GC_API void * GC_CALL GC_same_obj(void * /* p */, void * /* q */); /* Checked pointer pre- and post- increment operations. Note that */ /* the second argument is in units of bytes, not multiples of the */ /* object size. This should either be invoked from a macro, or the */ /* call should be automatically generated. */ GC_API void * GC_CALL GC_pre_incr(void **, ptrdiff_t /* how_much */) GC_ATTR_NONNULL(1); GC_API void * GC_CALL GC_post_incr(void **, ptrdiff_t /* how_much */) GC_ATTR_NONNULL(1); /* Check that p is visible */ /* to the collector as a possibly pointer containing location. */ /* If it isn't fail conspicuously. */ /* Returns the argument in all cases. May erroneously succeed */ /* in hard cases. (This is intended for debugging use with */ /* untyped allocations. The idea is that it should be possible, though */ /* slow, to add such a call to all indirect pointer stores.) */ /* Currently useless for multi-threaded worlds. */ GC_API void * GC_CALL GC_is_visible(void * /* p */); /* Check that if p is a pointer to a heap page, then it points to */ /* a valid displacement within a heap object. */ /* Fail conspicuously if this property does not hold. */ /* Uninteresting with GC_all_interior_pointers. */ /* Always returns its argument. */ GC_API void * GC_CALL GC_is_valid_displacement(void * /* p */); /* Explicitly dump the GC state. This is most often called from the */ /* debugger, or by setting the GC_DUMP_REGULARLY environment variable, */ /* but it may be useful to call it from client code during debugging. */ /* Defined only if the library has been compiled without NO_DEBUGGING. */ GC_API void GC_CALL GC_dump(void); /* Safer, but slow, pointer addition. Probably useful mainly with */ /* a preprocessor. Useful only for heap pointers. */ /* Only the macros without trailing digits are meant to be used */ /* by clients. These are designed to model the available C pointer */ /* arithmetic expressions. */ /* Even then, these are probably more useful as */ /* documentation than as part of the API. */ /* Note that GC_PTR_ADD evaluates the first argument more than once. */ #if defined(GC_DEBUG) && defined(__GNUC__) # define GC_PTR_ADD3(x, n, type_of_result) \ ((type_of_result)GC_same_obj((x)+(n), (x))) # define GC_PRE_INCR3(x, n, type_of_result) \ ((type_of_result)GC_pre_incr((void **)(&(x)), (n)*sizeof(*x))) # define GC_POST_INCR3(x, n, type_of_result) \ ((type_of_result)GC_post_incr((void **)(&(x)), (n)*sizeof(*x))) # define GC_PTR_ADD(x, n) GC_PTR_ADD3(x, n, typeof(x)) # define GC_PRE_INCR(x, n) GC_PRE_INCR3(x, n, typeof(x)) # define GC_POST_INCR(x) GC_POST_INCR3(x, 1, typeof(x)) # define GC_POST_DECR(x) GC_POST_INCR3(x, -1, typeof(x)) #else /* !GC_DEBUG || !__GNUC__ */ /* We can't do this right without typeof, which ANSI decided was not */ /* sufficiently useful. Without it we resort to the non-debug version. */ /* FIXME: This should eventually support C++0x decltype. */ # define GC_PTR_ADD(x, n) ((x)+(n)) # define GC_PRE_INCR(x, n) ((x) += (n)) # define GC_POST_INCR(x) ((x)++) # define GC_POST_DECR(x) ((x)--) #endif /* !GC_DEBUG || !__GNUC__ */ /* Safer assignment of a pointer to a non-stack location. */ #ifdef GC_DEBUG # define GC_PTR_STORE(p, q) \ (*(void **)GC_is_visible(p) = GC_is_valid_displacement(q)) #else # define GC_PTR_STORE(p, q) (*(p) = (q)) #endif /* Functions called to report pointer checking errors */ GC_API void (GC_CALLBACK * GC_same_obj_print_proc)(void * /* p */, void * /* q */); GC_API void (GC_CALLBACK * GC_is_valid_displacement_print_proc)(void *); GC_API void (GC_CALLBACK * GC_is_visible_print_proc)(void *); #ifdef GC_PTHREADS /* For pthread support, we generally need to intercept a number of */ /* thread library calls. We do that here by macro defining them. */ # include "gc_pthread_redirects.h" #endif /* This returns a list of objects, linked through their first word. */ /* Its use can greatly reduce lock contention problems, since the */ /* allocation lock can be acquired and released many fewer times. */ GC_API GC_ATTR_MALLOC void * GC_CALL GC_malloc_many(size_t /* lb */); #define GC_NEXT(p) (*(void * *)(p)) /* Retrieve the next element */ /* in returned list. */ /* A filter function to control the scanning of dynamic libraries. */ /* If implemented, called by GC before registering a dynamic library */ /* (discovered by GC) section as a static data root (called only as */ /* a last reason not to register). The filename of the library, the */ /* address and the length of the memory region (section) are passed. */ /* This routine should return nonzero if that region should be scanned. */ /* Always called with the allocation lock held. Depending on the */ /* platform, might be called with the "world" stopped. */ typedef int (GC_CALLBACK * GC_has_static_roots_func)( const char * /* dlpi_name */, void * /* section_start */, size_t /* section_size */); /* Register a new callback (a user-supplied filter) to control the */ /* scanning of dynamic libraries. Replaces any previously registered */ /* callback. May be 0 (means no filtering). May be unused on some */ /* platforms (if the filtering is unimplemented or inappropriate). */ GC_API void GC_CALL GC_register_has_static_roots_callback( GC_has_static_roots_func); #if defined(GC_WIN32_THREADS) \ && (!defined(GC_PTHREADS) || defined(GC_BUILD) || defined(WINAPI)) /* Note: for Cygwin and pthreads-win32, this is skipped */ /* unless windows.h is included before gc.h. */ # if !defined(GC_NO_THREAD_DECLS) || defined(GC_BUILD) # ifdef __cplusplus } /* Including windows.h in an extern "C" context no longer works. */ # endif # if !defined(_WIN32_WCE) && !defined(__CEGCC__) # include /* For _beginthreadex, _endthreadex */ # endif # include # ifdef __cplusplus extern "C" { # endif # ifdef GC_UNDERSCORE_STDCALL /* Explicitly prefix exported/imported WINAPI (__stdcall) symbols */ /* with '_' (underscore). Might be useful if MinGW/x86 is used. */ # define GC_CreateThread _GC_CreateThread # define GC_ExitThread _GC_ExitThread # endif # ifdef GC_INSIDE_DLL /* Export GC DllMain to be invoked from client DllMain. */ # ifdef GC_UNDERSCORE_STDCALL # define GC_DllMain _GC_DllMain # endif GC_API BOOL WINAPI GC_DllMain(HINSTANCE /* inst */, ULONG /* reason */, LPVOID /* reserved */); # endif /* GC_INSIDE_DLL */ # if !defined(_UINTPTR_T) && !defined(_UINTPTR_T_DEFINED) \ && !defined(UINTPTR_MAX) typedef GC_word GC_uintptr_t; # else typedef uintptr_t GC_uintptr_t; # endif # define GC_WIN32_SIZE_T GC_uintptr_t /* All threads must be created using GC_CreateThread or */ /* GC_beginthreadex, or must explicitly call GC_register_my_thread */ /* (and call GC_unregister_my_thread before thread termination), so */ /* that they will be recorded in the thread table. For backward */ /* compatibility, it is possible to build the GC with GC_DLL */ /* defined, and to call GC_use_threads_discovery. This implicitly */ /* registers all created threads, but appears to be less robust. */ /* Currently the collector expects all threads to fall through and */ /* terminate normally, or call GC_endthreadex() or GC_ExitThread, */ /* so that the thread is properly unregistered. */ GC_API HANDLE WINAPI GC_CreateThread( LPSECURITY_ATTRIBUTES /* lpThreadAttributes */, GC_WIN32_SIZE_T /* dwStackSize */, LPTHREAD_START_ROUTINE /* lpStartAddress */, LPVOID /* lpParameter */, DWORD /* dwCreationFlags */, LPDWORD /* lpThreadId */); # ifndef DECLSPEC_NORETURN /* Typically defined in winnt.h. */ # define DECLSPEC_NORETURN /* empty */ # endif GC_API DECLSPEC_NORETURN void WINAPI GC_ExitThread( DWORD /* dwExitCode */); # if !defined(_WIN32_WCE) && !defined(__CEGCC__) GC_API GC_uintptr_t GC_CALL GC_beginthreadex( void * /* security */, unsigned /* stack_size */, unsigned (__stdcall *)(void *), void * /* arglist */, unsigned /* initflag */, unsigned * /* thrdaddr */); /* Note: _endthreadex() is not currently marked as no-return in */ /* VC++ and MinGW headers, so we don't mark it neither. */ GC_API void GC_CALL GC_endthreadex(unsigned /* retval */); # endif /* !_WIN32_WCE */ # endif /* !GC_NO_THREAD_DECLS */ # ifdef GC_WINMAIN_REDIRECT /* win32_threads.c implements the real WinMain(), which will start */ /* a new thread to call GC_WinMain() after initializing the garbage */ /* collector. */ # define WinMain GC_WinMain # endif /* For compatibility only. */ # define GC_use_DllMain GC_use_threads_discovery # ifndef GC_NO_THREAD_REDIRECTS # define CreateThread GC_CreateThread # define ExitThread GC_ExitThread # undef _beginthreadex # define _beginthreadex GC_beginthreadex # undef _endthreadex # define _endthreadex GC_endthreadex /* #define _beginthread { > "Please use _beginthreadex instead of _beginthread" < } */ # endif /* !GC_NO_THREAD_REDIRECTS */ #endif /* GC_WIN32_THREADS */ /* Public setter and getter for switching "unmap as much as possible" */ /* mode on(1) and off(0). Has no effect unless unmapping is turned on. */ /* Has no effect on implicitly-initiated garbage collections. Initial */ /* value is controlled by GC_FORCE_UNMAP_ON_GCOLLECT. The setter and */ /* getter are unsynchronized. */ GC_API void GC_CALL GC_set_force_unmap_on_gcollect(int); GC_API int GC_CALL GC_get_force_unmap_on_gcollect(void); /* Fully portable code should call GC_INIT() from the main program */ /* before making any other GC_ calls. On most platforms this is a */ /* no-op and the collector self-initializes. But a number of */ /* platforms make that too hard. */ /* A GC_INIT call is required if the collector is built with */ /* THREAD_LOCAL_ALLOC defined and the initial allocation call is not */ /* to GC_malloc() or GC_malloc_atomic(). */ #if defined(__CYGWIN32__) || defined(__CYGWIN__) /* Similarly gnu-win32 DLLs need explicit initialization from the */ /* main program, as does AIX. */ extern int _data_start__[], _data_end__[], _bss_start__[], _bss_end__[]; # define GC_DATASTART ((GC_word)_data_start__ < (GC_word)_bss_start__ ? \ (void *)_data_start__ : (void *)_bss_start__) # define GC_DATAEND ((GC_word)_data_end__ > (GC_word)_bss_end__ ? \ (void *)_data_end__ : (void *)_bss_end__) # define GC_INIT_CONF_ROOTS GC_add_roots(GC_DATASTART, GC_DATAEND); \ GC_gcollect() /* For blacklisting. */ /* Required at least if GC is in a DLL. And doesn't hurt. */ #elif defined(_AIX) extern int _data[], _end[]; # define GC_DATASTART ((void *)((ulong)_data)) # define GC_DATAEND ((void *)((ulong)_end)) # define GC_INIT_CONF_ROOTS GC_add_roots(GC_DATASTART, GC_DATAEND) #elif (defined(PLATFORM_ANDROID) || defined(__ANDROID__)) \ && !defined(GC_NOT_DLL) # pragma weak __data_start extern int __data_start[], _end[]; # pragma weak _etext # pragma weak __dso_handle extern int _etext[], __dso_handle[]; /* Explicitly register caller static data roots (__data_start points */ /* to the beginning typically but NDK "gold" linker could provide it */ /* incorrectly, so the workaround is to check the value and use */ /* __dso_handle as an alternative data start reference if provided). */ /* It also works for Android/x86 target where __data_start is not */ /* defined currently (regardless of linker used). */ # define GC_INIT_CONF_ROOTS \ (void)((GC_word)__data_start < (GC_word)_etext \ && (GC_word)_etext < (GC_word)__dso_handle ? \ (GC_add_roots(__dso_handle, _end), 0) : \ (GC_word)__data_start != 0 ? \ (GC_add_roots(__data_start, _end), 0) : 0) #else # define GC_INIT_CONF_ROOTS /* empty */ #endif #ifdef GC_DONT_EXPAND /* Set GC_dont_expand to TRUE at start-up */ # define GC_INIT_CONF_DONT_EXPAND GC_set_dont_expand(1) #else # define GC_INIT_CONF_DONT_EXPAND /* empty */ #endif #ifdef GC_FORCE_UNMAP_ON_GCOLLECT /* Turn on "unmap as much as possible on explicit GC" mode at start-up */ # define GC_INIT_CONF_FORCE_UNMAP_ON_GCOLLECT \ GC_set_force_unmap_on_gcollect(1) #else # define GC_INIT_CONF_FORCE_UNMAP_ON_GCOLLECT /* empty */ #endif #ifdef GC_DONT_GC /* This is for debugging only (useful if environment variables are */ /* unsupported); cannot call GC_disable as goes before GC_init. */ # define GC_INIT_CONF_MAX_RETRIES (void)(GC_dont_gc = 1) #elif defined(GC_MAX_RETRIES) /* Set GC_max_retries to the desired value at start-up */ # define GC_INIT_CONF_MAX_RETRIES GC_set_max_retries(GC_MAX_RETRIES) #else # define GC_INIT_CONF_MAX_RETRIES /* empty */ #endif #ifdef GC_FREE_SPACE_DIVISOR /* Set GC_free_space_divisor to the desired value at start-up */ # define GC_INIT_CONF_FREE_SPACE_DIVISOR \ GC_set_free_space_divisor(GC_FREE_SPACE_DIVISOR) #else # define GC_INIT_CONF_FREE_SPACE_DIVISOR /* empty */ #endif #ifdef GC_FULL_FREQ /* Set GC_full_freq to the desired value at start-up */ # define GC_INIT_CONF_FULL_FREQ GC_set_full_freq(GC_FULL_FREQ) #else # define GC_INIT_CONF_FULL_FREQ /* empty */ #endif #ifdef GC_TIME_LIMIT /* Set GC_time_limit to the desired value at start-up */ # define GC_INIT_CONF_TIME_LIMIT GC_set_time_limit(GC_TIME_LIMIT) #else # define GC_INIT_CONF_TIME_LIMIT /* empty */ #endif #if defined(GC_SIG_SUSPEND) && defined(GC_THREADS) # define GC_INIT_CONF_SUSPEND_SIGNAL GC_set_suspend_signal(GC_SIG_SUSPEND) #else # define GC_INIT_CONF_SUSPEND_SIGNAL /* empty */ #endif #if defined(GC_SIG_THR_RESTART) && defined(GC_THREADS) # define GC_INIT_CONF_THR_RESTART_SIGNAL \ GC_set_thr_restart_signal(GC_SIG_THR_RESTART) #else # define GC_INIT_CONF_THR_RESTART_SIGNAL /* empty */ #endif #ifdef GC_MAXIMUM_HEAP_SIZE /* Limit the heap size to the desired value (useful for debugging). */ /* The limit could be overridden either at the program start-up by */ /* the similar environment variable or anytime later by the */ /* corresponding API function call. */ # define GC_INIT_CONF_MAXIMUM_HEAP_SIZE \ GC_set_max_heap_size(GC_MAXIMUM_HEAP_SIZE) #else # define GC_INIT_CONF_MAXIMUM_HEAP_SIZE /* empty */ #endif #ifdef GC_IGNORE_WARN /* Turn off all warnings at start-up (after GC initialization) */ # define GC_INIT_CONF_IGNORE_WARN GC_set_warn_proc(GC_ignore_warn_proc) #else # define GC_INIT_CONF_IGNORE_WARN /* empty */ #endif #ifdef GC_INITIAL_HEAP_SIZE /* Set heap size to the desired value at start-up */ # define GC_INIT_CONF_INITIAL_HEAP_SIZE \ { size_t heap_size = GC_get_heap_size(); \ if (heap_size < (GC_INITIAL_HEAP_SIZE)) \ (void)GC_expand_hp((GC_INITIAL_HEAP_SIZE) - heap_size); } #else # define GC_INIT_CONF_INITIAL_HEAP_SIZE /* empty */ #endif /* Portable clients should call this at the program start-up. More */ /* over, some platforms require this call to be done strictly from the */ /* primordial thread. */ #define GC_INIT() { GC_INIT_CONF_DONT_EXPAND; /* pre-init */ \ GC_INIT_CONF_FORCE_UNMAP_ON_GCOLLECT; \ GC_INIT_CONF_MAX_RETRIES; \ GC_INIT_CONF_FREE_SPACE_DIVISOR; \ GC_INIT_CONF_FULL_FREQ; \ GC_INIT_CONF_TIME_LIMIT; \ GC_INIT_CONF_SUSPEND_SIGNAL; \ GC_INIT_CONF_THR_RESTART_SIGNAL; \ GC_INIT_CONF_MAXIMUM_HEAP_SIZE; \ GC_init(); /* real GC initialization */ \ GC_INIT_CONF_ROOTS; /* post-init */ \ GC_INIT_CONF_IGNORE_WARN; \ GC_INIT_CONF_INITIAL_HEAP_SIZE; } /* win32S may not free all resources on process exit. */ /* This explicitly deallocates the heap. */ GC_API void GC_CALL GC_win32_free_heap(void); #if defined(__SYMBIAN32__) void GC_init_global_static_roots(void); #endif #if defined(_AMIGA) && !defined(GC_AMIGA_MAKINGLIB) /* Allocation really goes through GC_amiga_allocwrapper_do. */ void *GC_amiga_realloc(void *, size_t); # define GC_realloc(a,b) GC_amiga_realloc(a,b) void GC_amiga_set_toany(void (*)(void)); extern int GC_amiga_free_space_divisor_inc; extern void *(*GC_amiga_allocwrapper_do)(size_t, void *(GC_CALL *)(size_t)); # define GC_malloc(a) \ (*GC_amiga_allocwrapper_do)(a,GC_malloc) # define GC_malloc_atomic(a) \ (*GC_amiga_allocwrapper_do)(a,GC_malloc_atomic) # define GC_malloc_uncollectable(a) \ (*GC_amiga_allocwrapper_do)(a,GC_malloc_uncollectable) # define GC_malloc_stubborn(a) \ (*GC_amiga_allocwrapper_do)(a,GC_malloc_stubborn) # define GC_malloc_atomic_uncollectable(a) \ (*GC_amiga_allocwrapper_do)(a,GC_malloc_atomic_uncollectable) # define GC_malloc_ignore_off_page(a) \ (*GC_amiga_allocwrapper_do)(a,GC_malloc_ignore_off_page) # define GC_malloc_atomic_ignore_off_page(a) \ (*GC_amiga_allocwrapper_do)(a,GC_malloc_atomic_ignore_off_page) #endif /* _AMIGA && !GC_AMIGA_MAKINGLIB */ #ifdef __cplusplus } /* end of extern "C" */ #endif #endif /* GC_H */ ecl-16.1.2/src/bdwgc/include/gc_allocator.h000066400000000000000000000240451266352375300204670ustar00rootroot00000000000000/* * Copyright (c) 1996-1997 * Silicon Graphics Computer Systems, Inc. * * Permission to use, copy, modify, distribute and sell this software * and its documentation for any purpose is hereby granted without fee, * provided that the above copyright notice appear in all copies and * that both that copyright notice and this permission notice appear * in supporting documentation. Silicon Graphics makes no * representations about the suitability of this software for any * purpose. It is provided "as is" without express or implied warranty. * * Copyright (c) 2002 * Hewlett-Packard Company * * Permission to use, copy, modify, distribute and sell this software * and its documentation for any purpose is hereby granted without fee, * provided that the above copyright notice appear in all copies and * that both that copyright notice and this permission notice appear * in supporting documentation. Hewlett-Packard Company makes no * representations about the suitability of this software for any * purpose. It is provided "as is" without express or implied warranty. */ /* * This implements standard-conforming allocators that interact with * the garbage collector. Gc_allocator allocates garbage-collectible * objects of type T. Traceable_allocator allocates objects that * are not themselves garbage collected, but are scanned by the * collector for pointers to collectible objects. Traceable_alloc * should be used for explicitly managed STL containers that may * point to collectible objects. * * This code was derived from an earlier version of the GNU C++ standard * library, which itself was derived from the SGI STL implementation. * * Ignore-off-page allocator: George T. Talbot */ #ifndef GC_ALLOCATOR_H #define GC_ALLOCATOR_H #include "gc.h" #include // for placement new #if defined(__GNUC__) # define GC_ATTR_UNUSED __attribute__((__unused__)) #else # define GC_ATTR_UNUSED #endif /* First some helpers to allow us to dispatch on whether or not a type * is known to be pointer-free. * These are private, except that the client may invoke the * GC_DECLARE_PTRFREE macro. */ struct GC_true_type {}; struct GC_false_type {}; template struct GC_type_traits { GC_false_type GC_is_ptr_free; }; # define GC_DECLARE_PTRFREE(T) \ template<> struct GC_type_traits { GC_true_type GC_is_ptr_free; } GC_DECLARE_PTRFREE(char); GC_DECLARE_PTRFREE(signed char); GC_DECLARE_PTRFREE(unsigned char); GC_DECLARE_PTRFREE(signed short); GC_DECLARE_PTRFREE(unsigned short); GC_DECLARE_PTRFREE(signed int); GC_DECLARE_PTRFREE(unsigned int); GC_DECLARE_PTRFREE(signed long); GC_DECLARE_PTRFREE(unsigned long); GC_DECLARE_PTRFREE(float); GC_DECLARE_PTRFREE(double); GC_DECLARE_PTRFREE(long double); /* The client may want to add others. */ // In the following GC_Tp is GC_true_type if we are allocating a // pointer-free object. template inline void * GC_selective_alloc(size_t n, GC_Tp, bool ignore_off_page) { return ignore_off_page?GC_MALLOC_IGNORE_OFF_PAGE(n):GC_MALLOC(n); } template <> inline void * GC_selective_alloc(size_t n, GC_true_type, bool ignore_off_page) { return ignore_off_page? GC_MALLOC_ATOMIC_IGNORE_OFF_PAGE(n) : GC_MALLOC_ATOMIC(n); } /* Now the public gc_allocator class: */ template class gc_allocator { public: typedef size_t size_type; typedef ptrdiff_t difference_type; typedef GC_Tp* pointer; typedef const GC_Tp* const_pointer; typedef GC_Tp& reference; typedef const GC_Tp& const_reference; typedef GC_Tp value_type; template struct rebind { typedef gc_allocator other; }; gc_allocator() {} gc_allocator(const gc_allocator&) throw() {} # if !(GC_NO_MEMBER_TEMPLATES || 0 < _MSC_VER && _MSC_VER <= 1200) // MSVC++ 6.0 do not support member templates template gc_allocator(const gc_allocator&) throw() {} # endif ~gc_allocator() throw() {} pointer address(reference GC_x) const { return &GC_x; } const_pointer address(const_reference GC_x) const { return &GC_x; } // GC_n is permitted to be 0. The C++ standard says nothing about what // the return value is when GC_n == 0. GC_Tp* allocate(size_type GC_n, const void* = 0) { GC_type_traits traits; return static_cast (GC_selective_alloc(GC_n * sizeof(GC_Tp), traits.GC_is_ptr_free, false)); } // __p is not permitted to be a null pointer. void deallocate(pointer __p, size_type GC_ATTR_UNUSED GC_n) { GC_FREE(__p); } size_type max_size() const throw() { return size_t(-1) / sizeof(GC_Tp); } void construct(pointer __p, const GC_Tp& __val) { new(__p) GC_Tp(__val); } void destroy(pointer __p) { __p->~GC_Tp(); } }; template<> class gc_allocator { typedef size_t size_type; typedef ptrdiff_t difference_type; typedef void* pointer; typedef const void* const_pointer; typedef void value_type; template struct rebind { typedef gc_allocator other; }; }; template inline bool operator==(const gc_allocator&, const gc_allocator&) { return true; } template inline bool operator!=(const gc_allocator&, const gc_allocator&) { return false; } /* Now the public gc_allocator_ignore_off_page class: */ template class gc_allocator_ignore_off_page { public: typedef size_t size_type; typedef ptrdiff_t difference_type; typedef GC_Tp* pointer; typedef const GC_Tp* const_pointer; typedef GC_Tp& reference; typedef const GC_Tp& const_reference; typedef GC_Tp value_type; template struct rebind { typedef gc_allocator_ignore_off_page other; }; gc_allocator_ignore_off_page() {} gc_allocator_ignore_off_page(const gc_allocator_ignore_off_page&) throw() {} # if !(GC_NO_MEMBER_TEMPLATES || 0 < _MSC_VER && _MSC_VER <= 1200) // MSVC++ 6.0 do not support member templates template gc_allocator_ignore_off_page(const gc_allocator_ignore_off_page&) throw() {} # endif ~gc_allocator_ignore_off_page() throw() {} pointer address(reference GC_x) const { return &GC_x; } const_pointer address(const_reference GC_x) const { return &GC_x; } // GC_n is permitted to be 0. The C++ standard says nothing about what // the return value is when GC_n == 0. GC_Tp* allocate(size_type GC_n, const void* = 0) { GC_type_traits traits; return static_cast (GC_selective_alloc(GC_n * sizeof(GC_Tp), traits.GC_is_ptr_free, true)); } // __p is not permitted to be a null pointer. void deallocate(pointer __p, size_type GC_ATTR_UNUSED GC_n) { GC_FREE(__p); } size_type max_size() const throw() { return size_t(-1) / sizeof(GC_Tp); } void construct(pointer __p, const GC_Tp& __val) { new(__p) GC_Tp(__val); } void destroy(pointer __p) { __p->~GC_Tp(); } }; template<> class gc_allocator_ignore_off_page { typedef size_t size_type; typedef ptrdiff_t difference_type; typedef void* pointer; typedef const void* const_pointer; typedef void value_type; template struct rebind { typedef gc_allocator_ignore_off_page other; }; }; template inline bool operator==(const gc_allocator_ignore_off_page&, const gc_allocator_ignore_off_page&) { return true; } template inline bool operator!=(const gc_allocator_ignore_off_page&, const gc_allocator_ignore_off_page&) { return false; } /* * And the public traceable_allocator class. */ // Note that we currently don't specialize the pointer-free case, since a // pointer-free traceable container doesn't make that much sense, // though it could become an issue due to abstraction boundaries. template class traceable_allocator { public: typedef size_t size_type; typedef ptrdiff_t difference_type; typedef GC_Tp* pointer; typedef const GC_Tp* const_pointer; typedef GC_Tp& reference; typedef const GC_Tp& const_reference; typedef GC_Tp value_type; template struct rebind { typedef traceable_allocator other; }; traceable_allocator() throw() {} traceable_allocator(const traceable_allocator&) throw() {} # if !(GC_NO_MEMBER_TEMPLATES || 0 < _MSC_VER && _MSC_VER <= 1200) // MSVC++ 6.0 do not support member templates template traceable_allocator (const traceable_allocator&) throw() {} # endif ~traceable_allocator() throw() {} pointer address(reference GC_x) const { return &GC_x; } const_pointer address(const_reference GC_x) const { return &GC_x; } // GC_n is permitted to be 0. The C++ standard says nothing about what // the return value is when GC_n == 0. GC_Tp* allocate(size_type GC_n, const void* = 0) { return static_cast(GC_MALLOC_UNCOLLECTABLE(GC_n * sizeof(GC_Tp))); } // __p is not permitted to be a null pointer. void deallocate(pointer __p, size_type GC_ATTR_UNUSED GC_n) { GC_FREE(__p); } size_type max_size() const throw() { return size_t(-1) / sizeof(GC_Tp); } void construct(pointer __p, const GC_Tp& __val) { new(__p) GC_Tp(__val); } void destroy(pointer __p) { __p->~GC_Tp(); } }; template<> class traceable_allocator { typedef size_t size_type; typedef ptrdiff_t difference_type; typedef void* pointer; typedef const void* const_pointer; typedef void value_type; template struct rebind { typedef traceable_allocator other; }; }; template inline bool operator==(const traceable_allocator&, const traceable_allocator&) { return true; } template inline bool operator!=(const traceable_allocator&, const traceable_allocator&) { return false; } #endif /* GC_ALLOCATOR_H */ ecl-16.1.2/src/bdwgc/include/gc_backptr.h000066400000000000000000000100641266352375300201310ustar00rootroot00000000000000/* * Copyright (c) 1994 by Xerox Corporation. All rights reserved. * Copyright (c) 1996 by Silicon Graphics. All rights reserved. * Copyright (c) 1998 by Fergus Henderson. All rights reserved. * Copyright (c) 2000-2009 by Hewlett-Packard Development Company. * All rights reserved. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. */ /* * This is a simple API to implement pointer back tracing, i.e. * to answer questions such as "who is pointing to this" or * "why is this object being retained by the collector" * * This API assumes that we have an ANSI C compiler. * * Most of these calls yield useful information on only after * a garbage collection. Usually the client will first force * a full collection and then gather information, preferably * before much intervening allocation. * * The implementation of the interface is only about 99.9999% * correct. It is intended to be good enough for profiling, * but is not intended to be used with production code. * * Results are likely to be much more useful if all allocation is * accomplished through the debugging allocators. * * The implementation idea is due to A. Demers. */ #ifndef GC_BACKPTR_H #define GC_BACKPTR_H #ifndef GC_H # include "gc.h" #endif #ifdef __cplusplus extern "C" { #endif /* Store information about the object referencing dest in *base_p */ /* and *offset_p. */ /* If multiple objects or roots point to dest, the one reported */ /* will be the last on used by the garbage collector to trace the */ /* object. */ /* source is root ==> *base_p = address, *offset_p = 0 */ /* source is heap object ==> *base_p != 0, *offset_p = offset */ /* Returns 1 on success, 0 if source couldn't be determined. */ /* Dest can be any address within a heap object. */ typedef enum { GC_UNREFERENCED, /* No reference info available. */ GC_NO_SPACE, /* Dest not allocated with debug alloc. */ GC_REFD_FROM_ROOT, /* Referenced directly by root *base_p. */ GC_REFD_FROM_REG, /* Referenced from a register, i.e. */ /* a root without an address. */ GC_REFD_FROM_HEAP, /* Referenced from another heap obj. */ GC_FINALIZER_REFD /* Finalizable and hence accessible. */ } GC_ref_kind; GC_API GC_ref_kind GC_CALL GC_get_back_ptr_info(void * /* dest */, void ** /* base_p */, size_t * /* offset_p */) GC_ATTR_NONNULL(1); /* Generate a random heap address. */ /* The resulting address is in the heap, but */ /* not necessarily inside a valid object. */ GC_API void * GC_CALL GC_generate_random_heap_address(void); /* Generate a random address inside a valid marked heap object. */ GC_API void * GC_CALL GC_generate_random_valid_address(void); /* Force a garbage collection and generate a backtrace from a */ /* random heap address. */ /* This uses the GC logging mechanism (GC_printf) to produce */ /* output. It can often be called from a debugger. The */ /* source in dbg_mlc.c also serves as a sample client. */ GC_API void GC_CALL GC_generate_random_backtrace(void); /* Print a backtrace from a specific address. Used by the */ /* above. The client should call GC_gcollect() immediately */ /* before invocation. */ GC_API void GC_CALL GC_print_backtrace(void *) GC_ATTR_NONNULL(1); #ifdef __cplusplus } /* end of extern "C" */ #endif #endif /* GC_BACKPTR_H */ ecl-16.1.2/src/bdwgc/include/gc_config_macros.h000066400000000000000000000324201266352375300213140ustar00rootroot00000000000000/* * Copyright (c) 1994 by Xerox Corporation. All rights reserved. * Copyright (c) 1996 by Silicon Graphics. All rights reserved. * Copyright (c) 1998 by Fergus Henderson. All rights reserved. * Copyright (c) 2000-2009 by Hewlett-Packard Development Company. * All rights reserved. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. */ /* This should never be included directly; it is included only from gc.h. */ /* We separate it only to make gc.h more suitable as documentation. */ #if defined(GC_H) /* Some tests for old macros. These violate our namespace rules and */ /* will disappear shortly. Use the GC_ names. */ #if defined(SOLARIS_THREADS) || defined(_SOLARIS_THREADS) \ || defined(_SOLARIS_PTHREADS) || defined(GC_SOLARIS_PTHREADS) /* We no longer support old style Solaris threads. */ /* GC_SOLARIS_THREADS now means pthreads. */ # ifndef GC_SOLARIS_THREADS # define GC_SOLARIS_THREADS # endif #endif #if defined(IRIX_THREADS) # define GC_IRIX_THREADS #endif #if defined(DGUX_THREADS) && !defined(GC_DGUX386_THREADS) # define GC_DGUX386_THREADS #endif #if defined(AIX_THREADS) # define GC_AIX_THREADS #endif #if defined(HPUX_THREADS) # define GC_HPUX_THREADS #endif #if defined(OSF1_THREADS) # define GC_OSF1_THREADS #endif #if defined(LINUX_THREADS) # define GC_LINUX_THREADS #endif #if defined(WIN32_THREADS) # define GC_WIN32_THREADS #endif #if defined(RTEMS_THREADS) # define GC_RTEMS_PTHREADS #endif #if defined(USE_LD_WRAP) # define GC_USE_LD_WRAP #endif #if defined(GC_WIN32_PTHREADS) && !defined(GC_WIN32_THREADS) /* Using pthreads-win32 library (or other Win32 implementation). */ # define GC_WIN32_THREADS #endif #if defined(GC_AIX_THREADS) || defined(GC_DARWIN_THREADS) \ || defined(GC_DGUX386_THREADS) || defined(GC_FREEBSD_THREADS) \ || defined(GC_GNU_THREADS) || defined(GC_HPUX_THREADS) \ || defined(GC_IRIX_THREADS) || defined(GC_LINUX_THREADS) \ || defined(GC_NETBSD_THREADS) || defined(GC_OPENBSD_THREADS) \ || defined(GC_OSF1_THREADS) || defined(GC_SOLARIS_THREADS) \ || defined(GC_WIN32_THREADS) || defined(GC_RTEMS_PTHREADS) # ifndef GC_THREADS # define GC_THREADS # endif #elif defined(GC_THREADS) # if defined(__linux__) # define GC_LINUX_THREADS # endif # if !defined(__linux__) && (defined(_PA_RISC1_1) || defined(_PA_RISC2_0) \ || defined(hppa) || defined(__HPPA)) \ || (defined(__ia64) && defined(_HPUX_SOURCE)) # define GC_HPUX_THREADS # endif # if !defined(__linux__) && (defined(__alpha) || defined(__alpha__)) # define GC_OSF1_THREADS # endif # if defined(__mips) && !defined(__linux__) # define GC_IRIX_THREADS # endif # if defined(__sparc) && !defined(__linux__) \ || defined(sun) && (defined(i386) || defined(__i386__) \ || defined(__amd64__)) # define GC_SOLARIS_THREADS # elif defined(__APPLE__) && defined(__MACH__) # define GC_DARWIN_THREADS # elif defined(__OpenBSD__) # define GC_OPENBSD_THREADS # elif !defined(GC_LINUX_THREADS) && !defined(GC_HPUX_THREADS) \ && !defined(GC_OSF1_THREADS) && !defined(GC_IRIX_THREADS) /* FIXME: Should we really need for FreeBSD and NetBSD to check */ /* that no other GC_xxx_THREADS macro is set? */ # if defined(__FreeBSD__) || defined(__DragonFly__) # define GC_FREEBSD_THREADS # elif defined(__NetBSD__) # define GC_NETBSD_THREADS # endif # endif # if defined(DGUX) && (defined(i386) || defined(__i386__)) # define GC_DGUX386_THREADS # endif # if defined(_AIX) # define GC_AIX_THREADS # endif # if (defined(_WIN32) || defined(_MSC_VER) || defined(__BORLANDC__) \ || defined(__CYGWIN32__) || defined(__CYGWIN__) || defined(__CEGCC__) \ || defined(_WIN32_WCE) || defined(__MINGW32__)) \ && !defined(GC_WIN32_THREADS) /* Either posix or native Win32 threads. */ # define GC_WIN32_THREADS # endif # if defined(__rtems__) && (defined(i386) || defined(__i386__)) # define GC_RTEMS_PTHREADS # endif #endif /* GC_THREADS */ #undef GC_PTHREADS #if (!defined(GC_WIN32_THREADS) || defined(GC_WIN32_PTHREADS) \ || defined(__CYGWIN32__) || defined(__CYGWIN__)) && defined(GC_THREADS) /* Posix threads. */ # define GC_PTHREADS #endif #if !defined(_PTHREADS) && defined(GC_NETBSD_THREADS) # define _PTHREADS #endif #if defined(GC_DGUX386_THREADS) && !defined(_POSIX4A_DRAFT10_SOURCE) # define _POSIX4A_DRAFT10_SOURCE 1 #endif #if !defined(_REENTRANT) && defined(GC_PTHREADS) && !defined(GC_WIN32_THREADS) /* Better late than never. This fails if system headers that depend */ /* on this were previously included. */ # define _REENTRANT #endif #define __GC #if !defined(_WIN32_WCE) || defined(__GNUC__) # include # if defined(__MINGW32__) && !defined(_WIN32_WCE) # include /* We mention uintptr_t. */ /* Perhaps this should be included in pure msft environments */ /* as well? */ # endif #else /* _WIN32_WCE */ /* Yet more kludges for WinCE. */ # include /* size_t is defined here */ # ifndef _PTRDIFF_T_DEFINED /* ptrdiff_t is not defined */ # define _PTRDIFF_T_DEFINED typedef long ptrdiff_t; # endif #endif /* _WIN32_WCE */ #if !defined(GC_NOT_DLL) && !defined(GC_DLL) \ && ((defined(_DLL) && !defined(__GNUC__)) \ || (defined(DLL_EXPORT) && defined(GC_BUILD))) # define GC_DLL #endif #if defined(GC_DLL) && !defined(GC_API) # if defined(__MINGW32__) || defined(__CEGCC__) # ifdef GC_BUILD # define GC_API __declspec(dllexport) # else # define GC_API __declspec(dllimport) # endif # elif defined(_MSC_VER) || defined(__DMC__) || defined(__BORLANDC__) \ || defined(__CYGWIN__) # ifdef GC_BUILD # define GC_API extern __declspec(dllexport) # else # define GC_API __declspec(dllimport) # endif # elif defined(__WATCOMC__) # ifdef GC_BUILD # define GC_API extern __declspec(dllexport) # else # define GC_API extern __declspec(dllimport) # endif # elif defined(__SYMBIAN32__) # ifdef GC_BUILD # define GC_API extern EXPORT_C # else # define GC_API extern IMPORT_C # endif # elif defined(__GNUC__) /* Only matters if used in conjunction with -fvisibility=hidden option. */ # if defined(GC_BUILD) && (__GNUC__ >= 4 \ || defined(GC_VISIBILITY_HIDDEN_SET)) # define GC_API extern __attribute__((__visibility__("default"))) # endif # endif #endif /* GC_DLL */ #ifndef GC_API # define GC_API extern #endif #ifndef GC_CALL # define GC_CALL #endif #ifndef GC_CALLBACK # define GC_CALLBACK GC_CALL #endif #ifndef GC_ATTR_MALLOC /* 'malloc' attribute should be used for all malloc-like functions */ /* (to tell the compiler that a function may be treated as if any */ /* non-NULL pointer it returns cannot alias any other pointer valid */ /* when the function returns). If the client code violates this rule */ /* by using custom GC_oom_func then define GC_OOM_FUNC_RETURNS_ALIAS. */ # ifdef GC_OOM_FUNC_RETURNS_ALIAS # define GC_ATTR_MALLOC /* empty */ # elif defined(__GNUC__) && (__GNUC__ > 3 \ || (__GNUC__ == 3 && __GNUC_MINOR__ >= 1)) # define GC_ATTR_MALLOC __attribute__((__malloc__)) # elif defined(_MSC_VER) && _MSC_VER >= 14 # define GC_ATTR_MALLOC __declspec(noalias) __declspec(restrict) # else # define GC_ATTR_MALLOC # endif #endif #ifndef GC_ATTR_ALLOC_SIZE /* 'alloc_size' attribute improves __builtin_object_size correctness. */ /* Only single-argument form of 'alloc_size' attribute is used. */ # ifdef __clang__ # if __has_attribute(__alloc_size__) # define GC_ATTR_ALLOC_SIZE(argnum) __attribute__((__alloc_size__(argnum))) # else # define GC_ATTR_ALLOC_SIZE(argnum) /* empty */ # endif # elif __GNUC__ > 4 \ || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3 && !defined(__ICC)) # define GC_ATTR_ALLOC_SIZE(argnum) __attribute__((__alloc_size__(argnum))) # else # define GC_ATTR_ALLOC_SIZE(argnum) /* empty */ # endif #endif #ifndef GC_ATTR_NONNULL # if defined(__GNUC__) && __GNUC__ >= 4 # define GC_ATTR_NONNULL(argnum) __attribute__((__nonnull__(argnum))) # else # define GC_ATTR_NONNULL(argnum) /* empty */ # endif #endif #ifndef GC_ATTR_DEPRECATED # ifdef GC_BUILD # undef GC_ATTR_DEPRECATED # define GC_ATTR_DEPRECATED /* empty */ # elif defined(__GNUC__) && __GNUC__ >= 4 # define GC_ATTR_DEPRECATED __attribute__((__deprecated__)) # elif defined(_MSC_VER) && _MSC_VER >= 12 # define GC_ATTR_DEPRECATED __declspec(deprecated) # else # define GC_ATTR_DEPRECATED /* empty */ # endif #endif #if defined(__sgi) && !defined(__GNUC__) && _COMPILER_VERSION >= 720 # define GC_ADD_CALLER # define GC_RETURN_ADDR (GC_word)__return_address #endif #if defined(__linux__) || defined(__GLIBC__) # if !defined(__native_client__) # include # endif # if (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 1 || __GLIBC__ > 2) \ && !defined(__ia64__) && !defined(__UCLIBC__) \ && !defined(GC_HAVE_BUILTIN_BACKTRACE) # define GC_HAVE_BUILTIN_BACKTRACE # endif # if defined(__i386__) || defined(__amd64__) || defined(__x86_64__) # define GC_CAN_SAVE_CALL_STACKS # endif #endif /* GLIBC */ #if defined(_MSC_VER) && _MSC_VER >= 1200 /* version 12.0+ (MSVC 6.0+) */ \ && !defined(_AMD64_) && !defined(_M_X64) && !defined(_WIN32_WCE) \ && !defined(GC_HAVE_NO_BUILTIN_BACKTRACE) \ && !defined(GC_HAVE_BUILTIN_BACKTRACE) # define GC_HAVE_BUILTIN_BACKTRACE #endif #if defined(GC_HAVE_BUILTIN_BACKTRACE) && !defined(GC_CAN_SAVE_CALL_STACKS) # define GC_CAN_SAVE_CALL_STACKS #endif #if defined(__sparc__) # define GC_CAN_SAVE_CALL_STACKS #endif /* If we're on a platform on which we can't save call stacks, but */ /* gcc is normally used, we go ahead and define GC_ADD_CALLER. */ /* We make this decision independent of whether gcc is actually being */ /* used, in order to keep the interface consistent, and allow mixing */ /* of compilers. */ /* This may also be desirable if it is possible but expensive to */ /* retrieve the call chain. */ #if (defined(__linux__) || defined(__NetBSD__) || defined(__OpenBSD__) \ || defined(__FreeBSD__) || defined(__DragonFly__) \ || defined(PLATFORM_ANDROID) || defined(__ANDROID__)) \ && !defined(GC_CAN_SAVE_CALL_STACKS) # define GC_ADD_CALLER # if __GNUC__ >= 3 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95) /* gcc knows how to retrieve return address, but we don't know */ /* how to generate call stacks. */ # define GC_RETURN_ADDR (GC_word)__builtin_return_address(0) # if (__GNUC__ >= 4) && (defined(__i386__) || defined(__amd64__) \ || defined(__x86_64__) /* and probably others... */) # define GC_RETURN_ADDR_PARENT \ (GC_word)__builtin_extract_return_addr(__builtin_return_address(1)) # endif # else /* Just pass 0 for gcc compatibility. */ # define GC_RETURN_ADDR 0 # endif #endif /* !GC_CAN_SAVE_CALL_STACKS */ #ifdef GC_PTHREADS # if (defined(GC_DARWIN_THREADS) || defined(GC_WIN32_PTHREADS) \ || defined(__native_client__) || defined(GC_RTEMS_PTHREADS)) \ && !defined(GC_NO_DLOPEN) /* Either there is no dlopen() or we do not need to intercept it. */ # define GC_NO_DLOPEN # endif # if (defined(GC_DARWIN_THREADS) || defined(GC_WIN32_PTHREADS) \ || defined(GC_OPENBSD_THREADS) || defined(__native_client__)) \ && !defined(GC_NO_PTHREAD_SIGMASK) /* Either there is no pthread_sigmask() or no need to intercept it. */ # define GC_NO_PTHREAD_SIGMASK # endif # if defined(__native_client__) /* At present, NaCl pthread_create() prototype does not have */ /* "const" for its "attr" argument; also, NaCl pthread_exit() one */ /* does not have "noreturn" attribute. */ # ifndef GC_PTHREAD_CREATE_CONST # define GC_PTHREAD_CREATE_CONST /* empty */ # endif # ifndef GC_PTHREAD_EXIT_ATTRIBUTE # define GC_PTHREAD_EXIT_ATTRIBUTE /* empty */ # endif # endif # if !defined(GC_PTHREAD_EXIT_ATTRIBUTE) \ && !defined(PLATFORM_ANDROID) && !defined(__ANDROID__) \ && (defined(GC_LINUX_THREADS) || defined(GC_SOLARIS_THREADS)) /* Intercept pthread_exit on Linux and Solaris. */ # if defined(__GNUC__) /* since GCC v2.7 */ # define GC_PTHREAD_EXIT_ATTRIBUTE __attribute__((__noreturn__)) # elif defined(__NORETURN) /* used in Solaris */ # define GC_PTHREAD_EXIT_ATTRIBUTE __NORETURN # else # define GC_PTHREAD_EXIT_ATTRIBUTE /* empty */ # endif # endif # if (!defined(GC_PTHREAD_EXIT_ATTRIBUTE) || defined(__native_client__)) \ && !defined(GC_NO_PTHREAD_CANCEL) /* Either there is no pthread_cancel() or no need to intercept it. */ # define GC_NO_PTHREAD_CANCEL # endif #endif /* GC_PTHREADS */ #endif ecl-16.1.2/src/bdwgc/include/gc_cpp.h000066400000000000000000000342001266352375300172630ustar00rootroot00000000000000/* * Copyright (c) 1994 by Xerox Corporation. All rights reserved. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program for any * purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is * granted, provided the above notices are retained, and a notice that * the code was modified is included with the above copyright notice. */ #ifndef GC_CPP_H #define GC_CPP_H /**************************************************************************** C++ Interface to the Boehm Collector John R. Ellis and Jesse Hull This interface provides access to the Boehm collector. It provides basic facilities similar to those described in "Safe, Efficient Garbage Collection for C++", by John R. Ellis and David L. Detlefs (ftp://ftp.parc.xerox.com/pub/ellis/gc). All heap-allocated objects are either "collectible" or "uncollectible". Programs must explicitly delete uncollectible objects, whereas the garbage collector will automatically delete collectible objects when it discovers them to be inaccessible. Collectible objects may freely point at uncollectible objects and vice versa. Objects allocated with the built-in "::operator new" are uncollectible. Objects derived from class "gc" are collectible. For example: class A: public gc {...}; A* a = new A; // a is collectible. Collectible instances of non-class types can be allocated using the GC (or UseGC) placement: typedef int A[ 10 ]; A* a = new (GC) A; Uncollectible instances of classes derived from "gc" can be allocated using the NoGC placement: class A: public gc {...}; A* a = new (NoGC) A; // a is uncollectible. The new(PointerFreeGC) syntax allows the allocation of collectible objects that are not scanned by the collector. This useful if you are allocating compressed data, bitmaps, or network packets. (In the latter case, it may remove danger of unfriendly network packets intentionally containing values that cause spurious memory retention.) Both uncollectible and collectible objects can be explicitly deleted with "delete", which invokes an object's destructors and frees its storage immediately. A collectible object may have a clean-up function, which will be invoked when the collector discovers the object to be inaccessible. An object derived from "gc_cleanup" or containing a member derived from "gc_cleanup" has a default clean-up function that invokes the object's destructors. Explicit clean-up functions may be specified as an additional placement argument: A* a = ::new (GC, MyCleanup) A; An object is considered "accessible" by the collector if it can be reached by a path of pointers from static variables, automatic variables of active functions, or from some object with clean-up enabled; pointers from an object to itself are ignored. Thus, if objects A and B both have clean-up functions, and A points at B, B is considered accessible. After A's clean-up is invoked and its storage released, B will then become inaccessible and will have its clean-up invoked. If A points at B and B points to A, forming a cycle, then that's considered a storage leak, and neither will be collectible. See the interface gc.h for low-level facilities for handling such cycles of objects with clean-up. The collector cannot guarantee that it will find all inaccessible objects. In practice, it finds almost all of them. Cautions: 1. Be sure the collector has been augmented with "make c++" or "--enable-cplusplus". 2. If your compiler supports the new "operator new[]" syntax, then add -DGC_OPERATOR_NEW_ARRAY to the Makefile. If your compiler doesn't support "operator new[]", beware that an array of type T, where T is derived from "gc", may or may not be allocated as a collectible object (it depends on the compiler). Use the explicit GC placement to make the array collectible. For example: class A: public gc {...}; A* a1 = new A[ 10 ]; // collectible or uncollectible? A* a2 = new (GC) A[ 10 ]; // collectible. 3. The destructors of collectible arrays of objects derived from "gc_cleanup" will not be invoked properly. For example: class A: public gc_cleanup {...}; A* a = new (GC) A[ 10 ]; // destructors not invoked correctly Typically, only the destructor for the first element of the array will be invoked when the array is garbage-collected. To get all the destructors of any array executed, you must supply an explicit clean-up function: A* a = new (GC, MyCleanUp) A[ 10 ]; (Implementing clean-up of arrays correctly, portably, and in a way that preserves the correct exception semantics requires a language extension, e.g. the "gc" keyword.) 4. Compiler bugs (now hopefully history): * Solaris 2's CC (SC3.0) doesn't implement t->~T() correctly, so the destructors of classes derived from gc_cleanup won't be invoked. You'll have to explicitly register a clean-up function with new-placement syntax. * Evidently cfront 3.0 does not allow destructors to be explicitly invoked using the ANSI-conforming syntax t->~T(). If you're using cfront 3.0, you'll have to comment out the class gc_cleanup, which uses explicit invocation. 5. GC name conflicts: Many other systems seem to use the identifier "GC" as an abbreviation for "Graphics Context". Since version 5.0, GC placement has been replaced by UseGC. GC is an alias for UseGC, unless GC_NAME_CONFLICT is defined. ****************************************************************************/ #include "gc.h" #ifdef GC_NAMESPACE # define GC_NS_QUALIFY(T) boehmgc::T #else # define GC_NS_QUALIFY(T) T #endif #ifndef THINK_CPLUS # define GC_cdecl GC_CALLBACK #else # define GC_cdecl _cdecl #endif #if ! defined( GC_NO_OPERATOR_NEW_ARRAY ) \ && !defined(_ENABLE_ARRAYNEW) /* Digimars */ \ && (defined(__BORLANDC__) && (__BORLANDC__ < 0x450) \ || (defined(__GNUC__) && \ (__GNUC__ < 2 || __GNUC__ == 2 && __GNUC_MINOR__ < 6)) \ || (defined(_MSC_VER) && _MSC_VER <= 1020) \ || (defined(__WATCOMC__) && __WATCOMC__ < 1050)) # define GC_NO_OPERATOR_NEW_ARRAY #endif #if !defined(GC_NO_OPERATOR_NEW_ARRAY) && !defined(GC_OPERATOR_NEW_ARRAY) # define GC_OPERATOR_NEW_ARRAY #endif #if (!defined(__BORLANDC__) || __BORLANDC__ > 0x0620) \ && ! defined ( __sgi ) && ! defined( __WATCOMC__ ) \ && (!defined(_MSC_VER) || _MSC_VER > 1020) # define GC_PLACEMENT_DELETE #endif #ifdef GC_NAMESPACE namespace boehmgc { #endif enum GCPlacement { UseGC, # ifndef GC_NAME_CONFLICT GC=UseGC, # endif NoGC, PointerFreeGC }; class gc { public: inline void* operator new( size_t size ); inline void* operator new( size_t size, GCPlacement gcp ); inline void* operator new( size_t size, void *p ); /* Must be redefined here, since the other overloadings */ /* hide the global definition. */ inline void operator delete( void* obj ); # ifdef GC_PLACEMENT_DELETE inline void operator delete( void*, GCPlacement ); /* called if construction fails. */ inline void operator delete( void*, void* ); # endif #ifdef GC_OPERATOR_NEW_ARRAY inline void* operator new[]( size_t size ); inline void* operator new[]( size_t size, GCPlacement gcp ); inline void* operator new[]( size_t size, void *p ); inline void operator delete[]( void* obj ); # ifdef GC_PLACEMENT_DELETE inline void operator delete[]( void*, GCPlacement ); inline void operator delete[]( void*, void* ); # endif #endif /* GC_OPERATOR_NEW_ARRAY */ }; /* Instances of classes derived from "gc" will be allocated in the collected heap by default, unless an explicit NoGC placement is specified. */ class gc_cleanup: virtual public gc { public: inline gc_cleanup(); inline virtual ~gc_cleanup(); private: inline static void GC_cdecl cleanup( void* obj, void* clientData ); }; /* Instances of classes derived from "gc_cleanup" will be allocated in the collected heap by default. When the collector discovers an inaccessible object derived from "gc_cleanup" or containing a member derived from "gc_cleanup", its destructors will be invoked. */ extern "C" { typedef void (GC_CALLBACK * GCCleanUpFunc)( void* obj, void* clientData ); } #ifdef GC_NAMESPACE } #endif #ifdef _MSC_VER // Disable warning that "no matching operator delete found; memory will // not be freed if initialization throws an exception" # pragma warning(disable:4291) #endif inline void* operator new( size_t size, GC_NS_QUALIFY(GCPlacement) gcp, GC_NS_QUALIFY(GCCleanUpFunc) cleanup = 0, void* clientData = 0 ); /* Allocates a collectible or uncollectible object, according to the value of "gcp". For collectible objects, if "cleanup" is non-null, then when the allocated object "obj" becomes inaccessible, the collector will invoke the function "cleanup( obj, clientData )" but will not invoke the object's destructors. It is an error to explicitly delete an object allocated with a non-null "cleanup". It is an error to specify a non-null "cleanup" with NoGC or for classes derived from "gc_cleanup" or containing members derived from "gc_cleanup". */ #ifdef GC_PLACEMENT_DELETE inline void operator delete( void*, GC_NS_QUALIFY(GCPlacement), GC_NS_QUALIFY(GCCleanUpFunc), void * ); #endif #ifdef _MSC_VER /** This ensures that the system default operator new[] doesn't get * undefined, which is what seems to happen on VC++ 6 for some reason * if we define a multi-argument operator new[]. * There seems to be no way to redirect new in this environment without * including this everywhere. */ # if _MSC_VER > 1020 void *operator new[]( size_t size ); void operator delete[]( void* obj ); # endif void* operator new( size_t size ); void operator delete( void* obj ); // This new operator is used by VC++ in case of Debug builds ! void* operator new( size_t size, int /* nBlockUse */, const char * szFileName, int nLine ); #endif /* _MSC_VER */ #ifdef GC_OPERATOR_NEW_ARRAY inline void* operator new[]( size_t size, GC_NS_QUALIFY(GCPlacement) gcp, GC_NS_QUALIFY(GCCleanUpFunc) cleanup = 0, void* clientData = 0 ); /* The operator new for arrays, identical to the above. */ #endif /* GC_OPERATOR_NEW_ARRAY */ /**************************************************************************** Inline implementation ****************************************************************************/ #ifdef GC_NAMESPACE namespace boehmgc { #endif inline void* gc::operator new( size_t size ) { return GC_MALLOC( size ); } inline void* gc::operator new( size_t size, GCPlacement gcp ) { if (gcp == UseGC) return GC_MALLOC( size ); else if (gcp == PointerFreeGC) return GC_MALLOC_ATOMIC( size ); else return GC_MALLOC_UNCOLLECTABLE( size ); } inline void* gc::operator new( size_t /* size */, void *p ) { return p; } inline void gc::operator delete( void* obj ) { GC_FREE( obj ); } #ifdef GC_PLACEMENT_DELETE inline void gc::operator delete( void*, void* ) {} inline void gc::operator delete( void* p, GCPlacement /* gcp */ ) { GC_FREE(p); } #endif #ifdef GC_OPERATOR_NEW_ARRAY inline void* gc::operator new[]( size_t size ) { return gc::operator new( size ); } inline void* gc::operator new[]( size_t size, GCPlacement gcp ) { return gc::operator new( size, gcp ); } inline void* gc::operator new[]( size_t /* size */, void *p ) { return p; } inline void gc::operator delete[]( void* obj ) { gc::operator delete( obj ); } # ifdef GC_PLACEMENT_DELETE inline void gc::operator delete[]( void*, void* ) {} inline void gc::operator delete[]( void* p, GCPlacement /* gcp */ ) { gc::operator delete(p); } # endif #endif /* GC_OPERATOR_NEW_ARRAY */ inline gc_cleanup::~gc_cleanup() { GC_register_finalizer_ignore_self( GC_base(this), 0, 0, 0, 0 ); } inline void GC_CALLBACK gc_cleanup::cleanup( void* obj, void* displ ) { ((gc_cleanup*) ((char*) obj + (ptrdiff_t) displ))->~gc_cleanup(); } inline gc_cleanup::gc_cleanup() { GC_finalization_proc oldProc; void* oldData; void* base = GC_base( (void *) this ); if (0 != base) { // Don't call the debug version, since this is a real base address. GC_register_finalizer_ignore_self( base, (GC_finalization_proc)cleanup, (void*)((char*)this - (char*)base), &oldProc, &oldData ); if (0 != oldProc) { GC_register_finalizer_ignore_self( base, oldProc, oldData, 0, 0 ); } } } #ifdef GC_NAMESPACE } #endif inline void* operator new( size_t size, GC_NS_QUALIFY(GCPlacement) gcp, GC_NS_QUALIFY(GCCleanUpFunc) cleanup, void* clientData ) { void* obj; if (gcp == GC_NS_QUALIFY(UseGC)) { obj = GC_MALLOC( size ); if (cleanup != 0) GC_REGISTER_FINALIZER_IGNORE_SELF( obj, cleanup, clientData, 0, 0 ); } else if (gcp == GC_NS_QUALIFY(PointerFreeGC)) { obj = GC_MALLOC_ATOMIC( size ); } else { obj = GC_MALLOC_UNCOLLECTABLE( size ); }; return obj; } #ifdef GC_PLACEMENT_DELETE inline void operator delete( void *p, GC_NS_QUALIFY(GCPlacement) /* gcp */, GC_NS_QUALIFY(GCCleanUpFunc) /* cleanup */, void* /* clientData */ ) { GC_FREE(p); } #endif /* GC_PLACEMENT_DELETE */ #ifdef GC_OPERATOR_NEW_ARRAY inline void* operator new[]( size_t size, GC_NS_QUALIFY(GCPlacement) gcp, GC_NS_QUALIFY(GCCleanUpFunc) cleanup, void* clientData ) { return ::operator new( size, gcp, cleanup, clientData ); } #endif /* GC_OPERATOR_NEW_ARRAY */ #if defined(__CYGWIN__) # include // for delete throw() inline void operator delete(void *p) { GC_FREE(p); } #endif #endif /* GC_CPP_H */ ecl-16.1.2/src/bdwgc/include/gc_disclaim.h000066400000000000000000000046571266352375300203030ustar00rootroot00000000000000/* * Copyright (c) 2007-2011 by Hewlett-Packard Company. All rights reserved. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. * */ #ifndef GC_DISCLAIM_H #define GC_DISCLAIM_H #include "gc.h" /* This API is defined only if the library has been suitably compiled */ /* (i.e. with ENABLE_DISCLAIM defined). */ /* Prepare the object kind used by GC_finalized_malloc. Call it from */ /* your initialization code or, at least, at some point before using */ /* finalized allocations. The function is thread-safe. */ GC_API void GC_CALL GC_init_finalized_malloc(void); /* Type of a disclaim call-back. */ typedef int (GC_CALLBACK * GC_disclaim_proc)(void * /*obj*/); /* Register "proc" to be called on each object of "kind" ready to be */ /* reclaimed. If "proc" returns non-zero, the collector will not */ /* reclaim the object on this GC cycle. Objects reachable from "proc" */ /* will be protected from collection if "mark_from_all" is non-zero, */ /* but at the expense that long chains of objects will take many cycles */ /* to reclaim. */ GC_API void GC_CALL GC_register_disclaim_proc(int /*kind*/, GC_disclaim_proc /*proc*/, int /*mark_from_all*/); /* The finalizer closure used by GC_finalized_malloc. */ struct GC_finalizer_closure { GC_finalization_proc proc; void *cd; }; /* Allocate "size" bytes which is finalized by "fc". This uses a */ /* dedicated object kind with a disclaim procedure, and is more */ /* efficient than GC_register_finalizer and friends. */ /* GC_init_finalized_malloc must be called before using this. */ GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1) void * GC_CALL GC_finalized_malloc(size_t /*size*/, const struct GC_finalizer_closure * /*fc*/); #endif ecl-16.1.2/src/bdwgc/include/gc_gcj.h000066400000000000000000000122161266352375300172470ustar00rootroot00000000000000/* * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers * Copyright (c) 1991-1995 by Xerox Corporation. All rights reserved. * Copyright 1996-1999 by Silicon Graphics. All rights reserved. * Copyright 1999 by Hewlett-Packard Company. All rights reserved. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. */ /* This file assumes the collector has been compiled with GC_GCJ_SUPPORT. */ /* * We allocate objects whose first word contains a pointer to a struct * describing the object type. This struct contains a garbage collector mark * descriptor at offset MARK_DESCR_OFFSET. Alternatively, the objects * may be marked by the mark procedure passed to GC_init_gcj_malloc. */ #ifndef GC_GCJ_H #define GC_GCJ_H /* Gcj keeps GC descriptor as second word of vtable. This */ /* probably needs to be adjusted for other clients. */ /* We currently assume that this offset is such that: */ /* - all objects of this kind are large enough to have */ /* a value at that offset, and */ /* - it is not zero. */ /* These assumptions allow objects on the free list to be */ /* marked normally. */ #ifndef GC_H # include "gc.h" #endif #ifdef __cplusplus extern "C" { #endif /* The following allocators signal an out of memory condition with */ /* return GC_oom_fn(bytes); */ /* The following function must be called before the gcj allocators */ /* can be invoked. */ /* mp_index and mp are the index and mark_proc (see gc_mark.h) */ /* respectively for the allocated objects. Mark_proc will be */ /* used to build the descriptor for objects allocated through the */ /* debugging interface. The mark_proc will be invoked on all such */ /* objects with an "environment" value of 1. The client may choose */ /* to use the same mark_proc for some of its generated mark descriptors.*/ /* In that case, it should use a different "environment" value to */ /* detect the presence or absence of the debug header. */ /* Mp is really of type mark_proc, as defined in gc_mark.h. We don't */ /* want to include that here for namespace pollution reasons. */ /* Passing in mp_index here instead of having GC_init_gcj_malloc() */ /* internally call GC_new_proc() is quite ugly, but in typical usage */ /* scenarios a compiler also has to know about mp_index, so */ /* generating it dynamically is not acceptable. Mp_index will */ /* typically be an integer < RESERVED_MARK_PROCS, so that it doesn't */ /* collide with GC_new_proc allocated indices. If the application */ /* needs no other reserved indices, zero */ /* (GC_GCJ_RESERVED_MARK_PROC_INDEX in gc_mark.h) is an obvious choice. */ GC_API void GC_CALL GC_init_gcj_malloc(int /* mp_index */, void * /* really mark_proc */ /* mp */); /* Allocate an object, clear it, and store the pointer to the */ /* type structure (vtable in gcj). */ /* This adds a byte at the end of the object if GC_malloc would.*/ GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1) void * GC_CALL GC_gcj_malloc(size_t /* lb */, void * /* ptr_to_struct_containing_descr */); /* The debug versions allocate such that the specified mark_proc */ /* is always invoked. */ GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1) void * GC_CALL GC_debug_gcj_malloc(size_t /* lb */, void * /* ptr_to_struct_containing_descr */, GC_EXTRA_PARAMS); /* Similar to GC_gcj_malloc, but assumes that a pointer to near the */ /* beginning of the resulting object is always maintained. */ GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1) void * GC_CALL GC_gcj_malloc_ignore_off_page(size_t /* lb */, void * /* ptr_to_struct_containing_descr */); /* The kind numbers of normal and debug gcj objects. */ /* Useful only for debug support, we hope. */ GC_API int GC_gcj_kind; GC_API int GC_gcj_debug_kind; #ifdef GC_DEBUG # define GC_GCJ_MALLOC(s,d) GC_debug_gcj_malloc(s,d,GC_EXTRAS) # define GC_GCJ_MALLOC_IGNORE_OFF_PAGE(s,d) GC_debug_gcj_malloc(s,d,GC_EXTRAS) #else # define GC_GCJ_MALLOC(s,d) GC_gcj_malloc(s,d) # define GC_GCJ_MALLOC_IGNORE_OFF_PAGE(s,d) GC_gcj_malloc_ignore_off_page(s,d) #endif #ifdef __cplusplus } /* end of extern "C" */ #endif #endif /* GC_GCJ_H */ ecl-16.1.2/src/bdwgc/include/gc_inline.h000066400000000000000000000153351266352375300177670ustar00rootroot00000000000000/* * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers * Copyright (c) 1991-1995 by Xerox Corporation. All rights reserved. * Copyright (c) 2005 Hewlett-Packard Development Company, L.P. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. */ #ifndef GC_INLINE_H #define GC_INLINE_H /* WARNING: */ /* Note that for these routines, it is the clients responsibility to */ /* add the extra byte at the end to deal with one-past-the-end pointers.*/ /* In the standard collector configuration, the collector assumes that */ /* such a byte has been added, and hence does not trace the last word */ /* in the resulting object. */ /* This is not an issue if the collector is compiled with */ /* DONT_ADD_BYTE_AT_END, or if GC_all_interior_pointers is not set. */ /* This interface is most useful for compilers that generate C. */ /* It is also used internally for thread-local allocation. */ /* Manual use is hereby discouraged. */ #include "gc.h" #include "gc_tiny_fl.h" #if __GNUC__ >= 3 # define GC_EXPECT(expr, outcome) __builtin_expect(expr,outcome) /* Equivalent to (expr), but predict that usually (expr)==outcome. */ #else # define GC_EXPECT(expr, outcome) (expr) #endif /* __GNUC__ */ #ifndef GC_ASSERT # define GC_ASSERT(expr) /* empty */ #endif /* Store a pointer to a list of newly allocated objects of kind k and */ /* size lb in *result. The caller must make sure that *result is */ /* traced even if objects are ptrfree. */ GC_API void GC_CALL GC_generic_malloc_many(size_t /* lb */, int /* k */, void ** /* result */); /* The ultimately general inline allocation macro. Allocate an object */ /* of size granules, putting the resulting pointer in result. Tiny_fl */ /* is a "tiny" free list array, which will be used first, if the size */ /* is appropriate. If granules is too large, we allocate with */ /* default_expr instead. If we need to refill the free list, we use */ /* GC_generic_malloc_many with the indicated kind. */ /* Tiny_fl should be an array of GC_TINY_FREELISTS void * pointers. */ /* If num_direct is nonzero, and the individual free list pointers */ /* are initialized to (void *)1, then we allocate numdirect granules */ /* directly using gmalloc before putting multiple objects into the */ /* tiny_fl entry. If num_direct is zero, then the free lists may also */ /* be initialized to (void *)0. */ /* Note that we use the zeroth free list to hold objects 1 granule in */ /* size that are used to satisfy size 0 allocation requests. */ /* We rely on much of this hopefully getting optimized away in the */ /* num_direct = 0 case. */ /* Particularly if granules is constant, this should generate a small */ /* amount of code. */ # define GC_FAST_MALLOC_GRANS(result,granules,tiny_fl,num_direct,\ kind,default_expr,init) \ do { \ if (GC_EXPECT((granules) >= GC_TINY_FREELISTS,0)) { \ result = (default_expr); \ } else { \ void **my_fl = (tiny_fl) + (granules); \ void *my_entry=*my_fl; \ void *next; \ \ while (GC_EXPECT((GC_word)my_entry \ <= (num_direct) + GC_TINY_FREELISTS + 1, 0)) { \ /* Entry contains counter or NULL */ \ if ((GC_word)my_entry - 1 < (num_direct)) { \ /* Small counter value, not NULL */ \ *my_fl = (char *)my_entry + (granules) + 1; \ result = (default_expr); \ goto out; \ } else { \ /* Large counter or NULL */ \ GC_generic_malloc_many(((granules) == 0? GC_GRANULE_BYTES : \ GC_RAW_BYTES_FROM_INDEX(granules)), \ kind, my_fl); \ my_entry = *my_fl; \ if (my_entry == 0) { \ result = (*GC_get_oom_fn())((granules)*GC_GRANULE_BYTES); \ goto out; \ } \ } \ } \ next = *(void **)(my_entry); \ result = (void *)my_entry; \ *my_fl = next; \ init; \ PREFETCH_FOR_WRITE(next); \ GC_ASSERT(GC_size(result) >= (granules)*GC_GRANULE_BYTES); \ GC_ASSERT((kind) == PTRFREE || ((GC_word *)result)[1] == 0); \ out: ; \ } \ } while (0) # define GC_WORDS_TO_WHOLE_GRANULES(n) \ GC_WORDS_TO_GRANULES((n) + GC_GRANULE_WORDS - 1) /* Allocate n words (NOT BYTES). X is made to point to the result. */ /* This should really only be used if GC_all_interior_pointers is */ /* not set, or DONT_ADD_BYTE_AT_END is set. See above. */ /* The semantics changed in version 7.0; we no longer lock, and */ /* the caller is responsible for supplying a cleared tiny_fl */ /* free list array. For single-threaded applications, this may be */ /* a global array. */ # define GC_MALLOC_WORDS(result,n,tiny_fl) \ do { \ size_t grans = GC_WORDS_TO_WHOLE_GRANULES(n); \ GC_FAST_MALLOC_GRANS(result, grans, tiny_fl, 0, \ NORMAL, GC_malloc(grans*GC_GRANULE_BYTES), \ *(void **)(result) = 0); \ } while (0) # define GC_MALLOC_ATOMIC_WORDS(result,n,tiny_fl) \ do { \ size_t grans = GC_WORDS_TO_WHOLE_GRANULES(n); \ GC_FAST_MALLOC_GRANS(result, grans, tiny_fl, 0, \ PTRFREE, GC_malloc_atomic(grans*GC_GRANULE_BYTES), \ (void)0 /* no initialization */); \ } while (0) /* And once more for two word initialized objects: */ # define GC_CONS(result, first, second, tiny_fl) \ do { \ size_t grans = GC_WORDS_TO_WHOLE_GRANULES(2); \ GC_FAST_MALLOC_GRANS(result, grans, tiny_fl, 0, \ NORMAL, GC_malloc(grans*GC_GRANULE_BYTES), \ *(void **)(result) = (void *)(first)); \ ((void **)(result))[1] = (void *)(second); \ } while (0) #endif /* !GC_INLINE_H */ ecl-16.1.2/src/bdwgc/include/gc_mark.h000066400000000000000000000406171266352375300174440ustar00rootroot00000000000000/* * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. * Copyright (c) 2001 by Hewlett-Packard Company. All rights reserved. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. * */ /* * This contains interfaces to the GC marker that are likely to be useful to * clients that provide detailed heap layout information to the collector. * This interface should not be used by normal C or C++ clients. * It will be useful to runtimes for other languages. * * This is an experts-only interface! There are many ways to break the * collector in subtle ways by using this functionality. */ #ifndef GC_MARK_H #define GC_MARK_H #ifndef GC_H # include "gc.h" #endif #ifdef __cplusplus extern "C" { #endif /* A client supplied mark procedure. Returns new mark stack pointer. */ /* Primary effect should be to push new entries on the mark stack. */ /* Mark stack pointer values are passed and returned explicitly. */ /* Global variables describing mark stack are not necessarily valid. */ /* (This usually saves a few cycles by keeping things in registers.) */ /* Assumed to scan about GC_PROC_BYTES on average. If it needs to do */ /* much more work than that, it should do it in smaller pieces by */ /* pushing itself back on the mark stack. */ /* Note that it should always do some work (defined as marking some */ /* objects) before pushing more than one entry on the mark stack. */ /* This is required to ensure termination in the event of mark stack */ /* overflows. */ /* This procedure is always called with at least one empty entry on the */ /* mark stack. */ /* Currently we require that mark procedures look for pointers in a */ /* subset of the places the conservative marker would. It must be safe */ /* to invoke the normal mark procedure instead. */ /* WARNING: Such a mark procedure may be invoked on an unused object */ /* residing on a free list. Such objects are cleared, except for a */ /* free list link field in the first word. Thus mark procedures may */ /* not count on the presence of a type descriptor, and must handle this */ /* case correctly somehow. */ #define GC_PROC_BYTES 100 #ifdef GC_BUILD struct GC_ms_entry; #else struct GC_ms_entry { void *opaque; }; #endif typedef struct GC_ms_entry * (*GC_mark_proc)(GC_word * /* addr */, struct GC_ms_entry * /* mark_stack_ptr */, struct GC_ms_entry * /* mark_stack_limit */, GC_word /* env */); #define GC_LOG_MAX_MARK_PROCS 6 #define GC_MAX_MARK_PROCS (1 << GC_LOG_MAX_MARK_PROCS) /* In a few cases it's necessary to assign statically known indices to */ /* certain mark procs. Thus we reserve a few for well known clients. */ /* (This is necessary if mark descriptors are compiler generated.) */ #define GC_RESERVED_MARK_PROCS 8 #define GC_GCJ_RESERVED_MARK_PROC_INDEX 0 /* Object descriptors on mark stack or in objects. Low order two */ /* bits are tags distinguishing among the following 4 possibilities */ /* for the high order 30 bits. */ #define GC_DS_TAG_BITS 2 #define GC_DS_TAGS ((1 << GC_DS_TAG_BITS) - 1) #define GC_DS_LENGTH 0 /* The entire word is a length in bytes that */ /* must be a multiple of 4. */ #define GC_DS_BITMAP 1 /* 30 (62) bits are a bitmap describing pointer */ /* fields. The msb is 1 if the first word */ /* is a pointer. */ /* (This unconventional ordering sometimes */ /* makes the marker slightly faster.) */ /* Zeroes indicate definite nonpointers. Ones */ /* indicate possible pointers. */ /* Only usable if pointers are word aligned. */ #define GC_DS_PROC 2 /* The objects referenced by this object can be */ /* pushed on the mark stack by invoking */ /* PROC(descr). ENV(descr) is passed as the */ /* last argument. */ #define GC_MAKE_PROC(proc_index, env) \ (((((env) << GC_LOG_MAX_MARK_PROCS) \ | (proc_index)) << GC_DS_TAG_BITS) | GC_DS_PROC) #define GC_DS_PER_OBJECT 3 /* The real descriptor is at the */ /* byte displacement from the beginning of the */ /* object given by descr & ~DS_TAGS */ /* If the descriptor is negative, the real */ /* descriptor is at (*) - */ /* (descr & ~DS_TAGS) - GC_INDIR_PER_OBJ_BIAS */ /* The latter alternative can be used if each */ /* object contains a type descriptor in the */ /* first word. */ /* Note that in the multi-threaded environments */ /* per-object descriptors must be located in */ /* either the first two or last two words of */ /* the object, since only those are guaranteed */ /* to be cleared while the allocation lock is */ /* held. */ #define GC_INDIR_PER_OBJ_BIAS 0x10 GC_API void * GC_least_plausible_heap_addr; GC_API void * GC_greatest_plausible_heap_addr; /* Bounds on the heap. Guaranteed valid */ /* Likely to include future heap expansion. */ /* Hence usually includes not-yet-mapped */ /* memory. */ /* Handle nested references in a custom mark procedure. */ /* Check if obj is a valid object. If so, ensure that it is marked. */ /* If it was not previously marked, push its contents onto the mark */ /* stack for future scanning. The object will then be scanned using */ /* its mark descriptor. */ /* Returns the new mark stack pointer. */ /* Handles mark stack overflows correctly. */ /* Since this marks first, it makes progress even if there are mark */ /* stack overflows. */ /* Src is the address of the pointer to obj, which is used only */ /* for back pointer-based heap debugging. */ /* It is strongly recommended that most objects be handled without mark */ /* procedures, e.g. with bitmap descriptors, and that mark procedures */ /* be reserved for exceptional cases. That will ensure that */ /* performance of this call is not extremely performance critical. */ /* (Otherwise we would need to inline GC_mark_and_push completely, */ /* which would tie the client code to a fixed collector version.) */ /* Note that mark procedures should explicitly call FIXUP_POINTER() */ /* if required. */ GC_API struct GC_ms_entry * GC_CALL GC_mark_and_push(void * /* obj */, struct GC_ms_entry * /* mark_stack_ptr */, struct GC_ms_entry * /* mark_stack_limit */, void ** /* src */); #define GC_MARK_AND_PUSH(obj, msp, lim, src) \ ((GC_word)(obj) >= (GC_word)GC_least_plausible_heap_addr && \ (GC_word)(obj) <= (GC_word)GC_greatest_plausible_heap_addr ? \ GC_mark_and_push(obj, msp, lim, src) : (msp)) GC_API size_t GC_debug_header_size; /* The size of the header added to objects allocated through */ /* the GC_debug routines. */ /* Defined as a variable so that client mark procedures don't */ /* need to be recompiled for collector version changes. */ #define GC_USR_PTR_FROM_BASE(p) ((void *)((char *)(p) + GC_debug_header_size)) /* And some routines to support creation of new "kinds", e.g. with */ /* custom mark procedures, by language runtimes. */ /* The _inner versions assume the caller holds the allocation lock. */ /* Return a new free list array. */ GC_API void ** GC_CALL GC_new_free_list(void); GC_API void ** GC_CALL GC_new_free_list_inner(void); /* Return a new kind, as specified. */ GC_API unsigned GC_CALL GC_new_kind(void ** /* free_list */, GC_word /* mark_descriptor_template */, int /* add_size_to_descriptor */, int /* clear_new_objects */) GC_ATTR_NONNULL(1); /* The last two parameters must be zero or one. */ GC_API unsigned GC_CALL GC_new_kind_inner(void ** /* free_list */, GC_word /* mark_descriptor_template */, int /* add_size_to_descriptor */, int /* clear_new_objects */) GC_ATTR_NONNULL(1); /* Return a new mark procedure identifier, suitable for use as */ /* the first argument in GC_MAKE_PROC. */ GC_API unsigned GC_CALL GC_new_proc(GC_mark_proc); GC_API unsigned GC_CALL GC_new_proc_inner(GC_mark_proc); /* Allocate an object of a given kind. By default, there are only */ /* a few kinds: composite (pointer-free), atomic, uncollectible, etc. */ /* We claim it is possible for clever client code that understands the */ /* GC internals to add more, e.g. to communicate object layout */ /* information to the collector. Note that in the multi-threaded */ /* contexts, this is usually unsafe for kinds that have the descriptor */ /* in the object itself, since there is otherwise a window in which */ /* the descriptor is not correct. Even in the single-threaded case, */ /* we need to be sure that cleared objects on a free list don't */ /* cause a GC crash if they are accidentally traced. */ GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1) void * GC_CALL GC_generic_malloc( size_t /* lb */, int /* knd */); GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1) void * GC_CALL GC_generic_malloc_ignore_off_page( size_t /* lb */, int /* knd */); /* As above, but pointers to past the */ /* first page of the resulting object */ /* are ignored. */ /* Same as above but primary for allocating an object of the same kind */ /* as an existing one (kind obtained by GC_get_kind_and_size). */ /* Not suitable for GCJ and typed-malloc kinds. */ GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1) void * GC_CALL GC_generic_or_special_malloc( size_t /* size */, int /* knd */); GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1) void * GC_CALL GC_debug_generic_or_special_malloc( size_t /* size */, int /* knd */, GC_EXTRA_PARAMS); #ifdef GC_DEBUG # define GC_GENERIC_OR_SPECIAL_MALLOC(sz, knd) \ GC_debug_generic_or_special_malloc(sz, knd, GC_EXTRAS) #else # define GC_GENERIC_OR_SPECIAL_MALLOC(sz, knd) \ GC_generic_or_special_malloc(sz, knd) #endif /* !GC_DEBUG */ /* Similar to GC_size but returns object kind. Size is returned too */ /* if psize is not NULL. */ GC_API int GC_CALL GC_get_kind_and_size(const void *, size_t * /* psize */) GC_ATTR_NONNULL(1); typedef void (GC_CALLBACK * GC_describe_type_fn)(void * /* p */, char * /* out_buf */); /* A procedure which */ /* produces a human-readable */ /* description of the "type" of object */ /* p into the buffer out_buf of length */ /* GC_TYPE_DESCR_LEN. This is used by */ /* the debug support when printing */ /* objects. */ /* These functions should be as robust */ /* as possible, though we do avoid */ /* invoking them on objects on the */ /* global free list. */ #define GC_TYPE_DESCR_LEN 40 GC_API void GC_CALL GC_register_describe_type_fn(int /* kind */, GC_describe_type_fn); /* Register a describe_type function */ /* to be used when printing objects */ /* of a particular kind. */ /* Clear some of the inaccessible part of the stack. Returns its */ /* argument, so it can be used in a tail call position, hence clearing */ /* another frame. Argument may be NULL. */ GC_API void * GC_CALL GC_clear_stack(void *); /* Set and get the client notifier on collections. The client function */ /* is called at the start of every full GC (called with the allocation */ /* lock held). May be 0. This is a really tricky interface to use */ /* correctly. Unless you really understand the collector internals, */ /* the callback should not, directly or indirectly, make any GC_ or */ /* potentially blocking calls. In particular, it is not safe to */ /* allocate memory using the garbage collector from within the callback */ /* function. Both the setter and getter acquire the GC lock. */ typedef void (GC_CALLBACK * GC_start_callback_proc)(void); GC_API void GC_CALL GC_set_start_callback(GC_start_callback_proc); GC_API GC_start_callback_proc GC_CALL GC_get_start_callback(void); /* Slow/general mark bit manipulation. The caller must hold the */ /* allocation lock. GC_is_marked returns 1 (TRUE) or 0. */ GC_API int GC_CALL GC_is_marked(const void *) GC_ATTR_NONNULL(1); GC_API void GC_CALL GC_clear_mark_bit(const void *) GC_ATTR_NONNULL(1); GC_API void GC_CALL GC_set_mark_bit(const void *) GC_ATTR_NONNULL(1); /* Push everything in the given range onto the mark stack. */ /* (GC_push_conditional pushes either all or only dirty pages depending */ /* on the third argument.) */ GC_API void GC_CALL GC_push_all(char * /* bottom */, char * /* top */); GC_API void GC_CALL GC_push_conditional(char * /* bottom */, char * /* top */, int /* bool all */); /* Set and get the client push-other-roots procedure. A client */ /* supplied procedure should also call the original procedure. */ /* Note that both the setter and getter require some external */ /* synchronization to avoid data race. */ typedef void (GC_CALLBACK * GC_push_other_roots_proc)(void); GC_API void GC_CALL GC_set_push_other_roots(GC_push_other_roots_proc); GC_API GC_push_other_roots_proc GC_CALL GC_get_push_other_roots(void); #ifdef __cplusplus } /* end of extern "C" */ #endif #endif /* GC_MARK_H */ ecl-16.1.2/src/bdwgc/include/gc_pthread_redirects.h000066400000000000000000000072271266352375300222050ustar00rootroot00000000000000/* * Copyright (c) 1994 by Xerox Corporation. All rights reserved. * Copyright (c) 1996 by Silicon Graphics. All rights reserved. * Copyright (c) 1998 by Fergus Henderson. All rights reserved. * Copyright (c) 2000-2010 by Hewlett-Packard Development Company. * All rights reserved. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. */ /* Our pthread support normally needs to intercept a number of thread */ /* calls. We arrange to do that here, if appropriate. */ /* Included from gc.h only. Included only if GC_PTHREADS. */ #if defined(GC_H) && defined(GC_PTHREADS) /* We need to intercept calls to many of the threads primitives, so */ /* that we can locate thread stacks and stop the world. */ /* Note also that the collector cannot always see thread specific data. */ /* Thread specific data should generally consist of pointers to */ /* uncollectible objects (allocated with GC_malloc_uncollectable, */ /* not the system malloc), which are deallocated using the destructor */ /* facility in thr_keycreate. Alternatively, keep a redundant pointer */ /* to thread specific data on the thread stack. */ #ifndef GC_PTHREAD_REDIRECTS_ONLY # include # ifndef GC_NO_DLOPEN # include GC_API void *GC_dlopen(const char * /* path */, int /* mode */); # endif /* !GC_NO_DLOPEN */ # ifndef GC_NO_PTHREAD_SIGMASK # include GC_API int GC_pthread_sigmask(int /* how */, const sigset_t *, sigset_t * /* oset */); # endif /* !GC_NO_PTHREAD_SIGMASK */ # ifndef GC_PTHREAD_CREATE_CONST /* This is used for pthread_create() only. */ # define GC_PTHREAD_CREATE_CONST const # endif GC_API int GC_pthread_create(pthread_t *, GC_PTHREAD_CREATE_CONST pthread_attr_t *, void *(*)(void *), void * /* arg */); GC_API int GC_pthread_join(pthread_t, void ** /* retval */); GC_API int GC_pthread_detach(pthread_t); # ifndef GC_NO_PTHREAD_CANCEL GC_API int GC_pthread_cancel(pthread_t); # endif # if defined(GC_PTHREAD_EXIT_ATTRIBUTE) && !defined(GC_PTHREAD_EXIT_DECLARED) # define GC_PTHREAD_EXIT_DECLARED GC_API void GC_pthread_exit(void *) GC_PTHREAD_EXIT_ATTRIBUTE; # endif #endif /* !GC_PTHREAD_REDIRECTS_ONLY */ #if !defined(GC_NO_THREAD_REDIRECTS) && !defined(GC_USE_LD_WRAP) /* Unless the compiler supports #pragma extern_prefix, the Tru64 */ /* UNIX redefines some POSIX thread functions to use */ /* mangled names. Anyway, it's safe to undef them before redefining. */ # undef pthread_create # undef pthread_join # undef pthread_detach # define pthread_create GC_pthread_create # define pthread_join GC_pthread_join # define pthread_detach GC_pthread_detach # ifndef GC_NO_PTHREAD_SIGMASK # undef pthread_sigmask # define pthread_sigmask GC_pthread_sigmask # endif # ifndef GC_NO_DLOPEN # undef dlopen # define dlopen GC_dlopen # endif # ifndef GC_NO_PTHREAD_CANCEL # undef pthread_cancel # define pthread_cancel GC_pthread_cancel # endif # ifdef GC_PTHREAD_EXIT_ATTRIBUTE # undef pthread_exit # define pthread_exit GC_pthread_exit # endif #endif /* !GC_NO_THREAD_REDIRECTS */ #endif /* GC_PTHREADS */ ecl-16.1.2/src/bdwgc/include/gc_tiny_fl.h000066400000000000000000000076131266352375300201550ustar00rootroot00000000000000/* * Copyright (c) 1999-2005 Hewlett-Packard Development Company, L.P. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. */ #ifndef GC_TINY_FL_H #define GC_TINY_FL_H /* * Constants and data structures for "tiny" free lists. * These are used for thread-local allocation or in-lined allocators. * Each global free list also essentially starts with one of these. * However, global free lists are known to the GC. "Tiny" free lists * are basically private to the client. Their contents are viewed as * "in use" and marked accordingly by the core of the GC. * * Note that inlined code might know about the layout of these and the constants * involved. Thus any change here may invalidate clients, and such changes should * be avoided. Hence we keep this as simple as possible. */ /* * We always set GC_GRANULE_BYTES to twice the length of a pointer. * This means that all allocation requests are rounded up to the next * multiple of 16 on 64-bit architectures or 8 on 32-bit architectures. * This appears to be a reasonable compromise between fragmentation overhead * and space usage for mark bits (usually mark bytes). * On many 64-bit architectures some memory references require 16-byte * alignment, making this necessary anyway. * For a few 32-bit architecture (e.g. x86), we may also need 16-byte alignment * for certain memory references. But currently that does not seem to be the * default for all conventional malloc implementations, so we ignore that * problem. * It would always be safe, and often useful, to be able to allocate very * small objects with smaller alignment. But that would cost us mark bit * space, so we no longer do so. */ #ifndef GC_GRANULE_BYTES /* GC_GRANULE_BYTES should not be overridden in any instances of the GC */ /* library that may be shared between applications, since it affects */ /* the binary interface to the library. */ # if defined(__LP64__) || defined (_LP64) || defined(_WIN64) \ || defined(__s390x__) \ || (defined(__x86_64__) && !defined(__ILP32__)) \ || defined(__alpha__) || defined(__powerpc64__) \ || defined(__arch64__) # define GC_GRANULE_BYTES 16 # define GC_GRANULE_WORDS 2 # else # define GC_GRANULE_BYTES 8 # define GC_GRANULE_WORDS 2 # endif #endif /* !GC_GRANULE_BYTES */ #if GC_GRANULE_WORDS == 2 # define GC_WORDS_TO_GRANULES(n) ((n)>>1) #else # define GC_WORDS_TO_GRANULES(n) ((n)*sizeof(void *)/GC_GRANULE_BYTES) #endif /* A "tiny" free list header contains TINY_FREELISTS pointers to */ /* singly linked lists of objects of different sizes, the ith one */ /* containing objects i granules in size. Note that there is a list */ /* of size zero objects. */ #ifndef GC_TINY_FREELISTS # if GC_GRANULE_BYTES == 16 # define GC_TINY_FREELISTS 25 # else # define GC_TINY_FREELISTS 33 /* Up to and including 256 bytes */ # endif #endif /* !GC_TINY_FREELISTS */ /* The ith free list corresponds to size i*GC_GRANULE_BYTES */ /* Internally to the collector, the index can be computed with */ /* ROUNDED_UP_GRANULES. Externally, we don't know whether */ /* DONT_ADD_BYTE_AT_END is set, but the client should know. */ /* Convert a free list index to the actual size of objects */ /* on that list, including extra space we added. Not an */ /* inverse of the above. */ #define GC_RAW_BYTES_FROM_INDEX(i) ((i) * GC_GRANULE_BYTES) #endif /* GC_TINY_FL_H */ ecl-16.1.2/src/bdwgc/include/gc_typed.h000066400000000000000000000127721266352375300176400ustar00rootroot00000000000000/* * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. * Copyright 1996 Silicon Graphics. All rights reserved. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. */ /* * Some simple primitives for allocation with explicit type information. * Facilities for dynamic type inference may be added later. * Should be used only for extremely performance critical applications, * or if conservative collector leakage is otherwise a problem (unlikely). * Note that this is implemented completely separately from the rest * of the collector, and is not linked in unless referenced. * This does not currently support GC_DEBUG in any interesting way. */ #ifndef GC_TYPED_H #define GC_TYPED_H #ifndef GC_H # include "gc.h" #endif #ifdef __cplusplus extern "C" { #endif typedef GC_word * GC_bitmap; /* The least significant bit of the first word is one if */ /* the first word in the object may be a pointer. */ #define GC_WORDSZ (8 * sizeof(GC_word)) #define GC_get_bit(bm, index) \ (((bm)[(index) / GC_WORDSZ] >> ((index) % GC_WORDSZ)) & 1) #define GC_set_bit(bm, index) \ ((bm)[(index) / GC_WORDSZ] |= (GC_word)1 << ((index) % GC_WORDSZ)) #define GC_WORD_OFFSET(t, f) (offsetof(t,f) / sizeof(GC_word)) #define GC_WORD_LEN(t) (sizeof(t) / sizeof(GC_word)) #define GC_BITMAP_SIZE(t) ((GC_WORD_LEN(t) + GC_WORDSZ - 1) / GC_WORDSZ) typedef GC_word GC_descr; GC_API GC_descr GC_CALL GC_make_descriptor(const GC_word * /* GC_bitmap bm */, size_t /* len */); /* Return a type descriptor for the object whose layout */ /* is described by the argument. */ /* The least significant bit of the first word is one */ /* if the first word in the object may be a pointer. */ /* The second argument specifies the number of */ /* meaningful bits in the bitmap. The actual object */ /* may be larger (but not smaller). Any additional */ /* words in the object are assumed not to contain */ /* pointers. */ /* Returns a conservative approximation in the */ /* (unlikely) case of insufficient memory to build */ /* the descriptor. Calls to GC_make_descriptor */ /* may consume some amount of a finite resource. This */ /* is intended to be called once per type, not once */ /* per allocation. */ /* It is possible to generate a descriptor for a C type T with */ /* word aligned pointer fields f1, f2, ... as follows: */ /* */ /* GC_descr T_descr; */ /* GC_word T_bitmap[GC_BITMAP_SIZE(T)] = {0}; */ /* GC_set_bit(T_bitmap, GC_WORD_OFFSET(T,f1)); */ /* GC_set_bit(T_bitmap, GC_WORD_OFFSET(T,f2)); */ /* ... */ /* T_descr = GC_make_descriptor(T_bitmap, GC_WORD_LEN(T)); */ GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1) void * GC_CALL GC_malloc_explicitly_typed(size_t /* size_in_bytes */, GC_descr /* d */); /* Allocate an object whose layout is described by d. */ /* The resulting object MAY NOT BE PASSED TO REALLOC. */ /* The returned object is cleared. */ GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1) void * GC_CALL GC_malloc_explicitly_typed_ignore_off_page(size_t /* size_in_bytes */, GC_descr /* d */); GC_API GC_ATTR_MALLOC void * GC_CALL GC_calloc_explicitly_typed(size_t /* nelements */, size_t /* element_size_in_bytes */, GC_descr /* d */); /* Allocate an array of nelements elements, each of the */ /* given size, and with the given descriptor. */ /* The element size must be a multiple of the byte */ /* alignment required for pointers. E.g. on a 32-bit */ /* machine with 16-bit aligned pointers, size_in_bytes */ /* must be a multiple of 2. */ /* Returned object is cleared. */ #ifdef GC_DEBUG # define GC_MALLOC_EXPLICITLY_TYPED(bytes, d) GC_MALLOC(bytes) # define GC_CALLOC_EXPLICITLY_TYPED(n, bytes, d) GC_MALLOC((n) * (bytes)) #else # define GC_MALLOC_EXPLICITLY_TYPED(bytes, d) \ GC_malloc_explicitly_typed(bytes, d) # define GC_CALLOC_EXPLICITLY_TYPED(n, bytes, d) \ GC_calloc_explicitly_typed(n, bytes, d) #endif #ifdef __cplusplus } /* matches extern "C" */ #endif #endif /* GC_TYPED_H */ ecl-16.1.2/src/bdwgc/include/gc_version.h000066400000000000000000000040371266352375300201730ustar00rootroot00000000000000/* * Copyright (c) 1994 by Xerox Corporation. All rights reserved. * Copyright (c) 1996 by Silicon Graphics. All rights reserved. * Copyright (c) 1998 by Fergus Henderson. All rights reserved. * Copyright (c) 2000-2009 by Hewlett-Packard Development Company. * All rights reserved. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. */ /* This should never be included directly; it is included only from gc.h. */ #if defined(GC_H) /* The policy regarding version numbers: development code has odd */ /* "minor" number (and "micro" part is 0); when development is finished */ /* and a release is prepared, "minor" number is incremented (keeping */ /* "micro" number still zero), whenever a defect is fixed a new release */ /* is prepared incrementing "micro" part to odd value (the most stable */ /* release has the biggest "micro" number). */ /* The version here should match that in configure/configure.ac */ /* Eventually this one may become unnecessary. For now we need */ /* it to keep the old-style build process working. */ #define GC_TMP_VERSION_MAJOR 7 #define GC_TMP_VERSION_MINOR 5 #define GC_TMP_VERSION_MICRO 0 /* 7.5.0 */ #ifdef GC_VERSION_MAJOR # if GC_TMP_VERSION_MAJOR != GC_VERSION_MAJOR \ || GC_TMP_VERSION_MINOR != GC_VERSION_MINOR \ || GC_TMP_VERSION_MICRO != GC_VERSION_MICRO # error Inconsistent version info. Check README.md, include/gc_version.h and configure.ac. # endif #else # define GC_VERSION_MAJOR GC_TMP_VERSION_MAJOR # define GC_VERSION_MINOR GC_TMP_VERSION_MINOR # define GC_VERSION_MICRO GC_TMP_VERSION_MICRO #endif /* !GC_VERSION_MAJOR */ #endif ecl-16.1.2/src/bdwgc/include/include.am000066400000000000000000000034121266352375300176220ustar00rootroot00000000000000# # THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED # OR IMPLIED. ANY USE IS AT YOUR OWN RISK. # # Permission is hereby granted to use or copy this program # for any purpose, provided the above notices are retained on all copies. # Permission to modify the code and to distribute modified code is granted, # provided the above notices are retained, and a notice that the code was # modified is included with the above copyright notice. ## Process this file with automake to produce part of Makefile.in. # installed headers # pkginclude_HEADERS += \ include/gc.h \ include/gc_allocator.h \ include/gc_backptr.h \ include/gc_config_macros.h \ include/gc_disclaim.h \ include/gc_gcj.h \ include/gc_inline.h \ include/gc_mark.h \ include/gc_pthread_redirects.h \ include/gc_tiny_fl.h \ include/gc_typed.h \ include/gc_version.h \ include/javaxfc.h \ include/leak_detector.h \ include/weakpointer.h # headers which are not installed # dist_noinst_HEADERS += \ include/cord.h \ include/cord_pos.h \ include/ec.h \ include/new_gc_alloc.h \ include/private/darwin_semaphore.h \ include/private/darwin_stop_world.h \ include/private/dbg_mlc.h \ include/private/gc_hdrs.h \ include/private/gc_locks.h \ include/private/gc_pmark.h \ include/private/gc_priv.h \ include/private/gcconfig.h \ include/private/msvc_dbg.h \ include/private/pthread_stop_world.h \ include/private/pthread_support.h \ include/private/specific.h \ include/private/thread_local_alloc.h # unprefixed header include_HEADERS += \ include/extra/gc.h ecl-16.1.2/src/bdwgc/include/javaxfc.h000066400000000000000000000033031266352375300174520ustar00rootroot00000000000000/* * Copyright (c) 1994 by Xerox Corporation. All rights reserved. * Copyright (c) 1996 by Silicon Graphics. All rights reserved. * Copyright (c) 1998 by Fergus Henderson. All rights reserved. * Copyright (c) 2000-2009 by Hewlett-Packard Development Company. * All rights reserved. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. */ #ifndef GC_H # include "gc.h" #endif #ifdef __cplusplus extern "C" { #endif /* * Invoke all remaining finalizers that haven't yet been run. (Since the * notifier is not called, this should be called from a separate thread.) * This function is needed for strict compliance with the Java standard, * which can make the runtime guarantee that all finalizers are run. * This is problematic for several reasons: * 1) It means that finalizers, and all methods called by them, * must be prepared to deal with objects that have been finalized in * spite of the fact that they are still referenced by statically * allocated pointer variables. * 1) It may mean that we get stuck in an infinite loop running * finalizers which create new finalizable objects, though that's * probably unlikely. * Thus this is not recommended for general use. */ GC_API void GC_CALL GC_finalize_all(void); #ifdef __cplusplus } /* end of extern "C" */ #endif ecl-16.1.2/src/bdwgc/include/leak_detector.h000066400000000000000000000040051266352375300206350ustar00rootroot00000000000000/* * Copyright (c) 2000-2011 by Hewlett-Packard Development Company. * All rights reserved. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. */ #ifndef GC_LEAK_DETECTOR_H #define GC_LEAK_DETECTOR_H /* Include leak_detector.h (e.g., via GCC --include directive) */ /* to turn BoehmGC into a Leak Detector. */ #ifndef GC_DEBUG # define GC_DEBUG #endif #include "gc.h" #ifndef GC_DONT_INCLUDE_STDLIB /* We ensure stdlib.h and string.h are included before */ /* redirecting malloc() and the accompanying functions. */ # include # include #endif #undef malloc #define malloc(n) GC_MALLOC(n) #undef calloc #define calloc(m,n) GC_MALLOC((m)*(n)) #undef free #define free(p) GC_FREE(p) #undef realloc #define realloc(p,n) GC_REALLOC(p,n) #undef strdup #define strdup(s) GC_STRDUP(s) #undef strndup #define strndup(s,n) GC_STRNDUP(s,n) #ifdef GC_REQUIRE_WCSDUP /* The collector should be built with GC_REQUIRE_WCSDUP */ /* defined as well to redirect wcsdup(). */ # include # undef wcsdup # define wcsdup(s) GC_WCSDUP(s) #endif #undef memalign #define memalign(a,n) GC_memalign(a,n) #undef posix_memalign #define posix_memalign(p,a,n) GC_posix_memalign(p,a,n) #ifndef CHECK_LEAKS # define CHECK_LEAKS() GC_gcollect() /* Note 1: CHECK_LEAKS does not have GC prefix (preserved for */ /* backward compatibility). */ /* Note 2: GC_gcollect() is also called automatically in the */ /* leak-finding mode at program exit. */ #endif #endif /* GC_LEAK_DETECTOR_H */ ecl-16.1.2/src/bdwgc/include/new_gc_alloc.h000066400000000000000000000361721266352375300204560ustar00rootroot00000000000000/* * Copyright (c) 1996-1998 by Silicon Graphics. All rights reserved. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. */ // // This is a revision of gc_alloc.h for SGI STL versions > 3.0 // Unlike earlier versions, it supplements the standard "alloc.h" // instead of replacing it. // // This is sloppy about variable names used in header files. // It also doesn't yet understand the new header file names or // namespaces. // // This assumes the collector has been compiled with -DATOMIC_UNCOLLECTABLE. // The user should also consider -DREDIRECT_MALLOC=GC_uncollectable_malloc, // to ensure that object allocated through malloc are traced. // // Some of this could be faster in the explicit deallocation case. // In particular, we spend too much time clearing objects on the // free lists. That could be avoided. // // This uses template classes with static members, and hence does not work // with g++ 2.7.2 and earlier. // // Unlike its predecessor, this one simply defines // gc_alloc // single_client_gc_alloc // traceable_alloc // single_client_traceable_alloc // // It does not redefine alloc. Nor does it change the default allocator, // though the user may wish to do so. (The argument against changing // the default allocator is that it may introduce subtle link compatibility // problems. The argument for changing it is that the usual default // allocator is usually a very bad choice for a garbage collected environment.) // #ifndef GC_ALLOC_H #include "gc.h" #if (__GNUC__ < 3) # include // A more portable way to get stl_alloc.h . #else # include # ifndef __STL_BEGIN_NAMESPACE # define __STL_BEGIN_NAMESPACE namespace std { # define __STL_END_NAMESPACE }; # endif #ifndef __STL_USE_STD_ALLOCATORS #define __STL_USE_STD_ALLOCATORS #endif #endif /* A hack to deal with gcc 3.1. If you are using gcc3.1 and later, */ /* you should probably really use gc_allocator.h instead. */ #if defined (__GNUC__) && \ (__GNUC__ > 3 || (__GNUC__ == 3 && (__GNUC_MINOR__ >= 1))) # define simple_alloc __simple_alloc #endif #define GC_ALLOC_H #include #include // The following need to match collector data structures. // We can't include gc_priv.h, since that pulls in way too much stuff. // This should eventually be factored out into another include file. extern "C" { GC_API void ** const GC_objfreelist_ptr; GC_API void ** const GC_aobjfreelist_ptr; GC_API void ** const GC_uobjfreelist_ptr; GC_API void ** const GC_auobjfreelist_ptr; GC_API void GC_CALL GC_incr_bytes_allocd(size_t bytes); GC_API void GC_CALL GC_incr_bytes_freed(size_t bytes); GC_API char * GC_CALL GC_generic_malloc_words_small(size_t word, int kind); /* FIXME: Doesn't exist anymore. */ } // Object kinds; must match PTRFREE, NORMAL, UNCOLLECTABLE, and // AUNCOLLECTABLE in gc_priv.h. enum { GC_PTRFREE = 0, GC_NORMAL = 1, GC_UNCOLLECTABLE = 2, GC_AUNCOLLECTABLE = 3 }; enum { GC_max_fast_bytes = 255 }; enum { GC_bytes_per_word = sizeof(char *) }; enum { GC_byte_alignment = 8 }; enum { GC_word_alignment = GC_byte_alignment/GC_bytes_per_word }; inline void * &GC_obj_link(void * p) { return *reinterpret_cast(p); } // Compute a number of words >= n+1 bytes. // The +1 allows for pointers one past the end. inline size_t GC_round_up(size_t n) { return ((n + GC_byte_alignment)/GC_byte_alignment)*GC_word_alignment; } // The same but don't allow for extra byte. inline size_t GC_round_up_uncollectable(size_t n) { return ((n + GC_byte_alignment - 1)/GC_byte_alignment)*GC_word_alignment; } template class GC_aux_template { public: // File local count of allocated words. Occasionally this is // added into the global count. A separate count is necessary since the // real one must be updated with a procedure call. static size_t GC_bytes_recently_allocd; // Same for uncollectible memory. Not yet reflected in either // GC_bytes_recently_allocd or GC_non_gc_bytes. static size_t GC_uncollectable_bytes_recently_allocd; // Similar counter for explicitly deallocated memory. static size_t GC_bytes_recently_freed; // Again for uncollectible memory. static size_t GC_uncollectable_bytes_recently_freed; static void * GC_out_of_line_malloc(size_t nwords, int kind); }; template size_t GC_aux_template::GC_bytes_recently_allocd = 0; template size_t GC_aux_template::GC_uncollectable_bytes_recently_allocd = 0; template size_t GC_aux_template::GC_bytes_recently_freed = 0; template size_t GC_aux_template::GC_uncollectable_bytes_recently_freed = 0; template void * GC_aux_template::GC_out_of_line_malloc(size_t nwords, int kind) { GC_bytes_recently_allocd += GC_uncollectable_bytes_recently_allocd; GC_non_gc_bytes += GC_uncollectable_bytes_recently_allocd; GC_uncollectable_bytes_recently_allocd = 0; GC_bytes_recently_freed += GC_uncollectable_bytes_recently_freed; GC_non_gc_bytes -= GC_uncollectable_bytes_recently_freed; GC_uncollectable_bytes_recently_freed = 0; GC_incr_bytes_allocd(GC_bytes_recently_allocd); GC_bytes_recently_allocd = 0; GC_incr_bytes_freed(GC_bytes_recently_freed); GC_bytes_recently_freed = 0; return GC_generic_malloc_words_small(nwords, kind); } typedef GC_aux_template<0> GC_aux; // A fast, single-threaded, garbage-collected allocator // We assume the first word will be immediately overwritten. // In this version, deallocation is not a no-op, and explicit // deallocation is likely to help performance. template class single_client_gc_alloc_template { public: static void * allocate(size_t n) { size_t nwords = GC_round_up(n); void ** flh; void * op; if (n > GC_max_fast_bytes) return GC_malloc(n); flh = GC_objfreelist_ptr + nwords; if (0 == (op = *flh)) { return GC_aux::GC_out_of_line_malloc(nwords, GC_NORMAL); } *flh = GC_obj_link(op); GC_aux::GC_bytes_recently_allocd += nwords * GC_bytes_per_word; return op; } static void * ptr_free_allocate(size_t n) { size_t nwords = GC_round_up(n); void ** flh; void * op; if (n > GC_max_fast_bytes) return GC_malloc_atomic(n); flh = GC_aobjfreelist_ptr + nwords; if (0 == (op = *flh)) { return GC_aux::GC_out_of_line_malloc(nwords, GC_PTRFREE); } *flh = GC_obj_link(op); GC_aux::GC_bytes_recently_allocd += nwords * GC_bytes_per_word; return op; } static void deallocate(void *p, size_t n) { size_t nwords = GC_round_up(n); void ** flh; if (n > GC_max_fast_bytes) { GC_free(p); } else { flh = GC_objfreelist_ptr + nwords; GC_obj_link(p) = *flh; memset(reinterpret_cast(p) + GC_bytes_per_word, 0, GC_bytes_per_word * (nwords - 1)); *flh = p; GC_aux::GC_bytes_recently_freed += nwords * GC_bytes_per_word; } } static void ptr_free_deallocate(void *p, size_t n) { size_t nwords = GC_round_up(n); void ** flh; if (n > GC_max_fast_bytes) { GC_free(p); } else { flh = GC_aobjfreelist_ptr + nwords; GC_obj_link(p) = *flh; *flh = p; GC_aux::GC_bytes_recently_freed += nwords * GC_bytes_per_word; } } }; typedef single_client_gc_alloc_template<0> single_client_gc_alloc; // Once more, for uncollectible objects. template class single_client_traceable_alloc_template { public: static void * allocate(size_t n) { size_t nwords = GC_round_up_uncollectable(n); void ** flh; void * op; if (n > GC_max_fast_bytes) return GC_malloc_uncollectable(n); flh = GC_uobjfreelist_ptr + nwords; if (0 == (op = *flh)) { return GC_aux::GC_out_of_line_malloc(nwords, GC_UNCOLLECTABLE); } *flh = GC_obj_link(op); GC_aux::GC_uncollectable_bytes_recently_allocd += nwords * GC_bytes_per_word; return op; } static void * ptr_free_allocate(size_t n) { size_t nwords = GC_round_up_uncollectable(n); void ** flh; void * op; if (n > GC_max_fast_bytes) return GC_malloc_atomic_uncollectable(n); flh = GC_auobjfreelist_ptr + nwords; if (0 == (op = *flh)) { return GC_aux::GC_out_of_line_malloc(nwords, GC_AUNCOLLECTABLE); } *flh = GC_obj_link(op); GC_aux::GC_uncollectable_bytes_recently_allocd += nwords * GC_bytes_per_word; return op; } static void deallocate(void *p, size_t n) { size_t nwords = GC_round_up_uncollectable(n); void ** flh; if (n > GC_max_fast_bytes) { GC_free(p); } else { flh = GC_uobjfreelist_ptr + nwords; GC_obj_link(p) = *flh; *flh = p; GC_aux::GC_uncollectable_bytes_recently_freed += nwords * GC_bytes_per_word; } } static void ptr_free_deallocate(void *p, size_t n) { size_t nwords = GC_round_up_uncollectable(n); void ** flh; if (n > GC_max_fast_bytes) { GC_free(p); } else { flh = GC_auobjfreelist_ptr + nwords; GC_obj_link(p) = *flh; *flh = p; GC_aux::GC_uncollectable_bytes_recently_freed += nwords * GC_bytes_per_word; } } }; typedef single_client_traceable_alloc_template<0> single_client_traceable_alloc; template < int dummy > class gc_alloc_template { public: static void * allocate(size_t n) { return GC_malloc(n); } static void * ptr_free_allocate(size_t n) { return GC_malloc_atomic(n); } static void deallocate(void *, size_t) { } static void ptr_free_deallocate(void *, size_t) { } }; typedef gc_alloc_template < 0 > gc_alloc; template < int dummy > class traceable_alloc_template { public: static void * allocate(size_t n) { return GC_malloc_uncollectable(n); } static void * ptr_free_allocate(size_t n) { return GC_malloc_atomic_uncollectable(n); } static void deallocate(void *p, size_t) { GC_free(p); } static void ptr_free_deallocate(void *p, size_t) { GC_free(p); } }; typedef traceable_alloc_template < 0 > traceable_alloc; // We want to specialize simple_alloc so that it does the right thing // for all pointer-free types. At the moment there is no portable way to // even approximate that. The following approximation should work for // SGI compilers, and recent versions of g++. // GC_SPECIALIZE() is used internally. #define GC_SPECIALIZE(T,alloc) \ class simple_alloc { \ public: \ static T *allocate(size_t n) \ { return 0 == n? 0 : \ reinterpret_cast(alloc::ptr_free_allocate(n * sizeof(T))); } \ static T *allocate(void) \ { return reinterpret_cast(alloc::ptr_free_allocate(sizeof(T))); } \ static void deallocate(T *p, size_t n) \ { if (0 != n) alloc::ptr_free_deallocate(p, n * sizeof(T)); } \ static void deallocate(T *p) \ { alloc::ptr_free_deallocate(p, sizeof(T)); } \ }; __STL_BEGIN_NAMESPACE GC_SPECIALIZE(char, gc_alloc) GC_SPECIALIZE(int, gc_alloc) GC_SPECIALIZE(unsigned, gc_alloc) GC_SPECIALIZE(float, gc_alloc) GC_SPECIALIZE(double, gc_alloc) GC_SPECIALIZE(char, traceable_alloc) GC_SPECIALIZE(int, traceable_alloc) GC_SPECIALIZE(unsigned, traceable_alloc) GC_SPECIALIZE(float, traceable_alloc) GC_SPECIALIZE(double, traceable_alloc) GC_SPECIALIZE(char, single_client_gc_alloc) GC_SPECIALIZE(int, single_client_gc_alloc) GC_SPECIALIZE(unsigned, single_client_gc_alloc) GC_SPECIALIZE(float, single_client_gc_alloc) GC_SPECIALIZE(double, single_client_gc_alloc) GC_SPECIALIZE(char, single_client_traceable_alloc) GC_SPECIALIZE(int, single_client_traceable_alloc) GC_SPECIALIZE(unsigned, single_client_traceable_alloc) GC_SPECIALIZE(float, single_client_traceable_alloc) GC_SPECIALIZE(double, single_client_traceable_alloc) __STL_END_NAMESPACE #ifdef __STL_USE_STD_ALLOCATORS __STL_BEGIN_NAMESPACE template struct _Alloc_traits<_Tp, gc_alloc > { static const bool _S_instanceless = true; typedef simple_alloc<_Tp, gc_alloc > _Alloc_type; typedef __allocator<_Tp, gc_alloc > allocator_type; }; inline bool operator==(const gc_alloc&, const gc_alloc&) { return true; } inline bool operator!=(const gc_alloc&, const gc_alloc&) { return false; } template struct _Alloc_traits<_Tp, single_client_gc_alloc > { static const bool _S_instanceless = true; typedef simple_alloc<_Tp, single_client_gc_alloc > _Alloc_type; typedef __allocator<_Tp, single_client_gc_alloc > allocator_type; }; inline bool operator==(const single_client_gc_alloc&, const single_client_gc_alloc&) { return true; } inline bool operator!=(const single_client_gc_alloc&, const single_client_gc_alloc&) { return false; } template struct _Alloc_traits<_Tp, traceable_alloc > { static const bool _S_instanceless = true; typedef simple_alloc<_Tp, traceable_alloc > _Alloc_type; typedef __allocator<_Tp, traceable_alloc > allocator_type; }; inline bool operator==(const traceable_alloc&, const traceable_alloc&) { return true; } inline bool operator!=(const traceable_alloc&, const traceable_alloc&) { return false; } template struct _Alloc_traits<_Tp, single_client_traceable_alloc > { static const bool _S_instanceless = true; typedef simple_alloc<_Tp, single_client_traceable_alloc > _Alloc_type; typedef __allocator<_Tp, single_client_traceable_alloc > allocator_type; }; inline bool operator==(const single_client_traceable_alloc&, const single_client_traceable_alloc&) { return true; } inline bool operator!=(const single_client_traceable_alloc&, const single_client_traceable_alloc&) { return false; } __STL_END_NAMESPACE #endif /* __STL_USE_STD_ALLOCATORS */ #endif /* GC_ALLOC_H */ ecl-16.1.2/src/bdwgc/include/private/000077500000000000000000000000001266352375300173325ustar00rootroot00000000000000ecl-16.1.2/src/bdwgc/include/private/darwin_semaphore.h000066400000000000000000000047601266352375300230410ustar00rootroot00000000000000/* * Copyright (c) 1994 by Xerox Corporation. All rights reserved. * Copyright (c) 1996 by Silicon Graphics. All rights reserved. * Copyright (c) 1998 by Fergus Henderson. All rights reserved. * Copyright (c) 2000-2009 by Hewlett-Packard Development Company. * All rights reserved. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. */ #ifndef GC_DARWIN_SEMAPHORE_H #define GC_DARWIN_SEMAPHORE_H #if !defined(GC_DARWIN_THREADS) # error darwin_semaphore.h included with GC_DARWIN_THREADS not defined #endif /* This is a very simple semaphore implementation for Darwin. It is */ /* implemented in terms of pthread calls so it is not async signal */ /* safe. But this is not a problem because signals are not used to */ /* suspend threads on Darwin. */ typedef struct { pthread_mutex_t mutex; pthread_cond_t cond; int value; } sem_t; GC_INLINE int sem_init(sem_t *sem, int pshared, int value) { if (pshared != 0) { errno = EPERM; /* unsupported */ return -1; } sem->value = value; if (pthread_mutex_init(&sem->mutex, NULL) != 0) return -1; if (pthread_cond_init(&sem->cond, NULL) != 0) { (void)pthread_mutex_destroy(&sem->mutex); return -1; } return 0; } GC_INLINE int sem_post(sem_t *sem) { if (pthread_mutex_lock(&sem->mutex) != 0) return -1; sem->value++; if (pthread_cond_signal(&sem->cond) != 0) { (void)pthread_mutex_unlock(&sem->mutex); return -1; } return pthread_mutex_unlock(&sem->mutex) != 0 ? -1 : 0; } GC_INLINE int sem_wait(sem_t *sem) { if (pthread_mutex_lock(&sem->mutex) != 0) return -1; while (sem->value == 0) { if (pthread_cond_wait(&sem->cond, &sem->mutex) != 0) { (void)pthread_mutex_unlock(&sem->mutex); return -1; } } sem->value--; return pthread_mutex_unlock(&sem->mutex) != 0 ? -1 : 0; } GC_INLINE int sem_destroy(sem_t *sem) { return pthread_cond_destroy(&sem->cond) != 0 || pthread_mutex_destroy(&sem->mutex) != 0 ? -1 : 0; } #endif ecl-16.1.2/src/bdwgc/include/private/darwin_stop_world.h000066400000000000000000000026601266352375300232470ustar00rootroot00000000000000/* * Copyright (c) 1994 by Xerox Corporation. All rights reserved. * Copyright (c) 1996 by Silicon Graphics. All rights reserved. * Copyright (c) 1998 by Fergus Henderson. All rights reserved. * Copyright (c) 2000-2009 by Hewlett-Packard Development Company. * All rights reserved. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. */ #ifndef GC_DARWIN_STOP_WORLD_H #define GC_DARWIN_STOP_WORLD_H #if !defined(GC_DARWIN_THREADS) # error darwin_stop_world.h included without GC_DARWIN_THREADS defined #endif #include #include struct thread_stop_info { mach_port_t mach_thread; ptr_t stack_ptr; /* Valid only when thread is in a "blocked" state. */ }; #ifndef DARWIN_DONT_PARSE_STACK GC_INNER ptr_t GC_FindTopOfStack(unsigned long); #endif #ifdef MPROTECT_VDB GC_INNER void GC_mprotect_stop(void); GC_INNER void GC_mprotect_resume(void); #endif #if defined(PARALLEL_MARK) && !defined(GC_NO_THREADS_DISCOVERY) GC_INNER GC_bool GC_is_mach_marker(thread_act_t); #endif #endif ecl-16.1.2/src/bdwgc/include/private/dbg_mlc.h000066400000000000000000000154311266352375300210760ustar00rootroot00000000000000/* * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers * Copyright (c) 1991-1995 by Xerox Corporation. All rights reserved. * Copyright (c) 1997 by Silicon Graphics. All rights reserved. * Copyright (c) 1999 by Hewlett-Packard Company. All rights reserved. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. */ /* * This is mostly an internal header file. Typical clients should * not use it. Clients that define their own object kinds with * debugging allocators will probably want to include this, however. * No attempt is made to keep the namespace clean. This should not be * included from header files that are frequently included by clients. */ #ifndef _DBG_MLC_H #define _DBG_MLC_H #include "gc_priv.h" #ifdef KEEP_BACK_PTRS # include "gc_backptr.h" #endif #if CPP_WORDSZ == 32 # define START_FLAG (word)0xfedcedcb # define END_FLAG (word)0xbcdecdef #else # define START_FLAG GC_WORD_C(0xFEDCEDCBfedcedcb) # define END_FLAG GC_WORD_C(0xBCDECDEFbcdecdef) #endif /* Stored both one past the end of user object, and one before */ /* the end of the object as seen by the allocator. */ #if defined(KEEP_BACK_PTRS) || defined(PRINT_BLACK_LIST) \ || defined(MAKE_BACK_GRAPH) /* Pointer "source"s that aren't real locations. */ /* Used in oh_back_ptr fields and as "source" */ /* argument to some marking functions. */ # define NOT_MARKED (ptr_t)0 # define MARKED_FOR_FINALIZATION ((ptr_t)(word)2) /* Object was marked because it is finalizable. */ # define MARKED_FROM_REGISTER ((ptr_t)(word)4) /* Object was marked from a register. Hence the */ /* source of the reference doesn't have an address. */ #endif /* KEEP_BACK_PTRS || PRINT_BLACK_LIST */ /* Object header */ typedef struct { # if defined(KEEP_BACK_PTRS) || defined(MAKE_BACK_GRAPH) /* We potentially keep two different kinds of back */ /* pointers. KEEP_BACK_PTRS stores a single back */ /* pointer in each reachable object to allow reporting */ /* of why an object was retained. MAKE_BACK_GRAPH */ /* builds a graph containing the inverse of all */ /* "points-to" edges including those involving */ /* objects that have just become unreachable. This */ /* allows detection of growing chains of unreachable */ /* objects. It may be possible to eventually combine */ /* both, but for now we keep them separate. Both */ /* kinds of back pointers are hidden using the */ /* following macros. In both cases, the plain version */ /* is constrained to have an least significant bit of 1, */ /* to allow it to be distinguished from a free list */ /* link. This means the plain version must have an */ /* lsb of 0. */ /* Note that blocks dropped by black-listing will */ /* also have the lsb clear once debugging has */ /* started. */ /* We're careful never to overwrite a value with lsb 0. */ # if ALIGNMENT == 1 /* Fudge back pointer to be even. */ # define HIDE_BACK_PTR(p) GC_HIDE_POINTER(~1 & (GC_word)(p)) # else # define HIDE_BACK_PTR(p) GC_HIDE_POINTER(p) # endif # ifdef KEEP_BACK_PTRS GC_hidden_pointer oh_back_ptr; # endif # ifdef MAKE_BACK_GRAPH GC_hidden_pointer oh_bg_ptr; # endif # if defined(KEEP_BACK_PTRS) != defined(MAKE_BACK_GRAPH) /* Keep double-pointer-sized alignment. */ word oh_dummy; # endif # endif const char * oh_string; /* object descriptor string */ word oh_int; /* object descriptor integers */ # ifdef NEED_CALLINFO struct callinfo oh_ci[NFRAMES]; # endif # ifndef SHORT_DBG_HDRS word oh_sz; /* Original malloc arg. */ word oh_sf; /* start flag */ # endif /* SHORT_DBG_HDRS */ } oh; /* The size of the above structure is assumed not to de-align things, */ /* and to be a multiple of the word length. */ #ifdef SHORT_DBG_HDRS # define DEBUG_BYTES (sizeof (oh)) # define UNCOLLECTABLE_DEBUG_BYTES DEBUG_BYTES #else /* Add space for END_FLAG, but use any extra space that was already */ /* added to catch off-the-end pointers. */ /* For uncollectible objects, the extra byte is not added. */ # define UNCOLLECTABLE_DEBUG_BYTES (sizeof (oh) + sizeof (word)) # define DEBUG_BYTES (UNCOLLECTABLE_DEBUG_BYTES - EXTRA_BYTES) #endif /* Round bytes to words without adding extra byte at end. */ #define SIMPLE_ROUNDED_UP_WORDS(n) BYTES_TO_WORDS((n) + WORDS_TO_BYTES(1) - 1) /* ADD_CALL_CHAIN stores a (partial) call chain into an object */ /* header. It may be called with or without the allocation */ /* lock. */ /* PRINT_CALL_CHAIN prints the call chain stored in an object */ /* to stderr. It requires that we do not hold the lock. */ #if defined(SAVE_CALL_CHAIN) struct callinfo; GC_INNER void GC_save_callers(struct callinfo info[NFRAMES]); GC_INNER void GC_print_callers(struct callinfo info[NFRAMES]); # define ADD_CALL_CHAIN(base, ra) GC_save_callers(((oh *)(base)) -> oh_ci) # define PRINT_CALL_CHAIN(base) GC_print_callers(((oh *)(base)) -> oh_ci) #elif defined(GC_ADD_CALLER) struct callinfo; GC_INNER void GC_print_callers(struct callinfo info[NFRAMES]); # define ADD_CALL_CHAIN(base, ra) ((oh *)(base)) -> oh_ci[0].ci_pc = (ra) # define PRINT_CALL_CHAIN(base) GC_print_callers(((oh *)(base)) -> oh_ci) #else # define ADD_CALL_CHAIN(base, ra) # define PRINT_CALL_CHAIN(base) #endif #ifdef GC_ADD_CALLER # define OPT_RA ra, #else # define OPT_RA #endif /* Check whether object with base pointer p has debugging info */ /* p is assumed to point to a legitimate object in our part */ /* of the heap. */ #ifdef SHORT_DBG_HDRS # define GC_has_other_debug_info(p) 1 #else GC_INNER int GC_has_other_debug_info(ptr_t p); #endif #if defined(KEEP_BACK_PTRS) || defined(MAKE_BACK_GRAPH) # define GC_HAS_DEBUG_INFO(p) \ ((*((word *)p) & 1) && GC_has_other_debug_info(p) > 0) #else # define GC_HAS_DEBUG_INFO(p) (GC_has_other_debug_info(p) > 0) #endif #endif /* _DBG_MLC_H */ ecl-16.1.2/src/bdwgc/include/private/gc_hdrs.h000066400000000000000000000172361266352375300211250ustar00rootroot00000000000000/* * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. */ #ifndef GC_HEADERS_H #define GC_HEADERS_H typedef struct hblkhdr hdr; #if CPP_WORDSZ != 32 && CPP_WORDSZ < 36 --> Get a real machine. #endif /* * The 2 level tree data structure that is used to find block headers. * If there are more than 32 bits in a pointer, the top level is a hash * table. * * This defines HDR, GET_HDR, and SET_HDR, the main macros used to * retrieve and set object headers. * * We take advantage of a header lookup * cache. This is a locally declared direct mapped cache, used inside * the marker. The HC_GET_HDR macro uses and maintains this * cache. Assuming we get reasonable hit rates, this shaves a few * memory references from each pointer validation. */ #if CPP_WORDSZ > 32 # define HASH_TL #endif /* Define appropriate out-degrees for each of the two tree levels */ #if defined(LARGE_CONFIG) || !defined(SMALL_CONFIG) # define LOG_BOTTOM_SZ 10 #else # define LOG_BOTTOM_SZ 11 /* Keep top index size reasonable with smaller blocks. */ #endif #define BOTTOM_SZ (1 << LOG_BOTTOM_SZ) #ifndef HASH_TL # define LOG_TOP_SZ (WORDSZ - LOG_BOTTOM_SZ - LOG_HBLKSIZE) #else # define LOG_TOP_SZ 11 #endif #define TOP_SZ (1 << LOG_TOP_SZ) /* #define COUNT_HDR_CACHE_HITS */ #ifdef COUNT_HDR_CACHE_HITS extern word GC_hdr_cache_hits; /* used for debugging/profiling */ extern word GC_hdr_cache_misses; # define HC_HIT() ++GC_hdr_cache_hits # define HC_MISS() ++GC_hdr_cache_misses #else # define HC_HIT() # define HC_MISS() #endif typedef struct hce { word block_addr; /* right shifted by LOG_HBLKSIZE */ hdr * hce_hdr; } hdr_cache_entry; #define HDR_CACHE_SIZE 8 /* power of 2 */ #define DECLARE_HDR_CACHE \ hdr_cache_entry hdr_cache[HDR_CACHE_SIZE] #define INIT_HDR_CACHE BZERO(hdr_cache, sizeof(hdr_cache)) #define HCE(h) hdr_cache + (((word)(h) >> LOG_HBLKSIZE) & (HDR_CACHE_SIZE-1)) #define HCE_VALID_FOR(hce,h) ((hce) -> block_addr == \ ((word)(h) >> LOG_HBLKSIZE)) #define HCE_HDR(h) ((hce) -> hce_hdr) #ifdef PRINT_BLACK_LIST GC_INNER hdr * GC_header_cache_miss(ptr_t p, hdr_cache_entry *hce, ptr_t source); # define HEADER_CACHE_MISS(p, hce, source) \ GC_header_cache_miss(p, hce, source) #else GC_INNER hdr * GC_header_cache_miss(ptr_t p, hdr_cache_entry *hce); # define HEADER_CACHE_MISS(p, hce, source) GC_header_cache_miss(p, hce) #endif /* Set hhdr to the header for p. Analogous to GET_HDR below, */ /* except that in the case of large objects, it */ /* gets the header for the object beginning, if GC_all_interior_ptrs */ /* is set. */ /* Returns zero if p points to somewhere other than the first page */ /* of an object, and it is not a valid pointer to the object. */ #define HC_GET_HDR(p, hhdr, source, exit_label) \ do { \ hdr_cache_entry * hce = HCE(p); \ if (EXPECT(HCE_VALID_FOR(hce, p), TRUE)) { \ HC_HIT(); \ hhdr = hce -> hce_hdr; \ } else { \ hhdr = HEADER_CACHE_MISS(p, hce, source); \ if (0 == hhdr) goto exit_label; \ } \ } while (0) typedef struct bi { hdr * index[BOTTOM_SZ]; /* * The bottom level index contains one of three kinds of values: * 0 means we're not responsible for this block, * or this is a block other than the first one in a free block. * 1 < (long)X <= MAX_JUMP means the block starts at least * X * HBLKSIZE bytes before the current address. * A valid pointer points to a hdr structure. (The above can't be * valid pointers due to the GET_MEM return convention.) */ struct bi * asc_link; /* All indices are linked in */ /* ascending order... */ struct bi * desc_link; /* ... and in descending order. */ word key; /* high order address bits. */ # ifdef HASH_TL struct bi * hash_link; /* Hash chain link. */ # endif } bottom_index; /* bottom_index GC_all_nils; - really part of GC_arrays */ /* extern bottom_index * GC_top_index []; - really part of GC_arrays */ /* Each entry points to a bottom_index. */ /* On a 32 bit machine, it points to */ /* the index for a set of high order */ /* bits equal to the index. For longer */ /* addresses, we hash the high order */ /* bits to compute the index in */ /* GC_top_index, and each entry points */ /* to a hash chain. */ /* The last entry in each chain is */ /* GC_all_nils. */ #define MAX_JUMP (HBLKSIZE - 1) #define HDR_FROM_BI(bi, p) \ ((bi)->index[((word)(p) >> LOG_HBLKSIZE) & (BOTTOM_SZ - 1)]) #ifndef HASH_TL # define BI(p) (GC_top_index \ [(word)(p) >> (LOG_BOTTOM_SZ + LOG_HBLKSIZE)]) # define HDR_INNER(p) HDR_FROM_BI(BI(p),p) # ifdef SMALL_CONFIG # define HDR(p) GC_find_header((ptr_t)(p)) # else # define HDR(p) HDR_INNER(p) # endif # define GET_BI(p, bottom_indx) (void)((bottom_indx) = BI(p)) # define GET_HDR(p, hhdr) (void)((hhdr) = HDR(p)) # define SET_HDR(p, hhdr) (void)(HDR_INNER(p) = (hhdr)) # define GET_HDR_ADDR(p, ha) (void)((ha) = &HDR_INNER(p)) #else /* hash */ /* Hash function for tree top level */ # define TL_HASH(hi) ((hi) & (TOP_SZ - 1)) /* Set bottom_indx to point to the bottom index for address p */ # define GET_BI(p, bottom_indx) \ do { \ register word hi = \ (word)(p) >> (LOG_BOTTOM_SZ + LOG_HBLKSIZE); \ register bottom_index * _bi = GC_top_index[TL_HASH(hi)]; \ while (_bi -> key != hi && _bi != GC_all_nils) \ _bi = _bi -> hash_link; \ (bottom_indx) = _bi; \ } while (0) # define GET_HDR_ADDR(p, ha) \ do { \ register bottom_index * bi; \ GET_BI(p, bi); \ (ha) = &HDR_FROM_BI(bi, p); \ } while (0) # define GET_HDR(p, hhdr) \ do { \ register hdr ** _ha; \ GET_HDR_ADDR(p, _ha); \ (hhdr) = *_ha; \ } while (0) # define SET_HDR(p, hhdr) \ do { \ register hdr ** _ha; \ GET_HDR_ADDR(p, _ha); \ *_ha = (hhdr); \ } while (0) # define HDR(p) GC_find_header((ptr_t)(p)) #endif /* Is the result a forwarding address to someplace closer to the */ /* beginning of the block or NULL? */ #define IS_FORWARDING_ADDR_OR_NIL(hhdr) ((size_t) (hhdr) <= MAX_JUMP) /* Get an HBLKSIZE aligned address closer to the beginning of the block */ /* h. Assumes hhdr == HDR(h) and IS_FORWARDING_ADDR(hhdr). */ #define FORWARDED_ADDR(h, hhdr) ((struct hblk *)(h) - (size_t)(hhdr)) #endif /* GC_HEADERS_H */ ecl-16.1.2/src/bdwgc/include/private/gc_locks.h000066400000000000000000000227501266352375300212750ustar00rootroot00000000000000/* * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. * Copyright (c) 1999 by Hewlett-Packard Company. All rights reserved. * * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. */ #ifndef GC_LOCKS_H #define GC_LOCKS_H /* * Mutual exclusion between allocator/collector routines. * Needed if there is more than one allocator thread. * DCL_LOCK_STATE declares any local variables needed by LOCK and UNLOCK. * * Note that I_HOLD_LOCK and I_DONT_HOLD_LOCK are used only positively * in assertions, and may return TRUE in the "don't know" case. */ # ifdef THREADS # if defined(GC_PTHREADS) && !defined(GC_WIN32_THREADS) # include "atomic_ops.h" # endif # ifdef PCR # include # include GC_EXTERN PCR_Th_ML GC_allocate_ml; # define DCL_LOCK_STATE \ PCR_ERes GC_fastLockRes; PCR_sigset_t GC_old_sig_mask # define UNCOND_LOCK() PCR_Th_ML_Acquire(&GC_allocate_ml) # define UNCOND_UNLOCK() PCR_Th_ML_Release(&GC_allocate_ml) # endif # if (!defined(AO_HAVE_test_and_set_acquire) || defined(GC_RTEMS_PTHREADS) \ || defined(SN_TARGET_PS3) || defined(GC_WIN32_THREADS) \ || defined(LINT2)) && defined(GC_PTHREADS) # define USE_PTHREAD_LOCKS # endif # if defined(GC_WIN32_THREADS) && !defined(USE_PTHREAD_LOCKS) # ifndef WIN32_LEAN_AND_MEAN # define WIN32_LEAN_AND_MEAN 1 # endif # define NOSERVICE # include # define NO_THREAD (DWORD)(-1) GC_EXTERN CRITICAL_SECTION GC_allocate_ml; # ifdef GC_ASSERTIONS GC_EXTERN DWORD GC_lock_holder; # define SET_LOCK_HOLDER() GC_lock_holder = GetCurrentThreadId() # define UNSET_LOCK_HOLDER() GC_lock_holder = NO_THREAD # define I_HOLD_LOCK() (!GC_need_to_lock \ || GC_lock_holder == GetCurrentThreadId()) # define I_DONT_HOLD_LOCK() (!GC_need_to_lock \ || GC_lock_holder != GetCurrentThreadId()) # define UNCOND_LOCK() \ { GC_ASSERT(I_DONT_HOLD_LOCK()); \ EnterCriticalSection(&GC_allocate_ml); \ SET_LOCK_HOLDER(); } # define UNCOND_UNLOCK() \ { GC_ASSERT(I_HOLD_LOCK()); UNSET_LOCK_HOLDER(); \ LeaveCriticalSection(&GC_allocate_ml); } # else # define UNCOND_LOCK() EnterCriticalSection(&GC_allocate_ml) # define UNCOND_UNLOCK() LeaveCriticalSection(&GC_allocate_ml) # endif /* !GC_ASSERTIONS */ # elif defined(GC_PTHREADS) # include /* Posix allows pthread_t to be a struct, though it rarely is. */ /* Unfortunately, we need to use a pthread_t to index a data */ /* structure. It also helps if comparisons don't involve a */ /* function call. Hence we introduce platform-dependent macros */ /* to compare pthread_t ids and to map them to integers. */ /* The mapping to integers does not need to result in different */ /* integers for each thread, though that should be true as much */ /* as possible. */ /* Refine to exclude platforms on which pthread_t is struct. */ # if !defined(GC_WIN32_PTHREADS) # define NUMERIC_THREAD_ID(id) ((unsigned long)(id)) # define THREAD_EQUAL(id1, id2) ((id1) == (id2)) # define NUMERIC_THREAD_ID_UNIQUE # elif defined(__WINPTHREADS_VERSION_MAJOR) /* winpthreads */ # define NUMERIC_THREAD_ID(id) ((unsigned long)(id)) # define THREAD_EQUAL(id1, id2) ((id1) == (id2)) # ifndef _WIN64 /* NUMERIC_THREAD_ID is 32-bit and not unique on Win64. */ # define NUMERIC_THREAD_ID_UNIQUE # endif # else /* pthreads-win32 */ # define NUMERIC_THREAD_ID(id) ((unsigned long)(id.p)) /* Using documented internal details of pthreads-win32 library. */ /* Faster than pthread_equal(). Should not change with */ /* future versions of pthreads-win32 library. */ # define THREAD_EQUAL(id1, id2) ((id1.p == id2.p) && (id1.x == id2.x)) # undef NUMERIC_THREAD_ID_UNIQUE /* Generic definitions based on pthread_equal() always work but */ /* will result in poor performance (as NUMERIC_THREAD_ID is */ /* defined to just a constant) and weak assertion checking. */ # endif # define NO_THREAD ((unsigned long)(-1l)) /* != NUMERIC_THREAD_ID(pthread_self()) for any thread */ # if !defined(THREAD_LOCAL_ALLOC) && !defined(USE_PTHREAD_LOCKS) /* In the THREAD_LOCAL_ALLOC case, the allocation lock tends to */ /* be held for long periods, if it is held at all. Thus spinning */ /* and sleeping for fixed periods are likely to result in */ /* significant wasted time. We thus rely mostly on queued locks. */ # define USE_SPIN_LOCK GC_EXTERN volatile AO_TS_t GC_allocate_lock; GC_INNER void GC_lock(void); /* Allocation lock holder. Only set if acquired by client through */ /* GC_call_with_alloc_lock. */ # ifdef GC_ASSERTIONS # define UNCOND_LOCK() \ { GC_ASSERT(I_DONT_HOLD_LOCK()); \ if (AO_test_and_set_acquire(&GC_allocate_lock) == AO_TS_SET) \ GC_lock(); \ SET_LOCK_HOLDER(); } # define UNCOND_UNLOCK() \ { GC_ASSERT(I_HOLD_LOCK()); UNSET_LOCK_HOLDER(); \ AO_CLEAR(&GC_allocate_lock); } # else # define UNCOND_LOCK() \ { GC_ASSERT(I_DONT_HOLD_LOCK()); \ if (AO_test_and_set_acquire(&GC_allocate_lock) == AO_TS_SET) \ GC_lock(); } # define UNCOND_UNLOCK() AO_CLEAR(&GC_allocate_lock) # endif /* !GC_ASSERTIONS */ # else /* THREAD_LOCAL_ALLOC || USE_PTHREAD_LOCKS */ # ifndef USE_PTHREAD_LOCKS # define USE_PTHREAD_LOCKS # endif # endif /* THREAD_LOCAL_ALLOC || USE_PTHREAD_LOCKS */ # ifdef USE_PTHREAD_LOCKS # include GC_EXTERN pthread_mutex_t GC_allocate_ml; # ifdef GC_ASSERTIONS # define UNCOND_LOCK() { GC_ASSERT(I_DONT_HOLD_LOCK()); \ GC_lock(); SET_LOCK_HOLDER(); } # define UNCOND_UNLOCK() \ { GC_ASSERT(I_HOLD_LOCK()); UNSET_LOCK_HOLDER(); \ pthread_mutex_unlock(&GC_allocate_ml); } # else /* !GC_ASSERTIONS */ # if defined(NO_PTHREAD_TRYLOCK) # ifdef USE_SPIN_LOCK # define UNCOND_LOCK() GC_lock() # else # define UNCOND_LOCK() pthread_mutex_lock(&GC_allocate_ml) # endif # else # define UNCOND_LOCK() \ { if (0 != pthread_mutex_trylock(&GC_allocate_ml)) \ GC_lock(); } # endif # define UNCOND_UNLOCK() pthread_mutex_unlock(&GC_allocate_ml) # endif /* !GC_ASSERTIONS */ # endif /* USE_PTHREAD_LOCKS */ # ifdef GC_ASSERTIONS GC_EXTERN unsigned long GC_lock_holder; # define SET_LOCK_HOLDER() \ GC_lock_holder = NUMERIC_THREAD_ID(pthread_self()) # define UNSET_LOCK_HOLDER() GC_lock_holder = NO_THREAD # define I_HOLD_LOCK() \ (!GC_need_to_lock \ || GC_lock_holder == NUMERIC_THREAD_ID(pthread_self())) # ifndef NUMERIC_THREAD_ID_UNIQUE # define I_DONT_HOLD_LOCK() 1 /* Conservatively say yes */ # else # define I_DONT_HOLD_LOCK() \ (!GC_need_to_lock \ || GC_lock_holder != NUMERIC_THREAD_ID(pthread_self())) # endif # endif /* GC_ASSERTIONS */ GC_EXTERN volatile GC_bool GC_collecting; # define ENTER_GC() GC_collecting = 1; # define EXIT_GC() GC_collecting = 0; GC_INNER void GC_lock(void); # endif /* GC_PTHREADS with linux_threads.c implementation */ # ifdef GC_ALWAYS_MULTITHREADED # define GC_need_to_lock TRUE # else GC_EXTERN GC_bool GC_need_to_lock; # endif # else /* !THREADS */ # define LOCK() (void)0 # define UNLOCK() (void)0 # ifdef GC_ASSERTIONS # define I_HOLD_LOCK() TRUE # define I_DONT_HOLD_LOCK() TRUE /* Used only in positive assertions or to test whether */ /* we still need to acquire the lock. TRUE works in */ /* either case. */ # endif # endif /* !THREADS */ #if defined(UNCOND_LOCK) && !defined(LOCK) # if defined(LINT2) || defined(GC_ALWAYS_MULTITHREADED) /* Instruct code analysis tools not to care about GC_need_to_lock */ /* influence to LOCK/UNLOCK semantic. */ # define LOCK() UNCOND_LOCK() # define UNLOCK() UNCOND_UNLOCK() # else /* At least two thread running; need to lock. */ # define LOCK() do { if (GC_need_to_lock) UNCOND_LOCK(); } while (0) # define UNLOCK() do { if (GC_need_to_lock) UNCOND_UNLOCK(); } while (0) # endif #endif # ifndef ENTER_GC # define ENTER_GC() # define EXIT_GC() # endif # ifndef DCL_LOCK_STATE # define DCL_LOCK_STATE # endif #endif /* GC_LOCKS_H */ ecl-16.1.2/src/bdwgc/include/private/gc_pmark.h000066400000000000000000000463131266352375300212750ustar00rootroot00000000000000/* * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. * Copyright (c) 2001 by Hewlett-Packard Company. All rights reserved. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. * */ /* Private declarations of GC marker data structures and macros */ /* * Declarations of mark stack. Needed by marker and client supplied mark * routines. Transitively include gc_priv.h. */ #ifndef GC_PMARK_H #define GC_PMARK_H #ifdef HAVE_CONFIG_H # include "config.h" #endif #ifndef GC_BUILD # define GC_BUILD #endif #if defined(KEEP_BACK_PTRS) || defined(PRINT_BLACK_LIST) # include "dbg_mlc.h" #endif #ifndef GC_MARK_H # include "../gc_mark.h" #endif #ifndef GC_PRIVATE_H # include "gc_priv.h" #endif /* The real declarations of the following is in gc_priv.h, so that */ /* we can avoid scanning the following table. */ /* mark_proc GC_mark_procs[MAX_MARK_PROCS]; */ #ifndef MARK_DESCR_OFFSET # define MARK_DESCR_OFFSET sizeof(word) #endif /* * Mark descriptor stuff that should remain private for now, mostly * because it's hard to export WORDSZ without including gcconfig.h. */ #define BITMAP_BITS (WORDSZ - GC_DS_TAG_BITS) #define PROC(descr) \ (GC_mark_procs[((descr) >> GC_DS_TAG_BITS) & (GC_MAX_MARK_PROCS-1)]) #define ENV(descr) \ ((descr) >> (GC_DS_TAG_BITS + GC_LOG_MAX_MARK_PROCS)) #define MAX_ENV \ (((word)1 << (WORDSZ - GC_DS_TAG_BITS - GC_LOG_MAX_MARK_PROCS)) - 1) GC_EXTERN unsigned GC_n_mark_procs; /* Number of mark stack entries to discard on overflow. */ #define GC_MARK_STACK_DISCARDS (INITIAL_MARK_STACK_SIZE/8) GC_EXTERN size_t GC_mark_stack_size; #ifdef PARALLEL_MARK /* * Allow multiple threads to participate in the marking process. * This works roughly as follows: * The main mark stack never shrinks, but it can grow. * * The initiating threads holds the GC lock, and sets GC_help_wanted. * * Other threads: * 1) update helper_count (while holding mark_lock.) * 2) allocate a local mark stack * repeatedly: * 3) Steal a global mark stack entry by atomically replacing * its descriptor with 0. * 4) Copy it to the local stack. * 5) Mark on the local stack until it is empty, or * it may be profitable to copy it back. * 6) If necessary, copy local stack to global one, * holding mark lock. * 7) Stop when the global mark stack is empty. * 8) decrement helper_count (holding mark_lock). * * This is an experiment to see if we can do something along the lines * of the University of Tokyo SGC in a less intrusive, though probably * also less performant, way. */ /* GC_mark_stack_top is protected by mark lock. */ /* * GC_notify_all_marker() is used when GC_help_wanted is first set, * when the last helper becomes inactive, * when something is added to the global mark stack, and just after * GC_mark_no is incremented. * This could be split into multiple CVs (and probably should be to * scale to really large numbers of processors.) */ #endif /* PARALLEL_MARK */ GC_INNER mse * GC_signal_mark_stack_overflow(mse *msp); /* Push the object obj with corresponding heap block header hhdr onto */ /* the mark stack. */ #define PUSH_OBJ(obj, hhdr, mark_stack_top, mark_stack_limit) \ do { \ register word _descr = (hhdr) -> hb_descr; \ GC_ASSERT(!HBLK_IS_FREE(hhdr)); \ if (_descr != 0) { \ mark_stack_top++; \ if ((word)mark_stack_top >= (word)(mark_stack_limit)) { \ mark_stack_top = GC_signal_mark_stack_overflow(mark_stack_top); \ } \ mark_stack_top -> mse_start = (obj); \ mark_stack_top -> mse_descr.w = _descr; \ } \ } while (0) /* Push the contents of current onto the mark stack if it is a valid */ /* ptr to a currently unmarked object. Mark it. */ /* If we assumed a standard-conforming compiler, we could probably */ /* generate the exit_label transparently. */ #define PUSH_CONTENTS(current, mark_stack_top, mark_stack_limit, \ source, exit_label) \ do { \ hdr * my_hhdr; \ HC_GET_HDR(current, my_hhdr, source, exit_label); \ PUSH_CONTENTS_HDR(current, mark_stack_top, mark_stack_limit, \ source, exit_label, my_hhdr, TRUE); \ exit_label: ; \ } while (0) /* Set mark bit, exit if it was already set. */ #ifdef USE_MARK_BYTES /* There is a race here, and we may set */ /* the bit twice in the concurrent case. This can result in the */ /* object being pushed twice. But that's only a performance issue. */ # define SET_MARK_BIT_EXIT_IF_SET(hhdr,bit_no,exit_label) \ do { \ char * mark_byte_addr = (char *)hhdr -> hb_marks + (bit_no); \ if (*mark_byte_addr) goto exit_label; \ *mark_byte_addr = 1; \ } while (0) #else # ifdef PARALLEL_MARK /* This is used only if we explicitly set USE_MARK_BITS. */ /* The following may fail to exit even if the bit was already set. */ /* For our uses, that's benign: */ # define OR_WORD_EXIT_IF_SET(addr, bits, exit_label) \ do { \ if (!(*(addr) & (bits))) { \ AO_or((volatile AO_t *)(addr), (AO_t)(bits)); \ } else { \ goto exit_label; \ } \ } while (0) # else # define OR_WORD_EXIT_IF_SET(addr, bits, exit_label) \ do { \ word old = *(addr); \ word my_bits = (bits); \ if (old & my_bits) goto exit_label; \ *(addr) = (old | my_bits); \ } while (0) # endif /* !PARALLEL_MARK */ # define SET_MARK_BIT_EXIT_IF_SET(hhdr,bit_no,exit_label) \ do { \ word * mark_word_addr = hhdr -> hb_marks + divWORDSZ(bit_no); \ OR_WORD_EXIT_IF_SET(mark_word_addr, (word)1 << modWORDSZ(bit_no), \ exit_label); \ } while (0) #endif /* !USE_MARK_BYTES */ #ifdef PARALLEL_MARK # define INCR_MARKS(hhdr) \ AO_store(&hhdr->hb_n_marks, AO_load(&hhdr->hb_n_marks) + 1) #else # define INCR_MARKS(hhdr) (void)(++hhdr->hb_n_marks) #endif #ifdef ENABLE_TRACE # define TRACE(source, cmd) \ if (GC_trace_addr != 0 && (ptr_t)(source) == GC_trace_addr) cmd # define TRACE_TARGET(target, cmd) \ if (GC_trace_addr != 0 && (target) == *(ptr_t *)GC_trace_addr) cmd #else # define TRACE(source, cmd) # define TRACE_TARGET(source, cmd) #endif #if defined(I386) && defined(__GNUC__) # define LONG_MULT(hprod, lprod, x, y) \ do { \ __asm__ __volatile__("mull %2" : "=a"(lprod), "=d"(hprod) \ : "g"(y), "0"(x)); \ } while (0) #else # define LONG_MULT(hprod, lprod, x, y) \ do { \ unsigned long long prod = (unsigned long long)(x) \ * (unsigned long long)(y); \ GC_STATIC_ASSERT(sizeof(x) + sizeof(y) <= sizeof(prod)); \ hprod = prod >> 32; \ lprod = (unsigned32)prod; \ } while (0) #endif /* !I386 */ /* If the mark bit corresponding to current is not set, set it, and */ /* push the contents of the object on the mark stack. Current points */ /* to the beginning of the object. We rely on the fact that the */ /* preceding header calculation will succeed for a pointer past the */ /* first page of an object, only if it is in fact a valid pointer */ /* to the object. Thus we can omit the otherwise necessary tests */ /* here. Note in particular that the "displ" value is the displacement */ /* from the beginning of the heap block, which may itself be in the */ /* interior of a large object. */ #ifdef MARK_BIT_PER_GRANULE # define PUSH_CONTENTS_HDR(current, mark_stack_top, mark_stack_limit, \ source, exit_label, hhdr, do_offset_check) \ do { \ size_t displ = HBLKDISPL(current); /* Displacement in block; in bytes. */\ /* displ is always within range. If current doesn't point to */ \ /* first block, then we are in the all_interior_pointers case, and */ \ /* it is safe to use any displacement value. */ \ size_t gran_displ = BYTES_TO_GRANULES(displ); \ size_t gran_offset = hhdr -> hb_map[gran_displ]; \ size_t byte_offset = displ & (GRANULE_BYTES - 1); \ ptr_t base = current; \ /* The following always fails for large block references. */ \ if (EXPECT((gran_offset | byte_offset) != 0, FALSE)) { \ if ((hhdr -> hb_flags & LARGE_BLOCK) != 0) { \ /* gran_offset is bogus. */ \ size_t obj_displ; \ base = (ptr_t)(hhdr -> hb_block); \ obj_displ = (ptr_t)(current) - base; \ if (obj_displ != displ) { \ GC_ASSERT(obj_displ < hhdr -> hb_sz); \ /* Must be in all_interior_pointer case, not first block */ \ /* already did validity check on cache miss. */ \ } else { \ if (do_offset_check && !GC_valid_offsets[obj_displ]) { \ GC_ADD_TO_BLACK_LIST_NORMAL(current, source); \ goto exit_label; \ } \ } \ gran_displ = 0; \ GC_ASSERT(hhdr -> hb_sz > HBLKSIZE || \ hhdr -> hb_block == HBLKPTR(current)); \ GC_ASSERT((word)hhdr->hb_block <= (word)(current)); \ } else { \ size_t obj_displ = GRANULES_TO_BYTES(gran_offset) \ + byte_offset; \ if (do_offset_check && !GC_valid_offsets[obj_displ]) { \ GC_ADD_TO_BLACK_LIST_NORMAL(current, source); \ goto exit_label; \ } \ gran_displ -= gran_offset; \ base -= obj_displ; \ } \ } \ GC_ASSERT(hhdr == GC_find_header(base)); \ GC_ASSERT(gran_displ % BYTES_TO_GRANULES(hhdr -> hb_sz) == 0); \ TRACE(source, GC_log_printf("GC #%u: passed validity tests\n", \ (unsigned)GC_gc_no)); \ SET_MARK_BIT_EXIT_IF_SET(hhdr, gran_displ, exit_label); \ TRACE(source, GC_log_printf("GC #%u: previously unmarked\n", \ (unsigned)GC_gc_no)); \ TRACE_TARGET(base, \ GC_log_printf("GC #%u: marking %p from %p instead\n", \ (unsigned)GC_gc_no, base, source)); \ INCR_MARKS(hhdr); \ GC_STORE_BACK_PTR((ptr_t)source, base); \ PUSH_OBJ(base, hhdr, mark_stack_top, mark_stack_limit); \ } while (0) #endif /* MARK_BIT_PER_GRANULE */ #ifdef MARK_BIT_PER_OBJ # define PUSH_CONTENTS_HDR(current, mark_stack_top, mark_stack_limit, \ source, exit_label, hhdr, do_offset_check) \ do { \ size_t displ = HBLKDISPL(current); /* Displacement in block; in bytes. */\ unsigned32 low_prod, high_prod; \ unsigned32 inv_sz = hhdr -> hb_inv_sz; \ ptr_t base = current; \ LONG_MULT(high_prod, low_prod, displ, inv_sz); \ /* product is > and within sz_in_bytes of displ * sz_in_bytes * 2**32 */ \ if (EXPECT(low_prod >> 16 != 0, FALSE)) { \ /* FIXME: fails if offset is a multiple of HBLKSIZE which becomes 0 */ \ if (inv_sz == LARGE_INV_SZ) { \ size_t obj_displ; \ base = (ptr_t)(hhdr -> hb_block); \ obj_displ = (ptr_t)(current) - base; \ if (obj_displ != displ) { \ GC_ASSERT(obj_displ < hhdr -> hb_sz); \ /* Must be in all_interior_pointer case, not first block */ \ /* already did validity check on cache miss. */ \ } else { \ if (do_offset_check && !GC_valid_offsets[obj_displ]) { \ GC_ADD_TO_BLACK_LIST_NORMAL(current, source); \ goto exit_label; \ } \ } \ GC_ASSERT(hhdr -> hb_sz > HBLKSIZE || \ hhdr -> hb_block == HBLKPTR(current)); \ GC_ASSERT((word)hhdr->hb_block < (word)(current)); \ } else { \ /* Accurate enough if HBLKSIZE <= 2**15. */ \ GC_STATIC_ASSERT(HBLKSIZE <= (1 << 15)); \ size_t obj_displ = (((low_prod >> 16) + 1) * (hhdr->hb_sz)) >> 16; \ if (do_offset_check && !GC_valid_offsets[obj_displ]) { \ GC_ADD_TO_BLACK_LIST_NORMAL(current, source); \ goto exit_label; \ } \ base -= obj_displ; \ } \ } \ /* May get here for pointer to start of block not at */ \ /* beginning of object. If so, it's valid, and we're fine. */ \ GC_ASSERT(high_prod <= HBLK_OBJS(hhdr -> hb_sz)); \ TRACE(source, GC_log_printf("GC #%u: passed validity tests\n", \ (unsigned)GC_gc_no)); \ SET_MARK_BIT_EXIT_IF_SET(hhdr, high_prod, exit_label); \ TRACE(source, GC_log_printf("GC #%u: previously unmarked\n", \ (unsigned)GC_gc_no)); \ TRACE_TARGET(base, \ GC_log_printf("GC #%u: marking %p from %p instead\n", \ (unsigned)GC_gc_no, base, source)); \ INCR_MARKS(hhdr); \ GC_STORE_BACK_PTR((ptr_t)source, base); \ PUSH_OBJ(base, hhdr, mark_stack_top, mark_stack_limit); \ } while (0) #endif /* MARK_BIT_PER_OBJ */ #if defined(PRINT_BLACK_LIST) || defined(KEEP_BACK_PTRS) # define PUSH_ONE_CHECKED_STACK(p, source) \ GC_mark_and_push_stack((ptr_t)(p), (ptr_t)(source)) #else # define PUSH_ONE_CHECKED_STACK(p, source) \ GC_mark_and_push_stack((ptr_t)(p)) #endif /* * Push a single value onto mark stack. Mark from the object pointed to by p. * Invoke FIXUP_POINTER(p) before any further processing. * P is considered valid even if it is an interior pointer. * Previously marked objects are not pushed. Hence we make progress even * if the mark stack overflows. */ #if NEED_FIXUP_POINTER /* Try both the raw version and the fixed up one. */ # define GC_PUSH_ONE_STACK(p, source) \ do { \ if ((word)(p) >= (word)GC_least_plausible_heap_addr \ && (word)(p) < (word)GC_greatest_plausible_heap_addr) { \ PUSH_ONE_CHECKED_STACK(p, source); \ } \ FIXUP_POINTER(p); \ if ((word)(p) >= (word)GC_least_plausible_heap_addr \ && (word)(p) < (word)GC_greatest_plausible_heap_addr) { \ PUSH_ONE_CHECKED_STACK(p, source); \ } \ } while (0) #else /* !NEED_FIXUP_POINTER */ # define GC_PUSH_ONE_STACK(p, source) \ do { \ if ((word)(p) >= (word)GC_least_plausible_heap_addr \ && (word)(p) < (word)GC_greatest_plausible_heap_addr) { \ PUSH_ONE_CHECKED_STACK(p, source); \ } \ } while (0) #endif /* As above, but interior pointer recognition as for normal heap pointers. */ #define GC_PUSH_ONE_HEAP(p,source,mark_stack_top) \ do { \ FIXUP_POINTER(p); \ if ((word)(p) >= (word)GC_least_plausible_heap_addr \ && (word)(p) < (word)GC_greatest_plausible_heap_addr) \ mark_stack_top = GC_mark_and_push((void *)(p), mark_stack_top, \ GC_mark_stack_limit, (void * *)(source)); \ } while (0) /* Mark starting at mark stack entry top (incl.) down to */ /* mark stack entry bottom (incl.). Stop after performing */ /* about one page worth of work. Return the new mark stack */ /* top entry. */ GC_INNER mse * GC_mark_from(mse * top, mse * bottom, mse *limit); #define MARK_FROM_MARK_STACK() \ GC_mark_stack_top = GC_mark_from(GC_mark_stack_top, \ GC_mark_stack, \ GC_mark_stack + GC_mark_stack_size); #define GC_mark_stack_empty() ((word)GC_mark_stack_top < (word)GC_mark_stack) /* * Mark from one finalizable object using the specified * mark proc. May not mark the object pointed to by * real_ptr. That is the job of the caller, if appropriate. * Note that this is called with the mutator running, but * with us holding the allocation lock. This is safe only if the * mutator needs the allocation lock to reveal hidden pointers. * FIXME: Why do we need the GC_mark_state test below? */ #define GC_MARK_FO(real_ptr, mark_proc) \ do { \ (*(mark_proc))(real_ptr); \ while (!GC_mark_stack_empty()) MARK_FROM_MARK_STACK(); \ if (GC_mark_state != MS_NONE) { \ GC_set_mark_bit(real_ptr); \ while (!GC_mark_some((ptr_t)0)) { /* empty */ } \ } \ } while (0) GC_EXTERN GC_bool GC_mark_stack_too_small; /* We need a larger mark stack. May be */ /* set by client supplied mark routines.*/ typedef int mark_state_t; /* Current state of marking, as follows:*/ /* Used to remember where we are during */ /* concurrent marking. */ /* We say something is dirty if it was */ /* written since the last time we */ /* retrieved dirty bits. We say it's */ /* grungy if it was marked dirty in the */ /* last set of bits we retrieved. */ /* Invariant I: all roots and marked */ /* objects p are either dirty, or point */ /* to objects q that are either marked */ /* or a pointer to q appears in a range */ /* on the mark stack. */ #define MS_NONE 0 /* No marking in progress. I holds. */ /* Mark stack is empty. */ #define MS_PUSH_RESCUERS 1 /* Rescuing objects are currently */ /* being pushed. I holds, except */ /* that grungy roots may point to */ /* unmarked objects, as may marked */ /* grungy objects above scan_ptr. */ #define MS_PUSH_UNCOLLECTABLE 2 /* I holds, except that marked */ /* uncollectible objects above scan_ptr */ /* may point to unmarked objects. */ /* Roots may point to unmarked objects */ #define MS_ROOTS_PUSHED 3 /* I holds, mark stack may be nonempty */ #define MS_PARTIALLY_INVALID 4 /* I may not hold, e.g. because of M.S. */ /* overflow. However marked heap */ /* objects below scan_ptr point to */ /* marked or stacked objects. */ #define MS_INVALID 5 /* I may not hold. */ GC_EXTERN mark_state_t GC_mark_state; #endif /* GC_PMARK_H */ ecl-16.1.2/src/bdwgc/include/private/gc_priv.h000066400000000000000000003234161266352375300211450ustar00rootroot00000000000000/* * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. * Copyright (c) 1999-2004 Hewlett-Packard Development Company, L.P. * * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. */ #ifndef GC_PRIVATE_H #define GC_PRIVATE_H #ifdef HAVE_CONFIG_H # include "config.h" #endif #ifndef GC_BUILD # define GC_BUILD #endif #if (defined(__linux__) || defined(__GLIBC__) || defined(__GNU__)) \ && !defined(_GNU_SOURCE) /* Can't test LINUX, since this must be defined before other includes. */ # define _GNU_SOURCE 1 #endif #if (defined(DGUX) && defined(GC_THREADS) || defined(DGUX386_THREADS) \ || defined(GC_DGUX386_THREADS)) && !defined(_USING_POSIX4A_DRAFT10) # define _USING_POSIX4A_DRAFT10 1 #endif # if defined(NO_DEBUGGING) && !defined(GC_ASSERTIONS) && !defined(NDEBUG) /* To turn off assertion checking (in atomic_ops.h). */ # define NDEBUG 1 # endif #ifndef GC_H # include "../gc.h" #endif #include #if !defined(sony_news) # include #endif #ifdef DGUX # include # include # include #endif /* DGUX */ #ifdef BSD_TIME # include # include # include #endif /* BSD_TIME */ #ifdef PARALLEL_MARK # define AO_REQUIRE_CAS # if !defined(__GNUC__) && !defined(AO_ASSUME_WINDOWS98) # define AO_ASSUME_WINDOWS98 # endif #endif #ifndef GC_TINY_FL_H # include "../gc_tiny_fl.h" #endif #ifndef GC_MARK_H # include "../gc_mark.h" #endif typedef GC_word word; typedef GC_signed_word signed_word; typedef unsigned int unsigned32; typedef int GC_bool; #define TRUE 1 #define FALSE 0 typedef char * ptr_t; /* A generic pointer to which we can add */ /* byte displacements and which can be used */ /* for address comparisons. */ #ifndef GCCONFIG_H # include "gcconfig.h" #endif #ifndef GC_INNER /* This tagging macro must be used at the start of every variable */ /* definition which is declared with GC_EXTERN. Should be also used */ /* for the GC-scope function definitions and prototypes. Must not be */ /* used in gcconfig.h. Shouldn't be used for the debugging-only */ /* functions. Currently, not used for the functions declared in or */ /* called from the "dated" source files (pcr_interface.c and files */ /* located in the "extra" folder). */ # if defined(GC_DLL) && defined(__GNUC__) && !defined(MSWIN32) \ && !defined(MSWINCE) && !defined(CYGWIN32) # if __GNUC__ >= 4 /* See the corresponding GC_API definition. */ # define GC_INNER __attribute__((__visibility__("hidden"))) # else /* The attribute is unsupported. */ # define GC_INNER /* empty */ # endif # else # define GC_INNER /* empty */ # endif # define GC_EXTERN extern GC_INNER /* Used only for the GC-scope variables (prefixed with "GC_") */ /* declared in the header files. Must not be used for thread-local */ /* variables. Must not be used in gcconfig.h. Shouldn't be used for */ /* the debugging-only or profiling-only variables. Currently, not */ /* used for the variables accessed from the "dated" source files */ /* (pcr_interface.c, specific.c/h, and in the "extra" folder). */ /* The corresponding variable definition must start with GC_INNER. */ #endif /* !GC_INNER */ #ifndef HEADERS_H # include "gc_hdrs.h" #endif #ifndef GC_ATTR_UNUSED # if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) # define GC_ATTR_UNUSED __attribute__((__unused__)) # else # define GC_ATTR_UNUSED /* empty */ # endif #endif /* !GC_ATTR_UNUSED */ #if __GNUC__ >= 3 && !defined(LINT2) # define EXPECT(expr, outcome) __builtin_expect(expr,outcome) /* Equivalent to (expr), but predict that usually (expr)==outcome. */ #else # define EXPECT(expr, outcome) (expr) #endif /* __GNUC__ */ #ifdef HAVE_CONFIG_H /* The "inline" keyword is determined by Autoconf AC_C_INLINE. */ # define GC_INLINE static inline #elif defined(_MSC_VER) || defined(__INTEL_COMPILER) || defined(__DMC__) \ || ((__GNUC__ >= 3) && defined(__STRICT_ANSI__)) \ || defined(__WATCOMC__) # define GC_INLINE static __inline #elif (__GNUC__ >= 3) || defined(__sun) # define GC_INLINE static inline #else # define GC_INLINE static #endif #ifndef GC_API_OSCALL /* This is used to identify GC routines called by name from OS. */ # if defined(__GNUC__) # if __GNUC__ >= 4 /* Same as GC_API if GC_DLL. */ # define GC_API_OSCALL extern __attribute__((__visibility__("default"))) # else /* The attribute is unsupported. */ # define GC_API_OSCALL extern # endif # else # define GC_API_OSCALL GC_API # endif #endif #ifndef GC_API_PRIV # define GC_API_PRIV GC_API #endif #ifndef GC_LOCKS_H # include "gc_locks.h" #endif #define ONES ((word)(signed_word)(-1)) # ifdef STACK_GROWS_DOWN # define COOLER_THAN > # define HOTTER_THAN < # define MAKE_COOLER(x,y) if ((word)((x) + (y)) > (word)(x)) {(x) += (y);} \ else (x) = (ptr_t)ONES # define MAKE_HOTTER(x,y) (x) -= (y) # else # define COOLER_THAN < # define HOTTER_THAN > # define MAKE_COOLER(x,y) if ((word)((x) - (y)) < (word)(x)) {(x) -= (y);} \ else (x) = 0 # define MAKE_HOTTER(x,y) (x) += (y) # endif #if defined(AMIGA) && defined(__SASC) # define GC_FAR __far #else # define GC_FAR #endif /*********************************/ /* */ /* Definitions for conservative */ /* collector */ /* */ /*********************************/ /*********************************/ /* */ /* Easily changeable parameters */ /* */ /*********************************/ /* #define STUBBORN_ALLOC */ /* Enable stubborn allocation, and thus a limited */ /* form of incremental collection w/o dirty bits. */ /* #define ALL_INTERIOR_POINTERS */ /* Forces all pointers into the interior of an */ /* object to be considered valid. Also causes the */ /* sizes of all objects to be inflated by at least */ /* one byte. This should suffice to guarantee */ /* that in the presence of a compiler that does */ /* not perform garbage-collector-unsafe */ /* optimizations, all portable, strictly ANSI */ /* conforming C programs should be safely usable */ /* with malloc replaced by GC_malloc and free */ /* calls removed. There are several disadvantages: */ /* 1. There are probably no interesting, portable, */ /* strictly ANSI conforming C programs. */ /* 2. This option makes it hard for the collector */ /* to allocate space that is not "pointed to" */ /* by integers, etc. Under SunOS 4.X with a */ /* statically linked libc, we empirically */ /* observed that it would be difficult to */ /* allocate individual objects larger than 100K. */ /* Even if only smaller objects are allocated, */ /* more swap space is likely to be needed. */ /* Fortunately, much of this will never be */ /* touched. */ /* If you can easily avoid using this option, do. */ /* If not, try to keep individual objects small. */ /* This is now really controlled at startup, */ /* through GC_all_interior_pointers. */ #ifndef GC_NO_FINALIZATION # define GC_INVOKE_FINALIZERS() GC_notify_or_invoke_finalizers() GC_INNER void GC_notify_or_invoke_finalizers(void); /* If GC_finalize_on_demand is not set, invoke */ /* eligible finalizers. Otherwise: */ /* Call *GC_finalizer_notifier if there are */ /* finalizers to be run, and we haven't called */ /* this procedure yet this GC cycle. */ GC_INNER void GC_push_finalizer_structures(void); GC_INNER void GC_finalize(void); /* Perform all indicated finalization actions */ /* on unmarked objects. */ /* Unreachable finalizable objects are enqueued */ /* for processing by GC_invoke_finalizers. */ /* Invoked with lock. */ # ifndef SMALL_CONFIG GC_INNER void GC_print_finalization_stats(void); # endif #else # define GC_INVOKE_FINALIZERS() (void)0 #endif /* GC_NO_FINALIZATION */ #if !defined(DONT_ADD_BYTE_AT_END) # ifdef LINT2 /* Explicitly instruct the code analysis tool that */ /* GC_all_interior_pointers is assumed to have only 0 or 1 value. */ # define EXTRA_BYTES (GC_all_interior_pointers? 1 : 0) # else # define EXTRA_BYTES GC_all_interior_pointers # endif # define MAX_EXTRA_BYTES 1 #else # define EXTRA_BYTES 0 # define MAX_EXTRA_BYTES 0 #endif # ifndef LARGE_CONFIG # define MINHINCR 16 /* Minimum heap increment, in blocks of HBLKSIZE */ /* Must be multiple of largest page size. */ # define MAXHINCR 2048 /* Maximum heap increment, in blocks */ # else # define MINHINCR 64 # define MAXHINCR 4096 # endif # define BL_LIMIT GC_black_list_spacing /* If we need a block of N bytes, and we have */ /* a block of N + BL_LIMIT bytes available, */ /* and N > BL_LIMIT, */ /* but all possible positions in it are */ /* blacklisted, we just use it anyway (and */ /* print a warning, if warnings are enabled). */ /* This risks subsequently leaking the block */ /* due to a false reference. But not using */ /* the block risks unreasonable immediate */ /* heap growth. */ /*********************************/ /* */ /* Stack saving for debugging */ /* */ /*********************************/ #ifdef NEED_CALLINFO struct callinfo { word ci_pc; /* Caller, not callee, pc */ # if NARGS > 0 word ci_arg[NARGS]; /* bit-wise complement to avoid retention */ # endif # if (NFRAMES * (NARGS + 1)) % 2 == 1 /* Likely alignment problem. */ word ci_dummy; # endif }; #endif #ifdef SAVE_CALL_CHAIN /* Fill in the pc and argument information for up to NFRAMES of my */ /* callers. Ignore my frame and my callers frame. */ GC_INNER void GC_save_callers(struct callinfo info[NFRAMES]); GC_INNER void GC_print_callers(struct callinfo info[NFRAMES]); #endif /*********************************/ /* */ /* OS interface routines */ /* */ /*********************************/ #ifdef BSD_TIME # undef CLOCK_TYPE # undef GET_TIME # undef MS_TIME_DIFF # define CLOCK_TYPE struct timeval # define GET_TIME(x) \ do { \ struct rusage rusage; \ getrusage(RUSAGE_SELF, &rusage); \ x = rusage.ru_utime; \ } while (0) # define MS_TIME_DIFF(a,b) ((unsigned long)(a.tv_sec - b.tv_sec) * 1000 \ + (unsigned long)(a.tv_usec - b.tv_usec) / 1000) #elif defined(MSWIN32) || defined(MSWINCE) # ifndef WIN32_LEAN_AND_MEAN # define WIN32_LEAN_AND_MEAN 1 # endif # define NOSERVICE # include # include # define CLOCK_TYPE DWORD # define GET_TIME(x) (void)(x = GetTickCount()) # define MS_TIME_DIFF(a,b) ((long)((a)-(b))) #else /* !MSWIN32, !MSWINCE, !BSD_TIME */ # include # if defined(FREEBSD) && !defined(CLOCKS_PER_SEC) # include # define CLOCKS_PER_SEC CLK_TCK # endif # if !defined(CLOCKS_PER_SEC) # define CLOCKS_PER_SEC 1000000 /* This is technically a bug in the implementation. */ /* ANSI requires that CLOCKS_PER_SEC be defined. But at least */ /* under SunOS 4.1.1, it isn't. Also note that the combination of */ /* ANSI C and POSIX is incredibly gross here. The type clock_t */ /* is used by both clock() and times(). But on some machines */ /* these use different notions of a clock tick, CLOCKS_PER_SEC */ /* seems to apply only to clock. Hence we use it here. On many */ /* machines, including SunOS, clock actually uses units of */ /* microseconds (which are not really clock ticks). */ # endif # define CLOCK_TYPE clock_t # define GET_TIME(x) (void)(x = clock()) # define MS_TIME_DIFF(a,b) (CLOCKS_PER_SEC % 1000 == 0 ? \ (unsigned long)((a) - (b)) / (unsigned long)(CLOCKS_PER_SEC / 1000) \ : ((unsigned long)((a) - (b)) * 1000) / (unsigned long)CLOCKS_PER_SEC) /* Avoid using double type since some targets (like ARM) might */ /* require -lm option for double-to-long conversion. */ #endif /* !BSD_TIME && !MSWIN32 */ /* We use bzero and bcopy internally. They may not be available. */ # if defined(SPARC) && defined(SUNOS4) # define BCOPY_EXISTS # endif # if defined(M68K) && defined(AMIGA) # define BCOPY_EXISTS # endif # if defined(M68K) && defined(NEXT) # define BCOPY_EXISTS # endif # if defined(VAX) # define BCOPY_EXISTS # endif # if defined(AMIGA) # include # define BCOPY_EXISTS # endif # if defined(DARWIN) # include # define BCOPY_EXISTS # endif # if defined(MACOS) && defined(POWERPC) # include # define bcopy(x,y,n) BlockMoveData(x, y, n) # define bzero(x,n) BlockZero(x, n) # define BCOPY_EXISTS # endif # ifndef BCOPY_EXISTS # include # define BCOPY(x,y,n) memcpy(y, x, (size_t)(n)) # define BZERO(x,n) memset(x, 0, (size_t)(n)) # else # define BCOPY(x,y,n) bcopy((void *)(x),(void *)(y),(size_t)(n)) # define BZERO(x,n) bzero((void *)(x),(size_t)(n)) # endif /* * Stop and restart mutator threads. */ # ifdef PCR # include "th/PCR_ThCtl.h" # define STOP_WORLD() \ PCR_ThCtl_SetExclusiveMode(PCR_ThCtl_ExclusiveMode_stopNormal, \ PCR_allSigsBlocked, \ PCR_waitForever) # define START_WORLD() \ PCR_ThCtl_SetExclusiveMode(PCR_ThCtl_ExclusiveMode_null, \ PCR_allSigsBlocked, \ PCR_waitForever) # else # if defined(GC_WIN32_THREADS) || defined(GC_PTHREADS) GC_INNER void GC_stop_world(void); GC_INNER void GC_start_world(void); # define STOP_WORLD() GC_stop_world() # define START_WORLD() GC_start_world() # else /* Just do a sanity check: we are not inside GC_do_blocking(). */ # define STOP_WORLD() GC_ASSERT(GC_blocked_sp == NULL) # define START_WORLD() # endif # endif /* Abandon ship */ # ifdef PCR # define ABORT(s) PCR_Base_Panic(s) # else # if defined(MSWINCE) && !defined(DebugBreak) \ && (!defined(UNDER_CE) || (defined(__MINGW32CE__) && !defined(ARM32))) /* This simplifies linking for WinCE (and, probably, doesn't */ /* hurt debugging much); use -DDebugBreak=DebugBreak to override */ /* this behavior if really needed. This is also a workaround for */ /* x86mingw32ce toolchain (if it is still declaring DebugBreak() */ /* instead of defining it as a macro). */ # define DebugBreak() _exit(-1) /* there is no abort() in WinCE */ # endif # ifdef SMALL_CONFIG # define GC_on_abort(msg) (void)0 /* be silent on abort */ # else GC_API_PRIV GC_abort_func GC_on_abort; # endif /* !SMALL_CONFIG */ # if defined(MSWIN32) && (defined(NO_DEBUGGING) || defined(LINT2)) /* A more user-friendly abort after showing fatal message. */ # define ABORT(msg) (GC_on_abort(msg), _exit(-1)) /* Exit on error without running "at-exit" callbacks. */ # elif defined(MSWINCE) && defined(NO_DEBUGGING) # define ABORT(msg) (GC_on_abort(msg), ExitProcess(-1)) # elif defined(MSWIN32) || defined(MSWINCE) # define ABORT(msg) { GC_on_abort(msg); DebugBreak(); } /* Note that: on a WinCE box, this could be silently */ /* ignored (i.e., the program is not aborted); */ /* DebugBreak is a statement in some toolchains. */ # else # define ABORT(msg) (GC_on_abort(msg), abort()) # endif /* !MSWIN32 */ # endif /* !PCR */ /* For abort message with 1-3 arguments. C_msg and C_fmt should be */ /* literals. C_msg should not contain format specifiers. Arguments */ /* should match their format specifiers. */ #define ABORT_ARG1(C_msg, C_fmt, arg1) \ do { \ GC_COND_LOG_PRINTF(C_msg /* + */ C_fmt, arg1); \ ABORT(C_msg); \ } while (0) #define ABORT_ARG2(C_msg, C_fmt, arg1, arg2) \ do { \ GC_COND_LOG_PRINTF(C_msg /* + */ C_fmt, arg1, arg2); \ ABORT(C_msg); \ } while (0) #define ABORT_ARG3(C_msg, C_fmt, arg1, arg2, arg3) \ do { \ GC_COND_LOG_PRINTF(C_msg /* + */ C_fmt, arg1, arg2, arg3); \ ABORT(C_msg); \ } while (0) /* Same as ABORT but does not have 'no-return' attribute. */ /* ABORT on a dummy condition (which is always true). */ #define ABORT_RET(msg) \ if ((signed_word)GC_current_warn_proc == -1) {} else ABORT(msg) /* Exit abnormally, but without making a mess (e.g. out of memory) */ # ifdef PCR # define EXIT() PCR_Base_Exit(1,PCR_waitForever) # else # define EXIT() (GC_on_abort(NULL), exit(1 /* EXIT_FAILURE */)) # endif /* Print warning message, e.g. almost out of memory. */ /* The argument (if any) format specifier should be: */ /* "%s", "%p" or "%"WARN_PRIdPTR. */ #define WARN(msg, arg) (*GC_current_warn_proc)("GC Warning: " msg, \ (GC_word)(arg)) GC_EXTERN GC_warn_proc GC_current_warn_proc; /* Print format type macro for decimal signed_word value passed WARN(). */ /* This could be redefined for Win64 or LLP64, but typically should */ /* not be done as the WARN format string is, possibly, processed on the */ /* client side, so non-standard print type modifiers (like MS "I64d") */ /* should be avoided here if possible. */ #ifndef WARN_PRIdPTR /* Assume sizeof(void *) == sizeof(long) (or a little-endian machine) */ # define WARN_PRIdPTR "ld" #endif /* Get environment entry */ #ifdef GC_READ_ENV_FILE GC_INNER char * GC_envfile_getenv(const char *name); # define GETENV(name) GC_envfile_getenv(name) #elif defined(NO_GETENV) # define GETENV(name) NULL #elif defined(EMPTY_GETENV_RESULTS) /* Workaround for a reputed Wine bug. */ GC_INLINE char * fixed_getenv(const char *name) { char *value = getenv(name); return value != NULL && *value != '\0' ? value : NULL; } # define GETENV(name) fixed_getenv(name) #else # define GETENV(name) getenv(name) #endif #if defined(DARWIN) # include # ifndef MAC_OS_X_VERSION_MAX_ALLOWED # include /* Include this header just to import the above macro. */ # endif # if defined(POWERPC) # if CPP_WORDSZ == 32 # define GC_THREAD_STATE_T ppc_thread_state_t # else # define GC_THREAD_STATE_T ppc_thread_state64_t # define GC_MACH_THREAD_STATE PPC_THREAD_STATE64 # define GC_MACH_THREAD_STATE_COUNT PPC_THREAD_STATE64_COUNT # endif # elif defined(I386) || defined(X86_64) # if CPP_WORDSZ == 32 # if defined(i386_THREAD_STATE_COUNT) && !defined(x86_THREAD_STATE32_COUNT) /* Use old naming convention for 32-bit x86. */ # define GC_THREAD_STATE_T i386_thread_state_t # define GC_MACH_THREAD_STATE i386_THREAD_STATE # define GC_MACH_THREAD_STATE_COUNT i386_THREAD_STATE_COUNT # else # define GC_THREAD_STATE_T x86_thread_state32_t # define GC_MACH_THREAD_STATE x86_THREAD_STATE32 # define GC_MACH_THREAD_STATE_COUNT x86_THREAD_STATE32_COUNT # endif # else # define GC_THREAD_STATE_T x86_thread_state64_t # define GC_MACH_THREAD_STATE x86_THREAD_STATE64 # define GC_MACH_THREAD_STATE_COUNT x86_THREAD_STATE64_COUNT # endif # elif defined(ARM32) && defined(ARM_UNIFIED_THREAD_STATE) # define GC_THREAD_STATE_T arm_unified_thread_state_t # define GC_MACH_THREAD_STATE ARM_UNIFIED_THREAD_STATE # define GC_MACH_THREAD_STATE_COUNT ARM_UNIFIED_THREAD_STATE_COUNT # elif defined(ARM32) # define GC_THREAD_STATE_T arm_thread_state_t # ifdef ARM_MACHINE_THREAD_STATE_COUNT # define GC_MACH_THREAD_STATE ARM_MACHINE_THREAD_STATE # define GC_MACH_THREAD_STATE_COUNT ARM_MACHINE_THREAD_STATE_COUNT # endif # elif defined(AARCH64) # define GC_THREAD_STATE_T arm_thread_state64_t # define GC_MACH_THREAD_STATE ARM_THREAD_STATE64 # define GC_MACH_THREAD_STATE_COUNT ARM_THREAD_STATE64_COUNT # else # error define GC_THREAD_STATE_T # endif # ifndef GC_MACH_THREAD_STATE # define GC_MACH_THREAD_STATE MACHINE_THREAD_STATE # define GC_MACH_THREAD_STATE_COUNT MACHINE_THREAD_STATE_COUNT # endif # if CPP_WORDSZ == 32 # define GC_MACH_HEADER mach_header # define GC_MACH_SECTION section # define GC_GETSECTBYNAME getsectbynamefromheader # else # define GC_MACH_HEADER mach_header_64 # define GC_MACH_SECTION section_64 # define GC_GETSECTBYNAME getsectbynamefromheader_64 # endif /* Try to work out the right way to access thread state structure */ /* members. The structure has changed its definition in different */ /* Darwin versions. This now defaults to the (older) names */ /* without __, thus hopefully, not breaking any existing */ /* Makefile.direct builds. */ # if __DARWIN_UNIX03 # if defined(ARM32) && defined(ARM_UNIFIED_THREAD_STATE) # define THREAD_FLD(x) ts_32.__ ## x # else # define THREAD_FLD(x) __ ## x # endif # else # if defined(ARM32) && defined(ARM_UNIFIED_THREAD_STATE) # define THREAD_FLD(x) ts_32. ## x # else # define THREAD_FLD(x) x # endif # endif #endif /* DARWIN */ /*********************************/ /* */ /* Word-size-dependent defines */ /* */ /*********************************/ #if CPP_WORDSZ == 32 # define WORDS_TO_BYTES(x) ((x)<<2) # define BYTES_TO_WORDS(x) ((x)>>2) # define LOGWL ((word)5) /* log[2] of CPP_WORDSZ */ # define modWORDSZ(n) ((n) & 0x1f) /* n mod size of word */ # if ALIGNMENT != 4 # define UNALIGNED_PTRS # endif #endif #if CPP_WORDSZ == 64 # define WORDS_TO_BYTES(x) ((x)<<3) # define BYTES_TO_WORDS(x) ((x)>>3) # define LOGWL ((word)6) /* log[2] of CPP_WORDSZ */ # define modWORDSZ(n) ((n) & 0x3f) /* n mod size of word */ # if ALIGNMENT != 8 # define UNALIGNED_PTRS # endif #endif /* The first TINY_FREELISTS free lists correspond to the first */ /* TINY_FREELISTS multiples of GRANULE_BYTES, i.e. we keep */ /* separate free lists for each multiple of GRANULE_BYTES */ /* up to (TINY_FREELISTS-1) * GRANULE_BYTES. After that they */ /* may be spread out further. */ #include "../gc_tiny_fl.h" #define GRANULE_BYTES GC_GRANULE_BYTES #define TINY_FREELISTS GC_TINY_FREELISTS #define WORDSZ ((word)CPP_WORDSZ) #define SIGNB ((word)1 << (WORDSZ-1)) #define BYTES_PER_WORD ((word)(sizeof (word))) #define divWORDSZ(n) ((n) >> LOGWL) /* divide n by size of word */ #if GRANULE_BYTES == 8 # define BYTES_TO_GRANULES(n) ((n)>>3) # define GRANULES_TO_BYTES(n) ((n)<<3) # if CPP_WORDSZ == 64 # define GRANULES_TO_WORDS(n) (n) # elif CPP_WORDSZ == 32 # define GRANULES_TO_WORDS(n) ((n)<<1) # else # define GRANULES_TO_WORDS(n) BYTES_TO_WORDS(GRANULES_TO_BYTES(n)) # endif #elif GRANULE_BYTES == 16 # define BYTES_TO_GRANULES(n) ((n)>>4) # define GRANULES_TO_BYTES(n) ((n)<<4) # if CPP_WORDSZ == 64 # define GRANULES_TO_WORDS(n) ((n)<<1) # elif CPP_WORDSZ == 32 # define GRANULES_TO_WORDS(n) ((n)<<2) # else # define GRANULES_TO_WORDS(n) BYTES_TO_WORDS(GRANULES_TO_BYTES(n)) # endif #else # error Bad GRANULE_BYTES value #endif /*********************/ /* */ /* Size Parameters */ /* */ /*********************/ /* Heap block size, bytes. Should be power of 2. */ /* Incremental GC with MPROTECT_VDB currently requires the */ /* page size to be a multiple of HBLKSIZE. Since most modern */ /* architectures support variable page sizes down to 4K, and */ /* X86 is generally 4K, we now default to 4K, except for */ /* Alpha: Seems to be used with 8K pages. */ /* SMALL_CONFIG: Want less block-level fragmentation. */ #ifndef HBLKSIZE # if defined(LARGE_CONFIG) || !defined(SMALL_CONFIG) # ifdef ALPHA # define CPP_LOG_HBLKSIZE 13 # else # define CPP_LOG_HBLKSIZE 12 # endif # else # define CPP_LOG_HBLKSIZE 10 # endif #else # if HBLKSIZE == 512 # define CPP_LOG_HBLKSIZE 9 # elif HBLKSIZE == 1024 # define CPP_LOG_HBLKSIZE 10 # elif HBLKSIZE == 2048 # define CPP_LOG_HBLKSIZE 11 # elif HBLKSIZE == 4096 # define CPP_LOG_HBLKSIZE 12 # elif HBLKSIZE == 8192 # define CPP_LOG_HBLKSIZE 13 # elif HBLKSIZE == 16384 # define CPP_LOG_HBLKSIZE 14 # else --> fix HBLKSIZE # endif # undef HBLKSIZE #endif # define CPP_HBLKSIZE (1 << CPP_LOG_HBLKSIZE) # define LOG_HBLKSIZE ((size_t)CPP_LOG_HBLKSIZE) # define HBLKSIZE ((size_t)CPP_HBLKSIZE) /* max size objects supported by freelist (larger objects are */ /* allocated directly with allchblk(), by rounding to the next */ /* multiple of HBLKSIZE. */ #define CPP_MAXOBJBYTES (CPP_HBLKSIZE/2) #define MAXOBJBYTES ((size_t)CPP_MAXOBJBYTES) #define CPP_MAXOBJWORDS BYTES_TO_WORDS(CPP_MAXOBJBYTES) #define MAXOBJWORDS ((size_t)CPP_MAXOBJWORDS) #define CPP_MAXOBJGRANULES BYTES_TO_GRANULES(CPP_MAXOBJBYTES) #define MAXOBJGRANULES ((size_t)CPP_MAXOBJGRANULES) # define divHBLKSZ(n) ((n) >> LOG_HBLKSIZE) # define HBLK_PTR_DIFF(p,q) divHBLKSZ((ptr_t)p - (ptr_t)q) /* Equivalent to subtracting 2 hblk pointers. */ /* We do it this way because a compiler should */ /* find it hard to use an integer division */ /* instead of a shift. The bundled SunOS 4.1 */ /* o.w. sometimes pessimizes the subtraction to */ /* involve a call to .div. */ # define modHBLKSZ(n) ((n) & (HBLKSIZE-1)) # define HBLKPTR(objptr) ((struct hblk *)(((word) (objptr)) & ~(HBLKSIZE-1))) # define HBLKDISPL(objptr) (((size_t) (objptr)) & (HBLKSIZE-1)) /* Round up allocation size (in bytes) to a multiple of a granule. */ #define ROUNDUP_GRANULE_SIZE(bytes) \ (((bytes) + (GRANULE_BYTES - 1)) & ~(GRANULE_BYTES - 1)) /* Round up byte allocation requests to integral number of words, etc. */ # define ROUNDED_UP_GRANULES(n) \ BYTES_TO_GRANULES((n) + (GRANULE_BYTES - 1 + EXTRA_BYTES)) # if MAX_EXTRA_BYTES == 0 # define SMALL_OBJ(bytes) EXPECT((bytes) <= (MAXOBJBYTES), TRUE) # else # define SMALL_OBJ(bytes) \ (EXPECT((bytes) <= (MAXOBJBYTES - MAX_EXTRA_BYTES), TRUE) \ || (bytes) <= MAXOBJBYTES - EXTRA_BYTES) /* This really just tests bytes <= MAXOBJBYTES - EXTRA_BYTES. */ /* But we try to avoid looking up EXTRA_BYTES. */ # endif # define ADD_SLOP(bytes) ((bytes) + EXTRA_BYTES) # ifndef MIN_WORDS # define MIN_WORDS 2 /* FIXME: obsolete */ # endif /* * Hash table representation of sets of pages. * Implements a map from aligned HBLKSIZE chunks of the address space to one * bit each. * This assumes it is OK to spuriously set bits, e.g. because multiple * addresses are represented by a single location. * Used by black-listing code, and perhaps by dirty bit maintenance code. */ # ifdef LARGE_CONFIG # if CPP_WORDSZ == 32 # define LOG_PHT_ENTRIES 20 /* Collisions likely at 1M blocks, */ /* which is >= 4GB. Each table takes */ /* 128KB, some of which may never be */ /* touched. */ # else # define LOG_PHT_ENTRIES 21 /* Collisions likely at 2M blocks, */ /* which is >= 8GB. Each table takes */ /* 256KB, some of which may never be */ /* touched. */ # endif # elif !defined(SMALL_CONFIG) # define LOG_PHT_ENTRIES 18 /* Collisions are likely if heap grows */ /* to more than 256K hblks >= 1GB. */ /* Each hash table occupies 32K bytes. */ /* Even for somewhat smaller heaps, */ /* say half that, collisions may be an */ /* issue because we blacklist */ /* addresses outside the heap. */ # else # define LOG_PHT_ENTRIES 15 /* Collisions are likely if heap grows */ /* to more than 32K hblks = 128MB. */ /* Each hash table occupies 4K bytes. */ # endif # define PHT_ENTRIES ((word)1 << LOG_PHT_ENTRIES) # define PHT_SIZE (PHT_ENTRIES >> LOGWL) typedef word page_hash_table[PHT_SIZE]; # define PHT_HASH(addr) ((((word)(addr)) >> LOG_HBLKSIZE) & (PHT_ENTRIES - 1)) # define get_pht_entry_from_index(bl, index) \ (((bl)[divWORDSZ(index)] >> modWORDSZ(index)) & 1) # define set_pht_entry_from_index(bl, index) \ (bl)[divWORDSZ(index)] |= (word)1 << modWORDSZ(index) # define clear_pht_entry_from_index(bl, index) \ (bl)[divWORDSZ(index)] &= ~((word)1 << modWORDSZ(index)) /* And a dumb but thread-safe version of set_pht_entry_from_index. */ /* This sets (many) extra bits. */ # define set_pht_entry_from_index_safe(bl, index) \ (bl)[divWORDSZ(index)] = ONES /********************************************/ /* */ /* H e a p B l o c k s */ /* */ /********************************************/ /* heap block header */ #define HBLKMASK (HBLKSIZE-1) #define MARK_BITS_PER_HBLK (HBLKSIZE/GRANULE_BYTES) /* upper bound */ /* We allocate 1 bit per allocation granule. */ /* If MARK_BIT_PER_GRANULE is defined, we use */ /* every nth bit, where n is the number of */ /* allocation granules per object. If */ /* MARK_BIT_PER_OBJ is defined, we only use the */ /* initial group of mark bits, and it is safe */ /* to allocate smaller header for large objects. */ #ifdef PARALLEL_MARK # include "atomic_ops.h" # define counter_t volatile AO_t #else typedef size_t counter_t; # if defined(THREADS) && (defined(MPROTECT_VDB) \ || (defined(GC_ASSERTIONS) && defined(THREAD_LOCAL_ALLOC))) # include "atomic_ops.h" # endif #endif /* !PARALLEL_MARK */ union word_ptr_ao_u { word w; signed_word sw; void *vp; # ifdef AO_HAVE_load volatile AO_t ao; # endif }; /* We maintain layout maps for heap blocks containing objects of a given */ /* size. Each entry in this map describes a byte offset and has the */ /* following type. */ struct hblkhdr { struct hblk * hb_next; /* Link field for hblk free list */ /* and for lists of chunks waiting to be */ /* reclaimed. */ struct hblk * hb_prev; /* Backwards link for free list. */ struct hblk * hb_block; /* The corresponding block. */ unsigned char hb_obj_kind; /* Kind of objects in the block. Each kind */ /* identifies a mark procedure and a set of */ /* list headers. Sometimes called regions. */ unsigned char hb_flags; # define IGNORE_OFF_PAGE 1 /* Ignore pointers that do not */ /* point to the first page of */ /* this object. */ # define WAS_UNMAPPED 2 /* This is a free block, which has */ /* been unmapped from the address */ /* space. */ /* GC_remap must be invoked on it */ /* before it can be reallocated. */ /* Only set with USE_MUNMAP. */ # define FREE_BLK 4 /* Block is free, i.e. not in use. */ # ifdef ENABLE_DISCLAIM # define HAS_DISCLAIM 8 /* This kind has a callback on reclaim. */ # define MARK_UNCONDITIONALLY 0x10 /* Mark from all objects, marked or */ /* not. Used to mark objects needed by */ /* reclaim notifier. */ # endif # ifdef MARK_BIT_PER_GRANULE # define LARGE_BLOCK 0x20 # endif unsigned short hb_last_reclaimed; /* Value of GC_gc_no when block was */ /* last allocated or swept. May wrap. */ /* For a free block, this is maintained */ /* only for USE_MUNMAP, and indicates */ /* when the header was allocated, or */ /* when the size of the block last */ /* changed. */ # ifdef MARK_BIT_PER_OBJ unsigned32 hb_inv_sz; /* A good upper bound for 2**32/hb_sz. */ /* For large objects, we use */ /* LARGE_INV_SZ. */ # define LARGE_INV_SZ (1 << 16) # endif size_t hb_sz; /* If in use, size in bytes, of objects in the block. */ /* if free, the size in bytes of the whole block */ /* We assume that this is convertible to signed_word */ /* without generating a negative result. We avoid */ /* generating free blocks larger than that. */ word hb_descr; /* object descriptor for marking. See */ /* mark.h. */ # ifdef MARK_BIT_PER_GRANULE short * hb_map; /* Essentially a table of remainders */ /* mod BYTES_TO_GRANULES(hb_sz), except */ /* for large blocks. See GC_obj_map. */ # endif counter_t hb_n_marks; /* Number of set mark bits, excluding */ /* the one always set at the end. */ /* Currently it is concurrently */ /* updated and hence only approximate. */ /* But a zero value does guarantee that */ /* the block contains no marked */ /* objects. */ /* Ensuring this property means that we */ /* never decrement it to zero during a */ /* collection, and hence the count may */ /* be one too high. Due to concurrent */ /* updates, an arbitrary number of */ /* increments, but not all of them (!) */ /* may be lost, hence it may in theory */ /* be much too low. */ /* The count may also be too high if */ /* multiple mark threads mark the */ /* same object due to a race. */ /* Without parallel marking, the count */ /* is accurate. */ # ifdef USE_MARK_BYTES # define MARK_BITS_SZ (MARK_BITS_PER_HBLK + 1) /* Unlike the other case, this is in units of bytes. */ /* Since we force double-word alignment, we need at most one */ /* mark bit per 2 words. But we do allocate and set one */ /* extra mark bit to avoid an explicit check for the */ /* partial object at the end of each block. */ union { char _hb_marks[MARK_BITS_SZ]; /* The i'th byte is 1 if the object */ /* starting at granule i or object i is */ /* marked, 0 o.w. */ /* The mark bit for the "one past the */ /* end" object is always set to avoid a */ /* special case test in the marker. */ word dummy; /* Force word alignment of mark bytes. */ } _mark_byte_union; # define hb_marks _mark_byte_union._hb_marks # else # define MARK_BITS_SZ (MARK_BITS_PER_HBLK/CPP_WORDSZ + 1) word hb_marks[MARK_BITS_SZ]; # endif /* !USE_MARK_BYTES */ }; # define ANY_INDEX 23 /* "Random" mark bit index for assertions */ /* heap block body */ # define HBLK_WORDS (HBLKSIZE/sizeof(word)) # define HBLK_GRANULES (HBLKSIZE/GRANULE_BYTES) /* The number of objects in a block dedicated to a certain size. */ /* may erroneously yield zero (instead of one) for large objects. */ # define HBLK_OBJS(sz_in_bytes) (HBLKSIZE/(sz_in_bytes)) struct hblk { char hb_body[HBLKSIZE]; }; # define HBLK_IS_FREE(hdr) (((hdr) -> hb_flags & FREE_BLK) != 0) # define OBJ_SZ_TO_BLOCKS(sz) divHBLKSZ((sz) + HBLKSIZE-1) /* Size of block (in units of HBLKSIZE) needed to hold objects of */ /* given sz (in bytes). */ /* Object free list link */ # define obj_link(p) (*(void **)(p)) # define LOG_MAX_MARK_PROCS 6 # define MAX_MARK_PROCS (1 << LOG_MAX_MARK_PROCS) /* Root sets. Logically private to mark_rts.c. But we don't want the */ /* tables scanned, so we put them here. */ /* MAX_ROOT_SETS is the maximum number of ranges that can be */ /* registered as static roots. */ # ifdef LARGE_CONFIG # define MAX_ROOT_SETS 8192 # elif !defined(SMALL_CONFIG) # define MAX_ROOT_SETS 2048 # else # define MAX_ROOT_SETS 512 # endif # define MAX_EXCLUSIONS (MAX_ROOT_SETS/4) /* Maximum number of segments that can be excluded from root sets. */ /* * Data structure for excluded static roots. */ struct exclusion { ptr_t e_start; ptr_t e_end; }; /* Data structure for list of root sets. */ /* We keep a hash table, so that we can filter out duplicate additions. */ /* Under Win32, we need to do a better job of filtering overlaps, so */ /* we resort to sequential search, and pay the price. */ struct roots { ptr_t r_start;/* multiple of word size */ ptr_t r_end; /* multiple of word size and greater than r_start */ # if !defined(MSWIN32) && !defined(MSWINCE) && !defined(CYGWIN32) struct roots * r_next; # endif GC_bool r_tmp; /* Delete before registering new dynamic libraries */ }; #if !defined(MSWIN32) && !defined(MSWINCE) && !defined(CYGWIN32) /* Size of hash table index to roots. */ # define LOG_RT_SIZE 6 # define RT_SIZE (1 << LOG_RT_SIZE) /* Power of 2, may be != MAX_ROOT_SETS */ #endif #ifndef MAX_HEAP_SECTS # ifdef LARGE_CONFIG # if CPP_WORDSZ > 32 # define MAX_HEAP_SECTS 8192 /* overflows at roughly 128 GB */ # else # define MAX_HEAP_SECTS 768 /* Separately added heap sections. */ # endif # elif defined(SMALL_CONFIG) && !defined(USE_PROC_FOR_LIBRARIES) # if defined(PARALLEL_MARK) && (defined(MSWIN32) || defined(CYGWIN32)) # define MAX_HEAP_SECTS 384 # else # define MAX_HEAP_SECTS 128 /* Roughly 256MB (128*2048*1K) */ # endif # elif CPP_WORDSZ > 32 # define MAX_HEAP_SECTS 1024 /* Roughly 8GB */ # else # define MAX_HEAP_SECTS 512 /* Roughly 4GB */ # endif #endif /* !MAX_HEAP_SECTS */ typedef struct GC_ms_entry { ptr_t mse_start; /* First word of object, word aligned. */ union word_ptr_ao_u mse_descr; /* Descriptor; low order two bits are tags, */ /* as described in gc_mark.h. */ } mse; /* Lists of all heap blocks and free lists */ /* as well as other random data structures */ /* that should not be scanned by the */ /* collector. */ /* These are grouped together in a struct */ /* so that they can be easily skipped by the */ /* GC_mark routine. */ /* The ordering is weird to make GC_malloc */ /* faster by keeping the important fields */ /* sufficiently close together that a */ /* single load of a base register will do. */ /* Scalars that could easily appear to */ /* be pointers are also put here. */ /* The main fields should precede any */ /* conditionally included fields, so that */ /* gc_inl.h will work even if a different set */ /* of macros is defined when the client is */ /* compiled. */ struct _GC_arrays { word _heapsize; /* Heap size in bytes (value never goes down). */ word _requested_heapsize; /* Heap size due to explicit expansion. */ ptr_t _last_heap_addr; ptr_t _prev_heap_addr; word _large_free_bytes; /* Total bytes contained in blocks on large object free */ /* list. */ word _large_allocd_bytes; /* Total number of bytes in allocated large objects blocks. */ /* For the purposes of this counter and the next one only, a */ /* large object is one that occupies a block of at least */ /* 2*HBLKSIZE. */ word _max_large_allocd_bytes; /* Maximum number of bytes that were ever allocated in */ /* large object blocks. This is used to help decide when it */ /* is safe to split up a large block. */ word _bytes_allocd_before_gc; /* Number of bytes allocated before this */ /* collection cycle. */ # ifndef SEPARATE_GLOBALS # define GC_bytes_allocd GC_arrays._bytes_allocd word _bytes_allocd; /* Number of bytes allocated during this collection cycle. */ # endif word _bytes_dropped; /* Number of black-listed bytes dropped during GC cycle */ /* as a result of repeated scanning during allocation */ /* attempts. These are treated largely as allocated, */ /* even though they are not useful to the client. */ word _bytes_finalized; /* Approximate number of bytes in objects (and headers) */ /* that became ready for finalization in the last */ /* collection. */ word _bytes_freed; /* Number of explicitly deallocated bytes of memory */ /* since last collection. */ word _finalizer_bytes_freed; /* Bytes of memory explicitly deallocated while */ /* finalizers were running. Used to approximate mem. */ /* explicitly deallocated by finalizers. */ ptr_t _scratch_end_ptr; ptr_t _scratch_last_end_ptr; /* Used by headers.c, and can easily appear to point to */ /* heap. Also used by GC_register_dynamic_libraries(). */ mse *_mark_stack; /* Limits of stack for GC_mark routine. All ranges */ /* between GC_mark_stack (incl.) and GC_mark_stack_top */ /* (incl.) still need to be marked from. */ mse *_mark_stack_limit; # ifdef PARALLEL_MARK mse *volatile _mark_stack_top; /* Updated only with mark lock held, but read asynchronously. */ /* TODO: Use union to avoid casts to AO_t */ # else mse *_mark_stack_top; # endif word _composite_in_use; /* Number of bytes in the accessible */ /* composite objects. */ word _atomic_in_use; /* Number of bytes in the accessible */ /* atomic objects. */ # ifdef USE_MUNMAP # define GC_unmapped_bytes GC_arrays._unmapped_bytes word _unmapped_bytes; # else # define GC_unmapped_bytes 0 # endif bottom_index * _all_nils; # ifdef ENABLE_TRACE # define GC_trace_addr GC_arrays._trace_addr ptr_t _trace_addr; # endif GC_mark_proc _mark_procs[MAX_MARK_PROCS]; /* Table of user-defined mark procedures. There is */ /* a small number of these, which can be referenced */ /* by DS_PROC mark descriptors. See gc_mark.h. */ char _modws_valid_offsets[sizeof(word)]; /* GC_valid_offsets[i] ==> */ /* GC_modws_valid_offsets[i%sizeof(word)] */ # if !defined(MSWIN32) && !defined(MSWINCE) && !defined(CYGWIN32) # define GC_root_index GC_arrays._root_index struct roots * _root_index[RT_SIZE]; # endif # ifdef SAVE_CALL_CHAIN # define GC_last_stack GC_arrays._last_stack struct callinfo _last_stack[NFRAMES]; /* Stack at last garbage collection. Useful for */ /* debugging mysterious object disappearances. In the */ /* multi-threaded case, we currently only save the */ /* calling stack. */ # endif # ifndef SEPARATE_GLOBALS # define GC_objfreelist GC_arrays._objfreelist void *_objfreelist[MAXOBJGRANULES+1]; /* free list for objects */ # define GC_aobjfreelist GC_arrays._aobjfreelist void *_aobjfreelist[MAXOBJGRANULES+1]; /* free list for atomic objs */ # endif void *_uobjfreelist[MAXOBJGRANULES+1]; /* Uncollectible but traced objs */ /* objects on this and auobjfreelist */ /* are always marked, except during */ /* garbage collections. */ # ifdef ATOMIC_UNCOLLECTABLE # define GC_auobjfreelist GC_arrays._auobjfreelist void *_auobjfreelist[MAXOBJGRANULES+1]; /* Atomic uncollectible but traced objs */ # endif size_t _size_map[MAXOBJBYTES+1]; /* Number of granules to allocate when asked for a certain */ /* number of bytes. */ # ifdef STUBBORN_ALLOC # define GC_sobjfreelist GC_arrays._sobjfreelist ptr_t _sobjfreelist[MAXOBJGRANULES+1]; /* Free list for immutable objects. */ # endif # ifdef MARK_BIT_PER_GRANULE # define GC_obj_map GC_arrays._obj_map short * _obj_map[MAXOBJGRANULES+1]; /* If not NULL, then a pointer to a map of valid */ /* object addresses. */ /* _obj_map[sz_in_granules][i] is */ /* i % sz_in_granules. */ /* This is now used purely to replace a */ /* division in the marker by a table lookup. */ /* _obj_map[0] is used for large objects and */ /* contains all nonzero entries. This gets us */ /* out of the marker fast path without an extra */ /* test. */ # define MAP_LEN BYTES_TO_GRANULES(HBLKSIZE) # endif # define VALID_OFFSET_SZ HBLKSIZE char _valid_offsets[VALID_OFFSET_SZ]; /* GC_valid_offsets[i] == TRUE ==> i */ /* is registered as a displacement. */ # ifdef STUBBORN_ALLOC # define GC_changed_pages GC_arrays._changed_pages page_hash_table _changed_pages; /* Stubborn object pages that were changes since last call to */ /* GC_read_changed. */ # define GC_prev_changed_pages GC_arrays._prev_changed_pages page_hash_table _prev_changed_pages; /* Stubborn object pages that were changes before last call to */ /* GC_read_changed. */ # endif # if defined(PROC_VDB) || defined(MPROTECT_VDB) \ || defined(GWW_VDB) || defined(MANUAL_VDB) # define GC_grungy_pages GC_arrays._grungy_pages page_hash_table _grungy_pages; /* Pages that were dirty at last */ /* GC_read_dirty. */ # endif # if defined(MPROTECT_VDB) || defined(MANUAL_VDB) # define GC_dirty_pages GC_arrays._dirty_pages volatile page_hash_table _dirty_pages; /* Pages dirtied since last GC_read_dirty. */ # endif # if defined(PROC_VDB) || defined(GWW_VDB) # define GC_written_pages GC_arrays._written_pages page_hash_table _written_pages; /* Pages ever dirtied */ # endif # define GC_heap_sects GC_arrays._heap_sects struct HeapSect { ptr_t hs_start; size_t hs_bytes; } _heap_sects[MAX_HEAP_SECTS]; /* Heap segments potentially */ /* client objects. */ # if defined(USE_PROC_FOR_LIBRARIES) # define GC_our_memory GC_arrays._our_memory struct HeapSect _our_memory[MAX_HEAP_SECTS]; /* All GET_MEM allocated */ /* memory. Includes block */ /* headers and the like. */ # endif # if defined(MSWIN32) || defined(MSWINCE) || defined(CYGWIN32) # define GC_heap_bases GC_arrays._heap_bases ptr_t _heap_bases[MAX_HEAP_SECTS]; /* Start address of memory regions obtained from kernel. */ # endif # ifdef MSWINCE # define GC_heap_lengths GC_arrays._heap_lengths word _heap_lengths[MAX_HEAP_SECTS]; /* Committed lengths of memory regions obtained from kernel. */ # endif struct roots _static_roots[MAX_ROOT_SETS]; struct exclusion _excl_table[MAX_EXCLUSIONS]; /* Block header index; see gc_headers.h */ bottom_index * _top_index[TOP_SZ]; }; GC_API_PRIV GC_FAR struct _GC_arrays GC_arrays; #define GC_all_nils GC_arrays._all_nils #define GC_atomic_in_use GC_arrays._atomic_in_use #define GC_bytes_allocd_before_gc GC_arrays._bytes_allocd_before_gc #define GC_bytes_dropped GC_arrays._bytes_dropped #define GC_bytes_finalized GC_arrays._bytes_finalized #define GC_bytes_freed GC_arrays._bytes_freed #define GC_composite_in_use GC_arrays._composite_in_use #define GC_excl_table GC_arrays._excl_table #define GC_finalizer_bytes_freed GC_arrays._finalizer_bytes_freed #define GC_heapsize GC_arrays._heapsize #define GC_large_allocd_bytes GC_arrays._large_allocd_bytes #define GC_large_free_bytes GC_arrays._large_free_bytes #define GC_last_heap_addr GC_arrays._last_heap_addr #define GC_mark_stack GC_arrays._mark_stack #define GC_mark_stack_limit GC_arrays._mark_stack_limit #define GC_mark_stack_top GC_arrays._mark_stack_top #define GC_mark_procs GC_arrays._mark_procs #define GC_max_large_allocd_bytes GC_arrays._max_large_allocd_bytes #define GC_modws_valid_offsets GC_arrays._modws_valid_offsets #define GC_prev_heap_addr GC_arrays._prev_heap_addr #define GC_requested_heapsize GC_arrays._requested_heapsize #define GC_scratch_end_ptr GC_arrays._scratch_end_ptr #define GC_scratch_last_end_ptr GC_arrays._scratch_last_end_ptr #define GC_size_map GC_arrays._size_map #define GC_static_roots GC_arrays._static_roots #define GC_top_index GC_arrays._top_index #define GC_uobjfreelist GC_arrays._uobjfreelist #define GC_valid_offsets GC_arrays._valid_offsets #define beginGC_arrays ((ptr_t)(&GC_arrays)) #define endGC_arrays (((ptr_t)(&GC_arrays)) + (sizeof GC_arrays)) #define USED_HEAP_SIZE (GC_heapsize - GC_large_free_bytes) /* Object kinds: */ #define MAXOBJKINDS 16 GC_EXTERN struct obj_kind { void **ok_freelist; /* Array of free listheaders for this kind of object */ /* Point either to GC_arrays or to storage allocated */ /* with GC_scratch_alloc. */ struct hblk **ok_reclaim_list; /* List headers for lists of blocks waiting to be */ /* swept. */ /* Indexed by object size in granules. */ word ok_descriptor; /* Descriptor template for objects in this */ /* block. */ GC_bool ok_relocate_descr; /* Add object size in bytes to descriptor */ /* template to obtain descriptor. Otherwise */ /* template is used as is. */ GC_bool ok_init; /* Clear objects before putting them on the free list. */ # ifdef ENABLE_DISCLAIM GC_bool ok_mark_unconditionally; /* Mark from all, including unmarked, objects */ /* in block. Used to protect objects reachable */ /* from reclaim notifiers. */ int (GC_CALLBACK *ok_disclaim_proc)(void * /*obj*/); /* The disclaim procedure is called before obj */ /* is reclaimed, but must also tolerate being */ /* called with object from freelist. Non-zero */ /* exit prevents object from being reclaimed. */ # define OK_DISCLAIM_INITZ /* comma */, FALSE, 0 # else # define OK_DISCLAIM_INITZ /* empty */ # endif /* !ENABLE_DISCLAIM */ } GC_obj_kinds[MAXOBJKINDS]; #define beginGC_obj_kinds ((ptr_t)(&GC_obj_kinds)) #define endGC_obj_kinds (beginGC_obj_kinds + (sizeof GC_obj_kinds)) /* Variables that used to be in GC_arrays, but need to be accessed by */ /* inline allocation code. If they were in GC_arrays, the inlined */ /* allocation code would include GC_arrays offsets (as it did), which */ /* introduce maintenance problems. */ #ifdef SEPARATE_GLOBALS extern word GC_bytes_allocd; /* Number of bytes allocated during this collection cycle. */ extern ptr_t GC_objfreelist[MAXOBJGRANULES+1]; /* free list for NORMAL objects */ # define beginGC_objfreelist ((ptr_t)(&GC_objfreelist)) # define endGC_objfreelist (beginGC_objfreelist + sizeof(GC_objfreelist)) extern ptr_t GC_aobjfreelist[MAXOBJGRANULES+1]; /* free list for atomic (PTRFREE) objs */ # define beginGC_aobjfreelist ((ptr_t)(&GC_aobjfreelist)) # define endGC_aobjfreelist (beginGC_aobjfreelist + sizeof(GC_aobjfreelist)) #endif /* SEPARATE_GLOBALS */ /* Predefined kinds: */ #define PTRFREE 0 #define NORMAL 1 #define UNCOLLECTABLE 2 #ifdef ATOMIC_UNCOLLECTABLE # define AUNCOLLECTABLE 3 # define STUBBORN 4 # define IS_UNCOLLECTABLE(k) (((k) & ~1) == UNCOLLECTABLE) #else # define STUBBORN 3 # define IS_UNCOLLECTABLE(k) ((k) == UNCOLLECTABLE) #endif GC_EXTERN unsigned GC_n_kinds; GC_EXTERN word GC_n_heap_sects; /* Number of separately added heap */ /* sections. */ #ifdef USE_PROC_FOR_LIBRARIES GC_EXTERN word GC_n_memory; /* Number of GET_MEM allocated memory */ /* sections. */ #endif GC_EXTERN word GC_page_size; /* Round up allocation size to a multiple of a page size. */ /* GC_setpagesize() is assumed to be already invoked. */ #define ROUNDUP_PAGESIZE(bytes) \ (((bytes) + GC_page_size - 1) & ~(GC_page_size - 1)) /* Same as above but used to make GET_MEM() argument safe. */ #ifdef MMAP_SUPPORTED # define ROUNDUP_PAGESIZE_IF_MMAP(bytes) ROUNDUP_PAGESIZE(bytes) #else # define ROUNDUP_PAGESIZE_IF_MMAP(bytes) (bytes) #endif #if defined(MSWIN32) || defined(MSWINCE) || defined(CYGWIN32) struct _SYSTEM_INFO; GC_EXTERN struct _SYSTEM_INFO GC_sysinfo; GC_INNER GC_bool GC_is_heap_base(ptr_t p); #endif GC_EXTERN word GC_black_list_spacing; /* Average number of bytes between blacklisted */ /* blocks. Approximate. */ /* Counts only blocks that are */ /* "stack-blacklisted", i.e. that are */ /* problematic in the interior of an object. */ #ifdef GC_GCJ_SUPPORT extern struct hblk * GC_hblkfreelist[]; /* Remains visible to GNU GCJ. */ #endif #ifdef GC_DISABLE_INCREMENTAL # define GC_incremental FALSE /* Hopefully allow optimizer to remove some code. */ # define TRUE_INCREMENTAL FALSE #else GC_EXTERN GC_bool GC_incremental; /* Using incremental/generational collection. */ # define TRUE_INCREMENTAL \ (GC_incremental && GC_time_limit != GC_TIME_UNLIMITED) /* True incremental, not just generational, mode */ #endif /* !GC_DISABLE_INCREMENTAL */ GC_EXTERN word GC_root_size; /* Total size of registered root sections. */ GC_EXTERN GC_bool GC_debugging_started; /* GC_debug_malloc has been called. */ /* This is used by GC_do_blocking[_inner](). */ struct blocking_data { GC_fn_type fn; void * client_data; /* and result */ }; /* This is used by GC_call_with_gc_active(), GC_push_all_stack_sections(). */ struct GC_traced_stack_sect_s { ptr_t saved_stack_ptr; # ifdef IA64 ptr_t saved_backing_store_ptr; ptr_t backing_store_end; # endif struct GC_traced_stack_sect_s *prev; }; #ifdef THREADS /* Process all "traced stack sections" - scan entire stack except for */ /* frames belonging to the user functions invoked by GC_do_blocking. */ GC_INNER void GC_push_all_stack_sections(ptr_t lo, ptr_t hi, struct GC_traced_stack_sect_s *traced_stack_sect); GC_EXTERN word GC_total_stacksize; /* updated on every push_all_stacks */ #else GC_EXTERN ptr_t GC_blocked_sp; GC_EXTERN struct GC_traced_stack_sect_s *GC_traced_stack_sect; /* Points to the "frame" data held in stack by */ /* the innermost GC_call_with_gc_active(). */ /* NULL if no such "frame" active. */ #endif /* !THREADS */ #ifdef IA64 /* Similar to GC_push_all_stack_sections() but for IA-64 registers store. */ GC_INNER void GC_push_all_register_sections(ptr_t bs_lo, ptr_t bs_hi, int eager, struct GC_traced_stack_sect_s *traced_stack_sect); #endif /* Marks are in a reserved area in */ /* each heap block. Each word has one mark bit associated */ /* with it. Only those corresponding to the beginning of an */ /* object are used. */ /* Mark bit operations */ /* * Retrieve, set, clear the nth mark bit in a given heap block. * * (Recall that bit n corresponds to nth object or allocation granule * relative to the beginning of the block, including unused words) */ #ifdef USE_MARK_BYTES # define mark_bit_from_hdr(hhdr,n) ((hhdr)->hb_marks[n]) # define set_mark_bit_from_hdr(hhdr,n) ((hhdr)->hb_marks[n] = 1) # define clear_mark_bit_from_hdr(hhdr,n) ((hhdr)->hb_marks[n] = 0) #else /* Set mark bit correctly, even if mark bits may be concurrently */ /* accessed. */ # ifdef PARALLEL_MARK /* This is used only if we explicitly set USE_MARK_BITS. */ # define OR_WORD(addr, bits) AO_or((volatile AO_t *)(addr), (AO_t)(bits)) # else # define OR_WORD(addr, bits) (void)(*(addr) |= (bits)) # endif # define mark_bit_from_hdr(hhdr,n) \ (((hhdr)->hb_marks[divWORDSZ(n)] >> modWORDSZ(n)) & (word)1) # define set_mark_bit_from_hdr(hhdr,n) \ OR_WORD((hhdr)->hb_marks+divWORDSZ(n), (word)1 << modWORDSZ(n)) # define clear_mark_bit_from_hdr(hhdr,n) \ ((hhdr)->hb_marks[divWORDSZ(n)] &= ~((word)1 << modWORDSZ(n))) #endif /* !USE_MARK_BYTES */ #ifdef MARK_BIT_PER_OBJ # define MARK_BIT_NO(offset, sz) (((unsigned)(offset))/(sz)) /* Get the mark bit index corresponding to the given byte */ /* offset and size (in bytes). */ # define MARK_BIT_OFFSET(sz) 1 /* Spacing between useful mark bits. */ # define IF_PER_OBJ(x) x # define FINAL_MARK_BIT(sz) ((sz) > MAXOBJBYTES? 1 : HBLK_OBJS(sz)) /* Position of final, always set, mark bit. */ #else /* MARK_BIT_PER_GRANULE */ # define MARK_BIT_NO(offset, sz) BYTES_TO_GRANULES((unsigned)(offset)) # define MARK_BIT_OFFSET(sz) BYTES_TO_GRANULES(sz) # define IF_PER_OBJ(x) # define FINAL_MARK_BIT(sz) \ ((sz) > MAXOBJBYTES ? MARK_BITS_PER_HBLK \ : BYTES_TO_GRANULES((sz) * HBLK_OBJS(sz))) #endif /* Important internal collector routines */ GC_INNER ptr_t GC_approx_sp(void); GC_INNER GC_bool GC_should_collect(void); void GC_apply_to_all_blocks(void (*fn)(struct hblk *h, word client_data), word client_data); /* Invoke fn(hbp, client_data) for each */ /* allocated heap block. */ GC_INNER struct hblk * GC_next_used_block(struct hblk * h); /* Return first in-use block >= h */ GC_INNER struct hblk * GC_prev_block(struct hblk * h); /* Return last block <= h. Returned block */ /* is managed by GC, but may or may not be in */ /* use. */ GC_INNER void GC_mark_init(void); GC_INNER void GC_clear_marks(void); /* Clear mark bits for all heap objects. */ GC_INNER void GC_invalidate_mark_state(void); /* Tell the marker that marked */ /* objects may point to unmarked */ /* ones, and roots may point to */ /* unmarked objects. Reset mark stack. */ GC_INNER GC_bool GC_mark_some(ptr_t cold_gc_frame); /* Perform about one pages worth of marking */ /* work of whatever kind is needed. Returns */ /* quickly if no collection is in progress. */ /* Return TRUE if mark phase finished. */ GC_INNER void GC_initiate_gc(void); /* initiate collection. */ /* If the mark state is invalid, this */ /* becomes full collection. Otherwise */ /* it's partial. */ GC_INNER GC_bool GC_collection_in_progress(void); /* Collection is in progress, or was abandoned. */ #ifndef GC_DISABLE_INCREMENTAL # define GC_PUSH_CONDITIONAL(b, t, all) \ GC_push_conditional((ptr_t)(b), (ptr_t)(t), all) /* Do either of GC_push_all or GC_push_selected */ /* depending on the third arg. */ #else # define GC_PUSH_CONDITIONAL(b, t, all) GC_push_all((ptr_t)(b), (ptr_t)(t)) #endif GC_INNER void GC_push_all_stack(ptr_t b, ptr_t t); /* As GC_push_all but consider */ /* interior pointers as valid. */ GC_INNER void GC_push_all_eager(ptr_t b, ptr_t t); /* Same as GC_push_all_stack, but */ /* ensures that stack is scanned */ /* immediately, not just scheduled */ /* for scanning. */ /* In the threads case, we push part of the current thread stack */ /* with GC_push_all_eager when we push the registers. This gets the */ /* callee-save registers that may disappear. The remainder of the */ /* stacks are scheduled for scanning in *GC_push_other_roots, which */ /* is thread-package-specific. */ GC_INNER void GC_push_roots(GC_bool all, ptr_t cold_gc_frame); /* Push all or dirty roots. */ GC_API_PRIV GC_push_other_roots_proc GC_push_other_roots; /* Push system or application specific roots */ /* onto the mark stack. In some environments */ /* (e.g. threads environments) this is */ /* predefined to be non-zero. A client */ /* supplied replacement should also call the */ /* original function. Remains externally */ /* visible as used by some well-known 3rd-party */ /* software (e.g., ECL) currently. */ #ifdef THREADS void GC_push_thread_structures(void); #endif GC_EXTERN void (*GC_push_typed_structures)(void); /* A pointer such that we can avoid linking in */ /* the typed allocation support if unused. */ GC_INNER void GC_with_callee_saves_pushed(void (*fn)(ptr_t, void *), ptr_t arg); #if defined(SPARC) || defined(IA64) /* Cause all stacked registers to be saved in memory. Return a */ /* pointer to the top of the corresponding memory stack. */ ptr_t GC_save_regs_in_stack(void); #endif /* Push register contents onto mark stack. */ #if defined(MSWIN32) || defined(MSWINCE) void __cdecl GC_push_one(word p); #else void GC_push_one(word p); /* If p points to an object, mark it */ /* and push contents on the mark stack */ /* Pointer recognition test always */ /* accepts interior pointers, i.e. this */ /* is appropriate for pointers found on */ /* stack. */ #endif #if defined(PRINT_BLACK_LIST) || defined(KEEP_BACK_PTRS) GC_INNER void GC_mark_and_push_stack(ptr_t p, ptr_t source); /* Ditto, omits plausibility test */ #else GC_INNER void GC_mark_and_push_stack(ptr_t p); #endif GC_INNER void GC_clear_hdr_marks(hdr * hhdr); /* Clear the mark bits in a header */ GC_INNER void GC_set_hdr_marks(hdr * hhdr); /* Set the mark bits in a header */ GC_INNER void GC_set_fl_marks(ptr_t p); /* Set all mark bits associated with */ /* a free list. */ #if defined(GC_ASSERTIONS) && defined(THREADS) && defined(THREAD_LOCAL_ALLOC) void GC_check_fl_marks(void **); /* Check that all mark bits */ /* associated with a free list are */ /* set. Abort if not. */ #endif void GC_add_roots_inner(ptr_t b, ptr_t e, GC_bool tmp); GC_INNER void GC_exclude_static_roots_inner(void *start, void *finish); #if defined(DYNAMIC_LOADING) || defined(MSWIN32) || defined(MSWINCE) \ || defined(CYGWIN32) || defined(PCR) GC_INNER void GC_register_dynamic_libraries(void); /* Add dynamic library data sections to the root set. */ #endif GC_INNER void GC_cond_register_dynamic_libraries(void); /* Remove and reregister dynamic libraries if we're */ /* configured to do that at each GC. */ /* Machine dependent startup routines */ ptr_t GC_get_main_stack_base(void); /* Cold end of stack. */ #ifdef IA64 GC_INNER ptr_t GC_get_register_stack_base(void); /* Cold end of register stack. */ #endif void GC_register_data_segments(void); #ifdef THREADS GC_INNER void GC_thr_init(void); GC_INNER void GC_init_parallel(void); #else GC_INNER GC_bool GC_is_static_root(ptr_t p); /* Is the address p in one of the registered static */ /* root sections? */ #endif /* Black listing: */ #ifdef PRINT_BLACK_LIST GC_INNER void GC_add_to_black_list_normal(word p, ptr_t source); /* Register bits as a possible future false */ /* reference from the heap or static data */ # define GC_ADD_TO_BLACK_LIST_NORMAL(bits, source) \ if (GC_all_interior_pointers) { \ GC_add_to_black_list_stack((word)(bits), (source)); \ } else \ GC_add_to_black_list_normal((word)(bits), (source)) GC_INNER void GC_add_to_black_list_stack(word p, ptr_t source); # define GC_ADD_TO_BLACK_LIST_STACK(bits, source) \ GC_add_to_black_list_stack((word)(bits), (source)) #else GC_INNER void GC_add_to_black_list_normal(word p); # define GC_ADD_TO_BLACK_LIST_NORMAL(bits, source) \ if (GC_all_interior_pointers) { \ GC_add_to_black_list_stack((word)(bits)); \ } else \ GC_add_to_black_list_normal((word)(bits)) GC_INNER void GC_add_to_black_list_stack(word p); # define GC_ADD_TO_BLACK_LIST_STACK(bits, source) \ GC_add_to_black_list_stack((word)(bits)) #endif /* PRINT_BLACK_LIST */ struct hblk * GC_is_black_listed(struct hblk * h, word len); /* If there are likely to be false references */ /* to a block starting at h of the indicated */ /* length, then return the next plausible */ /* starting location for h that might avoid */ /* these false references. Remains externally */ /* visible as used by GNU GCJ currently. */ GC_INNER void GC_promote_black_lists(void); /* Declare an end to a black listing phase. */ GC_INNER void GC_unpromote_black_lists(void); /* Approximately undo the effect of the above. */ /* This actually loses some information, but */ /* only in a reasonably safe way. */ GC_INNER ptr_t GC_scratch_alloc(size_t bytes); /* GC internal memory allocation for */ /* small objects. Deallocation is not */ /* possible. May return NULL. */ /* Heap block layout maps: */ GC_INNER GC_bool GC_add_map_entry(size_t sz); /* Add a heap block map for objects of */ /* size sz to obj_map. */ /* Return FALSE on failure. */ GC_INNER void GC_register_displacement_inner(size_t offset); /* Version of GC_register_displacement */ /* that assumes lock is already held. */ /* hblk allocation: */ GC_INNER void GC_new_hblk(size_t size_in_granules, int kind); /* Allocate a new heap block, and build */ /* a free list in it. */ GC_INNER ptr_t GC_build_fl(struct hblk *h, size_t words, GC_bool clear, ptr_t list); /* Build a free list for objects of */ /* size sz in block h. Append list to */ /* end of the free lists. Possibly */ /* clear objects on the list. Normally */ /* called by GC_new_hblk, but also */ /* called explicitly without GC lock. */ GC_INNER struct hblk * GC_allochblk(size_t size_in_bytes, int kind, unsigned flags); /* Allocate a heap block, inform */ /* the marker that block is valid */ /* for objects of indicated size. */ GC_INNER ptr_t GC_alloc_large(size_t lb, int k, unsigned flags); /* Allocate a large block of size lb bytes. */ /* The block is not cleared. */ /* Flags is 0 or IGNORE_OFF_PAGE. */ /* Calls GC_allchblk to do the actual */ /* allocation, but also triggers GC and/or */ /* heap expansion as appropriate. */ /* Does not update GC_bytes_allocd, but does */ /* other accounting. */ GC_INNER void GC_freehblk(struct hblk * p); /* Deallocate a heap block and mark it */ /* as invalid. */ /* Misc GC: */ GC_INNER GC_bool GC_expand_hp_inner(word n); GC_INNER void GC_start_reclaim(GC_bool abort_if_found); /* Restore unmarked objects to free */ /* lists, or (if abort_if_found is */ /* TRUE) report them. */ /* Sweeping of small object pages is */ /* largely deferred. */ GC_INNER void GC_continue_reclaim(size_t sz, int kind); /* Sweep pages of the given size and */ /* kind, as long as possible, and */ /* as long as the corr. free list is */ /* empty. Sz is in granules. */ GC_INNER GC_bool GC_reclaim_all(GC_stop_func stop_func, GC_bool ignore_old); /* Reclaim all blocks. Abort (in a */ /* consistent state) if f returns TRUE. */ GC_INNER ptr_t GC_reclaim_generic(struct hblk * hbp, hdr *hhdr, size_t sz, GC_bool init, ptr_t list, signed_word *count); /* Rebuild free list in hbp with */ /* header hhdr, with objects of size sz */ /* bytes. Add list to the end of the */ /* free list. Add the number of */ /* reclaimed bytes to *count. */ GC_INNER GC_bool GC_block_empty(hdr * hhdr); /* Block completely unmarked? */ GC_INNER int GC_CALLBACK GC_never_stop_func(void); /* Always returns 0 (FALSE). */ GC_INNER GC_bool GC_try_to_collect_inner(GC_stop_func f); /* Collect; caller must have acquired */ /* lock. Collection is aborted if f */ /* returns TRUE. Returns TRUE if it */ /* completes successfully. */ #define GC_gcollect_inner() \ (void)GC_try_to_collect_inner(GC_never_stop_func) GC_EXTERN GC_bool GC_is_initialized; /* GC_init() has been run. */ #if defined(MSWIN32) || defined(MSWINCE) void GC_deinit(void); /* Free any resources allocated by */ /* GC_init */ #endif GC_INNER void GC_collect_a_little_inner(int n); /* Do n units worth of garbage */ /* collection work, if appropriate. */ /* A unit is an amount appropriate for */ /* HBLKSIZE bytes of allocation. */ GC_INNER void * GC_generic_malloc_inner(size_t lb, int k); /* Allocate an object of the given */ /* kind but assuming lock already held. */ GC_INNER void * GC_generic_malloc_inner_ignore_off_page(size_t lb, int k); /* Allocate an object, where */ /* the client guarantees that there */ /* will always be a pointer to the */ /* beginning of the object while the */ /* object is live. */ GC_INNER ptr_t GC_allocobj(size_t sz, int kind); /* Make the indicated */ /* free list nonempty, and return its */ /* head. Sz is in granules. */ #ifdef GC_ADD_CALLER /* GC_DBG_EXTRAS is used by GC debug API functions (unlike GC_EXTRAS */ /* used by GC debug API macros) thus GC_RETURN_ADDR_PARENT (pointing */ /* to client caller) should be used if possible. */ # ifdef GC_RETURN_ADDR_PARENT # define GC_DBG_EXTRAS GC_RETURN_ADDR_PARENT, NULL, 0 # else # define GC_DBG_EXTRAS GC_RETURN_ADDR, NULL, 0 # endif #else # define GC_DBG_EXTRAS "unknown", 0 #endif /* We make the GC_clear_stack() call a tail one, hoping to get more of */ /* the stack. */ #define GENERAL_MALLOC(lb,k) \ GC_clear_stack(GC_generic_malloc(lb, k)) #define GENERAL_MALLOC_IOP(lb,k) \ GC_clear_stack(GC_generic_malloc_ignore_off_page(lb, k)) #ifdef GC_COLLECT_AT_MALLOC extern size_t GC_dbg_collect_at_malloc_min_lb; /* variable visible outside for debugging */ # define GC_DBG_COLLECT_AT_MALLOC(lb) \ (void)((lb) >= GC_dbg_collect_at_malloc_min_lb ? \ (GC_gcollect(), 0) : 0) #else # define GC_DBG_COLLECT_AT_MALLOC(lb) (void)0 #endif /* !GC_COLLECT_AT_MALLOC */ /* Allocation routines that bypass the thread local cache. */ #ifdef THREAD_LOCAL_ALLOC GC_INNER void * GC_core_malloc(size_t); GC_INNER void * GC_core_malloc_atomic(size_t); # ifdef GC_GCJ_SUPPORT GC_INNER void * GC_core_gcj_malloc(size_t, void *); # endif #endif /* THREAD_LOCAL_ALLOC */ GC_INNER void GC_init_headers(void); GC_INNER struct hblkhdr * GC_install_header(struct hblk *h); /* Install a header for block h. */ /* Return 0 on failure, or the header */ /* otherwise. */ GC_INNER GC_bool GC_install_counts(struct hblk * h, size_t sz); /* Set up forwarding counts for block */ /* h of size sz. */ /* Return FALSE on failure. */ GC_INNER void GC_remove_header(struct hblk * h); /* Remove the header for block h. */ GC_INNER void GC_remove_counts(struct hblk * h, size_t sz); /* Remove forwarding counts for h. */ GC_INNER hdr * GC_find_header(ptr_t h); GC_INNER void GC_add_to_heap(struct hblk *p, size_t bytes); /* Add a HBLKSIZE aligned chunk to the heap. */ #ifdef USE_PROC_FOR_LIBRARIES GC_INNER void GC_add_to_our_memory(ptr_t p, size_t bytes); /* Add a chunk to GC_our_memory. */ /* If p == 0, do nothing. */ #else # define GC_add_to_our_memory(p, bytes) #endif GC_INNER void GC_print_all_errors(void); /* Print smashed and leaked objects, if any. */ /* Clear the lists of such objects. */ GC_EXTERN void (*GC_check_heap)(void); /* Check that all objects in the heap with */ /* debugging info are intact. */ /* Add any that are not to GC_smashed list. */ GC_EXTERN void (*GC_print_all_smashed)(void); /* Print GC_smashed if it's not empty. */ /* Clear GC_smashed list. */ GC_EXTERN void (*GC_print_heap_obj)(ptr_t p); /* If possible print (using GC_err_printf) */ /* a more detailed description (terminated with */ /* "\n") of the object referred to by p. */ #if defined(LINUX) && defined(__ELF__) && !defined(SMALL_CONFIG) void GC_print_address_map(void); /* Print an address map of the process. */ #endif #ifndef SHORT_DBG_HDRS GC_EXTERN GC_bool GC_findleak_delay_free; /* Do not immediately deallocate object on */ /* free() in the leak-finding mode, just mark */ /* it as freed (and deallocate it after GC). */ GC_INNER GC_bool GC_check_leaked(ptr_t base); /* from dbg_mlc.c */ #endif GC_EXTERN GC_bool GC_have_errors; /* We saw a smashed or leaked object. */ /* Call error printing routine */ /* occasionally. It is OK to read it */ /* without acquiring the lock. */ #define VERBOSE 2 #ifndef SMALL_CONFIG /* GC_print_stats should be visible to extra/MacOS.c. */ extern int GC_print_stats; /* Nonzero generates basic GC log. */ /* VERBOSE generates add'l messages. */ #else /* SMALL_CONFIG */ # define GC_print_stats 0 /* Will this remove the message character strings from the executable? */ /* With a particular level of optimizations, it should... */ #endif #ifdef KEEP_BACK_PTRS GC_EXTERN long GC_backtraces; GC_INNER void GC_generate_random_backtrace_no_gc(void); #endif GC_EXTERN GC_bool GC_print_back_height; #ifdef MAKE_BACK_GRAPH void GC_print_back_graph_stats(void); #endif #ifdef THREADS GC_INNER void GC_free_inner(void * p); #endif /* Macros used for collector internal allocation. */ /* These assume the collector lock is held. */ #ifdef DBG_HDRS_ALL GC_INNER void * GC_debug_generic_malloc_inner(size_t lb, int k); GC_INNER void * GC_debug_generic_malloc_inner_ignore_off_page(size_t lb, int k); # define GC_INTERNAL_MALLOC GC_debug_generic_malloc_inner # define GC_INTERNAL_MALLOC_IGNORE_OFF_PAGE \ GC_debug_generic_malloc_inner_ignore_off_page # ifdef THREADS GC_INNER void GC_debug_free_inner(void * p); # define GC_INTERNAL_FREE GC_debug_free_inner # else # define GC_INTERNAL_FREE GC_debug_free # endif #else # define GC_INTERNAL_MALLOC GC_generic_malloc_inner # define GC_INTERNAL_MALLOC_IGNORE_OFF_PAGE \ GC_generic_malloc_inner_ignore_off_page # ifdef THREADS # define GC_INTERNAL_FREE GC_free_inner # else # define GC_INTERNAL_FREE GC_free # endif #endif /* !DBG_HDRS_ALL */ #ifdef USE_MUNMAP /* Memory unmapping: */ GC_INNER void GC_unmap_old(void); GC_INNER void GC_merge_unmapped(void); GC_INNER void GC_unmap(ptr_t start, size_t bytes); GC_INNER void GC_remap(ptr_t start, size_t bytes); GC_INNER void GC_unmap_gap(ptr_t start1, size_t bytes1, ptr_t start2, size_t bytes2); #endif #ifdef CAN_HANDLE_FORK GC_EXTERN int GC_handle_fork; /* Fork-handling mode: */ /* 0 means no fork handling requested (but client could */ /* anyway call fork() provided it is surrounded with */ /* GC_atfork_prepare/parent/child calls); */ /* -1 means GC tries to use pthread_at_fork if it is */ /* available (if it succeeds then GC_handle_fork value */ /* is changed to 1), client should nonetheless surround */ /* fork() with GC_atfork_prepare/parent/child (for the */ /* case of pthread_at_fork failure or absence); */ /* 1 (or other values) means client fully relies on */ /* pthread_at_fork (so if it is missing or failed then */ /* abort occurs in GC_init), GC_atfork_prepare and the */ /* accompanying routines are no-op in such a case. */ #endif #ifndef GC_DISABLE_INCREMENTAL GC_EXTERN GC_bool GC_dirty_maintained; /* Dirty bits are being maintained, */ /* either for incremental collection, */ /* or to limit the root set. */ /* Virtual dirty bit implementation: */ /* Each implementation exports the following: */ GC_INNER void GC_read_dirty(void); /* Retrieve dirty bits. */ GC_INNER GC_bool GC_page_was_dirty(struct hblk *h); /* Read retrieved dirty bits. */ GC_INNER void GC_remove_protection(struct hblk *h, word nblocks, GC_bool pointerfree); /* h is about to be written or allocated. Ensure */ /* that it's not write protected by the virtual */ /* dirty bit implementation. */ GC_INNER void GC_dirty_init(void); #endif /* !GC_DISABLE_INCREMENTAL */ /* Same as GC_base but excepts and returns a pointer to const object. */ #define GC_base_C(p) ((const void *)GC_base((/* no const */ void *)(p))) /* Stubborn objects: */ void GC_read_changed(void); /* Analogous to GC_read_dirty */ GC_bool GC_page_was_changed(struct hblk * h); /* Analogous to GC_page_was_dirty */ void GC_clean_changing_list(void); /* Collect obsolete changing list entries */ void GC_stubborn_init(void); /* Debugging print routines: */ void GC_print_block_list(void); void GC_print_hblkfreelist(void); void GC_print_heap_sects(void); void GC_print_static_roots(void); /* void GC_dump(void); - declared in gc.h */ extern word GC_fo_entries; /* should be visible in extra/MacOS.c */ #ifdef KEEP_BACK_PTRS GC_INNER void GC_store_back_pointer(ptr_t source, ptr_t dest); GC_INNER void GC_marked_for_finalization(ptr_t dest); # define GC_STORE_BACK_PTR(source, dest) GC_store_back_pointer(source, dest) # define GC_MARKED_FOR_FINALIZATION(dest) GC_marked_for_finalization(dest) #else # define GC_STORE_BACK_PTR(source, dest) # define GC_MARKED_FOR_FINALIZATION(dest) #endif /* Make arguments appear live to compiler */ void GC_noop6(word, word, word, word, word, word); GC_API void GC_CALL GC_noop1(word); #ifndef GC_ATTR_FORMAT_PRINTF # if defined(__GNUC__) && __GNUC__ >= 3 # define GC_ATTR_FORMAT_PRINTF(spec_argnum, first_checked) \ __attribute__((__format__(__printf__, spec_argnum, first_checked))) # else # define GC_ATTR_FORMAT_PRINTF(spec_argnum, first_checked) # endif #endif /* Logging and diagnostic output: */ /* GC_printf is used typically on client explicit print requests. */ /* For all GC_X_printf routines, it is recommended to put "\n" at */ /* 'format' string end (for output atomicity). */ GC_API_PRIV void GC_printf(const char * format, ...) GC_ATTR_FORMAT_PRINTF(1, 2); /* A version of printf that doesn't allocate, */ /* 1K total output length. */ /* (We use sprintf. Hopefully that doesn't */ /* allocate for long arguments.) */ GC_API_PRIV void GC_err_printf(const char * format, ...) GC_ATTR_FORMAT_PRINTF(1, 2); /* Basic logging routine. Typically, GC_log_printf is called directly */ /* only inside various DEBUG_x blocks. */ #if defined(__cplusplus) && defined(SYMBIAN) extern "C" { #endif GC_API_PRIV void GC_log_printf(const char * format, ...) GC_ATTR_FORMAT_PRINTF(1, 2); #if defined(__cplusplus) && defined(SYMBIAN) } #endif #ifndef GC_ANDROID_LOG # define GC_PRINT_STATS_FLAG (GC_print_stats != 0) # define GC_INFOLOG_PRINTF GC_COND_LOG_PRINTF /* GC_verbose_log_printf is called only if GC_print_stats is VERBOSE. */ # define GC_verbose_log_printf GC_log_printf #else extern GC_bool GC_quiet; # define GC_PRINT_STATS_FLAG (!GC_quiet) /* INFO/DBG loggers are enabled even if GC_print_stats is off. */ # ifndef GC_INFOLOG_PRINTF # define GC_INFOLOG_PRINTF if (GC_quiet) {} else GC_info_log_printf # endif GC_INNER void GC_info_log_printf(const char *format, ...) GC_ATTR_FORMAT_PRINTF(1, 2); GC_INNER void GC_verbose_log_printf(const char *format, ...) GC_ATTR_FORMAT_PRINTF(1, 2); #endif /* GC_ANDROID_LOG */ /* Convenient macros for GC_[verbose_]log_printf invocation. */ #define GC_COND_LOG_PRINTF \ if (EXPECT(!GC_print_stats, TRUE)) {} else GC_log_printf #define GC_VERBOSE_LOG_PRINTF \ if (EXPECT(GC_print_stats != VERBOSE, TRUE)) {} else GC_verbose_log_printf #ifndef GC_DBGLOG_PRINTF # define GC_DBGLOG_PRINTF if (!GC_PRINT_STATS_FLAG) {} else GC_log_printf #endif void GC_err_puts(const char *s); /* Write s to stderr, don't buffer, don't add */ /* newlines, don't ... */ /* Handy macro for logging size values (of word type) in KiB (rounding */ /* to nearest value). */ #define TO_KiB_UL(v) ((unsigned long)(((v) + ((1 << 9) - 1)) >> 10)) GC_EXTERN unsigned GC_fail_count; /* How many consecutive GC/expansion failures? */ /* Reset by GC_allochblk(); defined in alloc.c. */ GC_EXTERN long GC_large_alloc_warn_interval; /* defined in misc.c */ GC_EXTERN signed_word GC_bytes_found; /* Number of reclaimed bytes after garbage collection; */ /* protected by GC lock; defined in reclaim.c. */ #ifndef GC_GET_HEAP_USAGE_NOT_NEEDED GC_EXTERN word GC_reclaimed_bytes_before_gc; /* Number of bytes reclaimed before this */ /* collection cycle; used for statistics only. */ #endif #ifdef USE_MUNMAP GC_EXTERN int GC_unmap_threshold; /* defined in allchblk.c */ GC_EXTERN GC_bool GC_force_unmap_on_gcollect; /* defined in misc.c */ #endif #ifdef MSWIN32 GC_EXTERN GC_bool GC_no_win32_dlls; /* defined in os_dep.c */ GC_EXTERN GC_bool GC_wnt; /* Is Windows NT derivative; */ /* defined and set in os_dep.c. */ #endif #ifdef THREADS # if defined(MSWIN32) || defined(MSWINCE) GC_EXTERN CRITICAL_SECTION GC_write_cs; /* defined in misc.c */ # ifdef GC_ASSERTIONS GC_EXTERN GC_bool GC_write_disabled; /* defined in win32_threads.c; */ /* protected by GC_write_cs. */ # endif # endif # ifdef MPROTECT_VDB GC_EXTERN volatile AO_TS_t GC_fault_handler_lock; /* defined in os_dep.c */ # endif # ifdef MSWINCE GC_EXTERN GC_bool GC_dont_query_stack_min; /* Defined and set in os_dep.c. */ # endif #elif defined(IA64) GC_EXTERN ptr_t GC_save_regs_ret_val; /* defined in mach_dep.c. */ /* Previously set to backing store pointer. */ #endif /* !THREADS */ #ifdef THREAD_LOCAL_ALLOC GC_EXTERN GC_bool GC_world_stopped; /* defined in alloc.c */ GC_INNER void GC_mark_thread_local_free_lists(void); #endif #ifdef GC_GCJ_SUPPORT # ifdef GC_ASSERTIONS GC_EXTERN GC_bool GC_gcj_malloc_initialized; /* defined in gcj_mlc.c */ # endif GC_EXTERN ptr_t * GC_gcjobjfreelist; #endif #if defined(GWW_VDB) && defined(MPROTECT_VDB) GC_INNER GC_bool GC_gww_dirty_init(void); /* Defined in os_dep.c. Returns TRUE if GetWriteWatch is available. */ /* May be called repeatedly. */ #endif #if defined(CHECKSUMS) || defined(PROC_VDB) GC_INNER GC_bool GC_page_was_ever_dirty(struct hblk * h); /* Could the page contain valid heap pointers? */ #endif GC_INNER void GC_default_print_heap_obj_proc(ptr_t p); GC_INNER void GC_extend_size_map(size_t); /* in misc.c */ GC_INNER void GC_setpagesize(void); GC_INNER void GC_initialize_offsets(void); /* defined in obj_map.c */ GC_INNER void GC_bl_init(void); GC_INNER void GC_bl_init_no_interiors(void); /* defined in blacklst.c */ GC_INNER void GC_start_debugging(void); /* defined in dbg_mlc.c */ /* Store debugging info into p. Return displaced pointer. */ /* Assumes we don't hold allocation lock. */ GC_INNER ptr_t GC_store_debug_info(ptr_t p, word sz, const char *str, int linenum); #ifdef REDIRECT_MALLOC # ifdef GC_LINUX_THREADS GC_INNER GC_bool GC_text_mapping(char *nm, ptr_t *startp, ptr_t *endp); /* from os_dep.c */ # endif #elif defined(USE_WINALLOC) GC_INNER void GC_add_current_malloc_heap(void); #endif /* !REDIRECT_MALLOC */ #ifdef MAKE_BACK_GRAPH GC_INNER void GC_build_back_graph(void); GC_INNER void GC_traverse_back_graph(void); #endif #ifdef MSWIN32 GC_INNER void GC_init_win32(void); #endif #if !defined(MSWIN32) && !defined(MSWINCE) && !defined(CYGWIN32) GC_INNER void * GC_roots_present(ptr_t); /* The type is a lie, since the real type doesn't make sense here, */ /* and we only test for NULL. */ #endif #ifdef GC_WIN32_THREADS GC_INNER void GC_get_next_stack(char *start, char * limit, char **lo, char **hi); # ifdef MPROTECT_VDB GC_INNER void GC_set_write_fault_handler(void); # endif #endif /* GC_WIN32_THREADS */ #ifdef THREADS GC_INNER void GC_reset_finalizer_nested(void); GC_INNER unsigned char *GC_check_finalizer_nested(void); GC_INNER void GC_do_blocking_inner(ptr_t data, void * context); GC_INNER void GC_push_all_stacks(void); # ifdef USE_PROC_FOR_LIBRARIES GC_INNER GC_bool GC_segment_is_thread_stack(ptr_t lo, ptr_t hi); # endif # ifdef IA64 GC_INNER ptr_t GC_greatest_stack_base_below(ptr_t bound); # endif #endif /* THREADS */ #ifdef DYNAMIC_LOADING GC_INNER GC_bool GC_register_main_static_data(void); # ifdef DARWIN GC_INNER void GC_init_dyld(void); # endif #endif /* DYNAMIC_LOADING */ #ifdef SEARCH_FOR_DATA_START GC_INNER void GC_init_linux_data_start(void); #endif #if defined(NETBSD) && defined(__ELF__) GC_INNER void GC_init_netbsd_elf(void); #endif #ifdef UNIX_LIKE GC_INNER void GC_set_and_save_fault_handler(void (*handler)(int)); #endif #ifdef NEED_PROC_MAPS # if defined(DYNAMIC_LOADING) && defined(USE_PROC_FOR_LIBRARIES) GC_INNER char *GC_parse_map_entry(char *buf_ptr, ptr_t *start, ptr_t *end, char **prot, unsigned int *maj_dev, char **mapping_name); # endif GC_INNER char *GC_get_maps(void); /* from os_dep.c */ #endif /* NEED_PROC_MAPS */ #ifdef GC_ASSERTIONS # define GC_ASSERT(expr) \ do { \ if (!(expr)) { \ GC_err_printf("Assertion failure: %s:%d\n", \ __FILE__, __LINE__); \ ABORT("assertion failure"); \ } \ } while (0) GC_INNER word GC_compute_large_free_bytes(void); GC_INNER word GC_compute_root_size(void); #else # define GC_ASSERT(expr) #endif /* Check a compile time assertion at compile time. The error */ /* message for failure is a bit baroque, but ... */ #if defined(mips) && !defined(__GNUC__) /* DOB: MIPSPro C gets an internal error taking the sizeof an array type. This code works correctly (ugliness is to avoid "unused var" warnings) */ # define GC_STATIC_ASSERT(expr) \ do { if (0) { char j[(expr)? 1 : -1]; j[0]='\0'; j[0]=j[0]; } } while(0) #else # define GC_STATIC_ASSERT(expr) (void)sizeof(char[(expr)? 1 : -1]) #endif #define COND_DUMP_CHECKS \ do { \ GC_ASSERT(GC_compute_large_free_bytes() == GC_large_free_bytes); \ GC_ASSERT(GC_compute_root_size() == GC_root_size); \ } while (0) #ifndef NO_DEBUGGING GC_EXTERN GC_bool GC_dump_regularly; /* Generate regular debugging dumps. */ # define COND_DUMP if (EXPECT(GC_dump_regularly, FALSE)) GC_dump(); \ else COND_DUMP_CHECKS #else # define COND_DUMP COND_DUMP_CHECKS #endif #if defined(PARALLEL_MARK) /* We need additional synchronization facilities from the thread */ /* support. We believe these are less performance critical */ /* than the main garbage collector lock; standard pthreads-based */ /* implementations should be sufficient. */ # define GC_markers_m1 GC_parallel /* Number of mark threads we would like to have */ /* excluding the initiating thread. */ /* The mark lock and condition variable. If the GC lock is also */ /* acquired, the GC lock must be acquired first. The mark lock is */ /* used to both protect some variables used by the parallel */ /* marker, and to protect GC_fl_builder_count, below. */ /* GC_notify_all_marker() is called when */ /* the state of the parallel marker changes */ /* in some significant way (see gc_mark.h for details). The */ /* latter set of events includes incrementing GC_mark_no. */ /* GC_notify_all_builder() is called when GC_fl_builder_count */ /* reaches 0. */ GC_INNER void GC_acquire_mark_lock(void); GC_INNER void GC_release_mark_lock(void); GC_INNER void GC_notify_all_builder(void); GC_INNER void GC_wait_for_reclaim(void); GC_EXTERN word GC_fl_builder_count; /* Protected by mark lock. */ GC_INNER void GC_notify_all_marker(void); GC_INNER void GC_wait_marker(void); GC_EXTERN word GC_mark_no; /* Protected by mark lock. */ GC_INNER void GC_help_marker(word my_mark_no); /* Try to help out parallel marker for mark cycle */ /* my_mark_no. Returns if the mark cycle finishes or */ /* was already done, or there was nothing to do for */ /* some other reason. */ #endif /* PARALLEL_MARK */ #if defined(GC_PTHREADS) && !defined(GC_WIN32_THREADS) && !defined(NACL) \ && !defined(GC_DARWIN_THREADS) && !defined(SIG_SUSPEND) /* We define the thread suspension signal here, so that we can refer */ /* to it in the dirty bit implementation, if necessary. Ideally we */ /* would allocate a (real-time?) signal using the standard mechanism. */ /* unfortunately, there is no standard mechanism. (There is one */ /* in Linux glibc, but it's not exported.) Thus we continue to use */ /* the same hard-coded signals we've always used. */ # if (defined(GC_LINUX_THREADS) || defined(GC_DGUX386_THREADS)) \ && !defined(GC_USESIGRT_SIGNALS) # if defined(SPARC) && !defined(SIGPWR) /* SPARC/Linux doesn't properly define SIGPWR in . */ /* It is aliased to SIGLOST in asm/signal.h, though. */ # define SIG_SUSPEND SIGLOST # else /* Linuxthreads itself uses SIGUSR1 and SIGUSR2. */ # define SIG_SUSPEND SIGPWR # endif # elif defined(GC_OPENBSD_THREADS) # ifndef GC_OPENBSD_UTHREADS # define SIG_SUSPEND SIGXFSZ # endif # elif defined(_SIGRTMIN) # define SIG_SUSPEND _SIGRTMIN + 6 # else # define SIG_SUSPEND SIGRTMIN + 6 # endif #endif /* GC_PTHREADS && !SIG_SUSPEND */ #if defined(GC_PTHREADS) && !defined(GC_SEM_INIT_PSHARED) # define GC_SEM_INIT_PSHARED 0 #endif #include /* Some macros for setjmp that works across signal handlers */ /* were possible, and a couple of routines to facilitate */ /* catching accesses to bad addresses when that's */ /* possible/needed. */ #if (defined(UNIX_LIKE) || (defined(NEED_FIND_LIMIT) && defined(CYGWIN32))) \ && !defined(GC_NO_SIGSETJMP) # if defined(SUNOS5SIGS) && !defined(FREEBSD) && !defined(LINUX) # include # endif /* Define SETJMP and friends to be the version that restores */ /* the signal mask. */ # define SETJMP(env) sigsetjmp(env, 1) # define LONGJMP(env, val) siglongjmp(env, val) # define JMP_BUF sigjmp_buf #else # ifdef ECOS # define SETJMP(env) hal_setjmp(env) # else # define SETJMP(env) setjmp(env) # endif # define LONGJMP(env, val) longjmp(env, val) # define JMP_BUF jmp_buf #endif /* !UNIX_LIKE || GC_NO_SIGSETJMP */ /* Do we need the GC_find_limit machinery to find the end of a */ /* data segment. */ #if defined(HEURISTIC2) || defined(SEARCH_FOR_DATA_START) # define NEED_FIND_LIMIT #endif #if !defined(STACKBOTTOM) && defined(HEURISTIC2) # define NEED_FIND_LIMIT #endif #if (defined(SVR4) || defined(AUX) || defined(DGUX) \ || (defined(LINUX) && defined(SPARC))) && !defined(PCR) # define NEED_FIND_LIMIT #endif #if defined(FREEBSD) && (defined(I386) || defined(X86_64) \ || defined(powerpc) || defined(__powerpc__)) # include # if !defined(PCR) # define NEED_FIND_LIMIT # endif #endif /* FREEBSD */ #if (defined(NETBSD) || defined(OPENBSD)) && defined(__ELF__) \ && !defined(NEED_FIND_LIMIT) /* Used by GC_init_netbsd_elf() in os_dep.c. */ # define NEED_FIND_LIMIT #endif #if defined(IA64) && !defined(NEED_FIND_LIMIT) # define NEED_FIND_LIMIT /* May be needed for register backing store base. */ #endif #if defined(NEED_FIND_LIMIT) \ || (defined(USE_PROC_FOR_LIBRARIES) && defined(THREADS)) JMP_BUF GC_jmp_buf; /* Set up a handler for address faults which will longjmp to */ /* GC_jmp_buf; */ GC_INNER void GC_setup_temporary_fault_handler(void); /* Undo the effect of GC_setup_temporary_fault_handler. */ GC_INNER void GC_reset_fault_handler(void); #endif /* NEED_FIND_LIMIT || USE_PROC_FOR_LIBRARIES */ /* Some convenience macros for cancellation support. */ #if defined(CANCEL_SAFE) # if defined(GC_ASSERTIONS) && (defined(USE_COMPILER_TLS) \ || (defined(LINUX) && !defined(ARM32) \ && (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 3)) \ || defined(HPUX) /* and probably others ... */)) extern __thread unsigned char GC_cancel_disable_count; # define NEED_CANCEL_DISABLE_COUNT # define INCR_CANCEL_DISABLE() ++GC_cancel_disable_count # define DECR_CANCEL_DISABLE() --GC_cancel_disable_count # define ASSERT_CANCEL_DISABLED() GC_ASSERT(GC_cancel_disable_count > 0) # else # define INCR_CANCEL_DISABLE() # define DECR_CANCEL_DISABLE() # define ASSERT_CANCEL_DISABLED() (void)0 # endif /* GC_ASSERTIONS & ... */ # define DISABLE_CANCEL(state) \ do { pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &state); \ INCR_CANCEL_DISABLE(); } while (0) # define RESTORE_CANCEL(state) \ do { ASSERT_CANCEL_DISABLED(); \ pthread_setcancelstate(state, NULL); \ DECR_CANCEL_DISABLE(); } while (0) #else /* !CANCEL_SAFE */ # define DISABLE_CANCEL(state) (void)0 # define RESTORE_CANCEL(state) (void)0 # define ASSERT_CANCEL_DISABLED() (void)0 #endif /* !CANCEL_SAFE */ #endif /* GC_PRIVATE_H */ ecl-16.1.2/src/bdwgc/include/private/gcconfig.h000066400000000000000000003137061266352375300212740ustar00rootroot00000000000000/* * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. * Copyright (c) 1996 by Silicon Graphics. All rights reserved. * Copyright (c) 2000-2004 Hewlett-Packard Development Company, L.P. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. */ /* * This header is private to the gc. It is almost always included from * gc_priv.h. However it is possible to include it by itself if just the * configuration macros are needed. In that * case, a few declarations relying on types declared in gc_priv.h will be * omitted. */ #ifndef GCCONFIG_H #define GCCONFIG_H # ifndef GC_PRIVATE_H /* Fake ptr_t declaration, just to avoid compilation errors. */ /* This avoids many instances if "ifndef GC_PRIVATE_H" below. */ typedef struct GC_undefined_struct * ptr_t; # include /* For size_t etc. */ # endif /* Machine dependent parameters. Some tuning parameters can be found */ /* near the top of gc_private.h. */ /* Machine specific parts contributed by various people. See README file. */ #if defined(__ANDROID__) && !defined(PLATFORM_ANDROID) /* __ANDROID__ macro is defined by Android NDK gcc. */ # define PLATFORM_ANDROID 1 #endif #if defined(__SYMBIAN32__) && !defined(SYMBIAN) # define SYMBIAN # ifdef __WINS__ # pragma data_seg(".data2") # endif #endif /* First a unified test for Linux: */ # if (defined(linux) || defined(__linux__) || defined(PLATFORM_ANDROID)) \ && !defined(LINUX) && !defined(__native_client__) # define LINUX # endif /* And one for QNX: */ # if defined(__QNX__) # define I386 # define OS_TYPE "QNX" # define SA_RESTART 0 # define HEURISTIC1 extern char etext[]; # define DATASTART ((ptr_t)(etext)) extern int _end[]; # define DATAEND (_end) # define mach_type_known # endif /* And one for NetBSD: */ # if defined(__NetBSD__) # define NETBSD # endif /* And one for OpenBSD: */ # if defined(__OpenBSD__) # define OPENBSD # endif /* And one for FreeBSD: */ # if (defined(__FreeBSD__) || defined(__DragonFly__) \ || defined(__FreeBSD_kernel__)) && !defined(FREEBSD) # define FREEBSD # endif /* And one for Darwin: */ # if defined(macosx) || (defined(__APPLE__) && defined(__MACH__)) # define DARWIN # endif /* Determine the machine type: */ # if defined(__native_client__) # define NACL # define I386 # define mach_type_known # endif # if defined(__aarch64__) # define AARCH64 # if !defined(LINUX) && !defined(DARWIN) # define NOSYS # define mach_type_known # endif # endif # if defined(__arm) || defined(__arm__) || defined(__thumb__) # define ARM32 # if !defined(LINUX) && !defined(NETBSD) && !defined(FREEBSD) \ && !defined(OPENBSD) && !defined(DARWIN) \ && !defined(_WIN32) && !defined(__CEGCC__) && !defined(SYMBIAN) # define NOSYS # define mach_type_known # endif # endif # if defined(sun) && defined(mc68000) # error SUNOS4 no longer supported # endif # if defined(hp9000s300) # error M68K based HP machines no longer supported. # endif # if defined(OPENBSD) && defined(m68k) /* FIXME: Should we remove this case? */ # define M68K # define mach_type_known # endif # if defined(OPENBSD) && defined(__sparc__) # define SPARC # define mach_type_known # endif # if defined(OPENBSD) && defined(__arm__) # define ARM32 # define mach_type_known # endif # if defined(OPENBSD) && defined(__sh__) # define SH # define mach_type_known # endif # if defined(NETBSD) && (defined(m68k) || defined(__m68k__)) # define M68K # define mach_type_known # endif # if defined(NETBSD) && defined(__powerpc__) # define POWERPC # define mach_type_known # endif # if defined(NETBSD) && (defined(__arm32__) || defined(__arm__)) # define ARM32 # define mach_type_known # endif # if defined(NETBSD) && defined(__sh__) # define SH # define mach_type_known # endif # if defined(vax) || defined(__vax__) # define VAX # ifdef ultrix # define ULTRIX # else # define BSD # endif # define mach_type_known # endif # if defined(__NetBSD__) && defined(__vax__) # define VAX # define mach_type_known # endif # if defined(mips) || defined(__mips) || defined(_mips) # define MIPS # if defined(nec_ews) || defined(_nec_ews) # define EWS4800 # endif # if !defined(LINUX) && !defined(EWS4800) && !defined(NETBSD) \ && !defined(OPENBSD) # if defined(ultrix) || defined(__ultrix) # define ULTRIX # else # define IRIX5 /* or IRIX 6.X */ # endif # endif /* !LINUX */ # if defined(__NetBSD__) && defined(__MIPSEL__) # undef ULTRIX # endif # define mach_type_known # endif # if defined(__or1k__) # define OR1K /* OpenRISC/or1k */ # define mach_type_known # endif # if defined(DGUX) && (defined(i386) || defined(__i386__)) # define I386 # ifndef _USING_DGUX # define _USING_DGUX # endif # define mach_type_known # endif # if defined(sequent) && (defined(i386) || defined(__i386__)) # define I386 # define SEQUENT # define mach_type_known # endif # if defined(sun) && (defined(i386) || defined(__i386__)) # define I386 # define SOLARIS # define mach_type_known # endif # if defined(sun) && defined(__amd64) # define X86_64 # define SOLARIS # define mach_type_known # endif # if (defined(__OS2__) || defined(__EMX__)) && defined(__32BIT__) # define I386 # define OS2 # define mach_type_known # endif # if defined(ibm032) # error IBM PC/RT no longer supported. # endif # if defined(sun) && (defined(sparc) || defined(__sparc)) # define SPARC /* Test for SunOS 5.x */ # include # define SOLARIS # define mach_type_known # endif # if defined(sparc) && defined(unix) && !defined(sun) && !defined(linux) \ && !defined(__OpenBSD__) && !defined(__NetBSD__) \ && !defined(__FreeBSD__) && !defined(__DragonFly__) # define SPARC # define DRSNX # define mach_type_known # endif # if defined(_IBMR2) # define POWERPC # define AIX # define mach_type_known # endif # if defined(__NetBSD__) && defined(__sparc__) # define SPARC # define mach_type_known # endif # if defined(_M_XENIX) && defined(_M_SYSV) && defined(_M_I386) /* The above test may need refinement */ # define I386 # if defined(_SCO_ELF) # define SCO_ELF # else # define SCO # endif # define mach_type_known # endif # if defined(_AUX_SOURCE) # error A/UX no longer supported # endif # if defined(_PA_RISC1_0) || defined(_PA_RISC1_1) || defined(_PA_RISC2_0) \ || defined(hppa) || defined(__hppa__) # define HP_PA # if !defined(LINUX) && !defined(HPUX) && !defined(OPENBSD) # define HPUX # endif # define mach_type_known # endif # if defined(__ia64) && (defined(_HPUX_SOURCE) || defined(__HP_aCC)) # define IA64 # ifndef HPUX # define HPUX # endif # define mach_type_known # endif # if defined(__BEOS__) && defined(_X86_) # define I386 # define BEOS # define mach_type_known # endif # if defined(OPENBSD) && defined(__amd64__) # define X86_64 # define mach_type_known # endif # if defined(LINUX) && (defined(i386) || defined(__i386__)) # define I386 # define mach_type_known # endif # if defined(LINUX) && defined(__x86_64__) # define X86_64 # define mach_type_known # endif # if defined(LINUX) && (defined(__ia64__) || defined(__ia64)) # define IA64 # define mach_type_known # endif # if defined(LINUX) && defined(__aarch64__) # define AARCH64 # define mach_type_known # endif # if defined(LINUX) && (defined(__arm) || defined(__arm__)) # define ARM32 # define mach_type_known # endif # if defined(LINUX) && defined(__cris__) # ifndef CRIS # define CRIS # endif # define mach_type_known # endif # if defined(LINUX) && (defined(powerpc) || defined(__powerpc__) \ || defined(powerpc64) || defined(__powerpc64__)) # define POWERPC # define mach_type_known # endif # if defined(LINUX) && defined(__mc68000__) # define M68K # define mach_type_known # endif # if defined(LINUX) && (defined(sparc) || defined(__sparc__)) # define SPARC # define mach_type_known # endif # if defined(LINUX) && defined(__sh__) # define SH # define mach_type_known # endif # if defined(LINUX) && defined(__avr32__) # define AVR32 # define mach_type_known # endif # if defined(LINUX) && defined(__m32r__) # define M32R # define mach_type_known # endif # if defined(__alpha) || defined(__alpha__) # define ALPHA # if !defined(LINUX) && !defined(NETBSD) && !defined(OPENBSD) \ && !defined(FREEBSD) # define OSF1 /* a.k.a Digital Unix */ # endif # define mach_type_known # endif # if defined(_AMIGA) && !defined(AMIGA) # define AMIGA # endif # ifdef AMIGA # define M68K # define mach_type_known # endif # if defined(THINK_C) \ || (defined(__MWERKS__) && !defined(__powerc) && !defined(SYMBIAN)) # define M68K # define MACOS # define mach_type_known # endif # if defined(__MWERKS__) && defined(__powerc) && !defined(__MACH__) \ && !defined(SYMBIAN) # define POWERPC # define MACOS # define mach_type_known # endif # if defined(__OpenBSD__) && defined(__powerpc__) # define POWERPC # define OPENBSD # define mach_type_known # endif # if defined(DARWIN) # if defined(__ppc__) || defined(__ppc64__) # define POWERPC # define mach_type_known # elif defined(__x86_64__) || defined(__x86_64) # define X86_64 # define mach_type_known # elif defined(__i386__) # define I386 # define mach_type_known # elif defined(__arm__) # define ARM32 # define mach_type_known # define DARWIN_DONT_PARSE_STACK # elif defined(__aarch64__) # define AARCH64 # define mach_type_known # define DARWIN_DONT_PARSE_STACK # endif # endif # if defined(__rtems__) && (defined(i386) || defined(__i386__)) # define I386 # define RTEMS # define mach_type_known # endif # if defined(NeXT) && defined(mc68000) # define M68K # define NEXT # define mach_type_known # endif # if defined(NeXT) && (defined(i386) || defined(__i386__)) # define I386 # define NEXT # define mach_type_known # endif # if defined(__OpenBSD__) && (defined(i386) || defined(__i386__)) # define I386 # define OPENBSD # define mach_type_known # endif # if defined(__NetBSD__) && (defined(i386) || defined(__i386__)) # define I386 # define mach_type_known # endif # if defined(__NetBSD__) && defined(__x86_64__) # define X86_64 # define mach_type_known # endif # if defined(FREEBSD) && (defined(i386) || defined(__i386__)) # define I386 # define mach_type_known # endif # if defined(FREEBSD) && (defined(__amd64__) || defined(__x86_64__)) # define X86_64 # define mach_type_known # endif # if defined(FREEBSD) && defined(__ia64__) # define IA64 # define mach_type_known # endif # if defined(FREEBSD) && defined(__sparc__) # define SPARC # define mach_type_known # endif # if defined(FREEBSD) && (defined(powerpc) || defined(__powerpc__)) # define POWERPC # define mach_type_known # endif # if defined(FREEBSD) && defined(__arm__) # define ARM32 # define mach_type_known # endif # if defined(bsdi) && (defined(i386) || defined(__i386__)) # define I386 # define BSDI # define mach_type_known # endif # if !defined(mach_type_known) && defined(__386BSD__) # define I386 # define THREE86BSD # define mach_type_known # endif # if defined(_CX_UX) && defined(_M88K) # define M88K # define CX_UX # define mach_type_known # endif # if defined(DGUX) && defined(m88k) # define M88K /* DGUX defined */ # define mach_type_known # endif # if defined(_WIN32_WCE) || defined(__CEGCC__) || defined(__MINGW32CE__) /* SH3, SH4, MIPS already defined for corresponding architectures */ # if defined(SH3) || defined(SH4) # define SH # endif # if defined(x86) || defined(__i386__) # define I386 # endif # if defined(_M_ARM) || defined(ARM) || defined(_ARM_) # define ARM32 # endif # define MSWINCE # define mach_type_known # else # if ((defined(_MSDOS) || defined(_MSC_VER)) && (_M_IX86 >= 300)) \ || (defined(_WIN32) && !defined(__CYGWIN32__) && !defined(__CYGWIN__) \ && !defined(SYMBIAN)) # if defined(__LP64__) || defined(_WIN64) # define X86_64 # else # define I386 # endif # define MSWIN32 /* or Win64 */ # define mach_type_known # endif # if defined(_MSC_VER) && defined(_M_IA64) # define IA64 # define MSWIN32 /* Really win64, but we don't treat 64-bit */ /* variants as a different platform. */ # endif # endif # if defined(__DJGPP__) # define I386 # ifndef DJGPP # define DJGPP /* MSDOS running the DJGPP port of GCC */ # endif # define mach_type_known # endif # if defined(__CYGWIN32__) || defined(__CYGWIN__) # if defined(__LP64__) # define X86_64 # else # define I386 # endif # define CYGWIN32 # define mach_type_known # endif # if defined(__MINGW32__) && !defined(mach_type_known) # define I386 # define MSWIN32 # define mach_type_known # endif # if defined(__BORLANDC__) # define I386 # define MSWIN32 # define mach_type_known # endif # if defined(_UTS) && !defined(mach_type_known) # define S370 # define UTS4 # define mach_type_known # endif # if defined(__pj__) # error PicoJava no longer supported /* The implementation had problems, and I haven't heard of users */ /* in ages. If you want it resurrected, let me know. */ # endif # if defined(__embedded__) && defined(PPC) # define POWERPC # define NOSYS # define mach_type_known # endif # if defined(__WATCOMC__) && defined(__386__) # define I386 # if !defined(OS2) && !defined(MSWIN32) && !defined(DOS4GW) # if defined(__OS2__) # define OS2 # else # if defined(__WINDOWS_386__) || defined(__NT__) # define MSWIN32 # else # define DOS4GW # endif # endif # endif # define mach_type_known # endif # if defined(__s390__) && defined(LINUX) # define S390 # define mach_type_known # endif # if defined(__GNU__) # if defined(__i386__) /* The Debian Hurd running on generic PC */ # define HURD # define I386 # define mach_type_known # endif # endif # if defined(__TANDEM) /* Nonstop S-series */ /* FIXME: Should recognize Integrity series? */ # define MIPS # define NONSTOP # define mach_type_known # endif # if defined(__hexagon__) && defined(LINUX) # define HEXAGON # define mach_type_known # endif # if defined(SYMBIAN) # define mach_type_known # endif # if defined(__EMSCRIPTEN__) # define I386 # define mach_type_known # endif /* Feel free to add more clauses here */ /* Or manually define the machine type here. A machine type is */ /* characterized by the architecture. Some */ /* machine types are further subdivided by OS. */ /* Macros such as LINUX, FREEBSD, etc. distinguish them. */ /* SYSV on an M68K actually means A/UX. */ /* The distinction in these cases is usually the stack starting address */ # ifndef mach_type_known # error "The collector has not been ported to this machine/OS combination." # endif /* Mapping is: M68K ==> Motorola 680X0 */ /* (NEXT, and SYSV (A/UX), */ /* MACOS and AMIGA variants) */ /* I386 ==> Intel 386 */ /* (SEQUENT, OS2, SCO, LINUX, NETBSD, */ /* FREEBSD, THREE86BSD, MSWIN32, */ /* BSDI, SOLARIS, NEXT and others) */ /* NS32K ==> Encore Multimax */ /* MIPS ==> R2000 through R14K */ /* (many variants) */ /* VAX ==> DEC VAX */ /* (BSD, ULTRIX variants) */ /* HP_PA ==> HP9000/700 & /800 */ /* HP/UX, LINUX */ /* SPARC ==> SPARC v7/v8/v9 */ /* (SOLARIS, LINUX, DRSNX variants) */ /* ALPHA ==> DEC Alpha */ /* (OSF1 and LINUX variants) */ /* M88K ==> Motorola 88XX0 */ /* (CX_UX and DGUX) */ /* S370 ==> 370-like machine */ /* running Amdahl UTS4 */ /* S390 ==> 390-like machine */ /* running LINUX */ /* AARCH64 ==> ARM AArch64 */ /* ARM32 ==> Intel StrongARM */ /* IA64 ==> Intel IPF */ /* (e.g. Itanium) */ /* (LINUX and HPUX) */ /* SH ==> Hitachi SuperH */ /* (LINUX & MSWINCE) */ /* X86_64 ==> AMD x86-64 */ /* POWERPC ==> IBM/Apple PowerPC */ /* (MACOS(<=9),DARWIN(incl.MACOSX),*/ /* LINUX, NETBSD, AIX, NOSYS */ /* variants) */ /* Handles 32 and 64-bit variants. */ /* CRIS ==> Axis Etrax */ /* M32R ==> Renesas M32R */ /* HEXAGON ==> Qualcomm Hexagon */ /* * For each architecture and OS, the following need to be defined: * * CPP_WORDSZ is a simple integer constant representing the word size. * in bits. We assume byte addressability, where a byte has 8 bits. * We also assume CPP_WORDSZ is either 32 or 64. * (We care about the length of pointers, not hardware * bus widths. Thus a 64 bit processor with a C compiler that uses * 32 bit pointers should use CPP_WORDSZ of 32, not 64. Default is 32.) * * MACH_TYPE is a string representation of the machine type. * OS_TYPE is analogous for the OS. * * ALIGNMENT is the largest N, such that * all pointer are guaranteed to be aligned on N byte boundaries. * defining it to be 1 will always work, but perform poorly. * * DATASTART is the beginning of the data segment. * On some platforms SEARCH_FOR_DATA_START is defined. * SEARCH_FOR_DATASTART will cause GC_data_start to * be set to an address determined by accessing data backwards from _end * until an unmapped page is found. DATASTART will be defined to be * GC_data_start. * On UNIX-like systems, the collector will scan the area between DATASTART * and DATAEND for root pointers. * * DATAEND, if not "end", where "end" is defined as "extern int end[]". * RTH suggests gaining access to linker script synth'd values with * this idiom instead of "&end", where "end" is defined as "extern int end". * Otherwise, "GCC will assume these are in .sdata/.sbss" and it will, e.g., * cause failures on alpha*-*-* with -msmall-data or -fpic or mips-*-* * without any special options. * * STACKBOTTOM is the cool end of the stack, which is usually the * highest address in the stack. * Under PCR or OS/2, we have other ways of finding thread stacks. * For each machine, the following should: * 1) define STACK_GROWS_UP if the stack grows toward higher addresses, and * 2) define exactly one of * STACKBOTTOM (should be defined to be an expression) * LINUX_STACKBOTTOM * HEURISTIC1 * HEURISTIC2 * If STACKBOTTOM is defined, then it's value will be used directly as the * stack base. If LINUX_STACKBOTTOM is defined, then it will be determined * with a method appropriate for most Linux systems. Currently we look * first for __libc_stack_end (currently only if USE_LIBC_PRIVATES is * defined), and if that fails read it from /proc. (If USE_LIBC_PRIVATES * is not defined and NO_PROC_STAT is defined, we revert to HEURISTIC2.) * If either of the last two macros are defined, then STACKBOTTOM is computed * during collector startup using one of the following two heuristics: * HEURISTIC1: Take an address inside GC_init's frame, and round it up to * the next multiple of STACK_GRAN. * HEURISTIC2: Take an address inside GC_init's frame, increment it repeatedly * in small steps (decrement if STACK_GROWS_UP), and read the value * at each location. Remember the value when the first * Segmentation violation or Bus error is signaled. Round that * to the nearest plausible page boundary, and use that instead * of STACKBOTTOM. * * Gustavo Rodriguez-Rivera points out that on most (all?) Unix machines, * the value of environ is a pointer that can serve as STACKBOTTOM. * I expect that HEURISTIC2 can be replaced by this approach, which * interferes far less with debugging. However it has the disadvantage * that it's confused by a putenv call before the collector is initialized. * This could be dealt with by intercepting putenv ... * * If no expression for STACKBOTTOM can be found, and neither of the above * heuristics are usable, the collector can still be used with all of the above * undefined, provided one of the following is done: * 1) GC_mark_roots can be changed to somehow mark from the correct stack(s) * without reference to STACKBOTTOM. This is appropriate for use in * conjunction with thread packages, since there will be multiple stacks. * (Allocating thread stacks in the heap, and treating them as ordinary * heap data objects is also possible as a last resort. However, this is * likely to introduce significant amounts of excess storage retention * unless the dead parts of the thread stacks are periodically cleared.) * 2) Client code may set GC_stackbottom before calling any GC_ routines. * If the author of the client code controls the main program, this is * easily accomplished by introducing a new main program, setting * GC_stackbottom to the address of a local variable, and then calling * the original main program. The new main program would read something * like (provided real_main() is not inlined by the compiler): * * # include "gc_private.h" * * main(argc, argv, envp) * int argc; * char **argv, **envp; * { * volatile int dummy; * * GC_stackbottom = (ptr_t)(&dummy); * return(real_main(argc, argv, envp)); * } * * * Each architecture may also define the style of virtual dirty bit * implementation to be used: * MPROTECT_VDB: Write protect the heap and catch faults. * GWW_VDB: Use win32 GetWriteWatch primitive. * PROC_VDB: Use the SVR4 /proc primitives to read dirty bits. * * The first and second one may be combined, in which case a runtime * selection will be made, based on GetWriteWatch availability. * * An architecture may define DYNAMIC_LOADING if dyn_load.c * defined GC_register_dynamic_libraries() for the architecture. * * An architecture may define PREFETCH(x) to preload the cache with *x. * This defaults to GCC built-in operation (or a no-op for other compilers). * * PREFETCH_FOR_WRITE(x) is used if *x is about to be written. * * An architecture may also define CLEAR_DOUBLE(x) to be a fast way to * clear the two words at GC_malloc-aligned address x. By default, * word stores of 0 are used instead. * * HEAP_START may be defined as the initial address hint for mmap-based * allocation. */ /* If we are using a recent version of gcc, we can use */ /* __builtin_unwind_init() to push the relevant registers onto the stack. */ # if defined(__GNUC__) && ((__GNUC__ >= 3) \ || (__GNUC__ == 2 && __GNUC_MINOR__ >= 8)) \ && !defined(__INTEL_COMPILER) && !defined(__PATHCC__) \ && !defined(__FUJITSU) /* for FX10 system */ \ && !(defined(POWERPC) && defined(DARWIN)) /* for MacOS X 10.3.9 */ \ && !defined(RTEMS) \ && !defined(__clang__) /* since no-op in clang (3.0) */ # define HAVE_BUILTIN_UNWIND_INIT # endif # ifdef SYMBIAN # define MACH_TYPE "SYMBIAN" # define OS_TYPE "SYMBIAN" # define CPP_WORDSZ 32 # define ALIGNMENT 4 # define DATASTART NULL # define DATAEND NULL # endif # ifdef __EMSCRIPTEN__ # define OS_TYPE "EMSCRIPTEN" # define CPP_WORDSZ 32 # define ALIGNMENT 4 # define DATASTART NULL # define DATAEND NULL # define STACK_NOT_SCANNED # endif # define STACK_GRAN 0x1000000 # ifdef M68K # define MACH_TYPE "M68K" # define ALIGNMENT 2 # ifdef OPENBSD /* FIXME: Should we remove this case? */ # define OS_TYPE "OPENBSD" # define HEURISTIC2 # ifdef __ELF__ extern ptr_t GC_data_start; # define DATASTART GC_data_start # define DYNAMIC_LOADING # else extern char etext[]; # define DATASTART ((ptr_t)(etext)) # endif # endif # ifdef NETBSD # define OS_TYPE "NETBSD" # define HEURISTIC2 # ifdef __ELF__ extern ptr_t GC_data_start; # define DATASTART GC_data_start # define DYNAMIC_LOADING # else extern char etext[]; # define DATASTART ((ptr_t)(etext)) # endif # endif # ifdef LINUX # define OS_TYPE "LINUX" # define LINUX_STACKBOTTOM # define MPROTECT_VDB # ifdef __ELF__ # define DYNAMIC_LOADING # include # if defined(__GLIBC__) && __GLIBC__ >= 2 # define SEARCH_FOR_DATA_START # else /* !GLIBC2 */ # ifdef PLATFORM_ANDROID # define __environ environ # endif extern char **__environ; # define DATASTART ((ptr_t)(&__environ)) /* hideous kludge: __environ is the first */ /* word in crt0.o, and delimits the start */ /* of the data segment, no matter which */ /* ld options were passed through. */ /* We could use _etext instead, but that */ /* would include .rodata, which may */ /* contain large read-only data tables */ /* that we'd rather not scan. */ # endif /* !GLIBC2 */ extern int _end[]; # define DATAEND (ptr_t)(_end) # else extern int etext[]; # define DATASTART ((ptr_t)((((word) (etext)) + 0xfff) & ~0xfff)) # endif # endif # ifdef AMIGA # define OS_TYPE "AMIGA" /* STACKBOTTOM and DATASTART handled specially */ /* in os_dep.c */ # define DATAEND /* not needed */ # define GETPAGESIZE() 4096 # endif # ifdef MACOS # ifndef __LOWMEM__ # include # endif # define OS_TYPE "MACOS" /* see os_dep.c for details of global data segments. */ # define STACKBOTTOM ((ptr_t) LMGetCurStackBase()) # define DATAEND /* not needed */ # define GETPAGESIZE() 4096 # endif # ifdef NEXT # define OS_TYPE "NEXT" # define DATASTART ((ptr_t) get_etext()) # define DATASTART_IS_FUNC # define STACKBOTTOM ((ptr_t) 0x4000000) # define DATAEND /* not needed */ # endif # endif # if defined(POWERPC) # define MACH_TYPE "POWERPC" # ifdef MACOS # define ALIGNMENT 2 /* Still necessary? Could it be 4? */ # ifndef __LOWMEM__ # include # endif # define OS_TYPE "MACOS" /* see os_dep.c for details of global data segments. */ # define STACKBOTTOM ((ptr_t) LMGetCurStackBase()) # define DATAEND /* not needed */ # endif # ifdef LINUX # if defined(__powerpc64__) # define ALIGNMENT 8 # define CPP_WORDSZ 64 # ifndef HBLKSIZE # define HBLKSIZE 4096 # endif # else # define ALIGNMENT 4 # endif # define OS_TYPE "LINUX" /* HEURISTIC1 has been reliably reported to fail for a 32-bit */ /* executable on a 64 bit kernel. */ # if defined(__bg__) /* The Linux Compute Node Kernel (used on BlueGene systems) */ /* does not support LINUX_STACKBOTTOM way. */ # define HEURISTIC2 # define NO_PTHREAD_GETATTR_NP # else # define LINUX_STACKBOTTOM # endif # define DYNAMIC_LOADING # define SEARCH_FOR_DATA_START extern int _end[]; # define DATAEND (ptr_t)(_end) # endif # ifdef DARWIN # define OS_TYPE "DARWIN" # define DYNAMIC_LOADING # if defined(__ppc64__) # define ALIGNMENT 8 # define CPP_WORDSZ 64 # define STACKBOTTOM ((ptr_t) 0x7fff5fc00000) # define CACHE_LINE_SIZE 64 # ifndef HBLKSIZE # define HBLKSIZE 4096 # endif # else # define ALIGNMENT 4 # define STACKBOTTOM ((ptr_t) 0xc0000000) # endif /* XXX: see get_end(3), get_etext() and get_end() should not be used. */ /* These aren't used when dyld support is enabled (it is by default). */ # define DATASTART ((ptr_t) get_etext()) # define DATAEND ((ptr_t) get_end()) # ifndef USE_MMAP # define USE_MMAP # endif # define USE_MMAP_ANON # define MPROTECT_VDB # include # define GETPAGESIZE() getpagesize() # if defined(USE_PPC_PREFETCH) && defined(__GNUC__) /* The performance impact of prefetches is untested */ # define PREFETCH(x) \ __asm__ __volatile__ ("dcbt 0,%0" : : "r" ((const void *) (x))) # define PREFETCH_FOR_WRITE(x) \ __asm__ __volatile__ ("dcbtst 0,%0" : : "r" ((const void *) (x))) # endif /* There seems to be some issues with trylock hanging on darwin. */ /* This should be looked into some more. */ # define NO_PTHREAD_TRYLOCK # endif # ifdef OPENBSD # define OS_TYPE "OPENBSD" # define ALIGNMENT 4 # ifndef GC_OPENBSD_THREADS # include # include # define STACKBOTTOM ((ptr_t) USRSTACK) # endif extern int __data_start[]; # define DATASTART ((ptr_t)__data_start) extern char _end[]; # define DATAEND ((ptr_t)(&_end)) # define DYNAMIC_LOADING # endif # ifdef FREEBSD # if defined(__powerpc64__) # define ALIGNMENT 8 # define CPP_WORDSZ 64 # ifndef HBLKSIZE # define HBLKSIZE 4096 # endif # else # define ALIGNMENT 4 # endif # define OS_TYPE "FREEBSD" # ifndef GC_FREEBSD_THREADS # define MPROTECT_VDB # endif # define SIG_SUSPEND SIGUSR1 # define SIG_THR_RESTART SIGUSR2 # define FREEBSD_STACKBOTTOM # ifdef __ELF__ # define DYNAMIC_LOADING # endif extern char etext[]; ptr_t GC_FreeBSDGetDataStart(size_t, ptr_t); # define DATASTART GC_FreeBSDGetDataStart(0x1000, (ptr_t)etext) # define DATASTART_IS_FUNC # endif # ifdef NETBSD # define ALIGNMENT 4 # define OS_TYPE "NETBSD" # define HEURISTIC2 extern ptr_t GC_data_start; # define DATASTART GC_data_start # define DYNAMIC_LOADING # endif # ifdef SN_TARGET_PS3 # define NO_GETENV # define CPP_WORDSZ 32 # define ALIGNMENT 4 extern int _end []; extern int __bss_start; # define DATAEND (ptr_t)(_end) # define DATASTART (ptr_t)(__bss_start) # define STACKBOTTOM ((ptr_t)ps3_get_stack_bottom()) # define NO_PTHREAD_TRYLOCK /* Current GC LOCK() implementation for PS3 explicitly */ /* use pthread_mutex_lock for some reason. */ # endif # ifdef AIX # define OS_TYPE "AIX" # undef ALIGNMENT /* in case it's defined */ # undef IA64 /* DOB: some AIX installs stupidly define IA64 in */ /* /usr/include/sys/systemcfg.h */ # ifdef __64BIT__ # define ALIGNMENT 8 # define CPP_WORDSZ 64 # define STACKBOTTOM ((ptr_t)0x1000000000000000) # else # define ALIGNMENT 4 # define CPP_WORDSZ 32 # define STACKBOTTOM ((ptr_t)((ulong)&errno)) # endif # ifndef USE_MMAP # define USE_MMAP # endif # define USE_MMAP_ANON /* From AIX linker man page: _text Specifies the first location of the program. _etext Specifies the first location after the program. _data Specifies the first location of the data. _edata Specifies the first location after the initialized data _end or end Specifies the first location after all data. */ extern int _data[], _end[]; # define DATASTART ((ptr_t)((ulong)_data)) # define DATAEND ((ptr_t)((ulong)_end)) extern int errno; # define DYNAMIC_LOADING /* For really old versions of AIX, this may have to be removed. */ # endif # ifdef NOSYS # define ALIGNMENT 4 # define OS_TYPE "NOSYS" extern void __end[], __dso_handle[]; # define DATASTART (__dso_handle) /* OK, that's ugly. */ # define DATAEND (ptr_t)(__end) /* Stack starts at 0xE0000000 for the simulator. */ # undef STACK_GRAN # define STACK_GRAN 0x10000000 # define HEURISTIC1 # endif # endif # ifdef VAX # define MACH_TYPE "VAX" # define ALIGNMENT 4 /* Pointers are longword aligned by 4.2 C compiler */ extern char etext[]; # define DATASTART ((ptr_t)(etext)) # ifdef BSD # define OS_TYPE "BSD" # define HEURISTIC1 /* HEURISTIC2 may be OK, but it's hard to test. */ # endif # ifdef ULTRIX # define OS_TYPE "ULTRIX" # define STACKBOTTOM ((ptr_t) 0x7fffc800) # endif # endif # ifdef SPARC # define MACH_TYPE "SPARC" # if defined(__arch64__) || defined(__sparcv9) # define ALIGNMENT 8 # define CPP_WORDSZ 64 # define ELF_CLASS ELFCLASS64 # else # define ALIGNMENT 4 /* Required by hardware */ # define CPP_WORDSZ 32 # endif /* Don't define USE_ASM_PUSH_REGS. We do use an asm helper, but */ /* not to push the registers on the mark stack. */ # ifdef SOLARIS # define OS_TYPE "SOLARIS" extern int _etext[]; extern int _end[]; ptr_t GC_SysVGetDataStart(size_t, ptr_t); # define DATASTART GC_SysVGetDataStart(0x10000, (ptr_t)_etext) # define DATASTART_IS_FUNC # define DATAEND (ptr_t)(_end) # if !defined(USE_MMAP) && defined(REDIRECT_MALLOC) # define USE_MMAP /* Otherwise we now use calloc. Mmap may result in the */ /* heap interleaved with thread stacks, which can result in */ /* excessive blacklisting. Sbrk is unusable since it */ /* doesn't interact correctly with the system malloc. */ # endif # ifdef USE_MMAP # define HEAP_START (ptr_t)0x40000000 # else # define HEAP_START DATAEND # endif # define PROC_VDB /* HEURISTIC1 reportedly no longer works under 2.7. */ /* HEURISTIC2 probably works, but this appears to be preferable. */ /* Apparently USRSTACK is defined to be USERLIMIT, but in some */ /* installations that's undefined. We work around this with a */ /* gross hack: */ # include # ifdef USERLIMIT /* This should work everywhere, but doesn't. */ # define STACKBOTTOM ((ptr_t) USRSTACK) # else # define HEURISTIC2 # endif # include # define GETPAGESIZE() sysconf(_SC_PAGESIZE) /* getpagesize() appeared to be missing from at least one */ /* Solaris 5.4 installation. Weird. */ # define DYNAMIC_LOADING # endif # ifdef DRSNX # define OS_TYPE "DRSNX" ptr_t GC_SysVGetDataStart(size_t, ptr_t); extern int etext[]; # define DATASTART GC_SysVGetDataStart(0x10000, (ptr_t)etext) # define DATASTART_IS_FUNC # define MPROTECT_VDB # define STACKBOTTOM ((ptr_t) 0xdfff0000) # define DYNAMIC_LOADING # endif # ifdef LINUX # define OS_TYPE "LINUX" # ifdef __ELF__ # define DYNAMIC_LOADING # else # error --> Linux SPARC a.out not supported # endif extern int _end[]; extern int _etext[]; # define DATAEND (ptr_t)(_end) # define SVR4 ptr_t GC_SysVGetDataStart(size_t, ptr_t); # ifdef __arch64__ # define DATASTART GC_SysVGetDataStart(0x100000, (ptr_t)_etext) # else # define DATASTART GC_SysVGetDataStart(0x10000, (ptr_t)_etext) # endif # define DATASTART_IS_FUNC # define LINUX_STACKBOTTOM # endif # ifdef OPENBSD # define OS_TYPE "OPENBSD" # ifndef GC_OPENBSD_THREADS # include # include # define STACKBOTTOM ((ptr_t) USRSTACK) # endif extern int __data_start[]; # define DATASTART ((ptr_t)__data_start) extern char _end[]; # define DATAEND ((ptr_t)(&_end)) # define DYNAMIC_LOADING # endif # ifdef NETBSD # define OS_TYPE "NETBSD" # define HEURISTIC2 # ifdef __ELF__ extern ptr_t GC_data_start; # define DATASTART GC_data_start # define DYNAMIC_LOADING # else extern char etext[]; # define DATASTART ((ptr_t)(etext)) # endif # endif # ifdef FREEBSD # define OS_TYPE "FREEBSD" # define SIG_SUSPEND SIGUSR1 # define SIG_THR_RESTART SIGUSR2 # define FREEBSD_STACKBOTTOM # ifdef __ELF__ # define DYNAMIC_LOADING # endif extern char etext[]; extern char edata[]; extern char end[]; # define NEED_FIND_LIMIT # define DATASTART ((ptr_t)(&etext)) ptr_t GC_find_limit(ptr_t, GC_bool); # define DATAEND (GC_find_limit (DATASTART, TRUE)) # define DATAEND_IS_FUNC # define DATASTART2 ((ptr_t)(&edata)) # define DATAEND2 ((ptr_t)(&end)) # endif # endif # ifdef I386 # define MACH_TYPE "I386" # if defined(__LP64__) || defined(_WIN64) # error This should be handled as X86_64 # else # define CPP_WORDSZ 32 # define ALIGNMENT 4 /* Appears to hold for all "32 bit" compilers */ /* except Borland. The -a4 option fixes */ /* Borland. For Watcom the option is -zp4. */ # endif # ifdef SEQUENT # define OS_TYPE "SEQUENT" extern int etext[]; # define DATASTART ((ptr_t)((((word) (etext)) + 0xfff) & ~0xfff)) # define STACKBOTTOM ((ptr_t) 0x3ffff000) # endif # ifdef BEOS # define OS_TYPE "BEOS" # include # define GETPAGESIZE() B_PAGE_SIZE extern int etext[]; # define DATASTART ((ptr_t)((((word) (etext)) + 0xfff) & ~0xfff)) # endif # ifdef SOLARIS # define OS_TYPE "SOLARIS" extern int _etext[], _end[]; ptr_t GC_SysVGetDataStart(size_t, ptr_t); # define DATASTART GC_SysVGetDataStart(0x1000, (ptr_t)_etext) # define DATASTART_IS_FUNC # define DATAEND (ptr_t)(_end) /* # define STACKBOTTOM ((ptr_t)(_start)) worked through 2.7, */ /* but reportedly breaks under 2.8. It appears that the stack */ /* base is a property of the executable, so this should not break */ /* old executables. */ /* HEURISTIC2 probably works, but this appears to be preferable. */ # include # define STACKBOTTOM ((ptr_t) USRSTACK) /* At least in Solaris 2.5, PROC_VDB gives wrong values for dirty bits. */ /* It appears to be fixed in 2.8 and 2.9. */ # ifdef SOLARIS25_PROC_VDB_BUG_FIXED # define PROC_VDB # endif # ifndef GC_THREADS # define MPROTECT_VDB # endif # define DYNAMIC_LOADING # if !defined(USE_MMAP) && defined(REDIRECT_MALLOC) # define USE_MMAP /* Otherwise we now use calloc. Mmap may result in the */ /* heap interleaved with thread stacks, which can result in */ /* excessive blacklisting. Sbrk is unusable since it */ /* doesn't interact correctly with the system malloc. */ # endif # ifdef USE_MMAP # define HEAP_START (ptr_t)0x40000000 # else # define HEAP_START DATAEND # endif # endif # ifdef SCO # define OS_TYPE "SCO" extern int etext[]; # define DATASTART ((ptr_t)((((word) (etext)) + 0x3fffff) \ & ~0x3fffff) \ +((word)etext & 0xfff)) # define STACKBOTTOM ((ptr_t) 0x7ffffffc) # endif # ifdef SCO_ELF # define OS_TYPE "SCO_ELF" extern int etext[]; # define DATASTART ((ptr_t)(etext)) # define STACKBOTTOM ((ptr_t) 0x08048000) # define DYNAMIC_LOADING # define ELF_CLASS ELFCLASS32 # endif # ifdef DGUX # define OS_TYPE "DGUX" extern int _etext, _end; ptr_t GC_SysVGetDataStart(size_t, ptr_t); # define DATASTART GC_SysVGetDataStart(0x1000, (ptr_t)(&_etext)) # define DATASTART_IS_FUNC # define DATAEND (ptr_t)(&_end) # define STACK_GROWS_DOWN # define HEURISTIC2 # include # define GETPAGESIZE() sysconf(_SC_PAGESIZE) # define DYNAMIC_LOADING # ifndef USE_MMAP # define USE_MMAP # endif # define MAP_FAILED (void *) ((word)-1) # ifdef USE_MMAP # define HEAP_START (ptr_t)0x40000000 # else # define HEAP_START DATAEND # endif # endif /* DGUX */ # ifdef NACL # define OS_TYPE "NACL" extern int etext[]; /* #define DATASTART ((ptr_t)((((word) (etext)) + 0xfff) & ~0xfff)) */ # define DATASTART ((ptr_t)0x10000000) extern int _end[]; # define DATAEND (_end) # undef STACK_GRAN # define STACK_GRAN 0x10000 # define HEURISTIC1 # define NO_PTHREAD_GETATTR_NP # define GETPAGESIZE() 65536 # ifndef MAX_NACL_GC_THREADS # define MAX_NACL_GC_THREADS 1024 # endif # endif /* NACL */ # ifdef LINUX # define OS_TYPE "LINUX" # define LINUX_STACKBOTTOM # if !defined(GC_LINUX_THREADS) || !defined(REDIRECT_MALLOC) # define MPROTECT_VDB # else /* We seem to get random errors in incremental mode, */ /* possibly because Linux threads is itself a malloc client */ /* and can't deal with the signals. */ # endif # define HEAP_START (ptr_t)0x1000 /* This encourages mmap to give us low addresses, */ /* thus allowing the heap to grow to ~3GB */ # ifdef __ELF__ # define DYNAMIC_LOADING # ifdef UNDEFINED /* includes ro data */ extern int _etext[]; # define DATASTART ((ptr_t)((((word) (_etext)) + 0xfff) & ~0xfff)) # endif # include # if defined(__GLIBC__) && __GLIBC__ >= 2 \ || defined(PLATFORM_ANDROID) # define SEARCH_FOR_DATA_START # else extern char **__environ; # define DATASTART ((ptr_t)(&__environ)) /* hideous kludge: __environ is the first */ /* word in crt0.o, and delimits the start */ /* of the data segment, no matter which */ /* ld options were passed through. */ /* We could use _etext instead, but that */ /* would include .rodata, which may */ /* contain large read-only data tables */ /* that we'd rather not scan. */ # endif extern int _end[]; # define DATAEND (ptr_t)(_end) # if defined(PLATFORM_ANDROID) && !defined(GC_NO_SIGSETJMP) /* As of Android NDK r8b, _sigsetjmp is still missing */ /* for x86 (setjmp is used instead to find data_start). */ # define GC_NO_SIGSETJMP # endif # else extern int etext[]; # define DATASTART ((ptr_t)((((word) (etext)) + 0xfff) & ~0xfff)) # endif # ifdef USE_I686_PREFETCH # define PREFETCH(x) \ __asm__ __volatile__ ("prefetchnta %0" : : "m"(*(char *)(x))) /* Empirically prefetcht0 is much more effective at reducing */ /* cache miss stalls for the targeted load instructions. But it */ /* seems to interfere enough with other cache traffic that the */ /* net result is worse than prefetchnta. */ # ifdef FORCE_WRITE_PREFETCH /* Using prefetches for write seems to have a slight negative */ /* impact on performance, at least for a PIII/500. */ # define PREFETCH_FOR_WRITE(x) \ __asm__ __volatile__ ("prefetcht0 %0" : : "m"(*(char *)(x))) # else # define NO_PREFETCH_FOR_WRITE # endif # elif defined(USE_3DNOW_PREFETCH) # define PREFETCH(x) \ __asm__ __volatile__ ("prefetch %0" : : "m"(*(char *)(x))) # define PREFETCH_FOR_WRITE(x) \ __asm__ __volatile__ ("prefetchw %0" : : "m"(*(char *)(x))) # endif # if defined(__GLIBC__) /* Workaround lock elision implementation for some glibc. */ # define GLIBC_2_19_TSX_BUG # include /* for gnu_get_libc_version() */ # endif # endif # ifdef CYGWIN32 # define OS_TYPE "CYGWIN32" # define DATASTART ((ptr_t)GC_DATASTART) /* From gc.h */ # define DATAEND ((ptr_t)GC_DATAEND) # undef STACK_GRAN # define STACK_GRAN 0x10000 # ifdef USE_MMAP # define NEED_FIND_LIMIT # define USE_MMAP_ANON # endif # endif # ifdef OS2 # define OS_TYPE "OS2" /* STACKBOTTOM and DATASTART are handled specially in */ /* os_dep.c. OS2 actually has the right */ /* system call! */ # define DATAEND /* not needed */ # endif # ifdef MSWIN32 # define OS_TYPE "MSWIN32" /* STACKBOTTOM and DATASTART are handled specially in */ /* os_dep.c. */ # define MPROTECT_VDB # define GWW_VDB # define DATAEND /* not needed */ # endif # ifdef MSWINCE # define OS_TYPE "MSWINCE" # define DATAEND /* not needed */ # endif # ifdef DJGPP # define OS_TYPE "DJGPP" # include "stubinfo.h" extern int etext[]; extern int _stklen; extern int __djgpp_stack_limit; # define DATASTART ((ptr_t)((((word) (etext)) + 0x1ff) & ~0x1ff)) /* #define STACKBOTTOM ((ptr_t)((word)_stubinfo+_stubinfo->size+_stklen)) */ # define STACKBOTTOM ((ptr_t)((word) __djgpp_stack_limit + _stklen)) /* This may not be right. */ # endif # ifdef OPENBSD # define OS_TYPE "OPENBSD" # ifndef GC_OPENBSD_THREADS # include # include # define STACKBOTTOM ((ptr_t) USRSTACK) # endif extern int __data_start[]; # define DATASTART ((ptr_t)__data_start) extern char _end[]; # define DATAEND ((ptr_t)(&_end)) # define DYNAMIC_LOADING # endif # ifdef FREEBSD # define OS_TYPE "FREEBSD" # ifndef GC_FREEBSD_THREADS # define MPROTECT_VDB # endif # ifdef __GLIBC__ # define SIG_SUSPEND (32+6) # define SIG_THR_RESTART (32+5) extern int _end[]; # define DATAEND (ptr_t)(_end) # else # define SIG_SUSPEND SIGUSR1 # define SIG_THR_RESTART SIGUSR2 /* SIGTSTP and SIGCONT could be used alternatively. */ # endif # define FREEBSD_STACKBOTTOM # ifdef __ELF__ # define DYNAMIC_LOADING # endif extern char etext[]; char * GC_FreeBSDGetDataStart(size_t, ptr_t); # define DATASTART GC_FreeBSDGetDataStart(0x1000, (ptr_t)etext) # define DATASTART_IS_FUNC # endif # ifdef NETBSD # define OS_TYPE "NETBSD" # ifdef __ELF__ # define DYNAMIC_LOADING # endif # endif # ifdef THREE86BSD # define OS_TYPE "THREE86BSD" # endif # ifdef BSDI # define OS_TYPE "BSDI" # endif # if defined(NETBSD) || defined(THREE86BSD) || defined(BSDI) # define HEURISTIC2 extern char etext[]; # define DATASTART ((ptr_t)(etext)) # endif # ifdef NEXT # define OS_TYPE "NEXT" # define DATASTART ((ptr_t) get_etext()) # define DATASTART_IS_FUNC # define STACKBOTTOM ((ptr_t)0xc0000000) # define DATAEND /* not needed */ # endif # ifdef RTEMS # define OS_TYPE "RTEMS" # include extern int etext[]; extern int end[]; void *rtems_get_stack_bottom(void); # define InitStackBottom rtems_get_stack_bottom() # define DATASTART ((ptr_t)etext) # define DATAEND ((ptr_t)end) # define STACKBOTTOM ((ptr_t)InitStackBottom) # define SIG_SUSPEND SIGUSR1 # define SIG_THR_RESTART SIGUSR2 # endif # ifdef DOS4GW # define OS_TYPE "DOS4GW" extern long __nullarea; extern char _end; extern char *_STACKTOP; /* Depending on calling conventions Watcom C either precedes */ /* or does not precedes with underscore names of C-variables. */ /* Make sure startup code variables always have the same names. */ #pragma aux __nullarea "*"; #pragma aux _end "*"; # define STACKBOTTOM ((ptr_t) _STACKTOP) /* confused? me too. */ # define DATASTART ((ptr_t) &__nullarea) # define DATAEND ((ptr_t) &_end) # endif # ifdef HURD # define OS_TYPE "HURD" # define STACK_GROWS_DOWN # define HEURISTIC2 # define SIG_SUSPEND SIGUSR1 # define SIG_THR_RESTART SIGUSR2 # define SEARCH_FOR_DATA_START extern int _end[]; # define DATAEND ((ptr_t) (_end)) /* # define MPROTECT_VDB Not quite working yet? */ # define DYNAMIC_LOADING # endif # ifdef DARWIN # define OS_TYPE "DARWIN" # define DARWIN_DONT_PARSE_STACK # define DYNAMIC_LOADING /* XXX: see get_end(3), get_etext() and get_end() should not be used. */ /* These aren't used when dyld support is enabled (it is by default). */ # define DATASTART ((ptr_t) get_etext()) # define DATAEND ((ptr_t) get_end()) # define STACKBOTTOM ((ptr_t) 0xc0000000) # ifndef USE_MMAP # define USE_MMAP # endif # define USE_MMAP_ANON # define MPROTECT_VDB # include # define GETPAGESIZE() getpagesize() /* There seems to be some issues with trylock hanging on darwin. */ /* This should be looked into some more. */ # define NO_PTHREAD_TRYLOCK # endif /* DARWIN */ # endif # ifdef NS32K # define MACH_TYPE "NS32K" # define ALIGNMENT 4 extern char **environ; # define DATASTART ((ptr_t)(&environ)) /* hideous kludge: environ is the first */ /* word in crt0.o, and delimits the start */ /* of the data segment, no matter which */ /* ld options were passed through. */ # define STACKBOTTOM ((ptr_t) 0xfffff000) /* for Encore */ # endif # ifdef MIPS # define MACH_TYPE "MIPS" # ifdef LINUX # define OS_TYPE "LINUX" # define DYNAMIC_LOADING extern int _end[]; # define DATAEND (ptr_t)(_end) # pragma weak __data_start extern int __data_start[]; # define DATASTART ((ptr_t)(__data_start)) # ifdef _MIPS_SZPTR # define CPP_WORDSZ _MIPS_SZPTR # define ALIGNMENT (_MIPS_SZPTR/8) # else # define ALIGNMENT 4 # endif # ifndef HBLKSIZE # define HBLKSIZE 4096 # endif # if __GLIBC__ == 2 && __GLIBC_MINOR__ >= 2 || __GLIBC__ > 2 # define LINUX_STACKBOTTOM # else # define STACKBOTTOM ((ptr_t)0x7fff8000) # endif # endif /* Linux */ # ifdef EWS4800 # define HEURISTIC2 # if defined(_MIPS_SZPTR) && (_MIPS_SZPTR == 64) extern int _fdata[], _end[]; # define DATASTART ((ptr_t)_fdata) # define DATAEND ((ptr_t)_end) # define CPP_WORDSZ _MIPS_SZPTR # define ALIGNMENT (_MIPS_SZPTR/8) # else extern int etext[], edata[], end[]; extern int _DYNAMIC_LINKING[], _gp[]; # define DATASTART ((ptr_t)((((word)etext + 0x3ffff) & ~0x3ffff) \ + ((word)etext & 0xffff))) # define DATAEND (ptr_t)(edata) # define DATASTART2 (_DYNAMIC_LINKING \ ? (ptr_t)(((word)_gp + 0x8000 + 0x3ffff) & ~0x3ffff) \ : (ptr_t)edata) # define DATAEND2 (ptr_t)(end) # define ALIGNMENT 4 # endif # define OS_TYPE "EWS4800" # endif # ifdef ULTRIX # define HEURISTIC2 # define DATASTART (ptr_t)0x10000000 /* Could probably be slightly higher since */ /* startup code allocates lots of stuff. */ # define OS_TYPE "ULTRIX" # define ALIGNMENT 4 # endif # ifdef IRIX5 # define HEURISTIC2 extern int _fdata[]; # define DATASTART ((ptr_t)(_fdata)) # ifdef USE_MMAP # define HEAP_START (ptr_t)0x30000000 # else # define HEAP_START DATASTART # endif /* Lowest plausible heap address. */ /* In the MMAP case, we map there. */ /* In either case it is used to identify */ /* heap sections so they're not */ /* considered as roots. */ # define OS_TYPE "IRIX5" /*# define MPROTECT_VDB DOB: this should work, but there is evidence */ /* of recent breakage. */ # ifdef _MIPS_SZPTR # define CPP_WORDSZ _MIPS_SZPTR # define ALIGNMENT (_MIPS_SZPTR/8) # else # define ALIGNMENT 4 # endif # define DYNAMIC_LOADING # endif # ifdef MSWINCE # define OS_TYPE "MSWINCE" # define ALIGNMENT 4 # define DATAEND /* not needed */ # endif # if defined(NETBSD) # define OS_TYPE "NETBSD" # define ALIGNMENT 4 # define HEURISTIC2 # ifdef __ELF__ extern ptr_t GC_data_start; # define DATASTART GC_data_start # define NEED_FIND_LIMIT # define DYNAMIC_LOADING # else # define DATASTART ((ptr_t) 0x10000000) # define STACKBOTTOM ((ptr_t) 0x7ffff000) # endif /* _ELF_ */ # endif # ifdef OPENBSD # define OS_TYPE "OPENBSD" # define ALIGNMENT 4 # ifndef GC_OPENBSD_THREADS # include # include # define STACKBOTTOM ((ptr_t) USRSTACK) # endif extern int _fdata[]; # define DATASTART ((ptr_t)_fdata) extern char _end[]; # define DATAEND ((ptr_t)(&_end)) # define DYNAMIC_LOADING # endif # if defined(NONSTOP) # define CPP_WORDSZ 32 # define OS_TYPE "NONSTOP" # define ALIGNMENT 4 # define DATASTART ((ptr_t) 0x08000000) extern char **environ; # define DATAEND ((ptr_t)(environ - 0x10)) # define STACKBOTTOM ((ptr_t) 0x4fffffff) # endif # endif # ifdef OR1K # define CPP_WORDSZ 32 # define MACH_TYPE "OR1K" # ifdef LINUX # define OS_TYPE "LINUX" # define DYNAMIC_LOADING extern int _end[]; # define DATAEND (ptr_t)(_end) extern int __data_start[]; # define DATASTART ((ptr_t)(__data_start)) # define ALIGNMENT 4 # ifndef HBLKSIZE # define HBLKSIZE 4096 # endif # define LINUX_STACKBOTTOM # endif /* Linux */ # endif # ifdef HP_PA # define MACH_TYPE "HP_PA" # ifdef __LP64__ # define CPP_WORDSZ 64 # define ALIGNMENT 8 # else # define CPP_WORDSZ 32 # define ALIGNMENT 4 # endif # if !defined(GC_HPUX_THREADS) && !defined(GC_LINUX_THREADS) \ && !defined(OPENBSD) && !defined(LINUX) /* For now. */ # define MPROTECT_VDB # endif # define STACK_GROWS_UP # ifdef HPUX # define OS_TYPE "HPUX" extern int __data_start[]; # define DATASTART ((ptr_t)(__data_start)) # ifdef USE_HPUX_FIXED_STACKBOTTOM /* The following appears to work for 7xx systems running HP/UX */ /* 9.xx. Furthermore, it might result in much faster */ /* collections than HEURISTIC2, which may involve scanning */ /* segments that directly precede the stack. It is not the */ /* default, since it may not work on older machine/OS */ /* combinations. (Thanks to Raymond X.T. Nijssen for uncovering */ /* this.) */ # define STACKBOTTOM ((ptr_t) 0x7b033000) /* from /etc/conf/h/param.h */ # else /* Gustavo Rodriguez-Rivera suggested changing HEURISTIC2 */ /* to this. Note that the GC must be initialized before the */ /* first putenv call. */ extern char ** environ; # define STACKBOTTOM ((ptr_t)environ) # endif # define DYNAMIC_LOADING # include # define GETPAGESIZE() sysconf(_SC_PAGE_SIZE) # ifndef __GNUC__ # define PREFETCH(x) do { \ register long addr = (long)(x); \ (void) _asm ("LDW", 0, 0, addr, 0); \ } while (0) # endif # endif /* HPUX */ # ifdef LINUX # define OS_TYPE "LINUX" # define LINUX_STACKBOTTOM # define DYNAMIC_LOADING # define SEARCH_FOR_DATA_START extern int _end[]; # define DATAEND (ptr_t)(&_end) # endif /* LINUX */ # ifdef OPENBSD # define OS_TYPE "OPENBSD" # ifndef GC_OPENBSD_THREADS # include # include # define STACKBOTTOM ((ptr_t) USRSTACK) # endif extern int __data_start[]; # define DATASTART ((ptr_t)__data_start) extern char _end[]; # define DATAEND ((ptr_t)(&_end)) # define DYNAMIC_LOADING # endif # endif /* HP_PA */ # ifdef ALPHA # define MACH_TYPE "ALPHA" # define ALIGNMENT 8 # define CPP_WORDSZ 64 # ifdef NETBSD # define OS_TYPE "NETBSD" # define HEURISTIC2 extern ptr_t GC_data_start; # define DATASTART GC_data_start # define ELFCLASS32 32 # define ELFCLASS64 64 # define ELF_CLASS ELFCLASS64 # define DYNAMIC_LOADING # endif # ifdef OPENBSD # define OS_TYPE "OPENBSD" # define ELF_CLASS ELFCLASS64 # ifndef GC_OPENBSD_THREADS # include # include # define STACKBOTTOM ((ptr_t) USRSTACK) # endif extern int __data_start[]; # define DATASTART ((ptr_t)__data_start) extern char _end[]; # define DATAEND ((ptr_t)(&_end)) # define DYNAMIC_LOADING # endif # ifdef FREEBSD # define OS_TYPE "FREEBSD" /* MPROTECT_VDB is not yet supported at all on FreeBSD/alpha. */ # define SIG_SUSPEND SIGUSR1 # define SIG_THR_RESTART SIGUSR2 /* SIGTSTP and SIGCONT could be used alternatively. */ # define FREEBSD_STACKBOTTOM # ifdef __ELF__ # define DYNAMIC_LOADING # endif /* Handle unmapped hole alpha*-*-freebsd[45]* puts between etext and edata. */ extern char etext[]; extern char edata[]; extern char end[]; # define NEED_FIND_LIMIT # define DATASTART ((ptr_t)(&etext)) ptr_t GC_find_limit(ptr_t, GC_bool); # define DATAEND (GC_find_limit (DATASTART, TRUE)) # define DATAEND_IS_FUNC # define DATASTART2 ((ptr_t)(&edata)) # define DATAEND2 ((ptr_t)(&end)) # endif # ifdef OSF1 # define OS_TYPE "OSF1" # define DATASTART ((ptr_t) 0x140000000) extern int _end[]; # define DATAEND ((ptr_t) &_end) extern char ** environ; /* round up from the value of environ to the nearest page boundary */ /* Probably breaks if putenv is called before collector */ /* initialization. */ # define STACKBOTTOM ((ptr_t)(((word)(environ) | (getpagesize()-1))+1)) /* # define HEURISTIC2 */ /* Normally HEURISTIC2 is too conservative, since */ /* the text segment immediately follows the stack. */ /* Hence we give an upper pound. */ /* This is currently unused, since we disabled HEURISTIC2 */ extern int __start[]; # define HEURISTIC2_LIMIT ((ptr_t)((word)(__start) & ~(getpagesize()-1))) # ifndef GC_OSF1_THREADS /* Unresolved signal issues with threads. */ # define MPROTECT_VDB # endif # define DYNAMIC_LOADING # endif # ifdef LINUX # define OS_TYPE "LINUX" # define LINUX_STACKBOTTOM # ifdef __ELF__ # define SEARCH_FOR_DATA_START # define DYNAMIC_LOADING # else # define DATASTART ((ptr_t) 0x140000000) # endif extern int _end[]; # define DATAEND (ptr_t)(_end) # define MPROTECT_VDB /* Has only been superficially tested. May not */ /* work on all versions. */ # endif # endif # ifdef IA64 # define MACH_TYPE "IA64" # ifdef HPUX # ifdef _ILP32 # define CPP_WORDSZ 32 /* Requires 8 byte alignment for malloc */ # define ALIGNMENT 4 # else # ifndef _LP64 # error --> unknown ABI # endif # define CPP_WORDSZ 64 /* Requires 16 byte alignment for malloc */ # define ALIGNMENT 8 # endif # define OS_TYPE "HPUX" extern int __data_start[]; # define DATASTART ((ptr_t)(__data_start)) /* Gustavo Rodriguez-Rivera suggested changing HEURISTIC2 */ /* to this. Note that the GC must be initialized before the */ /* first putenv call. */ extern char ** environ; # define STACKBOTTOM ((ptr_t)environ) # define HPUX_STACKBOTTOM # define DYNAMIC_LOADING # include # define GETPAGESIZE() sysconf(_SC_PAGE_SIZE) /* The following was empirically determined, and is probably */ /* not very robust. */ /* Note that the backing store base seems to be at a nice */ /* address minus one page. */ # define BACKING_STORE_DISPLACEMENT 0x1000000 # define BACKING_STORE_ALIGNMENT 0x1000 extern ptr_t GC_register_stackbottom; # define BACKING_STORE_BASE GC_register_stackbottom /* Known to be wrong for recent HP/UX versions!!! */ # endif # ifdef LINUX # define CPP_WORDSZ 64 # define ALIGNMENT 8 # define OS_TYPE "LINUX" /* The following works on NUE and older kernels: */ /* # define STACKBOTTOM ((ptr_t) 0xa000000000000000l) */ /* This does not work on NUE: */ # define LINUX_STACKBOTTOM /* We also need the base address of the register stack */ /* backing store. */ extern ptr_t GC_register_stackbottom; # define BACKING_STORE_BASE GC_register_stackbottom # define SEARCH_FOR_DATA_START # ifdef __GNUC__ # define DYNAMIC_LOADING # else /* In the Intel compiler environment, we seem to end up with */ /* statically linked executables and an undefined reference */ /* to _DYNAMIC */ # endif # define MPROTECT_VDB /* Requires Linux 2.3.47 or later. */ extern int _end[]; # define DATAEND (ptr_t)(_end) # ifdef __GNUC__ # ifndef __INTEL_COMPILER # define PREFETCH(x) \ __asm__ (" lfetch [%0]": : "r"(x)) # define PREFETCH_FOR_WRITE(x) \ __asm__ (" lfetch.excl [%0]": : "r"(x)) # define CLEAR_DOUBLE(x) \ __asm__ (" stf.spill [%0]=f0": : "r"((void *)(x))) # else # include # define PREFETCH(x) __lfetch(__lfhint_none, (x)) # define PREFETCH_FOR_WRITE(x) __lfetch(__lfhint_nta, (x)) # define CLEAR_DOUBLE(x) __stf_spill((void *)(x), 0) # endif /* __INTEL_COMPILER */ # endif # endif # ifdef CYGWIN32 # define OS_TYPE "CYGWIN32" # define DATASTART ((ptr_t)GC_DATASTART) /* From gc.h */ # define DATAEND ((ptr_t)GC_DATAEND) # undef STACK_GRAN # define STACK_GRAN 0x10000 # ifdef USE_MMAP # define NEED_FIND_LIMIT # define USE_MMAP_ANON # endif # endif # ifdef MSWIN32 /* FIXME: This is a very partial guess. There is no port, yet. */ # define OS_TYPE "MSWIN32" /* STACKBOTTOM and DATASTART are handled specially in */ /* os_dep.c. */ # define DATAEND /* not needed */ # if defined(_WIN64) # define CPP_WORDSZ 64 # else # define CPP_WORDSZ 32 /* Is this possible? */ # endif # define ALIGNMENT 8 # endif # endif # ifdef M88K # define MACH_TYPE "M88K" # define ALIGNMENT 4 extern int etext[]; # ifdef CX_UX # define OS_TYPE "CX_UX" # define DATASTART ((((word)etext + 0x3fffff) & ~0x3fffff) + 0x10000) # endif # ifdef DGUX # define OS_TYPE "DGUX" ptr_t GC_SysVGetDataStart(size_t, ptr_t); # define DATASTART GC_SysVGetDataStart(0x10000, (ptr_t)etext) # define DATASTART_IS_FUNC # endif # define STACKBOTTOM ((char*)0xf0000000) /* determined empirically */ # endif # ifdef S370 /* If this still works, and if anyone cares, this should probably */ /* be moved to the S390 category. */ # define MACH_TYPE "S370" # define ALIGNMENT 4 /* Required by hardware */ # ifdef UTS4 # define OS_TYPE "UTS4" extern int etext[]; extern int _etext[]; extern int _end[]; ptr_t GC_SysVGetDataStart(size_t, ptr_t); # define DATASTART GC_SysVGetDataStart(0x10000, (ptr_t)_etext) # define DATASTART_IS_FUNC # define DATAEND (ptr_t)(_end) # define HEURISTIC2 # endif # endif # ifdef S390 # define MACH_TYPE "S390" # ifndef __s390x__ # define ALIGNMENT 4 # define CPP_WORDSZ 32 # else # define ALIGNMENT 8 # define CPP_WORDSZ 64 # ifndef HBLKSIZE # define HBLKSIZE 4096 # endif # endif # ifdef LINUX # define OS_TYPE "LINUX" # define LINUX_STACKBOTTOM # define DYNAMIC_LOADING extern int __data_start[] __attribute__((__weak__)); # define DATASTART ((ptr_t)(__data_start)) extern int _end[] __attribute__((__weak__)); # define DATAEND (ptr_t)(_end) # define CACHE_LINE_SIZE 256 # define GETPAGESIZE() 4096 # endif # endif # ifdef AARCH64 # define MACH_TYPE "AARCH64" # ifdef __ILP32__ # define CPP_WORDSZ 32 # define ALIGNMENT 4 # else # define CPP_WORDSZ 64 # define ALIGNMENT 8 # endif # ifndef HBLKSIZE # define HBLKSIZE 4096 # endif # ifdef LINUX # define OS_TYPE "LINUX" # define LINUX_STACKBOTTOM # define DYNAMIC_LOADING extern int __data_start[]; # define DATASTART ((ptr_t)__data_start) extern char _end[]; # define DATAEND ((ptr_t)(&_end)) # endif # ifdef DARWIN /* iOS */ # define OS_TYPE "DARWIN" # ifndef GC_DONT_REGISTER_MAIN_STATIC_DATA # define DYNAMIC_LOADING # endif # define DATASTART ((ptr_t) get_etext()) # define DATAEND ((ptr_t) get_end()) # define STACKBOTTOM ((ptr_t) 0x16fdfffff) # ifndef USE_MMAP # define USE_MMAP # endif # define USE_MMAP_ANON # define MPROTECT_VDB # include # define GETPAGESIZE() getpagesize() /* FIXME: There seems to be some issues with trylock hanging on */ /* darwin. This should be looked into some more. */ # define NO_PTHREAD_TRYLOCK # ifndef NO_DYLD_BIND_FULLY_IMAGE # define NO_DYLD_BIND_FULLY_IMAGE # endif # endif # ifdef NOSYS /* __data_start is usually defined in the target linker script. */ extern int __data_start[]; # define DATASTART ((ptr_t)__data_start) extern void *__stack_base__; # define STACKBOTTOM ((ptr_t)__stack_base__) # endif # endif # ifdef ARM32 # define CPP_WORDSZ 32 # define MACH_TYPE "ARM32" # define ALIGNMENT 4 # ifdef NETBSD # define OS_TYPE "NETBSD" # define HEURISTIC2 # ifdef __ELF__ extern ptr_t GC_data_start; # define DATASTART GC_data_start # define DYNAMIC_LOADING # else extern char etext[]; # define DATASTART ((ptr_t)(etext)) # endif # endif # ifdef LINUX # define OS_TYPE "LINUX" # define LINUX_STACKBOTTOM # undef STACK_GRAN # define STACK_GRAN 0x10000000 # ifdef __ELF__ # define DYNAMIC_LOADING # include # if defined(__GLIBC__) && __GLIBC__ >= 2 \ || defined(PLATFORM_ANDROID) # define SEARCH_FOR_DATA_START # else extern char **__environ; # define DATASTART ((ptr_t)(&__environ)) /* hideous kludge: __environ is the first */ /* word in crt0.o, and delimits the start */ /* of the data segment, no matter which */ /* ld options were passed through. */ /* We could use _etext instead, but that */ /* would include .rodata, which may */ /* contain large read-only data tables */ /* that we'd rather not scan. */ # endif extern int _end[]; # define DATAEND (ptr_t)(_end) # else extern int etext[]; # define DATASTART ((ptr_t)((((word) (etext)) + 0xfff) & ~0xfff)) # endif # endif # ifdef MSWINCE # define OS_TYPE "MSWINCE" # define DATAEND /* not needed */ # endif # ifdef FREEBSD /* FreeBSD/arm */ # define ALIGNMENT 4 # define OS_TYPE "FREEBSD" # ifdef __ELF__ # define DYNAMIC_LOADING # endif # define HEURISTIC2 extern char etext[]; # define SEARCH_FOR_DATA_START # endif # ifdef DARWIN /* iPhone */ # define OS_TYPE "DARWIN" # ifndef GC_DONT_REGISTER_MAIN_STATIC_DATA # define DYNAMIC_LOADING # endif # define DATASTART ((ptr_t) get_etext()) # define DATAEND ((ptr_t) get_end()) # define STACKBOTTOM ((ptr_t) 0x30000000) # ifndef USE_MMAP # define USE_MMAP # endif # define USE_MMAP_ANON # define MPROTECT_VDB # include # define GETPAGESIZE() getpagesize() /* FIXME: There seems to be some issues with trylock hanging on */ /* darwin. This should be looked into some more. */ # define NO_PTHREAD_TRYLOCK # ifndef NO_DYLD_BIND_FULLY_IMAGE # define NO_DYLD_BIND_FULLY_IMAGE # endif # endif # ifdef OPENBSD # define ALIGNMENT 4 # define OS_TYPE "OPENBSD" # ifndef GC_OPENBSD_THREADS # include # include # define STACKBOTTOM ((ptr_t) USRSTACK) # endif extern int __data_start[]; # define DATASTART ((ptr_t)__data_start) extern char _end[]; # define DATAEND ((ptr_t)(&_end)) # define DYNAMIC_LOADING # endif # ifdef NOSYS /* __data_start is usually defined in the target linker script. */ extern int __data_start[]; # define DATASTART (ptr_t)(__data_start) /* __stack_base__ is set in newlib/libc/sys/arm/crt0.S */ extern void *__stack_base__; # define STACKBOTTOM ((ptr_t) (__stack_base__)) # endif #endif # ifdef CRIS # define MACH_TYPE "CRIS" # define CPP_WORDSZ 32 # define ALIGNMENT 1 # define OS_TYPE "LINUX" # define DYNAMIC_LOADING # define LINUX_STACKBOTTOM # define SEARCH_FOR_DATA_START extern int _end[]; # define DATAEND (ptr_t)(_end) # endif # if defined(SH) && !defined(SH4) # define MACH_TYPE "SH" # define ALIGNMENT 4 # ifdef MSWINCE # define OS_TYPE "MSWINCE" # define DATAEND /* not needed */ # endif # ifdef LINUX # define OS_TYPE "LINUX" # define LINUX_STACKBOTTOM # define DYNAMIC_LOADING # define SEARCH_FOR_DATA_START extern int _end[]; # define DATAEND (ptr_t)(_end) # endif # ifdef NETBSD # define OS_TYPE "NETBSD" # define HEURISTIC2 extern ptr_t GC_data_start; # define DATASTART GC_data_start # define DYNAMIC_LOADING # endif # ifdef OPENBSD # define OS_TYPE "OPENBSD" # ifndef GC_OPENBSD_THREADS # include # include # define STACKBOTTOM ((ptr_t) USRSTACK) # endif extern int __data_start[]; # define DATASTART ((ptr_t)__data_start) extern char _end[]; # define DATAEND ((ptr_t)(&_end)) # define DYNAMIC_LOADING # endif # endif # ifdef SH4 # define MACH_TYPE "SH4" # define OS_TYPE "MSWINCE" # define ALIGNMENT 4 # define DATAEND /* not needed */ # endif # ifdef AVR32 # define MACH_TYPE "AVR32" # define CPP_WORDSZ 32 # define ALIGNMENT 4 # define OS_TYPE "LINUX" # define DYNAMIC_LOADING # define LINUX_STACKBOTTOM # define SEARCH_FOR_DATA_START extern int _end[]; # define DATAEND (_end) # endif # ifdef M32R # define CPP_WORDSZ 32 # define MACH_TYPE "M32R" # define ALIGNMENT 4 # ifdef LINUX # define OS_TYPE "LINUX" # define LINUX_STACKBOTTOM # undef STACK_GRAN # define STACK_GRAN 0x10000000 # define DYNAMIC_LOADING # define SEARCH_FOR_DATA_START extern int _end[]; # define DATAEND (ptr_t)(_end) # endif # endif # ifdef X86_64 # define MACH_TYPE "X86_64" # ifdef __ILP32__ # define ALIGNMENT 4 # define CPP_WORDSZ 32 # else # define ALIGNMENT 8 # define CPP_WORDSZ 64 # endif # ifndef HBLKSIZE # define HBLKSIZE 4096 # endif # define CACHE_LINE_SIZE 64 # ifdef OPENBSD # define OS_TYPE "OPENBSD" # define ELF_CLASS ELFCLASS64 # ifndef GC_OPENBSD_THREADS # include # include # define STACKBOTTOM ((ptr_t) USRSTACK) # endif extern int __data_start[]; # define DATASTART ((ptr_t)__data_start) extern char _end[]; # define DATAEND ((ptr_t)(&_end)) # define DYNAMIC_LOADING # endif # ifdef LINUX # define OS_TYPE "LINUX" # define LINUX_STACKBOTTOM # if !defined(GC_LINUX_THREADS) || !defined(REDIRECT_MALLOC) # define MPROTECT_VDB # else /* We seem to get random errors in incremental mode, */ /* possibly because Linux threads is itself a malloc client */ /* and can't deal with the signals. */ # endif # ifdef __ELF__ # define DYNAMIC_LOADING # ifdef UNDEFINED /* includes ro data */ extern int _etext[]; # define DATASTART ((ptr_t)((((word) (_etext)) + 0xfff) & ~0xfff)) # endif # include # define SEARCH_FOR_DATA_START extern int _end[]; # define DATAEND (ptr_t)(_end) # else extern int etext[]; # define DATASTART ((ptr_t)((((word) (etext)) + 0xfff) & ~0xfff)) # endif # if defined(__GLIBC__) && !defined(__UCLIBC__) /* At present, there's a bug in GLibc getcontext() on */ /* Linux/x64 (it clears FPU exception mask). We define this */ /* macro to workaround it. */ /* FIXME: This seems to be fixed in GLibc v2.14. */ # define GETCONTEXT_FPU_EXCMASK_BUG # endif # if defined(__GLIBC__) /* Workaround lock elision implementation for some glibc. */ # define GLIBC_2_19_TSX_BUG # include /* for gnu_get_libc_version() */ # endif # endif # ifdef DARWIN # define OS_TYPE "DARWIN" # define DARWIN_DONT_PARSE_STACK # define DYNAMIC_LOADING /* XXX: see get_end(3), get_etext() and get_end() should not be used. */ /* These aren't used when dyld support is enabled (it is by default) */ # define DATASTART ((ptr_t) get_etext()) # define DATAEND ((ptr_t) get_end()) # define STACKBOTTOM ((ptr_t) 0x7fff5fc00000) # ifndef USE_MMAP # define USE_MMAP # endif # define USE_MMAP_ANON # define MPROTECT_VDB # include # define GETPAGESIZE() getpagesize() /* There seems to be some issues with trylock hanging on darwin. */ /* This should be looked into some more. */ # define NO_PTHREAD_TRYLOCK # endif # ifdef FREEBSD # define OS_TYPE "FREEBSD" # ifndef GC_FREEBSD_THREADS # define MPROTECT_VDB # endif # ifdef __GLIBC__ # define SIG_SUSPEND (32+6) # define SIG_THR_RESTART (32+5) extern int _end[]; # define DATAEND (ptr_t)(_end) # else # define SIG_SUSPEND SIGUSR1 # define SIG_THR_RESTART SIGUSR2 /* SIGTSTP and SIGCONT could be used alternatively. */ # endif # define FREEBSD_STACKBOTTOM # ifdef __ELF__ # define DYNAMIC_LOADING # endif extern char etext[]; ptr_t GC_FreeBSDGetDataStart(size_t, ptr_t); # define DATASTART GC_FreeBSDGetDataStart(0x1000, (ptr_t)etext) # define DATASTART_IS_FUNC # endif # ifdef NETBSD # define OS_TYPE "NETBSD" # define HEURISTIC2 # ifdef __ELF__ extern ptr_t GC_data_start; # define DATASTART GC_data_start # define DYNAMIC_LOADING # else # define SEARCH_FOR_DATA_START # endif # endif # ifdef SOLARIS # define OS_TYPE "SOLARIS" # define ELF_CLASS ELFCLASS64 extern int _etext[], _end[]; ptr_t GC_SysVGetDataStart(size_t, ptr_t); # define DATASTART GC_SysVGetDataStart(0x1000, (ptr_t)_etext) # define DATASTART_IS_FUNC # define DATAEND (ptr_t)(_end) /* # define STACKBOTTOM ((ptr_t)(_start)) worked through 2.7, */ /* but reportedly breaks under 2.8. It appears that the stack */ /* base is a property of the executable, so this should not break */ /* old executables. */ /* HEURISTIC2 probably works, but this appears to be preferable. */ /* Apparently USRSTACK is defined to be USERLIMIT, but in some */ /* installations that's undefined. We work around this with a */ /* gross hack: */ # include # ifdef USERLIMIT /* This should work everywhere, but doesn't. */ # define STACKBOTTOM ((ptr_t) USRSTACK) # else # define HEURISTIC2 # endif /* At least in Solaris 2.5, PROC_VDB gives wrong values for dirty bits. */ /* It appears to be fixed in 2.8 and 2.9. */ # ifdef SOLARIS25_PROC_VDB_BUG_FIXED # define PROC_VDB # endif # ifndef GC_THREADS # define MPROTECT_VDB # endif # define DYNAMIC_LOADING # if !defined(USE_MMAP) && defined(REDIRECT_MALLOC) # define USE_MMAP /* Otherwise we now use calloc. Mmap may result in the */ /* heap interleaved with thread stacks, which can result in */ /* excessive blacklisting. Sbrk is unusable since it */ /* doesn't interact correctly with the system malloc. */ # endif # ifdef USE_MMAP # define HEAP_START (ptr_t)0x40000000 # else # define HEAP_START DATAEND # endif # endif # ifdef MSWIN32 # define OS_TYPE "MSWIN32" /* STACKBOTTOM and DATASTART are handled specially in */ /* os_dep.c. */ # if !defined(__GNUC__) || defined(__INTEL_COMPILER) /* GCC does not currently support SetUnhandledExceptionFilter */ /* (does not generate SEH unwinding information) on x64. */ # define MPROTECT_VDB # endif # define GWW_VDB # define DATAEND /* not needed */ # endif # endif /* X86_64 */ # ifdef HEXAGON # define CPP_WORDSZ 32 # define MACH_TYPE "HEXAGON" # define ALIGNMENT 4 # ifdef LINUX # define OS_TYPE "LINUX" # define LINUX_STACKBOTTOM # define MPROTECT_VDB # ifdef __ELF__ # define DYNAMIC_LOADING # include # if defined(__GLIBC__) && __GLIBC__ >= 2 # define SEARCH_FOR_DATA_START # else # error --> unknown Hexagon libc configuration # endif extern int _end[]; # define DATAEND (ptr_t)(_end) # else # error --> bad Hexagon Linux configuration # endif # else # error --> unknown Hexagon OS configuration # endif # endif #if defined(__GLIBC__) && !defined(DONT_USE_LIBC_PRIVATES) /* Use glibc's stack-end marker. */ # define USE_LIBC_PRIVATES #endif #if defined(LINUX_STACKBOTTOM) && defined(NO_PROC_STAT) \ && !defined(USE_LIBC_PRIVATES) /* This combination will fail, since we have no way to get */ /* the stack base. Use HEURISTIC2 instead. */ # undef LINUX_STACKBOTTOM # define HEURISTIC2 /* This may still fail on some architectures like IA64. */ /* We tried ... */ #endif #if defined(LINUX) && defined(USE_MMAP) /* The kernel may do a somewhat better job merging mappings etc. */ /* with anonymous mappings. */ # define USE_MMAP_ANON #endif #if defined(GC_LINUX_THREADS) && defined(REDIRECT_MALLOC) \ && !defined(USE_PROC_FOR_LIBRARIES) /* Nptl allocates thread stacks with mmap, which is fine. But it */ /* keeps a cache of thread stacks. Thread stacks contain the */ /* thread control blocks. These in turn contain a pointer to */ /* (sizeof (void *) from the beginning of) the dtv for thread-local */ /* storage, which is calloc allocated. If we don't scan the cached */ /* thread stacks, we appear to lose the dtv. This tends to */ /* result in something that looks like a bogus dtv count, which */ /* tends to result in a memset call on a block that is way too */ /* large. Sometimes we're lucky and the process just dies ... */ /* There seems to be a similar issue with some other memory */ /* allocated by the dynamic loader. */ /* This should be avoidable by either: */ /* - Defining USE_PROC_FOR_LIBRARIES here. */ /* That performs very poorly, precisely because we end up */ /* scanning cached stacks. */ /* - Have calloc look at its callers. */ /* In spite of the fact that it is gross and disgusting. */ /* In fact neither seems to suffice, probably in part because */ /* even with USE_PROC_FOR_LIBRARIES, we don't scan parts of stack */ /* segments that appear to be out of bounds. Thus we actually */ /* do both, which seems to yield the best results. */ # define USE_PROC_FOR_LIBRARIES #endif #ifndef STACK_GROWS_UP # define STACK_GROWS_DOWN #endif #ifndef CPP_WORDSZ # define CPP_WORDSZ 32 #endif #ifndef OS_TYPE # define OS_TYPE "" #endif #ifndef DATAEND extern int end[]; # define DATAEND (ptr_t)(end) #endif #if defined(PLATFORM_ANDROID) && !defined(THREADS) \ && !defined(USE_GET_STACKBASE_FOR_MAIN) /* Always use pthread_attr_getstack on Android ("-lpthread" option is */ /* not needed to be specified manually) since GC_linux_main_stack_base */ /* causes app crash if invoked inside Dalvik VM. */ # define USE_GET_STACKBASE_FOR_MAIN #endif #if (defined(SVR4) || defined(PLATFORM_ANDROID)) && !defined(GETPAGESIZE) # include # define GETPAGESIZE() sysconf(_SC_PAGESIZE) #endif #ifndef GETPAGESIZE # if defined(SOLARIS) || defined(IRIX5) || defined(LINUX) \ || defined(NETBSD) || defined(FREEBSD) || defined(HPUX) # include # endif # define GETPAGESIZE() getpagesize() #endif #if defined(SOLARIS) || defined(DRSNX) || defined(UTS4) /* OS has SVR4 generic features. */ /* Probably others also qualify. */ # define SVR4 #endif #if defined(SOLARIS) || defined(DRSNX) /* OS has SOLARIS style semi-undocumented interface */ /* to dynamic loader. */ # define SOLARISDL /* OS has SOLARIS style signal handlers. */ # define SUNOS5SIGS #endif #if defined(HPUX) # define SUNOS5SIGS #endif #if defined(FREEBSD) && (defined(__DragonFly__) || __FreeBSD__ >= 4 \ || (__FreeBSD_kernel__ >= 4)) # define SUNOS5SIGS #endif #if !defined(GC_EXPLICIT_SIGNALS_UNBLOCK) && defined(SUNOS5SIGS) \ && !defined(GC_NO_PTHREAD_SIGMASK) # define GC_EXPLICIT_SIGNALS_UNBLOCK #endif #ifdef GC_NETBSD_THREADS # define SIGRTMIN 33 # define SIGRTMAX 63 #endif #ifdef GC_OPENBSD_THREADS # include /* Prior to 5.2 release, OpenBSD had user threads and required */ /* special handling. */ # if OpenBSD < 201211 # define GC_OPENBSD_UTHREADS 1 # endif #endif /* GC_OPENBSD_THREADS */ #if defined(SVR4) || defined(LINUX) || defined(IRIX5) || defined(HPUX) \ || defined(OPENBSD) || defined(NETBSD) || defined(FREEBSD) \ || defined(DGUX) || defined(BSD) || defined(HURD) \ || defined(AIX) || defined(DARWIN) || defined(OSF1) # define UNIX_LIKE /* Basic Unix-like system calls work. */ #endif #if CPP_WORDSZ != 32 && CPP_WORDSZ != 64 # error --> bad word size #endif #ifndef ALIGNMENT # error --> undefined ALIGNMENT #endif #ifdef PCR # undef DYNAMIC_LOADING # undef STACKBOTTOM # undef HEURISTIC1 # undef HEURISTIC2 # undef PROC_VDB # undef MPROTECT_VDB # define PCR_VDB #endif #if !defined(STACKBOTTOM) && (defined(ECOS) || defined(NOSYS)) # error --> undefined STACKBOTTOM #endif #ifdef IGNORE_DYNAMIC_LOADING # undef DYNAMIC_LOADING #endif #if defined(SMALL_CONFIG) && !defined(GC_DISABLE_INCREMENTAL) /* Presumably not worth the space it takes. */ # define GC_DISABLE_INCREMENTAL #endif #if (defined(MSWIN32) || defined(MSWINCE)) && !defined(USE_WINALLOC) /* USE_WINALLOC is only an option for Cygwin. */ # define USE_WINALLOC #endif #ifdef USE_WINALLOC # undef USE_MMAP #endif #if defined(LINUX) || defined(FREEBSD) || defined(SOLARIS) || defined(IRIX5) \ || ((defined(USE_MMAP) || defined(USE_MUNMAP)) && !defined(USE_WINALLOC)) # define MMAP_SUPPORTED #endif #if defined(GC_DISABLE_INCREMENTAL) || defined(MANUAL_VDB) # undef GWW_VDB # undef MPROTECT_VDB # undef PCR_VDB # undef PROC_VDB #endif #ifdef GC_DISABLE_INCREMENTAL # undef CHECKSUMS #endif #ifdef USE_GLOBAL_ALLOC /* Cannot pass MEM_WRITE_WATCH to GlobalAlloc(). */ # undef GWW_VDB #endif #ifdef USE_MUNMAP /* FIXME: Remove this undef if possible. */ # undef MPROTECT_VDB /* Can't deal with address space holes. */ #endif /* PARALLEL_MARK does not cause undef MPROTECT_VDB any longer. */ #if defined(MPROTECT_VDB) && defined(GC_PREFER_MPROTECT_VDB) /* Choose MPROTECT_VDB manually (if multiple strategies available). */ # undef PCR_VDB # undef PROC_VDB /* #undef GWW_VDB - handled in os_dep.c */ #endif #ifdef PROC_VDB /* Multi-VDB mode is not implemented. */ # undef MPROTECT_VDB #endif #if !defined(PCR_VDB) && !defined(PROC_VDB) && !defined(MPROTECT_VDB) \ && !defined(GWW_VDB) && !defined(MANUAL_VDB) \ && !defined(GC_DISABLE_INCREMENTAL) # define DEFAULT_VDB #endif #if ((defined(UNIX_LIKE) && (defined(DARWIN) || defined(HURD) \ || defined(OPENBSD) || defined(ARM32) \ || defined(MIPS) || defined(AVR32) \ || defined(OR1K))) \ || (defined(LINUX) && (defined(SPARC) || defined(M68K))) \ || ((defined(RTEMS) || defined(PLATFORM_ANDROID)) && defined(I386))) \ && !defined(NO_GETCONTEXT) # define NO_GETCONTEXT #endif #ifndef PREFETCH # if defined(__GNUC__) && __GNUC__ >= 3 && !defined(NO_PREFETCH) # define PREFETCH(x) __builtin_prefetch((x), 0, 0) # else # define PREFETCH(x) (void)0 # endif #endif #ifndef PREFETCH_FOR_WRITE # if defined(__GNUC__) && __GNUC__ >= 3 && !defined(NO_PREFETCH_FOR_WRITE) # define PREFETCH_FOR_WRITE(x) __builtin_prefetch((x), 1) # else # define PREFETCH_FOR_WRITE(x) (void)0 # endif #endif #ifndef CACHE_LINE_SIZE # define CACHE_LINE_SIZE 32 /* Wild guess */ #endif #ifndef STATIC # ifndef NO_DEBUGGING # define STATIC /* ignore to aid profiling and possibly debugging */ # else # define STATIC static # endif #endif #if defined(LINUX) && (defined(USE_PROC_FOR_LIBRARIES) || defined(IA64) \ || !defined(SMALL_CONFIG)) # define NEED_PROC_MAPS #endif #if defined(LINUX) || defined(HURD) || defined(__GLIBC__) # define REGISTER_LIBRARIES_EARLY /* We sometimes use dl_iterate_phdr, which may acquire an internal */ /* lock. This isn't safe after the world has stopped. So we must */ /* call GC_register_dynamic_libraries before stopping the world. */ /* For performance reasons, this may be beneficial on other */ /* platforms as well, though it should be avoided in win32. */ #endif /* LINUX */ #if defined(SEARCH_FOR_DATA_START) extern ptr_t GC_data_start; # define DATASTART GC_data_start #endif #ifndef CLEAR_DOUBLE # define CLEAR_DOUBLE(x) (((word*)(x))[0] = 0, ((word*)(x))[1] = 0) #endif #if defined(GC_LINUX_THREADS) && defined(REDIRECT_MALLOC) \ && !defined(INCLUDE_LINUX_THREAD_DESCR) /* Will not work, since libc and the dynamic loader use thread */ /* locals, sometimes as the only reference. */ # define INCLUDE_LINUX_THREAD_DESCR #endif #if defined(GC_IRIX_THREADS) && !defined(IRIX5) # error --> inconsistent configuration #endif #if defined(GC_LINUX_THREADS) && !defined(LINUX) && !defined(NACL) # error --> inconsistent configuration #endif #if defined(GC_NETBSD_THREADS) && !defined(NETBSD) # error --> inconsistent configuration #endif #if defined(GC_FREEBSD_THREADS) && !defined(FREEBSD) # error --> inconsistent configuration #endif #if defined(GC_SOLARIS_THREADS) && !defined(SOLARIS) # error --> inconsistent configuration #endif #if defined(GC_HPUX_THREADS) && !defined(HPUX) # error --> inconsistent configuration #endif #if defined(GC_AIX_THREADS) && !defined(_AIX) # error --> inconsistent configuration #endif #if defined(GC_GNU_THREADS) && !defined(HURD) # error --> inconsistent configuration #endif #if defined(GC_WIN32_THREADS) && !defined(MSWIN32) && !defined(CYGWIN32) \ && !defined(MSWINCE) # error --> inconsistent configuration #endif #if defined(PCR) || defined(GC_WIN32_THREADS) || defined(GC_PTHREADS) \ || defined(SN_TARGET_PS3) # define THREADS #endif #if defined(PARALLEL_MARK) && !defined(THREADS) # error "invalid config - PARALLEL_MARK requires GC_THREADS" #endif #if defined(UNIX_LIKE) && defined(THREADS) && !defined(NO_CANCEL_SAFE) \ && !defined(PLATFORM_ANDROID) /* Make the code cancellation-safe. This basically means that we */ /* ensure that cancellation requests are ignored while we are in */ /* the collector. This applies only to Posix deferred cancellation; */ /* we don't handle Posix asynchronous cancellation. */ /* Note that this only works if pthread_setcancelstate is */ /* async-signal-safe, at least in the absence of asynchronous */ /* cancellation. This appears to be true for the glibc version, */ /* though it is not documented. Without that assumption, there */ /* seems to be no way to safely wait in a signal handler, which */ /* we need to do for thread suspension. */ /* Also note that little other code appears to be cancellation-safe. */ /* Hence it may make sense to turn this off for performance. */ # define CANCEL_SAFE #endif #ifdef CANCEL_SAFE # define IF_CANCEL(x) x #else # define IF_CANCEL(x) /* empty */ #endif #if !defined(CAN_HANDLE_FORK) && !defined(NO_HANDLE_FORK) \ && !defined(HAVE_NO_FORK) \ && ((defined(GC_PTHREADS) && !defined(NACL) \ && !defined(GC_WIN32_PTHREADS) && !defined(USE_WINALLOC)) \ || (defined(DARWIN) && defined(MPROTECT_VDB)) || defined(HANDLE_FORK)) /* Attempts (where supported and requested) to make GC_malloc work in */ /* a child process fork'ed from a multi-threaded parent. */ # define CAN_HANDLE_FORK #endif #if defined(CAN_HANDLE_FORK) && !defined(CAN_CALL_ATFORK) \ && !defined(HURD) && !defined(PLATFORM_ANDROID) /* Have working pthread_atfork(). */ # define CAN_CALL_ATFORK #endif #if !defined(CAN_HANDLE_FORK) && !defined(HAVE_NO_FORK) \ && (defined(MSWIN32) || defined(MSWINCE) || defined(DOS4GW) \ || defined(OS2) || defined(SYMBIAN) /* and probably others ... */) # define HAVE_NO_FORK #endif #if !defined(USE_MARK_BITS) && !defined(USE_MARK_BYTES) \ && defined(PARALLEL_MARK) /* Minimize compare-and-swap usage. */ # define USE_MARK_BYTES #endif #if defined(MSWINCE) && !defined(__CEGCC__) && !defined(NO_GETENV) # define NO_GETENV #endif #if (defined(NO_GETENV) || defined(MSWINCE)) && !defined(NO_GETENV_WIN32) # define NO_GETENV_WIN32 #endif #ifndef STRTOULL # if defined(_WIN64) && !defined(__GNUC__) # define STRTOULL _strtoui64 # elif defined(_LLP64) || defined(__LLP64__) || defined(_WIN64) # define STRTOULL strtoull # else /* strtoul() fits since sizeof(long) >= sizeof(word). */ # define STRTOULL strtoul # endif #endif /* !STRTOULL */ #ifndef GC_WORD_C # if defined(_WIN64) && !defined(__GNUC__) # define GC_WORD_C(val) val##ui64 # elif defined(_LLP64) || defined(__LLP64__) || defined(_WIN64) # define GC_WORD_C(val) val##ULL # else # define GC_WORD_C(val) ((word)val##UL) # endif #endif /* !GC_WORD_C */ #if defined(SPARC) # define ASM_CLEAR_CODE /* Stack clearing is crucial, and we */ /* include assembly code to do it well. */ #endif /* Can we save call chain in objects for debugging? */ /* SET NFRAMES (# of saved frames) and NARGS (#of args for each */ /* frame) to reasonable values for the platform. */ /* Set SAVE_CALL_CHAIN if we can. SAVE_CALL_COUNT can be specified */ /* at build time, though we feel free to adjust it slightly. */ /* Define NEED_CALLINFO if we either save the call stack or */ /* GC_ADD_CALLER is defined. */ /* GC_CAN_SAVE_CALL_STACKS is set in gc.h. */ #if defined(SPARC) # define CAN_SAVE_CALL_ARGS #endif #if (defined(I386) || defined(X86_64)) \ && (defined(LINUX) || defined(__GLIBC__)) /* SAVE_CALL_CHAIN is supported if the code is compiled to save */ /* frame pointers by default, i.e. no -fomit-frame-pointer flag. */ # define CAN_SAVE_CALL_ARGS #endif #if defined(SAVE_CALL_COUNT) && !defined(GC_ADD_CALLER) \ && defined(GC_CAN_SAVE_CALL_STACKS) # define SAVE_CALL_CHAIN #endif #ifdef SAVE_CALL_CHAIN # if defined(SAVE_CALL_NARGS) && defined(CAN_SAVE_CALL_ARGS) # define NARGS SAVE_CALL_NARGS # else # define NARGS 0 /* Number of arguments to save for each call. */ # endif #endif #ifdef SAVE_CALL_CHAIN # ifndef SAVE_CALL_COUNT # define NFRAMES 6 /* Number of frames to save. Even for */ /* alignment reasons. */ # else # define NFRAMES ((SAVE_CALL_COUNT + 1) & ~1) # endif # define NEED_CALLINFO #endif /* SAVE_CALL_CHAIN */ #ifdef GC_ADD_CALLER # define NFRAMES 1 # define NARGS 0 # define NEED_CALLINFO #endif #if (defined(FREEBSD) || (defined(DARWIN) && !defined(_POSIX_C_SOURCE)) \ || (defined(SOLARIS) && (!defined(_XOPEN_SOURCE) \ || defined(__EXTENSIONS__))) \ || defined(LINUX)) && !defined(HAVE_DLADDR) # define HAVE_DLADDR #endif #if defined(MAKE_BACK_GRAPH) && !defined(DBG_HDRS_ALL) # define DBG_HDRS_ALL #endif #if defined(POINTER_MASK) && !defined(POINTER_SHIFT) # define POINTER_SHIFT 0 #endif #if defined(POINTER_SHIFT) && !defined(POINTER_MASK) # define POINTER_MASK ((GC_word)(-1)) #endif #if !defined(FIXUP_POINTER) && defined(POINTER_MASK) # define FIXUP_POINTER(p) (p = ((p) & POINTER_MASK) << POINTER_SHIFT) #endif #if defined(FIXUP_POINTER) # define NEED_FIXUP_POINTER 1 #else # define NEED_FIXUP_POINTER 0 # define FIXUP_POINTER(p) #endif #if !defined(MARK_BIT_PER_GRANULE) && !defined(MARK_BIT_PER_OBJ) # define MARK_BIT_PER_GRANULE /* Usually faster */ #endif /* Some static sanity tests. */ #if defined(MARK_BIT_PER_GRANULE) && defined(MARK_BIT_PER_OBJ) # error Define only one of MARK_BIT_PER_GRANULE and MARK_BIT_PER_OBJ. #endif #if defined(STACK_GROWS_UP) && defined(STACK_GROWS_DOWN) # error "Only one of STACK_GROWS_UP and STACK_GROWS_DOWN should be defd." #endif #if !defined(STACK_GROWS_UP) && !defined(STACK_GROWS_DOWN) # error "One of STACK_GROWS_UP and STACK_GROWS_DOWN should be defd." #endif #if defined(REDIRECT_MALLOC) && defined(THREADS) && !defined(LINUX) # error "REDIRECT_MALLOC with THREADS works at most on Linux." #endif #ifdef GC_PRIVATE_H /* This relies on some type definitions from gc_priv.h, from */ /* where it's normally included. */ /* */ /* How to get heap memory from the OS: */ /* Note that sbrk()-like allocation is preferred, since it */ /* usually makes it possible to merge consecutively allocated */ /* chunks. It also avoids unintended recursion with */ /* REDIRECT_MALLOC macro defined. */ /* GET_MEM() returns a HLKSIZE aligned chunk. */ /* 0 is taken to mean failure. */ /* In case of MMAP_SUPPORTED, the argument must also be */ /* a multiple of a physical page size. */ /* GET_MEM is currently not assumed to retrieve 0 filled space, */ /* though we should perhaps take advantage of the case in which */ /* does. */ struct hblk; /* See gc_priv.h. */ # if defined(PCR) char * real_malloc(size_t bytes); # define GET_MEM(bytes) HBLKPTR(real_malloc((size_t)(bytes) + GC_page_size) \ + GC_page_size-1) # elif defined(OS2) void * os2_alloc(size_t bytes); # define GET_MEM(bytes) HBLKPTR((ptr_t)os2_alloc((size_t)(bytes) \ + GC_page_size) + GC_page_size-1) # elif defined(NEXT) || defined(DOS4GW) || defined(NONSTOP) \ || (defined(AMIGA) && !defined(GC_AMIGA_FASTALLOC)) \ || (defined(SOLARIS) && !defined(USE_MMAP)) || defined(RTEMS) \ || defined(__CC_ARM) # define GET_MEM(bytes) HBLKPTR((size_t)calloc(1, \ (size_t)(bytes) + GC_page_size) \ + GC_page_size - 1) # elif defined(MSWIN32) || defined(CYGWIN32) ptr_t GC_win32_get_mem(GC_word bytes); # define GET_MEM(bytes) (struct hblk *)GC_win32_get_mem(bytes) # elif defined(MACOS) # if defined(USE_TEMPORARY_MEMORY) Ptr GC_MacTemporaryNewPtr(size_t size, Boolean clearMemory); # define GET_MEM(bytes) HBLKPTR( \ GC_MacTemporaryNewPtr((bytes) + GC_page_size, true) \ + GC_page_size-1) # else # define GET_MEM(bytes) HBLKPTR(NewPtrClear((bytes) + GC_page_size) \ + GC_page_size-1) # endif # elif defined(MSWINCE) ptr_t GC_wince_get_mem(GC_word bytes); # define GET_MEM(bytes) (struct hblk *)GC_wince_get_mem(bytes) # elif defined(AMIGA) && defined(GC_AMIGA_FASTALLOC) void *GC_amiga_get_mem(size_t size); # define GET_MEM(bytes) HBLKPTR((size_t) \ GC_amiga_get_mem((size_t)(bytes) + GC_page_size) \ + GC_page_size-1) # elif defined(SN_TARGET_PS3) void *ps3_get_mem(size_t size); # define GET_MEM(bytes) (struct hblk*)ps3_get_mem(bytes) # else ptr_t GC_unix_get_mem(GC_word bytes); # define GET_MEM(bytes) (struct hblk *)GC_unix_get_mem(bytes) # endif #endif /* GC_PRIVATE_H */ #endif /* GCCONFIG_H */ ecl-16.1.2/src/bdwgc/include/private/msvc_dbg.h000066400000000000000000000055051266352375300212740ustar00rootroot00000000000000/* Copyright (c) 2004-2005 Andrei Polushin Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ #ifndef _MSVC_DBG_H #define _MSVC_DBG_H #include #ifdef __cplusplus extern "C" { #endif #if !MSVC_DBG_DLL #define MSVC_DBG_EXPORT #elif MSVC_DBG_BUILD #define MSVC_DBG_EXPORT __declspec(dllexport) #else #define MSVC_DBG_EXPORT __declspec(dllimport) #endif #ifndef MAX_SYM_NAME #define MAX_SYM_NAME 2000 #endif typedef void* HANDLE; typedef struct _CONTEXT CONTEXT; MSVC_DBG_EXPORT size_t GetStackFrames(size_t skip, void* frames[], size_t maxFrames); MSVC_DBG_EXPORT size_t GetStackFramesFromContext(HANDLE hProcess, HANDLE hThread, CONTEXT* context, size_t skip, void* frames[], size_t maxFrames); MSVC_DBG_EXPORT size_t GetModuleNameFromAddress(void* address, char* moduleName, size_t size); MSVC_DBG_EXPORT size_t GetModuleNameFromStack(size_t skip, char* moduleName, size_t size); MSVC_DBG_EXPORT size_t GetSymbolNameFromAddress(void* address, char* symbolName, size_t size, size_t* offsetBytes); MSVC_DBG_EXPORT size_t GetSymbolNameFromStack(size_t skip, char* symbolName, size_t size, size_t* offsetBytes); MSVC_DBG_EXPORT size_t GetFileLineFromAddress(void* address, char* fileName, size_t size, size_t* lineNumber, size_t* offsetBytes); MSVC_DBG_EXPORT size_t GetFileLineFromStack(size_t skip, char* fileName, size_t size, size_t* lineNumber, size_t* offsetBytes); MSVC_DBG_EXPORT size_t GetDescriptionFromAddress(void* address, const char* format, char* description, size_t size); MSVC_DBG_EXPORT size_t GetDescriptionFromStack(void*const frames[], size_t count, const char* format, char* description[], size_t size); /* Compatibility with */ MSVC_DBG_EXPORT int backtrace(void* addresses[], int count); MSVC_DBG_EXPORT char** backtrace_symbols(void*const addresses[], int count); #ifdef __cplusplus } #endif #endif/*_MSVC_DBG_H*/ ecl-16.1.2/src/bdwgc/include/private/pthread_stop_world.h000066400000000000000000000034241266352375300234110ustar00rootroot00000000000000/* * Copyright (c) 1994 by Xerox Corporation. All rights reserved. * Copyright (c) 1996 by Silicon Graphics. All rights reserved. * Copyright (c) 1998 by Fergus Henderson. All rights reserved. * Copyright (c) 2000-2009 by Hewlett-Packard Development Company. * All rights reserved. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. */ #ifndef GC_PTHREAD_STOP_WORLD_H #define GC_PTHREAD_STOP_WORLD_H struct thread_stop_info { # ifndef GC_OPENBSD_UTHREADS word last_stop_count; /* GC_last_stop_count value when thread */ /* last successfully handled a suspend */ /* signal. */ # endif ptr_t stack_ptr; /* Valid only when stopped. */ # ifdef NACL /* Grab NACL_GC_REG_STORAGE_SIZE pointers off the stack when */ /* going into a syscall. 20 is more than we need, but it's an */ /* overestimate in case the instrumented function uses any callee */ /* saved registers, they may be pushed to the stack much earlier. */ /* Also, on amd64 'push' puts 8 bytes on the stack even though */ /* our pointers are 4 bytes. */ # define NACL_GC_REG_STORAGE_SIZE 20 ptr_t reg_storage[NACL_GC_REG_STORAGE_SIZE]; # endif }; GC_INNER void GC_stop_init(void); #endif ecl-16.1.2/src/bdwgc/include/private/pthread_support.h000066400000000000000000000153251266352375300227340ustar00rootroot00000000000000/* * Copyright (c) 1994 by Xerox Corporation. All rights reserved. * Copyright (c) 1996 by Silicon Graphics. All rights reserved. * Copyright (c) 1998 by Fergus Henderson. All rights reserved. * Copyright (c) 2000-2009 by Hewlett-Packard Development Company. * All rights reserved. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. */ #ifndef GC_PTHREAD_SUPPORT_H #define GC_PTHREAD_SUPPORT_H #include "private/gc_priv.h" #if defined(GC_PTHREADS) && !defined(GC_WIN32_THREADS) #if defined(GC_DARWIN_THREADS) # include "private/darwin_stop_world.h" #else # include "private/pthread_stop_world.h" #endif #ifdef THREAD_LOCAL_ALLOC # include "thread_local_alloc.h" #endif /* We use the allocation lock to protect thread-related data structures. */ /* The set of all known threads. We intercept thread creation and */ /* joins. */ /* Protected by allocation/GC lock. */ /* Some of this should be declared volatile, but that's inconsistent */ /* with some library routine declarations. */ typedef struct GC_Thread_Rep { struct GC_Thread_Rep * next; /* More recently allocated threads */ /* with a given pthread id come */ /* first. (All but the first are */ /* guaranteed to be dead, but we may */ /* not yet have registered the join.) */ pthread_t id; # ifdef PLATFORM_ANDROID pid_t kernel_id; # endif /* Extra bookkeeping information the stopping code uses */ struct thread_stop_info stop_info; unsigned char flags; # define FINISHED 1 /* Thread has exited. */ # define DETACHED 2 /* Thread is treated as detached. */ /* Thread may really be detached, or */ /* it may have been explicitly */ /* registered, in which case we can */ /* deallocate its GC_Thread_Rep once */ /* it unregisters itself, since it */ /* may not return a GC pointer. */ # define MAIN_THREAD 4 /* True for the original thread only. */ # define SUSPENDED_EXT 8 /* Thread was suspended externally */ /* (this is not used by the unmodified */ /* GC itself at present). */ # define DISABLED_GC 0x10 /* Collections are disabled while the */ /* thread is exiting. */ unsigned char thread_blocked; /* Protected by GC lock. */ /* Treated as a boolean value. If set, */ /* thread will acquire GC lock before */ /* doing any pointer manipulations, and */ /* has set its SP value. Thus it does */ /* not need to be sent a signal to stop */ /* it. */ unsigned short finalizer_skipped; unsigned char finalizer_nested; /* Used by GC_check_finalizer_nested() */ /* to minimize the level of recursion */ /* when a client finalizer allocates */ /* memory (initially both are 0). */ ptr_t stack_end; /* Cold end of the stack (except for */ /* main thread). */ # if defined(GC_DARWIN_THREADS) && !defined(DARWIN_DONT_PARSE_STACK) ptr_t topOfStack; /* Result of GC_FindTopOfStack(0); */ /* valid only if the thread is blocked; */ /* non-NULL value means already set. */ # endif # ifdef IA64 ptr_t backing_store_end; ptr_t backing_store_ptr; # endif struct GC_traced_stack_sect_s *traced_stack_sect; /* Points to the "frame" data held in stack by */ /* the innermost GC_call_with_gc_active() of */ /* this thread. May be NULL. */ void * status; /* The value returned from the thread. */ /* Used only to avoid premature */ /* reclamation of any data it might */ /* reference. */ /* This is unfortunately also the */ /* reason we need to intercept join */ /* and detach. */ # ifdef THREAD_LOCAL_ALLOC struct thread_local_freelists tlfs; # endif } * GC_thread; # define THREAD_TABLE_SZ 256 /* Must be power of 2 */ GC_EXTERN volatile GC_thread GC_threads[THREAD_TABLE_SZ]; GC_EXTERN GC_bool GC_thr_initialized; GC_INNER GC_thread GC_lookup_thread(pthread_t id); GC_EXTERN GC_bool GC_in_thread_creation; /* We may currently be in thread creation or destruction. */ /* Only set to TRUE while allocation lock is held. */ /* When set, it is OK to run GC from unknown thread. */ #ifdef NACL GC_EXTERN __thread GC_thread GC_nacl_gc_thread_self; GC_INNER void GC_nacl_initialize_gc_thread(void); GC_INNER void GC_nacl_shutdown_gc_thread(void); #endif #ifdef GC_EXPLICIT_SIGNALS_UNBLOCK GC_INNER void GC_unblock_gc_signals(void); #endif #ifdef GC_PTHREAD_START_STANDALONE # define GC_INNER_PTHRSTART /* empty */ #else # define GC_INNER_PTHRSTART GC_INNER #endif GC_INNER_PTHRSTART GC_thread GC_start_rtn_prepare_thread( void *(**pstart)(void *), void **pstart_arg, struct GC_stack_base *sb, void *arg); GC_INNER_PTHRSTART void GC_thread_exit_proc(void *); #endif /* GC_PTHREADS && !GC_WIN32_THREADS */ #endif /* GC_PTHREAD_SUPPORT_H */ ecl-16.1.2/src/bdwgc/include/private/specific.h000066400000000000000000000077361266352375300213050ustar00rootroot00000000000000/* * This is a reimplementation of a subset of the pthread_getspecific/setspecific * interface. This appears to outperform the standard linuxthreads one * by a significant margin. * The major restriction is that each thread may only make a single * pthread_setspecific call on a single key. (The current data structure * doesn't really require that. The restriction should be easily removable.) * We don't currently support the destruction functions, though that * could be done. * We also currently assume that only one pthread_setspecific call * can be executed at a time, though that assumption would be easy to remove * by adding a lock. */ #include #include "atomic_ops.h" /* Called during key creation or setspecific. */ /* For the GC we already hold lock. */ /* Currently allocated objects leak on thread exit. */ /* That's hard to fix, but OK if we allocate garbage */ /* collected memory. */ #define MALLOC_CLEAR(n) GC_INTERNAL_MALLOC(n, NORMAL) #define TS_CACHE_SIZE 1024 #define CACHE_HASH(n) ((((n) >> 8) ^ (n)) & (TS_CACHE_SIZE - 1)) #define TS_HASH_SIZE 1024 #define HASH(p) \ ((unsigned)((((word)(p)) >> 8) ^ (word)(p)) & (TS_HASH_SIZE - 1)) /* An entry describing a thread-specific value for a given thread. */ /* All such accessible structures preserve the invariant that if either */ /* thread is a valid pthread id or qtid is a valid "quick tread id" */ /* for a thread, then value holds the corresponding thread specific */ /* value. This invariant must be preserved at ALL times, since */ /* asynchronous reads are allowed. */ typedef struct thread_specific_entry { volatile AO_t qtid; /* quick thread id, only for cache */ void * value; struct thread_specific_entry *next; pthread_t thread; } tse; /* We represent each thread-specific datum as two tables. The first is */ /* a cache, indexed by a "quick thread identifier". The "quick" thread */ /* identifier is an easy to compute value, which is guaranteed to */ /* determine the thread, though a thread may correspond to more than */ /* one value. We typically use the address of a page in the stack. */ /* The second is a hash table, indexed by pthread_self(). It is used */ /* only as a backup. */ /* Return the "quick thread id". Default version. Assumes page size, */ /* or at least thread stack separation, is at least 4K. */ /* Must be defined so that it never returns 0. (Page 0 can't really be */ /* part of any stack, since that would make 0 a valid stack pointer.) */ #define quick_thread_id() (((word)GC_approx_sp()) >> 12) #define INVALID_QTID ((word)0) #define INVALID_THREADID ((pthread_t)0) union ptse_ao_u { tse *p; volatile AO_t ao; }; typedef struct thread_specific_data { tse * volatile cache[TS_CACHE_SIZE]; /* A faster index to the hash table */ union ptse_ao_u hash[TS_HASH_SIZE]; pthread_mutex_t lock; } tsd; typedef tsd * GC_key_t; #define GC_key_create(key, d) GC_key_create_inner(key) GC_INNER int GC_key_create_inner(tsd ** key_ptr); GC_INNER int GC_setspecific(tsd * key, void * value); GC_INNER void GC_remove_specific(tsd * key); /* An internal version of getspecific that assumes a cache miss. */ GC_INNER void * GC_slow_getspecific(tsd * key, word qtid, tse * volatile * cache_entry); /* GC_INLINE is defined in gc_priv.h. */ GC_INLINE void * GC_getspecific(tsd * key) { word qtid = quick_thread_id(); tse * volatile * entry_ptr = &key->cache[CACHE_HASH(qtid)]; tse * entry = *entry_ptr; /* Must be loaded only once. */ GC_ASSERT(qtid != INVALID_QTID); if (EXPECT(entry -> qtid == qtid, TRUE)) { GC_ASSERT(entry -> thread == pthread_self()); return entry -> value; } return GC_slow_getspecific(key, qtid, entry_ptr); } ecl-16.1.2/src/bdwgc/include/private/thread_local_alloc.h000066400000000000000000000155141266352375300233040ustar00rootroot00000000000000/* * Copyright (c) 2000-2005 by Hewlett-Packard Company. All rights reserved. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. */ /* Included indirectly from a thread-library-specific file. */ /* This is the interface for thread-local allocation, whose */ /* implementation is mostly thread-library-independent. */ /* Here we describe only the interface that needs to be known */ /* and invoked from the thread support layer; the actual */ /* implementation also exports GC_malloc and friends, which */ /* are declared in gc.h. */ #ifndef GC_THREAD_LOCAL_ALLOC_H #define GC_THREAD_LOCAL_ALLOC_H #include "private/gc_priv.h" #ifdef THREAD_LOCAL_ALLOC #include "gc_inline.h" #if defined(USE_HPUX_TLS) # error USE_HPUX_TLS macro was replaced by USE_COMPILER_TLS #endif #if !defined(USE_PTHREAD_SPECIFIC) && !defined(USE_WIN32_SPECIFIC) \ && !defined(USE_WIN32_COMPILER_TLS) && !defined(USE_COMPILER_TLS) \ && !defined(USE_CUSTOM_SPECIFIC) # if defined(MSWIN32) || defined(MSWINCE) || defined(CYGWIN32) # if defined(CYGWIN32) && (__GNUC__ >= 4) # if defined(__clang__) /* As of Cygwin clang3.1, thread-local storage is unsupported. */ # define USE_PTHREAD_SPECIFIC # else # define USE_COMPILER_TLS # endif # elif defined(__GNUC__) || defined(MSWINCE) # define USE_WIN32_SPECIFIC # else # define USE_WIN32_COMPILER_TLS # endif /* !GNU */ # elif (defined(LINUX) && !defined(ARM32) && !defined(AVR32) \ && (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 3)) \ && !(defined(__clang__) && defined(PLATFORM_ANDROID))) \ || (defined(PLATFORM_ANDROID) && defined(ARM32) \ && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))) /* As of Android NDK r8e, Clang cannot find __tls_get_addr. */ # define USE_COMPILER_TLS # elif defined(GC_DGUX386_THREADS) || defined(GC_OSF1_THREADS) \ || defined(GC_AIX_THREADS) || defined(GC_DARWIN_THREADS) \ || defined(GC_FREEBSD_THREADS) || defined(GC_NETBSD_THREADS) \ || defined(GC_LINUX_THREADS) || defined(GC_RTEMS_PTHREADS) # define USE_PTHREAD_SPECIFIC # elif defined(GC_HPUX_THREADS) # ifdef __GNUC__ # define USE_PTHREAD_SPECIFIC /* Empirically, as of gcc 3.3, USE_COMPILER_TLS doesn't work. */ # else # define USE_COMPILER_TLS # endif # else # define USE_CUSTOM_SPECIFIC /* Use our own. */ # endif #endif #include /* One of these should be declared as the tlfs field in the */ /* structure pointed to by a GC_thread. */ typedef struct thread_local_freelists { void * ptrfree_freelists[TINY_FREELISTS]; void * normal_freelists[TINY_FREELISTS]; # ifdef GC_GCJ_SUPPORT void * gcj_freelists[TINY_FREELISTS]; # define ERROR_FL ((void *)(word)-1) /* Value used for gcj_freelist[-1]; allocation is */ /* erroneous. */ # endif # ifdef ENABLE_DISCLAIM void * finalized_freelists[TINY_FREELISTS]; # endif /* Free lists contain either a pointer or a small count */ /* reflecting the number of granules allocated at that */ /* size. */ /* 0 ==> thread-local allocation in use, free list */ /* empty. */ /* > 0, <= DIRECT_GRANULES ==> Using global allocation, */ /* too few objects of this size have been */ /* allocated by this thread. */ /* >= HBLKSIZE => pointer to nonempty free list. */ /* > DIRECT_GRANULES, < HBLKSIZE ==> transition to */ /* local alloc, equivalent to 0. */ # define DIRECT_GRANULES (HBLKSIZE/GRANULE_BYTES) /* Don't use local free lists for up to this much */ /* allocation. */ } *GC_tlfs; #if defined(USE_PTHREAD_SPECIFIC) # define GC_getspecific pthread_getspecific # define GC_setspecific pthread_setspecific # define GC_key_create pthread_key_create # define GC_remove_specific(key) /* No need for cleanup on exit. */ typedef pthread_key_t GC_key_t; #elif defined(USE_COMPILER_TLS) || defined(USE_WIN32_COMPILER_TLS) # define GC_getspecific(x) (x) # define GC_setspecific(key, v) ((key) = (v), 0) # define GC_key_create(key, d) 0 # define GC_remove_specific(key) /* No need for cleanup on exit. */ typedef void * GC_key_t; #elif defined(USE_WIN32_SPECIFIC) # ifndef WIN32_LEAN_AND_MEAN # define WIN32_LEAN_AND_MEAN 1 # endif # define NOSERVICE # include # define GC_getspecific TlsGetValue # define GC_setspecific(key, v) !TlsSetValue(key, v) /* We assume 0 == success, msft does the opposite. */ # ifndef TLS_OUT_OF_INDEXES /* this is currently missing in WinCE */ # define TLS_OUT_OF_INDEXES (DWORD)0xFFFFFFFF # endif # define GC_key_create(key, d) \ ((d) != 0 || (*(key) = TlsAlloc()) == TLS_OUT_OF_INDEXES ? -1 : 0) # define GC_remove_specific(key) /* No need for cleanup on exit. */ /* Need TlsFree on process exit/detach? */ typedef DWORD GC_key_t; #elif defined(USE_CUSTOM_SPECIFIC) # include "private/specific.h" #else # error implement me #endif /* Each thread structure must be initialized. */ /* This call must be made from the new thread. */ /* Caller holds allocation lock. */ GC_INNER void GC_init_thread_local(GC_tlfs p); /* Called when a thread is unregistered, or exits. */ /* We hold the allocator lock. */ GC_INNER void GC_destroy_thread_local(GC_tlfs p); /* The thread support layer must arrange to mark thread-local */ /* free lists explicitly, since the link field is often */ /* invisible to the marker. It knows how to find all threads; */ /* we take care of an individual thread freelist structure. */ GC_INNER void GC_mark_thread_local_fls_for(GC_tlfs p); #ifdef ENABLE_DISCLAIM GC_EXTERN ptr_t * GC_finalized_objfreelist; #endif extern #if defined(USE_COMPILER_TLS) __thread #elif defined(USE_WIN32_COMPILER_TLS) __declspec(thread) #endif GC_key_t GC_thread_key; /* This is set up by the thread_local_alloc implementation. No need */ /* for cleanup on thread exit. But the thread support layer makes sure */ /* that GC_thread_key is traced, if necessary. */ #endif /* THREAD_LOCAL_ALLOC */ #endif /* GC_THREAD_LOCAL_ALLOC_H */ ecl-16.1.2/src/bdwgc/include/weakpointer.h000066400000000000000000000215761266352375300203740ustar00rootroot00000000000000#ifndef _weakpointer_h_ #define _weakpointer_h_ /**************************************************************************** WeakPointer and CleanUp Copyright (c) 1991 by Xerox Corporation. All rights reserved. THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED OR IMPLIED. ANY USE IS AT YOUR OWN RISK. Permission is hereby granted to copy this code for any purpose, provided the above notices are retained on all copies. ****************************************************************************/ /**************************************************************************** WeakPointer A weak pointer is a pointer to a heap-allocated object that doesn't prevent the object from being garbage collected. Weak pointers can be used to track which objects haven't yet been reclaimed by the collector. A weak pointer is deactivated when the collector discovers its referent object is unreachable by normal pointers (reachability and deactivation are defined more precisely below). A deactivated weak pointer remains deactivated forever. ****************************************************************************/ template< class T > class WeakPointer { public: WeakPointer( T* t = 0 ) /* Constructs a weak pointer for *t. t may be null. It is an error if t is non-null and *t is not a collected object. */ {impl = _WeakPointer_New( t );} T* Pointer() /* wp.Pointer() returns a pointer to the referent object of wp or null if wp has been deactivated (because its referent object has been discovered unreachable by the collector). */ {return (T*) _WeakPointer_Pointer( this->impl );} int operator==( WeakPointer< T > wp2 ) /* Given weak pointers wp1 and wp2, if wp1 == wp2, then wp1 and wp2 refer to the same object. If wp1 != wp2, then either wp1 and wp2 don't refer to the same object, or if they do, one or both of them has been deactivated. (Note: If objects t1 and t2 are never made reachable by their clean-up functions, then WeakPointer(t1) == WeakPointer(t2) if and only t1 == t2.) */ {return _WeakPointer_Equal( this->impl, wp2.impl );} int Hash() /* Returns a hash code suitable for use by multiplicative- and division-based hash tables. If wp1 == wp2, then wp1.Hash() == wp2.Hash(). */ {return _WeakPointer_Hash( this->impl );} private: void* impl; }; /***************************************************************************** CleanUp A garbage-collected object can have an associated clean-up function that will be invoked some time after the collector discovers the object is unreachable via normal pointers. Clean-up functions can be used to release resources such as open-file handles or window handles when their containing objects become unreachable. If a C++ object has a non-empty explicit destructor (i.e. it contains programmer-written code), the destructor will be automatically registered as the object's initial clean-up function. There is no guarantee that the collector will detect every unreachable object (though it will find almost all of them). Clients should not rely on clean-up to cause some action to occur immediately -- clean-up is only a mechanism for improving resource usage. Every object with a clean-up function also has a clean-up queue. When the collector finds the object is unreachable, it enqueues it on its queue. The clean-up function is applied when the object is removed from the queue. By default, objects are enqueued on the garbage collector's queue, and the collector removes all objects from its queue after each collection. If a client supplies another queue for objects, it is his responsibility to remove objects (and cause their functions to be called) by polling it periodically. Clean-up queues allow clean-up functions accessing global data to synchronize with the main program. Garbage collection can occur at any time, and clean-ups invoked by the collector might access data in an inconsistent state. A client can control this by defining an explicit queue for objects and polling it at safe points. The following definitions are used by the specification below: Given a pointer t to a collected object, the base object BO(t) is the value returned by new when it created the object. (Because of multiple inheritance, t and BO(t) may not be the same address.) A weak pointer wp references an object *t if BO(wp.Pointer()) == BO(t). ***************************************************************************/ template< class T, class Data > class CleanUp { public: static void Set( T* t, void c( Data* d, T* t ), Data* d = 0 ) /* Sets the clean-up function of object BO(t) to be , replacing any previously defined clean-up function for BO(t); c and d can be null, but t cannot. Sets the clean-up queue for BO(t) to be the collector's queue. When t is removed from its clean-up queue, its clean-up will be applied by calling c(d, t). It is an error if *t is not a collected object. */ {_CleanUp_Set( t, c, d );} static void Call( T* t ) /* Sets the new clean-up function for BO(t) to be null and, if the old one is non-null, calls it immediately, even if BO(t) is still reachable. Deactivates any weak pointers to BO(t). */ {_CleanUp_Call( t );} class Queue {public: Queue() /* Constructs a new queue. */ {this->head = _CleanUp_Queue_NewHead();} void Set( T* t ) /* q.Set(t) sets the clean-up queue of BO(t) to be q. */ {_CleanUp_Queue_Set( this->head, t );} int Call() /* If q is non-empty, q.Call() removes the first object and calls its clean-up function; does nothing if q is empty. Returns true if there are more objects in the queue. */ {return _CleanUp_Queue_Call( this->head );} private: void* head; }; }; /********************************************************************** Reachability and Clean-up An object O is reachable if it can be reached via a non-empty path of normal pointers from the registers, stacks, global variables, or an object with a non-null clean-up function (including O itself), ignoring pointers from an object to itself. This definition of reachability ensures that if object B is accessible from object A (and not vice versa) and if both A and B have clean-up functions, then A will always be cleaned up before B. Note that as long as an object with a clean-up function is contained in a cycle of pointers, it will always be reachable and will never be cleaned up or collected. When the collector finds an unreachable object with a null clean-up function, it atomically deactivates all weak pointers referencing the object and recycles its storage. If object B is accessible from object A via a path of normal pointers, A will be discovered unreachable no later than B, and a weak pointer to A will be deactivated no later than a weak pointer to B. When the collector finds an unreachable object with a non-null clean-up function, the collector atomically deactivates all weak pointers referencing the object, redefines its clean-up function to be null, and enqueues it on its clean-up queue. The object then becomes reachable again and remains reachable at least until its clean-up function executes. The clean-up function is assured that its argument is the only accessible pointer to the object. Nothing prevents the function from redefining the object's clean-up function or making the object reachable again (for example, by storing the pointer in a global variable). If the clean-up function does not make its object reachable again and does not redefine its clean-up function, then the object will be collected by a subsequent collection (because the object remains unreachable and now has a null clean-up function). If the clean-up function does make its object reachable again and a clean-up function is subsequently redefined for the object, then the new clean-up function will be invoked the next time the collector finds the object unreachable. Note that a destructor for a collected object cannot safely redefine a clean-up function for its object, since after the destructor executes, the object has been destroyed into "raw memory". (In most implementations, destroying an object mutates its vtbl.) Finally, note that calling delete t on a collected object first deactivates any weak pointers to t and then invokes its clean-up function (destructor). **********************************************************************/ extern "C" { void* _WeakPointer_New( void* t ); void* _WeakPointer_Pointer( void* wp ); int _WeakPointer_Equal( void* wp1, void* wp2 ); int _WeakPointer_Hash( void* wp ); void _CleanUp_Set( void* t, void (*c)( void* d, void* t ), void* d ); void _CleanUp_Call( void* t ); void* _CleanUp_Queue_NewHead (); void _CleanUp_Queue_Set( void* h, void* t ); int _CleanUp_Queue_Call( void* h ); } #endif /* _weakpointer_h_ */ ecl-16.1.2/src/bdwgc/install-sh000077500000000000000000000345231266352375300162500ustar00rootroot00000000000000#!/bin/sh # install - install a program, script, or datafile scriptversion=2013-12-25.23; # UTC # This originates from X11R5 (mit/util/scripts/install.sh), which was # later released in X11R6 (xc/config/util/install.sh) with the # following copyright and license. # # Copyright (C) 1994 X Consortium # # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to # deal in the Software without restriction, including without limitation the # rights to use, copy, modify, merge, publish, distribute, sublicense, and/or # sell copies of the Software, and to permit persons to whom the Software is # furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included in # all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN # AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNEC- # TION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. # # Except as contained in this notice, the name of the X Consortium shall not # be used in advertising or otherwise to promote the sale, use or other deal- # ings in this Software without prior written authorization from the X Consor- # tium. # # # FSF changes to this file are in the public domain. # # Calling this script install-sh is preferred over install.sh, to prevent # 'make' implicit rules from creating a file called install from it # when there is no Makefile. # # This script is compatible with the BSD install script, but was written # from scratch. tab=' ' nl=' ' IFS=" $tab$nl" # Set DOITPROG to "echo" to test this script. doit=${DOITPROG-} doit_exec=${doit:-exec} # Put in absolute file names if you don't have them in your path; # or use environment vars. chgrpprog=${CHGRPPROG-chgrp} chmodprog=${CHMODPROG-chmod} chownprog=${CHOWNPROG-chown} cmpprog=${CMPPROG-cmp} cpprog=${CPPROG-cp} mkdirprog=${MKDIRPROG-mkdir} mvprog=${MVPROG-mv} rmprog=${RMPROG-rm} stripprog=${STRIPPROG-strip} posix_mkdir= # Desired mode of installed file. mode=0755 chgrpcmd= chmodcmd=$chmodprog chowncmd= mvcmd=$mvprog rmcmd="$rmprog -f" stripcmd= src= dst= dir_arg= dst_arg= copy_on_change=false is_target_a_directory=possibly usage="\ Usage: $0 [OPTION]... [-T] SRCFILE DSTFILE or: $0 [OPTION]... SRCFILES... DIRECTORY or: $0 [OPTION]... -t DIRECTORY SRCFILES... or: $0 [OPTION]... -d DIRECTORIES... In the 1st form, copy SRCFILE to DSTFILE. In the 2nd and 3rd, copy all SRCFILES to DIRECTORY. In the 4th, create DIRECTORIES. Options: --help display this help and exit. --version display version info and exit. -c (ignored) -C install only if different (preserve the last data modification time) -d create directories instead of installing files. -g GROUP $chgrpprog installed files to GROUP. -m MODE $chmodprog installed files to MODE. -o USER $chownprog installed files to USER. -s $stripprog installed files. -t DIRECTORY install into DIRECTORY. -T report an error if DSTFILE is a directory. Environment variables override the default commands: CHGRPPROG CHMODPROG CHOWNPROG CMPPROG CPPROG MKDIRPROG MVPROG RMPROG STRIPPROG " while test $# -ne 0; do case $1 in -c) ;; -C) copy_on_change=true;; -d) dir_arg=true;; -g) chgrpcmd="$chgrpprog $2" shift;; --help) echo "$usage"; exit $?;; -m) mode=$2 case $mode in *' '* | *"$tab"* | *"$nl"* | *'*'* | *'?'* | *'['*) echo "$0: invalid mode: $mode" >&2 exit 1;; esac shift;; -o) chowncmd="$chownprog $2" shift;; -s) stripcmd=$stripprog;; -t) is_target_a_directory=always dst_arg=$2 # Protect names problematic for 'test' and other utilities. case $dst_arg in -* | [=\(\)!]) dst_arg=./$dst_arg;; esac shift;; -T) is_target_a_directory=never;; --version) echo "$0 $scriptversion"; exit $?;; --) shift break;; -*) echo "$0: invalid option: $1" >&2 exit 1;; *) break;; esac shift done # We allow the use of options -d and -T together, by making -d # take the precedence; this is for compatibility with GNU install. if test -n "$dir_arg"; then if test -n "$dst_arg"; then echo "$0: target directory not allowed when installing a directory." >&2 exit 1 fi fi if test $# -ne 0 && test -z "$dir_arg$dst_arg"; then # When -d is used, all remaining arguments are directories to create. # When -t is used, the destination is already specified. # Otherwise, the last argument is the destination. Remove it from $@. for arg do if test -n "$dst_arg"; then # $@ is not empty: it contains at least $arg. set fnord "$@" "$dst_arg" shift # fnord fi shift # arg dst_arg=$arg # Protect names problematic for 'test' and other utilities. case $dst_arg in -* | [=\(\)!]) dst_arg=./$dst_arg;; esac done fi if test $# -eq 0; then if test -z "$dir_arg"; then echo "$0: no input file specified." >&2 exit 1 fi # It's OK to call 'install-sh -d' without argument. # This can happen when creating conditional directories. exit 0 fi if test -z "$dir_arg"; then if test $# -gt 1 || test "$is_target_a_directory" = always; then if test ! -d "$dst_arg"; then echo "$0: $dst_arg: Is not a directory." >&2 exit 1 fi fi fi if test -z "$dir_arg"; then do_exit='(exit $ret); exit $ret' trap "ret=129; $do_exit" 1 trap "ret=130; $do_exit" 2 trap "ret=141; $do_exit" 13 trap "ret=143; $do_exit" 15 # Set umask so as not to create temps with too-generous modes. # However, 'strip' requires both read and write access to temps. case $mode in # Optimize common cases. *644) cp_umask=133;; *755) cp_umask=22;; *[0-7]) if test -z "$stripcmd"; then u_plus_rw= else u_plus_rw='% 200' fi cp_umask=`expr '(' 777 - $mode % 1000 ')' $u_plus_rw`;; *) if test -z "$stripcmd"; then u_plus_rw= else u_plus_rw=,u+rw fi cp_umask=$mode$u_plus_rw;; esac fi for src do # Protect names problematic for 'test' and other utilities. case $src in -* | [=\(\)!]) src=./$src;; esac if test -n "$dir_arg"; then dst=$src dstdir=$dst test -d "$dstdir" dstdir_status=$? else # Waiting for this to be detected by the "$cpprog $src $dsttmp" command # might cause directories to be created, which would be especially bad # if $src (and thus $dsttmp) contains '*'. if test ! -f "$src" && test ! -d "$src"; then echo "$0: $src does not exist." >&2 exit 1 fi if test -z "$dst_arg"; then echo "$0: no destination specified." >&2 exit 1 fi dst=$dst_arg # If destination is a directory, append the input filename; won't work # if double slashes aren't ignored. if test -d "$dst"; then if test "$is_target_a_directory" = never; then echo "$0: $dst_arg: Is a directory" >&2 exit 1 fi dstdir=$dst dst=$dstdir/`basename "$src"` dstdir_status=0 else dstdir=`dirname "$dst"` test -d "$dstdir" dstdir_status=$? fi fi obsolete_mkdir_used=false if test $dstdir_status != 0; then case $posix_mkdir in '') # Create intermediate dirs using mode 755 as modified by the umask. # This is like FreeBSD 'install' as of 1997-10-28. umask=`umask` case $stripcmd.$umask in # Optimize common cases. *[2367][2367]) mkdir_umask=$umask;; .*0[02][02] | .[02][02] | .[02]) mkdir_umask=22;; *[0-7]) mkdir_umask=`expr $umask + 22 \ - $umask % 100 % 40 + $umask % 20 \ - $umask % 10 % 4 + $umask % 2 `;; *) mkdir_umask=$umask,go-w;; esac # With -d, create the new directory with the user-specified mode. # Otherwise, rely on $mkdir_umask. if test -n "$dir_arg"; then mkdir_mode=-m$mode else mkdir_mode= fi posix_mkdir=false case $umask in *[123567][0-7][0-7]) # POSIX mkdir -p sets u+wx bits regardless of umask, which # is incompatible with FreeBSD 'install' when (umask & 300) != 0. ;; *) tmpdir=${TMPDIR-/tmp}/ins$RANDOM-$$ trap 'ret=$?; rmdir "$tmpdir/d" "$tmpdir" 2>/dev/null; exit $ret' 0 if (umask $mkdir_umask && exec $mkdirprog $mkdir_mode -p -- "$tmpdir/d") >/dev/null 2>&1 then if test -z "$dir_arg" || { # Check for POSIX incompatibilities with -m. # HP-UX 11.23 and IRIX 6.5 mkdir -m -p sets group- or # other-writable bit of parent directory when it shouldn't. # FreeBSD 6.1 mkdir -m -p sets mode of existing directory. ls_ld_tmpdir=`ls -ld "$tmpdir"` case $ls_ld_tmpdir in d????-?r-*) different_mode=700;; d????-?--*) different_mode=755;; *) false;; esac && $mkdirprog -m$different_mode -p -- "$tmpdir" && { ls_ld_tmpdir_1=`ls -ld "$tmpdir"` test "$ls_ld_tmpdir" = "$ls_ld_tmpdir_1" } } then posix_mkdir=: fi rmdir "$tmpdir/d" "$tmpdir" else # Remove any dirs left behind by ancient mkdir implementations. rmdir ./$mkdir_mode ./-p ./-- 2>/dev/null fi trap '' 0;; esac;; esac if $posix_mkdir && ( umask $mkdir_umask && $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir" ) then : else # The umask is ridiculous, or mkdir does not conform to POSIX, # or it failed possibly due to a race condition. Create the # directory the slow way, step by step, checking for races as we go. case $dstdir in /*) prefix='/';; [-=\(\)!]*) prefix='./';; *) prefix='';; esac oIFS=$IFS IFS=/ set -f set fnord $dstdir shift set +f IFS=$oIFS prefixes= for d do test X"$d" = X && continue prefix=$prefix$d if test -d "$prefix"; then prefixes= else if $posix_mkdir; then (umask=$mkdir_umask && $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir") && break # Don't fail if two instances are running concurrently. test -d "$prefix" || exit 1 else case $prefix in *\'*) qprefix=`echo "$prefix" | sed "s/'/'\\\\\\\\''/g"`;; *) qprefix=$prefix;; esac prefixes="$prefixes '$qprefix'" fi fi prefix=$prefix/ done if test -n "$prefixes"; then # Don't fail if two instances are running concurrently. (umask $mkdir_umask && eval "\$doit_exec \$mkdirprog $prefixes") || test -d "$dstdir" || exit 1 obsolete_mkdir_used=true fi fi fi if test -n "$dir_arg"; then { test -z "$chowncmd" || $doit $chowncmd "$dst"; } && { test -z "$chgrpcmd" || $doit $chgrpcmd "$dst"; } && { test "$obsolete_mkdir_used$chowncmd$chgrpcmd" = false || test -z "$chmodcmd" || $doit $chmodcmd $mode "$dst"; } || exit 1 else # Make a couple of temp file names in the proper directory. dsttmp=$dstdir/_inst.$$_ rmtmp=$dstdir/_rm.$$_ # Trap to clean up those temp files at exit. trap 'ret=$?; rm -f "$dsttmp" "$rmtmp" && exit $ret' 0 # Copy the file name to the temp name. (umask $cp_umask && $doit_exec $cpprog "$src" "$dsttmp") && # and set any options; do chmod last to preserve setuid bits. # # If any of these fail, we abort the whole thing. If we want to # ignore errors from any of these, just make sure not to ignore # errors from the above "$doit $cpprog $src $dsttmp" command. # { test -z "$chowncmd" || $doit $chowncmd "$dsttmp"; } && { test -z "$chgrpcmd" || $doit $chgrpcmd "$dsttmp"; } && { test -z "$stripcmd" || $doit $stripcmd "$dsttmp"; } && { test -z "$chmodcmd" || $doit $chmodcmd $mode "$dsttmp"; } && # If -C, don't bother to copy if it wouldn't change the file. if $copy_on_change && old=`LC_ALL=C ls -dlL "$dst" 2>/dev/null` && new=`LC_ALL=C ls -dlL "$dsttmp" 2>/dev/null` && set -f && set X $old && old=:$2:$4:$5:$6 && set X $new && new=:$2:$4:$5:$6 && set +f && test "$old" = "$new" && $cmpprog "$dst" "$dsttmp" >/dev/null 2>&1 then rm -f "$dsttmp" else # Rename the file to the real destination. $doit $mvcmd -f "$dsttmp" "$dst" 2>/dev/null || # The rename failed, perhaps because mv can't rename something else # to itself, or perhaps because mv is so ancient that it does not # support -f. { # Now remove or move aside any old file at destination location. # We try this two ways since rm can't unlink itself on some # systems and the destination file might be busy for other # reasons. In this case, the final cleanup might fail but the new # file should still install successfully. { test ! -f "$dst" || $doit $rmcmd -f "$dst" 2>/dev/null || { $doit $mvcmd -f "$dst" "$rmtmp" 2>/dev/null && { $doit $rmcmd -f "$rmtmp" 2>/dev/null; :; } } || { echo "$0: cannot unlink or rename $dst" >&2 (exit 1); exit 1 } } && # Now rename the file to the real destination. $doit $mvcmd "$dsttmp" "$dst" } fi || exit 1 trap '' 0 fi done # Local variables: # eval: (add-hook 'write-file-hooks 'time-stamp) # time-stamp-start: "scriptversion=" # time-stamp-format: "%:y-%02m-%02d.%02H" # time-stamp-time-zone: "UTC" # time-stamp-end: "; # UTC" # End: ecl-16.1.2/src/bdwgc/libatomic_ops/000077500000000000000000000000001266352375300170615ustar00rootroot00000000000000ecl-16.1.2/src/bdwgc/libatomic_ops/.gitattributes000066400000000000000000000004141266352375300217530ustar00rootroot00000000000000# Git repo attributes. # Ensure all text files have normalized (LF) line endings in the repository. * text=auto # Note: "core.eol" configuration variable controls which line endings to use # for the normalized files in the working directory (the default is native). ecl-16.1.2/src/bdwgc/libatomic_ops/.gitignore000066400000000000000000000017011266352375300210500ustar00rootroot00000000000000# Ignored files in libatomic_ops Git repo. Makefile /pkgconfig/atomic_ops.pc /pkgconfig/atomic_ops-uninstalled.pc /autom4te.cache/ /config.cache /config.log /config.status /libatomic_ops-* *.a *.dll *.exe *.gcda *.gch *.gcno *.la *.lib *.lo *.o *.obj *.so /src/.deps/ /src/.dirstamp /src/.libs/ /src/config.h /src/config.h.in~ /src/stamp-h1 /tests/.deps/ /tests/.dirstamp /tests/.libs/ /tests/core /tests/list_atomic.i /tests/test_atomic /tests/test_atomic_pthreads /tests/test_malloc /tests/test_stack # External library (without trailing slash to allow symlinks): /pthreads-w32* # These files are generated by autoreconf: /aclocal.m4 /compile /config.guess /config.sub /configure /depcomp /install-sh /missing /mkinstalldirs /src/config.h.in /test-driver Makefile.in # Generated by libtoolize: /libtool /ltmain.sh /m4/*.m4 # These files are generated by make check: /tests/list_atomic.c /tests/test_atomic_include.h /tests/test*.log /tests/test*.trs ecl-16.1.2/src/bdwgc/libatomic_ops/AUTHORS000066400000000000000000000032251266352375300201330ustar00rootroot00000000000000Originally written by Hans Boehm, with some platform-dependent code imported from the Boehm-Demers-Weiser GC, where it was contributed by many others. Currently maintained by Ivan Maidanski. Andreas Tobler Andrew Agno Bradley Smith Bruce Mitchener Carlos O'Donell Daniel Grayson Doug Lea Earl Chew Emmanuel Stapf Frank Schaefer Gilles Talis Gregory Farnum H.J. Lu Hans Boehm Hans-Peter Nilsson Ian Wienand Ivan Maidanski James Cowgill Jeremy Huddleston Jim Marshall Joerg Wagner Linas Vepstas Luca Barbato Kochin Chang Maged Michael Manuel Serrano Michael Hope Patrick Marlier Pavel Raiskup Petter Urkedal Philipp Zambelli Ranko Zivojnovic Roger Hoover Sebastian Siewior Steve Capper Takashi Yoshii Thiemo Seufer Thorsten Glaser Tony Mantler Yvan Roux ecl-16.1.2/src/bdwgc/libatomic_ops/COPYING000066400000000000000000000431101266352375300201130ustar00rootroot00000000000000 GNU GENERAL PUBLIC LICENSE Version 2, June 1991 Copyright (C) 1989, 1991 Free Software Foundation, Inc. 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it. (Some other Free Software Foundation software is covered by the GNU Library General Public License instead.) You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things. To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it. For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software. Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations. Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all. The precise terms and conditions for copying, distribution and modification follow. GNU GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language. (Hereinafter, translation is included without limitation in the term "modification".) Each licensee is addressed as "you". Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does. 1. You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change. b) You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License. c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License. (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program. In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following: a) Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, b) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, c) Accompany it with the information you received as to the offer to distribute corresponding source code. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.) The source code for a work means the preferred form of the work for making modifications to it. For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code. 4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 5. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Program or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it. 6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License. 7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all. For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 9. The Free Software Foundation may publish revised and/or new versions of the General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation. 10. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA Also add information on how to contact you by electronic and paper mail. If the program is interactive, make it output a short notice like this when it starts in an interactive mode: Gnomovision version 69, Copyright (C) year name of author Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, the commands you use may be called something other than `show w' and `show c'; they could even be mouse-clicks or menu items--whatever suits your program. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the program, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the program `Gnomovision' (which makes passes at compilers) written by James Hacker. , 1 April 1989 Ty Coon, President of Vice This General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Library General Public License instead of this License. ecl-16.1.2/src/bdwgc/libatomic_ops/ChangeLog000066400000000000000000000402721266352375300206400ustar00rootroot00000000000000 == [7.5.0] (development) == * Relax shareability domain for dmb st in AO_nop_write (ARM/AArch64). * Use LLD and SCD instructions on mips64. == [7.4.4] (unset) == * Eliminate 'variable set but not used' Cppcheck warnings in test_stack. * Fix makefile preventing AO_pause undefined in libatomic_ops_gpl. * Fix missing casts to match printf format specifier in test_atomic. * Fix missing output folder on making auto-generated test files (Automake). * Minor fix of code alignment in mips AO_compare_and_swap. * Restore contribution info in ChangeLog for authors not listed in git log. == [7.4.2] 2014-05-02 == * Fix a typo in doc/README.txt (remove redundant "an" article). * Update emails/links due to project site transition. == [7.4.0] 2013-11-17 == * Add and/or/xor entries to list_atomic (tests). * Add char/short/int/AO_double_t and dd_acquire cases to list_atomic (tests). * Add compile-time assertion for size of 'standard' AO_double_t. * Add double_store pthread-based implementation and tests. * Add generalized CAS primitives of char/short/int size. * Add generalized atomic and/or/xor operations for char/short/int types. * Add generalized fetch_and_add_acquire/release (for ARMv6+). * Add generic implementation of double_load primitives. * Add information about AO_ASSUME_VISTA to README_win32. * Add internal header containing only char/short/int/AO_t atomic loads. * Add load/store primitives generalization based on CAS. * Add lock-based implementation of char/short/int_fetch_compare_and_swap. * Add makefile rule to test list_atomic.template syntax (tests). * Add missing 'const' in aligned-atomic XSIZE_load implementation. * Add missing double_compare_and_swap to generalization. * Add missing generalization of no-barrier CAS in template. * Add negative double-CAS test cases to test_atomic_include (tests). * Add test_stack to Makefile.msft (tests). * Adjust fprintf arguments type matching specifier in test_stack (tests). * Adjust included filenames in atomic_ops_malloc and test_stack. * Adjust quotes in echo command of Makefile.msft (Win32). * Always use 'mfence' for nop_full if target CPU supports SSE2 (gcc/x86). * Better document configure THREADDLLIBS variable. * Cast away volatile on dereference in CAS-based generalization primitives. * Change policy regarding version numbers ("micro" part instead of "alpha"). * Convert README to Markdown format. * Define AO_NO_PTHREADS in configure if no pthreads (Win32 and VxWorks). * Define AO_int_X operations for ARM and avr32. * Define double-wide ordered loads/stores for x86. * Define int_and/or/xor primitives in ao_t_is_int header. * Define nop_full as compiler barrier for pre-ARMv6 single-core case. * Do not duplicate BUILT_SOURCES entries in nobase_private_HEADERS (Makefile). * Do not include standard_ao_double_t.h where double-CAS is unimplemented. * Do not report absence of meaningless nop, load and store in test_atomic. * Do not use deprecated AO_T and AO_TS_T (tests). * Eliminate 'missing initializer' warning for AO_stack_t value initializer. * Eliminate 64-bit compiler warnings in atomic_ops_malloc. * Eliminate arithmetic shifts in double-CAS (gcc/arm, msftc/x86). * Eliminate warning for fetch_and_add argument in test_atomic_include (tests). * Enable Makefile.msft for Win64. * Enable build using toolchain without pthreads. * Enable double_compare_and_swap for non-cpp code (msftc/x86.h). * Enable generalization of all variants of CAS via fetch_compare_and_swap. * Enable test_stack for pthreads-w32 and Win32 with native threads. * Fix generalized AO_char/short_compare_and_swap args (missing 'unsigned'). * Fix makefile sed rule for list_atomic (tests). * Fix missing abort() usage in atomic_ops_malloc and tests on WinCE. * Generalize compare_double_and_swap_double using double_compare_and_swap. * Generalize double_load/store for x86_64 (GCC). * Generate ao_t_is_int, 'loadstore' headers from templates. * Generate generalized AO_t load/store/fetch_and_add primitives from template. * Generate ordered_loads/stores_only headers from templates. * Group all X_acquire_release_volatile.h and X_[aligned_]atomic_load_store.h. * Implement and/or/xor, AO_double_load for ARM. * Implement atomic store using direct write by default on ARMv6+. * Implement char/short/int-wide primitives using GCC built-in atomic/sync. * Implement char/short/int_fetch_and_add for msftc/x86[_64] (Win32). * Implement char/short_fetch_and_add, char/short_load for ARMv6+ (GCC). * Implement char/short_store primitives at aligned addresses for ARM. * Implement compare_double_and_swap_double for SunCC/x86. * Implement double_load/store based on guaranteed x86 access atomicity. * Implement double_store for ARMv7 using LDREXD/STREXD. * Implement load/store via simple LDR/STR for ARMv6+ (msftc). * Implement nop_full/write using 'dmb' instruction if available (gcc/arm). * Improve debug printing in test_stack (tests). * Log messages to stdout instead of stderr (tests). * Make AO_ASSUME_VISTA also enables Win98 code in msftc/x86.h (Win32). * Minimize gcc/generic-arithm template by factoring out barriers. * Move 'unsigned' keyword to XCTYPE in generalize-small template. * Move default compiler options to CFLAGS in Makefile.msft (Win32). * Move definitions of ordered loads/stores to inner separate headers. * Move gcc-generic AO_t-wide primitives to generic-small/arithm headers. * Move generalized arithmetical primitives to 'generalize-arithm' template. * Optimize AO_spin manually to minimize compiler influence on its duration. * Parameterize list_atomic template with XSIZE (tests). * Perform only few list reversals in test_malloc if AO based on pthreads. * Put autogen.sh to 'dist' package (Automake). * Remote duplicate definition of test_and_set_acquire in generalize.h. * Remove X_aligned_atomic_load_store headers and template. * Remove duplicate AO_spin and AO_pause definition in atomic_ops_stack. * Remove gcc/x86_64.h eliminating code duplication of gcc/x86.h. * Remove nested AO_USE_PTHREAD_DEFS macro check in atomic_ops.h (gcc/arm). * Remove redundant 'cc' clobber for LDREXD instruction (gcc/arm). * Remove store_full from msftc/arm.h in favor of generalized primitive. * Remove sunc/x86_64.h eliminating code duplication of sunc/x86.h. * Remove unsafe emulation-based implementation of double CAS (SunCC/x86_64). * Remove useless 'perror' call in run_parallel.h (tests). * Reorder AO_double_t union elements for AO_DOUBLE_T_INITIALIZER portability. * Replace atomic_load_store.template with atomic_load and atomic_store ones. * Replace some FIXME items with TODO in atomic_ops.c and sysdeps headers. * Specify fetch_and_add/sub1 result as unused in test_atomic (tests). * Support AArch64 (64-bit ARM) target (GCC). * Support ARMv8 target (gcc/arm). * Test double_compare_and_swap in test_atomic (tests). * Use AO_ prefix for internal functions in arm_v6.h, hppa.h. * Use __atomic GCC built-in to implement generic double-wide CAS. * Use built-in __sync CAS for double-CAS if AO_USE_SYNC_CAS_BUILTIN for x86. * Workaround GCC 4.4.3 warning reported for 'val' of list_atomic.c (tests). == [7.3alpha2] 2012-05-11 == * Add '-no-undefined' to LDFLAGS in src/Makefile.am. * Add AO_and, AO_xor atomic operations. * Add AO_fetch_compare_and_swap primitives. * Add and fill in AUTHORS, TODO files. * Add autogen.sh file. * Adjust AO_..._H macros in public headers. * Code refactoring of gcc/arm.h by introducing AO_ARM_HAVE_x macros. * Define AO macros for libatomic_ops version identification. * Do not define NDEBUG if '--enable-assertions' passed to configure. * Eliminate compiler warnings in various functions and macros. * Generalize AO_compare_and_swap primitives via AO_fetch_compare_and_swap. * Generalize acquire/release/full CAS primitives for MIPS * Implement fetch_and_add, test_and_set primitives for MIPS. * Improve Makefile for MS VC++; pass '-W3' option to MS compiler. * Include ao_t_is_int.h from atomic_ops.h after first generalization pass * Merge all Makefile.am files in src tree. * Minor code refactoring of atomic_ops.c, generic_pthread.h. * Minor configure build improvements (e.g., ensure proper autoconf version). * Place only major per-release changes description to ChangeLog (this file). * Recognize AO_PREFER_GENERALIZED macro to favor generalization over assembly. * Remove all auto-generated files except for generalize-small.h from the repo. * Remove duplicate doc/COPYING and empty NEWS files. * Replace atomic_ops_malloc static mmap-related empty functions with macros. * Replace pointer relational comparisons with non-pointer ones. * Require autoconf 2.61 instead of v2.64. * Show extra compiler warnings (GCC only). * Turn off AO primitives inlining if AO_NO_INLINE defined. * Use __builtin_expect in CAS failure loop condition checks (GCC only). == [7.2g] (unset) == * Remove inclusion of acquire_release_volatile.h on MIPS. == [7.2f] 2014-05-02 == * Fix a typo in doc/README.txt (remove redundant "an" article). * Regenerate configure files by new automake (v1.14.1), libtool (v2.4.2.418). == [7.2e] 2013-11-10 == * Fix (remove) invalid include of read_ordered.h for ARM. * Fix AM_CONFIG_HEADER in configure for autoconf-2.69-1. * Fix AO_pause sleep delay for particular argument values (Win32). * Fix ARMv7 LDREXD/STREXD double-wide operand specification (GCC/Clang). * Fix LDREXD/STREXD use for pre-Clang3.3/arm. * Fix README regarding _acquire_read barrier. * Fix XSIZE_load/store definition order in generalize-small template. * Fix asm constraint of CAS memory operand for gcc/alpha, clang-3.1/mips. * Fix asm constraints of primitives in sunc/x86.h. * Fix cmpxchg16b-based compare_double_and_swap_double for SunCC/x86_64. * Fix compare_double_and_swap_double and double_ptr_storage for gcc/x32. * Fix compare_double_and_swap_double for clang3.0/x86 in PIC mode. * Fix compare_double_and_swap_double_full definition condition in emul_cas. * Fix generalize-small template adding missed CAS-based fetch_and_add. * Fix generalized fetch_and_add function. * Fix missing compiler barrier in nop_full for uniprocessor ARM. * Fix ordered_except_wr header inclusion for s390. * Fix return type of AO_int_X primitives defined in ao_t_is_int header. * Fix return type of char/short/int_load_read() in read_ordered.h. * Fix template-based headers regeneration order in src/Makefile. * Fix typos in ao_t_is_int, atomic_ops.h, generalize.h, msftc/arm.h comments. * Fix variable type to match printf format specifier in test_stack. * Fix visibility and initial value of 'dummy' variable in atomic_ops_stack. * Terminate tests with abort after error reported. == [7.2d] 2012-08-09 == * Fix AO_compare_double_and_swap_double_full for gcc-4.2.1/x86 in PIC mode. * Fix AO_compiler_barrier missing parentheses. * Fix missing 'unsigned' for generalized AO_char/short_fetch_and_add result. == [7.2] 2012-05-11 == * Add atomic_ops.pc.in and atomic_ops-uninstalled.pc.in to pkgconfig folder. * Define and use AO_PTRDIFF_T in tests for casts between pointer and integer. * Fix AO_compare_and_swap return type for s390 and PowerPC. * Fix AO_compare_double_and_swap_double_full for gcc/x86 (PIC mode). * Fix AO_stack_push_release to workaround bug in clang-1.1/x86 compiler. * Fix AO_test_and_setXX in tests/list_atomic.template. * Fix AO_test_and_set_full (gcc/x86[_64].h) to work-around a bug in LLVM v2.7. * Fix AO_test_and_set_full on m68k. * Fix __ARM_ARCH_5__ macro handling for Android NDK (ARMv7). * Fix configure for Cygwin, mingw-w64/32. * Fix configure to define __PIC__ macro explicitly if needed (GCC). * Fix double_ptr_storage definition for GCC pre-v4 (x86_64). * Fix for x32 by removing 'q' suffix in x86-64 instructions. * Fix generalization for IA-64 (regarding AO_or, AO_..._read/write primitives) * Fix generalized AO__fetch_and_add() return type. * Fix test_atomic_include for the case of missing CAS primitive. * Fix test_malloc - allocate less memory in case of missing mmap. * Implement the basic atomic primitives for the hexagon CPU. == [7.2alpha6] 2011-06-14 == * Add missing AO_HAVE_ macros. * Add support of avr32 CPU. * Better support of various models of ARM. * Disable AO_compare_double_and_swap_double_full for SunCC x86 as not working. * Enable ARM Thumb-2 mode. * Fix AO_test_and_set_full for SunCC (x86). * Fix bugs in tests. * Fix clobbers in AO_compare_and_swap_full (x86.h). * Fix typos in identifiers and comments. * Improve AO_sync for PowerPC. * Improve make scripts (configure.ac). * Make get_mmaped() in atomic_ops_malloc.c more portable. * Support Intel compiler. * Support NaCl target. * Suppress compiler warnings in various places. * Test more predefined macros (ARM, PowerPC). * Use assembly code only for MS VC if available (x86_64). * Use built-in __sync_bool_compare_and_swap if available (x86_64). * Workaround bugs in LLVM GCC and SunCC regarding XCHG (x86, x86_64). == [7.2alpha4] 2009-12-02 == * Fix typos in comments, identifiers and documentation. * Implement AO_compare_and_swap_full for SPARC. * Refine ARM-specific code. * Refine code and comments for MS VC. * Regenerate make scripts. * Share common code for all 32-bit CPUs (MS VC). * Support DigitalMars and Watcom compilers. * Support MS VC for ARM (WinCE). * Support SH CPU. * Support win32-pthreads. * Support x86 and x86_64 for SunCC compiler. == [7.2alpha2] 2009-05-27 == * Add MIPS support. * Add better support for m68k. * Add "const" to first parameter of load calls. * Add parentheses around address argument for various macros. * Add some platform-specific documentation to INSTALL. * Add untested 64-bit support for PowerPC. * Fix AO_compare_and_swap_double_acquire. * Fix AO_int_fetch_and_add_full (x86_64). * Fix comments. * Fix s390 include paths. * Fix use of lwz instruction (PowerPC). * Refine clobbers (PowerPC). * Remove outdated info about Windows support in README. * Replace K&R-style function definition with ANSI C one. * add AO_compare_double_and_swap_double for ARMv6. * gcc/powerpc.h: Consider __NO_LWSYNC__. == [7.1] 2008-02-11 == * Add test_and_set, AO_double_compare_and_swap generalizations. * Conditionally add compare_double_and_swap_double (x86). * Conditionally add compare_double_and_swap_double (x86). * Fix AO_compare_double_and_swap_double_full (x86) for PIC mode. * Fix AO_load_acquire for PowerPC. * Fix double-width CAS (x86). * Refine README (add more warnings about data dependencies). * Refine double_ptr_storage type definition. * Support ARMv6+ in GCC. * Support ArmCC compiler. * Use _InterlockedExchangeAdd for MS VC (x86). == [7.0] 2007-06-28 == * Add 64-bit version of AO_load_acquire for PowerPC (by Luca Barbato). * Add support of x86 and x86_64 for MS VC. * Do not assume that "mfence" is always present (x86.h). * Fix ARM AO_test_and_set_full. * Include windows.h (MS VC). * Update README to reflect C++0x effort. == [1.2] 2006-07-11 == * Add prototypes to suppress compiler warnings. * Add simple VxWorks support. * Fix InterlockedCompareExchange proto usage. * Fix typos (ia64). * Include all_acquire_release_volatile.h and all_atomic_load_store.h (ia64). * Initial support for 64-bit targets. * Use "=q" for AO_test_and_set_full (x86). * Use inline assembler to generate "mfence" and byte sized XCHG. * Use new intrinsics available in MSVC 2003 and MSVC 2005. == [1.1] 2005-09-27 == * Add and use read_ordered.h. * Change function naming from "byte" to "char". * Fix AO_test_and_set for ARM; define AO_CAN_EMUL_CAS. == [1.0] 2005-03-21 == * Add atomic_ops primitives for different sized data. * Add compare_double_and_swap_double and compare_and_swap_double. * Add gcc/cris.h (originally comes from Hans-Peter Nilsson). * Add gcc/m68k.h (contributed by Tony Mantler). * Add gcc/powerpc.h (with help of Maged Michael, Doug Lea, Roger Hoover). * Add initial support for atomic_ops for VC++/Windows/X86 and HP/UX. * Add minimal support for the Sun SPARC compiler. * Add support for platforms that require out-of-line assembly code. * Add support of int-wide operations on platforms with int-sized pointers. * Added libatomic_ops_gpl library with support for lock-free stack and malloc. * Change atomic_ops include file structure. * Change most platforms to use byte-wide test-and-set locations. * Define AO_CLEAR, __ldcw[_align] macros in gcc/hppa.h (by Carlos O'Donell). * Fix various bugs. * Install under "atomic_ops" instead of "ao". * Remove compiler_barrier workaround for gcc 3.4+. * Renamed various types to end in _t. * Replace AO_HAVE_NOP_FULL with AO_HAVE_nop_full (by Ranko Zivojnovic). * Use autoconf, automake. ecl-16.1.2/src/bdwgc/libatomic_ops/Makefile.am000066400000000000000000000004031266352375300211120ustar00rootroot00000000000000SUBDIRS = src doc tests ACLOCAL_AMFLAGS = -I m4 pkgconfigdir = $(libdir)/pkgconfig pkgconfig_DATA = pkgconfig/atomic_ops.pc noinst_DATA = pkgconfig/atomic_ops-uninstalled.pc dist_pkgdata_DATA = COPYING README.md EXTRA_DIST = autogen.sh #distclean-local: ecl-16.1.2/src/bdwgc/libatomic_ops/Makefile.in000066400000000000000000000711021266352375300211270ustar00rootroot00000000000000# Makefile.in generated by automake 1.15 from Makefile.am. # @configure_input@ # Copyright (C) 1994-2014 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__is_gnu_make = { \ if test -z '$(MAKELEVEL)'; then \ false; \ elif test -n '$(MAKE_HOST)'; then \ true; \ elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \ true; \ else \ false; \ fi; \ } am__make_running_with_option = \ case $${target_option-} in \ ?) ;; \ *) echo "am__make_running_with_option: internal error: invalid" \ "target option '$${target_option-}' specified" >&2; \ exit 1;; \ esac; \ has_opt=no; \ sane_makeflags=$$MAKEFLAGS; \ if $(am__is_gnu_make); then \ sane_makeflags=$$MFLAGS; \ else \ case $$MAKEFLAGS in \ *\\[\ \ ]*) \ bs=\\; \ sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \ | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \ esac; \ fi; \ skip_next=no; \ strip_trailopt () \ { \ flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \ }; \ for flg in $$sane_makeflags; do \ test $$skip_next = yes && { skip_next=no; continue; }; \ case $$flg in \ *=*|--*) continue;; \ -*I) strip_trailopt 'I'; skip_next=yes;; \ -*I?*) strip_trailopt 'I';; \ -*O) strip_trailopt 'O'; skip_next=yes;; \ -*O?*) strip_trailopt 'O';; \ -*l) strip_trailopt 'l'; skip_next=yes;; \ -*l?*) strip_trailopt 'l';; \ -[dEDm]) skip_next=yes;; \ -[JT]) skip_next=yes;; \ esac; \ case $$flg in \ *$$target_option*) has_opt=yes; break;; \ esac; \ done; \ test $$has_opt = yes am__make_dryrun = (target_option=n; $(am__make_running_with_option)) am__make_keepgoing = (target_option=k; $(am__make_running_with_option)) 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@ target_triplet = @target@ subdir = . 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) DIST_COMMON = $(srcdir)/Makefile.am $(top_srcdir)/configure \ $(am__configure_deps) $(dist_pkgdata_DATA) $(am__DIST_COMMON) am__CONFIG_DISTCLEAN_FILES = config.status config.cache config.log \ configure.lineno config.status.lineno mkinstalldirs = $(install_sh) -d CONFIG_HEADER = $(top_builddir)/src/config.h CONFIG_CLEAN_FILES = pkgconfig/atomic_ops.pc \ pkgconfig/atomic_ops-uninstalled.pc CONFIG_CLEAN_VPATH_FILES = 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 = SOURCES = DIST_SOURCES = RECURSIVE_TARGETS = all-recursive check-recursive cscopelist-recursive \ ctags-recursive dvi-recursive html-recursive info-recursive \ install-data-recursive install-dvi-recursive \ install-exec-recursive install-html-recursive \ install-info-recursive install-pdf-recursive \ install-ps-recursive install-recursive installcheck-recursive \ installdirs-recursive pdf-recursive ps-recursive \ tags-recursive uninstall-recursive am__can_run_installinfo = \ case $$AM_UPDATE_INFO_DIR in \ n|no|NO) false;; \ *) (install-info --version) >/dev/null 2>&1;; \ esac 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)$(pkgdatadir)" \ "$(DESTDIR)$(pkgconfigdir)" DATA = $(dist_pkgdata_DATA) $(noinst_DATA) $(pkgconfig_DATA) RECURSIVE_CLEAN_TARGETS = mostlyclean-recursive clean-recursive \ distclean-recursive maintainer-clean-recursive am__recursive_targets = \ $(RECURSIVE_TARGETS) \ $(RECURSIVE_CLEAN_TARGETS) \ $(am__extra_recursive_targets) AM_RECURSIVE_TARGETS = $(am__recursive_targets:-recursive=) TAGS CTAGS \ cscope distdir dist dist-all distcheck am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP) # Read a list of newline-separated strings from the standard input, # and print each of them once, without duplicates. Input order is # *not* preserved. am__uniquify_input = $(AWK) '\ BEGIN { nonempty = 0; } \ { items[$$0] = 1; nonempty = 1; } \ END { if (nonempty) { for (i in items) print i; }; } \ ' # Make sure the list of sources is unique. This is necessary because, # e.g., the same source file might be shared among _SOURCES variables # for different programs/libraries. am__define_uniq_tagged_files = \ list='$(am__tagged_files)'; \ unique=`for i in $$list; do \ if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ done | $(am__uniquify_input)` ETAGS = etags CTAGS = ctags CSCOPE = cscope DIST_SUBDIRS = $(SUBDIRS) am__DIST_COMMON = $(srcdir)/Makefile.in $(top_srcdir)/../compile \ $(top_srcdir)/../config.guess $(top_srcdir)/../config.sub \ $(top_srcdir)/../install-sh $(top_srcdir)/../ltmain.sh \ $(top_srcdir)/../missing \ $(top_srcdir)/pkgconfig/atomic_ops-uninstalled.pc.in \ $(top_srcdir)/pkgconfig/atomic_ops.pc.in AUTHORS COPYING \ ChangeLog TODO 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) am__relativize = \ dir0=`pwd`; \ sed_first='s,^\([^/]*\)/.*$$,\1,'; \ sed_rest='s,^[^/]*/*,,'; \ sed_last='s,^.*/\([^/]*\)$$,\1,'; \ sed_butlast='s,/*[^/]*$$,,'; \ while test -n "$$dir1"; do \ first=`echo "$$dir1" | sed -e "$$sed_first"`; \ if test "$$first" != "."; then \ if test "$$first" = ".."; then \ dir2=`echo "$$dir0" | sed -e "$$sed_last"`/"$$dir2"; \ dir0=`echo "$$dir0" | sed -e "$$sed_butlast"`; \ else \ first2=`echo "$$dir2" | sed -e "$$sed_first"`; \ if test "$$first2" = "$$first"; then \ dir2=`echo "$$dir2" | sed -e "$$sed_rest"`; \ else \ dir2="../$$dir2"; \ fi; \ dir0="$$dir0"/"$$first"; \ fi; \ fi; \ dir1=`echo "$$dir1" | sed -e "$$sed_rest"`; \ done; \ reldir="$$dir2" DIST_ARCHIVES = $(distdir).tar.gz $(distdir).tar.bz2 GZIP_ENV = --best DIST_TARGETS = dist-bzip2 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@ AUTOCONF = @AUTOCONF@ AUTOHEADER = @AUTOHEADER@ AUTOMAKE = @AUTOMAKE@ AWK = @AWK@ CC = @CC@ CCAS = @CCAS@ CCASDEPMODE = @CCASDEPMODE@ CCASFLAGS = @CCASFLAGS@ CCDEPMODE = @CCDEPMODE@ CFLAGS = @CFLAGS@ CPP = @CPP@ CPPFLAGS = @CPPFLAGS@ 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@ LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@ 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@ PICFLAG = @PICFLAG@ RANLIB = @RANLIB@ SED = @SED@ SET_MAKE = @SET_MAKE@ SHELL = @SHELL@ STRIP = @STRIP@ THREADDLLIBS = @THREADDLLIBS@ 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_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 = @target@ target_alias = @target_alias@ target_cpu = @target_cpu@ target_os = @target_os@ target_vendor = @target_vendor@ top_build_prefix = @top_build_prefix@ top_builddir = @top_builddir@ top_srcdir = @top_srcdir@ SUBDIRS = src doc tests ACLOCAL_AMFLAGS = -I m4 pkgconfigdir = $(libdir)/pkgconfig pkgconfig_DATA = pkgconfig/atomic_ops.pc noinst_DATA = pkgconfig/atomic_ops-uninstalled.pc dist_pkgdata_DATA = COPYING README.md EXTRA_DIST = autogen.sh all: all-recursive .SUFFIXES: 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 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): pkgconfig/atomic_ops.pc: $(top_builddir)/config.status $(top_srcdir)/pkgconfig/atomic_ops.pc.in cd $(top_builddir) && $(SHELL) ./config.status $@ pkgconfig/atomic_ops-uninstalled.pc: $(top_builddir)/config.status $(top_srcdir)/pkgconfig/atomic_ops-uninstalled.pc.in cd $(top_builddir) && $(SHELL) ./config.status $@ mostlyclean-libtool: -rm -f *.lo clean-libtool: -rm -rf .libs _libs distclean-libtool: -rm -f libtool config.lt install-dist_pkgdataDATA: $(dist_pkgdata_DATA) @$(NORMAL_INSTALL) @list='$(dist_pkgdata_DATA)'; test -n "$(pkgdatadir)" || list=; \ if test -n "$$list"; then \ echo " $(MKDIR_P) '$(DESTDIR)$(pkgdatadir)'"; \ $(MKDIR_P) "$(DESTDIR)$(pkgdatadir)" || 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)$(pkgdatadir)'"; \ $(INSTALL_DATA) $$files "$(DESTDIR)$(pkgdatadir)" || exit $$?; \ done uninstall-dist_pkgdataDATA: @$(NORMAL_UNINSTALL) @list='$(dist_pkgdata_DATA)'; test -n "$(pkgdatadir)" || list=; \ files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \ dir='$(DESTDIR)$(pkgdatadir)'; $(am__uninstall_files_from_dir) 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) # This directory's subdirectories are mostly independent; you can cd # into them and run 'make' without going through this Makefile. # To change the values of 'make' variables: instead of editing Makefiles, # (1) if the variable is set in 'config.status', edit 'config.status' # (which will cause the Makefiles to be regenerated when you run 'make'); # (2) otherwise, pass the desired values on the 'make' command line. $(am__recursive_targets): @fail=; \ if $(am__make_keepgoing); then \ failcom='fail=yes'; \ else \ failcom='exit 1'; \ fi; \ dot_seen=no; \ target=`echo $@ | sed s/-recursive//`; \ case "$@" in \ distclean-* | maintainer-clean-*) list='$(DIST_SUBDIRS)' ;; \ *) list='$(SUBDIRS)' ;; \ esac; \ for subdir in $$list; do \ echo "Making $$target in $$subdir"; \ if test "$$subdir" = "."; then \ dot_seen=yes; \ local_target="$$target-am"; \ else \ local_target="$$target"; \ fi; \ ($(am__cd) $$subdir && $(MAKE) $(AM_MAKEFLAGS) $$local_target) \ || eval $$failcom; \ done; \ if test "$$dot_seen" = "no"; then \ $(MAKE) $(AM_MAKEFLAGS) "$$target-am" || exit 1; \ fi; test -z "$$fail" ID: $(am__tagged_files) $(am__define_uniq_tagged_files); mkid -fID $$unique tags: tags-recursive TAGS: tags tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) set x; \ here=`pwd`; \ if ($(ETAGS) --etags-include --version) >/dev/null 2>&1; then \ include_option=--etags-include; \ empty_fix=.; \ else \ include_option=--include; \ empty_fix=; \ fi; \ list='$(SUBDIRS)'; for subdir in $$list; do \ if test "$$subdir" = .; then :; else \ test ! -f $$subdir/TAGS || \ set "$$@" "$$include_option=$$here/$$subdir/TAGS"; \ fi; \ done; \ $(am__define_uniq_tagged_files); \ 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-recursive CTAGS: ctags ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) $(am__define_uniq_tagged_files); \ 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: cscopelist-recursive cscopelist-am: $(am__tagged_files) list='$(am__tagged_files)'; \ 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 @list='$(DIST_SUBDIRS)'; for subdir in $$list; do \ if test "$$subdir" = .; then :; else \ $(am__make_dryrun) \ || test -d "$(distdir)/$$subdir" \ || $(MKDIR_P) "$(distdir)/$$subdir" \ || exit 1; \ dir1=$$subdir; dir2="$(distdir)/$$subdir"; \ $(am__relativize); \ new_distdir=$$reldir; \ dir1=$$subdir; dir2="$(top_distdir)"; \ $(am__relativize); \ new_top_distdir=$$reldir; \ echo " (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) top_distdir="$$new_top_distdir" distdir="$$new_distdir" \\"; \ echo " am__remove_distdir=: am__skip_length_check=: am__skip_mode_fix=: distdir)"; \ ($(am__cd) $$subdir && \ $(MAKE) $(AM_MAKEFLAGS) \ top_distdir="$$new_top_distdir" \ distdir="$$new_distdir" \ am__remove_distdir=: \ am__skip_length_check=: \ am__skip_mode_fix=: \ distdir) \ || 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 @echo WARNING: "Support for distribution archives compressed with" \ "legacy program 'compress' is deprecated." >&2 @echo WARNING: "It will be removed altogether in Automake 2.0" >&2 tardir=$(distdir) && $(am__tar) | compress -c >$(distdir).tar.Z $(am__post_remove_distdir) dist-shar: distdir @echo WARNING: "Support for shar distribution archives is" \ "deprecated." >&2 @echo WARNING: "It will be removed altogether in Automake 2.0" >&2 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 $(distdir)/_build/sub $(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/sub \ && ../../configure \ $(AM_DISTCHECK_CONFIGURE_FLAGS) \ $(DISTCHECK_CONFIGURE_FLAGS) \ --srcdir=../.. --prefix="$$dc_install_base" \ && $(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-recursive all-am: Makefile $(DATA) installdirs: installdirs-recursive installdirs-am: for dir in "$(DESTDIR)$(pkgdatadir)" "$(DESTDIR)$(pkgconfigdir)"; do \ test -z "$$dir" || $(MKDIR_P) "$$dir"; \ done install: install-recursive install-exec: install-exec-recursive install-data: install-data-recursive uninstall: uninstall-recursive install-am: all-am @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am installcheck: installcheck-recursive 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) 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-recursive clean-am: clean-generic clean-libtool mostlyclean-am distclean: distclean-recursive -rm -f $(am__CONFIG_DISTCLEAN_FILES) -rm -f Makefile distclean-am: clean-am distclean-generic distclean-libtool \ distclean-tags dvi: dvi-recursive dvi-am: html: html-recursive html-am: info: info-recursive info-am: install-data-am: install-dist_pkgdataDATA install-pkgconfigDATA install-dvi: install-dvi-recursive install-dvi-am: install-exec-am: install-html: install-html-recursive install-html-am: install-info: install-info-recursive install-info-am: install-man: install-pdf: install-pdf-recursive install-pdf-am: install-ps: install-ps-recursive install-ps-am: installcheck-am: maintainer-clean: maintainer-clean-recursive -rm -f $(am__CONFIG_DISTCLEAN_FILES) -rm -rf $(top_srcdir)/autom4te.cache -rm -f Makefile maintainer-clean-am: distclean-am maintainer-clean-generic mostlyclean: mostlyclean-recursive mostlyclean-am: mostlyclean-generic mostlyclean-libtool pdf: pdf-recursive pdf-am: ps: ps-recursive ps-am: uninstall-am: uninstall-dist_pkgdataDATA uninstall-pkgconfigDATA .MAKE: $(am__recursive_targets) install-am install-strip .PHONY: $(am__recursive_targets) CTAGS GTAGS TAGS all all-am \ am--refresh check check-am clean clean-cscope clean-generic \ clean-libtool cscope cscopelist-am ctags ctags-am dist \ dist-all dist-bzip2 dist-gzip dist-lzip dist-shar dist-tarZ \ dist-xz dist-zip distcheck distclean distclean-generic \ 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-dist_pkgdataDATA install-dvi install-dvi-am \ install-exec install-exec-am install-html install-html-am \ install-info install-info-am install-man install-pdf \ install-pdf-am install-pkgconfigDATA install-ps install-ps-am \ install-strip installcheck installcheck-am installdirs \ installdirs-am maintainer-clean maintainer-clean-generic \ mostlyclean mostlyclean-generic mostlyclean-libtool pdf pdf-am \ ps ps-am tags tags-am uninstall uninstall-am \ uninstall-dist_pkgdataDATA uninstall-pkgconfigDATA .PRECIOUS: Makefile #distclean-local: # 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: ecl-16.1.2/src/bdwgc/libatomic_ops/README.md000066400000000000000000000042231266352375300203410ustar00rootroot00000000000000# The atomic_ops library (libatomic_ops) This is version 7.5.0 of libatomic_ops. You might find a more recent version [here](http://www.hboehm.info/gc/), or [here](https://github.com/ivmai/libatomic_ops). ## Overview This package provides semi-portable access to hardware-provided atomic memory update operations on a number architectures. These might allow you to write code: * That does more interesting things in signal handlers. * Makes more effective use of multiprocessors by allowing you to write clever lock-free code. Note that such code is very difficult to get right, and will unavoidably be less portable than lock-based code. It is also not always faster than lock-based code. But it may occasionally be a large performance win. * To experiment with new and much better thread programming paradigms, etc. For details and licensing restrictions see the files in the "doc" subdirectory. Please address bug reports to [mailing list](mailto:bdwgc@lists.opendylan.org). ## Installation and Usage The configuration and build scripts for this package were generated by Automake/Autoconf. "./configure; make; sudo make install" in this directory should work. For a more customized build, see the output of "./configure --help". Note that much of the content of this library is in the header files. However, two small libraries are built and installed: * libatomic_ops.a is a support library, which is not needed on some platforms. This is intended to be usable, under some mild restrictions, in free or proprietary code, as are all the header files. See doc/LICENSING.txt. * libatomic_ops_gpl.a contains some higher level facilities. This code is currently covered by the GPL. The contents currently correspond to the headers atomic_ops_stack.h and atomic_ops_malloc.h. ## Platform Specific Notes Win32/64: src/Makefile.msft contains a very simple Makefile for building and running tests and building the gpl library. The core atomic_ops implementation is entirely in header files. HP-UX/PA-RISC: aCC -Ae won't work as a C compiler, since it doesn't support inline assembly code. Use cc. ## Copyright & Warranty See doc/LICENSING.txt file. ecl-16.1.2/src/bdwgc/libatomic_ops/TODO000066400000000000000000000005141266352375300175510ustar00rootroot00000000000000== TODO tasks == Add C++0x ATM (atomic memory operations) layer. == FIXME tasks == RHELinux6/POWER7 (gcc-4.4.7-3/ppc64), Fedora16/POWER7 (gcc-4.6.2-1/ppc64), Debian/powerpc (gcc 4.6.3-7): test_stack failed (Debian Bug #680100). Debian/m68k (Linux 3.2.0-2-atari): test_stack failed (Bus error), regression (Debian Bug #680066). ecl-16.1.2/src/bdwgc/libatomic_ops/aclocal.m4000066400000000000000000001272521266352375300207320ustar00rootroot00000000000000# generated automatically by aclocal 1.15 -*- Autoconf -*- # Copyright (C) 1996-2014 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_CONFIG_MACRO_DIRS], [m4_defun([_AM_CONFIG_MACRO_DIRS], [])m4_defun([AC_CONFIG_MACRO_DIRS], [_AM_CONFIG_MACRO_DIRS($@)])]) 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-2014 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. # 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.15' 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.15], [], [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.15])dnl m4_ifndef([AC_AUTOCONF_VERSION], [m4_copy([m4_PACKAGE_VERSION], [AC_AUTOCONF_VERSION])])dnl _AM_AUTOCONF_VERSION(m4_defn([AC_AUTOCONF_VERSION]))]) # Figure out how to run the assembler. -*- Autoconf -*- # Copyright (C) 2001-2014 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. # AM_PROG_AS # ---------- AC_DEFUN([AM_PROG_AS], [# By default we simply use the C compiler to build assembly code. AC_REQUIRE([AC_PROG_CC]) test "${CCAS+set}" = set || CCAS=$CC test "${CCASFLAGS+set}" = set || CCASFLAGS=$CFLAGS AC_ARG_VAR([CCAS], [assembler compiler command (defaults to CC)]) AC_ARG_VAR([CCASFLAGS], [assembler compiler flags (defaults to CFLAGS)]) _AM_IF_OPTION([no-dependencies],, [_AM_DEPENDENCIES([CCAS])])dnl ]) # AM_AUX_DIR_EXPAND -*- Autoconf -*- # Copyright (C) 2001-2014 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. # 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], [AC_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT])dnl # Expand $ac_aux_dir to an absolute path. am_aux_dir=`cd "$ac_aux_dir" && pwd` ]) # AM_CONDITIONAL -*- Autoconf -*- # Copyright (C) 1997-2014 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. # 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-2014 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. # 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-2014 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. # _AM_OUTPUT_DEPENDENCY_COMMANDS # ------------------------------ AC_DEFUN([_AM_OUTPUT_DEPENDENCY_COMMANDS], [{ # Older Autoconf 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-2014 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 macro actually does too much. Some checks are only needed if # your package does certain things. But this isn't really a big deal. dnl Redefine AC_PROG_CC to automatically invoke _AM_PROG_CC_C_O. m4_define([AC_PROG_CC], m4_defn([AC_PROG_CC]) [_AM_PROG_CC_C_O ]) # 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.65])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.]) 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 (and possibly the TAP driver). 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 AC_PROVIDE_IFELSE([AC_PROG_OBJCXX], [_AM_DEPENDENCIES([OBJCXX])], [m4_define([AC_PROG_OBJCXX], m4_defn([AC_PROG_OBJCXX])[_AM_DEPENDENCIES([OBJCXX])])])dnl ]) AC_REQUIRE([AM_SILENT_RULES])dnl dnl The testsuite driver may need to know about EXEEXT, so add the dnl 'am__EXEEXT' conditional if _AM_COMPILER_EXEEXT was seen. This dnl macro 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 # POSIX will say in a future version that running "rm -f" with no argument # is OK; and we want to be able to make that assumption in our Makefile # recipes. So use an aggressive probe to check that the usage we want is # actually supported "in the wild" to an acceptable degree. # See automake bug#10828. # To make any issue more visible, cause the running configure to be aborted # by default if the 'rm' program in use doesn't match our expectations; the # user can still override this though. if rm -f && rm -fr && rm -rf; then : OK; else cat >&2 <<'END' Oops! Your 'rm' program seems unable to run without file operands specified on the command line, even when the '-f' option is present. This is contrary to the behaviour of most rm programs out there, and not conforming with the upcoming POSIX standard: Please tell bug-automake@gnu.org about your system, including the value of your $PATH and any error possibly output before this message. This can help us improve future automake versions. END if test x"$ACCEPT_INFERIOR_RM_PROGRAM" = x"yes"; then echo 'Configuration will proceed anyway, since you have set the' >&2 echo 'ACCEPT_INFERIOR_RM_PROGRAM variable to "yes"' >&2 echo >&2 else cat >&2 <<'END' Aborting the configuration process, to ensure you take notice of the issue. You can download and install GNU coreutils to get an 'rm' implementation that behaves properly: . If you want to complete the configuration process using your problematic 'rm' anyway, export the environment variable ACCEPT_INFERIOR_RM_PROGRAM to "yes", and re-run configure. END AC_MSG_ERROR([Your 'rm' program is bad, sorry.]) fi fi dnl The trailing newline in this macro's definition is deliberate, for dnl backward compatibility and to allow trailing 'dnl'-style comments dnl after the AM_INIT_AUTOMAKE invocation. See automake bug#16841. ]) 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-2014 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. # 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+set}" != 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-2014 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. # 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-2014 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. # 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 ] ) # Check to see how 'make' treats includes. -*- Autoconf -*- # Copyright (C) 2001-2014 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. # 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-2014 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. # 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 is modern enough. # If it is, 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 --is-lightweight"; then am_missing_run="$MISSING " else am_missing_run= AC_MSG_WARN(['missing' script is too old or missing]) fi ]) # Helper functions for option handling. -*- Autoconf -*- # Copyright (C) 2001-2014 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. # _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])]) # Copyright (C) 1999-2014 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. # _AM_PROG_CC_C_O # --------------- # Like AC_PROG_CC_C_O, but changed for automake. We rewrite AC_PROG_CC # to automatically call this. AC_DEFUN([_AM_PROG_CC_C_O], [AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl AC_REQUIRE_AUX_FILE([compile])dnl AC_LANG_PUSH([C])dnl AC_CACHE_CHECK( [whether $CC understands -c and -o together], [am_cv_prog_cc_c_o], [AC_LANG_CONFTEST([AC_LANG_PROGRAM([])]) # Make sure it works both with $CC and with simple cc. # Following AC_PROG_CC_C_O, we do the test twice because some # compilers refuse to overwrite an existing .o file with -o, # though they will create one. am_cv_prog_cc_c_o=yes for am_i in 1 2; do if AM_RUN_LOG([$CC -c conftest.$ac_ext -o conftest2.$ac_objext]) \ && test -f conftest2.$ac_objext; then : OK else am_cv_prog_cc_c_o=no break fi done rm -f core conftest* unset am_i]) if test "$am_cv_prog_cc_c_o" != yes; then # Losing compiler, so override with the script. # FIXME: It is wrong to rewrite CC. # 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__CC in this case, # and then we could set am__CC="\$(top_srcdir)/compile \$(CC)" CC="$am_aux_dir/compile $CC" fi AC_LANG_POP([C])]) # For backward compatibility. AC_DEFUN_ONCE([AM_PROG_CC_C_O], [AC_REQUIRE([AC_PROG_CC])]) # Copyright (C) 2001-2014 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. # AM_RUN_LOG(COMMAND) # ------------------- # Run COMMAND, save the exit status in ac_status, and log it. # (This has been adapted from Autoconf's _AC_RUN_LOG macro.) AC_DEFUN([AM_RUN_LOG], [{ echo "$as_me:$LINENO: $1" >&AS_MESSAGE_LOG_FD ($1) >&AS_MESSAGE_LOG_FD 2>&AS_MESSAGE_LOG_FD ac_status=$? echo "$as_me:$LINENO: \$? = $ac_status" >&AS_MESSAGE_LOG_FD (exit $ac_status); }]) # Check to make sure that the build environment is sane. -*- Autoconf -*- # Copyright (C) 1996-2014 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. # 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-2014 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. # 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-2014 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. # 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-2014 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. # _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-2014 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. # _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}']) # We'll loop over all known methods to create a tar archive until one works. _am_tools='gnutar m4_if([$1], [ustar], [plaintar]) pax cpio none' m4_if([$1], [v7], [am__tar='$${TAR-tar} chof - "$$tardir"' am__untar='$${TAR-tar} xf -'], [m4_case([$1], [ustar], [# The POSIX 1988 'ustar' format is defined with fixed-size fields. # There is notably a 21 bits limit for the UID and the GID. In fact, # the 'pax' utility can hang on bigger UID/GID (see automake bug#8343 # and bug#13588). am_max_uid=2097151 # 2^21 - 1 am_max_gid=$am_max_uid # The $UID and $GID variables are not portable, so we need to resort # to the POSIX-mandated id(1) utility. Errors in the 'id' calls # below are definitely unexpected, so allow the users to see them # (that is, avoid stderr redirection). am_uid=`id -u || echo unknown` am_gid=`id -g || echo unknown` AC_MSG_CHECKING([whether UID '$am_uid' is supported by ustar format]) if test $am_uid -le $am_max_uid; then AC_MSG_RESULT([yes]) else AC_MSG_RESULT([no]) _am_tools=none fi AC_MSG_CHECKING([whether GID '$am_gid' is supported by ustar format]) if test $am_gid -le $am_max_gid; then AC_MSG_RESULT([yes]) else AC_MSG_RESULT([no]) _am_tools=none fi], [pax], [], [m4_fatal([Unknown tar format])]) AC_MSG_CHECKING([how to create a $1 tar archive]) # Go ahead even if we have the value already cached. We do so because we # need to set the values for the 'am__tar' and 'am__untar' variables. _am_tools=${am_cv_prog_tar_$1-$_am_tools} 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]) ecl-16.1.2/src/bdwgc/libatomic_ops/autogen.sh000077500000000000000000000003271266352375300210640ustar00rootroot00000000000000#!/bin/sh set -e # This script creates (or regenerates) configure (as well as aclocal.m4, # config.h.in, Makefile.in, etc.) missing in the source repository. autoreconf -i echo echo "Ready to run './configure'." ecl-16.1.2/src/bdwgc/libatomic_ops/configure000077500000000000000000015451131266352375300210020ustar00rootroot00000000000000#! /bin/sh # Guess values for system-dependent variables and create Makefiles. # Generated by GNU Autoconf 2.69 for libatomic_ops 7.5.0. # # Report bugs to . # # # 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 and $0: bdwgc@lists.opendylan.org about your system, including $0: any error possibly output before this message. Then $0: install a modern shell, or manually run the script $0: 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='libatomic_ops' PACKAGE_TARNAME='libatomic_ops' PACKAGE_VERSION='7.5.0' PACKAGE_STRING='libatomic_ops 7.5.0' PACKAGE_BUGREPORT='bdwgc@lists.opendylan.org' PACKAGE_URL='' ac_unique_file="src/atomic_ops.c" # 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_header_list= ac_subst_vars='am__EXEEXT_FALSE am__EXEEXT_TRUE LTLIBOBJS LIBOBJS NEED_ASM_FALSE NEED_ASM_TRUE HAVE_PTHREAD_H_FALSE HAVE_PTHREAD_H_TRUE THREADDLLIBS PICFLAG CPP LT_SYS_LIBRARY_PATH OTOOL64 OTOOL LIPO NMEDIT DSYMUTIL MANIFEST_TOOL RANLIB ac_ct_AR AR DLLTOOL OBJDUMP LN_S NM ac_ct_DUMPBIN DUMPBIN LD FGREP EGREP GREP SED LIBTOOL am__fastdepCCAS_FALSE am__fastdepCCAS_TRUE CCASDEPMODE CCASFLAGS CCAS 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 MAINT MAINTAINER_MODE_FALSE MAINTAINER_MODE_TRUE 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_os target_vendor target_cpu target host_os host_vendor host_cpu host build_os build_vendor build_cpu build 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_maintainer_mode enable_dependency_tracking enable_shared enable_static with_pic enable_fast_install with_aix_soname with_gnu_ld with_sysroot enable_libtool_lock enable_werror enable_assertions ' ac_precious_vars='build_alias host_alias target_alias CC CFLAGS LDFLAGS LIBS CPPFLAGS CCAS CCASFLAGS LT_SYS_LIBRARY_PATH CPP' # 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 libatomic_ops 7.5.0 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/libatomic_ops] --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] --target=TARGET configure for building compilers for TARGET [HOST] _ACEOF fi if test -n "$ac_init_help"; then case $ac_init_help in short | recursive ) echo "Configuration of libatomic_ops 7.5.0:";; 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-maintainer-mode enable make rules and dependencies not useful (and sometimes confusing) to the casual installer --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-werror Pass -Werror to the C compiler --enable-assertions Assertion checking Optional Packages: --with-PACKAGE[=ARG] use PACKAGE [ARG=yes] --without-PACKAGE do not use PACKAGE (same as --with-PACKAGE=no) --with-pic[=PKGS] try to use only PIC/non-PIC objects [default=use both] --with-aix-soname=aix|svr4|both shared library versioning (aka "SONAME") variant to provide on AIX, [default=aix]. --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 CCAS assembler compiler command (defaults to CC) CCASFLAGS assembler compiler flags (defaults to CFLAGS) LT_SYS_LIBRARY_PATH User-defined run-time library search path. CPP 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 . _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 libatomic_ops configure 7.5.0 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 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 libatomic_ops $as_me 7.5.0, 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 as_fn_append ac_header_list " stdlib.h" as_fn_append ac_header_list " unistd.h" as_fn_append ac_header_list " sys/param.h" # 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 ac_aux_dir= for ac_dir in "$srcdir" "$srcdir/.." "$srcdir/../.."; do if test -f "$ac_dir/install-sh"; then ac_aux_dir=$ac_dir ac_install_sh="$ac_aux_dir/install-sh -c" break elif test -f "$ac_dir/install.sh"; then ac_aux_dir=$ac_dir ac_install_sh="$ac_aux_dir/install.sh -c" break 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 \"$srcdir\" \"$srcdir/..\" \"$srcdir/../..\"" "$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. # 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 { $as_echo "$as_me:${as_lineno-$LINENO}: checking target system type" >&5 $as_echo_n "checking target system type... " >&6; } if ${ac_cv_target+:} false; then : $as_echo_n "(cached) " >&6 else if test "x$target_alias" = x; then ac_cv_target=$ac_cv_host else ac_cv_target=`$SHELL "$ac_aux_dir/config.sub" $target_alias` || as_fn_error $? "$SHELL $ac_aux_dir/config.sub $target_alias failed" "$LINENO" 5 fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_target" >&5 $as_echo "$ac_cv_target" >&6; } case $ac_cv_target in *-*-*) ;; *) as_fn_error $? "invalid value of canonical target" "$LINENO" 5;; esac target=$ac_cv_target ac_save_IFS=$IFS; IFS='-' set x $ac_cv_target shift target_cpu=$1 target_vendor=$2 shift; shift # Remember, the first character of IFS is used to create $*, # except with old shells: target_os=$* IFS=$ac_save_IFS case $target_os in *\ *) target_os=`echo "$target_os" | sed 's/ /-/g'`;; esac # The aliases save the names the user supplied, while $host etc. # will get canonicalized. test -n "$target_alias" && test "$program_prefix$program_suffix$program_transform_name" = \ NONENONEs,x,x, && program_prefix=${target_alias}- am__api_version='1.15' # 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 --is-lightweight"; then am_missing_run="$MISSING " 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+set}" != 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='libatomic_ops' VERSION='7.5.0' 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 (and possibly the TAP driver). 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}' # We'll loop over all known methods to create a tar archive until one works. _am_tools='gnutar pax cpio none' am__tar='$${TAR-tar} chof - "$$tardir"' am__untar='$${TAR-tar} xf -' # POSIX will say in a future version that running "rm -f" with no argument # is OK; and we want to be able to make that assumption in our Makefile # recipes. So use an aggressive probe to check that the usage we want is # actually supported "in the wild" to an acceptable degree. # See automake bug#10828. # To make any issue more visible, cause the running configure to be aborted # by default if the 'rm' program in use doesn't match our expectations; the # user can still override this though. if rm -f && rm -fr && rm -rf; then : OK; else cat >&2 <<'END' Oops! Your 'rm' program seems unable to run without file operands specified on the command line, even when the '-f' option is present. This is contrary to the behaviour of most rm programs out there, and not conforming with the upcoming POSIX standard: Please tell bug-automake@gnu.org about your system, including the value of your $PATH and any error possibly output before this message. This can help us improve future automake versions. END if test x"$ACCEPT_INFERIOR_RM_PROGRAM" = x"yes"; then echo 'Configuration will proceed anyway, since you have set the' >&2 echo 'ACCEPT_INFERIOR_RM_PROGRAM variable to "yes"' >&2 echo >&2 else cat >&2 <<'END' Aborting the configuration process, to ensure you take notice of the issue. You can download and install GNU coreutils to get an 'rm' implementation that behaves properly: . If you want to complete the configuration process using your problematic 'rm' anyway, export the environment variable ACCEPT_INFERIOR_RM_PROGRAM to "yes", and re-run configure. END as_fn_error $? "Your 'rm' program is bad, sorry." "$LINENO" 5 fi fi { $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 ac_config_headers="$ac_config_headers src/config.h" # Checks for programs. 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 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 $CC understands -c and -o together" >&5 $as_echo_n "checking whether $CC understands -c and -o together... " >&6; } if ${am_cv_prog_cc_c_o+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF # Make sure it works both with $CC and with simple cc. # Following AC_PROG_CC_C_O, we do the test twice because some # compilers refuse to overwrite an existing .o file with -o, # though they will create one. am_cv_prog_cc_c_o=yes for am_i in 1 2; do if { echo "$as_me:$LINENO: $CC -c conftest.$ac_ext -o conftest2.$ac_objext" >&5 ($CC -c conftest.$ac_ext -o conftest2.$ac_objext) >&5 2>&5 ac_status=$? echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } \ && test -f conftest2.$ac_objext; then : OK else am_cv_prog_cc_c_o=no break fi done rm -f core conftest* unset am_i fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_prog_cc_c_o" >&5 $as_echo "$am_cv_prog_cc_c_o" >&6; } if test "$am_cv_prog_cc_c_o" != yes; then # Losing compiler, so override with the script. # FIXME: It is wrong to rewrite CC. # 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__CC in this case, # and then we could set am__CC="\$(top_srcdir)/compile \$(CC)" CC="$am_aux_dir/compile $CC" 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 # By default we simply use the C compiler to build assembly code. test "${CCAS+set}" = set || CCAS=$CC test "${CCASFLAGS+set}" = set || CCASFLAGS=$CFLAGS depcc="$CCAS" 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_CCAS_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_CCAS_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 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_CCAS_dependencies_compiler_type=$depmode break fi fi done cd .. rm -rf conftest.dir else am_cv_CCAS_dependencies_compiler_type=none fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_CCAS_dependencies_compiler_type" >&5 $as_echo "$am_cv_CCAS_dependencies_compiler_type" >&6; } CCASDEPMODE=depmode=$am_cv_CCAS_dependencies_compiler_type if test "x$enable_dependency_tracking" != xno \ && test "$am_cv_CCAS_dependencies_compiler_type" = gcc3; then am__fastdepCCAS_TRUE= am__fastdepCCAS_FALSE='#' else am__fastdepCCAS_TRUE='#' am__fastdepCCAS_FALSE= fi 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.6' macro_revision='2.4.6' ltmain=$ac_aux_dir/ltmain.sh # 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 no = "$withval" || with_gnu_ld=yes else with_gnu_ld=no fi ac_prog=ld if test yes = "$GCC"; 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 yes = "$with_gnu_ld"; 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 # MSYS converts /dev/null to NUL, MinGW nm treats NUL as empty case $build_os in mingw*) lt_bad_file=conftest.nm/nofile ;; *) lt_bad_file=/dev/null ;; esac case `"$tmp_nm" -B $lt_bad_file 2>&1 | sed '1q'` in *$lt_bad_file* | *'Invalid file or object type'*) lt_cv_path_NM="$tmp_nm -B" break 2 ;; *) case `"$tmp_nm" -p /dev/null 2>&1 | sed '1q'` in */dev/null*) lt_cv_path_NM="$tmp_nm -p" break 2 ;; *) 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 no != "$lt_cv_path_NM"; 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 -headers /dev/null 2>&1 | sed '1q'` in *COFF*) DUMPBIN="$DUMPBIN -symbols -headers" ;; *) 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; ;; bitrig* | darwin* | dragonfly* | freebsd* | netbsd* | openbsd*) # 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 ;; os2*) # The test takes a long time on OS/2. lt_cv_sys_max_cmd_len=8192 ;; 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" && \ test undefined != "$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`env echo "$teststring$teststring" 2>/dev/null` \ = "X$teststring$teststring"; } >/dev/null 2>&1 && test 17 != "$i" # 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"} 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 yes != "$GCC"; then reload_cmds=false fi ;; darwin*) if test yes = "$GCC"; 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 # that 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. if ( 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 ;; 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 glibc/ELF. linux* | k*bsd*-gnu | kopensolaris*-gnu | 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* | bitrig*) if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`"; 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 ;; os2*) 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 one 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 0 -eq "$ac_status"; 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 0 -ne "$ac_status"; 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 no = "$lt_cv_ar_at_file"; 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 bitrig* | openbsd*) old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB -t \$tool_oldlib" ;; *) old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB \$tool_oldlib" ;; esac old_archive_cmds="$old_archive_cmds~\$RANLIB \$tool_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 ia64 = "$host_cpu"; 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 if test "$lt_cv_nm_interface" = "MS dumpbin"; then # Gets list of data symbols to import. lt_cv_sys_global_symbol_to_import="sed -n -e 's/^I .* \(.*\)$/\1/p'" # Adjust the below global symbol transforms to fixup imported variables. lt_cdecl_hook=" -e 's/^I .* \(.*\)$/extern __declspec(dllimport) char \1;/p'" lt_c_name_hook=" -e 's/^I .* \(.*\)$/ {\"\1\", (void *) 0},/p'" lt_c_name_lib_hook="\ -e 's/^I .* \(lib.*\)$/ {\"\1\", (void *) 0},/p'\ -e 's/^I .* \(.*\)$/ {\"lib\1\", (void *) 0},/p'" else # Disable hooks by default. lt_cv_sys_global_symbol_to_import= lt_cdecl_hook= lt_c_name_hook= lt_c_name_lib_hook= fi # 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"\ $lt_cdecl_hook\ " -e 's/^T .* \(.*\)$/extern int \1();/p'"\ " -e 's/^$symcode$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"\ $lt_c_name_hook\ " -e 's/^: \(.*\) .*$/ {\"\1\", (void *) 0},/p'"\ " -e 's/^$symcode$symcode* .* \(.*\)$/ {\"\1\", (void *) \&\1},/p'" # Transform an extracted symbol line into symbol name with lib prefix and # symbol address. lt_cv_sys_global_symbol_to_c_name_address_lib_prefix="sed -n"\ $lt_c_name_lib_hook\ " -e 's/^: \(.*\) .*$/ {\"\1\", (void *) 0},/p'"\ " -e 's/^$symcode$symcode* .* \(lib.*\)$/ {\"\1\", (void *) \&\1},/p'"\ " -e 's/^$symcode$symcode* .* \(.*\)$/ {\"lib\1\", (void *) \&\1},/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, # D for any global variable and I for any imported 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};"\ " /^COFF SYMBOL TABLE/{for(i in hide) delete hide[i]};"\ " /Section length .*#relocs.*(pick any)/{hide[last_section]=1};"\ " /^ *Symbol name *: /{split(\$ 0,sn,\":\"); si=substr(sn[2],2)};"\ " /^ *Type *: code/{print \"T\",si,substr(si,length(prfx))};"\ " /^ *Type *: data/{print \"I\",si,substr(si,length(prfx))};"\ " \$ 0!~/External *\|/{next};"\ " / 0+ UNDEF /{next}; / UNDEF \([^|]\)*()/{next};"\ " {if(hide[section]) next};"\ " {f=\"D\"}; \$ 0~/\(\).*\|/{f=\"T\"};"\ " {split(\$ 0,a,/\||\r/); split(a[2],s)};"\ " s[1]~/^[@?]/{print f,s[1],s[1]; next};"\ " s[1]~prfx {split(s[1],t,\"@\"); print f,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 can'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* .* \(.*\)$/ {\"\1\", (void *) \&\1},/" < "$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 yes = "$pipe_works"; 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 yes = "$GCC"; 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; } { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a working dd" >&5 $as_echo_n "checking for a working dd... " >&6; } if ${ac_cv_path_lt_DD+:} false; then : $as_echo_n "(cached) " >&6 else printf 0123456789abcdef0123456789abcdef >conftest.i cat conftest.i conftest.i >conftest2.i : ${lt_DD:=$DD} if test -z "$lt_DD"; then ac_path_lt_DD_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 dd; do for ac_exec_ext in '' $ac_executable_extensions; do ac_path_lt_DD="$as_dir/$ac_prog$ac_exec_ext" as_fn_executable_p "$ac_path_lt_DD" || continue if "$ac_path_lt_DD" bs=32 count=1 conftest.out 2>/dev/null; then cmp -s conftest.i conftest.out \ && ac_cv_path_lt_DD="$ac_path_lt_DD" ac_path_lt_DD_found=: fi $ac_path_lt_DD_found && break 3 done done done IFS=$as_save_IFS if test -z "$ac_cv_path_lt_DD"; then : fi else ac_cv_path_lt_DD=$lt_DD fi rm -f conftest.i conftest2.i conftest.out fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_lt_DD" >&5 $as_echo "$ac_cv_path_lt_DD" >&6; } { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to truncate binary pipes" >&5 $as_echo_n "checking how to truncate binary pipes... " >&6; } if ${lt_cv_truncate_bin+:} false; then : $as_echo_n "(cached) " >&6 else printf 0123456789abcdef0123456789abcdef >conftest.i cat conftest.i conftest.i >conftest2.i lt_cv_truncate_bin= if "$ac_cv_path_lt_DD" bs=32 count=1 conftest.out 2>/dev/null; then cmp -s conftest.i conftest.out \ && lt_cv_truncate_bin="$ac_cv_path_lt_DD bs=4096 count=1" fi rm -f conftest.i conftest2.i conftest.out test -z "$lt_cv_truncate_bin" && lt_cv_truncate_bin="$SED -e 4q" fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_truncate_bin" >&5 $as_echo "$lt_cv_truncate_bin" >&6; } # Calculate cc_basename. Skip known compiler wrappers and cross-prefix. func_cc_basename () { for cc_temp in $*""; do case $cc_temp in compile | *[\\/]compile | ccache | *[\\/]ccache ) ;; distcc | *[\\/]distcc | purify | *[\\/]purify ) ;; \-*) ;; *) break;; esac done func_cc_basename_result=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"` } # Check whether --enable-libtool-lock was given. if test "${enable_libtool_lock+set}" = set; then : enableval=$enable_libtool_lock; fi test no = "$enable_libtool_lock" || 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 what ABI is being produced by ac_compile, and set mode # options accordingly. 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 what ABI is being produced by ac_compile, and set linker # options accordingly. 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 yes = "$lt_cv_prog_gnu_ld"; 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* ;; mips64*-*linux*) # Find out what ABI is being produced by ac_compile, and set linker # options accordingly. 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 emul=elf case `/usr/bin/file conftest.$ac_objext` in *32-bit*) emul="${emul}32" ;; *64-bit*) emul="${emul}64" ;; esac case `/usr/bin/file conftest.$ac_objext` in *MSB*) emul="${emul}btsmip" ;; *LSB*) emul="${emul}ltsmip" ;; esac case `/usr/bin/file conftest.$ac_objext` in *N32*) emul="${emul}n32" ;; esac LD="${LD-ld} -m $emul" fi rm -rf conftest* ;; x86_64-*kfreebsd*-gnu|x86_64-*linux*|powerpc*-*linux*| \ s390*-*linux*|s390*-*tpf*|sparc*-*linux*) # Find out what ABI is being produced by ac_compile, and set linker # options accordingly. Note that the listed cases only cover the # situations where additional linker options are needed (such as when # doing 32-bit compilation for a host where ld defaults to 64-bit, or # vice versa); the common cases where no linker options are needed do # not appear in the list. 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*) case `/usr/bin/file conftest.o` in *x86-64*) LD="${LD-ld} -m elf32_x86_64" ;; *) LD="${LD-ld} -m elf_i386" ;; esac ;; powerpc64le-*linux*) LD="${LD-ld} -m elf32lppclinux" ;; 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" ;; powerpcle-*linux*) LD="${LD-ld} -m elf64lppc" ;; 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 yes != "$lt_cv_cc_needs_belf"; then # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf CFLAGS=$SAVE_CFLAGS fi ;; *-*solaris*) # Find out what ABI is being produced by ac_compile, and set linker # options accordingly. 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*) case $host in i?86-*-solaris*|x86_64-*-solaris*) LD="${LD-ld} -m elf_x86_64" ;; sparc*-*-solaris*) LD="${LD-ld} -m elf64_sparc" ;; esac # GNU ld 2.21 introduced _sol2 emulations. Use them if available. if ${LD-ld} -V | grep _sol2 >/dev/null 2>&1; then LD=${LD-ld}_sol2 fi ;; *) 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 yes != "$lt_cv_path_mainfest_tool"; 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 there is a non-empty error log, and "single_module" # appears in it, assume the flag caused a linker warning if test -s conftest.err && $GREP single_module conftest.err; then cat conftest.err >&5 # Otherwise, if the output was created with a 0 exit code from # the compiler, it worked. elif test -f libconftest.dylib && test 0 = "$_lt_result"; 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 -s conftest.err && $GREP force_load conftest.err; then cat conftest.err >&5 elif test -f conftest && test 0 = "$_lt_result" && $GREP forced_load conftest >/dev/null 2>&1; 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 yes = "$lt_cv_apple_cc_single_mod"; then _lt_dar_single_mod='$single_module' fi if test yes = "$lt_cv_ld_exported_symbols_list"; 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 no = "$lt_cv_ld_force_load"; then _lt_dsymutil='~$DSYMUTIL $lib || :' else _lt_dsymutil= fi ;; esac # func_munge_path_list VARIABLE PATH # ----------------------------------- # VARIABLE is name of variable containing _space_ separated list of # directories to be munged by the contents of PATH, which is string # having a format: # "DIR[:DIR]:" # string "DIR[ DIR]" will be prepended to VARIABLE # ":DIR[:DIR]" # string "DIR[ DIR]" will be appended to VARIABLE # "DIRP[:DIRP]::[DIRA:]DIRA" # string "DIRP[ DIRP]" will be prepended to VARIABLE and string # "DIRA[ DIRA]" will be appended to VARIABLE # "DIR[:DIR]" # VARIABLE will be replaced by "DIR[ DIR]" func_munge_path_list () { case x$2 in x) ;; *:) eval $1=\"`$ECHO $2 | $SED 's/:/ /g'` \$$1\" ;; x:*) eval $1=\"\$$1 `$ECHO $2 | $SED 's/:/ /g'`\" ;; *::*) eval $1=\"\$$1\ `$ECHO $2 | $SED -e 's/.*:://' -e 's/:/ /g'`\" eval $1=\"`$ECHO $2 | $SED -e 's/::.*//' -e 's/:/ /g'`\ \$$1\" ;; *) eval $1=\"`$ECHO $2 | $SED 's/:/ /g'`\" ;; 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_dlopen=no enable_win32_dll=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; lt_p=${PACKAGE-default} case $withval in yes|no) pic_mode=$withval ;; *) pic_mode=default # Look at the argument we got. We use all the common list separators. lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR, for lt_pkg in $withval; do IFS=$lt_save_ifs if test "X$lt_pkg" = "X$lt_p"; then pic_mode=yes fi done IFS=$lt_save_ifs ;; esac else pic_mode=default fi # 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 shared_archive_member_spec= case $host,$enable_shared in power*-*-aix[5-9]*,yes) { $as_echo "$as_me:${as_lineno-$LINENO}: checking which variant of shared library versioning to provide" >&5 $as_echo_n "checking which variant of shared library versioning to provide... " >&6; } # Check whether --with-aix-soname was given. if test "${with_aix_soname+set}" = set; then : withval=$with_aix_soname; case $withval in aix|svr4|both) ;; *) as_fn_error $? "Unknown argument to --with-aix-soname" "$LINENO" 5 ;; esac lt_cv_with_aix_soname=$with_aix_soname else if ${lt_cv_with_aix_soname+:} false; then : $as_echo_n "(cached) " >&6 else lt_cv_with_aix_soname=aix fi with_aix_soname=$lt_cv_with_aix_soname fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $with_aix_soname" >&5 $as_echo "$with_aix_soname" >&6; } if test aix != "$with_aix_soname"; then # For the AIX way of multilib, we name the shared archive member # based on the bitwidth used, traditionally 'shr.o' or 'shr_64.o', # and 'shr.imp' or 'shr_64.imp', respectively, for the Import File. # Even when GNU compilers ignore OBJECT_MODE but need '-maix64' flag, # the AIX toolchain works better with OBJECT_MODE set (default 32). if test 64 = "${OBJECT_MODE-32}"; then shared_archive_member_spec=shr_64 else shared_archive_member_spec=shr fi fi ;; *) with_aix_soname=aix ;; esac # 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 set != "${COLLECT_NAMES+set}"; 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 func_cc_basename $compiler cc_basename=$func_cc_basename_result # 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 yes = "$GCC"; 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" ## exclude from sc_useless_quotes_in_assignment # 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 yes = "$lt_cv_prog_compiler_rtti_exceptions"; 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 yes = "$GCC"; then lt_prog_compiler_wl='-Wl,' lt_prog_compiler_static='-static' case $host_os in aix*) # All AIX code is PIC. if test ia64 = "$host_cpu"; then # AIX 5 now supports IA64 processor lt_prog_compiler_static='-Bstatic' fi lt_prog_compiler_pic='-fPIC' ;; 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' case $host_os in os2*) lt_prog_compiler_static='$wl-static' ;; esac ;; 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 ' if test -n "$lt_prog_compiler_pic"; then lt_prog_compiler_pic="-Xcompiler $lt_prog_compiler_pic" fi ;; 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 ia64 = "$host_cpu"; then # AIX 5 now supports IA64 processor lt_prog_compiler_static='-Bstatic' else lt_prog_compiler_static='-bnso -bI:/lib/syscalls.exp' fi ;; darwin* | rhapsody*) # PIC is the default on this platform # Common symbols not allowed in MH_DYLIB files lt_prog_compiler_pic='-fno-common' case $cc_basename in nagfor*) # NAG Fortran compiler lt_prog_compiler_wl='-Wl,-Wl,,' lt_prog_compiler_pic='-PIC' lt_prog_compiler_static='-Bstatic' ;; esac ;; 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' case $host_os in os2*) lt_prog_compiler_static='$wl-static' ;; esac ;; 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 | 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' ;; tcc*) # Fabrice Bellard et al's Tiny C Compiler lt_prog_compiler_wl='-Wl,' lt_prog_compiler_pic='-fPIC' lt_prog_compiler_static='-static' ;; 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\ Ceres\ Fortran* | *Sun*Fortran*\ [1-7].* | *Sun*Fortran*\ 8.[0-3]*) # 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\ F* | *Sun*Fortran*) lt_prog_compiler_pic='-KPIC' lt_prog_compiler_static='-Bstatic' lt_prog_compiler_wl='-Qoption ld ' ;; *Sun\ C*) # Sun C 5.9 lt_prog_compiler_pic='-KPIC' lt_prog_compiler_static='-Bstatic' lt_prog_compiler_wl='-Wl,' ;; *Intel*\ [CF]*Compiler*) lt_prog_compiler_wl='-Wl,' lt_prog_compiler_pic='-fPIC' lt_prog_compiler_static='-static' ;; *Portland\ Group*) lt_prog_compiler_wl='-Wl,' lt_prog_compiler_pic='-fpic' lt_prog_compiler_static='-Bstatic' ;; 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 that 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" ## exclude from sc_useless_quotes_in_assignment # 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 yes = "$lt_cv_prog_compiler_pic_works"; 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 yes = "$lt_cv_prog_compiler_static_works"; 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 no = "$lt_cv_prog_compiler_c_o" && test no != "$need_locks"; 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 no = "$hard_links"; 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_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 yes != "$GCC"; then with_gnu_ld=no fi ;; interix*) # we just hope/assume this is gcc and not c89 (= MSVC++) with_gnu_ld=yes ;; openbsd* | bitrig*) 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 yes = "$with_gnu_ld"; 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 yes = "$lt_use_gnu_ld_interface"; 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 | $SED -e 's/(^)\+)\s\+//' 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 ia64 != "$host_cpu"; 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, use it as # is; otherwise, prepend EXPORTS... archive_expsym_cmds='if test DEF = "`$SED -n -e '\''s/^[ ]*//'\'' -e '\''/^\(;.*\)*$/d'\'' -e '\''s/^\(EXPORTS\|LIBRARY\)\([ ].*\)*$/DEF/p'\'' -e q $export_symbols`" ; 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 ;; os2*) hardcode_libdir_flag_spec='-L$libdir' hardcode_minus_L=yes allow_undefined_flag=unsupported shrext_cmds=.dll archive_cmds='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~ $ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~ $ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~ $ECHO EXPORTS >> $output_objdir/$libname.def~ emxexp $libobjs | $SED /"_DLL_InitTerm"/d >> $output_objdir/$libname.def~ $CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~ emximp -o $lib $output_objdir/$libname.def' archive_expsym_cmds='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~ $ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~ $ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~ $ECHO EXPORTS >> $output_objdir/$libname.def~ prefix_cmds="$SED"~ if test EXPORTS = "`$SED 1q $export_symbols`"; then prefix_cmds="$prefix_cmds -e 1d"; fi~ prefix_cmds="$prefix_cmds -e \"s/^\(.*\)$/_\1/g\""~ cat $export_symbols | $prefix_cmds >> $output_objdir/$libname.def~ $CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~ emximp -o $lib $output_objdir/$libname.def' old_archive_From_new_cmds='emximp -o $output_objdir/${libname}_dll.a $output_objdir/$libname.def' enable_shared_with_static_runtimes=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 linux-dietlibc = "$host_os"; 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 no = "$tmp_diet" 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' ;; nagfor*) # NAGFOR 5.3 tmp_sharedflag='-Wl,-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 yes = "$supports_anon_versioning"; 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 tcc*) export_dynamic_flag_spec='-rdynamic' ;; 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='$wl-rpath $wl$libdir' archive_cmds='$LD -shared $libobjs $deplibs $linker_flags -soname $soname -o $lib' if test yes = "$supports_anon_versioning"; 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 cannot *** 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 no = "$ld_shlibs"; 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 yes = "$GCC" && 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 ia64 = "$host_cpu"; 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 GNU nm, but means don't demangle to AIX nm. # Without the "-l" option, or with the "-B" option, AIX nm treats # weak defined symbols like other global defined symbols, whereas # GNU nm marks them as "W". # While the 'weak' keyword is ignored in the Export File, we need # it in the Import File for the 'aix-soname' feature, so we have # to replace the "-B" option with "-P" for AIX nm. 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) != ".")) { if (\$ 2 == "W") { print \$ 3 " weak" } else { print \$ 3 } } }'\'' | sort -u > $export_symbols' else export_symbols_cmds='`func_echo_all $NM | $SED -e '\''s/B\([^B]*\)$/P\1/'\''` -PCpgl $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) && (substr(\$ 1,1,1) != ".")) { if ((\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) { print \$ 1 " weak" } else { print \$ 1 } } }'\'' | 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 # have runtime linking enabled, and use it for executables. # For shared libraries, we enable/disable runtime linking # depending on the kind of the shared library created - # when "with_aix_soname,aix_use_runtimelinking" is: # "aix,no" lib.a(lib.so.V) shared, rtl:no, for executables # "aix,yes" lib.so shared, rtl:yes, for executables # lib.a static archive # "both,no" lib.so.V(shr.o) shared, rtl:yes # lib.a(lib.so.V) shared, rtl:no, for executables # "both,yes" lib.so.V(shr.o) shared, rtl:yes, for executables # lib.a(lib.so.V) shared, rtl:no # "svr4,*" lib.so.V(shr.o) shared, rtl:yes, for executables # lib.a static archive case $host_os in aix4.[23]|aix4.[23].*|aix[5-9]*) for ld_flag in $LDFLAGS; do if (test x-brtl = "x$ld_flag" || test x-Wl,-brtl = "x$ld_flag"); then aix_use_runtimelinking=yes break fi done if test svr4,no = "$with_aix_soname,$aix_use_runtimelinking"; then # With aix-soname=svr4, we create the lib.so.V shared archives only, # so we don't have lib.a shared libs to link our executables. # We have to force runtime linking in this case. aix_use_runtimelinking=yes LDFLAGS="$LDFLAGS -Wl,-brtl" fi ;; 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,' case $with_aix_soname,$aix_use_runtimelinking in aix,*) ;; # traditional, no import file svr4,* | *,yes) # use import file # The Import File defines what to hardcode. hardcode_direct=no hardcode_direct_absolute=no ;; esac if test yes = "$GCC"; 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 yes = "$aix_use_runtimelinking"; then shared_flag="$shared_flag "'$wl-G' fi # Need to ensure runtime linking is disabled for the traditional # shared library, or the linker may eventually find shared libraries # /with/ Import File - we do not want to mix them. shared_flag_aix='-shared' shared_flag_svr4='-shared $wl-G' else # not using gcc if test ia64 = "$host_cpu"; 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 yes = "$aix_use_runtimelinking"; then shared_flag='$wl-G' else shared_flag='$wl-bM:SRE' fi shared_flag_aix='$wl-bM:SRE' shared_flag_svr4='$wl-G' 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,yes = "$with_aix_soname,$aix_use_runtimelinking"; 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 set = "${lt_cv_aix_libpath+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 -n "$allow_undefined_flag"; then func_echo_all "$wl$allow_undefined_flag"; else :; fi` $wl'$exp_sym_flag:\$export_symbols' '$shared_flag else if test ia64 = "$host_cpu"; 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 set = "${lt_cv_aix_libpath+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 yes = "$with_gnu_ld"; 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 archive_expsym_cmds='$RM -r $output_objdir/$realname.d~$MKDIR $output_objdir/$realname.d' # -brtl affects multiple linker settings, -berok does not and is overridden later compiler_flags_filtered='`func_echo_all "$compiler_flags " | $SED -e "s%-brtl\\([, ]\\)%-berok\\1%g"`' if test svr4 != "$with_aix_soname"; then # This is similar to how AIX traditionally builds its shared libraries. archive_expsym_cmds="$archive_expsym_cmds"'~$CC '$shared_flag_aix' -o $output_objdir/$realname.d/$soname $libobjs $deplibs $wl-bnoentry '$compiler_flags_filtered'$wl-bE:$export_symbols$allow_undefined_flag~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$realname.d/$soname' fi if test aix != "$with_aix_soname"; then archive_expsym_cmds="$archive_expsym_cmds"'~$CC '$shared_flag_svr4' -o $output_objdir/$realname.d/$shared_archive_member_spec.o $libobjs $deplibs $wl-bnoentry '$compiler_flags_filtered'$wl-bE:$export_symbols$allow_undefined_flag~$STRIP -e $output_objdir/$realname.d/$shared_archive_member_spec.o~( func_echo_all "#! $soname($shared_archive_member_spec.o)"; if test shr_64 = "$shared_archive_member_spec"; then func_echo_all "# 64"; else func_echo_all "# 32"; fi; cat $export_symbols ) > $output_objdir/$realname.d/$shared_archive_member_spec.imp~$AR $AR_FLAGS $output_objdir/$soname $output_objdir/$realname.d/$shared_archive_member_spec.o $output_objdir/$realname.d/$shared_archive_member_spec.imp' else # used by -dlpreopen to get the symbols archive_expsym_cmds="$archive_expsym_cmds"'~$MV $output_objdir/$realname.d/$soname $output_objdir' fi archive_expsym_cmds="$archive_expsym_cmds"'~$RM -r $output_objdir/$realname.d' 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,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~linknames=' archive_expsym_cmds='if test DEF = "`$SED -n -e '\''s/^[ ]*//'\'' -e '\''/^\(;.*\)*$/d'\'' -e '\''s/^\(EXPORTS\|LIBRARY\)\([ ].*\)*$/DEF/p'\'' -e q $export_symbols`" ; then cp "$export_symbols" "$output_objdir/$soname.def"; echo "$tool_output_objdir$soname.def" > "$output_objdir/$soname.exp"; else $SED -e '\''s/^/-link -EXPORT:/'\'' < $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 exclude_expsyms='_NULL_IMPORT_DESCRIPTOR|_IMPORT_DESCRIPTOR_.*' 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 yes = "$lt_cv_ld_force_load"; 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*|nagfor*) _lt_dar_can_shared=yes ;; *) _lt_dar_can_shared=$GCC ;; esac if test yes = "$_lt_dar_can_shared"; 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 ;; # 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 yes = "$GCC"; 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 "x$output_objdir/$soname" = "x$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 "x$output_objdir/$soname" = "x$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 yes,no = "$GCC,$with_gnu_ld"; 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 no = "$with_gnu_ld"; then hardcode_libdir_flag_spec='$wl+b $wl$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 yes,no = "$GCC,$with_gnu_ld"; 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 yes = "$lt_cv_prog_compiler__b"; 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 no = "$with_gnu_ld"; 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 yes = "$GCC"; 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 yes = "$lt_cv_irix_exported_symbol"; 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 ;; linux*) case $cc_basename in tcc*) # Fabrice Bellard et al's Tiny C Compiler ld_shlibs=yes archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags' ;; esac ;; 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* | bitrig*) 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__`"; 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 archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags' hardcode_libdir_flag_spec='$wl-rpath,$libdir' fi else ld_shlibs=no fi ;; os2*) hardcode_libdir_flag_spec='-L$libdir' hardcode_minus_L=yes allow_undefined_flag=unsupported shrext_cmds=.dll archive_cmds='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~ $ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~ $ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~ $ECHO EXPORTS >> $output_objdir/$libname.def~ emxexp $libobjs | $SED /"_DLL_InitTerm"/d >> $output_objdir/$libname.def~ $CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~ emximp -o $lib $output_objdir/$libname.def' archive_expsym_cmds='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~ $ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~ $ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~ $ECHO EXPORTS >> $output_objdir/$libname.def~ prefix_cmds="$SED"~ if test EXPORTS = "`$SED 1q $export_symbols`"; then prefix_cmds="$prefix_cmds -e 1d"; fi~ prefix_cmds="$prefix_cmds -e \"s/^\(.*\)$/_\1/g\""~ cat $export_symbols | $prefix_cmds >> $output_objdir/$libname.def~ $CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~ emximp -o $lib $output_objdir/$libname.def' old_archive_From_new_cmds='emximp -o $output_objdir/${libname}_dll.a $output_objdir/$libname.def' enable_shared_with_static_runtimes=yes ;; osf3*) if test yes = "$GCC"; 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 yes = "$GCC"; 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 yes = "$GCC"; 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 yes = "$GCC"; 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 sequent = "$host_vendor"; 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 yes = "$GCC"; 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 CANNOT 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 yes = "$GCC"; 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 sni = "$host_vendor"; 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 no = "$ld_shlibs" && 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 yes,yes = "$GCC,$enable_shared"; 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 yes = "$GCC"; 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` # ...but if some path component already ends with the multilib dir we assume # that all is fine and trust -print-search-dirs as is (GCC 4.2? or newer). case "$lt_multi_os_dir; $lt_search_path_spec " in "/; "* | "/.; "* | "/./; "* | *"$lt_multi_os_dir "* | *"$lt_multi_os_dir/ "*) lt_multi_os_dir= ;; esac 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" elif test -n "$lt_multi_os_dir"; then 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 # correct to gnu/linux during the next big refactor 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 # correct to gnu/linux during the next big refactor need_lib_prefix=no need_version=no hardcode_into_libs=yes if test ia64 = "$host_cpu"; 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 # Using Import Files as archive members, it is possible to support # filename-based versioning of shared library archives on AIX. While # this would work for both with and without runtime linking, it will # prevent static linking of such archives. So we do filename-based # shared library versioning with .so extension only, which is used # when both runtime linking and shared linking is enabled. # Unfortunately, runtime linking may impact performance, so we do # not want this to be the default eventually. Also, we use the # versioned .so libs for executables only if there is the -brtl # linker flag in LDFLAGS as well, or --with-aix-soname=svr4 only. # To allow for filename-based versioning support, we need to create # libNAME.so.V as an archive file, containing: # *) an Import File, referring to the versioned filename of the # archive as well as the shared archive member, telling the # bitwidth (32 or 64) of that shared object, and providing the # list of exported symbols of that shared object, eventually # decorated with the 'weak' keyword # *) the shared object with the F_LOADONLY flag set, to really avoid # it being seen by the linker. # At run time we better use the real file rather than another symlink, # but for link time we create the symlink libNAME.so -> libNAME.so.V case $with_aix_soname,$aix_use_runtimelinking in # AIX (on Power*) has no versioning support, so currently we cannot hardcode correct # soname into executable. Probably we can add versioning support to # collect2, so additional links can be useful in future. aix,yes) # traditional libtool dynamic_linker='AIX unversionable lib.so' # 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' ;; aix,no) # traditional AIX only dynamic_linker='AIX lib.a(lib.so.V)' # 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' ;; svr4,*) # full svr4 only dynamic_linker="AIX lib.so.V($shared_archive_member_spec.o)" library_names_spec='$libname$release$shared_ext$major $libname$shared_ext' # We do not specify a path in Import Files, so LIBPATH fires. shlibpath_overrides_runpath=yes ;; *,yes) # both, prefer svr4 dynamic_linker="AIX lib.so.V($shared_archive_member_spec.o), lib.a(lib.so.V)" library_names_spec='$libname$release$shared_ext$major $libname$shared_ext' # unpreferred sharedlib libNAME.a needs extra handling postinstall_cmds='test -n "$linkname" || linkname="$realname"~func_stripname "" ".so" "$linkname"~$install_shared_prog "$dir/$func_stripname_result.$libext" "$destdir/$func_stripname_result.$libext"~test -z "$tstripme" || test -z "$striplib" || $striplib "$destdir/$func_stripname_result.$libext"' postuninstall_cmds='for n in $library_names $old_library; do :; done~func_stripname "" ".so" "$n"~test "$func_stripname_result" = "$n" || func_append rmfiles " $odir/$func_stripname_result.$libext"' # We do not specify a path in Import Files, so LIBPATH fires. shlibpath_overrides_runpath=yes ;; *,no) # both, prefer aix dynamic_linker="AIX lib.a(lib.so.V), lib.so.V($shared_archive_member_spec.o)" library_names_spec='$libname$release.a $libname.a' soname_spec='$libname$release$shared_ext$major' # unpreferred sharedlib libNAME.so.V and symlink libNAME.so need extra handling postinstall_cmds='test -z "$dlname" || $install_shared_prog $dir/$dlname $destdir/$dlname~test -z "$tstripme" || test -z "$striplib" || $striplib $destdir/$dlname~test -n "$linkname" || linkname=$realname~func_stripname "" ".a" "$linkname"~(cd "$destdir" && $LN_S -f $dlname $func_stripname_result.so)' postuninstall_cmds='test -z "$dlname" || func_append rmfiles " $odir/$dlname"~for n in $old_library $library_names; do :; done~func_stripname "" ".a" "$n"~func_append rmfiles " $odir/$func_stripname_result.so"' ;; esac 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%'\''`; $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 # correct to gnu/linux during the next big refactor 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 # correct to gnu/linux during the next big refactor 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 ;; 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[23].*) 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$major $libname$shared_ext' soname_spec='$libname$release$shared_ext$major' 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 ;; haiku*) version_type=linux # correct to gnu/linux during the next big refactor 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=no 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 32 = "$HPUX_IA64_MODE"; then sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib" sys_lib_dlsearch_path_spec=/usr/lib/hpux32 else sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64" sys_lib_dlsearch_path_spec=/usr/lib/hpux64 fi ;; 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 # correct to gnu/linux during the next big refactor 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 yes = "$lt_cv_prog_gnu_ld"; then version_type=linux # correct to gnu/linux during the next big refactor 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 ;; linux*android*) version_type=none # Android doesn't support versioned libraries. need_lib_prefix=no need_version=no library_names_spec='$libname$release$shared_ext' soname_spec='$libname$release$shared_ext' finish_cmds= shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=yes # 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 dynamic_linker='Android linker' # Don't embed -rpath directories since the linker doesn't support them. hardcode_libdir_flag_spec='-L$libdir' ;; # This must be glibc/ELF. linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*) version_type=linux # correct to gnu/linux during the next big refactor 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 # Ideally, we could use ldconfig to report *all* directores which are # searched for libraries, however this is still not possible. Aside from not # being certain /sbin/ldconfig is available, command # 'ldconfig -N -X -v | grep ^/' on 64bit Fedora does not report /usr/lib64, # even though it is searched at run-time. Try to do the best guess by # appending ld.so.conf contents (and includes) 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="/lib /usr/lib $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 # correct to gnu/linux during the next big refactor 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* | bitrig*) version_type=sunos sys_lib_dlsearch_path_spec=/usr/lib need_lib_prefix=no if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`"; then need_version=no else need_version=yes fi 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 shlibpath_overrides_runpath=yes ;; os2*) libname_spec='$name' version_type=windows shrext_cmds=.dll need_version=no need_lib_prefix=no # OS/2 can only load a DLL with a base name of 8 characters or less. soname_spec='`test -n "$os2dllname" && libname="$os2dllname"; v=$($ECHO $release$versuffix | tr -d .-); n=$($ECHO $libname | cut -b -$((8 - ${#v})) | tr . _); $ECHO $n$v`$shared_ext' library_names_spec='${libname}_dll.$libext' dynamic_linker='OS/2 ld.exe' shlibpath_var=BEGINLIBPATH sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib" sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec 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' ;; 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 # correct to gnu/linux during the next big refactor 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 yes = "$with_gnu_ld"; then need_lib_prefix=no fi need_version=yes ;; sysv4 | sysv4.3*) version_type=linux # correct to gnu/linux during the next big refactor 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 # correct to gnu/linux during the next big refactor 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=sco 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 yes = "$with_gnu_ld"; 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 # correct to gnu/linux during the next big refactor 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 # correct to gnu/linux during the next big refactor 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 no = "$dynamic_linker" && can_build_shared=no variables_saved_for_relink="PATH $shlibpath_var $runpath_var" if test yes = "$GCC"; then variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH" fi if test set = "${lt_cv_sys_lib_search_path_spec+set}"; then sys_lib_search_path_spec=$lt_cv_sys_lib_search_path_spec fi if test set = "${lt_cv_sys_lib_dlsearch_path_spec+set}"; then sys_lib_dlsearch_path_spec=$lt_cv_sys_lib_dlsearch_path_spec fi # remember unaugmented sys_lib_dlsearch_path content for libtool script decls... configure_time_dlsearch_path=$sys_lib_dlsearch_path_spec # ... but it needs LT_SYS_LIBRARY_PATH munging for other configure-time code func_munge_path_list sys_lib_dlsearch_path_spec "$LT_SYS_LIBRARY_PATH" # to be used as default LT_SYS_LIBRARY_PATH value in generated libtool configure_time_lt_sys_library_path=$LT_SYS_LIBRARY_PATH { $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 yes = "$hardcode_automatic"; then # We can hardcode non-existent directories. if test no != "$hardcode_direct" && # 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 no != "$_LT_TAGVAR(hardcode_shlibpath_var, )" && test no != "$hardcode_minus_L"; 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 relink = "$hardcode_action" || test yes = "$inherit_rpath"; then # Fast installation is not supported enable_fast_install=no elif test yes = "$shlibpath_overrides_runpath" || test no = "$enable_shared"; then # Fast installation is not necessary enable_fast_install=needless fi if test yes != "$enable_dlopen"; 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 ;; tpf*) # Don't try to run any link tests for TPF. We know it's impossible # because TPF is a cross-compiler, and we know how we open DSOs. lt_cv_dlopen=dlopen lt_cv_dlopen_libs= lt_cv_dlopen_self=no ;; *) 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 no = "$lt_cv_dlopen"; then enable_dlopen=no else enable_dlopen=yes fi case $lt_cv_dlopen in dlopen) save_CPPFLAGS=$CPPFLAGS test yes = "$ac_cv_header_dlfcn_h" && 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 yes = "$cross_compiling"; 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 -fvisibility=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 yes = "$lt_cv_dlopen_self"; 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 yes = "$cross_compiling"; 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 -fvisibility=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 what 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 no = "$can_build_shared" && 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 yes = "$enable_shared" && enable_static=no if test -n "$RANLIB"; then archive_cmds="$archive_cmds~\$RANLIB \$lib" postinstall_cmds='$RANLIB $lib' fi ;; aix[4-9]*) if test ia64 != "$host_cpu"; then case $enable_shared,$with_aix_soname,$aix_use_runtimelinking in yes,aix,yes) ;; # shared object as lib.so file only yes,svr4,*) ;; # shared object as lib.so archive member only yes,*) enable_static=no ;; # shared object in lib.a archive as well esac 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 yes = "$enable_shared" || 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: # Checks for functions. for ac_header in $ac_header_list 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_func in getpagesize do : ac_fn_c_check_func "$LINENO" "getpagesize" "ac_cv_func_getpagesize" if test "x$ac_cv_func_getpagesize" = xyes; then : cat >>confdefs.h <<_ACEOF #define HAVE_GETPAGESIZE 1 _ACEOF fi done { $as_echo "$as_me:${as_lineno-$LINENO}: checking for working mmap" >&5 $as_echo_n "checking for working mmap... " >&6; } if ${ac_cv_func_mmap_fixed_mapped+:} false; then : $as_echo_n "(cached) " >&6 else if test "$cross_compiling" = yes; then : ac_cv_func_mmap_fixed_mapped=no else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $ac_includes_default /* malloc might have been renamed as rpl_malloc. */ #undef malloc /* Thanks to Mike Haertel and Jim Avera for this test. Here is a matrix of mmap possibilities: mmap private not fixed mmap private fixed at somewhere currently unmapped mmap private fixed at somewhere already mapped mmap shared not fixed mmap shared fixed at somewhere currently unmapped mmap shared fixed at somewhere already mapped For private mappings, we should verify that changes cannot be read() back from the file, nor mmap's back from the file at a different address. (There have been systems where private was not correctly implemented like the infamous i386 svr4.0, and systems where the VM page cache was not coherent with the file system buffer cache like early versions of FreeBSD and possibly contemporary NetBSD.) For shared mappings, we should conversely verify that changes get propagated back to all the places they're supposed to be. Grep wants private fixed already mapped. The main things grep needs to know about mmap are: * does it exist and is it safe to write into the mmap'd area * how to use it (BSD variants) */ #include #include #if !defined STDC_HEADERS && !defined HAVE_STDLIB_H char *malloc (); #endif /* This mess was copied from the GNU getpagesize.h. */ #ifndef HAVE_GETPAGESIZE # ifdef _SC_PAGESIZE # define getpagesize() sysconf(_SC_PAGESIZE) # else /* no _SC_PAGESIZE */ # ifdef HAVE_SYS_PARAM_H # include # ifdef EXEC_PAGESIZE # define getpagesize() EXEC_PAGESIZE # else /* no EXEC_PAGESIZE */ # ifdef NBPG # define getpagesize() NBPG * CLSIZE # ifndef CLSIZE # define CLSIZE 1 # endif /* no CLSIZE */ # else /* no NBPG */ # ifdef NBPC # define getpagesize() NBPC # else /* no NBPC */ # ifdef PAGESIZE # define getpagesize() PAGESIZE # endif /* PAGESIZE */ # endif /* no NBPC */ # endif /* no NBPG */ # endif /* no EXEC_PAGESIZE */ # else /* no HAVE_SYS_PARAM_H */ # define getpagesize() 8192 /* punt totally */ # endif /* no HAVE_SYS_PARAM_H */ # endif /* no _SC_PAGESIZE */ #endif /* no HAVE_GETPAGESIZE */ int main () { char *data, *data2, *data3; const char *cdata2; int i, pagesize; int fd, fd2; pagesize = getpagesize (); /* First, make a file with some known garbage in it. */ data = (char *) malloc (pagesize); if (!data) return 1; for (i = 0; i < pagesize; ++i) *(data + i) = rand (); umask (0); fd = creat ("conftest.mmap", 0600); if (fd < 0) return 2; if (write (fd, data, pagesize) != pagesize) return 3; close (fd); /* Next, check that the tail of a page is zero-filled. File must have non-zero length, otherwise we risk SIGBUS for entire page. */ fd2 = open ("conftest.txt", O_RDWR | O_CREAT | O_TRUNC, 0600); if (fd2 < 0) return 4; cdata2 = ""; if (write (fd2, cdata2, 1) != 1) return 5; data2 = (char *) mmap (0, pagesize, PROT_READ | PROT_WRITE, MAP_SHARED, fd2, 0L); if (data2 == MAP_FAILED) return 6; for (i = 0; i < pagesize; ++i) if (*(data2 + i)) return 7; close (fd2); if (munmap (data2, pagesize)) return 8; /* Next, try to mmap the file at a fixed address which already has something else allocated at it. If we can, also make sure that we see the same garbage. */ fd = open ("conftest.mmap", O_RDWR); if (fd < 0) return 9; if (data2 != mmap (data2, pagesize, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_FIXED, fd, 0L)) return 10; for (i = 0; i < pagesize; ++i) if (*(data + i) != *(data2 + i)) return 11; /* Finally, make sure that changes to the mapped area do not percolate back to the file as seen by read(). (This is a bug on some variants of i386 svr4.0.) */ for (i = 0; i < pagesize; ++i) *(data2 + i) = *(data2 + i) + 1; data3 = (char *) malloc (pagesize); if (!data3) return 12; if (read (fd, data3, pagesize) != pagesize) return 13; for (i = 0; i < pagesize; ++i) if (*(data + i) != *(data3 + i)) return 14; close (fd); return 0; } _ACEOF if ac_fn_c_try_run "$LINENO"; then : ac_cv_func_mmap_fixed_mapped=yes else ac_cv_func_mmap_fixed_mapped=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 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_mmap_fixed_mapped" >&5 $as_echo "$ac_cv_func_mmap_fixed_mapped" >&6; } if test $ac_cv_func_mmap_fixed_mapped = yes; then $as_echo "#define HAVE_MMAP 1" >>confdefs.h fi rm -f conftest.mmap conftest.txt # Determine PIC flag. need_asm=false PICFLAG= { $as_echo "$as_me:${as_lineno-$LINENO}: checking for PIC compiler flag" >&5 $as_echo_n "checking for PIC compiler flag... " >&6; } if test "$GCC" = yes; then case "$host" in *-*-cygwin* | *-*-mingw*) # Cygwin and Mingw[-w32/64] do not need -fPIC. { $as_echo "$as_me:${as_lineno-$LINENO}: result: \"\"" >&5 $as_echo "\"\"" >&6; } ;; *) { $as_echo "$as_me:${as_lineno-$LINENO}: result: -fPIC" >&5 $as_echo "-fPIC" >&6; } PICFLAG=-fPIC { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether gcc -fPIC causes __PIC__ definition" >&5 $as_echo_n "checking whether gcc -fPIC causes __PIC__ definition... " >&6; } # Workaround: at least GCC 3.4.6 (Solaris) does not define this macro. old_CFLAGS="$CFLAGS" CFLAGS="$PICFLAG $CFLAGS" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { #ifndef __PIC__ # error #endif ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_cv_pic_macro=yes else ac_cv_pic_macro=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext CFLAGS="$old_CFLAGS" { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_pic_macro" >&5 $as_echo "$ac_cv_pic_macro" >&6; } if test "$ac_cv_pic_macro" = yes; then : else PICFLAG="-D__PIC__=1 $PICFLAG" fi ;; esac # Output all warnings. { $as_echo "$as_me:${as_lineno-$LINENO}: checking for gcc -Wextra" >&5 $as_echo_n "checking for gcc -Wextra... " >&6; } old_CFLAGS="$CFLAGS" CFLAGS="-Wextra $CFLAGS" 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_cc_wextra=yes else ac_cv_cc_wextra=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext CFLAGS="$old_CFLAGS" { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_cc_wextra" >&5 $as_echo "$ac_cv_cc_wextra" >&6; } if test "$ac_cv_cc_wextra" = yes; then : WEXTRA="-Wextra" else WEXTRA="-W" fi CFLAGS="-Wall $WEXTRA $CFLAGS" # Check whether --enable-werror was given. if test "${enable_werror+set}" = set; then : enableval=$enable_werror; fi if test "$enable_werror" = yes; then CFLAGS="-Werror $CFLAGS" fi else case "$host" in *-*-hpux*) { $as_echo "$as_me:${as_lineno-$LINENO}: result: \"+Z\"" >&5 $as_echo "\"+Z\"" >&6; } PICFLAG="+Z" CFLAGS="+O2 -mt $CFLAGS" ;; *-*-solaris*) { $as_echo "$as_me:${as_lineno-$LINENO}: result: -Kpic" >&5 $as_echo "-Kpic" >&6; } PICFLAG=-Kpic CFLAGS="-O $CFLAGS" need_asm=true ;; *-*-linux*) { $as_echo "$as_me:${as_lineno-$LINENO}: result: -fPIC" >&5 $as_echo "-fPIC" >&6; } PICFLAG=-fPIC # Any Linux compiler had better be gcc compatible. ;; *) { $as_echo "$as_me:${as_lineno-$LINENO}: result: \"\"" >&5 $as_echo "\"\"" >&6; } ;; esac fi # Check whether --enable-assertions was given. if test "${enable_assertions+set}" = set; then : enableval=$enable_assertions; fi if test "$enable_assertions" != yes; then $as_echo "#define NDEBUG 1" >>confdefs.h fi # These macros are tested in public headers $as_echo "#define _REENTRANT 1" >>confdefs.h # Libraries needed to support threads (if any). have_pthreads=false { $as_echo "$as_me:${as_lineno-$LINENO}: checking for pthread_self in -lpthread" >&5 $as_echo_n "checking for pthread_self in -lpthread... " >&6; } if ${ac_cv_lib_pthread_pthread_self+:} false; then : $as_echo_n "(cached) " >&6 else ac_check_lib_save_LIBS=$LIBS LIBS="-lpthread $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 pthread_self (); int main () { return pthread_self (); ; return 0; } _ACEOF if ac_fn_c_try_link "$LINENO"; then : ac_cv_lib_pthread_pthread_self=yes else ac_cv_lib_pthread_pthread_self=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_pthread_pthread_self" >&5 $as_echo "$ac_cv_lib_pthread_pthread_self" >&6; } if test "x$ac_cv_lib_pthread_pthread_self" = xyes; then : have_pthreads=true fi if test x$have_pthreads = xtrue; then THREADDLLIBS=-lpthread case "$host" in *-*-netbsd*) # Indicates the use of pthreads. $as_echo "#define _PTHREADS 1" >>confdefs.h ;; *-*-openbsd* | *-*-kfreebsd*-gnu | *-*-dgux*) THREADDLLIBS=-pthread ;; *-*-cygwin* | *-*-darwin*) # Cygwin does not have a real libpthread, so Libtool cannot link # against it. THREADDLLIBS= ;; *-*-mingw*) # Use Win32 threads for tests anyway. THREADDLLIBS= # Skip test_atomic_pthreads. have_pthreads=false ;; esac else $as_echo "#define AO_NO_PTHREADS 1" >>confdefs.h # Assume VxWorks or Win32. THREADDLLIBS= fi if test x$have_pthreads = xtrue; then HAVE_PTHREAD_H_TRUE= HAVE_PTHREAD_H_FALSE='#' else HAVE_PTHREAD_H_TRUE='#' HAVE_PTHREAD_H_FALSE= fi if test x$need_asm = xtrue; then NEED_ASM_TRUE= NEED_ASM_FALSE='#' else NEED_ASM_TRUE='#' NEED_ASM_FALSE= fi ac_config_files="$ac_config_files Makefile doc/Makefile src/Makefile tests/Makefile pkgconfig/atomic_ops.pc pkgconfig/atomic_ops-uninstalled.pc" ac_config_commands="$ac_config_commands default" 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 "${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 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__fastdepCCAS_TRUE}" && test -z "${am__fastdepCCAS_FALSE}"; then as_fn_error $? "conditional \"am__fastdepCCAS\" was never defined. Usually this means the macro was only invoked conditionally." "$LINENO" 5 fi if test -z "${HAVE_PTHREAD_H_TRUE}" && test -z "${HAVE_PTHREAD_H_FALSE}"; then as_fn_error $? "conditional \"HAVE_PTHREAD_H\" was never defined. Usually this means the macro was only invoked conditionally." "$LINENO" 5 fi if test -z "${NEED_ASM_TRUE}" && test -z "${NEED_ASM_FALSE}"; then as_fn_error $? "conditional \"NEED_ASM\" 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 libatomic_ops $as_me 7.5.0, 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 ." _ACEOF cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`" ac_cs_version="\\ libatomic_ops config.status 7.5.0 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"`' 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"`' shared_archive_member_spec='`$ECHO "$shared_archive_member_spec" | $SED "$delay_single_quote_subst"`' SHELL='`$ECHO "$SHELL" | $SED "$delay_single_quote_subst"`' ECHO='`$ECHO "$ECHO" | $SED "$delay_single_quote_subst"`' PATH_SEPARATOR='`$ECHO "$PATH_SEPARATOR" | $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"`' OBJDUMP='`$ECHO "$OBJDUMP" | $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"`' DLLTOOL='`$ECHO "$DLLTOOL" | $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_import='`$ECHO "$lt_cv_sys_global_symbol_to_import" | $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"`' lt_cv_nm_interface='`$ECHO "$lt_cv_nm_interface" | $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"`' lt_cv_truncate_bin='`$ECHO "$lt_cv_truncate_bin" | $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_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"`' configure_time_dlsearch_path='`$ECHO "$configure_time_dlsearch_path" | $SED "$delay_single_quote_subst"`' configure_time_lt_sys_library_path='`$ECHO "$configure_time_lt_sys_library_path" | $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"`' 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 SHELL \ ECHO \ PATH_SEPARATOR \ SED \ GREP \ EGREP \ FGREP \ LD \ NM \ LN_S \ lt_SP2NL \ lt_NL2SP \ reload_flag \ OBJDUMP \ deplibs_check_method \ file_magic_cmd \ file_magic_glob \ want_nocaseglob \ DLLTOOL \ 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_import \ lt_cv_sys_global_symbol_to_c_name_address \ lt_cv_sys_global_symbol_to_c_name_address_lib_prefix \ lt_cv_nm_interface \ nm_file_list_spec \ lt_cv_truncate_bin \ 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_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; do case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in *[\\\\\\\`\\"\\\$]*) eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED \\"\\\$sed_quote_subst\\"\\\`\\\\\\"" ## exclude from sc_prohibit_nested_quotes ;; *) 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 \ configure_time_dlsearch_path \ configure_time_lt_sys_library_path; do case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in *[\\\\\\\`\\"\\\$]*) eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED -e \\"\\\$double_quote_subst\\" -e \\"\\\$sed_quote_subst\\" -e \\"\\\$delay_variable_subst\\"\\\`\\\\\\"" ## exclude from sc_prohibit_nested_quotes ;; *) eval "lt_\$var=\\\\\\"\\\$\$var\\\\\\"" ;; esac done ac_aux_dir='$ac_aux_dir' # See if we are running on zsh, and set the options that 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' RM='$RM' ofile='$ofile' PICFLAG="${PICFLAG}" CC="${CC}" DEFS="${DEFS}" _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 "src/config.h") CONFIG_HEADERS="$CONFIG_HEADERS src/config.h" ;; "depfiles") CONFIG_COMMANDS="$CONFIG_COMMANDS depfiles" ;; "libtool") CONFIG_COMMANDS="$CONFIG_COMMANDS libtool" ;; "Makefile") CONFIG_FILES="$CONFIG_FILES Makefile" ;; "doc/Makefile") CONFIG_FILES="$CONFIG_FILES doc/Makefile" ;; "src/Makefile") CONFIG_FILES="$CONFIG_FILES src/Makefile" ;; "tests/Makefile") CONFIG_FILES="$CONFIG_FILES tests/Makefile" ;; "pkgconfig/atomic_ops.pc") CONFIG_FILES="$CONFIG_FILES pkgconfig/atomic_ops.pc" ;; "pkgconfig/atomic_ops-uninstalled.pc") CONFIG_FILES="$CONFIG_FILES pkgconfig/atomic_ops-uninstalled.pc" ;; "default") CONFIG_COMMANDS="$CONFIG_COMMANDS default" ;; *) 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"" || { # Older Autoconf 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 that 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 # Generated automatically by $as_me ($PACKAGE) $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. # Provide generalized library-building support services. # Written by Gordon Matzigkeit, 1996 # Copyright (C) 2014 Free Software Foundation, Inc. # This is free software; see the source for copying conditions. There is NO # warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. # 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 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 this program. If not, see . # The names of the tagged configurations supported by this script. available_tags='' # Configured defaults for sys_lib_dlsearch_path munging. : \${LT_SYS_LIBRARY_PATH="$configure_time_lt_sys_library_path"} # ### 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 # 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 # Shared archive member basename,for filename based shared library versioning on AIX. shared_archive_member_spec=$shared_archive_member_spec # Shell to use when invoking shell scripts. SHELL=$lt_SHELL # An echo program that protects backslashes. ECHO=$lt_ECHO # The PATH separator for the build system. PATH_SEPARATOR=$lt_PATH_SEPARATOR # 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 # An object symbol dumper. OBJDUMP=$lt_OBJDUMP # 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 # DLL creation program. DLLTOOL=$lt_DLLTOOL # 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 into a list of symbols to manually relocate. global_symbol_to_import=$lt_lt_cv_sys_global_symbol_to_import # 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 # The name lister interface. nm_interface=$lt_lt_cv_nm_interface # 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 where our libraries should be installed. lt_sysroot=$lt_sysroot # Command to truncate a binary pipe. lt_truncate_bin=$lt_lt_cv_truncate_bin # 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 # Detected run-time system search path for libraries. sys_lib_dlsearch_path_spec=$lt_configure_time_dlsearch_path # Explicit LT_SYS_LIBRARY_PATH set during ./configure time. configure_time_lt_sys_library_path=$lt_configure_time_lt_sys_library_path # 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 # 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 # ### END LIBTOOL CONFIG _LT_EOF cat <<'_LT_EOF' >> "$cfgfile" # ### BEGIN FUNCTIONS SHARED WITH CONFIGURE # func_munge_path_list VARIABLE PATH # ----------------------------------- # VARIABLE is name of variable containing _space_ separated list of # directories to be munged by the contents of PATH, which is string # having a format: # "DIR[:DIR]:" # string "DIR[ DIR]" will be prepended to VARIABLE # ":DIR[:DIR]" # string "DIR[ DIR]" will be appended to VARIABLE # "DIRP[:DIRP]::[DIRA:]DIRA" # string "DIRP[ DIRP]" will be prepended to VARIABLE and string # "DIRA[ DIRA]" will be appended to VARIABLE # "DIR[:DIR]" # VARIABLE will be replaced by "DIR[ DIR]" func_munge_path_list () { case x$2 in x) ;; *:) eval $1=\"`$ECHO $2 | $SED 's/:/ /g'` \$$1\" ;; x:*) eval $1=\"\$$1 `$ECHO $2 | $SED 's/:/ /g'`\" ;; *::*) eval $1=\"\$$1\ `$ECHO $2 | $SED -e 's/.*:://' -e 's/:/ /g'`\" eval $1=\"`$ECHO $2 | $SED -e 's/::.*//' -e 's/:/ /g'`\ \$$1\" ;; *) eval $1=\"`$ECHO $2 | $SED 's/:/ /g'`\" ;; esac } # Calculate cc_basename. Skip known compiler wrappers and cross-prefix. func_cc_basename () { for cc_temp in $*""; do case $cc_temp in compile | *[\\/]compile | ccache | *[\\/]ccache ) ;; distcc | *[\\/]distcc | purify | *[\\/]purify ) ;; \-*) ;; *) break;; esac done func_cc_basename_result=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"` } # ### END FUNCTIONS SHARED WITH CONFIGURE _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 set != "${COLLECT_NAMES+set}"; 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) mv -f "$cfgfile" "$ofile" || (rm -f "$ofile" && cp "$cfgfile" "$ofile" && rm -f "$cfgfile") chmod +x "$ofile" ;; "default":C) ;; 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 ecl-16.1.2/src/bdwgc/libatomic_ops/configure.ac000066400000000000000000000137641266352375300213620ustar00rootroot00000000000000# Process this file with autoconf to produce a configure script. AC_INIT([libatomic_ops],[7.5.0],bdwgc@lists.opendylan.org) AC_PREREQ(2.61) AC_CANONICAL_TARGET([]) AC_CONFIG_SRCDIR(src/atomic_ops.c) AC_CONFIG_MACRO_DIR([m4]) AM_INIT_AUTOMAKE([foreign dist-bzip2 nostdinc]) AM_MAINTAINER_MODE AC_CONFIG_HEADERS([src/config.h]) # Checks for programs. AM_PROG_CC_C_O AM_PROG_AS LT_INIT([disable-shared]) # Checks for functions. AC_FUNC_MMAP # Determine PIC flag. need_asm=false PICFLAG= AC_MSG_CHECKING(for PIC compiler flag) if test "$GCC" = yes; then case "$host" in *-*-cygwin* | *-*-mingw*) # Cygwin and Mingw[-w32/64] do not need -fPIC. AC_MSG_RESULT("") ;; *) AC_MSG_RESULT(-fPIC) PICFLAG=-fPIC AC_MSG_CHECKING(whether gcc -fPIC causes __PIC__ definition) # Workaround: at least GCC 3.4.6 (Solaris) does not define this macro. old_CFLAGS="$CFLAGS" CFLAGS="$PICFLAG $CFLAGS" AC_TRY_COMPILE([],[ #ifndef __PIC__ # error #endif ], [ac_cv_pic_macro=yes], [ac_cv_pic_macro=no]) CFLAGS="$old_CFLAGS" AC_MSG_RESULT($ac_cv_pic_macro) AS_IF([test "$ac_cv_pic_macro" = yes], [], [PICFLAG="-D__PIC__=1 $PICFLAG"]) ;; esac # Output all warnings. AC_MSG_CHECKING(for gcc -Wextra) old_CFLAGS="$CFLAGS" CFLAGS="-Wextra $CFLAGS" AC_TRY_COMPILE([],[], [ac_cv_cc_wextra=yes], [ac_cv_cc_wextra=no]) CFLAGS="$old_CFLAGS" AC_MSG_RESULT($ac_cv_cc_wextra) AS_IF([test "$ac_cv_cc_wextra" = yes], [WEXTRA="-Wextra"], [WEXTRA="-W"]) CFLAGS="-Wall $WEXTRA $CFLAGS" AC_ARG_ENABLE(werror, [AC_HELP_STRING([--enable-werror], [Pass -Werror to the C compiler])]) if test "$enable_werror" = yes; then CFLAGS="-Werror $CFLAGS" fi else case "$host" in *-*-hpux*) AC_MSG_RESULT("+Z") PICFLAG="+Z" CFLAGS="+O2 -mt $CFLAGS" ;; *-*-solaris*) AC_MSG_RESULT(-Kpic) PICFLAG=-Kpic CFLAGS="-O $CFLAGS" need_asm=true ;; *-*-linux*) AC_MSG_RESULT(-fPIC) PICFLAG=-fPIC # Any Linux compiler had better be gcc compatible. ;; *) AC_MSG_RESULT("") ;; esac fi AC_ARG_ENABLE(assertions, [AC_HELP_STRING([--enable-assertions], [Assertion checking])]) if test "$enable_assertions" != yes; then AC_DEFINE([NDEBUG], 1, [Define to disable assertion checking.]) fi AC_SUBST(PICFLAG) AC_SUBST(DEFS) AH_TEMPLATE([_PTHREADS], [Indicates the use of pthreads (NetBSD).]) AH_TEMPLATE([AO_USE_NANOSLEEP], [Use nanosleep() instead of select() (only if atomic operations \ are emulated)]) AH_TEMPLATE([AO_USE_NO_SIGNALS], [Do not block signals in compare_and_swap (only if atomic operations \ are emulated)]) AH_TEMPLATE([AO_USE_WIN32_PTHREADS], [Use Win32 Sleep() instead of select() (only if atomic operations \ are emulated)]) AH_TEMPLATE([AO_TRACE_MALLOC], [Trace AO_malloc/free calls (for debug only)]) # These macros are tested in public headers AH_TEMPLATE([AO_GENERALIZE_ASM_BOOL_CAS], [Force compare_and_swap definition via fetch_compare_and_swap]) AH_TEMPLATE([AO_PREFER_GENERALIZED], [Prefer generalized definitions to direct assembly-based ones]) AH_TEMPLATE([AO_USE_PTHREAD_DEFS], [Emulate atomic operations via slow and async-signal-unsafe \ pthread locking]) AH_TEMPLATE([AO_ASM_X64_AVAILABLE], [Inline assembly avalable (only VC/x86_64)]) AH_TEMPLATE([AO_ASSUME_VISTA], [Assume Windows Server 2003, Vista or later target (only VC/x86)]) AH_TEMPLATE([AO_ASSUME_WINDOWS98], [Assume hardware compare-and-swap functionality available \ on target (only VC/x86)]) AH_TEMPLATE([AO_CMPXCHG16B_AVAILABLE], [Assume target is not old AMD Opteron chip (only x86_64)]) AH_TEMPLATE([AO_FORCE_USE_SWP], [Force test_and_set to use SWP instruction instead of LDREX/STREX \ (only arm v6+)]) AH_TEMPLATE([AO_NO_SPARC_V9], [Assume target is not sparc v9+ (only sparc)]) AH_TEMPLATE([AO_OLD_STYLE_INTERLOCKED_COMPARE_EXCHANGE], [Assume ancient MS VS Win32 headers (only VC/arm v6+, VC/x86)]) AH_TEMPLATE([AO_UNIPROCESSOR], [Assume single-core target (only arm v6+)]) AH_TEMPLATE([AO_USE_INTERLOCKED_INTRINSICS], [Assume Win32 _Interlocked primitives available as intrinsics \ (only VC/arm)]) AH_TEMPLATE([AO_USE_PENTIUM4_INSTRS], [Use Pentium 4 'mfence' instruction (only x86)]) AH_TEMPLATE([AO_USE_SYNC_CAS_BUILTIN], [Prefer GCC built-in CAS intrinsics in favor of inline assembly \ (only gcc/x86, gcc/x86_64)]) AH_TEMPLATE([AO_WEAK_DOUBLE_CAS_EMULATION], [Emulate double-width CAS via pthread locking in case of no hardware \ support (only gcc/x86_64, the emulation is unsafe)]) AC_DEFINE(_REENTRANT, 1, [Required define if using POSIX threads.]) # Libraries needed to support threads (if any). have_pthreads=false AC_CHECK_LIB(pthread, pthread_self, have_pthreads=true) if test x$have_pthreads = xtrue; then THREADDLLIBS=-lpthread case "$host" in *-*-netbsd*) # Indicates the use of pthreads. AC_DEFINE(_PTHREADS) ;; *-*-openbsd* | *-*-kfreebsd*-gnu | *-*-dgux*) THREADDLLIBS=-pthread ;; *-*-cygwin* | *-*-darwin*) # Cygwin does not have a real libpthread, so Libtool cannot link # against it. THREADDLLIBS= ;; *-*-mingw*) # Use Win32 threads for tests anyway. THREADDLLIBS= # Skip test_atomic_pthreads. have_pthreads=false ;; esac else AC_DEFINE([AO_NO_PTHREADS], 1, [No pthreads library available]) # Assume VxWorks or Win32. THREADDLLIBS= fi AC_SUBST(THREADDLLIBS) AM_CONDITIONAL(HAVE_PTHREAD_H, test x$have_pthreads = xtrue) AM_CONDITIONAL(NEED_ASM, test x$need_asm = xtrue) AC_CONFIG_FILES([ Makefile doc/Makefile src/Makefile tests/Makefile pkgconfig/atomic_ops.pc pkgconfig/atomic_ops-uninstalled.pc ]) AC_CONFIG_COMMANDS([default],[[]],[[ PICFLAG="${PICFLAG}" CC="${CC}" DEFS="${DEFS}" ]]) AC_OUTPUT ecl-16.1.2/src/bdwgc/libatomic_ops/doc/000077500000000000000000000000001266352375300176265ustar00rootroot00000000000000ecl-16.1.2/src/bdwgc/libatomic_ops/doc/LICENSING.txt000066400000000000000000000053601266352375300217060ustar00rootroot00000000000000Our intent is to make it easy to use libatomic_ops, in both free and proprietary software. Hence most code that we expect to be linked into a client application is covered by an MIT-style license. A few library routines are covered by the GNU General Public License. These are put into a separate library, libatomic_ops_gpl.a . The low-level part of the library is mostly covered by the following license: ---------------------------------------- Copyright (c) ... Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. -------------------------------- A few files in the sysdeps directory were inherited in part from the Boehm-Demers-Weiser conservative garbage collector, and are covered by its license, which is similar in spirit: -------------------------------- Copyright (c) ... THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED OR IMPLIED. ANY USE IS AT YOUR OWN RISK. Permission is hereby granted to use or copy this program for any purpose, provided the above notices are retained on all copies. Permission to modify the code and to distribute modified code is granted, provided the above notices are retained, and a notice that the code was modified is included with the above copyright notice. ---------------------------------- A few files are covered by the GNU General Public License. (See file "COPYING".) This applies only to test code, sample applications, and the libatomic_ops_gpl portion of the library. Thus libatomic_ops_gpl should generally not be linked into proprietary code. (This distinction was motivated by patent considerations.) It is possible that the license of the GPL pieces may be changed for future versions to make them more consistent with the rest of the package. If you submit patches, and have strong preferences about licensing, please express them. ecl-16.1.2/src/bdwgc/libatomic_ops/doc/Makefile.am000066400000000000000000000002011266352375300216530ustar00rootroot00000000000000# installed documentation # dist_pkgdata_DATA=LICENSING.txt README.txt README_stack.txt \ README_malloc.txt README_win32.txt ecl-16.1.2/src/bdwgc/libatomic_ops/doc/Makefile.in000066400000000000000000000345031266352375300217000ustar00rootroot00000000000000# Makefile.in generated by automake 1.15 from Makefile.am. # @configure_input@ # Copyright (C) 1994-2014 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__is_gnu_make = { \ if test -z '$(MAKELEVEL)'; then \ false; \ elif test -n '$(MAKE_HOST)'; then \ true; \ elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \ true; \ else \ false; \ fi; \ } am__make_running_with_option = \ case $${target_option-} in \ ?) ;; \ *) echo "am__make_running_with_option: internal error: invalid" \ "target option '$${target_option-}' specified" >&2; \ exit 1;; \ esac; \ has_opt=no; \ sane_makeflags=$$MAKEFLAGS; \ if $(am__is_gnu_make); then \ sane_makeflags=$$MFLAGS; \ else \ case $$MAKEFLAGS in \ *\\[\ \ ]*) \ bs=\\; \ sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \ | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \ esac; \ fi; \ skip_next=no; \ strip_trailopt () \ { \ flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \ }; \ for flg in $$sane_makeflags; do \ test $$skip_next = yes && { skip_next=no; continue; }; \ case $$flg in \ *=*|--*) continue;; \ -*I) strip_trailopt 'I'; skip_next=yes;; \ -*I?*) strip_trailopt 'I';; \ -*O) strip_trailopt 'O'; skip_next=yes;; \ -*O?*) strip_trailopt 'O';; \ -*l) strip_trailopt 'l'; skip_next=yes;; \ -*l?*) strip_trailopt 'l';; \ -[dEDm]) skip_next=yes;; \ -[JT]) skip_next=yes;; \ esac; \ case $$flg in \ *$$target_option*) has_opt=yes; break;; \ esac; \ done; \ test $$has_opt = yes am__make_dryrun = (target_option=n; $(am__make_running_with_option)) am__make_keepgoing = (target_option=k; $(am__make_running_with_option)) 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@ target_triplet = @target@ subdir = doc 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) DIST_COMMON = $(srcdir)/Makefile.am $(dist_pkgdata_DATA) \ $(am__DIST_COMMON) mkinstalldirs = $(install_sh) -d CONFIG_HEADER = $(top_builddir)/src/config.h CONFIG_CLEAN_FILES = CONFIG_CLEAN_VPATH_FILES = 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 = SOURCES = DIST_SOURCES = am__can_run_installinfo = \ case $$AM_UPDATE_INFO_DIR in \ n|no|NO) false;; \ *) (install-info --version) >/dev/null 2>&1;; \ esac 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)$(pkgdatadir)" DATA = $(dist_pkgdata_DATA) am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP) am__DIST_COMMON = $(srcdir)/Makefile.in DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) ACLOCAL = @ACLOCAL@ AMTAR = @AMTAR@ AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@ AR = @AR@ AUTOCONF = @AUTOCONF@ AUTOHEADER = @AUTOHEADER@ AUTOMAKE = @AUTOMAKE@ AWK = @AWK@ CC = @CC@ CCAS = @CCAS@ CCASDEPMODE = @CCASDEPMODE@ CCASFLAGS = @CCASFLAGS@ CCDEPMODE = @CCDEPMODE@ CFLAGS = @CFLAGS@ CPP = @CPP@ CPPFLAGS = @CPPFLAGS@ 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@ LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@ 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@ PICFLAG = @PICFLAG@ RANLIB = @RANLIB@ SED = @SED@ SET_MAKE = @SET_MAKE@ SHELL = @SHELL@ STRIP = @STRIP@ THREADDLLIBS = @THREADDLLIBS@ 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_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 = @target@ target_alias = @target_alias@ target_cpu = @target_cpu@ target_os = @target_os@ target_vendor = @target_vendor@ top_build_prefix = @top_build_prefix@ top_builddir = @top_builddir@ top_srcdir = @top_srcdir@ # installed documentation # dist_pkgdata_DATA = LICENSING.txt README.txt README_stack.txt \ README_malloc.txt README_win32.txt all: all-am .SUFFIXES: $(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.am $(am__configure_deps) @for dep in $?; do \ case '$(am__configure_deps)' in \ *$$dep*) \ ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \ && { if test -f $@; then exit 0; else break; fi; }; \ exit 1;; \ esac; \ done; \ echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign doc/Makefile'; \ $(am__cd) $(top_srcdir) && \ $(AUTOMAKE) --foreign doc/Makefile Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status @case '$?' in \ *config.status*) \ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \ *) \ echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \ cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \ esac; $(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh $(top_srcdir)/configure: @MAINTAINER_MODE_TRUE@ $(am__configure_deps) cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh $(ACLOCAL_M4): @MAINTAINER_MODE_TRUE@ $(am__aclocal_m4_deps) cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh $(am__aclocal_m4_deps): mostlyclean-libtool: -rm -f *.lo clean-libtool: -rm -rf .libs _libs install-dist_pkgdataDATA: $(dist_pkgdata_DATA) @$(NORMAL_INSTALL) @list='$(dist_pkgdata_DATA)'; test -n "$(pkgdatadir)" || list=; \ if test -n "$$list"; then \ echo " $(MKDIR_P) '$(DESTDIR)$(pkgdatadir)'"; \ $(MKDIR_P) "$(DESTDIR)$(pkgdatadir)" || 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)$(pkgdatadir)'"; \ $(INSTALL_DATA) $$files "$(DESTDIR)$(pkgdatadir)" || exit $$?; \ done uninstall-dist_pkgdataDATA: @$(NORMAL_UNINSTALL) @list='$(dist_pkgdata_DATA)'; test -n "$(pkgdatadir)" || list=; \ files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \ dir='$(DESTDIR)$(pkgdatadir)'; $(am__uninstall_files_from_dir) tags TAGS: ctags CTAGS: cscope cscopelist: distdir: $(DISTFILES) @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 check-am: all-am check: check-am all-am: Makefile $(DATA) installdirs: for dir in "$(DESTDIR)$(pkgdatadir)"; 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) 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-libtool mostlyclean-am distclean: distclean-am -rm -f Makefile distclean-am: clean-am distclean-generic dvi: dvi-am dvi-am: html: html-am html-am: info: info-am info-am: install-data-am: install-dist_pkgdataDATA install-dvi: install-dvi-am install-dvi-am: install-exec-am: 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 Makefile maintainer-clean-am: distclean-am maintainer-clean-generic mostlyclean: mostlyclean-am mostlyclean-am: mostlyclean-generic mostlyclean-libtool pdf: pdf-am pdf-am: ps: ps-am ps-am: uninstall-am: uninstall-dist_pkgdataDATA .MAKE: install-am install-strip .PHONY: all all-am check check-am clean clean-generic clean-libtool \ cscopelist-am ctags-am distclean distclean-generic \ distclean-libtool distdir dvi dvi-am html html-am info info-am \ install install-am install-data install-data-am \ install-dist_pkgdataDATA install-dvi install-dvi-am \ install-exec install-exec-am install-html install-html-am \ install-info install-info-am install-man install-pdf \ install-pdf-am install-ps install-ps-am install-strip \ installcheck installcheck-am installdirs maintainer-clean \ maintainer-clean-generic mostlyclean mostlyclean-generic \ mostlyclean-libtool pdf pdf-am ps ps-am tags-am uninstall \ uninstall-am uninstall-dist_pkgdataDATA .PRECIOUS: Makefile # 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: ecl-16.1.2/src/bdwgc/libatomic_ops/doc/README.txt000066400000000000000000000272011266352375300213260ustar00rootroot00000000000000Usage: 0) If possible, do this on a multiprocessor, especially if you are planning on modifying or enhancing the package. It will work on a uniprocessor, but the tests are much more likely to pass in the presence of serious problems. 1) Type ./configure --prefix=; make; make check in the directory containing unpacked source. The usual GNU build machinery is used, except that only static, but position-independent, libraries are normally built. On Windows, read README_win32.txt instead. 2) Applications should include atomic_ops.h. Nearly all operations are implemented by header files included from it. It is sometimes necessary, and always recommended to also link against libatomic_ops.a. To use the almost non-blocking stack or malloc implementations, see the corresponding README files, and also link against libatomic_gpl.a before linking against libatomic_ops.a. OVERVIEW: Atomic_ops.h defines a large collection of operations, each one of which is a combination of an (optional) atomic memory operation, and a memory barrier. Also defines associated feature-test macros to determine whether a particular operation is available on the current target hardware (either directly or by synthesis). This is an attempt to replace various existing files with similar goals, since they usually do not handle differences in memory barrier styles with sufficient generality. If this is included after defining AO_REQUIRE_CAS, then the package will make an attempt to emulate compare-and-swap in a way that (at least on Linux) should still be async-signal-safe. As a result, most other atomic operations will then be defined using the compare-and-swap emulation. This emulation is slow, since it needs to disable signals. And it needs to block in case of contention. If you care about performance on a platform that can't directly provide compare-and-swap, there are probably better alternatives. But this allows easy ports to some such platforms (e.g. PA_RISC). The option is ignored if compare-and-swap can be implemented directly. If atomic_ops.h is included after defining AO_USE_PTHREAD_DEFS, then all atomic operations will be emulated with pthread locking. This is NOT async-signal-safe. And it is slow. It is intended primarily for debugging of the atomic_ops package itself. Note that the implementation reflects our understanding of real processor behavior. This occasionally diverges from the documented behavior. (E.g. the documented X86 behavior seems to be weak enough that it is impractical to use. Current real implementations appear to be much better behaved.) We of course are in no position to guarantee that future processors (even HPs) will continue to behave this way, though we hope they will. This is a work in progress. Corrections/additions for other platforms are greatly appreciated. It passes rudimentary tests on X86, Itanium, and Alpha. OPERATIONS: Most operations operate on values of type AO_t, which are unsigned integers whose size matches that of pointers on the given architecture. Exceptions are: - AO_test_and_set operates on AO_TS_t, which is whatever size the hardware supports with good performance. In some cases this is the length of a cache line. In some cases it is a byte. In many cases it is equivalent to AO_t. - A few operations are implemented on smaller or larger size integers. Such operations are indicated by the appropriate prefix: AO_char_... Operates on unsigned char values. AO_short_... Operates on unsigned short values. AO_int_... Operates on unsigned int values. (Currently a very limited selection of these is implemented. We're working on it.) The defined operations are all of the form AO_[_](). The component specifies an atomic memory operation. It may be one of the following, where the corresponding argument and result types are also specified: void nop() No atomic operation. The barrier may still be useful. AO_t load(const volatile AO_t * addr) Atomic load of *addr. void store(volatile AO_t * addr, AO_t new_val) Atomically store new_val to *addr. AO_t fetch_and_add(volatile AO_t *addr, AO_t incr) Atomically add incr to *addr, and return the original value of *addr. AO_t fetch_and_add1(volatile AO_t *addr) Equivalent to AO_fetch_and_add(addr, 1). AO_t fetch_and_sub1(volatile AO_t *addr) Equivalent to AO_fetch_and_add(addr, (AO_t)(-1)). void and(volatile AO_t *addr, AO_t value) Atomically 'and' value into *addr. void or(volatile AO_t *addr, AO_t value) Atomically 'or' value into *addr. void xor(volatile AO_t *addr, AO_t value) Atomically 'xor' value into *addr. int compare_and_swap(volatile AO_t * addr, AO_t old_val, AO_t new_val) Atomically compare *addr to old_val, and replace *addr by new_val if the first comparison succeeds. Returns nonzero if the comparison succeeded and *addr was updated. AO_t fetch_compare_and_swap(volatile AO_t * addr, AO_t old_val, AO_t new_val) Atomically compare *addr to old_val, and replace *addr by new_val if the first comparison succeeds; returns the original value of *addr. AO_TS_VAL_t test_and_set(volatile AO_TS_t * addr) Atomically read the binary value at *addr, and set it. AO_TS_VAL_t is an enumeration type which includes two values AO_TS_SET and AO_TS_CLEAR. An AO_TS_t location is capable of holding an AO_TS_VAL_t, but may be much larger, as dictated by hardware constraints. Test_and_set logically sets the value to AO_TS_SET. It may be reset to AO_TS_CLEAR with the AO_CLEAR(AO_TS_t *) macro. AO_TS_t locations should be initialized to AO_TS_INITIALIZER. The values of AO_TS_SET and AO_TS_CLEAR are hardware dependent. (On PA-RISC, AO_TS_SET is zero!) Test_and_set is a more limited version of compare_and_swap. Its only advantage is that it is more easily implementable on some hardware. It should thus be used if only binary test-and-set functionality is needed. If available, we also provide compare_and_swap operations that operate on wider values. Since standard data types for double width values may not be available, these explicitly take pairs of arguments for the new and/or old value. Unfortunately, there are two common variants, neither of which can easily and efficiently emulate the other. The first performs a comparison against the entire value being replaced, where the second replaces a double-width replacement, but performs a single-width comparison: int compare_double_and_swap_double(volatile AO_double_t * addr, AO_t old_val1, AO_t old_val2, AO_t new_val1, AO_t new_val2); int compare_and_swap_double(volatile AO_double_t * addr, AO_t old_val1, AO_t new_val1, AO_t new_val2); where AO_double_t is a structure containing AO_val1 and AO_val2 fields, both of type AO_t. For compare_and_swap_double, we compare against the val1 field. AO_double_t exists only if AO_HAVE_double_t is defined. ORDERING CONSTRAINTS: Each operation name also includes a suffix that specifies the associated ordering semantics. The ordering constraint limits reordering of this operation with respect to other atomic operations and ordinary memory references. The current implementation assumes that all memory references are to ordinary cacheable memory; the ordering guarantee is with respect to other threads or processes, not I/O devices. (Whether or not this distinction is important is platform-dependent.) Ordering suffixes are one of the following: : No memory barrier. A plain AO_nop() really does nothing. _release: Earlier operations must become visible to other threads before the atomic operation. _acquire: Later operations must become visible after this operation. _read: Subsequent reads must become visible after reads included in the atomic operation or preceding it. Rarely useful for clients? _write: Earlier writes become visible before writes during or after the atomic operation. Rarely useful for clients? _full: Ordered with respect to both earlier and later memory ops. AO_store_full or AO_nop_full are the normal ways to force a store to be ordered with respect to a later load. _release_write: Ordered with respect to earlier writes. This is normally implemented as either a _write or _release barrier. _acquire_read: Ordered with respect to later reads. This is normally implemented as either a _read or _acquire barrier. _dd_acquire_read: Ordered with respect to later reads that are data dependent on this one. This is needed on a pointer read, which is later dereferenced to read a second value, with the expectation that the second read is ordered after the first one. On most architectures, this is equivalent to no barrier. (This is very hard to define precisely. It should probably be avoided. A major problem is that optimizers tend to try to eliminate dependencies from the generated code, since dependencies force the hardware to execute the code serially.) We assume that if a store is data-dependent on a previous load, then the two are always implicitly ordered. It is possible to test whether AO_ is available on the current platform by checking whether AO_HAVE__ is defined as a macro. Note that we generally don't implement operations that are either meaningless (e.g. AO_nop_acquire, AO_nop_release) or which appear to have no clear use (e.g. AO_load_release, AO_store_acquire, AO_load_write, AO_store_read). On some platforms (e.g. PA-RISC) many operations will remain undefined unless AO_REQUIRE_CAS is defined before including the package. When typed in the package build directory, the following command will print operations that are unimplemented on the platform: make test_atomic; ./test_atomic The following command generates a file "list_atomic.i" containing the macro expansions of all implemented operations on the platform: make list_atomic.i Future directions: It currently appears that something roughly analogous to this is very likely to become part of the C++0x standard. That effort has pointed out a number of issues that we expect to address there. Since some of the solutions really require compiler support, they may not be completely addressed here. Known issues include: We should be more precise in defining the semantics of the ordering constraints, and if and how we can guarantee sequential consistency. Dd_acquire_read is very hard or impossible to define in a way that cannot be invalidated by reasonably standard compiler transformations. There is probably no good reason to provide operations on standard integer types, since those may have the wrong alignment constraints. Example: If you want to initialize an object, and then "publish" a pointer to it in a global location p, such that other threads reading the new value of p are guaranteed to see an initialized object, it suffices to use AO_release_write(p, ...) to write the pointer to the object, and to retrieve it in other threads with AO_acquire_read(p). Platform notes: All X86: We quietly assume 486 or better. Microsoft compilers: Define AO_ASSUME_WINDOWS98 to get access to hardware compare-and-swap functionality. This relies on the InterlockedCompareExchange() function which was apparently not supported in Windows95. (There may be a better way to get access to this.) Gcc on x86: Define AO_USE_PENTIUM4_INSTRS to use the Pentium 4 mfence instruction. Currently this is appears to be of marginal benefit. ecl-16.1.2/src/bdwgc/libatomic_ops/doc/README_malloc.txt000066400000000000000000000060161266352375300226560ustar00rootroot00000000000000The libatomic_ops_gpl includes a simple almost-lock-free malloc implementation. This is intended as a safe way to allocate memory from a signal handler, or to allocate memory in the context of a library that does not know what thread library it will be used with. In either case locking is impossible. Note that the operations are only guaranteed to be 1-lock-free, i.e. a single blocked thread will not prevent progress, but multiple blocked threads may. To safely use these operations in a signal handler, the handler should be non-reentrant, i.e. it should not be interruptable by another handler using these operations. Furthermore use outside of signal handlers in a multithreaded application should be protected by a lock, so that at most one invocation may be interrupted by a signal. The header will define the macro "AO_MALLOC_IS_LOCK_FREE" on platforms on which malloc is completely lock-free, and hence these restrictions do not apply. In the presence of threads, but absence of contention, the time performance of this package should be as good, or slightly better than, most system malloc implementations. Its space performance is theoretically optimal (to within a constant factor), but probably quite poor in practice. In particular, no attempt is made to coalesce free small memory blocks. Something like Doug Lea's malloc is likely to use significantly less memory for complex applications. Performance on platforms without an efficient compare-and-swap implementation will be poor. This package was not designed for processor-scalability in the face of high allocation rates. If all threads happen to allocate different-sized objects, you might get lucky. Otherwise expect contention and false-sharing problems. If this is an issue, something like Maged Michael's algorithm (PLDI 2004) would be technically a far better choice. If you are concerned only with scalability, and not signal-safety, you might also consider using Hoard instead. We have seen a factor of 3 to 4 slowdown from the standard glibc malloc implementation with contention, even when the performance without contention was faster. (To make the implementation more scalable, one would need to replicate at least the free list headers, so that concurrent access is possible without cache conflicts.) Unfortunately there is no portable async-signal-safe way to obtain large chunks of memory from the OS. Based on reading of the source code, mmap-based allocation appears safe under Linux, and probably BSD variants. It is probably unsafe for operating systems built on Mach, such as Apple's Darwin. Without use of mmap, the allocator is limited to a fixed size, statically preallocated heap (2MB by default), and will fail to allocate objects above a certain size (just under 64K by default). Use of mmap to circumvent these limitations requires an explicit call. The entire interface to the AO_malloc package currently consists of: #include /* includes atomic_ops.h */ void *AO_malloc(size_t sz); void AO_free(void *p); void AO_malloc_enable_mmap(void); ecl-16.1.2/src/bdwgc/libatomic_ops/doc/README_stack.txt000066400000000000000000000075671266352375300225300ustar00rootroot00000000000000Note that the AO_stack implementation is licensed under the GPL, unlike the lower level routines. The header file atomic_ops_stack.h defines a linked stack abstraction. Stacks may be accessed by multiple concurrent threads. The implementation is 1-lock-free, i.e. it will continue to make progress if at most one thread becomes inactive while operating on the data structure. (The implementation can be built to be N-lock-free for any given N. But that seems to rarely be useful, especially since larger N involve some slowdown.) This makes it safe to access these data structures from non-reentrant signal handlers, provided at most one non-signal-handler thread is accessing the data structure at once. This latter condition can be ensured by acquiring an ordinary lock around the non-handler accesses to the data structure. For details see: Hans-J. Boehm, "An Almost Non-Blocking Stack", PODC 2004, http://portal.acm.org/citation.cfm?doid=1011767.1011774 (This is not exactly the implementation described there, since the interface was cleaned up in the interim. But it should perform very similarly.) We use a fully lock-free implementation when the underlying hardware makes that less expensive, i.e. when we have a double-wide compare-and-swap operation available. (The fully lock-free implementation uses an AO_t- sized version count, and assumes it does not wrap during the time any given operation is active. This seems reasonably safe on 32-bit hardware, and very safe on 64-bit hardware.) If a fully lock-free implementation is used, the macro AO_STACK_IS_LOCK_FREE will be defined. The implementation is interesting only because it allows reuse of existing nodes. This is necessary, for example, to implement a memory allocator. Since we want to leave the precise stack node type up to the client, we insist only that each stack node contains a link field of type AO_t. When a new node is pushed on the stack, the push operation expects to be passed the pointer to this link field, which will then be overwritten by this link field. Similarly, the pop operation returns a pointer to the link field of the object that previously was on the top of the stack. The cleanest way to use these routines is probably to define the stack node type with an initial AO_t link field, so that the conversion between the link-field pointer and the stack element pointer is just a compile-time cast. But other possibilities exist. (This would be cleaner in C++ with templates.) A stack is represented by an AO_stack_t structure. (This is normally 2 or 3 times the size of a pointer.) It may be statically initialized by setting it to AO_STACK_INITIALIZER, or dynamically initialized to an empty stack with AO_stack_init. There are only three operations for accessing stacks: void AO_stack_init(AO_stack_t *list); void AO_stack_push_release(AO_stack_t *list, AO_t *new_element); AO_t * AO_stack_pop_acquire(volatile AO_stack_t *list); We require that the objects pushed as list elements remain addressable as long as any push or pop operation are in progress. (It is OK for an object to be "pop"ped off a stack and "deallocated" with a concurrent "pop" on the same stack still in progress, but only if "deallocation" leaves the object addressable. The second "pop" may still read the object, but the value it reads will not matter.) We require that the headers (AO_stack objects) remain allocated and valid as long as any operations on them are still in-flight. We also provide macros AO_REAL_HEAD_PTR that converts an AO_stack_t to a pointer to the link field in the next element, and AO_REAL_NEXT_PTR that converts a link field to a real, dereferencable, pointer to the link field in the next element. This is intended only for debugging, or to traverse the list after modification has ceased. There is otherwise no guarantee that walking a stack using this macro will produce any kind of consistent picture of the data structure. ecl-16.1.2/src/bdwgc/libatomic_ops/doc/README_win32.txt000066400000000000000000000031651266352375300223530ustar00rootroot00000000000000Most of the atomic_ops functionality is available under Win32 with the Microsoft tools, but the build process currently is considerably more primitive than on Linux/Unix platforms. To build: 1) Go to the src directory in the distribution. 2) Make sure the Microsoft command-line tools (e.g. nmake) are available. 3) Run "nmake -f Makefile.msft". This should run some tests, which may print warnings about the types of the "Interlocked" functions. I haven't been able to make all versions of VC++ happy. If you know how to, please send a patch. 4) To compile applications, you will need to retain or copy the following pieces from the resulting src directory contents: "atomic_ops.h" - Header file defining low-level primitives. This includes files from: "atomic_ops"- Subdirectory containing implementation header files. "atomic_ops_stack.h" - Header file describing almost lock-free stack. "atomic_ops_malloc.h" - Header file describing almost lock-free malloc. "libatomic_ops_gpl.lib" - Library containing implementation of the above two (plus AO_pause() defined in atomic_ops.c). The atomic_ops.h implementation is entirely in the header files in Win32. Most clients of atomic_ops.h will need to define AO_ASSUME_WINDOWS98 before including it. Compare_and_swap is otherwise not available. Defining AO_ASSUME_VISTA will make compare_double_and_swap_double available as well. Note that the library is covered by the GNU General Public License, while the top 2 of these pieces allow use in proprietary code. ecl-16.1.2/src/bdwgc/libatomic_ops/pkgconfig/000077500000000000000000000000001266352375300210305ustar00rootroot00000000000000ecl-16.1.2/src/bdwgc/libatomic_ops/pkgconfig/atomic_ops-uninstalled.pc.in000066400000000000000000000004671266352375300264450ustar00rootroot00000000000000prefix=@prefix@ exec_prefix=@exec_prefix@ top_builddir=@abs_top_builddir@ top_srcdir=@abs_top_srcdir@ Name: The atomic_ops library (uninstalled) Description: Atomic memory update operations Version: @PACKAGE_VERSION@ Libs: ${top_builddir}/src/libatomic_ops.la Cflags: -I${top_builddir}/src -I${top_srcdir}/src ecl-16.1.2/src/bdwgc/libatomic_ops/pkgconfig/atomic_ops.pc.in000066400000000000000000000004071266352375300241170ustar00rootroot00000000000000prefix=@prefix@ exec_prefix=@exec_prefix@ libdir=@libdir@ includedir=@includedir@ Name: The atomic_ops library Description: Atomic memory update operations portable implementation Version: @PACKAGE_VERSION@ Libs: -L${libdir} -latomic_ops Cflags: -I${includedir} ecl-16.1.2/src/bdwgc/libatomic_ops/src/000077500000000000000000000000001266352375300176505ustar00rootroot00000000000000ecl-16.1.2/src/bdwgc/libatomic_ops/src/Makefile.am000066400000000000000000000250471266352375300217140ustar00rootroot00000000000000AM_CFLAGS=@PICFLAG@ AM_CPPFLAGS = -I$(top_builddir)/src -I$(top_srcdir)/src include_HEADERS = atomic_ops.h atomic_ops_stack.h atomic_ops_malloc.h lib_LTLIBRARIES = libatomic_ops.la libatomic_ops_gpl.la if NEED_ASM libatomic_ops_la_SOURCES = atomic_ops.c atomic_ops_sysdeps.S else libatomic_ops_la_SOURCES = atomic_ops.c endif libatomic_ops_la_LDFLAGS = -version-info 1:3:0 -no-undefined libatomic_ops_gpl_la_SOURCES = atomic_ops_stack.c atomic_ops_malloc.c libatomic_ops_gpl_la_LDFLAGS = -version-info 1:3:0 -no-undefined libatomic_ops_gpl_la_LIBADD = libatomic_ops.la EXTRA_DIST = Makefile.msft atomic_ops/sysdeps/README \ atomic_ops/generalize-arithm.template \ atomic_ops/generalize-small.template \ atomic_ops/sysdeps/ao_t_is_int.template \ atomic_ops/sysdeps/gcc/generic-arithm.template \ atomic_ops/sysdeps/gcc/generic-small.template \ atomic_ops/sysdeps/loadstore/acquire_release_volatile.template \ atomic_ops/sysdeps/loadstore/atomic_load.template \ atomic_ops/sysdeps/loadstore/atomic_store.template \ atomic_ops/sysdeps/loadstore/ordered_loads_only.template \ atomic_ops/sysdeps/loadstore/ordered_stores_only.template \ atomic_ops/sysdeps/sunc/sparc.S BUILT_SOURCES = atomic_ops/generalize-arithm.h \ atomic_ops/generalize-small.h \ atomic_ops/sysdeps/ao_t_is_int.h \ atomic_ops/sysdeps/gcc/generic-arithm.h \ atomic_ops/sysdeps/gcc/generic-small.h \ atomic_ops/sysdeps/loadstore/acquire_release_volatile.h \ atomic_ops/sysdeps/loadstore/atomic_load.h \ atomic_ops/sysdeps/loadstore/atomic_store.h \ atomic_ops/sysdeps/loadstore/char_acquire_release_volatile.h \ atomic_ops/sysdeps/loadstore/char_atomic_load.h \ atomic_ops/sysdeps/loadstore/char_atomic_store.h \ atomic_ops/sysdeps/loadstore/int_acquire_release_volatile.h \ atomic_ops/sysdeps/loadstore/int_atomic_load.h \ atomic_ops/sysdeps/loadstore/int_atomic_store.h \ atomic_ops/sysdeps/loadstore/ordered_loads_only.h \ atomic_ops/sysdeps/loadstore/ordered_stores_only.h \ atomic_ops/sysdeps/loadstore/short_acquire_release_volatile.h \ atomic_ops/sysdeps/loadstore/short_atomic_load.h \ atomic_ops/sysdeps/loadstore/short_atomic_store.h #Private Headers privatedir=${includedir}/ nobase_private_HEADERS = atomic_ops/ao_version.h \ atomic_ops/generalize.h \ $(BUILT_SOURCES) \ \ atomic_ops/sysdeps/all_acquire_release_volatile.h \ atomic_ops/sysdeps/all_aligned_atomic_load_store.h \ atomic_ops/sysdeps/all_atomic_load_store.h \ atomic_ops/sysdeps/all_atomic_only_load.h \ atomic_ops/sysdeps/emul_cas.h \ atomic_ops/sysdeps/generic_pthread.h \ atomic_ops/sysdeps/ordered.h \ atomic_ops/sysdeps/ordered_except_wr.h \ atomic_ops/sysdeps/read_ordered.h \ atomic_ops/sysdeps/standard_ao_double_t.h \ atomic_ops/sysdeps/test_and_set_t_is_ao_t.h \ atomic_ops/sysdeps/test_and_set_t_is_char.h \ \ atomic_ops/sysdeps/armcc/arm_v6.h \ \ atomic_ops/sysdeps/gcc/aarch64.h \ atomic_ops/sysdeps/gcc/alpha.h \ atomic_ops/sysdeps/gcc/arm.h \ atomic_ops/sysdeps/gcc/avr32.h \ atomic_ops/sysdeps/gcc/cris.h \ atomic_ops/sysdeps/gcc/generic.h \ atomic_ops/sysdeps/gcc/hexagon.h \ atomic_ops/sysdeps/gcc/hppa.h \ atomic_ops/sysdeps/gcc/ia64.h \ atomic_ops/sysdeps/gcc/m68k.h \ atomic_ops/sysdeps/gcc/mips.h \ atomic_ops/sysdeps/gcc/powerpc.h \ atomic_ops/sysdeps/gcc/s390.h \ atomic_ops/sysdeps/gcc/sh.h \ atomic_ops/sysdeps/gcc/sparc.h \ atomic_ops/sysdeps/gcc/x86.h \ \ atomic_ops/sysdeps/hpc/hppa.h \ atomic_ops/sysdeps/hpc/ia64.h \ \ atomic_ops/sysdeps/ibmc/powerpc.h \ \ atomic_ops/sysdeps/icc/ia64.h \ \ atomic_ops/sysdeps/loadstore/double_atomic_load_store.h \ \ atomic_ops/sysdeps/msftc/arm.h \ atomic_ops/sysdeps/msftc/common32_defs.h \ atomic_ops/sysdeps/msftc/x86.h \ atomic_ops/sysdeps/msftc/x86_64.h \ \ atomic_ops/sysdeps/sunc/sparc.h \ atomic_ops/sysdeps/sunc/x86.h atomic_ops/generalize-small.h: atomic_ops/generalize-small.template mkdir -p `dirname $@` sed -e s:XSIZE:char:g -e s:XCTYPE:unsigned/**/char:g $? > $@ sed -e s:XSIZE:short:g -e s:XCTYPE:unsigned/**/short:g $? >> $@ sed -e s:XSIZE:int:g -e s:XCTYPE:unsigned:g $? >> $@ sed -e s:XSIZE_::g -e s:XCTYPE:AO_t:g $? >> $@ sed -e s:XSIZE:double:g -e s:XCTYPE:AO_double_t:g $? >> $@ atomic_ops/generalize-arithm.h: atomic_ops/generalize-arithm.template mkdir -p `dirname $@` sed -e s:XSIZE:char:g -e s:XCTYPE:unsigned/**/char:g $? > $@ sed -e s:XSIZE:short:g -e s:XCTYPE:unsigned/**/short:g $? >> $@ sed -e s:XSIZE:int:g -e s:XCTYPE:unsigned:g $? >> $@ sed -e s:XSIZE_::g -e s:XCTYPE:AO_t:g $? >> $@ atomic_ops/sysdeps/ao_t_is_int.h: atomic_ops/sysdeps/ao_t_is_int.template mkdir -p `dirname $@` sed -e s:_XBAR::g $? > $@ sed -e s:XBAR:full:g $? >> $@ sed -e s:XBAR:acquire:g $? >> $@ sed -e s:XBAR:release:g $? >> $@ sed -e s:XBAR:write:g $? >> $@ sed -e s:XBAR:read:g $? >> $@ atomic_ops/sysdeps/gcc/generic-arithm.h: \ atomic_ops/sysdeps/gcc/generic-arithm.template mkdir -p `dirname $@` sed -e s:_XBAR::g -e s:XGCCBAR:RELAXED:g \ -e s:XSIZE:char:g -e s:XCTYPE:unsigned/**/char:g $? > $@ sed -e s:_XBAR::g -e s:XGCCBAR:RELAXED:g \ -e s:XSIZE:short:g -e s:XCTYPE:unsigned/**/short:g $? >> $@ sed -e s:_XBAR::g -e s:XGCCBAR:RELAXED:g \ -e s:XSIZE:int:g -e s:XCTYPE:unsigned:g $? >> $@ sed -e s:_XBAR::g -e s:XGCCBAR:RELAXED:g \ -e s:XSIZE_::g -e s:XCTYPE:AO_t:g $? >> $@ sed -e s:XBAR:acquire:g -e s:XGCCBAR:ACQUIRE:g \ -e s:XSIZE:char:g -e s:XCTYPE:unsigned/**/char:g $? >> $@ sed -e s:XBAR:acquire:g -e s:XGCCBAR:ACQUIRE:g \ -e s:XSIZE:short:g -e s:XCTYPE:unsigned/**/short:g $? >> $@ sed -e s:XBAR:acquire:g -e s:XGCCBAR:ACQUIRE:g \ -e s:XSIZE:int:g -e s:XCTYPE:unsigned:g $? >> $@ sed -e s:XBAR:acquire:g -e s:XGCCBAR:ACQUIRE:g \ -e s:XSIZE_::g -e s:XCTYPE:AO_t:g $? >> $@ sed -e s:XBAR:release:g -e s:XGCCBAR:RELEASE:g \ -e s:XSIZE:char:g -e s:XCTYPE:unsigned/**/char:g $? >> $@ sed -e s:XBAR:release:g -e s:XGCCBAR:RELEASE:g \ -e s:XSIZE:short:g -e s:XCTYPE:unsigned/**/short:g $? >> $@ sed -e s:XBAR:release:g -e s:XGCCBAR:RELEASE:g \ -e s:XSIZE:int:g -e s:XCTYPE:unsigned:g $? >> $@ sed -e s:XBAR:release:g -e s:XGCCBAR:RELEASE:g \ -e s:XSIZE_::g -e s:XCTYPE:AO_t:g $? >> $@ sed -e s:XBAR:full:g -e s:XGCCBAR:SEQ_CST:g \ -e s:XSIZE:char:g -e s:XCTYPE:unsigned/**/char:g $? >> $@ sed -e s:XBAR:full:g -e s:XGCCBAR:SEQ_CST:g \ -e s:XSIZE:short:g -e s:XCTYPE:unsigned/**/short:g $? >> $@ sed -e s:XBAR:full:g -e s:XGCCBAR:SEQ_CST:g \ -e s:XSIZE:int:g -e s:XCTYPE:unsigned:g $? >> $@ sed -e s:XBAR:full:g -e s:XGCCBAR:SEQ_CST:g \ -e s:XSIZE_::g -e s:XCTYPE:AO_t:g $? >> $@ atomic_ops/sysdeps/gcc/generic-small.h: \ atomic_ops/sysdeps/gcc/generic-small.template mkdir -p `dirname $@` sed -e s:XSIZE:char:g -e s:XCTYPE:unsigned/**/char:g $? > $@ sed -e s:XSIZE:short:g -e s:XCTYPE:unsigned/**/short:g $? >> $@ sed -e s:XSIZE:int:g -e s:XCTYPE:unsigned:g $? >> $@ sed -e s:XSIZE_::g -e s:XCTYPE:AO_t:g $? >> $@ atomic_ops/sysdeps/loadstore/ordered_loads_only.h: \ atomic_ops/sysdeps/loadstore/ordered_loads_only.template mkdir -p `dirname $@` sed -e s:XSIZE:char:g -e s:XCTYPE:unsigned/**/char:g $? > $@ sed -e s:XSIZE:short:g -e s:XCTYPE:unsigned/**/short:g $? >> $@ sed -e s:XSIZE:int:g -e s:XCTYPE:unsigned:g $? >> $@ sed -e s:XSIZE_::g -e s:XCTYPE:AO_t:g $? >> $@ sed -e s:XSIZE:double:g -e s:XCTYPE:AO_double_t:g $? >> $@ atomic_ops/sysdeps/loadstore/ordered_stores_only.h: \ atomic_ops/sysdeps/loadstore/ordered_stores_only.template mkdir -p `dirname $@` sed -e s:XSIZE:char:g -e s:XCTYPE:unsigned/**/char:g $? > $@ sed -e s:XSIZE:short:g -e s:XCTYPE:unsigned/**/short:g $? >> $@ sed -e s:XSIZE:int:g -e s:XCTYPE:unsigned:g $? >> $@ sed -e s:XSIZE_::g -e s:XCTYPE:AO_t:g $? >> $@ sed -e s:XSIZE:double:g -e s:XCTYPE:AO_double_t:g $? >> $@ atomic_ops/sysdeps/loadstore/acquire_release_volatile.h: \ atomic_ops/sysdeps/loadstore/acquire_release_volatile.template mkdir -p `dirname $@` sed -e s:XSIZE_::g -e s:XCTYPE:AO_t:g $? > $@ atomic_ops/sysdeps/loadstore/char_acquire_release_volatile.h: \ atomic_ops/sysdeps/loadstore/acquire_release_volatile.template mkdir -p `dirname $@` sed -e s:XSIZE:char:g -e s:XCTYPE:unsigned/**/char:g $? > $@ atomic_ops/sysdeps/loadstore/int_acquire_release_volatile.h: \ atomic_ops/sysdeps/loadstore/acquire_release_volatile.template mkdir -p `dirname $@` sed -e s:XSIZE:int:g -e s:XCTYPE:unsigned:g $? > $@ atomic_ops/sysdeps/loadstore/short_acquire_release_volatile.h: \ atomic_ops/sysdeps/loadstore/acquire_release_volatile.template mkdir -p `dirname $@` sed -e s:XSIZE:short:g -e s:XCTYPE:unsigned/**/short:g $? > $@ atomic_ops/sysdeps/loadstore/atomic_load.h: \ atomic_ops/sysdeps/loadstore/atomic_load.template mkdir -p `dirname $@` sed -e s:XSIZE_::g -e s:XCTYPE:AO_t:g $? > $@ atomic_ops/sysdeps/loadstore/char_atomic_load.h: \ atomic_ops/sysdeps/loadstore/atomic_load.template mkdir -p `dirname $@` sed -e s:XSIZE:char:g -e s:XCTYPE:unsigned/**/char:g $? > $@ atomic_ops/sysdeps/loadstore/int_atomic_load.h: \ atomic_ops/sysdeps/loadstore/atomic_load.template mkdir -p `dirname $@` sed -e s:XSIZE:int:g -e s:XCTYPE:unsigned:g $? > $@ atomic_ops/sysdeps/loadstore/short_atomic_load.h: \ atomic_ops/sysdeps/loadstore/atomic_load.template mkdir -p `dirname $@` sed -e s:XSIZE:short:g -e s:XCTYPE:unsigned/**/short:g $? > $@ atomic_ops/sysdeps/loadstore/atomic_store.h: \ atomic_ops/sysdeps/loadstore/atomic_store.template mkdir -p `dirname $@` sed -e s:XSIZE_::g -e s:XCTYPE:AO_t:g $? > $@ atomic_ops/sysdeps/loadstore/char_atomic_store.h: \ atomic_ops/sysdeps/loadstore/atomic_store.template mkdir -p `dirname $@` sed -e s:XSIZE:char:g -e s:XCTYPE:unsigned/**/char:g $? > $@ atomic_ops/sysdeps/loadstore/int_atomic_store.h: \ atomic_ops/sysdeps/loadstore/atomic_store.template mkdir -p `dirname $@` sed -e s:XSIZE:int:g -e s:XCTYPE:unsigned:g $? > $@ atomic_ops/sysdeps/loadstore/short_atomic_store.h: \ atomic_ops/sysdeps/loadstore/atomic_store.template mkdir -p `dirname $@` sed -e s:XSIZE:short:g -e s:XCTYPE:unsigned/**/short:g $? > $@ ecl-16.1.2/src/bdwgc/libatomic_ops/src/Makefile.in000066400000000000000000001104541266352375300217220ustar00rootroot00000000000000# Makefile.in generated by automake 1.15 from Makefile.am. # @configure_input@ # Copyright (C) 1994-2014 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__is_gnu_make = { \ if test -z '$(MAKELEVEL)'; then \ false; \ elif test -n '$(MAKE_HOST)'; then \ true; \ elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \ true; \ else \ false; \ fi; \ } am__make_running_with_option = \ case $${target_option-} in \ ?) ;; \ *) echo "am__make_running_with_option: internal error: invalid" \ "target option '$${target_option-}' specified" >&2; \ exit 1;; \ esac; \ has_opt=no; \ sane_makeflags=$$MAKEFLAGS; \ if $(am__is_gnu_make); then \ sane_makeflags=$$MFLAGS; \ else \ case $$MAKEFLAGS in \ *\\[\ \ ]*) \ bs=\\; \ sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \ | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \ esac; \ fi; \ skip_next=no; \ strip_trailopt () \ { \ flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \ }; \ for flg in $$sane_makeflags; do \ test $$skip_next = yes && { skip_next=no; continue; }; \ case $$flg in \ *=*|--*) continue;; \ -*I) strip_trailopt 'I'; skip_next=yes;; \ -*I?*) strip_trailopt 'I';; \ -*O) strip_trailopt 'O'; skip_next=yes;; \ -*O?*) strip_trailopt 'O';; \ -*l) strip_trailopt 'l'; skip_next=yes;; \ -*l?*) strip_trailopt 'l';; \ -[dEDm]) skip_next=yes;; \ -[JT]) skip_next=yes;; \ esac; \ case $$flg in \ *$$target_option*) has_opt=yes; break;; \ esac; \ done; \ test $$has_opt = yes am__make_dryrun = (target_option=n; $(am__make_running_with_option)) am__make_keepgoing = (target_option=k; $(am__make_running_with_option)) 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@ target_triplet = @target@ subdir = src 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) DIST_COMMON = $(srcdir)/Makefile.am $(include_HEADERS) \ $(nobase_private_HEADERS) $(am__DIST_COMMON) mkinstalldirs = $(install_sh) -d CONFIG_HEADER = config.h CONFIG_CLEAN_FILES = 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)$(includedir)" \ "$(DESTDIR)$(privatedir)" LTLIBRARIES = $(lib_LTLIBRARIES) libatomic_ops_la_LIBADD = am__libatomic_ops_la_SOURCES_DIST = atomic_ops.c atomic_ops_sysdeps.S @NEED_ASM_FALSE@am_libatomic_ops_la_OBJECTS = atomic_ops.lo @NEED_ASM_TRUE@am_libatomic_ops_la_OBJECTS = atomic_ops.lo \ @NEED_ASM_TRUE@ atomic_ops_sysdeps.lo libatomic_ops_la_OBJECTS = $(am_libatomic_ops_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 = libatomic_ops_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC \ $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CCLD) \ $(AM_CFLAGS) $(CFLAGS) $(libatomic_ops_la_LDFLAGS) $(LDFLAGS) \ -o $@ libatomic_ops_gpl_la_DEPENDENCIES = libatomic_ops.la am_libatomic_ops_gpl_la_OBJECTS = atomic_ops_stack.lo \ atomic_ops_malloc.lo libatomic_ops_gpl_la_OBJECTS = $(am_libatomic_ops_gpl_la_OBJECTS) libatomic_ops_gpl_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC \ $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CCLD) \ $(AM_CFLAGS) $(CFLAGS) $(libatomic_ops_gpl_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 = depcomp = $(SHELL) $(top_srcdir)/../depcomp am__depfiles_maybe = depfiles am__mv = mv -f CPPASCOMPILE = $(CCAS) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \ $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CCASFLAGS) $(CCASFLAGS) LTCPPASCOMPILE = $(LIBTOOL) $(AM_V_lt) $(AM_LIBTOOLFLAGS) \ $(LIBTOOLFLAGS) --mode=compile $(CCAS) $(DEFS) \ $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \ $(AM_CCASFLAGS) $(CCASFLAGS) AM_V_CPPAS = $(am__v_CPPAS_@AM_V@) am__v_CPPAS_ = $(am__v_CPPAS_@AM_DEFAULT_V@) am__v_CPPAS_0 = @echo " CPPAS " $@; am__v_CPPAS_1 = COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \ $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) LTCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \ $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) \ $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \ $(AM_CFLAGS) $(CFLAGS) AM_V_CC = $(am__v_CC_@AM_V@) am__v_CC_ = $(am__v_CC_@AM_DEFAULT_V@) am__v_CC_0 = @echo " CC " $@; am__v_CC_1 = CCLD = $(CC) LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \ $(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \ $(AM_LDFLAGS) $(LDFLAGS) -o $@ AM_V_CCLD = $(am__v_CCLD_@AM_V@) am__v_CCLD_ = $(am__v_CCLD_@AM_DEFAULT_V@) am__v_CCLD_0 = @echo " CCLD " $@; am__v_CCLD_1 = SOURCES = $(libatomic_ops_la_SOURCES) $(libatomic_ops_gpl_la_SOURCES) DIST_SOURCES = $(am__libatomic_ops_la_SOURCES_DIST) \ $(libatomic_ops_gpl_la_SOURCES) am__can_run_installinfo = \ case $$AM_UPDATE_INFO_DIR in \ n|no|NO) false;; \ *) (install-info --version) >/dev/null 2>&1;; \ esac HEADERS = $(include_HEADERS) $(nobase_private_HEADERS) am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) \ $(LISP)config.h.in # Read a list of newline-separated strings from the standard input, # and print each of them once, without duplicates. Input order is # *not* preserved. am__uniquify_input = $(AWK) '\ BEGIN { nonempty = 0; } \ { items[$$0] = 1; nonempty = 1; } \ END { if (nonempty) { for (i in items) print i; }; } \ ' # Make sure the list of sources is unique. This is necessary because, # e.g., the same source file might be shared among _SOURCES variables # for different programs/libraries. am__define_uniq_tagged_files = \ list='$(am__tagged_files)'; \ unique=`for i in $$list; do \ if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ done | $(am__uniquify_input)` ETAGS = etags CTAGS = ctags am__DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/config.h.in \ $(top_srcdir)/../depcomp DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) ACLOCAL = @ACLOCAL@ AMTAR = @AMTAR@ AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@ AR = @AR@ AUTOCONF = @AUTOCONF@ AUTOHEADER = @AUTOHEADER@ AUTOMAKE = @AUTOMAKE@ AWK = @AWK@ CC = @CC@ CCAS = @CCAS@ CCASDEPMODE = @CCASDEPMODE@ CCASFLAGS = @CCASFLAGS@ CCDEPMODE = @CCDEPMODE@ CFLAGS = @CFLAGS@ CPP = @CPP@ CPPFLAGS = @CPPFLAGS@ 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@ LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@ 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@ PICFLAG = @PICFLAG@ RANLIB = @RANLIB@ SED = @SED@ SET_MAKE = @SET_MAKE@ SHELL = @SHELL@ STRIP = @STRIP@ THREADDLLIBS = @THREADDLLIBS@ 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_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 = @target@ target_alias = @target_alias@ target_cpu = @target_cpu@ target_os = @target_os@ target_vendor = @target_vendor@ top_build_prefix = @top_build_prefix@ top_builddir = @top_builddir@ top_srcdir = @top_srcdir@ AM_CFLAGS = @PICFLAG@ AM_CPPFLAGS = -I$(top_builddir)/src -I$(top_srcdir)/src include_HEADERS = atomic_ops.h atomic_ops_stack.h atomic_ops_malloc.h lib_LTLIBRARIES = libatomic_ops.la libatomic_ops_gpl.la @NEED_ASM_FALSE@libatomic_ops_la_SOURCES = atomic_ops.c @NEED_ASM_TRUE@libatomic_ops_la_SOURCES = atomic_ops.c atomic_ops_sysdeps.S libatomic_ops_la_LDFLAGS = -version-info 1:3:0 -no-undefined libatomic_ops_gpl_la_SOURCES = atomic_ops_stack.c atomic_ops_malloc.c libatomic_ops_gpl_la_LDFLAGS = -version-info 1:3:0 -no-undefined libatomic_ops_gpl_la_LIBADD = libatomic_ops.la EXTRA_DIST = Makefile.msft atomic_ops/sysdeps/README \ atomic_ops/generalize-arithm.template \ atomic_ops/generalize-small.template \ atomic_ops/sysdeps/ao_t_is_int.template \ atomic_ops/sysdeps/gcc/generic-arithm.template \ atomic_ops/sysdeps/gcc/generic-small.template \ atomic_ops/sysdeps/loadstore/acquire_release_volatile.template \ atomic_ops/sysdeps/loadstore/atomic_load.template \ atomic_ops/sysdeps/loadstore/atomic_store.template \ atomic_ops/sysdeps/loadstore/ordered_loads_only.template \ atomic_ops/sysdeps/loadstore/ordered_stores_only.template \ atomic_ops/sysdeps/sunc/sparc.S BUILT_SOURCES = atomic_ops/generalize-arithm.h \ atomic_ops/generalize-small.h \ atomic_ops/sysdeps/ao_t_is_int.h \ atomic_ops/sysdeps/gcc/generic-arithm.h \ atomic_ops/sysdeps/gcc/generic-small.h \ atomic_ops/sysdeps/loadstore/acquire_release_volatile.h \ atomic_ops/sysdeps/loadstore/atomic_load.h \ atomic_ops/sysdeps/loadstore/atomic_store.h \ atomic_ops/sysdeps/loadstore/char_acquire_release_volatile.h \ atomic_ops/sysdeps/loadstore/char_atomic_load.h \ atomic_ops/sysdeps/loadstore/char_atomic_store.h \ atomic_ops/sysdeps/loadstore/int_acquire_release_volatile.h \ atomic_ops/sysdeps/loadstore/int_atomic_load.h \ atomic_ops/sysdeps/loadstore/int_atomic_store.h \ atomic_ops/sysdeps/loadstore/ordered_loads_only.h \ atomic_ops/sysdeps/loadstore/ordered_stores_only.h \ atomic_ops/sysdeps/loadstore/short_acquire_release_volatile.h \ atomic_ops/sysdeps/loadstore/short_atomic_load.h \ atomic_ops/sysdeps/loadstore/short_atomic_store.h #Private Headers privatedir = ${includedir}/ nobase_private_HEADERS = atomic_ops/ao_version.h \ atomic_ops/generalize.h \ $(BUILT_SOURCES) \ \ atomic_ops/sysdeps/all_acquire_release_volatile.h \ atomic_ops/sysdeps/all_aligned_atomic_load_store.h \ atomic_ops/sysdeps/all_atomic_load_store.h \ atomic_ops/sysdeps/all_atomic_only_load.h \ atomic_ops/sysdeps/emul_cas.h \ atomic_ops/sysdeps/generic_pthread.h \ atomic_ops/sysdeps/ordered.h \ atomic_ops/sysdeps/ordered_except_wr.h \ atomic_ops/sysdeps/read_ordered.h \ atomic_ops/sysdeps/standard_ao_double_t.h \ atomic_ops/sysdeps/test_and_set_t_is_ao_t.h \ atomic_ops/sysdeps/test_and_set_t_is_char.h \ \ atomic_ops/sysdeps/armcc/arm_v6.h \ \ atomic_ops/sysdeps/gcc/aarch64.h \ atomic_ops/sysdeps/gcc/alpha.h \ atomic_ops/sysdeps/gcc/arm.h \ atomic_ops/sysdeps/gcc/avr32.h \ atomic_ops/sysdeps/gcc/cris.h \ atomic_ops/sysdeps/gcc/generic.h \ atomic_ops/sysdeps/gcc/hexagon.h \ atomic_ops/sysdeps/gcc/hppa.h \ atomic_ops/sysdeps/gcc/ia64.h \ atomic_ops/sysdeps/gcc/m68k.h \ atomic_ops/sysdeps/gcc/mips.h \ atomic_ops/sysdeps/gcc/powerpc.h \ atomic_ops/sysdeps/gcc/s390.h \ atomic_ops/sysdeps/gcc/sh.h \ atomic_ops/sysdeps/gcc/sparc.h \ atomic_ops/sysdeps/gcc/x86.h \ \ atomic_ops/sysdeps/hpc/hppa.h \ atomic_ops/sysdeps/hpc/ia64.h \ \ atomic_ops/sysdeps/ibmc/powerpc.h \ \ atomic_ops/sysdeps/icc/ia64.h \ \ atomic_ops/sysdeps/loadstore/double_atomic_load_store.h \ \ atomic_ops/sysdeps/msftc/arm.h \ atomic_ops/sysdeps/msftc/common32_defs.h \ atomic_ops/sysdeps/msftc/x86.h \ atomic_ops/sysdeps/msftc/x86_64.h \ \ atomic_ops/sysdeps/sunc/sparc.h \ atomic_ops/sysdeps/sunc/x86.h all: $(BUILT_SOURCES) config.h $(MAKE) $(AM_MAKEFLAGS) all-am .SUFFIXES: .SUFFIXES: .S .c .lo .o .obj $(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.am $(am__configure_deps) @for dep in $?; do \ case '$(am__configure_deps)' in \ *$$dep*) \ ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \ && { if test -f $@; then exit 0; else break; fi; }; \ exit 1;; \ esac; \ done; \ echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign src/Makefile'; \ $(am__cd) $(top_srcdir) && \ $(AUTOMAKE) --foreign src/Makefile Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status @case '$?' in \ *config.status*) \ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \ *) \ echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \ cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \ esac; $(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh $(top_srcdir)/configure: @MAINTAINER_MODE_TRUE@ $(am__configure_deps) cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh $(ACLOCAL_M4): @MAINTAINER_MODE_TRUE@ $(am__aclocal_m4_deps) cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh $(am__aclocal_m4_deps): config.h: stamp-h1 @test -f $@ || rm -f stamp-h1 @test -f $@ || $(MAKE) $(AM_MAKEFLAGS) stamp-h1 stamp-h1: $(srcdir)/config.h.in $(top_builddir)/config.status @rm -f stamp-h1 cd $(top_builddir) && $(SHELL) ./config.status src/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 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}; \ } libatomic_ops.la: $(libatomic_ops_la_OBJECTS) $(libatomic_ops_la_DEPENDENCIES) $(EXTRA_libatomic_ops_la_DEPENDENCIES) $(AM_V_CCLD)$(libatomic_ops_la_LINK) -rpath $(libdir) $(libatomic_ops_la_OBJECTS) $(libatomic_ops_la_LIBADD) $(LIBS) libatomic_ops_gpl.la: $(libatomic_ops_gpl_la_OBJECTS) $(libatomic_ops_gpl_la_DEPENDENCIES) $(EXTRA_libatomic_ops_gpl_la_DEPENDENCIES) $(AM_V_CCLD)$(libatomic_ops_gpl_la_LINK) -rpath $(libdir) $(libatomic_ops_gpl_la_OBJECTS) $(libatomic_ops_gpl_la_LIBADD) $(LIBS) mostlyclean-compile: -rm -f *.$(OBJEXT) distclean-compile: -rm -f *.tab.c @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/atomic_ops.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/atomic_ops_malloc.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/atomic_ops_stack.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/atomic_ops_sysdeps.Plo@am__quote@ .S.o: @am__fastdepCCAS_TRUE@ $(AM_V_CPPAS)$(CPPASCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $< @am__fastdepCCAS_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po @AMDEP_TRUE@@am__fastdepCCAS_FALSE@ $(AM_V_CPPAS)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCCAS_FALSE@ DEPDIR=$(DEPDIR) $(CCASDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCCAS_FALSE@ $(AM_V_CPPAS@am__nodep@)$(CPPASCOMPILE) -c -o $@ $< .S.obj: @am__fastdepCCAS_TRUE@ $(AM_V_CPPAS)$(CPPASCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'` @am__fastdepCCAS_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po @AMDEP_TRUE@@am__fastdepCCAS_FALSE@ $(AM_V_CPPAS)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCCAS_FALSE@ DEPDIR=$(DEPDIR) $(CCASDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCCAS_FALSE@ $(AM_V_CPPAS@am__nodep@)$(CPPASCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'` .S.lo: @am__fastdepCCAS_TRUE@ $(AM_V_CPPAS)$(LTCPPASCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $< @am__fastdepCCAS_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Plo @AMDEP_TRUE@@am__fastdepCCAS_FALSE@ $(AM_V_CPPAS)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCCAS_FALSE@ DEPDIR=$(DEPDIR) $(CCASDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCCAS_FALSE@ $(AM_V_CPPAS@am__nodep@)$(LTCPPASCOMPILE) -c -o $@ $< .c.o: @am__fastdepCC_TRUE@ $(AM_V_CC)$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $< @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(COMPILE) -c -o $@ $< .c.obj: @am__fastdepCC_TRUE@ $(AM_V_CC)$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(COMPILE) -c -o $@ `$(CYGPATH_W) '$<'` .c.lo: @am__fastdepCC_TRUE@ $(AM_V_CC)$(LTCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $< @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Plo @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(LTCOMPILE) -c -o $@ $< mostlyclean-libtool: -rm -f *.lo clean-libtool: -rm -rf .libs _libs install-includeHEADERS: $(include_HEADERS) @$(NORMAL_INSTALL) @list='$(include_HEADERS)'; test -n "$(includedir)" || list=; \ if test -n "$$list"; then \ echo " $(MKDIR_P) '$(DESTDIR)$(includedir)'"; \ $(MKDIR_P) "$(DESTDIR)$(includedir)" || 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)$(includedir)'"; \ $(INSTALL_HEADER) $$files "$(DESTDIR)$(includedir)" || exit $$?; \ done uninstall-includeHEADERS: @$(NORMAL_UNINSTALL) @list='$(include_HEADERS)'; test -n "$(includedir)" || list=; \ files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \ dir='$(DESTDIR)$(includedir)'; $(am__uninstall_files_from_dir) install-nobase_privateHEADERS: $(nobase_private_HEADERS) @$(NORMAL_INSTALL) @list='$(nobase_private_HEADERS)'; test -n "$(privatedir)" || list=; \ if test -n "$$list"; then \ echo " $(MKDIR_P) '$(DESTDIR)$(privatedir)'"; \ $(MKDIR_P) "$(DESTDIR)$(privatedir)" || exit 1; \ fi; \ $(am__nobase_list) | while read dir files; do \ xfiles=; for file in $$files; do \ if test -f "$$file"; then xfiles="$$xfiles $$file"; \ else xfiles="$$xfiles $(srcdir)/$$file"; fi; done; \ test -z "$$xfiles" || { \ test "x$$dir" = x. || { \ echo " $(MKDIR_P) '$(DESTDIR)$(privatedir)/$$dir'"; \ $(MKDIR_P) "$(DESTDIR)$(privatedir)/$$dir"; }; \ echo " $(INSTALL_HEADER) $$xfiles '$(DESTDIR)$(privatedir)/$$dir'"; \ $(INSTALL_HEADER) $$xfiles "$(DESTDIR)$(privatedir)/$$dir" || exit $$?; }; \ done uninstall-nobase_privateHEADERS: @$(NORMAL_UNINSTALL) @list='$(nobase_private_HEADERS)'; test -n "$(privatedir)" || list=; \ $(am__nobase_strip_setup); files=`$(am__nobase_strip)`; \ dir='$(DESTDIR)$(privatedir)'; $(am__uninstall_files_from_dir) ID: $(am__tagged_files) $(am__define_uniq_tagged_files); mkid -fID $$unique tags: tags-am TAGS: tags tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) set x; \ here=`pwd`; \ $(am__define_uniq_tagged_files); \ 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-am CTAGS: ctags ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) $(am__define_uniq_tagged_files); \ 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" cscopelist: cscopelist-am cscopelist-am: $(am__tagged_files) list='$(am__tagged_files)'; \ 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 distdir: $(DISTFILES) @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 check-am: all-am check: $(BUILT_SOURCES) $(MAKE) $(AM_MAKEFLAGS) check-am all-am: Makefile $(LTLIBRARIES) $(HEADERS) config.h installdirs: for dir in "$(DESTDIR)$(libdir)" "$(DESTDIR)$(includedir)" "$(DESTDIR)$(privatedir)"; do \ test -z "$$dir" || $(MKDIR_P) "$$dir"; \ done install: $(BUILT_SOURCES) $(MAKE) $(AM_MAKEFLAGS) 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) maintainer-clean-generic: @echo "This command is intended for maintainers to use" @echo "it deletes files that may require special tools to rebuild." -test -z "$(BUILT_SOURCES)" || rm -f $(BUILT_SOURCES) clean: clean-am clean-am: clean-generic clean-libLTLIBRARIES clean-libtool \ mostlyclean-am distclean: distclean-am -rm -rf ./$(DEPDIR) -rm -f Makefile distclean-am: clean-am distclean-compile distclean-generic \ distclean-hdr distclean-tags dvi: dvi-am dvi-am: html: html-am html-am: info: info-am info-am: install-data-am: install-includeHEADERS install-nobase_privateHEADERS 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 -rf ./$(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-includeHEADERS uninstall-libLTLIBRARIES \ uninstall-nobase_privateHEADERS .MAKE: all check install install-am install-strip .PHONY: CTAGS GTAGS TAGS all all-am check check-am clean clean-generic \ clean-libLTLIBRARIES clean-libtool cscopelist-am ctags \ ctags-am distclean distclean-compile distclean-generic \ distclean-hdr distclean-libtool distclean-tags distdir 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-includeHEADERS install-info install-info-am \ install-libLTLIBRARIES install-man \ install-nobase_privateHEADERS install-pdf install-pdf-am \ 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 tags-am uninstall uninstall-am uninstall-includeHEADERS \ uninstall-libLTLIBRARIES uninstall-nobase_privateHEADERS .PRECIOUS: Makefile atomic_ops/generalize-small.h: atomic_ops/generalize-small.template mkdir -p `dirname $@` sed -e s:XSIZE:char:g -e s:XCTYPE:unsigned/**/char:g $? > $@ sed -e s:XSIZE:short:g -e s:XCTYPE:unsigned/**/short:g $? >> $@ sed -e s:XSIZE:int:g -e s:XCTYPE:unsigned:g $? >> $@ sed -e s:XSIZE_::g -e s:XCTYPE:AO_t:g $? >> $@ sed -e s:XSIZE:double:g -e s:XCTYPE:AO_double_t:g $? >> $@ atomic_ops/generalize-arithm.h: atomic_ops/generalize-arithm.template mkdir -p `dirname $@` sed -e s:XSIZE:char:g -e s:XCTYPE:unsigned/**/char:g $? > $@ sed -e s:XSIZE:short:g -e s:XCTYPE:unsigned/**/short:g $? >> $@ sed -e s:XSIZE:int:g -e s:XCTYPE:unsigned:g $? >> $@ sed -e s:XSIZE_::g -e s:XCTYPE:AO_t:g $? >> $@ atomic_ops/sysdeps/ao_t_is_int.h: atomic_ops/sysdeps/ao_t_is_int.template mkdir -p `dirname $@` sed -e s:_XBAR::g $? > $@ sed -e s:XBAR:full:g $? >> $@ sed -e s:XBAR:acquire:g $? >> $@ sed -e s:XBAR:release:g $? >> $@ sed -e s:XBAR:write:g $? >> $@ sed -e s:XBAR:read:g $? >> $@ atomic_ops/sysdeps/gcc/generic-arithm.h: \ atomic_ops/sysdeps/gcc/generic-arithm.template mkdir -p `dirname $@` sed -e s:_XBAR::g -e s:XGCCBAR:RELAXED:g \ -e s:XSIZE:char:g -e s:XCTYPE:unsigned/**/char:g $? > $@ sed -e s:_XBAR::g -e s:XGCCBAR:RELAXED:g \ -e s:XSIZE:short:g -e s:XCTYPE:unsigned/**/short:g $? >> $@ sed -e s:_XBAR::g -e s:XGCCBAR:RELAXED:g \ -e s:XSIZE:int:g -e s:XCTYPE:unsigned:g $? >> $@ sed -e s:_XBAR::g -e s:XGCCBAR:RELAXED:g \ -e s:XSIZE_::g -e s:XCTYPE:AO_t:g $? >> $@ sed -e s:XBAR:acquire:g -e s:XGCCBAR:ACQUIRE:g \ -e s:XSIZE:char:g -e s:XCTYPE:unsigned/**/char:g $? >> $@ sed -e s:XBAR:acquire:g -e s:XGCCBAR:ACQUIRE:g \ -e s:XSIZE:short:g -e s:XCTYPE:unsigned/**/short:g $? >> $@ sed -e s:XBAR:acquire:g -e s:XGCCBAR:ACQUIRE:g \ -e s:XSIZE:int:g -e s:XCTYPE:unsigned:g $? >> $@ sed -e s:XBAR:acquire:g -e s:XGCCBAR:ACQUIRE:g \ -e s:XSIZE_::g -e s:XCTYPE:AO_t:g $? >> $@ sed -e s:XBAR:release:g -e s:XGCCBAR:RELEASE:g \ -e s:XSIZE:char:g -e s:XCTYPE:unsigned/**/char:g $? >> $@ sed -e s:XBAR:release:g -e s:XGCCBAR:RELEASE:g \ -e s:XSIZE:short:g -e s:XCTYPE:unsigned/**/short:g $? >> $@ sed -e s:XBAR:release:g -e s:XGCCBAR:RELEASE:g \ -e s:XSIZE:int:g -e s:XCTYPE:unsigned:g $? >> $@ sed -e s:XBAR:release:g -e s:XGCCBAR:RELEASE:g \ -e s:XSIZE_::g -e s:XCTYPE:AO_t:g $? >> $@ sed -e s:XBAR:full:g -e s:XGCCBAR:SEQ_CST:g \ -e s:XSIZE:char:g -e s:XCTYPE:unsigned/**/char:g $? >> $@ sed -e s:XBAR:full:g -e s:XGCCBAR:SEQ_CST:g \ -e s:XSIZE:short:g -e s:XCTYPE:unsigned/**/short:g $? >> $@ sed -e s:XBAR:full:g -e s:XGCCBAR:SEQ_CST:g \ -e s:XSIZE:int:g -e s:XCTYPE:unsigned:g $? >> $@ sed -e s:XBAR:full:g -e s:XGCCBAR:SEQ_CST:g \ -e s:XSIZE_::g -e s:XCTYPE:AO_t:g $? >> $@ atomic_ops/sysdeps/gcc/generic-small.h: \ atomic_ops/sysdeps/gcc/generic-small.template mkdir -p `dirname $@` sed -e s:XSIZE:char:g -e s:XCTYPE:unsigned/**/char:g $? > $@ sed -e s:XSIZE:short:g -e s:XCTYPE:unsigned/**/short:g $? >> $@ sed -e s:XSIZE:int:g -e s:XCTYPE:unsigned:g $? >> $@ sed -e s:XSIZE_::g -e s:XCTYPE:AO_t:g $? >> $@ atomic_ops/sysdeps/loadstore/ordered_loads_only.h: \ atomic_ops/sysdeps/loadstore/ordered_loads_only.template mkdir -p `dirname $@` sed -e s:XSIZE:char:g -e s:XCTYPE:unsigned/**/char:g $? > $@ sed -e s:XSIZE:short:g -e s:XCTYPE:unsigned/**/short:g $? >> $@ sed -e s:XSIZE:int:g -e s:XCTYPE:unsigned:g $? >> $@ sed -e s:XSIZE_::g -e s:XCTYPE:AO_t:g $? >> $@ sed -e s:XSIZE:double:g -e s:XCTYPE:AO_double_t:g $? >> $@ atomic_ops/sysdeps/loadstore/ordered_stores_only.h: \ atomic_ops/sysdeps/loadstore/ordered_stores_only.template mkdir -p `dirname $@` sed -e s:XSIZE:char:g -e s:XCTYPE:unsigned/**/char:g $? > $@ sed -e s:XSIZE:short:g -e s:XCTYPE:unsigned/**/short:g $? >> $@ sed -e s:XSIZE:int:g -e s:XCTYPE:unsigned:g $? >> $@ sed -e s:XSIZE_::g -e s:XCTYPE:AO_t:g $? >> $@ sed -e s:XSIZE:double:g -e s:XCTYPE:AO_double_t:g $? >> $@ atomic_ops/sysdeps/loadstore/acquire_release_volatile.h: \ atomic_ops/sysdeps/loadstore/acquire_release_volatile.template mkdir -p `dirname $@` sed -e s:XSIZE_::g -e s:XCTYPE:AO_t:g $? > $@ atomic_ops/sysdeps/loadstore/char_acquire_release_volatile.h: \ atomic_ops/sysdeps/loadstore/acquire_release_volatile.template mkdir -p `dirname $@` sed -e s:XSIZE:char:g -e s:XCTYPE:unsigned/**/char:g $? > $@ atomic_ops/sysdeps/loadstore/int_acquire_release_volatile.h: \ atomic_ops/sysdeps/loadstore/acquire_release_volatile.template mkdir -p `dirname $@` sed -e s:XSIZE:int:g -e s:XCTYPE:unsigned:g $? > $@ atomic_ops/sysdeps/loadstore/short_acquire_release_volatile.h: \ atomic_ops/sysdeps/loadstore/acquire_release_volatile.template mkdir -p `dirname $@` sed -e s:XSIZE:short:g -e s:XCTYPE:unsigned/**/short:g $? > $@ atomic_ops/sysdeps/loadstore/atomic_load.h: \ atomic_ops/sysdeps/loadstore/atomic_load.template mkdir -p `dirname $@` sed -e s:XSIZE_::g -e s:XCTYPE:AO_t:g $? > $@ atomic_ops/sysdeps/loadstore/char_atomic_load.h: \ atomic_ops/sysdeps/loadstore/atomic_load.template mkdir -p `dirname $@` sed -e s:XSIZE:char:g -e s:XCTYPE:unsigned/**/char:g $? > $@ atomic_ops/sysdeps/loadstore/int_atomic_load.h: \ atomic_ops/sysdeps/loadstore/atomic_load.template mkdir -p `dirname $@` sed -e s:XSIZE:int:g -e s:XCTYPE:unsigned:g $? > $@ atomic_ops/sysdeps/loadstore/short_atomic_load.h: \ atomic_ops/sysdeps/loadstore/atomic_load.template mkdir -p `dirname $@` sed -e s:XSIZE:short:g -e s:XCTYPE:unsigned/**/short:g $? > $@ atomic_ops/sysdeps/loadstore/atomic_store.h: \ atomic_ops/sysdeps/loadstore/atomic_store.template mkdir -p `dirname $@` sed -e s:XSIZE_::g -e s:XCTYPE:AO_t:g $? > $@ atomic_ops/sysdeps/loadstore/char_atomic_store.h: \ atomic_ops/sysdeps/loadstore/atomic_store.template mkdir -p `dirname $@` sed -e s:XSIZE:char:g -e s:XCTYPE:unsigned/**/char:g $? > $@ atomic_ops/sysdeps/loadstore/int_atomic_store.h: \ atomic_ops/sysdeps/loadstore/atomic_store.template mkdir -p `dirname $@` sed -e s:XSIZE:int:g -e s:XCTYPE:unsigned:g $? > $@ atomic_ops/sysdeps/loadstore/short_atomic_store.h: \ atomic_ops/sysdeps/loadstore/atomic_store.template mkdir -p `dirname $@` sed -e s:XSIZE:short:g -e s:XCTYPE:unsigned/**/short:g $? > $@ # 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: ecl-16.1.2/src/bdwgc/libatomic_ops/src/Makefile.msft000066400000000000000000000036371266352375300222710ustar00rootroot00000000000000# # Copyright (c) 2003-2005 Hewlett-Packard Development Company, L.P. # # The really trivial win32/VC++ Makefile. Note that atomic_ops.c defines # only AO_pause (used by atomic_ops_stack). # And we rely on a pre-built test_atomic_include.h and generalize-small.h, # since we can't rely on sed. But we don't keep test_atomic_include.h in # the development repository any longer, so if you want to do "make check" # for the sources obtained from the repository then # do "autoreconf -vif; ./configure; make check" in Cygwin first. # Win32 clients only need to include the header files. # To install, copy atomic_ops.h and the atomic_ops/... tree to your favorite # include directory. #MY_CPU=X86 #CPU=$(MY_CPU) #!include CFLAGS=-O2 -W3 -DAO_ASSUME_WINDOWS98 LIB_OBJS=atomic_ops.obj atomic_ops_malloc.obj atomic_ops_stack.obj all: libatomic_ops_gpl.lib atomic_ops.obj: cl $(CFLAGS) -c atomic_ops.c atomic_ops_stack.obj: cl $(CFLAGS) -c atomic_ops_stack.c atomic_ops_malloc.obj: cl $(CFLAGS) -c atomic_ops_malloc.c libatomic_ops_gpl.lib: $(LIB_OBJS) lib /out:libatomic_ops_gpl.lib $(LIB_OBJS) test_atomic: ..\tests\test_atomic.c ..\tests\test_atomic_include.h cl $(CFLAGS) -I. ..\tests\test_atomic.c /Fo.\test_atomic test_atomic_w95: ..\tests\test_atomic.c ..\tests\test_atomic_include.h cl -W3 -O2 -I. ..\tests\test_atomic.c /Fo.\test_atomic_w95 test_malloc: ..\tests\test_malloc.c libatomic_ops_gpl.lib cl $(CFLAGS) -I. ..\tests\test_malloc.c /Fo.\test_malloc \ libatomic_ops_gpl.lib test_stack: ..\tests\test_stack.c libatomic_ops_gpl.lib cl $(CFLAGS) -I. ..\tests\test_stack.c /Fo.\test_stack \ libatomic_ops_gpl.lib check: test_atomic test_atomic_w95 test_malloc test_stack @echo "The following will print lots of 'Missing ...' messages" test_atomic_w95 @echo "The following will print some 'Missing ...' messages" test_atomic test_malloc test_stack clean: del *.exe *.obj libatomic_ops_gpl.lib ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops.c000066400000000000000000000164261266352375300221620ustar00rootroot00000000000000/* * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ /* * Initialized data and out-of-line functions to support atomic_ops.h * go here. Currently this is needed only for pthread-based atomics * emulation, or for compare-and-swap emulation. * Pthreads emulation isn't useful on a native Windows platform, and * cas emulation is not needed. Thus we skip this on Windows. */ #if defined(HAVE_CONFIG_H) # include "config.h" #endif #if defined(__native_client__) && !defined(AO_USE_NO_SIGNALS) \ && !defined(AO_USE_NANOSLEEP) /* Since NaCl is not recognized by configure yet, we do it here. */ # define AO_USE_NO_SIGNALS # define AO_USE_NANOSLEEP #endif #if defined(AO_USE_WIN32_PTHREADS) && !defined(AO_USE_NO_SIGNALS) # define AO_USE_NO_SIGNALS #endif #undef AO_REQUIRE_CAS #include "atomic_ops.h" /* Without cas emulation! */ #if !defined(_MSC_VER) && !defined(__MINGW32__) && !defined(__BORLANDC__) \ || defined(AO_USE_NO_SIGNALS) #ifndef AO_NO_PTHREADS # include #endif #ifndef AO_USE_NO_SIGNALS # include #endif #ifdef AO_USE_NANOSLEEP /* This requires _POSIX_TIMERS feature. */ # include # include #elif defined(AO_USE_WIN32_PTHREADS) # include /* for Sleep() */ #elif defined(_HPUX_SOURCE) # include #else # include #endif #ifndef AO_HAVE_double_t # include "atomic_ops/sysdeps/standard_ao_double_t.h" #endif /* Lock for pthreads-based implementation. */ #ifndef AO_NO_PTHREADS pthread_mutex_t AO_pt_lock = PTHREAD_MUTEX_INITIALIZER; #endif /* * Out of line compare-and-swap emulation based on test and set. * * We use a small table of locks for different compare_and_swap locations. * Before we update perform a compare-and-swap, we grab the corresponding * lock. Different locations may hash to the same lock, but since we * never acquire more than one lock at a time, this can't deadlock. * We explicitly disable signals while we perform this operation. * * TODO: Probably also support emulation based on Lamport * locks, since we may not have test_and_set either. */ #define AO_HASH_SIZE 16 #define AO_HASH(x) (((unsigned long)(x) >> 12) & (AO_HASH_SIZE-1)) AO_TS_t AO_locks[AO_HASH_SIZE] = { AO_TS_INITIALIZER, AO_TS_INITIALIZER, AO_TS_INITIALIZER, AO_TS_INITIALIZER, AO_TS_INITIALIZER, AO_TS_INITIALIZER, AO_TS_INITIALIZER, AO_TS_INITIALIZER, AO_TS_INITIALIZER, AO_TS_INITIALIZER, AO_TS_INITIALIZER, AO_TS_INITIALIZER, AO_TS_INITIALIZER, AO_TS_INITIALIZER, AO_TS_INITIALIZER, AO_TS_INITIALIZER, }; void AO_pause(int); /* defined below */ static void lock_ool(volatile AO_TS_t *l) { int i = 0; while (AO_test_and_set_acquire(l) == AO_TS_SET) AO_pause(++i); } AO_INLINE void lock(volatile AO_TS_t *l) { if (AO_EXPECT_FALSE(AO_test_and_set_acquire(l) == AO_TS_SET)) lock_ool(l); } AO_INLINE void unlock(volatile AO_TS_t *l) { AO_CLEAR(l); } #ifndef AO_USE_NO_SIGNALS static sigset_t all_sigs; static volatile AO_t initialized = 0; static volatile AO_TS_t init_lock = AO_TS_INITIALIZER; AO_INLINE void block_all_signals(sigset_t *old_sigs_ptr) { if (AO_EXPECT_FALSE(!AO_load_acquire(&initialized))) { lock(&init_lock); if (!initialized) sigfillset(&all_sigs); unlock(&init_lock); AO_store_release(&initialized, 1); } sigprocmask(SIG_BLOCK, &all_sigs, old_sigs_ptr); /* Neither sigprocmask nor pthread_sigmask is 100% */ /* guaranteed to work here. Sigprocmask is not */ /* guaranteed be thread safe, and pthread_sigmask */ /* is not async-signal-safe. Under linuxthreads, */ /* sigprocmask may block some pthreads-internal */ /* signals. So long as we do that for short periods, */ /* we should be OK. */ } #endif /* !AO_USE_NO_SIGNALS */ AO_t AO_fetch_compare_and_swap_emulation(volatile AO_t *addr, AO_t old_val, AO_t new_val) { AO_TS_t *my_lock = AO_locks + AO_HASH(addr); AO_t fetched_val; # ifndef AO_USE_NO_SIGNALS sigset_t old_sigs; block_all_signals(&old_sigs); # endif lock(my_lock); fetched_val = *addr; if (fetched_val == old_val) *addr = new_val; unlock(my_lock); # ifndef AO_USE_NO_SIGNALS sigprocmask(SIG_SETMASK, &old_sigs, NULL); # endif return fetched_val; } int AO_compare_double_and_swap_double_emulation(volatile AO_double_t *addr, AO_t old_val1, AO_t old_val2, AO_t new_val1, AO_t new_val2) { AO_TS_t *my_lock = AO_locks + AO_HASH(addr); int result; # ifndef AO_USE_NO_SIGNALS sigset_t old_sigs; block_all_signals(&old_sigs); # endif lock(my_lock); if (addr -> AO_val1 == old_val1 && addr -> AO_val2 == old_val2) { addr -> AO_val1 = new_val1; addr -> AO_val2 = new_val2; result = 1; } else result = 0; unlock(my_lock); # ifndef AO_USE_NO_SIGNALS sigprocmask(SIG_SETMASK, &old_sigs, NULL); # endif return result; } void AO_store_full_emulation(volatile AO_t *addr, AO_t val) { AO_TS_t *my_lock = AO_locks + AO_HASH(addr); lock(my_lock); *addr = val; unlock(my_lock); } #else /* Non-posix platform */ # include # define AO_USE_WIN32_PTHREADS /* define to use Sleep() */ extern int AO_non_posix_implementation_is_entirely_in_headers; #endif static AO_t spin_dummy = 1; /* Spin for 2**n units. */ static void AO_spin(int n) { AO_t j = AO_load(&spin_dummy); int i = 2 << n; while (i-- > 0) j += (j - 1) << 2; /* Given 'spin_dummy' is initialized to 1, j is 1 after the loop. */ AO_store(&spin_dummy, j); } void AO_pause(int n) { if (n < 12) AO_spin(n); else { # ifdef AO_USE_NANOSLEEP struct timespec ts; ts.tv_sec = 0; ts.tv_nsec = (n > 28 ? 100000 * 1000 : 1 << (n - 2)); nanosleep(&ts, 0); # elif defined(AO_USE_WIN32_PTHREADS) Sleep(n > 28 ? 100 : n < 22 ? 1 : 1 << (n - 22)); /* in millis */ # else struct timeval tv; /* Short async-signal-safe sleep. */ tv.tv_sec = 0; tv.tv_usec = n > 28 ? 100000 : 1 << (n - 12); select(0, 0, 0, 0, &tv); # endif } } ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops.h000066400000000000000000000445661266352375300221750ustar00rootroot00000000000000/* * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ #ifndef AO_ATOMIC_OPS_H #define AO_ATOMIC_OPS_H #include "atomic_ops/ao_version.h" /* Define version numbers here to allow */ /* test on build machines for cross-builds. */ #include #include /* We define various atomic operations on memory in a */ /* machine-specific way. Unfortunately, this is complicated */ /* by the fact that these may or may not be combined with */ /* various memory barriers. Thus the actual operations we */ /* define have the form AO__, for all */ /* plausible combinations of and . */ /* This of course results in a mild combinatorial explosion. */ /* To deal with it, we try to generate derived */ /* definitions for as many of the combinations as we can, as */ /* automatically as possible. */ /* */ /* Our assumption throughout is that the programmer will */ /* specify the least demanding operation and memory barrier */ /* that will guarantee correctness for the implementation. */ /* Our job is to find the least expensive way to implement it */ /* on the applicable hardware. In many cases that will */ /* involve, for example, a stronger memory barrier, or a */ /* combination of hardware primitives. */ /* */ /* Conventions: */ /* "plain" atomic operations are not guaranteed to include */ /* a barrier. The suffix in the name specifies the barrier */ /* type. Suffixes are: */ /* _release: Earlier operations may not be delayed past it. */ /* _acquire: Later operations may not move ahead of it. */ /* _read: Subsequent reads must follow this operation and */ /* preceding reads. */ /* _write: Earlier writes precede both this operation and */ /* later writes. */ /* _full: Ordered with respect to both earlier and later memory */ /* operations. */ /* _release_write: Ordered with respect to earlier writes. */ /* _acquire_read: Ordered with respect to later reads. */ /* */ /* Currently we try to define the following atomic memory */ /* operations, in combination with the above barriers: */ /* AO_nop */ /* AO_load */ /* AO_store */ /* AO_test_and_set (binary) */ /* AO_fetch_and_add */ /* AO_fetch_and_add1 */ /* AO_fetch_and_sub1 */ /* AO_and */ /* AO_or */ /* AO_xor */ /* AO_compare_and_swap */ /* AO_fetch_compare_and_swap */ /* */ /* Note that atomicity guarantees are valid only if both */ /* readers and writers use AO_ operations to access the */ /* shared value, while ordering constraints are intended to */ /* apply all memory operations. If a location can potentially */ /* be accessed simultaneously from multiple threads, and one of */ /* those accesses may be a write access, then all such */ /* accesses to that location should be through AO_ primitives. */ /* However if AO_ operations enforce sufficient ordering to */ /* ensure that a location x cannot be accessed concurrently, */ /* or can only be read concurrently, then x can be accessed */ /* via ordinary references and assignments. */ /* */ /* AO_compare_and_swap takes an address and an expected old */ /* value and a new value, and returns an int. Non-zero result */ /* indicates that it succeeded. */ /* AO_fetch_compare_and_swap takes an address and an expected */ /* old value and a new value, and returns the real old value. */ /* The operation succeeded if and only if the expected old */ /* value matches the old value returned. */ /* */ /* Test_and_set takes an address, atomically replaces it by */ /* AO_TS_SET, and returns the prior value. */ /* An AO_TS_t location can be reset with the */ /* AO_CLEAR macro, which normally uses AO_store_release. */ /* AO_fetch_and_add takes an address and an AO_t increment */ /* value. The AO_fetch_and_add1 and AO_fetch_and_sub1 variants */ /* are provided, since they allow faster implementations on */ /* some hardware. AO_and, AO_or, AO_xor do atomically and, or, */ /* xor (respectively) an AO_t value into a memory location, */ /* but do not provide access to the original. */ /* */ /* We expect this list to grow slowly over time. */ /* */ /* Note that AO_nop_full is a full memory barrier. */ /* */ /* Note that if some data is initialized with */ /* data.x = ...; data.y = ...; ... */ /* AO_store_release_write(&data_is_initialized, 1) */ /* then data is guaranteed to be initialized after the test */ /* if (AO_load_acquire_read(&data_is_initialized)) ... */ /* succeeds. Furthermore, this should generate near-optimal */ /* code on all common platforms. */ /* */ /* All operations operate on unsigned AO_t, which */ /* is the natural word size, and usually unsigned long. */ /* It is possible to check whether a particular operation op */ /* is available on a particular platform by checking whether */ /* AO_HAVE_op is defined. We make heavy use of these macros */ /* internally. */ /* The rest of this file basically has three sections: */ /* */ /* Some utility and default definitions. */ /* */ /* The architecture dependent section: */ /* This defines atomic operations that have direct hardware */ /* support on a particular platform, mostly by including the */ /* appropriate compiler- and hardware-dependent file. */ /* */ /* The synthesis section: */ /* This tries to define other atomic operations in terms of */ /* those that are explicitly available on the platform. */ /* This section is hardware independent. */ /* We make no attempt to synthesize operations in ways that */ /* effectively introduce locks, except for the debugging/demo */ /* pthread-based implementation at the beginning. A more */ /* realistic implementation that falls back to locks could be */ /* added as a higher layer. But that would sacrifice */ /* usability from signal handlers. */ /* The synthesis section is implemented almost entirely in */ /* atomic_ops/generalize.h. */ /* Some common defaults. Overridden for some architectures. */ #define AO_t size_t /* The test_and_set primitive returns an AO_TS_VAL_t value. */ /* AO_TS_t is the type of an in-memory test-and-set location. */ #define AO_TS_INITIALIZER (AO_t)AO_TS_CLEAR /* Platform-dependent stuff: */ #if (defined(__GNUC__) || defined(_MSC_VER) || defined(__INTEL_COMPILER) \ || defined(__DMC__) || defined(__WATCOMC__)) && !defined(AO_NO_INLINE) # define AO_INLINE static __inline #elif defined(__sun) && !defined(AO_NO_INLINE) # define AO_INLINE static inline #else # define AO_INLINE static #endif #if __GNUC__ >= 3 && !defined(LINT2) # define AO_EXPECT_FALSE(expr) __builtin_expect(expr, 0) /* Equivalent to (expr) but predict that usually (expr) == 0. */ #else # define AO_EXPECT_FALSE(expr) (expr) #endif /* !__GNUC__ */ #if defined(__GNUC__) && !defined(__INTEL_COMPILER) # define AO_compiler_barrier() __asm__ __volatile__("" : : : "memory") #elif defined(_MSC_VER) || defined(__DMC__) || defined(__BORLANDC__) \ || defined(__WATCOMC__) # if defined(_AMD64_) || defined(_M_X64) || _MSC_VER >= 1400 # if defined(_WIN32_WCE) /* # include */ # elif defined(_MSC_VER) # include # endif # pragma intrinsic(_ReadWriteBarrier) # define AO_compiler_barrier() _ReadWriteBarrier() /* We assume this does not generate a fence instruction. */ /* The documentation is a bit unclear. */ # else # define AO_compiler_barrier() __asm { } /* The preceding implementation may be preferable here too. */ /* But the documentation warns about VC++ 2003 and earlier. */ # endif #elif defined(__INTEL_COMPILER) # define AO_compiler_barrier() __memory_barrier() /* FIXME: Too strong? IA64-only? */ #elif defined(_HPUX_SOURCE) # if defined(__ia64) # include # define AO_compiler_barrier() _Asm_sched_fence() # else /* FIXME - We dont know how to do this. This is a guess. */ /* And probably a bad one. */ static volatile int AO_barrier_dummy; # define AO_compiler_barrier() (void)(AO_barrier_dummy = AO_barrier_dummy) # endif #else /* We conjecture that the following usually gives us the right */ /* semantics or an error. */ # define AO_compiler_barrier() asm("") #endif #if defined(AO_USE_PTHREAD_DEFS) # include "atomic_ops/sysdeps/generic_pthread.h" #endif /* AO_USE_PTHREAD_DEFS */ #if (defined(__CC_ARM) || defined(__ARMCC__)) && !defined(__GNUC__) \ && !defined(AO_USE_PTHREAD_DEFS) # include "atomic_ops/sysdeps/armcc/arm_v6.h" # define AO_GENERALIZE_TWICE #endif #if defined(__GNUC__) && !defined(AO_USE_PTHREAD_DEFS) \ && !defined(__INTEL_COMPILER) # if defined(__i386__) /* We don't define AO_USE_SYNC_CAS_BUILTIN for x86 here because */ /* it might require specifying additional options (like -march) */ /* or additional link libraries (if -march is not specified). */ # include "atomic_ops/sysdeps/gcc/x86.h" # endif /* __i386__ */ # if defined(__x86_64__) # if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)) \ && !defined(AO_USE_SYNC_CAS_BUILTIN) /* It is safe to use __sync CAS built-in on this architecture. */ # define AO_USE_SYNC_CAS_BUILTIN # endif # include "atomic_ops/sysdeps/gcc/x86.h" # endif /* __x86_64__ */ # if defined(__ia64__) # include "atomic_ops/sysdeps/gcc/ia64.h" # define AO_GENERALIZE_TWICE # endif /* __ia64__ */ # if defined(__hppa__) # include "atomic_ops/sysdeps/gcc/hppa.h" # define AO_CAN_EMUL_CAS # endif /* __hppa__ */ # if defined(__alpha__) # include "atomic_ops/sysdeps/gcc/alpha.h" # define AO_GENERALIZE_TWICE # endif /* __alpha__ */ # if defined(__s390__) # include "atomic_ops/sysdeps/gcc/s390.h" # endif /* __s390__ */ # if defined(__sparc__) # include "atomic_ops/sysdeps/gcc/sparc.h" # define AO_CAN_EMUL_CAS # endif /* __sparc__ */ # if defined(__m68k__) # include "atomic_ops/sysdeps/gcc/m68k.h" # endif /* __m68k__ */ # if defined(__powerpc__) || defined(__ppc__) || defined(__PPC__) \ || defined(__powerpc64__) || defined(__ppc64__) # include "atomic_ops/sysdeps/gcc/powerpc.h" # endif /* __powerpc__ */ # if defined(__aarch64__) # include "atomic_ops/sysdeps/gcc/aarch64.h" # define AO_CAN_EMUL_CAS # endif /* __aarch64__ */ # if defined(__arm__) # include "atomic_ops/sysdeps/gcc/arm.h" # define AO_CAN_EMUL_CAS # endif /* __arm__ */ # if defined(__cris__) || defined(CRIS) # include "atomic_ops/sysdeps/gcc/cris.h" # define AO_GENERALIZE_TWICE # endif # if defined(__mips__) # include "atomic_ops/sysdeps/gcc/mips.h" # endif /* __mips__ */ # if defined(__sh__) || defined(SH4) # include "atomic_ops/sysdeps/gcc/sh.h" # define AO_CAN_EMUL_CAS # endif /* __sh__ */ # if defined(__avr32__) # include "atomic_ops/sysdeps/gcc/avr32.h" # endif # if defined(__hexagon__) # include "atomic_ops/sysdeps/gcc/hexagon.h" # endif #endif /* __GNUC__ && !AO_USE_PTHREAD_DEFS */ #if (defined(__IBMC__) || defined(__IBMCPP__)) && !defined(__GNUC__) \ && !defined(AO_USE_PTHREAD_DEFS) # if defined(__powerpc__) || defined(__powerpc) || defined(__ppc__) \ || defined(__PPC__) || defined(_M_PPC) || defined(_ARCH_PPC) \ || defined(_ARCH_PWR) # include "atomic_ops/sysdeps/ibmc/powerpc.h" # define AO_GENERALIZE_TWICE # endif #endif #if defined(__INTEL_COMPILER) && !defined(AO_USE_PTHREAD_DEFS) # if defined(__ia64__) # include "atomic_ops/sysdeps/icc/ia64.h" # define AO_GENERALIZE_TWICE # endif # if defined(__GNUC__) /* Intel Compiler in GCC compatible mode */ # if defined(__i386__) # include "atomic_ops/sysdeps/gcc/x86.h" # endif /* __i386__ */ # if defined(__x86_64__) # if (__INTEL_COMPILER > 1110) && !defined(AO_USE_SYNC_CAS_BUILTIN) # define AO_USE_SYNC_CAS_BUILTIN # endif # include "atomic_ops/sysdeps/gcc/x86.h" # endif /* __x86_64__ */ # endif #endif #if defined(_HPUX_SOURCE) && !defined(__GNUC__) && !defined(AO_USE_PTHREAD_DEFS) # if defined(__ia64) # include "atomic_ops/sysdeps/hpc/ia64.h" # define AO_GENERALIZE_TWICE # else # include "atomic_ops/sysdeps/hpc/hppa.h" # define AO_CAN_EMUL_CAS # endif #endif #if defined(_MSC_VER) || defined(__DMC__) || defined(__BORLANDC__) \ || (defined(__WATCOMC__) && defined(__NT__)) # if defined(_AMD64_) || defined(_M_X64) # include "atomic_ops/sysdeps/msftc/x86_64.h" # elif defined(_M_IX86) || defined(x86) # include "atomic_ops/sysdeps/msftc/x86.h" # elif defined(_M_ARM) || defined(ARM) || defined(_ARM_) # include "atomic_ops/sysdeps/msftc/arm.h" # define AO_GENERALIZE_TWICE # endif #endif #if defined(__sun) && !defined(__GNUC__) && !defined(AO_USE_PTHREAD_DEFS) /* Note: use -DAO_USE_PTHREAD_DEFS if Sun CC does not handle inline asm. */ # if defined(__i386) || defined(__x86_64) || defined(__amd64) # include "atomic_ops/sysdeps/sunc/x86.h" # endif #endif #if !defined(__GNUC__) && (defined(sparc) || defined(__sparc)) \ && !defined(AO_USE_PTHREAD_DEFS) # include "atomic_ops/sysdeps/sunc/sparc.h" # define AO_CAN_EMUL_CAS #endif #if defined(AO_REQUIRE_CAS) && !defined(AO_HAVE_compare_and_swap) \ && !defined(AO_HAVE_fetch_compare_and_swap) \ && !defined(AO_HAVE_compare_and_swap_full) \ && !defined(AO_HAVE_fetch_compare_and_swap_full) \ && !defined(AO_HAVE_compare_and_swap_acquire) \ && !defined(AO_HAVE_fetch_compare_and_swap_acquire) # if defined(AO_CAN_EMUL_CAS) # include "atomic_ops/sysdeps/emul_cas.h" # else # error Cannot implement AO_compare_and_swap_full on this architecture. # endif #endif /* AO_REQUIRE_CAS && !AO_HAVE_compare_and_swap ... */ /* The most common way to clear a test-and-set location */ /* at the end of a critical section. */ #if AO_AO_TS_T && !defined(AO_CLEAR) # define AO_CLEAR(addr) AO_store_release((AO_TS_t *)(addr), AO_TS_CLEAR) #endif #if AO_CHAR_TS_T && !defined(AO_CLEAR) # define AO_CLEAR(addr) AO_char_store_release((AO_TS_t *)(addr), AO_TS_CLEAR) #endif /* The generalization section. */ #if !defined(AO_GENERALIZE_TWICE) && defined(AO_CAN_EMUL_CAS) \ && !defined(AO_HAVE_compare_and_swap_full) \ && !defined(AO_HAVE_fetch_compare_and_swap_full) # define AO_GENERALIZE_TWICE #endif /* Theoretically we should repeatedly include atomic_ops/generalize.h. */ /* In fact, we observe that this converges after a small fixed number */ /* of iterations, usually one. */ #include "atomic_ops/generalize.h" #if !defined(AO_GENERALIZE_TWICE) \ && defined(AO_HAVE_compare_double_and_swap_double) \ && (!defined(AO_HAVE_double_load) || !defined(AO_HAVE_double_store)) # define AO_GENERALIZE_TWICE #endif #ifdef AO_T_IS_INT /* Included after the first generalization pass. */ # include "atomic_ops/sysdeps/ao_t_is_int.h" # ifndef AO_GENERALIZE_TWICE /* Always generalize again. */ # define AO_GENERALIZE_TWICE # endif #endif /* AO_T_IS_INT */ #ifdef AO_GENERALIZE_TWICE # include "atomic_ops/generalize.h" #endif /* For compatibility with version 0.4 and earlier */ #define AO_TS_T AO_TS_t #define AO_T AO_t #define AO_TS_VAL AO_TS_VAL_t #endif /* !AO_ATOMIC_OPS_H */ ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/000077500000000000000000000000001266352375300220055ustar00rootroot00000000000000ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/ao_version.h000066400000000000000000000034761266352375300243340ustar00rootroot00000000000000/* * Copyright (c) 2003-2004 Hewlett-Packard Development Company, L.P. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ #ifndef AO_ATOMIC_OPS_H # error This file should not be included directly. #endif /* The policy regarding version numbers: development code has odd */ /* "minor" number (and "micro" part is 0); when development is finished */ /* and a release is prepared, "minor" number is incremented (keeping */ /* "micro" number still zero), whenever a defect is fixed a new release */ /* is prepared incrementing "micro" part to odd value (the most stable */ /* release has the biggest "micro" number). */ /* The version here should match that in configure.ac and README. */ #define AO_VERSION_MAJOR 7 #define AO_VERSION_MINOR 5 #define AO_VERSION_MICRO 0 /* 7.5.0 */ ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/generalize-arithm.h000066400000000000000000003715731266352375300256050ustar00rootroot00000000000000/* * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ /* char_compare_and_swap (based on fetch_compare_and_swap) */ #if defined(AO_HAVE_char_fetch_compare_and_swap_full) \ && !defined(AO_HAVE_char_compare_and_swap_full) AO_INLINE int AO_char_compare_and_swap_full(volatile unsigned/**/char *addr, unsigned/**/char old_val, unsigned/**/char new_val) { return AO_char_fetch_compare_and_swap_full(addr, old_val, new_val) == old_val; } # define AO_HAVE_char_compare_and_swap_full #endif #if defined(AO_HAVE_char_fetch_compare_and_swap_acquire) \ && !defined(AO_HAVE_char_compare_and_swap_acquire) AO_INLINE int AO_char_compare_and_swap_acquire(volatile unsigned/**/char *addr, unsigned/**/char old_val, unsigned/**/char new_val) { return AO_char_fetch_compare_and_swap_acquire(addr, old_val, new_val) == old_val; } # define AO_HAVE_char_compare_and_swap_acquire #endif #if defined(AO_HAVE_char_fetch_compare_and_swap_release) \ && !defined(AO_HAVE_char_compare_and_swap_release) AO_INLINE int AO_char_compare_and_swap_release(volatile unsigned/**/char *addr, unsigned/**/char old_val, unsigned/**/char new_val) { return AO_char_fetch_compare_and_swap_release(addr, old_val, new_val) == old_val; } # define AO_HAVE_char_compare_and_swap_release #endif #if defined(AO_HAVE_char_fetch_compare_and_swap_write) \ && !defined(AO_HAVE_char_compare_and_swap_write) AO_INLINE int AO_char_compare_and_swap_write(volatile unsigned/**/char *addr, unsigned/**/char old_val, unsigned/**/char new_val) { return AO_char_fetch_compare_and_swap_write(addr, old_val, new_val) == old_val; } # define AO_HAVE_char_compare_and_swap_write #endif #if defined(AO_HAVE_char_fetch_compare_and_swap_read) \ && !defined(AO_HAVE_char_compare_and_swap_read) AO_INLINE int AO_char_compare_and_swap_read(volatile unsigned/**/char *addr, unsigned/**/char old_val, unsigned/**/char new_val) { return AO_char_fetch_compare_and_swap_read(addr, old_val, new_val) == old_val; } # define AO_HAVE_char_compare_and_swap_read #endif #if defined(AO_HAVE_char_fetch_compare_and_swap) \ && !defined(AO_HAVE_char_compare_and_swap) AO_INLINE int AO_char_compare_and_swap(volatile unsigned/**/char *addr, unsigned/**/char old_val, unsigned/**/char new_val) { return AO_char_fetch_compare_and_swap(addr, old_val, new_val) == old_val; } # define AO_HAVE_char_compare_and_swap #endif #if defined(AO_HAVE_char_fetch_compare_and_swap_release_write) \ && !defined(AO_HAVE_char_compare_and_swap_release_write) AO_INLINE int AO_char_compare_and_swap_release_write(volatile unsigned/**/char *addr, unsigned/**/char old_val, unsigned/**/char new_val) { return AO_char_fetch_compare_and_swap_release_write(addr, old_val, new_val) == old_val; } # define AO_HAVE_char_compare_and_swap_release_write #endif #if defined(AO_HAVE_char_fetch_compare_and_swap_acquire_read) \ && !defined(AO_HAVE_char_compare_and_swap_acquire_read) AO_INLINE int AO_char_compare_and_swap_acquire_read(volatile unsigned/**/char *addr, unsigned/**/char old_val, unsigned/**/char new_val) { return AO_char_fetch_compare_and_swap_acquire_read(addr, old_val, new_val) == old_val; } # define AO_HAVE_char_compare_and_swap_acquire_read #endif #if defined(AO_HAVE_char_fetch_compare_and_swap_dd_acquire_read) \ && !defined(AO_HAVE_char_compare_and_swap_dd_acquire_read) AO_INLINE int AO_char_compare_and_swap_dd_acquire_read(volatile unsigned/**/char *addr, unsigned/**/char old_val, unsigned/**/char new_val) { return AO_char_fetch_compare_and_swap_dd_acquire_read(addr, old_val, new_val) == old_val; } # define AO_HAVE_char_compare_and_swap_dd_acquire_read #endif /* char_fetch_and_add */ /* We first try to implement fetch_and_add variants in terms of the */ /* corresponding compare_and_swap variants to minimize adding barriers. */ #if defined(AO_HAVE_char_compare_and_swap_full) \ && !defined(AO_HAVE_char_fetch_and_add_full) AO_INLINE unsigned/**/char AO_char_fetch_and_add_full(volatile unsigned/**/char *addr, unsigned/**/char incr) { unsigned/**/char old; do { old = *(unsigned/**/char *)addr; } while (AO_EXPECT_FALSE(!AO_char_compare_and_swap_full(addr, old, old + incr))); return old; } # define AO_HAVE_char_fetch_and_add_full #endif #if defined(AO_HAVE_char_compare_and_swap_acquire) \ && !defined(AO_HAVE_char_fetch_and_add_acquire) AO_INLINE unsigned/**/char AO_char_fetch_and_add_acquire(volatile unsigned/**/char *addr, unsigned/**/char incr) { unsigned/**/char old; do { old = *(unsigned/**/char *)addr; } while (AO_EXPECT_FALSE(!AO_char_compare_and_swap_acquire(addr, old, old + incr))); return old; } # define AO_HAVE_char_fetch_and_add_acquire #endif #if defined(AO_HAVE_char_compare_and_swap_release) \ && !defined(AO_HAVE_char_fetch_and_add_release) AO_INLINE unsigned/**/char AO_char_fetch_and_add_release(volatile unsigned/**/char *addr, unsigned/**/char incr) { unsigned/**/char old; do { old = *(unsigned/**/char *)addr; } while (AO_EXPECT_FALSE(!AO_char_compare_and_swap_release(addr, old, old + incr))); return old; } # define AO_HAVE_char_fetch_and_add_release #endif #if defined(AO_HAVE_char_compare_and_swap) \ && !defined(AO_HAVE_char_fetch_and_add) AO_INLINE unsigned/**/char AO_char_fetch_and_add(volatile unsigned/**/char *addr, unsigned/**/char incr) { unsigned/**/char old; do { old = *(unsigned/**/char *)addr; } while (AO_EXPECT_FALSE(!AO_char_compare_and_swap(addr, old, old + incr))); return old; } # define AO_HAVE_char_fetch_and_add #endif #if defined(AO_HAVE_char_fetch_and_add_full) # if !defined(AO_HAVE_char_fetch_and_add_release) # define AO_char_fetch_and_add_release(addr, val) \ AO_char_fetch_and_add_full(addr, val) # define AO_HAVE_char_fetch_and_add_release # endif # if !defined(AO_HAVE_char_fetch_and_add_acquire) # define AO_char_fetch_and_add_acquire(addr, val) \ AO_char_fetch_and_add_full(addr, val) # define AO_HAVE_char_fetch_and_add_acquire # endif # if !defined(AO_HAVE_char_fetch_and_add_write) # define AO_char_fetch_and_add_write(addr, val) \ AO_char_fetch_and_add_full(addr, val) # define AO_HAVE_char_fetch_and_add_write # endif # if !defined(AO_HAVE_char_fetch_and_add_read) # define AO_char_fetch_and_add_read(addr, val) \ AO_char_fetch_and_add_full(addr, val) # define AO_HAVE_char_fetch_and_add_read # endif #endif /* AO_HAVE_char_fetch_and_add_full */ #if defined(AO_HAVE_char_fetch_and_add) && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_char_fetch_and_add_acquire) AO_INLINE unsigned/**/char AO_char_fetch_and_add_acquire(volatile unsigned/**/char *addr, unsigned/**/char incr) { unsigned/**/char result = AO_char_fetch_and_add(addr, incr); AO_nop_full(); return result; } # define AO_HAVE_char_fetch_and_add_acquire #endif #if defined(AO_HAVE_char_fetch_and_add) && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_char_fetch_and_add_release) # define AO_char_fetch_and_add_release(addr, incr) \ (AO_nop_full(), AO_char_fetch_and_add(addr, incr)) # define AO_HAVE_char_fetch_and_add_release #endif #if !defined(AO_HAVE_char_fetch_and_add) \ && defined(AO_HAVE_char_fetch_and_add_release) # define AO_char_fetch_and_add(addr, val) \ AO_char_fetch_and_add_release(addr, val) # define AO_HAVE_char_fetch_and_add #endif #if !defined(AO_HAVE_char_fetch_and_add) \ && defined(AO_HAVE_char_fetch_and_add_acquire) # define AO_char_fetch_and_add(addr, val) \ AO_char_fetch_and_add_acquire(addr, val) # define AO_HAVE_char_fetch_and_add #endif #if !defined(AO_HAVE_char_fetch_and_add) \ && defined(AO_HAVE_char_fetch_and_add_write) # define AO_char_fetch_and_add(addr, val) \ AO_char_fetch_and_add_write(addr, val) # define AO_HAVE_char_fetch_and_add #endif #if !defined(AO_HAVE_char_fetch_and_add) \ && defined(AO_HAVE_char_fetch_and_add_read) # define AO_char_fetch_and_add(addr, val) \ AO_char_fetch_and_add_read(addr, val) # define AO_HAVE_char_fetch_and_add #endif #if defined(AO_HAVE_char_fetch_and_add_acquire) \ && defined(AO_HAVE_nop_full) && !defined(AO_HAVE_char_fetch_and_add_full) # define AO_char_fetch_and_add_full(addr, val) \ (AO_nop_full(), AO_char_fetch_and_add_acquire(addr, val)) # define AO_HAVE_char_fetch_and_add_full #endif #if !defined(AO_HAVE_char_fetch_and_add_release_write) \ && defined(AO_HAVE_char_fetch_and_add_write) # define AO_char_fetch_and_add_release_write(addr, val) \ AO_char_fetch_and_add_write(addr, val) # define AO_HAVE_char_fetch_and_add_release_write #endif #if !defined(AO_HAVE_char_fetch_and_add_release_write) \ && defined(AO_HAVE_char_fetch_and_add_release) # define AO_char_fetch_and_add_release_write(addr, val) \ AO_char_fetch_and_add_release(addr, val) # define AO_HAVE_char_fetch_and_add_release_write #endif #if !defined(AO_HAVE_char_fetch_and_add_acquire_read) \ && defined(AO_HAVE_char_fetch_and_add_read) # define AO_char_fetch_and_add_acquire_read(addr, val) \ AO_char_fetch_and_add_read(addr, val) # define AO_HAVE_char_fetch_and_add_acquire_read #endif #if !defined(AO_HAVE_char_fetch_and_add_acquire_read) \ && defined(AO_HAVE_char_fetch_and_add_acquire) # define AO_char_fetch_and_add_acquire_read(addr, val) \ AO_char_fetch_and_add_acquire(addr, val) # define AO_HAVE_char_fetch_and_add_acquire_read #endif #ifdef AO_NO_DD_ORDERING # if defined(AO_HAVE_char_fetch_and_add_acquire_read) # define AO_char_fetch_and_add_dd_acquire_read(addr, val) \ AO_char_fetch_and_add_acquire_read(addr, val) # define AO_HAVE_char_fetch_and_add_dd_acquire_read # endif #else # if defined(AO_HAVE_char_fetch_and_add) # define AO_char_fetch_and_add_dd_acquire_read(addr, val) \ AO_char_fetch_and_add(addr, val) # define AO_HAVE_char_fetch_and_add_dd_acquire_read # endif #endif /* !AO_NO_DD_ORDERING */ /* char_fetch_and_add1 */ #if defined(AO_HAVE_char_fetch_and_add_full) \ && !defined(AO_HAVE_char_fetch_and_add1_full) # define AO_char_fetch_and_add1_full(addr) \ AO_char_fetch_and_add_full(addr, 1) # define AO_HAVE_char_fetch_and_add1_full #endif #if defined(AO_HAVE_char_fetch_and_add_release) \ && !defined(AO_HAVE_char_fetch_and_add1_release) # define AO_char_fetch_and_add1_release(addr) \ AO_char_fetch_and_add_release(addr, 1) # define AO_HAVE_char_fetch_and_add1_release #endif #if defined(AO_HAVE_char_fetch_and_add_acquire) \ && !defined(AO_HAVE_char_fetch_and_add1_acquire) # define AO_char_fetch_and_add1_acquire(addr) \ AO_char_fetch_and_add_acquire(addr, 1) # define AO_HAVE_char_fetch_and_add1_acquire #endif #if defined(AO_HAVE_char_fetch_and_add_write) \ && !defined(AO_HAVE_char_fetch_and_add1_write) # define AO_char_fetch_and_add1_write(addr) \ AO_char_fetch_and_add_write(addr, 1) # define AO_HAVE_char_fetch_and_add1_write #endif #if defined(AO_HAVE_char_fetch_and_add_read) \ && !defined(AO_HAVE_char_fetch_and_add1_read) # define AO_char_fetch_and_add1_read(addr) \ AO_char_fetch_and_add_read(addr, 1) # define AO_HAVE_char_fetch_and_add1_read #endif #if defined(AO_HAVE_char_fetch_and_add_release_write) \ && !defined(AO_HAVE_char_fetch_and_add1_release_write) # define AO_char_fetch_and_add1_release_write(addr) \ AO_char_fetch_and_add_release_write(addr, 1) # define AO_HAVE_char_fetch_and_add1_release_write #endif #if defined(AO_HAVE_char_fetch_and_add_acquire_read) \ && !defined(AO_HAVE_char_fetch_and_add1_acquire_read) # define AO_char_fetch_and_add1_acquire_read(addr) \ AO_char_fetch_and_add_acquire_read(addr, 1) # define AO_HAVE_char_fetch_and_add1_acquire_read #endif #if defined(AO_HAVE_char_fetch_and_add) \ && !defined(AO_HAVE_char_fetch_and_add1) # define AO_char_fetch_and_add1(addr) AO_char_fetch_and_add(addr, 1) # define AO_HAVE_char_fetch_and_add1 #endif #if defined(AO_HAVE_char_fetch_and_add1_full) # if !defined(AO_HAVE_char_fetch_and_add1_release) # define AO_char_fetch_and_add1_release(addr) \ AO_char_fetch_and_add1_full(addr) # define AO_HAVE_char_fetch_and_add1_release # endif # if !defined(AO_HAVE_char_fetch_and_add1_acquire) # define AO_char_fetch_and_add1_acquire(addr) \ AO_char_fetch_and_add1_full(addr) # define AO_HAVE_char_fetch_and_add1_acquire # endif # if !defined(AO_HAVE_char_fetch_and_add1_write) # define AO_char_fetch_and_add1_write(addr) \ AO_char_fetch_and_add1_full(addr) # define AO_HAVE_char_fetch_and_add1_write # endif # if !defined(AO_HAVE_char_fetch_and_add1_read) # define AO_char_fetch_and_add1_read(addr) \ AO_char_fetch_and_add1_full(addr) # define AO_HAVE_char_fetch_and_add1_read # endif #endif /* AO_HAVE_char_fetch_and_add1_full */ #if !defined(AO_HAVE_char_fetch_and_add1) \ && defined(AO_HAVE_char_fetch_and_add1_release) # define AO_char_fetch_and_add1(addr) AO_char_fetch_and_add1_release(addr) # define AO_HAVE_char_fetch_and_add1 #endif #if !defined(AO_HAVE_char_fetch_and_add1) \ && defined(AO_HAVE_char_fetch_and_add1_acquire) # define AO_char_fetch_and_add1(addr) AO_char_fetch_and_add1_acquire(addr) # define AO_HAVE_char_fetch_and_add1 #endif #if !defined(AO_HAVE_char_fetch_and_add1) \ && defined(AO_HAVE_char_fetch_and_add1_write) # define AO_char_fetch_and_add1(addr) AO_char_fetch_and_add1_write(addr) # define AO_HAVE_char_fetch_and_add1 #endif #if !defined(AO_HAVE_char_fetch_and_add1) \ && defined(AO_HAVE_char_fetch_and_add1_read) # define AO_char_fetch_and_add1(addr) AO_char_fetch_and_add1_read(addr) # define AO_HAVE_char_fetch_and_add1 #endif #if defined(AO_HAVE_char_fetch_and_add1_acquire) \ && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_char_fetch_and_add1_full) # define AO_char_fetch_and_add1_full(addr) \ (AO_nop_full(), AO_char_fetch_and_add1_acquire(addr)) # define AO_HAVE_char_fetch_and_add1_full #endif #if !defined(AO_HAVE_char_fetch_and_add1_release_write) \ && defined(AO_HAVE_char_fetch_and_add1_write) # define AO_char_fetch_and_add1_release_write(addr) \ AO_char_fetch_and_add1_write(addr) # define AO_HAVE_char_fetch_and_add1_release_write #endif #if !defined(AO_HAVE_char_fetch_and_add1_release_write) \ && defined(AO_HAVE_char_fetch_and_add1_release) # define AO_char_fetch_and_add1_release_write(addr) \ AO_char_fetch_and_add1_release(addr) # define AO_HAVE_char_fetch_and_add1_release_write #endif #if !defined(AO_HAVE_char_fetch_and_add1_acquire_read) \ && defined(AO_HAVE_char_fetch_and_add1_read) # define AO_char_fetch_and_add1_acquire_read(addr) \ AO_char_fetch_and_add1_read(addr) # define AO_HAVE_char_fetch_and_add1_acquire_read #endif #if !defined(AO_HAVE_char_fetch_and_add1_acquire_read) \ && defined(AO_HAVE_char_fetch_and_add1_acquire) # define AO_char_fetch_and_add1_acquire_read(addr) \ AO_char_fetch_and_add1_acquire(addr) # define AO_HAVE_char_fetch_and_add1_acquire_read #endif #ifdef AO_NO_DD_ORDERING # if defined(AO_HAVE_char_fetch_and_add1_acquire_read) # define AO_char_fetch_and_add1_dd_acquire_read(addr) \ AO_char_fetch_and_add1_acquire_read(addr) # define AO_HAVE_char_fetch_and_add1_dd_acquire_read # endif #else # if defined(AO_HAVE_char_fetch_and_add1) # define AO_char_fetch_and_add1_dd_acquire_read(addr) \ AO_char_fetch_and_add1(addr) # define AO_HAVE_char_fetch_and_add1_dd_acquire_read # endif #endif /* !AO_NO_DD_ORDERING */ /* char_fetch_and_sub1 */ #if defined(AO_HAVE_char_fetch_and_add_full) \ && !defined(AO_HAVE_char_fetch_and_sub1_full) # define AO_char_fetch_and_sub1_full(addr) \ AO_char_fetch_and_add_full(addr, (unsigned/**/char)(-1)) # define AO_HAVE_char_fetch_and_sub1_full #endif #if defined(AO_HAVE_char_fetch_and_add_release) \ && !defined(AO_HAVE_char_fetch_and_sub1_release) # define AO_char_fetch_and_sub1_release(addr) \ AO_char_fetch_and_add_release(addr, (unsigned/**/char)(-1)) # define AO_HAVE_char_fetch_and_sub1_release #endif #if defined(AO_HAVE_char_fetch_and_add_acquire) \ && !defined(AO_HAVE_char_fetch_and_sub1_acquire) # define AO_char_fetch_and_sub1_acquire(addr) \ AO_char_fetch_and_add_acquire(addr, (unsigned/**/char)(-1)) # define AO_HAVE_char_fetch_and_sub1_acquire #endif #if defined(AO_HAVE_char_fetch_and_add_write) \ && !defined(AO_HAVE_char_fetch_and_sub1_write) # define AO_char_fetch_and_sub1_write(addr) \ AO_char_fetch_and_add_write(addr, (unsigned/**/char)(-1)) # define AO_HAVE_char_fetch_and_sub1_write #endif #if defined(AO_HAVE_char_fetch_and_add_read) \ && !defined(AO_HAVE_char_fetch_and_sub1_read) # define AO_char_fetch_and_sub1_read(addr) \ AO_char_fetch_and_add_read(addr, (unsigned/**/char)(-1)) # define AO_HAVE_char_fetch_and_sub1_read #endif #if defined(AO_HAVE_char_fetch_and_add_release_write) \ && !defined(AO_HAVE_char_fetch_and_sub1_release_write) # define AO_char_fetch_and_sub1_release_write(addr) \ AO_char_fetch_and_add_release_write(addr, (unsigned/**/char)(-1)) # define AO_HAVE_char_fetch_and_sub1_release_write #endif #if defined(AO_HAVE_char_fetch_and_add_acquire_read) \ && !defined(AO_HAVE_char_fetch_and_sub1_acquire_read) # define AO_char_fetch_and_sub1_acquire_read(addr) \ AO_char_fetch_and_add_acquire_read(addr, (unsigned/**/char)(-1)) # define AO_HAVE_char_fetch_and_sub1_acquire_read #endif #if defined(AO_HAVE_char_fetch_and_add) \ && !defined(AO_HAVE_char_fetch_and_sub1) # define AO_char_fetch_and_sub1(addr) \ AO_char_fetch_and_add(addr, (unsigned/**/char)(-1)) # define AO_HAVE_char_fetch_and_sub1 #endif #if defined(AO_HAVE_char_fetch_and_sub1_full) # if !defined(AO_HAVE_char_fetch_and_sub1_release) # define AO_char_fetch_and_sub1_release(addr) \ AO_char_fetch_and_sub1_full(addr) # define AO_HAVE_char_fetch_and_sub1_release # endif # if !defined(AO_HAVE_char_fetch_and_sub1_acquire) # define AO_char_fetch_and_sub1_acquire(addr) \ AO_char_fetch_and_sub1_full(addr) # define AO_HAVE_char_fetch_and_sub1_acquire # endif # if !defined(AO_HAVE_char_fetch_and_sub1_write) # define AO_char_fetch_and_sub1_write(addr) \ AO_char_fetch_and_sub1_full(addr) # define AO_HAVE_char_fetch_and_sub1_write # endif # if !defined(AO_HAVE_char_fetch_and_sub1_read) # define AO_char_fetch_and_sub1_read(addr) \ AO_char_fetch_and_sub1_full(addr) # define AO_HAVE_char_fetch_and_sub1_read # endif #endif /* AO_HAVE_char_fetch_and_sub1_full */ #if !defined(AO_HAVE_char_fetch_and_sub1) \ && defined(AO_HAVE_char_fetch_and_sub1_release) # define AO_char_fetch_and_sub1(addr) AO_char_fetch_and_sub1_release(addr) # define AO_HAVE_char_fetch_and_sub1 #endif #if !defined(AO_HAVE_char_fetch_and_sub1) \ && defined(AO_HAVE_char_fetch_and_sub1_acquire) # define AO_char_fetch_and_sub1(addr) AO_char_fetch_and_sub1_acquire(addr) # define AO_HAVE_char_fetch_and_sub1 #endif #if !defined(AO_HAVE_char_fetch_and_sub1) \ && defined(AO_HAVE_char_fetch_and_sub1_write) # define AO_char_fetch_and_sub1(addr) AO_char_fetch_and_sub1_write(addr) # define AO_HAVE_char_fetch_and_sub1 #endif #if !defined(AO_HAVE_char_fetch_and_sub1) \ && defined(AO_HAVE_char_fetch_and_sub1_read) # define AO_char_fetch_and_sub1(addr) AO_char_fetch_and_sub1_read(addr) # define AO_HAVE_char_fetch_and_sub1 #endif #if defined(AO_HAVE_char_fetch_and_sub1_acquire) \ && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_char_fetch_and_sub1_full) # define AO_char_fetch_and_sub1_full(addr) \ (AO_nop_full(), AO_char_fetch_and_sub1_acquire(addr)) # define AO_HAVE_char_fetch_and_sub1_full #endif #if !defined(AO_HAVE_char_fetch_and_sub1_release_write) \ && defined(AO_HAVE_char_fetch_and_sub1_write) # define AO_char_fetch_and_sub1_release_write(addr) \ AO_char_fetch_and_sub1_write(addr) # define AO_HAVE_char_fetch_and_sub1_release_write #endif #if !defined(AO_HAVE_char_fetch_and_sub1_release_write) \ && defined(AO_HAVE_char_fetch_and_sub1_release) # define AO_char_fetch_and_sub1_release_write(addr) \ AO_char_fetch_and_sub1_release(addr) # define AO_HAVE_char_fetch_and_sub1_release_write #endif #if !defined(AO_HAVE_char_fetch_and_sub1_acquire_read) \ && defined(AO_HAVE_char_fetch_and_sub1_read) # define AO_char_fetch_and_sub1_acquire_read(addr) \ AO_char_fetch_and_sub1_read(addr) # define AO_HAVE_char_fetch_and_sub1_acquire_read #endif #if !defined(AO_HAVE_char_fetch_and_sub1_acquire_read) \ && defined(AO_HAVE_char_fetch_and_sub1_acquire) # define AO_char_fetch_and_sub1_acquire_read(addr) \ AO_char_fetch_and_sub1_acquire(addr) # define AO_HAVE_char_fetch_and_sub1_acquire_read #endif #ifdef AO_NO_DD_ORDERING # if defined(AO_HAVE_char_fetch_and_sub1_acquire_read) # define AO_char_fetch_and_sub1_dd_acquire_read(addr) \ AO_char_fetch_and_sub1_acquire_read(addr) # define AO_HAVE_char_fetch_and_sub1_dd_acquire_read # endif #else # if defined(AO_HAVE_char_fetch_and_sub1) # define AO_char_fetch_and_sub1_dd_acquire_read(addr) \ AO_char_fetch_and_sub1(addr) # define AO_HAVE_char_fetch_and_sub1_dd_acquire_read # endif #endif /* !AO_NO_DD_ORDERING */ /* char_and */ #if defined(AO_HAVE_char_compare_and_swap_full) \ && !defined(AO_HAVE_char_and_full) AO_INLINE void AO_char_and_full(volatile unsigned/**/char *addr, unsigned/**/char value) { unsigned/**/char old; do { old = *(unsigned/**/char *)addr; } while (AO_EXPECT_FALSE(!AO_char_compare_and_swap_full(addr, old, old & value))); } # define AO_HAVE_char_and_full #endif #if defined(AO_HAVE_char_and_full) # if !defined(AO_HAVE_char_and_release) # define AO_char_and_release(addr, val) AO_char_and_full(addr, val) # define AO_HAVE_char_and_release # endif # if !defined(AO_HAVE_char_and_acquire) # define AO_char_and_acquire(addr, val) AO_char_and_full(addr, val) # define AO_HAVE_char_and_acquire # endif # if !defined(AO_HAVE_char_and_write) # define AO_char_and_write(addr, val) AO_char_and_full(addr, val) # define AO_HAVE_char_and_write # endif # if !defined(AO_HAVE_char_and_read) # define AO_char_and_read(addr, val) AO_char_and_full(addr, val) # define AO_HAVE_char_and_read # endif #endif /* AO_HAVE_char_and_full */ #if !defined(AO_HAVE_char_and) && defined(AO_HAVE_char_and_release) # define AO_char_and(addr, val) AO_char_and_release(addr, val) # define AO_HAVE_char_and #endif #if !defined(AO_HAVE_char_and) && defined(AO_HAVE_char_and_acquire) # define AO_char_and(addr, val) AO_char_and_acquire(addr, val) # define AO_HAVE_char_and #endif #if !defined(AO_HAVE_char_and) && defined(AO_HAVE_char_and_write) # define AO_char_and(addr, val) AO_char_and_write(addr, val) # define AO_HAVE_char_and #endif #if !defined(AO_HAVE_char_and) && defined(AO_HAVE_char_and_read) # define AO_char_and(addr, val) AO_char_and_read(addr, val) # define AO_HAVE_char_and #endif #if defined(AO_HAVE_char_and_acquire) && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_char_and_full) # define AO_char_and_full(addr, val) \ (AO_nop_full(), AO_char_and_acquire(addr, val)) # define AO_HAVE_char_and_full #endif #if !defined(AO_HAVE_char_and_release_write) \ && defined(AO_HAVE_char_and_write) # define AO_char_and_release_write(addr, val) AO_char_and_write(addr, val) # define AO_HAVE_char_and_release_write #endif #if !defined(AO_HAVE_char_and_release_write) \ && defined(AO_HAVE_char_and_release) # define AO_char_and_release_write(addr, val) AO_char_and_release(addr, val) # define AO_HAVE_char_and_release_write #endif #if !defined(AO_HAVE_char_and_acquire_read) \ && defined(AO_HAVE_char_and_read) # define AO_char_and_acquire_read(addr, val) AO_char_and_read(addr, val) # define AO_HAVE_char_and_acquire_read #endif #if !defined(AO_HAVE_char_and_acquire_read) \ && defined(AO_HAVE_char_and_acquire) # define AO_char_and_acquire_read(addr, val) AO_char_and_acquire(addr, val) # define AO_HAVE_char_and_acquire_read #endif /* char_or */ #if defined(AO_HAVE_char_compare_and_swap_full) \ && !defined(AO_HAVE_char_or_full) AO_INLINE void AO_char_or_full(volatile unsigned/**/char *addr, unsigned/**/char value) { unsigned/**/char old; do { old = *(unsigned/**/char *)addr; } while (AO_EXPECT_FALSE(!AO_char_compare_and_swap_full(addr, old, old | value))); } # define AO_HAVE_char_or_full #endif #if defined(AO_HAVE_char_or_full) # if !defined(AO_HAVE_char_or_release) # define AO_char_or_release(addr, val) AO_char_or_full(addr, val) # define AO_HAVE_char_or_release # endif # if !defined(AO_HAVE_char_or_acquire) # define AO_char_or_acquire(addr, val) AO_char_or_full(addr, val) # define AO_HAVE_char_or_acquire # endif # if !defined(AO_HAVE_char_or_write) # define AO_char_or_write(addr, val) AO_char_or_full(addr, val) # define AO_HAVE_char_or_write # endif # if !defined(AO_HAVE_char_or_read) # define AO_char_or_read(addr, val) AO_char_or_full(addr, val) # define AO_HAVE_char_or_read # endif #endif /* AO_HAVE_char_or_full */ #if !defined(AO_HAVE_char_or) && defined(AO_HAVE_char_or_release) # define AO_char_or(addr, val) AO_char_or_release(addr, val) # define AO_HAVE_char_or #endif #if !defined(AO_HAVE_char_or) && defined(AO_HAVE_char_or_acquire) # define AO_char_or(addr, val) AO_char_or_acquire(addr, val) # define AO_HAVE_char_or #endif #if !defined(AO_HAVE_char_or) && defined(AO_HAVE_char_or_write) # define AO_char_or(addr, val) AO_char_or_write(addr, val) # define AO_HAVE_char_or #endif #if !defined(AO_HAVE_char_or) && defined(AO_HAVE_char_or_read) # define AO_char_or(addr, val) AO_char_or_read(addr, val) # define AO_HAVE_char_or #endif #if defined(AO_HAVE_char_or_acquire) && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_char_or_full) # define AO_char_or_full(addr, val) \ (AO_nop_full(), AO_char_or_acquire(addr, val)) # define AO_HAVE_char_or_full #endif #if !defined(AO_HAVE_char_or_release_write) \ && defined(AO_HAVE_char_or_write) # define AO_char_or_release_write(addr, val) AO_char_or_write(addr, val) # define AO_HAVE_char_or_release_write #endif #if !defined(AO_HAVE_char_or_release_write) \ && defined(AO_HAVE_char_or_release) # define AO_char_or_release_write(addr, val) AO_char_or_release(addr, val) # define AO_HAVE_char_or_release_write #endif #if !defined(AO_HAVE_char_or_acquire_read) && defined(AO_HAVE_char_or_read) # define AO_char_or_acquire_read(addr, val) AO_char_or_read(addr, val) # define AO_HAVE_char_or_acquire_read #endif #if !defined(AO_HAVE_char_or_acquire_read) \ && defined(AO_HAVE_char_or_acquire) # define AO_char_or_acquire_read(addr, val) AO_char_or_acquire(addr, val) # define AO_HAVE_char_or_acquire_read #endif /* char_xor */ #if defined(AO_HAVE_char_compare_and_swap_full) \ && !defined(AO_HAVE_char_xor_full) AO_INLINE void AO_char_xor_full(volatile unsigned/**/char *addr, unsigned/**/char value) { unsigned/**/char old; do { old = *(unsigned/**/char *)addr; } while (AO_EXPECT_FALSE(!AO_char_compare_and_swap_full(addr, old, old ^ value))); } # define AO_HAVE_char_xor_full #endif #if defined(AO_HAVE_char_xor_full) # if !defined(AO_HAVE_char_xor_release) # define AO_char_xor_release(addr, val) AO_char_xor_full(addr, val) # define AO_HAVE_char_xor_release # endif # if !defined(AO_HAVE_char_xor_acquire) # define AO_char_xor_acquire(addr, val) AO_char_xor_full(addr, val) # define AO_HAVE_char_xor_acquire # endif # if !defined(AO_HAVE_char_xor_write) # define AO_char_xor_write(addr, val) AO_char_xor_full(addr, val) # define AO_HAVE_char_xor_write # endif # if !defined(AO_HAVE_char_xor_read) # define AO_char_xor_read(addr, val) AO_char_xor_full(addr, val) # define AO_HAVE_char_xor_read # endif #endif /* AO_HAVE_char_xor_full */ #if !defined(AO_HAVE_char_xor) && defined(AO_HAVE_char_xor_release) # define AO_char_xor(addr, val) AO_char_xor_release(addr, val) # define AO_HAVE_char_xor #endif #if !defined(AO_HAVE_char_xor) && defined(AO_HAVE_char_xor_acquire) # define AO_char_xor(addr, val) AO_char_xor_acquire(addr, val) # define AO_HAVE_char_xor #endif #if !defined(AO_HAVE_char_xor) && defined(AO_HAVE_char_xor_write) # define AO_char_xor(addr, val) AO_char_xor_write(addr, val) # define AO_HAVE_char_xor #endif #if !defined(AO_HAVE_char_xor) && defined(AO_HAVE_char_xor_read) # define AO_char_xor(addr, val) AO_char_xor_read(addr, val) # define AO_HAVE_char_xor #endif #if defined(AO_HAVE_char_xor_acquire) && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_char_xor_full) # define AO_char_xor_full(addr, val) \ (AO_nop_full(), AO_char_xor_acquire(addr, val)) # define AO_HAVE_char_xor_full #endif #if !defined(AO_HAVE_char_xor_release_write) \ && defined(AO_HAVE_char_xor_write) # define AO_char_xor_release_write(addr, val) AO_char_xor_write(addr, val) # define AO_HAVE_char_xor_release_write #endif #if !defined(AO_HAVE_char_xor_release_write) \ && defined(AO_HAVE_char_xor_release) # define AO_char_xor_release_write(addr, val) AO_char_xor_release(addr, val) # define AO_HAVE_char_xor_release_write #endif #if !defined(AO_HAVE_char_xor_acquire_read) \ && defined(AO_HAVE_char_xor_read) # define AO_char_xor_acquire_read(addr, val) AO_char_xor_read(addr, val) # define AO_HAVE_char_xor_acquire_read #endif #if !defined(AO_HAVE_char_xor_acquire_read) \ && defined(AO_HAVE_char_xor_acquire) # define AO_char_xor_acquire_read(addr, val) AO_char_xor_acquire(addr, val) # define AO_HAVE_char_xor_acquire_read #endif /* char_and/or/xor_dd_acquire_read are meaningless. */ /* * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ /* short_compare_and_swap (based on fetch_compare_and_swap) */ #if defined(AO_HAVE_short_fetch_compare_and_swap_full) \ && !defined(AO_HAVE_short_compare_and_swap_full) AO_INLINE int AO_short_compare_and_swap_full(volatile unsigned/**/short *addr, unsigned/**/short old_val, unsigned/**/short new_val) { return AO_short_fetch_compare_and_swap_full(addr, old_val, new_val) == old_val; } # define AO_HAVE_short_compare_and_swap_full #endif #if defined(AO_HAVE_short_fetch_compare_and_swap_acquire) \ && !defined(AO_HAVE_short_compare_and_swap_acquire) AO_INLINE int AO_short_compare_and_swap_acquire(volatile unsigned/**/short *addr, unsigned/**/short old_val, unsigned/**/short new_val) { return AO_short_fetch_compare_and_swap_acquire(addr, old_val, new_val) == old_val; } # define AO_HAVE_short_compare_and_swap_acquire #endif #if defined(AO_HAVE_short_fetch_compare_and_swap_release) \ && !defined(AO_HAVE_short_compare_and_swap_release) AO_INLINE int AO_short_compare_and_swap_release(volatile unsigned/**/short *addr, unsigned/**/short old_val, unsigned/**/short new_val) { return AO_short_fetch_compare_and_swap_release(addr, old_val, new_val) == old_val; } # define AO_HAVE_short_compare_and_swap_release #endif #if defined(AO_HAVE_short_fetch_compare_and_swap_write) \ && !defined(AO_HAVE_short_compare_and_swap_write) AO_INLINE int AO_short_compare_and_swap_write(volatile unsigned/**/short *addr, unsigned/**/short old_val, unsigned/**/short new_val) { return AO_short_fetch_compare_and_swap_write(addr, old_val, new_val) == old_val; } # define AO_HAVE_short_compare_and_swap_write #endif #if defined(AO_HAVE_short_fetch_compare_and_swap_read) \ && !defined(AO_HAVE_short_compare_and_swap_read) AO_INLINE int AO_short_compare_and_swap_read(volatile unsigned/**/short *addr, unsigned/**/short old_val, unsigned/**/short new_val) { return AO_short_fetch_compare_and_swap_read(addr, old_val, new_val) == old_val; } # define AO_HAVE_short_compare_and_swap_read #endif #if defined(AO_HAVE_short_fetch_compare_and_swap) \ && !defined(AO_HAVE_short_compare_and_swap) AO_INLINE int AO_short_compare_and_swap(volatile unsigned/**/short *addr, unsigned/**/short old_val, unsigned/**/short new_val) { return AO_short_fetch_compare_and_swap(addr, old_val, new_val) == old_val; } # define AO_HAVE_short_compare_and_swap #endif #if defined(AO_HAVE_short_fetch_compare_and_swap_release_write) \ && !defined(AO_HAVE_short_compare_and_swap_release_write) AO_INLINE int AO_short_compare_and_swap_release_write(volatile unsigned/**/short *addr, unsigned/**/short old_val, unsigned/**/short new_val) { return AO_short_fetch_compare_and_swap_release_write(addr, old_val, new_val) == old_val; } # define AO_HAVE_short_compare_and_swap_release_write #endif #if defined(AO_HAVE_short_fetch_compare_and_swap_acquire_read) \ && !defined(AO_HAVE_short_compare_and_swap_acquire_read) AO_INLINE int AO_short_compare_and_swap_acquire_read(volatile unsigned/**/short *addr, unsigned/**/short old_val, unsigned/**/short new_val) { return AO_short_fetch_compare_and_swap_acquire_read(addr, old_val, new_val) == old_val; } # define AO_HAVE_short_compare_and_swap_acquire_read #endif #if defined(AO_HAVE_short_fetch_compare_and_swap_dd_acquire_read) \ && !defined(AO_HAVE_short_compare_and_swap_dd_acquire_read) AO_INLINE int AO_short_compare_and_swap_dd_acquire_read(volatile unsigned/**/short *addr, unsigned/**/short old_val, unsigned/**/short new_val) { return AO_short_fetch_compare_and_swap_dd_acquire_read(addr, old_val, new_val) == old_val; } # define AO_HAVE_short_compare_and_swap_dd_acquire_read #endif /* short_fetch_and_add */ /* We first try to implement fetch_and_add variants in terms of the */ /* corresponding compare_and_swap variants to minimize adding barriers. */ #if defined(AO_HAVE_short_compare_and_swap_full) \ && !defined(AO_HAVE_short_fetch_and_add_full) AO_INLINE unsigned/**/short AO_short_fetch_and_add_full(volatile unsigned/**/short *addr, unsigned/**/short incr) { unsigned/**/short old; do { old = *(unsigned/**/short *)addr; } while (AO_EXPECT_FALSE(!AO_short_compare_and_swap_full(addr, old, old + incr))); return old; } # define AO_HAVE_short_fetch_and_add_full #endif #if defined(AO_HAVE_short_compare_and_swap_acquire) \ && !defined(AO_HAVE_short_fetch_and_add_acquire) AO_INLINE unsigned/**/short AO_short_fetch_and_add_acquire(volatile unsigned/**/short *addr, unsigned/**/short incr) { unsigned/**/short old; do { old = *(unsigned/**/short *)addr; } while (AO_EXPECT_FALSE(!AO_short_compare_and_swap_acquire(addr, old, old + incr))); return old; } # define AO_HAVE_short_fetch_and_add_acquire #endif #if defined(AO_HAVE_short_compare_and_swap_release) \ && !defined(AO_HAVE_short_fetch_and_add_release) AO_INLINE unsigned/**/short AO_short_fetch_and_add_release(volatile unsigned/**/short *addr, unsigned/**/short incr) { unsigned/**/short old; do { old = *(unsigned/**/short *)addr; } while (AO_EXPECT_FALSE(!AO_short_compare_and_swap_release(addr, old, old + incr))); return old; } # define AO_HAVE_short_fetch_and_add_release #endif #if defined(AO_HAVE_short_compare_and_swap) \ && !defined(AO_HAVE_short_fetch_and_add) AO_INLINE unsigned/**/short AO_short_fetch_and_add(volatile unsigned/**/short *addr, unsigned/**/short incr) { unsigned/**/short old; do { old = *(unsigned/**/short *)addr; } while (AO_EXPECT_FALSE(!AO_short_compare_and_swap(addr, old, old + incr))); return old; } # define AO_HAVE_short_fetch_and_add #endif #if defined(AO_HAVE_short_fetch_and_add_full) # if !defined(AO_HAVE_short_fetch_and_add_release) # define AO_short_fetch_and_add_release(addr, val) \ AO_short_fetch_and_add_full(addr, val) # define AO_HAVE_short_fetch_and_add_release # endif # if !defined(AO_HAVE_short_fetch_and_add_acquire) # define AO_short_fetch_and_add_acquire(addr, val) \ AO_short_fetch_and_add_full(addr, val) # define AO_HAVE_short_fetch_and_add_acquire # endif # if !defined(AO_HAVE_short_fetch_and_add_write) # define AO_short_fetch_and_add_write(addr, val) \ AO_short_fetch_and_add_full(addr, val) # define AO_HAVE_short_fetch_and_add_write # endif # if !defined(AO_HAVE_short_fetch_and_add_read) # define AO_short_fetch_and_add_read(addr, val) \ AO_short_fetch_and_add_full(addr, val) # define AO_HAVE_short_fetch_and_add_read # endif #endif /* AO_HAVE_short_fetch_and_add_full */ #if defined(AO_HAVE_short_fetch_and_add) && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_short_fetch_and_add_acquire) AO_INLINE unsigned/**/short AO_short_fetch_and_add_acquire(volatile unsigned/**/short *addr, unsigned/**/short incr) { unsigned/**/short result = AO_short_fetch_and_add(addr, incr); AO_nop_full(); return result; } # define AO_HAVE_short_fetch_and_add_acquire #endif #if defined(AO_HAVE_short_fetch_and_add) && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_short_fetch_and_add_release) # define AO_short_fetch_and_add_release(addr, incr) \ (AO_nop_full(), AO_short_fetch_and_add(addr, incr)) # define AO_HAVE_short_fetch_and_add_release #endif #if !defined(AO_HAVE_short_fetch_and_add) \ && defined(AO_HAVE_short_fetch_and_add_release) # define AO_short_fetch_and_add(addr, val) \ AO_short_fetch_and_add_release(addr, val) # define AO_HAVE_short_fetch_and_add #endif #if !defined(AO_HAVE_short_fetch_and_add) \ && defined(AO_HAVE_short_fetch_and_add_acquire) # define AO_short_fetch_and_add(addr, val) \ AO_short_fetch_and_add_acquire(addr, val) # define AO_HAVE_short_fetch_and_add #endif #if !defined(AO_HAVE_short_fetch_and_add) \ && defined(AO_HAVE_short_fetch_and_add_write) # define AO_short_fetch_and_add(addr, val) \ AO_short_fetch_and_add_write(addr, val) # define AO_HAVE_short_fetch_and_add #endif #if !defined(AO_HAVE_short_fetch_and_add) \ && defined(AO_HAVE_short_fetch_and_add_read) # define AO_short_fetch_and_add(addr, val) \ AO_short_fetch_and_add_read(addr, val) # define AO_HAVE_short_fetch_and_add #endif #if defined(AO_HAVE_short_fetch_and_add_acquire) \ && defined(AO_HAVE_nop_full) && !defined(AO_HAVE_short_fetch_and_add_full) # define AO_short_fetch_and_add_full(addr, val) \ (AO_nop_full(), AO_short_fetch_and_add_acquire(addr, val)) # define AO_HAVE_short_fetch_and_add_full #endif #if !defined(AO_HAVE_short_fetch_and_add_release_write) \ && defined(AO_HAVE_short_fetch_and_add_write) # define AO_short_fetch_and_add_release_write(addr, val) \ AO_short_fetch_and_add_write(addr, val) # define AO_HAVE_short_fetch_and_add_release_write #endif #if !defined(AO_HAVE_short_fetch_and_add_release_write) \ && defined(AO_HAVE_short_fetch_and_add_release) # define AO_short_fetch_and_add_release_write(addr, val) \ AO_short_fetch_and_add_release(addr, val) # define AO_HAVE_short_fetch_and_add_release_write #endif #if !defined(AO_HAVE_short_fetch_and_add_acquire_read) \ && defined(AO_HAVE_short_fetch_and_add_read) # define AO_short_fetch_and_add_acquire_read(addr, val) \ AO_short_fetch_and_add_read(addr, val) # define AO_HAVE_short_fetch_and_add_acquire_read #endif #if !defined(AO_HAVE_short_fetch_and_add_acquire_read) \ && defined(AO_HAVE_short_fetch_and_add_acquire) # define AO_short_fetch_and_add_acquire_read(addr, val) \ AO_short_fetch_and_add_acquire(addr, val) # define AO_HAVE_short_fetch_and_add_acquire_read #endif #ifdef AO_NO_DD_ORDERING # if defined(AO_HAVE_short_fetch_and_add_acquire_read) # define AO_short_fetch_and_add_dd_acquire_read(addr, val) \ AO_short_fetch_and_add_acquire_read(addr, val) # define AO_HAVE_short_fetch_and_add_dd_acquire_read # endif #else # if defined(AO_HAVE_short_fetch_and_add) # define AO_short_fetch_and_add_dd_acquire_read(addr, val) \ AO_short_fetch_and_add(addr, val) # define AO_HAVE_short_fetch_and_add_dd_acquire_read # endif #endif /* !AO_NO_DD_ORDERING */ /* short_fetch_and_add1 */ #if defined(AO_HAVE_short_fetch_and_add_full) \ && !defined(AO_HAVE_short_fetch_and_add1_full) # define AO_short_fetch_and_add1_full(addr) \ AO_short_fetch_and_add_full(addr, 1) # define AO_HAVE_short_fetch_and_add1_full #endif #if defined(AO_HAVE_short_fetch_and_add_release) \ && !defined(AO_HAVE_short_fetch_and_add1_release) # define AO_short_fetch_and_add1_release(addr) \ AO_short_fetch_and_add_release(addr, 1) # define AO_HAVE_short_fetch_and_add1_release #endif #if defined(AO_HAVE_short_fetch_and_add_acquire) \ && !defined(AO_HAVE_short_fetch_and_add1_acquire) # define AO_short_fetch_and_add1_acquire(addr) \ AO_short_fetch_and_add_acquire(addr, 1) # define AO_HAVE_short_fetch_and_add1_acquire #endif #if defined(AO_HAVE_short_fetch_and_add_write) \ && !defined(AO_HAVE_short_fetch_and_add1_write) # define AO_short_fetch_and_add1_write(addr) \ AO_short_fetch_and_add_write(addr, 1) # define AO_HAVE_short_fetch_and_add1_write #endif #if defined(AO_HAVE_short_fetch_and_add_read) \ && !defined(AO_HAVE_short_fetch_and_add1_read) # define AO_short_fetch_and_add1_read(addr) \ AO_short_fetch_and_add_read(addr, 1) # define AO_HAVE_short_fetch_and_add1_read #endif #if defined(AO_HAVE_short_fetch_and_add_release_write) \ && !defined(AO_HAVE_short_fetch_and_add1_release_write) # define AO_short_fetch_and_add1_release_write(addr) \ AO_short_fetch_and_add_release_write(addr, 1) # define AO_HAVE_short_fetch_and_add1_release_write #endif #if defined(AO_HAVE_short_fetch_and_add_acquire_read) \ && !defined(AO_HAVE_short_fetch_and_add1_acquire_read) # define AO_short_fetch_and_add1_acquire_read(addr) \ AO_short_fetch_and_add_acquire_read(addr, 1) # define AO_HAVE_short_fetch_and_add1_acquire_read #endif #if defined(AO_HAVE_short_fetch_and_add) \ && !defined(AO_HAVE_short_fetch_and_add1) # define AO_short_fetch_and_add1(addr) AO_short_fetch_and_add(addr, 1) # define AO_HAVE_short_fetch_and_add1 #endif #if defined(AO_HAVE_short_fetch_and_add1_full) # if !defined(AO_HAVE_short_fetch_and_add1_release) # define AO_short_fetch_and_add1_release(addr) \ AO_short_fetch_and_add1_full(addr) # define AO_HAVE_short_fetch_and_add1_release # endif # if !defined(AO_HAVE_short_fetch_and_add1_acquire) # define AO_short_fetch_and_add1_acquire(addr) \ AO_short_fetch_and_add1_full(addr) # define AO_HAVE_short_fetch_and_add1_acquire # endif # if !defined(AO_HAVE_short_fetch_and_add1_write) # define AO_short_fetch_and_add1_write(addr) \ AO_short_fetch_and_add1_full(addr) # define AO_HAVE_short_fetch_and_add1_write # endif # if !defined(AO_HAVE_short_fetch_and_add1_read) # define AO_short_fetch_and_add1_read(addr) \ AO_short_fetch_and_add1_full(addr) # define AO_HAVE_short_fetch_and_add1_read # endif #endif /* AO_HAVE_short_fetch_and_add1_full */ #if !defined(AO_HAVE_short_fetch_and_add1) \ && defined(AO_HAVE_short_fetch_and_add1_release) # define AO_short_fetch_and_add1(addr) AO_short_fetch_and_add1_release(addr) # define AO_HAVE_short_fetch_and_add1 #endif #if !defined(AO_HAVE_short_fetch_and_add1) \ && defined(AO_HAVE_short_fetch_and_add1_acquire) # define AO_short_fetch_and_add1(addr) AO_short_fetch_and_add1_acquire(addr) # define AO_HAVE_short_fetch_and_add1 #endif #if !defined(AO_HAVE_short_fetch_and_add1) \ && defined(AO_HAVE_short_fetch_and_add1_write) # define AO_short_fetch_and_add1(addr) AO_short_fetch_and_add1_write(addr) # define AO_HAVE_short_fetch_and_add1 #endif #if !defined(AO_HAVE_short_fetch_and_add1) \ && defined(AO_HAVE_short_fetch_and_add1_read) # define AO_short_fetch_and_add1(addr) AO_short_fetch_and_add1_read(addr) # define AO_HAVE_short_fetch_and_add1 #endif #if defined(AO_HAVE_short_fetch_and_add1_acquire) \ && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_short_fetch_and_add1_full) # define AO_short_fetch_and_add1_full(addr) \ (AO_nop_full(), AO_short_fetch_and_add1_acquire(addr)) # define AO_HAVE_short_fetch_and_add1_full #endif #if !defined(AO_HAVE_short_fetch_and_add1_release_write) \ && defined(AO_HAVE_short_fetch_and_add1_write) # define AO_short_fetch_and_add1_release_write(addr) \ AO_short_fetch_and_add1_write(addr) # define AO_HAVE_short_fetch_and_add1_release_write #endif #if !defined(AO_HAVE_short_fetch_and_add1_release_write) \ && defined(AO_HAVE_short_fetch_and_add1_release) # define AO_short_fetch_and_add1_release_write(addr) \ AO_short_fetch_and_add1_release(addr) # define AO_HAVE_short_fetch_and_add1_release_write #endif #if !defined(AO_HAVE_short_fetch_and_add1_acquire_read) \ && defined(AO_HAVE_short_fetch_and_add1_read) # define AO_short_fetch_and_add1_acquire_read(addr) \ AO_short_fetch_and_add1_read(addr) # define AO_HAVE_short_fetch_and_add1_acquire_read #endif #if !defined(AO_HAVE_short_fetch_and_add1_acquire_read) \ && defined(AO_HAVE_short_fetch_and_add1_acquire) # define AO_short_fetch_and_add1_acquire_read(addr) \ AO_short_fetch_and_add1_acquire(addr) # define AO_HAVE_short_fetch_and_add1_acquire_read #endif #ifdef AO_NO_DD_ORDERING # if defined(AO_HAVE_short_fetch_and_add1_acquire_read) # define AO_short_fetch_and_add1_dd_acquire_read(addr) \ AO_short_fetch_and_add1_acquire_read(addr) # define AO_HAVE_short_fetch_and_add1_dd_acquire_read # endif #else # if defined(AO_HAVE_short_fetch_and_add1) # define AO_short_fetch_and_add1_dd_acquire_read(addr) \ AO_short_fetch_and_add1(addr) # define AO_HAVE_short_fetch_and_add1_dd_acquire_read # endif #endif /* !AO_NO_DD_ORDERING */ /* short_fetch_and_sub1 */ #if defined(AO_HAVE_short_fetch_and_add_full) \ && !defined(AO_HAVE_short_fetch_and_sub1_full) # define AO_short_fetch_and_sub1_full(addr) \ AO_short_fetch_and_add_full(addr, (unsigned/**/short)(-1)) # define AO_HAVE_short_fetch_and_sub1_full #endif #if defined(AO_HAVE_short_fetch_and_add_release) \ && !defined(AO_HAVE_short_fetch_and_sub1_release) # define AO_short_fetch_and_sub1_release(addr) \ AO_short_fetch_and_add_release(addr, (unsigned/**/short)(-1)) # define AO_HAVE_short_fetch_and_sub1_release #endif #if defined(AO_HAVE_short_fetch_and_add_acquire) \ && !defined(AO_HAVE_short_fetch_and_sub1_acquire) # define AO_short_fetch_and_sub1_acquire(addr) \ AO_short_fetch_and_add_acquire(addr, (unsigned/**/short)(-1)) # define AO_HAVE_short_fetch_and_sub1_acquire #endif #if defined(AO_HAVE_short_fetch_and_add_write) \ && !defined(AO_HAVE_short_fetch_and_sub1_write) # define AO_short_fetch_and_sub1_write(addr) \ AO_short_fetch_and_add_write(addr, (unsigned/**/short)(-1)) # define AO_HAVE_short_fetch_and_sub1_write #endif #if defined(AO_HAVE_short_fetch_and_add_read) \ && !defined(AO_HAVE_short_fetch_and_sub1_read) # define AO_short_fetch_and_sub1_read(addr) \ AO_short_fetch_and_add_read(addr, (unsigned/**/short)(-1)) # define AO_HAVE_short_fetch_and_sub1_read #endif #if defined(AO_HAVE_short_fetch_and_add_release_write) \ && !defined(AO_HAVE_short_fetch_and_sub1_release_write) # define AO_short_fetch_and_sub1_release_write(addr) \ AO_short_fetch_and_add_release_write(addr, (unsigned/**/short)(-1)) # define AO_HAVE_short_fetch_and_sub1_release_write #endif #if defined(AO_HAVE_short_fetch_and_add_acquire_read) \ && !defined(AO_HAVE_short_fetch_and_sub1_acquire_read) # define AO_short_fetch_and_sub1_acquire_read(addr) \ AO_short_fetch_and_add_acquire_read(addr, (unsigned/**/short)(-1)) # define AO_HAVE_short_fetch_and_sub1_acquire_read #endif #if defined(AO_HAVE_short_fetch_and_add) \ && !defined(AO_HAVE_short_fetch_and_sub1) # define AO_short_fetch_and_sub1(addr) \ AO_short_fetch_and_add(addr, (unsigned/**/short)(-1)) # define AO_HAVE_short_fetch_and_sub1 #endif #if defined(AO_HAVE_short_fetch_and_sub1_full) # if !defined(AO_HAVE_short_fetch_and_sub1_release) # define AO_short_fetch_and_sub1_release(addr) \ AO_short_fetch_and_sub1_full(addr) # define AO_HAVE_short_fetch_and_sub1_release # endif # if !defined(AO_HAVE_short_fetch_and_sub1_acquire) # define AO_short_fetch_and_sub1_acquire(addr) \ AO_short_fetch_and_sub1_full(addr) # define AO_HAVE_short_fetch_and_sub1_acquire # endif # if !defined(AO_HAVE_short_fetch_and_sub1_write) # define AO_short_fetch_and_sub1_write(addr) \ AO_short_fetch_and_sub1_full(addr) # define AO_HAVE_short_fetch_and_sub1_write # endif # if !defined(AO_HAVE_short_fetch_and_sub1_read) # define AO_short_fetch_and_sub1_read(addr) \ AO_short_fetch_and_sub1_full(addr) # define AO_HAVE_short_fetch_and_sub1_read # endif #endif /* AO_HAVE_short_fetch_and_sub1_full */ #if !defined(AO_HAVE_short_fetch_and_sub1) \ && defined(AO_HAVE_short_fetch_and_sub1_release) # define AO_short_fetch_and_sub1(addr) AO_short_fetch_and_sub1_release(addr) # define AO_HAVE_short_fetch_and_sub1 #endif #if !defined(AO_HAVE_short_fetch_and_sub1) \ && defined(AO_HAVE_short_fetch_and_sub1_acquire) # define AO_short_fetch_and_sub1(addr) AO_short_fetch_and_sub1_acquire(addr) # define AO_HAVE_short_fetch_and_sub1 #endif #if !defined(AO_HAVE_short_fetch_and_sub1) \ && defined(AO_HAVE_short_fetch_and_sub1_write) # define AO_short_fetch_and_sub1(addr) AO_short_fetch_and_sub1_write(addr) # define AO_HAVE_short_fetch_and_sub1 #endif #if !defined(AO_HAVE_short_fetch_and_sub1) \ && defined(AO_HAVE_short_fetch_and_sub1_read) # define AO_short_fetch_and_sub1(addr) AO_short_fetch_and_sub1_read(addr) # define AO_HAVE_short_fetch_and_sub1 #endif #if defined(AO_HAVE_short_fetch_and_sub1_acquire) \ && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_short_fetch_and_sub1_full) # define AO_short_fetch_and_sub1_full(addr) \ (AO_nop_full(), AO_short_fetch_and_sub1_acquire(addr)) # define AO_HAVE_short_fetch_and_sub1_full #endif #if !defined(AO_HAVE_short_fetch_and_sub1_release_write) \ && defined(AO_HAVE_short_fetch_and_sub1_write) # define AO_short_fetch_and_sub1_release_write(addr) \ AO_short_fetch_and_sub1_write(addr) # define AO_HAVE_short_fetch_and_sub1_release_write #endif #if !defined(AO_HAVE_short_fetch_and_sub1_release_write) \ && defined(AO_HAVE_short_fetch_and_sub1_release) # define AO_short_fetch_and_sub1_release_write(addr) \ AO_short_fetch_and_sub1_release(addr) # define AO_HAVE_short_fetch_and_sub1_release_write #endif #if !defined(AO_HAVE_short_fetch_and_sub1_acquire_read) \ && defined(AO_HAVE_short_fetch_and_sub1_read) # define AO_short_fetch_and_sub1_acquire_read(addr) \ AO_short_fetch_and_sub1_read(addr) # define AO_HAVE_short_fetch_and_sub1_acquire_read #endif #if !defined(AO_HAVE_short_fetch_and_sub1_acquire_read) \ && defined(AO_HAVE_short_fetch_and_sub1_acquire) # define AO_short_fetch_and_sub1_acquire_read(addr) \ AO_short_fetch_and_sub1_acquire(addr) # define AO_HAVE_short_fetch_and_sub1_acquire_read #endif #ifdef AO_NO_DD_ORDERING # if defined(AO_HAVE_short_fetch_and_sub1_acquire_read) # define AO_short_fetch_and_sub1_dd_acquire_read(addr) \ AO_short_fetch_and_sub1_acquire_read(addr) # define AO_HAVE_short_fetch_and_sub1_dd_acquire_read # endif #else # if defined(AO_HAVE_short_fetch_and_sub1) # define AO_short_fetch_and_sub1_dd_acquire_read(addr) \ AO_short_fetch_and_sub1(addr) # define AO_HAVE_short_fetch_and_sub1_dd_acquire_read # endif #endif /* !AO_NO_DD_ORDERING */ /* short_and */ #if defined(AO_HAVE_short_compare_and_swap_full) \ && !defined(AO_HAVE_short_and_full) AO_INLINE void AO_short_and_full(volatile unsigned/**/short *addr, unsigned/**/short value) { unsigned/**/short old; do { old = *(unsigned/**/short *)addr; } while (AO_EXPECT_FALSE(!AO_short_compare_and_swap_full(addr, old, old & value))); } # define AO_HAVE_short_and_full #endif #if defined(AO_HAVE_short_and_full) # if !defined(AO_HAVE_short_and_release) # define AO_short_and_release(addr, val) AO_short_and_full(addr, val) # define AO_HAVE_short_and_release # endif # if !defined(AO_HAVE_short_and_acquire) # define AO_short_and_acquire(addr, val) AO_short_and_full(addr, val) # define AO_HAVE_short_and_acquire # endif # if !defined(AO_HAVE_short_and_write) # define AO_short_and_write(addr, val) AO_short_and_full(addr, val) # define AO_HAVE_short_and_write # endif # if !defined(AO_HAVE_short_and_read) # define AO_short_and_read(addr, val) AO_short_and_full(addr, val) # define AO_HAVE_short_and_read # endif #endif /* AO_HAVE_short_and_full */ #if !defined(AO_HAVE_short_and) && defined(AO_HAVE_short_and_release) # define AO_short_and(addr, val) AO_short_and_release(addr, val) # define AO_HAVE_short_and #endif #if !defined(AO_HAVE_short_and) && defined(AO_HAVE_short_and_acquire) # define AO_short_and(addr, val) AO_short_and_acquire(addr, val) # define AO_HAVE_short_and #endif #if !defined(AO_HAVE_short_and) && defined(AO_HAVE_short_and_write) # define AO_short_and(addr, val) AO_short_and_write(addr, val) # define AO_HAVE_short_and #endif #if !defined(AO_HAVE_short_and) && defined(AO_HAVE_short_and_read) # define AO_short_and(addr, val) AO_short_and_read(addr, val) # define AO_HAVE_short_and #endif #if defined(AO_HAVE_short_and_acquire) && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_short_and_full) # define AO_short_and_full(addr, val) \ (AO_nop_full(), AO_short_and_acquire(addr, val)) # define AO_HAVE_short_and_full #endif #if !defined(AO_HAVE_short_and_release_write) \ && defined(AO_HAVE_short_and_write) # define AO_short_and_release_write(addr, val) AO_short_and_write(addr, val) # define AO_HAVE_short_and_release_write #endif #if !defined(AO_HAVE_short_and_release_write) \ && defined(AO_HAVE_short_and_release) # define AO_short_and_release_write(addr, val) AO_short_and_release(addr, val) # define AO_HAVE_short_and_release_write #endif #if !defined(AO_HAVE_short_and_acquire_read) \ && defined(AO_HAVE_short_and_read) # define AO_short_and_acquire_read(addr, val) AO_short_and_read(addr, val) # define AO_HAVE_short_and_acquire_read #endif #if !defined(AO_HAVE_short_and_acquire_read) \ && defined(AO_HAVE_short_and_acquire) # define AO_short_and_acquire_read(addr, val) AO_short_and_acquire(addr, val) # define AO_HAVE_short_and_acquire_read #endif /* short_or */ #if defined(AO_HAVE_short_compare_and_swap_full) \ && !defined(AO_HAVE_short_or_full) AO_INLINE void AO_short_or_full(volatile unsigned/**/short *addr, unsigned/**/short value) { unsigned/**/short old; do { old = *(unsigned/**/short *)addr; } while (AO_EXPECT_FALSE(!AO_short_compare_and_swap_full(addr, old, old | value))); } # define AO_HAVE_short_or_full #endif #if defined(AO_HAVE_short_or_full) # if !defined(AO_HAVE_short_or_release) # define AO_short_or_release(addr, val) AO_short_or_full(addr, val) # define AO_HAVE_short_or_release # endif # if !defined(AO_HAVE_short_or_acquire) # define AO_short_or_acquire(addr, val) AO_short_or_full(addr, val) # define AO_HAVE_short_or_acquire # endif # if !defined(AO_HAVE_short_or_write) # define AO_short_or_write(addr, val) AO_short_or_full(addr, val) # define AO_HAVE_short_or_write # endif # if !defined(AO_HAVE_short_or_read) # define AO_short_or_read(addr, val) AO_short_or_full(addr, val) # define AO_HAVE_short_or_read # endif #endif /* AO_HAVE_short_or_full */ #if !defined(AO_HAVE_short_or) && defined(AO_HAVE_short_or_release) # define AO_short_or(addr, val) AO_short_or_release(addr, val) # define AO_HAVE_short_or #endif #if !defined(AO_HAVE_short_or) && defined(AO_HAVE_short_or_acquire) # define AO_short_or(addr, val) AO_short_or_acquire(addr, val) # define AO_HAVE_short_or #endif #if !defined(AO_HAVE_short_or) && defined(AO_HAVE_short_or_write) # define AO_short_or(addr, val) AO_short_or_write(addr, val) # define AO_HAVE_short_or #endif #if !defined(AO_HAVE_short_or) && defined(AO_HAVE_short_or_read) # define AO_short_or(addr, val) AO_short_or_read(addr, val) # define AO_HAVE_short_or #endif #if defined(AO_HAVE_short_or_acquire) && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_short_or_full) # define AO_short_or_full(addr, val) \ (AO_nop_full(), AO_short_or_acquire(addr, val)) # define AO_HAVE_short_or_full #endif #if !defined(AO_HAVE_short_or_release_write) \ && defined(AO_HAVE_short_or_write) # define AO_short_or_release_write(addr, val) AO_short_or_write(addr, val) # define AO_HAVE_short_or_release_write #endif #if !defined(AO_HAVE_short_or_release_write) \ && defined(AO_HAVE_short_or_release) # define AO_short_or_release_write(addr, val) AO_short_or_release(addr, val) # define AO_HAVE_short_or_release_write #endif #if !defined(AO_HAVE_short_or_acquire_read) && defined(AO_HAVE_short_or_read) # define AO_short_or_acquire_read(addr, val) AO_short_or_read(addr, val) # define AO_HAVE_short_or_acquire_read #endif #if !defined(AO_HAVE_short_or_acquire_read) \ && defined(AO_HAVE_short_or_acquire) # define AO_short_or_acquire_read(addr, val) AO_short_or_acquire(addr, val) # define AO_HAVE_short_or_acquire_read #endif /* short_xor */ #if defined(AO_HAVE_short_compare_and_swap_full) \ && !defined(AO_HAVE_short_xor_full) AO_INLINE void AO_short_xor_full(volatile unsigned/**/short *addr, unsigned/**/short value) { unsigned/**/short old; do { old = *(unsigned/**/short *)addr; } while (AO_EXPECT_FALSE(!AO_short_compare_and_swap_full(addr, old, old ^ value))); } # define AO_HAVE_short_xor_full #endif #if defined(AO_HAVE_short_xor_full) # if !defined(AO_HAVE_short_xor_release) # define AO_short_xor_release(addr, val) AO_short_xor_full(addr, val) # define AO_HAVE_short_xor_release # endif # if !defined(AO_HAVE_short_xor_acquire) # define AO_short_xor_acquire(addr, val) AO_short_xor_full(addr, val) # define AO_HAVE_short_xor_acquire # endif # if !defined(AO_HAVE_short_xor_write) # define AO_short_xor_write(addr, val) AO_short_xor_full(addr, val) # define AO_HAVE_short_xor_write # endif # if !defined(AO_HAVE_short_xor_read) # define AO_short_xor_read(addr, val) AO_short_xor_full(addr, val) # define AO_HAVE_short_xor_read # endif #endif /* AO_HAVE_short_xor_full */ #if !defined(AO_HAVE_short_xor) && defined(AO_HAVE_short_xor_release) # define AO_short_xor(addr, val) AO_short_xor_release(addr, val) # define AO_HAVE_short_xor #endif #if !defined(AO_HAVE_short_xor) && defined(AO_HAVE_short_xor_acquire) # define AO_short_xor(addr, val) AO_short_xor_acquire(addr, val) # define AO_HAVE_short_xor #endif #if !defined(AO_HAVE_short_xor) && defined(AO_HAVE_short_xor_write) # define AO_short_xor(addr, val) AO_short_xor_write(addr, val) # define AO_HAVE_short_xor #endif #if !defined(AO_HAVE_short_xor) && defined(AO_HAVE_short_xor_read) # define AO_short_xor(addr, val) AO_short_xor_read(addr, val) # define AO_HAVE_short_xor #endif #if defined(AO_HAVE_short_xor_acquire) && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_short_xor_full) # define AO_short_xor_full(addr, val) \ (AO_nop_full(), AO_short_xor_acquire(addr, val)) # define AO_HAVE_short_xor_full #endif #if !defined(AO_HAVE_short_xor_release_write) \ && defined(AO_HAVE_short_xor_write) # define AO_short_xor_release_write(addr, val) AO_short_xor_write(addr, val) # define AO_HAVE_short_xor_release_write #endif #if !defined(AO_HAVE_short_xor_release_write) \ && defined(AO_HAVE_short_xor_release) # define AO_short_xor_release_write(addr, val) AO_short_xor_release(addr, val) # define AO_HAVE_short_xor_release_write #endif #if !defined(AO_HAVE_short_xor_acquire_read) \ && defined(AO_HAVE_short_xor_read) # define AO_short_xor_acquire_read(addr, val) AO_short_xor_read(addr, val) # define AO_HAVE_short_xor_acquire_read #endif #if !defined(AO_HAVE_short_xor_acquire_read) \ && defined(AO_HAVE_short_xor_acquire) # define AO_short_xor_acquire_read(addr, val) AO_short_xor_acquire(addr, val) # define AO_HAVE_short_xor_acquire_read #endif /* short_and/or/xor_dd_acquire_read are meaningless. */ /* * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ /* int_compare_and_swap (based on fetch_compare_and_swap) */ #if defined(AO_HAVE_int_fetch_compare_and_swap_full) \ && !defined(AO_HAVE_int_compare_and_swap_full) AO_INLINE int AO_int_compare_and_swap_full(volatile unsigned *addr, unsigned old_val, unsigned new_val) { return AO_int_fetch_compare_and_swap_full(addr, old_val, new_val) == old_val; } # define AO_HAVE_int_compare_and_swap_full #endif #if defined(AO_HAVE_int_fetch_compare_and_swap_acquire) \ && !defined(AO_HAVE_int_compare_and_swap_acquire) AO_INLINE int AO_int_compare_and_swap_acquire(volatile unsigned *addr, unsigned old_val, unsigned new_val) { return AO_int_fetch_compare_and_swap_acquire(addr, old_val, new_val) == old_val; } # define AO_HAVE_int_compare_and_swap_acquire #endif #if defined(AO_HAVE_int_fetch_compare_and_swap_release) \ && !defined(AO_HAVE_int_compare_and_swap_release) AO_INLINE int AO_int_compare_and_swap_release(volatile unsigned *addr, unsigned old_val, unsigned new_val) { return AO_int_fetch_compare_and_swap_release(addr, old_val, new_val) == old_val; } # define AO_HAVE_int_compare_and_swap_release #endif #if defined(AO_HAVE_int_fetch_compare_and_swap_write) \ && !defined(AO_HAVE_int_compare_and_swap_write) AO_INLINE int AO_int_compare_and_swap_write(volatile unsigned *addr, unsigned old_val, unsigned new_val) { return AO_int_fetch_compare_and_swap_write(addr, old_val, new_val) == old_val; } # define AO_HAVE_int_compare_and_swap_write #endif #if defined(AO_HAVE_int_fetch_compare_and_swap_read) \ && !defined(AO_HAVE_int_compare_and_swap_read) AO_INLINE int AO_int_compare_and_swap_read(volatile unsigned *addr, unsigned old_val, unsigned new_val) { return AO_int_fetch_compare_and_swap_read(addr, old_val, new_val) == old_val; } # define AO_HAVE_int_compare_and_swap_read #endif #if defined(AO_HAVE_int_fetch_compare_and_swap) \ && !defined(AO_HAVE_int_compare_and_swap) AO_INLINE int AO_int_compare_and_swap(volatile unsigned *addr, unsigned old_val, unsigned new_val) { return AO_int_fetch_compare_and_swap(addr, old_val, new_val) == old_val; } # define AO_HAVE_int_compare_and_swap #endif #if defined(AO_HAVE_int_fetch_compare_and_swap_release_write) \ && !defined(AO_HAVE_int_compare_and_swap_release_write) AO_INLINE int AO_int_compare_and_swap_release_write(volatile unsigned *addr, unsigned old_val, unsigned new_val) { return AO_int_fetch_compare_and_swap_release_write(addr, old_val, new_val) == old_val; } # define AO_HAVE_int_compare_and_swap_release_write #endif #if defined(AO_HAVE_int_fetch_compare_and_swap_acquire_read) \ && !defined(AO_HAVE_int_compare_and_swap_acquire_read) AO_INLINE int AO_int_compare_and_swap_acquire_read(volatile unsigned *addr, unsigned old_val, unsigned new_val) { return AO_int_fetch_compare_and_swap_acquire_read(addr, old_val, new_val) == old_val; } # define AO_HAVE_int_compare_and_swap_acquire_read #endif #if defined(AO_HAVE_int_fetch_compare_and_swap_dd_acquire_read) \ && !defined(AO_HAVE_int_compare_and_swap_dd_acquire_read) AO_INLINE int AO_int_compare_and_swap_dd_acquire_read(volatile unsigned *addr, unsigned old_val, unsigned new_val) { return AO_int_fetch_compare_and_swap_dd_acquire_read(addr, old_val, new_val) == old_val; } # define AO_HAVE_int_compare_and_swap_dd_acquire_read #endif /* int_fetch_and_add */ /* We first try to implement fetch_and_add variants in terms of the */ /* corresponding compare_and_swap variants to minimize adding barriers. */ #if defined(AO_HAVE_int_compare_and_swap_full) \ && !defined(AO_HAVE_int_fetch_and_add_full) AO_INLINE unsigned AO_int_fetch_and_add_full(volatile unsigned *addr, unsigned incr) { unsigned old; do { old = *(unsigned *)addr; } while (AO_EXPECT_FALSE(!AO_int_compare_and_swap_full(addr, old, old + incr))); return old; } # define AO_HAVE_int_fetch_and_add_full #endif #if defined(AO_HAVE_int_compare_and_swap_acquire) \ && !defined(AO_HAVE_int_fetch_and_add_acquire) AO_INLINE unsigned AO_int_fetch_and_add_acquire(volatile unsigned *addr, unsigned incr) { unsigned old; do { old = *(unsigned *)addr; } while (AO_EXPECT_FALSE(!AO_int_compare_and_swap_acquire(addr, old, old + incr))); return old; } # define AO_HAVE_int_fetch_and_add_acquire #endif #if defined(AO_HAVE_int_compare_and_swap_release) \ && !defined(AO_HAVE_int_fetch_and_add_release) AO_INLINE unsigned AO_int_fetch_and_add_release(volatile unsigned *addr, unsigned incr) { unsigned old; do { old = *(unsigned *)addr; } while (AO_EXPECT_FALSE(!AO_int_compare_and_swap_release(addr, old, old + incr))); return old; } # define AO_HAVE_int_fetch_and_add_release #endif #if defined(AO_HAVE_int_compare_and_swap) \ && !defined(AO_HAVE_int_fetch_and_add) AO_INLINE unsigned AO_int_fetch_and_add(volatile unsigned *addr, unsigned incr) { unsigned old; do { old = *(unsigned *)addr; } while (AO_EXPECT_FALSE(!AO_int_compare_and_swap(addr, old, old + incr))); return old; } # define AO_HAVE_int_fetch_and_add #endif #if defined(AO_HAVE_int_fetch_and_add_full) # if !defined(AO_HAVE_int_fetch_and_add_release) # define AO_int_fetch_and_add_release(addr, val) \ AO_int_fetch_and_add_full(addr, val) # define AO_HAVE_int_fetch_and_add_release # endif # if !defined(AO_HAVE_int_fetch_and_add_acquire) # define AO_int_fetch_and_add_acquire(addr, val) \ AO_int_fetch_and_add_full(addr, val) # define AO_HAVE_int_fetch_and_add_acquire # endif # if !defined(AO_HAVE_int_fetch_and_add_write) # define AO_int_fetch_and_add_write(addr, val) \ AO_int_fetch_and_add_full(addr, val) # define AO_HAVE_int_fetch_and_add_write # endif # if !defined(AO_HAVE_int_fetch_and_add_read) # define AO_int_fetch_and_add_read(addr, val) \ AO_int_fetch_and_add_full(addr, val) # define AO_HAVE_int_fetch_and_add_read # endif #endif /* AO_HAVE_int_fetch_and_add_full */ #if defined(AO_HAVE_int_fetch_and_add) && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_int_fetch_and_add_acquire) AO_INLINE unsigned AO_int_fetch_and_add_acquire(volatile unsigned *addr, unsigned incr) { unsigned result = AO_int_fetch_and_add(addr, incr); AO_nop_full(); return result; } # define AO_HAVE_int_fetch_and_add_acquire #endif #if defined(AO_HAVE_int_fetch_and_add) && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_int_fetch_and_add_release) # define AO_int_fetch_and_add_release(addr, incr) \ (AO_nop_full(), AO_int_fetch_and_add(addr, incr)) # define AO_HAVE_int_fetch_and_add_release #endif #if !defined(AO_HAVE_int_fetch_and_add) \ && defined(AO_HAVE_int_fetch_and_add_release) # define AO_int_fetch_and_add(addr, val) \ AO_int_fetch_and_add_release(addr, val) # define AO_HAVE_int_fetch_and_add #endif #if !defined(AO_HAVE_int_fetch_and_add) \ && defined(AO_HAVE_int_fetch_and_add_acquire) # define AO_int_fetch_and_add(addr, val) \ AO_int_fetch_and_add_acquire(addr, val) # define AO_HAVE_int_fetch_and_add #endif #if !defined(AO_HAVE_int_fetch_and_add) \ && defined(AO_HAVE_int_fetch_and_add_write) # define AO_int_fetch_and_add(addr, val) \ AO_int_fetch_and_add_write(addr, val) # define AO_HAVE_int_fetch_and_add #endif #if !defined(AO_HAVE_int_fetch_and_add) \ && defined(AO_HAVE_int_fetch_and_add_read) # define AO_int_fetch_and_add(addr, val) \ AO_int_fetch_and_add_read(addr, val) # define AO_HAVE_int_fetch_and_add #endif #if defined(AO_HAVE_int_fetch_and_add_acquire) \ && defined(AO_HAVE_nop_full) && !defined(AO_HAVE_int_fetch_and_add_full) # define AO_int_fetch_and_add_full(addr, val) \ (AO_nop_full(), AO_int_fetch_and_add_acquire(addr, val)) # define AO_HAVE_int_fetch_and_add_full #endif #if !defined(AO_HAVE_int_fetch_and_add_release_write) \ && defined(AO_HAVE_int_fetch_and_add_write) # define AO_int_fetch_and_add_release_write(addr, val) \ AO_int_fetch_and_add_write(addr, val) # define AO_HAVE_int_fetch_and_add_release_write #endif #if !defined(AO_HAVE_int_fetch_and_add_release_write) \ && defined(AO_HAVE_int_fetch_and_add_release) # define AO_int_fetch_and_add_release_write(addr, val) \ AO_int_fetch_and_add_release(addr, val) # define AO_HAVE_int_fetch_and_add_release_write #endif #if !defined(AO_HAVE_int_fetch_and_add_acquire_read) \ && defined(AO_HAVE_int_fetch_and_add_read) # define AO_int_fetch_and_add_acquire_read(addr, val) \ AO_int_fetch_and_add_read(addr, val) # define AO_HAVE_int_fetch_and_add_acquire_read #endif #if !defined(AO_HAVE_int_fetch_and_add_acquire_read) \ && defined(AO_HAVE_int_fetch_and_add_acquire) # define AO_int_fetch_and_add_acquire_read(addr, val) \ AO_int_fetch_and_add_acquire(addr, val) # define AO_HAVE_int_fetch_and_add_acquire_read #endif #ifdef AO_NO_DD_ORDERING # if defined(AO_HAVE_int_fetch_and_add_acquire_read) # define AO_int_fetch_and_add_dd_acquire_read(addr, val) \ AO_int_fetch_and_add_acquire_read(addr, val) # define AO_HAVE_int_fetch_and_add_dd_acquire_read # endif #else # if defined(AO_HAVE_int_fetch_and_add) # define AO_int_fetch_and_add_dd_acquire_read(addr, val) \ AO_int_fetch_and_add(addr, val) # define AO_HAVE_int_fetch_and_add_dd_acquire_read # endif #endif /* !AO_NO_DD_ORDERING */ /* int_fetch_and_add1 */ #if defined(AO_HAVE_int_fetch_and_add_full) \ && !defined(AO_HAVE_int_fetch_and_add1_full) # define AO_int_fetch_and_add1_full(addr) \ AO_int_fetch_and_add_full(addr, 1) # define AO_HAVE_int_fetch_and_add1_full #endif #if defined(AO_HAVE_int_fetch_and_add_release) \ && !defined(AO_HAVE_int_fetch_and_add1_release) # define AO_int_fetch_and_add1_release(addr) \ AO_int_fetch_and_add_release(addr, 1) # define AO_HAVE_int_fetch_and_add1_release #endif #if defined(AO_HAVE_int_fetch_and_add_acquire) \ && !defined(AO_HAVE_int_fetch_and_add1_acquire) # define AO_int_fetch_and_add1_acquire(addr) \ AO_int_fetch_and_add_acquire(addr, 1) # define AO_HAVE_int_fetch_and_add1_acquire #endif #if defined(AO_HAVE_int_fetch_and_add_write) \ && !defined(AO_HAVE_int_fetch_and_add1_write) # define AO_int_fetch_and_add1_write(addr) \ AO_int_fetch_and_add_write(addr, 1) # define AO_HAVE_int_fetch_and_add1_write #endif #if defined(AO_HAVE_int_fetch_and_add_read) \ && !defined(AO_HAVE_int_fetch_and_add1_read) # define AO_int_fetch_and_add1_read(addr) \ AO_int_fetch_and_add_read(addr, 1) # define AO_HAVE_int_fetch_and_add1_read #endif #if defined(AO_HAVE_int_fetch_and_add_release_write) \ && !defined(AO_HAVE_int_fetch_and_add1_release_write) # define AO_int_fetch_and_add1_release_write(addr) \ AO_int_fetch_and_add_release_write(addr, 1) # define AO_HAVE_int_fetch_and_add1_release_write #endif #if defined(AO_HAVE_int_fetch_and_add_acquire_read) \ && !defined(AO_HAVE_int_fetch_and_add1_acquire_read) # define AO_int_fetch_and_add1_acquire_read(addr) \ AO_int_fetch_and_add_acquire_read(addr, 1) # define AO_HAVE_int_fetch_and_add1_acquire_read #endif #if defined(AO_HAVE_int_fetch_and_add) \ && !defined(AO_HAVE_int_fetch_and_add1) # define AO_int_fetch_and_add1(addr) AO_int_fetch_and_add(addr, 1) # define AO_HAVE_int_fetch_and_add1 #endif #if defined(AO_HAVE_int_fetch_and_add1_full) # if !defined(AO_HAVE_int_fetch_and_add1_release) # define AO_int_fetch_and_add1_release(addr) \ AO_int_fetch_and_add1_full(addr) # define AO_HAVE_int_fetch_and_add1_release # endif # if !defined(AO_HAVE_int_fetch_and_add1_acquire) # define AO_int_fetch_and_add1_acquire(addr) \ AO_int_fetch_and_add1_full(addr) # define AO_HAVE_int_fetch_and_add1_acquire # endif # if !defined(AO_HAVE_int_fetch_and_add1_write) # define AO_int_fetch_and_add1_write(addr) \ AO_int_fetch_and_add1_full(addr) # define AO_HAVE_int_fetch_and_add1_write # endif # if !defined(AO_HAVE_int_fetch_and_add1_read) # define AO_int_fetch_and_add1_read(addr) \ AO_int_fetch_and_add1_full(addr) # define AO_HAVE_int_fetch_and_add1_read # endif #endif /* AO_HAVE_int_fetch_and_add1_full */ #if !defined(AO_HAVE_int_fetch_and_add1) \ && defined(AO_HAVE_int_fetch_and_add1_release) # define AO_int_fetch_and_add1(addr) AO_int_fetch_and_add1_release(addr) # define AO_HAVE_int_fetch_and_add1 #endif #if !defined(AO_HAVE_int_fetch_and_add1) \ && defined(AO_HAVE_int_fetch_and_add1_acquire) # define AO_int_fetch_and_add1(addr) AO_int_fetch_and_add1_acquire(addr) # define AO_HAVE_int_fetch_and_add1 #endif #if !defined(AO_HAVE_int_fetch_and_add1) \ && defined(AO_HAVE_int_fetch_and_add1_write) # define AO_int_fetch_and_add1(addr) AO_int_fetch_and_add1_write(addr) # define AO_HAVE_int_fetch_and_add1 #endif #if !defined(AO_HAVE_int_fetch_and_add1) \ && defined(AO_HAVE_int_fetch_and_add1_read) # define AO_int_fetch_and_add1(addr) AO_int_fetch_and_add1_read(addr) # define AO_HAVE_int_fetch_and_add1 #endif #if defined(AO_HAVE_int_fetch_and_add1_acquire) \ && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_int_fetch_and_add1_full) # define AO_int_fetch_and_add1_full(addr) \ (AO_nop_full(), AO_int_fetch_and_add1_acquire(addr)) # define AO_HAVE_int_fetch_and_add1_full #endif #if !defined(AO_HAVE_int_fetch_and_add1_release_write) \ && defined(AO_HAVE_int_fetch_and_add1_write) # define AO_int_fetch_and_add1_release_write(addr) \ AO_int_fetch_and_add1_write(addr) # define AO_HAVE_int_fetch_and_add1_release_write #endif #if !defined(AO_HAVE_int_fetch_and_add1_release_write) \ && defined(AO_HAVE_int_fetch_and_add1_release) # define AO_int_fetch_and_add1_release_write(addr) \ AO_int_fetch_and_add1_release(addr) # define AO_HAVE_int_fetch_and_add1_release_write #endif #if !defined(AO_HAVE_int_fetch_and_add1_acquire_read) \ && defined(AO_HAVE_int_fetch_and_add1_read) # define AO_int_fetch_and_add1_acquire_read(addr) \ AO_int_fetch_and_add1_read(addr) # define AO_HAVE_int_fetch_and_add1_acquire_read #endif #if !defined(AO_HAVE_int_fetch_and_add1_acquire_read) \ && defined(AO_HAVE_int_fetch_and_add1_acquire) # define AO_int_fetch_and_add1_acquire_read(addr) \ AO_int_fetch_and_add1_acquire(addr) # define AO_HAVE_int_fetch_and_add1_acquire_read #endif #ifdef AO_NO_DD_ORDERING # if defined(AO_HAVE_int_fetch_and_add1_acquire_read) # define AO_int_fetch_and_add1_dd_acquire_read(addr) \ AO_int_fetch_and_add1_acquire_read(addr) # define AO_HAVE_int_fetch_and_add1_dd_acquire_read # endif #else # if defined(AO_HAVE_int_fetch_and_add1) # define AO_int_fetch_and_add1_dd_acquire_read(addr) \ AO_int_fetch_and_add1(addr) # define AO_HAVE_int_fetch_and_add1_dd_acquire_read # endif #endif /* !AO_NO_DD_ORDERING */ /* int_fetch_and_sub1 */ #if defined(AO_HAVE_int_fetch_and_add_full) \ && !defined(AO_HAVE_int_fetch_and_sub1_full) # define AO_int_fetch_and_sub1_full(addr) \ AO_int_fetch_and_add_full(addr, (unsigned)(-1)) # define AO_HAVE_int_fetch_and_sub1_full #endif #if defined(AO_HAVE_int_fetch_and_add_release) \ && !defined(AO_HAVE_int_fetch_and_sub1_release) # define AO_int_fetch_and_sub1_release(addr) \ AO_int_fetch_and_add_release(addr, (unsigned)(-1)) # define AO_HAVE_int_fetch_and_sub1_release #endif #if defined(AO_HAVE_int_fetch_and_add_acquire) \ && !defined(AO_HAVE_int_fetch_and_sub1_acquire) # define AO_int_fetch_and_sub1_acquire(addr) \ AO_int_fetch_and_add_acquire(addr, (unsigned)(-1)) # define AO_HAVE_int_fetch_and_sub1_acquire #endif #if defined(AO_HAVE_int_fetch_and_add_write) \ && !defined(AO_HAVE_int_fetch_and_sub1_write) # define AO_int_fetch_and_sub1_write(addr) \ AO_int_fetch_and_add_write(addr, (unsigned)(-1)) # define AO_HAVE_int_fetch_and_sub1_write #endif #if defined(AO_HAVE_int_fetch_and_add_read) \ && !defined(AO_HAVE_int_fetch_and_sub1_read) # define AO_int_fetch_and_sub1_read(addr) \ AO_int_fetch_and_add_read(addr, (unsigned)(-1)) # define AO_HAVE_int_fetch_and_sub1_read #endif #if defined(AO_HAVE_int_fetch_and_add_release_write) \ && !defined(AO_HAVE_int_fetch_and_sub1_release_write) # define AO_int_fetch_and_sub1_release_write(addr) \ AO_int_fetch_and_add_release_write(addr, (unsigned)(-1)) # define AO_HAVE_int_fetch_and_sub1_release_write #endif #if defined(AO_HAVE_int_fetch_and_add_acquire_read) \ && !defined(AO_HAVE_int_fetch_and_sub1_acquire_read) # define AO_int_fetch_and_sub1_acquire_read(addr) \ AO_int_fetch_and_add_acquire_read(addr, (unsigned)(-1)) # define AO_HAVE_int_fetch_and_sub1_acquire_read #endif #if defined(AO_HAVE_int_fetch_and_add) \ && !defined(AO_HAVE_int_fetch_and_sub1) # define AO_int_fetch_and_sub1(addr) \ AO_int_fetch_and_add(addr, (unsigned)(-1)) # define AO_HAVE_int_fetch_and_sub1 #endif #if defined(AO_HAVE_int_fetch_and_sub1_full) # if !defined(AO_HAVE_int_fetch_and_sub1_release) # define AO_int_fetch_and_sub1_release(addr) \ AO_int_fetch_and_sub1_full(addr) # define AO_HAVE_int_fetch_and_sub1_release # endif # if !defined(AO_HAVE_int_fetch_and_sub1_acquire) # define AO_int_fetch_and_sub1_acquire(addr) \ AO_int_fetch_and_sub1_full(addr) # define AO_HAVE_int_fetch_and_sub1_acquire # endif # if !defined(AO_HAVE_int_fetch_and_sub1_write) # define AO_int_fetch_and_sub1_write(addr) \ AO_int_fetch_and_sub1_full(addr) # define AO_HAVE_int_fetch_and_sub1_write # endif # if !defined(AO_HAVE_int_fetch_and_sub1_read) # define AO_int_fetch_and_sub1_read(addr) \ AO_int_fetch_and_sub1_full(addr) # define AO_HAVE_int_fetch_and_sub1_read # endif #endif /* AO_HAVE_int_fetch_and_sub1_full */ #if !defined(AO_HAVE_int_fetch_and_sub1) \ && defined(AO_HAVE_int_fetch_and_sub1_release) # define AO_int_fetch_and_sub1(addr) AO_int_fetch_and_sub1_release(addr) # define AO_HAVE_int_fetch_and_sub1 #endif #if !defined(AO_HAVE_int_fetch_and_sub1) \ && defined(AO_HAVE_int_fetch_and_sub1_acquire) # define AO_int_fetch_and_sub1(addr) AO_int_fetch_and_sub1_acquire(addr) # define AO_HAVE_int_fetch_and_sub1 #endif #if !defined(AO_HAVE_int_fetch_and_sub1) \ && defined(AO_HAVE_int_fetch_and_sub1_write) # define AO_int_fetch_and_sub1(addr) AO_int_fetch_and_sub1_write(addr) # define AO_HAVE_int_fetch_and_sub1 #endif #if !defined(AO_HAVE_int_fetch_and_sub1) \ && defined(AO_HAVE_int_fetch_and_sub1_read) # define AO_int_fetch_and_sub1(addr) AO_int_fetch_and_sub1_read(addr) # define AO_HAVE_int_fetch_and_sub1 #endif #if defined(AO_HAVE_int_fetch_and_sub1_acquire) \ && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_int_fetch_and_sub1_full) # define AO_int_fetch_and_sub1_full(addr) \ (AO_nop_full(), AO_int_fetch_and_sub1_acquire(addr)) # define AO_HAVE_int_fetch_and_sub1_full #endif #if !defined(AO_HAVE_int_fetch_and_sub1_release_write) \ && defined(AO_HAVE_int_fetch_and_sub1_write) # define AO_int_fetch_and_sub1_release_write(addr) \ AO_int_fetch_and_sub1_write(addr) # define AO_HAVE_int_fetch_and_sub1_release_write #endif #if !defined(AO_HAVE_int_fetch_and_sub1_release_write) \ && defined(AO_HAVE_int_fetch_and_sub1_release) # define AO_int_fetch_and_sub1_release_write(addr) \ AO_int_fetch_and_sub1_release(addr) # define AO_HAVE_int_fetch_and_sub1_release_write #endif #if !defined(AO_HAVE_int_fetch_and_sub1_acquire_read) \ && defined(AO_HAVE_int_fetch_and_sub1_read) # define AO_int_fetch_and_sub1_acquire_read(addr) \ AO_int_fetch_and_sub1_read(addr) # define AO_HAVE_int_fetch_and_sub1_acquire_read #endif #if !defined(AO_HAVE_int_fetch_and_sub1_acquire_read) \ && defined(AO_HAVE_int_fetch_and_sub1_acquire) # define AO_int_fetch_and_sub1_acquire_read(addr) \ AO_int_fetch_and_sub1_acquire(addr) # define AO_HAVE_int_fetch_and_sub1_acquire_read #endif #ifdef AO_NO_DD_ORDERING # if defined(AO_HAVE_int_fetch_and_sub1_acquire_read) # define AO_int_fetch_and_sub1_dd_acquire_read(addr) \ AO_int_fetch_and_sub1_acquire_read(addr) # define AO_HAVE_int_fetch_and_sub1_dd_acquire_read # endif #else # if defined(AO_HAVE_int_fetch_and_sub1) # define AO_int_fetch_and_sub1_dd_acquire_read(addr) \ AO_int_fetch_and_sub1(addr) # define AO_HAVE_int_fetch_and_sub1_dd_acquire_read # endif #endif /* !AO_NO_DD_ORDERING */ /* int_and */ #if defined(AO_HAVE_int_compare_and_swap_full) \ && !defined(AO_HAVE_int_and_full) AO_INLINE void AO_int_and_full(volatile unsigned *addr, unsigned value) { unsigned old; do { old = *(unsigned *)addr; } while (AO_EXPECT_FALSE(!AO_int_compare_and_swap_full(addr, old, old & value))); } # define AO_HAVE_int_and_full #endif #if defined(AO_HAVE_int_and_full) # if !defined(AO_HAVE_int_and_release) # define AO_int_and_release(addr, val) AO_int_and_full(addr, val) # define AO_HAVE_int_and_release # endif # if !defined(AO_HAVE_int_and_acquire) # define AO_int_and_acquire(addr, val) AO_int_and_full(addr, val) # define AO_HAVE_int_and_acquire # endif # if !defined(AO_HAVE_int_and_write) # define AO_int_and_write(addr, val) AO_int_and_full(addr, val) # define AO_HAVE_int_and_write # endif # if !defined(AO_HAVE_int_and_read) # define AO_int_and_read(addr, val) AO_int_and_full(addr, val) # define AO_HAVE_int_and_read # endif #endif /* AO_HAVE_int_and_full */ #if !defined(AO_HAVE_int_and) && defined(AO_HAVE_int_and_release) # define AO_int_and(addr, val) AO_int_and_release(addr, val) # define AO_HAVE_int_and #endif #if !defined(AO_HAVE_int_and) && defined(AO_HAVE_int_and_acquire) # define AO_int_and(addr, val) AO_int_and_acquire(addr, val) # define AO_HAVE_int_and #endif #if !defined(AO_HAVE_int_and) && defined(AO_HAVE_int_and_write) # define AO_int_and(addr, val) AO_int_and_write(addr, val) # define AO_HAVE_int_and #endif #if !defined(AO_HAVE_int_and) && defined(AO_HAVE_int_and_read) # define AO_int_and(addr, val) AO_int_and_read(addr, val) # define AO_HAVE_int_and #endif #if defined(AO_HAVE_int_and_acquire) && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_int_and_full) # define AO_int_and_full(addr, val) \ (AO_nop_full(), AO_int_and_acquire(addr, val)) # define AO_HAVE_int_and_full #endif #if !defined(AO_HAVE_int_and_release_write) \ && defined(AO_HAVE_int_and_write) # define AO_int_and_release_write(addr, val) AO_int_and_write(addr, val) # define AO_HAVE_int_and_release_write #endif #if !defined(AO_HAVE_int_and_release_write) \ && defined(AO_HAVE_int_and_release) # define AO_int_and_release_write(addr, val) AO_int_and_release(addr, val) # define AO_HAVE_int_and_release_write #endif #if !defined(AO_HAVE_int_and_acquire_read) \ && defined(AO_HAVE_int_and_read) # define AO_int_and_acquire_read(addr, val) AO_int_and_read(addr, val) # define AO_HAVE_int_and_acquire_read #endif #if !defined(AO_HAVE_int_and_acquire_read) \ && defined(AO_HAVE_int_and_acquire) # define AO_int_and_acquire_read(addr, val) AO_int_and_acquire(addr, val) # define AO_HAVE_int_and_acquire_read #endif /* int_or */ #if defined(AO_HAVE_int_compare_and_swap_full) \ && !defined(AO_HAVE_int_or_full) AO_INLINE void AO_int_or_full(volatile unsigned *addr, unsigned value) { unsigned old; do { old = *(unsigned *)addr; } while (AO_EXPECT_FALSE(!AO_int_compare_and_swap_full(addr, old, old | value))); } # define AO_HAVE_int_or_full #endif #if defined(AO_HAVE_int_or_full) # if !defined(AO_HAVE_int_or_release) # define AO_int_or_release(addr, val) AO_int_or_full(addr, val) # define AO_HAVE_int_or_release # endif # if !defined(AO_HAVE_int_or_acquire) # define AO_int_or_acquire(addr, val) AO_int_or_full(addr, val) # define AO_HAVE_int_or_acquire # endif # if !defined(AO_HAVE_int_or_write) # define AO_int_or_write(addr, val) AO_int_or_full(addr, val) # define AO_HAVE_int_or_write # endif # if !defined(AO_HAVE_int_or_read) # define AO_int_or_read(addr, val) AO_int_or_full(addr, val) # define AO_HAVE_int_or_read # endif #endif /* AO_HAVE_int_or_full */ #if !defined(AO_HAVE_int_or) && defined(AO_HAVE_int_or_release) # define AO_int_or(addr, val) AO_int_or_release(addr, val) # define AO_HAVE_int_or #endif #if !defined(AO_HAVE_int_or) && defined(AO_HAVE_int_or_acquire) # define AO_int_or(addr, val) AO_int_or_acquire(addr, val) # define AO_HAVE_int_or #endif #if !defined(AO_HAVE_int_or) && defined(AO_HAVE_int_or_write) # define AO_int_or(addr, val) AO_int_or_write(addr, val) # define AO_HAVE_int_or #endif #if !defined(AO_HAVE_int_or) && defined(AO_HAVE_int_or_read) # define AO_int_or(addr, val) AO_int_or_read(addr, val) # define AO_HAVE_int_or #endif #if defined(AO_HAVE_int_or_acquire) && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_int_or_full) # define AO_int_or_full(addr, val) \ (AO_nop_full(), AO_int_or_acquire(addr, val)) # define AO_HAVE_int_or_full #endif #if !defined(AO_HAVE_int_or_release_write) \ && defined(AO_HAVE_int_or_write) # define AO_int_or_release_write(addr, val) AO_int_or_write(addr, val) # define AO_HAVE_int_or_release_write #endif #if !defined(AO_HAVE_int_or_release_write) \ && defined(AO_HAVE_int_or_release) # define AO_int_or_release_write(addr, val) AO_int_or_release(addr, val) # define AO_HAVE_int_or_release_write #endif #if !defined(AO_HAVE_int_or_acquire_read) && defined(AO_HAVE_int_or_read) # define AO_int_or_acquire_read(addr, val) AO_int_or_read(addr, val) # define AO_HAVE_int_or_acquire_read #endif #if !defined(AO_HAVE_int_or_acquire_read) \ && defined(AO_HAVE_int_or_acquire) # define AO_int_or_acquire_read(addr, val) AO_int_or_acquire(addr, val) # define AO_HAVE_int_or_acquire_read #endif /* int_xor */ #if defined(AO_HAVE_int_compare_and_swap_full) \ && !defined(AO_HAVE_int_xor_full) AO_INLINE void AO_int_xor_full(volatile unsigned *addr, unsigned value) { unsigned old; do { old = *(unsigned *)addr; } while (AO_EXPECT_FALSE(!AO_int_compare_and_swap_full(addr, old, old ^ value))); } # define AO_HAVE_int_xor_full #endif #if defined(AO_HAVE_int_xor_full) # if !defined(AO_HAVE_int_xor_release) # define AO_int_xor_release(addr, val) AO_int_xor_full(addr, val) # define AO_HAVE_int_xor_release # endif # if !defined(AO_HAVE_int_xor_acquire) # define AO_int_xor_acquire(addr, val) AO_int_xor_full(addr, val) # define AO_HAVE_int_xor_acquire # endif # if !defined(AO_HAVE_int_xor_write) # define AO_int_xor_write(addr, val) AO_int_xor_full(addr, val) # define AO_HAVE_int_xor_write # endif # if !defined(AO_HAVE_int_xor_read) # define AO_int_xor_read(addr, val) AO_int_xor_full(addr, val) # define AO_HAVE_int_xor_read # endif #endif /* AO_HAVE_int_xor_full */ #if !defined(AO_HAVE_int_xor) && defined(AO_HAVE_int_xor_release) # define AO_int_xor(addr, val) AO_int_xor_release(addr, val) # define AO_HAVE_int_xor #endif #if !defined(AO_HAVE_int_xor) && defined(AO_HAVE_int_xor_acquire) # define AO_int_xor(addr, val) AO_int_xor_acquire(addr, val) # define AO_HAVE_int_xor #endif #if !defined(AO_HAVE_int_xor) && defined(AO_HAVE_int_xor_write) # define AO_int_xor(addr, val) AO_int_xor_write(addr, val) # define AO_HAVE_int_xor #endif #if !defined(AO_HAVE_int_xor) && defined(AO_HAVE_int_xor_read) # define AO_int_xor(addr, val) AO_int_xor_read(addr, val) # define AO_HAVE_int_xor #endif #if defined(AO_HAVE_int_xor_acquire) && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_int_xor_full) # define AO_int_xor_full(addr, val) \ (AO_nop_full(), AO_int_xor_acquire(addr, val)) # define AO_HAVE_int_xor_full #endif #if !defined(AO_HAVE_int_xor_release_write) \ && defined(AO_HAVE_int_xor_write) # define AO_int_xor_release_write(addr, val) AO_int_xor_write(addr, val) # define AO_HAVE_int_xor_release_write #endif #if !defined(AO_HAVE_int_xor_release_write) \ && defined(AO_HAVE_int_xor_release) # define AO_int_xor_release_write(addr, val) AO_int_xor_release(addr, val) # define AO_HAVE_int_xor_release_write #endif #if !defined(AO_HAVE_int_xor_acquire_read) \ && defined(AO_HAVE_int_xor_read) # define AO_int_xor_acquire_read(addr, val) AO_int_xor_read(addr, val) # define AO_HAVE_int_xor_acquire_read #endif #if !defined(AO_HAVE_int_xor_acquire_read) \ && defined(AO_HAVE_int_xor_acquire) # define AO_int_xor_acquire_read(addr, val) AO_int_xor_acquire(addr, val) # define AO_HAVE_int_xor_acquire_read #endif /* int_and/or/xor_dd_acquire_read are meaningless. */ /* * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ /* compare_and_swap (based on fetch_compare_and_swap) */ #if defined(AO_HAVE_fetch_compare_and_swap_full) \ && !defined(AO_HAVE_compare_and_swap_full) AO_INLINE int AO_compare_and_swap_full(volatile AO_t *addr, AO_t old_val, AO_t new_val) { return AO_fetch_compare_and_swap_full(addr, old_val, new_val) == old_val; } # define AO_HAVE_compare_and_swap_full #endif #if defined(AO_HAVE_fetch_compare_and_swap_acquire) \ && !defined(AO_HAVE_compare_and_swap_acquire) AO_INLINE int AO_compare_and_swap_acquire(volatile AO_t *addr, AO_t old_val, AO_t new_val) { return AO_fetch_compare_and_swap_acquire(addr, old_val, new_val) == old_val; } # define AO_HAVE_compare_and_swap_acquire #endif #if defined(AO_HAVE_fetch_compare_and_swap_release) \ && !defined(AO_HAVE_compare_and_swap_release) AO_INLINE int AO_compare_and_swap_release(volatile AO_t *addr, AO_t old_val, AO_t new_val) { return AO_fetch_compare_and_swap_release(addr, old_val, new_val) == old_val; } # define AO_HAVE_compare_and_swap_release #endif #if defined(AO_HAVE_fetch_compare_and_swap_write) \ && !defined(AO_HAVE_compare_and_swap_write) AO_INLINE int AO_compare_and_swap_write(volatile AO_t *addr, AO_t old_val, AO_t new_val) { return AO_fetch_compare_and_swap_write(addr, old_val, new_val) == old_val; } # define AO_HAVE_compare_and_swap_write #endif #if defined(AO_HAVE_fetch_compare_and_swap_read) \ && !defined(AO_HAVE_compare_and_swap_read) AO_INLINE int AO_compare_and_swap_read(volatile AO_t *addr, AO_t old_val, AO_t new_val) { return AO_fetch_compare_and_swap_read(addr, old_val, new_val) == old_val; } # define AO_HAVE_compare_and_swap_read #endif #if defined(AO_HAVE_fetch_compare_and_swap) \ && !defined(AO_HAVE_compare_and_swap) AO_INLINE int AO_compare_and_swap(volatile AO_t *addr, AO_t old_val, AO_t new_val) { return AO_fetch_compare_and_swap(addr, old_val, new_val) == old_val; } # define AO_HAVE_compare_and_swap #endif #if defined(AO_HAVE_fetch_compare_and_swap_release_write) \ && !defined(AO_HAVE_compare_and_swap_release_write) AO_INLINE int AO_compare_and_swap_release_write(volatile AO_t *addr, AO_t old_val, AO_t new_val) { return AO_fetch_compare_and_swap_release_write(addr, old_val, new_val) == old_val; } # define AO_HAVE_compare_and_swap_release_write #endif #if defined(AO_HAVE_fetch_compare_and_swap_acquire_read) \ && !defined(AO_HAVE_compare_and_swap_acquire_read) AO_INLINE int AO_compare_and_swap_acquire_read(volatile AO_t *addr, AO_t old_val, AO_t new_val) { return AO_fetch_compare_and_swap_acquire_read(addr, old_val, new_val) == old_val; } # define AO_HAVE_compare_and_swap_acquire_read #endif #if defined(AO_HAVE_fetch_compare_and_swap_dd_acquire_read) \ && !defined(AO_HAVE_compare_and_swap_dd_acquire_read) AO_INLINE int AO_compare_and_swap_dd_acquire_read(volatile AO_t *addr, AO_t old_val, AO_t new_val) { return AO_fetch_compare_and_swap_dd_acquire_read(addr, old_val, new_val) == old_val; } # define AO_HAVE_compare_and_swap_dd_acquire_read #endif /* fetch_and_add */ /* We first try to implement fetch_and_add variants in terms of the */ /* corresponding compare_and_swap variants to minimize adding barriers. */ #if defined(AO_HAVE_compare_and_swap_full) \ && !defined(AO_HAVE_fetch_and_add_full) AO_INLINE AO_t AO_fetch_and_add_full(volatile AO_t *addr, AO_t incr) { AO_t old; do { old = *(AO_t *)addr; } while (AO_EXPECT_FALSE(!AO_compare_and_swap_full(addr, old, old + incr))); return old; } # define AO_HAVE_fetch_and_add_full #endif #if defined(AO_HAVE_compare_and_swap_acquire) \ && !defined(AO_HAVE_fetch_and_add_acquire) AO_INLINE AO_t AO_fetch_and_add_acquire(volatile AO_t *addr, AO_t incr) { AO_t old; do { old = *(AO_t *)addr; } while (AO_EXPECT_FALSE(!AO_compare_and_swap_acquire(addr, old, old + incr))); return old; } # define AO_HAVE_fetch_and_add_acquire #endif #if defined(AO_HAVE_compare_and_swap_release) \ && !defined(AO_HAVE_fetch_and_add_release) AO_INLINE AO_t AO_fetch_and_add_release(volatile AO_t *addr, AO_t incr) { AO_t old; do { old = *(AO_t *)addr; } while (AO_EXPECT_FALSE(!AO_compare_and_swap_release(addr, old, old + incr))); return old; } # define AO_HAVE_fetch_and_add_release #endif #if defined(AO_HAVE_compare_and_swap) \ && !defined(AO_HAVE_fetch_and_add) AO_INLINE AO_t AO_fetch_and_add(volatile AO_t *addr, AO_t incr) { AO_t old; do { old = *(AO_t *)addr; } while (AO_EXPECT_FALSE(!AO_compare_and_swap(addr, old, old + incr))); return old; } # define AO_HAVE_fetch_and_add #endif #if defined(AO_HAVE_fetch_and_add_full) # if !defined(AO_HAVE_fetch_and_add_release) # define AO_fetch_and_add_release(addr, val) \ AO_fetch_and_add_full(addr, val) # define AO_HAVE_fetch_and_add_release # endif # if !defined(AO_HAVE_fetch_and_add_acquire) # define AO_fetch_and_add_acquire(addr, val) \ AO_fetch_and_add_full(addr, val) # define AO_HAVE_fetch_and_add_acquire # endif # if !defined(AO_HAVE_fetch_and_add_write) # define AO_fetch_and_add_write(addr, val) \ AO_fetch_and_add_full(addr, val) # define AO_HAVE_fetch_and_add_write # endif # if !defined(AO_HAVE_fetch_and_add_read) # define AO_fetch_and_add_read(addr, val) \ AO_fetch_and_add_full(addr, val) # define AO_HAVE_fetch_and_add_read # endif #endif /* AO_HAVE_fetch_and_add_full */ #if defined(AO_HAVE_fetch_and_add) && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_fetch_and_add_acquire) AO_INLINE AO_t AO_fetch_and_add_acquire(volatile AO_t *addr, AO_t incr) { AO_t result = AO_fetch_and_add(addr, incr); AO_nop_full(); return result; } # define AO_HAVE_fetch_and_add_acquire #endif #if defined(AO_HAVE_fetch_and_add) && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_fetch_and_add_release) # define AO_fetch_and_add_release(addr, incr) \ (AO_nop_full(), AO_fetch_and_add(addr, incr)) # define AO_HAVE_fetch_and_add_release #endif #if !defined(AO_HAVE_fetch_and_add) \ && defined(AO_HAVE_fetch_and_add_release) # define AO_fetch_and_add(addr, val) \ AO_fetch_and_add_release(addr, val) # define AO_HAVE_fetch_and_add #endif #if !defined(AO_HAVE_fetch_and_add) \ && defined(AO_HAVE_fetch_and_add_acquire) # define AO_fetch_and_add(addr, val) \ AO_fetch_and_add_acquire(addr, val) # define AO_HAVE_fetch_and_add #endif #if !defined(AO_HAVE_fetch_and_add) \ && defined(AO_HAVE_fetch_and_add_write) # define AO_fetch_and_add(addr, val) \ AO_fetch_and_add_write(addr, val) # define AO_HAVE_fetch_and_add #endif #if !defined(AO_HAVE_fetch_and_add) \ && defined(AO_HAVE_fetch_and_add_read) # define AO_fetch_and_add(addr, val) \ AO_fetch_and_add_read(addr, val) # define AO_HAVE_fetch_and_add #endif #if defined(AO_HAVE_fetch_and_add_acquire) \ && defined(AO_HAVE_nop_full) && !defined(AO_HAVE_fetch_and_add_full) # define AO_fetch_and_add_full(addr, val) \ (AO_nop_full(), AO_fetch_and_add_acquire(addr, val)) # define AO_HAVE_fetch_and_add_full #endif #if !defined(AO_HAVE_fetch_and_add_release_write) \ && defined(AO_HAVE_fetch_and_add_write) # define AO_fetch_and_add_release_write(addr, val) \ AO_fetch_and_add_write(addr, val) # define AO_HAVE_fetch_and_add_release_write #endif #if !defined(AO_HAVE_fetch_and_add_release_write) \ && defined(AO_HAVE_fetch_and_add_release) # define AO_fetch_and_add_release_write(addr, val) \ AO_fetch_and_add_release(addr, val) # define AO_HAVE_fetch_and_add_release_write #endif #if !defined(AO_HAVE_fetch_and_add_acquire_read) \ && defined(AO_HAVE_fetch_and_add_read) # define AO_fetch_and_add_acquire_read(addr, val) \ AO_fetch_and_add_read(addr, val) # define AO_HAVE_fetch_and_add_acquire_read #endif #if !defined(AO_HAVE_fetch_and_add_acquire_read) \ && defined(AO_HAVE_fetch_and_add_acquire) # define AO_fetch_and_add_acquire_read(addr, val) \ AO_fetch_and_add_acquire(addr, val) # define AO_HAVE_fetch_and_add_acquire_read #endif #ifdef AO_NO_DD_ORDERING # if defined(AO_HAVE_fetch_and_add_acquire_read) # define AO_fetch_and_add_dd_acquire_read(addr, val) \ AO_fetch_and_add_acquire_read(addr, val) # define AO_HAVE_fetch_and_add_dd_acquire_read # endif #else # if defined(AO_HAVE_fetch_and_add) # define AO_fetch_and_add_dd_acquire_read(addr, val) \ AO_fetch_and_add(addr, val) # define AO_HAVE_fetch_and_add_dd_acquire_read # endif #endif /* !AO_NO_DD_ORDERING */ /* fetch_and_add1 */ #if defined(AO_HAVE_fetch_and_add_full) \ && !defined(AO_HAVE_fetch_and_add1_full) # define AO_fetch_and_add1_full(addr) \ AO_fetch_and_add_full(addr, 1) # define AO_HAVE_fetch_and_add1_full #endif #if defined(AO_HAVE_fetch_and_add_release) \ && !defined(AO_HAVE_fetch_and_add1_release) # define AO_fetch_and_add1_release(addr) \ AO_fetch_and_add_release(addr, 1) # define AO_HAVE_fetch_and_add1_release #endif #if defined(AO_HAVE_fetch_and_add_acquire) \ && !defined(AO_HAVE_fetch_and_add1_acquire) # define AO_fetch_and_add1_acquire(addr) \ AO_fetch_and_add_acquire(addr, 1) # define AO_HAVE_fetch_and_add1_acquire #endif #if defined(AO_HAVE_fetch_and_add_write) \ && !defined(AO_HAVE_fetch_and_add1_write) # define AO_fetch_and_add1_write(addr) \ AO_fetch_and_add_write(addr, 1) # define AO_HAVE_fetch_and_add1_write #endif #if defined(AO_HAVE_fetch_and_add_read) \ && !defined(AO_HAVE_fetch_and_add1_read) # define AO_fetch_and_add1_read(addr) \ AO_fetch_and_add_read(addr, 1) # define AO_HAVE_fetch_and_add1_read #endif #if defined(AO_HAVE_fetch_and_add_release_write) \ && !defined(AO_HAVE_fetch_and_add1_release_write) # define AO_fetch_and_add1_release_write(addr) \ AO_fetch_and_add_release_write(addr, 1) # define AO_HAVE_fetch_and_add1_release_write #endif #if defined(AO_HAVE_fetch_and_add_acquire_read) \ && !defined(AO_HAVE_fetch_and_add1_acquire_read) # define AO_fetch_and_add1_acquire_read(addr) \ AO_fetch_and_add_acquire_read(addr, 1) # define AO_HAVE_fetch_and_add1_acquire_read #endif #if defined(AO_HAVE_fetch_and_add) \ && !defined(AO_HAVE_fetch_and_add1) # define AO_fetch_and_add1(addr) AO_fetch_and_add(addr, 1) # define AO_HAVE_fetch_and_add1 #endif #if defined(AO_HAVE_fetch_and_add1_full) # if !defined(AO_HAVE_fetch_and_add1_release) # define AO_fetch_and_add1_release(addr) \ AO_fetch_and_add1_full(addr) # define AO_HAVE_fetch_and_add1_release # endif # if !defined(AO_HAVE_fetch_and_add1_acquire) # define AO_fetch_and_add1_acquire(addr) \ AO_fetch_and_add1_full(addr) # define AO_HAVE_fetch_and_add1_acquire # endif # if !defined(AO_HAVE_fetch_and_add1_write) # define AO_fetch_and_add1_write(addr) \ AO_fetch_and_add1_full(addr) # define AO_HAVE_fetch_and_add1_write # endif # if !defined(AO_HAVE_fetch_and_add1_read) # define AO_fetch_and_add1_read(addr) \ AO_fetch_and_add1_full(addr) # define AO_HAVE_fetch_and_add1_read # endif #endif /* AO_HAVE_fetch_and_add1_full */ #if !defined(AO_HAVE_fetch_and_add1) \ && defined(AO_HAVE_fetch_and_add1_release) # define AO_fetch_and_add1(addr) AO_fetch_and_add1_release(addr) # define AO_HAVE_fetch_and_add1 #endif #if !defined(AO_HAVE_fetch_and_add1) \ && defined(AO_HAVE_fetch_and_add1_acquire) # define AO_fetch_and_add1(addr) AO_fetch_and_add1_acquire(addr) # define AO_HAVE_fetch_and_add1 #endif #if !defined(AO_HAVE_fetch_and_add1) \ && defined(AO_HAVE_fetch_and_add1_write) # define AO_fetch_and_add1(addr) AO_fetch_and_add1_write(addr) # define AO_HAVE_fetch_and_add1 #endif #if !defined(AO_HAVE_fetch_and_add1) \ && defined(AO_HAVE_fetch_and_add1_read) # define AO_fetch_and_add1(addr) AO_fetch_and_add1_read(addr) # define AO_HAVE_fetch_and_add1 #endif #if defined(AO_HAVE_fetch_and_add1_acquire) \ && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_fetch_and_add1_full) # define AO_fetch_and_add1_full(addr) \ (AO_nop_full(), AO_fetch_and_add1_acquire(addr)) # define AO_HAVE_fetch_and_add1_full #endif #if !defined(AO_HAVE_fetch_and_add1_release_write) \ && defined(AO_HAVE_fetch_and_add1_write) # define AO_fetch_and_add1_release_write(addr) \ AO_fetch_and_add1_write(addr) # define AO_HAVE_fetch_and_add1_release_write #endif #if !defined(AO_HAVE_fetch_and_add1_release_write) \ && defined(AO_HAVE_fetch_and_add1_release) # define AO_fetch_and_add1_release_write(addr) \ AO_fetch_and_add1_release(addr) # define AO_HAVE_fetch_and_add1_release_write #endif #if !defined(AO_HAVE_fetch_and_add1_acquire_read) \ && defined(AO_HAVE_fetch_and_add1_read) # define AO_fetch_and_add1_acquire_read(addr) \ AO_fetch_and_add1_read(addr) # define AO_HAVE_fetch_and_add1_acquire_read #endif #if !defined(AO_HAVE_fetch_and_add1_acquire_read) \ && defined(AO_HAVE_fetch_and_add1_acquire) # define AO_fetch_and_add1_acquire_read(addr) \ AO_fetch_and_add1_acquire(addr) # define AO_HAVE_fetch_and_add1_acquire_read #endif #ifdef AO_NO_DD_ORDERING # if defined(AO_HAVE_fetch_and_add1_acquire_read) # define AO_fetch_and_add1_dd_acquire_read(addr) \ AO_fetch_and_add1_acquire_read(addr) # define AO_HAVE_fetch_and_add1_dd_acquire_read # endif #else # if defined(AO_HAVE_fetch_and_add1) # define AO_fetch_and_add1_dd_acquire_read(addr) \ AO_fetch_and_add1(addr) # define AO_HAVE_fetch_and_add1_dd_acquire_read # endif #endif /* !AO_NO_DD_ORDERING */ /* fetch_and_sub1 */ #if defined(AO_HAVE_fetch_and_add_full) \ && !defined(AO_HAVE_fetch_and_sub1_full) # define AO_fetch_and_sub1_full(addr) \ AO_fetch_and_add_full(addr, (AO_t)(-1)) # define AO_HAVE_fetch_and_sub1_full #endif #if defined(AO_HAVE_fetch_and_add_release) \ && !defined(AO_HAVE_fetch_and_sub1_release) # define AO_fetch_and_sub1_release(addr) \ AO_fetch_and_add_release(addr, (AO_t)(-1)) # define AO_HAVE_fetch_and_sub1_release #endif #if defined(AO_HAVE_fetch_and_add_acquire) \ && !defined(AO_HAVE_fetch_and_sub1_acquire) # define AO_fetch_and_sub1_acquire(addr) \ AO_fetch_and_add_acquire(addr, (AO_t)(-1)) # define AO_HAVE_fetch_and_sub1_acquire #endif #if defined(AO_HAVE_fetch_and_add_write) \ && !defined(AO_HAVE_fetch_and_sub1_write) # define AO_fetch_and_sub1_write(addr) \ AO_fetch_and_add_write(addr, (AO_t)(-1)) # define AO_HAVE_fetch_and_sub1_write #endif #if defined(AO_HAVE_fetch_and_add_read) \ && !defined(AO_HAVE_fetch_and_sub1_read) # define AO_fetch_and_sub1_read(addr) \ AO_fetch_and_add_read(addr, (AO_t)(-1)) # define AO_HAVE_fetch_and_sub1_read #endif #if defined(AO_HAVE_fetch_and_add_release_write) \ && !defined(AO_HAVE_fetch_and_sub1_release_write) # define AO_fetch_and_sub1_release_write(addr) \ AO_fetch_and_add_release_write(addr, (AO_t)(-1)) # define AO_HAVE_fetch_and_sub1_release_write #endif #if defined(AO_HAVE_fetch_and_add_acquire_read) \ && !defined(AO_HAVE_fetch_and_sub1_acquire_read) # define AO_fetch_and_sub1_acquire_read(addr) \ AO_fetch_and_add_acquire_read(addr, (AO_t)(-1)) # define AO_HAVE_fetch_and_sub1_acquire_read #endif #if defined(AO_HAVE_fetch_and_add) \ && !defined(AO_HAVE_fetch_and_sub1) # define AO_fetch_and_sub1(addr) \ AO_fetch_and_add(addr, (AO_t)(-1)) # define AO_HAVE_fetch_and_sub1 #endif #if defined(AO_HAVE_fetch_and_sub1_full) # if !defined(AO_HAVE_fetch_and_sub1_release) # define AO_fetch_and_sub1_release(addr) \ AO_fetch_and_sub1_full(addr) # define AO_HAVE_fetch_and_sub1_release # endif # if !defined(AO_HAVE_fetch_and_sub1_acquire) # define AO_fetch_and_sub1_acquire(addr) \ AO_fetch_and_sub1_full(addr) # define AO_HAVE_fetch_and_sub1_acquire # endif # if !defined(AO_HAVE_fetch_and_sub1_write) # define AO_fetch_and_sub1_write(addr) \ AO_fetch_and_sub1_full(addr) # define AO_HAVE_fetch_and_sub1_write # endif # if !defined(AO_HAVE_fetch_and_sub1_read) # define AO_fetch_and_sub1_read(addr) \ AO_fetch_and_sub1_full(addr) # define AO_HAVE_fetch_and_sub1_read # endif #endif /* AO_HAVE_fetch_and_sub1_full */ #if !defined(AO_HAVE_fetch_and_sub1) \ && defined(AO_HAVE_fetch_and_sub1_release) # define AO_fetch_and_sub1(addr) AO_fetch_and_sub1_release(addr) # define AO_HAVE_fetch_and_sub1 #endif #if !defined(AO_HAVE_fetch_and_sub1) \ && defined(AO_HAVE_fetch_and_sub1_acquire) # define AO_fetch_and_sub1(addr) AO_fetch_and_sub1_acquire(addr) # define AO_HAVE_fetch_and_sub1 #endif #if !defined(AO_HAVE_fetch_and_sub1) \ && defined(AO_HAVE_fetch_and_sub1_write) # define AO_fetch_and_sub1(addr) AO_fetch_and_sub1_write(addr) # define AO_HAVE_fetch_and_sub1 #endif #if !defined(AO_HAVE_fetch_and_sub1) \ && defined(AO_HAVE_fetch_and_sub1_read) # define AO_fetch_and_sub1(addr) AO_fetch_and_sub1_read(addr) # define AO_HAVE_fetch_and_sub1 #endif #if defined(AO_HAVE_fetch_and_sub1_acquire) \ && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_fetch_and_sub1_full) # define AO_fetch_and_sub1_full(addr) \ (AO_nop_full(), AO_fetch_and_sub1_acquire(addr)) # define AO_HAVE_fetch_and_sub1_full #endif #if !defined(AO_HAVE_fetch_and_sub1_release_write) \ && defined(AO_HAVE_fetch_and_sub1_write) # define AO_fetch_and_sub1_release_write(addr) \ AO_fetch_and_sub1_write(addr) # define AO_HAVE_fetch_and_sub1_release_write #endif #if !defined(AO_HAVE_fetch_and_sub1_release_write) \ && defined(AO_HAVE_fetch_and_sub1_release) # define AO_fetch_and_sub1_release_write(addr) \ AO_fetch_and_sub1_release(addr) # define AO_HAVE_fetch_and_sub1_release_write #endif #if !defined(AO_HAVE_fetch_and_sub1_acquire_read) \ && defined(AO_HAVE_fetch_and_sub1_read) # define AO_fetch_and_sub1_acquire_read(addr) \ AO_fetch_and_sub1_read(addr) # define AO_HAVE_fetch_and_sub1_acquire_read #endif #if !defined(AO_HAVE_fetch_and_sub1_acquire_read) \ && defined(AO_HAVE_fetch_and_sub1_acquire) # define AO_fetch_and_sub1_acquire_read(addr) \ AO_fetch_and_sub1_acquire(addr) # define AO_HAVE_fetch_and_sub1_acquire_read #endif #ifdef AO_NO_DD_ORDERING # if defined(AO_HAVE_fetch_and_sub1_acquire_read) # define AO_fetch_and_sub1_dd_acquire_read(addr) \ AO_fetch_and_sub1_acquire_read(addr) # define AO_HAVE_fetch_and_sub1_dd_acquire_read # endif #else # if defined(AO_HAVE_fetch_and_sub1) # define AO_fetch_and_sub1_dd_acquire_read(addr) \ AO_fetch_and_sub1(addr) # define AO_HAVE_fetch_and_sub1_dd_acquire_read # endif #endif /* !AO_NO_DD_ORDERING */ /* and */ #if defined(AO_HAVE_compare_and_swap_full) \ && !defined(AO_HAVE_and_full) AO_INLINE void AO_and_full(volatile AO_t *addr, AO_t value) { AO_t old; do { old = *(AO_t *)addr; } while (AO_EXPECT_FALSE(!AO_compare_and_swap_full(addr, old, old & value))); } # define AO_HAVE_and_full #endif #if defined(AO_HAVE_and_full) # if !defined(AO_HAVE_and_release) # define AO_and_release(addr, val) AO_and_full(addr, val) # define AO_HAVE_and_release # endif # if !defined(AO_HAVE_and_acquire) # define AO_and_acquire(addr, val) AO_and_full(addr, val) # define AO_HAVE_and_acquire # endif # if !defined(AO_HAVE_and_write) # define AO_and_write(addr, val) AO_and_full(addr, val) # define AO_HAVE_and_write # endif # if !defined(AO_HAVE_and_read) # define AO_and_read(addr, val) AO_and_full(addr, val) # define AO_HAVE_and_read # endif #endif /* AO_HAVE_and_full */ #if !defined(AO_HAVE_and) && defined(AO_HAVE_and_release) # define AO_and(addr, val) AO_and_release(addr, val) # define AO_HAVE_and #endif #if !defined(AO_HAVE_and) && defined(AO_HAVE_and_acquire) # define AO_and(addr, val) AO_and_acquire(addr, val) # define AO_HAVE_and #endif #if !defined(AO_HAVE_and) && defined(AO_HAVE_and_write) # define AO_and(addr, val) AO_and_write(addr, val) # define AO_HAVE_and #endif #if !defined(AO_HAVE_and) && defined(AO_HAVE_and_read) # define AO_and(addr, val) AO_and_read(addr, val) # define AO_HAVE_and #endif #if defined(AO_HAVE_and_acquire) && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_and_full) # define AO_and_full(addr, val) \ (AO_nop_full(), AO_and_acquire(addr, val)) # define AO_HAVE_and_full #endif #if !defined(AO_HAVE_and_release_write) \ && defined(AO_HAVE_and_write) # define AO_and_release_write(addr, val) AO_and_write(addr, val) # define AO_HAVE_and_release_write #endif #if !defined(AO_HAVE_and_release_write) \ && defined(AO_HAVE_and_release) # define AO_and_release_write(addr, val) AO_and_release(addr, val) # define AO_HAVE_and_release_write #endif #if !defined(AO_HAVE_and_acquire_read) \ && defined(AO_HAVE_and_read) # define AO_and_acquire_read(addr, val) AO_and_read(addr, val) # define AO_HAVE_and_acquire_read #endif #if !defined(AO_HAVE_and_acquire_read) \ && defined(AO_HAVE_and_acquire) # define AO_and_acquire_read(addr, val) AO_and_acquire(addr, val) # define AO_HAVE_and_acquire_read #endif /* or */ #if defined(AO_HAVE_compare_and_swap_full) \ && !defined(AO_HAVE_or_full) AO_INLINE void AO_or_full(volatile AO_t *addr, AO_t value) { AO_t old; do { old = *(AO_t *)addr; } while (AO_EXPECT_FALSE(!AO_compare_and_swap_full(addr, old, old | value))); } # define AO_HAVE_or_full #endif #if defined(AO_HAVE_or_full) # if !defined(AO_HAVE_or_release) # define AO_or_release(addr, val) AO_or_full(addr, val) # define AO_HAVE_or_release # endif # if !defined(AO_HAVE_or_acquire) # define AO_or_acquire(addr, val) AO_or_full(addr, val) # define AO_HAVE_or_acquire # endif # if !defined(AO_HAVE_or_write) # define AO_or_write(addr, val) AO_or_full(addr, val) # define AO_HAVE_or_write # endif # if !defined(AO_HAVE_or_read) # define AO_or_read(addr, val) AO_or_full(addr, val) # define AO_HAVE_or_read # endif #endif /* AO_HAVE_or_full */ #if !defined(AO_HAVE_or) && defined(AO_HAVE_or_release) # define AO_or(addr, val) AO_or_release(addr, val) # define AO_HAVE_or #endif #if !defined(AO_HAVE_or) && defined(AO_HAVE_or_acquire) # define AO_or(addr, val) AO_or_acquire(addr, val) # define AO_HAVE_or #endif #if !defined(AO_HAVE_or) && defined(AO_HAVE_or_write) # define AO_or(addr, val) AO_or_write(addr, val) # define AO_HAVE_or #endif #if !defined(AO_HAVE_or) && defined(AO_HAVE_or_read) # define AO_or(addr, val) AO_or_read(addr, val) # define AO_HAVE_or #endif #if defined(AO_HAVE_or_acquire) && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_or_full) # define AO_or_full(addr, val) \ (AO_nop_full(), AO_or_acquire(addr, val)) # define AO_HAVE_or_full #endif #if !defined(AO_HAVE_or_release_write) \ && defined(AO_HAVE_or_write) # define AO_or_release_write(addr, val) AO_or_write(addr, val) # define AO_HAVE_or_release_write #endif #if !defined(AO_HAVE_or_release_write) \ && defined(AO_HAVE_or_release) # define AO_or_release_write(addr, val) AO_or_release(addr, val) # define AO_HAVE_or_release_write #endif #if !defined(AO_HAVE_or_acquire_read) && defined(AO_HAVE_or_read) # define AO_or_acquire_read(addr, val) AO_or_read(addr, val) # define AO_HAVE_or_acquire_read #endif #if !defined(AO_HAVE_or_acquire_read) \ && defined(AO_HAVE_or_acquire) # define AO_or_acquire_read(addr, val) AO_or_acquire(addr, val) # define AO_HAVE_or_acquire_read #endif /* xor */ #if defined(AO_HAVE_compare_and_swap_full) \ && !defined(AO_HAVE_xor_full) AO_INLINE void AO_xor_full(volatile AO_t *addr, AO_t value) { AO_t old; do { old = *(AO_t *)addr; } while (AO_EXPECT_FALSE(!AO_compare_and_swap_full(addr, old, old ^ value))); } # define AO_HAVE_xor_full #endif #if defined(AO_HAVE_xor_full) # if !defined(AO_HAVE_xor_release) # define AO_xor_release(addr, val) AO_xor_full(addr, val) # define AO_HAVE_xor_release # endif # if !defined(AO_HAVE_xor_acquire) # define AO_xor_acquire(addr, val) AO_xor_full(addr, val) # define AO_HAVE_xor_acquire # endif # if !defined(AO_HAVE_xor_write) # define AO_xor_write(addr, val) AO_xor_full(addr, val) # define AO_HAVE_xor_write # endif # if !defined(AO_HAVE_xor_read) # define AO_xor_read(addr, val) AO_xor_full(addr, val) # define AO_HAVE_xor_read # endif #endif /* AO_HAVE_xor_full */ #if !defined(AO_HAVE_xor) && defined(AO_HAVE_xor_release) # define AO_xor(addr, val) AO_xor_release(addr, val) # define AO_HAVE_xor #endif #if !defined(AO_HAVE_xor) && defined(AO_HAVE_xor_acquire) # define AO_xor(addr, val) AO_xor_acquire(addr, val) # define AO_HAVE_xor #endif #if !defined(AO_HAVE_xor) && defined(AO_HAVE_xor_write) # define AO_xor(addr, val) AO_xor_write(addr, val) # define AO_HAVE_xor #endif #if !defined(AO_HAVE_xor) && defined(AO_HAVE_xor_read) # define AO_xor(addr, val) AO_xor_read(addr, val) # define AO_HAVE_xor #endif #if defined(AO_HAVE_xor_acquire) && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_xor_full) # define AO_xor_full(addr, val) \ (AO_nop_full(), AO_xor_acquire(addr, val)) # define AO_HAVE_xor_full #endif #if !defined(AO_HAVE_xor_release_write) \ && defined(AO_HAVE_xor_write) # define AO_xor_release_write(addr, val) AO_xor_write(addr, val) # define AO_HAVE_xor_release_write #endif #if !defined(AO_HAVE_xor_release_write) \ && defined(AO_HAVE_xor_release) # define AO_xor_release_write(addr, val) AO_xor_release(addr, val) # define AO_HAVE_xor_release_write #endif #if !defined(AO_HAVE_xor_acquire_read) \ && defined(AO_HAVE_xor_read) # define AO_xor_acquire_read(addr, val) AO_xor_read(addr, val) # define AO_HAVE_xor_acquire_read #endif #if !defined(AO_HAVE_xor_acquire_read) \ && defined(AO_HAVE_xor_acquire) # define AO_xor_acquire_read(addr, val) AO_xor_acquire(addr, val) # define AO_HAVE_xor_acquire_read #endif /* and/or/xor_dd_acquire_read are meaningless. */ ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/generalize-arithm.template000066400000000000000000001002031266352375300271450ustar00rootroot00000000000000/* * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ /* XSIZE_compare_and_swap (based on fetch_compare_and_swap) */ #if defined(AO_HAVE_XSIZE_fetch_compare_and_swap_full) \ && !defined(AO_HAVE_XSIZE_compare_and_swap_full) AO_INLINE int AO_XSIZE_compare_and_swap_full(volatile XCTYPE *addr, XCTYPE old_val, XCTYPE new_val) { return AO_XSIZE_fetch_compare_and_swap_full(addr, old_val, new_val) == old_val; } # define AO_HAVE_XSIZE_compare_and_swap_full #endif #if defined(AO_HAVE_XSIZE_fetch_compare_and_swap_acquire) \ && !defined(AO_HAVE_XSIZE_compare_and_swap_acquire) AO_INLINE int AO_XSIZE_compare_and_swap_acquire(volatile XCTYPE *addr, XCTYPE old_val, XCTYPE new_val) { return AO_XSIZE_fetch_compare_and_swap_acquire(addr, old_val, new_val) == old_val; } # define AO_HAVE_XSIZE_compare_and_swap_acquire #endif #if defined(AO_HAVE_XSIZE_fetch_compare_and_swap_release) \ && !defined(AO_HAVE_XSIZE_compare_and_swap_release) AO_INLINE int AO_XSIZE_compare_and_swap_release(volatile XCTYPE *addr, XCTYPE old_val, XCTYPE new_val) { return AO_XSIZE_fetch_compare_and_swap_release(addr, old_val, new_val) == old_val; } # define AO_HAVE_XSIZE_compare_and_swap_release #endif #if defined(AO_HAVE_XSIZE_fetch_compare_and_swap_write) \ && !defined(AO_HAVE_XSIZE_compare_and_swap_write) AO_INLINE int AO_XSIZE_compare_and_swap_write(volatile XCTYPE *addr, XCTYPE old_val, XCTYPE new_val) { return AO_XSIZE_fetch_compare_and_swap_write(addr, old_val, new_val) == old_val; } # define AO_HAVE_XSIZE_compare_and_swap_write #endif #if defined(AO_HAVE_XSIZE_fetch_compare_and_swap_read) \ && !defined(AO_HAVE_XSIZE_compare_and_swap_read) AO_INLINE int AO_XSIZE_compare_and_swap_read(volatile XCTYPE *addr, XCTYPE old_val, XCTYPE new_val) { return AO_XSIZE_fetch_compare_and_swap_read(addr, old_val, new_val) == old_val; } # define AO_HAVE_XSIZE_compare_and_swap_read #endif #if defined(AO_HAVE_XSIZE_fetch_compare_and_swap) \ && !defined(AO_HAVE_XSIZE_compare_and_swap) AO_INLINE int AO_XSIZE_compare_and_swap(volatile XCTYPE *addr, XCTYPE old_val, XCTYPE new_val) { return AO_XSIZE_fetch_compare_and_swap(addr, old_val, new_val) == old_val; } # define AO_HAVE_XSIZE_compare_and_swap #endif #if defined(AO_HAVE_XSIZE_fetch_compare_and_swap_release_write) \ && !defined(AO_HAVE_XSIZE_compare_and_swap_release_write) AO_INLINE int AO_XSIZE_compare_and_swap_release_write(volatile XCTYPE *addr, XCTYPE old_val, XCTYPE new_val) { return AO_XSIZE_fetch_compare_and_swap_release_write(addr, old_val, new_val) == old_val; } # define AO_HAVE_XSIZE_compare_and_swap_release_write #endif #if defined(AO_HAVE_XSIZE_fetch_compare_and_swap_acquire_read) \ && !defined(AO_HAVE_XSIZE_compare_and_swap_acquire_read) AO_INLINE int AO_XSIZE_compare_and_swap_acquire_read(volatile XCTYPE *addr, XCTYPE old_val, XCTYPE new_val) { return AO_XSIZE_fetch_compare_and_swap_acquire_read(addr, old_val, new_val) == old_val; } # define AO_HAVE_XSIZE_compare_and_swap_acquire_read #endif #if defined(AO_HAVE_XSIZE_fetch_compare_and_swap_dd_acquire_read) \ && !defined(AO_HAVE_XSIZE_compare_and_swap_dd_acquire_read) AO_INLINE int AO_XSIZE_compare_and_swap_dd_acquire_read(volatile XCTYPE *addr, XCTYPE old_val, XCTYPE new_val) { return AO_XSIZE_fetch_compare_and_swap_dd_acquire_read(addr, old_val, new_val) == old_val; } # define AO_HAVE_XSIZE_compare_and_swap_dd_acquire_read #endif /* XSIZE_fetch_and_add */ /* We first try to implement fetch_and_add variants in terms of the */ /* corresponding compare_and_swap variants to minimize adding barriers. */ #if defined(AO_HAVE_XSIZE_compare_and_swap_full) \ && !defined(AO_HAVE_XSIZE_fetch_and_add_full) AO_INLINE XCTYPE AO_XSIZE_fetch_and_add_full(volatile XCTYPE *addr, XCTYPE incr) { XCTYPE old; do { old = *(XCTYPE *)addr; } while (AO_EXPECT_FALSE(!AO_XSIZE_compare_and_swap_full(addr, old, old + incr))); return old; } # define AO_HAVE_XSIZE_fetch_and_add_full #endif #if defined(AO_HAVE_XSIZE_compare_and_swap_acquire) \ && !defined(AO_HAVE_XSIZE_fetch_and_add_acquire) AO_INLINE XCTYPE AO_XSIZE_fetch_and_add_acquire(volatile XCTYPE *addr, XCTYPE incr) { XCTYPE old; do { old = *(XCTYPE *)addr; } while (AO_EXPECT_FALSE(!AO_XSIZE_compare_and_swap_acquire(addr, old, old + incr))); return old; } # define AO_HAVE_XSIZE_fetch_and_add_acquire #endif #if defined(AO_HAVE_XSIZE_compare_and_swap_release) \ && !defined(AO_HAVE_XSIZE_fetch_and_add_release) AO_INLINE XCTYPE AO_XSIZE_fetch_and_add_release(volatile XCTYPE *addr, XCTYPE incr) { XCTYPE old; do { old = *(XCTYPE *)addr; } while (AO_EXPECT_FALSE(!AO_XSIZE_compare_and_swap_release(addr, old, old + incr))); return old; } # define AO_HAVE_XSIZE_fetch_and_add_release #endif #if defined(AO_HAVE_XSIZE_compare_and_swap) \ && !defined(AO_HAVE_XSIZE_fetch_and_add) AO_INLINE XCTYPE AO_XSIZE_fetch_and_add(volatile XCTYPE *addr, XCTYPE incr) { XCTYPE old; do { old = *(XCTYPE *)addr; } while (AO_EXPECT_FALSE(!AO_XSIZE_compare_and_swap(addr, old, old + incr))); return old; } # define AO_HAVE_XSIZE_fetch_and_add #endif #if defined(AO_HAVE_XSIZE_fetch_and_add_full) # if !defined(AO_HAVE_XSIZE_fetch_and_add_release) # define AO_XSIZE_fetch_and_add_release(addr, val) \ AO_XSIZE_fetch_and_add_full(addr, val) # define AO_HAVE_XSIZE_fetch_and_add_release # endif # if !defined(AO_HAVE_XSIZE_fetch_and_add_acquire) # define AO_XSIZE_fetch_and_add_acquire(addr, val) \ AO_XSIZE_fetch_and_add_full(addr, val) # define AO_HAVE_XSIZE_fetch_and_add_acquire # endif # if !defined(AO_HAVE_XSIZE_fetch_and_add_write) # define AO_XSIZE_fetch_and_add_write(addr, val) \ AO_XSIZE_fetch_and_add_full(addr, val) # define AO_HAVE_XSIZE_fetch_and_add_write # endif # if !defined(AO_HAVE_XSIZE_fetch_and_add_read) # define AO_XSIZE_fetch_and_add_read(addr, val) \ AO_XSIZE_fetch_and_add_full(addr, val) # define AO_HAVE_XSIZE_fetch_and_add_read # endif #endif /* AO_HAVE_XSIZE_fetch_and_add_full */ #if defined(AO_HAVE_XSIZE_fetch_and_add) && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_XSIZE_fetch_and_add_acquire) AO_INLINE XCTYPE AO_XSIZE_fetch_and_add_acquire(volatile XCTYPE *addr, XCTYPE incr) { XCTYPE result = AO_XSIZE_fetch_and_add(addr, incr); AO_nop_full(); return result; } # define AO_HAVE_XSIZE_fetch_and_add_acquire #endif #if defined(AO_HAVE_XSIZE_fetch_and_add) && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_XSIZE_fetch_and_add_release) # define AO_XSIZE_fetch_and_add_release(addr, incr) \ (AO_nop_full(), AO_XSIZE_fetch_and_add(addr, incr)) # define AO_HAVE_XSIZE_fetch_and_add_release #endif #if !defined(AO_HAVE_XSIZE_fetch_and_add) \ && defined(AO_HAVE_XSIZE_fetch_and_add_release) # define AO_XSIZE_fetch_and_add(addr, val) \ AO_XSIZE_fetch_and_add_release(addr, val) # define AO_HAVE_XSIZE_fetch_and_add #endif #if !defined(AO_HAVE_XSIZE_fetch_and_add) \ && defined(AO_HAVE_XSIZE_fetch_and_add_acquire) # define AO_XSIZE_fetch_and_add(addr, val) \ AO_XSIZE_fetch_and_add_acquire(addr, val) # define AO_HAVE_XSIZE_fetch_and_add #endif #if !defined(AO_HAVE_XSIZE_fetch_and_add) \ && defined(AO_HAVE_XSIZE_fetch_and_add_write) # define AO_XSIZE_fetch_and_add(addr, val) \ AO_XSIZE_fetch_and_add_write(addr, val) # define AO_HAVE_XSIZE_fetch_and_add #endif #if !defined(AO_HAVE_XSIZE_fetch_and_add) \ && defined(AO_HAVE_XSIZE_fetch_and_add_read) # define AO_XSIZE_fetch_and_add(addr, val) \ AO_XSIZE_fetch_and_add_read(addr, val) # define AO_HAVE_XSIZE_fetch_and_add #endif #if defined(AO_HAVE_XSIZE_fetch_and_add_acquire) \ && defined(AO_HAVE_nop_full) && !defined(AO_HAVE_XSIZE_fetch_and_add_full) # define AO_XSIZE_fetch_and_add_full(addr, val) \ (AO_nop_full(), AO_XSIZE_fetch_and_add_acquire(addr, val)) # define AO_HAVE_XSIZE_fetch_and_add_full #endif #if !defined(AO_HAVE_XSIZE_fetch_and_add_release_write) \ && defined(AO_HAVE_XSIZE_fetch_and_add_write) # define AO_XSIZE_fetch_and_add_release_write(addr, val) \ AO_XSIZE_fetch_and_add_write(addr, val) # define AO_HAVE_XSIZE_fetch_and_add_release_write #endif #if !defined(AO_HAVE_XSIZE_fetch_and_add_release_write) \ && defined(AO_HAVE_XSIZE_fetch_and_add_release) # define AO_XSIZE_fetch_and_add_release_write(addr, val) \ AO_XSIZE_fetch_and_add_release(addr, val) # define AO_HAVE_XSIZE_fetch_and_add_release_write #endif #if !defined(AO_HAVE_XSIZE_fetch_and_add_acquire_read) \ && defined(AO_HAVE_XSIZE_fetch_and_add_read) # define AO_XSIZE_fetch_and_add_acquire_read(addr, val) \ AO_XSIZE_fetch_and_add_read(addr, val) # define AO_HAVE_XSIZE_fetch_and_add_acquire_read #endif #if !defined(AO_HAVE_XSIZE_fetch_and_add_acquire_read) \ && defined(AO_HAVE_XSIZE_fetch_and_add_acquire) # define AO_XSIZE_fetch_and_add_acquire_read(addr, val) \ AO_XSIZE_fetch_and_add_acquire(addr, val) # define AO_HAVE_XSIZE_fetch_and_add_acquire_read #endif #ifdef AO_NO_DD_ORDERING # if defined(AO_HAVE_XSIZE_fetch_and_add_acquire_read) # define AO_XSIZE_fetch_and_add_dd_acquire_read(addr, val) \ AO_XSIZE_fetch_and_add_acquire_read(addr, val) # define AO_HAVE_XSIZE_fetch_and_add_dd_acquire_read # endif #else # if defined(AO_HAVE_XSIZE_fetch_and_add) # define AO_XSIZE_fetch_and_add_dd_acquire_read(addr, val) \ AO_XSIZE_fetch_and_add(addr, val) # define AO_HAVE_XSIZE_fetch_and_add_dd_acquire_read # endif #endif /* !AO_NO_DD_ORDERING */ /* XSIZE_fetch_and_add1 */ #if defined(AO_HAVE_XSIZE_fetch_and_add_full) \ && !defined(AO_HAVE_XSIZE_fetch_and_add1_full) # define AO_XSIZE_fetch_and_add1_full(addr) \ AO_XSIZE_fetch_and_add_full(addr, 1) # define AO_HAVE_XSIZE_fetch_and_add1_full #endif #if defined(AO_HAVE_XSIZE_fetch_and_add_release) \ && !defined(AO_HAVE_XSIZE_fetch_and_add1_release) # define AO_XSIZE_fetch_and_add1_release(addr) \ AO_XSIZE_fetch_and_add_release(addr, 1) # define AO_HAVE_XSIZE_fetch_and_add1_release #endif #if defined(AO_HAVE_XSIZE_fetch_and_add_acquire) \ && !defined(AO_HAVE_XSIZE_fetch_and_add1_acquire) # define AO_XSIZE_fetch_and_add1_acquire(addr) \ AO_XSIZE_fetch_and_add_acquire(addr, 1) # define AO_HAVE_XSIZE_fetch_and_add1_acquire #endif #if defined(AO_HAVE_XSIZE_fetch_and_add_write) \ && !defined(AO_HAVE_XSIZE_fetch_and_add1_write) # define AO_XSIZE_fetch_and_add1_write(addr) \ AO_XSIZE_fetch_and_add_write(addr, 1) # define AO_HAVE_XSIZE_fetch_and_add1_write #endif #if defined(AO_HAVE_XSIZE_fetch_and_add_read) \ && !defined(AO_HAVE_XSIZE_fetch_and_add1_read) # define AO_XSIZE_fetch_and_add1_read(addr) \ AO_XSIZE_fetch_and_add_read(addr, 1) # define AO_HAVE_XSIZE_fetch_and_add1_read #endif #if defined(AO_HAVE_XSIZE_fetch_and_add_release_write) \ && !defined(AO_HAVE_XSIZE_fetch_and_add1_release_write) # define AO_XSIZE_fetch_and_add1_release_write(addr) \ AO_XSIZE_fetch_and_add_release_write(addr, 1) # define AO_HAVE_XSIZE_fetch_and_add1_release_write #endif #if defined(AO_HAVE_XSIZE_fetch_and_add_acquire_read) \ && !defined(AO_HAVE_XSIZE_fetch_and_add1_acquire_read) # define AO_XSIZE_fetch_and_add1_acquire_read(addr) \ AO_XSIZE_fetch_and_add_acquire_read(addr, 1) # define AO_HAVE_XSIZE_fetch_and_add1_acquire_read #endif #if defined(AO_HAVE_XSIZE_fetch_and_add) \ && !defined(AO_HAVE_XSIZE_fetch_and_add1) # define AO_XSIZE_fetch_and_add1(addr) AO_XSIZE_fetch_and_add(addr, 1) # define AO_HAVE_XSIZE_fetch_and_add1 #endif #if defined(AO_HAVE_XSIZE_fetch_and_add1_full) # if !defined(AO_HAVE_XSIZE_fetch_and_add1_release) # define AO_XSIZE_fetch_and_add1_release(addr) \ AO_XSIZE_fetch_and_add1_full(addr) # define AO_HAVE_XSIZE_fetch_and_add1_release # endif # if !defined(AO_HAVE_XSIZE_fetch_and_add1_acquire) # define AO_XSIZE_fetch_and_add1_acquire(addr) \ AO_XSIZE_fetch_and_add1_full(addr) # define AO_HAVE_XSIZE_fetch_and_add1_acquire # endif # if !defined(AO_HAVE_XSIZE_fetch_and_add1_write) # define AO_XSIZE_fetch_and_add1_write(addr) \ AO_XSIZE_fetch_and_add1_full(addr) # define AO_HAVE_XSIZE_fetch_and_add1_write # endif # if !defined(AO_HAVE_XSIZE_fetch_and_add1_read) # define AO_XSIZE_fetch_and_add1_read(addr) \ AO_XSIZE_fetch_and_add1_full(addr) # define AO_HAVE_XSIZE_fetch_and_add1_read # endif #endif /* AO_HAVE_XSIZE_fetch_and_add1_full */ #if !defined(AO_HAVE_XSIZE_fetch_and_add1) \ && defined(AO_HAVE_XSIZE_fetch_and_add1_release) # define AO_XSIZE_fetch_and_add1(addr) AO_XSIZE_fetch_and_add1_release(addr) # define AO_HAVE_XSIZE_fetch_and_add1 #endif #if !defined(AO_HAVE_XSIZE_fetch_and_add1) \ && defined(AO_HAVE_XSIZE_fetch_and_add1_acquire) # define AO_XSIZE_fetch_and_add1(addr) AO_XSIZE_fetch_and_add1_acquire(addr) # define AO_HAVE_XSIZE_fetch_and_add1 #endif #if !defined(AO_HAVE_XSIZE_fetch_and_add1) \ && defined(AO_HAVE_XSIZE_fetch_and_add1_write) # define AO_XSIZE_fetch_and_add1(addr) AO_XSIZE_fetch_and_add1_write(addr) # define AO_HAVE_XSIZE_fetch_and_add1 #endif #if !defined(AO_HAVE_XSIZE_fetch_and_add1) \ && defined(AO_HAVE_XSIZE_fetch_and_add1_read) # define AO_XSIZE_fetch_and_add1(addr) AO_XSIZE_fetch_and_add1_read(addr) # define AO_HAVE_XSIZE_fetch_and_add1 #endif #if defined(AO_HAVE_XSIZE_fetch_and_add1_acquire) \ && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_XSIZE_fetch_and_add1_full) # define AO_XSIZE_fetch_and_add1_full(addr) \ (AO_nop_full(), AO_XSIZE_fetch_and_add1_acquire(addr)) # define AO_HAVE_XSIZE_fetch_and_add1_full #endif #if !defined(AO_HAVE_XSIZE_fetch_and_add1_release_write) \ && defined(AO_HAVE_XSIZE_fetch_and_add1_write) # define AO_XSIZE_fetch_and_add1_release_write(addr) \ AO_XSIZE_fetch_and_add1_write(addr) # define AO_HAVE_XSIZE_fetch_and_add1_release_write #endif #if !defined(AO_HAVE_XSIZE_fetch_and_add1_release_write) \ && defined(AO_HAVE_XSIZE_fetch_and_add1_release) # define AO_XSIZE_fetch_and_add1_release_write(addr) \ AO_XSIZE_fetch_and_add1_release(addr) # define AO_HAVE_XSIZE_fetch_and_add1_release_write #endif #if !defined(AO_HAVE_XSIZE_fetch_and_add1_acquire_read) \ && defined(AO_HAVE_XSIZE_fetch_and_add1_read) # define AO_XSIZE_fetch_and_add1_acquire_read(addr) \ AO_XSIZE_fetch_and_add1_read(addr) # define AO_HAVE_XSIZE_fetch_and_add1_acquire_read #endif #if !defined(AO_HAVE_XSIZE_fetch_and_add1_acquire_read) \ && defined(AO_HAVE_XSIZE_fetch_and_add1_acquire) # define AO_XSIZE_fetch_and_add1_acquire_read(addr) \ AO_XSIZE_fetch_and_add1_acquire(addr) # define AO_HAVE_XSIZE_fetch_and_add1_acquire_read #endif #ifdef AO_NO_DD_ORDERING # if defined(AO_HAVE_XSIZE_fetch_and_add1_acquire_read) # define AO_XSIZE_fetch_and_add1_dd_acquire_read(addr) \ AO_XSIZE_fetch_and_add1_acquire_read(addr) # define AO_HAVE_XSIZE_fetch_and_add1_dd_acquire_read # endif #else # if defined(AO_HAVE_XSIZE_fetch_and_add1) # define AO_XSIZE_fetch_and_add1_dd_acquire_read(addr) \ AO_XSIZE_fetch_and_add1(addr) # define AO_HAVE_XSIZE_fetch_and_add1_dd_acquire_read # endif #endif /* !AO_NO_DD_ORDERING */ /* XSIZE_fetch_and_sub1 */ #if defined(AO_HAVE_XSIZE_fetch_and_add_full) \ && !defined(AO_HAVE_XSIZE_fetch_and_sub1_full) # define AO_XSIZE_fetch_and_sub1_full(addr) \ AO_XSIZE_fetch_and_add_full(addr, (XCTYPE)(-1)) # define AO_HAVE_XSIZE_fetch_and_sub1_full #endif #if defined(AO_HAVE_XSIZE_fetch_and_add_release) \ && !defined(AO_HAVE_XSIZE_fetch_and_sub1_release) # define AO_XSIZE_fetch_and_sub1_release(addr) \ AO_XSIZE_fetch_and_add_release(addr, (XCTYPE)(-1)) # define AO_HAVE_XSIZE_fetch_and_sub1_release #endif #if defined(AO_HAVE_XSIZE_fetch_and_add_acquire) \ && !defined(AO_HAVE_XSIZE_fetch_and_sub1_acquire) # define AO_XSIZE_fetch_and_sub1_acquire(addr) \ AO_XSIZE_fetch_and_add_acquire(addr, (XCTYPE)(-1)) # define AO_HAVE_XSIZE_fetch_and_sub1_acquire #endif #if defined(AO_HAVE_XSIZE_fetch_and_add_write) \ && !defined(AO_HAVE_XSIZE_fetch_and_sub1_write) # define AO_XSIZE_fetch_and_sub1_write(addr) \ AO_XSIZE_fetch_and_add_write(addr, (XCTYPE)(-1)) # define AO_HAVE_XSIZE_fetch_and_sub1_write #endif #if defined(AO_HAVE_XSIZE_fetch_and_add_read) \ && !defined(AO_HAVE_XSIZE_fetch_and_sub1_read) # define AO_XSIZE_fetch_and_sub1_read(addr) \ AO_XSIZE_fetch_and_add_read(addr, (XCTYPE)(-1)) # define AO_HAVE_XSIZE_fetch_and_sub1_read #endif #if defined(AO_HAVE_XSIZE_fetch_and_add_release_write) \ && !defined(AO_HAVE_XSIZE_fetch_and_sub1_release_write) # define AO_XSIZE_fetch_and_sub1_release_write(addr) \ AO_XSIZE_fetch_and_add_release_write(addr, (XCTYPE)(-1)) # define AO_HAVE_XSIZE_fetch_and_sub1_release_write #endif #if defined(AO_HAVE_XSIZE_fetch_and_add_acquire_read) \ && !defined(AO_HAVE_XSIZE_fetch_and_sub1_acquire_read) # define AO_XSIZE_fetch_and_sub1_acquire_read(addr) \ AO_XSIZE_fetch_and_add_acquire_read(addr, (XCTYPE)(-1)) # define AO_HAVE_XSIZE_fetch_and_sub1_acquire_read #endif #if defined(AO_HAVE_XSIZE_fetch_and_add) \ && !defined(AO_HAVE_XSIZE_fetch_and_sub1) # define AO_XSIZE_fetch_and_sub1(addr) \ AO_XSIZE_fetch_and_add(addr, (XCTYPE)(-1)) # define AO_HAVE_XSIZE_fetch_and_sub1 #endif #if defined(AO_HAVE_XSIZE_fetch_and_sub1_full) # if !defined(AO_HAVE_XSIZE_fetch_and_sub1_release) # define AO_XSIZE_fetch_and_sub1_release(addr) \ AO_XSIZE_fetch_and_sub1_full(addr) # define AO_HAVE_XSIZE_fetch_and_sub1_release # endif # if !defined(AO_HAVE_XSIZE_fetch_and_sub1_acquire) # define AO_XSIZE_fetch_and_sub1_acquire(addr) \ AO_XSIZE_fetch_and_sub1_full(addr) # define AO_HAVE_XSIZE_fetch_and_sub1_acquire # endif # if !defined(AO_HAVE_XSIZE_fetch_and_sub1_write) # define AO_XSIZE_fetch_and_sub1_write(addr) \ AO_XSIZE_fetch_and_sub1_full(addr) # define AO_HAVE_XSIZE_fetch_and_sub1_write # endif # if !defined(AO_HAVE_XSIZE_fetch_and_sub1_read) # define AO_XSIZE_fetch_and_sub1_read(addr) \ AO_XSIZE_fetch_and_sub1_full(addr) # define AO_HAVE_XSIZE_fetch_and_sub1_read # endif #endif /* AO_HAVE_XSIZE_fetch_and_sub1_full */ #if !defined(AO_HAVE_XSIZE_fetch_and_sub1) \ && defined(AO_HAVE_XSIZE_fetch_and_sub1_release) # define AO_XSIZE_fetch_and_sub1(addr) AO_XSIZE_fetch_and_sub1_release(addr) # define AO_HAVE_XSIZE_fetch_and_sub1 #endif #if !defined(AO_HAVE_XSIZE_fetch_and_sub1) \ && defined(AO_HAVE_XSIZE_fetch_and_sub1_acquire) # define AO_XSIZE_fetch_and_sub1(addr) AO_XSIZE_fetch_and_sub1_acquire(addr) # define AO_HAVE_XSIZE_fetch_and_sub1 #endif #if !defined(AO_HAVE_XSIZE_fetch_and_sub1) \ && defined(AO_HAVE_XSIZE_fetch_and_sub1_write) # define AO_XSIZE_fetch_and_sub1(addr) AO_XSIZE_fetch_and_sub1_write(addr) # define AO_HAVE_XSIZE_fetch_and_sub1 #endif #if !defined(AO_HAVE_XSIZE_fetch_and_sub1) \ && defined(AO_HAVE_XSIZE_fetch_and_sub1_read) # define AO_XSIZE_fetch_and_sub1(addr) AO_XSIZE_fetch_and_sub1_read(addr) # define AO_HAVE_XSIZE_fetch_and_sub1 #endif #if defined(AO_HAVE_XSIZE_fetch_and_sub1_acquire) \ && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_XSIZE_fetch_and_sub1_full) # define AO_XSIZE_fetch_and_sub1_full(addr) \ (AO_nop_full(), AO_XSIZE_fetch_and_sub1_acquire(addr)) # define AO_HAVE_XSIZE_fetch_and_sub1_full #endif #if !defined(AO_HAVE_XSIZE_fetch_and_sub1_release_write) \ && defined(AO_HAVE_XSIZE_fetch_and_sub1_write) # define AO_XSIZE_fetch_and_sub1_release_write(addr) \ AO_XSIZE_fetch_and_sub1_write(addr) # define AO_HAVE_XSIZE_fetch_and_sub1_release_write #endif #if !defined(AO_HAVE_XSIZE_fetch_and_sub1_release_write) \ && defined(AO_HAVE_XSIZE_fetch_and_sub1_release) # define AO_XSIZE_fetch_and_sub1_release_write(addr) \ AO_XSIZE_fetch_and_sub1_release(addr) # define AO_HAVE_XSIZE_fetch_and_sub1_release_write #endif #if !defined(AO_HAVE_XSIZE_fetch_and_sub1_acquire_read) \ && defined(AO_HAVE_XSIZE_fetch_and_sub1_read) # define AO_XSIZE_fetch_and_sub1_acquire_read(addr) \ AO_XSIZE_fetch_and_sub1_read(addr) # define AO_HAVE_XSIZE_fetch_and_sub1_acquire_read #endif #if !defined(AO_HAVE_XSIZE_fetch_and_sub1_acquire_read) \ && defined(AO_HAVE_XSIZE_fetch_and_sub1_acquire) # define AO_XSIZE_fetch_and_sub1_acquire_read(addr) \ AO_XSIZE_fetch_and_sub1_acquire(addr) # define AO_HAVE_XSIZE_fetch_and_sub1_acquire_read #endif #ifdef AO_NO_DD_ORDERING # if defined(AO_HAVE_XSIZE_fetch_and_sub1_acquire_read) # define AO_XSIZE_fetch_and_sub1_dd_acquire_read(addr) \ AO_XSIZE_fetch_and_sub1_acquire_read(addr) # define AO_HAVE_XSIZE_fetch_and_sub1_dd_acquire_read # endif #else # if defined(AO_HAVE_XSIZE_fetch_and_sub1) # define AO_XSIZE_fetch_and_sub1_dd_acquire_read(addr) \ AO_XSIZE_fetch_and_sub1(addr) # define AO_HAVE_XSIZE_fetch_and_sub1_dd_acquire_read # endif #endif /* !AO_NO_DD_ORDERING */ /* XSIZE_and */ #if defined(AO_HAVE_XSIZE_compare_and_swap_full) \ && !defined(AO_HAVE_XSIZE_and_full) AO_INLINE void AO_XSIZE_and_full(volatile XCTYPE *addr, XCTYPE value) { XCTYPE old; do { old = *(XCTYPE *)addr; } while (AO_EXPECT_FALSE(!AO_XSIZE_compare_and_swap_full(addr, old, old & value))); } # define AO_HAVE_XSIZE_and_full #endif #if defined(AO_HAVE_XSIZE_and_full) # if !defined(AO_HAVE_XSIZE_and_release) # define AO_XSIZE_and_release(addr, val) AO_XSIZE_and_full(addr, val) # define AO_HAVE_XSIZE_and_release # endif # if !defined(AO_HAVE_XSIZE_and_acquire) # define AO_XSIZE_and_acquire(addr, val) AO_XSIZE_and_full(addr, val) # define AO_HAVE_XSIZE_and_acquire # endif # if !defined(AO_HAVE_XSIZE_and_write) # define AO_XSIZE_and_write(addr, val) AO_XSIZE_and_full(addr, val) # define AO_HAVE_XSIZE_and_write # endif # if !defined(AO_HAVE_XSIZE_and_read) # define AO_XSIZE_and_read(addr, val) AO_XSIZE_and_full(addr, val) # define AO_HAVE_XSIZE_and_read # endif #endif /* AO_HAVE_XSIZE_and_full */ #if !defined(AO_HAVE_XSIZE_and) && defined(AO_HAVE_XSIZE_and_release) # define AO_XSIZE_and(addr, val) AO_XSIZE_and_release(addr, val) # define AO_HAVE_XSIZE_and #endif #if !defined(AO_HAVE_XSIZE_and) && defined(AO_HAVE_XSIZE_and_acquire) # define AO_XSIZE_and(addr, val) AO_XSIZE_and_acquire(addr, val) # define AO_HAVE_XSIZE_and #endif #if !defined(AO_HAVE_XSIZE_and) && defined(AO_HAVE_XSIZE_and_write) # define AO_XSIZE_and(addr, val) AO_XSIZE_and_write(addr, val) # define AO_HAVE_XSIZE_and #endif #if !defined(AO_HAVE_XSIZE_and) && defined(AO_HAVE_XSIZE_and_read) # define AO_XSIZE_and(addr, val) AO_XSIZE_and_read(addr, val) # define AO_HAVE_XSIZE_and #endif #if defined(AO_HAVE_XSIZE_and_acquire) && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_XSIZE_and_full) # define AO_XSIZE_and_full(addr, val) \ (AO_nop_full(), AO_XSIZE_and_acquire(addr, val)) # define AO_HAVE_XSIZE_and_full #endif #if !defined(AO_HAVE_XSIZE_and_release_write) \ && defined(AO_HAVE_XSIZE_and_write) # define AO_XSIZE_and_release_write(addr, val) AO_XSIZE_and_write(addr, val) # define AO_HAVE_XSIZE_and_release_write #endif #if !defined(AO_HAVE_XSIZE_and_release_write) \ && defined(AO_HAVE_XSIZE_and_release) # define AO_XSIZE_and_release_write(addr, val) AO_XSIZE_and_release(addr, val) # define AO_HAVE_XSIZE_and_release_write #endif #if !defined(AO_HAVE_XSIZE_and_acquire_read) \ && defined(AO_HAVE_XSIZE_and_read) # define AO_XSIZE_and_acquire_read(addr, val) AO_XSIZE_and_read(addr, val) # define AO_HAVE_XSIZE_and_acquire_read #endif #if !defined(AO_HAVE_XSIZE_and_acquire_read) \ && defined(AO_HAVE_XSIZE_and_acquire) # define AO_XSIZE_and_acquire_read(addr, val) AO_XSIZE_and_acquire(addr, val) # define AO_HAVE_XSIZE_and_acquire_read #endif /* XSIZE_or */ #if defined(AO_HAVE_XSIZE_compare_and_swap_full) \ && !defined(AO_HAVE_XSIZE_or_full) AO_INLINE void AO_XSIZE_or_full(volatile XCTYPE *addr, XCTYPE value) { XCTYPE old; do { old = *(XCTYPE *)addr; } while (AO_EXPECT_FALSE(!AO_XSIZE_compare_and_swap_full(addr, old, old | value))); } # define AO_HAVE_XSIZE_or_full #endif #if defined(AO_HAVE_XSIZE_or_full) # if !defined(AO_HAVE_XSIZE_or_release) # define AO_XSIZE_or_release(addr, val) AO_XSIZE_or_full(addr, val) # define AO_HAVE_XSIZE_or_release # endif # if !defined(AO_HAVE_XSIZE_or_acquire) # define AO_XSIZE_or_acquire(addr, val) AO_XSIZE_or_full(addr, val) # define AO_HAVE_XSIZE_or_acquire # endif # if !defined(AO_HAVE_XSIZE_or_write) # define AO_XSIZE_or_write(addr, val) AO_XSIZE_or_full(addr, val) # define AO_HAVE_XSIZE_or_write # endif # if !defined(AO_HAVE_XSIZE_or_read) # define AO_XSIZE_or_read(addr, val) AO_XSIZE_or_full(addr, val) # define AO_HAVE_XSIZE_or_read # endif #endif /* AO_HAVE_XSIZE_or_full */ #if !defined(AO_HAVE_XSIZE_or) && defined(AO_HAVE_XSIZE_or_release) # define AO_XSIZE_or(addr, val) AO_XSIZE_or_release(addr, val) # define AO_HAVE_XSIZE_or #endif #if !defined(AO_HAVE_XSIZE_or) && defined(AO_HAVE_XSIZE_or_acquire) # define AO_XSIZE_or(addr, val) AO_XSIZE_or_acquire(addr, val) # define AO_HAVE_XSIZE_or #endif #if !defined(AO_HAVE_XSIZE_or) && defined(AO_HAVE_XSIZE_or_write) # define AO_XSIZE_or(addr, val) AO_XSIZE_or_write(addr, val) # define AO_HAVE_XSIZE_or #endif #if !defined(AO_HAVE_XSIZE_or) && defined(AO_HAVE_XSIZE_or_read) # define AO_XSIZE_or(addr, val) AO_XSIZE_or_read(addr, val) # define AO_HAVE_XSIZE_or #endif #if defined(AO_HAVE_XSIZE_or_acquire) && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_XSIZE_or_full) # define AO_XSIZE_or_full(addr, val) \ (AO_nop_full(), AO_XSIZE_or_acquire(addr, val)) # define AO_HAVE_XSIZE_or_full #endif #if !defined(AO_HAVE_XSIZE_or_release_write) \ && defined(AO_HAVE_XSIZE_or_write) # define AO_XSIZE_or_release_write(addr, val) AO_XSIZE_or_write(addr, val) # define AO_HAVE_XSIZE_or_release_write #endif #if !defined(AO_HAVE_XSIZE_or_release_write) \ && defined(AO_HAVE_XSIZE_or_release) # define AO_XSIZE_or_release_write(addr, val) AO_XSIZE_or_release(addr, val) # define AO_HAVE_XSIZE_or_release_write #endif #if !defined(AO_HAVE_XSIZE_or_acquire_read) && defined(AO_HAVE_XSIZE_or_read) # define AO_XSIZE_or_acquire_read(addr, val) AO_XSIZE_or_read(addr, val) # define AO_HAVE_XSIZE_or_acquire_read #endif #if !defined(AO_HAVE_XSIZE_or_acquire_read) \ && defined(AO_HAVE_XSIZE_or_acquire) # define AO_XSIZE_or_acquire_read(addr, val) AO_XSIZE_or_acquire(addr, val) # define AO_HAVE_XSIZE_or_acquire_read #endif /* XSIZE_xor */ #if defined(AO_HAVE_XSIZE_compare_and_swap_full) \ && !defined(AO_HAVE_XSIZE_xor_full) AO_INLINE void AO_XSIZE_xor_full(volatile XCTYPE *addr, XCTYPE value) { XCTYPE old; do { old = *(XCTYPE *)addr; } while (AO_EXPECT_FALSE(!AO_XSIZE_compare_and_swap_full(addr, old, old ^ value))); } # define AO_HAVE_XSIZE_xor_full #endif #if defined(AO_HAVE_XSIZE_xor_full) # if !defined(AO_HAVE_XSIZE_xor_release) # define AO_XSIZE_xor_release(addr, val) AO_XSIZE_xor_full(addr, val) # define AO_HAVE_XSIZE_xor_release # endif # if !defined(AO_HAVE_XSIZE_xor_acquire) # define AO_XSIZE_xor_acquire(addr, val) AO_XSIZE_xor_full(addr, val) # define AO_HAVE_XSIZE_xor_acquire # endif # if !defined(AO_HAVE_XSIZE_xor_write) # define AO_XSIZE_xor_write(addr, val) AO_XSIZE_xor_full(addr, val) # define AO_HAVE_XSIZE_xor_write # endif # if !defined(AO_HAVE_XSIZE_xor_read) # define AO_XSIZE_xor_read(addr, val) AO_XSIZE_xor_full(addr, val) # define AO_HAVE_XSIZE_xor_read # endif #endif /* AO_HAVE_XSIZE_xor_full */ #if !defined(AO_HAVE_XSIZE_xor) && defined(AO_HAVE_XSIZE_xor_release) # define AO_XSIZE_xor(addr, val) AO_XSIZE_xor_release(addr, val) # define AO_HAVE_XSIZE_xor #endif #if !defined(AO_HAVE_XSIZE_xor) && defined(AO_HAVE_XSIZE_xor_acquire) # define AO_XSIZE_xor(addr, val) AO_XSIZE_xor_acquire(addr, val) # define AO_HAVE_XSIZE_xor #endif #if !defined(AO_HAVE_XSIZE_xor) && defined(AO_HAVE_XSIZE_xor_write) # define AO_XSIZE_xor(addr, val) AO_XSIZE_xor_write(addr, val) # define AO_HAVE_XSIZE_xor #endif #if !defined(AO_HAVE_XSIZE_xor) && defined(AO_HAVE_XSIZE_xor_read) # define AO_XSIZE_xor(addr, val) AO_XSIZE_xor_read(addr, val) # define AO_HAVE_XSIZE_xor #endif #if defined(AO_HAVE_XSIZE_xor_acquire) && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_XSIZE_xor_full) # define AO_XSIZE_xor_full(addr, val) \ (AO_nop_full(), AO_XSIZE_xor_acquire(addr, val)) # define AO_HAVE_XSIZE_xor_full #endif #if !defined(AO_HAVE_XSIZE_xor_release_write) \ && defined(AO_HAVE_XSIZE_xor_write) # define AO_XSIZE_xor_release_write(addr, val) AO_XSIZE_xor_write(addr, val) # define AO_HAVE_XSIZE_xor_release_write #endif #if !defined(AO_HAVE_XSIZE_xor_release_write) \ && defined(AO_HAVE_XSIZE_xor_release) # define AO_XSIZE_xor_release_write(addr, val) AO_XSIZE_xor_release(addr, val) # define AO_HAVE_XSIZE_xor_release_write #endif #if !defined(AO_HAVE_XSIZE_xor_acquire_read) \ && defined(AO_HAVE_XSIZE_xor_read) # define AO_XSIZE_xor_acquire_read(addr, val) AO_XSIZE_xor_read(addr, val) # define AO_HAVE_XSIZE_xor_acquire_read #endif #if !defined(AO_HAVE_XSIZE_xor_acquire_read) \ && defined(AO_HAVE_XSIZE_xor_acquire) # define AO_XSIZE_xor_acquire_read(addr, val) AO_XSIZE_xor_acquire(addr, val) # define AO_HAVE_XSIZE_xor_acquire_read #endif /* XSIZE_and/or/xor_dd_acquire_read are meaningless. */ ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/generalize-small.h000066400000000000000000003073111266352375300254160ustar00rootroot00000000000000/* * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ /* char_fetch_compare_and_swap */ #if defined(AO_HAVE_char_fetch_compare_and_swap) \ && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_char_fetch_compare_and_swap_acquire) AO_INLINE unsigned/**/char AO_char_fetch_compare_and_swap_acquire(volatile unsigned/**/char *addr, unsigned/**/char old_val, unsigned/**/char new_val) { unsigned/**/char result = AO_char_fetch_compare_and_swap(addr, old_val, new_val); AO_nop_full(); return result; } # define AO_HAVE_char_fetch_compare_and_swap_acquire #endif #if defined(AO_HAVE_char_fetch_compare_and_swap) \ && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_char_fetch_compare_and_swap_release) # define AO_char_fetch_compare_and_swap_release(addr, old_val, new_val) \ (AO_nop_full(), \ AO_char_fetch_compare_and_swap(addr, old_val, new_val)) # define AO_HAVE_char_fetch_compare_and_swap_release #endif #if defined(AO_HAVE_char_fetch_compare_and_swap_full) # if !defined(AO_HAVE_char_fetch_compare_and_swap_release) # define AO_char_fetch_compare_and_swap_release(addr, old_val, new_val) \ AO_char_fetch_compare_and_swap_full(addr, old_val, new_val) # define AO_HAVE_char_fetch_compare_and_swap_release # endif # if !defined(AO_HAVE_char_fetch_compare_and_swap_acquire) # define AO_char_fetch_compare_and_swap_acquire(addr, old_val, new_val) \ AO_char_fetch_compare_and_swap_full(addr, old_val, new_val) # define AO_HAVE_char_fetch_compare_and_swap_acquire # endif # if !defined(AO_HAVE_char_fetch_compare_and_swap_write) # define AO_char_fetch_compare_and_swap_write(addr, old_val, new_val) \ AO_char_fetch_compare_and_swap_full(addr, old_val, new_val) # define AO_HAVE_char_fetch_compare_and_swap_write # endif # if !defined(AO_HAVE_char_fetch_compare_and_swap_read) # define AO_char_fetch_compare_and_swap_read(addr, old_val, new_val) \ AO_char_fetch_compare_and_swap_full(addr, old_val, new_val) # define AO_HAVE_char_fetch_compare_and_swap_read # endif #endif /* AO_HAVE_char_fetch_compare_and_swap_full */ #if !defined(AO_HAVE_char_fetch_compare_and_swap) \ && defined(AO_HAVE_char_fetch_compare_and_swap_release) # define AO_char_fetch_compare_and_swap(addr, old_val, new_val) \ AO_char_fetch_compare_and_swap_release(addr, old_val, new_val) # define AO_HAVE_char_fetch_compare_and_swap #endif #if !defined(AO_HAVE_char_fetch_compare_and_swap) \ && defined(AO_HAVE_char_fetch_compare_and_swap_acquire) # define AO_char_fetch_compare_and_swap(addr, old_val, new_val) \ AO_char_fetch_compare_and_swap_acquire(addr, old_val, new_val) # define AO_HAVE_char_fetch_compare_and_swap #endif #if !defined(AO_HAVE_char_fetch_compare_and_swap) \ && defined(AO_HAVE_char_fetch_compare_and_swap_write) # define AO_char_fetch_compare_and_swap(addr, old_val, new_val) \ AO_char_fetch_compare_and_swap_write(addr, old_val, new_val) # define AO_HAVE_char_fetch_compare_and_swap #endif #if !defined(AO_HAVE_char_fetch_compare_and_swap) \ && defined(AO_HAVE_char_fetch_compare_and_swap_read) # define AO_char_fetch_compare_and_swap(addr, old_val, new_val) \ AO_char_fetch_compare_and_swap_read(addr, old_val, new_val) # define AO_HAVE_char_fetch_compare_and_swap #endif #if defined(AO_HAVE_char_fetch_compare_and_swap_acquire) \ && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_char_fetch_compare_and_swap_full) # define AO_char_fetch_compare_and_swap_full(addr, old_val, new_val) \ (AO_nop_full(), \ AO_char_fetch_compare_and_swap_acquire(addr, old_val, new_val)) # define AO_HAVE_char_fetch_compare_and_swap_full #endif #if !defined(AO_HAVE_char_fetch_compare_and_swap_release_write) \ && defined(AO_HAVE_char_fetch_compare_and_swap_write) # define AO_char_fetch_compare_and_swap_release_write(addr,old_val,new_val) \ AO_char_fetch_compare_and_swap_write(addr, old_val, new_val) # define AO_HAVE_char_fetch_compare_and_swap_release_write #endif #if !defined(AO_HAVE_char_fetch_compare_and_swap_release_write) \ && defined(AO_HAVE_char_fetch_compare_and_swap_release) # define AO_char_fetch_compare_and_swap_release_write(addr,old_val,new_val) \ AO_char_fetch_compare_and_swap_release(addr, old_val, new_val) # define AO_HAVE_char_fetch_compare_and_swap_release_write #endif #if !defined(AO_HAVE_char_fetch_compare_and_swap_acquire_read) \ && defined(AO_HAVE_char_fetch_compare_and_swap_read) # define AO_char_fetch_compare_and_swap_acquire_read(addr,old_val,new_val) \ AO_char_fetch_compare_and_swap_read(addr, old_val, new_val) # define AO_HAVE_char_fetch_compare_and_swap_acquire_read #endif #if !defined(AO_HAVE_char_fetch_compare_and_swap_acquire_read) \ && defined(AO_HAVE_char_fetch_compare_and_swap_acquire) # define AO_char_fetch_compare_and_swap_acquire_read(addr,old_val,new_val) \ AO_char_fetch_compare_and_swap_acquire(addr, old_val, new_val) # define AO_HAVE_char_fetch_compare_and_swap_acquire_read #endif #ifdef AO_NO_DD_ORDERING # if defined(AO_HAVE_char_fetch_compare_and_swap_acquire_read) # define AO_char_fetch_compare_and_swap_dd_acquire_read(addr,old_val,new_val) \ AO_char_fetch_compare_and_swap_acquire_read(addr, old_val, new_val) # define AO_HAVE_char_fetch_compare_and_swap_dd_acquire_read # endif #else # if defined(AO_HAVE_char_fetch_compare_and_swap) # define AO_char_fetch_compare_and_swap_dd_acquire_read(addr,old_val,new_val) \ AO_char_fetch_compare_and_swap(addr, old_val, new_val) # define AO_HAVE_char_fetch_compare_and_swap_dd_acquire_read # endif #endif /* !AO_NO_DD_ORDERING */ /* char_compare_and_swap */ #if defined(AO_HAVE_char_compare_and_swap) && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_char_compare_and_swap_acquire) AO_INLINE int AO_char_compare_and_swap_acquire(volatile unsigned/**/char *addr, unsigned/**/char old, unsigned/**/char new_val) { int result = AO_char_compare_and_swap(addr, old, new_val); AO_nop_full(); return result; } # define AO_HAVE_char_compare_and_swap_acquire #endif #if defined(AO_HAVE_char_compare_and_swap) && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_char_compare_and_swap_release) # define AO_char_compare_and_swap_release(addr, old, new_val) \ (AO_nop_full(), AO_char_compare_and_swap(addr, old, new_val)) # define AO_HAVE_char_compare_and_swap_release #endif #if defined(AO_HAVE_char_compare_and_swap_full) # if !defined(AO_HAVE_char_compare_and_swap_release) # define AO_char_compare_and_swap_release(addr, old, new_val) \ AO_char_compare_and_swap_full(addr, old, new_val) # define AO_HAVE_char_compare_and_swap_release # endif # if !defined(AO_HAVE_char_compare_and_swap_acquire) # define AO_char_compare_and_swap_acquire(addr, old, new_val) \ AO_char_compare_and_swap_full(addr, old, new_val) # define AO_HAVE_char_compare_and_swap_acquire # endif # if !defined(AO_HAVE_char_compare_and_swap_write) # define AO_char_compare_and_swap_write(addr, old, new_val) \ AO_char_compare_and_swap_full(addr, old, new_val) # define AO_HAVE_char_compare_and_swap_write # endif # if !defined(AO_HAVE_char_compare_and_swap_read) # define AO_char_compare_and_swap_read(addr, old, new_val) \ AO_char_compare_and_swap_full(addr, old, new_val) # define AO_HAVE_char_compare_and_swap_read # endif #endif /* AO_HAVE_char_compare_and_swap_full */ #if !defined(AO_HAVE_char_compare_and_swap) \ && defined(AO_HAVE_char_compare_and_swap_release) # define AO_char_compare_and_swap(addr, old, new_val) \ AO_char_compare_and_swap_release(addr, old, new_val) # define AO_HAVE_char_compare_and_swap #endif #if !defined(AO_HAVE_char_compare_and_swap) \ && defined(AO_HAVE_char_compare_and_swap_acquire) # define AO_char_compare_and_swap(addr, old, new_val) \ AO_char_compare_and_swap_acquire(addr, old, new_val) # define AO_HAVE_char_compare_and_swap #endif #if !defined(AO_HAVE_char_compare_and_swap) \ && defined(AO_HAVE_char_compare_and_swap_write) # define AO_char_compare_and_swap(addr, old, new_val) \ AO_char_compare_and_swap_write(addr, old, new_val) # define AO_HAVE_char_compare_and_swap #endif #if !defined(AO_HAVE_char_compare_and_swap) \ && defined(AO_HAVE_char_compare_and_swap_read) # define AO_char_compare_and_swap(addr, old, new_val) \ AO_char_compare_and_swap_read(addr, old, new_val) # define AO_HAVE_char_compare_and_swap #endif #if defined(AO_HAVE_char_compare_and_swap_acquire) \ && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_char_compare_and_swap_full) # define AO_char_compare_and_swap_full(addr, old, new_val) \ (AO_nop_full(), \ AO_char_compare_and_swap_acquire(addr, old, new_val)) # define AO_HAVE_char_compare_and_swap_full #endif #if !defined(AO_HAVE_char_compare_and_swap_release_write) \ && defined(AO_HAVE_char_compare_and_swap_write) # define AO_char_compare_and_swap_release_write(addr, old, new_val) \ AO_char_compare_and_swap_write(addr, old, new_val) # define AO_HAVE_char_compare_and_swap_release_write #endif #if !defined(AO_HAVE_char_compare_and_swap_release_write) \ && defined(AO_HAVE_char_compare_and_swap_release) # define AO_char_compare_and_swap_release_write(addr, old, new_val) \ AO_char_compare_and_swap_release(addr, old, new_val) # define AO_HAVE_char_compare_and_swap_release_write #endif #if !defined(AO_HAVE_char_compare_and_swap_acquire_read) \ && defined(AO_HAVE_char_compare_and_swap_read) # define AO_char_compare_and_swap_acquire_read(addr, old, new_val) \ AO_char_compare_and_swap_read(addr, old, new_val) # define AO_HAVE_char_compare_and_swap_acquire_read #endif #if !defined(AO_HAVE_char_compare_and_swap_acquire_read) \ && defined(AO_HAVE_char_compare_and_swap_acquire) # define AO_char_compare_and_swap_acquire_read(addr, old, new_val) \ AO_char_compare_and_swap_acquire(addr, old, new_val) # define AO_HAVE_char_compare_and_swap_acquire_read #endif #ifdef AO_NO_DD_ORDERING # if defined(AO_HAVE_char_compare_and_swap_acquire_read) # define AO_char_compare_and_swap_dd_acquire_read(addr, old, new_val) \ AO_char_compare_and_swap_acquire_read(addr, old, new_val) # define AO_HAVE_char_compare_and_swap_dd_acquire_read # endif #else # if defined(AO_HAVE_char_compare_and_swap) # define AO_char_compare_and_swap_dd_acquire_read(addr, old, new_val) \ AO_char_compare_and_swap(addr, old, new_val) # define AO_HAVE_char_compare_and_swap_dd_acquire_read # endif #endif /* !AO_NO_DD_ORDERING */ /* char_load */ #if defined(AO_HAVE_char_load_full) && !defined(AO_HAVE_char_load_acquire) # define AO_char_load_acquire(addr) AO_char_load_full(addr) # define AO_HAVE_char_load_acquire #endif #if defined(AO_HAVE_char_load_acquire) && !defined(AO_HAVE_char_load) # define AO_char_load(addr) AO_char_load_acquire(addr) # define AO_HAVE_char_load #endif #if defined(AO_HAVE_char_load_full) && !defined(AO_HAVE_char_load_read) # define AO_char_load_read(addr) AO_char_load_full(addr) # define AO_HAVE_char_load_read #endif #if !defined(AO_HAVE_char_load_acquire_read) \ && defined(AO_HAVE_char_load_acquire) # define AO_char_load_acquire_read(addr) AO_char_load_acquire(addr) # define AO_HAVE_char_load_acquire_read #endif #if defined(AO_HAVE_char_load) && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_char_load_acquire) AO_INLINE unsigned/**/char AO_char_load_acquire(const volatile unsigned/**/char *addr) { unsigned/**/char result = AO_char_load(addr); /* Acquire barrier would be useless, since the load could be delayed */ /* beyond it. */ AO_nop_full(); return result; } # define AO_HAVE_char_load_acquire #endif #if defined(AO_HAVE_char_load) && defined(AO_HAVE_nop_read) \ && !defined(AO_HAVE_char_load_read) AO_INLINE unsigned/**/char AO_char_load_read(const volatile unsigned/**/char *addr) { unsigned/**/char result = AO_char_load(addr); AO_nop_read(); return result; } # define AO_HAVE_char_load_read #endif #if defined(AO_HAVE_char_load_acquire) && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_char_load_full) # define AO_char_load_full(addr) (AO_nop_full(), AO_char_load_acquire(addr)) # define AO_HAVE_char_load_full #endif #if defined(AO_HAVE_char_compare_and_swap_read) \ && !defined(AO_HAVE_char_load_read) # define AO_char_CAS_BASED_LOAD_READ AO_INLINE unsigned/**/char AO_char_load_read(const volatile unsigned/**/char *addr) { unsigned/**/char result; do { result = *(const unsigned/**/char *)addr; } while (AO_EXPECT_FALSE(!AO_char_compare_and_swap_read( (volatile unsigned/**/char *)addr, result, result))); return result; } # define AO_HAVE_char_load_read #endif #if !defined(AO_HAVE_char_load_acquire_read) \ && defined(AO_HAVE_char_load_read) # define AO_char_load_acquire_read(addr) AO_char_load_read(addr) # define AO_HAVE_char_load_acquire_read #endif #if defined(AO_HAVE_char_load_acquire_read) && !defined(AO_HAVE_char_load) \ && (!defined(AO_char_CAS_BASED_LOAD_READ) \ || !defined(AO_HAVE_char_compare_and_swap)) # define AO_char_load(addr) AO_char_load_acquire_read(addr) # define AO_HAVE_char_load #endif #if defined(AO_HAVE_char_compare_and_swap_full) \ && !defined(AO_HAVE_char_load_full) AO_INLINE unsigned/**/char AO_char_load_full(const volatile unsigned/**/char *addr) { unsigned/**/char result; do { result = *(const unsigned/**/char *)addr; } while (AO_EXPECT_FALSE(!AO_char_compare_and_swap_full( (volatile unsigned/**/char *)addr, result, result))); return result; } # define AO_HAVE_char_load_full #endif #if defined(AO_HAVE_char_compare_and_swap_acquire) \ && !defined(AO_HAVE_char_load_acquire) AO_INLINE unsigned/**/char AO_char_load_acquire(const volatile unsigned/**/char *addr) { unsigned/**/char result; do { result = *(const unsigned/**/char *)addr; } while (AO_EXPECT_FALSE(!AO_char_compare_and_swap_acquire( (volatile unsigned/**/char *)addr, result, result))); return result; } # define AO_HAVE_char_load_acquire #endif #if defined(AO_HAVE_char_compare_and_swap) && !defined(AO_HAVE_char_load) AO_INLINE unsigned/**/char AO_char_load(const volatile unsigned/**/char *addr) { unsigned/**/char result; do { result = *(const unsigned/**/char *)addr; } while (AO_EXPECT_FALSE(!AO_char_compare_and_swap( (volatile unsigned/**/char *)addr, result, result))); return result; } # define AO_HAVE_char_load #endif #ifdef AO_NO_DD_ORDERING # if defined(AO_HAVE_char_load_acquire_read) # define AO_char_load_dd_acquire_read(addr) \ AO_char_load_acquire_read(addr) # define AO_HAVE_char_load_dd_acquire_read # endif #else # if defined(AO_HAVE_char_load) # define AO_char_load_dd_acquire_read(addr) AO_char_load(addr) # define AO_HAVE_char_load_dd_acquire_read # endif #endif /* !AO_NO_DD_ORDERING */ /* char_store */ #if defined(AO_HAVE_char_store_full) && !defined(AO_HAVE_char_store_release) # define AO_char_store_release(addr, val) AO_char_store_full(addr, val) # define AO_HAVE_char_store_release #endif #if defined(AO_HAVE_char_store_release) && !defined(AO_HAVE_char_store) # define AO_char_store(addr, val) AO_char_store_release(addr, val) # define AO_HAVE_char_store #endif #if defined(AO_HAVE_char_store_full) && !defined(AO_HAVE_char_store_write) # define AO_char_store_write(addr, val) AO_char_store_full(addr, val) # define AO_HAVE_char_store_write #endif #if defined(AO_HAVE_char_store_release) \ && !defined(AO_HAVE_char_store_release_write) # define AO_char_store_release_write(addr, val) \ AO_char_store_release(addr, val) # define AO_HAVE_char_store_release_write #endif #if defined(AO_HAVE_char_store_write) && !defined(AO_HAVE_char_store) # define AO_char_store(addr, val) AO_char_store_write(addr, val) # define AO_HAVE_char_store #endif #if defined(AO_HAVE_char_store) && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_char_store_release) # define AO_char_store_release(addr, val) \ (AO_nop_full(), AO_char_store(addr, val)) # define AO_HAVE_char_store_release #endif #if defined(AO_HAVE_char_store) && defined(AO_HAVE_nop_write) \ && !defined(AO_HAVE_char_store_write) # define AO_char_store_write(addr, val) \ (AO_nop_write(), AO_char_store(addr, val)) # define AO_HAVE_char_store_write #endif #if defined(AO_HAVE_char_compare_and_swap_write) \ && !defined(AO_HAVE_char_store_write) AO_INLINE void AO_char_store_write(volatile unsigned/**/char *addr, unsigned/**/char new_val) { unsigned/**/char old_val; do { old_val = *(unsigned/**/char *)addr; } while (AO_EXPECT_FALSE(!AO_char_compare_and_swap_write(addr, old_val, new_val))); } # define AO_HAVE_char_store_write #endif #if defined(AO_HAVE_char_store_write) \ && !defined(AO_HAVE_char_store_release_write) # define AO_char_store_release_write(addr, val) \ AO_char_store_write(addr, val) # define AO_HAVE_char_store_release_write #endif #if defined(AO_HAVE_char_store_release) && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_char_store_full) # define AO_char_store_full(addr, val) \ (AO_char_store_release(addr, val), \ AO_nop_full()) # define AO_HAVE_char_store_full #endif #if defined(AO_HAVE_char_compare_and_swap) && !defined(AO_HAVE_char_store) AO_INLINE void AO_char_store(volatile unsigned/**/char *addr, unsigned/**/char new_val) { unsigned/**/char old_val; do { old_val = *(unsigned/**/char *)addr; } while (AO_EXPECT_FALSE(!AO_char_compare_and_swap(addr, old_val, new_val))); } # define AO_HAVE_char_store #endif #if defined(AO_HAVE_char_compare_and_swap_release) \ && !defined(AO_HAVE_char_store_release) AO_INLINE void AO_char_store_release(volatile unsigned/**/char *addr, unsigned/**/char new_val) { unsigned/**/char old_val; do { old_val = *(unsigned/**/char *)addr; } while (AO_EXPECT_FALSE(!AO_char_compare_and_swap_release(addr, old_val, new_val))); } # define AO_HAVE_char_store_release #endif #if defined(AO_HAVE_char_compare_and_swap_full) \ && !defined(AO_HAVE_char_store_full) AO_INLINE void AO_char_store_full(volatile unsigned/**/char *addr, unsigned/**/char new_val) { unsigned/**/char old_val; do { old_val = *(unsigned/**/char *)addr; } while (AO_EXPECT_FALSE(!AO_char_compare_and_swap_full(addr, old_val, new_val))); } # define AO_HAVE_char_store_full #endif /* * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ /* short_fetch_compare_and_swap */ #if defined(AO_HAVE_short_fetch_compare_and_swap) \ && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_short_fetch_compare_and_swap_acquire) AO_INLINE unsigned/**/short AO_short_fetch_compare_and_swap_acquire(volatile unsigned/**/short *addr, unsigned/**/short old_val, unsigned/**/short new_val) { unsigned/**/short result = AO_short_fetch_compare_and_swap(addr, old_val, new_val); AO_nop_full(); return result; } # define AO_HAVE_short_fetch_compare_and_swap_acquire #endif #if defined(AO_HAVE_short_fetch_compare_and_swap) \ && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_short_fetch_compare_and_swap_release) # define AO_short_fetch_compare_and_swap_release(addr, old_val, new_val) \ (AO_nop_full(), \ AO_short_fetch_compare_and_swap(addr, old_val, new_val)) # define AO_HAVE_short_fetch_compare_and_swap_release #endif #if defined(AO_HAVE_short_fetch_compare_and_swap_full) # if !defined(AO_HAVE_short_fetch_compare_and_swap_release) # define AO_short_fetch_compare_and_swap_release(addr, old_val, new_val) \ AO_short_fetch_compare_and_swap_full(addr, old_val, new_val) # define AO_HAVE_short_fetch_compare_and_swap_release # endif # if !defined(AO_HAVE_short_fetch_compare_and_swap_acquire) # define AO_short_fetch_compare_and_swap_acquire(addr, old_val, new_val) \ AO_short_fetch_compare_and_swap_full(addr, old_val, new_val) # define AO_HAVE_short_fetch_compare_and_swap_acquire # endif # if !defined(AO_HAVE_short_fetch_compare_and_swap_write) # define AO_short_fetch_compare_and_swap_write(addr, old_val, new_val) \ AO_short_fetch_compare_and_swap_full(addr, old_val, new_val) # define AO_HAVE_short_fetch_compare_and_swap_write # endif # if !defined(AO_HAVE_short_fetch_compare_and_swap_read) # define AO_short_fetch_compare_and_swap_read(addr, old_val, new_val) \ AO_short_fetch_compare_and_swap_full(addr, old_val, new_val) # define AO_HAVE_short_fetch_compare_and_swap_read # endif #endif /* AO_HAVE_short_fetch_compare_and_swap_full */ #if !defined(AO_HAVE_short_fetch_compare_and_swap) \ && defined(AO_HAVE_short_fetch_compare_and_swap_release) # define AO_short_fetch_compare_and_swap(addr, old_val, new_val) \ AO_short_fetch_compare_and_swap_release(addr, old_val, new_val) # define AO_HAVE_short_fetch_compare_and_swap #endif #if !defined(AO_HAVE_short_fetch_compare_and_swap) \ && defined(AO_HAVE_short_fetch_compare_and_swap_acquire) # define AO_short_fetch_compare_and_swap(addr, old_val, new_val) \ AO_short_fetch_compare_and_swap_acquire(addr, old_val, new_val) # define AO_HAVE_short_fetch_compare_and_swap #endif #if !defined(AO_HAVE_short_fetch_compare_and_swap) \ && defined(AO_HAVE_short_fetch_compare_and_swap_write) # define AO_short_fetch_compare_and_swap(addr, old_val, new_val) \ AO_short_fetch_compare_and_swap_write(addr, old_val, new_val) # define AO_HAVE_short_fetch_compare_and_swap #endif #if !defined(AO_HAVE_short_fetch_compare_and_swap) \ && defined(AO_HAVE_short_fetch_compare_and_swap_read) # define AO_short_fetch_compare_and_swap(addr, old_val, new_val) \ AO_short_fetch_compare_and_swap_read(addr, old_val, new_val) # define AO_HAVE_short_fetch_compare_and_swap #endif #if defined(AO_HAVE_short_fetch_compare_and_swap_acquire) \ && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_short_fetch_compare_and_swap_full) # define AO_short_fetch_compare_and_swap_full(addr, old_val, new_val) \ (AO_nop_full(), \ AO_short_fetch_compare_and_swap_acquire(addr, old_val, new_val)) # define AO_HAVE_short_fetch_compare_and_swap_full #endif #if !defined(AO_HAVE_short_fetch_compare_and_swap_release_write) \ && defined(AO_HAVE_short_fetch_compare_and_swap_write) # define AO_short_fetch_compare_and_swap_release_write(addr,old_val,new_val) \ AO_short_fetch_compare_and_swap_write(addr, old_val, new_val) # define AO_HAVE_short_fetch_compare_and_swap_release_write #endif #if !defined(AO_HAVE_short_fetch_compare_and_swap_release_write) \ && defined(AO_HAVE_short_fetch_compare_and_swap_release) # define AO_short_fetch_compare_and_swap_release_write(addr,old_val,new_val) \ AO_short_fetch_compare_and_swap_release(addr, old_val, new_val) # define AO_HAVE_short_fetch_compare_and_swap_release_write #endif #if !defined(AO_HAVE_short_fetch_compare_and_swap_acquire_read) \ && defined(AO_HAVE_short_fetch_compare_and_swap_read) # define AO_short_fetch_compare_and_swap_acquire_read(addr,old_val,new_val) \ AO_short_fetch_compare_and_swap_read(addr, old_val, new_val) # define AO_HAVE_short_fetch_compare_and_swap_acquire_read #endif #if !defined(AO_HAVE_short_fetch_compare_and_swap_acquire_read) \ && defined(AO_HAVE_short_fetch_compare_and_swap_acquire) # define AO_short_fetch_compare_and_swap_acquire_read(addr,old_val,new_val) \ AO_short_fetch_compare_and_swap_acquire(addr, old_val, new_val) # define AO_HAVE_short_fetch_compare_and_swap_acquire_read #endif #ifdef AO_NO_DD_ORDERING # if defined(AO_HAVE_short_fetch_compare_and_swap_acquire_read) # define AO_short_fetch_compare_and_swap_dd_acquire_read(addr,old_val,new_val) \ AO_short_fetch_compare_and_swap_acquire_read(addr, old_val, new_val) # define AO_HAVE_short_fetch_compare_and_swap_dd_acquire_read # endif #else # if defined(AO_HAVE_short_fetch_compare_and_swap) # define AO_short_fetch_compare_and_swap_dd_acquire_read(addr,old_val,new_val) \ AO_short_fetch_compare_and_swap(addr, old_val, new_val) # define AO_HAVE_short_fetch_compare_and_swap_dd_acquire_read # endif #endif /* !AO_NO_DD_ORDERING */ /* short_compare_and_swap */ #if defined(AO_HAVE_short_compare_and_swap) && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_short_compare_and_swap_acquire) AO_INLINE int AO_short_compare_and_swap_acquire(volatile unsigned/**/short *addr, unsigned/**/short old, unsigned/**/short new_val) { int result = AO_short_compare_and_swap(addr, old, new_val); AO_nop_full(); return result; } # define AO_HAVE_short_compare_and_swap_acquire #endif #if defined(AO_HAVE_short_compare_and_swap) && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_short_compare_and_swap_release) # define AO_short_compare_and_swap_release(addr, old, new_val) \ (AO_nop_full(), AO_short_compare_and_swap(addr, old, new_val)) # define AO_HAVE_short_compare_and_swap_release #endif #if defined(AO_HAVE_short_compare_and_swap_full) # if !defined(AO_HAVE_short_compare_and_swap_release) # define AO_short_compare_and_swap_release(addr, old, new_val) \ AO_short_compare_and_swap_full(addr, old, new_val) # define AO_HAVE_short_compare_and_swap_release # endif # if !defined(AO_HAVE_short_compare_and_swap_acquire) # define AO_short_compare_and_swap_acquire(addr, old, new_val) \ AO_short_compare_and_swap_full(addr, old, new_val) # define AO_HAVE_short_compare_and_swap_acquire # endif # if !defined(AO_HAVE_short_compare_and_swap_write) # define AO_short_compare_and_swap_write(addr, old, new_val) \ AO_short_compare_and_swap_full(addr, old, new_val) # define AO_HAVE_short_compare_and_swap_write # endif # if !defined(AO_HAVE_short_compare_and_swap_read) # define AO_short_compare_and_swap_read(addr, old, new_val) \ AO_short_compare_and_swap_full(addr, old, new_val) # define AO_HAVE_short_compare_and_swap_read # endif #endif /* AO_HAVE_short_compare_and_swap_full */ #if !defined(AO_HAVE_short_compare_and_swap) \ && defined(AO_HAVE_short_compare_and_swap_release) # define AO_short_compare_and_swap(addr, old, new_val) \ AO_short_compare_and_swap_release(addr, old, new_val) # define AO_HAVE_short_compare_and_swap #endif #if !defined(AO_HAVE_short_compare_and_swap) \ && defined(AO_HAVE_short_compare_and_swap_acquire) # define AO_short_compare_and_swap(addr, old, new_val) \ AO_short_compare_and_swap_acquire(addr, old, new_val) # define AO_HAVE_short_compare_and_swap #endif #if !defined(AO_HAVE_short_compare_and_swap) \ && defined(AO_HAVE_short_compare_and_swap_write) # define AO_short_compare_and_swap(addr, old, new_val) \ AO_short_compare_and_swap_write(addr, old, new_val) # define AO_HAVE_short_compare_and_swap #endif #if !defined(AO_HAVE_short_compare_and_swap) \ && defined(AO_HAVE_short_compare_and_swap_read) # define AO_short_compare_and_swap(addr, old, new_val) \ AO_short_compare_and_swap_read(addr, old, new_val) # define AO_HAVE_short_compare_and_swap #endif #if defined(AO_HAVE_short_compare_and_swap_acquire) \ && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_short_compare_and_swap_full) # define AO_short_compare_and_swap_full(addr, old, new_val) \ (AO_nop_full(), \ AO_short_compare_and_swap_acquire(addr, old, new_val)) # define AO_HAVE_short_compare_and_swap_full #endif #if !defined(AO_HAVE_short_compare_and_swap_release_write) \ && defined(AO_HAVE_short_compare_and_swap_write) # define AO_short_compare_and_swap_release_write(addr, old, new_val) \ AO_short_compare_and_swap_write(addr, old, new_val) # define AO_HAVE_short_compare_and_swap_release_write #endif #if !defined(AO_HAVE_short_compare_and_swap_release_write) \ && defined(AO_HAVE_short_compare_and_swap_release) # define AO_short_compare_and_swap_release_write(addr, old, new_val) \ AO_short_compare_and_swap_release(addr, old, new_val) # define AO_HAVE_short_compare_and_swap_release_write #endif #if !defined(AO_HAVE_short_compare_and_swap_acquire_read) \ && defined(AO_HAVE_short_compare_and_swap_read) # define AO_short_compare_and_swap_acquire_read(addr, old, new_val) \ AO_short_compare_and_swap_read(addr, old, new_val) # define AO_HAVE_short_compare_and_swap_acquire_read #endif #if !defined(AO_HAVE_short_compare_and_swap_acquire_read) \ && defined(AO_HAVE_short_compare_and_swap_acquire) # define AO_short_compare_and_swap_acquire_read(addr, old, new_val) \ AO_short_compare_and_swap_acquire(addr, old, new_val) # define AO_HAVE_short_compare_and_swap_acquire_read #endif #ifdef AO_NO_DD_ORDERING # if defined(AO_HAVE_short_compare_and_swap_acquire_read) # define AO_short_compare_and_swap_dd_acquire_read(addr, old, new_val) \ AO_short_compare_and_swap_acquire_read(addr, old, new_val) # define AO_HAVE_short_compare_and_swap_dd_acquire_read # endif #else # if defined(AO_HAVE_short_compare_and_swap) # define AO_short_compare_and_swap_dd_acquire_read(addr, old, new_val) \ AO_short_compare_and_swap(addr, old, new_val) # define AO_HAVE_short_compare_and_swap_dd_acquire_read # endif #endif /* !AO_NO_DD_ORDERING */ /* short_load */ #if defined(AO_HAVE_short_load_full) && !defined(AO_HAVE_short_load_acquire) # define AO_short_load_acquire(addr) AO_short_load_full(addr) # define AO_HAVE_short_load_acquire #endif #if defined(AO_HAVE_short_load_acquire) && !defined(AO_HAVE_short_load) # define AO_short_load(addr) AO_short_load_acquire(addr) # define AO_HAVE_short_load #endif #if defined(AO_HAVE_short_load_full) && !defined(AO_HAVE_short_load_read) # define AO_short_load_read(addr) AO_short_load_full(addr) # define AO_HAVE_short_load_read #endif #if !defined(AO_HAVE_short_load_acquire_read) \ && defined(AO_HAVE_short_load_acquire) # define AO_short_load_acquire_read(addr) AO_short_load_acquire(addr) # define AO_HAVE_short_load_acquire_read #endif #if defined(AO_HAVE_short_load) && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_short_load_acquire) AO_INLINE unsigned/**/short AO_short_load_acquire(const volatile unsigned/**/short *addr) { unsigned/**/short result = AO_short_load(addr); /* Acquire barrier would be useless, since the load could be delayed */ /* beyond it. */ AO_nop_full(); return result; } # define AO_HAVE_short_load_acquire #endif #if defined(AO_HAVE_short_load) && defined(AO_HAVE_nop_read) \ && !defined(AO_HAVE_short_load_read) AO_INLINE unsigned/**/short AO_short_load_read(const volatile unsigned/**/short *addr) { unsigned/**/short result = AO_short_load(addr); AO_nop_read(); return result; } # define AO_HAVE_short_load_read #endif #if defined(AO_HAVE_short_load_acquire) && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_short_load_full) # define AO_short_load_full(addr) (AO_nop_full(), AO_short_load_acquire(addr)) # define AO_HAVE_short_load_full #endif #if defined(AO_HAVE_short_compare_and_swap_read) \ && !defined(AO_HAVE_short_load_read) # define AO_short_CAS_BASED_LOAD_READ AO_INLINE unsigned/**/short AO_short_load_read(const volatile unsigned/**/short *addr) { unsigned/**/short result; do { result = *(const unsigned/**/short *)addr; } while (AO_EXPECT_FALSE(!AO_short_compare_and_swap_read( (volatile unsigned/**/short *)addr, result, result))); return result; } # define AO_HAVE_short_load_read #endif #if !defined(AO_HAVE_short_load_acquire_read) \ && defined(AO_HAVE_short_load_read) # define AO_short_load_acquire_read(addr) AO_short_load_read(addr) # define AO_HAVE_short_load_acquire_read #endif #if defined(AO_HAVE_short_load_acquire_read) && !defined(AO_HAVE_short_load) \ && (!defined(AO_short_CAS_BASED_LOAD_READ) \ || !defined(AO_HAVE_short_compare_and_swap)) # define AO_short_load(addr) AO_short_load_acquire_read(addr) # define AO_HAVE_short_load #endif #if defined(AO_HAVE_short_compare_and_swap_full) \ && !defined(AO_HAVE_short_load_full) AO_INLINE unsigned/**/short AO_short_load_full(const volatile unsigned/**/short *addr) { unsigned/**/short result; do { result = *(const unsigned/**/short *)addr; } while (AO_EXPECT_FALSE(!AO_short_compare_and_swap_full( (volatile unsigned/**/short *)addr, result, result))); return result; } # define AO_HAVE_short_load_full #endif #if defined(AO_HAVE_short_compare_and_swap_acquire) \ && !defined(AO_HAVE_short_load_acquire) AO_INLINE unsigned/**/short AO_short_load_acquire(const volatile unsigned/**/short *addr) { unsigned/**/short result; do { result = *(const unsigned/**/short *)addr; } while (AO_EXPECT_FALSE(!AO_short_compare_and_swap_acquire( (volatile unsigned/**/short *)addr, result, result))); return result; } # define AO_HAVE_short_load_acquire #endif #if defined(AO_HAVE_short_compare_and_swap) && !defined(AO_HAVE_short_load) AO_INLINE unsigned/**/short AO_short_load(const volatile unsigned/**/short *addr) { unsigned/**/short result; do { result = *(const unsigned/**/short *)addr; } while (AO_EXPECT_FALSE(!AO_short_compare_and_swap( (volatile unsigned/**/short *)addr, result, result))); return result; } # define AO_HAVE_short_load #endif #ifdef AO_NO_DD_ORDERING # if defined(AO_HAVE_short_load_acquire_read) # define AO_short_load_dd_acquire_read(addr) \ AO_short_load_acquire_read(addr) # define AO_HAVE_short_load_dd_acquire_read # endif #else # if defined(AO_HAVE_short_load) # define AO_short_load_dd_acquire_read(addr) AO_short_load(addr) # define AO_HAVE_short_load_dd_acquire_read # endif #endif /* !AO_NO_DD_ORDERING */ /* short_store */ #if defined(AO_HAVE_short_store_full) && !defined(AO_HAVE_short_store_release) # define AO_short_store_release(addr, val) AO_short_store_full(addr, val) # define AO_HAVE_short_store_release #endif #if defined(AO_HAVE_short_store_release) && !defined(AO_HAVE_short_store) # define AO_short_store(addr, val) AO_short_store_release(addr, val) # define AO_HAVE_short_store #endif #if defined(AO_HAVE_short_store_full) && !defined(AO_HAVE_short_store_write) # define AO_short_store_write(addr, val) AO_short_store_full(addr, val) # define AO_HAVE_short_store_write #endif #if defined(AO_HAVE_short_store_release) \ && !defined(AO_HAVE_short_store_release_write) # define AO_short_store_release_write(addr, val) \ AO_short_store_release(addr, val) # define AO_HAVE_short_store_release_write #endif #if defined(AO_HAVE_short_store_write) && !defined(AO_HAVE_short_store) # define AO_short_store(addr, val) AO_short_store_write(addr, val) # define AO_HAVE_short_store #endif #if defined(AO_HAVE_short_store) && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_short_store_release) # define AO_short_store_release(addr, val) \ (AO_nop_full(), AO_short_store(addr, val)) # define AO_HAVE_short_store_release #endif #if defined(AO_HAVE_short_store) && defined(AO_HAVE_nop_write) \ && !defined(AO_HAVE_short_store_write) # define AO_short_store_write(addr, val) \ (AO_nop_write(), AO_short_store(addr, val)) # define AO_HAVE_short_store_write #endif #if defined(AO_HAVE_short_compare_and_swap_write) \ && !defined(AO_HAVE_short_store_write) AO_INLINE void AO_short_store_write(volatile unsigned/**/short *addr, unsigned/**/short new_val) { unsigned/**/short old_val; do { old_val = *(unsigned/**/short *)addr; } while (AO_EXPECT_FALSE(!AO_short_compare_and_swap_write(addr, old_val, new_val))); } # define AO_HAVE_short_store_write #endif #if defined(AO_HAVE_short_store_write) \ && !defined(AO_HAVE_short_store_release_write) # define AO_short_store_release_write(addr, val) \ AO_short_store_write(addr, val) # define AO_HAVE_short_store_release_write #endif #if defined(AO_HAVE_short_store_release) && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_short_store_full) # define AO_short_store_full(addr, val) \ (AO_short_store_release(addr, val), \ AO_nop_full()) # define AO_HAVE_short_store_full #endif #if defined(AO_HAVE_short_compare_and_swap) && !defined(AO_HAVE_short_store) AO_INLINE void AO_short_store(volatile unsigned/**/short *addr, unsigned/**/short new_val) { unsigned/**/short old_val; do { old_val = *(unsigned/**/short *)addr; } while (AO_EXPECT_FALSE(!AO_short_compare_and_swap(addr, old_val, new_val))); } # define AO_HAVE_short_store #endif #if defined(AO_HAVE_short_compare_and_swap_release) \ && !defined(AO_HAVE_short_store_release) AO_INLINE void AO_short_store_release(volatile unsigned/**/short *addr, unsigned/**/short new_val) { unsigned/**/short old_val; do { old_val = *(unsigned/**/short *)addr; } while (AO_EXPECT_FALSE(!AO_short_compare_and_swap_release(addr, old_val, new_val))); } # define AO_HAVE_short_store_release #endif #if defined(AO_HAVE_short_compare_and_swap_full) \ && !defined(AO_HAVE_short_store_full) AO_INLINE void AO_short_store_full(volatile unsigned/**/short *addr, unsigned/**/short new_val) { unsigned/**/short old_val; do { old_val = *(unsigned/**/short *)addr; } while (AO_EXPECT_FALSE(!AO_short_compare_and_swap_full(addr, old_val, new_val))); } # define AO_HAVE_short_store_full #endif /* * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ /* int_fetch_compare_and_swap */ #if defined(AO_HAVE_int_fetch_compare_and_swap) \ && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_int_fetch_compare_and_swap_acquire) AO_INLINE unsigned AO_int_fetch_compare_and_swap_acquire(volatile unsigned *addr, unsigned old_val, unsigned new_val) { unsigned result = AO_int_fetch_compare_and_swap(addr, old_val, new_val); AO_nop_full(); return result; } # define AO_HAVE_int_fetch_compare_and_swap_acquire #endif #if defined(AO_HAVE_int_fetch_compare_and_swap) \ && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_int_fetch_compare_and_swap_release) # define AO_int_fetch_compare_and_swap_release(addr, old_val, new_val) \ (AO_nop_full(), \ AO_int_fetch_compare_and_swap(addr, old_val, new_val)) # define AO_HAVE_int_fetch_compare_and_swap_release #endif #if defined(AO_HAVE_int_fetch_compare_and_swap_full) # if !defined(AO_HAVE_int_fetch_compare_and_swap_release) # define AO_int_fetch_compare_and_swap_release(addr, old_val, new_val) \ AO_int_fetch_compare_and_swap_full(addr, old_val, new_val) # define AO_HAVE_int_fetch_compare_and_swap_release # endif # if !defined(AO_HAVE_int_fetch_compare_and_swap_acquire) # define AO_int_fetch_compare_and_swap_acquire(addr, old_val, new_val) \ AO_int_fetch_compare_and_swap_full(addr, old_val, new_val) # define AO_HAVE_int_fetch_compare_and_swap_acquire # endif # if !defined(AO_HAVE_int_fetch_compare_and_swap_write) # define AO_int_fetch_compare_and_swap_write(addr, old_val, new_val) \ AO_int_fetch_compare_and_swap_full(addr, old_val, new_val) # define AO_HAVE_int_fetch_compare_and_swap_write # endif # if !defined(AO_HAVE_int_fetch_compare_and_swap_read) # define AO_int_fetch_compare_and_swap_read(addr, old_val, new_val) \ AO_int_fetch_compare_and_swap_full(addr, old_val, new_val) # define AO_HAVE_int_fetch_compare_and_swap_read # endif #endif /* AO_HAVE_int_fetch_compare_and_swap_full */ #if !defined(AO_HAVE_int_fetch_compare_and_swap) \ && defined(AO_HAVE_int_fetch_compare_and_swap_release) # define AO_int_fetch_compare_and_swap(addr, old_val, new_val) \ AO_int_fetch_compare_and_swap_release(addr, old_val, new_val) # define AO_HAVE_int_fetch_compare_and_swap #endif #if !defined(AO_HAVE_int_fetch_compare_and_swap) \ && defined(AO_HAVE_int_fetch_compare_and_swap_acquire) # define AO_int_fetch_compare_and_swap(addr, old_val, new_val) \ AO_int_fetch_compare_and_swap_acquire(addr, old_val, new_val) # define AO_HAVE_int_fetch_compare_and_swap #endif #if !defined(AO_HAVE_int_fetch_compare_and_swap) \ && defined(AO_HAVE_int_fetch_compare_and_swap_write) # define AO_int_fetch_compare_and_swap(addr, old_val, new_val) \ AO_int_fetch_compare_and_swap_write(addr, old_val, new_val) # define AO_HAVE_int_fetch_compare_and_swap #endif #if !defined(AO_HAVE_int_fetch_compare_and_swap) \ && defined(AO_HAVE_int_fetch_compare_and_swap_read) # define AO_int_fetch_compare_and_swap(addr, old_val, new_val) \ AO_int_fetch_compare_and_swap_read(addr, old_val, new_val) # define AO_HAVE_int_fetch_compare_and_swap #endif #if defined(AO_HAVE_int_fetch_compare_and_swap_acquire) \ && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_int_fetch_compare_and_swap_full) # define AO_int_fetch_compare_and_swap_full(addr, old_val, new_val) \ (AO_nop_full(), \ AO_int_fetch_compare_and_swap_acquire(addr, old_val, new_val)) # define AO_HAVE_int_fetch_compare_and_swap_full #endif #if !defined(AO_HAVE_int_fetch_compare_and_swap_release_write) \ && defined(AO_HAVE_int_fetch_compare_and_swap_write) # define AO_int_fetch_compare_and_swap_release_write(addr,old_val,new_val) \ AO_int_fetch_compare_and_swap_write(addr, old_val, new_val) # define AO_HAVE_int_fetch_compare_and_swap_release_write #endif #if !defined(AO_HAVE_int_fetch_compare_and_swap_release_write) \ && defined(AO_HAVE_int_fetch_compare_and_swap_release) # define AO_int_fetch_compare_and_swap_release_write(addr,old_val,new_val) \ AO_int_fetch_compare_and_swap_release(addr, old_val, new_val) # define AO_HAVE_int_fetch_compare_and_swap_release_write #endif #if !defined(AO_HAVE_int_fetch_compare_and_swap_acquire_read) \ && defined(AO_HAVE_int_fetch_compare_and_swap_read) # define AO_int_fetch_compare_and_swap_acquire_read(addr,old_val,new_val) \ AO_int_fetch_compare_and_swap_read(addr, old_val, new_val) # define AO_HAVE_int_fetch_compare_and_swap_acquire_read #endif #if !defined(AO_HAVE_int_fetch_compare_and_swap_acquire_read) \ && defined(AO_HAVE_int_fetch_compare_and_swap_acquire) # define AO_int_fetch_compare_and_swap_acquire_read(addr,old_val,new_val) \ AO_int_fetch_compare_and_swap_acquire(addr, old_val, new_val) # define AO_HAVE_int_fetch_compare_and_swap_acquire_read #endif #ifdef AO_NO_DD_ORDERING # if defined(AO_HAVE_int_fetch_compare_and_swap_acquire_read) # define AO_int_fetch_compare_and_swap_dd_acquire_read(addr,old_val,new_val) \ AO_int_fetch_compare_and_swap_acquire_read(addr, old_val, new_val) # define AO_HAVE_int_fetch_compare_and_swap_dd_acquire_read # endif #else # if defined(AO_HAVE_int_fetch_compare_and_swap) # define AO_int_fetch_compare_and_swap_dd_acquire_read(addr,old_val,new_val) \ AO_int_fetch_compare_and_swap(addr, old_val, new_val) # define AO_HAVE_int_fetch_compare_and_swap_dd_acquire_read # endif #endif /* !AO_NO_DD_ORDERING */ /* int_compare_and_swap */ #if defined(AO_HAVE_int_compare_and_swap) && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_int_compare_and_swap_acquire) AO_INLINE int AO_int_compare_and_swap_acquire(volatile unsigned *addr, unsigned old, unsigned new_val) { int result = AO_int_compare_and_swap(addr, old, new_val); AO_nop_full(); return result; } # define AO_HAVE_int_compare_and_swap_acquire #endif #if defined(AO_HAVE_int_compare_and_swap) && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_int_compare_and_swap_release) # define AO_int_compare_and_swap_release(addr, old, new_val) \ (AO_nop_full(), AO_int_compare_and_swap(addr, old, new_val)) # define AO_HAVE_int_compare_and_swap_release #endif #if defined(AO_HAVE_int_compare_and_swap_full) # if !defined(AO_HAVE_int_compare_and_swap_release) # define AO_int_compare_and_swap_release(addr, old, new_val) \ AO_int_compare_and_swap_full(addr, old, new_val) # define AO_HAVE_int_compare_and_swap_release # endif # if !defined(AO_HAVE_int_compare_and_swap_acquire) # define AO_int_compare_and_swap_acquire(addr, old, new_val) \ AO_int_compare_and_swap_full(addr, old, new_val) # define AO_HAVE_int_compare_and_swap_acquire # endif # if !defined(AO_HAVE_int_compare_and_swap_write) # define AO_int_compare_and_swap_write(addr, old, new_val) \ AO_int_compare_and_swap_full(addr, old, new_val) # define AO_HAVE_int_compare_and_swap_write # endif # if !defined(AO_HAVE_int_compare_and_swap_read) # define AO_int_compare_and_swap_read(addr, old, new_val) \ AO_int_compare_and_swap_full(addr, old, new_val) # define AO_HAVE_int_compare_and_swap_read # endif #endif /* AO_HAVE_int_compare_and_swap_full */ #if !defined(AO_HAVE_int_compare_and_swap) \ && defined(AO_HAVE_int_compare_and_swap_release) # define AO_int_compare_and_swap(addr, old, new_val) \ AO_int_compare_and_swap_release(addr, old, new_val) # define AO_HAVE_int_compare_and_swap #endif #if !defined(AO_HAVE_int_compare_and_swap) \ && defined(AO_HAVE_int_compare_and_swap_acquire) # define AO_int_compare_and_swap(addr, old, new_val) \ AO_int_compare_and_swap_acquire(addr, old, new_val) # define AO_HAVE_int_compare_and_swap #endif #if !defined(AO_HAVE_int_compare_and_swap) \ && defined(AO_HAVE_int_compare_and_swap_write) # define AO_int_compare_and_swap(addr, old, new_val) \ AO_int_compare_and_swap_write(addr, old, new_val) # define AO_HAVE_int_compare_and_swap #endif #if !defined(AO_HAVE_int_compare_and_swap) \ && defined(AO_HAVE_int_compare_and_swap_read) # define AO_int_compare_and_swap(addr, old, new_val) \ AO_int_compare_and_swap_read(addr, old, new_val) # define AO_HAVE_int_compare_and_swap #endif #if defined(AO_HAVE_int_compare_and_swap_acquire) \ && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_int_compare_and_swap_full) # define AO_int_compare_and_swap_full(addr, old, new_val) \ (AO_nop_full(), \ AO_int_compare_and_swap_acquire(addr, old, new_val)) # define AO_HAVE_int_compare_and_swap_full #endif #if !defined(AO_HAVE_int_compare_and_swap_release_write) \ && defined(AO_HAVE_int_compare_and_swap_write) # define AO_int_compare_and_swap_release_write(addr, old, new_val) \ AO_int_compare_and_swap_write(addr, old, new_val) # define AO_HAVE_int_compare_and_swap_release_write #endif #if !defined(AO_HAVE_int_compare_and_swap_release_write) \ && defined(AO_HAVE_int_compare_and_swap_release) # define AO_int_compare_and_swap_release_write(addr, old, new_val) \ AO_int_compare_and_swap_release(addr, old, new_val) # define AO_HAVE_int_compare_and_swap_release_write #endif #if !defined(AO_HAVE_int_compare_and_swap_acquire_read) \ && defined(AO_HAVE_int_compare_and_swap_read) # define AO_int_compare_and_swap_acquire_read(addr, old, new_val) \ AO_int_compare_and_swap_read(addr, old, new_val) # define AO_HAVE_int_compare_and_swap_acquire_read #endif #if !defined(AO_HAVE_int_compare_and_swap_acquire_read) \ && defined(AO_HAVE_int_compare_and_swap_acquire) # define AO_int_compare_and_swap_acquire_read(addr, old, new_val) \ AO_int_compare_and_swap_acquire(addr, old, new_val) # define AO_HAVE_int_compare_and_swap_acquire_read #endif #ifdef AO_NO_DD_ORDERING # if defined(AO_HAVE_int_compare_and_swap_acquire_read) # define AO_int_compare_and_swap_dd_acquire_read(addr, old, new_val) \ AO_int_compare_and_swap_acquire_read(addr, old, new_val) # define AO_HAVE_int_compare_and_swap_dd_acquire_read # endif #else # if defined(AO_HAVE_int_compare_and_swap) # define AO_int_compare_and_swap_dd_acquire_read(addr, old, new_val) \ AO_int_compare_and_swap(addr, old, new_val) # define AO_HAVE_int_compare_and_swap_dd_acquire_read # endif #endif /* !AO_NO_DD_ORDERING */ /* int_load */ #if defined(AO_HAVE_int_load_full) && !defined(AO_HAVE_int_load_acquire) # define AO_int_load_acquire(addr) AO_int_load_full(addr) # define AO_HAVE_int_load_acquire #endif #if defined(AO_HAVE_int_load_acquire) && !defined(AO_HAVE_int_load) # define AO_int_load(addr) AO_int_load_acquire(addr) # define AO_HAVE_int_load #endif #if defined(AO_HAVE_int_load_full) && !defined(AO_HAVE_int_load_read) # define AO_int_load_read(addr) AO_int_load_full(addr) # define AO_HAVE_int_load_read #endif #if !defined(AO_HAVE_int_load_acquire_read) \ && defined(AO_HAVE_int_load_acquire) # define AO_int_load_acquire_read(addr) AO_int_load_acquire(addr) # define AO_HAVE_int_load_acquire_read #endif #if defined(AO_HAVE_int_load) && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_int_load_acquire) AO_INLINE unsigned AO_int_load_acquire(const volatile unsigned *addr) { unsigned result = AO_int_load(addr); /* Acquire barrier would be useless, since the load could be delayed */ /* beyond it. */ AO_nop_full(); return result; } # define AO_HAVE_int_load_acquire #endif #if defined(AO_HAVE_int_load) && defined(AO_HAVE_nop_read) \ && !defined(AO_HAVE_int_load_read) AO_INLINE unsigned AO_int_load_read(const volatile unsigned *addr) { unsigned result = AO_int_load(addr); AO_nop_read(); return result; } # define AO_HAVE_int_load_read #endif #if defined(AO_HAVE_int_load_acquire) && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_int_load_full) # define AO_int_load_full(addr) (AO_nop_full(), AO_int_load_acquire(addr)) # define AO_HAVE_int_load_full #endif #if defined(AO_HAVE_int_compare_and_swap_read) \ && !defined(AO_HAVE_int_load_read) # define AO_int_CAS_BASED_LOAD_READ AO_INLINE unsigned AO_int_load_read(const volatile unsigned *addr) { unsigned result; do { result = *(const unsigned *)addr; } while (AO_EXPECT_FALSE(!AO_int_compare_and_swap_read( (volatile unsigned *)addr, result, result))); return result; } # define AO_HAVE_int_load_read #endif #if !defined(AO_HAVE_int_load_acquire_read) \ && defined(AO_HAVE_int_load_read) # define AO_int_load_acquire_read(addr) AO_int_load_read(addr) # define AO_HAVE_int_load_acquire_read #endif #if defined(AO_HAVE_int_load_acquire_read) && !defined(AO_HAVE_int_load) \ && (!defined(AO_int_CAS_BASED_LOAD_READ) \ || !defined(AO_HAVE_int_compare_and_swap)) # define AO_int_load(addr) AO_int_load_acquire_read(addr) # define AO_HAVE_int_load #endif #if defined(AO_HAVE_int_compare_and_swap_full) \ && !defined(AO_HAVE_int_load_full) AO_INLINE unsigned AO_int_load_full(const volatile unsigned *addr) { unsigned result; do { result = *(const unsigned *)addr; } while (AO_EXPECT_FALSE(!AO_int_compare_and_swap_full( (volatile unsigned *)addr, result, result))); return result; } # define AO_HAVE_int_load_full #endif #if defined(AO_HAVE_int_compare_and_swap_acquire) \ && !defined(AO_HAVE_int_load_acquire) AO_INLINE unsigned AO_int_load_acquire(const volatile unsigned *addr) { unsigned result; do { result = *(const unsigned *)addr; } while (AO_EXPECT_FALSE(!AO_int_compare_and_swap_acquire( (volatile unsigned *)addr, result, result))); return result; } # define AO_HAVE_int_load_acquire #endif #if defined(AO_HAVE_int_compare_and_swap) && !defined(AO_HAVE_int_load) AO_INLINE unsigned AO_int_load(const volatile unsigned *addr) { unsigned result; do { result = *(const unsigned *)addr; } while (AO_EXPECT_FALSE(!AO_int_compare_and_swap( (volatile unsigned *)addr, result, result))); return result; } # define AO_HAVE_int_load #endif #ifdef AO_NO_DD_ORDERING # if defined(AO_HAVE_int_load_acquire_read) # define AO_int_load_dd_acquire_read(addr) \ AO_int_load_acquire_read(addr) # define AO_HAVE_int_load_dd_acquire_read # endif #else # if defined(AO_HAVE_int_load) # define AO_int_load_dd_acquire_read(addr) AO_int_load(addr) # define AO_HAVE_int_load_dd_acquire_read # endif #endif /* !AO_NO_DD_ORDERING */ /* int_store */ #if defined(AO_HAVE_int_store_full) && !defined(AO_HAVE_int_store_release) # define AO_int_store_release(addr, val) AO_int_store_full(addr, val) # define AO_HAVE_int_store_release #endif #if defined(AO_HAVE_int_store_release) && !defined(AO_HAVE_int_store) # define AO_int_store(addr, val) AO_int_store_release(addr, val) # define AO_HAVE_int_store #endif #if defined(AO_HAVE_int_store_full) && !defined(AO_HAVE_int_store_write) # define AO_int_store_write(addr, val) AO_int_store_full(addr, val) # define AO_HAVE_int_store_write #endif #if defined(AO_HAVE_int_store_release) \ && !defined(AO_HAVE_int_store_release_write) # define AO_int_store_release_write(addr, val) \ AO_int_store_release(addr, val) # define AO_HAVE_int_store_release_write #endif #if defined(AO_HAVE_int_store_write) && !defined(AO_HAVE_int_store) # define AO_int_store(addr, val) AO_int_store_write(addr, val) # define AO_HAVE_int_store #endif #if defined(AO_HAVE_int_store) && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_int_store_release) # define AO_int_store_release(addr, val) \ (AO_nop_full(), AO_int_store(addr, val)) # define AO_HAVE_int_store_release #endif #if defined(AO_HAVE_int_store) && defined(AO_HAVE_nop_write) \ && !defined(AO_HAVE_int_store_write) # define AO_int_store_write(addr, val) \ (AO_nop_write(), AO_int_store(addr, val)) # define AO_HAVE_int_store_write #endif #if defined(AO_HAVE_int_compare_and_swap_write) \ && !defined(AO_HAVE_int_store_write) AO_INLINE void AO_int_store_write(volatile unsigned *addr, unsigned new_val) { unsigned old_val; do { old_val = *(unsigned *)addr; } while (AO_EXPECT_FALSE(!AO_int_compare_and_swap_write(addr, old_val, new_val))); } # define AO_HAVE_int_store_write #endif #if defined(AO_HAVE_int_store_write) \ && !defined(AO_HAVE_int_store_release_write) # define AO_int_store_release_write(addr, val) \ AO_int_store_write(addr, val) # define AO_HAVE_int_store_release_write #endif #if defined(AO_HAVE_int_store_release) && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_int_store_full) # define AO_int_store_full(addr, val) \ (AO_int_store_release(addr, val), \ AO_nop_full()) # define AO_HAVE_int_store_full #endif #if defined(AO_HAVE_int_compare_and_swap) && !defined(AO_HAVE_int_store) AO_INLINE void AO_int_store(volatile unsigned *addr, unsigned new_val) { unsigned old_val; do { old_val = *(unsigned *)addr; } while (AO_EXPECT_FALSE(!AO_int_compare_and_swap(addr, old_val, new_val))); } # define AO_HAVE_int_store #endif #if defined(AO_HAVE_int_compare_and_swap_release) \ && !defined(AO_HAVE_int_store_release) AO_INLINE void AO_int_store_release(volatile unsigned *addr, unsigned new_val) { unsigned old_val; do { old_val = *(unsigned *)addr; } while (AO_EXPECT_FALSE(!AO_int_compare_and_swap_release(addr, old_val, new_val))); } # define AO_HAVE_int_store_release #endif #if defined(AO_HAVE_int_compare_and_swap_full) \ && !defined(AO_HAVE_int_store_full) AO_INLINE void AO_int_store_full(volatile unsigned *addr, unsigned new_val) { unsigned old_val; do { old_val = *(unsigned *)addr; } while (AO_EXPECT_FALSE(!AO_int_compare_and_swap_full(addr, old_val, new_val))); } # define AO_HAVE_int_store_full #endif /* * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ /* fetch_compare_and_swap */ #if defined(AO_HAVE_fetch_compare_and_swap) \ && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_fetch_compare_and_swap_acquire) AO_INLINE AO_t AO_fetch_compare_and_swap_acquire(volatile AO_t *addr, AO_t old_val, AO_t new_val) { AO_t result = AO_fetch_compare_and_swap(addr, old_val, new_val); AO_nop_full(); return result; } # define AO_HAVE_fetch_compare_and_swap_acquire #endif #if defined(AO_HAVE_fetch_compare_and_swap) \ && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_fetch_compare_and_swap_release) # define AO_fetch_compare_and_swap_release(addr, old_val, new_val) \ (AO_nop_full(), \ AO_fetch_compare_and_swap(addr, old_val, new_val)) # define AO_HAVE_fetch_compare_and_swap_release #endif #if defined(AO_HAVE_fetch_compare_and_swap_full) # if !defined(AO_HAVE_fetch_compare_and_swap_release) # define AO_fetch_compare_and_swap_release(addr, old_val, new_val) \ AO_fetch_compare_and_swap_full(addr, old_val, new_val) # define AO_HAVE_fetch_compare_and_swap_release # endif # if !defined(AO_HAVE_fetch_compare_and_swap_acquire) # define AO_fetch_compare_and_swap_acquire(addr, old_val, new_val) \ AO_fetch_compare_and_swap_full(addr, old_val, new_val) # define AO_HAVE_fetch_compare_and_swap_acquire # endif # if !defined(AO_HAVE_fetch_compare_and_swap_write) # define AO_fetch_compare_and_swap_write(addr, old_val, new_val) \ AO_fetch_compare_and_swap_full(addr, old_val, new_val) # define AO_HAVE_fetch_compare_and_swap_write # endif # if !defined(AO_HAVE_fetch_compare_and_swap_read) # define AO_fetch_compare_and_swap_read(addr, old_val, new_val) \ AO_fetch_compare_and_swap_full(addr, old_val, new_val) # define AO_HAVE_fetch_compare_and_swap_read # endif #endif /* AO_HAVE_fetch_compare_and_swap_full */ #if !defined(AO_HAVE_fetch_compare_and_swap) \ && defined(AO_HAVE_fetch_compare_and_swap_release) # define AO_fetch_compare_and_swap(addr, old_val, new_val) \ AO_fetch_compare_and_swap_release(addr, old_val, new_val) # define AO_HAVE_fetch_compare_and_swap #endif #if !defined(AO_HAVE_fetch_compare_and_swap) \ && defined(AO_HAVE_fetch_compare_and_swap_acquire) # define AO_fetch_compare_and_swap(addr, old_val, new_val) \ AO_fetch_compare_and_swap_acquire(addr, old_val, new_val) # define AO_HAVE_fetch_compare_and_swap #endif #if !defined(AO_HAVE_fetch_compare_and_swap) \ && defined(AO_HAVE_fetch_compare_and_swap_write) # define AO_fetch_compare_and_swap(addr, old_val, new_val) \ AO_fetch_compare_and_swap_write(addr, old_val, new_val) # define AO_HAVE_fetch_compare_and_swap #endif #if !defined(AO_HAVE_fetch_compare_and_swap) \ && defined(AO_HAVE_fetch_compare_and_swap_read) # define AO_fetch_compare_and_swap(addr, old_val, new_val) \ AO_fetch_compare_and_swap_read(addr, old_val, new_val) # define AO_HAVE_fetch_compare_and_swap #endif #if defined(AO_HAVE_fetch_compare_and_swap_acquire) \ && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_fetch_compare_and_swap_full) # define AO_fetch_compare_and_swap_full(addr, old_val, new_val) \ (AO_nop_full(), \ AO_fetch_compare_and_swap_acquire(addr, old_val, new_val)) # define AO_HAVE_fetch_compare_and_swap_full #endif #if !defined(AO_HAVE_fetch_compare_and_swap_release_write) \ && defined(AO_HAVE_fetch_compare_and_swap_write) # define AO_fetch_compare_and_swap_release_write(addr,old_val,new_val) \ AO_fetch_compare_and_swap_write(addr, old_val, new_val) # define AO_HAVE_fetch_compare_and_swap_release_write #endif #if !defined(AO_HAVE_fetch_compare_and_swap_release_write) \ && defined(AO_HAVE_fetch_compare_and_swap_release) # define AO_fetch_compare_and_swap_release_write(addr,old_val,new_val) \ AO_fetch_compare_and_swap_release(addr, old_val, new_val) # define AO_HAVE_fetch_compare_and_swap_release_write #endif #if !defined(AO_HAVE_fetch_compare_and_swap_acquire_read) \ && defined(AO_HAVE_fetch_compare_and_swap_read) # define AO_fetch_compare_and_swap_acquire_read(addr,old_val,new_val) \ AO_fetch_compare_and_swap_read(addr, old_val, new_val) # define AO_HAVE_fetch_compare_and_swap_acquire_read #endif #if !defined(AO_HAVE_fetch_compare_and_swap_acquire_read) \ && defined(AO_HAVE_fetch_compare_and_swap_acquire) # define AO_fetch_compare_and_swap_acquire_read(addr,old_val,new_val) \ AO_fetch_compare_and_swap_acquire(addr, old_val, new_val) # define AO_HAVE_fetch_compare_and_swap_acquire_read #endif #ifdef AO_NO_DD_ORDERING # if defined(AO_HAVE_fetch_compare_and_swap_acquire_read) # define AO_fetch_compare_and_swap_dd_acquire_read(addr,old_val,new_val) \ AO_fetch_compare_and_swap_acquire_read(addr, old_val, new_val) # define AO_HAVE_fetch_compare_and_swap_dd_acquire_read # endif #else # if defined(AO_HAVE_fetch_compare_and_swap) # define AO_fetch_compare_and_swap_dd_acquire_read(addr,old_val,new_val) \ AO_fetch_compare_and_swap(addr, old_val, new_val) # define AO_HAVE_fetch_compare_and_swap_dd_acquire_read # endif #endif /* !AO_NO_DD_ORDERING */ /* compare_and_swap */ #if defined(AO_HAVE_compare_and_swap) && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_compare_and_swap_acquire) AO_INLINE int AO_compare_and_swap_acquire(volatile AO_t *addr, AO_t old, AO_t new_val) { int result = AO_compare_and_swap(addr, old, new_val); AO_nop_full(); return result; } # define AO_HAVE_compare_and_swap_acquire #endif #if defined(AO_HAVE_compare_and_swap) && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_compare_and_swap_release) # define AO_compare_and_swap_release(addr, old, new_val) \ (AO_nop_full(), AO_compare_and_swap(addr, old, new_val)) # define AO_HAVE_compare_and_swap_release #endif #if defined(AO_HAVE_compare_and_swap_full) # if !defined(AO_HAVE_compare_and_swap_release) # define AO_compare_and_swap_release(addr, old, new_val) \ AO_compare_and_swap_full(addr, old, new_val) # define AO_HAVE_compare_and_swap_release # endif # if !defined(AO_HAVE_compare_and_swap_acquire) # define AO_compare_and_swap_acquire(addr, old, new_val) \ AO_compare_and_swap_full(addr, old, new_val) # define AO_HAVE_compare_and_swap_acquire # endif # if !defined(AO_HAVE_compare_and_swap_write) # define AO_compare_and_swap_write(addr, old, new_val) \ AO_compare_and_swap_full(addr, old, new_val) # define AO_HAVE_compare_and_swap_write # endif # if !defined(AO_HAVE_compare_and_swap_read) # define AO_compare_and_swap_read(addr, old, new_val) \ AO_compare_and_swap_full(addr, old, new_val) # define AO_HAVE_compare_and_swap_read # endif #endif /* AO_HAVE_compare_and_swap_full */ #if !defined(AO_HAVE_compare_and_swap) \ && defined(AO_HAVE_compare_and_swap_release) # define AO_compare_and_swap(addr, old, new_val) \ AO_compare_and_swap_release(addr, old, new_val) # define AO_HAVE_compare_and_swap #endif #if !defined(AO_HAVE_compare_and_swap) \ && defined(AO_HAVE_compare_and_swap_acquire) # define AO_compare_and_swap(addr, old, new_val) \ AO_compare_and_swap_acquire(addr, old, new_val) # define AO_HAVE_compare_and_swap #endif #if !defined(AO_HAVE_compare_and_swap) \ && defined(AO_HAVE_compare_and_swap_write) # define AO_compare_and_swap(addr, old, new_val) \ AO_compare_and_swap_write(addr, old, new_val) # define AO_HAVE_compare_and_swap #endif #if !defined(AO_HAVE_compare_and_swap) \ && defined(AO_HAVE_compare_and_swap_read) # define AO_compare_and_swap(addr, old, new_val) \ AO_compare_and_swap_read(addr, old, new_val) # define AO_HAVE_compare_and_swap #endif #if defined(AO_HAVE_compare_and_swap_acquire) \ && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_compare_and_swap_full) # define AO_compare_and_swap_full(addr, old, new_val) \ (AO_nop_full(), \ AO_compare_and_swap_acquire(addr, old, new_val)) # define AO_HAVE_compare_and_swap_full #endif #if !defined(AO_HAVE_compare_and_swap_release_write) \ && defined(AO_HAVE_compare_and_swap_write) # define AO_compare_and_swap_release_write(addr, old, new_val) \ AO_compare_and_swap_write(addr, old, new_val) # define AO_HAVE_compare_and_swap_release_write #endif #if !defined(AO_HAVE_compare_and_swap_release_write) \ && defined(AO_HAVE_compare_and_swap_release) # define AO_compare_and_swap_release_write(addr, old, new_val) \ AO_compare_and_swap_release(addr, old, new_val) # define AO_HAVE_compare_and_swap_release_write #endif #if !defined(AO_HAVE_compare_and_swap_acquire_read) \ && defined(AO_HAVE_compare_and_swap_read) # define AO_compare_and_swap_acquire_read(addr, old, new_val) \ AO_compare_and_swap_read(addr, old, new_val) # define AO_HAVE_compare_and_swap_acquire_read #endif #if !defined(AO_HAVE_compare_and_swap_acquire_read) \ && defined(AO_HAVE_compare_and_swap_acquire) # define AO_compare_and_swap_acquire_read(addr, old, new_val) \ AO_compare_and_swap_acquire(addr, old, new_val) # define AO_HAVE_compare_and_swap_acquire_read #endif #ifdef AO_NO_DD_ORDERING # if defined(AO_HAVE_compare_and_swap_acquire_read) # define AO_compare_and_swap_dd_acquire_read(addr, old, new_val) \ AO_compare_and_swap_acquire_read(addr, old, new_val) # define AO_HAVE_compare_and_swap_dd_acquire_read # endif #else # if defined(AO_HAVE_compare_and_swap) # define AO_compare_and_swap_dd_acquire_read(addr, old, new_val) \ AO_compare_and_swap(addr, old, new_val) # define AO_HAVE_compare_and_swap_dd_acquire_read # endif #endif /* !AO_NO_DD_ORDERING */ /* load */ #if defined(AO_HAVE_load_full) && !defined(AO_HAVE_load_acquire) # define AO_load_acquire(addr) AO_load_full(addr) # define AO_HAVE_load_acquire #endif #if defined(AO_HAVE_load_acquire) && !defined(AO_HAVE_load) # define AO_load(addr) AO_load_acquire(addr) # define AO_HAVE_load #endif #if defined(AO_HAVE_load_full) && !defined(AO_HAVE_load_read) # define AO_load_read(addr) AO_load_full(addr) # define AO_HAVE_load_read #endif #if !defined(AO_HAVE_load_acquire_read) \ && defined(AO_HAVE_load_acquire) # define AO_load_acquire_read(addr) AO_load_acquire(addr) # define AO_HAVE_load_acquire_read #endif #if defined(AO_HAVE_load) && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_load_acquire) AO_INLINE AO_t AO_load_acquire(const volatile AO_t *addr) { AO_t result = AO_load(addr); /* Acquire barrier would be useless, since the load could be delayed */ /* beyond it. */ AO_nop_full(); return result; } # define AO_HAVE_load_acquire #endif #if defined(AO_HAVE_load) && defined(AO_HAVE_nop_read) \ && !defined(AO_HAVE_load_read) AO_INLINE AO_t AO_load_read(const volatile AO_t *addr) { AO_t result = AO_load(addr); AO_nop_read(); return result; } # define AO_HAVE_load_read #endif #if defined(AO_HAVE_load_acquire) && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_load_full) # define AO_load_full(addr) (AO_nop_full(), AO_load_acquire(addr)) # define AO_HAVE_load_full #endif #if defined(AO_HAVE_compare_and_swap_read) \ && !defined(AO_HAVE_load_read) # define AO_CAS_BASED_LOAD_READ AO_INLINE AO_t AO_load_read(const volatile AO_t *addr) { AO_t result; do { result = *(const AO_t *)addr; } while (AO_EXPECT_FALSE(!AO_compare_and_swap_read( (volatile AO_t *)addr, result, result))); return result; } # define AO_HAVE_load_read #endif #if !defined(AO_HAVE_load_acquire_read) \ && defined(AO_HAVE_load_read) # define AO_load_acquire_read(addr) AO_load_read(addr) # define AO_HAVE_load_acquire_read #endif #if defined(AO_HAVE_load_acquire_read) && !defined(AO_HAVE_load) \ && (!defined(AO_CAS_BASED_LOAD_READ) \ || !defined(AO_HAVE_compare_and_swap)) # define AO_load(addr) AO_load_acquire_read(addr) # define AO_HAVE_load #endif #if defined(AO_HAVE_compare_and_swap_full) \ && !defined(AO_HAVE_load_full) AO_INLINE AO_t AO_load_full(const volatile AO_t *addr) { AO_t result; do { result = *(const AO_t *)addr; } while (AO_EXPECT_FALSE(!AO_compare_and_swap_full( (volatile AO_t *)addr, result, result))); return result; } # define AO_HAVE_load_full #endif #if defined(AO_HAVE_compare_and_swap_acquire) \ && !defined(AO_HAVE_load_acquire) AO_INLINE AO_t AO_load_acquire(const volatile AO_t *addr) { AO_t result; do { result = *(const AO_t *)addr; } while (AO_EXPECT_FALSE(!AO_compare_and_swap_acquire( (volatile AO_t *)addr, result, result))); return result; } # define AO_HAVE_load_acquire #endif #if defined(AO_HAVE_compare_and_swap) && !defined(AO_HAVE_load) AO_INLINE AO_t AO_load(const volatile AO_t *addr) { AO_t result; do { result = *(const AO_t *)addr; } while (AO_EXPECT_FALSE(!AO_compare_and_swap( (volatile AO_t *)addr, result, result))); return result; } # define AO_HAVE_load #endif #ifdef AO_NO_DD_ORDERING # if defined(AO_HAVE_load_acquire_read) # define AO_load_dd_acquire_read(addr) \ AO_load_acquire_read(addr) # define AO_HAVE_load_dd_acquire_read # endif #else # if defined(AO_HAVE_load) # define AO_load_dd_acquire_read(addr) AO_load(addr) # define AO_HAVE_load_dd_acquire_read # endif #endif /* !AO_NO_DD_ORDERING */ /* store */ #if defined(AO_HAVE_store_full) && !defined(AO_HAVE_store_release) # define AO_store_release(addr, val) AO_store_full(addr, val) # define AO_HAVE_store_release #endif #if defined(AO_HAVE_store_release) && !defined(AO_HAVE_store) # define AO_store(addr, val) AO_store_release(addr, val) # define AO_HAVE_store #endif #if defined(AO_HAVE_store_full) && !defined(AO_HAVE_store_write) # define AO_store_write(addr, val) AO_store_full(addr, val) # define AO_HAVE_store_write #endif #if defined(AO_HAVE_store_release) \ && !defined(AO_HAVE_store_release_write) # define AO_store_release_write(addr, val) \ AO_store_release(addr, val) # define AO_HAVE_store_release_write #endif #if defined(AO_HAVE_store_write) && !defined(AO_HAVE_store) # define AO_store(addr, val) AO_store_write(addr, val) # define AO_HAVE_store #endif #if defined(AO_HAVE_store) && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_store_release) # define AO_store_release(addr, val) \ (AO_nop_full(), AO_store(addr, val)) # define AO_HAVE_store_release #endif #if defined(AO_HAVE_store) && defined(AO_HAVE_nop_write) \ && !defined(AO_HAVE_store_write) # define AO_store_write(addr, val) \ (AO_nop_write(), AO_store(addr, val)) # define AO_HAVE_store_write #endif #if defined(AO_HAVE_compare_and_swap_write) \ && !defined(AO_HAVE_store_write) AO_INLINE void AO_store_write(volatile AO_t *addr, AO_t new_val) { AO_t old_val; do { old_val = *(AO_t *)addr; } while (AO_EXPECT_FALSE(!AO_compare_and_swap_write(addr, old_val, new_val))); } # define AO_HAVE_store_write #endif #if defined(AO_HAVE_store_write) \ && !defined(AO_HAVE_store_release_write) # define AO_store_release_write(addr, val) \ AO_store_write(addr, val) # define AO_HAVE_store_release_write #endif #if defined(AO_HAVE_store_release) && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_store_full) # define AO_store_full(addr, val) \ (AO_store_release(addr, val), \ AO_nop_full()) # define AO_HAVE_store_full #endif #if defined(AO_HAVE_compare_and_swap) && !defined(AO_HAVE_store) AO_INLINE void AO_store(volatile AO_t *addr, AO_t new_val) { AO_t old_val; do { old_val = *(AO_t *)addr; } while (AO_EXPECT_FALSE(!AO_compare_and_swap(addr, old_val, new_val))); } # define AO_HAVE_store #endif #if defined(AO_HAVE_compare_and_swap_release) \ && !defined(AO_HAVE_store_release) AO_INLINE void AO_store_release(volatile AO_t *addr, AO_t new_val) { AO_t old_val; do { old_val = *(AO_t *)addr; } while (AO_EXPECT_FALSE(!AO_compare_and_swap_release(addr, old_val, new_val))); } # define AO_HAVE_store_release #endif #if defined(AO_HAVE_compare_and_swap_full) \ && !defined(AO_HAVE_store_full) AO_INLINE void AO_store_full(volatile AO_t *addr, AO_t new_val) { AO_t old_val; do { old_val = *(AO_t *)addr; } while (AO_EXPECT_FALSE(!AO_compare_and_swap_full(addr, old_val, new_val))); } # define AO_HAVE_store_full #endif /* * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ /* double_fetch_compare_and_swap */ #if defined(AO_HAVE_double_fetch_compare_and_swap) \ && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_double_fetch_compare_and_swap_acquire) AO_INLINE AO_double_t AO_double_fetch_compare_and_swap_acquire(volatile AO_double_t *addr, AO_double_t old_val, AO_double_t new_val) { AO_double_t result = AO_double_fetch_compare_and_swap(addr, old_val, new_val); AO_nop_full(); return result; } # define AO_HAVE_double_fetch_compare_and_swap_acquire #endif #if defined(AO_HAVE_double_fetch_compare_and_swap) \ && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_double_fetch_compare_and_swap_release) # define AO_double_fetch_compare_and_swap_release(addr, old_val, new_val) \ (AO_nop_full(), \ AO_double_fetch_compare_and_swap(addr, old_val, new_val)) # define AO_HAVE_double_fetch_compare_and_swap_release #endif #if defined(AO_HAVE_double_fetch_compare_and_swap_full) # if !defined(AO_HAVE_double_fetch_compare_and_swap_release) # define AO_double_fetch_compare_and_swap_release(addr, old_val, new_val) \ AO_double_fetch_compare_and_swap_full(addr, old_val, new_val) # define AO_HAVE_double_fetch_compare_and_swap_release # endif # if !defined(AO_HAVE_double_fetch_compare_and_swap_acquire) # define AO_double_fetch_compare_and_swap_acquire(addr, old_val, new_val) \ AO_double_fetch_compare_and_swap_full(addr, old_val, new_val) # define AO_HAVE_double_fetch_compare_and_swap_acquire # endif # if !defined(AO_HAVE_double_fetch_compare_and_swap_write) # define AO_double_fetch_compare_and_swap_write(addr, old_val, new_val) \ AO_double_fetch_compare_and_swap_full(addr, old_val, new_val) # define AO_HAVE_double_fetch_compare_and_swap_write # endif # if !defined(AO_HAVE_double_fetch_compare_and_swap_read) # define AO_double_fetch_compare_and_swap_read(addr, old_val, new_val) \ AO_double_fetch_compare_and_swap_full(addr, old_val, new_val) # define AO_HAVE_double_fetch_compare_and_swap_read # endif #endif /* AO_HAVE_double_fetch_compare_and_swap_full */ #if !defined(AO_HAVE_double_fetch_compare_and_swap) \ && defined(AO_HAVE_double_fetch_compare_and_swap_release) # define AO_double_fetch_compare_and_swap(addr, old_val, new_val) \ AO_double_fetch_compare_and_swap_release(addr, old_val, new_val) # define AO_HAVE_double_fetch_compare_and_swap #endif #if !defined(AO_HAVE_double_fetch_compare_and_swap) \ && defined(AO_HAVE_double_fetch_compare_and_swap_acquire) # define AO_double_fetch_compare_and_swap(addr, old_val, new_val) \ AO_double_fetch_compare_and_swap_acquire(addr, old_val, new_val) # define AO_HAVE_double_fetch_compare_and_swap #endif #if !defined(AO_HAVE_double_fetch_compare_and_swap) \ && defined(AO_HAVE_double_fetch_compare_and_swap_write) # define AO_double_fetch_compare_and_swap(addr, old_val, new_val) \ AO_double_fetch_compare_and_swap_write(addr, old_val, new_val) # define AO_HAVE_double_fetch_compare_and_swap #endif #if !defined(AO_HAVE_double_fetch_compare_and_swap) \ && defined(AO_HAVE_double_fetch_compare_and_swap_read) # define AO_double_fetch_compare_and_swap(addr, old_val, new_val) \ AO_double_fetch_compare_and_swap_read(addr, old_val, new_val) # define AO_HAVE_double_fetch_compare_and_swap #endif #if defined(AO_HAVE_double_fetch_compare_and_swap_acquire) \ && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_double_fetch_compare_and_swap_full) # define AO_double_fetch_compare_and_swap_full(addr, old_val, new_val) \ (AO_nop_full(), \ AO_double_fetch_compare_and_swap_acquire(addr, old_val, new_val)) # define AO_HAVE_double_fetch_compare_and_swap_full #endif #if !defined(AO_HAVE_double_fetch_compare_and_swap_release_write) \ && defined(AO_HAVE_double_fetch_compare_and_swap_write) # define AO_double_fetch_compare_and_swap_release_write(addr,old_val,new_val) \ AO_double_fetch_compare_and_swap_write(addr, old_val, new_val) # define AO_HAVE_double_fetch_compare_and_swap_release_write #endif #if !defined(AO_HAVE_double_fetch_compare_and_swap_release_write) \ && defined(AO_HAVE_double_fetch_compare_and_swap_release) # define AO_double_fetch_compare_and_swap_release_write(addr,old_val,new_val) \ AO_double_fetch_compare_and_swap_release(addr, old_val, new_val) # define AO_HAVE_double_fetch_compare_and_swap_release_write #endif #if !defined(AO_HAVE_double_fetch_compare_and_swap_acquire_read) \ && defined(AO_HAVE_double_fetch_compare_and_swap_read) # define AO_double_fetch_compare_and_swap_acquire_read(addr,old_val,new_val) \ AO_double_fetch_compare_and_swap_read(addr, old_val, new_val) # define AO_HAVE_double_fetch_compare_and_swap_acquire_read #endif #if !defined(AO_HAVE_double_fetch_compare_and_swap_acquire_read) \ && defined(AO_HAVE_double_fetch_compare_and_swap_acquire) # define AO_double_fetch_compare_and_swap_acquire_read(addr,old_val,new_val) \ AO_double_fetch_compare_and_swap_acquire(addr, old_val, new_val) # define AO_HAVE_double_fetch_compare_and_swap_acquire_read #endif #ifdef AO_NO_DD_ORDERING # if defined(AO_HAVE_double_fetch_compare_and_swap_acquire_read) # define AO_double_fetch_compare_and_swap_dd_acquire_read(addr,old_val,new_val) \ AO_double_fetch_compare_and_swap_acquire_read(addr, old_val, new_val) # define AO_HAVE_double_fetch_compare_and_swap_dd_acquire_read # endif #else # if defined(AO_HAVE_double_fetch_compare_and_swap) # define AO_double_fetch_compare_and_swap_dd_acquire_read(addr,old_val,new_val) \ AO_double_fetch_compare_and_swap(addr, old_val, new_val) # define AO_HAVE_double_fetch_compare_and_swap_dd_acquire_read # endif #endif /* !AO_NO_DD_ORDERING */ /* double_compare_and_swap */ #if defined(AO_HAVE_double_compare_and_swap) && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_double_compare_and_swap_acquire) AO_INLINE int AO_double_compare_and_swap_acquire(volatile AO_double_t *addr, AO_double_t old, AO_double_t new_val) { int result = AO_double_compare_and_swap(addr, old, new_val); AO_nop_full(); return result; } # define AO_HAVE_double_compare_and_swap_acquire #endif #if defined(AO_HAVE_double_compare_and_swap) && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_double_compare_and_swap_release) # define AO_double_compare_and_swap_release(addr, old, new_val) \ (AO_nop_full(), AO_double_compare_and_swap(addr, old, new_val)) # define AO_HAVE_double_compare_and_swap_release #endif #if defined(AO_HAVE_double_compare_and_swap_full) # if !defined(AO_HAVE_double_compare_and_swap_release) # define AO_double_compare_and_swap_release(addr, old, new_val) \ AO_double_compare_and_swap_full(addr, old, new_val) # define AO_HAVE_double_compare_and_swap_release # endif # if !defined(AO_HAVE_double_compare_and_swap_acquire) # define AO_double_compare_and_swap_acquire(addr, old, new_val) \ AO_double_compare_and_swap_full(addr, old, new_val) # define AO_HAVE_double_compare_and_swap_acquire # endif # if !defined(AO_HAVE_double_compare_and_swap_write) # define AO_double_compare_and_swap_write(addr, old, new_val) \ AO_double_compare_and_swap_full(addr, old, new_val) # define AO_HAVE_double_compare_and_swap_write # endif # if !defined(AO_HAVE_double_compare_and_swap_read) # define AO_double_compare_and_swap_read(addr, old, new_val) \ AO_double_compare_and_swap_full(addr, old, new_val) # define AO_HAVE_double_compare_and_swap_read # endif #endif /* AO_HAVE_double_compare_and_swap_full */ #if !defined(AO_HAVE_double_compare_and_swap) \ && defined(AO_HAVE_double_compare_and_swap_release) # define AO_double_compare_and_swap(addr, old, new_val) \ AO_double_compare_and_swap_release(addr, old, new_val) # define AO_HAVE_double_compare_and_swap #endif #if !defined(AO_HAVE_double_compare_and_swap) \ && defined(AO_HAVE_double_compare_and_swap_acquire) # define AO_double_compare_and_swap(addr, old, new_val) \ AO_double_compare_and_swap_acquire(addr, old, new_val) # define AO_HAVE_double_compare_and_swap #endif #if !defined(AO_HAVE_double_compare_and_swap) \ && defined(AO_HAVE_double_compare_and_swap_write) # define AO_double_compare_and_swap(addr, old, new_val) \ AO_double_compare_and_swap_write(addr, old, new_val) # define AO_HAVE_double_compare_and_swap #endif #if !defined(AO_HAVE_double_compare_and_swap) \ && defined(AO_HAVE_double_compare_and_swap_read) # define AO_double_compare_and_swap(addr, old, new_val) \ AO_double_compare_and_swap_read(addr, old, new_val) # define AO_HAVE_double_compare_and_swap #endif #if defined(AO_HAVE_double_compare_and_swap_acquire) \ && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_double_compare_and_swap_full) # define AO_double_compare_and_swap_full(addr, old, new_val) \ (AO_nop_full(), \ AO_double_compare_and_swap_acquire(addr, old, new_val)) # define AO_HAVE_double_compare_and_swap_full #endif #if !defined(AO_HAVE_double_compare_and_swap_release_write) \ && defined(AO_HAVE_double_compare_and_swap_write) # define AO_double_compare_and_swap_release_write(addr, old, new_val) \ AO_double_compare_and_swap_write(addr, old, new_val) # define AO_HAVE_double_compare_and_swap_release_write #endif #if !defined(AO_HAVE_double_compare_and_swap_release_write) \ && defined(AO_HAVE_double_compare_and_swap_release) # define AO_double_compare_and_swap_release_write(addr, old, new_val) \ AO_double_compare_and_swap_release(addr, old, new_val) # define AO_HAVE_double_compare_and_swap_release_write #endif #if !defined(AO_HAVE_double_compare_and_swap_acquire_read) \ && defined(AO_HAVE_double_compare_and_swap_read) # define AO_double_compare_and_swap_acquire_read(addr, old, new_val) \ AO_double_compare_and_swap_read(addr, old, new_val) # define AO_HAVE_double_compare_and_swap_acquire_read #endif #if !defined(AO_HAVE_double_compare_and_swap_acquire_read) \ && defined(AO_HAVE_double_compare_and_swap_acquire) # define AO_double_compare_and_swap_acquire_read(addr, old, new_val) \ AO_double_compare_and_swap_acquire(addr, old, new_val) # define AO_HAVE_double_compare_and_swap_acquire_read #endif #ifdef AO_NO_DD_ORDERING # if defined(AO_HAVE_double_compare_and_swap_acquire_read) # define AO_double_compare_and_swap_dd_acquire_read(addr, old, new_val) \ AO_double_compare_and_swap_acquire_read(addr, old, new_val) # define AO_HAVE_double_compare_and_swap_dd_acquire_read # endif #else # if defined(AO_HAVE_double_compare_and_swap) # define AO_double_compare_and_swap_dd_acquire_read(addr, old, new_val) \ AO_double_compare_and_swap(addr, old, new_val) # define AO_HAVE_double_compare_and_swap_dd_acquire_read # endif #endif /* !AO_NO_DD_ORDERING */ /* double_load */ #if defined(AO_HAVE_double_load_full) && !defined(AO_HAVE_double_load_acquire) # define AO_double_load_acquire(addr) AO_double_load_full(addr) # define AO_HAVE_double_load_acquire #endif #if defined(AO_HAVE_double_load_acquire) && !defined(AO_HAVE_double_load) # define AO_double_load(addr) AO_double_load_acquire(addr) # define AO_HAVE_double_load #endif #if defined(AO_HAVE_double_load_full) && !defined(AO_HAVE_double_load_read) # define AO_double_load_read(addr) AO_double_load_full(addr) # define AO_HAVE_double_load_read #endif #if !defined(AO_HAVE_double_load_acquire_read) \ && defined(AO_HAVE_double_load_acquire) # define AO_double_load_acquire_read(addr) AO_double_load_acquire(addr) # define AO_HAVE_double_load_acquire_read #endif #if defined(AO_HAVE_double_load) && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_double_load_acquire) AO_INLINE AO_double_t AO_double_load_acquire(const volatile AO_double_t *addr) { AO_double_t result = AO_double_load(addr); /* Acquire barrier would be useless, since the load could be delayed */ /* beyond it. */ AO_nop_full(); return result; } # define AO_HAVE_double_load_acquire #endif #if defined(AO_HAVE_double_load) && defined(AO_HAVE_nop_read) \ && !defined(AO_HAVE_double_load_read) AO_INLINE AO_double_t AO_double_load_read(const volatile AO_double_t *addr) { AO_double_t result = AO_double_load(addr); AO_nop_read(); return result; } # define AO_HAVE_double_load_read #endif #if defined(AO_HAVE_double_load_acquire) && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_double_load_full) # define AO_double_load_full(addr) (AO_nop_full(), AO_double_load_acquire(addr)) # define AO_HAVE_double_load_full #endif #if defined(AO_HAVE_double_compare_and_swap_read) \ && !defined(AO_HAVE_double_load_read) # define AO_double_CAS_BASED_LOAD_READ AO_INLINE AO_double_t AO_double_load_read(const volatile AO_double_t *addr) { AO_double_t result; do { result = *(const AO_double_t *)addr; } while (AO_EXPECT_FALSE(!AO_double_compare_and_swap_read( (volatile AO_double_t *)addr, result, result))); return result; } # define AO_HAVE_double_load_read #endif #if !defined(AO_HAVE_double_load_acquire_read) \ && defined(AO_HAVE_double_load_read) # define AO_double_load_acquire_read(addr) AO_double_load_read(addr) # define AO_HAVE_double_load_acquire_read #endif #if defined(AO_HAVE_double_load_acquire_read) && !defined(AO_HAVE_double_load) \ && (!defined(AO_double_CAS_BASED_LOAD_READ) \ || !defined(AO_HAVE_double_compare_and_swap)) # define AO_double_load(addr) AO_double_load_acquire_read(addr) # define AO_HAVE_double_load #endif #if defined(AO_HAVE_double_compare_and_swap_full) \ && !defined(AO_HAVE_double_load_full) AO_INLINE AO_double_t AO_double_load_full(const volatile AO_double_t *addr) { AO_double_t result; do { result = *(const AO_double_t *)addr; } while (AO_EXPECT_FALSE(!AO_double_compare_and_swap_full( (volatile AO_double_t *)addr, result, result))); return result; } # define AO_HAVE_double_load_full #endif #if defined(AO_HAVE_double_compare_and_swap_acquire) \ && !defined(AO_HAVE_double_load_acquire) AO_INLINE AO_double_t AO_double_load_acquire(const volatile AO_double_t *addr) { AO_double_t result; do { result = *(const AO_double_t *)addr; } while (AO_EXPECT_FALSE(!AO_double_compare_and_swap_acquire( (volatile AO_double_t *)addr, result, result))); return result; } # define AO_HAVE_double_load_acquire #endif #if defined(AO_HAVE_double_compare_and_swap) && !defined(AO_HAVE_double_load) AO_INLINE AO_double_t AO_double_load(const volatile AO_double_t *addr) { AO_double_t result; do { result = *(const AO_double_t *)addr; } while (AO_EXPECT_FALSE(!AO_double_compare_and_swap( (volatile AO_double_t *)addr, result, result))); return result; } # define AO_HAVE_double_load #endif #ifdef AO_NO_DD_ORDERING # if defined(AO_HAVE_double_load_acquire_read) # define AO_double_load_dd_acquire_read(addr) \ AO_double_load_acquire_read(addr) # define AO_HAVE_double_load_dd_acquire_read # endif #else # if defined(AO_HAVE_double_load) # define AO_double_load_dd_acquire_read(addr) AO_double_load(addr) # define AO_HAVE_double_load_dd_acquire_read # endif #endif /* !AO_NO_DD_ORDERING */ /* double_store */ #if defined(AO_HAVE_double_store_full) && !defined(AO_HAVE_double_store_release) # define AO_double_store_release(addr, val) AO_double_store_full(addr, val) # define AO_HAVE_double_store_release #endif #if defined(AO_HAVE_double_store_release) && !defined(AO_HAVE_double_store) # define AO_double_store(addr, val) AO_double_store_release(addr, val) # define AO_HAVE_double_store #endif #if defined(AO_HAVE_double_store_full) && !defined(AO_HAVE_double_store_write) # define AO_double_store_write(addr, val) AO_double_store_full(addr, val) # define AO_HAVE_double_store_write #endif #if defined(AO_HAVE_double_store_release) \ && !defined(AO_HAVE_double_store_release_write) # define AO_double_store_release_write(addr, val) \ AO_double_store_release(addr, val) # define AO_HAVE_double_store_release_write #endif #if defined(AO_HAVE_double_store_write) && !defined(AO_HAVE_double_store) # define AO_double_store(addr, val) AO_double_store_write(addr, val) # define AO_HAVE_double_store #endif #if defined(AO_HAVE_double_store) && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_double_store_release) # define AO_double_store_release(addr, val) \ (AO_nop_full(), AO_double_store(addr, val)) # define AO_HAVE_double_store_release #endif #if defined(AO_HAVE_double_store) && defined(AO_HAVE_nop_write) \ && !defined(AO_HAVE_double_store_write) # define AO_double_store_write(addr, val) \ (AO_nop_write(), AO_double_store(addr, val)) # define AO_HAVE_double_store_write #endif #if defined(AO_HAVE_double_compare_and_swap_write) \ && !defined(AO_HAVE_double_store_write) AO_INLINE void AO_double_store_write(volatile AO_double_t *addr, AO_double_t new_val) { AO_double_t old_val; do { old_val = *(AO_double_t *)addr; } while (AO_EXPECT_FALSE(!AO_double_compare_and_swap_write(addr, old_val, new_val))); } # define AO_HAVE_double_store_write #endif #if defined(AO_HAVE_double_store_write) \ && !defined(AO_HAVE_double_store_release_write) # define AO_double_store_release_write(addr, val) \ AO_double_store_write(addr, val) # define AO_HAVE_double_store_release_write #endif #if defined(AO_HAVE_double_store_release) && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_double_store_full) # define AO_double_store_full(addr, val) \ (AO_double_store_release(addr, val), \ AO_nop_full()) # define AO_HAVE_double_store_full #endif #if defined(AO_HAVE_double_compare_and_swap) && !defined(AO_HAVE_double_store) AO_INLINE void AO_double_store(volatile AO_double_t *addr, AO_double_t new_val) { AO_double_t old_val; do { old_val = *(AO_double_t *)addr; } while (AO_EXPECT_FALSE(!AO_double_compare_and_swap(addr, old_val, new_val))); } # define AO_HAVE_double_store #endif #if defined(AO_HAVE_double_compare_and_swap_release) \ && !defined(AO_HAVE_double_store_release) AO_INLINE void AO_double_store_release(volatile AO_double_t *addr, AO_double_t new_val) { AO_double_t old_val; do { old_val = *(AO_double_t *)addr; } while (AO_EXPECT_FALSE(!AO_double_compare_and_swap_release(addr, old_val, new_val))); } # define AO_HAVE_double_store_release #endif #if defined(AO_HAVE_double_compare_and_swap_full) \ && !defined(AO_HAVE_double_store_full) AO_INLINE void AO_double_store_full(volatile AO_double_t *addr, AO_double_t new_val) { AO_double_t old_val; do { old_val = *(AO_double_t *)addr; } while (AO_EXPECT_FALSE(!AO_double_compare_and_swap_full(addr, old_val, new_val))); } # define AO_HAVE_double_store_full #endif ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/generalize-small.template000066400000000000000000000502511266352375300270000ustar00rootroot00000000000000/* * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ /* XSIZE_fetch_compare_and_swap */ #if defined(AO_HAVE_XSIZE_fetch_compare_and_swap) \ && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_XSIZE_fetch_compare_and_swap_acquire) AO_INLINE XCTYPE AO_XSIZE_fetch_compare_and_swap_acquire(volatile XCTYPE *addr, XCTYPE old_val, XCTYPE new_val) { XCTYPE result = AO_XSIZE_fetch_compare_and_swap(addr, old_val, new_val); AO_nop_full(); return result; } # define AO_HAVE_XSIZE_fetch_compare_and_swap_acquire #endif #if defined(AO_HAVE_XSIZE_fetch_compare_and_swap) \ && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_XSIZE_fetch_compare_and_swap_release) # define AO_XSIZE_fetch_compare_and_swap_release(addr, old_val, new_val) \ (AO_nop_full(), \ AO_XSIZE_fetch_compare_and_swap(addr, old_val, new_val)) # define AO_HAVE_XSIZE_fetch_compare_and_swap_release #endif #if defined(AO_HAVE_XSIZE_fetch_compare_and_swap_full) # if !defined(AO_HAVE_XSIZE_fetch_compare_and_swap_release) # define AO_XSIZE_fetch_compare_and_swap_release(addr, old_val, new_val) \ AO_XSIZE_fetch_compare_and_swap_full(addr, old_val, new_val) # define AO_HAVE_XSIZE_fetch_compare_and_swap_release # endif # if !defined(AO_HAVE_XSIZE_fetch_compare_and_swap_acquire) # define AO_XSIZE_fetch_compare_and_swap_acquire(addr, old_val, new_val) \ AO_XSIZE_fetch_compare_and_swap_full(addr, old_val, new_val) # define AO_HAVE_XSIZE_fetch_compare_and_swap_acquire # endif # if !defined(AO_HAVE_XSIZE_fetch_compare_and_swap_write) # define AO_XSIZE_fetch_compare_and_swap_write(addr, old_val, new_val) \ AO_XSIZE_fetch_compare_and_swap_full(addr, old_val, new_val) # define AO_HAVE_XSIZE_fetch_compare_and_swap_write # endif # if !defined(AO_HAVE_XSIZE_fetch_compare_and_swap_read) # define AO_XSIZE_fetch_compare_and_swap_read(addr, old_val, new_val) \ AO_XSIZE_fetch_compare_and_swap_full(addr, old_val, new_val) # define AO_HAVE_XSIZE_fetch_compare_and_swap_read # endif #endif /* AO_HAVE_XSIZE_fetch_compare_and_swap_full */ #if !defined(AO_HAVE_XSIZE_fetch_compare_and_swap) \ && defined(AO_HAVE_XSIZE_fetch_compare_and_swap_release) # define AO_XSIZE_fetch_compare_and_swap(addr, old_val, new_val) \ AO_XSIZE_fetch_compare_and_swap_release(addr, old_val, new_val) # define AO_HAVE_XSIZE_fetch_compare_and_swap #endif #if !defined(AO_HAVE_XSIZE_fetch_compare_and_swap) \ && defined(AO_HAVE_XSIZE_fetch_compare_and_swap_acquire) # define AO_XSIZE_fetch_compare_and_swap(addr, old_val, new_val) \ AO_XSIZE_fetch_compare_and_swap_acquire(addr, old_val, new_val) # define AO_HAVE_XSIZE_fetch_compare_and_swap #endif #if !defined(AO_HAVE_XSIZE_fetch_compare_and_swap) \ && defined(AO_HAVE_XSIZE_fetch_compare_and_swap_write) # define AO_XSIZE_fetch_compare_and_swap(addr, old_val, new_val) \ AO_XSIZE_fetch_compare_and_swap_write(addr, old_val, new_val) # define AO_HAVE_XSIZE_fetch_compare_and_swap #endif #if !defined(AO_HAVE_XSIZE_fetch_compare_and_swap) \ && defined(AO_HAVE_XSIZE_fetch_compare_and_swap_read) # define AO_XSIZE_fetch_compare_and_swap(addr, old_val, new_val) \ AO_XSIZE_fetch_compare_and_swap_read(addr, old_val, new_val) # define AO_HAVE_XSIZE_fetch_compare_and_swap #endif #if defined(AO_HAVE_XSIZE_fetch_compare_and_swap_acquire) \ && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_XSIZE_fetch_compare_and_swap_full) # define AO_XSIZE_fetch_compare_and_swap_full(addr, old_val, new_val) \ (AO_nop_full(), \ AO_XSIZE_fetch_compare_and_swap_acquire(addr, old_val, new_val)) # define AO_HAVE_XSIZE_fetch_compare_and_swap_full #endif #if !defined(AO_HAVE_XSIZE_fetch_compare_and_swap_release_write) \ && defined(AO_HAVE_XSIZE_fetch_compare_and_swap_write) # define AO_XSIZE_fetch_compare_and_swap_release_write(addr,old_val,new_val) \ AO_XSIZE_fetch_compare_and_swap_write(addr, old_val, new_val) # define AO_HAVE_XSIZE_fetch_compare_and_swap_release_write #endif #if !defined(AO_HAVE_XSIZE_fetch_compare_and_swap_release_write) \ && defined(AO_HAVE_XSIZE_fetch_compare_and_swap_release) # define AO_XSIZE_fetch_compare_and_swap_release_write(addr,old_val,new_val) \ AO_XSIZE_fetch_compare_and_swap_release(addr, old_val, new_val) # define AO_HAVE_XSIZE_fetch_compare_and_swap_release_write #endif #if !defined(AO_HAVE_XSIZE_fetch_compare_and_swap_acquire_read) \ && defined(AO_HAVE_XSIZE_fetch_compare_and_swap_read) # define AO_XSIZE_fetch_compare_and_swap_acquire_read(addr,old_val,new_val) \ AO_XSIZE_fetch_compare_and_swap_read(addr, old_val, new_val) # define AO_HAVE_XSIZE_fetch_compare_and_swap_acquire_read #endif #if !defined(AO_HAVE_XSIZE_fetch_compare_and_swap_acquire_read) \ && defined(AO_HAVE_XSIZE_fetch_compare_and_swap_acquire) # define AO_XSIZE_fetch_compare_and_swap_acquire_read(addr,old_val,new_val) \ AO_XSIZE_fetch_compare_and_swap_acquire(addr, old_val, new_val) # define AO_HAVE_XSIZE_fetch_compare_and_swap_acquire_read #endif #ifdef AO_NO_DD_ORDERING # if defined(AO_HAVE_XSIZE_fetch_compare_and_swap_acquire_read) # define AO_XSIZE_fetch_compare_and_swap_dd_acquire_read(addr,old_val,new_val) \ AO_XSIZE_fetch_compare_and_swap_acquire_read(addr, old_val, new_val) # define AO_HAVE_XSIZE_fetch_compare_and_swap_dd_acquire_read # endif #else # if defined(AO_HAVE_XSIZE_fetch_compare_and_swap) # define AO_XSIZE_fetch_compare_and_swap_dd_acquire_read(addr,old_val,new_val) \ AO_XSIZE_fetch_compare_and_swap(addr, old_val, new_val) # define AO_HAVE_XSIZE_fetch_compare_and_swap_dd_acquire_read # endif #endif /* !AO_NO_DD_ORDERING */ /* XSIZE_compare_and_swap */ #if defined(AO_HAVE_XSIZE_compare_and_swap) && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_XSIZE_compare_and_swap_acquire) AO_INLINE int AO_XSIZE_compare_and_swap_acquire(volatile XCTYPE *addr, XCTYPE old, XCTYPE new_val) { int result = AO_XSIZE_compare_and_swap(addr, old, new_val); AO_nop_full(); return result; } # define AO_HAVE_XSIZE_compare_and_swap_acquire #endif #if defined(AO_HAVE_XSIZE_compare_and_swap) && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_XSIZE_compare_and_swap_release) # define AO_XSIZE_compare_and_swap_release(addr, old, new_val) \ (AO_nop_full(), AO_XSIZE_compare_and_swap(addr, old, new_val)) # define AO_HAVE_XSIZE_compare_and_swap_release #endif #if defined(AO_HAVE_XSIZE_compare_and_swap_full) # if !defined(AO_HAVE_XSIZE_compare_and_swap_release) # define AO_XSIZE_compare_and_swap_release(addr, old, new_val) \ AO_XSIZE_compare_and_swap_full(addr, old, new_val) # define AO_HAVE_XSIZE_compare_and_swap_release # endif # if !defined(AO_HAVE_XSIZE_compare_and_swap_acquire) # define AO_XSIZE_compare_and_swap_acquire(addr, old, new_val) \ AO_XSIZE_compare_and_swap_full(addr, old, new_val) # define AO_HAVE_XSIZE_compare_and_swap_acquire # endif # if !defined(AO_HAVE_XSIZE_compare_and_swap_write) # define AO_XSIZE_compare_and_swap_write(addr, old, new_val) \ AO_XSIZE_compare_and_swap_full(addr, old, new_val) # define AO_HAVE_XSIZE_compare_and_swap_write # endif # if !defined(AO_HAVE_XSIZE_compare_and_swap_read) # define AO_XSIZE_compare_and_swap_read(addr, old, new_val) \ AO_XSIZE_compare_and_swap_full(addr, old, new_val) # define AO_HAVE_XSIZE_compare_and_swap_read # endif #endif /* AO_HAVE_XSIZE_compare_and_swap_full */ #if !defined(AO_HAVE_XSIZE_compare_and_swap) \ && defined(AO_HAVE_XSIZE_compare_and_swap_release) # define AO_XSIZE_compare_and_swap(addr, old, new_val) \ AO_XSIZE_compare_and_swap_release(addr, old, new_val) # define AO_HAVE_XSIZE_compare_and_swap #endif #if !defined(AO_HAVE_XSIZE_compare_and_swap) \ && defined(AO_HAVE_XSIZE_compare_and_swap_acquire) # define AO_XSIZE_compare_and_swap(addr, old, new_val) \ AO_XSIZE_compare_and_swap_acquire(addr, old, new_val) # define AO_HAVE_XSIZE_compare_and_swap #endif #if !defined(AO_HAVE_XSIZE_compare_and_swap) \ && defined(AO_HAVE_XSIZE_compare_and_swap_write) # define AO_XSIZE_compare_and_swap(addr, old, new_val) \ AO_XSIZE_compare_and_swap_write(addr, old, new_val) # define AO_HAVE_XSIZE_compare_and_swap #endif #if !defined(AO_HAVE_XSIZE_compare_and_swap) \ && defined(AO_HAVE_XSIZE_compare_and_swap_read) # define AO_XSIZE_compare_and_swap(addr, old, new_val) \ AO_XSIZE_compare_and_swap_read(addr, old, new_val) # define AO_HAVE_XSIZE_compare_and_swap #endif #if defined(AO_HAVE_XSIZE_compare_and_swap_acquire) \ && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_XSIZE_compare_and_swap_full) # define AO_XSIZE_compare_and_swap_full(addr, old, new_val) \ (AO_nop_full(), \ AO_XSIZE_compare_and_swap_acquire(addr, old, new_val)) # define AO_HAVE_XSIZE_compare_and_swap_full #endif #if !defined(AO_HAVE_XSIZE_compare_and_swap_release_write) \ && defined(AO_HAVE_XSIZE_compare_and_swap_write) # define AO_XSIZE_compare_and_swap_release_write(addr, old, new_val) \ AO_XSIZE_compare_and_swap_write(addr, old, new_val) # define AO_HAVE_XSIZE_compare_and_swap_release_write #endif #if !defined(AO_HAVE_XSIZE_compare_and_swap_release_write) \ && defined(AO_HAVE_XSIZE_compare_and_swap_release) # define AO_XSIZE_compare_and_swap_release_write(addr, old, new_val) \ AO_XSIZE_compare_and_swap_release(addr, old, new_val) # define AO_HAVE_XSIZE_compare_and_swap_release_write #endif #if !defined(AO_HAVE_XSIZE_compare_and_swap_acquire_read) \ && defined(AO_HAVE_XSIZE_compare_and_swap_read) # define AO_XSIZE_compare_and_swap_acquire_read(addr, old, new_val) \ AO_XSIZE_compare_and_swap_read(addr, old, new_val) # define AO_HAVE_XSIZE_compare_and_swap_acquire_read #endif #if !defined(AO_HAVE_XSIZE_compare_and_swap_acquire_read) \ && defined(AO_HAVE_XSIZE_compare_and_swap_acquire) # define AO_XSIZE_compare_and_swap_acquire_read(addr, old, new_val) \ AO_XSIZE_compare_and_swap_acquire(addr, old, new_val) # define AO_HAVE_XSIZE_compare_and_swap_acquire_read #endif #ifdef AO_NO_DD_ORDERING # if defined(AO_HAVE_XSIZE_compare_and_swap_acquire_read) # define AO_XSIZE_compare_and_swap_dd_acquire_read(addr, old, new_val) \ AO_XSIZE_compare_and_swap_acquire_read(addr, old, new_val) # define AO_HAVE_XSIZE_compare_and_swap_dd_acquire_read # endif #else # if defined(AO_HAVE_XSIZE_compare_and_swap) # define AO_XSIZE_compare_and_swap_dd_acquire_read(addr, old, new_val) \ AO_XSIZE_compare_and_swap(addr, old, new_val) # define AO_HAVE_XSIZE_compare_and_swap_dd_acquire_read # endif #endif /* !AO_NO_DD_ORDERING */ /* XSIZE_load */ #if defined(AO_HAVE_XSIZE_load_full) && !defined(AO_HAVE_XSIZE_load_acquire) # define AO_XSIZE_load_acquire(addr) AO_XSIZE_load_full(addr) # define AO_HAVE_XSIZE_load_acquire #endif #if defined(AO_HAVE_XSIZE_load_acquire) && !defined(AO_HAVE_XSIZE_load) # define AO_XSIZE_load(addr) AO_XSIZE_load_acquire(addr) # define AO_HAVE_XSIZE_load #endif #if defined(AO_HAVE_XSIZE_load_full) && !defined(AO_HAVE_XSIZE_load_read) # define AO_XSIZE_load_read(addr) AO_XSIZE_load_full(addr) # define AO_HAVE_XSIZE_load_read #endif #if !defined(AO_HAVE_XSIZE_load_acquire_read) \ && defined(AO_HAVE_XSIZE_load_acquire) # define AO_XSIZE_load_acquire_read(addr) AO_XSIZE_load_acquire(addr) # define AO_HAVE_XSIZE_load_acquire_read #endif #if defined(AO_HAVE_XSIZE_load) && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_XSIZE_load_acquire) AO_INLINE XCTYPE AO_XSIZE_load_acquire(const volatile XCTYPE *addr) { XCTYPE result = AO_XSIZE_load(addr); /* Acquire barrier would be useless, since the load could be delayed */ /* beyond it. */ AO_nop_full(); return result; } # define AO_HAVE_XSIZE_load_acquire #endif #if defined(AO_HAVE_XSIZE_load) && defined(AO_HAVE_nop_read) \ && !defined(AO_HAVE_XSIZE_load_read) AO_INLINE XCTYPE AO_XSIZE_load_read(const volatile XCTYPE *addr) { XCTYPE result = AO_XSIZE_load(addr); AO_nop_read(); return result; } # define AO_HAVE_XSIZE_load_read #endif #if defined(AO_HAVE_XSIZE_load_acquire) && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_XSIZE_load_full) # define AO_XSIZE_load_full(addr) (AO_nop_full(), AO_XSIZE_load_acquire(addr)) # define AO_HAVE_XSIZE_load_full #endif #if defined(AO_HAVE_XSIZE_compare_and_swap_read) \ && !defined(AO_HAVE_XSIZE_load_read) # define AO_XSIZE_CAS_BASED_LOAD_READ AO_INLINE XCTYPE AO_XSIZE_load_read(const volatile XCTYPE *addr) { XCTYPE result; do { result = *(const XCTYPE *)addr; } while (AO_EXPECT_FALSE(!AO_XSIZE_compare_and_swap_read( (volatile XCTYPE *)addr, result, result))); return result; } # define AO_HAVE_XSIZE_load_read #endif #if !defined(AO_HAVE_XSIZE_load_acquire_read) \ && defined(AO_HAVE_XSIZE_load_read) # define AO_XSIZE_load_acquire_read(addr) AO_XSIZE_load_read(addr) # define AO_HAVE_XSIZE_load_acquire_read #endif #if defined(AO_HAVE_XSIZE_load_acquire_read) && !defined(AO_HAVE_XSIZE_load) \ && (!defined(AO_XSIZE_CAS_BASED_LOAD_READ) \ || !defined(AO_HAVE_XSIZE_compare_and_swap)) # define AO_XSIZE_load(addr) AO_XSIZE_load_acquire_read(addr) # define AO_HAVE_XSIZE_load #endif #if defined(AO_HAVE_XSIZE_compare_and_swap_full) \ && !defined(AO_HAVE_XSIZE_load_full) AO_INLINE XCTYPE AO_XSIZE_load_full(const volatile XCTYPE *addr) { XCTYPE result; do { result = *(const XCTYPE *)addr; } while (AO_EXPECT_FALSE(!AO_XSIZE_compare_and_swap_full( (volatile XCTYPE *)addr, result, result))); return result; } # define AO_HAVE_XSIZE_load_full #endif #if defined(AO_HAVE_XSIZE_compare_and_swap_acquire) \ && !defined(AO_HAVE_XSIZE_load_acquire) AO_INLINE XCTYPE AO_XSIZE_load_acquire(const volatile XCTYPE *addr) { XCTYPE result; do { result = *(const XCTYPE *)addr; } while (AO_EXPECT_FALSE(!AO_XSIZE_compare_and_swap_acquire( (volatile XCTYPE *)addr, result, result))); return result; } # define AO_HAVE_XSIZE_load_acquire #endif #if defined(AO_HAVE_XSIZE_compare_and_swap) && !defined(AO_HAVE_XSIZE_load) AO_INLINE XCTYPE AO_XSIZE_load(const volatile XCTYPE *addr) { XCTYPE result; do { result = *(const XCTYPE *)addr; } while (AO_EXPECT_FALSE(!AO_XSIZE_compare_and_swap( (volatile XCTYPE *)addr, result, result))); return result; } # define AO_HAVE_XSIZE_load #endif #ifdef AO_NO_DD_ORDERING # if defined(AO_HAVE_XSIZE_load_acquire_read) # define AO_XSIZE_load_dd_acquire_read(addr) \ AO_XSIZE_load_acquire_read(addr) # define AO_HAVE_XSIZE_load_dd_acquire_read # endif #else # if defined(AO_HAVE_XSIZE_load) # define AO_XSIZE_load_dd_acquire_read(addr) AO_XSIZE_load(addr) # define AO_HAVE_XSIZE_load_dd_acquire_read # endif #endif /* !AO_NO_DD_ORDERING */ /* XSIZE_store */ #if defined(AO_HAVE_XSIZE_store_full) && !defined(AO_HAVE_XSIZE_store_release) # define AO_XSIZE_store_release(addr, val) AO_XSIZE_store_full(addr, val) # define AO_HAVE_XSIZE_store_release #endif #if defined(AO_HAVE_XSIZE_store_release) && !defined(AO_HAVE_XSIZE_store) # define AO_XSIZE_store(addr, val) AO_XSIZE_store_release(addr, val) # define AO_HAVE_XSIZE_store #endif #if defined(AO_HAVE_XSIZE_store_full) && !defined(AO_HAVE_XSIZE_store_write) # define AO_XSIZE_store_write(addr, val) AO_XSIZE_store_full(addr, val) # define AO_HAVE_XSIZE_store_write #endif #if defined(AO_HAVE_XSIZE_store_release) \ && !defined(AO_HAVE_XSIZE_store_release_write) # define AO_XSIZE_store_release_write(addr, val) \ AO_XSIZE_store_release(addr, val) # define AO_HAVE_XSIZE_store_release_write #endif #if defined(AO_HAVE_XSIZE_store_write) && !defined(AO_HAVE_XSIZE_store) # define AO_XSIZE_store(addr, val) AO_XSIZE_store_write(addr, val) # define AO_HAVE_XSIZE_store #endif #if defined(AO_HAVE_XSIZE_store) && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_XSIZE_store_release) # define AO_XSIZE_store_release(addr, val) \ (AO_nop_full(), AO_XSIZE_store(addr, val)) # define AO_HAVE_XSIZE_store_release #endif #if defined(AO_HAVE_XSIZE_store) && defined(AO_HAVE_nop_write) \ && !defined(AO_HAVE_XSIZE_store_write) # define AO_XSIZE_store_write(addr, val) \ (AO_nop_write(), AO_XSIZE_store(addr, val)) # define AO_HAVE_XSIZE_store_write #endif #if defined(AO_HAVE_XSIZE_compare_and_swap_write) \ && !defined(AO_HAVE_XSIZE_store_write) AO_INLINE void AO_XSIZE_store_write(volatile XCTYPE *addr, XCTYPE new_val) { XCTYPE old_val; do { old_val = *(XCTYPE *)addr; } while (AO_EXPECT_FALSE(!AO_XSIZE_compare_and_swap_write(addr, old_val, new_val))); } # define AO_HAVE_XSIZE_store_write #endif #if defined(AO_HAVE_XSIZE_store_write) \ && !defined(AO_HAVE_XSIZE_store_release_write) # define AO_XSIZE_store_release_write(addr, val) \ AO_XSIZE_store_write(addr, val) # define AO_HAVE_XSIZE_store_release_write #endif #if defined(AO_HAVE_XSIZE_store_release) && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_XSIZE_store_full) # define AO_XSIZE_store_full(addr, val) \ (AO_XSIZE_store_release(addr, val), \ AO_nop_full()) # define AO_HAVE_XSIZE_store_full #endif #if defined(AO_HAVE_XSIZE_compare_and_swap) && !defined(AO_HAVE_XSIZE_store) AO_INLINE void AO_XSIZE_store(volatile XCTYPE *addr, XCTYPE new_val) { XCTYPE old_val; do { old_val = *(XCTYPE *)addr; } while (AO_EXPECT_FALSE(!AO_XSIZE_compare_and_swap(addr, old_val, new_val))); } # define AO_HAVE_XSIZE_store #endif #if defined(AO_HAVE_XSIZE_compare_and_swap_release) \ && !defined(AO_HAVE_XSIZE_store_release) AO_INLINE void AO_XSIZE_store_release(volatile XCTYPE *addr, XCTYPE new_val) { XCTYPE old_val; do { old_val = *(XCTYPE *)addr; } while (AO_EXPECT_FALSE(!AO_XSIZE_compare_and_swap_release(addr, old_val, new_val))); } # define AO_HAVE_XSIZE_store_release #endif #if defined(AO_HAVE_XSIZE_compare_and_swap_full) \ && !defined(AO_HAVE_XSIZE_store_full) AO_INLINE void AO_XSIZE_store_full(volatile XCTYPE *addr, XCTYPE new_val) { XCTYPE old_val; do { old_val = *(XCTYPE *)addr; } while (AO_EXPECT_FALSE(!AO_XSIZE_compare_and_swap_full(addr, old_val, new_val))); } # define AO_HAVE_XSIZE_store_full #endif ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/generalize.h000066400000000000000000000665341266352375300243210ustar00rootroot00000000000000/* * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ /* * Generalize atomic operations for atomic_ops.h. * Should not be included directly. * * We make no attempt to define useless operations, such as * AO_nop_acquire * AO_nop_release * * We have also so far neglected to define some others, which * do not appear likely to be useful, e.g. stores with acquire * or read barriers. * * This file is sometimes included twice by atomic_ops.h. * All definitions include explicit checks that we are not replacing * an earlier definition. In general, more desirable expansions * appear earlier so that we are more likely to use them. * * We only make safe generalizations, except that by default we define * the ...dd_acquire_read operations to be equivalent to those without * a barrier. On platforms for which this is unsafe, the platform-specific * file must define AO_NO_DD_ORDERING. */ #ifndef AO_ATOMIC_OPS_H # error This file should not be included directly. #endif /* Generate test_and_set_full, if necessary and possible. */ #if !defined(AO_HAVE_test_and_set) && !defined(AO_HAVE_test_and_set_release) \ && !defined(AO_HAVE_test_and_set_acquire) \ && !defined(AO_HAVE_test_and_set_read) \ && !defined(AO_HAVE_test_and_set_full) /* Emulate AO_compare_and_swap() via AO_fetch_compare_and_swap(). */ # if defined(AO_HAVE_fetch_compare_and_swap) \ && !defined(AO_HAVE_compare_and_swap) AO_INLINE int AO_compare_and_swap(volatile AO_t *addr, AO_t old_val, AO_t new_val) { return AO_fetch_compare_and_swap(addr, old_val, new_val) == old_val; } # define AO_HAVE_compare_and_swap # endif # if defined(AO_HAVE_fetch_compare_and_swap_full) \ && !defined(AO_HAVE_compare_and_swap_full) AO_INLINE int AO_compare_and_swap_full(volatile AO_t *addr, AO_t old_val, AO_t new_val) { return AO_fetch_compare_and_swap_full(addr, old_val, new_val) == old_val; } # define AO_HAVE_compare_and_swap_full # endif # if defined(AO_HAVE_fetch_compare_and_swap_acquire) \ && !defined(AO_HAVE_compare_and_swap_acquire) AO_INLINE int AO_compare_and_swap_acquire(volatile AO_t *addr, AO_t old_val, AO_t new_val) { return AO_fetch_compare_and_swap_acquire(addr, old_val, new_val) == old_val; } # define AO_HAVE_compare_and_swap_acquire # endif # if defined(AO_HAVE_fetch_compare_and_swap_release) \ && !defined(AO_HAVE_compare_and_swap_release) AO_INLINE int AO_compare_and_swap_release(volatile AO_t *addr, AO_t old_val, AO_t new_val) { return AO_fetch_compare_and_swap_release(addr, old_val, new_val) == old_val; } # define AO_HAVE_compare_and_swap_release # endif # if AO_CHAR_TS_T # define AO_TS_COMPARE_AND_SWAP_FULL(a,o,n) \ AO_char_compare_and_swap_full(a,o,n) # define AO_TS_COMPARE_AND_SWAP_ACQUIRE(a,o,n) \ AO_char_compare_and_swap_acquire(a,o,n) # define AO_TS_COMPARE_AND_SWAP_RELEASE(a,o,n) \ AO_char_compare_and_swap_release(a,o,n) # define AO_TS_COMPARE_AND_SWAP(a,o,n) AO_char_compare_and_swap(a,o,n) # endif # if AO_AO_TS_T # define AO_TS_COMPARE_AND_SWAP_FULL(a,o,n) AO_compare_and_swap_full(a,o,n) # define AO_TS_COMPARE_AND_SWAP_ACQUIRE(a,o,n) \ AO_compare_and_swap_acquire(a,o,n) # define AO_TS_COMPARE_AND_SWAP_RELEASE(a,o,n) \ AO_compare_and_swap_release(a,o,n) # define AO_TS_COMPARE_AND_SWAP(a,o,n) AO_compare_and_swap(a,o,n) # endif # if (AO_AO_TS_T && defined(AO_HAVE_compare_and_swap_full)) \ || (AO_CHAR_TS_T && defined(AO_HAVE_char_compare_and_swap_full)) AO_INLINE AO_TS_VAL_t AO_test_and_set_full(volatile AO_TS_t *addr) { if (AO_TS_COMPARE_AND_SWAP_FULL(addr, AO_TS_CLEAR, AO_TS_SET)) return AO_TS_CLEAR; else return AO_TS_SET; } # define AO_HAVE_test_and_set_full # endif /* AO_HAVE_compare_and_swap_full */ # if (AO_AO_TS_T && defined(AO_HAVE_compare_and_swap_acquire)) \ || (AO_CHAR_TS_T && defined(AO_HAVE_char_compare_and_swap_acquire)) AO_INLINE AO_TS_VAL_t AO_test_and_set_acquire(volatile AO_TS_t *addr) { if (AO_TS_COMPARE_AND_SWAP_ACQUIRE(addr, AO_TS_CLEAR, AO_TS_SET)) return AO_TS_CLEAR; else return AO_TS_SET; } # define AO_HAVE_test_and_set_acquire # endif /* AO_HAVE_compare_and_swap_acquire */ # if (AO_AO_TS_T && defined(AO_HAVE_compare_and_swap_release)) \ || (AO_CHAR_TS_T && defined(AO_HAVE_char_compare_and_swap_release)) AO_INLINE AO_TS_VAL_t AO_test_and_set_release(volatile AO_TS_t *addr) { if (AO_TS_COMPARE_AND_SWAP_RELEASE(addr, AO_TS_CLEAR, AO_TS_SET)) return AO_TS_CLEAR; else return AO_TS_SET; } # define AO_HAVE_test_and_set_release # endif /* AO_HAVE_compare_and_swap_release */ # if (AO_AO_TS_T && defined(AO_HAVE_compare_and_swap)) \ || (AO_CHAR_TS_T && defined(AO_HAVE_char_compare_and_swap)) AO_INLINE AO_TS_VAL_t AO_test_and_set(volatile AO_TS_t *addr) { if (AO_TS_COMPARE_AND_SWAP(addr, AO_TS_CLEAR, AO_TS_SET)) return AO_TS_CLEAR; else return AO_TS_SET; } # define AO_HAVE_test_and_set # endif /* AO_HAVE_compare_and_swap */ #endif /* No prior test and set */ /* Nop */ #if !defined(AO_HAVE_nop) AO_INLINE void AO_nop(void) {} # define AO_HAVE_nop #endif #if defined(AO_HAVE_test_and_set_full) && !defined(AO_HAVE_nop_full) AO_INLINE void AO_nop_full(void) { AO_TS_t dummy = AO_TS_INITIALIZER; AO_test_and_set_full(&dummy); } # define AO_HAVE_nop_full #endif #if defined(AO_HAVE_nop_acquire) # error AO_nop_acquire is useless: dont define. #endif #if defined(AO_HAVE_nop_release) # error AO_nop_release is useless: dont define. #endif #if defined(AO_HAVE_nop_full) && !defined(AO_HAVE_nop_read) # define AO_nop_read() AO_nop_full() # define AO_HAVE_nop_read #endif #if defined(AO_HAVE_nop_full) && !defined(AO_HAVE_nop_write) # define AO_nop_write() AO_nop_full() # define AO_HAVE_nop_write #endif /* Test_and_set */ #if defined(AO_HAVE_test_and_set) && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_test_and_set_release) # define AO_test_and_set_release(addr) (AO_nop_full(), AO_test_and_set(addr)) # define AO_HAVE_test_and_set_release #endif #if defined(AO_HAVE_test_and_set) && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_test_and_set_acquire) AO_INLINE AO_TS_VAL_t AO_test_and_set_acquire(volatile AO_TS_t *addr) { AO_TS_VAL_t result = AO_test_and_set(addr); AO_nop_full(); return result; } # define AO_HAVE_test_and_set_acquire #endif #if defined(AO_HAVE_test_and_set_full) # if !defined(AO_HAVE_test_and_set_release) # define AO_test_and_set_release(addr) AO_test_and_set_full(addr) # define AO_HAVE_test_and_set_release # endif # if !defined(AO_HAVE_test_and_set_acquire) # define AO_test_and_set_acquire(addr) AO_test_and_set_full(addr) # define AO_HAVE_test_and_set_acquire # endif # if !defined(AO_HAVE_test_and_set_write) # define AO_test_and_set_write(addr) AO_test_and_set_full(addr) # define AO_HAVE_test_and_set_write # endif # if !defined(AO_HAVE_test_and_set_read) # define AO_test_and_set_read(addr) AO_test_and_set_full(addr) # define AO_HAVE_test_and_set_read # endif #endif /* AO_HAVE_test_and_set_full */ #if !defined(AO_HAVE_test_and_set) && defined(AO_HAVE_test_and_set_release) # define AO_test_and_set(addr) AO_test_and_set_release(addr) # define AO_HAVE_test_and_set #endif #if !defined(AO_HAVE_test_and_set) && defined(AO_HAVE_test_and_set_acquire) # define AO_test_and_set(addr) AO_test_and_set_acquire(addr) # define AO_HAVE_test_and_set #endif #if !defined(AO_HAVE_test_and_set) && defined(AO_HAVE_test_and_set_write) # define AO_test_and_set(addr) AO_test_and_set_write(addr) # define AO_HAVE_test_and_set #endif #if !defined(AO_HAVE_test_and_set) && defined(AO_HAVE_test_and_set_read) # define AO_test_and_set(addr) AO_test_and_set_read(addr) # define AO_HAVE_test_and_set #endif #if defined(AO_HAVE_test_and_set_acquire) && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_test_and_set_full) # define AO_test_and_set_full(addr) \ (AO_nop_full(), AO_test_and_set_acquire(addr)) # define AO_HAVE_test_and_set_full #endif #if !defined(AO_HAVE_test_and_set_release_write) \ && defined(AO_HAVE_test_and_set_write) # define AO_test_and_set_release_write(addr) AO_test_and_set_write(addr) # define AO_HAVE_test_and_set_release_write #endif #if !defined(AO_HAVE_test_and_set_release_write) \ && defined(AO_HAVE_test_and_set_release) # define AO_test_and_set_release_write(addr) AO_test_and_set_release(addr) # define AO_HAVE_test_and_set_release_write #endif #if !defined(AO_HAVE_test_and_set_acquire_read) \ && defined(AO_HAVE_test_and_set_read) # define AO_test_and_set_acquire_read(addr) AO_test_and_set_read(addr) # define AO_HAVE_test_and_set_acquire_read #endif #if !defined(AO_HAVE_test_and_set_acquire_read) \ && defined(AO_HAVE_test_and_set_acquire) # define AO_test_and_set_acquire_read(addr) AO_test_and_set_acquire(addr) # define AO_HAVE_test_and_set_acquire_read #endif #ifdef AO_NO_DD_ORDERING # if defined(AO_HAVE_test_and_set_acquire_read) # define AO_test_and_set_dd_acquire_read(addr) \ AO_test_and_set_acquire_read(addr) # define AO_HAVE_test_and_set_dd_acquire_read # endif #else # if defined(AO_HAVE_test_and_set) # define AO_test_and_set_dd_acquire_read(addr) AO_test_and_set(addr) # define AO_HAVE_test_and_set_dd_acquire_read # endif #endif /* !AO_NO_DD_ORDERING */ #include "generalize-small.h" #include "generalize-arithm.h" /* Compare_double_and_swap_double based on double_compare_and_swap. */ #ifdef AO_HAVE_DOUBLE_PTR_STORAGE # if defined(AO_HAVE_double_compare_and_swap) \ && !defined(AO_HAVE_compare_double_and_swap_double) AO_INLINE int AO_compare_double_and_swap_double(volatile AO_double_t *addr, AO_t old_val1, AO_t old_val2, AO_t new_val1, AO_t new_val2) { AO_double_t old_w; AO_double_t new_w; old_w.AO_val1 = old_val1; old_w.AO_val2 = old_val2; new_w.AO_val1 = new_val1; new_w.AO_val2 = new_val2; return AO_double_compare_and_swap(addr, old_w, new_w); } # define AO_HAVE_compare_double_and_swap_double # endif # if defined(AO_HAVE_double_compare_and_swap_full) \ && !defined(AO_HAVE_compare_double_and_swap_double_full) AO_INLINE int AO_compare_double_and_swap_double_full(volatile AO_double_t *addr, AO_t old_val1, AO_t old_val2, AO_t new_val1, AO_t new_val2) { AO_double_t old_w; AO_double_t new_w; old_w.AO_val1 = old_val1; old_w.AO_val2 = old_val2; new_w.AO_val1 = new_val1; new_w.AO_val2 = new_val2; return AO_double_compare_and_swap_full(addr, old_w, new_w); } # define AO_HAVE_compare_double_and_swap_double_full # endif #endif /* AO_HAVE_DOUBLE_PTR_STORAGE */ /* Compare_double_and_swap_double */ #if defined(AO_HAVE_compare_double_and_swap_double) \ && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_compare_double_and_swap_double_acquire) AO_INLINE int AO_compare_double_and_swap_double_acquire(volatile AO_double_t *addr, AO_t o1, AO_t o2, AO_t n1, AO_t n2) { int result = AO_compare_double_and_swap_double(addr, o1, o2, n1, n2); AO_nop_full(); return result; } # define AO_HAVE_compare_double_and_swap_double_acquire #endif #if defined(AO_HAVE_compare_double_and_swap_double) \ && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_compare_double_and_swap_double_release) # define AO_compare_double_and_swap_double_release(addr,o1,o2,n1,n2) \ (AO_nop_full(), AO_compare_double_and_swap_double(addr,o1,o2,n1,n2)) # define AO_HAVE_compare_double_and_swap_double_release #endif #if defined(AO_HAVE_compare_double_and_swap_double_full) # if !defined(AO_HAVE_compare_double_and_swap_double_release) # define AO_compare_double_and_swap_double_release(addr,o1,o2,n1,n2) \ AO_compare_double_and_swap_double_full(addr,o1,o2,n1,n2) # define AO_HAVE_compare_double_and_swap_double_release # endif # if !defined(AO_HAVE_compare_double_and_swap_double_acquire) # define AO_compare_double_and_swap_double_acquire(addr,o1,o2,n1,n2) \ AO_compare_double_and_swap_double_full(addr,o1,o2,n1,n2) # define AO_HAVE_compare_double_and_swap_double_acquire # endif # if !defined(AO_HAVE_compare_double_and_swap_double_write) # define AO_compare_double_and_swap_double_write(addr,o1,o2,n1,n2) \ AO_compare_double_and_swap_double_full(addr,o1,o2,n1,n2) # define AO_HAVE_compare_double_and_swap_double_write # endif # if !defined(AO_HAVE_compare_double_and_swap_double_read) # define AO_compare_double_and_swap_double_read(addr,o1,o2,n1,n2) \ AO_compare_double_and_swap_double_full(addr,o1,o2,n1,n2) # define AO_HAVE_compare_double_and_swap_double_read # endif #endif /* AO_HAVE_compare_double_and_swap_double_full */ #if !defined(AO_HAVE_compare_double_and_swap_double) \ && defined(AO_HAVE_compare_double_and_swap_double_release) # define AO_compare_double_and_swap_double(addr,o1,o2,n1,n2) \ AO_compare_double_and_swap_double_release(addr,o1,o2,n1,n2) # define AO_HAVE_compare_double_and_swap_double #endif #if !defined(AO_HAVE_compare_double_and_swap_double) \ && defined(AO_HAVE_compare_double_and_swap_double_acquire) # define AO_compare_double_and_swap_double(addr,o1,o2,n1,n2) \ AO_compare_double_and_swap_double_acquire(addr,o1,o2,n1,n2) # define AO_HAVE_compare_double_and_swap_double #endif #if !defined(AO_HAVE_compare_double_and_swap_double) \ && defined(AO_HAVE_compare_double_and_swap_double_write) # define AO_compare_double_and_swap_double(addr,o1,o2,n1,n2) \ AO_compare_double_and_swap_double_write(addr,o1,o2,n1,n2) # define AO_HAVE_compare_double_and_swap_double #endif #if !defined(AO_HAVE_compare_double_and_swap_double) \ && defined(AO_HAVE_compare_double_and_swap_double_read) # define AO_compare_double_and_swap_double(addr,o1,o2,n1,n2) \ AO_compare_double_and_swap_double_read(addr,o1,o2,n1,n2) # define AO_HAVE_compare_double_and_swap_double #endif #if defined(AO_HAVE_compare_double_and_swap_double_acquire) \ && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_compare_double_and_swap_double_full) # define AO_compare_double_and_swap_double_full(addr,o1,o2,n1,n2) \ (AO_nop_full(), \ AO_compare_double_and_swap_double_acquire(addr,o1,o2,n1,n2)) # define AO_HAVE_compare_double_and_swap_double_full #endif #if !defined(AO_HAVE_compare_double_and_swap_double_release_write) \ && defined(AO_HAVE_compare_double_and_swap_double_write) # define AO_compare_double_and_swap_double_release_write(addr,o1,o2,n1,n2) \ AO_compare_double_and_swap_double_write(addr,o1,o2,n1,n2) # define AO_HAVE_compare_double_and_swap_double_release_write #endif #if !defined(AO_HAVE_compare_double_and_swap_double_release_write) \ && defined(AO_HAVE_compare_double_and_swap_double_release) # define AO_compare_double_and_swap_double_release_write(addr,o1,o2,n1,n2) \ AO_compare_double_and_swap_double_release(addr,o1,o2,n1,n2) # define AO_HAVE_compare_double_and_swap_double_release_write #endif #if !defined(AO_HAVE_compare_double_and_swap_double_acquire_read) \ && defined(AO_HAVE_compare_double_and_swap_double_read) # define AO_compare_double_and_swap_double_acquire_read(addr,o1,o2,n1,n2) \ AO_compare_double_and_swap_double_read(addr,o1,o2,n1,n2) # define AO_HAVE_compare_double_and_swap_double_acquire_read #endif #if !defined(AO_HAVE_compare_double_and_swap_double_acquire_read) \ && defined(AO_HAVE_compare_double_and_swap_double_acquire) # define AO_compare_double_and_swap_double_acquire_read(addr,o1,o2,n1,n2) \ AO_compare_double_and_swap_double_acquire(addr,o1,o2,n1,n2) # define AO_HAVE_compare_double_and_swap_double_acquire_read #endif #ifdef AO_NO_DD_ORDERING # if defined(AO_HAVE_compare_double_and_swap_double_acquire_read) # define AO_compare_double_and_swap_double_dd_acquire_read(addr,o1,o2,n1,n2) \ AO_compare_double_and_swap_double_acquire_read(addr,o1,o2,n1,n2) # define AO_HAVE_compare_double_and_swap_double_dd_acquire_read # endif #else # if defined(AO_HAVE_compare_double_and_swap_double) # define AO_compare_double_and_swap_double_dd_acquire_read(addr,o1,o2,n1,n2) \ AO_compare_double_and_swap_double(addr,o1,o2,n1,n2) # define AO_HAVE_compare_double_and_swap_double_dd_acquire_read # endif #endif /* !AO_NO_DD_ORDERING */ /* Compare_and_swap_double */ #if defined(AO_HAVE_compare_and_swap_double) && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_compare_and_swap_double_acquire) AO_INLINE int AO_compare_and_swap_double_acquire(volatile AO_double_t *addr, AO_t o1, AO_t n1, AO_t n2) { int result = AO_compare_and_swap_double(addr, o1, n1, n2); AO_nop_full(); return result; } # define AO_HAVE_compare_and_swap_double_acquire #endif #if defined(AO_HAVE_compare_and_swap_double) \ && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_compare_and_swap_double_release) # define AO_compare_and_swap_double_release(addr,o1,n1,n2) \ (AO_nop_full(), AO_compare_and_swap_double(addr,o1,n1,n2)) # define AO_HAVE_compare_and_swap_double_release #endif #if defined(AO_HAVE_compare_and_swap_double_full) # if !defined(AO_HAVE_compare_and_swap_double_release) # define AO_compare_and_swap_double_release(addr,o1,n1,n2) \ AO_compare_and_swap_double_full(addr,o1,n1,n2) # define AO_HAVE_compare_and_swap_double_release # endif # if !defined(AO_HAVE_compare_and_swap_double_acquire) # define AO_compare_and_swap_double_acquire(addr,o1,n1,n2) \ AO_compare_and_swap_double_full(addr,o1,n1,n2) # define AO_HAVE_compare_and_swap_double_acquire # endif # if !defined(AO_HAVE_compare_and_swap_double_write) # define AO_compare_and_swap_double_write(addr,o1,n1,n2) \ AO_compare_and_swap_double_full(addr,o1,n1,n2) # define AO_HAVE_compare_and_swap_double_write # endif # if !defined(AO_HAVE_compare_and_swap_double_read) # define AO_compare_and_swap_double_read(addr,o1,n1,n2) \ AO_compare_and_swap_double_full(addr,o1,n1,n2) # define AO_HAVE_compare_and_swap_double_read # endif #endif /* AO_HAVE_compare_and_swap_double_full */ #if !defined(AO_HAVE_compare_and_swap_double) \ && defined(AO_HAVE_compare_and_swap_double_release) # define AO_compare_and_swap_double(addr,o1,n1,n2) \ AO_compare_and_swap_double_release(addr,o1,n1,n2) # define AO_HAVE_compare_and_swap_double #endif #if !defined(AO_HAVE_compare_and_swap_double) \ && defined(AO_HAVE_compare_and_swap_double_acquire) # define AO_compare_and_swap_double(addr,o1,n1,n2) \ AO_compare_and_swap_double_acquire(addr,o1,n1,n2) # define AO_HAVE_compare_and_swap_double #endif #if !defined(AO_HAVE_compare_and_swap_double) \ && defined(AO_HAVE_compare_and_swap_double_write) # define AO_compare_and_swap_double(addr,o1,n1,n2) \ AO_compare_and_swap_double_write(addr,o1,n1,n2) # define AO_HAVE_compare_and_swap_double #endif #if !defined(AO_HAVE_compare_and_swap_double) \ && defined(AO_HAVE_compare_and_swap_double_read) # define AO_compare_and_swap_double(addr,o1,n1,n2) \ AO_compare_and_swap_double_read(addr,o1,n1,n2) # define AO_HAVE_compare_and_swap_double #endif #if defined(AO_HAVE_compare_and_swap_double_acquire) \ && defined(AO_HAVE_nop_full) \ && !defined(AO_HAVE_compare_and_swap_double_full) # define AO_compare_and_swap_double_full(addr,o1,n1,n2) \ (AO_nop_full(), AO_compare_and_swap_double_acquire(addr,o1,n1,n2)) # define AO_HAVE_compare_and_swap_double_full #endif #if !defined(AO_HAVE_compare_and_swap_double_release_write) \ && defined(AO_HAVE_compare_and_swap_double_write) # define AO_compare_and_swap_double_release_write(addr,o1,n1,n2) \ AO_compare_and_swap_double_write(addr,o1,n1,n2) # define AO_HAVE_compare_and_swap_double_release_write #endif #if !defined(AO_HAVE_compare_and_swap_double_release_write) \ && defined(AO_HAVE_compare_and_swap_double_release) # define AO_compare_and_swap_double_release_write(addr,o1,n1,n2) \ AO_compare_and_swap_double_release(addr,o1,n1,n2) # define AO_HAVE_compare_and_swap_double_release_write #endif #if !defined(AO_HAVE_compare_and_swap_double_acquire_read) \ && defined(AO_HAVE_compare_and_swap_double_read) # define AO_compare_and_swap_double_acquire_read(addr,o1,n1,n2) \ AO_compare_and_swap_double_read(addr,o1,n1,n2) # define AO_HAVE_compare_and_swap_double_acquire_read #endif #if !defined(AO_HAVE_compare_and_swap_double_acquire_read) \ && defined(AO_HAVE_compare_and_swap_double_acquire) # define AO_compare_and_swap_double_acquire_read(addr,o1,n1,n2) \ AO_compare_and_swap_double_acquire(addr,o1,n1,n2) # define AO_HAVE_compare_and_swap_double_acquire_read #endif #ifdef AO_NO_DD_ORDERING # if defined(AO_HAVE_compare_and_swap_double_acquire_read) # define AO_compare_and_swap_double_dd_acquire_read(addr,o1,n1,n2) \ AO_compare_and_swap_double_acquire_read(addr,o1,n1,n2) # define AO_HAVE_compare_and_swap_double_dd_acquire_read # endif #else # if defined(AO_HAVE_compare_and_swap_double) # define AO_compare_and_swap_double_dd_acquire_read(addr,o1,n1,n2) \ AO_compare_and_swap_double(addr,o1,n1,n2) # define AO_HAVE_compare_and_swap_double_dd_acquire_read # endif #endif /* Convenience functions for AO_double compare-and-swap which types and */ /* reads easier in code. */ #if defined(AO_HAVE_compare_double_and_swap_double) \ && !defined(AO_HAVE_double_compare_and_swap) AO_INLINE int AO_double_compare_and_swap(volatile AO_double_t *addr, AO_double_t old_val, AO_double_t new_val) { return AO_compare_double_and_swap_double(addr, old_val.AO_val1, old_val.AO_val2, new_val.AO_val1, new_val.AO_val2); } # define AO_HAVE_double_compare_and_swap #endif #if defined(AO_HAVE_compare_double_and_swap_double_release) \ && !defined(AO_HAVE_double_compare_and_swap_release) AO_INLINE int AO_double_compare_and_swap_release(volatile AO_double_t *addr, AO_double_t old_val, AO_double_t new_val) { return AO_compare_double_and_swap_double_release(addr, old_val.AO_val1, old_val.AO_val2, new_val.AO_val1, new_val.AO_val2); } # define AO_HAVE_double_compare_and_swap_release #endif #if defined(AO_HAVE_compare_double_and_swap_double_acquire) \ && !defined(AO_HAVE_double_compare_and_swap_acquire) AO_INLINE int AO_double_compare_and_swap_acquire(volatile AO_double_t *addr, AO_double_t old_val, AO_double_t new_val) { return AO_compare_double_and_swap_double_acquire(addr, old_val.AO_val1, old_val.AO_val2, new_val.AO_val1, new_val.AO_val2); } # define AO_HAVE_double_compare_and_swap_acquire #endif #if defined(AO_HAVE_compare_double_and_swap_double_read) \ && !defined(AO_HAVE_double_compare_and_swap_read) AO_INLINE int AO_double_compare_and_swap_read(volatile AO_double_t *addr, AO_double_t old_val, AO_double_t new_val) { return AO_compare_double_and_swap_double_read(addr, old_val.AO_val1, old_val.AO_val2, new_val.AO_val1, new_val.AO_val2); } # define AO_HAVE_double_compare_and_swap_read #endif #if defined(AO_HAVE_compare_double_and_swap_double_write) \ && !defined(AO_HAVE_double_compare_and_swap_write) AO_INLINE int AO_double_compare_and_swap_write(volatile AO_double_t *addr, AO_double_t old_val, AO_double_t new_val) { return AO_compare_double_and_swap_double_write(addr, old_val.AO_val1, old_val.AO_val2, new_val.AO_val1, new_val.AO_val2); } # define AO_HAVE_double_compare_and_swap_write #endif #if defined(AO_HAVE_compare_double_and_swap_double_release_write) \ && !defined(AO_HAVE_double_compare_and_swap_release_write) AO_INLINE int AO_double_compare_and_swap_release_write(volatile AO_double_t *addr, AO_double_t old_val, AO_double_t new_val) { return AO_compare_double_and_swap_double_release_write(addr, old_val.AO_val1, old_val.AO_val2, new_val.AO_val1, new_val.AO_val2); } # define AO_HAVE_double_compare_and_swap_release_write #endif #if defined(AO_HAVE_compare_double_and_swap_double_acquire_read) \ && !defined(AO_HAVE_double_compare_and_swap_acquire_read) AO_INLINE int AO_double_compare_and_swap_acquire_read(volatile AO_double_t *addr, AO_double_t old_val, AO_double_t new_val) { return AO_compare_double_and_swap_double_acquire_read(addr, old_val.AO_val1, old_val.AO_val2, new_val.AO_val1, new_val.AO_val2); } # define AO_HAVE_double_compare_and_swap_acquire_read #endif #if defined(AO_HAVE_compare_double_and_swap_double_full) \ && !defined(AO_HAVE_double_compare_and_swap_full) AO_INLINE int AO_double_compare_and_swap_full(volatile AO_double_t *addr, AO_double_t old_val, AO_double_t new_val) { return AO_compare_double_and_swap_double_full(addr, old_val.AO_val1, old_val.AO_val2, new_val.AO_val1, new_val.AO_val2); } # define AO_HAVE_double_compare_and_swap_full #endif ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/000077500000000000000000000000001266352375300234775ustar00rootroot00000000000000ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/README000066400000000000000000000005411266352375300243570ustar00rootroot00000000000000There are two kinds of entities in this directory: - Subdirectories corresponding to specific compilers (or compiler/OS combinations). Each of these includes one or more architecture-specific headers. - More generic header files corresponding to a particular ordering and/or atomicity property that might be shared by multiple hardware platforms. ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/all_acquire_release_volatile.h000066400000000000000000000030541266352375300315320ustar00rootroot00000000000000/* * Copyright (c) 2004 Hewlett-Packard Development Company, L.P. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ /* Describes architectures on which volatile AO_t, unsigned char, */ /* unsigned short, and unsigned int loads and stores have */ /* acquire/release semantics for all normally legal alignments. */ #include "loadstore/acquire_release_volatile.h" #include "loadstore/char_acquire_release_volatile.h" #include "loadstore/short_acquire_release_volatile.h" #include "loadstore/int_acquire_release_volatile.h" ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/all_aligned_atomic_load_store.h000066400000000000000000000030251266352375300316520ustar00rootroot00000000000000/* * Copyright (c) 2004 Hewlett-Packard Development Company, L.P. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ /* Describes architectures on which AO_t, unsigned char, unsigned */ /* short, and unsigned int loads and stores are atomic but only if data */ /* is suitably aligned. */ #define AO_ACCESS_CHECK_ALIGNED /* Check for char type is a misnomer. */ #define AO_ACCESS_short_CHECK_ALIGNED #define AO_ACCESS_int_CHECK_ALIGNED #include "all_atomic_load_store.h" ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/all_atomic_load_store.h000066400000000000000000000030371266352375300301720ustar00rootroot00000000000000/* * Copyright (c) 2004 Hewlett-Packard Development Company, L.P. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ /* Describes architectures on which AO_t, unsigned char, unsigned */ /* short, and unsigned int loads and stores are atomic for all normally */ /* legal alignments. */ #include "all_atomic_only_load.h" #include "loadstore/atomic_store.h" #include "loadstore/char_atomic_store.h" #include "loadstore/short_atomic_store.h" #include "loadstore/int_atomic_store.h" ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/all_atomic_only_load.h000066400000000000000000000027701266352375300300220ustar00rootroot00000000000000/* * Copyright (c) 2004 Hewlett-Packard Development Company, L.P. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ /* Describes architectures on which AO_t, unsigned char, unsigned */ /* short, and unsigned int loads are atomic for all normally legal */ /* alignments. */ #include "loadstore/atomic_load.h" #include "loadstore/char_atomic_load.h" #include "loadstore/short_atomic_load.h" #include "loadstore/int_atomic_load.h" ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/ao_t_is_int.h000066400000000000000000000560401266352375300261440ustar00rootroot00000000000000/* * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ /* Inclusion of this file signifies that AO_t is in fact int. */ /* Hence any AO_... operation can also serve as AO_int_... operation. */ #if defined(AO_HAVE_load) && !defined(AO_HAVE_int_load) # define AO_int_load(addr) \ (unsigned)AO_load((const volatile AO_t *)(addr)) # define AO_HAVE_int_load #endif #if defined(AO_HAVE_store) && !defined(AO_HAVE_int_store) # define AO_int_store(addr, val) \ AO_store((volatile AO_t *)(addr), (AO_t)(val)) # define AO_HAVE_int_store #endif #if defined(AO_HAVE_fetch_and_add) \ && !defined(AO_HAVE_int_fetch_and_add) # define AO_int_fetch_and_add(addr, incr) \ (unsigned)AO_fetch_and_add((volatile AO_t *)(addr), \ (AO_t)(incr)) # define AO_HAVE_int_fetch_and_add #endif #if defined(AO_HAVE_fetch_and_add1) \ && !defined(AO_HAVE_int_fetch_and_add1) # define AO_int_fetch_and_add1(addr) \ (unsigned)AO_fetch_and_add1((volatile AO_t *)(addr)) # define AO_HAVE_int_fetch_and_add1 #endif #if defined(AO_HAVE_fetch_and_sub1) \ && !defined(AO_HAVE_int_fetch_and_sub1) # define AO_int_fetch_and_sub1(addr) \ (unsigned)AO_fetch_and_sub1((volatile AO_t *)(addr)) # define AO_HAVE_int_fetch_and_sub1 #endif #if defined(AO_HAVE_and) && !defined(AO_HAVE_int_and) # define AO_int_and(addr, val) \ AO_and((volatile AO_t *)(addr), (AO_t)(val)) # define AO_HAVE_int_and #endif #if defined(AO_HAVE_or) && !defined(AO_HAVE_int_or) # define AO_int_or(addr, val) \ AO_or((volatile AO_t *)(addr), (AO_t)(val)) # define AO_HAVE_int_or #endif #if defined(AO_HAVE_xor) && !defined(AO_HAVE_int_xor) # define AO_int_xor(addr, val) \ AO_xor((volatile AO_t *)(addr), (AO_t)(val)) # define AO_HAVE_int_xor #endif #if defined(AO_HAVE_fetch_compare_and_swap) \ && !defined(AO_HAVE_int_fetch_compare_and_swap) # define AO_int_fetch_compare_and_swap(addr, old, new_val) \ (unsigned)AO_fetch_compare_and_swap((volatile AO_t *)(addr), \ (AO_t)(old), (AO_t)(new_val)) # define AO_HAVE_int_fetch_compare_and_swap #endif #if defined(AO_HAVE_compare_and_swap) \ && !defined(AO_HAVE_int_compare_and_swap) # define AO_int_compare_and_swap(addr, old, new_val) \ AO_compare_and_swap((volatile AO_t *)(addr), \ (AO_t)(old), (AO_t)(new_val)) # define AO_HAVE_int_compare_and_swap #endif /* * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ /* Inclusion of this file signifies that AO_t is in fact int. */ /* Hence any AO_... operation can also serve as AO_int_... operation. */ #if defined(AO_HAVE_load_full) && !defined(AO_HAVE_int_load_full) # define AO_int_load_full(addr) \ (unsigned)AO_load_full((const volatile AO_t *)(addr)) # define AO_HAVE_int_load_full #endif #if defined(AO_HAVE_store_full) && !defined(AO_HAVE_int_store_full) # define AO_int_store_full(addr, val) \ AO_store_full((volatile AO_t *)(addr), (AO_t)(val)) # define AO_HAVE_int_store_full #endif #if defined(AO_HAVE_fetch_and_add_full) \ && !defined(AO_HAVE_int_fetch_and_add_full) # define AO_int_fetch_and_add_full(addr, incr) \ (unsigned)AO_fetch_and_add_full((volatile AO_t *)(addr), \ (AO_t)(incr)) # define AO_HAVE_int_fetch_and_add_full #endif #if defined(AO_HAVE_fetch_and_add1_full) \ && !defined(AO_HAVE_int_fetch_and_add1_full) # define AO_int_fetch_and_add1_full(addr) \ (unsigned)AO_fetch_and_add1_full((volatile AO_t *)(addr)) # define AO_HAVE_int_fetch_and_add1_full #endif #if defined(AO_HAVE_fetch_and_sub1_full) \ && !defined(AO_HAVE_int_fetch_and_sub1_full) # define AO_int_fetch_and_sub1_full(addr) \ (unsigned)AO_fetch_and_sub1_full((volatile AO_t *)(addr)) # define AO_HAVE_int_fetch_and_sub1_full #endif #if defined(AO_HAVE_and_full) && !defined(AO_HAVE_int_and_full) # define AO_int_and_full(addr, val) \ AO_and_full((volatile AO_t *)(addr), (AO_t)(val)) # define AO_HAVE_int_and_full #endif #if defined(AO_HAVE_or_full) && !defined(AO_HAVE_int_or_full) # define AO_int_or_full(addr, val) \ AO_or_full((volatile AO_t *)(addr), (AO_t)(val)) # define AO_HAVE_int_or_full #endif #if defined(AO_HAVE_xor_full) && !defined(AO_HAVE_int_xor_full) # define AO_int_xor_full(addr, val) \ AO_xor_full((volatile AO_t *)(addr), (AO_t)(val)) # define AO_HAVE_int_xor_full #endif #if defined(AO_HAVE_fetch_compare_and_swap_full) \ && !defined(AO_HAVE_int_fetch_compare_and_swap_full) # define AO_int_fetch_compare_and_swap_full(addr, old, new_val) \ (unsigned)AO_fetch_compare_and_swap_full((volatile AO_t *)(addr), \ (AO_t)(old), (AO_t)(new_val)) # define AO_HAVE_int_fetch_compare_and_swap_full #endif #if defined(AO_HAVE_compare_and_swap_full) \ && !defined(AO_HAVE_int_compare_and_swap_full) # define AO_int_compare_and_swap_full(addr, old, new_val) \ AO_compare_and_swap_full((volatile AO_t *)(addr), \ (AO_t)(old), (AO_t)(new_val)) # define AO_HAVE_int_compare_and_swap_full #endif /* * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ /* Inclusion of this file signifies that AO_t is in fact int. */ /* Hence any AO_... operation can also serve as AO_int_... operation. */ #if defined(AO_HAVE_load_acquire) && !defined(AO_HAVE_int_load_acquire) # define AO_int_load_acquire(addr) \ (unsigned)AO_load_acquire((const volatile AO_t *)(addr)) # define AO_HAVE_int_load_acquire #endif #if defined(AO_HAVE_store_acquire) && !defined(AO_HAVE_int_store_acquire) # define AO_int_store_acquire(addr, val) \ AO_store_acquire((volatile AO_t *)(addr), (AO_t)(val)) # define AO_HAVE_int_store_acquire #endif #if defined(AO_HAVE_fetch_and_add_acquire) \ && !defined(AO_HAVE_int_fetch_and_add_acquire) # define AO_int_fetch_and_add_acquire(addr, incr) \ (unsigned)AO_fetch_and_add_acquire((volatile AO_t *)(addr), \ (AO_t)(incr)) # define AO_HAVE_int_fetch_and_add_acquire #endif #if defined(AO_HAVE_fetch_and_add1_acquire) \ && !defined(AO_HAVE_int_fetch_and_add1_acquire) # define AO_int_fetch_and_add1_acquire(addr) \ (unsigned)AO_fetch_and_add1_acquire((volatile AO_t *)(addr)) # define AO_HAVE_int_fetch_and_add1_acquire #endif #if defined(AO_HAVE_fetch_and_sub1_acquire) \ && !defined(AO_HAVE_int_fetch_and_sub1_acquire) # define AO_int_fetch_and_sub1_acquire(addr) \ (unsigned)AO_fetch_and_sub1_acquire((volatile AO_t *)(addr)) # define AO_HAVE_int_fetch_and_sub1_acquire #endif #if defined(AO_HAVE_and_acquire) && !defined(AO_HAVE_int_and_acquire) # define AO_int_and_acquire(addr, val) \ AO_and_acquire((volatile AO_t *)(addr), (AO_t)(val)) # define AO_HAVE_int_and_acquire #endif #if defined(AO_HAVE_or_acquire) && !defined(AO_HAVE_int_or_acquire) # define AO_int_or_acquire(addr, val) \ AO_or_acquire((volatile AO_t *)(addr), (AO_t)(val)) # define AO_HAVE_int_or_acquire #endif #if defined(AO_HAVE_xor_acquire) && !defined(AO_HAVE_int_xor_acquire) # define AO_int_xor_acquire(addr, val) \ AO_xor_acquire((volatile AO_t *)(addr), (AO_t)(val)) # define AO_HAVE_int_xor_acquire #endif #if defined(AO_HAVE_fetch_compare_and_swap_acquire) \ && !defined(AO_HAVE_int_fetch_compare_and_swap_acquire) # define AO_int_fetch_compare_and_swap_acquire(addr, old, new_val) \ (unsigned)AO_fetch_compare_and_swap_acquire((volatile AO_t *)(addr), \ (AO_t)(old), (AO_t)(new_val)) # define AO_HAVE_int_fetch_compare_and_swap_acquire #endif #if defined(AO_HAVE_compare_and_swap_acquire) \ && !defined(AO_HAVE_int_compare_and_swap_acquire) # define AO_int_compare_and_swap_acquire(addr, old, new_val) \ AO_compare_and_swap_acquire((volatile AO_t *)(addr), \ (AO_t)(old), (AO_t)(new_val)) # define AO_HAVE_int_compare_and_swap_acquire #endif /* * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ /* Inclusion of this file signifies that AO_t is in fact int. */ /* Hence any AO_... operation can also serve as AO_int_... operation. */ #if defined(AO_HAVE_load_release) && !defined(AO_HAVE_int_load_release) # define AO_int_load_release(addr) \ (unsigned)AO_load_release((const volatile AO_t *)(addr)) # define AO_HAVE_int_load_release #endif #if defined(AO_HAVE_store_release) && !defined(AO_HAVE_int_store_release) # define AO_int_store_release(addr, val) \ AO_store_release((volatile AO_t *)(addr), (AO_t)(val)) # define AO_HAVE_int_store_release #endif #if defined(AO_HAVE_fetch_and_add_release) \ && !defined(AO_HAVE_int_fetch_and_add_release) # define AO_int_fetch_and_add_release(addr, incr) \ (unsigned)AO_fetch_and_add_release((volatile AO_t *)(addr), \ (AO_t)(incr)) # define AO_HAVE_int_fetch_and_add_release #endif #if defined(AO_HAVE_fetch_and_add1_release) \ && !defined(AO_HAVE_int_fetch_and_add1_release) # define AO_int_fetch_and_add1_release(addr) \ (unsigned)AO_fetch_and_add1_release((volatile AO_t *)(addr)) # define AO_HAVE_int_fetch_and_add1_release #endif #if defined(AO_HAVE_fetch_and_sub1_release) \ && !defined(AO_HAVE_int_fetch_and_sub1_release) # define AO_int_fetch_and_sub1_release(addr) \ (unsigned)AO_fetch_and_sub1_release((volatile AO_t *)(addr)) # define AO_HAVE_int_fetch_and_sub1_release #endif #if defined(AO_HAVE_and_release) && !defined(AO_HAVE_int_and_release) # define AO_int_and_release(addr, val) \ AO_and_release((volatile AO_t *)(addr), (AO_t)(val)) # define AO_HAVE_int_and_release #endif #if defined(AO_HAVE_or_release) && !defined(AO_HAVE_int_or_release) # define AO_int_or_release(addr, val) \ AO_or_release((volatile AO_t *)(addr), (AO_t)(val)) # define AO_HAVE_int_or_release #endif #if defined(AO_HAVE_xor_release) && !defined(AO_HAVE_int_xor_release) # define AO_int_xor_release(addr, val) \ AO_xor_release((volatile AO_t *)(addr), (AO_t)(val)) # define AO_HAVE_int_xor_release #endif #if defined(AO_HAVE_fetch_compare_and_swap_release) \ && !defined(AO_HAVE_int_fetch_compare_and_swap_release) # define AO_int_fetch_compare_and_swap_release(addr, old, new_val) \ (unsigned)AO_fetch_compare_and_swap_release((volatile AO_t *)(addr), \ (AO_t)(old), (AO_t)(new_val)) # define AO_HAVE_int_fetch_compare_and_swap_release #endif #if defined(AO_HAVE_compare_and_swap_release) \ && !defined(AO_HAVE_int_compare_and_swap_release) # define AO_int_compare_and_swap_release(addr, old, new_val) \ AO_compare_and_swap_release((volatile AO_t *)(addr), \ (AO_t)(old), (AO_t)(new_val)) # define AO_HAVE_int_compare_and_swap_release #endif /* * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ /* Inclusion of this file signifies that AO_t is in fact int. */ /* Hence any AO_... operation can also serve as AO_int_... operation. */ #if defined(AO_HAVE_load_write) && !defined(AO_HAVE_int_load_write) # define AO_int_load_write(addr) \ (unsigned)AO_load_write((const volatile AO_t *)(addr)) # define AO_HAVE_int_load_write #endif #if defined(AO_HAVE_store_write) && !defined(AO_HAVE_int_store_write) # define AO_int_store_write(addr, val) \ AO_store_write((volatile AO_t *)(addr), (AO_t)(val)) # define AO_HAVE_int_store_write #endif #if defined(AO_HAVE_fetch_and_add_write) \ && !defined(AO_HAVE_int_fetch_and_add_write) # define AO_int_fetch_and_add_write(addr, incr) \ (unsigned)AO_fetch_and_add_write((volatile AO_t *)(addr), \ (AO_t)(incr)) # define AO_HAVE_int_fetch_and_add_write #endif #if defined(AO_HAVE_fetch_and_add1_write) \ && !defined(AO_HAVE_int_fetch_and_add1_write) # define AO_int_fetch_and_add1_write(addr) \ (unsigned)AO_fetch_and_add1_write((volatile AO_t *)(addr)) # define AO_HAVE_int_fetch_and_add1_write #endif #if defined(AO_HAVE_fetch_and_sub1_write) \ && !defined(AO_HAVE_int_fetch_and_sub1_write) # define AO_int_fetch_and_sub1_write(addr) \ (unsigned)AO_fetch_and_sub1_write((volatile AO_t *)(addr)) # define AO_HAVE_int_fetch_and_sub1_write #endif #if defined(AO_HAVE_and_write) && !defined(AO_HAVE_int_and_write) # define AO_int_and_write(addr, val) \ AO_and_write((volatile AO_t *)(addr), (AO_t)(val)) # define AO_HAVE_int_and_write #endif #if defined(AO_HAVE_or_write) && !defined(AO_HAVE_int_or_write) # define AO_int_or_write(addr, val) \ AO_or_write((volatile AO_t *)(addr), (AO_t)(val)) # define AO_HAVE_int_or_write #endif #if defined(AO_HAVE_xor_write) && !defined(AO_HAVE_int_xor_write) # define AO_int_xor_write(addr, val) \ AO_xor_write((volatile AO_t *)(addr), (AO_t)(val)) # define AO_HAVE_int_xor_write #endif #if defined(AO_HAVE_fetch_compare_and_swap_write) \ && !defined(AO_HAVE_int_fetch_compare_and_swap_write) # define AO_int_fetch_compare_and_swap_write(addr, old, new_val) \ (unsigned)AO_fetch_compare_and_swap_write((volatile AO_t *)(addr), \ (AO_t)(old), (AO_t)(new_val)) # define AO_HAVE_int_fetch_compare_and_swap_write #endif #if defined(AO_HAVE_compare_and_swap_write) \ && !defined(AO_HAVE_int_compare_and_swap_write) # define AO_int_compare_and_swap_write(addr, old, new_val) \ AO_compare_and_swap_write((volatile AO_t *)(addr), \ (AO_t)(old), (AO_t)(new_val)) # define AO_HAVE_int_compare_and_swap_write #endif /* * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ /* Inclusion of this file signifies that AO_t is in fact int. */ /* Hence any AO_... operation can also serve as AO_int_... operation. */ #if defined(AO_HAVE_load_read) && !defined(AO_HAVE_int_load_read) # define AO_int_load_read(addr) \ (unsigned)AO_load_read((const volatile AO_t *)(addr)) # define AO_HAVE_int_load_read #endif #if defined(AO_HAVE_store_read) && !defined(AO_HAVE_int_store_read) # define AO_int_store_read(addr, val) \ AO_store_read((volatile AO_t *)(addr), (AO_t)(val)) # define AO_HAVE_int_store_read #endif #if defined(AO_HAVE_fetch_and_add_read) \ && !defined(AO_HAVE_int_fetch_and_add_read) # define AO_int_fetch_and_add_read(addr, incr) \ (unsigned)AO_fetch_and_add_read((volatile AO_t *)(addr), \ (AO_t)(incr)) # define AO_HAVE_int_fetch_and_add_read #endif #if defined(AO_HAVE_fetch_and_add1_read) \ && !defined(AO_HAVE_int_fetch_and_add1_read) # define AO_int_fetch_and_add1_read(addr) \ (unsigned)AO_fetch_and_add1_read((volatile AO_t *)(addr)) # define AO_HAVE_int_fetch_and_add1_read #endif #if defined(AO_HAVE_fetch_and_sub1_read) \ && !defined(AO_HAVE_int_fetch_and_sub1_read) # define AO_int_fetch_and_sub1_read(addr) \ (unsigned)AO_fetch_and_sub1_read((volatile AO_t *)(addr)) # define AO_HAVE_int_fetch_and_sub1_read #endif #if defined(AO_HAVE_and_read) && !defined(AO_HAVE_int_and_read) # define AO_int_and_read(addr, val) \ AO_and_read((volatile AO_t *)(addr), (AO_t)(val)) # define AO_HAVE_int_and_read #endif #if defined(AO_HAVE_or_read) && !defined(AO_HAVE_int_or_read) # define AO_int_or_read(addr, val) \ AO_or_read((volatile AO_t *)(addr), (AO_t)(val)) # define AO_HAVE_int_or_read #endif #if defined(AO_HAVE_xor_read) && !defined(AO_HAVE_int_xor_read) # define AO_int_xor_read(addr, val) \ AO_xor_read((volatile AO_t *)(addr), (AO_t)(val)) # define AO_HAVE_int_xor_read #endif #if defined(AO_HAVE_fetch_compare_and_swap_read) \ && !defined(AO_HAVE_int_fetch_compare_and_swap_read) # define AO_int_fetch_compare_and_swap_read(addr, old, new_val) \ (unsigned)AO_fetch_compare_and_swap_read((volatile AO_t *)(addr), \ (AO_t)(old), (AO_t)(new_val)) # define AO_HAVE_int_fetch_compare_and_swap_read #endif #if defined(AO_HAVE_compare_and_swap_read) \ && !defined(AO_HAVE_int_compare_and_swap_read) # define AO_int_compare_and_swap_read(addr, old, new_val) \ AO_compare_and_swap_read((volatile AO_t *)(addr), \ (AO_t)(old), (AO_t)(new_val)) # define AO_HAVE_int_compare_and_swap_read #endif ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/ao_t_is_int.template000066400000000000000000000075121266352375300275300ustar00rootroot00000000000000/* * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ /* Inclusion of this file signifies that AO_t is in fact int. */ /* Hence any AO_... operation can also serve as AO_int_... operation. */ #if defined(AO_HAVE_load_XBAR) && !defined(AO_HAVE_int_load_XBAR) # define AO_int_load_XBAR(addr) \ (unsigned)AO_load_XBAR((const volatile AO_t *)(addr)) # define AO_HAVE_int_load_XBAR #endif #if defined(AO_HAVE_store_XBAR) && !defined(AO_HAVE_int_store_XBAR) # define AO_int_store_XBAR(addr, val) \ AO_store_XBAR((volatile AO_t *)(addr), (AO_t)(val)) # define AO_HAVE_int_store_XBAR #endif #if defined(AO_HAVE_fetch_and_add_XBAR) \ && !defined(AO_HAVE_int_fetch_and_add_XBAR) # define AO_int_fetch_and_add_XBAR(addr, incr) \ (unsigned)AO_fetch_and_add_XBAR((volatile AO_t *)(addr), \ (AO_t)(incr)) # define AO_HAVE_int_fetch_and_add_XBAR #endif #if defined(AO_HAVE_fetch_and_add1_XBAR) \ && !defined(AO_HAVE_int_fetch_and_add1_XBAR) # define AO_int_fetch_and_add1_XBAR(addr) \ (unsigned)AO_fetch_and_add1_XBAR((volatile AO_t *)(addr)) # define AO_HAVE_int_fetch_and_add1_XBAR #endif #if defined(AO_HAVE_fetch_and_sub1_XBAR) \ && !defined(AO_HAVE_int_fetch_and_sub1_XBAR) # define AO_int_fetch_and_sub1_XBAR(addr) \ (unsigned)AO_fetch_and_sub1_XBAR((volatile AO_t *)(addr)) # define AO_HAVE_int_fetch_and_sub1_XBAR #endif #if defined(AO_HAVE_and_XBAR) && !defined(AO_HAVE_int_and_XBAR) # define AO_int_and_XBAR(addr, val) \ AO_and_XBAR((volatile AO_t *)(addr), (AO_t)(val)) # define AO_HAVE_int_and_XBAR #endif #if defined(AO_HAVE_or_XBAR) && !defined(AO_HAVE_int_or_XBAR) # define AO_int_or_XBAR(addr, val) \ AO_or_XBAR((volatile AO_t *)(addr), (AO_t)(val)) # define AO_HAVE_int_or_XBAR #endif #if defined(AO_HAVE_xor_XBAR) && !defined(AO_HAVE_int_xor_XBAR) # define AO_int_xor_XBAR(addr, val) \ AO_xor_XBAR((volatile AO_t *)(addr), (AO_t)(val)) # define AO_HAVE_int_xor_XBAR #endif #if defined(AO_HAVE_fetch_compare_and_swap_XBAR) \ && !defined(AO_HAVE_int_fetch_compare_and_swap_XBAR) # define AO_int_fetch_compare_and_swap_XBAR(addr, old, new_val) \ (unsigned)AO_fetch_compare_and_swap_XBAR((volatile AO_t *)(addr), \ (AO_t)(old), (AO_t)(new_val)) # define AO_HAVE_int_fetch_compare_and_swap_XBAR #endif #if defined(AO_HAVE_compare_and_swap_XBAR) \ && !defined(AO_HAVE_int_compare_and_swap_XBAR) # define AO_int_compare_and_swap_XBAR(addr, old, new_val) \ AO_compare_and_swap_XBAR((volatile AO_t *)(addr), \ (AO_t)(old), (AO_t)(new_val)) # define AO_HAVE_int_compare_and_swap_XBAR #endif ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/armcc/000077500000000000000000000000001266352375300245645ustar00rootroot00000000000000ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/armcc/arm_v6.h000066400000000000000000000161751266352375300261410ustar00rootroot00000000000000/* * Copyright (c) 2007 by NEC LE-IT: All rights reserved. * A transcription of ARMv6 atomic operations for the ARM Realview Toolchain. * This code works with armcc from RVDS 3.1 * This is based on work in gcc/arm.h by * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. * Copyright (c) 1999-2003 by Hewlett-Packard Company. All rights reserved. * * * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. * */ #include "../test_and_set_t_is_ao_t.h" /* Probably suboptimal */ #if __TARGET_ARCH_ARM < 6 Dont use with ARM instruction sets lower than v6 #else #define AO_ACCESS_CHECK_ALIGNED #define AO_ACCESS_short_CHECK_ALIGNED #define AO_ACCESS_int_CHECK_ALIGNED #include "../all_atomic_only_load.h" #include "../standard_ao_double_t.h" /* NEC LE-IT: ARMv6 is the first architecture providing support for simple LL/SC * A data memory barrier must be raised via CP15 command (see documentation). * * ARMv7 is compatible to ARMv6 but has a simpler command for issuing a * memory barrier (DMB). Raising it via CP15 should still work as told me by the * support engineers. If it turns out to be much quicker than we should implement * custom code for ARMv7 using the asm { dmb } command. * * If only a single processor is used, we can define AO_UNIPROCESSOR * and do not need to access CP15 for ensuring a DMB at all. */ AO_INLINE void AO_nop_full(void) { # ifndef AO_UNIPROCESSOR unsigned int dest=0; /* issue an data memory barrier (keeps ordering of memory transactions */ /* before and after this operation) */ __asm { mcr p15,0,dest,c7,c10,5 }; # else AO_compiler_barrier(); # endif } #define AO_HAVE_nop_full /* NEC LE-IT: atomic "store" - according to ARM documentation this is * the only safe way to set variables also used in LL/SC environment. * A direct write won't be recognized by the LL/SC construct in other CPUs. * * HB: Based on subsequent discussion, I think it would be OK to use an * ordinary store here if we knew that interrupt handlers always cleared * the reservation. They should, but there is some doubt that this is * currently always the case for e.g. Linux. */ AO_INLINE void AO_store(volatile AO_t *addr, AO_t value) { unsigned long tmp; retry: __asm { ldrex tmp, [addr] strex tmp, value, [addr] teq tmp, #0 bne retry }; } #define AO_HAVE_store /* NEC LE-IT: replace the SWAP as recommended by ARM: "Applies to: ARM11 Cores Though the SWP instruction will still work with ARM V6 cores, it is recommended to use the new V6 synchronization instructions. The SWP instruction produces locked read and write accesses which are atomic, i.e. another operation cannot be done between these locked accesses which ties up external bus (AHB,AXI) bandwidth and can increase worst case interrupt latencies. LDREX,STREX are more flexible, other instructions can be done between the LDREX and STREX accesses. " */ #ifndef AO_PREFER_GENERALIZED AO_INLINE AO_TS_VAL_t AO_test_and_set(volatile AO_TS_t *addr) { AO_TS_VAL_t oldval; unsigned long tmp; unsigned long one = 1; retry: __asm { ldrex oldval, [addr] strex tmp, one, [addr] teq tmp, #0 bne retry } return oldval; } #define AO_HAVE_test_and_set AO_INLINE AO_t AO_fetch_and_add(volatile AO_t *p, AO_t incr) { unsigned long tmp,tmp2; AO_t result; retry: __asm { ldrex result, [p] add tmp, incr, result strex tmp2, tmp, [p] teq tmp2, #0 bne retry } return result; } #define AO_HAVE_fetch_and_add AO_INLINE AO_t AO_fetch_and_add1(volatile AO_t *p) { unsigned long tmp,tmp2; AO_t result; retry: __asm { ldrex result, [p] add tmp, result, #1 strex tmp2, tmp, [p] teq tmp2, #0 bne retry } return result; } #define AO_HAVE_fetch_and_add1 AO_INLINE AO_t AO_fetch_and_sub1(volatile AO_t *p) { unsigned long tmp,tmp2; AO_t result; retry: __asm { ldrex result, [p] sub tmp, result, #1 strex tmp2, tmp, [p] teq tmp2, #0 bne retry } return result; } #define AO_HAVE_fetch_and_sub1 #endif /* !AO_PREFER_GENERALIZED */ #ifndef AO_GENERALIZE_ASM_BOOL_CAS /* Returns nonzero if the comparison succeeded. */ AO_INLINE int AO_compare_and_swap(volatile AO_t *addr, AO_t old_val, AO_t new_val) { AO_t result, tmp; retry: __asm__ { mov result, #2 ldrex tmp, [addr] teq tmp, old_val # ifdef __thumb__ it eq # endif strexeq result, new_val, [addr] teq result, #1 beq retry } return !(result&2); } # define AO_HAVE_compare_and_swap #endif /* !AO_GENERALIZE_ASM_BOOL_CAS */ AO_INLINE AO_t AO_fetch_compare_and_swap(volatile AO_t *addr, AO_t old_val, AO_t new_val) { AO_t fetched_val, tmp; retry: __asm__ { mov tmp, #2 ldrex fetched_val, [addr] teq fetched_val, old_val # ifdef __thumb__ it eq # endif strexeq tmp, new_val, [addr] teq tmp, #1 beq retry } return fetched_val; } #define AO_HAVE_fetch_compare_and_swap /* helper functions for the Realview compiler: LDREXD is not usable * with inline assembler, so use the "embedded" assembler as * suggested by ARM Dev. support (June 2008). */ __asm inline double_ptr_storage AO_load_ex(const volatile AO_double_t *addr) { LDREXD r0,r1,[r0] } __asm inline int AO_store_ex(AO_t val1, AO_t val2, volatile AO_double_t *addr) { STREXD r3,r0,r1,[r2] MOV r0,r3 } AO_INLINE AO_double_t AO_double_load(const volatile AO_double_t *addr) { AO_double_t result; result.AO_whole = AO_load_ex(addr); return result; } #define AO_HAVE_double_load AO_INLINE int AO_compare_double_and_swap_double(volatile AO_double_t *addr, AO_t old_val1, AO_t old_val2, AO_t new_val1, AO_t new_val2) { double_ptr_storage old_val = ((double_ptr_storage)old_val2 << 32) | old_val1; double_ptr_storage tmp; int result; while(1) { tmp = AO_load_ex(addr); if(tmp != old_val) return 0; result = AO_store_ex(new_val1, new_val2, addr); if(!result) return 1; } } #define AO_HAVE_compare_double_and_swap_double #endif /* __TARGET_ARCH_ARM >= 6 */ #define AO_T_IS_INT ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/emul_cas.h000066400000000000000000000064211266352375300254430ustar00rootroot00000000000000/* * Copyright (c) 2003 by Hewlett-Packard Company. All rights reserved. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ /* * Ensure, if at all possible, that AO_compare_and_swap_full() is * available. The emulation should be brute-force signal-safe, even * though it actually blocks. * Including this file will generate an error if AO_compare_and_swap_full() * cannot be made available. * This will be included from platform-specific atomic_ops files * if appropriate, and if AO_REQUIRE_CAS is defined. It should not be * included directly, especially since it affects the implementation * of other atomic update primitives. * The implementation assumes that only AO_store_XXX and AO_test_and_set_XXX * variants are defined, and that AO_test_and_set_XXX is not used to * operate on compare_and_swap locations. */ #ifndef AO_ATOMIC_OPS_H # error This file should not be included directly. #endif #ifndef AO_HAVE_double_t # include "standard_ao_double_t.h" #endif AO_t AO_fetch_compare_and_swap_emulation(volatile AO_t *addr, AO_t old_val, AO_t new_val); int AO_compare_double_and_swap_double_emulation(volatile AO_double_t *addr, AO_t old_val1, AO_t old_val2, AO_t new_val1, AO_t new_val2); void AO_store_full_emulation(volatile AO_t *addr, AO_t val); #ifndef AO_HAVE_fetch_compare_and_swap_full # define AO_fetch_compare_and_swap_full(addr, old, newval) \ AO_fetch_compare_and_swap_emulation(addr, old, newval) # define AO_HAVE_fetch_compare_and_swap_full #endif #ifndef AO_HAVE_compare_double_and_swap_double_full # define AO_compare_double_and_swap_double_full(addr, old1, old2, \ newval1, newval2) \ AO_compare_double_and_swap_double_emulation(addr, old1, old2, \ newval1, newval2) # define AO_HAVE_compare_double_and_swap_double_full #endif #undef AO_store #undef AO_HAVE_store #undef AO_store_write #undef AO_HAVE_store_write #undef AO_store_release #undef AO_HAVE_store_release #undef AO_store_full #undef AO_HAVE_store_full #define AO_store_full(addr, val) AO_store_full_emulation(addr, val) #define AO_HAVE_store_full ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/gcc/000077500000000000000000000000001266352375300242335ustar00rootroot00000000000000ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/gcc/aarch64.h000066400000000000000000000142221266352375300256350ustar00rootroot00000000000000/* * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. * Copyright (c) 1999-2003 by Hewlett-Packard Company. All rights reserved. * * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. * */ #include "../test_and_set_t_is_ao_t.h" #include "../standard_ao_double_t.h" #ifndef AO_UNIPROCESSOR AO_INLINE void AO_nop_write(void) { /* TODO: Use C++11 primitive. */ __asm__ __volatile__("dmb ishst" : : : "memory"); } # define AO_HAVE_nop_write #endif /* TODO: Adjust version check on fixing double-wide AO support in GCC. */ #if __GNUC__ >= 4 AO_INLINE AO_double_t AO_double_load(const volatile AO_double_t *addr) { AO_double_t result; int status; /* Note that STXP cannot be discarded because LD[A]XP is not */ /* single-copy atomic (unlike LDREXD for 32-bit ARM). */ do { __asm__ __volatile__("//AO_double_load\n" " ldxp %0, %1, %3\n" " stxp %w2, %0, %1, %3" : "=&r" (result.AO_val1), "=&r" (result.AO_val2), "=&r" (status) : "Q" (*addr)); } while (AO_EXPECT_FALSE(status)); return result; } # define AO_HAVE_double_load AO_INLINE AO_double_t AO_double_load_acquire(const volatile AO_double_t *addr) { AO_double_t result; int status; do { __asm__ __volatile__("//AO_double_load_acquire\n" " ldaxp %0, %1, %3\n" " stxp %w2, %0, %1, %3" : "=&r" (result.AO_val1), "=&r" (result.AO_val2), "=&r" (status) : "Q" (*addr)); } while (AO_EXPECT_FALSE(status)); return result; } # define AO_HAVE_double_load_acquire AO_INLINE void AO_double_store(volatile AO_double_t *addr, AO_double_t value) { AO_double_t old_val; int status; do { __asm__ __volatile__("//AO_double_store\n" " ldxp %0, %1, %3\n" " stxp %w2, %4, %5, %3" : "=&r" (old_val.AO_val1), "=&r" (old_val.AO_val2), "=&r" (status), "=Q" (*addr) : "r" (value.AO_val1), "r" (value.AO_val2)); /* Compared to the arm.h implementation, the 'cc' (flags) are not */ /* clobbered because A64 has no concept of conditional execution. */ } while (AO_EXPECT_FALSE(status)); } # define AO_HAVE_double_store AO_INLINE void AO_double_store_release(volatile AO_double_t *addr, AO_double_t value) { AO_double_t old_val; int status; do { __asm__ __volatile__("//AO_double_store_release\n" " ldxp %0, %1, %3\n" " stlxp %w2, %4, %5, %3" : "=&r" (old_val.AO_val1), "=&r" (old_val.AO_val2), "=&r" (status), "=Q" (*addr) : "r" (value.AO_val1), "r" (value.AO_val2)); } while (AO_EXPECT_FALSE(status)); } # define AO_HAVE_double_store_release AO_INLINE int AO_double_compare_and_swap(volatile AO_double_t *addr, AO_double_t old_val, AO_double_t new_val) { AO_double_t tmp; int result = 1; do { __asm__ __volatile__("//AO_double_compare_and_swap\n" " ldxp %0, %1, %2\n" : "=&r" (tmp.AO_val1), "=&r" (tmp.AO_val2) : "Q" (*addr)); if (tmp.AO_val1 != old_val.AO_val1 || tmp.AO_val2 != old_val.AO_val2) break; __asm__ __volatile__( " stxp %w0, %2, %3, %1\n" : "=&r" (result), "=Q" (*addr) : "r" (new_val.AO_val1), "r" (new_val.AO_val2)); } while (AO_EXPECT_FALSE(result)); return !result; } # define AO_HAVE_double_compare_and_swap AO_INLINE int AO_double_compare_and_swap_acquire(volatile AO_double_t *addr, AO_double_t old_val, AO_double_t new_val) { AO_double_t tmp; int result = 1; do { __asm__ __volatile__("//AO_double_compare_and_swap_acquire\n" " ldaxp %0, %1, %2\n" : "=&r" (tmp.AO_val1), "=&r" (tmp.AO_val2) : "Q" (*addr)); if (tmp.AO_val1 != old_val.AO_val1 || tmp.AO_val2 != old_val.AO_val2) break; __asm__ __volatile__( " stxp %w0, %2, %3, %1\n" : "=&r" (result), "=Q" (*addr) : "r" (new_val.AO_val1), "r" (new_val.AO_val2)); } while (AO_EXPECT_FALSE(result)); return !result; } # define AO_HAVE_double_compare_and_swap_acquire AO_INLINE int AO_double_compare_and_swap_release(volatile AO_double_t *addr, AO_double_t old_val, AO_double_t new_val) { AO_double_t tmp; int result = 1; do { __asm__ __volatile__("//AO_double_compare_and_swap_release\n" " ldxp %0, %1, %2\n" : "=&r" (tmp.AO_val1), "=&r" (tmp.AO_val2) : "Q" (*addr)); if (tmp.AO_val1 != old_val.AO_val1 || tmp.AO_val2 != old_val.AO_val2) break; __asm__ __volatile__( " stlxp %w0, %2, %3, %1\n" : "=&r" (result), "=Q" (*addr) : "r" (new_val.AO_val1), "r" (new_val.AO_val2)); } while (AO_EXPECT_FALSE(result)); return !result; } # define AO_HAVE_double_compare_and_swap_release AO_INLINE int AO_double_compare_and_swap_full(volatile AO_double_t *addr, AO_double_t old_val, AO_double_t new_val) { AO_double_t tmp; int result = 1; do { __asm__ __volatile__("//AO_double_compare_and_swap_full\n" " ldaxp %0, %1, %2\n" : "=&r" (tmp.AO_val1), "=&r" (tmp.AO_val2) : "Q" (*addr)); if (tmp.AO_val1 != old_val.AO_val1 || tmp.AO_val2 != old_val.AO_val2) break; __asm__ __volatile__( " stlxp %w0, %2, %3, %1\n" : "=&r" (result), "=Q" (*addr) : "r" (new_val.AO_val1), "r" (new_val.AO_val2)); } while (AO_EXPECT_FALSE(result)); return !result; } # define AO_HAVE_double_compare_and_swap_full #endif /* __GNUC__ >= 4 */ #include "generic.h" ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/gcc/alpha.h000066400000000000000000000040031266352375300254660ustar00rootroot00000000000000/* * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. * Copyright (c) 1999-2003 by Hewlett-Packard Company. All rights reserved. * * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. * */ #include "../loadstore/atomic_load.h" #include "../loadstore/atomic_store.h" #include "../test_and_set_t_is_ao_t.h" #define AO_NO_DD_ORDERING /* Data dependence does not imply read ordering. */ AO_INLINE void AO_nop_full(void) { __asm__ __volatile__("mb" : : : "memory"); } #define AO_HAVE_nop_full AO_INLINE void AO_nop_write(void) { __asm__ __volatile__("wmb" : : : "memory"); } #define AO_HAVE_nop_write /* mb should be used for AO_nop_read(). That's the default. */ /* TODO: implement AO_fetch_and_add explicitly. */ /* We believe that ldq_l ... stq_c does not imply any memory barrier. */ AO_INLINE int AO_compare_and_swap(volatile AO_t *addr, AO_t old, AO_t new_val) { unsigned long was_equal; unsigned long temp; __asm__ __volatile__( "1: ldq_l %0,%1\n" " cmpeq %0,%4,%2\n" " mov %3,%0\n" " beq %2,2f\n" " stq_c %0,%1\n" " beq %0,1b\n" "2:\n" : "=&r" (temp), "+m" (*addr), "=&r" (was_equal) : "r" (new_val), "Ir" (old) :"memory"); return (int)was_equal; } #define AO_HAVE_compare_and_swap /* TODO: implement AO_fetch_compare_and_swap */ ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/gcc/arm.h000066400000000000000000000525061266352375300251730ustar00rootroot00000000000000/* * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. * Copyright (c) 1999-2003 by Hewlett-Packard Company. All rights reserved. * * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. * */ #include "../test_and_set_t_is_ao_t.h" /* Probably suboptimal */ #if defined(__thumb__) && !defined(__thumb2__) /* Thumb One mode does not have ARM "mcr", "swp" and some load/store */ /* instructions, so we temporarily switch to ARM mode and go back */ /* afterwards (clobbering "r3" register). */ # define AO_THUMB_GO_ARM \ " adr r3, 4f\n" \ " bx r3\n" \ " .align\n" \ " .arm\n" \ "4:\n" # define AO_THUMB_RESTORE_MODE \ " adr r3, 5f + 1\n" \ " bx r3\n" \ " .thumb\n" \ "5:\n" # define AO_THUMB_SWITCH_CLOBBERS "r3", #else # define AO_THUMB_GO_ARM /* empty */ # define AO_THUMB_RESTORE_MODE /* empty */ # define AO_THUMB_SWITCH_CLOBBERS /* empty */ #endif /* !__thumb__ */ /* NEC LE-IT: gcc has no way to easily check the arm architecture */ /* but it defines only one (or several) of __ARM_ARCH_x__ to be true. */ #if !defined(__ARM_ARCH_2__) && !defined(__ARM_ARCH_3__) \ && !defined(__ARM_ARCH_3M__) && !defined(__ARM_ARCH_4__) \ && !defined(__ARM_ARCH_4T__) \ && ((!defined(__ARM_ARCH_5__) && !defined(__ARM_ARCH_5E__) \ && !defined(__ARM_ARCH_5T__) && !defined(__ARM_ARCH_5TE__) \ && !defined(__ARM_ARCH_5TEJ__) && !defined(__ARM_ARCH_6M__)) \ || defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_7A__) \ || defined(__ARM_ARCH_8A__)) # define AO_ARM_HAVE_LDREX # if !defined(__ARM_ARCH_6__) && !defined(__ARM_ARCH_6J__) \ && !defined(__ARM_ARCH_6T2__) /* LDREXB/STREXB and LDREXH/STREXH are present in ARMv6K/Z+. */ # define AO_ARM_HAVE_LDREXBH # endif # if !defined(__ARM_ARCH_6__) && !defined(__ARM_ARCH_6J__) \ && !defined(__ARM_ARCH_6T2__) && !defined(__ARM_ARCH_6Z__) \ && !defined(__ARM_ARCH_6ZT2__) # if !defined(__ARM_ARCH_6K__) && !defined(__ARM_ARCH_6ZK__) /* DMB is present in ARMv6M and ARMv7+. */ # define AO_ARM_HAVE_DMB # endif # if (!defined(__thumb__) \ || (defined(__thumb2__) && !defined(__ARM_ARCH_7__) \ && !defined(__ARM_ARCH_7M__) && !defined(__ARM_ARCH_7EM__))) \ && (!defined(__clang__) || (__clang_major__ > 3) \ || (__clang_major__ == 3 && __clang_minor__ >= 3)) /* LDREXD/STREXD present in ARMv6K/M+ (see gas/config/tc-arm.c). */ /* In the Thumb mode, this works only starting from ARMv7 (except */ /* for the base and 'M' models). Clang3.2 (and earlier) does not */ /* allocate register pairs for LDREXD/STREXD properly (besides, */ /* Clang3.1 does not support "%H" operand specification). */ # define AO_ARM_HAVE_LDREXD # endif /* !thumb || ARMv7A || ARMv7R+ */ # endif /* ARMv7+ */ #endif /* ARMv6+ */ #if !defined(__ARM_ARCH_2__) && !defined(__ARM_ARCH_6M__) \ && !defined(__ARM_ARCH_8A__) && !defined(__thumb2__) # define AO_ARM_HAVE_SWP /* Note: ARMv6M is excluded due to no ARM mode support. */ /* Also, SWP is obsoleted for ARMv8+. */ #endif /* !__thumb2__ */ #ifdef AO_UNIPROCESSOR /* If only a single processor (core) is used, AO_UNIPROCESSOR could */ /* be defined by the client to avoid unnecessary memory barrier. */ AO_INLINE void AO_nop_full(void) { AO_compiler_barrier(); } # define AO_HAVE_nop_full #elif defined(AO_ARM_HAVE_DMB) /* ARMv7 is compatible to ARMv6 but has a simpler command for issuing */ /* a memory barrier (DMB). Raising it via CP15 should still work */ /* (but slightly less efficient because it requires the use of */ /* a general-purpose register). */ AO_INLINE void AO_nop_full(void) { /* AO_THUMB_GO_ARM is empty. */ __asm__ __volatile__("dmb" : : : "memory"); } # define AO_HAVE_nop_full AO_INLINE void AO_nop_write(void) { /* AO_THUMB_GO_ARM is empty. */ /* This will target the system domain and thus be overly */ /* conservative as the CPUs will occupy the inner shareable domain. */ /* The plain variant (dmb st) is theoretically slower, and should */ /* not be needed. That said, with limited experimentation, a CPU */ /* implementation for which it actually matters has not been found */ /* yet, though they should already exist. */ /* Anyway, note that the "st" and "ishst" barriers are actually */ /* quite weak and, as the libatomic_ops documentation states, */ /* usually not what you really want. */ __asm__ __volatile__("dmb ishst" : : : "memory"); } # define AO_HAVE_nop_write #elif defined(AO_ARM_HAVE_LDREX) /* ARMv6 is the first architecture providing support for a simple */ /* LL/SC. A data memory barrier must be raised via CP15 command. */ AO_INLINE void AO_nop_full(void) { unsigned dest = 0; /* Issue a data memory barrier (keeps ordering of memory */ /* transactions before and after this operation). */ __asm__ __volatile__("@AO_nop_full\n" AO_THUMB_GO_ARM " mcr p15,0,%0,c7,c10,5\n" AO_THUMB_RESTORE_MODE : "=&r"(dest) : /* empty */ : AO_THUMB_SWITCH_CLOBBERS "memory"); } # define AO_HAVE_nop_full #else /* AO_nop_full() is emulated using AO_test_and_set_full(). */ #endif /* !AO_UNIPROCESSOR && !AO_ARM_HAVE_LDREX */ #ifdef AO_ARM_HAVE_LDREX /* AO_t/char/short/int load is simple reading. */ /* Unaligned accesses are not guaranteed to be atomic. */ # define AO_ACCESS_CHECK_ALIGNED # define AO_ACCESS_short_CHECK_ALIGNED # define AO_ACCESS_int_CHECK_ALIGNED # include "../all_atomic_only_load.h" /* "ARM Architecture Reference Manual" (chapter A3.5.3) says that the */ /* single-copy atomic processor accesses are all byte accesses, all */ /* halfword accesses to halfword-aligned locations, all word accesses */ /* to word-aligned locations. */ /* There is only a single concern related to AO store operations: */ /* a direct write (by STR[B/H] instruction) will not be recognized */ /* by the LL/SC construct on the same CPU (i.e., according to ARM */ /* documentation, e.g., see CortexA8 TRM reference, point 8.5, */ /* atomic "store" (using LDREX/STREX[B/H]) is the only safe way to */ /* set variables also used in LL/SC environment). */ /* This is only a problem if interrupt handlers do not clear the */ /* reservation (by CLREX instruction or a dummy STREX one), as they */ /* almost certainly should (e.g., see restore_user_regs defined in */ /* arch/arm/kernel/entry-header.S of Linux. Nonetheless, there is */ /* a doubt this was properly implemented in some ancient OS releases. */ # ifdef AO_BROKEN_TASKSWITCH_CLREX AO_INLINE void AO_store(volatile AO_t *addr, AO_t value) { int flag; __asm__ __volatile__("@AO_store\n" AO_THUMB_GO_ARM "1: ldrex %0, [%2]\n" " strex %0, %3, [%2]\n" " teq %0, #0\n" " bne 1b\n" AO_THUMB_RESTORE_MODE : "=&r" (flag), "+m" (*addr) : "r" (addr), "r" (value) : AO_THUMB_SWITCH_CLOBBERS "cc"); } # define AO_HAVE_store # ifdef AO_ARM_HAVE_LDREXBH AO_INLINE void AO_char_store(volatile unsigned char *addr, unsigned char value) { int flag; __asm__ __volatile__("@AO_char_store\n" AO_THUMB_GO_ARM "1: ldrexb %0, [%2]\n" " strexb %0, %3, [%2]\n" " teq %0, #0\n" " bne 1b\n" AO_THUMB_RESTORE_MODE : "=&r" (flag), "+m" (*addr) : "r" (addr), "r" (value) : AO_THUMB_SWITCH_CLOBBERS "cc"); } # define AO_HAVE_char_store AO_INLINE void AO_short_store(volatile unsigned short *addr, unsigned short value) { int flag; __asm__ __volatile__("@AO_short_store\n" AO_THUMB_GO_ARM "1: ldrexh %0, [%2]\n" " strexh %0, %3, [%2]\n" " teq %0, #0\n" " bne 1b\n" AO_THUMB_RESTORE_MODE : "=&r" (flag), "+m" (*addr) : "r" (addr), "r" (value) : AO_THUMB_SWITCH_CLOBBERS "cc"); } # define AO_HAVE_short_store # endif /* AO_ARM_HAVE_LDREXBH */ # else # include "../loadstore/atomic_store.h" /* AO_int_store is defined in ao_t_is_int.h. */ # endif /* !AO_BROKEN_TASKSWITCH_CLREX */ # ifndef AO_HAVE_char_store # include "../loadstore/char_atomic_store.h" # include "../loadstore/short_atomic_store.h" # endif /* NEC LE-IT: replace the SWAP as recommended by ARM: "Applies to: ARM11 Cores Though the SWP instruction will still work with ARM V6 cores, it is recommended to use the new V6 synchronization instructions. The SWP instruction produces 'locked' read and write accesses which are atomic, i.e. another operation cannot be done between these locked accesses which ties up external bus (AHB, AXI) bandwidth and can increase worst case interrupt latencies. LDREX, STREX are more flexible, other instructions can be done between the LDREX and STREX accesses." */ #ifndef AO_PREFER_GENERALIZED #if !defined(AO_FORCE_USE_SWP) || !defined(AO_ARM_HAVE_SWP) /* But, on the other hand, there could be a considerable performance */ /* degradation in case of a race. Eg., test_atomic.c executing */ /* test_and_set test on a dual-core ARMv7 processor using LDREX/STREX */ /* showed around 35 times lower performance than that using SWP. */ /* To force use of SWP instruction, use -D AO_FORCE_USE_SWP option */ /* (the latter is ignored if SWP instruction is unsupported). */ AO_INLINE AO_TS_VAL_t AO_test_and_set(volatile AO_TS_t *addr) { AO_TS_VAL_t oldval; int flag; __asm__ __volatile__("@AO_test_and_set\n" AO_THUMB_GO_ARM "1: ldrex %0, [%3]\n" " strex %1, %4, [%3]\n" " teq %1, #0\n" " bne 1b\n" AO_THUMB_RESTORE_MODE : "=&r"(oldval), "=&r"(flag), "+m"(*addr) : "r"(addr), "r"(1) : AO_THUMB_SWITCH_CLOBBERS "cc"); return oldval; } # define AO_HAVE_test_and_set #endif /* !AO_FORCE_USE_SWP */ AO_INLINE AO_t AO_fetch_and_add(volatile AO_t *p, AO_t incr) { AO_t result, tmp; int flag; __asm__ __volatile__("@AO_fetch_and_add\n" AO_THUMB_GO_ARM "1: ldrex %0, [%5]\n" /* get original */ " add %2, %0, %4\n" /* sum up in incr */ " strex %1, %2, [%5]\n" /* store them */ " teq %1, #0\n" " bne 1b\n" AO_THUMB_RESTORE_MODE : "=&r"(result), "=&r"(flag), "=&r"(tmp), "+m"(*p) /* 0..3 */ : "r"(incr), "r"(p) /* 4..5 */ : AO_THUMB_SWITCH_CLOBBERS "cc"); return result; } #define AO_HAVE_fetch_and_add AO_INLINE AO_t AO_fetch_and_add1(volatile AO_t *p) { AO_t result, tmp; int flag; __asm__ __volatile__("@AO_fetch_and_add1\n" AO_THUMB_GO_ARM "1: ldrex %0, [%4]\n" /* get original */ " add %1, %0, #1\n" /* increment */ " strex %2, %1, [%4]\n" /* store them */ " teq %2, #0\n" " bne 1b\n" AO_THUMB_RESTORE_MODE : "=&r"(result), "=&r"(tmp), "=&r"(flag), "+m"(*p) : "r"(p) : AO_THUMB_SWITCH_CLOBBERS "cc"); return result; } #define AO_HAVE_fetch_and_add1 AO_INLINE AO_t AO_fetch_and_sub1(volatile AO_t *p) { AO_t result, tmp; int flag; __asm__ __volatile__("@AO_fetch_and_sub1\n" AO_THUMB_GO_ARM "1: ldrex %0, [%4]\n" /* get original */ " sub %1, %0, #1\n" /* decrement */ " strex %2, %1, [%4]\n" /* store them */ " teq %2, #0\n" " bne 1b\n" AO_THUMB_RESTORE_MODE : "=&r"(result), "=&r"(tmp), "=&r"(flag), "+m"(*p) : "r"(p) : AO_THUMB_SWITCH_CLOBBERS "cc"); return result; } #define AO_HAVE_fetch_and_sub1 AO_INLINE void AO_and(volatile AO_t *p, AO_t value) { AO_t tmp, result; __asm__ __volatile__("@AO_and\n" AO_THUMB_GO_ARM "1: ldrex %0, [%4]\n" " and %1, %0, %3\n" " strex %0, %1, [%4]\n" " teq %0, #0\n" " bne 1b\n" AO_THUMB_RESTORE_MODE : "=&r" (tmp), "=&r" (result), "+m" (*p) : "r" (value), "r" (p) : AO_THUMB_SWITCH_CLOBBERS "cc"); } #define AO_HAVE_and AO_INLINE void AO_or(volatile AO_t *p, AO_t value) { AO_t tmp, result; __asm__ __volatile__("@AO_or\n" AO_THUMB_GO_ARM "1: ldrex %0, [%4]\n" " orr %1, %0, %3\n" " strex %0, %1, [%4]\n" " teq %0, #0\n" " bne 1b\n" AO_THUMB_RESTORE_MODE : "=&r" (tmp), "=&r" (result), "+m" (*p) : "r" (value), "r" (p) : AO_THUMB_SWITCH_CLOBBERS "cc"); } #define AO_HAVE_or AO_INLINE void AO_xor(volatile AO_t *p, AO_t value) { AO_t tmp, result; __asm__ __volatile__("@AO_xor\n" AO_THUMB_GO_ARM "1: ldrex %0, [%4]\n" " eor %1, %0, %3\n" " strex %0, %1, [%4]\n" " teq %0, #0\n" " bne 1b\n" AO_THUMB_RESTORE_MODE : "=&r" (tmp), "=&r" (result), "+m" (*p) : "r" (value), "r" (p) : AO_THUMB_SWITCH_CLOBBERS "cc"); } #define AO_HAVE_xor #endif /* !AO_PREFER_GENERALIZED */ #ifdef AO_ARM_HAVE_LDREXBH AO_INLINE unsigned char AO_char_fetch_and_add(volatile unsigned char *p, unsigned char incr) { unsigned result, tmp; int flag; __asm__ __volatile__("@AO_char_fetch_and_add\n" AO_THUMB_GO_ARM "1: ldrexb %0, [%5]\n" " add %2, %0, %4\n" " strexb %1, %2, [%5]\n" " teq %1, #0\n" " bne 1b\n" AO_THUMB_RESTORE_MODE : "=&r" (result), "=&r" (flag), "=&r" (tmp), "+m" (*p) : "r" ((unsigned)incr), "r" (p) : AO_THUMB_SWITCH_CLOBBERS "cc"); return (unsigned char)result; } # define AO_HAVE_char_fetch_and_add AO_INLINE unsigned short AO_short_fetch_and_add(volatile unsigned short *p, unsigned short incr) { unsigned result, tmp; int flag; __asm__ __volatile__("@AO_short_fetch_and_add\n" AO_THUMB_GO_ARM "1: ldrexh %0, [%5]\n" " add %2, %0, %4\n" " strexh %1, %2, [%5]\n" " teq %1, #0\n" " bne 1b\n" AO_THUMB_RESTORE_MODE : "=&r" (result), "=&r" (flag), "=&r" (tmp), "+m" (*p) : "r" ((unsigned)incr), "r" (p) : AO_THUMB_SWITCH_CLOBBERS "cc"); return (unsigned short)result; } # define AO_HAVE_short_fetch_and_add #endif /* AO_ARM_HAVE_LDREXBH */ #ifndef AO_GENERALIZE_ASM_BOOL_CAS /* Returns nonzero if the comparison succeeded. */ AO_INLINE int AO_compare_and_swap(volatile AO_t *addr, AO_t old_val, AO_t new_val) { AO_t result, tmp; __asm__ __volatile__("@AO_compare_and_swap\n" AO_THUMB_GO_ARM "1: mov %0, #2\n" /* store a flag */ " ldrex %1, [%3]\n" /* get original */ " teq %1, %4\n" /* see if match */ # ifdef __thumb2__ /* TODO: Eliminate warning: it blocks containing wide Thumb */ /* instructions are deprecated in ARMv8. */ " it eq\n" # endif " strexeq %0, %5, [%3]\n" /* store new one if matched */ " teq %0, #1\n" " beq 1b\n" /* if update failed, repeat */ AO_THUMB_RESTORE_MODE : "=&r"(result), "=&r"(tmp), "+m"(*addr) : "r"(addr), "r"(old_val), "r"(new_val) : AO_THUMB_SWITCH_CLOBBERS "cc"); return !(result&2); /* if succeded, return 1, else 0 */ } # define AO_HAVE_compare_and_swap #endif /* !AO_GENERALIZE_ASM_BOOL_CAS */ AO_INLINE AO_t AO_fetch_compare_and_swap(volatile AO_t *addr, AO_t old_val, AO_t new_val) { AO_t fetched_val; int flag; __asm__ __volatile__("@AO_fetch_compare_and_swap\n" AO_THUMB_GO_ARM "1: mov %0, #2\n" /* store a flag */ " ldrex %1, [%3]\n" /* get original */ " teq %1, %4\n" /* see if match */ # ifdef __thumb2__ " it eq\n" # endif " strexeq %0, %5, [%3]\n" /* store new one if matched */ " teq %0, #1\n" " beq 1b\n" /* if update failed, repeat */ AO_THUMB_RESTORE_MODE : "=&r"(flag), "=&r"(fetched_val), "+m"(*addr) : "r"(addr), "r"(old_val), "r"(new_val) : AO_THUMB_SWITCH_CLOBBERS "cc"); return fetched_val; } #define AO_HAVE_fetch_compare_and_swap #ifdef AO_ARM_HAVE_LDREXD # include "../standard_ao_double_t.h" /* "ARM Architecture Reference Manual ARMv7-A/R edition" (chapter */ /* A3.5.3) says that memory accesses caused by LDREXD and STREXD */ /* instructions to doubleword-aligned locations are single-copy */ /* atomic; accesses to 64-bit elements by other instructions might */ /* not be single-copy atomic as they are executed as a sequence of */ /* 32-bit accesses. */ AO_INLINE AO_double_t AO_double_load(const volatile AO_double_t *addr) { AO_double_t result; /* AO_THUMB_GO_ARM is empty. */ __asm__ __volatile__("@AO_double_load\n" " ldrexd %0, %H0, [%1]" : "=&r" (result.AO_whole) : "r" (addr) /* : no clobber */); return result; } # define AO_HAVE_double_load AO_INLINE void AO_double_store(volatile AO_double_t *addr, AO_double_t new_val) { AO_double_t old_val; int status; do { /* AO_THUMB_GO_ARM is empty. */ __asm__ __volatile__("@AO_double_store\n" " ldrexd %0, %H0, [%3]\n" " strexd %1, %4, %H4, [%3]" : "=&r" (old_val.AO_whole), "=&r" (status), "+m" (*addr) : "r" (addr), "r" (new_val.AO_whole) : "cc"); } while (AO_EXPECT_FALSE(status)); } # define AO_HAVE_double_store AO_INLINE int AO_double_compare_and_swap(volatile AO_double_t *addr, AO_double_t old_val, AO_double_t new_val) { double_ptr_storage tmp; int result = 1; do { /* AO_THUMB_GO_ARM is empty. */ __asm__ __volatile__("@AO_double_compare_and_swap\n" " ldrexd %0, %H0, [%1]\n" /* get original to r1 & r2 */ : "=&r"(tmp) : "r"(addr) /* : no clobber */); if (tmp != old_val.AO_whole) break; __asm__ __volatile__( " strexd %0, %3, %H3, [%2]\n" /* store new one if matched */ : "=&r"(result), "+m"(*addr) : "r" (addr), "r" (new_val.AO_whole) : "cc"); } while (AO_EXPECT_FALSE(result)); return !result; /* if succeded, return 1 else 0 */ } # define AO_HAVE_double_compare_and_swap #endif /* AO_ARM_HAVE_LDREXD */ #else /* pre ARMv6 architectures ... */ /* I found a slide set that, if I read it correctly, claims that */ /* Loads followed by either a Load or Store are ordered, but nothing */ /* else is. */ /* It appears that SWP is the only simple memory barrier. */ #include "../all_aligned_atomic_load_store.h" /* The code should run correctly on a multi-core ARMv6+ as well. */ #endif /* !AO_ARM_HAVE_LDREX */ #if !defined(AO_HAVE_test_and_set_full) && !defined(AO_HAVE_test_and_set) \ && defined (AO_ARM_HAVE_SWP) && (!defined(AO_PREFER_GENERALIZED) \ || !defined(AO_HAVE_fetch_compare_and_swap)) AO_INLINE AO_TS_VAL_t AO_test_and_set_full(volatile AO_TS_t *addr) { AO_TS_VAL_t oldval; /* SWP on ARM is very similar to XCHG on x86. */ /* The first operand is the result, the second the value */ /* to be stored. Both registers must be different from addr. */ /* Make the address operand an early clobber output so it */ /* doesn't overlap with the other operands. The early clobber */ /* on oldval is necessary to prevent the compiler allocating */ /* them to the same register if they are both unused. */ __asm__ __volatile__("@AO_test_and_set_full\n" AO_THUMB_GO_ARM " swp %0, %2, [%3]\n" /* Ignore GCC "SWP is deprecated for this architecture" */ /* warning here (for ARMv6+). */ AO_THUMB_RESTORE_MODE : "=&r"(oldval), "=&r"(addr) : "r"(1), "1"(addr) : AO_THUMB_SWITCH_CLOBBERS "memory"); return oldval; } # define AO_HAVE_test_and_set_full #endif /* !AO_HAVE_test_and_set[_full] && AO_ARM_HAVE_SWP */ #define AO_T_IS_INT ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/gcc/avr32.h000066400000000000000000000046151266352375300253470ustar00rootroot00000000000000/* * Copyright (C) 2009 Bradley Smith * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the * "Software"), to deal in the Software without restriction, including * without limitation the rights to use, copy, modify, merge, publish, * distribute, sublicense, and/or sell copies of the Software, and to * permit persons to whom the Software is furnished to do so, subject to * the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. * */ #include "../all_atomic_load_store.h" #include "../ordered.h" /* There are no multiprocessor implementations. */ #include "../test_and_set_t_is_ao_t.h" #ifndef AO_PREFER_GENERALIZED AO_INLINE AO_TS_VAL_t AO_test_and_set_full(volatile AO_TS_t *addr) { register long ret; __asm__ __volatile__( "xchg %[oldval], %[mem], %[newval]" : [oldval] "=&r"(ret) : [mem] "r"(addr), [newval] "r"(1) : "memory"); return (AO_TS_VAL_t)ret; } # define AO_HAVE_test_and_set_full #endif /* !AO_PREFER_GENERALIZED */ AO_INLINE int AO_compare_and_swap_full(volatile AO_t *addr, AO_t old, AO_t new_val) { register long ret; __asm__ __volatile__( "1: ssrf 5\n" " ld.w %[res], %[mem]\n" " eor %[res], %[oldval]\n" " brne 2f\n" " stcond %[mem], %[newval]\n" " brne 1b\n" "2:\n" : [res] "=&r"(ret), [mem] "=m"(*addr) : "m"(*addr), [newval] "r"(new_val), [oldval] "r"(old) : "cc", "memory"); return (int)ret; } #define AO_HAVE_compare_and_swap_full /* TODO: implement AO_fetch_compare_and_swap. */ #define AO_T_IS_INT ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/gcc/cris.h000066400000000000000000000052211266352375300253440ustar00rootroot00000000000000/* * Copyright (c) 2004 Hewlett-Packard Development Company, L.P. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ /* FIXME: seems to be untested. */ #include "../all_atomic_load_store.h" #include "../ordered.h" /* There are no multiprocessor implementations. */ #include "../test_and_set_t_is_ao_t.h" /* * The architecture apparently supports an "f" flag which is * set on preemption. This essentially gives us load-locked, * store-conditional primitives, though I'm not quite sure how * this would work on a hypothetical multiprocessor. -HB * * For details, see * http://developer.axis.com/doc/hardware/etrax100lx/prog_man/ * 1_architectural_description.pdf * * Presumably many other primitives (notably CAS, including the double- * width versions) could be implemented in this manner, if someone got * around to it. */ AO_INLINE AO_TS_VAL_t AO_test_and_set_full(volatile AO_TS_t *addr) { /* Ripped from linuxthreads/sysdeps/cris/pt-machine.h */ register unsigned long int ret; /* Note the use of a dummy output of *addr to expose the write. The memory barrier is to stop *other* writes being moved past this code. */ __asm__ __volatile__("clearf\n" "0:\n\t" "movu.b [%2],%0\n\t" "ax\n\t" "move.b %3,[%2]\n\t" "bwf 0b\n\t" "clearf" : "=&r" (ret), "=m" (*addr) : "r" (addr), "r" ((int) 1), "m" (*addr) : "memory"); return ret; } #define AO_HAVE_test_and_set_full ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/gcc/generic-arithm.h000066400000000000000000000536241266352375300273140ustar00rootroot00000000000000/* * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. * * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. * */ AO_INLINE unsigned/**/char AO_char_fetch_and_add(volatile unsigned/**/char *addr, unsigned/**/char incr) { return __atomic_fetch_add(addr, incr, __ATOMIC_RELAXED); } #define AO_HAVE_char_fetch_and_add AO_INLINE void AO_char_and(volatile unsigned/**/char *addr, unsigned/**/char value) { (void)__atomic_and_fetch(addr, value, __ATOMIC_RELAXED); } #define AO_HAVE_char_and AO_INLINE void AO_char_or(volatile unsigned/**/char *addr, unsigned/**/char value) { (void)__atomic_or_fetch(addr, value, __ATOMIC_RELAXED); } #define AO_HAVE_char_or AO_INLINE void AO_char_xor(volatile unsigned/**/char *addr, unsigned/**/char value) { (void)__atomic_xor_fetch(addr, value, __ATOMIC_RELAXED); } #define AO_HAVE_char_xor /* * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. * * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. * */ AO_INLINE unsigned/**/short AO_short_fetch_and_add(volatile unsigned/**/short *addr, unsigned/**/short incr) { return __atomic_fetch_add(addr, incr, __ATOMIC_RELAXED); } #define AO_HAVE_short_fetch_and_add AO_INLINE void AO_short_and(volatile unsigned/**/short *addr, unsigned/**/short value) { (void)__atomic_and_fetch(addr, value, __ATOMIC_RELAXED); } #define AO_HAVE_short_and AO_INLINE void AO_short_or(volatile unsigned/**/short *addr, unsigned/**/short value) { (void)__atomic_or_fetch(addr, value, __ATOMIC_RELAXED); } #define AO_HAVE_short_or AO_INLINE void AO_short_xor(volatile unsigned/**/short *addr, unsigned/**/short value) { (void)__atomic_xor_fetch(addr, value, __ATOMIC_RELAXED); } #define AO_HAVE_short_xor /* * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. * * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. * */ AO_INLINE unsigned AO_int_fetch_and_add(volatile unsigned *addr, unsigned incr) { return __atomic_fetch_add(addr, incr, __ATOMIC_RELAXED); } #define AO_HAVE_int_fetch_and_add AO_INLINE void AO_int_and(volatile unsigned *addr, unsigned value) { (void)__atomic_and_fetch(addr, value, __ATOMIC_RELAXED); } #define AO_HAVE_int_and AO_INLINE void AO_int_or(volatile unsigned *addr, unsigned value) { (void)__atomic_or_fetch(addr, value, __ATOMIC_RELAXED); } #define AO_HAVE_int_or AO_INLINE void AO_int_xor(volatile unsigned *addr, unsigned value) { (void)__atomic_xor_fetch(addr, value, __ATOMIC_RELAXED); } #define AO_HAVE_int_xor /* * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. * * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. * */ AO_INLINE AO_t AO_fetch_and_add(volatile AO_t *addr, AO_t incr) { return __atomic_fetch_add(addr, incr, __ATOMIC_RELAXED); } #define AO_HAVE_fetch_and_add AO_INLINE void AO_and(volatile AO_t *addr, AO_t value) { (void)__atomic_and_fetch(addr, value, __ATOMIC_RELAXED); } #define AO_HAVE_and AO_INLINE void AO_or(volatile AO_t *addr, AO_t value) { (void)__atomic_or_fetch(addr, value, __ATOMIC_RELAXED); } #define AO_HAVE_or AO_INLINE void AO_xor(volatile AO_t *addr, AO_t value) { (void)__atomic_xor_fetch(addr, value, __ATOMIC_RELAXED); } #define AO_HAVE_xor /* * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. * * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. * */ AO_INLINE unsigned/**/char AO_char_fetch_and_add_acquire(volatile unsigned/**/char *addr, unsigned/**/char incr) { return __atomic_fetch_add(addr, incr, __ATOMIC_ACQUIRE); } #define AO_HAVE_char_fetch_and_add_acquire AO_INLINE void AO_char_and_acquire(volatile unsigned/**/char *addr, unsigned/**/char value) { (void)__atomic_and_fetch(addr, value, __ATOMIC_ACQUIRE); } #define AO_HAVE_char_and_acquire AO_INLINE void AO_char_or_acquire(volatile unsigned/**/char *addr, unsigned/**/char value) { (void)__atomic_or_fetch(addr, value, __ATOMIC_ACQUIRE); } #define AO_HAVE_char_or_acquire AO_INLINE void AO_char_xor_acquire(volatile unsigned/**/char *addr, unsigned/**/char value) { (void)__atomic_xor_fetch(addr, value, __ATOMIC_ACQUIRE); } #define AO_HAVE_char_xor_acquire /* * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. * * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. * */ AO_INLINE unsigned/**/short AO_short_fetch_and_add_acquire(volatile unsigned/**/short *addr, unsigned/**/short incr) { return __atomic_fetch_add(addr, incr, __ATOMIC_ACQUIRE); } #define AO_HAVE_short_fetch_and_add_acquire AO_INLINE void AO_short_and_acquire(volatile unsigned/**/short *addr, unsigned/**/short value) { (void)__atomic_and_fetch(addr, value, __ATOMIC_ACQUIRE); } #define AO_HAVE_short_and_acquire AO_INLINE void AO_short_or_acquire(volatile unsigned/**/short *addr, unsigned/**/short value) { (void)__atomic_or_fetch(addr, value, __ATOMIC_ACQUIRE); } #define AO_HAVE_short_or_acquire AO_INLINE void AO_short_xor_acquire(volatile unsigned/**/short *addr, unsigned/**/short value) { (void)__atomic_xor_fetch(addr, value, __ATOMIC_ACQUIRE); } #define AO_HAVE_short_xor_acquire /* * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. * * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. * */ AO_INLINE unsigned AO_int_fetch_and_add_acquire(volatile unsigned *addr, unsigned incr) { return __atomic_fetch_add(addr, incr, __ATOMIC_ACQUIRE); } #define AO_HAVE_int_fetch_and_add_acquire AO_INLINE void AO_int_and_acquire(volatile unsigned *addr, unsigned value) { (void)__atomic_and_fetch(addr, value, __ATOMIC_ACQUIRE); } #define AO_HAVE_int_and_acquire AO_INLINE void AO_int_or_acquire(volatile unsigned *addr, unsigned value) { (void)__atomic_or_fetch(addr, value, __ATOMIC_ACQUIRE); } #define AO_HAVE_int_or_acquire AO_INLINE void AO_int_xor_acquire(volatile unsigned *addr, unsigned value) { (void)__atomic_xor_fetch(addr, value, __ATOMIC_ACQUIRE); } #define AO_HAVE_int_xor_acquire /* * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. * * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. * */ AO_INLINE AO_t AO_fetch_and_add_acquire(volatile AO_t *addr, AO_t incr) { return __atomic_fetch_add(addr, incr, __ATOMIC_ACQUIRE); } #define AO_HAVE_fetch_and_add_acquire AO_INLINE void AO_and_acquire(volatile AO_t *addr, AO_t value) { (void)__atomic_and_fetch(addr, value, __ATOMIC_ACQUIRE); } #define AO_HAVE_and_acquire AO_INLINE void AO_or_acquire(volatile AO_t *addr, AO_t value) { (void)__atomic_or_fetch(addr, value, __ATOMIC_ACQUIRE); } #define AO_HAVE_or_acquire AO_INLINE void AO_xor_acquire(volatile AO_t *addr, AO_t value) { (void)__atomic_xor_fetch(addr, value, __ATOMIC_ACQUIRE); } #define AO_HAVE_xor_acquire /* * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. * * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. * */ AO_INLINE unsigned/**/char AO_char_fetch_and_add_release(volatile unsigned/**/char *addr, unsigned/**/char incr) { return __atomic_fetch_add(addr, incr, __ATOMIC_RELEASE); } #define AO_HAVE_char_fetch_and_add_release AO_INLINE void AO_char_and_release(volatile unsigned/**/char *addr, unsigned/**/char value) { (void)__atomic_and_fetch(addr, value, __ATOMIC_RELEASE); } #define AO_HAVE_char_and_release AO_INLINE void AO_char_or_release(volatile unsigned/**/char *addr, unsigned/**/char value) { (void)__atomic_or_fetch(addr, value, __ATOMIC_RELEASE); } #define AO_HAVE_char_or_release AO_INLINE void AO_char_xor_release(volatile unsigned/**/char *addr, unsigned/**/char value) { (void)__atomic_xor_fetch(addr, value, __ATOMIC_RELEASE); } #define AO_HAVE_char_xor_release /* * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. * * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. * */ AO_INLINE unsigned/**/short AO_short_fetch_and_add_release(volatile unsigned/**/short *addr, unsigned/**/short incr) { return __atomic_fetch_add(addr, incr, __ATOMIC_RELEASE); } #define AO_HAVE_short_fetch_and_add_release AO_INLINE void AO_short_and_release(volatile unsigned/**/short *addr, unsigned/**/short value) { (void)__atomic_and_fetch(addr, value, __ATOMIC_RELEASE); } #define AO_HAVE_short_and_release AO_INLINE void AO_short_or_release(volatile unsigned/**/short *addr, unsigned/**/short value) { (void)__atomic_or_fetch(addr, value, __ATOMIC_RELEASE); } #define AO_HAVE_short_or_release AO_INLINE void AO_short_xor_release(volatile unsigned/**/short *addr, unsigned/**/short value) { (void)__atomic_xor_fetch(addr, value, __ATOMIC_RELEASE); } #define AO_HAVE_short_xor_release /* * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. * * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. * */ AO_INLINE unsigned AO_int_fetch_and_add_release(volatile unsigned *addr, unsigned incr) { return __atomic_fetch_add(addr, incr, __ATOMIC_RELEASE); } #define AO_HAVE_int_fetch_and_add_release AO_INLINE void AO_int_and_release(volatile unsigned *addr, unsigned value) { (void)__atomic_and_fetch(addr, value, __ATOMIC_RELEASE); } #define AO_HAVE_int_and_release AO_INLINE void AO_int_or_release(volatile unsigned *addr, unsigned value) { (void)__atomic_or_fetch(addr, value, __ATOMIC_RELEASE); } #define AO_HAVE_int_or_release AO_INLINE void AO_int_xor_release(volatile unsigned *addr, unsigned value) { (void)__atomic_xor_fetch(addr, value, __ATOMIC_RELEASE); } #define AO_HAVE_int_xor_release /* * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. * * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. * */ AO_INLINE AO_t AO_fetch_and_add_release(volatile AO_t *addr, AO_t incr) { return __atomic_fetch_add(addr, incr, __ATOMIC_RELEASE); } #define AO_HAVE_fetch_and_add_release AO_INLINE void AO_and_release(volatile AO_t *addr, AO_t value) { (void)__atomic_and_fetch(addr, value, __ATOMIC_RELEASE); } #define AO_HAVE_and_release AO_INLINE void AO_or_release(volatile AO_t *addr, AO_t value) { (void)__atomic_or_fetch(addr, value, __ATOMIC_RELEASE); } #define AO_HAVE_or_release AO_INLINE void AO_xor_release(volatile AO_t *addr, AO_t value) { (void)__atomic_xor_fetch(addr, value, __ATOMIC_RELEASE); } #define AO_HAVE_xor_release /* * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. * * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. * */ AO_INLINE unsigned/**/char AO_char_fetch_and_add_full(volatile unsigned/**/char *addr, unsigned/**/char incr) { return __atomic_fetch_add(addr, incr, __ATOMIC_SEQ_CST); } #define AO_HAVE_char_fetch_and_add_full AO_INLINE void AO_char_and_full(volatile unsigned/**/char *addr, unsigned/**/char value) { (void)__atomic_and_fetch(addr, value, __ATOMIC_SEQ_CST); } #define AO_HAVE_char_and_full AO_INLINE void AO_char_or_full(volatile unsigned/**/char *addr, unsigned/**/char value) { (void)__atomic_or_fetch(addr, value, __ATOMIC_SEQ_CST); } #define AO_HAVE_char_or_full AO_INLINE void AO_char_xor_full(volatile unsigned/**/char *addr, unsigned/**/char value) { (void)__atomic_xor_fetch(addr, value, __ATOMIC_SEQ_CST); } #define AO_HAVE_char_xor_full /* * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. * * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. * */ AO_INLINE unsigned/**/short AO_short_fetch_and_add_full(volatile unsigned/**/short *addr, unsigned/**/short incr) { return __atomic_fetch_add(addr, incr, __ATOMIC_SEQ_CST); } #define AO_HAVE_short_fetch_and_add_full AO_INLINE void AO_short_and_full(volatile unsigned/**/short *addr, unsigned/**/short value) { (void)__atomic_and_fetch(addr, value, __ATOMIC_SEQ_CST); } #define AO_HAVE_short_and_full AO_INLINE void AO_short_or_full(volatile unsigned/**/short *addr, unsigned/**/short value) { (void)__atomic_or_fetch(addr, value, __ATOMIC_SEQ_CST); } #define AO_HAVE_short_or_full AO_INLINE void AO_short_xor_full(volatile unsigned/**/short *addr, unsigned/**/short value) { (void)__atomic_xor_fetch(addr, value, __ATOMIC_SEQ_CST); } #define AO_HAVE_short_xor_full /* * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. * * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. * */ AO_INLINE unsigned AO_int_fetch_and_add_full(volatile unsigned *addr, unsigned incr) { return __atomic_fetch_add(addr, incr, __ATOMIC_SEQ_CST); } #define AO_HAVE_int_fetch_and_add_full AO_INLINE void AO_int_and_full(volatile unsigned *addr, unsigned value) { (void)__atomic_and_fetch(addr, value, __ATOMIC_SEQ_CST); } #define AO_HAVE_int_and_full AO_INLINE void AO_int_or_full(volatile unsigned *addr, unsigned value) { (void)__atomic_or_fetch(addr, value, __ATOMIC_SEQ_CST); } #define AO_HAVE_int_or_full AO_INLINE void AO_int_xor_full(volatile unsigned *addr, unsigned value) { (void)__atomic_xor_fetch(addr, value, __ATOMIC_SEQ_CST); } #define AO_HAVE_int_xor_full /* * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. * * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. * */ AO_INLINE AO_t AO_fetch_and_add_full(volatile AO_t *addr, AO_t incr) { return __atomic_fetch_add(addr, incr, __ATOMIC_SEQ_CST); } #define AO_HAVE_fetch_and_add_full AO_INLINE void AO_and_full(volatile AO_t *addr, AO_t value) { (void)__atomic_and_fetch(addr, value, __ATOMIC_SEQ_CST); } #define AO_HAVE_and_full AO_INLINE void AO_or_full(volatile AO_t *addr, AO_t value) { (void)__atomic_or_fetch(addr, value, __ATOMIC_SEQ_CST); } #define AO_HAVE_or_full AO_INLINE void AO_xor_full(volatile AO_t *addr, AO_t value) { (void)__atomic_xor_fetch(addr, value, __ATOMIC_SEQ_CST); } #define AO_HAVE_xor_full ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/gcc/generic-arithm.template000066400000000000000000000025321266352375300306700ustar00rootroot00000000000000/* * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. * * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. * */ AO_INLINE XCTYPE AO_XSIZE_fetch_and_add_XBAR(volatile XCTYPE *addr, XCTYPE incr) { return __atomic_fetch_add(addr, incr, __ATOMIC_XGCCBAR); } #define AO_HAVE_XSIZE_fetch_and_add_XBAR AO_INLINE void AO_XSIZE_and_XBAR(volatile XCTYPE *addr, XCTYPE value) { (void)__atomic_and_fetch(addr, value, __ATOMIC_XGCCBAR); } #define AO_HAVE_XSIZE_and_XBAR AO_INLINE void AO_XSIZE_or_XBAR(volatile XCTYPE *addr, XCTYPE value) { (void)__atomic_or_fetch(addr, value, __ATOMIC_XGCCBAR); } #define AO_HAVE_XSIZE_or_XBAR AO_INLINE void AO_XSIZE_xor_XBAR(volatile XCTYPE *addr, XCTYPE value) { (void)__atomic_xor_fetch(addr, value, __ATOMIC_XGCCBAR); } #define AO_HAVE_XSIZE_xor_XBAR ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/gcc/generic-small.h000066400000000000000000000221701266352375300271300ustar00rootroot00000000000000/* * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. * * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. * */ AO_INLINE unsigned/**/char AO_char_load(const volatile unsigned/**/char *addr) { return __atomic_load_n(addr, __ATOMIC_RELAXED); } #define AO_HAVE_char_load AO_INLINE unsigned/**/char AO_char_load_acquire(const volatile unsigned/**/char *addr) { return __atomic_load_n(addr, __ATOMIC_ACQUIRE); } #define AO_HAVE_char_load_acquire /* char_load_full is generalized using load and nop_full, so that */ /* char_load_read is defined using load and nop_read. */ /* char_store_full definition is omitted similar to load_full reason. */ AO_INLINE void AO_char_store(volatile unsigned/**/char *addr, unsigned/**/char value) { __atomic_store_n(addr, value, __ATOMIC_RELAXED); } #define AO_HAVE_char_store AO_INLINE void AO_char_store_release(volatile unsigned/**/char *addr, unsigned/**/char value) { __atomic_store_n(addr, value, __ATOMIC_RELEASE); } #define AO_HAVE_char_store_release AO_INLINE unsigned/**/char AO_char_fetch_compare_and_swap(volatile unsigned/**/char *addr, unsigned/**/char old_val, unsigned/**/char new_val) { return __sync_val_compare_and_swap(addr, old_val, new_val /* empty protection list */); } #define AO_HAVE_char_fetch_compare_and_swap /* TODO: Add CAS _acquire/release/full primitives. */ #ifndef AO_GENERALIZE_ASM_BOOL_CAS AO_INLINE int AO_char_compare_and_swap(volatile unsigned/**/char *addr, unsigned/**/char old_val, unsigned/**/char new_val) { return __sync_bool_compare_and_swap(addr, old_val, new_val /* empty protection list */); } # define AO_HAVE_char_compare_and_swap #endif /* !AO_GENERALIZE_ASM_BOOL_CAS */ /* * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. * * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. * */ AO_INLINE unsigned/**/short AO_short_load(const volatile unsigned/**/short *addr) { return __atomic_load_n(addr, __ATOMIC_RELAXED); } #define AO_HAVE_short_load AO_INLINE unsigned/**/short AO_short_load_acquire(const volatile unsigned/**/short *addr) { return __atomic_load_n(addr, __ATOMIC_ACQUIRE); } #define AO_HAVE_short_load_acquire /* short_load_full is generalized using load and nop_full, so that */ /* short_load_read is defined using load and nop_read. */ /* short_store_full definition is omitted similar to load_full reason. */ AO_INLINE void AO_short_store(volatile unsigned/**/short *addr, unsigned/**/short value) { __atomic_store_n(addr, value, __ATOMIC_RELAXED); } #define AO_HAVE_short_store AO_INLINE void AO_short_store_release(volatile unsigned/**/short *addr, unsigned/**/short value) { __atomic_store_n(addr, value, __ATOMIC_RELEASE); } #define AO_HAVE_short_store_release AO_INLINE unsigned/**/short AO_short_fetch_compare_and_swap(volatile unsigned/**/short *addr, unsigned/**/short old_val, unsigned/**/short new_val) { return __sync_val_compare_and_swap(addr, old_val, new_val /* empty protection list */); } #define AO_HAVE_short_fetch_compare_and_swap /* TODO: Add CAS _acquire/release/full primitives. */ #ifndef AO_GENERALIZE_ASM_BOOL_CAS AO_INLINE int AO_short_compare_and_swap(volatile unsigned/**/short *addr, unsigned/**/short old_val, unsigned/**/short new_val) { return __sync_bool_compare_and_swap(addr, old_val, new_val /* empty protection list */); } # define AO_HAVE_short_compare_and_swap #endif /* !AO_GENERALIZE_ASM_BOOL_CAS */ /* * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. * * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. * */ AO_INLINE unsigned AO_int_load(const volatile unsigned *addr) { return __atomic_load_n(addr, __ATOMIC_RELAXED); } #define AO_HAVE_int_load AO_INLINE unsigned AO_int_load_acquire(const volatile unsigned *addr) { return __atomic_load_n(addr, __ATOMIC_ACQUIRE); } #define AO_HAVE_int_load_acquire /* int_load_full is generalized using load and nop_full, so that */ /* int_load_read is defined using load and nop_read. */ /* int_store_full definition is omitted similar to load_full reason. */ AO_INLINE void AO_int_store(volatile unsigned *addr, unsigned value) { __atomic_store_n(addr, value, __ATOMIC_RELAXED); } #define AO_HAVE_int_store AO_INLINE void AO_int_store_release(volatile unsigned *addr, unsigned value) { __atomic_store_n(addr, value, __ATOMIC_RELEASE); } #define AO_HAVE_int_store_release AO_INLINE unsigned AO_int_fetch_compare_and_swap(volatile unsigned *addr, unsigned old_val, unsigned new_val) { return __sync_val_compare_and_swap(addr, old_val, new_val /* empty protection list */); } #define AO_HAVE_int_fetch_compare_and_swap /* TODO: Add CAS _acquire/release/full primitives. */ #ifndef AO_GENERALIZE_ASM_BOOL_CAS AO_INLINE int AO_int_compare_and_swap(volatile unsigned *addr, unsigned old_val, unsigned new_val) { return __sync_bool_compare_and_swap(addr, old_val, new_val /* empty protection list */); } # define AO_HAVE_int_compare_and_swap #endif /* !AO_GENERALIZE_ASM_BOOL_CAS */ /* * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. * * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. * */ AO_INLINE AO_t AO_load(const volatile AO_t *addr) { return __atomic_load_n(addr, __ATOMIC_RELAXED); } #define AO_HAVE_load AO_INLINE AO_t AO_load_acquire(const volatile AO_t *addr) { return __atomic_load_n(addr, __ATOMIC_ACQUIRE); } #define AO_HAVE_load_acquire /* load_full is generalized using load and nop_full, so that */ /* load_read is defined using load and nop_read. */ /* store_full definition is omitted similar to load_full reason. */ AO_INLINE void AO_store(volatile AO_t *addr, AO_t value) { __atomic_store_n(addr, value, __ATOMIC_RELAXED); } #define AO_HAVE_store AO_INLINE void AO_store_release(volatile AO_t *addr, AO_t value) { __atomic_store_n(addr, value, __ATOMIC_RELEASE); } #define AO_HAVE_store_release AO_INLINE AO_t AO_fetch_compare_and_swap(volatile AO_t *addr, AO_t old_val, AO_t new_val) { return __sync_val_compare_and_swap(addr, old_val, new_val /* empty protection list */); } #define AO_HAVE_fetch_compare_and_swap /* TODO: Add CAS _acquire/release/full primitives. */ #ifndef AO_GENERALIZE_ASM_BOOL_CAS AO_INLINE int AO_compare_and_swap(volatile AO_t *addr, AO_t old_val, AO_t new_val) { return __sync_bool_compare_and_swap(addr, old_val, new_val /* empty protection list */); } # define AO_HAVE_compare_and_swap #endif /* !AO_GENERALIZE_ASM_BOOL_CAS */ ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/gcc/generic-small.template000066400000000000000000000043611266352375300305160ustar00rootroot00000000000000/* * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. * * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. * */ AO_INLINE XCTYPE AO_XSIZE_load(const volatile XCTYPE *addr) { return __atomic_load_n(addr, __ATOMIC_RELAXED); } #define AO_HAVE_XSIZE_load AO_INLINE XCTYPE AO_XSIZE_load_acquire(const volatile XCTYPE *addr) { return __atomic_load_n(addr, __ATOMIC_ACQUIRE); } #define AO_HAVE_XSIZE_load_acquire /* XSIZE_load_full is generalized using load and nop_full, so that */ /* XSIZE_load_read is defined using load and nop_read. */ /* XSIZE_store_full definition is omitted similar to load_full reason. */ AO_INLINE void AO_XSIZE_store(volatile XCTYPE *addr, XCTYPE value) { __atomic_store_n(addr, value, __ATOMIC_RELAXED); } #define AO_HAVE_XSIZE_store AO_INLINE void AO_XSIZE_store_release(volatile XCTYPE *addr, XCTYPE value) { __atomic_store_n(addr, value, __ATOMIC_RELEASE); } #define AO_HAVE_XSIZE_store_release AO_INLINE XCTYPE AO_XSIZE_fetch_compare_and_swap(volatile XCTYPE *addr, XCTYPE old_val, XCTYPE new_val) { return __sync_val_compare_and_swap(addr, old_val, new_val /* empty protection list */); } #define AO_HAVE_XSIZE_fetch_compare_and_swap /* TODO: Add CAS _acquire/release/full primitives. */ #ifndef AO_GENERALIZE_ASM_BOOL_CAS AO_INLINE int AO_XSIZE_compare_and_swap(volatile XCTYPE *addr, XCTYPE old_val, XCTYPE new_val) { return __sync_bool_compare_and_swap(addr, old_val, new_val /* empty protection list */); } # define AO_HAVE_XSIZE_compare_and_swap #endif /* !AO_GENERALIZE_ASM_BOOL_CAS */ ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/gcc/generic.h000066400000000000000000000106301266352375300260200ustar00rootroot00000000000000/* * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. * * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. * */ /* The following implementation assumes GCC 4.7 or later. */ /* For the details, see GNU Manual, chapter 6.52 (Built-in functions */ /* for memory model aware atomic operations). */ /* TODO: Include this file for other targets if gcc 4.7+ */ #ifdef AO_UNIPROCESSOR /* If only a single processor (core) is used, AO_UNIPROCESSOR could */ /* be defined by the client to avoid unnecessary memory barrier. */ AO_INLINE void AO_nop_full(void) { AO_compiler_barrier(); } # define AO_HAVE_nop_full #else AO_INLINE void AO_nop_read(void) { __atomic_thread_fence(__ATOMIC_ACQUIRE); } # define AO_HAVE_nop_read # ifndef AO_HAVE_nop_write AO_INLINE void AO_nop_write(void) { __atomic_thread_fence(__ATOMIC_RELEASE); } # define AO_HAVE_nop_write # endif AO_INLINE void AO_nop_full(void) { /* __sync_synchronize() could be used instead. */ __atomic_thread_fence(__ATOMIC_SEQ_CST); } # define AO_HAVE_nop_full #endif /* !AO_UNIPROCESSOR */ #include "generic-small.h" #ifndef AO_PREFER_GENERALIZED # include "generic-arithm.h" AO_INLINE AO_TS_VAL_t AO_test_and_set(volatile AO_TS_t *addr) { return (AO_TS_VAL_t)__atomic_test_and_set(addr, __ATOMIC_RELAXED); } # define AO_HAVE_test_and_set AO_INLINE AO_TS_VAL_t AO_test_and_set_acquire(volatile AO_TS_t *addr) { return (AO_TS_VAL_t)__atomic_test_and_set(addr, __ATOMIC_ACQUIRE); } # define AO_HAVE_test_and_set_acquire AO_INLINE AO_TS_VAL_t AO_test_and_set_release(volatile AO_TS_t *addr) { return (AO_TS_VAL_t)__atomic_test_and_set(addr, __ATOMIC_RELEASE); } # define AO_HAVE_test_and_set_release AO_INLINE AO_TS_VAL_t AO_test_and_set_full(volatile AO_TS_t *addr) { return (AO_TS_VAL_t)__atomic_test_and_set(addr, __ATOMIC_SEQ_CST); } # define AO_HAVE_test_and_set_full #endif /* !AO_PREFER_GENERALIZED */ #ifdef AO_HAVE_DOUBLE_PTR_STORAGE # ifndef AO_HAVE_double_load AO_INLINE AO_double_t AO_double_load(const volatile AO_double_t *addr) { AO_double_t result; result.AO_whole = __atomic_load_n(&addr->AO_whole, __ATOMIC_RELAXED); return result; } # define AO_HAVE_double_load # endif # ifndef AO_HAVE_double_load_acquire AO_INLINE AO_double_t AO_double_load_acquire(const volatile AO_double_t *addr) { AO_double_t result; result.AO_whole = __atomic_load_n(&addr->AO_whole, __ATOMIC_ACQUIRE); return result; } # define AO_HAVE_double_load_acquire # endif # ifndef AO_HAVE_double_store AO_INLINE void AO_double_store(volatile AO_double_t *addr, AO_double_t value) { __atomic_store_n(&addr->AO_whole, value.AO_whole, __ATOMIC_RELAXED); } # define AO_HAVE_double_store # endif # ifndef AO_HAVE_double_store_release AO_INLINE void AO_double_store_release(volatile AO_double_t *addr, AO_double_t value) { __atomic_store_n(&addr->AO_whole, value.AO_whole, __ATOMIC_RELEASE); } # define AO_HAVE_double_store_release # endif # ifndef AO_HAVE_double_compare_and_swap AO_INLINE int AO_double_compare_and_swap(volatile AO_double_t *addr, AO_double_t old_val, AO_double_t new_val) { return (int)__atomic_compare_exchange_n(&addr->AO_whole, &old_val.AO_whole /* p_expected */, new_val.AO_whole /* desired */, 0 /* is_weak: false */, __ATOMIC_RELAXED /* success */, __ATOMIC_RELAXED /* failure */); } # define AO_HAVE_double_compare_and_swap # endif /* TODO: Add double CAS _acquire/release/full primitives. */ #endif /* AO_HAVE_DOUBLE_PTR_STORAGE */ ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/gcc/hexagon.h000066400000000000000000000101721266352375300260360ustar00rootroot00000000000000/* * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. */ #include "../all_aligned_atomic_load_store.h" #include "../test_and_set_t_is_ao_t.h" /* There's also "isync" and "barrier"; however, for all current CPU */ /* versions, "syncht" should suffice. Likewise, it seems that the */ /* auto-defined versions of *_acquire, *_release or *_full suffice for */ /* all current ISA implementations. */ AO_INLINE void AO_nop_full(void) { __asm__ __volatile__("syncht" : : : "memory"); } #define AO_HAVE_nop_full /* The Hexagon has load-locked, store-conditional primitives, and so */ /* resulting code is very nearly identical to that of PowerPC. */ #ifndef AO_PREFER_GENERALIZED AO_INLINE AO_t AO_fetch_and_add(volatile AO_t *addr, AO_t incr) { AO_t oldval; AO_t newval; __asm__ __volatile__( "1:\n" " %0 = memw_locked(%3);\n" /* load and reserve */ " %1 = add (%0,%4);\n" /* increment */ " memw_locked(%3,p1) = %1;\n" /* store conditional */ " if (!p1) jump 1b;\n" /* retry if lost reservation */ : "=&r"(oldval), "=&r"(newval), "+m"(*addr) : "r"(addr), "r"(incr) : "memory", "p1"); return oldval; } #define AO_HAVE_fetch_and_add AO_INLINE AO_TS_VAL_t AO_test_and_set(volatile AO_TS_t *addr) { int oldval; int locked_value = 1; __asm__ __volatile__( "1:\n" " %0 = memw_locked(%2);\n" /* load and reserve */ " {\n" " p2 = cmp.eq(%0,#0);\n" /* if load is not zero, */ " if (!p2.new) jump:nt 2f; \n" /* we are done */ " }\n" " memw_locked(%2,p1) = %3;\n" /* else store conditional */ " if (!p1) jump 1b;\n" /* retry if lost reservation */ "2:\n" /* oldval is zero if we set */ : "=&r"(oldval), "+m"(*addr) : "r"(addr), "r"(locked_value) : "memory", "p1", "p2"); return (AO_TS_VAL_t)oldval; } #define AO_HAVE_test_and_set #endif /* !AO_PREFER_GENERALIZED */ #ifndef AO_GENERALIZE_ASM_BOOL_CAS AO_INLINE int AO_compare_and_swap(volatile AO_t *addr, AO_t old, AO_t new_val) { AO_t __oldval; int result = 0; __asm__ __volatile__( "1:\n" " %0 = memw_locked(%3);\n" /* load and reserve */ " {\n" " p2 = cmp.eq(%0,%4);\n" /* if load is not equal to */ " if (!p2.new) jump:nt 2f; \n" /* old, fail */ " }\n" " memw_locked(%3,p1) = %5;\n" /* else store conditional */ " if (!p1) jump 1b;\n" /* retry if lost reservation */ " %1 = #1\n" /* success, result = 1 */ "2:\n" : "=&r" (__oldval), "+r" (result), "+m"(*addr) : "r" (addr), "r" (old), "r" (new_val) : "p1", "p2", "memory" ); return result; } # define AO_HAVE_compare_and_swap #endif /* !AO_GENERALIZE_ASM_BOOL_CAS */ AO_INLINE AO_t AO_fetch_compare_and_swap(volatile AO_t *addr, AO_t old_val, AO_t new_val) { AO_t __oldval; __asm__ __volatile__( "1:\n" " %0 = memw_locked(%2);\n" /* load and reserve */ " {\n" " p2 = cmp.eq(%0,%3);\n" /* if load is not equal to */ " if (!p2.new) jump:nt 2f; \n" /* old_val, fail */ " }\n" " memw_locked(%2,p1) = %4;\n" /* else store conditional */ " if (!p1) jump 1b;\n" /* retry if lost reservation */ "2:\n" : "=&r" (__oldval), "+m"(*addr) : "r" (addr), "r" (old_val), "r" (new_val) : "p1", "p2", "memory" ); return __oldval; } #define AO_HAVE_fetch_compare_and_swap #define AO_T_IS_INT ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/gcc/hppa.h000066400000000000000000000074351266352375300253450ustar00rootroot00000000000000/* * Copyright (c) 2003 Hewlett-Packard Development Company, L.P. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ #include "../all_atomic_load_store.h" /* Some architecture set descriptions include special "ordered" memory */ /* operations. As far as we can tell, no existing processors actually */ /* require those. Nor does it appear likely that future processors */ /* will. */ #include "../ordered.h" /* GCC will not guarantee the alignment we need, use four lock words */ /* and select the correctly aligned datum. See the glibc 2.3.2 */ /* linuxthread port for the original implementation. */ struct AO_pa_clearable_loc { int data[4]; }; #undef AO_TS_INITIALIZER #define AO_TS_t struct AO_pa_clearable_loc #define AO_TS_INITIALIZER {1,1,1,1} /* Switch meaning of set and clear, since we only have an atomic clear */ /* instruction. */ typedef enum {AO_PA_TS_set = 0, AO_PA_TS_clear = 1} AO_PA_TS_val; #define AO_TS_VAL_t AO_PA_TS_val #define AO_TS_CLEAR AO_PA_TS_clear #define AO_TS_SET AO_PA_TS_set /* The hppa only has one atomic read and modify memory operation, */ /* load and clear, so hppa spinlocks must use zero to signify that */ /* someone is holding the lock. The address used for the ldcw */ /* semaphore must be 16-byte aligned. */ #define AO_ldcw(a, ret) \ __asm__ __volatile__("ldcw 0(%2), %0" \ : "=r" (ret), "=m" (*(a)) : "r" (a)) /* Because malloc only guarantees 8-byte alignment for malloc'd data, */ /* and GCC only guarantees 8-byte alignment for stack locals, we can't */ /* be assured of 16-byte alignment for atomic lock data even if we */ /* specify "__attribute ((aligned(16)))" in the type declaration. So, */ /* we use a struct containing an array of four ints for the atomic lock */ /* type and dynamically select the 16-byte aligned int from the array */ /* for the semaphore. */ #define AO_PA_LDCW_ALIGNMENT 16 #define AO_ldcw_align(addr) \ ((volatile unsigned *)(((unsigned long)(addr) \ + (AO_PA_LDCW_ALIGNMENT - 1)) \ & ~(AO_PA_LDCW_ALIGNMENT - 1))) /* Works on PA 1.1 and PA 2.0 systems */ AO_INLINE AO_TS_VAL_t AO_test_and_set_full(volatile AO_TS_t * addr) { volatile unsigned int ret; volatile unsigned *a = AO_ldcw_align(addr); AO_ldcw(a, ret); return (AO_TS_VAL_t)ret; } #define AO_HAVE_test_and_set_full AO_INLINE void AO_pa_clear(volatile AO_TS_t * addr) { volatile unsigned *a = AO_ldcw_align(addr); AO_compiler_barrier(); *a = 1; } #define AO_CLEAR(addr) AO_pa_clear(addr) ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/gcc/ia64.h000066400000000000000000000233411266352375300251520ustar00rootroot00000000000000/* * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ #include "../all_atomic_load_store.h" #include "../all_acquire_release_volatile.h" #include "../test_and_set_t_is_char.h" #ifdef _ILP32 /* 32-bit HP/UX code. */ /* This requires pointer "swizzling". Pointers need to be expanded */ /* to 64 bits using the addp4 instruction before use. This makes it */ /* hard to share code, but we try anyway. */ # define AO_LEN "4" /* We assume that addr always appears in argument position 1 in asm */ /* code. If it is clobbered due to swizzling, we also need it in */ /* second position. Any later arguments are referenced symbolically, */ /* so that we don't have to worry about their position. This requires*/ /* gcc 3.1, but you shouldn't be using anything older than that on */ /* IA64 anyway. */ /* The AO_MASK macro is a workaround for the fact that HP/UX gcc */ /* appears to otherwise store 64-bit pointers in ar.ccv, i.e. it */ /* doesn't appear to clear high bits in a pointer value we pass into */ /* assembly code, even if it is supposedly of type AO_t. */ # define AO_IN_ADDR "1"(addr) # define AO_OUT_ADDR , "=r"(addr) # define AO_SWIZZLE "addp4 %1=0,%1;;\n" # define AO_MASK(ptr) __asm__ __volatile__("zxt4 %1=%1": "=r"(ptr) : "0"(ptr)) #else # define AO_LEN "8" # define AO_IN_ADDR "r"(addr) # define AO_OUT_ADDR # define AO_SWIZZLE # define AO_MASK(ptr) /* empty */ #endif /* !_ILP32 */ AO_INLINE void AO_nop_full(void) { __asm__ __volatile__("mf" : : : "memory"); } #define AO_HAVE_nop_full #ifndef AO_PREFER_GENERALIZED AO_INLINE AO_t AO_fetch_and_add1_acquire (volatile AO_t *addr) { AO_t result; __asm__ __volatile__ (AO_SWIZZLE "fetchadd" AO_LEN ".acq %0=[%1],1": "=r" (result) AO_OUT_ADDR: AO_IN_ADDR :"memory"); return result; } #define AO_HAVE_fetch_and_add1_acquire AO_INLINE AO_t AO_fetch_and_add1_release (volatile AO_t *addr) { AO_t result; __asm__ __volatile__ (AO_SWIZZLE "fetchadd" AO_LEN ".rel %0=[%1],1": "=r" (result) AO_OUT_ADDR: AO_IN_ADDR :"memory"); return result; } #define AO_HAVE_fetch_and_add1_release AO_INLINE AO_t AO_fetch_and_sub1_acquire (volatile AO_t *addr) { AO_t result; __asm__ __volatile__ (AO_SWIZZLE "fetchadd" AO_LEN ".acq %0=[%1],-1": "=r" (result) AO_OUT_ADDR: AO_IN_ADDR :"memory"); return result; } #define AO_HAVE_fetch_and_sub1_acquire AO_INLINE AO_t AO_fetch_and_sub1_release (volatile AO_t *addr) { AO_t result; __asm__ __volatile__ (AO_SWIZZLE "fetchadd" AO_LEN ".rel %0=[%1],-1": "=r" (result) AO_OUT_ADDR: AO_IN_ADDR :"memory"); return result; } #define AO_HAVE_fetch_and_sub1_release #endif /* !AO_PREFER_GENERALIZED */ AO_INLINE AO_t AO_fetch_compare_and_swap_acquire(volatile AO_t *addr, AO_t old, AO_t new_val) { AO_t fetched_val; AO_MASK(old); __asm__ __volatile__(AO_SWIZZLE "mov ar.ccv=%[old] ;; cmpxchg" AO_LEN ".acq %0=[%1],%[new_val],ar.ccv" : "=r"(fetched_val) AO_OUT_ADDR : AO_IN_ADDR, [new_val]"r"(new_val), [old]"r"(old) : "memory"); return fetched_val; } #define AO_HAVE_fetch_compare_and_swap_acquire AO_INLINE AO_t AO_fetch_compare_and_swap_release(volatile AO_t *addr, AO_t old, AO_t new_val) { AO_t fetched_val; AO_MASK(old); __asm__ __volatile__(AO_SWIZZLE "mov ar.ccv=%[old] ;; cmpxchg" AO_LEN ".rel %0=[%1],%[new_val],ar.ccv" : "=r"(fetched_val) AO_OUT_ADDR : AO_IN_ADDR, [new_val]"r"(new_val), [old]"r"(old) : "memory"); return fetched_val; } #define AO_HAVE_fetch_compare_and_swap_release AO_INLINE unsigned char AO_char_fetch_compare_and_swap_acquire(volatile unsigned char *addr, unsigned char old, unsigned char new_val) { unsigned char fetched_val; __asm__ __volatile__(AO_SWIZZLE "mov ar.ccv=%[old] ;; cmpxchg1.acq %0=[%1],%[new_val],ar.ccv" : "=r"(fetched_val) AO_OUT_ADDR : AO_IN_ADDR, [new_val]"r"(new_val), [old]"r"((AO_t)old) : "memory"); return fetched_val; } #define AO_HAVE_char_fetch_compare_and_swap_acquire AO_INLINE unsigned char AO_char_fetch_compare_and_swap_release(volatile unsigned char *addr, unsigned char old, unsigned char new_val) { unsigned char fetched_val; __asm__ __volatile__(AO_SWIZZLE "mov ar.ccv=%[old] ;; cmpxchg1.rel %0=[%1],%[new_val],ar.ccv" : "=r"(fetched_val) AO_OUT_ADDR : AO_IN_ADDR, [new_val]"r"(new_val), [old]"r"((AO_t)old) : "memory"); return fetched_val; } #define AO_HAVE_char_fetch_compare_and_swap_release AO_INLINE unsigned short AO_short_fetch_compare_and_swap_acquire(volatile unsigned short *addr, unsigned short old, unsigned short new_val) { unsigned short fetched_val; __asm__ __volatile__(AO_SWIZZLE "mov ar.ccv=%[old] ;; cmpxchg2.acq %0=[%1],%[new_val],ar.ccv" : "=r"(fetched_val) AO_OUT_ADDR : AO_IN_ADDR, [new_val]"r"(new_val), [old]"r"((AO_t)old) : "memory"); return fetched_val; } #define AO_HAVE_short_fetch_compare_and_swap_acquire AO_INLINE unsigned short AO_short_fetch_compare_and_swap_release(volatile unsigned short *addr, unsigned short old, unsigned short new_val) { unsigned short fetched_val; __asm__ __volatile__(AO_SWIZZLE "mov ar.ccv=%[old] ;; cmpxchg2.rel %0=[%1],%[new_val],ar.ccv" : "=r"(fetched_val) AO_OUT_ADDR : AO_IN_ADDR, [new_val]"r"(new_val), [old]"r"((AO_t)old) : "memory"); return fetched_val; } #define AO_HAVE_short_fetch_compare_and_swap_release #ifdef _ILP32 # define AO_T_IS_INT /* TODO: Add compare_double_and_swap_double for the _ILP32 case. */ #else # ifndef AO_PREFER_GENERALIZED AO_INLINE unsigned int AO_int_fetch_and_add1_acquire(volatile unsigned int *addr) { unsigned int result; __asm__ __volatile__("fetchadd4.acq %0=[%1],1" : "=r" (result) : AO_IN_ADDR : "memory"); return result; } # define AO_HAVE_int_fetch_and_add1_acquire AO_INLINE unsigned int AO_int_fetch_and_add1_release(volatile unsigned int *addr) { unsigned int result; __asm__ __volatile__("fetchadd4.rel %0=[%1],1" : "=r" (result) : AO_IN_ADDR : "memory"); return result; } # define AO_HAVE_int_fetch_and_add1_release AO_INLINE unsigned int AO_int_fetch_and_sub1_acquire(volatile unsigned int *addr) { unsigned int result; __asm__ __volatile__("fetchadd4.acq %0=[%1],-1" : "=r" (result) : AO_IN_ADDR : "memory"); return result; } # define AO_HAVE_int_fetch_and_sub1_acquire AO_INLINE unsigned int AO_int_fetch_and_sub1_release(volatile unsigned int *addr) { unsigned int result; __asm__ __volatile__("fetchadd4.rel %0=[%1],-1" : "=r" (result) : AO_IN_ADDR : "memory"); return result; } # define AO_HAVE_int_fetch_and_sub1_release # endif /* !AO_PREFER_GENERALIZED */ AO_INLINE unsigned int AO_int_fetch_compare_and_swap_acquire(volatile unsigned int *addr, unsigned int old, unsigned int new_val) { unsigned int fetched_val; __asm__ __volatile__("mov ar.ccv=%3 ;; cmpxchg4.acq %0=[%1],%2,ar.ccv" : "=r"(fetched_val) : AO_IN_ADDR, "r"(new_val), "r"((AO_t)old) : "memory"); return fetched_val; } # define AO_HAVE_int_fetch_compare_and_swap_acquire AO_INLINE unsigned int AO_int_fetch_compare_and_swap_release(volatile unsigned int *addr, unsigned int old, unsigned int new_val) { unsigned int fetched_val; __asm__ __volatile__("mov ar.ccv=%3 ;; cmpxchg4.rel %0=[%1],%2,ar.ccv" : "=r"(fetched_val) : AO_IN_ADDR, "r"(new_val), "r"((AO_t)old) : "memory"); return fetched_val; } # define AO_HAVE_int_fetch_compare_and_swap_release #endif /* !_ILP32 */ /* TODO: Add compare_and_swap_double as soon as there is widely */ /* available hardware that implements it. */ ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/gcc/m68k.h000066400000000000000000000042151266352375300251730ustar00rootroot00000000000000/* * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. * Copyright (c) 1999-2003 by Hewlett-Packard Company. All rights reserved. * * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. * */ /* The cas instruction causes an emulation trap for the */ /* 060 with a misaligned pointer, so let's avoid this. */ #undef AO_t typedef unsigned long AO_t __attribute__ ((aligned (4))); /* FIXME. Very incomplete. */ #include "../all_aligned_atomic_load_store.h" /* Are there any m68k multiprocessors still around? */ /* AFAIK, Alliants were sequentially consistent. */ #include "../ordered.h" #include "../test_and_set_t_is_char.h" AO_INLINE AO_TS_VAL_t AO_test_and_set_full(volatile AO_TS_t *addr) { AO_TS_t oldval; /* The value at addr is semi-phony. */ /* 'tas' sets bit 7 while the return */ /* value pretends all bits were set, */ /* which at least matches AO_TS_SET. */ __asm__ __volatile__( "tas %1; sne %0" : "=d" (oldval), "=m" (*addr) : "m" (*addr) : "memory"); /* This cast works due to the above. */ return (AO_TS_VAL_t)oldval; } #define AO_HAVE_test_and_set_full /* Returns nonzero if the comparison succeeded. */ AO_INLINE int AO_compare_and_swap_full(volatile AO_t *addr, AO_t old, AO_t new_val) { char result; __asm__ __volatile__( "cas.l %3,%4,%1; seq %0" : "=d" (result), "=m" (*addr) : "m" (*addr), "d" (old), "d" (new_val) : "memory"); return -result; } #define AO_HAVE_compare_and_swap_full /* TODO: implement AO_fetch_compare_and_swap. */ #define AO_T_IS_INT ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/gcc/mips.h000066400000000000000000000117261266352375300253630ustar00rootroot00000000000000/* * Copyright (c) 2005,2007 Thiemo Seufer * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. */ /* * FIXME: This should probably make finer distinctions. SGI MIPS is * much more strongly ordered, and in fact closer to sequentially * consistent. This is really aimed at modern embedded implementations. */ #include "../all_aligned_atomic_load_store.h" #include "../test_and_set_t_is_ao_t.h" /* Data dependence does not imply read ordering. */ #define AO_NO_DD_ORDERING #if defined(_ABI64) && (_MIPS_SIM == _ABI64) # define AO_MIPS_SET_ISA " .set mips3\n" # define AO_MIPS_LL_1(args) " lld " args "\n" # define AO_MIPS_SC(args) " scd " args "\n" #else # define AO_MIPS_SET_ISA " .set mips2\n" # define AO_MIPS_LL_1(args) " ll " args "\n" # define AO_MIPS_SC(args) " sc " args "\n" # define AO_T_IS_INT #endif #ifdef AO_ICE9A1_LLSC_WAR /* ICE9 rev A1 chip (used in very few systems) is reported to */ /* have a low-frequency bug that causes LL to fail. */ /* To workaround, just issue the second 'LL'. */ # define AO_MIPS_LL(args) AO_MIPS_LL_1(args) AO_MIPS_LL_1(args) #else # define AO_MIPS_LL(args) AO_MIPS_LL_1(args) #endif AO_INLINE void AO_nop_full(void) { __asm__ __volatile__( " .set push \n" AO_MIPS_SET_ISA " .set noreorder \n" " .set nomacro \n" " sync \n" " .set pop " : : : "memory"); } #define AO_HAVE_nop_full #ifndef AO_PREFER_GENERALIZED AO_INLINE AO_t AO_fetch_and_add(volatile AO_t *addr, AO_t incr) { register int result; register int temp; __asm__ __volatile__( " .set push\n" AO_MIPS_SET_ISA " .set noreorder\n" " .set nomacro\n" "1: " AO_MIPS_LL("%0, %2") " addu %1, %0, %3\n" AO_MIPS_SC("%1, %2") " beqz %1, 1b\n" " nop\n" " .set pop " : "=&r" (result), "=&r" (temp), "+m" (*addr) : "Ir" (incr) : "memory"); return (AO_t)result; } #define AO_HAVE_fetch_and_add AO_INLINE AO_TS_VAL_t AO_test_and_set(volatile AO_TS_t *addr) { register int oldval; register int temp; __asm__ __volatile__( " .set push\n" AO_MIPS_SET_ISA " .set noreorder\n" " .set nomacro\n" "1: " AO_MIPS_LL("%0, %2") " move %1, %3\n" AO_MIPS_SC("%1, %2") " beqz %1, 1b\n" " nop\n" " .set pop " : "=&r" (oldval), "=&r" (temp), "+m" (*addr) : "r" (1) : "memory"); return (AO_TS_VAL_t)oldval; } #define AO_HAVE_test_and_set /* TODO: Implement AO_and/or/xor primitives directly. */ #endif /* !AO_PREFER_GENERALIZED */ #ifndef AO_GENERALIZE_ASM_BOOL_CAS AO_INLINE int AO_compare_and_swap(volatile AO_t *addr, AO_t old, AO_t new_val) { register int was_equal = 0; register int temp; __asm__ __volatile__( " .set push \n" AO_MIPS_SET_ISA " .set noreorder \n" " .set nomacro \n" "1: " AO_MIPS_LL("%0, %1") " bne %0, %4, 2f \n" " move %0, %3 \n" AO_MIPS_SC("%0, %1") " .set pop \n" " beqz %0, 1b \n" " li %2, 1 \n" "2: " : "=&r" (temp), "+m" (*addr), "+r" (was_equal) : "r" (new_val), "r" (old) : "memory"); return was_equal; } # define AO_HAVE_compare_and_swap #endif /* !AO_GENERALIZE_ASM_BOOL_CAS */ AO_INLINE AO_t AO_fetch_compare_and_swap(volatile AO_t *addr, AO_t old, AO_t new_val) { register int fetched_val; register int temp; __asm__ __volatile__( " .set push\n" AO_MIPS_SET_ISA " .set noreorder\n" " .set nomacro\n" "1: " AO_MIPS_LL("%0, %2") " bne %0, %4, 2f\n" " move %1, %3\n" AO_MIPS_SC("%1, %2") " beqz %1, 1b\n" " nop\n" " .set pop\n" "2:" : "=&r" (fetched_val), "=&r" (temp), "+m" (*addr) : "r" (new_val), "Jr" (old) : "memory"); return (AO_t)fetched_val; } #define AO_HAVE_fetch_compare_and_swap /* #include "../standard_ao_double_t.h" */ /* TODO: Implement double-wide operations if available. */ /* CAS primitives with acquire, release and full semantics are */ /* generated automatically (and AO_int_... primitives are */ /* defined properly after the first generalization pass). */ ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/gcc/powerpc.h000066400000000000000000000277521266352375300261000ustar00rootroot00000000000000/* * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. * * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. * */ /* Memory model documented at http://www-106.ibm.com/developerworks/ */ /* eserver/articles/archguide.html and (clearer) */ /* http://www-106.ibm.com/developerworks/eserver/articles/powerpc.html. */ /* There appears to be no implicit ordering between any kind of */ /* independent memory references. */ /* Architecture enforces some ordering based on control dependence. */ /* I don't know if that could help. */ /* Data-dependent loads are always ordered. */ /* Based on the above references, eieio is intended for use on */ /* uncached memory, which we don't support. It does not order loads */ /* from cached memory. */ #include "../all_aligned_atomic_load_store.h" #include "../test_and_set_t_is_ao_t.h" /* There seems to be no byte equivalent of lwarx, so this */ /* may really be what we want, at least in the 32-bit case. */ AO_INLINE void AO_nop_full(void) { __asm__ __volatile__("sync" : : : "memory"); } #define AO_HAVE_nop_full /* lwsync apparently works for everything but a StoreLoad barrier. */ AO_INLINE void AO_lwsync(void) { #ifdef __NO_LWSYNC__ __asm__ __volatile__("sync" : : : "memory"); #else __asm__ __volatile__("lwsync" : : : "memory"); #endif } #define AO_nop_write() AO_lwsync() #define AO_HAVE_nop_write #define AO_nop_read() AO_lwsync() #define AO_HAVE_nop_read /* We explicitly specify load_acquire, since it is important, and can */ /* be implemented relatively cheaply. It could be implemented */ /* with an ordinary load followed by a lwsync. But the general wisdom */ /* seems to be that a data dependent branch followed by an isync is */ /* cheaper. And the documentation is fairly explicit that this also */ /* has acquire semantics. */ /* ppc64 uses ld not lwz */ AO_INLINE AO_t AO_load_acquire(const volatile AO_t *addr) { AO_t result; #if defined(__powerpc64__) || defined(__ppc64__) || defined(__64BIT__) __asm__ __volatile__ ( "ld%U1%X1 %0,%1\n" "cmpw %0,%0\n" "bne- 1f\n" "1: isync\n" : "=r" (result) : "m"(*addr) : "memory", "cr0"); #else /* FIXME: We should get gcc to allocate one of the condition */ /* registers. I always got "impossible constraint" when I */ /* tried the "y" constraint. */ __asm__ __volatile__ ( "lwz%U1%X1 %0,%1\n" "cmpw %0,%0\n" "bne- 1f\n" "1: isync\n" : "=r" (result) : "m"(*addr) : "memory", "cc"); #endif return result; } #define AO_HAVE_load_acquire /* We explicitly specify store_release, since it relies */ /* on the fact that lwsync is also a LoadStore barrier. */ AO_INLINE void AO_store_release(volatile AO_t *addr, AO_t value) { AO_lwsync(); *addr = value; } #define AO_HAVE_store_release #ifndef AO_PREFER_GENERALIZED /* This is similar to the code in the garbage collector. Deleting */ /* this and having it synthesized from compare_and_swap would probably */ /* only cost us a load immediate instruction. */ AO_INLINE AO_TS_VAL_t AO_test_and_set(volatile AO_TS_t *addr) { #if defined(__powerpc64__) || defined(__ppc64__) || defined(__64BIT__) /* Completely untested. And we should be using smaller objects anyway. */ unsigned long oldval; unsigned long temp = 1; /* locked value */ __asm__ __volatile__( "1:ldarx %0,0,%1\n" /* load and reserve */ "cmpdi %0, 0\n" /* if load is */ "bne 2f\n" /* non-zero, return already set */ "stdcx. %2,0,%1\n" /* else store conditional */ "bne- 1b\n" /* retry if lost reservation */ "2:\n" /* oldval is zero if we set */ : "=&r"(oldval) : "r"(addr), "r"(temp) : "memory", "cr0"); #else int oldval; int temp = 1; /* locked value */ __asm__ __volatile__( "1:lwarx %0,0,%1\n" /* load and reserve */ "cmpwi %0, 0\n" /* if load is */ "bne 2f\n" /* non-zero, return already set */ "stwcx. %2,0,%1\n" /* else store conditional */ "bne- 1b\n" /* retry if lost reservation */ "2:\n" /* oldval is zero if we set */ : "=&r"(oldval) : "r"(addr), "r"(temp) : "memory", "cr0"); #endif return (AO_TS_VAL_t)oldval; } #define AO_HAVE_test_and_set AO_INLINE AO_TS_VAL_t AO_test_and_set_acquire(volatile AO_TS_t *addr) { AO_TS_VAL_t result = AO_test_and_set(addr); AO_lwsync(); return result; } #define AO_HAVE_test_and_set_acquire AO_INLINE AO_TS_VAL_t AO_test_and_set_release(volatile AO_TS_t *addr) { AO_lwsync(); return AO_test_and_set(addr); } #define AO_HAVE_test_and_set_release AO_INLINE AO_TS_VAL_t AO_test_and_set_full(volatile AO_TS_t *addr) { AO_TS_VAL_t result; AO_lwsync(); result = AO_test_and_set(addr); AO_lwsync(); return result; } #define AO_HAVE_test_and_set_full #endif /* !AO_PREFER_GENERALIZED */ #ifndef AO_GENERALIZE_ASM_BOOL_CAS AO_INLINE int AO_compare_and_swap(volatile AO_t *addr, AO_t old, AO_t new_val) { AO_t oldval; int result = 0; # if defined(__powerpc64__) || defined(__ppc64__) || defined(__64BIT__) __asm__ __volatile__( "1:ldarx %0,0,%2\n" /* load and reserve */ "cmpd %0, %4\n" /* if load is not equal to */ "bne 2f\n" /* old, fail */ "stdcx. %3,0,%2\n" /* else store conditional */ "bne- 1b\n" /* retry if lost reservation */ "li %1,1\n" /* result = 1; */ "2:\n" : "=&r"(oldval), "=&r"(result) : "r"(addr), "r"(new_val), "r"(old), "1"(result) : "memory", "cr0"); # else __asm__ __volatile__( "1:lwarx %0,0,%2\n" /* load and reserve */ "cmpw %0, %4\n" /* if load is not equal to */ "bne 2f\n" /* old, fail */ "stwcx. %3,0,%2\n" /* else store conditional */ "bne- 1b\n" /* retry if lost reservation */ "li %1,1\n" /* result = 1; */ "2:\n" : "=&r"(oldval), "=&r"(result) : "r"(addr), "r"(new_val), "r"(old), "1"(result) : "memory", "cr0"); # endif return result; } # define AO_HAVE_compare_and_swap AO_INLINE int AO_compare_and_swap_acquire(volatile AO_t *addr, AO_t old, AO_t new_val) { int result = AO_compare_and_swap(addr, old, new_val); AO_lwsync(); return result; } # define AO_HAVE_compare_and_swap_acquire AO_INLINE int AO_compare_and_swap_release(volatile AO_t *addr, AO_t old, AO_t new_val) { AO_lwsync(); return AO_compare_and_swap(addr, old, new_val); } # define AO_HAVE_compare_and_swap_release AO_INLINE int AO_compare_and_swap_full(volatile AO_t *addr, AO_t old, AO_t new_val) { int result; AO_lwsync(); result = AO_compare_and_swap(addr, old, new_val); AO_lwsync(); return result; } # define AO_HAVE_compare_and_swap_full #endif /* !AO_GENERALIZE_ASM_BOOL_CAS */ AO_INLINE AO_t AO_fetch_compare_and_swap(volatile AO_t *addr, AO_t old_val, AO_t new_val) { AO_t fetched_val; # if defined(__powerpc64__) || defined(__ppc64__) || defined(__64BIT__) __asm__ __volatile__( "1:ldarx %0,0,%1\n" /* load and reserve */ "cmpd %0, %3\n" /* if load is not equal to */ "bne 2f\n" /* old_val, fail */ "stdcx. %2,0,%1\n" /* else store conditional */ "bne- 1b\n" /* retry if lost reservation */ "2:\n" : "=&r"(fetched_val) : "r"(addr), "r"(new_val), "r"(old_val) : "memory", "cr0"); # else __asm__ __volatile__( "1:lwarx %0,0,%1\n" /* load and reserve */ "cmpw %0, %3\n" /* if load is not equal to */ "bne 2f\n" /* old_val, fail */ "stwcx. %2,0,%1\n" /* else store conditional */ "bne- 1b\n" /* retry if lost reservation */ "2:\n" : "=&r"(fetched_val) : "r"(addr), "r"(new_val), "r"(old_val) : "memory", "cr0"); # endif return fetched_val; } #define AO_HAVE_fetch_compare_and_swap AO_INLINE AO_t AO_fetch_compare_and_swap_acquire(volatile AO_t *addr, AO_t old_val, AO_t new_val) { AO_t result = AO_fetch_compare_and_swap(addr, old_val, new_val); AO_lwsync(); return result; } #define AO_HAVE_fetch_compare_and_swap_acquire AO_INLINE AO_t AO_fetch_compare_and_swap_release(volatile AO_t *addr, AO_t old_val, AO_t new_val) { AO_lwsync(); return AO_fetch_compare_and_swap(addr, old_val, new_val); } #define AO_HAVE_fetch_compare_and_swap_release AO_INLINE AO_t AO_fetch_compare_and_swap_full(volatile AO_t *addr, AO_t old_val, AO_t new_val) { AO_t result; AO_lwsync(); result = AO_fetch_compare_and_swap(addr, old_val, new_val); AO_lwsync(); return result; } #define AO_HAVE_fetch_compare_and_swap_full #ifndef AO_PREFER_GENERALIZED AO_INLINE AO_t AO_fetch_and_add(volatile AO_t *addr, AO_t incr) { AO_t oldval; AO_t newval; #if defined(__powerpc64__) || defined(__ppc64__) || defined(__64BIT__) __asm__ __volatile__( "1:ldarx %0,0,%2\n" /* load and reserve */ "add %1,%0,%3\n" /* increment */ "stdcx. %1,0,%2\n" /* store conditional */ "bne- 1b\n" /* retry if lost reservation */ : "=&r"(oldval), "=&r"(newval) : "r"(addr), "r"(incr) : "memory", "cr0"); #else __asm__ __volatile__( "1:lwarx %0,0,%2\n" /* load and reserve */ "add %1,%0,%3\n" /* increment */ "stwcx. %1,0,%2\n" /* store conditional */ "bne- 1b\n" /* retry if lost reservation */ : "=&r"(oldval), "=&r"(newval) : "r"(addr), "r"(incr) : "memory", "cr0"); #endif return oldval; } #define AO_HAVE_fetch_and_add AO_INLINE AO_t AO_fetch_and_add_acquire(volatile AO_t *addr, AO_t incr) { AO_t result = AO_fetch_and_add(addr, incr); AO_lwsync(); return result; } #define AO_HAVE_fetch_and_add_acquire AO_INLINE AO_t AO_fetch_and_add_release(volatile AO_t *addr, AO_t incr) { AO_lwsync(); return AO_fetch_and_add(addr, incr); } #define AO_HAVE_fetch_and_add_release AO_INLINE AO_t AO_fetch_and_add_full(volatile AO_t *addr, AO_t incr) { AO_t result; AO_lwsync(); result = AO_fetch_and_add(addr, incr); AO_lwsync(); return result; } #define AO_HAVE_fetch_and_add_full #endif /* !AO_PREFER_GENERALIZED */ #if defined(__powerpc64__) || defined(__ppc64__) || defined(__64BIT__) /* Empty */ #else # define AO_T_IS_INT #endif /* TODO: Implement double-wide operations if available. */ ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/gcc/s390.h000066400000000000000000000050301266352375300251000ustar00rootroot00000000000000/* * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. * Copyright (c) 1999-2003 by Hewlett-Packard Company. All rights reserved. * * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. * */ /* FIXME: untested. */ /* The relevant documentation appears to be at */ /* http://publibz.boulder.ibm.com/epubs/pdf/dz9zr003.pdf */ /* around page 5-96. Apparently: */ /* - Memory references in general are atomic only for a single */ /* byte. But it appears that the most common load/store */ /* instructions also guarantee atomicity for aligned */ /* operands of standard types. WE FOOLISHLY ASSUME that */ /* compilers only generate those. If that turns out to be */ /* wrong, we need inline assembly code for AO_load and */ /* AO_store. */ /* - A store followed by a load is unordered since the store */ /* may be delayed. Otherwise everything is ordered. */ /* - There is a hardware compare-and-swap (CS) instruction. */ #include "../all_aligned_atomic_load_store.h" #include "../ordered_except_wr.h" #include "../test_and_set_t_is_ao_t.h" /* FIXME: Is there a way to do byte-sized test-and-set? */ /* TODO: AO_nop_full should probably be implemented directly. */ /* It appears that certain BCR instructions have that effect. */ /* Presumably they're cheaper than CS? */ AO_INLINE int AO_compare_and_swap_full(volatile AO_t *addr, AO_t old, AO_t new_val) { int retval; __asm__ __volatile__ ( # ifndef __s390x__ " cs %1,%2,0(%3)\n" # else " csg %1,%2,0(%3)\n" # endif " ipm %0\n" " srl %0,28\n" : "=&d" (retval), "+d" (old) : "d" (new_val), "a" (addr) : "cc", "memory"); return retval == 0; } #define AO_HAVE_compare_and_swap_full /* TODO: implement AO_fetch_compare_and_swap. */ /* TODO: Add double-wide operations for 32-bit executables. */ ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/gcc/sh.h000066400000000000000000000017451266352375300250250ustar00rootroot00000000000000/* * Copyright (c) 2009 by Takashi YOSHII. All rights reserved. * * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. */ #include "../all_atomic_load_store.h" #include "../ordered.h" /* sh has tas.b(byte) only */ #include "../test_and_set_t_is_char.h" AO_INLINE AO_TS_VAL_t AO_test_and_set_full(volatile AO_TS_t *addr) { int oldval; __asm__ __volatile__( "tas.b @%1; movt %0" : "=r" (oldval) : "r" (addr) : "t", "memory"); return oldval? AO_TS_CLEAR : AO_TS_SET; } #define AO_HAVE_test_and_set_full /* TODO: Very incomplete. */ ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/gcc/sparc.h000066400000000000000000000050451266352375300255200ustar00rootroot00000000000000/* * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. * Copyright (c) 1999-2003 by Hewlett-Packard Company. All rights reserved. * * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. * */ /* TODO: Very incomplete; Add support for sparc64. */ /* Non-ancient SPARCs provide compare-and-swap (casa). */ #include "../all_atomic_load_store.h" /* Real SPARC code uses TSO: */ #include "../ordered_except_wr.h" /* Test_and_set location is just a byte. */ #include "../test_and_set_t_is_char.h" AO_INLINE AO_TS_VAL_t AO_test_and_set_full(volatile AO_TS_t *addr) { AO_TS_VAL_t oldval; __asm__ __volatile__("ldstub %1,%0" : "=r"(oldval), "=m"(*addr) : "m"(*addr) : "memory"); return oldval; } #define AO_HAVE_test_and_set_full #ifndef AO_NO_SPARC_V9 /* Returns nonzero if the comparison succeeded. */ AO_INLINE int AO_compare_and_swap_full(volatile AO_t *addr, AO_t old, AO_t new_val) { char ret; __asm__ __volatile__ ("membar #StoreLoad | #LoadLoad\n\t" # if defined(__arch64__) "casx [%2],%0,%1\n\t" # else "cas [%2],%0,%1\n\t" /* 32-bit version */ # endif "membar #StoreLoad | #StoreStore\n\t" "cmp %0,%1\n\t" "be,a 0f\n\t" "mov 1,%0\n\t"/* one insn after branch always executed */ "clr %0\n\t" "0:\n\t" : "=r" (ret), "+r" (new_val) : "r" (addr), "0" (old) : "memory", "cc"); return (int)ret; } #define AO_HAVE_compare_and_swap_full /* TODO: implement AO_fetch_compare_and_swap. */ #endif /* !AO_NO_SPARC_V9 */ /* TODO: Extend this for SPARC v8 and v9 (V8 also has swap, V9 has CAS, */ /* there are barriers like membar #LoadStore, CASA (32-bit) and */ /* CASXA (64-bit) instructions added in V9). */ ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/gcc/x86.h000066400000000000000000000354451266352375300250440ustar00rootroot00000000000000/* * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. * Copyright (c) 1999-2003 by Hewlett-Packard Company. All rights reserved. * * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. * * Some of the machine specific code was borrowed from our GC distribution. */ /* The following really assume we have a 486 or better. Unfortunately */ /* gcc doesn't define a suitable feature test macro based on command */ /* line options. */ /* We should perhaps test dynamically. */ #include "../all_aligned_atomic_load_store.h" #include "../test_and_set_t_is_char.h" #if defined(__SSE2__) && !defined(AO_USE_PENTIUM4_INSTRS) /* "mfence" is a part of SSE2 set (introduced on Intel Pentium 4). */ # define AO_USE_PENTIUM4_INSTRS #endif #if defined(AO_USE_PENTIUM4_INSTRS) AO_INLINE void AO_nop_full(void) { __asm__ __volatile__("mfence" : : : "memory"); } # define AO_HAVE_nop_full #else /* We could use the cpuid instruction. But that seems to be slower */ /* than the default implementation based on test_and_set_full. Thus */ /* we omit that bit of misinformation here. */ #endif /* !AO_USE_PENTIUM4_INSTRS */ /* As far as we can tell, the lfence and sfence instructions are not */ /* currently needed or useful for cached memory accesses. */ /* Really only works for 486 and later */ #ifndef AO_PREFER_GENERALIZED AO_INLINE AO_t AO_fetch_and_add_full (volatile AO_t *p, AO_t incr) { AO_t result; __asm__ __volatile__ ("lock; xadd %0, %1" : "=r" (result), "=m" (*p) : "0" (incr), "m" (*p) : "memory"); return result; } # define AO_HAVE_fetch_and_add_full #endif /* !AO_PREFER_GENERALIZED */ AO_INLINE unsigned char AO_char_fetch_and_add_full (volatile unsigned char *p, unsigned char incr) { unsigned char result; __asm__ __volatile__ ("lock; xaddb %0, %1" : "=q" (result), "=m" (*p) : "0" (incr), "m" (*p) : "memory"); return result; } #define AO_HAVE_char_fetch_and_add_full AO_INLINE unsigned short AO_short_fetch_and_add_full (volatile unsigned short *p, unsigned short incr) { unsigned short result; __asm__ __volatile__ ("lock; xaddw %0, %1" : "=r" (result), "=m" (*p) : "0" (incr), "m" (*p) : "memory"); return result; } #define AO_HAVE_short_fetch_and_add_full #ifndef AO_PREFER_GENERALIZED /* Really only works for 486 and later */ AO_INLINE void AO_and_full (volatile AO_t *p, AO_t value) { __asm__ __volatile__ ("lock; and %1, %0" : "=m" (*p) : "r" (value), "m" (*p) : "memory"); } # define AO_HAVE_and_full AO_INLINE void AO_or_full (volatile AO_t *p, AO_t value) { __asm__ __volatile__ ("lock; or %1, %0" : "=m" (*p) : "r" (value), "m" (*p) : "memory"); } # define AO_HAVE_or_full AO_INLINE void AO_xor_full (volatile AO_t *p, AO_t value) { __asm__ __volatile__ ("lock; xor %1, %0" : "=m" (*p) : "r" (value), "m" (*p) : "memory"); } # define AO_HAVE_xor_full /* AO_store_full could be implemented directly using "xchg" but it */ /* could be generalized efficiently as an ordinary store accomplished */ /* with AO_nop_full ("mfence" instruction). */ #endif /* !AO_PREFER_GENERALIZED */ AO_INLINE AO_TS_VAL_t AO_test_and_set_full(volatile AO_TS_t *addr) { unsigned char oldval; /* Note: the "xchg" instruction does not need a "lock" prefix */ __asm__ __volatile__ ("xchgb %0, %1" : "=q" (oldval), "=m" (*addr) : "0" ((unsigned char)0xff), "m" (*addr) : "memory"); return (AO_TS_VAL_t)oldval; } #define AO_HAVE_test_and_set_full #ifndef AO_GENERALIZE_ASM_BOOL_CAS /* Returns nonzero if the comparison succeeded. */ AO_INLINE int AO_compare_and_swap_full(volatile AO_t *addr, AO_t old, AO_t new_val) { # ifdef AO_USE_SYNC_CAS_BUILTIN return (int)__sync_bool_compare_and_swap(addr, old, new_val /* empty protection list */); /* Note: an empty list of variables protected by the */ /* memory barrier should mean all globally accessible */ /* variables are protected. */ # else char result; __asm__ __volatile__ ("lock; cmpxchg %3, %0; setz %1" : "=m" (*addr), "=a" (result) : "m" (*addr), "r" (new_val), "a" (old) : "memory"); return (int)result; # endif } # define AO_HAVE_compare_and_swap_full #endif /* !AO_GENERALIZE_ASM_BOOL_CAS */ AO_INLINE AO_t AO_fetch_compare_and_swap_full(volatile AO_t *addr, AO_t old_val, AO_t new_val) { # ifdef AO_USE_SYNC_CAS_BUILTIN return __sync_val_compare_and_swap(addr, old_val, new_val /* empty protection list */); # else AO_t fetched_val; __asm__ __volatile__ ("lock; cmpxchg %3, %4" : "=a" (fetched_val), "=m" (*addr) : "a" (old_val), "r" (new_val), "m" (*addr) : "memory"); return fetched_val; # endif } #define AO_HAVE_fetch_compare_and_swap_full #if !defined(__x86_64__) && !defined(AO_USE_SYNC_CAS_BUILTIN) # include "../standard_ao_double_t.h" /* Reading or writing a quadword aligned on a 64-bit boundary is */ /* always carried out atomically on at least a Pentium according to */ /* Chapter 8.1.1 of Volume 3A Part 1 of Intel processor manuals. */ # define AO_ACCESS_double_CHECK_ALIGNED # include "../loadstore/double_atomic_load_store.h" /* Returns nonzero if the comparison succeeded. */ /* Really requires at least a Pentium. */ AO_INLINE int AO_compare_double_and_swap_double_full(volatile AO_double_t *addr, AO_t old_val1, AO_t old_val2, AO_t new_val1, AO_t new_val2) { char result; # ifdef __PIC__ AO_t saved_ebx; /* If PIC is turned on, we cannot use ebx as it is reserved for the */ /* GOT pointer. We should save and restore ebx. The proposed */ /* solution is not so efficient as the older alternatives using */ /* push ebx or edi as new_val1 (w/o clobbering edi and temporary */ /* local variable usage) but it is more portable (it works even if */ /* ebx is not used as GOT pointer, and it works for the buggy GCC */ /* releases that incorrectly evaluate memory operands offset in the */ /* inline assembly after push). */ # ifdef __OPTIMIZE__ __asm__ __volatile__("mov %%ebx, %2\n\t" /* save ebx */ "lea %0, %%edi\n\t" /* in case addr is in ebx */ "mov %7, %%ebx\n\t" /* load new_val1 */ "lock; cmpxchg8b (%%edi)\n\t" "mov %2, %%ebx\n\t" /* restore ebx */ "setz %1" : "=m" (*addr), "=a" (result), "=m" (saved_ebx) : "m" (*addr), "d" (old_val2), "a" (old_val1), "c" (new_val2), "m" (new_val1) : "%edi", "memory"); # else /* A less-efficient code manually preserving edi if GCC invoked */ /* with -O0 option (otherwise it fails while finding a register */ /* in class 'GENERAL_REGS'). */ AO_t saved_edi; __asm__ __volatile__("mov %%edi, %3\n\t" /* save edi */ "mov %%ebx, %2\n\t" /* save ebx */ "lea %0, %%edi\n\t" /* in case addr is in ebx */ "mov %8, %%ebx\n\t" /* load new_val1 */ "lock; cmpxchg8b (%%edi)\n\t" "mov %2, %%ebx\n\t" /* restore ebx */ "mov %3, %%edi\n\t" /* restore edi */ "setz %1" : "=m" (*addr), "=a" (result), "=m" (saved_ebx), "=m" (saved_edi) : "m" (*addr), "d" (old_val2), "a" (old_val1), "c" (new_val2), "m" (new_val1) : "memory"); # endif # else /* For non-PIC mode, this operation could be simplified (and be */ /* faster) by using ebx as new_val1 (GCC would refuse to compile */ /* such code for PIC mode). */ __asm__ __volatile__ ("lock; cmpxchg8b %0; setz %1" : "=m" (*addr), "=a" (result) : "m" (*addr), "d" (old_val2), "a" (old_val1), "c" (new_val2), "b" (new_val1) : "memory"); # endif return (int) result; } # define AO_HAVE_compare_double_and_swap_double_full # define AO_T_IS_INT #elif defined(__ILP32__) || !defined(__x86_64__) # include "../standard_ao_double_t.h" /* Reading or writing a quadword aligned on a 64-bit boundary is */ /* always carried out atomically (requires at least a Pentium). */ # define AO_ACCESS_double_CHECK_ALIGNED # include "../loadstore/double_atomic_load_store.h" /* X32 has native support for 64-bit integer operations (AO_double_t */ /* is a 64-bit integer and we could use 64-bit cmpxchg). */ /* This primitive is used by compare_double_and_swap_double_full. */ AO_INLINE int AO_double_compare_and_swap_full(volatile AO_double_t *addr, AO_double_t old_val, AO_double_t new_val) { /* It is safe to use __sync CAS built-in here. */ return __sync_bool_compare_and_swap(&addr->AO_whole, old_val.AO_whole, new_val.AO_whole /* empty protection list */); } # define AO_HAVE_double_compare_and_swap_full # define AO_T_IS_INT #else /* 64-bit */ AO_INLINE unsigned int AO_int_fetch_and_add_full (volatile unsigned int *p, unsigned int incr) { unsigned int result; __asm__ __volatile__ ("lock; xaddl %0, %1" : "=r" (result), "=m" (*p) : "0" (incr), "m" (*p) : "memory"); return result; } # define AO_HAVE_int_fetch_and_add_full /* The Intel and AMD Architecture Programmer Manuals state roughly */ /* the following: */ /* - CMPXCHG16B (with a LOCK prefix) can be used to perform 16-byte */ /* atomic accesses in 64-bit mode (with certain alignment */ /* restrictions); */ /* - SSE instructions that access data larger than a quadword (like */ /* MOVDQA) may be implemented using multiple memory accesses; */ /* - LOCK prefix causes an invalid-opcode exception when used with */ /* 128-bit media (SSE) instructions. */ /* Thus, currently, the only way to implement lock-free double_load */ /* and double_store on x86_64 is to use CMPXCHG16B (if available). */ /* TODO: Test some gcc macro to detect presence of cmpxchg16b. */ # ifdef AO_CMPXCHG16B_AVAILABLE # include "../standard_ao_double_t.h" /* NEC LE-IT: older AMD Opterons are missing this instruction. */ /* On these machines SIGILL will be thrown. */ /* Define AO_WEAK_DOUBLE_CAS_EMULATION to have an emulated (lock */ /* based) version available. */ /* HB: Changed this to not define either by default. There are */ /* enough machines and tool chains around on which cmpxchg16b */ /* doesn't work. And the emulation is unsafe by our usual rules. */ /* However both are clearly useful in certain cases. */ AO_INLINE int AO_compare_double_and_swap_double_full(volatile AO_double_t *addr, AO_t old_val1, AO_t old_val2, AO_t new_val1, AO_t new_val2) { char result; __asm__ __volatile__("lock; cmpxchg16b %0; setz %1" : "=m"(*addr), "=a"(result) : "m"(*addr), "d" (old_val2), "a" (old_val1), "c" (new_val2), "b" (new_val1) : "memory"); return (int) result; } # define AO_HAVE_compare_double_and_swap_double_full # elif defined(AO_WEAK_DOUBLE_CAS_EMULATION) # include "../standard_ao_double_t.h" /* This one provides spinlock based emulation of CAS implemented in */ /* atomic_ops.c. We probably do not want to do this here, since it */ /* is not atomic with respect to other kinds of updates of *addr. */ /* On the other hand, this may be a useful facility on occasion. */ int AO_compare_double_and_swap_double_emulation( volatile AO_double_t *addr, AO_t old_val1, AO_t old_val2, AO_t new_val1, AO_t new_val2); AO_INLINE int AO_compare_double_and_swap_double_full(volatile AO_double_t *addr, AO_t old_val1, AO_t old_val2, AO_t new_val1, AO_t new_val2) { return AO_compare_double_and_swap_double_emulation(addr, old_val1, old_val2, new_val1, new_val2); } # define AO_HAVE_compare_double_and_swap_double_full # endif /* AO_WEAK_DOUBLE_CAS_EMULATION && !AO_CMPXCHG16B_AVAILABLE */ #endif /* x86_64 && !ILP32 */ /* Real X86 implementations, except for some old 32-bit WinChips, */ /* appear to enforce ordering between memory operations, EXCEPT that */ /* a later read can pass earlier writes, presumably due to the visible */ /* presence of store buffers. */ /* We ignore both the WinChips and the fact that the official specs */ /* seem to be much weaker (and arguably too weak to be usable). */ #include "../ordered_except_wr.h" ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/generic_pthread.h000066400000000000000000000257631266352375300270100ustar00rootroot00000000000000/* * Copyright (c) 2003 by Hewlett-Packard Company. All rights reserved. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ /* The following is useful primarily for debugging and documentation. */ /* We define various atomic operations by acquiring a global pthread */ /* lock. The resulting implementation will perform poorly, but should */ /* be correct unless it is used from signal handlers. */ /* We assume that all pthread operations act like full memory barriers. */ /* (We believe that is the intent of the specification.) */ #include #include "test_and_set_t_is_ao_t.h" /* This is not necessarily compatible with the native */ /* implementation. But those can't be safely mixed anyway. */ /* We define only the full barrier variants, and count on the */ /* generalization section below to fill in the rest. */ extern pthread_mutex_t AO_pt_lock; AO_INLINE void AO_nop_full(void) { pthread_mutex_lock(&AO_pt_lock); pthread_mutex_unlock(&AO_pt_lock); } #define AO_HAVE_nop_full AO_INLINE AO_t AO_load_full(const volatile AO_t *addr) { AO_t result; pthread_mutex_lock(&AO_pt_lock); result = *addr; pthread_mutex_unlock(&AO_pt_lock); return result; } #define AO_HAVE_load_full AO_INLINE void AO_store_full(volatile AO_t *addr, AO_t val) { pthread_mutex_lock(&AO_pt_lock); *addr = val; pthread_mutex_unlock(&AO_pt_lock); } #define AO_HAVE_store_full AO_INLINE unsigned char AO_char_load_full(const volatile unsigned char *addr) { unsigned char result; pthread_mutex_lock(&AO_pt_lock); result = *addr; pthread_mutex_unlock(&AO_pt_lock); return result; } #define AO_HAVE_char_load_full AO_INLINE void AO_char_store_full(volatile unsigned char *addr, unsigned char val) { pthread_mutex_lock(&AO_pt_lock); *addr = val; pthread_mutex_unlock(&AO_pt_lock); } #define AO_HAVE_char_store_full AO_INLINE unsigned short AO_short_load_full(const volatile unsigned short *addr) { unsigned short result; pthread_mutex_lock(&AO_pt_lock); result = *addr; pthread_mutex_unlock(&AO_pt_lock); return result; } #define AO_HAVE_short_load_full AO_INLINE void AO_short_store_full(volatile unsigned short *addr, unsigned short val) { pthread_mutex_lock(&AO_pt_lock); *addr = val; pthread_mutex_unlock(&AO_pt_lock); } #define AO_HAVE_short_store_full AO_INLINE unsigned int AO_int_load_full(const volatile unsigned int *addr) { unsigned int result; pthread_mutex_lock(&AO_pt_lock); result = *addr; pthread_mutex_unlock(&AO_pt_lock); return result; } #define AO_HAVE_int_load_full AO_INLINE void AO_int_store_full(volatile unsigned int *addr, unsigned int val) { pthread_mutex_lock(&AO_pt_lock); *addr = val; pthread_mutex_unlock(&AO_pt_lock); } #define AO_HAVE_int_store_full AO_INLINE AO_TS_VAL_t AO_test_and_set_full(volatile AO_TS_t *addr) { AO_TS_VAL_t result; pthread_mutex_lock(&AO_pt_lock); result = (AO_TS_VAL_t)(*addr); *addr = AO_TS_SET; pthread_mutex_unlock(&AO_pt_lock); assert(result == AO_TS_SET || result == AO_TS_CLEAR); return result; } #define AO_HAVE_test_and_set_full AO_INLINE AO_t AO_fetch_and_add_full(volatile AO_t *p, AO_t incr) { AO_t old_val; pthread_mutex_lock(&AO_pt_lock); old_val = *p; *p = old_val + incr; pthread_mutex_unlock(&AO_pt_lock); return old_val; } #define AO_HAVE_fetch_and_add_full AO_INLINE unsigned char AO_char_fetch_and_add_full(volatile unsigned char *p, unsigned char incr) { unsigned char old_val; pthread_mutex_lock(&AO_pt_lock); old_val = *p; *p = old_val + incr; pthread_mutex_unlock(&AO_pt_lock); return old_val; } #define AO_HAVE_char_fetch_and_add_full AO_INLINE unsigned short AO_short_fetch_and_add_full(volatile unsigned short *p, unsigned short incr) { unsigned short old_val; pthread_mutex_lock(&AO_pt_lock); old_val = *p; *p = old_val + incr; pthread_mutex_unlock(&AO_pt_lock); return old_val; } #define AO_HAVE_short_fetch_and_add_full AO_INLINE unsigned int AO_int_fetch_and_add_full(volatile unsigned int *p, unsigned int incr) { unsigned int old_val; pthread_mutex_lock(&AO_pt_lock); old_val = *p; *p = old_val + incr; pthread_mutex_unlock(&AO_pt_lock); return old_val; } #define AO_HAVE_int_fetch_and_add_full AO_INLINE void AO_and_full(volatile AO_t *p, AO_t value) { pthread_mutex_lock(&AO_pt_lock); *p &= value; pthread_mutex_unlock(&AO_pt_lock); } #define AO_HAVE_and_full AO_INLINE void AO_or_full(volatile AO_t *p, AO_t value) { pthread_mutex_lock(&AO_pt_lock); *p |= value; pthread_mutex_unlock(&AO_pt_lock); } #define AO_HAVE_or_full AO_INLINE void AO_xor_full(volatile AO_t *p, AO_t value) { pthread_mutex_lock(&AO_pt_lock); *p ^= value; pthread_mutex_unlock(&AO_pt_lock); } #define AO_HAVE_xor_full AO_INLINE void AO_char_and_full(volatile unsigned char *p, unsigned char value) { pthread_mutex_lock(&AO_pt_lock); *p &= value; pthread_mutex_unlock(&AO_pt_lock); } #define AO_HAVE_char_and_full AO_INLINE void AO_char_or_full(volatile unsigned char *p, unsigned char value) { pthread_mutex_lock(&AO_pt_lock); *p |= value; pthread_mutex_unlock(&AO_pt_lock); } #define AO_HAVE_char_or_full AO_INLINE void AO_char_xor_full(volatile unsigned char *p, unsigned char value) { pthread_mutex_lock(&AO_pt_lock); *p ^= value; pthread_mutex_unlock(&AO_pt_lock); } #define AO_HAVE_char_xor_full AO_INLINE void AO_short_and_full(volatile unsigned short *p, unsigned short value) { pthread_mutex_lock(&AO_pt_lock); *p &= value; pthread_mutex_unlock(&AO_pt_lock); } #define AO_HAVE_short_and_full AO_INLINE void AO_short_or_full(volatile unsigned short *p, unsigned short value) { pthread_mutex_lock(&AO_pt_lock); *p |= value; pthread_mutex_unlock(&AO_pt_lock); } #define AO_HAVE_short_or_full AO_INLINE void AO_short_xor_full(volatile unsigned short *p, unsigned short value) { pthread_mutex_lock(&AO_pt_lock); *p ^= value; pthread_mutex_unlock(&AO_pt_lock); } #define AO_HAVE_short_xor_full AO_INLINE void AO_int_and_full(volatile unsigned *p, unsigned value) { pthread_mutex_lock(&AO_pt_lock); *p &= value; pthread_mutex_unlock(&AO_pt_lock); } #define AO_HAVE_int_and_full AO_INLINE void AO_int_or_full(volatile unsigned *p, unsigned value) { pthread_mutex_lock(&AO_pt_lock); *p |= value; pthread_mutex_unlock(&AO_pt_lock); } #define AO_HAVE_int_or_full AO_INLINE void AO_int_xor_full(volatile unsigned *p, unsigned value) { pthread_mutex_lock(&AO_pt_lock); *p ^= value; pthread_mutex_unlock(&AO_pt_lock); } #define AO_HAVE_int_xor_full AO_INLINE AO_t AO_fetch_compare_and_swap_full(volatile AO_t *addr, AO_t old_val, AO_t new_val) { AO_t fetched_val; pthread_mutex_lock(&AO_pt_lock); fetched_val = *addr; if (fetched_val == old_val) *addr = new_val; pthread_mutex_unlock(&AO_pt_lock); return fetched_val; } #define AO_HAVE_fetch_compare_and_swap_full AO_INLINE unsigned char AO_char_fetch_compare_and_swap_full(volatile unsigned char *addr, unsigned char old_val, unsigned char new_val) { unsigned char fetched_val; pthread_mutex_lock(&AO_pt_lock); fetched_val = *addr; if (fetched_val == old_val) *addr = new_val; pthread_mutex_unlock(&AO_pt_lock); return fetched_val; } #define AO_HAVE_char_fetch_compare_and_swap_full AO_INLINE unsigned short AO_short_fetch_compare_and_swap_full(volatile unsigned short *addr, unsigned short old_val, unsigned short new_val) { unsigned short fetched_val; pthread_mutex_lock(&AO_pt_lock); fetched_val = *addr; if (fetched_val == old_val) *addr = new_val; pthread_mutex_unlock(&AO_pt_lock); return fetched_val; } #define AO_HAVE_short_fetch_compare_and_swap_full AO_INLINE unsigned AO_int_fetch_compare_and_swap_full(volatile unsigned *addr, unsigned old_val, unsigned new_val) { unsigned fetched_val; pthread_mutex_lock(&AO_pt_lock); fetched_val = *addr; if (fetched_val == old_val) *addr = new_val; pthread_mutex_unlock(&AO_pt_lock); return fetched_val; } #define AO_HAVE_int_fetch_compare_and_swap_full /* Unlike real architectures, we define both double-width CAS variants. */ typedef struct { AO_t AO_val1; AO_t AO_val2; } AO_double_t; #define AO_HAVE_double_t #define AO_DOUBLE_T_INITIALIZER { (AO_t)0, (AO_t)0 } AO_INLINE AO_double_t AO_double_load_full(const volatile AO_double_t *addr) { AO_double_t result; pthread_mutex_lock(&AO_pt_lock); result.AO_val1 = addr->AO_val1; result.AO_val2 = addr->AO_val2; pthread_mutex_unlock(&AO_pt_lock); return result; } #define AO_HAVE_double_load_full AO_INLINE void AO_double_store_full(volatile AO_double_t *addr, AO_double_t value) { pthread_mutex_lock(&AO_pt_lock); addr->AO_val1 = value.AO_val1; addr->AO_val2 = value.AO_val2; pthread_mutex_unlock(&AO_pt_lock); } #define AO_HAVE_double_store_full AO_INLINE int AO_compare_double_and_swap_double_full(volatile AO_double_t *addr, AO_t old1, AO_t old2, AO_t new1, AO_t new2) { pthread_mutex_lock(&AO_pt_lock); if (addr -> AO_val1 == old1 && addr -> AO_val2 == old2) { addr -> AO_val1 = new1; addr -> AO_val2 = new2; pthread_mutex_unlock(&AO_pt_lock); return 1; } else pthread_mutex_unlock(&AO_pt_lock); return 0; } #define AO_HAVE_compare_double_and_swap_double_full AO_INLINE int AO_compare_and_swap_double_full(volatile AO_double_t *addr, AO_t old1, AO_t new1, AO_t new2) { pthread_mutex_lock(&AO_pt_lock); if (addr -> AO_val1 == old1) { addr -> AO_val1 = new1; addr -> AO_val2 = new2; pthread_mutex_unlock(&AO_pt_lock); return 1; } else pthread_mutex_unlock(&AO_pt_lock); return 0; } #define AO_HAVE_compare_and_swap_double_full /* We can't use hardware loads and stores, since they don't */ /* interact correctly with atomic updates. */ ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/hpc/000077500000000000000000000000001266352375300242515ustar00rootroot00000000000000ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/hpc/hppa.h000066400000000000000000000101371266352375300253540ustar00rootroot00000000000000/* * Copyright (c) 2003 Hewlett-Packard Development Company, L.P. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. * * Derived from the corresponding header file for gcc. */ #include "../loadstore/atomic_load.h" #include "../loadstore/atomic_store.h" /* Some architecture set descriptions include special "ordered" memory */ /* operations. As far as we can tell, no existing processors actually */ /* require those. Nor does it appear likely that future processors */ /* will. */ /* FIXME: The PA emulator on Itanium may obey weaker restrictions. */ /* There should be a mode in which we don't assume sequential */ /* consistency here. */ #include "../ordered.h" #include /* GCC will not guarantee the alignment we need, use four lock words */ /* and select the correctly aligned datum. See the glibc 2.3.2 */ /* linuxthread port for the original implementation. */ struct AO_pa_clearable_loc { int data[4]; }; #undef AO_TS_INITIALIZER #define AO_TS_t struct AO_pa_clearable_loc #define AO_TS_INITIALIZER {1,1,1,1} /* Switch meaning of set and clear, since we only have an atomic clear */ /* instruction. */ typedef enum {AO_PA_TS_set = 0, AO_PA_TS_clear = 1} AO_PA_TS_val; #define AO_TS_VAL_t AO_PA_TS_val #define AO_TS_CLEAR AO_PA_TS_clear #define AO_TS_SET AO_PA_TS_set /* The hppa only has one atomic read and modify memory operation, */ /* load and clear, so hppa spinlocks must use zero to signify that */ /* someone is holding the lock. The address used for the ldcw */ /* semaphore must be 16-byte aligned. */ #define AO_ldcw(a, ret) \ _LDCWX(0 /* index */, 0 /* s */, a /* base */, ret) /* Because malloc only guarantees 8-byte alignment for malloc'd data, */ /* and GCC only guarantees 8-byte alignment for stack locals, we can't */ /* be assured of 16-byte alignment for atomic lock data even if we */ /* specify "__attribute ((aligned(16)))" in the type declaration. So, */ /* we use a struct containing an array of four ints for the atomic lock */ /* type and dynamically select the 16-byte aligned int from the array */ /* for the semaphore. */ #define AO_PA_LDCW_ALIGNMENT 16 #define AO_ldcw_align(addr) \ ((volatile unsigned *)(((unsigned long)(addr) \ + (AO_PA_LDCW_ALIGNMENT - 1)) \ & ~(AO_PA_LDCW_ALIGNMENT - 1))) /* Works on PA 1.1 and PA 2.0 systems */ AO_INLINE AO_TS_VAL_t AO_test_and_set_full(volatile AO_TS_t * addr) { register unsigned int ret; register unsigned long a = (unsigned long)AO_ldcw_align(addr); AO_ldcw(a, ret); return (AO_TS_VAL_t)ret; } #define AO_HAVE_test_and_set_full AO_INLINE void AO_pa_clear(volatile AO_TS_t * addr) { volatile unsigned *a = AO_ldcw_align(addr); AO_compiler_barrier(); *a = 1; } #define AO_CLEAR(addr) AO_pa_clear(addr) ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/hpc/ia64.h000066400000000000000000000116271266352375300251740ustar00rootroot00000000000000/* * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ /* * This file specifies Itanimum primitives for use with the HP compiler * under HP/UX. We use intrinsics instead of the inline assembly code in the * gcc file. */ #include "../all_atomic_load_store.h" #include "../all_acquire_release_volatile.h" #include "../test_and_set_t_is_char.h" #include #ifdef __LP64__ # define AO_T_FASIZE _FASZ_D # define AO_T_SIZE _SZ_D #else # define AO_T_FASIZE _FASZ_W # define AO_T_SIZE _SZ_W #endif AO_INLINE void AO_nop_full(void) { _Asm_mf(); } #define AO_HAVE_nop_full #ifndef AO_PREFER_GENERALIZED AO_INLINE AO_t AO_fetch_and_add1_acquire (volatile AO_t *p) { return _Asm_fetchadd(AO_T_FASIZE, _SEM_ACQ, p, 1, _LDHINT_NONE, _DOWN_MEM_FENCE); } #define AO_HAVE_fetch_and_add1_acquire AO_INLINE AO_t AO_fetch_and_add1_release (volatile AO_t *p) { return _Asm_fetchadd(AO_T_FASIZE, _SEM_REL, p, 1, _LDHINT_NONE, _UP_MEM_FENCE); } #define AO_HAVE_fetch_and_add1_release AO_INLINE AO_t AO_fetch_and_sub1_acquire (volatile AO_t *p) { return _Asm_fetchadd(AO_T_FASIZE, _SEM_ACQ, p, -1, _LDHINT_NONE, _DOWN_MEM_FENCE); } #define AO_HAVE_fetch_and_sub1_acquire AO_INLINE AO_t AO_fetch_and_sub1_release (volatile AO_t *p) { return _Asm_fetchadd(AO_T_FASIZE, _SEM_REL, p, -1, _LDHINT_NONE, _UP_MEM_FENCE); } #define AO_HAVE_fetch_and_sub1_release #endif /* !AO_PREFER_GENERALIZED */ AO_INLINE AO_t AO_fetch_compare_and_swap_acquire(volatile AO_t *addr, AO_t old_val, AO_t new_val) { _Asm_mov_to_ar(_AREG_CCV, old_val, _DOWN_MEM_FENCE); return _Asm_cmpxchg(AO_T_SIZE, _SEM_ACQ, addr, new_val, _LDHINT_NONE, _DOWN_MEM_FENCE); } #define AO_HAVE_fetch_compare_and_swap_acquire AO_INLINE AO_t AO_fetch_compare_and_swap_release(volatile AO_t *addr, AO_t old_val, AO_t new_val) { _Asm_mov_to_ar(_AREG_CCV, old_val, _UP_MEM_FENCE); return _Asm_cmpxchg(AO_T_SIZE, _SEM_REL, addr, new_val, _LDHINT_NONE, _UP_MEM_FENCE); } #define AO_HAVE_fetch_compare_and_swap_release AO_INLINE unsigned char AO_char_fetch_compare_and_swap_acquire(volatile unsigned char *addr, unsigned char old_val, unsigned char new_val) { _Asm_mov_to_ar(_AREG_CCV, old_val, _DOWN_MEM_FENCE); return _Asm_cmpxchg(_SZ_B, _SEM_ACQ, addr, new_val, _LDHINT_NONE, _DOWN_MEM_FENCE); } #define AO_HAVE_char_fetch_compare_and_swap_acquire AO_INLINE unsigned char AO_char_fetch_compare_and_swap_release(volatile unsigned char *addr, unsigned char old_val, unsigned char new_val) { _Asm_mov_to_ar(_AREG_CCV, old_val, _UP_MEM_FENCE); return _Asm_cmpxchg(_SZ_B, _SEM_REL, addr, new_val, _LDHINT_NONE, _UP_MEM_FENCE); } #define AO_HAVE_char_fetch_compare_and_swap_release AO_INLINE unsigned short AO_short_fetch_compare_and_swap_acquire(volatile unsigned short *addr, unsigned short old_val, unsigned short new_val) { _Asm_mov_to_ar(_AREG_CCV, old_val, _DOWN_MEM_FENCE); return _Asm_cmpxchg(_SZ_B, _SEM_ACQ, addr, new_val, _LDHINT_NONE, _DOWN_MEM_FENCE); } #define AO_HAVE_short_fetch_compare_and_swap_acquire AO_INLINE unsigned short AO_short_fetch_compare_and_swap_release(volatile unsigned short *addr, unsigned short old_val, unsigned short new_val) { _Asm_mov_to_ar(_AREG_CCV, old_val, _UP_MEM_FENCE); return _Asm_cmpxchg(_SZ_B, _SEM_REL, addr, new_val, _LDHINT_NONE, _UP_MEM_FENCE); } #define AO_HAVE_short_fetch_compare_and_swap_release #ifndef __LP64__ # define AO_T_IS_INT #endif ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/ibmc/000077500000000000000000000000001266352375300244115ustar00rootroot00000000000000ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/ibmc/powerpc.h000066400000000000000000000075701266352375300262520ustar00rootroot00000000000000/* FIXME. This is only a placeholder for the AIX compiler. */ /* It doesn't work. Please send a patch. */ /* Memory model documented at http://www-106.ibm.com/developerworks/ */ /* eserver/articles/archguide.html and (clearer) */ /* http://www-106.ibm.com/developerworks/eserver/articles/powerpc.html. */ /* There appears to be no implicit ordering between any kind of */ /* independent memory references. */ /* Architecture enforces some ordering based on control dependence. */ /* I don't know if that could help. */ /* Data-dependent loads are always ordered. */ /* Based on the above references, eieio is intended for use on */ /* uncached memory, which we don't support. It does not order loads */ /* from cached memory. */ /* Thanks to Maged Michael, Doug Lea, and Roger Hoover for helping to */ /* track some of this down and correcting my misunderstandings. -HB */ #include "../all_aligned_atomic_load_store.h" void AO_sync(void); #pragma mc_func AO_sync { "7c0004ac" } #ifdef __NO_LWSYNC__ # define AO_lwsync AO_sync #else void AO_lwsync(void); #pragma mc_func AO_lwsync { "7c2004ac" } #endif #define AO_nop_write() AO_lwsync() #define AO_HAVE_nop_write #define AO_nop_read() AO_lwsync() #define AO_HAVE_nop_read /* We explicitly specify load_acquire and store_release, since these */ /* rely on the fact that lwsync is also a LoadStore barrier. */ AO_INLINE AO_t AO_load_acquire(const volatile AO_t *addr) { AO_t result = *addr; AO_lwsync(); return result; } #define AO_HAVE_load_acquire AO_INLINE void AO_store_release(volatile AO_t *addr, AO_t value) { AO_lwsync(); *addr = value; } #define AO_HAVE_store_release #ifndef AO_PREFER_GENERALIZED /* This is similar to the code in the garbage collector. Deleting */ /* this and having it synthesized from compare_and_swap would probably */ /* only cost us a load immediate instruction. */ /*AO_INLINE AO_TS_VAL_t AO_test_and_set(volatile AO_TS_t *addr) { # error FIXME Implement me } #define AO_HAVE_test_and_set*/ AO_INLINE AO_TS_VAL_t AO_test_and_set_acquire(volatile AO_TS_t *addr) { AO_TS_VAL_t result = AO_test_and_set(addr); AO_lwsync(); return result; } #define AO_HAVE_test_and_set_acquire AO_INLINE AO_TS_VAL_t AO_test_and_set_release(volatile AO_TS_t *addr) { AO_lwsync(); return AO_test_and_set(addr); } #define AO_HAVE_test_and_set_release AO_INLINE AO_TS_VAL_t AO_test_and_set_full(volatile AO_TS_t *addr) { AO_TS_VAL_t result; AO_lwsync(); result = AO_test_and_set(addr); AO_lwsync(); return result; } #define AO_HAVE_test_and_set_full #endif /* !AO_PREFER_GENERALIZED */ /*AO_INLINE AO_t AO_fetch_compare_and_swap(volatile AO_t *addr, AO_t old_val, AO_t new_val) { # error FIXME Implement me } #define AO_HAVE_fetch_compare_and_swap*/ AO_INLINE AO_t AO_fetch_compare_and_swap_acquire(volatile AO_t *addr, AO_t old_val, AO_t new_val) { AO_t result = AO_fetch_compare_and_swap(addr, old_val, new_val); AO_lwsync(); return result; } #define AO_HAVE_fetch_compare_and_swap_acquire AO_INLINE AO_t AO_fetch_compare_and_swap_release(volatile AO_t *addr, AO_t old_val, AO_t new_val) { AO_lwsync(); return AO_fetch_compare_and_swap(addr, old_val, new_val); } #define AO_HAVE_fetch_compare_and_swap_release AO_INLINE AO_t AO_fetch_compare_and_swap_full(volatile AO_t *addr, AO_t old_val, AO_t new_val) { AO_t result; AO_lwsync(); result = AO_fetch_compare_and_swap(addr, old_val, new_val); AO_lwsync(); return result; } #define AO_HAVE_fetch_compare_and_swap_full /* TODO: Implement AO_fetch_and_add, AO_and/or/xor directly. */ ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/icc/000077500000000000000000000000001266352375300242355ustar00rootroot00000000000000ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/icc/ia64.h000066400000000000000000000144321266352375300251550ustar00rootroot00000000000000/* * Copyright (c) 2003 by Hewlett-Packard Company. All rights reserved. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ /* * This file specifies Itanimum primitives for use with the Intel (ecc) * compiler. We use intrinsics instead of the inline assembly code in the * gcc file. */ #include "../all_atomic_load_store.h" #include "../test_and_set_t_is_char.h" #include /* The acquire release semantics of volatile can be turned off. And volatile */ /* operations in icc9 don't imply ordering with respect to other nonvolatile */ /* operations. */ #define AO_INTEL_PTR_t void * AO_INLINE AO_t AO_load_acquire(const volatile AO_t *p) { return (AO_t)(__ld8_acq((AO_INTEL_PTR_t)p)); } #define AO_HAVE_load_acquire AO_INLINE void AO_store_release(volatile AO_t *p, AO_t val) { __st8_rel((AO_INTEL_PTR_t)p, (__int64)val); } #define AO_HAVE_store_release AO_INLINE unsigned char AO_char_load_acquire(const volatile unsigned char *p) { /* A normal volatile load generates an ld.acq */ return (__ld1_acq((AO_INTEL_PTR_t)p)); } #define AO_HAVE_char_load_acquire AO_INLINE void AO_char_store_release(volatile unsigned char *p, unsigned char val) { __st1_rel((AO_INTEL_PTR_t)p, val); } #define AO_HAVE_char_store_release AO_INLINE unsigned short AO_short_load_acquire(const volatile unsigned short *p) { /* A normal volatile load generates an ld.acq */ return (__ld2_acq((AO_INTEL_PTR_t)p)); } #define AO_HAVE_short_load_acquire AO_INLINE void AO_short_store_release(volatile unsigned short *p, unsigned short val) { __st2_rel((AO_INTEL_PTR_t)p, val); } #define AO_HAVE_short_store_release AO_INLINE unsigned int AO_int_load_acquire(const volatile unsigned int *p) { /* A normal volatile load generates an ld.acq */ return (__ld4_acq((AO_INTEL_PTR_t)p)); } #define AO_HAVE_int_load_acquire AO_INLINE void AO_int_store_release(volatile unsigned int *p, unsigned int val) { __st4_rel((AO_INTEL_PTR_t)p, val); } #define AO_HAVE_int_store_release AO_INLINE void AO_nop_full(void) { __mf(); } #define AO_HAVE_nop_full #ifndef AO_PREFER_GENERALIZED AO_INLINE AO_t AO_fetch_and_add1_acquire(volatile AO_t *p) { return __fetchadd8_acq((unsigned __int64 *)p, 1); } #define AO_HAVE_fetch_and_add1_acquire AO_INLINE AO_t AO_fetch_and_add1_release(volatile AO_t *p) { return __fetchadd8_rel((unsigned __int64 *)p, 1); } #define AO_HAVE_fetch_and_add1_release AO_INLINE AO_t AO_fetch_and_sub1_acquire(volatile AO_t *p) { return __fetchadd8_acq((unsigned __int64 *)p, -1); } #define AO_HAVE_fetch_and_sub1_acquire AO_INLINE AO_t AO_fetch_and_sub1_release(volatile AO_t *p) { return __fetchadd8_rel((unsigned __int64 *)p, -1); } #define AO_HAVE_fetch_and_sub1_release #endif /* !AO_PREFER_GENERALIZED */ AO_INLINE AO_t AO_fetch_compare_and_swap_acquire(volatile AO_t *addr, AO_t old_val, AO_t new_val) { return _InterlockedCompareExchange64_acq(addr, new_val, old_val); } #define AO_HAVE_fetch_compare_and_swap_acquire AO_INLINE AO_t AO_fetch_compare_and_swap_release(volatile AO_t *addr, AO_t old_val, AO_t new_val) { return _InterlockedCompareExchange64_rel(addr, new_val, old_val); } #define AO_HAVE_fetch_compare_and_swap_release AO_INLINE unsigned char AO_char_fetch_compare_and_swap_acquire(volatile unsigned char *addr, unsigned char old_val, unsigned char new_val) { return _InterlockedCompareExchange8_acq(addr, new_val, old_val); } #define AO_HAVE_char_fetch_compare_and_swap_acquire AO_INLINE unsigned char AO_char_fetch_compare_and_swap_release(volatile unsigned char *addr, unsigned char old_val, unsigned char new_val) { return _InterlockedCompareExchange8_rel(addr, new_val, old_val); } #define AO_HAVE_char_fetch_compare_and_swap_release AO_INLINE unsigned short AO_short_fetch_compare_and_swap_acquire(volatile unsigned short *addr, unsigned short old_val, unsigned short new_val) { return _InterlockedCompareExchange16_acq(addr, new_val, old_val); } #define AO_HAVE_short_fetch_compare_and_swap_acquire AO_INLINE unsigned short AO_short_fetch_compare_and_swap_release(volatile unsigned short *addr, unsigned short old_val, unsigned short new_val) { return _InterlockedCompareExchange16_rel(addr, new_val, old_val); } #define AO_HAVE_short_fetch_compare_and_swap_release AO_INLINE unsigned int AO_int_fetch_compare_and_swap_acquire(volatile unsigned int *addr, unsigned int old_val, unsigned int new_val) { return _InterlockedCompareExchange_acq(addr, new_val, old_val); } #define AO_HAVE_int_fetch_compare_and_swap_acquire AO_INLINE unsigned int AO_int_fetch_compare_and_swap_release(volatile unsigned int *addr, unsigned int old_val, unsigned int new_val) { return _InterlockedCompareExchange_rel(addr, new_val, old_val); } #define AO_HAVE_int_fetch_compare_and_swap_release ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/loadstore/000077500000000000000000000000001266352375300254735ustar00rootroot00000000000000ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/loadstore/acquire_release_volatile.h000066400000000000000000000050001266352375300326670ustar00rootroot00000000000000/* * Copyright (c) 2003-2004 Hewlett-Packard Development Company, L.P. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ /* This file adds definitions appropriate for environments in which */ /* volatile load of a given type has acquire semantics, and volatile */ /* store of a given type has release semantics. This is arguably */ /* supposed to be true with the standard Itanium software conventions. */ /* Empirically gcc/ia64 does some reordering of ordinary operations */ /* around volatiles even when we think it should not. GCC v3.3 and */ /* earlier could reorder a volatile store with another store. As of */ /* March 2005, gcc pre-4 reuses some previously computed common */ /* subexpressions across a volatile load; hence, we now add compiler */ /* barriers for gcc. */ #ifndef AO_GCC_BARRIER /* TODO: Check GCC version (if workaround not needed for modern GCC). */ # if defined(__GNUC__) # define AO_GCC_BARRIER() AO_compiler_barrier() # else # define AO_GCC_BARRIER() (void)0 # endif #endif AO_INLINE AO_t AO_load_acquire(const volatile AO_t *addr) { AO_t result = *addr; /* A normal volatile load generates an ld.acq (on IA-64). */ AO_GCC_BARRIER(); return result; } #define AO_HAVE_load_acquire AO_INLINE void AO_store_release(volatile AO_t *addr, AO_t new_val) { AO_GCC_BARRIER(); /* A normal volatile store generates an st.rel (on IA-64). */ *addr = new_val; } #define AO_HAVE_store_release acquire_release_volatile.template000066400000000000000000000050421266352375300342020ustar00rootroot00000000000000ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/loadstore/* * Copyright (c) 2003-2004 Hewlett-Packard Development Company, L.P. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ /* This file adds definitions appropriate for environments in which */ /* volatile load of a given type has acquire semantics, and volatile */ /* store of a given type has release semantics. This is arguably */ /* supposed to be true with the standard Itanium software conventions. */ /* Empirically gcc/ia64 does some reordering of ordinary operations */ /* around volatiles even when we think it should not. GCC v3.3 and */ /* earlier could reorder a volatile store with another store. As of */ /* March 2005, gcc pre-4 reuses some previously computed common */ /* subexpressions across a volatile load; hence, we now add compiler */ /* barriers for gcc. */ #ifndef AO_GCC_BARRIER /* TODO: Check GCC version (if workaround not needed for modern GCC). */ # if defined(__GNUC__) # define AO_GCC_BARRIER() AO_compiler_barrier() # else # define AO_GCC_BARRIER() (void)0 # endif #endif AO_INLINE XCTYPE AO_XSIZE_load_acquire(const volatile XCTYPE *addr) { XCTYPE result = *addr; /* A normal volatile load generates an ld.acq (on IA-64). */ AO_GCC_BARRIER(); return result; } #define AO_HAVE_XSIZE_load_acquire AO_INLINE void AO_XSIZE_store_release(volatile XCTYPE *addr, XCTYPE new_val) { AO_GCC_BARRIER(); /* A normal volatile store generates an st.rel (on IA-64). */ *addr = new_val; } #define AO_HAVE_XSIZE_store_release ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/loadstore/atomic_load.h000066400000000000000000000032531266352375300301220ustar00rootroot00000000000000/* * Copyright (c) 2004 Hewlett-Packard Development Company, L.P. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ /* Definitions for architectures on which loads of given type are */ /* atomic (either for suitably aligned data only or for any legal */ /* alignment). */ AO_INLINE AO_t AO_load(const volatile AO_t *addr) { # ifdef AO_ACCESS_CHECK_ALIGNED assert(((size_t)addr & (sizeof(*addr) - 1)) == 0); # endif /* Cast away the volatile for architectures like IA64 where */ /* volatile adds barrier (fence) semantics. */ return *(const AO_t *)addr; } #define AO_HAVE_load ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/loadstore/atomic_load.template000066400000000000000000000033031266352375300315020ustar00rootroot00000000000000/* * Copyright (c) 2004 Hewlett-Packard Development Company, L.P. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ /* Definitions for architectures on which loads of given type are */ /* atomic (either for suitably aligned data only or for any legal */ /* alignment). */ AO_INLINE XCTYPE AO_XSIZE_load(const volatile XCTYPE *addr) { # ifdef AO_ACCESS_XSIZE_CHECK_ALIGNED assert(((size_t)addr & (sizeof(*addr) - 1)) == 0); # endif /* Cast away the volatile for architectures like IA64 where */ /* volatile adds barrier (fence) semantics. */ return *(const XCTYPE *)addr; } #define AO_HAVE_XSIZE_load ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/loadstore/atomic_store.h000066400000000000000000000030541266352375300303360ustar00rootroot00000000000000/* * Copyright (c) 2004 Hewlett-Packard Development Company, L.P. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ /* Definitions for architectures on which stores of given type are */ /* atomic (either for suitably aligned data only or for any legal */ /* alignment). */ AO_INLINE void AO_store(volatile AO_t *addr, AO_t new_val) { # ifdef AO_ACCESS_CHECK_ALIGNED assert(((size_t)addr & (sizeof(*addr) - 1)) == 0); # endif *(AO_t *)addr = new_val; } #define AO_HAVE_store ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/loadstore/atomic_store.template000066400000000000000000000031041266352375300317160ustar00rootroot00000000000000/* * Copyright (c) 2004 Hewlett-Packard Development Company, L.P. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ /* Definitions for architectures on which stores of given type are */ /* atomic (either for suitably aligned data only or for any legal */ /* alignment). */ AO_INLINE void AO_XSIZE_store(volatile XCTYPE *addr, XCTYPE new_val) { # ifdef AO_ACCESS_XSIZE_CHECK_ALIGNED assert(((size_t)addr & (sizeof(*addr) - 1)) == 0); # endif *(XCTYPE *)addr = new_val; } #define AO_HAVE_XSIZE_store ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/loadstore/char_acquire_release_volatile.h000066400000000000000000000051201266352375300336670ustar00rootroot00000000000000/* * Copyright (c) 2003-2004 Hewlett-Packard Development Company, L.P. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ /* This file adds definitions appropriate for environments in which */ /* volatile load of a given type has acquire semantics, and volatile */ /* store of a given type has release semantics. This is arguably */ /* supposed to be true with the standard Itanium software conventions. */ /* Empirically gcc/ia64 does some reordering of ordinary operations */ /* around volatiles even when we think it should not. GCC v3.3 and */ /* earlier could reorder a volatile store with another store. As of */ /* March 2005, gcc pre-4 reuses some previously computed common */ /* subexpressions across a volatile load; hence, we now add compiler */ /* barriers for gcc. */ #ifndef AO_GCC_BARRIER /* TODO: Check GCC version (if workaround not needed for modern GCC). */ # if defined(__GNUC__) # define AO_GCC_BARRIER() AO_compiler_barrier() # else # define AO_GCC_BARRIER() (void)0 # endif #endif AO_INLINE unsigned/**/char AO_char_load_acquire(const volatile unsigned/**/char *addr) { unsigned/**/char result = *addr; /* A normal volatile load generates an ld.acq (on IA-64). */ AO_GCC_BARRIER(); return result; } #define AO_HAVE_char_load_acquire AO_INLINE void AO_char_store_release(volatile unsigned/**/char *addr, unsigned/**/char new_val) { AO_GCC_BARRIER(); /* A normal volatile store generates an st.rel (on IA-64). */ *addr = new_val; } #define AO_HAVE_char_store_release ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/loadstore/char_atomic_load.h000066400000000000000000000033361266352375300311210ustar00rootroot00000000000000/* * Copyright (c) 2004 Hewlett-Packard Development Company, L.P. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ /* Definitions for architectures on which loads of given type are */ /* atomic (either for suitably aligned data only or for any legal */ /* alignment). */ AO_INLINE unsigned/**/char AO_char_load(const volatile unsigned/**/char *addr) { # ifdef AO_ACCESS_char_CHECK_ALIGNED assert(((size_t)addr & (sizeof(*addr) - 1)) == 0); # endif /* Cast away the volatile for architectures like IA64 where */ /* volatile adds barrier (fence) semantics. */ return *(const unsigned/**/char *)addr; } #define AO_HAVE_char_load ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/loadstore/char_atomic_store.h000066400000000000000000000031371266352375300313350ustar00rootroot00000000000000/* * Copyright (c) 2004 Hewlett-Packard Development Company, L.P. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ /* Definitions for architectures on which stores of given type are */ /* atomic (either for suitably aligned data only or for any legal */ /* alignment). */ AO_INLINE void AO_char_store(volatile unsigned/**/char *addr, unsigned/**/char new_val) { # ifdef AO_ACCESS_char_CHECK_ALIGNED assert(((size_t)addr & (sizeof(*addr) - 1)) == 0); # endif *(unsigned/**/char *)addr = new_val; } #define AO_HAVE_char_store ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/loadstore/double_atomic_load_store.h000066400000000000000000000037501266352375300326720ustar00rootroot00000000000000/* * Copyright (c) 2004 Hewlett-Packard Development Company, L.P. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ /* Definitions for architectures on which AO_double_t loads and stores */ /* are atomic (either for suitably aligned data only or for any legal */ /* alignment). */ AO_INLINE AO_double_t AO_double_load(const volatile AO_double_t *addr) { AO_double_t result; # ifdef AO_ACCESS_double_CHECK_ALIGNED assert(((size_t)addr & (sizeof(AO_double_t) - 1)) == 0); # endif /* Cast away the volatile in case it adds fence semantics. */ result.AO_whole = ((const AO_double_t *)addr)->AO_whole; return result; } #define AO_HAVE_double_load AO_INLINE void AO_double_store(volatile AO_double_t *addr, AO_double_t new_val) { # ifdef AO_ACCESS_double_CHECK_ALIGNED assert(((size_t)addr & (sizeof(AO_double_t) - 1)) == 0); # endif ((AO_double_t *)addr)->AO_whole = new_val.AO_whole; } #define AO_HAVE_double_store ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/loadstore/int_acquire_release_volatile.h000066400000000000000000000050441266352375300335510ustar00rootroot00000000000000/* * Copyright (c) 2003-2004 Hewlett-Packard Development Company, L.P. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ /* This file adds definitions appropriate for environments in which */ /* volatile load of a given type has acquire semantics, and volatile */ /* store of a given type has release semantics. This is arguably */ /* supposed to be true with the standard Itanium software conventions. */ /* Empirically gcc/ia64 does some reordering of ordinary operations */ /* around volatiles even when we think it should not. GCC v3.3 and */ /* earlier could reorder a volatile store with another store. As of */ /* March 2005, gcc pre-4 reuses some previously computed common */ /* subexpressions across a volatile load; hence, we now add compiler */ /* barriers for gcc. */ #ifndef AO_GCC_BARRIER /* TODO: Check GCC version (if workaround not needed for modern GCC). */ # if defined(__GNUC__) # define AO_GCC_BARRIER() AO_compiler_barrier() # else # define AO_GCC_BARRIER() (void)0 # endif #endif AO_INLINE unsigned AO_int_load_acquire(const volatile unsigned *addr) { unsigned result = *addr; /* A normal volatile load generates an ld.acq (on IA-64). */ AO_GCC_BARRIER(); return result; } #define AO_HAVE_int_load_acquire AO_INLINE void AO_int_store_release(volatile unsigned *addr, unsigned new_val) { AO_GCC_BARRIER(); /* A normal volatile store generates an st.rel (on IA-64). */ *addr = new_val; } #define AO_HAVE_int_store_release ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/loadstore/int_atomic_load.h000066400000000000000000000033031266352375300307700ustar00rootroot00000000000000/* * Copyright (c) 2004 Hewlett-Packard Development Company, L.P. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ /* Definitions for architectures on which loads of given type are */ /* atomic (either for suitably aligned data only or for any legal */ /* alignment). */ AO_INLINE unsigned AO_int_load(const volatile unsigned *addr) { # ifdef AO_ACCESS_int_CHECK_ALIGNED assert(((size_t)addr & (sizeof(*addr) - 1)) == 0); # endif /* Cast away the volatile for architectures like IA64 where */ /* volatile adds barrier (fence) semantics. */ return *(const unsigned *)addr; } #define AO_HAVE_int_load ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/loadstore/int_atomic_store.h000066400000000000000000000031041266352375300312040ustar00rootroot00000000000000/* * Copyright (c) 2004 Hewlett-Packard Development Company, L.P. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ /* Definitions for architectures on which stores of given type are */ /* atomic (either for suitably aligned data only or for any legal */ /* alignment). */ AO_INLINE void AO_int_store(volatile unsigned *addr, unsigned new_val) { # ifdef AO_ACCESS_int_CHECK_ALIGNED assert(((size_t)addr & (sizeof(*addr) - 1)) == 0); # endif *(unsigned *)addr = new_val; } #define AO_HAVE_int_store ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/loadstore/ordered_loads_only.h000066400000000000000000000150351266352375300315170ustar00rootroot00000000000000/* * Copyright (c) 2003 by Hewlett-Packard Company. All rights reserved. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ #ifdef AO_HAVE_char_load /* char_load_read is defined in generalize-small. */ # define AO_char_load_acquire(addr) AO_char_load_read(addr) # define AO_HAVE_char_load_acquire #endif /* * Copyright (c) 2003 by Hewlett-Packard Company. All rights reserved. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ #ifdef AO_HAVE_short_load /* short_load_read is defined in generalize-small. */ # define AO_short_load_acquire(addr) AO_short_load_read(addr) # define AO_HAVE_short_load_acquire #endif /* * Copyright (c) 2003 by Hewlett-Packard Company. All rights reserved. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ #ifdef AO_HAVE_int_load /* int_load_read is defined in generalize-small. */ # define AO_int_load_acquire(addr) AO_int_load_read(addr) # define AO_HAVE_int_load_acquire #endif /* * Copyright (c) 2003 by Hewlett-Packard Company. All rights reserved. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ #ifdef AO_HAVE_load /* load_read is defined in generalize-small. */ # define AO_load_acquire(addr) AO_load_read(addr) # define AO_HAVE_load_acquire #endif /* * Copyright (c) 2003 by Hewlett-Packard Company. All rights reserved. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ #ifdef AO_HAVE_double_load /* double_load_read is defined in generalize-small. */ # define AO_double_load_acquire(addr) AO_double_load_read(addr) # define AO_HAVE_double_load_acquire #endif ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/loadstore/ordered_loads_only.template000066400000000000000000000025011266352375300330750ustar00rootroot00000000000000/* * Copyright (c) 2003 by Hewlett-Packard Company. All rights reserved. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ #ifdef AO_HAVE_XSIZE_load /* XSIZE_load_read is defined in generalize-small. */ # define AO_XSIZE_load_acquire(addr) AO_XSIZE_load_read(addr) # define AO_HAVE_XSIZE_load_acquire #endif ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/loadstore/ordered_stores_only.h000066400000000000000000000150571266352375300317400ustar00rootroot00000000000000/* * Copyright (c) 2003 by Hewlett-Packard Company. All rights reserved. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ #ifdef AO_HAVE_char_store # define AO_char_store_release(addr, val) \ (AO_nop_write(), AO_char_store(addr, val)) # define AO_HAVE_char_store_release #endif /* * Copyright (c) 2003 by Hewlett-Packard Company. All rights reserved. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ #ifdef AO_HAVE_short_store # define AO_short_store_release(addr, val) \ (AO_nop_write(), AO_short_store(addr, val)) # define AO_HAVE_short_store_release #endif /* * Copyright (c) 2003 by Hewlett-Packard Company. All rights reserved. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ #ifdef AO_HAVE_int_store # define AO_int_store_release(addr, val) \ (AO_nop_write(), AO_int_store(addr, val)) # define AO_HAVE_int_store_release #endif /* * Copyright (c) 2003 by Hewlett-Packard Company. All rights reserved. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ #ifdef AO_HAVE_store # define AO_store_release(addr, val) \ (AO_nop_write(), AO_store(addr, val)) # define AO_HAVE_store_release #endif /* * Copyright (c) 2003 by Hewlett-Packard Company. All rights reserved. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ #ifdef AO_HAVE_double_store # define AO_double_store_release(addr, val) \ (AO_nop_write(), AO_double_store(addr, val)) # define AO_HAVE_double_store_release #endif ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/loadstore/ordered_stores_only.template000066400000000000000000000025031266352375300333140ustar00rootroot00000000000000/* * Copyright (c) 2003 by Hewlett-Packard Company. All rights reserved. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ #ifdef AO_HAVE_XSIZE_store # define AO_XSIZE_store_release(addr, val) \ (AO_nop_write(), AO_XSIZE_store(addr, val)) # define AO_HAVE_XSIZE_store_release #endif ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/loadstore/short_acquire_release_volatile.h000066400000000000000000000051311266352375300341130ustar00rootroot00000000000000/* * Copyright (c) 2003-2004 Hewlett-Packard Development Company, L.P. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ /* This file adds definitions appropriate for environments in which */ /* volatile load of a given type has acquire semantics, and volatile */ /* store of a given type has release semantics. This is arguably */ /* supposed to be true with the standard Itanium software conventions. */ /* Empirically gcc/ia64 does some reordering of ordinary operations */ /* around volatiles even when we think it should not. GCC v3.3 and */ /* earlier could reorder a volatile store with another store. As of */ /* March 2005, gcc pre-4 reuses some previously computed common */ /* subexpressions across a volatile load; hence, we now add compiler */ /* barriers for gcc. */ #ifndef AO_GCC_BARRIER /* TODO: Check GCC version (if workaround not needed for modern GCC). */ # if defined(__GNUC__) # define AO_GCC_BARRIER() AO_compiler_barrier() # else # define AO_GCC_BARRIER() (void)0 # endif #endif AO_INLINE unsigned/**/short AO_short_load_acquire(const volatile unsigned/**/short *addr) { unsigned/**/short result = *addr; /* A normal volatile load generates an ld.acq (on IA-64). */ AO_GCC_BARRIER(); return result; } #define AO_HAVE_short_load_acquire AO_INLINE void AO_short_store_release(volatile unsigned/**/short *addr, unsigned/**/short new_val) { AO_GCC_BARRIER(); /* A normal volatile store generates an st.rel (on IA-64). */ *addr = new_val; } #define AO_HAVE_short_store_release ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/loadstore/short_atomic_load.h000066400000000000000000000033441266352375300313420ustar00rootroot00000000000000/* * Copyright (c) 2004 Hewlett-Packard Development Company, L.P. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ /* Definitions for architectures on which loads of given type are */ /* atomic (either for suitably aligned data only or for any legal */ /* alignment). */ AO_INLINE unsigned/**/short AO_short_load(const volatile unsigned/**/short *addr) { # ifdef AO_ACCESS_short_CHECK_ALIGNED assert(((size_t)addr & (sizeof(*addr) - 1)) == 0); # endif /* Cast away the volatile for architectures like IA64 where */ /* volatile adds barrier (fence) semantics. */ return *(const unsigned/**/short *)addr; } #define AO_HAVE_short_load ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/loadstore/short_atomic_store.h000066400000000000000000000031451266352375300315560ustar00rootroot00000000000000/* * Copyright (c) 2004 Hewlett-Packard Development Company, L.P. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ /* Definitions for architectures on which stores of given type are */ /* atomic (either for suitably aligned data only or for any legal */ /* alignment). */ AO_INLINE void AO_short_store(volatile unsigned/**/short *addr, unsigned/**/short new_val) { # ifdef AO_ACCESS_short_CHECK_ALIGNED assert(((size_t)addr & (sizeof(*addr) - 1)) == 0); # endif *(unsigned/**/short *)addr = new_val; } #define AO_HAVE_short_store ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/msftc/000077500000000000000000000000001266352375300246135ustar00rootroot00000000000000ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/msftc/arm.h000066400000000000000000000047021266352375300255460ustar00rootroot00000000000000/* * Copyright (c) 2003 Hewlett-Packard Development Company, L.P. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ #ifndef AO_ASSUME_WINDOWS98 /* CAS is always available */ # define AO_ASSUME_WINDOWS98 #endif #include "common32_defs.h" /* FIXME: Do _InterlockedOps really have a full memory barrier? */ /* (MSDN WinCE docs say nothing about it.) */ #include "../test_and_set_t_is_ao_t.h" /* AO_test_and_set_full() is emulated using CAS. */ /* Some ARM slide set, if it has been read correctly, claims that Loads */ /* followed by either a Load or a Store are ordered, but nothing else. */ /* It is assumed that Windows interrupt handlers clear the LL/SC flag. */ /* Unaligned accesses are not guaranteed to be atomic. */ #include "../all_aligned_atomic_load_store.h" /* If only a single processor is used, we can define AO_UNIPROCESSOR. */ #ifdef AO_UNIPROCESSOR AO_INLINE void AO_nop_full(void) { AO_compiler_barrier(); } # define AO_HAVE_nop_full #else /* AO_nop_full() is emulated using AO_test_and_set_full(). */ #endif #if _M_ARM >= 6 /* ARMv6 is the first architecture providing support for simple LL/SC. */ /* #include "../standard_ao_double_t.h" */ /* TODO: implement double-wide operations (similar to x86). */ #else /* _M_ARM < 6 */ /* TODO: implement AO_test_and_set_full using SWP. */ #endif /* _M_ARM < 6 */ #define AO_T_IS_INT ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/msftc/common32_defs.h000066400000000000000000000106461266352375300274310ustar00rootroot00000000000000/* * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ /* This file contains AO primitives based on VC++ built-in intrinsic */ /* functions commonly available across 32-bit architectures. */ /* This file should be included from arch-specific header files. */ /* Define AO_USE_INTERLOCKED_INTRINSICS if _Interlocked primitives */ /* (used below) are available as intrinsic ones for a target arch */ /* (otherwise "Interlocked" functions family is used instead). */ /* Define AO_ASSUME_WINDOWS98 if CAS is available. */ #include /* Seems like over-kill, but that's what MSDN recommends. */ /* And apparently winbase.h is not always self-contained. */ #if _MSC_VER < 1310 || !defined(AO_USE_INTERLOCKED_INTRINSICS) # define _InterlockedIncrement InterlockedIncrement # define _InterlockedDecrement InterlockedDecrement # define _InterlockedExchangeAdd InterlockedExchangeAdd # define _InterlockedCompareExchange InterlockedCompareExchange # define AO_INTERLOCKED_VOLATILE /**/ #else /* elif _MSC_VER >= 1310 */ # if _MSC_VER >= 1400 # ifndef _WIN32_WCE # include # endif # else /* elif _MSC_VER < 1400 */ # ifdef __cplusplus extern "C" { # endif LONG __cdecl _InterlockedIncrement(LONG volatile *); LONG __cdecl _InterlockedDecrement(LONG volatile *); LONG __cdecl _InterlockedExchangeAdd(LONG volatile *, LONG); LONG __cdecl _InterlockedCompareExchange(LONG volatile *, LONG /* Exchange */, LONG /* Comp */); # ifdef __cplusplus } # endif # endif /* _MSC_VER < 1400 */ # if !defined(AO_PREFER_GENERALIZED) || !defined(AO_ASSUME_WINDOWS98) # pragma intrinsic (_InterlockedIncrement) # pragma intrinsic (_InterlockedDecrement) # pragma intrinsic (_InterlockedExchangeAdd) # endif /* !AO_PREFER_GENERALIZED */ # pragma intrinsic (_InterlockedCompareExchange) # define AO_INTERLOCKED_VOLATILE volatile #endif /* _MSC_VER >= 1310 */ #if !defined(AO_PREFER_GENERALIZED) || !defined(AO_ASSUME_WINDOWS98) AO_INLINE AO_t AO_fetch_and_add_full(volatile AO_t *p, AO_t incr) { return _InterlockedExchangeAdd((LONG AO_INTERLOCKED_VOLATILE *)p, (LONG)incr); } #define AO_HAVE_fetch_and_add_full AO_INLINE AO_t AO_fetch_and_add1_full(volatile AO_t *p) { return _InterlockedIncrement((LONG AO_INTERLOCKED_VOLATILE *)p) - 1; } #define AO_HAVE_fetch_and_add1_full AO_INLINE AO_t AO_fetch_and_sub1_full(volatile AO_t *p) { return _InterlockedDecrement((LONG AO_INTERLOCKED_VOLATILE *)p) + 1; } #define AO_HAVE_fetch_and_sub1_full #endif /* !AO_PREFER_GENERALIZED */ #ifdef AO_ASSUME_WINDOWS98 AO_INLINE AO_t AO_fetch_compare_and_swap_full(volatile AO_t *addr, AO_t old_val, AO_t new_val) { # ifdef AO_OLD_STYLE_INTERLOCKED_COMPARE_EXCHANGE return (AO_t)_InterlockedCompareExchange( (PVOID AO_INTERLOCKED_VOLATILE *)addr, (PVOID)new_val, (PVOID)old_val); # else return (AO_t)_InterlockedCompareExchange( (LONG AO_INTERLOCKED_VOLATILE *)addr, (LONG)new_val, (LONG)old_val); # endif } # define AO_HAVE_fetch_compare_and_swap_full #endif /* AO_ASSUME_WINDOWS98 */ ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/msftc/x86.h000066400000000000000000000117701266352375300254170ustar00rootroot00000000000000/* * Copyright (c) 2003 Hewlett-Packard Development Company, L.P. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ /* If AO_ASSUME_WINDOWS98 is defined, we assume Windows 98 or newer. */ /* If AO_ASSUME_VISTA is defined, we assume Windows Server 2003, Vista */ /* or later. */ #include "../all_aligned_atomic_load_store.h" #include "../test_and_set_t_is_char.h" #if defined(AO_ASSUME_VISTA) && !defined(AO_ASSUME_WINDOWS98) # define AO_ASSUME_WINDOWS98 #endif #ifndef AO_USE_INTERLOCKED_INTRINSICS /* _Interlocked primitives (Inc, Dec, Xchg, Add) are always available */ # define AO_USE_INTERLOCKED_INTRINSICS #endif #include "common32_defs.h" /* As far as we can tell, the lfence and sfence instructions are not */ /* currently needed or useful for cached memory accesses. */ /* Unfortunately mfence doesn't exist everywhere. */ /* IsProcessorFeaturePresent(PF_COMPARE_EXCHANGE128) is */ /* probably a conservative test for it? */ #if defined(AO_USE_PENTIUM4_INSTRS) AO_INLINE void AO_nop_full(void) { __asm { mfence } } #define AO_HAVE_nop_full #else /* We could use the cpuid instruction. But that seems to be slower */ /* than the default implementation based on test_and_set_full. Thus */ /* we omit that bit of misinformation here. */ #endif #ifndef AO_NO_ASM_XADD AO_INLINE unsigned char AO_char_fetch_and_add_full(volatile unsigned char *p, unsigned char incr) { __asm { mov al, incr mov ebx, p lock xadd byte ptr [ebx], al } /* Ignore possible "missing return value" warning here. */ } # define AO_HAVE_char_fetch_and_add_full AO_INLINE unsigned short AO_short_fetch_and_add_full(volatile unsigned short *p, unsigned short incr) { __asm { mov ax, incr mov ebx, p lock xadd word ptr [ebx], ax } /* Ignore possible "missing return value" warning here. */ } # define AO_HAVE_short_fetch_and_add_full #endif /* !AO_NO_ASM_XADD */ AO_INLINE AO_TS_VAL_t AO_test_and_set_full(volatile AO_TS_t *addr) { __asm { mov eax,0xff ; /* AO_TS_SET */ mov ebx,addr ; xchg byte ptr [ebx],al ; } /* Ignore possible "missing return value" warning here. */ } #define AO_HAVE_test_and_set_full #ifdef _WIN64 # error wrong architecture #endif #ifdef AO_ASSUME_VISTA # include "../standard_ao_double_t.h" /* Reading or writing a quadword aligned on a 64-bit boundary is */ /* always carried out atomically (requires at least a Pentium). */ # define AO_ACCESS_double_CHECK_ALIGNED # include "../loadstore/double_atomic_load_store.h" /* Whenever we run on a Pentium class machine, we have that certain */ /* function. */ # pragma intrinsic (_InterlockedCompareExchange64) /* Returns nonzero if the comparison succeeded. */ AO_INLINE int AO_double_compare_and_swap_full(volatile AO_double_t *addr, AO_double_t old_val, AO_double_t new_val) { return (double_ptr_storage)_InterlockedCompareExchange64( (__int64 volatile *)addr, new_val.AO_whole /* exchange */, old_val.AO_whole) == old_val.AO_whole; } # define AO_HAVE_double_compare_and_swap_full #endif /* AO_ASSUME_VISTA */ #define AO_T_IS_INT /* Real X86 implementations, except for some old WinChips, appear */ /* to enforce ordering between memory operations, EXCEPT that a later */ /* read can pass earlier writes, presumably due to the visible */ /* presence of store buffers. */ /* We ignore both the WinChips, and the fact that the official specs */ /* seem to be much weaker (and arguably too weak to be usable). */ #include "../ordered_except_wr.h" ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/msftc/x86_64.h000066400000000000000000000142501266352375300257240ustar00rootroot00000000000000/* * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ #include "../all_aligned_atomic_load_store.h" /* Real X86 implementations appear */ /* to enforce ordering between memory operations, EXCEPT that a later */ /* read can pass earlier writes, presumably due to the visible */ /* presence of store buffers. */ /* We ignore the fact that the official specs */ /* seem to be much weaker (and arguably too weak to be usable). */ #include "../ordered_except_wr.h" #ifdef AO_ASM_X64_AVAILABLE # include "../test_and_set_t_is_char.h" #else # include "../test_and_set_t_is_ao_t.h" #endif #include /* Seems like over-kill, but that's what MSDN recommends. */ /* And apparently winbase.h is not always self-contained. */ /* Assume _MSC_VER >= 1400 */ #include #pragma intrinsic (_InterlockedExchangeAdd) #pragma intrinsic (_InterlockedCompareExchange64) #ifndef AO_PREFER_GENERALIZED # pragma intrinsic (_InterlockedIncrement64) # pragma intrinsic (_InterlockedDecrement64) # pragma intrinsic (_InterlockedExchangeAdd64) AO_INLINE AO_t AO_fetch_and_add_full (volatile AO_t *p, AO_t incr) { return _InterlockedExchangeAdd64((LONGLONG volatile *)p, (LONGLONG)incr); } #define AO_HAVE_fetch_and_add_full AO_INLINE AO_t AO_fetch_and_add1_full (volatile AO_t *p) { return _InterlockedIncrement64((LONGLONG volatile *)p) - 1; } #define AO_HAVE_fetch_and_add1_full AO_INLINE AO_t AO_fetch_and_sub1_full (volatile AO_t *p) { return _InterlockedDecrement64((LONGLONG volatile *)p) + 1; } #define AO_HAVE_fetch_and_sub1_full #endif /* !AO_PREFER_GENERALIZED */ AO_INLINE AO_t AO_fetch_compare_and_swap_full(volatile AO_t *addr, AO_t old_val, AO_t new_val) { return (AO_t)_InterlockedCompareExchange64((LONGLONG volatile *)addr, (LONGLONG)new_val, (LONGLONG)old_val); } #define AO_HAVE_fetch_compare_and_swap_full AO_INLINE unsigned int AO_int_fetch_and_add_full(volatile unsigned int *p, unsigned int incr) { return _InterlockedExchangeAdd((LONG volatile *)p, incr); } #define AO_HAVE_int_fetch_and_add_full #ifdef AO_ASM_X64_AVAILABLE AO_INLINE unsigned char AO_char_fetch_and_add_full(volatile unsigned char *p, unsigned char incr) { __asm { mov al, incr mov rbx, p lock xadd byte ptr [rbx], al } } # define AO_HAVE_char_fetch_and_add_full AO_INLINE unsigned short AO_short_fetch_and_add_full(volatile unsigned short *p, unsigned short incr) { __asm { mov ax, incr mov rbx, p lock xadd word ptr [rbx], ax } } # define AO_HAVE_short_fetch_and_add_full /* As far as we can tell, the lfence and sfence instructions are not */ /* currently needed or useful for cached memory accesses. */ AO_INLINE void AO_nop_full(void) { /* Note: "mfence" (SSE2) is supported on all x86_64/amd64 chips. */ __asm { mfence } } # define AO_HAVE_nop_full AO_INLINE AO_TS_VAL_t AO_test_and_set_full(volatile AO_TS_t *addr) { __asm { mov rax,AO_TS_SET ; mov rbx,addr ; xchg byte ptr [rbx],al ; } } # define AO_HAVE_test_and_set_full #endif /* AO_ASM_X64_AVAILABLE */ #ifdef AO_CMPXCHG16B_AVAILABLE /* AO_compare_double_and_swap_double_full needs implementation for Win64. * Also see ../gcc/x86.h for partial old Opteron workaround. */ # if _MSC_VER >= 1500 # include "../standard_ao_double_t.h" # pragma intrinsic (_InterlockedCompareExchange128) AO_INLINE int AO_compare_double_and_swap_double_full(volatile AO_double_t *addr, AO_t old_val1, AO_t old_val2, AO_t new_val1, AO_t new_val2) { __int64 comparandResult[2]; comparandResult[0] = old_val1; /* low */ comparandResult[1] = old_val2; /* high */ return _InterlockedCompareExchange128((volatile __int64 *)addr, new_val2 /* high */, new_val1 /* low */, comparandResult); } # define AO_HAVE_compare_double_and_swap_double_full # elif defined(AO_ASM_X64_AVAILABLE) # include "../standard_ao_double_t.h" /* If there is no intrinsic _InterlockedCompareExchange128 then we */ /* need basically what's given below. */ AO_INLINE int AO_compare_double_and_swap_double_full(volatile AO_double_t *addr, AO_t old_val1, AO_t old_val2, AO_t new_val1, AO_t new_val2) { __asm { mov rdx,QWORD PTR [old_val2] ; mov rax,QWORD PTR [old_val1] ; mov rcx,QWORD PTR [new_val2] ; mov rbx,QWORD PTR [new_val1] ; lock cmpxchg16b [addr] ; setz rax ; } } # define AO_HAVE_compare_double_and_swap_double_full # endif /* AO_ASM_X64_AVAILABLE && (_MSC_VER < 1500) */ #endif /* AO_CMPXCHG16B_AVAILABLE */ ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/ordered.h000066400000000000000000000025711266352375300253010ustar00rootroot00000000000000/* * Copyright (c) 2003 Hewlett-Packard Development Company, L.P. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ /* These are common definitions for architectures that provide */ /* processor ordered memory operations. */ #include "ordered_except_wr.h" AO_INLINE void AO_nop_full(void) { AO_compiler_barrier(); } #define AO_HAVE_nop_full ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/ordered_except_wr.h000066400000000000000000000033651266352375300273630ustar00rootroot00000000000000/* * Copyright (c) 2003 by Hewlett-Packard Company. All rights reserved. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ /* * These are common definitions for architectures that provide processor * ordered memory operations except that a later read may pass an * earlier write. Real x86 implementations seem to be in this category, * except apparently for some IDT WinChips, which we ignore. */ #include "read_ordered.h" AO_INLINE void AO_nop_write(void) { /* AO_nop_write implementation is the same as of AO_nop_read. */ AO_compiler_barrier(); /* sfence according to Intel docs. Pentium 3 and up. */ /* Unnecessary for cached accesses? */ } #define AO_HAVE_nop_write #include "loadstore/ordered_stores_only.h" ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/read_ordered.h000066400000000000000000000030361266352375300262710ustar00rootroot00000000000000/* * Copyright (c) 2003 by Hewlett-Packard Company. All rights reserved. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ /* * These are common definitions for architectures that provide processor * ordered memory operations except that a later read may pass an * earlier write. Real x86 implementations seem to be in this category, * except apparently for some IDT WinChips, which we ignore. */ AO_INLINE void AO_nop_read(void) { AO_compiler_barrier(); } #define AO_HAVE_nop_read #include "loadstore/ordered_loads_only.h" ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/standard_ao_double_t.h000066400000000000000000000054311266352375300300070ustar00rootroot00000000000000/* * Copyright (c) 2004-2011 Hewlett-Packard Development Company, L.P. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ /* For 64-bit systems, we extend the double type to hold two int64's. */ /* x86-64 (except for x32): __m128 serves as a placeholder which also */ /* requires the compiler to align it on 16-byte boundary (as required */ /* by cmpxchg16). */ /* Similar things could be done for PPC 64-bit using a VMX data type. */ #if ((defined(__x86_64__) && __GNUC__ >= 4) || defined(_WIN64)) \ && !defined(__ILP32__) # include typedef __m128 double_ptr_storage; #elif defined(_WIN32) && !defined(__GNUC__) typedef unsigned __int64 double_ptr_storage; #elif defined(__aarch64__) typedef unsigned __int128 double_ptr_storage; #else typedef unsigned long long double_ptr_storage; #endif # define AO_HAVE_DOUBLE_PTR_STORAGE typedef union { struct { AO_t AO_v1; AO_t AO_v2; } AO_parts; /* Note that AO_v1 corresponds to the low or the high part of */ /* AO_whole depending on the machine endianness. */ double_ptr_storage AO_whole; /* AO_whole is now (starting from v7.3alpha3) the 2nd element */ /* of this union to make AO_DOUBLE_T_INITIALIZER portable */ /* (because __m128 definition could vary from a primitive type */ /* to a structure or array/vector). */ } AO_double_t; #define AO_HAVE_double_t /* Dummy declaration as a compile-time assertion for AO_double_t size. */ struct AO_double_t_size_static_assert { char dummy[sizeof(AO_double_t) == 2 * sizeof(AO_t) ? 1 : -1]; }; #define AO_DOUBLE_T_INITIALIZER { { (AO_t)0, (AO_t)0 } } #define AO_val1 AO_parts.AO_v1 #define AO_val2 AO_parts.AO_v2 ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/sunc/000077500000000000000000000000001266352375300244475ustar00rootroot00000000000000ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/sunc/sparc.S000066400000000000000000000002011266352375300256740ustar00rootroot00000000000000 .seg "text" .globl AO_test_and_set_full AO_test_and_set_full: retl ldstub [%o0],%o0 ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/sunc/sparc.h000066400000000000000000000030711266352375300257310ustar00rootroot00000000000000/* * Copyright (c) 2004 Hewlett-Packard Development Company, L.P. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ #include "../all_atomic_load_store.h" /* Real SPARC code uses TSO: */ #include "../ordered_except_wr.h" /* Test_and_set location is just a byte. */ #include "../test_and_set_t_is_char.h" extern AO_TS_VAL_t AO_test_and_set_full(volatile AO_TS_t *addr); /* Implemented in separate .S file, for now. */ #define AO_HAVE_test_and_set_full /* TODO: Like the gcc version, extend this for V8 and V9. */ ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/sunc/x86.h000066400000000000000000000173431266352375300252550ustar00rootroot00000000000000/* * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. * Copyright (c) 1999-2003 by Hewlett-Packard Company. All rights reserved. * * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. * * Some of the machine specific code was borrowed from our GC distribution. */ /* The following really assume we have a 486 or better. */ #include "../all_aligned_atomic_load_store.h" #include "../test_and_set_t_is_char.h" #if !defined(AO_USE_PENTIUM4_INSTRS) && !defined(__i386) /* "mfence" (SSE2) is supported on all x86_64/amd64 chips. */ # define AO_USE_PENTIUM4_INSTRS #endif #if defined(AO_USE_PENTIUM4_INSTRS) AO_INLINE void AO_nop_full(void) { __asm__ __volatile__ ("mfence" : : : "memory"); } # define AO_HAVE_nop_full #else /* We could use the cpuid instruction. But that seems to be slower */ /* than the default implementation based on test_and_set_full. Thus */ /* we omit that bit of misinformation here. */ #endif /* !AO_USE_PENTIUM4_INSTRS */ /* As far as we can tell, the lfence and sfence instructions are not */ /* currently needed or useful for cached memory accesses. */ /* Really only works for 486 and later */ #ifndef AO_PREFER_GENERALIZED AO_INLINE AO_t AO_fetch_and_add_full (volatile AO_t *p, AO_t incr) { AO_t result; __asm__ __volatile__ ("lock; xadd %0, %1" : "=r" (result), "+m" (*p) : "0" (incr) : "memory"); return result; } # define AO_HAVE_fetch_and_add_full #endif /* !AO_PREFER_GENERALIZED */ AO_INLINE unsigned char AO_char_fetch_and_add_full (volatile unsigned char *p, unsigned char incr) { unsigned char result; __asm__ __volatile__ ("lock; xaddb %0, %1" : "=q" (result), "+m" (*p) : "0" (incr) : "memory"); return result; } #define AO_HAVE_char_fetch_and_add_full AO_INLINE unsigned short AO_short_fetch_and_add_full (volatile unsigned short *p, unsigned short incr) { unsigned short result; __asm__ __volatile__ ("lock; xaddw %0, %1" : "=r" (result), "+m" (*p) : "0" (incr) : "memory"); return result; } #define AO_HAVE_short_fetch_and_add_full #ifndef AO_PREFER_GENERALIZED /* Really only works for 486 and later */ AO_INLINE void AO_and_full (volatile AO_t *p, AO_t value) { __asm__ __volatile__ ("lock; and %1, %0" : "+m" (*p) : "r" (value) : "memory"); } # define AO_HAVE_and_full AO_INLINE void AO_or_full (volatile AO_t *p, AO_t value) { __asm__ __volatile__ ("lock; or %1, %0" : "+m" (*p) : "r" (value) : "memory"); } # define AO_HAVE_or_full AO_INLINE void AO_xor_full (volatile AO_t *p, AO_t value) { __asm__ __volatile__ ("lock; xor %1, %0" : "+m" (*p) : "r" (value) : "memory"); } # define AO_HAVE_xor_full #endif /* !AO_PREFER_GENERALIZED */ AO_INLINE AO_TS_VAL_t AO_test_and_set_full (volatile AO_TS_t *addr) { AO_TS_t oldval; /* Note: the "xchg" instruction does not need a "lock" prefix */ __asm__ __volatile__ ("xchg %b0, %1" : "=q" (oldval), "+m" (*addr) : "0" (0xff) : "memory"); return (AO_TS_VAL_t)oldval; } #define AO_HAVE_test_and_set_full #ifndef AO_GENERALIZE_ASM_BOOL_CAS /* Returns nonzero if the comparison succeeded. */ AO_INLINE int AO_compare_and_swap_full(volatile AO_t *addr, AO_t old, AO_t new_val) { char result; __asm__ __volatile__ ("lock; cmpxchg %2, %0; setz %1" : "+m" (*addr), "=a" (result) : "r" (new_val), "a" (old) : "memory"); return (int) result; } # define AO_HAVE_compare_and_swap_full #endif /* !AO_GENERALIZE_ASM_BOOL_CAS */ AO_INLINE AO_t AO_fetch_compare_and_swap_full(volatile AO_t *addr, AO_t old_val, AO_t new_val) { AO_t fetched_val; __asm__ __volatile__ ("lock; cmpxchg %2, %0" : "+m" (*addr), "=a" (fetched_val) : "r" (new_val), "a" (old_val) : "memory"); return fetched_val; } #define AO_HAVE_fetch_compare_and_swap_full #if defined(__i386) # ifndef AO_NO_CMPXCHG8B # include "../standard_ao_double_t.h" /* Reading or writing a quadword aligned on a 64-bit boundary is */ /* always carried out atomically (requires at least a Pentium). */ # define AO_ACCESS_double_CHECK_ALIGNED # include "../loadstore/double_atomic_load_store.h" /* Returns nonzero if the comparison succeeded. */ /* Really requires at least a Pentium. */ AO_INLINE int AO_compare_double_and_swap_double_full(volatile AO_double_t *addr, AO_t old_val1, AO_t old_val2, AO_t new_val1, AO_t new_val2) { char result; __asm__ __volatile__ ("lock; cmpxchg8b %0; setz %1" : "+m" (*addr), "=a" (result) : "d" (old_val2), "a" (old_val1), "c" (new_val2), "b" (new_val1) : "memory"); return (int) result; } # define AO_HAVE_compare_double_and_swap_double_full # endif /* !AO_NO_CMPXCHG8B */ # define AO_T_IS_INT #else /* x64 */ AO_INLINE unsigned int AO_int_fetch_and_add_full (volatile unsigned int *p, unsigned int incr) { unsigned int result; __asm__ __volatile__ ("lock; xaddl %0, %1" : "=r" (result), "+m" (*p) : "0" (incr) : "memory"); return result; } # define AO_HAVE_int_fetch_and_add_full # ifdef AO_CMPXCHG16B_AVAILABLE # include "../standard_ao_double_t.h" /* Older AMD Opterons are missing this instruction (SIGILL should */ /* be thrown in this case). */ AO_INLINE int AO_compare_double_and_swap_double_full (volatile AO_double_t *addr, AO_t old_val1, AO_t old_val2, AO_t new_val1, AO_t new_val2) { char result; __asm__ __volatile__ ("lock; cmpxchg16b %0; setz %1" : "+m" (*addr), "=a" (result) : "d" (old_val2), "a" (old_val1), "c" (new_val2), "b" (new_val1) : "memory"); return (int) result; } # define AO_HAVE_compare_double_and_swap_double_full # endif /* !AO_CMPXCHG16B_AVAILABLE */ #endif /* x64 */ /* Real X86 implementations, except for some old 32-bit WinChips, */ /* appear to enforce ordering between memory operations, EXCEPT that */ /* a later read can pass earlier writes, presumably due to the visible */ /* presence of store buffers. */ /* We ignore both the WinChips and the fact that the official specs */ /* seem to be much weaker (and arguably too weak to be usable). */ #include "../ordered_except_wr.h" ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/test_and_set_t_is_ao_t.h000066400000000000000000000031341266352375300303450ustar00rootroot00000000000000/* * Copyright (c) 2004 Hewlett-Packard Development Company, L.P. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ /* * These are common definitions for architectures on which test_and_set * operates on pointer-sized quantities, the "clear" value contains * all zeroes, and the "set" value contains only one lowest bit set. * This can be used if test_and_set is synthesized from compare_and_swap. */ typedef enum {AO_TS_clear = 0, AO_TS_set = 1} AO_TS_val; #define AO_TS_VAL_t AO_TS_val #define AO_TS_CLEAR AO_TS_clear #define AO_TS_SET AO_TS_set #define AO_TS_t AO_t #define AO_AO_TS_T 1 ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops/sysdeps/test_and_set_t_is_char.h000066400000000000000000000030541266352375300303410ustar00rootroot00000000000000/* * Copyright (c) 2004 Hewlett-Packard Development Company, L.P. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ /* * These are common definitions for architectures on which test_and_set * operates on byte sized quantities, the "clear" value contains * all zeroes, and the "set" value contains all ones. */ #define AO_TS_t unsigned char typedef enum {AO_BYTE_TS_clear = 0, AO_BYTE_TS_set = 0xff} AO_BYTE_TS_val; #define AO_TS_VAL_t AO_BYTE_TS_val #define AO_TS_CLEAR AO_BYTE_TS_clear #define AO_TS_SET AO_BYTE_TS_set #define AO_CHAR_TS_T 1 ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops_malloc.c000066400000000000000000000175351266352375300235130ustar00rootroot00000000000000/* * Copyright (c) 2005 Hewlett-Packard Development Company, L.P. * * This file may be redistributed and/or modified under the * terms of the GNU General Public License as published by the Free Software * Foundation; either version 2, or (at your option) any later version. * * It 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 in the * file COPYING for more details. */ #if defined(HAVE_CONFIG_H) # include "config.h" #endif #define AO_REQUIRE_CAS #include "atomic_ops_malloc.h" #include /* for ffs, which is assumed reentrant. */ #include #include #ifdef AO_TRACE_MALLOC # include # include #endif #if (defined(_WIN32_WCE) || defined(__MINGW32CE__)) && !defined(abort) # define abort() _exit(-1) /* there is no abort() in WinCE */ #endif /* * We round up each allocation request to the next power of two * minus one word. * We keep one stack of free objects for each size. Each object * has an initial word (offset -sizeof(AO_t) from the visible pointer) * which contains either * The binary log of the object size in bytes (small objects) * The object size (a multiple of CHUNK_SIZE) for large objects. * The second case only arises if mmap-based allocation is supported. * We align the user-visible part of each object on a GRANULARITY * byte boundary. That means that the actual (hidden) start of * the object starts a word before this boundary. */ #ifndef LOG_MAX_SIZE # define LOG_MAX_SIZE 16 /* We assume that 2**LOG_MAX_SIZE is a multiple of page size. */ #endif #ifndef ALIGNMENT # define ALIGNMENT 16 /* Assumed to be at least sizeof(AO_t). */ #endif #define CHUNK_SIZE (1 << LOG_MAX_SIZE) #ifndef AO_INITIAL_HEAP_SIZE # define AO_INITIAL_HEAP_SIZE (2*(LOG_MAX_SIZE+1)*CHUNK_SIZE) #endif char AO_initial_heap[AO_INITIAL_HEAP_SIZE]; static volatile AO_t initial_heap_ptr = (AO_t)AO_initial_heap; #if defined(HAVE_MMAP) #include #include #include #include #if defined(MAP_ANONYMOUS) || defined(MAP_ANON) # define USE_MMAP_ANON #endif #ifdef USE_MMAP_FIXED # define GC_MMAP_FLAGS (MAP_FIXED | MAP_PRIVATE) /* Seems to yield better performance on Solaris 2, but can */ /* be unreliable if something is already mapped at the address. */ #else # define GC_MMAP_FLAGS MAP_PRIVATE #endif #ifdef USE_MMAP_ANON # ifdef MAP_ANONYMOUS # define OPT_MAP_ANON MAP_ANONYMOUS # else # define OPT_MAP_ANON MAP_ANON # endif #else # define OPT_MAP_ANON 0 #endif static volatile AO_t mmap_enabled = 0; void AO_malloc_enable_mmap(void) { # if defined(__sun) AO_store_release(&mmap_enabled, 1); /* Workaround for Sun CC */ # else AO_store(&mmap_enabled, 1); # endif } static char *get_mmaped(size_t sz) { char * result; # ifdef USE_MMAP_ANON # define zero_fd -1 # else int zero_fd; # endif assert(!(sz & (CHUNK_SIZE - 1))); if (!mmap_enabled) return 0; # ifndef USE_MMAP_ANON zero_fd = open("/dev/zero", O_RDONLY); if (zero_fd == -1) return 0; # endif result = mmap(0, sz, PROT_READ | PROT_WRITE, GC_MMAP_FLAGS | OPT_MAP_ANON, zero_fd, 0/* offset */); # ifndef USE_MMAP_ANON close(zero_fd); # endif if (result == MAP_FAILED) result = 0; return result; } /* Allocate an object of size (incl. header) of size > CHUNK_SIZE. */ /* sz includes space for an AO_t-sized header. */ static char * AO_malloc_large(size_t sz) { char * result; /* The header will force us to waste ALIGNMENT bytes, incl. header. */ sz += ALIGNMENT; /* Round to multiple of CHUNK_SIZE. */ sz = (sz + CHUNK_SIZE - 1) & ~(CHUNK_SIZE - 1); result = get_mmaped(sz); if (result == 0) return 0; result += ALIGNMENT; ((AO_t *)result)[-1] = (AO_t)sz; return result; } static void AO_free_large(char * p) { AO_t sz = ((AO_t *)p)[-1]; if (munmap(p - ALIGNMENT, (size_t)sz) != 0) abort(); /* Programmer error. Not really async-signal-safe, but ... */ } #else /* No MMAP */ void AO_malloc_enable_mmap(void) { } #define get_mmaped(sz) ((char*)0) #define AO_malloc_large(sz) ((char*)0) #define AO_free_large(p) abort() /* Programmer error. Not really async-signal-safe, but ... */ #endif /* No MMAP */ static char * get_chunk(void) { char *my_chunk_ptr; for (;;) { char *initial_ptr = (char *)AO_load(&initial_heap_ptr); my_chunk_ptr = (char *)(((AO_t)initial_ptr + (ALIGNMENT - 1)) & ~(ALIGNMENT - 1)); if (initial_ptr != my_chunk_ptr) { /* Align correctly. If this fails, someone else did it for us. */ (void)AO_compare_and_swap_acquire(&initial_heap_ptr, (AO_t)initial_ptr, (AO_t)my_chunk_ptr); } if (my_chunk_ptr - AO_initial_heap > AO_INITIAL_HEAP_SIZE - CHUNK_SIZE) break; if (AO_compare_and_swap(&initial_heap_ptr, (AO_t)my_chunk_ptr, (AO_t)(my_chunk_ptr + CHUNK_SIZE))) { return my_chunk_ptr; } } /* We failed. The initial heap is used up. */ my_chunk_ptr = get_mmaped(CHUNK_SIZE); assert (!((AO_t)my_chunk_ptr & (ALIGNMENT-1))); return my_chunk_ptr; } /* Object free lists. Ith entry corresponds to objects */ /* of total size 2**i bytes. */ AO_stack_t AO_free_list[LOG_MAX_SIZE+1]; /* Break up the chunk, and add it to the object free list for */ /* the given size. We have exclusive access to chunk. */ static void add_chunk_as(void * chunk, unsigned log_sz) { size_t ofs, limit; size_t sz = (size_t)1 << log_sz; assert (CHUNK_SIZE >= sz); limit = (size_t)CHUNK_SIZE - sz; for (ofs = ALIGNMENT - sizeof(AO_t); ofs <= limit; ofs += sz) { AO_stack_push(&AO_free_list[log_sz], (AO_t *)((char *)chunk + ofs)); } } static const int msbs[16] = {0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4}; /* Return the position of the most significant set bit in the */ /* argument. */ /* We follow the conventions of ffs(), i.e. the least */ /* significant bit is number one. */ static int msb(size_t s) { int result = 0; int v; if ((s & 0xff) != s) { /* The following is a tricky code ought to be equivalent to */ /* "(v = s >> 32) != 0" but suppresses warnings on 32-bit arch's. */ if (sizeof(size_t) > 4 && (v = s >> (sizeof(size_t) > 4 ? 32 : 0)) != 0) { s = v; result += 32; } if ((s >> 16) != 0) { s >>= 16; result += 16; } if ((s >> 8) != 0) { s >>= 8; result += 8; } } if (s > 15) { s >>= 4; result += 4; } result += msbs[s]; return result; } void * AO_malloc(size_t sz) { AO_t *result; int log_sz; if (sz > CHUNK_SIZE) return AO_malloc_large(sz); log_sz = msb(sz + (sizeof(AO_t) - 1)); result = AO_stack_pop(AO_free_list+log_sz); while (0 == result) { void * chunk = get_chunk(); if (0 == chunk) return 0; add_chunk_as(chunk, log_sz); result = AO_stack_pop(AO_free_list+log_sz); } *result = log_sz; # ifdef AO_TRACE_MALLOC fprintf(stderr, "%x: AO_malloc(%lu) = %p\n", (int)pthread_self(), (unsigned long)sz, result+1); # endif return result + 1; } void AO_free(void *p) { char *base = (char *)p - sizeof(AO_t); int log_sz; if (0 == p) return; log_sz = (int)(*(AO_t *)base); # ifdef AO_TRACE_MALLOC fprintf(stderr, "%x: AO_free(%p sz:%lu)\n", (int)pthread_self(), p, (unsigned long)(log_sz > LOG_MAX_SIZE? log_sz : (1 << log_sz))); # endif if (log_sz > LOG_MAX_SIZE) AO_free_large(p); else AO_stack_push(AO_free_list+log_sz, (AO_t *)base); } ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops_malloc.h000066400000000000000000000032011266352375300235010ustar00rootroot00000000000000/* * Copyright (c) 2005 Hewlett-Packard Development Company, L.P. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ /* Almost lock-free malloc implementation based on stack implementation. */ /* See doc/README_malloc.txt file for detailed usage rules. */ #ifndef AO_MALLOC_H #define AO_MALLOC_H #include "atomic_ops_stack.h" #include /* for size_t */ #ifdef AO_STACK_IS_LOCK_FREE # define AO_MALLOC_IS_LOCK_FREE #endif void AO_free(void *); void * AO_malloc(size_t); /* Allow use of mmap to grow the heap. No-op on some platforms. */ void AO_malloc_enable_mmap(void); #endif /* !AO_MALLOC_H */ ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops_stack.c000066400000000000000000000232151266352375300233410ustar00rootroot00000000000000/* * Copyright (c) 2005 Hewlett-Packard Development Company, L.P. * * This file may be redistributed and/or modified under the * terms of the GNU General Public License as published by the Free Software * Foundation; either version 2, or (at your option) any later version. * * It 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 in the * file COPYING for more details. */ #if defined(HAVE_CONFIG_H) # include "config.h" #endif #include #include #include #define AO_REQUIRE_CAS #include "atomic_ops_stack.h" #ifdef AO_USE_ALMOST_LOCK_FREE void AO_pause(int); /* defined in atomic_ops.c */ /* LIFO linked lists based on compare-and-swap. We need to avoid */ /* the case of a node deletion and reinsertion while I'm deleting */ /* it, since that may cause my CAS to succeed eventhough the next */ /* pointer is now wrong. Our solution is not fully lock-free, but it */ /* is good enough for signal handlers, provided we have a suitably low */ /* bound on the number of recursive signal handler reentries. */ /* A list consists of a first pointer and a blacklist */ /* of pointer values that are currently being removed. No list element */ /* on the blacklist may be inserted. If we would otherwise do so, we */ /* are allowed to insert a variant that differs only in the least */ /* significant, ignored, bits. If the list is full, we wait. */ /* Crucial observation: A particular padded pointer x (i.e. pointer */ /* plus arbitrary low order bits) can never be newly inserted into */ /* a list while it's in the corresponding auxiliary data structure. */ /* The second argument is a pointer to the link field of the element */ /* to be inserted. */ /* Both list headers and link fields contain "perturbed" pointers, i.e. */ /* pointers with extra bits "or"ed into the low order bits. */ void AO_stack_push_explicit_aux_release(volatile AO_t *list, AO_t *x, AO_stack_aux *a) { AO_t x_bits = (AO_t)x; AO_t next; /* No deletions of x can start here, since x is not currently in the */ /* list. */ retry: # if AO_BL_SIZE == 2 { /* Start all loads as close to concurrently as possible. */ AO_t entry1 = AO_load(a -> AO_stack_bl); AO_t entry2 = AO_load(a -> AO_stack_bl + 1); if (entry1 == x_bits || entry2 == x_bits) { /* Entry is currently being removed. Change it a little. */ ++x_bits; if ((x_bits & AO_BIT_MASK) == 0) /* Version count overflowed; */ /* EXTREMELY unlikely, but possible. */ x_bits = (AO_t)x; goto retry; } } # else { int i; for (i = 0; i < AO_BL_SIZE; ++i) { if (AO_load(a -> AO_stack_bl + i) == x_bits) { /* Entry is currently being removed. Change it a little. */ ++x_bits; if ((x_bits & AO_BIT_MASK) == 0) /* Version count overflowed; */ /* EXTREMELY unlikely, but possible. */ x_bits = (AO_t)x; goto retry; } } } # endif /* x_bits is not currently being deleted */ do { next = AO_load(list); *x = next; } while (AO_EXPECT_FALSE(!AO_compare_and_swap_release(list, next, x_bits))); } /* * I concluded experimentally that checking a value first before * performing a compare-and-swap is usually beneficial on X86, but * slows things down appreciably with contention on Itanium. * Since the Itanium behavior makes more sense to me (more cache line * movement unless we're mostly reading, but back-off should guard * against that), we take Itanium as the default. Measurements on * other multiprocessor architectures would be useful. (On a uniprocessor, * the initial check is almost certainly a very small loss.) - HB */ #ifdef __i386__ # define PRECHECK(a) (a) == 0 && #else # define PRECHECK(a) #endif AO_t * AO_stack_pop_explicit_aux_acquire(volatile AO_t *list, AO_stack_aux * a) { unsigned i; int j = 0; AO_t first; AO_t * first_ptr; AO_t next; retry: first = AO_load(list); if (0 == first) return 0; /* Insert first into aux black list. */ /* This may spin if more than AO_BL_SIZE removals using auxiliary */ /* structure a are currently in progress. */ for (i = 0; ; ) { if (PRECHECK(a -> AO_stack_bl[i]) AO_compare_and_swap_acquire(a->AO_stack_bl+i, 0, first)) break; ++i; if ( i >= AO_BL_SIZE ) { i = 0; AO_pause(++j); } } assert(i < AO_BL_SIZE); assert(a -> AO_stack_bl[i] == first); /* First is on the auxiliary black list. It may be removed by */ /* another thread before we get to it, but a new insertion of x */ /* cannot be started here. */ /* Only we can remove it from the black list. */ /* We need to make sure that first is still the first entry on the */ /* list. Otherwise it's possible that a reinsertion of it was */ /* already started before we added the black list entry. */ # if defined(__alpha__) && (__GNUC__ == 4) if (first != AO_load(list)) /* Workaround __builtin_expect bug found in */ /* gcc-4.6.3/alpha causing test_stack failure. */ # else if (AO_EXPECT_FALSE(first != AO_load(list))) # endif { AO_store_release(a->AO_stack_bl+i, 0); goto retry; } first_ptr = AO_REAL_NEXT_PTR(first); next = AO_load(first_ptr); # if defined(__alpha__) && (__GNUC__ == 4) if (!AO_compare_and_swap_release(list, first, next)) # else if (AO_EXPECT_FALSE(!AO_compare_and_swap_release(list, first, next))) # endif { AO_store_release(a->AO_stack_bl+i, 0); goto retry; } assert(*list != first); /* Since we never insert an entry on the black list, this cannot have */ /* succeeded unless first remained on the list while we were running. */ /* Thus its next link cannot have changed out from under us, and we */ /* removed exactly one entry and preserved the rest of the list. */ /* Note that it is quite possible that an additional entry was */ /* inserted and removed while we were running; this is OK since the */ /* part of the list following first must have remained unchanged, and */ /* first must again have been at the head of the list when the */ /* compare_and_swap succeeded. */ AO_store_release(a->AO_stack_bl+i, 0); return first_ptr; } #else /* ! USE_ALMOST_LOCK_FREE */ /* Better names for fields in AO_stack_t */ #define ptr AO_val2 #define version AO_val1 #if defined(AO_HAVE_compare_double_and_swap_double) void AO_stack_push_release(AO_stack_t *list, AO_t *element) { AO_t next; do { next = AO_load(&(list -> ptr)); *element = next; } while (AO_EXPECT_FALSE(!AO_compare_and_swap_release(&(list -> ptr), next, (AO_t)element))); /* This uses a narrow CAS here, an old optimization suggested */ /* by Treiber. Pop is still safe, since we run into the ABA */ /* problem only if there were both intervening "pop"s and "push"es. */ /* In that case we still see a change in the version number. */ } AO_t *AO_stack_pop_acquire(AO_stack_t *list) { # ifdef __clang__ AO_t *volatile cptr; /* Use volatile to workaround a bug in */ /* clang-1.1/x86 causing test_stack failure. */ # else AO_t *cptr; # endif AO_t next; AO_t cversion; do { /* Version must be loaded first. */ cversion = AO_load_acquire(&(list -> version)); cptr = (AO_t *)AO_load(&(list -> ptr)); if (cptr == 0) return 0; next = *cptr; } while (AO_EXPECT_FALSE(!AO_compare_double_and_swap_double_release(list, cversion, (AO_t)cptr, cversion+1, (AO_t)next))); return cptr; } #elif defined(AO_HAVE_compare_and_swap_double) /* Needed for future IA64 processors. No current clients? */ #error Untested! Probably doesnt work. /* We have a wide CAS, but only does an AO_t-wide comparison. */ /* We can't use the Treiber optimization, since we only check */ /* for an unchanged version number, not an unchanged pointer. */ void AO_stack_push_release(AO_stack_t *list, AO_t *element) { AO_t version; AO_t next_ptr; do { /* Again version must be loaded first, for different reason. */ version = AO_load_acquire(&(list -> version)); next_ptr = AO_load(&(list -> ptr)); *element = next_ptr; } while (!AO_compare_and_swap_double_release( list, version, version+1, (AO_t) element)); } AO_t *AO_stack_pop_acquire(AO_stack_t *list) { AO_t *cptr; AO_t next; AO_t cversion; do { cversion = AO_load_acquire(&(list -> version)); cptr = (AO_t *)AO_load(&(list -> ptr)); if (cptr == 0) return 0; next = *cptr; } while (!AO_compare_double_and_swap_double_release (list, cversion, (AO_t) cptr, cversion+1, next)); return cptr; } #endif /* AO_HAVE_compare_and_swap_double */ #endif /* ! USE_ALMOST_LOCK_FREE */ ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops_stack.h000066400000000000000000000147161266352375300233540ustar00rootroot00000000000000/* * The implementation of the routines described here is covered by the GPL. * This header file is covered by the following license: */ /* * Copyright (c) 2005 Hewlett-Packard Development Company, L.P. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ /* Almost lock-free LIFO linked lists (linked stacks). */ #ifndef AO_STACK_H #define AO_STACK_H #include "atomic_ops.h" #if !defined(AO_HAVE_compare_double_and_swap_double) \ && !defined(AO_HAVE_compare_double_and_swap) \ && defined(AO_HAVE_compare_and_swap) # define AO_USE_ALMOST_LOCK_FREE #else /* If we have no compare-and-swap operation defined, we assume */ /* that we will actually be using CAS emulation. If we do that, */ /* it's cheaper to use the version-based implementation. */ # define AO_STACK_IS_LOCK_FREE #endif /* * These are not guaranteed to be completely lock-free. * List insertion may spin under extremely unlikely conditions. * It cannot deadlock due to recursive reentry unless AO_list_remove * is called while at least AO_BL_SIZE activations of * AO_list_remove are currently active in the same thread, i.e. * we must have at least AO_BL_SIZE recursive signal handler * invocations. * * All operations take an AO_list_aux argument. It is safe to * share a single AO_list_aux structure among all lists, but that * may increase contention. Any given list must always be accessed * with the same AO_list_aux structure. * * We make some machine-dependent assumptions: * - We have a compare-and-swap operation. * - At least _AO_N_BITS low order bits in pointers are * zero and normally unused. * - size_t and pointers have the same size. * * We do use a fully lock-free implementation if double-width * compare-and-swap operations are available. */ #ifdef AO_USE_ALMOST_LOCK_FREE /* The number of low order pointer bits we can use for a small */ /* version number. */ # if defined(__LP64__) || defined(_LP64) || defined(_WIN64) /* WIN64 isn't really supported yet. */ # define AO_N_BITS 3 # else # define AO_N_BITS 2 # endif # define AO_BIT_MASK ((1 << AO_N_BITS) - 1) /* * AO_stack_aux should be treated as opaque. * It is fully defined here, so it can be allocated, and to facilitate * debugging. */ #ifndef AO_BL_SIZE # define AO_BL_SIZE 2 #endif #if AO_BL_SIZE > (1 << AO_N_BITS) # error AO_BL_SIZE too big #endif typedef struct AO__stack_aux { volatile AO_t AO_stack_bl[AO_BL_SIZE]; } AO_stack_aux; /* The stack implementation knows only about the location of */ /* link fields in nodes, and nothing about the rest of the */ /* stack elements. Link fields hold an AO_t, which is not */ /* necessarily a real pointer. This converts the AO_t to a */ /* real (AO_t *) which is either o, or points at the link */ /* field in the next node. */ #define AO_REAL_NEXT_PTR(x) (AO_t *)((x) & ~AO_BIT_MASK) /* The following two routines should not normally be used directly. */ /* We make them visible here for the rare cases in which it makes sense */ /* to share the an AO_stack_aux between stacks. */ void AO_stack_push_explicit_aux_release(volatile AO_t *list, AO_t *x, AO_stack_aux *); AO_t * AO_stack_pop_explicit_aux_acquire(volatile AO_t *list, AO_stack_aux *); /* And now AO_stack_t for the real interface: */ typedef struct AO__stack { volatile AO_t AO_ptr; AO_stack_aux AO_aux; } AO_stack_t; #define AO_STACK_INITIALIZER {0,{{0}}} AO_INLINE void AO_stack_init(AO_stack_t *list) { # if AO_BL_SIZE == 2 list -> AO_aux.AO_stack_bl[0] = 0; list -> AO_aux.AO_stack_bl[1] = 0; # else int i; for (i = 0; i < AO_BL_SIZE; ++i) list -> AO_aux.AO_stack_bl[i] = 0; # endif list -> AO_ptr = 0; } /* Convert an AO_stack_t to a pointer to the link field in */ /* the first element. */ #define AO_REAL_HEAD_PTR(x) AO_REAL_NEXT_PTR((x).AO_ptr) #define AO_stack_push_release(l, e) \ AO_stack_push_explicit_aux_release(&((l)->AO_ptr), e, &((l)->AO_aux)) #define AO_HAVE_stack_push_release #define AO_stack_pop_acquire(l) \ AO_stack_pop_explicit_aux_acquire(&((l)->AO_ptr), &((l)->AO_aux)) #define AO_HAVE_stack_pop_acquire # else /* Use fully non-blocking data structure, wide CAS */ #ifndef AO_HAVE_double_t /* Can happen if we're using CAS emulation, since we don't want to */ /* force that here, in case other atomic_ops clients don't want it. */ # include "atomic_ops/sysdeps/standard_ao_double_t.h" #endif typedef volatile AO_double_t AO_stack_t; /* AO_val1 is version, AO_val2 is pointer. */ #define AO_STACK_INITIALIZER AO_DOUBLE_T_INITIALIZER AO_INLINE void AO_stack_init(AO_stack_t *list) { list -> AO_val1 = 0; list -> AO_val2 = 0; } #define AO_REAL_HEAD_PTR(x) (AO_t *)((x).AO_val2) #define AO_REAL_NEXT_PTR(x) (AO_t *)(x) void AO_stack_push_release(AO_stack_t *list, AO_t *new_element); #define AO_HAVE_stack_push_release AO_t * AO_stack_pop_acquire(AO_stack_t *list); #define AO_HAVE_stack_pop_acquire #endif /* Wide CAS case */ #if defined(AO_HAVE_stack_push_release) && !defined(AO_HAVE_stack_push) # define AO_stack_push(l, e) AO_stack_push_release(l, e) # define AO_HAVE_stack_push #endif #if defined(AO_HAVE_stack_pop_acquire) && !defined(AO_HAVE_stack_pop) # define AO_stack_pop(l) AO_stack_pop_acquire(l) # define AO_HAVE_stack_pop #endif #endif /* !AO_STACK_H */ ecl-16.1.2/src/bdwgc/libatomic_ops/src/atomic_ops_sysdeps.S000066400000000000000000000004621266352375300237050ustar00rootroot00000000000000/* * Include the appropriate system-dependent assembly file, if any. * This is used only if the platform supports neither inline assembly * code, nor appropriate compiler intrinsics. */ #if !defined(__GNUC__) && (defined(sparc) || defined(__sparc)) # include "atomic_ops/sysdeps/sunc/sparc.S" #endif ecl-16.1.2/src/bdwgc/libatomic_ops/src/config.h.in000066400000000000000000000100031266352375300216650ustar00rootroot00000000000000/* src/config.h.in. Generated from configure.ac by autoheader. */ /* Inline assembly avalable (only VC/x86_64) */ #undef AO_ASM_X64_AVAILABLE /* Assume Windows Server 2003, Vista or later target (only VC/x86) */ #undef AO_ASSUME_VISTA /* Assume hardware compare-and-swap functionality available on target (only VC/x86) */ #undef AO_ASSUME_WINDOWS98 /* Assume target is not old AMD Opteron chip (only x86_64) */ #undef AO_CMPXCHG16B_AVAILABLE /* Force test_and_set to use SWP instruction instead of LDREX/STREX (only arm v6+) */ #undef AO_FORCE_USE_SWP /* Force compare_and_swap definition via fetch_compare_and_swap */ #undef AO_GENERALIZE_ASM_BOOL_CAS /* No pthreads library available */ #undef AO_NO_PTHREADS /* Assume target is not sparc v9+ (only sparc) */ #undef AO_NO_SPARC_V9 /* Assume ancient MS VS Win32 headers (only VC/arm v6+, VC/x86) */ #undef AO_OLD_STYLE_INTERLOCKED_COMPARE_EXCHANGE /* Prefer generalized definitions to direct assembly-based ones */ #undef AO_PREFER_GENERALIZED /* Trace AO_malloc/free calls (for debug only) */ #undef AO_TRACE_MALLOC /* Assume single-core target (only arm v6+) */ #undef AO_UNIPROCESSOR /* Assume Win32 _Interlocked primitives available as intrinsics (only VC/arm) */ #undef AO_USE_INTERLOCKED_INTRINSICS /* Use nanosleep() instead of select() (only if atomic operations are emulated) */ #undef AO_USE_NANOSLEEP /* Do not block signals in compare_and_swap (only if atomic operations are emulated) */ #undef AO_USE_NO_SIGNALS /* Use Pentium 4 'mfence' instruction (only x86) */ #undef AO_USE_PENTIUM4_INSTRS /* Emulate atomic operations via slow and async-signal-unsafe pthread locking */ #undef AO_USE_PTHREAD_DEFS /* Prefer GCC built-in CAS intrinsics in favor of inline assembly (only gcc/x86, gcc/x86_64) */ #undef AO_USE_SYNC_CAS_BUILTIN /* Use Win32 Sleep() instead of select() (only if atomic operations are emulated) */ #undef AO_USE_WIN32_PTHREADS /* Emulate double-width CAS via pthread locking in case of no hardware support (only gcc/x86_64, the emulation is unsafe) */ #undef AO_WEAK_DOUBLE_CAS_EMULATION /* Define to 1 if you have the header file. */ #undef HAVE_DLFCN_H /* Define to 1 if you have the `getpagesize' function. */ #undef HAVE_GETPAGESIZE /* 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 a working `mmap' system call. */ #undef HAVE_MMAP /* 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_PARAM_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 where libtool stores uninstalled libraries. */ #undef LT_OBJDIR /* Define to disable assertion checking. */ #undef NDEBUG /* 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 /* Indicates the use of pthreads (NetBSD). */ #undef _PTHREADS /* Required define if using POSIX threads. */ #undef _REENTRANT ecl-16.1.2/src/bdwgc/libatomic_ops/tests/000077500000000000000000000000001266352375300202235ustar00rootroot00000000000000ecl-16.1.2/src/bdwgc/libatomic_ops/tests/Makefile.am000066400000000000000000000123021266352375300222550ustar00rootroot00000000000000EXTRA_DIST=test_atomic_include.template list_atomic.template run_parallel.h \ test_atomic_include.h list_atomic.c # We distribute test_atomic_include.h and list_atomic.c, since it is hard # to regenerate them on Windows without sed. BUILT_SOURCES = test_atomic_include.h list_atomic.i list_atomic.o CLEANFILES = list_atomic.i list_atomic.o AM_CPPFLAGS = \ -I$(top_builddir)/src -I$(top_srcdir)/src \ -I$(top_builddir)/tests -I$(top_srcdir)/tests if HAVE_PTHREAD_H TESTS=test_atomic test_atomic_pthreads test_stack test_malloc test_atomic_pthreads_SOURCES=$(test_atomic_SOURCES) test_atomic_pthreads_CPPFLAGS=-DAO_USE_PTHREAD_DEFS $(AM_CPPFLAGS) test_atomic_pthreads_LDADD=$(test_atomic_LDADD) else TESTS=test_atomic test_stack test_malloc endif check_PROGRAMS=$(TESTS) test_atomic_SOURCES=test_atomic.c test_atomic_LDADD = $(THREADDLLIBS) $(top_builddir)/src/libatomic_ops.la test_stack_SOURCES=test_stack.c test_stack_LDADD = $(THREADDLLIBS) \ $(top_builddir)/src/libatomic_ops_gpl.la \ $(top_builddir)/src/libatomic_ops.la test_malloc_SOURCES=test_malloc.c test_malloc_LDADD = $(THREADDLLIBS) \ $(top_builddir)/src/libatomic_ops_gpl.la \ $(top_builddir)/src/libatomic_ops.la test_atomic_include.h: test_atomic_include.template mkdir -p `dirname $@` sed -e s:XX::g $? > $@ sed -e s:XX:_release:g $? >> $@ sed -e s:XX:_acquire:g $? >> $@ sed -e s:XX:_read:g $? >> $@ sed -e s:XX:_write:g $? >> $@ sed -e s:XX:_full:g $? >> $@ sed -e s:XX:_release_write:g $? >> $@ sed -e s:XX:_acquire_read:g $? >> $@ list_atomic.c: list_atomic.template mkdir -p `dirname $@` echo "#include \"atomic_ops.h\"" > $@ sed -e s:XSIZE_::g -e s:XCTYPE:AO_t:g -e s:XX::g $? >> $@ sed -e s:XSIZE_::g -e s:XCTYPE:AO_t:g -e s:XX:_release:g $? >> $@ sed -e s:XSIZE_::g -e s:XCTYPE:AO_t:g -e s:XX:_acquire:g $? >> $@ sed -e s:XSIZE_::g -e s:XCTYPE:AO_t:g -e s:XX:_read:g $? >> $@ sed -e s:XSIZE_::g -e s:XCTYPE:AO_t:g -e s:XX:_write:g $? >> $@ sed -e s:XSIZE_::g -e s:XCTYPE:AO_t:g -e s:XX:_full:g $? >> $@ sed -e s:XSIZE_::g -e s:XCTYPE:AO_t:g -e s:XX:_release_write:g $? >> $@ sed -e s:XSIZE_::g -e s:XCTYPE:AO_t:g -e s:XX:_acquire_read:g $? >> $@ sed -e s:XSIZE_::g -e s:XCTYPE:AO_t:g -e s:XX:_dd_acquire_read:g $? >> $@ sed -e s:XSIZE:char:g -e s:XCTYPE:unsigned/**/char:g -e s:XX::g $? >> $@ sed -e s:XSIZE:char:g -e s:XCTYPE:unsigned/**/char:g -e s:XX:_release:g $? >> $@ sed -e s:XSIZE:char:g -e s:XCTYPE:unsigned/**/char:g -e s:XX:_acquire:g $? >> $@ sed -e s:XSIZE:char:g -e s:XCTYPE:unsigned/**/char:g -e s:XX:_read:g $? >> $@ sed -e s:XSIZE:char:g -e s:XCTYPE:unsigned/**/char:g -e s:XX:_write:g $? >> $@ sed -e s:XSIZE:char:g -e s:XCTYPE:unsigned/**/char:g -e s:XX:_full:g $? >> $@ sed -e s:XSIZE:char:g -e s:XCTYPE:unsigned/**/char:g -e s:XX:_release_write:g $? >> $@ sed -e s:XSIZE:char:g -e s:XCTYPE:unsigned/**/char:g -e s:XX:_acquire_read:g $? >> $@ sed -e s:XSIZE:char:g -e s:XCTYPE:unsigned/**/char:g -e s:XX:_dd_acquire_read:g $? >> $@ sed -e s:XSIZE:short:g -e s:XCTYPE:unsigned/**/short:g -e s:XX::g $? >> $@ sed -e s:XSIZE:short:g -e s:XCTYPE:unsigned/**/short:g -e s:XX:_release:g $? >> $@ sed -e s:XSIZE:short:g -e s:XCTYPE:unsigned/**/short:g -e s:XX:_acquire:g $? >> $@ sed -e s:XSIZE:short:g -e s:XCTYPE:unsigned/**/short:g -e s:XX:_read:g $? >> $@ sed -e s:XSIZE:short:g -e s:XCTYPE:unsigned/**/short:g -e s:XX:_write:g $? >> $@ sed -e s:XSIZE:short:g -e s:XCTYPE:unsigned/**/short:g -e s:XX:_full:g $? >> $@ sed -e s:XSIZE:short:g -e s:XCTYPE:unsigned/**/short:g -e s:XX:_release_write:g $? >> $@ sed -e s:XSIZE:short:g -e s:XCTYPE:unsigned/**/short:g -e s:XX:_acquire_read:g $? >> $@ sed -e s:XSIZE:short:g -e s:XCTYPE:unsigned/**/short:g -e s:XX:_dd_acquire_read:g $? >> $@ sed -e s:XSIZE:int:g -e s:XCTYPE:unsigned:g -e s:XX::g $? >> $@ sed -e s:XSIZE:int:g -e s:XCTYPE:unsigned:g -e s:XX:_release:g $? >> $@ sed -e s:XSIZE:int:g -e s:XCTYPE:unsigned:g -e s:XX:_acquire:g $? >> $@ sed -e s:XSIZE:int:g -e s:XCTYPE:unsigned:g -e s:XX:_read:g $? >> $@ sed -e s:XSIZE:int:g -e s:XCTYPE:unsigned:g -e s:XX:_write:g $? >> $@ sed -e s:XSIZE:int:g -e s:XCTYPE:unsigned:g -e s:XX:_full:g $? >> $@ sed -e s:XSIZE:int:g -e s:XCTYPE:unsigned:g -e s:XX:_release_write:g $? >> $@ sed -e s:XSIZE:int:g -e s:XCTYPE:unsigned:g -e s:XX:_acquire_read:g $? >> $@ sed -e s:XSIZE:int:g -e s:XCTYPE:unsigned:g -e s:XX:_dd_acquire_read:g $? >> $@ sed -e s:XSIZE:double:g -e s:XCTYPE:AO_double_t:g -e s:XX::g $? >> $@ sed -e s:XSIZE:double:g -e s:XCTYPE:AO_double_t:g -e s:XX:_release:g $? >> $@ sed -e s:XSIZE:double:g -e s:XCTYPE:AO_double_t:g -e s:XX:_acquire:g $? >> $@ sed -e s:XSIZE:double:g -e s:XCTYPE:AO_double_t:g -e s:XX:_read:g $? >> $@ sed -e s:XSIZE:double:g -e s:XCTYPE:AO_double_t:g -e s:XX:_write:g $? >> $@ sed -e s:XSIZE:double:g -e s:XCTYPE:AO_double_t:g -e s:XX:_full:g $? >> $@ sed -e s:XSIZE:double:g -e s:XCTYPE:AO_double_t:g -e s:XX:_release_write:g $? >> $@ sed -e s:XSIZE:double:g -e s:XCTYPE:AO_double_t:g -e s:XX:_acquire_read:g $? >> $@ sed -e s:XSIZE:double:g -e s:XCTYPE:AO_double_t:g -e s:XX:_dd_acquire_read:g $? >> $@ list_atomic.i: list_atomic.c mkdir -p `dirname $@` $(COMPILE) $? -E > $@ # Verify list_atomic.c syntax: list_atomic.o: list_atomic.c $(COMPILE) -c -o $@ $? ecl-16.1.2/src/bdwgc/libatomic_ops/tests/Makefile.in000066400000000000000000001233131266352375300222730ustar00rootroot00000000000000# Makefile.in generated by automake 1.15 from Makefile.am. # @configure_input@ # Copyright (C) 1994-2014 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__is_gnu_make = { \ if test -z '$(MAKELEVEL)'; then \ false; \ elif test -n '$(MAKE_HOST)'; then \ true; \ elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \ true; \ else \ false; \ fi; \ } am__make_running_with_option = \ case $${target_option-} in \ ?) ;; \ *) echo "am__make_running_with_option: internal error: invalid" \ "target option '$${target_option-}' specified" >&2; \ exit 1;; \ esac; \ has_opt=no; \ sane_makeflags=$$MAKEFLAGS; \ if $(am__is_gnu_make); then \ sane_makeflags=$$MFLAGS; \ else \ case $$MAKEFLAGS in \ *\\[\ \ ]*) \ bs=\\; \ sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \ | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \ esac; \ fi; \ skip_next=no; \ strip_trailopt () \ { \ flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \ }; \ for flg in $$sane_makeflags; do \ test $$skip_next = yes && { skip_next=no; continue; }; \ case $$flg in \ *=*|--*) continue;; \ -*I) strip_trailopt 'I'; skip_next=yes;; \ -*I?*) strip_trailopt 'I';; \ -*O) strip_trailopt 'O'; skip_next=yes;; \ -*O?*) strip_trailopt 'O';; \ -*l) strip_trailopt 'l'; skip_next=yes;; \ -*l?*) strip_trailopt 'l';; \ -[dEDm]) skip_next=yes;; \ -[JT]) skip_next=yes;; \ esac; \ case $$flg in \ *$$target_option*) has_opt=yes; break;; \ esac; \ done; \ test $$has_opt = yes am__make_dryrun = (target_option=n; $(am__make_running_with_option)) am__make_keepgoing = (target_option=k; $(am__make_running_with_option)) 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@ target_triplet = @target@ @HAVE_PTHREAD_H_FALSE@TESTS = test_atomic$(EXEEXT) test_stack$(EXEEXT) \ @HAVE_PTHREAD_H_FALSE@ test_malloc$(EXEEXT) @HAVE_PTHREAD_H_TRUE@TESTS = test_atomic$(EXEEXT) \ @HAVE_PTHREAD_H_TRUE@ test_atomic_pthreads$(EXEEXT) \ @HAVE_PTHREAD_H_TRUE@ test_stack$(EXEEXT) test_malloc$(EXEEXT) check_PROGRAMS = $(am__EXEEXT_1) subdir = tests 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) DIST_COMMON = $(srcdir)/Makefile.am $(am__DIST_COMMON) mkinstalldirs = $(install_sh) -d CONFIG_HEADER = $(top_builddir)/src/config.h CONFIG_CLEAN_FILES = CONFIG_CLEAN_VPATH_FILES = @HAVE_PTHREAD_H_FALSE@am__EXEEXT_1 = test_atomic$(EXEEXT) \ @HAVE_PTHREAD_H_FALSE@ test_stack$(EXEEXT) test_malloc$(EXEEXT) @HAVE_PTHREAD_H_TRUE@am__EXEEXT_1 = test_atomic$(EXEEXT) \ @HAVE_PTHREAD_H_TRUE@ test_atomic_pthreads$(EXEEXT) \ @HAVE_PTHREAD_H_TRUE@ test_stack$(EXEEXT) test_malloc$(EXEEXT) am_test_atomic_OBJECTS = test_atomic.$(OBJEXT) test_atomic_OBJECTS = $(am_test_atomic_OBJECTS) am__DEPENDENCIES_1 = test_atomic_DEPENDENCIES = $(am__DEPENDENCIES_1) \ $(top_builddir)/src/libatomic_ops.la 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 = am__test_atomic_pthreads_SOURCES_DIST = test_atomic.c am__objects_1 = test_atomic_pthreads-test_atomic.$(OBJEXT) @HAVE_PTHREAD_H_TRUE@am_test_atomic_pthreads_OBJECTS = \ @HAVE_PTHREAD_H_TRUE@ $(am__objects_1) test_atomic_pthreads_OBJECTS = $(am_test_atomic_pthreads_OBJECTS) am__DEPENDENCIES_2 = $(am__DEPENDENCIES_1) \ $(top_builddir)/src/libatomic_ops.la @HAVE_PTHREAD_H_TRUE@test_atomic_pthreads_DEPENDENCIES = \ @HAVE_PTHREAD_H_TRUE@ $(am__DEPENDENCIES_2) am_test_malloc_OBJECTS = test_malloc.$(OBJEXT) test_malloc_OBJECTS = $(am_test_malloc_OBJECTS) test_malloc_DEPENDENCIES = $(am__DEPENDENCIES_1) \ $(top_builddir)/src/libatomic_ops_gpl.la \ $(top_builddir)/src/libatomic_ops.la am_test_stack_OBJECTS = test_stack.$(OBJEXT) test_stack_OBJECTS = $(am_test_stack_OBJECTS) test_stack_DEPENDENCIES = $(am__DEPENDENCIES_1) \ $(top_builddir)/src/libatomic_ops_gpl.la \ $(top_builddir)/src/libatomic_ops.la 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 = depcomp = $(SHELL) $(top_srcdir)/../depcomp am__depfiles_maybe = depfiles am__mv = mv -f COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \ $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) LTCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \ $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) \ $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \ $(AM_CFLAGS) $(CFLAGS) AM_V_CC = $(am__v_CC_@AM_V@) am__v_CC_ = $(am__v_CC_@AM_DEFAULT_V@) am__v_CC_0 = @echo " CC " $@; am__v_CC_1 = CCLD = $(CC) LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \ $(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \ $(AM_LDFLAGS) $(LDFLAGS) -o $@ AM_V_CCLD = $(am__v_CCLD_@AM_V@) am__v_CCLD_ = $(am__v_CCLD_@AM_DEFAULT_V@) am__v_CCLD_0 = @echo " CCLD " $@; am__v_CCLD_1 = SOURCES = $(test_atomic_SOURCES) $(test_atomic_pthreads_SOURCES) \ $(test_malloc_SOURCES) $(test_stack_SOURCES) DIST_SOURCES = $(test_atomic_SOURCES) \ $(am__test_atomic_pthreads_SOURCES_DIST) \ $(test_malloc_SOURCES) $(test_stack_SOURCES) am__can_run_installinfo = \ case $$AM_UPDATE_INFO_DIR in \ n|no|NO) false;; \ *) (install-info --version) >/dev/null 2>&1;; \ esac am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP) # Read a list of newline-separated strings from the standard input, # and print each of them once, without duplicates. Input order is # *not* preserved. am__uniquify_input = $(AWK) '\ BEGIN { nonempty = 0; } \ { items[$$0] = 1; nonempty = 1; } \ END { if (nonempty) { for (i in items) print i; }; } \ ' # Make sure the list of sources is unique. This is necessary because, # e.g., the same source file might be shared among _SOURCES variables # for different programs/libraries. am__define_uniq_tagged_files = \ list='$(am__tagged_files)'; \ unique=`for i in $$list; do \ if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ done | $(am__uniquify_input)` ETAGS = etags CTAGS = ctags am__tty_colors_dummy = \ mgn= red= grn= lgn= blu= brg= std=; \ am__color_tests=no am__tty_colors = { \ $(am__tty_colors_dummy); \ if test "X$(AM_COLOR_TESTS)" = Xno; then \ am__color_tests=no; \ elif test "X$(AM_COLOR_TESTS)" = Xalways; then \ am__color_tests=yes; \ elif test "X$$TERM" != Xdumb && { test -t 1; } 2>/dev/null; then \ am__color_tests=yes; \ fi; \ if test $$am__color_tests = yes; then \ red=''; \ grn=''; \ lgn=''; \ blu=''; \ mgn=''; \ brg=''; \ std=''; \ fi; \ } 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__recheck_rx = ^[ ]*:recheck:[ ]* am__global_test_result_rx = ^[ ]*:global-test-result:[ ]* am__copy_in_global_log_rx = ^[ ]*:copy-in-global-log:[ ]* # A command that, given a newline-separated list of test names on the # standard input, print the name of the tests that are to be re-run # upon "make recheck". am__list_recheck_tests = $(AWK) '{ \ recheck = 1; \ while ((rc = (getline line < ($$0 ".trs"))) != 0) \ { \ if (rc < 0) \ { \ if ((getline line2 < ($$0 ".log")) < 0) \ recheck = 0; \ break; \ } \ else if (line ~ /$(am__recheck_rx)[nN][Oo]/) \ { \ recheck = 0; \ break; \ } \ else if (line ~ /$(am__recheck_rx)[yY][eE][sS]/) \ { \ break; \ } \ }; \ if (recheck) \ print $$0; \ close ($$0 ".trs"); \ close ($$0 ".log"); \ }' # A command that, given a newline-separated list of test names on the # standard input, create the global log from their .trs and .log files. am__create_global_log = $(AWK) ' \ function fatal(msg) \ { \ print "fatal: making $@: " msg | "cat >&2"; \ exit 1; \ } \ function rst_section(header) \ { \ print header; \ len = length(header); \ for (i = 1; i <= len; i = i + 1) \ printf "="; \ printf "\n\n"; \ } \ { \ copy_in_global_log = 1; \ global_test_result = "RUN"; \ while ((rc = (getline line < ($$0 ".trs"))) != 0) \ { \ if (rc < 0) \ fatal("failed to read from " $$0 ".trs"); \ if (line ~ /$(am__global_test_result_rx)/) \ { \ sub("$(am__global_test_result_rx)", "", line); \ sub("[ ]*$$", "", line); \ global_test_result = line; \ } \ else if (line ~ /$(am__copy_in_global_log_rx)[nN][oO]/) \ copy_in_global_log = 0; \ }; \ if (copy_in_global_log) \ { \ rst_section(global_test_result ": " $$0); \ while ((rc = (getline line < ($$0 ".log"))) != 0) \ { \ if (rc < 0) \ fatal("failed to read from " $$0 ".log"); \ print line; \ }; \ printf "\n"; \ }; \ close ($$0 ".trs"); \ close ($$0 ".log"); \ }' # Restructured Text title. am__rst_title = { sed 's/.*/ & /;h;s/./=/g;p;x;s/ *$$//;p;g' && echo; } # Solaris 10 'make', and several other traditional 'make' implementations, # pass "-e" to $(SHELL), and POSIX 2008 even requires this. Work around it # by disabling -e (using the XSI extension "set +e") if it's set. am__sh_e_setup = case $$- in *e*) set +e;; esac # Default flags passed to test drivers. am__common_driver_flags = \ --color-tests "$$am__color_tests" \ --enable-hard-errors "$$am__enable_hard_errors" \ --expect-failure "$$am__expect_failure" # To be inserted before the command running the test. Creates the # directory for the log if needed. Stores in $dir the directory # containing $f, in $tst the test, in $log the log. Executes the # developer- defined test setup AM_TESTS_ENVIRONMENT (if any), and # passes TESTS_ENVIRONMENT. Set up options for the wrapper that # will run the test scripts (or their associated LOG_COMPILER, if # thy have one). am__check_pre = \ $(am__sh_e_setup); \ $(am__vpath_adj_setup) $(am__vpath_adj) \ $(am__tty_colors); \ srcdir=$(srcdir); export srcdir; \ case "$@" in \ */*) am__odir=`echo "./$@" | sed 's|/[^/]*$$||'`;; \ *) am__odir=.;; \ esac; \ test "x$$am__odir" = x"." || test -d "$$am__odir" \ || $(MKDIR_P) "$$am__odir" || exit $$?; \ if test -f "./$$f"; then dir=./; \ elif test -f "$$f"; then dir=; \ else dir="$(srcdir)/"; fi; \ tst=$$dir$$f; log='$@'; \ if test -n '$(DISABLE_HARD_ERRORS)'; then \ am__enable_hard_errors=no; \ else \ am__enable_hard_errors=yes; \ fi; \ case " $(XFAIL_TESTS) " in \ *[\ \ ]$$f[\ \ ]* | *[\ \ ]$$dir$$f[\ \ ]*) \ am__expect_failure=yes;; \ *) \ am__expect_failure=no;; \ esac; \ $(AM_TESTS_ENVIRONMENT) $(TESTS_ENVIRONMENT) # A shell command to get the names of the tests scripts with any registered # extension removed (i.e., equivalently, the names of the test logs, with # the '.log' extension removed). The result is saved in the shell variable # '$bases'. This honors runtime overriding of TESTS and TEST_LOGS. Sadly, # we cannot use something simpler, involving e.g., "$(TEST_LOGS:.log=)", # since that might cause problem with VPATH rewrites for suffix-less tests. # See also 'test-harness-vpath-rewrite.sh' and 'test-trs-basic.sh'. am__set_TESTS_bases = \ bases='$(TEST_LOGS)'; \ bases=`for i in $$bases; do echo $$i; done | sed 's/\.log$$//'`; \ bases=`echo $$bases` RECHECK_LOGS = $(TEST_LOGS) AM_RECURSIVE_TARGETS = check recheck TEST_SUITE_LOG = test-suite.log TEST_EXTENSIONS = @EXEEXT@ .test LOG_DRIVER = $(SHELL) $(top_srcdir)/../test-driver LOG_COMPILE = $(LOG_COMPILER) $(AM_LOG_FLAGS) $(LOG_FLAGS) am__set_b = \ case '$@' in \ */*) \ case '$*' in \ */*) b='$*';; \ *) b=`echo '$@' | sed 's/\.log$$//'`; \ esac;; \ *) \ b='$*';; \ esac am__test_logs1 = $(TESTS:=.log) am__test_logs2 = $(am__test_logs1:@EXEEXT@.log=.log) TEST_LOGS = $(am__test_logs2:.test.log=.log) TEST_LOG_DRIVER = $(SHELL) $(top_srcdir)/../test-driver TEST_LOG_COMPILE = $(TEST_LOG_COMPILER) $(AM_TEST_LOG_FLAGS) \ $(TEST_LOG_FLAGS) am__DIST_COMMON = $(srcdir)/Makefile.in $(top_srcdir)/../depcomp \ $(top_srcdir)/../test-driver DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) ACLOCAL = @ACLOCAL@ AMTAR = @AMTAR@ AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@ AR = @AR@ AUTOCONF = @AUTOCONF@ AUTOHEADER = @AUTOHEADER@ AUTOMAKE = @AUTOMAKE@ AWK = @AWK@ CC = @CC@ CCAS = @CCAS@ CCASDEPMODE = @CCASDEPMODE@ CCASFLAGS = @CCASFLAGS@ CCDEPMODE = @CCDEPMODE@ CFLAGS = @CFLAGS@ CPP = @CPP@ CPPFLAGS = @CPPFLAGS@ 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@ LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@ 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@ PICFLAG = @PICFLAG@ RANLIB = @RANLIB@ SED = @SED@ SET_MAKE = @SET_MAKE@ SHELL = @SHELL@ STRIP = @STRIP@ THREADDLLIBS = @THREADDLLIBS@ 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_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 = @target@ target_alias = @target_alias@ target_cpu = @target_cpu@ target_os = @target_os@ target_vendor = @target_vendor@ top_build_prefix = @top_build_prefix@ top_builddir = @top_builddir@ top_srcdir = @top_srcdir@ EXTRA_DIST = test_atomic_include.template list_atomic.template run_parallel.h \ test_atomic_include.h list_atomic.c # We distribute test_atomic_include.h and list_atomic.c, since it is hard # to regenerate them on Windows without sed. BUILT_SOURCES = test_atomic_include.h list_atomic.i list_atomic.o CLEANFILES = list_atomic.i list_atomic.o AM_CPPFLAGS = \ -I$(top_builddir)/src -I$(top_srcdir)/src \ -I$(top_builddir)/tests -I$(top_srcdir)/tests @HAVE_PTHREAD_H_TRUE@test_atomic_pthreads_SOURCES = $(test_atomic_SOURCES) @HAVE_PTHREAD_H_TRUE@test_atomic_pthreads_CPPFLAGS = -DAO_USE_PTHREAD_DEFS $(AM_CPPFLAGS) @HAVE_PTHREAD_H_TRUE@test_atomic_pthreads_LDADD = $(test_atomic_LDADD) test_atomic_SOURCES = test_atomic.c test_atomic_LDADD = $(THREADDLLIBS) $(top_builddir)/src/libatomic_ops.la test_stack_SOURCES = test_stack.c test_stack_LDADD = $(THREADDLLIBS) \ $(top_builddir)/src/libatomic_ops_gpl.la \ $(top_builddir)/src/libatomic_ops.la test_malloc_SOURCES = test_malloc.c test_malloc_LDADD = $(THREADDLLIBS) \ $(top_builddir)/src/libatomic_ops_gpl.la \ $(top_builddir)/src/libatomic_ops.la all: $(BUILT_SOURCES) $(MAKE) $(AM_MAKEFLAGS) all-am .SUFFIXES: .SUFFIXES: .c .lo .log .o .obj .test .test$(EXEEXT) .trs $(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.am $(am__configure_deps) @for dep in $?; do \ case '$(am__configure_deps)' in \ *$$dep*) \ ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \ && { if test -f $@; then exit 0; else break; fi; }; \ exit 1;; \ esac; \ done; \ echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign tests/Makefile'; \ $(am__cd) $(top_srcdir) && \ $(AUTOMAKE) --foreign tests/Makefile Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status @case '$?' in \ *config.status*) \ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \ *) \ echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \ cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \ esac; $(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh $(top_srcdir)/configure: @MAINTAINER_MODE_TRUE@ $(am__configure_deps) cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh $(ACLOCAL_M4): @MAINTAINER_MODE_TRUE@ $(am__aclocal_m4_deps) cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh $(am__aclocal_m4_deps): clean-checkPROGRAMS: @list='$(check_PROGRAMS)'; test -n "$$list" || exit 0; \ echo " rm -f" $$list; \ rm -f $$list || exit $$?; \ test -n "$(EXEEXT)" || exit 0; \ list=`for p in $$list; do echo "$$p"; done | sed 's/$(EXEEXT)$$//'`; \ echo " rm -f" $$list; \ rm -f $$list test_atomic$(EXEEXT): $(test_atomic_OBJECTS) $(test_atomic_DEPENDENCIES) $(EXTRA_test_atomic_DEPENDENCIES) @rm -f test_atomic$(EXEEXT) $(AM_V_CCLD)$(LINK) $(test_atomic_OBJECTS) $(test_atomic_LDADD) $(LIBS) test_atomic_pthreads$(EXEEXT): $(test_atomic_pthreads_OBJECTS) $(test_atomic_pthreads_DEPENDENCIES) $(EXTRA_test_atomic_pthreads_DEPENDENCIES) @rm -f test_atomic_pthreads$(EXEEXT) $(AM_V_CCLD)$(LINK) $(test_atomic_pthreads_OBJECTS) $(test_atomic_pthreads_LDADD) $(LIBS) test_malloc$(EXEEXT): $(test_malloc_OBJECTS) $(test_malloc_DEPENDENCIES) $(EXTRA_test_malloc_DEPENDENCIES) @rm -f test_malloc$(EXEEXT) $(AM_V_CCLD)$(LINK) $(test_malloc_OBJECTS) $(test_malloc_LDADD) $(LIBS) test_stack$(EXEEXT): $(test_stack_OBJECTS) $(test_stack_DEPENDENCIES) $(EXTRA_test_stack_DEPENDENCIES) @rm -f test_stack$(EXEEXT) $(AM_V_CCLD)$(LINK) $(test_stack_OBJECTS) $(test_stack_LDADD) $(LIBS) mostlyclean-compile: -rm -f *.$(OBJEXT) distclean-compile: -rm -f *.tab.c @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/test_atomic.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/test_atomic_pthreads-test_atomic.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/test_malloc.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/test_stack.Po@am__quote@ .c.o: @am__fastdepCC_TRUE@ $(AM_V_CC)$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $< @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(COMPILE) -c -o $@ $< .c.obj: @am__fastdepCC_TRUE@ $(AM_V_CC)$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(COMPILE) -c -o $@ `$(CYGPATH_W) '$<'` .c.lo: @am__fastdepCC_TRUE@ $(AM_V_CC)$(LTCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $< @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Plo @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(LTCOMPILE) -c -o $@ $< test_atomic_pthreads-test_atomic.o: test_atomic.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(test_atomic_pthreads_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT test_atomic_pthreads-test_atomic.o -MD -MP -MF $(DEPDIR)/test_atomic_pthreads-test_atomic.Tpo -c -o test_atomic_pthreads-test_atomic.o `test -f 'test_atomic.c' || echo '$(srcdir)/'`test_atomic.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/test_atomic_pthreads-test_atomic.Tpo $(DEPDIR)/test_atomic_pthreads-test_atomic.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='test_atomic.c' object='test_atomic_pthreads-test_atomic.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(test_atomic_pthreads_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o test_atomic_pthreads-test_atomic.o `test -f 'test_atomic.c' || echo '$(srcdir)/'`test_atomic.c test_atomic_pthreads-test_atomic.obj: test_atomic.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(test_atomic_pthreads_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT test_atomic_pthreads-test_atomic.obj -MD -MP -MF $(DEPDIR)/test_atomic_pthreads-test_atomic.Tpo -c -o test_atomic_pthreads-test_atomic.obj `if test -f 'test_atomic.c'; then $(CYGPATH_W) 'test_atomic.c'; else $(CYGPATH_W) '$(srcdir)/test_atomic.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/test_atomic_pthreads-test_atomic.Tpo $(DEPDIR)/test_atomic_pthreads-test_atomic.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='test_atomic.c' object='test_atomic_pthreads-test_atomic.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(test_atomic_pthreads_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o test_atomic_pthreads-test_atomic.obj `if test -f 'test_atomic.c'; then $(CYGPATH_W) 'test_atomic.c'; else $(CYGPATH_W) '$(srcdir)/test_atomic.c'; fi` mostlyclean-libtool: -rm -f *.lo clean-libtool: -rm -rf .libs _libs ID: $(am__tagged_files) $(am__define_uniq_tagged_files); mkid -fID $$unique tags: tags-am TAGS: tags tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) set x; \ here=`pwd`; \ $(am__define_uniq_tagged_files); \ 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-am CTAGS: ctags ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) $(am__define_uniq_tagged_files); \ 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" cscopelist: cscopelist-am cscopelist-am: $(am__tagged_files) list='$(am__tagged_files)'; \ 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 # Recover from deleted '.trs' file; this should ensure that # "rm -f foo.log; make foo.trs" re-run 'foo.test', and re-create # both 'foo.log' and 'foo.trs'. Break the recipe in two subshells # to avoid problems with "make -n". .log.trs: rm -f $< $@ $(MAKE) $(AM_MAKEFLAGS) $< # Leading 'am--fnord' is there to ensure the list of targets does not # expand to empty, as could happen e.g. with make check TESTS=''. am--fnord $(TEST_LOGS) $(TEST_LOGS:.log=.trs): $(am__force_recheck) am--force-recheck: @: $(TEST_SUITE_LOG): $(TEST_LOGS) @$(am__set_TESTS_bases); \ am__f_ok () { test -f "$$1" && test -r "$$1"; }; \ redo_bases=`for i in $$bases; do \ am__f_ok $$i.trs && am__f_ok $$i.log || echo $$i; \ done`; \ if test -n "$$redo_bases"; then \ redo_logs=`for i in $$redo_bases; do echo $$i.log; done`; \ redo_results=`for i in $$redo_bases; do echo $$i.trs; done`; \ if $(am__make_dryrun); then :; else \ rm -f $$redo_logs && rm -f $$redo_results || exit 1; \ fi; \ fi; \ if test -n "$$am__remaking_logs"; then \ echo "fatal: making $(TEST_SUITE_LOG): possible infinite" \ "recursion detected" >&2; \ elif test -n "$$redo_logs"; then \ am__remaking_logs=yes $(MAKE) $(AM_MAKEFLAGS) $$redo_logs; \ fi; \ if $(am__make_dryrun); then :; else \ st=0; \ errmsg="fatal: making $(TEST_SUITE_LOG): failed to create"; \ for i in $$redo_bases; do \ test -f $$i.trs && test -r $$i.trs \ || { echo "$$errmsg $$i.trs" >&2; st=1; }; \ test -f $$i.log && test -r $$i.log \ || { echo "$$errmsg $$i.log" >&2; st=1; }; \ done; \ test $$st -eq 0 || exit 1; \ fi @$(am__sh_e_setup); $(am__tty_colors); $(am__set_TESTS_bases); \ ws='[ ]'; \ results=`for b in $$bases; do echo $$b.trs; done`; \ test -n "$$results" || results=/dev/null; \ all=` grep "^$$ws*:test-result:" $$results | wc -l`; \ pass=` grep "^$$ws*:test-result:$$ws*PASS" $$results | wc -l`; \ fail=` grep "^$$ws*:test-result:$$ws*FAIL" $$results | wc -l`; \ skip=` grep "^$$ws*:test-result:$$ws*SKIP" $$results | wc -l`; \ xfail=`grep "^$$ws*:test-result:$$ws*XFAIL" $$results | wc -l`; \ xpass=`grep "^$$ws*:test-result:$$ws*XPASS" $$results | wc -l`; \ error=`grep "^$$ws*:test-result:$$ws*ERROR" $$results | wc -l`; \ if test `expr $$fail + $$xpass + $$error` -eq 0; then \ success=true; \ else \ success=false; \ fi; \ br='==================='; br=$$br$$br$$br$$br; \ result_count () \ { \ if test x"$$1" = x"--maybe-color"; then \ maybe_colorize=yes; \ elif test x"$$1" = x"--no-color"; then \ maybe_colorize=no; \ else \ echo "$@: invalid 'result_count' usage" >&2; exit 4; \ fi; \ shift; \ desc=$$1 count=$$2; \ if test $$maybe_colorize = yes && test $$count -gt 0; then \ color_start=$$3 color_end=$$std; \ else \ color_start= color_end=; \ fi; \ echo "$${color_start}# $$desc $$count$${color_end}"; \ }; \ create_testsuite_report () \ { \ result_count $$1 "TOTAL:" $$all "$$brg"; \ result_count $$1 "PASS: " $$pass "$$grn"; \ result_count $$1 "SKIP: " $$skip "$$blu"; \ result_count $$1 "XFAIL:" $$xfail "$$lgn"; \ result_count $$1 "FAIL: " $$fail "$$red"; \ result_count $$1 "XPASS:" $$xpass "$$red"; \ result_count $$1 "ERROR:" $$error "$$mgn"; \ }; \ { \ echo "$(PACKAGE_STRING): $(subdir)/$(TEST_SUITE_LOG)" | \ $(am__rst_title); \ create_testsuite_report --no-color; \ echo; \ echo ".. contents:: :depth: 2"; \ echo; \ for b in $$bases; do echo $$b; done \ | $(am__create_global_log); \ } >$(TEST_SUITE_LOG).tmp || exit 1; \ mv $(TEST_SUITE_LOG).tmp $(TEST_SUITE_LOG); \ if $$success; then \ col="$$grn"; \ else \ col="$$red"; \ test x"$$VERBOSE" = x || cat $(TEST_SUITE_LOG); \ fi; \ echo "$${col}$$br$${std}"; \ echo "$${col}Testsuite summary for $(PACKAGE_STRING)$${std}"; \ echo "$${col}$$br$${std}"; \ create_testsuite_report --maybe-color; \ echo "$$col$$br$$std"; \ if $$success; then :; else \ echo "$${col}See $(subdir)/$(TEST_SUITE_LOG)$${std}"; \ if test -n "$(PACKAGE_BUGREPORT)"; then \ echo "$${col}Please report to $(PACKAGE_BUGREPORT)$${std}"; \ fi; \ echo "$$col$$br$$std"; \ fi; \ $$success || exit 1 check-TESTS: @list='$(RECHECK_LOGS)'; test -z "$$list" || rm -f $$list @list='$(RECHECK_LOGS:.log=.trs)'; test -z "$$list" || rm -f $$list @test -z "$(TEST_SUITE_LOG)" || rm -f $(TEST_SUITE_LOG) @set +e; $(am__set_TESTS_bases); \ log_list=`for i in $$bases; do echo $$i.log; done`; \ trs_list=`for i in $$bases; do echo $$i.trs; done`; \ log_list=`echo $$log_list`; trs_list=`echo $$trs_list`; \ $(MAKE) $(AM_MAKEFLAGS) $(TEST_SUITE_LOG) TEST_LOGS="$$log_list"; \ exit $$?; recheck: all $(check_PROGRAMS) @test -z "$(TEST_SUITE_LOG)" || rm -f $(TEST_SUITE_LOG) @set +e; $(am__set_TESTS_bases); \ bases=`for i in $$bases; do echo $$i; done \ | $(am__list_recheck_tests)` || exit 1; \ log_list=`for i in $$bases; do echo $$i.log; done`; \ log_list=`echo $$log_list`; \ $(MAKE) $(AM_MAKEFLAGS) $(TEST_SUITE_LOG) \ am__force_recheck=am--force-recheck \ TEST_LOGS="$$log_list"; \ exit $$? test_atomic.log: test_atomic$(EXEEXT) @p='test_atomic$(EXEEXT)'; \ b='test_atomic'; \ $(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \ --log-file $$b.log --trs-file $$b.trs \ $(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \ "$$tst" $(AM_TESTS_FD_REDIRECT) test_stack.log: test_stack$(EXEEXT) @p='test_stack$(EXEEXT)'; \ b='test_stack'; \ $(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \ --log-file $$b.log --trs-file $$b.trs \ $(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \ "$$tst" $(AM_TESTS_FD_REDIRECT) test_malloc.log: test_malloc$(EXEEXT) @p='test_malloc$(EXEEXT)'; \ b='test_malloc'; \ $(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \ --log-file $$b.log --trs-file $$b.trs \ $(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \ "$$tst" $(AM_TESTS_FD_REDIRECT) test_atomic_pthreads.log: test_atomic_pthreads$(EXEEXT) @p='test_atomic_pthreads$(EXEEXT)'; \ b='test_atomic_pthreads'; \ $(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \ --log-file $$b.log --trs-file $$b.trs \ $(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \ "$$tst" $(AM_TESTS_FD_REDIRECT) .test.log: @p='$<'; \ $(am__set_b); \ $(am__check_pre) $(TEST_LOG_DRIVER) --test-name "$$f" \ --log-file $$b.log --trs-file $$b.trs \ $(am__common_driver_flags) $(AM_TEST_LOG_DRIVER_FLAGS) $(TEST_LOG_DRIVER_FLAGS) -- $(TEST_LOG_COMPILE) \ "$$tst" $(AM_TESTS_FD_REDIRECT) @am__EXEEXT_TRUE@.test$(EXEEXT).log: @am__EXEEXT_TRUE@ @p='$<'; \ @am__EXEEXT_TRUE@ $(am__set_b); \ @am__EXEEXT_TRUE@ $(am__check_pre) $(TEST_LOG_DRIVER) --test-name "$$f" \ @am__EXEEXT_TRUE@ --log-file $$b.log --trs-file $$b.trs \ @am__EXEEXT_TRUE@ $(am__common_driver_flags) $(AM_TEST_LOG_DRIVER_FLAGS) $(TEST_LOG_DRIVER_FLAGS) -- $(TEST_LOG_COMPILE) \ @am__EXEEXT_TRUE@ "$$tst" $(AM_TESTS_FD_REDIRECT) distdir: $(DISTFILES) @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 check-am: all-am $(MAKE) $(AM_MAKEFLAGS) $(check_PROGRAMS) $(MAKE) $(AM_MAKEFLAGS) check-TESTS check: $(BUILT_SOURCES) $(MAKE) $(AM_MAKEFLAGS) check-am all-am: Makefile installdirs: install: $(BUILT_SOURCES) $(MAKE) $(AM_MAKEFLAGS) 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: -test -z "$(TEST_LOGS)" || rm -f $(TEST_LOGS) -test -z "$(TEST_LOGS:.log=.trs)" || rm -f $(TEST_LOGS:.log=.trs) -test -z "$(TEST_SUITE_LOG)" || rm -f $(TEST_SUITE_LOG) clean-generic: -test -z "$(CLEANFILES)" || rm -f $(CLEANFILES) 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) maintainer-clean-generic: @echo "This command is intended for maintainers to use" @echo "it deletes files that may require special tools to rebuild." -test -z "$(BUILT_SOURCES)" || rm -f $(BUILT_SOURCES) clean: clean-am clean-am: clean-checkPROGRAMS clean-generic clean-libtool \ mostlyclean-am distclean: distclean-am -rm -rf ./$(DEPDIR) -rm -f Makefile distclean-am: clean-am distclean-compile distclean-generic \ distclean-tags dvi: dvi-am dvi-am: html: html-am html-am: info: info-am info-am: install-data-am: install-dvi: install-dvi-am install-dvi-am: install-exec-am: 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 -rf ./$(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: .MAKE: all check check-am install install-am install-strip .PHONY: CTAGS GTAGS TAGS all all-am check check-TESTS check-am clean \ clean-checkPROGRAMS clean-generic clean-libtool cscopelist-am \ ctags ctags-am distclean distclean-compile distclean-generic \ distclean-libtool distclean-tags distdir 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-man install-pdf install-pdf-am \ 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 \ recheck tags tags-am uninstall uninstall-am .PRECIOUS: Makefile test_atomic_include.h: test_atomic_include.template mkdir -p `dirname $@` sed -e s:XX::g $? > $@ sed -e s:XX:_release:g $? >> $@ sed -e s:XX:_acquire:g $? >> $@ sed -e s:XX:_read:g $? >> $@ sed -e s:XX:_write:g $? >> $@ sed -e s:XX:_full:g $? >> $@ sed -e s:XX:_release_write:g $? >> $@ sed -e s:XX:_acquire_read:g $? >> $@ list_atomic.c: list_atomic.template mkdir -p `dirname $@` echo "#include \"atomic_ops.h\"" > $@ sed -e s:XSIZE_::g -e s:XCTYPE:AO_t:g -e s:XX::g $? >> $@ sed -e s:XSIZE_::g -e s:XCTYPE:AO_t:g -e s:XX:_release:g $? >> $@ sed -e s:XSIZE_::g -e s:XCTYPE:AO_t:g -e s:XX:_acquire:g $? >> $@ sed -e s:XSIZE_::g -e s:XCTYPE:AO_t:g -e s:XX:_read:g $? >> $@ sed -e s:XSIZE_::g -e s:XCTYPE:AO_t:g -e s:XX:_write:g $? >> $@ sed -e s:XSIZE_::g -e s:XCTYPE:AO_t:g -e s:XX:_full:g $? >> $@ sed -e s:XSIZE_::g -e s:XCTYPE:AO_t:g -e s:XX:_release_write:g $? >> $@ sed -e s:XSIZE_::g -e s:XCTYPE:AO_t:g -e s:XX:_acquire_read:g $? >> $@ sed -e s:XSIZE_::g -e s:XCTYPE:AO_t:g -e s:XX:_dd_acquire_read:g $? >> $@ sed -e s:XSIZE:char:g -e s:XCTYPE:unsigned/**/char:g -e s:XX::g $? >> $@ sed -e s:XSIZE:char:g -e s:XCTYPE:unsigned/**/char:g -e s:XX:_release:g $? >> $@ sed -e s:XSIZE:char:g -e s:XCTYPE:unsigned/**/char:g -e s:XX:_acquire:g $? >> $@ sed -e s:XSIZE:char:g -e s:XCTYPE:unsigned/**/char:g -e s:XX:_read:g $? >> $@ sed -e s:XSIZE:char:g -e s:XCTYPE:unsigned/**/char:g -e s:XX:_write:g $? >> $@ sed -e s:XSIZE:char:g -e s:XCTYPE:unsigned/**/char:g -e s:XX:_full:g $? >> $@ sed -e s:XSIZE:char:g -e s:XCTYPE:unsigned/**/char:g -e s:XX:_release_write:g $? >> $@ sed -e s:XSIZE:char:g -e s:XCTYPE:unsigned/**/char:g -e s:XX:_acquire_read:g $? >> $@ sed -e s:XSIZE:char:g -e s:XCTYPE:unsigned/**/char:g -e s:XX:_dd_acquire_read:g $? >> $@ sed -e s:XSIZE:short:g -e s:XCTYPE:unsigned/**/short:g -e s:XX::g $? >> $@ sed -e s:XSIZE:short:g -e s:XCTYPE:unsigned/**/short:g -e s:XX:_release:g $? >> $@ sed -e s:XSIZE:short:g -e s:XCTYPE:unsigned/**/short:g -e s:XX:_acquire:g $? >> $@ sed -e s:XSIZE:short:g -e s:XCTYPE:unsigned/**/short:g -e s:XX:_read:g $? >> $@ sed -e s:XSIZE:short:g -e s:XCTYPE:unsigned/**/short:g -e s:XX:_write:g $? >> $@ sed -e s:XSIZE:short:g -e s:XCTYPE:unsigned/**/short:g -e s:XX:_full:g $? >> $@ sed -e s:XSIZE:short:g -e s:XCTYPE:unsigned/**/short:g -e s:XX:_release_write:g $? >> $@ sed -e s:XSIZE:short:g -e s:XCTYPE:unsigned/**/short:g -e s:XX:_acquire_read:g $? >> $@ sed -e s:XSIZE:short:g -e s:XCTYPE:unsigned/**/short:g -e s:XX:_dd_acquire_read:g $? >> $@ sed -e s:XSIZE:int:g -e s:XCTYPE:unsigned:g -e s:XX::g $? >> $@ sed -e s:XSIZE:int:g -e s:XCTYPE:unsigned:g -e s:XX:_release:g $? >> $@ sed -e s:XSIZE:int:g -e s:XCTYPE:unsigned:g -e s:XX:_acquire:g $? >> $@ sed -e s:XSIZE:int:g -e s:XCTYPE:unsigned:g -e s:XX:_read:g $? >> $@ sed -e s:XSIZE:int:g -e s:XCTYPE:unsigned:g -e s:XX:_write:g $? >> $@ sed -e s:XSIZE:int:g -e s:XCTYPE:unsigned:g -e s:XX:_full:g $? >> $@ sed -e s:XSIZE:int:g -e s:XCTYPE:unsigned:g -e s:XX:_release_write:g $? >> $@ sed -e s:XSIZE:int:g -e s:XCTYPE:unsigned:g -e s:XX:_acquire_read:g $? >> $@ sed -e s:XSIZE:int:g -e s:XCTYPE:unsigned:g -e s:XX:_dd_acquire_read:g $? >> $@ sed -e s:XSIZE:double:g -e s:XCTYPE:AO_double_t:g -e s:XX::g $? >> $@ sed -e s:XSIZE:double:g -e s:XCTYPE:AO_double_t:g -e s:XX:_release:g $? >> $@ sed -e s:XSIZE:double:g -e s:XCTYPE:AO_double_t:g -e s:XX:_acquire:g $? >> $@ sed -e s:XSIZE:double:g -e s:XCTYPE:AO_double_t:g -e s:XX:_read:g $? >> $@ sed -e s:XSIZE:double:g -e s:XCTYPE:AO_double_t:g -e s:XX:_write:g $? >> $@ sed -e s:XSIZE:double:g -e s:XCTYPE:AO_double_t:g -e s:XX:_full:g $? >> $@ sed -e s:XSIZE:double:g -e s:XCTYPE:AO_double_t:g -e s:XX:_release_write:g $? >> $@ sed -e s:XSIZE:double:g -e s:XCTYPE:AO_double_t:g -e s:XX:_acquire_read:g $? >> $@ sed -e s:XSIZE:double:g -e s:XCTYPE:AO_double_t:g -e s:XX:_dd_acquire_read:g $? >> $@ list_atomic.i: list_atomic.c mkdir -p `dirname $@` $(COMPILE) $? -E > $@ # Verify list_atomic.c syntax: list_atomic.o: list_atomic.c $(COMPILE) -c -o $@ $? # 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: ecl-16.1.2/src/bdwgc/libatomic_ops/tests/list_atomic.template000066400000000000000000000067741266352375300243050ustar00rootroot00000000000000/* * Copyright (c) 2003 by Hewlett-Packard Company. All rights reserved. * * This file is covered by the GNU general public license, version 2. * see COPYING for details. */ /* This generates a compilable program. But it is really meant to be */ /* be used only with cc -E, to inspect the expensions generated by */ /* primitives. */ /* The result will not link or run. */ void XSIZE_list_atomicXX(void) { # if defined(AO_HAVE_XSIZE_loadXX) || defined(AO_HAVE_XSIZE_storeXX) \ || defined(AO_HAVE_XSIZE_fetch_and_addXX) \ || defined(AO_HAVE_XSIZE_fetch_and_add1XX) \ || defined(AO_HAVE_XSIZE_andXX) \ || defined(AO_HAVE_XSIZE_compare_and_swapXX) \ || defined(AO_HAVE_XSIZE_fetch_compare_and_swapXX) static volatile XCTYPE val /* = 0 */; # endif # if defined(AO_HAVE_XSIZE_compare_and_swapXX) \ || defined(AO_HAVE_XSIZE_fetch_compare_and_swapXX) static XCTYPE oldval /* = 0 */; # endif # if defined(AO_HAVE_XSIZE_storeXX) \ || defined(AO_HAVE_XSIZE_compare_and_swapXX) \ || defined(AO_HAVE_XSIZE_fetch_compare_and_swapXX) static XCTYPE newval /* = 0 */; # endif # if defined(AO_HAVE_test_and_setXX) AO_TS_t ts; # endif # if defined(AO_HAVE_XSIZE_fetch_and_addXX) || defined(AO_HAVE_XSIZE_andXX) \ || defined(AO_HAVE_XSIZE_orXX) || defined(AO_HAVE_XSIZE_xorXX) static XCTYPE incr /* = 0 */; # endif # if defined(AO_HAVE_nopXX) (void)"AO_nopXX(): "; AO_nopXX(); # else (void)"No AO_nopXX"; # endif # ifdef AO_HAVE_XSIZE_loadXX (void)"AO_XSIZE_loadXX(&val):"; AO_XSIZE_loadXX(&val); # else (void)"No AO_XSIZE_loadXX"; # endif # ifdef AO_HAVE_XSIZE_storeXX (void)"AO_XSIZE_storeXX(&val, newval):"; AO_XSIZE_storeXX(&val, newval); # else (void)"No AO_XSIZE_storeXX"; # endif # ifdef AO_HAVE_XSIZE_fetch_and_addXX (void)"AO_XSIZE_fetch_and_addXX(&val, incr):"; AO_XSIZE_fetch_and_addXX(&val, incr); # else (void)"No AO_XSIZE_fetch_and_addXX"; # endif # ifdef AO_HAVE_XSIZE_fetch_and_add1XX (void)"AO_XSIZE_fetch_and_add1XX(&val):"; AO_XSIZE_fetch_and_add1XX(&val); # else (void)"No AO_XSIZE_fetch_and_add1XX"; # endif # ifdef AO_HAVE_XSIZE_fetch_and_sub1XX (void)"AO_XSIZE_fetch_and_sub1XX(&val):"; AO_XSIZE_fetch_and_sub1XX(&val); # else (void)"No AO_XSIZE_fetch_and_sub1XX"; # endif # ifdef AO_HAVE_XSIZE_andXX (void)"AO_XSIZE_andXX(&val, incr):"; AO_XSIZE_andXX(&val, incr); # else (void)"No AO_XSIZE_andXX"; # endif # ifdef AO_HAVE_XSIZE_orXX (void)"AO_XSIZE_orXX(&val, incr):"; AO_XSIZE_orXX(&val, incr); # else (void)"No AO_XSIZE_orXX"; # endif # ifdef AO_HAVE_XSIZE_xorXX (void)"AO_XSIZE_xorXX(&val, incr):"; AO_XSIZE_xorXX(&val, incr); # else (void)"No AO_XSIZE_xorXX"; # endif # ifdef AO_HAVE_XSIZE_compare_and_swapXX (void)"AO_XSIZE_compare_and_swapXX(&val, oldval, newval):"; AO_XSIZE_compare_and_swapXX(&val, oldval, newval); # else (void)"No AO_XSIZE_compare_and_swapXX"; # endif /* TODO: Add AO_compare_double_and_swap_doubleXX */ /* TODO: Add AO_compare_and_swap_doubleXX */ # ifdef AO_HAVE_XSIZE_fetch_compare_and_swapXX (void)"AO_XSIZE_fetch_compare_and_swapXX(&val, oldval, newval):"; AO_XSIZE_fetch_compare_and_swapXX(&val, oldval, newval); # else (void)"No AO_XSIZE_fetch_compare_and_swapXX"; # endif # if defined(AO_HAVE_test_and_setXX) (void)"AO_test_and_setXX(&ts):"; AO_test_and_setXX(&ts); # else (void)"No AO_test_and_setXX"; # endif } ecl-16.1.2/src/bdwgc/libatomic_ops/tests/run_parallel.h000066400000000000000000000110601266352375300230520ustar00rootroot00000000000000/* * Copyright (c) 2003-2005 Hewlett-Packard Development Company, L.P. * * This file is covered by the GNU general public license, version 2. * see COPYING for details. */ #if defined(_MSC_VER) || \ defined(_WIN32) && !defined(__CYGWIN32__) && !defined(__CYGWIN__) || \ defined(_WIN32_WINCE) # define USE_WINTHREADS #elif defined(__vxworks) # define USE_VXTHREADS #else # define USE_PTHREADS #endif #include #include #ifdef USE_PTHREADS # include #endif #ifdef USE_VXTHREADS # include # include #endif #ifdef USE_WINTHREADS # include #endif #include "atomic_ops.h" #if (defined(_WIN32_WCE) || defined(__MINGW32CE__)) && !defined(abort) # define abort() _exit(-1) /* there is no abort() in WinCE */ #endif #ifndef _WIN64 # define AO_PTRDIFF_T long #elif defined(__int64) # define AO_PTRDIFF_T __int64 #else # define AO_PTRDIFF_T long long #endif typedef void * (* thr_func)(void *); typedef int (* test_func)(void); /* Returns != 0 on success */ void * run_parallel(int nthreads, thr_func f1, test_func t, const char *name); #ifdef USE_PTHREADS void * run_parallel(int nthreads, thr_func f1, test_func t, const char *name) { pthread_attr_t attr; pthread_t thr[100]; int i; int code; printf("Testing %s\n", name); if (nthreads > 100) { fprintf(stderr, "run_parallel: requested too many threads\n"); abort(); } # ifdef _HPUX_SOURCE /* Default stack size is too small, especially with the 64 bit ABI */ /* Increase it. */ if (pthread_default_stacksize_np(1024*1024, 0) != 0) { fprintf(stderr, "pthread_default_stacksize_np failed. " "OK after first call.\n"); } # endif pthread_attr_init(&attr); for (i = 0; i < nthreads; ++i) { if ((code = pthread_create(thr + i, &attr, f1, (void *)(long)i)) != 0) { fprintf(stderr, "pthread_create returned %d, thread %d\n", code, i); abort(); } } for (i = 0; i < nthreads; ++i) { if ((code = pthread_join(thr[i], NULL)) != 0) { fprintf(stderr, "pthread_join returned %d, thread %d\n", code, i); abort(); } } if (t()) { printf("Succeeded\n"); } else { fprintf(stderr, "Failed\n"); abort(); } return 0; } #endif /* USE_PTHREADS */ #ifdef USE_VXTHREADS void * run_parallel(int nthreads, thr_func f1, test_func t, const char *name) { int thr[100]; int i; printf("Testing %s\n", name); if (nthreads > 100) { fprintf(stderr, "run_parallel: requested too many threads\n"); taskSuspend(0); } for (i = 0; i < nthreads; ++i) { thr[i] = taskSpawn((char*) name, 180, 0, 32768, (FUNCPTR) f1, i, 1, 2, 3, 4, 5, 6, 7, 8, 9); if (thr[i] == ERROR) { fprintf(stderr, "taskSpawn failed with %d, thread %d\n", errno, i); taskSuspend(0); } } for (i = 0; i < nthreads; ++i) { while (taskIdVerify(thr[i]) == OK) taskDelay(60); } if (t()) { printf("Succeeded\n"); } else { fprintf(stderr, "Failed\n"); taskSuspend(0); } return 0; } #endif /* USE_VXTHREADS */ #ifdef USE_WINTHREADS struct tramp_args { thr_func fn; long arg; }; DWORD WINAPI tramp(LPVOID param) { struct tramp_args *args = (struct tramp_args *)param; return (DWORD)(AO_PTRDIFF_T)(*args->fn)((LPVOID)(AO_PTRDIFF_T)args->arg); } void * run_parallel(int nthreads, thr_func f1, test_func t, const char *name) { HANDLE thr[100]; struct tramp_args args[100]; int i; DWORD code; printf("Testing %s\n", name); if (nthreads > 100) { fprintf(stderr, "run_parallel: requested too many threads\n"); abort(); } for (i = 0; i < nthreads; ++i) { args[i].fn = f1; args[i].arg = i; if ((thr[i] = CreateThread(NULL, 0, tramp, (LPVOID)(args+i), 0, NULL)) == NULL) { fprintf(stderr, "CreateThread failed with %lu, thread %d\n", (unsigned long)GetLastError(), i); abort(); } } for (i = 0; i < nthreads; ++i) { if ((code = WaitForSingleObject(thr[i], INFINITE)) != WAIT_OBJECT_0) { fprintf(stderr, "WaitForSingleObject returned %lu, thread %d\n", (unsigned long)code, i); abort(); } } if (t()) { printf("Succeeded\n"); } else { fprintf(stderr, "Failed\n"); abort(); } return 0; } #endif /* USE_WINTHREADS */ ecl-16.1.2/src/bdwgc/libatomic_ops/tests/test_atomic.c000066400000000000000000000120171266352375300227030ustar00rootroot00000000000000/* * Copyright (c) 2003-2005 Hewlett-Packard Development Company, L.P. * * This file may be redistributed and/or modified under the * terms of the GNU General Public License as published by the Free Software * Foundation; either version 2, or (at your option) any later version. * * It 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 in the * file COPYING for more details. */ #if defined(HAVE_CONFIG_H) # include "config.h" #endif #if defined(AO_NO_PTHREADS) && defined(AO_USE_PTHREAD_DEFS) # include int main(void) { printf("test skipped\n"); return 0; } #else #include "run_parallel.h" #include "test_atomic_include.h" #ifdef AO_USE_PTHREAD_DEFS # define NITERS 100000 #else # define NITERS 10000000 #endif void * add1sub1_thr(void * id); int add1sub1_test(void); void * acqrel_thr(void *id); int acqrel_test(void); void * test_and_set_thr(void * id); int test_and_set_test(void); #if defined(AO_HAVE_fetch_and_add1) && defined(AO_HAVE_fetch_and_sub1) AO_t counter = 0; void * add1sub1_thr(void * id) { int me = (int)(AO_PTRDIFF_T)id; int i; for (i = 0; i < NITERS; ++i) if ((me & 1) != 0) { (void)AO_fetch_and_sub1(&counter); } else { (void)AO_fetch_and_add1(&counter); } return 0; } int add1sub1_test(void) { return counter == 0; } #endif /* defined(AO_HAVE_fetch_and_add1) && defined(AO_HAVE_fetch_and_sub1) */ #if defined(AO_HAVE_store_release_write) && defined(AO_HAVE_load_acquire_read) /* Invariant: counter1 >= counter2 */ AO_t counter1 = 0; AO_t counter2 = 0; void * acqrel_thr(void *id) { int me = (int)(AO_PTRDIFF_T)id; int i; for (i = 0; i < NITERS; ++i) if (me & 1) { AO_t my_counter1; if (me != 1) { fprintf(stderr, "acqrel test: too many threads\n"); abort(); } my_counter1 = AO_load(&counter1); AO_store(&counter1, my_counter1 + 1); AO_store_release_write(&counter2, my_counter1 + 1); } else { AO_t my_counter1a, my_counter2a; AO_t my_counter1b, my_counter2b; my_counter2a = AO_load_acquire_read(&counter2); my_counter1a = AO_load(&counter1); /* Redo this, to make sure that the second load of counter1 */ /* is not viewed as a common subexpression. */ my_counter2b = AO_load_acquire_read(&counter2); my_counter1b = AO_load(&counter1); if (my_counter1a < my_counter2a) { fprintf(stderr, "Saw release store out of order: %lu < %lu\n", (unsigned long)my_counter1a, (unsigned long)my_counter2a); abort(); } if (my_counter1b < my_counter2b) { fprintf(stderr, "Saw release store out of order (bad CSE?): %lu < %lu\n", (unsigned long)my_counter1b, (unsigned long)my_counter2b); abort(); } } return 0; } int acqrel_test(void) { return counter1 == NITERS && counter2 == NITERS; } #endif /* AO_HAVE_store_release_write && AO_HAVE_load_acquire_read */ #if defined(AO_HAVE_test_and_set_acquire) AO_TS_t lock = AO_TS_INITIALIZER; unsigned long locked_counter; volatile unsigned long junk = 13; void * test_and_set_thr(void * id) { unsigned long i; for (i = 0; i < NITERS/10; ++i) { while (AO_test_and_set_acquire(&lock) != AO_TS_CLEAR); ++locked_counter; if (locked_counter != 1) { fprintf(stderr, "Test and set failure 1, counter = %ld, id = %d\n", (long)locked_counter, (int)(AO_PTRDIFF_T)id); abort(); } locked_counter *= 2; locked_counter -= 1; locked_counter *= 5; locked_counter -= 4; if (locked_counter != 1) { fprintf(stderr, "Test and set failure 2, counter = %ld, id = %d\n", (long)locked_counter, (int)(AO_PTRDIFF_T)id); abort(); } --locked_counter; AO_CLEAR(&lock); /* Spend a bit of time outside the lock. */ junk *= 17; junk *= 17; } return 0; } int test_and_set_test(void) { return locked_counter == 0; } #endif /* defined(AO_HAVE_test_and_set_acquire) */ int main(void) { test_atomic(); test_atomic_acquire(); test_atomic_release(); test_atomic_read(); test_atomic_write(); test_atomic_full(); test_atomic_release_write(); test_atomic_acquire_read(); # if defined(AO_HAVE_fetch_and_add1) && defined(AO_HAVE_fetch_and_sub1) run_parallel(4, add1sub1_thr, add1sub1_test, "add1/sub1"); # endif # if defined(AO_HAVE_store_release_write) && defined(AO_HAVE_load_acquire_read) run_parallel(3, acqrel_thr, acqrel_test, "store_release_write/load_acquire_read"); # endif # if defined(AO_HAVE_test_and_set_acquire) run_parallel(5, test_and_set_thr, test_and_set_test, "test_and_set"); # endif return 0; } #endif /* !AO_NO_PTHREADS || !AO_USE_PTHREAD_DEFS */ ecl-16.1.2/src/bdwgc/libatomic_ops/tests/test_atomic_include.template000066400000000000000000000272571266352375300260130ustar00rootroot00000000000000/* * Copyright (c) 2003 by Hewlett-Packard Company. All rights reserved. * * This file is covered by the GNU general public license, version 2. * see COPYING for details. */ /* Some basic sanity tests. These do not test the barrier semantics. */ #undef TA_assert #define TA_assert(e) \ if (!(e)) { fprintf(stderr, "Assertion failed %s:%d (barrier: XX)\n", \ __FILE__, __LINE__), exit(1); } #undef MISSING #define MISSING(name) \ printf("Missing: %s\n", #name "XX") void test_atomicXX(void) { AO_t x; unsigned char b; unsigned short s; unsigned int zz; # if defined(AO_HAVE_test_and_setXX) AO_TS_t z = AO_TS_INITIALIZER; # endif # if defined(AO_HAVE_double_compare_and_swapXX) \ || defined(AO_HAVE_double_loadXX) \ || defined(AO_HAVE_double_storeXX) AO_double_t old_w; AO_double_t new_w; # endif # if defined(AO_HAVE_compare_and_swap_doubleXX) \ || defined(AO_HAVE_compare_double_and_swap_doubleXX) \ || defined(AO_HAVE_double_compare_and_swapXX) AO_double_t w; w.AO_val1 = 0; w.AO_val2 = 0; # endif # if defined(AO_HAVE_nopXX) AO_nopXX(); # elif !defined(AO_HAVE_nop) || !defined(AO_HAVE_nop_full) \ || !defined(AO_HAVE_nop_read) || !defined(AO_HAVE_nop_write) MISSING(AO_nop); # endif # if defined(AO_HAVE_storeXX) AO_storeXX(&x, 13); TA_assert (x == 13); # else # if !defined(AO_HAVE_store) || !defined(AO_HAVE_store_full) \ || !defined(AO_HAVE_store_release) \ || !defined(AO_HAVE_store_release_write) \ || !defined(AO_HAVE_store_write) MISSING(AO_store); # endif x = 13; # endif # if defined(AO_HAVE_loadXX) TA_assert(AO_loadXX(&x) == 13); # elif !defined(AO_HAVE_load) || !defined(AO_HAVE_load_acquire) \ || !defined(AO_HAVE_load_acquire_read) \ || !defined(AO_HAVE_load_dd_acquire_read) \ || !defined(AO_HAVE_load_full) || !defined(AO_HAVE_load_read) MISSING(AO_load); # endif # if defined(AO_HAVE_test_and_setXX) assert(AO_test_and_setXX(&z) == AO_TS_CLEAR); assert(AO_test_and_setXX(&z) == AO_TS_SET); assert(AO_test_and_setXX(&z) == AO_TS_SET); AO_CLEAR(&z); # else MISSING(AO_test_and_set); # endif # if defined(AO_HAVE_fetch_and_addXX) TA_assert(AO_fetch_and_addXX(&x, 42) == 13); TA_assert(AO_fetch_and_addXX(&x, (AO_t)(-42)) == 55); # else MISSING(AO_fetch_and_add); # endif # if defined(AO_HAVE_fetch_and_add1XX) TA_assert(AO_fetch_and_add1XX(&x) == 13); # else MISSING(AO_fetch_and_add1); ++x; # endif # if defined(AO_HAVE_fetch_and_sub1XX) TA_assert(AO_fetch_and_sub1XX(&x) == 14); # else MISSING(AO_fetch_and_sub1); --x; # endif # if defined(AO_HAVE_short_storeXX) AO_short_storeXX(&s, 13); # else # if !defined(AO_HAVE_short_store) || !defined(AO_HAVE_short_store_full) \ || !defined(AO_HAVE_short_store_release) \ || !defined(AO_HAVE_short_store_release_write) \ || !defined(AO_HAVE_short_store_write) MISSING(AO_short_store); # endif s = 13; # endif # if defined(AO_HAVE_short_loadXX) TA_assert(AO_short_load(&s) == 13); # elif !defined(AO_HAVE_short_load) || !defined(AO_HAVE_short_load_acquire) \ || !defined(AO_HAVE_short_load_acquire_read) \ || !defined(AO_HAVE_short_load_dd_acquire_read) \ || !defined(AO_HAVE_short_load_full) \ || !defined(AO_HAVE_short_load_read) MISSING(AO_short_load); # endif # if defined(AO_HAVE_short_fetch_and_addXX) TA_assert(AO_short_fetch_and_addXX(&s, 42) == 13); TA_assert(AO_short_fetch_and_addXX(&s, (unsigned short)-42) == 55); # else MISSING(AO_short_fetch_and_add); # endif # if defined(AO_HAVE_short_fetch_and_add1XX) TA_assert(AO_short_fetch_and_add1XX(&s) == 13); # else MISSING(AO_short_fetch_and_add1); ++s; # endif # if defined(AO_HAVE_short_fetch_and_sub1XX) TA_assert(AO_short_fetch_and_sub1XX(&s) == 14); # else MISSING(AO_short_fetch_and_sub1); --s; # endif # if defined(AO_HAVE_char_storeXX) AO_char_storeXX(&b, 13); # else # if !defined(AO_HAVE_char_store) || !defined(AO_HAVE_char_store_full) \ || !defined(AO_HAVE_char_store_release) \ || !defined(AO_HAVE_char_store_release_write) \ || !defined(AO_HAVE_char_store_write) MISSING(AO_char_store); # endif b = 13; # endif # if defined(AO_HAVE_char_loadXX) TA_assert(AO_char_load(&b) == 13); # elif !defined(AO_HAVE_char_load) || !defined(AO_HAVE_char_load_acquire) \ || !defined(AO_HAVE_char_load_acquire_read) \ || !defined(AO_HAVE_char_load_dd_acquire_read) \ || !defined(AO_HAVE_char_load_full) || !defined(AO_HAVE_char_load_read) MISSING(AO_char_load); # endif # if defined(AO_HAVE_char_fetch_and_addXX) TA_assert(AO_char_fetch_and_addXX(&b, 42) == 13); TA_assert(AO_char_fetch_and_addXX(&b, (unsigned char)-42) == 55); # else MISSING(AO_char_fetch_and_add); # endif # if defined(AO_HAVE_char_fetch_and_add1XX) TA_assert(AO_char_fetch_and_add1XX(&b) == 13); # else MISSING(AO_char_fetch_and_add1); ++b; # endif # if defined(AO_HAVE_char_fetch_and_sub1XX) TA_assert(AO_char_fetch_and_sub1XX(&b) == 14); # else MISSING(AO_char_fetch_and_sub1); --b; # endif # if defined(AO_HAVE_int_storeXX) AO_int_storeXX(&zz, 13); # else # if !defined(AO_HAVE_int_store) || !defined(AO_HAVE_int_store_full) \ || !defined(AO_HAVE_int_store_release) \ || !defined(AO_HAVE_int_store_release_write) \ || !defined(AO_HAVE_int_store_write) MISSING(AO_int_store); # endif zz = 13; # endif # if defined(AO_HAVE_int_loadXX) TA_assert(AO_int_load(&zz) == 13); # elif !defined(AO_HAVE_int_load) || !defined(AO_HAVE_int_load_acquire) \ || !defined(AO_HAVE_int_load_acquire_read) \ || !defined(AO_HAVE_int_load_dd_acquire_read) \ || !defined(AO_HAVE_int_load_full) || !defined(AO_HAVE_int_load_read) MISSING(AO_int_load); # endif # if defined(AO_HAVE_int_fetch_and_addXX) TA_assert(AO_int_fetch_and_addXX(&zz, 42) == 13); TA_assert(AO_int_fetch_and_addXX(&zz, (unsigned int)-42) == 55); # else MISSING(AO_int_fetch_and_add); # endif # if defined(AO_HAVE_int_fetch_and_add1XX) TA_assert(AO_int_fetch_and_add1XX(&zz) == 13); # else MISSING(AO_int_fetch_and_add1); ++zz; # endif # if defined(AO_HAVE_int_fetch_and_sub1XX) TA_assert(AO_int_fetch_and_sub1XX(&zz) == 14); # else MISSING(AO_int_fetch_and_sub1); --zz; # endif # if defined(AO_HAVE_compare_and_swapXX) TA_assert(!AO_compare_and_swapXX(&x, 14, 42)); TA_assert(x == 13); TA_assert(AO_compare_and_swapXX(&x, 13, 42)); TA_assert(x == 42); # else MISSING(AO_compare_and_swap); if (x == 13) x = 42; # endif # if defined(AO_HAVE_orXX) AO_orXX(&x, 66); TA_assert(x == 106); # else MISSING(AO_or); x |= 66; # endif # if defined(AO_HAVE_xorXX) AO_xorXX(&x, 181); TA_assert(x == 223); # else MISSING(AO_xor); x ^= 181; # endif # if defined(AO_HAVE_andXX) AO_andXX(&x, 57); TA_assert(x == 25); # else MISSING(AO_and); x &= 57; # endif # if defined(AO_HAVE_fetch_compare_and_swapXX) TA_assert(AO_fetch_compare_and_swapXX(&x, 14, 117) == 25); TA_assert(x == 25); TA_assert(AO_fetch_compare_and_swapXX(&x, 25, 117) == 25); TA_assert(x == 117); # else MISSING(AO_fetch_compare_and_swap); if (x == 25) x = 117; # endif # if defined(AO_HAVE_double_loadXX) old_w.AO_val1 = 3316; old_w.AO_val2 = 2921; new_w = AO_double_loadXX(&old_w); TA_assert(new_w.AO_val1 == 3316 && new_w.AO_val2 == 2921); # elif !defined(AO_HAVE_double_load) \ || !defined(AO_HAVE_double_load_acquire) \ || !defined(AO_HAVE_double_load_acquire_read) \ || !defined(AO_HAVE_double_load_dd_acquire_read) \ || !defined(AO_HAVE_double_load_full) \ || !defined(AO_HAVE_double_load_read) MISSING(AO_double_load); # endif # if defined(AO_HAVE_double_storeXX) new_w.AO_val1 = 1375; new_w.AO_val2 = 8243; AO_double_storeXX(&old_w, new_w); TA_assert(old_w.AO_val1 == 1375 && old_w.AO_val2 == 8243); AO_double_storeXX(&old_w, new_w); TA_assert(old_w.AO_val1 == 1375 && old_w.AO_val2 == 8243); new_w.AO_val1 ^= old_w.AO_val1; new_w.AO_val2 ^= old_w.AO_val2; AO_double_storeXX(&old_w, new_w); TA_assert(old_w.AO_val1 == 0 && old_w.AO_val2 == 0); # elif !defined(AO_HAVE_double_store) \ || !defined(AO_HAVE_double_store_full) \ || !defined(AO_HAVE_double_store_release) \ || !defined(AO_HAVE_double_store_release_write) \ || !defined(AO_HAVE_double_store_write) MISSING(AO_double_store); # endif # if defined(AO_HAVE_compare_double_and_swap_doubleXX) TA_assert(!AO_compare_double_and_swap_doubleXX(&w, 17, 42, 12, 13)); TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0); TA_assert(AO_compare_double_and_swap_doubleXX(&w, 0, 0, 12, 13)); TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13); TA_assert(!AO_compare_double_and_swap_doubleXX(&w, 12, 14, 64, 33)); TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13); TA_assert(!AO_compare_double_and_swap_doubleXX(&w, 11, 13, 85, 82)); TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13); TA_assert(!AO_compare_double_and_swap_doubleXX(&w, 13, 12, 17, 42)); TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13); TA_assert(AO_compare_double_and_swap_doubleXX(&w, 12, 13, 17, 42)); TA_assert(w.AO_val1 == 17 && w.AO_val2 == 42); TA_assert(AO_compare_double_and_swap_doubleXX(&w, 17, 42, 0, 0)); TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0); # else MISSING(AO_compare_double_and_swap_double); # endif # if defined(AO_HAVE_compare_and_swap_doubleXX) TA_assert(!AO_compare_and_swap_doubleXX(&w, 17, 12, 13)); TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0); TA_assert(AO_compare_and_swap_doubleXX(&w, 0, 12, 13)); TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13); TA_assert(!AO_compare_and_swap_doubleXX(&w, 13, 12, 33)); TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13); TA_assert(!AO_compare_and_swap_doubleXX(&w, 1213, 48, 86)); TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13); TA_assert(AO_compare_and_swap_doubleXX(&w, 12, 17, 42)); TA_assert(w.AO_val1 == 17 && w.AO_val2 == 42); TA_assert(AO_compare_and_swap_doubleXX(&w, 17, 0, 0)); TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0); # else MISSING(AO_compare_and_swap_double); # endif # if defined(AO_HAVE_double_compare_and_swapXX) old_w.AO_val1 = 4116; old_w.AO_val2 = 2121; new_w.AO_val1 = 8537; new_w.AO_val2 = 6410; TA_assert(!AO_double_compare_and_swapXX(&w, old_w, new_w)); TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0); TA_assert(AO_double_compare_and_swapXX(&w, w, new_w)); TA_assert(w.AO_val1 == 8537 && w.AO_val2 == 6410); old_w.AO_val1 = new_w.AO_val1; old_w.AO_val2 = 29; new_w.AO_val1 = 820; new_w.AO_val2 = 5917; TA_assert(!AO_double_compare_and_swapXX(&w, old_w, new_w)); TA_assert(w.AO_val1 == 8537 && w.AO_val2 == 6410); old_w.AO_val1 = 11; old_w.AO_val2 = 6410; new_w.AO_val1 = 3552; new_w.AO_val2 = 1746; TA_assert(!AO_double_compare_and_swapXX(&w, old_w, new_w)); TA_assert(w.AO_val1 == 8537 && w.AO_val2 == 6410); old_w.AO_val1 = old_w.AO_val2; old_w.AO_val2 = 8537; new_w.AO_val1 = 4116; new_w.AO_val2 = 2121; TA_assert(!AO_double_compare_and_swapXX(&w, old_w, new_w)); TA_assert(w.AO_val1 == 8537 && w.AO_val2 == 6410); old_w.AO_val1 = old_w.AO_val2; old_w.AO_val2 = 6410; new_w.AO_val1 = 1; TA_assert(AO_double_compare_and_swapXX(&w, old_w, new_w)); TA_assert(w.AO_val1 == 1 && w.AO_val2 == 2121); old_w.AO_val1 = new_w.AO_val1; old_w.AO_val2 = w.AO_val2; new_w.AO_val1--; new_w.AO_val2 = 0; TA_assert(AO_double_compare_and_swapXX(&w, old_w, new_w)); TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0); # else MISSING(AO_double_compare_and_swap); # endif } ecl-16.1.2/src/bdwgc/libatomic_ops/tests/test_malloc.c000066400000000000000000000121041266352375300226730ustar00rootroot00000000000000/* * Copyright (c) 2005 Hewlett-Packard Development Company, L.P. * * This file may be redistributed and/or modified under the * terms of the GNU General Public License as published by the Free Software * Foundation; either version 2, or (at your option) any later version. * * It 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 in the * file COPYING for more details. */ #if defined(HAVE_CONFIG_H) # include "config.h" #endif #include "run_parallel.h" #include #include #include "atomic_ops_malloc.h" #ifndef MAX_NTHREADS # define MAX_NTHREADS 100 #endif #ifndef DEFAULT_NTHREADS # ifdef HAVE_MMAP # define DEFAULT_NTHREADS 10 # else # define DEFAULT_NTHREADS 3 # endif #endif #ifndef N_REVERSALS # ifdef AO_USE_PTHREAD_DEFS # define N_REVERSALS 4 # else # define N_REVERSALS 1000 /* must be even */ # endif #endif #ifndef LIST_LENGTH # ifdef HAVE_MMAP # define LIST_LENGTH 1000 # else # define LIST_LENGTH 100 # endif #endif #ifndef LARGE_OBJ_SIZE # ifdef HAVE_MMAP # define LARGE_OBJ_SIZE 200000 # else # define LARGE_OBJ_SIZE 20000 # endif #endif #ifdef USE_STANDARD_MALLOC # define AO_malloc(n) malloc(n) # define AO_free(p) free(p) # define AO_malloc_enable_mmap() #endif typedef struct list_node { struct list_node *next; int data; } ln; ln *cons(int d, ln *tail) { static size_t extra = 0; size_t my_extra = extra; ln *result; int * extras; unsigned i; if (my_extra > 100) extra = my_extra = 0; else ++extra; result = AO_malloc(sizeof(ln) + sizeof(int)*my_extra); if (result == 0) { fprintf(stderr, "Out of memory\n"); /* Normal for more than about 10 threads without mmap? */ exit(2); } result -> data = d; result -> next = tail; extras = (int *)(result+1); for (i = 0; i < my_extra; ++i) extras[i] = 42; return result; } void print_list(ln *l) { ln *p; for (p = l; p != 0; p = p -> next) { printf("%d, ", p -> data); } printf("\n"); } /* Check that l contains numbers from m to n inclusive in ascending order */ void check_list(ln *l, int m, int n) { ln *p; int i; for (p = l, i = m; p != 0 && i <= n; p = p -> next, ++i) { if (i != p -> data) { fprintf(stderr, "Found %d, expected %d\n", p -> data, i); abort(); } } if (i <= n) { fprintf(stderr, "Number not found: %d\n", i); abort(); } if (p != 0) { fprintf(stderr, "Found unexpected number: %d\n", i); abort(); } } /* Create a list of integers from m to n */ ln * make_list(int m, int n) { if (m > n) return 0; return cons(m, make_list(m+1, n)); } /* Reverse list x, and concatenate it to y, deallocating no longer needed */ /* nodes in x. */ ln * reverse(ln *x, ln *y) { ln * result; if (x == 0) return y; result = reverse(x -> next, cons(x -> data, y)); AO_free(x); return result; } int dummy_test(void) { return 1; } void * run_one_test(void * arg) { ln * x = make_list(1, LIST_LENGTH); int i; char *p = AO_malloc(LARGE_OBJ_SIZE); char *q; if (0 == p) { # ifdef HAVE_MMAP fprintf(stderr, "AO_malloc(%d) failed\n", LARGE_OBJ_SIZE); abort(); # else fprintf(stderr, "AO_malloc(%d) failed: This is normal without mmap\n", LARGE_OBJ_SIZE); # endif } else { p[0] = p[LARGE_OBJ_SIZE/2] = p[LARGE_OBJ_SIZE-1] = 'a'; q = AO_malloc(LARGE_OBJ_SIZE); if (q == 0) { fprintf(stderr, "Out of memory\n"); /* Normal for more than about 10 threads without mmap? */ exit(2); } q[0] = q[LARGE_OBJ_SIZE/2] = q[LARGE_OBJ_SIZE-1] = 'b'; if (p[0] != 'a' || p[LARGE_OBJ_SIZE/2] != 'a' || p[LARGE_OBJ_SIZE-1] != 'a') { fprintf(stderr, "First large allocation smashed\n"); abort(); } AO_free(p); if (q[0] != 'b' || q[LARGE_OBJ_SIZE/2] != 'b' || q[LARGE_OBJ_SIZE-1] != 'b') { fprintf(stderr, "Second large allocation smashed\n"); abort(); } AO_free(q); } # ifdef DEBUG_RUN_ONE_TEST x = reverse(x, 0); print_list(x); x = reverse(x, 0); print_list(x); # endif for (i = 0; i < N_REVERSALS; ++i) { x = reverse(x, 0); } check_list(x, 1, LIST_LENGTH); return arg; /* use arg to suppress compiler warning */ } int main(int argc, char **argv) { int nthreads; if (1 == argc) { nthreads = DEFAULT_NTHREADS; } else if (2 == argc) { nthreads = atoi(argv[1]); if (nthreads < 1 || nthreads > MAX_NTHREADS) { fprintf(stderr, "Invalid # of threads argument\n"); exit(1); } } else { fprintf(stderr, "Usage: %s [# of threads]\n", argv[0]); exit(1); } printf("Performing %d reversals of %d element lists in %d threads\n", N_REVERSALS, LIST_LENGTH, nthreads); AO_malloc_enable_mmap(); run_parallel(nthreads, run_one_test, dummy_test, "AO_malloc/AO_free"); return 0; } ecl-16.1.2/src/bdwgc/libatomic_ops/tests/test_stack.c000066400000000000000000000201641266352375300225360ustar00rootroot00000000000000/* * Copyright (c) 2005 Hewlett-Packard Development Company, L.P. * * This file may be redistributed and/or modified under the * terms of the GNU General Public License as published by the Free Software * Foundation; either version 2, or (at your option) any later version. * * It 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 in the * file COPYING for more details. */ #if defined(HAVE_CONFIG_H) # include "config.h" #endif #include #if defined(__vxworks) int main(void) { printf("test skipped\n"); return 0; } #else #if ((defined(_WIN32) && !defined(__CYGWIN32__) && !defined(__CYGWIN__)) \ || defined(_MSC_VER) || defined(_WIN32_WINCE)) \ && !defined(AO_USE_WIN32_PTHREADS) # define USE_WINTHREADS #endif #ifdef USE_WINTHREADS # include #else # include #endif #include #include "atomic_ops_stack.h" /* includes atomic_ops.h as well */ #if (defined(_WIN32_WCE) || defined(__MINGW32CE__)) && !defined(abort) # define abort() _exit(-1) /* there is no abort() in WinCE */ #endif #ifndef MAX_NTHREADS # define MAX_NTHREADS 100 #endif #ifdef NO_TIMES # define get_msecs() 0 #elif defined(USE_WINTHREADS) || defined(AO_USE_WIN32_PTHREADS) # include long long get_msecs(void) { struct timeb tb; ftime(&tb); return (long long)tb.time * 1000 + tb.millitm; } #else /* Unix */ # include # include /* Need 64-bit long long support */ long long get_msecs(void) { struct timeval tv; gettimeofday(&tv, 0); return (long long)tv.tv_sec * 1000 + tv.tv_usec/1000; } #endif /* !NO_TIMES */ typedef struct le { AO_t next; int data; } list_element; AO_stack_t the_list = AO_STACK_INITIALIZER; void add_elements(int n) { list_element * le; if (n == 0) return; add_elements(n-1); le = malloc(sizeof(list_element)); if (le == 0) { fprintf(stderr, "Out of memory\n"); exit(2); } le -> data = n; AO_stack_push(&the_list, (AO_t *)le); } void print_list(void) { list_element *p; for (p = (list_element *)AO_REAL_HEAD_PTR(the_list); p != 0; p = (list_element *)AO_REAL_NEXT_PTR(p -> next)) printf("%d\n", p -> data); } static char marks[MAX_NTHREADS * (MAX_NTHREADS + 1) / 2 + 1]; void check_list(int n) { list_element *p; int i; for (i = 1; i <= n; ++i) marks[i] = 0; for (p = (list_element *)AO_REAL_HEAD_PTR(the_list); p != 0; p = (list_element *)AO_REAL_NEXT_PTR(p -> next)) { i = p -> data; if (i > n || i <= 0) { fprintf(stderr, "Found erroneous list element %d\n", i); abort(); } if (marks[i] != 0) { fprintf(stderr, "Found duplicate list element %d\n", i); abort(); } marks[i] = 1; } for (i = 1; i <= n; ++i) if (marks[i] != 1) { fprintf(stderr, "Missing list element %d\n", i); abort(); } } volatile AO_t ops_performed = 0; #ifndef LIMIT /* Total number of push/pop ops in all threads per test. */ # ifdef AO_USE_PTHREAD_DEFS # define LIMIT 20000 # else # define LIMIT 1000000 # endif #endif #ifdef AO_HAVE_fetch_and_add # define fetch_and_add(addr, val) AO_fetch_and_add(addr, val) #else /* Fake it. This is really quite unacceptable for timing */ /* purposes. But as a correctness test, it should be OK. */ AO_INLINE AO_t fetch_and_add(volatile AO_t * addr, AO_t val) { AO_t result = AO_load(addr); AO_store(addr, result + val); return result; } #endif #ifdef USE_WINTHREADS DWORD WINAPI run_one_test(LPVOID arg) #else void * run_one_test(void * arg) #endif { list_element * t[MAX_NTHREADS + 1]; int index = (int)(size_t)arg; int i; # ifdef VERBOSE int j = 0; printf("starting thread %d\n", index); # endif while (fetch_and_add(&ops_performed, index + 1) + index + 1 < LIMIT) { for (i = 0; i < index + 1; ++i) { t[i] = (list_element *)AO_stack_pop(&the_list); if (0 == t[i]) { fprintf(stderr, "FAILED\n"); abort(); } } for (i = 0; i < index + 1; ++i) { AO_stack_push(&the_list, (AO_t *)t[i]); } # ifdef VERBOSE j += index + 1; # endif } # ifdef VERBOSE printf("finished thread %d: %d total ops\n", index, j); # endif return 0; } #ifndef N_EXPERIMENTS # define N_EXPERIMENTS 1 #endif unsigned long times[MAX_NTHREADS + 1][N_EXPERIMENTS]; int main(int argc, char **argv) { int nthreads; int max_nthreads; int exper_n; if (1 == argc) max_nthreads = 4; else if (2 == argc) { max_nthreads = atoi(argv[1]); if (max_nthreads < 1 || max_nthreads > MAX_NTHREADS) { fprintf(stderr, "Invalid max # of threads argument\n"); exit(1); } } else { fprintf(stderr, "Usage: %s [max # of threads]\n", argv[0]); exit(1); } for (exper_n = 0; exper_n < N_EXPERIMENTS; ++ exper_n) for (nthreads = 1; nthreads <= max_nthreads; ++nthreads) { int i; # ifdef USE_WINTHREADS DWORD thread_id; HANDLE thread[MAX_NTHREADS]; # else pthread_t thread[MAX_NTHREADS]; # endif int list_length = nthreads*(nthreads+1)/2; long long start_time; list_element * le; # ifdef VERBOSE printf("Before add_elements: exper_n=%d, nthreads=%d," " max_nthreads=%d, list_length=%d\n", exper_n, nthreads, max_nthreads, list_length); # endif add_elements(list_length); # ifdef VERBOSE printf("Initial list (nthreads = %d):\n", nthreads); print_list(); # endif ops_performed = 0; start_time = get_msecs(); for (i = 1; i < nthreads; ++i) { int code; # ifdef USE_WINTHREADS thread[i] = CreateThread(NULL, 0, run_one_test, (LPVOID)(size_t)i, 0, &thread_id); code = thread[i] != NULL ? 0 : (int)GetLastError(); # else code = pthread_create(&thread[i], 0, run_one_test, (void *)(size_t)i); # endif if (code != 0) { fprintf(stderr, "Thread creation failed %u\n", (unsigned)code); exit(3); } } /* We use the main thread to run one test. This allows gprof */ /* profiling to work, for example. */ run_one_test(0); for (i = 1; i < nthreads; ++i) { int code; # ifdef USE_WINTHREADS code = WaitForSingleObject(thread[i], INFINITE) == WAIT_OBJECT_0 ? 0 : (int)GetLastError(); # else code = pthread_join(thread[i], 0); # endif if (code != 0) { fprintf(stderr, "Thread join failed %u\n", (unsigned)code); abort(); } } times[nthreads][exper_n] = (unsigned long)(get_msecs() - start_time); # ifdef VERBOSE printf("%d %lu\n", nthreads, (unsigned long)(get_msecs() - start_time)); printf("final list (should be reordered initial list):\n"); print_list(); # endif check_list(list_length); while ((le = (list_element *)AO_stack_pop(&the_list)) != 0) free(le); } for (nthreads = 1; nthreads <= max_nthreads; ++nthreads) { # ifndef NO_TIMES unsigned long sum = 0; # endif printf("About %d pushes + %d pops in %d threads:", LIMIT, LIMIT, nthreads); # ifndef NO_TIMES for (exper_n = 0; exper_n < N_EXPERIMENTS; ++exper_n) { # if defined(VERBOSE) printf(" [%lu]", times[nthreads][exper_n]); # endif sum += times[nthreads][exper_n]; } printf(" %lu msecs\n", (sum + N_EXPERIMENTS/2)/N_EXPERIMENTS); # else printf(" completed\n"); # endif } return 0; } #endif ecl-16.1.2/src/bdwgc/ltmain.sh000066400000000000000000011707711266352375300160730ustar00rootroot00000000000000#! /bin/sh ## DO NOT EDIT - This file generated from ./build-aux/ltmain.in ## by inline-source v2014-01-03.01 # libtool (GNU libtool) 2.4.6 # Provide generalized library-building support services. # Written by Gordon Matzigkeit , 1996 # Copyright (C) 1996-2015 Free Software Foundation, Inc. # This is free software; see the source for copying conditions. There is NO # warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. # 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 this program. If not, see . PROGRAM=libtool PACKAGE=libtool VERSION=2.4.6 package_revision=2.4.6 ## ------ ## ## Usage. ## ## ------ ## # Run './libtool --help' for help with using this script from the # command line. ## ------------------------------- ## ## User overridable command paths. ## ## ------------------------------- ## # After configure completes, it has a better idea of some of the # shell tools we need than the defaults used by the functions shared # with bootstrap, so set those here where they can still be over- # ridden by the user, but otherwise take precedence. : ${AUTOCONF="autoconf"} : ${AUTOMAKE="automake"} ## -------------------------- ## ## Source external libraries. ## ## -------------------------- ## # Much of our low-level functionality needs to be sourced from external # libraries, which are installed to $pkgauxdir. # Set a version string for this script. scriptversion=2015-01-20.17; # UTC # General shell script boiler plate, and helper functions. # Written by Gary V. Vaughan, 2004 # Copyright (C) 2004-2015 Free Software Foundation, Inc. # This is free software; see the source for copying conditions. There is NO # warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. # 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. # 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. # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNES 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 . # Please report bugs or propose patches to gary@gnu.org. ## ------ ## ## Usage. ## ## ------ ## # Evaluate this file near the top of your script to gain access to # the functions and variables defined here: # # . `echo "$0" | ${SED-sed} 's|[^/]*$||'`/build-aux/funclib.sh # # If you need to override any of the default environment variable # settings, do that before evaluating this file. ## -------------------- ## ## Shell normalisation. ## ## -------------------- ## # Some shells need a little help to be as Bourne compatible as possible. # Before doing anything else, make sure all that help has been provided! 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 # NLS nuisances: We save the old values in case they are required later. _G_user_locale= _G_safe_locale= for _G_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES do eval "if test set = \"\${$_G_var+set}\"; then save_$_G_var=\$$_G_var $_G_var=C export $_G_var _G_user_locale=\"$_G_var=\\\$save_\$_G_var; \$_G_user_locale\" _G_safe_locale=\"$_G_var=C; \$_G_safe_locale\" fi" done # CDPATH. (unset CDPATH) >/dev/null 2>&1 && unset CDPATH # Make sure IFS has a sensible default sp=' ' nl=' ' IFS="$sp $nl" # There are apparently some retarded systems that use ';' as a PATH separator! 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 ## ------------------------- ## ## Locate command utilities. ## ## ------------------------- ## # func_executable_p FILE # ---------------------- # Check that FILE is an executable regular file. func_executable_p () { test -f "$1" && test -x "$1" } # func_path_progs PROGS_LIST CHECK_FUNC [PATH] # -------------------------------------------- # Search for either a program that responds to --version with output # containing "GNU", or else returned by CHECK_FUNC otherwise, by # trying all the directories in PATH with each of the elements of # PROGS_LIST. # # CHECK_FUNC should accept the path to a candidate program, and # set $func_check_prog_result if it truncates its output less than # $_G_path_prog_max characters. func_path_progs () { _G_progs_list=$1 _G_check_func=$2 _G_PATH=${3-"$PATH"} _G_path_prog_max=0 _G_path_prog_found=false _G_save_IFS=$IFS; IFS=${PATH_SEPARATOR-:} for _G_dir in $_G_PATH; do IFS=$_G_save_IFS test -z "$_G_dir" && _G_dir=. for _G_prog_name in $_G_progs_list; do for _exeext in '' .EXE; do _G_path_prog=$_G_dir/$_G_prog_name$_exeext func_executable_p "$_G_path_prog" || continue case `"$_G_path_prog" --version 2>&1` in *GNU*) func_path_progs_result=$_G_path_prog _G_path_prog_found=: ;; *) $_G_check_func $_G_path_prog func_path_progs_result=$func_check_prog_result ;; esac $_G_path_prog_found && break 3 done done done IFS=$_G_save_IFS test -z "$func_path_progs_result" && { echo "no acceptable sed could be found in \$PATH" >&2 exit 1 } } # We want to be able to use the functions in this file before configure # has figured out where the best binaries are kept, which means we have # to search for them ourselves - except when the results are already set # where we skip the searches. # Unless the user overrides by setting SED, search the path for either GNU # sed, or the sed that truncates its output the least. test -z "$SED" && { _G_sed_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/ for _G_i in 1 2 3 4 5 6 7; do _G_sed_script=$_G_sed_script$nl$_G_sed_script done echo "$_G_sed_script" 2>/dev/null | sed 99q >conftest.sed _G_sed_script= func_check_prog_sed () { _G_path_prog=$1 _G_count=0 printf 0123456789 >conftest.in while : do cat conftest.in conftest.in >conftest.tmp mv conftest.tmp conftest.in cp conftest.in conftest.nl echo '' >> conftest.nl "$_G_path_prog" -f conftest.sed conftest.out 2>/dev/null || break diff conftest.out conftest.nl >/dev/null 2>&1 || break _G_count=`expr $_G_count + 1` if test "$_G_count" -gt "$_G_path_prog_max"; then # Best one so far, save it but keep looking for a better one func_check_prog_result=$_G_path_prog _G_path_prog_max=$_G_count fi # 10*(2^10) chars as input seems more than enough test 10 -lt "$_G_count" && break done rm -f conftest.in conftest.tmp conftest.nl conftest.out } func_path_progs "sed gsed" func_check_prog_sed $PATH:/usr/xpg4/bin rm -f conftest.sed SED=$func_path_progs_result } # Unless the user overrides by setting GREP, search the path for either GNU # grep, or the grep that truncates its output the least. test -z "$GREP" && { func_check_prog_grep () { _G_path_prog=$1 _G_count=0 _G_path_prog_max=0 printf 0123456789 >conftest.in while : do cat conftest.in conftest.in >conftest.tmp mv conftest.tmp conftest.in cp conftest.in conftest.nl echo 'GREP' >> conftest.nl "$_G_path_prog" -e 'GREP$' -e '-(cannot match)-' conftest.out 2>/dev/null || break diff conftest.out conftest.nl >/dev/null 2>&1 || break _G_count=`expr $_G_count + 1` if test "$_G_count" -gt "$_G_path_prog_max"; then # Best one so far, save it but keep looking for a better one func_check_prog_result=$_G_path_prog _G_path_prog_max=$_G_count fi # 10*(2^10) chars as input seems more than enough test 10 -lt "$_G_count" && break done rm -f conftest.in conftest.tmp conftest.nl conftest.out } func_path_progs "grep ggrep" func_check_prog_grep $PATH:/usr/xpg4/bin GREP=$func_path_progs_result } ## ------------------------------- ## ## User overridable command paths. ## ## ------------------------------- ## # All uppercase variable names are used for environment variables. These # variables can be overridden by the user before calling a script that # uses them if a suitable command of that name is not already available # in the command search PATH. : ${CP="cp -f"} : ${ECHO="printf %s\n"} : ${EGREP="$GREP -E"} : ${FGREP="$GREP -F"} : ${LN_S="ln -s"} : ${MAKE="make"} : ${MKDIR="mkdir"} : ${MV="mv -f"} : ${RM="rm -f"} : ${SHELL="${CONFIG_SHELL-/bin/sh}"} ## -------------------- ## ## Useful sed snippets. ## ## -------------------- ## sed_dirname='s|/[^/]*$||' sed_basename='s|^.*/||' # Sed substitution that helps us do robust quoting. It backslashifies # metacharacters that are still active within double-quoted strings. sed_quote_subst='s|\([`"$\\]\)|\\\1|g' # Same as above, but do not quote variable references. sed_double_quote_subst='s/\(["`\\]\)/\\\1/g' # Sed substitution that turns a string into a regex matching for the # string literally. sed_make_literal_regex='s|[].[^$\\*\/]|\\&|g' # Sed substitution that converts a w32 file name or path # that contains forward slashes, into one that contains # (escaped) backslashes. A very naive implementation. sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g' # Re-'\' parameter expansions in output of sed_double_quote_subst that # were '\'-ed in input to the same. If an odd number of '\' preceded a # '$' in input to sed_double_quote_subst, that '$' was protected from # expansion. Since each input '\' is now two '\'s, look for any number # of runs of four '\'s followed by two '\'s and then a '$'. '\' that '$'. _G_bs='\\' _G_bs2='\\\\' _G_bs4='\\\\\\\\' _G_dollar='\$' sed_double_backslash="\ s/$_G_bs4/&\\ /g s/^$_G_bs2$_G_dollar/$_G_bs&/ s/\\([^$_G_bs]\\)$_G_bs2$_G_dollar/\\1$_G_bs2$_G_bs$_G_dollar/g s/\n//g" ## ----------------- ## ## Global variables. ## ## ----------------- ## # Except for the global variables explicitly listed below, the following # functions in the '^func_' namespace, and the '^require_' namespace # variables initialised in the 'Resource management' section, sourcing # this file will not pollute your global namespace with anything # else. There's no portable way to scope variables in Bourne shell # though, so actually running these functions will sometimes place # results into a variable named after the function, and often use # temporary variables in the '^_G_' namespace. If you are careful to # avoid using those namespaces casually in your sourcing script, things # should continue to work as you expect. And, of course, you can freely # overwrite any of the functions or variables defined here before # calling anything to customize them. EXIT_SUCCESS=0 EXIT_FAILURE=1 EXIT_MISMATCH=63 # $? = 63 is used to indicate version mismatch to missing. EXIT_SKIP=77 # $? = 77 is used to indicate a skipped test to automake. # Allow overriding, eg assuming that you follow the convention of # putting '$debug_cmd' at the start of all your functions, you can get # bash to show function call trace with: # # debug_cmd='eval echo "${FUNCNAME[0]} $*" >&2' bash your-script-name debug_cmd=${debug_cmd-":"} exit_cmd=: # By convention, finish your script with: # # exit $exit_status # # so that you can set exit_status to non-zero if you want to indicate # something went wrong during execution without actually bailing out at # the point of failure. exit_status=$EXIT_SUCCESS # Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh # is ksh but when the shell is invoked as "sh" and the current value of # the _XPG environment variable is not equal to 1 (one), the special # positional parameter $0, within a function call, is the name of the # function. progpath=$0 # The name of this program. progname=`$ECHO "$progpath" |$SED "$sed_basename"` # Make sure we have an absolute progpath for reexecution: case $progpath in [\\/]*|[A-Za-z]:\\*) ;; *[\\/]*) progdir=`$ECHO "$progpath" |$SED "$sed_dirname"` progdir=`cd "$progdir" && pwd` progpath=$progdir/$progname ;; *) _G_IFS=$IFS IFS=${PATH_SEPARATOR-:} for progdir in $PATH; do IFS=$_G_IFS test -x "$progdir/$progname" && break done IFS=$_G_IFS test -n "$progdir" || progdir=`pwd` progpath=$progdir/$progname ;; esac ## ----------------- ## ## Standard options. ## ## ----------------- ## # The following options affect the operation of the functions defined # below, and should be set appropriately depending on run-time para- # meters passed on the command line. opt_dry_run=false opt_quiet=false opt_verbose=false # Categories 'all' and 'none' are always available. Append any others # you will pass as the first argument to func_warning from your own # code. warning_categories= # By default, display warnings according to 'opt_warning_types'. Set # 'warning_func' to ':' to elide all warnings, or func_fatal_error to # treat the next displayed warning as a fatal error. warning_func=func_warn_and_continue # Set to 'all' to display all warnings, 'none' to suppress all # warnings, or a space delimited list of some subset of # 'warning_categories' to display only the listed warnings. opt_warning_types=all ## -------------------- ## ## Resource management. ## ## -------------------- ## # This section contains definitions for functions that each ensure a # particular resource (a file, or a non-empty configuration variable for # example) is available, and if appropriate to extract default values # from pertinent package files. Call them using their associated # 'require_*' variable to ensure that they are executed, at most, once. # # It's entirely deliberate that calling these functions can set # variables that don't obey the namespace limitations obeyed by the rest # of this file, in order that that they be as useful as possible to # callers. # require_term_colors # ------------------- # Allow display of bold text on terminals that support it. require_term_colors=func_require_term_colors func_require_term_colors () { $debug_cmd test -t 1 && { # COLORTERM and USE_ANSI_COLORS environment variables take # precedence, because most terminfo databases neglect to describe # whether color sequences are supported. test -n "${COLORTERM+set}" && : ${USE_ANSI_COLORS="1"} if test 1 = "$USE_ANSI_COLORS"; then # Standard ANSI escape sequences tc_reset='' tc_bold=''; tc_standout='' tc_red=''; tc_green='' tc_blue=''; tc_cyan='' else # Otherwise trust the terminfo database after all. test -n "`tput sgr0 2>/dev/null`" && { tc_reset=`tput sgr0` test -n "`tput bold 2>/dev/null`" && tc_bold=`tput bold` tc_standout=$tc_bold test -n "`tput smso 2>/dev/null`" && tc_standout=`tput smso` test -n "`tput setaf 1 2>/dev/null`" && tc_red=`tput setaf 1` test -n "`tput setaf 2 2>/dev/null`" && tc_green=`tput setaf 2` test -n "`tput setaf 4 2>/dev/null`" && tc_blue=`tput setaf 4` test -n "`tput setaf 5 2>/dev/null`" && tc_cyan=`tput setaf 5` } fi } require_term_colors=: } ## ----------------- ## ## Function library. ## ## ----------------- ## # This section contains a variety of useful functions to call in your # scripts. Take note of the portable wrappers for features provided by # some modern shells, which will fall back to slower equivalents on # less featureful shells. # func_append VAR VALUE # --------------------- # Append VALUE onto the existing contents of VAR. # We should try to minimise forks, especially on Windows where they are # unreasonably slow, so skip the feature probes when bash or zsh are # being used: if test set = "${BASH_VERSION+set}${ZSH_VERSION+set}"; then : ${_G_HAVE_ARITH_OP="yes"} : ${_G_HAVE_XSI_OPS="yes"} # The += operator was introduced in bash 3.1 case $BASH_VERSION in [12].* | 3.0 | 3.0*) ;; *) : ${_G_HAVE_PLUSEQ_OP="yes"} ;; esac fi # _G_HAVE_PLUSEQ_OP # Can be empty, in which case the shell is probed, "yes" if += is # useable or anything else if it does not work. test -z "$_G_HAVE_PLUSEQ_OP" \ && (eval 'x=a; x+=" b"; test "a b" = "$x"') 2>/dev/null \ && _G_HAVE_PLUSEQ_OP=yes if test yes = "$_G_HAVE_PLUSEQ_OP" then # This is an XSI compatible shell, allowing a faster implementation... eval 'func_append () { $debug_cmd eval "$1+=\$2" }' else # ...otherwise fall back to using expr, which is often a shell builtin. func_append () { $debug_cmd eval "$1=\$$1\$2" } fi # func_append_quoted VAR VALUE # ---------------------------- # Quote VALUE and append to the end of shell variable VAR, separated # by a space. if test yes = "$_G_HAVE_PLUSEQ_OP"; then eval 'func_append_quoted () { $debug_cmd func_quote_for_eval "$2" eval "$1+=\\ \$func_quote_for_eval_result" }' else func_append_quoted () { $debug_cmd func_quote_for_eval "$2" eval "$1=\$$1\\ \$func_quote_for_eval_result" } fi # func_append_uniq VAR VALUE # -------------------------- # Append unique VALUE onto the existing contents of VAR, assuming # entries are delimited by the first character of VALUE. For example: # # func_append_uniq options " --another-option option-argument" # # will only append to $options if " --another-option option-argument " # is not already present somewhere in $options already (note spaces at # each end implied by leading space in second argument). func_append_uniq () { $debug_cmd eval _G_current_value='`$ECHO $'$1'`' _G_delim=`expr "$2" : '\(.\)'` case $_G_delim$_G_current_value$_G_delim in *"$2$_G_delim"*) ;; *) func_append "$@" ;; esac } # func_arith TERM... # ------------------ # Set func_arith_result to the result of evaluating TERMs. test -z "$_G_HAVE_ARITH_OP" \ && (eval 'test 2 = $(( 1 + 1 ))') 2>/dev/null \ && _G_HAVE_ARITH_OP=yes if test yes = "$_G_HAVE_ARITH_OP"; then eval 'func_arith () { $debug_cmd func_arith_result=$(( $* )) }' else func_arith () { $debug_cmd func_arith_result=`expr "$@"` } fi # func_basename FILE # ------------------ # Set func_basename_result to FILE with everything up to and including # the last / stripped. if test yes = "$_G_HAVE_XSI_OPS"; then # If this shell supports suffix pattern removal, then use it to avoid # forking. Hide the definitions single quotes in case the shell chokes # on unsupported syntax... _b='func_basename_result=${1##*/}' _d='case $1 in */*) func_dirname_result=${1%/*}$2 ;; * ) func_dirname_result=$3 ;; esac' else # ...otherwise fall back to using sed. _b='func_basename_result=`$ECHO "$1" |$SED "$sed_basename"`' _d='func_dirname_result=`$ECHO "$1" |$SED "$sed_dirname"` if test "X$func_dirname_result" = "X$1"; then func_dirname_result=$3 else func_append func_dirname_result "$2" fi' fi eval 'func_basename () { $debug_cmd '"$_b"' }' # func_dirname FILE APPEND NONDIR_REPLACEMENT # ------------------------------------------- # Compute the dirname of FILE. If nonempty, add APPEND to the result, # otherwise set result to NONDIR_REPLACEMENT. eval 'func_dirname () { $debug_cmd '"$_d"' }' # func_dirname_and_basename FILE APPEND NONDIR_REPLACEMENT # -------------------------------------------------------- # Perform func_basename and func_dirname in a single function # call: # dirname: Compute the dirname of FILE. If nonempty, # add APPEND to the result, otherwise set result # to NONDIR_REPLACEMENT. # value returned in "$func_dirname_result" # basename: Compute filename of FILE. # value retuned in "$func_basename_result" # For efficiency, we do not delegate to the functions above but instead # duplicate the functionality here. eval 'func_dirname_and_basename () { $debug_cmd '"$_b"' '"$_d"' }' # func_echo ARG... # ---------------- # Echo program name prefixed message. func_echo () { $debug_cmd _G_message=$* func_echo_IFS=$IFS IFS=$nl for _G_line in $_G_message; do IFS=$func_echo_IFS $ECHO "$progname: $_G_line" done IFS=$func_echo_IFS } # func_echo_all ARG... # -------------------- # Invoke $ECHO with all args, space-separated. func_echo_all () { $ECHO "$*" } # func_echo_infix_1 INFIX ARG... # ------------------------------ # Echo program name, followed by INFIX on the first line, with any # additional lines not showing INFIX. func_echo_infix_1 () { $debug_cmd $require_term_colors _G_infix=$1; shift _G_indent=$_G_infix _G_prefix="$progname: $_G_infix: " _G_message=$* # Strip color escape sequences before counting printable length for _G_tc in "$tc_reset" "$tc_bold" "$tc_standout" "$tc_red" "$tc_green" "$tc_blue" "$tc_cyan" do test -n "$_G_tc" && { _G_esc_tc=`$ECHO "$_G_tc" | $SED "$sed_make_literal_regex"` _G_indent=`$ECHO "$_G_indent" | $SED "s|$_G_esc_tc||g"` } done _G_indent="$progname: "`echo "$_G_indent" | $SED 's|.| |g'`" " ## exclude from sc_prohibit_nested_quotes func_echo_infix_1_IFS=$IFS IFS=$nl for _G_line in $_G_message; do IFS=$func_echo_infix_1_IFS $ECHO "$_G_prefix$tc_bold$_G_line$tc_reset" >&2 _G_prefix=$_G_indent done IFS=$func_echo_infix_1_IFS } # func_error ARG... # ----------------- # Echo program name prefixed message to standard error. func_error () { $debug_cmd $require_term_colors func_echo_infix_1 " $tc_standout${tc_red}error$tc_reset" "$*" >&2 } # func_fatal_error ARG... # ----------------------- # Echo program name prefixed message to standard error, and exit. func_fatal_error () { $debug_cmd func_error "$*" exit $EXIT_FAILURE } # func_grep EXPRESSION FILENAME # ----------------------------- # Check whether EXPRESSION matches any line of FILENAME, without output. func_grep () { $debug_cmd $GREP "$1" "$2" >/dev/null 2>&1 } # func_len STRING # --------------- # Set func_len_result to the length of STRING. STRING may not # start with a hyphen. test -z "$_G_HAVE_XSI_OPS" \ && (eval 'x=a/b/c; test 5aa/bb/cc = "${#x}${x%%/*}${x%/*}${x#*/}${x##*/}"') 2>/dev/null \ && _G_HAVE_XSI_OPS=yes if test yes = "$_G_HAVE_XSI_OPS"; then eval 'func_len () { $debug_cmd func_len_result=${#1} }' else func_len () { $debug_cmd func_len_result=`expr "$1" : ".*" 2>/dev/null || echo $max_cmd_len` } fi # func_mkdir_p DIRECTORY-PATH # --------------------------- # Make sure the entire path to DIRECTORY-PATH is available. func_mkdir_p () { $debug_cmd _G_directory_path=$1 _G_dir_list= if test -n "$_G_directory_path" && test : != "$opt_dry_run"; then # Protect directory names starting with '-' case $_G_directory_path in -*) _G_directory_path=./$_G_directory_path ;; esac # While some portion of DIR does not yet exist... while test ! -d "$_G_directory_path"; do # ...make a list in topmost first order. Use a colon delimited # list incase some portion of path contains whitespace. _G_dir_list=$_G_directory_path:$_G_dir_list # If the last portion added has no slash in it, the list is done case $_G_directory_path in */*) ;; *) break ;; esac # ...otherwise throw away the child directory and loop _G_directory_path=`$ECHO "$_G_directory_path" | $SED -e "$sed_dirname"` done _G_dir_list=`$ECHO "$_G_dir_list" | $SED 's|:*$||'` func_mkdir_p_IFS=$IFS; IFS=: for _G_dir in $_G_dir_list; do IFS=$func_mkdir_p_IFS # mkdir can fail with a 'File exist' error if two processes # try to create one of the directories concurrently. Don't # stop in that case! $MKDIR "$_G_dir" 2>/dev/null || : done IFS=$func_mkdir_p_IFS # Bail out if we (or some other process) failed to create a directory. test -d "$_G_directory_path" || \ func_fatal_error "Failed to create '$1'" fi } # func_mktempdir [BASENAME] # ------------------------- # Make a temporary directory that won't clash with other running # libtool processes, and avoids race conditions if possible. If # given, BASENAME is the basename for that directory. func_mktempdir () { $debug_cmd _G_template=${TMPDIR-/tmp}/${1-$progname} if test : = "$opt_dry_run"; then # Return a directory name, but don't create it in dry-run mode _G_tmpdir=$_G_template-$$ else # If mktemp works, use that first and foremost _G_tmpdir=`mktemp -d "$_G_template-XXXXXXXX" 2>/dev/null` if test ! -d "$_G_tmpdir"; then # Failing that, at least try and use $RANDOM to avoid a race _G_tmpdir=$_G_template-${RANDOM-0}$$ func_mktempdir_umask=`umask` umask 0077 $MKDIR "$_G_tmpdir" umask $func_mktempdir_umask fi # If we're not in dry-run mode, bomb out on failure test -d "$_G_tmpdir" || \ func_fatal_error "cannot create temporary directory '$_G_tmpdir'" fi $ECHO "$_G_tmpdir" } # func_normal_abspath PATH # ------------------------ # Remove doubled-up and trailing slashes, "." path components, # and cancel out any ".." path components in PATH after making # it an absolute path. func_normal_abspath () { $debug_cmd # These SED scripts presuppose an absolute path with a trailing slash. _G_pathcar='s|^/\([^/]*\).*$|\1|' _G_pathcdr='s|^/[^/]*||' _G_removedotparts=':dotsl s|/\./|/|g t dotsl s|/\.$|/|' _G_collapseslashes='s|/\{1,\}|/|g' _G_finalslash='s|/*$|/|' # Start from root dir and reassemble the path. func_normal_abspath_result= func_normal_abspath_tpath=$1 func_normal_abspath_altnamespace= case $func_normal_abspath_tpath in "") # Empty path, that just means $cwd. func_stripname '' '/' "`pwd`" func_normal_abspath_result=$func_stripname_result return ;; # The next three entries are used to spot a run of precisely # two leading slashes without using negated character classes; # we take advantage of case's first-match behaviour. ///*) # Unusual form of absolute path, do nothing. ;; //*) # Not necessarily an ordinary path; POSIX reserves leading '//' # and for example Cygwin uses it to access remote file shares # over CIFS/SMB, so we conserve a leading double slash if found. func_normal_abspath_altnamespace=/ ;; /*) # Absolute path, do nothing. ;; *) # Relative path, prepend $cwd. func_normal_abspath_tpath=`pwd`/$func_normal_abspath_tpath ;; esac # Cancel out all the simple stuff to save iterations. We also want # the path to end with a slash for ease of parsing, so make sure # there is one (and only one) here. func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \ -e "$_G_removedotparts" -e "$_G_collapseslashes" -e "$_G_finalslash"` while :; do # Processed it all yet? if test / = "$func_normal_abspath_tpath"; then # If we ascended to the root using ".." the result may be empty now. if test -z "$func_normal_abspath_result"; then func_normal_abspath_result=/ fi break fi func_normal_abspath_tcomponent=`$ECHO "$func_normal_abspath_tpath" | $SED \ -e "$_G_pathcar"` func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \ -e "$_G_pathcdr"` # Figure out what to do with it case $func_normal_abspath_tcomponent in "") # Trailing empty path component, ignore it. ;; ..) # Parent dir; strip last assembled component from result. func_dirname "$func_normal_abspath_result" func_normal_abspath_result=$func_dirname_result ;; *) # Actual path component, append it. func_append func_normal_abspath_result "/$func_normal_abspath_tcomponent" ;; esac done # Restore leading double-slash if one was found on entry. func_normal_abspath_result=$func_normal_abspath_altnamespace$func_normal_abspath_result } # func_notquiet ARG... # -------------------- # Echo program name prefixed message only when not in quiet mode. func_notquiet () { $debug_cmd $opt_quiet || func_echo ${1+"$@"} # A bug in bash halts the script if the last line of a function # fails when set -e is in force, so we need another command to # work around that: : } # func_relative_path SRCDIR DSTDIR # -------------------------------- # Set func_relative_path_result to the relative path from SRCDIR to DSTDIR. func_relative_path () { $debug_cmd func_relative_path_result= func_normal_abspath "$1" func_relative_path_tlibdir=$func_normal_abspath_result func_normal_abspath "$2" func_relative_path_tbindir=$func_normal_abspath_result # Ascend the tree starting from libdir while :; do # check if we have found a prefix of bindir case $func_relative_path_tbindir in $func_relative_path_tlibdir) # found an exact match func_relative_path_tcancelled= break ;; $func_relative_path_tlibdir*) # found a matching prefix func_stripname "$func_relative_path_tlibdir" '' "$func_relative_path_tbindir" func_relative_path_tcancelled=$func_stripname_result if test -z "$func_relative_path_result"; then func_relative_path_result=. fi break ;; *) func_dirname $func_relative_path_tlibdir func_relative_path_tlibdir=$func_dirname_result if test -z "$func_relative_path_tlibdir"; then # Have to descend all the way to the root! func_relative_path_result=../$func_relative_path_result func_relative_path_tcancelled=$func_relative_path_tbindir break fi func_relative_path_result=../$func_relative_path_result ;; esac done # Now calculate path; take care to avoid doubling-up slashes. func_stripname '' '/' "$func_relative_path_result" func_relative_path_result=$func_stripname_result func_stripname '/' '/' "$func_relative_path_tcancelled" if test -n "$func_stripname_result"; then func_append func_relative_path_result "/$func_stripname_result" fi # Normalisation. If bindir is libdir, return '.' else relative path. if test -n "$func_relative_path_result"; then func_stripname './' '' "$func_relative_path_result" func_relative_path_result=$func_stripname_result fi test -n "$func_relative_path_result" || func_relative_path_result=. : } # func_quote_for_eval ARG... # -------------------------- # Aesthetically quote ARGs to be evaled later. # This function returns two values: # i) func_quote_for_eval_result # double-quoted, suitable for a subsequent eval # ii) func_quote_for_eval_unquoted_result # has all characters that are still active within double # quotes backslashified. func_quote_for_eval () { $debug_cmd func_quote_for_eval_unquoted_result= func_quote_for_eval_result= while test 0 -lt $#; do case $1 in *[\\\`\"\$]*) _G_unquoted_arg=`printf '%s\n' "$1" |$SED "$sed_quote_subst"` ;; *) _G_unquoted_arg=$1 ;; esac if test -n "$func_quote_for_eval_unquoted_result"; then func_append func_quote_for_eval_unquoted_result " $_G_unquoted_arg" else func_append func_quote_for_eval_unquoted_result "$_G_unquoted_arg" fi case $_G_unquoted_arg in # Double-quote args containing shell metacharacters to delay # word splitting, command substitution and variable expansion # for a subsequent eval. # Many Bourne shells cannot handle close brackets correctly # in scan sets, so we specify it separately. *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"") _G_quoted_arg=\"$_G_unquoted_arg\" ;; *) _G_quoted_arg=$_G_unquoted_arg ;; esac if test -n "$func_quote_for_eval_result"; then func_append func_quote_for_eval_result " $_G_quoted_arg" else func_append func_quote_for_eval_result "$_G_quoted_arg" fi shift done } # func_quote_for_expand ARG # ------------------------- # Aesthetically quote ARG to be evaled later; same as above, # but do not quote variable references. func_quote_for_expand () { $debug_cmd case $1 in *[\\\`\"]*) _G_arg=`$ECHO "$1" | $SED \ -e "$sed_double_quote_subst" -e "$sed_double_backslash"` ;; *) _G_arg=$1 ;; esac case $_G_arg in # Double-quote args containing shell metacharacters to delay # word splitting and command substitution for a subsequent eval. # Many Bourne shells cannot handle close brackets correctly # in scan sets, so we specify it separately. *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"") _G_arg=\"$_G_arg\" ;; esac func_quote_for_expand_result=$_G_arg } # func_stripname PREFIX SUFFIX NAME # --------------------------------- # strip PREFIX and SUFFIX from NAME, and store in func_stripname_result. # PREFIX and SUFFIX must not contain globbing or regex special # characters, hashes, percent signs, but SUFFIX may contain a leading # dot (in which case that matches only a dot). if test yes = "$_G_HAVE_XSI_OPS"; then eval 'func_stripname () { $debug_cmd # pdksh 5.2.14 does not do ${X%$Y} correctly if both X and Y are # positional parameters, so assign one to ordinary variable first. func_stripname_result=$3 func_stripname_result=${func_stripname_result#"$1"} func_stripname_result=${func_stripname_result%"$2"} }' else func_stripname () { $debug_cmd case $2 in .*) func_stripname_result=`$ECHO "$3" | $SED -e "s%^$1%%" -e "s%\\\\$2\$%%"`;; *) func_stripname_result=`$ECHO "$3" | $SED -e "s%^$1%%" -e "s%$2\$%%"`;; esac } fi # func_show_eval CMD [FAIL_EXP] # ----------------------------- # Unless opt_quiet is true, then output CMD. Then, if opt_dryrun is # not true, evaluate CMD. If the evaluation of CMD fails, and FAIL_EXP # is given, then evaluate it. func_show_eval () { $debug_cmd _G_cmd=$1 _G_fail_exp=${2-':'} func_quote_for_expand "$_G_cmd" eval "func_notquiet $func_quote_for_expand_result" $opt_dry_run || { eval "$_G_cmd" _G_status=$? if test 0 -ne "$_G_status"; then eval "(exit $_G_status); $_G_fail_exp" fi } } # func_show_eval_locale CMD [FAIL_EXP] # ------------------------------------ # Unless opt_quiet is true, then output CMD. Then, if opt_dryrun is # not true, evaluate CMD. If the evaluation of CMD fails, and FAIL_EXP # is given, then evaluate it. Use the saved locale for evaluation. func_show_eval_locale () { $debug_cmd _G_cmd=$1 _G_fail_exp=${2-':'} $opt_quiet || { func_quote_for_expand "$_G_cmd" eval "func_echo $func_quote_for_expand_result" } $opt_dry_run || { eval "$_G_user_locale $_G_cmd" _G_status=$? eval "$_G_safe_locale" if test 0 -ne "$_G_status"; then eval "(exit $_G_status); $_G_fail_exp" fi } } # func_tr_sh # ---------- # Turn $1 into a string suitable for a shell variable name. # Result is stored in $func_tr_sh_result. All characters # not in the set a-zA-Z0-9_ are replaced with '_'. Further, # if $1 begins with a digit, a '_' is prepended as well. func_tr_sh () { $debug_cmd case $1 in [0-9]* | *[!a-zA-Z0-9_]*) func_tr_sh_result=`$ECHO "$1" | $SED -e 's/^\([0-9]\)/_\1/' -e 's/[^a-zA-Z0-9_]/_/g'` ;; * ) func_tr_sh_result=$1 ;; esac } # func_verbose ARG... # ------------------- # Echo program name prefixed message in verbose mode only. func_verbose () { $debug_cmd $opt_verbose && func_echo "$*" : } # func_warn_and_continue ARG... # ----------------------------- # Echo program name prefixed warning message to standard error. func_warn_and_continue () { $debug_cmd $require_term_colors func_echo_infix_1 "${tc_red}warning$tc_reset" "$*" >&2 } # func_warning CATEGORY ARG... # ---------------------------- # Echo program name prefixed warning message to standard error. Warning # messages can be filtered according to CATEGORY, where this function # elides messages where CATEGORY is not listed in the global variable # 'opt_warning_types'. func_warning () { $debug_cmd # CATEGORY must be in the warning_categories list! case " $warning_categories " in *" $1 "*) ;; *) func_internal_error "invalid warning category '$1'" ;; esac _G_category=$1 shift case " $opt_warning_types " in *" $_G_category "*) $warning_func ${1+"$@"} ;; esac } # func_sort_ver VER1 VER2 # ----------------------- # 'sort -V' is not generally available. # Note this deviates from the version comparison in automake # in that it treats 1.5 < 1.5.0, and treats 1.4.4a < 1.4-p3a # but this should suffice as we won't be specifying old # version formats or redundant trailing .0 in bootstrap.conf. # If we did want full compatibility then we should probably # use m4_version_compare from autoconf. func_sort_ver () { $debug_cmd printf '%s\n%s\n' "$1" "$2" \ | sort -t. -k 1,1n -k 2,2n -k 3,3n -k 4,4n -k 5,5n -k 6,6n -k 7,7n -k 8,8n -k 9,9n } # func_lt_ver PREV CURR # --------------------- # Return true if PREV and CURR are in the correct order according to # func_sort_ver, otherwise false. Use it like this: # # func_lt_ver "$prev_ver" "$proposed_ver" || func_fatal_error "..." func_lt_ver () { $debug_cmd test "x$1" = x`func_sort_ver "$1" "$2" | $SED 1q` } # Local variables: # mode: shell-script # sh-indentation: 2 # eval: (add-hook 'before-save-hook 'time-stamp) # time-stamp-pattern: "10/scriptversion=%:y-%02m-%02d.%02H; # UTC" # time-stamp-time-zone: "UTC" # End: #! /bin/sh # Set a version string for this script. scriptversion=2014-01-07.03; # UTC # A portable, pluggable option parser for Bourne shell. # Written by Gary V. Vaughan, 2010 # Copyright (C) 2010-2015 Free Software Foundation, Inc. # This is free software; see the source for copying conditions. There is NO # warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. # 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 . # Please report bugs or propose patches to gary@gnu.org. ## ------ ## ## Usage. ## ## ------ ## # This file is a library for parsing options in your shell scripts along # with assorted other useful supporting features that you can make use # of too. # # For the simplest scripts you might need only: # # #!/bin/sh # . relative/path/to/funclib.sh # . relative/path/to/options-parser # scriptversion=1.0 # func_options ${1+"$@"} # eval set dummy "$func_options_result"; shift # ...rest of your script... # # In order for the '--version' option to work, you will need to have a # suitably formatted comment like the one at the top of this file # starting with '# Written by ' and ending with '# warranty; '. # # For '-h' and '--help' to work, you will also need a one line # description of your script's purpose in a comment directly above the # '# Written by ' line, like the one at the top of this file. # # The default options also support '--debug', which will turn on shell # execution tracing (see the comment above debug_cmd below for another # use), and '--verbose' and the func_verbose function to allow your script # to display verbose messages only when your user has specified # '--verbose'. # # After sourcing this file, you can plug processing for additional # options by amending the variables from the 'Configuration' section # below, and following the instructions in the 'Option parsing' # section further down. ## -------------- ## ## Configuration. ## ## -------------- ## # You should override these variables in your script after sourcing this # file so that they reflect the customisations you have added to the # option parser. # The usage line for option parsing errors and the start of '-h' and # '--help' output messages. You can embed shell variables for delayed # expansion at the time the message is displayed, but you will need to # quote other shell meta-characters carefully to prevent them being # expanded when the contents are evaled. usage='$progpath [OPTION]...' # Short help message in response to '-h' and '--help'. Add to this or # override it after sourcing this library to reflect the full set of # options your script accepts. usage_message="\ --debug enable verbose shell tracing -W, --warnings=CATEGORY report the warnings falling in CATEGORY [all] -v, --verbose verbosely report processing --version print version information and exit -h, --help print short or long help message and exit " # Additional text appended to 'usage_message' in response to '--help'. long_help_message=" Warning categories include: 'all' show all warnings 'none' turn off all the warnings 'error' warnings are treated as fatal errors" # Help message printed before fatal option parsing errors. fatal_help="Try '\$progname --help' for more information." ## ------------------------- ## ## Hook function management. ## ## ------------------------- ## # This section contains functions for adding, removing, and running hooks # to the main code. A hook is just a named list of of function, that can # be run in order later on. # func_hookable FUNC_NAME # ----------------------- # Declare that FUNC_NAME will run hooks added with # 'func_add_hook FUNC_NAME ...'. func_hookable () { $debug_cmd func_append hookable_fns " $1" } # func_add_hook FUNC_NAME HOOK_FUNC # --------------------------------- # Request that FUNC_NAME call HOOK_FUNC before it returns. FUNC_NAME must # first have been declared "hookable" by a call to 'func_hookable'. func_add_hook () { $debug_cmd case " $hookable_fns " in *" $1 "*) ;; *) func_fatal_error "'$1' does not accept hook functions." ;; esac eval func_append ${1}_hooks '" $2"' } # func_remove_hook FUNC_NAME HOOK_FUNC # ------------------------------------ # Remove HOOK_FUNC from the list of functions called by FUNC_NAME. func_remove_hook () { $debug_cmd eval ${1}_hooks='`$ECHO "\$'$1'_hooks" |$SED "s| '$2'||"`' } # func_run_hooks FUNC_NAME [ARG]... # --------------------------------- # Run all hook functions registered to FUNC_NAME. # It is assumed that the list of hook functions contains nothing more # than a whitespace-delimited list of legal shell function names, and # no effort is wasted trying to catch shell meta-characters or preserve # whitespace. func_run_hooks () { $debug_cmd case " $hookable_fns " in *" $1 "*) ;; *) func_fatal_error "'$1' does not support hook funcions.n" ;; esac eval _G_hook_fns=\$$1_hooks; shift for _G_hook in $_G_hook_fns; do eval $_G_hook '"$@"' # store returned options list back into positional # parameters for next 'cmd' execution. eval _G_hook_result=\$${_G_hook}_result eval set dummy "$_G_hook_result"; shift done func_quote_for_eval ${1+"$@"} func_run_hooks_result=$func_quote_for_eval_result } ## --------------- ## ## Option parsing. ## ## --------------- ## # In order to add your own option parsing hooks, you must accept the # full positional parameter list in your hook function, remove any # options that you action, and then pass back the remaining unprocessed # options in '_result', escaped suitably for # 'eval'. Like this: # # my_options_prep () # { # $debug_cmd # # # Extend the existing usage message. # usage_message=$usage_message' # -s, --silent don'\''t print informational messages # ' # # func_quote_for_eval ${1+"$@"} # my_options_prep_result=$func_quote_for_eval_result # } # func_add_hook func_options_prep my_options_prep # # # my_silent_option () # { # $debug_cmd # # # Note that for efficiency, we parse as many options as we can # # recognise in a loop before passing the remainder back to the # # caller on the first unrecognised argument we encounter. # while test $# -gt 0; do # opt=$1; shift # case $opt in # --silent|-s) opt_silent=: ;; # # Separate non-argument short options: # -s*) func_split_short_opt "$_G_opt" # set dummy "$func_split_short_opt_name" \ # "-$func_split_short_opt_arg" ${1+"$@"} # shift # ;; # *) set dummy "$_G_opt" "$*"; shift; break ;; # esac # done # # func_quote_for_eval ${1+"$@"} # my_silent_option_result=$func_quote_for_eval_result # } # func_add_hook func_parse_options my_silent_option # # # my_option_validation () # { # $debug_cmd # # $opt_silent && $opt_verbose && func_fatal_help "\ # '--silent' and '--verbose' options are mutually exclusive." # # func_quote_for_eval ${1+"$@"} # my_option_validation_result=$func_quote_for_eval_result # } # func_add_hook func_validate_options my_option_validation # # You'll alse need to manually amend $usage_message to reflect the extra # options you parse. It's preferable to append if you can, so that # multiple option parsing hooks can be added safely. # func_options [ARG]... # --------------------- # All the functions called inside func_options are hookable. See the # individual implementations for details. func_hookable func_options func_options () { $debug_cmd func_options_prep ${1+"$@"} eval func_parse_options \ ${func_options_prep_result+"$func_options_prep_result"} eval func_validate_options \ ${func_parse_options_result+"$func_parse_options_result"} eval func_run_hooks func_options \ ${func_validate_options_result+"$func_validate_options_result"} # save modified positional parameters for caller func_options_result=$func_run_hooks_result } # func_options_prep [ARG]... # -------------------------- # All initialisations required before starting the option parse loop. # Note that when calling hook functions, we pass through the list of # positional parameters. If a hook function modifies that list, and # needs to propogate that back to rest of this script, then the complete # modified list must be put in 'func_run_hooks_result' before # returning. func_hookable func_options_prep func_options_prep () { $debug_cmd # Option defaults: opt_verbose=false opt_warning_types= func_run_hooks func_options_prep ${1+"$@"} # save modified positional parameters for caller func_options_prep_result=$func_run_hooks_result } # func_parse_options [ARG]... # --------------------------- # The main option parsing loop. func_hookable func_parse_options func_parse_options () { $debug_cmd func_parse_options_result= # this just eases exit handling while test $# -gt 0; do # Defer to hook functions for initial option parsing, so they # get priority in the event of reusing an option name. func_run_hooks func_parse_options ${1+"$@"} # Adjust func_parse_options positional parameters to match eval set dummy "$func_run_hooks_result"; shift # Break out of the loop if we already parsed every option. test $# -gt 0 || break _G_opt=$1 shift case $_G_opt in --debug|-x) debug_cmd='set -x' func_echo "enabling shell trace mode" $debug_cmd ;; --no-warnings|--no-warning|--no-warn) set dummy --warnings none ${1+"$@"} shift ;; --warnings|--warning|-W) test $# = 0 && func_missing_arg $_G_opt && break case " $warning_categories $1" in *" $1 "*) # trailing space prevents matching last $1 above func_append_uniq opt_warning_types " $1" ;; *all) opt_warning_types=$warning_categories ;; *none) opt_warning_types=none warning_func=: ;; *error) opt_warning_types=$warning_categories warning_func=func_fatal_error ;; *) func_fatal_error \ "unsupported warning category: '$1'" ;; esac shift ;; --verbose|-v) opt_verbose=: ;; --version) func_version ;; -\?|-h) func_usage ;; --help) func_help ;; # Separate optargs to long options (plugins may need this): --*=*) func_split_equals "$_G_opt" set dummy "$func_split_equals_lhs" \ "$func_split_equals_rhs" ${1+"$@"} shift ;; # Separate optargs to short options: -W*) func_split_short_opt "$_G_opt" set dummy "$func_split_short_opt_name" \ "$func_split_short_opt_arg" ${1+"$@"} shift ;; # Separate non-argument short options: -\?*|-h*|-v*|-x*) func_split_short_opt "$_G_opt" set dummy "$func_split_short_opt_name" \ "-$func_split_short_opt_arg" ${1+"$@"} shift ;; --) break ;; -*) func_fatal_help "unrecognised option: '$_G_opt'" ;; *) set dummy "$_G_opt" ${1+"$@"}; shift; break ;; esac done # save modified positional parameters for caller func_quote_for_eval ${1+"$@"} func_parse_options_result=$func_quote_for_eval_result } # func_validate_options [ARG]... # ------------------------------ # Perform any sanity checks on option settings and/or unconsumed # arguments. func_hookable func_validate_options func_validate_options () { $debug_cmd # Display all warnings if -W was not given. test -n "$opt_warning_types" || opt_warning_types=" $warning_categories" func_run_hooks func_validate_options ${1+"$@"} # Bail if the options were screwed! $exit_cmd $EXIT_FAILURE # save modified positional parameters for caller func_validate_options_result=$func_run_hooks_result } ## ----------------- ## ## Helper functions. ## ## ----------------- ## # This section contains the helper functions used by the rest of the # hookable option parser framework in ascii-betical order. # func_fatal_help ARG... # ---------------------- # Echo program name prefixed message to standard error, followed by # a help hint, and exit. func_fatal_help () { $debug_cmd eval \$ECHO \""Usage: $usage"\" eval \$ECHO \""$fatal_help"\" func_error ${1+"$@"} exit $EXIT_FAILURE } # func_help # --------- # Echo long help message to standard output and exit. func_help () { $debug_cmd func_usage_message $ECHO "$long_help_message" exit 0 } # func_missing_arg ARGNAME # ------------------------ # Echo program name prefixed message to standard error and set global # exit_cmd. func_missing_arg () { $debug_cmd func_error "Missing argument for '$1'." exit_cmd=exit } # func_split_equals STRING # ------------------------ # Set func_split_equals_lhs and func_split_equals_rhs shell variables after # splitting STRING at the '=' sign. test -z "$_G_HAVE_XSI_OPS" \ && (eval 'x=a/b/c; test 5aa/bb/cc = "${#x}${x%%/*}${x%/*}${x#*/}${x##*/}"') 2>/dev/null \ && _G_HAVE_XSI_OPS=yes if test yes = "$_G_HAVE_XSI_OPS" then # This is an XSI compatible shell, allowing a faster implementation... eval 'func_split_equals () { $debug_cmd func_split_equals_lhs=${1%%=*} func_split_equals_rhs=${1#*=} test "x$func_split_equals_lhs" = "x$1" \ && func_split_equals_rhs= }' else # ...otherwise fall back to using expr, which is often a shell builtin. func_split_equals () { $debug_cmd func_split_equals_lhs=`expr "x$1" : 'x\([^=]*\)'` func_split_equals_rhs= test "x$func_split_equals_lhs" = "x$1" \ || func_split_equals_rhs=`expr "x$1" : 'x[^=]*=\(.*\)$'` } fi #func_split_equals # func_split_short_opt SHORTOPT # ----------------------------- # Set func_split_short_opt_name and func_split_short_opt_arg shell # variables after splitting SHORTOPT after the 2nd character. if test yes = "$_G_HAVE_XSI_OPS" then # This is an XSI compatible shell, allowing a faster implementation... eval 'func_split_short_opt () { $debug_cmd func_split_short_opt_arg=${1#??} func_split_short_opt_name=${1%"$func_split_short_opt_arg"} }' else # ...otherwise fall back to using expr, which is often a shell builtin. func_split_short_opt () { $debug_cmd func_split_short_opt_name=`expr "x$1" : 'x-\(.\)'` func_split_short_opt_arg=`expr "x$1" : 'x-.\(.*\)$'` } fi #func_split_short_opt # func_usage # ---------- # Echo short help message to standard output and exit. func_usage () { $debug_cmd func_usage_message $ECHO "Run '$progname --help |${PAGER-more}' for full usage" exit 0 } # func_usage_message # ------------------ # Echo short help message to standard output. func_usage_message () { $debug_cmd eval \$ECHO \""Usage: $usage"\" echo $SED -n 's|^# || /^Written by/{ x;p;x } h /^Written by/q' < "$progpath" echo eval \$ECHO \""$usage_message"\" } # func_version # ------------ # Echo version message to standard output and exit. func_version () { $debug_cmd printf '%s\n' "$progname $scriptversion" $SED -n ' /(C)/!b go :more /\./!{ N s|\n# | | b more } :go /^# Written by /,/# warranty; / { s|^# || s|^# *$|| s|\((C)\)[ 0-9,-]*[ ,-]\([1-9][0-9]* \)|\1 \2| p } /^# Written by / { s|^# || p } /^warranty; /q' < "$progpath" exit $? } # Local variables: # mode: shell-script # sh-indentation: 2 # eval: (add-hook 'before-save-hook 'time-stamp) # time-stamp-pattern: "10/scriptversion=%:y-%02m-%02d.%02H; # UTC" # time-stamp-time-zone: "UTC" # End: # Set a version string. scriptversion='(GNU libtool) 2.4.6' # func_echo ARG... # ---------------- # Libtool also displays the current mode in messages, so override # funclib.sh func_echo with this custom definition. func_echo () { $debug_cmd _G_message=$* func_echo_IFS=$IFS IFS=$nl for _G_line in $_G_message; do IFS=$func_echo_IFS $ECHO "$progname${opt_mode+: $opt_mode}: $_G_line" done IFS=$func_echo_IFS } # func_warning ARG... # ------------------- # Libtool warnings are not categorized, so override funclib.sh # func_warning with this simpler definition. func_warning () { $debug_cmd $warning_func ${1+"$@"} } ## ---------------- ## ## Options parsing. ## ## ---------------- ## # Hook in the functions to make sure our own options are parsed during # the option parsing loop. usage='$progpath [OPTION]... [MODE-ARG]...' # Short help message in response to '-h'. usage_message="Options: --config show all configuration variables --debug enable verbose shell tracing -n, --dry-run display commands without modifying any files --features display basic configuration information and exit --mode=MODE use operation mode MODE --no-warnings equivalent to '-Wnone' --preserve-dup-deps don't remove duplicate dependency libraries --quiet, --silent don't print informational messages --tag=TAG use configuration variables from tag TAG -v, --verbose print more informational messages than default --version print version information -W, --warnings=CATEGORY report the warnings falling in CATEGORY [all] -h, --help, --help-all print short, long, or detailed help message " # Additional text appended to 'usage_message' in response to '--help'. func_help () { $debug_cmd func_usage_message $ECHO "$long_help_message MODE must be one of the following: clean remove files from the build directory compile compile a source file into a libtool object execute automatically set library path, then run a program finish complete the installation of libtool libraries install install libraries or executables link create a library or an executable uninstall remove libraries from an installed directory MODE-ARGS vary depending on the MODE. When passed as first option, '--mode=MODE' may be abbreviated as 'MODE' or a unique abbreviation of that. Try '$progname --help --mode=MODE' for a more detailed description of MODE. When reporting a bug, please describe a test case to reproduce it and include the following information: host-triplet: $host shell: $SHELL compiler: $LTCC compiler flags: $LTCFLAGS linker: $LD (gnu? $with_gnu_ld) version: $progname (GNU libtool) 2.4.6 automake: `($AUTOMAKE --version) 2>/dev/null |$SED 1q` autoconf: `($AUTOCONF --version) 2>/dev/null |$SED 1q` Report bugs to . GNU libtool home page: . General help using GNU software: ." exit 0 } # func_lo2o OBJECT-NAME # --------------------- # Transform OBJECT-NAME from a '.lo' suffix to the platform specific # object suffix. lo2o=s/\\.lo\$/.$objext/ o2lo=s/\\.$objext\$/.lo/ if test yes = "$_G_HAVE_XSI_OPS"; then eval 'func_lo2o () { case $1 in *.lo) func_lo2o_result=${1%.lo}.$objext ;; * ) func_lo2o_result=$1 ;; esac }' # func_xform LIBOBJ-OR-SOURCE # --------------------------- # Transform LIBOBJ-OR-SOURCE from a '.o' or '.c' (or otherwise) # suffix to a '.lo' libtool-object suffix. eval 'func_xform () { func_xform_result=${1%.*}.lo }' else # ...otherwise fall back to using sed. func_lo2o () { func_lo2o_result=`$ECHO "$1" | $SED "$lo2o"` } func_xform () { func_xform_result=`$ECHO "$1" | $SED 's|\.[^.]*$|.lo|'` } fi # func_fatal_configuration ARG... # ------------------------------- # Echo program name prefixed message to standard error, followed by # a configuration failure hint, and exit. func_fatal_configuration () { func__fatal_error ${1+"$@"} \ "See the $PACKAGE documentation for more information." \ "Fatal configuration error." } # func_config # ----------- # Display the configuration for all the tags in this script. func_config () { re_begincf='^# ### BEGIN LIBTOOL' re_endcf='^# ### END LIBTOOL' # Default configuration. $SED "1,/$re_begincf CONFIG/d;/$re_endcf CONFIG/,\$d" < "$progpath" # Now print the configurations for the tags. for tagname in $taglist; do $SED -n "/$re_begincf TAG CONFIG: $tagname\$/,/$re_endcf TAG CONFIG: $tagname\$/p" < "$progpath" done exit $? } # func_features # ------------- # Display the features supported by this script. func_features () { echo "host: $host" if test yes = "$build_libtool_libs"; then echo "enable shared libraries" else echo "disable shared libraries" fi if test yes = "$build_old_libs"; then echo "enable static libraries" else echo "disable static libraries" fi exit $? } # func_enable_tag TAGNAME # ----------------------- # Verify that TAGNAME is valid, and either flag an error and exit, or # enable the TAGNAME tag. We also add TAGNAME to the global $taglist # variable here. func_enable_tag () { # Global variable: tagname=$1 re_begincf="^# ### BEGIN LIBTOOL TAG CONFIG: $tagname\$" re_endcf="^# ### END LIBTOOL TAG CONFIG: $tagname\$" sed_extractcf=/$re_begincf/,/$re_endcf/p # Validate tagname. case $tagname in *[!-_A-Za-z0-9,/]*) func_fatal_error "invalid tag name: $tagname" ;; esac # Don't test for the "default" C tag, as we know it's # there but not specially marked. case $tagname in CC) ;; *) if $GREP "$re_begincf" "$progpath" >/dev/null 2>&1; then taglist="$taglist $tagname" # Evaluate the configuration. Be careful to quote the path # and the sed script, to avoid splitting on whitespace, but # also don't use non-portable quotes within backquotes within # quotes we have to do it in 2 steps: extractedcf=`$SED -n -e "$sed_extractcf" < "$progpath"` eval "$extractedcf" else func_error "ignoring unknown tag $tagname" fi ;; esac } # func_check_version_match # ------------------------ # Ensure that we are using m4 macros, and libtool script from the same # release of libtool. func_check_version_match () { if test "$package_revision" != "$macro_revision"; then if test "$VERSION" != "$macro_version"; then if test -z "$macro_version"; then cat >&2 <<_LT_EOF $progname: Version mismatch error. This is $PACKAGE $VERSION, but the $progname: definition of this LT_INIT comes from an older release. $progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION $progname: and run autoconf again. _LT_EOF else cat >&2 <<_LT_EOF $progname: Version mismatch error. This is $PACKAGE $VERSION, but the $progname: definition of this LT_INIT comes from $PACKAGE $macro_version. $progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION $progname: and run autoconf again. _LT_EOF fi else cat >&2 <<_LT_EOF $progname: Version mismatch error. This is $PACKAGE $VERSION, revision $package_revision, $progname: but the definition of this LT_INIT comes from revision $macro_revision. $progname: You should recreate aclocal.m4 with macros from revision $package_revision $progname: of $PACKAGE $VERSION and run autoconf again. _LT_EOF fi exit $EXIT_MISMATCH fi } # libtool_options_prep [ARG]... # ----------------------------- # Preparation for options parsed by libtool. libtool_options_prep () { $debug_mode # Option defaults: opt_config=false opt_dlopen= opt_dry_run=false opt_help=false opt_mode= opt_preserve_dup_deps=false opt_quiet=false nonopt= preserve_args= # Shorthand for --mode=foo, only valid as the first argument case $1 in clean|clea|cle|cl) shift; set dummy --mode clean ${1+"$@"}; shift ;; compile|compil|compi|comp|com|co|c) shift; set dummy --mode compile ${1+"$@"}; shift ;; execute|execut|execu|exec|exe|ex|e) shift; set dummy --mode execute ${1+"$@"}; shift ;; finish|finis|fini|fin|fi|f) shift; set dummy --mode finish ${1+"$@"}; shift ;; install|instal|insta|inst|ins|in|i) shift; set dummy --mode install ${1+"$@"}; shift ;; link|lin|li|l) shift; set dummy --mode link ${1+"$@"}; shift ;; uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u) shift; set dummy --mode uninstall ${1+"$@"}; shift ;; esac # Pass back the list of options. func_quote_for_eval ${1+"$@"} libtool_options_prep_result=$func_quote_for_eval_result } func_add_hook func_options_prep libtool_options_prep # libtool_parse_options [ARG]... # --------------------------------- # Provide handling for libtool specific options. libtool_parse_options () { $debug_cmd # Perform our own loop to consume as many options as possible in # each iteration. while test $# -gt 0; do _G_opt=$1 shift case $_G_opt in --dry-run|--dryrun|-n) opt_dry_run=: ;; --config) func_config ;; --dlopen|-dlopen) opt_dlopen="${opt_dlopen+$opt_dlopen }$1" shift ;; --preserve-dup-deps) opt_preserve_dup_deps=: ;; --features) func_features ;; --finish) set dummy --mode finish ${1+"$@"}; shift ;; --help) opt_help=: ;; --help-all) opt_help=': help-all' ;; --mode) test $# = 0 && func_missing_arg $_G_opt && break opt_mode=$1 case $1 in # Valid mode arguments: clean|compile|execute|finish|install|link|relink|uninstall) ;; # Catch anything else as an error *) func_error "invalid argument for $_G_opt" exit_cmd=exit break ;; esac shift ;; --no-silent|--no-quiet) opt_quiet=false func_append preserve_args " $_G_opt" ;; --no-warnings|--no-warning|--no-warn) opt_warning=false func_append preserve_args " $_G_opt" ;; --no-verbose) opt_verbose=false func_append preserve_args " $_G_opt" ;; --silent|--quiet) opt_quiet=: opt_verbose=false func_append preserve_args " $_G_opt" ;; --tag) test $# = 0 && func_missing_arg $_G_opt && break opt_tag=$1 func_append preserve_args " $_G_opt $1" func_enable_tag "$1" shift ;; --verbose|-v) opt_quiet=false opt_verbose=: func_append preserve_args " $_G_opt" ;; # An option not handled by this hook function: *) set dummy "$_G_opt" ${1+"$@"}; shift; break ;; esac done # save modified positional parameters for caller func_quote_for_eval ${1+"$@"} libtool_parse_options_result=$func_quote_for_eval_result } func_add_hook func_parse_options libtool_parse_options # libtool_validate_options [ARG]... # --------------------------------- # Perform any sanity checks on option settings and/or unconsumed # arguments. libtool_validate_options () { # save first non-option argument if test 0 -lt $#; then nonopt=$1 shift fi # preserve --debug test : = "$debug_cmd" || func_append preserve_args " --debug" case $host in # Solaris2 added to fix http://debbugs.gnu.org/cgi/bugreport.cgi?bug=16452 # see also: http://gcc.gnu.org/bugzilla/show_bug.cgi?id=59788 *cygwin* | *mingw* | *pw32* | *cegcc* | *solaris2* | *os2*) # don't eliminate duplications in $postdeps and $predeps opt_duplicate_compiler_generated_deps=: ;; *) opt_duplicate_compiler_generated_deps=$opt_preserve_dup_deps ;; esac $opt_help || { # Sanity checks first: func_check_version_match test yes != "$build_libtool_libs" \ && test yes != "$build_old_libs" \ && func_fatal_configuration "not configured to build any kind of library" # Darwin sucks eval std_shrext=\"$shrext_cmds\" # Only execute mode is allowed to have -dlopen flags. if test -n "$opt_dlopen" && test execute != "$opt_mode"; then func_error "unrecognized option '-dlopen'" $ECHO "$help" 1>&2 exit $EXIT_FAILURE fi # Change the help message to a mode-specific one. generic_help=$help help="Try '$progname --help --mode=$opt_mode' for more information." } # Pass back the unparsed argument list func_quote_for_eval ${1+"$@"} libtool_validate_options_result=$func_quote_for_eval_result } func_add_hook func_validate_options libtool_validate_options # Process options as early as possible so that --help and --version # can return quickly. func_options ${1+"$@"} eval set dummy "$func_options_result"; shift ## ----------- ## ## Main. ## ## ----------- ## magic='%%%MAGIC variable%%%' magic_exe='%%%MAGIC EXE variable%%%' # Global variables. extracted_archives= extracted_serial=0 # If this variable is set in any of the actions, the command in it # will be execed at the end. This prevents here-documents from being # left over by shells. exec_cmd= # A function that is used when there is no print builtin or printf. func_fallback_echo () { eval 'cat <<_LTECHO_EOF $1 _LTECHO_EOF' } # func_generated_by_libtool # True iff stdin has been generated by Libtool. This function is only # a basic sanity check; it will hardly flush out determined imposters. func_generated_by_libtool_p () { $GREP "^# Generated by .*$PACKAGE" > /dev/null 2>&1 } # func_lalib_p file # True iff FILE is a libtool '.la' library or '.lo' object file. # This function is only a basic sanity check; it will hardly flush out # determined imposters. func_lalib_p () { test -f "$1" && $SED -e 4q "$1" 2>/dev/null | func_generated_by_libtool_p } # func_lalib_unsafe_p file # True iff FILE is a libtool '.la' library or '.lo' object file. # This function implements the same check as func_lalib_p without # resorting to external programs. To this end, it redirects stdin and # closes it afterwards, without saving the original file descriptor. # As a safety measure, use it only where a negative result would be # fatal anyway. Works if 'file' does not exist. func_lalib_unsafe_p () { lalib_p=no if test -f "$1" && test -r "$1" && exec 5<&0 <"$1"; then for lalib_p_l in 1 2 3 4 do read lalib_p_line case $lalib_p_line in \#\ Generated\ by\ *$PACKAGE* ) lalib_p=yes; break;; esac done exec 0<&5 5<&- fi test yes = "$lalib_p" } # func_ltwrapper_script_p file # True iff FILE is a libtool wrapper script # This function is only a basic sanity check; it will hardly flush out # determined imposters. func_ltwrapper_script_p () { test -f "$1" && $lt_truncate_bin < "$1" 2>/dev/null | func_generated_by_libtool_p } # func_ltwrapper_executable_p file # True iff FILE is a libtool wrapper executable # This function is only a basic sanity check; it will hardly flush out # determined imposters. func_ltwrapper_executable_p () { func_ltwrapper_exec_suffix= case $1 in *.exe) ;; *) func_ltwrapper_exec_suffix=.exe ;; esac $GREP "$magic_exe" "$1$func_ltwrapper_exec_suffix" >/dev/null 2>&1 } # func_ltwrapper_scriptname file # Assumes file is an ltwrapper_executable # uses $file to determine the appropriate filename for a # temporary ltwrapper_script. func_ltwrapper_scriptname () { func_dirname_and_basename "$1" "" "." func_stripname '' '.exe' "$func_basename_result" func_ltwrapper_scriptname_result=$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper } # func_ltwrapper_p file # True iff FILE is a libtool wrapper script or wrapper executable # This function is only a basic sanity check; it will hardly flush out # determined imposters. func_ltwrapper_p () { func_ltwrapper_script_p "$1" || func_ltwrapper_executable_p "$1" } # func_execute_cmds commands fail_cmd # Execute tilde-delimited COMMANDS. # If FAIL_CMD is given, eval that upon failure. # FAIL_CMD may read-access the current command in variable CMD! func_execute_cmds () { $debug_cmd save_ifs=$IFS; IFS='~' for cmd in $1; do IFS=$sp$nl eval cmd=\"$cmd\" IFS=$save_ifs func_show_eval "$cmd" "${2-:}" done IFS=$save_ifs } # func_source file # Source FILE, adding directory component if necessary. # Note that it is not necessary on cygwin/mingw to append a dot to # FILE even if both FILE and FILE.exe exist: automatic-append-.exe # behavior happens only for exec(3), not for open(2)! Also, sourcing # 'FILE.' does not work on cygwin managed mounts. func_source () { $debug_cmd case $1 in */* | *\\*) . "$1" ;; *) . "./$1" ;; esac } # func_resolve_sysroot PATH # Replace a leading = in PATH with a sysroot. Store the result into # func_resolve_sysroot_result func_resolve_sysroot () { func_resolve_sysroot_result=$1 case $func_resolve_sysroot_result in =*) func_stripname '=' '' "$func_resolve_sysroot_result" func_resolve_sysroot_result=$lt_sysroot$func_stripname_result ;; esac } # func_replace_sysroot PATH # If PATH begins with the sysroot, replace it with = and # store the result into func_replace_sysroot_result. func_replace_sysroot () { case $lt_sysroot:$1 in ?*:"$lt_sysroot"*) func_stripname "$lt_sysroot" '' "$1" func_replace_sysroot_result='='$func_stripname_result ;; *) # Including no sysroot. func_replace_sysroot_result=$1 ;; esac } # func_infer_tag arg # Infer tagged configuration to use if any are available and # if one wasn't chosen via the "--tag" command line option. # Only attempt this if the compiler in the base compile # command doesn't match the default compiler. # arg is usually of the form 'gcc ...' func_infer_tag () { $debug_cmd if test -n "$available_tags" && test -z "$tagname"; then CC_quoted= for arg in $CC; do func_append_quoted CC_quoted "$arg" done CC_expanded=`func_echo_all $CC` CC_quoted_expanded=`func_echo_all $CC_quoted` case $@ in # Blanks in the command may have been stripped by the calling shell, # but not from the CC environment variable when configure was run. " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \ " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*) ;; # Blanks at the start of $base_compile will cause this to fail # if we don't check for them as well. *) for z in $available_tags; do if $GREP "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then # Evaluate the configuration. eval "`$SED -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`" CC_quoted= for arg in $CC; do # Double-quote args containing other shell metacharacters. func_append_quoted CC_quoted "$arg" done CC_expanded=`func_echo_all $CC` CC_quoted_expanded=`func_echo_all $CC_quoted` case "$@ " in " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \ " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*) # The compiler in the base compile command matches # the one in the tagged configuration. # Assume this is the tagged configuration we want. tagname=$z break ;; esac fi done # If $tagname still isn't set, then no tagged configuration # was found and let the user know that the "--tag" command # line option must be used. if test -z "$tagname"; then func_echo "unable to infer tagged configuration" func_fatal_error "specify a tag with '--tag'" # else # func_verbose "using $tagname tagged configuration" fi ;; esac fi } # func_write_libtool_object output_name pic_name nonpic_name # Create a libtool object file (analogous to a ".la" file), # but don't create it if we're doing a dry run. func_write_libtool_object () { write_libobj=$1 if test yes = "$build_libtool_libs"; then write_lobj=\'$2\' else write_lobj=none fi if test yes = "$build_old_libs"; then write_oldobj=\'$3\' else write_oldobj=none fi $opt_dry_run || { cat >${write_libobj}T </dev/null` if test "$?" -eq 0 && test -n "$func_convert_core_file_wine_to_w32_tmp"; then func_convert_core_file_wine_to_w32_result=`$ECHO "$func_convert_core_file_wine_to_w32_tmp" | $SED -e "$sed_naive_backslashify"` else func_convert_core_file_wine_to_w32_result= fi fi } # end: func_convert_core_file_wine_to_w32 # func_convert_core_path_wine_to_w32 ARG # Helper function used by path conversion functions when $build is *nix, and # $host is mingw, cygwin, or some other w32 environment. Relies on a correctly # configured wine environment available, with the winepath program in $build's # $PATH. Assumes ARG has no leading or trailing path separator characters. # # ARG is path to be converted from $build format to win32. # Result is available in $func_convert_core_path_wine_to_w32_result. # Unconvertible file (directory) names in ARG are skipped; if no directory names # are convertible, then the result may be empty. func_convert_core_path_wine_to_w32 () { $debug_cmd # unfortunately, winepath doesn't convert paths, only file names func_convert_core_path_wine_to_w32_result= if test -n "$1"; then oldIFS=$IFS IFS=: for func_convert_core_path_wine_to_w32_f in $1; do IFS=$oldIFS func_convert_core_file_wine_to_w32 "$func_convert_core_path_wine_to_w32_f" if test -n "$func_convert_core_file_wine_to_w32_result"; then if test -z "$func_convert_core_path_wine_to_w32_result"; then func_convert_core_path_wine_to_w32_result=$func_convert_core_file_wine_to_w32_result else func_append func_convert_core_path_wine_to_w32_result ";$func_convert_core_file_wine_to_w32_result" fi fi done IFS=$oldIFS fi } # end: func_convert_core_path_wine_to_w32 # func_cygpath ARGS... # Wrapper around calling the cygpath program via LT_CYGPATH. This is used when # when (1) $build is *nix and Cygwin is hosted via a wine environment; or (2) # $build is MSYS and $host is Cygwin, or (3) $build is Cygwin. In case (1) or # (2), returns the Cygwin file name or path in func_cygpath_result (input # file name or path is assumed to be in w32 format, as previously converted # from $build's *nix or MSYS format). In case (3), returns the w32 file name # or path in func_cygpath_result (input file name or path is assumed to be in # Cygwin format). Returns an empty string on error. # # ARGS are passed to cygpath, with the last one being the file name or path to # be converted. # # Specify the absolute *nix (or w32) name to cygpath in the LT_CYGPATH # environment variable; do not put it in $PATH. func_cygpath () { $debug_cmd if test -n "$LT_CYGPATH" && test -f "$LT_CYGPATH"; then func_cygpath_result=`$LT_CYGPATH "$@" 2>/dev/null` if test "$?" -ne 0; then # on failure, ensure result is empty func_cygpath_result= fi else func_cygpath_result= func_error "LT_CYGPATH is empty or specifies non-existent file: '$LT_CYGPATH'" fi } #end: func_cygpath # func_convert_core_msys_to_w32 ARG # Convert file name or path ARG from MSYS format to w32 format. Return # result in func_convert_core_msys_to_w32_result. func_convert_core_msys_to_w32 () { $debug_cmd # awkward: cmd appends spaces to result func_convert_core_msys_to_w32_result=`( cmd //c echo "$1" ) 2>/dev/null | $SED -e 's/[ ]*$//' -e "$sed_naive_backslashify"` } #end: func_convert_core_msys_to_w32 # func_convert_file_check ARG1 ARG2 # Verify that ARG1 (a file name in $build format) was converted to $host # format in ARG2. Otherwise, emit an error message, but continue (resetting # func_to_host_file_result to ARG1). func_convert_file_check () { $debug_cmd if test -z "$2" && test -n "$1"; then func_error "Could not determine host file name corresponding to" func_error " '$1'" func_error "Continuing, but uninstalled executables may not work." # Fallback: func_to_host_file_result=$1 fi } # end func_convert_file_check # func_convert_path_check FROM_PATHSEP TO_PATHSEP FROM_PATH TO_PATH # Verify that FROM_PATH (a path in $build format) was converted to $host # format in TO_PATH. Otherwise, emit an error message, but continue, resetting # func_to_host_file_result to a simplistic fallback value (see below). func_convert_path_check () { $debug_cmd if test -z "$4" && test -n "$3"; then func_error "Could not determine the host path corresponding to" func_error " '$3'" func_error "Continuing, but uninstalled executables may not work." # Fallback. This is a deliberately simplistic "conversion" and # should not be "improved". See libtool.info. if test "x$1" != "x$2"; then lt_replace_pathsep_chars="s|$1|$2|g" func_to_host_path_result=`echo "$3" | $SED -e "$lt_replace_pathsep_chars"` else func_to_host_path_result=$3 fi fi } # end func_convert_path_check # func_convert_path_front_back_pathsep FRONTPAT BACKPAT REPL ORIG # Modifies func_to_host_path_result by prepending REPL if ORIG matches FRONTPAT # and appending REPL if ORIG matches BACKPAT. func_convert_path_front_back_pathsep () { $debug_cmd case $4 in $1 ) func_to_host_path_result=$3$func_to_host_path_result ;; esac case $4 in $2 ) func_append func_to_host_path_result "$3" ;; esac } # end func_convert_path_front_back_pathsep ################################################## # $build to $host FILE NAME CONVERSION FUNCTIONS # ################################################## # invoked via '$to_host_file_cmd ARG' # # In each case, ARG is the path to be converted from $build to $host format. # Result will be available in $func_to_host_file_result. # func_to_host_file ARG # Converts the file name ARG from $build format to $host format. Return result # in func_to_host_file_result. func_to_host_file () { $debug_cmd $to_host_file_cmd "$1" } # end func_to_host_file # func_to_tool_file ARG LAZY # converts the file name ARG from $build format to toolchain format. Return # result in func_to_tool_file_result. If the conversion in use is listed # in (the comma separated) LAZY, no conversion takes place. func_to_tool_file () { $debug_cmd case ,$2, in *,"$to_tool_file_cmd",*) func_to_tool_file_result=$1 ;; *) $to_tool_file_cmd "$1" func_to_tool_file_result=$func_to_host_file_result ;; esac } # end func_to_tool_file # func_convert_file_noop ARG # Copy ARG to func_to_host_file_result. func_convert_file_noop () { func_to_host_file_result=$1 } # end func_convert_file_noop # func_convert_file_msys_to_w32 ARG # Convert file name ARG from (mingw) MSYS to (mingw) w32 format; automatic # conversion to w32 is not available inside the cwrapper. Returns result in # func_to_host_file_result. func_convert_file_msys_to_w32 () { $debug_cmd func_to_host_file_result=$1 if test -n "$1"; then func_convert_core_msys_to_w32 "$1" func_to_host_file_result=$func_convert_core_msys_to_w32_result fi func_convert_file_check "$1" "$func_to_host_file_result" } # end func_convert_file_msys_to_w32 # func_convert_file_cygwin_to_w32 ARG # Convert file name ARG from Cygwin to w32 format. Returns result in # func_to_host_file_result. func_convert_file_cygwin_to_w32 () { $debug_cmd func_to_host_file_result=$1 if test -n "$1"; then # because $build is cygwin, we call "the" cygpath in $PATH; no need to use # LT_CYGPATH in this case. func_to_host_file_result=`cygpath -m "$1"` fi func_convert_file_check "$1" "$func_to_host_file_result" } # end func_convert_file_cygwin_to_w32 # func_convert_file_nix_to_w32 ARG # Convert file name ARG from *nix to w32 format. Requires a wine environment # and a working winepath. Returns result in func_to_host_file_result. func_convert_file_nix_to_w32 () { $debug_cmd func_to_host_file_result=$1 if test -n "$1"; then func_convert_core_file_wine_to_w32 "$1" func_to_host_file_result=$func_convert_core_file_wine_to_w32_result fi func_convert_file_check "$1" "$func_to_host_file_result" } # end func_convert_file_nix_to_w32 # func_convert_file_msys_to_cygwin ARG # Convert file name ARG from MSYS to Cygwin format. Requires LT_CYGPATH set. # Returns result in func_to_host_file_result. func_convert_file_msys_to_cygwin () { $debug_cmd func_to_host_file_result=$1 if test -n "$1"; then func_convert_core_msys_to_w32 "$1" func_cygpath -u "$func_convert_core_msys_to_w32_result" func_to_host_file_result=$func_cygpath_result fi func_convert_file_check "$1" "$func_to_host_file_result" } # end func_convert_file_msys_to_cygwin # func_convert_file_nix_to_cygwin ARG # Convert file name ARG from *nix to Cygwin format. Requires Cygwin installed # in a wine environment, working winepath, and LT_CYGPATH set. Returns result # in func_to_host_file_result. func_convert_file_nix_to_cygwin () { $debug_cmd func_to_host_file_result=$1 if test -n "$1"; then # convert from *nix to w32, then use cygpath to convert from w32 to cygwin. func_convert_core_file_wine_to_w32 "$1" func_cygpath -u "$func_convert_core_file_wine_to_w32_result" func_to_host_file_result=$func_cygpath_result fi func_convert_file_check "$1" "$func_to_host_file_result" } # end func_convert_file_nix_to_cygwin ############################################# # $build to $host PATH CONVERSION FUNCTIONS # ############################################# # invoked via '$to_host_path_cmd ARG' # # In each case, ARG is the path to be converted from $build to $host format. # The result will be available in $func_to_host_path_result. # # Path separators are also converted from $build format to $host format. If # ARG begins or ends with a path separator character, it is preserved (but # converted to $host format) on output. # # All path conversion functions are named using the following convention: # file name conversion function : func_convert_file_X_to_Y () # path conversion function : func_convert_path_X_to_Y () # where, for any given $build/$host combination the 'X_to_Y' value is the # same. If conversion functions are added for new $build/$host combinations, # the two new functions must follow this pattern, or func_init_to_host_path_cmd # will break. # func_init_to_host_path_cmd # Ensures that function "pointer" variable $to_host_path_cmd is set to the # appropriate value, based on the value of $to_host_file_cmd. to_host_path_cmd= func_init_to_host_path_cmd () { $debug_cmd if test -z "$to_host_path_cmd"; then func_stripname 'func_convert_file_' '' "$to_host_file_cmd" to_host_path_cmd=func_convert_path_$func_stripname_result fi } # func_to_host_path ARG # Converts the path ARG from $build format to $host format. Return result # in func_to_host_path_result. func_to_host_path () { $debug_cmd func_init_to_host_path_cmd $to_host_path_cmd "$1" } # end func_to_host_path # func_convert_path_noop ARG # Copy ARG to func_to_host_path_result. func_convert_path_noop () { func_to_host_path_result=$1 } # end func_convert_path_noop # func_convert_path_msys_to_w32 ARG # Convert path ARG from (mingw) MSYS to (mingw) w32 format; automatic # conversion to w32 is not available inside the cwrapper. Returns result in # func_to_host_path_result. func_convert_path_msys_to_w32 () { $debug_cmd func_to_host_path_result=$1 if test -n "$1"; then # Remove leading and trailing path separator characters from ARG. MSYS # behavior is inconsistent here; cygpath turns them into '.;' and ';.'; # and winepath ignores them completely. func_stripname : : "$1" func_to_host_path_tmp1=$func_stripname_result func_convert_core_msys_to_w32 "$func_to_host_path_tmp1" func_to_host_path_result=$func_convert_core_msys_to_w32_result func_convert_path_check : ";" \ "$func_to_host_path_tmp1" "$func_to_host_path_result" func_convert_path_front_back_pathsep ":*" "*:" ";" "$1" fi } # end func_convert_path_msys_to_w32 # func_convert_path_cygwin_to_w32 ARG # Convert path ARG from Cygwin to w32 format. Returns result in # func_to_host_file_result. func_convert_path_cygwin_to_w32 () { $debug_cmd func_to_host_path_result=$1 if test -n "$1"; then # See func_convert_path_msys_to_w32: func_stripname : : "$1" func_to_host_path_tmp1=$func_stripname_result func_to_host_path_result=`cygpath -m -p "$func_to_host_path_tmp1"` func_convert_path_check : ";" \ "$func_to_host_path_tmp1" "$func_to_host_path_result" func_convert_path_front_back_pathsep ":*" "*:" ";" "$1" fi } # end func_convert_path_cygwin_to_w32 # func_convert_path_nix_to_w32 ARG # Convert path ARG from *nix to w32 format. Requires a wine environment and # a working winepath. Returns result in func_to_host_file_result. func_convert_path_nix_to_w32 () { $debug_cmd func_to_host_path_result=$1 if test -n "$1"; then # See func_convert_path_msys_to_w32: func_stripname : : "$1" func_to_host_path_tmp1=$func_stripname_result func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1" func_to_host_path_result=$func_convert_core_path_wine_to_w32_result func_convert_path_check : ";" \ "$func_to_host_path_tmp1" "$func_to_host_path_result" func_convert_path_front_back_pathsep ":*" "*:" ";" "$1" fi } # end func_convert_path_nix_to_w32 # func_convert_path_msys_to_cygwin ARG # Convert path ARG from MSYS to Cygwin format. Requires LT_CYGPATH set. # Returns result in func_to_host_file_result. func_convert_path_msys_to_cygwin () { $debug_cmd func_to_host_path_result=$1 if test -n "$1"; then # See func_convert_path_msys_to_w32: func_stripname : : "$1" func_to_host_path_tmp1=$func_stripname_result func_convert_core_msys_to_w32 "$func_to_host_path_tmp1" func_cygpath -u -p "$func_convert_core_msys_to_w32_result" func_to_host_path_result=$func_cygpath_result func_convert_path_check : : \ "$func_to_host_path_tmp1" "$func_to_host_path_result" func_convert_path_front_back_pathsep ":*" "*:" : "$1" fi } # end func_convert_path_msys_to_cygwin # func_convert_path_nix_to_cygwin ARG # Convert path ARG from *nix to Cygwin format. Requires Cygwin installed in a # a wine environment, working winepath, and LT_CYGPATH set. Returns result in # func_to_host_file_result. func_convert_path_nix_to_cygwin () { $debug_cmd func_to_host_path_result=$1 if test -n "$1"; then # Remove leading and trailing path separator characters from # ARG. msys behavior is inconsistent here, cygpath turns them # into '.;' and ';.', and winepath ignores them completely. func_stripname : : "$1" func_to_host_path_tmp1=$func_stripname_result func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1" func_cygpath -u -p "$func_convert_core_path_wine_to_w32_result" func_to_host_path_result=$func_cygpath_result func_convert_path_check : : \ "$func_to_host_path_tmp1" "$func_to_host_path_result" func_convert_path_front_back_pathsep ":*" "*:" : "$1" fi } # end func_convert_path_nix_to_cygwin # func_dll_def_p FILE # True iff FILE is a Windows DLL '.def' file. # Keep in sync with _LT_DLL_DEF_P in libtool.m4 func_dll_def_p () { $debug_cmd func_dll_def_p_tmp=`$SED -n \ -e 's/^[ ]*//' \ -e '/^\(;.*\)*$/d' \ -e 's/^\(EXPORTS\|LIBRARY\)\([ ].*\)*$/DEF/p' \ -e q \ "$1"` test DEF = "$func_dll_def_p_tmp" } # func_mode_compile arg... func_mode_compile () { $debug_cmd # Get the compilation command and the source file. base_compile= srcfile=$nonopt # always keep a non-empty value in "srcfile" suppress_opt=yes suppress_output= arg_mode=normal libobj= later= pie_flag= for arg do case $arg_mode in arg ) # do not "continue". Instead, add this to base_compile lastarg=$arg arg_mode=normal ;; target ) libobj=$arg arg_mode=normal continue ;; normal ) # Accept any command-line options. case $arg in -o) test -n "$libobj" && \ func_fatal_error "you cannot specify '-o' more than once" arg_mode=target continue ;; -pie | -fpie | -fPIE) func_append pie_flag " $arg" continue ;; -shared | -static | -prefer-pic | -prefer-non-pic) func_append later " $arg" continue ;; -no-suppress) suppress_opt=no continue ;; -Xcompiler) arg_mode=arg # the next one goes into the "base_compile" arg list continue # The current "srcfile" will either be retained or ;; # replaced later. I would guess that would be a bug. -Wc,*) func_stripname '-Wc,' '' "$arg" args=$func_stripname_result lastarg= save_ifs=$IFS; IFS=, for arg in $args; do IFS=$save_ifs func_append_quoted lastarg "$arg" done IFS=$save_ifs func_stripname ' ' '' "$lastarg" lastarg=$func_stripname_result # Add the arguments to base_compile. func_append base_compile " $lastarg" continue ;; *) # Accept the current argument as the source file. # The previous "srcfile" becomes the current argument. # lastarg=$srcfile srcfile=$arg ;; esac # case $arg ;; esac # case $arg_mode # Aesthetically quote the previous argument. func_append_quoted base_compile "$lastarg" done # for arg case $arg_mode in arg) func_fatal_error "you must specify an argument for -Xcompile" ;; target) func_fatal_error "you must specify a target with '-o'" ;; *) # Get the name of the library object. test -z "$libobj" && { func_basename "$srcfile" libobj=$func_basename_result } ;; esac # Recognize several different file suffixes. # If the user specifies -o file.o, it is replaced with file.lo case $libobj in *.[cCFSifmso] | \ *.ada | *.adb | *.ads | *.asm | \ *.c++ | *.cc | *.ii | *.class | *.cpp | *.cxx | \ *.[fF][09]? | *.for | *.java | *.go | *.obj | *.sx | *.cu | *.cup) func_xform "$libobj" libobj=$func_xform_result ;; esac case $libobj in *.lo) func_lo2o "$libobj"; obj=$func_lo2o_result ;; *) func_fatal_error "cannot determine name of library object from '$libobj'" ;; esac func_infer_tag $base_compile for arg in $later; do case $arg in -shared) test yes = "$build_libtool_libs" \ || func_fatal_configuration "cannot build a shared library" build_old_libs=no continue ;; -static) build_libtool_libs=no build_old_libs=yes continue ;; -prefer-pic) pic_mode=yes continue ;; -prefer-non-pic) pic_mode=no continue ;; esac done func_quote_for_eval "$libobj" test "X$libobj" != "X$func_quote_for_eval_result" \ && $ECHO "X$libobj" | $GREP '[]~#^*{};<>?"'"'"' &()|`$[]' \ && func_warning "libobj name '$libobj' may not contain shell special characters." func_dirname_and_basename "$obj" "/" "" objname=$func_basename_result xdir=$func_dirname_result lobj=$xdir$objdir/$objname test -z "$base_compile" && \ func_fatal_help "you must specify a compilation command" # Delete any leftover library objects. if test yes = "$build_old_libs"; then removelist="$obj $lobj $libobj ${libobj}T" else removelist="$lobj $libobj ${libobj}T" fi # On Cygwin there's no "real" PIC flag so we must build both object types case $host_os in cygwin* | mingw* | pw32* | os2* | cegcc*) pic_mode=default ;; esac if test no = "$pic_mode" && test pass_all != "$deplibs_check_method"; then # non-PIC code in shared libraries is not supported pic_mode=default fi # Calculate the filename of the output object if compiler does # not support -o with -c if test no = "$compiler_c_o"; then output_obj=`$ECHO "$srcfile" | $SED 's%^.*/%%; s%\.[^.]*$%%'`.$objext lockfile=$output_obj.lock else output_obj= need_locks=no lockfile= fi # Lock this critical section if it is needed # We use this script file to make the link, it avoids creating a new file if test yes = "$need_locks"; then until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do func_echo "Waiting for $lockfile to be removed" sleep 2 done elif test warn = "$need_locks"; then if test -f "$lockfile"; then $ECHO "\ *** ERROR, $lockfile exists and contains: `cat $lockfile 2>/dev/null` This indicates that another process is trying to use the same temporary object file, and libtool could not work around it because your compiler does not support '-c' and '-o' together. If you repeat this compilation, it may succeed, by chance, but you had better avoid parallel builds (make -j) in this platform, or get a better compiler." $opt_dry_run || $RM $removelist exit $EXIT_FAILURE fi func_append removelist " $output_obj" $ECHO "$srcfile" > "$lockfile" fi $opt_dry_run || $RM $removelist func_append removelist " $lockfile" trap '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' 1 2 15 func_to_tool_file "$srcfile" func_convert_file_msys_to_w32 srcfile=$func_to_tool_file_result func_quote_for_eval "$srcfile" qsrcfile=$func_quote_for_eval_result # Only build a PIC object if we are building libtool libraries. if test yes = "$build_libtool_libs"; then # Without this assignment, base_compile gets emptied. fbsd_hideous_sh_bug=$base_compile if test no != "$pic_mode"; then command="$base_compile $qsrcfile $pic_flag" else # Don't build PIC code command="$base_compile $qsrcfile" fi func_mkdir_p "$xdir$objdir" if test -z "$output_obj"; then # Place PIC objects in $objdir func_append command " -o $lobj" fi func_show_eval_locale "$command" \ 'test -n "$output_obj" && $RM $removelist; exit $EXIT_FAILURE' if test warn = "$need_locks" && test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then $ECHO "\ *** ERROR, $lockfile contains: `cat $lockfile 2>/dev/null` but it should contain: $srcfile This indicates that another process is trying to use the same temporary object file, and libtool could not work around it because your compiler does not support '-c' and '-o' together. If you repeat this compilation, it may succeed, by chance, but you had better avoid parallel builds (make -j) in this platform, or get a better compiler." $opt_dry_run || $RM $removelist exit $EXIT_FAILURE fi # Just move the object if needed, then go on to compile the next one if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then func_show_eval '$MV "$output_obj" "$lobj"' \ 'error=$?; $opt_dry_run || $RM $removelist; exit $error' fi # Allow error messages only from the first compilation. if test yes = "$suppress_opt"; then suppress_output=' >/dev/null 2>&1' fi fi # Only build a position-dependent object if we build old libraries. if test yes = "$build_old_libs"; then if test yes != "$pic_mode"; then # Don't build PIC code command="$base_compile $qsrcfile$pie_flag" else command="$base_compile $qsrcfile $pic_flag" fi if test yes = "$compiler_c_o"; then func_append command " -o $obj" fi # Suppress compiler output if we already did a PIC compilation. func_append command "$suppress_output" func_show_eval_locale "$command" \ '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' if test warn = "$need_locks" && test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then $ECHO "\ *** ERROR, $lockfile contains: `cat $lockfile 2>/dev/null` but it should contain: $srcfile This indicates that another process is trying to use the same temporary object file, and libtool could not work around it because your compiler does not support '-c' and '-o' together. If you repeat this compilation, it may succeed, by chance, but you had better avoid parallel builds (make -j) in this platform, or get a better compiler." $opt_dry_run || $RM $removelist exit $EXIT_FAILURE fi # Just move the object if needed if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then func_show_eval '$MV "$output_obj" "$obj"' \ 'error=$?; $opt_dry_run || $RM $removelist; exit $error' fi fi $opt_dry_run || { func_write_libtool_object "$libobj" "$objdir/$objname" "$objname" # Unlock the critical section if it was locked if test no != "$need_locks"; then removelist=$lockfile $RM "$lockfile" fi } exit $EXIT_SUCCESS } $opt_help || { test compile = "$opt_mode" && func_mode_compile ${1+"$@"} } func_mode_help () { # We need to display help for each of the modes. case $opt_mode in "") # Generic help is extracted from the usage comments # at the start of this file. func_help ;; clean) $ECHO \ "Usage: $progname [OPTION]... --mode=clean RM [RM-OPTION]... FILE... Remove files from the build directory. RM is the name of the program to use to delete files associated with each FILE (typically '/bin/rm'). RM-OPTIONS are options (such as '-f') to be passed to RM. If FILE is a libtool library, object or program, all the files associated with it are deleted. Otherwise, only FILE itself is deleted using RM." ;; compile) $ECHO \ "Usage: $progname [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE Compile a source file into a libtool library object. This mode accepts the following additional options: -o OUTPUT-FILE set the output file name to OUTPUT-FILE -no-suppress do not suppress compiler output for multiple passes -prefer-pic try to build PIC objects only -prefer-non-pic try to build non-PIC objects only -shared do not build a '.o' file suitable for static linking -static only build a '.o' file suitable for static linking -Wc,FLAG pass FLAG directly to the compiler COMPILE-COMMAND is a command to be used in creating a 'standard' object file from the given SOURCEFILE. The output file name is determined by removing the directory component from SOURCEFILE, then substituting the C source code suffix '.c' with the library object suffix, '.lo'." ;; execute) $ECHO \ "Usage: $progname [OPTION]... --mode=execute COMMAND [ARGS]... Automatically set library path, then run a program. This mode accepts the following additional options: -dlopen FILE add the directory containing FILE to the library path This mode sets the library path environment variable according to '-dlopen' flags. If any of the ARGS are libtool executable wrappers, then they are translated into their corresponding uninstalled binary, and any of their required library directories are added to the library path. Then, COMMAND is executed, with ARGS as arguments." ;; finish) $ECHO \ "Usage: $progname [OPTION]... --mode=finish [LIBDIR]... Complete the installation of libtool libraries. Each LIBDIR is a directory that contains libtool libraries. The commands that this mode executes may require superuser privileges. Use the '--dry-run' option if you just want to see what would be executed." ;; install) $ECHO \ "Usage: $progname [OPTION]... --mode=install INSTALL-COMMAND... Install executables or libraries. INSTALL-COMMAND is the installation command. The first component should be either the 'install' or 'cp' program. The following components of INSTALL-COMMAND are treated specially: -inst-prefix-dir PREFIX-DIR Use PREFIX-DIR as a staging area for installation The rest of the components are interpreted as arguments to that command (only BSD-compatible install options are recognized)." ;; link) $ECHO \ "Usage: $progname [OPTION]... --mode=link LINK-COMMAND... Link object files or libraries together to form another library, or to create an executable program. LINK-COMMAND is a command using the C compiler that you would use to create a program from several object files. The following components of LINK-COMMAND are treated specially: -all-static do not do any dynamic linking at all -avoid-version do not add a version suffix if possible -bindir BINDIR specify path to binaries directory (for systems where libraries must be found in the PATH setting at runtime) -dlopen FILE '-dlpreopen' FILE if it cannot be dlopened at runtime -dlpreopen FILE link in FILE and add its symbols to lt_preloaded_symbols -export-dynamic allow symbols from OUTPUT-FILE to be resolved with dlsym(3) -export-symbols SYMFILE try to export only the symbols listed in SYMFILE -export-symbols-regex REGEX try to export only the symbols matching REGEX -LLIBDIR search LIBDIR for required installed libraries -lNAME OUTPUT-FILE requires the installed library libNAME -module build a library that can dlopened -no-fast-install disable the fast-install mode -no-install link a not-installable executable -no-undefined declare that a library does not refer to external symbols -o OUTPUT-FILE create OUTPUT-FILE from the specified objects -objectlist FILE use a list of object files found in FILE to specify objects -os2dllname NAME force a short DLL name on OS/2 (no effect on other OSes) -precious-files-regex REGEX don't remove output files matching REGEX -release RELEASE specify package release information -rpath LIBDIR the created library will eventually be installed in LIBDIR -R[ ]LIBDIR add LIBDIR to the runtime path of programs and libraries -shared only do dynamic linking of libtool libraries -shrext SUFFIX override the standard shared library file extension -static do not do any dynamic linking of uninstalled libtool libraries -static-libtool-libs do not do any dynamic linking of libtool libraries -version-info CURRENT[:REVISION[:AGE]] specify library version info [each variable defaults to 0] -weak LIBNAME declare that the target provides the LIBNAME interface -Wc,FLAG -Xcompiler FLAG pass linker-specific FLAG directly to the compiler -Wl,FLAG -Xlinker FLAG pass linker-specific FLAG directly to the linker -XCClinker FLAG pass link-specific FLAG to the compiler driver (CC) All other options (arguments beginning with '-') are ignored. Every other argument is treated as a filename. Files ending in '.la' are treated as uninstalled libtool libraries, other files are standard or library object files. If the OUTPUT-FILE ends in '.la', then a libtool library is created, only library objects ('.lo' files) may be specified, and '-rpath' is required, except when creating a convenience library. If OUTPUT-FILE ends in '.a' or '.lib', then a standard library is created using 'ar' and 'ranlib', or on Windows using 'lib'. If OUTPUT-FILE ends in '.lo' or '.$objext', then a reloadable object file is created, otherwise an executable program is created." ;; uninstall) $ECHO \ "Usage: $progname [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE... Remove libraries from an installation directory. RM is the name of the program to use to delete files associated with each FILE (typically '/bin/rm'). RM-OPTIONS are options (such as '-f') to be passed to RM. If FILE is a libtool library, all the files associated with it are deleted. Otherwise, only FILE itself is deleted using RM." ;; *) func_fatal_help "invalid operation mode '$opt_mode'" ;; esac echo $ECHO "Try '$progname --help' for more information about other modes." } # Now that we've collected a possible --mode arg, show help if necessary if $opt_help; then if test : = "$opt_help"; then func_mode_help else { func_help noexit for opt_mode in compile link execute install finish uninstall clean; do func_mode_help done } | $SED -n '1p; 2,$s/^Usage:/ or: /p' { func_help noexit for opt_mode in compile link execute install finish uninstall clean; do echo func_mode_help done } | $SED '1d /^When reporting/,/^Report/{ H d } $x /information about other modes/d /more detailed .*MODE/d s/^Usage:.*--mode=\([^ ]*\) .*/Description of \1 mode:/' fi exit $? fi # func_mode_execute arg... func_mode_execute () { $debug_cmd # The first argument is the command name. cmd=$nonopt test -z "$cmd" && \ func_fatal_help "you must specify a COMMAND" # Handle -dlopen flags immediately. for file in $opt_dlopen; do test -f "$file" \ || func_fatal_help "'$file' is not a file" dir= case $file in *.la) func_resolve_sysroot "$file" file=$func_resolve_sysroot_result # Check to see that this really is a libtool archive. func_lalib_unsafe_p "$file" \ || func_fatal_help "'$lib' is not a valid libtool archive" # Read the libtool library. dlname= library_names= func_source "$file" # Skip this library if it cannot be dlopened. if test -z "$dlname"; then # Warn if it was a shared library. test -n "$library_names" && \ func_warning "'$file' was not linked with '-export-dynamic'" continue fi func_dirname "$file" "" "." dir=$func_dirname_result if test -f "$dir/$objdir/$dlname"; then func_append dir "/$objdir" else if test ! -f "$dir/$dlname"; then func_fatal_error "cannot find '$dlname' in '$dir' or '$dir/$objdir'" fi fi ;; *.lo) # Just add the directory containing the .lo file. func_dirname "$file" "" "." dir=$func_dirname_result ;; *) func_warning "'-dlopen' is ignored for non-libtool libraries and objects" continue ;; esac # Get the absolute pathname. absdir=`cd "$dir" && pwd` test -n "$absdir" && dir=$absdir # Now add the directory to shlibpath_var. if eval "test -z \"\$$shlibpath_var\""; then eval "$shlibpath_var=\"\$dir\"" else eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\"" fi done # This variable tells wrapper scripts just to set shlibpath_var # rather than running their programs. libtool_execute_magic=$magic # Check if any of the arguments is a wrapper script. args= for file do case $file in -* | *.la | *.lo ) ;; *) # Do a test to see if this is really a libtool program. if func_ltwrapper_script_p "$file"; then func_source "$file" # Transform arg to wrapped name. file=$progdir/$program elif func_ltwrapper_executable_p "$file"; then func_ltwrapper_scriptname "$file" func_source "$func_ltwrapper_scriptname_result" # Transform arg to wrapped name. file=$progdir/$program fi ;; esac # Quote arguments (to preserve shell metacharacters). func_append_quoted args "$file" done if $opt_dry_run; then # Display what would be done. if test -n "$shlibpath_var"; then eval "\$ECHO \"\$shlibpath_var=\$$shlibpath_var\"" echo "export $shlibpath_var" fi $ECHO "$cmd$args" exit $EXIT_SUCCESS else if test -n "$shlibpath_var"; then # Export the shlibpath_var. eval "export $shlibpath_var" fi # Restore saved environment variables for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES do eval "if test \"\${save_$lt_var+set}\" = set; then $lt_var=\$save_$lt_var; export $lt_var else $lt_unset $lt_var fi" done # Now prepare to actually exec the command. exec_cmd=\$cmd$args fi } test execute = "$opt_mode" && func_mode_execute ${1+"$@"} # func_mode_finish arg... func_mode_finish () { $debug_cmd libs= libdirs= admincmds= for opt in "$nonopt" ${1+"$@"} do if test -d "$opt"; then func_append libdirs " $opt" elif test -f "$opt"; then if func_lalib_unsafe_p "$opt"; then func_append libs " $opt" else func_warning "'$opt' is not a valid libtool archive" fi else func_fatal_error "invalid argument '$opt'" fi done if test -n "$libs"; then if test -n "$lt_sysroot"; then sysroot_regex=`$ECHO "$lt_sysroot" | $SED "$sed_make_literal_regex"` sysroot_cmd="s/\([ ']\)$sysroot_regex/\1/g;" else sysroot_cmd= fi # Remove sysroot references if $opt_dry_run; then for lib in $libs; do echo "removing references to $lt_sysroot and '=' prefixes from $lib" done else tmpdir=`func_mktempdir` for lib in $libs; do $SED -e "$sysroot_cmd s/\([ ']-[LR]\)=/\1/g; s/\([ ']\)=/\1/g" $lib \ > $tmpdir/tmp-la mv -f $tmpdir/tmp-la $lib done ${RM}r "$tmpdir" fi fi if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then for libdir in $libdirs; do if test -n "$finish_cmds"; then # Do each command in the finish commands. func_execute_cmds "$finish_cmds" 'admincmds="$admincmds '"$cmd"'"' fi if test -n "$finish_eval"; then # Do the single finish_eval. eval cmds=\"$finish_eval\" $opt_dry_run || eval "$cmds" || func_append admincmds " $cmds" fi done fi # Exit here if they wanted silent mode. $opt_quiet && exit $EXIT_SUCCESS if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then echo "----------------------------------------------------------------------" echo "Libraries have been installed in:" for libdir in $libdirs; do $ECHO " $libdir" done echo echo "If you ever happen to want to link against installed libraries" echo "in a given directory, LIBDIR, you must either use libtool, and" echo "specify the full pathname of the library, or use the '-LLIBDIR'" echo "flag during linking and do at least one of the following:" if test -n "$shlibpath_var"; then echo " - add LIBDIR to the '$shlibpath_var' environment variable" echo " during execution" fi if test -n "$runpath_var"; then echo " - add LIBDIR to the '$runpath_var' environment variable" echo " during linking" fi if test -n "$hardcode_libdir_flag_spec"; then libdir=LIBDIR eval flag=\"$hardcode_libdir_flag_spec\" $ECHO " - use the '$flag' linker flag" fi if test -n "$admincmds"; then $ECHO " - have your system administrator run these commands:$admincmds" fi if test -f /etc/ld.so.conf; then echo " - have your system administrator add LIBDIR to '/etc/ld.so.conf'" fi echo echo "See any operating system documentation about shared libraries for" case $host in solaris2.[6789]|solaris2.1[0-9]) echo "more information, such as the ld(1), crle(1) and ld.so(8) manual" echo "pages." ;; *) echo "more information, such as the ld(1) and ld.so(8) manual pages." ;; esac echo "----------------------------------------------------------------------" fi exit $EXIT_SUCCESS } test finish = "$opt_mode" && func_mode_finish ${1+"$@"} # func_mode_install arg... func_mode_install () { $debug_cmd # There may be an optional sh(1) argument at the beginning of # install_prog (especially on Windows NT). if test "$SHELL" = "$nonopt" || test /bin/sh = "$nonopt" || # Allow the use of GNU shtool's install command. case $nonopt in *shtool*) :;; *) false;; esac then # Aesthetically quote it. func_quote_for_eval "$nonopt" install_prog="$func_quote_for_eval_result " arg=$1 shift else install_prog= arg=$nonopt fi # The real first argument should be the name of the installation program. # Aesthetically quote it. func_quote_for_eval "$arg" func_append install_prog "$func_quote_for_eval_result" install_shared_prog=$install_prog case " $install_prog " in *[\\\ /]cp\ *) install_cp=: ;; *) install_cp=false ;; esac # We need to accept at least all the BSD install flags. dest= files= opts= prev= install_type= isdir=false stripme= no_mode=: for arg do arg2= if test -n "$dest"; then func_append files " $dest" dest=$arg continue fi case $arg in -d) isdir=: ;; -f) if $install_cp; then :; else prev=$arg fi ;; -g | -m | -o) prev=$arg ;; -s) stripme=" -s" continue ;; -*) ;; *) # If the previous option needed an argument, then skip it. if test -n "$prev"; then if test X-m = "X$prev" && test -n "$install_override_mode"; then arg2=$install_override_mode no_mode=false fi prev= else dest=$arg continue fi ;; esac # Aesthetically quote the argument. func_quote_for_eval "$arg" func_append install_prog " $func_quote_for_eval_result" if test -n "$arg2"; then func_quote_for_eval "$arg2" fi func_append install_shared_prog " $func_quote_for_eval_result" done test -z "$install_prog" && \ func_fatal_help "you must specify an install program" test -n "$prev" && \ func_fatal_help "the '$prev' option requires an argument" if test -n "$install_override_mode" && $no_mode; then if $install_cp; then :; else func_quote_for_eval "$install_override_mode" func_append install_shared_prog " -m $func_quote_for_eval_result" fi fi if test -z "$files"; then if test -z "$dest"; then func_fatal_help "no file or destination specified" else func_fatal_help "you must specify a destination" fi fi # Strip any trailing slash from the destination. func_stripname '' '/' "$dest" dest=$func_stripname_result # Check to see that the destination is a directory. test -d "$dest" && isdir=: if $isdir; then destdir=$dest destname= else func_dirname_and_basename "$dest" "" "." destdir=$func_dirname_result destname=$func_basename_result # Not a directory, so check to see that there is only one file specified. set dummy $files; shift test "$#" -gt 1 && \ func_fatal_help "'$dest' is not a directory" fi case $destdir in [\\/]* | [A-Za-z]:[\\/]*) ;; *) for file in $files; do case $file in *.lo) ;; *) func_fatal_help "'$destdir' must be an absolute directory name" ;; esac done ;; esac # This variable tells wrapper scripts just to set variables rather # than running their programs. libtool_install_magic=$magic staticlibs= future_libdirs= current_libdirs= for file in $files; do # Do each installation. case $file in *.$libext) # Do the static libraries later. func_append staticlibs " $file" ;; *.la) func_resolve_sysroot "$file" file=$func_resolve_sysroot_result # Check to see that this really is a libtool archive. func_lalib_unsafe_p "$file" \ || func_fatal_help "'$file' is not a valid libtool archive" library_names= old_library= relink_command= func_source "$file" # Add the libdir to current_libdirs if it is the destination. if test "X$destdir" = "X$libdir"; then case "$current_libdirs " in *" $libdir "*) ;; *) func_append current_libdirs " $libdir" ;; esac else # Note the libdir as a future libdir. case "$future_libdirs " in *" $libdir "*) ;; *) func_append future_libdirs " $libdir" ;; esac fi func_dirname "$file" "/" "" dir=$func_dirname_result func_append dir "$objdir" if test -n "$relink_command"; then # Determine the prefix the user has applied to our future dir. inst_prefix_dir=`$ECHO "$destdir" | $SED -e "s%$libdir\$%%"` # Don't allow the user to place us outside of our expected # location b/c this prevents finding dependent libraries that # are installed to the same prefix. # At present, this check doesn't affect windows .dll's that # are installed into $libdir/../bin (currently, that works fine) # but it's something to keep an eye on. test "$inst_prefix_dir" = "$destdir" && \ func_fatal_error "error: cannot install '$file' to a directory not ending in $libdir" if test -n "$inst_prefix_dir"; then # Stick the inst_prefix_dir data into the link command. relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"` else relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%%"` fi func_warning "relinking '$file'" func_show_eval "$relink_command" \ 'func_fatal_error "error: relink '\''$file'\'' with the above command before installing it"' fi # See the names of the shared library. set dummy $library_names; shift if test -n "$1"; then realname=$1 shift srcname=$realname test -n "$relink_command" && srcname=${realname}T # Install the shared library and build the symlinks. func_show_eval "$install_shared_prog $dir/$srcname $destdir/$realname" \ 'exit $?' tstripme=$stripme case $host_os in cygwin* | mingw* | pw32* | cegcc*) case $realname in *.dll.a) tstripme= ;; esac ;; os2*) case $realname in *_dll.a) tstripme= ;; esac ;; esac if test -n "$tstripme" && test -n "$striplib"; then func_show_eval "$striplib $destdir/$realname" 'exit $?' fi if test "$#" -gt 0; then # Delete the old symlinks, and create new ones. # Try 'ln -sf' first, because the 'ln' binary might depend on # the symlink we replace! Solaris /bin/ln does not understand -f, # so we also need to try rm && ln -s. for linkname do test "$linkname" != "$realname" \ && func_show_eval "(cd $destdir && { $LN_S -f $realname $linkname || { $RM $linkname && $LN_S $realname $linkname; }; })" done fi # Do each command in the postinstall commands. lib=$destdir/$realname func_execute_cmds "$postinstall_cmds" 'exit $?' fi # Install the pseudo-library for information purposes. func_basename "$file" name=$func_basename_result instname=$dir/${name}i func_show_eval "$install_prog $instname $destdir/$name" 'exit $?' # Maybe install the static library, too. test -n "$old_library" && func_append staticlibs " $dir/$old_library" ;; *.lo) # Install (i.e. copy) a libtool object. # Figure out destination file name, if it wasn't already specified. if test -n "$destname"; then destfile=$destdir/$destname else func_basename "$file" destfile=$func_basename_result destfile=$destdir/$destfile fi # Deduce the name of the destination old-style object file. case $destfile in *.lo) func_lo2o "$destfile" staticdest=$func_lo2o_result ;; *.$objext) staticdest=$destfile destfile= ;; *) func_fatal_help "cannot copy a libtool object to '$destfile'" ;; esac # Install the libtool object if requested. test -n "$destfile" && \ func_show_eval "$install_prog $file $destfile" 'exit $?' # Install the old object if enabled. if test yes = "$build_old_libs"; then # Deduce the name of the old-style object file. func_lo2o "$file" staticobj=$func_lo2o_result func_show_eval "$install_prog \$staticobj \$staticdest" 'exit $?' fi exit $EXIT_SUCCESS ;; *) # Figure out destination file name, if it wasn't already specified. if test -n "$destname"; then destfile=$destdir/$destname else func_basename "$file" destfile=$func_basename_result destfile=$destdir/$destfile fi # If the file is missing, and there is a .exe on the end, strip it # because it is most likely a libtool script we actually want to # install stripped_ext= case $file in *.exe) if test ! -f "$file"; then func_stripname '' '.exe' "$file" file=$func_stripname_result stripped_ext=.exe fi ;; esac # Do a test to see if this is really a libtool program. case $host in *cygwin* | *mingw*) if func_ltwrapper_executable_p "$file"; then func_ltwrapper_scriptname "$file" wrapper=$func_ltwrapper_scriptname_result else func_stripname '' '.exe' "$file" wrapper=$func_stripname_result fi ;; *) wrapper=$file ;; esac if func_ltwrapper_script_p "$wrapper"; then notinst_deplibs= relink_command= func_source "$wrapper" # Check the variables that should have been set. test -z "$generated_by_libtool_version" && \ func_fatal_error "invalid libtool wrapper script '$wrapper'" finalize=: for lib in $notinst_deplibs; do # Check to see that each library is installed. libdir= if test -f "$lib"; then func_source "$lib" fi libfile=$libdir/`$ECHO "$lib" | $SED 's%^.*/%%g'` if test -n "$libdir" && test ! -f "$libfile"; then func_warning "'$lib' has not been installed in '$libdir'" finalize=false fi done relink_command= func_source "$wrapper" outputname= if test no = "$fast_install" && test -n "$relink_command"; then $opt_dry_run || { if $finalize; then tmpdir=`func_mktempdir` func_basename "$file$stripped_ext" file=$func_basename_result outputname=$tmpdir/$file # Replace the output file specification. relink_command=`$ECHO "$relink_command" | $SED 's%@OUTPUT@%'"$outputname"'%g'` $opt_quiet || { func_quote_for_expand "$relink_command" eval "func_echo $func_quote_for_expand_result" } if eval "$relink_command"; then : else func_error "error: relink '$file' with the above command before installing it" $opt_dry_run || ${RM}r "$tmpdir" continue fi file=$outputname else func_warning "cannot relink '$file'" fi } else # Install the binary that we compiled earlier. file=`$ECHO "$file$stripped_ext" | $SED "s%\([^/]*\)$%$objdir/\1%"` fi fi # remove .exe since cygwin /usr/bin/install will append another # one anyway case $install_prog,$host in */usr/bin/install*,*cygwin*) case $file:$destfile in *.exe:*.exe) # this is ok ;; *.exe:*) destfile=$destfile.exe ;; *:*.exe) func_stripname '' '.exe' "$destfile" destfile=$func_stripname_result ;; esac ;; esac func_show_eval "$install_prog\$stripme \$file \$destfile" 'exit $?' $opt_dry_run || if test -n "$outputname"; then ${RM}r "$tmpdir" fi ;; esac done for file in $staticlibs; do func_basename "$file" name=$func_basename_result # Set up the ranlib parameters. oldlib=$destdir/$name func_to_tool_file "$oldlib" func_convert_file_msys_to_w32 tool_oldlib=$func_to_tool_file_result func_show_eval "$install_prog \$file \$oldlib" 'exit $?' if test -n "$stripme" && test -n "$old_striplib"; then func_show_eval "$old_striplib $tool_oldlib" 'exit $?' fi # Do each command in the postinstall commands. func_execute_cmds "$old_postinstall_cmds" 'exit $?' done test -n "$future_libdirs" && \ func_warning "remember to run '$progname --finish$future_libdirs'" if test -n "$current_libdirs"; then # Maybe just do a dry run. $opt_dry_run && current_libdirs=" -n$current_libdirs" exec_cmd='$SHELL "$progpath" $preserve_args --finish$current_libdirs' else exit $EXIT_SUCCESS fi } test install = "$opt_mode" && func_mode_install ${1+"$@"} # func_generate_dlsyms outputname originator pic_p # Extract symbols from dlprefiles and create ${outputname}S.o with # a dlpreopen symbol table. func_generate_dlsyms () { $debug_cmd my_outputname=$1 my_originator=$2 my_pic_p=${3-false} my_prefix=`$ECHO "$my_originator" | $SED 's%[^a-zA-Z0-9]%_%g'` my_dlsyms= if test -n "$dlfiles$dlprefiles" || test no != "$dlself"; then if test -n "$NM" && test -n "$global_symbol_pipe"; then my_dlsyms=${my_outputname}S.c else func_error "not configured to extract global symbols from dlpreopened files" fi fi if test -n "$my_dlsyms"; then case $my_dlsyms in "") ;; *.c) # Discover the nlist of each of the dlfiles. nlist=$output_objdir/$my_outputname.nm func_show_eval "$RM $nlist ${nlist}S ${nlist}T" # Parse the name list into a source file. func_verbose "creating $output_objdir/$my_dlsyms" $opt_dry_run || $ECHO > "$output_objdir/$my_dlsyms" "\ /* $my_dlsyms - symbol resolution table for '$my_outputname' dlsym emulation. */ /* Generated by $PROGRAM (GNU $PACKAGE) $VERSION */ #ifdef __cplusplus extern \"C\" { #endif #if defined __GNUC__ && (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4)) || (__GNUC__ > 4)) #pragma GCC diagnostic ignored \"-Wstrict-prototypes\" #endif /* 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 can'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 #define STREQ(s1, s2) (strcmp ((s1), (s2)) == 0) /* External symbol declarations for the compiler. */\ " if test yes = "$dlself"; then func_verbose "generating symbol list for '$output'" $opt_dry_run || echo ': @PROGRAM@ ' > "$nlist" # Add our own program objects to the symbol list. progfiles=`$ECHO "$objs$old_deplibs" | $SP2NL | $SED "$lo2o" | $NL2SP` for progfile in $progfiles; do func_to_tool_file "$progfile" func_convert_file_msys_to_w32 func_verbose "extracting global C symbols from '$func_to_tool_file_result'" $opt_dry_run || eval "$NM $func_to_tool_file_result | $global_symbol_pipe >> '$nlist'" done if test -n "$exclude_expsyms"; then $opt_dry_run || { eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T' eval '$MV "$nlist"T "$nlist"' } fi if test -n "$export_symbols_regex"; then $opt_dry_run || { eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T' eval '$MV "$nlist"T "$nlist"' } fi # Prepare the list of exported symbols if test -z "$export_symbols"; then export_symbols=$output_objdir/$outputname.exp $opt_dry_run || { $RM $export_symbols eval "$SED -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"' case $host in *cygwin* | *mingw* | *cegcc* ) eval "echo EXPORTS "'> "$output_objdir/$outputname.def"' eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"' ;; esac } else $opt_dry_run || { eval "$SED -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"' eval '$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T' eval '$MV "$nlist"T "$nlist"' case $host in *cygwin* | *mingw* | *cegcc* ) eval "echo EXPORTS "'> "$output_objdir/$outputname.def"' eval 'cat "$nlist" >> "$output_objdir/$outputname.def"' ;; esac } fi fi for dlprefile in $dlprefiles; do func_verbose "extracting global C symbols from '$dlprefile'" func_basename "$dlprefile" name=$func_basename_result case $host in *cygwin* | *mingw* | *cegcc* ) # if an import library, we need to obtain dlname if func_win32_import_lib_p "$dlprefile"; then func_tr_sh "$dlprefile" eval "curr_lafile=\$libfile_$func_tr_sh_result" dlprefile_dlbasename= if test -n "$curr_lafile" && func_lalib_p "$curr_lafile"; then # Use subshell, to avoid clobbering current variable values dlprefile_dlname=`source "$curr_lafile" && echo "$dlname"` if test -n "$dlprefile_dlname"; then func_basename "$dlprefile_dlname" dlprefile_dlbasename=$func_basename_result else # no lafile. user explicitly requested -dlpreopen . $sharedlib_from_linklib_cmd "$dlprefile" dlprefile_dlbasename=$sharedlib_from_linklib_result fi fi $opt_dry_run || { if test -n "$dlprefile_dlbasename"; then eval '$ECHO ": $dlprefile_dlbasename" >> "$nlist"' else func_warning "Could not compute DLL name from $name" eval '$ECHO ": $name " >> "$nlist"' fi func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32 eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe | $SED -e '/I __imp/d' -e 's/I __nm_/D /;s/_nm__//' >> '$nlist'" } else # not an import lib $opt_dry_run || { eval '$ECHO ": $name " >> "$nlist"' func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32 eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'" } fi ;; *) $opt_dry_run || { eval '$ECHO ": $name " >> "$nlist"' func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32 eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'" } ;; esac done $opt_dry_run || { # Make sure we have at least an empty file. test -f "$nlist" || : > "$nlist" if test -n "$exclude_expsyms"; then $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T $MV "$nlist"T "$nlist" fi # Try sorting and uniquifying the output. if $GREP -v "^: " < "$nlist" | if sort -k 3 /dev/null 2>&1; then sort -k 3 else sort +2 fi | uniq > "$nlist"S; then : else $GREP -v "^: " < "$nlist" > "$nlist"S fi if test -f "$nlist"S; then eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"' else echo '/* NONE */' >> "$output_objdir/$my_dlsyms" fi func_show_eval '$RM "${nlist}I"' if test -n "$global_symbol_to_import"; then eval "$global_symbol_to_import"' < "$nlist"S > "$nlist"I' fi echo >> "$output_objdir/$my_dlsyms" "\ /* The mapping between symbol names and symbols. */ typedef struct { const char *name; void *address; } lt_dlsymlist; extern LT_DLSYM_CONST lt_dlsymlist lt_${my_prefix}_LTX_preloaded_symbols[];\ " if test -s "$nlist"I; then echo >> "$output_objdir/$my_dlsyms" "\ static void lt_syminit(void) { LT_DLSYM_CONST lt_dlsymlist *symbol = lt_${my_prefix}_LTX_preloaded_symbols; for (; symbol->name; ++symbol) {" $SED 's/.*/ if (STREQ (symbol->name, \"&\")) symbol->address = (void *) \&&;/' < "$nlist"I >> "$output_objdir/$my_dlsyms" echo >> "$output_objdir/$my_dlsyms" "\ } }" fi echo >> "$output_objdir/$my_dlsyms" "\ LT_DLSYM_CONST lt_dlsymlist lt_${my_prefix}_LTX_preloaded_symbols[] = { {\"$my_originator\", (void *) 0}," if test -s "$nlist"I; then echo >> "$output_objdir/$my_dlsyms" "\ {\"@INIT@\", (void *) <_syminit}," fi case $need_lib_prefix in no) eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$my_dlsyms" ;; *) eval "$global_symbol_to_c_name_address_lib_prefix" < "$nlist" >> "$output_objdir/$my_dlsyms" ;; esac echo >> "$output_objdir/$my_dlsyms" "\ {0, (void *) 0} }; /* This works around a problem in FreeBSD linker */ #ifdef FREEBSD_WORKAROUND static const void *lt_preloaded_setup() { return lt_${my_prefix}_LTX_preloaded_symbols; } #endif #ifdef __cplusplus } #endif\ " } # !$opt_dry_run pic_flag_for_symtable= case "$compile_command " in *" -static "*) ;; *) case $host in # compiling the symbol table file with pic_flag works around # a FreeBSD bug that causes programs to crash when -lm is # linked before any other PIC object. But we must not use # pic_flag when linking with -static. The problem exists in # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1. *-*-freebsd2.*|*-*-freebsd3.0*|*-*-freebsdelf3.0*) pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND" ;; *-*-hpux*) pic_flag_for_symtable=" $pic_flag" ;; *) $my_pic_p && pic_flag_for_symtable=" $pic_flag" ;; esac ;; esac symtab_cflags= for arg in $LTCFLAGS; do case $arg in -pie | -fpie | -fPIE) ;; *) func_append symtab_cflags " $arg" ;; esac done # Now compile the dynamic symbol file. func_show_eval '(cd $output_objdir && $LTCC$symtab_cflags -c$no_builtin_flag$pic_flag_for_symtable "$my_dlsyms")' 'exit $?' # Clean up the generated files. func_show_eval '$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T" "${nlist}I"' # Transform the symbol file into the correct name. symfileobj=$output_objdir/${my_outputname}S.$objext case $host in *cygwin* | *mingw* | *cegcc* ) if test -f "$output_objdir/$my_outputname.def"; then compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"` finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"` else compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"` finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"` fi ;; *) compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"` finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"` ;; esac ;; *) func_fatal_error "unknown suffix for '$my_dlsyms'" ;; esac else # We keep going just in case the user didn't refer to # lt_preloaded_symbols. The linker will fail if global_symbol_pipe # really was required. # Nullify the symbol file. compile_command=`$ECHO "$compile_command" | $SED "s% @SYMFILE@%%"` finalize_command=`$ECHO "$finalize_command" | $SED "s% @SYMFILE@%%"` fi } # func_cygming_gnu_implib_p ARG # This predicate returns with zero status (TRUE) if # ARG is a GNU/binutils-style import library. Returns # with nonzero status (FALSE) otherwise. func_cygming_gnu_implib_p () { $debug_cmd func_to_tool_file "$1" func_convert_file_msys_to_w32 func_cygming_gnu_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $EGREP ' (_head_[A-Za-z0-9_]+_[ad]l*|[A-Za-z0-9_]+_[ad]l*_iname)$'` test -n "$func_cygming_gnu_implib_tmp" } # func_cygming_ms_implib_p ARG # This predicate returns with zero status (TRUE) if # ARG is an MS-style import library. Returns # with nonzero status (FALSE) otherwise. func_cygming_ms_implib_p () { $debug_cmd func_to_tool_file "$1" func_convert_file_msys_to_w32 func_cygming_ms_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $GREP '_NULL_IMPORT_DESCRIPTOR'` test -n "$func_cygming_ms_implib_tmp" } # func_win32_libid arg # return the library type of file 'arg' # # Need a lot of goo to handle *both* DLLs and import libs # Has to be a shell function in order to 'eat' the argument # that is supplied when $file_magic_command is called. # Despite the name, also deal with 64 bit binaries. func_win32_libid () { $debug_cmd win32_libid_type=unknown win32_fileres=`file -L $1 2>/dev/null` case $win32_fileres in *ar\ archive\ import\ library*) # definitely import win32_libid_type="x86 archive import" ;; *ar\ archive*) # could be an import, or static # Keep the egrep pattern in sync with the one in _LT_CHECK_MAGIC_METHOD. if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null | $EGREP 'file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)' >/dev/null; then case $nm_interface in "MS dumpbin") if func_cygming_ms_implib_p "$1" || func_cygming_gnu_implib_p "$1" then win32_nmres=import else win32_nmres= fi ;; *) func_to_tool_file "$1" func_convert_file_msys_to_w32 win32_nmres=`eval $NM -f posix -A \"$func_to_tool_file_result\" | $SED -n -e ' 1,100{ / I /{ s|.*|import| p q } }'` ;; esac case $win32_nmres in import*) win32_libid_type="x86 archive import";; *) win32_libid_type="x86 archive static";; esac fi ;; *DLL*) win32_libid_type="x86 DLL" ;; *executable*) # but shell scripts are "executable" too... case $win32_fileres in *MS\ Windows\ PE\ Intel*) win32_libid_type="x86 DLL" ;; esac ;; esac $ECHO "$win32_libid_type" } # func_cygming_dll_for_implib ARG # # Platform-specific function to extract the # name of the DLL associated with the specified # import library ARG. # Invoked by eval'ing the libtool variable # $sharedlib_from_linklib_cmd # Result is available in the variable # $sharedlib_from_linklib_result func_cygming_dll_for_implib () { $debug_cmd sharedlib_from_linklib_result=`$DLLTOOL --identify-strict --identify "$1"` } # func_cygming_dll_for_implib_fallback_core SECTION_NAME LIBNAMEs # # The is the core of a fallback implementation of a # platform-specific function to extract the name of the # DLL associated with the specified import library LIBNAME. # # SECTION_NAME is either .idata$6 or .idata$7, depending # on the platform and compiler that created the implib. # # Echos the name of the DLL associated with the # specified import library. func_cygming_dll_for_implib_fallback_core () { $debug_cmd match_literal=`$ECHO "$1" | $SED "$sed_make_literal_regex"` $OBJDUMP -s --section "$1" "$2" 2>/dev/null | $SED '/^Contents of section '"$match_literal"':/{ # Place marker at beginning of archive member dllname section s/.*/====MARK====/ p d } # These lines can sometimes be longer than 43 characters, but # are always uninteresting /:[ ]*file format pe[i]\{,1\}-/d /^In archive [^:]*:/d # Ensure marker is printed /^====MARK====/p # Remove all lines with less than 43 characters /^.\{43\}/!d # From remaining lines, remove first 43 characters s/^.\{43\}//' | $SED -n ' # Join marker and all lines until next marker into a single line /^====MARK====/ b para H $ b para b :para x s/\n//g # Remove the marker s/^====MARK====// # Remove trailing dots and whitespace s/[\. \t]*$// # Print /./p' | # we now have a list, one entry per line, of the stringified # contents of the appropriate section of all members of the # archive that possess that section. Heuristic: eliminate # all those that have a first or second character that is # a '.' (that is, objdump's representation of an unprintable # character.) This should work for all archives with less than # 0x302f exports -- but will fail for DLLs whose name actually # begins with a literal '.' or a single character followed by # a '.'. # # Of those that remain, print the first one. $SED -e '/^\./d;/^.\./d;q' } # func_cygming_dll_for_implib_fallback ARG # Platform-specific function to extract the # name of the DLL associated with the specified # import library ARG. # # This fallback implementation is for use when $DLLTOOL # does not support the --identify-strict option. # Invoked by eval'ing the libtool variable # $sharedlib_from_linklib_cmd # Result is available in the variable # $sharedlib_from_linklib_result func_cygming_dll_for_implib_fallback () { $debug_cmd if func_cygming_gnu_implib_p "$1"; then # binutils import library sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$7' "$1"` elif func_cygming_ms_implib_p "$1"; then # ms-generated import library sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$6' "$1"` else # unknown sharedlib_from_linklib_result= fi } # func_extract_an_archive dir oldlib func_extract_an_archive () { $debug_cmd f_ex_an_ar_dir=$1; shift f_ex_an_ar_oldlib=$1 if test yes = "$lock_old_archive_extraction"; then lockfile=$f_ex_an_ar_oldlib.lock until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do func_echo "Waiting for $lockfile to be removed" sleep 2 done fi func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" \ 'stat=$?; rm -f "$lockfile"; exit $stat' if test yes = "$lock_old_archive_extraction"; then $opt_dry_run || rm -f "$lockfile" fi if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then : else func_fatal_error "object name conflicts in archive: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib" fi } # func_extract_archives gentop oldlib ... func_extract_archives () { $debug_cmd my_gentop=$1; shift my_oldlibs=${1+"$@"} my_oldobjs= my_xlib= my_xabs= my_xdir= for my_xlib in $my_oldlibs; do # Extract the objects. case $my_xlib in [\\/]* | [A-Za-z]:[\\/]*) my_xabs=$my_xlib ;; *) my_xabs=`pwd`"/$my_xlib" ;; esac func_basename "$my_xlib" my_xlib=$func_basename_result my_xlib_u=$my_xlib while :; do case " $extracted_archives " in *" $my_xlib_u "*) func_arith $extracted_serial + 1 extracted_serial=$func_arith_result my_xlib_u=lt$extracted_serial-$my_xlib ;; *) break ;; esac done extracted_archives="$extracted_archives $my_xlib_u" my_xdir=$my_gentop/$my_xlib_u func_mkdir_p "$my_xdir" case $host in *-darwin*) func_verbose "Extracting $my_xabs" # Do not bother doing anything if just a dry run $opt_dry_run || { darwin_orig_dir=`pwd` cd $my_xdir || exit $? darwin_archive=$my_xabs darwin_curdir=`pwd` func_basename "$darwin_archive" darwin_base_archive=$func_basename_result darwin_arches=`$LIPO -info "$darwin_archive" 2>/dev/null | $GREP Architectures 2>/dev/null || true` if test -n "$darwin_arches"; then darwin_arches=`$ECHO "$darwin_arches" | $SED -e 's/.*are://'` darwin_arch= func_verbose "$darwin_base_archive has multiple architectures $darwin_arches" for darwin_arch in $darwin_arches; do func_mkdir_p "unfat-$$/$darwin_base_archive-$darwin_arch" $LIPO -thin $darwin_arch -output "unfat-$$/$darwin_base_archive-$darwin_arch/$darwin_base_archive" "$darwin_archive" cd "unfat-$$/$darwin_base_archive-$darwin_arch" func_extract_an_archive "`pwd`" "$darwin_base_archive" cd "$darwin_curdir" $RM "unfat-$$/$darwin_base_archive-$darwin_arch/$darwin_base_archive" done # $darwin_arches ## Okay now we've a bunch of thin objects, gotta fatten them up :) darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print | $SED -e "$sed_basename" | sort -u` darwin_file= darwin_files= for darwin_file in $darwin_filelist; do darwin_files=`find unfat-$$ -name $darwin_file -print | sort | $NL2SP` $LIPO -create -output "$darwin_file" $darwin_files done # $darwin_filelist $RM -rf unfat-$$ cd "$darwin_orig_dir" else cd $darwin_orig_dir func_extract_an_archive "$my_xdir" "$my_xabs" fi # $darwin_arches } # !$opt_dry_run ;; *) func_extract_an_archive "$my_xdir" "$my_xabs" ;; esac my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | sort | $NL2SP` done func_extract_archives_result=$my_oldobjs } # func_emit_wrapper [arg=no] # # Emit a libtool wrapper script on stdout. # Don't directly open a file because we may want to # incorporate the script contents within a cygwin/mingw # wrapper executable. Must ONLY be called from within # func_mode_link because it depends on a number of variables # set therein. # # ARG is the value that the WRAPPER_SCRIPT_BELONGS_IN_OBJDIR # variable will take. If 'yes', then the emitted script # will assume that the directory where it is stored is # the $objdir directory. This is a cygwin/mingw-specific # behavior. func_emit_wrapper () { func_emit_wrapper_arg1=${1-no} $ECHO "\ #! $SHELL # $output - temporary wrapper script for $objdir/$outputname # Generated by $PROGRAM (GNU $PACKAGE) $VERSION # # The $output program cannot be directly executed until all the libtool # libraries that it depends on are installed. # # This wrapper script should never be moved out of the build directory. # If it is, it will not operate correctly. # Sed substitution that helps us do robust quoting. It backslashifies # metacharacters that are still active within double-quoted strings. sed_quote_subst='$sed_quote_subst' # Be Bourne compatible if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then emulate sh NULLCMD=: # Zsh 3.x and 4.x performs 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 BIN_SH=xpg4; export BIN_SH # for Tru64 DUALCASE=1; export DUALCASE # for MKS sh # 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 relink_command=\"$relink_command\" # This environment variable determines our operation mode. if test \"\$libtool_install_magic\" = \"$magic\"; then # install mode needs the following variables: generated_by_libtool_version='$macro_version' notinst_deplibs='$notinst_deplibs' else # When we are sourced in execute mode, \$file and \$ECHO are already set. if test \"\$libtool_execute_magic\" != \"$magic\"; then file=\"\$0\"" qECHO=`$ECHO "$ECHO" | $SED "$sed_quote_subst"` $ECHO "\ # A function that is used when there is no print builtin or printf. func_fallback_echo () { eval 'cat <<_LTECHO_EOF \$1 _LTECHO_EOF' } ECHO=\"$qECHO\" fi # Very basic option parsing. These options are (a) specific to # the libtool wrapper, (b) are identical between the wrapper # /script/ and the wrapper /executable/ that is used only on # windows platforms, and (c) all begin with the string "--lt-" # (application programs are unlikely to have options that match # this pattern). # # There are only two supported options: --lt-debug and # --lt-dump-script. There is, deliberately, no --lt-help. # # The first argument to this parsing function should be the # script's $0 value, followed by "$@". lt_option_debug= func_parse_lt_options () { lt_script_arg0=\$0 shift for lt_opt do case \"\$lt_opt\" in --lt-debug) lt_option_debug=1 ;; --lt-dump-script) lt_dump_D=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%/[^/]*$%%'\` test \"X\$lt_dump_D\" = \"X\$lt_script_arg0\" && lt_dump_D=. lt_dump_F=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%^.*/%%'\` cat \"\$lt_dump_D/\$lt_dump_F\" exit 0 ;; --lt-*) \$ECHO \"Unrecognized --lt- option: '\$lt_opt'\" 1>&2 exit 1 ;; esac done # Print the debug banner immediately: if test -n \"\$lt_option_debug\"; then echo \"$outputname:$output:\$LINENO: libtool wrapper (GNU $PACKAGE) $VERSION\" 1>&2 fi } # Used when --lt-debug. Prints its arguments to stdout # (redirection is the responsibility of the caller) func_lt_dump_args () { lt_dump_args_N=1; for lt_arg do \$ECHO \"$outputname:$output:\$LINENO: newargv[\$lt_dump_args_N]: \$lt_arg\" lt_dump_args_N=\`expr \$lt_dump_args_N + 1\` done } # Core function for launching the target application func_exec_program_core () { " case $host in # Backslashes separate directories on plain windows *-*-mingw | *-*-os2* | *-cegcc*) $ECHO "\ if test -n \"\$lt_option_debug\"; then \$ECHO \"$outputname:$output:\$LINENO: newargv[0]: \$progdir\\\\\$program\" 1>&2 func_lt_dump_args \${1+\"\$@\"} 1>&2 fi exec \"\$progdir\\\\\$program\" \${1+\"\$@\"} " ;; *) $ECHO "\ if test -n \"\$lt_option_debug\"; then \$ECHO \"$outputname:$output:\$LINENO: newargv[0]: \$progdir/\$program\" 1>&2 func_lt_dump_args \${1+\"\$@\"} 1>&2 fi exec \"\$progdir/\$program\" \${1+\"\$@\"} " ;; esac $ECHO "\ \$ECHO \"\$0: cannot exec \$program \$*\" 1>&2 exit 1 } # A function to encapsulate launching the target application # Strips options in the --lt-* namespace from \$@ and # launches target application with the remaining arguments. func_exec_program () { case \" \$* \" in *\\ --lt-*) for lt_wr_arg do case \$lt_wr_arg in --lt-*) ;; *) set x \"\$@\" \"\$lt_wr_arg\"; shift;; esac shift done ;; esac func_exec_program_core \${1+\"\$@\"} } # Parse options func_parse_lt_options \"\$0\" \${1+\"\$@\"} # Find the directory that this script lives in. thisdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*$%%'\` test \"x\$thisdir\" = \"x\$file\" && thisdir=. # Follow symbolic links until we get to the real thisdir. file=\`ls -ld \"\$file\" | $SED -n 's/.*-> //p'\` while test -n \"\$file\"; do destdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*\$%%'\` # If there was a directory component, then change thisdir. if test \"x\$destdir\" != \"x\$file\"; then case \"\$destdir\" in [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;; *) thisdir=\"\$thisdir/\$destdir\" ;; esac fi file=\`\$ECHO \"\$file\" | $SED 's%^.*/%%'\` file=\`ls -ld \"\$thisdir/\$file\" | $SED -n 's/.*-> //p'\` done # Usually 'no', except on cygwin/mingw when embedded into # the cwrapper. WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_arg1 if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then # special case for '.' if test \"\$thisdir\" = \".\"; then thisdir=\`pwd\` fi # remove .libs from thisdir case \"\$thisdir\" in *[\\\\/]$objdir ) thisdir=\`\$ECHO \"\$thisdir\" | $SED 's%[\\\\/][^\\\\/]*$%%'\` ;; $objdir ) thisdir=. ;; esac fi # Try to get the absolute directory name. absdir=\`cd \"\$thisdir\" && pwd\` test -n \"\$absdir\" && thisdir=\"\$absdir\" " if test yes = "$fast_install"; then $ECHO "\ program=lt-'$outputname'$exeext progdir=\"\$thisdir/$objdir\" if test ! -f \"\$progdir/\$program\" || { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | $SED 1q\`; \\ test \"X\$file\" != \"X\$progdir/\$program\"; }; then file=\"\$\$-\$program\" if test ! -d \"\$progdir\"; then $MKDIR \"\$progdir\" else $RM \"\$progdir/\$file\" fi" $ECHO "\ # relink executable if necessary if test -n \"\$relink_command\"; then if relink_command_output=\`eval \$relink_command 2>&1\`; then : else \$ECHO \"\$relink_command_output\" >&2 $RM \"\$progdir/\$file\" exit 1 fi fi $MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null || { $RM \"\$progdir/\$program\"; $MV \"\$progdir/\$file\" \"\$progdir/\$program\"; } $RM \"\$progdir/\$file\" fi" else $ECHO "\ program='$outputname' progdir=\"\$thisdir/$objdir\" " fi $ECHO "\ if test -f \"\$progdir/\$program\"; then" # fixup the dll searchpath if we need to. # # Fix the DLL searchpath if we need to. Do this before prepending # to shlibpath, because on Windows, both are PATH and uninstalled # libraries must come first. if test -n "$dllsearchpath"; then $ECHO "\ # Add the dll search path components to the executable PATH PATH=$dllsearchpath:\$PATH " fi # Export our shlibpath_var if we have one. if test yes = "$shlibpath_overrides_runpath" && test -n "$shlibpath_var" && test -n "$temp_rpath"; then $ECHO "\ # Add our own library path to $shlibpath_var $shlibpath_var=\"$temp_rpath\$$shlibpath_var\" # Some systems cannot cope with colon-terminated $shlibpath_var # The second colon is a workaround for a bug in BeOS R4 sed $shlibpath_var=\`\$ECHO \"\$$shlibpath_var\" | $SED 's/::*\$//'\` export $shlibpath_var " fi $ECHO "\ if test \"\$libtool_execute_magic\" != \"$magic\"; then # Run the actual program with our arguments. func_exec_program \${1+\"\$@\"} fi else # The program doesn't exist. \$ECHO \"\$0: error: '\$progdir/\$program' does not exist\" 1>&2 \$ECHO \"This script is just a wrapper for \$program.\" 1>&2 \$ECHO \"See the $PACKAGE documentation for more information.\" 1>&2 exit 1 fi fi\ " } # func_emit_cwrapperexe_src # emit the source code for a wrapper executable on stdout # Must ONLY be called from within func_mode_link because # it depends on a number of variable set therein. func_emit_cwrapperexe_src () { cat < #include #ifdef _MSC_VER # include # include # include #else # include # include # ifdef __CYGWIN__ # include # endif #endif #include #include #include #include #include #include #include #include #define STREQ(s1, s2) (strcmp ((s1), (s2)) == 0) /* declarations of non-ANSI functions */ #if defined __MINGW32__ # ifdef __STRICT_ANSI__ int _putenv (const char *); # endif #elif defined __CYGWIN__ # ifdef __STRICT_ANSI__ char *realpath (const char *, char *); int putenv (char *); int setenv (const char *, const char *, int); # endif /* #elif defined other_platform || defined ... */ #endif /* portability defines, excluding path handling macros */ #if defined _MSC_VER # define setmode _setmode # define stat _stat # define chmod _chmod # define getcwd _getcwd # define putenv _putenv # define S_IXUSR _S_IEXEC #elif defined __MINGW32__ # define setmode _setmode # define stat _stat # define chmod _chmod # define getcwd _getcwd # define putenv _putenv #elif defined __CYGWIN__ # define HAVE_SETENV # define FOPEN_WB "wb" /* #elif defined other platforms ... */ #endif #if defined PATH_MAX # define LT_PATHMAX PATH_MAX #elif defined MAXPATHLEN # define LT_PATHMAX MAXPATHLEN #else # define LT_PATHMAX 1024 #endif #ifndef S_IXOTH # define S_IXOTH 0 #endif #ifndef S_IXGRP # define S_IXGRP 0 #endif /* path handling portability macros */ #ifndef DIR_SEPARATOR # define DIR_SEPARATOR '/' # define PATH_SEPARATOR ':' #endif #if defined _WIN32 || defined __MSDOS__ || defined __DJGPP__ || \ defined __OS2__ # define HAVE_DOS_BASED_FILE_SYSTEM # define FOPEN_WB "wb" # ifndef DIR_SEPARATOR_2 # define DIR_SEPARATOR_2 '\\' # endif # ifndef PATH_SEPARATOR_2 # define PATH_SEPARATOR_2 ';' # endif #endif #ifndef DIR_SEPARATOR_2 # define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR) #else /* DIR_SEPARATOR_2 */ # define IS_DIR_SEPARATOR(ch) \ (((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2)) #endif /* DIR_SEPARATOR_2 */ #ifndef PATH_SEPARATOR_2 # define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR) #else /* PATH_SEPARATOR_2 */ # define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2) #endif /* PATH_SEPARATOR_2 */ #ifndef FOPEN_WB # define FOPEN_WB "w" #endif #ifndef _O_BINARY # define _O_BINARY 0 #endif #define XMALLOC(type, num) ((type *) xmalloc ((num) * sizeof(type))) #define XFREE(stale) do { \ if (stale) { free (stale); stale = 0; } \ } while (0) #if defined LT_DEBUGWRAPPER static int lt_debug = 1; #else static int lt_debug = 0; #endif const char *program_name = "libtool-wrapper"; /* in case xstrdup fails */ void *xmalloc (size_t num); char *xstrdup (const char *string); const char *base_name (const char *name); char *find_executable (const char *wrapper); char *chase_symlinks (const char *pathspec); int make_executable (const char *path); int check_executable (const char *path); char *strendzap (char *str, const char *pat); void lt_debugprintf (const char *file, int line, const char *fmt, ...); void lt_fatal (const char *file, int line, const char *message, ...); static const char *nonnull (const char *s); static const char *nonempty (const char *s); void lt_setenv (const char *name, const char *value); char *lt_extend_str (const char *orig_value, const char *add, int to_end); void lt_update_exe_path (const char *name, const char *value); void lt_update_lib_path (const char *name, const char *value); char **prepare_spawn (char **argv); void lt_dump_script (FILE *f); EOF cat <= 0) && (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH))) return 1; else return 0; } int make_executable (const char *path) { int rval = 0; struct stat st; lt_debugprintf (__FILE__, __LINE__, "(make_executable): %s\n", nonempty (path)); if ((!path) || (!*path)) return 0; if (stat (path, &st) >= 0) { rval = chmod (path, st.st_mode | S_IXOTH | S_IXGRP | S_IXUSR); } return rval; } /* Searches for the full path of the wrapper. Returns newly allocated full path name if found, NULL otherwise Does not chase symlinks, even on platforms that support them. */ char * find_executable (const char *wrapper) { int has_slash = 0; const char *p; const char *p_next; /* static buffer for getcwd */ char tmp[LT_PATHMAX + 1]; size_t tmp_len; char *concat_name; lt_debugprintf (__FILE__, __LINE__, "(find_executable): %s\n", nonempty (wrapper)); if ((wrapper == NULL) || (*wrapper == '\0')) return NULL; /* Absolute path? */ #if defined HAVE_DOS_BASED_FILE_SYSTEM if (isalpha ((unsigned char) wrapper[0]) && wrapper[1] == ':') { concat_name = xstrdup (wrapper); if (check_executable (concat_name)) return concat_name; XFREE (concat_name); } else { #endif if (IS_DIR_SEPARATOR (wrapper[0])) { concat_name = xstrdup (wrapper); if (check_executable (concat_name)) return concat_name; XFREE (concat_name); } #if defined HAVE_DOS_BASED_FILE_SYSTEM } #endif for (p = wrapper; *p; p++) if (*p == '/') { has_slash = 1; break; } if (!has_slash) { /* no slashes; search PATH */ const char *path = getenv ("PATH"); if (path != NULL) { for (p = path; *p; p = p_next) { const char *q; size_t p_len; for (q = p; *q; q++) if (IS_PATH_SEPARATOR (*q)) break; p_len = (size_t) (q - p); p_next = (*q == '\0' ? q : q + 1); if (p_len == 0) { /* empty path: current directory */ if (getcwd (tmp, LT_PATHMAX) == NULL) lt_fatal (__FILE__, __LINE__, "getcwd failed: %s", nonnull (strerror (errno))); tmp_len = strlen (tmp); concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1); memcpy (concat_name, tmp, tmp_len); concat_name[tmp_len] = '/'; strcpy (concat_name + tmp_len + 1, wrapper); } else { concat_name = XMALLOC (char, p_len + 1 + strlen (wrapper) + 1); memcpy (concat_name, p, p_len); concat_name[p_len] = '/'; strcpy (concat_name + p_len + 1, wrapper); } if (check_executable (concat_name)) return concat_name; XFREE (concat_name); } } /* not found in PATH; assume curdir */ } /* Relative path | not found in path: prepend cwd */ if (getcwd (tmp, LT_PATHMAX) == NULL) lt_fatal (__FILE__, __LINE__, "getcwd failed: %s", nonnull (strerror (errno))); tmp_len = strlen (tmp); concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1); memcpy (concat_name, tmp, tmp_len); concat_name[tmp_len] = '/'; strcpy (concat_name + tmp_len + 1, wrapper); if (check_executable (concat_name)) return concat_name; XFREE (concat_name); return NULL; } char * chase_symlinks (const char *pathspec) { #ifndef S_ISLNK return xstrdup (pathspec); #else char buf[LT_PATHMAX]; struct stat s; char *tmp_pathspec = xstrdup (pathspec); char *p; int has_symlinks = 0; while (strlen (tmp_pathspec) && !has_symlinks) { lt_debugprintf (__FILE__, __LINE__, "checking path component for symlinks: %s\n", tmp_pathspec); if (lstat (tmp_pathspec, &s) == 0) { if (S_ISLNK (s.st_mode) != 0) { has_symlinks = 1; break; } /* search backwards for last DIR_SEPARATOR */ p = tmp_pathspec + strlen (tmp_pathspec) - 1; while ((p > tmp_pathspec) && (!IS_DIR_SEPARATOR (*p))) p--; if ((p == tmp_pathspec) && (!IS_DIR_SEPARATOR (*p))) { /* no more DIR_SEPARATORS left */ break; } *p = '\0'; } else { lt_fatal (__FILE__, __LINE__, "error accessing file \"%s\": %s", tmp_pathspec, nonnull (strerror (errno))); } } XFREE (tmp_pathspec); if (!has_symlinks) { return xstrdup (pathspec); } tmp_pathspec = realpath (pathspec, buf); if (tmp_pathspec == 0) { lt_fatal (__FILE__, __LINE__, "could not follow symlinks for %s", pathspec); } return xstrdup (tmp_pathspec); #endif } char * strendzap (char *str, const char *pat) { size_t len, patlen; assert (str != NULL); assert (pat != NULL); len = strlen (str); patlen = strlen (pat); if (patlen <= len) { str += len - patlen; if (STREQ (str, pat)) *str = '\0'; } return str; } void lt_debugprintf (const char *file, int line, const char *fmt, ...) { va_list args; if (lt_debug) { (void) fprintf (stderr, "%s:%s:%d: ", program_name, file, line); va_start (args, fmt); (void) vfprintf (stderr, fmt, args); va_end (args); } } static void lt_error_core (int exit_status, const char *file, int line, const char *mode, const char *message, va_list ap) { fprintf (stderr, "%s:%s:%d: %s: ", program_name, file, line, mode); vfprintf (stderr, message, ap); fprintf (stderr, ".\n"); if (exit_status >= 0) exit (exit_status); } void lt_fatal (const char *file, int line, const char *message, ...) { va_list ap; va_start (ap, message); lt_error_core (EXIT_FAILURE, file, line, "FATAL", message, ap); va_end (ap); } static const char * nonnull (const char *s) { return s ? s : "(null)"; } static const char * nonempty (const char *s) { return (s && !*s) ? "(empty)" : nonnull (s); } void lt_setenv (const char *name, const char *value) { lt_debugprintf (__FILE__, __LINE__, "(lt_setenv) setting '%s' to '%s'\n", nonnull (name), nonnull (value)); { #ifdef HAVE_SETENV /* always make a copy, for consistency with !HAVE_SETENV */ char *str = xstrdup (value); setenv (name, str, 1); #else size_t len = strlen (name) + 1 + strlen (value) + 1; char *str = XMALLOC (char, len); sprintf (str, "%s=%s", name, value); if (putenv (str) != EXIT_SUCCESS) { XFREE (str); } #endif } } char * lt_extend_str (const char *orig_value, const char *add, int to_end) { char *new_value; if (orig_value && *orig_value) { size_t orig_value_len = strlen (orig_value); size_t add_len = strlen (add); new_value = XMALLOC (char, add_len + orig_value_len + 1); if (to_end) { strcpy (new_value, orig_value); strcpy (new_value + orig_value_len, add); } else { strcpy (new_value, add); strcpy (new_value + add_len, orig_value); } } else { new_value = xstrdup (add); } return new_value; } void lt_update_exe_path (const char *name, const char *value) { lt_debugprintf (__FILE__, __LINE__, "(lt_update_exe_path) modifying '%s' by prepending '%s'\n", nonnull (name), nonnull (value)); if (name && *name && value && *value) { char *new_value = lt_extend_str (getenv (name), value, 0); /* some systems can't cope with a ':'-terminated path #' */ size_t len = strlen (new_value); while ((len > 0) && IS_PATH_SEPARATOR (new_value[len-1])) { new_value[--len] = '\0'; } lt_setenv (name, new_value); XFREE (new_value); } } void lt_update_lib_path (const char *name, const char *value) { lt_debugprintf (__FILE__, __LINE__, "(lt_update_lib_path) modifying '%s' by prepending '%s'\n", nonnull (name), nonnull (value)); if (name && *name && value && *value) { char *new_value = lt_extend_str (getenv (name), value, 0); lt_setenv (name, new_value); XFREE (new_value); } } EOF case $host_os in mingw*) cat <<"EOF" /* Prepares an argument vector before calling spawn(). Note that spawn() does not by itself call the command interpreter (getenv ("COMSPEC") != NULL ? getenv ("COMSPEC") : ({ OSVERSIONINFO v; v.dwOSVersionInfoSize = sizeof(OSVERSIONINFO); GetVersionEx(&v); v.dwPlatformId == VER_PLATFORM_WIN32_NT; }) ? "cmd.exe" : "command.com"). Instead it simply concatenates the arguments, separated by ' ', and calls CreateProcess(). We must quote the arguments since Win32 CreateProcess() interprets characters like ' ', '\t', '\\', '"' (but not '<' and '>') in a special way: - Space and tab are interpreted as delimiters. They are not treated as delimiters if they are surrounded by double quotes: "...". - Unescaped double quotes are removed from the input. Their only effect is that within double quotes, space and tab are treated like normal characters. - Backslashes not followed by double quotes are not special. - But 2*n+1 backslashes followed by a double quote become n backslashes followed by a double quote (n >= 0): \" -> " \\\" -> \" \\\\\" -> \\" */ #define SHELL_SPECIAL_CHARS "\"\\ \001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037" #define SHELL_SPACE_CHARS " \001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037" char ** prepare_spawn (char **argv) { size_t argc; char **new_argv; size_t i; /* Count number of arguments. */ for (argc = 0; argv[argc] != NULL; argc++) ; /* Allocate new argument vector. */ new_argv = XMALLOC (char *, argc + 1); /* Put quoted arguments into the new argument vector. */ for (i = 0; i < argc; i++) { const char *string = argv[i]; if (string[0] == '\0') new_argv[i] = xstrdup ("\"\""); else if (strpbrk (string, SHELL_SPECIAL_CHARS) != NULL) { int quote_around = (strpbrk (string, SHELL_SPACE_CHARS) != NULL); size_t length; unsigned int backslashes; const char *s; char *quoted_string; char *p; length = 0; backslashes = 0; if (quote_around) length++; for (s = string; *s != '\0'; s++) { char c = *s; if (c == '"') length += backslashes + 1; length++; if (c == '\\') backslashes++; else backslashes = 0; } if (quote_around) length += backslashes + 1; quoted_string = XMALLOC (char, length + 1); p = quoted_string; backslashes = 0; if (quote_around) *p++ = '"'; for (s = string; *s != '\0'; s++) { char c = *s; if (c == '"') { unsigned int j; for (j = backslashes + 1; j > 0; j--) *p++ = '\\'; } *p++ = c; if (c == '\\') backslashes++; else backslashes = 0; } if (quote_around) { unsigned int j; for (j = backslashes; j > 0; j--) *p++ = '\\'; *p++ = '"'; } *p = '\0'; new_argv[i] = quoted_string; } else new_argv[i] = (char *) string; } new_argv[argc] = NULL; return new_argv; } EOF ;; esac cat <<"EOF" void lt_dump_script (FILE* f) { EOF func_emit_wrapper yes | $SED -n -e ' s/^\(.\{79\}\)\(..*\)/\1\ \2/ h s/\([\\"]\)/\\\1/g s/$/\\n/ s/\([^\n]*\).*/ fputs ("\1", f);/p g D' cat <<"EOF" } EOF } # end: func_emit_cwrapperexe_src # func_win32_import_lib_p ARG # True if ARG is an import lib, as indicated by $file_magic_cmd func_win32_import_lib_p () { $debug_cmd case `eval $file_magic_cmd \"\$1\" 2>/dev/null | $SED -e 10q` in *import*) : ;; *) false ;; esac } # func_suncc_cstd_abi # !!ONLY CALL THIS FOR SUN CC AFTER $compile_command IS FULLY EXPANDED!! # Several compiler flags select an ABI that is incompatible with the # Cstd library. Avoid specifying it if any are in CXXFLAGS. func_suncc_cstd_abi () { $debug_cmd case " $compile_command " in *" -compat=g "*|*\ -std=c++[0-9][0-9]\ *|*" -library=stdcxx4 "*|*" -library=stlport4 "*) suncc_use_cstd_abi=no ;; *) suncc_use_cstd_abi=yes ;; esac } # func_mode_link arg... func_mode_link () { $debug_cmd case $host in *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*) # It is impossible to link a dll without this setting, and # we shouldn't force the makefile maintainer to figure out # what system we are compiling for in order to pass an extra # flag for every libtool invocation. # allow_undefined=no # FIXME: Unfortunately, there are problems with the above when trying # to make a dll that has undefined symbols, in which case not # even a static library is built. For now, we need to specify # -no-undefined on the libtool link line when we can be certain # that all symbols are satisfied, otherwise we get a static library. allow_undefined=yes ;; *) allow_undefined=yes ;; esac libtool_args=$nonopt base_compile="$nonopt $@" compile_command=$nonopt finalize_command=$nonopt compile_rpath= finalize_rpath= compile_shlibpath= finalize_shlibpath= convenience= old_convenience= deplibs= old_deplibs= compiler_flags= linker_flags= dllsearchpath= lib_search_path=`pwd` inst_prefix_dir= new_inherited_linker_flags= avoid_version=no bindir= dlfiles= dlprefiles= dlself=no export_dynamic=no export_symbols= export_symbols_regex= generated= libobjs= ltlibs= module=no no_install=no objs= os2dllname= non_pic_objects= precious_files_regex= prefer_static_libs=no preload=false prev= prevarg= release= rpath= xrpath= perm_rpath= temp_rpath= thread_safe=no vinfo= vinfo_number=no weak_libs= single_module=$wl-single_module func_infer_tag $base_compile # We need to know -static, to get the right output filenames. for arg do case $arg in -shared) test yes != "$build_libtool_libs" \ && func_fatal_configuration "cannot build a shared library" build_old_libs=no break ;; -all-static | -static | -static-libtool-libs) case $arg in -all-static) if test yes = "$build_libtool_libs" && test -z "$link_static_flag"; then func_warning "complete static linking is impossible in this configuration" fi if test -n "$link_static_flag"; then dlopen_self=$dlopen_self_static fi prefer_static_libs=yes ;; -static) if test -z "$pic_flag" && test -n "$link_static_flag"; then dlopen_self=$dlopen_self_static fi prefer_static_libs=built ;; -static-libtool-libs) if test -z "$pic_flag" && test -n "$link_static_flag"; then dlopen_self=$dlopen_self_static fi prefer_static_libs=yes ;; esac build_libtool_libs=no build_old_libs=yes break ;; esac done # See if our shared archives depend on static archives. test -n "$old_archive_from_new_cmds" && build_old_libs=yes # Go through the arguments, transforming them on the way. while test "$#" -gt 0; do arg=$1 shift func_quote_for_eval "$arg" qarg=$func_quote_for_eval_unquoted_result func_append libtool_args " $func_quote_for_eval_result" # If the previous option needs an argument, assign it. if test -n "$prev"; then case $prev in output) func_append compile_command " @OUTPUT@" func_append finalize_command " @OUTPUT@" ;; esac case $prev in bindir) bindir=$arg prev= continue ;; dlfiles|dlprefiles) $preload || { # Add the symbol object into the linking commands. func_append compile_command " @SYMFILE@" func_append finalize_command " @SYMFILE@" preload=: } case $arg in *.la | *.lo) ;; # We handle these cases below. force) if test no = "$dlself"; then dlself=needless export_dynamic=yes fi prev= continue ;; self) if test dlprefiles = "$prev"; then dlself=yes elif test dlfiles = "$prev" && test yes != "$dlopen_self"; then dlself=yes else dlself=needless export_dynamic=yes fi prev= continue ;; *) if test dlfiles = "$prev"; then func_append dlfiles " $arg" else func_append dlprefiles " $arg" fi prev= continue ;; esac ;; expsyms) export_symbols=$arg test -f "$arg" \ || func_fatal_error "symbol file '$arg' does not exist" prev= continue ;; expsyms_regex) export_symbols_regex=$arg prev= continue ;; framework) case $host in *-*-darwin*) case "$deplibs " in *" $qarg.ltframework "*) ;; *) func_append deplibs " $qarg.ltframework" # this is fixed later ;; esac ;; esac prev= continue ;; inst_prefix) inst_prefix_dir=$arg prev= continue ;; mllvm) # Clang does not use LLVM to link, so we can simply discard any # '-mllvm $arg' options when doing the link step. prev= continue ;; objectlist) if test -f "$arg"; then save_arg=$arg moreargs= for fil in `cat "$save_arg"` do # func_append moreargs " $fil" arg=$fil # A libtool-controlled object. # Check to see that this really is a libtool object. if func_lalib_unsafe_p "$arg"; then pic_object= non_pic_object= # Read the .lo file func_source "$arg" if test -z "$pic_object" || test -z "$non_pic_object" || test none = "$pic_object" && test none = "$non_pic_object"; then func_fatal_error "cannot find name of object for '$arg'" fi # Extract subdirectory from the argument. func_dirname "$arg" "/" "" xdir=$func_dirname_result if test none != "$pic_object"; then # Prepend the subdirectory the object is found in. pic_object=$xdir$pic_object if test dlfiles = "$prev"; then if test yes = "$build_libtool_libs" && test yes = "$dlopen_support"; then func_append dlfiles " $pic_object" prev= continue else # If libtool objects are unsupported, then we need to preload. prev=dlprefiles fi fi # CHECK ME: I think I busted this. -Ossama if test dlprefiles = "$prev"; then # Preload the old-style object. func_append dlprefiles " $pic_object" prev= fi # A PIC object. func_append libobjs " $pic_object" arg=$pic_object fi # Non-PIC object. if test none != "$non_pic_object"; then # Prepend the subdirectory the object is found in. non_pic_object=$xdir$non_pic_object # A standard non-PIC object func_append non_pic_objects " $non_pic_object" if test -z "$pic_object" || test none = "$pic_object"; then arg=$non_pic_object fi else # If the PIC object exists, use it instead. # $xdir was prepended to $pic_object above. non_pic_object=$pic_object func_append non_pic_objects " $non_pic_object" fi else # Only an error if not doing a dry-run. if $opt_dry_run; then # Extract subdirectory from the argument. func_dirname "$arg" "/" "" xdir=$func_dirname_result func_lo2o "$arg" pic_object=$xdir$objdir/$func_lo2o_result non_pic_object=$xdir$func_lo2o_result func_append libobjs " $pic_object" func_append non_pic_objects " $non_pic_object" else func_fatal_error "'$arg' is not a valid libtool object" fi fi done else func_fatal_error "link input file '$arg' does not exist" fi arg=$save_arg prev= continue ;; os2dllname) os2dllname=$arg prev= continue ;; precious_regex) precious_files_regex=$arg prev= continue ;; release) release=-$arg prev= continue ;; rpath | xrpath) # We need an absolute path. case $arg in [\\/]* | [A-Za-z]:[\\/]*) ;; *) func_fatal_error "only absolute run-paths are allowed" ;; esac if test rpath = "$prev"; then case "$rpath " in *" $arg "*) ;; *) func_append rpath " $arg" ;; esac else case "$xrpath " in *" $arg "*) ;; *) func_append xrpath " $arg" ;; esac fi prev= continue ;; shrext) shrext_cmds=$arg prev= continue ;; weak) func_append weak_libs " $arg" prev= continue ;; xcclinker) func_append linker_flags " $qarg" func_append compiler_flags " $qarg" prev= func_append compile_command " $qarg" func_append finalize_command " $qarg" continue ;; xcompiler) func_append compiler_flags " $qarg" prev= func_append compile_command " $qarg" func_append finalize_command " $qarg" continue ;; xlinker) func_append linker_flags " $qarg" func_append compiler_flags " $wl$qarg" prev= func_append compile_command " $wl$qarg" func_append finalize_command " $wl$qarg" continue ;; *) eval "$prev=\"\$arg\"" prev= continue ;; esac fi # test -n "$prev" prevarg=$arg case $arg in -all-static) if test -n "$link_static_flag"; then # See comment for -static flag below, for more details. func_append compile_command " $link_static_flag" func_append finalize_command " $link_static_flag" fi continue ;; -allow-undefined) # FIXME: remove this flag sometime in the future. func_fatal_error "'-allow-undefined' must not be used because it is the default" ;; -avoid-version) avoid_version=yes continue ;; -bindir) prev=bindir continue ;; -dlopen) prev=dlfiles continue ;; -dlpreopen) prev=dlprefiles continue ;; -export-dynamic) export_dynamic=yes continue ;; -export-symbols | -export-symbols-regex) if test -n "$export_symbols" || test -n "$export_symbols_regex"; then func_fatal_error "more than one -exported-symbols argument is not allowed" fi if test X-export-symbols = "X$arg"; then prev=expsyms else prev=expsyms_regex fi continue ;; -framework) prev=framework continue ;; -inst-prefix-dir) prev=inst_prefix continue ;; # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:* # so, if we see these flags be careful not to treat them like -L -L[A-Z][A-Z]*:*) case $with_gcc/$host in no/*-*-irix* | /*-*-irix*) func_append compile_command " $arg" func_append finalize_command " $arg" ;; esac continue ;; -L*) func_stripname "-L" '' "$arg" if test -z "$func_stripname_result"; then if test "$#" -gt 0; then func_fatal_error "require no space between '-L' and '$1'" else func_fatal_error "need path for '-L' option" fi fi func_resolve_sysroot "$func_stripname_result" dir=$func_resolve_sysroot_result # We need an absolute path. case $dir in [\\/]* | [A-Za-z]:[\\/]*) ;; *) absdir=`cd "$dir" && pwd` test -z "$absdir" && \ func_fatal_error "cannot determine absolute directory name of '$dir'" dir=$absdir ;; esac case "$deplibs " in *" -L$dir "* | *" $arg "*) # Will only happen for absolute or sysroot arguments ;; *) # Preserve sysroot, but never include relative directories case $dir in [\\/]* | [A-Za-z]:[\\/]* | =*) func_append deplibs " $arg" ;; *) func_append deplibs " -L$dir" ;; esac func_append lib_search_path " $dir" ;; esac case $host in *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*) testbindir=`$ECHO "$dir" | $SED 's*/lib$*/bin*'` case :$dllsearchpath: in *":$dir:"*) ;; ::) dllsearchpath=$dir;; *) func_append dllsearchpath ":$dir";; esac case :$dllsearchpath: in *":$testbindir:"*) ;; ::) dllsearchpath=$testbindir;; *) func_append dllsearchpath ":$testbindir";; esac ;; esac continue ;; -l*) if test X-lc = "X$arg" || test X-lm = "X$arg"; then case $host in *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos* | *-cegcc* | *-*-haiku*) # These systems don't actually have a C or math library (as such) continue ;; *-*-os2*) # These systems don't actually have a C library (as such) test X-lc = "X$arg" && continue ;; *-*-openbsd* | *-*-freebsd* | *-*-dragonfly* | *-*-bitrig*) # Do not include libc due to us having libc/libc_r. test X-lc = "X$arg" && continue ;; *-*-rhapsody* | *-*-darwin1.[012]) # Rhapsody C and math libraries are in the System framework func_append deplibs " System.ltframework" continue ;; *-*-sco3.2v5* | *-*-sco5v6*) # Causes problems with __ctype test X-lc = "X$arg" && continue ;; *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*) # Compiler inserts libc in the correct place for threads to work test X-lc = "X$arg" && continue ;; esac elif test X-lc_r = "X$arg"; then case $host in *-*-openbsd* | *-*-freebsd* | *-*-dragonfly* | *-*-bitrig*) # Do not include libc_r directly, use -pthread flag. continue ;; esac fi func_append deplibs " $arg" continue ;; -mllvm) prev=mllvm continue ;; -module) module=yes continue ;; # Tru64 UNIX uses -model [arg] to determine the layout of C++ # classes, name mangling, and exception handling. # Darwin uses the -arch flag to determine output architecture. -model|-arch|-isysroot|--sysroot) func_append compiler_flags " $arg" func_append compile_command " $arg" func_append finalize_command " $arg" prev=xcompiler continue ;; -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe \ |-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp|-qsmp=*) func_append compiler_flags " $arg" func_append compile_command " $arg" func_append finalize_command " $arg" case "$new_inherited_linker_flags " in *" $arg "*) ;; * ) func_append new_inherited_linker_flags " $arg" ;; esac continue ;; -multi_module) single_module=$wl-multi_module continue ;; -no-fast-install) fast_install=no continue ;; -no-install) case $host in *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-darwin* | *-cegcc*) # The PATH hackery in wrapper scripts is required on Windows # and Darwin in order for the loader to find any dlls it needs. func_warning "'-no-install' is ignored for $host" func_warning "assuming '-no-fast-install' instead" fast_install=no ;; *) no_install=yes ;; esac continue ;; -no-undefined) allow_undefined=no continue ;; -objectlist) prev=objectlist continue ;; -os2dllname) prev=os2dllname continue ;; -o) prev=output ;; -precious-files-regex) prev=precious_regex continue ;; -release) prev=release continue ;; -rpath) prev=rpath continue ;; -R) prev=xrpath continue ;; -R*) func_stripname '-R' '' "$arg" dir=$func_stripname_result # We need an absolute path. case $dir in [\\/]* | [A-Za-z]:[\\/]*) ;; =*) func_stripname '=' '' "$dir" dir=$lt_sysroot$func_stripname_result ;; *) func_fatal_error "only absolute run-paths are allowed" ;; esac case "$xrpath " in *" $dir "*) ;; *) func_append xrpath " $dir" ;; esac continue ;; -shared) # The effects of -shared are defined in a previous loop. continue ;; -shrext) prev=shrext continue ;; -static | -static-libtool-libs) # The effects of -static are defined in a previous loop. # We used to do the same as -all-static on platforms that # didn't have a PIC flag, but the assumption that the effects # would be equivalent was wrong. It would break on at least # Digital Unix and AIX. continue ;; -thread-safe) thread_safe=yes continue ;; -version-info) prev=vinfo continue ;; -version-number) prev=vinfo vinfo_number=yes continue ;; -weak) prev=weak continue ;; -Wc,*) func_stripname '-Wc,' '' "$arg" args=$func_stripname_result arg= save_ifs=$IFS; IFS=, for flag in $args; do IFS=$save_ifs func_quote_for_eval "$flag" func_append arg " $func_quote_for_eval_result" func_append compiler_flags " $func_quote_for_eval_result" done IFS=$save_ifs func_stripname ' ' '' "$arg" arg=$func_stripname_result ;; -Wl,*) func_stripname '-Wl,' '' "$arg" args=$func_stripname_result arg= save_ifs=$IFS; IFS=, for flag in $args; do IFS=$save_ifs func_quote_for_eval "$flag" func_append arg " $wl$func_quote_for_eval_result" func_append compiler_flags " $wl$func_quote_for_eval_result" func_append linker_flags " $func_quote_for_eval_result" done IFS=$save_ifs func_stripname ' ' '' "$arg" arg=$func_stripname_result ;; -Xcompiler) prev=xcompiler continue ;; -Xlinker) prev=xlinker continue ;; -XCClinker) prev=xcclinker continue ;; # -msg_* for osf cc -msg_*) func_quote_for_eval "$arg" arg=$func_quote_for_eval_result ;; # Flags to be passed through unchanged, with rationale: # -64, -mips[0-9] enable 64-bit mode for the SGI compiler # -r[0-9][0-9]* specify processor for the SGI compiler # -xarch=*, -xtarget=* enable 64-bit mode for the Sun compiler # +DA*, +DD* enable 64-bit mode for the HP compiler # -q* compiler args for the IBM compiler # -m*, -t[45]*, -txscale* architecture-specific flags for GCC # -F/path path to uninstalled frameworks, gcc on darwin # -p, -pg, --coverage, -fprofile-* profiling flags for GCC # -fstack-protector* stack protector flags for GCC # @file GCC response files # -tp=* Portland pgcc target processor selection # --sysroot=* for sysroot support # -O*, -g*, -flto*, -fwhopr*, -fuse-linker-plugin GCC link-time optimization # -stdlib=* select c++ std lib with clang -64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \ -t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*|-tp=*|--sysroot=*| \ -O*|-g*|-flto*|-fwhopr*|-fuse-linker-plugin|-fstack-protector*|-stdlib=*) func_quote_for_eval "$arg" arg=$func_quote_for_eval_result func_append compile_command " $arg" func_append finalize_command " $arg" func_append compiler_flags " $arg" continue ;; -Z*) if test os2 = "`expr $host : '.*\(os2\)'`"; then # OS/2 uses -Zxxx to specify OS/2-specific options compiler_flags="$compiler_flags $arg" func_append compile_command " $arg" func_append finalize_command " $arg" case $arg in -Zlinker | -Zstack) prev=xcompiler ;; esac continue else # Otherwise treat like 'Some other compiler flag' below func_quote_for_eval "$arg" arg=$func_quote_for_eval_result fi ;; # Some other compiler flag. -* | +*) func_quote_for_eval "$arg" arg=$func_quote_for_eval_result ;; *.$objext) # A standard object. func_append objs " $arg" ;; *.lo) # A libtool-controlled object. # Check to see that this really is a libtool object. if func_lalib_unsafe_p "$arg"; then pic_object= non_pic_object= # Read the .lo file func_source "$arg" if test -z "$pic_object" || test -z "$non_pic_object" || test none = "$pic_object" && test none = "$non_pic_object"; then func_fatal_error "cannot find name of object for '$arg'" fi # Extract subdirectory from the argument. func_dirname "$arg" "/" "" xdir=$func_dirname_result test none = "$pic_object" || { # Prepend the subdirectory the object is found in. pic_object=$xdir$pic_object if test dlfiles = "$prev"; then if test yes = "$build_libtool_libs" && test yes = "$dlopen_support"; then func_append dlfiles " $pic_object" prev= continue else # If libtool objects are unsupported, then we need to preload. prev=dlprefiles fi fi # CHECK ME: I think I busted this. -Ossama if test dlprefiles = "$prev"; then # Preload the old-style object. func_append dlprefiles " $pic_object" prev= fi # A PIC object. func_append libobjs " $pic_object" arg=$pic_object } # Non-PIC object. if test none != "$non_pic_object"; then # Prepend the subdirectory the object is found in. non_pic_object=$xdir$non_pic_object # A standard non-PIC object func_append non_pic_objects " $non_pic_object" if test -z "$pic_object" || test none = "$pic_object"; then arg=$non_pic_object fi else # If the PIC object exists, use it instead. # $xdir was prepended to $pic_object above. non_pic_object=$pic_object func_append non_pic_objects " $non_pic_object" fi else # Only an error if not doing a dry-run. if $opt_dry_run; then # Extract subdirectory from the argument. func_dirname "$arg" "/" "" xdir=$func_dirname_result func_lo2o "$arg" pic_object=$xdir$objdir/$func_lo2o_result non_pic_object=$xdir$func_lo2o_result func_append libobjs " $pic_object" func_append non_pic_objects " $non_pic_object" else func_fatal_error "'$arg' is not a valid libtool object" fi fi ;; *.$libext) # An archive. func_append deplibs " $arg" func_append old_deplibs " $arg" continue ;; *.la) # A libtool-controlled library. func_resolve_sysroot "$arg" if test dlfiles = "$prev"; then # This library was specified with -dlopen. func_append dlfiles " $func_resolve_sysroot_result" prev= elif test dlprefiles = "$prev"; then # The library was specified with -dlpreopen. func_append dlprefiles " $func_resolve_sysroot_result" prev= else func_append deplibs " $func_resolve_sysroot_result" fi continue ;; # Some other compiler argument. *) # Unknown arguments in both finalize_command and compile_command need # to be aesthetically quoted because they are evaled later. func_quote_for_eval "$arg" arg=$func_quote_for_eval_result ;; esac # arg # Now actually substitute the argument into the commands. if test -n "$arg"; then func_append compile_command " $arg" func_append finalize_command " $arg" fi done # argument parsing loop test -n "$prev" && \ func_fatal_help "the '$prevarg' option requires an argument" if test yes = "$export_dynamic" && test -n "$export_dynamic_flag_spec"; then eval arg=\"$export_dynamic_flag_spec\" func_append compile_command " $arg" func_append finalize_command " $arg" fi oldlibs= # calculate the name of the file, without its directory func_basename "$output" outputname=$func_basename_result libobjs_save=$libobjs if test -n "$shlibpath_var"; then # get the directories listed in $shlibpath_var eval shlib_search_path=\`\$ECHO \"\$$shlibpath_var\" \| \$SED \'s/:/ /g\'\` else shlib_search_path= fi eval sys_lib_search_path=\"$sys_lib_search_path_spec\" eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\" # Definition is injected by LT_CONFIG during libtool generation. func_munge_path_list sys_lib_dlsearch_path "$LT_SYS_LIBRARY_PATH" func_dirname "$output" "/" "" output_objdir=$func_dirname_result$objdir func_to_tool_file "$output_objdir/" tool_output_objdir=$func_to_tool_file_result # Create the object directory. func_mkdir_p "$output_objdir" # Determine the type of output case $output in "") func_fatal_help "you must specify an output file" ;; *.$libext) linkmode=oldlib ;; *.lo | *.$objext) linkmode=obj ;; *.la) linkmode=lib ;; *) linkmode=prog ;; # Anything else should be a program. esac specialdeplibs= libs= # Find all interdependent deplibs by searching for libraries # that are linked more than once (e.g. -la -lb -la) for deplib in $deplibs; do if $opt_preserve_dup_deps; then case "$libs " in *" $deplib "*) func_append specialdeplibs " $deplib" ;; esac fi func_append libs " $deplib" done if test lib = "$linkmode"; then libs="$predeps $libs $compiler_lib_search_path $postdeps" # Compute libraries that are listed more than once in $predeps # $postdeps and mark them as special (i.e., whose duplicates are # not to be eliminated). pre_post_deps= if $opt_duplicate_compiler_generated_deps; then for pre_post_dep in $predeps $postdeps; do case "$pre_post_deps " in *" $pre_post_dep "*) func_append specialdeplibs " $pre_post_deps" ;; esac func_append pre_post_deps " $pre_post_dep" done fi pre_post_deps= fi deplibs= newdependency_libs= newlib_search_path= need_relink=no # whether we're linking any uninstalled libtool libraries notinst_deplibs= # not-installed libtool libraries notinst_path= # paths that contain not-installed libtool libraries case $linkmode in lib) passes="conv dlpreopen link" for file in $dlfiles $dlprefiles; do case $file in *.la) ;; *) func_fatal_help "libraries can '-dlopen' only libtool libraries: $file" ;; esac done ;; prog) compile_deplibs= finalize_deplibs= alldeplibs=false newdlfiles= newdlprefiles= passes="conv scan dlopen dlpreopen link" ;; *) passes="conv" ;; esac for pass in $passes; do # The preopen pass in lib mode reverses $deplibs; put it back here # so that -L comes before libs that need it for instance... if test lib,link = "$linkmode,$pass"; then ## FIXME: Find the place where the list is rebuilt in the wrong ## order, and fix it there properly tmp_deplibs= for deplib in $deplibs; do tmp_deplibs="$deplib $tmp_deplibs" done deplibs=$tmp_deplibs fi if test lib,link = "$linkmode,$pass" || test prog,scan = "$linkmode,$pass"; then libs=$deplibs deplibs= fi if test prog = "$linkmode"; then case $pass in dlopen) libs=$dlfiles ;; dlpreopen) libs=$dlprefiles ;; link) libs="$deplibs %DEPLIBS% $dependency_libs" ;; esac fi if test lib,dlpreopen = "$linkmode,$pass"; then # Collect and forward deplibs of preopened libtool libs for lib in $dlprefiles; do # Ignore non-libtool-libs dependency_libs= func_resolve_sysroot "$lib" case $lib in *.la) func_source "$func_resolve_sysroot_result" ;; esac # Collect preopened libtool deplibs, except any this library # has declared as weak libs for deplib in $dependency_libs; do func_basename "$deplib" deplib_base=$func_basename_result case " $weak_libs " in *" $deplib_base "*) ;; *) func_append deplibs " $deplib" ;; esac done done libs=$dlprefiles fi if test dlopen = "$pass"; then # Collect dlpreopened libraries save_deplibs=$deplibs deplibs= fi for deplib in $libs; do lib= found=false case $deplib in -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe \ |-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp|-qsmp=*) if test prog,link = "$linkmode,$pass"; then compile_deplibs="$deplib $compile_deplibs" finalize_deplibs="$deplib $finalize_deplibs" else func_append compiler_flags " $deplib" if test lib = "$linkmode"; then case "$new_inherited_linker_flags " in *" $deplib "*) ;; * ) func_append new_inherited_linker_flags " $deplib" ;; esac fi fi continue ;; -l*) if test lib != "$linkmode" && test prog != "$linkmode"; then func_warning "'-l' is ignored for archives/objects" continue fi func_stripname '-l' '' "$deplib" name=$func_stripname_result if test lib = "$linkmode"; then searchdirs="$newlib_search_path $lib_search_path $compiler_lib_search_dirs $sys_lib_search_path $shlib_search_path" else searchdirs="$newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path" fi for searchdir in $searchdirs; do for search_ext in .la $std_shrext .so .a; do # Search the libtool library lib=$searchdir/lib$name$search_ext if test -f "$lib"; then if test .la = "$search_ext"; then found=: else found=false fi break 2 fi done done if $found; then # deplib is a libtool library # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib, # We need to do some special things here, and not later. if test yes = "$allow_libtool_libs_with_static_runtimes"; then case " $predeps $postdeps " in *" $deplib "*) if func_lalib_p "$lib"; then library_names= old_library= func_source "$lib" for l in $old_library $library_names; do ll=$l done if test "X$ll" = "X$old_library"; then # only static version available found=false func_dirname "$lib" "" "." ladir=$func_dirname_result lib=$ladir/$old_library if test prog,link = "$linkmode,$pass"; then compile_deplibs="$deplib $compile_deplibs" finalize_deplibs="$deplib $finalize_deplibs" else deplibs="$deplib $deplibs" test lib = "$linkmode" && newdependency_libs="$deplib $newdependency_libs" fi continue fi fi ;; *) ;; esac fi else # deplib doesn't seem to be a libtool library if test prog,link = "$linkmode,$pass"; then compile_deplibs="$deplib $compile_deplibs" finalize_deplibs="$deplib $finalize_deplibs" else deplibs="$deplib $deplibs" test lib = "$linkmode" && newdependency_libs="$deplib $newdependency_libs" fi continue fi ;; # -l *.ltframework) if test prog,link = "$linkmode,$pass"; then compile_deplibs="$deplib $compile_deplibs" finalize_deplibs="$deplib $finalize_deplibs" else deplibs="$deplib $deplibs" if test lib = "$linkmode"; then case "$new_inherited_linker_flags " in *" $deplib "*) ;; * ) func_append new_inherited_linker_flags " $deplib" ;; esac fi fi continue ;; -L*) case $linkmode in lib) deplibs="$deplib $deplibs" test conv = "$pass" && continue newdependency_libs="$deplib $newdependency_libs" func_stripname '-L' '' "$deplib" func_resolve_sysroot "$func_stripname_result" func_append newlib_search_path " $func_resolve_sysroot_result" ;; prog) if test conv = "$pass"; then deplibs="$deplib $deplibs" continue fi if test scan = "$pass"; then deplibs="$deplib $deplibs" else compile_deplibs="$deplib $compile_deplibs" finalize_deplibs="$deplib $finalize_deplibs" fi func_stripname '-L' '' "$deplib" func_resolve_sysroot "$func_stripname_result" func_append newlib_search_path " $func_resolve_sysroot_result" ;; *) func_warning "'-L' is ignored for archives/objects" ;; esac # linkmode continue ;; # -L -R*) if test link = "$pass"; then func_stripname '-R' '' "$deplib" func_resolve_sysroot "$func_stripname_result" dir=$func_resolve_sysroot_result # Make sure the xrpath contains only unique directories. case "$xrpath " in *" $dir "*) ;; *) func_append xrpath " $dir" ;; esac fi deplibs="$deplib $deplibs" continue ;; *.la) func_resolve_sysroot "$deplib" lib=$func_resolve_sysroot_result ;; *.$libext) if test conv = "$pass"; then deplibs="$deplib $deplibs" continue fi case $linkmode in lib) # Linking convenience modules into shared libraries is allowed, # but linking other static libraries is non-portable. case " $dlpreconveniencelibs " in *" $deplib "*) ;; *) valid_a_lib=false case $deplibs_check_method in match_pattern*) set dummy $deplibs_check_method; shift match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"` if eval "\$ECHO \"$deplib\"" 2>/dev/null | $SED 10q \ | $EGREP "$match_pattern_regex" > /dev/null; then valid_a_lib=: fi ;; pass_all) valid_a_lib=: ;; esac if $valid_a_lib; then echo $ECHO "*** Warning: Linking the shared library $output against the" $ECHO "*** static library $deplib is not portable!" deplibs="$deplib $deplibs" else echo $ECHO "*** Warning: Trying to link with static lib archive $deplib." echo "*** I have the capability to make that library automatically link in when" echo "*** you link to this library. But I can only do this if you have a" echo "*** shared version of the library, which you do not appear to have" echo "*** because the file extensions .$libext of this argument makes me believe" echo "*** that it is just a static archive that I should not use here." fi ;; esac continue ;; prog) if test link != "$pass"; then deplibs="$deplib $deplibs" else compile_deplibs="$deplib $compile_deplibs" finalize_deplibs="$deplib $finalize_deplibs" fi continue ;; esac # linkmode ;; # *.$libext *.lo | *.$objext) if test conv = "$pass"; then deplibs="$deplib $deplibs" elif test prog = "$linkmode"; then if test dlpreopen = "$pass" || test yes != "$dlopen_support" || test no = "$build_libtool_libs"; then # If there is no dlopen support or we're linking statically, # we need to preload. func_append newdlprefiles " $deplib" compile_deplibs="$deplib $compile_deplibs" finalize_deplibs="$deplib $finalize_deplibs" else func_append newdlfiles " $deplib" fi fi continue ;; %DEPLIBS%) alldeplibs=: continue ;; esac # case $deplib $found || test -f "$lib" \ || func_fatal_error "cannot find the library '$lib' or unhandled argument '$deplib'" # Check to see that this really is a libtool archive. func_lalib_unsafe_p "$lib" \ || func_fatal_error "'$lib' is not a valid libtool archive" func_dirname "$lib" "" "." ladir=$func_dirname_result dlname= dlopen= dlpreopen= libdir= library_names= old_library= inherited_linker_flags= # If the library was installed with an old release of libtool, # it will not redefine variables installed, or shouldnotlink installed=yes shouldnotlink=no avoidtemprpath= # Read the .la file func_source "$lib" # Convert "-framework foo" to "foo.ltframework" if test -n "$inherited_linker_flags"; then tmp_inherited_linker_flags=`$ECHO "$inherited_linker_flags" | $SED 's/-framework \([^ $]*\)/\1.ltframework/g'` for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do case " $new_inherited_linker_flags " in *" $tmp_inherited_linker_flag "*) ;; *) func_append new_inherited_linker_flags " $tmp_inherited_linker_flag";; esac done fi dependency_libs=`$ECHO " $dependency_libs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'` if test lib,link = "$linkmode,$pass" || test prog,scan = "$linkmode,$pass" || { test prog != "$linkmode" && test lib != "$linkmode"; }; then test -n "$dlopen" && func_append dlfiles " $dlopen" test -n "$dlpreopen" && func_append dlprefiles " $dlpreopen" fi if test conv = "$pass"; then # Only check for convenience libraries deplibs="$lib $deplibs" if test -z "$libdir"; then if test -z "$old_library"; then func_fatal_error "cannot find name of link library for '$lib'" fi # It is a libtool convenience library, so add in its objects. func_append convenience " $ladir/$objdir/$old_library" func_append old_convenience " $ladir/$objdir/$old_library" elif test prog != "$linkmode" && test lib != "$linkmode"; then func_fatal_error "'$lib' is not a convenience library" fi tmp_libs= for deplib in $dependency_libs; do deplibs="$deplib $deplibs" if $opt_preserve_dup_deps; then case "$tmp_libs " in *" $deplib "*) func_append specialdeplibs " $deplib" ;; esac fi func_append tmp_libs " $deplib" done continue fi # $pass = conv # Get the name of the library we link against. linklib= if test -n "$old_library" && { test yes = "$prefer_static_libs" || test built,no = "$prefer_static_libs,$installed"; }; then linklib=$old_library else for l in $old_library $library_names; do linklib=$l done fi if test -z "$linklib"; then func_fatal_error "cannot find name of link library for '$lib'" fi # This library was specified with -dlopen. if test dlopen = "$pass"; then test -z "$libdir" \ && func_fatal_error "cannot -dlopen a convenience library: '$lib'" if test -z "$dlname" || test yes != "$dlopen_support" || test no = "$build_libtool_libs" then # If there is no dlname, no dlopen support or we're linking # statically, we need to preload. We also need to preload any # dependent libraries so libltdl's deplib preloader doesn't # bomb out in the load deplibs phase. func_append dlprefiles " $lib $dependency_libs" else func_append newdlfiles " $lib" fi continue fi # $pass = dlopen # We need an absolute path. case $ladir in [\\/]* | [A-Za-z]:[\\/]*) abs_ladir=$ladir ;; *) abs_ladir=`cd "$ladir" && pwd` if test -z "$abs_ladir"; then func_warning "cannot determine absolute directory name of '$ladir'" func_warning "passing it literally to the linker, although it might fail" abs_ladir=$ladir fi ;; esac func_basename "$lib" laname=$func_basename_result # Find the relevant object directory and library name. if test yes = "$installed"; then if test ! -f "$lt_sysroot$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then func_warning "library '$lib' was moved." dir=$ladir absdir=$abs_ladir libdir=$abs_ladir else dir=$lt_sysroot$libdir absdir=$lt_sysroot$libdir fi test yes = "$hardcode_automatic" && avoidtemprpath=yes else if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then dir=$ladir absdir=$abs_ladir # Remove this search path later func_append notinst_path " $abs_ladir" else dir=$ladir/$objdir absdir=$abs_ladir/$objdir # Remove this search path later func_append notinst_path " $abs_ladir" fi fi # $installed = yes func_stripname 'lib' '.la' "$laname" name=$func_stripname_result # This library was specified with -dlpreopen. if test dlpreopen = "$pass"; then if test -z "$libdir" && test prog = "$linkmode"; then func_fatal_error "only libraries may -dlpreopen a convenience library: '$lib'" fi case $host in # special handling for platforms with PE-DLLs. *cygwin* | *mingw* | *cegcc* ) # Linker will automatically link against shared library if both # static and shared are present. Therefore, ensure we extract # symbols from the import library if a shared library is present # (otherwise, the dlopen module name will be incorrect). We do # this by putting the import library name into $newdlprefiles. # We recover the dlopen module name by 'saving' the la file # name in a special purpose variable, and (later) extracting the # dlname from the la file. if test -n "$dlname"; then func_tr_sh "$dir/$linklib" eval "libfile_$func_tr_sh_result=\$abs_ladir/\$laname" func_append newdlprefiles " $dir/$linklib" else func_append newdlprefiles " $dir/$old_library" # Keep a list of preopened convenience libraries to check # that they are being used correctly in the link pass. test -z "$libdir" && \ func_append dlpreconveniencelibs " $dir/$old_library" fi ;; * ) # Prefer using a static library (so that no silly _DYNAMIC symbols # are required to link). if test -n "$old_library"; then func_append newdlprefiles " $dir/$old_library" # Keep a list of preopened convenience libraries to check # that they are being used correctly in the link pass. test -z "$libdir" && \ func_append dlpreconveniencelibs " $dir/$old_library" # Otherwise, use the dlname, so that lt_dlopen finds it. elif test -n "$dlname"; then func_append newdlprefiles " $dir/$dlname" else func_append newdlprefiles " $dir/$linklib" fi ;; esac fi # $pass = dlpreopen if test -z "$libdir"; then # Link the convenience library if test lib = "$linkmode"; then deplibs="$dir/$old_library $deplibs" elif test prog,link = "$linkmode,$pass"; then compile_deplibs="$dir/$old_library $compile_deplibs" finalize_deplibs="$dir/$old_library $finalize_deplibs" else deplibs="$lib $deplibs" # used for prog,scan pass fi continue fi if test prog = "$linkmode" && test link != "$pass"; then func_append newlib_search_path " $ladir" deplibs="$lib $deplibs" linkalldeplibs=false if test no != "$link_all_deplibs" || test -z "$library_names" || test no = "$build_libtool_libs"; then linkalldeplibs=: fi tmp_libs= for deplib in $dependency_libs; do case $deplib in -L*) func_stripname '-L' '' "$deplib" func_resolve_sysroot "$func_stripname_result" func_append newlib_search_path " $func_resolve_sysroot_result" ;; esac # Need to link against all dependency_libs? if $linkalldeplibs; then deplibs="$deplib $deplibs" else # Need to hardcode shared library paths # or/and link against static libraries newdependency_libs="$deplib $newdependency_libs" fi if $opt_preserve_dup_deps; then case "$tmp_libs " in *" $deplib "*) func_append specialdeplibs " $deplib" ;; esac fi func_append tmp_libs " $deplib" done # for deplib continue fi # $linkmode = prog... if test prog,link = "$linkmode,$pass"; then if test -n "$library_names" && { { test no = "$prefer_static_libs" || test built,yes = "$prefer_static_libs,$installed"; } || test -z "$old_library"; }; then # We need to hardcode the library path if test -n "$shlibpath_var" && test -z "$avoidtemprpath"; then # Make sure the rpath contains only unique directories. case $temp_rpath: in *"$absdir:"*) ;; *) func_append temp_rpath "$absdir:" ;; esac fi # Hardcode the library path. # Skip directories that are in the system default run-time # search path. case " $sys_lib_dlsearch_path " in *" $absdir "*) ;; *) case "$compile_rpath " in *" $absdir "*) ;; *) func_append compile_rpath " $absdir" ;; esac ;; esac case " $sys_lib_dlsearch_path " in *" $libdir "*) ;; *) case "$finalize_rpath " in *" $libdir "*) ;; *) func_append finalize_rpath " $libdir" ;; esac ;; esac fi # $linkmode,$pass = prog,link... if $alldeplibs && { test pass_all = "$deplibs_check_method" || { test yes = "$build_libtool_libs" && test -n "$library_names"; }; }; then # We only need to search for static libraries continue fi fi link_static=no # Whether the deplib will be linked statically use_static_libs=$prefer_static_libs if test built = "$use_static_libs" && test yes = "$installed"; then use_static_libs=no fi if test -n "$library_names" && { test no = "$use_static_libs" || test -z "$old_library"; }; then case $host in *cygwin* | *mingw* | *cegcc* | *os2*) # No point in relinking DLLs because paths are not encoded func_append notinst_deplibs " $lib" need_relink=no ;; *) if test no = "$installed"; then func_append notinst_deplibs " $lib" need_relink=yes fi ;; esac # This is a shared library # Warn about portability, can't link against -module's on some # systems (darwin). Don't bleat about dlopened modules though! dlopenmodule= for dlpremoduletest in $dlprefiles; do if test "X$dlpremoduletest" = "X$lib"; then dlopenmodule=$dlpremoduletest break fi done if test -z "$dlopenmodule" && test yes = "$shouldnotlink" && test link = "$pass"; then echo if test prog = "$linkmode"; then $ECHO "*** Warning: Linking the executable $output against the loadable module" else $ECHO "*** Warning: Linking the shared library $output against the loadable module" fi $ECHO "*** $linklib is not portable!" fi if test lib = "$linkmode" && test yes = "$hardcode_into_libs"; then # Hardcode the library path. # Skip directories that are in the system default run-time # search path. case " $sys_lib_dlsearch_path " in *" $absdir "*) ;; *) case "$compile_rpath " in *" $absdir "*) ;; *) func_append compile_rpath " $absdir" ;; esac ;; esac case " $sys_lib_dlsearch_path " in *" $libdir "*) ;; *) case "$finalize_rpath " in *" $libdir "*) ;; *) func_append finalize_rpath " $libdir" ;; esac ;; esac fi if test -n "$old_archive_from_expsyms_cmds"; then # figure out the soname set dummy $library_names shift realname=$1 shift libname=`eval "\\$ECHO \"$libname_spec\""` # use dlname if we got it. it's perfectly good, no? if test -n "$dlname"; then soname=$dlname elif test -n "$soname_spec"; then # bleh windows case $host in *cygwin* | mingw* | *cegcc* | *os2*) func_arith $current - $age major=$func_arith_result versuffix=-$major ;; esac eval soname=\"$soname_spec\" else soname=$realname fi # Make a new name for the extract_expsyms_cmds to use soroot=$soname func_basename "$soroot" soname=$func_basename_result func_stripname 'lib' '.dll' "$soname" newlib=libimp-$func_stripname_result.a # If the library has no export list, then create one now if test -f "$output_objdir/$soname-def"; then : else func_verbose "extracting exported symbol list from '$soname'" func_execute_cmds "$extract_expsyms_cmds" 'exit $?' fi # Create $newlib if test -f "$output_objdir/$newlib"; then :; else func_verbose "generating import library for '$soname'" func_execute_cmds "$old_archive_from_expsyms_cmds" 'exit $?' fi # make sure the library variables are pointing to the new library dir=$output_objdir linklib=$newlib fi # test -n "$old_archive_from_expsyms_cmds" if test prog = "$linkmode" || test relink != "$opt_mode"; then add_shlibpath= add_dir= add= lib_linked=yes case $hardcode_action in immediate | unsupported) if test no = "$hardcode_direct"; then add=$dir/$linklib case $host in *-*-sco3.2v5.0.[024]*) add_dir=-L$dir ;; *-*-sysv4*uw2*) add_dir=-L$dir ;; *-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \ *-*-unixware7*) add_dir=-L$dir ;; *-*-darwin* ) # if the lib is a (non-dlopened) module then we cannot # link against it, someone is ignoring the earlier warnings if /usr/bin/file -L $add 2> /dev/null | $GREP ": [^:]* bundle" >/dev/null; then if test "X$dlopenmodule" != "X$lib"; then $ECHO "*** Warning: lib $linklib is a module, not a shared library" if test -z "$old_library"; then echo echo "*** And there doesn't seem to be a static archive available" echo "*** The link will probably fail, sorry" else add=$dir/$old_library fi elif test -n "$old_library"; then add=$dir/$old_library fi fi esac elif test no = "$hardcode_minus_L"; then case $host in *-*-sunos*) add_shlibpath=$dir ;; esac add_dir=-L$dir add=-l$name elif test no = "$hardcode_shlibpath_var"; then add_shlibpath=$dir add=-l$name else lib_linked=no fi ;; relink) if test yes = "$hardcode_direct" && test no = "$hardcode_direct_absolute"; then add=$dir/$linklib elif test yes = "$hardcode_minus_L"; then add_dir=-L$absdir # Try looking first in the location we're being installed to. if test -n "$inst_prefix_dir"; then case $libdir in [\\/]*) func_append add_dir " -L$inst_prefix_dir$libdir" ;; esac fi add=-l$name elif test yes = "$hardcode_shlibpath_var"; then add_shlibpath=$dir add=-l$name else lib_linked=no fi ;; *) lib_linked=no ;; esac if test yes != "$lib_linked"; then func_fatal_configuration "unsupported hardcode properties" fi if test -n "$add_shlibpath"; then case :$compile_shlibpath: in *":$add_shlibpath:"*) ;; *) func_append compile_shlibpath "$add_shlibpath:" ;; esac fi if test prog = "$linkmode"; then test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs" test -n "$add" && compile_deplibs="$add $compile_deplibs" else test -n "$add_dir" && deplibs="$add_dir $deplibs" test -n "$add" && deplibs="$add $deplibs" if test yes != "$hardcode_direct" && test yes != "$hardcode_minus_L" && test yes = "$hardcode_shlibpath_var"; then case :$finalize_shlibpath: in *":$libdir:"*) ;; *) func_append finalize_shlibpath "$libdir:" ;; esac fi fi fi if test prog = "$linkmode" || test relink = "$opt_mode"; then add_shlibpath= add_dir= add= # Finalize command for both is simple: just hardcode it. if test yes = "$hardcode_direct" && test no = "$hardcode_direct_absolute"; then add=$libdir/$linklib elif test yes = "$hardcode_minus_L"; then add_dir=-L$libdir add=-l$name elif test yes = "$hardcode_shlibpath_var"; then case :$finalize_shlibpath: in *":$libdir:"*) ;; *) func_append finalize_shlibpath "$libdir:" ;; esac add=-l$name elif test yes = "$hardcode_automatic"; then if test -n "$inst_prefix_dir" && test -f "$inst_prefix_dir$libdir/$linklib"; then add=$inst_prefix_dir$libdir/$linklib else add=$libdir/$linklib fi else # We cannot seem to hardcode it, guess we'll fake it. add_dir=-L$libdir # Try looking first in the location we're being installed to. if test -n "$inst_prefix_dir"; then case $libdir in [\\/]*) func_append add_dir " -L$inst_prefix_dir$libdir" ;; esac fi add=-l$name fi if test prog = "$linkmode"; then test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs" test -n "$add" && finalize_deplibs="$add $finalize_deplibs" else test -n "$add_dir" && deplibs="$add_dir $deplibs" test -n "$add" && deplibs="$add $deplibs" fi fi elif test prog = "$linkmode"; then # Here we assume that one of hardcode_direct or hardcode_minus_L # is not unsupported. This is valid on all known static and # shared platforms. if test unsupported != "$hardcode_direct"; then test -n "$old_library" && linklib=$old_library compile_deplibs="$dir/$linklib $compile_deplibs" finalize_deplibs="$dir/$linklib $finalize_deplibs" else compile_deplibs="-l$name -L$dir $compile_deplibs" finalize_deplibs="-l$name -L$dir $finalize_deplibs" fi elif test yes = "$build_libtool_libs"; then # Not a shared library if test pass_all != "$deplibs_check_method"; then # We're trying link a shared library against a static one # but the system doesn't support it. # Just print a warning and add the library to dependency_libs so # that the program can be linked against the static library. echo $ECHO "*** Warning: This system cannot link to static lib archive $lib." echo "*** I have the capability to make that library automatically link in when" echo "*** you link to this library. But I can only do this if you have a" echo "*** shared version of the library, which you do not appear to have." if test yes = "$module"; then echo "*** But as you try to build a module library, libtool will still create " echo "*** a static module, that should work as long as the dlopening application" echo "*** is linked with the -dlopen flag to resolve symbols at runtime." if test -z "$global_symbol_pipe"; then echo echo "*** However, this would only work if libtool was able to extract symbol" echo "*** lists from a program, using 'nm' or equivalent, but libtool could" echo "*** not find such a program. So, this module is probably useless." echo "*** 'nm' from GNU binutils and a full rebuild may help." fi if test no = "$build_old_libs"; then build_libtool_libs=module build_old_libs=yes else build_libtool_libs=no fi fi else deplibs="$dir/$old_library $deplibs" link_static=yes fi fi # link shared/static library? if test lib = "$linkmode"; then if test -n "$dependency_libs" && { test yes != "$hardcode_into_libs" || test yes = "$build_old_libs" || test yes = "$link_static"; }; then # Extract -R from dependency_libs temp_deplibs= for libdir in $dependency_libs; do case $libdir in -R*) func_stripname '-R' '' "$libdir" temp_xrpath=$func_stripname_result case " $xrpath " in *" $temp_xrpath "*) ;; *) func_append xrpath " $temp_xrpath";; esac;; *) func_append temp_deplibs " $libdir";; esac done dependency_libs=$temp_deplibs fi func_append newlib_search_path " $absdir" # Link against this library test no = "$link_static" && newdependency_libs="$abs_ladir/$laname $newdependency_libs" # ... and its dependency_libs tmp_libs= for deplib in $dependency_libs; do newdependency_libs="$deplib $newdependency_libs" case $deplib in -L*) func_stripname '-L' '' "$deplib" func_resolve_sysroot "$func_stripname_result";; *) func_resolve_sysroot "$deplib" ;; esac if $opt_preserve_dup_deps; then case "$tmp_libs " in *" $func_resolve_sysroot_result "*) func_append specialdeplibs " $func_resolve_sysroot_result" ;; esac fi func_append tmp_libs " $func_resolve_sysroot_result" done if test no != "$link_all_deplibs"; then # Add the search paths of all dependency libraries for deplib in $dependency_libs; do path= case $deplib in -L*) path=$deplib ;; *.la) func_resolve_sysroot "$deplib" deplib=$func_resolve_sysroot_result func_dirname "$deplib" "" "." dir=$func_dirname_result # We need an absolute path. case $dir in [\\/]* | [A-Za-z]:[\\/]*) absdir=$dir ;; *) absdir=`cd "$dir" && pwd` if test -z "$absdir"; then func_warning "cannot determine absolute directory name of '$dir'" absdir=$dir fi ;; esac if $GREP "^installed=no" $deplib > /dev/null; then case $host in *-*-darwin*) depdepl= eval deplibrary_names=`$SED -n -e 's/^library_names=\(.*\)$/\1/p' $deplib` if test -n "$deplibrary_names"; then for tmp in $deplibrary_names; do depdepl=$tmp done if test -f "$absdir/$objdir/$depdepl"; then depdepl=$absdir/$objdir/$depdepl darwin_install_name=`$OTOOL -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'` if test -z "$darwin_install_name"; then darwin_install_name=`$OTOOL64 -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'` fi func_append compiler_flags " $wl-dylib_file $wl$darwin_install_name:$depdepl" func_append linker_flags " -dylib_file $darwin_install_name:$depdepl" path= fi fi ;; *) path=-L$absdir/$objdir ;; esac else eval libdir=`$SED -n -e 's/^libdir=\(.*\)$/\1/p' $deplib` test -z "$libdir" && \ func_fatal_error "'$deplib' is not a valid libtool archive" test "$absdir" != "$libdir" && \ func_warning "'$deplib' seems to be moved" path=-L$absdir fi ;; esac case " $deplibs " in *" $path "*) ;; *) deplibs="$path $deplibs" ;; esac done fi # link_all_deplibs != no fi # linkmode = lib done # for deplib in $libs if test link = "$pass"; then if test prog = "$linkmode"; then compile_deplibs="$new_inherited_linker_flags $compile_deplibs" finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs" else compiler_flags="$compiler_flags "`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'` fi fi dependency_libs=$newdependency_libs if test dlpreopen = "$pass"; then # Link the dlpreopened libraries before other libraries for deplib in $save_deplibs; do deplibs="$deplib $deplibs" done fi if test dlopen != "$pass"; then test conv = "$pass" || { # Make sure lib_search_path contains only unique directories. lib_search_path= for dir in $newlib_search_path; do case "$lib_search_path " in *" $dir "*) ;; *) func_append lib_search_path " $dir" ;; esac done newlib_search_path= } if test prog,link = "$linkmode,$pass"; then vars="compile_deplibs finalize_deplibs" else vars=deplibs fi for var in $vars dependency_libs; do # Add libraries to $var in reverse order eval tmp_libs=\"\$$var\" new_libs= for deplib in $tmp_libs; do # FIXME: Pedantically, this is the right thing to do, so # that some nasty dependency loop isn't accidentally # broken: #new_libs="$deplib $new_libs" # Pragmatically, this seems to cause very few problems in # practice: case $deplib in -L*) new_libs="$deplib $new_libs" ;; -R*) ;; *) # And here is the reason: when a library appears more # than once as an explicit dependence of a library, or # is implicitly linked in more than once by the # compiler, it is considered special, and multiple # occurrences thereof are not removed. Compare this # with having the same library being listed as a # dependency of multiple other libraries: in this case, # we know (pedantically, we assume) the library does not # need to be listed more than once, so we keep only the # last copy. This is not always right, but it is rare # enough that we require users that really mean to play # such unportable linking tricks to link the library # using -Wl,-lname, so that libtool does not consider it # for duplicate removal. case " $specialdeplibs " in *" $deplib "*) new_libs="$deplib $new_libs" ;; *) case " $new_libs " in *" $deplib "*) ;; *) new_libs="$deplib $new_libs" ;; esac ;; esac ;; esac done tmp_libs= for deplib in $new_libs; do case $deplib in -L*) case " $tmp_libs " in *" $deplib "*) ;; *) func_append tmp_libs " $deplib" ;; esac ;; *) func_append tmp_libs " $deplib" ;; esac done eval $var=\"$tmp_libs\" done # for var fi # Add Sun CC postdeps if required: test CXX = "$tagname" && { case $host_os in linux*) case `$CC -V 2>&1 | sed 5q` in *Sun\ C*) # Sun C++ 5.9 func_suncc_cstd_abi if test no != "$suncc_use_cstd_abi"; then func_append postdeps ' -library=Cstd -library=Crun' fi ;; esac ;; solaris*) func_cc_basename "$CC" case $func_cc_basename_result in CC* | sunCC*) func_suncc_cstd_abi if test no != "$suncc_use_cstd_abi"; then func_append postdeps ' -library=Cstd -library=Crun' fi ;; esac ;; esac } # Last step: remove runtime libs from dependency_libs # (they stay in deplibs) tmp_libs= for i in $dependency_libs; do case " $predeps $postdeps $compiler_lib_search_path " in *" $i "*) i= ;; esac if test -n "$i"; then func_append tmp_libs " $i" fi done dependency_libs=$tmp_libs done # for pass if test prog = "$linkmode"; then dlfiles=$newdlfiles fi if test prog = "$linkmode" || test lib = "$linkmode"; then dlprefiles=$newdlprefiles fi case $linkmode in oldlib) if test -n "$dlfiles$dlprefiles" || test no != "$dlself"; then func_warning "'-dlopen' is ignored for archives" fi case " $deplibs" in *\ -l* | *\ -L*) func_warning "'-l' and '-L' are ignored for archives" ;; esac test -n "$rpath" && \ func_warning "'-rpath' is ignored for archives" test -n "$xrpath" && \ func_warning "'-R' is ignored for archives" test -n "$vinfo" && \ func_warning "'-version-info/-version-number' is ignored for archives" test -n "$release" && \ func_warning "'-release' is ignored for archives" test -n "$export_symbols$export_symbols_regex" && \ func_warning "'-export-symbols' is ignored for archives" # Now set the variables for building old libraries. build_libtool_libs=no oldlibs=$output func_append objs "$old_deplibs" ;; lib) # Make sure we only generate libraries of the form 'libNAME.la'. case $outputname in lib*) func_stripname 'lib' '.la' "$outputname" name=$func_stripname_result eval shared_ext=\"$shrext_cmds\" eval libname=\"$libname_spec\" ;; *) test no = "$module" \ && func_fatal_help "libtool library '$output' must begin with 'lib'" if test no != "$need_lib_prefix"; then # Add the "lib" prefix for modules if required func_stripname '' '.la' "$outputname" name=$func_stripname_result eval shared_ext=\"$shrext_cmds\" eval libname=\"$libname_spec\" else func_stripname '' '.la' "$outputname" libname=$func_stripname_result fi ;; esac if test -n "$objs"; then if test pass_all != "$deplibs_check_method"; then func_fatal_error "cannot build libtool library '$output' from non-libtool objects on this host:$objs" else echo $ECHO "*** Warning: Linking the shared library $output against the non-libtool" $ECHO "*** objects $objs is not portable!" func_append libobjs " $objs" fi fi test no = "$dlself" \ || func_warning "'-dlopen self' is ignored for libtool libraries" set dummy $rpath shift test 1 -lt "$#" \ && func_warning "ignoring multiple '-rpath's for a libtool library" install_libdir=$1 oldlibs= if test -z "$rpath"; then if test yes = "$build_libtool_libs"; then # Building a libtool convenience library. # Some compilers have problems with a '.al' extension so # convenience libraries should have the same extension an # archive normally would. oldlibs="$output_objdir/$libname.$libext $oldlibs" build_libtool_libs=convenience build_old_libs=yes fi test -n "$vinfo" && \ func_warning "'-version-info/-version-number' is ignored for convenience libraries" test -n "$release" && \ func_warning "'-release' is ignored for convenience libraries" else # Parse the version information argument. save_ifs=$IFS; IFS=: set dummy $vinfo 0 0 0 shift IFS=$save_ifs test -n "$7" && \ func_fatal_help "too many parameters to '-version-info'" # convert absolute version numbers to libtool ages # this retains compatibility with .la files and attempts # to make the code below a bit more comprehensible case $vinfo_number in yes) number_major=$1 number_minor=$2 number_revision=$3 # # There are really only two kinds -- those that # use the current revision as the major version # and those that subtract age and use age as # a minor version. But, then there is irix # that has an extra 1 added just for fun # case $version_type in # correct linux to gnu/linux during the next big refactor darwin|freebsd-elf|linux|osf|windows|none) func_arith $number_major + $number_minor current=$func_arith_result age=$number_minor revision=$number_revision ;; freebsd-aout|qnx|sunos) current=$number_major revision=$number_minor age=0 ;; irix|nonstopux) func_arith $number_major + $number_minor current=$func_arith_result age=$number_minor revision=$number_minor lt_irix_increment=no ;; esac ;; no) current=$1 revision=$2 age=$3 ;; esac # Check that each of the things are valid numbers. case $current in 0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;; *) func_error "CURRENT '$current' must be a nonnegative integer" func_fatal_error "'$vinfo' is not valid version information" ;; esac case $revision in 0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;; *) func_error "REVISION '$revision' must be a nonnegative integer" func_fatal_error "'$vinfo' is not valid version information" ;; esac case $age in 0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;; *) func_error "AGE '$age' must be a nonnegative integer" func_fatal_error "'$vinfo' is not valid version information" ;; esac if test "$age" -gt "$current"; then func_error "AGE '$age' is greater than the current interface number '$current'" func_fatal_error "'$vinfo' is not valid version information" fi # Calculate the version variables. major= versuffix= verstring= case $version_type in none) ;; darwin) # Like Linux, but with the current version available in # verstring for coding it into the library header func_arith $current - $age major=.$func_arith_result versuffix=$major.$age.$revision # Darwin ld doesn't like 0 for these options... func_arith $current + 1 minor_current=$func_arith_result xlcverstring="$wl-compatibility_version $wl$minor_current $wl-current_version $wl$minor_current.$revision" verstring="-compatibility_version $minor_current -current_version $minor_current.$revision" # On Darwin other compilers case $CC in nagfor*) verstring="$wl-compatibility_version $wl$minor_current $wl-current_version $wl$minor_current.$revision" ;; *) verstring="-compatibility_version $minor_current -current_version $minor_current.$revision" ;; esac ;; freebsd-aout) major=.$current versuffix=.$current.$revision ;; freebsd-elf) func_arith $current - $age major=.$func_arith_result versuffix=$major.$age.$revision ;; irix | nonstopux) if test no = "$lt_irix_increment"; then func_arith $current - $age else func_arith $current - $age + 1 fi major=$func_arith_result case $version_type in nonstopux) verstring_prefix=nonstopux ;; *) verstring_prefix=sgi ;; esac verstring=$verstring_prefix$major.$revision # Add in all the interfaces that we are compatible with. loop=$revision while test 0 -ne "$loop"; do func_arith $revision - $loop iface=$func_arith_result func_arith $loop - 1 loop=$func_arith_result verstring=$verstring_prefix$major.$iface:$verstring done # Before this point, $major must not contain '.'. major=.$major versuffix=$major.$revision ;; linux) # correct to gnu/linux during the next big refactor func_arith $current - $age major=.$func_arith_result versuffix=$major.$age.$revision ;; osf) func_arith $current - $age major=.$func_arith_result versuffix=.$current.$age.$revision verstring=$current.$age.$revision # Add in all the interfaces that we are compatible with. loop=$age while test 0 -ne "$loop"; do func_arith $current - $loop iface=$func_arith_result func_arith $loop - 1 loop=$func_arith_result verstring=$verstring:$iface.0 done # Make executables depend on our current version. func_append verstring ":$current.0" ;; qnx) major=.$current versuffix=.$current ;; sco) major=.$current versuffix=.$current ;; sunos) major=.$current versuffix=.$current.$revision ;; windows) # Use '-' rather than '.', since we only want one # extension on DOS 8.3 file systems. func_arith $current - $age major=$func_arith_result versuffix=-$major ;; *) func_fatal_configuration "unknown library version type '$version_type'" ;; esac # Clear the version info if we defaulted, and they specified a release. if test -z "$vinfo" && test -n "$release"; then major= case $version_type in darwin) # we can't check for "0.0" in archive_cmds due to quoting # problems, so we reset it completely verstring= ;; *) verstring=0.0 ;; esac if test no = "$need_version"; then versuffix= else versuffix=.0.0 fi fi # Remove version info from name if versioning should be avoided if test yes,no = "$avoid_version,$need_version"; then major= versuffix= verstring= fi # Check to see if the archive will have undefined symbols. if test yes = "$allow_undefined"; then if test unsupported = "$allow_undefined_flag"; then if test yes = "$build_old_libs"; then func_warning "undefined symbols not allowed in $host shared libraries; building static only" build_libtool_libs=no else func_fatal_error "can't build $host shared library unless -no-undefined is specified" fi fi else # Don't allow undefined symbols. allow_undefined_flag=$no_undefined_flag fi fi func_generate_dlsyms "$libname" "$libname" : func_append libobjs " $symfileobj" test " " = "$libobjs" && libobjs= if test relink != "$opt_mode"; then # Remove our outputs, but don't remove object files since they # may have been created when compiling PIC objects. removelist= tempremovelist=`$ECHO "$output_objdir/*"` for p in $tempremovelist; do case $p in *.$objext | *.gcno) ;; $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/$libname$release.*) if test -n "$precious_files_regex"; then if $ECHO "$p" | $EGREP -e "$precious_files_regex" >/dev/null 2>&1 then continue fi fi func_append removelist " $p" ;; *) ;; esac done test -n "$removelist" && \ func_show_eval "${RM}r \$removelist" fi # Now set the variables for building old libraries. if test yes = "$build_old_libs" && test convenience != "$build_libtool_libs"; then func_append oldlibs " $output_objdir/$libname.$libext" # Transform .lo files to .o files. oldobjs="$objs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.$libext$/d; $lo2o" | $NL2SP` fi # Eliminate all temporary directories. #for path in $notinst_path; do # lib_search_path=`$ECHO "$lib_search_path " | $SED "s% $path % %g"` # deplibs=`$ECHO "$deplibs " | $SED "s% -L$path % %g"` # dependency_libs=`$ECHO "$dependency_libs " | $SED "s% -L$path % %g"` #done if test -n "$xrpath"; then # If the user specified any rpath flags, then add them. temp_xrpath= for libdir in $xrpath; do func_replace_sysroot "$libdir" func_append temp_xrpath " -R$func_replace_sysroot_result" case "$finalize_rpath " in *" $libdir "*) ;; *) func_append finalize_rpath " $libdir" ;; esac done if test yes != "$hardcode_into_libs" || test yes = "$build_old_libs"; then dependency_libs="$temp_xrpath $dependency_libs" fi fi # Make sure dlfiles contains only unique files that won't be dlpreopened old_dlfiles=$dlfiles dlfiles= for lib in $old_dlfiles; do case " $dlprefiles $dlfiles " in *" $lib "*) ;; *) func_append dlfiles " $lib" ;; esac done # Make sure dlprefiles contains only unique files old_dlprefiles=$dlprefiles dlprefiles= for lib in $old_dlprefiles; do case "$dlprefiles " in *" $lib "*) ;; *) func_append dlprefiles " $lib" ;; esac done if test yes = "$build_libtool_libs"; then if test -n "$rpath"; then case $host in *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos* | *-cegcc* | *-*-haiku*) # these systems don't actually have a c library (as such)! ;; *-*-rhapsody* | *-*-darwin1.[012]) # Rhapsody C library is in the System framework func_append deplibs " System.ltframework" ;; *-*-netbsd*) # Don't link with libc until the a.out ld.so is fixed. ;; *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*) # Do not include libc due to us having libc/libc_r. ;; *-*-sco3.2v5* | *-*-sco5v6*) # Causes problems with __ctype ;; *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*) # Compiler inserts libc in the correct place for threads to work ;; *) # Add libc to deplibs on all other systems if necessary. if test yes = "$build_libtool_need_lc"; then func_append deplibs " -lc" fi ;; esac fi # Transform deplibs into only deplibs that can be linked in shared. name_save=$name libname_save=$libname release_save=$release versuffix_save=$versuffix major_save=$major # I'm not sure if I'm treating the release correctly. I think # release should show up in the -l (ie -lgmp5) so we don't want to # add it in twice. Is that correct? release= versuffix= major= newdeplibs= droppeddeps=no case $deplibs_check_method in pass_all) # Don't check for shared/static. Everything works. # This might be a little naive. We might want to check # whether the library exists or not. But this is on # osf3 & osf4 and I'm not really sure... Just # implementing what was already the behavior. newdeplibs=$deplibs ;; test_compile) # This code stresses the "libraries are programs" paradigm to its # limits. Maybe even breaks it. We compile a program, linking it # against the deplibs as a proxy for the library. Then we can check # whether they linked in statically or dynamically with ldd. $opt_dry_run || $RM conftest.c cat > conftest.c </dev/null` $nocaseglob else potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null` fi for potent_lib in $potential_libs; do # Follow soft links. if ls -lLd "$potent_lib" 2>/dev/null | $GREP " -> " >/dev/null; then continue fi # The statement above tries to avoid entering an # endless loop below, in case of cyclic links. # We might still enter an endless loop, since a link # loop can be closed while we follow links, # but so what? potlib=$potent_lib while test -h "$potlib" 2>/dev/null; do potliblink=`ls -ld $potlib | $SED 's/.* -> //'` case $potliblink in [\\/]* | [A-Za-z]:[\\/]*) potlib=$potliblink;; *) potlib=`$ECHO "$potlib" | $SED 's|[^/]*$||'`"$potliblink";; esac done if eval $file_magic_cmd \"\$potlib\" 2>/dev/null | $SED -e 10q | $EGREP "$file_magic_regex" > /dev/null; then func_append newdeplibs " $a_deplib" a_deplib= break 2 fi done done fi if test -n "$a_deplib"; then droppeddeps=yes echo $ECHO "*** Warning: linker path does not have real file for library $a_deplib." echo "*** I have the capability to make that library automatically link in when" echo "*** you link to this library. But I can only do this if you have a" echo "*** shared version of the library, which you do not appear to have" echo "*** because I did check the linker path looking for a file starting" if test -z "$potlib"; then $ECHO "*** with $libname but no candidates were found. (...for file magic test)" else $ECHO "*** with $libname and none of the candidates passed a file format test" $ECHO "*** using a file magic. Last file checked: $potlib" fi fi ;; *) # Add a -L argument. func_append newdeplibs " $a_deplib" ;; esac done # Gone through all deplibs. ;; match_pattern*) set dummy $deplibs_check_method; shift match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"` for a_deplib in $deplibs; do case $a_deplib in -l*) func_stripname -l '' "$a_deplib" name=$func_stripname_result if test yes = "$allow_libtool_libs_with_static_runtimes"; then case " $predeps $postdeps " in *" $a_deplib "*) func_append newdeplibs " $a_deplib" a_deplib= ;; esac fi if test -n "$a_deplib"; then libname=`eval "\\$ECHO \"$libname_spec\""` for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do potential_libs=`ls $i/$libname[.-]* 2>/dev/null` for potent_lib in $potential_libs; do potlib=$potent_lib # see symlink-check above in file_magic test if eval "\$ECHO \"$potent_lib\"" 2>/dev/null | $SED 10q | \ $EGREP "$match_pattern_regex" > /dev/null; then func_append newdeplibs " $a_deplib" a_deplib= break 2 fi done done fi if test -n "$a_deplib"; then droppeddeps=yes echo $ECHO "*** Warning: linker path does not have real file for library $a_deplib." echo "*** I have the capability to make that library automatically link in when" echo "*** you link to this library. But I can only do this if you have a" echo "*** shared version of the library, which you do not appear to have" echo "*** because I did check the linker path looking for a file starting" if test -z "$potlib"; then $ECHO "*** with $libname but no candidates were found. (...for regex pattern test)" else $ECHO "*** with $libname and none of the candidates passed a file format test" $ECHO "*** using a regex pattern. Last file checked: $potlib" fi fi ;; *) # Add a -L argument. func_append newdeplibs " $a_deplib" ;; esac done # Gone through all deplibs. ;; none | unknown | *) newdeplibs= tmp_deplibs=`$ECHO " $deplibs" | $SED 's/ -lc$//; s/ -[LR][^ ]*//g'` if test yes = "$allow_libtool_libs_with_static_runtimes"; then for i in $predeps $postdeps; do # can't use Xsed below, because $i might contain '/' tmp_deplibs=`$ECHO " $tmp_deplibs" | $SED "s|$i||"` done fi case $tmp_deplibs in *[!\ \ ]*) echo if test none = "$deplibs_check_method"; then echo "*** Warning: inter-library dependencies are not supported in this platform." else echo "*** Warning: inter-library dependencies are not known to be supported." fi echo "*** All declared inter-library dependencies are being dropped." droppeddeps=yes ;; esac ;; esac versuffix=$versuffix_save major=$major_save release=$release_save libname=$libname_save name=$name_save case $host in *-*-rhapsody* | *-*-darwin1.[012]) # On Rhapsody replace the C library with the System framework newdeplibs=`$ECHO " $newdeplibs" | $SED 's/ -lc / System.ltframework /'` ;; esac if test yes = "$droppeddeps"; then if test yes = "$module"; then echo echo "*** Warning: libtool could not satisfy all declared inter-library" $ECHO "*** dependencies of module $libname. Therefore, libtool will create" echo "*** a static module, that should work as long as the dlopening" echo "*** application is linked with the -dlopen flag." if test -z "$global_symbol_pipe"; then echo echo "*** However, this would only work if libtool was able to extract symbol" echo "*** lists from a program, using 'nm' or equivalent, but libtool could" echo "*** not find such a program. So, this module is probably useless." echo "*** 'nm' from GNU binutils and a full rebuild may help." fi if test no = "$build_old_libs"; then oldlibs=$output_objdir/$libname.$libext build_libtool_libs=module build_old_libs=yes else build_libtool_libs=no fi else echo "*** The inter-library dependencies that have been dropped here will be" echo "*** automatically added whenever a program is linked with this library" echo "*** or is declared to -dlopen it." if test no = "$allow_undefined"; then echo echo "*** Since this library must not contain undefined symbols," echo "*** because either the platform does not support them or" echo "*** it was explicitly requested with -no-undefined," echo "*** libtool will only create a static version of it." if test no = "$build_old_libs"; then oldlibs=$output_objdir/$libname.$libext build_libtool_libs=module build_old_libs=yes else build_libtool_libs=no fi fi fi fi # Done checking deplibs! deplibs=$newdeplibs fi # Time to change all our "foo.ltframework" stuff back to "-framework foo" case $host in *-*-darwin*) newdeplibs=`$ECHO " $newdeplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'` new_inherited_linker_flags=`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'` deplibs=`$ECHO " $deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'` ;; esac # move library search paths that coincide with paths to not yet # installed libraries to the beginning of the library search list new_libs= for path in $notinst_path; do case " $new_libs " in *" -L$path/$objdir "*) ;; *) case " $deplibs " in *" -L$path/$objdir "*) func_append new_libs " -L$path/$objdir" ;; esac ;; esac done for deplib in $deplibs; do case $deplib in -L*) case " $new_libs " in *" $deplib "*) ;; *) func_append new_libs " $deplib" ;; esac ;; *) func_append new_libs " $deplib" ;; esac done deplibs=$new_libs # All the library-specific variables (install_libdir is set above). library_names= old_library= dlname= # Test again, we may have decided not to build it any more if test yes = "$build_libtool_libs"; then # Remove $wl instances when linking with ld. # FIXME: should test the right _cmds variable. case $archive_cmds in *\$LD\ *) wl= ;; esac if test yes = "$hardcode_into_libs"; then # Hardcode the library paths hardcode_libdirs= dep_rpath= rpath=$finalize_rpath test relink = "$opt_mode" || rpath=$compile_rpath$rpath for libdir in $rpath; do if test -n "$hardcode_libdir_flag_spec"; then if test -n "$hardcode_libdir_separator"; then func_replace_sysroot "$libdir" libdir=$func_replace_sysroot_result if test -z "$hardcode_libdirs"; then hardcode_libdirs=$libdir else # Just accumulate the unique libdirs. case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*) ;; *) func_append hardcode_libdirs "$hardcode_libdir_separator$libdir" ;; esac fi else eval flag=\"$hardcode_libdir_flag_spec\" func_append dep_rpath " $flag" fi elif test -n "$runpath_var"; then case "$perm_rpath " in *" $libdir "*) ;; *) func_append perm_rpath " $libdir" ;; esac fi done # Substitute the hardcoded libdirs into the rpath. if test -n "$hardcode_libdir_separator" && test -n "$hardcode_libdirs"; then libdir=$hardcode_libdirs eval "dep_rpath=\"$hardcode_libdir_flag_spec\"" fi if test -n "$runpath_var" && test -n "$perm_rpath"; then # We should set the runpath_var. rpath= for dir in $perm_rpath; do func_append rpath "$dir:" done eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var" fi test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs" fi shlibpath=$finalize_shlibpath test relink = "$opt_mode" || shlibpath=$compile_shlibpath$shlibpath if test -n "$shlibpath"; then eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var" fi # Get the real and link names of the library. eval shared_ext=\"$shrext_cmds\" eval library_names=\"$library_names_spec\" set dummy $library_names shift realname=$1 shift if test -n "$soname_spec"; then eval soname=\"$soname_spec\" else soname=$realname fi if test -z "$dlname"; then dlname=$soname fi lib=$output_objdir/$realname linknames= for link do func_append linknames " $link" done # Use standard objects if they are pic test -z "$pic_flag" && libobjs=`$ECHO "$libobjs" | $SP2NL | $SED "$lo2o" | $NL2SP` test "X$libobjs" = "X " && libobjs= delfiles= if test -n "$export_symbols" && test -n "$include_expsyms"; then $opt_dry_run || cp "$export_symbols" "$output_objdir/$libname.uexp" export_symbols=$output_objdir/$libname.uexp func_append delfiles " $export_symbols" fi orig_export_symbols= case $host_os in cygwin* | mingw* | cegcc*) if test -n "$export_symbols" && test -z "$export_symbols_regex"; then # exporting using user supplied symfile func_dll_def_p "$export_symbols" || { # and it's NOT already a .def file. Must figure out # which of the given symbols are data symbols and tag # them as such. So, trigger use of export_symbols_cmds. # export_symbols gets reassigned inside the "prepare # the list of exported symbols" if statement, so the # include_expsyms logic still works. orig_export_symbols=$export_symbols export_symbols= always_export_symbols=yes } fi ;; esac # Prepare the list of exported symbols if test -z "$export_symbols"; then if test yes = "$always_export_symbols" || test -n "$export_symbols_regex"; then func_verbose "generating symbol list for '$libname.la'" export_symbols=$output_objdir/$libname.exp $opt_dry_run || $RM $export_symbols cmds=$export_symbols_cmds save_ifs=$IFS; IFS='~' for cmd1 in $cmds; do IFS=$save_ifs # Take the normal branch if the nm_file_list_spec branch # doesn't work or if tool conversion is not needed. case $nm_file_list_spec~$to_tool_file_cmd in *~func_convert_file_noop | *~func_convert_file_msys_to_w32 | ~*) try_normal_branch=yes eval cmd=\"$cmd1\" func_len " $cmd" len=$func_len_result ;; *) try_normal_branch=no ;; esac if test yes = "$try_normal_branch" \ && { test "$len" -lt "$max_cmd_len" \ || test "$max_cmd_len" -le -1; } then func_show_eval "$cmd" 'exit $?' skipped_export=false elif test -n "$nm_file_list_spec"; then func_basename "$output" output_la=$func_basename_result save_libobjs=$libobjs save_output=$output output=$output_objdir/$output_la.nm func_to_tool_file "$output" libobjs=$nm_file_list_spec$func_to_tool_file_result func_append delfiles " $output" func_verbose "creating $NM input file list: $output" for obj in $save_libobjs; do func_to_tool_file "$obj" $ECHO "$func_to_tool_file_result" done > "$output" eval cmd=\"$cmd1\" func_show_eval "$cmd" 'exit $?' output=$save_output libobjs=$save_libobjs skipped_export=false else # The command line is too long to execute in one step. func_verbose "using reloadable object file for export list..." skipped_export=: # Break out early, otherwise skipped_export may be # set to false by a later but shorter cmd. break fi done IFS=$save_ifs if test -n "$export_symbols_regex" && test : != "$skipped_export"; then func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"' func_show_eval '$MV "${export_symbols}T" "$export_symbols"' fi fi fi if test -n "$export_symbols" && test -n "$include_expsyms"; then tmp_export_symbols=$export_symbols test -n "$orig_export_symbols" && tmp_export_symbols=$orig_export_symbols $opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"' fi if test : != "$skipped_export" && test -n "$orig_export_symbols"; then # The given exports_symbols file has to be filtered, so filter it. func_verbose "filter symbol list for '$libname.la' to tag DATA exports" # FIXME: $output_objdir/$libname.filter potentially contains lots of # 's' commands, which not all seds can handle. GNU sed should be fine # though. Also, the filter scales superlinearly with the number of # global variables. join(1) would be nice here, but unfortunately # isn't a blessed tool. $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter func_append delfiles " $export_symbols $output_objdir/$libname.filter" export_symbols=$output_objdir/$libname.def $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols fi tmp_deplibs= for test_deplib in $deplibs; do case " $convenience " in *" $test_deplib "*) ;; *) func_append tmp_deplibs " $test_deplib" ;; esac done deplibs=$tmp_deplibs if test -n "$convenience"; then if test -n "$whole_archive_flag_spec" && test yes = "$compiler_needs_object" && test -z "$libobjs"; then # extract the archives, so we have objects to list. # TODO: could optimize this to just extract one archive. whole_archive_flag_spec= fi if test -n "$whole_archive_flag_spec"; then save_libobjs=$libobjs eval libobjs=\"\$libobjs $whole_archive_flag_spec\" test "X$libobjs" = "X " && libobjs= else gentop=$output_objdir/${outputname}x func_append generated " $gentop" func_extract_archives $gentop $convenience func_append libobjs " $func_extract_archives_result" test "X$libobjs" = "X " && libobjs= fi fi if test yes = "$thread_safe" && test -n "$thread_safe_flag_spec"; then eval flag=\"$thread_safe_flag_spec\" func_append linker_flags " $flag" fi # Make a backup of the uninstalled library when relinking if test relink = "$opt_mode"; then $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U)' || exit $? fi # Do each of the archive commands. if test yes = "$module" && test -n "$module_cmds"; then if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then eval test_cmds=\"$module_expsym_cmds\" cmds=$module_expsym_cmds else eval test_cmds=\"$module_cmds\" cmds=$module_cmds fi else if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then eval test_cmds=\"$archive_expsym_cmds\" cmds=$archive_expsym_cmds else eval test_cmds=\"$archive_cmds\" cmds=$archive_cmds fi fi if test : != "$skipped_export" && func_len " $test_cmds" && len=$func_len_result && test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then : else # The command line is too long to link in one step, link piecewise # or, if using GNU ld and skipped_export is not :, use a linker # script. # Save the value of $output and $libobjs because we want to # use them later. If we have whole_archive_flag_spec, we # want to use save_libobjs as it was before # whole_archive_flag_spec was expanded, because we can't # assume the linker understands whole_archive_flag_spec. # This may have to be revisited, in case too many # convenience libraries get linked in and end up exceeding # the spec. if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then save_libobjs=$libobjs fi save_output=$output func_basename "$output" output_la=$func_basename_result # Clear the reloadable object creation command queue and # initialize k to one. test_cmds= concat_cmds= objlist= last_robj= k=1 if test -n "$save_libobjs" && test : != "$skipped_export" && test yes = "$with_gnu_ld"; then output=$output_objdir/$output_la.lnkscript func_verbose "creating GNU ld script: $output" echo 'INPUT (' > $output for obj in $save_libobjs do func_to_tool_file "$obj" $ECHO "$func_to_tool_file_result" >> $output done echo ')' >> $output func_append delfiles " $output" func_to_tool_file "$output" output=$func_to_tool_file_result elif test -n "$save_libobjs" && test : != "$skipped_export" && test -n "$file_list_spec"; then output=$output_objdir/$output_la.lnk func_verbose "creating linker input file list: $output" : > $output set x $save_libobjs shift firstobj= if test yes = "$compiler_needs_object"; then firstobj="$1 " shift fi for obj do func_to_tool_file "$obj" $ECHO "$func_to_tool_file_result" >> $output done func_append delfiles " $output" func_to_tool_file "$output" output=$firstobj\"$file_list_spec$func_to_tool_file_result\" else if test -n "$save_libobjs"; then func_verbose "creating reloadable object files..." output=$output_objdir/$output_la-$k.$objext eval test_cmds=\"$reload_cmds\" func_len " $test_cmds" len0=$func_len_result len=$len0 # Loop over the list of objects to be linked. for obj in $save_libobjs do func_len " $obj" func_arith $len + $func_len_result len=$func_arith_result if test -z "$objlist" || test "$len" -lt "$max_cmd_len"; then func_append objlist " $obj" else # The command $test_cmds is almost too long, add a # command to the queue. if test 1 -eq "$k"; then # The first file doesn't have a previous command to add. reload_objs=$objlist eval concat_cmds=\"$reload_cmds\" else # All subsequent reloadable object files will link in # the last one created. reload_objs="$objlist $last_robj" eval concat_cmds=\"\$concat_cmds~$reload_cmds~\$RM $last_robj\" fi last_robj=$output_objdir/$output_la-$k.$objext func_arith $k + 1 k=$func_arith_result output=$output_objdir/$output_la-$k.$objext objlist=" $obj" func_len " $last_robj" func_arith $len0 + $func_len_result len=$func_arith_result fi done # Handle the remaining objects by creating one last # reloadable object file. All subsequent reloadable object # files will link in the last one created. test -z "$concat_cmds" || concat_cmds=$concat_cmds~ reload_objs="$objlist $last_robj" eval concat_cmds=\"\$concat_cmds$reload_cmds\" if test -n "$last_robj"; then eval concat_cmds=\"\$concat_cmds~\$RM $last_robj\" fi func_append delfiles " $output" else output= fi ${skipped_export-false} && { func_verbose "generating symbol list for '$libname.la'" export_symbols=$output_objdir/$libname.exp $opt_dry_run || $RM $export_symbols libobjs=$output # Append the command to create the export file. test -z "$concat_cmds" || concat_cmds=$concat_cmds~ eval concat_cmds=\"\$concat_cmds$export_symbols_cmds\" if test -n "$last_robj"; then eval concat_cmds=\"\$concat_cmds~\$RM $last_robj\" fi } test -n "$save_libobjs" && func_verbose "creating a temporary reloadable object file: $output" # Loop through the commands generated above and execute them. save_ifs=$IFS; IFS='~' for cmd in $concat_cmds; do IFS=$save_ifs $opt_quiet || { func_quote_for_expand "$cmd" eval "func_echo $func_quote_for_expand_result" } $opt_dry_run || eval "$cmd" || { lt_exit=$? # Restore the uninstalled library and exit if test relink = "$opt_mode"; then ( cd "$output_objdir" && \ $RM "${realname}T" && \ $MV "${realname}U" "$realname" ) fi exit $lt_exit } done IFS=$save_ifs if test -n "$export_symbols_regex" && ${skipped_export-false}; then func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"' func_show_eval '$MV "${export_symbols}T" "$export_symbols"' fi fi ${skipped_export-false} && { if test -n "$export_symbols" && test -n "$include_expsyms"; then tmp_export_symbols=$export_symbols test -n "$orig_export_symbols" && tmp_export_symbols=$orig_export_symbols $opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"' fi if test -n "$orig_export_symbols"; then # The given exports_symbols file has to be filtered, so filter it. func_verbose "filter symbol list for '$libname.la' to tag DATA exports" # FIXME: $output_objdir/$libname.filter potentially contains lots of # 's' commands, which not all seds can handle. GNU sed should be fine # though. Also, the filter scales superlinearly with the number of # global variables. join(1) would be nice here, but unfortunately # isn't a blessed tool. $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter func_append delfiles " $export_symbols $output_objdir/$libname.filter" export_symbols=$output_objdir/$libname.def $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols fi } libobjs=$output # Restore the value of output. output=$save_output if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then eval libobjs=\"\$libobjs $whole_archive_flag_spec\" test "X$libobjs" = "X " && libobjs= fi # Expand the library linking commands again to reset the # value of $libobjs for piecewise linking. # Do each of the archive commands. if test yes = "$module" && test -n "$module_cmds"; then if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then cmds=$module_expsym_cmds else cmds=$module_cmds fi else if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then cmds=$archive_expsym_cmds else cmds=$archive_cmds fi fi fi if test -n "$delfiles"; then # Append the command to remove temporary files to $cmds. eval cmds=\"\$cmds~\$RM $delfiles\" fi # Add any objects from preloaded convenience libraries if test -n "$dlprefiles"; then gentop=$output_objdir/${outputname}x func_append generated " $gentop" func_extract_archives $gentop $dlprefiles func_append libobjs " $func_extract_archives_result" test "X$libobjs" = "X " && libobjs= fi save_ifs=$IFS; IFS='~' for cmd in $cmds; do IFS=$sp$nl eval cmd=\"$cmd\" IFS=$save_ifs $opt_quiet || { func_quote_for_expand "$cmd" eval "func_echo $func_quote_for_expand_result" } $opt_dry_run || eval "$cmd" || { lt_exit=$? # Restore the uninstalled library and exit if test relink = "$opt_mode"; then ( cd "$output_objdir" && \ $RM "${realname}T" && \ $MV "${realname}U" "$realname" ) fi exit $lt_exit } done IFS=$save_ifs # Restore the uninstalled library and exit if test relink = "$opt_mode"; then $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}T && $MV $realname ${realname}T && $MV ${realname}U $realname)' || exit $? if test -n "$convenience"; then if test -z "$whole_archive_flag_spec"; then func_show_eval '${RM}r "$gentop"' fi fi exit $EXIT_SUCCESS fi # Create links to the real library. for linkname in $linknames; do if test "$realname" != "$linkname"; then func_show_eval '(cd "$output_objdir" && $RM "$linkname" && $LN_S "$realname" "$linkname")' 'exit $?' fi done # If -module or -export-dynamic was specified, set the dlname. if test yes = "$module" || test yes = "$export_dynamic"; then # On all known operating systems, these are identical. dlname=$soname fi fi ;; obj) if test -n "$dlfiles$dlprefiles" || test no != "$dlself"; then func_warning "'-dlopen' is ignored for objects" fi case " $deplibs" in *\ -l* | *\ -L*) func_warning "'-l' and '-L' are ignored for objects" ;; esac test -n "$rpath" && \ func_warning "'-rpath' is ignored for objects" test -n "$xrpath" && \ func_warning "'-R' is ignored for objects" test -n "$vinfo" && \ func_warning "'-version-info' is ignored for objects" test -n "$release" && \ func_warning "'-release' is ignored for objects" case $output in *.lo) test -n "$objs$old_deplibs" && \ func_fatal_error "cannot build library object '$output' from non-libtool objects" libobj=$output func_lo2o "$libobj" obj=$func_lo2o_result ;; *) libobj= obj=$output ;; esac # Delete the old objects. $opt_dry_run || $RM $obj $libobj # Objects from convenience libraries. This assumes # single-version convenience libraries. Whenever we create # different ones for PIC/non-PIC, this we'll have to duplicate # the extraction. reload_conv_objs= gentop= # if reload_cmds runs $LD directly, get rid of -Wl from # whole_archive_flag_spec and hope we can get by with turning comma # into space. case $reload_cmds in *\$LD[\ \$]*) wl= ;; esac if test -n "$convenience"; then if test -n "$whole_archive_flag_spec"; then eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\" test -n "$wl" || tmp_whole_archive_flags=`$ECHO "$tmp_whole_archive_flags" | $SED 's|,| |g'` reload_conv_objs=$reload_objs\ $tmp_whole_archive_flags else gentop=$output_objdir/${obj}x func_append generated " $gentop" func_extract_archives $gentop $convenience reload_conv_objs="$reload_objs $func_extract_archives_result" fi fi # If we're not building shared, we need to use non_pic_objs test yes = "$build_libtool_libs" || libobjs=$non_pic_objects # Create the old-style object. reload_objs=$objs$old_deplibs' '`$ECHO "$libobjs" | $SP2NL | $SED "/\.$libext$/d; /\.lib$/d; $lo2o" | $NL2SP`' '$reload_conv_objs output=$obj func_execute_cmds "$reload_cmds" 'exit $?' # Exit if we aren't doing a library object file. if test -z "$libobj"; then if test -n "$gentop"; then func_show_eval '${RM}r "$gentop"' fi exit $EXIT_SUCCESS fi test yes = "$build_libtool_libs" || { if test -n "$gentop"; then func_show_eval '${RM}r "$gentop"' fi # Create an invalid libtool object if no PIC, so that we don't # accidentally link it into a program. # $show "echo timestamp > $libobj" # $opt_dry_run || eval "echo timestamp > $libobj" || exit $? exit $EXIT_SUCCESS } if test -n "$pic_flag" || test default != "$pic_mode"; then # Only do commands if we really have different PIC objects. reload_objs="$libobjs $reload_conv_objs" output=$libobj func_execute_cmds "$reload_cmds" 'exit $?' fi if test -n "$gentop"; then func_show_eval '${RM}r "$gentop"' fi exit $EXIT_SUCCESS ;; prog) case $host in *cygwin*) func_stripname '' '.exe' "$output" output=$func_stripname_result.exe;; esac test -n "$vinfo" && \ func_warning "'-version-info' is ignored for programs" test -n "$release" && \ func_warning "'-release' is ignored for programs" $preload \ && test unknown,unknown,unknown = "$dlopen_support,$dlopen_self,$dlopen_self_static" \ && func_warning "'LT_INIT([dlopen])' not used. Assuming no dlopen support." case $host in *-*-rhapsody* | *-*-darwin1.[012]) # On Rhapsody replace the C library is the System framework compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's/ -lc / System.ltframework /'` finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's/ -lc / System.ltframework /'` ;; esac case $host in *-*-darwin*) # Don't allow lazy linking, it breaks C++ global constructors # But is supposedly fixed on 10.4 or later (yay!). if test CXX = "$tagname"; then case ${MACOSX_DEPLOYMENT_TARGET-10.0} in 10.[0123]) func_append compile_command " $wl-bind_at_load" func_append finalize_command " $wl-bind_at_load" ;; esac fi # Time to change all our "foo.ltframework" stuff back to "-framework foo" compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'` finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'` ;; esac # move library search paths that coincide with paths to not yet # installed libraries to the beginning of the library search list new_libs= for path in $notinst_path; do case " $new_libs " in *" -L$path/$objdir "*) ;; *) case " $compile_deplibs " in *" -L$path/$objdir "*) func_append new_libs " -L$path/$objdir" ;; esac ;; esac done for deplib in $compile_deplibs; do case $deplib in -L*) case " $new_libs " in *" $deplib "*) ;; *) func_append new_libs " $deplib" ;; esac ;; *) func_append new_libs " $deplib" ;; esac done compile_deplibs=$new_libs func_append compile_command " $compile_deplibs" func_append finalize_command " $finalize_deplibs" if test -n "$rpath$xrpath"; then # If the user specified any rpath flags, then add them. for libdir in $rpath $xrpath; do # This is the magic to use -rpath. case "$finalize_rpath " in *" $libdir "*) ;; *) func_append finalize_rpath " $libdir" ;; esac done fi # Now hardcode the library paths rpath= hardcode_libdirs= for libdir in $compile_rpath $finalize_rpath; do if test -n "$hardcode_libdir_flag_spec"; then if test -n "$hardcode_libdir_separator"; then if test -z "$hardcode_libdirs"; then hardcode_libdirs=$libdir else # Just accumulate the unique libdirs. case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*) ;; *) func_append hardcode_libdirs "$hardcode_libdir_separator$libdir" ;; esac fi else eval flag=\"$hardcode_libdir_flag_spec\" func_append rpath " $flag" fi elif test -n "$runpath_var"; then case "$perm_rpath " in *" $libdir "*) ;; *) func_append perm_rpath " $libdir" ;; esac fi case $host in *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*) testbindir=`$ECHO "$libdir" | $SED -e 's*/lib$*/bin*'` case :$dllsearchpath: in *":$libdir:"*) ;; ::) dllsearchpath=$libdir;; *) func_append dllsearchpath ":$libdir";; esac case :$dllsearchpath: in *":$testbindir:"*) ;; ::) dllsearchpath=$testbindir;; *) func_append dllsearchpath ":$testbindir";; esac ;; esac done # Substitute the hardcoded libdirs into the rpath. if test -n "$hardcode_libdir_separator" && test -n "$hardcode_libdirs"; then libdir=$hardcode_libdirs eval rpath=\" $hardcode_libdir_flag_spec\" fi compile_rpath=$rpath rpath= hardcode_libdirs= for libdir in $finalize_rpath; do if test -n "$hardcode_libdir_flag_spec"; then if test -n "$hardcode_libdir_separator"; then if test -z "$hardcode_libdirs"; then hardcode_libdirs=$libdir else # Just accumulate the unique libdirs. case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*) ;; *) func_append hardcode_libdirs "$hardcode_libdir_separator$libdir" ;; esac fi else eval flag=\"$hardcode_libdir_flag_spec\" func_append rpath " $flag" fi elif test -n "$runpath_var"; then case "$finalize_perm_rpath " in *" $libdir "*) ;; *) func_append finalize_perm_rpath " $libdir" ;; esac fi done # Substitute the hardcoded libdirs into the rpath. if test -n "$hardcode_libdir_separator" && test -n "$hardcode_libdirs"; then libdir=$hardcode_libdirs eval rpath=\" $hardcode_libdir_flag_spec\" fi finalize_rpath=$rpath if test -n "$libobjs" && test yes = "$build_old_libs"; then # Transform all the library objects into standard objects. compile_command=`$ECHO "$compile_command" | $SP2NL | $SED "$lo2o" | $NL2SP` finalize_command=`$ECHO "$finalize_command" | $SP2NL | $SED "$lo2o" | $NL2SP` fi func_generate_dlsyms "$outputname" "@PROGRAM@" false # template prelinking step if test -n "$prelink_cmds"; then func_execute_cmds "$prelink_cmds" 'exit $?' fi wrappers_required=: case $host in *cegcc* | *mingw32ce*) # Disable wrappers for cegcc and mingw32ce hosts, we are cross compiling anyway. wrappers_required=false ;; *cygwin* | *mingw* ) test yes = "$build_libtool_libs" || wrappers_required=false ;; *) if test no = "$need_relink" || test yes != "$build_libtool_libs"; then wrappers_required=false fi ;; esac $wrappers_required || { # Replace the output file specification. compile_command=`$ECHO "$compile_command" | $SED 's%@OUTPUT@%'"$output"'%g'` link_command=$compile_command$compile_rpath # We have no uninstalled library dependencies, so finalize right now. exit_status=0 func_show_eval "$link_command" 'exit_status=$?' if test -n "$postlink_cmds"; then func_to_tool_file "$output" postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'` func_execute_cmds "$postlink_cmds" 'exit $?' fi # Delete the generated files. if test -f "$output_objdir/${outputname}S.$objext"; then func_show_eval '$RM "$output_objdir/${outputname}S.$objext"' fi exit $exit_status } if test -n "$compile_shlibpath$finalize_shlibpath"; then compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command" fi if test -n "$finalize_shlibpath"; then finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command" fi compile_var= finalize_var= if test -n "$runpath_var"; then if test -n "$perm_rpath"; then # We should set the runpath_var. rpath= for dir in $perm_rpath; do func_append rpath "$dir:" done compile_var="$runpath_var=\"$rpath\$$runpath_var\" " fi if test -n "$finalize_perm_rpath"; then # We should set the runpath_var. rpath= for dir in $finalize_perm_rpath; do func_append rpath "$dir:" done finalize_var="$runpath_var=\"$rpath\$$runpath_var\" " fi fi if test yes = "$no_install"; then # We don't need to create a wrapper script. link_command=$compile_var$compile_command$compile_rpath # Replace the output file specification. link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output"'%g'` # Delete the old output file. $opt_dry_run || $RM $output # Link the executable and exit func_show_eval "$link_command" 'exit $?' if test -n "$postlink_cmds"; then func_to_tool_file "$output" postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'` func_execute_cmds "$postlink_cmds" 'exit $?' fi exit $EXIT_SUCCESS fi case $hardcode_action,$fast_install in relink,*) # Fast installation is not supported link_command=$compile_var$compile_command$compile_rpath relink_command=$finalize_var$finalize_command$finalize_rpath func_warning "this platform does not like uninstalled shared libraries" func_warning "'$output' will be relinked during installation" ;; *,yes) link_command=$finalize_var$compile_command$finalize_rpath relink_command=`$ECHO "$compile_var$compile_command$compile_rpath" | $SED 's%@OUTPUT@%\$progdir/\$file%g'` ;; *,no) link_command=$compile_var$compile_command$compile_rpath relink_command=$finalize_var$finalize_command$finalize_rpath ;; *,needless) link_command=$finalize_var$compile_command$finalize_rpath relink_command= ;; esac # Replace the output file specification. link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'` # Delete the old output files. $opt_dry_run || $RM $output $output_objdir/$outputname $output_objdir/lt-$outputname func_show_eval "$link_command" 'exit $?' if test -n "$postlink_cmds"; then func_to_tool_file "$output_objdir/$outputname" postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'` func_execute_cmds "$postlink_cmds" 'exit $?' fi # Now create the wrapper script. func_verbose "creating $output" # Quote the relink command for shipping. if test -n "$relink_command"; then # Preserve any variables that may affect compiler behavior for var in $variables_saved_for_relink; do if eval test -z \"\${$var+set}\"; then relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command" elif eval var_value=\$$var; test -z "$var_value"; then relink_command="$var=; export $var; $relink_command" else func_quote_for_eval "$var_value" relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command" fi done relink_command="(cd `pwd`; $relink_command)" relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"` fi # Only actually do things if not in dry run mode. $opt_dry_run || { # win32 will think the script is a binary if it has # a .exe suffix, so we strip it off here. case $output in *.exe) func_stripname '' '.exe' "$output" output=$func_stripname_result ;; esac # test for cygwin because mv fails w/o .exe extensions case $host in *cygwin*) exeext=.exe func_stripname '' '.exe' "$outputname" outputname=$func_stripname_result ;; *) exeext= ;; esac case $host in *cygwin* | *mingw* ) func_dirname_and_basename "$output" "" "." output_name=$func_basename_result output_path=$func_dirname_result cwrappersource=$output_path/$objdir/lt-$output_name.c cwrapper=$output_path/$output_name.exe $RM $cwrappersource $cwrapper trap "$RM $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15 func_emit_cwrapperexe_src > $cwrappersource # The wrapper executable is built using the $host compiler, # because it contains $host paths and files. If cross- # compiling, it, like the target executable, must be # executed on the $host or under an emulation environment. $opt_dry_run || { $LTCC $LTCFLAGS -o $cwrapper $cwrappersource $STRIP $cwrapper } # Now, create the wrapper script for func_source use: func_ltwrapper_scriptname $cwrapper $RM $func_ltwrapper_scriptname_result trap "$RM $func_ltwrapper_scriptname_result; exit $EXIT_FAILURE" 1 2 15 $opt_dry_run || { # note: this script will not be executed, so do not chmod. if test "x$build" = "x$host"; then $cwrapper --lt-dump-script > $func_ltwrapper_scriptname_result else func_emit_wrapper no > $func_ltwrapper_scriptname_result fi } ;; * ) $RM $output trap "$RM $output; exit $EXIT_FAILURE" 1 2 15 func_emit_wrapper no > $output chmod +x $output ;; esac } exit $EXIT_SUCCESS ;; esac # See if we need to build an old-fashioned archive. for oldlib in $oldlibs; do case $build_libtool_libs in convenience) oldobjs="$libobjs_save $symfileobj" addlibs=$convenience build_libtool_libs=no ;; module) oldobjs=$libobjs_save addlibs=$old_convenience build_libtool_libs=no ;; *) oldobjs="$old_deplibs $non_pic_objects" $preload && test -f "$symfileobj" \ && func_append oldobjs " $symfileobj" addlibs=$old_convenience ;; esac if test -n "$addlibs"; then gentop=$output_objdir/${outputname}x func_append generated " $gentop" func_extract_archives $gentop $addlibs func_append oldobjs " $func_extract_archives_result" fi # Do each command in the archive commands. if test -n "$old_archive_from_new_cmds" && test yes = "$build_libtool_libs"; then cmds=$old_archive_from_new_cmds else # Add any objects from preloaded convenience libraries if test -n "$dlprefiles"; then gentop=$output_objdir/${outputname}x func_append generated " $gentop" func_extract_archives $gentop $dlprefiles func_append oldobjs " $func_extract_archives_result" fi # POSIX demands no paths to be encoded in archives. We have # to avoid creating archives with duplicate basenames if we # might have to extract them afterwards, e.g., when creating a # static archive out of a convenience library, or when linking # the entirety of a libtool archive into another (currently # not supported by libtool). if (for obj in $oldobjs do func_basename "$obj" $ECHO "$func_basename_result" done | sort | sort -uc >/dev/null 2>&1); then : else echo "copying selected object files to avoid basename conflicts..." gentop=$output_objdir/${outputname}x func_append generated " $gentop" func_mkdir_p "$gentop" save_oldobjs=$oldobjs oldobjs= counter=1 for obj in $save_oldobjs do func_basename "$obj" objbase=$func_basename_result case " $oldobjs " in " ") oldobjs=$obj ;; *[\ /]"$objbase "*) while :; do # Make sure we don't pick an alternate name that also # overlaps. newobj=lt$counter-$objbase func_arith $counter + 1 counter=$func_arith_result case " $oldobjs " in *[\ /]"$newobj "*) ;; *) if test ! -f "$gentop/$newobj"; then break; fi ;; esac done func_show_eval "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj" func_append oldobjs " $gentop/$newobj" ;; *) func_append oldobjs " $obj" ;; esac done fi func_to_tool_file "$oldlib" func_convert_file_msys_to_w32 tool_oldlib=$func_to_tool_file_result eval cmds=\"$old_archive_cmds\" func_len " $cmds" len=$func_len_result if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then cmds=$old_archive_cmds elif test -n "$archiver_list_spec"; then func_verbose "using command file archive linking..." for obj in $oldobjs do func_to_tool_file "$obj" $ECHO "$func_to_tool_file_result" done > $output_objdir/$libname.libcmd func_to_tool_file "$output_objdir/$libname.libcmd" oldobjs=" $archiver_list_spec$func_to_tool_file_result" cmds=$old_archive_cmds else # the command line is too long to link in one step, link in parts func_verbose "using piecewise archive linking..." save_RANLIB=$RANLIB RANLIB=: objlist= concat_cmds= save_oldobjs=$oldobjs oldobjs= # Is there a better way of finding the last object in the list? for obj in $save_oldobjs do last_oldobj=$obj done eval test_cmds=\"$old_archive_cmds\" func_len " $test_cmds" len0=$func_len_result len=$len0 for obj in $save_oldobjs do func_len " $obj" func_arith $len + $func_len_result len=$func_arith_result func_append objlist " $obj" if test "$len" -lt "$max_cmd_len"; then : else # the above command should be used before it gets too long oldobjs=$objlist if test "$obj" = "$last_oldobj"; then RANLIB=$save_RANLIB fi test -z "$concat_cmds" || concat_cmds=$concat_cmds~ eval concat_cmds=\"\$concat_cmds$old_archive_cmds\" objlist= len=$len0 fi done RANLIB=$save_RANLIB oldobjs=$objlist if test -z "$oldobjs"; then eval cmds=\"\$concat_cmds\" else eval cmds=\"\$concat_cmds~\$old_archive_cmds\" fi fi fi func_execute_cmds "$cmds" 'exit $?' done test -n "$generated" && \ func_show_eval "${RM}r$generated" # Now create the libtool archive. case $output in *.la) old_library= test yes = "$build_old_libs" && old_library=$libname.$libext func_verbose "creating $output" # Preserve any variables that may affect compiler behavior for var in $variables_saved_for_relink; do if eval test -z \"\${$var+set}\"; then relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command" elif eval var_value=\$$var; test -z "$var_value"; then relink_command="$var=; export $var; $relink_command" else func_quote_for_eval "$var_value" relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command" fi done # Quote the link command for shipping. relink_command="(cd `pwd`; $SHELL \"$progpath\" $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)" relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"` if test yes = "$hardcode_automatic"; then relink_command= fi # Only create the output if not a dry run. $opt_dry_run || { for installed in no yes; do if test yes = "$installed"; then if test -z "$install_libdir"; then break fi output=$output_objdir/${outputname}i # Replace all uninstalled libtool libraries with the installed ones newdependency_libs= for deplib in $dependency_libs; do case $deplib in *.la) func_basename "$deplib" name=$func_basename_result func_resolve_sysroot "$deplib" eval libdir=`$SED -n -e 's/^libdir=\(.*\)$/\1/p' $func_resolve_sysroot_result` test -z "$libdir" && \ func_fatal_error "'$deplib' is not a valid libtool archive" func_append newdependency_libs " ${lt_sysroot:+=}$libdir/$name" ;; -L*) func_stripname -L '' "$deplib" func_replace_sysroot "$func_stripname_result" func_append newdependency_libs " -L$func_replace_sysroot_result" ;; -R*) func_stripname -R '' "$deplib" func_replace_sysroot "$func_stripname_result" func_append newdependency_libs " -R$func_replace_sysroot_result" ;; *) func_append newdependency_libs " $deplib" ;; esac done dependency_libs=$newdependency_libs newdlfiles= for lib in $dlfiles; do case $lib in *.la) func_basename "$lib" name=$func_basename_result eval libdir=`$SED -n -e 's/^libdir=\(.*\)$/\1/p' $lib` test -z "$libdir" && \ func_fatal_error "'$lib' is not a valid libtool archive" func_append newdlfiles " ${lt_sysroot:+=}$libdir/$name" ;; *) func_append newdlfiles " $lib" ;; esac done dlfiles=$newdlfiles newdlprefiles= for lib in $dlprefiles; do case $lib in *.la) # Only pass preopened files to the pseudo-archive (for # eventual linking with the app. that links it) if we # didn't already link the preopened objects directly into # the library: func_basename "$lib" name=$func_basename_result eval libdir=`$SED -n -e 's/^libdir=\(.*\)$/\1/p' $lib` test -z "$libdir" && \ func_fatal_error "'$lib' is not a valid libtool archive" func_append newdlprefiles " ${lt_sysroot:+=}$libdir/$name" ;; esac done dlprefiles=$newdlprefiles else newdlfiles= for lib in $dlfiles; do case $lib in [\\/]* | [A-Za-z]:[\\/]*) abs=$lib ;; *) abs=`pwd`"/$lib" ;; esac func_append newdlfiles " $abs" done dlfiles=$newdlfiles newdlprefiles= for lib in $dlprefiles; do case $lib in [\\/]* | [A-Za-z]:[\\/]*) abs=$lib ;; *) abs=`pwd`"/$lib" ;; esac func_append newdlprefiles " $abs" done dlprefiles=$newdlprefiles fi $RM $output # place dlname in correct position for cygwin # In fact, it would be nice if we could use this code for all target # systems that can't hard-code library paths into their executables # and that have no shared library path variable independent of PATH, # but it turns out we can't easily determine that from inspecting # libtool variables, so we have to hard-code the OSs to which it # applies here; at the moment, that means platforms that use the PE # object format with DLL files. See the long comment at the top of # tests/bindir.at for full details. tdlname=$dlname case $host,$output,$installed,$module,$dlname in *cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll | *cegcc*,*lai,yes,no,*.dll) # If a -bindir argument was supplied, place the dll there. if test -n "$bindir"; then func_relative_path "$install_libdir" "$bindir" tdlname=$func_relative_path_result/$dlname else # Otherwise fall back on heuristic. tdlname=../bin/$dlname fi ;; esac $ECHO > $output "\ # $outputname - a libtool library file # Generated by $PROGRAM (GNU $PACKAGE) $VERSION # # Please DO NOT delete this file! # It is necessary for linking the library. # The name that we can dlopen(3). dlname='$tdlname' # Names of this library. library_names='$library_names' # The name of the static archive. old_library='$old_library' # Linker flags that cannot go in dependency_libs. inherited_linker_flags='$new_inherited_linker_flags' # Libraries that this one depends upon. dependency_libs='$dependency_libs' # Names of additional weak libraries provided by this library weak_library_names='$weak_libs' # Version information for $libname. current=$current age=$age revision=$revision # Is this an already installed library? installed=$installed # Should we warn about portability when linking against -modules? shouldnotlink=$module # Files to dlopen/dlpreopen dlopen='$dlfiles' dlpreopen='$dlprefiles' # Directory that this library needs to be installed in: libdir='$install_libdir'" if test no,yes = "$installed,$need_relink"; then $ECHO >> $output "\ relink_command=\"$relink_command\"" fi done } # Do a symbolic link so that the libtool archive can be found in # LD_LIBRARY_PATH before the program is installed. func_show_eval '( cd "$output_objdir" && $RM "$outputname" && $LN_S "../$outputname" "$outputname" )' 'exit $?' ;; esac exit $EXIT_SUCCESS } if test link = "$opt_mode" || test relink = "$opt_mode"; then func_mode_link ${1+"$@"} fi # func_mode_uninstall arg... func_mode_uninstall () { $debug_cmd RM=$nonopt files= rmforce=false exit_status=0 # This variable tells wrapper scripts just to set variables rather # than running their programs. libtool_install_magic=$magic for arg do case $arg in -f) func_append RM " $arg"; rmforce=: ;; -*) func_append RM " $arg" ;; *) func_append files " $arg" ;; esac done test -z "$RM" && \ func_fatal_help "you must specify an RM program" rmdirs= for file in $files; do func_dirname "$file" "" "." dir=$func_dirname_result if test . = "$dir"; then odir=$objdir else odir=$dir/$objdir fi func_basename "$file" name=$func_basename_result test uninstall = "$opt_mode" && odir=$dir # Remember odir for removal later, being careful to avoid duplicates if test clean = "$opt_mode"; then case " $rmdirs " in *" $odir "*) ;; *) func_append rmdirs " $odir" ;; esac fi # Don't error if the file doesn't exist and rm -f was used. if { test -L "$file"; } >/dev/null 2>&1 || { test -h "$file"; } >/dev/null 2>&1 || test -f "$file"; then : elif test -d "$file"; then exit_status=1 continue elif $rmforce; then continue fi rmfiles=$file case $name in *.la) # Possibly a libtool archive, so verify it. if func_lalib_p "$file"; then func_source $dir/$name # Delete the libtool libraries and symlinks. for n in $library_names; do func_append rmfiles " $odir/$n" done test -n "$old_library" && func_append rmfiles " $odir/$old_library" case $opt_mode in clean) case " $library_names " in *" $dlname "*) ;; *) test -n "$dlname" && func_append rmfiles " $odir/$dlname" ;; esac test -n "$libdir" && func_append rmfiles " $odir/$name $odir/${name}i" ;; uninstall) if test -n "$library_names"; then # Do each command in the postuninstall commands. func_execute_cmds "$postuninstall_cmds" '$rmforce || exit_status=1' fi if test -n "$old_library"; then # Do each command in the old_postuninstall commands. func_execute_cmds "$old_postuninstall_cmds" '$rmforce || exit_status=1' fi # FIXME: should reinstall the best remaining shared library. ;; esac fi ;; *.lo) # Possibly a libtool object, so verify it. if func_lalib_p "$file"; then # Read the .lo file func_source $dir/$name # Add PIC object to the list of files to remove. if test -n "$pic_object" && test none != "$pic_object"; then func_append rmfiles " $dir/$pic_object" fi # Add non-PIC object to the list of files to remove. if test -n "$non_pic_object" && test none != "$non_pic_object"; then func_append rmfiles " $dir/$non_pic_object" fi fi ;; *) if test clean = "$opt_mode"; then noexename=$name case $file in *.exe) func_stripname '' '.exe' "$file" file=$func_stripname_result func_stripname '' '.exe' "$name" noexename=$func_stripname_result # $file with .exe has already been added to rmfiles, # add $file without .exe func_append rmfiles " $file" ;; esac # Do a test to see if this is a libtool program. if func_ltwrapper_p "$file"; then if func_ltwrapper_executable_p "$file"; then func_ltwrapper_scriptname "$file" relink_command= func_source $func_ltwrapper_scriptname_result func_append rmfiles " $func_ltwrapper_scriptname_result" else relink_command= func_source $dir/$noexename fi # note $name still contains .exe if it was in $file originally # as does the version of $file that was added into $rmfiles func_append rmfiles " $odir/$name $odir/${name}S.$objext" if test yes = "$fast_install" && test -n "$relink_command"; then func_append rmfiles " $odir/lt-$name" fi if test "X$noexename" != "X$name"; then func_append rmfiles " $odir/lt-$noexename.c" fi fi fi ;; esac func_show_eval "$RM $rmfiles" 'exit_status=1' done # Try to remove the $objdir's in the directories where we deleted files for dir in $rmdirs; do if test -d "$dir"; then func_show_eval "rmdir $dir >/dev/null 2>&1" fi done exit $exit_status } if test uninstall = "$opt_mode" || test clean = "$opt_mode"; then func_mode_uninstall ${1+"$@"} fi test -z "$opt_mode" && { help=$generic_help func_fatal_help "you must specify a MODE" } test -z "$exec_cmd" && \ func_fatal_help "invalid operation mode '$opt_mode'" if test -n "$exec_cmd"; then eval exec "$exec_cmd" exit $EXIT_FAILURE fi exit $exit_status # The TAGs below are defined such that we never get into a situation # where we disable both kinds of libraries. Given conflicting # choices, we go for a static library, that is the most portable, # since we can't tell whether shared libraries were disabled because # the user asked for that or because the platform doesn't support # them. This is particularly important on AIX, because we don't # support having both static and shared libraries enabled at the same # time on that platform, so we default to a shared-only configuration. # If a disable-shared tag is given, we'll fallback to a static-only # configuration. But we'll never go from static-only to shared-only. # ### BEGIN LIBTOOL TAG CONFIG: disable-shared build_libtool_libs=no build_old_libs=yes # ### END LIBTOOL TAG CONFIG: disable-shared # ### BEGIN LIBTOOL TAG CONFIG: disable-static build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac` # ### END LIBTOOL TAG CONFIG: disable-static # Local Variables: # mode:shell-script # sh-indentation:2 # End: ecl-16.1.2/src/bdwgc/m4/000077500000000000000000000000001266352375300145555ustar00rootroot00000000000000ecl-16.1.2/src/bdwgc/m4/libtool.m4000066400000000000000000011250731266352375300164740ustar00rootroot00000000000000# libtool.m4 - Configure libtool for the host system. -*-Autoconf-*- # # Copyright (C) 1996-2001, 2003-2015 Free Software Foundation, Inc. # Written by Gordon Matzigkeit, 1996 # # 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. m4_define([_LT_COPYING], [dnl # Copyright (C) 2014 Free Software Foundation, Inc. # This is free software; see the source for copying conditions. There is NO # warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. # 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 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 this program. If not, see . ]) # serial 58 LT_INIT # LT_PREREQ(VERSION) # ------------------ # Complain and exit if this libtool version is less that VERSION. m4_defun([LT_PREREQ], [m4_if(m4_version_compare(m4_defn([LT_PACKAGE_VERSION]), [$1]), -1, [m4_default([$3], [m4_fatal([Libtool version $1 or higher is required], 63)])], [$2])]) # _LT_CHECK_BUILDDIR # ------------------ # Complain if the absolute build directory name contains unusual characters m4_defun([_LT_CHECK_BUILDDIR], [case `pwd` in *\ * | *\ *) AC_MSG_WARN([Libtool does not cope well with whitespace in `pwd`]) ;; esac ]) # LT_INIT([OPTIONS]) # ------------------ AC_DEFUN([LT_INIT], [AC_PREREQ([2.62])dnl We use AC_PATH_PROGS_FEATURE_CHECK AC_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT])dnl AC_BEFORE([$0], [LT_LANG])dnl AC_BEFORE([$0], [LT_OUTPUT])dnl AC_BEFORE([$0], [LTDL_INIT])dnl m4_require([_LT_CHECK_BUILDDIR])dnl dnl Autoconf doesn't catch unexpanded LT_ macros by default: m4_pattern_forbid([^_?LT_[A-Z_]+$])dnl m4_pattern_allow([^(_LT_EOF|LT_DLGLOBAL|LT_DLLAZY_OR_NOW|LT_MULTI_MODULE)$])dnl dnl aclocal doesn't pull ltoptions.m4, ltsugar.m4, or ltversion.m4 dnl unless we require an AC_DEFUNed macro: AC_REQUIRE([LTOPTIONS_VERSION])dnl AC_REQUIRE([LTSUGAR_VERSION])dnl AC_REQUIRE([LTVERSION_VERSION])dnl AC_REQUIRE([LTOBSOLETE_VERSION])dnl m4_require([_LT_PROG_LTMAIN])dnl _LT_SHELL_INIT([SHELL=${CONFIG_SHELL-/bin/sh}]) dnl Parse OPTIONS _LT_SET_OPTIONS([$0], [$1]) # This can be used to rebuild libtool when needed LIBTOOL_DEPS=$ltmain # Always use our own libtool. LIBTOOL='$(SHELL) $(top_builddir)/libtool' AC_SUBST(LIBTOOL)dnl _LT_SETUP # Only expand once: m4_define([LT_INIT]) ])# LT_INIT # Old names: AU_ALIAS([AC_PROG_LIBTOOL], [LT_INIT]) AU_ALIAS([AM_PROG_LIBTOOL], [LT_INIT]) dnl aclocal-1.4 backwards compatibility: dnl AC_DEFUN([AC_PROG_LIBTOOL], []) dnl AC_DEFUN([AM_PROG_LIBTOOL], []) # _LT_PREPARE_CC_BASENAME # ----------------------- m4_defun([_LT_PREPARE_CC_BASENAME], [ # Calculate cc_basename. Skip known compiler wrappers and cross-prefix. func_cc_basename () { for cc_temp in @S|@*""; do case $cc_temp in compile | *[[\\/]]compile | ccache | *[[\\/]]ccache ) ;; distcc | *[[\\/]]distcc | purify | *[[\\/]]purify ) ;; \-*) ;; *) break;; esac done func_cc_basename_result=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"` } ])# _LT_PREPARE_CC_BASENAME # _LT_CC_BASENAME(CC) # ------------------- # It would be clearer to call AC_REQUIREs from _LT_PREPARE_CC_BASENAME, # but that macro is also expanded into generated libtool script, which # arranges for $SED and $ECHO to be set by different means. m4_defun([_LT_CC_BASENAME], [m4_require([_LT_PREPARE_CC_BASENAME])dnl AC_REQUIRE([_LT_DECL_SED])dnl AC_REQUIRE([_LT_PROG_ECHO_BACKSLASH])dnl func_cc_basename $1 cc_basename=$func_cc_basename_result ]) # _LT_FILEUTILS_DEFAULTS # ---------------------- # It is okay to use these file commands and assume they have been set # sensibly after 'm4_require([_LT_FILEUTILS_DEFAULTS])'. m4_defun([_LT_FILEUTILS_DEFAULTS], [: ${CP="cp -f"} : ${MV="mv -f"} : ${RM="rm -f"} ])# _LT_FILEUTILS_DEFAULTS # _LT_SETUP # --------- m4_defun([_LT_SETUP], [AC_REQUIRE([AC_CANONICAL_HOST])dnl AC_REQUIRE([AC_CANONICAL_BUILD])dnl AC_REQUIRE([_LT_PREPARE_SED_QUOTE_VARS])dnl AC_REQUIRE([_LT_PROG_ECHO_BACKSLASH])dnl _LT_DECL([], [PATH_SEPARATOR], [1], [The PATH separator for the build system])dnl dnl _LT_DECL([], [host_alias], [0], [The host system])dnl _LT_DECL([], [host], [0])dnl _LT_DECL([], [host_os], [0])dnl dnl _LT_DECL([], [build_alias], [0], [The build system])dnl _LT_DECL([], [build], [0])dnl _LT_DECL([], [build_os], [0])dnl dnl AC_REQUIRE([AC_PROG_CC])dnl AC_REQUIRE([LT_PATH_LD])dnl AC_REQUIRE([LT_PATH_NM])dnl dnl AC_REQUIRE([AC_PROG_LN_S])dnl test -z "$LN_S" && LN_S="ln -s" _LT_DECL([], [LN_S], [1], [Whether we need soft or hard links])dnl dnl AC_REQUIRE([LT_CMD_MAX_LEN])dnl _LT_DECL([objext], [ac_objext], [0], [Object file suffix (normally "o")])dnl _LT_DECL([], [exeext], [0], [Executable file suffix (normally "")])dnl dnl m4_require([_LT_FILEUTILS_DEFAULTS])dnl m4_require([_LT_CHECK_SHELL_FEATURES])dnl m4_require([_LT_PATH_CONVERSION_FUNCTIONS])dnl m4_require([_LT_CMD_RELOAD])dnl m4_require([_LT_CHECK_MAGIC_METHOD])dnl m4_require([_LT_CHECK_SHAREDLIB_FROM_LINKLIB])dnl m4_require([_LT_CMD_OLD_ARCHIVE])dnl m4_require([_LT_CMD_GLOBAL_SYMBOLS])dnl m4_require([_LT_WITH_SYSROOT])dnl m4_require([_LT_CMD_TRUNCATE])dnl _LT_CONFIG_LIBTOOL_INIT([ # See if we are running on zsh, and set the options that allow our # commands through without removal of \ escapes INIT. if test -n "\${ZSH_VERSION+set}"; then setopt NO_GLOB_SUBST fi ]) if test -n "${ZSH_VERSION+set}"; then setopt NO_GLOB_SUBST fi _LT_CHECK_OBJDIR m4_require([_LT_TAG_COMPILER])dnl 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 set != "${COLLECT_NAMES+set}"; 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 _LT_CC_BASENAME([$compiler]) # 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 _LT_PATH_MAGIC fi ;; esac # Use C for the default configuration in the libtool script LT_SUPPORTED_TAG([CC]) _LT_LANG_C_CONFIG _LT_LANG_DEFAULT_CONFIG _LT_CONFIG_COMMANDS ])# _LT_SETUP # _LT_PREPARE_SED_QUOTE_VARS # -------------------------- # Define a few sed substitution that help us do robust quoting. m4_defun([_LT_PREPARE_SED_QUOTE_VARS], [# 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' ]) # _LT_PROG_LTMAIN # --------------- # Note that this code is called both from 'configure', and 'config.status' # now that we use AC_CONFIG_COMMANDS to generate libtool. Notably, # 'config.status' has no value for ac_aux_dir unless we are using Automake, # so we pass a copy along to make sure it has a sensible value anyway. m4_defun([_LT_PROG_LTMAIN], [m4_ifdef([AC_REQUIRE_AUX_FILE], [AC_REQUIRE_AUX_FILE([ltmain.sh])])dnl _LT_CONFIG_LIBTOOL_INIT([ac_aux_dir='$ac_aux_dir']) ltmain=$ac_aux_dir/ltmain.sh ])# _LT_PROG_LTMAIN ## ------------------------------------- ## ## Accumulate code for creating libtool. ## ## ------------------------------------- ## # So that we can recreate a full libtool script including additional # tags, we accumulate the chunks of code to send to AC_CONFIG_COMMANDS # in macros and then make a single call at the end using the 'libtool' # label. # _LT_CONFIG_LIBTOOL_INIT([INIT-COMMANDS]) # ---------------------------------------- # Register INIT-COMMANDS to be passed to AC_CONFIG_COMMANDS later. m4_define([_LT_CONFIG_LIBTOOL_INIT], [m4_ifval([$1], [m4_append([_LT_OUTPUT_LIBTOOL_INIT], [$1 ])])]) # Initialize. m4_define([_LT_OUTPUT_LIBTOOL_INIT]) # _LT_CONFIG_LIBTOOL([COMMANDS]) # ------------------------------ # Register COMMANDS to be passed to AC_CONFIG_COMMANDS later. m4_define([_LT_CONFIG_LIBTOOL], [m4_ifval([$1], [m4_append([_LT_OUTPUT_LIBTOOL_COMMANDS], [$1 ])])]) # Initialize. m4_define([_LT_OUTPUT_LIBTOOL_COMMANDS]) # _LT_CONFIG_SAVE_COMMANDS([COMMANDS], [INIT_COMMANDS]) # ----------------------------------------------------- m4_defun([_LT_CONFIG_SAVE_COMMANDS], [_LT_CONFIG_LIBTOOL([$1]) _LT_CONFIG_LIBTOOL_INIT([$2]) ]) # _LT_FORMAT_COMMENT([COMMENT]) # ----------------------------- # Add leading comment marks to the start of each line, and a trailing # full-stop to the whole comment if one is not present already. m4_define([_LT_FORMAT_COMMENT], [m4_ifval([$1], [ m4_bpatsubst([m4_bpatsubst([$1], [^ *], [# ])], [['`$\]], [\\\&])]m4_bmatch([$1], [[!?.]$], [], [.]) )]) ## ------------------------ ## ## FIXME: Eliminate VARNAME ## ## ------------------------ ## # _LT_DECL([CONFIGNAME], VARNAME, VALUE, [DESCRIPTION], [IS-TAGGED?]) # ------------------------------------------------------------------- # CONFIGNAME is the name given to the value in the libtool script. # VARNAME is the (base) name used in the configure script. # VALUE may be 0, 1 or 2 for a computed quote escaped value based on # VARNAME. Any other value will be used directly. m4_define([_LT_DECL], [lt_if_append_uniq([lt_decl_varnames], [$2], [, ], [lt_dict_add_subkey([lt_decl_dict], [$2], [libtool_name], [m4_ifval([$1], [$1], [$2])]) lt_dict_add_subkey([lt_decl_dict], [$2], [value], [$3]) m4_ifval([$4], [lt_dict_add_subkey([lt_decl_dict], [$2], [description], [$4])]) lt_dict_add_subkey([lt_decl_dict], [$2], [tagged?], [m4_ifval([$5], [yes], [no])])]) ]) # _LT_TAGDECL([CONFIGNAME], VARNAME, VALUE, [DESCRIPTION]) # -------------------------------------------------------- m4_define([_LT_TAGDECL], [_LT_DECL([$1], [$2], [$3], [$4], [yes])]) # lt_decl_tag_varnames([SEPARATOR], [VARNAME1...]) # ------------------------------------------------ m4_define([lt_decl_tag_varnames], [_lt_decl_filter([tagged?], [yes], $@)]) # _lt_decl_filter(SUBKEY, VALUE, [SEPARATOR], [VARNAME1..]) # --------------------------------------------------------- m4_define([_lt_decl_filter], [m4_case([$#], [0], [m4_fatal([$0: too few arguments: $#])], [1], [m4_fatal([$0: too few arguments: $#: $1])], [2], [lt_dict_filter([lt_decl_dict], [$1], [$2], [], lt_decl_varnames)], [3], [lt_dict_filter([lt_decl_dict], [$1], [$2], [$3], lt_decl_varnames)], [lt_dict_filter([lt_decl_dict], $@)])[]dnl ]) # lt_decl_quote_varnames([SEPARATOR], [VARNAME1...]) # -------------------------------------------------- m4_define([lt_decl_quote_varnames], [_lt_decl_filter([value], [1], $@)]) # lt_decl_dquote_varnames([SEPARATOR], [VARNAME1...]) # --------------------------------------------------- m4_define([lt_decl_dquote_varnames], [_lt_decl_filter([value], [2], $@)]) # lt_decl_varnames_tagged([SEPARATOR], [VARNAME1...]) # --------------------------------------------------- m4_define([lt_decl_varnames_tagged], [m4_assert([$# <= 2])dnl _$0(m4_quote(m4_default([$1], [[, ]])), m4_ifval([$2], [[$2]], [m4_dquote(lt_decl_tag_varnames)]), m4_split(m4_normalize(m4_quote(_LT_TAGS)), [ ]))]) m4_define([_lt_decl_varnames_tagged], [m4_ifval([$3], [lt_combine([$1], [$2], [_], $3)])]) # lt_decl_all_varnames([SEPARATOR], [VARNAME1...]) # ------------------------------------------------ m4_define([lt_decl_all_varnames], [_$0(m4_quote(m4_default([$1], [[, ]])), m4_if([$2], [], m4_quote(lt_decl_varnames), m4_quote(m4_shift($@))))[]dnl ]) m4_define([_lt_decl_all_varnames], [lt_join($@, lt_decl_varnames_tagged([$1], lt_decl_tag_varnames([[, ]], m4_shift($@))))dnl ]) # _LT_CONFIG_STATUS_DECLARE([VARNAME]) # ------------------------------------ # Quote a variable value, and forward it to 'config.status' so that its # declaration there will have the same value as in 'configure'. VARNAME # must have a single quote delimited value for this to work. m4_define([_LT_CONFIG_STATUS_DECLARE], [$1='`$ECHO "$][$1" | $SED "$delay_single_quote_subst"`']) # _LT_CONFIG_STATUS_DECLARATIONS # ------------------------------ # We delimit libtool config variables with single quotes, so when # we write them to config.status, we have to be sure to quote all # embedded single quotes properly. In configure, this macro expands # each variable declared with _LT_DECL (and _LT_TAGDECL) into: # # ='`$ECHO "$" | $SED "$delay_single_quote_subst"`' m4_defun([_LT_CONFIG_STATUS_DECLARATIONS], [m4_foreach([_lt_var], m4_quote(lt_decl_all_varnames), [m4_n([_LT_CONFIG_STATUS_DECLARE(_lt_var)])])]) # _LT_LIBTOOL_TAGS # ---------------- # Output comment and list of tags supported by the script m4_defun([_LT_LIBTOOL_TAGS], [_LT_FORMAT_COMMENT([The names of the tagged configurations supported by this script])dnl available_tags='_LT_TAGS'dnl ]) # _LT_LIBTOOL_DECLARE(VARNAME, [TAG]) # ----------------------------------- # Extract the dictionary values for VARNAME (optionally with TAG) and # expand to a commented shell variable setting: # # # Some comment about what VAR is for. # visible_name=$lt_internal_name m4_define([_LT_LIBTOOL_DECLARE], [_LT_FORMAT_COMMENT(m4_quote(lt_dict_fetch([lt_decl_dict], [$1], [description])))[]dnl m4_pushdef([_libtool_name], m4_quote(lt_dict_fetch([lt_decl_dict], [$1], [libtool_name])))[]dnl m4_case(m4_quote(lt_dict_fetch([lt_decl_dict], [$1], [value])), [0], [_libtool_name=[$]$1], [1], [_libtool_name=$lt_[]$1], [2], [_libtool_name=$lt_[]$1], [_libtool_name=lt_dict_fetch([lt_decl_dict], [$1], [value])])[]dnl m4_ifval([$2], [_$2])[]m4_popdef([_libtool_name])[]dnl ]) # _LT_LIBTOOL_CONFIG_VARS # ----------------------- # Produce commented declarations of non-tagged libtool config variables # suitable for insertion in the LIBTOOL CONFIG section of the 'libtool' # script. Tagged libtool config variables (even for the LIBTOOL CONFIG # section) are produced by _LT_LIBTOOL_TAG_VARS. m4_defun([_LT_LIBTOOL_CONFIG_VARS], [m4_foreach([_lt_var], m4_quote(_lt_decl_filter([tagged?], [no], [], lt_decl_varnames)), [m4_n([_LT_LIBTOOL_DECLARE(_lt_var)])])]) # _LT_LIBTOOL_TAG_VARS(TAG) # ------------------------- m4_define([_LT_LIBTOOL_TAG_VARS], [m4_foreach([_lt_var], m4_quote(lt_decl_tag_varnames), [m4_n([_LT_LIBTOOL_DECLARE(_lt_var, [$1])])])]) # _LT_TAGVAR(VARNAME, [TAGNAME]) # ------------------------------ m4_define([_LT_TAGVAR], [m4_ifval([$2], [$1_$2], [$1])]) # _LT_CONFIG_COMMANDS # ------------------- # Send accumulated output to $CONFIG_STATUS. Thanks to the lists of # variables for single and double quote escaping we saved from calls # to _LT_DECL, we can put quote escaped variables declarations # into 'config.status', and then the shell code to quote escape them in # for loops in 'config.status'. Finally, any additional code accumulated # from calls to _LT_CONFIG_LIBTOOL_INIT is expanded. m4_defun([_LT_CONFIG_COMMANDS], [AC_PROVIDE_IFELSE([LT_OUTPUT], dnl If the libtool generation code has been placed in $CONFIG_LT, dnl instead of duplicating it all over again into config.status, dnl then we will have config.status run $CONFIG_LT later, so it dnl needs to know what name is stored there: [AC_CONFIG_COMMANDS([libtool], [$SHELL $CONFIG_LT || AS_EXIT(1)], [CONFIG_LT='$CONFIG_LT'])], dnl If the libtool generation code is destined for config.status, dnl expand the accumulated commands and init code now: [AC_CONFIG_COMMANDS([libtool], [_LT_OUTPUT_LIBTOOL_COMMANDS], [_LT_OUTPUT_LIBTOOL_COMMANDS_INIT])]) ])#_LT_CONFIG_COMMANDS # Initialize. m4_define([_LT_OUTPUT_LIBTOOL_COMMANDS_INIT], [ # 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' _LT_CONFIG_STATUS_DECLARATIONS 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 lt_decl_all_varnames([[ \ ]], lt_decl_quote_varnames); do case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in *[[\\\\\\\`\\"\\\$]]*) eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED \\"\\\$sed_quote_subst\\"\\\`\\\\\\"" ## exclude from sc_prohibit_nested_quotes ;; *) eval "lt_\$var=\\\\\\"\\\$\$var\\\\\\"" ;; esac done # Double-quote double-evaled strings. for var in lt_decl_all_varnames([[ \ ]], lt_decl_dquote_varnames); do case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in *[[\\\\\\\`\\"\\\$]]*) eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED -e \\"\\\$double_quote_subst\\" -e \\"\\\$sed_quote_subst\\" -e \\"\\\$delay_variable_subst\\"\\\`\\\\\\"" ## exclude from sc_prohibit_nested_quotes ;; *) eval "lt_\$var=\\\\\\"\\\$\$var\\\\\\"" ;; esac done _LT_OUTPUT_LIBTOOL_INIT ]) # _LT_GENERATED_FILE_INIT(FILE, [COMMENT]) # ------------------------------------ # Generate a child script FILE with all initialization necessary to # reuse the environment learned by the parent script, and make the # file executable. If COMMENT is supplied, it is inserted after the # '#!' sequence but before initialization text begins. After this # macro, additional text can be appended to FILE to form the body of # the child script. The macro ends with non-zero status if the # file could not be fully written (such as if the disk is full). m4_ifdef([AS_INIT_GENERATED], [m4_defun([_LT_GENERATED_FILE_INIT],[AS_INIT_GENERATED($@)])], [m4_defun([_LT_GENERATED_FILE_INIT], [m4_require([AS_PREPARE])]dnl [m4_pushdef([AS_MESSAGE_LOG_FD])]dnl [lt_write_fail=0 cat >$1 <<_ASEOF || lt_write_fail=1 #! $SHELL # Generated by $as_me. $2 SHELL=\${CONFIG_SHELL-$SHELL} export SHELL _ASEOF cat >>$1 <<\_ASEOF || lt_write_fail=1 AS_SHELL_SANITIZE _AS_PREPARE exec AS_MESSAGE_FD>&1 _ASEOF test 0 = "$lt_write_fail" && chmod +x $1[]dnl m4_popdef([AS_MESSAGE_LOG_FD])])])# _LT_GENERATED_FILE_INIT # LT_OUTPUT # --------- # This macro allows early generation of the libtool script (before # AC_OUTPUT is called), incase it is used in configure for compilation # tests. AC_DEFUN([LT_OUTPUT], [: ${CONFIG_LT=./config.lt} AC_MSG_NOTICE([creating $CONFIG_LT]) _LT_GENERATED_FILE_INIT(["$CONFIG_LT"], [# Run this file to recreate a libtool stub with the current configuration.]) cat >>"$CONFIG_LT" <<\_LTEOF lt_cl_silent=false exec AS_MESSAGE_LOG_FD>>config.log { echo AS_BOX([Running $as_me.]) } >&AS_MESSAGE_LOG_FD lt_cl_help="\ '$as_me' creates a local libtool stub from the current configuration, for use in further configure time tests before the real libtool is generated. Usage: $[0] [[OPTIONS]] -h, --help print this help, then exit -V, --version print version number, then exit -q, --quiet do not print progress messages -d, --debug don't remove temporary files Report bugs to ." lt_cl_version="\ m4_ifset([AC_PACKAGE_NAME], [AC_PACKAGE_NAME ])config.lt[]dnl m4_ifset([AC_PACKAGE_VERSION], [ AC_PACKAGE_VERSION]) configured by $[0], generated by m4_PACKAGE_STRING. Copyright (C) 2011 Free Software Foundation, Inc. This config.lt script is free software; the Free Software Foundation gives unlimited permision to copy, distribute and modify it." while test 0 != $[#] do case $[1] in --version | --v* | -V ) echo "$lt_cl_version"; exit 0 ;; --help | --h* | -h ) echo "$lt_cl_help"; exit 0 ;; --debug | --d* | -d ) debug=: ;; --quiet | --q* | --silent | --s* | -q ) lt_cl_silent=: ;; -*) AC_MSG_ERROR([unrecognized option: $[1] Try '$[0] --help' for more information.]) ;; *) AC_MSG_ERROR([unrecognized argument: $[1] Try '$[0] --help' for more information.]) ;; esac shift done if $lt_cl_silent; then exec AS_MESSAGE_FD>/dev/null fi _LTEOF cat >>"$CONFIG_LT" <<_LTEOF _LT_OUTPUT_LIBTOOL_COMMANDS_INIT _LTEOF cat >>"$CONFIG_LT" <<\_LTEOF AC_MSG_NOTICE([creating $ofile]) _LT_OUTPUT_LIBTOOL_COMMANDS AS_EXIT(0) _LTEOF chmod +x "$CONFIG_LT" # configure is writing to config.log, but config.lt does its own redirection, # appending to config.log, which fails on DOS, as config.log is still kept # open by configure. Here we exec the FD to /dev/null, effectively closing # config.log, so it can be properly (re)opened and appended to by config.lt. lt_cl_success=: test yes = "$silent" && lt_config_lt_args="$lt_config_lt_args --quiet" exec AS_MESSAGE_LOG_FD>/dev/null $SHELL "$CONFIG_LT" $lt_config_lt_args || lt_cl_success=false exec AS_MESSAGE_LOG_FD>>config.log $lt_cl_success || AS_EXIT(1) ])# LT_OUTPUT # _LT_CONFIG(TAG) # --------------- # If TAG is the built-in tag, create an initial libtool script with a # default configuration from the untagged config vars. Otherwise add code # to config.status for appending the configuration named by TAG from the # matching tagged config vars. m4_defun([_LT_CONFIG], [m4_require([_LT_FILEUTILS_DEFAULTS])dnl _LT_CONFIG_SAVE_COMMANDS([ m4_define([_LT_TAG], m4_if([$1], [], [C], [$1]))dnl m4_if(_LT_TAG, [C], [ # See if we are running on zsh, and set the options that 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 # Generated automatically by $as_me ($PACKAGE) $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. # Provide generalized library-building support services. # Written by Gordon Matzigkeit, 1996 _LT_COPYING _LT_LIBTOOL_TAGS # Configured defaults for sys_lib_dlsearch_path munging. : \${LT_SYS_LIBRARY_PATH="$configure_time_lt_sys_library_path"} # ### BEGIN LIBTOOL CONFIG _LT_LIBTOOL_CONFIG_VARS _LT_LIBTOOL_TAG_VARS # ### END LIBTOOL CONFIG _LT_EOF cat <<'_LT_EOF' >> "$cfgfile" # ### BEGIN FUNCTIONS SHARED WITH CONFIGURE _LT_PREPARE_MUNGE_PATH_LIST _LT_PREPARE_CC_BASENAME # ### END FUNCTIONS SHARED WITH CONFIGURE _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 set != "${COLLECT_NAMES+set}"; then COLLECT_NAMES= export COLLECT_NAMES fi _LT_EOF ;; esac _LT_PROG_LTMAIN # 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) mv -f "$cfgfile" "$ofile" || (rm -f "$ofile" && cp "$cfgfile" "$ofile" && rm -f "$cfgfile") chmod +x "$ofile" ], [cat <<_LT_EOF >> "$ofile" dnl Unfortunately we have to use $1 here, since _LT_TAG is not expanded dnl in a comment (ie after a #). # ### BEGIN LIBTOOL TAG CONFIG: $1 _LT_LIBTOOL_TAG_VARS(_LT_TAG) # ### END LIBTOOL TAG CONFIG: $1 _LT_EOF ])dnl /m4_if ], [m4_if([$1], [], [ PACKAGE='$PACKAGE' VERSION='$VERSION' RM='$RM' ofile='$ofile'], []) ])dnl /_LT_CONFIG_SAVE_COMMANDS ])# _LT_CONFIG # LT_SUPPORTED_TAG(TAG) # --------------------- # Trace this macro to discover what tags are supported by the libtool # --tag option, using: # autoconf --trace 'LT_SUPPORTED_TAG:$1' AC_DEFUN([LT_SUPPORTED_TAG], []) # C support is built-in for now m4_define([_LT_LANG_C_enabled], []) m4_define([_LT_TAGS], []) # LT_LANG(LANG) # ------------- # Enable libtool support for the given language if not already enabled. AC_DEFUN([LT_LANG], [AC_BEFORE([$0], [LT_OUTPUT])dnl m4_case([$1], [C], [_LT_LANG(C)], [C++], [_LT_LANG(CXX)], [Go], [_LT_LANG(GO)], [Java], [_LT_LANG(GCJ)], [Fortran 77], [_LT_LANG(F77)], [Fortran], [_LT_LANG(FC)], [Windows Resource], [_LT_LANG(RC)], [m4_ifdef([_LT_LANG_]$1[_CONFIG], [_LT_LANG($1)], [m4_fatal([$0: unsupported language: "$1"])])])dnl ])# LT_LANG # _LT_LANG(LANGNAME) # ------------------ m4_defun([_LT_LANG], [m4_ifdef([_LT_LANG_]$1[_enabled], [], [LT_SUPPORTED_TAG([$1])dnl m4_append([_LT_TAGS], [$1 ])dnl m4_define([_LT_LANG_]$1[_enabled], [])dnl _LT_LANG_$1_CONFIG($1)])dnl ])# _LT_LANG m4_ifndef([AC_PROG_GO], [ ############################################################ # NOTE: This macro has been submitted for inclusion into # # GNU Autoconf as AC_PROG_GO. When it is available in # # a released version of Autoconf we should remove this # # macro and use it instead. # ############################################################ m4_defun([AC_PROG_GO], [AC_LANG_PUSH(Go)dnl AC_ARG_VAR([GOC], [Go compiler command])dnl AC_ARG_VAR([GOFLAGS], [Go compiler flags])dnl _AC_ARG_VAR_LDFLAGS()dnl AC_CHECK_TOOL(GOC, gccgo) if test -z "$GOC"; then if test -n "$ac_tool_prefix"; then AC_CHECK_PROG(GOC, [${ac_tool_prefix}gccgo], [${ac_tool_prefix}gccgo]) fi fi if test -z "$GOC"; then AC_CHECK_PROG(GOC, gccgo, gccgo, false) fi ])#m4_defun ])#m4_ifndef # _LT_LANG_DEFAULT_CONFIG # ----------------------- m4_defun([_LT_LANG_DEFAULT_CONFIG], [AC_PROVIDE_IFELSE([AC_PROG_CXX], [LT_LANG(CXX)], [m4_define([AC_PROG_CXX], defn([AC_PROG_CXX])[LT_LANG(CXX)])]) AC_PROVIDE_IFELSE([AC_PROG_F77], [LT_LANG(F77)], [m4_define([AC_PROG_F77], defn([AC_PROG_F77])[LT_LANG(F77)])]) AC_PROVIDE_IFELSE([AC_PROG_FC], [LT_LANG(FC)], [m4_define([AC_PROG_FC], defn([AC_PROG_FC])[LT_LANG(FC)])]) dnl The call to [A][M_PROG_GCJ] is quoted like that to stop aclocal dnl pulling things in needlessly. AC_PROVIDE_IFELSE([AC_PROG_GCJ], [LT_LANG(GCJ)], [AC_PROVIDE_IFELSE([A][M_PROG_GCJ], [LT_LANG(GCJ)], [AC_PROVIDE_IFELSE([LT_PROG_GCJ], [LT_LANG(GCJ)], [m4_ifdef([AC_PROG_GCJ], [m4_define([AC_PROG_GCJ], defn([AC_PROG_GCJ])[LT_LANG(GCJ)])]) m4_ifdef([A][M_PROG_GCJ], [m4_define([A][M_PROG_GCJ], defn([A][M_PROG_GCJ])[LT_LANG(GCJ)])]) m4_ifdef([LT_PROG_GCJ], [m4_define([LT_PROG_GCJ], defn([LT_PROG_GCJ])[LT_LANG(GCJ)])])])])]) AC_PROVIDE_IFELSE([AC_PROG_GO], [LT_LANG(GO)], [m4_define([AC_PROG_GO], defn([AC_PROG_GO])[LT_LANG(GO)])]) AC_PROVIDE_IFELSE([LT_PROG_RC], [LT_LANG(RC)], [m4_define([LT_PROG_RC], defn([LT_PROG_RC])[LT_LANG(RC)])]) ])# _LT_LANG_DEFAULT_CONFIG # Obsolete macros: AU_DEFUN([AC_LIBTOOL_CXX], [LT_LANG(C++)]) AU_DEFUN([AC_LIBTOOL_F77], [LT_LANG(Fortran 77)]) AU_DEFUN([AC_LIBTOOL_FC], [LT_LANG(Fortran)]) AU_DEFUN([AC_LIBTOOL_GCJ], [LT_LANG(Java)]) AU_DEFUN([AC_LIBTOOL_RC], [LT_LANG(Windows Resource)]) dnl aclocal-1.4 backwards compatibility: dnl AC_DEFUN([AC_LIBTOOL_CXX], []) dnl AC_DEFUN([AC_LIBTOOL_F77], []) dnl AC_DEFUN([AC_LIBTOOL_FC], []) dnl AC_DEFUN([AC_LIBTOOL_GCJ], []) dnl AC_DEFUN([AC_LIBTOOL_RC], []) # _LT_TAG_COMPILER # ---------------- m4_defun([_LT_TAG_COMPILER], [AC_REQUIRE([AC_PROG_CC])dnl _LT_DECL([LTCC], [CC], [1], [A C compiler])dnl _LT_DECL([LTCFLAGS], [CFLAGS], [1], [LTCC compiler flags])dnl _LT_TAGDECL([CC], [compiler], [1], [A language specific compiler])dnl _LT_TAGDECL([with_gcc], [GCC], [0], [Is the compiler the GNU compiler?])dnl # 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 ])# _LT_TAG_COMPILER # _LT_COMPILER_BOILERPLATE # ------------------------ # Check for compiler boilerplate output or warnings with # the simple compiler test code. m4_defun([_LT_COMPILER_BOILERPLATE], [m4_require([_LT_DECL_SED])dnl 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* ])# _LT_COMPILER_BOILERPLATE # _LT_LINKER_BOILERPLATE # ---------------------- # Check for linker boilerplate output or warnings with # the simple link test code. m4_defun([_LT_LINKER_BOILERPLATE], [m4_require([_LT_DECL_SED])dnl 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* ])# _LT_LINKER_BOILERPLATE # _LT_REQUIRED_DARWIN_CHECKS # ------------------------- m4_defun_once([_LT_REQUIRED_DARWIN_CHECKS],[ case $host_os in rhapsody* | darwin*) AC_CHECK_TOOL([DSYMUTIL], [dsymutil], [:]) AC_CHECK_TOOL([NMEDIT], [nmedit], [:]) AC_CHECK_TOOL([LIPO], [lipo], [:]) AC_CHECK_TOOL([OTOOL], [otool], [:]) AC_CHECK_TOOL([OTOOL64], [otool64], [:]) _LT_DECL([], [DSYMUTIL], [1], [Tool to manipulate archived DWARF debug symbol files on Mac OS X]) _LT_DECL([], [NMEDIT], [1], [Tool to change global to local symbols on Mac OS X]) _LT_DECL([], [LIPO], [1], [Tool to manipulate fat objects and archives on Mac OS X]) _LT_DECL([], [OTOOL], [1], [ldd/readelf like tool for Mach-O binaries on Mac OS X]) _LT_DECL([], [OTOOL64], [1], [ldd/readelf like tool for 64 bit Mach-O binaries on Mac OS X 10.4]) AC_CACHE_CHECK([for -single_module linker flag],[lt_cv_apple_cc_single_mod], [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" >&AS_MESSAGE_LOG_FD $LTCC $LTCFLAGS $LDFLAGS -o libconftest.dylib \ -dynamiclib -Wl,-single_module conftest.c 2>conftest.err _lt_result=$? # If there is a non-empty error log, and "single_module" # appears in it, assume the flag caused a linker warning if test -s conftest.err && $GREP single_module conftest.err; then cat conftest.err >&AS_MESSAGE_LOG_FD # Otherwise, if the output was created with a 0 exit code from # the compiler, it worked. elif test -f libconftest.dylib && test 0 = "$_lt_result"; then lt_cv_apple_cc_single_mod=yes else cat conftest.err >&AS_MESSAGE_LOG_FD fi rm -rf libconftest.dylib* rm -f conftest.* fi]) AC_CACHE_CHECK([for -exported_symbols_list linker flag], [lt_cv_ld_exported_symbols_list], [lt_cv_ld_exported_symbols_list=no save_LDFLAGS=$LDFLAGS echo "_main" > conftest.sym LDFLAGS="$LDFLAGS -Wl,-exported_symbols_list,conftest.sym" AC_LINK_IFELSE([AC_LANG_PROGRAM([],[])], [lt_cv_ld_exported_symbols_list=yes], [lt_cv_ld_exported_symbols_list=no]) LDFLAGS=$save_LDFLAGS ]) AC_CACHE_CHECK([for -force_load linker flag],[lt_cv_ld_force_load], [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" >&AS_MESSAGE_LOG_FD $LTCC $LTCFLAGS -c -o conftest.o conftest.c 2>&AS_MESSAGE_LOG_FD echo "$AR cru libconftest.a conftest.o" >&AS_MESSAGE_LOG_FD $AR cru libconftest.a conftest.o 2>&AS_MESSAGE_LOG_FD echo "$RANLIB libconftest.a" >&AS_MESSAGE_LOG_FD $RANLIB libconftest.a 2>&AS_MESSAGE_LOG_FD cat > conftest.c << _LT_EOF int main() { return 0;} _LT_EOF echo "$LTCC $LTCFLAGS $LDFLAGS -o conftest conftest.c -Wl,-force_load,./libconftest.a" >&AS_MESSAGE_LOG_FD $LTCC $LTCFLAGS $LDFLAGS -o conftest conftest.c -Wl,-force_load,./libconftest.a 2>conftest.err _lt_result=$? if test -s conftest.err && $GREP force_load conftest.err; then cat conftest.err >&AS_MESSAGE_LOG_FD elif test -f conftest && test 0 = "$_lt_result" && $GREP forced_load conftest >/dev/null 2>&1; then lt_cv_ld_force_load=yes else cat conftest.err >&AS_MESSAGE_LOG_FD fi rm -f conftest.err libconftest.a conftest conftest.c rm -rf conftest.dSYM ]) 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 yes = "$lt_cv_apple_cc_single_mod"; then _lt_dar_single_mod='$single_module' fi if test yes = "$lt_cv_ld_exported_symbols_list"; 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 no = "$lt_cv_ld_force_load"; then _lt_dsymutil='~$DSYMUTIL $lib || :' else _lt_dsymutil= fi ;; esac ]) # _LT_DARWIN_LINKER_FEATURES([TAG]) # --------------------------------- # Checks for linker and compiler features on darwin m4_defun([_LT_DARWIN_LINKER_FEATURES], [ m4_require([_LT_REQUIRED_DARWIN_CHECKS]) _LT_TAGVAR(archive_cmds_need_lc, $1)=no _LT_TAGVAR(hardcode_direct, $1)=no _LT_TAGVAR(hardcode_automatic, $1)=yes _LT_TAGVAR(hardcode_shlibpath_var, $1)=unsupported if test yes = "$lt_cv_ld_force_load"; then _LT_TAGVAR(whole_archive_flag_spec, $1)='`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience $wl-force_load,$conv\"; done; func_echo_all \"$new_convenience\"`' m4_case([$1], [F77], [_LT_TAGVAR(compiler_needs_object, $1)=yes], [FC], [_LT_TAGVAR(compiler_needs_object, $1)=yes]) else _LT_TAGVAR(whole_archive_flag_spec, $1)='' fi _LT_TAGVAR(link_all_deplibs, $1)=yes _LT_TAGVAR(allow_undefined_flag, $1)=$_lt_dar_allow_undefined case $cc_basename in ifort*|nagfor*) _lt_dar_can_shared=yes ;; *) _lt_dar_can_shared=$GCC ;; esac if test yes = "$_lt_dar_can_shared"; then output_verbose_link_cmd=func_echo_all _LT_TAGVAR(archive_cmds, $1)="\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring $_lt_dar_single_mod$_lt_dsymutil" _LT_TAGVAR(module_cmds, $1)="\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags$_lt_dsymutil" _LT_TAGVAR(archive_expsym_cmds, $1)="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" _LT_TAGVAR(module_expsym_cmds, $1)="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" m4_if([$1], [CXX], [ if test yes != "$lt_cv_apple_cc_single_mod"; then _LT_TAGVAR(archive_cmds, $1)="\$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" _LT_TAGVAR(archive_expsym_cmds, $1)="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 _LT_TAGVAR(ld_shlibs, $1)=no fi ]) # _LT_SYS_MODULE_PATH_AIX([TAGNAME]) # ---------------------------------- # Links a minimal program and checks the executable # for the system default hardcoded library path. In most cases, # this is /usr/lib:/lib, but when the MPI compilers are used # the location of the communication and MPI libs are included too. # If we don't find anything, use the default library path according # to the aix ld manual. # Store the results from the different compilers for each TAGNAME. # Allow to override them for all tags through lt_cv_aix_libpath. m4_defun([_LT_SYS_MODULE_PATH_AIX], [m4_require([_LT_DECL_SED])dnl if test set = "${lt_cv_aix_libpath+set}"; then aix_libpath=$lt_cv_aix_libpath else AC_CACHE_VAL([_LT_TAGVAR([lt_cv_aix_libpath_], [$1])], [AC_LINK_IFELSE([AC_LANG_PROGRAM],[ lt_aix_libpath_sed='[ /Import File Strings/,/^$/ { /^0/ { s/^0 *\([^ ]*\) *$/\1/ p } }]' _LT_TAGVAR([lt_cv_aix_libpath_], [$1])=`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_TAGVAR([lt_cv_aix_libpath_], [$1])"; then _LT_TAGVAR([lt_cv_aix_libpath_], [$1])=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"` fi],[]) if test -z "$_LT_TAGVAR([lt_cv_aix_libpath_], [$1])"; then _LT_TAGVAR([lt_cv_aix_libpath_], [$1])=/usr/lib:/lib fi ]) aix_libpath=$_LT_TAGVAR([lt_cv_aix_libpath_], [$1]) fi ])# _LT_SYS_MODULE_PATH_AIX # _LT_SHELL_INIT(ARG) # ------------------- m4_define([_LT_SHELL_INIT], [m4_divert_text([M4SH-INIT], [$1 ])])# _LT_SHELL_INIT # _LT_PROG_ECHO_BACKSLASH # ----------------------- # Find how we can fake an echo command that does not interpret backslash. # In particular, with Autoconf 2.60 or later we add some code to the start # of the generated configure script that will find a shell with a builtin # printf (that we can use as an echo command). m4_defun([_LT_PROG_ECHO_BACKSLASH], [ECHO='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO$ECHO AC_MSG_CHECKING([how to print strings]) # 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*) AC_MSG_RESULT([printf]) ;; print*) AC_MSG_RESULT([print -r]) ;; *) AC_MSG_RESULT([cat]) ;; esac m4_ifdef([_AS_DETECT_SUGGESTED], [_AS_DETECT_SUGGESTED([ 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" )])]) _LT_DECL([], [SHELL], [1], [Shell to use when invoking shell scripts]) _LT_DECL([], [ECHO], [1], [An echo program that protects backslashes]) ])# _LT_PROG_ECHO_BACKSLASH # _LT_WITH_SYSROOT # ---------------- AC_DEFUN([_LT_WITH_SYSROOT], [AC_MSG_CHECKING([for sysroot]) AC_ARG_WITH([sysroot], [AS_HELP_STRING([--with-sysroot@<:@=DIR@:>@], [Search for dependent libraries within DIR (or the compiler's sysroot if not specified).])], [], [with_sysroot=no]) dnl lt_sysroot will always be passed unquoted. We quote it here dnl in case the user passed a directory name. lt_sysroot= case $with_sysroot in #( yes) if test yes = "$GCC"; then lt_sysroot=`$CC --print-sysroot 2>/dev/null` fi ;; #( /*) lt_sysroot=`echo "$with_sysroot" | sed -e "$sed_quote_subst"` ;; #( no|'') ;; #( *) AC_MSG_RESULT([$with_sysroot]) AC_MSG_ERROR([The sysroot must be an absolute path.]) ;; esac AC_MSG_RESULT([${lt_sysroot:-no}]) _LT_DECL([], [lt_sysroot], [0], [The root where to search for ]dnl [dependent libraries, and where our libraries should be installed.])]) # _LT_ENABLE_LOCK # --------------- m4_defun([_LT_ENABLE_LOCK], [AC_ARG_ENABLE([libtool-lock], [AS_HELP_STRING([--disable-libtool-lock], [avoid locking (might break parallel builds)])]) test no = "$enable_libtool_lock" || 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 what ABI is being produced by ac_compile, and set mode # options accordingly. echo 'int i;' > conftest.$ac_ext if AC_TRY_EVAL(ac_compile); 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 what ABI is being produced by ac_compile, and set linker # options accordingly. echo '[#]line '$LINENO' "configure"' > conftest.$ac_ext if AC_TRY_EVAL(ac_compile); then if test yes = "$lt_cv_prog_gnu_ld"; 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* ;; mips64*-*linux*) # Find out what ABI is being produced by ac_compile, and set linker # options accordingly. echo '[#]line '$LINENO' "configure"' > conftest.$ac_ext if AC_TRY_EVAL(ac_compile); then emul=elf case `/usr/bin/file conftest.$ac_objext` in *32-bit*) emul="${emul}32" ;; *64-bit*) emul="${emul}64" ;; esac case `/usr/bin/file conftest.$ac_objext` in *MSB*) emul="${emul}btsmip" ;; *LSB*) emul="${emul}ltsmip" ;; esac case `/usr/bin/file conftest.$ac_objext` in *N32*) emul="${emul}n32" ;; esac LD="${LD-ld} -m $emul" fi rm -rf conftest* ;; x86_64-*kfreebsd*-gnu|x86_64-*linux*|powerpc*-*linux*| \ s390*-*linux*|s390*-*tpf*|sparc*-*linux*) # Find out what ABI is being produced by ac_compile, and set linker # options accordingly. Note that the listed cases only cover the # situations where additional linker options are needed (such as when # doing 32-bit compilation for a host where ld defaults to 64-bit, or # vice versa); the common cases where no linker options are needed do # not appear in the list. echo 'int i;' > conftest.$ac_ext if AC_TRY_EVAL(ac_compile); 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*) case `/usr/bin/file conftest.o` in *x86-64*) LD="${LD-ld} -m elf32_x86_64" ;; *) LD="${LD-ld} -m elf_i386" ;; esac ;; powerpc64le-*linux*) LD="${LD-ld} -m elf32lppclinux" ;; 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" ;; powerpcle-*linux*) LD="${LD-ld} -m elf64lppc" ;; 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" AC_CACHE_CHECK([whether the C compiler needs -belf], lt_cv_cc_needs_belf, [AC_LANG_PUSH(C) AC_LINK_IFELSE([AC_LANG_PROGRAM([[]],[[]])],[lt_cv_cc_needs_belf=yes],[lt_cv_cc_needs_belf=no]) AC_LANG_POP]) if test yes != "$lt_cv_cc_needs_belf"; then # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf CFLAGS=$SAVE_CFLAGS fi ;; *-*solaris*) # Find out what ABI is being produced by ac_compile, and set linker # options accordingly. echo 'int i;' > conftest.$ac_ext if AC_TRY_EVAL(ac_compile); then case `/usr/bin/file conftest.o` in *64-bit*) case $lt_cv_prog_gnu_ld in yes*) case $host in i?86-*-solaris*|x86_64-*-solaris*) LD="${LD-ld} -m elf_x86_64" ;; sparc*-*-solaris*) LD="${LD-ld} -m elf64_sparc" ;; esac # GNU ld 2.21 introduced _sol2 emulations. Use them if available. if ${LD-ld} -V | grep _sol2 >/dev/null 2>&1; then LD=${LD-ld}_sol2 fi ;; *) 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 ])# _LT_ENABLE_LOCK # _LT_PROG_AR # ----------- m4_defun([_LT_PROG_AR], [AC_CHECK_TOOLS(AR, [ar], false) : ${AR=ar} : ${AR_FLAGS=cru} _LT_DECL([], [AR], [1], [The archiver]) _LT_DECL([], [AR_FLAGS], [1], [Flags to create an archive]) AC_CACHE_CHECK([for archiver @FILE support], [lt_cv_ar_at_file], [lt_cv_ar_at_file=no AC_COMPILE_IFELSE([AC_LANG_PROGRAM], [echo conftest.$ac_objext > conftest.lst lt_ar_try='$AR $AR_FLAGS libconftest.a @conftest.lst >&AS_MESSAGE_LOG_FD' AC_TRY_EVAL([lt_ar_try]) if test 0 -eq "$ac_status"; then # Ensure the archiver fails upon bogus file names. rm -f conftest.$ac_objext libconftest.a AC_TRY_EVAL([lt_ar_try]) if test 0 -ne "$ac_status"; then lt_cv_ar_at_file=@ fi fi rm -f conftest.* libconftest.a ]) ]) if test no = "$lt_cv_ar_at_file"; then archiver_list_spec= else archiver_list_spec=$lt_cv_ar_at_file fi _LT_DECL([], [archiver_list_spec], [1], [How to feed a file listing to the archiver]) ])# _LT_PROG_AR # _LT_CMD_OLD_ARCHIVE # ------------------- m4_defun([_LT_CMD_OLD_ARCHIVE], [_LT_PROG_AR AC_CHECK_TOOL(STRIP, strip, :) test -z "$STRIP" && STRIP=: _LT_DECL([], [STRIP], [1], [A symbol stripping program]) AC_CHECK_TOOL(RANLIB, ranlib, :) test -z "$RANLIB" && RANLIB=: _LT_DECL([], [RANLIB], [1], [Commands used to install an old-style archive]) # 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 bitrig* | openbsd*) old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB -t \$tool_oldlib" ;; *) old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB \$tool_oldlib" ;; esac old_archive_cmds="$old_archive_cmds~\$RANLIB \$tool_oldlib" fi case $host_os in darwin*) lock_old_archive_extraction=yes ;; *) lock_old_archive_extraction=no ;; esac _LT_DECL([], [old_postinstall_cmds], [2]) _LT_DECL([], [old_postuninstall_cmds], [2]) _LT_TAGDECL([], [old_archive_cmds], [2], [Commands used to build an old-style archive]) _LT_DECL([], [lock_old_archive_extraction], [0], [Whether to use a lock for old archive extraction]) ])# _LT_CMD_OLD_ARCHIVE # _LT_COMPILER_OPTION(MESSAGE, VARIABLE-NAME, FLAGS, # [OUTPUT-FILE], [ACTION-SUCCESS], [ACTION-FAILURE]) # ---------------------------------------------------------------- # Check whether the given compiler option works AC_DEFUN([_LT_COMPILER_OPTION], [m4_require([_LT_FILEUTILS_DEFAULTS])dnl m4_require([_LT_DECL_SED])dnl AC_CACHE_CHECK([$1], [$2], [$2=no m4_if([$4], , [ac_outfile=conftest.$ac_objext], [ac_outfile=$4]) echo "$lt_simple_compile_test_code" > conftest.$ac_ext lt_compiler_flag="$3" ## exclude from sc_useless_quotes_in_assignment # 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\"" >&AS_MESSAGE_LOG_FD) (eval "$lt_compile" 2>conftest.err) ac_status=$? cat conftest.err >&AS_MESSAGE_LOG_FD echo "$as_me:$LINENO: \$? = $ac_status" >&AS_MESSAGE_LOG_FD 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 $2=yes fi fi $RM conftest* ]) if test yes = "[$]$2"; then m4_if([$5], , :, [$5]) else m4_if([$6], , :, [$6]) fi ])# _LT_COMPILER_OPTION # Old name: AU_ALIAS([AC_LIBTOOL_COMPILER_OPTION], [_LT_COMPILER_OPTION]) dnl aclocal-1.4 backwards compatibility: dnl AC_DEFUN([AC_LIBTOOL_COMPILER_OPTION], []) # _LT_LINKER_OPTION(MESSAGE, VARIABLE-NAME, FLAGS, # [ACTION-SUCCESS], [ACTION-FAILURE]) # ---------------------------------------------------- # Check whether the given linker option works AC_DEFUN([_LT_LINKER_OPTION], [m4_require([_LT_FILEUTILS_DEFAULTS])dnl m4_require([_LT_DECL_SED])dnl AC_CACHE_CHECK([$1], [$2], [$2=no save_LDFLAGS=$LDFLAGS LDFLAGS="$LDFLAGS $3" 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>&AS_MESSAGE_LOG_FD $ECHO "$_lt_linker_boilerplate" | $SED '/^$/d' > conftest.exp $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2 if diff conftest.exp conftest.er2 >/dev/null; then $2=yes fi else $2=yes fi fi $RM -r conftest* LDFLAGS=$save_LDFLAGS ]) if test yes = "[$]$2"; then m4_if([$4], , :, [$4]) else m4_if([$5], , :, [$5]) fi ])# _LT_LINKER_OPTION # Old name: AU_ALIAS([AC_LIBTOOL_LINKER_OPTION], [_LT_LINKER_OPTION]) dnl aclocal-1.4 backwards compatibility: dnl AC_DEFUN([AC_LIBTOOL_LINKER_OPTION], []) # LT_CMD_MAX_LEN #--------------- AC_DEFUN([LT_CMD_MAX_LEN], [AC_REQUIRE([AC_CANONICAL_HOST])dnl # find the maximum length of command line arguments AC_MSG_CHECKING([the maximum length of command line arguments]) AC_CACHE_VAL([lt_cv_sys_max_cmd_len], [dnl 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; ;; bitrig* | darwin* | dragonfly* | freebsd* | netbsd* | openbsd*) # 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 ;; os2*) # The test takes a long time on OS/2. lt_cv_sys_max_cmd_len=8192 ;; 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" && \ test undefined != "$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`env echo "$teststring$teststring" 2>/dev/null` \ = "X$teststring$teststring"; } >/dev/null 2>&1 && test 17 != "$i" # 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 ]) if test -n "$lt_cv_sys_max_cmd_len"; then AC_MSG_RESULT($lt_cv_sys_max_cmd_len) else AC_MSG_RESULT(none) fi max_cmd_len=$lt_cv_sys_max_cmd_len _LT_DECL([], [max_cmd_len], [0], [What is the maximum length of a command?]) ])# LT_CMD_MAX_LEN # Old name: AU_ALIAS([AC_LIBTOOL_SYS_MAX_CMD_LEN], [LT_CMD_MAX_LEN]) dnl aclocal-1.4 backwards compatibility: dnl AC_DEFUN([AC_LIBTOOL_SYS_MAX_CMD_LEN], []) # _LT_HEADER_DLFCN # ---------------- m4_defun([_LT_HEADER_DLFCN], [AC_CHECK_HEADERS([dlfcn.h], [], [], [AC_INCLUDES_DEFAULT])dnl ])# _LT_HEADER_DLFCN # _LT_TRY_DLOPEN_SELF (ACTION-IF-TRUE, ACTION-IF-TRUE-W-USCORE, # ACTION-IF-FALSE, ACTION-IF-CROSS-COMPILING) # ---------------------------------------------------------------- m4_defun([_LT_TRY_DLOPEN_SELF], [m4_require([_LT_HEADER_DLFCN])dnl if test yes = "$cross_compiling"; then : [$4] 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 -fvisibility=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 AC_TRY_EVAL(ac_link) && test -s "conftest$ac_exeext" 2>/dev/null; then (./conftest; exit; ) >&AS_MESSAGE_LOG_FD 2>/dev/null lt_status=$? case x$lt_status in x$lt_dlno_uscore) $1 ;; x$lt_dlneed_uscore) $2 ;; x$lt_dlunknown|x*) $3 ;; esac else : # compilation failed $3 fi fi rm -fr conftest* ])# _LT_TRY_DLOPEN_SELF # LT_SYS_DLOPEN_SELF # ------------------ AC_DEFUN([LT_SYS_DLOPEN_SELF], [m4_require([_LT_HEADER_DLFCN])dnl if test yes != "$enable_dlopen"; 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 AC_CHECK_LIB([dl], [dlopen], [lt_cv_dlopen=dlopen lt_cv_dlopen_libs=-ldl],[ lt_cv_dlopen=dyld lt_cv_dlopen_libs= lt_cv_dlopen_self=yes ]) ;; tpf*) # Don't try to run any link tests for TPF. We know it's impossible # because TPF is a cross-compiler, and we know how we open DSOs. lt_cv_dlopen=dlopen lt_cv_dlopen_libs= lt_cv_dlopen_self=no ;; *) AC_CHECK_FUNC([shl_load], [lt_cv_dlopen=shl_load], [AC_CHECK_LIB([dld], [shl_load], [lt_cv_dlopen=shl_load lt_cv_dlopen_libs=-ldld], [AC_CHECK_FUNC([dlopen], [lt_cv_dlopen=dlopen], [AC_CHECK_LIB([dl], [dlopen], [lt_cv_dlopen=dlopen lt_cv_dlopen_libs=-ldl], [AC_CHECK_LIB([svld], [dlopen], [lt_cv_dlopen=dlopen lt_cv_dlopen_libs=-lsvld], [AC_CHECK_LIB([dld], [dld_link], [lt_cv_dlopen=dld_link lt_cv_dlopen_libs=-ldld]) ]) ]) ]) ]) ]) ;; esac if test no = "$lt_cv_dlopen"; then enable_dlopen=no else enable_dlopen=yes fi case $lt_cv_dlopen in dlopen) save_CPPFLAGS=$CPPFLAGS test yes = "$ac_cv_header_dlfcn_h" && 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" AC_CACHE_CHECK([whether a program can dlopen itself], lt_cv_dlopen_self, [dnl _LT_TRY_DLOPEN_SELF( lt_cv_dlopen_self=yes, lt_cv_dlopen_self=yes, lt_cv_dlopen_self=no, lt_cv_dlopen_self=cross) ]) if test yes = "$lt_cv_dlopen_self"; then wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $lt_prog_compiler_static\" AC_CACHE_CHECK([whether a statically linked program can dlopen itself], lt_cv_dlopen_self_static, [dnl _LT_TRY_DLOPEN_SELF( lt_cv_dlopen_self_static=yes, lt_cv_dlopen_self_static=yes, lt_cv_dlopen_self_static=no, lt_cv_dlopen_self_static=cross) ]) 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 _LT_DECL([dlopen_support], [enable_dlopen], [0], [Whether dlopen is supported]) _LT_DECL([dlopen_self], [enable_dlopen_self], [0], [Whether dlopen of programs is supported]) _LT_DECL([dlopen_self_static], [enable_dlopen_self_static], [0], [Whether dlopen of statically linked programs is supported]) ])# LT_SYS_DLOPEN_SELF # Old name: AU_ALIAS([AC_LIBTOOL_DLOPEN_SELF], [LT_SYS_DLOPEN_SELF]) dnl aclocal-1.4 backwards compatibility: dnl AC_DEFUN([AC_LIBTOOL_DLOPEN_SELF], []) # _LT_COMPILER_C_O([TAGNAME]) # --------------------------- # Check to see if options -c and -o are simultaneously supported by compiler. # This macro does not hard code the compiler like AC_PROG_CC_C_O. m4_defun([_LT_COMPILER_C_O], [m4_require([_LT_DECL_SED])dnl m4_require([_LT_FILEUTILS_DEFAULTS])dnl m4_require([_LT_TAG_COMPILER])dnl AC_CACHE_CHECK([if $compiler supports -c -o file.$ac_objext], [_LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)], [_LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)=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\"" >&AS_MESSAGE_LOG_FD) (eval "$lt_compile" 2>out/conftest.err) ac_status=$? cat out/conftest.err >&AS_MESSAGE_LOG_FD echo "$as_me:$LINENO: \$? = $ac_status" >&AS_MESSAGE_LOG_FD 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_TAGVAR(lt_cv_prog_compiler_c_o, $1)=yes fi fi chmod u+w . 2>&AS_MESSAGE_LOG_FD $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* ]) _LT_TAGDECL([compiler_c_o], [lt_cv_prog_compiler_c_o], [1], [Does compiler simultaneously support -c and -o options?]) ])# _LT_COMPILER_C_O # _LT_COMPILER_FILE_LOCKS([TAGNAME]) # ---------------------------------- # Check to see if we can do hard links to lock some files if needed m4_defun([_LT_COMPILER_FILE_LOCKS], [m4_require([_LT_ENABLE_LOCK])dnl m4_require([_LT_FILEUTILS_DEFAULTS])dnl _LT_COMPILER_C_O([$1]) hard_links=nottested if test no = "$_LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)" && test no != "$need_locks"; then # do not overwrite the value of need_locks provided by the user AC_MSG_CHECKING([if we can lock with hard links]) 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 AC_MSG_RESULT([$hard_links]) if test no = "$hard_links"; then AC_MSG_WARN(['$CC' does not support '-c -o', so 'make -j' may be unsafe]) need_locks=warn fi else need_locks=no fi _LT_DECL([], [need_locks], [1], [Must we lock files when doing compilation?]) ])# _LT_COMPILER_FILE_LOCKS # _LT_CHECK_OBJDIR # ---------------- m4_defun([_LT_CHECK_OBJDIR], [AC_CACHE_CHECK([for objdir], [lt_cv_objdir], [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]) objdir=$lt_cv_objdir _LT_DECL([], [objdir], [0], [The name of the directory that contains temporary libtool files])dnl m4_pattern_allow([LT_OBJDIR])dnl AC_DEFINE_UNQUOTED([LT_OBJDIR], "$lt_cv_objdir/", [Define to the sub-directory where libtool stores uninstalled libraries.]) ])# _LT_CHECK_OBJDIR # _LT_LINKER_HARDCODE_LIBPATH([TAGNAME]) # -------------------------------------- # Check hardcoding attributes. m4_defun([_LT_LINKER_HARDCODE_LIBPATH], [AC_MSG_CHECKING([how to hardcode library paths into programs]) _LT_TAGVAR(hardcode_action, $1)= if test -n "$_LT_TAGVAR(hardcode_libdir_flag_spec, $1)" || test -n "$_LT_TAGVAR(runpath_var, $1)" || test yes = "$_LT_TAGVAR(hardcode_automatic, $1)"; then # We can hardcode non-existent directories. if test no != "$_LT_TAGVAR(hardcode_direct, $1)" && # 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 no != "$_LT_TAGVAR(hardcode_shlibpath_var, $1)" && test no != "$_LT_TAGVAR(hardcode_minus_L, $1)"; then # Linking always hardcodes the temporary library directory. _LT_TAGVAR(hardcode_action, $1)=relink else # We can link without hardcoding, and we can hardcode nonexisting dirs. _LT_TAGVAR(hardcode_action, $1)=immediate fi else # We cannot hardcode anything, or else we can only hardcode existing # directories. _LT_TAGVAR(hardcode_action, $1)=unsupported fi AC_MSG_RESULT([$_LT_TAGVAR(hardcode_action, $1)]) if test relink = "$_LT_TAGVAR(hardcode_action, $1)" || test yes = "$_LT_TAGVAR(inherit_rpath, $1)"; then # Fast installation is not supported enable_fast_install=no elif test yes = "$shlibpath_overrides_runpath" || test no = "$enable_shared"; then # Fast installation is not necessary enable_fast_install=needless fi _LT_TAGDECL([], [hardcode_action], [0], [How to hardcode a shared library path into an executable]) ])# _LT_LINKER_HARDCODE_LIBPATH # _LT_CMD_STRIPLIB # ---------------- m4_defun([_LT_CMD_STRIPLIB], [m4_require([_LT_DECL_EGREP]) striplib= old_striplib= AC_MSG_CHECKING([whether stripping libraries is possible]) 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" AC_MSG_RESULT([yes]) 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" AC_MSG_RESULT([yes]) else AC_MSG_RESULT([no]) fi ;; *) AC_MSG_RESULT([no]) ;; esac fi _LT_DECL([], [old_striplib], [1], [Commands to strip libraries]) _LT_DECL([], [striplib], [1]) ])# _LT_CMD_STRIPLIB # _LT_PREPARE_MUNGE_PATH_LIST # --------------------------- # Make sure func_munge_path_list() is defined correctly. m4_defun([_LT_PREPARE_MUNGE_PATH_LIST], [[# func_munge_path_list VARIABLE PATH # ----------------------------------- # VARIABLE is name of variable containing _space_ separated list of # directories to be munged by the contents of PATH, which is string # having a format: # "DIR[:DIR]:" # string "DIR[ DIR]" will be prepended to VARIABLE # ":DIR[:DIR]" # string "DIR[ DIR]" will be appended to VARIABLE # "DIRP[:DIRP]::[DIRA:]DIRA" # string "DIRP[ DIRP]" will be prepended to VARIABLE and string # "DIRA[ DIRA]" will be appended to VARIABLE # "DIR[:DIR]" # VARIABLE will be replaced by "DIR[ DIR]" func_munge_path_list () { case x@S|@2 in x) ;; *:) eval @S|@1=\"`$ECHO @S|@2 | $SED 's/:/ /g'` \@S|@@S|@1\" ;; x:*) eval @S|@1=\"\@S|@@S|@1 `$ECHO @S|@2 | $SED 's/:/ /g'`\" ;; *::*) eval @S|@1=\"\@S|@@S|@1\ `$ECHO @S|@2 | $SED -e 's/.*:://' -e 's/:/ /g'`\" eval @S|@1=\"`$ECHO @S|@2 | $SED -e 's/::.*//' -e 's/:/ /g'`\ \@S|@@S|@1\" ;; *) eval @S|@1=\"`$ECHO @S|@2 | $SED 's/:/ /g'`\" ;; esac } ]])# _LT_PREPARE_PATH_LIST # _LT_SYS_DYNAMIC_LINKER([TAG]) # ----------------------------- # PORTME Fill in your ld.so characteristics m4_defun([_LT_SYS_DYNAMIC_LINKER], [AC_REQUIRE([AC_CANONICAL_HOST])dnl m4_require([_LT_DECL_EGREP])dnl m4_require([_LT_FILEUTILS_DEFAULTS])dnl m4_require([_LT_DECL_OBJDUMP])dnl m4_require([_LT_DECL_SED])dnl m4_require([_LT_CHECK_SHELL_FEATURES])dnl m4_require([_LT_PREPARE_MUNGE_PATH_LIST])dnl AC_MSG_CHECKING([dynamic linker characteristics]) m4_if([$1], [], [ if test yes = "$GCC"; 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` # ...but if some path component already ends with the multilib dir we assume # that all is fine and trust -print-search-dirs as is (GCC 4.2? or newer). case "$lt_multi_os_dir; $lt_search_path_spec " in "/; "* | "/.; "* | "/./; "* | *"$lt_multi_os_dir "* | *"$lt_multi_os_dir/ "*) lt_multi_os_dir= ;; esac 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" elif test -n "$lt_multi_os_dir"; then 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 AC_ARG_VAR([LT_SYS_LIBRARY_PATH], [User-defined run-time library search path.]) case $host_os in aix3*) version_type=linux # correct to gnu/linux during the next big refactor 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 # correct to gnu/linux during the next big refactor need_lib_prefix=no need_version=no hardcode_into_libs=yes if test ia64 = "$host_cpu"; 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 # Using Import Files as archive members, it is possible to support # filename-based versioning of shared library archives on AIX. While # this would work for both with and without runtime linking, it will # prevent static linking of such archives. So we do filename-based # shared library versioning with .so extension only, which is used # when both runtime linking and shared linking is enabled. # Unfortunately, runtime linking may impact performance, so we do # not want this to be the default eventually. Also, we use the # versioned .so libs for executables only if there is the -brtl # linker flag in LDFLAGS as well, or --with-aix-soname=svr4 only. # To allow for filename-based versioning support, we need to create # libNAME.so.V as an archive file, containing: # *) an Import File, referring to the versioned filename of the # archive as well as the shared archive member, telling the # bitwidth (32 or 64) of that shared object, and providing the # list of exported symbols of that shared object, eventually # decorated with the 'weak' keyword # *) the shared object with the F_LOADONLY flag set, to really avoid # it being seen by the linker. # At run time we better use the real file rather than another symlink, # but for link time we create the symlink libNAME.so -> libNAME.so.V case $with_aix_soname,$aix_use_runtimelinking in # AIX (on Power*) has no versioning support, so currently we cannot hardcode correct # soname into executable. Probably we can add versioning support to # collect2, so additional links can be useful in future. aix,yes) # traditional libtool dynamic_linker='AIX unversionable lib.so' # 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' ;; aix,no) # traditional AIX only dynamic_linker='AIX lib.a[(]lib.so.V[)]' # 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' ;; svr4,*) # full svr4 only dynamic_linker="AIX lib.so.V[(]$shared_archive_member_spec.o[)]" library_names_spec='$libname$release$shared_ext$major $libname$shared_ext' # We do not specify a path in Import Files, so LIBPATH fires. shlibpath_overrides_runpath=yes ;; *,yes) # both, prefer svr4 dynamic_linker="AIX lib.so.V[(]$shared_archive_member_spec.o[)], lib.a[(]lib.so.V[)]" library_names_spec='$libname$release$shared_ext$major $libname$shared_ext' # unpreferred sharedlib libNAME.a needs extra handling postinstall_cmds='test -n "$linkname" || linkname="$realname"~func_stripname "" ".so" "$linkname"~$install_shared_prog "$dir/$func_stripname_result.$libext" "$destdir/$func_stripname_result.$libext"~test -z "$tstripme" || test -z "$striplib" || $striplib "$destdir/$func_stripname_result.$libext"' postuninstall_cmds='for n in $library_names $old_library; do :; done~func_stripname "" ".so" "$n"~test "$func_stripname_result" = "$n" || func_append rmfiles " $odir/$func_stripname_result.$libext"' # We do not specify a path in Import Files, so LIBPATH fires. shlibpath_overrides_runpath=yes ;; *,no) # both, prefer aix dynamic_linker="AIX lib.a[(]lib.so.V[)], lib.so.V[(]$shared_archive_member_spec.o[)]" library_names_spec='$libname$release.a $libname.a' soname_spec='$libname$release$shared_ext$major' # unpreferred sharedlib libNAME.so.V and symlink libNAME.so need extra handling postinstall_cmds='test -z "$dlname" || $install_shared_prog $dir/$dlname $destdir/$dlname~test -z "$tstripme" || test -z "$striplib" || $striplib $destdir/$dlname~test -n "$linkname" || linkname=$realname~func_stripname "" ".a" "$linkname"~(cd "$destdir" && $LN_S -f $dlname $func_stripname_result.so)' postuninstall_cmds='test -z "$dlname" || func_append rmfiles " $odir/$dlname"~for n in $old_library $library_names; do :; done~func_stripname "" ".a" "$n"~func_append rmfiles " $odir/$func_stripname_result.so"' ;; esac 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%'\''`; $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 # correct to gnu/linux during the next big refactor 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' m4_if([$1], [],[ 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`' m4_if([$1], [],[ 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 # correct to gnu/linux during the next big refactor 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 ;; 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[[23]].*) 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$major $libname$shared_ext' soname_spec='$libname$release$shared_ext$major' 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 ;; haiku*) version_type=linux # correct to gnu/linux during the next big refactor 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=no 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 32 = "$HPUX_IA64_MODE"; then sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib" sys_lib_dlsearch_path_spec=/usr/lib/hpux32 else sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64" sys_lib_dlsearch_path_spec=/usr/lib/hpux64 fi ;; 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 # correct to gnu/linux during the next big refactor 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 yes = "$lt_cv_prog_gnu_ld"; then version_type=linux # correct to gnu/linux during the next big refactor 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 ;; linux*android*) version_type=none # Android doesn't support versioned libraries. need_lib_prefix=no need_version=no library_names_spec='$libname$release$shared_ext' soname_spec='$libname$release$shared_ext' finish_cmds= shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=yes # 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 dynamic_linker='Android linker' # Don't embed -rpath directories since the linker doesn't support them. _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' ;; # This must be glibc/ELF. linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*) version_type=linux # correct to gnu/linux during the next big refactor 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 AC_CACHE_VAL([lt_cv_shlibpath_overrides_runpath], [lt_cv_shlibpath_overrides_runpath=no save_LDFLAGS=$LDFLAGS save_libdir=$libdir eval "libdir=/foo; wl=\"$_LT_TAGVAR(lt_prog_compiler_wl, $1)\"; \ LDFLAGS=\"\$LDFLAGS $_LT_TAGVAR(hardcode_libdir_flag_spec, $1)\"" AC_LINK_IFELSE([AC_LANG_PROGRAM([],[])], [AS_IF([ ($OBJDUMP -p conftest$ac_exeext) 2>/dev/null | grep "RUNPATH.*$libdir" >/dev/null], [lt_cv_shlibpath_overrides_runpath=yes])]) LDFLAGS=$save_LDFLAGS libdir=$save_libdir ]) 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 # Ideally, we could use ldconfig to report *all* directores which are # searched for libraries, however this is still not possible. Aside from not # being certain /sbin/ldconfig is available, command # 'ldconfig -N -X -v | grep ^/' on 64bit Fedora does not report /usr/lib64, # even though it is searched at run-time. Try to do the best guess by # appending ld.so.conf contents (and includes) 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="/lib /usr/lib $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 # correct to gnu/linux during the next big refactor 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* | bitrig*) version_type=sunos sys_lib_dlsearch_path_spec=/usr/lib need_lib_prefix=no if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`"; then need_version=no else need_version=yes fi 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 shlibpath_overrides_runpath=yes ;; os2*) libname_spec='$name' version_type=windows shrext_cmds=.dll need_version=no need_lib_prefix=no # OS/2 can only load a DLL with a base name of 8 characters or less. soname_spec='`test -n "$os2dllname" && libname="$os2dllname"; v=$($ECHO $release$versuffix | tr -d .-); n=$($ECHO $libname | cut -b -$((8 - ${#v})) | tr . _); $ECHO $n$v`$shared_ext' library_names_spec='${libname}_dll.$libext' dynamic_linker='OS/2 ld.exe' shlibpath_var=BEGINLIBPATH sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib" sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec 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' ;; 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 # correct to gnu/linux during the next big refactor 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 yes = "$with_gnu_ld"; then need_lib_prefix=no fi need_version=yes ;; sysv4 | sysv4.3*) version_type=linux # correct to gnu/linux during the next big refactor 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 # correct to gnu/linux during the next big refactor 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=sco 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 yes = "$with_gnu_ld"; 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 # correct to gnu/linux during the next big refactor 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 # correct to gnu/linux during the next big refactor 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 AC_MSG_RESULT([$dynamic_linker]) test no = "$dynamic_linker" && can_build_shared=no variables_saved_for_relink="PATH $shlibpath_var $runpath_var" if test yes = "$GCC"; then variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH" fi if test set = "${lt_cv_sys_lib_search_path_spec+set}"; then sys_lib_search_path_spec=$lt_cv_sys_lib_search_path_spec fi if test set = "${lt_cv_sys_lib_dlsearch_path_spec+set}"; then sys_lib_dlsearch_path_spec=$lt_cv_sys_lib_dlsearch_path_spec fi # remember unaugmented sys_lib_dlsearch_path content for libtool script decls... configure_time_dlsearch_path=$sys_lib_dlsearch_path_spec # ... but it needs LT_SYS_LIBRARY_PATH munging for other configure-time code func_munge_path_list sys_lib_dlsearch_path_spec "$LT_SYS_LIBRARY_PATH" # to be used as default LT_SYS_LIBRARY_PATH value in generated libtool configure_time_lt_sys_library_path=$LT_SYS_LIBRARY_PATH _LT_DECL([], [variables_saved_for_relink], [1], [Variables whose values should be saved in libtool wrapper scripts and restored at link time]) _LT_DECL([], [need_lib_prefix], [0], [Do we need the "lib" prefix for modules?]) _LT_DECL([], [need_version], [0], [Do we need a version for libraries?]) _LT_DECL([], [version_type], [0], [Library versioning type]) _LT_DECL([], [runpath_var], [0], [Shared library runtime path variable]) _LT_DECL([], [shlibpath_var], [0],[Shared library path variable]) _LT_DECL([], [shlibpath_overrides_runpath], [0], [Is shlibpath searched before the hard-coded library search path?]) _LT_DECL([], [libname_spec], [1], [Format of library name prefix]) _LT_DECL([], [library_names_spec], [1], [[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]]) _LT_DECL([], [soname_spec], [1], [[The coded name of the library, if different from the real name]]) _LT_DECL([], [install_override_mode], [1], [Permission mode override for installation of shared libraries]) _LT_DECL([], [postinstall_cmds], [2], [Command to use after installation of a shared archive]) _LT_DECL([], [postuninstall_cmds], [2], [Command to use after uninstallation of a shared archive]) _LT_DECL([], [finish_cmds], [2], [Commands used to finish a libtool library installation in a directory]) _LT_DECL([], [finish_eval], [1], [[As "finish_cmds", except a single script fragment to be evaled but not shown]]) _LT_DECL([], [hardcode_into_libs], [0], [Whether we should hardcode library paths into libraries]) _LT_DECL([], [sys_lib_search_path_spec], [2], [Compile-time system search path for libraries]) _LT_DECL([sys_lib_dlsearch_path_spec], [configure_time_dlsearch_path], [2], [Detected run-time system search path for libraries]) _LT_DECL([], [configure_time_lt_sys_library_path], [2], [Explicit LT_SYS_LIBRARY_PATH set during ./configure time]) ])# _LT_SYS_DYNAMIC_LINKER # _LT_PATH_TOOL_PREFIX(TOOL) # -------------------------- # find a file program that can recognize shared library AC_DEFUN([_LT_PATH_TOOL_PREFIX], [m4_require([_LT_DECL_EGREP])dnl AC_MSG_CHECKING([for $1]) AC_CACHE_VAL(lt_cv_path_MAGIC_CMD, [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 dnl $ac_dummy forces splitting on constant user-supplied paths. dnl POSIX.2 word splitting is done only on the output of word expansions, dnl not every word. This closes a longstanding sh security hole. ac_dummy="m4_if([$2], , $PATH, [$2])" for ac_dir in $ac_dummy; do IFS=$lt_save_ifs test -z "$ac_dir" && ac_dir=. if test -f "$ac_dir/$1"; then lt_cv_path_MAGIC_CMD=$ac_dir/"$1" 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]) MAGIC_CMD=$lt_cv_path_MAGIC_CMD if test -n "$MAGIC_CMD"; then AC_MSG_RESULT($MAGIC_CMD) else AC_MSG_RESULT(no) fi _LT_DECL([], [MAGIC_CMD], [0], [Used to examine libraries when file_magic_cmd begins with "file"])dnl ])# _LT_PATH_TOOL_PREFIX # Old name: AU_ALIAS([AC_PATH_TOOL_PREFIX], [_LT_PATH_TOOL_PREFIX]) dnl aclocal-1.4 backwards compatibility: dnl AC_DEFUN([AC_PATH_TOOL_PREFIX], []) # _LT_PATH_MAGIC # -------------- # find a file program that can recognize a shared library m4_defun([_LT_PATH_MAGIC], [_LT_PATH_TOOL_PREFIX(${ac_tool_prefix}file, /usr/bin$PATH_SEPARATOR$PATH) if test -z "$lt_cv_path_MAGIC_CMD"; then if test -n "$ac_tool_prefix"; then _LT_PATH_TOOL_PREFIX(file, /usr/bin$PATH_SEPARATOR$PATH) else MAGIC_CMD=: fi fi ])# _LT_PATH_MAGIC # LT_PATH_LD # ---------- # find the pathname to the GNU or non-GNU linker AC_DEFUN([LT_PATH_LD], [AC_REQUIRE([AC_PROG_CC])dnl AC_REQUIRE([AC_CANONICAL_HOST])dnl AC_REQUIRE([AC_CANONICAL_BUILD])dnl m4_require([_LT_DECL_SED])dnl m4_require([_LT_DECL_EGREP])dnl m4_require([_LT_PROG_ECHO_BACKSLASH])dnl AC_ARG_WITH([gnu-ld], [AS_HELP_STRING([--with-gnu-ld], [assume the C compiler uses GNU ld @<:@default=no@:>@])], [test no = "$withval" || with_gnu_ld=yes], [with_gnu_ld=no])dnl ac_prog=ld if test yes = "$GCC"; then # Check if gcc -print-prog-name=ld gives a path. AC_MSG_CHECKING([for ld used by $CC]) 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 yes = "$with_gnu_ld"; then AC_MSG_CHECKING([for GNU ld]) else AC_MSG_CHECKING([for non-GNU ld]) fi AC_CACHE_VAL(lt_cv_path_LD, [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 &1 conftest.i cat conftest.i conftest.i >conftest2.i : ${lt_DD:=$DD} AC_PATH_PROGS_FEATURE_CHECK([lt_DD], [dd], [if "$ac_path_lt_DD" bs=32 count=1 conftest.out 2>/dev/null; then cmp -s conftest.i conftest.out \ && ac_cv_path_lt_DD="$ac_path_lt_DD" ac_path_lt_DD_found=: fi]) rm -f conftest.i conftest2.i conftest.out]) ])# _LT_PATH_DD # _LT_CMD_TRUNCATE # ---------------- # find command to truncate a binary pipe m4_defun([_LT_CMD_TRUNCATE], [m4_require([_LT_PATH_DD]) AC_CACHE_CHECK([how to truncate binary pipes], [lt_cv_truncate_bin], [printf 0123456789abcdef0123456789abcdef >conftest.i cat conftest.i conftest.i >conftest2.i lt_cv_truncate_bin= if "$ac_cv_path_lt_DD" bs=32 count=1 conftest.out 2>/dev/null; then cmp -s conftest.i conftest.out \ && lt_cv_truncate_bin="$ac_cv_path_lt_DD bs=4096 count=1" fi rm -f conftest.i conftest2.i conftest.out test -z "$lt_cv_truncate_bin" && lt_cv_truncate_bin="$SED -e 4q"]) _LT_DECL([lt_truncate_bin], [lt_cv_truncate_bin], [1], [Command to truncate a binary pipe]) ])# _LT_CMD_TRUNCATE # _LT_CHECK_MAGIC_METHOD # ---------------------- # how to check for library dependencies # -- PORTME fill in with the dynamic library characteristics m4_defun([_LT_CHECK_MAGIC_METHOD], [m4_require([_LT_DECL_EGREP]) m4_require([_LT_DECL_OBJDUMP]) AC_CACHE_CHECK([how to recognize dependent libraries], lt_cv_deplibs_check_method, [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 # that 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. if ( 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 ;; 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 glibc/ELF. linux* | k*bsd*-gnu | kopensolaris*-gnu | 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* | bitrig*) if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`"; 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 ;; os2*) lt_cv_deplibs_check_method=pass_all ;; esac ]) 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 _LT_DECL([], [deplibs_check_method], [1], [Method to check whether dependent libraries are shared objects]) _LT_DECL([], [file_magic_cmd], [1], [Command to use when deplibs_check_method = "file_magic"]) _LT_DECL([], [file_magic_glob], [1], [How to find potential files when deplibs_check_method = "file_magic"]) _LT_DECL([], [want_nocaseglob], [1], [Find potential files using nocaseglob when deplibs_check_method = "file_magic"]) ])# _LT_CHECK_MAGIC_METHOD # LT_PATH_NM # ---------- # find the pathname to a BSD- or MS-compatible name lister AC_DEFUN([LT_PATH_NM], [AC_REQUIRE([AC_PROG_CC])dnl AC_CACHE_CHECK([for BSD- or MS-compatible name lister (nm)], lt_cv_path_NM, [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 # MSYS converts /dev/null to NUL, MinGW nm treats NUL as empty case $build_os in mingw*) lt_bad_file=conftest.nm/nofile ;; *) lt_bad_file=/dev/null ;; esac case `"$tmp_nm" -B $lt_bad_file 2>&1 | sed '1q'` in *$lt_bad_file* | *'Invalid file or object type'*) lt_cv_path_NM="$tmp_nm -B" break 2 ;; *) case `"$tmp_nm" -p /dev/null 2>&1 | sed '1q'` in */dev/null*) lt_cv_path_NM="$tmp_nm -p" break 2 ;; *) 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]) if test no != "$lt_cv_path_NM"; 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 AC_CHECK_TOOLS(DUMPBIN, [dumpbin "link -dump"], :) case `$DUMPBIN -symbols -headers /dev/null 2>&1 | sed '1q'` in *COFF*) DUMPBIN="$DUMPBIN -symbols -headers" ;; *) DUMPBIN=: ;; esac fi AC_SUBST([DUMPBIN]) if test : != "$DUMPBIN"; then NM=$DUMPBIN fi fi test -z "$NM" && NM=nm AC_SUBST([NM]) _LT_DECL([], [NM], [1], [A BSD- or MS-compatible name lister])dnl AC_CACHE_CHECK([the name lister ($NM) interface], [lt_cv_nm_interface], [lt_cv_nm_interface="BSD nm" echo "int some_variable = 0;" > conftest.$ac_ext (eval echo "\"\$as_me:$LINENO: $ac_compile\"" >&AS_MESSAGE_LOG_FD) (eval "$ac_compile" 2>conftest.err) cat conftest.err >&AS_MESSAGE_LOG_FD (eval echo "\"\$as_me:$LINENO: $NM \\\"conftest.$ac_objext\\\"\"" >&AS_MESSAGE_LOG_FD) (eval "$NM \"conftest.$ac_objext\"" 2>conftest.err > conftest.out) cat conftest.err >&AS_MESSAGE_LOG_FD (eval echo "\"\$as_me:$LINENO: output\"" >&AS_MESSAGE_LOG_FD) cat conftest.out >&AS_MESSAGE_LOG_FD if $GREP 'External.*some_variable' conftest.out > /dev/null; then lt_cv_nm_interface="MS dumpbin" fi rm -f conftest*]) ])# LT_PATH_NM # Old names: AU_ALIAS([AM_PROG_NM], [LT_PATH_NM]) AU_ALIAS([AC_PROG_NM], [LT_PATH_NM]) dnl aclocal-1.4 backwards compatibility: dnl AC_DEFUN([AM_PROG_NM], []) dnl AC_DEFUN([AC_PROG_NM], []) # _LT_CHECK_SHAREDLIB_FROM_LINKLIB # -------------------------------- # how to determine the name of the shared library # associated with a specific link library. # -- PORTME fill in with the dynamic library characteristics m4_defun([_LT_CHECK_SHAREDLIB_FROM_LINKLIB], [m4_require([_LT_DECL_EGREP]) m4_require([_LT_DECL_OBJDUMP]) m4_require([_LT_DECL_DLLTOOL]) AC_CACHE_CHECK([how to associate runtime and link libraries], lt_cv_sharedlib_from_linklib_cmd, [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 one 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 ]) sharedlib_from_linklib_cmd=$lt_cv_sharedlib_from_linklib_cmd test -z "$sharedlib_from_linklib_cmd" && sharedlib_from_linklib_cmd=$ECHO _LT_DECL([], [sharedlib_from_linklib_cmd], [1], [Command to associate shared and link libraries]) ])# _LT_CHECK_SHAREDLIB_FROM_LINKLIB # _LT_PATH_MANIFEST_TOOL # ---------------------- # locate the manifest tool m4_defun([_LT_PATH_MANIFEST_TOOL], [AC_CHECK_TOOL(MANIFEST_TOOL, mt, :) test -z "$MANIFEST_TOOL" && MANIFEST_TOOL=mt AC_CACHE_CHECK([if $MANIFEST_TOOL is a manifest tool], [lt_cv_path_mainfest_tool], [lt_cv_path_mainfest_tool=no echo "$as_me:$LINENO: $MANIFEST_TOOL '-?'" >&AS_MESSAGE_LOG_FD $MANIFEST_TOOL '-?' 2>conftest.err > conftest.out cat conftest.err >&AS_MESSAGE_LOG_FD if $GREP 'Manifest Tool' conftest.out > /dev/null; then lt_cv_path_mainfest_tool=yes fi rm -f conftest*]) if test yes != "$lt_cv_path_mainfest_tool"; then MANIFEST_TOOL=: fi _LT_DECL([], [MANIFEST_TOOL], [1], [Manifest tool])dnl ])# _LT_PATH_MANIFEST_TOOL # _LT_DLL_DEF_P([FILE]) # --------------------- # True iff FILE is a Windows DLL '.def' file. # Keep in sync with func_dll_def_p in the libtool script AC_DEFUN([_LT_DLL_DEF_P], [dnl test DEF = "`$SED -n dnl -e '\''s/^[[ ]]*//'\'' dnl Strip leading whitespace -e '\''/^\(;.*\)*$/d'\'' dnl Delete empty lines and comments -e '\''s/^\(EXPORTS\|LIBRARY\)\([[ ]].*\)*$/DEF/p'\'' dnl -e q dnl Only consider the first "real" line $1`" dnl ])# _LT_DLL_DEF_P # LT_LIB_M # -------- # check for math library AC_DEFUN([LT_LIB_M], [AC_REQUIRE([AC_CANONICAL_HOST])dnl LIBM= case $host in *-*-beos* | *-*-cegcc* | *-*-cygwin* | *-*-haiku* | *-*-pw32* | *-*-darwin*) # These system don't have libm, or don't need it ;; *-ncr-sysv4.3*) AC_CHECK_LIB(mw, _mwvalidcheckl, LIBM=-lmw) AC_CHECK_LIB(m, cos, LIBM="$LIBM -lm") ;; *) AC_CHECK_LIB(m, cos, LIBM=-lm) ;; esac AC_SUBST([LIBM]) ])# LT_LIB_M # Old name: AU_ALIAS([AC_CHECK_LIBM], [LT_LIB_M]) dnl aclocal-1.4 backwards compatibility: dnl AC_DEFUN([AC_CHECK_LIBM], []) # _LT_COMPILER_NO_RTTI([TAGNAME]) # ------------------------------- m4_defun([_LT_COMPILER_NO_RTTI], [m4_require([_LT_TAG_COMPILER])dnl _LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)= if test yes = "$GCC"; then case $cc_basename in nvcc*) _LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=' -Xcompiler -fno-builtin' ;; *) _LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=' -fno-builtin' ;; esac _LT_COMPILER_OPTION([if $compiler supports -fno-rtti -fno-exceptions], lt_cv_prog_compiler_rtti_exceptions, [-fno-rtti -fno-exceptions], [], [_LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)="$_LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1) -fno-rtti -fno-exceptions"]) fi _LT_TAGDECL([no_builtin_flag], [lt_prog_compiler_no_builtin_flag], [1], [Compiler flag to turn off builtin functions]) ])# _LT_COMPILER_NO_RTTI # _LT_CMD_GLOBAL_SYMBOLS # ---------------------- m4_defun([_LT_CMD_GLOBAL_SYMBOLS], [AC_REQUIRE([AC_CANONICAL_HOST])dnl AC_REQUIRE([AC_PROG_CC])dnl AC_REQUIRE([AC_PROG_AWK])dnl AC_REQUIRE([LT_PATH_NM])dnl AC_REQUIRE([LT_PATH_LD])dnl m4_require([_LT_DECL_SED])dnl m4_require([_LT_DECL_EGREP])dnl m4_require([_LT_TAG_COMPILER])dnl # Check for command to grab the raw symbol name followed by C symbol from nm. AC_MSG_CHECKING([command to parse $NM output from $compiler object]) AC_CACHE_VAL([lt_cv_sys_global_symbol_pipe], [ # 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 ia64 = "$host_cpu"; 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 if test "$lt_cv_nm_interface" = "MS dumpbin"; then # Gets list of data symbols to import. lt_cv_sys_global_symbol_to_import="sed -n -e 's/^I .* \(.*\)$/\1/p'" # Adjust the below global symbol transforms to fixup imported variables. lt_cdecl_hook=" -e 's/^I .* \(.*\)$/extern __declspec(dllimport) char \1;/p'" lt_c_name_hook=" -e 's/^I .* \(.*\)$/ {\"\1\", (void *) 0},/p'" lt_c_name_lib_hook="\ -e 's/^I .* \(lib.*\)$/ {\"\1\", (void *) 0},/p'\ -e 's/^I .* \(.*\)$/ {\"lib\1\", (void *) 0},/p'" else # Disable hooks by default. lt_cv_sys_global_symbol_to_import= lt_cdecl_hook= lt_c_name_hook= lt_c_name_lib_hook= fi # 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"\ $lt_cdecl_hook\ " -e 's/^T .* \(.*\)$/extern int \1();/p'"\ " -e 's/^$symcode$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"\ $lt_c_name_hook\ " -e 's/^: \(.*\) .*$/ {\"\1\", (void *) 0},/p'"\ " -e 's/^$symcode$symcode* .* \(.*\)$/ {\"\1\", (void *) \&\1},/p'" # Transform an extracted symbol line into symbol name with lib prefix and # symbol address. lt_cv_sys_global_symbol_to_c_name_address_lib_prefix="sed -n"\ $lt_c_name_lib_hook\ " -e 's/^: \(.*\) .*$/ {\"\1\", (void *) 0},/p'"\ " -e 's/^$symcode$symcode* .* \(lib.*\)$/ {\"\1\", (void *) \&\1},/p'"\ " -e 's/^$symcode$symcode* .* \(.*\)$/ {\"lib\1\", (void *) \&\1},/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, # D for any global variable and I for any imported 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};"\ " /^COFF SYMBOL TABLE/{for(i in hide) delete hide[i]};"\ " /Section length .*#relocs.*(pick any)/{hide[last_section]=1};"\ " /^ *Symbol name *: /{split(\$ 0,sn,\":\"); si=substr(sn[2],2)};"\ " /^ *Type *: code/{print \"T\",si,substr(si,length(prfx))};"\ " /^ *Type *: data/{print \"I\",si,substr(si,length(prfx))};"\ " \$ 0!~/External *\|/{next};"\ " / 0+ UNDEF /{next}; / UNDEF \([^|]\)*()/{next};"\ " {if(hide[section]) next};"\ " {f=\"D\"}; \$ 0~/\(\).*\|/{f=\"T\"};"\ " {split(\$ 0,a,/\||\r/); split(a[2],s)};"\ " s[1]~/^[@?]/{print f,s[1],s[1]; next};"\ " s[1]~prfx {split(s[1],t,\"@\"); print f,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 AC_TRY_EVAL(ac_compile); then # Now try to grab the symbols. nlist=conftest.nm if AC_TRY_EVAL(NM conftest.$ac_objext \| "$lt_cv_sys_global_symbol_pipe" \> $nlist) && 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 can't be const, because runtime relocations are performed -- see ld's documentation on pseudo-relocs. */ # define LT@&t@_DLSYM_CONST #elif defined __osf__ /* This system does not cope well with relocations in const data. */ # define LT@&t@_DLSYM_CONST #else # define LT@&t@_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@&t@_DLSYM_CONST struct { const char *name; void *address; } lt__PROGRAM__LTX_preloaded_symbols[[]] = { { "@PROGRAM@", (void *) 0 }, _LT_EOF $SED "s/^$symcode$symcode* .* \(.*\)$/ {\"\1\", (void *) \&\1},/" < "$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_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)" if AC_TRY_EVAL(ac_link) && 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" >&AS_MESSAGE_LOG_FD fi else echo "cannot find nm_test_var in $nlist" >&AS_MESSAGE_LOG_FD fi else echo "cannot run $lt_cv_sys_global_symbol_pipe" >&AS_MESSAGE_LOG_FD fi else echo "$progname: failed program was:" >&AS_MESSAGE_LOG_FD cat conftest.$ac_ext >&5 fi rm -rf conftest* conftst* # Do not use the global_symbol_pipe unless it works. if test yes = "$pipe_works"; then break else lt_cv_sys_global_symbol_pipe= fi done ]) 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 AC_MSG_RESULT(failed) else AC_MSG_RESULT(ok) 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 _LT_DECL([global_symbol_pipe], [lt_cv_sys_global_symbol_pipe], [1], [Take the output of nm and produce a listing of raw symbols and C names]) _LT_DECL([global_symbol_to_cdecl], [lt_cv_sys_global_symbol_to_cdecl], [1], [Transform the output of nm in a proper C declaration]) _LT_DECL([global_symbol_to_import], [lt_cv_sys_global_symbol_to_import], [1], [Transform the output of nm into a list of symbols to manually relocate]) _LT_DECL([global_symbol_to_c_name_address], [lt_cv_sys_global_symbol_to_c_name_address], [1], [Transform the output of nm in a C name address pair]) _LT_DECL([global_symbol_to_c_name_address_lib_prefix], [lt_cv_sys_global_symbol_to_c_name_address_lib_prefix], [1], [Transform the output of nm in a C name address pair when lib prefix is needed]) _LT_DECL([nm_interface], [lt_cv_nm_interface], [1], [The name lister interface]) _LT_DECL([], [nm_file_list_spec], [1], [Specify filename containing input files for $NM]) ]) # _LT_CMD_GLOBAL_SYMBOLS # _LT_COMPILER_PIC([TAGNAME]) # --------------------------- m4_defun([_LT_COMPILER_PIC], [m4_require([_LT_TAG_COMPILER])dnl _LT_TAGVAR(lt_prog_compiler_wl, $1)= _LT_TAGVAR(lt_prog_compiler_pic, $1)= _LT_TAGVAR(lt_prog_compiler_static, $1)= m4_if([$1], [CXX], [ # C++ specific cases for pic, static, wl, etc. if test yes = "$GXX"; then _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' _LT_TAGVAR(lt_prog_compiler_static, $1)='-static' case $host_os in aix*) # All AIX code is PIC. if test ia64 = "$host_cpu"; then # AIX 5 now supports IA64 processor _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' fi _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' ;; amigaos*) case $host_cpu in powerpc) # see comment about AmigaOS4 .so support _LT_TAGVAR(lt_prog_compiler_pic, $1)='-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_TAGVAR(lt_prog_compiler_pic, $1)='-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 m4_if([$1], [GCJ], [], [_LT_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT']) case $host_os in os2*) _LT_TAGVAR(lt_prog_compiler_static, $1)='$wl-static' ;; esac ;; darwin* | rhapsody*) # PIC is the default on this platform # Common symbols not allowed in MH_DYLIB files _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fno-common' ;; *djgpp*) # DJGPP does not support shared libraries at all _LT_TAGVAR(lt_prog_compiler_pic, $1)= ;; haiku*) # PIC is the default for Haiku. # The "-static" flag exists, but is broken. _LT_TAGVAR(lt_prog_compiler_static, $1)= ;; 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_TAGVAR(lt_prog_compiler_pic, $1)=-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_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' ;; esac ;; *qnx* | *nto*) # QNX uses GNU C++, but need to define -shared option too, otherwise # it will coredump. _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC -shared' ;; *) _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' ;; esac else case $host_os in aix[[4-9]]*) # All AIX code is PIC. if test ia64 = "$host_cpu"; then # AIX 5 now supports IA64 processor _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' else _LT_TAGVAR(lt_prog_compiler_static, $1)='-bnso -bI:/lib/syscalls.exp' fi ;; chorus*) case $cc_basename in cxch68*) # Green Hills C++ Compiler # _LT_TAGVAR(lt_prog_compiler_static, $1)="--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). m4_if([$1], [GCJ], [], [_LT_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT']) ;; dgux*) case $cc_basename in ec++*) _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' ;; ghcx*) # Green Hills C++ Compiler _LT_TAGVAR(lt_prog_compiler_pic, $1)='-pic' ;; *) ;; esac ;; freebsd* | dragonfly*) # FreeBSD uses GNU C++ ;; hpux9* | hpux10* | hpux11*) case $cc_basename in CC*) _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' _LT_TAGVAR(lt_prog_compiler_static, $1)='$wl-a ${wl}archive' if test ia64 != "$host_cpu"; then _LT_TAGVAR(lt_prog_compiler_pic, $1)='+Z' fi ;; aCC*) _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' _LT_TAGVAR(lt_prog_compiler_static, $1)='$wl-a ${wl}archive' case $host_cpu in hppa*64*|ia64*) # +Z the default ;; *) _LT_TAGVAR(lt_prog_compiler_pic, $1)='+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_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared' # CC pic flag -KPIC is the default. ;; *) ;; esac ;; linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*) case $cc_basename in KCC*) # KAI C++ Compiler _LT_TAGVAR(lt_prog_compiler_wl, $1)='--backend -Wl,' _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' ;; ecpc* ) # old Intel C++ for x86_64, which still supported -KPIC. _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' _LT_TAGVAR(lt_prog_compiler_static, $1)='-static' ;; icpc* ) # Intel C++, used to be incompatible with GCC. # ICC 10 doesn't accept -KPIC any more. _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' _LT_TAGVAR(lt_prog_compiler_static, $1)='-static' ;; pgCC* | pgcpp*) # Portland Group C++ compiler _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fpic' _LT_TAGVAR(lt_prog_compiler_static, $1)='-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_TAGVAR(lt_prog_compiler_pic, $1)= _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared' ;; xlc* | xlC* | bgxl[[cC]]* | mpixl[[cC]]*) # IBM XL 8.0, 9.0 on PPC and BlueGene _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' _LT_TAGVAR(lt_prog_compiler_pic, $1)='-qpic' _LT_TAGVAR(lt_prog_compiler_static, $1)='-qstaticlink' ;; *) case `$CC -V 2>&1 | sed 5q` in *Sun\ C*) # Sun C++ 5.9 _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld ' ;; esac ;; esac ;; lynxos*) ;; m88k*) ;; mvs*) case $cc_basename in cxx*) _LT_TAGVAR(lt_prog_compiler_pic, $1)='-W c,exportall' ;; *) ;; esac ;; netbsd*) ;; *qnx* | *nto*) # QNX uses GNU C++, but need to define -shared option too, otherwise # it will coredump. _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC -shared' ;; osf3* | osf4* | osf5*) case $cc_basename in KCC*) _LT_TAGVAR(lt_prog_compiler_wl, $1)='--backend -Wl,' ;; RCC*) # Rational C++ 2.4.1 _LT_TAGVAR(lt_prog_compiler_pic, $1)='-pic' ;; cxx*) # Digital/Compaq C++ _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' # Make sure the PIC flag is empty. It appears that all Alpha # Linux and Compaq Tru64 Unix objects are PIC. _LT_TAGVAR(lt_prog_compiler_pic, $1)= _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared' ;; *) ;; esac ;; psos*) ;; solaris*) case $cc_basename in CC* | sunCC*) # Sun C++ 4.2, 5.x and Centerline C++ _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld ' ;; gcx*) # Green Hills C++ Compiler _LT_TAGVAR(lt_prog_compiler_pic, $1)='-PIC' ;; *) ;; esac ;; sunos4*) case $cc_basename in CC*) # Sun C++ 4.x _LT_TAGVAR(lt_prog_compiler_pic, $1)='-pic' _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' ;; lcc*) # Lucid _LT_TAGVAR(lt_prog_compiler_pic, $1)='-pic' ;; *) ;; esac ;; sysv5* | unixware* | sco3.2v5* | sco5v6* | OpenUNIX*) case $cc_basename in CC*) _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' ;; esac ;; tandem*) case $cc_basename in NCC*) # NonStop-UX NCC 3.20 _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' ;; *) ;; esac ;; vxworks*) ;; *) _LT_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no ;; esac fi ], [ if test yes = "$GCC"; then _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' _LT_TAGVAR(lt_prog_compiler_static, $1)='-static' case $host_os in aix*) # All AIX code is PIC. if test ia64 = "$host_cpu"; then # AIX 5 now supports IA64 processor _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' fi _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' ;; amigaos*) case $host_cpu in powerpc) # see comment about AmigaOS4 .so support _LT_TAGVAR(lt_prog_compiler_pic, $1)='-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_TAGVAR(lt_prog_compiler_pic, $1)='-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 m4_if([$1], [GCJ], [], [_LT_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT']) case $host_os in os2*) _LT_TAGVAR(lt_prog_compiler_static, $1)='$wl-static' ;; esac ;; darwin* | rhapsody*) # PIC is the default on this platform # Common symbols not allowed in MH_DYLIB files _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fno-common' ;; haiku*) # PIC is the default for Haiku. # The "-static" flag exists, but is broken. _LT_TAGVAR(lt_prog_compiler_static, $1)= ;; 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_TAGVAR(lt_prog_compiler_pic, $1)='-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_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no enable_shared=no ;; *nto* | *qnx*) # QNX uses GNU C++, but need to define -shared option too, otherwise # it will coredump. _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC -shared' ;; sysv4*MP*) if test -d /usr/nec; then _LT_TAGVAR(lt_prog_compiler_pic, $1)=-Kconform_pic fi ;; *) _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' ;; esac case $cc_basename in nvcc*) # Cuda Compiler Driver 2.2 _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Xlinker ' if test -n "$_LT_TAGVAR(lt_prog_compiler_pic, $1)"; then _LT_TAGVAR(lt_prog_compiler_pic, $1)="-Xcompiler $_LT_TAGVAR(lt_prog_compiler_pic, $1)" fi ;; esac else # PORTME Check for flag to pass linker flags through the system compiler. case $host_os in aix*) _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' if test ia64 = "$host_cpu"; then # AIX 5 now supports IA64 processor _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' else _LT_TAGVAR(lt_prog_compiler_static, $1)='-bnso -bI:/lib/syscalls.exp' fi ;; darwin* | rhapsody*) # PIC is the default on this platform # Common symbols not allowed in MH_DYLIB files _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fno-common' case $cc_basename in nagfor*) # NAG Fortran compiler _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,-Wl,,' _LT_TAGVAR(lt_prog_compiler_pic, $1)='-PIC' _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' ;; esac ;; 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). m4_if([$1], [GCJ], [], [_LT_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT']) case $host_os in os2*) _LT_TAGVAR(lt_prog_compiler_static, $1)='$wl-static' ;; esac ;; hpux9* | hpux10* | hpux11*) _LT_TAGVAR(lt_prog_compiler_wl, $1)='-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_TAGVAR(lt_prog_compiler_pic, $1)='+Z' ;; esac # Is there a better lt_prog_compiler_static that works with the bundled CC? _LT_TAGVAR(lt_prog_compiler_static, $1)='$wl-a ${wl}archive' ;; irix5* | irix6* | nonstopux*) _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' # PIC (with -KPIC) is the default. _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared' ;; linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*) case $cc_basename in # old Intel for x86_64, which still supported -KPIC. ecc*) _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' _LT_TAGVAR(lt_prog_compiler_static, $1)='-static' ;; # icc used to be incompatible with GCC. # ICC 10 doesn't accept -KPIC any more. icc* | ifort*) _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' _LT_TAGVAR(lt_prog_compiler_static, $1)='-static' ;; # Lahey Fortran 8.1. lf95*) _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' _LT_TAGVAR(lt_prog_compiler_pic, $1)='--shared' _LT_TAGVAR(lt_prog_compiler_static, $1)='--static' ;; nagfor*) # NAG Fortran compiler _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,-Wl,,' _LT_TAGVAR(lt_prog_compiler_pic, $1)='-PIC' _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' ;; tcc*) # Fabrice Bellard et al's Tiny C Compiler _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' _LT_TAGVAR(lt_prog_compiler_static, $1)='-static' ;; pgcc* | pgf77* | pgf90* | pgf95* | pgfortran*) # Portland Group compilers (*not* the Pentium gcc compiler, # which looks to be a dead project) _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fpic' _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' ;; ccc*) _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' # All Alpha code is PIC. _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared' ;; xl* | bgxl* | bgf* | mpixl*) # IBM XL C 8.0/Fortran 10.1, 11.1 on PPC and BlueGene _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' _LT_TAGVAR(lt_prog_compiler_pic, $1)='-qpic' _LT_TAGVAR(lt_prog_compiler_static, $1)='-qstaticlink' ;; *) case `$CC -V 2>&1 | sed 5q` in *Sun\ Ceres\ Fortran* | *Sun*Fortran*\ [[1-7]].* | *Sun*Fortran*\ 8.[[0-3]]*) # Sun Fortran 8.3 passes all unrecognized flags to the linker _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' _LT_TAGVAR(lt_prog_compiler_wl, $1)='' ;; *Sun\ F* | *Sun*Fortran*) _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld ' ;; *Sun\ C*) # Sun C 5.9 _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' ;; *Intel*\ [[CF]]*Compiler*) _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' _LT_TAGVAR(lt_prog_compiler_static, $1)='-static' ;; *Portland\ Group*) _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fpic' _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' ;; esac ;; esac ;; newsos6) _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' ;; *nto* | *qnx*) # QNX uses GNU C++, but need to define -shared option too, otherwise # it will coredump. _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC -shared' ;; osf3* | osf4* | osf5*) _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' # All OSF/1 code is PIC. _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared' ;; rdos*) _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared' ;; solaris*) _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' case $cc_basename in f77* | f90* | f95* | sunf77* | sunf90* | sunf95*) _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld ';; *) _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,';; esac ;; sunos4*) _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld ' _LT_TAGVAR(lt_prog_compiler_pic, $1)='-PIC' _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' ;; sysv4 | sysv4.2uw2* | sysv4.3*) _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' ;; sysv4*MP*) if test -d /usr/nec; then _LT_TAGVAR(lt_prog_compiler_pic, $1)='-Kconform_pic' _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' fi ;; sysv5* | unixware* | sco3.2v5* | sco5v6* | OpenUNIX*) _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' ;; unicos*) _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' _LT_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no ;; uts4*) _LT_TAGVAR(lt_prog_compiler_pic, $1)='-pic' _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' ;; *) _LT_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no ;; esac fi ]) case $host_os in # For platforms that do not support PIC, -DPIC is meaningless: *djgpp*) _LT_TAGVAR(lt_prog_compiler_pic, $1)= ;; *) _LT_TAGVAR(lt_prog_compiler_pic, $1)="$_LT_TAGVAR(lt_prog_compiler_pic, $1)@&t@m4_if([$1],[],[ -DPIC],[m4_if([$1],[CXX],[ -DPIC],[])])" ;; esac AC_CACHE_CHECK([for $compiler option to produce PIC], [_LT_TAGVAR(lt_cv_prog_compiler_pic, $1)], [_LT_TAGVAR(lt_cv_prog_compiler_pic, $1)=$_LT_TAGVAR(lt_prog_compiler_pic, $1)]) _LT_TAGVAR(lt_prog_compiler_pic, $1)=$_LT_TAGVAR(lt_cv_prog_compiler_pic, $1) # # Check to make sure the PIC flag actually works. # if test -n "$_LT_TAGVAR(lt_prog_compiler_pic, $1)"; then _LT_COMPILER_OPTION([if $compiler PIC flag $_LT_TAGVAR(lt_prog_compiler_pic, $1) works], [_LT_TAGVAR(lt_cv_prog_compiler_pic_works, $1)], [$_LT_TAGVAR(lt_prog_compiler_pic, $1)@&t@m4_if([$1],[],[ -DPIC],[m4_if([$1],[CXX],[ -DPIC],[])])], [], [case $_LT_TAGVAR(lt_prog_compiler_pic, $1) in "" | " "*) ;; *) _LT_TAGVAR(lt_prog_compiler_pic, $1)=" $_LT_TAGVAR(lt_prog_compiler_pic, $1)" ;; esac], [_LT_TAGVAR(lt_prog_compiler_pic, $1)= _LT_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no]) fi _LT_TAGDECL([pic_flag], [lt_prog_compiler_pic], [1], [Additional compiler flags for building library objects]) _LT_TAGDECL([wl], [lt_prog_compiler_wl], [1], [How to pass a linker flag through the compiler]) # # Check to make sure the static flag actually works. # wl=$_LT_TAGVAR(lt_prog_compiler_wl, $1) eval lt_tmp_static_flag=\"$_LT_TAGVAR(lt_prog_compiler_static, $1)\" _LT_LINKER_OPTION([if $compiler static flag $lt_tmp_static_flag works], _LT_TAGVAR(lt_cv_prog_compiler_static_works, $1), $lt_tmp_static_flag, [], [_LT_TAGVAR(lt_prog_compiler_static, $1)=]) _LT_TAGDECL([link_static_flag], [lt_prog_compiler_static], [1], [Compiler flag to prevent dynamic linking]) ])# _LT_COMPILER_PIC # _LT_LINKER_SHLIBS([TAGNAME]) # ---------------------------- # See if the linker supports building shared libraries. m4_defun([_LT_LINKER_SHLIBS], [AC_REQUIRE([LT_PATH_LD])dnl AC_REQUIRE([LT_PATH_NM])dnl m4_require([_LT_PATH_MANIFEST_TOOL])dnl m4_require([_LT_FILEUTILS_DEFAULTS])dnl m4_require([_LT_DECL_EGREP])dnl m4_require([_LT_DECL_SED])dnl m4_require([_LT_CMD_GLOBAL_SYMBOLS])dnl m4_require([_LT_TAG_COMPILER])dnl AC_MSG_CHECKING([whether the $compiler linker ($LD) supports shared libraries]) m4_if([$1], [CXX], [ _LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols' _LT_TAGVAR(exclude_expsyms, $1)=['_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 GNU nm, but means don't demangle to AIX nm. # Without the "-l" option, or with the "-B" option, AIX nm treats # weak defined symbols like other global defined symbols, whereas # GNU nm marks them as "W". # While the 'weak' keyword is ignored in the Export File, we need # it in the Import File for the 'aix-soname' feature, so we have # to replace the "-B" option with "-P" for AIX nm. if $NM -V 2>&1 | $GREP 'GNU' > /dev/null; then _LT_TAGVAR(export_symbols_cmds, $1)='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) && ([substr](\$ 3,1,1) != ".")) { if (\$ 2 == "W") { print \$ 3 " weak" } else { print \$ 3 } } }'\'' | sort -u > $export_symbols' else _LT_TAGVAR(export_symbols_cmds, $1)='`func_echo_all $NM | $SED -e '\''s/B\([[^B]]*\)$/P\1/'\''` -PCpgl $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) && ([substr](\$ 1,1,1) != ".")) { if ((\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) { print \$ 1 " weak" } else { print \$ 1 } } }'\'' | sort -u > $export_symbols' fi ;; pw32*) _LT_TAGVAR(export_symbols_cmds, $1)=$ltdll_cmds ;; cygwin* | mingw* | cegcc*) case $cc_basename in cl*) _LT_TAGVAR(exclude_expsyms, $1)='_NULL_IMPORT_DESCRIPTOR|_IMPORT_DESCRIPTOR_.*' ;; *) _LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[[BCDGRS]][[ ]]/s/.*[[ ]]\([[^ ]]*\)/\1 DATA/;s/^.*[[ ]]__nm__\([[^ ]]*\)[[ ]][[^ ]]*/\1 DATA/;/^I[[ ]]/d;/^[[AITW]][[ ]]/s/.* //'\'' | sort | uniq > $export_symbols' _LT_TAGVAR(exclude_expsyms, $1)=['[_]+GLOBAL_OFFSET_TABLE_|[_]+GLOBAL__[FID]_.*|[_]+head_[A-Za-z0-9_]+_dll|[A-Za-z0-9_]+_dll_iname'] ;; esac ;; *) _LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols' ;; esac ], [ runpath_var= _LT_TAGVAR(allow_undefined_flag, $1)= _LT_TAGVAR(always_export_symbols, $1)=no _LT_TAGVAR(archive_cmds, $1)= _LT_TAGVAR(archive_expsym_cmds, $1)= _LT_TAGVAR(compiler_needs_object, $1)=no _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=no _LT_TAGVAR(export_dynamic_flag_spec, $1)= _LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols' _LT_TAGVAR(hardcode_automatic, $1)=no _LT_TAGVAR(hardcode_direct, $1)=no _LT_TAGVAR(hardcode_direct_absolute, $1)=no _LT_TAGVAR(hardcode_libdir_flag_spec, $1)= _LT_TAGVAR(hardcode_libdir_separator, $1)= _LT_TAGVAR(hardcode_minus_L, $1)=no _LT_TAGVAR(hardcode_shlibpath_var, $1)=unsupported _LT_TAGVAR(inherit_rpath, $1)=no _LT_TAGVAR(link_all_deplibs, $1)=unknown _LT_TAGVAR(module_cmds, $1)= _LT_TAGVAR(module_expsym_cmds, $1)= _LT_TAGVAR(old_archive_from_new_cmds, $1)= _LT_TAGVAR(old_archive_from_expsyms_cmds, $1)= _LT_TAGVAR(thread_safe_flag_spec, $1)= _LT_TAGVAR(whole_archive_flag_spec, $1)= # include_expsyms should be a list of space-separated symbols to be *always* # included in the symbol list _LT_TAGVAR(include_expsyms, $1)= # 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'. _LT_TAGVAR(exclude_expsyms, $1)=['_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. dnl Note also adjust exclude_expsyms for C++ above. 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 yes != "$GCC"; then with_gnu_ld=no fi ;; interix*) # we just hope/assume this is gcc and not c89 (= MSVC++) with_gnu_ld=yes ;; openbsd* | bitrig*) with_gnu_ld=no ;; esac _LT_TAGVAR(ld_shlibs, $1)=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 yes = "$with_gnu_ld"; 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 yes = "$lt_use_gnu_ld_interface"; 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 _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir' _LT_TAGVAR(export_dynamic_flag_spec, $1)='$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 _LT_TAGVAR(whole_archive_flag_spec, $1)=$wlarc'--whole-archive$convenience '$wlarc'--no-whole-archive' else _LT_TAGVAR(whole_archive_flag_spec, $1)= fi supports_anon_versioning=no case `$LD -v | $SED -e 's/([^)]\+)\s\+//' 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 ia64 != "$host_cpu"; then _LT_TAGVAR(ld_shlibs, $1)=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 _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib' _LT_TAGVAR(archive_expsym_cmds, $1)='' ;; m68k) _LT_TAGVAR(archive_cmds, $1)='$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)' _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' _LT_TAGVAR(hardcode_minus_L, $1)=yes ;; esac ;; beos*) if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then _LT_TAGVAR(allow_undefined_flag, $1)=unsupported # Joseph Beckenbach says some releases of gcc # support --undefined. This deserves some investigation. FIXME _LT_TAGVAR(archive_cmds, $1)='$CC -nostart $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib' else _LT_TAGVAR(ld_shlibs, $1)=no fi ;; cygwin* | mingw* | pw32* | cegcc*) # _LT_TAGVAR(hardcode_libdir_flag_spec, $1) is actually meaningless, # as there is no search path for DLLs. _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl--export-all-symbols' _LT_TAGVAR(allow_undefined_flag, $1)=unsupported _LT_TAGVAR(always_export_symbols, $1)=no _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes _LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[[BCDGRS]][[ ]]/s/.*[[ ]]\([[^ ]]*\)/\1 DATA/;s/^.*[[ ]]__nm__\([[^ ]]*\)[[ ]][[^ ]]*/\1 DATA/;/^I[[ ]]/d;/^[[AITW]][[ ]]/s/.* //'\'' | sort | uniq > $export_symbols' _LT_TAGVAR(exclude_expsyms, $1)=['[_]+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 _LT_TAGVAR(archive_cmds, $1)='$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, use it as # is; otherwise, prepend EXPORTS... _LT_TAGVAR(archive_expsym_cmds, $1)='if _LT_DLL_DEF_P([$export_symbols]); 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 _LT_TAGVAR(ld_shlibs, $1)=no fi ;; haiku*) _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib' _LT_TAGVAR(link_all_deplibs, $1)=yes ;; os2*) _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' _LT_TAGVAR(hardcode_minus_L, $1)=yes _LT_TAGVAR(allow_undefined_flag, $1)=unsupported shrext_cmds=.dll _LT_TAGVAR(archive_cmds, $1)='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~ $ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~ $ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~ $ECHO EXPORTS >> $output_objdir/$libname.def~ emxexp $libobjs | $SED /"_DLL_InitTerm"/d >> $output_objdir/$libname.def~ $CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~ emximp -o $lib $output_objdir/$libname.def' _LT_TAGVAR(archive_expsym_cmds, $1)='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~ $ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~ $ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~ $ECHO EXPORTS >> $output_objdir/$libname.def~ prefix_cmds="$SED"~ if test EXPORTS = "`$SED 1q $export_symbols`"; then prefix_cmds="$prefix_cmds -e 1d"; fi~ prefix_cmds="$prefix_cmds -e \"s/^\(.*\)$/_\1/g\""~ cat $export_symbols | $prefix_cmds >> $output_objdir/$libname.def~ $CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~ emximp -o $lib $output_objdir/$libname.def' _LT_TAGVAR(old_archive_From_new_cmds, $1)='emximp -o $output_objdir/${libname}_dll.a $output_objdir/$libname.def' _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes ;; interix[[3-9]]*) _LT_TAGVAR(hardcode_direct, $1)=no _LT_TAGVAR(hardcode_shlibpath_var, $1)=no _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath,$libdir' _LT_TAGVAR(export_dynamic_flag_spec, $1)='$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. _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-h,$soname $wl--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib' _LT_TAGVAR(archive_expsym_cmds, $1)='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 linux-dietlibc = "$host_os"; 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 no = "$tmp_diet" then tmp_addflag=' $pic_flag' tmp_sharedflag='-shared' case $cc_basename,$host_cpu in pgcc*) # Portland Group C compiler _LT_TAGVAR(whole_archive_flag_spec, $1)='$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 _LT_TAGVAR(whole_archive_flag_spec, $1)='$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 _LT_TAGVAR(whole_archive_flag_spec, $1)= tmp_sharedflag='--shared' ;; nagfor*) # NAGFOR 5.3 tmp_sharedflag='-Wl,-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 _LT_TAGVAR(whole_archive_flag_spec, $1)='$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' _LT_TAGVAR(compiler_needs_object, $1)=yes ;; esac case `$CC -V 2>&1 | sed 5q` in *Sun\ C*) # Sun C 5.9 _LT_TAGVAR(whole_archive_flag_spec, $1)='$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' _LT_TAGVAR(compiler_needs_object, $1)=yes tmp_sharedflag='-G' ;; *Sun\ F*) # Sun Fortran 8.3 tmp_sharedflag='-G' ;; esac _LT_TAGVAR(archive_cmds, $1)='$CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib' if test yes = "$supports_anon_versioning"; then _LT_TAGVAR(archive_expsym_cmds, $1)='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 tcc*) _LT_TAGVAR(export_dynamic_flag_spec, $1)='-rdynamic' ;; xlf* | bgf* | bgxlf* | mpixlf*) # IBM XL Fortran 10.1 on PPC cannot create shared libs itself _LT_TAGVAR(whole_archive_flag_spec, $1)='--whole-archive$convenience --no-whole-archive' _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir' _LT_TAGVAR(archive_cmds, $1)='$LD -shared $libobjs $deplibs $linker_flags -soname $soname -o $lib' if test yes = "$supports_anon_versioning"; then _LT_TAGVAR(archive_expsym_cmds, $1)='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 _LT_TAGVAR(ld_shlibs, $1)=no fi ;; netbsd*) if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then _LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable $libobjs $deplibs $linker_flags -o $lib' wlarc= else _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib' _LT_TAGVAR(archive_expsym_cmds, $1)='$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 _LT_TAGVAR(ld_shlibs, $1)=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 _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib' _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib' else _LT_TAGVAR(ld_shlibs, $1)=no fi ;; sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX*) case `$LD -v 2>&1` in *\ [[01]].* | *\ 2.[[0-9]].* | *\ 2.1[[0-5]].*) _LT_TAGVAR(ld_shlibs, $1)=no cat <<_LT_EOF 1>&2 *** Warning: Releases of the GNU linker prior to 2.16.91.0.3 cannot *** 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 _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir' _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib' _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib' else _LT_TAGVAR(ld_shlibs, $1)=no fi ;; esac ;; sunos4*) _LT_TAGVAR(archive_cmds, $1)='$LD -assert pure-text -Bshareable -o $lib $libobjs $deplibs $linker_flags' wlarc= _LT_TAGVAR(hardcode_direct, $1)=yes _LT_TAGVAR(hardcode_shlibpath_var, $1)=no ;; *) if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib' _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib' else _LT_TAGVAR(ld_shlibs, $1)=no fi ;; esac if test no = "$_LT_TAGVAR(ld_shlibs, $1)"; then runpath_var= _LT_TAGVAR(hardcode_libdir_flag_spec, $1)= _LT_TAGVAR(export_dynamic_flag_spec, $1)= _LT_TAGVAR(whole_archive_flag_spec, $1)= fi else # PORTME fill in a description of your system's linker (not GNU ld) case $host_os in aix3*) _LT_TAGVAR(allow_undefined_flag, $1)=unsupported _LT_TAGVAR(always_export_symbols, $1)=yes _LT_TAGVAR(archive_expsym_cmds, $1)='$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. _LT_TAGVAR(hardcode_minus_L, $1)=yes if test yes = "$GCC" && test -z "$lt_prog_compiler_static"; then # Neither direct hardcoding nor static linking is supported with a # broken collect2. _LT_TAGVAR(hardcode_direct, $1)=unsupported fi ;; aix[[4-9]]*) if test ia64 = "$host_cpu"; 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 GNU nm, but means don't demangle to AIX nm. # Without the "-l" option, or with the "-B" option, AIX nm treats # weak defined symbols like other global defined symbols, whereas # GNU nm marks them as "W". # While the 'weak' keyword is ignored in the Export File, we need # it in the Import File for the 'aix-soname' feature, so we have # to replace the "-B" option with "-P" for AIX nm. if $NM -V 2>&1 | $GREP 'GNU' > /dev/null; then _LT_TAGVAR(export_symbols_cmds, $1)='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) && ([substr](\$ 3,1,1) != ".")) { if (\$ 2 == "W") { print \$ 3 " weak" } else { print \$ 3 } } }'\'' | sort -u > $export_symbols' else _LT_TAGVAR(export_symbols_cmds, $1)='`func_echo_all $NM | $SED -e '\''s/B\([[^B]]*\)$/P\1/'\''` -PCpgl $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) && ([substr](\$ 1,1,1) != ".")) { if ((\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) { print \$ 1 " weak" } else { print \$ 1 } } }'\'' | 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 # have runtime linking enabled, and use it for executables. # For shared libraries, we enable/disable runtime linking # depending on the kind of the shared library created - # when "with_aix_soname,aix_use_runtimelinking" is: # "aix,no" lib.a(lib.so.V) shared, rtl:no, for executables # "aix,yes" lib.so shared, rtl:yes, for executables # lib.a static archive # "both,no" lib.so.V(shr.o) shared, rtl:yes # lib.a(lib.so.V) shared, rtl:no, for executables # "both,yes" lib.so.V(shr.o) shared, rtl:yes, for executables # lib.a(lib.so.V) shared, rtl:no # "svr4,*" lib.so.V(shr.o) shared, rtl:yes, for executables # lib.a static archive case $host_os in aix4.[[23]]|aix4.[[23]].*|aix[[5-9]]*) for ld_flag in $LDFLAGS; do if (test x-brtl = "x$ld_flag" || test x-Wl,-brtl = "x$ld_flag"); then aix_use_runtimelinking=yes break fi done if test svr4,no = "$with_aix_soname,$aix_use_runtimelinking"; then # With aix-soname=svr4, we create the lib.so.V shared archives only, # so we don't have lib.a shared libs to link our executables. # We have to force runtime linking in this case. aix_use_runtimelinking=yes LDFLAGS="$LDFLAGS -Wl,-brtl" fi ;; 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. _LT_TAGVAR(archive_cmds, $1)='' _LT_TAGVAR(hardcode_direct, $1)=yes _LT_TAGVAR(hardcode_direct_absolute, $1)=yes _LT_TAGVAR(hardcode_libdir_separator, $1)=':' _LT_TAGVAR(link_all_deplibs, $1)=yes _LT_TAGVAR(file_list_spec, $1)='$wl-f,' case $with_aix_soname,$aix_use_runtimelinking in aix,*) ;; # traditional, no import file svr4,* | *,yes) # use import file # The Import File defines what to hardcode. _LT_TAGVAR(hardcode_direct, $1)=no _LT_TAGVAR(hardcode_direct_absolute, $1)=no ;; esac if test yes = "$GCC"; 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 _LT_TAGVAR(hardcode_direct, $1)=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 _LT_TAGVAR(hardcode_minus_L, $1)=yes _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' _LT_TAGVAR(hardcode_libdir_separator, $1)= fi ;; esac shared_flag='-shared' if test yes = "$aix_use_runtimelinking"; then shared_flag="$shared_flag "'$wl-G' fi # Need to ensure runtime linking is disabled for the traditional # shared library, or the linker may eventually find shared libraries # /with/ Import File - we do not want to mix them. shared_flag_aix='-shared' shared_flag_svr4='-shared $wl-G' else # not using gcc if test ia64 = "$host_cpu"; 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 yes = "$aix_use_runtimelinking"; then shared_flag='$wl-G' else shared_flag='$wl-bM:SRE' fi shared_flag_aix='$wl-bM:SRE' shared_flag_svr4='$wl-G' fi fi _LT_TAGVAR(export_dynamic_flag_spec, $1)='$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. _LT_TAGVAR(always_export_symbols, $1)=yes if test aix,yes = "$with_aix_soname,$aix_use_runtimelinking"; then # Warning - without using the other runtime loading flags (-brtl), # -berok will link without error, but may produce a broken library. _LT_TAGVAR(allow_undefined_flag, $1)='-berok' # Determine the default libpath from the value encoded in an # empty executable. _LT_SYS_MODULE_PATH_AIX([$1]) _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-blibpath:$libdir:'"$aix_libpath" _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -o $output_objdir/$soname $libobjs $deplibs $wl'$no_entry_flag' $compiler_flags `if test -n "$allow_undefined_flag"; then func_echo_all "$wl$allow_undefined_flag"; else :; fi` $wl'$exp_sym_flag:\$export_symbols' '$shared_flag else if test ia64 = "$host_cpu"; then _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-R $libdir:/usr/lib:/lib' _LT_TAGVAR(allow_undefined_flag, $1)="-z nodefs" _LT_TAGVAR(archive_expsym_cmds, $1)="\$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. _LT_SYS_MODULE_PATH_AIX([$1]) _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$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. _LT_TAGVAR(no_undefined_flag, $1)=' $wl-bernotok' _LT_TAGVAR(allow_undefined_flag, $1)=' $wl-berok' if test yes = "$with_gnu_ld"; then # We only use this code for GNU lds that support --whole-archive. _LT_TAGVAR(whole_archive_flag_spec, $1)='$wl--whole-archive$convenience $wl--no-whole-archive' else # Exported symbols can be pulled into shared objects from archives _LT_TAGVAR(whole_archive_flag_spec, $1)='$convenience' fi _LT_TAGVAR(archive_cmds_need_lc, $1)=yes _LT_TAGVAR(archive_expsym_cmds, $1)='$RM -r $output_objdir/$realname.d~$MKDIR $output_objdir/$realname.d' # -brtl affects multiple linker settings, -berok does not and is overridden later compiler_flags_filtered='`func_echo_all "$compiler_flags " | $SED -e "s%-brtl\\([[, ]]\\)%-berok\\1%g"`' if test svr4 != "$with_aix_soname"; then # This is similar to how AIX traditionally builds its shared libraries. _LT_TAGVAR(archive_expsym_cmds, $1)="$_LT_TAGVAR(archive_expsym_cmds, $1)"'~$CC '$shared_flag_aix' -o $output_objdir/$realname.d/$soname $libobjs $deplibs $wl-bnoentry '$compiler_flags_filtered'$wl-bE:$export_symbols$allow_undefined_flag~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$realname.d/$soname' fi if test aix != "$with_aix_soname"; then _LT_TAGVAR(archive_expsym_cmds, $1)="$_LT_TAGVAR(archive_expsym_cmds, $1)"'~$CC '$shared_flag_svr4' -o $output_objdir/$realname.d/$shared_archive_member_spec.o $libobjs $deplibs $wl-bnoentry '$compiler_flags_filtered'$wl-bE:$export_symbols$allow_undefined_flag~$STRIP -e $output_objdir/$realname.d/$shared_archive_member_spec.o~( func_echo_all "#! $soname($shared_archive_member_spec.o)"; if test shr_64 = "$shared_archive_member_spec"; then func_echo_all "# 64"; else func_echo_all "# 32"; fi; cat $export_symbols ) > $output_objdir/$realname.d/$shared_archive_member_spec.imp~$AR $AR_FLAGS $output_objdir/$soname $output_objdir/$realname.d/$shared_archive_member_spec.o $output_objdir/$realname.d/$shared_archive_member_spec.imp' else # used by -dlpreopen to get the symbols _LT_TAGVAR(archive_expsym_cmds, $1)="$_LT_TAGVAR(archive_expsym_cmds, $1)"'~$MV $output_objdir/$realname.d/$soname $output_objdir' fi _LT_TAGVAR(archive_expsym_cmds, $1)="$_LT_TAGVAR(archive_expsym_cmds, $1)"'~$RM -r $output_objdir/$realname.d' fi fi ;; amigaos*) case $host_cpu in powerpc) # see comment about AmigaOS4 .so support _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib' _LT_TAGVAR(archive_expsym_cmds, $1)='' ;; m68k) _LT_TAGVAR(archive_cmds, $1)='$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)' _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' _LT_TAGVAR(hardcode_minus_L, $1)=yes ;; esac ;; bsdi[[45]]*) _LT_TAGVAR(export_dynamic_flag_spec, $1)=-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 _LT_TAGVAR(hardcode_libdir_flag_spec, $1)=' ' _LT_TAGVAR(allow_undefined_flag, $1)=unsupported _LT_TAGVAR(always_export_symbols, $1)=yes _LT_TAGVAR(file_list_spec, $1)='@' # 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. _LT_TAGVAR(archive_cmds, $1)='$CC -o $output_objdir/$soname $libobjs $compiler_flags $deplibs -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~linknames=' _LT_TAGVAR(archive_expsym_cmds, $1)='if _LT_DLL_DEF_P([$export_symbols]); then cp "$export_symbols" "$output_objdir/$soname.def"; echo "$tool_output_objdir$soname.def" > "$output_objdir/$soname.exp"; else $SED -e '\''s/^/-link -EXPORT:/'\'' < $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, $1)='true' _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes _LT_TAGVAR(exclude_expsyms, $1)='_NULL_IMPORT_DESCRIPTOR|_IMPORT_DESCRIPTOR_.*' _LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[[BCDGRS]][[ ]]/s/.*[[ ]]\([[^ ]]*\)/\1,DATA/'\'' | $SED -e '\''/^[[AITW]][[ ]]/s/.*[[ ]]//'\'' | sort | uniq > $export_symbols' # Don't use ranlib _LT_TAGVAR(old_postinstall_cmds, $1)='chmod 644 $oldlib' _LT_TAGVAR(postlink_cmds, $1)='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 _LT_TAGVAR(hardcode_libdir_flag_spec, $1)=' ' _LT_TAGVAR(allow_undefined_flag, $1)=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. _LT_TAGVAR(archive_cmds, $1)='$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. _LT_TAGVAR(old_archive_from_new_cmds, $1)='true' # FIXME: Should let the user specify the lib program. _LT_TAGVAR(old_archive_cmds, $1)='lib -OUT:$oldlib$oldobjs$old_deplibs' _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes ;; esac ;; darwin* | rhapsody*) _LT_DARWIN_LINKER_FEATURES($1) ;; dgux*) _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' _LT_TAGVAR(hardcode_shlibpath_var, $1)=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*) _LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags /usr/lib/c++rt0.o' _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir' _LT_TAGVAR(hardcode_direct, $1)=yes _LT_TAGVAR(hardcode_shlibpath_var, $1)=no ;; # Unfortunately, older versions of FreeBSD 2 do not have this feature. freebsd2.*) _LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags' _LT_TAGVAR(hardcode_direct, $1)=yes _LT_TAGVAR(hardcode_minus_L, $1)=yes _LT_TAGVAR(hardcode_shlibpath_var, $1)=no ;; # FreeBSD 3 and greater uses gcc -shared to do shared libraries. freebsd* | dragonfly*) _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags' _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir' _LT_TAGVAR(hardcode_direct, $1)=yes _LT_TAGVAR(hardcode_shlibpath_var, $1)=no ;; hpux9*) if test yes = "$GCC"; then _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$CC -shared $pic_flag $wl+b $wl$install_libdir -o $output_objdir/$soname $libobjs $deplibs $compiler_flags~test "x$output_objdir/$soname" = "x$lib" || mv $output_objdir/$soname $lib' else _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$LD -b +b $install_libdir -o $output_objdir/$soname $libobjs $deplibs $linker_flags~test "x$output_objdir/$soname" = "x$lib" || mv $output_objdir/$soname $lib' fi _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl+b $wl$libdir' _LT_TAGVAR(hardcode_libdir_separator, $1)=: _LT_TAGVAR(hardcode_direct, $1)=yes # hardcode_minus_L: Not really in the search PATH, # but as the default location of the library. _LT_TAGVAR(hardcode_minus_L, $1)=yes _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-E' ;; hpux10*) if test yes,no = "$GCC,$with_gnu_ld"; then _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $wl+h $wl$soname $wl+b $wl$install_libdir -o $lib $libobjs $deplibs $compiler_flags' else _LT_TAGVAR(archive_cmds, $1)='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags' fi if test no = "$with_gnu_ld"; then _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl+b $wl$libdir' _LT_TAGVAR(hardcode_libdir_separator, $1)=: _LT_TAGVAR(hardcode_direct, $1)=yes _LT_TAGVAR(hardcode_direct_absolute, $1)=yes _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-E' # hardcode_minus_L: Not really in the search PATH, # but as the default location of the library. _LT_TAGVAR(hardcode_minus_L, $1)=yes fi ;; hpux11*) if test yes,no = "$GCC,$with_gnu_ld"; then case $host_cpu in hppa*64*) _LT_TAGVAR(archive_cmds, $1)='$CC -shared $wl+h $wl$soname -o $lib $libobjs $deplibs $compiler_flags' ;; ia64*) _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $wl+h $wl$soname $wl+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags' ;; *) _LT_TAGVAR(archive_cmds, $1)='$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*) _LT_TAGVAR(archive_cmds, $1)='$CC -b $wl+h $wl$soname -o $lib $libobjs $deplibs $compiler_flags' ;; ia64*) _LT_TAGVAR(archive_cmds, $1)='$CC -b $wl+h $wl$soname $wl+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags' ;; *) m4_if($1, [], [ # 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) _LT_LINKER_OPTION([if $CC understands -b], _LT_TAGVAR(lt_cv_prog_compiler__b, $1), [-b], [_LT_TAGVAR(archive_cmds, $1)='$CC -b $wl+h $wl$soname $wl+b $wl$install_libdir -o $lib $libobjs $deplibs $compiler_flags'], [_LT_TAGVAR(archive_cmds, $1)='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags'])], [_LT_TAGVAR(archive_cmds, $1)='$CC -b $wl+h $wl$soname $wl+b $wl$install_libdir -o $lib $libobjs $deplibs $compiler_flags']) ;; esac fi if test no = "$with_gnu_ld"; then _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl+b $wl$libdir' _LT_TAGVAR(hardcode_libdir_separator, $1)=: case $host_cpu in hppa*64*|ia64*) _LT_TAGVAR(hardcode_direct, $1)=no _LT_TAGVAR(hardcode_shlibpath_var, $1)=no ;; *) _LT_TAGVAR(hardcode_direct, $1)=yes _LT_TAGVAR(hardcode_direct_absolute, $1)=yes _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-E' # hardcode_minus_L: Not really in the search PATH, # but as the default location of the library. _LT_TAGVAR(hardcode_minus_L, $1)=yes ;; esac fi ;; irix5* | irix6* | nonstopux*) if test yes = "$GCC"; then _LT_TAGVAR(archive_cmds, $1)='$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. AC_CACHE_CHECK([whether the $host_os linker accepts -exported_symbol], [lt_cv_irix_exported_symbol], [save_LDFLAGS=$LDFLAGS LDFLAGS="$LDFLAGS -shared $wl-exported_symbol ${wl}foo $wl-update_registry $wl/dev/null" AC_LINK_IFELSE( [AC_LANG_SOURCE( [AC_LANG_CASE([C], [[int foo (void) { return 0; }]], [C++], [[int foo (void) { return 0; }]], [Fortran 77], [[ subroutine foo end]], [Fortran], [[ subroutine foo end]])])], [lt_cv_irix_exported_symbol=yes], [lt_cv_irix_exported_symbol=no]) LDFLAGS=$save_LDFLAGS]) if test yes = "$lt_cv_irix_exported_symbol"; then _LT_TAGVAR(archive_expsym_cmds, $1)='$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 _LT_TAGVAR(archive_cmds, $1)='$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' _LT_TAGVAR(archive_expsym_cmds, $1)='$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 _LT_TAGVAR(archive_cmds_need_lc, $1)='no' _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir' _LT_TAGVAR(hardcode_libdir_separator, $1)=: _LT_TAGVAR(inherit_rpath, $1)=yes _LT_TAGVAR(link_all_deplibs, $1)=yes ;; linux*) case $cc_basename in tcc*) # Fabrice Bellard et al's Tiny C Compiler _LT_TAGVAR(ld_shlibs, $1)=yes _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags' ;; esac ;; netbsd*) if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then _LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags' # a.out else _LT_TAGVAR(archive_cmds, $1)='$LD -shared -o $lib $libobjs $deplibs $linker_flags' # ELF fi _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir' _LT_TAGVAR(hardcode_direct, $1)=yes _LT_TAGVAR(hardcode_shlibpath_var, $1)=no ;; newsos6) _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' _LT_TAGVAR(hardcode_direct, $1)=yes _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir' _LT_TAGVAR(hardcode_libdir_separator, $1)=: _LT_TAGVAR(hardcode_shlibpath_var, $1)=no ;; *nto* | *qnx*) ;; openbsd* | bitrig*) if test -f /usr/libexec/ld.so; then _LT_TAGVAR(hardcode_direct, $1)=yes _LT_TAGVAR(hardcode_shlibpath_var, $1)=no _LT_TAGVAR(hardcode_direct_absolute, $1)=yes if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`"; then _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags' _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags $wl-retain-symbols-file,$export_symbols' _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath,$libdir' _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-E' else _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags' _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath,$libdir' fi else _LT_TAGVAR(ld_shlibs, $1)=no fi ;; os2*) _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' _LT_TAGVAR(hardcode_minus_L, $1)=yes _LT_TAGVAR(allow_undefined_flag, $1)=unsupported shrext_cmds=.dll _LT_TAGVAR(archive_cmds, $1)='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~ $ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~ $ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~ $ECHO EXPORTS >> $output_objdir/$libname.def~ emxexp $libobjs | $SED /"_DLL_InitTerm"/d >> $output_objdir/$libname.def~ $CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~ emximp -o $lib $output_objdir/$libname.def' _LT_TAGVAR(archive_expsym_cmds, $1)='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~ $ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~ $ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~ $ECHO EXPORTS >> $output_objdir/$libname.def~ prefix_cmds="$SED"~ if test EXPORTS = "`$SED 1q $export_symbols`"; then prefix_cmds="$prefix_cmds -e 1d"; fi~ prefix_cmds="$prefix_cmds -e \"s/^\(.*\)$/_\1/g\""~ cat $export_symbols | $prefix_cmds >> $output_objdir/$libname.def~ $CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~ emximp -o $lib $output_objdir/$libname.def' _LT_TAGVAR(old_archive_From_new_cmds, $1)='emximp -o $output_objdir/${libname}_dll.a $output_objdir/$libname.def' _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes ;; osf3*) if test yes = "$GCC"; then _LT_TAGVAR(allow_undefined_flag, $1)=' $wl-expect_unresolved $wl\*' _LT_TAGVAR(archive_cmds, $1)='$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 _LT_TAGVAR(allow_undefined_flag, $1)=' -expect_unresolved \*' _LT_TAGVAR(archive_cmds, $1)='$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 _LT_TAGVAR(archive_cmds_need_lc, $1)='no' _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir' _LT_TAGVAR(hardcode_libdir_separator, $1)=: ;; osf4* | osf5*) # as osf3* with the addition of -msym flag if test yes = "$GCC"; then _LT_TAGVAR(allow_undefined_flag, $1)=' $wl-expect_unresolved $wl\*' _LT_TAGVAR(archive_cmds, $1)='$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' _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir' else _LT_TAGVAR(allow_undefined_flag, $1)=' -expect_unresolved \*' _LT_TAGVAR(archive_cmds, $1)='$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' _LT_TAGVAR(archive_expsym_cmds, $1)='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 _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-rpath $libdir' fi _LT_TAGVAR(archive_cmds_need_lc, $1)='no' _LT_TAGVAR(hardcode_libdir_separator, $1)=: ;; solaris*) _LT_TAGVAR(no_undefined_flag, $1)=' -z defs' if test yes = "$GCC"; then wlarc='$wl' _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $wl-z ${wl}text $wl-h $wl$soname -o $lib $libobjs $deplibs $compiler_flags' _LT_TAGVAR(archive_expsym_cmds, $1)='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='' _LT_TAGVAR(archive_cmds, $1)='$LD -G$allow_undefined_flag -h $soname -o $lib $libobjs $deplibs $linker_flags' _LT_TAGVAR(archive_expsym_cmds, $1)='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' _LT_TAGVAR(archive_cmds, $1)='$CC -G$allow_undefined_flag -h $soname -o $lib $libobjs $deplibs $compiler_flags' _LT_TAGVAR(archive_expsym_cmds, $1)='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 _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir' _LT_TAGVAR(hardcode_shlibpath_var, $1)=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 yes = "$GCC"; then _LT_TAGVAR(whole_archive_flag_spec, $1)='$wl-z ${wl}allextract$convenience $wl-z ${wl}defaultextract' else _LT_TAGVAR(whole_archive_flag_spec, $1)='-z allextract$convenience -z defaultextract' fi ;; esac _LT_TAGVAR(link_all_deplibs, $1)=yes ;; sunos4*) if test sequent = "$host_vendor"; then # Use $CC to link under sequent, because it throws in some extra .o # files that make .init and .fini sections work. _LT_TAGVAR(archive_cmds, $1)='$CC -G $wl-h $soname -o $lib $libobjs $deplibs $compiler_flags' else _LT_TAGVAR(archive_cmds, $1)='$LD -assert pure-text -Bstatic -o $lib $libobjs $deplibs $linker_flags' fi _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' _LT_TAGVAR(hardcode_direct, $1)=yes _LT_TAGVAR(hardcode_minus_L, $1)=yes _LT_TAGVAR(hardcode_shlibpath_var, $1)=no ;; sysv4) case $host_vendor in sni) _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' _LT_TAGVAR(hardcode_direct, $1)=yes # is this really true??? ;; siemens) ## LD is ld it makes a PLAMLIB ## CC just makes a GrossModule. _LT_TAGVAR(archive_cmds, $1)='$LD -G -o $lib $libobjs $deplibs $linker_flags' _LT_TAGVAR(reload_cmds, $1)='$CC -r -o $output$reload_objs' _LT_TAGVAR(hardcode_direct, $1)=no ;; motorola) _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' _LT_TAGVAR(hardcode_direct, $1)=no #Motorola manual says yes, but my tests say they lie ;; esac runpath_var='LD_RUN_PATH' _LT_TAGVAR(hardcode_shlibpath_var, $1)=no ;; sysv4.3*) _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' _LT_TAGVAR(hardcode_shlibpath_var, $1)=no _LT_TAGVAR(export_dynamic_flag_spec, $1)='-Bexport' ;; sysv4*MP*) if test -d /usr/nec; then _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' _LT_TAGVAR(hardcode_shlibpath_var, $1)=no runpath_var=LD_RUN_PATH hardcode_runpath_var=yes _LT_TAGVAR(ld_shlibs, $1)=yes fi ;; sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[[01]].[[10]]* | unixware7* | sco3.2v5.0.[[024]]*) _LT_TAGVAR(no_undefined_flag, $1)='$wl-z,text' _LT_TAGVAR(archive_cmds_need_lc, $1)=no _LT_TAGVAR(hardcode_shlibpath_var, $1)=no runpath_var='LD_RUN_PATH' if test yes = "$GCC"; then _LT_TAGVAR(archive_cmds, $1)='$CC -shared $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags' _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags' else _LT_TAGVAR(archive_cmds, $1)='$CC -G $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags' _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags' fi ;; sysv5* | sco3.2v5* | sco5v6*) # Note: We CANNOT 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. _LT_TAGVAR(no_undefined_flag, $1)='$wl-z,text' _LT_TAGVAR(allow_undefined_flag, $1)='$wl-z,nodefs' _LT_TAGVAR(archive_cmds_need_lc, $1)=no _LT_TAGVAR(hardcode_shlibpath_var, $1)=no _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-R,$libdir' _LT_TAGVAR(hardcode_libdir_separator, $1)=':' _LT_TAGVAR(link_all_deplibs, $1)=yes _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-Bexport' runpath_var='LD_RUN_PATH' if test yes = "$GCC"; then _LT_TAGVAR(archive_cmds, $1)='$CC -shared $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags' _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags' else _LT_TAGVAR(archive_cmds, $1)='$CC -G $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags' _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags' fi ;; uts4*) _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' _LT_TAGVAR(hardcode_shlibpath_var, $1)=no ;; *) _LT_TAGVAR(ld_shlibs, $1)=no ;; esac if test sni = "$host_vendor"; then case $host in sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*) _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-Blargedynsym' ;; esac fi fi ]) AC_MSG_RESULT([$_LT_TAGVAR(ld_shlibs, $1)]) test no = "$_LT_TAGVAR(ld_shlibs, $1)" && can_build_shared=no _LT_TAGVAR(with_gnu_ld, $1)=$with_gnu_ld _LT_DECL([], [libext], [0], [Old archive suffix (normally "a")])dnl _LT_DECL([], [shrext_cmds], [1], [Shared library suffix (normally ".so")])dnl _LT_DECL([], [extract_expsyms_cmds], [2], [The commands to extract the exported symbol list from a shared archive]) # # Do we need to explicitly link libc? # case "x$_LT_TAGVAR(archive_cmds_need_lc, $1)" in x|xyes) # Assume -lc should be added _LT_TAGVAR(archive_cmds_need_lc, $1)=yes if test yes,yes = "$GCC,$enable_shared"; then case $_LT_TAGVAR(archive_cmds, $1) 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. AC_CACHE_CHECK([whether -lc should be explicitly linked in], [lt_cv_]_LT_TAGVAR(archive_cmds_need_lc, $1), [$RM conftest* echo "$lt_simple_compile_test_code" > conftest.$ac_ext if AC_TRY_EVAL(ac_compile) 2>conftest.err; then soname=conftest lib=conftest libobjs=conftest.$ac_objext deplibs= wl=$_LT_TAGVAR(lt_prog_compiler_wl, $1) pic_flag=$_LT_TAGVAR(lt_prog_compiler_pic, $1) compiler_flags=-v linker_flags=-v verstring= output_objdir=. libname=conftest lt_save_allow_undefined_flag=$_LT_TAGVAR(allow_undefined_flag, $1) _LT_TAGVAR(allow_undefined_flag, $1)= if AC_TRY_EVAL(_LT_TAGVAR(archive_cmds, $1) 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1) then lt_cv_[]_LT_TAGVAR(archive_cmds_need_lc, $1)=no else lt_cv_[]_LT_TAGVAR(archive_cmds_need_lc, $1)=yes fi _LT_TAGVAR(allow_undefined_flag, $1)=$lt_save_allow_undefined_flag else cat conftest.err 1>&5 fi $RM conftest* ]) _LT_TAGVAR(archive_cmds_need_lc, $1)=$lt_cv_[]_LT_TAGVAR(archive_cmds_need_lc, $1) ;; esac fi ;; esac _LT_TAGDECL([build_libtool_need_lc], [archive_cmds_need_lc], [0], [Whether or not to add -lc for building shared libraries]) _LT_TAGDECL([allow_libtool_libs_with_static_runtimes], [enable_shared_with_static_runtimes], [0], [Whether or not to disallow shared libs when runtime libs are static]) _LT_TAGDECL([], [export_dynamic_flag_spec], [1], [Compiler flag to allow reflexive dlopens]) _LT_TAGDECL([], [whole_archive_flag_spec], [1], [Compiler flag to generate shared objects directly from archives]) _LT_TAGDECL([], [compiler_needs_object], [1], [Whether the compiler copes with passing no objects directly]) _LT_TAGDECL([], [old_archive_from_new_cmds], [2], [Create an old-style archive from a shared archive]) _LT_TAGDECL([], [old_archive_from_expsyms_cmds], [2], [Create a temporary old-style archive to link instead of a shared archive]) _LT_TAGDECL([], [archive_cmds], [2], [Commands used to build a shared archive]) _LT_TAGDECL([], [archive_expsym_cmds], [2]) _LT_TAGDECL([], [module_cmds], [2], [Commands used to build a loadable module if different from building a shared archive.]) _LT_TAGDECL([], [module_expsym_cmds], [2]) _LT_TAGDECL([], [with_gnu_ld], [1], [Whether we are building with GNU ld or not]) _LT_TAGDECL([], [allow_undefined_flag], [1], [Flag that allows shared libraries with undefined symbols to be built]) _LT_TAGDECL([], [no_undefined_flag], [1], [Flag that enforces no undefined symbols]) _LT_TAGDECL([], [hardcode_libdir_flag_spec], [1], [Flag to hardcode $libdir into a binary during linking. This must work even if $libdir does not exist]) _LT_TAGDECL([], [hardcode_libdir_separator], [1], [Whether we need a single "-rpath" flag with a separated argument]) _LT_TAGDECL([], [hardcode_direct], [0], [Set to "yes" if using DIR/libNAME$shared_ext during linking hardcodes DIR into the resulting binary]) _LT_TAGDECL([], [hardcode_direct_absolute], [0], [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]) _LT_TAGDECL([], [hardcode_minus_L], [0], [Set to "yes" if using the -LDIR flag during linking hardcodes DIR into the resulting binary]) _LT_TAGDECL([], [hardcode_shlibpath_var], [0], [Set to "yes" if using SHLIBPATH_VAR=DIR during linking hardcodes DIR into the resulting binary]) _LT_TAGDECL([], [hardcode_automatic], [0], [Set to "yes" if building a shared library automatically hardcodes DIR into the library and all subsequent libraries and executables linked against it]) _LT_TAGDECL([], [inherit_rpath], [0], [Set to yes if linker adds runtime paths of dependent libraries to runtime path list]) _LT_TAGDECL([], [link_all_deplibs], [0], [Whether libtool must link a program against all its dependency libraries]) _LT_TAGDECL([], [always_export_symbols], [0], [Set to "yes" if exported symbols are required]) _LT_TAGDECL([], [export_symbols_cmds], [2], [The commands to list exported symbols]) _LT_TAGDECL([], [exclude_expsyms], [1], [Symbols that should not be listed in the preloaded symbols]) _LT_TAGDECL([], [include_expsyms], [1], [Symbols that must always be exported]) _LT_TAGDECL([], [prelink_cmds], [2], [Commands necessary for linking programs (against libraries) with templates]) _LT_TAGDECL([], [postlink_cmds], [2], [Commands necessary for finishing linking programs]) _LT_TAGDECL([], [file_list_spec], [1], [Specify filename containing input files]) dnl FIXME: Not yet implemented dnl _LT_TAGDECL([], [thread_safe_flag_spec], [1], dnl [Compiler flag to generate thread safe objects]) ])# _LT_LINKER_SHLIBS # _LT_LANG_C_CONFIG([TAG]) # ------------------------ # Ensure that the configuration variables for a C compiler are suitably # defined. These variables are subsequently used by _LT_CONFIG to write # the compiler configuration to 'libtool'. m4_defun([_LT_LANG_C_CONFIG], [m4_require([_LT_DECL_EGREP])dnl lt_save_CC=$CC AC_LANG_PUSH(C) # Source file extension for C test sources. ac_ext=c # Object file extension for compiled C test sources. objext=o _LT_TAGVAR(objext, $1)=$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);}' _LT_TAG_COMPILER # 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 _LT_COMPILER_BOILERPLATE _LT_LINKER_BOILERPLATE ## 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_COMPILER_NO_RTTI($1) _LT_COMPILER_PIC($1) _LT_COMPILER_C_O($1) _LT_COMPILER_FILE_LOCKS($1) _LT_LINKER_SHLIBS($1) _LT_SYS_DYNAMIC_LINKER($1) _LT_LINKER_HARDCODE_LIBPATH($1) LT_SYS_DLOPEN_SELF _LT_CMD_STRIPLIB # Report what library types will actually be built AC_MSG_CHECKING([if libtool supports shared libraries]) AC_MSG_RESULT([$can_build_shared]) AC_MSG_CHECKING([whether to build shared libraries]) test no = "$can_build_shared" && 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 yes = "$enable_shared" && enable_static=no if test -n "$RANLIB"; then archive_cmds="$archive_cmds~\$RANLIB \$lib" postinstall_cmds='$RANLIB $lib' fi ;; aix[[4-9]]*) if test ia64 != "$host_cpu"; then case $enable_shared,$with_aix_soname,$aix_use_runtimelinking in yes,aix,yes) ;; # shared object as lib.so file only yes,svr4,*) ;; # shared object as lib.so archive member only yes,*) enable_static=no ;; # shared object in lib.a archive as well esac fi ;; esac AC_MSG_RESULT([$enable_shared]) AC_MSG_CHECKING([whether to build static libraries]) # Make sure either enable_shared or enable_static is yes. test yes = "$enable_shared" || enable_static=yes AC_MSG_RESULT([$enable_static]) _LT_CONFIG($1) fi AC_LANG_POP CC=$lt_save_CC ])# _LT_LANG_C_CONFIG # _LT_LANG_CXX_CONFIG([TAG]) # -------------------------- # Ensure that the configuration variables for a C++ compiler are suitably # defined. These variables are subsequently used by _LT_CONFIG to write # the compiler configuration to 'libtool'. m4_defun([_LT_LANG_CXX_CONFIG], [m4_require([_LT_FILEUTILS_DEFAULTS])dnl m4_require([_LT_DECL_EGREP])dnl m4_require([_LT_PATH_MANIFEST_TOOL])dnl if test -n "$CXX" && ( test no != "$CXX" && ( (test g++ = "$CXX" && `g++ -v >/dev/null 2>&1` ) || (test g++ != "$CXX"))); then AC_PROG_CXXCPP else _lt_caught_CXX_error=yes fi AC_LANG_PUSH(C++) _LT_TAGVAR(archive_cmds_need_lc, $1)=no _LT_TAGVAR(allow_undefined_flag, $1)= _LT_TAGVAR(always_export_symbols, $1)=no _LT_TAGVAR(archive_expsym_cmds, $1)= _LT_TAGVAR(compiler_needs_object, $1)=no _LT_TAGVAR(export_dynamic_flag_spec, $1)= _LT_TAGVAR(hardcode_direct, $1)=no _LT_TAGVAR(hardcode_direct_absolute, $1)=no _LT_TAGVAR(hardcode_libdir_flag_spec, $1)= _LT_TAGVAR(hardcode_libdir_separator, $1)= _LT_TAGVAR(hardcode_minus_L, $1)=no _LT_TAGVAR(hardcode_shlibpath_var, $1)=unsupported _LT_TAGVAR(hardcode_automatic, $1)=no _LT_TAGVAR(inherit_rpath, $1)=no _LT_TAGVAR(module_cmds, $1)= _LT_TAGVAR(module_expsym_cmds, $1)= _LT_TAGVAR(link_all_deplibs, $1)=unknown _LT_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds _LT_TAGVAR(reload_flag, $1)=$reload_flag _LT_TAGVAR(reload_cmds, $1)=$reload_cmds _LT_TAGVAR(no_undefined_flag, $1)= _LT_TAGVAR(whole_archive_flag_spec, $1)= _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=no # Source file extension for C++ test sources. ac_ext=cpp # Object file extension for compiled C++ test sources. objext=o _LT_TAGVAR(objext, $1)=$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 yes != "$_lt_caught_CXX_error"; 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. _LT_TAG_COMPILER # save warnings/boilerplate of simple test code _LT_COMPILER_BOILERPLATE _LT_LINKER_BOILERPLATE # 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 _LT_TAGVAR(compiler, $1)=$CC _LT_CC_BASENAME([$compiler]) if test -n "$compiler"; then # We don't want -fno-exception when compiling C++ code, so set the # no_builtin_flag separately if test yes = "$GXX"; then _LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=' -fno-builtin' else _LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)= fi if test yes = "$GXX"; then # Set up default GNU C++ configuration LT_PATH_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 yes = "$with_gnu_ld"; then _LT_TAGVAR(archive_cmds, $1)='$CC $pic_flag -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname -o $lib' _LT_TAGVAR(archive_expsym_cmds, $1)='$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' _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir' _LT_TAGVAR(export_dynamic_flag_spec, $1)='$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 _LT_TAGVAR(whole_archive_flag_spec, $1)=$wlarc'--whole-archive$convenience '$wlarc'--no-whole-archive' else _LT_TAGVAR(whole_archive_flag_spec, $1)= 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. _LT_TAGVAR(archive_cmds, $1)='$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 AC_MSG_CHECKING([whether the $compiler linker ($LD) supports shared libraries]) _LT_TAGVAR(ld_shlibs, $1)=yes case $host_os in aix3*) # FIXME: insert proper C++ library support _LT_TAGVAR(ld_shlibs, $1)=no ;; aix[[4-9]]*) if test ia64 = "$host_cpu"; 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 # have runtime linking enabled, and use it for executables. # For shared libraries, we enable/disable runtime linking # depending on the kind of the shared library created - # when "with_aix_soname,aix_use_runtimelinking" is: # "aix,no" lib.a(lib.so.V) shared, rtl:no, for executables # "aix,yes" lib.so shared, rtl:yes, for executables # lib.a static archive # "both,no" lib.so.V(shr.o) shared, rtl:yes # lib.a(lib.so.V) shared, rtl:no, for executables # "both,yes" lib.so.V(shr.o) shared, rtl:yes, for executables # lib.a(lib.so.V) shared, rtl:no # "svr4,*" lib.so.V(shr.o) shared, rtl:yes, for executables # lib.a static archive 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 if test svr4,no = "$with_aix_soname,$aix_use_runtimelinking"; then # With aix-soname=svr4, we create the lib.so.V shared archives only, # so we don't have lib.a shared libs to link our executables. # We have to force runtime linking in this case. aix_use_runtimelinking=yes LDFLAGS="$LDFLAGS -Wl,-brtl" fi ;; 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. _LT_TAGVAR(archive_cmds, $1)='' _LT_TAGVAR(hardcode_direct, $1)=yes _LT_TAGVAR(hardcode_direct_absolute, $1)=yes _LT_TAGVAR(hardcode_libdir_separator, $1)=':' _LT_TAGVAR(link_all_deplibs, $1)=yes _LT_TAGVAR(file_list_spec, $1)='$wl-f,' case $with_aix_soname,$aix_use_runtimelinking in aix,*) ;; # no import file svr4,* | *,yes) # use import file # The Import File defines what to hardcode. _LT_TAGVAR(hardcode_direct, $1)=no _LT_TAGVAR(hardcode_direct_absolute, $1)=no ;; esac if test yes = "$GXX"; 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 _LT_TAGVAR(hardcode_direct, $1)=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 _LT_TAGVAR(hardcode_minus_L, $1)=yes _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' _LT_TAGVAR(hardcode_libdir_separator, $1)= fi esac shared_flag='-shared' if test yes = "$aix_use_runtimelinking"; then shared_flag=$shared_flag' $wl-G' fi # Need to ensure runtime linking is disabled for the traditional # shared library, or the linker may eventually find shared libraries # /with/ Import File - we do not want to mix them. shared_flag_aix='-shared' shared_flag_svr4='-shared $wl-G' else # not using gcc if test ia64 = "$host_cpu"; 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 yes = "$aix_use_runtimelinking"; then shared_flag='$wl-G' else shared_flag='$wl-bM:SRE' fi shared_flag_aix='$wl-bM:SRE' shared_flag_svr4='$wl-G' fi fi _LT_TAGVAR(export_dynamic_flag_spec, $1)='$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. _LT_TAGVAR(always_export_symbols, $1)=yes if test aix,yes = "$with_aix_soname,$aix_use_runtimelinking"; then # Warning - without using the other runtime loading flags (-brtl), # -berok will link without error, but may produce a broken library. # The "-G" linker flag allows undefined symbols. _LT_TAGVAR(no_undefined_flag, $1)='-bernotok' # Determine the default libpath from the value encoded in an empty # executable. _LT_SYS_MODULE_PATH_AIX([$1]) _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-blibpath:$libdir:'"$aix_libpath" _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -o $output_objdir/$soname $libobjs $deplibs $wl'$no_entry_flag' $compiler_flags `if test -n "$allow_undefined_flag"; then func_echo_all "$wl$allow_undefined_flag"; else :; fi` $wl'$exp_sym_flag:\$export_symbols' '$shared_flag else if test ia64 = "$host_cpu"; then _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-R $libdir:/usr/lib:/lib' _LT_TAGVAR(allow_undefined_flag, $1)="-z nodefs" _LT_TAGVAR(archive_expsym_cmds, $1)="\$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. _LT_SYS_MODULE_PATH_AIX([$1]) _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$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. _LT_TAGVAR(no_undefined_flag, $1)=' $wl-bernotok' _LT_TAGVAR(allow_undefined_flag, $1)=' $wl-berok' if test yes = "$with_gnu_ld"; then # We only use this code for GNU lds that support --whole-archive. _LT_TAGVAR(whole_archive_flag_spec, $1)='$wl--whole-archive$convenience $wl--no-whole-archive' else # Exported symbols can be pulled into shared objects from archives _LT_TAGVAR(whole_archive_flag_spec, $1)='$convenience' fi _LT_TAGVAR(archive_cmds_need_lc, $1)=yes _LT_TAGVAR(archive_expsym_cmds, $1)='$RM -r $output_objdir/$realname.d~$MKDIR $output_objdir/$realname.d' # -brtl affects multiple linker settings, -berok does not and is overridden later compiler_flags_filtered='`func_echo_all "$compiler_flags " | $SED -e "s%-brtl\\([[, ]]\\)%-berok\\1%g"`' if test svr4 != "$with_aix_soname"; then # This is similar to how AIX traditionally builds its shared # libraries. Need -bnortl late, we may have -brtl in LDFLAGS. _LT_TAGVAR(archive_expsym_cmds, $1)="$_LT_TAGVAR(archive_expsym_cmds, $1)"'~$CC '$shared_flag_aix' -o $output_objdir/$realname.d/$soname $libobjs $deplibs $wl-bnoentry '$compiler_flags_filtered'$wl-bE:$export_symbols$allow_undefined_flag~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$realname.d/$soname' fi if test aix != "$with_aix_soname"; then _LT_TAGVAR(archive_expsym_cmds, $1)="$_LT_TAGVAR(archive_expsym_cmds, $1)"'~$CC '$shared_flag_svr4' -o $output_objdir/$realname.d/$shared_archive_member_spec.o $libobjs $deplibs $wl-bnoentry '$compiler_flags_filtered'$wl-bE:$export_symbols$allow_undefined_flag~$STRIP -e $output_objdir/$realname.d/$shared_archive_member_spec.o~( func_echo_all "#! $soname($shared_archive_member_spec.o)"; if test shr_64 = "$shared_archive_member_spec"; then func_echo_all "# 64"; else func_echo_all "# 32"; fi; cat $export_symbols ) > $output_objdir/$realname.d/$shared_archive_member_spec.imp~$AR $AR_FLAGS $output_objdir/$soname $output_objdir/$realname.d/$shared_archive_member_spec.o $output_objdir/$realname.d/$shared_archive_member_spec.imp' else # used by -dlpreopen to get the symbols _LT_TAGVAR(archive_expsym_cmds, $1)="$_LT_TAGVAR(archive_expsym_cmds, $1)"'~$MV $output_objdir/$realname.d/$soname $output_objdir' fi _LT_TAGVAR(archive_expsym_cmds, $1)="$_LT_TAGVAR(archive_expsym_cmds, $1)"'~$RM -r $output_objdir/$realname.d' fi fi ;; beos*) if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then _LT_TAGVAR(allow_undefined_flag, $1)=unsupported # Joseph Beckenbach says some releases of gcc # support --undefined. This deserves some investigation. FIXME _LT_TAGVAR(archive_cmds, $1)='$CC -nostart $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib' else _LT_TAGVAR(ld_shlibs, $1)=no fi ;; chorus*) case $cc_basename in *) # FIXME: insert proper C++ library support _LT_TAGVAR(ld_shlibs, $1)=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. _LT_TAGVAR(hardcode_libdir_flag_spec, $1)=' ' _LT_TAGVAR(allow_undefined_flag, $1)=unsupported _LT_TAGVAR(always_export_symbols, $1)=yes _LT_TAGVAR(file_list_spec, $1)='@' # 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. _LT_TAGVAR(archive_cmds, $1)='$CC -o $output_objdir/$soname $libobjs $compiler_flags $deplibs -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~linknames=' _LT_TAGVAR(archive_expsym_cmds, $1)='if _LT_DLL_DEF_P([$export_symbols]); then cp "$export_symbols" "$output_objdir/$soname.def"; echo "$tool_output_objdir$soname.def" > "$output_objdir/$soname.exp"; else $SED -e '\''s/^/-link -EXPORT:/'\'' < $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, $1)='true' _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes # Don't use ranlib _LT_TAGVAR(old_postinstall_cmds, $1)='chmod 644 $oldlib' _LT_TAGVAR(postlink_cmds, $1)='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, $1) is actually meaningless, # as there is no search path for DLLs. _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl--export-all-symbols' _LT_TAGVAR(allow_undefined_flag, $1)=unsupported _LT_TAGVAR(always_export_symbols, $1)=no _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes if $LD --help 2>&1 | $GREP 'auto-import' > /dev/null; then _LT_TAGVAR(archive_cmds, $1)='$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, use it as # is; otherwise, prepend EXPORTS... _LT_TAGVAR(archive_expsym_cmds, $1)='if _LT_DLL_DEF_P([$export_symbols]); 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 _LT_TAGVAR(ld_shlibs, $1)=no fi ;; esac ;; darwin* | rhapsody*) _LT_DARWIN_LINKER_FEATURES($1) ;; os2*) _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' _LT_TAGVAR(hardcode_minus_L, $1)=yes _LT_TAGVAR(allow_undefined_flag, $1)=unsupported shrext_cmds=.dll _LT_TAGVAR(archive_cmds, $1)='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~ $ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~ $ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~ $ECHO EXPORTS >> $output_objdir/$libname.def~ emxexp $libobjs | $SED /"_DLL_InitTerm"/d >> $output_objdir/$libname.def~ $CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~ emximp -o $lib $output_objdir/$libname.def' _LT_TAGVAR(archive_expsym_cmds, $1)='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~ $ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~ $ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~ $ECHO EXPORTS >> $output_objdir/$libname.def~ prefix_cmds="$SED"~ if test EXPORTS = "`$SED 1q $export_symbols`"; then prefix_cmds="$prefix_cmds -e 1d"; fi~ prefix_cmds="$prefix_cmds -e \"s/^\(.*\)$/_\1/g\""~ cat $export_symbols | $prefix_cmds >> $output_objdir/$libname.def~ $CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~ emximp -o $lib $output_objdir/$libname.def' _LT_TAGVAR(old_archive_From_new_cmds, $1)='emximp -o $output_objdir/${libname}_dll.a $output_objdir/$libname.def' _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes ;; dgux*) case $cc_basename in ec++*) # FIXME: insert proper C++ library support _LT_TAGVAR(ld_shlibs, $1)=no ;; ghcx*) # Green Hills C++ Compiler # FIXME: insert proper C++ library support _LT_TAGVAR(ld_shlibs, $1)=no ;; *) # FIXME: insert proper C++ library support _LT_TAGVAR(ld_shlibs, $1)=no ;; esac ;; freebsd2.*) # C++ shared libraries reported to be fairly broken before # switch to ELF _LT_TAGVAR(ld_shlibs, $1)=no ;; freebsd-elf*) _LT_TAGVAR(archive_cmds_need_lc, $1)=no ;; freebsd* | dragonfly*) # FreeBSD 3 and later use GNU C++ and GNU ld with standard ELF # conventions _LT_TAGVAR(ld_shlibs, $1)=yes ;; haiku*) _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib' _LT_TAGVAR(link_all_deplibs, $1)=yes ;; hpux9*) _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl+b $wl$libdir' _LT_TAGVAR(hardcode_libdir_separator, $1)=: _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-E' _LT_TAGVAR(hardcode_direct, $1)=yes _LT_TAGVAR(hardcode_minus_L, $1)=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 _LT_TAGVAR(ld_shlibs, $1)=no ;; aCC*) _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$CC -b $wl+b $wl$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test "x$output_objdir/$soname" = "x$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 yes = "$GXX"; then _LT_TAGVAR(archive_cmds, $1)='$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 "x$output_objdir/$soname" = "x$lib" || mv $output_objdir/$soname $lib' else # FIXME: insert proper C++ library support _LT_TAGVAR(ld_shlibs, $1)=no fi ;; esac ;; hpux10*|hpux11*) if test no = "$with_gnu_ld"; then _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl+b $wl$libdir' _LT_TAGVAR(hardcode_libdir_separator, $1)=: case $host_cpu in hppa*64*|ia64*) ;; *) _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-E' ;; esac fi case $host_cpu in hppa*64*|ia64*) _LT_TAGVAR(hardcode_direct, $1)=no _LT_TAGVAR(hardcode_shlibpath_var, $1)=no ;; *) _LT_TAGVAR(hardcode_direct, $1)=yes _LT_TAGVAR(hardcode_direct_absolute, $1)=yes _LT_TAGVAR(hardcode_minus_L, $1)=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 _LT_TAGVAR(ld_shlibs, $1)=no ;; aCC*) case $host_cpu in hppa*64*) _LT_TAGVAR(archive_cmds, $1)='$CC -b $wl+h $wl$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' ;; ia64*) _LT_TAGVAR(archive_cmds, $1)='$CC -b $wl+h $wl$soname $wl+nodefaultrpath -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' ;; *) _LT_TAGVAR(archive_cmds, $1)='$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 yes = "$GXX"; then if test no = "$with_gnu_ld"; then case $host_cpu in hppa*64*) _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib -fPIC $wl+h $wl$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' ;; ia64*) _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $pic_flag $wl+h $wl$soname $wl+nodefaultrpath -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' ;; *) _LT_TAGVAR(archive_cmds, $1)='$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 _LT_TAGVAR(ld_shlibs, $1)=no fi ;; esac ;; interix[[3-9]]*) _LT_TAGVAR(hardcode_direct, $1)=no _LT_TAGVAR(hardcode_shlibpath_var, $1)=no _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath,$libdir' _LT_TAGVAR(export_dynamic_flag_spec, $1)='$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. _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-h,$soname $wl--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib' _LT_TAGVAR(archive_expsym_cmds, $1)='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++ _LT_TAGVAR(archive_cmds, $1)='$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. _LT_TAGVAR(old_archive_cmds, $1)='$CC -ar -WR,-u -o $oldlib $oldobjs' ;; *) if test yes = "$GXX"; then if test no = "$with_gnu_ld"; then _LT_TAGVAR(archive_cmds, $1)='$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 _LT_TAGVAR(archive_cmds, $1)='$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 _LT_TAGVAR(link_all_deplibs, $1)=yes ;; esac _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir' _LT_TAGVAR(hardcode_libdir_separator, $1)=: _LT_TAGVAR(inherit_rpath, $1)=yes ;; linux* | k*bsd*-gnu | kopensolaris*-gnu | 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. _LT_TAGVAR(archive_cmds, $1)='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' _LT_TAGVAR(archive_expsym_cmds, $1)='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"' _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath,$libdir' _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl--export-dynamic' # Archives containing C++ object files must be created using # "CC -Bstatic", where "CC" is the KAI C++ compiler. _LT_TAGVAR(old_archive_cmds, $1)='$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."*) _LT_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname -o $lib' _LT_TAGVAR(archive_expsym_cmds, $1)='$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 _LT_TAGVAR(archive_cmds, $1)='$CC -shared'"$tmp_idyn"' $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib' _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared'"$tmp_idyn"' $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib' ;; esac _LT_TAGVAR(archive_cmds_need_lc, $1)=no _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath,$libdir' _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl--export-dynamic' _LT_TAGVAR(whole_archive_flag_spec, $1)='$wl--whole-archive$convenience $wl--no-whole-archive' ;; pgCC* | pgcpp*) # Portland Group C++ compiler case `$CC -V` in *pgCC\ [[1-5]].* | *pgcpp\ [[1-5]].*) _LT_TAGVAR(prelink_cmds, $1)='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`"' _LT_TAGVAR(old_archive_cmds, $1)='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' _LT_TAGVAR(archive_cmds, $1)='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' _LT_TAGVAR(archive_expsym_cmds, $1)='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 _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname -o $lib' _LT_TAGVAR(archive_expsym_cmds, $1)='$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 _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl--rpath $wl$libdir' _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl--export-dynamic' _LT_TAGVAR(whole_archive_flag_spec, $1)='$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++ _LT_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname -o $lib' _LT_TAGVAR(archive_expsym_cmds, $1)='$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 _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-rpath $libdir' _LT_TAGVAR(hardcode_libdir_separator, $1)=: # 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 _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir' _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl--export-dynamic' _LT_TAGVAR(archive_cmds, $1)='$CC -qmkshrobj $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib' if test yes = "$supports_anon_versioning"; then _LT_TAGVAR(archive_expsym_cmds, $1)='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 _LT_TAGVAR(no_undefined_flag, $1)=' -zdefs' _LT_TAGVAR(archive_cmds, $1)='$CC -G$allow_undefined_flag -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G$allow_undefined_flag -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-retain-symbols-file $wl$export_symbols' _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir' _LT_TAGVAR(whole_archive_flag_spec, $1)='$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' _LT_TAGVAR(compiler_needs_object, $1)=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. _LT_TAGVAR(old_archive_cmds, $1)='$CC -xar -o $oldlib $oldobjs' ;; esac ;; esac ;; lynxos*) # FIXME: insert proper C++ library support _LT_TAGVAR(ld_shlibs, $1)=no ;; m88k*) # FIXME: insert proper C++ library support _LT_TAGVAR(ld_shlibs, $1)=no ;; mvs*) case $cc_basename in cxx*) # FIXME: insert proper C++ library support _LT_TAGVAR(ld_shlibs, $1)=no ;; *) # FIXME: insert proper C++ library support _LT_TAGVAR(ld_shlibs, $1)=no ;; esac ;; netbsd*) if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then _LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $predep_objects $libobjs $deplibs $postdep_objects $linker_flags' wlarc= _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir' _LT_TAGVAR(hardcode_direct, $1)=yes _LT_TAGVAR(hardcode_shlibpath_var, $1)=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*) _LT_TAGVAR(ld_shlibs, $1)=yes ;; openbsd* | bitrig*) if test -f /usr/libexec/ld.so; then _LT_TAGVAR(hardcode_direct, $1)=yes _LT_TAGVAR(hardcode_shlibpath_var, $1)=no _LT_TAGVAR(hardcode_direct_absolute, $1)=yes _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $lib' _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath,$libdir' if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`"; then _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-retain-symbols-file,$export_symbols -o $lib' _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-E' _LT_TAGVAR(whole_archive_flag_spec, $1)=$wlarc'--whole-archive$convenience '$wlarc'--no-whole-archive' fi output_verbose_link_cmd=func_echo_all else _LT_TAGVAR(ld_shlibs, $1)=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. _LT_TAGVAR(archive_cmds, $1)='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' _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath,$libdir' _LT_TAGVAR(hardcode_libdir_separator, $1)=: # Archives containing C++ object files must be created using # the KAI C++ compiler. case $host in osf3*) _LT_TAGVAR(old_archive_cmds, $1)='$CC -Bstatic -o $oldlib $oldobjs' ;; *) _LT_TAGVAR(old_archive_cmds, $1)='$CC -o $oldlib $oldobjs' ;; esac ;; RCC*) # Rational C++ 2.4.1 # FIXME: insert proper C++ library support _LT_TAGVAR(ld_shlibs, $1)=no ;; cxx*) case $host in osf3*) _LT_TAGVAR(allow_undefined_flag, $1)=' $wl-expect_unresolved $wl\*' _LT_TAGVAR(archive_cmds, $1)='$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' _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir' ;; *) _LT_TAGVAR(allow_undefined_flag, $1)=' -expect_unresolved \*' _LT_TAGVAR(archive_cmds, $1)='$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' _LT_TAGVAR(archive_expsym_cmds, $1)='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' _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-rpath $libdir' ;; esac _LT_TAGVAR(hardcode_libdir_separator, $1)=: # 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 yes,no = "$GXX,$with_gnu_ld"; then _LT_TAGVAR(allow_undefined_flag, $1)=' $wl-expect_unresolved $wl\*' case $host in osf3*) _LT_TAGVAR(archive_cmds, $1)='$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' ;; *) _LT_TAGVAR(archive_cmds, $1)='$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 _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir' _LT_TAGVAR(hardcode_libdir_separator, $1)=: # 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 _LT_TAGVAR(ld_shlibs, $1)=no fi ;; esac ;; psos*) # FIXME: insert proper C++ library support _LT_TAGVAR(ld_shlibs, $1)=no ;; sunos4*) case $cc_basename in CC*) # Sun C++ 4.x # FIXME: insert proper C++ library support _LT_TAGVAR(ld_shlibs, $1)=no ;; lcc*) # Lucid # FIXME: insert proper C++ library support _LT_TAGVAR(ld_shlibs, $1)=no ;; *) # FIXME: insert proper C++ library support _LT_TAGVAR(ld_shlibs, $1)=no ;; esac ;; solaris*) case $cc_basename in CC* | sunCC*) # Sun C++ 4.2, 5.x and Centerline C++ _LT_TAGVAR(archive_cmds_need_lc,$1)=yes _LT_TAGVAR(no_undefined_flag, $1)=' -zdefs' _LT_TAGVAR(archive_cmds, $1)='$CC -G$allow_undefined_flag -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' _LT_TAGVAR(archive_expsym_cmds, $1)='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' _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir' _LT_TAGVAR(hardcode_shlibpath_var, $1)=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?) _LT_TAGVAR(whole_archive_flag_spec, $1)='-z allextract$convenience -z defaultextract' ;; esac _LT_TAGVAR(link_all_deplibs, $1)=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. _LT_TAGVAR(old_archive_cmds, $1)='$CC -xar -o $oldlib $oldobjs' ;; gcx*) # Green Hills C++ Compiler _LT_TAGVAR(archive_cmds, $1)='$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. _LT_TAGVAR(old_archive_cmds, $1)='$CC $LDFLAGS -archive -o $oldlib $oldobjs' ;; *) # GNU C++ compiler with Solaris linker if test yes,no = "$GXX,$with_gnu_ld"; then _LT_TAGVAR(no_undefined_flag, $1)=' $wl-z ${wl}defs' if $CC --version | $GREP -v '^2\.7' > /dev/null; then _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-h $wl$soname -o $lib' _LT_TAGVAR(archive_expsym_cmds, $1)='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 $wl-h $wl$soname -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. _LT_TAGVAR(archive_cmds, $1)='$CC -G -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-h $wl$soname -o $lib' _LT_TAGVAR(archive_expsym_cmds, $1)='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 $wl-h $wl$soname -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 _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-R $wl$libdir' case $host_os in solaris2.[[0-5]] | solaris2.[[0-5]].*) ;; *) _LT_TAGVAR(whole_archive_flag_spec, $1)='$wl-z ${wl}allextract$convenience $wl-z ${wl}defaultextract' ;; esac fi ;; esac ;; sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[[01]].[[10]]* | unixware7* | sco3.2v5.0.[[024]]*) _LT_TAGVAR(no_undefined_flag, $1)='$wl-z,text' _LT_TAGVAR(archive_cmds_need_lc, $1)=no _LT_TAGVAR(hardcode_shlibpath_var, $1)=no runpath_var='LD_RUN_PATH' case $cc_basename in CC*) _LT_TAGVAR(archive_cmds, $1)='$CC -G $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags' _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags' ;; *) _LT_TAGVAR(archive_cmds, $1)='$CC -shared $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags' _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags' ;; esac ;; sysv5* | sco3.2v5* | sco5v6*) # Note: We CANNOT 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. _LT_TAGVAR(no_undefined_flag, $1)='$wl-z,text' _LT_TAGVAR(allow_undefined_flag, $1)='$wl-z,nodefs' _LT_TAGVAR(archive_cmds_need_lc, $1)=no _LT_TAGVAR(hardcode_shlibpath_var, $1)=no _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-R,$libdir' _LT_TAGVAR(hardcode_libdir_separator, $1)=':' _LT_TAGVAR(link_all_deplibs, $1)=yes _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-Bexport' runpath_var='LD_RUN_PATH' case $cc_basename in CC*) _LT_TAGVAR(archive_cmds, $1)='$CC -G $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags' _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags' _LT_TAGVAR(old_archive_cmds, $1)='$CC -Tprelink_objects $oldobjs~ '"$_LT_TAGVAR(old_archive_cmds, $1)" _LT_TAGVAR(reload_cmds, $1)='$CC -Tprelink_objects $reload_objs~ '"$_LT_TAGVAR(reload_cmds, $1)" ;; *) _LT_TAGVAR(archive_cmds, $1)='$CC -shared $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags' _LT_TAGVAR(archive_expsym_cmds, $1)='$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 _LT_TAGVAR(ld_shlibs, $1)=no ;; *) # FIXME: insert proper C++ library support _LT_TAGVAR(ld_shlibs, $1)=no ;; esac ;; vxworks*) # FIXME: insert proper C++ library support _LT_TAGVAR(ld_shlibs, $1)=no ;; *) # FIXME: insert proper C++ library support _LT_TAGVAR(ld_shlibs, $1)=no ;; esac AC_MSG_RESULT([$_LT_TAGVAR(ld_shlibs, $1)]) test no = "$_LT_TAGVAR(ld_shlibs, $1)" && can_build_shared=no _LT_TAGVAR(GCC, $1)=$GXX _LT_TAGVAR(LD, $1)=$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... _LT_SYS_HIDDEN_LIBDEPS($1) _LT_COMPILER_PIC($1) _LT_COMPILER_C_O($1) _LT_COMPILER_FILE_LOCKS($1) _LT_LINKER_SHLIBS($1) _LT_SYS_DYNAMIC_LINKER($1) _LT_LINKER_HARDCODE_LIBPATH($1) _LT_CONFIG($1) 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 yes != "$_lt_caught_CXX_error" AC_LANG_POP ])# _LT_LANG_CXX_CONFIG # _LT_FUNC_STRIPNAME_CNF # ---------------------- # func_stripname_cnf prefix suffix name # strip PREFIX and SUFFIX off of NAME. # PREFIX and SUFFIX must not contain globbing or regex special # characters, hashes, percent signs, but SUFFIX may contain a leading # dot (in which case that matches only a dot). # # This function is identical to the (non-XSI) version of func_stripname, # except this one can be used by m4 code that may be executed by configure, # rather than the libtool script. m4_defun([_LT_FUNC_STRIPNAME_CNF],[dnl AC_REQUIRE([_LT_DECL_SED]) AC_REQUIRE([_LT_PROG_ECHO_BACKSLASH]) func_stripname_cnf () { case @S|@2 in .*) func_stripname_result=`$ECHO "@S|@3" | $SED "s%^@S|@1%%; s%\\\\@S|@2\$%%"`;; *) func_stripname_result=`$ECHO "@S|@3" | $SED "s%^@S|@1%%; s%@S|@2\$%%"`;; esac } # func_stripname_cnf ])# _LT_FUNC_STRIPNAME_CNF # _LT_SYS_HIDDEN_LIBDEPS([TAGNAME]) # --------------------------------- # Figure out "hidden" library dependencies from verbose # compiler output when linking a shared library. # Parse the compiler output and extract the necessary # objects, libraries and library flags. m4_defun([_LT_SYS_HIDDEN_LIBDEPS], [m4_require([_LT_FILEUTILS_DEFAULTS])dnl AC_REQUIRE([_LT_FUNC_STRIPNAME_CNF])dnl # Dependencies to place before and after the object being linked: _LT_TAGVAR(predep_objects, $1)= _LT_TAGVAR(postdep_objects, $1)= _LT_TAGVAR(predeps, $1)= _LT_TAGVAR(postdeps, $1)= _LT_TAGVAR(compiler_lib_search_path, $1)= dnl we can't use the lt_simple_compile_test_code here, dnl because it contains code intended for an executable, dnl not a library. It's possible we should let each dnl tag define a new lt_????_link_test_code variable, dnl but it's only used here... m4_if([$1], [], [cat > conftest.$ac_ext <<_LT_EOF int a; void foo (void) { a = 0; } _LT_EOF ], [$1], [CXX], [cat > conftest.$ac_ext <<_LT_EOF class Foo { public: Foo (void) { a = 0; } private: int a; }; _LT_EOF ], [$1], [F77], [cat > conftest.$ac_ext <<_LT_EOF subroutine foo implicit none integer*4 a a=0 return end _LT_EOF ], [$1], [FC], [cat > conftest.$ac_ext <<_LT_EOF subroutine foo implicit none integer a a=0 return end _LT_EOF ], [$1], [GCJ], [cat > conftest.$ac_ext <<_LT_EOF public class foo { private int a; public void bar (void) { a = 0; } }; _LT_EOF ], [$1], [GO], [cat > conftest.$ac_ext <<_LT_EOF package foo func foo() { } _LT_EOF ]) _lt_libdeps_save_CFLAGS=$CFLAGS case "$CC $CFLAGS " in #( *\ -flto*\ *) CFLAGS="$CFLAGS -fno-lto" ;; *\ -fwhopr*\ *) CFLAGS="$CFLAGS -fno-whopr" ;; *\ -fuse-linker-plugin*\ *) CFLAGS="$CFLAGS -fno-use-linker-plugin" ;; esac dnl Parse the compiler output and extract the necessary dnl objects, libraries and library flags. if AC_TRY_EVAL(ac_compile); 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 x-L = "$p" || test x-R = "$p"; 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 no = "$pre_test_object_deps_done"; 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 "$_LT_TAGVAR(compiler_lib_search_path, $1)"; then _LT_TAGVAR(compiler_lib_search_path, $1)=$prev$p else _LT_TAGVAR(compiler_lib_search_path, $1)="${_LT_TAGVAR(compiler_lib_search_path, $1)} $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 "$_LT_TAGVAR(postdeps, $1)"; then _LT_TAGVAR(postdeps, $1)=$prev$p else _LT_TAGVAR(postdeps, $1)="${_LT_TAGVAR(postdeps, $1)} $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 no = "$pre_test_object_deps_done"; then if test -z "$_LT_TAGVAR(predep_objects, $1)"; then _LT_TAGVAR(predep_objects, $1)=$p else _LT_TAGVAR(predep_objects, $1)="$_LT_TAGVAR(predep_objects, $1) $p" fi else if test -z "$_LT_TAGVAR(postdep_objects, $1)"; then _LT_TAGVAR(postdep_objects, $1)=$p else _LT_TAGVAR(postdep_objects, $1)="$_LT_TAGVAR(postdep_objects, $1) $p" fi fi ;; *) ;; # Ignore the rest. esac done # Clean up. rm -f a.out a.exe else echo "libtool.m4: error: problem compiling $1 test program" fi $RM -f confest.$objext CFLAGS=$_lt_libdeps_save_CFLAGS # PORTME: override above test on systems where it is broken m4_if([$1], [CXX], [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. _LT_TAGVAR(predep_objects,$1)= _LT_TAGVAR(postdep_objects,$1)= _LT_TAGVAR(postdeps,$1)= ;; esac ]) case " $_LT_TAGVAR(postdeps, $1) " in *" -lc "*) _LT_TAGVAR(archive_cmds_need_lc, $1)=no ;; esac _LT_TAGVAR(compiler_lib_search_dirs, $1)= if test -n "${_LT_TAGVAR(compiler_lib_search_path, $1)}"; then _LT_TAGVAR(compiler_lib_search_dirs, $1)=`echo " ${_LT_TAGVAR(compiler_lib_search_path, $1)}" | $SED -e 's! -L! !g' -e 's!^ !!'` fi _LT_TAGDECL([], [compiler_lib_search_dirs], [1], [The directories searched by this compiler when creating a shared library]) _LT_TAGDECL([], [predep_objects], [1], [Dependencies to place before and after the objects being linked to create a shared library]) _LT_TAGDECL([], [postdep_objects], [1]) _LT_TAGDECL([], [predeps], [1]) _LT_TAGDECL([], [postdeps], [1]) _LT_TAGDECL([], [compiler_lib_search_path], [1], [The library search path used internally by the compiler when linking a shared library]) ])# _LT_SYS_HIDDEN_LIBDEPS # _LT_LANG_F77_CONFIG([TAG]) # -------------------------- # Ensure that the configuration variables for a Fortran 77 compiler are # suitably defined. These variables are subsequently used by _LT_CONFIG # to write the compiler configuration to 'libtool'. m4_defun([_LT_LANG_F77_CONFIG], [AC_LANG_PUSH(Fortran 77) if test -z "$F77" || test no = "$F77"; then _lt_disable_F77=yes fi _LT_TAGVAR(archive_cmds_need_lc, $1)=no _LT_TAGVAR(allow_undefined_flag, $1)= _LT_TAGVAR(always_export_symbols, $1)=no _LT_TAGVAR(archive_expsym_cmds, $1)= _LT_TAGVAR(export_dynamic_flag_spec, $1)= _LT_TAGVAR(hardcode_direct, $1)=no _LT_TAGVAR(hardcode_direct_absolute, $1)=no _LT_TAGVAR(hardcode_libdir_flag_spec, $1)= _LT_TAGVAR(hardcode_libdir_separator, $1)= _LT_TAGVAR(hardcode_minus_L, $1)=no _LT_TAGVAR(hardcode_automatic, $1)=no _LT_TAGVAR(inherit_rpath, $1)=no _LT_TAGVAR(module_cmds, $1)= _LT_TAGVAR(module_expsym_cmds, $1)= _LT_TAGVAR(link_all_deplibs, $1)=unknown _LT_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds _LT_TAGVAR(reload_flag, $1)=$reload_flag _LT_TAGVAR(reload_cmds, $1)=$reload_cmds _LT_TAGVAR(no_undefined_flag, $1)= _LT_TAGVAR(whole_archive_flag_spec, $1)= _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=no # Source file extension for f77 test sources. ac_ext=f # Object file extension for compiled f77 test sources. objext=o _LT_TAGVAR(objext, $1)=$objext # No sense in running all these tests if we already determined that # the F77 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 yes != "$_lt_disable_F77"; then # Code to be used in simple compile tests lt_simple_compile_test_code="\ subroutine t return end " # Code to be used in simple link tests lt_simple_link_test_code="\ program t end " # ltmain only uses $CC for tagged configurations so make sure $CC is set. _LT_TAG_COMPILER # save warnings/boilerplate of simple test code _LT_COMPILER_BOILERPLATE _LT_LINKER_BOILERPLATE # Allow CC to be a program name with arguments. lt_save_CC=$CC lt_save_GCC=$GCC lt_save_CFLAGS=$CFLAGS CC=${F77-"f77"} CFLAGS=$FFLAGS compiler=$CC _LT_TAGVAR(compiler, $1)=$CC _LT_CC_BASENAME([$compiler]) GCC=$G77 if test -n "$compiler"; then AC_MSG_CHECKING([if libtool supports shared libraries]) AC_MSG_RESULT([$can_build_shared]) AC_MSG_CHECKING([whether to build shared libraries]) test no = "$can_build_shared" && 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 yes = "$enable_shared" && enable_static=no if test -n "$RANLIB"; then archive_cmds="$archive_cmds~\$RANLIB \$lib" postinstall_cmds='$RANLIB $lib' fi ;; aix[[4-9]]*) if test ia64 != "$host_cpu"; then case $enable_shared,$with_aix_soname,$aix_use_runtimelinking in yes,aix,yes) ;; # shared object as lib.so file only yes,svr4,*) ;; # shared object as lib.so archive member only yes,*) enable_static=no ;; # shared object in lib.a archive as well esac fi ;; esac AC_MSG_RESULT([$enable_shared]) AC_MSG_CHECKING([whether to build static libraries]) # Make sure either enable_shared or enable_static is yes. test yes = "$enable_shared" || enable_static=yes AC_MSG_RESULT([$enable_static]) _LT_TAGVAR(GCC, $1)=$G77 _LT_TAGVAR(LD, $1)=$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... _LT_COMPILER_PIC($1) _LT_COMPILER_C_O($1) _LT_COMPILER_FILE_LOCKS($1) _LT_LINKER_SHLIBS($1) _LT_SYS_DYNAMIC_LINKER($1) _LT_LINKER_HARDCODE_LIBPATH($1) _LT_CONFIG($1) fi # test -n "$compiler" GCC=$lt_save_GCC CC=$lt_save_CC CFLAGS=$lt_save_CFLAGS fi # test yes != "$_lt_disable_F77" AC_LANG_POP ])# _LT_LANG_F77_CONFIG # _LT_LANG_FC_CONFIG([TAG]) # ------------------------- # Ensure that the configuration variables for a Fortran compiler are # suitably defined. These variables are subsequently used by _LT_CONFIG # to write the compiler configuration to 'libtool'. m4_defun([_LT_LANG_FC_CONFIG], [AC_LANG_PUSH(Fortran) if test -z "$FC" || test no = "$FC"; then _lt_disable_FC=yes fi _LT_TAGVAR(archive_cmds_need_lc, $1)=no _LT_TAGVAR(allow_undefined_flag, $1)= _LT_TAGVAR(always_export_symbols, $1)=no _LT_TAGVAR(archive_expsym_cmds, $1)= _LT_TAGVAR(export_dynamic_flag_spec, $1)= _LT_TAGVAR(hardcode_direct, $1)=no _LT_TAGVAR(hardcode_direct_absolute, $1)=no _LT_TAGVAR(hardcode_libdir_flag_spec, $1)= _LT_TAGVAR(hardcode_libdir_separator, $1)= _LT_TAGVAR(hardcode_minus_L, $1)=no _LT_TAGVAR(hardcode_automatic, $1)=no _LT_TAGVAR(inherit_rpath, $1)=no _LT_TAGVAR(module_cmds, $1)= _LT_TAGVAR(module_expsym_cmds, $1)= _LT_TAGVAR(link_all_deplibs, $1)=unknown _LT_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds _LT_TAGVAR(reload_flag, $1)=$reload_flag _LT_TAGVAR(reload_cmds, $1)=$reload_cmds _LT_TAGVAR(no_undefined_flag, $1)= _LT_TAGVAR(whole_archive_flag_spec, $1)= _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=no # Source file extension for fc test sources. ac_ext=${ac_fc_srcext-f} # Object file extension for compiled fc test sources. objext=o _LT_TAGVAR(objext, $1)=$objext # No sense in running all these tests if we already determined that # the FC 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 yes != "$_lt_disable_FC"; then # Code to be used in simple compile tests lt_simple_compile_test_code="\ subroutine t return end " # Code to be used in simple link tests lt_simple_link_test_code="\ program t end " # ltmain only uses $CC for tagged configurations so make sure $CC is set. _LT_TAG_COMPILER # save warnings/boilerplate of simple test code _LT_COMPILER_BOILERPLATE _LT_LINKER_BOILERPLATE # Allow CC to be a program name with arguments. lt_save_CC=$CC lt_save_GCC=$GCC lt_save_CFLAGS=$CFLAGS CC=${FC-"f95"} CFLAGS=$FCFLAGS compiler=$CC GCC=$ac_cv_fc_compiler_gnu _LT_TAGVAR(compiler, $1)=$CC _LT_CC_BASENAME([$compiler]) if test -n "$compiler"; then AC_MSG_CHECKING([if libtool supports shared libraries]) AC_MSG_RESULT([$can_build_shared]) AC_MSG_CHECKING([whether to build shared libraries]) test no = "$can_build_shared" && 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 yes = "$enable_shared" && enable_static=no if test -n "$RANLIB"; then archive_cmds="$archive_cmds~\$RANLIB \$lib" postinstall_cmds='$RANLIB $lib' fi ;; aix[[4-9]]*) if test ia64 != "$host_cpu"; then case $enable_shared,$with_aix_soname,$aix_use_runtimelinking in yes,aix,yes) ;; # shared object as lib.so file only yes,svr4,*) ;; # shared object as lib.so archive member only yes,*) enable_static=no ;; # shared object in lib.a archive as well esac fi ;; esac AC_MSG_RESULT([$enable_shared]) AC_MSG_CHECKING([whether to build static libraries]) # Make sure either enable_shared or enable_static is yes. test yes = "$enable_shared" || enable_static=yes AC_MSG_RESULT([$enable_static]) _LT_TAGVAR(GCC, $1)=$ac_cv_fc_compiler_gnu _LT_TAGVAR(LD, $1)=$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... _LT_SYS_HIDDEN_LIBDEPS($1) _LT_COMPILER_PIC($1) _LT_COMPILER_C_O($1) _LT_COMPILER_FILE_LOCKS($1) _LT_LINKER_SHLIBS($1) _LT_SYS_DYNAMIC_LINKER($1) _LT_LINKER_HARDCODE_LIBPATH($1) _LT_CONFIG($1) fi # test -n "$compiler" GCC=$lt_save_GCC CC=$lt_save_CC CFLAGS=$lt_save_CFLAGS fi # test yes != "$_lt_disable_FC" AC_LANG_POP ])# _LT_LANG_FC_CONFIG # _LT_LANG_GCJ_CONFIG([TAG]) # -------------------------- # Ensure that the configuration variables for the GNU Java Compiler compiler # are suitably defined. These variables are subsequently used by _LT_CONFIG # to write the compiler configuration to 'libtool'. m4_defun([_LT_LANG_GCJ_CONFIG], [AC_REQUIRE([LT_PROG_GCJ])dnl AC_LANG_SAVE # Source file extension for Java test sources. ac_ext=java # Object file extension for compiled Java test sources. objext=o _LT_TAGVAR(objext, $1)=$objext # Code to be used in simple compile tests lt_simple_compile_test_code="class foo {}" # Code to be used in simple link tests lt_simple_link_test_code='public class conftest { public static void main(String[[]] argv) {}; }' # ltmain only uses $CC for tagged configurations so make sure $CC is set. _LT_TAG_COMPILER # save warnings/boilerplate of simple test code _LT_COMPILER_BOILERPLATE _LT_LINKER_BOILERPLATE # Allow CC to be a program name with arguments. lt_save_CC=$CC lt_save_CFLAGS=$CFLAGS lt_save_GCC=$GCC GCC=yes CC=${GCJ-"gcj"} CFLAGS=$GCJFLAGS compiler=$CC _LT_TAGVAR(compiler, $1)=$CC _LT_TAGVAR(LD, $1)=$LD _LT_CC_BASENAME([$compiler]) # GCJ did not exist at the time GCC didn't implicitly link libc in. _LT_TAGVAR(archive_cmds_need_lc, $1)=no _LT_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds _LT_TAGVAR(reload_flag, $1)=$reload_flag _LT_TAGVAR(reload_cmds, $1)=$reload_cmds ## 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_COMPILER_NO_RTTI($1) _LT_COMPILER_PIC($1) _LT_COMPILER_C_O($1) _LT_COMPILER_FILE_LOCKS($1) _LT_LINKER_SHLIBS($1) _LT_LINKER_HARDCODE_LIBPATH($1) _LT_CONFIG($1) fi AC_LANG_RESTORE GCC=$lt_save_GCC CC=$lt_save_CC CFLAGS=$lt_save_CFLAGS ])# _LT_LANG_GCJ_CONFIG # _LT_LANG_GO_CONFIG([TAG]) # -------------------------- # Ensure that the configuration variables for the GNU Go compiler # are suitably defined. These variables are subsequently used by _LT_CONFIG # to write the compiler configuration to 'libtool'. m4_defun([_LT_LANG_GO_CONFIG], [AC_REQUIRE([LT_PROG_GO])dnl AC_LANG_SAVE # Source file extension for Go test sources. ac_ext=go # Object file extension for compiled Go test sources. objext=o _LT_TAGVAR(objext, $1)=$objext # Code to be used in simple compile tests lt_simple_compile_test_code="package main; func main() { }" # Code to be used in simple link tests lt_simple_link_test_code='package main; func main() { }' # ltmain only uses $CC for tagged configurations so make sure $CC is set. _LT_TAG_COMPILER # save warnings/boilerplate of simple test code _LT_COMPILER_BOILERPLATE _LT_LINKER_BOILERPLATE # Allow CC to be a program name with arguments. lt_save_CC=$CC lt_save_CFLAGS=$CFLAGS lt_save_GCC=$GCC GCC=yes CC=${GOC-"gccgo"} CFLAGS=$GOFLAGS compiler=$CC _LT_TAGVAR(compiler, $1)=$CC _LT_TAGVAR(LD, $1)=$LD _LT_CC_BASENAME([$compiler]) # Go did not exist at the time GCC didn't implicitly link libc in. _LT_TAGVAR(archive_cmds_need_lc, $1)=no _LT_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds _LT_TAGVAR(reload_flag, $1)=$reload_flag _LT_TAGVAR(reload_cmds, $1)=$reload_cmds ## 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_COMPILER_NO_RTTI($1) _LT_COMPILER_PIC($1) _LT_COMPILER_C_O($1) _LT_COMPILER_FILE_LOCKS($1) _LT_LINKER_SHLIBS($1) _LT_LINKER_HARDCODE_LIBPATH($1) _LT_CONFIG($1) fi AC_LANG_RESTORE GCC=$lt_save_GCC CC=$lt_save_CC CFLAGS=$lt_save_CFLAGS ])# _LT_LANG_GO_CONFIG # _LT_LANG_RC_CONFIG([TAG]) # ------------------------- # Ensure that the configuration variables for the Windows resource compiler # are suitably defined. These variables are subsequently used by _LT_CONFIG # to write the compiler configuration to 'libtool'. m4_defun([_LT_LANG_RC_CONFIG], [AC_REQUIRE([LT_PROG_RC])dnl AC_LANG_SAVE # Source file extension for RC test sources. ac_ext=rc # Object file extension for compiled RC test sources. objext=o _LT_TAGVAR(objext, $1)=$objext # Code to be used in simple compile tests lt_simple_compile_test_code='sample MENU { MENUITEM "&Soup", 100, CHECKED }' # Code to be used in simple link tests lt_simple_link_test_code=$lt_simple_compile_test_code # ltmain only uses $CC for tagged configurations so make sure $CC is set. _LT_TAG_COMPILER # save warnings/boilerplate of simple test code _LT_COMPILER_BOILERPLATE _LT_LINKER_BOILERPLATE # Allow CC to be a program name with arguments. lt_save_CC=$CC lt_save_CFLAGS=$CFLAGS lt_save_GCC=$GCC GCC= CC=${RC-"windres"} CFLAGS= compiler=$CC _LT_TAGVAR(compiler, $1)=$CC _LT_CC_BASENAME([$compiler]) _LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)=yes if test -n "$compiler"; then : _LT_CONFIG($1) fi GCC=$lt_save_GCC AC_LANG_RESTORE CC=$lt_save_CC CFLAGS=$lt_save_CFLAGS ])# _LT_LANG_RC_CONFIG # LT_PROG_GCJ # ----------- AC_DEFUN([LT_PROG_GCJ], [m4_ifdef([AC_PROG_GCJ], [AC_PROG_GCJ], [m4_ifdef([A][M_PROG_GCJ], [A][M_PROG_GCJ], [AC_CHECK_TOOL(GCJ, gcj,) test set = "${GCJFLAGS+set}" || GCJFLAGS="-g -O2" AC_SUBST(GCJFLAGS)])])[]dnl ]) # Old name: AU_ALIAS([LT_AC_PROG_GCJ], [LT_PROG_GCJ]) dnl aclocal-1.4 backwards compatibility: dnl AC_DEFUN([LT_AC_PROG_GCJ], []) # LT_PROG_GO # ---------- AC_DEFUN([LT_PROG_GO], [AC_CHECK_TOOL(GOC, gccgo,) ]) # LT_PROG_RC # ---------- AC_DEFUN([LT_PROG_RC], [AC_CHECK_TOOL(RC, windres,) ]) # Old name: AU_ALIAS([LT_AC_PROG_RC], [LT_PROG_RC]) dnl aclocal-1.4 backwards compatibility: dnl AC_DEFUN([LT_AC_PROG_RC], []) # _LT_DECL_EGREP # -------------- # If we don't have a new enough Autoconf to choose the best grep # available, choose the one first in the user's PATH. m4_defun([_LT_DECL_EGREP], [AC_REQUIRE([AC_PROG_EGREP])dnl AC_REQUIRE([AC_PROG_FGREP])dnl test -z "$GREP" && GREP=grep _LT_DECL([], [GREP], [1], [A grep program that handles long lines]) _LT_DECL([], [EGREP], [1], [An ERE matcher]) _LT_DECL([], [FGREP], [1], [A literal string matcher]) dnl Non-bleeding-edge autoconf doesn't subst GREP, so do it here too AC_SUBST([GREP]) ]) # _LT_DECL_OBJDUMP # -------------- # If we don't have a new enough Autoconf to choose the best objdump # available, choose the one first in the user's PATH. m4_defun([_LT_DECL_OBJDUMP], [AC_CHECK_TOOL(OBJDUMP, objdump, false) test -z "$OBJDUMP" && OBJDUMP=objdump _LT_DECL([], [OBJDUMP], [1], [An object symbol dumper]) AC_SUBST([OBJDUMP]) ]) # _LT_DECL_DLLTOOL # ---------------- # Ensure DLLTOOL variable is set. m4_defun([_LT_DECL_DLLTOOL], [AC_CHECK_TOOL(DLLTOOL, dlltool, false) test -z "$DLLTOOL" && DLLTOOL=dlltool _LT_DECL([], [DLLTOOL], [1], [DLL creation program]) AC_SUBST([DLLTOOL]) ]) # _LT_DECL_SED # ------------ # Check for a fully-functional sed program, that truncates # as few characters as possible. Prefer GNU sed if found. m4_defun([_LT_DECL_SED], [AC_PROG_SED test -z "$SED" && SED=sed Xsed="$SED -e 1s/^X//" _LT_DECL([], [SED], [1], [A sed program that does not truncate output]) _LT_DECL([], [Xsed], ["\$SED -e 1s/^X//"], [Sed that helps us avoid accidentally triggering echo(1) options like -n]) ])# _LT_DECL_SED m4_ifndef([AC_PROG_SED], [ ############################################################ # NOTE: This macro has been submitted for inclusion into # # GNU Autoconf as AC_PROG_SED. When it is available in # # a released version of Autoconf we should remove this # # macro and use it instead. # ############################################################ m4_defun([AC_PROG_SED], [AC_MSG_CHECKING([for a sed that does not truncate output]) AC_CACHE_VAL(lt_cv_path_SED, [# Loop through the user's path and test for sed and gsed. # Then use that list of sed's as ones to test for truncation. as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for lt_ac_prog in sed gsed; do for ac_exec_ext in '' $ac_executable_extensions; do if $as_executable_p "$as_dir/$lt_ac_prog$ac_exec_ext"; then lt_ac_sed_list="$lt_ac_sed_list $as_dir/$lt_ac_prog$ac_exec_ext" fi done done done IFS=$as_save_IFS lt_ac_max=0 lt_ac_count=0 # Add /usr/xpg4/bin/sed as it is typically found on Solaris # along with /bin/sed that truncates output. for lt_ac_sed in $lt_ac_sed_list /usr/xpg4/bin/sed; do test ! -f "$lt_ac_sed" && continue cat /dev/null > conftest.in lt_ac_count=0 echo $ECHO_N "0123456789$ECHO_C" >conftest.in # Check for GNU sed and select it if it is found. if "$lt_ac_sed" --version 2>&1 < /dev/null | grep 'GNU' > /dev/null; then lt_cv_path_SED=$lt_ac_sed break fi while true; do cat conftest.in conftest.in >conftest.tmp mv conftest.tmp conftest.in cp conftest.in conftest.nl echo >>conftest.nl $lt_ac_sed -e 's/a$//' < conftest.nl >conftest.out || break cmp -s conftest.out conftest.nl || break # 10000 chars as input seems more than enough test 10 -lt "$lt_ac_count" && break lt_ac_count=`expr $lt_ac_count + 1` if test "$lt_ac_count" -gt "$lt_ac_max"; then lt_ac_max=$lt_ac_count lt_cv_path_SED=$lt_ac_sed fi done done ]) SED=$lt_cv_path_SED AC_SUBST([SED]) AC_MSG_RESULT([$SED]) ])#AC_PROG_SED ])#m4_ifndef # Old name: AU_ALIAS([LT_AC_PROG_SED], [AC_PROG_SED]) dnl aclocal-1.4 backwards compatibility: dnl AC_DEFUN([LT_AC_PROG_SED], []) # _LT_CHECK_SHELL_FEATURES # ------------------------ # Find out whether the shell is Bourne or XSI compatible, # or has some other useful features. m4_defun([_LT_CHECK_SHELL_FEATURES], [if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then lt_unset=unset else lt_unset=false fi _LT_DECL([], [lt_unset], [0], [whether the shell understands "unset"])dnl # 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 _LT_DECL([SP2NL], [lt_SP2NL], [1], [turn spaces into newlines])dnl _LT_DECL([NL2SP], [lt_NL2SP], [1], [turn newlines into spaces])dnl ])# _LT_CHECK_SHELL_FEATURES # _LT_PATH_CONVERSION_FUNCTIONS # ----------------------------- # Determine what file name conversion functions should be used by # func_to_host_file (and, implicitly, by func_to_host_path). These are needed # for certain cross-compile configurations and native mingw. m4_defun([_LT_PATH_CONVERSION_FUNCTIONS], [AC_REQUIRE([AC_CANONICAL_HOST])dnl AC_REQUIRE([AC_CANONICAL_BUILD])dnl AC_MSG_CHECKING([how to convert $build file names to $host format]) AC_CACHE_VAL(lt_cv_to_host_file_cmd, [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 ]) to_host_file_cmd=$lt_cv_to_host_file_cmd AC_MSG_RESULT([$lt_cv_to_host_file_cmd]) _LT_DECL([to_host_file_cmd], [lt_cv_to_host_file_cmd], [0], [convert $build file names to $host format])dnl AC_MSG_CHECKING([how to convert $build file names to toolchain format]) AC_CACHE_VAL(lt_cv_to_tool_file_cmd, [#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 ]) to_tool_file_cmd=$lt_cv_to_tool_file_cmd AC_MSG_RESULT([$lt_cv_to_tool_file_cmd]) _LT_DECL([to_tool_file_cmd], [lt_cv_to_tool_file_cmd], [0], [convert $build files to toolchain format])dnl ])# _LT_PATH_CONVERSION_FUNCTIONS ecl-16.1.2/src/bdwgc/m4/ltoptions.m4000066400000000000000000000342621266352375300170610ustar00rootroot00000000000000# Helper functions for option handling. -*- Autoconf -*- # # Copyright (C) 2004-2005, 2007-2009, 2011-2015 Free Software # Foundation, Inc. # Written by Gary V. Vaughan, 2004 # # 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 ltoptions.m4 # This is to help aclocal find these macros, as it can't see m4_define. AC_DEFUN([LTOPTIONS_VERSION], [m4_if([1])]) # _LT_MANGLE_OPTION(MACRO-NAME, OPTION-NAME) # ------------------------------------------ m4_define([_LT_MANGLE_OPTION], [[_LT_OPTION_]m4_bpatsubst($1__$2, [[^a-zA-Z0-9_]], [_])]) # _LT_SET_OPTION(MACRO-NAME, OPTION-NAME) # --------------------------------------- # Set option OPTION-NAME for macro MACRO-NAME, and if there is a # matching handler defined, dispatch to it. Other OPTION-NAMEs are # saved as a flag. m4_define([_LT_SET_OPTION], [m4_define(_LT_MANGLE_OPTION([$1], [$2]))dnl m4_ifdef(_LT_MANGLE_DEFUN([$1], [$2]), _LT_MANGLE_DEFUN([$1], [$2]), [m4_warning([Unknown $1 option '$2'])])[]dnl ]) # _LT_IF_OPTION(MACRO-NAME, OPTION-NAME, IF-SET, [IF-NOT-SET]) # ------------------------------------------------------------ # Execute IF-SET if OPTION is set, IF-NOT-SET otherwise. m4_define([_LT_IF_OPTION], [m4_ifdef(_LT_MANGLE_OPTION([$1], [$2]), [$3], [$4])]) # _LT_UNLESS_OPTIONS(MACRO-NAME, OPTION-LIST, IF-NOT-SET) # ------------------------------------------------------- # Execute IF-NOT-SET unless all options in OPTION-LIST for MACRO-NAME # are set. m4_define([_LT_UNLESS_OPTIONS], [m4_foreach([_LT_Option], m4_split(m4_normalize([$2])), [m4_ifdef(_LT_MANGLE_OPTION([$1], _LT_Option), [m4_define([$0_found])])])[]dnl m4_ifdef([$0_found], [m4_undefine([$0_found])], [$3 ])[]dnl ]) # _LT_SET_OPTIONS(MACRO-NAME, OPTION-LIST) # ---------------------------------------- # OPTION-LIST is a space-separated list of Libtool options associated # with MACRO-NAME. If any OPTION has a matching handler declared with # LT_OPTION_DEFINE, dispatch to that macro; otherwise complain about # the unknown option and exit. m4_defun([_LT_SET_OPTIONS], [# Set options m4_foreach([_LT_Option], m4_split(m4_normalize([$2])), [_LT_SET_OPTION([$1], _LT_Option)]) m4_if([$1],[LT_INIT],[ dnl dnl Simply set some default values (i.e off) if boolean options were not dnl specified: _LT_UNLESS_OPTIONS([LT_INIT], [dlopen], [enable_dlopen=no ]) _LT_UNLESS_OPTIONS([LT_INIT], [win32-dll], [enable_win32_dll=no ]) dnl dnl If no reference was made to various pairs of opposing options, then dnl we run the default mode handler for the pair. For example, if neither dnl 'shared' nor 'disable-shared' was passed, we enable building of shared dnl archives by default: _LT_UNLESS_OPTIONS([LT_INIT], [shared disable-shared], [_LT_ENABLE_SHARED]) _LT_UNLESS_OPTIONS([LT_INIT], [static disable-static], [_LT_ENABLE_STATIC]) _LT_UNLESS_OPTIONS([LT_INIT], [pic-only no-pic], [_LT_WITH_PIC]) _LT_UNLESS_OPTIONS([LT_INIT], [fast-install disable-fast-install], [_LT_ENABLE_FAST_INSTALL]) _LT_UNLESS_OPTIONS([LT_INIT], [aix-soname=aix aix-soname=both aix-soname=svr4], [_LT_WITH_AIX_SONAME([aix])]) ]) ])# _LT_SET_OPTIONS ## --------------------------------- ## ## Macros to handle LT_INIT options. ## ## --------------------------------- ## # _LT_MANGLE_DEFUN(MACRO-NAME, OPTION-NAME) # ----------------------------------------- m4_define([_LT_MANGLE_DEFUN], [[_LT_OPTION_DEFUN_]m4_bpatsubst(m4_toupper([$1__$2]), [[^A-Z0-9_]], [_])]) # LT_OPTION_DEFINE(MACRO-NAME, OPTION-NAME, CODE) # ----------------------------------------------- m4_define([LT_OPTION_DEFINE], [m4_define(_LT_MANGLE_DEFUN([$1], [$2]), [$3])[]dnl ])# LT_OPTION_DEFINE # dlopen # ------ LT_OPTION_DEFINE([LT_INIT], [dlopen], [enable_dlopen=yes ]) AU_DEFUN([AC_LIBTOOL_DLOPEN], [_LT_SET_OPTION([LT_INIT], [dlopen]) AC_DIAGNOSE([obsolete], [$0: Remove this warning and the call to _LT_SET_OPTION when you put the 'dlopen' option into LT_INIT's first parameter.]) ]) dnl aclocal-1.4 backwards compatibility: dnl AC_DEFUN([AC_LIBTOOL_DLOPEN], []) # win32-dll # --------- # Declare package support for building win32 dll's. LT_OPTION_DEFINE([LT_INIT], [win32-dll], [enable_win32_dll=yes case $host in *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-cegcc*) AC_CHECK_TOOL(AS, as, false) AC_CHECK_TOOL(DLLTOOL, dlltool, false) AC_CHECK_TOOL(OBJDUMP, objdump, false) ;; esac test -z "$AS" && AS=as _LT_DECL([], [AS], [1], [Assembler program])dnl test -z "$DLLTOOL" && DLLTOOL=dlltool _LT_DECL([], [DLLTOOL], [1], [DLL creation program])dnl test -z "$OBJDUMP" && OBJDUMP=objdump _LT_DECL([], [OBJDUMP], [1], [Object dumper program])dnl ])# win32-dll AU_DEFUN([AC_LIBTOOL_WIN32_DLL], [AC_REQUIRE([AC_CANONICAL_HOST])dnl _LT_SET_OPTION([LT_INIT], [win32-dll]) AC_DIAGNOSE([obsolete], [$0: Remove this warning and the call to _LT_SET_OPTION when you put the 'win32-dll' option into LT_INIT's first parameter.]) ]) dnl aclocal-1.4 backwards compatibility: dnl AC_DEFUN([AC_LIBTOOL_WIN32_DLL], []) # _LT_ENABLE_SHARED([DEFAULT]) # ---------------------------- # implement the --enable-shared flag, and supports the 'shared' and # 'disable-shared' LT_INIT options. # DEFAULT is either 'yes' or 'no'. If omitted, it defaults to 'yes'. m4_define([_LT_ENABLE_SHARED], [m4_define([_LT_ENABLE_SHARED_DEFAULT], [m4_if($1, no, no, yes)])dnl AC_ARG_ENABLE([shared], [AS_HELP_STRING([--enable-shared@<:@=PKGS@:>@], [build shared libraries @<:@default=]_LT_ENABLE_SHARED_DEFAULT[@:>@])], [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], [enable_shared=]_LT_ENABLE_SHARED_DEFAULT) _LT_DECL([build_libtool_libs], [enable_shared], [0], [Whether or not to build shared libraries]) ])# _LT_ENABLE_SHARED LT_OPTION_DEFINE([LT_INIT], [shared], [_LT_ENABLE_SHARED([yes])]) LT_OPTION_DEFINE([LT_INIT], [disable-shared], [_LT_ENABLE_SHARED([no])]) # Old names: AC_DEFUN([AC_ENABLE_SHARED], [_LT_SET_OPTION([LT_INIT], m4_if([$1], [no], [disable-])[shared]) ]) AC_DEFUN([AC_DISABLE_SHARED], [_LT_SET_OPTION([LT_INIT], [disable-shared]) ]) AU_DEFUN([AM_ENABLE_SHARED], [AC_ENABLE_SHARED($@)]) AU_DEFUN([AM_DISABLE_SHARED], [AC_DISABLE_SHARED($@)]) dnl aclocal-1.4 backwards compatibility: dnl AC_DEFUN([AM_ENABLE_SHARED], []) dnl AC_DEFUN([AM_DISABLE_SHARED], []) # _LT_ENABLE_STATIC([DEFAULT]) # ---------------------------- # implement the --enable-static flag, and support the 'static' and # 'disable-static' LT_INIT options. # DEFAULT is either 'yes' or 'no'. If omitted, it defaults to 'yes'. m4_define([_LT_ENABLE_STATIC], [m4_define([_LT_ENABLE_STATIC_DEFAULT], [m4_if($1, no, no, yes)])dnl AC_ARG_ENABLE([static], [AS_HELP_STRING([--enable-static@<:@=PKGS@:>@], [build static libraries @<:@default=]_LT_ENABLE_STATIC_DEFAULT[@:>@])], [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], [enable_static=]_LT_ENABLE_STATIC_DEFAULT) _LT_DECL([build_old_libs], [enable_static], [0], [Whether or not to build static libraries]) ])# _LT_ENABLE_STATIC LT_OPTION_DEFINE([LT_INIT], [static], [_LT_ENABLE_STATIC([yes])]) LT_OPTION_DEFINE([LT_INIT], [disable-static], [_LT_ENABLE_STATIC([no])]) # Old names: AC_DEFUN([AC_ENABLE_STATIC], [_LT_SET_OPTION([LT_INIT], m4_if([$1], [no], [disable-])[static]) ]) AC_DEFUN([AC_DISABLE_STATIC], [_LT_SET_OPTION([LT_INIT], [disable-static]) ]) AU_DEFUN([AM_ENABLE_STATIC], [AC_ENABLE_STATIC($@)]) AU_DEFUN([AM_DISABLE_STATIC], [AC_DISABLE_STATIC($@)]) dnl aclocal-1.4 backwards compatibility: dnl AC_DEFUN([AM_ENABLE_STATIC], []) dnl AC_DEFUN([AM_DISABLE_STATIC], []) # _LT_ENABLE_FAST_INSTALL([DEFAULT]) # ---------------------------------- # implement the --enable-fast-install flag, and support the 'fast-install' # and 'disable-fast-install' LT_INIT options. # DEFAULT is either 'yes' or 'no'. If omitted, it defaults to 'yes'. m4_define([_LT_ENABLE_FAST_INSTALL], [m4_define([_LT_ENABLE_FAST_INSTALL_DEFAULT], [m4_if($1, no, no, yes)])dnl AC_ARG_ENABLE([fast-install], [AS_HELP_STRING([--enable-fast-install@<:@=PKGS@:>@], [optimize for fast installation @<:@default=]_LT_ENABLE_FAST_INSTALL_DEFAULT[@:>@])], [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], [enable_fast_install=]_LT_ENABLE_FAST_INSTALL_DEFAULT) _LT_DECL([fast_install], [enable_fast_install], [0], [Whether or not to optimize for fast installation])dnl ])# _LT_ENABLE_FAST_INSTALL LT_OPTION_DEFINE([LT_INIT], [fast-install], [_LT_ENABLE_FAST_INSTALL([yes])]) LT_OPTION_DEFINE([LT_INIT], [disable-fast-install], [_LT_ENABLE_FAST_INSTALL([no])]) # Old names: AU_DEFUN([AC_ENABLE_FAST_INSTALL], [_LT_SET_OPTION([LT_INIT], m4_if([$1], [no], [disable-])[fast-install]) AC_DIAGNOSE([obsolete], [$0: Remove this warning and the call to _LT_SET_OPTION when you put the 'fast-install' option into LT_INIT's first parameter.]) ]) AU_DEFUN([AC_DISABLE_FAST_INSTALL], [_LT_SET_OPTION([LT_INIT], [disable-fast-install]) AC_DIAGNOSE([obsolete], [$0: Remove this warning and the call to _LT_SET_OPTION when you put the 'disable-fast-install' option into LT_INIT's first parameter.]) ]) dnl aclocal-1.4 backwards compatibility: dnl AC_DEFUN([AC_ENABLE_FAST_INSTALL], []) dnl AC_DEFUN([AM_DISABLE_FAST_INSTALL], []) # _LT_WITH_AIX_SONAME([DEFAULT]) # ---------------------------------- # implement the --with-aix-soname flag, and support the `aix-soname=aix' # and `aix-soname=both' and `aix-soname=svr4' LT_INIT options. DEFAULT # is either `aix', `both' or `svr4'. If omitted, it defaults to `aix'. m4_define([_LT_WITH_AIX_SONAME], [m4_define([_LT_WITH_AIX_SONAME_DEFAULT], [m4_if($1, svr4, svr4, m4_if($1, both, both, aix))])dnl shared_archive_member_spec= case $host,$enable_shared in power*-*-aix[[5-9]]*,yes) AC_MSG_CHECKING([which variant of shared library versioning to provide]) AC_ARG_WITH([aix-soname], [AS_HELP_STRING([--with-aix-soname=aix|svr4|both], [shared library versioning (aka "SONAME") variant to provide on AIX, @<:@default=]_LT_WITH_AIX_SONAME_DEFAULT[@:>@.])], [case $withval in aix|svr4|both) ;; *) AC_MSG_ERROR([Unknown argument to --with-aix-soname]) ;; esac lt_cv_with_aix_soname=$with_aix_soname], [AC_CACHE_VAL([lt_cv_with_aix_soname], [lt_cv_with_aix_soname=]_LT_WITH_AIX_SONAME_DEFAULT) with_aix_soname=$lt_cv_with_aix_soname]) AC_MSG_RESULT([$with_aix_soname]) if test aix != "$with_aix_soname"; then # For the AIX way of multilib, we name the shared archive member # based on the bitwidth used, traditionally 'shr.o' or 'shr_64.o', # and 'shr.imp' or 'shr_64.imp', respectively, for the Import File. # Even when GNU compilers ignore OBJECT_MODE but need '-maix64' flag, # the AIX toolchain works better with OBJECT_MODE set (default 32). if test 64 = "${OBJECT_MODE-32}"; then shared_archive_member_spec=shr_64 else shared_archive_member_spec=shr fi fi ;; *) with_aix_soname=aix ;; esac _LT_DECL([], [shared_archive_member_spec], [0], [Shared archive member basename, for filename based shared library versioning on AIX])dnl ])# _LT_WITH_AIX_SONAME LT_OPTION_DEFINE([LT_INIT], [aix-soname=aix], [_LT_WITH_AIX_SONAME([aix])]) LT_OPTION_DEFINE([LT_INIT], [aix-soname=both], [_LT_WITH_AIX_SONAME([both])]) LT_OPTION_DEFINE([LT_INIT], [aix-soname=svr4], [_LT_WITH_AIX_SONAME([svr4])]) # _LT_WITH_PIC([MODE]) # -------------------- # implement the --with-pic flag, and support the 'pic-only' and 'no-pic' # LT_INIT options. # MODE is either 'yes' or 'no'. If omitted, it defaults to 'both'. m4_define([_LT_WITH_PIC], [AC_ARG_WITH([pic], [AS_HELP_STRING([--with-pic@<:@=PKGS@:>@], [try to use only PIC/non-PIC objects @<:@default=use both@:>@])], [lt_p=${PACKAGE-default} case $withval in yes|no) pic_mode=$withval ;; *) pic_mode=default # Look at the argument we got. We use all the common list separators. lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR, for lt_pkg in $withval; do IFS=$lt_save_ifs if test "X$lt_pkg" = "X$lt_p"; then pic_mode=yes fi done IFS=$lt_save_ifs ;; esac], [pic_mode=m4_default([$1], [default])]) _LT_DECL([], [pic_mode], [0], [What type of objects to build])dnl ])# _LT_WITH_PIC LT_OPTION_DEFINE([LT_INIT], [pic-only], [_LT_WITH_PIC([yes])]) LT_OPTION_DEFINE([LT_INIT], [no-pic], [_LT_WITH_PIC([no])]) # Old name: AU_DEFUN([AC_LIBTOOL_PICMODE], [_LT_SET_OPTION([LT_INIT], [pic-only]) AC_DIAGNOSE([obsolete], [$0: Remove this warning and the call to _LT_SET_OPTION when you put the 'pic-only' option into LT_INIT's first parameter.]) ]) dnl aclocal-1.4 backwards compatibility: dnl AC_DEFUN([AC_LIBTOOL_PICMODE], []) ## ----------------- ## ## LTDL_INIT Options ## ## ----------------- ## m4_define([_LTDL_MODE], []) LT_OPTION_DEFINE([LTDL_INIT], [nonrecursive], [m4_define([_LTDL_MODE], [nonrecursive])]) LT_OPTION_DEFINE([LTDL_INIT], [recursive], [m4_define([_LTDL_MODE], [recursive])]) LT_OPTION_DEFINE([LTDL_INIT], [subproject], [m4_define([_LTDL_MODE], [subproject])]) m4_define([_LTDL_TYPE], []) LT_OPTION_DEFINE([LTDL_INIT], [installable], [m4_define([_LTDL_TYPE], [installable])]) LT_OPTION_DEFINE([LTDL_INIT], [convenience], [m4_define([_LTDL_TYPE], [convenience])]) ecl-16.1.2/src/bdwgc/m4/ltsugar.m4000066400000000000000000000104401266352375300164770ustar00rootroot00000000000000# ltsugar.m4 -- libtool m4 base layer. -*-Autoconf-*- # # Copyright (C) 2004-2005, 2007-2008, 2011-2015 Free Software # Foundation, Inc. # Written by Gary V. Vaughan, 2004 # # 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 ltsugar.m4 # This is to help aclocal find these macros, as it can't see m4_define. AC_DEFUN([LTSUGAR_VERSION], [m4_if([0.1])]) # lt_join(SEP, ARG1, [ARG2...]) # ----------------------------- # Produce ARG1SEPARG2...SEPARGn, omitting [] arguments and their # associated separator. # Needed until we can rely on m4_join from Autoconf 2.62, since all earlier # versions in m4sugar had bugs. m4_define([lt_join], [m4_if([$#], [1], [], [$#], [2], [[$2]], [m4_if([$2], [], [], [[$2]_])$0([$1], m4_shift(m4_shift($@)))])]) m4_define([_lt_join], [m4_if([$#$2], [2], [], [m4_if([$2], [], [], [[$1$2]])$0([$1], m4_shift(m4_shift($@)))])]) # lt_car(LIST) # lt_cdr(LIST) # ------------ # Manipulate m4 lists. # These macros are necessary as long as will still need to support # Autoconf-2.59, which quotes differently. m4_define([lt_car], [[$1]]) m4_define([lt_cdr], [m4_if([$#], 0, [m4_fatal([$0: cannot be called without arguments])], [$#], 1, [], [m4_dquote(m4_shift($@))])]) m4_define([lt_unquote], $1) # lt_append(MACRO-NAME, STRING, [SEPARATOR]) # ------------------------------------------ # Redefine MACRO-NAME to hold its former content plus 'SEPARATOR''STRING'. # Note that neither SEPARATOR nor STRING are expanded; they are appended # to MACRO-NAME as is (leaving the expansion for when MACRO-NAME is invoked). # No SEPARATOR is output if MACRO-NAME was previously undefined (different # than defined and empty). # # This macro is needed until we can rely on Autoconf 2.62, since earlier # versions of m4sugar mistakenly expanded SEPARATOR but not STRING. m4_define([lt_append], [m4_define([$1], m4_ifdef([$1], [m4_defn([$1])[$3]])[$2])]) # lt_combine(SEP, PREFIX-LIST, INFIX, SUFFIX1, [SUFFIX2...]) # ---------------------------------------------------------- # Produce a SEP delimited list of all paired combinations of elements of # PREFIX-LIST with SUFFIX1 through SUFFIXn. Each element of the list # has the form PREFIXmINFIXSUFFIXn. # Needed until we can rely on m4_combine added in Autoconf 2.62. m4_define([lt_combine], [m4_if(m4_eval([$# > 3]), [1], [m4_pushdef([_Lt_sep], [m4_define([_Lt_sep], m4_defn([lt_car]))])]]dnl [[m4_foreach([_Lt_prefix], [$2], [m4_foreach([_Lt_suffix], ]m4_dquote(m4_dquote(m4_shift(m4_shift(m4_shift($@)))))[, [_Lt_sep([$1])[]m4_defn([_Lt_prefix])[$3]m4_defn([_Lt_suffix])])])])]) # lt_if_append_uniq(MACRO-NAME, VARNAME, [SEPARATOR], [UNIQ], [NOT-UNIQ]) # ----------------------------------------------------------------------- # Iff MACRO-NAME does not yet contain VARNAME, then append it (delimited # by SEPARATOR if supplied) and expand UNIQ, else NOT-UNIQ. m4_define([lt_if_append_uniq], [m4_ifdef([$1], [m4_if(m4_index([$3]m4_defn([$1])[$3], [$3$2$3]), [-1], [lt_append([$1], [$2], [$3])$4], [$5])], [lt_append([$1], [$2], [$3])$4])]) # lt_dict_add(DICT, KEY, VALUE) # ----------------------------- m4_define([lt_dict_add], [m4_define([$1($2)], [$3])]) # lt_dict_add_subkey(DICT, KEY, SUBKEY, VALUE) # -------------------------------------------- m4_define([lt_dict_add_subkey], [m4_define([$1($2:$3)], [$4])]) # lt_dict_fetch(DICT, KEY, [SUBKEY]) # ---------------------------------- m4_define([lt_dict_fetch], [m4_ifval([$3], m4_ifdef([$1($2:$3)], [m4_defn([$1($2:$3)])]), m4_ifdef([$1($2)], [m4_defn([$1($2)])]))]) # lt_if_dict_fetch(DICT, KEY, [SUBKEY], VALUE, IF-TRUE, [IF-FALSE]) # ----------------------------------------------------------------- m4_define([lt_if_dict_fetch], [m4_if(lt_dict_fetch([$1], [$2], [$3]), [$4], [$5], [$6])]) # lt_dict_filter(DICT, [SUBKEY], VALUE, [SEPARATOR], KEY, [...]) # -------------------------------------------------------------- m4_define([lt_dict_filter], [m4_if([$5], [], [], [lt_join(m4_quote(m4_default([$4], [[, ]])), lt_unquote(m4_split(m4_normalize(m4_foreach(_Lt_key, lt_car([m4_shiftn(4, $@)]), [lt_if_dict_fetch([$1], _Lt_key, [$2], [$3], [_Lt_key ])])))))])[]dnl ]) ecl-16.1.2/src/bdwgc/m4/ltversion.m4000066400000000000000000000012731266352375300170470ustar00rootroot00000000000000# ltversion.m4 -- version numbers -*- Autoconf -*- # # Copyright (C) 2004, 2011-2015 Free Software Foundation, Inc. # Written by Scott James Remnant, 2004 # # 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. # @configure_input@ # serial 4179 ltversion.m4 # This file is part of GNU Libtool m4_define([LT_PACKAGE_VERSION], [2.4.6]) m4_define([LT_PACKAGE_REVISION], [2.4.6]) AC_DEFUN([LTVERSION_VERSION], [macro_version='2.4.6' macro_revision='2.4.6' _LT_DECL(, macro_version, 0, [Which release of libtool.m4 was used?]) _LT_DECL(, macro_revision, 0) ]) ecl-16.1.2/src/bdwgc/m4/lt~obsolete.m4000066400000000000000000000137741266352375300174050ustar00rootroot00000000000000# lt~obsolete.m4 -- aclocal satisfying obsolete definitions. -*-Autoconf-*- # # Copyright (C) 2004-2005, 2007, 2009, 2011-2015 Free Software # Foundation, Inc. # Written by Scott James Remnant, 2004. # # 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 lt~obsolete.m4 # These exist entirely to fool aclocal when bootstrapping libtool. # # In the past libtool.m4 has provided macros via AC_DEFUN (or AU_DEFUN), # which have later been changed to m4_define as they aren't part of the # exported API, or moved to Autoconf or Automake where they belong. # # The trouble is, aclocal is a bit thick. It'll see the old AC_DEFUN # in /usr/share/aclocal/libtool.m4 and remember it, then when it sees us # using a macro with the same name in our local m4/libtool.m4 it'll # pull the old libtool.m4 in (it doesn't see our shiny new m4_define # and doesn't know about Autoconf macros at all.) # # So we provide this file, which has a silly filename so it's always # included after everything else. This provides aclocal with the # AC_DEFUNs it wants, but when m4 processes it, it doesn't do anything # because those macros already exist, or will be overwritten later. # We use AC_DEFUN over AU_DEFUN for compatibility with aclocal-1.6. # # Anytime we withdraw an AC_DEFUN or AU_DEFUN, remember to add it here. # Yes, that means every name once taken will need to remain here until # we give up compatibility with versions before 1.7, at which point # we need to keep only those names which we still refer to. # This is to help aclocal find these macros, as it can't see m4_define. AC_DEFUN([LTOBSOLETE_VERSION], [m4_if([1])]) m4_ifndef([AC_LIBTOOL_LINKER_OPTION], [AC_DEFUN([AC_LIBTOOL_LINKER_OPTION])]) m4_ifndef([AC_PROG_EGREP], [AC_DEFUN([AC_PROG_EGREP])]) m4_ifndef([_LT_AC_PROG_ECHO_BACKSLASH], [AC_DEFUN([_LT_AC_PROG_ECHO_BACKSLASH])]) m4_ifndef([_LT_AC_SHELL_INIT], [AC_DEFUN([_LT_AC_SHELL_INIT])]) m4_ifndef([_LT_AC_SYS_LIBPATH_AIX], [AC_DEFUN([_LT_AC_SYS_LIBPATH_AIX])]) m4_ifndef([_LT_PROG_LTMAIN], [AC_DEFUN([_LT_PROG_LTMAIN])]) m4_ifndef([_LT_AC_TAGVAR], [AC_DEFUN([_LT_AC_TAGVAR])]) m4_ifndef([AC_LTDL_ENABLE_INSTALL], [AC_DEFUN([AC_LTDL_ENABLE_INSTALL])]) m4_ifndef([AC_LTDL_PREOPEN], [AC_DEFUN([AC_LTDL_PREOPEN])]) m4_ifndef([_LT_AC_SYS_COMPILER], [AC_DEFUN([_LT_AC_SYS_COMPILER])]) m4_ifndef([_LT_AC_LOCK], [AC_DEFUN([_LT_AC_LOCK])]) m4_ifndef([AC_LIBTOOL_SYS_OLD_ARCHIVE], [AC_DEFUN([AC_LIBTOOL_SYS_OLD_ARCHIVE])]) m4_ifndef([_LT_AC_TRY_DLOPEN_SELF], [AC_DEFUN([_LT_AC_TRY_DLOPEN_SELF])]) m4_ifndef([AC_LIBTOOL_PROG_CC_C_O], [AC_DEFUN([AC_LIBTOOL_PROG_CC_C_O])]) m4_ifndef([AC_LIBTOOL_SYS_HARD_LINK_LOCKS], [AC_DEFUN([AC_LIBTOOL_SYS_HARD_LINK_LOCKS])]) m4_ifndef([AC_LIBTOOL_OBJDIR], [AC_DEFUN([AC_LIBTOOL_OBJDIR])]) m4_ifndef([AC_LTDL_OBJDIR], [AC_DEFUN([AC_LTDL_OBJDIR])]) m4_ifndef([AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH], [AC_DEFUN([AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH])]) m4_ifndef([AC_LIBTOOL_SYS_LIB_STRIP], [AC_DEFUN([AC_LIBTOOL_SYS_LIB_STRIP])]) m4_ifndef([AC_PATH_MAGIC], [AC_DEFUN([AC_PATH_MAGIC])]) m4_ifndef([AC_PROG_LD_GNU], [AC_DEFUN([AC_PROG_LD_GNU])]) m4_ifndef([AC_PROG_LD_RELOAD_FLAG], [AC_DEFUN([AC_PROG_LD_RELOAD_FLAG])]) m4_ifndef([AC_DEPLIBS_CHECK_METHOD], [AC_DEFUN([AC_DEPLIBS_CHECK_METHOD])]) m4_ifndef([AC_LIBTOOL_PROG_COMPILER_NO_RTTI], [AC_DEFUN([AC_LIBTOOL_PROG_COMPILER_NO_RTTI])]) m4_ifndef([AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE], [AC_DEFUN([AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE])]) m4_ifndef([AC_LIBTOOL_PROG_COMPILER_PIC], [AC_DEFUN([AC_LIBTOOL_PROG_COMPILER_PIC])]) m4_ifndef([AC_LIBTOOL_PROG_LD_SHLIBS], [AC_DEFUN([AC_LIBTOOL_PROG_LD_SHLIBS])]) m4_ifndef([AC_LIBTOOL_POSTDEP_PREDEP], [AC_DEFUN([AC_LIBTOOL_POSTDEP_PREDEP])]) m4_ifndef([LT_AC_PROG_EGREP], [AC_DEFUN([LT_AC_PROG_EGREP])]) m4_ifndef([LT_AC_PROG_SED], [AC_DEFUN([LT_AC_PROG_SED])]) m4_ifndef([_LT_CC_BASENAME], [AC_DEFUN([_LT_CC_BASENAME])]) m4_ifndef([_LT_COMPILER_BOILERPLATE], [AC_DEFUN([_LT_COMPILER_BOILERPLATE])]) m4_ifndef([_LT_LINKER_BOILERPLATE], [AC_DEFUN([_LT_LINKER_BOILERPLATE])]) m4_ifndef([_AC_PROG_LIBTOOL], [AC_DEFUN([_AC_PROG_LIBTOOL])]) m4_ifndef([AC_LIBTOOL_SETUP], [AC_DEFUN([AC_LIBTOOL_SETUP])]) m4_ifndef([_LT_AC_CHECK_DLFCN], [AC_DEFUN([_LT_AC_CHECK_DLFCN])]) m4_ifndef([AC_LIBTOOL_SYS_DYNAMIC_LINKER], [AC_DEFUN([AC_LIBTOOL_SYS_DYNAMIC_LINKER])]) m4_ifndef([_LT_AC_TAGCONFIG], [AC_DEFUN([_LT_AC_TAGCONFIG])]) m4_ifndef([AC_DISABLE_FAST_INSTALL], [AC_DEFUN([AC_DISABLE_FAST_INSTALL])]) m4_ifndef([_LT_AC_LANG_CXX], [AC_DEFUN([_LT_AC_LANG_CXX])]) m4_ifndef([_LT_AC_LANG_F77], [AC_DEFUN([_LT_AC_LANG_F77])]) m4_ifndef([_LT_AC_LANG_GCJ], [AC_DEFUN([_LT_AC_LANG_GCJ])]) m4_ifndef([AC_LIBTOOL_LANG_C_CONFIG], [AC_DEFUN([AC_LIBTOOL_LANG_C_CONFIG])]) m4_ifndef([_LT_AC_LANG_C_CONFIG], [AC_DEFUN([_LT_AC_LANG_C_CONFIG])]) m4_ifndef([AC_LIBTOOL_LANG_CXX_CONFIG], [AC_DEFUN([AC_LIBTOOL_LANG_CXX_CONFIG])]) m4_ifndef([_LT_AC_LANG_CXX_CONFIG], [AC_DEFUN([_LT_AC_LANG_CXX_CONFIG])]) m4_ifndef([AC_LIBTOOL_LANG_F77_CONFIG], [AC_DEFUN([AC_LIBTOOL_LANG_F77_CONFIG])]) m4_ifndef([_LT_AC_LANG_F77_CONFIG], [AC_DEFUN([_LT_AC_LANG_F77_CONFIG])]) m4_ifndef([AC_LIBTOOL_LANG_GCJ_CONFIG], [AC_DEFUN([AC_LIBTOOL_LANG_GCJ_CONFIG])]) m4_ifndef([_LT_AC_LANG_GCJ_CONFIG], [AC_DEFUN([_LT_AC_LANG_GCJ_CONFIG])]) m4_ifndef([AC_LIBTOOL_LANG_RC_CONFIG], [AC_DEFUN([AC_LIBTOOL_LANG_RC_CONFIG])]) m4_ifndef([_LT_AC_LANG_RC_CONFIG], [AC_DEFUN([_LT_AC_LANG_RC_CONFIG])]) m4_ifndef([AC_LIBTOOL_CONFIG], [AC_DEFUN([AC_LIBTOOL_CONFIG])]) m4_ifndef([_LT_AC_FILE_LTDLL_C], [AC_DEFUN([_LT_AC_FILE_LTDLL_C])]) m4_ifndef([_LT_REQUIRED_DARWIN_CHECKS], [AC_DEFUN([_LT_REQUIRED_DARWIN_CHECKS])]) m4_ifndef([_LT_AC_PROG_CXXCPP], [AC_DEFUN([_LT_AC_PROG_CXXCPP])]) m4_ifndef([_LT_PREPARE_SED_QUOTE_VARS], [AC_DEFUN([_LT_PREPARE_SED_QUOTE_VARS])]) m4_ifndef([_LT_PROG_ECHO_BACKSLASH], [AC_DEFUN([_LT_PROG_ECHO_BACKSLASH])]) m4_ifndef([_LT_PROG_F77], [AC_DEFUN([_LT_PROG_F77])]) m4_ifndef([_LT_PROG_FC], [AC_DEFUN([_LT_PROG_FC])]) m4_ifndef([_LT_PROG_CXX], [AC_DEFUN([_LT_PROG_CXX])]) ecl-16.1.2/src/bdwgc/mach_dep.c000066400000000000000000000257141266352375300161520ustar00rootroot00000000000000/* * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. */ #include "private/gc_priv.h" #include #ifdef AMIGA # ifndef __GNUC__ # include # else # include # endif #endif #if defined(MACOS) && defined(__MWERKS__) #if defined(POWERPC) # define NONVOLATILE_GPR_COUNT 19 struct ppc_registers { unsigned long gprs[NONVOLATILE_GPR_COUNT]; /* R13-R31 */ }; typedef struct ppc_registers ppc_registers; asm static void getRegisters(register ppc_registers* regs) { stmw r13,regs->gprs /* save R13-R31 */ blr } static void PushMacRegisters(void) { ppc_registers regs; int i; getRegisters(®s); for (i = 0; i < NONVOLATILE_GPR_COUNT; i++) GC_push_one(regs.gprs[i]); } #else /* M68K */ asm static void PushMacRegisters(void) { sub.w #4,sp /* reserve space for one parameter */ move.l a2,(sp) jsr GC_push_one move.l a3,(sp) jsr GC_push_one move.l a4,(sp) jsr GC_push_one # if !__option(a6frames) /* perhaps a6 should be pushed if stack frames are not being used */ move.l a6,(sp) jsr GC_push_one # endif /* skip a5 (globals), a6 (frame pointer), and a7 (stack pointer) */ move.l d2,(sp) jsr GC_push_one move.l d3,(sp) jsr GC_push_one move.l d4,(sp) jsr GC_push_one move.l d5,(sp) jsr GC_push_one move.l d6,(sp) jsr GC_push_one move.l d7,(sp) jsr GC_push_one add.w #4,sp /* fix stack */ rts } #endif /* M68K */ #endif /* MACOS && __MWERKS__ */ # if defined(SPARC) || defined(IA64) /* Value returned from register flushing routine; either sp (SPARC) */ /* or ar.bsp (IA64). */ GC_INNER ptr_t GC_save_regs_ret_val = NULL; # endif /* Routine to mark from registers that are preserved by the C compiler. */ /* This must be ported to every new architecture. It is not optional, */ /* and should not be used on platforms that are either UNIX-like, or */ /* require thread support. */ #undef HAVE_PUSH_REGS #if defined(USE_ASM_PUSH_REGS) # define HAVE_PUSH_REGS #else /* No asm implementation */ # ifdef STACK_NOT_SCANNED void GC_push_regs(void) { /* empty */ } # define HAVE_PUSH_REGS # elif defined(M68K) && defined(AMIGA) /* This function is not static because it could also be */ /* erroneously defined in .S file, so this error would be caught */ /* by the linker. */ void GC_push_regs(void) { /* AMIGA - could be replaced by generic code */ /* a0, a1, d0 and d1 are caller save */ # ifdef __GNUC__ asm("subq.w &0x4,%sp"); /* allocate word on top of stack */ asm("mov.l %a2,(%sp)"); asm("jsr _GC_push_one"); asm("mov.l %a3,(%sp)"); asm("jsr _GC_push_one"); asm("mov.l %a4,(%sp)"); asm("jsr _GC_push_one"); asm("mov.l %a5,(%sp)"); asm("jsr _GC_push_one"); asm("mov.l %a6,(%sp)"); asm("jsr _GC_push_one"); /* Skip frame pointer and stack pointer */ asm("mov.l %d2,(%sp)"); asm("jsr _GC_push_one"); asm("mov.l %d3,(%sp)"); asm("jsr _GC_push_one"); asm("mov.l %d4,(%sp)"); asm("jsr _GC_push_one"); asm("mov.l %d5,(%sp)"); asm("jsr _GC_push_one"); asm("mov.l %d6,(%sp)"); asm("jsr _GC_push_one"); asm("mov.l %d7,(%sp)"); asm("jsr _GC_push_one"); asm("addq.w &0x4,%sp"); /* put stack back where it was */ # else /* !__GNUC__ */ GC_push_one(getreg(REG_A2)); GC_push_one(getreg(REG_A3)); # ifndef __SASC /* Can probably be changed to #if 0 -Kjetil M. (a4=globals) */ GC_push_one(getreg(REG_A4)); # endif GC_push_one(getreg(REG_A5)); GC_push_one(getreg(REG_A6)); /* Skip stack pointer */ GC_push_one(getreg(REG_D2)); GC_push_one(getreg(REG_D3)); GC_push_one(getreg(REG_D4)); GC_push_one(getreg(REG_D5)); GC_push_one(getreg(REG_D6)); GC_push_one(getreg(REG_D7)); # endif /* !__GNUC__ */ } # define HAVE_PUSH_REGS # elif defined(MACOS) # if defined(M68K) && defined(THINK_C) # define PushMacReg(reg) \ move.l reg,(sp) \ jsr GC_push_one void GC_push_regs(void) { asm { sub.w #4,sp ; reserve space for one parameter. PushMacReg(a2); PushMacReg(a3); PushMacReg(a4); ; skip a5 (globals), a6 (frame pointer), and a7 (stack pointer) PushMacReg(d2); PushMacReg(d3); PushMacReg(d4); PushMacReg(d5); PushMacReg(d6); PushMacReg(d7); add.w #4,sp ; fix stack. } } # define HAVE_PUSH_REGS # undef PushMacReg # elif defined(__MWERKS__) void GC_push_regs(void) { PushMacRegisters(); } # define HAVE_PUSH_REGS # endif /* __MWERKS__ */ # endif /* MACOS */ #endif /* !USE_ASM_PUSH_REGS */ #if defined(HAVE_PUSH_REGS) && defined(THREADS) # error GC_push_regs cannot be used with threads /* Would fail for GC_do_blocking. There are probably other safety */ /* issues. */ # undef HAVE_PUSH_REGS #endif #if !defined(HAVE_PUSH_REGS) && defined(UNIX_LIKE) # include # ifndef NO_GETCONTEXT # if defined(DARWIN) \ && (MAC_OS_X_VERSION_MAX_ALLOWED >= 1060 /*MAC_OS_X_VERSION_10_6*/) # include # else # include # endif /* !DARWIN */ # ifdef GETCONTEXT_FPU_EXCMASK_BUG # include # endif # endif #endif /* !HAVE_PUSH_REGS */ /* Ensure that either registers are pushed, or callee-save registers */ /* are somewhere on the stack, and then call fn(arg, ctxt). */ /* ctxt is either a pointer to a ucontext_t we generated, or NULL. */ GC_INNER void GC_with_callee_saves_pushed(void (*fn)(ptr_t, void *), ptr_t arg) { volatile int dummy; void * context = 0; # if defined(HAVE_PUSH_REGS) GC_push_regs(); # elif defined(UNIX_LIKE) && !defined(NO_GETCONTEXT) /* Older versions of Darwin seem to lack getcontext(). */ /* ARM and MIPS Linux often doesn't support a real */ /* getcontext(). */ ucontext_t ctxt; # ifdef GETCONTEXT_FPU_EXCMASK_BUG /* Workaround a bug (clearing the FPU exception mask) in */ /* getcontext on Linux/x86_64. */ # ifdef X86_64 /* We manipulate FPU control word here just not to force the */ /* client application to use -lm linker option. */ unsigned short old_fcw; __asm__ __volatile__ ("fstcw %0" : "=m" (*&old_fcw)); # else int except_mask = fegetexcept(); # endif # endif if (getcontext(&ctxt) < 0) ABORT ("getcontext failed: Use another register retrieval method?"); # ifdef GETCONTEXT_FPU_EXCMASK_BUG # ifdef X86_64 __asm__ __volatile__ ("fldcw %0" : : "m" (*&old_fcw)); { unsigned mxcsr; /* And now correct the exception mask in SSE MXCSR. */ __asm__ __volatile__ ("stmxcsr %0" : "=m" (*&mxcsr)); mxcsr = (mxcsr & ~(FE_ALL_EXCEPT << 7)) | ((old_fcw & FE_ALL_EXCEPT) << 7); __asm__ __volatile__ ("ldmxcsr %0" : : "m" (*&mxcsr)); } # else /* !X86_64 */ if (feenableexcept(except_mask) < 0) ABORT("feenableexcept failed"); # endif # endif context = &ctxt; # if defined(SPARC) || defined(IA64) /* On a register window machine, we need to save register */ /* contents on the stack for this to work. This may already be */ /* subsumed by the getcontext() call. */ GC_save_regs_ret_val = GC_save_regs_in_stack(); # endif /* register windows. */ # elif defined(HAVE_BUILTIN_UNWIND_INIT) /* This was suggested by Richard Henderson as the way to */ /* force callee-save registers and register windows onto */ /* the stack. */ __builtin_unwind_init(); # else /* !HAVE_BUILTIN_UNWIND_INIT && !UNIX_LIKE */ /* && !HAVE_PUSH_REGS */ /* Generic code */ /* The idea is due to Parag Patel at HP. */ /* We're not sure whether he would like */ /* to be acknowledged for it or not. */ jmp_buf regs; register word * i = (word *) regs; register ptr_t lim = (ptr_t)(regs) + (sizeof regs); /* Setjmp doesn't always clear all of the buffer. */ /* That tends to preserve garbage. Clear it. */ for (; (word)i < (word)lim; i++) { *i = 0; } # if defined(MSWIN32) || defined(MSWINCE) || defined(UTS4) \ || defined(OS2) || defined(CX_UX) || defined(__CC_ARM) \ || defined(LINUX) || defined(EWS4800) || defined(RTEMS) (void) setjmp(regs); # else (void) _setjmp(regs); /* We don't want to mess with signals. According to */ /* SUSV3, setjmp() may or may not save signal mask. */ /* _setjmp won't, but is less portable. */ # endif # endif /* !HAVE_PUSH_REGS ... */ /* FIXME: context here is sometimes just zero. At the moment the */ /* callees don't really need it. */ fn(arg, context); /* Strongly discourage the compiler from treating the above */ /* as a tail-call, since that would pop the register */ /* contents before we get a chance to look at them. */ GC_noop1((word)(&dummy)); } #if defined(ASM_CLEAR_CODE) # ifdef LINT ptr_t GC_clear_stack_inner(ptr_t arg, word limit) { return limit ? arg : 0; /* use both arguments */ } /* The real version is in a .S file */ # endif #endif /* ASM_CLEAR_CODE */ ecl-16.1.2/src/bdwgc/malloc.c000066400000000000000000000471741266352375300156650ustar00rootroot00000000000000/* * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. * Copyright (c) 1999-2004 Hewlett-Packard Development Company, L.P. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. */ #include "private/gc_priv.h" #include #include /* Allocate reclaim list for kind: */ /* Return TRUE on success */ STATIC GC_bool GC_alloc_reclaim_list(struct obj_kind *kind) { struct hblk ** result = (struct hblk **) GC_scratch_alloc((MAXOBJGRANULES+1) * sizeof(struct hblk *)); if (result == 0) return(FALSE); BZERO(result, (MAXOBJGRANULES+1)*sizeof(struct hblk *)); kind -> ok_reclaim_list = result; return(TRUE); } GC_INNER GC_bool GC_collect_or_expand(word needed_blocks, GC_bool ignore_off_page, GC_bool retry); /* from alloc.c */ /* Allocate a large block of size lb bytes. */ /* The block is not cleared. */ /* Flags is 0 or IGNORE_OFF_PAGE. */ /* We hold the allocation lock. */ /* EXTRA_BYTES were already added to lb. */ GC_INNER ptr_t GC_alloc_large(size_t lb, int k, unsigned flags) { struct hblk * h; word n_blocks; ptr_t result; GC_bool retry = FALSE; lb = ROUNDUP_GRANULE_SIZE(lb); n_blocks = OBJ_SZ_TO_BLOCKS(lb); if (!EXPECT(GC_is_initialized, TRUE)) GC_init(); /* Do our share of marking work */ if (GC_incremental && !GC_dont_gc) GC_collect_a_little_inner((int)n_blocks); h = GC_allochblk(lb, k, flags); # ifdef USE_MUNMAP if (0 == h) { GC_merge_unmapped(); h = GC_allochblk(lb, k, flags); } # endif while (0 == h && GC_collect_or_expand(n_blocks, flags != 0, retry)) { h = GC_allochblk(lb, k, flags); retry = TRUE; } if (h == 0) { result = 0; } else { size_t total_bytes = n_blocks * HBLKSIZE; if (n_blocks > 1) { GC_large_allocd_bytes += total_bytes; if (GC_large_allocd_bytes > GC_max_large_allocd_bytes) GC_max_large_allocd_bytes = GC_large_allocd_bytes; } /* FIXME: Do we need some way to reset GC_max_large_allocd_bytes? */ result = h -> hb_body; } return result; } /* Allocate a large block of size lb bytes. Clear if appropriate. */ /* We hold the allocation lock. */ /* EXTRA_BYTES were already added to lb. */ STATIC ptr_t GC_alloc_large_and_clear(size_t lb, int k, unsigned flags) { ptr_t result = GC_alloc_large(lb, k, flags); word n_blocks = OBJ_SZ_TO_BLOCKS(lb); if (0 == result) return 0; if (GC_debugging_started || GC_obj_kinds[k].ok_init) { /* Clear the whole block, in case of GC_realloc call. */ BZERO(result, n_blocks * HBLKSIZE); } return result; } /* allocate lb bytes for an object of kind k. */ /* Should not be used to directly to allocate */ /* objects such as STUBBORN objects that */ /* require special handling on allocation. */ /* First a version that assumes we already */ /* hold lock: */ GC_INNER void * GC_generic_malloc_inner(size_t lb, int k) { void *op; if(SMALL_OBJ(lb)) { struct obj_kind * kind = GC_obj_kinds + k; size_t lg = GC_size_map[lb]; void ** opp = &(kind -> ok_freelist[lg]); op = *opp; if (EXPECT(0 == op, FALSE)) { if (lg == 0) { if (!EXPECT(GC_is_initialized, TRUE)) { GC_init(); lg = GC_size_map[lb]; } if (0 == lg) { GC_extend_size_map(lb); lg = GC_size_map[lb]; GC_ASSERT(lg != 0); } /* Retry */ opp = &(kind -> ok_freelist[lg]); op = *opp; } if (0 == op) { if (0 == kind -> ok_reclaim_list && !GC_alloc_reclaim_list(kind)) return NULL; op = GC_allocobj(lg, k); if (0 == op) return NULL; } } *opp = obj_link(op); obj_link(op) = 0; GC_bytes_allocd += GRANULES_TO_BYTES(lg); } else { op = (ptr_t)GC_alloc_large_and_clear(ADD_SLOP(lb), k, 0); GC_bytes_allocd += lb; } return op; } /* Allocate a composite object of size n bytes. The caller guarantees */ /* that pointers past the first page are not relevant. Caller holds */ /* allocation lock. */ GC_INNER void * GC_generic_malloc_inner_ignore_off_page(size_t lb, int k) { word lb_adjusted; void * op; if (lb <= HBLKSIZE) return(GC_generic_malloc_inner(lb, k)); lb_adjusted = ADD_SLOP(lb); op = GC_alloc_large_and_clear(lb_adjusted, k, IGNORE_OFF_PAGE); GC_bytes_allocd += lb_adjusted; return op; } #ifdef GC_COLLECT_AT_MALLOC /* Parameter to force GC at every malloc of size greater or equal to */ /* the given value. This might be handy during debugging. */ size_t GC_dbg_collect_at_malloc_min_lb = (GC_COLLECT_AT_MALLOC); #endif GC_API GC_ATTR_MALLOC void * GC_CALL GC_generic_malloc(size_t lb, int k) { void * result; DCL_LOCK_STATE; if (EXPECT(GC_have_errors, FALSE)) GC_print_all_errors(); GC_INVOKE_FINALIZERS(); GC_DBG_COLLECT_AT_MALLOC(lb); if (SMALL_OBJ(lb)) { LOCK(); result = GC_generic_malloc_inner(lb, k); UNLOCK(); } else { size_t lg; size_t lb_rounded; word n_blocks; GC_bool init; lg = ROUNDED_UP_GRANULES(lb); lb_rounded = GRANULES_TO_BYTES(lg); if (lb_rounded < lb) return((*GC_get_oom_fn())(lb)); n_blocks = OBJ_SZ_TO_BLOCKS(lb_rounded); init = GC_obj_kinds[k].ok_init; LOCK(); result = (ptr_t)GC_alloc_large(lb_rounded, k, 0); if (0 != result) { if (GC_debugging_started) { BZERO(result, n_blocks * HBLKSIZE); } else { # ifdef THREADS /* Clear any memory that might be used for GC descriptors */ /* before we release the lock. */ ((word *)result)[0] = 0; ((word *)result)[1] = 0; ((word *)result)[GRANULES_TO_WORDS(lg)-1] = 0; ((word *)result)[GRANULES_TO_WORDS(lg)-2] = 0; # endif } } GC_bytes_allocd += lb_rounded; UNLOCK(); if (init && !GC_debugging_started && 0 != result) { BZERO(result, n_blocks * HBLKSIZE); } } if (0 == result) { return((*GC_get_oom_fn())(lb)); } else { return(result); } } /* Allocate lb bytes of atomic (pointer-free) data. */ #ifdef THREAD_LOCAL_ALLOC GC_INNER void * GC_core_malloc_atomic(size_t lb) #else GC_API GC_ATTR_MALLOC void * GC_CALL GC_malloc_atomic(size_t lb) #endif { void *op; size_t lg; DCL_LOCK_STATE; if(SMALL_OBJ(lb)) { GC_DBG_COLLECT_AT_MALLOC(lb); lg = GC_size_map[lb]; LOCK(); op = GC_aobjfreelist[lg]; if (EXPECT(0 == op, FALSE)) { UNLOCK(); return(GENERAL_MALLOC((word)lb, PTRFREE)); } GC_aobjfreelist[lg] = obj_link(op); GC_bytes_allocd += GRANULES_TO_BYTES(lg); UNLOCK(); return((void *) op); } else { return(GENERAL_MALLOC((word)lb, PTRFREE)); } } /* Allocate lb bytes of composite (pointerful) data */ #ifdef THREAD_LOCAL_ALLOC GC_INNER void * GC_core_malloc(size_t lb) #else GC_API GC_ATTR_MALLOC void * GC_CALL GC_malloc(size_t lb) #endif { void *op; size_t lg; DCL_LOCK_STATE; if(SMALL_OBJ(lb)) { GC_DBG_COLLECT_AT_MALLOC(lb); lg = GC_size_map[lb]; LOCK(); op = GC_objfreelist[lg]; if (EXPECT(0 == op, FALSE)) { UNLOCK(); return (GENERAL_MALLOC((word)lb, NORMAL)); } GC_ASSERT(0 == obj_link(op) || ((word)obj_link(op) <= (word)GC_greatest_plausible_heap_addr && (word)obj_link(op) >= (word)GC_least_plausible_heap_addr)); GC_objfreelist[lg] = obj_link(op); obj_link(op) = 0; GC_bytes_allocd += GRANULES_TO_BYTES(lg); UNLOCK(); return op; } else { return(GENERAL_MALLOC(lb, NORMAL)); } } /* Allocate lb bytes of pointerful, traced, but not collectible data. */ GC_API GC_ATTR_MALLOC void * GC_CALL GC_malloc_uncollectable(size_t lb) { void *op; size_t lg; DCL_LOCK_STATE; if (SMALL_OBJ(lb)) { GC_DBG_COLLECT_AT_MALLOC(lb); if (EXTRA_BYTES != 0 && lb != 0) lb--; /* We don't need the extra byte, since this won't be */ /* collected anyway. */ lg = GC_size_map[lb]; LOCK(); op = GC_uobjfreelist[lg]; if (EXPECT(op != 0, TRUE)) { GC_uobjfreelist[lg] = obj_link(op); obj_link(op) = 0; GC_bytes_allocd += GRANULES_TO_BYTES(lg); /* Mark bit ws already set on free list. It will be */ /* cleared only temporarily during a collection, as a */ /* result of the normal free list mark bit clearing. */ GC_non_gc_bytes += GRANULES_TO_BYTES(lg); UNLOCK(); } else { UNLOCK(); op = GC_generic_malloc(lb, UNCOLLECTABLE); /* For small objects, the free lists are completely marked. */ } GC_ASSERT(0 == op || GC_is_marked(op)); } else { hdr * hhdr; op = GC_generic_malloc(lb, UNCOLLECTABLE); if (0 == op) return(0); GC_ASSERT(((word)op & (HBLKSIZE - 1)) == 0); /* large block */ hhdr = HDR(op); /* We don't need the lock here, since we have an undisguised */ /* pointer. We do need to hold the lock while we adjust */ /* mark bits. */ LOCK(); set_mark_bit_from_hdr(hhdr, 0); /* Only object. */ # ifndef THREADS GC_ASSERT(hhdr -> hb_n_marks == 0); /* This is not guaranteed in the multi-threaded case */ /* because the counter could be updated before locking. */ # endif hhdr -> hb_n_marks = 1; UNLOCK(); } return op; } #ifdef REDIRECT_MALLOC # ifndef MSWINCE # include # endif /* Avoid unnecessary nested procedure calls here, by #defining some */ /* malloc replacements. Otherwise we end up saving a */ /* meaningless return address in the object. It also speeds things up, */ /* but it is admittedly quite ugly. */ # define GC_debug_malloc_replacement(lb) GC_debug_malloc(lb, GC_DBG_EXTRAS) void * malloc(size_t lb) { /* It might help to manually inline the GC_malloc call here. */ /* But any decent compiler should reduce the extra procedure call */ /* to at most a jump instruction in this case. */ # if defined(I386) && defined(GC_SOLARIS_THREADS) /* Thread initialization can call malloc before we're ready for. */ /* It's not clear that this is enough to help matters. */ /* The thread implementation may well call malloc at other */ /* inopportune times. */ if (!EXPECT(GC_is_initialized, TRUE)) return sbrk(lb); # endif /* I386 && GC_SOLARIS_THREADS */ return((void *)REDIRECT_MALLOC(lb)); } #if defined(GC_LINUX_THREADS) /* && !defined(USE_PROC_FOR_LIBRARIES) */ STATIC ptr_t GC_libpthread_start = 0; STATIC ptr_t GC_libpthread_end = 0; STATIC ptr_t GC_libld_start = 0; STATIC ptr_t GC_libld_end = 0; STATIC void GC_init_lib_bounds(void) { if (GC_libpthread_start != 0) return; GC_init(); /* if not called yet */ if (!GC_text_mapping("libpthread-", &GC_libpthread_start, &GC_libpthread_end)) { WARN("Failed to find libpthread.so text mapping: Expect crash\n", 0); /* This might still work with some versions of libpthread, */ /* so we don't abort. Perhaps we should. */ /* Generate message only once: */ GC_libpthread_start = (ptr_t)1; } if (!GC_text_mapping("ld-", &GC_libld_start, &GC_libld_end)) { WARN("Failed to find ld.so text mapping: Expect crash\n", 0); } } #endif /* GC_LINUX_THREADS */ #include #ifdef SIZE_MAX # define GC_SIZE_MAX SIZE_MAX #else # define GC_SIZE_MAX (~(size_t)0) #endif #define GC_SQRT_SIZE_MAX ((1U << (WORDSZ / 2)) - 1) void * calloc(size_t n, size_t lb) { if ((lb | n) > GC_SQRT_SIZE_MAX /* fast initial test */ && lb && n > GC_SIZE_MAX / lb) return NULL; # if defined(GC_LINUX_THREADS) /* && !defined(USE_PROC_FOR_LIBRARIES) */ /* libpthread allocated some memory that is only pointed to by */ /* mmapped thread stacks. Make sure it is not collectible. */ { static GC_bool lib_bounds_set = FALSE; ptr_t caller = (ptr_t)__builtin_return_address(0); /* This test does not need to ensure memory visibility, since */ /* the bounds will be set when/if we create another thread. */ if (!EXPECT(lib_bounds_set, TRUE)) { GC_init_lib_bounds(); lib_bounds_set = TRUE; } if (((word)caller >= (word)GC_libpthread_start && (word)caller < (word)GC_libpthread_end) || ((word)caller >= (word)GC_libld_start && (word)caller < (word)GC_libld_end)) return GC_malloc_uncollectable(n*lb); /* The two ranges are actually usually adjacent, so there may */ /* be a way to speed this up. */ } # endif return((void *)REDIRECT_MALLOC(n*lb)); } #ifndef strdup char *strdup(const char *s) { size_t lb = strlen(s) + 1; char *result = (char *)REDIRECT_MALLOC(lb); if (result == 0) { errno = ENOMEM; return 0; } BCOPY(s, result, lb); return result; } #endif /* !defined(strdup) */ /* If strdup is macro defined, we assume that it actually calls malloc, */ /* and thus the right thing will happen even without overriding it. */ /* This seems to be true on most Linux systems. */ #ifndef strndup /* This is similar to strdup(). */ char *strndup(const char *str, size_t size) { char *copy; size_t len = strlen(str); if (len > size) len = size; copy = (char *)REDIRECT_MALLOC(len + 1); if (copy == NULL) { errno = ENOMEM; return NULL; } BCOPY(str, copy, len); copy[len] = '\0'; return copy; } #endif /* !strndup */ #undef GC_debug_malloc_replacement #endif /* REDIRECT_MALLOC */ /* Explicitly deallocate an object p. */ GC_API void GC_CALL GC_free(void * p) { struct hblk *h; hdr *hhdr; size_t sz; /* In bytes */ size_t ngranules; /* sz in granules */ void **flh; int knd; struct obj_kind * ok; DCL_LOCK_STATE; if (p == 0) return; /* Required by ANSI. It's not my fault ... */ # ifdef LOG_ALLOCS GC_log_printf("GC_free(%p) after GC #%lu\n", p, (unsigned long)GC_gc_no); # endif h = HBLKPTR(p); hhdr = HDR(h); # if defined(REDIRECT_MALLOC) && \ (defined(GC_SOLARIS_THREADS) || defined(GC_LINUX_THREADS) \ || defined(MSWIN32)) /* For Solaris, we have to redirect malloc calls during */ /* initialization. For the others, this seems to happen */ /* implicitly. */ /* Don't try to deallocate that memory. */ if (0 == hhdr) return; # endif GC_ASSERT(GC_base(p) == p); sz = hhdr -> hb_sz; ngranules = BYTES_TO_GRANULES(sz); knd = hhdr -> hb_obj_kind; ok = &GC_obj_kinds[knd]; if (EXPECT(ngranules <= MAXOBJGRANULES, TRUE)) { LOCK(); GC_bytes_freed += sz; if (IS_UNCOLLECTABLE(knd)) GC_non_gc_bytes -= sz; /* Its unnecessary to clear the mark bit. If the */ /* object is reallocated, it doesn't matter. O.w. the */ /* collector will do it, since it's on a free list. */ if (ok -> ok_init) { BZERO((word *)p + 1, sz-sizeof(word)); } flh = &(ok -> ok_freelist[ngranules]); obj_link(p) = *flh; *flh = (ptr_t)p; UNLOCK(); } else { size_t nblocks = OBJ_SZ_TO_BLOCKS(sz); LOCK(); GC_bytes_freed += sz; if (IS_UNCOLLECTABLE(knd)) GC_non_gc_bytes -= sz; if (nblocks > 1) { GC_large_allocd_bytes -= nblocks * HBLKSIZE; } GC_freehblk(h); UNLOCK(); } } /* Explicitly deallocate an object p when we already hold lock. */ /* Only used for internally allocated objects, so we can take some */ /* shortcuts. */ #ifdef THREADS GC_INNER void GC_free_inner(void * p) { struct hblk *h; hdr *hhdr; size_t sz; /* bytes */ size_t ngranules; /* sz in granules */ void ** flh; int knd; struct obj_kind * ok; h = HBLKPTR(p); hhdr = HDR(h); knd = hhdr -> hb_obj_kind; sz = hhdr -> hb_sz; ngranules = BYTES_TO_GRANULES(sz); ok = &GC_obj_kinds[knd]; if (ngranules <= MAXOBJGRANULES) { GC_bytes_freed += sz; if (IS_UNCOLLECTABLE(knd)) GC_non_gc_bytes -= sz; if (ok -> ok_init) { BZERO((word *)p + 1, sz-sizeof(word)); } flh = &(ok -> ok_freelist[ngranules]); obj_link(p) = *flh; *flh = (ptr_t)p; } else { size_t nblocks = OBJ_SZ_TO_BLOCKS(sz); GC_bytes_freed += sz; if (IS_UNCOLLECTABLE(knd)) GC_non_gc_bytes -= sz; if (nblocks > 1) { GC_large_allocd_bytes -= nblocks * HBLKSIZE; } GC_freehblk(h); } } #endif /* THREADS */ #if defined(REDIRECT_MALLOC) && !defined(REDIRECT_FREE) # define REDIRECT_FREE GC_free #endif #ifdef REDIRECT_FREE void free(void * p) { # if defined(GC_LINUX_THREADS) && !defined(USE_PROC_FOR_LIBRARIES) { /* Don't bother with initialization checks. If nothing */ /* has been initialized, the check fails, and that's safe, */ /* since we have not allocated uncollectible objects neither. */ ptr_t caller = (ptr_t)__builtin_return_address(0); /* This test does not need to ensure memory visibility, since */ /* the bounds will be set when/if we create another thread. */ if (((word)caller >= (word)GC_libpthread_start && (word)caller < (word)GC_libpthread_end) || ((word)caller >= (word)GC_libld_start && (word)caller < (word)GC_libld_end)) { GC_free(p); return; } } # endif # ifndef IGNORE_FREE REDIRECT_FREE(p); # endif } #endif /* REDIRECT_FREE */ ecl-16.1.2/src/bdwgc/mallocx.c000066400000000000000000000513661266352375300160530ustar00rootroot00000000000000/* * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. * Copyright (c) 1996 by Silicon Graphics. All rights reserved. * Copyright (c) 2000 by Hewlett-Packard Company. All rights reserved. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. */ #include "private/gc_priv.h" /* * These are extra allocation routines which are likely to be less * frequently used than those in malloc.c. They are separate in the * hope that the .o file will be excluded from statically linked * executables. We should probably break this up further. */ #include #include #ifdef MSWINCE # ifndef WIN32_LEAN_AND_MEAN # define WIN32_LEAN_AND_MEAN 1 # endif # define NOSERVICE # include #else # include #endif /* Some externally visible but unadvertised variables to allow access to */ /* free lists from inlined allocators without including gc_priv.h */ /* or introducing dependencies on internal data structure layouts. */ void ** const GC_objfreelist_ptr = GC_objfreelist; void ** const GC_aobjfreelist_ptr = GC_aobjfreelist; void ** const GC_uobjfreelist_ptr = GC_uobjfreelist; # ifdef ATOMIC_UNCOLLECTABLE void ** const GC_auobjfreelist_ptr = GC_auobjfreelist; # endif GC_API int GC_CALL GC_get_kind_and_size(const void * p, size_t * psize) { hdr * hhdr = HDR(p); if (psize != NULL) { *psize = hhdr -> hb_sz; } return hhdr -> hb_obj_kind; } GC_API GC_ATTR_MALLOC void * GC_CALL GC_generic_or_special_malloc(size_t lb, int knd) { switch(knd) { # ifdef STUBBORN_ALLOC case STUBBORN: return GC_malloc_stubborn(lb); # endif case PTRFREE: return GC_malloc_atomic(lb); case NORMAL: return GC_malloc(lb); case UNCOLLECTABLE: return GC_malloc_uncollectable(lb); # ifdef ATOMIC_UNCOLLECTABLE case AUNCOLLECTABLE: return GC_malloc_atomic_uncollectable(lb); # endif /* ATOMIC_UNCOLLECTABLE */ default: return GC_generic_malloc(lb, knd); } } /* Change the size of the block pointed to by p to contain at least */ /* lb bytes. The object may be (and quite likely will be) moved. */ /* The kind (e.g. atomic) is the same as that of the old. */ /* Shrinking of large blocks is not implemented well. */ GC_API void * GC_CALL GC_realloc(void * p, size_t lb) { struct hblk * h; hdr * hhdr; size_t sz; /* Current size in bytes */ size_t orig_sz; /* Original sz in bytes */ int obj_kind; if (p == 0) return(GC_malloc(lb)); /* Required by ANSI */ h = HBLKPTR(p); hhdr = HDR(h); sz = hhdr -> hb_sz; obj_kind = hhdr -> hb_obj_kind; orig_sz = sz; if (sz > MAXOBJBYTES) { /* Round it up to the next whole heap block */ word descr; sz = (sz+HBLKSIZE-1) & (~HBLKMASK); hhdr -> hb_sz = sz; descr = GC_obj_kinds[obj_kind].ok_descriptor; if (GC_obj_kinds[obj_kind].ok_relocate_descr) descr += sz; hhdr -> hb_descr = descr; # ifdef MARK_BIT_PER_OBJ GC_ASSERT(hhdr -> hb_inv_sz == LARGE_INV_SZ); # else GC_ASSERT((hhdr -> hb_flags & LARGE_BLOCK) != 0 && hhdr -> hb_map[ANY_INDEX] == 1); # endif if (IS_UNCOLLECTABLE(obj_kind)) GC_non_gc_bytes += (sz - orig_sz); /* Extra area is already cleared by GC_alloc_large_and_clear. */ } if (ADD_SLOP(lb) <= sz) { if (lb >= (sz >> 1)) { # ifdef STUBBORN_ALLOC if (obj_kind == STUBBORN) GC_change_stubborn(p); # endif if (orig_sz > lb) { /* Clear unneeded part of object to avoid bogus pointer */ /* tracing. */ /* Safe for stubborn objects. */ BZERO(((ptr_t)p) + lb, orig_sz - lb); } return(p); } else { /* shrink */ void * result = GC_generic_or_special_malloc((word)lb, obj_kind); if (result == 0) return(0); /* Could also return original object. But this */ /* gives the client warning of imminent disaster. */ BCOPY(p, result, lb); # ifndef IGNORE_FREE GC_free(p); # endif return(result); } } else { /* grow */ void * result = GC_generic_or_special_malloc((word)lb, obj_kind); if (result == 0) return(0); BCOPY(p, result, sz); # ifndef IGNORE_FREE GC_free(p); # endif return(result); } } # if defined(REDIRECT_MALLOC) && !defined(REDIRECT_REALLOC) # define REDIRECT_REALLOC GC_realloc # endif # ifdef REDIRECT_REALLOC /* As with malloc, avoid two levels of extra calls here. */ # define GC_debug_realloc_replacement(p, lb) \ GC_debug_realloc(p, lb, GC_DBG_EXTRAS) void * realloc(void * p, size_t lb) { return(REDIRECT_REALLOC(p, lb)); } # undef GC_debug_realloc_replacement # endif /* REDIRECT_REALLOC */ /* Allocate memory such that only pointers to near the */ /* beginning of the object are considered. */ /* We avoid holding allocation lock while we clear the memory. */ GC_API GC_ATTR_MALLOC void * GC_CALL GC_generic_malloc_ignore_off_page(size_t lb, int k) { void *result; size_t lg; size_t lb_rounded; word n_blocks; GC_bool init; DCL_LOCK_STATE; if (SMALL_OBJ(lb)) return GC_generic_malloc(lb, k); lg = ROUNDED_UP_GRANULES(lb); lb_rounded = GRANULES_TO_BYTES(lg); if (lb_rounded < lb) return((*GC_get_oom_fn())(lb)); n_blocks = OBJ_SZ_TO_BLOCKS(lb_rounded); init = GC_obj_kinds[k].ok_init; if (EXPECT(GC_have_errors, FALSE)) GC_print_all_errors(); GC_INVOKE_FINALIZERS(); GC_DBG_COLLECT_AT_MALLOC(lb); LOCK(); result = (ptr_t)GC_alloc_large(ADD_SLOP(lb), k, IGNORE_OFF_PAGE); if (0 != result) { if (GC_debugging_started) { BZERO(result, n_blocks * HBLKSIZE); } else { # ifdef THREADS /* Clear any memory that might be used for GC descriptors */ /* before we release the lock. */ ((word *)result)[0] = 0; ((word *)result)[1] = 0; ((word *)result)[GRANULES_TO_WORDS(lg)-1] = 0; ((word *)result)[GRANULES_TO_WORDS(lg)-2] = 0; # endif } } GC_bytes_allocd += lb_rounded; if (0 == result) { GC_oom_func oom_fn = GC_oom_fn; UNLOCK(); return((*oom_fn)(lb)); } else { UNLOCK(); if (init && !GC_debugging_started) { BZERO(result, n_blocks * HBLKSIZE); } return(result); } } GC_API GC_ATTR_MALLOC void * GC_CALL GC_malloc_ignore_off_page(size_t lb) { return GC_generic_malloc_ignore_off_page(lb, NORMAL); } GC_API GC_ATTR_MALLOC void * GC_CALL GC_malloc_atomic_ignore_off_page(size_t lb) { return GC_generic_malloc_ignore_off_page(lb, PTRFREE); } /* Increment GC_bytes_allocd from code that doesn't have direct access */ /* to GC_arrays. */ GC_API void GC_CALL GC_incr_bytes_allocd(size_t n) { GC_bytes_allocd += n; } /* The same for GC_bytes_freed. */ GC_API void GC_CALL GC_incr_bytes_freed(size_t n) { GC_bytes_freed += n; } # ifdef PARALLEL_MARK STATIC volatile AO_t GC_bytes_allocd_tmp = 0; /* Number of bytes of memory allocated since */ /* we released the GC lock. Instead of */ /* reacquiring the GC lock just to add this in, */ /* we add it in the next time we reacquire */ /* the lock. (Atomically adding it doesn't */ /* work, since we would have to atomically */ /* update it in GC_malloc, which is too */ /* expensive.) */ # endif /* PARALLEL_MARK */ /* Return a list of 1 or more objects of the indicated size, linked */ /* through the first word in the object. This has the advantage that */ /* it acquires the allocation lock only once, and may greatly reduce */ /* time wasted contending for the allocation lock. Typical usage would */ /* be in a thread that requires many items of the same size. It would */ /* keep its own free list in thread-local storage, and call */ /* GC_malloc_many or friends to replenish it. (We do not round up */ /* object sizes, since a call indicates the intention to consume many */ /* objects of exactly this size.) */ /* We assume that the size is a multiple of GRANULE_BYTES. */ /* We return the free-list by assigning it to *result, since it is */ /* not safe to return, e.g. a linked list of pointer-free objects, */ /* since the collector would not retain the entire list if it were */ /* invoked just as we were returning. */ /* Note that the client should usually clear the link field. */ GC_API void GC_CALL GC_generic_malloc_many(size_t lb, int k, void **result) { void *op; void *p; void **opp; size_t lw; /* Length in words. */ size_t lg; /* Length in granules. */ signed_word my_bytes_allocd = 0; struct obj_kind * ok = &(GC_obj_kinds[k]); struct hblk ** rlh; DCL_LOCK_STATE; GC_ASSERT(lb != 0 && (lb & (GRANULE_BYTES-1)) == 0); if (!SMALL_OBJ(lb)) { op = GC_generic_malloc(lb, k); if (EXPECT(0 != op, TRUE)) obj_link(op) = 0; *result = op; return; } lw = BYTES_TO_WORDS(lb); lg = BYTES_TO_GRANULES(lb); if (EXPECT(GC_have_errors, FALSE)) GC_print_all_errors(); GC_INVOKE_FINALIZERS(); GC_DBG_COLLECT_AT_MALLOC(lb); LOCK(); if (!EXPECT(GC_is_initialized, TRUE)) GC_init(); /* Do our share of marking work */ if (GC_incremental && !GC_dont_gc) { ENTER_GC(); GC_collect_a_little_inner(1); EXIT_GC(); } /* First see if we can reclaim a page of objects waiting to be */ /* reclaimed. */ rlh = ok -> ok_reclaim_list; if (rlh != NULL) { struct hblk * hbp; hdr * hhdr; rlh += lg; while ((hbp = *rlh) != 0) { hhdr = HDR(hbp); *rlh = hhdr -> hb_next; GC_ASSERT(hhdr -> hb_sz == lb); hhdr -> hb_last_reclaimed = (unsigned short) GC_gc_no; # ifdef PARALLEL_MARK if (GC_parallel) { signed_word my_bytes_allocd_tmp = (signed_word)AO_load(&GC_bytes_allocd_tmp); GC_ASSERT(my_bytes_allocd_tmp >= 0); /* We only decrement it while holding the GC lock. */ /* Thus we can't accidentally adjust it down in more */ /* than one thread simultaneously. */ if (my_bytes_allocd_tmp != 0) { (void)AO_fetch_and_add(&GC_bytes_allocd_tmp, (AO_t)(-my_bytes_allocd_tmp)); GC_bytes_allocd += my_bytes_allocd_tmp; } GC_acquire_mark_lock(); ++ GC_fl_builder_count; UNLOCK(); GC_release_mark_lock(); } # endif op = GC_reclaim_generic(hbp, hhdr, lb, ok -> ok_init, 0, &my_bytes_allocd); if (op != 0) { /* We also reclaimed memory, so we need to adjust */ /* that count. */ /* This should be atomic, so the results may be */ /* inaccurate. */ GC_bytes_found += my_bytes_allocd; # ifdef PARALLEL_MARK if (GC_parallel) { *result = op; (void)AO_fetch_and_add(&GC_bytes_allocd_tmp, (AO_t)my_bytes_allocd); GC_acquire_mark_lock(); -- GC_fl_builder_count; if (GC_fl_builder_count == 0) GC_notify_all_builder(); GC_release_mark_lock(); (void) GC_clear_stack(0); return; } # endif GC_bytes_allocd += my_bytes_allocd; goto out; } # ifdef PARALLEL_MARK if (GC_parallel) { GC_acquire_mark_lock(); -- GC_fl_builder_count; if (GC_fl_builder_count == 0) GC_notify_all_builder(); GC_release_mark_lock(); LOCK(); /* GC lock is needed for reclaim list access. We */ /* must decrement fl_builder_count before reacquiring */ /* the lock. Hopefully this path is rare. */ } # endif } } /* Next try to use prefix of global free list if there is one. */ /* We don't refill it, but we need to use it up before allocating */ /* a new block ourselves. */ opp = &(GC_obj_kinds[k].ok_freelist[lg]); if ( (op = *opp) != 0 ) { *opp = 0; my_bytes_allocd = 0; for (p = op; p != 0; p = obj_link(p)) { my_bytes_allocd += lb; if ((word)my_bytes_allocd >= HBLKSIZE) { *opp = obj_link(p); obj_link(p) = 0; break; } } GC_bytes_allocd += my_bytes_allocd; goto out; } /* Next try to allocate a new block worth of objects of this size. */ { struct hblk *h = GC_allochblk(lb, k, 0); if (h != 0) { if (IS_UNCOLLECTABLE(k)) GC_set_hdr_marks(HDR(h)); GC_bytes_allocd += HBLKSIZE - HBLKSIZE % lb; # ifdef PARALLEL_MARK if (GC_parallel) { GC_acquire_mark_lock(); ++ GC_fl_builder_count; UNLOCK(); GC_release_mark_lock(); op = GC_build_fl(h, lw, (ok -> ok_init || GC_debugging_started), 0); *result = op; GC_acquire_mark_lock(); -- GC_fl_builder_count; if (GC_fl_builder_count == 0) GC_notify_all_builder(); GC_release_mark_lock(); (void) GC_clear_stack(0); return; } # endif op = GC_build_fl(h, lw, (ok -> ok_init || GC_debugging_started), 0); goto out; } } /* As a last attempt, try allocating a single object. Note that */ /* this may trigger a collection or expand the heap. */ op = GC_generic_malloc_inner(lb, k); if (0 != op) obj_link(op) = 0; out: *result = op; UNLOCK(); (void) GC_clear_stack(0); } /* Note that the "atomic" version of this would be unsafe, since the */ /* links would not be seen by the collector. */ GC_API GC_ATTR_MALLOC void * GC_CALL GC_malloc_many(size_t lb) { void *result; GC_generic_malloc_many(ROUNDUP_GRANULE_SIZE(lb + EXTRA_BYTES), NORMAL, &result); return result; } /* Not well tested nor integrated. */ /* Debug version is tricky and currently missing. */ #include GC_API GC_ATTR_MALLOC void * GC_CALL GC_memalign(size_t align, size_t lb) { size_t new_lb; size_t offset; ptr_t result; if (align <= GRANULE_BYTES) return GC_malloc(lb); if (align >= HBLKSIZE/2 || lb >= HBLKSIZE/2) { if (align > HBLKSIZE) { return (*GC_get_oom_fn())(LONG_MAX-1024); /* Fail */ } return GC_malloc(lb <= HBLKSIZE? HBLKSIZE : lb); /* Will be HBLKSIZE aligned. */ } /* We could also try to make sure that the real rounded-up object size */ /* is a multiple of align. That would be correct up to HBLKSIZE. */ new_lb = lb + align - 1; result = GC_malloc(new_lb); /* It is OK not to check result for NULL as in that case */ /* GC_memalign returns NULL too since (0 + 0 % align) is 0. */ offset = (word)result % align; if (offset != 0) { offset = align - offset; if (!GC_all_interior_pointers) { if (offset >= VALID_OFFSET_SZ) return GC_malloc(HBLKSIZE); GC_register_displacement(offset); } } result = (void *) ((ptr_t)result + offset); GC_ASSERT((word)result % align == 0); return result; } /* This one exists largely to redirect posix_memalign for leaks finding. */ GC_API int GC_CALL GC_posix_memalign(void **memptr, size_t align, size_t lb) { /* Check alignment properly. */ if (((align - 1) & align) != 0 || align < sizeof(void *)) { # ifdef MSWINCE return ERROR_INVALID_PARAMETER; # else return EINVAL; # endif } if ((*memptr = GC_memalign(align, lb)) == NULL) { # ifdef MSWINCE return ERROR_NOT_ENOUGH_MEMORY; # else return ENOMEM; # endif } return 0; } #ifdef ATOMIC_UNCOLLECTABLE /* Allocate lb bytes of pointer-free, untraced, uncollectible data */ /* This is normally roughly equivalent to the system malloc. */ /* But it may be useful if malloc is redefined. */ GC_API GC_ATTR_MALLOC void * GC_CALL GC_malloc_atomic_uncollectable(size_t lb) { void *op; size_t lg; DCL_LOCK_STATE; if (SMALL_OBJ(lb)) { GC_DBG_COLLECT_AT_MALLOC(lb); if (EXTRA_BYTES != 0 && lb != 0) lb--; /* We don't need the extra byte, since this won't be */ /* collected anyway. */ lg = GC_size_map[lb]; LOCK(); op = GC_auobjfreelist[lg]; if (EXPECT(op != 0, TRUE)) { GC_auobjfreelist[lg] = obj_link(op); obj_link(op) = 0; GC_bytes_allocd += GRANULES_TO_BYTES(lg); /* Mark bit was already set while object was on free list. */ GC_non_gc_bytes += GRANULES_TO_BYTES(lg); UNLOCK(); } else { UNLOCK(); op = (ptr_t)GC_generic_malloc(lb, AUNCOLLECTABLE); } GC_ASSERT(0 == op || GC_is_marked(op)); return((void *) op); } else { hdr * hhdr; op = (ptr_t)GC_generic_malloc(lb, AUNCOLLECTABLE); if (0 == op) return(0); GC_ASSERT(((word)op & (HBLKSIZE - 1)) == 0); hhdr = HDR(op); LOCK(); set_mark_bit_from_hdr(hhdr, 0); /* Only object. */ # ifndef THREADS GC_ASSERT(hhdr -> hb_n_marks == 0); # endif hhdr -> hb_n_marks = 1; UNLOCK(); return((void *) op); } } #endif /* ATOMIC_UNCOLLECTABLE */ /* provide a version of strdup() that uses the collector to allocate the copy of the string */ GC_API GC_ATTR_MALLOC char * GC_CALL GC_strdup(const char *s) { char *copy; size_t lb; if (s == NULL) return NULL; lb = strlen(s) + 1; if ((copy = GC_malloc_atomic(lb)) == NULL) { # ifndef MSWINCE errno = ENOMEM; # endif return NULL; } BCOPY(s, copy, lb); return copy; } GC_API GC_ATTR_MALLOC char * GC_CALL GC_strndup(const char *str, size_t size) { char *copy; size_t len = strlen(str); /* str is expected to be non-NULL */ if (len > size) len = size; copy = GC_malloc_atomic(len + 1); if (copy == NULL) { # ifndef MSWINCE errno = ENOMEM; # endif return NULL; } BCOPY(str, copy, len); copy[len] = '\0'; return copy; } #ifdef GC_REQUIRE_WCSDUP # include /* for wcslen() */ GC_API GC_ATTR_MALLOC wchar_t * GC_CALL GC_wcsdup(const wchar_t *str) { size_t lb = (wcslen(str) + 1) * sizeof(wchar_t); wchar_t *copy = GC_malloc_atomic(lb); if (copy == NULL) { # ifndef MSWINCE errno = ENOMEM; # endif return NULL; } BCOPY(str, copy, lb); return copy; } #endif /* GC_REQUIRE_WCSDUP */ ecl-16.1.2/src/bdwgc/mark.c000066400000000000000000002160061266352375300153400ustar00rootroot00000000000000/* * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers * Copyright (c) 1991-1995 by Xerox Corporation. All rights reserved. * Copyright (c) 2000 by Hewlett-Packard Company. All rights reserved. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. * */ #include "private/gc_pmark.h" #include #if defined(MSWIN32) && defined(__GNUC__) # include #endif /* Make arguments appear live to compiler. Put here to minimize the */ /* risk of inlining. Used to minimize junk left in registers. */ void GC_noop6(word arg1 GC_ATTR_UNUSED, word arg2 GC_ATTR_UNUSED, word arg3 GC_ATTR_UNUSED, word arg4 GC_ATTR_UNUSED, word arg5 GC_ATTR_UNUSED, word arg6 GC_ATTR_UNUSED) { /* Empty */ } /* Single argument version, robust against whole program analysis. */ volatile word GC_noop_sink; GC_API void GC_CALL GC_noop1(word x) { GC_noop_sink = x; } /* mark_proc GC_mark_procs[MAX_MARK_PROCS] = {0} -- declared in gc_priv.h */ GC_INNER unsigned GC_n_mark_procs = GC_RESERVED_MARK_PROCS; /* Initialize GC_obj_kinds properly and standard free lists properly. */ /* This must be done statically since they may be accessed before */ /* GC_init is called. */ /* It's done here, since we need to deal with mark descriptors. */ GC_INNER struct obj_kind GC_obj_kinds[MAXOBJKINDS] = { /* PTRFREE */ { &GC_aobjfreelist[0], 0 /* filled in dynamically */, 0 | GC_DS_LENGTH, FALSE, FALSE /*, */ OK_DISCLAIM_INITZ }, /* NORMAL */ { &GC_objfreelist[0], 0, 0 | GC_DS_LENGTH, /* Adjusted in GC_init for EXTRA_BYTES */ TRUE /* add length to descr */, TRUE /*, */ OK_DISCLAIM_INITZ }, /* UNCOLLECTABLE */ { &GC_uobjfreelist[0], 0, 0 | GC_DS_LENGTH, TRUE /* add length to descr */, TRUE /*, */ OK_DISCLAIM_INITZ }, # ifdef ATOMIC_UNCOLLECTABLE /* AUNCOLLECTABLE */ { &GC_auobjfreelist[0], 0, 0 | GC_DS_LENGTH, FALSE /* add length to descr */, FALSE /*, */ OK_DISCLAIM_INITZ }, # endif # ifdef STUBBORN_ALLOC /*STUBBORN*/ { (void **)&GC_sobjfreelist[0], 0, 0 | GC_DS_LENGTH, TRUE /* add length to descr */, TRUE /*, */ OK_DISCLAIM_INITZ }, # endif }; # ifdef ATOMIC_UNCOLLECTABLE # ifdef STUBBORN_ALLOC # define GC_N_KINDS_INITIAL_VALUE 5 # else # define GC_N_KINDS_INITIAL_VALUE 4 # endif # else # ifdef STUBBORN_ALLOC # define GC_N_KINDS_INITIAL_VALUE 4 # else # define GC_N_KINDS_INITIAL_VALUE 3 # endif # endif GC_INNER unsigned GC_n_kinds = GC_N_KINDS_INITIAL_VALUE; # ifndef INITIAL_MARK_STACK_SIZE # define INITIAL_MARK_STACK_SIZE (1*HBLKSIZE) /* INITIAL_MARK_STACK_SIZE * sizeof(mse) should be a */ /* multiple of HBLKSIZE. */ /* The incremental collector actually likes a larger */ /* size, since it want to push all marked dirty objs */ /* before marking anything new. Currently we let it */ /* grow dynamically. */ # endif STATIC word GC_n_rescuing_pages = 0; /* Number of dirty pages we marked from */ /* excludes ptrfree pages, etc. */ GC_INNER size_t GC_mark_stack_size = 0; #ifdef PARALLEL_MARK STATIC volatile AO_t GC_first_nonempty = 0; /* Lowest entry on mark stack */ /* that may be nonempty. */ /* Updated only by initiating */ /* thread. */ #endif GC_INNER mark_state_t GC_mark_state = MS_NONE; GC_INNER GC_bool GC_mark_stack_too_small = FALSE; static struct hblk * scan_ptr; STATIC GC_bool GC_objects_are_marked = FALSE; /* Are there collectible marked objects in the heap? */ /* Is a collection in progress? Note that this can return true in the */ /* nonincremental case, if a collection has been abandoned and the */ /* mark state is now MS_INVALID. */ GC_INNER GC_bool GC_collection_in_progress(void) { return(GC_mark_state != MS_NONE); } /* clear all mark bits in the header */ GC_INNER void GC_clear_hdr_marks(hdr *hhdr) { size_t last_bit = FINAL_MARK_BIT(hhdr -> hb_sz); BZERO(hhdr -> hb_marks, sizeof(hhdr->hb_marks)); set_mark_bit_from_hdr(hhdr, last_bit); hhdr -> hb_n_marks = 0; } /* Set all mark bits in the header. Used for uncollectible blocks. */ GC_INNER void GC_set_hdr_marks(hdr *hhdr) { unsigned i; size_t sz = hhdr -> hb_sz; unsigned n_marks = (unsigned)FINAL_MARK_BIT(sz); # ifdef USE_MARK_BYTES for (i = 0; i <= n_marks; i += (unsigned)MARK_BIT_OFFSET(sz)) { hhdr -> hb_marks[i] = 1; } # else for (i = 0; i < divWORDSZ(n_marks + WORDSZ); ++i) { hhdr -> hb_marks[i] = ONES; } # endif # ifdef MARK_BIT_PER_OBJ hhdr -> hb_n_marks = n_marks - 1; # else hhdr -> hb_n_marks = HBLK_OBJS(sz); # endif } /* * Clear all mark bits associated with block h. */ static void clear_marks_for_block(struct hblk *h, word dummy GC_ATTR_UNUSED) { register hdr * hhdr = HDR(h); if (IS_UNCOLLECTABLE(hhdr -> hb_obj_kind)) return; /* Mark bit for these is cleared only once the object is */ /* explicitly deallocated. This either frees the block, or */ /* the bit is cleared once the object is on the free list. */ GC_clear_hdr_marks(hhdr); } /* Slow but general routines for setting/clearing/asking about mark bits */ GC_API void GC_CALL GC_set_mark_bit(const void *p) { struct hblk *h = HBLKPTR(p); hdr * hhdr = HDR(h); word bit_no = MARK_BIT_NO((ptr_t)p - (ptr_t)h, hhdr -> hb_sz); if (!mark_bit_from_hdr(hhdr, bit_no)) { set_mark_bit_from_hdr(hhdr, bit_no); ++hhdr -> hb_n_marks; } } GC_API void GC_CALL GC_clear_mark_bit(const void *p) { struct hblk *h = HBLKPTR(p); hdr * hhdr = HDR(h); word bit_no = MARK_BIT_NO((ptr_t)p - (ptr_t)h, hhdr -> hb_sz); if (mark_bit_from_hdr(hhdr, bit_no)) { size_t n_marks; clear_mark_bit_from_hdr(hhdr, bit_no); n_marks = hhdr -> hb_n_marks - 1; # ifdef PARALLEL_MARK if (n_marks != 0 || !GC_parallel) hhdr -> hb_n_marks = n_marks; /* Don't decrement to zero. The counts are approximate due to */ /* concurrency issues, but we need to ensure that a count of */ /* zero implies an empty block. */ # else hhdr -> hb_n_marks = n_marks; # endif } } GC_API int GC_CALL GC_is_marked(const void *p) { struct hblk *h = HBLKPTR(p); hdr * hhdr = HDR(h); word bit_no = MARK_BIT_NO((ptr_t)p - (ptr_t)h, hhdr -> hb_sz); return (int)mark_bit_from_hdr(hhdr, bit_no); /* 0 or 1 */ } /* * Clear mark bits in all allocated heap blocks. This invalidates * the marker invariant, and sets GC_mark_state to reflect this. * (This implicitly starts marking to reestablish the invariant.) */ GC_INNER void GC_clear_marks(void) { GC_apply_to_all_blocks(clear_marks_for_block, (word)0); GC_objects_are_marked = FALSE; GC_mark_state = MS_INVALID; scan_ptr = 0; } #ifdef CHECKSUMS void GC_check_dirty(void); #endif /* Initiate a garbage collection. Initiates a full collection if the */ /* mark state is invalid. */ GC_INNER void GC_initiate_gc(void) { # ifndef GC_DISABLE_INCREMENTAL if (GC_dirty_maintained) GC_read_dirty(); # endif # ifdef STUBBORN_ALLOC GC_read_changed(); # endif # ifdef CHECKSUMS if (GC_dirty_maintained) GC_check_dirty(); # endif GC_n_rescuing_pages = 0; if (GC_mark_state == MS_NONE) { GC_mark_state = MS_PUSH_RESCUERS; } else if (GC_mark_state != MS_INVALID) { ABORT("Unexpected state"); } /* else this is really a full collection, and mark */ /* bits are invalid. */ scan_ptr = 0; } #ifdef PARALLEL_MARK STATIC void GC_do_parallel_mark(void); /* initiate parallel marking. */ #endif /* PARALLEL_MARK */ #ifdef GC_DISABLE_INCREMENTAL # define GC_push_next_marked_dirty(h) GC_push_next_marked(h) #else STATIC struct hblk * GC_push_next_marked_dirty(struct hblk *h); /* Invoke GC_push_marked on next dirty block above h. */ /* Return a pointer just past the end of this block. */ #endif /* !GC_DISABLE_INCREMENTAL */ STATIC struct hblk * GC_push_next_marked(struct hblk *h); /* Ditto, but also mark from clean pages. */ STATIC struct hblk * GC_push_next_marked_uncollectable(struct hblk *h); /* Ditto, but mark only from uncollectible pages. */ static void alloc_mark_stack(size_t); # if (((defined(MSWIN32) || defined(MSWINCE)) && !defined(__GNUC__)) \ || (defined(MSWIN32) && defined(I386)) /* for Win98 */ \ || (defined(USE_PROC_FOR_LIBRARIES) && defined(THREADS))) \ && !defined(NO_WRAP_MARK_SOME) /* Under rare conditions, we may end up marking from nonexistent memory. */ /* Hence we need to be prepared to recover by running GC_mark_some */ /* with a suitable handler in place. */ /* FIXME: Should we really need it for WinCE? If yes then */ /* WRAP_MARK_SOME should be also defined for CeGCC which requires */ /* CPU/OS-specific code in mark_ex_handler() and GC_mark_some() */ /* (for manual stack unwinding and exception handler installation). */ # define WRAP_MARK_SOME # endif /* Perform a small amount of marking. */ /* We try to touch roughly a page of memory. */ /* Return TRUE if we just finished a mark phase. */ /* Cold_gc_frame is an address inside a GC frame that */ /* remains valid until all marking is complete. */ /* A zero value indicates that it's OK to miss some */ /* register values. */ /* We hold the allocation lock. In the case of */ /* incremental collection, the world may not be stopped.*/ #ifdef WRAP_MARK_SOME /* For win32, this is called after we establish a structured */ /* exception handler, in case Windows unmaps one of our root */ /* segments. See below. In either case, we acquire the */ /* allocator lock long before we get here. */ STATIC GC_bool GC_mark_some_inner(ptr_t cold_gc_frame) #else GC_INNER GC_bool GC_mark_some(ptr_t cold_gc_frame) #endif { switch(GC_mark_state) { case MS_NONE: break; case MS_PUSH_RESCUERS: if ((word)GC_mark_stack_top >= (word)(GC_mark_stack_limit - INITIAL_MARK_STACK_SIZE/2)) { /* Go ahead and mark, even though that might cause us to */ /* see more marked dirty objects later on. Avoid this */ /* in the future. */ GC_mark_stack_too_small = TRUE; MARK_FROM_MARK_STACK(); break; } else { scan_ptr = GC_push_next_marked_dirty(scan_ptr); if (scan_ptr == 0) { GC_COND_LOG_PRINTF("Marked from %lu dirty pages\n", (unsigned long)GC_n_rescuing_pages); GC_push_roots(FALSE, cold_gc_frame); GC_objects_are_marked = TRUE; if (GC_mark_state != MS_INVALID) { GC_mark_state = MS_ROOTS_PUSHED; } } } break; case MS_PUSH_UNCOLLECTABLE: if ((word)GC_mark_stack_top >= (word)(GC_mark_stack + GC_mark_stack_size/4)) { # ifdef PARALLEL_MARK /* Avoid this, since we don't parallelize the marker */ /* here. */ if (GC_parallel) GC_mark_stack_too_small = TRUE; # endif MARK_FROM_MARK_STACK(); break; } else { scan_ptr = GC_push_next_marked_uncollectable(scan_ptr); if (scan_ptr == 0) { GC_push_roots(TRUE, cold_gc_frame); GC_objects_are_marked = TRUE; if (GC_mark_state != MS_INVALID) { GC_mark_state = MS_ROOTS_PUSHED; } } } break; case MS_ROOTS_PUSHED: # ifdef PARALLEL_MARK /* In the incremental GC case, this currently doesn't */ /* quite do the right thing, since it runs to */ /* completion. On the other hand, starting a */ /* parallel marker is expensive, so perhaps it is */ /* the right thing? */ /* Eventually, incremental marking should run */ /* asynchronously in multiple threads, without grabbing */ /* the allocation lock. */ if (GC_parallel) { GC_do_parallel_mark(); GC_ASSERT((word)GC_mark_stack_top < (word)GC_first_nonempty); GC_mark_stack_top = GC_mark_stack - 1; if (GC_mark_stack_too_small) { alloc_mark_stack(2*GC_mark_stack_size); } if (GC_mark_state == MS_ROOTS_PUSHED) { GC_mark_state = MS_NONE; return(TRUE); } break; } # endif if ((word)GC_mark_stack_top >= (word)GC_mark_stack) { MARK_FROM_MARK_STACK(); break; } else { GC_mark_state = MS_NONE; if (GC_mark_stack_too_small) { alloc_mark_stack(2*GC_mark_stack_size); } return(TRUE); } case MS_INVALID: case MS_PARTIALLY_INVALID: if (!GC_objects_are_marked) { GC_mark_state = MS_PUSH_UNCOLLECTABLE; break; } if ((word)GC_mark_stack_top >= (word)GC_mark_stack) { MARK_FROM_MARK_STACK(); break; } if (scan_ptr == 0 && GC_mark_state == MS_INVALID) { /* About to start a heap scan for marked objects. */ /* Mark stack is empty. OK to reallocate. */ if (GC_mark_stack_too_small) { alloc_mark_stack(2*GC_mark_stack_size); } GC_mark_state = MS_PARTIALLY_INVALID; } scan_ptr = GC_push_next_marked(scan_ptr); if (scan_ptr == 0 && GC_mark_state == MS_PARTIALLY_INVALID) { GC_push_roots(TRUE, cold_gc_frame); GC_objects_are_marked = TRUE; if (GC_mark_state != MS_INVALID) { GC_mark_state = MS_ROOTS_PUSHED; } } break; default: ABORT("GC_mark_some: bad state"); } return(FALSE); } #ifdef WRAP_MARK_SOME # if (defined(MSWIN32) || defined(MSWINCE)) && defined(__GNUC__) typedef struct { EXCEPTION_REGISTRATION ex_reg; void *alt_path; } ext_ex_regn; static EXCEPTION_DISPOSITION mark_ex_handler( struct _EXCEPTION_RECORD *ex_rec, void *est_frame, struct _CONTEXT *context, void *disp_ctxt GC_ATTR_UNUSED) { if (ex_rec->ExceptionCode == STATUS_ACCESS_VIOLATION) { ext_ex_regn *xer = (ext_ex_regn *)est_frame; /* Unwind from the inner function assuming the standard */ /* function prologue. */ /* Assumes code has not been compiled with */ /* -fomit-frame-pointer. */ context->Esp = context->Ebp; context->Ebp = *((DWORD *)context->Esp); context->Esp = context->Esp - 8; /* Resume execution at the "real" handler within the */ /* wrapper function. */ context->Eip = (DWORD )(xer->alt_path); return ExceptionContinueExecution; } else { return ExceptionContinueSearch; } } # endif /* __GNUC__ && MSWIN32 */ #if defined(GC_WIN32_THREADS) && !defined(__GNUC__) GC_INNER GC_bool GC_started_thread_while_stopped(void); /* In win32_threads.c. Did we invalidate mark phase with an */ /* unexpected thread start? */ #endif GC_INNER GC_bool GC_mark_some(ptr_t cold_gc_frame) { GC_bool ret_val; # if defined(MSWIN32) || defined(MSWINCE) # ifndef __GNUC__ /* Windows 98 appears to asynchronously create and remove */ /* writable memory mappings, for reasons we haven't yet */ /* understood. Since we look for writable regions to */ /* determine the root set, we may try to mark from an */ /* address range that disappeared since we started the */ /* collection. Thus we have to recover from faults here. */ /* This code does not appear to be necessary for Windows */ /* 95/NT/2000+. Note that this code should never generate */ /* an incremental GC write fault. */ /* This code seems to be necessary for WinCE (at least in */ /* the case we'd decide to add MEM_PRIVATE sections to */ /* data roots in GC_register_dynamic_libraries()). */ /* It's conceivable that this is the same issue with */ /* terminating threads that we see with Linux and */ /* USE_PROC_FOR_LIBRARIES. */ __try { ret_val = GC_mark_some_inner(cold_gc_frame); } __except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) { goto handle_ex; } # ifdef GC_WIN32_THREADS /* With DllMain-based thread tracking, a thread may have */ /* started while we were marking. This is logically equivalent */ /* to the exception case; our results are invalid and we have */ /* to start over. This cannot be prevented since we can't */ /* block in DllMain. */ if (GC_started_thread_while_stopped()) goto handle_ex; # endif rm_handler: return ret_val; # else /* __GNUC__ */ /* Manually install an exception handler since GCC does */ /* not yet support Structured Exception Handling (SEH) on */ /* Win32. */ ext_ex_regn er; er.alt_path = &&handle_ex; er.ex_reg.handler = mark_ex_handler; __asm__ __volatile__ ("movl %%fs:0, %0" : "=r" (er.ex_reg.prev)); __asm__ __volatile__ ("movl %0, %%fs:0" : : "r" (&er)); ret_val = GC_mark_some_inner(cold_gc_frame); /* Prevent GCC from considering the following code unreachable */ /* and thus eliminating it. */ if (er.alt_path == 0) goto handle_ex; rm_handler: /* Uninstall the exception handler */ __asm__ __volatile__ ("mov %0, %%fs:0" : : "r" (er.ex_reg.prev)); return ret_val; # endif /* __GNUC__ */ # else /* !MSWIN32 */ /* Here we are handling the case in which /proc is used for root */ /* finding, and we have threads. We may find a stack for a */ /* thread that is in the process of exiting, and disappears */ /* while we are marking it. This seems extremely difficult to */ /* avoid otherwise. */ if (GC_incremental) { WARN("Incremental GC incompatible with /proc roots\n", 0); /* I'm not sure if this could still work ... */ } GC_setup_temporary_fault_handler(); if(SETJMP(GC_jmp_buf) != 0) goto handle_ex; ret_val = GC_mark_some_inner(cold_gc_frame); rm_handler: GC_reset_fault_handler(); return ret_val; # endif /* !MSWIN32 */ handle_ex: /* Exception handler starts here for all cases. */ WARN("Caught ACCESS_VIOLATION in marker;" " memory mapping disappeared\n", 0); /* We have bad roots on the stack. Discard mark stack. */ /* Rescan from marked objects. Redetermine roots. */ GC_invalidate_mark_state(); scan_ptr = 0; ret_val = FALSE; goto rm_handler; /* Back to platform-specific code. */ } #endif /* WRAP_MARK_SOME */ GC_INNER void GC_invalidate_mark_state(void) { GC_mark_state = MS_INVALID; GC_mark_stack_top = GC_mark_stack-1; } GC_INNER mse * GC_signal_mark_stack_overflow(mse *msp) { GC_mark_state = MS_INVALID; # ifdef PARALLEL_MARK /* We are using a local_mark_stack in parallel mode, so */ /* do not signal the global mark stack to be resized. */ /* That will be done if required in GC_return_mark_stack. */ if (!GC_parallel) GC_mark_stack_too_small = TRUE; # else GC_mark_stack_too_small = TRUE; # endif GC_COND_LOG_PRINTF("Mark stack overflow; current size = %lu entries\n", (unsigned long)GC_mark_stack_size); return(msp - GC_MARK_STACK_DISCARDS); } /* * Mark objects pointed to by the regions described by * mark stack entries between mark_stack and mark_stack_top, * inclusive. Assumes the upper limit of a mark stack entry * is never 0. A mark stack entry never has size 0. * We try to traverse on the order of a hblk of memory before we return. * Caller is responsible for calling this until the mark stack is empty. * Note that this is the most performance critical routine in the * collector. Hence it contains all sorts of ugly hacks to speed * things up. In particular, we avoid procedure calls on the common * path, we take advantage of peculiarities of the mark descriptor * encoding, we optionally maintain a cache for the block address to * header mapping, we prefetch when an object is "grayed", etc. */ GC_INNER mse * GC_mark_from(mse *mark_stack_top, mse *mark_stack, mse *mark_stack_limit) { signed_word credit = HBLKSIZE; /* Remaining credit for marking work */ ptr_t current_p; /* Pointer to current candidate ptr. */ word current; /* Candidate pointer. */ ptr_t limit; /* (Incl) limit of current candidate range. */ word descr; ptr_t greatest_ha = GC_greatest_plausible_heap_addr; ptr_t least_ha = GC_least_plausible_heap_addr; DECLARE_HDR_CACHE; # define SPLIT_RANGE_WORDS 128 /* Must be power of 2. */ GC_objects_are_marked = TRUE; INIT_HDR_CACHE; # ifdef OS2 /* Use untweaked version to circumvent compiler problem */ while ((word)mark_stack_top >= (word)mark_stack && credit >= 0) # else while ((((ptr_t)mark_stack_top - (ptr_t)mark_stack) | credit) >= 0) # endif { current_p = mark_stack_top -> mse_start; descr = mark_stack_top -> mse_descr.w; retry: /* current_p and descr describe the current object. */ /* *mark_stack_top is vacant. */ /* The following is 0 only for small objects described by a simple */ /* length descriptor. For many applications this is the common */ /* case, so we try to detect it quickly. */ if (descr & ((~(WORDS_TO_BYTES(SPLIT_RANGE_WORDS) - 1)) | GC_DS_TAGS)) { word tag = descr & GC_DS_TAGS; switch(tag) { case GC_DS_LENGTH: /* Large length. */ /* Process part of the range to avoid pushing too much on the */ /* stack. */ GC_ASSERT(descr < (word)GC_greatest_plausible_heap_addr - (word)GC_least_plausible_heap_addr); # ifdef ENABLE_TRACE if ((word)GC_trace_addr >= (word)current_p && (word)GC_trace_addr < (word)(current_p + descr)) { GC_log_printf("GC #%u: large section; start %p, len %lu\n", (unsigned)GC_gc_no, current_p, (unsigned long)descr); } # endif /* ENABLE_TRACE */ # ifdef PARALLEL_MARK # define SHARE_BYTES 2048 if (descr > SHARE_BYTES && GC_parallel && (word)mark_stack_top < (word)(mark_stack_limit - 1)) { int new_size = (descr/2) & ~(sizeof(word)-1); mark_stack_top -> mse_start = current_p; mark_stack_top -> mse_descr.w = new_size + sizeof(word); /* makes sure we handle */ /* misaligned pointers. */ mark_stack_top++; # ifdef ENABLE_TRACE if ((word)GC_trace_addr >= (word)current_p && (word)GC_trace_addr < (word)(current_p + descr)) { GC_log_printf("GC #%u: splitting (parallel) %p at %p\n", (unsigned)GC_gc_no, current_p, current_p + new_size); } # endif /* ENABLE_TRACE */ current_p += new_size; descr -= new_size; goto retry; } # endif /* PARALLEL_MARK */ mark_stack_top -> mse_start = limit = current_p + WORDS_TO_BYTES(SPLIT_RANGE_WORDS-1); mark_stack_top -> mse_descr.w = descr - WORDS_TO_BYTES(SPLIT_RANGE_WORDS-1); # ifdef ENABLE_TRACE if ((word)GC_trace_addr >= (word)current_p && (word)GC_trace_addr < (word)(current_p + descr)) { GC_log_printf("GC #%u: splitting %p at %p\n", (unsigned)GC_gc_no, current_p, limit); } # endif /* ENABLE_TRACE */ /* Make sure that pointers overlapping the two ranges are */ /* considered. */ limit += sizeof(word) - ALIGNMENT; break; case GC_DS_BITMAP: mark_stack_top--; # ifdef ENABLE_TRACE if ((word)GC_trace_addr >= (word)current_p && (word)GC_trace_addr < (word)(current_p + WORDS_TO_BYTES(WORDSZ-2))) { GC_log_printf("GC #%u: tracing from %p bitmap descr %lu\n", (unsigned)GC_gc_no, current_p, (unsigned long)descr); } # endif /* ENABLE_TRACE */ descr &= ~GC_DS_TAGS; credit -= WORDS_TO_BYTES(WORDSZ/2); /* guess */ while (descr != 0) { if ((signed_word)descr < 0) { current = *(word *)current_p; FIXUP_POINTER(current); if (current >= (word)least_ha && current < (word)greatest_ha) { PREFETCH((ptr_t)current); # ifdef ENABLE_TRACE if (GC_trace_addr == current_p) { GC_log_printf("GC #%u: considering(3) %p -> %p\n", (unsigned)GC_gc_no, current_p, (ptr_t)current); } # endif /* ENABLE_TRACE */ PUSH_CONTENTS((ptr_t)current, mark_stack_top, mark_stack_limit, current_p, exit1); } } descr <<= 1; current_p += sizeof(word); } continue; case GC_DS_PROC: mark_stack_top--; # ifdef ENABLE_TRACE if ((word)GC_trace_addr >= (word)current_p && GC_base(current_p) != 0 && GC_base(current_p) == GC_base(GC_trace_addr)) { GC_log_printf("GC #%u: tracing from %p, proc descr %lu\n", (unsigned)GC_gc_no, current_p, (unsigned long)descr); } # endif /* ENABLE_TRACE */ credit -= GC_PROC_BYTES; mark_stack_top = (*PROC(descr))((word *)current_p, mark_stack_top, mark_stack_limit, ENV(descr)); continue; case GC_DS_PER_OBJECT: if ((signed_word)descr >= 0) { /* Descriptor is in the object. */ descr = *(word *)(current_p + descr - GC_DS_PER_OBJECT); } else { /* Descriptor is in type descriptor pointed to by first */ /* word in object. */ ptr_t type_descr = *(ptr_t *)current_p; /* type_descr is either a valid pointer to the descriptor */ /* structure, or this object was on a free list. If it */ /* it was anything but the last object on the free list, */ /* we will misinterpret the next object on the free list as */ /* the type descriptor, and get a 0 GC descriptor, which */ /* is ideal. Unfortunately, we need to check for the last */ /* object case explicitly. */ if (0 == type_descr) { /* Rarely executed. */ mark_stack_top--; continue; } descr = *(word *)(type_descr - (descr + (GC_INDIR_PER_OBJ_BIAS - GC_DS_PER_OBJECT))); } if (0 == descr) { /* Can happen either because we generated a 0 descriptor */ /* or we saw a pointer to a free object. */ mark_stack_top--; continue; } goto retry; default: limit = 0; /* initialized to prevent warning. */ ABORT_RET("GC_mark_from: bad state"); } } else /* Small object with length descriptor */ { mark_stack_top--; # ifndef SMALL_CONFIG if (descr < sizeof(word)) continue; # endif limit = current_p + (word)descr; } # ifdef ENABLE_TRACE if ((word)GC_trace_addr >= (word)current_p && (word)GC_trace_addr < (word)limit) { GC_log_printf("GC #%u: Tracing from %p, length is %lu\n", (unsigned)GC_gc_no, current_p, (unsigned long)descr); } # endif /* ENABLE_TRACE */ /* The simple case in which we're scanning a range. */ GC_ASSERT(!((word)current_p & (ALIGNMENT-1))); credit -= limit - current_p; limit -= sizeof(word); { # define PREF_DIST 4 # ifndef SMALL_CONFIG word deferred; /* Try to prefetch the next pointer to be examined ASAP. */ /* Empirically, this also seems to help slightly without */ /* prefetches, at least on linux/X86. Presumably this loop */ /* ends up with less register pressure, and gcc thus ends up */ /* generating slightly better code. Overall gcc code quality */ /* for this loop is still not great. */ for(;;) { PREFETCH(limit - PREF_DIST*CACHE_LINE_SIZE); GC_ASSERT((word)limit >= (word)current_p); deferred = *(word *)limit; FIXUP_POINTER(deferred); limit -= ALIGNMENT; if (deferred >= (word)least_ha && deferred < (word)greatest_ha) { PREFETCH((ptr_t)deferred); break; } if ((word)current_p > (word)limit) goto next_object; /* Unroll once, so we don't do too many of the prefetches */ /* based on limit. */ deferred = *(word *)limit; FIXUP_POINTER(deferred); limit -= ALIGNMENT; if (deferred >= (word)least_ha && deferred < (word)greatest_ha) { PREFETCH((ptr_t)deferred); break; } if ((word)current_p > (word)limit) goto next_object; } # endif while ((word)current_p <= (word)limit) { /* Empirically, unrolling this loop doesn't help a lot. */ /* Since PUSH_CONTENTS expands to a lot of code, */ /* we don't. */ current = *(word *)current_p; FIXUP_POINTER(current); PREFETCH(current_p + PREF_DIST*CACHE_LINE_SIZE); if (current >= (word)least_ha && current < (word)greatest_ha) { /* Prefetch the contents of the object we just pushed. It's */ /* likely we will need them soon. */ PREFETCH((ptr_t)current); # ifdef ENABLE_TRACE if (GC_trace_addr == current_p) { GC_log_printf("GC #%u: considering(1) %p -> %p\n", (unsigned)GC_gc_no, current_p, (ptr_t)current); } # endif /* ENABLE_TRACE */ PUSH_CONTENTS((ptr_t)current, mark_stack_top, mark_stack_limit, current_p, exit2); } current_p += ALIGNMENT; } # ifndef SMALL_CONFIG /* We still need to mark the entry we previously prefetched. */ /* We already know that it passes the preliminary pointer */ /* validity test. */ # ifdef ENABLE_TRACE if (GC_trace_addr == current_p) { GC_log_printf("GC #%u: considering(2) %p -> %p\n", (unsigned)GC_gc_no, current_p, (ptr_t)deferred); } # endif /* ENABLE_TRACE */ PUSH_CONTENTS((ptr_t)deferred, mark_stack_top, mark_stack_limit, current_p, exit4); next_object:; # endif } } return mark_stack_top; } #ifdef PARALLEL_MARK STATIC GC_bool GC_help_wanted = FALSE; /* Protected by mark lock */ STATIC unsigned GC_helper_count = 0; /* Number of running helpers. */ /* Protected by mark lock */ STATIC unsigned GC_active_count = 0; /* Number of active helpers. */ /* Protected by mark lock */ /* May increase and decrease */ /* within each mark cycle. But */ /* once it returns to 0, it */ /* stays zero for the cycle. */ GC_INNER word GC_mark_no = 0; #define LOCAL_MARK_STACK_SIZE HBLKSIZE /* Under normal circumstances, this is big enough to guarantee */ /* we don't overflow half of it in a single call to */ /* GC_mark_from. */ /* Steal mark stack entries starting at mse low into mark stack local */ /* until we either steal mse high, or we have max entries. */ /* Return a pointer to the top of the local mark stack. */ /* *next is replaced by a pointer to the next unscanned mark stack */ /* entry. */ STATIC mse * GC_steal_mark_stack(mse * low, mse * high, mse * local, unsigned max, mse **next) { mse *p; mse *top = local - 1; unsigned i = 0; GC_ASSERT((word)high >= (word)(low - 1) && (word)(high - low + 1) <= GC_mark_stack_size); for (p = low; (word)p <= (word)high && i <= max; ++p) { word descr = (word)AO_load(&p->mse_descr.ao); if (descr != 0) { /* Must be ordered after read of descr: */ AO_store_release_write(&p->mse_descr.ao, 0); /* More than one thread may get this entry, but that's only */ /* a minor performance problem. */ ++top; top -> mse_descr.w = descr; top -> mse_start = p -> mse_start; GC_ASSERT((top->mse_descr.w & GC_DS_TAGS) != GC_DS_LENGTH || top->mse_descr.w < (word)GC_greatest_plausible_heap_addr - (word)GC_least_plausible_heap_addr); /* If this is a big object, count it as */ /* size/256 + 1 objects. */ ++i; if ((descr & GC_DS_TAGS) == GC_DS_LENGTH) i += (int)(descr >> 8); } } *next = p; return top; } /* Copy back a local mark stack. */ /* low and high are inclusive bounds. */ STATIC void GC_return_mark_stack(mse * low, mse * high) { mse * my_top; mse * my_start; size_t stack_size; if ((word)high < (word)low) return; stack_size = high - low + 1; GC_acquire_mark_lock(); my_top = GC_mark_stack_top; /* Concurrent modification impossible. */ my_start = my_top + 1; if ((word)(my_start - GC_mark_stack + stack_size) > (word)GC_mark_stack_size) { GC_COND_LOG_PRINTF("No room to copy back mark stack\n"); GC_mark_state = MS_INVALID; GC_mark_stack_too_small = TRUE; /* We drop the local mark stack. We'll fix things later. */ } else { BCOPY(low, my_start, stack_size * sizeof(mse)); GC_ASSERT((mse *)AO_load((volatile AO_t *)(&GC_mark_stack_top)) == my_top); AO_store_release_write((volatile AO_t *)(&GC_mark_stack_top), (AO_t)(my_top + stack_size)); /* Ensures visibility of previously written stack contents. */ } GC_release_mark_lock(); GC_notify_all_marker(); } /* Mark from the local mark stack. */ /* On return, the local mark stack is empty. */ /* But this may be achieved by copying the */ /* local mark stack back into the global one. */ STATIC void GC_do_local_mark(mse *local_mark_stack, mse *local_top) { unsigned n; # define N_LOCAL_ITERS 1 # ifdef GC_ASSERTIONS /* Make sure we don't hold mark lock. */ GC_acquire_mark_lock(); GC_release_mark_lock(); # endif for (;;) { for (n = 0; n < N_LOCAL_ITERS; ++n) { local_top = GC_mark_from(local_top, local_mark_stack, local_mark_stack + LOCAL_MARK_STACK_SIZE); if ((word)local_top < (word)local_mark_stack) return; if ((word)(local_top - local_mark_stack) >= LOCAL_MARK_STACK_SIZE / 2) { GC_return_mark_stack(local_mark_stack, local_top); return; } } if ((word)AO_load((volatile AO_t *)&GC_mark_stack_top) < (word)AO_load(&GC_first_nonempty) && GC_active_count < GC_helper_count && (word)local_top > (word)(local_mark_stack + 1)) { /* Try to share the load, since the main stack is empty, */ /* and helper threads are waiting for a refill. */ /* The entries near the bottom of the stack are likely */ /* to require more work. Thus we return those, even though */ /* it's harder. */ mse * new_bottom = local_mark_stack + (local_top - local_mark_stack)/2; GC_ASSERT((word)new_bottom > (word)local_mark_stack && (word)new_bottom < (word)local_top); GC_return_mark_stack(local_mark_stack, new_bottom - 1); memmove(local_mark_stack, new_bottom, (local_top - new_bottom + 1) * sizeof(mse)); local_top -= (new_bottom - local_mark_stack); } } } #define ENTRIES_TO_GET 5 /* Mark using the local mark stack until the global mark stack is empty */ /* and there are no active workers. Update GC_first_nonempty to reflect */ /* progress. */ /* Caller does not hold mark lock. */ /* Caller has already incremented GC_helper_count. We decrement it, */ /* and maintain GC_active_count. */ STATIC void GC_mark_local(mse *local_mark_stack, int id) { mse * my_first_nonempty; GC_acquire_mark_lock(); GC_active_count++; my_first_nonempty = (mse *)AO_load(&GC_first_nonempty); GC_ASSERT((word)GC_mark_stack <= (word)my_first_nonempty); GC_ASSERT((word)my_first_nonempty <= (word)AO_load((volatile AO_t *)&GC_mark_stack_top) + sizeof(mse)); GC_VERBOSE_LOG_PRINTF("Starting mark helper %lu\n", (unsigned long)id); GC_release_mark_lock(); for (;;) { size_t n_on_stack; unsigned n_to_get; mse * my_top; mse * local_top; mse * global_first_nonempty = (mse *)AO_load(&GC_first_nonempty); GC_ASSERT((word)my_first_nonempty >= (word)GC_mark_stack && (word)my_first_nonempty <= (word)AO_load((volatile AO_t *)&GC_mark_stack_top) + sizeof(mse)); GC_ASSERT((word)global_first_nonempty >= (word)GC_mark_stack && (word)global_first_nonempty <= (word)AO_load((volatile AO_t *)&GC_mark_stack_top) + sizeof(mse)); if ((word)my_first_nonempty < (word)global_first_nonempty) { my_first_nonempty = global_first_nonempty; } else if ((word)global_first_nonempty < (word)my_first_nonempty) { AO_compare_and_swap(&GC_first_nonempty, (AO_t) global_first_nonempty, (AO_t) my_first_nonempty); /* If this fails, we just go ahead, without updating */ /* GC_first_nonempty. */ } /* Perhaps we should also update GC_first_nonempty, if it */ /* is less. But that would require using atomic updates. */ my_top = (mse *)AO_load_acquire((volatile AO_t *)(&GC_mark_stack_top)); n_on_stack = my_top - my_first_nonempty + 1; if (0 == n_on_stack) { GC_acquire_mark_lock(); my_top = GC_mark_stack_top; /* Asynchronous modification impossible here, */ /* since we hold mark lock. */ n_on_stack = my_top - my_first_nonempty + 1; if (0 == n_on_stack) { GC_active_count--; GC_ASSERT(GC_active_count <= GC_helper_count); /* Other markers may redeposit objects */ /* on the stack. */ if (0 == GC_active_count) GC_notify_all_marker(); while (GC_active_count > 0 && (word)AO_load(&GC_first_nonempty) > (word)GC_mark_stack_top) { /* We will be notified if either GC_active_count */ /* reaches zero, or if more objects are pushed on */ /* the global mark stack. */ GC_wait_marker(); } if (GC_active_count == 0 && (word)AO_load(&GC_first_nonempty) > (word)GC_mark_stack_top) { GC_bool need_to_notify = FALSE; /* The above conditions can't be falsified while we */ /* hold the mark lock, since neither */ /* GC_active_count nor GC_mark_stack_top can */ /* change. GC_first_nonempty can only be */ /* incremented asynchronously. Thus we know that */ /* both conditions actually held simultaneously. */ GC_helper_count--; if (0 == GC_helper_count) need_to_notify = TRUE; GC_VERBOSE_LOG_PRINTF("Finished mark helper %lu\n", (unsigned long)id); GC_release_mark_lock(); if (need_to_notify) GC_notify_all_marker(); return; } /* else there's something on the stack again, or */ /* another helper may push something. */ GC_active_count++; GC_ASSERT(GC_active_count > 0); GC_release_mark_lock(); continue; } else { GC_release_mark_lock(); } } n_to_get = ENTRIES_TO_GET; if (n_on_stack < 2 * ENTRIES_TO_GET) n_to_get = 1; local_top = GC_steal_mark_stack(my_first_nonempty, my_top, local_mark_stack, n_to_get, &my_first_nonempty); GC_ASSERT((word)my_first_nonempty >= (word)GC_mark_stack && (word)my_first_nonempty <= (word)AO_load((volatile AO_t *)&GC_mark_stack_top) + sizeof(mse)); GC_do_local_mark(local_mark_stack, local_top); } } /* Perform Parallel mark. */ /* We hold the GC lock, not the mark lock. */ /* Currently runs until the mark stack is */ /* empty. */ STATIC void GC_do_parallel_mark(void) { mse local_mark_stack[LOCAL_MARK_STACK_SIZE]; /* Note: local_mark_stack is quite big (up to 128 KiB). */ GC_acquire_mark_lock(); GC_ASSERT(I_HOLD_LOCK()); /* This could be a GC_ASSERT, but it seems safer to keep it on */ /* all the time, especially since it's cheap. */ if (GC_help_wanted || GC_active_count != 0 || GC_helper_count != 0) ABORT("Tried to start parallel mark in bad state"); GC_VERBOSE_LOG_PRINTF("Starting marking for mark phase number %lu\n", (unsigned long)GC_mark_no); GC_first_nonempty = (AO_t)GC_mark_stack; GC_active_count = 0; GC_helper_count = 1; GC_help_wanted = TRUE; GC_release_mark_lock(); GC_notify_all_marker(); /* Wake up potential helpers. */ GC_mark_local(local_mark_stack, 0); GC_acquire_mark_lock(); GC_help_wanted = FALSE; /* Done; clean up. */ while (GC_helper_count > 0) { GC_wait_marker(); } /* GC_helper_count cannot be incremented while GC_help_wanted == FALSE */ GC_VERBOSE_LOG_PRINTF("Finished marking for mark phase number %lu\n", (unsigned long)GC_mark_no); GC_mark_no++; GC_release_mark_lock(); GC_notify_all_marker(); } /* Try to help out the marker, if it's running. */ /* We do not hold the GC lock, but the requestor does. */ GC_INNER void GC_help_marker(word my_mark_no) { unsigned my_id; mse local_mark_stack[LOCAL_MARK_STACK_SIZE]; /* Note: local_mark_stack is quite big (up to 128 KiB). */ if (!GC_parallel) return; GC_acquire_mark_lock(); while (GC_mark_no < my_mark_no || (!GC_help_wanted && GC_mark_no == my_mark_no)) { GC_wait_marker(); } my_id = GC_helper_count; if (GC_mark_no != my_mark_no || my_id > (unsigned)GC_markers_m1) { /* Second test is useful only if original threads can also */ /* act as helpers. Under Linux they can't. */ GC_release_mark_lock(); return; } GC_helper_count = my_id + 1; GC_release_mark_lock(); GC_mark_local(local_mark_stack, my_id); /* GC_mark_local decrements GC_helper_count. */ } #endif /* PARALLEL_MARK */ /* Allocate or reallocate space for mark stack of size n entries. */ /* May silently fail. */ static void alloc_mark_stack(size_t n) { mse * new_stack = (mse *)GC_scratch_alloc(n * sizeof(struct GC_ms_entry)); # ifdef GWW_VDB /* Don't recycle a stack segment obtained with the wrong flags. */ /* Win32 GetWriteWatch requires the right kind of memory. */ static GC_bool GC_incremental_at_stack_alloc = FALSE; GC_bool recycle_old = (!GC_incremental || GC_incremental_at_stack_alloc); GC_incremental_at_stack_alloc = GC_incremental; # else # define recycle_old TRUE # endif GC_mark_stack_too_small = FALSE; if (GC_mark_stack_size != 0) { if (new_stack != 0) { if (recycle_old) { /* Recycle old space */ size_t page_offset = (word)GC_mark_stack & (GC_page_size - 1); size_t size = GC_mark_stack_size * sizeof(struct GC_ms_entry); size_t displ = 0; if (0 != page_offset) displ = GC_page_size - page_offset; size = (size - displ) & ~(GC_page_size - 1); if (size > 0) { GC_add_to_heap((struct hblk *) ((word)GC_mark_stack + displ), (word)size); } } GC_mark_stack = new_stack; GC_mark_stack_size = n; /* FIXME: Do we need some way to reset GC_mark_stack_size? */ GC_mark_stack_limit = new_stack + n; GC_COND_LOG_PRINTF("Grew mark stack to %lu frames\n", (unsigned long)GC_mark_stack_size); } else { WARN("Failed to grow mark stack to %" WARN_PRIdPTR " frames\n", n); } } else { if (new_stack == 0) { GC_err_printf("No space for mark stack\n"); EXIT(); } GC_mark_stack = new_stack; GC_mark_stack_size = n; GC_mark_stack_limit = new_stack + n; } GC_mark_stack_top = GC_mark_stack-1; } GC_INNER void GC_mark_init(void) { alloc_mark_stack(INITIAL_MARK_STACK_SIZE); } /* * Push all locations between b and t onto the mark stack. * b is the first location to be checked. t is one past the last * location to be checked. * Should only be used if there is no possibility of mark stack * overflow. */ GC_API void GC_CALL GC_push_all(char *bottom, char *top) { register word length; bottom = (char *)(((word) bottom + ALIGNMENT-1) & ~(ALIGNMENT-1)); top = (char *)(((word) top) & ~(ALIGNMENT-1)); if ((word)bottom >= (word)top) return; GC_mark_stack_top++; if ((word)GC_mark_stack_top >= (word)GC_mark_stack_limit) { ABORT("Unexpected mark stack overflow"); } length = top - bottom; # if GC_DS_TAGS > ALIGNMENT - 1 length += GC_DS_TAGS; length &= ~GC_DS_TAGS; # endif GC_mark_stack_top -> mse_start = bottom; GC_mark_stack_top -> mse_descr.w = length; } #ifndef GC_DISABLE_INCREMENTAL /* Analogous to the above, but push only those pages h with */ /* dirty_fn(h) != 0. We use GC_push_all to actually push the block. */ /* Used both to selectively push dirty pages, or to push a block in */ /* piecemeal fashion, to allow for more marking concurrency. */ /* Will not overflow mark stack if GC_push_all pushes a small fixed */ /* number of entries. (This is invoked only if GC_push_all pushes */ /* a single entry, or if it marks each object before pushing it, thus */ /* ensuring progress in the event of a stack overflow.) */ STATIC void GC_push_selected(ptr_t bottom, ptr_t top, GC_bool (*dirty_fn)(struct hblk *)) { struct hblk * h; bottom = (ptr_t)(((word) bottom + ALIGNMENT-1) & ~(ALIGNMENT-1)); top = (ptr_t)(((word) top) & ~(ALIGNMENT-1)); if ((word)bottom >= (word)top) return; h = HBLKPTR(bottom + HBLKSIZE); if ((word)top <= (word)h) { if ((*dirty_fn)(h-1)) { GC_push_all(bottom, top); } return; } if ((*dirty_fn)(h-1)) { GC_push_all(bottom, (ptr_t)h); } while ((word)(h+1) <= (word)top) { if ((*dirty_fn)(h)) { if ((word)(GC_mark_stack_top - GC_mark_stack) > 3 * GC_mark_stack_size / 4) { /* Danger of mark stack overflow */ GC_push_all((ptr_t)h, top); return; } else { GC_push_all((ptr_t)h, (ptr_t)(h+1)); } } h++; } if ((ptr_t)h != top && (*dirty_fn)(h)) { GC_push_all((ptr_t)h, top); } if ((word)GC_mark_stack_top >= (word)GC_mark_stack_limit) { ABORT("Unexpected mark stack overflow"); } } GC_API void GC_CALL GC_push_conditional(char *bottom, char *top, int all) { if (!all) { GC_push_selected((ptr_t)bottom, (ptr_t)top, GC_page_was_dirty); } else { # ifdef PROC_VDB if (GC_dirty_maintained) { /* Pages that were never dirtied cannot contain pointers. */ GC_push_selected((ptr_t)bottom, (ptr_t)top, GC_page_was_ever_dirty); } else # endif /* else */ { GC_push_all(bottom, top); } } } #else GC_API void GC_CALL GC_push_conditional(char *bottom, char *top, int all GC_ATTR_UNUSED) { GC_push_all(bottom, top); } #endif /* GC_DISABLE_INCREMENTAL */ #if defined(MSWIN32) || defined(MSWINCE) void __cdecl GC_push_one(word p) #else void GC_push_one(word p) #endif { GC_PUSH_ONE_STACK(p, MARKED_FROM_REGISTER); } GC_API struct GC_ms_entry * GC_CALL GC_mark_and_push(void *obj, mse *mark_stack_ptr, mse *mark_stack_limit, void ** src GC_ATTR_UNUSED) { hdr * hhdr; PREFETCH(obj); GET_HDR(obj, hhdr); if ((EXPECT(IS_FORWARDING_ADDR_OR_NIL(hhdr), FALSE) && (!GC_all_interior_pointers || NULL == (hhdr = GC_find_header(GC_base(obj))))) || EXPECT(HBLK_IS_FREE(hhdr), FALSE)) { GC_ADD_TO_BLACK_LIST_NORMAL(obj, (ptr_t)src); return mark_stack_ptr; } PUSH_CONTENTS_HDR(obj, mark_stack_ptr /* modified */, mark_stack_limit, (ptr_t)src, was_marked, hhdr, TRUE); was_marked: return mark_stack_ptr; } #if defined(MANUAL_VDB) && defined(THREADS) void GC_dirty(ptr_t p); #endif /* Mark and push (i.e. gray) a single object p onto the main */ /* mark stack. Consider p to be valid if it is an interior */ /* pointer. */ /* The object p has passed a preliminary pointer validity */ /* test, but we do not definitely know whether it is valid. */ /* Mark bits are NOT atomically updated. Thus this must be the */ /* only thread setting them. */ # if defined(PRINT_BLACK_LIST) || defined(KEEP_BACK_PTRS) GC_INNER void GC_mark_and_push_stack(ptr_t p, ptr_t source) # else GC_INNER void GC_mark_and_push_stack(ptr_t p) # define source ((ptr_t)0) # endif { hdr * hhdr; ptr_t r = p; PREFETCH(p); GET_HDR(p, hhdr); if (EXPECT(IS_FORWARDING_ADDR_OR_NIL(hhdr), FALSE)) { if (hhdr != 0) { r = GC_base(p); hhdr = HDR(r); } if (hhdr == 0) { GC_ADD_TO_BLACK_LIST_STACK(p, source); return; } } if (EXPECT(HBLK_IS_FREE(hhdr), FALSE)) { GC_ADD_TO_BLACK_LIST_NORMAL(p, source); return; } # if defined(MANUAL_VDB) && defined(THREADS) /* Pointer is on the stack. We may have dirtied the object */ /* it points to, but not yet have called GC_dirty(); */ GC_dirty(p); /* Implicitly affects entire object. */ # endif PUSH_CONTENTS_HDR(r, GC_mark_stack_top, GC_mark_stack_limit, source, mark_and_push_exit, hhdr, FALSE); mark_and_push_exit: ; /* We silently ignore pointers to near the end of a block, */ /* which is very mildly suboptimal. */ /* FIXME: We should probably add a header word to address */ /* this. */ } # undef source # ifdef TRACE_BUF # define TRACE_ENTRIES 1000 struct trace_entry { char * kind; word gc_no; word bytes_allocd; word arg1; word arg2; } GC_trace_buf[TRACE_ENTRIES]; int GC_trace_buf_ptr = 0; void GC_add_trace_entry(char *kind, word arg1, word arg2) { GC_trace_buf[GC_trace_buf_ptr].kind = kind; GC_trace_buf[GC_trace_buf_ptr].gc_no = GC_gc_no; GC_trace_buf[GC_trace_buf_ptr].bytes_allocd = GC_bytes_allocd; GC_trace_buf[GC_trace_buf_ptr].arg1 = arg1 ^ 0x80000000; GC_trace_buf[GC_trace_buf_ptr].arg2 = arg2 ^ 0x80000000; GC_trace_buf_ptr++; if (GC_trace_buf_ptr >= TRACE_ENTRIES) GC_trace_buf_ptr = 0; } void GC_print_trace_inner(word gc_no) { int i; struct trace_entry *p; for (i = GC_trace_buf_ptr-1; i != GC_trace_buf_ptr; i--) { if (i < 0) i = TRACE_ENTRIES-1; p = GC_trace_buf + i; if (p -> gc_no < gc_no || p -> kind == 0) { return; } GC_printf("Trace:%s (gc:%u, bytes:%lu) 0x%lX, 0x%lX\n", p -> kind, (unsigned)p -> gc_no, (unsigned long)p -> bytes_allocd, (long)p->arg1 ^ 0x80000000L, (long)p->arg2 ^ 0x80000000L); } GC_printf("Trace incomplete\n"); } void GC_print_trace(word gc_no) { DCL_LOCK_STATE; LOCK(); GC_print_trace_inner(gc_no); UNLOCK(); } # endif /* TRACE_BUF */ /* * A version of GC_push_all that treats all interior pointers as valid * and scans the entire region immediately, in case the contents * change. */ GC_INNER void GC_push_all_eager(ptr_t bottom, ptr_t top) { word * b = (word *)(((word) bottom + ALIGNMENT-1) & ~(ALIGNMENT-1)); word * t = (word *)(((word) top) & ~(ALIGNMENT-1)); register word *p; register word q; register word *lim; register ptr_t greatest_ha = GC_greatest_plausible_heap_addr; register ptr_t least_ha = GC_least_plausible_heap_addr; # define GC_greatest_plausible_heap_addr greatest_ha # define GC_least_plausible_heap_addr least_ha if (top == 0) return; /* check all pointers in range and push if they appear */ /* to be valid. */ lim = t - 1 /* longword */; for (p = b; (word)p <= (word)lim; p = (word *)(((ptr_t)p) + ALIGNMENT)) { q = *p; GC_PUSH_ONE_STACK(q, p); } # undef GC_greatest_plausible_heap_addr # undef GC_least_plausible_heap_addr } GC_INNER void GC_push_all_stack(ptr_t bottom, ptr_t top) { # if defined(THREADS) && defined(MPROTECT_VDB) GC_push_all_eager(bottom, top); # else if (!NEED_FIXUP_POINTER && GC_all_interior_pointers) { GC_push_all(bottom, top); } else { GC_push_all_eager(bottom, top); } # endif } #if !defined(SMALL_CONFIG) && !defined(USE_MARK_BYTES) && \ defined(MARK_BIT_PER_GRANULE) # if GC_GRANULE_WORDS == 1 # define USE_PUSH_MARKED_ACCELERATORS # define PUSH_GRANULE(q) \ do { \ word qcontents = (q)[0]; \ GC_PUSH_ONE_HEAP(qcontents, q, GC_mark_stack_top); \ } while (0) # elif GC_GRANULE_WORDS == 2 # define USE_PUSH_MARKED_ACCELERATORS # define PUSH_GRANULE(q) \ do { \ word qcontents = (q)[0]; \ GC_PUSH_ONE_HEAP(qcontents, q, GC_mark_stack_top); \ qcontents = (q)[1]; \ GC_PUSH_ONE_HEAP(qcontents, (q)+1, GC_mark_stack_top); \ } while (0) # elif GC_GRANULE_WORDS == 4 # define USE_PUSH_MARKED_ACCELERATORS # define PUSH_GRANULE(q) \ do { \ word qcontents = (q)[0]; \ GC_PUSH_ONE_HEAP(qcontents, q, GC_mark_stack_top); \ qcontents = (q)[1]; \ GC_PUSH_ONE_HEAP(qcontents, (q)+1, GC_mark_stack_top); \ qcontents = (q)[2]; \ GC_PUSH_ONE_HEAP(qcontents, (q)+2, GC_mark_stack_top); \ qcontents = (q)[3]; \ GC_PUSH_ONE_HEAP(qcontents, (q)+3, GC_mark_stack_top); \ } while (0) # endif #endif /* !USE_MARK_BYTES && MARK_BIT_PER_GRANULE */ #ifdef USE_PUSH_MARKED_ACCELERATORS /* Push all objects reachable from marked objects in the given block */ /* containing objects of size 1 granule. */ STATIC void GC_push_marked1(struct hblk *h, hdr *hhdr) { word * mark_word_addr = &(hhdr->hb_marks[0]); word *p; word *plim; word *q; word mark_word; /* Allow registers to be used for some frequently accessed */ /* global variables. Otherwise aliasing issues are likely */ /* to prevent that. */ ptr_t greatest_ha = GC_greatest_plausible_heap_addr; ptr_t least_ha = GC_least_plausible_heap_addr; mse * mark_stack_top = GC_mark_stack_top; mse * mark_stack_limit = GC_mark_stack_limit; # undef GC_mark_stack_top # undef GC_mark_stack_limit # define GC_mark_stack_top mark_stack_top # define GC_mark_stack_limit mark_stack_limit # define GC_greatest_plausible_heap_addr greatest_ha # define GC_least_plausible_heap_addr least_ha p = (word *)(h->hb_body); plim = (word *)(((word)h) + HBLKSIZE); /* go through all words in block */ while ((word)p < (word)plim) { mark_word = *mark_word_addr++; q = p; while(mark_word != 0) { if (mark_word & 1) { PUSH_GRANULE(q); } q += GC_GRANULE_WORDS; mark_word >>= 1; } p += WORDSZ*GC_GRANULE_WORDS; } # undef GC_greatest_plausible_heap_addr # undef GC_least_plausible_heap_addr # undef GC_mark_stack_top # undef GC_mark_stack_limit # define GC_mark_stack_limit GC_arrays._mark_stack_limit # define GC_mark_stack_top GC_arrays._mark_stack_top GC_mark_stack_top = mark_stack_top; } #ifndef UNALIGNED_PTRS /* Push all objects reachable from marked objects in the given block */ /* of size 2 (granules) objects. */ STATIC void GC_push_marked2(struct hblk *h, hdr *hhdr) { word * mark_word_addr = &(hhdr->hb_marks[0]); word *p; word *plim; word *q; word mark_word; ptr_t greatest_ha = GC_greatest_plausible_heap_addr; ptr_t least_ha = GC_least_plausible_heap_addr; mse * mark_stack_top = GC_mark_stack_top; mse * mark_stack_limit = GC_mark_stack_limit; # undef GC_mark_stack_top # undef GC_mark_stack_limit # define GC_mark_stack_top mark_stack_top # define GC_mark_stack_limit mark_stack_limit # define GC_greatest_plausible_heap_addr greatest_ha # define GC_least_plausible_heap_addr least_ha p = (word *)(h->hb_body); plim = (word *)(((word)h) + HBLKSIZE); /* go through all words in block */ while ((word)p < (word)plim) { mark_word = *mark_word_addr++; q = p; while(mark_word != 0) { if (mark_word & 1) { PUSH_GRANULE(q); PUSH_GRANULE(q + GC_GRANULE_WORDS); } q += 2 * GC_GRANULE_WORDS; mark_word >>= 2; } p += WORDSZ*GC_GRANULE_WORDS; } # undef GC_greatest_plausible_heap_addr # undef GC_least_plausible_heap_addr # undef GC_mark_stack_top # undef GC_mark_stack_limit # define GC_mark_stack_limit GC_arrays._mark_stack_limit # define GC_mark_stack_top GC_arrays._mark_stack_top GC_mark_stack_top = mark_stack_top; } # if GC_GRANULE_WORDS < 4 /* Push all objects reachable from marked objects in the given block */ /* of size 4 (granules) objects. */ /* There is a risk of mark stack overflow here. But we handle that. */ /* And only unmarked objects get pushed, so it's not very likely. */ STATIC void GC_push_marked4(struct hblk *h, hdr *hhdr) { word * mark_word_addr = &(hhdr->hb_marks[0]); word *p; word *plim; word *q; word mark_word; ptr_t greatest_ha = GC_greatest_plausible_heap_addr; ptr_t least_ha = GC_least_plausible_heap_addr; mse * mark_stack_top = GC_mark_stack_top; mse * mark_stack_limit = GC_mark_stack_limit; # undef GC_mark_stack_top # undef GC_mark_stack_limit # define GC_mark_stack_top mark_stack_top # define GC_mark_stack_limit mark_stack_limit # define GC_greatest_plausible_heap_addr greatest_ha # define GC_least_plausible_heap_addr least_ha p = (word *)(h->hb_body); plim = (word *)(((word)h) + HBLKSIZE); /* go through all words in block */ while ((word)p < (word)plim) { mark_word = *mark_word_addr++; q = p; while(mark_word != 0) { if (mark_word & 1) { PUSH_GRANULE(q); PUSH_GRANULE(q + GC_GRANULE_WORDS); PUSH_GRANULE(q + 2*GC_GRANULE_WORDS); PUSH_GRANULE(q + 3*GC_GRANULE_WORDS); } q += 4 * GC_GRANULE_WORDS; mark_word >>= 4; } p += WORDSZ*GC_GRANULE_WORDS; } # undef GC_greatest_plausible_heap_addr # undef GC_least_plausible_heap_addr # undef GC_mark_stack_top # undef GC_mark_stack_limit # define GC_mark_stack_limit GC_arrays._mark_stack_limit # define GC_mark_stack_top GC_arrays._mark_stack_top GC_mark_stack_top = mark_stack_top; } #endif /* GC_GRANULE_WORDS < 4 */ #endif /* UNALIGNED_PTRS */ #endif /* USE_PUSH_MARKED_ACCELERATORS */ /* Push all objects reachable from marked objects in the given block */ STATIC void GC_push_marked(struct hblk *h, hdr *hhdr) { size_t sz = hhdr -> hb_sz; word descr = hhdr -> hb_descr; ptr_t p; word bit_no; ptr_t lim; mse * GC_mark_stack_top_reg; mse * mark_stack_limit = GC_mark_stack_limit; /* Some quick shortcuts: */ if ((0 | GC_DS_LENGTH) == descr) return; if (GC_block_empty(hhdr)/* nothing marked */) return; GC_n_rescuing_pages++; GC_objects_are_marked = TRUE; if (sz > MAXOBJBYTES) { lim = h -> hb_body; } else { lim = (h + 1)->hb_body - sz; } switch(BYTES_TO_GRANULES(sz)) { # if defined(USE_PUSH_MARKED_ACCELERATORS) case 1: GC_push_marked1(h, hhdr); break; # if !defined(UNALIGNED_PTRS) case 2: GC_push_marked2(h, hhdr); break; # if GC_GRANULE_WORDS < 4 case 4: GC_push_marked4(h, hhdr); break; # endif # endif # endif default: GC_mark_stack_top_reg = GC_mark_stack_top; for (p = h -> hb_body, bit_no = 0; (word)p <= (word)lim; p += sz, bit_no += MARK_BIT_OFFSET(sz)) { if (mark_bit_from_hdr(hhdr, bit_no)) { /* Mark from fields inside the object */ PUSH_OBJ(p, hhdr, GC_mark_stack_top_reg, mark_stack_limit); } } GC_mark_stack_top = GC_mark_stack_top_reg; } } #ifdef ENABLE_DISCLAIM /* Unconditionally mark from all objects which have not been reclaimed. */ /* This is useful in order to retain pointers which are reachable from */ /* the disclaim notifiers. */ /* */ /* To determine whether an object has been reclaimed, we require that */ /* any live object has a non-zero as one of the two lowest bits of the */ /* first word. On the other hand, a reclaimed object is a members of */ /* free-lists, and thus contains a word-aligned next-pointer as the */ /* first word. */ STATIC void GC_push_unconditionally(struct hblk *h, hdr *hhdr) { size_t sz = hhdr -> hb_sz; word descr = hhdr -> hb_descr; ptr_t p; ptr_t lim; mse * GC_mark_stack_top_reg; mse * mark_stack_limit = GC_mark_stack_limit; if ((0 | GC_DS_LENGTH) == descr) return; GC_n_rescuing_pages++; GC_objects_are_marked = TRUE; if (sz > MAXOBJBYTES) lim = h -> hb_body; else lim = (h + 1)->hb_body - sz; GC_mark_stack_top_reg = GC_mark_stack_top; for (p = h -> hb_body; (word)p <= (word)lim; p += sz) if ((*(GC_word *)p & 0x3) != 0) PUSH_OBJ(p, hhdr, GC_mark_stack_top_reg, mark_stack_limit); GC_mark_stack_top = GC_mark_stack_top_reg; } #endif /* ENABLE_DISCLAIM */ #ifndef GC_DISABLE_INCREMENTAL /* Test whether any page in the given block is dirty. */ STATIC GC_bool GC_block_was_dirty(struct hblk *h, hdr *hhdr) { size_t sz = hhdr -> hb_sz; if (sz <= MAXOBJBYTES) { return(GC_page_was_dirty(h)); } else { ptr_t p = (ptr_t)h; while ((word)p < (word)h + sz) { if (GC_page_was_dirty((struct hblk *)p)) return(TRUE); p += HBLKSIZE; } return(FALSE); } } #endif /* GC_DISABLE_INCREMENTAL */ /* Similar to GC_push_marked, but skip over unallocated blocks */ /* and return address of next plausible block. */ STATIC struct hblk * GC_push_next_marked(struct hblk *h) { hdr * hhdr = HDR(h); if (EXPECT(IS_FORWARDING_ADDR_OR_NIL(hhdr) || HBLK_IS_FREE(hhdr), FALSE)) { h = GC_next_used_block(h); if (h == 0) return(0); hhdr = GC_find_header((ptr_t)h); } GC_push_marked(h, hhdr); return(h + OBJ_SZ_TO_BLOCKS(hhdr -> hb_sz)); } #ifndef GC_DISABLE_INCREMENTAL /* Identical to above, but mark only from dirty pages */ STATIC struct hblk * GC_push_next_marked_dirty(struct hblk *h) { hdr * hhdr = HDR(h); if (!GC_dirty_maintained) ABORT("Dirty bits not set up"); for (;;) { if (EXPECT(IS_FORWARDING_ADDR_OR_NIL(hhdr) || HBLK_IS_FREE(hhdr), FALSE)) { h = GC_next_used_block(h); if (h == 0) return(0); hhdr = GC_find_header((ptr_t)h); } # ifdef STUBBORN_ALLOC if (hhdr -> hb_obj_kind == STUBBORN) { if (GC_page_was_changed(h) && GC_block_was_dirty(h, hhdr)) { break; } } else { if (GC_block_was_dirty(h, hhdr)) break; } # else if (GC_block_was_dirty(h, hhdr)) break; # endif h += OBJ_SZ_TO_BLOCKS(hhdr -> hb_sz); hhdr = HDR(h); } GC_push_marked(h, hhdr); return(h + OBJ_SZ_TO_BLOCKS(hhdr -> hb_sz)); } #endif /* !GC_DISABLE_INCREMENTAL */ /* Similar to above, but for uncollectible pages. Needed since we */ /* do not clear marks for such pages, even for full collections. */ STATIC struct hblk * GC_push_next_marked_uncollectable(struct hblk *h) { hdr * hhdr = HDR(h); for (;;) { if (EXPECT(IS_FORWARDING_ADDR_OR_NIL(hhdr) || HBLK_IS_FREE(hhdr), FALSE)) { h = GC_next_used_block(h); if (h == 0) return(0); hhdr = GC_find_header((ptr_t)h); } if (hhdr -> hb_obj_kind == UNCOLLECTABLE) { GC_push_marked(h, hhdr); break; } # ifdef ENABLE_DISCLAIM if ((hhdr -> hb_flags & MARK_UNCONDITIONALLY) != 0) { GC_push_unconditionally(h, hhdr); break; } # endif h += OBJ_SZ_TO_BLOCKS(hhdr -> hb_sz); hhdr = HDR(h); } return(h + OBJ_SZ_TO_BLOCKS(hhdr -> hb_sz)); } ecl-16.1.2/src/bdwgc/mark_rts.c000066400000000000000000000716411266352375300162340ustar00rootroot00000000000000/* * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. */ #include "private/gc_priv.h" #include /* Data structure for list of root sets. */ /* We keep a hash table, so that we can filter out duplicate additions. */ /* Under Win32, we need to do a better job of filtering overlaps, so */ /* we resort to sequential search, and pay the price. */ /* This is really declared in gc_priv.h: struct roots { ptr_t r_start; ptr_t r_end; # if !defined(MSWIN32) && !defined(MSWINCE) && !defined(CYGWIN32) struct roots * r_next; # endif GC_bool r_tmp; -- Delete before registering new dynamic libraries }; struct roots GC_static_roots[MAX_ROOT_SETS]; */ int GC_no_dls = 0; /* Register dynamic library data segments. */ static int n_root_sets = 0; /* GC_static_roots[0..n_root_sets) contains the valid root sets. */ #if !defined(NO_DEBUGGING) || defined(GC_ASSERTIONS) /* Should return the same value as GC_root_size. */ GC_INNER word GC_compute_root_size(void) { int i; word size = 0; for (i = 0; i < n_root_sets; i++) { size += GC_static_roots[i].r_end - GC_static_roots[i].r_start; } return size; } #endif /* !NO_DEBUGGING || GC_ASSERTIONS */ #if !defined(NO_DEBUGGING) /* For debugging: */ void GC_print_static_roots(void) { int i; word size; for (i = 0; i < n_root_sets; i++) { GC_printf("From %p to %p%s\n", GC_static_roots[i].r_start, GC_static_roots[i].r_end, GC_static_roots[i].r_tmp ? " (temporary)" : ""); } GC_printf("GC_root_size: %lu\n", (unsigned long)GC_root_size); if ((size = GC_compute_root_size()) != GC_root_size) GC_err_printf("GC_root_size incorrect!! Should be: %lu\n", (unsigned long)size); } #endif /* !NO_DEBUGGING */ #ifndef THREADS /* Primarily for debugging support: */ /* Is the address p in one of the registered static root sections? */ GC_INNER GC_bool GC_is_static_root(ptr_t p) { static int last_root_set = MAX_ROOT_SETS; int i; if (last_root_set < n_root_sets && (word)p >= (word)GC_static_roots[last_root_set].r_start && (word)p < (word)GC_static_roots[last_root_set].r_end) return(TRUE); for (i = 0; i < n_root_sets; i++) { if ((word)p >= (word)GC_static_roots[i].r_start && (word)p < (word)GC_static_roots[i].r_end) { last_root_set = i; return(TRUE); } } return(FALSE); } #endif /* !THREADS */ #if !defined(MSWIN32) && !defined(MSWINCE) && !defined(CYGWIN32) /* # define LOG_RT_SIZE 6 # define RT_SIZE (1 << LOG_RT_SIZE) -- Power of 2, may be != MAX_ROOT_SETS struct roots * GC_root_index[RT_SIZE]; -- Hash table header. Used only to check whether a range is -- already present. -- really defined in gc_priv.h */ GC_INLINE int rt_hash(ptr_t addr) { word result = (word) addr; # if CPP_WORDSZ > 8*LOG_RT_SIZE result ^= result >> 8*LOG_RT_SIZE; # endif # if CPP_WORDSZ > 4*LOG_RT_SIZE result ^= result >> 4*LOG_RT_SIZE; # endif result ^= result >> 2*LOG_RT_SIZE; result ^= result >> LOG_RT_SIZE; result &= (RT_SIZE-1); return(result); } /* Is a range starting at b already in the table? If so return a */ /* pointer to it, else NULL. */ GC_INNER void * GC_roots_present(ptr_t b) { int h = rt_hash(b); struct roots *p = GC_root_index[h]; while (p != 0) { if (p -> r_start == (ptr_t)b) return(p); p = p -> r_next; } return NULL; } /* Add the given root structure to the index. */ GC_INLINE void add_roots_to_index(struct roots *p) { int h = rt_hash(p -> r_start); p -> r_next = GC_root_index[h]; GC_root_index[h] = p; } #endif /* !MSWIN32 && !MSWINCE && !CYGWIN32 */ GC_INNER word GC_root_size = 0; GC_API void GC_CALL GC_add_roots(void *b, void *e) { DCL_LOCK_STATE; if (!EXPECT(GC_is_initialized, TRUE)) GC_init(); LOCK(); GC_add_roots_inner((ptr_t)b, (ptr_t)e, FALSE); UNLOCK(); } /* Add [b,e) to the root set. Adding the same interval a second time */ /* is a moderately fast no-op, and hence benign. We do not handle */ /* different but overlapping intervals efficiently. (We do handle */ /* them correctly.) */ /* Tmp specifies that the interval may be deleted before */ /* re-registering dynamic libraries. */ void GC_add_roots_inner(ptr_t b, ptr_t e, GC_bool tmp) { struct roots * old; GC_ASSERT((word)b <= (word)e); b = (ptr_t)(((word)b + (sizeof(word) - 1)) & ~(sizeof(word) - 1)); /* round b up to word boundary */ e = (ptr_t)((word)e & ~(sizeof(word) - 1)); /* round e down to word boundary */ if ((word)b >= (word)e) return; /* nothing to do */ # if defined(MSWIN32) || defined(MSWINCE) || defined(CYGWIN32) /* Spend the time to ensure that there are no overlapping */ /* or adjacent intervals. */ /* This could be done faster with e.g. a */ /* balanced tree. But the execution time here is */ /* virtually guaranteed to be dominated by the time it */ /* takes to scan the roots. */ { register int i; old = 0; /* initialized to prevent warning. */ for (i = 0; i < n_root_sets; i++) { old = GC_static_roots + i; if ((word)b <= (word)old->r_end && (word)e >= (word)old->r_start) { if ((word)b < (word)old->r_start) { GC_root_size += old->r_start - b; old -> r_start = b; } if ((word)e > (word)old->r_end) { GC_root_size += e - old->r_end; old -> r_end = e; } old -> r_tmp &= tmp; break; } } if (i < n_root_sets) { /* merge other overlapping intervals */ struct roots *other; for (i++; i < n_root_sets; i++) { other = GC_static_roots + i; b = other -> r_start; e = other -> r_end; if ((word)b <= (word)old->r_end && (word)e >= (word)old->r_start) { if ((word)b < (word)old->r_start) { GC_root_size += old->r_start - b; old -> r_start = b; } if ((word)e > (word)old->r_end) { GC_root_size += e - old->r_end; old -> r_end = e; } old -> r_tmp &= other -> r_tmp; /* Delete this entry. */ GC_root_size -= (other -> r_end - other -> r_start); other -> r_start = GC_static_roots[n_root_sets-1].r_start; other -> r_end = GC_static_roots[n_root_sets-1].r_end; n_root_sets--; } } return; } } # else old = (struct roots *)GC_roots_present(b); if (old != 0) { if ((word)e <= (word)old->r_end) /* already there */ return; /* else extend */ GC_root_size += e - old -> r_end; old -> r_end = e; return; } # endif if (n_root_sets == MAX_ROOT_SETS) { ABORT("Too many root sets"); } # ifdef DEBUG_ADD_DEL_ROOTS GC_log_printf("Adding data root section %d: %p .. %p%s\n", n_root_sets, b, e, tmp ? " (temporary)" : ""); # endif GC_static_roots[n_root_sets].r_start = (ptr_t)b; GC_static_roots[n_root_sets].r_end = (ptr_t)e; GC_static_roots[n_root_sets].r_tmp = tmp; # if !defined(MSWIN32) && !defined(MSWINCE) && !defined(CYGWIN32) GC_static_roots[n_root_sets].r_next = 0; add_roots_to_index(GC_static_roots + n_root_sets); # endif GC_root_size += e - b; n_root_sets++; } static GC_bool roots_were_cleared = FALSE; GC_API void GC_CALL GC_clear_roots(void) { DCL_LOCK_STATE; if (!EXPECT(GC_is_initialized, TRUE)) GC_init(); LOCK(); roots_were_cleared = TRUE; n_root_sets = 0; GC_root_size = 0; # if !defined(MSWIN32) && !defined(MSWINCE) && !defined(CYGWIN32) BZERO(GC_root_index, RT_SIZE * sizeof(void *)); # endif # ifdef DEBUG_ADD_DEL_ROOTS GC_log_printf("Clear all data root sections\n"); # endif UNLOCK(); } /* Internal use only; lock held. */ STATIC void GC_remove_root_at_pos(int i) { # ifdef DEBUG_ADD_DEL_ROOTS GC_log_printf("Remove data root section at %d: %p .. %p%s\n", i, GC_static_roots[i].r_start, GC_static_roots[i].r_end, GC_static_roots[i].r_tmp ? " (temporary)" : ""); # endif GC_root_size -= (GC_static_roots[i].r_end - GC_static_roots[i].r_start); GC_static_roots[i].r_start = GC_static_roots[n_root_sets-1].r_start; GC_static_roots[i].r_end = GC_static_roots[n_root_sets-1].r_end; GC_static_roots[i].r_tmp = GC_static_roots[n_root_sets-1].r_tmp; n_root_sets--; } #if !defined(MSWIN32) && !defined(MSWINCE) && !defined(CYGWIN32) STATIC void GC_rebuild_root_index(void) { int i; BZERO(GC_root_index, RT_SIZE * sizeof(void *)); for (i = 0; i < n_root_sets; i++) add_roots_to_index(GC_static_roots + i); } #endif #if defined(DYNAMIC_LOADING) || defined(MSWIN32) || defined(MSWINCE) \ || defined(PCR) || defined(CYGWIN32) /* Internal use only; lock held. */ STATIC void GC_remove_tmp_roots(void) { int i; for (i = 0; i < n_root_sets; ) { if (GC_static_roots[i].r_tmp) { GC_remove_root_at_pos(i); } else { i++; } } # if !defined(MSWIN32) && !defined(MSWINCE) && !defined(CYGWIN32) GC_rebuild_root_index(); # endif } #endif #if !defined(MSWIN32) && !defined(MSWINCE) && !defined(CYGWIN32) STATIC void GC_remove_roots_inner(ptr_t b, ptr_t e); GC_API void GC_CALL GC_remove_roots(void *b, void *e) { DCL_LOCK_STATE; /* Quick check whether has nothing to do */ if ((((word)b + (sizeof(word) - 1)) & ~(sizeof(word) - 1)) >= ((word)e & ~(sizeof(word) - 1))) return; LOCK(); GC_remove_roots_inner((ptr_t)b, (ptr_t)e); UNLOCK(); } /* Should only be called when the lock is held */ STATIC void GC_remove_roots_inner(ptr_t b, ptr_t e) { int i; for (i = 0; i < n_root_sets; ) { if ((word)GC_static_roots[i].r_start >= (word)b && (word)GC_static_roots[i].r_end <= (word)e) { GC_remove_root_at_pos(i); } else { i++; } } GC_rebuild_root_index(); } #endif /* !defined(MSWIN32) && !defined(MSWINCE) && !defined(CYGWIN32) */ #if (defined(MSWIN32) || defined(MSWINCE) || defined(CYGWIN32)) \ && !defined(NO_DEBUGGING) /* Not used at present (except for, may be, debugging purpose). */ /* Workaround for the OS mapping and unmapping behind our back: */ /* Is the address p in one of the temporary static root sections? */ GC_bool GC_is_tmp_root(ptr_t p) { static int last_root_set = MAX_ROOT_SETS; register int i; if (last_root_set < n_root_sets && (word)p >= (word)GC_static_roots[last_root_set].r_start && (word)p < (word)GC_static_roots[last_root_set].r_end) return GC_static_roots[last_root_set].r_tmp; for (i = 0; i < n_root_sets; i++) { if ((word)p >= (word)GC_static_roots[i].r_start && (word)p < (word)GC_static_roots[i].r_end) { last_root_set = i; return GC_static_roots[i].r_tmp; } } return(FALSE); } #endif /* MSWIN32 || MSWINCE || CYGWIN32 */ GC_INNER ptr_t GC_approx_sp(void) { volatile word sp; sp = (word)&sp; /* Also force stack to grow if necessary. Otherwise the */ /* later accesses might cause the kernel to think we're */ /* doing something wrong. */ return((ptr_t)sp); /* GNU C: alternatively, we may return the value of */ /*__builtin_frame_address(0). */ } /* * Data structure for excluded static roots. * Real declaration is in gc_priv.h. struct exclusion { ptr_t e_start; ptr_t e_end; }; struct exclusion GC_excl_table[MAX_EXCLUSIONS]; -- Array of exclusions, ascending -- address order. */ STATIC size_t GC_excl_table_entries = 0;/* Number of entries in use. */ /* Return the first exclusion range that includes an address >= start_addr */ /* Assumes the exclusion table contains at least one entry (namely the */ /* GC data structures). */ STATIC struct exclusion * GC_next_exclusion(ptr_t start_addr) { size_t low = 0; size_t high = GC_excl_table_entries - 1; size_t mid; while (high > low) { mid = (low + high) >> 1; /* low <= mid < high */ if ((word) GC_excl_table[mid].e_end <= (word) start_addr) { low = mid + 1; } else { high = mid; } } if ((word) GC_excl_table[low].e_end <= (word) start_addr) return 0; return GC_excl_table + low; } /* Should only be called when the lock is held. The range boundaries */ /* should be properly aligned and valid. */ GC_INNER void GC_exclude_static_roots_inner(void *start, void *finish) { struct exclusion * next; size_t next_index, i; GC_ASSERT((word)start % sizeof(word) == 0); GC_ASSERT((word)start < (word)finish); if (0 == GC_excl_table_entries) { next = 0; } else { next = GC_next_exclusion(start); } if (0 != next) { if ((word)(next -> e_start) < (word) finish) { /* incomplete error check. */ ABORT("Exclusion ranges overlap"); } if ((word)(next -> e_start) == (word) finish) { /* extend old range backwards */ next -> e_start = (ptr_t)start; return; } next_index = next - GC_excl_table; for (i = GC_excl_table_entries; i > next_index; --i) { GC_excl_table[i] = GC_excl_table[i-1]; } } else { next_index = GC_excl_table_entries; } if (GC_excl_table_entries == MAX_EXCLUSIONS) ABORT("Too many exclusions"); GC_excl_table[next_index].e_start = (ptr_t)start; GC_excl_table[next_index].e_end = (ptr_t)finish; ++GC_excl_table_entries; } GC_API void GC_CALL GC_exclude_static_roots(void *b, void *e) { DCL_LOCK_STATE; if (b == e) return; /* nothing to exclude? */ /* Round boundaries (in direction reverse to that of GC_add_roots). */ b = (void *)((word)b & ~(sizeof(word) - 1)); e = (void *)(((word)e + (sizeof(word) - 1)) & ~(sizeof(word) - 1)); if (0 == e) e = (void *)(word)(~(sizeof(word) - 1)); /* handle overflow */ LOCK(); GC_exclude_static_roots_inner(b, e); UNLOCK(); } /* Invoke push_conditional on ranges that are not excluded. */ STATIC void GC_push_conditional_with_exclusions(ptr_t bottom, ptr_t top, GC_bool all GC_ATTR_UNUSED) { struct exclusion * next; ptr_t excl_start; while ((word)bottom < (word)top) { next = GC_next_exclusion(bottom); if (0 == next || (word)(excl_start = next -> e_start) >= (word)top) { GC_PUSH_CONDITIONAL(bottom, top, all); return; } if ((word)excl_start > (word)bottom) GC_PUSH_CONDITIONAL(bottom, excl_start, all); bottom = next -> e_end; } } #ifdef IA64 /* Similar to GC_push_all_stack_sections() but for IA-64 registers store. */ GC_INNER void GC_push_all_register_sections(ptr_t bs_lo, ptr_t bs_hi, int eager, struct GC_traced_stack_sect_s *traced_stack_sect) { while (traced_stack_sect != NULL) { ptr_t frame_bs_lo = traced_stack_sect -> backing_store_end; GC_ASSERT((word)frame_bs_lo <= (word)bs_hi); if (eager) { GC_push_all_eager(frame_bs_lo, bs_hi); } else { GC_push_all_stack(frame_bs_lo, bs_hi); } bs_hi = traced_stack_sect -> saved_backing_store_ptr; traced_stack_sect = traced_stack_sect -> prev; } GC_ASSERT((word)bs_lo <= (word)bs_hi); if (eager) { GC_push_all_eager(bs_lo, bs_hi); } else { GC_push_all_stack(bs_lo, bs_hi); } } #endif /* IA64 */ #ifdef THREADS GC_INNER void GC_push_all_stack_sections(ptr_t lo, ptr_t hi, struct GC_traced_stack_sect_s *traced_stack_sect) { while (traced_stack_sect != NULL) { GC_ASSERT((word)lo HOTTER_THAN (word)traced_stack_sect); # ifdef STACK_GROWS_UP GC_push_all_stack((ptr_t)traced_stack_sect, lo); # else /* STACK_GROWS_DOWN */ GC_push_all_stack(lo, (ptr_t)traced_stack_sect); # endif lo = traced_stack_sect -> saved_stack_ptr; GC_ASSERT(lo != NULL); traced_stack_sect = traced_stack_sect -> prev; } GC_ASSERT(!((word)hi HOTTER_THAN (word)lo)); # ifdef STACK_GROWS_UP /* We got them backwards! */ GC_push_all_stack(hi, lo); # else /* STACK_GROWS_DOWN */ GC_push_all_stack(lo, hi); # endif } #else /* !THREADS */ # ifdef TRACE_BUF /* Defined in mark.c. */ void GC_add_trace_entry(char *kind, word arg1, word arg2); # endif /* Similar to GC_push_all_eager, but only the */ /* part hotter than cold_gc_frame is scanned */ /* immediately. Needed to ensure that callee- */ /* save registers are not missed. */ /* * A version of GC_push_all that treats all interior pointers as valid * and scans part of the area immediately, to make sure that saved * register values are not lost. * Cold_gc_frame delimits the stack section that must be scanned * eagerly. A zero value indicates that no eager scanning is needed. * We don't need to worry about the MANUAL_VDB case here, since this * is only called in the single-threaded case. We assume that we * cannot collect between an assignment and the corresponding * GC_dirty() call. */ STATIC void GC_push_all_stack_partially_eager(ptr_t bottom, ptr_t top, ptr_t cold_gc_frame) { if (!NEED_FIXUP_POINTER && GC_all_interior_pointers) { /* Push the hot end of the stack eagerly, so that register values */ /* saved inside GC frames are marked before they disappear. */ /* The rest of the marking can be deferred until later. */ if (0 == cold_gc_frame) { GC_push_all_stack(bottom, top); return; } GC_ASSERT((word)bottom <= (word)cold_gc_frame && (word)cold_gc_frame <= (word)top); # ifdef STACK_GROWS_DOWN GC_push_all(cold_gc_frame - sizeof(ptr_t), top); GC_push_all_eager(bottom, cold_gc_frame); # else /* STACK_GROWS_UP */ GC_push_all(bottom, cold_gc_frame + sizeof(ptr_t)); GC_push_all_eager(cold_gc_frame, top); # endif /* STACK_GROWS_UP */ } else { GC_push_all_eager(bottom, top); } # ifdef TRACE_BUF GC_add_trace_entry("GC_push_all_stack", bottom, top); # endif } /* Similar to GC_push_all_stack_sections() but also uses cold_gc_frame. */ STATIC void GC_push_all_stack_part_eager_sections(ptr_t lo, ptr_t hi, ptr_t cold_gc_frame, struct GC_traced_stack_sect_s *traced_stack_sect) { GC_ASSERT(traced_stack_sect == NULL || cold_gc_frame == NULL || (word)cold_gc_frame HOTTER_THAN (word)traced_stack_sect); while (traced_stack_sect != NULL) { GC_ASSERT((word)lo HOTTER_THAN (word)traced_stack_sect); # ifdef STACK_GROWS_UP GC_push_all_stack_partially_eager((ptr_t)traced_stack_sect, lo, cold_gc_frame); # else /* STACK_GROWS_DOWN */ GC_push_all_stack_partially_eager(lo, (ptr_t)traced_stack_sect, cold_gc_frame); # endif lo = traced_stack_sect -> saved_stack_ptr; GC_ASSERT(lo != NULL); traced_stack_sect = traced_stack_sect -> prev; cold_gc_frame = NULL; /* Use at most once. */ } GC_ASSERT(!((word)hi HOTTER_THAN (word)lo)); # ifdef STACK_GROWS_UP /* We got them backwards! */ GC_push_all_stack_partially_eager(hi, lo, cold_gc_frame); # else /* STACK_GROWS_DOWN */ GC_push_all_stack_partially_eager(lo, hi, cold_gc_frame); # endif } #endif /* !THREADS */ /* Push enough of the current stack eagerly to */ /* ensure that callee-save registers saved in */ /* GC frames are scanned. */ /* In the non-threads case, schedule entire */ /* stack for scanning. */ /* The second argument is a pointer to the */ /* (possibly null) thread context, for */ /* (currently hypothetical) more precise */ /* stack scanning. */ /* * In the absence of threads, push the stack contents. * In the presence of threads, push enough of the current stack * to ensure that callee-save registers saved in collector frames have been * seen. * FIXME: Merge with per-thread stuff. */ STATIC void GC_push_current_stack(ptr_t cold_gc_frame, void * context GC_ATTR_UNUSED) { # if defined(THREADS) if (0 == cold_gc_frame) return; # ifdef STACK_GROWS_DOWN GC_push_all_eager(GC_approx_sp(), cold_gc_frame); /* For IA64, the register stack backing store is handled */ /* in the thread-specific code. */ # else GC_push_all_eager(cold_gc_frame, GC_approx_sp()); # endif # else GC_push_all_stack_part_eager_sections(GC_approx_sp(), GC_stackbottom, cold_gc_frame, GC_traced_stack_sect); # ifdef IA64 /* We also need to push the register stack backing store. */ /* This should really be done in the same way as the */ /* regular stack. For now we fudge it a bit. */ /* Note that the backing store grows up, so we can't use */ /* GC_push_all_stack_partially_eager. */ { ptr_t bsp = GC_save_regs_ret_val; ptr_t cold_gc_bs_pointer = bsp - 2048; if (GC_all_interior_pointers && (word)cold_gc_bs_pointer > (word)BACKING_STORE_BASE) { /* Adjust cold_gc_bs_pointer if below our innermost */ /* "traced stack section" in backing store. */ if (GC_traced_stack_sect != NULL && (word)cold_gc_bs_pointer < (word)GC_traced_stack_sect->backing_store_end) cold_gc_bs_pointer = GC_traced_stack_sect->backing_store_end; GC_push_all_register_sections(BACKING_STORE_BASE, cold_gc_bs_pointer, FALSE, GC_traced_stack_sect); GC_push_all_eager(cold_gc_bs_pointer, bsp); } else { GC_push_all_register_sections(BACKING_STORE_BASE, bsp, TRUE /* eager */, GC_traced_stack_sect); } /* All values should be sufficiently aligned that we */ /* don't have to worry about the boundary. */ } # endif # endif /* !THREADS */ } GC_INNER void (*GC_push_typed_structures)(void) = 0; /* Push GC internal roots. These are normally */ /* included in the static data segment, and */ /* Thus implicitly pushed. But we must do this */ /* explicitly if normal root processing is */ /* disabled. */ /* * Push GC internal roots. Only called if there is some reason to believe * these would not otherwise get registered. */ STATIC void GC_push_gc_structures(void) { # ifndef GC_NO_FINALIZATION GC_push_finalizer_structures(); # endif # if defined(THREADS) GC_push_thread_structures(); # endif if( GC_push_typed_structures ) GC_push_typed_structures(); } GC_INNER void GC_cond_register_dynamic_libraries(void) { # if defined(DYNAMIC_LOADING) || defined(MSWIN32) || defined(MSWINCE) \ || defined(CYGWIN32) || defined(PCR) GC_remove_tmp_roots(); if (!GC_no_dls) GC_register_dynamic_libraries(); # else GC_no_dls = TRUE; # endif } STATIC void GC_push_regs_and_stack(ptr_t cold_gc_frame) { GC_with_callee_saves_pushed(GC_push_current_stack, cold_gc_frame); } /* * Call the mark routines (GC_tl_push for a single pointer, * GC_push_conditional on groups of pointers) on every top level * accessible pointer. * If all is FALSE, arrange to push only possibly altered values. * Cold_gc_frame is an address inside a GC frame that * remains valid until all marking is complete. * A zero value indicates that it's OK to miss some * register values. */ GC_INNER void GC_push_roots(GC_bool all, ptr_t cold_gc_frame GC_ATTR_UNUSED) { int i; unsigned kind; /* * Next push static data. This must happen early on, since it's * not robust against mark stack overflow. */ /* Re-register dynamic libraries, in case one got added. */ /* There is some argument for doing this as late as possible, */ /* especially on win32, where it can change asynchronously. */ /* In those cases, we do it here. But on other platforms, it's */ /* not safe with the world stopped, so we do it earlier. */ # if !defined(REGISTER_LIBRARIES_EARLY) GC_cond_register_dynamic_libraries(); # endif /* Mark everything in static data areas */ for (i = 0; i < n_root_sets; i++) { GC_push_conditional_with_exclusions( GC_static_roots[i].r_start, GC_static_roots[i].r_end, all); } /* Mark all free list header blocks, if those were allocated from */ /* the garbage collected heap. This makes sure they don't */ /* disappear if we are not marking from static data. It also */ /* saves us the trouble of scanning them, and possibly that of */ /* marking the freelists. */ for (kind = 0; kind < GC_n_kinds; kind++) { void *base = GC_base(GC_obj_kinds[kind].ok_freelist); if (0 != base) { GC_set_mark_bit(base); } } /* Mark from GC internal roots if those might otherwise have */ /* been excluded. */ if (GC_no_dls || roots_were_cleared) { GC_push_gc_structures(); } /* Mark thread local free lists, even if their mark */ /* descriptor excludes the link field. */ /* If the world is not stopped, this is unsafe. It is */ /* also unnecessary, since we will do this again with the */ /* world stopped. */ # if defined(THREAD_LOCAL_ALLOC) if (GC_world_stopped) GC_mark_thread_local_free_lists(); # endif /* * Now traverse stacks, and mark from register contents. * These must be done last, since they can legitimately overflow * the mark stack. * This is usually done by saving the current context on the * stack, and then just tracing from the stack. */ # ifndef STACK_NOT_SCANNED GC_push_regs_and_stack(cold_gc_frame); # endif if (GC_push_other_roots != 0) (*GC_push_other_roots)(); /* In the threads case, this also pushes thread stacks. */ /* Note that without interior pointer recognition lots */ /* of stuff may have been pushed already, and this */ /* should be careful about mark stack overflows. */ } ecl-16.1.2/src/bdwgc/misc.c000066400000000000000000002103231266352375300153350ustar00rootroot00000000000000/* * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. * Copyright (c) 1999-2001 by Hewlett-Packard Company. All rights reserved. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. */ #include "private/gc_pmark.h" #include #include #include #ifndef MSWINCE # include #endif #ifdef GC_SOLARIS_THREADS # include #endif #if defined(MSWIN32) || defined(MSWINCE) \ || (defined(CYGWIN32) && defined(GC_READ_ENV_FILE)) # ifndef WIN32_LEAN_AND_MEAN # define WIN32_LEAN_AND_MEAN 1 # endif # define NOSERVICE # include #endif #if defined(UNIX_LIKE) || defined(CYGWIN32) || defined(SYMBIAN) # include # include # include #endif #ifdef NONSTOP # include #endif #ifdef THREADS # ifdef PCR # include "il/PCR_IL.h" GC_INNER PCR_Th_ML GC_allocate_ml; # elif defined(SN_TARGET_PS3) # include GC_INNER pthread_mutex_t GC_allocate_ml; # endif /* For other platforms with threads, the lock and possibly */ /* GC_lock_holder variables are defined in the thread support code. */ #endif /* THREADS */ #ifdef DYNAMIC_LOADING /* We need to register the main data segment. Returns TRUE unless */ /* this is done implicitly as part of dynamic library registration. */ # define GC_REGISTER_MAIN_STATIC_DATA() GC_register_main_static_data() #elif defined(GC_DONT_REGISTER_MAIN_STATIC_DATA) # define GC_REGISTER_MAIN_STATIC_DATA() FALSE #else /* Don't unnecessarily call GC_register_main_static_data() in case */ /* dyn_load.c isn't linked in. */ # define GC_REGISTER_MAIN_STATIC_DATA() TRUE #endif #ifdef NEED_CANCEL_DISABLE_COUNT __thread unsigned char GC_cancel_disable_count = 0; #endif GC_FAR struct _GC_arrays GC_arrays /* = { 0 } */; GC_INNER GC_bool GC_debugging_started = FALSE; /* defined here so we don't have to load debug_malloc.o */ ptr_t GC_stackbottom = 0; #ifdef IA64 ptr_t GC_register_stackbottom = 0; #endif int GC_dont_gc = FALSE; int GC_dont_precollect = FALSE; GC_bool GC_quiet = 0; /* used also in pcr_interface.c */ #ifndef SMALL_CONFIG int GC_print_stats = 0; #endif #ifdef GC_PRINT_BACK_HEIGHT GC_INNER GC_bool GC_print_back_height = TRUE; #else GC_INNER GC_bool GC_print_back_height = FALSE; #endif #ifndef NO_DEBUGGING # ifdef GC_DUMP_REGULARLY GC_INNER GC_bool GC_dump_regularly = TRUE; /* Generate regular debugging dumps. */ # else GC_INNER GC_bool GC_dump_regularly = FALSE; # endif #endif #ifdef KEEP_BACK_PTRS GC_INNER long GC_backtraces = 0; /* Number of random backtraces to generate for each GC. */ #endif #ifdef FIND_LEAK int GC_find_leak = 1; #else int GC_find_leak = 0; #endif #ifndef SHORT_DBG_HDRS # ifdef GC_FINDLEAK_DELAY_FREE GC_INNER GC_bool GC_findleak_delay_free = TRUE; # else GC_INNER GC_bool GC_findleak_delay_free = FALSE; # endif #endif /* !SHORT_DBG_HDRS */ #ifdef ALL_INTERIOR_POINTERS int GC_all_interior_pointers = 1; #else int GC_all_interior_pointers = 0; #endif #ifdef FINALIZE_ON_DEMAND int GC_finalize_on_demand = 1; #else int GC_finalize_on_demand = 0; #endif #ifdef JAVA_FINALIZATION int GC_java_finalization = 1; #else int GC_java_finalization = 0; #endif /* All accesses to it should be synchronized to avoid data races. */ GC_finalizer_notifier_proc GC_finalizer_notifier = (GC_finalizer_notifier_proc)0; #ifdef GC_FORCE_UNMAP_ON_GCOLLECT /* Has no effect unless USE_MUNMAP. */ /* Has no effect on implicitly-initiated garbage collections. */ GC_INNER GC_bool GC_force_unmap_on_gcollect = TRUE; #else GC_INNER GC_bool GC_force_unmap_on_gcollect = FALSE; #endif #ifndef GC_LARGE_ALLOC_WARN_INTERVAL # define GC_LARGE_ALLOC_WARN_INTERVAL 5 #endif GC_INNER long GC_large_alloc_warn_interval = GC_LARGE_ALLOC_WARN_INTERVAL; /* Interval between unsuppressed warnings. */ STATIC void * GC_CALLBACK GC_default_oom_fn( size_t bytes_requested GC_ATTR_UNUSED) { return(0); } /* All accesses to it should be synchronized to avoid data races. */ GC_oom_func GC_oom_fn = GC_default_oom_fn; #ifdef CAN_HANDLE_FORK # ifdef HANDLE_FORK GC_INNER int GC_handle_fork = 1; /* The value is examined by GC_thr_init. */ # else GC_INNER int GC_handle_fork = FALSE; # endif #elif !defined(HAVE_NO_FORK) /* Same as above but with GC_CALL calling conventions. */ GC_API void GC_CALL GC_atfork_prepare(void) { # ifdef THREADS ABORT("fork() handling unsupported"); # endif } GC_API void GC_CALL GC_atfork_parent(void) { /* empty */ } GC_API void GC_CALL GC_atfork_child(void) { /* empty */ } #endif /* !CAN_HANDLE_FORK && !HAVE_NO_FORK */ /* Overrides the default automatic handle-fork mode. Has effect only */ /* if called before GC_INIT. */ GC_API void GC_CALL GC_set_handle_fork(int value GC_ATTR_UNUSED) { # ifdef CAN_HANDLE_FORK if (!GC_is_initialized) GC_handle_fork = value >= -1 ? value : 1; /* Map all negative values except for -1 to a positive one. */ # elif defined(THREADS) || (defined(DARWIN) && defined(MPROTECT_VDB)) if (!GC_is_initialized && value) { # ifndef SMALL_CONFIG GC_init(); /* just to initialize GC_stderr */ # endif ABORT("fork() handling unsupported"); } # else /* No at-fork handler is needed in the single-threaded mode. */ # endif } /* Set things up so that GC_size_map[i] >= granules(i), */ /* but not too much bigger */ /* and so that size_map contains relatively few distinct entries */ /* This was originally stolen from Russ Atkinson's Cedar */ /* quantization algorithm (but we precompute it). */ STATIC void GC_init_size_map(void) { int i; /* Map size 0 to something bigger. */ /* This avoids problems at lower levels. */ GC_size_map[0] = 1; for (i = 1; i <= GRANULES_TO_BYTES(TINY_FREELISTS-1) - EXTRA_BYTES; i++) { GC_size_map[i] = ROUNDED_UP_GRANULES(i); # ifndef _MSC_VER GC_ASSERT(GC_size_map[i] < TINY_FREELISTS); /* Seems to tickle bug in VC++ 2008 for AMD64 */ # endif } /* We leave the rest of the array to be filled in on demand. */ } /* Fill in additional entries in GC_size_map, including the ith one */ /* We assume the ith entry is currently 0. */ /* Note that a filled in section of the array ending at n always */ /* has length at least n/4. */ GC_INNER void GC_extend_size_map(size_t i) { size_t orig_granule_sz = ROUNDED_UP_GRANULES(i); size_t granule_sz = orig_granule_sz; size_t byte_sz = GRANULES_TO_BYTES(granule_sz); /* The size we try to preserve. */ /* Close to i, unless this would */ /* introduce too many distinct sizes. */ size_t smaller_than_i = byte_sz - (byte_sz >> 3); size_t much_smaller_than_i = byte_sz - (byte_sz >> 2); size_t low_limit; /* The lowest indexed entry we */ /* initialize. */ size_t j; if (GC_size_map[smaller_than_i] == 0) { low_limit = much_smaller_than_i; while (GC_size_map[low_limit] != 0) low_limit++; } else { low_limit = smaller_than_i + 1; while (GC_size_map[low_limit] != 0) low_limit++; granule_sz = ROUNDED_UP_GRANULES(low_limit); granule_sz += granule_sz >> 3; if (granule_sz < orig_granule_sz) granule_sz = orig_granule_sz; } /* For these larger sizes, we use an even number of granules. */ /* This makes it easier to, for example, construct a 16byte-aligned */ /* allocator even if GRANULE_BYTES is 8. */ granule_sz += 1; granule_sz &= ~1; if (granule_sz > MAXOBJGRANULES) { granule_sz = MAXOBJGRANULES; } /* If we can fit the same number of larger objects in a block, */ /* do so. */ { size_t number_of_objs = HBLK_GRANULES/granule_sz; GC_ASSERT(number_of_objs != 0); granule_sz = HBLK_GRANULES/number_of_objs; granule_sz &= ~1; } byte_sz = GRANULES_TO_BYTES(granule_sz); /* We may need one extra byte; */ /* don't always fill in GC_size_map[byte_sz] */ byte_sz -= EXTRA_BYTES; for (j = low_limit; j <= byte_sz; j++) GC_size_map[j] = granule_sz; } /* * The following is a gross hack to deal with a problem that can occur * on machines that are sloppy about stack frame sizes, notably SPARC. * Bogus pointers may be written to the stack and not cleared for * a LONG time, because they always fall into holes in stack frames * that are not written. We partially address this by clearing * sections of the stack whenever we get control. */ # ifdef THREADS # define BIG_CLEAR_SIZE 2048 /* Clear this much now and then. */ # define SMALL_CLEAR_SIZE 256 /* Clear this much every time. */ # else STATIC word GC_stack_last_cleared = 0; /* GC_no when we last did this */ STATIC ptr_t GC_min_sp = NULL; /* Coolest stack pointer value from which */ /* we've already cleared the stack. */ STATIC ptr_t GC_high_water = NULL; /* "hottest" stack pointer value we have seen */ /* recently. Degrades over time. */ STATIC word GC_bytes_allocd_at_reset = 0; # define DEGRADE_RATE 50 # endif # define CLEAR_SIZE 213 /* Granularity for GC_clear_stack_inner */ #if defined(ASM_CLEAR_CODE) void *GC_clear_stack_inner(void *, ptr_t); #else /* Clear the stack up to about limit. Return arg. This function is */ /* not static because it could also be erroneously defined in .S */ /* file, so this error would be caught by the linker. */ void * GC_clear_stack_inner(void *arg, ptr_t limit) { volatile word dummy[CLEAR_SIZE]; BZERO((/* no volatile */ void *)dummy, sizeof(dummy)); if ((word)GC_approx_sp() COOLER_THAN (word)limit) { (void) GC_clear_stack_inner(arg, limit); } /* Make sure the recursive call is not a tail call, and the bzero */ /* call is not recognized as dead code. */ GC_noop1((word)dummy); return(arg); } #endif /* Clear some of the inaccessible part of the stack. Returns its */ /* argument, so it can be used in a tail call position, hence clearing */ /* another frame. */ GC_API void * GC_CALL GC_clear_stack(void *arg) { # ifndef STACK_NOT_SCANNED ptr_t sp = GC_approx_sp(); /* Hotter than actual sp */ # ifdef THREADS word volatile dummy[SMALL_CLEAR_SIZE]; static unsigned random_no = 0; /* Should be more random than it is ... */ /* Used to occasionally clear a bigger */ /* chunk. */ # endif ptr_t limit; # define SLOP 400 /* Extra bytes we clear every time. This clears our own */ /* activation record, and should cause more frequent */ /* clearing near the cold end of the stack, a good thing. */ # define GC_SLOP 4000 /* We make GC_high_water this much hotter than we really saw */ /* saw it, to cover for GC noise etc. above our current frame. */ # define CLEAR_THRESHOLD 100000 /* We restart the clearing process after this many bytes of */ /* allocation. Otherwise very heavily recursive programs */ /* with sparse stacks may result in heaps that grow almost */ /* without bounds. As the heap gets larger, collection */ /* frequency decreases, thus clearing frequency would decrease, */ /* thus more junk remains accessible, thus the heap gets */ /* larger ... */ # ifdef THREADS if (++random_no % 13 == 0) { limit = sp; MAKE_HOTTER(limit, BIG_CLEAR_SIZE*sizeof(word)); limit = (ptr_t)((word)limit & ~0xf); /* Make it sufficiently aligned for assembly */ /* implementations of GC_clear_stack_inner. */ return GC_clear_stack_inner(arg, limit); } else { BZERO((void *)dummy, SMALL_CLEAR_SIZE*sizeof(word)); } # else if (GC_gc_no > GC_stack_last_cleared) { /* Start things over, so we clear the entire stack again */ if (GC_stack_last_cleared == 0) GC_high_water = (ptr_t)GC_stackbottom; GC_min_sp = GC_high_water; GC_stack_last_cleared = GC_gc_no; GC_bytes_allocd_at_reset = GC_bytes_allocd; } /* Adjust GC_high_water */ MAKE_COOLER(GC_high_water, WORDS_TO_BYTES(DEGRADE_RATE) + GC_SLOP); if ((word)sp HOTTER_THAN (word)GC_high_water) { GC_high_water = sp; } MAKE_HOTTER(GC_high_water, GC_SLOP); limit = GC_min_sp; MAKE_HOTTER(limit, SLOP); if ((word)sp COOLER_THAN (word)limit) { limit = (ptr_t)((word)limit & ~0xf); /* Make it sufficiently aligned for assembly */ /* implementations of GC_clear_stack_inner. */ GC_min_sp = sp; return GC_clear_stack_inner(arg, limit); } else if (GC_bytes_allocd - GC_bytes_allocd_at_reset > CLEAR_THRESHOLD) { /* Restart clearing process, but limit how much clearing we do. */ GC_min_sp = sp; MAKE_HOTTER(GC_min_sp, CLEAR_THRESHOLD/4); if ((word)GC_min_sp HOTTER_THAN (word)GC_high_water) GC_min_sp = GC_high_water; GC_bytes_allocd_at_reset = GC_bytes_allocd; } # endif # endif return arg; } /* Return a pointer to the base address of p, given a pointer to a */ /* an address within an object. Return 0 o.w. */ GC_API void * GC_CALL GC_base(void * p) { ptr_t r; struct hblk *h; bottom_index *bi; hdr *candidate_hdr; ptr_t limit; r = p; if (!EXPECT(GC_is_initialized, TRUE)) return 0; h = HBLKPTR(r); GET_BI(r, bi); candidate_hdr = HDR_FROM_BI(bi, r); if (candidate_hdr == 0) return(0); /* If it's a pointer to the middle of a large object, move it */ /* to the beginning. */ while (IS_FORWARDING_ADDR_OR_NIL(candidate_hdr)) { h = FORWARDED_ADDR(h,candidate_hdr); r = (ptr_t)h; candidate_hdr = HDR(h); } if (HBLK_IS_FREE(candidate_hdr)) return(0); /* Make sure r points to the beginning of the object */ r = (ptr_t)((word)r & ~(WORDS_TO_BYTES(1) - 1)); { size_t offset = HBLKDISPL(r); word sz = candidate_hdr -> hb_sz; size_t obj_displ = offset % sz; r -= obj_displ; limit = r + sz; if ((word)limit > (word)(h + 1) && sz <= HBLKSIZE) { return(0); } if ((word)p >= (word)limit) return(0); } return((void *)r); } /* Return TRUE if and only if p points to somewhere in GC heap. */ GC_API int GC_CALL GC_is_heap_ptr(const void *p) { bottom_index *bi; GC_ASSERT(GC_is_initialized); GET_BI(p, bi); return HDR_FROM_BI(bi, p) != 0; } /* Return the size of an object, given a pointer to its base. */ /* (For small objects this also happens to work from interior pointers, */ /* but that shouldn't be relied upon.) */ GC_API size_t GC_CALL GC_size(const void * p) { hdr * hhdr = HDR(p); return hhdr -> hb_sz; } /* These getters remain unsynchronized for compatibility (since some */ /* clients could call some of them from a GC callback holding the */ /* allocator lock). */ GC_API size_t GC_CALL GC_get_heap_size(void) { /* ignore the memory space returned to OS (i.e. count only the */ /* space owned by the garbage collector) */ return (size_t)(GC_heapsize - GC_unmapped_bytes); } GC_API size_t GC_CALL GC_get_free_bytes(void) { /* ignore the memory space returned to OS */ return (size_t)(GC_large_free_bytes - GC_unmapped_bytes); } GC_API size_t GC_CALL GC_get_unmapped_bytes(void) { return (size_t)GC_unmapped_bytes; } GC_API size_t GC_CALL GC_get_bytes_since_gc(void) { return (size_t)GC_bytes_allocd; } GC_API size_t GC_CALL GC_get_total_bytes(void) { return (size_t)(GC_bytes_allocd + GC_bytes_allocd_before_gc); } #ifndef GC_GET_HEAP_USAGE_NOT_NEEDED /* Return the heap usage information. This is a thread-safe (atomic) */ /* alternative for the five above getters. NULL pointer is allowed for */ /* any argument. Returned (filled in) values are of word type. */ GC_API void GC_CALL GC_get_heap_usage_safe(GC_word *pheap_size, GC_word *pfree_bytes, GC_word *punmapped_bytes, GC_word *pbytes_since_gc, GC_word *ptotal_bytes) { DCL_LOCK_STATE; LOCK(); if (pheap_size != NULL) *pheap_size = GC_heapsize - GC_unmapped_bytes; if (pfree_bytes != NULL) *pfree_bytes = GC_large_free_bytes - GC_unmapped_bytes; if (punmapped_bytes != NULL) *punmapped_bytes = GC_unmapped_bytes; if (pbytes_since_gc != NULL) *pbytes_since_gc = GC_bytes_allocd; if (ptotal_bytes != NULL) *ptotal_bytes = GC_bytes_allocd + GC_bytes_allocd_before_gc; UNLOCK(); } GC_INNER word GC_reclaimed_bytes_before_gc = 0; /* Fill in GC statistics provided the destination is of enough size. */ static void fill_prof_stats(struct GC_prof_stats_s *pstats) { pstats->heapsize_full = GC_heapsize; pstats->free_bytes_full = GC_large_free_bytes; pstats->unmapped_bytes = GC_unmapped_bytes; pstats->bytes_allocd_since_gc = GC_bytes_allocd; pstats->allocd_bytes_before_gc = GC_bytes_allocd_before_gc; pstats->non_gc_bytes = GC_non_gc_bytes; pstats->gc_no = GC_gc_no; /* could be -1 */ # ifdef PARALLEL_MARK pstats->markers_m1 = (word)GC_markers_m1; # else pstats->markers_m1 = 0; /* one marker */ # endif pstats->bytes_reclaimed_since_gc = GC_bytes_found > 0 ? (word)GC_bytes_found : 0; pstats->reclaimed_bytes_before_gc = GC_reclaimed_bytes_before_gc; } # include /* for memset() */ GC_API size_t GC_CALL GC_get_prof_stats(struct GC_prof_stats_s *pstats, size_t stats_sz) { struct GC_prof_stats_s stats; DCL_LOCK_STATE; LOCK(); fill_prof_stats(stats_sz >= sizeof(stats) ? pstats : &stats); UNLOCK(); if (stats_sz == sizeof(stats)) { return sizeof(stats); } else if (stats_sz > sizeof(stats)) { /* Fill in the remaining part with -1. */ memset((char *)pstats + sizeof(stats), 0xff, stats_sz - sizeof(stats)); return sizeof(stats); } else { BCOPY(&stats, pstats, stats_sz); return stats_sz; } } # ifdef THREADS /* The _unsafe version assumes the caller holds the allocation lock. */ GC_API size_t GC_CALL GC_get_prof_stats_unsafe( struct GC_prof_stats_s *pstats, size_t stats_sz) { struct GC_prof_stats_s stats; if (stats_sz >= sizeof(stats)) { fill_prof_stats(pstats); if (stats_sz > sizeof(stats)) memset((char *)pstats + sizeof(stats), 0xff, stats_sz - sizeof(stats)); return sizeof(stats); } else { fill_prof_stats(&stats); BCOPY(&stats, pstats, stats_sz); return stats_sz; } } # endif /* THREADS */ #endif /* !GC_GET_HEAP_USAGE_NOT_NEEDED */ #if defined(GC_DARWIN_THREADS) || defined(GC_OPENBSD_UTHREADS) \ || defined(GC_WIN32_THREADS) || (defined(NACL) && defined(THREADS)) /* GC does not use signals to suspend and restart threads. */ GC_API void GC_CALL GC_set_suspend_signal(int sig GC_ATTR_UNUSED) { /* empty */ } GC_API void GC_CALL GC_set_thr_restart_signal(int sig GC_ATTR_UNUSED) { /* empty */ } GC_API int GC_CALL GC_get_suspend_signal(void) { return -1; } GC_API int GC_CALL GC_get_thr_restart_signal(void) { return -1; } #endif /* GC_DARWIN_THREADS || GC_WIN32_THREADS || ... */ #if !defined(_MAX_PATH) && (defined(MSWIN32) || defined(MSWINCE) \ || defined(CYGWIN32)) # define _MAX_PATH MAX_PATH #endif #ifdef GC_READ_ENV_FILE /* This works for Win32/WinCE for now. Really useful only for WinCE. */ STATIC char *GC_envfile_content = NULL; /* The content of the GC "env" file with CR and */ /* LF replaced to '\0'. NULL if the file is */ /* missing or empty. Otherwise, always ends */ /* with '\0'. */ STATIC unsigned GC_envfile_length = 0; /* Length of GC_envfile_content (if non-NULL). */ # ifndef GC_ENVFILE_MAXLEN # define GC_ENVFILE_MAXLEN 0x4000 # endif /* The routine initializes GC_envfile_content from the GC "env" file. */ STATIC void GC_envfile_init(void) { # if defined(MSWIN32) || defined(MSWINCE) || defined(CYGWIN32) HANDLE hFile; char *content; unsigned ofs; unsigned len; DWORD nBytesRead; TCHAR path[_MAX_PATH + 0x10]; /* buffer for path + ext */ len = (unsigned)GetModuleFileName(NULL /* hModule */, path, _MAX_PATH + 1); /* If GetModuleFileName() has failed then len is 0. */ if (len > 4 && path[len - 4] == (TCHAR)'.') { len -= 4; /* strip executable file extension */ } BCOPY(TEXT(".gc.env"), &path[len], sizeof(TEXT(".gc.env"))); hFile = CreateFile(path, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL /* lpSecurityAttributes */, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL /* hTemplateFile */); if (hFile == INVALID_HANDLE_VALUE) return; /* the file is absent or the operation is failed */ len = (unsigned)GetFileSize(hFile, NULL); if (len <= 1 || len >= GC_ENVFILE_MAXLEN) { CloseHandle(hFile); return; /* invalid file length - ignoring the file content */ } /* At this execution point, GC_setpagesize() and GC_init_win32() */ /* must already be called (for GET_MEM() to work correctly). */ content = (char *)GET_MEM(ROUNDUP_PAGESIZE_IF_MMAP(len + 1)); if (content == NULL) { CloseHandle(hFile); return; /* allocation failure */ } ofs = 0; nBytesRead = (DWORD)-1L; /* Last ReadFile() call should clear nBytesRead on success. */ while (ReadFile(hFile, content + ofs, len - ofs + 1, &nBytesRead, NULL /* lpOverlapped */) && nBytesRead != 0) { if ((ofs += nBytesRead) > len) break; } CloseHandle(hFile); if (ofs != len || nBytesRead != 0) return; /* read operation is failed - ignoring the file content */ content[ofs] = '\0'; while (ofs-- > 0) { if (content[ofs] == '\r' || content[ofs] == '\n') content[ofs] = '\0'; } GC_envfile_length = len + 1; GC_envfile_content = content; # endif } /* This routine scans GC_envfile_content for the specified */ /* environment variable (and returns its value if found). */ GC_INNER char * GC_envfile_getenv(const char *name) { char *p; char *end_of_content; unsigned namelen; # ifndef NO_GETENV p = getenv(name); /* try the standard getenv() first */ if (p != NULL) return *p != '\0' ? p : NULL; # endif p = GC_envfile_content; if (p == NULL) return NULL; /* "env" file is absent (or empty) */ namelen = strlen(name); if (namelen == 0) /* a sanity check */ return NULL; for (end_of_content = p + GC_envfile_length; p != end_of_content; p += strlen(p) + 1) { if (strncmp(p, name, namelen) == 0 && *(p += namelen) == '=') { p++; /* the match is found; skip '=' */ return *p != '\0' ? p : NULL; } /* If not matching then skip to the next line. */ } return NULL; /* no match found */ } #endif /* GC_READ_ENV_FILE */ GC_INNER GC_bool GC_is_initialized = FALSE; #if (defined(MSWIN32) || defined(MSWINCE)) && defined(THREADS) GC_INNER CRITICAL_SECTION GC_write_cs; #endif #ifndef DONT_USE_ATEXIT STATIC void GC_exit_check(void) { if (GC_find_leak) { GC_gcollect(); } } #endif #if defined(UNIX_LIKE) && !defined(NO_DEBUGGING) static void looping_handler(int sig) { GC_err_printf("Caught signal %d: looping in handler\n", sig); for (;;) { /* empty */ } } static GC_bool installed_looping_handler = FALSE; static void maybe_install_looping_handler(void) { /* Install looping handler before the write fault handler, so we */ /* handle write faults correctly. */ if (!installed_looping_handler && 0 != GETENV("GC_LOOP_ON_ABORT")) { GC_set_and_save_fault_handler(looping_handler); installed_looping_handler = TRUE; } } #else /* !UNIX_LIKE */ # define maybe_install_looping_handler() #endif #define GC_DEFAULT_STDOUT_FD 1 #define GC_DEFAULT_STDERR_FD 2 #if !defined(OS2) && !defined(MACOS) && !defined(GC_ANDROID_LOG) \ && !defined(MSWIN32) && !defined(MSWINCE) STATIC int GC_stdout = GC_DEFAULT_STDOUT_FD; STATIC int GC_stderr = GC_DEFAULT_STDERR_FD; STATIC int GC_log = GC_DEFAULT_STDERR_FD; GC_API void GC_CALL GC_set_log_fd(int fd) { GC_log = fd; } #endif STATIC word GC_parse_mem_size_arg(const char *str) { char *endptr; word result = 0; /* bad value */ char ch; if (*str != '\0') { result = (word)STRTOULL(str, &endptr, 10); ch = *endptr; if (ch != '\0') { if (*(endptr + 1) != '\0') return 0; /* Allow k, M or G suffix. */ switch (ch) { case 'K': case 'k': result <<= 10; break; case 'M': case 'm': result <<= 20; break; case 'G': case 'g': result <<= 30; break; default: result = 0; } } } return result; } #define GC_LOG_STD_NAME "gc.log" GC_API void GC_CALL GC_init(void) { /* LOCK(); -- no longer does anything this early. */ word initial_heap_sz; IF_CANCEL(int cancel_state;) if (EXPECT(GC_is_initialized, TRUE)) return; # ifdef REDIRECT_MALLOC { static GC_bool init_started = FALSE; if (init_started) ABORT("Redirected malloc() called during GC init"); init_started = TRUE; } # endif # ifdef GC_INITIAL_HEAP_SIZE initial_heap_sz = divHBLKSZ(GC_INITIAL_HEAP_SIZE); # else initial_heap_sz = (word)MINHINCR; # endif DISABLE_CANCEL(cancel_state); /* Note that although we are nominally called with the */ /* allocation lock held, the allocation lock is now */ /* only really acquired once a second thread is forked.*/ /* And the initialization code needs to run before */ /* then. Thus we really don't hold any locks, and can */ /* in fact safely initialize them here. */ # ifdef THREADS # ifndef GC_ALWAYS_MULTITHREADED GC_ASSERT(!GC_need_to_lock); # endif # ifdef SN_TARGET_PS3 { pthread_mutexattr_t mattr; if (0 != pthread_mutexattr_init(&mattr)) { ABORT("pthread_mutexattr_init failed"); } if (0 != pthread_mutex_init(&GC_allocate_ml, &mattr)) { ABORT("pthread_mutex_init failed"); } (void)pthread_mutexattr_destroy(&mattr); } # endif # endif /* THREADS */ # if defined(GC_WIN32_THREADS) && !defined(GC_PTHREADS) { # ifndef MSWINCE BOOL (WINAPI *pfn) (LPCRITICAL_SECTION, DWORD) = NULL; HMODULE hK32 = GetModuleHandle(TEXT("kernel32.dll")); if (hK32) pfn = (BOOL (WINAPI *) (LPCRITICAL_SECTION, DWORD)) GetProcAddress (hK32, "InitializeCriticalSectionAndSpinCount"); if (pfn) pfn(&GC_allocate_ml, 4000); else # endif /* !MSWINCE */ /* else */ InitializeCriticalSection (&GC_allocate_ml); } # endif /* GC_WIN32_THREADS */ # if (defined(MSWIN32) || defined(MSWINCE)) && defined(THREADS) InitializeCriticalSection(&GC_write_cs); # endif GC_setpagesize(); # ifdef MSWIN32 GC_init_win32(); # endif # ifdef GC_READ_ENV_FILE GC_envfile_init(); # endif # ifndef SMALL_CONFIG # ifdef GC_PRINT_VERBOSE_STATS /* This is useful for debugging and profiling on platforms with */ /* missing getenv() (like WinCE). */ GC_print_stats = VERBOSE; # else if (0 != GETENV("GC_PRINT_VERBOSE_STATS")) { GC_print_stats = VERBOSE; } else if (0 != GETENV("GC_PRINT_STATS")) { GC_print_stats = 1; } # endif # if (defined(UNIX_LIKE) && !defined(GC_ANDROID_LOG)) \ || defined(CYGWIN32) || defined(SYMBIAN) { char * file_name = GETENV("GC_LOG_FILE"); # ifdef GC_LOG_TO_FILE_ALWAYS if (NULL == file_name) file_name = GC_LOG_STD_NAME; # else if (0 != file_name) # endif { int log_d = open(file_name, O_CREAT|O_WRONLY|O_APPEND, 0666); if (log_d < 0) { GC_err_printf("Failed to open %s as log file\n", file_name); } else { char *str; GC_log = log_d; str = GETENV("GC_ONLY_LOG_TO_FILE"); # ifdef GC_ONLY_LOG_TO_FILE /* The similar environment variable set to "0" */ /* overrides the effect of the macro defined. */ if (str != NULL && *str == '0' && *(str + 1) == '\0') # else /* Otherwise setting the environment variable */ /* to anything other than "0" will prevent from */ /* redirecting stdout/err to the log file. */ if (str == NULL || (*str == '0' && *(str + 1) == '\0')) # endif { GC_stdout = log_d; GC_stderr = log_d; } } } } # endif # endif /* !SMALL_CONFIG */ # if !defined(NO_DEBUGGING) && !defined(GC_DUMP_REGULARLY) if (0 != GETENV("GC_DUMP_REGULARLY")) { GC_dump_regularly = TRUE; } # endif # ifdef KEEP_BACK_PTRS { char * backtraces_string = GETENV("GC_BACKTRACES"); if (0 != backtraces_string) { GC_backtraces = atol(backtraces_string); if (backtraces_string[0] == '\0') GC_backtraces = 1; } } # endif if (0 != GETENV("GC_FIND_LEAK")) { GC_find_leak = 1; } # ifndef SHORT_DBG_HDRS if (0 != GETENV("GC_FINDLEAK_DELAY_FREE")) { GC_findleak_delay_free = TRUE; } # endif if (0 != GETENV("GC_ALL_INTERIOR_POINTERS")) { GC_all_interior_pointers = 1; } if (0 != GETENV("GC_DONT_GC")) { GC_dont_gc = 1; } if (0 != GETENV("GC_PRINT_BACK_HEIGHT")) { GC_print_back_height = TRUE; } if (0 != GETENV("GC_NO_BLACKLIST_WARNING")) { GC_large_alloc_warn_interval = LONG_MAX; } { char * addr_string = GETENV("GC_TRACE"); if (0 != addr_string) { # ifndef ENABLE_TRACE WARN("Tracing not enabled: Ignoring GC_TRACE value\n", 0); # else word addr = (word)STRTOULL(addr_string, NULL, 16); if (addr < 0x1000) WARN("Unlikely trace address: %p\n", addr); GC_trace_addr = (ptr_t)addr; # endif } } # ifdef GC_COLLECT_AT_MALLOC { char * string = GETENV("GC_COLLECT_AT_MALLOC"); if (0 != string) { size_t min_lb = (size_t)STRTOULL(string, NULL, 10); if (min_lb > 0) GC_dbg_collect_at_malloc_min_lb = min_lb; } } # endif # ifndef GC_DISABLE_INCREMENTAL { char * time_limit_string = GETENV("GC_PAUSE_TIME_TARGET"); if (0 != time_limit_string) { long time_limit = atol(time_limit_string); if (time_limit < 5) { WARN("GC_PAUSE_TIME_TARGET environment variable value too small " "or bad syntax: Ignoring\n", 0); } else { GC_time_limit = time_limit; } } } # endif # ifndef SMALL_CONFIG { char * full_freq_string = GETENV("GC_FULL_FREQUENCY"); if (full_freq_string != NULL) { int full_freq = atoi(full_freq_string); if (full_freq > 0) GC_full_freq = full_freq; } } # endif { char * interval_string = GETENV("GC_LARGE_ALLOC_WARN_INTERVAL"); if (0 != interval_string) { long interval = atol(interval_string); if (interval <= 0) { WARN("GC_LARGE_ALLOC_WARN_INTERVAL environment variable has " "bad value: Ignoring\n", 0); } else { GC_large_alloc_warn_interval = interval; } } } { char * space_divisor_string = GETENV("GC_FREE_SPACE_DIVISOR"); if (space_divisor_string != NULL) { int space_divisor = atoi(space_divisor_string); if (space_divisor > 0) GC_free_space_divisor = (GC_word)space_divisor; } } # ifdef USE_MUNMAP { char * string = GETENV("GC_UNMAP_THRESHOLD"); if (string != NULL) { if (*string == '0' && *(string + 1) == '\0') { /* "0" is used to disable unmapping. */ GC_unmap_threshold = 0; } else { int unmap_threshold = atoi(string); if (unmap_threshold > 0) GC_unmap_threshold = unmap_threshold; } } } { char * string = GETENV("GC_FORCE_UNMAP_ON_GCOLLECT"); if (string != NULL) { if (*string == '0' && *(string + 1) == '\0') { /* "0" is used to turn off the mode. */ GC_force_unmap_on_gcollect = FALSE; } else { GC_force_unmap_on_gcollect = TRUE; } } } { char * string = GETENV("GC_USE_ENTIRE_HEAP"); if (string != NULL) { if (*string == '0' && *(string + 1) == '\0') { /* "0" is used to turn off the mode. */ GC_use_entire_heap = FALSE; } else { GC_use_entire_heap = TRUE; } } } # endif maybe_install_looping_handler(); /* Adjust normal object descriptor for extra allocation. */ if (ALIGNMENT > GC_DS_TAGS && EXTRA_BYTES != 0) { GC_obj_kinds[NORMAL].ok_descriptor = ((word)(-ALIGNMENT) | GC_DS_LENGTH); } GC_exclude_static_roots_inner(beginGC_arrays, endGC_arrays); GC_exclude_static_roots_inner(beginGC_obj_kinds, endGC_obj_kinds); # ifdef SEPARATE_GLOBALS GC_exclude_static_roots_inner(beginGC_objfreelist, endGC_objfreelist); GC_exclude_static_roots_inner(beginGC_aobjfreelist, endGC_aobjfreelist); # endif # if defined(USE_PROC_FOR_LIBRARIES) && defined(GC_LINUX_THREADS) WARN("USE_PROC_FOR_LIBRARIES + GC_LINUX_THREADS performs poorly.\n", 0); /* If thread stacks are cached, they tend to be scanned in */ /* entirety as part of the root set. This wil grow them to */ /* maximum size, and is generally not desirable. */ # endif # if defined(SEARCH_FOR_DATA_START) GC_init_linux_data_start(); # endif # if defined(NETBSD) && defined(__ELF__) GC_init_netbsd_elf(); # endif # if !defined(THREADS) || defined(GC_PTHREADS) \ || defined(GC_WIN32_THREADS) || defined(GC_SOLARIS_THREADS) if (GC_stackbottom == 0) { GC_stackbottom = GC_get_main_stack_base(); # if (defined(LINUX) || defined(HPUX)) && defined(IA64) GC_register_stackbottom = GC_get_register_stack_base(); # endif } else { # if (defined(LINUX) || defined(HPUX)) && defined(IA64) if (GC_register_stackbottom == 0) { WARN("GC_register_stackbottom should be set with GC_stackbottom\n", 0); /* The following may fail, since we may rely on */ /* alignment properties that may not hold with a user set */ /* GC_stackbottom. */ GC_register_stackbottom = GC_get_register_stack_base(); } # endif } # endif GC_STATIC_ASSERT(sizeof (ptr_t) == sizeof(word)); GC_STATIC_ASSERT(sizeof (signed_word) == sizeof(word)); GC_STATIC_ASSERT(sizeof (struct hblk) == HBLKSIZE); # ifndef THREADS GC_ASSERT(!((word)GC_stackbottom HOTTER_THAN (word)GC_approx_sp())); # endif # if !defined(_AUX_SOURCE) || defined(__GNUC__) GC_STATIC_ASSERT((word)(-1) > (word)0); /* word should be unsigned */ # endif /* We no longer check for ((void*)(-1) > NULL) since all pointers */ /* are explicitly cast to word in every less-greater comparison. */ GC_STATIC_ASSERT((signed_word)(-1) < (signed_word)0); # ifndef GC_DISABLE_INCREMENTAL if (GC_incremental || 0 != GETENV("GC_ENABLE_INCREMENTAL")) { /* For GWW_VDB on Win32, this needs to happen before any */ /* heap memory is allocated. */ GC_dirty_init(); GC_ASSERT(GC_bytes_allocd == 0); GC_incremental = TRUE; } # endif /* Add initial guess of root sets. Do this first, since sbrk(0) */ /* might be used. */ if (GC_REGISTER_MAIN_STATIC_DATA()) GC_register_data_segments(); GC_init_headers(); GC_bl_init(); GC_mark_init(); { char * sz_str = GETENV("GC_INITIAL_HEAP_SIZE"); if (sz_str != NULL) { initial_heap_sz = GC_parse_mem_size_arg(sz_str); if (initial_heap_sz <= MINHINCR * HBLKSIZE) { WARN("Bad initial heap size %s - ignoring it.\n", sz_str); } initial_heap_sz = divHBLKSZ(initial_heap_sz); } } { char * sz_str = GETENV("GC_MAXIMUM_HEAP_SIZE"); if (sz_str != NULL) { word max_heap_sz = GC_parse_mem_size_arg(sz_str); if (max_heap_sz < initial_heap_sz * HBLKSIZE) { WARN("Bad maximum heap size %s - ignoring it.\n", sz_str); } if (0 == GC_max_retries) GC_max_retries = 2; GC_set_max_heap_size(max_heap_sz); } } if (!GC_expand_hp_inner(initial_heap_sz)) { GC_err_printf("Can't start up: not enough memory\n"); EXIT(); } else { GC_requested_heapsize += initial_heap_sz; } if (GC_all_interior_pointers) GC_initialize_offsets(); GC_register_displacement_inner(0L); # if defined(GC_LINUX_THREADS) && defined(REDIRECT_MALLOC) if (!GC_all_interior_pointers) { /* TLS ABI uses pointer-sized offsets for dtv. */ GC_register_displacement_inner(sizeof(void *)); } # endif GC_init_size_map(); # ifdef PCR if (PCR_IL_Lock(PCR_Bool_false, PCR_allSigsBlocked, PCR_waitForever) != PCR_ERes_okay) { ABORT("Can't lock load state"); } else if (PCR_IL_Unlock() != PCR_ERes_okay) { ABORT("Can't unlock load state"); } PCR_IL_Unlock(); GC_pcr_install(); # endif GC_is_initialized = TRUE; # if defined(GC_PTHREADS) || defined(GC_WIN32_THREADS) GC_thr_init(); # endif COND_DUMP; /* Get black list set up and/or incremental GC started */ if (!GC_dont_precollect || GC_incremental) GC_gcollect_inner(); # ifdef STUBBORN_ALLOC GC_stubborn_init(); # endif # ifndef DONT_USE_ATEXIT if (GC_find_leak) { /* This is to give us at least one chance to detect leaks. */ /* This may report some very benign leaks, but ... */ atexit(GC_exit_check); } # endif /* The rest of this again assumes we don't really hold */ /* the allocation lock. */ # if defined(PARALLEL_MARK) || defined(THREAD_LOCAL_ALLOC) \ || (defined(GC_ALWAYS_MULTITHREADED) && defined(GC_WIN32_THREADS) \ && !defined(GC_NO_THREADS_DISCOVERY)) /* Make sure marker threads are started and thread local */ /* allocation is initialized, in case we didn't get */ /* called from GC_init_parallel. */ GC_init_parallel(); # endif /* PARALLEL_MARK || THREAD_LOCAL_ALLOC */ # if defined(DYNAMIC_LOADING) && defined(DARWIN) /* This must be called WITHOUT the allocation lock held */ /* and before any threads are created. */ GC_init_dyld(); # endif RESTORE_CANCEL(cancel_state); } GC_API void GC_CALL GC_enable_incremental(void) { # if !defined(GC_DISABLE_INCREMENTAL) && !defined(KEEP_BACK_PTRS) DCL_LOCK_STATE; /* If we are keeping back pointers, the GC itself dirties all */ /* pages on which objects have been marked, making */ /* incremental GC pointless. */ if (!GC_find_leak && 0 == GETENV("GC_DISABLE_INCREMENTAL")) { LOCK(); if (!GC_incremental) { GC_setpagesize(); /* if (GC_no_win32_dlls) goto out; Should be win32S test? */ maybe_install_looping_handler(); /* Before write fault handler! */ GC_incremental = TRUE; if (!GC_is_initialized) { GC_init(); } else { GC_dirty_init(); } if (GC_dirty_maintained && !GC_dont_gc) { /* Can't easily do it if GC_dont_gc. */ if (GC_bytes_allocd > 0) { /* There may be unmarked reachable objects. */ GC_gcollect_inner(); } /* else we're OK in assuming everything's */ /* clean since nothing can point to an */ /* unmarked object. */ GC_read_dirty(); } } UNLOCK(); return; } # endif GC_init(); } #if defined(THREADS) && (!defined(PARALLEL_MARK) || !defined(CAN_HANDLE_FORK)) GC_API void GC_CALL GC_start_mark_threads(void) { /* No action since parallel markers are disabled (or no POSIX fork). */ GC_ASSERT(I_DONT_HOLD_LOCK()); } #endif #if defined(MSWIN32) || defined(MSWINCE) # if defined(_MSC_VER) && defined(_DEBUG) && !defined(MSWINCE) # include # endif STATIC HANDLE GC_log = 0; void GC_deinit(void) { # ifdef THREADS if (GC_is_initialized) { DeleteCriticalSection(&GC_write_cs); } # endif } # ifdef THREADS # if defined(PARALLEL_MARK) && !defined(GC_ALWAYS_MULTITHREADED) # define IF_NEED_TO_LOCK(x) if (GC_parallel || GC_need_to_lock) x # else # define IF_NEED_TO_LOCK(x) if (GC_need_to_lock) x # endif # else # define IF_NEED_TO_LOCK(x) # endif /* !THREADS */ STATIC HANDLE GC_CreateLogFile(void) { HANDLE hFile; TCHAR *logPath; BOOL appendToFile = FALSE; # if !defined(NO_GETENV_WIN32) || !defined(OLD_WIN32_LOG_FILE) TCHAR pathBuf[_MAX_PATH + 0x10]; /* buffer for path + ext */ logPath = pathBuf; # endif /* Use GetEnvironmentVariable instead of GETENV() for unicode support. */ # ifndef NO_GETENV_WIN32 if (GetEnvironmentVariable(TEXT("GC_LOG_FILE"), pathBuf, _MAX_PATH + 1) - 1U < (DWORD)_MAX_PATH) { appendToFile = TRUE; } else # endif /* else */ { /* Env var not found or its value too long. */ # ifdef OLD_WIN32_LOG_FILE logPath = TEXT(GC_LOG_STD_NAME); # else int len = (int)GetModuleFileName(NULL /* hModule */, pathBuf, _MAX_PATH + 1); /* If GetModuleFileName() has failed then len is 0. */ if (len > 4 && pathBuf[len - 4] == (TCHAR)'.') { len -= 4; /* strip executable file extension */ } BCOPY(TEXT(".") TEXT(GC_LOG_STD_NAME), &pathBuf[len], sizeof(TEXT(".") TEXT(GC_LOG_STD_NAME))); # endif } hFile = CreateFile(logPath, GENERIC_WRITE, FILE_SHARE_READ, NULL /* lpSecurityAttributes */, appendToFile ? OPEN_ALWAYS : CREATE_ALWAYS, GC_print_stats == VERBOSE ? FILE_ATTRIBUTE_NORMAL : /* immediately flush writes unless very verbose */ FILE_ATTRIBUTE_NORMAL | FILE_FLAG_WRITE_THROUGH, NULL /* hTemplateFile */); # ifndef NO_GETENV_WIN32 if (appendToFile && hFile != INVALID_HANDLE_VALUE) { LONG posHigh = 0; (void)SetFilePointer(hFile, 0, &posHigh, FILE_END); /* Seek to file end (ignoring any error) */ } # endif return hFile; } STATIC int GC_write(const char *buf, size_t len) { BOOL res; DWORD written; # if defined(THREADS) && defined(GC_ASSERTIONS) static GC_bool inside_write = FALSE; /* to prevent infinite recursion at abort. */ if (inside_write) return -1; # endif if (len == 0) return 0; IF_NEED_TO_LOCK(EnterCriticalSection(&GC_write_cs)); # if defined(THREADS) && defined(GC_ASSERTIONS) if (GC_write_disabled) { inside_write = TRUE; ABORT("Assertion failure: GC_write called with write_disabled"); } # endif if (GC_log == 0) { GC_log = GC_CreateLogFile(); } if (GC_log == INVALID_HANDLE_VALUE) { IF_NEED_TO_LOCK(LeaveCriticalSection(&GC_write_cs)); # ifdef NO_DEBUGGING /* Ignore open log failure (e.g., it might be caused by */ /* read-only folder of the client application). */ return 0; # else return -1; # endif } res = WriteFile(GC_log, buf, (DWORD)len, &written, NULL); # if defined(_MSC_VER) && defined(_DEBUG) # ifdef MSWINCE /* There is no CrtDbgReport() in WinCE */ { WCHAR wbuf[1024]; /* Always use Unicode variant of OutputDebugString() */ wbuf[MultiByteToWideChar(CP_ACP, 0 /* dwFlags */, buf, len, wbuf, sizeof(wbuf) / sizeof(wbuf[0]) - 1)] = 0; OutputDebugStringW(wbuf); } # else _CrtDbgReport(_CRT_WARN, NULL, 0, NULL, "%.*s", len, buf); # endif # endif IF_NEED_TO_LOCK(LeaveCriticalSection(&GC_write_cs)); return res ? (int)written : -1; } /* FIXME: This is pretty ugly ... */ # define WRITE(f, buf, len) GC_write(buf, len) #elif defined(OS2) || defined(MACOS) STATIC FILE * GC_stdout = NULL; STATIC FILE * GC_stderr = NULL; STATIC FILE * GC_log = NULL; /* Initialize GC_log (and the friends) passed to GC_write(). */ STATIC void GC_set_files(void) { if (GC_stdout == NULL) { GC_stdout = stdout; } if (GC_stderr == NULL) { GC_stderr = stderr; } if (GC_log == NULL) { GC_log = stderr; } } GC_INLINE int GC_write(FILE *f, const char *buf, size_t len) { int res = fwrite(buf, 1, len, f); fflush(f); return res; } # define WRITE(f, buf, len) (GC_set_files(), GC_write(f, buf, len)) #elif defined(GC_ANDROID_LOG) # include # ifndef GC_ANDROID_LOG_TAG # define GC_ANDROID_LOG_TAG "BDWGC" # endif # define GC_stdout ANDROID_LOG_DEBUG # define GC_stderr ANDROID_LOG_ERROR # define GC_log GC_stdout # define WRITE(level, buf, unused_len) \ __android_log_write(level, GC_ANDROID_LOG_TAG, buf) #else # if !defined(AMIGA) && !defined(__CC_ARM) # include # endif STATIC int GC_write(int fd, const char *buf, size_t len) { # if defined(ECOS) || defined(NOSYS) # ifdef ECOS /* FIXME: This seems to be defined nowhere at present. */ /* _Jv_diag_write(buf, len); */ # else /* No writing. */ # endif return len; # else int bytes_written = 0; int result; IF_CANCEL(int cancel_state;) DISABLE_CANCEL(cancel_state); while ((size_t)bytes_written < len) { # ifdef GC_SOLARIS_THREADS result = syscall(SYS_write, fd, buf + bytes_written, len - bytes_written); # else result = write(fd, buf + bytes_written, len - bytes_written); # endif if (-1 == result) { RESTORE_CANCEL(cancel_state); return(result); } bytes_written += result; } RESTORE_CANCEL(cancel_state); return(bytes_written); # endif } # define WRITE(f, buf, len) GC_write(f, buf, len) #endif /* !MSWIN32 && !OS2 && !MACOS && !GC_ANDROID_LOG */ #define BUFSZ 1024 #if defined(DJGPP) || defined(__STRICT_ANSI__) /* vsnprintf is missing in DJGPP (v2.0.3) */ # define GC_VSNPRINTF(buf, bufsz, format, args) vsprintf(buf, format, args) #elif defined(_MSC_VER) # ifdef MSWINCE /* _vsnprintf is deprecated in WinCE */ # define GC_VSNPRINTF StringCchVPrintfA # else # define GC_VSNPRINTF _vsnprintf # endif #else # define GC_VSNPRINTF vsnprintf #endif /* A version of printf that is unlikely to call malloc, and is thus safer */ /* to call from the collector in case malloc has been bound to GC_malloc. */ /* Floating point arguments and formats should be avoided, since FP */ /* conversion is more likely to allocate memory. */ /* Assumes that no more than BUFSZ-1 characters are written at once. */ #define GC_PRINTF_FILLBUF(buf, format) \ do { \ va_list args; \ va_start(args, format); \ (buf)[sizeof(buf) - 1] = 0x15; /* guard */ \ (void)GC_VSNPRINTF(buf, sizeof(buf) - 1, format, args); \ va_end(args); \ if ((buf)[sizeof(buf) - 1] != 0x15) \ ABORT("GC_printf clobbered stack"); \ } while (0) void GC_printf(const char *format, ...) { char buf[BUFSZ + 1]; if (!GC_quiet) { GC_PRINTF_FILLBUF(buf, format); if (WRITE(GC_stdout, buf, strlen(buf)) < 0) ABORT("write to stdout failed"); } } void GC_err_printf(const char *format, ...) { char buf[BUFSZ + 1]; GC_PRINTF_FILLBUF(buf, format); GC_err_puts(buf); } void GC_log_printf(const char *format, ...) { char buf[BUFSZ + 1]; GC_PRINTF_FILLBUF(buf, format); if (WRITE(GC_log, buf, strlen(buf)) < 0) ABORT("write to GC log failed"); } #ifndef GC_ANDROID_LOG # define GC_warn_printf GC_err_printf #else GC_INNER void GC_info_log_printf(const char *format, ...) { char buf[BUFSZ + 1]; GC_PRINTF_FILLBUF(buf, format); (void)WRITE(ANDROID_LOG_INFO, buf, 0 /* unused */); } GC_INNER void GC_verbose_log_printf(const char *format, ...) { char buf[BUFSZ + 1]; GC_PRINTF_FILLBUF(buf, format); (void)WRITE(ANDROID_LOG_VERBOSE, buf, 0); /* ignore write errors */ } STATIC void GC_warn_printf(const char *format, ...) { char buf[BUFSZ + 1]; GC_PRINTF_FILLBUF(buf, format); (void)WRITE(ANDROID_LOG_WARN, buf, 0); } #endif /* GC_ANDROID_LOG */ void GC_err_puts(const char *s) { (void)WRITE(GC_stderr, s, strlen(s)); /* ignore errors */ } STATIC void GC_CALLBACK GC_default_warn_proc(char *msg, GC_word arg) { /* TODO: Add assertion on arg comply with msg (format). */ GC_warn_printf(msg, arg); } GC_INNER GC_warn_proc GC_current_warn_proc = GC_default_warn_proc; /* This is recommended for production code (release). */ GC_API void GC_CALLBACK GC_ignore_warn_proc(char *msg, GC_word arg) { if (GC_print_stats) { /* Don't ignore warnings if stats printing is on. */ GC_default_warn_proc(msg, arg); } } GC_API void GC_CALL GC_set_warn_proc(GC_warn_proc p) { DCL_LOCK_STATE; GC_ASSERT(p != 0); # ifdef GC_WIN32_THREADS # ifdef CYGWIN32 /* Need explicit GC_INIT call */ GC_ASSERT(GC_is_initialized); # else if (!GC_is_initialized) GC_init(); # endif # endif LOCK(); GC_current_warn_proc = p; UNLOCK(); } GC_API GC_warn_proc GC_CALL GC_get_warn_proc(void) { GC_warn_proc result; DCL_LOCK_STATE; LOCK(); result = GC_current_warn_proc; UNLOCK(); return(result); } #if !defined(PCR) && !defined(SMALL_CONFIG) /* Print (or display) a message before abnormal exit (including */ /* abort). Invoked from ABORT(msg) macro (there msg is non-NULL) */ /* and from EXIT() macro (msg is NULL in that case). */ STATIC void GC_CALLBACK GC_default_on_abort(const char *msg) { GC_find_leak = FALSE; /* disable at-exit GC_gcollect() */ if (msg != NULL) { # if defined(MSWIN32) # ifndef DONT_USE_USER32_DLL /* Use static binding to "user32.dll". */ (void)MessageBoxA(NULL, msg, "Fatal error in GC", MB_ICONERROR | MB_OK); # else /* This simplifies linking - resolve "MessageBoxA" at run-time. */ HINSTANCE hU32 = LoadLibrary(TEXT("user32.dll")); if (hU32) { FARPROC pfn = GetProcAddress(hU32, "MessageBoxA"); if (pfn) (void)(*(int (WINAPI *)(HWND, LPCSTR, LPCSTR, UINT))pfn)( NULL /* hWnd */, msg, "Fatal error in GC", MB_ICONERROR | MB_OK); (void)FreeLibrary(hU32); } # endif /* Also duplicate msg to GC log file. */ # endif # ifndef GC_ANDROID_LOG /* Avoid calling GC_err_printf() here, as GC_on_abort() could be */ /* called from it. Note 1: this is not an atomic output. */ /* Note 2: possible write errors are ignored. */ # if defined(THREADS) && defined(GC_ASSERTIONS) \ && (defined(MSWIN32) || defined(MSWINCE)) if (!GC_write_disabled) # endif { if (WRITE(GC_stderr, (void *)msg, strlen(msg)) >= 0) (void)WRITE(GC_stderr, (void *)("\n"), 1); } # else __android_log_assert("*" /* cond */, GC_ANDROID_LOG_TAG, "%s\n", msg); # endif } # if !defined(NO_DEBUGGING) && !defined(GC_ANDROID_LOG) if (GETENV("GC_LOOP_ON_ABORT") != NULL) { /* In many cases it's easier to debug a running process. */ /* It's arguably nicer to sleep, but that makes it harder */ /* to look at the thread if the debugger doesn't know much */ /* about threads. */ for(;;) { /* Empty */ } } # endif } GC_abort_func GC_on_abort = GC_default_on_abort; GC_API void GC_CALL GC_set_abort_func(GC_abort_func fn) { DCL_LOCK_STATE; GC_ASSERT(fn != 0); LOCK(); GC_on_abort = fn; UNLOCK(); } GC_API GC_abort_func GC_CALL GC_get_abort_func(void) { GC_abort_func fn; DCL_LOCK_STATE; LOCK(); fn = GC_on_abort; UNLOCK(); return fn; } #endif /* !SMALL_CONFIG */ GC_API void GC_CALL GC_enable(void) { DCL_LOCK_STATE; LOCK(); GC_ASSERT(GC_dont_gc != 0); /* ensure no counter underflow */ GC_dont_gc--; UNLOCK(); } GC_API void GC_CALL GC_disable(void) { DCL_LOCK_STATE; LOCK(); GC_dont_gc++; UNLOCK(); } GC_API int GC_CALL GC_is_disabled(void) { return GC_dont_gc != 0; } /* Helper procedures for new kind creation. */ GC_API void ** GC_CALL GC_new_free_list_inner(void) { void *result = GC_INTERNAL_MALLOC((MAXOBJGRANULES+1)*sizeof(ptr_t), PTRFREE); if (result == 0) ABORT("Failed to allocate freelist for new kind"); BZERO(result, (MAXOBJGRANULES+1)*sizeof(ptr_t)); return result; } GC_API void ** GC_CALL GC_new_free_list(void) { void *result; DCL_LOCK_STATE; LOCK(); result = GC_new_free_list_inner(); UNLOCK(); return result; } GC_API unsigned GC_CALL GC_new_kind_inner(void **fl, GC_word descr, int adjust, int clear) { unsigned result = GC_n_kinds; if (result < MAXOBJKINDS) { GC_n_kinds++; GC_obj_kinds[result].ok_freelist = fl; GC_obj_kinds[result].ok_reclaim_list = 0; GC_obj_kinds[result].ok_descriptor = descr; GC_obj_kinds[result].ok_relocate_descr = adjust; GC_obj_kinds[result].ok_init = (GC_bool)clear; # ifdef ENABLE_DISCLAIM GC_obj_kinds[result].ok_mark_unconditionally = FALSE; GC_obj_kinds[result].ok_disclaim_proc = 0; # endif } else { ABORT("Too many kinds"); } return result; } GC_API unsigned GC_CALL GC_new_kind(void **fl, GC_word descr, int adjust, int clear) { unsigned result; DCL_LOCK_STATE; LOCK(); result = GC_new_kind_inner(fl, descr, adjust, clear); UNLOCK(); return result; } GC_API unsigned GC_CALL GC_new_proc_inner(GC_mark_proc proc) { unsigned result = GC_n_mark_procs; if (result < MAX_MARK_PROCS) { GC_n_mark_procs++; GC_mark_procs[result] = proc; } else { ABORT("Too many mark procedures"); } return result; } GC_API unsigned GC_CALL GC_new_proc(GC_mark_proc proc) { unsigned result; DCL_LOCK_STATE; LOCK(); result = GC_new_proc_inner(proc); UNLOCK(); return result; } GC_API void * GC_CALL GC_call_with_alloc_lock(GC_fn_type fn, void *client_data) { void * result; DCL_LOCK_STATE; # ifdef THREADS LOCK(); # endif result = (*fn)(client_data); # ifdef THREADS UNLOCK(); # endif return(result); } GC_API void * GC_CALL GC_call_with_stack_base(GC_stack_base_func fn, void *arg) { struct GC_stack_base base; void *result; base.mem_base = (void *)&base; # ifdef IA64 base.reg_base = (void *)GC_save_regs_in_stack(); /* Unnecessarily flushes register stack, */ /* but that probably doesn't hurt. */ # endif result = fn(&base, arg); /* Strongly discourage the compiler from treating the above */ /* as a tail call. */ GC_noop1((word)(&base)); return result; } #ifndef THREADS GC_INNER ptr_t GC_blocked_sp = NULL; /* NULL value means we are not inside GC_do_blocking() call. */ # ifdef IA64 STATIC ptr_t GC_blocked_register_sp = NULL; # endif GC_INNER struct GC_traced_stack_sect_s *GC_traced_stack_sect = NULL; /* This is nearly the same as in win32_threads.c */ GC_API void * GC_CALL GC_call_with_gc_active(GC_fn_type fn, void * client_data) { struct GC_traced_stack_sect_s stacksect; GC_ASSERT(GC_is_initialized); /* Adjust our stack base value (this could happen if */ /* GC_get_main_stack_base() is unimplemented or broken for */ /* the platform). */ if ((word)GC_stackbottom HOTTER_THAN (word)(&stacksect)) GC_stackbottom = (ptr_t)(&stacksect); if (GC_blocked_sp == NULL) { /* We are not inside GC_do_blocking() - do nothing more. */ client_data = fn(client_data); /* Prevent treating the above as a tail call. */ GC_noop1((word)(&stacksect)); return client_data; /* result */ } /* Setup new "stack section". */ stacksect.saved_stack_ptr = GC_blocked_sp; # ifdef IA64 /* This is the same as in GC_call_with_stack_base(). */ stacksect.backing_store_end = GC_save_regs_in_stack(); /* Unnecessarily flushes register stack, */ /* but that probably doesn't hurt. */ stacksect.saved_backing_store_ptr = GC_blocked_register_sp; # endif stacksect.prev = GC_traced_stack_sect; GC_blocked_sp = NULL; GC_traced_stack_sect = &stacksect; client_data = fn(client_data); GC_ASSERT(GC_blocked_sp == NULL); GC_ASSERT(GC_traced_stack_sect == &stacksect); /* Restore original "stack section". */ GC_traced_stack_sect = stacksect.prev; # ifdef IA64 GC_blocked_register_sp = stacksect.saved_backing_store_ptr; # endif GC_blocked_sp = stacksect.saved_stack_ptr; return client_data; /* result */ } /* This is nearly the same as in win32_threads.c */ STATIC void GC_do_blocking_inner(ptr_t data, void * context GC_ATTR_UNUSED) { struct blocking_data * d = (struct blocking_data *) data; GC_ASSERT(GC_is_initialized); GC_ASSERT(GC_blocked_sp == NULL); # ifdef SPARC GC_blocked_sp = GC_save_regs_in_stack(); # else GC_blocked_sp = (ptr_t) &d; /* save approx. sp */ # endif # ifdef IA64 GC_blocked_register_sp = GC_save_regs_in_stack(); # endif d -> client_data = (d -> fn)(d -> client_data); # ifdef SPARC GC_ASSERT(GC_blocked_sp != NULL); # else GC_ASSERT(GC_blocked_sp == (ptr_t) &d); # endif GC_blocked_sp = NULL; } #endif /* !THREADS */ /* Wrapper for functions that are likely to block (or, at least, do not */ /* allocate garbage collected memory and/or manipulate pointers to the */ /* garbage collected heap) for an appreciable length of time. */ /* In the single threaded case, GC_do_blocking() (together */ /* with GC_call_with_gc_active()) might be used to make stack scanning */ /* more precise (i.e. scan only stack frames of functions that allocate */ /* garbage collected memory and/or manipulate pointers to the garbage */ /* collected heap). */ GC_API void * GC_CALL GC_do_blocking(GC_fn_type fn, void * client_data) { struct blocking_data my_data; my_data.fn = fn; my_data.client_data = client_data; GC_with_callee_saves_pushed(GC_do_blocking_inner, (ptr_t)(&my_data)); return my_data.client_data; /* result */ } #if !defined(NO_DEBUGGING) GC_API void GC_CALL GC_dump(void) { GC_printf("***Static roots:\n"); GC_print_static_roots(); GC_printf("\n***Heap sections:\n"); GC_print_heap_sects(); GC_printf("\n***Free blocks:\n"); GC_print_hblkfreelist(); GC_printf("\n***Blocks in use:\n"); GC_print_block_list(); } #endif /* !NO_DEBUGGING */ /* Getter functions for the public Read-only variables. */ /* GC_get_gc_no() is unsynchronized and should be typically called */ /* inside the context of GC_call_with_alloc_lock() to prevent data */ /* races (on multiprocessors). */ GC_API GC_word GC_CALL GC_get_gc_no(void) { return GC_gc_no; } #ifdef THREADS GC_API int GC_CALL GC_get_parallel(void) { /* GC_parallel is initialized at start-up. */ return GC_parallel; } #endif /* Setter and getter functions for the public R/W function variables. */ /* These functions are synchronized (like GC_set_warn_proc() and */ /* GC_get_warn_proc()). */ GC_API void GC_CALL GC_set_oom_fn(GC_oom_func fn) { GC_ASSERT(fn != 0); DCL_LOCK_STATE; LOCK(); GC_oom_fn = fn; UNLOCK(); } GC_API GC_oom_func GC_CALL GC_get_oom_fn(void) { GC_oom_func fn; DCL_LOCK_STATE; LOCK(); fn = GC_oom_fn; UNLOCK(); return fn; } GC_API void GC_CALL GC_set_on_heap_resize(GC_on_heap_resize_proc fn) { /* fn may be 0 (means no event notifier). */ DCL_LOCK_STATE; LOCK(); GC_on_heap_resize = fn; UNLOCK(); } GC_API GC_on_heap_resize_proc GC_CALL GC_get_on_heap_resize(void) { GC_on_heap_resize_proc fn; DCL_LOCK_STATE; LOCK(); fn = GC_on_heap_resize; UNLOCK(); return fn; } GC_API void GC_CALL GC_set_finalizer_notifier(GC_finalizer_notifier_proc fn) { /* fn may be 0 (means no finalizer notifier). */ DCL_LOCK_STATE; LOCK(); GC_finalizer_notifier = fn; UNLOCK(); } GC_API GC_finalizer_notifier_proc GC_CALL GC_get_finalizer_notifier(void) { GC_finalizer_notifier_proc fn; DCL_LOCK_STATE; LOCK(); fn = GC_finalizer_notifier; UNLOCK(); return fn; } /* Setter and getter functions for the public numeric R/W variables. */ /* It is safe to call these functions even before GC_INIT(). */ /* These functions are unsynchronized and should be typically called */ /* inside the context of GC_call_with_alloc_lock() (if called after */ /* GC_INIT()) to prevent data races (unless it is guaranteed the */ /* collector is not multi-threaded at that execution point). */ GC_API void GC_CALL GC_set_find_leak(int value) { /* value is of boolean type. */ GC_find_leak = value; } GC_API int GC_CALL GC_get_find_leak(void) { return GC_find_leak; } GC_API void GC_CALL GC_set_all_interior_pointers(int value) { DCL_LOCK_STATE; GC_all_interior_pointers = value ? 1 : 0; if (GC_is_initialized) { /* It is not recommended to change GC_all_interior_pointers value */ /* after GC is initialized but it seems GC could work correctly */ /* even after switching the mode. */ LOCK(); GC_initialize_offsets(); /* NOTE: this resets manual offsets as well */ if (!GC_all_interior_pointers) GC_bl_init_no_interiors(); UNLOCK(); } } GC_API int GC_CALL GC_get_all_interior_pointers(void) { return GC_all_interior_pointers; } GC_API void GC_CALL GC_set_finalize_on_demand(int value) { GC_ASSERT(value != -1); /* value is of boolean type. */ GC_finalize_on_demand = value; } GC_API int GC_CALL GC_get_finalize_on_demand(void) { return GC_finalize_on_demand; } GC_API void GC_CALL GC_set_java_finalization(int value) { GC_ASSERT(value != -1); /* value is of boolean type. */ GC_java_finalization = value; } GC_API int GC_CALL GC_get_java_finalization(void) { return GC_java_finalization; } GC_API void GC_CALL GC_set_dont_expand(int value) { GC_ASSERT(value != -1); /* value is of boolean type. */ GC_dont_expand = value; } GC_API int GC_CALL GC_get_dont_expand(void) { return GC_dont_expand; } GC_API void GC_CALL GC_set_no_dls(int value) { GC_ASSERT(value != -1); /* value is of boolean type. */ GC_no_dls = value; } GC_API int GC_CALL GC_get_no_dls(void) { return GC_no_dls; } GC_API void GC_CALL GC_set_non_gc_bytes(GC_word value) { GC_non_gc_bytes = value; } GC_API GC_word GC_CALL GC_get_non_gc_bytes(void) { return GC_non_gc_bytes; } GC_API void GC_CALL GC_set_free_space_divisor(GC_word value) { GC_ASSERT(value > 0); GC_free_space_divisor = value; } GC_API GC_word GC_CALL GC_get_free_space_divisor(void) { return GC_free_space_divisor; } GC_API void GC_CALL GC_set_max_retries(GC_word value) { GC_ASSERT(value != ~(GC_word)0); GC_max_retries = value; } GC_API GC_word GC_CALL GC_get_max_retries(void) { return GC_max_retries; } GC_API void GC_CALL GC_set_dont_precollect(int value) { GC_ASSERT(value != -1); /* value is of boolean type. */ GC_dont_precollect = value; } GC_API int GC_CALL GC_get_dont_precollect(void) { return GC_dont_precollect; } GC_API void GC_CALL GC_set_full_freq(int value) { GC_ASSERT(value >= 0); GC_full_freq = value; } GC_API int GC_CALL GC_get_full_freq(void) { return GC_full_freq; } GC_API void GC_CALL GC_set_time_limit(unsigned long value) { GC_ASSERT(value != (unsigned long)-1L); GC_time_limit = value; } GC_API unsigned long GC_CALL GC_get_time_limit(void) { return GC_time_limit; } GC_API void GC_CALL GC_set_force_unmap_on_gcollect(int value) { GC_force_unmap_on_gcollect = (GC_bool)value; } GC_API int GC_CALL GC_get_force_unmap_on_gcollect(void) { return (int)GC_force_unmap_on_gcollect; } ecl-16.1.2/src/bdwgc/missing000077500000000000000000000153301266352375300156360ustar00rootroot00000000000000#! /bin/sh # Common wrapper for a few potentially missing GNU programs. scriptversion=2013-10-28.13; # UTC # Copyright (C) 1996-2014 Free Software Foundation, Inc. # Originally written by Fran,cois Pinard , 1996. # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2, or (at your option) # any later version. # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # You should have received a copy of the GNU General Public License # along with this program. If not, see . # As a special exception to the GNU General Public License, if you # distribute this file as part of a program that contains a # configuration script generated by Autoconf, you may include it under # the same distribution terms that you use for the rest of that program. if test $# -eq 0; then echo 1>&2 "Try '$0 --help' for more information" exit 1 fi case $1 in --is-lightweight) # Used by our autoconf macros to check whether the available missing # script is modern enough. exit 0 ;; --run) # Back-compat with the calling convention used by older automake. shift ;; -h|--h|--he|--hel|--help) echo "\ $0 [OPTION]... PROGRAM [ARGUMENT]... Run 'PROGRAM [ARGUMENT]...', returning a proper advice when this fails due to PROGRAM being missing or too old. Options: -h, --help display this help and exit -v, --version output version information and exit Supported PROGRAM values: aclocal autoconf autoheader autom4te automake makeinfo bison yacc flex lex help2man Version suffixes to PROGRAM as well as the prefixes 'gnu-', 'gnu', and 'g' are ignored when checking the name. Send bug reports to ." exit $? ;; -v|--v|--ve|--ver|--vers|--versi|--versio|--version) echo "missing $scriptversion (GNU Automake)" exit $? ;; -*) echo 1>&2 "$0: unknown '$1' option" echo 1>&2 "Try '$0 --help' for more information" exit 1 ;; esac # Run the given program, remember its exit status. "$@"; st=$? # If it succeeded, we are done. test $st -eq 0 && exit 0 # Also exit now if we it failed (or wasn't found), and '--version' was # passed; such an option is passed most likely to detect whether the # program is present and works. case $2 in --version|--help) exit $st;; esac # Exit code 63 means version mismatch. This often happens when the user # tries to use an ancient version of a tool on a file that requires a # minimum version. if test $st -eq 63; then msg="probably too old" elif test $st -eq 127; then # Program was missing. msg="missing on your system" else # Program was found and executed, but failed. Give up. exit $st fi perl_URL=http://www.perl.org/ flex_URL=http://flex.sourceforge.net/ gnu_software_URL=http://www.gnu.org/software program_details () { case $1 in aclocal|automake) echo "The '$1' program is part of the GNU Automake package:" echo "<$gnu_software_URL/automake>" echo "It also requires GNU Autoconf, GNU m4 and Perl in order to run:" echo "<$gnu_software_URL/autoconf>" echo "<$gnu_software_URL/m4/>" echo "<$perl_URL>" ;; autoconf|autom4te|autoheader) echo "The '$1' program is part of the GNU Autoconf package:" echo "<$gnu_software_URL/autoconf/>" echo "It also requires GNU m4 and Perl in order to run:" echo "<$gnu_software_URL/m4/>" echo "<$perl_URL>" ;; esac } give_advice () { # Normalize program name to check for. normalized_program=`echo "$1" | sed ' s/^gnu-//; t s/^gnu//; t s/^g//; t'` printf '%s\n' "'$1' is $msg." configure_deps="'configure.ac' or m4 files included by 'configure.ac'" case $normalized_program in autoconf*) echo "You should only need it if you modified 'configure.ac'," echo "or m4 files included by it." program_details 'autoconf' ;; autoheader*) echo "You should only need it if you modified 'acconfig.h' or" echo "$configure_deps." program_details 'autoheader' ;; automake*) echo "You should only need it if you modified 'Makefile.am' or" echo "$configure_deps." program_details 'automake' ;; aclocal*) echo "You should only need it if you modified 'acinclude.m4' or" echo "$configure_deps." program_details 'aclocal' ;; autom4te*) echo "You might have modified some maintainer files that require" echo "the 'autom4te' program to be rebuilt." program_details 'autom4te' ;; bison*|yacc*) echo "You should only need it if you modified a '.y' file." echo "You may want to install the GNU Bison package:" echo "<$gnu_software_URL/bison/>" ;; lex*|flex*) echo "You should only need it if you modified a '.l' file." echo "You may want to install the Fast Lexical Analyzer package:" echo "<$flex_URL>" ;; help2man*) echo "You should only need it if you modified a dependency" \ "of a man page." echo "You may want to install the GNU Help2man package:" echo "<$gnu_software_URL/help2man/>" ;; makeinfo*) echo "You should only need it if you modified a '.texi' file, or" echo "any other file indirectly affecting the aspect of the manual." echo "You might want to install the Texinfo package:" echo "<$gnu_software_URL/texinfo/>" echo "The spurious makeinfo call might also be the consequence of" echo "using a buggy 'make' (AIX, DU, IRIX), in which case you might" echo "want to install GNU make:" echo "<$gnu_software_URL/make/>" ;; *) echo "You might have modified some files without having the proper" echo "tools for further handling them. Check the 'README' file, it" echo "often tells you about the needed prerequisites for installing" echo "this package. You may also peek at any GNU archive site, in" echo "case some other package contains this missing '$1' program." ;; esac } give_advice "$1" | sed -e '1s/^/WARNING: /' \ -e '2,$s/^/ /' >&2 # Propagate the correct exit status (expected to be 127 for a program # not found, 63 for a program that failed due to version mismatch). exit $st # Local variables: # eval: (add-hook 'write-file-hooks 'time-stamp) # time-stamp-start: "scriptversion=" # time-stamp-format: "%:y-%02m-%02d.%02H" # time-stamp-time-zone: "UTC" # time-stamp-end: "; # UTC" # End: ecl-16.1.2/src/bdwgc/new_hblk.c000066400000000000000000000142221266352375300161730ustar00rootroot00000000000000/* * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. * Copyright (c) 2000 by Hewlett-Packard Company. All rights reserved. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. */ #include "private/gc_priv.h" /* * This file contains the functions: * ptr_t GC_build_flXXX(h, old_fl) * void GC_new_hblk(size) */ #include #ifndef SMALL_CONFIG /* Build a free list for size 2 (words) cleared objects inside */ /* hblk h. Set the last link to be ofl. Return a pointer tpo the */ /* first free list entry. */ STATIC ptr_t GC_build_fl_clear2(struct hblk *h, ptr_t ofl) { word * p = (word *)(h -> hb_body); word * lim = (word *)(h + 1); p[0] = (word)ofl; p[1] = 0; p[2] = (word)p; p[3] = 0; p += 4; for (; (word)p < (word)lim; p += 4) { p[0] = (word)(p-2); p[1] = 0; p[2] = (word)p; p[3] = 0; }; return((ptr_t)(p-2)); } /* The same for size 4 cleared objects. */ STATIC ptr_t GC_build_fl_clear4(struct hblk *h, ptr_t ofl) { word * p = (word *)(h -> hb_body); word * lim = (word *)(h + 1); p[0] = (word)ofl; p[1] = 0; p[2] = 0; p[3] = 0; p += 4; for (; (word)p < (word)lim; p += 4) { PREFETCH_FOR_WRITE((ptr_t)(p+64)); p[0] = (word)(p-4); p[1] = 0; CLEAR_DOUBLE(p+2); }; return((ptr_t)(p-4)); } /* The same for size 2 uncleared objects. */ STATIC ptr_t GC_build_fl2(struct hblk *h, ptr_t ofl) { word * p = (word *)(h -> hb_body); word * lim = (word *)(h + 1); p[0] = (word)ofl; p[2] = (word)p; p += 4; for (; (word)p < (word)lim; p += 4) { p[0] = (word)(p-2); p[2] = (word)p; }; return((ptr_t)(p-2)); } /* The same for size 4 uncleared objects. */ STATIC ptr_t GC_build_fl4(struct hblk *h, ptr_t ofl) { word * p = (word *)(h -> hb_body); word * lim = (word *)(h + 1); p[0] = (word)ofl; p[4] = (word)p; p += 8; for (; (word)p < (word)lim; p += 8) { PREFETCH_FOR_WRITE((ptr_t)(p+64)); p[0] = (word)(p-4); p[4] = (word)p; }; return((ptr_t)(p-4)); } #endif /* !SMALL_CONFIG */ /* Build a free list for objects of size sz inside heap block h. */ /* Clear objects inside h if clear is set. Add list to the end of */ /* the free list we build. Return the new free list. */ /* This could be called without the main GC lock, if we ensure that */ /* there is no concurrent collection which might reclaim objects that */ /* we have not yet allocated. */ GC_INNER ptr_t GC_build_fl(struct hblk *h, size_t sz, GC_bool clear, ptr_t list) { word *p, *prev; word *last_object; /* points to last object in new hblk */ /* Do a few prefetches here, just because its cheap. */ /* If we were more serious about it, these should go inside */ /* the loops. But write prefetches usually don't seem to */ /* matter much. */ PREFETCH_FOR_WRITE((ptr_t)h); PREFETCH_FOR_WRITE((ptr_t)h + 128); PREFETCH_FOR_WRITE((ptr_t)h + 256); PREFETCH_FOR_WRITE((ptr_t)h + 378); # ifndef SMALL_CONFIG /* Handle small objects sizes more efficiently. For larger objects */ /* the difference is less significant. */ switch (sz) { case 2: if (clear) { return GC_build_fl_clear2(h, list); } else { return GC_build_fl2(h, list); } case 4: if (clear) { return GC_build_fl_clear4(h, list); } else { return GC_build_fl4(h, list); } default: break; } # endif /* !SMALL_CONFIG */ /* Clear the page if necessary. */ if (clear) BZERO(h, HBLKSIZE); /* Add objects to free list */ p = (word *)(h -> hb_body) + sz; /* second object in *h */ prev = (word *)(h -> hb_body); /* One object behind p */ last_object = (word *)((char *)h + HBLKSIZE); last_object -= sz; /* Last place for last object to start */ /* make a list of all objects in *h with head as last object */ while ((word)p <= (word)last_object) { /* current object's link points to last object */ obj_link(p) = (ptr_t)prev; prev = p; p += sz; } p -= sz; /* p now points to last object */ /* Put p (which is now head of list of objects in *h) as first */ /* pointer in the appropriate free list for this size. */ *(ptr_t *)h = list; return ((ptr_t)p); } /* Allocate a new heapblock for small objects of size gran granules. */ /* Add all of the heapblock's objects to the free list for objects */ /* of that size. Set all mark bits if objects are uncollectible. */ /* Will fail to do anything if we are out of memory. */ GC_INNER void GC_new_hblk(size_t gran, int kind) { struct hblk *h; /* the new heap block */ GC_bool clear = GC_obj_kinds[kind].ok_init; GC_STATIC_ASSERT((sizeof (struct hblk)) == HBLKSIZE); if (GC_debugging_started) clear = TRUE; /* Allocate a new heap block */ h = GC_allochblk(GRANULES_TO_BYTES(gran), kind, 0); if (h == 0) return; /* Mark all objects if appropriate. */ if (IS_UNCOLLECTABLE(kind)) GC_set_hdr_marks(HDR(h)); /* Build the free list */ GC_obj_kinds[kind].ok_freelist[gran] = GC_build_fl(h, GRANULES_TO_WORDS(gran), clear, GC_obj_kinds[kind].ok_freelist[gran]); } ecl-16.1.2/src/bdwgc/obj_map.c000066400000000000000000000057631266352375300160230ustar00rootroot00000000000000/* * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers * Copyright (c) 1991, 1992 by Xerox Corporation. All rights reserved. * Copyright (c) 1999-2001 by Hewlett-Packard Company. All rights reserved. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. */ #include "private/gc_priv.h" /* Routines for maintaining maps describing heap block * layouts for various object sizes. Allows fast pointer validity checks * and fast location of object start locations on machines (such as SPARC) * with slow division. */ /* Consider pointers that are offset bytes displaced from the beginning */ /* of an object to be valid. */ GC_API void GC_CALL GC_register_displacement(size_t offset) { DCL_LOCK_STATE; LOCK(); GC_register_displacement_inner(offset); UNLOCK(); } GC_INNER void GC_register_displacement_inner(size_t offset) { if (offset >= VALID_OFFSET_SZ) { ABORT("Bad argument to GC_register_displacement"); } if (!GC_valid_offsets[offset]) { GC_valid_offsets[offset] = TRUE; GC_modws_valid_offsets[offset % sizeof(word)] = TRUE; } } #ifdef MARK_BIT_PER_GRANULE /* Add a heap block map for objects of size granules to obj_map. */ /* Return FALSE on failure. */ /* A size of 0 granules is used for large objects. */ GC_INNER GC_bool GC_add_map_entry(size_t granules) { unsigned displ; short * new_map; if (granules > BYTES_TO_GRANULES(MAXOBJBYTES)) granules = 0; if (GC_obj_map[granules] != 0) { return(TRUE); } new_map = (short *)GC_scratch_alloc(MAP_LEN * sizeof(short)); if (new_map == 0) return(FALSE); GC_COND_LOG_PRINTF( "Adding block map for size of %u granules (%u bytes)\n", (unsigned)granules, (unsigned)GRANULES_TO_BYTES(granules)); if (granules == 0) { for (displ = 0; displ < BYTES_TO_GRANULES(HBLKSIZE); displ++) { new_map[displ] = 1; /* Nonzero to get us out of marker fast path. */ } } else { for (displ = 0; displ < BYTES_TO_GRANULES(HBLKSIZE); displ++) { new_map[displ] = (short)(displ % granules); } } GC_obj_map[granules] = new_map; return(TRUE); } #endif /* MARK_BIT_PER_GRANULE */ GC_INNER void GC_initialize_offsets(void) { unsigned i; if (GC_all_interior_pointers) { for (i = 0; i < VALID_OFFSET_SZ; ++i) GC_valid_offsets[i] = TRUE; } else { BZERO(GC_valid_offsets, sizeof(GC_valid_offsets)); for (i = 0; i < sizeof(word); ++i) GC_modws_valid_offsets[i] = FALSE; } } ecl-16.1.2/src/bdwgc/os_dep.c000066400000000000000000005031611266352375300156600ustar00rootroot00000000000000/* * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers * Copyright (c) 1991-1995 by Xerox Corporation. All rights reserved. * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. * Copyright (c) 1999 by Hewlett-Packard Company. All rights reserved. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. */ #include "private/gc_priv.h" #if !defined(OS2) && !defined(PCR) && !defined(AMIGA) && !defined(MACOS) \ && !defined(MSWINCE) && !defined(__CC_ARM) # include # if !defined(MSWIN32) # include # endif #endif #include #if defined(MSWINCE) || defined(SN_TARGET_PS3) # define SIGSEGV 0 /* value is irrelevant */ #else # include #endif #if defined(UNIX_LIKE) || defined(CYGWIN32) || defined(NACL) \ || defined(SYMBIAN) # include #endif #if defined(LINUX) || defined(LINUX_STACKBOTTOM) # include #endif /* Blatantly OS dependent routines, except for those that are related */ /* to dynamic loading. */ #ifdef AMIGA # define GC_AMIGA_DEF # include "extra/AmigaOS.c" # undef GC_AMIGA_DEF #endif #if defined(MSWIN32) || defined(MSWINCE) || defined(CYGWIN32) # ifndef WIN32_LEAN_AND_MEAN # define WIN32_LEAN_AND_MEAN 1 # endif # define NOSERVICE # include /* It's not clear this is completely kosher under Cygwin. But it */ /* allows us to get a working GC_get_stack_base. */ #endif #ifdef MACOS # include #endif #ifdef IRIX5 # include # include /* for locking */ #endif #if defined(MMAP_SUPPORTED) || defined(ADD_HEAP_GUARD_PAGES) # if defined(USE_MUNMAP) && !defined(USE_MMAP) # error "invalid config - USE_MUNMAP requires USE_MMAP" # endif # include # include # include # include #endif #ifdef DARWIN /* for get_etext and friends */ # include #endif #ifdef DJGPP /* Apparently necessary for djgpp 2.01. May cause problems with */ /* other versions. */ typedef long unsigned int caddr_t; #endif #ifdef PCR # include "il/PCR_IL.h" # include "th/PCR_ThCtl.h" # include "mm/PCR_MM.h" #endif #if !defined(NO_EXECUTE_PERMISSION) STATIC GC_bool GC_pages_executable = TRUE; #else STATIC GC_bool GC_pages_executable = FALSE; #endif #define IGNORE_PAGES_EXECUTABLE 1 /* Undefined on GC_pages_executable real use. */ #ifdef NEED_PROC_MAPS /* We need to parse /proc/self/maps, either to find dynamic libraries, */ /* and/or to find the register backing store base (IA64). Do it once */ /* here. */ #define READ read /* Repeatedly perform a read call until the buffer is filled or */ /* we encounter EOF. */ STATIC ssize_t GC_repeat_read(int fd, char *buf, size_t count) { size_t num_read = 0; ssize_t result; ASSERT_CANCEL_DISABLED(); while (num_read < count) { result = READ(fd, buf + num_read, count - num_read); if (result < 0) return result; if (result == 0) break; num_read += result; } return num_read; } #ifdef THREADS /* Determine the length of a file by incrementally reading it into a */ /* This would be silly to use on a file supporting lseek, but Linux */ /* /proc files usually do not. */ STATIC size_t GC_get_file_len(int f) { size_t total = 0; ssize_t result; # define GET_FILE_LEN_BUF_SZ 500 char buf[GET_FILE_LEN_BUF_SZ]; do { result = read(f, buf, GET_FILE_LEN_BUF_SZ); if (result == -1) return 0; total += result; } while (result > 0); return total; } STATIC size_t GC_get_maps_len(void) { int f = open("/proc/self/maps", O_RDONLY); size_t result; if (f < 0) return 0; /* treat missing file as empty */ result = GC_get_file_len(f); close(f); return result; } #endif /* THREADS */ /* Copy the contents of /proc/self/maps to a buffer in our address */ /* space. Return the address of the buffer, or zero on failure. */ /* This code could be simplified if we could determine its size ahead */ /* of time. */ GC_INNER char * GC_get_maps(void) { int f; ssize_t result; static char *maps_buf = NULL; static size_t maps_buf_sz = 1; size_t maps_size, old_maps_size = 0; /* The buffer is essentially static, so there must be a single client. */ GC_ASSERT(I_HOLD_LOCK()); /* Note that in the presence of threads, the maps file can */ /* essentially shrink asynchronously and unexpectedly as */ /* threads that we already think of as dead release their */ /* stacks. And there is no easy way to read the entire */ /* file atomically. This is arguably a misfeature of the */ /* /proc/.../maps interface. */ /* Since we don't believe the file can grow */ /* asynchronously, it should suffice to first determine */ /* the size (using lseek or read), and then to reread the */ /* file. If the size is inconsistent we have to retry. */ /* This only matters with threads enabled, and if we use */ /* this to locate roots (not the default). */ # ifdef THREADS /* Determine the initial size of /proc/self/maps. */ /* Note that lseek doesn't work, at least as of 2.6.15. */ maps_size = GC_get_maps_len(); if (0 == maps_size) return 0; # else maps_size = 4000; /* Guess */ # endif /* Read /proc/self/maps, growing maps_buf as necessary. */ /* Note that we may not allocate conventionally, and */ /* thus can't use stdio. */ do { while (maps_size >= maps_buf_sz) { /* Grow only by powers of 2, since we leak "too small" buffers.*/ while (maps_size >= maps_buf_sz) maps_buf_sz *= 2; maps_buf = GC_scratch_alloc(maps_buf_sz); # ifdef THREADS /* Recompute initial length, since we allocated. */ /* This can only happen a few times per program */ /* execution. */ maps_size = GC_get_maps_len(); if (0 == maps_size) return 0; # endif if (maps_buf == 0) return 0; } GC_ASSERT(maps_buf_sz >= maps_size + 1); f = open("/proc/self/maps", O_RDONLY); if (-1 == f) return 0; # ifdef THREADS old_maps_size = maps_size; # endif maps_size = 0; do { result = GC_repeat_read(f, maps_buf, maps_buf_sz-1); if (result <= 0) break; maps_size += result; } while ((size_t)result == maps_buf_sz-1); close(f); if (result <= 0) return 0; # ifdef THREADS if (maps_size > old_maps_size) { ABORT_ARG2("Unexpected asynchronous /proc/self/maps growth " "(unregistered thread?)", " from %lu to %lu", (unsigned long)old_maps_size, (unsigned long)maps_size); } # endif } while (maps_size >= maps_buf_sz || maps_size < old_maps_size); /* In the single-threaded case, the second clause is false. */ maps_buf[maps_size] = '\0'; /* Apply fn to result. */ return maps_buf; } /* * GC_parse_map_entry parses an entry from /proc/self/maps so we can * locate all writable data segments that belong to shared libraries. * The format of one of these entries and the fields we care about * is as follows: * XXXXXXXX-XXXXXXXX r-xp 00000000 30:05 260537 name of mapping...\n * ^^^^^^^^ ^^^^^^^^ ^^^^ ^^ * start end prot maj_dev * * Note that since about august 2003 kernels, the columns no longer have * fixed offsets on 64-bit kernels. Hence we no longer rely on fixed offsets * anywhere, which is safer anyway. */ /* Assign various fields of the first line in buf_ptr to (*start), */ /* (*end), (*prot), (*maj_dev) and (*mapping_name). mapping_name may */ /* be NULL. (*prot) and (*mapping_name) are assigned pointers into the */ /* original buffer. */ #if (defined(DYNAMIC_LOADING) && defined(USE_PROC_FOR_LIBRARIES)) \ || defined(IA64) || defined(INCLUDE_LINUX_THREAD_DESCR) \ || defined(REDIRECT_MALLOC) GC_INNER char *GC_parse_map_entry(char *buf_ptr, ptr_t *start, ptr_t *end, char **prot, unsigned int *maj_dev, char **mapping_name) { unsigned char *start_start, *end_start, *maj_dev_start; unsigned char *p; /* unsigned for isspace, isxdigit */ if (buf_ptr == NULL || *buf_ptr == '\0') { return NULL; } p = (unsigned char *)buf_ptr; while (isspace(*p)) ++p; start_start = p; GC_ASSERT(isxdigit(*start_start)); *start = (ptr_t)strtoul((char *)start_start, (char **)&p, 16); GC_ASSERT(*p=='-'); ++p; end_start = p; GC_ASSERT(isxdigit(*end_start)); *end = (ptr_t)strtoul((char *)end_start, (char **)&p, 16); GC_ASSERT(isspace(*p)); while (isspace(*p)) ++p; GC_ASSERT(*p == 'r' || *p == '-'); *prot = (char *)p; /* Skip past protection field to offset field */ while (!isspace(*p)) ++p; while (isspace(*p)) ++p; GC_ASSERT(isxdigit(*p)); /* Skip past offset field, which we ignore */ while (!isspace(*p)) ++p; while (isspace(*p)) ++p; maj_dev_start = p; GC_ASSERT(isxdigit(*maj_dev_start)); *maj_dev = strtoul((char *)maj_dev_start, NULL, 16); if (mapping_name == 0) { while (*p && *p++ != '\n'); } else { while (*p && *p != '\n' && *p != '/' && *p != '[') p++; *mapping_name = (char *)p; while (*p && *p++ != '\n'); } return (char *)p; } #endif /* REDIRECT_MALLOC || DYNAMIC_LOADING || IA64 || ... */ #if defined(IA64) || defined(INCLUDE_LINUX_THREAD_DESCR) /* Try to read the backing store base from /proc/self/maps. */ /* Return the bounds of the writable mapping with a 0 major device, */ /* which includes the address passed as data. */ /* Return FALSE if there is no such mapping. */ GC_INNER GC_bool GC_enclosing_mapping(ptr_t addr, ptr_t *startp, ptr_t *endp) { char *prot; ptr_t my_start, my_end; unsigned int maj_dev; char *maps = GC_get_maps(); char *buf_ptr = maps; if (0 == maps) return(FALSE); for (;;) { buf_ptr = GC_parse_map_entry(buf_ptr, &my_start, &my_end, &prot, &maj_dev, 0); if (buf_ptr == NULL) return FALSE; if (prot[1] == 'w' && maj_dev == 0) { if ((word)my_end > (word)addr && (word)my_start <= (word)addr) { *startp = my_start; *endp = my_end; return TRUE; } } } return FALSE; } #endif /* IA64 || INCLUDE_LINUX_THREAD_DESCR */ #if defined(REDIRECT_MALLOC) /* Find the text(code) mapping for the library whose name, after */ /* stripping the directory part, starts with nm. */ GC_INNER GC_bool GC_text_mapping(char *nm, ptr_t *startp, ptr_t *endp) { size_t nm_len = strlen(nm); char *prot; char *map_path; ptr_t my_start, my_end; unsigned int maj_dev; char *maps = GC_get_maps(); char *buf_ptr = maps; if (0 == maps) return(FALSE); for (;;) { buf_ptr = GC_parse_map_entry(buf_ptr, &my_start, &my_end, &prot, &maj_dev, &map_path); if (buf_ptr == NULL) return FALSE; if (prot[0] == 'r' && prot[1] == '-' && prot[2] == 'x') { char *p = map_path; /* Set p to point just past last slash, if any. */ while (*p != '\0' && *p != '\n' && *p != ' ' && *p != '\t') ++p; while (*p != '/' && (word)p >= (word)map_path) --p; ++p; if (strncmp(nm, p, nm_len) == 0) { *startp = my_start; *endp = my_end; return TRUE; } } } return FALSE; } #endif /* REDIRECT_MALLOC */ #ifdef IA64 static ptr_t backing_store_base_from_proc(void) { ptr_t my_start, my_end; if (!GC_enclosing_mapping(GC_save_regs_in_stack(), &my_start, &my_end)) { GC_COND_LOG_PRINTF("Failed to find backing store base from /proc\n"); return 0; } return my_start; } #endif #endif /* NEED_PROC_MAPS */ #if defined(SEARCH_FOR_DATA_START) /* The I386 case can be handled without a search. The Alpha case */ /* used to be handled differently as well, but the rules changed */ /* for recent Linux versions. This seems to be the easiest way to */ /* cover all versions. */ # if defined(LINUX) || defined(HURD) /* Some Linux distributions arrange to define __data_start. Some */ /* define data_start as a weak symbol. The latter is technically */ /* broken, since the user program may define data_start, in which */ /* case we lose. Nonetheless, we try both, preferring __data_start.*/ /* We assume gcc-compatible pragmas. */ # pragma weak __data_start # pragma weak data_start extern int __data_start[], data_start[]; # ifdef PLATFORM_ANDROID # pragma weak _etext # pragma weak __dso_handle extern int _etext[], __dso_handle[]; # endif # endif /* LINUX */ extern int _end[]; ptr_t GC_data_start = NULL; ptr_t GC_find_limit(ptr_t, GC_bool); GC_INNER void GC_init_linux_data_start(void) { # if (defined(LINUX) || defined(HURD)) && !defined(IGNORE_PROG_DATA_START) /* Try the easy approaches first: */ # ifdef PLATFORM_ANDROID /* Workaround for "gold" (default) linker (as of Android NDK r9b). */ if ((word)__data_start < (word)_etext && (word)_etext < (word)__dso_handle) { GC_data_start = (ptr_t)(__dso_handle); # ifdef DEBUG_ADD_DEL_ROOTS GC_log_printf( "__data_start is wrong; using __dso_handle as data start\n"); # endif GC_ASSERT((word)GC_data_start <= (word)_end); return; } # endif if ((ptr_t)__data_start != 0) { GC_data_start = (ptr_t)(__data_start); GC_ASSERT((word)GC_data_start <= (word)_end); return; } if ((ptr_t)data_start != 0) { GC_data_start = (ptr_t)(data_start); GC_ASSERT((word)GC_data_start <= (word)_end); return; } # ifdef DEBUG_ADD_DEL_ROOTS GC_log_printf("__data_start not provided\n"); # endif # endif /* LINUX */ if (GC_no_dls) { /* Not needed, avoids the SIGSEGV caused by */ /* GC_find_limit which complicates debugging. */ GC_data_start = (ptr_t)_end; /* set data root size to 0 */ return; } GC_data_start = GC_find_limit((ptr_t)(_end), FALSE); } #endif /* SEARCH_FOR_DATA_START */ #ifdef ECOS # ifndef ECOS_GC_MEMORY_SIZE # define ECOS_GC_MEMORY_SIZE (448 * 1024) # endif /* ECOS_GC_MEMORY_SIZE */ /* FIXME: This is a simple way of allocating memory which is */ /* compatible with ECOS early releases. Later releases use a more */ /* sophisticated means of allocating memory than this simple static */ /* allocator, but this method is at least bound to work. */ static char ecos_gc_memory[ECOS_GC_MEMORY_SIZE]; static char *ecos_gc_brk = ecos_gc_memory; static void *tiny_sbrk(ptrdiff_t increment) { void *p = ecos_gc_brk; ecos_gc_brk += increment; if ((word)ecos_gc_brk > (word)(ecos_gc_memory + sizeof(ecos_gc_memory))) { ecos_gc_brk -= increment; return NULL; } return p; } # define sbrk tiny_sbrk #endif /* ECOS */ #if defined(NETBSD) && defined(__ELF__) ptr_t GC_data_start = NULL; ptr_t GC_find_limit(ptr_t, GC_bool); extern char **environ; GC_INNER void GC_init_netbsd_elf(void) { /* This may need to be environ, without the underscore, for */ /* some versions. */ GC_data_start = GC_find_limit((ptr_t)&environ, FALSE); } #endif /* NETBSD */ #ifdef OPENBSD static struct sigaction old_segv_act; STATIC sigjmp_buf GC_jmp_buf_openbsd; # ifdef THREADS # include extern sigset_t __syscall(quad_t, ...); # endif /* Don't use GC_find_limit() because siglongjmp() outside of the */ /* signal handler by-passes our userland pthreads lib, leaving */ /* SIGSEGV and SIGPROF masked. Instead, use this custom one that */ /* works-around the issues. */ STATIC void GC_fault_handler_openbsd(int sig GC_ATTR_UNUSED) { siglongjmp(GC_jmp_buf_openbsd, 1); } /* Return the first non-addressable location > p or bound. */ /* Requires the allocation lock. */ STATIC ptr_t GC_find_limit_openbsd(ptr_t p, ptr_t bound) { static volatile ptr_t result; /* Safer if static, since otherwise it may not be */ /* preserved across the longjmp. Can safely be */ /* static since it's only called with the */ /* allocation lock held. */ struct sigaction act; size_t pgsz = (size_t)sysconf(_SC_PAGESIZE); GC_ASSERT(I_HOLD_LOCK()); act.sa_handler = GC_fault_handler_openbsd; sigemptyset(&act.sa_mask); act.sa_flags = SA_NODEFER | SA_RESTART; /* act.sa_restorer is deprecated and should not be initialized. */ sigaction(SIGSEGV, &act, &old_segv_act); if (sigsetjmp(GC_jmp_buf_openbsd, 1) == 0) { result = (ptr_t)((word)p & ~(pgsz-1)); for (;;) { result += pgsz; if ((word)result >= (word)bound) { result = bound; break; } GC_noop1((word)(*result)); } } # ifdef THREADS /* Due to the siglongjump we need to manually unmask SIGPROF. */ __syscall(SYS_sigprocmask, SIG_UNBLOCK, sigmask(SIGPROF)); # endif sigaction(SIGSEGV, &old_segv_act, 0); return(result); } /* Return first addressable location > p or bound. */ /* Requires the allocation lock. */ STATIC ptr_t GC_skip_hole_openbsd(ptr_t p, ptr_t bound) { static volatile ptr_t result; static volatile int firstpass; struct sigaction act; size_t pgsz = (size_t)sysconf(_SC_PAGESIZE); GC_ASSERT(I_HOLD_LOCK()); act.sa_handler = GC_fault_handler_openbsd; sigemptyset(&act.sa_mask); act.sa_flags = SA_NODEFER | SA_RESTART; /* act.sa_restorer is deprecated and should not be initialized. */ sigaction(SIGSEGV, &act, &old_segv_act); firstpass = 1; result = (ptr_t)((word)p & ~(pgsz-1)); if (sigsetjmp(GC_jmp_buf_openbsd, 1) != 0 || firstpass) { firstpass = 0; result += pgsz; if ((word)result >= (word)bound) { result = bound; } else { GC_noop1((word)(*result)); } } sigaction(SIGSEGV, &old_segv_act, 0); return(result); } #endif /* OPENBSD */ # ifdef OS2 # include # if !defined(__IBMC__) && !defined(__WATCOMC__) /* e.g. EMX */ struct exe_hdr { unsigned short magic_number; unsigned short padding[29]; long new_exe_offset; }; #define E_MAGIC(x) (x).magic_number #define EMAGIC 0x5A4D #define E_LFANEW(x) (x).new_exe_offset struct e32_exe { unsigned char magic_number[2]; unsigned char byte_order; unsigned char word_order; unsigned long exe_format_level; unsigned short cpu; unsigned short os; unsigned long padding1[13]; unsigned long object_table_offset; unsigned long object_count; unsigned long padding2[31]; }; #define E32_MAGIC1(x) (x).magic_number[0] #define E32MAGIC1 'L' #define E32_MAGIC2(x) (x).magic_number[1] #define E32MAGIC2 'X' #define E32_BORDER(x) (x).byte_order #define E32LEBO 0 #define E32_WORDER(x) (x).word_order #define E32LEWO 0 #define E32_CPU(x) (x).cpu #define E32CPU286 1 #define E32_OBJTAB(x) (x).object_table_offset #define E32_OBJCNT(x) (x).object_count struct o32_obj { unsigned long size; unsigned long base; unsigned long flags; unsigned long pagemap; unsigned long mapsize; unsigned long reserved; }; #define O32_FLAGS(x) (x).flags #define OBJREAD 0x0001L #define OBJWRITE 0x0002L #define OBJINVALID 0x0080L #define O32_SIZE(x) (x).size #define O32_BASE(x) (x).base # else /* IBM's compiler */ /* A kludge to get around what appears to be a header file bug */ # ifndef WORD # define WORD unsigned short # endif # ifndef DWORD # define DWORD unsigned long # endif # define EXE386 1 # include # include # endif /* __IBMC__ */ # define INCL_DOSEXCEPTIONS # define INCL_DOSPROCESS # define INCL_DOSERRORS # define INCL_DOSMODULEMGR # define INCL_DOSMEMMGR # include # endif /* OS/2 */ /* Find the page size */ GC_INNER word GC_page_size = 0; #if defined(MSWIN32) || defined(MSWINCE) || defined(CYGWIN32) # ifndef VER_PLATFORM_WIN32_CE # define VER_PLATFORM_WIN32_CE 3 # endif # if defined(MSWINCE) && defined(THREADS) GC_INNER GC_bool GC_dont_query_stack_min = FALSE; # endif GC_INNER SYSTEM_INFO GC_sysinfo; GC_INNER void GC_setpagesize(void) { GetSystemInfo(&GC_sysinfo); GC_page_size = GC_sysinfo.dwPageSize; # if defined(MSWINCE) && !defined(_WIN32_WCE_EMULATION) { OSVERSIONINFO verInfo; /* Check the current WinCE version. */ verInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFO); if (!GetVersionEx(&verInfo)) ABORT("GetVersionEx failed"); if (verInfo.dwPlatformId == VER_PLATFORM_WIN32_CE && verInfo.dwMajorVersion < 6) { /* Only the first 32 MB of address space belongs to the */ /* current process (unless WinCE 6.0+ or emulation). */ GC_sysinfo.lpMaximumApplicationAddress = (LPVOID)((word)32 << 20); # ifdef THREADS /* On some old WinCE versions, it's observed that */ /* VirtualQuery calls don't work properly when used to */ /* get thread current stack committed minimum. */ if (verInfo.dwMajorVersion < 5) GC_dont_query_stack_min = TRUE; # endif } } # endif } # ifndef CYGWIN32 # define is_writable(prot) ((prot) == PAGE_READWRITE \ || (prot) == PAGE_WRITECOPY \ || (prot) == PAGE_EXECUTE_READWRITE \ || (prot) == PAGE_EXECUTE_WRITECOPY) /* Return the number of bytes that are writable starting at p. */ /* The pointer p is assumed to be page aligned. */ /* If base is not 0, *base becomes the beginning of the */ /* allocation region containing p. */ STATIC word GC_get_writable_length(ptr_t p, ptr_t *base) { MEMORY_BASIC_INFORMATION buf; word result; word protect; result = VirtualQuery(p, &buf, sizeof(buf)); if (result != sizeof(buf)) ABORT("Weird VirtualQuery result"); if (base != 0) *base = (ptr_t)(buf.AllocationBase); protect = (buf.Protect & ~(PAGE_GUARD | PAGE_NOCACHE)); if (!is_writable(protect)) { return(0); } if (buf.State != MEM_COMMIT) return(0); return(buf.RegionSize); } GC_API int GC_CALL GC_get_stack_base(struct GC_stack_base *sb) { ptr_t trunc_sp = (ptr_t)((word)GC_approx_sp() & ~(GC_page_size - 1)); /* FIXME: This won't work if called from a deeply recursive */ /* client code (and the committed stack space has grown). */ word size = GC_get_writable_length(trunc_sp, 0); GC_ASSERT(size != 0); sb -> mem_base = trunc_sp + size; return GC_SUCCESS; } # else /* CYGWIN32 */ /* An alternate version for Cygwin (adapted from Dave Korn's */ /* gcc version of boehm-gc). */ GC_API int GC_CALL GC_get_stack_base(struct GC_stack_base *sb) { # ifdef X86_64 sb -> mem_base = ((NT_TIB*)NtCurrentTeb())->StackBase; # else void * _tlsbase; __asm__ ("movl %%fs:4, %0" : "=r" (_tlsbase)); sb -> mem_base = _tlsbase; # endif return GC_SUCCESS; } # endif /* CYGWIN32 */ # define HAVE_GET_STACK_BASE #else /* !MSWIN32 */ GC_INNER void GC_setpagesize(void) { # if defined(MPROTECT_VDB) || defined(PROC_VDB) || defined(USE_MMAP) GC_page_size = GETPAGESIZE(); if (!GC_page_size) ABORT("getpagesize failed"); # else /* It's acceptable to fake it. */ GC_page_size = HBLKSIZE; # endif } #endif /* !MSWIN32 */ #ifdef BEOS # include GC_API int GC_CALL GC_get_stack_base(struct GC_stack_base *sb) { thread_info th; get_thread_info(find_thread(NULL),&th); sb->mem_base = th.stack_end; return GC_SUCCESS; } # define HAVE_GET_STACK_BASE #endif /* BEOS */ #ifdef OS2 GC_API int GC_CALL GC_get_stack_base(struct GC_stack_base *sb) { PTIB ptib; /* thread information block */ PPIB ppib; if (DosGetInfoBlocks(&ptib, &ppib) != NO_ERROR) { ABORT("DosGetInfoBlocks failed"); } sb->mem_base = ptib->tib_pstacklimit; return GC_SUCCESS; } # define HAVE_GET_STACK_BASE #endif /* OS2 */ # ifdef AMIGA # define GC_AMIGA_SB # include "extra/AmigaOS.c" # undef GC_AMIGA_SB # endif /* AMIGA */ # if defined(NEED_FIND_LIMIT) || defined(UNIX_LIKE) typedef void (*GC_fault_handler_t)(int); # if defined(SUNOS5SIGS) || defined(IRIX5) || defined(OSF1) \ || defined(HURD) || defined(FREEBSD) || defined(NETBSD) static struct sigaction old_segv_act; # if defined(_sigargs) /* !Irix6.x */ \ || defined(HURD) || defined(NETBSD) || defined(FREEBSD) static struct sigaction old_bus_act; # endif # else static GC_fault_handler_t old_segv_handler; # ifdef SIGBUS static GC_fault_handler_t old_bus_handler; # endif # endif GC_INNER void GC_set_and_save_fault_handler(GC_fault_handler_t h) { # if defined(SUNOS5SIGS) || defined(IRIX5) || defined(OSF1) \ || defined(HURD) || defined(FREEBSD) || defined(NETBSD) struct sigaction act; act.sa_handler = h; # ifdef SIGACTION_FLAGS_NODEFER_HACK /* Was necessary for Solaris 2.3 and very temporary */ /* NetBSD bugs. */ act.sa_flags = SA_RESTART | SA_NODEFER; # else act.sa_flags = SA_RESTART; # endif (void) sigemptyset(&act.sa_mask); /* act.sa_restorer is deprecated and should not be initialized. */ # ifdef GC_IRIX_THREADS /* Older versions have a bug related to retrieving and */ /* and setting a handler at the same time. */ (void) sigaction(SIGSEGV, 0, &old_segv_act); (void) sigaction(SIGSEGV, &act, 0); # else (void) sigaction(SIGSEGV, &act, &old_segv_act); # if defined(IRIX5) && defined(_sigargs) /* Irix 5.x, not 6.x */ \ || defined(HURD) || defined(NETBSD) || defined(FREEBSD) /* Under Irix 5.x or HP/UX, we may get SIGBUS. */ /* Pthreads doesn't exist under Irix 5.x, so we */ /* don't have to worry in the threads case. */ (void) sigaction(SIGBUS, &act, &old_bus_act); # endif # endif /* !GC_IRIX_THREADS */ # else old_segv_handler = signal(SIGSEGV, h); # ifdef SIGBUS old_bus_handler = signal(SIGBUS, h); # endif # endif } # endif /* NEED_FIND_LIMIT || UNIX_LIKE */ # if defined(NEED_FIND_LIMIT) \ || (defined(USE_PROC_FOR_LIBRARIES) && defined(THREADS)) /* Some tools to implement HEURISTIC2 */ # define MIN_PAGE_SIZE 256 /* Smallest conceivable page size, bytes */ STATIC void GC_fault_handler(int sig GC_ATTR_UNUSED) { LONGJMP(GC_jmp_buf, 1); } GC_INNER void GC_setup_temporary_fault_handler(void) { /* Handler is process-wide, so this should only happen in */ /* one thread at a time. */ GC_ASSERT(I_HOLD_LOCK()); GC_set_and_save_fault_handler(GC_fault_handler); } GC_INNER void GC_reset_fault_handler(void) { # if defined(SUNOS5SIGS) || defined(IRIX5) || defined(OSF1) \ || defined(HURD) || defined(FREEBSD) || defined(NETBSD) (void) sigaction(SIGSEGV, &old_segv_act, 0); # if defined(IRIX5) && defined(_sigargs) /* Irix 5.x, not 6.x */ \ || defined(HURD) || defined(NETBSD) (void) sigaction(SIGBUS, &old_bus_act, 0); # endif # else (void) signal(SIGSEGV, old_segv_handler); # ifdef SIGBUS (void) signal(SIGBUS, old_bus_handler); # endif # endif } /* Return the first non-addressable location > p (up) or */ /* the smallest location q s.t. [q,p) is addressable (!up). */ /* We assume that p (up) or p-1 (!up) is addressable. */ /* Requires allocation lock. */ STATIC ptr_t GC_find_limit_with_bound(ptr_t p, GC_bool up, ptr_t bound) { static volatile ptr_t result; /* Safer if static, since otherwise it may not be */ /* preserved across the longjmp. Can safely be */ /* static since it's only called with the */ /* allocation lock held. */ GC_ASSERT(I_HOLD_LOCK()); GC_setup_temporary_fault_handler(); if (SETJMP(GC_jmp_buf) == 0) { result = (ptr_t)(((word)(p)) & ~(MIN_PAGE_SIZE-1)); for (;;) { if (up) { result += MIN_PAGE_SIZE; if ((word)result >= (word)bound) { result = bound; break; } } else { result -= MIN_PAGE_SIZE; if ((word)result <= (word)bound) { result = bound - MIN_PAGE_SIZE; /* This is to compensate */ /* further result increment (we */ /* do not modify "up" variable */ /* since it might be clobbered */ /* by setjmp otherwise). */ break; } } GC_noop1((word)(*result)); } } GC_reset_fault_handler(); if (!up) { result += MIN_PAGE_SIZE; } return(result); } ptr_t GC_find_limit(ptr_t p, GC_bool up) { return GC_find_limit_with_bound(p, up, up ? (ptr_t)(word)(-1) : 0); } # endif /* NEED_FIND_LIMIT || USE_PROC_FOR_LIBRARIES */ #ifdef HPUX_STACKBOTTOM #include #include GC_INNER ptr_t GC_get_register_stack_base(void) { struct pst_vm_status vm_status; int i = 0; while (pstat_getprocvm(&vm_status, sizeof(vm_status), 0, i++) == 1) { if (vm_status.pst_type == PS_RSESTACK) { return (ptr_t) vm_status.pst_vaddr; } } /* old way to get the register stackbottom */ return (ptr_t)(((word)GC_stackbottom - BACKING_STORE_DISPLACEMENT - 1) & ~(BACKING_STORE_ALIGNMENT - 1)); } #endif /* HPUX_STACK_BOTTOM */ #ifdef LINUX_STACKBOTTOM # include # include # define STAT_SKIP 27 /* Number of fields preceding startstack */ /* field in /proc/self/stat */ # ifdef USE_LIBC_PRIVATES # pragma weak __libc_stack_end extern ptr_t __libc_stack_end; # endif # ifdef IA64 # ifdef USE_LIBC_PRIVATES # pragma weak __libc_ia64_register_backing_store_base extern ptr_t __libc_ia64_register_backing_store_base; # endif GC_INNER ptr_t GC_get_register_stack_base(void) { ptr_t result; # ifdef USE_LIBC_PRIVATES if (0 != &__libc_ia64_register_backing_store_base && 0 != __libc_ia64_register_backing_store_base) { /* Glibc 2.2.4 has a bug such that for dynamically linked */ /* executables __libc_ia64_register_backing_store_base is */ /* defined but uninitialized during constructor calls. */ /* Hence we check for both nonzero address and value. */ return __libc_ia64_register_backing_store_base; } # endif result = backing_store_base_from_proc(); if (0 == result) { result = GC_find_limit(GC_save_regs_in_stack(), FALSE); /* Now seems to work better than constant displacement */ /* heuristic used in 6.X versions. The latter seems to */ /* fail for 2.6 kernels. */ } return result; } # endif /* IA64 */ STATIC ptr_t GC_linux_main_stack_base(void) { /* We read the stack base value from /proc/self/stat. We do this */ /* using direct I/O system calls in order to avoid calling malloc */ /* in case REDIRECT_MALLOC is defined. */ # ifndef STAT_READ /* Also defined in pthread_support.c. */ # define STAT_BUF_SIZE 4096 # define STAT_READ read # endif /* Should probably call the real read, if read is wrapped. */ char stat_buf[STAT_BUF_SIZE]; int f; word result; int i, buf_offset = 0, len; /* First try the easy way. This should work for glibc 2.2 */ /* This fails in a prelinked ("prelink" command) executable */ /* since the correct value of __libc_stack_end never */ /* becomes visible to us. The second test works around */ /* this. */ # ifdef USE_LIBC_PRIVATES if (0 != &__libc_stack_end && 0 != __libc_stack_end ) { # if defined(IA64) /* Some versions of glibc set the address 16 bytes too */ /* low while the initialization code is running. */ if (((word)__libc_stack_end & 0xfff) + 0x10 < 0x1000) { return __libc_stack_end + 0x10; } /* Otherwise it's not safe to add 16 bytes and we fall */ /* back to using /proc. */ # elif defined(SPARC) /* Older versions of glibc for 64-bit SPARC do not set this */ /* variable correctly, it gets set to either zero or one. */ if (__libc_stack_end != (ptr_t) (unsigned long)0x1) return __libc_stack_end; # else return __libc_stack_end; # endif } # endif f = open("/proc/self/stat", O_RDONLY); if (f < 0) ABORT("Couldn't read /proc/self/stat"); len = STAT_READ(f, stat_buf, STAT_BUF_SIZE); close(f); /* Skip the required number of fields. This number is hopefully */ /* constant across all Linux implementations. */ for (i = 0; i < STAT_SKIP; ++i) { while (buf_offset < len && isspace(stat_buf[buf_offset++])) { /* empty */ } while (buf_offset < len && !isspace(stat_buf[buf_offset++])) { /* empty */ } } /* Skip spaces. */ while (buf_offset < len && isspace(stat_buf[buf_offset])) { buf_offset++; } /* Find the end of the number and cut the buffer there. */ for (i = 0; buf_offset + i < len; i++) { if (!isdigit(stat_buf[buf_offset + i])) break; } if (buf_offset + i >= len) ABORT("Could not parse /proc/self/stat"); stat_buf[buf_offset + i] = '\0'; result = (word)STRTOULL(&stat_buf[buf_offset], NULL, 10); if (result < 0x100000 || (result & (sizeof(word) - 1)) != 0) ABORT("Absurd stack bottom value"); return (ptr_t)result; } #endif /* LINUX_STACKBOTTOM */ #ifdef FREEBSD_STACKBOTTOM /* This uses an undocumented sysctl call, but at least one expert */ /* believes it will stay. */ # include # include # include STATIC ptr_t GC_freebsd_main_stack_base(void) { int nm[2] = {CTL_KERN, KERN_USRSTACK}; ptr_t base; size_t len = sizeof(ptr_t); int r = sysctl(nm, 2, &base, &len, NULL, 0); if (r) ABORT("Error getting main stack base"); return base; } #endif /* FREEBSD_STACKBOTTOM */ #if defined(ECOS) || defined(NOSYS) ptr_t GC_get_main_stack_base(void) { return STACKBOTTOM; } # define GET_MAIN_STACKBASE_SPECIAL #elif defined(SYMBIAN) extern int GC_get_main_symbian_stack_base(void); ptr_t GC_get_main_stack_base(void) { return (ptr_t)GC_get_main_symbian_stack_base(); } # define GET_MAIN_STACKBASE_SPECIAL #elif !defined(BEOS) && !defined(AMIGA) && !defined(OS2) \ && !defined(MSWIN32) && !defined(MSWINCE) && !defined(CYGWIN32) \ && !defined(GC_OPENBSD_THREADS) \ && (!defined(GC_SOLARIS_THREADS) || defined(_STRICT_STDC)) # if defined(LINUX) && defined(USE_GET_STACKBASE_FOR_MAIN) # include # elif defined(DARWIN) && !defined(NO_PTHREAD_GET_STACKADDR_NP) /* We could use pthread_get_stackaddr_np even in case of a */ /* single-threaded gclib (there is no -lpthread on Darwin). */ # include # undef STACKBOTTOM # define STACKBOTTOM (ptr_t)pthread_get_stackaddr_np(pthread_self()) # endif ptr_t GC_get_main_stack_base(void) { ptr_t result; # if defined(LINUX) && !defined(NO_PTHREAD_GETATTR_NP) \ && (defined(USE_GET_STACKBASE_FOR_MAIN) \ || (defined(THREADS) && !defined(REDIRECT_MALLOC))) pthread_attr_t attr; void *stackaddr; size_t size; if (pthread_getattr_np(pthread_self(), &attr) == 0) { if (pthread_attr_getstack(&attr, &stackaddr, &size) == 0 && stackaddr != NULL) { (void)pthread_attr_destroy(&attr); # ifdef STACK_GROWS_DOWN stackaddr = (char *)stackaddr + size; # endif return (ptr_t)stackaddr; } (void)pthread_attr_destroy(&attr); } WARN("pthread_getattr_np or pthread_attr_getstack failed" " for main thread\n", 0); # endif # ifdef STACKBOTTOM result = STACKBOTTOM; # else # define STACKBOTTOM_ALIGNMENT_M1 ((word)STACK_GRAN - 1) # ifdef HEURISTIC1 # ifdef STACK_GROWS_DOWN result = (ptr_t)(((word)GC_approx_sp() + STACKBOTTOM_ALIGNMENT_M1) & ~STACKBOTTOM_ALIGNMENT_M1); # else result = (ptr_t)((word)GC_approx_sp() & ~STACKBOTTOM_ALIGNMENT_M1); # endif # endif /* HEURISTIC1 */ # ifdef LINUX_STACKBOTTOM result = GC_linux_main_stack_base(); # endif # ifdef FREEBSD_STACKBOTTOM result = GC_freebsd_main_stack_base(); # endif # ifdef HEURISTIC2 { ptr_t sp = GC_approx_sp(); # ifdef STACK_GROWS_DOWN result = GC_find_limit(sp, TRUE); # ifdef HEURISTIC2_LIMIT if ((word)result > (word)HEURISTIC2_LIMIT && (word)sp < (word)HEURISTIC2_LIMIT) { result = HEURISTIC2_LIMIT; } # endif # else result = GC_find_limit(sp, FALSE); # ifdef HEURISTIC2_LIMIT if ((word)result < (word)HEURISTIC2_LIMIT && (word)sp > (word)HEURISTIC2_LIMIT) { result = HEURISTIC2_LIMIT; } # endif # endif } # endif /* HEURISTIC2 */ # ifdef STACK_GROWS_DOWN if (result == 0) result = (ptr_t)(signed_word)(-sizeof(ptr_t)); # endif # endif GC_ASSERT((word)GC_approx_sp() HOTTER_THAN (word)result); return(result); } # define GET_MAIN_STACKBASE_SPECIAL #endif /* !AMIGA, !BEOS, !OPENBSD, !OS2, !Windows */ #if (defined(GC_LINUX_THREADS) || defined(PLATFORM_ANDROID)) \ && !defined(NO_PTHREAD_GETATTR_NP) # include /* extern int pthread_getattr_np(pthread_t, pthread_attr_t *); */ GC_API int GC_CALL GC_get_stack_base(struct GC_stack_base *b) { pthread_attr_t attr; size_t size; # ifdef IA64 DCL_LOCK_STATE; # endif if (pthread_getattr_np(pthread_self(), &attr) != 0) { WARN("pthread_getattr_np failed\n", 0); return GC_UNIMPLEMENTED; } if (pthread_attr_getstack(&attr, &(b -> mem_base), &size) != 0) { ABORT("pthread_attr_getstack failed"); } (void)pthread_attr_destroy(&attr); # ifdef STACK_GROWS_DOWN b -> mem_base = (char *)(b -> mem_base) + size; # endif # ifdef IA64 /* We could try backing_store_base_from_proc, but that's safe */ /* only if no mappings are being asynchronously created. */ /* Subtracting the size from the stack base doesn't work for at */ /* least the main thread. */ LOCK(); { IF_CANCEL(int cancel_state;) ptr_t bsp; ptr_t next_stack; DISABLE_CANCEL(cancel_state); bsp = GC_save_regs_in_stack(); next_stack = GC_greatest_stack_base_below(bsp); if (0 == next_stack) { b -> reg_base = GC_find_limit(bsp, FALSE); } else { /* Avoid walking backwards into preceding memory stack and */ /* growing it. */ b -> reg_base = GC_find_limit_with_bound(bsp, FALSE, next_stack); } RESTORE_CANCEL(cancel_state); } UNLOCK(); # endif return GC_SUCCESS; } # define HAVE_GET_STACK_BASE #endif /* GC_LINUX_THREADS */ #if defined(GC_DARWIN_THREADS) && !defined(NO_PTHREAD_GET_STACKADDR_NP) # include GC_API int GC_CALL GC_get_stack_base(struct GC_stack_base *b) { /* pthread_get_stackaddr_np() should return stack bottom (highest */ /* stack address plus 1). */ b->mem_base = pthread_get_stackaddr_np(pthread_self()); GC_ASSERT((word)GC_approx_sp() HOTTER_THAN (word)b->mem_base); return GC_SUCCESS; } # define HAVE_GET_STACK_BASE #endif /* GC_DARWIN_THREADS */ #ifdef GC_OPENBSD_THREADS # include # include # include /* Find the stack using pthread_stackseg_np(). */ GC_API int GC_CALL GC_get_stack_base(struct GC_stack_base *sb) { stack_t stack; if (pthread_stackseg_np(pthread_self(), &stack)) ABORT("pthread_stackseg_np(self) failed"); sb->mem_base = stack.ss_sp; return GC_SUCCESS; } # define HAVE_GET_STACK_BASE #endif /* GC_OPENBSD_THREADS */ #if defined(GC_SOLARIS_THREADS) && !defined(_STRICT_STDC) # include # include # include /* These variables are used to cache ss_sp value for the primordial */ /* thread (it's better not to call thr_stksegment() twice for this */ /* thread - see JDK bug #4352906). */ static pthread_t stackbase_main_self = 0; /* 0 means stackbase_main_ss_sp value is unset. */ static void *stackbase_main_ss_sp = NULL; GC_API int GC_CALL GC_get_stack_base(struct GC_stack_base *b) { stack_t s; pthread_t self = pthread_self(); if (self == stackbase_main_self) { /* If the client calls GC_get_stack_base() from the main thread */ /* then just return the cached value. */ b -> mem_base = stackbase_main_ss_sp; GC_ASSERT(b -> mem_base != NULL); return GC_SUCCESS; } if (thr_stksegment(&s)) { /* According to the manual, the only failure error code returned */ /* is EAGAIN meaning "the information is not available due to the */ /* thread is not yet completely initialized or it is an internal */ /* thread" - this shouldn't happen here. */ ABORT("thr_stksegment failed"); } /* s.ss_sp holds the pointer to the stack bottom. */ GC_ASSERT((word)GC_approx_sp() HOTTER_THAN (word)s.ss_sp); if (!stackbase_main_self && thr_main() != 0) { /* Cache the stack base value for the primordial thread (this */ /* is done during GC_init, so there is no race). */ stackbase_main_ss_sp = s.ss_sp; stackbase_main_self = self; } b -> mem_base = s.ss_sp; return GC_SUCCESS; } # define HAVE_GET_STACK_BASE #endif /* GC_SOLARIS_THREADS */ #ifdef GC_RTEMS_PTHREADS GC_API int GC_CALL GC_get_stack_base(struct GC_stack_base *sb) { sb->mem_base = rtems_get_stack_bottom(); return GC_SUCCESS; } # define HAVE_GET_STACK_BASE #endif /* GC_RTEMS_PTHREADS */ #ifndef HAVE_GET_STACK_BASE # ifdef NEED_FIND_LIMIT /* Retrieve stack base. */ /* Using the GC_find_limit version is risky. */ /* On IA64, for example, there is no guard page between the */ /* stack of one thread and the register backing store of the */ /* next. Thus this is likely to identify way too large a */ /* "stack" and thus at least result in disastrous performance. */ /* FIXME - Implement better strategies here. */ GC_API int GC_CALL GC_get_stack_base(struct GC_stack_base *b) { IF_CANCEL(int cancel_state;) DCL_LOCK_STATE; LOCK(); DISABLE_CANCEL(cancel_state); /* May be unnecessary? */ # ifdef STACK_GROWS_DOWN b -> mem_base = GC_find_limit(GC_approx_sp(), TRUE); # ifdef IA64 b -> reg_base = GC_find_limit(GC_save_regs_in_stack(), FALSE); # endif # else b -> mem_base = GC_find_limit(GC_approx_sp(), FALSE); # endif RESTORE_CANCEL(cancel_state); UNLOCK(); return GC_SUCCESS; } # else GC_API int GC_CALL GC_get_stack_base( struct GC_stack_base *b GC_ATTR_UNUSED) { # if defined(GET_MAIN_STACKBASE_SPECIAL) && !defined(THREADS) \ && !defined(IA64) b->mem_base = GC_get_main_stack_base(); return GC_SUCCESS; # else return GC_UNIMPLEMENTED; # endif } # endif /* !NEED_FIND_LIMIT */ #endif /* !HAVE_GET_STACK_BASE */ #ifndef GET_MAIN_STACKBASE_SPECIAL /* This is always called from the main thread. Default implementation. */ ptr_t GC_get_main_stack_base(void) { struct GC_stack_base sb; if (GC_get_stack_base(&sb) != GC_SUCCESS) ABORT("GC_get_stack_base failed"); GC_ASSERT((word)GC_approx_sp() HOTTER_THAN (word)sb.mem_base); return (ptr_t)sb.mem_base; } #endif /* !GET_MAIN_STACKBASE_SPECIAL */ /* Register static data segment(s) as roots. If more data segments are */ /* added later then they need to be registered at that point (as we do */ /* with SunOS dynamic loading), or GC_mark_roots needs to check for */ /* them (as we do with PCR). Called with allocator lock held. */ # ifdef OS2 void GC_register_data_segments(void) { PTIB ptib; PPIB ppib; HMODULE module_handle; # define PBUFSIZ 512 UCHAR path[PBUFSIZ]; FILE * myexefile; struct exe_hdr hdrdos; /* MSDOS header. */ struct e32_exe hdr386; /* Real header for my executable */ struct o32_obj seg; /* Current segment */ int nsegs; if (DosGetInfoBlocks(&ptib, &ppib) != NO_ERROR) { ABORT("DosGetInfoBlocks failed"); } module_handle = ppib -> pib_hmte; if (DosQueryModuleName(module_handle, PBUFSIZ, path) != NO_ERROR) { ABORT("DosQueryModuleName failed"); } myexefile = fopen(path, "rb"); if (myexefile == 0) { ABORT_ARG1("Failed to open executable", ": %s", path); } if (fread((char *)(&hdrdos), 1, sizeof(hdrdos), myexefile) < sizeof(hdrdos)) { ABORT_ARG1("Could not read MSDOS header", " from: %s", path); } if (E_MAGIC(hdrdos) != EMAGIC) { ABORT_ARG1("Bad DOS magic number", " in file: %s", path); } if (fseek(myexefile, E_LFANEW(hdrdos), SEEK_SET) != 0) { ABORT_ARG1("Bad DOS magic number", " in file: %s", path); } if (fread((char *)(&hdr386), 1, sizeof(hdr386), myexefile) < sizeof(hdr386)) { ABORT_ARG1("Could not read OS/2 header", " from: %s", path); } if (E32_MAGIC1(hdr386) != E32MAGIC1 || E32_MAGIC2(hdr386) != E32MAGIC2) { ABORT_ARG1("Bad OS/2 magic number", " in file: %s", path); } if (E32_BORDER(hdr386) != E32LEBO || E32_WORDER(hdr386) != E32LEWO) { ABORT_ARG1("Bad byte order in executable", " file: %s", path); } if (E32_CPU(hdr386) == E32CPU286) { ABORT_ARG1("GC cannot handle 80286 executables", ": %s", path); } if (fseek(myexefile, E_LFANEW(hdrdos) + E32_OBJTAB(hdr386), SEEK_SET) != 0) { ABORT_ARG1("Seek to object table failed", " in file: %s", path); } for (nsegs = E32_OBJCNT(hdr386); nsegs > 0; nsegs--) { int flags; if (fread((char *)(&seg), 1, sizeof(seg), myexefile) < sizeof(seg)) { ABORT_ARG1("Could not read obj table entry", " from file: %s", path); } flags = O32_FLAGS(seg); if (!(flags & OBJWRITE)) continue; if (!(flags & OBJREAD)) continue; if (flags & OBJINVALID) { GC_err_printf("Object with invalid pages?\n"); continue; } GC_add_roots_inner((ptr_t)O32_BASE(seg), (ptr_t)(O32_BASE(seg)+O32_SIZE(seg)), FALSE); } (void)fclose(myexefile); } # else /* !OS2 */ # if defined(GWW_VDB) # ifndef MEM_WRITE_WATCH # define MEM_WRITE_WATCH 0x200000 # endif # ifndef WRITE_WATCH_FLAG_RESET # define WRITE_WATCH_FLAG_RESET 1 # endif /* Since we can't easily check whether ULONG_PTR and SIZE_T are */ /* defined in Win32 basetsd.h, we define own ULONG_PTR. */ # define GC_ULONG_PTR word typedef UINT (WINAPI * GetWriteWatch_type)( DWORD, PVOID, GC_ULONG_PTR /* SIZE_T */, PVOID *, GC_ULONG_PTR *, PULONG); static GetWriteWatch_type GetWriteWatch_func; static DWORD GetWriteWatch_alloc_flag; # define GC_GWW_AVAILABLE() (GetWriteWatch_func != NULL) static void detect_GetWriteWatch(void) { static GC_bool done; HMODULE hK32; if (done) return; # if defined(MPROTECT_VDB) { char * str = GETENV("GC_USE_GETWRITEWATCH"); # if defined(GC_PREFER_MPROTECT_VDB) if (str == NULL || (*str == '0' && *(str + 1) == '\0')) { /* GC_USE_GETWRITEWATCH is unset or set to "0". */ done = TRUE; /* falling back to MPROTECT_VDB strategy. */ /* This should work as if GWW_VDB is undefined. */ return; } # else if (str != NULL && *str == '0' && *(str + 1) == '\0') { /* GC_USE_GETWRITEWATCH is set "0". */ done = TRUE; /* falling back to MPROTECT_VDB strategy. */ return; } # endif } # endif hK32 = GetModuleHandle(TEXT("kernel32.dll")); if (hK32 != (HMODULE)0 && (GetWriteWatch_func = (GetWriteWatch_type)GetProcAddress(hK32, "GetWriteWatch")) != NULL) { /* Also check whether VirtualAlloc accepts MEM_WRITE_WATCH, */ /* as some versions of kernel32.dll have one but not the */ /* other, making the feature completely broken. */ void * page = VirtualAlloc(NULL, GC_page_size, MEM_WRITE_WATCH | MEM_RESERVE, PAGE_READWRITE); if (page != NULL) { PVOID pages[16]; GC_ULONG_PTR count = 16; DWORD page_size; /* Check that it actually works. In spite of some */ /* documentation it actually seems to exist on W2K. */ /* This test may be unnecessary, but ... */ if (GetWriteWatch_func(WRITE_WATCH_FLAG_RESET, page, GC_page_size, pages, &count, &page_size) != 0) { /* GetWriteWatch always fails. */ GetWriteWatch_func = NULL; } else { GetWriteWatch_alloc_flag = MEM_WRITE_WATCH; } VirtualFree(page, 0 /* dwSize */, MEM_RELEASE); } else { /* GetWriteWatch will be useless. */ GetWriteWatch_func = NULL; } } # ifndef SMALL_CONFIG if (GetWriteWatch_func == NULL) { GC_COND_LOG_PRINTF("Did not find a usable GetWriteWatch()\n"); } else { GC_COND_LOG_PRINTF("Using GetWriteWatch()\n"); } # endif done = TRUE; } # else # define GetWriteWatch_alloc_flag 0 # endif /* !GWW_VDB */ # if defined(MSWIN32) || defined(MSWINCE) || defined(CYGWIN32) # ifdef MSWIN32 /* Unfortunately, we have to handle win32s very differently from NT, */ /* Since VirtualQuery has very different semantics. In particular, */ /* under win32s a VirtualQuery call on an unmapped page returns an */ /* invalid result. Under NT, GC_register_data_segments is a no-op */ /* and all real work is done by GC_register_dynamic_libraries. Under */ /* win32s, we cannot find the data segments associated with dll's. */ /* We register the main data segment here. */ GC_INNER GC_bool GC_no_win32_dlls = FALSE; /* This used to be set for gcc, to avoid dealing with */ /* the structured exception handling issues. But we now have */ /* assembly code to do that right. */ GC_INNER GC_bool GC_wnt = FALSE; /* This is a Windows NT derivative, i.e. NT, W2K, XP or later. */ GC_INNER void GC_init_win32(void) { /* Set GC_wnt. If we're running under win32s, assume that no DLLs */ /* will be loaded. I doubt anyone still runs win32s, but... */ DWORD v = GetVersion(); GC_wnt = !(v & 0x80000000); GC_no_win32_dlls |= ((!GC_wnt) && (v & 0xff) <= 3); # ifdef USE_MUNMAP if (GC_no_win32_dlls) { /* Turn off unmapping for safety (since may not work well with */ /* GlobalAlloc). */ GC_unmap_threshold = 0; } # endif } /* Return the smallest address a such that VirtualQuery */ /* returns correct results for all addresses between a and start. */ /* Assumes VirtualQuery returns correct information for start. */ STATIC ptr_t GC_least_described_address(ptr_t start) { MEMORY_BASIC_INFORMATION buf; size_t result; LPVOID limit; ptr_t p; LPVOID q; limit = GC_sysinfo.lpMinimumApplicationAddress; p = (ptr_t)((word)start & ~(GC_page_size - 1)); for (;;) { q = (LPVOID)(p - GC_page_size); if ((word)q > (word)p /* underflow */ || (word)q < (word)limit) break; result = VirtualQuery(q, &buf, sizeof(buf)); if (result != sizeof(buf) || buf.AllocationBase == 0) break; p = (ptr_t)(buf.AllocationBase); } return p; } # endif /* MSWIN32 */ # ifndef REDIRECT_MALLOC /* We maintain a linked list of AllocationBase values that we know */ /* correspond to malloc heap sections. Currently this is only called */ /* during a GC. But there is some hope that for long running */ /* programs we will eventually see most heap sections. */ /* In the long run, it would be more reliable to occasionally walk */ /* the malloc heap with HeapWalk on the default heap. But that */ /* apparently works only for NT-based Windows. */ STATIC size_t GC_max_root_size = 100000; /* Appr. largest root size. */ # ifdef USE_WINALLOC /* In the long run, a better data structure would also be nice ... */ STATIC struct GC_malloc_heap_list { void * allocation_base; struct GC_malloc_heap_list *next; } *GC_malloc_heap_l = 0; /* Is p the base of one of the malloc heap sections we already know */ /* about? */ STATIC GC_bool GC_is_malloc_heap_base(ptr_t p) { struct GC_malloc_heap_list *q = GC_malloc_heap_l; while (0 != q) { if (q -> allocation_base == p) return TRUE; q = q -> next; } return FALSE; } STATIC void *GC_get_allocation_base(void *p) { MEMORY_BASIC_INFORMATION buf; size_t result = VirtualQuery(p, &buf, sizeof(buf)); if (result != sizeof(buf)) { ABORT("Weird VirtualQuery result"); } return buf.AllocationBase; } GC_INNER void GC_add_current_malloc_heap(void) { struct GC_malloc_heap_list *new_l = malloc(sizeof(struct GC_malloc_heap_list)); void * candidate = GC_get_allocation_base(new_l); if (new_l == 0) return; if (GC_is_malloc_heap_base(candidate)) { /* Try a little harder to find malloc heap. */ size_t req_size = 10000; do { void *p = malloc(req_size); if (0 == p) { free(new_l); return; } candidate = GC_get_allocation_base(p); free(p); req_size *= 2; } while (GC_is_malloc_heap_base(candidate) && req_size < GC_max_root_size/10 && req_size < 500000); if (GC_is_malloc_heap_base(candidate)) { free(new_l); return; } } GC_COND_LOG_PRINTF("Found new system malloc AllocationBase at %p\n", candidate); new_l -> allocation_base = candidate; new_l -> next = GC_malloc_heap_l; GC_malloc_heap_l = new_l; } # endif /* USE_WINALLOC */ # endif /* !REDIRECT_MALLOC */ STATIC word GC_n_heap_bases = 0; /* See GC_heap_bases. */ /* Is p the start of either the malloc heap, or of one of our */ /* heap sections? */ GC_INNER GC_bool GC_is_heap_base(ptr_t p) { unsigned i; # ifndef REDIRECT_MALLOC if (GC_root_size > GC_max_root_size) GC_max_root_size = GC_root_size; # ifdef USE_WINALLOC if (GC_is_malloc_heap_base(p)) return TRUE; # endif # endif for (i = 0; i < GC_n_heap_bases; i++) { if (GC_heap_bases[i] == p) return TRUE; } return FALSE; } #ifdef MSWIN32 STATIC void GC_register_root_section(ptr_t static_root) { MEMORY_BASIC_INFORMATION buf; size_t result; DWORD protect; LPVOID p; char * base; char * limit, * new_limit; if (!GC_no_win32_dlls) return; p = base = limit = GC_least_described_address(static_root); while ((word)p < (word)GC_sysinfo.lpMaximumApplicationAddress) { result = VirtualQuery(p, &buf, sizeof(buf)); if (result != sizeof(buf) || buf.AllocationBase == 0 || GC_is_heap_base(buf.AllocationBase)) break; new_limit = (char *)p + buf.RegionSize; protect = buf.Protect; if (buf.State == MEM_COMMIT && is_writable(protect)) { if ((char *)p == limit) { limit = new_limit; } else { if (base != limit) GC_add_roots_inner(base, limit, FALSE); base = p; limit = new_limit; } } if ((word)p > (word)new_limit /* overflow */) break; p = (LPVOID)new_limit; } if (base != limit) GC_add_roots_inner(base, limit, FALSE); } #endif /* MSWIN32 */ void GC_register_data_segments(void) { # ifdef MSWIN32 GC_register_root_section((ptr_t)&GC_pages_executable); /* any other GC global variable would fit too. */ # endif } # else /* !OS2 && !Windows */ # if (defined(SVR4) || defined(AUX) || defined(DGUX) \ || (defined(LINUX) && defined(SPARC))) && !defined(PCR) ptr_t GC_SysVGetDataStart(size_t max_page_size, ptr_t etext_addr) { word text_end = ((word)(etext_addr) + sizeof(word) - 1) & ~(sizeof(word) - 1); /* etext rounded to word boundary */ word next_page = ((text_end + (word)max_page_size - 1) & ~((word)max_page_size - 1)); word page_offset = (text_end & ((word)max_page_size - 1)); char * volatile result = (char *)(next_page + page_offset); /* Note that this isn't equivalent to just adding */ /* max_page_size to &etext if &etext is at a page boundary */ GC_setup_temporary_fault_handler(); if (SETJMP(GC_jmp_buf) == 0) { /* Try writing to the address. */ *result = *result; GC_reset_fault_handler(); } else { GC_reset_fault_handler(); /* We got here via a longjmp. The address is not readable. */ /* This is known to happen under Solaris 2.4 + gcc, which place */ /* string constants in the text segment, but after etext. */ /* Use plan B. Note that we now know there is a gap between */ /* text and data segments, so plan A bought us something. */ result = (char *)GC_find_limit((ptr_t)(DATAEND), FALSE); } return((ptr_t)result); } # endif # if defined(FREEBSD) && !defined(PCR) && (defined(I386) || defined(X86_64) \ || defined(powerpc) || defined(__powerpc__)) /* Its unclear whether this should be identical to the above, or */ /* whether it should apply to non-X86 architectures. */ /* For now we don't assume that there is always an empty page after */ /* etext. But in some cases there actually seems to be slightly more. */ /* This also deals with holes between read-only data and writable data. */ ptr_t GC_FreeBSDGetDataStart(size_t max_page_size, ptr_t etext_addr) { word text_end = ((word)(etext_addr) + sizeof(word) - 1) & ~(sizeof(word) - 1); /* etext rounded to word boundary */ volatile word next_page = (text_end + (word)max_page_size - 1) & ~((word)max_page_size - 1); volatile ptr_t result = (ptr_t)text_end; GC_setup_temporary_fault_handler(); if (SETJMP(GC_jmp_buf) == 0) { /* Try reading at the address. */ /* This should happen before there is another thread. */ for (; next_page < (word)(DATAEND); next_page += (word)max_page_size) *(volatile char *)next_page; GC_reset_fault_handler(); } else { GC_reset_fault_handler(); /* As above, we go to plan B */ result = GC_find_limit((ptr_t)(DATAEND), FALSE); } return(result); } # endif /* FREEBSD */ #ifdef AMIGA # define GC_AMIGA_DS # include "extra/AmigaOS.c" # undef GC_AMIGA_DS #elif defined(OPENBSD) /* Depending on arch alignment, there can be multiple holes */ /* between DATASTART and DATAEND. Scan in DATASTART .. DATAEND */ /* and register each region. */ void GC_register_data_segments(void) { ptr_t region_start = DATASTART; ptr_t region_end; for (;;) { region_end = GC_find_limit_openbsd(region_start, DATAEND); GC_add_roots_inner(region_start, region_end, FALSE); if ((word)region_end >= (word)(DATAEND)) break; region_start = GC_skip_hole_openbsd(region_end, DATAEND); } } # else /* !OS2 && !Windows && !AMIGA && !OPENBSD */ void GC_register_data_segments(void) { # if !defined(PCR) && !defined(MACOS) # if defined(REDIRECT_MALLOC) && defined(GC_SOLARIS_THREADS) /* As of Solaris 2.3, the Solaris threads implementation */ /* allocates the data structure for the initial thread with */ /* sbrk at process startup. It needs to be scanned, so that */ /* we don't lose some malloc allocated data structures */ /* hanging from it. We're on thin ice here ... */ extern caddr_t sbrk(int); GC_ASSERT(DATASTART); { ptr_t p = (ptr_t)sbrk(0); if ((word)(DATASTART) < (word)p) GC_add_roots_inner(DATASTART, p, FALSE); } # else GC_ASSERT(DATASTART); GC_add_roots_inner(DATASTART, (ptr_t)(DATAEND), FALSE); # if defined(DATASTART2) GC_add_roots_inner(DATASTART2, (ptr_t)(DATAEND2), FALSE); # endif # endif # endif # if defined(MACOS) { # if defined(THINK_C) extern void* GC_MacGetDataStart(void); /* globals begin above stack and end at a5. */ GC_add_roots_inner((ptr_t)GC_MacGetDataStart(), (ptr_t)LMGetCurrentA5(), FALSE); # else # if defined(__MWERKS__) # if !__POWERPC__ extern void* GC_MacGetDataStart(void); /* MATTHEW: Function to handle Far Globals (CW Pro 3) */ # if __option(far_data) extern void* GC_MacGetDataEnd(void); # endif /* globals begin above stack and end at a5. */ GC_add_roots_inner((ptr_t)GC_MacGetDataStart(), (ptr_t)LMGetCurrentA5(), FALSE); /* MATTHEW: Handle Far Globals */ # if __option(far_data) /* Far globals follow he QD globals: */ GC_add_roots_inner((ptr_t)LMGetCurrentA5(), (ptr_t)GC_MacGetDataEnd(), FALSE); # endif # else extern char __data_start__[], __data_end__[]; GC_add_roots_inner((ptr_t)&__data_start__, (ptr_t)&__data_end__, FALSE); # endif /* __POWERPC__ */ # endif /* __MWERKS__ */ # endif /* !THINK_C */ } # endif /* MACOS */ /* Dynamic libraries are added at every collection, since they may */ /* change. */ } # endif /* !AMIGA */ # endif /* !MSWIN32 && !MSWINCE */ # endif /* !OS2 */ /* * Auxiliary routines for obtaining memory from OS. */ # if !defined(OS2) && !defined(PCR) && !defined(AMIGA) \ && !defined(USE_WINALLOC) && !defined(MACOS) && !defined(DOS4GW) \ && !defined(NONSTOP) && !defined(SN_TARGET_PS3) && !defined(RTEMS) \ && !defined(__CC_ARM) # define SBRK_ARG_T ptrdiff_t #if defined(MMAP_SUPPORTED) #ifdef USE_MMAP_FIXED # define GC_MMAP_FLAGS MAP_FIXED | MAP_PRIVATE /* Seems to yield better performance on Solaris 2, but can */ /* be unreliable if something is already mapped at the address. */ #else # define GC_MMAP_FLAGS MAP_PRIVATE #endif #ifdef USE_MMAP_ANON # define zero_fd -1 # if defined(MAP_ANONYMOUS) # define OPT_MAP_ANON MAP_ANONYMOUS # else # define OPT_MAP_ANON MAP_ANON # endif #else static int zero_fd; # define OPT_MAP_ANON 0 #endif #ifndef HEAP_START # define HEAP_START ((ptr_t)0) #endif #ifdef SYMBIAN extern char* GC_get_private_path_and_zero_file(void); #endif STATIC ptr_t GC_unix_mmap_get_mem(word bytes) { void *result; static ptr_t last_addr = HEAP_START; # ifndef USE_MMAP_ANON static GC_bool initialized = FALSE; if (!EXPECT(initialized, TRUE)) { # ifdef SYMBIAN char* path = GC_get_private_path_and_zero_file(); zero_fd = open(path, O_RDWR | O_CREAT, 0666); free(path); # else zero_fd = open("/dev/zero", O_RDONLY); # endif if (zero_fd == -1) ABORT("Could not open /dev/zero"); fcntl(zero_fd, F_SETFD, FD_CLOEXEC); initialized = TRUE; } # endif if (bytes & (GC_page_size - 1)) ABORT("Bad GET_MEM arg"); result = mmap(last_addr, bytes, (PROT_READ | PROT_WRITE) | (GC_pages_executable ? PROT_EXEC : 0), GC_MMAP_FLAGS | OPT_MAP_ANON, zero_fd, 0/* offset */); # undef IGNORE_PAGES_EXECUTABLE if (result == MAP_FAILED) return(0); last_addr = (ptr_t)ROUNDUP_PAGESIZE((word)result + bytes); # if !defined(LINUX) if (last_addr == 0) { /* Oops. We got the end of the address space. This isn't */ /* usable by arbitrary C code, since one-past-end pointers */ /* don't work, so we discard it and try again. */ munmap(result, (size_t)(-GC_page_size) - (size_t)result); /* Leave last page mapped, so we can't repeat. */ return GC_unix_mmap_get_mem(bytes); } # else GC_ASSERT(last_addr != 0); # endif if (((word)result % HBLKSIZE) != 0) ABORT( "GC_unix_get_mem: Memory returned by mmap is not aligned to HBLKSIZE."); return((ptr_t)result); } # endif /* MMAP_SUPPORTED */ #if defined(USE_MMAP) ptr_t GC_unix_get_mem(word bytes) { return GC_unix_mmap_get_mem(bytes); } #else /* !USE_MMAP */ STATIC ptr_t GC_unix_sbrk_get_mem(word bytes) { ptr_t result; # ifdef IRIX5 /* Bare sbrk isn't thread safe. Play by malloc rules. */ /* The equivalent may be needed on other systems as well. */ __LOCK_MALLOC(); # endif { ptr_t cur_brk = (ptr_t)sbrk(0); SBRK_ARG_T lsbs = (word)cur_brk & (GC_page_size-1); if ((SBRK_ARG_T)bytes < 0) { result = 0; /* too big */ goto out; } if (lsbs != 0) { if((ptr_t)sbrk(GC_page_size - lsbs) == (ptr_t)(-1)) { result = 0; goto out; } } # ifdef ADD_HEAP_GUARD_PAGES /* This is useful for catching severe memory overwrite problems that */ /* span heap sections. It shouldn't otherwise be turned on. */ { ptr_t guard = (ptr_t)sbrk((SBRK_ARG_T)GC_page_size); if (mprotect(guard, GC_page_size, PROT_NONE) != 0) ABORT("ADD_HEAP_GUARD_PAGES: mprotect failed"); } # endif /* ADD_HEAP_GUARD_PAGES */ result = (ptr_t)sbrk((SBRK_ARG_T)bytes); if (result == (ptr_t)(-1)) result = 0; } out: # ifdef IRIX5 __UNLOCK_MALLOC(); # endif return(result); } ptr_t GC_unix_get_mem(word bytes) { # if defined(MMAP_SUPPORTED) /* By default, we try both sbrk and mmap, in that order. */ static GC_bool sbrk_failed = FALSE; ptr_t result = 0; if (!sbrk_failed) result = GC_unix_sbrk_get_mem(bytes); if (0 == result) { sbrk_failed = TRUE; result = GC_unix_mmap_get_mem(bytes); } if (0 == result) { /* Try sbrk again, in case sbrk memory became available. */ result = GC_unix_sbrk_get_mem(bytes); } return result; # else /* !MMAP_SUPPORTED */ return GC_unix_sbrk_get_mem(bytes); # endif } #endif /* !USE_MMAP */ # endif /* UN*X */ # ifdef OS2 void * os2_alloc(size_t bytes) { void * result; if (DosAllocMem(&result, bytes, (PAG_READ | PAG_WRITE | PAG_COMMIT) | (GC_pages_executable ? PAG_EXECUTE : 0)) != NO_ERROR) { return(0); } /* FIXME: What's the purpose of this recursion? (Probably, if */ /* DosAllocMem returns memory at 0 address then just retry once.) */ if (result == 0) return(os2_alloc(bytes)); return(result); } # endif /* OS2 */ #ifdef MSWINCE ptr_t GC_wince_get_mem(word bytes) { ptr_t result = 0; /* initialized to prevent warning. */ word i; bytes = ROUNDUP_PAGESIZE(bytes); /* Try to find reserved, uncommitted pages */ for (i = 0; i < GC_n_heap_bases; i++) { if (((word)(-(signed_word)GC_heap_lengths[i]) & (GC_sysinfo.dwAllocationGranularity-1)) >= bytes) { result = GC_heap_bases[i] + GC_heap_lengths[i]; break; } } if (i == GC_n_heap_bases) { /* Reserve more pages */ word res_bytes = (bytes + GC_sysinfo.dwAllocationGranularity-1) & ~(GC_sysinfo.dwAllocationGranularity-1); /* If we ever support MPROTECT_VDB here, we will probably need to */ /* ensure that res_bytes is strictly > bytes, so that VirtualProtect */ /* never spans regions. It seems to be OK for a VirtualFree */ /* argument to span regions, so we should be OK for now. */ result = (ptr_t) VirtualAlloc(NULL, res_bytes, MEM_RESERVE | MEM_TOP_DOWN, GC_pages_executable ? PAGE_EXECUTE_READWRITE : PAGE_READWRITE); if (HBLKDISPL(result) != 0) ABORT("Bad VirtualAlloc result"); /* If I read the documentation correctly, this can */ /* only happen if HBLKSIZE > 64k or not a power of 2. */ if (GC_n_heap_bases >= MAX_HEAP_SECTS) ABORT("Too many heap sections"); if (result == NULL) return NULL; GC_heap_bases[GC_n_heap_bases] = result; GC_heap_lengths[GC_n_heap_bases] = 0; GC_n_heap_bases++; } /* Commit pages */ result = (ptr_t) VirtualAlloc(result, bytes, MEM_COMMIT, GC_pages_executable ? PAGE_EXECUTE_READWRITE : PAGE_READWRITE); # undef IGNORE_PAGES_EXECUTABLE if (result != NULL) { if (HBLKDISPL(result) != 0) ABORT("Bad VirtualAlloc result"); GC_heap_lengths[i] += bytes; } return(result); } #elif defined(USE_WINALLOC) || defined(CYGWIN32) # ifdef USE_GLOBAL_ALLOC # define GLOBAL_ALLOC_TEST 1 # else # define GLOBAL_ALLOC_TEST GC_no_win32_dlls # endif # if defined(GC_USE_MEM_TOP_DOWN) && defined(USE_WINALLOC) DWORD GC_mem_top_down = MEM_TOP_DOWN; /* Use GC_USE_MEM_TOP_DOWN for better 64-bit */ /* testing. Otherwise all addresses tend to */ /* end up in first 4GB, hiding bugs. */ # else # define GC_mem_top_down 0 # endif /* !GC_USE_MEM_TOP_DOWN */ ptr_t GC_win32_get_mem(word bytes) { ptr_t result; # ifndef USE_WINALLOC result = GC_unix_get_mem(bytes); # else # ifdef MSWIN32 if (GLOBAL_ALLOC_TEST) { /* VirtualAlloc doesn't like PAGE_EXECUTE_READWRITE. */ /* There are also unconfirmed rumors of other */ /* problems, so we dodge the issue. */ result = (ptr_t) GlobalAlloc(0, bytes + HBLKSIZE); result = (ptr_t)(((word)result + HBLKSIZE - 1) & ~(HBLKSIZE-1)); } else # endif /* else */ { /* VirtualProtect only works on regions returned by a */ /* single VirtualAlloc call. Thus we allocate one */ /* extra page, which will prevent merging of blocks */ /* in separate regions, and eliminate any temptation */ /* to call VirtualProtect on a range spanning regions. */ /* This wastes a small amount of memory, and risks */ /* increased fragmentation. But better alternatives */ /* would require effort. */ # ifdef MPROTECT_VDB /* We can't check for GC_incremental here (because */ /* GC_enable_incremental() might be called some time */ /* later after the GC initialization). */ # ifdef GWW_VDB # define VIRTUAL_ALLOC_PAD (GC_GWW_AVAILABLE() ? 0 : 1) # else # define VIRTUAL_ALLOC_PAD 1 # endif # else # define VIRTUAL_ALLOC_PAD 0 # endif /* Pass the MEM_WRITE_WATCH only if GetWriteWatch-based */ /* VDBs are enabled and the GetWriteWatch function is */ /* available. Otherwise we waste resources or possibly */ /* cause VirtualAlloc to fail (observed in Windows 2000 */ /* SP2). */ result = (ptr_t) VirtualAlloc(NULL, bytes + VIRTUAL_ALLOC_PAD, GetWriteWatch_alloc_flag | (MEM_COMMIT | MEM_RESERVE) | GC_mem_top_down, GC_pages_executable ? PAGE_EXECUTE_READWRITE : PAGE_READWRITE); # undef IGNORE_PAGES_EXECUTABLE } # endif /* USE_WINALLOC */ if (HBLKDISPL(result) != 0) ABORT("Bad VirtualAlloc result"); /* If I read the documentation correctly, this can */ /* only happen if HBLKSIZE > 64k or not a power of 2. */ if (GC_n_heap_bases >= MAX_HEAP_SECTS) ABORT("Too many heap sections"); if (0 != result) GC_heap_bases[GC_n_heap_bases++] = result; return(result); } GC_API void GC_CALL GC_win32_free_heap(void) { # ifndef CYGWIN32 if (GLOBAL_ALLOC_TEST) # endif { while (GC_n_heap_bases-- > 0) { # ifdef CYGWIN32 /* FIXME: Is it OK to use non-GC free() here? */ # else GlobalFree(GC_heap_bases[GC_n_heap_bases]); # endif GC_heap_bases[GC_n_heap_bases] = 0; } } /* else */ # ifndef CYGWIN32 else { /* Avoiding VirtualAlloc leak. */ while (GC_n_heap_bases > 0) { VirtualFree(GC_heap_bases[--GC_n_heap_bases], 0, MEM_RELEASE); GC_heap_bases[GC_n_heap_bases] = 0; } } # endif } #endif /* USE_WINALLOC || CYGWIN32 */ #ifdef AMIGA # define GC_AMIGA_AM # include "extra/AmigaOS.c" # undef GC_AMIGA_AM #endif #ifdef USE_MUNMAP /* For now, this only works on Win32/WinCE and some Unix-like */ /* systems. If you have something else, don't define */ /* USE_MUNMAP. */ #if !defined(MSWIN32) && !defined(MSWINCE) # include # include # include # include #endif /* Compute a page aligned starting address for the unmap */ /* operation on a block of size bytes starting at start. */ /* Return 0 if the block is too small to make this feasible. */ STATIC ptr_t GC_unmap_start(ptr_t start, size_t bytes) { ptr_t result = (ptr_t)ROUNDUP_PAGESIZE((word)start); if ((word)(result + GC_page_size) > (word)(start + bytes)) return 0; return result; } /* Compute end address for an unmap operation on the indicated */ /* block. */ STATIC ptr_t GC_unmap_end(ptr_t start, size_t bytes) { return (ptr_t)((word)(start + bytes) & ~(GC_page_size - 1)); } /* Under Win32/WinCE we commit (map) and decommit (unmap) */ /* memory using VirtualAlloc and VirtualFree. These functions */ /* work on individual allocations of virtual memory, made */ /* previously using VirtualAlloc with the MEM_RESERVE flag. */ /* The ranges we need to (de)commit may span several of these */ /* allocations; therefore we use VirtualQuery to check */ /* allocation lengths, and split up the range as necessary. */ /* We assume that GC_remap is called on exactly the same range */ /* as a previous call to GC_unmap. It is safe to consistently */ /* round the endpoints in both places. */ GC_INNER void GC_unmap(ptr_t start, size_t bytes) { ptr_t start_addr = GC_unmap_start(start, bytes); ptr_t end_addr = GC_unmap_end(start, bytes); word len = end_addr - start_addr; if (0 == start_addr) return; # ifdef USE_WINALLOC while (len != 0) { MEMORY_BASIC_INFORMATION mem_info; GC_word free_len; if (VirtualQuery(start_addr, &mem_info, sizeof(mem_info)) != sizeof(mem_info)) ABORT("Weird VirtualQuery result"); free_len = (len < mem_info.RegionSize) ? len : mem_info.RegionSize; if (!VirtualFree(start_addr, free_len, MEM_DECOMMIT)) ABORT("VirtualFree failed"); GC_unmapped_bytes += free_len; start_addr += free_len; len -= free_len; } # else /* We immediately remap it to prevent an intervening mmap from */ /* accidentally grabbing the same address space. */ { void * result; result = mmap(start_addr, len, PROT_NONE, MAP_PRIVATE | MAP_FIXED | OPT_MAP_ANON, zero_fd, 0/* offset */); if (result != (void *)start_addr) ABORT("mmap(PROT_NONE) failed"); } GC_unmapped_bytes += len; # endif } GC_INNER void GC_remap(ptr_t start, size_t bytes) { ptr_t start_addr = GC_unmap_start(start, bytes); ptr_t end_addr = GC_unmap_end(start, bytes); word len = end_addr - start_addr; if (0 == start_addr) return; /* FIXME: Handle out-of-memory correctly (at least for Win32) */ # ifdef USE_WINALLOC while (len != 0) { MEMORY_BASIC_INFORMATION mem_info; GC_word alloc_len; ptr_t result; if (VirtualQuery(start_addr, &mem_info, sizeof(mem_info)) != sizeof(mem_info)) ABORT("Weird VirtualQuery result"); alloc_len = (len < mem_info.RegionSize) ? len : mem_info.RegionSize; result = VirtualAlloc(start_addr, alloc_len, MEM_COMMIT, GC_pages_executable ? PAGE_EXECUTE_READWRITE : PAGE_READWRITE); if (result != start_addr) { if (GetLastError() == ERROR_NOT_ENOUGH_MEMORY || GetLastError() == ERROR_OUTOFMEMORY) { ABORT("Not enough memory to process remapping"); } else { ABORT("VirtualAlloc remapping failed"); } } GC_unmapped_bytes -= alloc_len; start_addr += alloc_len; len -= alloc_len; } # else /* It was already remapped with PROT_NONE. */ { # ifdef NACL /* NaCl does not expose mprotect, but mmap should work fine. */ void *mmap_result = mmap(start_addr, len, (PROT_READ | PROT_WRITE) | (GC_pages_executable ? PROT_EXEC : 0), MAP_PRIVATE | MAP_FIXED | OPT_MAP_ANON, zero_fd, 0 /* offset */); if (mmap_result != (void *)start_addr) ABORT("mmap as mprotect failed"); # else if (mprotect(start_addr, len, (PROT_READ | PROT_WRITE) | (GC_pages_executable ? PROT_EXEC : 0)) != 0) { ABORT_ARG3("mprotect remapping failed", " at %p (length %lu), errcode= %d", start_addr, (unsigned long)len, errno); } # endif /* !NACL */ } # undef IGNORE_PAGES_EXECUTABLE GC_unmapped_bytes -= len; # endif } /* Two adjacent blocks have already been unmapped and are about to */ /* be merged. Unmap the whole block. This typically requires */ /* that we unmap a small section in the middle that was not previously */ /* unmapped due to alignment constraints. */ GC_INNER void GC_unmap_gap(ptr_t start1, size_t bytes1, ptr_t start2, size_t bytes2) { ptr_t start1_addr = GC_unmap_start(start1, bytes1); ptr_t end1_addr = GC_unmap_end(start1, bytes1); ptr_t start2_addr = GC_unmap_start(start2, bytes2); ptr_t start_addr = end1_addr; ptr_t end_addr = start2_addr; size_t len; GC_ASSERT(start1 + bytes1 == start2); if (0 == start1_addr) start_addr = GC_unmap_start(start1, bytes1 + bytes2); if (0 == start2_addr) end_addr = GC_unmap_end(start1, bytes1 + bytes2); if (0 == start_addr) return; len = end_addr - start_addr; # ifdef USE_WINALLOC while (len != 0) { MEMORY_BASIC_INFORMATION mem_info; GC_word free_len; if (VirtualQuery(start_addr, &mem_info, sizeof(mem_info)) != sizeof(mem_info)) ABORT("Weird VirtualQuery result"); free_len = (len < mem_info.RegionSize) ? len : mem_info.RegionSize; if (!VirtualFree(start_addr, free_len, MEM_DECOMMIT)) ABORT("VirtualFree failed"); GC_unmapped_bytes += free_len; start_addr += free_len; len -= free_len; } # else if (len != 0) { /* Immediately remap as above. */ void * result; result = mmap(start_addr, len, PROT_NONE, MAP_PRIVATE | MAP_FIXED | OPT_MAP_ANON, zero_fd, 0/* offset */); if (result != (void *)start_addr) ABORT("mmap(PROT_NONE) failed"); } GC_unmapped_bytes += len; # endif } #endif /* USE_MUNMAP */ /* Routine for pushing any additional roots. In THREADS */ /* environment, this is also responsible for marking from */ /* thread stacks. */ #ifndef THREADS GC_push_other_roots_proc GC_push_other_roots = 0; #else /* THREADS */ # ifdef PCR PCR_ERes GC_push_thread_stack(PCR_Th_T *t, PCR_Any dummy) { struct PCR_ThCtl_TInfoRep info; PCR_ERes result; info.ti_stkLow = info.ti_stkHi = 0; result = PCR_ThCtl_GetInfo(t, &info); GC_push_all_stack((ptr_t)(info.ti_stkLow), (ptr_t)(info.ti_stkHi)); return(result); } /* Push the contents of an old object. We treat this as stack */ /* data only because that makes it robust against mark stack */ /* overflow. */ PCR_ERes GC_push_old_obj(void *p, size_t size, PCR_Any data) { GC_push_all_stack((ptr_t)p, (ptr_t)p + size); return(PCR_ERes_okay); } extern struct PCR_MM_ProcsRep * GC_old_allocator; /* defined in pcr_interface.c. */ STATIC void GC_CALLBACK GC_default_push_other_roots(void) { /* Traverse data allocated by previous memory managers. */ if ((*(GC_old_allocator->mmp_enumerate))(PCR_Bool_false, GC_push_old_obj, 0) != PCR_ERes_okay) { ABORT("Old object enumeration failed"); } /* Traverse all thread stacks. */ if (PCR_ERes_IsErr( PCR_ThCtl_ApplyToAllOtherThreads(GC_push_thread_stack,0)) || PCR_ERes_IsErr(GC_push_thread_stack(PCR_Th_CurrThread(), 0))) { ABORT("Thread stack marking failed"); } } # endif /* PCR */ # if defined(GC_PTHREADS) || defined(GC_WIN32_THREADS) STATIC void GC_CALLBACK GC_default_push_other_roots(void) { GC_push_all_stacks(); } # endif /* GC_WIN32_THREADS || GC_PTHREADS */ # ifdef SN_TARGET_PS3 STATIC void GC_CALLBACK GC_default_push_other_roots(void) { ABORT("GC_default_push_other_roots is not implemented"); } void GC_push_thread_structures(void) { ABORT("GC_push_thread_structures is not implemented"); } # endif /* SN_TARGET_PS3 */ GC_push_other_roots_proc GC_push_other_roots = GC_default_push_other_roots; #endif /* THREADS */ GC_API void GC_CALL GC_set_push_other_roots(GC_push_other_roots_proc fn) { GC_push_other_roots = fn; } GC_API GC_push_other_roots_proc GC_CALL GC_get_push_other_roots(void) { return GC_push_other_roots; } /* * Routines for accessing dirty bits on virtual pages. * There are six ways to maintain this information: * DEFAULT_VDB: A simple dummy implementation that treats every page * as possibly dirty. This makes incremental collection * useless, but the implementation is still correct. * MANUAL_VDB: Stacks and static data are always considered dirty. * Heap pages are considered dirty if GC_dirty(p) has been * called on some pointer p pointing to somewhere inside * an object on that page. A GC_dirty() call on a large * object directly dirties only a single page, but for * MANUAL_VDB we are careful to treat an object with a dirty * page as completely dirty. * In order to avoid races, an object must be marked dirty * after it is written, and a reference to the object * must be kept on a stack or in a register in the interim. * With threads enabled, an object directly reachable from the * stack at the time of a collection is treated as dirty. * In single-threaded mode, it suffices to ensure that no * collection can take place between the pointer assignment * and the GC_dirty() call. * PCR_VDB: Use PPCRs virtual dirty bit facility. * PROC_VDB: Use the /proc facility for reading dirty bits. Only * works under some SVR4 variants. Even then, it may be * too slow to be entirely satisfactory. Requires reading * dirty bits for entire address space. Implementations tend * to assume that the client is a (slow) debugger. * MPROTECT_VDB:Protect pages and then catch the faults to keep track of * dirtied pages. The implementation (and implementability) * is highly system dependent. This usually fails when system * calls write to a protected page. We prevent the read system * call from doing so. It is the clients responsibility to * make sure that other system calls are similarly protected * or write only to the stack. * GWW_VDB: Use the Win32 GetWriteWatch functions, if available, to * read dirty bits. In case it is not available (because we * are running on Windows 95, Windows 2000 or earlier), * MPROTECT_VDB may be defined as a fallback strategy. */ #ifndef GC_DISABLE_INCREMENTAL GC_INNER GC_bool GC_dirty_maintained = FALSE; #endif #if defined(PROC_VDB) || defined(GWW_VDB) /* Add all pages in pht2 to pht1 */ STATIC void GC_or_pages(page_hash_table pht1, page_hash_table pht2) { register unsigned i; for (i = 0; i < PHT_SIZE; i++) pht1[i] |= pht2[i]; } # ifdef MPROTECT_VDB STATIC GC_bool GC_gww_page_was_dirty(struct hblk * h) # else GC_INNER GC_bool GC_page_was_dirty(struct hblk * h) # endif { register word index; if (HDR(h) == 0) return TRUE; index = PHT_HASH(h); return get_pht_entry_from_index(GC_grungy_pages, index); } # if defined(CHECKSUMS) || defined(PROC_VDB) /* Used only if GWW_VDB. */ # ifdef MPROTECT_VDB STATIC GC_bool GC_gww_page_was_ever_dirty(struct hblk * h) # else GC_INNER GC_bool GC_page_was_ever_dirty(struct hblk * h) # endif { register word index; if (HDR(h) == 0) return TRUE; index = PHT_HASH(h); return get_pht_entry_from_index(GC_written_pages, index); } # endif /* CHECKSUMS || PROC_VDB */ # ifndef MPROTECT_VDB /* Ignore write hints. They don't help us here. */ GC_INNER void GC_remove_protection(struct hblk * h GC_ATTR_UNUSED, word nblocks GC_ATTR_UNUSED, GC_bool is_ptrfree GC_ATTR_UNUSED) {} # endif #endif /* PROC_VDB || GWW_VDB */ #ifdef GWW_VDB # define GC_GWW_BUF_LEN (MAXHINCR * HBLKSIZE / 4096 /* X86 page size */) /* Still susceptible to overflow, if there are very large allocations, */ /* and everything is dirty. */ static PVOID gww_buf[GC_GWW_BUF_LEN]; # ifdef MPROTECT_VDB GC_INNER GC_bool GC_gww_dirty_init(void) { detect_GetWriteWatch(); return GC_GWW_AVAILABLE(); } # else GC_INNER void GC_dirty_init(void) { detect_GetWriteWatch(); GC_dirty_maintained = GC_GWW_AVAILABLE(); } # endif /* !MPROTECT_VDB */ # ifdef MPROTECT_VDB STATIC void GC_gww_read_dirty(void) # else GC_INNER void GC_read_dirty(void) # endif { word i; BZERO(GC_grungy_pages, sizeof(GC_grungy_pages)); for (i = 0; i != GC_n_heap_sects; ++i) { GC_ULONG_PTR count; do { PVOID * pages, * pages_end; DWORD page_size; pages = gww_buf; count = GC_GWW_BUF_LEN; /* GetWriteWatch is documented as returning non-zero when it */ /* fails, but the documentation doesn't explicitly say why it */ /* would fail or what its behaviour will be if it fails. */ /* It does appear to fail, at least on recent W2K instances, if */ /* the underlying memory was not allocated with the appropriate */ /* flag. This is common if GC_enable_incremental is called */ /* shortly after GC initialization. To avoid modifying the */ /* interface, we silently work around such a failure, it only */ /* affects the initial (small) heap allocation. If there are */ /* more dirty pages than will fit in the buffer, this is not */ /* treated as a failure; we must check the page count in the */ /* loop condition. Since each partial call will reset the */ /* status of some pages, this should eventually terminate even */ /* in the overflow case. */ if (GetWriteWatch_func(WRITE_WATCH_FLAG_RESET, GC_heap_sects[i].hs_start, GC_heap_sects[i].hs_bytes, pages, &count, &page_size) != 0) { static int warn_count = 0; unsigned j; struct hblk * start = (struct hblk *)GC_heap_sects[i].hs_start; static struct hblk *last_warned = 0; size_t nblocks = divHBLKSZ(GC_heap_sects[i].hs_bytes); if ( i != 0 && last_warned != start && warn_count++ < 5) { last_warned = start; WARN( "GC_gww_read_dirty unexpectedly failed at %p: " "Falling back to marking all pages dirty\n", start); } for (j = 0; j < nblocks; ++j) { word hash = PHT_HASH(start + j); set_pht_entry_from_index(GC_grungy_pages, hash); } count = 1; /* Done with this section. */ } else /* succeeded */ { pages_end = pages + count; while (pages != pages_end) { struct hblk * h = (struct hblk *) *pages++; struct hblk * h_end = (struct hblk *) ((char *) h + page_size); do { set_pht_entry_from_index(GC_grungy_pages, PHT_HASH(h)); } while ((word)(++h) < (word)h_end); } } } while (count == GC_GWW_BUF_LEN); /* FIXME: It's unclear from Microsoft's documentation if this loop */ /* is useful. We suspect the call just fails if the buffer fills */ /* up. But that should still be handled correctly. */ } GC_or_pages(GC_written_pages, GC_grungy_pages); } #endif /* GWW_VDB */ #ifdef DEFAULT_VDB /* All of the following assume the allocation lock is held. */ /* The client asserts that unallocated pages in the heap are never */ /* written. */ /* Initialize virtual dirty bit implementation. */ GC_INNER void GC_dirty_init(void) { GC_VERBOSE_LOG_PRINTF("Initializing DEFAULT_VDB...\n"); GC_dirty_maintained = TRUE; } /* Retrieve system dirty bits for heap to a local buffer. */ /* Restore the systems notion of which pages are dirty. */ GC_INNER void GC_read_dirty(void) {} /* Is the HBLKSIZE sized page at h marked dirty in the local buffer? */ /* If the actual page size is different, this returns TRUE if any */ /* of the pages overlapping h are dirty. This routine may err on the */ /* side of labeling pages as dirty (and this implementation does). */ GC_INNER GC_bool GC_page_was_dirty(struct hblk * h GC_ATTR_UNUSED) { return(TRUE); } /* The following two routines are typically less crucial. */ /* They matter most with large dynamic libraries, or if we can't */ /* accurately identify stacks, e.g. under Solaris 2.X. Otherwise the */ /* following default versions are adequate. */ # ifdef CHECKSUMS /* Could any valid GC heap pointer ever have been written to this page? */ GC_INNER GC_bool GC_page_was_ever_dirty(struct hblk * h GC_ATTR_UNUSED) { return(TRUE); } # endif /* CHECKSUMS */ /* A call that: */ /* I) hints that [h, h+nblocks) is about to be written. */ /* II) guarantees that protection is removed. */ /* (I) may speed up some dirty bit implementations. */ /* (II) may be essential if we need to ensure that */ /* pointer-free system call buffers in the heap are */ /* not protected. */ GC_INNER void GC_remove_protection(struct hblk * h GC_ATTR_UNUSED, word nblocks GC_ATTR_UNUSED, GC_bool is_ptrfree GC_ATTR_UNUSED) {} #endif /* DEFAULT_VDB */ #ifdef MANUAL_VDB /* Initialize virtual dirty bit implementation. */ GC_INNER void GC_dirty_init(void) { GC_VERBOSE_LOG_PRINTF("Initializing MANUAL_VDB...\n"); /* GC_dirty_pages and GC_grungy_pages are already cleared. */ GC_dirty_maintained = TRUE; } /* Retrieve system dirty bits for heap to a local buffer. */ /* Restore the systems notion of which pages are dirty. */ GC_INNER void GC_read_dirty(void) { BCOPY((word *)GC_dirty_pages, GC_grungy_pages, (sizeof GC_dirty_pages)); BZERO((word *)GC_dirty_pages, (sizeof GC_dirty_pages)); } /* Is the HBLKSIZE sized page at h marked dirty in the local buffer? */ /* If the actual page size is different, this returns TRUE if any */ /* of the pages overlapping h are dirty. This routine may err on the */ /* side of labeling pages as dirty (and this implementation does). */ GC_INNER GC_bool GC_page_was_dirty(struct hblk *h) { register word index = PHT_HASH(h); return(HDR(h) == 0 || get_pht_entry_from_index(GC_grungy_pages, index)); } # define async_set_pht_entry_from_index(db, index) \ set_pht_entry_from_index(db, index) /* for now */ /* Mark the page containing p as dirty. Logically, this dirties the */ /* entire object. */ void GC_dirty(ptr_t p) { word index = PHT_HASH(p); async_set_pht_entry_from_index(GC_dirty_pages, index); } GC_INNER void GC_remove_protection(struct hblk * h GC_ATTR_UNUSED, word nblocks GC_ATTR_UNUSED, GC_bool is_ptrfree GC_ATTR_UNUSED) {} # ifdef CHECKSUMS /* Could any valid GC heap pointer ever have been written to this page? */ GC_INNER GC_bool GC_page_was_ever_dirty(struct hblk * h GC_ATTR_UNUSED) { /* FIXME - implement me. */ return(TRUE); } # endif /* CHECKSUMS */ #endif /* MANUAL_VDB */ #ifdef MPROTECT_VDB /* See DEFAULT_VDB for interface descriptions. */ /* * This implementation maintains dirty bits itself by catching write * faults and keeping track of them. We assume nobody else catches * SIGBUS or SIGSEGV. We assume no write faults occur in system calls. * This means that clients must ensure that system calls don't write * to the write-protected heap. Probably the best way to do this is to * ensure that system calls write at most to pointer-free objects in the * heap, and do even that only if we are on a platform on which those * are not protected. Another alternative is to wrap system calls * (see example for read below), but the current implementation holds * applications. * We assume the page size is a multiple of HBLKSIZE. * We prefer them to be the same. We avoid protecting pointer-free * objects only if they are the same. */ # ifdef DARWIN /* Using vm_protect (mach syscall) over mprotect (BSD syscall) seems to decrease the likelihood of some of the problems described below. */ # include STATIC mach_port_t GC_task_self = 0; # define PROTECT(addr,len) \ if (vm_protect(GC_task_self, (vm_address_t)(addr), (vm_size_t)(len), \ FALSE, VM_PROT_READ \ | (GC_pages_executable ? VM_PROT_EXECUTE : 0)) \ == KERN_SUCCESS) {} else ABORT("vm_protect(PROTECT) failed") # define UNPROTECT(addr,len) \ if (vm_protect(GC_task_self, (vm_address_t)(addr), (vm_size_t)(len), \ FALSE, (VM_PROT_READ | VM_PROT_WRITE) \ | (GC_pages_executable ? VM_PROT_EXECUTE : 0)) \ == KERN_SUCCESS) {} else ABORT("vm_protect(UNPROTECT) failed") # elif !defined(USE_WINALLOC) # include # include # include # define PROTECT(addr, len) \ if (mprotect((caddr_t)(addr), (size_t)(len), \ PROT_READ \ | (GC_pages_executable ? PROT_EXEC : 0)) >= 0) { \ } else ABORT("mprotect failed") # define UNPROTECT(addr, len) \ if (mprotect((caddr_t)(addr), (size_t)(len), \ (PROT_READ | PROT_WRITE) \ | (GC_pages_executable ? PROT_EXEC : 0)) >= 0) { \ } else ABORT(GC_pages_executable ? \ "un-mprotect executable page failed" \ " (probably disabled by OS)" : \ "un-mprotect failed") # undef IGNORE_PAGES_EXECUTABLE # else /* USE_WINALLOC */ # ifndef MSWINCE # include # endif static DWORD protect_junk; # define PROTECT(addr, len) \ if (VirtualProtect((addr), (len), \ GC_pages_executable ? PAGE_EXECUTE_READ : \ PAGE_READONLY, \ &protect_junk)) { \ } else ABORT_ARG1("VirtualProtect failed", \ ": errcode= 0x%X", (unsigned)GetLastError()) # define UNPROTECT(addr, len) \ if (VirtualProtect((addr), (len), \ GC_pages_executable ? PAGE_EXECUTE_READWRITE : \ PAGE_READWRITE, \ &protect_junk)) { \ } else ABORT("un-VirtualProtect failed") # endif /* USE_WINALLOC */ # if defined(MSWIN32) typedef LPTOP_LEVEL_EXCEPTION_FILTER SIG_HNDLR_PTR; # undef SIG_DFL # define SIG_DFL (LPTOP_LEVEL_EXCEPTION_FILTER)((signed_word)-1) # elif defined(MSWINCE) typedef LONG (WINAPI *SIG_HNDLR_PTR)(struct _EXCEPTION_POINTERS *); # undef SIG_DFL # define SIG_DFL (SIG_HNDLR_PTR) (-1) # elif defined(DARWIN) typedef void (* SIG_HNDLR_PTR)(); # else typedef void (* SIG_HNDLR_PTR)(int, siginfo_t *, void *); typedef void (* PLAIN_HNDLR_PTR)(int); # endif # if defined(__GLIBC__) # if __GLIBC__ < 2 || __GLIBC__ == 2 && __GLIBC_MINOR__ < 2 # error glibc too old? # endif # endif #ifndef DARWIN STATIC SIG_HNDLR_PTR GC_old_segv_handler = 0; /* Also old MSWIN32 ACCESS_VIOLATION filter */ # if !defined(MSWIN32) && !defined(MSWINCE) STATIC SIG_HNDLR_PTR GC_old_bus_handler = 0; # if defined(FREEBSD) || defined(HURD) || defined(HPUX) STATIC GC_bool GC_old_bus_handler_used_si = FALSE; # endif STATIC GC_bool GC_old_segv_handler_used_si = FALSE; # endif /* !MSWIN32 */ #endif /* !DARWIN */ #if defined(THREADS) /* We need to lock around the bitmap update in the write fault handler */ /* in order to avoid the risk of losing a bit. We do this with a */ /* test-and-set spin lock if we know how to do that. Otherwise we */ /* check whether we are already in the handler and use the dumb but */ /* safe fallback algorithm of setting all bits in the word. */ /* Contention should be very rare, so we do the minimum to handle it */ /* correctly. */ #ifdef AO_HAVE_test_and_set_acquire GC_INNER volatile AO_TS_t GC_fault_handler_lock = AO_TS_INITIALIZER; static void async_set_pht_entry_from_index(volatile page_hash_table db, size_t index) { while (AO_test_and_set_acquire(&GC_fault_handler_lock) == AO_TS_SET) { /* empty */ } /* Could also revert to set_pht_entry_from_index_safe if initial */ /* GC_test_and_set fails. */ set_pht_entry_from_index(db, index); AO_CLEAR(&GC_fault_handler_lock); } #else /* !AO_HAVE_test_and_set_acquire */ # error No test_and_set operation: Introduces a race. /* THIS WOULD BE INCORRECT! */ /* The dirty bit vector may be temporarily wrong, */ /* just before we notice the conflict and correct it. We may end up */ /* looking at it while it's wrong. But this requires contention */ /* exactly when a GC is triggered, which seems far less likely to */ /* fail than the old code, which had no reported failures. Thus we */ /* leave it this way while we think of something better, or support */ /* GC_test_and_set on the remaining platforms. */ static int * volatile currently_updating = 0; static void async_set_pht_entry_from_index(volatile page_hash_table db, size_t index) { int update_dummy; currently_updating = &update_dummy; set_pht_entry_from_index(db, index); /* If we get contention in the 10 or so instruction window here, */ /* and we get stopped by a GC between the two updates, we lose! */ if (currently_updating != &update_dummy) { set_pht_entry_from_index_safe(db, index); /* We claim that if two threads concurrently try to update the */ /* dirty bit vector, the first one to execute UPDATE_START */ /* will see it changed when UPDATE_END is executed. (Note that */ /* &update_dummy must differ in two distinct threads.) It */ /* will then execute set_pht_entry_from_index_safe, thus */ /* returning us to a safe state, though not soon enough. */ } } #endif /* !AO_HAVE_test_and_set_acquire */ #else /* !THREADS */ # define async_set_pht_entry_from_index(db, index) \ set_pht_entry_from_index(db, index) #endif /* !THREADS */ #ifdef CHECKSUMS void GC_record_fault(struct hblk * h); /* from checksums.c */ #endif #ifndef DARWIN # if !defined(MSWIN32) && !defined(MSWINCE) # include # if defined(FREEBSD) || defined(HURD) || defined(HPUX) # define SIG_OK (sig == SIGBUS || sig == SIGSEGV) # else # define SIG_OK (sig == SIGSEGV) /* Catch SIGSEGV but ignore SIGBUS. */ # endif # if defined(FREEBSD) # ifndef SEGV_ACCERR # define SEGV_ACCERR 2 # endif # if defined(POWERPC) # define AIM /* Pretend that we're AIM. */ # include # define CODE_OK (si -> si_code == EXC_DSI \ || si -> si_code == SEGV_ACCERR) # else # define CODE_OK (si -> si_code == BUS_PAGE_FAULT \ || si -> si_code == SEGV_ACCERR) # endif # elif defined(OSF1) # define CODE_OK (si -> si_code == 2 /* experimentally determined */) # elif defined(IRIX5) # define CODE_OK (si -> si_code == EACCES) # elif defined(HURD) # define CODE_OK TRUE # elif defined(LINUX) # define CODE_OK TRUE /* Empirically c.trapno == 14, on IA32, but is that useful? */ /* Should probably consider alignment issues on other */ /* architectures. */ # elif defined(HPUX) # define CODE_OK (si -> si_code == SEGV_ACCERR \ || si -> si_code == BUS_ADRERR \ || si -> si_code == BUS_UNKNOWN \ || si -> si_code == SEGV_UNKNOWN \ || si -> si_code == BUS_OBJERR) # elif defined(SUNOS5SIGS) # define CODE_OK (si -> si_code == SEGV_ACCERR) # endif # ifndef NO_GETCONTEXT # include # endif STATIC void GC_write_fault_handler(int sig, siginfo_t *si, void *raw_sc) # else # define SIG_OK (exc_info -> ExceptionRecord -> ExceptionCode \ == STATUS_ACCESS_VIOLATION) # define CODE_OK (exc_info -> ExceptionRecord -> ExceptionInformation[0] \ == 1) /* Write fault */ STATIC LONG WINAPI GC_write_fault_handler( struct _EXCEPTION_POINTERS *exc_info) # endif /* MSWIN32 || MSWINCE */ { # if !defined(MSWIN32) && !defined(MSWINCE) char *addr = si -> si_addr; # else char * addr = (char *) (exc_info -> ExceptionRecord -> ExceptionInformation[1]); # endif unsigned i; if (SIG_OK && CODE_OK) { register struct hblk * h = (struct hblk *)((word)addr & ~(GC_page_size-1)); GC_bool in_allocd_block; # ifdef CHECKSUMS GC_record_fault(h); # endif # ifdef SUNOS5SIGS /* Address is only within the correct physical page. */ in_allocd_block = FALSE; for (i = 0; i < divHBLKSZ(GC_page_size); i++) { if (HDR(h+i) != 0) { in_allocd_block = TRUE; break; } } # else in_allocd_block = (HDR(addr) != 0); # endif if (!in_allocd_block) { /* FIXME - We should make sure that we invoke the */ /* old handler with the appropriate calling */ /* sequence, which often depends on SA_SIGINFO. */ /* Heap blocks now begin and end on page boundaries */ SIG_HNDLR_PTR old_handler; # if defined(MSWIN32) || defined(MSWINCE) old_handler = GC_old_segv_handler; # else GC_bool used_si; # if defined(FREEBSD) || defined(HURD) || defined(HPUX) if (sig == SIGBUS) { old_handler = GC_old_bus_handler; used_si = GC_old_bus_handler_used_si; } else # endif /* else */ { old_handler = GC_old_segv_handler; used_si = GC_old_segv_handler_used_si; } # endif if (old_handler == (SIG_HNDLR_PTR)SIG_DFL) { # if !defined(MSWIN32) && !defined(MSWINCE) ABORT_ARG1("Unexpected bus error or segmentation fault", " at %p", addr); # else return(EXCEPTION_CONTINUE_SEARCH); # endif } else { /* * FIXME: This code should probably check if the * old signal handler used the traditional style and * if so call it using that style. */ # if defined(MSWIN32) || defined(MSWINCE) return((*old_handler)(exc_info)); # else if (used_si) ((SIG_HNDLR_PTR)old_handler) (sig, si, raw_sc); else /* FIXME: should pass nonstandard args as well. */ ((PLAIN_HNDLR_PTR)old_handler) (sig); return; # endif } } UNPROTECT(h, GC_page_size); /* We need to make sure that no collection occurs between */ /* the UNPROTECT and the setting of the dirty bit. Otherwise */ /* a write by a third thread might go unnoticed. Reversing */ /* the order is just as bad, since we would end up unprotecting */ /* a page in a GC cycle during which it's not marked. */ /* Currently we do this by disabling the thread stopping */ /* signals while this handler is running. An alternative might */ /* be to record the fact that we're about to unprotect, or */ /* have just unprotected a page in the GC's thread structure, */ /* and then to have the thread stopping code set the dirty */ /* flag, if necessary. */ for (i = 0; i < divHBLKSZ(GC_page_size); i++) { size_t index = PHT_HASH(h+i); async_set_pht_entry_from_index(GC_dirty_pages, index); } /* The write may not take place before dirty bits are read. */ /* But then we'll fault again ... */ # if defined(MSWIN32) || defined(MSWINCE) return(EXCEPTION_CONTINUE_EXECUTION); # else return; # endif } # if defined(MSWIN32) || defined(MSWINCE) return EXCEPTION_CONTINUE_SEARCH; # else ABORT_ARG1("Unexpected bus error or segmentation fault", " at %p", addr); # endif } # ifdef GC_WIN32_THREADS GC_INNER void GC_set_write_fault_handler(void) { SetUnhandledExceptionFilter(GC_write_fault_handler); } # endif #endif /* !DARWIN */ /* We hold the allocation lock. We expect block h to be written */ /* shortly. Ensure that all pages containing any part of the n hblks */ /* starting at h are no longer protected. If is_ptrfree is false, also */ /* ensure that they will subsequently appear to be dirty. Not allowed */ /* to call GC_printf (and the friends) here, see Win32 GC_stop_world() */ /* for the information. */ GC_INNER void GC_remove_protection(struct hblk *h, word nblocks, GC_bool is_ptrfree) { struct hblk * h_trunc; /* Truncated to page boundary */ struct hblk * h_end; /* Page boundary following block end */ struct hblk * current; # if defined(GWW_VDB) if (GC_GWW_AVAILABLE()) return; # endif if (!GC_dirty_maintained) return; h_trunc = (struct hblk *)((word)h & ~(GC_page_size-1)); h_end = (struct hblk *)ROUNDUP_PAGESIZE((word)(h + nblocks)); if (h_end == h_trunc + 1 && get_pht_entry_from_index(GC_dirty_pages, PHT_HASH(h_trunc))) { /* already marked dirty, and hence unprotected. */ return; } for (current = h_trunc; (word)current < (word)h_end; ++current) { size_t index = PHT_HASH(current); if (!is_ptrfree || (word)current < (word)h || (word)current >= (word)(h + nblocks)) { async_set_pht_entry_from_index(GC_dirty_pages, index); } } UNPROTECT(h_trunc, (ptr_t)h_end - (ptr_t)h_trunc); } #if !defined(DARWIN) GC_INNER void GC_dirty_init(void) { # if !defined(MSWIN32) && !defined(MSWINCE) struct sigaction act, oldact; act.sa_flags = SA_RESTART | SA_SIGINFO; act.sa_sigaction = GC_write_fault_handler; (void)sigemptyset(&act.sa_mask); # if defined(THREADS) && !defined(GC_OPENBSD_UTHREADS) \ && !defined(GC_WIN32_THREADS) && !defined(NACL) /* Arrange to postpone the signal while we are in a write fault */ /* handler. This effectively makes the handler atomic w.r.t. */ /* stopping the world for GC. */ (void)sigaddset(&act.sa_mask, GC_get_suspend_signal()); # endif # endif /* !MSWIN32 */ GC_VERBOSE_LOG_PRINTF( "Initializing mprotect virtual dirty bit implementation\n"); GC_dirty_maintained = TRUE; if (GC_page_size % HBLKSIZE != 0) { ABORT("Page size not multiple of HBLKSIZE"); } # if !defined(MSWIN32) && !defined(MSWINCE) /* act.sa_restorer is deprecated and should not be initialized. */ # if defined(GC_IRIX_THREADS) sigaction(SIGSEGV, 0, &oldact); sigaction(SIGSEGV, &act, 0); # else { int res = sigaction(SIGSEGV, &act, &oldact); if (res != 0) ABORT("Sigaction failed"); } # endif if (oldact.sa_flags & SA_SIGINFO) { GC_old_segv_handler = oldact.sa_sigaction; GC_old_segv_handler_used_si = TRUE; } else { GC_old_segv_handler = (SIG_HNDLR_PTR)oldact.sa_handler; GC_old_segv_handler_used_si = FALSE; } if (GC_old_segv_handler == (SIG_HNDLR_PTR)SIG_IGN) { WARN("Previously ignored segmentation violation!?\n", 0); GC_old_segv_handler = (SIG_HNDLR_PTR)SIG_DFL; } if (GC_old_segv_handler != (SIG_HNDLR_PTR)SIG_DFL) { GC_VERBOSE_LOG_PRINTF("Replaced other SIGSEGV handler\n"); } # if defined(HPUX) || defined(LINUX) || defined(HURD) \ || (defined(FREEBSD) && defined(SUNOS5SIGS)) sigaction(SIGBUS, &act, &oldact); if ((oldact.sa_flags & SA_SIGINFO) != 0) { GC_old_bus_handler = oldact.sa_sigaction; # if !defined(LINUX) GC_old_bus_handler_used_si = TRUE; # endif } else { GC_old_bus_handler = (SIG_HNDLR_PTR)oldact.sa_handler; # if !defined(LINUX) GC_old_bus_handler_used_si = FALSE; # endif } if (GC_old_bus_handler == (SIG_HNDLR_PTR)SIG_IGN) { WARN("Previously ignored bus error!?\n", 0); # if !defined(LINUX) GC_old_bus_handler = (SIG_HNDLR_PTR)SIG_DFL; # else /* GC_old_bus_handler is not used by GC_write_fault_handler. */ # endif } else if (GC_old_bus_handler != (SIG_HNDLR_PTR)SIG_DFL) { GC_VERBOSE_LOG_PRINTF("Replaced other SIGBUS handler\n"); } # endif /* HPUX || LINUX || HURD || (FREEBSD && SUNOS5SIGS) */ # endif /* ! MS windows */ # if defined(GWW_VDB) if (GC_gww_dirty_init()) return; # endif # if defined(MSWIN32) GC_old_segv_handler = SetUnhandledExceptionFilter(GC_write_fault_handler); if (GC_old_segv_handler != NULL) { GC_COND_LOG_PRINTF("Replaced other UnhandledExceptionFilter\n"); } else { GC_old_segv_handler = SIG_DFL; } # elif defined(MSWINCE) /* MPROTECT_VDB is unsupported for WinCE at present. */ /* FIXME: implement it (if possible). */ # endif } #endif /* !DARWIN */ GC_API int GC_CALL GC_incremental_protection_needs(void) { GC_ASSERT(GC_is_initialized); if (GC_page_size == HBLKSIZE) { return GC_PROTECTS_POINTER_HEAP; } else { return GC_PROTECTS_POINTER_HEAP | GC_PROTECTS_PTRFREE_HEAP; } } #define HAVE_INCREMENTAL_PROTECTION_NEEDS #define IS_PTRFREE(hhdr) ((hhdr)->hb_descr == 0) #define PAGE_ALIGNED(x) !((word)(x) & (GC_page_size - 1)) STATIC void GC_protect_heap(void) { ptr_t start; size_t len; struct hblk * current; struct hblk * current_start; /* Start of block to be protected. */ struct hblk * limit; unsigned i; GC_bool protect_all = (0 != (GC_incremental_protection_needs() & GC_PROTECTS_PTRFREE_HEAP)); for (i = 0; i < GC_n_heap_sects; i++) { start = GC_heap_sects[i].hs_start; len = GC_heap_sects[i].hs_bytes; if (protect_all) { PROTECT(start, len); } else { GC_ASSERT(PAGE_ALIGNED(len)); GC_ASSERT(PAGE_ALIGNED(start)); current_start = current = (struct hblk *)start; limit = (struct hblk *)(start + len); while ((word)current < (word)limit) { hdr * hhdr; word nhblks; GC_bool is_ptrfree; GC_ASSERT(PAGE_ALIGNED(current)); GET_HDR(current, hhdr); if (IS_FORWARDING_ADDR_OR_NIL(hhdr)) { /* This can happen only if we're at the beginning of a */ /* heap segment, and a block spans heap segments. */ /* We will handle that block as part of the preceding */ /* segment. */ GC_ASSERT(current_start == current); current_start = ++current; continue; } if (HBLK_IS_FREE(hhdr)) { GC_ASSERT(PAGE_ALIGNED(hhdr -> hb_sz)); nhblks = divHBLKSZ(hhdr -> hb_sz); is_ptrfree = TRUE; /* dirty on alloc */ } else { nhblks = OBJ_SZ_TO_BLOCKS(hhdr -> hb_sz); is_ptrfree = IS_PTRFREE(hhdr); } if (is_ptrfree) { if ((word)current_start < (word)current) { PROTECT(current_start, (ptr_t)current - (ptr_t)current_start); } current_start = (current += nhblks); } else { current += nhblks; } } if ((word)current_start < (word)current) { PROTECT(current_start, (ptr_t)current - (ptr_t)current_start); } } } } /* We assume that either the world is stopped or its OK to lose dirty */ /* bits while this is happening (as in GC_enable_incremental). */ GC_INNER void GC_read_dirty(void) { # if defined(GWW_VDB) if (GC_GWW_AVAILABLE()) { GC_gww_read_dirty(); return; } # endif BCOPY((word *)GC_dirty_pages, GC_grungy_pages, (sizeof GC_dirty_pages)); BZERO((word *)GC_dirty_pages, (sizeof GC_dirty_pages)); GC_protect_heap(); } GC_INNER GC_bool GC_page_was_dirty(struct hblk *h) { register word index; # if defined(GWW_VDB) if (GC_GWW_AVAILABLE()) return GC_gww_page_was_dirty(h); # endif index = PHT_HASH(h); return(HDR(h) == 0 || get_pht_entry_from_index(GC_grungy_pages, index)); } /* * Acquiring the allocation lock here is dangerous, since this * can be called from within GC_call_with_alloc_lock, and the cord * package does so. On systems that allow nested lock acquisition, this * happens to work. */ /* We no longer wrap read by default, since that was causing too many */ /* problems. It is preferred that the client instead avoids writing */ /* to the write-protected heap with a system call. */ # ifdef CHECKSUMS GC_INNER GC_bool GC_page_was_ever_dirty(struct hblk * h GC_ATTR_UNUSED) { # if defined(GWW_VDB) if (GC_GWW_AVAILABLE()) return GC_gww_page_was_ever_dirty(h); # endif return(TRUE); } # endif /* CHECKSUMS */ #endif /* MPROTECT_VDB */ #ifdef PROC_VDB /* See DEFAULT_VDB for interface descriptions. */ /* This implementation assumes a Solaris 2.X like /proc */ /* pseudo-file-system from which we can read page modified bits. This */ /* facility is far from optimal (e.g. we would like to get the info for */ /* only some of the address space), but it avoids intercepting system */ /* calls. */ # include # include # include # include # include # include # include # define INITIAL_BUF_SZ 16384 STATIC word GC_proc_buf_size = INITIAL_BUF_SZ; STATIC char *GC_proc_buf = NULL; STATIC int GC_proc_fd = 0; GC_INNER void GC_dirty_init(void) { int fd; char buf[30]; if (GC_bytes_allocd != 0 || GC_bytes_allocd_before_gc != 0) { memset(GC_written_pages, 0xff, sizeof(page_hash_table)); GC_VERBOSE_LOG_PRINTF( "Allocated %lu bytes: all pages may have been written\n", (unsigned long)(GC_bytes_allocd + GC_bytes_allocd_before_gc)); } (void)snprintf(buf, sizeof(buf), "/proc/%ld", (long)getpid()); buf[sizeof(buf) - 1] = '\0'; fd = open(buf, O_RDONLY); if (fd < 0) { ABORT("/proc open failed"); } GC_proc_fd = syscall(SYS_ioctl, fd, PIOCOPENPD, 0); close(fd); syscall(SYS_fcntl, GC_proc_fd, F_SETFD, FD_CLOEXEC); if (GC_proc_fd < 0) { WARN("/proc ioctl(PIOCOPENPD) failed", 0); return; } GC_dirty_maintained = TRUE; GC_proc_buf = GC_scratch_alloc(GC_proc_buf_size); if (GC_proc_buf == NULL) ABORT("Insufficient space for /proc read"); } # define READ read GC_INNER void GC_read_dirty(void) { int nmaps; unsigned long npages; unsigned pagesize; ptr_t vaddr, limit; struct prasmap * map; char * bufp; int i; BZERO(GC_grungy_pages, sizeof(GC_grungy_pages)); bufp = GC_proc_buf; if (READ(GC_proc_fd, bufp, GC_proc_buf_size) <= 0) { /* Retry with larger buffer. */ word new_size = 2 * GC_proc_buf_size; char *new_buf; WARN("/proc read failed: GC_proc_buf_size = %" WARN_PRIdPTR "\n", (signed_word)GC_proc_buf_size); new_buf = GC_scratch_alloc(new_size); if (new_buf != 0) { GC_proc_buf = bufp = new_buf; GC_proc_buf_size = new_size; } if (READ(GC_proc_fd, bufp, GC_proc_buf_size) <= 0) { WARN("Insufficient space for /proc read\n", 0); /* Punt: */ memset(GC_grungy_pages, 0xff, sizeof (page_hash_table)); memset(GC_written_pages, 0xff, sizeof(page_hash_table)); return; } } /* Copy dirty bits into GC_grungy_pages */ nmaps = ((struct prpageheader *)bufp) -> pr_nmap; # ifdef DEBUG_DIRTY_BITS GC_log_printf("Proc VDB read: pr_nmap= %u, pr_npage= %lu\n", nmaps, ((struct prpageheader *)bufp)->pr_npage); # endif bufp += sizeof(struct prpageheader); for (i = 0; i < nmaps; i++) { map = (struct prasmap *)bufp; vaddr = (ptr_t)(map -> pr_vaddr); npages = map -> pr_npage; pagesize = map -> pr_pagesize; # ifdef DEBUG_DIRTY_BITS GC_log_printf( "pr_vaddr= %p, npage= %lu, mflags= 0x%x, pagesize= 0x%x\n", vaddr, npages, map->pr_mflags, pagesize); # endif bufp += sizeof(struct prasmap); limit = vaddr + pagesize * npages; for (; (word)vaddr < (word)limit; vaddr += pagesize) { if ((*bufp++) & PG_MODIFIED) { register struct hblk * h; ptr_t next_vaddr = vaddr + pagesize; # ifdef DEBUG_DIRTY_BITS GC_log_printf("dirty page at: %p\n", vaddr); # endif for (h = (struct hblk *)vaddr; (word)h < (word)next_vaddr; h++) { register word index = PHT_HASH(h); set_pht_entry_from_index(GC_grungy_pages, index); } } } bufp = (char *)(((word)bufp + (sizeof(long)-1)) & ~(sizeof(long)-1)); } # ifdef DEBUG_DIRTY_BITS GC_log_printf("Proc VDB read done.\n"); # endif /* Update GC_written_pages. */ GC_or_pages(GC_written_pages, GC_grungy_pages); } # undef READ #endif /* PROC_VDB */ #ifdef PCR_VDB # include "vd/PCR_VD.h" # define NPAGES (32*1024) /* 128 MB */ PCR_VD_DB GC_grungy_bits[NPAGES]; STATIC ptr_t GC_vd_base = NULL; /* Address corresponding to GC_grungy_bits[0] */ /* HBLKSIZE aligned. */ GC_INNER void GC_dirty_init(void) { GC_dirty_maintained = TRUE; /* For the time being, we assume the heap generally grows up */ GC_vd_base = GC_heap_sects[0].hs_start; if (GC_vd_base == 0) { ABORT("Bad initial heap segment"); } if (PCR_VD_Start(HBLKSIZE, GC_vd_base, NPAGES*HBLKSIZE) != PCR_ERes_okay) { ABORT("Dirty bit initialization failed"); } } GC_INNER void GC_read_dirty(void) { /* lazily enable dirty bits on newly added heap sects */ { static int onhs = 0; int nhs = GC_n_heap_sects; for(; onhs < nhs; onhs++) { PCR_VD_WriteProtectEnable( GC_heap_sects[onhs].hs_start, GC_heap_sects[onhs].hs_bytes ); } } if (PCR_VD_Clear(GC_vd_base, NPAGES*HBLKSIZE, GC_grungy_bits) != PCR_ERes_okay) { ABORT("Dirty bit read failed"); } } GC_INNER GC_bool GC_page_was_dirty(struct hblk *h) { if ((word)h < (word)GC_vd_base || (word)h >= (word)(GC_vd_base + NPAGES*HBLKSIZE)) { return(TRUE); } return(GC_grungy_bits[h - (struct hblk *)GC_vd_base] & PCR_VD_DB_dirtyBit); } GC_INNER void GC_remove_protection(struct hblk *h, word nblocks, GC_bool is_ptrfree GC_ATTR_UNUSED) { PCR_VD_WriteProtectDisable(h, nblocks*HBLKSIZE); PCR_VD_WriteProtectEnable(h, nblocks*HBLKSIZE); } #endif /* PCR_VDB */ #if defined(MPROTECT_VDB) && defined(DARWIN) /* The following sources were used as a "reference" for this exception handling code: 1. Apple's mach/xnu documentation 2. Timothy J. Wood's "Mach Exception Handlers 101" post to the omnigroup's macosx-dev list. www.omnigroup.com/mailman/archive/macosx-dev/2000-June/014178.html 3. macosx-nat.c from Apple's GDB source code. */ /* The bug that caused all this trouble should now be fixed. This should eventually be removed if all goes well. */ /* #define BROKEN_EXCEPTION_HANDLING */ #include #include #include #include #include /* These are not defined in any header, although they are documented */ extern boolean_t exc_server(mach_msg_header_t *, mach_msg_header_t *); extern kern_return_t exception_raise(mach_port_t, mach_port_t, mach_port_t, exception_type_t, exception_data_t, mach_msg_type_number_t); extern kern_return_t exception_raise_state(mach_port_t, mach_port_t, mach_port_t, exception_type_t, exception_data_t, mach_msg_type_number_t, thread_state_flavor_t*, thread_state_t, mach_msg_type_number_t, thread_state_t, mach_msg_type_number_t*); extern kern_return_t exception_raise_state_identity(mach_port_t, mach_port_t, mach_port_t, exception_type_t, exception_data_t, mach_msg_type_number_t, thread_state_flavor_t*, thread_state_t, mach_msg_type_number_t, thread_state_t, mach_msg_type_number_t*); GC_API_OSCALL kern_return_t catch_exception_raise(mach_port_t exception_port, mach_port_t thread, mach_port_t task, exception_type_t exception, exception_data_t code, mach_msg_type_number_t code_count); /* These should never be called, but just in case... */ GC_API_OSCALL kern_return_t catch_exception_raise_state(mach_port_name_t exception_port GC_ATTR_UNUSED, int exception GC_ATTR_UNUSED, exception_data_t code GC_ATTR_UNUSED, mach_msg_type_number_t codeCnt GC_ATTR_UNUSED, int flavor GC_ATTR_UNUSED, thread_state_t old_state GC_ATTR_UNUSED, int old_stateCnt GC_ATTR_UNUSED, thread_state_t new_state GC_ATTR_UNUSED, int new_stateCnt GC_ATTR_UNUSED) { ABORT_RET("Unexpected catch_exception_raise_state invocation"); return(KERN_INVALID_ARGUMENT); } GC_API_OSCALL kern_return_t catch_exception_raise_state_identity( mach_port_name_t exception_port GC_ATTR_UNUSED, mach_port_t thread GC_ATTR_UNUSED, mach_port_t task GC_ATTR_UNUSED, int exception GC_ATTR_UNUSED, exception_data_t code GC_ATTR_UNUSED, mach_msg_type_number_t codeCnt GC_ATTR_UNUSED, int flavor GC_ATTR_UNUSED, thread_state_t old_state GC_ATTR_UNUSED, int old_stateCnt GC_ATTR_UNUSED, thread_state_t new_state GC_ATTR_UNUSED, int new_stateCnt GC_ATTR_UNUSED) { ABORT_RET("Unexpected catch_exception_raise_state_identity invocation"); return(KERN_INVALID_ARGUMENT); } #define MAX_EXCEPTION_PORTS 16 static struct { mach_msg_type_number_t count; exception_mask_t masks[MAX_EXCEPTION_PORTS]; exception_handler_t ports[MAX_EXCEPTION_PORTS]; exception_behavior_t behaviors[MAX_EXCEPTION_PORTS]; thread_state_flavor_t flavors[MAX_EXCEPTION_PORTS]; } GC_old_exc_ports; STATIC struct { void (*volatile os_callback[3])(void); mach_port_t exception; # if defined(THREADS) mach_port_t reply; # endif } GC_ports = { { /* This is to prevent stripping these routines as dead. */ (void (*)(void))catch_exception_raise, (void (*)(void))catch_exception_raise_state, (void (*)(void))catch_exception_raise_state_identity }, # ifdef THREADS 0, /* for 'exception' */ # endif 0 }; typedef struct { mach_msg_header_t head; } GC_msg_t; typedef enum { GC_MP_NORMAL, GC_MP_DISCARDING, GC_MP_STOPPED } GC_mprotect_state_t; #ifdef THREADS /* FIXME: 1 and 2 seem to be safe to use in the msgh_id field, but it */ /* is not documented. Use the source and see if they should be OK. */ # define ID_STOP 1 # define ID_RESUME 2 /* This value is only used on the reply port. */ # define ID_ACK 3 STATIC GC_mprotect_state_t GC_mprotect_state = 0; /* The following should ONLY be called when the world is stopped. */ STATIC void GC_mprotect_thread_notify(mach_msg_id_t id) { struct { GC_msg_t msg; mach_msg_trailer_t trailer; } buf; mach_msg_return_t r; /* remote, local */ buf.msg.head.msgh_bits = MACH_MSGH_BITS(MACH_MSG_TYPE_MAKE_SEND, 0); buf.msg.head.msgh_size = sizeof(buf.msg); buf.msg.head.msgh_remote_port = GC_ports.exception; buf.msg.head.msgh_local_port = MACH_PORT_NULL; buf.msg.head.msgh_id = id; r = mach_msg(&buf.msg.head, MACH_SEND_MSG | MACH_RCV_MSG | MACH_RCV_LARGE, sizeof(buf.msg), sizeof(buf), GC_ports.reply, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL); if (r != MACH_MSG_SUCCESS) ABORT("mach_msg failed in GC_mprotect_thread_notify"); if (buf.msg.head.msgh_id != ID_ACK) ABORT("Invalid ack in GC_mprotect_thread_notify"); } /* Should only be called by the mprotect thread */ STATIC void GC_mprotect_thread_reply(void) { GC_msg_t msg; mach_msg_return_t r; /* remote, local */ msg.head.msgh_bits = MACH_MSGH_BITS(MACH_MSG_TYPE_MAKE_SEND, 0); msg.head.msgh_size = sizeof(msg); msg.head.msgh_remote_port = GC_ports.reply; msg.head.msgh_local_port = MACH_PORT_NULL; msg.head.msgh_id = ID_ACK; r = mach_msg(&msg.head, MACH_SEND_MSG, sizeof(msg), 0, MACH_PORT_NULL, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL); if (r != MACH_MSG_SUCCESS) ABORT("mach_msg failed in GC_mprotect_thread_reply"); } GC_INNER void GC_mprotect_stop(void) { GC_mprotect_thread_notify(ID_STOP); } GC_INNER void GC_mprotect_resume(void) { GC_mprotect_thread_notify(ID_RESUME); } # ifndef GC_NO_THREADS_DISCOVERY GC_INNER void GC_darwin_register_mach_handler_thread(mach_port_t thread); # endif #else /* The compiler should optimize away any GC_mprotect_state computations */ # define GC_mprotect_state GC_MP_NORMAL #endif /* !THREADS */ STATIC void *GC_mprotect_thread(void *arg) { mach_msg_return_t r; /* These two structures contain some private kernel data. We don't */ /* need to access any of it so we don't bother defining a proper */ /* struct. The correct definitions are in the xnu source code. */ struct { mach_msg_header_t head; char data[256]; } reply; struct { mach_msg_header_t head; mach_msg_body_t msgh_body; char data[1024]; } msg; mach_msg_id_t id; if ((word)arg == (word)-1) return 0; /* to make compiler happy */ # if defined(THREADS) && !defined(GC_NO_THREADS_DISCOVERY) GC_darwin_register_mach_handler_thread(mach_thread_self()); # endif for(;;) { r = mach_msg(&msg.head, MACH_RCV_MSG | MACH_RCV_LARGE | (GC_mprotect_state == GC_MP_DISCARDING ? MACH_RCV_TIMEOUT : 0), 0, sizeof(msg), GC_ports.exception, GC_mprotect_state == GC_MP_DISCARDING ? 0 : MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL); id = r == MACH_MSG_SUCCESS ? msg.head.msgh_id : -1; # if defined(THREADS) if(GC_mprotect_state == GC_MP_DISCARDING) { if(r == MACH_RCV_TIMED_OUT) { GC_mprotect_state = GC_MP_STOPPED; GC_mprotect_thread_reply(); continue; } if(r == MACH_MSG_SUCCESS && (id == ID_STOP || id == ID_RESUME)) ABORT("Out of order mprotect thread request"); } # endif /* THREADS */ if (r != MACH_MSG_SUCCESS) { ABORT_ARG2("mach_msg failed", ": errcode= %d (%s)", (int)r, mach_error_string(r)); } switch(id) { # if defined(THREADS) case ID_STOP: if(GC_mprotect_state != GC_MP_NORMAL) ABORT("Called mprotect_stop when state wasn't normal"); GC_mprotect_state = GC_MP_DISCARDING; break; case ID_RESUME: if(GC_mprotect_state != GC_MP_STOPPED) ABORT("Called mprotect_resume when state wasn't stopped"); GC_mprotect_state = GC_MP_NORMAL; GC_mprotect_thread_reply(); break; # endif /* THREADS */ default: /* Handle the message (calls catch_exception_raise) */ if(!exc_server(&msg.head, &reply.head)) ABORT("exc_server failed"); /* Send the reply */ r = mach_msg(&reply.head, MACH_SEND_MSG, reply.head.msgh_size, 0, MACH_PORT_NULL, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL); if(r != MACH_MSG_SUCCESS) { /* This will fail if the thread dies, but the thread */ /* shouldn't die... */ # ifdef BROKEN_EXCEPTION_HANDLING GC_err_printf("mach_msg failed with %d %s while sending " "exc reply\n", (int)r, mach_error_string(r)); # else ABORT("mach_msg failed while sending exception reply"); # endif } } /* switch */ } /* for(;;) */ } /* All this SIGBUS code shouldn't be necessary. All protection faults should be going through the mach exception handler. However, it seems a SIGBUS is occasionally sent for some unknown reason. Even more odd, it seems to be meaningless and safe to ignore. */ #ifdef BROKEN_EXCEPTION_HANDLING /* Updates to this aren't atomic, but the SIGBUS'es seem pretty rare. */ /* Even if this doesn't get updated property, it isn't really a problem. */ STATIC int GC_sigbus_count = 0; STATIC void GC_darwin_sigbus(int num, siginfo_t *sip, void *context) { if (num != SIGBUS) ABORT("Got a non-sigbus signal in the sigbus handler"); /* Ugh... some seem safe to ignore, but too many in a row probably means trouble. GC_sigbus_count is reset for each mach exception that is handled */ if (GC_sigbus_count >= 8) { ABORT("Got more than 8 SIGBUSs in a row!"); } else { GC_sigbus_count++; WARN("Ignoring SIGBUS.\n", 0); } } #endif /* BROKEN_EXCEPTION_HANDLING */ GC_INNER void GC_dirty_init(void) { kern_return_t r; mach_port_t me; pthread_t thread; pthread_attr_t attr; exception_mask_t mask; # ifdef CAN_HANDLE_FORK if (GC_handle_fork) { /* To both support GC incremental mode and GC functions usage in */ /* the forked child, pthread_atfork should be used to install */ /* handlers that switch off GC_dirty_maintained in the child */ /* gracefully (unprotecting all pages and clearing */ /* GC_mach_handler_thread). For now, we just disable incremental */ /* mode if fork() handling is requested by the client. */ GC_COND_LOG_PRINTF("GC incremental mode disabled since fork()" " handling requested\n"); return; } # endif GC_VERBOSE_LOG_PRINTF("Initializing mach/darwin mprotect" " virtual dirty bit implementation\n"); # ifdef BROKEN_EXCEPTION_HANDLING WARN("Enabling workarounds for various darwin " "exception handling bugs.\n", 0); # endif GC_dirty_maintained = TRUE; if (GC_page_size % HBLKSIZE != 0) { ABORT("Page size not multiple of HBLKSIZE"); } GC_task_self = me = mach_task_self(); r = mach_port_allocate(me, MACH_PORT_RIGHT_RECEIVE, &GC_ports.exception); if (r != KERN_SUCCESS) ABORT("mach_port_allocate failed (exception port)"); r = mach_port_insert_right(me, GC_ports.exception, GC_ports.exception, MACH_MSG_TYPE_MAKE_SEND); if (r != KERN_SUCCESS) ABORT("mach_port_insert_right failed (exception port)"); # if defined(THREADS) r = mach_port_allocate(me, MACH_PORT_RIGHT_RECEIVE, &GC_ports.reply); if(r != KERN_SUCCESS) ABORT("mach_port_allocate failed (reply port)"); # endif /* The exceptions we want to catch */ mask = EXC_MASK_BAD_ACCESS; r = task_get_exception_ports(me, mask, GC_old_exc_ports.masks, &GC_old_exc_ports.count, GC_old_exc_ports.ports, GC_old_exc_ports.behaviors, GC_old_exc_ports.flavors); if (r != KERN_SUCCESS) ABORT("task_get_exception_ports failed"); r = task_set_exception_ports(me, mask, GC_ports.exception, EXCEPTION_DEFAULT, GC_MACH_THREAD_STATE); if (r != KERN_SUCCESS) ABORT("task_set_exception_ports failed"); if (pthread_attr_init(&attr) != 0) ABORT("pthread_attr_init failed"); if (pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED) != 0) ABORT("pthread_attr_setdetachedstate failed"); # undef pthread_create /* This will call the real pthread function, not our wrapper */ if (pthread_create(&thread, &attr, GC_mprotect_thread, NULL) != 0) ABORT("pthread_create failed"); (void)pthread_attr_destroy(&attr); /* Setup the sigbus handler for ignoring the meaningless SIGBUSs */ # ifdef BROKEN_EXCEPTION_HANDLING { struct sigaction sa, oldsa; sa.sa_handler = (SIG_HNDLR_PTR)GC_darwin_sigbus; sigemptyset(&sa.sa_mask); sa.sa_flags = SA_RESTART|SA_SIGINFO; /* sa.sa_restorer is deprecated and should not be initialized. */ if (sigaction(SIGBUS, &sa, &oldsa) < 0) ABORT("sigaction failed"); if ((SIG_HNDLR_PTR)oldsa.sa_handler != SIG_DFL) { GC_VERBOSE_LOG_PRINTF("Replaced other SIGBUS handler\n"); } } # endif /* BROKEN_EXCEPTION_HANDLING */ } /* The source code for Apple's GDB was used as a reference for the */ /* exception forwarding code. This code is similar to be GDB code only */ /* because there is only one way to do it. */ STATIC kern_return_t GC_forward_exception(mach_port_t thread, mach_port_t task, exception_type_t exception, exception_data_t data, mach_msg_type_number_t data_count) { unsigned int i; kern_return_t r; mach_port_t port; exception_behavior_t behavior; thread_state_flavor_t flavor; thread_state_data_t thread_state; mach_msg_type_number_t thread_state_count = THREAD_STATE_MAX; for (i=0; i < GC_old_exc_ports.count; i++) if (GC_old_exc_ports.masks[i] & (1 << exception)) break; if (i == GC_old_exc_ports.count) ABORT("No handler for exception!"); port = GC_old_exc_ports.ports[i]; behavior = GC_old_exc_ports.behaviors[i]; flavor = GC_old_exc_ports.flavors[i]; if (behavior == EXCEPTION_STATE || behavior == EXCEPTION_STATE_IDENTITY) { r = thread_get_state(thread, flavor, thread_state, &thread_state_count); if(r != KERN_SUCCESS) ABORT("thread_get_state failed in forward_exception"); } switch(behavior) { case EXCEPTION_STATE: r = exception_raise_state(port, thread, task, exception, data, data_count, &flavor, thread_state, thread_state_count, thread_state, &thread_state_count); break; case EXCEPTION_STATE_IDENTITY: r = exception_raise_state_identity(port, thread, task, exception, data, data_count, &flavor, thread_state, thread_state_count, thread_state, &thread_state_count); break; /* case EXCEPTION_DEFAULT: */ /* default signal handlers */ default: /* user-supplied signal handlers */ r = exception_raise(port, thread, task, exception, data, data_count); } if (behavior == EXCEPTION_STATE || behavior == EXCEPTION_STATE_IDENTITY) { r = thread_set_state(thread, flavor, thread_state, thread_state_count); if (r != KERN_SUCCESS) ABORT("thread_set_state failed in forward_exception"); } return r; } #define FWD() GC_forward_exception(thread, task, exception, code, code_count) #ifdef ARM32 # define DARWIN_EXC_STATE ARM_EXCEPTION_STATE # define DARWIN_EXC_STATE_COUNT ARM_EXCEPTION_STATE_COUNT # define DARWIN_EXC_STATE_T arm_exception_state_t # define DARWIN_EXC_STATE_DAR THREAD_FLD(far) #elif defined(AARCH64) # define DARWIN_EXC_STATE ARM_EXCEPTION_STATE64 # define DARWIN_EXC_STATE_COUNT ARM_EXCEPTION_STATE64_COUNT # define DARWIN_EXC_STATE_T arm_exception_state64_t # define DARWIN_EXC_STATE_DAR THREAD_FLD(far) #elif defined(POWERPC) # if CPP_WORDSZ == 32 # define DARWIN_EXC_STATE PPC_EXCEPTION_STATE # define DARWIN_EXC_STATE_COUNT PPC_EXCEPTION_STATE_COUNT # define DARWIN_EXC_STATE_T ppc_exception_state_t # else # define DARWIN_EXC_STATE PPC_EXCEPTION_STATE64 # define DARWIN_EXC_STATE_COUNT PPC_EXCEPTION_STATE64_COUNT # define DARWIN_EXC_STATE_T ppc_exception_state64_t # endif # define DARWIN_EXC_STATE_DAR THREAD_FLD(dar) #elif defined(I386) || defined(X86_64) # if CPP_WORDSZ == 32 # if defined(i386_EXCEPTION_STATE_COUNT) \ && !defined(x86_EXCEPTION_STATE32_COUNT) /* Use old naming convention for 32-bit x86. */ # define DARWIN_EXC_STATE i386_EXCEPTION_STATE # define DARWIN_EXC_STATE_COUNT i386_EXCEPTION_STATE_COUNT # define DARWIN_EXC_STATE_T i386_exception_state_t # else # define DARWIN_EXC_STATE x86_EXCEPTION_STATE32 # define DARWIN_EXC_STATE_COUNT x86_EXCEPTION_STATE32_COUNT # define DARWIN_EXC_STATE_T x86_exception_state32_t # endif # else # define DARWIN_EXC_STATE x86_EXCEPTION_STATE64 # define DARWIN_EXC_STATE_COUNT x86_EXCEPTION_STATE64_COUNT # define DARWIN_EXC_STATE_T x86_exception_state64_t # endif # define DARWIN_EXC_STATE_DAR THREAD_FLD(faultvaddr) #else # error FIXME for non-arm/ppc/x86 darwin #endif /* This violates the namespace rules but there isn't anything that can */ /* be done about it. The exception handling stuff is hard coded to */ /* call this. catch_exception_raise, catch_exception_raise_state and */ /* and catch_exception_raise_state_identity are called from OS. */ GC_API_OSCALL kern_return_t catch_exception_raise(mach_port_t exception_port GC_ATTR_UNUSED, mach_port_t thread, mach_port_t task GC_ATTR_UNUSED, exception_type_t exception, exception_data_t code, mach_msg_type_number_t code_count GC_ATTR_UNUSED) { kern_return_t r; char *addr; struct hblk *h; unsigned int i; thread_state_flavor_t flavor = DARWIN_EXC_STATE; mach_msg_type_number_t exc_state_count = DARWIN_EXC_STATE_COUNT; DARWIN_EXC_STATE_T exc_state; if (exception != EXC_BAD_ACCESS || code[0] != KERN_PROTECTION_FAILURE) { # ifdef DEBUG_EXCEPTION_HANDLING /* We aren't interested, pass it on to the old handler */ GC_log_printf("Exception: 0x%x Code: 0x%x 0x%x in catch...\n", exception, code_count > 0 ? code[0] : -1, code_count > 1 ? code[1] : -1); # endif return FWD(); } r = thread_get_state(thread, flavor, (natural_t*)&exc_state, &exc_state_count); if(r != KERN_SUCCESS) { /* The thread is supposed to be suspended while the exception */ /* handler is called. This shouldn't fail. */ # ifdef BROKEN_EXCEPTION_HANDLING GC_err_printf("thread_get_state failed in catch_exception_raise\n"); return KERN_SUCCESS; # else ABORT("thread_get_state failed in catch_exception_raise"); # endif } /* This is the address that caused the fault */ addr = (char*) exc_state.DARWIN_EXC_STATE_DAR; if (HDR(addr) == 0) { /* Ugh... just like the SIGBUS problem above, it seems we get */ /* a bogus KERN_PROTECTION_FAILURE every once and a while. We wait */ /* till we get a bunch in a row before doing anything about it. */ /* If a "real" fault ever occurs it'll just keep faulting over and */ /* over and we'll hit the limit pretty quickly. */ # ifdef BROKEN_EXCEPTION_HANDLING static char *last_fault; static int last_fault_count; if(addr != last_fault) { last_fault = addr; last_fault_count = 0; } if(++last_fault_count < 32) { if(last_fault_count == 1) WARN("Ignoring KERN_PROTECTION_FAILURE at %p\n", addr); return KERN_SUCCESS; } GC_err_printf( "Unexpected KERN_PROTECTION_FAILURE at %p; aborting...\n", addr); /* Can't pass it along to the signal handler because that is */ /* ignoring SIGBUS signals. We also shouldn't call ABORT here as */ /* signals don't always work too well from the exception handler. */ EXIT(); # else /* BROKEN_EXCEPTION_HANDLING */ /* Pass it along to the next exception handler (which should call SIGBUS/SIGSEGV) */ return FWD(); # endif /* !BROKEN_EXCEPTION_HANDLING */ } # ifdef BROKEN_EXCEPTION_HANDLING /* Reset the number of consecutive SIGBUSs */ GC_sigbus_count = 0; # endif if (GC_mprotect_state == GC_MP_NORMAL) { /* common case */ h = (struct hblk*)((word)addr & ~(GC_page_size-1)); UNPROTECT(h, GC_page_size); for (i = 0; i < divHBLKSZ(GC_page_size); i++) { register int index = PHT_HASH(h+i); async_set_pht_entry_from_index(GC_dirty_pages, index); } } else if (GC_mprotect_state == GC_MP_DISCARDING) { /* Lie to the thread for now. No sense UNPROTECT()ing the memory when we're just going to PROTECT() it again later. The thread will just fault again once it resumes */ } else { /* Shouldn't happen, i don't think */ GC_err_printf("KERN_PROTECTION_FAILURE while world is stopped\n"); return FWD(); } return KERN_SUCCESS; } #undef FWD #ifndef NO_DESC_CATCH_EXCEPTION_RAISE /* These symbols should have REFERENCED_DYNAMICALLY (0x10) bit set to */ /* let strip know they are not to be stripped. */ __asm__(".desc _catch_exception_raise, 0x10"); __asm__(".desc _catch_exception_raise_state, 0x10"); __asm__(".desc _catch_exception_raise_state_identity, 0x10"); #endif #endif /* DARWIN && MPROTECT_VDB */ #ifndef HAVE_INCREMENTAL_PROTECTION_NEEDS GC_API int GC_CALL GC_incremental_protection_needs(void) { return GC_PROTECTS_NONE; } #endif /* !HAVE_INCREMENTAL_PROTECTION_NEEDS */ #ifdef ECOS /* Undo sbrk() redirection. */ # undef sbrk #endif /* If value is non-zero then allocate executable memory. */ GC_API void GC_CALL GC_set_pages_executable(int value) { GC_ASSERT(!GC_is_initialized); /* Even if IGNORE_PAGES_EXECUTABLE is defined, GC_pages_executable is */ /* touched here to prevent a compiler warning. */ GC_pages_executable = (GC_bool)(value != 0); } /* Returns non-zero if the GC-allocated memory is executable. */ /* GC_get_pages_executable is defined after all the places */ /* where GC_get_pages_executable is undefined. */ GC_API int GC_CALL GC_get_pages_executable(void) { # ifdef IGNORE_PAGES_EXECUTABLE return 1; /* Always allocate executable memory. */ # else return (int)GC_pages_executable; # endif } /* Call stack save code for debugging. Should probably be in */ /* mach_dep.c, but that requires reorganization. */ /* I suspect the following works for most X86 *nix variants, so */ /* long as the frame pointer is explicitly stored. In the case of gcc, */ /* compiler flags (e.g. -fomit-frame-pointer) determine whether it is. */ #if defined(I386) && defined(LINUX) && defined(SAVE_CALL_CHAIN) # include struct frame { struct frame *fr_savfp; long fr_savpc; long fr_arg[NARGS]; /* All the arguments go here. */ }; #endif #if defined(SPARC) # if defined(LINUX) # include struct frame { long fr_local[8]; long fr_arg[6]; struct frame *fr_savfp; long fr_savpc; # ifndef __arch64__ char *fr_stret; # endif long fr_argd[6]; long fr_argx[0]; }; # elif defined (DRSNX) # include # elif defined(OPENBSD) # include # elif defined(FREEBSD) || defined(NETBSD) # include # else # include # endif # if NARGS > 6 # error We only know how to get the first 6 arguments # endif #endif /* SPARC */ #ifdef NEED_CALLINFO /* Fill in the pc and argument information for up to NFRAMES of my */ /* callers. Ignore my frame and my callers frame. */ #ifdef LINUX # include #endif #endif /* NEED_CALLINFO */ #if defined(GC_HAVE_BUILTIN_BACKTRACE) # ifdef _MSC_VER # include "private/msvc_dbg.h" # else # include # endif #endif #ifdef SAVE_CALL_CHAIN #if NARGS == 0 && NFRAMES % 2 == 0 /* No padding */ \ && defined(GC_HAVE_BUILTIN_BACKTRACE) #ifdef REDIRECT_MALLOC /* Deal with possible malloc calls in backtrace by omitting */ /* the infinitely recursing backtrace. */ # ifdef THREADS __thread /* If your compiler doesn't understand this */ /* you could use something like pthread_getspecific. */ # endif GC_in_save_callers = FALSE; #endif GC_INNER void GC_save_callers(struct callinfo info[NFRAMES]) { void * tmp_info[NFRAMES + 1]; int npcs, i; # define IGNORE_FRAMES 1 /* We retrieve NFRAMES+1 pc values, but discard the first, since it */ /* points to our own frame. */ # ifdef REDIRECT_MALLOC if (GC_in_save_callers) { info[0].ci_pc = (word)(&GC_save_callers); for (i = 1; i < NFRAMES; ++i) info[i].ci_pc = 0; return; } GC_in_save_callers = TRUE; # endif GC_STATIC_ASSERT(sizeof(struct callinfo) == sizeof(void *)); npcs = backtrace((void **)tmp_info, NFRAMES + IGNORE_FRAMES); BCOPY(tmp_info+IGNORE_FRAMES, info, (npcs - IGNORE_FRAMES) * sizeof(void *)); for (i = npcs - IGNORE_FRAMES; i < NFRAMES; ++i) info[i].ci_pc = 0; # ifdef REDIRECT_MALLOC GC_in_save_callers = FALSE; # endif } #else /* No builtin backtrace; do it ourselves */ #if (defined(OPENBSD) || defined(NETBSD) || defined(FREEBSD)) && defined(SPARC) # define FR_SAVFP fr_fp # define FR_SAVPC fr_pc #else # define FR_SAVFP fr_savfp # define FR_SAVPC fr_savpc #endif #if defined(SPARC) && (defined(__arch64__) || defined(__sparcv9)) # define BIAS 2047 #else # define BIAS 0 #endif GC_INNER void GC_save_callers(struct callinfo info[NFRAMES]) { struct frame *frame; struct frame *fp; int nframes = 0; # ifdef I386 /* We assume this is turned on only with gcc as the compiler. */ asm("movl %%ebp,%0" : "=r"(frame)); fp = frame; # else frame = (struct frame *)GC_save_regs_in_stack(); fp = (struct frame *)((long) frame -> FR_SAVFP + BIAS); #endif for (; !((word)fp HOTTER_THAN (word)frame) && !((word)GC_stackbottom HOTTER_THAN (word)fp) && nframes < NFRAMES; fp = (struct frame *)((long) fp -> FR_SAVFP + BIAS), nframes++) { # if NARGS > 0 register int i; # endif info[nframes].ci_pc = fp->FR_SAVPC; # if NARGS > 0 for (i = 0; i < NARGS; i++) { info[nframes].ci_arg[i] = ~(fp->fr_arg[i]); } # endif /* NARGS > 0 */ } if (nframes < NFRAMES) info[nframes].ci_pc = 0; } #endif /* No builtin backtrace */ #endif /* SAVE_CALL_CHAIN */ #ifdef NEED_CALLINFO /* Print info to stderr. We do NOT hold the allocation lock */ GC_INNER void GC_print_callers(struct callinfo info[NFRAMES]) { int i; static int reentry_count = 0; GC_bool stop = FALSE; DCL_LOCK_STATE; /* FIXME: This should probably use a different lock, so that we */ /* become callable with or without the allocation lock. */ LOCK(); ++reentry_count; UNLOCK(); # if NFRAMES == 1 GC_err_printf("\tCaller at allocation:\n"); # else GC_err_printf("\tCall chain at allocation:\n"); # endif for (i = 0; i < NFRAMES && !stop; i++) { if (info[i].ci_pc == 0) break; # if NARGS > 0 { int j; GC_err_printf("\t\targs: "); for (j = 0; j < NARGS; j++) { if (j != 0) GC_err_printf(", "); GC_err_printf("%d (0x%X)", ~(info[i].ci_arg[j]), ~(info[i].ci_arg[j])); } GC_err_printf("\n"); } # endif if (reentry_count > 1) { /* We were called during an allocation during */ /* a previous GC_print_callers call; punt. */ GC_err_printf("\t\t##PC##= 0x%lx\n", info[i].ci_pc); continue; } { # if defined(GC_HAVE_BUILTIN_BACKTRACE) \ && !defined(GC_BACKTRACE_SYMBOLS_BROKEN) char **sym_name = backtrace_symbols((void **)(&(info[i].ci_pc)), 1); char *name = sym_name[0]; # else char buf[40]; char *name = buf; (void)snprintf(buf, sizeof(buf), "##PC##= 0x%lx", info[i].ci_pc); buf[sizeof(buf) - 1] = '\0'; # endif # if defined(LINUX) && !defined(SMALL_CONFIG) /* Try for a line number. */ { FILE *pipe; # define EXE_SZ 100 static char exe_name[EXE_SZ]; # define CMD_SZ 200 char cmd_buf[CMD_SZ]; # define RESULT_SZ 200 static char result_buf[RESULT_SZ]; size_t result_len; char *old_preload; # define PRELOAD_SZ 200 char preload_buf[PRELOAD_SZ]; static GC_bool found_exe_name = FALSE; static GC_bool will_fail = FALSE; int ret_code; /* Try to get it via a hairy and expensive scheme. */ /* First we get the name of the executable: */ if (will_fail) goto out; if (!found_exe_name) { ret_code = readlink("/proc/self/exe", exe_name, EXE_SZ); if (ret_code < 0 || ret_code >= EXE_SZ || exe_name[0] != '/') { will_fail = TRUE; /* Don't try again. */ goto out; } exe_name[ret_code] = '\0'; found_exe_name = TRUE; } /* Then we use popen to start addr2line -e */ /* There are faster ways to do this, but hopefully this */ /* isn't time critical. */ (void)snprintf(cmd_buf, sizeof(cmd_buf), "/usr/bin/addr2line -f -e %s 0x%lx", exe_name, (unsigned long)info[i].ci_pc); cmd_buf[sizeof(cmd_buf) - 1] = '\0'; old_preload = GETENV("LD_PRELOAD"); if (0 != old_preload) { size_t old_len = strlen(old_preload); if (old_len >= PRELOAD_SZ) { will_fail = TRUE; goto out; } BCOPY(old_preload, preload_buf, old_len + 1); unsetenv ("LD_PRELOAD"); } pipe = popen(cmd_buf, "r"); if (0 != old_preload && 0 != setenv ("LD_PRELOAD", preload_buf, 0)) { WARN("Failed to reset LD_PRELOAD\n", 0); } if (pipe == NULL || (result_len = fread(result_buf, 1, RESULT_SZ - 1, pipe)) == 0) { if (pipe != NULL) pclose(pipe); will_fail = TRUE; goto out; } if (result_buf[result_len - 1] == '\n') --result_len; result_buf[result_len] = 0; if (result_buf[0] == '?' || (result_buf[result_len-2] == ':' && result_buf[result_len-1] == '0')) { pclose(pipe); goto out; } /* Get rid of embedded newline, if any. Test for "main" */ { char * nl = strchr(result_buf, '\n'); if (nl != NULL && (word)nl < (word)(result_buf + result_len)) { *nl = ':'; } if (strncmp(result_buf, "main", nl - result_buf) == 0) { stop = TRUE; } } if (result_len < RESULT_SZ - 25) { /* Add in hex address */ (void)snprintf(&result_buf[result_len], sizeof(result_buf) - result_len, " [0x%lx]", (unsigned long)info[i].ci_pc); result_buf[sizeof(result_buf) - 1] = '\0'; } name = result_buf; pclose(pipe); out:; } # endif /* LINUX */ GC_err_printf("\t\t%s\n", name); # if defined(GC_HAVE_BUILTIN_BACKTRACE) \ && !defined(GC_BACKTRACE_SYMBOLS_BROKEN) free(sym_name); /* May call GC_free; that's OK */ # endif } } LOCK(); --reentry_count; UNLOCK(); } #endif /* NEED_CALLINFO */ #if defined(LINUX) && defined(__ELF__) && !defined(SMALL_CONFIG) /* Dump /proc/self/maps to GC_stderr, to enable looking up names for */ /* addresses in FIND_LEAK output. */ void GC_print_address_map(void) { char *maps; GC_err_printf("---------- Begin address map ----------\n"); maps = GC_get_maps(); GC_err_puts(maps != NULL ? maps : "Failed to get map!\n"); GC_err_printf("---------- End address map ----------\n"); } #endif /* LINUX && ELF */ ecl-16.1.2/src/bdwgc/pcr_interface.c000066400000000000000000000115541266352375300172130ustar00rootroot00000000000000/* * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. */ # include "private/gc_priv.h" # ifdef PCR /* * Note that POSIX PCR requires an ANSI C compiler. Hence we are allowed * to make the same assumption here. * We wrap all of the allocator functions to avoid questions of * compatibility between the prototyped and nonprototyped versions of the f */ # include "config/PCR_StdTypes.h" # include "mm/PCR_MM.h" # include # define MY_MAGIC 17L # define MY_DEBUGMAGIC 42L void * GC_AllocProc(size_t size, PCR_Bool ptrFree, PCR_Bool clear ) { if (ptrFree) { void * result = (void *)GC_malloc_atomic(size); if (clear && result != 0) BZERO(result, size); return(result); } else { return((void *)GC_malloc(size)); } } void * GC_DebugAllocProc(size_t size, PCR_Bool ptrFree, PCR_Bool clear ) { if (ptrFree) { void * result = (void *)GC_debug_malloc_atomic(size, __FILE__, __LINE__); if (clear && result != 0) BZERO(result, size); return(result); } else { return((void *)GC_debug_malloc(size, __FILE__, __LINE__)); } } # define GC_ReallocProc GC_realloc void * GC_DebugReallocProc(void * old_object, size_t new_size_in_bytes) { return(GC_debug_realloc(old_object, new_size_in_bytes, __FILE__, __LINE__)); } # define GC_FreeProc GC_free # define GC_DebugFreeProc GC_debug_free typedef struct { PCR_ERes (*ed_proc)(void *p, size_t size, PCR_Any data); GC_bool ed_pointerfree; PCR_ERes ed_fail_code; PCR_Any ed_client_data; } enumerate_data; void GC_enumerate_block(struct hblk *h; enumerate_data * ed) { register hdr * hhdr; register int sz; ptr_t p; ptr_t lim; word descr; # error This code was updated without testing. # error and its precursor was clearly broken. hhdr = HDR(h); descr = hhdr -> hb_descr; sz = hhdr -> hb_sz; if (descr != 0 && ed -> ed_pointerfree || descr == 0 && !(ed -> ed_pointerfree)) return; lim = (ptr_t)(h+1) - sz; p = (ptr_t)h; do { if (PCR_ERes_IsErr(ed -> ed_fail_code)) return; ed -> ed_fail_code = (*(ed -> ed_proc))(p, sz, ed -> ed_client_data); p+= sz; } while ((word)p <= (word)lim); } struct PCR_MM_ProcsRep * GC_old_allocator = 0; PCR_ERes GC_EnumerateProc( PCR_Bool ptrFree, PCR_ERes (*proc)(void *p, size_t size, PCR_Any data), PCR_Any data ) { enumerate_data ed; ed.ed_proc = proc; ed.ed_pointerfree = ptrFree; ed.ed_fail_code = PCR_ERes_okay; ed.ed_client_data = data; GC_apply_to_all_blocks(GC_enumerate_block, &ed); if (ed.ed_fail_code != PCR_ERes_okay) { return(ed.ed_fail_code); } else { /* Also enumerate objects allocated by my predecessors */ return((*(GC_old_allocator->mmp_enumerate))(ptrFree, proc, data)); } } void GC_DummyFreeProc(void *p) {} void GC_DummyShutdownProc(void) {} struct PCR_MM_ProcsRep GC_Rep = { MY_MAGIC, GC_AllocProc, GC_ReallocProc, GC_DummyFreeProc, /* mmp_free */ GC_FreeProc, /* mmp_unsafeFree */ GC_EnumerateProc, GC_DummyShutdownProc /* mmp_shutdown */ }; struct PCR_MM_ProcsRep GC_DebugRep = { MY_DEBUGMAGIC, GC_DebugAllocProc, GC_DebugReallocProc, GC_DummyFreeProc, /* mmp_free */ GC_DebugFreeProc, /* mmp_unsafeFree */ GC_EnumerateProc, GC_DummyShutdownProc /* mmp_shutdown */ }; GC_bool GC_use_debug = 0; void GC_pcr_install() { PCR_MM_Install((GC_use_debug? &GC_DebugRep : &GC_Rep), &GC_old_allocator); } PCR_ERes PCR_GC_Setup(void) { return PCR_ERes_okay; } PCR_ERes PCR_GC_Run(void) { if( !PCR_Base_TestPCRArg("-nogc") ) { GC_quiet = ( PCR_Base_TestPCRArg("-gctrace") ? 0 : 1 ); GC_use_debug = (GC_bool)PCR_Base_TestPCRArg("-debug_alloc"); GC_init(); if( !PCR_Base_TestPCRArg("-nogc_incremental") ) { /* * awful hack to test whether VD is implemented ... */ if( PCR_VD_Start( 0, NIL, 0) != PCR_ERes_FromErr(ENOSYS) ) { GC_enable_incremental(); } } } return PCR_ERes_okay; } void GC_push_thread_structures(void) { /* PCR doesn't work unless static roots are pushed. Can't get here. */ ABORT("In GC_push_thread_structures()"); } # endif ecl-16.1.2/src/bdwgc/pthread_start.c000066400000000000000000000056231266352375300172530ustar00rootroot00000000000000/* * Copyright (c) 1994 by Xerox Corporation. All rights reserved. * Copyright (c) 1996 by Silicon Graphics. All rights reserved. * Copyright (c) 1998 by Fergus Henderson. All rights reserved. * Copyright (c) 2000-2010 by Hewlett-Packard Development Company. * All rights reserved. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. */ /* We want to make sure that GC_thread_exit_proc() is unconditionally */ /* invoked, even if the client is not compiled with -fexceptions, but */ /* the GC is. The workaround is to put GC_inner_start_routine() in its */ /* own file (pthread_start.c), and undefine __EXCEPTIONS in the GCC */ /* case at the top of the file. FIXME: it's still unclear whether this */ /* will actually cause the exit handler to be invoked last when */ /* thread_exit is called (and if -fexceptions is used). */ #if defined(__GNUC__) && defined(__linux__) /* We undefine __EXCEPTIONS to avoid using GCC __cleanup__ attribute. */ /* The current NPTL implementation of pthread_cleanup_push uses */ /* __cleanup__ attribute when __EXCEPTIONS is defined (-fexceptions). */ /* The stack unwinding and cleanup with __cleanup__ attributes work */ /* correctly when everything is compiled with -fexceptions, but it is */ /* not the requirement for this library clients to use -fexceptions */ /* everywhere. With __EXCEPTIONS undefined, the cleanup routines are */ /* registered with __pthread_register_cancel thus should work anyway. */ # undef __EXCEPTIONS #endif #include "private/pthread_support.h" #if defined(GC_PTHREADS) && !defined(GC_WIN32_THREADS) #include #include /* Invoked from GC_start_routine(). */ GC_INNER_PTHRSTART void * GC_CALLBACK GC_inner_start_routine( struct GC_stack_base *sb, void *arg) { void * (*start)(void *); void * start_arg; void * result; volatile GC_thread me = GC_start_rtn_prepare_thread(&start, &start_arg, sb, arg); # ifndef NACL pthread_cleanup_push(GC_thread_exit_proc, me); # endif result = (*start)(start_arg); # if defined(DEBUG_THREADS) && !defined(GC_PTHREAD_START_STANDALONE) GC_log_printf("Finishing thread %p\n", (void *)pthread_self()); # endif me -> status = result; # ifndef NACL pthread_cleanup_pop(1); /* Cleanup acquires lock, ensuring that we can't exit while */ /* a collection that thinks we're alive is trying to stop us. */ # endif return result; } #endif /* GC_PTHREADS */ ecl-16.1.2/src/bdwgc/pthread_stop_world.c000066400000000000000000000757331266352375300203230ustar00rootroot00000000000000/* * Copyright (c) 1994 by Xerox Corporation. All rights reserved. * Copyright (c) 1996 by Silicon Graphics. All rights reserved. * Copyright (c) 1998 by Fergus Henderson. All rights reserved. * Copyright (c) 2000-2009 by Hewlett-Packard Development Company. * All rights reserved. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. */ #include "private/pthread_support.h" #if defined(GC_PTHREADS) && !defined(GC_WIN32_THREADS) && \ !defined(GC_DARWIN_THREADS) #ifdef NACL #include #include STATIC int GC_nacl_num_gc_threads = 0; STATIC __thread int GC_nacl_thread_idx = -1; STATIC int GC_nacl_park_threads_now = 0; STATIC pthread_t GC_nacl_thread_parker = -1; GC_INNER __thread GC_thread GC_nacl_gc_thread_self = NULL; int GC_nacl_thread_parked[MAX_NACL_GC_THREADS]; int GC_nacl_thread_used[MAX_NACL_GC_THREADS]; #elif defined(GC_OPENBSD_UTHREADS) # include #else /* !GC_OPENBSD_UTHREADS && !NACL */ #include #include #include #include #include "atomic_ops.h" /* It's safe to call original pthread_sigmask() here. */ #undef pthread_sigmask #ifdef DEBUG_THREADS # ifndef NSIG # if defined(MAXSIG) # define NSIG (MAXSIG+1) # elif defined(_NSIG) # define NSIG _NSIG # elif defined(__SIGRTMAX) # define NSIG (__SIGRTMAX+1) # else --> please fix it # endif # endif /* NSIG */ void GC_print_sig_mask(void) { sigset_t blocked; int i; if (pthread_sigmask(SIG_BLOCK, NULL, &blocked) != 0) ABORT("pthread_sigmask failed"); for (i = 1; i < NSIG; i++) { if (sigismember(&blocked, i)) GC_printf("Signal blocked: %d\n", i); } } #endif /* DEBUG_THREADS */ /* Remove the signals that we want to allow in thread stopping */ /* handler from a set. */ STATIC void GC_remove_allowed_signals(sigset_t *set) { if (sigdelset(set, SIGINT) != 0 || sigdelset(set, SIGQUIT) != 0 || sigdelset(set, SIGABRT) != 0 || sigdelset(set, SIGTERM) != 0) { ABORT("sigdelset failed"); } # ifdef MPROTECT_VDB /* Handlers write to the thread structure, which is in the heap, */ /* and hence can trigger a protection fault. */ if (sigdelset(set, SIGSEGV) != 0 # ifdef SIGBUS || sigdelset(set, SIGBUS) != 0 # endif ) { ABORT("sigdelset failed"); } # endif } static sigset_t suspend_handler_mask; STATIC volatile AO_t GC_stop_count = 0; /* Incremented at the beginning of GC_stop_world. */ STATIC volatile AO_t GC_world_is_stopped = FALSE; /* FALSE ==> it is safe for threads to restart, i.e. */ /* they will see another suspend signal before they */ /* are expected to stop (unless they have voluntarily */ /* stopped). */ #ifdef GC_OSF1_THREADS STATIC GC_bool GC_retry_signals = TRUE; #else STATIC GC_bool GC_retry_signals = FALSE; #endif /* * We use signals to stop threads during GC. * * Suspended threads wait in signal handler for SIG_THR_RESTART. * That's more portable than semaphores or condition variables. * (We do use sem_post from a signal handler, but that should be portable.) * * The thread suspension signal SIG_SUSPEND is now defined in gc_priv.h. * Note that we can't just stop a thread; we need it to save its stack * pointer(s) and acknowledge. */ #ifndef SIG_THR_RESTART # if defined(GC_HPUX_THREADS) || defined(GC_OSF1_THREADS) \ || defined(GC_NETBSD_THREADS) || defined(GC_USESIGRT_SIGNALS) # ifdef _SIGRTMIN # define SIG_THR_RESTART _SIGRTMIN + 5 # else # define SIG_THR_RESTART SIGRTMIN + 5 # endif # else # define SIG_THR_RESTART SIGXCPU # endif #endif #define SIGNAL_UNSET (-1) /* Since SIG_SUSPEND and/or SIG_THR_RESTART could represent */ /* a non-constant expression (e.g., in case of SIGRTMIN), */ /* actual signal numbers are determined by GC_stop_init() */ /* unless manually set (before GC initialization). */ STATIC int GC_sig_suspend = SIGNAL_UNSET; STATIC int GC_sig_thr_restart = SIGNAL_UNSET; GC_API void GC_CALL GC_set_suspend_signal(int sig) { if (GC_is_initialized) return; GC_sig_suspend = sig; } GC_API void GC_CALL GC_set_thr_restart_signal(int sig) { if (GC_is_initialized) return; GC_sig_thr_restart = sig; } GC_API int GC_CALL GC_get_suspend_signal(void) { return GC_sig_suspend != SIGNAL_UNSET ? GC_sig_suspend : SIG_SUSPEND; } GC_API int GC_CALL GC_get_thr_restart_signal(void) { return GC_sig_thr_restart != SIGNAL_UNSET ? GC_sig_thr_restart : SIG_THR_RESTART; } #ifdef GC_EXPLICIT_SIGNALS_UNBLOCK /* Some targets (e.g., Solaris) might require this to be called when */ /* doing thread registering from the thread destructor. */ GC_INNER void GC_unblock_gc_signals(void) { sigset_t set; sigemptyset(&set); GC_ASSERT(GC_sig_suspend != SIGNAL_UNSET); GC_ASSERT(GC_sig_thr_restart != SIGNAL_UNSET); sigaddset(&set, GC_sig_suspend); sigaddset(&set, GC_sig_thr_restart); if (pthread_sigmask(SIG_UNBLOCK, &set, NULL) != 0) ABORT("pthread_sigmask failed"); } #endif /* GC_EXPLICIT_SIGNALS_UNBLOCK */ STATIC sem_t GC_suspend_ack_sem; #ifdef GC_NETBSD_THREADS # define GC_NETBSD_THREADS_WORKAROUND /* It seems to be necessary to wait until threads have restarted. */ /* But it is unclear why that is the case. */ STATIC sem_t GC_restart_ack_sem; #endif STATIC void GC_suspend_handler_inner(ptr_t sig_arg, void *context); #ifdef SA_SIGINFO STATIC void GC_suspend_handler(int sig, siginfo_t * info GC_ATTR_UNUSED, void * context GC_ATTR_UNUSED) #else STATIC void GC_suspend_handler(int sig) #endif { int old_errno = errno; # if defined(IA64) || defined(HP_PA) || defined(M68K) GC_with_callee_saves_pushed(GC_suspend_handler_inner, (ptr_t)(word)sig); # else /* We believe that in all other cases the full context is already */ /* in the signal handler frame. */ # ifndef SA_SIGINFO void *context = 0; # endif GC_suspend_handler_inner((ptr_t)(word)sig, context); # endif errno = old_errno; } STATIC void GC_suspend_handler_inner(ptr_t sig_arg, void * context GC_ATTR_UNUSED) { pthread_t self = pthread_self(); GC_thread me; IF_CANCEL(int cancel_state;) AO_t my_stop_count = AO_load(&GC_stop_count); if ((signed_word)sig_arg != GC_sig_suspend) { # if defined(GC_FREEBSD_THREADS) /* Workaround "deferred signal handling" bug in FreeBSD 9.2. */ if (0 == sig_arg) return; # endif ABORT("Bad signal in suspend_handler"); } DISABLE_CANCEL(cancel_state); /* pthread_setcancelstate is not defined to be async-signal-safe. */ /* But the glibc version appears to be in the absence of */ /* asynchronous cancellation. And since this signal handler */ /* to block on sigsuspend, which is both async-signal-safe */ /* and a cancellation point, there seems to be no obvious way */ /* out of it. In fact, it looks to me like an async-signal-safe */ /* cancellation point is inherently a problem, unless there is */ /* some way to disable cancellation in the handler. */ # ifdef DEBUG_THREADS GC_log_printf("Suspending %p\n", (void *)self); # endif me = GC_lookup_thread(self); /* The lookup here is safe, since I'm doing this on behalf */ /* of a thread which holds the allocation lock in order */ /* to stop the world. Thus concurrent modification of the */ /* data structure is impossible. */ if (me -> stop_info.last_stop_count == my_stop_count) { /* Duplicate signal. OK if we are retrying. */ if (!GC_retry_signals) { WARN("Duplicate suspend signal in thread %p\n", self); } RESTORE_CANCEL(cancel_state); return; } # ifdef SPARC me -> stop_info.stack_ptr = GC_save_regs_in_stack(); # else me -> stop_info.stack_ptr = GC_approx_sp(); # endif # ifdef IA64 me -> backing_store_ptr = GC_save_regs_in_stack(); # endif /* Tell the thread that wants to stop the world that this */ /* thread has been stopped. Note that sem_post() is */ /* the only async-signal-safe primitive in LinuxThreads. */ sem_post(&GC_suspend_ack_sem); me -> stop_info.last_stop_count = my_stop_count; /* Wait until that thread tells us to restart by sending */ /* this thread a GC_sig_thr_restart signal (should be masked */ /* at this point thus there is no race). */ /* We do not continue until we receive that signal, */ /* but we do not take that as authoritative. (We may be */ /* accidentally restarted by one of the user signals we */ /* don't block.) After we receive the signal, we use a */ /* primitive and expensive mechanism to wait until it's */ /* really safe to proceed. Under normal circumstances, */ /* this code should not be executed. */ do { sigsuspend (&suspend_handler_mask); } while (AO_load_acquire(&GC_world_is_stopped) && AO_load(&GC_stop_count) == my_stop_count); /* If the RESTART signal gets lost, we can still lose. That should */ /* be less likely than losing the SUSPEND signal, since we don't do */ /* much between the sem_post and sigsuspend. */ /* We'd need more handshaking to work around that. */ /* Simply dropping the sigsuspend call should be safe, but is */ /* unlikely to be efficient. */ # ifdef DEBUG_THREADS GC_log_printf("Continuing %p\n", (void *)self); # endif RESTORE_CANCEL(cancel_state); } STATIC void GC_restart_handler(int sig) { # if defined(DEBUG_THREADS) || defined(GC_NETBSD_THREADS_WORKAROUND) int old_errno = errno; /* Preserve errno value. */ # endif if (sig != GC_sig_thr_restart) ABORT("Bad signal in restart handler"); # ifdef GC_NETBSD_THREADS_WORKAROUND sem_post(&GC_restart_ack_sem); # endif /* ** Note: even if we don't do anything useful here, ** it would still be necessary to have a signal handler, ** rather than ignoring the signals, otherwise ** the signals will not be delivered at all, and ** will thus not interrupt the sigsuspend() above. */ # ifdef DEBUG_THREADS GC_log_printf("In GC_restart_handler for %p\n", (void *)pthread_self()); # endif # if defined(DEBUG_THREADS) || defined(GC_NETBSD_THREADS_WORKAROUND) errno = old_errno; # endif } #endif /* !GC_OPENBSD_UTHREADS && !NACL */ #ifdef IA64 # define IF_IA64(x) x #else # define IF_IA64(x) #endif /* We hold allocation lock. Should do exactly the right thing if the */ /* world is stopped. Should not fail if it isn't. */ GC_INNER void GC_push_all_stacks(void) { GC_bool found_me = FALSE; size_t nthreads = 0; int i; GC_thread p; ptr_t lo, hi; /* On IA64, we also need to scan the register backing store. */ IF_IA64(ptr_t bs_lo; ptr_t bs_hi;) struct GC_traced_stack_sect_s *traced_stack_sect; pthread_t self = pthread_self(); word total_size = 0; if (!EXPECT(GC_thr_initialized, TRUE)) GC_thr_init(); # ifdef DEBUG_THREADS GC_log_printf("Pushing stacks from thread %p\n", (void *)self); # endif for (i = 0; i < THREAD_TABLE_SZ; i++) { for (p = GC_threads[i]; p != 0; p = p -> next) { if (p -> flags & FINISHED) continue; ++nthreads; traced_stack_sect = p -> traced_stack_sect; if (THREAD_EQUAL(p -> id, self)) { GC_ASSERT(!p->thread_blocked); # ifdef SPARC lo = (ptr_t)GC_save_regs_in_stack(); # else lo = GC_approx_sp(); # endif found_me = TRUE; IF_IA64(bs_hi = (ptr_t)GC_save_regs_in_stack();) } else { lo = p -> stop_info.stack_ptr; IF_IA64(bs_hi = p -> backing_store_ptr;) if (traced_stack_sect != NULL && traced_stack_sect->saved_stack_ptr == lo) { /* If the thread has never been stopped since the recent */ /* GC_call_with_gc_active invocation then skip the top */ /* "stack section" as stack_ptr already points to. */ traced_stack_sect = traced_stack_sect->prev; } } if ((p -> flags & MAIN_THREAD) == 0) { hi = p -> stack_end; IF_IA64(bs_lo = p -> backing_store_end); } else { /* The original stack. */ hi = GC_stackbottom; IF_IA64(bs_lo = BACKING_STORE_BASE;) } # ifdef DEBUG_THREADS GC_log_printf("Stack for thread %p = [%p,%p)\n", (void *)p->id, lo, hi); # endif if (0 == lo) ABORT("GC_push_all_stacks: sp not set!"); GC_push_all_stack_sections(lo, hi, traced_stack_sect); # ifdef STACK_GROWS_UP total_size += lo - hi; # else total_size += hi - lo; /* lo <= hi */ # endif # ifdef NACL /* Push reg_storage as roots, this will cover the reg context. */ GC_push_all_stack((ptr_t)p -> stop_info.reg_storage, (ptr_t)(p -> stop_info.reg_storage + NACL_GC_REG_STORAGE_SIZE)); total_size += NACL_GC_REG_STORAGE_SIZE * sizeof(ptr_t); # endif # ifdef IA64 # ifdef DEBUG_THREADS GC_log_printf("Reg stack for thread %p = [%p,%p)\n", (void *)p->id, bs_lo, bs_hi); # endif /* FIXME: This (if p->id==self) may add an unbounded number of */ /* entries, and hence overflow the mark stack, which is bad. */ GC_push_all_register_sections(bs_lo, bs_hi, THREAD_EQUAL(p -> id, self), traced_stack_sect); total_size += bs_hi - bs_lo; /* bs_lo <= bs_hi */ # endif } } GC_VERBOSE_LOG_PRINTF("Pushed %d thread stacks\n", (int)nthreads); if (!found_me && !GC_in_thread_creation) ABORT("Collecting from unknown thread"); GC_total_stacksize = total_size; } #ifdef DEBUG_THREADS /* There seems to be a very rare thread stopping problem. To help us */ /* debug that, we save the ids of the stopping thread. */ pthread_t GC_stopping_thread; int GC_stopping_pid = 0; #endif #ifdef PLATFORM_ANDROID extern int tkill(pid_t tid, int sig); /* from sys/linux-unistd.h */ static int android_thread_kill(pid_t tid, int sig) { int ret; int old_errno = errno; ret = tkill(tid, sig); if (ret < 0) { ret = errno; errno = old_errno; } return ret; } #endif /* PLATFORM_ANDROID */ /* We hold the allocation lock. Suspend all threads that might */ /* still be running. Return the number of suspend signals that */ /* were sent. */ STATIC int GC_suspend_all(void) { int n_live_threads = 0; int i; # ifndef NACL GC_thread p; # ifndef GC_OPENBSD_UTHREADS int result; # endif pthread_t self = pthread_self(); # ifdef DEBUG_THREADS GC_stopping_thread = self; GC_stopping_pid = getpid(); # endif for (i = 0; i < THREAD_TABLE_SZ; i++) { for (p = GC_threads[i]; p != 0; p = p -> next) { if (!THREAD_EQUAL(p -> id, self)) { if (p -> flags & FINISHED) continue; if (p -> thread_blocked) /* Will wait */ continue; # ifndef GC_OPENBSD_UTHREADS if (p -> stop_info.last_stop_count == GC_stop_count) continue; n_live_threads++; # endif # ifdef DEBUG_THREADS GC_log_printf("Sending suspend signal to %p\n", (void *)p->id); # endif # ifdef GC_OPENBSD_UTHREADS { stack_t stack; if (pthread_suspend_np(p -> id) != 0) ABORT("pthread_suspend_np failed"); if (pthread_stackseg_np(p->id, &stack)) ABORT("pthread_stackseg_np failed"); p -> stop_info.stack_ptr = (ptr_t)stack.ss_sp - stack.ss_size; } # else # ifndef PLATFORM_ANDROID result = pthread_kill(p -> id, GC_sig_suspend); # else result = android_thread_kill(p -> kernel_id, GC_sig_suspend); # endif switch(result) { case ESRCH: /* Not really there anymore. Possible? */ n_live_threads--; break; case 0: break; default: ABORT_ARG1("pthread_kill failed at suspend", ": errcode= %d", result); } # endif } } } # else /* NACL */ # ifndef NACL_PARK_WAIT_NANOSECONDS # define NACL_PARK_WAIT_NANOSECONDS (100 * 1000) # endif # define NANOS_PER_SECOND (1000UL * 1000 * 1000) unsigned long num_sleeps = 0; # ifdef DEBUG_THREADS GC_log_printf("pthread_stop_world: num_threads %d\n", GC_nacl_num_gc_threads - 1); # endif GC_nacl_thread_parker = pthread_self(); GC_nacl_park_threads_now = 1; # ifdef DEBUG_THREADS GC_stopping_thread = GC_nacl_thread_parker; GC_stopping_pid = getpid(); # endif while (1) { int num_threads_parked = 0; struct timespec ts; int num_used = 0; /* Check the 'parked' flag for each thread the GC knows about. */ for (i = 0; i < MAX_NACL_GC_THREADS && num_used < GC_nacl_num_gc_threads; i++) { if (GC_nacl_thread_used[i] == 1) { num_used++; if (GC_nacl_thread_parked[i] == 1) { num_threads_parked++; } } } /* -1 for the current thread. */ if (num_threads_parked >= GC_nacl_num_gc_threads - 1) break; ts.tv_sec = 0; ts.tv_nsec = NACL_PARK_WAIT_NANOSECONDS; # ifdef DEBUG_THREADS GC_log_printf("Sleep waiting for %d threads to park...\n", GC_nacl_num_gc_threads - num_threads_parked - 1); # endif /* This requires _POSIX_TIMERS feature. */ nanosleep(&ts, 0); if (++num_sleeps > NANOS_PER_SECOND / NACL_PARK_WAIT_NANOSECONDS) { WARN("GC appears stalled waiting for %" WARN_PRIdPTR " threads to park...\n", GC_nacl_num_gc_threads - num_threads_parked - 1); num_sleeps = 0; } } # endif /* NACL */ return n_live_threads; } GC_INNER void GC_stop_world(void) { # if !defined(GC_OPENBSD_UTHREADS) && !defined(NACL) int i; int n_live_threads; int code; # endif GC_ASSERT(I_HOLD_LOCK()); # ifdef DEBUG_THREADS GC_log_printf("Stopping the world from %p\n", (void *)pthread_self()); # endif /* Make sure all free list construction has stopped before we start. */ /* No new construction can start, since free list construction is */ /* required to acquire and release the GC lock before it starts, */ /* and we have the lock. */ # ifdef PARALLEL_MARK if (GC_parallel) { GC_acquire_mark_lock(); GC_ASSERT(GC_fl_builder_count == 0); /* We should have previously waited for it to become zero. */ } # endif /* PARALLEL_MARK */ # if defined(GC_OPENBSD_UTHREADS) || defined(NACL) (void)GC_suspend_all(); # else AO_store(&GC_stop_count, GC_stop_count+1); /* Only concurrent reads are possible. */ AO_store_release(&GC_world_is_stopped, TRUE); n_live_threads = GC_suspend_all(); if (GC_retry_signals) { unsigned long wait_usecs = 0; /* Total wait since retry. */ # define WAIT_UNIT 3000 # define RETRY_INTERVAL 100000 for (;;) { int ack_count; sem_getvalue(&GC_suspend_ack_sem, &ack_count); if (ack_count == n_live_threads) break; if (wait_usecs > RETRY_INTERVAL) { int newly_sent = GC_suspend_all(); GC_COND_LOG_PRINTF("Resent %d signals after timeout\n", newly_sent); sem_getvalue(&GC_suspend_ack_sem, &ack_count); if (newly_sent < n_live_threads - ack_count) { WARN("Lost some threads during GC_stop_world?!\n",0); n_live_threads = ack_count + newly_sent; } wait_usecs = 0; } usleep(WAIT_UNIT); wait_usecs += WAIT_UNIT; } } for (i = 0; i < n_live_threads; i++) { retry: code = sem_wait(&GC_suspend_ack_sem); if (0 != code) { /* On Linux, sem_wait is documented to always return zero. */ /* But the documentation appears to be incorrect. */ if (errno == EINTR) { /* Seems to happen with some versions of gdb. */ goto retry; } ABORT("sem_wait for handler failed"); } } # endif # ifdef PARALLEL_MARK if (GC_parallel) GC_release_mark_lock(); # endif # ifdef DEBUG_THREADS GC_log_printf("World stopped from %p\n", (void *)pthread_self()); GC_stopping_thread = 0; # endif } #ifdef NACL # if defined(__x86_64__) # define NACL_STORE_REGS() \ do { \ __asm__ __volatile__ ("push %rbx"); \ __asm__ __volatile__ ("push %rbp"); \ __asm__ __volatile__ ("push %r12"); \ __asm__ __volatile__ ("push %r13"); \ __asm__ __volatile__ ("push %r14"); \ __asm__ __volatile__ ("push %r15"); \ __asm__ __volatile__ ("mov %%esp, %0" \ : "=m" (GC_nacl_gc_thread_self->stop_info.stack_ptr)); \ BCOPY(GC_nacl_gc_thread_self->stop_info.stack_ptr, \ GC_nacl_gc_thread_self->stop_info.reg_storage, \ NACL_GC_REG_STORAGE_SIZE * sizeof(ptr_t)); \ __asm__ __volatile__ ("naclasp $48, %r15"); \ } while (0) # elif defined(__i386__) # define NACL_STORE_REGS() \ do { \ __asm__ __volatile__ ("push %ebx"); \ __asm__ __volatile__ ("push %ebp"); \ __asm__ __volatile__ ("push %esi"); \ __asm__ __volatile__ ("push %edi"); \ __asm__ __volatile__ ("mov %%esp, %0" \ : "=m" (GC_nacl_gc_thread_self->stop_info.stack_ptr)); \ BCOPY(GC_nacl_gc_thread_self->stop_info.stack_ptr, \ GC_nacl_gc_thread_self->stop_info.reg_storage, \ NACL_GC_REG_STORAGE_SIZE * sizeof(ptr_t));\ __asm__ __volatile__ ("add $16, %esp"); \ } while (0) # else # error FIXME for non-amd64/x86 NaCl # endif GC_API_OSCALL void nacl_pre_syscall_hook(void) { if (GC_nacl_thread_idx != -1) { NACL_STORE_REGS(); GC_nacl_gc_thread_self->stop_info.stack_ptr = GC_approx_sp(); GC_nacl_thread_parked[GC_nacl_thread_idx] = 1; } } GC_API_OSCALL void __nacl_suspend_thread_if_needed(void) { if (GC_nacl_park_threads_now) { pthread_t self = pthread_self(); /* Don't try to park the thread parker. */ if (GC_nacl_thread_parker == self) return; /* This can happen when a thread is created outside of the GC */ /* system (wthread mostly). */ if (GC_nacl_thread_idx < 0) return; /* If it was already 'parked', we're returning from a syscall, */ /* so don't bother storing registers again, the GC has a set. */ if (!GC_nacl_thread_parked[GC_nacl_thread_idx]) { NACL_STORE_REGS(); GC_nacl_gc_thread_self->stop_info.stack_ptr = GC_approx_sp(); } GC_nacl_thread_parked[GC_nacl_thread_idx] = 1; while (GC_nacl_park_threads_now) { /* Just spin. */ } GC_nacl_thread_parked[GC_nacl_thread_idx] = 0; /* Clear out the reg storage for next suspend. */ BZERO(GC_nacl_gc_thread_self->stop_info.reg_storage, NACL_GC_REG_STORAGE_SIZE * sizeof(ptr_t)); } } GC_API_OSCALL void nacl_post_syscall_hook(void) { /* Calling __nacl_suspend_thread_if_needed right away should */ /* guarantee we don't mutate the GC set. */ __nacl_suspend_thread_if_needed(); if (GC_nacl_thread_idx != -1) { GC_nacl_thread_parked[GC_nacl_thread_idx] = 0; } } STATIC GC_bool GC_nacl_thread_parking_inited = FALSE; STATIC pthread_mutex_t GC_nacl_thread_alloc_lock = PTHREAD_MUTEX_INITIALIZER; extern void nacl_register_gc_hooks(void (*pre)(void), void (*post)(void)); GC_INNER void GC_nacl_initialize_gc_thread(void) { int i; nacl_register_gc_hooks(nacl_pre_syscall_hook, nacl_post_syscall_hook); pthread_mutex_lock(&GC_nacl_thread_alloc_lock); if (!EXPECT(GC_nacl_thread_parking_inited, TRUE)) { BZERO(GC_nacl_thread_parked, sizeof(GC_nacl_thread_parked)); BZERO(GC_nacl_thread_used, sizeof(GC_nacl_thread_used)); GC_nacl_thread_parking_inited = TRUE; } GC_ASSERT(GC_nacl_num_gc_threads <= MAX_NACL_GC_THREADS); for (i = 0; i < MAX_NACL_GC_THREADS; i++) { if (GC_nacl_thread_used[i] == 0) { GC_nacl_thread_used[i] = 1; GC_nacl_thread_idx = i; GC_nacl_num_gc_threads++; break; } } pthread_mutex_unlock(&GC_nacl_thread_alloc_lock); } GC_INNER void GC_nacl_shutdown_gc_thread(void) { pthread_mutex_lock(&GC_nacl_thread_alloc_lock); GC_ASSERT(GC_nacl_thread_idx >= 0); GC_ASSERT(GC_nacl_thread_idx < MAX_NACL_GC_THREADS); GC_ASSERT(GC_nacl_thread_used[GC_nacl_thread_idx] != 0); GC_nacl_thread_used[GC_nacl_thread_idx] = 0; GC_nacl_thread_idx = -1; GC_nacl_num_gc_threads--; pthread_mutex_unlock(&GC_nacl_thread_alloc_lock); } #endif /* NACL */ /* Caller holds allocation lock, and has held it continuously since */ /* the world stopped. */ GC_INNER void GC_start_world(void) { # ifndef NACL pthread_t self = pthread_self(); register int i; register GC_thread p; # ifndef GC_OPENBSD_UTHREADS register int n_live_threads = 0; register int result; # endif # ifdef GC_NETBSD_THREADS_WORKAROUND int code; # endif # ifdef DEBUG_THREADS GC_log_printf("World starting\n"); # endif # ifndef GC_OPENBSD_UTHREADS AO_store(&GC_world_is_stopped, FALSE); # endif for (i = 0; i < THREAD_TABLE_SZ; i++) { for (p = GC_threads[i]; p != 0; p = p -> next) { if (!THREAD_EQUAL(p -> id, self)) { if (p -> flags & FINISHED) continue; if (p -> thread_blocked) continue; # ifndef GC_OPENBSD_UTHREADS n_live_threads++; # endif # ifdef DEBUG_THREADS GC_log_printf("Sending restart signal to %p\n", (void *)p->id); # endif # ifdef GC_OPENBSD_UTHREADS if (pthread_resume_np(p -> id) != 0) ABORT("pthread_resume_np failed"); # else # ifndef PLATFORM_ANDROID result = pthread_kill(p -> id, GC_sig_thr_restart); # else result = android_thread_kill(p -> kernel_id, GC_sig_thr_restart); # endif switch(result) { case ESRCH: /* Not really there anymore. Possible? */ n_live_threads--; break; case 0: break; default: ABORT_ARG1("pthread_kill failed at resume", ": errcode= %d", result); } # endif } } } # ifdef GC_NETBSD_THREADS_WORKAROUND for (i = 0; i < n_live_threads; i++) { while (0 != (code = sem_wait(&GC_restart_ack_sem))) { if (errno != EINTR) { ABORT_ARG1("sem_wait() for restart handler failed", ": errcode= %d", code); } } } # endif # ifdef DEBUG_THREADS GC_log_printf("World started\n"); # endif # else /* NACL */ # ifdef DEBUG_THREADS GC_log_printf("World starting...\n"); # endif GC_nacl_park_threads_now = 0; # endif } GC_INNER void GC_stop_init(void) { # if !defined(GC_OPENBSD_UTHREADS) && !defined(NACL) struct sigaction act; if (SIGNAL_UNSET == GC_sig_suspend) GC_sig_suspend = SIG_SUSPEND; if (SIGNAL_UNSET == GC_sig_thr_restart) GC_sig_thr_restart = SIG_THR_RESTART; if (GC_sig_suspend == GC_sig_thr_restart) ABORT("Cannot use same signal for thread suspend and resume"); if (sem_init(&GC_suspend_ack_sem, GC_SEM_INIT_PSHARED, 0) != 0) ABORT("sem_init failed"); # ifdef GC_NETBSD_THREADS_WORKAROUND if (sem_init(&GC_restart_ack_sem, GC_SEM_INIT_PSHARED, 0) != 0) ABORT("sem_init failed"); # endif # ifdef SA_RESTART act.sa_flags = SA_RESTART # else act.sa_flags = 0 # endif # ifdef SA_SIGINFO | SA_SIGINFO # endif ; if (sigfillset(&act.sa_mask) != 0) { ABORT("sigfillset failed"); } # ifdef GC_RTEMS_PTHREADS if(sigprocmask(SIG_UNBLOCK, &act.sa_mask, NULL) != 0) { ABORT("sigprocmask failed"); } # endif GC_remove_allowed_signals(&act.sa_mask); /* GC_sig_thr_restart is set in the resulting mask. */ /* It is unmasked by the handler when necessary. */ # ifdef SA_SIGINFO act.sa_sigaction = GC_suspend_handler; # else act.sa_handler = GC_suspend_handler; # endif /* act.sa_restorer is deprecated and should not be initialized. */ if (sigaction(GC_sig_suspend, &act, NULL) != 0) { ABORT("Cannot set SIG_SUSPEND handler"); } # ifdef SA_SIGINFO act.sa_flags &= ~SA_SIGINFO; # endif act.sa_handler = GC_restart_handler; if (sigaction(GC_sig_thr_restart, &act, NULL) != 0) { ABORT("Cannot set SIG_THR_RESTART handler"); } /* Initialize suspend_handler_mask (excluding GC_sig_thr_restart). */ if (sigfillset(&suspend_handler_mask) != 0) ABORT("sigfillset failed"); GC_remove_allowed_signals(&suspend_handler_mask); if (sigdelset(&suspend_handler_mask, GC_sig_thr_restart) != 0) ABORT("sigdelset failed"); /* Check for GC_RETRY_SIGNALS. */ if (0 != GETENV("GC_RETRY_SIGNALS")) { GC_retry_signals = TRUE; } if (0 != GETENV("GC_NO_RETRY_SIGNALS")) { GC_retry_signals = FALSE; } if (GC_retry_signals) { GC_COND_LOG_PRINTF("Will retry suspend signal if necessary\n"); } # endif /* !GC_OPENBSD_UTHREADS && !NACL */ } #endif /* GC_PTHREADS && !GC_DARWIN_THREADS && !GC_WIN32_THREADS */ ecl-16.1.2/src/bdwgc/pthread_support.c000066400000000000000000002135221266352375300176310ustar00rootroot00000000000000/* * Copyright (c) 1994 by Xerox Corporation. All rights reserved. * Copyright (c) 1996 by Silicon Graphics. All rights reserved. * Copyright (c) 1998 by Fergus Henderson. All rights reserved. * Copyright (c) 2000-2005 by Hewlett-Packard Company. All rights reserved. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. */ #include "private/pthread_support.h" /* * Support code originally for LinuxThreads, the clone()-based kernel * thread package for Linux which is included in libc6. * * This code no doubt makes some assumptions beyond what is * guaranteed by the pthread standard, though it now does * very little of that. It now also supports NPTL, and many * other Posix thread implementations. We are trying to merge * all flavors of pthread support code into this file. */ /* * Linux_threads.c now also includes some code to support HPUX and * OSF1 (Compaq Tru64 Unix, really). The OSF1 support is based on Eric Benson's * patch. * * Eric also suggested an alternate basis for a lock implementation in * his code: * + #elif defined(OSF1) * + unsigned long GC_allocate_lock = 0; * + msemaphore GC_allocate_semaphore; * + # define GC_TRY_LOCK() \ * + ((msem_lock(&GC_allocate_semaphore, MSEM_IF_NOWAIT) == 0) \ * + ? (GC_allocate_lock = 1) \ * + : 0) * + # define GC_LOCK_TAKEN GC_allocate_lock */ #if defined(GC_PTHREADS) && !defined(GC_WIN32_THREADS) # include # include # include # include # include # include # if !defined(GC_RTEMS_PTHREADS) # include # endif # include # include # include # include # include # include "gc_inline.h" #if defined(GC_DARWIN_THREADS) # include "private/darwin_semaphore.h" #else # include #endif /* !GC_DARWIN_THREADS */ #if defined(GC_DARWIN_THREADS) || defined(GC_FREEBSD_THREADS) # include #endif /* GC_DARWIN_THREADS */ #if defined(GC_NETBSD_THREADS) || defined(GC_OPENBSD_THREADS) # include # include #endif /* GC_NETBSD_THREADS */ /* Allocator lock definitions. */ #if !defined(USE_SPIN_LOCK) GC_INNER pthread_mutex_t GC_allocate_ml = PTHREAD_MUTEX_INITIALIZER; #endif #ifdef GC_ASSERTIONS GC_INNER unsigned long GC_lock_holder = NO_THREAD; /* Used only for assertions. */ #endif #if defined(GC_DGUX386_THREADS) # include # include /* sem_t is an uint in DG/UX */ typedef unsigned int sem_t; #endif /* GC_DGUX386_THREADS */ /* Undefine macros used to redirect pthread primitives. */ # undef pthread_create # ifndef GC_NO_PTHREAD_SIGMASK # undef pthread_sigmask # endif # ifndef GC_NO_PTHREAD_CANCEL # undef pthread_cancel # endif # ifdef GC_PTHREAD_EXIT_ATTRIBUTE # undef pthread_exit # endif # undef pthread_join # undef pthread_detach # if defined(GC_OSF1_THREADS) && defined(_PTHREAD_USE_MANGLED_NAMES_) \ && !defined(_PTHREAD_USE_PTDNAM_) /* Restore the original mangled names on Tru64 UNIX. */ # define pthread_create __pthread_create # define pthread_join __pthread_join # define pthread_detach __pthread_detach # ifndef GC_NO_PTHREAD_CANCEL # define pthread_cancel __pthread_cancel # endif # ifdef GC_PTHREAD_EXIT_ATTRIBUTE # define pthread_exit __pthread_exit # endif # endif #ifdef GC_USE_LD_WRAP # define WRAP_FUNC(f) __wrap_##f # define REAL_FUNC(f) __real_##f int REAL_FUNC(pthread_create)(pthread_t *, GC_PTHREAD_CREATE_CONST pthread_attr_t *, void *(*start_routine)(void *), void *); int REAL_FUNC(pthread_join)(pthread_t, void **); int REAL_FUNC(pthread_detach)(pthread_t); # ifndef GC_NO_PTHREAD_SIGMASK int REAL_FUNC(pthread_sigmask)(int, const sigset_t *, sigset_t *); # endif # ifndef GC_NO_PTHREAD_CANCEL int REAL_FUNC(pthread_cancel)(pthread_t); # endif # ifdef GC_PTHREAD_EXIT_ATTRIBUTE void REAL_FUNC(pthread_exit)(void *) GC_PTHREAD_EXIT_ATTRIBUTE; # endif #else # ifdef GC_USE_DLOPEN_WRAP # include # define WRAP_FUNC(f) f # define REAL_FUNC(f) GC_real_##f /* We define both GC_f and plain f to be the wrapped function. */ /* In that way plain calls work, as do calls from files that */ /* included gc.h, which redefined f to GC_f. */ /* FIXME: Needs work for DARWIN and True64 (OSF1) */ typedef int (* GC_pthread_create_t)(pthread_t *, GC_PTHREAD_CREATE_CONST pthread_attr_t *, void * (*)(void *), void *); static GC_pthread_create_t REAL_FUNC(pthread_create); # ifndef GC_NO_PTHREAD_SIGMASK typedef int (* GC_pthread_sigmask_t)(int, const sigset_t *, sigset_t *); static GC_pthread_sigmask_t REAL_FUNC(pthread_sigmask); # endif typedef int (* GC_pthread_join_t)(pthread_t, void **); static GC_pthread_join_t REAL_FUNC(pthread_join); typedef int (* GC_pthread_detach_t)(pthread_t); static GC_pthread_detach_t REAL_FUNC(pthread_detach); # ifndef GC_NO_PTHREAD_CANCEL typedef int (* GC_pthread_cancel_t)(pthread_t); static GC_pthread_cancel_t REAL_FUNC(pthread_cancel); # endif # ifdef GC_PTHREAD_EXIT_ATTRIBUTE typedef void (* GC_pthread_exit_t)(void *) GC_PTHREAD_EXIT_ATTRIBUTE; static GC_pthread_exit_t REAL_FUNC(pthread_exit); # endif # else # define WRAP_FUNC(f) GC_##f # if !defined(GC_DGUX386_THREADS) # define REAL_FUNC(f) f # else /* GC_DGUX386_THREADS */ # define REAL_FUNC(f) __d10_##f # endif /* GC_DGUX386_THREADS */ # endif #endif #if defined(GC_USE_LD_WRAP) || defined(GC_USE_DLOPEN_WRAP) /* Define GC_ functions as aliases for the plain ones, which will */ /* be intercepted. This allows files which include gc.h, and hence */ /* generate references to the GC_ symbols, to see the right symbols. */ GC_API int GC_pthread_create(pthread_t * t, GC_PTHREAD_CREATE_CONST pthread_attr_t *a, void * (* fn)(void *), void * arg) { return pthread_create(t, a, fn, arg); } # ifndef GC_NO_PTHREAD_SIGMASK GC_API int GC_pthread_sigmask(int how, const sigset_t *mask, sigset_t *old) { return pthread_sigmask(how, mask, old); } # endif /* !GC_NO_PTHREAD_SIGMASK */ GC_API int GC_pthread_join(pthread_t t, void **res) { return pthread_join(t, res); } GC_API int GC_pthread_detach(pthread_t t) { return pthread_detach(t); } # ifndef GC_NO_PTHREAD_CANCEL GC_API int GC_pthread_cancel(pthread_t t) { return pthread_cancel(t); } # endif /* !GC_NO_PTHREAD_CANCEL */ # ifdef GC_PTHREAD_EXIT_ATTRIBUTE GC_API GC_PTHREAD_EXIT_ATTRIBUTE void GC_pthread_exit(void *retval) { pthread_exit(retval); } # endif /* GC_PTHREAD_EXIT_ATTRIBUTE */ #endif /* Linker-based interception. */ #ifdef GC_USE_DLOPEN_WRAP STATIC GC_bool GC_syms_initialized = FALSE; STATIC void GC_init_real_syms(void) { void *dl_handle; if (GC_syms_initialized) return; # ifdef RTLD_NEXT dl_handle = RTLD_NEXT; # else dl_handle = dlopen("libpthread.so.0", RTLD_LAZY); if (NULL == dl_handle) { dl_handle = dlopen("libpthread.so", RTLD_LAZY); /* without ".0" */ } if (NULL == dl_handle) ABORT("Couldn't open libpthread"); # endif REAL_FUNC(pthread_create) = (GC_pthread_create_t) dlsym(dl_handle, "pthread_create"); # ifdef RTLD_NEXT if (REAL_FUNC(pthread_create) == 0) ABORT("pthread_create not found" " (probably -lgc is specified after -lpthread)"); # endif # ifndef GC_NO_PTHREAD_SIGMASK REAL_FUNC(pthread_sigmask) = (GC_pthread_sigmask_t) dlsym(dl_handle, "pthread_sigmask"); # endif REAL_FUNC(pthread_join) = (GC_pthread_join_t) dlsym(dl_handle, "pthread_join"); REAL_FUNC(pthread_detach) = (GC_pthread_detach_t) dlsym(dl_handle, "pthread_detach"); # ifndef GC_NO_PTHREAD_CANCEL REAL_FUNC(pthread_cancel) = (GC_pthread_cancel_t) dlsym(dl_handle, "pthread_cancel"); # endif # ifdef GC_PTHREAD_EXIT_ATTRIBUTE REAL_FUNC(pthread_exit) = (GC_pthread_exit_t) dlsym(dl_handle, "pthread_exit"); # endif GC_syms_initialized = TRUE; } # define INIT_REAL_SYMS() if (EXPECT(GC_syms_initialized, TRUE)) {} \ else GC_init_real_syms() #else # define INIT_REAL_SYMS() (void)0 #endif static GC_bool parallel_initialized = FALSE; #ifndef GC_ALWAYS_MULTITHREADED GC_INNER GC_bool GC_need_to_lock = FALSE; #endif STATIC int GC_nprocs = 1; /* Number of processors. We may not have */ /* access to all of them, but this is as good */ /* a guess as any ... */ #ifdef THREAD_LOCAL_ALLOC /* We must explicitly mark ptrfree and gcj free lists, since the free */ /* list links wouldn't otherwise be found. We also set them in the */ /* normal free lists, since that involves touching less memory than */ /* if we scanned them normally. */ GC_INNER void GC_mark_thread_local_free_lists(void) { int i; GC_thread p; for (i = 0; i < THREAD_TABLE_SZ; ++i) { for (p = GC_threads[i]; 0 != p; p = p -> next) { if (!(p -> flags & FINISHED)) GC_mark_thread_local_fls_for(&(p->tlfs)); } } } # if defined(GC_ASSERTIONS) void GC_check_tls_for(GC_tlfs p); # if defined(USE_CUSTOM_SPECIFIC) void GC_check_tsd_marks(tsd *key); # endif /* Check that all thread-local free-lists are completely marked. */ /* Also check that thread-specific-data structures are marked. */ void GC_check_tls(void) { int i; GC_thread p; for (i = 0; i < THREAD_TABLE_SZ; ++i) { for (p = GC_threads[i]; 0 != p; p = p -> next) { if (!(p -> flags & FINISHED)) GC_check_tls_for(&(p->tlfs)); } } # if defined(USE_CUSTOM_SPECIFIC) if (GC_thread_key != 0) GC_check_tsd_marks(GC_thread_key); # endif } # endif /* GC_ASSERTIONS */ #endif /* THREAD_LOCAL_ALLOC */ #ifdef PARALLEL_MARK # ifndef MAX_MARKERS # define MAX_MARKERS 16 # endif static ptr_t marker_sp[MAX_MARKERS - 1] = {0}; #ifdef IA64 static ptr_t marker_bsp[MAX_MARKERS - 1] = {0}; #endif #if defined(GC_DARWIN_THREADS) && !defined(GC_NO_THREADS_DISCOVERY) static mach_port_t marker_mach_threads[MAX_MARKERS - 1] = {0}; /* Used only by GC_suspend_thread_list(). */ GC_INNER GC_bool GC_is_mach_marker(thread_act_t thread) { int i; for (i = 0; i < GC_markers_m1; i++) { if (marker_mach_threads[i] == thread) return TRUE; } return FALSE; } #endif /* GC_DARWIN_THREADS */ STATIC void * GC_mark_thread(void * id) { word my_mark_no = 0; IF_CANCEL(int cancel_state;) if ((word)id == (word)-1) return 0; /* to make compiler happy */ DISABLE_CANCEL(cancel_state); /* Mark threads are not cancellable; they */ /* should be invisible to client. */ marker_sp[(word)id] = GC_approx_sp(); # ifdef IA64 marker_bsp[(word)id] = GC_save_regs_in_stack(); # endif # if defined(GC_DARWIN_THREADS) && !defined(GC_NO_THREADS_DISCOVERY) marker_mach_threads[(word)id] = mach_thread_self(); # endif for (;; ++my_mark_no) { /* GC_mark_no is passed only to allow GC_help_marker to terminate */ /* promptly. This is important if it were called from the signal */ /* handler or from the GC lock acquisition code. Under Linux, it's */ /* not safe to call it from a signal handler, since it uses mutexes */ /* and condition variables. Since it is called only here, the */ /* argument is unnecessary. */ if (my_mark_no < GC_mark_no || my_mark_no > GC_mark_no + 2) { /* resynchronize if we get far off, e.g. because GC_mark_no */ /* wrapped. */ my_mark_no = GC_mark_no; } # ifdef DEBUG_THREADS GC_log_printf("Starting mark helper for mark number %lu\n", (unsigned long)my_mark_no); # endif GC_help_marker(my_mark_no); } } STATIC pthread_t GC_mark_threads[MAX_MARKERS]; #ifdef CAN_HANDLE_FORK static int available_markers_m1 = 0; # define start_mark_threads GC_start_mark_threads GC_API void GC_CALL #else # define available_markers_m1 GC_markers_m1 static void #endif start_mark_threads(void) { int i; pthread_attr_t attr; GC_ASSERT(I_DONT_HOLD_LOCK()); # ifdef CAN_HANDLE_FORK if (available_markers_m1 <= 0 || GC_parallel) return; /* Skip if parallel markers disabled or already started. */ # endif INIT_REAL_SYMS(); /* for pthread_create */ if (0 != pthread_attr_init(&attr)) ABORT("pthread_attr_init failed"); if (0 != pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED)) ABORT("pthread_attr_setdetachstate failed"); # if defined(HPUX) || defined(GC_DGUX386_THREADS) /* Default stack size is usually too small: fix it. */ /* Otherwise marker threads or GC may run out of */ /* space. */ # define MIN_STACK_SIZE (8*HBLKSIZE*sizeof(word)) { size_t old_size; if (pthread_attr_getstacksize(&attr, &old_size) != 0) ABORT("pthread_attr_getstacksize failed"); if (old_size < MIN_STACK_SIZE) { if (pthread_attr_setstacksize(&attr, MIN_STACK_SIZE) != 0) ABORT("pthread_attr_setstacksize failed"); } } # endif /* HPUX || GC_DGUX386_THREADS */ for (i = 0; i < available_markers_m1; ++i) { if (0 != REAL_FUNC(pthread_create)(GC_mark_threads + i, &attr, GC_mark_thread, (void *)(word)i)) { WARN("Marker thread creation failed, errno = %" WARN_PRIdPTR "\n", errno); /* Don't try to create other marker threads. */ break; } } GC_markers_m1 = i; (void)pthread_attr_destroy(&attr); GC_COND_LOG_PRINTF("Started %d mark helper threads\n", GC_markers_m1); } #endif /* PARALLEL_MARK */ GC_INNER GC_bool GC_thr_initialized = FALSE; GC_INNER volatile GC_thread GC_threads[THREAD_TABLE_SZ] = {0}; void GC_push_thread_structures(void) { GC_ASSERT(I_HOLD_LOCK()); GC_push_all((ptr_t)(GC_threads), (ptr_t)(GC_threads)+sizeof(GC_threads)); # if defined(THREAD_LOCAL_ALLOC) GC_push_all((ptr_t)(&GC_thread_key), (ptr_t)(&GC_thread_key) + sizeof(GC_thread_key)); # endif } #ifdef DEBUG_THREADS STATIC int GC_count_threads(void) { int i; int count = 0; GC_ASSERT(I_HOLD_LOCK()); for (i = 0; i < THREAD_TABLE_SZ; ++i) { GC_thread th = GC_threads[i]; while (th) { if (!(th->flags & FINISHED)) ++count; th = th->next; } } return count; } #endif /* DEBUG_THREADS */ /* It may not be safe to allocate when we register the first thread. */ static struct GC_Thread_Rep first_thread; /* Add a thread to GC_threads. We assume it wasn't already there. */ /* Caller holds allocation lock. */ STATIC GC_thread GC_new_thread(pthread_t id) { int hv = NUMERIC_THREAD_ID(id) % THREAD_TABLE_SZ; GC_thread result; static GC_bool first_thread_used = FALSE; # ifdef DEBUG_THREADS GC_log_printf("Creating thread %p\n", (void *)id); # endif GC_ASSERT(I_HOLD_LOCK()); if (!EXPECT(first_thread_used, TRUE)) { result = &first_thread; first_thread_used = TRUE; } else { result = (struct GC_Thread_Rep *) GC_INTERNAL_MALLOC(sizeof(struct GC_Thread_Rep), NORMAL); if (result == 0) return(0); } result -> id = id; # ifdef PLATFORM_ANDROID result -> kernel_id = gettid(); # endif result -> next = GC_threads[hv]; GC_threads[hv] = result; # ifdef NACL GC_nacl_gc_thread_self = result; GC_nacl_initialize_gc_thread(); # endif GC_ASSERT(result -> flags == 0 && result -> thread_blocked == 0); return(result); } /* Delete a thread from GC_threads. We assume it is there. */ /* (The code intentionally traps if it wasn't.) */ /* It is safe to delete the main thread. */ STATIC void GC_delete_thread(pthread_t id) { int hv = NUMERIC_THREAD_ID(id) % THREAD_TABLE_SZ; register GC_thread p = GC_threads[hv]; register GC_thread prev = 0; # ifdef DEBUG_THREADS GC_log_printf("Deleting thread %p, n_threads = %d\n", (void *)id, GC_count_threads()); # endif # ifdef NACL GC_nacl_shutdown_gc_thread(); GC_nacl_gc_thread_self = NULL; # endif GC_ASSERT(I_HOLD_LOCK()); while (!THREAD_EQUAL(p -> id, id)) { prev = p; p = p -> next; } if (prev == 0) { GC_threads[hv] = p -> next; } else { prev -> next = p -> next; } if (p != &first_thread) { # ifdef GC_DARWIN_THREADS mach_port_deallocate(mach_task_self(), p->stop_info.mach_thread); # endif GC_INTERNAL_FREE(p); } } /* If a thread has been joined, but we have not yet */ /* been notified, then there may be more than one thread */ /* in the table with the same pthread id. */ /* This is OK, but we need a way to delete a specific one. */ STATIC void GC_delete_gc_thread(GC_thread t) { pthread_t id = t -> id; int hv = NUMERIC_THREAD_ID(id) % THREAD_TABLE_SZ; register GC_thread p = GC_threads[hv]; register GC_thread prev = 0; GC_ASSERT(I_HOLD_LOCK()); while (p != t) { prev = p; p = p -> next; } if (prev == 0) { GC_threads[hv] = p -> next; } else { prev -> next = p -> next; } # ifdef GC_DARWIN_THREADS mach_port_deallocate(mach_task_self(), p->stop_info.mach_thread); # endif GC_INTERNAL_FREE(p); # ifdef DEBUG_THREADS GC_log_printf("Deleted thread %p, n_threads = %d\n", (void *)id, GC_count_threads()); # endif } /* Return a GC_thread corresponding to a given pthread_t. */ /* Returns 0 if it's not there. */ /* Caller holds allocation lock or otherwise inhibits */ /* updates. */ /* If there is more than one thread with the given id we */ /* return the most recent one. */ GC_INNER GC_thread GC_lookup_thread(pthread_t id) { int hv = NUMERIC_THREAD_ID(id) % THREAD_TABLE_SZ; register GC_thread p = GC_threads[hv]; while (p != 0 && !THREAD_EQUAL(p -> id, id)) p = p -> next; return(p); } /* Called by GC_finalize() (in case of an allocation failure observed). */ GC_INNER void GC_reset_finalizer_nested(void) { GC_thread me = GC_lookup_thread(pthread_self()); me->finalizer_nested = 0; } /* Checks and updates the thread-local level of finalizers recursion. */ /* Returns NULL if GC_invoke_finalizers() should not be called by the */ /* collector (to minimize the risk of a deep finalizers recursion), */ /* otherwise returns a pointer to the thread-local finalizer_nested. */ /* Called by GC_notify_or_invoke_finalizers() only (the lock is held). */ GC_INNER unsigned char *GC_check_finalizer_nested(void) { GC_thread me = GC_lookup_thread(pthread_self()); unsigned nesting_level = me->finalizer_nested; if (nesting_level) { /* We are inside another GC_invoke_finalizers(). */ /* Skip some implicitly-called GC_invoke_finalizers() */ /* depending on the nesting (recursion) level. */ if (++me->finalizer_skipped < (1U << nesting_level)) return NULL; me->finalizer_skipped = 0; } me->finalizer_nested = (unsigned char)(nesting_level + 1); return &me->finalizer_nested; } #if defined(GC_ASSERTIONS) && defined(THREAD_LOCAL_ALLOC) /* This is called from thread-local GC_malloc(). */ GC_bool GC_is_thread_tsd_valid(void *tsd) { GC_thread me; DCL_LOCK_STATE; LOCK(); me = GC_lookup_thread(pthread_self()); UNLOCK(); return (word)tsd >= (word)(&me->tlfs) && (word)tsd < (word)(&me->tlfs) + sizeof(me->tlfs); } #endif /* GC_ASSERTIONS && THREAD_LOCAL_ALLOC */ GC_API int GC_CALL GC_thread_is_registered(void) { pthread_t self = pthread_self(); GC_thread me; DCL_LOCK_STATE; LOCK(); me = GC_lookup_thread(self); UNLOCK(); return me != NULL; } #ifdef CAN_HANDLE_FORK /* Remove all entries from the GC_threads table, except the */ /* one for the current thread. We need to do this in the child */ /* process after a fork(), since only the current thread */ /* survives in the child. */ STATIC void GC_remove_all_threads_but_me(void) { pthread_t self = pthread_self(); int hv; GC_thread p, next, me; for (hv = 0; hv < THREAD_TABLE_SZ; ++hv) { me = 0; for (p = GC_threads[hv]; 0 != p; p = next) { next = p -> next; if (THREAD_EQUAL(p -> id, self)) { me = p; p -> next = 0; # ifdef GC_DARWIN_THREADS /* Update thread Id after fork (it is OK to call */ /* GC_destroy_thread_local and GC_free_internal */ /* before update). */ me -> stop_info.mach_thread = mach_thread_self(); # elif defined(PLATFORM_ANDROID) me -> kernel_id = gettid(); # endif # if defined(THREAD_LOCAL_ALLOC) && !defined(USE_CUSTOM_SPECIFIC) /* Some TLS implementations might be not fork-friendly, so */ /* we re-assign thread-local pointer to 'tlfs' for safety */ /* instead of the assertion check (again, it is OK to call */ /* GC_destroy_thread_local and GC_free_internal before). */ if (GC_setspecific(GC_thread_key, &me->tlfs) != 0) ABORT("GC_setspecific failed (in child)"); # endif } else { # ifdef THREAD_LOCAL_ALLOC if (!(p -> flags & FINISHED)) { GC_destroy_thread_local(&(p->tlfs)); GC_remove_specific(GC_thread_key); } # endif if (p != &first_thread) GC_INTERNAL_FREE(p); } } GC_threads[hv] = me; } } #endif /* CAN_HANDLE_FORK */ #ifdef USE_PROC_FOR_LIBRARIES GC_INNER GC_bool GC_segment_is_thread_stack(ptr_t lo, ptr_t hi) { int i; GC_thread p; GC_ASSERT(I_HOLD_LOCK()); # ifdef PARALLEL_MARK for (i = 0; i < GC_markers_m1; ++i) { if ((word)marker_sp[i] > (word)lo && (word)marker_sp[i] < (word)hi) return TRUE; # ifdef IA64 if ((word)marker_bsp[i] > (word)lo && (word)marker_bsp[i] < (word)hi) return TRUE; # endif } # endif for (i = 0; i < THREAD_TABLE_SZ; i++) { for (p = GC_threads[i]; p != 0; p = p -> next) { if (0 != p -> stack_end) { # ifdef STACK_GROWS_UP if ((word)p->stack_end >= (word)lo && (word)p->stack_end < (word)hi) return TRUE; # else /* STACK_GROWS_DOWN */ if ((word)p->stack_end > (word)lo && (word)p->stack_end <= (word)hi) return TRUE; # endif } } } return FALSE; } #endif /* USE_PROC_FOR_LIBRARIES */ #ifdef IA64 /* Find the largest stack_base smaller than bound. May be used */ /* to find the boundary between a register stack and adjacent */ /* immediately preceding memory stack. */ GC_INNER ptr_t GC_greatest_stack_base_below(ptr_t bound) { int i; GC_thread p; ptr_t result = 0; GC_ASSERT(I_HOLD_LOCK()); # ifdef PARALLEL_MARK for (i = 0; i < GC_markers_m1; ++i) { if ((word)marker_sp[i] > (word)result && (word)marker_sp[i] < (word)bound) result = marker_sp[i]; } # endif for (i = 0; i < THREAD_TABLE_SZ; i++) { for (p = GC_threads[i]; p != 0; p = p -> next) { if ((word)p->stack_end > (word)result && (word)p->stack_end < (word)bound) { result = p -> stack_end; } } } return result; } #endif /* IA64 */ #ifndef STAT_READ /* Also defined in os_dep.c. */ # define STAT_BUF_SIZE 4096 # define STAT_READ read /* If read is wrapped, this may need to be redefined to call */ /* the real one. */ #endif #ifdef GC_HPUX_THREADS # define GC_get_nprocs() pthread_num_processors_np() #elif defined(GC_OSF1_THREADS) || defined(GC_AIX_THREADS) \ || defined(GC_SOLARIS_THREADS) || defined(GC_GNU_THREADS) \ || defined(PLATFORM_ANDROID) || defined(NACL) GC_INLINE int GC_get_nprocs(void) { int nprocs = (int)sysconf(_SC_NPROCESSORS_ONLN); return nprocs > 0 ? nprocs : 1; /* ignore error silently */ } #elif defined(GC_IRIX_THREADS) GC_INLINE int GC_get_nprocs(void) { int nprocs = (int)sysconf(_SC_NPROC_ONLN); return nprocs > 0 ? nprocs : 1; /* ignore error silently */ } #elif defined(GC_LINUX_THREADS) /* && !PLATFORM_ANDROID && !NACL */ /* Return the number of processors. */ STATIC int GC_get_nprocs(void) { /* Should be "return sysconf(_SC_NPROCESSORS_ONLN);" but that */ /* appears to be buggy in many cases. */ /* We look for lines "cpu" in /proc/stat. */ char stat_buf[STAT_BUF_SIZE]; int f; int result, i, len; f = open("/proc/stat", O_RDONLY); if (f < 0) { WARN("Couldn't read /proc/stat\n", 0); return 1; /* assume an uniprocessor */ } len = STAT_READ(f, stat_buf, STAT_BUF_SIZE); close(f); result = 1; /* Some old kernels only have a single "cpu nnnn ..." */ /* entry in /proc/stat. We identify those as */ /* uniprocessors. */ for (i = 0; i < len - 100; ++i) { if (stat_buf[i] == '\n' && stat_buf[i+1] == 'c' && stat_buf[i+2] == 'p' && stat_buf[i+3] == 'u') { int cpu_no = atoi(&stat_buf[i + 4]); if (cpu_no >= result) result = cpu_no + 1; } } return result; } #elif defined(GC_DGUX386_THREADS) /* Return the number of processors, or i <= 0 if it can't be determined. */ STATIC int GC_get_nprocs(void) { int numCpus; struct dg_sys_info_pm_info pm_sysinfo; int status = 0; status = dg_sys_info((long int *) &pm_sysinfo, DG_SYS_INFO_PM_INFO_TYPE, DG_SYS_INFO_PM_CURRENT_VERSION); if (status < 0) /* set -1 for error */ numCpus = -1; else /* Active CPUs */ numCpus = pm_sysinfo.idle_vp_count; return(numCpus); } #elif defined(GC_DARWIN_THREADS) || defined(GC_FREEBSD_THREADS) \ || defined(GC_NETBSD_THREADS) || defined(GC_OPENBSD_THREADS) STATIC int GC_get_nprocs(void) { int mib[] = {CTL_HW,HW_NCPU}; int res; size_t len = sizeof(res); sysctl(mib, sizeof(mib)/sizeof(int), &res, &len, NULL, 0); return res; } #else /* E.g., GC_RTEMS_PTHREADS */ # define GC_get_nprocs() 1 /* not implemented */ #endif /* !GC_LINUX_THREADS && !GC_DARWIN_THREADS && ... */ #if defined(ARM32) && defined(GC_LINUX_THREADS) && !defined(NACL) /* Some buggy Linux/arm kernels show only non-sleeping CPUs in */ /* /proc/stat (and /proc/cpuinfo), so another data system source is */ /* tried first. Result <= 0 on error. */ STATIC int GC_get_nprocs_present(void) { char stat_buf[16]; int f; int len; f = open("/sys/devices/system/cpu/present", O_RDONLY); if (f < 0) return -1; /* cannot open the file */ len = STAT_READ(f, stat_buf, sizeof(stat_buf)); close(f); /* Recognized file format: "0\n" or "0-\n" */ /* The file might probably contain a comma-separated list */ /* but we do not need to handle it (just silently ignore). */ if (len < 2 || stat_buf[0] != '0' || stat_buf[len - 1] != '\n') { return 0; /* read error or unrecognized content */ } else if (len == 2) { return 1; /* an uniprocessor */ } else if (stat_buf[1] != '-') { return 0; /* unrecognized content */ } stat_buf[len - 1] = '\0'; /* terminate the string */ return atoi(&stat_buf[2]) + 1; /* skip "0-" and parse max_cpu_num */ } #endif /* ARM32 && GC_LINUX_THREADS && !NACL */ /* We hold the GC lock. Wait until an in-progress GC has finished. */ /* Repeatedly RELEASES GC LOCK in order to wait. */ /* If wait_for_all is true, then we exit with the GC lock held and no */ /* collection in progress; otherwise we just wait for the current GC */ /* to finish. */ STATIC void GC_wait_for_gc_completion(GC_bool wait_for_all) { DCL_LOCK_STATE; GC_ASSERT(I_HOLD_LOCK()); ASSERT_CANCEL_DISABLED(); if (GC_incremental && GC_collection_in_progress()) { word old_gc_no = GC_gc_no; /* Make sure that no part of our stack is still on the mark stack, */ /* since it's about to be unmapped. */ while (GC_incremental && GC_collection_in_progress() && (wait_for_all || old_gc_no == GC_gc_no)) { ENTER_GC(); GC_in_thread_creation = TRUE; GC_collect_a_little_inner(1); GC_in_thread_creation = FALSE; EXIT_GC(); UNLOCK(); sched_yield(); LOCK(); } } } #ifdef CAN_HANDLE_FORK /* Procedures called before and after a fork. The goal here is to make */ /* it safe to call GC_malloc() in a forked child. It's unclear that is */ /* attainable, since the single UNIX spec seems to imply that one */ /* should only call async-signal-safe functions, and we probably can't */ /* quite guarantee that. But we give it our best shot. (That same */ /* spec also implies that it's not safe to call the system malloc */ /* between fork() and exec(). Thus we're doing no worse than it.) */ IF_CANCEL(static int fork_cancel_state;) /* protected by allocation lock. */ /* Called before a fork() */ static void fork_prepare_proc(void) { /* Acquire all relevant locks, so that after releasing the locks */ /* the child will see a consistent state in which monitor */ /* invariants hold. Unfortunately, we can't acquire libc locks */ /* we might need, and there seems to be no guarantee that libc */ /* must install a suitable fork handler. */ /* Wait for an ongoing GC to finish, since we can't finish it in */ /* the (one remaining thread in) the child. */ LOCK(); DISABLE_CANCEL(fork_cancel_state); /* Following waits may include cancellation points. */ # if defined(PARALLEL_MARK) if (GC_parallel) GC_wait_for_reclaim(); # endif GC_wait_for_gc_completion(TRUE); # if defined(PARALLEL_MARK) if (GC_parallel) GC_acquire_mark_lock(); # endif } /* Called in parent after a fork() (even if the latter failed). */ static void fork_parent_proc(void) { # if defined(PARALLEL_MARK) if (GC_parallel) GC_release_mark_lock(); # endif RESTORE_CANCEL(fork_cancel_state); UNLOCK(); } /* Called in child after a fork() */ static void fork_child_proc(void) { /* Clean up the thread table, so that just our thread is left. */ # if defined(PARALLEL_MARK) if (GC_parallel) GC_release_mark_lock(); # endif GC_remove_all_threads_but_me(); # ifdef PARALLEL_MARK /* Turn off parallel marking in the child, since we are probably */ /* just going to exec, and we would have to restart mark threads. */ GC_parallel = FALSE; # endif /* PARALLEL_MARK */ RESTORE_CANCEL(fork_cancel_state); UNLOCK(); } /* Routines for fork handling by client (no-op if pthread_atfork works). */ GC_API void GC_CALL GC_atfork_prepare(void) { # if defined(GC_DARWIN_THREADS) && defined(MPROTECT_VDB) if (GC_dirty_maintained) { GC_ASSERT(0 == GC_handle_fork); ABORT("Unable to fork while mprotect_thread is running"); } # endif if (GC_handle_fork <= 0) fork_prepare_proc(); } GC_API void GC_CALL GC_atfork_parent(void) { if (GC_handle_fork <= 0) fork_parent_proc(); } GC_API void GC_CALL GC_atfork_child(void) { if (GC_handle_fork <= 0) fork_child_proc(); } #endif /* CAN_HANDLE_FORK */ #ifdef INCLUDE_LINUX_THREAD_DESCR __thread int GC_dummy_thread_local; GC_INNER GC_bool GC_enclosing_mapping(ptr_t addr, ptr_t *startp, ptr_t *endp); #endif #ifdef PARALLEL_MARK static void setup_mark_lock(void); #endif /* We hold the allocation lock. */ GC_INNER void GC_thr_init(void) { if (GC_thr_initialized) return; GC_thr_initialized = TRUE; GC_ASSERT((word)&GC_threads % sizeof(word) == 0); # ifdef CAN_HANDLE_FORK /* Prepare for forks if requested. */ if (GC_handle_fork) { # ifdef CAN_CALL_ATFORK if (pthread_atfork(fork_prepare_proc, fork_parent_proc, fork_child_proc) == 0) { /* Handlers successfully registered. */ GC_handle_fork = 1; } else # endif /* else */ if (GC_handle_fork != -1) ABORT("pthread_atfork failed"); } # endif # ifdef INCLUDE_LINUX_THREAD_DESCR /* Explicitly register the region including the address */ /* of a thread local variable. This should include thread */ /* locals for the main thread, except for those allocated */ /* in response to dlopen calls. */ { ptr_t thread_local_addr = (ptr_t)(&GC_dummy_thread_local); ptr_t main_thread_start, main_thread_end; if (!GC_enclosing_mapping(thread_local_addr, &main_thread_start, &main_thread_end)) { ABORT("Failed to find mapping for main thread thread locals"); } else { /* main_thread_start and main_thread_end are initialized. */ GC_add_roots_inner(main_thread_start, main_thread_end, FALSE); } } # endif /* Add the initial thread, so we can stop it. */ { GC_thread t = GC_new_thread(pthread_self()); if (t == NULL) ABORT("Failed to allocate memory for the initial thread"); # ifdef GC_DARWIN_THREADS t -> stop_info.mach_thread = mach_thread_self(); # else t -> stop_info.stack_ptr = GC_approx_sp(); # endif t -> flags = DETACHED | MAIN_THREAD; } # ifndef GC_DARWIN_THREADS GC_stop_init(); # endif /* Set GC_nprocs. */ { char * nprocs_string = GETENV("GC_NPROCS"); GC_nprocs = -1; if (nprocs_string != NULL) GC_nprocs = atoi(nprocs_string); } if (GC_nprocs <= 0 # if defined(ARM32) && defined(GC_LINUX_THREADS) && !defined(NACL) && (GC_nprocs = GC_get_nprocs_present()) <= 1 /* Workaround for some Linux/arm kernels */ # endif ) { GC_nprocs = GC_get_nprocs(); } if (GC_nprocs <= 0) { WARN("GC_get_nprocs() returned %" WARN_PRIdPTR "\n", GC_nprocs); GC_nprocs = 2; /* assume dual-core */ # ifdef PARALLEL_MARK available_markers_m1 = 0; /* but use only one marker */ # endif } else { # ifdef PARALLEL_MARK { char * markers_string = GETENV("GC_MARKERS"); int markers_m1; if (markers_string != NULL) { markers_m1 = atoi(markers_string) - 1; if (markers_m1 >= MAX_MARKERS) { WARN("Limiting number of mark threads\n", 0); markers_m1 = MAX_MARKERS - 1; } } else { markers_m1 = GC_nprocs - 1; # ifdef GC_MIN_MARKERS /* This is primarily for targets without getenv(). */ if (markers_m1 < GC_MIN_MARKERS - 1) markers_m1 = GC_MIN_MARKERS - 1; # endif if (markers_m1 >= MAX_MARKERS) markers_m1 = MAX_MARKERS - 1; /* silently limit the value */ } available_markers_m1 = markers_m1; } # endif } GC_COND_LOG_PRINTF("Number of processors = %d\n", GC_nprocs); # ifdef PARALLEL_MARK if (available_markers_m1 <= 0) { /* Disable parallel marking. */ GC_parallel = FALSE; GC_COND_LOG_PRINTF( "Single marker thread, turning off parallel marking\n"); } else { /* Disable true incremental collection, but generational is OK. */ GC_time_limit = GC_TIME_UNLIMITED; setup_mark_lock(); /* If we are using a parallel marker, actually start helper threads. */ start_mark_threads(); } # endif } /* Perform all initializations, including those that */ /* may require allocation. */ /* Called without allocation lock. */ /* Must be called before a second thread is created. */ /* Did we say it's called without the allocation lock? */ GC_INNER void GC_init_parallel(void) { # if defined(THREAD_LOCAL_ALLOC) DCL_LOCK_STATE; # endif if (parallel_initialized) return; parallel_initialized = TRUE; /* GC_init() calls us back, so set flag first. */ if (!GC_is_initialized) GC_init(); /* Initialize thread local free lists if used. */ # if defined(THREAD_LOCAL_ALLOC) LOCK(); GC_init_thread_local(&(GC_lookup_thread(pthread_self())->tlfs)); UNLOCK(); # endif } #ifndef GC_NO_PTHREAD_SIGMASK GC_API int WRAP_FUNC(pthread_sigmask)(int how, const sigset_t *set, sigset_t *oset) { sigset_t fudged_set; int sig_suspend; INIT_REAL_SYMS(); if (set != NULL && (how == SIG_BLOCK || how == SIG_SETMASK)) { fudged_set = *set; sig_suspend = GC_get_suspend_signal(); GC_ASSERT(sig_suspend >= 0); sigdelset(&fudged_set, sig_suspend); set = &fudged_set; } return(REAL_FUNC(pthread_sigmask)(how, set, oset)); } #endif /* !GC_NO_PTHREAD_SIGMASK */ /* Wrapper for functions that are likely to block for an appreciable */ /* length of time. */ GC_INNER void GC_do_blocking_inner(ptr_t data, void * context GC_ATTR_UNUSED) { struct blocking_data * d = (struct blocking_data *) data; pthread_t self = pthread_self(); GC_thread me; # if defined(SPARC) || defined(IA64) ptr_t stack_ptr = GC_save_regs_in_stack(); # endif # if defined(GC_DARWIN_THREADS) && !defined(DARWIN_DONT_PARSE_STACK) GC_bool topOfStackUnset = FALSE; # endif DCL_LOCK_STATE; LOCK(); me = GC_lookup_thread(self); GC_ASSERT(!(me -> thread_blocked)); # ifdef SPARC me -> stop_info.stack_ptr = stack_ptr; # else me -> stop_info.stack_ptr = GC_approx_sp(); # endif # if defined(GC_DARWIN_THREADS) && !defined(DARWIN_DONT_PARSE_STACK) if (me -> topOfStack == NULL) { /* GC_do_blocking_inner is not called recursively, */ /* so topOfStack should be computed now. */ topOfStackUnset = TRUE; me -> topOfStack = GC_FindTopOfStack(0); } # endif # ifdef IA64 me -> backing_store_ptr = stack_ptr; # endif me -> thread_blocked = (unsigned char)TRUE; /* Save context here if we want to support precise stack marking */ UNLOCK(); d -> client_data = (d -> fn)(d -> client_data); LOCK(); /* This will block if the world is stopped. */ me -> thread_blocked = FALSE; # if defined(GC_DARWIN_THREADS) && !defined(DARWIN_DONT_PARSE_STACK) if (topOfStackUnset) me -> topOfStack = NULL; /* make topOfStack unset again */ # endif UNLOCK(); } /* GC_call_with_gc_active() has the opposite to GC_do_blocking() */ /* functionality. It might be called from a user function invoked by */ /* GC_do_blocking() to temporarily back allow calling any GC function */ /* and/or manipulating pointers to the garbage collected heap. */ GC_API void * GC_CALL GC_call_with_gc_active(GC_fn_type fn, void * client_data) { struct GC_traced_stack_sect_s stacksect; pthread_t self = pthread_self(); GC_thread me; DCL_LOCK_STATE; LOCK(); /* This will block if the world is stopped. */ me = GC_lookup_thread(self); /* Adjust our stack base value (this could happen unless */ /* GC_get_stack_base() was used which returned GC_SUCCESS). */ if ((me -> flags & MAIN_THREAD) == 0) { GC_ASSERT(me -> stack_end != NULL); if ((word)me->stack_end HOTTER_THAN (word)(&stacksect)) me -> stack_end = (ptr_t)(&stacksect); } else { /* The original stack. */ if ((word)GC_stackbottom HOTTER_THAN (word)(&stacksect)) GC_stackbottom = (ptr_t)(&stacksect); } if (!me->thread_blocked) { /* We are not inside GC_do_blocking() - do nothing more. */ UNLOCK(); client_data = fn(client_data); /* Prevent treating the above as a tail call. */ GC_noop1((word)(&stacksect)); return client_data; /* result */ } /* Setup new "stack section". */ stacksect.saved_stack_ptr = me -> stop_info.stack_ptr; # ifdef IA64 /* This is the same as in GC_call_with_stack_base(). */ stacksect.backing_store_end = GC_save_regs_in_stack(); /* Unnecessarily flushes register stack, */ /* but that probably doesn't hurt. */ stacksect.saved_backing_store_ptr = me -> backing_store_ptr; # endif stacksect.prev = me -> traced_stack_sect; me -> thread_blocked = FALSE; me -> traced_stack_sect = &stacksect; UNLOCK(); client_data = fn(client_data); GC_ASSERT(me -> thread_blocked == FALSE); GC_ASSERT(me -> traced_stack_sect == &stacksect); /* Restore original "stack section". */ LOCK(); me -> traced_stack_sect = stacksect.prev; # ifdef IA64 me -> backing_store_ptr = stacksect.saved_backing_store_ptr; # endif me -> thread_blocked = (unsigned char)TRUE; me -> stop_info.stack_ptr = stacksect.saved_stack_ptr; UNLOCK(); return client_data; /* result */ } STATIC void GC_unregister_my_thread_inner(GC_thread me) { # ifdef DEBUG_THREADS GC_log_printf( "Unregistering thread %p, gc_thread = %p, n_threads = %d\n", (void *)me->id, me, GC_count_threads()); # endif GC_ASSERT(!(me -> flags & FINISHED)); # if defined(THREAD_LOCAL_ALLOC) GC_ASSERT(GC_getspecific(GC_thread_key) == &me->tlfs); GC_destroy_thread_local(&(me->tlfs)); # endif # if defined(GC_PTHREAD_EXIT_ATTRIBUTE) || !defined(GC_NO_PTHREAD_CANCEL) /* Handle DISABLED_GC flag which is set by the */ /* intercepted pthread_cancel or pthread_exit. */ if ((me -> flags & DISABLED_GC) != 0) { GC_dont_gc--; } # endif if (me -> flags & DETACHED) { GC_delete_thread(pthread_self()); } else { me -> flags |= FINISHED; } # if defined(THREAD_LOCAL_ALLOC) /* It is required to call remove_specific defined in specific.c. */ GC_remove_specific(GC_thread_key); # endif } GC_API int GC_CALL GC_unregister_my_thread(void) { pthread_t self = pthread_self(); GC_thread me; IF_CANCEL(int cancel_state;) DCL_LOCK_STATE; LOCK(); DISABLE_CANCEL(cancel_state); /* Wait for any GC that may be marking from our stack to */ /* complete before we remove this thread. */ GC_wait_for_gc_completion(FALSE); me = GC_lookup_thread(self); # ifdef DEBUG_THREADS GC_log_printf( "Called GC_unregister_my_thread on %p, gc_thread = %p\n", (void *)self, me); # endif GC_ASSERT(me->id == self); GC_unregister_my_thread_inner(me); RESTORE_CANCEL(cancel_state); UNLOCK(); return GC_SUCCESS; } /* Called at thread exit. */ /* Never called for main thread. That's OK, since it */ /* results in at most a tiny one-time leak. And */ /* linuxthreads doesn't reclaim the main threads */ /* resources or id anyway. */ GC_INNER_PTHRSTART void GC_thread_exit_proc(void *arg) { # ifdef DEBUG_THREADS GC_log_printf("Called GC_thread_exit_proc on %p, gc_thread = %p\n", (void *)((GC_thread)arg)->id, arg); # endif IF_CANCEL(int cancel_state;) DCL_LOCK_STATE; LOCK(); DISABLE_CANCEL(cancel_state); GC_wait_for_gc_completion(FALSE); GC_unregister_my_thread_inner((GC_thread)arg); RESTORE_CANCEL(cancel_state); UNLOCK(); } GC_API int WRAP_FUNC(pthread_join)(pthread_t thread, void **retval) { int result; GC_thread t; DCL_LOCK_STATE; INIT_REAL_SYMS(); LOCK(); t = GC_lookup_thread(thread); /* This is guaranteed to be the intended one, since the thread id */ /* can't have been recycled by pthreads. */ UNLOCK(); result = REAL_FUNC(pthread_join)(thread, retval); # if defined(GC_FREEBSD_THREADS) /* On FreeBSD, the wrapped pthread_join() sometimes returns (what appears to be) a spurious EINTR which caused the test and real code to gratuitously fail. Having looked at system pthread library source code, I see how this return code may be generated. In one path of code, pthread_join() just returns the errno setting of the thread being joined. This does not match the POSIX specification or the local man pages thus I have taken the liberty to catch this one spurious return value properly conditionalized on GC_FREEBSD_THREADS. */ if (result == EINTR) result = 0; # endif if (result == 0) { LOCK(); /* Here the pthread thread id may have been recycled. */ GC_ASSERT((t -> flags & FINISHED) != 0); GC_delete_gc_thread(t); UNLOCK(); } return result; } GC_API int WRAP_FUNC(pthread_detach)(pthread_t thread) { int result; GC_thread t; DCL_LOCK_STATE; INIT_REAL_SYMS(); LOCK(); t = GC_lookup_thread(thread); UNLOCK(); result = REAL_FUNC(pthread_detach)(thread); if (result == 0) { LOCK(); t -> flags |= DETACHED; /* Here the pthread thread id may have been recycled. */ if ((t -> flags & FINISHED) != 0) { GC_delete_gc_thread(t); } UNLOCK(); } return result; } #ifndef GC_NO_PTHREAD_CANCEL /* We should deal with the fact that apparently on Solaris and, */ /* probably, on some Linux we can't collect while a thread is */ /* exiting, since signals aren't handled properly. This currently */ /* gives rise to deadlocks. The only workaround seen is to intercept */ /* pthread_cancel() and pthread_exit(), and disable the collections */ /* until the thread exit handler is called. That's ugly, because we */ /* risk growing the heap unnecessarily. But it seems that we don't */ /* really have an option in that the process is not in a fully */ /* functional state while a thread is exiting. */ GC_API int WRAP_FUNC(pthread_cancel)(pthread_t thread) { # ifdef CANCEL_SAFE GC_thread t; DCL_LOCK_STATE; # endif INIT_REAL_SYMS(); # ifdef CANCEL_SAFE LOCK(); t = GC_lookup_thread(thread); /* We test DISABLED_GC because pthread_exit could be called at */ /* the same time. (If t is NULL then pthread_cancel should */ /* return ESRCH.) */ if (t != NULL && (t -> flags & DISABLED_GC) == 0) { t -> flags |= DISABLED_GC; GC_dont_gc++; } UNLOCK(); # endif return REAL_FUNC(pthread_cancel)(thread); } #endif /* !GC_NO_PTHREAD_CANCEL */ #ifdef GC_PTHREAD_EXIT_ATTRIBUTE GC_API GC_PTHREAD_EXIT_ATTRIBUTE void WRAP_FUNC(pthread_exit)(void *retval) { pthread_t self = pthread_self(); GC_thread me; DCL_LOCK_STATE; INIT_REAL_SYMS(); LOCK(); me = GC_lookup_thread(self); /* We test DISABLED_GC because someone else could call */ /* pthread_cancel at the same time. */ if (me != 0 && (me -> flags & DISABLED_GC) == 0) { me -> flags |= DISABLED_GC; GC_dont_gc++; } UNLOCK(); # ifdef NACL /* Native Client doesn't support pthread cleanup functions, */ /* so cleanup the thread here. */ GC_thread_exit_proc(0); # endif REAL_FUNC(pthread_exit)(retval); } #endif /* GC_PTHREAD_EXIT_ATTRIBUTE */ GC_INNER GC_bool GC_in_thread_creation = FALSE; /* Protected by allocation lock. */ GC_INLINE void GC_record_stack_base(GC_thread me, const struct GC_stack_base *sb) { # ifndef GC_DARWIN_THREADS me -> stop_info.stack_ptr = sb -> mem_base; # endif me -> stack_end = sb -> mem_base; if (me -> stack_end == NULL) ABORT("Bad stack base in GC_register_my_thread"); # ifdef IA64 me -> backing_store_end = sb -> reg_base; # endif } STATIC GC_thread GC_register_my_thread_inner(const struct GC_stack_base *sb, pthread_t my_pthread) { GC_thread me; GC_in_thread_creation = TRUE; /* OK to collect from unknown thread. */ me = GC_new_thread(my_pthread); GC_in_thread_creation = FALSE; if (me == 0) ABORT("Failed to allocate memory for thread registering"); # ifdef GC_DARWIN_THREADS me -> stop_info.mach_thread = mach_thread_self(); # endif GC_record_stack_base(me, sb); # ifdef GC_EXPLICIT_SIGNALS_UNBLOCK /* Since this could be executed from a detached thread */ /* destructor, our signals might already be blocked. */ GC_unblock_gc_signals(); # endif return me; } GC_API void GC_CALL GC_allow_register_threads(void) { /* Check GC is initialized and the current thread is registered. */ GC_ASSERT(GC_lookup_thread(pthread_self()) != 0); # ifndef GC_ALWAYS_MULTITHREADED GC_need_to_lock = TRUE; /* We are multi-threaded now. */ # endif } GC_API int GC_CALL GC_register_my_thread(const struct GC_stack_base *sb) { pthread_t self = pthread_self(); GC_thread me; DCL_LOCK_STATE; if (GC_need_to_lock == FALSE) ABORT("Threads explicit registering is not previously enabled"); LOCK(); me = GC_lookup_thread(self); if (0 == me) { me = GC_register_my_thread_inner(sb, self); me -> flags |= DETACHED; /* Treat as detached, since we do not need to worry about */ /* pointer results. */ # if defined(THREAD_LOCAL_ALLOC) GC_init_thread_local(&(me->tlfs)); # endif UNLOCK(); return GC_SUCCESS; } else if ((me -> flags & FINISHED) != 0) { /* This code is executed when a thread is registered from the */ /* client thread key destructor. */ GC_record_stack_base(me, sb); me -> flags &= ~FINISHED; /* but not DETACHED */ # ifdef GC_EXPLICIT_SIGNALS_UNBLOCK /* Since this could be executed from a thread destructor, */ /* our signals might be blocked. */ GC_unblock_gc_signals(); # endif # if defined(THREAD_LOCAL_ALLOC) GC_init_thread_local(&(me->tlfs)); # endif UNLOCK(); return GC_SUCCESS; } else { UNLOCK(); return GC_DUPLICATE; } } struct start_info { void *(*start_routine)(void *); void *arg; word flags; sem_t registered; /* 1 ==> in our thread table, but */ /* parent hasn't yet noticed. */ }; /* Called from GC_inner_start_routine(). Defined in this file to */ /* minimize the number of include files in pthread_start.c (because */ /* sem_t and sem_post() are not used that file directly). */ GC_INNER_PTHRSTART GC_thread GC_start_rtn_prepare_thread( void *(**pstart)(void *), void **pstart_arg, struct GC_stack_base *sb, void *arg) { struct start_info * si = arg; pthread_t self = pthread_self(); GC_thread me; DCL_LOCK_STATE; # ifdef DEBUG_THREADS GC_log_printf("Starting thread %p, pid = %ld, sp = %p\n", (void *)self, (long)getpid(), &arg); # endif LOCK(); me = GC_register_my_thread_inner(sb, self); me -> flags = si -> flags; # if defined(THREAD_LOCAL_ALLOC) GC_init_thread_local(&(me->tlfs)); # endif UNLOCK(); *pstart = si -> start_routine; # ifdef DEBUG_THREADS GC_log_printf("start_routine = %p\n", (void *)(signed_word)(*pstart)); # endif *pstart_arg = si -> arg; sem_post(&(si -> registered)); /* Last action on si. */ /* OK to deallocate. */ return me; } GC_INNER_PTHRSTART void * GC_CALLBACK GC_inner_start_routine( struct GC_stack_base *sb, void *arg); /* defined in pthread_start.c */ STATIC void * GC_start_routine(void * arg) { # ifdef INCLUDE_LINUX_THREAD_DESCR struct GC_stack_base sb; # ifdef REDIRECT_MALLOC /* GC_get_stack_base may call pthread_getattr_np, which can */ /* unfortunately call realloc, which may allocate from an */ /* unregistered thread. This is unpleasant, since it might */ /* force heap growth (or, even, heap overflow). */ GC_disable(); # endif if (GC_get_stack_base(&sb) != GC_SUCCESS) ABORT("Failed to get thread stack base"); # ifdef REDIRECT_MALLOC GC_enable(); # endif return GC_inner_start_routine(&sb, arg); # else return GC_call_with_stack_base(GC_inner_start_routine, arg); # endif } GC_API int WRAP_FUNC(pthread_create)(pthread_t *new_thread, GC_PTHREAD_CREATE_CONST pthread_attr_t *attr, void *(*start_routine)(void *), void *arg) { int result; int detachstate; word my_flags = 0; struct start_info * si; DCL_LOCK_STATE; /* This is otherwise saved only in an area mmapped by the thread */ /* library, which isn't visible to the collector. */ /* We resist the temptation to muck with the stack size here, */ /* even if the default is unreasonably small. That's the client's */ /* responsibility. */ INIT_REAL_SYMS(); LOCK(); si = (struct start_info *)GC_INTERNAL_MALLOC(sizeof(struct start_info), NORMAL); UNLOCK(); if (!EXPECT(parallel_initialized, TRUE)) GC_init_parallel(); if (EXPECT(0 == si, FALSE) && (si = (struct start_info *) (*GC_get_oom_fn())(sizeof(struct start_info))) == 0) return(ENOMEM); if (sem_init(&(si -> registered), GC_SEM_INIT_PSHARED, 0) != 0) ABORT("sem_init failed"); si -> start_routine = start_routine; si -> arg = arg; LOCK(); if (!EXPECT(GC_thr_initialized, TRUE)) GC_thr_init(); # ifdef GC_ASSERTIONS { size_t stack_size = 0; if (NULL != attr) { if (pthread_attr_getstacksize(attr, &stack_size) != 0) ABORT("pthread_attr_getstacksize failed"); } if (0 == stack_size) { pthread_attr_t my_attr; if (pthread_attr_init(&my_attr) != 0) ABORT("pthread_attr_init failed"); if (pthread_attr_getstacksize(&my_attr, &stack_size) != 0) ABORT("pthread_attr_getstacksize failed"); (void)pthread_attr_destroy(&my_attr); } /* On Solaris 10, with default attr initialization, */ /* stack_size remains 0. Fudge it. */ if (0 == stack_size) { # ifndef SOLARIS WARN("Failed to get stack size for assertion checking\n", 0); # endif stack_size = 1000000; } # ifdef PARALLEL_MARK GC_ASSERT(stack_size >= (8*HBLKSIZE*sizeof(word))); # else /* FreeBSD-5.3/Alpha: default pthread stack is 64K, */ /* HBLKSIZE=8192, sizeof(word)=8 */ GC_ASSERT(stack_size >= 65536); # endif /* Our threads may need to do some work for the GC. */ /* Ridiculously small threads won't work, and they */ /* probably wouldn't work anyway. */ } # endif if (NULL == attr) { detachstate = PTHREAD_CREATE_JOINABLE; } else { pthread_attr_getdetachstate(attr, &detachstate); } if (PTHREAD_CREATE_DETACHED == detachstate) my_flags |= DETACHED; si -> flags = my_flags; UNLOCK(); # ifdef DEBUG_THREADS GC_log_printf("About to start new thread from thread %p\n", (void *)pthread_self()); # endif # ifndef GC_ALWAYS_MULTITHREADED GC_need_to_lock = TRUE; # endif result = REAL_FUNC(pthread_create)(new_thread, attr, GC_start_routine, si); /* Wait until child has been added to the thread table. */ /* This also ensures that we hold onto si until the child is done */ /* with it. Thus it doesn't matter whether it is otherwise */ /* visible to the collector. */ if (0 == result) { IF_CANCEL(int cancel_state;) # ifdef DEBUG_THREADS if (new_thread) GC_log_printf("Started thread %p\n", (void *)(*new_thread)); # endif DISABLE_CANCEL(cancel_state); /* pthread_create is not a cancellation point. */ while (0 != sem_wait(&(si -> registered))) { if (EINTR != errno) ABORT("sem_wait failed"); } RESTORE_CANCEL(cancel_state); } sem_destroy(&(si -> registered)); LOCK(); GC_INTERNAL_FREE(si); UNLOCK(); return(result); } #if defined(USE_SPIN_LOCK) || !defined(NO_PTHREAD_TRYLOCK) /* Spend a few cycles in a way that can't introduce contention with */ /* other threads. */ STATIC void GC_pause(void) { int i; # if !defined(__GNUC__) || defined(__INTEL_COMPILER) volatile word dummy = 0; # endif for (i = 0; i < 10; ++i) { # if defined(__GNUC__) && !defined(__INTEL_COMPILER) __asm__ __volatile__ (" " : : : "memory"); # else /* Something that's unlikely to be optimized away. */ GC_noop1(++dummy); # endif } } #endif #define SPIN_MAX 128 /* Maximum number of calls to GC_pause before */ /* give up. */ GC_INNER volatile GC_bool GC_collecting = 0; /* A hint that we're in the collector and */ /* holding the allocation lock for an */ /* extended period. */ #if (!defined(USE_SPIN_LOCK) && !defined(NO_PTHREAD_TRYLOCK)) \ || defined(PARALLEL_MARK) /* If we don't want to use the below spinlock implementation, either */ /* because we don't have a GC_test_and_set implementation, or because */ /* we don't want to risk sleeping, we can still try spinning on */ /* pthread_mutex_trylock for a while. This appears to be very */ /* beneficial in many cases. */ /* I suspect that under high contention this is nearly always better */ /* than the spin lock. But it's a bit slower on a uniprocessor. */ /* Hence we still default to the spin lock. */ /* This is also used to acquire the mark lock for the parallel */ /* marker. */ /* Here we use a strict exponential backoff scheme. I don't know */ /* whether that's better or worse than the above. We eventually */ /* yield by calling pthread_mutex_lock(); it never makes sense to */ /* explicitly sleep. */ /* #define LOCK_STATS */ /* Note that LOCK_STATS requires AO_HAVE_test_and_set. */ #ifdef LOCK_STATS volatile AO_t GC_spin_count = 0; volatile AO_t GC_block_count = 0; volatile AO_t GC_unlocked_count = 0; #endif STATIC void GC_generic_lock(pthread_mutex_t * lock) { #ifndef NO_PTHREAD_TRYLOCK unsigned pause_length = 1; unsigned i; if (0 == pthread_mutex_trylock(lock)) { # ifdef LOCK_STATS (void)AO_fetch_and_add1(&GC_unlocked_count); # endif return; } for (; pause_length <= SPIN_MAX; pause_length <<= 1) { for (i = 0; i < pause_length; ++i) { GC_pause(); } switch(pthread_mutex_trylock(lock)) { case 0: # ifdef LOCK_STATS (void)AO_fetch_and_add1(&GC_spin_count); # endif return; case EBUSY: break; default: ABORT("Unexpected error from pthread_mutex_trylock"); } } #endif /* !NO_PTHREAD_TRYLOCK */ # ifdef LOCK_STATS (void)AO_fetch_and_add1(&GC_block_count); # endif pthread_mutex_lock(lock); } #endif /* !USE_SPIN_LOCK || ... */ #if defined(USE_SPIN_LOCK) /* Reasonably fast spin locks. Basically the same implementation */ /* as STL alloc.h. This isn't really the right way to do this. */ /* but until the POSIX scheduling mess gets straightened out ... */ GC_INNER volatile AO_TS_t GC_allocate_lock = AO_TS_INITIALIZER; GC_INNER void GC_lock(void) { # define low_spin_max 30 /* spin cycles if we suspect uniprocessor */ # define high_spin_max SPIN_MAX /* spin cycles for multiprocessor */ static unsigned spin_max = low_spin_max; unsigned my_spin_max; static unsigned last_spins = 0; unsigned my_last_spins; unsigned i; if (AO_test_and_set_acquire(&GC_allocate_lock) == AO_TS_CLEAR) { return; } my_spin_max = spin_max; my_last_spins = last_spins; for (i = 0; i < my_spin_max; i++) { if (GC_collecting || GC_nprocs == 1) goto yield; if (i < my_last_spins/2) { GC_pause(); continue; } if (AO_test_and_set_acquire(&GC_allocate_lock) == AO_TS_CLEAR) { /* * got it! * Spinning worked. Thus we're probably not being scheduled * against the other process with which we were contending. * Thus it makes sense to spin longer the next time. */ last_spins = i; spin_max = high_spin_max; return; } } /* We are probably being scheduled against the other process. Sleep. */ spin_max = low_spin_max; yield: for (i = 0;; ++i) { if (AO_test_and_set_acquire(&GC_allocate_lock) == AO_TS_CLEAR) { return; } # define SLEEP_THRESHOLD 12 /* Under Linux very short sleeps tend to wait until */ /* the current time quantum expires. On old Linux */ /* kernels nanosleep(<= 2ms) just spins under Linux. */ /* (Under 2.4, this happens only for real-time */ /* processes.) We want to minimize both behaviors */ /* here. */ if (i < SLEEP_THRESHOLD) { sched_yield(); } else { struct timespec ts; if (i > 24) i = 24; /* Don't wait for more than about 15msecs, even */ /* under extreme contention. */ ts.tv_sec = 0; ts.tv_nsec = 1 << i; nanosleep(&ts, 0); } } } #else /* !USE_SPIN_LOCK */ GC_INNER void GC_lock(void) { #ifndef NO_PTHREAD_TRYLOCK if (1 == GC_nprocs || GC_collecting) { pthread_mutex_lock(&GC_allocate_ml); } else { GC_generic_lock(&GC_allocate_ml); } #else /* !NO_PTHREAD_TRYLOCK */ pthread_mutex_lock(&GC_allocate_ml); #endif /* !NO_PTHREAD_TRYLOCK */ } #endif /* !USE_SPIN_LOCK */ #ifdef PARALLEL_MARK # ifdef GC_ASSERTIONS STATIC unsigned long GC_mark_lock_holder = NO_THREAD; # define SET_MARK_LOCK_HOLDER \ (void)(GC_mark_lock_holder = NUMERIC_THREAD_ID(pthread_self())) # define UNSET_MARK_LOCK_HOLDER \ do { \ GC_ASSERT(GC_mark_lock_holder \ == NUMERIC_THREAD_ID(pthread_self())); \ GC_mark_lock_holder = NO_THREAD; \ } while (0) # else # define SET_MARK_LOCK_HOLDER (void)0 # define UNSET_MARK_LOCK_HOLDER (void)0 # endif /* !GC_ASSERTIONS */ #ifdef GLIBC_2_1_MUTEX_HACK /* Ugly workaround for a linux threads bug in the final versions */ /* of glibc2.1. Pthread_mutex_trylock sets the mutex owner */ /* field even when it fails to acquire the mutex. This causes */ /* pthread_cond_wait to die. Remove for glibc2.2. */ /* According to the man page, we should use */ /* PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP, but that isn't actually */ /* defined. */ static pthread_mutex_t mark_mutex = {0, 0, 0, PTHREAD_MUTEX_ERRORCHECK_NP, {0, 0}}; #else static pthread_mutex_t mark_mutex = PTHREAD_MUTEX_INITIALIZER; #endif static pthread_cond_t builder_cv = PTHREAD_COND_INITIALIZER; #ifdef GLIBC_2_19_TSX_BUG /* Parse string like [.[]] and return major value. */ static int parse_version(int *pminor, const char *pverstr) { char *endp; unsigned long value = strtoul(pverstr, &endp, 10); int major = (int)value; if (major < 0 || (char *)pverstr == endp || (unsigned)major != value) { /* Parse error */ return -1; } if (*endp != '.') { /* No minor part. */ *pminor = -1; } else { value = strtoul(endp + 1, &endp, 10); *pminor = (int)value; if (*pminor < 0 || (unsigned)(*pminor) != value) { return -1; } } return major; } #endif /* GLIBC_2_19_TSX_BUG */ static void setup_mark_lock(void) { # ifdef GLIBC_2_19_TSX_BUG pthread_mutexattr_t mattr; int glibc_minor = -1; int glibc_major = parse_version(&glibc_minor, gnu_get_libc_version()); if (glibc_major > 2 || (glibc_major == 2 && glibc_minor >= 19)) { /* TODO: disable this workaround for glibc with fixed TSX */ /* This disables lock elision to workaround a bug in glibc 2.19+ */ if (0 != pthread_mutexattr_init(&mattr)) { ABORT("pthread_mutexattr_init failed"); } if (0 != pthread_mutexattr_settype(&mattr, PTHREAD_MUTEX_NORMAL)) { ABORT("pthread_mutexattr_settype failed"); } if (0 != pthread_mutex_init(&mark_mutex, &mattr)) { ABORT("pthread_mutex_init failed"); } (void)pthread_mutexattr_destroy(&mattr); } # endif } GC_INNER void GC_acquire_mark_lock(void) { # ifdef NUMERIC_THREAD_ID_UNIQUE GC_ASSERT(GC_mark_lock_holder != NUMERIC_THREAD_ID(pthread_self())); # endif GC_generic_lock(&mark_mutex); SET_MARK_LOCK_HOLDER; } GC_INNER void GC_release_mark_lock(void) { UNSET_MARK_LOCK_HOLDER; if (pthread_mutex_unlock(&mark_mutex) != 0) { ABORT("pthread_mutex_unlock failed"); } } /* Collector must wait for a freelist builders for 2 reasons: */ /* 1) Mark bits may still be getting examined without lock. */ /* 2) Partial free lists referenced only by locals may not be scanned */ /* correctly, e.g. if they contain "pointer-free" objects, since the */ /* free-list link may be ignored. */ STATIC void GC_wait_builder(void) { ASSERT_CANCEL_DISABLED(); UNSET_MARK_LOCK_HOLDER; if (pthread_cond_wait(&builder_cv, &mark_mutex) != 0) { ABORT("pthread_cond_wait failed"); } GC_ASSERT(GC_mark_lock_holder == NO_THREAD); SET_MARK_LOCK_HOLDER; } GC_INNER void GC_wait_for_reclaim(void) { GC_acquire_mark_lock(); while (GC_fl_builder_count > 0) { GC_wait_builder(); } GC_release_mark_lock(); } GC_INNER void GC_notify_all_builder(void) { GC_ASSERT(GC_mark_lock_holder == NUMERIC_THREAD_ID(pthread_self())); if (pthread_cond_broadcast(&builder_cv) != 0) { ABORT("pthread_cond_broadcast failed"); } } static pthread_cond_t mark_cv = PTHREAD_COND_INITIALIZER; GC_INNER void GC_wait_marker(void) { ASSERT_CANCEL_DISABLED(); UNSET_MARK_LOCK_HOLDER; if (pthread_cond_wait(&mark_cv, &mark_mutex) != 0) { ABORT("pthread_cond_wait failed"); } GC_ASSERT(GC_mark_lock_holder == NO_THREAD); SET_MARK_LOCK_HOLDER; } GC_INNER void GC_notify_all_marker(void) { if (pthread_cond_broadcast(&mark_cv) != 0) { ABORT("pthread_cond_broadcast failed"); } } #endif /* PARALLEL_MARK */ #ifdef PTHREAD_REGISTER_CANCEL_WEAK_STUBS /* Workaround "undefined reference" linkage errors on some targets. */ void __pthread_register_cancel() __attribute__((__weak__)); void __pthread_unregister_cancel() __attribute__((__weak__)); void __pthread_register_cancel() {} void __pthread_unregister_cancel() {} #endif #endif /* GC_PTHREADS */ ecl-16.1.2/src/bdwgc/ptr_chck.c000066400000000000000000000225661266352375300162110ustar00rootroot00000000000000/* * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. */ #include "private/gc_pmark.h" /* * These are checking routines calls to which could be inserted by a * preprocessor to validate C pointer arithmetic. */ STATIC void GC_CALLBACK GC_default_same_obj_print_proc(void * p, void * q) { ABORT_ARG2("GC_same_obj test failed", ": %p and %p are not in the same object", p, q); } void (GC_CALLBACK *GC_same_obj_print_proc) (void *, void *) = GC_default_same_obj_print_proc; /* Check that p and q point to the same object. Call */ /* *GC_same_obj_print_proc if they don't. */ /* Returns the first argument. (Return value may be hard */ /* to use due to typing issues. But if we had a suitable */ /* preprocessor...) */ /* Succeeds if neither p nor q points to the heap. */ /* We assume this is performance critical. (It shouldn't */ /* be called by production code, but this can easily make */ /* debugging intolerably slow.) */ GC_API void * GC_CALL GC_same_obj(void *p, void *q) { struct hblk *h; hdr *hhdr; ptr_t base, limit; word sz; if (!EXPECT(GC_is_initialized, TRUE)) GC_init(); hhdr = HDR((word)p); if (hhdr == 0) { if (divHBLKSZ((word)p) != divHBLKSZ((word)q) && HDR((word)q) != 0) { goto fail; } return(p); } /* If it's a pointer to the middle of a large object, move it */ /* to the beginning. */ if (IS_FORWARDING_ADDR_OR_NIL(hhdr)) { h = HBLKPTR(p) - (word)hhdr; hhdr = HDR(h); while (IS_FORWARDING_ADDR_OR_NIL(hhdr)) { h = FORWARDED_ADDR(h, hhdr); hhdr = HDR(h); } limit = (ptr_t)h + hhdr -> hb_sz; if ((word)p >= (word)limit || (word)q >= (word)limit || (word)q < (word)h) { goto fail; } return(p); } sz = hhdr -> hb_sz; if (sz > MAXOBJBYTES) { base = (ptr_t)HBLKPTR(p); limit = base + sz; if ((word)p >= (word)limit) { goto fail; } } else { size_t offset; size_t pdispl = HBLKDISPL(p); offset = pdispl % sz; if (HBLKPTR(p) != HBLKPTR(q)) goto fail; /* W/o this check, we might miss an error if */ /* q points to the first object on a page, and */ /* points just before the page. */ base = (ptr_t)p - offset; limit = base + sz; } /* [base, limit) delimits the object containing p, if any. */ /* If p is not inside a valid object, then either q is */ /* also outside any valid object, or it is outside */ /* [base, limit). */ if ((word)q >= (word)limit || (word)q < (word)base) { goto fail; } return(p); fail: (*GC_same_obj_print_proc)((ptr_t)p, (ptr_t)q); return(p); } STATIC void GC_CALLBACK GC_default_is_valid_displacement_print_proc (void *p) { ABORT_ARG1("GC_is_valid_displacement test failed", ": %p not valid", p); } void (GC_CALLBACK *GC_is_valid_displacement_print_proc)(void *) = GC_default_is_valid_displacement_print_proc; /* Check that if p is a pointer to a heap page, then it points to */ /* a valid displacement within a heap object. */ /* Uninteresting with GC_all_interior_pointers. */ /* Always returns its argument. */ /* Note that we don't lock, since nothing relevant about the header */ /* should change while we have a valid object pointer to the block. */ GC_API void * GC_CALL GC_is_valid_displacement(void *p) { hdr *hhdr; word pdispl; word offset; struct hblk *h; word sz; if (!EXPECT(GC_is_initialized, TRUE)) GC_init(); hhdr = HDR((word)p); if (hhdr == 0) return(p); h = HBLKPTR(p); if (GC_all_interior_pointers) { while (IS_FORWARDING_ADDR_OR_NIL(hhdr)) { h = FORWARDED_ADDR(h, hhdr); hhdr = HDR(h); } } if (IS_FORWARDING_ADDR_OR_NIL(hhdr)) { goto fail; } sz = hhdr -> hb_sz; pdispl = HBLKDISPL(p); offset = pdispl % sz; if ((sz > MAXOBJBYTES && (word)p >= (word)h + sz) || !GC_valid_offsets[offset] || (word)p - offset + sz > (word)(h + 1)) { goto fail; } return(p); fail: (*GC_is_valid_displacement_print_proc)((ptr_t)p); return(p); } STATIC void GC_CALLBACK GC_default_is_visible_print_proc(void * p) { ABORT_ARG1("GC_is_visible test failed", ": %p not GC-visible", p); } void (GC_CALLBACK *GC_is_visible_print_proc)(void * p) = GC_default_is_visible_print_proc; #ifndef THREADS /* Could p be a stack address? */ STATIC GC_bool GC_on_stack(ptr_t p) { # ifdef STACK_GROWS_DOWN if ((word)p >= (word)GC_approx_sp() && (word)p < (word)GC_stackbottom) { return(TRUE); } # else if ((word)p <= (word)GC_approx_sp() && (word)p > (word)GC_stackbottom) { return(TRUE); } # endif return(FALSE); } #endif /* Check that p is visible */ /* to the collector as a possibly pointer containing location. */ /* If it isn't invoke *GC_is_visible_print_proc. */ /* Returns the argument in all cases. May erroneously succeed */ /* in hard cases. (This is intended for debugging use with */ /* untyped allocations. The idea is that it should be possible, though */ /* slow, to add such a call to all indirect pointer stores.) */ /* Currently useless for the multi-threaded worlds. */ GC_API void * GC_CALL GC_is_visible(void *p) { hdr *hhdr; if ((word)p & (ALIGNMENT - 1)) goto fail; if (!EXPECT(GC_is_initialized, TRUE)) GC_init(); # ifdef THREADS hhdr = HDR((word)p); if (hhdr != 0 && GC_base(p) == 0) { goto fail; } else { /* May be inside thread stack. We can't do much. */ return(p); } # else /* Check stack first: */ if (GC_on_stack(p)) return(p); hhdr = HDR((word)p); if (hhdr == 0) { if (GC_is_static_root(p)) return(p); /* Else do it again correctly: */ # if defined(DYNAMIC_LOADING) || defined(MSWIN32) \ || defined(MSWINCE) || defined(CYGWIN32) || defined(PCR) GC_register_dynamic_libraries(); if (GC_is_static_root(p)) return(p); # endif goto fail; } else { /* p points to the heap. */ word descr; ptr_t base = GC_base(p); /* Should be manually inlined? */ if (base == 0) goto fail; if (HBLKPTR(base) != HBLKPTR(p)) hhdr = HDR((word)p); descr = hhdr -> hb_descr; retry: switch(descr & GC_DS_TAGS) { case GC_DS_LENGTH: if ((word)p - (word)base > descr) goto fail; break; case GC_DS_BITMAP: if ((word)p - (word)base >= WORDS_TO_BYTES(BITMAP_BITS) || ((word)p & (sizeof(word) - 1))) goto fail; if (!(((word)1 << (WORDSZ - ((ptr_t)p - (ptr_t)base) - 1)) & descr)) goto fail; break; case GC_DS_PROC: /* We could try to decipher this partially. */ /* For now we just punt. */ break; case GC_DS_PER_OBJECT: if ((signed_word)descr >= 0) { descr = *(word *)((ptr_t)base + (descr & ~GC_DS_TAGS)); } else { ptr_t type_descr = *(ptr_t *)base; descr = *(word *)(type_descr - (descr - (word)(GC_DS_PER_OBJECT - GC_INDIR_PER_OBJ_BIAS))); } goto retry; } return(p); } # endif fail: (*GC_is_visible_print_proc)((ptr_t)p); return(p); } GC_API void * GC_CALL GC_pre_incr (void **p, ptrdiff_t how_much) { void * initial = *p; void * result = GC_same_obj((void *)((ptr_t)initial + how_much), initial); if (!GC_all_interior_pointers) { (void) GC_is_valid_displacement(result); } return (*p = result); } GC_API void * GC_CALL GC_post_incr (void **p, ptrdiff_t how_much) { void * initial = *p; void * result = GC_same_obj((void *)((ptr_t)initial + how_much), initial); if (!GC_all_interior_pointers) { (void) GC_is_valid_displacement(result); } *p = result; return(initial); } ecl-16.1.2/src/bdwgc/real_malloc.c000066400000000000000000000021331266352375300166520ustar00rootroot00000000000000/* * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. */ # ifdef HAVE_CONFIG_H # include "config.h" # endif # ifdef PCR /* * This definition should go in its own file that includes no other * header files. Otherwise, we risk not getting the underlying system * malloc. */ # define PCR_NO_RENAME # include void * real_malloc(size_t size) { return(malloc(size)); } # else extern int GC_quiet; /* ANSI C doesn't allow translation units to be empty. */ /* So we guarantee this one is nonempty. */ #endif /* PCR */ ecl-16.1.2/src/bdwgc/reclaim.c000066400000000000000000000604611266352375300160240ustar00rootroot00000000000000/* * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers * Copyright (c) 1991-1996 by Xerox Corporation. All rights reserved. * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. * Copyright (c) 1999-2004 Hewlett-Packard Development Company, L.P. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. */ #include "private/gc_priv.h" #ifdef ENABLE_DISCLAIM # include "gc_disclaim.h" #endif #include GC_INNER signed_word GC_bytes_found = 0; /* Number of bytes of memory reclaimed */ /* minus the number of bytes originally */ /* on free lists which we had to drop. */ #if defined(PARALLEL_MARK) GC_INNER word GC_fl_builder_count = 0; /* Number of threads currently building free lists without */ /* holding GC lock. It is not safe to collect if this is */ /* nonzero. */ #endif /* PARALLEL_MARK */ /* We defer printing of leaked objects until we're done with the GC */ /* cycle, since the routine for printing objects needs to run outside */ /* the collector, e.g. without the allocation lock. */ #ifndef MAX_LEAKED # define MAX_LEAKED 40 #endif STATIC ptr_t GC_leaked[MAX_LEAKED] = { NULL }; STATIC unsigned GC_n_leaked = 0; GC_INNER GC_bool GC_have_errors = FALSE; #if !defined(EAGER_SWEEP) && defined(ENABLE_DISCLAIM) STATIC void GC_reclaim_unconditionally_marked(void); #endif GC_INLINE void GC_add_leaked(ptr_t leaked) { # ifndef SHORT_DBG_HDRS if (GC_findleak_delay_free && !GC_check_leaked(leaked)) return; # endif GC_have_errors = TRUE; if (GC_n_leaked < MAX_LEAKED) { GC_leaked[GC_n_leaked++] = leaked; /* Make sure it's not reclaimed this cycle */ GC_set_mark_bit(leaked); } } /* Print all objects on the list after printing any smashed objects. */ /* Clear both lists. Called without the allocation lock held. */ GC_INNER void GC_print_all_errors(void) { static GC_bool printing_errors = FALSE; GC_bool have_errors; unsigned i, n_leaked; ptr_t leaked[MAX_LEAKED]; DCL_LOCK_STATE; LOCK(); if (printing_errors) { UNLOCK(); return; } have_errors = GC_have_errors; printing_errors = TRUE; n_leaked = GC_n_leaked; GC_ASSERT(n_leaked <= MAX_LEAKED); BCOPY(GC_leaked, leaked, n_leaked * sizeof(ptr_t)); GC_n_leaked = 0; BZERO(GC_leaked, n_leaked * sizeof(ptr_t)); UNLOCK(); if (GC_debugging_started) { GC_print_all_smashed(); } else { have_errors = FALSE; } if (n_leaked > 0) { GC_err_printf("Found %u leaked objects:\n", n_leaked); have_errors = TRUE; } for (i = 0; i < n_leaked; i++) { ptr_t p = leaked[i]; GC_print_heap_obj(p); GC_free(p); } if (have_errors # ifndef GC_ABORT_ON_LEAK && GETENV("GC_ABORT_ON_LEAK") != NULL # endif ) { ABORT("Leaked or smashed objects encountered"); } LOCK(); printing_errors = FALSE; UNLOCK(); } /* * reclaim phase * */ /* Test whether a block is completely empty, i.e. contains no marked */ /* objects. This does not require the block to be in physical memory. */ GC_INNER GC_bool GC_block_empty(hdr *hhdr) { return (hhdr -> hb_n_marks == 0); } STATIC GC_bool GC_block_nearly_full(hdr *hhdr) { return (hhdr -> hb_n_marks > 7 * HBLK_OBJS(hhdr -> hb_sz)/8); } /* FIXME: This should perhaps again be specialized for USE_MARK_BYTES */ /* and USE_MARK_BITS cases. */ /* * Restore unmarked small objects in h of size sz to the object * free list. Returns the new list. * Clears unmarked objects. Sz is in bytes. */ STATIC ptr_t GC_reclaim_clear(struct hblk *hbp, hdr *hhdr, size_t sz, ptr_t list, signed_word *count) { word bit_no = 0; word *p, *q, *plim; signed_word n_bytes_found = 0; GC_ASSERT(hhdr == GC_find_header((ptr_t)hbp)); GC_ASSERT(sz == hhdr -> hb_sz); GC_ASSERT((sz & (BYTES_PER_WORD-1)) == 0); p = (word *)(hbp->hb_body); plim = (word *)(hbp->hb_body + HBLKSIZE - sz); /* go through all words in block */ while ((word)p <= (word)plim) { if (mark_bit_from_hdr(hhdr, bit_no)) { p = (word *)((ptr_t)p + sz); } else { n_bytes_found += sz; /* object is available - put on list */ obj_link(p) = list; list = ((ptr_t)p); /* Clear object, advance p to next object in the process */ q = (word *)((ptr_t)p + sz); # ifdef USE_MARK_BYTES GC_ASSERT(!(sz & 1) && !((word)p & (2 * sizeof(word) - 1))); p[1] = 0; p += 2; while ((word)p < (word)q) { CLEAR_DOUBLE(p); p += 2; } # else p++; /* Skip link field */ while ((word)p < (word)q) { *p++ = 0; } # endif } bit_no += MARK_BIT_OFFSET(sz); } *count += n_bytes_found; return(list); } /* The same thing, but don't clear objects: */ STATIC ptr_t GC_reclaim_uninit(struct hblk *hbp, hdr *hhdr, size_t sz, ptr_t list, signed_word *count) { word bit_no = 0; word *p, *plim; signed_word n_bytes_found = 0; GC_ASSERT(sz == hhdr -> hb_sz); p = (word *)(hbp->hb_body); plim = (word *)((ptr_t)hbp + HBLKSIZE - sz); /* go through all words in block */ while ((word)p <= (word)plim) { if (!mark_bit_from_hdr(hhdr, bit_no)) { n_bytes_found += sz; /* object is available - put on list */ obj_link(p) = list; list = ((ptr_t)p); } p = (word *)((ptr_t)p + sz); bit_no += MARK_BIT_OFFSET(sz); } *count += n_bytes_found; return(list); } #ifdef ENABLE_DISCLAIM /* Call reclaim notifier for block's kind on each unmarked object in */ /* block, all within a pair of corresponding enter/leave callbacks. */ STATIC ptr_t GC_disclaim_and_reclaim(struct hblk *hbp, hdr *hhdr, size_t sz, ptr_t list, signed_word *count) { int bit_no = 0; word *p, *q, *plim; signed_word n_bytes_found = 0; struct obj_kind *ok = &GC_obj_kinds[hhdr->hb_obj_kind]; int (GC_CALLBACK *disclaim)(void *) = ok->ok_disclaim_proc; GC_ASSERT(sz == hhdr -> hb_sz); p = (word *)(hbp -> hb_body); plim = (word *)((ptr_t)p + HBLKSIZE - sz); while ((word)p <= (word)plim) { int marked = mark_bit_from_hdr(hhdr, bit_no); if (!marked && (*disclaim)(p)) { hhdr -> hb_n_marks++; marked = 1; } if (marked) p = (word *)((ptr_t)p + sz); else { n_bytes_found += sz; /* object is available - put on list */ obj_link(p) = list; list = ((ptr_t)p); /* Clear object, advance p to next object in the process */ q = (word *)((ptr_t)p + sz); # ifdef USE_MARK_BYTES GC_ASSERT((sz & 1) == 0); GC_ASSERT(((word)p & (2 * sizeof(word) - 1)) == 0); p[1] = 0; p += 2; while ((word)p < (word)q) { CLEAR_DOUBLE(p); p += 2; } # else p++; /* Skip link field */ while ((word)p < (word)q) { *p++ = 0; } # endif } bit_no += MARK_BIT_OFFSET(sz); } *count += n_bytes_found; return list; } #endif /* ENABLE_DISCLAIM */ /* Don't really reclaim objects, just check for unmarked ones: */ STATIC void GC_reclaim_check(struct hblk *hbp, hdr *hhdr, word sz) { word bit_no; ptr_t p, plim; GC_ASSERT(sz == hhdr -> hb_sz); /* go through all words in block */ p = hbp->hb_body; plim = p + HBLKSIZE - sz; for (bit_no = 0; (word)p <= (word)plim; p += sz, bit_no += MARK_BIT_OFFSET(sz)) { if (!mark_bit_from_hdr(hhdr, bit_no)) { GC_add_leaked(p); } } } /* * Generic procedure to rebuild a free list in hbp. * Also called directly from GC_malloc_many. * Sz is now in bytes. */ GC_INNER ptr_t GC_reclaim_generic(struct hblk * hbp, hdr *hhdr, size_t sz, GC_bool init, ptr_t list, signed_word *count) { ptr_t result; GC_ASSERT(GC_find_header((ptr_t)hbp) == hhdr); # ifndef GC_DISABLE_INCREMENTAL GC_remove_protection(hbp, 1, (hhdr)->hb_descr == 0 /* Pointer-free? */); # endif # ifdef ENABLE_DISCLAIM if ((hhdr -> hb_flags & HAS_DISCLAIM) != 0) { result = GC_disclaim_and_reclaim(hbp, hhdr, sz, list, count); } else # endif /* else */ if (init || GC_debugging_started) { result = GC_reclaim_clear(hbp, hhdr, sz, list, count); } else { GC_ASSERT((hhdr)->hb_descr == 0 /* Pointer-free block */); result = GC_reclaim_uninit(hbp, hhdr, sz, list, count); } if (IS_UNCOLLECTABLE(hhdr -> hb_obj_kind)) GC_set_hdr_marks(hhdr); return result; } /* * Restore unmarked small objects in the block pointed to by hbp * to the appropriate object free list. * If entirely empty blocks are to be completely deallocated, then * caller should perform that check. */ STATIC void GC_reclaim_small_nonempty_block(struct hblk *hbp, GC_bool report_if_found) { hdr *hhdr = HDR(hbp); size_t sz = hhdr -> hb_sz; struct obj_kind * ok = &GC_obj_kinds[hhdr -> hb_obj_kind]; void **flh = &(ok -> ok_freelist[BYTES_TO_GRANULES(sz)]); hhdr -> hb_last_reclaimed = (unsigned short) GC_gc_no; if (report_if_found) { GC_reclaim_check(hbp, hhdr, sz); } else { *flh = GC_reclaim_generic(hbp, hhdr, sz, ok -> ok_init, *flh, &GC_bytes_found); } } #ifdef ENABLE_DISCLAIM STATIC void GC_disclaim_and_reclaim_or_free_small_block(struct hblk *hbp) { hdr *hhdr = HDR(hbp); size_t sz = hhdr -> hb_sz; struct obj_kind * ok = &GC_obj_kinds[hhdr -> hb_obj_kind]; void **flh = &(ok -> ok_freelist[BYTES_TO_GRANULES(sz)]); void *flh_next; hhdr -> hb_last_reclaimed = (unsigned short) GC_gc_no; flh_next = GC_reclaim_generic(hbp, hhdr, sz, ok -> ok_init, *flh, &GC_bytes_found); if (hhdr -> hb_n_marks) *flh = flh_next; else { GC_bytes_found += HBLKSIZE; GC_freehblk(hbp); } } #endif /* ENABLE_DISCLAIM */ /* * Restore an unmarked large object or an entirely empty blocks of small objects * to the heap block free list. * Otherwise enqueue the block for later processing * by GC_reclaim_small_nonempty_block. * If report_if_found is TRUE, then process any block immediately, and * simply report free objects; do not actually reclaim them. */ STATIC void GC_reclaim_block(struct hblk *hbp, word report_if_found) { hdr * hhdr = HDR(hbp); size_t sz = hhdr -> hb_sz; /* size of objects in current block */ struct obj_kind * ok = &GC_obj_kinds[hhdr -> hb_obj_kind]; struct hblk ** rlh; if( sz > MAXOBJBYTES ) { /* 1 big object */ if( !mark_bit_from_hdr(hhdr, 0) ) { if (report_if_found) { GC_add_leaked((ptr_t)hbp); } else { size_t blocks; # ifdef ENABLE_DISCLAIM if (EXPECT(hhdr->hb_flags & HAS_DISCLAIM, 0)) { struct obj_kind *ok = &GC_obj_kinds[hhdr->hb_obj_kind]; if ((*ok->ok_disclaim_proc)(hbp)) { /* Not disclaimed => resurrect the object. */ set_mark_bit_from_hdr(hhdr, 0); goto in_use; } } # endif blocks = OBJ_SZ_TO_BLOCKS(sz); if (blocks > 1) { GC_large_allocd_bytes -= blocks * HBLKSIZE; } GC_bytes_found += sz; GC_freehblk(hbp); } } else { # ifdef ENABLE_DISCLAIM in_use: # endif if (hhdr -> hb_descr != 0) { GC_composite_in_use += sz; } else { GC_atomic_in_use += sz; } } } else { GC_bool empty = GC_block_empty(hhdr); # ifdef PARALLEL_MARK /* Count can be low or one too high because we sometimes */ /* have to ignore decrements. Objects can also potentially */ /* be repeatedly marked by each marker. */ /* Here we assume two markers, but this is extremely */ /* unlikely to fail spuriously with more. And if it does, it */ /* should be looked at. */ GC_ASSERT(hhdr -> hb_n_marks <= 2 * (HBLKSIZE/sz + 1) + 16); # else GC_ASSERT(sz * hhdr -> hb_n_marks <= HBLKSIZE); # endif if (report_if_found) { GC_reclaim_small_nonempty_block(hbp, TRUE /* report_if_found */); } else if (empty) { # ifdef ENABLE_DISCLAIM if ((hhdr -> hb_flags & HAS_DISCLAIM) != 0) { GC_disclaim_and_reclaim_or_free_small_block(hbp); } else # endif /* else */ { GC_bytes_found += HBLKSIZE; GC_freehblk(hbp); } } else if (GC_find_leak || !GC_block_nearly_full(hhdr)) { /* group of smaller objects, enqueue the real work */ rlh = &(ok -> ok_reclaim_list[BYTES_TO_GRANULES(sz)]); hhdr -> hb_next = *rlh; *rlh = hbp; } /* else not worth salvaging. */ /* We used to do the nearly_full check later, but we */ /* already have the right cache context here. Also */ /* doing it here avoids some silly lock contention in */ /* GC_malloc_many. */ if (hhdr -> hb_descr != 0) { GC_composite_in_use += sz * hhdr -> hb_n_marks; } else { GC_atomic_in_use += sz * hhdr -> hb_n_marks; } } } #if !defined(NO_DEBUGGING) /* Routines to gather and print heap block info */ /* intended for debugging. Otherwise should be called */ /* with lock. */ struct Print_stats { size_t number_of_blocks; size_t total_bytes; }; #ifdef USE_MARK_BYTES /* Return the number of set mark bits in the given header. */ /* Remains externally visible as used by GNU GCJ currently. */ int GC_n_set_marks(hdr *hhdr) { int result = 0; int i; size_t sz = hhdr -> hb_sz; int offset = (int)MARK_BIT_OFFSET(sz); int limit = (int)FINAL_MARK_BIT(sz); for (i = 0; i < limit; i += offset) { result += hhdr -> hb_marks[i]; } GC_ASSERT(hhdr -> hb_marks[limit]); return(result); } #else /* Number of set bits in a word. Not performance critical. */ static int set_bits(word n) { word m = n; int result = 0; while (m > 0) { if (m & 1) result++; m >>= 1; } return(result); } int GC_n_set_marks(hdr *hhdr) { int result = 0; int i; int n_mark_words; # ifdef MARK_BIT_PER_OBJ int n_objs = (int)HBLK_OBJS(hhdr -> hb_sz); if (0 == n_objs) n_objs = 1; n_mark_words = divWORDSZ(n_objs + WORDSZ - 1); # else /* MARK_BIT_PER_GRANULE */ n_mark_words = MARK_BITS_SZ; # endif for (i = 0; i < n_mark_words - 1; i++) { result += set_bits(hhdr -> hb_marks[i]); } # ifdef MARK_BIT_PER_OBJ result += set_bits((hhdr -> hb_marks[n_mark_words - 1]) << (n_mark_words * WORDSZ - n_objs)); # else result += set_bits(hhdr -> hb_marks[n_mark_words - 1]); # endif return(result - 1); } #endif /* !USE_MARK_BYTES */ STATIC void GC_print_block_descr(struct hblk *h, word /* struct PrintStats */ raw_ps) { hdr * hhdr = HDR(h); size_t bytes = hhdr -> hb_sz; struct Print_stats *ps; unsigned n_marks = GC_n_set_marks(hhdr); if (hhdr -> hb_n_marks != n_marks) { GC_printf("(%u:%u,%u!=%u)\n", hhdr->hb_obj_kind, (unsigned)bytes, (unsigned)hhdr->hb_n_marks, n_marks); } else { GC_printf("(%u:%u,%u)\n", hhdr->hb_obj_kind, (unsigned)bytes, n_marks); } bytes += HBLKSIZE-1; bytes &= ~(HBLKSIZE-1); ps = (struct Print_stats *)raw_ps; ps->total_bytes += bytes; ps->number_of_blocks++; } void GC_print_block_list(void) { struct Print_stats pstats; GC_printf("(kind(0=ptrfree,1=normal,2=unc.):size_in_bytes, #_marks_set)\n"); pstats.number_of_blocks = 0; pstats.total_bytes = 0; GC_apply_to_all_blocks(GC_print_block_descr, (word)&pstats); GC_printf("blocks= %lu, bytes= %lu\n", (unsigned long)pstats.number_of_blocks, (unsigned long)pstats.total_bytes); } /* Currently for debugger use only: */ void GC_print_free_list(int kind, size_t sz_in_granules) { struct obj_kind * ok = &GC_obj_kinds[kind]; ptr_t flh = ok -> ok_freelist[sz_in_granules]; int n; for (n = 0; flh; n++) { struct hblk *block = HBLKPTR(flh); GC_printf("Free object in heap block %p [%d]: %p\n", (void *)block, n, flh); flh = obj_link(flh); } } #endif /* !NO_DEBUGGING */ /* * Clear all obj_link pointers in the list of free objects *flp. * Clear *flp. * This must be done before dropping a list of free gcj-style objects, * since may otherwise end up with dangling "descriptor" pointers. * It may help for other pointer-containing objects. */ STATIC void GC_clear_fl_links(void **flp) { void *next = *flp; while (0 != next) { *flp = 0; flp = &(obj_link(next)); next = *flp; } } /* * Perform GC_reclaim_block on the entire heap, after first clearing * small object free lists (if we are not just looking for leaks). */ GC_INNER void GC_start_reclaim(GC_bool report_if_found) { unsigned kind; # if defined(PARALLEL_MARK) GC_ASSERT(0 == GC_fl_builder_count); # endif /* Reset in use counters. GC_reclaim_block recomputes them. */ GC_composite_in_use = 0; GC_atomic_in_use = 0; /* Clear reclaim- and free-lists */ for (kind = 0; kind < GC_n_kinds; kind++) { void **fop; void **lim; struct hblk ** rlist = GC_obj_kinds[kind].ok_reclaim_list; GC_bool should_clobber = (GC_obj_kinds[kind].ok_descriptor != 0); if (rlist == 0) continue; /* This kind not used. */ if (!report_if_found) { lim = &(GC_obj_kinds[kind].ok_freelist[MAXOBJGRANULES+1]); for (fop = GC_obj_kinds[kind].ok_freelist; (word)fop < (word)lim; fop++) { if (*fop != 0) { if (should_clobber) { GC_clear_fl_links(fop); } else { *fop = 0; } } } } /* otherwise free list objects are marked, */ /* and its safe to leave them */ BZERO(rlist, (MAXOBJGRANULES + 1) * sizeof(void *)); } /* Go through all heap blocks (in hblklist) and reclaim unmarked objects */ /* or enqueue the block for later processing. */ GC_apply_to_all_blocks(GC_reclaim_block, (word)report_if_found); # ifdef EAGER_SWEEP /* This is a very stupid thing to do. We make it possible anyway, */ /* so that you can convince yourself that it really is very stupid. */ GC_reclaim_all((GC_stop_func)0, FALSE); # elif defined(ENABLE_DISCLAIM) /* However, make sure to clear reclaimable objects of kinds with */ /* unconditional marking enabled before we do any significant */ /* marking work. */ GC_reclaim_unconditionally_marked(); # endif # if defined(PARALLEL_MARK) GC_ASSERT(0 == GC_fl_builder_count); # endif } /* * Sweep blocks of the indicated object size and kind until either the * appropriate free list is nonempty, or there are no more blocks to * sweep. */ GC_INNER void GC_continue_reclaim(size_t sz /* granules */, int kind) { hdr * hhdr; struct hblk * hbp; struct obj_kind * ok = &(GC_obj_kinds[kind]); struct hblk ** rlh = ok -> ok_reclaim_list; void **flh = &(ok -> ok_freelist[sz]); if (rlh == 0) return; /* No blocks of this kind. */ rlh += sz; while ((hbp = *rlh) != 0) { hhdr = HDR(hbp); *rlh = hhdr -> hb_next; GC_reclaim_small_nonempty_block(hbp, FALSE); if (*flh != 0) break; } } /* * Reclaim all small blocks waiting to be reclaimed. * Abort and return FALSE when/if (*stop_func)() returns TRUE. * If this returns TRUE, then it's safe to restart the world * with incorrectly cleared mark bits. * If ignore_old is TRUE, then reclaim only blocks that have been * recently reclaimed, and discard the rest. * Stop_func may be 0. */ GC_INNER GC_bool GC_reclaim_all(GC_stop_func stop_func, GC_bool ignore_old) { word sz; unsigned kind; hdr * hhdr; struct hblk * hbp; struct obj_kind * ok; struct hblk ** rlp; struct hblk ** rlh; # ifndef SMALL_CONFIG CLOCK_TYPE start_time = 0; /* initialized to prevent warning. */ CLOCK_TYPE done_time; if (GC_print_stats == VERBOSE) GET_TIME(start_time); # endif for (kind = 0; kind < GC_n_kinds; kind++) { ok = &(GC_obj_kinds[kind]); rlp = ok -> ok_reclaim_list; if (rlp == 0) continue; for (sz = 1; sz <= MAXOBJGRANULES; sz++) { rlh = rlp + sz; while ((hbp = *rlh) != 0) { if (stop_func != (GC_stop_func)0 && (*stop_func)()) { return(FALSE); } hhdr = HDR(hbp); *rlh = hhdr -> hb_next; if (!ignore_old || hhdr -> hb_last_reclaimed == GC_gc_no - 1) { /* It's likely we'll need it this time, too */ /* It's been touched recently, so this */ /* shouldn't trigger paging. */ GC_reclaim_small_nonempty_block(hbp, FALSE); } } } } # ifndef SMALL_CONFIG if (GC_print_stats == VERBOSE) { GET_TIME(done_time); GC_verbose_log_printf("Disposing of reclaim lists took %lu msecs\n", MS_TIME_DIFF(done_time,start_time)); } # endif return(TRUE); } #if !defined(EAGER_SWEEP) && defined(ENABLE_DISCLAIM) /* We do an eager sweep on heap blocks where unconditional marking has */ /* been enabled, so that any reclaimable objects have been reclaimed */ /* before we start marking. This is a simplified GC_reclaim_all */ /* restricted to kinds where ok_mark_unconditionally is true. */ STATIC void GC_reclaim_unconditionally_marked(void) { word sz; unsigned kind; hdr * hhdr; struct hblk * hbp; struct obj_kind * ok; struct hblk ** rlp; struct hblk ** rlh; for (kind = 0; kind < GC_n_kinds; kind++) { ok = &(GC_obj_kinds[kind]); if (!ok->ok_mark_unconditionally) continue; rlp = ok->ok_reclaim_list; if (rlp == 0) continue; for (sz = 1; sz <= MAXOBJGRANULES; sz++) { rlh = rlp + sz; while ((hbp = *rlh) != 0) { hhdr = HDR(hbp); *rlh = hhdr->hb_next; GC_reclaim_small_nonempty_block(hbp, FALSE); } } } } #endif /* !EAGER_SWEEP && ENABLE_DISCLAIM */ ecl-16.1.2/src/bdwgc/sparc_mach_dep.S000066400000000000000000000036021266352375300173120ustar00rootroot00000000000000! SPARCompiler 3.0 and later apparently no longer handles ! asm outside functions. So we need a separate .s file ! This is only set up for SunOS 5, not SunOS 4. ! Assumes this is called before the stack contents are ! examined. .seg "text" .globl GC_save_regs_in_stack GC_save_regs_in_stack: #if defined(__arch64__) || defined(__sparcv9) save %sp,-128,%sp flushw ret restore %sp,2047+128,%o0 #else /* 32 bit SPARC */ ta 0x3 ! ST_FLUSH_WINDOWS mov %sp,%o0 retl nop #endif /* 32 bit SPARC */ .GC_save_regs_in_stack_end: .size GC_save_regs_in_stack,.GC_save_regs_in_stack_end-GC_save_regs_in_stack ! GC_clear_stack_inner(arg, limit) clears stack area up to limit and ! returns arg. Stack clearing is crucial on SPARC, so we supply ! an assembly version that s more careful. Assumes limit is hotter ! than sp, and limit is 8 byte aligned. .globl GC_clear_stack_inner GC_clear_stack_inner: #if defined(__arch64__) || defined(__sparcv9) mov %sp,%o2 ! Save sp add %sp,2047-8,%o3 ! p = sp+bias-8 add %o1,-2047-192,%sp ! Move sp out of the way, ! so that traps still work. ! Includes some extra words ! so we can be sloppy below. loop: stx %g0,[%o3] ! *(long *)p = 0 cmp %o3,%o1 bgu,pt %xcc, loop ! if (p > limit) goto loop add %o3,-8,%o3 ! p -= 8 (delay slot) retl mov %o2,%sp ! Restore sp., delay slot #else /* 32 bit SPARC */ mov %sp,%o2 ! Save sp add %sp,-8,%o3 ! p = sp-8 clr %g1 ! [g0,g1] = 0 add %o1,-0x60,%sp ! Move sp out of the way, ! so that traps still work. ! Includes some extra words ! so we can be sloppy below. loop: std %g0,[%o3] ! *(long long *)p = 0 cmp %o3,%o1 bgu loop ! if (p > limit) goto loop add %o3,-8,%o3 ! p -= 8 (delay slot) retl mov %o2,%sp ! Restore sp., delay slot #endif /* 32 bit SPARC */ .GC_clear_stack_inner_end: .size GC_clear_stack_inner,.GC_clear_stack_inner_end-GC_clear_stack_inner ecl-16.1.2/src/bdwgc/sparc_netbsd_mach_dep.s000066400000000000000000000016121266352375300207100ustar00rootroot00000000000000! SPARCompiler 3.0 and later apparently no longer handles ! asm outside functions. So we need a separate .s file ! This is only set up for SunOS 4. ! Assumes this is called before the stack contents are ! examined. #include "machine/asm.h" .seg "text" .globl _C_LABEL(GC_save_regs_in_stack) .globl _C_LABEL(GC_push_regs) _C_LABEL(GC_save_regs_in_stack): _C_LABEL(GC_push_regs): ta 0x3 ! ST_FLUSH_WINDOWS mov %sp,%o0 retl nop .globl _C_LABEL(GC_clear_stack_inner) _C_LABEL(GC_clear_stack_inner): mov %sp,%o2 ! Save sp add %sp,-8,%o3 ! p = sp-8 clr %g1 ! [g0,g1] = 0 add %o1,-0x60,%sp ! Move sp out of the way, ! so that traps still work. ! Includes some extra words ! so we can be sloppy below. loop: std %g0,[%o3] ! *(long long *)p = 0 cmp %o3,%o1 bgu loop ! if (p > limit) goto loop add %o3,-8,%o3 ! p -= 8 (delay slot) retl mov %o2,%sp ! Restore sp., delay slot ecl-16.1.2/src/bdwgc/sparc_sunos4_mach_dep.s000066400000000000000000000014761266352375300206740ustar00rootroot00000000000000! SPARCompiler 3.0 and later apparently no longer handles ! asm outside functions. So we need a separate .s file ! This is only set up for SunOS 4. ! Assumes this is called before the stack contents are ! examined. .seg "text" .globl _GC_save_regs_in_stack .globl _GC_push_regs _GC_save_regs_in_stack: _GC_push_regs: ta 0x3 ! ST_FLUSH_WINDOWS mov %sp,%o0 retl nop .globl _GC_clear_stack_inner _GC_clear_stack_inner: mov %sp,%o2 ! Save sp add %sp,-8,%o3 ! p = sp-8 clr %g1 ! [g0,g1] = 0 add %o1,-0x60,%sp ! Move sp out of the way, ! so that traps still work. ! Includes some extra words ! so we can be sloppy below. loop: std %g0,[%o3] ! *(long long *)p = 0 cmp %o3,%o1 bgu loop ! if (p > limit) goto loop add %o3,-8,%o3 ! p -= 8 (delay slot) retl mov %o2,%sp ! Restore sp., delay slot ecl-16.1.2/src/bdwgc/specific.c000066400000000000000000000141451266352375300161730ustar00rootroot00000000000000/* * Copyright (c) 2000 by Hewlett-Packard Company. All rights reserved. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. */ #include "private/thread_local_alloc.h" /* To determine type of tsd impl. */ /* Includes private/specific.h */ /* if needed. */ #if defined(USE_CUSTOM_SPECIFIC) static const tse invalid_tse = {INVALID_QTID, 0, 0, INVALID_THREADID}; /* A thread-specific data entry which will never */ /* appear valid to a reader. Used to fill in empty */ /* cache entries to avoid a check for 0. */ GC_INNER int GC_key_create_inner(tsd ** key_ptr) { int i; int ret; tsd * result = (tsd *)MALLOC_CLEAR(sizeof(tsd)); /* A quick alignment check, since we need atomic stores */ GC_ASSERT((word)(&invalid_tse.next) % sizeof(tse *) == 0); if (0 == result) return ENOMEM; ret = pthread_mutex_init(&result->lock, NULL); if (ret != 0) return ret; for (i = 0; i < TS_CACHE_SIZE; ++i) { result -> cache[i] = (/* no const */ tse *)&invalid_tse; } # ifdef GC_ASSERTIONS for (i = 0; i < TS_HASH_SIZE; ++i) { GC_ASSERT(result -> hash[i].p == 0); } # endif *key_ptr = result; return 0; } /* Called with the lock held. */ GC_INNER int GC_setspecific(tsd * key, void * value) { pthread_t self = pthread_self(); int hash_val = HASH(self); volatile tse * entry; GC_ASSERT(self != INVALID_THREADID); GC_dont_gc++; /* disable GC */ entry = (volatile tse *)MALLOC_CLEAR(sizeof(tse)); GC_dont_gc--; if (0 == entry) return ENOMEM; pthread_mutex_lock(&(key -> lock)); /* Could easily check for an existing entry here. */ entry -> next = key->hash[hash_val].p; entry -> thread = self; entry -> value = value; GC_ASSERT(entry -> qtid == INVALID_QTID); /* There can only be one writer at a time, but this needs to be */ /* atomic with respect to concurrent readers. */ AO_store_release(&key->hash[hash_val].ao, (AO_t)entry); pthread_mutex_unlock(&(key -> lock)); return 0; } /* Remove thread-specific data for this thread. Should be called on */ /* thread exit. */ GC_INNER void GC_remove_specific(tsd * key) { pthread_t self = pthread_self(); unsigned hash_val = HASH(self); tse *entry; tse **link = &key->hash[hash_val].p; pthread_mutex_lock(&(key -> lock)); entry = *link; while (entry != NULL && entry -> thread != self) { link = &(entry -> next); entry = *link; } /* Invalidate qtid field, since qtids may be reused, and a later */ /* cache lookup could otherwise find this entry. */ if (entry != NULL) { entry -> qtid = INVALID_QTID; *link = entry -> next; /* Atomic! concurrent accesses still work. */ /* They must, since readers don't lock. */ /* We shouldn't need a volatile access here, */ /* since both this and the preceding write */ /* should become visible no later than */ /* the pthread_mutex_unlock() call. */ } /* If we wanted to deallocate the entry, we'd first have to clear */ /* any cache entries pointing to it. That probably requires */ /* additional synchronization, since we can't prevent a concurrent */ /* cache lookup, which should still be examining deallocated memory.*/ /* This can only happen if the concurrent access is from another */ /* thread, and hence has missed the cache, but still... */ /* With GC, we're done, since the pointers from the cache will */ /* be overwritten, all local pointers to the entries will be */ /* dropped, and the entry will then be reclaimed. */ pthread_mutex_unlock(&(key -> lock)); } /* Note that even the slow path doesn't lock. */ GC_INNER void * GC_slow_getspecific(tsd * key, word qtid, tse * volatile * cache_ptr) { pthread_t self = pthread_self(); unsigned hash_val = HASH(self); tse *entry = key->hash[hash_val].p; GC_ASSERT(qtid != INVALID_QTID); while (entry != NULL && entry -> thread != self) { entry = entry -> next; } if (entry == NULL) return NULL; /* Set cache_entry. */ entry -> qtid = (AO_t)qtid; /* It's safe to do this asynchronously. Either value */ /* is safe, though may produce spurious misses. */ /* We're replacing one qtid with another one for the */ /* same thread. */ *cache_ptr = entry; /* Again this is safe since pointer assignments are */ /* presumed atomic, and either pointer is valid. */ return entry -> value; } #ifdef GC_ASSERTIONS /* Check that that all elements of the data structure associated */ /* with key are marked. */ void GC_check_tsd_marks(tsd *key) { int i; tse *p; if (!GC_is_marked(GC_base(key))) { ABORT("Unmarked thread-specific-data table"); } for (i = 0; i < TS_HASH_SIZE; ++i) { for (p = key->hash[i].p; p != 0; p = p -> next) { if (!GC_is_marked(GC_base(p))) { ABORT_ARG1("Unmarked thread-specific-data entry", " at %p", p); } } } for (i = 0; i < TS_CACHE_SIZE; ++i) { p = key -> cache[i]; if (p != &invalid_tse && !GC_is_marked(GC_base(p))) { ABORT_ARG1("Unmarked cached thread-specific-data entry", " at %p", p); } } } #endif /* GC_ASSERTIONS */ #endif /* USE_CUSTOM_SPECIFIC */ ecl-16.1.2/src/bdwgc/stubborn.c000066400000000000000000000031721266352375300162420ustar00rootroot00000000000000/* * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. */ #include "private/gc_priv.h" #if defined(MANUAL_VDB) /* Stubborn object (hard to change, nearly immutable) allocation. */ /* This interface is deprecated. We mostly emulate it using */ /* MANUAL_VDB. But that imposes the additional constraint that */ /* written, but not yet GC_dirty()ed objects must be referenced */ /* by a stack. */ void GC_dirty(ptr_t p); GC_API GC_ATTR_MALLOC void * GC_CALL GC_malloc_stubborn(size_t lb) { return(GC_malloc(lb)); } GC_API void GC_CALL GC_end_stubborn_change(const void *p) { GC_dirty((ptr_t)p); } GC_API void GC_CALL GC_change_stubborn(const void *p GC_ATTR_UNUSED) { } #else /* !MANUAL_VDB */ GC_API GC_ATTR_MALLOC void * GC_CALL GC_malloc_stubborn(size_t lb) { return(GC_malloc(lb)); } GC_API void GC_CALL GC_end_stubborn_change(const void *p GC_ATTR_UNUSED) { } GC_API void GC_CALL GC_change_stubborn(const void *p GC_ATTR_UNUSED) { } #endif /* !MANUAL_VDB */ ecl-16.1.2/src/bdwgc/test-driver000077500000000000000000000110401266352375300164270ustar00rootroot00000000000000#! /bin/sh # test-driver - basic testsuite driver script. scriptversion=2013-07-13.22; # UTC # Copyright (C) 2011-2014 Free Software Foundation, Inc. # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2, or (at your option) # any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . # As a special exception to the GNU General Public License, if you # distribute this file as part of a program that contains a # configuration script generated by Autoconf, you may include it under # the same distribution terms that you use for the rest of that program. # This file is maintained in Automake, please report # bugs to or send patches to # . # Make unconditional expansion of undefined variables an error. This # helps a lot in preventing typo-related bugs. set -u usage_error () { echo "$0: $*" >&2 print_usage >&2 exit 2 } print_usage () { cat <$log_file 2>&1 estatus=$? if test $enable_hard_errors = no && test $estatus -eq 99; then tweaked_estatus=1 else tweaked_estatus=$estatus fi case $tweaked_estatus:$expect_failure in 0:yes) col=$red res=XPASS recheck=yes gcopy=yes;; 0:*) col=$grn res=PASS recheck=no gcopy=no;; 77:*) col=$blu res=SKIP recheck=no gcopy=yes;; 99:*) col=$mgn res=ERROR recheck=yes gcopy=yes;; *:yes) col=$lgn res=XFAIL recheck=no gcopy=yes;; *:*) col=$red res=FAIL recheck=yes gcopy=yes;; esac # Report the test outcome and exit status in the logs, so that one can # know whether the test passed or failed simply by looking at the '.log' # file, without the need of also peaking into the corresponding '.trs' # file (automake bug#11814). echo "$res $test_name (exit status: $estatus)" >>$log_file # Report outcome to console. echo "${col}${res}${std}: $test_name" # Register the test result, and other relevant metadata. echo ":test-result: $res" > $trs_file echo ":global-test-result: $res" >> $trs_file echo ":recheck: $recheck" >> $trs_file echo ":copy-in-global-log: $gcopy" >> $trs_file # Local Variables: # mode: shell-script # sh-indentation: 2 # eval: (add-hook 'write-file-hooks 'time-stamp) # time-stamp-start: "scriptversion=" # time-stamp-format: "%:y-%02m-%02d.%02H" # time-stamp-time-zone: "UTC" # time-stamp-end: "; # UTC" # End: ecl-16.1.2/src/bdwgc/tests/000077500000000000000000000000001266352375300153775ustar00rootroot00000000000000ecl-16.1.2/src/bdwgc/tests/CMakeLists.txt000066400000000000000000000015111266352375300201350ustar00rootroot00000000000000# # Copyright (c) 1994 by Xerox Corporation. All rights reserved. # Copyright (c) 1996 by Silicon Graphics. All rights reserved. # Copyright (c) 1998 by Fergus Henderson. All rights reserved. # Copyright (c) 2000-2010 by Hewlett-Packard Company. All rights reserved. ## # THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED # OR IMPLIED. ANY USE IS AT YOUR OWN RISK. ## # Permission is hereby granted to use or copy this program # for any purpose, provided the above notices are retained on all copies. # Permission to modify the code and to distribute modified code is granted, # provided the above notices are retained, and a notice that the code was # modified is included with the above copyright notice. ## ADD_DEFINITIONS(-DGC_NOT_DLL) ADD_EXECUTABLE(gctest WIN32 test.c) TARGET_LINK_LIBRARIES(gctest gc-lib) ecl-16.1.2/src/bdwgc/tests/disclaim_bench.c000066400000000000000000000071401266352375300204710ustar00rootroot00000000000000/* * Copyright (c) 2011 by Hewlett-Packard Company. All rights reserved. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. * */ #include #include #include #include "private/gc_priv.h" #include "gc_disclaim.h" #define my_assert(e) \ if (!(e)) { \ fprintf(stderr, "Assertion failure, line %d: " #e "\n", __LINE__); \ exit(-1); \ } static int free_count = 0; struct testobj_s { struct testobj_s *keep_link; int i; }; typedef struct testobj_s *testobj_t; void GC_CALLBACK testobj_finalize(void *obj, void *carg) { ++*(int *)carg; my_assert(((testobj_t)obj)->i == 109); ((testobj_t)obj)->i = 110; } static const struct GC_finalizer_closure fclos = { testobj_finalize, &free_count }; testobj_t testobj_new(int model) { testobj_t obj; switch (model) { case 0: obj = GC_MALLOC(sizeof(struct testobj_s)); if (obj != NULL) GC_register_finalizer_no_order(obj, testobj_finalize, &free_count, NULL, NULL); break; case 1: obj = GC_finalized_malloc(sizeof(struct testobj_s), &fclos); break; case 2: obj = GC_MALLOC(sizeof(struct testobj_s)); break; default: exit(-1); } if (obj == NULL) { fprintf(stderr, "Out of memory!\n"); exit(3); } my_assert(obj->i == 0 && obj->keep_link == NULL); obj->i = 109; return obj; } #define ALLOC_CNT (4*1024*1024) #define KEEP_CNT (32*1024) static char const *model_str[3] = { "regular finalization", "finalize on reclaim", "no finalization" }; int main(int argc, char **argv) { int i; int model, model_min, model_max; testobj_t *keep_arr; GC_INIT(); GC_init_finalized_malloc(); keep_arr = GC_MALLOC(sizeof(void *)*KEEP_CNT); if (argc == 2 && strcmp(argv[1], "--help") == 0) { fprintf(stderr, "Usage: %s [FINALIZATION_MODEL]\n" "\t0 -- original finalization\n" "\t1 -- finalization on reclaim\n" "\t2 -- no finalization\n", argv[0]); return 1; } if (argc == 2) { model_min = model_max = atoi(argv[1]); if (model_min < 0 || model_max > 2) exit(2); } else { model_min = 0; model_max = 2; } printf("\t\t\tfin. ratio time/s time/fin.\n"); for (model = model_min; model <= model_max; ++model) { double t = 0.0; free_count = 0; # ifdef CLOCK_TYPE CLOCK_TYPE tI, tF; GET_TIME(tI); # endif for (i = 0; i < ALLOC_CNT; ++i) { int k = rand() % KEEP_CNT; keep_arr[k] = testobj_new(model); } GC_gcollect(); # ifdef CLOCK_TYPE GET_TIME(tF); t = MS_TIME_DIFF(tF, tI)*1e-3; # endif if (model < 2) printf("%20s: %12.4lf %12lg %12lg\n", model_str[model], free_count/(double)ALLOC_CNT, t, t/free_count); else printf("%20s: %12.4lf %12lg %12s\n", model_str[model], 0.0, t, "N/A"); } return 0; } ecl-16.1.2/src/bdwgc/tests/disclaim_test.c000066400000000000000000000132661266352375300203770ustar00rootroot00000000000000/* * Copyright (c) 2011 by Hewlett-Packard Company. All rights reserved. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. * */ /* Test that objects reachable from an object allocated with */ /* GC_malloc_with_finalizer is not reclaimable before the finalizer */ /* is called. */ #include #include #include #ifdef HAVE_CONFIG_H /* For GC_[P]THREADS */ # include "config.h" #endif #include "gc_disclaim.h" #define my_assert(e) \ if (!(e)) { \ fflush(stdout); \ fprintf(stderr, "Assertion failure, line %d: " #e "\n", __LINE__); \ exit(-1); \ } int memeq(void *s, int c, size_t len) { while (len--) { if (*(char *)s != c) return 0; s = (char *)s + 1; } return 1; } void GC_CALLBACK misc_sizes_dct(void *obj, void *cd) { unsigned log_size = *(unsigned char *)obj; size_t size; my_assert(log_size < sizeof(size_t) * 8); my_assert(cd == NULL); size = (size_t)1 << log_size; my_assert(memeq((char *)obj + 1, 0x56, size - 1)); } void test_misc_sizes(void) { static const struct GC_finalizer_closure fc = { misc_sizes_dct, NULL }; int i; for (i = 1; i <= 20; ++i) { /* Up to 1 MiB. */ void *p = GC_finalized_malloc((size_t)1 << i, &fc); if (p == NULL) { fprintf(stderr, "Out of memory!\n"); exit(3); } my_assert(memeq(p, 0, (size_t)1 << i)); memset(p, 0x56, (size_t)1 << i); *(unsigned char *)p = i; } } typedef struct pair_s *pair_t; struct pair_s { char magic[16]; int checksum; pair_t car; pair_t cdr; }; static const char *pair_magic = "PAIR_MAGIC_BYTES"; int is_pair(pair_t p) { return memcmp(p->magic, pair_magic, sizeof(p->magic)) == 0; } void GC_CALLBACK pair_dct(void *obj, void *cd) { pair_t p = obj; int checksum; /* Check that obj and its car and cdr are not trashed. */ # ifdef DEBUG_DISCLAIM_DESTRUCT printf("Destruct %p = (%p, %p)\n", (void *)p, (void *)p->car, (void *)p->cdr); # endif my_assert(GC_base(obj)); my_assert(is_pair(p)); my_assert(!p->car || is_pair(p->car)); my_assert(!p->cdr || is_pair(p->cdr)); checksum = 782; if (p->car) checksum += p->car->checksum; if (p->cdr) checksum += p->cdr->checksum; my_assert(p->checksum == checksum); /* Invalidate it. */ memset(p->magic, '*', sizeof(p->magic)); p->checksum = 0; p->car = cd; p->cdr = NULL; } pair_t pair_new(pair_t car, pair_t cdr) { pair_t p; static const struct GC_finalizer_closure fc = { pair_dct, NULL }; p = GC_finalized_malloc(sizeof(struct pair_s), &fc); my_assert(!is_pair(p)); if (p == NULL) { fprintf(stderr, "Out of memory!\n"); exit(3); } my_assert(memeq(p, 0, sizeof(struct pair_s))); memcpy(p->magic, pair_magic, sizeof(p->magic)); p->checksum = 782 + (car? car->checksum : 0) + (cdr? cdr->checksum : 0); p->car = car; p->cdr = cdr; # ifdef DEBUG_DISCLAIM_DESTRUCT printf("Construct %p = (%p, %p)\n", (void *)p, (void *)p->car, (void *)p->cdr); # endif return p; } void pair_check_rec(pair_t p) { while (p) { int checksum = 782; if (p->car) checksum += p->car->checksum; if (p->cdr) checksum += p->cdr->checksum; my_assert(p->checksum == checksum); if (rand() % 2) p = p->car; else p = p->cdr; } } #ifdef GC_PTHREADS # define THREAD_CNT 6 # include #else # define THREAD_CNT 1 #endif #define POP_SIZE 1000 #if THREAD_CNT > 1 # define MUTATE_CNT 2000000/THREAD_CNT #else # define MUTATE_CNT 10000000 #endif #define GROW_LIMIT 10000000 void *test(void *data) { int i; pair_t pop[POP_SIZE]; memset(pop, 0, sizeof(pop)); for (i = 0; i < MUTATE_CNT; ++i) { int t = rand() % POP_SIZE; switch (rand() % (i > GROW_LIMIT? 5 : 3)) { case 0: case 3: if (pop[t]) pop[t] = pop[t]->car; break; case 1: case 4: if (pop[t]) pop[t] = pop[t]->cdr; break; case 2: pop[t] = pair_new(pop[rand() % POP_SIZE], pop[rand() % POP_SIZE]); break; } if (rand() % 8 == 1) pair_check_rec(pop[rand() % POP_SIZE]); } return data; } int main(void) { #if THREAD_CNT > 1 pthread_t th[THREAD_CNT]; int i; #endif GC_set_all_interior_pointers(0); /* for a stricter test */ GC_INIT(); GC_init_finalized_malloc(); test_misc_sizes(); #if THREAD_CNT > 1 printf("Threaded disclaim test.\n"); for (i = 0; i < THREAD_CNT; ++i) { int err = pthread_create(&th[i], NULL, test, NULL); if (err) { fprintf(stderr, "Failed to create thread # %d: %s\n", i, strerror(err)); exit(1); } } for (i = 0; i < THREAD_CNT; ++i) { int err = pthread_join(th[i], NULL); if (err) { fprintf(stderr, "Failed to join thread # %d: %s\n", i, strerror(err)); exit(69); } } #else printf("Unthreaded disclaim test.\n"); test(NULL); #endif return 0; } ecl-16.1.2/src/bdwgc/tests/huge_test.c000066400000000000000000000030651266352375300175360ustar00rootroot00000000000000 #include #include #include #ifndef GC_IGNORE_WARN /* Ignore misleading "Out of Memory!" warning (which is printed on */ /* every GC_MALLOC(LONG_MAX) call) by defining this macro before */ /* "gc.h" inclusion. */ # define GC_IGNORE_WARN #endif #include "gc.h" /* * Check that very large allocation requests fail. "Success" would usually * indicate that the size was somehow converted to a negative * number. Clients shouldn't do this, but we should fail in the * expected manner. */ int main(void) { GC_INIT(); GC_set_max_heap_size(100*1024*1024); /* Otherwise heap expansion aborts when deallocating large block. */ /* That's OK. We test this corner case mostly to make sure that */ /* it fails predictably. */ GC_expand_hp(1024*1024*5); if (sizeof(long) == sizeof(void *)) { void *r = GC_MALLOC(LONG_MAX-1024); if (0 != r) { fprintf(stderr, "Size LONG_MAX-1024 allocation unexpectedly succeeded\n"); exit(1); } r = GC_MALLOC(LONG_MAX); if (0 != r) { fprintf(stderr, "Size LONG_MAX allocation unexpectedly succeeded\n"); exit(1); } r = GC_MALLOC((size_t)LONG_MAX + 1024); if (0 != r) { fprintf(stderr, "Size LONG_MAX+1024 allocation unexpectedly succeeded\n"); exit(1); } } return 0; } ecl-16.1.2/src/bdwgc/tests/initsecondarythread.c000066400000000000000000000050141266352375300216060ustar00rootroot00000000000000/* * Copyright (C) 2011 Ludovic Courtes * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. */ /* Make sure 'GC_INIT' can be called from threads other than the initial * thread. */ #ifdef HAVE_CONFIG_H # include "config.h" #endif #ifndef GC_THREADS # define GC_THREADS #endif #define GC_NO_THREAD_REDIRECTS 1 /* Do not redirect thread creation and join calls. */ #include "gc.h" #ifdef GC_PTHREADS # include #else # include #endif #include #include #ifdef GC_PTHREADS static void *thread(void *arg) #else static DWORD WINAPI thread(LPVOID arg) #endif { GC_INIT(); (void)GC_MALLOC(123); (void)GC_MALLOC(12345); # ifdef GC_PTHREADS return arg; # else return (DWORD)(GC_word)arg; # endif } #include "private/gcconfig.h" int main(void) { # ifdef GC_PTHREADS int code; pthread_t t; # else HANDLE t; DWORD thread_id; # endif # if !(defined(BEOS) || defined(MSWIN32) || defined(MSWINCE) \ || defined(CYGWIN32) || defined(GC_OPENBSD_UTHREADS) \ || (defined(DARWIN) && !defined(NO_PTHREAD_GET_STACKADDR_NP)) \ || (defined(LINUX) && !defined(NACL)) \ || (defined(GC_SOLARIS_THREADS) && !defined(_STRICT_STDC)) \ || (!defined(STACKBOTTOM) && (defined(HEURISTIC1) \ || (!defined(LINUX_STACKBOTTOM) && !defined(FREEBSD_STACKBOTTOM))))) /* GC_INIT() must be called from main thread only. */ GC_INIT(); # endif # ifdef GC_PTHREADS if ((code = pthread_create (&t, NULL, thread, NULL)) != 0) { fprintf(stderr, "Thread creation failed %d\n", code); return 1; } if ((code = pthread_join (t, NULL)) != 0) { fprintf(stderr, "Thread join failed %d\n", code); return 1; } # else t = CreateThread(NULL, 0, thread, 0, 0, &thread_id); if (t == NULL) { fprintf(stderr, "Thread creation failed %d\n", (int)GetLastError()); return 1; } if (WaitForSingleObject(t, INFINITE) != WAIT_OBJECT_0) { fprintf(stderr, "Thread join failed %d\n", (int)GetLastError()); CloseHandle(t); return 1; } CloseHandle(t); # endif return 0; } ecl-16.1.2/src/bdwgc/tests/leak_test.c000066400000000000000000000012371266352375300175210ustar00rootroot00000000000000#include "leak_detector.h" int main(void) { int *p[10]; int i; GC_set_find_leak(1); /* for new collect versions not compiled */ /* with -DFIND_LEAK. */ GC_INIT(); /* Needed if thread-local allocation is enabled. */ /* FIXME: This is not ideal. */ for (i = 0; i < 10; ++i) { p[i] = malloc(sizeof(int)+i); } CHECK_LEAKS(); for (i = 1; i < 10; ++i) { free(p[i]); } for (i = 0; i < 9; ++i) { p[i] = malloc(sizeof(int)+i); } CHECK_LEAKS(); CHECK_LEAKS(); CHECK_LEAKS(); return 0; } ecl-16.1.2/src/bdwgc/tests/middle.c000066400000000000000000000007701266352375300170050ustar00rootroot00000000000000/* * Test at the boundary between small and large objects. * Inspired by a test case from Zoltan Varga. */ #include "gc.h" #include int main (void) { int i; GC_set_all_interior_pointers(0); GC_INIT(); for (i = 0; i < 20000; ++i) { (void)GC_malloc_atomic(4096); (void)GC_malloc(4096); } for (i = 0; i < 20000; ++i) { (void)GC_malloc_atomic(2048); (void)GC_malloc(2048); } printf("Final heap size is %lu\n", (unsigned long)GC_get_heap_size()); return 0; } ecl-16.1.2/src/bdwgc/tests/realloc_test.c000066400000000000000000000012471266352375300202270ustar00rootroot00000000000000 #include #include #include "gc.h" #define COUNT 10000000 int main(void) { int i; unsigned long last_heap_size = 0; GC_INIT(); for (i = 0; i < COUNT; i++) { int **p = GC_MALLOC(sizeof(int *)); int *q = GC_MALLOC_ATOMIC(sizeof(int)); if (p == 0 || *p != 0) { fprintf(stderr, "GC_malloc returned garbage (or NULL)\n"); exit(1); } *p = GC_REALLOC(q, 2 * sizeof(int)); if (i % 10 == 0) { unsigned long heap_size = (unsigned long)GC_get_heap_size(); if (heap_size != last_heap_size) { printf("Heap size: %lu\n", heap_size); last_heap_size = heap_size; } } } return 0; } ecl-16.1.2/src/bdwgc/tests/smash_test.c000066400000000000000000000006211266352375300177140ustar00rootroot00000000000000/* * Test that overwrite error detection works reasonably. */ #define GC_DEBUG #include "gc.h" #include #define COUNT 7000 #define SIZE 40 char * A[COUNT]; int main(void) { int i; char *p; GC_INIT(); for (i = 0; i < COUNT; ++i) { A[i] = p = GC_MALLOC(SIZE); if (i%3000 == 0) GC_gcollect(); if (i%5678 == 0 && p != 0) p[SIZE + i/2000] = 42; } return 0; } ecl-16.1.2/src/bdwgc/tests/staticrootslib.c000066400000000000000000000024501266352375300206110ustar00rootroot00000000000000 /* This test file is intended to be compiled into a DLL. */ #ifndef GC_DEBUG # define GC_DEBUG #endif #include "gc.h" #ifndef GC_TEST_EXPORT_API # if defined(GC_VISIBILITY_HIDDEN_SET) \ && !defined(__CEGCC__) && !defined(__CYGWIN__) && !defined(__MINGW32__) # define GC_TEST_EXPORT_API \ extern __attribute__((__visibility__("default"))) # else # define GC_TEST_EXPORT_API extern # endif #endif struct treenode { struct treenode *x; struct treenode *y; }; static struct treenode *root[10] = { 0 }; static struct treenode *root_nz[10] = { (void *)(GC_word)2 }; #ifdef STATICROOTSLIB2 # define libsrl_getpelem libsrl_getpelem2 #else GC_TEST_EXPORT_API struct treenode * libsrl_mktree(int i) { struct treenode * r = GC_MALLOC(sizeof(struct treenode)); if (0 == i) return 0; if (1 == i) r = GC_MALLOC_ATOMIC(sizeof(struct treenode)); if (r) { r -> x = libsrl_mktree(i-1); r -> y = libsrl_mktree(i-1); } return r; } GC_TEST_EXPORT_API void * libsrl_init(void) { # ifndef STATICROOTSLIB_INIT_IN_MAIN GC_INIT(); # endif return GC_MALLOC(sizeof(struct treenode)); } #endif /* !STATICROOTSLIB2 */ GC_TEST_EXPORT_API struct treenode ** libsrl_getpelem(int i, int j) { return &((j & 1) != 0 ? root_nz : root)[i]; } ecl-16.1.2/src/bdwgc/tests/staticrootstest.c000066400000000000000000000032041266352375300210200ustar00rootroot00000000000000 #include #include #ifndef GC_DEBUG # define GC_DEBUG #endif #include "gc.h" #include "gc_backptr.h" #ifndef GC_TEST_IMPORT_API # define GC_TEST_IMPORT_API extern #endif /* Should match that in staticrootslib.c. */ struct treenode { struct treenode *x; struct treenode *y; }; struct treenode *root[10] = { NULL }; /* Same as "root" variable but initialized to some non-zero value (to */ /* be placed to .data section instead of .bss). */ struct treenode *root_nz[10] = { (void *)(GC_word)1 }; static char *staticroot = 0; GC_TEST_IMPORT_API struct treenode * libsrl_mktree(int i); GC_TEST_IMPORT_API void * libsrl_init(void); GC_TEST_IMPORT_API struct treenode ** libsrl_getpelem(int i, int j); GC_TEST_IMPORT_API struct treenode ** libsrl_getpelem2(int i, int j); int main(void) { int i, j; # ifdef STATICROOTSLIB_INIT_IN_MAIN GC_INIT(); # endif staticroot = libsrl_init(); if (NULL == staticroot) { fprintf(stderr, "GC_malloc returned NULL\n"); return 2; } memset(staticroot, 0x42, sizeof(struct treenode)); GC_gcollect(); for (j = 0; j < 4; j++) { for (i = 0; i < (int)(sizeof(root) / sizeof(root[0])); ++i) { # ifdef STATICROOTSLIB2 *libsrl_getpelem2(i, j) = libsrl_mktree(12); # endif *libsrl_getpelem(i, j) = libsrl_mktree(12); ((j & 1) != 0 ? root_nz : root)[i] = libsrl_mktree(12); GC_gcollect(); } for (i = 0; i < (int)sizeof(struct treenode); ++i) { if (staticroot[i] != 0x42) { fprintf(stderr, "Memory check failed\n"); return -1; } } } return 0; } ecl-16.1.2/src/bdwgc/tests/subthread_create.c000066400000000000000000000064411266352375300210540ustar00rootroot00000000000000 #ifdef HAVE_CONFIG_H /* For PARALLEL_MARK */ # include "config.h" #endif #ifndef GC_THREADS # define GC_THREADS #endif #include "gc.h" #ifdef PARALLEL_MARK # define AO_REQUIRE_CAS #endif #include "atomic_ops.h" #include #ifdef AO_HAVE_fetch_and_add #ifdef GC_PTHREADS # include #else # include #endif #include #include #ifndef MAX_SUBTHREAD_DEPTH # define INITIAL_THREAD_COUNT 31 # define MAX_ALIVE_THREAD_COUNT 55 # define MAX_SUBTHREAD_DEPTH 7 # define MAX_SUBTHREAD_COUNT 200 #endif #ifndef DECAY_NUMER # define DECAY_NUMER 15 # define DECAY_DENOM 16 #endif volatile AO_t thread_created_cnt = 0; volatile AO_t thread_ended_cnt = 0; #ifdef GC_PTHREADS void *entry(void *arg) #else DWORD WINAPI entry(LPVOID arg) #endif { int thread_num = AO_fetch_and_add(&thread_created_cnt, 1); GC_word my_depth = (GC_word)arg + 1; if (my_depth <= MAX_SUBTHREAD_DEPTH && thread_num < MAX_SUBTHREAD_COUNT && (thread_num % DECAY_DENOM) < DECAY_NUMER && (int)(thread_num - AO_load(&thread_ended_cnt)) <= MAX_ALIVE_THREAD_COUNT) { # ifdef GC_PTHREADS int err; pthread_t th; err = pthread_create(&th, NULL, entry, (void *)my_depth); if (err) { fprintf(stderr, "Thread #%d creation failed: %s", thread_num, strerror(err)); exit(2); } # else HANDLE th; DWORD thread_id; th = CreateThread(NULL, 0, entry, (LPVOID)my_depth, 0, &thread_id); if (th == NULL) { fprintf(stderr, "Thread #%d creation failed: %d\n", thread_num, (int)GetLastError()); exit(2); } CloseHandle(th); # endif } AO_fetch_and_add(&thread_ended_cnt, 1); return 0; } int main(void) { int i; # ifdef GC_PTHREADS int err; pthread_t th[INITIAL_THREAD_COUNT]; # else HANDLE th[INITIAL_THREAD_COUNT]; # endif GC_INIT(); for (i = 0; i < INITIAL_THREAD_COUNT; ++i) { # ifdef GC_PTHREADS err = pthread_create(&th[i], NULL, entry, 0); if (err) { fprintf(stderr, "Thread creation failed: %s", strerror(err)); exit(1); } # else DWORD thread_id; th[i] = CreateThread(NULL, 0, entry, 0, 0, &thread_id); if (th[i] == NULL) { fprintf(stderr, "Thread creation failed: %d\n", (int)GetLastError()); exit(1); } # endif } for (i = 0; i < INITIAL_THREAD_COUNT; ++i) { # ifdef GC_PTHREADS void *res; err = pthread_join(th[i], &res); if (err) { fprintf(stderr, "Failed to join thread: %s", strerror(err)); exit(1); } # else if (WaitForSingleObject(th[i], INFINITE) != WAIT_OBJECT_0) { fprintf(stderr, "Failed to join thread: %d\n", (int)GetLastError()); CloseHandle(th[i]); exit(1); } CloseHandle(th[i]); # endif } printf("subthread_create: created %d threads (%d ended)\n", (int)AO_load(&thread_created_cnt), (int)AO_load(&thread_ended_cnt)); return 0; } #else int main(void) { printf("subthread_create test skipped\n"); return 0; } #endif /* !AO_HAVE_fetch_and_add */ ecl-16.1.2/src/bdwgc/tests/test.c000066400000000000000000001571251266352375300165350ustar00rootroot00000000000000/* * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. * Copyright (c) 1996 by Silicon Graphics. All rights reserved. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. */ /* An incomplete test for the garbage collector. */ /* Some more obscure entry points are not tested at all. */ /* This must be compiled with the same flags used to build the */ /* GC. It uses GC internals to allow more precise results */ /* checking for some of the tests. */ # ifdef HAVE_CONFIG_H # include "config.h" # endif # undef GC_BUILD #if (defined(DBG_HDRS_ALL) || defined(MAKE_BACK_GRAPH)) && !defined(GC_DEBUG) # define GC_DEBUG #endif #include "gc.h" #ifndef NTHREADS /* Number of additional threads to fork. */ # define NTHREADS 5 /* excludes main thread, which also runs a test. */ /* Not respected by PCR test. */ #endif # if defined(mips) && defined(SYSTYPE_BSD43) /* MIPS RISCOS 4 */ # else # include # endif # include # if defined(_WIN32_WCE) && !defined(__GNUC__) # include /* # define assert ASSERT */ # else # include /* Not normally used, but handy for debugging. */ # endif # include "gc_typed.h" # include "private/gc_priv.h" /* For output, locking, MIN_WORDS, */ /* some statistics and gcconfig.h. */ # if defined(MSWIN32) || defined(MSWINCE) # include # endif #ifdef GC_PRINT_VERBOSE_STATS # define print_stats VERBOSE # define INIT_PRINT_STATS /* empty */ #else /* Use own variable as GC_print_stats might not be exported. */ static int print_stats = 0; # ifdef GC_READ_ENV_FILE /* GETENV uses GC internal function in this case. */ # define INIT_PRINT_STATS /* empty */ # else # define INIT_PRINT_STATS \ { \ if (0 != GETENV("GC_PRINT_VERBOSE_STATS")) \ print_stats = VERBOSE; \ else if (0 != GETENV("GC_PRINT_STATS")) \ print_stats = 1; \ } # endif #endif /* !GC_PRINT_VERBOSE_STATS */ # ifdef PCR # include "th/PCR_ThCrSec.h" # include "th/PCR_Th.h" # define GC_printf printf # endif # if defined(GC_PTHREADS) # include # endif # if (!defined(THREADS) || !defined(HANDLE_FORK) \ || (defined(DARWIN) && defined(MPROTECT_VDB) \ && !defined(NO_INCREMENTAL) && !defined(MAKE_BACK_GRAPH))) \ && !defined(NO_TEST_HANDLE_FORK) && !defined(TEST_HANDLE_FORK) \ && !defined(TEST_FORK_WITHOUT_ATFORK) # define NO_TEST_HANDLE_FORK # endif # ifndef NO_TEST_HANDLE_FORK # include # ifdef HANDLE_FORK # define INIT_FORK_SUPPORT GC_set_handle_fork(1) /* Causes abort in GC_init on pthread_atfork failure. */ # elif !defined(TEST_FORK_WITHOUT_ATFORK) # define INIT_FORK_SUPPORT GC_set_handle_fork(-1) /* Passing -1 implies fork() should be as well manually */ /* surrounded with GC_atfork_prepare/parent/child. */ # endif # endif # ifndef INIT_FORK_SUPPORT # define INIT_FORK_SUPPORT /* empty */ # endif # if defined(GC_WIN32_THREADS) && !defined(GC_PTHREADS) static CRITICAL_SECTION incr_cs; # endif # include #define CHECH_GCLIB_VERSION \ if (GC_get_version() != ((GC_VERSION_MAJOR<<16) \ | (GC_VERSION_MINOR<<8) \ | GC_VERSION_MICRO)) { \ GC_printf("libgc version mismatch\n"); \ exit(1); \ } /* Call GC_INIT only on platforms on which we think we really need it, */ /* so that we can test automatic initialization on the rest. */ #if defined(CYGWIN32) || defined (AIX) || defined(DARWIN) \ || defined(PLATFORM_ANDROID) || defined(THREAD_LOCAL_ALLOC) \ || (defined(MSWINCE) && !defined(GC_WINMAIN_REDIRECT)) # define GC_OPT_INIT GC_INIT() #else # define GC_OPT_INIT /* empty */ #endif #define GC_COND_INIT() \ INIT_FORK_SUPPORT; GC_OPT_INIT; CHECH_GCLIB_VERSION; INIT_PRINT_STATS #define CHECK_OUT_OF_MEMORY(p) \ if ((p) == NULL) { \ GC_printf("Out of memory\n"); \ exit(1); \ } /* Allocation Statistics. Incremented without synchronization. */ /* FIXME: We should be using synchronization. */ int stubborn_count = 0; int uncollectable_count = 0; int collectable_count = 0; int atomic_count = 0; int realloc_count = 0; #if defined(GC_AMIGA_FASTALLOC) && defined(AMIGA) void GC_amiga_free_all_mem(void); void Amiga_Fail(void){GC_amiga_free_all_mem();abort();} # define FAIL (void)Amiga_Fail() void *GC_amiga_gctest_malloc_explicitly_typed(size_t lb, GC_descr d){ void *ret=GC_malloc_explicitly_typed(lb,d); if(ret==NULL){ GC_gcollect(); ret=GC_malloc_explicitly_typed(lb,d); if(ret==NULL){ GC_printf("Out of memory, (typed allocations are not directly " "supported with the GC_AMIGA_FASTALLOC option.)\n"); FAIL; } } return ret; } void *GC_amiga_gctest_calloc_explicitly_typed(size_t a,size_t lb, GC_descr d){ void *ret=GC_calloc_explicitly_typed(a,lb,d); if(ret==NULL){ GC_gcollect(); ret=GC_calloc_explicitly_typed(a,lb,d); if(ret==NULL){ GC_printf("Out of memory, (typed allocations are not directly " "supported with the GC_AMIGA_FASTALLOC option.)\n"); FAIL; } } return ret; } # define GC_malloc_explicitly_typed(a,b) GC_amiga_gctest_malloc_explicitly_typed(a,b) # define GC_calloc_explicitly_typed(a,b,c) GC_amiga_gctest_calloc_explicitly_typed(a,b,c) #else /* !AMIGA_FASTALLOC */ # if defined(PCR) || defined(LINT2) # define FAIL (void)abort() # else # define FAIL ABORT("Test failed") # endif #endif /* !AMIGA_FASTALLOC */ /* AT_END may be defined to exercise the interior pointer test */ /* if the collector is configured with ALL_INTERIOR_POINTERS. */ /* As it stands, this test should succeed with either */ /* configuration. In the FIND_LEAK configuration, it should */ /* find lots of leaks, since we free almost nothing. */ struct SEXPR { struct SEXPR * sexpr_car; struct SEXPR * sexpr_cdr; }; typedef struct SEXPR * sexpr; # define INT_TO_SEXPR(x) ((sexpr)(GC_word)(x)) # define SEXPR_TO_INT(x) ((int)(GC_word)(x)) # undef nil # define nil (INT_TO_SEXPR(0)) # define car(x) ((x) -> sexpr_car) # define cdr(x) ((x) -> sexpr_cdr) # define is_nil(x) ((x) == nil) int extra_count = 0; /* Amount of space wasted in cons node */ /* Silly implementation of Lisp cons. Intentionally wastes lots of space */ /* to test collector. */ # ifdef VERY_SMALL_CONFIG # define cons small_cons # else sexpr cons (sexpr x, sexpr y) { sexpr r; int *p; int my_extra = extra_count; stubborn_count++; r = (sexpr) GC_MALLOC_STUBBORN(sizeof(struct SEXPR) + my_extra); CHECK_OUT_OF_MEMORY(r); for (p = (int *)r; (word)p < (word)r + my_extra + sizeof(struct SEXPR); p++) { if (*p) { GC_printf("Found nonzero at %p - allocator is broken\n", (void *)p); FAIL; } *p = (int)((13 << 12) + ((p - (int *)r) & 0xfff)); } # ifdef AT_END r = (sexpr)((char *)r + (my_extra & ~7)); # endif r -> sexpr_car = x; r -> sexpr_cdr = y; my_extra++; if ( my_extra >= 5000 ) { extra_count = 0; } else { extra_count = my_extra; } GC_END_STUBBORN_CHANGE(r); return(r); } # endif #ifdef GC_GCJ_SUPPORT #include "gc_mark.h" #include "gc_gcj.h" /* The following struct emulates the vtable in gcj. */ /* This assumes the default value of MARK_DESCR_OFFSET. */ struct fake_vtable { void * dummy; /* class pointer in real gcj. */ GC_word descr; }; struct fake_vtable gcj_class_struct1 = { 0, sizeof(struct SEXPR) + sizeof(struct fake_vtable *) }; /* length based descriptor. */ struct fake_vtable gcj_class_struct2 = { 0, ((GC_word)3 << (CPP_WORDSZ - 3)) | GC_DS_BITMAP}; /* Bitmap based descriptor. */ struct GC_ms_entry * fake_gcj_mark_proc(word * addr, struct GC_ms_entry *mark_stack_ptr, struct GC_ms_entry *mark_stack_limit, word env ) { sexpr x; if (1 == env) { /* Object allocated with debug allocator. */ addr = (word *)GC_USR_PTR_FROM_BASE(addr); } x = (sexpr)(addr + 1); /* Skip the vtable pointer. */ mark_stack_ptr = GC_MARK_AND_PUSH( (void *)(x -> sexpr_cdr), mark_stack_ptr, mark_stack_limit, (void * *)&(x -> sexpr_cdr)); mark_stack_ptr = GC_MARK_AND_PUSH( (void *)(x -> sexpr_car), mark_stack_ptr, mark_stack_limit, (void * *)&(x -> sexpr_car)); return(mark_stack_ptr); } #endif /* GC_GCJ_SUPPORT */ sexpr small_cons (sexpr x, sexpr y) { sexpr r; collectable_count++; r = (sexpr) GC_MALLOC(sizeof(struct SEXPR)); CHECK_OUT_OF_MEMORY(r); r -> sexpr_car = x; r -> sexpr_cdr = y; return(r); } sexpr small_cons_uncollectable (sexpr x, sexpr y) { sexpr r; uncollectable_count++; r = (sexpr) GC_MALLOC_UNCOLLECTABLE(sizeof(struct SEXPR)); CHECK_OUT_OF_MEMORY(r); r -> sexpr_car = x; r -> sexpr_cdr = (sexpr)(~(GC_word)y); return(r); } #ifdef GC_GCJ_SUPPORT sexpr gcj_cons(sexpr x, sexpr y) { GC_word * r; sexpr result; r = (GC_word *) GC_GCJ_MALLOC(sizeof(struct SEXPR) + sizeof(struct fake_vtable*), &gcj_class_struct2); CHECK_OUT_OF_MEMORY(r); result = (sexpr)(r + 1); result -> sexpr_car = x; result -> sexpr_cdr = y; return(result); } #endif /* Return reverse(x) concatenated with y */ sexpr reverse1(sexpr x, sexpr y) { if (is_nil(x)) { return(y); } else { return( reverse1(cdr(x), cons(car(x), y)) ); } } sexpr reverse(sexpr x) { # ifdef TEST_WITH_SYSTEM_MALLOC malloc(100000); # endif return( reverse1(x, nil) ); } sexpr ints(int low, int up) { if (low > up) { return(nil); } else { return(small_cons(small_cons(INT_TO_SEXPR(low), nil), ints(low+1, up))); } } #ifdef GC_GCJ_SUPPORT /* Return reverse(x) concatenated with y */ sexpr gcj_reverse1(sexpr x, sexpr y) { if (is_nil(x)) { return(y); } else { return( gcj_reverse1(cdr(x), gcj_cons(car(x), y)) ); } } sexpr gcj_reverse(sexpr x) { return( gcj_reverse1(x, nil) ); } sexpr gcj_ints(int low, int up) { if (low > up) { return(nil); } else { return(gcj_cons(gcj_cons(INT_TO_SEXPR(low), nil), gcj_ints(low+1, up))); } } #endif /* GC_GCJ_SUPPORT */ /* To check uncollectible allocation we build lists with disguised cdr */ /* pointers, and make sure they don't go away. */ sexpr uncollectable_ints(int low, int up) { if (low > up) { return(nil); } else { return(small_cons_uncollectable(small_cons(INT_TO_SEXPR(low), nil), uncollectable_ints(low+1, up))); } } void check_ints(sexpr list, int low, int up) { if (SEXPR_TO_INT(car(car(list))) != low) { GC_printf( "List reversal produced incorrect list - collector is broken\n"); FAIL; } if (low == up) { if (cdr(list) != nil) { GC_printf("List too long - collector is broken\n"); FAIL; } } else { check_ints(cdr(list), low+1, up); } } # define UNCOLLECTABLE_CDR(x) (sexpr)(~(GC_word)(cdr(x))) void check_uncollectable_ints(sexpr list, int low, int up) { if (SEXPR_TO_INT(car(car(list))) != low) { GC_printf("Uncollectable list corrupted - collector is broken\n"); FAIL; } if (low == up) { if (UNCOLLECTABLE_CDR(list) != nil) { GC_printf("Uncollectable list too long - collector is broken\n"); FAIL; } } else { check_uncollectable_ints(UNCOLLECTABLE_CDR(list), low+1, up); } } /* Not used, but useful for debugging: */ void print_int_list(sexpr x) { if (is_nil(x)) { GC_printf("NIL\n"); } else { GC_printf("(%d)", SEXPR_TO_INT(car(car(x)))); if (!is_nil(cdr(x))) { GC_printf(", "); print_int_list(cdr(x)); } else { GC_printf("\n"); } } } /* ditto: */ void check_marks_int_list(sexpr x) { if (!GC_is_marked(x)) GC_printf("[unm:%p]", (void *)x); else GC_printf("[mkd:%p]", (void *)x); if (is_nil(x)) { GC_printf("NIL\n"); } else { if (!GC_is_marked(car(x))) GC_printf("[unm car:%p]", (void *)car(x)); GC_printf("(%d)", SEXPR_TO_INT(car(car(x)))); if (!is_nil(cdr(x))) { GC_printf(", "); check_marks_int_list(cdr(x)); } else { GC_printf("\n"); } } } /* * A tiny list reversal test to check thread creation. */ #ifdef THREADS # ifdef VERY_SMALL_CONFIG # define TINY_REVERSE_UPPER_VALUE 4 # else # define TINY_REVERSE_UPPER_VALUE 10 # endif # if defined(GC_WIN32_THREADS) && !defined(GC_PTHREADS) DWORD __stdcall tiny_reverse_test(void * arg GC_ATTR_UNUSED) # else void * tiny_reverse_test(void * arg GC_ATTR_UNUSED) # endif { int i; for (i = 0; i < 5; ++i) { check_ints(reverse(reverse(ints(1, TINY_REVERSE_UPPER_VALUE))), 1, TINY_REVERSE_UPPER_VALUE); } return 0; } # if defined(GC_PTHREADS) void fork_a_thread(void) { pthread_t t; int code; if ((code = pthread_create(&t, 0, tiny_reverse_test, 0)) != 0) { GC_printf("Small thread creation failed %d\n", code); FAIL; } if ((code = pthread_join(t, 0)) != 0) { GC_printf("Small thread join failed %d\n", code); FAIL; } } # elif defined(GC_WIN32_THREADS) void fork_a_thread(void) { DWORD thread_id; HANDLE h; h = GC_CreateThread((SECURITY_ATTRIBUTES *)NULL, (word)0, tiny_reverse_test, NULL, (DWORD)0, &thread_id); /* Explicitly specify types of the */ /* arguments to test the prototype. */ if (h == (HANDLE)NULL) { GC_printf("Small thread creation failed %d\n", (int)GetLastError()); FAIL; } if (WaitForSingleObject(h, INFINITE) != WAIT_OBJECT_0) { GC_printf("Small thread wait failed %d\n", (int)GetLastError()); FAIL; } } # endif #endif void test_generic_malloc_or_special(void *p) { size_t size; int kind = GC_get_kind_and_size(p, &size); void *p2; if (size != GC_size(p)) { GC_printf("GC_get_kind_and_size returned size not matching GC_size\n"); FAIL; } p2 = GC_GENERIC_OR_SPECIAL_MALLOC(10, kind); CHECK_OUT_OF_MEMORY(p2); if (GC_get_kind_and_size(p2, NULL) != kind) { GC_printf("GC_generic_or_special_malloc:" " unexpected kind of returned object\n"); FAIL; } GC_FREE(p2); } /* Try to force a to be strangely aligned */ struct { char dummy; sexpr aa; } A; #define a A.aa /* * Repeatedly reverse lists built out of very different sized cons cells. * Check that we didn't lose anything. */ void *GC_CALLBACK reverse_test_inner(void *data) { int i; sexpr b; sexpr c; sexpr d; sexpr e; sexpr *f, *g, *h; if (data == 0) { /* This stack frame is not guaranteed to be scanned. */ return GC_call_with_gc_active(reverse_test_inner, (void*)(word)1); } # if /*defined(MSWIN32) ||*/ defined(MACOS) /* Win32S only allows 128K stacks */ # define BIG 1000 # elif defined(PCR) /* PCR default stack is 100K. Stack frames are up to 120 bytes. */ # define BIG 700 # elif defined(MSWINCE) || defined(RTEMS) /* WinCE only allows 64K stacks */ # define BIG 500 # elif defined(OSF1) /* OSF has limited stack space by default, and large frames. */ # define BIG 200 # elif defined(__MACH__) && defined(__ppc64__) # define BIG 2500 # else # define BIG 4500 # endif A.dummy = 17; a = ints(1, 49); b = ints(1, 50); c = ints(1, BIG); d = uncollectable_ints(1, 100); test_generic_malloc_or_special(d); e = uncollectable_ints(1, 1); /* Check that realloc updates object descriptors correctly */ collectable_count++; f = (sexpr *)GC_MALLOC(4 * sizeof(sexpr)); realloc_count++; f = (sexpr *)GC_REALLOC((void *)f, 6 * sizeof(sexpr)); CHECK_OUT_OF_MEMORY(f); f[5] = ints(1,17); collectable_count++; g = (sexpr *)GC_MALLOC(513 * sizeof(sexpr)); test_generic_malloc_or_special(g); realloc_count++; g = (sexpr *)GC_REALLOC((void *)g, 800 * sizeof(sexpr)); CHECK_OUT_OF_MEMORY(g); g[799] = ints(1,18); collectable_count++; h = (sexpr *)GC_MALLOC(1025 * sizeof(sexpr)); realloc_count++; h = (sexpr *)GC_REALLOC((void *)h, 2000 * sizeof(sexpr)); CHECK_OUT_OF_MEMORY(h); # ifdef GC_GCJ_SUPPORT h[1999] = gcj_ints(1,200); for (i = 0; i < 51; ++i) h[1999] = gcj_reverse(h[1999]); /* Leave it as the reversed list for now. */ # else h[1999] = ints(1,200); # endif /* Try to force some collections and reuse of small list elements */ for (i = 0; i < 10; i++) { (void)ints(1, BIG); } /* Superficially test interior pointer recognition on stack */ c = (sexpr)((char *)c + sizeof(char *)); d = (sexpr)((char *)d + sizeof(char *)); GC_FREE((void *)e); check_ints(b,1,50); check_ints(a,1,49); for (i = 0; i < 50; i++) { check_ints(b,1,50); b = reverse(reverse(b)); } check_ints(b,1,50); check_ints(a,1,49); for (i = 0; i < 60; i++) { # if defined(GC_PTHREADS) || defined(GC_WIN32_THREADS) if (i % 10 == 0) fork_a_thread(); # endif /* This maintains the invariant that a always points to a list of */ /* 49 integers. Thus this is thread safe without locks, */ /* assuming atomic pointer assignments. */ a = reverse(reverse(a)); # if !defined(AT_END) && !defined(THREADS) /* This is not thread safe, since realloc explicitly deallocates */ if (i & 1) { a = (sexpr)GC_REALLOC((void *)a, 500); } else { a = (sexpr)GC_REALLOC((void *)a, 8200); } # endif } check_ints(a,1,49); check_ints(b,1,50); /* Restore c and d values. */ c = (sexpr)((char *)c - sizeof(char *)); d = (sexpr)((char *)d - sizeof(char *)); check_ints(c,1,BIG); check_uncollectable_ints(d, 1, 100); check_ints(f[5], 1,17); check_ints(g[799], 1,18); # ifdef GC_GCJ_SUPPORT h[1999] = gcj_reverse(h[1999]); # endif check_ints(h[1999], 1,200); # ifndef THREADS a = 0; # endif *(sexpr volatile *)&b = 0; *(sexpr volatile *)&c = 0; return 0; } void reverse_test(void) { /* Test GC_do_blocking/GC_call_with_gc_active. */ (void)GC_do_blocking(reverse_test_inner, 0); } #undef a /* * The rest of this builds balanced binary trees, checks that they don't * disappear, and tests finalization. */ typedef struct treenode { int level; struct treenode * lchild; struct treenode * rchild; } tn; int finalizable_count = 0; int finalized_count = 0; volatile int dropped_something = 0; void GC_CALLBACK finalizer(void * obj, void * client_data) { tn * t = (tn *)obj; # ifdef PCR PCR_ThCrSec_EnterSys(); # endif # if defined(GC_PTHREADS) static pthread_mutex_t incr_lock = PTHREAD_MUTEX_INITIALIZER; pthread_mutex_lock(&incr_lock); # elif defined(GC_WIN32_THREADS) EnterCriticalSection(&incr_cs); # endif if ((int)(GC_word)client_data != t -> level) { GC_printf("Wrong finalization data - collector is broken\n"); FAIL; } finalized_count++; t -> level = -1; /* detect duplicate finalization immediately */ # ifdef PCR PCR_ThCrSec_ExitSys(); # endif # if defined(GC_PTHREADS) pthread_mutex_unlock(&incr_lock); # elif defined(GC_WIN32_THREADS) LeaveCriticalSection(&incr_cs); # endif } size_t counter = 0; # define MAX_FINALIZED (NTHREADS*4000) # if !defined(MACOS) GC_FAR GC_word live_indicators[MAX_FINALIZED] = {0}; # ifndef GC_LONG_REFS_NOT_NEEDED GC_FAR void *live_long_refs[MAX_FINALIZED] = { NULL }; # endif #else /* Too big for THINK_C. have to allocate it dynamically. */ GC_word *live_indicators = 0; # ifndef GC_LONG_REFS_NOT_NEEDED # define GC_LONG_REFS_NOT_NEEDED # endif #endif int live_indicators_count = 0; tn * mktree(int n) { tn * result = (tn *)GC_MALLOC(sizeof(tn)); collectable_count++; # if defined(MACOS) /* get around static data limitations. */ if (!live_indicators) { live_indicators = (GC_word*)NewPtrClear(MAX_FINALIZED * sizeof(GC_word)); CHECK_OUT_OF_MEMORY(live_indicators); } # endif if (n == 0) return(0); CHECK_OUT_OF_MEMORY(result); result -> level = n; result -> lchild = mktree(n-1); result -> rchild = mktree(n-1); if (counter++ % 17 == 0 && n >= 2) { tn * tmp; CHECK_OUT_OF_MEMORY(result->lchild); tmp = result -> lchild -> rchild; CHECK_OUT_OF_MEMORY(result->rchild); result -> lchild -> rchild = result -> rchild -> lchild; result -> rchild -> lchild = tmp; } if (counter++ % 119 == 0) { # ifndef GC_NO_FINALIZATION int my_index; void *new_link; # endif { # ifdef PCR PCR_ThCrSec_EnterSys(); # endif # if defined(GC_PTHREADS) static pthread_mutex_t incr_lock = PTHREAD_MUTEX_INITIALIZER; pthread_mutex_lock(&incr_lock); # elif defined(GC_WIN32_THREADS) EnterCriticalSection(&incr_cs); # endif /* Losing a count here causes erroneous report of failure. */ finalizable_count++; # ifndef GC_NO_FINALIZATION my_index = live_indicators_count++; # endif # ifdef PCR PCR_ThCrSec_ExitSys(); # endif # if defined(GC_PTHREADS) pthread_mutex_unlock(&incr_lock); # elif defined(GC_WIN32_THREADS) LeaveCriticalSection(&incr_cs); # endif } # ifndef GC_NO_FINALIZATION GC_REGISTER_FINALIZER((void *)result, finalizer, (void *)(GC_word)n, (GC_finalization_proc *)0, (void * *)0); if (my_index >= MAX_FINALIZED) { GC_printf("live_indicators overflowed\n"); FAIL; } live_indicators[my_index] = 13; if (GC_GENERAL_REGISTER_DISAPPEARING_LINK( (void * *)(&(live_indicators[my_index])), result) != 0) { GC_printf("GC_general_register_disappearing_link failed\n"); FAIL; } if (GC_move_disappearing_link((void **)(&(live_indicators[my_index])), (void **)(&(live_indicators[my_index]))) != GC_SUCCESS) { GC_printf("GC_move_disappearing_link(link,link) failed\n"); FAIL; } new_link = (void *)live_indicators[my_index]; if (GC_move_disappearing_link((void **)(&(live_indicators[my_index])), &new_link) != GC_SUCCESS) { GC_printf("GC_move_disappearing_link(new_link) failed\n"); FAIL; } if (GC_unregister_disappearing_link(&new_link) == 0) { GC_printf("GC_unregister_disappearing_link failed\n"); FAIL; } if (GC_move_disappearing_link((void **)(&(live_indicators[my_index])), &new_link) != GC_NOT_FOUND) { GC_printf("GC_move_disappearing_link(new_link) failed 2\n"); FAIL; } if (GC_GENERAL_REGISTER_DISAPPEARING_LINK( (void * *)(&(live_indicators[my_index])), result) != 0) { GC_printf("GC_general_register_disappearing_link failed 2\n"); FAIL; } # ifndef GC_LONG_REFS_NOT_NEEDED if (GC_REGISTER_LONG_LINK(&live_long_refs[my_index], result) != 0) { GC_printf("GC_register_long_link failed\n"); FAIL; } if (GC_move_long_link(&live_long_refs[my_index], &live_long_refs[my_index]) != GC_SUCCESS) { GC_printf("GC_move_long_link(link,link) failed\n"); FAIL; } new_link = live_long_refs[my_index]; if (GC_move_long_link(&live_long_refs[my_index], &new_link) != GC_SUCCESS) { GC_printf("GC_move_long_link(new_link) failed\n"); FAIL; } if (GC_unregister_long_link(&new_link) == 0) { GC_printf("GC_unregister_long_link failed\n"); FAIL; } if (GC_move_long_link(&live_long_refs[my_index], &new_link) != GC_NOT_FOUND) { GC_printf("GC_move_long_link(new_link) failed 2\n"); FAIL; } if (GC_REGISTER_LONG_LINK(&live_long_refs[my_index], result) != 0) { GC_printf("GC_register_long_link failed 2\n"); FAIL; } # endif # endif GC_reachable_here(result); } return(result); } void chktree(tn *t, int n) { if (n == 0 && t != 0) { GC_printf("Clobbered a leaf - collector is broken\n"); FAIL; } if (n == 0) return; if (t -> level != n) { GC_printf("Lost a node at level %d - collector is broken\n", n); FAIL; } if (counter++ % 373 == 0) { collectable_count++; (void) GC_MALLOC(counter%5001); } chktree(t -> lchild, n-1); if (counter++ % 73 == 0) { collectable_count++; (void) GC_MALLOC(counter%373); } chktree(t -> rchild, n-1); } #if defined(GC_PTHREADS) pthread_key_t fl_key; void * alloc8bytes(void) { # if defined(SMALL_CONFIG) || defined(GC_DEBUG) collectable_count++; return(GC_MALLOC(8)); # else void ** my_free_list_ptr; void * my_free_list; my_free_list_ptr = (void **)pthread_getspecific(fl_key); if (my_free_list_ptr == 0) { uncollectable_count++; my_free_list_ptr = GC_NEW_UNCOLLECTABLE(void *); CHECK_OUT_OF_MEMORY(my_free_list_ptr); if (pthread_setspecific(fl_key, my_free_list_ptr) != 0) { GC_printf("pthread_setspecific failed\n"); FAIL; } } my_free_list = *my_free_list_ptr; if (my_free_list == 0) { my_free_list = GC_malloc_many(8); CHECK_OUT_OF_MEMORY(my_free_list); } *my_free_list_ptr = GC_NEXT(my_free_list); GC_NEXT(my_free_list) = 0; collectable_count++; return(my_free_list); # endif } #else # define alloc8bytes() GC_MALLOC_ATOMIC(8) #endif void alloc_small(int n) { int i; for (i = 0; i < n; i += 8) { atomic_count++; if (alloc8bytes() == 0) { GC_printf("Out of memory\n"); FAIL; } } } # if defined(THREADS) && defined(GC_DEBUG) # ifdef VERY_SMALL_CONFIG # define TREE_HEIGHT 12 # else # define TREE_HEIGHT 15 # endif # else # ifdef VERY_SMALL_CONFIG # define TREE_HEIGHT 13 # else # define TREE_HEIGHT 16 # endif # endif void tree_test(void) { tn * root; int i; root = mktree(TREE_HEIGHT); # ifndef VERY_SMALL_CONFIG alloc_small(5000000); # endif chktree(root, TREE_HEIGHT); if (finalized_count && ! dropped_something) { GC_printf("Premature finalization - collector is broken\n"); FAIL; } dropped_something = 1; GC_noop1((word)root); /* Root needs to remain live until */ /* dropped_something is set. */ root = mktree(TREE_HEIGHT); chktree(root, TREE_HEIGHT); for (i = TREE_HEIGHT; i >= 0; i--) { root = mktree(i); chktree(root, i); } # ifndef VERY_SMALL_CONFIG alloc_small(5000000); # endif } unsigned n_tests = 0; const GC_word bm_huge[10] = { 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0x00ffffff, }; /* A very simple test of explicitly typed allocation */ void typed_test(void) { GC_word * old, * new; GC_word bm3 = 0x3; GC_word bm2 = 0x2; GC_word bm_large = 0xf7ff7fff; GC_descr d1 = GC_make_descriptor(&bm3, 2); GC_descr d2 = GC_make_descriptor(&bm2, 2); GC_descr d3 = GC_make_descriptor(&bm_large, 32); GC_descr d4 = GC_make_descriptor(bm_huge, 320); GC_word * x = (GC_word *)GC_malloc_explicitly_typed(2000, d4); int i; # ifndef LINT (void)GC_make_descriptor(&bm_large, 32); # endif collectable_count++; old = 0; for (i = 0; i < 4000; i++) { collectable_count++; new = (GC_word *) GC_malloc_explicitly_typed(4 * sizeof(GC_word), d1); CHECK_OUT_OF_MEMORY(new); if (0 != new[0] || 0 != new[1]) { GC_printf("Bad initialization by GC_malloc_explicitly_typed\n"); FAIL; } new[0] = 17; new[1] = (GC_word)old; old = new; collectable_count++; new = (GC_word *) GC_malloc_explicitly_typed(4 * sizeof(GC_word), d2); CHECK_OUT_OF_MEMORY(new); new[0] = 17; new[1] = (GC_word)old; old = new; collectable_count++; new = (GC_word *) GC_malloc_explicitly_typed(33 * sizeof(GC_word), d3); CHECK_OUT_OF_MEMORY(new); new[0] = 17; new[1] = (GC_word)old; old = new; collectable_count++; new = (GC_word *) GC_calloc_explicitly_typed(4, 2 * sizeof(GC_word), d1); CHECK_OUT_OF_MEMORY(new); new[0] = 17; new[1] = (GC_word)old; old = new; collectable_count++; if (i & 0xff) { new = (GC_word *) GC_calloc_explicitly_typed(7, 3 * sizeof(GC_word), d2); } else { new = (GC_word *) GC_calloc_explicitly_typed(1001, 3 * sizeof(GC_word), d2); if (new && (0 != new[0] || 0 != new[1])) { GC_printf("Bad initialization by GC_malloc_explicitly_typed\n"); FAIL; } } CHECK_OUT_OF_MEMORY(new); new[0] = 17; new[1] = (GC_word)old; old = new; } for (i = 0; i < 20000; i++) { if (new[0] != 17) { GC_printf("typed alloc failed at %lu\n", (unsigned long)i); FAIL; } new[0] = 0; old = new; new = (GC_word *)(old[1]); } GC_gcollect(); GC_noop1((word)x); } int fail_count = 0; void GC_CALLBACK fail_proc1(void *x GC_ATTR_UNUSED) { fail_count++; } static void uniq(void *p, ...) { va_list a; void *q[100]; int n = 0, i, j; q[n++] = p; va_start(a,p); for (;(q[n] = va_arg(a,void *)) != NULL;n++) ; va_end(a); for (i=0; i= (n)) #endif void * GC_CALLBACK inc_int_counter(void *pcounter) { ++(*(int *)pcounter); return NULL; } void run_one_test(void) { # ifndef DBG_HDRS_ALL char *x; char **z; # ifdef LINT char *y = 0; # else char *y = (char *)(GC_word)fail_proc1; # endif CLOCK_TYPE typed_time; # endif CLOCK_TYPE start_time; CLOCK_TYPE reverse_time; CLOCK_TYPE tree_time; unsigned long time_diff; # ifdef FIND_LEAK GC_printf( "This test program is not designed for leak detection mode\n"); GC_printf("Expect lots of problems\n"); # endif GC_FREE(0); # ifdef THREADS if (!GC_thread_is_registered()) { GC_printf("Current thread is not registered with GC\n"); FAIL; } # endif # ifndef DBG_HDRS_ALL collectable_count += 3; if ((GC_size(GC_malloc(7)) != 8 && GC_size(GC_malloc(7)) != MIN_WORDS * sizeof(GC_word)) || GC_size(GC_malloc(15)) != 16) { GC_printf("GC_size produced unexpected results\n"); FAIL; } collectable_count += 1; if (GC_size(GC_malloc(0)) != MIN_WORDS * sizeof(GC_word)) { GC_printf("GC_malloc(0) failed: GC_size returns %lu\n", (unsigned long)GC_size(GC_malloc(0))); FAIL; } collectable_count += 1; if (GC_size(GC_malloc_uncollectable(0)) != MIN_WORDS * sizeof(GC_word)) { GC_printf("GC_malloc_uncollectable(0) failed\n"); FAIL; } GC_is_valid_displacement_print_proc = fail_proc1; GC_is_visible_print_proc = fail_proc1; collectable_count += 1; x = GC_malloc(16); if (GC_base(GC_PTR_ADD(x, 13)) != x) { GC_printf("GC_base(heap ptr) produced incorrect result\n"); FAIL; } if (!GC_is_heap_ptr(x)) { GC_printf("GC_is_heap_ptr(heap_ptr) produced incorrect result\n"); FAIL; } if (GC_is_heap_ptr(&x)) { GC_printf("GC_is_heap_ptr(&local_var) produced incorrect result\n"); FAIL; } if (GC_is_heap_ptr(&fail_count) || GC_is_heap_ptr(NULL)) { GC_printf("GC_is_heap_ptr(&global_var) produced incorrect result\n"); FAIL; } (void)GC_PRE_INCR(x, 0); (void)GC_POST_INCR(x); (void)GC_POST_DECR(x); if (GC_base(x) != x) { GC_printf("Bad INCR/DECR result\n"); FAIL; } # ifndef PCR if (GC_base(y) != 0) { GC_printf("GC_base(fn_ptr) produced incorrect result\n"); FAIL; } # endif if (GC_same_obj(x+5, x) != x + 5) { GC_printf("GC_same_obj produced incorrect result\n"); FAIL; } if (GC_is_visible(y) != y || GC_is_visible(x) != x) { GC_printf("GC_is_visible produced incorrect result\n"); FAIL; } z = GC_malloc(8); GC_PTR_STORE(z, x); if (*z != x) { GC_printf("GC_PTR_STORE failed: %p != %p\n", (void *)(*z), (void *)x); FAIL; } if (!TEST_FAIL_COUNT(1)) { # if!(defined(POWERPC) || defined(IA64)) || defined(M68K) /* On POWERPCs function pointers point to a descriptor in the */ /* data segment, so there should have been no failures. */ /* The same applies to IA64. Something similar seems to */ /* be going on with NetBSD/M68K. */ GC_printf("GC_is_visible produced wrong failure indication\n"); FAIL; # endif } if (GC_is_valid_displacement(y) != y || GC_is_valid_displacement(x) != x || GC_is_valid_displacement(x + 3) != x + 3) { GC_printf("GC_is_valid_displacement produced incorrect result\n"); FAIL; } { size_t i; (void)GC_malloc(17); for (i = sizeof(GC_word); i < 512; i *= 2) { GC_word result = (GC_word) GC_memalign(i, 17); if (result % i != 0 || result == 0 || *(int *)result != 0) FAIL; } } # ifndef ALL_INTERIOR_POINTERS # if defined(RS6000) || defined(POWERPC) if (!TEST_FAIL_COUNT(1)) # else if (!TEST_FAIL_COUNT(GC_get_all_interior_pointers() ? 1 : 2)) # endif { GC_printf( "GC_is_valid_displacement produced wrong failure indication\n"); FAIL; } # endif # endif /* DBG_HDRS_ALL */ /* Test floating point alignment */ collectable_count += 2; { double *dp = GC_MALLOC(sizeof(double)); CHECK_OUT_OF_MEMORY(dp); *dp = 1.0; dp = GC_MALLOC(sizeof(double)); CHECK_OUT_OF_MEMORY(dp); *dp = 1.0; } /* Test size 0 allocation a bit more */ { size_t i; for (i = 0; i < 10000; ++i) { (void)GC_MALLOC(0); GC_FREE(GC_MALLOC(0)); (void)GC_MALLOC_ATOMIC(0); GC_FREE(GC_MALLOC_ATOMIC(0)); test_generic_malloc_or_special(GC_malloc_atomic(1)); } } # ifdef GC_GCJ_SUPPORT GC_REGISTER_DISPLACEMENT(sizeof(struct fake_vtable *)); GC_init_gcj_malloc(0, (void *)(GC_word)fake_gcj_mark_proc); # endif /* Make sure that fn arguments are visible to the collector. */ uniq( GC_malloc(12), GC_malloc(12), GC_malloc(12), (GC_gcollect(),GC_malloc(12)), GC_malloc(12), GC_malloc(12), GC_malloc(12), (GC_gcollect(),GC_malloc(12)), GC_malloc(12), GC_malloc(12), GC_malloc(12), (GC_gcollect(),GC_malloc(12)), GC_malloc(12), GC_malloc(12), GC_malloc(12), (GC_gcollect(),GC_malloc(12)), GC_malloc(12), GC_malloc(12), GC_malloc(12), (GC_gcollect(),GC_malloc(12)), (void *)0); /* GC_malloc(0) must return NULL or something we can deallocate. */ GC_free(GC_malloc(0)); GC_free(GC_malloc_atomic(0)); GC_free(GC_malloc(0)); GC_free(GC_malloc_atomic(0)); # ifndef NO_TEST_HANDLE_FORK GC_atfork_prepare(); if (fork() != 0) { GC_atfork_parent(); if (print_stats) GC_log_printf("Forked child process (or failed)\n"); } else { GC_atfork_child(); if (print_stats) GC_log_printf("Started a child process\n"); # ifdef THREADS # ifdef PARALLEL_MARK GC_gcollect(); /* no parallel markers */ # endif GC_start_mark_threads(); # endif GC_gcollect(); # ifdef THREADS tiny_reverse_test(0); GC_gcollect(); # endif if (print_stats) GC_log_printf("Finished a child process\n"); exit(0); } # endif /* Repeated list reversal test. */ GET_TIME(start_time); reverse_test(); if (print_stats) { GET_TIME(reverse_time); time_diff = MS_TIME_DIFF(reverse_time, start_time); GC_log_printf("-------------Finished reverse_test at time %u (%p)\n", (unsigned) time_diff, (void *)&start_time); } # ifndef DBG_HDRS_ALL typed_test(); if (print_stats) { GET_TIME(typed_time); time_diff = MS_TIME_DIFF(typed_time, start_time); GC_log_printf("-------------Finished typed_test at time %u (%p)\n", (unsigned) time_diff, (void *)&start_time); } # endif /* DBG_HDRS_ALL */ tree_test(); if (print_stats) { GET_TIME(tree_time); time_diff = MS_TIME_DIFF(tree_time, start_time); GC_log_printf("-------------Finished tree_test at time %u (%p)\n", (unsigned) time_diff, (void *)&start_time); } /* Run reverse_test a second time, so we hopefully notice corruption. */ reverse_test(); if (print_stats) { GET_TIME(reverse_time); time_diff = MS_TIME_DIFF(reverse_time, start_time); GC_log_printf( "-------------Finished second reverse_test at time %u (%p)\n", (unsigned)time_diff, (void *)&start_time); } /* GC_allocate_ml and GC_need_to_lock are no longer exported, and */ /* AO_fetch_and_add1() may be unavailable to update a counter. */ (void)GC_call_with_alloc_lock(inc_int_counter, &n_tests); if (print_stats) GC_log_printf("Finished %p\n", (void *)&start_time); } #define NUMBER_ROUND_UP(v, bound) ((((v) + (bound) - 1) / (bound)) * (bound)) void check_heap_stats(void) { size_t max_heap_sz; int i; # ifndef GC_NO_FINALIZATION int still_live; # ifndef GC_LONG_REFS_NOT_NEEDED int still_long_live = 0; # endif # ifdef FINALIZE_ON_DEMAND int late_finalize_count = 0; # endif # endif # ifdef VERY_SMALL_CONFIG /* The upper bounds are a guess, which has been empirically */ /* adjusted. On low end uniprocessors with incremental GC */ /* these may be particularly dubious, since empirically the */ /* heap tends to grow largely as a result of the GC not */ /* getting enough cycles. */ # if CPP_WORDSZ == 64 max_heap_sz = 4500000; # else max_heap_sz = 2800000; # endif # else # if CPP_WORDSZ == 64 max_heap_sz = 23000000; # else max_heap_sz = 16000000; # endif # endif # ifdef GC_DEBUG max_heap_sz *= 2; # ifdef SAVE_CALL_CHAIN max_heap_sz *= 3; # ifdef SAVE_CALL_COUNT max_heap_sz += max_heap_sz * SAVE_CALL_COUNT/4; # endif # endif # endif max_heap_sz *= n_tests; # if defined(USE_MMAP) || defined(MSWIN32) max_heap_sz = NUMBER_ROUND_UP(max_heap_sz, 4 * 1024 * 1024); # endif /* Garbage collect repeatedly so that all inaccessible objects */ /* can be finalized. */ while (GC_collect_a_little()) { } for (i = 0; i < 16; i++) { GC_gcollect(); # ifndef GC_NO_FINALIZATION # ifdef FINALIZE_ON_DEMAND late_finalize_count += # endif GC_invoke_finalizers(); # endif } if (print_stats) { struct GC_stack_base sb; int res = GC_get_stack_base(&sb); if (res == GC_SUCCESS) { GC_log_printf("Primordial thread stack bottom: %p\n", sb.mem_base); } else if (res == GC_UNIMPLEMENTED) { GC_log_printf("GC_get_stack_base() unimplemented\n"); } else { GC_printf("GC_get_stack_base() failed: %d\n", res); FAIL; } } GC_printf("Completed %u tests\n", n_tests); GC_printf("Allocated %d collectable objects\n", collectable_count); GC_printf("Allocated %d uncollectable objects\n", uncollectable_count); GC_printf("Allocated %d atomic objects\n", atomic_count); GC_printf("Allocated %d stubborn objects\n", stubborn_count); GC_printf("Finalized %d/%d objects - ", finalized_count, finalizable_count); # ifndef GC_NO_FINALIZATION # ifdef FINALIZE_ON_DEMAND if (finalized_count != late_finalize_count) { GC_printf("Demand finalization error\n"); FAIL; } # endif if (finalized_count > finalizable_count || finalized_count < finalizable_count/2) { GC_printf("finalization is probably broken\n"); FAIL; } else { GC_printf("finalization is probably ok\n"); } still_live = 0; for (i = 0; i < MAX_FINALIZED; i++) { if (live_indicators[i] != 0) { still_live++; } # ifndef GC_LONG_REFS_NOT_NEEDED if (live_long_refs[i] != NULL) { still_long_live++; } # endif } i = finalizable_count - finalized_count - still_live; if (0 != i) { GC_printf("%d disappearing links remain and %d more objects " "were not finalized\n", still_live, i); if (i > 10) { GC_printf("\tVery suspicious!\n"); } else { GC_printf("\tSlightly suspicious, but probably OK\n"); } } # ifndef GC_LONG_REFS_NOT_NEEDED if (0 != still_long_live) { GC_printf("%d 'long' links remain\n", still_long_live); } # endif # endif GC_printf("Total number of bytes allocated is %lu\n", (unsigned long)GC_get_total_bytes()); GC_printf("Final heap size is %lu bytes\n", (unsigned long)GC_get_heap_size()); if (GC_get_total_bytes() < n_tests * # ifdef VERY_SMALL_CONFIG 2700000 # else 33500000 # endif ) { GC_printf("Incorrect execution - missed some allocations\n"); FAIL; } if (GC_get_heap_size() + GC_get_unmapped_bytes() > max_heap_sz) { GC_printf("Unexpected heap growth - collector may be broken" " (heapsize: %lu, expected: %lu)\n", (unsigned long)(GC_get_heap_size() + GC_get_unmapped_bytes()), (unsigned long)max_heap_sz); FAIL; } # ifndef GC_GET_HEAP_USAGE_NOT_NEEDED /* Get global counters (just to check the functions work). */ GC_get_heap_usage_safe(NULL, NULL, NULL, NULL, NULL); { struct GC_prof_stats_s stats; (void)GC_get_prof_stats(&stats, sizeof(stats)); # ifdef THREADS (void)GC_get_prof_stats_unsafe(&stats, sizeof(stats)); # endif } # endif # ifdef THREADS GC_unregister_my_thread(); /* just to check it works (for main) */ # endif GC_printf("Completed %u collections", (unsigned)GC_get_gc_no()); # ifdef PARALLEL_MARK GC_printf(" (using %d marker threads)", GC_get_parallel() + 1); # endif GC_printf("\n" "Collector appears to work\n"); } #if defined(MACOS) void SetMinimumStack(long minSize) { long newApplLimit; if (minSize > LMGetDefltStack()) { newApplLimit = (long) GetApplLimit() - (minSize - LMGetDefltStack()); SetApplLimit((Ptr) newApplLimit); MaxApplZone(); } } #define cMinStackSpace (512L * 1024L) #endif void GC_CALLBACK warn_proc(char *msg, GC_word p) { GC_printf(msg, (unsigned long)p); /*FAIL;*/ } #if defined(MSWINCE) && defined(UNDER_CE) # define WINMAIN_LPTSTR LPWSTR #else # define WINMAIN_LPTSTR LPSTR #endif #if !defined(PCR) && !defined(GC_WIN32_THREADS) && !defined(GC_PTHREADS) \ || defined(LINT) #if defined(MSWIN32) && !defined(__MINGW32__) || defined(MSWINCE) int APIENTRY WinMain(HINSTANCE instance GC_ATTR_UNUSED, HINSTANCE prev GC_ATTR_UNUSED, WINMAIN_LPTSTR cmd GC_ATTR_UNUSED, int n GC_ATTR_UNUSED) #elif defined(RTEMS) # include # define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER # define CONFIGURE_APPLICATION_NEEDS_CONSOLE_DRIVER # define CONFIGURE_RTEMS_INIT_TASKS_TABLE # define CONFIGURE_MAXIMUM_TASKS 1 # define CONFIGURE_INIT # define CONFIGURE_INIT_TASK_STACK_SIZE (64*1024) # include rtems_task Init(rtems_task_argument ignord) #else int main(void) #endif { n_tests = 0; # if defined(MACOS) /* Make sure we have lots and lots of stack space. */ SetMinimumStack(cMinStackSpace); /* Cheat and let stdio initialize toolbox for us. */ printf("Testing GC Macintosh port\n"); # endif GC_COND_INIT(); GC_set_warn_proc(warn_proc); # if (defined(MPROTECT_VDB) || defined(PROC_VDB) || defined(GWW_VDB)) \ && !defined(MAKE_BACK_GRAPH) && !defined(NO_INCREMENTAL) GC_enable_incremental(); GC_printf("Switched to incremental mode\n"); # if defined(MPROTECT_VDB) GC_printf("Emulating dirty bits with mprotect/signals\n"); # else # ifdef PROC_VDB GC_printf("Reading dirty bits from /proc\n"); # elif defined(GWW_VDB) GC_printf("Using GetWriteWatch-based implementation\n"); # else GC_printf("Using DEFAULT_VDB dirty bit implementation\n"); # endif # endif # endif run_one_test(); check_heap_stats(); # ifndef MSWINCE fflush(stdout); # endif # ifdef MSWIN32 GC_win32_free_heap(); # endif # ifdef RTEMS exit(0); # else return(0); # endif } # endif #if defined(GC_WIN32_THREADS) && !defined(GC_PTHREADS) DWORD __stdcall thr_run_one_test(void * arg GC_ATTR_UNUSED) { run_one_test(); return 0; } #ifdef MSWINCE HANDLE win_created_h; HWND win_handle; LRESULT CALLBACK window_proc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { LRESULT ret = 0; switch (uMsg) { case WM_HIBERNATE: GC_printf("Received WM_HIBERNATE, calling GC_gcollect\n"); /* Force "unmap as much memory as possible" mode. */ GC_gcollect_and_unmap(); break; case WM_CLOSE: GC_printf("Received WM_CLOSE, closing window\n"); DestroyWindow(hwnd); break; case WM_DESTROY: PostQuitMessage(0); break; default: ret = DefWindowProc(hwnd, uMsg, wParam, lParam); break; } return ret; } DWORD __stdcall thr_window(void * arg GC_ATTR_UNUSED) { WNDCLASS win_class = { CS_NOCLOSE, window_proc, 0, 0, GetModuleHandle(NULL), NULL, NULL, (HBRUSH)(COLOR_APPWORKSPACE+1), NULL, TEXT("GCtestWindow") }; MSG msg; if (!RegisterClass(&win_class)) FAIL; win_handle = CreateWindowEx( 0, TEXT("GCtestWindow"), TEXT("GCtest"), 0, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, NULL, NULL, GetModuleHandle(NULL), NULL); if (win_handle == NULL) FAIL; SetEvent(win_created_h); ShowWindow(win_handle, SW_SHOW); UpdateWindow(win_handle); while (GetMessage(&msg, NULL, 0, 0)) { TranslateMessage(&msg); DispatchMessage(&msg); } return 0; } #endif int APIENTRY WinMain(HINSTANCE instance GC_ATTR_UNUSED, HINSTANCE prev GC_ATTR_UNUSED, WINMAIN_LPTSTR cmd GC_ATTR_UNUSED, int n GC_ATTR_UNUSED) { # if NTHREADS > 0 HANDLE h[NTHREADS]; int i; # endif # ifdef MSWINCE HANDLE win_thr_h; # endif DWORD thread_id; # if defined(GC_DLL) && !defined(GC_NO_THREADS_DISCOVERY) \ && !defined(MSWINCE) && !defined(THREAD_LOCAL_ALLOC) \ && !defined(PARALLEL_MARK) GC_use_threads_discovery(); /* Test with implicit thread registration if possible. */ GC_printf("Using DllMain to track threads\n"); # endif GC_COND_INIT(); # if !defined(MAKE_BACK_GRAPH) && !defined(NO_INCREMENTAL) GC_enable_incremental(); # endif InitializeCriticalSection(&incr_cs); GC_set_warn_proc(warn_proc); # ifdef MSWINCE win_created_h = CreateEvent(NULL, FALSE, FALSE, NULL); if (win_created_h == (HANDLE)NULL) { GC_printf("Event creation failed %d\n", (int)GetLastError()); FAIL; } win_thr_h = GC_CreateThread(NULL, 0, thr_window, 0, 0, &thread_id); if (win_thr_h == (HANDLE)NULL) { GC_printf("Thread creation failed %d\n", (int)GetLastError()); FAIL; } if (WaitForSingleObject(win_created_h, INFINITE) != WAIT_OBJECT_0) FAIL; CloseHandle(win_created_h); # endif # if NTHREADS > 0 for (i = 0; i < NTHREADS; i++) { h[i] = GC_CreateThread(NULL, 0, thr_run_one_test, 0, 0, &thread_id); if (h[i] == (HANDLE)NULL) { GC_printf("Thread creation failed %d\n", (int)GetLastError()); FAIL; } } # endif /* NTHREADS > 0 */ run_one_test(); # if NTHREADS > 0 for (i = 0; i < NTHREADS; i++) { if (WaitForSingleObject(h[i], INFINITE) != WAIT_OBJECT_0) { GC_printf("Thread wait failed %d\n", (int)GetLastError()); FAIL; } } # endif /* NTHREADS > 0 */ # ifdef MSWINCE PostMessage(win_handle, WM_CLOSE, 0, 0); if (WaitForSingleObject(win_thr_h, INFINITE) != WAIT_OBJECT_0) FAIL; # endif check_heap_stats(); return(0); } #endif /* GC_WIN32_THREADS */ #ifdef PCR int test(void) { PCR_Th_T * th1; PCR_Th_T * th2; int code; n_tests = 0; /* GC_enable_incremental(); */ GC_set_warn_proc(warn_proc); th1 = PCR_Th_Fork(run_one_test, 0); th2 = PCR_Th_Fork(run_one_test, 0); run_one_test(); if (PCR_Th_T_Join(th1, &code, NIL, PCR_allSigsBlocked, PCR_waitForever) != PCR_ERes_okay || code != 0) { GC_printf("Thread 1 failed\n"); } if (PCR_Th_T_Join(th2, &code, NIL, PCR_allSigsBlocked, PCR_waitForever) != PCR_ERes_okay || code != 0) { GC_printf("Thread 2 failed\n"); } check_heap_stats(); return(0); } #endif #if defined(GC_PTHREADS) void * thr_run_one_test(void * arg GC_ATTR_UNUSED) { run_one_test(); return(0); } #ifdef GC_DEBUG # define GC_free GC_debug_free #endif int main(void) { pthread_t th[NTHREADS]; pthread_attr_t attr; int code; int i; # ifdef GC_IRIX_THREADS /* Force a larger stack to be preallocated */ /* Since the initial can't always grow later. */ *((volatile char *)&code - 1024*1024) = 0; /* Require 1 MB */ # endif /* GC_IRIX_THREADS */ # if defined(GC_HPUX_THREADS) /* Default stack size is too small, especially with the 64 bit ABI */ /* Increase it. */ if (pthread_default_stacksize_np(1024*1024, 0) != 0) { GC_printf("pthread_default_stacksize_np failed\n"); } # endif /* GC_HPUX_THREADS */ # ifdef PTW32_STATIC_LIB pthread_win32_process_attach_np (); pthread_win32_thread_attach_np (); # endif # if defined(GC_DARWIN_THREADS) && !defined(GC_NO_THREADS_DISCOVERY) \ && !defined(DARWIN_DONT_PARSE_STACK) && !defined(THREAD_LOCAL_ALLOC) /* Test with the Darwin implicit thread registration. */ GC_use_threads_discovery(); GC_printf("Using Darwin task-threads-based world stop and push\n"); # endif GC_COND_INIT(); if ((code = pthread_attr_init(&attr)) != 0) { GC_printf("pthread_attr_init failed, error=%d\n", code); FAIL; } # if defined(GC_IRIX_THREADS) || defined(GC_FREEBSD_THREADS) \ || defined(GC_DARWIN_THREADS) || defined(GC_AIX_THREADS) \ || defined(GC_OPENBSD_THREADS) if ((code = pthread_attr_setstacksize(&attr, 1000 * 1024)) != 0) { GC_printf("pthread_attr_setstacksize failed, error=%d\n", code); FAIL; } # endif n_tests = 0; # if (defined(MPROTECT_VDB)) && !defined(REDIRECT_MALLOC) \ && !defined(MAKE_BACK_GRAPH) && !defined(USE_PROC_FOR_LIBRARIES) \ && !defined(NO_INCREMENTAL) GC_enable_incremental(); GC_printf("Switched to incremental mode\n"); # if defined(MPROTECT_VDB) GC_printf("Emulating dirty bits with mprotect/signals\n"); # else # ifdef PROC_VDB GC_printf("Reading dirty bits from /proc\n"); # else GC_printf("Using DEFAULT_VDB dirty bit implementation\n"); # endif # endif # endif GC_set_warn_proc(warn_proc); if ((code = pthread_key_create(&fl_key, 0)) != 0) { GC_printf("Key creation failed %d\n", code); FAIL; } for (i = 0; i < NTHREADS; ++i) { if ((code = pthread_create(th+i, &attr, thr_run_one_test, 0)) != 0) { GC_printf("Thread %d creation failed %d\n", i, code); FAIL; } } run_one_test(); for (i = 0; i < NTHREADS; ++i) { if ((code = pthread_join(th[i], 0)) != 0) { GC_printf("Thread %d failed %d\n", i, code); FAIL; } } check_heap_stats(); (void)fflush(stdout); (void)pthread_attr_destroy(&attr); # ifdef PTW32_STATIC_LIB pthread_win32_thread_detach_np (); pthread_win32_process_detach_np (); # endif return(0); } #endif /* GC_PTHREADS */ ecl-16.1.2/src/bdwgc/tests/test_cpp.cc000066400000000000000000000210271266352375300175310ustar00rootroot00000000000000/**************************************************************************** Copyright (c) 1994 by Xerox Corporation. All rights reserved. THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED OR IMPLIED. ANY USE IS AT YOUR OWN RISK. Permission is hereby granted to use or copy this program for any purpose, provided the above notices are retained on all copies. Permission to modify the code and to distribute modified code is granted, provided the above notices are retained, and a notice that the code was modified is included with the above copyright notice. **************************************************************************** usage: test_cpp number-of-iterations This program tries to test the specific C++ functionality provided by gc_c++.h that isn't tested by the more general test routines of the collector. A recommended value for number-of-iterations is 10, which will take a few minutes to complete. ***************************************************************************/ #ifdef HAVE_CONFIG_H # include "config.h" #endif #undef GC_BUILD #include "gc_cpp.h" #include #include #include #ifndef DONT_USE_STD_ALLOCATOR # include "gc_allocator.h" #else /* Note: This works only for ancient STL versions. */ # include "new_gc_alloc.h" #endif extern "C" { # include "private/gcconfig.h" # ifndef GC_API_PRIV # define GC_API_PRIV GC_API # endif GC_API_PRIV void GC_printf(const char * format, ...); /* Use GC private output to reach the same log file. */ /* Don't include gc_priv.h, since that may include Windows system */ /* header files that don't take kindly to this context. */ } #ifdef MSWIN32 # include #endif #ifdef GC_NAME_CONFLICT # define USE_GC GC_NS_QUALIFY(UseGC) struct foo * GC; #else # define USE_GC GC_NS_QUALIFY(GC) #endif #define my_assert( e ) \ if (! (e)) { \ GC_printf( "Assertion failure in " __FILE__ ", line %d: " #e "\n", \ __LINE__ ); \ exit( 1 ); } #if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) # define ATTR_UNUSED __attribute__((__unused__)) #else # define ATTR_UNUSED /* empty */ #endif class A {public: /* An uncollectible class. */ A( int iArg ): i( iArg ) {} void Test( int iArg ) { my_assert( i == iArg );} int i;}; class B: public GC_NS_QUALIFY(gc), public A { public: /* A collectible class. */ B( int j ): A( j ) {} ~B() { my_assert( deleting );} static void Deleting( int on ) { deleting = on;} static int deleting;}; int B::deleting = 0; class C: public GC_NS_QUALIFY(gc_cleanup), public A { public: /* A collectible class with cleanup and virtual multiple inheritance. */ C( int levelArg ): A( levelArg ), level( levelArg ) { nAllocated++; if (level > 0) { left = new C( level - 1 ); right = new C( level - 1 );} else { left = right = 0;}} ~C() { this->A::Test( level ); nFreed++; my_assert( level == 0 ? left == 0 && right == 0 : level == left->level + 1 && level == right->level + 1 ); left = right = 0; level = -123456;} static void Test() { my_assert( nFreed <= nAllocated && nFreed >= .8 * nAllocated );} static int nFreed; static int nAllocated; int level; C* left; C* right;}; int C::nFreed = 0; int C::nAllocated = 0; class D: public GC_NS_QUALIFY(gc) { public: /* A collectible class with a static member function to be used as an explicit clean-up function supplied to ::new. */ D( int iArg ): i( iArg ) { nAllocated++;} static void CleanUp( void* obj, void* data ) { D* self = (D*) obj; nFreed++; my_assert( self->i == (int) (GC_word) data );} static void Test() { my_assert( nFreed >= .8 * nAllocated );} int i; static int nFreed; static int nAllocated;}; int D::nFreed = 0; int D::nAllocated = 0; class E: public GC_NS_QUALIFY(gc_cleanup) { public: /* A collectible class with clean-up for use by F. */ E() { nAllocated++;} ~E() { nFreed++;} static int nFreed; static int nAllocated;}; int E::nFreed = 0; int E::nAllocated = 0; class F: public E {public: /* A collectible class with clean-up, a base with clean-up, and a member with clean-up. */ F() { nAllocated++;} ~F() { nFreed++;} static void Test() { my_assert( nFreed >= .8 * nAllocated ); my_assert( 2 * nFreed == E::nFreed );} E e; static int nFreed; static int nAllocated;}; int F::nFreed = 0; int F::nAllocated = 0; GC_word Disguise( void* p ) { return ~ (GC_word) p;} void* Undisguise( GC_word i ) { return (void*) ~ i;} #ifdef MSWIN32 int APIENTRY WinMain( HINSTANCE instance ATTR_UNUSED, HINSTANCE prev ATTR_UNUSED, LPSTR cmd, int cmdShow ATTR_UNUSED ) { int argc = 0; char* argv[ 3 ]; if (cmd != 0) for (argc = 1; argc < (int)(sizeof(argv) / sizeof(argv[0])); argc++) { argv[ argc ] = strtok( argc == 1 ? cmd : 0, " \t" ); if (0 == argv[ argc ]) break;} #elif defined(MACOS) int main() { char* argv_[] = {"test_cpp", "10"}; // MacOS doesn't have a commandline argv = argv_; argc = sizeof(argv_)/sizeof(argv_[0]); #else int main( int argc, char* argv[] ) { #endif GC_set_all_interior_pointers(1); /* needed due to C++ multiple inheritance used */ GC_INIT(); int i, iters, n; # ifndef DONT_USE_STD_ALLOCATOR int *x = gc_allocator().allocate(1); int *xio; xio = gc_allocator_ignore_off_page().allocate(1); (void)xio; int **xptr = traceable_allocator().allocate(1); # else int *x = (int *)gc_alloc::allocate(sizeof(int)); # endif *x = 29; # ifndef DONT_USE_STD_ALLOCATOR if (!xptr) { fprintf(stderr, "Out of memory!\n"); exit(3); } *xptr = x; x = 0; # endif if (argc != 2 || (0 >= (n = atoi( argv[ 1 ] )))) { GC_printf( "usage: test_cpp number-of-iterations\nAssuming 10 iters\n" ); n = 10;} for (iters = 1; iters <= n; iters++) { GC_printf( "Starting iteration %d\n", iters ); /* Allocate some uncollectible As and disguise their pointers. Later we'll check to see if the objects are still there. We're checking to make sure these objects really are uncollectible. */ GC_word as[ 1000 ]; GC_word bs[ 1000 ]; for (i = 0; i < 1000; i++) { as[ i ] = Disguise( new (GC_NS_QUALIFY(NoGC)) A(i) ); bs[ i ] = Disguise( new (GC_NS_QUALIFY(NoGC)) B(i) ); } /* Allocate a fair number of finalizable Cs, Ds, and Fs. Later we'll check to make sure they've gone away. */ for (i = 0; i < 1000; i++) { C* c = new C( 2 ); C c1( 2 ); /* stack allocation should work too */ D* d; F* f; d = ::new (USE_GC, D::CleanUp, (void*)(GC_word)i) D( i ); (void)d; f = new F; (void)f; if (0 == i % 10) delete c;} /* Allocate a very large number of collectible As and Bs and drop the references to them immediately, forcing many collections. */ for (i = 0; i < 1000000; i++) { A* a; a = new (USE_GC) A( i ); (void)a; B* b; b = new B( i ); (void)b; b = new (USE_GC) B( i ); if (0 == i % 10) { B::Deleting( 1 ); delete b; B::Deleting( 0 );} # ifdef FINALIZE_ON_DEMAND GC_invoke_finalizers(); # endif } /* Make sure the uncollectible As and Bs are still there. */ for (i = 0; i < 1000; i++) { A* a = (A*) Undisguise( as[ i ] ); B* b = (B*) Undisguise( bs[ i ] ); a->Test( i ); delete a; b->Test( i ); B::Deleting( 1 ); delete b; B::Deleting( 0 ); # ifdef FINALIZE_ON_DEMAND GC_invoke_finalizers(); # endif } /* Make sure most of the finalizable Cs, Ds, and Fs have gone away. */ C::Test(); D::Test(); F::Test();} # ifndef DONT_USE_STD_ALLOCATOR x = *xptr; # endif my_assert (29 == x[0]); GC_printf( "The test appears to have succeeded.\n" ); return( 0 ); } ecl-16.1.2/src/bdwgc/tests/tests.am000066400000000000000000000074351266352375300170710ustar00rootroot00000000000000# # THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED # OR IMPLIED. ANY USE IS AT YOUR OWN RISK. # # Permission is hereby granted to use or copy this program # for any purpose, provided the above notices are retained on all copies. # Permission to modify the code and to distribute modified code is granted, # provided the above notices are retained, and a notice that the code was # modified is included with the above copyright notice. # Common libs to _LDADD for all tests. test_ldadd = $(top_builddir)/libgc.la $(EXTRA_TEST_LIBS) TESTS += gctest$(EXEEXT) check_PROGRAMS += gctest gctest_SOURCES = tests/test.c gctest_LDADD = $(test_ldadd) if THREADS gctest_LDADD += $(THREADDLLIBS) endif gctest_DEPENDENCIES = $(top_builddir)/libgc.la TESTS += leaktest$(EXEEXT) check_PROGRAMS += leaktest leaktest_SOURCES = tests/leak_test.c leaktest_LDADD = $(test_ldadd) TESTS += middletest$(EXEEXT) check_PROGRAMS += middletest middletest_SOURCES = tests/middle.c middletest_LDADD = $(test_ldadd) TESTS += smashtest$(EXEEXT) check_PROGRAMS += smashtest smashtest_SOURCES = tests/smash_test.c smashtest_LDADD = $(test_ldadd) TESTS += hugetest$(EXEEXT) check_PROGRAMS += hugetest hugetest_SOURCES = tests/huge_test.c hugetest_LDADD = $(test_ldadd) TESTS += realloc_test$(EXEEXT) check_PROGRAMS += realloc_test realloc_test_SOURCES = tests/realloc_test.c realloc_test_LDADD = $(test_ldadd) TESTS += staticrootstest$(EXEEXT) check_PROGRAMS += staticrootstest staticrootstest_SOURCES = tests/staticrootstest.c staticrootstest_CFLAGS = -DSTATICROOTSLIB2 staticrootstest_LDADD = $(test_ldadd) libstaticrootslib_test.la \ libstaticrootslib2_test.la check_LTLIBRARIES += libstaticrootslib_test.la libstaticrootslib2_test.la libstaticrootslib_test_la_SOURCES = tests/staticrootslib.c libstaticrootslib_test_la_LIBADD = $(test_ldadd) libstaticrootslib_test_la_LDFLAGS = -version-info 1:3:0 -no-undefined \ -rpath /nowhere libstaticrootslib_test_la_DEPENDENCIES = $(top_builddir)/libgc.la libstaticrootslib2_test_la_SOURCES = tests/staticrootslib.c libstaticrootslib2_test_la_LIBADD = $(test_ldadd) libstaticrootslib2_test_la_CFLAGS = -DSTATICROOTSLIB2 libstaticrootslib2_test_la_LDFLAGS = -version-info 1:3:0 -no-undefined \ -rpath /nowhere if KEEP_BACK_PTRS TESTS += tracetest$(EXEEXT) check_PROGRAMS += tracetest tracetest_SOURCES = tests/trace_test.c tracetest_LDADD = $(test_ldadd) endif if THREADS TESTS += threadleaktest$(EXEEXT) check_PROGRAMS += threadleaktest threadleaktest_SOURCES = tests/thread_leak_test.c threadleaktest_LDADD = $(test_ldadd) $(THREADDLLIBS) TESTS += threadkey_test$(EXEEXT) check_PROGRAMS += threadkey_test threadkey_test_SOURCES = tests/threadkey_test.c threadkey_test_LDADD = $(test_ldadd) $(THREADDLLIBS) TESTS += subthreadcreate_test$(EXEEXT) check_PROGRAMS += subthreadcreate_test subthreadcreate_test_SOURCES = tests/subthread_create.c subthreadcreate_test_LDADD = $(test_ldadd) $(THREADDLLIBS) TESTS += initsecondarythread_test$(EXEEXT) check_PROGRAMS += initsecondarythread_test initsecondarythread_test_SOURCES = tests/initsecondarythread.c initsecondarythread_test_LDADD = $(test_ldadd) $(THREADDLLIBS) endif if CPLUSPLUS TESTS += test_cpp$(EXEEXT) check_PROGRAMS += test_cpp test_cpp_SOURCES = tests/test_cpp.cc if AVOID_CPP_LIB test_cpp_LDADD = gc_cpp.o $(test_ldadd) $(CXXLIBS) else test_cpp_LDADD = libgccpp.la $(test_ldadd) $(CXXLIBS) endif endif if ENABLE_DISCLAIM TESTS += disclaim_test check_PROGRAMS += disclaim_test disclaim_test_SOURCES = tests/disclaim_test.c disclaim_test_LDADD = $(test_ldadd) if THREADS disclaim_test_LDADD += $(THREADDLLIBS) endif TESTS += disclaim_bench check_PROGRAMS += disclaim_bench disclaim_bench_SOURCES = tests/disclaim_bench.c disclaim_bench_LDADD = $(test_ldadd) endif ecl-16.1.2/src/bdwgc/tests/thread_leak_test.c000066400000000000000000000034221266352375300210460ustar00rootroot00000000000000 #ifdef HAVE_CONFIG_H # include "config.h" #endif #ifndef GC_THREADS # define GC_THREADS #endif #include "leak_detector.h" #ifdef GC_PTHREADS # include #else # include #endif #include #ifdef GC_PTHREADS void * test(void * arg) #else DWORD WINAPI test(LPVOID arg) #endif { int *p[10]; int i; for (i = 0; i < 10; ++i) { p[i] = malloc(sizeof(int)+i); } CHECK_LEAKS(); for (i = 1; i < 10; ++i) { free(p[i]); } # ifdef GC_PTHREADS return arg; # else return (DWORD)(GC_word)arg; # endif } #define NTHREADS 5 int main(void) { int i; # ifdef GC_PTHREADS pthread_t t[NTHREADS]; # else HANDLE t[NTHREADS]; DWORD thread_id; # endif int code; GC_set_find_leak(1); /* for new collect versions not compiled */ /* with -DFIND_LEAK. */ GC_INIT(); for (i = 0; i < NTHREADS; ++i) { # ifdef GC_PTHREADS code = pthread_create(t + i, 0, test, 0); # else t[i] = CreateThread(NULL, 0, test, 0, 0, &thread_id); code = t[i] != NULL ? 0 : (int)GetLastError(); # endif if (code != 0) { fprintf(stderr, "Thread creation failed %d\n", code); exit(2); } } for (i = 0; i < NTHREADS; ++i) { # ifdef GC_PTHREADS code = pthread_join(t[i], 0); # else code = WaitForSingleObject(t[i], INFINITE) == WAIT_OBJECT_0 ? 0 : (int)GetLastError(); # endif if (code != 0) { fprintf(stderr, "Thread join failed %d\n", code); exit(2); } } CHECK_LEAKS(); CHECK_LEAKS(); CHECK_LEAKS(); return 0; } ecl-16.1.2/src/bdwgc/tests/threadkey_test.c000066400000000000000000000040051266352375300205610ustar00rootroot00000000000000 #ifdef HAVE_CONFIG_H # include "config.h" #endif #ifndef GC_THREADS # define GC_THREADS #endif #define GC_NO_THREAD_REDIRECTS 1 #include "gc.h" #if (!defined(GC_PTHREADS) || defined(GC_SOLARIS_THREADS) \ || defined(__native_client__)) && !defined(SKIP_THREADKEY_TEST) /* FIXME: Skip this test on Solaris for now. The test may fail on */ /* other targets as well. Currently, tested only on Linux, Cygwin */ /* and Darwin. */ # define SKIP_THREADKEY_TEST #endif #ifdef SKIP_THREADKEY_TEST #include int main (void) { printf("threadkey_test skipped\n"); return 0; } #else #include pthread_key_t key; #ifdef GC_SOLARIS_THREADS /* pthread_once_t key_once = { PTHREAD_ONCE_INIT }; */ #else pthread_once_t key_once = PTHREAD_ONCE_INIT; #endif void * entry (void *arg) { pthread_setspecific(key, (void *)GC_HIDE_POINTER(GC_STRDUP("hello, world"))); return arg; } void * GC_CALLBACK on_thread_exit_inner (struct GC_stack_base * sb, void * arg) { int res = GC_register_my_thread (sb); pthread_t t; int creation_res; /* Used to suppress a warning about */ /* unchecked pthread_create() result. */ creation_res = GC_pthread_create (&t, NULL, entry, NULL); if (res == GC_SUCCESS) GC_unregister_my_thread (); return arg ? (void*)(GC_word)creation_res : 0; } void on_thread_exit (void *v) { GC_call_with_stack_base (on_thread_exit_inner, v); } void make_key (void) { pthread_key_create (&key, on_thread_exit); } #ifndef LIMIT # define LIMIT 30 #endif int main (void) { int i; GC_INIT (); # ifdef GC_SOLARIS_THREADS pthread_key_create (&key, on_thread_exit); # else pthread_once (&key_once, make_key); # endif for (i = 0; i < LIMIT; i++) { pthread_t t; void *res; if (GC_pthread_create (&t, NULL, entry, NULL) == 0 && (i & 1) != 0) { (void)GC_pthread_join(t, &res); } } return 0; } #endif /* !SKIP_THREADKEY_TEST */ ecl-16.1.2/src/bdwgc/tests/trace_test.c000066400000000000000000000014031266352375300176760ustar00rootroot00000000000000#include #include #ifndef GC_DEBUG # define GC_DEBUG #endif #include "gc.h" #include "gc_backptr.h" struct treenode { struct treenode *x; struct treenode *y; } * root[10]; struct treenode * mktree(int i) { struct treenode * r = GC_MALLOC(sizeof(struct treenode)); if (0 == i) return 0; if (1 == i) r = GC_MALLOC_ATOMIC(sizeof(struct treenode)); if (r == NULL) { fprintf(stderr, "Out of memory\n"); exit(1); } r -> x = mktree(i-1); r -> y = mktree(i-1); return r; } int main(void) { int i; GC_INIT(); for (i = 0; i < 10; ++i) { root[i] = mktree(12); } GC_generate_random_backtrace(); GC_generate_random_backtrace(); GC_generate_random_backtrace(); GC_generate_random_backtrace(); return 0; } ecl-16.1.2/src/bdwgc/thread_local_alloc.c000066400000000000000000000300361266352375300201760ustar00rootroot00000000000000/* * Copyright (c) 2000-2005 by Hewlett-Packard Company. All rights reserved. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. */ #include "private/gc_priv.h" #if defined(THREAD_LOCAL_ALLOC) #ifndef THREADS # error "invalid config - THREAD_LOCAL_ALLOC requires GC_THREADS" #endif #include "private/thread_local_alloc.h" #include #if defined(USE_COMPILER_TLS) __thread #elif defined(USE_WIN32_COMPILER_TLS) __declspec(thread) #endif GC_key_t GC_thread_key; static GC_bool keys_initialized; #ifdef ENABLE_DISCLAIM GC_INNER ptr_t * GC_finalized_objfreelist = NULL; /* This variable is declared here to prevent linking of */ /* fnlz_mlc module unless the client uses the latter one. */ #endif /* Return a single nonempty freelist fl to the global one pointed to */ /* by gfl. */ static void return_single_freelist(void *fl, void **gfl) { void *q, **qptr; if (*gfl == 0) { *gfl = fl; } else { GC_ASSERT(GC_size(fl) == GC_size(*gfl)); /* Concatenate: */ qptr = &(obj_link(fl)); while ((word)(q = *qptr) >= HBLKSIZE) qptr = &(obj_link(q)); GC_ASSERT(0 == q); *qptr = *gfl; *gfl = fl; } } /* Recover the contents of the freelist array fl into the global one gfl.*/ /* We hold the allocator lock. */ static void return_freelists(void **fl, void **gfl) { int i; for (i = 1; i < TINY_FREELISTS; ++i) { if ((word)(fl[i]) >= HBLKSIZE) { return_single_freelist(fl[i], gfl+i); } /* Clear fl[i], since the thread structure may hang around. */ /* Do it in a way that is likely to trap if we access it. */ fl[i] = (ptr_t)HBLKSIZE; } /* The 0 granule freelist really contains 1 granule objects. */ # ifdef GC_GCJ_SUPPORT if (fl[0] == ERROR_FL) return; # endif if ((word)(fl[0]) >= HBLKSIZE) { return_single_freelist(fl[0], gfl+1); } } /* Each thread structure must be initialized. */ /* This call must be made from the new thread. */ GC_INNER void GC_init_thread_local(GC_tlfs p) { int i; GC_ASSERT(I_HOLD_LOCK()); if (!EXPECT(keys_initialized, TRUE)) { GC_ASSERT((word)&GC_thread_key % sizeof(word) == 0); if (0 != GC_key_create(&GC_thread_key, 0)) { ABORT("Failed to create key for local allocator"); } keys_initialized = TRUE; } if (0 != GC_setspecific(GC_thread_key, p)) { ABORT("Failed to set thread specific allocation pointers"); } for (i = 1; i < TINY_FREELISTS; ++i) { p -> ptrfree_freelists[i] = (void *)(word)1; p -> normal_freelists[i] = (void *)(word)1; # ifdef GC_GCJ_SUPPORT p -> gcj_freelists[i] = (void *)(word)1; # endif # ifdef ENABLE_DISCLAIM p -> finalized_freelists[i] = (void *)(word)1; # endif } /* Set up the size 0 free lists. */ /* We now handle most of them like regular free lists, to ensure */ /* That explicit deallocation works. However, allocation of a */ /* size 0 "gcj" object is always an error. */ p -> ptrfree_freelists[0] = (void *)(word)1; p -> normal_freelists[0] = (void *)(word)1; # ifdef GC_GCJ_SUPPORT p -> gcj_freelists[0] = ERROR_FL; # endif # ifdef ENABLE_DISCLAIM p -> finalized_freelists[0] = (void *)(word)1; # endif } /* We hold the allocator lock. */ GC_INNER void GC_destroy_thread_local(GC_tlfs p) { /* We currently only do this from the thread itself or from */ /* the fork handler for a child process. */ return_freelists(p -> ptrfree_freelists, GC_aobjfreelist); return_freelists(p -> normal_freelists, GC_objfreelist); # ifdef GC_GCJ_SUPPORT return_freelists(p -> gcj_freelists, (void **)GC_gcjobjfreelist); # endif # ifdef ENABLE_DISCLAIM return_freelists(p -> finalized_freelists, (void **)GC_finalized_objfreelist); # endif } #ifdef GC_ASSERTIONS /* Defined in pthread_support.c or win32_threads.c. */ GC_bool GC_is_thread_tsd_valid(void *tsd); #endif GC_API GC_ATTR_MALLOC void * GC_CALL GC_malloc(size_t bytes) { size_t granules = ROUNDED_UP_GRANULES(bytes); void *tsd; void *result; void **tiny_fl; # if !defined(USE_PTHREAD_SPECIFIC) && !defined(USE_WIN32_SPECIFIC) GC_key_t k = GC_thread_key; if (EXPECT(0 == k, FALSE)) { /* We haven't yet run GC_init_parallel. That means */ /* we also aren't locking, so this is fairly cheap. */ return GC_core_malloc(bytes); } tsd = GC_getspecific(k); # else tsd = GC_getspecific(GC_thread_key); # endif # if !defined(USE_COMPILER_TLS) && !defined(USE_WIN32_COMPILER_TLS) if (EXPECT(0 == tsd, FALSE)) { return GC_core_malloc(bytes); } # endif GC_ASSERT(GC_is_initialized); GC_ASSERT(GC_is_thread_tsd_valid(tsd)); tiny_fl = ((GC_tlfs)tsd) -> normal_freelists; GC_FAST_MALLOC_GRANS(result, granules, tiny_fl, DIRECT_GRANULES, NORMAL, GC_core_malloc(bytes), obj_link(result)=0); # ifdef LOG_ALLOCS GC_log_printf("GC_malloc(%lu) returned %p, recent GC #%lu\n", (unsigned long)bytes, result, (unsigned long)GC_gc_no); # endif return result; } GC_API GC_ATTR_MALLOC void * GC_CALL GC_malloc_atomic(size_t bytes) { size_t granules = ROUNDED_UP_GRANULES(bytes); void *tsd; void *result; void **tiny_fl; # if !defined(USE_PTHREAD_SPECIFIC) && !defined(USE_WIN32_SPECIFIC) GC_key_t k = GC_thread_key; if (EXPECT(0 == k, FALSE)) { /* We haven't yet run GC_init_parallel. That means */ /* we also aren't locking, so this is fairly cheap. */ return GC_core_malloc_atomic(bytes); } tsd = GC_getspecific(k); # else tsd = GC_getspecific(GC_thread_key); # endif # if !defined(USE_COMPILER_TLS) && !defined(USE_WIN32_COMPILER_TLS) if (EXPECT(0 == tsd, FALSE)) { return GC_core_malloc_atomic(bytes); } # endif GC_ASSERT(GC_is_initialized); tiny_fl = ((GC_tlfs)tsd) -> ptrfree_freelists; GC_FAST_MALLOC_GRANS(result, granules, tiny_fl, DIRECT_GRANULES, PTRFREE, GC_core_malloc_atomic(bytes), (void)0 /* no init */); return result; } #ifdef GC_GCJ_SUPPORT # include "atomic_ops.h" /* for AO_compiler_barrier() */ # include "include/gc_gcj.h" /* Gcj-style allocation without locks is extremely tricky. The */ /* fundamental issue is that we may end up marking a free list, which */ /* has freelist links instead of "vtable" pointers. That is usually */ /* OK, since the next object on the free list will be cleared, and */ /* will thus be interpreted as containing a zero descriptor. That's */ /* fine if the object has not yet been initialized. But there are */ /* interesting potential races. */ /* In the case of incremental collection, this seems hopeless, since */ /* the marker may run asynchronously, and may pick up the pointer to */ /* the next freelist entry (which it thinks is a vtable pointer), get */ /* suspended for a while, and then see an allocated object instead */ /* of the vtable. This may be avoidable with either a handshake with */ /* the collector or, probably more easily, by moving the free list */ /* links to the second word of each object. The latter isn't a */ /* universal win, since on architecture like Itanium, nonzero offsets */ /* are not necessarily free. And there may be cache fill order issues. */ /* For now, we punt with incremental GC. This probably means that */ /* incremental GC should be enabled before we fork a second thread. */ /* Unlike the other thread local allocation calls, we assume that the */ /* collector has been explicitly initialized. */ GC_API GC_ATTR_MALLOC void * GC_CALL GC_gcj_malloc(size_t bytes, void * ptr_to_struct_containing_descr) { if (EXPECT(GC_incremental, FALSE)) { return GC_core_gcj_malloc(bytes, ptr_to_struct_containing_descr); } else { size_t granules = ROUNDED_UP_GRANULES(bytes); void *result; void **tiny_fl = ((GC_tlfs)GC_getspecific(GC_thread_key)) -> gcj_freelists; GC_ASSERT(GC_gcj_malloc_initialized); GC_FAST_MALLOC_GRANS(result, granules, tiny_fl, DIRECT_GRANULES, GC_gcj_kind, GC_core_gcj_malloc(bytes, ptr_to_struct_containing_descr), {AO_compiler_barrier(); *(void **)result = ptr_to_struct_containing_descr;}); /* This forces the initialization of the "method ptr". */ /* This is necessary to ensure some very subtle properties */ /* required if a GC is run in the middle of such an allocation. */ /* Here we implicitly also assume atomicity for the free list. */ /* and method pointer assignments. */ /* We must update the freelist before we store the pointer. */ /* Otherwise a GC at this point would see a corrupted */ /* free list. */ /* A real memory barrier is not needed, since the */ /* action of stopping this thread will cause prior writes */ /* to complete. */ /* We assert that any concurrent marker will stop us. */ /* Thus it is impossible for a mark procedure to see the */ /* allocation of the next object, but to see this object */ /* still containing a free list pointer. Otherwise the */ /* marker, by misinterpreting the freelist link as a vtable */ /* pointer, might find a random "mark descriptor" in the next */ /* object. */ return result; } } #endif /* GC_GCJ_SUPPORT */ /* The thread support layer must arrange to mark thread-local */ /* free lists explicitly, since the link field is often */ /* invisible to the marker. It knows how to find all threads; */ /* we take care of an individual thread freelist structure. */ GC_INNER void GC_mark_thread_local_fls_for(GC_tlfs p) { ptr_t q; int j; for (j = 0; j < TINY_FREELISTS; ++j) { q = p -> ptrfree_freelists[j]; if ((word)q > HBLKSIZE) GC_set_fl_marks(q); q = p -> normal_freelists[j]; if ((word)q > HBLKSIZE) GC_set_fl_marks(q); # ifdef GC_GCJ_SUPPORT if (j > 0) { q = p -> gcj_freelists[j]; if ((word)q > HBLKSIZE) GC_set_fl_marks(q); } # endif /* GC_GCJ_SUPPORT */ # ifdef ENABLE_DISCLAIM q = p -> finalized_freelists[j]; if ((word)q > HBLKSIZE) GC_set_fl_marks(q); # endif } } #if defined(GC_ASSERTIONS) /* Check that all thread-local free-lists in p are completely marked. */ void GC_check_tls_for(GC_tlfs p) { int j; for (j = 1; j < TINY_FREELISTS; ++j) { GC_check_fl_marks(&p->ptrfree_freelists[j]); GC_check_fl_marks(&p->normal_freelists[j]); # ifdef GC_GCJ_SUPPORT GC_check_fl_marks(&p->gcj_freelists[j]); # endif # ifdef ENABLE_DISCLAIM GC_check_fl_marks(&p->finalized_freelists[j]); # endif } } #endif /* GC_ASSERTIONS */ #endif /* THREAD_LOCAL_ALLOC */ ecl-16.1.2/src/bdwgc/tools/000077500000000000000000000000001266352375300153755ustar00rootroot00000000000000ecl-16.1.2/src/bdwgc/tools/add_gc_prefix.c000066400000000000000000000003721266352375300203210ustar00rootroot00000000000000# include # include int main(int argc, char ** argv) { int i; for (i = 1; i < argc; i++) { printf("gc-%d.%d.%d/%s ", GC_VERSION_MAJOR, GC_VERSION_MINOR, GC_VERSION_MICRO, argv[i]); } return(0); } ecl-16.1.2/src/bdwgc/tools/callprocs.sh000077500000000000000000000002241266352375300177140ustar00rootroot00000000000000#!/bin/sh GC_DEBUG=1 export GC_DEBUG $* 2>&1 | awk '{print "0x3e=c\""$0"\""};/^\t##PC##=/ {if ($2 != 0) {print $2"?i"}}' | adb $1 | sed "s/^ >/>/" ecl-16.1.2/src/bdwgc/tools/gcname.c000066400000000000000000000002411266352375300167700ustar00rootroot00000000000000#include #include int main(void) { printf("gc-%d.%d.%d", GC_VERSION_MAJOR, GC_VERSION_MINOR, GC_VERSION_MICRO); return 0; } ecl-16.1.2/src/bdwgc/tools/if_mach.c000066400000000000000000000013271266352375300171320ustar00rootroot00000000000000/* Conditionally execute a command based on machine and OS from gcconfig.h */ # include "private/gc_priv.h" # include # include # include int main(int argc, char **argv) { if (argc < 4) goto Usage; if (strcmp(MACH_TYPE, argv[1]) != 0) return(0); if (strcmp(OS_TYPE, "") != 0 && strcmp(argv[2], "") != 0 && strcmp(OS_TYPE, argv[2]) != 0) return(0); fprintf(stderr, "^^^^Starting command^^^^\n"); fflush(stdout); execvp(argv[3], argv+3); perror("Couldn't execute"); Usage: fprintf(stderr, "Usage: %s mach_type os_type command\n", argv[0]); fprintf(stderr, "Currently mach_type = %s, os_type = %s\n", MACH_TYPE, OS_TYPE); return(1); } ecl-16.1.2/src/bdwgc/tools/if_not_there.c000066400000000000000000000015571266352375300202160ustar00rootroot00000000000000/* Conditionally execute a command based if the file argv[1] doesn't exist */ /* Except for execvp, we stick to ANSI C. */ # include "private/gc_priv.h" # include # include # include #ifdef __DJGPP__ #include #endif /* __DJGPP__ */ int main(int argc, char **argv) { FILE * f; #ifdef __DJGPP__ DIR * d; #endif /* __DJGPP__ */ if (argc < 3) goto Usage; if ((f = fopen(argv[1], "rb")) != 0 || (f = fopen(argv[1], "r")) != 0) { fclose(f); return(0); } #ifdef __DJGPP__ if ((d = opendir(argv[1])) != 0) { closedir(d); return(0); } #endif printf("^^^^Starting command^^^^\n"); fflush(stdout); execvp(argv[2], argv+2); exit(1); Usage: fprintf(stderr, "Usage: %s file_name command\n", argv[0]); return(1); } ecl-16.1.2/src/bdwgc/tools/setjmp_t.c000066400000000000000000000110631266352375300173670ustar00rootroot00000000000000/* * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. */ /* Check whether setjmp actually saves registers in jmp_buf. */ /* If it doesn't, the generic mark_regs code won't work. */ /* Compilers vary as to whether they will put x in a */ /* (callee-save) register without -O. The code is */ /* contrived such that any decent compiler should put x in */ /* a callee-save register with -O. Thus it is */ /* recommended that this be run optimized. (If the machine */ /* has no callee-save registers, then the generic code is */ /* safe, but this will not be noticed by this piece of */ /* code.) This test appears to be far from perfect. */ #include #include #include #include "private/gc_priv.h" #ifdef OS2 /* GETPAGESIZE() is set to getpagesize() by default, but that */ /* doesn't really exist, and the collector doesn't need it. */ #define INCL_DOSFILEMGR #define INCL_DOSMISC #define INCL_DOSERRORS #include int getpagesize(void) { ULONG result[1]; if (DosQuerySysInfo(QSV_PAGE_SIZE, QSV_PAGE_SIZE, (void *)result, sizeof(ULONG)) != NO_ERROR) { fprintf(stderr, "DosQuerySysInfo failed\n"); result[0] = 4096; } return((int)(result[0])); } #elif defined(MSWIN32) || defined(MSWINCE) || defined(CYGWIN32) # include int getpagesize(void) { SYSTEM_INFO sysinfo; GetSystemInfo(&sysinfo); return sysinfo.dwPageSize; } #endif struct { char a_a; char * a_b; } a; int * nested_sp(void) { volatile word sp; sp = (word)(&sp); return (int *)sp; } int main(void) { volatile word sp; long ps = GETPAGESIZE(); jmp_buf b; register int x = (int)strlen("a"); /* 1, slightly disguised */ static int y = 0; sp = (word)(&sp); printf("This appears to be a %s running %s\n", MACH_TYPE, OS_TYPE); if ((word)nested_sp() < sp) { printf("Stack appears to grow down, which is the default.\n"); printf("A good guess for STACKBOTTOM on this machine is 0x%lx.\n", ((unsigned long)sp + ps) & ~(ps-1)); } else { printf("Stack appears to grow up.\n"); printf("Define STACK_GROWS_UP in gc_private.h\n"); printf("A good guess for STACKBOTTOM on this machine is 0x%lx.\n", ((unsigned long)sp + ps) & ~(ps-1)); } printf("Note that this may vary between machines of ostensibly\n"); printf("the same architecture (e.g. Sun 3/50s and 3/80s).\n"); printf("On many machines the value is not fixed.\n"); printf("A good guess for ALIGNMENT on this machine is %ld.\n", (unsigned long)((word)(&(a.a_b)) - (word)(&a))); printf("The following is a very dubious test of one root marking" " strategy.\n"); printf("Results may not be accurate/useful:\n"); /* Encourage the compiler to keep x in a callee-save register */ x = 2*x-1; printf("\n"); x = 2*x-1; setjmp(b); if (y == 1) { if (x == 2) { printf("Setjmp-based generic mark_regs code probably wont work.\n"); printf("But we rarely try that anymore. If you have getcontect()\n"); printf("this probably doesn't matter.\n"); } else if (x == 1) { printf("Setjmp-based register marking code may work.\n"); } else { printf("Very strange setjmp implementation.\n"); } } y++; x = 2; if (y == 1) longjmp(b,1); printf("Some GC internal configuration stuff: \n"); printf("\tWORDSZ = %lu, ALIGNMENT = %d, GC_GRANULE_BYTES = %d\n", (unsigned long)WORDSZ, ALIGNMENT, GC_GRANULE_BYTES); printf("\tUsing one mark "); # if defined(USE_MARK_BYTES) printf("byte"); # else printf("bit"); # endif printf(" per "); # if defined(MARK_BIT_PER_OBJ) printf("object.\n"); # elif defined(MARK_BIT_PER_GRANULE) printf("granule.\n"); # endif # ifdef THREAD_LOCAL_ALLOC printf("Thread local allocation enabled.\n"); # endif # ifdef PARALLEL_MARK printf("Parallel marking enabled.\n"); # endif return(0); } int g(int x) { return(x); } ecl-16.1.2/src/bdwgc/tools/threadlibs.c000066400000000000000000000053631266352375300176710ustar00rootroot00000000000000/* * Copyright (c) 1994 by Xerox Corporation. All rights reserved. * Copyright (c) 1996 by Silicon Graphics. All rights reserved. * Copyright (c) 1998 by Fergus Henderson. All rights reserved. * Copyright (c) 2000-2010 by Hewlett-Packard Development Company. * All rights reserved. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. */ # include "private/gc_priv.h" # include int main(void) { # if defined(GC_USE_LD_WRAP) printf("-Wl,--wrap -Wl,dlopen " "-Wl,--wrap -Wl,pthread_create -Wl,--wrap -Wl,pthread_join " "-Wl,--wrap -Wl,pthread_detach -Wl,--wrap -Wl,pthread_sigmask " "-Wl,--wrap -Wl,pthread_exit -Wl,--wrap -Wl,pthread_cancel\n"); # endif # if (defined(GC_LINUX_THREADS) && !defined(PLATFORM_ANDROID)) \ || defined(GC_IRIX_THREADS) || defined(GC_DARWIN_THREADS) \ || defined(GC_AIX_THREADS) || defined(GC_GNU_THREADS) # ifdef GC_USE_DLOPEN_WRAP printf("-ldl "); # endif printf("-lpthread\n"); # endif # if defined(GC_OPENBSD_THREADS) printf("-pthread\n"); # endif # if defined(GC_FREEBSD_THREADS) # ifdef GC_USE_DLOPEN_WRAP printf("-ldl "); # endif # if (__FREEBSD_version >= 500000) printf("-lpthread\n"); # else printf("-pthread\n"); # endif # endif # if defined(GC_NETBSD_THREADS) printf("-lpthread -lrt\n"); # endif # if defined(GC_HPUX_THREADS) || defined(GC_OSF1_THREADS) printf("-lpthread -lrt\n"); # endif # if defined(GC_SOLARIS_THREADS) printf("-lthread -lposix4\n"); /* Is this right for recent versions? */ # endif # if defined(GC_WIN32_THREADS) && defined(CYGWIN32) printf("-lpthread\n"); # endif # if defined(GC_WIN32_PTHREADS) # ifdef PTW32_STATIC_LIB /* assume suffix s for static version of the win32 pthread library */ printf("-lpthreadGC2s -lws2_32\n"); # else printf("-lpthreadGC2\n"); # endif # endif # if defined(GC_OSF1_THREADS) printf("-pthread -lrt"); /* DOB: must be -pthread, not -lpthread */ # endif /* You need GCC 3.0.3 to build this one! */ /* DG/UX native gcc doesn't know what "-pthread" is */ # if defined(GC_DGUX386_THREADS) printf("-ldl -pthread\n"); # endif return 0; } ecl-16.1.2/src/bdwgc/typd_mlc.c000066400000000000000000000660571266352375300162320ustar00rootroot00000000000000/* * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. * Copyright (c) 1999-2000 by Hewlett-Packard Company. All rights reserved. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. * */ #include "private/gc_pmark.h" /* * Some simple primitives for allocation with explicit type information. * Simple objects are allocated such that they contain a GC_descr at the * end (in the last allocated word). This descriptor may be a procedure * which then examines an extended descriptor passed as its environment. * * Arrays are treated as simple objects if they have sufficiently simple * structure. Otherwise they are allocated from an array kind that supplies * a special mark procedure. These arrays contain a pointer to a * complex_descriptor as their last word. * This is done because the environment field is too small, and the collector * must trace the complex_descriptor. * * Note that descriptors inside objects may appear cleared, if we encounter a * false reference to an object on a free list. In the GC_descr case, this * is OK, since a 0 descriptor corresponds to examining no fields. * In the complex_descriptor case, we explicitly check for that case. * * MAJOR PARTS OF THIS CODE HAVE NOT BEEN TESTED AT ALL and are not testable, * since they are not accessible through the current interface. */ #include "gc_typed.h" #define TYPD_EXTRA_BYTES (sizeof(word) - EXTRA_BYTES) STATIC GC_bool GC_explicit_typing_initialized = FALSE; STATIC int GC_explicit_kind = 0; /* Object kind for objects with indirect */ /* (possibly extended) descriptors. */ STATIC int GC_array_kind = 0; /* Object kind for objects with complex */ /* descriptors and GC_array_mark_proc. */ /* Extended descriptors. GC_typed_mark_proc understands these. */ /* These are used for simple objects that are larger than what */ /* can be described by a BITMAP_BITS sized bitmap. */ typedef struct { word ed_bitmap; /* lsb corresponds to first word. */ GC_bool ed_continued; /* next entry is continuation. */ } ext_descr; /* Array descriptors. GC_array_mark_proc understands these. */ /* We may eventually need to add provisions for headers and */ /* trailers. Hence we provide for tree structured descriptors, */ /* though we don't really use them currently. */ typedef union ComplexDescriptor { struct LeafDescriptor { /* Describes simple array */ word ld_tag; # define LEAF_TAG 1 size_t ld_size; /* bytes per element */ /* multiple of ALIGNMENT */ size_t ld_nelements; /* Number of elements. */ GC_descr ld_descriptor; /* A simple length, bitmap, */ /* or procedure descriptor. */ } ld; struct ComplexArrayDescriptor { word ad_tag; # define ARRAY_TAG 2 size_t ad_nelements; union ComplexDescriptor * ad_element_descr; } ad; struct SequenceDescriptor { word sd_tag; # define SEQUENCE_TAG 3 union ComplexDescriptor * sd_first; union ComplexDescriptor * sd_second; } sd; } complex_descriptor; #define TAG ld.ld_tag STATIC ext_descr * GC_ext_descriptors = NULL; /* Points to array of extended */ /* descriptors. */ STATIC size_t GC_ed_size = 0; /* Current size of above arrays. */ #define ED_INITIAL_SIZE 100 STATIC size_t GC_avail_descr = 0; /* Next available slot. */ STATIC int GC_typed_mark_proc_index = 0; /* Indices of my mark */ STATIC int GC_array_mark_proc_index = 0; /* procedures. */ STATIC void GC_push_typed_structures_proc(void) { GC_push_all((ptr_t)&GC_ext_descriptors, (ptr_t)&GC_ext_descriptors + sizeof(word)); } /* Add a multiword bitmap to GC_ext_descriptors arrays. Return */ /* starting index. */ /* Returns -1 on failure. */ /* Caller does not hold allocation lock. */ STATIC signed_word GC_add_ext_descriptor(const GC_word * bm, word nbits) { size_t nwords = divWORDSZ(nbits + WORDSZ-1); signed_word result; size_t i; word last_part; size_t extra_bits; DCL_LOCK_STATE; LOCK(); while (GC_avail_descr + nwords >= GC_ed_size) { ext_descr * new; size_t new_size; word ed_size = GC_ed_size; if (ed_size == 0) { GC_ASSERT((word)&GC_ext_descriptors % sizeof(word) == 0); GC_push_typed_structures = GC_push_typed_structures_proc; UNLOCK(); new_size = ED_INITIAL_SIZE; } else { UNLOCK(); new_size = 2 * ed_size; if (new_size > MAX_ENV) return(-1); } new = (ext_descr *) GC_malloc_atomic(new_size * sizeof(ext_descr)); if (new == 0) return(-1); LOCK(); if (ed_size == GC_ed_size) { if (GC_avail_descr != 0) { BCOPY(GC_ext_descriptors, new, GC_avail_descr * sizeof(ext_descr)); } GC_ed_size = new_size; GC_ext_descriptors = new; } /* else another thread already resized it in the meantime */ } result = GC_avail_descr; for (i = 0; i < nwords-1; i++) { GC_ext_descriptors[result + i].ed_bitmap = bm[i]; GC_ext_descriptors[result + i].ed_continued = TRUE; } last_part = bm[i]; /* Clear irrelevant bits. */ extra_bits = nwords * WORDSZ - nbits; last_part <<= extra_bits; last_part >>= extra_bits; GC_ext_descriptors[result + i].ed_bitmap = last_part; GC_ext_descriptors[result + i].ed_continued = FALSE; GC_avail_descr += nwords; UNLOCK(); return(result); } /* Table of bitmap descriptors for n word long all pointer objects. */ STATIC GC_descr GC_bm_table[WORDSZ/2]; /* Return a descriptor for the concatenation of 2 nwords long objects, */ /* each of which is described by descriptor. */ /* The result is known to be short enough to fit into a bitmap */ /* descriptor. */ /* Descriptor is a GC_DS_LENGTH or GC_DS_BITMAP descriptor. */ STATIC GC_descr GC_double_descr(GC_descr descriptor, word nwords) { if ((descriptor & GC_DS_TAGS) == GC_DS_LENGTH) { descriptor = GC_bm_table[BYTES_TO_WORDS((word)descriptor)]; }; descriptor |= (descriptor & ~GC_DS_TAGS) >> nwords; return(descriptor); } STATIC complex_descriptor * GC_make_sequence_descriptor(complex_descriptor *first, complex_descriptor *second); /* Build a descriptor for an array with nelements elements, */ /* each of which can be described by a simple descriptor. */ /* We try to optimize some common cases. */ /* If the result is COMPLEX, then a complex_descr* is returned */ /* in *complex_d. */ /* If the result is LEAF, then we built a LeafDescriptor in */ /* the structure pointed to by leaf. */ /* The tag in the leaf structure is not set. */ /* If the result is SIMPLE, then a GC_descr */ /* is returned in *simple_d. */ /* If the result is NO_MEM, then */ /* we failed to allocate the descriptor. */ /* The implementation knows that GC_DS_LENGTH is 0. */ /* *leaf, *complex_d, and *simple_d may be used as temporaries */ /* during the construction. */ #define COMPLEX 2 #define LEAF 1 #define SIMPLE 0 #define NO_MEM (-1) STATIC int GC_make_array_descriptor(size_t nelements, size_t size, GC_descr descriptor, GC_descr *simple_d, complex_descriptor **complex_d, struct LeafDescriptor * leaf) { # define OPT_THRESHOLD 50 /* For larger arrays, we try to combine descriptors of adjacent */ /* descriptors to speed up marking, and to reduce the amount */ /* of space needed on the mark stack. */ if ((descriptor & GC_DS_TAGS) == GC_DS_LENGTH) { if (descriptor == (GC_descr)size) { *simple_d = nelements * descriptor; return(SIMPLE); } else if ((word)descriptor == 0) { *simple_d = (GC_descr)0; return(SIMPLE); } } if (nelements <= OPT_THRESHOLD) { if (nelements <= 1) { if (nelements == 1) { *simple_d = descriptor; return(SIMPLE); } else { *simple_d = (GC_descr)0; return(SIMPLE); } } } else if (size <= BITMAP_BITS/2 && (descriptor & GC_DS_TAGS) != GC_DS_PROC && (size & (sizeof(word)-1)) == 0) { int result = GC_make_array_descriptor(nelements/2, 2*size, GC_double_descr(descriptor, BYTES_TO_WORDS(size)), simple_d, complex_d, leaf); if ((nelements & 1) == 0) { return(result); } else { struct LeafDescriptor * one_element = (struct LeafDescriptor *) GC_malloc_atomic(sizeof(struct LeafDescriptor)); if (result == NO_MEM || one_element == 0) return(NO_MEM); one_element -> ld_tag = LEAF_TAG; one_element -> ld_size = size; one_element -> ld_nelements = 1; one_element -> ld_descriptor = descriptor; switch(result) { case SIMPLE: { struct LeafDescriptor * beginning = (struct LeafDescriptor *) GC_malloc_atomic(sizeof(struct LeafDescriptor)); if (beginning == 0) return(NO_MEM); beginning -> ld_tag = LEAF_TAG; beginning -> ld_size = size; beginning -> ld_nelements = 1; beginning -> ld_descriptor = *simple_d; *complex_d = GC_make_sequence_descriptor( (complex_descriptor *)beginning, (complex_descriptor *)one_element); break; } case LEAF: { struct LeafDescriptor * beginning = (struct LeafDescriptor *) GC_malloc_atomic(sizeof(struct LeafDescriptor)); if (beginning == 0) return(NO_MEM); beginning -> ld_tag = LEAF_TAG; beginning -> ld_size = leaf -> ld_size; beginning -> ld_nelements = leaf -> ld_nelements; beginning -> ld_descriptor = leaf -> ld_descriptor; *complex_d = GC_make_sequence_descriptor( (complex_descriptor *)beginning, (complex_descriptor *)one_element); break; } case COMPLEX: *complex_d = GC_make_sequence_descriptor( *complex_d, (complex_descriptor *)one_element); break; } return(COMPLEX); } } leaf -> ld_size = size; leaf -> ld_nelements = nelements; leaf -> ld_descriptor = descriptor; return(LEAF); } STATIC complex_descriptor * GC_make_sequence_descriptor(complex_descriptor *first, complex_descriptor *second) { struct SequenceDescriptor * result = (struct SequenceDescriptor *) GC_malloc(sizeof(struct SequenceDescriptor)); /* Can't result in overly conservative marking, since tags are */ /* very small integers. Probably faster than maintaining type */ /* info. */ if (result != 0) { result -> sd_tag = SEQUENCE_TAG; result -> sd_first = first; result -> sd_second = second; } return((complex_descriptor *)result); } #ifdef UNDEFINED complex_descriptor * GC_make_complex_array_descriptor(word nelements, complex_descriptor *descr) { struct ComplexArrayDescriptor * result = (struct ComplexArrayDescriptor *) GC_malloc(sizeof(struct ComplexArrayDescriptor)); if (result != 0) { result -> ad_tag = ARRAY_TAG; result -> ad_nelements = nelements; result -> ad_element_descr = descr; } return((complex_descriptor *)result); } #endif STATIC ptr_t * GC_eobjfreelist = NULL; STATIC ptr_t * GC_arobjfreelist = NULL; STATIC mse * GC_typed_mark_proc(word * addr, mse * mark_stack_ptr, mse * mark_stack_limit, word env); STATIC mse * GC_array_mark_proc(word * addr, mse * mark_stack_ptr, mse * mark_stack_limit, word env); /* Caller does not hold allocation lock. */ STATIC void GC_init_explicit_typing(void) { register unsigned i; DCL_LOCK_STATE; GC_STATIC_ASSERT(sizeof(struct LeafDescriptor) % sizeof(word) == 0); LOCK(); if (GC_explicit_typing_initialized) { UNLOCK(); return; } GC_explicit_typing_initialized = TRUE; /* Set up object kind with simple indirect descriptor. */ GC_eobjfreelist = (ptr_t *)GC_new_free_list_inner(); GC_explicit_kind = GC_new_kind_inner( (void **)GC_eobjfreelist, (WORDS_TO_BYTES((word)-1) | GC_DS_PER_OBJECT), TRUE, TRUE); /* Descriptors are in the last word of the object. */ GC_typed_mark_proc_index = GC_new_proc_inner(GC_typed_mark_proc); /* Set up object kind with array descriptor. */ GC_arobjfreelist = (ptr_t *)GC_new_free_list_inner(); GC_array_mark_proc_index = GC_new_proc_inner(GC_array_mark_proc); GC_array_kind = GC_new_kind_inner( (void **)GC_arobjfreelist, GC_MAKE_PROC(GC_array_mark_proc_index, 0), FALSE, TRUE); for (i = 0; i < WORDSZ/2; i++) { GC_bm_table[i] = (((word)-1) << (WORDSZ - i)) | GC_DS_BITMAP; } UNLOCK(); } STATIC mse * GC_typed_mark_proc(word * addr, mse * mark_stack_ptr, mse * mark_stack_limit, word env) { word bm = GC_ext_descriptors[env].ed_bitmap; word * current_p = addr; word current; ptr_t greatest_ha = GC_greatest_plausible_heap_addr; ptr_t least_ha = GC_least_plausible_heap_addr; DECLARE_HDR_CACHE; INIT_HDR_CACHE; for (; bm != 0; bm >>= 1, current_p++) { if (bm & 1) { current = *current_p; FIXUP_POINTER(current); if (current >= (word)least_ha && current <= (word)greatest_ha) { PUSH_CONTENTS((ptr_t)current, mark_stack_ptr, mark_stack_limit, (ptr_t)current_p, exit1); } } } if (GC_ext_descriptors[env].ed_continued) { /* Push an entry with the rest of the descriptor back onto the */ /* stack. Thus we never do too much work at once. Note that */ /* we also can't overflow the mark stack unless we actually */ /* mark something. */ mark_stack_ptr++; if ((word)mark_stack_ptr >= (word)mark_stack_limit) { mark_stack_ptr = GC_signal_mark_stack_overflow(mark_stack_ptr); } mark_stack_ptr -> mse_start = (ptr_t)(addr + WORDSZ); mark_stack_ptr -> mse_descr.w = GC_MAKE_PROC(GC_typed_mark_proc_index, env + 1); } return(mark_stack_ptr); } /* Return the size of the object described by d. It would be faster to */ /* store this directly, or to compute it as part of */ /* GC_push_complex_descriptor, but hopefully it doesn't matter. */ STATIC word GC_descr_obj_size(complex_descriptor *d) { switch(d -> TAG) { case LEAF_TAG: return(d -> ld.ld_nelements * d -> ld.ld_size); case ARRAY_TAG: return(d -> ad.ad_nelements * GC_descr_obj_size(d -> ad.ad_element_descr)); case SEQUENCE_TAG: return(GC_descr_obj_size(d -> sd.sd_first) + GC_descr_obj_size(d -> sd.sd_second)); default: ABORT_RET("Bad complex descriptor"); return 0; } } /* Push descriptors for the object at addr with complex descriptor d */ /* onto the mark stack. Return 0 if the mark stack overflowed. */ STATIC mse * GC_push_complex_descriptor(word *addr, complex_descriptor *d, mse *msp, mse *msl) { register ptr_t current = (ptr_t) addr; register word nelements; register word sz; register word i; switch(d -> TAG) { case LEAF_TAG: { register GC_descr descr = d -> ld.ld_descriptor; nelements = d -> ld.ld_nelements; if (msl - msp <= (ptrdiff_t)nelements) return(0); sz = d -> ld.ld_size; for (i = 0; i < nelements; i++) { msp++; msp -> mse_start = current; msp -> mse_descr.w = descr; current += sz; } return(msp); } case ARRAY_TAG: { register complex_descriptor *descr = d -> ad.ad_element_descr; nelements = d -> ad.ad_nelements; sz = GC_descr_obj_size(descr); for (i = 0; i < nelements; i++) { msp = GC_push_complex_descriptor((word *)current, descr, msp, msl); if (msp == 0) return(0); current += sz; } return(msp); } case SEQUENCE_TAG: { sz = GC_descr_obj_size(d -> sd.sd_first); msp = GC_push_complex_descriptor((word *)current, d -> sd.sd_first, msp, msl); if (msp == 0) return(0); current += sz; msp = GC_push_complex_descriptor((word *)current, d -> sd.sd_second, msp, msl); return(msp); } default: ABORT_RET("Bad complex descriptor"); return 0; } } STATIC mse * GC_array_mark_proc(word * addr, mse * mark_stack_ptr, mse * mark_stack_limit, word env GC_ATTR_UNUSED) { hdr * hhdr = HDR(addr); size_t sz = hhdr -> hb_sz; size_t nwords = BYTES_TO_WORDS(sz); complex_descriptor * descr = (complex_descriptor *)(addr[nwords-1]); mse * orig_mark_stack_ptr = mark_stack_ptr; mse * new_mark_stack_ptr; if (descr == 0) { /* Found a reference to a free list entry. Ignore it. */ return(orig_mark_stack_ptr); } /* In use counts were already updated when array descriptor was */ /* pushed. Here we only replace it by subobject descriptors, so */ /* no update is necessary. */ new_mark_stack_ptr = GC_push_complex_descriptor(addr, descr, mark_stack_ptr, mark_stack_limit-1); if (new_mark_stack_ptr == 0) { /* Doesn't fit. Conservatively push the whole array as a unit */ /* and request a mark stack expansion. */ /* This cannot cause a mark stack overflow, since it replaces */ /* the original array entry. */ GC_mark_stack_too_small = TRUE; new_mark_stack_ptr = orig_mark_stack_ptr + 1; new_mark_stack_ptr -> mse_start = (ptr_t)addr; new_mark_stack_ptr -> mse_descr.w = sz | GC_DS_LENGTH; } else { /* Push descriptor itself */ new_mark_stack_ptr++; new_mark_stack_ptr -> mse_start = (ptr_t)(addr + nwords - 1); new_mark_stack_ptr -> mse_descr.w = sizeof(word) | GC_DS_LENGTH; } return new_mark_stack_ptr; } GC_API GC_descr GC_CALL GC_make_descriptor(const GC_word * bm, size_t len) { signed_word last_set_bit = len - 1; GC_descr result; signed_word i; # define HIGH_BIT (((word)1) << (WORDSZ - 1)) if (!EXPECT(GC_explicit_typing_initialized, TRUE)) GC_init_explicit_typing(); while (last_set_bit >= 0 && !GC_get_bit(bm, last_set_bit)) last_set_bit--; if (last_set_bit < 0) return(0 /* no pointers */); # if ALIGNMENT == CPP_WORDSZ/8 { register GC_bool all_bits_set = TRUE; for (i = 0; i < last_set_bit; i++) { if (!GC_get_bit(bm, i)) { all_bits_set = FALSE; break; } } if (all_bits_set) { /* An initial section contains all pointers. Use length descriptor. */ return (WORDS_TO_BYTES(last_set_bit+1) | GC_DS_LENGTH); } } # endif if ((word)last_set_bit < BITMAP_BITS) { /* Hopefully the common case. */ /* Build bitmap descriptor (with bits reversed) */ result = HIGH_BIT; for (i = last_set_bit - 1; i >= 0; i--) { result >>= 1; if (GC_get_bit(bm, i)) result |= HIGH_BIT; } result |= GC_DS_BITMAP; return(result); } else { signed_word index; index = GC_add_ext_descriptor(bm, (word)last_set_bit+1); if (index == -1) return(WORDS_TO_BYTES(last_set_bit+1) | GC_DS_LENGTH); /* Out of memory: use conservative */ /* approximation. */ result = GC_MAKE_PROC(GC_typed_mark_proc_index, (word)index); return result; } } GC_API GC_ATTR_MALLOC void * GC_CALL GC_malloc_explicitly_typed(size_t lb, GC_descr d) { ptr_t op; size_t lg; DCL_LOCK_STATE; lb += TYPD_EXTRA_BYTES; if(SMALL_OBJ(lb)) { GC_DBG_COLLECT_AT_MALLOC(lb); lg = GC_size_map[lb]; LOCK(); op = GC_eobjfreelist[lg]; if (EXPECT(0 == op, FALSE)) { UNLOCK(); op = (ptr_t)GENERAL_MALLOC((word)lb, GC_explicit_kind); if (0 == op) return 0; lg = GC_size_map[lb]; /* May have been uninitialized. */ } else { GC_eobjfreelist[lg] = obj_link(op); obj_link(op) = 0; GC_bytes_allocd += GRANULES_TO_BYTES(lg); UNLOCK(); } ((word *)op)[GRANULES_TO_WORDS(lg) - 1] = d; } else { op = (ptr_t)GENERAL_MALLOC((word)lb, GC_explicit_kind); if (op != NULL) { lg = BYTES_TO_GRANULES(GC_size(op)); ((word *)op)[GRANULES_TO_WORDS(lg) - 1] = d; } } return((void *) op); } GC_API GC_ATTR_MALLOC void * GC_CALL GC_malloc_explicitly_typed_ignore_off_page(size_t lb, GC_descr d) { ptr_t op; size_t lg; DCL_LOCK_STATE; lb += TYPD_EXTRA_BYTES; if (SMALL_OBJ(lb)) { GC_DBG_COLLECT_AT_MALLOC(lb); lg = GC_size_map[lb]; LOCK(); op = GC_eobjfreelist[lg]; if (EXPECT(0 == op, FALSE)) { UNLOCK(); op = (ptr_t)GENERAL_MALLOC_IOP(lb, GC_explicit_kind); if (0 == op) return 0; lg = GC_size_map[lb]; /* May have been uninitialized. */ } else { GC_eobjfreelist[lg] = obj_link(op); obj_link(op) = 0; GC_bytes_allocd += GRANULES_TO_BYTES(lg); UNLOCK(); } ((word *)op)[GRANULES_TO_WORDS(lg) - 1] = d; } else { op = (ptr_t)GENERAL_MALLOC_IOP(lb, GC_explicit_kind); if (op != NULL) { lg = BYTES_TO_GRANULES(GC_size(op)); ((word *)op)[GRANULES_TO_WORDS(lg) - 1] = d; } } return((void *) op); } GC_API GC_ATTR_MALLOC void * GC_CALL GC_calloc_explicitly_typed(size_t n, size_t lb, GC_descr d) { ptr_t op; size_t lg; GC_descr simple_descr; complex_descriptor *complex_descr; register int descr_type; struct LeafDescriptor leaf; DCL_LOCK_STATE; descr_type = GC_make_array_descriptor((word)n, (word)lb, d, &simple_descr, &complex_descr, &leaf); switch(descr_type) { case NO_MEM: return(0); case SIMPLE: return(GC_malloc_explicitly_typed(n*lb, simple_descr)); case LEAF: lb *= n; lb += sizeof(struct LeafDescriptor) + TYPD_EXTRA_BYTES; break; case COMPLEX: lb *= n; lb += TYPD_EXTRA_BYTES; break; } if( SMALL_OBJ(lb) ) { lg = GC_size_map[lb]; LOCK(); op = GC_arobjfreelist[lg]; if (EXPECT(0 == op, FALSE)) { UNLOCK(); op = (ptr_t)GENERAL_MALLOC((word)lb, GC_array_kind); if (0 == op) return(0); lg = GC_size_map[lb]; /* May have been uninitialized. */ } else { GC_arobjfreelist[lg] = obj_link(op); obj_link(op) = 0; GC_bytes_allocd += GRANULES_TO_BYTES(lg); UNLOCK(); } } else { op = (ptr_t)GENERAL_MALLOC((word)lb, GC_array_kind); if (0 == op) return(0); lg = BYTES_TO_GRANULES(GC_size(op)); } if (descr_type == LEAF) { /* Set up the descriptor inside the object itself. */ volatile struct LeafDescriptor * lp = (struct LeafDescriptor *) ((word *)op + GRANULES_TO_WORDS(lg) - (BYTES_TO_WORDS(sizeof(struct LeafDescriptor)) + 1)); lp -> ld_tag = LEAF_TAG; lp -> ld_size = leaf.ld_size; lp -> ld_nelements = leaf.ld_nelements; lp -> ld_descriptor = leaf.ld_descriptor; ((volatile word *)op)[GRANULES_TO_WORDS(lg) - 1] = (word)lp; } else { # ifndef GC_NO_FINALIZATION size_t lw = GRANULES_TO_WORDS(lg); ((word *)op)[lw - 1] = (word)complex_descr; /* Make sure the descriptor is cleared once there is any danger */ /* it may have been collected. */ if (GC_general_register_disappearing_link((void * *)((word *)op+lw-1), op) == GC_NO_MEMORY) # endif { /* Couldn't register it due to lack of memory. Punt. */ /* This will probably fail too, but gives the recovery code */ /* a chance. */ return(GC_malloc(n*lb)); } } return((void *) op); } ecl-16.1.2/src/bdwgc/win32_threads.c000066400000000000000000003020451266352375300170610ustar00rootroot00000000000000/* * Copyright (c) 1994 by Xerox Corporation. All rights reserved. * Copyright (c) 1996 by Silicon Graphics. All rights reserved. * Copyright (c) 1998 by Fergus Henderson. All rights reserved. * Copyright (c) 2000-2008 by Hewlett-Packard Development Company. * All rights reserved. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. */ #include "private/gc_priv.h" #if defined(GC_WIN32_THREADS) #ifndef WIN32_LEAN_AND_MEAN # define WIN32_LEAN_AND_MEAN 1 #endif #define NOSERVICE #include #ifdef THREAD_LOCAL_ALLOC # include "private/thread_local_alloc.h" #endif /* THREAD_LOCAL_ALLOC */ /* Allocation lock declarations. */ #if !defined(USE_PTHREAD_LOCKS) GC_INNER CRITICAL_SECTION GC_allocate_ml; # ifdef GC_ASSERTIONS GC_INNER DWORD GC_lock_holder = NO_THREAD; /* Thread id for current holder of allocation lock */ # endif #else GC_INNER pthread_mutex_t GC_allocate_ml = PTHREAD_MUTEX_INITIALIZER; # ifdef GC_ASSERTIONS GC_INNER unsigned long GC_lock_holder = NO_THREAD; # endif #endif #undef CreateThread #undef ExitThread #undef _beginthreadex #undef _endthreadex #ifdef GC_PTHREADS # include /* for EAGAIN */ /* Cygwin-specific forward decls */ # undef pthread_create # undef pthread_join # undef pthread_detach # ifndef GC_NO_PTHREAD_SIGMASK # undef pthread_sigmask # endif STATIC void * GC_pthread_start(void * arg); STATIC void GC_thread_exit_proc(void *arg); # include # ifdef CAN_CALL_ATFORK # include # endif #elif !defined(MSWINCE) # include /* For _beginthreadex, _endthreadex */ # include /* for errno, EAGAIN */ #endif /* !GC_PTHREADS && !MSWINCE */ /* DllMain-based thread registration is currently incompatible */ /* with thread-local allocation, pthreads and WinCE. */ #if (defined(GC_DLL) || defined(GC_INSIDE_DLL)) \ && !defined(GC_NO_THREADS_DISCOVERY) && !defined(MSWINCE) \ && !defined(THREAD_LOCAL_ALLOC) && !defined(GC_PTHREADS) # include "atomic_ops.h" /* This code operates in two distinct modes, depending on */ /* the setting of GC_win32_dll_threads. */ /* If GC_win32_dll_threads is set, all threads in the process */ /* are implicitly registered with the GC by DllMain. */ /* No explicit registration is required, and attempts at */ /* explicit registration are ignored. This mode is */ /* very different from the Posix operation of the collector. */ /* In this mode access to the thread table is lock-free. */ /* Hence there is a static limit on the number of threads. */ # ifdef GC_DISCOVER_TASK_THREADS /* GC_DISCOVER_TASK_THREADS should be used if DllMain-based */ /* thread registration is required but it is impossible to */ /* call GC_use_threads_discovery before other GC routines. */ # define GC_win32_dll_threads TRUE # else STATIC GC_bool GC_win32_dll_threads = FALSE; /* GC_win32_dll_threads must be set (if needed) at the */ /* application initialization time, i.e. before any */ /* collector or thread calls. We make it a "dynamic" */ /* option only to avoid multiple library versions. */ # endif #else /* If GC_win32_dll_threads is FALSE (or the collector is */ /* built without GC_DLL defined), things operate in a way */ /* that is very similar to Posix platforms, and new threads */ /* must be registered with the collector, e.g. by using */ /* preprocessor-based interception of the thread primitives. */ /* In this case, we use a real data structure for the thread */ /* table. Note that there is no equivalent of linker-based */ /* call interception, since we don't have ELF-like */ /* facilities. The Windows analog appears to be "API */ /* hooking", which really seems to be a standard way to */ /* do minor binary rewriting (?). I'd prefer not to have */ /* the basic collector rely on such facilities, but an */ /* optional package that intercepts thread calls this way */ /* would probably be nice. */ # ifndef GC_NO_THREADS_DISCOVERY # define GC_NO_THREADS_DISCOVERY # endif # define GC_win32_dll_threads FALSE # undef MAX_THREADS # define MAX_THREADS 1 /* dll_thread_table[] is always empty. */ #endif /* GC_NO_THREADS_DISCOVERY */ /* We have two versions of the thread table. Which one */ /* we us depends on whether or not GC_win32_dll_threads */ /* is set. Note that before initialization, we don't */ /* add any entries to either table, even if DllMain is */ /* called. The main thread will be added on */ /* initialization. */ /* The type of the first argument to InterlockedExchange. */ /* Documented to be LONG volatile *, but at least gcc likes */ /* this better. */ typedef LONG * IE_t; STATIC GC_bool GC_thr_initialized = FALSE; #ifndef GC_ALWAYS_MULTITHREADED GC_INNER GC_bool GC_need_to_lock = FALSE; #endif static GC_bool parallel_initialized = FALSE; /* GC_use_threads_discovery() is currently incompatible with pthreads */ /* and WinCE. It might be possible to get DllMain-based thread */ /* registration to work with Cygwin, but if you try it then you are on */ /* your own. */ GC_API void GC_CALL GC_use_threads_discovery(void) { # ifdef GC_NO_THREADS_DISCOVERY ABORT("GC DllMain-based thread registration unsupported"); # else /* Turn on GC_win32_dll_threads. */ GC_ASSERT(!parallel_initialized); # ifndef GC_DISCOVER_TASK_THREADS GC_win32_dll_threads = TRUE; # endif GC_init_parallel(); # endif } STATIC DWORD GC_main_thread = 0; #define ADDR_LIMIT ((ptr_t)(word)-1) struct GC_Thread_Rep { union { # ifndef GC_NO_THREADS_DISCOVERY volatile AO_t in_use; /* Updated without lock. */ /* We assert that unused */ /* entries have invalid ids of */ /* zero and zero stack fields. */ /* Used only with GC_win32_dll_threads. */ # endif struct GC_Thread_Rep * next; /* Hash table link without */ /* GC_win32_dll_threads. */ /* More recently allocated threads */ /* with a given pthread id come */ /* first. (All but the first are */ /* guaranteed to be dead, but we may */ /* not yet have registered the join.) */ } tm; /* table_management */ DWORD id; # ifdef MSWINCE /* According to MSDN specs for WinCE targets: */ /* - DuplicateHandle() is not applicable to thread handles; and */ /* - the value returned by GetCurrentThreadId() could be used as */ /* a "real" thread handle (for SuspendThread(), ResumeThread() and */ /* GetThreadContext()). */ # define THREAD_HANDLE(t) (HANDLE)(word)(t)->id # else HANDLE handle; # define THREAD_HANDLE(t) (t)->handle # endif ptr_t stack_base; /* The cold end of the stack. */ /* 0 ==> entry not valid. */ /* !in_use ==> stack_base == 0 */ ptr_t last_stack_min; /* Last known minimum (hottest) address */ /* in stack or ADDR_LIMIT if unset */ # ifdef IA64 ptr_t backing_store_end; ptr_t backing_store_ptr; # endif ptr_t thread_blocked_sp; /* Protected by GC lock. */ /* NULL value means thread unblocked. */ /* If set to non-NULL, thread will */ /* acquire GC lock before doing any */ /* pointer manipulations. Thus it does */ /* not need to stop this thread. */ struct GC_traced_stack_sect_s *traced_stack_sect; /* Points to the "stack section" data */ /* held in stack by the innermost */ /* GC_call_with_gc_active() of this */ /* thread. May be NULL. */ unsigned short finalizer_skipped; unsigned char finalizer_nested; /* Used by GC_check_finalizer_nested() */ /* to minimize the level of recursion */ /* when a client finalizer allocates */ /* memory (initially both are 0). */ unsigned char suspended; /* really of GC_bool type */ # ifdef GC_PTHREADS unsigned char flags; /* Protected by GC lock. */ # define FINISHED 1 /* Thread has exited. */ # define DETACHED 2 /* Thread is intended to be detached. */ # define KNOWN_FINISHED(t) (((t) -> flags) & FINISHED) pthread_t pthread_id; void *status; /* hold exit value until join in case it's a pointer */ # else # define KNOWN_FINISHED(t) 0 # endif # ifdef THREAD_LOCAL_ALLOC struct thread_local_freelists tlfs; # endif }; typedef struct GC_Thread_Rep * GC_thread; typedef volatile struct GC_Thread_Rep * GC_vthread; #ifndef GC_NO_THREADS_DISCOVERY /* We assumed that volatile ==> memory ordering, at least among */ /* volatiles. This code should consistently use atomic_ops. */ STATIC volatile GC_bool GC_please_stop = FALSE; #elif defined(GC_ASSERTIONS) STATIC GC_bool GC_please_stop = FALSE; #endif /* * We track thread attachments while the world is supposed to be stopped. * Unfortunately, we can't stop them from starting, since blocking in * DllMain seems to cause the world to deadlock. Thus we have to recover * If we notice this in the middle of marking. */ #ifndef GC_NO_THREADS_DISCOVERY STATIC volatile AO_t GC_attached_thread = FALSE; #endif #if !defined(__GNUC__) /* Return TRUE if an thread was attached since we last asked or */ /* since GC_attached_thread was explicitly reset. */ GC_INNER GC_bool GC_started_thread_while_stopped(void) { # ifndef GC_NO_THREADS_DISCOVERY if (GC_win32_dll_threads) { # ifdef AO_HAVE_compare_and_swap_release if (AO_compare_and_swap_release(&GC_attached_thread, TRUE, FALSE /* stored */)) return TRUE; # else AO_nop_full(); /* Prior heap reads need to complete earlier. */ if (AO_load(&GC_attached_thread)) { AO_store(&GC_attached_thread, FALSE); return TRUE; } # endif } # endif return FALSE; } #endif /* !__GNUC__ */ /* Thread table used if GC_win32_dll_threads is set. */ /* This is a fixed size array. */ /* Since we use runtime conditionals, both versions */ /* are always defined. */ # ifndef MAX_THREADS # define MAX_THREADS 512 # endif /* Things may get quite slow for large numbers of threads, */ /* since we look them up with sequential search. */ volatile struct GC_Thread_Rep dll_thread_table[MAX_THREADS]; STATIC volatile LONG GC_max_thread_index = 0; /* Largest index in dll_thread_table */ /* that was ever used. */ /* And now the version used if GC_win32_dll_threads is not set. */ /* This is a chained hash table, with much of the code borrowed */ /* From the Posix implementation. */ #ifndef THREAD_TABLE_SZ # define THREAD_TABLE_SZ 256 /* Power of 2 (for speed). */ #endif #define THREAD_TABLE_INDEX(id) (((word)(id) >> 2) % THREAD_TABLE_SZ) STATIC GC_thread GC_threads[THREAD_TABLE_SZ]; /* It may not be safe to allocate when we register the first thread. */ /* Thus we allocated one statically. It does not contain any field we */ /* need to push ("next" and "status" fields are unused). */ static struct GC_Thread_Rep first_thread; static GC_bool first_thread_used = FALSE; /* Add a thread to GC_threads. We assume it wasn't already there. */ /* Caller holds allocation lock. */ /* Unlike the pthreads version, the id field is set by the caller. */ STATIC GC_thread GC_new_thread(DWORD id) { word hv = THREAD_TABLE_INDEX(id); GC_thread result; GC_ASSERT(I_HOLD_LOCK()); if (!EXPECT(first_thread_used, TRUE)) { result = &first_thread; first_thread_used = TRUE; } else { GC_ASSERT(!GC_win32_dll_threads); result = (struct GC_Thread_Rep *) GC_INTERNAL_MALLOC(sizeof(struct GC_Thread_Rep), NORMAL); /* result can be NULL */ if (result == 0) return(0); } /* result -> id = id; Done by caller. */ result -> tm.next = GC_threads[hv]; GC_threads[hv] = result; # ifdef GC_PTHREADS GC_ASSERT(result -> flags == 0); # endif GC_ASSERT(result -> thread_blocked_sp == NULL); return(result); } STATIC GC_bool GC_in_thread_creation = FALSE; /* Protected by allocation lock. */ GC_INLINE void GC_record_stack_base(GC_vthread me, const struct GC_stack_base *sb) { me -> stack_base = sb -> mem_base; # ifdef IA64 me -> backing_store_end = sb -> reg_base; # endif if (me -> stack_base == NULL) ABORT("Bad stack base in GC_register_my_thread"); } /* This may be called from DllMain, and hence operates under unusual */ /* constraints. In particular, it must be lock-free if */ /* GC_win32_dll_threads is set. Always called from the thread being */ /* added. If GC_win32_dll_threads is not set, we already hold the */ /* allocation lock except possibly during single-threaded startup code. */ STATIC GC_thread GC_register_my_thread_inner(const struct GC_stack_base *sb, DWORD thread_id) { GC_vthread me; /* The following should be a no-op according to the win32 */ /* documentation. There is empirical evidence that it */ /* isn't. - HB */ # if defined(MPROTECT_VDB) if (GC_incremental # ifdef GWW_VDB && !GC_gww_dirty_init() # endif ) GC_set_write_fault_handler(); # endif # ifndef GC_NO_THREADS_DISCOVERY if (GC_win32_dll_threads) { int i; /* It appears to be unsafe to acquire a lock here, since this */ /* code is apparently not preemptible on some systems. */ /* (This is based on complaints, not on Microsoft's official */ /* documentation, which says this should perform "only simple */ /* initialization tasks".) */ /* Hence we make do with nonblocking synchronization. */ /* It has been claimed that DllMain is really only executed with */ /* a particular system lock held, and thus careful use of locking */ /* around code that doesn't call back into the system libraries */ /* might be OK. But this hasn't been tested across all win32 */ /* variants. */ /* cast away volatile qualifier */ for (i = 0; InterlockedExchange((void*)&dll_thread_table[i].tm.in_use, 1) != 0; i++) { /* Compare-and-swap would make this cleaner, but that's not */ /* supported before Windows 98 and NT 4.0. In Windows 2000, */ /* InterlockedExchange is supposed to be replaced by */ /* InterlockedExchangePointer, but that's not really what I */ /* want here. */ /* FIXME: We should eventually declare Win95 dead and use AO_ */ /* primitives here. */ if (i == MAX_THREADS - 1) ABORT("Too many threads"); } /* Update GC_max_thread_index if necessary. The following is */ /* safe, and unlike CompareExchange-based solutions seems to work */ /* on all Windows95 and later platforms. */ /* Unfortunately, GC_max_thread_index may be temporarily out of */ /* bounds, so readers have to compensate. */ while (i > GC_max_thread_index) { InterlockedIncrement((IE_t)&GC_max_thread_index); } if (GC_max_thread_index >= MAX_THREADS) { /* We overshot due to simultaneous increments. */ /* Setting it to MAX_THREADS-1 is always safe. */ GC_max_thread_index = MAX_THREADS - 1; } me = dll_thread_table + i; } else # endif /* else */ /* Not using DllMain */ { GC_ASSERT(I_HOLD_LOCK()); GC_in_thread_creation = TRUE; /* OK to collect from unknown thread. */ me = GC_new_thread(thread_id); GC_in_thread_creation = FALSE; if (me == 0) ABORT("Failed to allocate memory for thread registering"); } # ifdef GC_PTHREADS /* me can be NULL -> segfault */ me -> pthread_id = pthread_self(); # endif # ifndef MSWINCE /* GetCurrentThread() returns a pseudohandle (a const value). */ if (!DuplicateHandle(GetCurrentProcess(), GetCurrentThread(), GetCurrentProcess(), (HANDLE*)&(me -> handle), 0 /* dwDesiredAccess */, FALSE /* bInheritHandle */, DUPLICATE_SAME_ACCESS)) { ABORT_ARG1("DuplicateHandle failed", ": errcode= 0x%X", (unsigned)GetLastError()); } # endif me -> last_stack_min = ADDR_LIMIT; GC_record_stack_base(me, sb); /* Up until this point, GC_push_all_stacks considers this thread */ /* invalid. */ /* Up until this point, this entry is viewed as reserved but invalid */ /* by GC_delete_thread. */ me -> id = thread_id; # if defined(THREAD_LOCAL_ALLOC) GC_init_thread_local((GC_tlfs)(&(me->tlfs))); # endif # ifndef GC_NO_THREADS_DISCOVERY if (GC_win32_dll_threads) { if (GC_please_stop) { AO_store(&GC_attached_thread, TRUE); AO_nop_full(); /* Later updates must become visible after this. */ } /* We'd like to wait here, but can't, since waiting in DllMain */ /* provokes deadlocks. */ /* Thus we force marking to be restarted instead. */ } else # endif /* else */ { GC_ASSERT(!GC_please_stop); /* Otherwise both we and the thread stopping code would be */ /* holding the allocation lock. */ } return (GC_thread)(me); } /* * GC_max_thread_index may temporarily be larger than MAX_THREADS. * To avoid subscript errors, we check on access. */ GC_INLINE LONG GC_get_max_thread_index(void) { LONG my_max = GC_max_thread_index; if (my_max >= MAX_THREADS) return MAX_THREADS - 1; return my_max; } /* Return the GC_thread corresponding to a thread id. May be called */ /* without a lock, but should be called in contexts in which the */ /* requested thread cannot be asynchronously deleted, e.g. from the */ /* thread itself. */ /* This version assumes that either GC_win32_dll_threads is set, or */ /* we hold the allocator lock. */ /* Also used (for assertion checking only) from thread_local_alloc.c. */ STATIC GC_thread GC_lookup_thread_inner(DWORD thread_id) { # ifndef GC_NO_THREADS_DISCOVERY if (GC_win32_dll_threads) { int i; LONG my_max = GC_get_max_thread_index(); for (i = 0; i <= my_max && (!AO_load_acquire(&dll_thread_table[i].tm.in_use) || dll_thread_table[i].id != thread_id); /* Must still be in_use, since nobody else can store our */ /* thread_id. */ i++) { /* empty */ } return i <= my_max ? (GC_thread)(dll_thread_table + i) : NULL; } else # endif /* else */ { word hv = THREAD_TABLE_INDEX(thread_id); register GC_thread p = GC_threads[hv]; GC_ASSERT(I_HOLD_LOCK()); while (p != 0 && p -> id != thread_id) p = p -> tm.next; return(p); } } #ifdef LINT2 # define CHECK_LOOKUP_MY_THREAD(me) \ if (!(me)) ABORT("GC_lookup_thread_inner(GetCurrentThreadId) failed") #else # define CHECK_LOOKUP_MY_THREAD(me) /* empty */ #endif /* Called by GC_finalize() (in case of an allocation failure observed). */ /* GC_reset_finalizer_nested() is the same as in pthread_support.c. */ GC_INNER void GC_reset_finalizer_nested(void) { GC_thread me = GC_lookup_thread_inner(GetCurrentThreadId()); CHECK_LOOKUP_MY_THREAD(me); me->finalizer_nested = 0; } /* Checks and updates the thread-local level of finalizers recursion. */ /* Returns NULL if GC_invoke_finalizers() should not be called by the */ /* collector (to minimize the risk of a deep finalizers recursion), */ /* otherwise returns a pointer to the thread-local finalizer_nested. */ /* Called by GC_notify_or_invoke_finalizers() only (the lock is held). */ /* GC_check_finalizer_nested() is the same as in pthread_support.c. */ GC_INNER unsigned char *GC_check_finalizer_nested(void) { GC_thread me = GC_lookup_thread_inner(GetCurrentThreadId()); unsigned nesting_level; CHECK_LOOKUP_MY_THREAD(me); nesting_level = me->finalizer_nested; if (nesting_level) { /* We are inside another GC_invoke_finalizers(). */ /* Skip some implicitly-called GC_invoke_finalizers() */ /* depending on the nesting (recursion) level. */ if (++me->finalizer_skipped < (1U << nesting_level)) return NULL; me->finalizer_skipped = 0; } me->finalizer_nested = (unsigned char)(nesting_level + 1); return &me->finalizer_nested; } #if defined(GC_ASSERTIONS) && defined(THREAD_LOCAL_ALLOC) /* This is called from thread-local GC_malloc(). */ GC_bool GC_is_thread_tsd_valid(void *tsd) { GC_thread me; DCL_LOCK_STATE; LOCK(); me = GC_lookup_thread_inner(GetCurrentThreadId()); UNLOCK(); return (word)tsd >= (word)(&me->tlfs) && (word)tsd < (word)(&me->tlfs) + sizeof(me->tlfs); } #endif /* GC_ASSERTIONS && THREAD_LOCAL_ALLOC */ GC_API int GC_CALL GC_thread_is_registered(void) { DWORD thread_id = GetCurrentThreadId(); GC_thread me; DCL_LOCK_STATE; LOCK(); me = GC_lookup_thread_inner(thread_id); UNLOCK(); return me != NULL; } /* Make sure thread descriptor t is not protected by the VDB */ /* implementation. */ /* Used to prevent write faults when the world is (partially) stopped, */ /* since it may have been stopped with a system lock held, and that */ /* lock may be required for fault handling. */ #if defined(MPROTECT_VDB) # define UNPROTECT_THREAD(t) \ if (!GC_win32_dll_threads && GC_dirty_maintained \ && t != &first_thread) { \ GC_ASSERT(SMALL_OBJ(GC_size(t))); \ GC_remove_protection(HBLKPTR(t), 1, FALSE); \ } else (void)0 #else # define UNPROTECT_THREAD(t) (void)0 #endif #ifdef CYGWIN32 # define GC_PTHREAD_PTRVAL(pthread_id) pthread_id #elif defined(GC_WIN32_PTHREADS) || defined(GC_PTHREADS_PARAMARK) # include /* to check for winpthreads */ # if defined(__WINPTHREADS_VERSION_MAJOR) # define GC_PTHREAD_PTRVAL(pthread_id) pthread_id # else # define GC_PTHREAD_PTRVAL(pthread_id) pthread_id.p # endif #endif /* If a thread has been joined, but we have not yet */ /* been notified, then there may be more than one thread */ /* in the table with the same win32 id. */ /* This is OK, but we need a way to delete a specific one. */ /* Assumes we hold the allocation lock unless */ /* GC_win32_dll_threads is set. Does not actually free */ /* GC_thread entry (only unlinks it). */ /* If GC_win32_dll_threads is set it should be called from the */ /* thread being deleted. */ STATIC void GC_delete_gc_thread_no_free(GC_vthread t) { # ifndef MSWINCE CloseHandle(t->handle); # endif # ifndef GC_NO_THREADS_DISCOVERY if (GC_win32_dll_threads) { /* This is intended to be lock-free. */ /* It is either called synchronously from the thread being */ /* deleted, or by the joining thread. */ /* In this branch asynchronous changes to (*t) are possible. */ /* It's not allowed to call GC_printf (and the friends) here, */ /* see GC_stop_world() for the information. */ t -> stack_base = 0; t -> id = 0; AO_store_release(&t->tm.in_use, FALSE); } else # endif /* else */ { DWORD id = ((GC_thread)t) -> id; /* Cast away volatile qualifier, since we have lock. */ word hv = THREAD_TABLE_INDEX(id); register GC_thread p = GC_threads[hv]; register GC_thread prev = 0; GC_ASSERT(I_HOLD_LOCK()); while (p != (GC_thread)t) { prev = p; p = p -> tm.next; } if (prev == 0) { GC_threads[hv] = p -> tm.next; } else { prev -> tm.next = p -> tm.next; } } } /* Delete a thread from GC_threads. We assume it is there. */ /* (The code intentionally traps if it wasn't.) Assumes we */ /* hold the allocation lock unless GC_win32_dll_threads is set. */ /* If GC_win32_dll_threads is set then it should be called from */ /* the thread being deleted. It is also safe to delete the */ /* main thread (unless GC_win32_dll_threads). */ STATIC void GC_delete_thread(DWORD id) { if (GC_win32_dll_threads) { GC_vthread t = GC_lookup_thread_inner(id); if (0 == t) { WARN("Removing nonexistent thread, id = %" WARN_PRIdPTR "\n", id); } else { GC_delete_gc_thread_no_free(t); } } else { word hv = THREAD_TABLE_INDEX(id); register GC_thread p = GC_threads[hv]; register GC_thread prev = 0; GC_ASSERT(I_HOLD_LOCK()); while (p -> id != id) { prev = p; p = p -> tm.next; } # ifndef MSWINCE CloseHandle(p->handle); # endif if (prev == 0) { GC_threads[hv] = p -> tm.next; } else { prev -> tm.next = p -> tm.next; } if (p != &first_thread) { GC_INTERNAL_FREE(p); } } } GC_API void GC_CALL GC_allow_register_threads(void) { /* Check GC is initialized and the current thread is registered. */ GC_ASSERT(GC_lookup_thread_inner(GetCurrentThreadId()) != 0); # ifndef GC_ALWAYS_MULTITHREADED # if !defined(GC_NO_THREADS_DISCOVERY) && !defined(PARALLEL_MARK) /* GC_init() does not call GC_init_parallel() in this case. */ parallel_initialized = TRUE; # endif GC_need_to_lock = TRUE; /* We are multi-threaded now. */ # endif } GC_API int GC_CALL GC_register_my_thread(const struct GC_stack_base *sb) { GC_thread me; DWORD thread_id = GetCurrentThreadId(); DCL_LOCK_STATE; if (GC_need_to_lock == FALSE) ABORT("Threads explicit registering is not previously enabled"); /* We lock here, since we want to wait for an ongoing GC. */ LOCK(); me = GC_lookup_thread_inner(thread_id); if (me == 0) { # ifdef GC_PTHREADS me = GC_register_my_thread_inner(sb, thread_id); me -> flags |= DETACHED; /* Treat as detached, since we do not need to worry about */ /* pointer results. */ # else GC_register_my_thread_inner(sb, thread_id); # endif UNLOCK(); return GC_SUCCESS; } else # ifdef GC_PTHREADS /* else */ if ((me -> flags & FINISHED) != 0) { GC_record_stack_base(me, sb); me -> flags &= ~FINISHED; /* but not DETACHED */ # ifdef THREAD_LOCAL_ALLOC GC_init_thread_local((GC_tlfs)(&me->tlfs)); # endif UNLOCK(); return GC_SUCCESS; } else # endif /* else */ { UNLOCK(); return GC_DUPLICATE; } } /* Similar to that in pthread_support.c. */ STATIC void GC_wait_for_gc_completion(GC_bool wait_for_all) { GC_ASSERT(I_HOLD_LOCK()); if (GC_incremental && GC_collection_in_progress()) { word old_gc_no = GC_gc_no; /* Make sure that no part of our stack is still on the mark stack, */ /* since it's about to be unmapped. */ do { ENTER_GC(); GC_in_thread_creation = TRUE; GC_collect_a_little_inner(1); GC_in_thread_creation = FALSE; EXIT_GC(); UNLOCK(); Sleep(0); /* yield */ LOCK(); } while (GC_incremental && GC_collection_in_progress() && (wait_for_all || old_gc_no == GC_gc_no)); } } GC_API int GC_CALL GC_unregister_my_thread(void) { DCL_LOCK_STATE; # ifdef DEBUG_THREADS GC_log_printf("Unregistering thread 0x%lx\n", (long)GetCurrentThreadId()); # endif if (GC_win32_dll_threads) { # if defined(THREAD_LOCAL_ALLOC) /* Can't happen: see GC_use_threads_discovery(). */ GC_ASSERT(FALSE); # else /* FIXME: Should we just ignore this? */ GC_delete_thread(GetCurrentThreadId()); # endif } else { # if defined(THREAD_LOCAL_ALLOC) || defined(GC_PTHREADS) GC_thread me; # endif DWORD thread_id = GetCurrentThreadId(); LOCK(); GC_wait_for_gc_completion(FALSE); # if defined(THREAD_LOCAL_ALLOC) || defined(GC_PTHREADS) me = GC_lookup_thread_inner(thread_id); CHECK_LOOKUP_MY_THREAD(me); GC_ASSERT(!KNOWN_FINISHED(me)); # endif # if defined(THREAD_LOCAL_ALLOC) GC_ASSERT(GC_getspecific(GC_thread_key) == &me->tlfs); GC_destroy_thread_local(&(me->tlfs)); # endif # ifdef GC_PTHREADS if ((me -> flags & DETACHED) == 0) { me -> flags |= FINISHED; } else # endif /* else */ { GC_delete_thread(thread_id); } # if defined(THREAD_LOCAL_ALLOC) /* It is required to call remove_specific defined in specific.c. */ GC_remove_specific(GC_thread_key); # endif UNLOCK(); } return GC_SUCCESS; } /* Wrapper for functions that are likely to block for an appreciable */ /* length of time. */ /* GC_do_blocking_inner() is nearly the same as in pthread_support.c */ GC_INNER void GC_do_blocking_inner(ptr_t data, void * context GC_ATTR_UNUSED) { struct blocking_data * d = (struct blocking_data *) data; DWORD thread_id = GetCurrentThreadId(); GC_thread me; # ifdef IA64 ptr_t stack_ptr = GC_save_regs_in_stack(); # endif DCL_LOCK_STATE; LOCK(); me = GC_lookup_thread_inner(thread_id); CHECK_LOOKUP_MY_THREAD(me); GC_ASSERT(me -> thread_blocked_sp == NULL); # ifdef IA64 me -> backing_store_ptr = stack_ptr; # endif me -> thread_blocked_sp = (ptr_t) &d; /* save approx. sp */ /* Save context here if we want to support precise stack marking */ UNLOCK(); d -> client_data = (d -> fn)(d -> client_data); LOCK(); /* This will block if the world is stopped. */ me -> thread_blocked_sp = NULL; UNLOCK(); } /* GC_call_with_gc_active() has the opposite to GC_do_blocking() */ /* functionality. It might be called from a user function invoked by */ /* GC_do_blocking() to temporarily back allow calling any GC function */ /* and/or manipulating pointers to the garbage collected heap. */ GC_API void * GC_CALL GC_call_with_gc_active(GC_fn_type fn, void * client_data) { struct GC_traced_stack_sect_s stacksect; DWORD thread_id = GetCurrentThreadId(); GC_thread me; DCL_LOCK_STATE; LOCK(); /* This will block if the world is stopped. */ me = GC_lookup_thread_inner(thread_id); CHECK_LOOKUP_MY_THREAD(me); /* Adjust our stack base value (this could happen unless */ /* GC_get_stack_base() was used which returned GC_SUCCESS). */ GC_ASSERT(me -> stack_base != NULL); if ((word)me->stack_base < (word)(&stacksect)) me -> stack_base = (ptr_t)(&stacksect); if (me -> thread_blocked_sp == NULL) { /* We are not inside GC_do_blocking() - do nothing more. */ UNLOCK(); client_data = fn(client_data); /* Prevent treating the above as a tail call. */ GC_noop1((word)(&stacksect)); return client_data; /* result */ } /* Setup new "stack section". */ stacksect.saved_stack_ptr = me -> thread_blocked_sp; # ifdef IA64 /* This is the same as in GC_call_with_stack_base(). */ stacksect.backing_store_end = GC_save_regs_in_stack(); /* Unnecessarily flushes register stack, */ /* but that probably doesn't hurt. */ stacksect.saved_backing_store_ptr = me -> backing_store_ptr; # endif stacksect.prev = me -> traced_stack_sect; me -> thread_blocked_sp = NULL; me -> traced_stack_sect = &stacksect; UNLOCK(); client_data = fn(client_data); GC_ASSERT(me -> thread_blocked_sp == NULL); GC_ASSERT(me -> traced_stack_sect == &stacksect); /* Restore original "stack section". */ LOCK(); me -> traced_stack_sect = stacksect.prev; # ifdef IA64 me -> backing_store_ptr = stacksect.saved_backing_store_ptr; # endif me -> thread_blocked_sp = stacksect.saved_stack_ptr; UNLOCK(); return client_data; /* result */ } #ifdef GC_PTHREADS /* A quick-and-dirty cache of the mapping between pthread_t */ /* and win32 thread id. */ # define PTHREAD_MAP_SIZE 512 DWORD GC_pthread_map_cache[PTHREAD_MAP_SIZE] = {0}; # define PTHREAD_MAP_INDEX(pthread_id) \ ((NUMERIC_THREAD_ID(pthread_id) >> 5) % PTHREAD_MAP_SIZE) /* It appears pthread_t is really a pointer type ... */ # define SET_PTHREAD_MAP_CACHE(pthread_id, win32_id) \ (void)(GC_pthread_map_cache[PTHREAD_MAP_INDEX(pthread_id)] = (win32_id)) # define GET_PTHREAD_MAP_CACHE(pthread_id) \ GC_pthread_map_cache[PTHREAD_MAP_INDEX(pthread_id)] /* Return a GC_thread corresponding to a given pthread_t. */ /* Returns 0 if it's not there. */ /* We assume that this is only called for pthread ids that */ /* have not yet terminated or are still joinable, and */ /* cannot be concurrently terminated. */ /* Assumes we do NOT hold the allocation lock. */ STATIC GC_thread GC_lookup_pthread(pthread_t id) { # ifndef GC_NO_THREADS_DISCOVERY if (GC_win32_dll_threads) { int i; LONG my_max = GC_get_max_thread_index(); for (i = 0; i <= my_max && (!AO_load_acquire(&dll_thread_table[i].tm.in_use) || THREAD_EQUAL(dll_thread_table[i].pthread_id, id)); /* Must still be in_use, since nobody else can */ /* store our thread_id. */ i++) { /* empty */ } return i <= my_max ? (GC_thread)(dll_thread_table + i) : NULL; } else # endif /* else */ { /* We first try the cache. If that fails, we use a very slow */ /* approach. */ word hv_guess = THREAD_TABLE_INDEX(GET_PTHREAD_MAP_CACHE(id)); int hv; GC_thread p; DCL_LOCK_STATE; LOCK(); for (p = GC_threads[hv_guess]; 0 != p; p = p -> tm.next) { if (THREAD_EQUAL(p -> pthread_id, id)) goto foundit; } for (hv = 0; hv < THREAD_TABLE_SZ; ++hv) { for (p = GC_threads[hv]; 0 != p; p = p -> tm.next) { if (THREAD_EQUAL(p -> pthread_id, id)) goto foundit; } } p = 0; foundit: UNLOCK(); return p; } } #endif /* GC_PTHREADS */ #ifdef CAN_HANDLE_FORK /* Similar to that in pthread_support.c but also rehashes the table */ /* since hash map key (thread_id) differs from that in the parent. */ STATIC void GC_remove_all_threads_but_me(void) { int hv; GC_thread p, next, me = NULL; DWORD thread_id; pthread_t pthread_id = pthread_self(); /* same as in parent */ GC_ASSERT(!GC_win32_dll_threads); for (hv = 0; hv < THREAD_TABLE_SZ; ++hv) { for (p = GC_threads[hv]; 0 != p; p = next) { next = p -> tm.next; if (THREAD_EQUAL(p -> pthread_id, pthread_id)) { GC_ASSERT(me == NULL); me = p; p -> tm.next = 0; } else { # ifdef THREAD_LOCAL_ALLOC if ((p -> flags & FINISHED) == 0) { GC_destroy_thread_local(&p->tlfs); GC_remove_specific(GC_thread_key); } # endif if (&first_thread != p) GC_INTERNAL_FREE(p); } } GC_threads[hv] = NULL; } /* Put "me" back to GC_threads. */ GC_ASSERT(me != NULL); thread_id = GetCurrentThreadId(); /* differs from that in parent */ GC_threads[THREAD_TABLE_INDEX(thread_id)] = me; /* Update Win32 thread Id and handle. */ me -> id = thread_id; # ifndef MSWINCE if (!DuplicateHandle(GetCurrentProcess(), GetCurrentThread(), GetCurrentProcess(), (HANDLE *)&me->handle, 0 /* dwDesiredAccess */, FALSE /* bInheritHandle */, DUPLICATE_SAME_ACCESS)) ABORT("DuplicateHandle failed"); # endif # if defined(THREAD_LOCAL_ALLOC) && !defined(USE_CUSTOM_SPECIFIC) /* For Cygwin, we need to re-assign thread-local pointer to */ /* 'tlfs' (it is OK to call GC_destroy_thread_local and */ /* GC_free_internal before this action). */ if (GC_setspecific(GC_thread_key, &me->tlfs) != 0) ABORT("GC_setspecific failed (in child)"); # endif } static void fork_prepare_proc(void) { LOCK(); # ifdef PARALLEL_MARK if (GC_parallel) GC_wait_for_reclaim(); # endif GC_wait_for_gc_completion(TRUE); # ifdef PARALLEL_MARK if (GC_parallel) GC_acquire_mark_lock(); # endif } static void fork_parent_proc(void) { # ifdef PARALLEL_MARK if (GC_parallel) GC_release_mark_lock(); # endif UNLOCK(); } static void fork_child_proc(void) { # ifdef PARALLEL_MARK if (GC_parallel) { GC_release_mark_lock(); GC_parallel = FALSE; /* or GC_markers_m1 = 0 */ /* Turn off parallel marking in the child, since we are */ /* probably just going to exec, and we would have to */ /* restart mark threads. */ } # endif GC_remove_all_threads_but_me(); UNLOCK(); } /* Routines for fork handling by client (no-op if pthread_atfork works). */ GC_API void GC_CALL GC_atfork_prepare(void) { if (GC_handle_fork <= 0) fork_prepare_proc(); } GC_API void GC_CALL GC_atfork_parent(void) { if (GC_handle_fork <= 0) fork_parent_proc(); } GC_API void GC_CALL GC_atfork_child(void) { if (GC_handle_fork <= 0) fork_child_proc(); } #endif /* CAN_HANDLE_FORK */ void GC_push_thread_structures(void) { GC_ASSERT(I_HOLD_LOCK()); # ifndef GC_NO_THREADS_DISCOVERY if (GC_win32_dll_threads) { /* Unlike the other threads implementations, the thread table */ /* here contains no pointers to the collectible heap (note also */ /* that GC_PTHREADS is incompatible with DllMain-based thread */ /* registration). Thus we have no private structures we need */ /* to preserve. */ } else # endif /* else */ { GC_push_all((ptr_t)(GC_threads), (ptr_t)(GC_threads)+sizeof(GC_threads)); } # if defined(THREAD_LOCAL_ALLOC) GC_push_all((ptr_t)(&GC_thread_key), (ptr_t)(&GC_thread_key) + sizeof(GC_thread_key)); /* Just in case we ever use our own TLS implementation. */ # endif } /* Suspend the given thread, if it's still active. */ STATIC void GC_suspend(GC_thread t) { # ifndef MSWINCE /* Apparently the Windows 95 GetOpenFileName call creates */ /* a thread that does not properly get cleaned up, and */ /* SuspendThread on its descriptor may provoke a crash. */ /* This reduces the probability of that event, though it still */ /* appears there's a race here. */ DWORD exitCode; # endif UNPROTECT_THREAD(t); # ifndef MSWINCE if (GetExitCodeThread(t -> handle, &exitCode) && exitCode != STILL_ACTIVE) { # ifdef GC_PTHREADS t -> stack_base = 0; /* prevent stack from being pushed */ # else /* this breaks pthread_join on Cygwin, which is guaranteed to */ /* only see user pthreads */ GC_ASSERT(GC_win32_dll_threads); GC_delete_gc_thread_no_free(t); # endif return; } # endif # if defined(MPROTECT_VDB) /* Acquire the spin lock we use to update dirty bits. */ /* Threads shouldn't get stopped holding it. But we may */ /* acquire and release it in the UNPROTECT_THREAD call. */ while (AO_test_and_set_acquire(&GC_fault_handler_lock) == AO_TS_SET) { /* empty */ } # endif # ifdef MSWINCE /* SuspendThread() will fail if thread is running kernel code. */ while (SuspendThread(THREAD_HANDLE(t)) == (DWORD)-1) Sleep(10); /* in millis */ # else if (SuspendThread(t -> handle) == (DWORD)-1) ABORT("SuspendThread failed"); # endif /* !MSWINCE */ t -> suspended = (unsigned char)TRUE; # if defined(MPROTECT_VDB) AO_CLEAR(&GC_fault_handler_lock); # endif } #if defined(GC_ASSERTIONS) && !defined(CYGWIN32) GC_INNER GC_bool GC_write_disabled = FALSE; /* TRUE only if GC_stop_world() acquired GC_write_cs. */ #endif GC_INNER void GC_stop_world(void) { DWORD thread_id = GetCurrentThreadId(); if (!GC_thr_initialized) ABORT("GC_stop_world() called before GC_thr_init()"); GC_ASSERT(I_HOLD_LOCK()); /* This code is the same as in pthread_stop_world.c */ # ifdef PARALLEL_MARK if (GC_parallel) { GC_acquire_mark_lock(); GC_ASSERT(GC_fl_builder_count == 0); /* We should have previously waited for it to become zero. */ } # endif /* PARALLEL_MARK */ # if !defined(GC_NO_THREADS_DISCOVERY) || defined(GC_ASSERTIONS) GC_please_stop = TRUE; # endif # ifndef CYGWIN32 GC_ASSERT(!GC_write_disabled); EnterCriticalSection(&GC_write_cs); /* It's not allowed to call GC_printf() (and friends) here down to */ /* LeaveCriticalSection (same applies recursively to GC_suspend, */ /* GC_delete_gc_thread_no_free, GC_get_max_thread_index, GC_size */ /* and GC_remove_protection). */ # ifdef GC_ASSERTIONS GC_write_disabled = TRUE; # endif # endif # ifndef GC_NO_THREADS_DISCOVERY if (GC_win32_dll_threads) { int i; int my_max; /* Any threads being created during this loop will end up setting */ /* GC_attached_thread when they start. This will force marking */ /* to restart. This is not ideal, but hopefully correct. */ AO_store(&GC_attached_thread, FALSE); my_max = (int)GC_get_max_thread_index(); for (i = 0; i <= my_max; i++) { GC_vthread t = dll_thread_table + i; if (t -> stack_base != 0 && t -> thread_blocked_sp == NULL && t -> id != thread_id) { GC_suspend((GC_thread)t); } } } else # endif /* else */ { GC_thread t; int i; for (i = 0; i < THREAD_TABLE_SZ; i++) { for (t = GC_threads[i]; t != 0; t = t -> tm.next) { if (t -> stack_base != 0 && t -> thread_blocked_sp == NULL && !KNOWN_FINISHED(t) && t -> id != thread_id) { GC_suspend(t); } } } } # ifndef CYGWIN32 # ifdef GC_ASSERTIONS GC_write_disabled = FALSE; # endif LeaveCriticalSection(&GC_write_cs); # endif # ifdef PARALLEL_MARK if (GC_parallel) GC_release_mark_lock(); # endif } GC_INNER void GC_start_world(void) { # ifdef GC_ASSERTIONS DWORD thread_id = GetCurrentThreadId(); # endif int i; GC_ASSERT(I_HOLD_LOCK()); if (GC_win32_dll_threads) { LONG my_max = GC_get_max_thread_index(); for (i = 0; i <= my_max; i++) { GC_thread t = (GC_thread)(dll_thread_table + i); if (t -> suspended) { GC_ASSERT(t -> stack_base != 0 && t -> id != thread_id); if (ResumeThread(THREAD_HANDLE(t)) == (DWORD)-1) ABORT("ResumeThread failed"); t -> suspended = FALSE; } } } else { GC_thread t; int i; for (i = 0; i < THREAD_TABLE_SZ; i++) { for (t = GC_threads[i]; t != 0; t = t -> tm.next) { if (t -> suspended) { GC_ASSERT(t -> stack_base != 0 && t -> id != thread_id); if (ResumeThread(THREAD_HANDLE(t)) == (DWORD)-1) ABORT("ResumeThread failed"); UNPROTECT_THREAD(t); t -> suspended = FALSE; } } } } # if !defined(GC_NO_THREADS_DISCOVERY) || defined(GC_ASSERTIONS) GC_please_stop = FALSE; # endif } #ifdef MSWINCE /* The VirtualQuery calls below won't work properly on some old WinCE */ /* versions, but since each stack is restricted to an aligned 64 KiB */ /* region of virtual memory we can just take the next lowest multiple */ /* of 64 KiB. The result of this macro must not be used as its */ /* argument later and must not be used as the lower bound for sp */ /* check (since the stack may be bigger than 64 KiB). */ # define GC_wince_evaluate_stack_min(s) \ (ptr_t)(((word)(s) - 1) & ~(word)0xFFFF) #elif defined(GC_ASSERTIONS) # define GC_dont_query_stack_min FALSE #endif /* A cache holding the results of the recent VirtualQuery call. */ /* Protected by the allocation lock. */ static ptr_t last_address = 0; static MEMORY_BASIC_INFORMATION last_info; /* Probe stack memory region (starting at "s") to find out its */ /* lowest address (i.e. stack top). */ /* S must be a mapped address inside the region, NOT the first */ /* unmapped address. */ STATIC ptr_t GC_get_stack_min(ptr_t s) { ptr_t bottom; GC_ASSERT(I_HOLD_LOCK()); if (s != last_address) { VirtualQuery(s, &last_info, sizeof(last_info)); last_address = s; } do { bottom = last_info.BaseAddress; VirtualQuery(bottom - 1, &last_info, sizeof(last_info)); last_address = bottom - 1; } while ((last_info.Protect & PAGE_READWRITE) && !(last_info.Protect & PAGE_GUARD)); return(bottom); } /* Return true if the page at s has protections appropriate */ /* for a stack page. */ static GC_bool may_be_in_stack(ptr_t s) { GC_ASSERT(I_HOLD_LOCK()); if (s != last_address) { VirtualQuery(s, &last_info, sizeof(last_info)); last_address = s; } return (last_info.Protect & PAGE_READWRITE) && !(last_info.Protect & PAGE_GUARD); } STATIC word GC_push_stack_for(GC_thread thread, DWORD me) { ptr_t sp, stack_min; struct GC_traced_stack_sect_s *traced_stack_sect = thread -> traced_stack_sect; if (thread -> id == me) { GC_ASSERT(thread -> thread_blocked_sp == NULL); sp = GC_approx_sp(); } else if ((sp = thread -> thread_blocked_sp) == NULL) { /* Use saved sp value for blocked threads. */ /* For unblocked threads call GetThreadContext(). */ CONTEXT context; context.ContextFlags = CONTEXT_INTEGER|CONTEXT_CONTROL; if (!GetThreadContext(THREAD_HANDLE(thread), &context)) ABORT("GetThreadContext failed"); /* Push all registers that might point into the heap. Frame */ /* pointer registers are included in case client code was */ /* compiled with the 'omit frame pointer' optimization. */ # define PUSH1(reg) GC_push_one((word)context.reg) # define PUSH2(r1,r2) (PUSH1(r1), PUSH1(r2)) # define PUSH4(r1,r2,r3,r4) (PUSH2(r1,r2), PUSH2(r3,r4)) # if defined(I386) PUSH4(Edi,Esi,Ebx,Edx), PUSH2(Ecx,Eax), PUSH1(Ebp); sp = (ptr_t)context.Esp; # elif defined(X86_64) PUSH4(Rax,Rcx,Rdx,Rbx); PUSH2(Rbp, Rsi); PUSH1(Rdi); PUSH4(R8, R9, R10, R11); PUSH4(R12, R13, R14, R15); sp = (ptr_t)context.Rsp; # elif defined(ARM32) PUSH4(R0,R1,R2,R3),PUSH4(R4,R5,R6,R7),PUSH4(R8,R9,R10,R11); PUSH1(R12); sp = (ptr_t)context.Sp; # elif defined(SHx) PUSH4(R0,R1,R2,R3), PUSH4(R4,R5,R6,R7), PUSH4(R8,R9,R10,R11); PUSH2(R12,R13), PUSH1(R14); sp = (ptr_t)context.R15; # elif defined(MIPS) PUSH4(IntAt,IntV0,IntV1,IntA0), PUSH4(IntA1,IntA2,IntA3,IntT0); PUSH4(IntT1,IntT2,IntT3,IntT4), PUSH4(IntT5,IntT6,IntT7,IntS0); PUSH4(IntS1,IntS2,IntS3,IntS4), PUSH4(IntS5,IntS6,IntS7,IntT8); PUSH4(IntT9,IntK0,IntK1,IntS8); sp = (ptr_t)context.IntSp; # elif defined(PPC) PUSH4(Gpr0, Gpr3, Gpr4, Gpr5), PUSH4(Gpr6, Gpr7, Gpr8, Gpr9); PUSH4(Gpr10,Gpr11,Gpr12,Gpr14), PUSH4(Gpr15,Gpr16,Gpr17,Gpr18); PUSH4(Gpr19,Gpr20,Gpr21,Gpr22), PUSH4(Gpr23,Gpr24,Gpr25,Gpr26); PUSH4(Gpr27,Gpr28,Gpr29,Gpr30), PUSH1(Gpr31); sp = (ptr_t)context.Gpr1; # elif defined(ALPHA) PUSH4(IntV0,IntT0,IntT1,IntT2), PUSH4(IntT3,IntT4,IntT5,IntT6); PUSH4(IntT7,IntS0,IntS1,IntS2), PUSH4(IntS3,IntS4,IntS5,IntFp); PUSH4(IntA0,IntA1,IntA2,IntA3), PUSH4(IntA4,IntA5,IntT8,IntT9); PUSH4(IntT10,IntT11,IntT12,IntAt); sp = (ptr_t)context.IntSp; # else # error "architecture is not supported" # endif } /* ! current thread */ /* Set stack_min to the lowest address in the thread stack, */ /* or to an address in the thread stack no larger than sp, */ /* taking advantage of the old value to avoid slow traversals */ /* of large stacks. */ if (thread -> last_stack_min == ADDR_LIMIT) { # ifdef MSWINCE if (GC_dont_query_stack_min) { stack_min = GC_wince_evaluate_stack_min(traced_stack_sect != NULL ? (ptr_t)traced_stack_sect : thread -> stack_base); /* Keep last_stack_min value unmodified. */ } else # endif /* else */ { stack_min = GC_get_stack_min(traced_stack_sect != NULL ? (ptr_t)traced_stack_sect : thread -> stack_base); UNPROTECT_THREAD(thread); thread -> last_stack_min = stack_min; } } else { /* First, adjust the latest known minimum stack address if we */ /* are inside GC_call_with_gc_active(). */ if (traced_stack_sect != NULL && (word)thread->last_stack_min > (word)traced_stack_sect) { UNPROTECT_THREAD(thread); thread -> last_stack_min = (ptr_t)traced_stack_sect; } if ((word)sp < (word)thread->stack_base && (word)sp >= (word)thread->last_stack_min) { stack_min = sp; } else { /* In the current thread it is always safe to use sp value. */ if (may_be_in_stack(thread -> id == me && (word)sp < (word)thread->last_stack_min ? sp : thread -> last_stack_min)) { stack_min = last_info.BaseAddress; /* Do not probe rest of the stack if sp is correct. */ if ((word)sp < (word)stack_min || (word)sp >= (word)thread->stack_base) stack_min = GC_get_stack_min(thread -> last_stack_min); } else { /* Stack shrunk? Is this possible? */ stack_min = GC_get_stack_min(thread -> stack_base); } UNPROTECT_THREAD(thread); thread -> last_stack_min = stack_min; } } GC_ASSERT(GC_dont_query_stack_min || stack_min == GC_get_stack_min(thread -> stack_base) || ((word)sp >= (word)stack_min && (word)stack_min < (word)thread->stack_base && (word)stack_min > (word)GC_get_stack_min(thread -> stack_base))); if ((word)sp >= (word)stack_min && (word)sp < (word)thread->stack_base) { # ifdef DEBUG_THREADS GC_log_printf("Pushing stack for 0x%x from sp %p to %p from 0x%x\n", (int)thread -> id, sp, thread -> stack_base, (int)me); # endif GC_push_all_stack_sections(sp, thread->stack_base, traced_stack_sect); } else { /* If not current thread then it is possible for sp to point to */ /* the guarded (untouched yet) page just below the current */ /* stack_min of the thread. */ if (thread -> id == me || (word)sp >= (word)thread->stack_base || (word)(sp + GC_page_size) < (word)stack_min) WARN("Thread stack pointer %p out of range, pushing everything\n", sp); # ifdef DEBUG_THREADS GC_log_printf("Pushing stack for 0x%x from (min) %p to %p from 0x%x\n", (int)thread->id, stack_min, thread->stack_base, (int)me); # endif /* Push everything - ignore "traced stack section" data. */ GC_push_all_stack(stack_min, thread->stack_base); } return thread->stack_base - sp; /* stack grows down */ } GC_INNER void GC_push_all_stacks(void) { DWORD thread_id = GetCurrentThreadId(); GC_bool found_me = FALSE; # ifndef SMALL_CONFIG unsigned nthreads = 0; # endif word total_size = 0; # ifndef GC_NO_THREADS_DISCOVERY if (GC_win32_dll_threads) { int i; LONG my_max = GC_get_max_thread_index(); for (i = 0; i <= my_max; i++) { GC_thread t = (GC_thread)(dll_thread_table + i); if (t -> tm.in_use && t -> stack_base) { # ifndef SMALL_CONFIG ++nthreads; # endif total_size += GC_push_stack_for(t, thread_id); if (t -> id == thread_id) found_me = TRUE; } } } else # endif /* else */ { int i; for (i = 0; i < THREAD_TABLE_SZ; i++) { GC_thread t; for (t = GC_threads[i]; t != 0; t = t -> tm.next) { if (!KNOWN_FINISHED(t) && t -> stack_base) { # ifndef SMALL_CONFIG ++nthreads; # endif total_size += GC_push_stack_for(t, thread_id); if (t -> id == thread_id) found_me = TRUE; } } } } # ifndef SMALL_CONFIG GC_VERBOSE_LOG_PRINTF("Pushed %d thread stacks%s\n", nthreads, GC_win32_dll_threads ? " based on DllMain thread tracking" : ""); # endif if (!found_me && !GC_in_thread_creation) ABORT("Collecting from unknown thread"); GC_total_stacksize = total_size; } #ifdef PARALLEL_MARK # ifndef MAX_MARKERS # define MAX_MARKERS 16 # endif static ptr_t marker_sp[MAX_MARKERS - 1]; /* The cold end of the stack */ /* for markers. */ # ifdef IA64 static ptr_t marker_bsp[MAX_MARKERS - 1]; # endif static ptr_t marker_last_stack_min[MAX_MARKERS - 1]; /* Last known minimum (hottest) address */ /* in stack (or ADDR_LIMIT if unset) */ /* for markers. */ #endif /* PARALLEL_MARK */ /* Find stack with the lowest address which overlaps the */ /* interval [start, limit). */ /* Return stack bounds in *lo and *hi. If no such stack */ /* is found, both *hi and *lo will be set to an address */ /* higher than limit. */ GC_INNER void GC_get_next_stack(char *start, char *limit, char **lo, char **hi) { int i; char * current_min = ADDR_LIMIT; /* Least in-range stack base */ ptr_t *plast_stack_min = NULL; /* Address of last_stack_min */ /* field for thread corresponding */ /* to current_min. */ GC_thread thread = NULL; /* Either NULL or points to the */ /* thread's hash table entry */ /* containing *plast_stack_min. */ /* First set current_min, ignoring limit. */ if (GC_win32_dll_threads) { LONG my_max = GC_get_max_thread_index(); for (i = 0; i <= my_max; i++) { ptr_t s = (ptr_t)(dll_thread_table[i].stack_base); if ((word)s > (word)start && (word)s < (word)current_min) { /* Update address of last_stack_min. */ plast_stack_min = (ptr_t * /* no volatile */) &dll_thread_table[i].last_stack_min; current_min = s; } } } else { for (i = 0; i < THREAD_TABLE_SZ; i++) { GC_thread t; for (t = GC_threads[i]; t != 0; t = t -> tm.next) { ptr_t s = t -> stack_base; if ((word)s > (word)start && (word)s < (word)current_min) { /* Update address of last_stack_min. */ plast_stack_min = &t -> last_stack_min; thread = t; /* Remember current thread to unprotect. */ current_min = s; } } } # ifdef PARALLEL_MARK for (i = 0; i < GC_markers_m1; ++i) { ptr_t s = marker_sp[i]; # ifdef IA64 /* FIXME: not implemented */ # endif if ((word)s > (word)start && (word)s < (word)current_min) { GC_ASSERT(marker_last_stack_min[i] != NULL); plast_stack_min = &marker_last_stack_min[i]; current_min = s; thread = NULL; /* Not a thread's hash table entry. */ } } # endif } *hi = current_min; if (current_min == ADDR_LIMIT) { *lo = ADDR_LIMIT; return; } GC_ASSERT((word)current_min > (word)start && plast_stack_min != NULL); # ifdef MSWINCE if (GC_dont_query_stack_min) { *lo = GC_wince_evaluate_stack_min(current_min); /* Keep last_stack_min value unmodified. */ return; } # endif if ((word)current_min > (word)limit && !may_be_in_stack(limit)) { /* Skip the rest since the memory region at limit address is */ /* not a stack (so the lowest address of the found stack would */ /* be above the limit value anyway). */ *lo = ADDR_LIMIT; return; } /* Get the minimum address of the found stack by probing its memory */ /* region starting from the recent known minimum (if set). */ if (*plast_stack_min == ADDR_LIMIT || !may_be_in_stack(*plast_stack_min)) { /* Unsafe to start from last_stack_min value. */ *lo = GC_get_stack_min(current_min); } else { /* Use the recent value to optimize search for min address. */ *lo = GC_get_stack_min(*plast_stack_min); } /* Remember current stack_min value. */ if (thread != NULL) { UNPROTECT_THREAD(thread); } *plast_stack_min = *lo; } #ifdef PARALLEL_MARK # if defined(GC_PTHREADS) && !defined(GC_PTHREADS_PARAMARK) /* Use pthread-based parallel mark implementation. */ # define GC_PTHREADS_PARAMARK # endif # if !defined(GC_PTHREADS_PARAMARK) STATIC HANDLE GC_marker_cv[MAX_MARKERS - 1] = {0}; /* Events with manual reset (one for each */ /* mark helper). */ STATIC DWORD GC_marker_Id[MAX_MARKERS - 1] = {0}; /* This table is used for mapping helper */ /* threads ID to mark helper index (linear */ /* search is used since the mapping contains */ /* only a few entries). */ # endif /* GC_mark_thread() is the same as in pthread_support.c */ # ifdef GC_PTHREADS_PARAMARK STATIC void * GC_mark_thread(void * id) # else # ifdef MSWINCE STATIC DWORD WINAPI GC_mark_thread(LPVOID id) # else STATIC unsigned __stdcall GC_mark_thread(void * id) # endif # endif { word my_mark_no = 0; if ((word)id == (word)-1) return 0; /* to make compiler happy */ marker_sp[(word)id] = GC_approx_sp(); # ifdef IA64 marker_bsp[(word)id] = GC_save_regs_in_stack(); # endif # if !defined(GC_PTHREADS_PARAMARK) GC_marker_Id[(word)id] = GetCurrentThreadId(); # endif for (;; ++my_mark_no) { if (my_mark_no - GC_mark_no > (word)2) { /* resynchronize if we get far off, e.g. because GC_mark_no */ /* wrapped. */ my_mark_no = GC_mark_no; } # ifdef DEBUG_THREADS GC_log_printf("Starting mark helper for mark number %lu\n", (unsigned long)my_mark_no); # endif GC_help_marker(my_mark_no); } } # ifndef GC_ASSERTIONS # define SET_MARK_LOCK_HOLDER (void)0 # define UNSET_MARK_LOCK_HOLDER (void)0 # endif /* GC_mark_threads[] is unused here unlike that in pthread_support.c */ # ifndef CAN_HANDLE_FORK # define available_markers_m1 GC_markers_m1 # endif # ifdef GC_PTHREADS_PARAMARK # include # ifndef NUMERIC_THREAD_ID # define NUMERIC_THREAD_ID(id) (unsigned long)GC_PTHREAD_PTRVAL(id) /* Id not guaranteed to be unique. */ # endif /* start_mark_threads is the same as in pthread_support.c except */ /* for thread stack that is assumed to be large enough. */ # ifdef CAN_HANDLE_FORK static int available_markers_m1 = 0; # define start_mark_threads GC_start_mark_threads GC_API void GC_CALL # else static void # endif start_mark_threads(void) { int i; pthread_attr_t attr; pthread_t new_thread; GC_ASSERT(I_DONT_HOLD_LOCK()); # ifdef CAN_HANDLE_FORK if (available_markers_m1 <= 0 || GC_parallel) return; /* Skip if parallel markers disabled or already started. */ # endif if (0 != pthread_attr_init(&attr)) ABORT("pthread_attr_init failed"); if (0 != pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED)) ABORT("pthread_attr_setdetachstate failed"); for (i = 0; i < available_markers_m1; ++i) { marker_last_stack_min[i] = ADDR_LIMIT; if (0 != pthread_create(&new_thread, &attr, GC_mark_thread, (void *)(word)i)) { WARN("Marker thread creation failed.\n", 0); /* Don't try to create other marker threads. */ break; } } GC_markers_m1 = i; (void)pthread_attr_destroy(&attr); GC_COND_LOG_PRINTF("Started %d mark helper threads\n", GC_markers_m1); } # ifdef GC_ASSERTIONS STATIC unsigned long GC_mark_lock_holder = NO_THREAD; # define SET_MARK_LOCK_HOLDER \ (void)(GC_mark_lock_holder = NUMERIC_THREAD_ID(pthread_self())) # define UNSET_MARK_LOCK_HOLDER \ do { \ GC_ASSERT(GC_mark_lock_holder \ == NUMERIC_THREAD_ID(pthread_self())); \ GC_mark_lock_holder = NO_THREAD; \ } while (0) # endif /* GC_ASSERTIONS */ static pthread_mutex_t mark_mutex = PTHREAD_MUTEX_INITIALIZER; static pthread_cond_t builder_cv = PTHREAD_COND_INITIALIZER; /* GC_acquire/release_mark_lock(), GC_wait_builder/marker(), */ /* GC_wait_for_reclaim(), GC_notify_all_builder/marker() are the same */ /* as in pthread_support.c except that GC_generic_lock() is not used. */ # ifdef LOCK_STATS volatile AO_t GC_block_count = 0; # endif GC_INNER void GC_acquire_mark_lock(void) { # ifdef NUMERIC_THREAD_ID_UNIQUE GC_ASSERT(GC_mark_lock_holder != NUMERIC_THREAD_ID(pthread_self())); # endif if (pthread_mutex_lock(&mark_mutex) != 0) { ABORT("pthread_mutex_lock failed"); } # ifdef LOCK_STATS (void)AO_fetch_and_add1(&GC_block_count); # endif /* GC_generic_lock(&mark_mutex); */ SET_MARK_LOCK_HOLDER; } GC_INNER void GC_release_mark_lock(void) { UNSET_MARK_LOCK_HOLDER; if (pthread_mutex_unlock(&mark_mutex) != 0) { ABORT("pthread_mutex_unlock failed"); } } /* Collector must wait for a freelist builders for 2 reasons: */ /* 1) Mark bits may still be getting examined without lock. */ /* 2) Partial free lists referenced only by locals may not be */ /* scanned correctly, e.g. if they contain "pointer-free" objects, */ /* since the free-list link may be ignored. */ STATIC void GC_wait_builder(void) { UNSET_MARK_LOCK_HOLDER; if (pthread_cond_wait(&builder_cv, &mark_mutex) != 0) { ABORT("pthread_cond_wait failed"); } GC_ASSERT(GC_mark_lock_holder == NO_THREAD); SET_MARK_LOCK_HOLDER; } GC_INNER void GC_wait_for_reclaim(void) { GC_acquire_mark_lock(); while (GC_fl_builder_count > 0) { GC_wait_builder(); } GC_release_mark_lock(); } GC_INNER void GC_notify_all_builder(void) { GC_ASSERT(GC_mark_lock_holder == NUMERIC_THREAD_ID(pthread_self())); if (pthread_cond_broadcast(&builder_cv) != 0) { ABORT("pthread_cond_broadcast failed"); } } static pthread_cond_t mark_cv = PTHREAD_COND_INITIALIZER; GC_INNER void GC_wait_marker(void) { UNSET_MARK_LOCK_HOLDER; if (pthread_cond_wait(&mark_cv, &mark_mutex) != 0) { ABORT("pthread_cond_wait failed"); } GC_ASSERT(GC_mark_lock_holder == NO_THREAD); SET_MARK_LOCK_HOLDER; } GC_INNER void GC_notify_all_marker(void) { if (pthread_cond_broadcast(&mark_cv) != 0) { ABORT("pthread_cond_broadcast failed"); } } # else /* ! GC_PTHREADS_PARAMARK */ # ifndef MARK_THREAD_STACK_SIZE # define MARK_THREAD_STACK_SIZE 0 /* default value */ # endif /* mark_mutex_event, builder_cv, mark_cv are initialized in GC_thr_init */ static HANDLE mark_mutex_event = (HANDLE)0; /* Event with auto-reset. */ static HANDLE builder_cv = (HANDLE)0; /* Event with manual reset. */ static HANDLE mark_cv = (HANDLE)0; /* Event with manual reset. */ static void start_mark_threads(void) { int i; # ifdef MSWINCE HANDLE handle; DWORD thread_id; # else GC_uintptr_t handle; unsigned thread_id; # endif /* Initialize GC_marker_cv[] fully before starting the */ /* first helper thread. */ for (i = 0; i < GC_markers_m1; ++i) { if ((GC_marker_cv[i] = CreateEvent(NULL /* attrs */, TRUE /* isManualReset */, FALSE /* initialState */, NULL /* name (A/W) */)) == (HANDLE)0) ABORT("CreateEvent failed"); } for (i = 0; i < GC_markers_m1; ++i) { marker_last_stack_min[i] = ADDR_LIMIT; # ifdef MSWINCE /* There is no _beginthreadex() in WinCE. */ handle = CreateThread(NULL /* lpsa */, MARK_THREAD_STACK_SIZE /* ignored */, GC_mark_thread, (LPVOID)(word)i, 0 /* fdwCreate */, &thread_id); if (handle == NULL) { WARN("Marker thread creation failed\n", 0); /* The most probable failure reason is "not enough memory". */ /* Don't try to create other marker threads. */ break; } else { /* It's safe to detach the thread. */ CloseHandle(handle); } # else handle = _beginthreadex(NULL /* security_attr */, MARK_THREAD_STACK_SIZE, GC_mark_thread, (void *)(word)i, 0 /* flags */, &thread_id); if (!handle || handle == (GC_uintptr_t)-1L) { WARN("Marker thread creation failed\n", 0); /* Don't try to create other marker threads. */ break; } else {/* We may detach the thread (if handle is of HANDLE type) */ /* CloseHandle((HANDLE)handle); */ } # endif } /* Adjust GC_markers_m1 (and free unused resources) if failed. */ while (GC_markers_m1 > i) { GC_markers_m1--; CloseHandle(GC_marker_cv[GC_markers_m1]); } GC_COND_LOG_PRINTF("Started %d mark helper threads\n", GC_markers_m1); if (i == 0) { CloseHandle(mark_cv); CloseHandle(builder_cv); CloseHandle(mark_mutex_event); } } # ifdef GC_ASSERTIONS STATIC DWORD GC_mark_lock_holder = NO_THREAD; # define SET_MARK_LOCK_HOLDER \ (void)(GC_mark_lock_holder = GetCurrentThreadId()) # define UNSET_MARK_LOCK_HOLDER \ do { \ GC_ASSERT(GC_mark_lock_holder == GetCurrentThreadId()); \ GC_mark_lock_holder = NO_THREAD; \ } while (0) # endif /* GC_ASSERTIONS */ STATIC /* volatile */ LONG GC_mark_mutex_state = 0; /* Mutex state: 0 - unlocked, */ /* 1 - locked and no other waiters, */ /* -1 - locked and waiters may exist. */ /* Accessed by InterlockedExchange(). */ /* #define LOCK_STATS */ # ifdef LOCK_STATS volatile AO_t GC_block_count = 0; volatile AO_t GC_unlocked_count = 0; # endif GC_INNER void GC_acquire_mark_lock(void) { GC_ASSERT(GC_mark_lock_holder != GetCurrentThreadId()); if (InterlockedExchange(&GC_mark_mutex_state, 1 /* locked */) != 0) { # ifdef LOCK_STATS (void)AO_fetch_and_add1(&GC_block_count); # endif /* Repeatedly reset the state and wait until acquire the lock. */ while (InterlockedExchange(&GC_mark_mutex_state, -1 /* locked_and_has_waiters */) != 0) { if (WaitForSingleObject(mark_mutex_event, INFINITE) == WAIT_FAILED) ABORT("WaitForSingleObject failed"); } } # ifdef LOCK_STATS else { (void)AO_fetch_and_add1(&GC_unlocked_count); } # endif GC_ASSERT(GC_mark_lock_holder == NO_THREAD); SET_MARK_LOCK_HOLDER; } GC_INNER void GC_release_mark_lock(void) { UNSET_MARK_LOCK_HOLDER; if (InterlockedExchange(&GC_mark_mutex_state, 0 /* unlocked */) < 0) { /* wake a waiter */ if (SetEvent(mark_mutex_event) == FALSE) ABORT("SetEvent failed"); } } /* In GC_wait_for_reclaim/GC_notify_all_builder() we emulate POSIX */ /* cond_wait/cond_broadcast() primitives with WinAPI Event object */ /* (working in "manual reset" mode). This works here because */ /* GC_notify_all_builder() is always called holding lock on */ /* mark_mutex and the checked condition (GC_fl_builder_count == 0) */ /* is the only one for which broadcasting on builder_cv is performed. */ GC_INNER void GC_wait_for_reclaim(void) { GC_ASSERT(builder_cv != 0); for (;;) { GC_acquire_mark_lock(); if (GC_fl_builder_count == 0) break; if (ResetEvent(builder_cv) == FALSE) ABORT("ResetEvent failed"); GC_release_mark_lock(); if (WaitForSingleObject(builder_cv, INFINITE) == WAIT_FAILED) ABORT("WaitForSingleObject failed"); } GC_release_mark_lock(); } GC_INNER void GC_notify_all_builder(void) { GC_ASSERT(GC_mark_lock_holder == GetCurrentThreadId()); GC_ASSERT(builder_cv != 0); GC_ASSERT(GC_fl_builder_count == 0); if (SetEvent(builder_cv) == FALSE) ABORT("SetEvent failed"); } /* mark_cv is used (for waiting) by a non-helper thread. */ GC_INNER void GC_wait_marker(void) { HANDLE event = mark_cv; DWORD thread_id = GetCurrentThreadId(); int i = GC_markers_m1; while (i-- > 0) { if (GC_marker_Id[i] == thread_id) { event = GC_marker_cv[i]; break; } } if (ResetEvent(event) == FALSE) ABORT("ResetEvent failed"); GC_release_mark_lock(); if (WaitForSingleObject(event, INFINITE) == WAIT_FAILED) ABORT("WaitForSingleObject failed"); GC_acquire_mark_lock(); } GC_INNER void GC_notify_all_marker(void) { DWORD thread_id = GetCurrentThreadId(); int i = GC_markers_m1; while (i-- > 0) { /* Notify every marker ignoring self (for efficiency). */ if (SetEvent(GC_marker_Id[i] != thread_id ? GC_marker_cv[i] : mark_cv) == FALSE) ABORT("SetEvent failed"); } } # endif /* ! GC_PTHREADS_PARAMARK */ #endif /* PARALLEL_MARK */ /* We have no DllMain to take care of new threads. Thus we */ /* must properly intercept thread creation. */ typedef struct { LPTHREAD_START_ROUTINE start; LPVOID param; } thread_args; STATIC void * GC_CALLBACK GC_win32_start_inner(struct GC_stack_base *sb, void *arg) { void * ret; LPTHREAD_START_ROUTINE start = ((thread_args *)arg)->start; LPVOID param = ((thread_args *)arg)->param; GC_register_my_thread(sb); /* This waits for an in-progress GC. */ # ifdef DEBUG_THREADS GC_log_printf("thread 0x%lx starting...\n", (long)GetCurrentThreadId()); # endif GC_free(arg); /* Clear the thread entry even if we exit with an exception. */ /* This is probably pointless, since an uncaught exception is */ /* supposed to result in the process being killed. */ # ifndef __GNUC__ __try # endif { ret = (void *)(word)(*start)(param); } # ifndef __GNUC__ __finally # endif { GC_unregister_my_thread(); } # ifdef DEBUG_THREADS GC_log_printf("thread 0x%lx returned from start routine\n", (long)GetCurrentThreadId()); # endif return ret; } STATIC DWORD WINAPI GC_win32_start(LPVOID arg) { return (DWORD)(word)GC_call_with_stack_base(GC_win32_start_inner, arg); } GC_API HANDLE WINAPI GC_CreateThread( LPSECURITY_ATTRIBUTES lpThreadAttributes, GC_WIN32_SIZE_T dwStackSize, LPTHREAD_START_ROUTINE lpStartAddress, LPVOID lpParameter, DWORD dwCreationFlags, LPDWORD lpThreadId) { HANDLE thread_h; thread_args *args; if (!EXPECT(parallel_initialized, TRUE)) GC_init_parallel(); /* make sure GC is initialized (i.e. main thread is */ /* attached, tls initialized). */ # ifdef DEBUG_THREADS GC_log_printf("About to create a thread from 0x%lx\n", (long)GetCurrentThreadId()); # endif if (GC_win32_dll_threads) { return CreateThread(lpThreadAttributes, dwStackSize, lpStartAddress, lpParameter, dwCreationFlags, lpThreadId); } else { args = GC_malloc_uncollectable(sizeof(thread_args)); /* Handed off to and deallocated by child thread. */ if (0 == args) { SetLastError(ERROR_NOT_ENOUGH_MEMORY); return NULL; } /* set up thread arguments */ args -> start = lpStartAddress; args -> param = lpParameter; # ifndef GC_ALWAYS_MULTITHREADED GC_need_to_lock = TRUE; # endif thread_h = CreateThread(lpThreadAttributes, dwStackSize, GC_win32_start, args, dwCreationFlags, lpThreadId); if (thread_h == 0) GC_free(args); return thread_h; } } GC_API DECLSPEC_NORETURN void WINAPI GC_ExitThread(DWORD dwExitCode) { GC_unregister_my_thread(); ExitThread(dwExitCode); } # if !defined(MSWINCE) && !defined(CYGWIN32) GC_API GC_uintptr_t GC_CALL GC_beginthreadex( void *security, unsigned stack_size, unsigned (__stdcall *start_address)(void *), void *arglist, unsigned initflag, unsigned *thrdaddr) { GC_uintptr_t thread_h; thread_args *args; if (!EXPECT(parallel_initialized, TRUE)) GC_init_parallel(); /* make sure GC is initialized (i.e. main thread is */ /* attached, tls initialized). */ # ifdef DEBUG_THREADS GC_log_printf("About to create a thread from 0x%lx\n", (long)GetCurrentThreadId()); # endif if (GC_win32_dll_threads) { return _beginthreadex(security, stack_size, start_address, arglist, initflag, thrdaddr); } else { args = GC_malloc_uncollectable(sizeof(thread_args)); /* Handed off to and deallocated by child thread. */ if (0 == args) { /* MSDN docs say _beginthreadex() returns 0 on error and sets */ /* errno to either EAGAIN (too many threads) or EINVAL (the */ /* argument is invalid or the stack size is incorrect), so we */ /* set errno to EAGAIN on "not enough memory". */ errno = EAGAIN; return 0; } /* set up thread arguments */ args -> start = (LPTHREAD_START_ROUTINE)start_address; args -> param = arglist; # ifndef GC_ALWAYS_MULTITHREADED GC_need_to_lock = TRUE; # endif thread_h = _beginthreadex(security, stack_size, (unsigned (__stdcall *)(void *))GC_win32_start, args, initflag, thrdaddr); if (thread_h == 0) GC_free(args); return thread_h; } } GC_API void GC_CALL GC_endthreadex(unsigned retval) { GC_unregister_my_thread(); _endthreadex(retval); } # endif /* !MSWINCE && !CYGWIN32 */ #ifdef GC_WINMAIN_REDIRECT /* This might be useful on WinCE. Shouldn't be used with GC_DLL. */ # if defined(MSWINCE) && defined(UNDER_CE) # define WINMAIN_LPTSTR LPWSTR # else # define WINMAIN_LPTSTR LPSTR # endif /* This is defined in gc.h. */ # undef WinMain /* Defined outside GC by an application. */ int WINAPI GC_WinMain(HINSTANCE, HINSTANCE, WINMAIN_LPTSTR, int); typedef struct { HINSTANCE hInstance; HINSTANCE hPrevInstance; WINMAIN_LPTSTR lpCmdLine; int nShowCmd; } main_thread_args; static DWORD WINAPI main_thread_start(LPVOID arg) { main_thread_args * args = (main_thread_args *) arg; return (DWORD)GC_WinMain(args->hInstance, args->hPrevInstance, args->lpCmdLine, args->nShowCmd); } STATIC void * GC_waitForSingleObjectInfinite(void * handle) { return (void *)(word)WaitForSingleObject((HANDLE)handle, INFINITE); } # ifndef WINMAIN_THREAD_STACK_SIZE # define WINMAIN_THREAD_STACK_SIZE 0 /* default value */ # endif int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, WINMAIN_LPTSTR lpCmdLine, int nShowCmd) { DWORD exit_code = 1; main_thread_args args = { hInstance, hPrevInstance, lpCmdLine, nShowCmd }; HANDLE thread_h; DWORD thread_id; /* initialize everything */ GC_INIT(); /* start the main thread */ thread_h = GC_CreateThread(NULL /* lpsa */, WINMAIN_THREAD_STACK_SIZE /* ignored on WinCE */, main_thread_start, &args, 0 /* fdwCreate */, &thread_id); if (thread_h != NULL) { if ((DWORD)(word)GC_do_blocking(GC_waitForSingleObjectInfinite, (void *)thread_h) == WAIT_FAILED) ABORT("WaitForSingleObject(main_thread) failed"); GetExitCodeThread (thread_h, &exit_code); CloseHandle (thread_h); } else { ABORT("GC_CreateThread(main_thread) failed"); } # ifdef MSWINCE GC_deinit(); DeleteCriticalSection(&GC_allocate_ml); # endif return (int) exit_code; } #endif /* GC_WINMAIN_REDIRECT */ /* Called by GC_init() - we hold the allocation lock. */ GC_INNER void GC_thr_init(void) { struct GC_stack_base sb; # ifdef GC_ASSERTIONS int sb_result; # endif GC_ASSERT(I_HOLD_LOCK()); if (GC_thr_initialized) return; GC_ASSERT((word)&GC_threads % sizeof(word) == 0); GC_main_thread = GetCurrentThreadId(); GC_thr_initialized = TRUE; # ifdef CAN_HANDLE_FORK /* Prepare for forks if requested. */ if (GC_handle_fork) { # ifdef CAN_CALL_ATFORK if (pthread_atfork(fork_prepare_proc, fork_parent_proc, fork_child_proc) == 0) { /* Handlers successfully registered. */ GC_handle_fork = 1; } else # endif /* else */ if (GC_handle_fork != -1) ABORT("pthread_atfork failed"); } # endif /* Add the initial thread, so we can stop it. */ # ifdef GC_ASSERTIONS sb_result = # endif GC_get_stack_base(&sb); GC_ASSERT(sb_result == GC_SUCCESS); # if defined(PARALLEL_MARK) { char * markers_string = GETENV("GC_MARKERS"); int markers_m1; if (markers_string != NULL) { markers_m1 = atoi(markers_string) - 1; if (markers_m1 >= MAX_MARKERS) { WARN("Limiting number of mark threads\n", 0); markers_m1 = MAX_MARKERS - 1; } } else { # ifdef MSWINCE /* There is no GetProcessAffinityMask() in WinCE. */ /* GC_sysinfo is already initialized. */ markers_m1 = (int)GC_sysinfo.dwNumberOfProcessors - 1; # else # ifdef _WIN64 DWORD_PTR procMask = 0; DWORD_PTR sysMask; # else DWORD procMask = 0; DWORD sysMask; # endif int ncpu = 0; if (GetProcessAffinityMask(GetCurrentProcess(), (void *)&procMask, (void *)&sysMask) && procMask) { do { ncpu++; } while ((procMask &= procMask - 1) != 0); } markers_m1 = ncpu - 1; # endif # ifdef GC_MIN_MARKERS /* This is primarily for testing on systems without getenv(). */ if (markers_m1 < GC_MIN_MARKERS - 1) markers_m1 = GC_MIN_MARKERS - 1; # endif if (markers_m1 >= MAX_MARKERS) markers_m1 = MAX_MARKERS - 1; /* silently limit the value */ } available_markers_m1 = markers_m1; } /* Check whether parallel mode could be enabled. */ { if (GC_win32_dll_threads || available_markers_m1 <= 0) { /* Disable parallel marking. */ GC_parallel = FALSE; GC_COND_LOG_PRINTF( "Single marker thread, turning off parallel marking\n"); } else { # ifndef GC_PTHREADS_PARAMARK /* Initialize Win32 event objects for parallel marking. */ mark_mutex_event = CreateEvent(NULL /* attrs */, FALSE /* isManualReset */, FALSE /* initialState */, NULL /* name */); builder_cv = CreateEvent(NULL /* attrs */, TRUE /* isManualReset */, FALSE /* initialState */, NULL /* name */); mark_cv = CreateEvent(NULL /* attrs */, TRUE /* isManualReset */, FALSE /* initialState */, NULL /* name */); if (mark_mutex_event == (HANDLE)0 || builder_cv == (HANDLE)0 || mark_cv == (HANDLE)0) ABORT("CreateEvent failed"); # endif /* Disable true incremental collection, but generational is OK. */ GC_time_limit = GC_TIME_UNLIMITED; } } # endif /* PARALLEL_MARK */ GC_ASSERT(0 == GC_lookup_thread_inner(GC_main_thread)); GC_register_my_thread_inner(&sb, GC_main_thread); # ifdef PARALLEL_MARK # ifndef CAN_HANDLE_FORK if (GC_parallel) # endif { /* If we are using a parallel marker, actually start helper threads. */ start_mark_threads(); } # endif } #ifdef GC_PTHREADS struct start_info { void *(*start_routine)(void *); void *arg; GC_bool detached; }; GC_API int GC_pthread_join(pthread_t pthread_id, void **retval) { int result; GC_thread t; DCL_LOCK_STATE; GC_ASSERT(!GC_win32_dll_threads); # ifdef DEBUG_THREADS GC_log_printf("thread %p(0x%lx) is joining thread %p\n", GC_PTHREAD_PTRVAL(pthread_self()), (long)GetCurrentThreadId(), GC_PTHREAD_PTRVAL(pthread_id)); # endif /* Thread being joined might not have registered itself yet. */ /* After the join, thread id may have been recycled. */ /* FIXME: It would be better if this worked more like */ /* pthread_support.c. */ # ifndef GC_WIN32_PTHREADS while ((t = GC_lookup_pthread(pthread_id)) == 0) Sleep(10); result = pthread_join(pthread_id, retval); # else result = pthread_join(pthread_id, retval); /* pthreads-win32 and winpthreads id are unique (not recycled). */ t = GC_lookup_pthread(pthread_id); if (NULL == t) ABORT("Thread not registered"); # endif LOCK(); GC_delete_gc_thread_no_free(t); GC_INTERNAL_FREE(t); UNLOCK(); # ifdef DEBUG_THREADS GC_log_printf("thread %p(0x%lx) completed join with thread %p\n", GC_PTHREAD_PTRVAL(pthread_self()), (long)GetCurrentThreadId(), GC_PTHREAD_PTRVAL(pthread_id)); # endif return result; } /* Cygwin-pthreads calls CreateThread internally, but it's not easily */ /* interceptible by us..., so intercept pthread_create instead. */ GC_API int GC_pthread_create(pthread_t *new_thread, GC_PTHREAD_CREATE_CONST pthread_attr_t *attr, void *(*start_routine)(void *), void *arg) { int result; struct start_info * si; if (!EXPECT(parallel_initialized, TRUE)) GC_init_parallel(); /* make sure GC is initialized (i.e. main thread is attached) */ GC_ASSERT(!GC_win32_dll_threads); /* This is otherwise saved only in an area mmapped by the thread */ /* library, which isn't visible to the collector. */ si = GC_malloc_uncollectable(sizeof(struct start_info)); if (0 == si) return(EAGAIN); si -> start_routine = start_routine; si -> arg = arg; if (attr != 0 && pthread_attr_getdetachstate(attr, &si->detached) == PTHREAD_CREATE_DETACHED) { si->detached = TRUE; } # ifdef DEBUG_THREADS GC_log_printf("About to create a thread from %p(0x%lx)\n", GC_PTHREAD_PTRVAL(pthread_self()), (long)GetCurrentThreadId()); # endif # ifndef GC_ALWAYS_MULTITHREADED GC_need_to_lock = TRUE; # endif result = pthread_create(new_thread, attr, GC_pthread_start, si); if (result) { /* failure */ GC_free(si); } return(result); } STATIC void * GC_CALLBACK GC_pthread_start_inner(struct GC_stack_base *sb, void * arg) { struct start_info * si = arg; void * result; void *(*start)(void *); void *start_arg; DWORD thread_id = GetCurrentThreadId(); pthread_t pthread_id = pthread_self(); GC_thread me; DCL_LOCK_STATE; # ifdef DEBUG_THREADS GC_log_printf("thread %p(0x%x) starting...\n", GC_PTHREAD_PTRVAL(pthread_id), (int)thread_id); # endif GC_ASSERT(!GC_win32_dll_threads); /* If a GC occurs before the thread is registered, that GC will */ /* ignore this thread. That's fine, since it will block trying to */ /* acquire the allocation lock, and won't yet hold interesting */ /* pointers. */ LOCK(); /* We register the thread here instead of in the parent, so that */ /* we don't need to hold the allocation lock during pthread_create. */ me = GC_register_my_thread_inner(sb, thread_id); SET_PTHREAD_MAP_CACHE(pthread_id, thread_id); me -> pthread_id = pthread_id; if (si->detached) me -> flags |= DETACHED; UNLOCK(); start = si -> start_routine; start_arg = si -> arg; GC_free(si); /* was allocated uncollectible */ pthread_cleanup_push(GC_thread_exit_proc, (void *)me); result = (*start)(start_arg); me -> status = result; pthread_cleanup_pop(1); # ifdef DEBUG_THREADS GC_log_printf("thread %p(0x%x) returned from start routine\n", GC_PTHREAD_PTRVAL(pthread_id), (int)thread_id); # endif return(result); } STATIC void * GC_pthread_start(void * arg) { return GC_call_with_stack_base(GC_pthread_start_inner, arg); } STATIC void GC_thread_exit_proc(void *arg) { GC_thread me = (GC_thread)arg; DCL_LOCK_STATE; GC_ASSERT(!GC_win32_dll_threads); # ifdef DEBUG_THREADS GC_log_printf("thread %p(0x%lx) called pthread_exit()\n", GC_PTHREAD_PTRVAL(pthread_self()), (long)GetCurrentThreadId()); # endif LOCK(); GC_wait_for_gc_completion(FALSE); # if defined(THREAD_LOCAL_ALLOC) GC_ASSERT(GC_getspecific(GC_thread_key) == &me->tlfs); GC_destroy_thread_local(&(me->tlfs)); # endif if (me -> flags & DETACHED) { GC_delete_thread(GetCurrentThreadId()); } else { /* deallocate it as part of join */ me -> flags |= FINISHED; } # if defined(THREAD_LOCAL_ALLOC) /* It is required to call remove_specific defined in specific.c. */ GC_remove_specific(GC_thread_key); # endif UNLOCK(); } # ifndef GC_NO_PTHREAD_SIGMASK /* Win32 pthread does not support sigmask. */ /* So, nothing required here... */ GC_API int GC_pthread_sigmask(int how, const sigset_t *set, sigset_t *oset) { return pthread_sigmask(how, set, oset); } # endif /* !GC_NO_PTHREAD_SIGMASK */ GC_API int GC_pthread_detach(pthread_t thread) { int result; GC_thread t; DCL_LOCK_STATE; GC_ASSERT(!GC_win32_dll_threads); LOCK(); t = GC_lookup_pthread(thread); UNLOCK(); result = pthread_detach(thread); if (result == 0) { if (NULL == t) ABORT("Thread not registered"); LOCK(); t -> flags |= DETACHED; /* Here the pthread thread id may have been recycled. */ if ((t -> flags & FINISHED) != 0) { GC_delete_gc_thread_no_free(t); GC_INTERNAL_FREE(t); } UNLOCK(); } return result; } #elif !defined(GC_NO_THREADS_DISCOVERY) /* We avoid acquiring locks here, since this doesn't seem to be */ /* preemptible. This may run with an uninitialized collector, in */ /* which case we don't do much. This implies that no threads other */ /* than the main one should be created with an uninitialized */ /* collector. (The alternative of initializing the collector here */ /* seems dangerous, since DllMain is limited in what it can do.) */ # ifdef GC_INSIDE_DLL /* Export only if needed by client. */ GC_API # else # define GC_DllMain DllMain # endif BOOL WINAPI GC_DllMain(HINSTANCE inst GC_ATTR_UNUSED, ULONG reason, LPVOID reserved GC_ATTR_UNUSED) { DWORD thread_id; static int entry_count = 0; if (!GC_win32_dll_threads && parallel_initialized) return TRUE; switch (reason) { case DLL_THREAD_ATTACH: # ifdef PARALLEL_MARK /* Don't register marker threads. */ if (GC_parallel) { /* We could reach here only if parallel_initialized == FALSE. */ break; } # endif GC_ASSERT(entry_count == 0 || parallel_initialized); ++entry_count; /* and fall through: */ case DLL_PROCESS_ATTACH: /* This may run with the collector uninitialized. */ thread_id = GetCurrentThreadId(); if (parallel_initialized && GC_main_thread != thread_id) { # ifdef PARALLEL_MARK ABORT("Cannot initialize parallel marker from DllMain"); # else struct GC_stack_base sb; /* Don't lock here. */ # ifdef GC_ASSERTIONS int sb_result = # endif GC_get_stack_base(&sb); GC_ASSERT(sb_result == GC_SUCCESS); GC_register_my_thread_inner(&sb, thread_id); # endif } /* o.w. we already did it during GC_thr_init, called by GC_init */ break; case DLL_THREAD_DETACH: /* We are hopefully running in the context of the exiting thread. */ GC_ASSERT(parallel_initialized); if (GC_win32_dll_threads) { GC_delete_thread(GetCurrentThreadId()); } break; case DLL_PROCESS_DETACH: if (GC_win32_dll_threads) { int i; int my_max = (int)GC_get_max_thread_index(); for (i = 0; i <= my_max; ++i) { if (AO_load(&(dll_thread_table[i].tm.in_use))) GC_delete_gc_thread_no_free(&dll_thread_table[i]); } GC_deinit(); DeleteCriticalSection(&GC_allocate_ml); } break; } return TRUE; } #endif /* !GC_NO_THREADS_DISCOVERY && !GC_PTHREADS */ /* Perform all initializations, including those that */ /* may require allocation. */ /* Called without allocation lock. */ /* Must be called before a second thread is created. */ GC_INNER void GC_init_parallel(void) { # if defined(THREAD_LOCAL_ALLOC) GC_thread me; DCL_LOCK_STATE; # endif if (parallel_initialized) return; parallel_initialized = TRUE; /* GC_init() calls us back, so set flag first. */ if (!GC_is_initialized) GC_init(); # ifndef GC_ALWAYS_MULTITHREADED if (GC_win32_dll_threads) { GC_need_to_lock = TRUE; /* Cannot intercept thread creation. Hence we don't know if */ /* other threads exist. However, client is not allowed to */ /* create other threads before collector initialization. */ /* Thus it's OK not to lock before this. */ } # endif /* Initialize thread local free lists if used. */ # if defined(THREAD_LOCAL_ALLOC) LOCK(); me = GC_lookup_thread_inner(GetCurrentThreadId()); CHECK_LOOKUP_MY_THREAD(me); GC_init_thread_local(&me->tlfs); UNLOCK(); # endif } #if defined(USE_PTHREAD_LOCKS) /* Support for pthread locking code. */ /* Pthread_mutex_try_lock may not win here, */ /* due to builtin support for spinning first? */ GC_INNER volatile GC_bool GC_collecting = 0; /* A hint that we're in the collector and */ /* holding the allocation lock for an */ /* extended period. */ GC_INNER void GC_lock(void) { pthread_mutex_lock(&GC_allocate_ml); } #endif /* USE_PTHREAD_LOCKS */ #if defined(THREAD_LOCAL_ALLOC) /* Add thread-local allocation support. VC++ uses __declspec(thread). */ /* We must explicitly mark ptrfree and gcj free lists, since the free */ /* list links wouldn't otherwise be found. We also set them in the */ /* normal free lists, since that involves touching less memory than if */ /* we scanned them normally. */ GC_INNER void GC_mark_thread_local_free_lists(void) { int i; GC_thread p; for (i = 0; i < THREAD_TABLE_SZ; ++i) { for (p = GC_threads[i]; 0 != p; p = p -> tm.next) { if (!KNOWN_FINISHED(p)) { # ifdef DEBUG_THREADS GC_log_printf("Marking thread locals for 0x%x\n", (int)p -> id); # endif GC_mark_thread_local_fls_for(&(p->tlfs)); } } } } # if defined(GC_ASSERTIONS) void GC_check_tls_for(GC_tlfs p); # if defined(USE_CUSTOM_SPECIFIC) void GC_check_tsd_marks(tsd *key); # endif /* Check that all thread-local free-lists are completely marked. */ /* also check that thread-specific-data structures are marked. */ void GC_check_tls(void) { int i; GC_thread p; for (i = 0; i < THREAD_TABLE_SZ; ++i) { for (p = GC_threads[i]; 0 != p; p = p -> tm.next) { if (!KNOWN_FINISHED(p)) GC_check_tls_for(&(p->tlfs)); } } # if defined(USE_CUSTOM_SPECIFIC) if (GC_thread_key != 0) GC_check_tsd_marks(GC_thread_key); # endif } # endif /* GC_ASSERTIONS */ #endif /* THREAD_LOCAL_ALLOC ... */ # ifndef GC_NO_THREAD_REDIRECTS /* Restore thread calls redirection. */ # define CreateThread GC_CreateThread # define ExitThread GC_ExitThread # undef _beginthreadex # define _beginthreadex GC_beginthreadex # undef _endthreadex # define _endthreadex GC_endthreadex # endif /* !GC_NO_THREAD_REDIRECTS */ #endif /* GC_WIN32_THREADS */ ecl-16.1.2/src/bdwgc/windows-untested/000077500000000000000000000000001266352375300175605ustar00rootroot00000000000000ecl-16.1.2/src/bdwgc/windows-untested/README000066400000000000000000000003021266352375300204330ustar00rootroot00000000000000gc.def should probably be removed completely. I removed an apparently erroneous line for GC_CreateThread. Unfortunately gc.def is referenced in various other places I cannot easily edit. -HB ecl-16.1.2/src/bdwgc/windows-untested/gc.def000066400000000000000000000000451266352375300206300ustar00rootroot00000000000000EXPORTS GC_version DATA ecl-16.1.2/src/bdwgc/windows-untested/gc.rc000066400000000000000000000000221266352375300204710ustar00rootroot00000000000000#include "gc.ver" ecl-16.1.2/src/bdwgc/windows-untested/gc.ver000066400000000000000000000045321266352375300206730ustar00rootroot00000000000000#include #include #include "../include/../version.h" #define GC_VERSION_REVISION 0 #define GC_VERSION ((GC_VERSION_MAJOR) * 100 + GC_VERSION_MINOR) #define GC_FULL_VERSION ((GC_VERSION) * 10000 + GC_VERSION_MICRO) #ifndef __T # ifdef UNICODE # define __T(x) L ## x # else # define __T(x) x # endif #endif #define PP_TSTR(x) __T(#x) #define PP_EVAL_TSTR(x) PP_TSTR(x) #define GC_VERSION_STR PP_EVAL_TSTR(GC_VERSION_MAJOR) __T(".") PP_EVAL_TSTR(GC_VERSION_MINOR) #define GC_FULL_VERSION_STR PP_EVAL_TSTR(GC_VERSION_MAJOR) __T(".") PP_EVAL_TSTR(GC_VERSION_MINOR) __T(".") PP_EVAL_TSTR(GC_VERSION_MICRO) __T(".") PP_EVAL_TSTR(GC_VERSION_REVISION) #define GC_FULL_VERSION_CSV GC_VERSION_MAJOR, GC_VERSION_MINOR, GC_VERSION_MICRO, GC_VERSION_REVISION #ifdef _DEBUG #define VER_DEBUG VS_FF_DEBUG #else #define VER_DEBUG 0 #endif #ifdef _BETA #define VER_PRERELEASE VS_FF_PRERELEASE #else #define VER_PRERELEASE 0 #endif LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US #pragma code_page(1252) VS_VERSION_INFO VERSIONINFO FILEVERSION GC_FULL_VERSION_CSV PRODUCTVERSION GC_FULL_VERSION_CSV FILEFLAGSMASK VS_FFI_FILEFLAGSMASK FILEFLAGS VER_DEBUG | VER_PRERELEASE FILEOS VOS__WINDOWS32 FILETYPE VFT_DLL FILESUBTYPE VFT2_UNKNOWN BEGIN BLOCK "StringFileInfo" BEGIN BLOCK "040904B0" BEGIN VALUE "CompanyName", "\ Hans-J. Boehm, \ Alan J. Demers, \ Xerox Corporation, \ Silicon Graphics, \ and Hewlett-Packard Company. \ \0" VALUE "LegalCopyright", "\ Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers. \ Copyright (c) 1991-1995 by Xerox Corporation. All rights reserved. \ Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. \ Copyright (c) 1999-2004 by Hewlett-Packard. All rights reserved. \ \0" VALUE "OriginalFilename", "GC.DLL\0" VALUE "InternalName", "GC\0" VALUE "FileDescription", "Conservative Garbage Collector for C and C++\0" VALUE "FileVersion", GC_FULL_VERSION_STR VALUE "ProductName", "Conservative Garbage Collector for C and C++\0" VALUE "ProductVersion", GC_FULL_VERSION_STR END END BLOCK "VarFileInfo" BEGIN VALUE "Translation", 0x409, 1200 END END ecl-16.1.2/src/bdwgc/windows-untested/stdafx.c000066400000000000000000000000241266352375300212110ustar00rootroot00000000000000#include "stdafx.h" ecl-16.1.2/src/bdwgc/windows-untested/stdafx.h000066400000000000000000000004121266352375300212170ustar00rootroot00000000000000#define WIN32_LEAN_AND_MEAN #include #pragma warning(error: 4013) // function undefined; assuming extern returning int #ifdef _MT # define GC_THREADS 1 #endif #ifdef _DEBUG # define GC_DEBUG #endif #define SAVE_CALL_CHAIN #define SAVE_CALL_COUNT 8 ecl-16.1.2/src/bdwgc/windows-untested/vc60/000077500000000000000000000000001266352375300203365ustar00rootroot00000000000000ecl-16.1.2/src/bdwgc/windows-untested/vc60/all.dsp000066400000000000000000000032741266352375300216240ustar00rootroot00000000000000# Microsoft Developer Studio Project File - Name="all" - Package Owner=<4> # Microsoft Developer Studio Generated Build File, Format Version 6.00 # ** DO NOT EDIT ** # TARGTYPE "Win32 (x86) Generic Project" 0x010a CFG=all - Win32 Debug !MESSAGE This is not a valid makefile. To build this project using NMAKE, !MESSAGE use the Export Makefile command and run !MESSAGE !MESSAGE NMAKE /f "all.mak". !MESSAGE !MESSAGE You can specify a configuration when running NMAKE !MESSAGE by defining the macro CFG on the command line. For example: !MESSAGE !MESSAGE NMAKE /f "all.mak" CFG="all - Win32 Debug" !MESSAGE !MESSAGE Possible choices for configuration are: !MESSAGE !MESSAGE "all - Win32 Release" (based on "Win32 (x86) Generic Project") !MESSAGE "all - Win32 Debug" (based on "Win32 (x86) Generic Project") !MESSAGE # Begin Project # PROP AllowPerConfigDependencies 0 # PROP Scc_ProjName "" # PROP Scc_LocalPath "" MTL=midl.exe !IF "$(CFG)" == "all - Win32 Release" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 0 # PROP BASE Output_Dir "Release" # PROP BASE Intermediate_Dir "Release" # PROP BASE Target_Dir "" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 0 # PROP Output_Dir "..\..\..\bin" # PROP Intermediate_Dir "..\..\..\obj\Release" # PROP Target_Dir "" !ELSEIF "$(CFG)" == "all - Win32 Debug" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 1 # PROP BASE Output_Dir "Debug" # PROP BASE Intermediate_Dir "Debug" # PROP BASE Target_Dir "" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 1 # PROP Output_Dir "..\..\..\bin" # PROP Intermediate_Dir "..\..\..\obj\Debug" # PROP Target_Dir "" !ENDIF # Begin Target # Name "all - Win32 Release" # Name "all - Win32 Debug" # End Target # End Project ecl-16.1.2/src/bdwgc/windows-untested/vc60/gc.dsp000066400000000000000000000200421266352375300214350ustar00rootroot00000000000000# Microsoft Developer Studio Project File - Name="gc" - Package Owner=<4> # Microsoft Developer Studio Generated Build File, Format Version 6.00 # ** DO NOT EDIT ** # TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102 CFG=gc - Win32 Debug !MESSAGE This is not a valid makefile. To build this project using NMAKE, !MESSAGE use the Export Makefile command and run !MESSAGE !MESSAGE NMAKE /f "gc.mak". !MESSAGE !MESSAGE You can specify a configuration when running NMAKE !MESSAGE by defining the macro CFG on the command line. For example: !MESSAGE !MESSAGE NMAKE /f "gc.mak" CFG="gc - Win32 Debug" !MESSAGE !MESSAGE Possible choices for configuration are: !MESSAGE !MESSAGE "gc - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library") !MESSAGE "gc - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library") !MESSAGE # Begin Project # PROP AllowPerConfigDependencies 0 # PROP Scc_ProjName "" # PROP Scc_LocalPath "" CPP=cl.exe MTL=midl.exe RSC=rc.exe !IF "$(CFG)" == "gc - Win32 Release" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 0 # PROP BASE Output_Dir "Release" # PROP BASE Intermediate_Dir "Release" # PROP BASE Target_Dir "" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 0 # PROP Output_Dir "..\..\..\bin" # PROP Intermediate_Dir "..\..\..\obj\Release\gc" # PROP Ignore_Export_Lib 0 # PROP Target_Dir "" # ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "GC_EXPORTS" /YX /FD /c # ADD CPP /nologo /MD /W3 /GX /Zi /O2 /I "..\..\include" /FI"stdafx.h" /D "NDEBUG" /D "_WINDOWS" /D "_USRDLL" /D "GC_DLL" /D "WIN32" /D "_MBCS" /D "GC_THREADS" /Yu"stdafx.h" /FD /c # ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32 # ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32 # ADD BASE RSC /l 0x409 /d "NDEBUG" # ADD RSC /l 0x409 /i "..\..\include" /d "NDEBUG" BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo LINK32=link.exe # ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386 # ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib /nologo /base:"0x37C30000" /subsystem:console /dll /debug /machine:I386 /out:"..\..\..\bin/gc60.dll" /implib:"..\..\..\lib/gc.lib" /opt:ref /release # SUBTRACT LINK32 /pdb:none # Begin Special Build Tool OutDir=.\..\..\..\bin SOURCE="$(InputPath)" PostBuild_Cmds=del $(OutDir)\..\lib\gc.exp # End Special Build Tool !ELSEIF "$(CFG)" == "gc - Win32 Debug" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 1 # PROP BASE Output_Dir "Debug" # PROP BASE Intermediate_Dir "Debug" # PROP BASE Target_Dir "" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 1 # PROP Output_Dir "..\..\..\bin" # PROP Intermediate_Dir "..\..\..\obj\Debug\gc" # PROP Ignore_Export_Lib 0 # PROP Target_Dir "" # ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "GC_EXPORTS" /YX /FD /GZ /c # ADD CPP /nologo /MDd /W3 /GX /Zi /Od /I "..\..\include" /FI"stdafx.h" /D "_DEBUG" /D "_WINDOWS" /D "_USRDLL" /D "GC_DLL" /D "WIN32" /D "_MBCS" /D "GC_THREADS" /Yu"stdafx.h" /FD /GZ /c # ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32 # ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32 # ADD BASE RSC /l 0x409 /d "_DEBUG" # ADD RSC /l 0x409 /i "..\..\include" /d "_DEBUG" BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo /o"..\..\..\bin/gcd.bsc" LINK32=link.exe # ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /pdbtype:sept # ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib /nologo /base:"0x37C30000" /subsystem:console /dll /incremental:no /debug /machine:I386 /out:"..\..\..\bin/gc60d.dll" /implib:"..\..\..\lib/gcd.lib" /pdbtype:sept # SUBTRACT LINK32 /pdb:none # Begin Special Build Tool OutDir=.\..\..\..\bin SOURCE="$(InputPath)" PostBuild_Cmds=del $(OutDir)\..\lib\gcd.exp # End Special Build Tool !ENDIF # Begin Target # Name "gc - Win32 Release" # Name "gc - Win32 Debug" # Begin Group "Source Files" # PROP Default_Filter "c;cpp;cc;cxx;tcc;rc;def;r;odl;idl;hpj;bat" # Begin Source File SOURCE=..\..\allchblk.c # End Source File # Begin Source File SOURCE=..\..\alloc.c # End Source File # Begin Source File SOURCE=..\..\backgraph.c # End Source File # Begin Source File SOURCE=..\..\blacklst.c # End Source File # Begin Source File SOURCE=..\..\checksums.c # End Source File # Begin Source File SOURCE=..\..\dbg_mlc.c # End Source File # Begin Source File SOURCE=..\..\gcj_mlc.c # End Source File # Begin Source File SOURCE=..\..\fnlz_mlc.c # End Source File # Begin Source File SOURCE=..\..\dyn_load.c # End Source File # Begin Source File SOURCE=..\..\finalize.c # End Source File # Begin Source File SOURCE=..\..\headers.c # End Source File # Begin Source File SOURCE=..\..\mach_dep.c # End Source File # Begin Source File SOURCE=..\..\malloc.c # End Source File # Begin Source File SOURCE=..\..\mallocx.c # End Source File # Begin Source File SOURCE=..\..\mark.c # End Source File # Begin Source File SOURCE=..\..\mark_rts.c # End Source File # Begin Source File SOURCE=..\..\misc.c # End Source File # Begin Source File SOURCE=..\..\msvc_dbg.c # End Source File # Begin Source File SOURCE=..\..\new_hblk.c # End Source File # Begin Source File SOURCE=..\..\obj_map.c # End Source File # Begin Source File SOURCE=..\..\os_dep.c # End Source File # Begin Source File SOURCE=..\..\ptr_chck.c # End Source File # Begin Source File SOURCE=..\..\reclaim.c # End Source File # Begin Source File SOURCE=..\stdafx.c # ADD CPP /Yc"stdafx.h" # End Source File # Begin Source File SOURCE=..\..\stubborn.c # End Source File # Begin Source File SOURCE=..\..\typd_mlc.c # End Source File # Begin Source File SOURCE=..\..\win32_threads.c # End Source File # End Group # Begin Group "Header Files" # PROP Default_Filter "h;hh;hpp;hxx;hm;inl" # Begin Source File SOURCE=..\..\include\gc.h # End Source File # Begin Source File SOURCE=..\..\include\gc_allocator.h # End Source File # Begin Source File SOURCE=..\..\include\gc_backptr.h # End Source File # Begin Source File SOURCE=..\..\include\gc_config_macros.h # End Source File # Begin Source File SOURCE=..\..\include\gc_cpp.h # End Source File # Begin Source File SOURCE=..\..\include\gc_gcj.h # End Source File # Begin Source File SOURCE=..\..\include\private\gc_hdrs.h # End Source File # Begin Source File SOURCE=..\..\include\gc_inl.h # End Source File # Begin Source File SOURCE=..\..\include\gc_inline.h # End Source File # Begin Source File SOURCE=..\..\include\private\gc_locks.h # End Source File # Begin Source File SOURCE=..\..\include\gc_mark.h # End Source File # Begin Source File SOURCE=..\..\include\gc_disclaim.h # End Source File # Begin Source File SOURCE=..\..\include\private\gc_pmark.h # End Source File # Begin Source File SOURCE=..\..\include\private\gc_priv.h # End Source File # Begin Source File SOURCE=..\..\include\gc_pthread_redirects.h # End Source File # Begin Source File SOURCE=..\..\include\gc_typed.h # End Source File # Begin Source File SOURCE=..\..\include\private\gcconfig.h # End Source File # Begin Source File SOURCE=..\..\include\javaxfc.h # End Source File # Begin Source File SOURCE=..\..\include\leak_detector.h # End Source File # Begin Source File SOURCE=..\..\msvc_dbg.h # End Source File # Begin Source File SOURCE=..\..\include\new_gc_alloc.h # End Source File # Begin Source File SOURCE=..\stdafx.h # End Source File # Begin Source File SOURCE=..\..\version.h # End Source File # Begin Source File SOURCE=..\..\include\weakpointer.h # End Source File # End Group # Begin Group "Resource Files" # PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe" # Begin Source File SOURCE=..\gc.def # End Source File # Begin Source File SOURCE=..\gc.rc # End Source File # Begin Source File SOURCE=..\gc.ver # End Source File # End Group # End Target # End Project ecl-16.1.2/src/bdwgc/windows-untested/vc60/gc.dsw000066400000000000000000000070431266352375300214520ustar00rootroot00000000000000Microsoft Developer Studio Workspace File, Format Version 6.00 # WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE! ############################################################################### Project: "all"=".\all.dsp" - Package Owner=<4> Package=<5> {{{ }}} Package=<4> {{{ Begin Project Dependency Project_Dep_Name gc End Project Dependency Begin Project Dependency Project_Dep_Name libgc End Project Dependency Begin Project Dependency Project_Dep_Name libgcmt End Project Dependency }}} ############################################################################### Project: "gc"=".\gc.dsp" - Package Owner=<4> Package=<5> {{{ }}} Package=<4> {{{ }}} ############################################################################### Project: "libgc"=".\libgc.dsp" - Package Owner=<4> Package=<5> {{{ }}} Package=<4> {{{ }}} ############################################################################### Project: "libgcmt"=".\libgcmt.dsp" - Package Owner=<4> Package=<5> {{{ }}} Package=<4> {{{ }}} ############################################################################### Project: "test"=".\test.dsp" - Package Owner=<4> Package=<5> {{{ }}} Package=<4> {{{ Begin Project Dependency Project_Dep_Name test_gc End Project Dependency Begin Project Dependency Project_Dep_Name test_libgc End Project Dependency Begin Project Dependency Project_Dep_Name test_libgcmt End Project Dependency Begin Project Dependency Project_Dep_Name test_leak_gc End Project Dependency Begin Project Dependency Project_Dep_Name test_leak_libgc End Project Dependency Begin Project Dependency Project_Dep_Name test_leak_libgcmt End Project Dependency }}} ############################################################################### Project: "test_gc"=".\test_gc.dsp" - Package Owner=<4> Package=<5> {{{ }}} Package=<4> {{{ Begin Project Dependency Project_Dep_Name gc End Project Dependency }}} ############################################################################### Project: "test_leak_gc"=".\test_leak_gc.dsp" - Package Owner=<4> Package=<5> {{{ }}} Package=<4> {{{ Begin Project Dependency Project_Dep_Name gc End Project Dependency }}} ############################################################################### Project: "test_leak_libgc"=".\test_leak_libgc.dsp" - Package Owner=<4> Package=<5> {{{ }}} Package=<4> {{{ Begin Project Dependency Project_Dep_Name libgc End Project Dependency }}} ############################################################################### Project: "test_leak_libgcmt"=".\test_leak_libgcmt.dsp" - Package Owner=<4> Package=<5> {{{ }}} Package=<4> {{{ Begin Project Dependency Project_Dep_Name libgcmt End Project Dependency }}} ############################################################################### Project: "test_libgc"=".\test_libgc.dsp" - Package Owner=<4> Package=<5> {{{ }}} Package=<4> {{{ Begin Project Dependency Project_Dep_Name libgc End Project Dependency }}} ############################################################################### Project: "test_libgcmt"=".\test_libgcmt.dsp" - Package Owner=<4> Package=<5> {{{ }}} Package=<4> {{{ Begin Project Dependency Project_Dep_Name libgcmt End Project Dependency }}} ############################################################################### Global: Package=<5> {{{ }}} Package=<3> {{{ }}} ############################################################################### ecl-16.1.2/src/bdwgc/windows-untested/vc60/libgc.dsp000066400000000000000000000134541266352375300221350ustar00rootroot00000000000000# Microsoft Developer Studio Project File - Name="libgc" - Package Owner=<4> # Microsoft Developer Studio Generated Build File, Format Version 6.00 # ** DO NOT EDIT ** # TARGTYPE "Win32 (x86) Static Library" 0x0104 CFG=libgc - Win32 Debug !MESSAGE This is not a valid makefile. To build this project using NMAKE, !MESSAGE use the Export Makefile command and run !MESSAGE !MESSAGE NMAKE /f "libgc.mak". !MESSAGE !MESSAGE You can specify a configuration when running NMAKE !MESSAGE by defining the macro CFG on the command line. For example: !MESSAGE !MESSAGE NMAKE /f "libgc.mak" CFG="libgc - Win32 Debug" !MESSAGE !MESSAGE Possible choices for configuration are: !MESSAGE !MESSAGE "libgc - Win32 Release" (based on "Win32 (x86) Static Library") !MESSAGE "libgc - Win32 Debug" (based on "Win32 (x86) Static Library") !MESSAGE # Begin Project # PROP AllowPerConfigDependencies 0 # PROP Scc_ProjName "" # PROP Scc_LocalPath "" CPP=cl.exe RSC=rc.exe !IF "$(CFG)" == "libgc - Win32 Release" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 0 # PROP BASE Output_Dir "Release" # PROP BASE Intermediate_Dir "Release" # PROP BASE Target_Dir "" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 0 # PROP Output_Dir "..\..\..\lib" # PROP Intermediate_Dir "..\..\..\obj\Release\libgc" # PROP Target_Dir "" # ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /YX /FD /c # ADD CPP /nologo /W3 /GX /Zi /O2 /I "..\..\include" /FI"stdafx.h" /D "NDEBUG" /D "_LIB" /D "WIN32" /D "_MBCS" /Yu"stdafx.h" /Fd"..\..\..\lib\libgc.pdb" /FD /c # ADD BASE RSC /l 0x409 /d "NDEBUG" # ADD RSC /l 0x409 /d "NDEBUG" BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo LIB32=link.exe -lib # ADD BASE LIB32 /nologo # ADD LIB32 /nologo # Begin Special Build Tool OutDir=.\..\..\..\lib TargetName=libgc SOURCE="$(InputPath)" PostBuild_Cmds=del $(OutDir)\$(TargetName).idb # End Special Build Tool !ELSEIF "$(CFG)" == "libgc - Win32 Debug" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 1 # PROP BASE Output_Dir "Debug" # PROP BASE Intermediate_Dir "Debug" # PROP BASE Target_Dir "" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 1 # PROP Output_Dir "..\..\..\lib" # PROP Intermediate_Dir "..\..\..\obj\Debug\libgc" # PROP Target_Dir "" # ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c # ADD CPP /nologo /W3 /GX /Zi /Od /I "..\..\include" /FI"stdafx.h" /D "_DEBUG" /D "_LIB" /D "WIN32" /D "_MBCS" /Yu"stdafx.h" /Fd"..\..\..\lib\libgcd.pdb" /FD /GZ /c # ADD BASE RSC /l 0x409 /d "_DEBUG" # ADD RSC /l 0x409 /d "_DEBUG" BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo /o"..\..\..\lib/libgcd.bsc" LIB32=link.exe -lib # ADD BASE LIB32 /nologo # ADD LIB32 /nologo /out:"..\..\..\lib\libgcd.lib" # Begin Special Build Tool OutDir=.\..\..\..\lib TargetName=libgcd SOURCE="$(InputPath)" PostBuild_Cmds=del $(OutDir)\$(TargetName).idb # End Special Build Tool !ENDIF # Begin Target # Name "libgc - Win32 Release" # Name "libgc - Win32 Debug" # Begin Group "Source Files" # PROP Default_Filter "c;cpp;cc;cxx;tcc;rc;def;r;odl;idl;hpj;bat" # Begin Source File SOURCE=..\..\allchblk.c # End Source File # Begin Source File SOURCE=..\..\alloc.c # End Source File # Begin Source File SOURCE=..\..\backgraph.c # End Source File # Begin Source File SOURCE=..\..\blacklst.c # End Source File # Begin Source File SOURCE=..\..\checksums.c # End Source File # Begin Source File SOURCE=..\..\dbg_mlc.c # End Source File # Begin Source File SOURCE=..\..\gcj_mlc.c # End Source File # Begin Source File SOURCE=..\..\fnlz_mlc.c # End Source File # Begin Source File SOURCE=..\..\dyn_load.c # End Source File # Begin Source File SOURCE=..\..\finalize.c # End Source File # Begin Source File SOURCE=..\..\headers.c # End Source File # Begin Source File SOURCE=..\..\mach_dep.c # End Source File # Begin Source File SOURCE=..\..\malloc.c # End Source File # Begin Source File SOURCE=..\..\mallocx.c # End Source File # Begin Source File SOURCE=..\..\mark.c # End Source File # Begin Source File SOURCE=..\..\mark_rts.c # End Source File # Begin Source File SOURCE=..\..\misc.c # End Source File # Begin Source File SOURCE=..\..\msvc_dbg.c # End Source File # Begin Source File SOURCE=..\..\new_hblk.c # End Source File # Begin Source File SOURCE=..\..\obj_map.c # End Source File # Begin Source File SOURCE=..\..\os_dep.c # End Source File # Begin Source File SOURCE=..\..\ptr_chck.c # End Source File # Begin Source File SOURCE=..\..\reclaim.c # End Source File # Begin Source File SOURCE=..\stdafx.c # ADD CPP /Yc"stdafx.h" # End Source File # Begin Source File SOURCE=..\..\stubborn.c # End Source File # Begin Source File SOURCE=..\..\typd_mlc.c # End Source File # Begin Source File SOURCE=..\..\win32_threads.c # End Source File # End Group # Begin Group "Header Files" # PROP Default_Filter "h;hh;hpp;hxx;hm;inl" # Begin Source File SOURCE=..\..\include\gc_allocator.h # End Source File # Begin Source File SOURCE=..\..\include\gc_backptr.h # End Source File # Begin Source File SOURCE=..\..\include\gc_cpp.h # End Source File # Begin Source File SOURCE=..\..\include\gc_gcj.h # End Source File # Begin Source File SOURCE=..\..\include\gc_inl.h # End Source File # Begin Source File SOURCE=..\..\include\gc_inline.h # End Source File # Begin Source File SOURCE=..\..\include\gc_pthread_redirects.h # End Source File # Begin Source File SOURCE=..\..\include\javaxfc.h # End Source File # Begin Source File SOURCE=..\..\include\leak_detector.h # End Source File # Begin Source File SOURCE=..\..\msvc_dbg.h # End Source File # Begin Source File SOURCE=..\..\include\new_gc_alloc.h # End Source File # Begin Source File SOURCE=..\stdafx.h # End Source File # Begin Source File SOURCE=..\..\version.h # End Source File # Begin Source File SOURCE=..\..\include\weakpointer.h # End Source File # End Group # End Target # End Project ecl-16.1.2/src/bdwgc/windows-untested/vc60/libgcmt.dsp000066400000000000000000000121361266352375300224720ustar00rootroot00000000000000# Microsoft Developer Studio Project File - Name="libgcmt" - Package Owner=<4> # Microsoft Developer Studio Generated Build File, Format Version 6.00 # ** DO NOT EDIT ** # TARGTYPE "Win32 (x86) Static Library" 0x0104 CFG=libgcmt - Win32 Debug !MESSAGE This is not a valid makefile. To build this project using NMAKE, !MESSAGE use the Export Makefile command and run !MESSAGE !MESSAGE NMAKE /f "libgcmt.mak". !MESSAGE !MESSAGE You can specify a configuration when running NMAKE !MESSAGE by defining the macro CFG on the command line. For example: !MESSAGE !MESSAGE NMAKE /f "libgcmt.mak" CFG="libgcmt - Win32 Debug" !MESSAGE !MESSAGE Possible choices for configuration are: !MESSAGE !MESSAGE "libgcmt - Win32 Release" (based on "Win32 (x86) Static Library") !MESSAGE "libgcmt - Win32 Debug" (based on "Win32 (x86) Static Library") !MESSAGE # Begin Project # PROP AllowPerConfigDependencies 0 # PROP Scc_ProjName "" # PROP Scc_LocalPath "" CPP=cl.exe RSC=rc.exe !IF "$(CFG)" == "libgcmt - Win32 Release" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 0 # PROP BASE Output_Dir "Release" # PROP BASE Intermediate_Dir "Release" # PROP BASE Target_Dir "" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 0 # PROP Output_Dir "..\..\..\lib" # PROP Intermediate_Dir "..\..\..\obj\Release\libgcmt" # PROP Target_Dir "" # ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /YX /FD /c # ADD CPP /nologo /MT /W3 /GX /Zi /O2 /I "..\..\include" /FI"stdafx.h" /D "NDEBUG" /D "_LIB" /D "WIN32" /D "_MBCS" /D "GC_THREADS" /Yu"stdafx.h" /Fd"..\..\..\lib\libgcmt.pdb" /Zl /FD /c # ADD BASE RSC /l 0x409 /d "NDEBUG" # ADD RSC /l 0x409 /d "NDEBUG" BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo LIB32=link.exe -lib # ADD BASE LIB32 /nologo # ADD LIB32 /nologo # Begin Special Build Tool OutDir=.\..\..\..\lib TargetName=libgcmt SOURCE="$(InputPath)" PostBuild_Cmds=del $(OutDir)\$(TargetName).idb # End Special Build Tool !ELSEIF "$(CFG)" == "libgcmt - Win32 Debug" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 1 # PROP BASE Output_Dir "Debug" # PROP BASE Intermediate_Dir "Debug" # PROP BASE Target_Dir "" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 1 # PROP Output_Dir "..\..\..\lib" # PROP Intermediate_Dir "..\..\..\obj\Debug\libgcmt" # PROP Target_Dir "" # ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c # ADD CPP /nologo /MTd /W3 /GX /Zi /Od /I "..\..\include" /FI"stdafx.h" /D "_DEBUG" /D "_LIB" /D "WIN32" /D "_MBCS" /D "GC_THREADS" /Yu"stdafx.h" /Fd"..\..\..\lib\libgcmtd.pdb" /Zl /FD /GZ /c # ADD BASE RSC /l 0x409 /d "_DEBUG" # ADD RSC /l 0x409 /d "_DEBUG" BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo /o"..\..\..\lib/libgcmtd.bsc" LIB32=link.exe -lib # ADD BASE LIB32 /nologo # ADD LIB32 /nologo /out:"..\..\..\lib\libgcmtd.lib" # Begin Special Build Tool OutDir=.\..\..\..\lib TargetName=libgcmtd SOURCE="$(InputPath)" PostBuild_Cmds=del $(OutDir)\$(TargetName).idb # End Special Build Tool !ENDIF # Begin Target # Name "libgcmt - Win32 Release" # Name "libgcmt - Win32 Debug" # Begin Group "Source Files" # PROP Default_Filter "c;cpp;cc;cxx;tcc;rc;def;r;odl;idl;hpj;bat" # Begin Source File SOURCE=..\..\allchblk.c # End Source File # Begin Source File SOURCE=..\..\alloc.c # End Source File # Begin Source File SOURCE=..\..\backgraph.c # End Source File # Begin Source File SOURCE=..\..\blacklst.c # End Source File # Begin Source File SOURCE=..\..\checksums.c # End Source File # Begin Source File SOURCE=..\..\dbg_mlc.c # End Source File # Begin Source File SOURCE=..\..\gcj_mlc.c # End Source File # Begin Source File SOURCE=..\..\fnlz_mlc.c # End Source File # Begin Source File SOURCE=..\..\dyn_load.c # End Source File # Begin Source File SOURCE=..\..\finalize.c # End Source File # Begin Source File SOURCE=..\..\headers.c # End Source File # Begin Source File SOURCE=..\..\mach_dep.c # End Source File # Begin Source File SOURCE=..\..\malloc.c # End Source File # Begin Source File SOURCE=..\..\mallocx.c # End Source File # Begin Source File SOURCE=..\..\mark.c # End Source File # Begin Source File SOURCE=..\..\mark_rts.c # End Source File # Begin Source File SOURCE=..\..\misc.c # End Source File # Begin Source File SOURCE=..\..\msvc_dbg.c # End Source File # Begin Source File SOURCE=..\..\new_hblk.c # End Source File # Begin Source File SOURCE=..\..\obj_map.c # End Source File # Begin Source File SOURCE=..\..\os_dep.c # End Source File # Begin Source File SOURCE=..\..\ptr_chck.c # End Source File # Begin Source File SOURCE=..\..\reclaim.c # End Source File # Begin Source File SOURCE=..\stdafx.c # ADD CPP /Yc"stdafx.h" # End Source File # Begin Source File SOURCE=..\..\stubborn.c # End Source File # Begin Source File SOURCE=..\..\typd_mlc.c # End Source File # Begin Source File SOURCE=..\..\win32_threads.c # End Source File # End Group # Begin Group "Header Files" # PROP Default_Filter "h;hh;hpp;hxx;hm;inl" # Begin Source File SOURCE=..\..\msvc_dbg.h # End Source File # Begin Source File SOURCE=..\stdafx.h # End Source File # Begin Source File SOURCE=..\..\version.h # End Source File # End Group # End Target # End Project ecl-16.1.2/src/bdwgc/windows-untested/vc60/test.dsp000066400000000000000000000033101266352375300220220ustar00rootroot00000000000000# Microsoft Developer Studio Project File - Name="test" - Package Owner=<4> # Microsoft Developer Studio Generated Build File, Format Version 6.00 # ** DO NOT EDIT ** # TARGTYPE "Win32 (x86) Generic Project" 0x010a CFG=test - Win32 Debug !MESSAGE This is not a valid makefile. To build this project using NMAKE, !MESSAGE use the Export Makefile command and run !MESSAGE !MESSAGE NMAKE /f "test.mak". !MESSAGE !MESSAGE You can specify a configuration when running NMAKE !MESSAGE by defining the macro CFG on the command line. For example: !MESSAGE !MESSAGE NMAKE /f "test.mak" CFG="test - Win32 Debug" !MESSAGE !MESSAGE Possible choices for configuration are: !MESSAGE !MESSAGE "test - Win32 Release" (based on "Win32 (x86) Generic Project") !MESSAGE "test - Win32 Debug" (based on "Win32 (x86) Generic Project") !MESSAGE # Begin Project # PROP testowPerConfigDependencies 0 # PROP Scc_ProjName "" # PROP Scc_LocalPath "" MTL=midl.exe !IF "$(CFG)" == "test - Win32 Release" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 0 # PROP BASE Output_Dir "Release" # PROP BASE Intermediate_Dir "Release" # PROP BASE Target_Dir "" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 0 # PROP Output_Dir "..\..\..\bin" # PROP Intermediate_Dir "..\..\..\obj\Release" # PROP Target_Dir "" !ELSEIF "$(CFG)" == "test - Win32 Debug" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 1 # PROP BASE Output_Dir "Debug" # PROP BASE Intermediate_Dir "Debug" # PROP BASE Target_Dir "" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 1 # PROP Output_Dir "..\..\..\bin" # PROP Intermediate_Dir "..\..\..\obj\Debug" # PROP Target_Dir "" !ENDIF # Begin Target # Name "test - Win32 Release" # Name "test - Win32 Debug" # End Target # End Project ecl-16.1.2/src/bdwgc/windows-untested/vc60/test_gc.dsp000066400000000000000000000074411266352375300225040ustar00rootroot00000000000000# Microsoft Developer Studio Project File - Name="test_gc" - Package Owner=<4> # Microsoft Developer Studio Generated Build File, Format Version 6.00 # ** DO NOT EDIT ** # TARGTYPE "Win32 (x86) Console Application" 0x0103 CFG=test_gc - Win32 Debug !MESSAGE This is not a valid makefile. To build this project using NMAKE, !MESSAGE use the Export Makefile command and run !MESSAGE !MESSAGE NMAKE /f "test_gc.mak". !MESSAGE !MESSAGE You can specify a configuration when running NMAKE !MESSAGE by defining the macro CFG on the command line. For example: !MESSAGE !MESSAGE NMAKE /f "test_gc.mak" CFG="test_gc - Win32 Debug" !MESSAGE !MESSAGE Possible choices for configuration are: !MESSAGE !MESSAGE "test_gc - Win32 Release" (based on "Win32 (x86) Console Application") !MESSAGE "test_gc - Win32 Debug" (based on "Win32 (x86) Console Application") !MESSAGE # Begin Project # PROP AllowPerConfigDependencies 0 # PROP Scc_ProjName "" # PROP Scc_LocalPath "" CPP=cl.exe RSC=rc.exe !IF "$(CFG)" == "test_gc - Win32 Release" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 0 # PROP BASE Output_Dir "Release" # PROP BASE Intermediate_Dir "Release" # PROP BASE Target_Dir "" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 0 # PROP Output_Dir "..\..\..\bin" # PROP Intermediate_Dir "..\..\..\obj\Release\test_gc" # PROP Ignore_Export_Lib 0 # PROP Target_Dir "" # ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c # ADD CPP /nologo /MD /W3 /GX /Zi /O2 /I "..\..\include" /D "NDEBUG" /D "_CONSOLE" /D "GC_DLL" /D "WIN32" /D "_MBCS" /D "GC_THREADS" /FD /c # SUBTRACT CPP /Fr /YX # ADD BASE RSC /l 0x409 /d "NDEBUG" # ADD RSC /l 0x409 /d "NDEBUG" BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo LINK32=link.exe # ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /machine:I386 # ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib /nologo /debug /machine:I386 /release /opt:ref # SUBTRACT LINK32 /pdb:none !ELSEIF "$(CFG)" == "test_gc - Win32 Debug" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 1 # PROP BASE Output_Dir "Debug" # PROP BASE Intermediate_Dir "Debug" # PROP BASE Target_Dir "" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 1 # PROP Output_Dir "..\..\..\bin" # PROP Intermediate_Dir "..\..\..\obj\Debug\test_gc" # PROP Ignore_Export_Lib 0 # PROP Target_Dir "" # ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c # ADD CPP /nologo /MDd /W3 /Gm /GX /Zi /Od /I "..\..\include" /D "_DEBUG" /D "_CONSOLE" /D "GC_DLL" /D "WIN32" /D "_MBCS" /D "GC_THREADS" /YX /FD /GZ /c # SUBTRACT CPP /Fr # ADD BASE RSC /l 0x409 /d "_DEBUG" # ADD RSC /l 0x409 /d "_DEBUG" BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo /o"..\..\..\bin/test_gcd.bsc" LINK32=link.exe # ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /debug /machine:I386 /pdbtype:sept # ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib /nologo /incremental:no /debug /machine:I386 /out:"..\..\..\bin/test_gcd.exe" /pdbtype:sept !ENDIF # Begin Target # Name "test_gc - Win32 Release" # Name "test_gc - Win32 Debug" # Begin Source File SOURCE=..\..\tests\test.c # End Source File # End Target # End Project ecl-16.1.2/src/bdwgc/windows-untested/vc60/test_leak_gc.dsp000066400000000000000000000075611266352375300235030ustar00rootroot00000000000000# Microsoft Developer Studio Project File - Name="test_leak_gc" - Package Owner=<4> # Microsoft Developer Studio Generated Build File, Format Version 6.00 # ** DO NOT EDIT ** # TARGTYPE "Win32 (x86) Console Application" 0x0103 CFG=test_leak_gc - Win32 Debug !MESSAGE This is not a valid makefile. To build this project using NMAKE, !MESSAGE use the Export Makefile command and run !MESSAGE !MESSAGE NMAKE /f "test_leak_gc.mak". !MESSAGE !MESSAGE You can specify a configuration when running NMAKE !MESSAGE by defining the macro CFG on the command line. For example: !MESSAGE !MESSAGE NMAKE /f "test_leak_gc.mak" CFG="test_leak_gc - Win32 Debug" !MESSAGE !MESSAGE Possible choices for configuration are: !MESSAGE !MESSAGE "test_leak_gc - Win32 Release" (based on "Win32 (x86) Console Application") !MESSAGE "test_leak_gc - Win32 Debug" (based on "Win32 (x86) Console Application") !MESSAGE # Begin Project # PROP AllowPerConfigDependencies 0 # PROP Scc_ProjName "" # PROP Scc_LocalPath "" CPP=cl.exe RSC=rc.exe !IF "$(CFG)" == "test_leak_gc - Win32 Release" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 0 # PROP BASE Output_Dir "Release" # PROP BASE Intermediate_Dir "Release" # PROP BASE Target_Dir "" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 0 # PROP Output_Dir "..\..\..\bin" # PROP Intermediate_Dir "..\..\..\obj\Release\test_leak_gc" # PROP Ignore_Export_Lib 0 # PROP Target_Dir "" # ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c # ADD CPP /nologo /MD /W3 /GX /Zi /O2 /I "..\..\include" /D "NDEBUG" /D "_CONSOLE" /D "GC_DLL" /D "WIN32" /D "_MBCS" /D "GC_THREADS" /FD /c # SUBTRACT CPP /Fr /YX # ADD BASE RSC /l 0x409 /d "NDEBUG" # ADD RSC /l 0x409 /d "NDEBUG" BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo LINK32=link.exe # ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /machine:I386 # ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib /nologo /debug /machine:I386 /release /opt:ref # SUBTRACT LINK32 /pdb:none !ELSEIF "$(CFG)" == "test_leak_gc - Win32 Debug" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 1 # PROP BASE Output_Dir "Debug" # PROP BASE Intermediate_Dir "Debug" # PROP BASE Target_Dir "" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 1 # PROP Output_Dir "..\..\..\bin" # PROP Intermediate_Dir "..\..\..\obj\Debug\test_leak_gc" # PROP Ignore_Export_Lib 0 # PROP Target_Dir "" # ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c # ADD CPP /nologo /MDd /W3 /Gm /GX /Zi /Od /I "..\..\include" /D "_DEBUG" /D "_CONSOLE" /D "GC_DLL" /D "WIN32" /D "_MBCS" /D "GC_THREADS" /YX /FD /GZ /c # SUBTRACT CPP /Fr # ADD BASE RSC /l 0x409 /d "_DEBUG" # ADD RSC /l 0x409 /d "_DEBUG" BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo /o"..\..\..\bin/test_leak_gcd.bsc" LINK32=link.exe # ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /debug /machine:I386 /pdbtype:sept # ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib /nologo /incremental:no /debug /machine:I386 /out:"..\..\..\bin/test_leak_gcd.exe" /pdbtype:sept !ENDIF # Begin Target # Name "test_leak_gc - Win32 Release" # Name "test_leak_gc - Win32 Debug" # Begin Source File SOURCE=..\..\tests\leak_test.c # End Source File # End Target # End Project ecl-16.1.2/src/bdwgc/windows-untested/vc60/test_leak_libgc.dsp000066400000000000000000000075351266352375300241730ustar00rootroot00000000000000# Microsoft Developer Studio Project File - Name="test_leak_libgc" - Package Owner=<4> # Microsoft Developer Studio Generated Build File, Format Version 6.00 # ** DO NOT EDIT ** # TARGTYPE "Win32 (x86) Console Application" 0x0103 CFG=test_leak_libgc - Win32 Debug !MESSAGE This is not a valid makefile. To build this project using NMAKE, !MESSAGE use the Export Makefile command and run !MESSAGE !MESSAGE NMAKE /f "test_leak_libgc.mak". !MESSAGE !MESSAGE You can specify a configuration when running NMAKE !MESSAGE by defining the macro CFG on the command line. For example: !MESSAGE !MESSAGE NMAKE /f "test_leak_libgc.mak" CFG="test_leak_libgc - Win32 Debug" !MESSAGE !MESSAGE Possible choices for configuration are: !MESSAGE !MESSAGE "test_leak_libgc - Win32 Release" (based on "Win32 (x86) Console Application") !MESSAGE "test_leak_libgc - Win32 Debug" (based on "Win32 (x86) Console Application") !MESSAGE # Begin Project # PROP AllowPerConfigDependencies 0 # PROP Scc_ProjName "" # PROP Scc_LocalPath "" CPP=cl.exe RSC=rc.exe !IF "$(CFG)" == "test_leak_libgc - Win32 Release" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 0 # PROP BASE Output_Dir "Release" # PROP BASE Intermediate_Dir "Release" # PROP BASE Target_Dir "" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 0 # PROP Output_Dir "..\..\..\bin" # PROP Intermediate_Dir "..\..\..\obj\Release\test_leak_libgc" # PROP Ignore_Export_Lib 0 # PROP Target_Dir "" # ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c # ADD CPP /nologo /W3 /GX /Zi /O2 /I "..\..\include" /D "NDEBUG" /D "_CONSOLE" /D "WIN32" /D "_MBCS" /FD /c # SUBTRACT CPP /Fr /YX # ADD BASE RSC /l 0x409 /d "NDEBUG" # ADD RSC /l 0x409 /d "NDEBUG" BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo LINK32=link.exe # ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /machine:I386 # ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib /nologo /debug /machine:I386 /release /opt:ref # SUBTRACT LINK32 /pdb:none !ELSEIF "$(CFG)" == "test_leak_libgc - Win32 Debug" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 1 # PROP BASE Output_Dir "Debug" # PROP BASE Intermediate_Dir "Debug" # PROP BASE Target_Dir "" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 1 # PROP Output_Dir "..\..\..\bin" # PROP Intermediate_Dir "..\..\..\obj\Debug\test_leak_libgc" # PROP Ignore_Export_Lib 0 # PROP Target_Dir "" # ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c # ADD CPP /nologo /W3 /Gm /GX /Zi /Od /I "..\..\include" /D "_DEBUG" /D "_CONSOLE" /D "WIN32" /D "_MBCS" /YX /FD /GZ /c # SUBTRACT CPP /Fr # ADD BASE RSC /l 0x409 /d "_DEBUG" # ADD RSC /l 0x409 /d "_DEBUG" BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo /o"..\..\..\bin/test_leak_libgcd.bsc" LINK32=link.exe # ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /debug /machine:I386 /pdbtype:sept # ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib /nologo /incremental:no /debug /machine:I386 /out:"..\..\..\bin/test_leak_libgcd.exe" /pdbtype:sept !ENDIF # Begin Target # Name "test_leak_libgc - Win32 Release" # Name "test_leak_libgc - Win32 Debug" # Begin Source File SOURCE=..\..\tests\leak_test.c # End Source File # End Target # End Project ecl-16.1.2/src/bdwgc/windows-untested/vc60/test_leak_libgcmt.dsp000066400000000000000000000076441266352375300245350ustar00rootroot00000000000000# Microsoft Developer Studio Project File - Name="test_leak_libgcmt" - Package Owner=<4> # Microsoft Developer Studio Generated Build File, Format Version 6.00 # ** DO NOT EDIT ** # TARGTYPE "Win32 (x86) Console Application" 0x0103 CFG=test_leak_libgcmt - Win32 Debug !MESSAGE This is not a valid makefile. To build this project using NMAKE, !MESSAGE use the Export Makefile command and run !MESSAGE !MESSAGE NMAKE /f "test_leak_libgcmt.mak". !MESSAGE !MESSAGE You can specify a configuration when running NMAKE !MESSAGE by defining the macro CFG on the command line. For example: !MESSAGE !MESSAGE NMAKE /f "test_leak_libgcmt.mak" CFG="test_leak_libgcmt - Win32 Debug" !MESSAGE !MESSAGE Possible choices for configuration are: !MESSAGE !MESSAGE "test_leak_libgcmt - Win32 Release" (based on "Win32 (x86) Console Application") !MESSAGE "test_leak_libgcmt - Win32 Debug" (based on "Win32 (x86) Console Application") !MESSAGE # Begin Project # PROP AllowPerConfigDependencies 0 # PROP Scc_ProjName "" # PROP Scc_LocalPath "" CPP=cl.exe RSC=rc.exe !IF "$(CFG)" == "test_leak_libgcmt - Win32 Release" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 0 # PROP BASE Output_Dir "Release" # PROP BASE Intermediate_Dir "Release" # PROP BASE Target_Dir "" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 0 # PROP Output_Dir "..\..\..\bin" # PROP Intermediate_Dir "..\..\..\obj\Release\test_leak_libgcmt" # PROP Ignore_Export_Lib 0 # PROP Target_Dir "" # ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c # ADD CPP /nologo /MT /W3 /GX /Zi /O2 /I "..\..\include" /D "NDEBUG" /D "_CONSOLE" /D "WIN32" /D "_MBCS" /D "GC_THREADS" /FD /c # SUBTRACT CPP /Fr /YX # ADD BASE RSC /l 0x409 /d "NDEBUG" # ADD RSC /l 0x409 /d "NDEBUG" BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo LINK32=link.exe # ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /machine:I386 # ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib /nologo /debug /machine:I386 /release /opt:ref # SUBTRACT LINK32 /pdb:none !ELSEIF "$(CFG)" == "test_leak_libgcmt - Win32 Debug" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 1 # PROP BASE Output_Dir "Debug" # PROP BASE Intermediate_Dir "Debug" # PROP BASE Target_Dir "" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 1 # PROP Output_Dir "..\..\..\bin" # PROP Intermediate_Dir "..\..\..\obj\Debug\test_leak_libgcmt" # PROP Ignore_Export_Lib 0 # PROP Target_Dir "" # ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c # ADD CPP /nologo /MTd /W3 /Gm /GX /Zi /Od /I "..\..\include" /D "_DEBUG" /D "_CONSOLE" /D "WIN32" /D "_MBCS" /D "GC_THREADS" /YX /FD /GZ /c # SUBTRACT CPP /Fr # ADD BASE RSC /l 0x409 /d "_DEBUG" # ADD RSC /l 0x409 /d "_DEBUG" BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo /o"..\..\..\bin/test_leak_libgcmtd.bsc" LINK32=link.exe # ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /debug /machine:I386 /pdbtype:sept # ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib /nologo /incremental:no /debug /machine:I386 /out:"..\..\..\bin/test_leak_libgcmtd.exe" /pdbtype:sept !ENDIF # Begin Target # Name "test_leak_libgcmt - Win32 Release" # Name "test_leak_libgcmt - Win32 Debug" # Begin Source File SOURCE=..\..\tests\leak_test.c # End Source File # End Target # End Project ecl-16.1.2/src/bdwgc/windows-untested/vc60/test_libgc.dsp000066400000000000000000000074151266352375300231740ustar00rootroot00000000000000# Microsoft Developer Studio Project File - Name="test_libgc" - Package Owner=<4> # Microsoft Developer Studio Generated Build File, Format Version 6.00 # ** DO NOT EDIT ** # TARGTYPE "Win32 (x86) Console Application" 0x0103 CFG=test_libgc - Win32 Debug !MESSAGE This is not a valid makefile. To build this project using NMAKE, !MESSAGE use the Export Makefile command and run !MESSAGE !MESSAGE NMAKE /f "test_libgc.mak". !MESSAGE !MESSAGE You can specify a configuration when running NMAKE !MESSAGE by defining the macro CFG on the command line. For example: !MESSAGE !MESSAGE NMAKE /f "test_libgc.mak" CFG="test_libgc - Win32 Debug" !MESSAGE !MESSAGE Possible choices for configuration are: !MESSAGE !MESSAGE "test_libgc - Win32 Release" (based on "Win32 (x86) Console Application") !MESSAGE "test_libgc - Win32 Debug" (based on "Win32 (x86) Console Application") !MESSAGE # Begin Project # PROP AllowPerConfigDependencies 0 # PROP Scc_ProjName "" # PROP Scc_LocalPath "" CPP=cl.exe RSC=rc.exe !IF "$(CFG)" == "test_libgc - Win32 Release" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 0 # PROP BASE Output_Dir "Release" # PROP BASE Intermediate_Dir "Release" # PROP BASE Target_Dir "" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 0 # PROP Output_Dir "..\..\..\bin" # PROP Intermediate_Dir "..\..\..\obj\Release\test_libgc" # PROP Ignore_Export_Lib 0 # PROP Target_Dir "" # ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c # ADD CPP /nologo /W3 /GX /Zi /O2 /I "..\..\include" /D "NDEBUG" /D "_CONSOLE" /D "WIN32" /D "_MBCS" /FD /c # SUBTRACT CPP /Fr /YX # ADD BASE RSC /l 0x409 /d "NDEBUG" # ADD RSC /l 0x409 /d "NDEBUG" BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo LINK32=link.exe # ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /machine:I386 # ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib /nologo /debug /machine:I386 /release /opt:ref # SUBTRACT LINK32 /pdb:none !ELSEIF "$(CFG)" == "test_libgc - Win32 Debug" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 1 # PROP BASE Output_Dir "Debug" # PROP BASE Intermediate_Dir "Debug" # PROP BASE Target_Dir "" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 1 # PROP Output_Dir "..\..\..\bin" # PROP Intermediate_Dir "..\..\..\obj\Debug\test_libgc" # PROP Ignore_Export_Lib 0 # PROP Target_Dir "" # ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c # ADD CPP /nologo /W3 /Gm /GX /Zi /Od /I "..\..\include" /D "_DEBUG" /D "_CONSOLE" /D "WIN32" /D "_MBCS" /YX /FD /GZ /c # SUBTRACT CPP /Fr # ADD BASE RSC /l 0x409 /d "_DEBUG" # ADD RSC /l 0x409 /d "_DEBUG" BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo /o"..\..\..\bin/test_libgcd.bsc" LINK32=link.exe # ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /debug /machine:I386 /pdbtype:sept # ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib /nologo /incremental:no /debug /machine:I386 /out:"..\..\..\bin/test_libgcd.exe" /pdbtype:sept !ENDIF # Begin Target # Name "test_libgc - Win32 Release" # Name "test_libgc - Win32 Debug" # Begin Source File SOURCE=..\..\tests\test.c # End Source File # End Target # End Project ecl-16.1.2/src/bdwgc/windows-untested/vc60/test_libgcmt.dsp000066400000000000000000000075241266352375300235360ustar00rootroot00000000000000# Microsoft Developer Studio Project File - Name="test_libgcmt" - Package Owner=<4> # Microsoft Developer Studio Generated Build File, Format Version 6.00 # ** DO NOT EDIT ** # TARGTYPE "Win32 (x86) Console Application" 0x0103 CFG=test_libgcmt - Win32 Debug !MESSAGE This is not a valid makefile. To build this project using NMAKE, !MESSAGE use the Export Makefile command and run !MESSAGE !MESSAGE NMAKE /f "test_libgcmt.mak". !MESSAGE !MESSAGE You can specify a configuration when running NMAKE !MESSAGE by defining the macro CFG on the command line. For example: !MESSAGE !MESSAGE NMAKE /f "test_libgcmt.mak" CFG="test_libgcmt - Win32 Debug" !MESSAGE !MESSAGE Possible choices for configuration are: !MESSAGE !MESSAGE "test_libgcmt - Win32 Release" (based on "Win32 (x86) Console Application") !MESSAGE "test_libgcmt - Win32 Debug" (based on "Win32 (x86) Console Application") !MESSAGE # Begin Project # PROP AllowPerConfigDependencies 0 # PROP Scc_ProjName "" # PROP Scc_LocalPath "" CPP=cl.exe RSC=rc.exe !IF "$(CFG)" == "test_libgcmt - Win32 Release" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 0 # PROP BASE Output_Dir "Release" # PROP BASE Intermediate_Dir "Release" # PROP BASE Target_Dir "" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 0 # PROP Output_Dir "..\..\..\bin" # PROP Intermediate_Dir "..\..\..\obj\Release\test_libgcmt" # PROP Ignore_Export_Lib 0 # PROP Target_Dir "" # ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c # ADD CPP /nologo /MT /W3 /GX /Zi /O2 /I "..\..\include" /D "NDEBUG" /D "_CONSOLE" /D "WIN32" /D "_MBCS" /D "GC_THREADS" /FD /c # SUBTRACT CPP /Fr /YX # ADD BASE RSC /l 0x409 /d "NDEBUG" # ADD RSC /l 0x409 /d "NDEBUG" BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo LINK32=link.exe # ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /machine:I386 # ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib /nologo /debug /machine:I386 /release /opt:ref # SUBTRACT LINK32 /pdb:none !ELSEIF "$(CFG)" == "test_libgcmt - Win32 Debug" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 1 # PROP BASE Output_Dir "Debug" # PROP BASE Intermediate_Dir "Debug" # PROP BASE Target_Dir "" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 1 # PROP Output_Dir "..\..\..\bin" # PROP Intermediate_Dir "..\..\..\obj\Debug\test_libgcmt" # PROP Ignore_Export_Lib 0 # PROP Target_Dir "" # ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c # ADD CPP /nologo /MTd /W3 /Gm /GX /Zi /Od /I "..\..\include" /D "_DEBUG" /D "_CONSOLE" /D "WIN32" /D "_MBCS" /D "GC_THREADS" /YX /FD /GZ /c # SUBTRACT CPP /Fr # ADD BASE RSC /l 0x409 /d "_DEBUG" # ADD RSC /l 0x409 /d "_DEBUG" BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo /o"..\..\..\bin/test_libgcmtd.bsc" LINK32=link.exe # ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /debug /machine:I386 /pdbtype:sept # ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib /nologo /incremental:no /debug /machine:I386 /out:"..\..\..\bin/test_libgcmtd.exe" /pdbtype:sept !ENDIF # Begin Target # Name "test_libgcmt - Win32 Release" # Name "test_libgcmt - Win32 Debug" # Begin Source File SOURCE=..\..\tests\test.c # End Source File # End Target # End Project ecl-16.1.2/src/bdwgc/windows-untested/vc60/vc60crlf.cmd000077500000000000000000000004311266352375300224510ustar00rootroot00000000000000@echo off rem This script will convert Unix-style line endings into Windows format. for %%P in (*.ds?) do call :fixline %%P goto :eof :fixline @echo on if exist "%~1.new" del "%~1.new" for /f %%S in (%1) do ( echo %%S>>"%~1.new" ) ren %1 "%~1.bak" ren "%~1.new" %1 goto :eof ecl-16.1.2/src/bdwgc/windows-untested/vc70/000077500000000000000000000000001266352375300203375ustar00rootroot00000000000000ecl-16.1.2/src/bdwgc/windows-untested/vc70/all.vcproj000066400000000000000000000025341266352375300223400ustar00rootroot00000000000000 ecl-16.1.2/src/bdwgc/windows-untested/vc70/gc.sln000066400000000000000000000152111266352375300214460ustar00rootroot00000000000000Microsoft Visual Studio Solution File, Format Version 7.00 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "all", "all.vcproj", "{CED9D953-AC1A-4795-9853-6D60857509EE}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gc", "gc.vcproj", "{D7ADAD9A-14FF-4C93-9BF1-ACD03FB6A2FA}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libgc", "libgc.vcproj", "{F80C47A7-2B2D-4BA9-BEED-AAFA7541650D}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libgcmt", "libgcmt.vcproj", "{39802D97-BEF7-499D-8570-294AEA39ED7D}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "test", "test.vcproj", "{997208FE-7A7D-435A-945A-C61C57D8070C}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "test_gc", "test_gc.vcproj", "{D1F56655-8C27-4320-9436-2A11729A337B}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "test_leak_gc", "test_leak_gc.vcproj", "{6E545988-1AE7-41FB-A981-D256A84F4C3A}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "test_leak_libgc", "test_leak_libgc.vcproj", "{A561AE5C-33FE-4DBC-A4D4-52B7F196D20F}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "test_leak_libgcmt", "test_leak_libgcmt.vcproj", "{92046CBF-2EF9-408D-B997-8445E945D687}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "test_libgc", "test_libgc.vcproj", "{8CFE55AA-676C-4B5A-B133-390B4BF02AB8}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "test_libgcmt", "test_libgcmt.vcproj", "{8C63DB39-DBF4-49D3-A908-172ADA21753B}" EndProject Global GlobalSection(SolutionConfiguration) = preSolution ConfigName.0 = Debug ConfigName.1 = Release EndGlobalSection GlobalSection(ProjectDependencies) = postSolution {CED9D953-AC1A-4795-9853-6D60857509EE}.0 = {39802D97-BEF7-499D-8570-294AEA39ED7D} {CED9D953-AC1A-4795-9853-6D60857509EE}.1 = {F80C47A7-2B2D-4BA9-BEED-AAFA7541650D} {CED9D953-AC1A-4795-9853-6D60857509EE}.2 = {D7ADAD9A-14FF-4C93-9BF1-ACD03FB6A2FA} {997208FE-7A7D-435A-945A-C61C57D8070C}.0 = {92046CBF-2EF9-408D-B997-8445E945D687} {997208FE-7A7D-435A-945A-C61C57D8070C}.1 = {A561AE5C-33FE-4DBC-A4D4-52B7F196D20F} {997208FE-7A7D-435A-945A-C61C57D8070C}.2 = {6E545988-1AE7-41FB-A981-D256A84F4C3A} {997208FE-7A7D-435A-945A-C61C57D8070C}.3 = {8C63DB39-DBF4-49D3-A908-172ADA21753B} {997208FE-7A7D-435A-945A-C61C57D8070C}.4 = {8CFE55AA-676C-4B5A-B133-390B4BF02AB8} {997208FE-7A7D-435A-945A-C61C57D8070C}.5 = {D1F56655-8C27-4320-9436-2A11729A337B} {D1F56655-8C27-4320-9436-2A11729A337B}.0 = {D7ADAD9A-14FF-4C93-9BF1-ACD03FB6A2FA} {6E545988-1AE7-41FB-A981-D256A84F4C3A}.0 = {D7ADAD9A-14FF-4C93-9BF1-ACD03FB6A2FA} {A561AE5C-33FE-4DBC-A4D4-52B7F196D20F}.0 = {F80C47A7-2B2D-4BA9-BEED-AAFA7541650D} {92046CBF-2EF9-408D-B997-8445E945D687}.0 = {39802D97-BEF7-499D-8570-294AEA39ED7D} {8CFE55AA-676C-4B5A-B133-390B4BF02AB8}.0 = {F80C47A7-2B2D-4BA9-BEED-AAFA7541650D} {8C63DB39-DBF4-49D3-A908-172ADA21753B}.0 = {39802D97-BEF7-499D-8570-294AEA39ED7D} EndGlobalSection GlobalSection(ProjectConfiguration) = postSolution {CED9D953-AC1A-4795-9853-6D60857509EE}.Debug.ActiveCfg = Debug|Win32 {CED9D953-AC1A-4795-9853-6D60857509EE}.Debug.Build.0 = Debug|Win32 {CED9D953-AC1A-4795-9853-6D60857509EE}.Release.ActiveCfg = Release|Win32 {CED9D953-AC1A-4795-9853-6D60857509EE}.Release.Build.0 = Release|Win32 {D7ADAD9A-14FF-4C93-9BF1-ACD03FB6A2FA}.Debug.ActiveCfg = Debug|Win32 {D7ADAD9A-14FF-4C93-9BF1-ACD03FB6A2FA}.Debug.Build.0 = Debug|Win32 {D7ADAD9A-14FF-4C93-9BF1-ACD03FB6A2FA}.Release.ActiveCfg = Release|Win32 {D7ADAD9A-14FF-4C93-9BF1-ACD03FB6A2FA}.Release.Build.0 = Release|Win32 {F80C47A7-2B2D-4BA9-BEED-AAFA7541650D}.Debug.ActiveCfg = Debug|Win32 {F80C47A7-2B2D-4BA9-BEED-AAFA7541650D}.Debug.Build.0 = Debug|Win32 {F80C47A7-2B2D-4BA9-BEED-AAFA7541650D}.Release.ActiveCfg = Release|Win32 {F80C47A7-2B2D-4BA9-BEED-AAFA7541650D}.Release.Build.0 = Release|Win32 {39802D97-BEF7-499D-8570-294AEA39ED7D}.Debug.ActiveCfg = Debug|Win32 {39802D97-BEF7-499D-8570-294AEA39ED7D}.Debug.Build.0 = Debug|Win32 {39802D97-BEF7-499D-8570-294AEA39ED7D}.Release.ActiveCfg = Release|Win32 {39802D97-BEF7-499D-8570-294AEA39ED7D}.Release.Build.0 = Release|Win32 {997208FE-7A7D-435A-945A-C61C57D8070C}.Debug.ActiveCfg = Debug|Win32 {997208FE-7A7D-435A-945A-C61C57D8070C}.Debug.Build.0 = Debug|Win32 {997208FE-7A7D-435A-945A-C61C57D8070C}.Release.ActiveCfg = Release|Win32 {997208FE-7A7D-435A-945A-C61C57D8070C}.Release.Build.0 = Release|Win32 {D1F56655-8C27-4320-9436-2A11729A337B}.Debug.ActiveCfg = Debug|Win32 {D1F56655-8C27-4320-9436-2A11729A337B}.Debug.Build.0 = Debug|Win32 {D1F56655-8C27-4320-9436-2A11729A337B}.Release.ActiveCfg = Release|Win32 {D1F56655-8C27-4320-9436-2A11729A337B}.Release.Build.0 = Release|Win32 {6E545988-1AE7-41FB-A981-D256A84F4C3A}.Debug.ActiveCfg = Debug|Win32 {6E545988-1AE7-41FB-A981-D256A84F4C3A}.Debug.Build.0 = Debug|Win32 {6E545988-1AE7-41FB-A981-D256A84F4C3A}.Release.ActiveCfg = Release|Win32 {6E545988-1AE7-41FB-A981-D256A84F4C3A}.Release.Build.0 = Release|Win32 {A561AE5C-33FE-4DBC-A4D4-52B7F196D20F}.Debug.ActiveCfg = Debug|Win32 {A561AE5C-33FE-4DBC-A4D4-52B7F196D20F}.Debug.Build.0 = Debug|Win32 {A561AE5C-33FE-4DBC-A4D4-52B7F196D20F}.Release.ActiveCfg = Release|Win32 {A561AE5C-33FE-4DBC-A4D4-52B7F196D20F}.Release.Build.0 = Release|Win32 {92046CBF-2EF9-408D-B997-8445E945D687}.Debug.ActiveCfg = Debug|Win32 {92046CBF-2EF9-408D-B997-8445E945D687}.Debug.Build.0 = Debug|Win32 {92046CBF-2EF9-408D-B997-8445E945D687}.Release.ActiveCfg = Release|Win32 {92046CBF-2EF9-408D-B997-8445E945D687}.Release.Build.0 = Release|Win32 {8CFE55AA-676C-4B5A-B133-390B4BF02AB8}.Debug.ActiveCfg = Debug|Win32 {8CFE55AA-676C-4B5A-B133-390B4BF02AB8}.Debug.Build.0 = Debug|Win32 {8CFE55AA-676C-4B5A-B133-390B4BF02AB8}.Release.ActiveCfg = Release|Win32 {8CFE55AA-676C-4B5A-B133-390B4BF02AB8}.Release.Build.0 = Release|Win32 {8C63DB39-DBF4-49D3-A908-172ADA21753B}.Debug.ActiveCfg = Debug|Win32 {8C63DB39-DBF4-49D3-A908-172ADA21753B}.Debug.Build.0 = Debug|Win32 {8C63DB39-DBF4-49D3-A908-172ADA21753B}.Release.ActiveCfg = Release|Win32 {8C63DB39-DBF4-49D3-A908-172ADA21753B}.Release.Build.0 = Release|Win32 EndGlobalSection GlobalSection(ExtensibilityGlobals) = postSolution EndGlobalSection GlobalSection(ExtensibilityAddIns) = postSolution EndGlobalSection EndGlobal ecl-16.1.2/src/bdwgc/windows-untested/vc70/gc.vcproj000066400000000000000000000274671266352375300221750ustar00rootroot00000000000000 ecl-16.1.2/src/bdwgc/windows-untested/vc70/libgc.vcproj000066400000000000000000000207161266352375300226520ustar00rootroot00000000000000 ecl-16.1.2/src/bdwgc/windows-untested/vc70/libgcmt.vcproj000066400000000000000000000167251266352375300232200ustar00rootroot00000000000000 ecl-16.1.2/src/bdwgc/windows-untested/vc70/test.vcproj000066400000000000000000000025351266352375300225500ustar00rootroot00000000000000 ecl-16.1.2/src/bdwgc/windows-untested/vc70/test_gc.vcproj000066400000000000000000000113021266352375300232110ustar00rootroot00000000000000 ecl-16.1.2/src/bdwgc/windows-untested/vc70/test_leak_gc.vcproj000066400000000000000000000114461266352375300242160ustar00rootroot00000000000000 ecl-16.1.2/src/bdwgc/windows-untested/vc70/test_leak_libgc.vcproj000066400000000000000000000114731266352375300247050ustar00rootroot00000000000000 ecl-16.1.2/src/bdwgc/windows-untested/vc70/test_leak_libgcmt.vcproj000066400000000000000000000115671266352375300252520ustar00rootroot00000000000000 ecl-16.1.2/src/bdwgc/windows-untested/vc70/test_libgc.vcproj000066400000000000000000000113271266352375300237070ustar00rootroot00000000000000 ecl-16.1.2/src/bdwgc/windows-untested/vc70/test_libgcmt.vcproj000066400000000000000000000114231266352375300242450ustar00rootroot00000000000000 ecl-16.1.2/src/bdwgc/windows-untested/vc71/000077500000000000000000000000001266352375300203405ustar00rootroot00000000000000ecl-16.1.2/src/bdwgc/windows-untested/vc71/all.vcproj000066400000000000000000000032351266352375300223400ustar00rootroot00000000000000 ecl-16.1.2/src/bdwgc/windows-untested/vc71/gc.sln000066400000000000000000000165301266352375300214540ustar00rootroot00000000000000Microsoft Visual Studio Solution File, Format Version 8.00 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "all", "all.vcproj", "{684E465A-3944-4BA0-BA8D-52A064B43A5D}" ProjectSection(ProjectDependencies) = postProject {EDA8C8B6-2538-4F1E-9C9A-F5C4FAF1EC16} = {EDA8C8B6-2538-4F1E-9C9A-F5C4FAF1EC16} {1C32FB8B-6F91-4190-9F05-CE1E772BB5E0} = {1C32FB8B-6F91-4190-9F05-CE1E772BB5E0} {93622AAF-633A-4D02-B023-674D4CDA266B} = {93622AAF-633A-4D02-B023-674D4CDA266B} EndProjectSection EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gc", "gc.vcproj", "{93622AAF-633A-4D02-B023-674D4CDA266B}" ProjectSection(ProjectDependencies) = postProject EndProjectSection EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libgc", "libgc.vcproj", "{1C32FB8B-6F91-4190-9F05-CE1E772BB5E0}" ProjectSection(ProjectDependencies) = postProject EndProjectSection EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libgcmt", "libgcmt.vcproj", "{EDA8C8B6-2538-4F1E-9C9A-F5C4FAF1EC16}" ProjectSection(ProjectDependencies) = postProject EndProjectSection EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "test", "test.vcproj", "{1891ADD8-C39B-494B-B69D-D64F76729E5A}" ProjectSection(ProjectDependencies) = postProject {8A595901-33E6-4959-A8E9-6DACC2D57330} = {8A595901-33E6-4959-A8E9-6DACC2D57330} {EB1D2ECA-926D-4B6E-BF65-B429C713381C} = {EB1D2ECA-926D-4B6E-BF65-B429C713381C} {500B7CE2-FD16-42C5-B738-1406C13A68B4} = {500B7CE2-FD16-42C5-B738-1406C13A68B4} {9551B5E4-94A5-4B04-ACA1-9FB28DFD28AA} = {9551B5E4-94A5-4B04-ACA1-9FB28DFD28AA} {B0F6C137-5153-48E3-ABED-6C02D3912EDA} = {B0F6C137-5153-48E3-ABED-6C02D3912EDA} {1911057C-30C3-41CE-AF9E-232AEB37BCD3} = {1911057C-30C3-41CE-AF9E-232AEB37BCD3} EndProjectSection EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "test_gc", "test_gc.vcproj", "{1911057C-30C3-41CE-AF9E-232AEB37BCD3}" ProjectSection(ProjectDependencies) = postProject {93622AAF-633A-4D02-B023-674D4CDA266B} = {93622AAF-633A-4D02-B023-674D4CDA266B} EndProjectSection EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "test_leak_gc", "test_leak_gc.vcproj", "{500B7CE2-FD16-42C5-B738-1406C13A68B4}" ProjectSection(ProjectDependencies) = postProject {93622AAF-633A-4D02-B023-674D4CDA266B} = {93622AAF-633A-4D02-B023-674D4CDA266B} EndProjectSection EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "test_leak_libgc", "test_leak_libgc.vcproj", "{EB1D2ECA-926D-4B6E-BF65-B429C713381C}" ProjectSection(ProjectDependencies) = postProject {1C32FB8B-6F91-4190-9F05-CE1E772BB5E0} = {1C32FB8B-6F91-4190-9F05-CE1E772BB5E0} EndProjectSection EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "test_leak_libgcmt", "test_leak_libgcmt.vcproj", "{8A595901-33E6-4959-A8E9-6DACC2D57330}" ProjectSection(ProjectDependencies) = postProject {EDA8C8B6-2538-4F1E-9C9A-F5C4FAF1EC16} = {EDA8C8B6-2538-4F1E-9C9A-F5C4FAF1EC16} EndProjectSection EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "test_libgc", "test_libgc.vcproj", "{B0F6C137-5153-48E3-ABED-6C02D3912EDA}" ProjectSection(ProjectDependencies) = postProject {1C32FB8B-6F91-4190-9F05-CE1E772BB5E0} = {1C32FB8B-6F91-4190-9F05-CE1E772BB5E0} EndProjectSection EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "test_libgcmt", "test_libgcmt.vcproj", "{9551B5E4-94A5-4B04-ACA1-9FB28DFD28AA}" ProjectSection(ProjectDependencies) = postProject {EDA8C8B6-2538-4F1E-9C9A-F5C4FAF1EC16} = {EDA8C8B6-2538-4F1E-9C9A-F5C4FAF1EC16} EndProjectSection EndProject Global GlobalSection(SolutionConfiguration) = preSolution Debug = Debug Release = Release EndGlobalSection GlobalSection(ProjectConfiguration) = postSolution {684E465A-3944-4BA0-BA8D-52A064B43A5D}.Debug.ActiveCfg = Debug|Win32 {684E465A-3944-4BA0-BA8D-52A064B43A5D}.Debug.Build.0 = Debug|Win32 {684E465A-3944-4BA0-BA8D-52A064B43A5D}.Release.ActiveCfg = Release|Win32 {684E465A-3944-4BA0-BA8D-52A064B43A5D}.Release.Build.0 = Release|Win32 {93622AAF-633A-4D02-B023-674D4CDA266B}.Debug.ActiveCfg = Debug|Win32 {93622AAF-633A-4D02-B023-674D4CDA266B}.Debug.Build.0 = Debug|Win32 {93622AAF-633A-4D02-B023-674D4CDA266B}.Release.ActiveCfg = Release|Win32 {93622AAF-633A-4D02-B023-674D4CDA266B}.Release.Build.0 = Release|Win32 {1C32FB8B-6F91-4190-9F05-CE1E772BB5E0}.Debug.ActiveCfg = Debug|Win32 {1C32FB8B-6F91-4190-9F05-CE1E772BB5E0}.Debug.Build.0 = Debug|Win32 {1C32FB8B-6F91-4190-9F05-CE1E772BB5E0}.Release.ActiveCfg = Release|Win32 {1C32FB8B-6F91-4190-9F05-CE1E772BB5E0}.Release.Build.0 = Release|Win32 {EDA8C8B6-2538-4F1E-9C9A-F5C4FAF1EC16}.Debug.ActiveCfg = Debug|Win32 {EDA8C8B6-2538-4F1E-9C9A-F5C4FAF1EC16}.Debug.Build.0 = Debug|Win32 {EDA8C8B6-2538-4F1E-9C9A-F5C4FAF1EC16}.Release.ActiveCfg = Release|Win32 {EDA8C8B6-2538-4F1E-9C9A-F5C4FAF1EC16}.Release.Build.0 = Release|Win32 {1891ADD8-C39B-494B-B69D-D64F76729E5A}.Debug.ActiveCfg = Debug|Win32 {1891ADD8-C39B-494B-B69D-D64F76729E5A}.Debug.Build.0 = Debug|Win32 {1891ADD8-C39B-494B-B69D-D64F76729E5A}.Release.ActiveCfg = Release|Win32 {1891ADD8-C39B-494B-B69D-D64F76729E5A}.Release.Build.0 = Release|Win32 {1911057C-30C3-41CE-AF9E-232AEB37BCD3}.Debug.ActiveCfg = Debug|Win32 {1911057C-30C3-41CE-AF9E-232AEB37BCD3}.Debug.Build.0 = Debug|Win32 {1911057C-30C3-41CE-AF9E-232AEB37BCD3}.Release.ActiveCfg = Release|Win32 {1911057C-30C3-41CE-AF9E-232AEB37BCD3}.Release.Build.0 = Release|Win32 {500B7CE2-FD16-42C5-B738-1406C13A68B4}.Debug.ActiveCfg = Debug|Win32 {500B7CE2-FD16-42C5-B738-1406C13A68B4}.Debug.Build.0 = Debug|Win32 {500B7CE2-FD16-42C5-B738-1406C13A68B4}.Release.ActiveCfg = Release|Win32 {500B7CE2-FD16-42C5-B738-1406C13A68B4}.Release.Build.0 = Release|Win32 {EB1D2ECA-926D-4B6E-BF65-B429C713381C}.Debug.ActiveCfg = Debug|Win32 {EB1D2ECA-926D-4B6E-BF65-B429C713381C}.Debug.Build.0 = Debug|Win32 {EB1D2ECA-926D-4B6E-BF65-B429C713381C}.Release.ActiveCfg = Release|Win32 {EB1D2ECA-926D-4B6E-BF65-B429C713381C}.Release.Build.0 = Release|Win32 {8A595901-33E6-4959-A8E9-6DACC2D57330}.Debug.ActiveCfg = Debug|Win32 {8A595901-33E6-4959-A8E9-6DACC2D57330}.Debug.Build.0 = Debug|Win32 {8A595901-33E6-4959-A8E9-6DACC2D57330}.Release.ActiveCfg = Release|Win32 {8A595901-33E6-4959-A8E9-6DACC2D57330}.Release.Build.0 = Release|Win32 {B0F6C137-5153-48E3-ABED-6C02D3912EDA}.Debug.ActiveCfg = Debug|Win32 {B0F6C137-5153-48E3-ABED-6C02D3912EDA}.Debug.Build.0 = Debug|Win32 {B0F6C137-5153-48E3-ABED-6C02D3912EDA}.Release.ActiveCfg = Release|Win32 {B0F6C137-5153-48E3-ABED-6C02D3912EDA}.Release.Build.0 = Release|Win32 {9551B5E4-94A5-4B04-ACA1-9FB28DFD28AA}.Debug.ActiveCfg = Debug|Win32 {9551B5E4-94A5-4B04-ACA1-9FB28DFD28AA}.Debug.Build.0 = Debug|Win32 {9551B5E4-94A5-4B04-ACA1-9FB28DFD28AA}.Release.ActiveCfg = Release|Win32 {9551B5E4-94A5-4B04-ACA1-9FB28DFD28AA}.Release.Build.0 = Release|Win32 EndGlobalSection GlobalSection(ExtensibilityGlobals) = postSolution EndGlobalSection GlobalSection(ExtensibilityAddIns) = postSolution EndGlobalSection EndGlobal ecl-16.1.2/src/bdwgc/windows-untested/vc71/gc.vcproj000066400000000000000000001120061266352375300221560ustar00rootroot00000000000000 ecl-16.1.2/src/bdwgc/windows-untested/vc71/libgc.vcproj000066400000000000000000000740771266352375300226640ustar00rootroot00000000000000 ecl-16.1.2/src/bdwgc/windows-untested/vc71/libgcmt.vcproj000066400000000000000000000721061266352375300232140ustar00rootroot00000000000000 ecl-16.1.2/src/bdwgc/windows-untested/vc71/test.vcproj000066400000000000000000000032401266352375300225430ustar00rootroot00000000000000 ecl-16.1.2/src/bdwgc/windows-untested/vc71/test_gc.vcproj000066400000000000000000000135571266352375300232300ustar00rootroot00000000000000 ecl-16.1.2/src/bdwgc/windows-untested/vc71/test_leak_gc.vcproj000066400000000000000000000137231266352375300242170ustar00rootroot00000000000000 ecl-16.1.2/src/bdwgc/windows-untested/vc71/test_leak_libgc.vcproj000066400000000000000000000137501266352375300247060ustar00rootroot00000000000000 ecl-16.1.2/src/bdwgc/windows-untested/vc71/test_leak_libgcmt.vcproj000066400000000000000000000140441266352375300252440ustar00rootroot00000000000000 ecl-16.1.2/src/bdwgc/windows-untested/vc71/test_libgc.vcproj000066400000000000000000000136041266352375300237100ustar00rootroot00000000000000 ecl-16.1.2/src/bdwgc/windows-untested/vc71/test_libgcmt.vcproj000066400000000000000000000137001266352375300242460ustar00rootroot00000000000000 ecl-16.1.2/src/c/000077500000000000000000000000001266352375300133715ustar00rootroot00000000000000ecl-16.1.2/src/c/Makefile.in000066400000000000000000000122641266352375300154430ustar00rootroot00000000000000# -*- Mode: Makefile; indent-tabs-mode: nil -*- # vim: set filetype=makefile tabstop=8 shiftwidth=4 expandtab: # # Makefile for ECL core library # top_srcdir= @top_srcdir@ srcdir = @srcdir@ VPATH = @srcdir@ # Programs used by "make": # CC = @CC@ TRUE_CC = $(CC) CFLAGS = -I. -I@true_builddir@ -I$(srcdir) -I../ecl/gc -DECL_API -DECL_NO_LEGACY @CPPFLAGS@ @CFLAGS@ @ECL_CFLAGS@ -c # The following flags could be added and used by GCC # -Wall -W -Wfloat-equal -Wundef -Wendif-labels -Wpointer-arith -Wcast-align \ # -Wwrite-strings -Wconversion -Wsign-compare -Wmissing-prototypes \ # -Wredundant-decls -Wunreachable-code -Winline SHELL = /bin/sh RM = @RM@ EXE = @EXEEXT@ DPP = ./dpp$(EXE) RANLIB = @RANLIB@ AR = @AR@ # Data for installation # INSTALL = @INSTALL@ INSTALL_DATA = @INSTALL_DATA@ prefix=@prefix@ exec_prefix=@exec_prefix@ libdir=@libdir@ includedir=@includedir@ # Files HDIR = ../ecl HFILES = $(HDIR)/config.h $(HDIR)/ecl.h $(HDIR)/ecl-cmp.h\ $(HDIR)/object.h $(HDIR)/cs.h $(HDIR)/stacks.h\ $(HDIR)/external.h $(HDIR)/cons.h $(HDIR)/legacy.h\ $(HDIR)/number.h $(HDIR)/page.h $(HDIR)/unify.h OBJS = main.o symbol.o package.o cons.o list.o\ apply.o eval.o interpreter.o compiler.o disassembler.o \ instance.o gfun.o clos/cache.o clos/accessor.o \ reference.o character.o\ file.o read.o print.o error.o string.o cfun.o\ reader/parse_integer.o reader/parse_number.o \ printer/float_to_digits.o printer/float_to_string.o \ printer/integer_to_string.o printer/write_ugly.o \ printer/write_object.o printer/write_symbol.o \ printer/write_array.o printer/write_list.o printer/write_code.o \ printer/write_sse.o printer/print_unreadable.o \ ffi/libraries.o ffi/backtrace.o ffi/mmap.o ffi/cdata.o \ numbers/cos.o numbers/sin.o numbers/tan.o numbers/atan.o \ numbers/cosh.o numbers/sinh.o numbers/tanh.o \ numbers/exp.o numbers/expt.o numbers/log.o \ numbers/sqrt.o numbers/abs.o \ numbers/zerop.o numbers/plusp.o numbers/minusp.o \ numbers/negate.o numbers/conjugate.o \ numbers/one_plus.o numbers/one_minus.o \ numbers/plus.o numbers/minus.o numbers/times.o numbers/divide.o \ numbers/number_compare.o numbers/number_equalp.o numbers/minmax.o \ numbers/floor.o numbers/ceiling.o numbers/round.o numbers/truncate.o \ typespec.o assignment.o \ predicate.o number.o\ num_pred.o num_arith.o num_co.o\ num_log.o num_rand.o array.o vector_push.o sequence.o cmpaux.o\ macros.o backq.o stacks.o \ time.o unixint.o\ mapfun.o multival.o hash.o format.o pathname.o\ structure.o load.o unixfsys.o unixsys.o \ serialize.o ffi.o sse2.o @EXTRA_OBJS@ threads/atomic.o .SUFFIXES: .c .o .d .s .PHONY: all all: $(DPP) ../libeclmin.a ../cinit.o .d.c: $(DPP) if test -f ../CROSS-DPP ; then ../CROSS-DPP $< $@ ; else $(DPP) $< $@ ; fi .d.o: $(DPP) if test -f ../CROSS-DPP ; then ../CROSS-DPP $< $@.c ; else $(DPP) $< $@.c ; fi $(CC) -DECLDIR="\"@ecldir@\"" $(CFLAGS) -o $@ $@.c .c.o: $(CC) -DECLDIR="\"@ecldir@\"" $(CFLAGS) -o $@ $< .d.s: $(HFILES) if test -f ../CROSS-DPP ; then ../CROSS-DPP $< $@.c ; else $(DPP) $< $@.c ; fi $(CC) -DECLDIR="\"@ecldir@\"" $(CFLAGS) -S -o $@ $@.c #.c.o: $(HFILES) # $(CC) -DECLDIR="\"@ecldir@\"" $(CFLAGS) -o $@ $< apply_x86.c: $(srcdir)/arch/apply_x86.d $(DPP) $(HFILES) if test -f ../CROSS-DPP ; then \ ../CROSS-DPP $(srcdir)/arch/apply_x86.d $@ ; \ else $(DPP) $(srcdir)/arch/apply_x86.d $@ ; \ fi ffi_x86.c: $(srcdir)/arch/ffi_x86.d $(DPP) $(HFILES) if test -f ../CROSS-DPP ; then \ ../CROSS-DPP $(srcdir)/arch/ffi_x86.d $@ ; \ else $(DPP) $(srcdir)/arch/ffi_x86.d $@ ; \ fi ffi_x86_64.c: $(srcdir)/arch/ffi_x86_64.d $(DPP) $(HFILES) if test -f ../CROSS-DPP ; then \ ../CROSS-DPP $(srcdir)/arch/ffi_x86_64.d $@ ; \ else $(DPP) $(srcdir)/arch/ffi_x86_64.d $@ ; \ fi ../libeclmin.a: $(OBJS) all_symbols.o all_symbols2.o $(RM) $@ $(AR) cr $@ $(OBJS) $(RANLIB) $@ clean: $(RM) $(DPP) *.c *.h $(OBJS) all_symbols.o all_symbols2.o ../libecl.a cinit.o core a.out tmp.c # Build rules $(DPP): $(srcdir)/dpp.c $(srcdir)/symbols_list2.h if test -f ../CROSS-DPP; then touch dpp; else \ $(TRUE_CC) -I$(srcdir) -I@true_builddir@ -I./ $(srcdir)/dpp.c @CPPFLAGS@ @CFLAGS@ @ECL_CFLAGS@ -o $@ ; \ fi $(OBJS): $(DPP) # # symbols_list2.h is built this way to allow for an atomic replacement of # the file. Otherwise we have problem when doing concurrent builds with # rsync updates of the source tree. # $(srcdir)/symbols_list2.h: $(srcdir)/symbols_list.h Makefile cat $(srcdir)/symbols_list.h | \ sed -e 's%{\([A-Z ]*.*".*"\),[^,]*,[ ]*NULL,.*}%{\1,NULL}%g' \ -e 's%{\([A-Z ]*.*".*"\),[^,]*,[ ]*\([^,]*\),.*}%{\1,"\2"}%g' \ -e 's%{NULL.*%{NULL,NULL}};%' | \ sed -e 's%"\(IF_[A-Z0-9]*\)(\([^)]*\))"%\1("\2")%g' > tmp.h mv tmp.h $@ # # GCC might break this code # gbc.o: gbc.c $(HFILES) $(CC) $(CFLAGS) -O0 gbc.c -o $@ # # This reduces the overhead of jumping to other functions # apply.c: $(DPP) apply.o: apply.c $(HFILES) $(HDIR)/cs.h $(CC) $(CFLAGS) apply.c -o $@ # # These files are interrelated # all_symbols.c: $(DPP) all_symbols.o: all_symbols.c $(CC) $(CFLAGS) -I./ all_symbols.c -o $@ all_symbols2.o: all_symbols.c $(CC) $(CFLAGS) -DECL_FINAL -I./ all_symbols.c -o $@ # # This is in another directory # cinit.c: $(DPP) ../cinit.o: cinit.c $(HFILES) $(CC) $(CFLAGS) -I./ cinit.c -o $@ ecl-16.1.2/src/c/all_symbols.d000066400000000000000000000240511266352375300160600ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ #include #include #include #include #define CL_PACKAGE 0 #define SI_PACKAGE 4 #define EXT_PACKAGE 64 #define GRAY_PACKAGE 32 #define FFI_PACKAGE 128 #define KEYWORD_PACKAGE 8 #define MP_PACKAGE 12 #define CLOS_PACKAGE 16 #define ORDINARY_SYMBOL 0 #define CONSTANT_SYMBOL 1 #define SPECIAL_SYMBOL 2 #define FORM_SYMBOL 3 #define PRIVATE 256 #define CL_ORDINARY CL_PACKAGE | ORDINARY_SYMBOL #define CL_SPECIAL CL_PACKAGE | SPECIAL_SYMBOL #define CL_CONSTANT CL_PACKAGE | CONSTANT_SYMBOL #define CL_FORM CL_PACKAGE | ORDINARY_SYMBOL | FORM_SYMBOL #define SI_ORDINARY SI_PACKAGE | ORDINARY_SYMBOL #define SI_SPECIAL SI_PACKAGE | SPECIAL_SYMBOL #define SI_CONSTANT SI_PACKAGE | CONSTANT_SYMBOL #define EXT_ORDINARY EXT_PACKAGE | ORDINARY_SYMBOL #define EXT_SPECIAL EXT_PACKAGE | SPECIAL_SYMBOL #define EXT_CONSTANT EXT_PACKAGE | CONSTANT_SYMBOL #define EXT_FORM EXT_PACKAGE | ORDINARY_SYMBOL | FORM_SYMBOL #define MP_ORDINARY MP_PACKAGE | ORDINARY_SYMBOL #define MP_SPECIAL MP_PACKAGE | SPECIAL_SYMBOL #define MP_CONSTANT MP_PACKAGE | CONSTANT_SYMBOL #define CLOS_ORDINARY CLOS_PACKAGE | ORDINARY_SYMBOL #define CLOS_SPECIAL CLOS_PACKAGE | SPECIAL_SYMBOL #define KEYWORD KEYWORD_PACKAGE | CONSTANT_SYMBOL #define GRAY_ORDINARY GRAY_PACKAGE | ORDINARY_SYMBOL #define FFI_ORDINARY FFI_PACKAGE | ORDINARY_SYMBOL #define FFI_CONSTANT FFI_PACKAGE | CONSTANT_SYMBOL #include "symbols_list.h" cl_index cl_num_symbols_in_core = 0; static unsigned char * mangle_name(cl_object output, unsigned char *source, int l) { unsigned char c; while (l--) { c = *(source++); if (ecl_alphanumericp(c)) { c = ecl_char_downcase(c); } else if (c == '-' || c == '_') { c = '_'; } else if (c == '&') { c = 'A'; } else if (c == '*') { c = 'X'; } else if (c == '+') { c = 'P'; } else if (c == '<') { c = 'L'; } else if (c == '>') { c = 'G'; } else if (c == '=') { c = 'E'; } else if (c == '/') { c = 'N'; } else if (c == ':') { c = 'X'; } else { return NULL; } output->base_string.self[output->base_string.fillp++] = c; } return &output->base_string.self[output->base_string.fillp]; } @(defun si::mangle-name (symbol &optional as_function) cl_index l; unsigned char c, *source, *dest; cl_object output; cl_object package; cl_object found = ECL_NIL; cl_object maxarg = ecl_make_fixnum(ECL_CALL_ARGUMENTS_LIMIT); cl_object minarg = ecl_make_fixnum(0); bool is_symbol; cl_object name; @ name = ecl_symbol_name(symbol); is_symbol = Null(as_function); if (is_symbol) { cl_fixnum p; if (symbol == ECL_NIL) @(return ECL_T make_constant_base_string("ECL_NIL")) else if (symbol == ECL_T) @(return ECL_T make_constant_base_string("ECL_T")) p = (cl_symbol_initializer*)symbol - cl_symbols; if (p >= 0 && p <= cl_num_symbols_in_core) { found = ECL_T; output = cl_format(4, ECL_NIL, make_constant_base_string("ECL_SYM(~S,~D)"), name, ecl_make_fixnum(p)); @(return found output maxarg) } } else if (!Null(symbol)) { cl_object fun = symbol->symbol.gfdef; cl_type t = (fun == OBJNULL)? t_other : type_of(fun); if ((t == t_cfun || t == t_cfunfixed) && fun->cfun.block == OBJNULL) { for (l = 0; l <= cl_num_symbols_in_core; l++) { cl_object s = (cl_object)(cl_symbols + l); if (fun == ECL_SYM_FUN(s)) { symbol = s; found = ECL_T; if (fun->cfun.narg >= 0) { minarg = maxarg = ecl_make_fixnum(fun->cfun.narg); } break; } } } } package = ecl_symbol_package(symbol); if (Null(package)) ; else if (package == cl_core.lisp_package) package = make_constant_base_string("cl"); else if (package == cl_core.system_package) package = make_constant_base_string("si"); else if (package == cl_core.ext_package) package = make_constant_base_string("si"); else if (package == cl_core.keyword_package) package = ECL_NIL; else package = package->pack.name; symbol = ecl_symbol_name(symbol); l = symbol->base_string.fillp; source = symbol->base_string.self; output = ecl_alloc_simple_base_string(ecl_length(package) + l + 1); if (is_symbol && source[0] == '*') { if (l > 2 && source[l-1] == '*') l--; c = 'V'; l--; source++; } else if (is_symbol && l > 2 && source[0] == '+' && source[l-1] == '+') { c = 'C'; l-= 2; source++; } else if (!is_symbol) { c = '_'; } else if (package == cl_core.keyword_package) { c = 'K'; } else { c = 'S'; } output->base_string.fillp = 0; if (!Null(package)) if (!mangle_name(output, package->base_string.self, package->base_string.fillp)) @(return ECL_NIL ECL_NIL maxarg) output->base_string.self[output->base_string.fillp++] = c; if (!(dest = mangle_name(output, source, l))) @(return ECL_NIL ECL_NIL maxarg) if (dest[-1] == '_') dest[-1] = 'M'; *(dest++) = '\0'; @(return found output minarg maxarg) @) static void make_this_symbol(int i, cl_object s, int code, const char *name, cl_objectfn fun, int narg, cl_object value) { enum ecl_stype stp; cl_object package; bool form = 0; switch (code & 3) { case ORDINARY_SYMBOL: stp = ecl_stp_ordinary; break; case SPECIAL_SYMBOL: stp = ecl_stp_special; break; case CONSTANT_SYMBOL: stp = ecl_stp_constant; break; case FORM_SYMBOL: form = 1; stp = ecl_stp_ordinary; } switch (code & 0xfc) { case CL_PACKAGE: package = cl_core.lisp_package; break; case SI_PACKAGE: package = cl_core.system_package; break; case EXT_PACKAGE: package = cl_core.ext_package; break; case KEYWORD_PACKAGE: package = cl_core.keyword_package; break; case MP_PACKAGE: package = cl_core.mp_package; break; case CLOS_PACKAGE: package = cl_core.clos_package; break; #ifdef ECL_CLOS_STREAMS case GRAY_PACKAGE: package = cl_core.gray_package; break; #endif case FFI_PACKAGE: package = cl_core.ffi_package; break; default: printf("%d\n", code & ~(int)3); ecl_internal_error("Unknown package code in init_all_symbols()"); } s->symbol.t = t_symbol; s->symbol.dynamic = 0; #ifdef ECL_THREADS s->symbol.binding = ECL_MISSING_SPECIAL_BINDING; #endif ECL_SET(s, OBJNULL); ECL_SYM_FUN(s) = ECL_NIL; s->symbol.plist = ECL_NIL; s->symbol.hpack = ECL_NIL; s->symbol.stype = stp; s->symbol.hpack = package; s->symbol.name = make_constant_base_string(name); if (package == cl_core.keyword_package) { package->pack.external = _ecl_sethash(s->symbol.name, package->pack.external, s); ECL_SET(s, s); } else { int intern_flag; ECL_SET(s, value); if (ecl_find_symbol(s->symbol.name, package, &intern_flag) != ECL_NIL && intern_flag == ECL_INHERITED) { ecl_shadowing_import(s, package); } else { cl_import2(s, package); } if (!(code & PRIVATE)) { cl_export2(s, package); if (package == cl_core.ext_package) cl_export2(s, cl_core.system_package); } } if (form) { s->symbol.stype |= ecl_stp_special_form; } else if (fun) { cl_object f; if (narg >= 0) { f = ecl_make_cfun((cl_objectfn_fixed)fun, s, NULL, narg); } else { f = ecl_make_cfun_va(fun, s, NULL); } ECL_SYM_FUN(s) = f; } cl_num_symbols_in_core = i + 1; } void init_all_symbols(void) { int i, code, narg; const char *name; cl_object s, value; cl_objectfn fun; /* We skip NIL and T */ for (i = 2; cl_symbols[i].init.name != NULL; i++) { s = (cl_object)(cl_symbols + i); code = cl_symbols[i].init.type; name = cl_symbols[i].init.name; fun = (cl_objectfn)cl_symbols[i].init.fun; narg = cl_symbols[i].init.narg; value = cl_symbols[i].init.value; make_this_symbol(i, s, code, name, fun, narg, value); } } ecl-16.1.2/src/c/alloc.d000066400000000000000000000733701266352375300146420ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* alloc.c -- Memory allocation. */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ /******************************************************************************** *** *** *** IMPORTANT: This is obsolete code. The current garbage collector of ECL *** *** is the Boehm-Weiser garbage collector and it is dealt with in *** *** alloc_2.d *** *** This file is kept here because of historical purposes, but also because *** *** it might be useful in the future to implement another garbage collector *** *** *** ********************************************************************************/ /* Heap and Relocatable Area heap_end data_end +------+--------------------+ - - - + - - --------+ | text | heap | hole | stack | +------+--------------------+ - - - + - - --------+ The type_map array covers all pages of memory: those not used for objects are marked as type t_other. The tm_table array holds a struct typemanager for each type, which contains the first element of the free list for the type, and other bookkeeping information. */ #include #include #include #include #include #include #define USE_MMAP #if defined(USE_MMAP) #include #include #elif defined(HAVE_ULIMIT_H) #include #else #include #endif #ifdef ECL_SMALL_CONS #error "Internal error: ECL cannot be built with --disable-boehm and --enable-smallcons" #endif /******************************* EXPORTS ******************************/ cl_index real_maxpage; cl_index new_holepage; char type_map[MAXPAGE]; struct typemanager tm_table[(int)t_end]; struct contblock *cb_pointer = NULL; cl_index ncb; /* number of contblocks */ cl_index ncbpage; /* number of contblock pages */ cl_index maxcbpage; /* maximum number of contblock pages */ cl_index cbgccount; /* contblock gc count */ cl_index holepage; /* hole pages */ cl_ptr heap_end; /* heap end */ cl_ptr heap_start; /* heap start */ cl_ptr data_end; /* end of data space */ /******************************* ------- ******************************/ static bool ignore_maximum_pages = TRUE; #ifdef NEED_MALLOC static cl_object malloc_list; #endif /* Ensure that the hole is at least "n" pages large. If it is not, allocate space from the operating system. */ #if defined(USE_MMAP) void cl_resize_hole(cl_index n) { #define PAGESIZE 8192 cl_index m, bytes; cl_ptr result, last_addr; bytes = n * LISP_PAGESIZE; bytes = (bytes + PAGESIZE-1) / PAGESIZE; bytes = bytes * PAGESIZE; if (heap_start == NULL) { /* First time use. We allocate the memory and keep the first * address in heap_start. */ result = mmap(0x2E000000, bytes, PROT_READ | PROT_WRITE, MAP_ANON | MAP_FIXED | MAP_PRIVATE, -1 ,0); if (result == MAP_FAILED) ecl_internal_error("Cannot allocate memory. Good-bye!"); data_end = heap_end = heap_start = result; last_addr = heap_start + bytes; holepage = n; } else { /* Next time use. We extend the region of memory that we had * mapped before. */ m = (data_end - heap_end)/LISP_PAGESIZE; if (n <= m) return; result = mmap(data_end, bytes, PROT_READ | PROT_WRITE, MAP_ANON | MAP_FIXED | MAP_PRIVATE, -1, 0); if (result == MAP_FAILED) ecl_internal_error("Cannot resize memory pool. Good-bye!"); last_addr = result + bytes; if (result != data_end) { cl_dealloc(heap_end, data_end - heap_end); while (heap_end < result) { cl_index p = page(heap_end); if (p > real_maxpage) ecl_internal_error("Memory limit exceeded."); type_map[p] = t_other; heap_end += LISP_PAGESIZE; } } holepage = (last_addr - heap_end) / LISP_PAGESIZE; } while (data_end < last_addr) { type_map[page(data_end)] = t_other; data_end += LISP_PAGESIZE; } } #else void cl_resize_hole(cl_index n) { cl_ptr e; cl_index m; m = (data_end - heap_end)/LISP_PAGESIZE; if (n <= m) return; /* Create the hole */ e = sbrk(0); if (data_end == e) { e = sbrk((n -= m) * LISP_PAGESIZE); } else { cl_dealloc(heap_end, data_end - heap_end); /* FIXME! Horrible hack! */ /* mark as t_other pages not allocated by us */ heap_end = e; while (data_end < heap_end) { type_map[page(data_end)] = t_other; data_end += LISP_PAGESIZE; } holepage = 0; e = sbrk(n * LISP_PAGESIZE + (data_end - e)); } if ((cl_fixnum)e < 0) ecl_internal_error("Can't allocate. Good-bye!"); data_end = e; holepage += n; } #endif /* Allocates n pages from the hole. */ static void * alloc_page(cl_index n) { cl_ptr e = heap_end; if (n >= holepage) { ecl_gc(t_contiguous); cl_resize_hole(new_holepage+n); } holepage -= n; heap_end += LISP_PAGESIZE*n; return e; } /* * We have to mark all objects within the page as FREE. However, at * the end of the page there might be extra bytes, which have to be * tagged as useless. Since these bytes are at least 4, x->m points to * data within the page and we can mark this object setting x->m=FREE. */ static void add_page_to_freelist(cl_ptr p, struct typemanager *tm) { cl_type t; cl_object x, f; cl_index i; t = tm->tm_type; type_map[page(p)] = t; f = tm->tm_free; for (i = tm->tm_nppage; i > 0; --i, p += tm->tm_size) { x = (cl_object)p; ((struct freelist *)x)->t = (short)t; ((struct freelist *)x)->m = FREE; ((struct freelist *)x)->f_link = f; f = x; } /* Mark the extra bytes which cannot be used. */ if (tm->tm_size * tm->tm_nppage < LISP_PAGESIZE) { x = (cl_object)p; x->d.m = FREE; } tm->tm_free = f; tm->tm_nfree += tm->tm_nppage; tm->tm_npage++; } cl_object ecl_alloc_object(cl_type t) { register cl_object obj; register struct typemanager *tm; register cl_ptr p; switch (t) { case t_fixnum: return MAKE_FIXNUM(0); /* Immediate fixnum */ case t_character: return ECL_CODE_CHAR('\0'); /* Immediate character */ default:; } ecl_disable_interrupts(); tm = tm_of(t); ONCE_MORE: obj = tm->tm_free; if (obj == OBJNULL) { cl_index available = available_pages(); if (tm->tm_npage >= tm->tm_maxpage) goto CALL_GC; if (available < 1) { ignore_maximum_pages = FALSE; goto CALL_GC; } p = alloc_page(1); add_page_to_freelist(p, tm); obj = tm->tm_free; /* why this? Beppe if (tm->tm_npage >= tm->tm_maxpage) goto CALL_GC; */ } tm->tm_free = ((struct freelist *)obj)->f_link; --(tm->tm_nfree); (tm->tm_nused)++; obj->d.t = (short)t; obj->d.m = FALSE; /* Now initialize the object so that it can be correctly marked * by the GC */ switch (t) { case t_bignum: ECL_BIGNUM_DIM(obj) = ECL_BIGNUM_SIZE(obj) = 0; ECL_BIGNUM_LIMBS(obj) = NULL; break; case t_ratio: obj->ratio.num = OBJNULL; obj->ratio.den = OBJNULL; break; #ifdef ECL_SSE2 case t_sse_pack: #endif case t_singlefloat: case t_doublefloat: #ifdef ECL_LONG_FLOAT case t_longfloat: #endif break; case t_complex: obj->complex.imag = OBJNULL; obj->complex.real = OBJNULL; break; case t_symbol: obj->symbol.plist = OBJNULL; obj->symbol.gfdef = OBJNULL; obj->symbol.value = OBJNULL; obj->symbol.name = OBJNULL; obj->symbol.hpack = OBJNULL; break; case t_package: obj->pack.name = OBJNULL; obj->pack.nicknames = OBJNULL; obj->pack.shadowings = OBJNULL; obj->pack.uses = OBJNULL; obj->pack.usedby = OBJNULL; obj->pack.internal = OBJNULL; obj->pack.external = OBJNULL; break; case t_cons: #error "FIXME" obj->cons.car = OBJNULL; obj->cons.cdr = OBJNULL; break; case t_hashtable: obj->hash.rehash_size = OBJNULL; obj->hash.threshold = OBJNULL; obj->hash.data = NULL; break; case t_array: obj->array.dims = NULL; obj->array.displaced = ECL_NIL; obj->array.elttype = (short)ecl_aet_object; obj->array.self.t = NULL; break; #ifdef ECL_UNICODE case t_string: #endif case t_vector: obj->array.displaced = ECL_NIL; obj->array.elttype = (short)ecl_aet_object; obj->array.self.t = NULL; break; case t_base_string: obj->base_string.displaced = ECL_NIL; obj->base_string.self = NULL; break; case t_bitvector: obj->vector.displaced = ECL_NIL; obj->vector.self.bit = NULL; break; case t_stream: obj->stream.mode = (short)ecl_smm_broadcast; obj->stream.file.descriptor = -1; obj->stream.object0 = OBJNULL; obj->stream.object1 = OBJNULL; obj->stream.buffer = NULL; break; case t_random: break; case t_readtable: obj->readtable.table = NULL; break; case t_pathname: obj->pathname.host = OBJNULL; obj->pathname.device = OBJNULL; obj->pathname.directory = OBJNULL; obj->pathname.name = OBJNULL; obj->pathname.type = OBJNULL; obj->pathname.version = OBJNULL; break; case t_bytecodes: obj->bytecodes.lex = ECL_NIL; obj->bytecodes.name = ECL_NIL; obj->bytecodes.definition = ECL_NIL; obj->bytecodes.specials = ECL_NIL; obj->bytecodes.code_size = 0; obj->bytecodes.code = NULL; obj->bytecodes.data = NULL; break; case t_bclosure: obj->bclosure.code = obj->bclosure.lex = ECL_NIL; break; case t_cfun: case t_cfunfixed: obj->cfun.name = OBJNULL; obj->cfun.block = NULL; break; case t_cclosure: obj->cclosure.env = OBJNULL; obj->cclosure.block = NULL; break; /* case t_spice: break; */ #ifdef ECL_THREADS case t_process: obj->process.name = OBJNULL; obj->process.function = OBJNULL; obj->process.args = OBJNULL; obj->process.env = NULL; obj->process.interrupt = OBJNULL; break; case t_lock: obj->lock.mutex = OBJNULL; case t_condition_variable: obj->condition_variable.cv = OBJNULL; break; #endif #ifdef ECL_SEMAPHORES case t_semaphore: obj->semaphore.handle = NULL; break; #endif case t_instance: obj->instance.length = 0; ECL_CLASS_OF(obj) = OBJNULL; obj->instance.sig = ECL_NIL; obj->instance.isgf = 0; obj->instance.slots = NULL; break; case t_codeblock: obj->cblock.locked = 0; obj->cblock.name = ECL_NIL; obj->cblock.handle = NULL; obj->cblock.entry = NULL; obj->cblock.data = NULL; obj->cblock.data_size = 0; obj->cblock.data_text = NULL; obj->cblock.data_text_size = 0; obj->cblock.links = ECL_NIL; obj->cblock.next = ECL_NIL; break; case t_foreign: obj->foreign.tag = ECL_NIL; obj->foreign.size = 0; obj->foreign.data = NULL; break; default: printf("\ttype = %d\n", t); ecl_internal_error("alloc botch."); } ecl_enable_interrupts(); return(obj); CALL_GC: ecl_gc(tm->tm_type); if (tm->tm_nfree != 0 && (float)tm->tm_nfree * 10.0 >= (float)tm->tm_nused) goto ONCE_MORE; /* EXHAUSTED: */ if (ignore_maximum_pages) { if (tm->tm_maxpage/2 <= 0) tm->tm_maxpage += 1; else tm->tm_maxpage += tm->tm_maxpage/2; goto ONCE_MORE; } GC_disable(); { cl_object s = ecl_make_simple_base_string(tm_table[(int)t].tm_name+1, -1); GC_enable(); CEerror(ECL_T, "The storage for ~A is exhausted.~%\ Currently, ~D pages are allocated.~%\ Use ALLOCATE to expand the space.", 2, s, MAKE_FIXNUM(tm->tm_npage)); } goto ONCE_MORE; } cl_object ecl_cons(cl_object a, cl_object d) { register cl_object obj; register cl_ptr p; struct typemanager *tm=(&tm_table[(int)t_cons]); ecl_disable_interrupts(); ONCE_MORE: obj = tm->tm_free; if (obj == OBJNULL) { if (tm->tm_npage >= tm->tm_maxpage) goto CALL_GC; if (available_pages() < 1) { ignore_maximum_pages = FALSE; goto CALL_GC; } p = alloc_page(1); add_page_to_freelist(p,tm); obj = tm->tm_free; if (tm->tm_npage >= tm->tm_maxpage) goto CALL_GC; } tm->tm_free = ((struct freelist *)obj)->f_link; --(tm->tm_nfree); (tm->tm_nused)++; obj->d.t = (short)t_cons; obj->d.m = FALSE; obj->cons.car = a; obj->cons.cdr = d; ecl_enable_interrupts(); return(obj); CALL_GC: ecl_gc(t_cons); if ((tm->tm_nfree != 0) && (tm->tm_nfree * 10.0 >= tm->tm_nused)) goto ONCE_MORE; /* EXHAUSTED: */ if (ignore_maximum_pages) { if (tm->tm_maxpage/2 <= 0) tm->tm_maxpage += 1; else tm->tm_maxpage += tm->tm_maxpage/2; goto ONCE_MORE; } CEerror(ECL_T, "The storage for CONS is exhausted.~%\ Currently, ~D pages are allocated.~%\ Use ALLOCATE to expand the space.", 1, MAKE_FIXNUM(tm->tm_npage)); goto ONCE_MORE; #undef tm } cl_object ecl_alloc_instance(cl_index slots) { cl_object i = ecl_alloc_object(t_instance); if (slots >= ECL_SLOTS_LIMIT) FEerror("Limit on instance size exceeded: ~S slots requested.", 1, MAKE_FIXNUM(slots)); /* INV: slots > 0 */ i->instance.slots = (cl_object*)ecl_alloc(sizeof(cl_object) * slots); i->instance.length = slots; return i; } void * ecl_alloc(cl_index n) { volatile cl_ptr p; struct contblock **cbpp; cl_index i, m; bool g; g = FALSE; n = round_up(n); ecl_disable_interrupts(); ONCE_MORE: /* Use extra indirection so that cb_pointer can be updated */ for (cbpp = &cb_pointer; (*cbpp) != NULL; cbpp = &(*cbpp)->cb_link) if ((*cbpp)->cb_size >= n) { p = (cl_ptr)(*cbpp); i = (*cbpp)->cb_size - n; *cbpp = (*cbpp)->cb_link; --ncb; cl_dealloc(p+n, i); ecl_enable_interrupts(); return(p); } m = round_to_page(n); if (ncbpage + m > maxcbpage || available_pages() < m) { if (available_pages() < m) ignore_maximum_pages = FALSE; if (!g) { ecl_gc(t_contiguous); g = TRUE; goto ONCE_MORE; } if (ignore_maximum_pages) { if (maxcbpage/2 <= 0) maxcbpage += 1; else maxcbpage += maxcbpage/2; g = FALSE; goto ONCE_MORE; } CEerror(ECL_T, "Contiguous blocks exhausted.~%\ Currently, ~D pages are allocated.~%\ Use ALLOCATE-CONTIGUOUS-PAGES to expand the space.", 1, MAKE_FIXNUM(ncbpage)); g = FALSE; goto ONCE_MORE; } p = alloc_page(m); for (i = 0; i < m; i++) type_map[page(p) + i] = (char)t_contiguous; ncbpage += m; cl_dealloc(p+n, LISP_PAGESIZE*m - n); ecl_enable_interrupts(); return memset(p, 0, n); } /* * adds a contblock to the list of available ones, pointed by cb_pointer, * sorted by increasing size. */ void cl_dealloc(void *p, cl_index s) { struct contblock **cbpp, *cbp; if (s < CBMINSIZE) return; ncb++; cbp = (struct contblock *)p; cbp->cb_size = s; for (cbpp = &cb_pointer; *cbpp != NULL; cbpp = &((*cbpp)->cb_link)) if ((*cbpp)->cb_size >= s) { cbp->cb_link = *cbpp; *cbpp = cbp; return; } cbp->cb_link = NULL; *cbpp = cbp; } /* * align must be a power of 2 representing the alignment boundary * required for the block. */ void * ecl_alloc_align(cl_index size, cl_index align) { void *output; ecl_disable_interrupts(); align--; if (align) output = (void*)(((cl_index)ecl_alloc(size + align) + align - 1) & ~align); else output = ecl_alloc(size); ecl_enable_interrupts(); return output; } static void init_tm(cl_type t, const char *name, cl_index elsize, cl_index maxpage) { int i, j; struct typemanager *tm = &tm_table[(int)t]; if (elsize < 2*sizeof(cl_index)) { // A free list cell does not fit into this type elsize = 2*sizeof(cl_index); } tm->tm_name = name; for (i = (int)t_start, j = i-1; i < (int)t_end; i++) if (tm_table[i].tm_size >= elsize && (j < (int)t_start || tm_table[j].tm_size > tm_table[i].tm_size)) j = i; if (j >= (int)t_start) { tm->tm_type = (cl_type)j; tm_table[j].tm_maxpage += maxpage; return; } tm->tm_type = t; tm->tm_size = round_up(elsize); tm->tm_nppage = LISP_PAGESIZE/round_up(elsize); tm->tm_free = OBJNULL; tm->tm_nfree = 0; tm->tm_nused = 0; tm->tm_npage = 0; tm->tm_maxpage = maxpage; tm->tm_gccount = 0; } static int alloc_initialized = FALSE; void init_alloc(void) { cl_index i; if (alloc_initialized) return; alloc_initialized = TRUE; holepage = 0; new_holepage = HOLEPAGE; #ifdef USE_MMAP real_maxpage = MAXPAGE; #elif defined(MSDOS) || defined(__CYGWIN__) real_maxpage = MAXPAGE; #elif !defined(HAVE_ULIMIT_H) { struct rlimit data_rlimit; # ifdef __MACH__ sbrk(0); getrlimit(RLIMIT_DATA, &data_rlimit); real_maxpage = ((unsigned)get_etext() + (unsigned)data_rlimit.rlim_cur)/LISP_PAGESIZE; # else extern etext; getrlimit(RLIMIT_DATA, &data_rlimit); real_maxpage = ((unsigned int)&etext + (unsigned)data_rlimit.rlim_cur)/LISP_PAGESIZE; # endif if (real_maxpage > MAXPAGE) real_maxpage = MAXPAGE; } #else /* HAVE_ULIMIT */ real_maxpage= ulimit(UL_GMEMLIM)/LISP_PAGESIZE; if (real_maxpage > MAXPAGE) real_maxpage = MAXPAGE; #endif /* USE_MMAP, MSDOS, or HAVE_ULIMIT */ #ifdef USE_MMAP heap_start = NULL; #else heap_end = sbrk(0); i = ((cl_index)heap_end) % LISP_PAGESIZE; if (i) sbrk(LISP_PAGESIZE - i); heap_end = heap_start = data_end = sbrk(0); #endif cl_resize_hole(INIT_HOLEPAGE); for (i = 0; i < MAXPAGE; i++) type_map[i] = (char)t_other; /* Initialization must be done in increasing size order: */ init_tm(t_singlefloat, "FSINGLE-FLOAT", /* 8 */ sizeof(struct ecl_singlefloat), 1); init_tm(t_cons, ".CONS", sizeof(struct ecl_cons), 384); /* 12 */ init_tm(t_doublefloat, "LDOUBLE-FLOAT", /* 16 */ sizeof(struct ecl_doublefloat), 1); init_tm(t_bytecodes, "bBYTECODES", sizeof(struct ecl_bytecodes), 64); init_tm(t_bytecodes, "bBCLOSURE", sizeof(struct ecl_bclosure), 64); init_tm(t_base_string, "\"BASE-STRING", sizeof(struct ecl_base_string), 64); /* 20 */ #ifdef ECL_UNICODE init_tm(t_string, "\"STRING", sizeof(struct ecl_string), 64); #endif init_tm(t_array, "aARRAY", sizeof(struct ecl_array), 64); /* 24 */ init_tm(t_pathname, "pPATHNAME", sizeof(struct ecl_pathname), 1); /* 28 */ init_tm(t_symbol, "|SYMBOL", sizeof(struct ecl_symbol), 64); /* 32 */ init_tm(t_package, ":PACKAGE", sizeof(struct ecl_package), 1); /* 36 */ init_tm(t_codeblock, "#CODEBLOCK", sizeof(struct ecl_codeblock), 1); init_tm(t_bignum, "BBIGNUM", sizeof(struct ecl_bignum), 16); init_tm(t_ratio, "RRATIO", sizeof(struct ecl_ratio), 1); init_tm(t_complex, "CCOMPLEX", sizeof(struct ecl_complex), 1); init_tm(t_hashtable, "hHASH-TABLE", sizeof(struct ecl_hashtable), 1); init_tm(t_vector, "vVECTOR", sizeof(struct ecl_vector), 2); init_tm(t_bitvector, "bBIT-VECTOR", sizeof(struct ecl_vector), 1); init_tm(t_stream, "sSTREAM", sizeof(struct ecl_stream), 1); init_tm(t_random, "$RANDOM-STATE", sizeof(struct ecl_random), 1); init_tm(t_readtable, "rREADTABLE", sizeof(struct ecl_readtable), 1); init_tm(t_cfun, "fCFUN", sizeof(struct ecl_cfun), 32); init_tm(t_cfunfixed, "fCFUN", sizeof(struct ecl_cfun), 32); init_tm(t_cclosure, "cCCLOSURE", sizeof(struct ecl_cclosure), 1); init_tm(t_instance, "IINSTANCE", sizeof(struct ecl_instance), 32); init_tm(t_foreign, "LFOREIGN", sizeof(struct ecl_foreign), 1); #ifdef ECL_THREADS init_tm(t_process, "tPROCESS", sizeof(struct ecl_process), 2); init_tm(t_lock, "tLOCK", sizeof(struct ecl_lock), 2); init_tm(t_condition_variable, "tCONDITION-VARIABLE", sizeof(struct ecl_condition_variable), 2); #endif /* THREADS */ #ifdef ECL_SEMAPHORES init_tm(t_semaphore, "tSEMAPHORE", sizeof(struct ecl_semaphore), 2); #endif #ifdef ECL_LONG_FLOAT init_tm(t_longfloat, "tLONGFLOAT", sizeof(struct ecl_long_float), 2); #endif ncb = 0; ncbpage = 0; maxcbpage = 2048; #ifdef NEED_MALLOC malloc_list = ECL_NIL; ecl_register_static_root(&malloc_list); #endif } static int t_from_type(cl_object type) { int t; type = cl_string(type); for (t = (int)t_start ; t < (int)t_end ; t++) { struct typemanager *tm = &tm_table[t]; if (tm->tm_name && strncmp((tm->tm_name)+1, type->base_string.self, type->base_string.fillp) == 0) return(t); } FEerror("Unrecognized type", 0); } @(defun si::allocate (type qty &optional (now ECL_NIL)) struct typemanager *tm; cl_ptr pp; cl_index i; @ tm = tm_of(t_from_type(type)); i = ecl_to_size(qty); if (tm->tm_npage > i) i = tm->tm_npage; tm->tm_maxpage = i; if (now == ECL_NIL || tm->tm_maxpage <= tm->tm_npage) @(return ECL_T) if (available_pages() < tm->tm_maxpage - tm->tm_npage || (pp = alloc_page(tm->tm_maxpage - tm->tm_npage)) == NULL) FEerror("Can't allocate ~D pages for ~A.", 2, type, make_constant_base_string(tm->tm_name+1)); for (; tm->tm_npage < tm->tm_maxpage; pp += LISP_PAGESIZE) add_page_to_freelist(pp, tm); @(return ECL_T) @) @(defun si::maximum-allocatable-pages (type) @ @(return MAKE_FIXNUM(tm_of(t_from_type(type))->tm_maxpage)) @) @(defun si::allocated-pages (type) @ @(return MAKE_FIXNUM(tm_of(t_from_type(type))->tm_npage)) @) @(defun si::allocate-contiguous-pages (qty &optional (now ECL_NIL)) cl_index i, m; cl_ptr p; @ i = ecl_to_size(qty); if (ncbpage > i) FEerror("Can't set the limit for contiguous blocks to ~D,~%\ since ~D pages are already allocated.", 2, qty, MAKE_FIXNUM(ncbpage)); maxcbpage = i; if (Null(now)) @(return ECL_T) m = maxcbpage - ncbpage; if (available_pages() < m || (p = alloc_page(m)) == NULL) FEerror("Can't allocate ~D pages for contiguous blocks.", 1, qty); for (i = 0; i < m; i++) type_map[page(p + LISP_PAGESIZE*i)] = (char)t_contiguous; ncbpage += m; cl_dealloc(p, LISP_PAGESIZE*m); @(return ECL_T) @) @(defun si::allocated-contiguous-pages () @ @(return MAKE_FIXNUM(ncbpage)) @) @(defun si::maximum-contiguous-pages () @ @(return MAKE_FIXNUM(maxcbpage)) @) @(defun si::get-hole-size () @ @(return MAKE_FIXNUM(new_holepage)) @) @(defun si::set-hole-size (size) cl_index i; @ i = ecl_to_size(size); if (i == 0 || i > available_pages() + new_holepage) FEerror("Illegal value for the hole size.", 0); new_holepage = i; @(return size) @) @(defun si::ignore-maximum-pages (&optional (flag OBJNULL)) @ if (flag == OBJNULL) @(return (ignore_maximum_pages? ECL_T : ECL_NIL)) ignore_maximum_pages = Null(flag); @(return flag) @) #ifdef NEED_MALLOC /* UNIX malloc simulator. Used by getwd, popen, etc. */ #undef malloc #undef calloc #undef free #undef cfree #undef realloc void * malloc(size_t size) { cl_object x; if (!GC_enabled() && !alloc_initialized) init_alloc(); x = alloc_simple_base_string(size-1); x->base_string.self = (char *)ecl_alloc(size); malloc_list = ecl_cons(x, malloc_list); return(x->base_string.self); } void free(void *ptr) { cl_object *p; if (ptr) { for (p = &malloc_list; !ecl_endp(*p); p = &(CDR((*p)))) if ((CAR((*p)))->base_string.self == ptr) { cl_dealloc(CAR((*p))->base_string.self, CAR((*p))->base_string.dim+1); CAR((*p))->base_string.self = NULL; *p = CDR((*p)); return; } FEerror("free(3) error.", 0); } } void * realloc(void *ptr, size_t size) { cl_object x; size_t i, j; if (ptr == NULL) return malloc(size); for (x = malloc_list; !ecl_endp(x); x = CDR(x)) if (CAR(x)->base_string.self == ptr) { x = CAR(x); if (x->base_string.dim >= size) { x->base_string.fillp = size; return(ptr); } else { j = x->base_string.dim; x->base_string.self = (char *)ecl_alloc(size); x->base_string.fillp = x->base_string.dim = size; memcpy(x->base_string.self, ptr, j); cl_dealloc(ptr, j); return(x->base_string.self); } } FEerror("realloc(3) error.", 0); } void * calloc(size_t nelem, size_t elsize) { char *ptr; size_t i = nelem*elsize; ptr = malloc(i); memset(ptr, 0 , i); return(ptr); } void cfree(void *ptr) { free(ptr); } /* make f allocate enough extra, so that we can round up, the address given to an even multiple. Special case of size == 0 , in which case we just want an aligned number in the address range */ #define ALLOC_ALIGNED(f, size, align) \ ((align) <= 4 ? (int)(f)(size) : \ ((align) * (((unsigned)(f)(size + (size ? (align) - 1 : 0)) + (align) - 1)/(align)))) void * memalign(size_t align, size_t size) { cl_object x = alloc_simple_base_string(size); malloc_list = ecl_cons(x, malloc_list); return x->base_string.self; } # ifdef WANT_VALLOC char * valloc(size_t size) { return memalign(getpagesize(), size);} # endif /* WANT_VALLOC */ #endif /* NEED_MALLOC */ ecl-16.1.2/src/c/alloc_2.d000066400000000000000000001433221266352375300150560ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* alloc_2.c -- Memory allocation based on the Boehmn GC. */ /* Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #include #ifdef ECL_THREADS # ifdef ECL_WINDOWS_THREADS # include # else # include # endif #endif #include #include #include #ifdef ECL_WSOCK #include #endif #ifdef GBC_BOEHM static void (*GC_old_start_callback)(void) = NULL; #ifdef HAVE_GC_SET_START_CALLBACK extern void GC_set_start_callback(void *); extern void *GC_get_start_callback(); #else extern void (*GC_start_call_back)(void); #endif static void gather_statistics(void); static void ecl_mark_env(struct cl_env_struct *env); /* We need these prototypes because private/gc.h is not available * and this interface is not yet exported by BDWGC */ extern void GC_push_all(char *bottom, char *top); extern void GC_push_conditional(char *bottom, char *top, int all); extern void GC_set_mark_bit(const void *p); #ifdef GBC_BOEHM_PRECISE # if GBC_BOEHM # undef GBC_BOEHM_PRECISE # else # include "gc_typed.h" # include "gc_mark.h" # ifdef GBC_BOEHM_OWN_ALLOCATOR # include "private/gc_priv.h" # endif # define GBC_BOEHM_OWN_MARKER # if defined(GBC_BOEHM_OWN_MARKER) || defined(GBC_BOEHM_OWN_ALLOCATOR) static int cl_object_kind, cl_object_mark_proc_index; static void **cl_object_free_list; # endif extern void GC_init_explicit_typing(void); # endif #endif /********************************************************** * OBJECT ALLOCATION * **********************************************************/ void _ecl_set_max_heap_size(size_t new_size) { const cl_env_ptr the_env = ecl_process_env(); ecl_disable_interrupts_env(the_env); GC_set_max_heap_size(cl_core.max_heap_size = new_size); if (new_size == 0) { cl_index size = ecl_option_values[ECL_OPT_HEAP_SAFETY_AREA]; cl_core.safety_region = ecl_alloc_atomic_unprotected(size); } else if (cl_core.safety_region) { GC_FREE(cl_core.safety_region); cl_core.safety_region = 0; } ecl_enable_interrupts_env(the_env); } static int failure; static void * out_of_memory_check(size_t requested_bytes) { failure = 1; return 0; } static void no_warnings(char *msg, GC_word arg) { } static void * out_of_memory(size_t requested_bytes) { const cl_env_ptr the_env = ecl_process_env(); int interrupts = the_env->disable_interrupts; int method = 0; void *output; if (!interrupts) ecl_disable_interrupts_env(the_env); /* Free the input / output buffers */ the_env->string_pool = ECL_NIL; /* The out of memory condition may happen in more than one thread */ /* But then we have to ensure the error has not been solved */ #ifdef ECL_THREADS mp_get_lock_wait(cl_core.error_lock); ECL_UNWIND_PROTECT_BEGIN(the_env) #endif { failure = 0; GC_gcollect(); GC_set_oom_fn(out_of_memory_check); { output = GC_MALLOC(requested_bytes); GC_set_oom_fn(out_of_memory); if (output != 0 && failure == 0) { method = 2; goto OUTPUT; } } if (cl_core.max_heap_size == 0) { /* We did not set any limit in the amount of memory, * yet we failed, or we had some limits but we have * not reached them. */ if (cl_core.safety_region) { /* We can free some memory and try handling the error */ GC_FREE(cl_core.safety_region); the_env->string_pool = ECL_NIL; cl_core.safety_region = 0; method = 0; } else { /* No possibility of continuing */ method = 2; } } else { cl_core.max_heap_size += ecl_option_values[ECL_OPT_HEAP_SAFETY_AREA]; GC_set_max_heap_size(cl_core.max_heap_size); method = 1; } OUTPUT: (void)0; } #ifdef ECL_THREADS ECL_UNWIND_PROTECT_EXIT { mp_giveup_lock(cl_core.error_lock); ecl_enable_interrupts_env(the_env); } ECL_UNWIND_PROTECT_END; #else ecl_enable_interrupts_env(the_env); #endif switch (method) { case 0: cl_error(1, @'ext::storage-exhausted'); break; case 1: cl_cerror(2, make_constant_base_string("Extend heap size"), @'ext::storage-exhausted'); break; case 2: return output; default: ecl_internal_error("Memory exhausted, quitting program."); break; } if (!interrupts) ecl_disable_interrupts_env(the_env); GC_set_max_heap_size(cl_core.max_heap_size += cl_core.max_heap_size / 2); /* Default allocation. Note that we do not allocate atomic. */ return GC_MALLOC(requested_bytes); } #ifdef alloc_object #undef alloc_object #endif static struct ecl_type_information { size_t size; #ifdef GBC_BOEHM_PRECISE GC_word descriptor; #endif cl_object (*allocator)(register struct ecl_type_information *); size_t t; } type_info[t_end]; static void error_wrong_tag(cl_type t) { ecl_internal_error("Collector called with invalid tag number."); } cl_index ecl_object_byte_size(cl_type t) { if (t == t_fixnum || t == t_character) FEerror("ecl_object_byte_size invoked with an immediate type ~D", 1, ecl_make_fixnum(1)); if (t >= t_end) FEerror("ecl_object_byte_size invoked with an unknown type ~D", 1, ecl_make_fixnum(1)); return type_info[t].size; } static cl_object allocate_object_atomic(register struct ecl_type_information *type_info) { const cl_env_ptr the_env = ecl_process_env(); cl_object op; ecl_disable_interrupts_env(the_env); op = GC_MALLOC_ATOMIC(type_info->size); op->d.t = type_info->t; ecl_enable_interrupts_env(the_env); return op; } static cl_object allocate_object_full(register struct ecl_type_information *type_info) { const cl_env_ptr the_env = ecl_process_env(); cl_object op; ecl_disable_interrupts_env(the_env); op = GC_MALLOC(type_info->size); op->d.t = type_info->t; ecl_enable_interrupts_env(the_env); return op; } #ifdef GBC_BOEHM_PRECISE static cl_object allocate_object_typed(register struct ecl_type_information *type_info) { const cl_env_ptr the_env = ecl_process_env(); cl_object op; ecl_disable_interrupts_env(the_env); op = GC_malloc_explicitly_typed(type_info->size, type_info->descriptor); op->d.t = type_info->t; ecl_enable_interrupts_env(the_env); return op; } #endif #ifdef GBC_BOEHM_OWN_ALLOCATOR #error static cl_object allocate_object_own(register struct ecl_type_information *type_info) { #define TYPD_EXTRA_BYTES (sizeof(word) - EXTRA_BYTES) #define GENERAL_MALLOC(lb,k) (void *)GC_generic_malloc(lb, k) const cl_env_ptr the_env = ecl_process_env(); typedef void *ptr_t; ptr_t op; ptr_t * opp; size_t lg, lb; DCL_LOCK_STATE; ecl_disable_interrupts_env(the_env); lb = type_info->size + TYPD_EXTRA_BYTES; if (ecl_likely(SMALL_OBJ(lb))) { lg = GC_size_map[lb]; opp = &(cl_object_free_list[lg]); LOCK(); if( (op = *opp) == 0 ) { UNLOCK(); op = (ptr_t)GENERAL_MALLOC((word)lb, cl_object_kind); if (0 == op) return 0; lg = GC_size_map[lb]; /* May have been uninitialized. */ } else { *opp = obj_link(op); obj_link(op) = 0; GC_bytes_allocd += GRANULES_TO_BYTES(lg); UNLOCK(); } } else { op = (ptr_t)GENERAL_MALLOC((word)lb, cl_object_kind); lg = BYTES_TO_GRANULES(GC_size(op)); } ((word *)op)[GRANULES_TO_WORDS(lg) - 1] = type_info->descriptor; ((cl_object)op)->d.t = type_info->t; ecl_enable_interrupts_env(the_env); return (cl_object)op; } #endif /* GBC_BOEHM_OWN_ALLOCATOR */ #ifdef GBC_BOEHM_OWN_MARKER #define IGNORABLE_POINTER(obj) (ECL_IMMEDIATE(obj) & 2) #define GC_MARK_AND_PUSH(obj, msp, lim, src) \ ((!IGNORABLE_POINTER(obj) && \ (GC_word)obj >= (GC_word)GC_least_plausible_heap_addr && \ (GC_word)obj <= (GC_word)GC_greatest_plausible_heap_addr)? \ GC_mark_and_push(obj, msp, lim, src) : \ msp) static struct GC_ms_entry * cl_object_mark_proc(void *addr, struct GC_ms_entry *msp, struct GC_ms_entry *msl, GC_word env) { #if 1 cl_type t = ((cl_object)addr)->d.t; if (ecl_likely(t > t_start && t < t_end)) { struct ecl_type_information *info = type_info + t; GC_word d = info->descriptor; GC_word *p; for (p = addr; d; p++, d<<=1) { if ((GC_signed_word)d < 0) { GC_word aux = *p; if ((aux & 2) || aux <= (GC_word)GC_least_plausible_heap_addr || aux >= (GC_word)GC_greatest_plausible_heap_addr) continue; msp = GC_mark_and_push((void*)aux, (void*)msp, (void*)msl, (void*)p); } } } #else #define MAYBE_MARK2(ptr) { \ GC_word aux = (GC_word)(ptr); \ if (!(aux & 2) && \ aux >= (GC_word)GC_least_plausible_heap_addr && \ aux <= (GC_word)GC_greatest_plausible_heap_addr) \ msp = GC_mark_and_push((void*)aux, msp, msl, (void*)o); \ } #define MAYBE_MARK(ptr) { \ GC_word aux = (GC_word)(ptr); \ if (!(aux & 2) && \ aux >= (GC_word)lpa && \ aux <= (GC_word)gpa) \ msp = GC_mark_and_push((void*)aux, msp, msl, (void*)o); \ } cl_object o = (cl_object)addr; const GC_word lpa = (GC_word)GC_least_plausible_heap_addr; const GC_word gpa = (GC_word)GC_greatest_plausible_heap_addr; switch (o->d.t) { case t_bignum: MAYBE_MARK(ECL_BIGNUN_LIMBS(o)); break; case t_ratio: MAYBE_MARK(o->ratio.num); MAYBE_MARK(o->ratio.den); break; case t_complex: MAYBE_MARK(o->complex.real); MAYBE_MARK(o->complex.imag); break; case t_symbol: MAYBE_MARK(o->symbol.hpack); MAYBE_MARK(o->symbol.name); MAYBE_MARK(o->symbol.plist); MAYBE_MARK(o->symbol.gfdef); MAYBE_MARK(o->symbol.value); break; case t_package: MAYBE_MARK(o->pack.external); MAYBE_MARK(o->pack.internal); MAYBE_MARK(o->pack.usedby); MAYBE_MARK(o->pack.uses); MAYBE_MARK(o->pack.shadowings); MAYBE_MARK(o->pack.nicknames); MAYBE_MARK(o->pack.name); break; case t_hashtable: MAYBE_MARK(o->hash.threshold); MAYBE_MARK(o->hash.rehash_size); MAYBE_MARK(o->hash.data); break; case t_array: MAYBE_MARK(o->array.dims); case t_vector: # ifdef ECL_UNICODE case t_string: # endif case t_base_string: case t_bitvector: MAYBE_MARK(o->vector.self.t); MAYBE_MARK(o->vector.displaced); break; case t_stream: MAYBE_MARK(o->stream.format_table); MAYBE_MARK(o->stream.format); MAYBE_MARK(o->stream.buffer); MAYBE_MARK(o->stream.byte_stack); MAYBE_MARK(o->stream.object1); MAYBE_MARK(o->stream.object0); MAYBE_MARK(o->stream.ops); break; case t_random: MAYBE_MARK(o->random.value); break; case t_readtable: # ifdef ECL_UNICODE MAYBE_MARK(o->readtable.hash); # endif MAYBE_MARK(o->readtable.table); break; case t_pathname: MAYBE_MARK(o->pathname.version); MAYBE_MARK(o->pathname.type); MAYBE_MARK(o->pathname.name); MAYBE_MARK(o->pathname.directory); MAYBE_MARK(o->pathname.device); MAYBE_MARK(o->pathname.host); break; case t_bytecodes: MAYBE_MARK(o->bytecodes.file_position); MAYBE_MARK(o->bytecodes.file); MAYBE_MARK(o->bytecodes.data); MAYBE_MARK(o->bytecodes.code); MAYBE_MARK(o->bytecodes.definition); MAYBE_MARK(o->bytecodes.name); break; case t_bclosure: MAYBE_MARK(o->bclosure.lex); MAYBE_MARK(o->bclosure.code); break; case t_cfun: MAYBE_MARK(o->cfun.file_position); MAYBE_MARK(o->cfun.file); MAYBE_MARK(o->cfun.block); MAYBE_MARK(o->cfun.name); break; case t_cfunfixed: MAYBE_MARK(o->cfunfixed.file_position); MAYBE_MARK(o->cfunfixed.file); MAYBE_MARK(o->cfunfixed.block); MAYBE_MARK(o->cfunfixed.name); break; case t_cclosure: MAYBE_MARK(o->cclosure.file_position); MAYBE_MARK(o->cclosure.file); MAYBE_MARK(o->cclosure.block); MAYBE_MARK(o->cclosure.env); break; case t_instance: MAYBE_MARK(o->instance.slots); MAYBE_MARK(o->instance.sig); MAYBE_MARK(o->instance.clas); break; # ifdef ECL_THREADS case t_process: MAYBE_MARK(o->process.queue_record); MAYBE_MARK(o->process.start_spinlock); MAYBE_MARK(o->process.woken_up); MAYBE_MARK(o->process.exit_values); MAYBE_MARK(o->process.exit_barrier); MAYBE_MARK(o->process.parent); MAYBE_MARK(o->process.initial_bindings); MAYBE_MARK(o->process.interrupt); MAYBE_MARK(o->process.args); MAYBE_MARK(o->process.function); MAYBE_MARK(o->process.name); if (o->process.env && o->process.env != ECL_NIL) ecl_mark_env(o->process.env); break; case t_lock: MAYBE_MARK(o->lock.queue_list); MAYBE_MARK(o->lock.queue_spinlock); MAYBE_MARK(o->lock.owner); MAYBE_MARK(o->lock.name); break; case t_condition_variable: MAYBE_MARK(o->condition_variable.queue_spinlock); MAYBE_MARK(o->condition_variable.queue_list); MAYBE_MARK(o->condition_variable.lock); break; case t_rwlock: MAYBE_MARK(o->rwlock.name); # ifndef ECL_RWLOCK MAYBE_MARK(o->rwlock.mutex); break; # endif case t_semaphore: MAYBE_MARK(o->semaphore.queue_list); MAYBE_MARK(o->semaphore.queue_spinlock); MAYBE_MARK(o->semaphore.name); break; case t_barrier: MAYBE_MARK(o->barrier.queue_list); MAYBE_MARK(o->barrier.queue_spinlock); MAYBE_MARK(o->barrier.name); break; case t_mailbox: MAYBE_MARK(o->mailbox.data); MAYBE_MARK(o->mailbox.name); MAYBE_MARK(o->mailbox.reader_semaphore); MAYBE_MARK(o->mailbox.writer_semaphore); break; # endif case t_codeblock: MAYBE_MARK(o->cblock.error); MAYBE_MARK(o->cblock.source); MAYBE_MARK(o->cblock.links); MAYBE_MARK(o->cblock.name); MAYBE_MARK(o->cblock.next); MAYBE_MARK(o->cblock.temp_data); MAYBE_MARK(o->cblock.data); break; case t_foreign: MAYBE_MARK(o->foreign.tag); MAYBE_MARK(o->foreign.data); break; case t_frame: MAYBE_MARK(o->frame.env); MAYBE_MARK(o->frame.base); MAYBE_MARK(o->frame.stack); break; default: break; } #endif return msp; } static cl_object allocate_object_marked(register struct ecl_type_information *type_info) { const cl_env_ptr the_env = ecl_process_env(); cl_object op; ecl_disable_interrupts_env(the_env); op = GC_generic_malloc(type_info->size, cl_object_kind); op->d.t = type_info->t; ecl_enable_interrupts_env(the_env); return op; } #endif cl_object ecl_alloc_object(cl_type t) { #ifdef GBC_BOEHM_PRECISE struct ecl_type_information *ti; if (ecl_likely(t > t_start && t < t_end)) { ti = type_info + t; return ti->allocator(ti); } error_wrong_tag(t); return OBJNULL; #else const cl_env_ptr the_env = ecl_process_env(); /* GC_MALLOC already resets objects */ switch (t) { case t_fixnum: return ecl_make_fixnum(0); /* Immediate fixnum */ case t_character: return ECL_CODE_CHAR(' '); /* Immediate character */ #ifdef ECL_SSE2 case t_sse_pack: #endif #ifdef ECL_LONG_FLOAT case t_longfloat: #endif case t_singlefloat: case t_doublefloat: { cl_object obj; ecl_disable_interrupts_env(the_env); obj = (cl_object)GC_MALLOC_ATOMIC(type_info[t].size); ecl_enable_interrupts_env(the_env); obj->d.t = t; return obj; } case t_bignum: case t_ratio: case t_complex: case t_symbol: case t_package: case t_hashtable: case t_array: case t_vector: case t_base_string: #ifdef ECL_UNICODE case t_string: #endif case t_bitvector: case t_stream: case t_random: case t_readtable: case t_pathname: case t_bytecodes: case t_bclosure: case t_cfun: case t_cfunfixed: case t_cclosure: case t_instance: #ifdef ECL_THREADS case t_process: case t_lock: case t_rwlock: case t_condition_variable: case t_semaphore: case t_barrier: case t_mailbox: #endif case t_foreign: case t_codeblock: { cl_object obj; ecl_disable_interrupts_env(the_env); obj = (cl_object)GC_MALLOC(type_info[t].size); ecl_enable_interrupts_env(the_env); obj->d.t = t; return obj; } default: printf("\ttype = %d\n", t); ecl_internal_error("alloc botch."); } #endif } cl_object ecl_alloc_compact_object(cl_type t, cl_index extra_space) { const cl_env_ptr the_env = ecl_process_env(); cl_index size = type_info[t].size; cl_object x; ecl_disable_interrupts_env(the_env); x = (cl_object)GC_MALLOC_ATOMIC(size + extra_space); ecl_enable_interrupts_env(the_env); x->array.t = t; x->array.displaced = (void*)(((char*)x) + size); return x; } cl_object ecl_cons(cl_object a, cl_object d) { const cl_env_ptr the_env = ecl_process_env(); struct ecl_cons *obj; ecl_disable_interrupts_env(the_env); obj = GC_MALLOC(sizeof(struct ecl_cons)); ecl_enable_interrupts_env(the_env); #ifdef ECL_SMALL_CONS obj->car = a; obj->cdr = d; return ECL_PTR_CONS(obj); #else obj->t = t_list; obj->car = a; obj->cdr = d; return (cl_object)obj; #endif } cl_object ecl_list1(cl_object a) { const cl_env_ptr the_env = ecl_process_env(); struct ecl_cons *obj; ecl_disable_interrupts_env(the_env); obj = GC_MALLOC(sizeof(struct ecl_cons)); ecl_enable_interrupts_env(the_env); #ifdef ECL_SMALL_CONS obj->car = a; obj->cdr = ECL_NIL; return ECL_PTR_CONS(obj); #else obj->t = t_list; obj->car = a; obj->cdr = ECL_NIL; return (cl_object)obj; #endif } cl_object ecl_alloc_instance(cl_index slots) { cl_object i; i = ecl_alloc_object(t_instance); i->instance.slots = (cl_object *)ecl_alloc(sizeof(cl_object) * slots); i->instance.length = slots; i->instance.entry = FEnot_funcallable_vararg; i->instance.sig = ECL_UNBOUND; return i; } void * ecl_alloc_uncollectable(size_t size) { const cl_env_ptr the_env = ecl_process_env(); void *output; ecl_disable_interrupts_env(the_env); output = GC_MALLOC_UNCOLLECTABLE(size); ecl_enable_interrupts_env(the_env); return output; } void ecl_free_uncollectable(void *pointer) { const cl_env_ptr the_env = ecl_process_env(); ecl_disable_interrupts_env(the_env); GC_FREE(pointer); ecl_enable_interrupts_env(the_env); } void * ecl_alloc_unprotected(cl_index n) { return GC_MALLOC_IGNORE_OFF_PAGE(n); } void * ecl_alloc_atomic_unprotected(cl_index n) { return GC_MALLOC_ATOMIC_IGNORE_OFF_PAGE(n); } void * ecl_alloc(cl_index n) { const cl_env_ptr the_env = ecl_process_env(); void *output; ecl_disable_interrupts_env(the_env); output = ecl_alloc_unprotected(n); ecl_enable_interrupts_env(the_env); return output; } void * ecl_alloc_atomic(cl_index n) { const cl_env_ptr the_env = ecl_process_env(); void *output; ecl_disable_interrupts_env(the_env); output = ecl_alloc_atomic_unprotected(n); ecl_enable_interrupts_env(the_env); return output; } void ecl_dealloc(void *ptr) { const cl_env_ptr the_env = ecl_process_env(); ecl_disable_interrupts_env(the_env); GC_FREE(ptr); ecl_enable_interrupts_env(the_env); } static int alloc_initialized = FALSE; extern void (*GC_push_other_roots)(); static void (*old_GC_push_other_roots)(); static void stacks_scanner(); static cl_index to_bitmap(void *x, void *y) { cl_index n = (char*)y - (char*)x; if (n % sizeof(void*)) ecl_internal_error("Misaligned pointer in ECL structure."); n /= sizeof(void*); return 1 << n; } void init_alloc(void) { union cl_lispunion o; struct ecl_cons c; int i; if (alloc_initialized) return; alloc_initialized = TRUE; /* * Garbage collector restrictions: we set up the garbage collector * library to work as follows * * 1) The garbage collector shall not scan shared libraries * explicitely. * 2) We only detect objects that are referenced by a pointer to * the begining or to the first byte. * 3) Out of the incremental garbage collector, we only use the * generational component. */ GC_set_no_dls(1); GC_set_all_interior_pointers(0); GC_set_time_limit(GC_TIME_UNLIMITED); GC_init(); #ifdef ECL_THREADS # if GC_VERSION_MAJOR > 7 || GC_VERSION_MINOR > 1 GC_allow_register_threads(); # endif #endif if (ecl_option_values[ECL_OPT_INCREMENTAL_GC]) { GC_enable_incremental(); } GC_register_displacement(1); #ifdef GBC_BOEHM_PRECISE GC_init_explicit_typing(); #endif GC_clear_roots(); GC_disable(); #ifdef GBC_BOEHM_PRECISE # ifdef GBC_BOEHM_OWN_ALLOCATOR cl_object_free_list = (void **)GC_new_free_list_inner(); cl_object_kind = GC_new_kind_inner(cl_object_free_list, (((word)WORDS_TO_BYTES(-1)) | GC_DS_PER_OBJECT), TRUE, TRUE); # else # ifdef GBC_BOEHM_OWN_MARKER cl_object_free_list = (void **)GC_new_free_list_inner(); cl_object_mark_proc_index = GC_new_proc((GC_mark_proc)cl_object_mark_proc); cl_object_kind = GC_new_kind_inner(cl_object_free_list, GC_MAKE_PROC(cl_object_mark_proc_index, 0), FALSE, TRUE); # endif # endif #endif /* !GBC_BOEHM_PRECISE */ GC_set_max_heap_size(cl_core.max_heap_size = ecl_option_values[ECL_OPT_HEAP_SIZE]); /* Save some memory for the case we get tight. */ if (cl_core.max_heap_size == 0) { cl_index size = ecl_option_values[ECL_OPT_HEAP_SAFETY_AREA]; cl_core.safety_region = ecl_alloc_atomic_unprotected(size); } else if (cl_core.safety_region) { cl_core.safety_region = 0; } #define init_tm(x,y,z,w) { \ type_info[x].size = (z); \ if ((w) == 0) { type_info[x].allocator = allocate_object_atomic; } } for (i = 0; i < t_end; i++) { type_info[i].t = i; type_info[i].size = 0; type_info[i].allocator = allocate_object_full; } init_tm(t_list, "CONS", sizeof(struct ecl_cons), 2); init_tm(t_bignum, "BIGNUM", sizeof(struct ecl_bignum), 2); init_tm(t_ratio, "RATIO", sizeof(struct ecl_ratio), 2); init_tm(t_singlefloat, "SINGLE-FLOAT", sizeof(struct ecl_singlefloat), 0); init_tm(t_doublefloat, "DOUBLE-FLOAT", sizeof(struct ecl_doublefloat), 0); #ifdef ECL_LONG_FLOAT init_tm(t_longfloat, "LONG-FLOAT", sizeof(struct ecl_long_float), 0); #endif init_tm(t_complex, "COMPLEX", sizeof(struct ecl_complex), 2); init_tm(t_symbol, "SYMBOL", sizeof(struct ecl_symbol), 5); init_tm(t_package, "PACKAGE", sizeof(struct ecl_package), -1); /* 36 */ #ifdef ECL_THREADS init_tm(t_hashtable, "HASH-TABLE", sizeof(struct ecl_hashtable), 3); #else init_tm(t_hashtable, "HASH-TABLE", sizeof(struct ecl_hashtable), 4); #endif init_tm(t_array, "ARRAY", sizeof(struct ecl_array), 3); init_tm(t_vector, "VECTOR", sizeof(struct ecl_vector), 2); #ifdef ECL_UNICODE init_tm(t_string, "STRING", sizeof(struct ecl_string), 2); #endif init_tm(t_base_string, "BASE-STRING", sizeof(struct ecl_base_string), 2); init_tm(t_bitvector, "BIT-VECTOR", sizeof(struct ecl_vector), 2); init_tm(t_stream, "STREAM", sizeof(struct ecl_stream), 6); init_tm(t_random, "RANDOM-STATE", sizeof(struct ecl_random), -1); init_tm(t_readtable, "READTABLE", sizeof(struct ecl_readtable), 2); init_tm(t_pathname, "PATHNAME", sizeof(struct ecl_pathname), -1); init_tm(t_bytecodes, "BYTECODES", sizeof(struct ecl_bytecodes), -1); init_tm(t_bclosure, "BCLOSURE", sizeof(struct ecl_bclosure), 3); init_tm(t_cfun, "CFUN", sizeof(struct ecl_cfun), -1); init_tm(t_cfunfixed, "CFUNFIXED", sizeof(struct ecl_cfunfixed), -1); init_tm(t_cclosure, "CCLOSURE", sizeof(struct ecl_cclosure), -1); init_tm(t_instance, "INSTANCE", sizeof(struct ecl_instance), 4); #ifdef ECL_THREADS init_tm(t_process, "PROCESS", sizeof(struct ecl_process), 8); init_tm(t_lock, "LOCK", sizeof(struct ecl_lock), 2); init_tm(t_rwlock, "LOCK", sizeof(struct ecl_rwlock), 0); init_tm(t_condition_variable, "CONDITION-VARIABLE", sizeof(struct ecl_condition_variable), 0); init_tm(t_semaphore, "SEMAPHORES", sizeof(struct ecl_semaphore), 0); init_tm(t_barrier, "BARRIER", sizeof(struct ecl_barrier), 0); init_tm(t_mailbox, "MAILBOX", sizeof(struct ecl_mailbox), 0); #endif init_tm(t_codeblock, "CODEBLOCK", sizeof(struct ecl_codeblock), -1); init_tm(t_foreign, "FOREIGN", sizeof(struct ecl_foreign), 2); init_tm(t_frame, "STACK-FRAME", sizeof(struct ecl_stack_frame), 2); init_tm(t_weak_pointer, "WEAK-POINTER", sizeof(struct ecl_weak_pointer), 0); #ifdef ECL_SSE2 init_tm(t_sse_pack, "SSE-PACK", sizeof(struct ecl_sse_pack), 0); #endif #ifdef GBC_BOEHM_PRECISE type_info[t_list].descriptor = to_bitmap(&c, &(c.car)) | to_bitmap(&c, &(c.cdr)); type_info[t_bignum].descriptor = to_bitmap(&o, &(ECL_BIGNUM_LIMBS(&o))); type_info[t_ratio].descriptor = to_bitmap(&o, &(o.ratio.num)) | to_bitmap(&o, &(o.ratio.den)); type_info[t_singlefloat].descriptor = 0; type_info[t_doublefloat].descriptor = 0; #ifdef ECL_LONG_FLOAT type_info[t_longfloat].descriptor = 0; #endif type_info[t_complex].descriptor = to_bitmap(&o, &(o.complex.real)) | to_bitmap(&o, &(o.complex.imag)); type_info[t_symbol].descriptor = to_bitmap(&o, &(o.symbol.value)) | to_bitmap(&o, &(o.symbol.gfdef)) | to_bitmap(&o, &(o.symbol.plist)) | to_bitmap(&o, &(o.symbol.name)) | to_bitmap(&o, &(o.symbol.hpack)); type_info[t_package].descriptor = to_bitmap(&o, &(o.pack.name)) | to_bitmap(&o, &(o.pack.nicknames)) | to_bitmap(&o, &(o.pack.shadowings)) | to_bitmap(&o, &(o.pack.uses)) | to_bitmap(&o, &(o.pack.usedby)) | to_bitmap(&o, &(o.pack.internal)) | to_bitmap(&o, &(o.pack.external)); type_info[t_hashtable].descriptor = to_bitmap(&o, &(o.hash.data)) | to_bitmap(&o, &(o.hash.rehash_size)) | to_bitmap(&o, &(o.hash.threshold)); type_info[t_array].descriptor = to_bitmap(&o, &(o.array.dims)) | to_bitmap(&o, &(o.array.self.t)) | to_bitmap(&o, &(o.array.displaced)); type_info[t_vector].descriptor = to_bitmap(&o, &(o.vector.self.t)) | to_bitmap(&o, &(o.vector.displaced)); # ifdef ECL_UNICODE type_info[t_string].descriptor = to_bitmap(&o, &(o.string.self)) | to_bitmap(&o, &(o.string.displaced)); # endif type_info[t_base_string].descriptor = to_bitmap(&o, &(o.base_string.self)) | to_bitmap(&o, &(o.base_string.displaced)); type_info[t_bitvector].descriptor = to_bitmap(&o, &(o.vector.self.t)) | to_bitmap(&o, &(o.vector.displaced)); type_info[t_stream].descriptor = to_bitmap(&o, &(o.stream.ops)) | to_bitmap(&o, &(o.stream.object0)) | to_bitmap(&o, &(o.stream.object1)) | to_bitmap(&o, &(o.stream.byte_stack)) | to_bitmap(&o, &(o.stream.buffer)) | to_bitmap(&o, &(o.stream.format)) | to_bitmap(&o, &(o.stream.format_table)); type_info[t_random].descriptor = to_bitmap(&o, &(o.random.value)); type_info[t_readtable].descriptor = # ifdef ECL_UNICODE to_bitmap(&o, &(o.readtable.hash)) | # endif to_bitmap(&o, &(o.readtable.table)); type_info[t_pathname].descriptor = to_bitmap(&o, &(o.pathname.version)) | to_bitmap(&o, &(o.pathname.type)) | to_bitmap(&o, &(o.pathname.name)) | to_bitmap(&o, &(o.pathname.directory)) | to_bitmap(&o, &(o.pathname.device)) | to_bitmap(&o, &(o.pathname.host)); type_info[t_bytecodes].descriptor = to_bitmap(&o, &(o.bytecodes.name)) | to_bitmap(&o, &(o.bytecodes.definition)) | to_bitmap(&o, &(o.bytecodes.code)) | to_bitmap(&o, &(o.bytecodes.data)) | to_bitmap(&o, &(o.bytecodes.file)) | to_bitmap(&o, &(o.bytecodes.file_position)); type_info[t_bclosure].descriptor = to_bitmap(&o, &(o.bclosure.code)) | to_bitmap(&o, &(o.bclosure.lex)); type_info[t_cfun].descriptor = to_bitmap(&o, &(o.cfun.name)) | to_bitmap(&o, &(o.cfun.block)) | to_bitmap(&o, &(o.cfun.file)) | to_bitmap(&o, &(o.cfun.file_position)); type_info[t_cfunfixed].descriptor = to_bitmap(&o, &(o.cfunfixed.name)) | to_bitmap(&o, &(o.cfunfixed.block)) | to_bitmap(&o, &(o.cfunfixed.file)) | to_bitmap(&o, &(o.cfunfixed.file_position)); type_info[t_cclosure].descriptor = to_bitmap(&o, &(o.cclosure.env)) | to_bitmap(&o, &(o.cclosure.block)) | to_bitmap(&o, &(o.cclosure.file)) | to_bitmap(&o, &(o.cclosure.file_position)); type_info[t_instance].descriptor = to_bitmap(&o, &(o.instance.clas)) | to_bitmap(&o, &(o.instance.sig)) | to_bitmap(&o, &(o.instance.slots)); # ifdef ECL_THREADS type_info[t_process].descriptor = to_bitmap(&o, &(o.process.name)) | to_bitmap(&o, &(o.process.function)) | to_bitmap(&o, &(o.process.args)) | to_bitmap(&o, &(o.process.env)) | to_bitmap(&o, &(o.process.interrupt)) | to_bitmap(&o, &(o.process.initial_bindings)) | to_bitmap(&o, &(o.process.parent)) | to_bitmap(&o, &(o.process.exit_barrier)) | to_bitmap(&o, &(o.process.exit_values)) | to_bitmap(&o, &(o.process.woken_up)) | to_bitmap(&o, &(o.process.start_spinlock)) | to_bitmap(&o, &(o.process.queue_record)); type_info[t_lock].descriptor = to_bitmap(&o, &(o.lock.name)) | to_bitmap(&o, &(o.lock.owner)) | to_bitmap(&o, &(o.lock.queue_spinlock)) | to_bitmap(&o, &(o.lock.queue_list)); # ifdef ECL_RWLOCK type_info[t_rwlock].descriptor = to_bitmap(&o, &(o.rwlock.name)); # else type_info[t_rwlock].descriptor = to_bitmap(&o, &(o.rwlock.name)) | to_bitmap(&o, &(o.rwlock.mutex)); # endif type_info[t_condition_variable].descriptor = to_bitmap(&o, &(o.condition_variable.lock)) | to_bitmap(&o, &(o.condition_variable.queue_list)) | to_bitmap(&o, &(o.condition_variable.queue_spinlock)); type_info[t_semaphore].descriptor = to_bitmap(&o, &(o.semaphore.name)) | to_bitmap(&o, &(o.semaphore.queue_list)) | to_bitmap(&o, &(o.semaphore.queue_spinlock)); type_info[t_barrier].descriptor = to_bitmap(&o, &(o.barrier.name)) | to_bitmap(&o, &(o.barrier.queue_list)) | to_bitmap(&o, &(o.barrier.queue_spinlock)); type_info[t_mailbox].descriptor = to_bitmap(&o, &(o.mailbox.name)) | to_bitmap(&o, &(o.mailbox.data)) | to_bitmap(&o, &(o.mailbox.reader_semaphore)) | to_bitmap(&o, &(o.mailbox.writer_semaphore)); # endif type_info[t_codeblock].descriptor = to_bitmap(&o, &(o.cblock.data)) | to_bitmap(&o, &(o.cblock.temp_data)) | to_bitmap(&o, &(o.cblock.next)) | to_bitmap(&o, &(o.cblock.name)) | to_bitmap(&o, &(o.cblock.links)) | to_bitmap(&o, &(o.cblock.source)) | to_bitmap(&o, &(o.cblock.error)); type_info[t_foreign].descriptor = to_bitmap(&o, &(o.foreign.data)) | to_bitmap(&o, &(o.foreign.tag)); type_info[t_frame].descriptor = to_bitmap(&o, &(o.frame.stack)) | to_bitmap(&o, &(o.frame.base)) | to_bitmap(&o, &(o.frame.env)); type_info[t_weak_pointer].descriptor = 0; #ifdef ECL_SSE2 type_info[t_sse_pack].descriptor = 0; #endif for (i = 0; i < t_end; i++) { GC_word descriptor = type_info[i].descriptor; int bits = type_info[i].size / sizeof(GC_word); if (descriptor) { #ifdef GBC_BOEHM_OWN_MARKER type_info[i].allocator = allocate_object_marked; descriptor = GC_make_descriptor(&descriptor, bits); descriptor &= ~GC_DS_TAGS; #else GC_word mask = (1 << (bits-1)) - 1; mask ^= (descriptor >> 1); if (mask == 0) type_info[i].allocator = allocate_object_full; else type_info[i].allocator = allocate_object_typed; descriptor = GC_make_descriptor(&descriptor, bits); #endif } else { type_info[i].allocator = allocate_object_atomic; descriptor = 0; } type_info[i].descriptor = descriptor; } #endif /* GBC_BOEHM_PRECISE */ old_GC_push_other_roots = GC_push_other_roots; GC_push_other_roots = stacks_scanner; #ifdef HAVE_GC_SET_START_CALLBACK GC_old_start_callback = GC_get_start_callback(); GC_set_start_callback(gather_statistics); #else GC_old_start_callback = GC_start_call_back; GC_start_call_back = (void (*)(void))gather_statistics; #endif GC_set_java_finalization(1); GC_set_oom_fn(out_of_memory); GC_set_warn_proc(no_warnings); GC_enable(); } /********************************************************** * FINALIZATION * **********************************************************/ static void standard_finalizer(cl_object o) { switch (o->d.t) { #ifdef ENABLE_DLOPEN case t_codeblock: ecl_library_close(o); break; #endif case t_stream: cl_close(1, o); break; case t_weak_pointer: GC_unregister_disappearing_link((void**)&(o->weak.value)); break; #ifdef ECL_THREADS # ifdef ECL_RWLOCK case t_rwlock: { const cl_env_ptr the_env = ecl_process_env(); ecl_disable_interrupts_env(the_env); pthread_rwlock_destroy(&o->rwlock.mutex); ecl_enable_interrupts_env(the_env); break; } # endif case t_symbol: { ecl_atomic_push(&cl_core.reused_indices, ecl_make_fixnum(o->symbol.binding)); } #endif /* ECL_THREADS */ default:; } } static void wrapped_finalizer(cl_object o, cl_object finalizer) { if (finalizer != ECL_NIL && finalizer != NULL) { CL_NEWENV_BEGIN { if (finalizer != ECL_T) { funcall(2, finalizer, o); } standard_finalizer(o); } CL_NEWENV_END; } } cl_object si_get_finalizer(cl_object o) { const cl_env_ptr the_env = ecl_process_env(); cl_object output; GC_finalization_proc ofn; void *odata; ecl_disable_interrupts_env(the_env); GC_register_finalizer_no_order(o, (GC_finalization_proc)0, 0, &ofn, &odata); if (ofn == 0) { output = ECL_NIL; } else if (ofn == (GC_finalization_proc)wrapped_finalizer) { output = (cl_object)odata; } else { output = ECL_NIL; } GC_register_finalizer_no_order(o, ofn, odata, &ofn, &odata); ecl_enable_interrupts_env(the_env); @(return output) } void ecl_set_finalizer_unprotected(cl_object o, cl_object finalizer) { GC_finalization_proc ofn; void *odata; if (finalizer == ECL_NIL) { GC_register_finalizer_no_order(o, (GC_finalization_proc)0, 0, &ofn, &odata); } else { GC_finalization_proc newfn; newfn = (GC_finalization_proc)wrapped_finalizer; GC_register_finalizer_no_order(o, newfn, finalizer, &ofn, &odata); } } cl_object si_set_finalizer(cl_object o, cl_object finalizer) { const cl_env_ptr the_env = ecl_process_env(); ecl_disable_interrupts_env(the_env); ecl_set_finalizer_unprotected(o, finalizer); ecl_enable_interrupts_env(the_env); @(return) } /* If we do not build our own version of the library, we do not have * control over the existence of this variable. */ #if GBC_BOEHM == 0 extern int GC_print_stats; #else static int GC_print_stats; #endif cl_object si_gc_stats(cl_object enable) { cl_object old_status; cl_object size1 = ecl_make_fixnum(0); cl_object size2 = ecl_make_fixnum(0); if (cl_core.gc_stats == 0) { old_status = ECL_NIL; } else if (GC_print_stats) { old_status = @':full'; } else { old_status = ECL_T; } if (cl_core.bytes_consed == ECL_NIL) { cl_core.bytes_consed = ecl_alloc_object(t_bignum); mpz_init2(cl_core.bytes_consed->big.big_num, 128); cl_core.gc_counter = ecl_alloc_object(t_bignum); mpz_init2(cl_core.gc_counter->big.big_num, 128); } else { /* We need fresh copies of the bignums */ size1 = _ecl_big_plus_fix(cl_core.bytes_consed, 1); size2 = _ecl_big_plus_fix(cl_core.gc_counter, 1); } if (enable == ECL_NIL) { GC_print_stats = 0; cl_core.gc_stats = 0; } else if (enable == ecl_make_fixnum(0)) { mpz_set_ui(cl_core.bytes_consed->big.big_num, 0); mpz_set_ui(cl_core.gc_counter->big.big_num, 0); } else { cl_core.gc_stats = 1; GC_print_stats = (enable == @':full'); } @(return size1 size2 old_status) } /* * This procedure is invoked after garbage collection. Note that we * cannot cons because this procedure is invoked with the garbage * collection lock on. */ static void gather_statistics() { if (cl_core.gc_stats) { /* Sorry, no gc stats if you do not use bignums */ #if GBC_BOEHM == 0 mpz_add_ui(cl_core.bytes_consed->big.big_num, cl_core.bytes_consed->big.big_num, GC_get_bytes_since_gc()); #else /* This is not accurate and may wrap around. We try to detect this assuming that an overflow in an unsigned integer will produce an smaller integer.*/ static cl_index bytes = 0; cl_index new_bytes = GC_get_total_bytes(); if (bytes > new_bytes) { cl_index wrapped; wrapped = ~((cl_index)0) - bytes; mpz_add_ui(cl_core.bytes_consed->big.big_num, cl_core.bytes_consed->big.big_num, wrapped); bytes = new_bytes; } mpz_add_ui(cl_core.bytes_consed->big.big_num, cl_core.bytes_consed->big.big_num, new_bytes - bytes); #endif mpz_add_ui(cl_core.gc_counter->big.big_num, cl_core.gc_counter->big.big_num, 1); } if (GC_old_start_callback) GC_old_start_callback(); } /********************************************************** * GARBAGE COLLECTOR * **********************************************************/ static void ecl_mark_env(struct cl_env_struct *env) { #if 1 if (env->stack) { GC_push_conditional((void *)env->stack, (void *)env->stack_top, 1); GC_set_mark_bit((void *)env->stack); } if (env->frs_top) { GC_push_conditional((void *)env->frs_org, (void *)(env->frs_top+1), 1); GC_set_mark_bit((void *)env->frs_org); } if (env->bds_top) { GC_push_conditional((void *)env->bds_org, (void *)(env->bds_top+1), 1); GC_set_mark_bit((void *)env->bds_org); } #endif /*memset(env->values[env->nvalues], 0, (64-env->nvalues)*sizeof(cl_object));*/ #if defined(ECL_THREADS) && !defined(ECL_USE_MPROTECT) && !defined(ECL_USE_GUARD_PAGE) /* When using threads, "env" is a pointer to memory allocated by ECL. */ GC_push_conditional((void *)env, (void *)(env + 1), 1); GC_set_mark_bit((void *)env); #else /* When not using threads, "env" is mmaped or statically allocated. */ GC_push_all((void *)env, (void *)(env + 1)); #endif } static void stacks_scanner() { cl_env_ptr the_env = ecl_process_env(); cl_object l; l = cl_core.libraries; if (l) { for (; l != ECL_NIL; l = ECL_CONS_CDR(l)) { cl_object dll = ECL_CONS_CAR(l); if (dll->cblock.locked) { GC_push_conditional((void *)dll, (void *)(&dll->cblock + 1), 1); GC_set_mark_bit((void *)dll); } } } GC_push_all((void *)(&cl_core), (void *)(&cl_core + 1)); GC_push_all((void *)cl_symbols, (void *)(cl_symbols + cl_num_symbols_in_core)); if (the_env != NULL) ecl_mark_env(the_env); #ifdef ECL_THREADS l = cl_core.processes; if (l != OBJNULL) { cl_index i, size; for (i = 0, size = l->vector.dim; i < size; i++) { cl_object process = l->vector.self.t[i]; if (!Null(process)) { cl_env_ptr env = process->process.env; if (env && (env != the_env)) ecl_mark_env(env); } } } #endif if (old_GC_push_other_roots) (*old_GC_push_other_roots)(); } /********************************************************** * GARBAGE COLLECTION * **********************************************************/ void ecl_register_root(cl_object *p) { const cl_env_ptr the_env = ecl_process_env(); ecl_disable_interrupts_env(the_env); GC_add_roots((char*)p, (char*)(p+1)); ecl_enable_interrupts_env(the_env); } cl_object si_gc(cl_narg narg, ...) { const cl_env_ptr the_env = ecl_process_env(); ecl_disable_interrupts_env(the_env); GC_gcollect(); ecl_enable_interrupts_env(the_env); @(return) } cl_object si_gc_dump() { const cl_env_ptr the_env = ecl_process_env(); ecl_disable_interrupts_env(the_env); GC_dump(); ecl_enable_interrupts_env(the_env); @(return) } /********************************************************************** * WEAK POINTERS */ static cl_object ecl_alloc_weak_pointer(cl_object o) { const cl_env_ptr the_env = ecl_process_env(); struct ecl_weak_pointer *obj; ecl_disable_interrupts_env(the_env); obj = GC_MALLOC_ATOMIC(sizeof(struct ecl_weak_pointer)); ecl_enable_interrupts_env(the_env); obj->t = t_weak_pointer; obj->value = o; if (!ECL_FIXNUMP(o) && !ECL_CHARACTERP(o) && !Null(o)) { GC_general_register_disappearing_link((void**)&(obj->value), (void*)o); si_set_finalizer((cl_object)obj, ECL_T); } return (cl_object)obj; } cl_object si_make_weak_pointer(cl_object o) { cl_object pointer = ecl_alloc_weak_pointer(o); @(return pointer); } static cl_object ecl_weak_pointer_value(cl_object o) { return o->weak.value; } cl_object si_weak_pointer_value(cl_object o) { cl_object value; if (ecl_unlikely(ecl_t_of(o) != t_weak_pointer)) FEwrong_type_only_arg(@[ext::weak-pointer-value], o, @[ext::weak-pointer]); value = (cl_object)GC_call_with_alloc_lock((GC_fn_type)ecl_weak_pointer_value, o); @(return (value? value : ECL_NIL)); } #endif /* GBC_BOEHM */ ecl-16.1.2/src/c/apply.d000066400000000000000000001156711266352375300146760ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* apply.c -- Interface to C call mechanism. */ /* Copyright (c) 1993, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #ifndef ECL_ASM_APPLY cl_object APPLY(cl_narg n, cl_objectfn fn, cl_object *x) { switch (n) { case 0: return (*fn)(n); case 1: return (*fn)(n, x[0]); case 2: return (*fn)(n, x[0],x[1]); case 3: return (*fn)(n, x[0],x[1],x[2]); case 4: return (*fn)(n, x[0],x[1],x[2],x[3]); case 5: return (*fn)(n, x[0],x[1],x[2],x[3],x[4]); case 6: return (*fn)(n, x[0],x[1],x[2],x[3],x[4],x[5]); case 7: return (*fn)(n, x[0],x[1],x[2],x[3],x[4],x[5],x[6]); case 8: return (*fn)(n, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7]); case 9: return (*fn)(n, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8]); case 10: return (*fn)(n, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9]); case 11: return (*fn)(n, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10]); case 12: return (*fn)(n, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11]); case 13: return (*fn)(n, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12]); case 14: return (*fn)(n, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13]); case 15: return (*fn)(n, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14]); case 16: return (*fn)(n, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15]); case 17: return (*fn)(n, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16]); case 18: return (*fn)(n, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17]); case 19: return (*fn)(n, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18]); case 20: return (*fn)(n, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19]); case 21: return (*fn)(n, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20]); case 22: return (*fn)(n, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21]); case 23: return (*fn)(n, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22]); case 24: return (*fn)(n, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23]); case 25: return (*fn)(n, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24]); case 26: return (*fn)(n, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25]); case 27: return (*fn)(n, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26]); case 28: return (*fn)(n, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27]); case 29: return (*fn)(n, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28]); case 30: return (*fn)(n, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28], x[29]); case 31: return (*fn)(n, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28], x[29],x[30]); case 32: return (*fn)(n, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28], x[29],x[30],x[31]); case 33: return (*fn)(n, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28], x[29],x[30],x[31],x[32]); case 34: return (*fn)(n, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28], x[29],x[30],x[31],x[32],x[33]); case 35: return (*fn)(n, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28], x[29],x[30],x[31],x[32],x[33],x[34]); case 36: return (*fn)(n, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28], x[29],x[30],x[31],x[32],x[33],x[34],x[35]); case 37: return (*fn)(n, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28], x[29],x[30],x[31],x[32],x[33],x[34],x[35], x[36]); case 38: return (*fn)(n, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28], x[29],x[30],x[31],x[32],x[33],x[34],x[35], x[36],x[37]); case 39: return (*fn)(n, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28], x[29],x[30],x[31],x[32],x[33],x[34],x[35], x[36],x[37],x[38]); case 40: return (*fn)(n, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28], x[29],x[30],x[31],x[32],x[33],x[34],x[35], x[36],x[37],x[38],x[39]); case 41: return (*fn)(n, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28], x[29],x[30],x[31],x[32],x[33],x[34],x[35], x[36],x[37],x[38],x[39],x[40]); case 42: return (*fn)(n, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28], x[29],x[30],x[31],x[32],x[33],x[34],x[35], x[36],x[37],x[38],x[39],x[40],x[41]); case 43: return (*fn)(n, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28], x[29],x[30],x[31],x[32],x[33],x[34],x[35], x[36],x[37],x[38],x[39],x[40],x[41],x[42]); case 44: return (*fn)(n, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28], x[29],x[30],x[31],x[32],x[33],x[34],x[35], x[36],x[37],x[38],x[39],x[40],x[41],x[42], x[43]); case 45: return (*fn)(n, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28], x[29],x[30],x[31],x[32],x[33],x[34],x[35], x[36],x[37],x[38],x[39],x[40],x[41],x[42], x[43],x[44]); case 46: return (*fn)(n, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28], x[29],x[30],x[31],x[32],x[33],x[34],x[35], x[36],x[37],x[38],x[39],x[40],x[41],x[42], x[43],x[44],x[45]); case 47: return (*fn)(n, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28], x[29],x[30],x[31],x[32],x[33],x[34],x[35], x[36],x[37],x[38],x[39],x[40],x[41],x[42], x[43],x[44],x[45],x[46]); case 48: return (*fn)(n, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28], x[29],x[30],x[31],x[32],x[33],x[34],x[35], x[36],x[37],x[38],x[39],x[40],x[41],x[42], x[43],x[44],x[45],x[46],x[47]); case 49: return (*fn)(n, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28], x[29],x[30],x[31],x[32],x[33],x[34],x[35], x[36],x[37],x[38],x[39],x[40],x[41],x[42], x[43],x[44],x[45],x[46],x[47],x[48]); case 50: return (*fn)(n, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28], x[29],x[30],x[31],x[32],x[33],x[34],x[35], x[36],x[37],x[38],x[39],x[40],x[41],x[42], x[43],x[44],x[45],x[46],x[47],x[48],x[49]); case 51: return (*fn)(n, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28], x[29],x[30],x[31],x[32],x[33],x[34],x[35], x[36],x[37],x[38],x[39],x[40],x[41],x[42], x[43],x[44],x[45],x[46],x[47],x[48],x[49], x[50]); case 52: return (*fn)(n, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28], x[29],x[30],x[31],x[32],x[33],x[34],x[35], x[36],x[37],x[38],x[39],x[40],x[41],x[42], x[43],x[44],x[45],x[46],x[47],x[48],x[49], x[50],x[51]); case 53: return (*fn)(n, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28], x[29],x[30],x[31],x[32],x[33],x[34],x[35], x[36],x[37],x[38],x[39],x[40],x[41],x[42], x[43],x[44],x[45],x[46],x[47],x[48],x[49], x[50],x[51],x[52]); case 54: return (*fn)(n, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28], x[29],x[30],x[31],x[32],x[33],x[34],x[35], x[36],x[37],x[38],x[39],x[40],x[41],x[42], x[43],x[44],x[45],x[46],x[47],x[48],x[49], x[50],x[51],x[52],x[53]); case 55: return (*fn)(n, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28], x[29],x[30],x[31],x[32],x[33],x[34],x[35], x[36],x[37],x[38],x[39],x[40],x[41],x[42], x[43],x[44],x[45],x[46],x[47],x[48],x[49], x[50],x[51],x[52],x[53],x[54]); case 56: return (*fn)(n, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28], x[29],x[30],x[31],x[32],x[33],x[34],x[35], x[36],x[37],x[38],x[39],x[40],x[41],x[42], x[43],x[44],x[45],x[46],x[47],x[48],x[49], x[50],x[51],x[52],x[53],x[54],x[55]); case 57: return (*fn)(n, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28], x[29],x[30],x[31],x[32],x[33],x[34],x[35], x[36],x[37],x[38],x[39],x[40],x[41],x[42], x[43],x[44],x[45],x[46],x[47],x[48],x[49], x[50],x[51],x[52],x[53],x[54],x[55],x[56]); case 58: return (*fn)(n, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28], x[29],x[30],x[31],x[32],x[33],x[34],x[35], x[36],x[37],x[38],x[39],x[40],x[41],x[42], x[43],x[44],x[45],x[46],x[47],x[48],x[49], x[50],x[51],x[52],x[53],x[54],x[55],x[56], x[57]); case 59: return (*fn)(n, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28], x[29],x[30],x[31],x[32],x[33],x[34],x[35], x[36],x[37],x[38],x[39],x[40],x[41],x[42], x[43],x[44],x[45],x[46],x[47],x[48],x[49], x[50],x[51],x[52],x[53],x[54],x[55],x[56], x[57],x[58]); case 60: return (*fn)(n, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28], x[29],x[30],x[31],x[32],x[33],x[34],x[35], x[36],x[37],x[38],x[39],x[40],x[41],x[42], x[43],x[44],x[45],x[46],x[47],x[48],x[49], x[50],x[51],x[52],x[53],x[54],x[55],x[56], x[57],x[58],x[59]); case 61: return (*fn)(n, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28], x[29],x[30],x[31],x[32],x[33],x[34],x[35], x[36],x[37],x[38],x[39],x[40],x[41],x[42], x[43],x[44],x[45],x[46],x[47],x[48],x[49], x[50],x[51],x[52],x[53],x[54],x[55],x[56], x[57],x[58],x[59],x[60]); case 62: return (*fn)(n, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28], x[29],x[30],x[31],x[32],x[33],x[34],x[35], x[36],x[37],x[38],x[39],x[40],x[41],x[42], x[43],x[44],x[45],x[46],x[47],x[48],x[49], x[50],x[51],x[52],x[53],x[54],x[55],x[56], x[57],x[58],x[59],x[60],x[61]); case 63: return (*fn)(n, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28], x[29],x[30],x[31],x[32],x[33],x[34],x[35], x[36],x[37],x[38],x[39],x[40],x[41],x[42], x[43],x[44],x[45],x[46],x[47],x[48],x[49], x[50],x[51],x[52],x[53],x[54],x[55],x[56], x[57],x[58],x[59],x[60],x[61],x[62]); default: return (*fn)(n, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28], x[29],x[30],x[31],x[32],x[33],x[34],x[35], x[36],x[37],x[38],x[39],x[40],x[41],x[42], x[43],x[44],x[45],x[46],x[47],x[48],x[49], x[50],x[51],x[52],x[53],x[54],x[55],x[56], x[57],x[58],x[59],x[60],x[61],x[62],x[63]); /* Arguments above 64 have been pushed on the stack */ } } cl_object APPLY_fixed(cl_narg n, cl_object (*fn)(), cl_object *x) { switch (n) { case 0: return (*fn)(); case 1: return (*fn)(x[0]); case 2: return (*fn)(x[0],x[1]); case 3: return (*fn)(x[0],x[1],x[2]); case 4: return (*fn)(x[0],x[1],x[2],x[3]); case 5: return (*fn)(x[0],x[1],x[2],x[3],x[4]); case 6: return (*fn)(x[0],x[1],x[2],x[3],x[4],x[5]); case 7: return (*fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6]); case 8: return (*fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7]); case 9: return (*fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8]); case 10: return (*fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9]); case 11: return (*fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10]); case 12: return (*fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11]); case 13: return (*fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12]); case 14: return (*fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13]); case 15: return (*fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14]); case 16: return (*fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15]); case 17: return (*fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16]); case 18: return (*fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17]); case 19: return (*fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18]); case 20: return (*fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19]); case 21: return (*fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20]); case 22: return (*fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21]); case 23: return (*fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22]); case 24: return (*fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23]); case 25: return (*fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24]); case 26: return (*fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25]); case 27: return (*fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26]); case 28: return (*fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27]); case 29: return (*fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28]); case 30: return (*fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28], x[29]); case 31: return (*fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28], x[29],x[30]); case 32: return (*fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28], x[29],x[30],x[31]); case 33: return (*fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28], x[29],x[30],x[31],x[32]); case 34: return (*fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28], x[29],x[30],x[31],x[32],x[33]); case 35: return (*fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28], x[29],x[30],x[31],x[32],x[33],x[34]); case 36: return (*fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28], x[29],x[30],x[31],x[32],x[33],x[34],x[35]); case 37: return (*fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28], x[29],x[30],x[31],x[32],x[33],x[34],x[35], x[36]); case 38: return (*fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28], x[29],x[30],x[31],x[32],x[33],x[34],x[35], x[36],x[37]); case 39: return (*fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28], x[29],x[30],x[31],x[32],x[33],x[34],x[35], x[36],x[37],x[38]); case 40: return (*fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28], x[29],x[30],x[31],x[32],x[33],x[34],x[35], x[36],x[37],x[38],x[39]); case 41: return (*fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28], x[29],x[30],x[31],x[32],x[33],x[34],x[35], x[36],x[37],x[38],x[39],x[40]); case 42: return (*fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28], x[29],x[30],x[31],x[32],x[33],x[34],x[35], x[36],x[37],x[38],x[39],x[40],x[41]); case 43: return (*fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28], x[29],x[30],x[31],x[32],x[33],x[34],x[35], x[36],x[37],x[38],x[39],x[40],x[41],x[42]); case 44: return (*fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28], x[29],x[30],x[31],x[32],x[33],x[34],x[35], x[36],x[37],x[38],x[39],x[40],x[41],x[42], x[43]); case 45: return (*fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28], x[29],x[30],x[31],x[32],x[33],x[34],x[35], x[36],x[37],x[38],x[39],x[40],x[41],x[42], x[43],x[44]); case 46: return (*fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28], x[29],x[30],x[31],x[32],x[33],x[34],x[35], x[36],x[37],x[38],x[39],x[40],x[41],x[42], x[43],x[44],x[45]); case 47: return (*fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28], x[29],x[30],x[31],x[32],x[33],x[34],x[35], x[36],x[37],x[38],x[39],x[40],x[41],x[42], x[43],x[44],x[45],x[46]); case 48: return (*fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28], x[29],x[30],x[31],x[32],x[33],x[34],x[35], x[36],x[37],x[38],x[39],x[40],x[41],x[42], x[43],x[44],x[45],x[46],x[47]); case 49: return (*fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28], x[29],x[30],x[31],x[32],x[33],x[34],x[35], x[36],x[37],x[38],x[39],x[40],x[41],x[42], x[43],x[44],x[45],x[46],x[47],x[48]); case 50: return (*fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28], x[29],x[30],x[31],x[32],x[33],x[34],x[35], x[36],x[37],x[38],x[39],x[40],x[41],x[42], x[43],x[44],x[45],x[46],x[47],x[48],x[49]); case 51: return (*fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28], x[29],x[30],x[31],x[32],x[33],x[34],x[35], x[36],x[37],x[38],x[39],x[40],x[41],x[42], x[43],x[44],x[45],x[46],x[47],x[48],x[49], x[50]); case 52: return (*fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28], x[29],x[30],x[31],x[32],x[33],x[34],x[35], x[36],x[37],x[38],x[39],x[40],x[41],x[42], x[43],x[44],x[45],x[46],x[47],x[48],x[49], x[50],x[51]); case 53: return (*fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28], x[29],x[30],x[31],x[32],x[33],x[34],x[35], x[36],x[37],x[38],x[39],x[40],x[41],x[42], x[43],x[44],x[45],x[46],x[47],x[48],x[49], x[50],x[51],x[52]); case 54: return (*fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28], x[29],x[30],x[31],x[32],x[33],x[34],x[35], x[36],x[37],x[38],x[39],x[40],x[41],x[42], x[43],x[44],x[45],x[46],x[47],x[48],x[49], x[50],x[51],x[52],x[53]); case 55: return (*fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28], x[29],x[30],x[31],x[32],x[33],x[34],x[35], x[36],x[37],x[38],x[39],x[40],x[41],x[42], x[43],x[44],x[45],x[46],x[47],x[48],x[49], x[50],x[51],x[52],x[53],x[54]); case 56: return (*fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28], x[29],x[30],x[31],x[32],x[33],x[34],x[35], x[36],x[37],x[38],x[39],x[40],x[41],x[42], x[43],x[44],x[45],x[46],x[47],x[48],x[49], x[50],x[51],x[52],x[53],x[54],x[55]); case 57: return (*fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28], x[29],x[30],x[31],x[32],x[33],x[34],x[35], x[36],x[37],x[38],x[39],x[40],x[41],x[42], x[43],x[44],x[45],x[46],x[47],x[48],x[49], x[50],x[51],x[52],x[53],x[54],x[55],x[56]); case 58: return (*fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28], x[29],x[30],x[31],x[32],x[33],x[34],x[35], x[36],x[37],x[38],x[39],x[40],x[41],x[42], x[43],x[44],x[45],x[46],x[47],x[48],x[49], x[50],x[51],x[52],x[53],x[54],x[55],x[56], x[57]); case 59: return (*fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28], x[29],x[30],x[31],x[32],x[33],x[34],x[35], x[36],x[37],x[38],x[39],x[40],x[41],x[42], x[43],x[44],x[45],x[46],x[47],x[48],x[49], x[50],x[51],x[52],x[53],x[54],x[55],x[56], x[57],x[58]); case 60: return (*fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28], x[29],x[30],x[31],x[32],x[33],x[34],x[35], x[36],x[37],x[38],x[39],x[40],x[41],x[42], x[43],x[44],x[45],x[46],x[47],x[48],x[49], x[50],x[51],x[52],x[53],x[54],x[55],x[56], x[57],x[58],x[59]); case 61: return (*fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28], x[29],x[30],x[31],x[32],x[33],x[34],x[35], x[36],x[37],x[38],x[39],x[40],x[41],x[42], x[43],x[44],x[45],x[46],x[47],x[48],x[49], x[50],x[51],x[52],x[53],x[54],x[55],x[56], x[57],x[58],x[59],x[60]); case 62: return (*fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28], x[29],x[30],x[31],x[32],x[33],x[34],x[35], x[36],x[37],x[38],x[39],x[40],x[41],x[42], x[43],x[44],x[45],x[46],x[47],x[48],x[49], x[50],x[51],x[52],x[53],x[54],x[55],x[56], x[57],x[58],x[59],x[60],x[61]); case 63: return (*fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28], x[29],x[30],x[31],x[32],x[33],x[34],x[35], x[36],x[37],x[38],x[39],x[40],x[41],x[42], x[43],x[44],x[45],x[46],x[47],x[48],x[49], x[50],x[51],x[52],x[53],x[54],x[55],x[56], x[57],x[58],x[59],x[60],x[61],x[62]); case 64: return (*fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7], x[8],x[9],x[10],x[11],x[12],x[13],x[14], x[15],x[16],x[17],x[18],x[19],x[20],x[21], x[22],x[23],x[24],x[25],x[26],x[27],x[28], x[29],x[30],x[31],x[32],x[33],x[34],x[35], x[36],x[37],x[38],x[39],x[40],x[41],x[42], x[43],x[44],x[45],x[46],x[47],x[48],x[49], x[50],x[51],x[52],x[53],x[54],x[55],x[56], x[57],x[58],x[59],x[60],x[61],x[62],x[63]); default: FEprogram_error_noreturn("Too many arguments", 0); } } #endif ecl-16.1.2/src/c/arch/000077500000000000000000000000001266352375300143065ustar00rootroot00000000000000ecl-16.1.2/src/c/arch/apply_x86.d000066400000000000000000000106141266352375300163070ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* apply.c -- Interface to C call mechanism. */ /* Copyright (c) 2008, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include cl_object APPLY(cl_narg n, cl_objectfn fn, cl_object *x) { cl_object output; asm volatile ( "movl 4(%%ebp),%%edx\n\t" /* Create a fake frame for debugger */ "pushl %%edx\n\t" "pushl %%ebp\n\t" "movl %%ecx, %%edx\n\t" "cmpl $63, %%ecx\n\t" /* Copy at most 63 arguments onto the stack */ "jle FOO1\n\t" "movl $63, %%ecx\n\t" "FOO1:\n\t" /* Here we compute the new address of the stack pointer */ "movl %%esp, %%ebp\n\t" /* using the formula ESP = (ESP - ECX*4 - 4) & -16 */ "negl %%ecx\n\t" /* which rounds ESP making it a multiple of 16 bytes. */ "leal -4(%%esp,%%ecx,4), %%esp\n\t" "andl $-16, %%esp\n\t" "movl %%edx, (%%esp)\n\t" /* Then ESP[0] is the number of arguments */ "negl %%ecx\n\t" "leal 4(%%esp), %%edi\n\t" /* and the other arguments are copied from ESP[4] on */ "rep\n\t" "movsl\n\t" "call *%%eax\n\t" /* At this point the stack must be aligned */ "movl %%ebp, %%esp\n\t" "popl %%ebp\n\t" "popl %%edx\n\t" : "=a" (output) : "c" (n), "a" (fn), "S" (x) : "%edx", "%edi"); return output; } cl_object APPLY_fixed(cl_narg n, cl_object (*fn)(), cl_object *x) { cl_object output; asm volatile ( "movl 4(%%ebp),%%edx\n\t" /* Create a fake frame for debugger */ "pushl %%edx\n\t" "pushl %%ebp\n\t" "movl %%ecx, %%edx\n\t" /* Copy at most 63 arguments onto the stack */ "cmpl $63, %%ecx\n\t" "jle FOO2\n\t" "movl $63, %%ecx\n" "FOO2:\n\t" /* Here we compute the new address of the stack pointer */ "movl %%esp, %%ebp\n\t" /* using the formula ESP = (ESP - ECX*4) & -16 */ "negl %%ecx\n\t" /* which rounds ESP making it a multiple of 16 bytes. */ "leal (%%esp,%%ecx,4), %%esp\n\t" "andl $-16, %%esp\n\t" "negl %%ecx\n\t" "movl %%esp, %%edi\n\t" /* then the arguments are copied from ESP[0] on */ "rep\n\t" "movsl\n\t" "call *%%eax\n\t" /* At this point the stack must be aligned */ "movl %%ebp, %%esp\n\t" "popl %%ebp\n\t" "popl %%edx\n\t" : "=a" (output) : "c" (n), "a" (fn), "S" (x) : "%edx", "%edi"); return output; } cl_object APPLY_closure(cl_narg n, cl_objectfn fn, cl_object cl, cl_object *x) { cl_object output; asm volatile ( "movl 4(%%ebp),%%edx\n\t" /* Create a fake frame for debugger */ "pushl %%edx\n\t" "pushl %%ebp\n\t" "movl %%ecx, %%edx\n\t" "cmpl $63, %%ecx\n\t" /* Copy at most 63 arguments onto the stack */ "jle FOO3\n\t" "movl $63, %%ecx\n\t" "FOO3:\n\t" /* Here we compute the new address of the stack pointer */ "movl %%esp, %%ebp\n\t" /* using the formula ESP = (ESP - ECX*4 - 8) & -16 */ "negl %%ecx\n\t" /* which rounds ESP making it a multiple of 16 bytes. */ "leal -8(%%esp,%%ecx,4), %%esp\n\t" "andl $-16, %%esp\n\t" "movl %%edx, (%%esp)\n\t" /* Then ESP[0] is the number of arguments */ "movl %%edi, 4(%%esp)\n\t" /* ESP[4] is the closure environment */ "negl %%ecx\n\t" "leal 8(%%esp), %%edi\n\t" /* and the other arguments are copied from ESP[8] on */ "rep\n\t" "movsl\n\t" "call *%%eax\n\t" /* At this point the stack must be aligned */ "movl %%ebp, %%esp\n\t" "popl %%ebp\n\t" "popl %%edx\n\t" : "=a" (output) : "c" (n), "a" (fn), "S" (x), "D" (cl) : "%edx"); return output; } ecl-16.1.2/src/c/arch/ffi_ppc32.d000066400000000000000000000201241266352375300162250ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* ffi_x86.c -- Nonportable component of the FFI */ /* Copyright (c) 2005, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #include #include #error "This file is a placeholder for current development" /* * Calling conventions for OS X under PowerPC/32bit architecture. The rules are * as follows: * * - Registers GPR3-GPR10 are used to pass 32-bit arguments. This includes * integers and composed data structures which fit in the registers. * - Registers FPR1-FPR13 are used to pass float and double arguments. * - For each argument passed in a register, the same amount of memory is * reserved in the stack. * - When the amount of registers is exhausted, the remaining arguments are * passed in the stack. * - There is a difference between functions whose signature is known and those * whose is not. In the second case, when passing float/double arguments, * they are passed redundantly using a GPR, a FPR and the stack. In the * former case, only the FPR or the stack is used. * - Since we do not allow functions with varargs (i.e "..." in C parlance), we * do not care about the last case. * * Since we do not allow passing or receiving structures, we need not care * about it and the only rule is: * * - Returns arguments <= 32 bits are stored in GPR3 * - Returns arguments <= 64 bits are shared between GPR3 and GPR4, for high * and low bits, respectively. * - Floating point values are returned in FPR1. * * This information appears in "Mac OS X ABI Function Call Guide", from Apple * Developer's Documentation (April 2006). */ #define MAX_INT_REGISTERS 8 #define MAX_FP_REGISTERS 13 struct ecl_fficall_reg { long int registers[MAX_INT_REGISTERS]; int int_registers_size; double fp_registers[MAX_FP_REGISTERS]; int fp_registers_size; }; struct ecl_fficall_reg * ecl_fficall_prepare_extra(struct ecl_fficall_reg *registers) { if (registers == 0) { registers = (struct ecl_fficall_reg *)cl_alloc_atomic(sizeof(*registers)); } registers->int_registers_size = 0; registers->fp_registers_size = 0; } void ecl_fficall_push_arg(union ecl_ffi_values *data, enum ecl_ffi_tag type) { long i; struct ecl_fficall *fficall = cl_env.fficall; struct ecl_fficall_reg *registers = cl_env.fficall->registers; switch (type) { case ECL_FFI_CHAR: i = data->c; goto INT; case ECL_FFI_UNSIGNED_CHAR: i = data->uc; goto INT; case ECL_FFI_BYTE: i = data->b; goto INT; case ECL_FFI_UNSIGNED_BYTE: i = data->ub; goto INT; case ECL_FFI_SHORT: i = data->s; goto INT; case ECL_FFI_UNSIGNED_SHORT: i = data->us; goto INT; case ECL_FFI_INT: i = data->i; goto INT; case ECL_FFI_UNSIGNED_INT: i = data->ui; goto INT; case ECL_FFI_LONG: case ECL_FFI_UNSIGNED_LONG: case ECL_FFI_POINTER_VOID: case ECL_FFI_CSTRING: case ECL_FFI_OBJECT: i = data->l; INT: if (registers->int_registers_size < MAX_INT_REGISTERS) { registers->registers[registers->int_registers_size++] = i; } ecl_fficall_align(sizeof(long)); ecl_fficall_push_bytes(&i, sizeof(long)); break; case ECL_FFI_DOUBLE: if (registers->fp_registers_size < MAX_FP_REGISTERS) { registers->fp_registers[registers->fp_registers_size++] = data->d; registers->int_registers_size += 2; } ecl_fficall_align(sizeof(long)); ecl_fficall_push_bytes(&data->d, sizeof(double), sizeof(long)); break; case ECL_FFI_FLOAT: if (registers->fp_registers_size < MAX_FP_REGISTERS) { registers->fp_registers[registers->fp_registers_size++] = data->f; registers->int_registers_size++; } ecl_fficall_align(sizeof(long)); ecl_fficall_push_bytes(&data->f, sizeof(float), sizeof(long)); break; case ECL_FFI_VOID: FEerror("VOID is not a valid argument type for a C function", 0); } } static void ecl_fficall_do_execute(cl_index buf_size, void *stack, void *gpr, void *gpfr, void *f) { } void ecl_fficall_execute(void *_f_ptr, struct ecl_fficall *fficall, enum ecl_ffi_tag return_type) { struct ecl_fficall_reg *registers = fficall->registers; long bufsize = fficall->buffer_size; char* buf = fficall->buffer; asm volatile ( "mr r5,%[bufsize]\n\t" /* r5 = size of stack */ "mr r6,%[buf]\n\t" /* r6 = origin of stack data */ "mr r17,%[registers]\n\t" /* r17 = origin of integer registers */ "mr r16,%[fp_registers]\n\t"/* r16 = origin of fp registers */ "mr r15,%[fptr]\n\t" /* r15 = _f_ptr */ "mr r29, r1\n\t" /* r29 saves r1 */ "subf r13,r5,r1\n\t" "stwu r13,-80(r13)\n\t" /* r13 <- r1 - r5 - 80 */ "mflr r0\n\t" "stw r0,8(r1)\n\t" "mr r1,r13\n\t" /* r1 <- r13 */ "stwu r14,24(r1)\n\t" /* r14 <- begin of parameters */ "cmpwi cr0,r5,0\n\t" /* copy r5 bytes from (r6) to (r14) */ "ble cr0,L3\n\t" "mtctr r5\n" "LX: lbz r0,0(r6)\n\t" "addi r6,r6,1\n\t" "stb r0,0(r14)\n\t" "addi r14,r14,1\n" "L3: lfd f1, 0(r16)\n\t" /* load fp registers from (r16) */ "lfd f2, 8(r16)\n\t" "lfd f3, 16(r16)\n\t" "lfd f4, 24(r16)\n\t" "lfd f5, 32(r16)\n\t" "lfd f6, 40(r16)\n\t" "lfd f7, 48(r16)\n\t" "lfd f8, 56(r16)\n\t" "lfd f9, 64(r16)\n\t" "lfd f10, 72(r16)\n\t" "lfd f11, 80(r16)\n\t" "lfd f12, 88(r16)\n\t" "lfd f13, 96(r16)\n\t" "lwz r6, 16(r17)\n\t" /* load int registers from (r17) */ "lwz r7, 20(r17)\n\t" "lwz r8, 24(r17)\n\t" "lwz r9, 28(r17)\n\t" "lwz r10, 32(r17)\n\t" "lwz r5, 8(r17)\n\t" "lwz r4, 4(r17)\n\t" "lwz r3, 0(r17)\n\t" "mtctr r15\n\t" /* call the function stored in r15 */ "bctrl \n\t" "mr r1,r29\n\t" /* restore stack and return pointer */ "lwz r0,8(r1)\n\t" "mtlr r0\n\t" "stw r3,0(r17)\n\t" /* store function's output */ "stw r4,4(r17)\n\t" "stfd f1,0(r16)\n\t" :: [bufsize] "r" (bufsize), [buf] "r" (buf), [registers] "r" (registers->registers), [fp_registers] "r" (registers->fp_registers), [fptr] "r" (_f_ptr) : "r5","r6","r17","r16","r29","r13","r14"); void *data = registers->registers; if (return_type <= ECL_FFI_UNSIGNED_LONG) { fficall->output.i = *((unsigned long *)data); } else if (return_type == ECL_FFI_POINTER_VOID) { fficall->output.pv = *((void **)data); } else if (return_type == ECL_FFI_CSTRING) { fficall->output.pc = *((char *)data); } else if (return_type == ECL_FFI_OBJECT) { fficall->output.o = *((cl_object *)data); } else if (return_type == ECL_FFI_FLOAT) { fficall->output.f = registers->fp_registers[0]; } else if (return_type == ECL_FFI_DOUBLE) { fficall->output.d = registers->fp_registers[0]; } } void* ecl_dynamic_callback_make(cl_object data, enum ecl_ffi_calling_convention cc_type) { exit(0); } ecl-16.1.2/src/c/arch/ffi_x86.d000066400000000000000000000260261266352375300157320ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* ffi_x86.c -- Nonportable component of the FFI */ /* Copyright (c) 2005, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #include #include #if !defined(HAVE_LIBFFI) struct ecl_fficall_reg * ecl_fficall_prepare_extra(struct ecl_fficall_reg *registers) { /* No need to prepare registers */ return 0; } void ecl_fficall_push_arg(union ecl_ffi_values *data, enum ecl_ffi_tag type) { int i; switch (type) { case ECL_FFI_CHAR: i = data->c; goto INT_ECL; case ECL_FFI_UNSIGNED_CHAR: i = data->uc; goto INT_ECL; case ECL_FFI_BYTE: i = data->b; goto INT_ECL; case ECL_FFI_UNSIGNED_BYTE: i = data->ub; goto INT_ECL; case ECL_FFI_SHORT: i = data->s; goto INT_ECL; case ECL_FFI_UNSIGNED_SHORT: i = data->us; goto INT_ECL; #ifdef ecl_uint8_t case ECL_FFI_INT8_T: i = data->i8; goto INT_ECL; case ECL_FFI_UINT8_T: i = data->u8; goto INT_ECL; #endif #ifdef ecl_uint16_t case ECL_FFI_INT16_T: i = data->i16; goto INT_ECL; case ECL_FFI_UINT16_T: i = data->u16; goto INT_ECL; #endif case ECL_FFI_INT: case ECL_FFI_LONG: case ECL_FFI_UNSIGNED_INT: case ECL_FFI_UNSIGNED_LONG: #ifdef ecl_uint32_t case ECL_FFI_INT32_T: case ECL_FFI_UINT32_T: #endif case ECL_FFI_POINTER_VOID: case ECL_FFI_CSTRING: case ECL_FFI_OBJECT: i = data->i; INT_ECL: ecl_fficall_align(sizeof(int)); ecl_fficall_push_int(i); break; case ECL_FFI_DOUBLE: ecl_fficall_align(sizeof(int)); ecl_fficall_push_bytes(&data->d, sizeof(double)); break; case ECL_FFI_FLOAT: ecl_fficall_align(sizeof(int)); ecl_fficall_push_bytes(&data->f, sizeof(float)); break; #ifdef ecl_uint64_t case ECL_FFI_UINT64_T: case ECL_FFI_INT64_T: ecl_fficall_align(sizeof(ecl_uint64_t)); ecl_fficall_push_bytes(&data->ull, sizeof(ecl_uint64_t)); break; #endif #ifdef ecl_long_long_t case ECL_FFI_UNSIGNED_LONG_LONG: case ECL_FFI_LONG_LONG: ecl_fficall_align(sizeof(unsigned long)); ecl_fficall_push_bytes(&data->ull, sizeof(unsigned long long)); break; #endif case ECL_FFI_VOID: FEerror("VOID is not a valid argument type for a C function", 0); } } void ecl_fficall_execute(void *f_ptr, struct ecl_fficall *fficall, enum ecl_ffi_tag return_type) { int bufsize = fficall->buffer_size; char* buf = fficall->buffer; char* stack_p; #ifdef _MSC_VER __asm { mov stack_p,esp sub esp,bufsize mov esi,buf mov edi,esp mov ecx,bufsize rep movsb } #else asm volatile ( "movl %%esp, %0\n\t" "subl %1, %%esp\n\t" "movl %2, %%esi\n\t" "movl %%esp, %%edi\n\t" "rep\n\t" "movsb\n\t" : "=a" (stack_p) : "c" (bufsize), "d" (buf) : "%edi", "%esi"); #endif if (return_type <= ECL_FFI_UNSIGNED_LONG) { fficall->output.i = ((int (*)())f_ptr)(); } else if (return_type == ECL_FFI_POINTER_VOID) { fficall->output.pv = ((void * (*)())f_ptr)(); } else if (return_type == ECL_FFI_CSTRING) { fficall->output.pc = ((char * (*)())f_ptr)(); } else if (return_type == ECL_FFI_OBJECT) { fficall->output.o = ((cl_object (*)())f_ptr)(); } else if (return_type == ECL_FFI_FLOAT) { fficall->output.f = ((float (*)())f_ptr)(); } else if (return_type == ECL_FFI_DOUBLE) { fficall->output.d = ((double (*)())f_ptr)(); } #ifdef ecl_uint8_t else if (return_type == ECL_FFI_INT8_T) { fficall->output.i8 = ((ecl_int8_t (*)())f_ptr)(); } else if (return_type == ECL_FFI_UINT16_T) { fficall->output.u8 = ((ecl_uint8_t (*)())f_ptr)(); } #endif #ifdef ecl_uint16_t else if (return_type == ECL_FFI_INT16_T) { fficall->output.i16 = ((ecl_int16_t (*)())f_ptr)(); } else if (return_type == ECL_FFI_UINT16_T) { fficall->output.u16 = ((ecl_uint16_t (*)())f_ptr)(); } #endif #ifdef ecl_uint32_t else if (return_type == ECL_FFI_INT32_T) { fficall->output.i32 = ((ecl_int32_t (*)())f_ptr)(); } else if (return_type == ECL_FFI_UINT32_T) { fficall->output.u32 = ((ecl_uint32_t (*)())f_ptr)(); } #endif #ifdef ecl_uint64_t else if (return_type == ECL_FFI_INT64_T) { fficall->output.i64 = ((ecl_int64_t (*)())f_ptr)(); } else if (return_type == ECL_FFI_UINT32_T) { fficall->output.u64 = ((ecl_uint64_t (*)())f_ptr)(); } #endif #ifdef ecl_long_long_t else if (return_type == ECL_FFI_LONG_LONG) { fficall->output.ll = ((ecl_long_long_t (*)())f_ptr)(); } else if (return_type == ECL_FFI_UNSIGNED_LONG_LONG) { fficall->output.ull = ((ecl_ulong_long_t (*)())f_ptr)(); } #endif else { ((void (*)())f_ptr)(); } #ifdef _MSC_VER __asm mov esp,stack_p #else asm volatile ("mov %0,%%esp" :: "a" (stack_p)); #endif } static void ecl_dynamic_callback_execute(cl_object cbk_info, char *arg_buffer) { cl_object fun, rtype, argtypes; cl_object result; cl_index i, size; union ecl_ffi_values output; enum ecl_ffi_tag tag; cl_env_ptr env = ecl_process_env(); ECL_BUILD_STACK_FRAME(env, frame, aux); fun = CAR(cbk_info); rtype = CADR(cbk_info); argtypes = CADDR(cbk_info); arg_buffer += 4; /* Skip return address */ for (i=0; !ecl_endp(argtypes); argtypes = CDR(argtypes), i++) { tag = ecl_foreign_type_code(CAR(argtypes)); size = ecl_fixnum(si_size_of_foreign_elt_type(CAR(argtypes))); result = ecl_foreign_data_ref_elt(arg_buffer, tag); ecl_stack_frame_push(frame,result); { int mask = 3; int sp = (size + mask) & ~mask; arg_buffer += (sp); } } result = ecl_apply_from_stack_frame(frame, fun); ecl_stack_frame_close(frame); tag = ecl_foreign_type_code(rtype); memset(&output, 0, sizeof(output)); ecl_foreign_data_set_elt(&output, tag, result); switch (tag) { case ECL_FFI_CHAR: i = output.c; goto INT_ECL; case ECL_FFI_UNSIGNED_CHAR: i = output.uc; goto INT_ECL; case ECL_FFI_BYTE: i = output.b; goto INT_ECL; case ECL_FFI_UNSIGNED_BYTE: i = output.ub; goto INT_ECL; #ifdef ecl_uint8_t case ECL_FFI_INT8_T: i = output.i8; goto INT_ECL; case ECL_FFI_UINT8_T: i = output.u8; goto INT_ECL; #endif #ifdef ecl_uint16_t case ECL_FFI_INT16_T: #endif case ECL_FFI_SHORT: i = output.s; goto INT_ECL; #ifdef ecl_uint16_t case ECL_FFI_UINT16_T: #endif case ECL_FFI_UNSIGNED_SHORT: i = output.us; goto INT_ECL; case ECL_FFI_POINTER_VOID: case ECL_FFI_OBJECT: case ECL_FFI_CSTRING: case ECL_FFI_INT: case ECL_FFI_UNSIGNED_INT: #ifdef ecl_uint32_t case ECL_FFI_INT32_T: case ECL_FFI_UINT32_T: #endif case ECL_FFI_LONG: case ECL_FFI_UNSIGNED_LONG: i = output.i; INT_ECL: #ifdef _MSC_VER __asm mov eax,i #else { register int eax asm("eax"); eax = i; } #endif return; #if defined(ecl_long_long_t) || defined(ecl_uint64_t) # ifdef ecl_long_long_t case ECL_FFI_LONG_LONG: case ECL_FFI_UNSIGNED_LONG_LONG: # endif # ifdef ecl_uint64_t case ECL_FFI_INT64_T: case ECL_FFI_UINT64_T: # endif # ifdef _MSC_VER __asm mov eax,output.l2[0] __asm mov edx,output.l2[1] # else { register int eax asm("eax"); register int edx asm("edx"); eax = output.l2[0]; edx = output.l2[1]; } # endif return; #endif /* ecl_long_long_t */ case ECL_FFI_DOUBLE: { #ifdef _MSC_VER __asm fld output.d #else { asm("fldl (%0)" :: "a" (&output.d)); } #endif return; } case ECL_FFI_FLOAT: { #ifdef _MSC_VER __asm fld output.f #else { asm("flds (%0)" :: "a" (&output.f)); } #endif return; } case ECL_FFI_VOID: return; } } void* ecl_dynamic_callback_make(cl_object data, enum ecl_ffi_calling_convention cc_type) { /* * push %esp 54 * pushl 68 * call ecl_dynamic_callback_call E8 * [ Here we could use also lea 4(%esp), %esp, but %ecx seems to be free ] * pop %ecx 59 * pop %ecx 59 * ret c3 * nop 90 * nop 90 */ char *buf = (char*)ecl_alloc_atomic_align(sizeof(char)*16, 4); *(char*) (buf+0) = 0x54; *(char*) (buf+1) = 0x68; *(long*) (buf+2) = (long)data; *(unsigned char*) (buf+6) = 0xE8; *(long*) (buf+7) = (long)ecl_dynamic_callback_execute - (long)(buf+11); *(char*) (buf+11) = 0x59; *(char*) (buf+12) = 0x59; if (cc_type == ECL_FFI_CC_CDECL) { *(unsigned char*) (buf+13) = 0xc3; *(unsigned short*)(buf+14) = 0x9090; } else { cl_object arg_types = CADDR(data); int byte_size = 0; int mask = 3; while (CONSP(arg_types)) { int sz = ecl_fixnum(si_size_of_foreign_elt_type(CAR(arg_types))); byte_size += ((sz+mask)&(~mask)); arg_types = CDR(arg_types); } *(unsigned char*) (buf+13) = 0xc2; *(unsigned short*)(buf+14) = (unsigned short)byte_size; } return buf; } #endif ecl-16.1.2/src/c/arch/ffi_x86_64.d000066400000000000000000000320171266352375300162400ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* ffi_x86.c -- Nonportable component of the FFI */ /* Copyright (c) 2005, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #include #include #if !defined(HAVE_LIBFFI) #define MAX_INT_REGISTERS 6 #define MAX_FP_REGISTERS 8 struct ecl_fficall_reg { long int_registers[MAX_INT_REGISTERS]; int int_registers_size; double fp_registers[MAX_FP_REGISTERS]; int fp_registers_size; }; struct ecl_fficall_reg * ecl_fficall_prepare_extra(struct ecl_fficall_reg *registers) { if (registers == 0) { registers = ecl_alloc_atomic_align(sizeof(*registers), sizeof(long)); } registers->int_registers_size = 0; registers->fp_registers_size = 0; return registers; } void ecl_fficall_push_arg(union ecl_ffi_values *data, enum ecl_ffi_tag type) { long i; struct ecl_fficall *fficall = cl_env.fficall; struct ecl_fficall_reg *registers = fficall->registers; switch (type) { case ECL_FFI_CHAR: i = data->c; goto INT; case ECL_FFI_UNSIGNED_CHAR: i = data->uc; goto INT; #ifdef ecl_uint8_t case ECL_FFI_INT8_T: i = data->i8; goto INT; case ECL_FFI_UINT8_T: i = data->u8; goto INT; #endif case ECL_FFI_BYTE: i = data->b; goto INT; case ECL_FFI_UNSIGNED_BYTE: i = data->ub; goto INT; #ifdef ecl_uint16_t case ECL_FFI_INT16_T: i = data->i16; goto INT; case ECL_FFI_UINT16_T: i = data->u16; goto INT; #endif case ECL_FFI_SHORT: i = data->s; goto INT; case ECL_FFI_UNSIGNED_SHORT: i = data->us; goto INT; #ifdef ecl_uint32_t case ECL_FFI_INT32_T: i = data->i32; goto INT; case ECL_FFI_UINT32_T: i = data->u32; goto INT; #endif case ECL_FFI_INT: i = data->i; goto INT; case ECL_FFI_UNSIGNED_INT: i = data->ui; goto INT; case ECL_FFI_LONG: case ECL_FFI_UNSIGNED_LONG: #ifdef ecl_uint64_t case ECL_FFI_INT64_T: case ECL_FFI_UINT64_T: #endif case ECL_FFI_POINTER_VOID: case ECL_FFI_CSTRING: case ECL_FFI_OBJECT: i = data->l; INT: if (registers->int_registers_size < MAX_INT_REGISTERS) { registers->int_registers[registers->int_registers_size++] = i; } else { ecl_fficall_align(sizeof(long)); ecl_fficall_push_bytes(&i, sizeof(long)); } break; case ECL_FFI_DOUBLE: if (registers->fp_registers_size < MAX_FP_REGISTERS) { registers->fp_registers[registers->fp_registers_size++] = data->d; } else { ecl_fficall_align(sizeof(long)); ecl_fficall_push_bytes(&data->d, sizeof(double)); } break; case ECL_FFI_FLOAT: if (registers->fp_registers_size < MAX_FP_REGISTERS) { memset(®isters->fp_registers[registers->fp_registers_size], 0, sizeof(double)); (*(float*)(®isters->fp_registers[registers->fp_registers_size++])) = (float)data->f; } else { i = 0; ecl_fficall_align(sizeof(long)); ecl_fficall_push_bytes(&data->f, sizeof(float)); ecl_fficall_push_bytes(&i, sizeof(float)); } break; case ECL_FFI_VOID: FEerror("VOID is not a valid argument type for a C function", 0); } } void ecl_fficall_execute(void *_f_ptr, struct ecl_fficall *fficall, enum ecl_ffi_tag return_type) { struct ecl_fficall_reg *registers = fficall->registers; long bufsize = fficall->buffer_size; char* buf = fficall->buffer; char* stack_p; register void* f_ptr asm("r10"); ecl_fficall_align(16); bufsize = fficall->buffer_size; f_ptr = _f_ptr; asm volatile ( "mov %%rsp, %0\n\t" "sub %1, %%rsp\n\t" "mov %2, %%rsi\n\t" "mov %%rsp, %%rdi\n\t" "rep\n\t" "movsb\n\t" : "=a" (stack_p) : "c" (bufsize), "d" (buf) : "%rdi", "%rsi"); asm volatile ( "mov (%%rax), %%rdi\n\t" "mov 0x08(%%rax), %%rsi\n\t" "mov 0x10(%%rax), %%rdx\n\t" "mov 0x18(%%rax), %%rcx\n\t" "mov 0x20(%%rax), %%r8\n\t" "mov 0x28(%%rax), %%r9\n\t" :: "a" (registers->int_registers)); asm volatile ( "movsd (%%rax), %%xmm0\n\t" "movsd 0x08(%%rax), %%xmm1\n\t" "movsd 0x10(%%rax), %%xmm2\n\t" "movsd 0x18(%%rax), %%xmm3\n\t" "movsd 0x20(%%rax), %%xmm4\n\t" "movsd 0x28(%%rax), %%xmm5\n\t" "movsd 0x30(%%rax), %%xmm6\n\t" "movsd 0x38(%%rax), %%xmm7\n\t" :: "a" (registers->fp_registers)); if (return_type <= ECL_FFI_UNSIGNED_LONG) { fficall->output.ul = ((unsigned long (*)())f_ptr)(); } else if (return_type == ECL_FFI_POINTER_VOID) { fficall->output.pv = ((void * (*)())f_ptr)(); } else if (return_type == ECL_FFI_CSTRING) { fficall->output.pc = ((char * (*)())f_ptr)(); } else if (return_type == ECL_FFI_OBJECT) { fficall->output.o = ((cl_object (*)())f_ptr)(); } else if (return_type == ECL_FFI_FLOAT) { fficall->output.f = ((float (*)())f_ptr)(); } else if (return_type == ECL_FFI_DOUBLE) { fficall->output.d = ((double (*)())f_ptr)(); } #ifdef ecl_uint8_t else if (return_type == ECL_FFI_INT8_T) { fficall->output.i8 = ((ecl_int8_t (*)())f_ptr)(); } else if (return_type == ECL_FFI_UINT16_T) { fficall->output.u8 = ((ecl_uint8_t (*)())f_ptr)(); } #endif #ifdef ecl_uint16_t else if (return_type == ECL_FFI_INT16_T) { fficall->output.i16 = ((ecl_int16_t (*)())f_ptr)(); } else if (return_type == ECL_FFI_UINT16_T) { fficall->output.u16 = ((ecl_uint16_t (*)())f_ptr)(); } #endif #ifdef ecl_uint32_t else if (return_type == ECL_FFI_INT32_T) { fficall->output.i32 = ((ecl_int32_t (*)())f_ptr)(); } else if (return_type == ECL_FFI_UINT32_T) { fficall->output.u32 = ((ecl_uint32_t (*)())f_ptr)(); } #endif #ifdef ecl_uint64_t else if (return_type == ECL_FFI_INT64_T) { fficall->output.i64 = ((ecl_int64_t (*)())f_ptr)(); } else if (return_type == ECL_FFI_UINT32_T) { fficall->output.u64 = ((ecl_uint64_t (*)())f_ptr)(); } #endif #ifdef ecl_long_long_t else if (return_type == ECL_FFI_LONG_LONG) { fficall->output.ll = ((ecl_long_long_t (*)())f_ptr)(); } else if (return_type == ECL_FFI_UNSIGNED_LONG_LONG) { fficall->output.ull = ((ecl_ulong_long_t (*)())f_ptr)(); } #endif else { ((void (*)())f_ptr)(); } asm volatile ("mov %0,%%rsp" :: "a" (stack_p)); } static void ecl_dynamic_callback_execute(long i1, long i2, long i3, long i4, long i5, long i6, double f1, double f2, double f3, double f4, double f5, double f6, double f7, double f8, cl_object cbk_info, char *arg_buffer) { cl_object fun, rtype, argtypes; cl_object result; cl_index i, size, i_reg_index, f_reg_index; union ecl_ffi_values output; enum ecl_ffi_tag tag; long i_reg[MAX_INT_REGISTERS]; double f_reg[MAX_FP_REGISTERS]; cl_env_ptr env = ecl_process_env(); ECL_BUILD_STACK_FRAME(env, frame, aux); fun = CAR(cbk_info); rtype = CADR(cbk_info); argtypes = CADDR(cbk_info); i_reg_index = f_reg_index = 0; i_reg[0] = i1; i_reg[1] = i2; i_reg[2] = i3; i_reg[3] = i4; i_reg[4] = i5; i_reg[5] = i6; f_reg[0] = f1; f_reg[1] = f2; f_reg[2] = f3; f_reg[3] = f4; f_reg[4] = f5; f_reg[5] = f6; f_reg[6] = f7; f_reg[7] = f8; arg_buffer += 2*sizeof(void*); /* Skip return address and base pointer */ for (i=0; !ecl_endp(argtypes); argtypes = CDR(argtypes), i++) { tag = ecl_foreign_type_code(CAR(argtypes)); size = ecl_fixnum(si_size_of_foreign_elt_type(CAR(argtypes))); if (tag <= ECL_FFI_OBJECT) { if (i_reg_index < MAX_INT_REGISTERS) result = ecl_foreign_data_ref_elt(&i_reg[i_reg_index++], tag); else goto ARG_FROM_STACK; } else if (tag <= ECL_FFI_DOUBLE) { if (f_reg_index < MAX_FP_REGISTERS) result = ecl_foreign_data_ref_elt(&f_reg[f_reg_index++], tag); else goto ARG_FROM_STACK; } else { ARG_FROM_STACK: result = ecl_foreign_data_ref_elt(arg_buffer, tag); { int mask = 7; int sp = (size + mask) & ~mask; arg_buffer += (sp); } } ecl_stack_frame_push(frame, result); } result = ecl_apply_from_stack_frame(frame, fun); ecl_stack_frame_close(frame); tag = ecl_foreign_type_code(rtype); memset(&output, 0, sizeof(output)); ecl_foreign_data_set_elt(&output, tag, result); switch (tag) { case ECL_FFI_CHAR: i = output.c; goto INT; case ECL_FFI_UNSIGNED_CHAR: i = output.uc; goto INT; case ECL_FFI_BYTE: i = output.b; goto INT; case ECL_FFI_UNSIGNED_BYTE: i = output.ub; goto INT; #ifdef ecl_uint8_t case ECL_FFI_INT8_T: i = output.i8; goto INT; case ECL_FFI_UINT8_T: i = output.u8; goto INT; #endif #ifdef ecl_uint16_t case ECL_FFI_INT16_T: i = output.i16; goto INT; case ECL_FFI_UINT16_T: i = output.u16; goto INT; #endif case ECL_FFI_SHORT: i = output.s; goto INT; case ECL_FFI_UNSIGNED_SHORT: i = output.us; goto INT; #ifdef ecl_uint32_t case ECL_FFI_INT32_T: i = output.i32; goto INT; case ECL_FFI_UINT32_T: i = output.u32; goto INT; #endif case ECL_FFI_POINTER_VOID: case ECL_FFI_OBJECT: case ECL_FFI_CSTRING: case ECL_FFI_INT: case ECL_FFI_UNSIGNED_INT: case ECL_FFI_LONG: case ECL_FFI_UNSIGNED_LONG: #ifdef ecl_uint64_t case ECL_FFI_INT64_T: case ECL_FFI_UINT64_T: #endif i = output.i; INT: { register long eax asm("rax"); eax = i; } return; case ECL_FFI_DOUBLE: { { asm("movsd (%0),%%xmm0" :: "a" (&output.d)); } return; } case ECL_FFI_FLOAT: { { asm("movss (%0),%%xmm0" :: "a" (&output.f)); } return; } case ECL_FFI_VOID: return; } } void* ecl_dynamic_callback_make(cl_object data, enum ecl_ffi_calling_convention cc_type) { /* * push %rbp 55 * push %rsp 54 * mov ,%rax 48 b8 * push %rax 50 * mov ,%rax 48 b8 * callq *%rax 48 ff d0 * pop %rcx 59 * pop %rcx 59 * pop %rbp 5d * ret c3 * nop 90 * nop 90 */ char *buf = (char*)ecl_alloc_atomic_align(sizeof(char)*32, 8); *(char*) (buf+0) = 0x55; *(char*) (buf+1) = 0x54; *(short*)(buf+2) = 0xb848; *(long*) (buf+4) = (long)data; *(char*) (buf+12) = 0x50; *(short*)(buf+13) = 0xb848; *(long*) (buf+15) = (long)ecl_dynamic_callback_execute; *(int*) (buf+23) = (int)0x00d0ff48; /* leading null byte is overwritten */ *(char*) (buf+26) = 0x59; *(char*) (buf+27) = 0x59; *(char*) (buf+28) = 0x5d; *(char*) (buf+29) = 0xc3; *(short*)(buf+30) = 0x9090; return buf; } #endif ecl-16.1.2/src/c/arch/fpe_none.c000066400000000000000000000021731266352375300162460ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* fpe_none.c -- Nonportable component of the floating point code (dummy) */ /* Copyright (c) 2005, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ /* * The ecl_detect_fpe() is a macro (or a function) that detects whether a * floating point exception has been produced in a recent time. Currently * it is of great importance in the x86 architecture because exceptions * are not signaled on the instruction that originates the problem, but on * the next FP instruction. However, we could conceivably write a more * complex code on architectures that do not signal FP exceptions by * checking the control word of the FPU and doing the dispatching ourselves * instead of using signal(). */ #define ecl_detect_fpe() (void)0 ecl-16.1.2/src/c/arch/fpe_x86.c000077500000000000000000000014451266352375300157400ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* fpe_x86.c -- Nonportable component of the floating point code */ /* Copyright (c) 2005, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ /* * See fpe_none.c for a description */ #ifdef _MSC_VER # ifdef _WIN64 # error "This file shouldn't have been included!" # else # define ecl_detect_fpe() __asm fwait # endif #endif #ifdef __GNUC__ #define ecl_detect_fpe() asm("fwait") #endif ecl-16.1.2/src/c/array.d000066400000000000000000001420231266352375300146560ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* array.c -- Array routines */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #include #include #define ECL_DEFINE_AET_SIZE #include static const cl_object ecl_aet_name[] = { ECL_T, /* ecl_aet_object */ @'single-float', /* ecl_aet_sf */ @'double-float', /* ecl_aet_df */ @'bit', /* ecl_aet_bit: cannot be handled with this code */ @'ext::cl-fixnum', /* ecl_aet_fix */ @'ext::cl-index', /* ecl_aet_index */ @'ext::byte8', /* ecl_aet_b8 */ @'ext::integer8', /* ecl_aet_i8 */ #ifdef ecl_uint16_t @'ext::byte16', @'ext::integer16', #endif #ifdef ecl_uint32_t @'ext::byte32', @'ext::integer32', #endif #ifdef ecl_uint64_t @'ext::byte64', @'ext::integer64', #endif #ifdef ECL_UNICODE @'character', /* ecl_aet_ch */ #endif @'base-char' /* ecl_aet_bc */ }; static void FEbad_aet() ecl_attr_noreturn; static void FEbad_aet() { FEerror( "A routine from ECL got an object with a bad array element type.\n" "If you are running a standard copy of ECL, please report this bug.\n" "If you are embedding ECL into an application, please ensure you\n" "passed the right value to the array creation routines.\n",0); } static cl_index out_of_bounds_error(cl_index ndx, cl_object x) { cl_object type = cl_list(3, @'integer', ecl_make_fixnum(0), ecl_make_fixnum(x->array.dim)); FEwrong_type_argument(ecl_make_integer(ndx), type); } void FEwrong_dimensions(cl_object a, cl_index rank) { cl_object list = cl_make_list(3, ecl_make_fixnum(rank), @':initial-element', @'*'); cl_object type = cl_list(3, @'array', @'*', list); FEwrong_type_argument(type, a); } static ECL_INLINE cl_index checked_index(cl_object function, cl_object a, int which, cl_object index, cl_index nonincl_limit) { cl_index output; unlikely_if (!ECL_FIXNUMP(index) || ecl_fixnum_minusp(index)) FEwrong_index(function, a, which, index, nonincl_limit); output = ecl_fixnum(index); unlikely_if (output >= nonincl_limit) FEwrong_index(function, a, which, index, nonincl_limit); return output; } cl_index ecl_to_index(cl_object n) { switch (ecl_t_of(n)) { case t_fixnum: { cl_fixnum out = ecl_fixnum(n); if (out < 0 || out >= ECL_ARRAY_DIMENSION_LIMIT) FEtype_error_index(ECL_NIL, out); return out; } default: FEwrong_type_only_arg(@[coerce], n, @[fixnum]); } } cl_object cl_row_major_aref(cl_object x, cl_object indx) { cl_index j = ecl_to_size(indx); @(return ecl_aref(x, j)) } cl_object si_row_major_aset(cl_object x, cl_object indx, cl_object val) { cl_index j = ecl_to_size(indx); @(return ecl_aset(x, j, val)) } @(defun aref (x &rest indx) @ { cl_index i, j; cl_index r = narg - 1; switch (ecl_t_of(x)) { case t_array: if (r != x->array.rank) FEerror("Wrong number of indices.", 0); for (i = j = 0; i < r; i++) { cl_index s = checked_index(@[aref], x, i, ecl_va_arg(indx), x->array.dims[i]); j = j*(x->array.dims[i]) + s; } break; case t_vector: #ifdef ECL_UNICODE case t_string: #endif case t_base_string: case t_bitvector: if (r != 1) FEerror("Wrong number of indices.", 0); j = checked_index(@[aref], x, -1, ecl_va_arg(indx), x->vector.dim); break; default: FEwrong_type_nth_arg(@[aref], 1, x, @[array]); } @(return ecl_aref_unsafe(x, j)); } @) cl_object ecl_aref_unsafe(cl_object x, cl_index index) { switch (x->array.elttype) { case ecl_aet_object: return x->array.self.t[index]; case ecl_aet_bc: return ECL_CODE_CHAR(x->base_string.self[index]); #ifdef ECL_UNICODE case ecl_aet_ch: return ECL_CODE_CHAR(x->string.self[index]); #endif case ecl_aet_bit: index += x->vector.offset; if (x->vector.self.bit[index/CHAR_BIT] & (0200>>index%CHAR_BIT)) return(ecl_make_fixnum(1)); else return(ecl_make_fixnum(0)); case ecl_aet_fix: return ecl_make_integer(x->array.self.fix[index]); case ecl_aet_index: return ecl_make_unsigned_integer(x->array.self.index[index]); case ecl_aet_sf: return(ecl_make_single_float(x->array.self.sf[index])); case ecl_aet_df: return(ecl_make_double_float(x->array.self.df[index])); case ecl_aet_b8: return ecl_make_uint8_t(x->array.self.b8[index]); case ecl_aet_i8: return ecl_make_int8_t(x->array.self.i8[index]); #ifdef ecl_uint16_t case ecl_aet_b16: return ecl_make_uint16_t(x->array.self.b16[index]); case ecl_aet_i16: return ecl_make_int16_t(x->array.self.i16[index]); #endif #ifdef ecl_uint32_t case ecl_aet_b32: return ecl_make_uint32_t(x->array.self.b32[index]); case ecl_aet_i32: return ecl_make_int32_t(x->array.self.i32[index]); #endif #ifdef ecl_uint64_t case ecl_aet_b64: return ecl_make_uint64_t(x->array.self.b64[index]); case ecl_aet_i64: return ecl_make_int64_t(x->array.self.i64[index]); #endif default: FEbad_aet(); } } cl_object ecl_aref(cl_object x, cl_index index) { if (ecl_unlikely(!ECL_ARRAYP(x))) { FEwrong_type_nth_arg(@[aref], 1, x, @[array]); } if (ecl_unlikely(index >= x->array.dim)) { FEwrong_index(@[row-major-aref], x, -1, ecl_make_fixnum(index), x->array.dim); } return ecl_aref_unsafe(x, index); } cl_object ecl_aref1(cl_object x, cl_index index) { if (ecl_unlikely(!ECL_VECTORP(x))) { FEwrong_type_nth_arg(@[aref], 1, x, @[array]); } if (ecl_unlikely(index >= x->array.dim)) { FEwrong_index(@[aref], x, -1, ecl_make_fixnum(index), x->array.dim); } return ecl_aref_unsafe(x, index); } void * ecl_row_major_ptr(cl_object x, cl_index index, cl_index bytes) { cl_index elt_size, offset; cl_elttype elt_type; if (ecl_unlikely(!ECL_ARRAYP(x))) { FEwrong_type_nth_arg(@[aref], 1, x, @[array]); } elt_type = x->array.elttype; if (ecl_unlikely(elt_type == ecl_aet_bit || elt_type == ecl_aet_object)) FEerror("In ecl_row_major_ptr: Specialized array expected, element type ~S found.", 1,ecl_elttype_to_symbol(elt_type)); elt_size = ecl_aet_size[elt_type]; offset = index*elt_size; /* don't check bounds if bytes == 0 */ if (ecl_unlikely(bytes > 0 && offset + bytes > x->array.dim*elt_size)) { FEwrong_index(@[row-major-aref], x, -1, ecl_make_fixnum(index), x->array.dim); } return x->array.self.b8 + offset; } /* Internal function for setting array elements: (si:aset value array dim0 ... dimN) */ @(defun si::aset (x &rest dims) @ { cl_index i, j; cl_index r = narg - 2; cl_object v; switch (ecl_t_of(x)) { case t_array: if (ecl_unlikely(r != x->array.rank)) FEerror("Wrong number of indices.", 0); for (i = j = 0; i < r; i++) { cl_index s = checked_index(@[si::aset], x, i, ecl_va_arg(dims), x->array.dims[i]); j = j*(x->array.dims[i]) + s; } break; case t_vector: #ifdef ECL_UNICODE case t_string: #endif case t_base_string: case t_bitvector: if (ecl_unlikely(r != 1)) FEerror("Wrong number of indices.", 0); j = checked_index(@[si::aset], x, -1, ecl_va_arg(dims), x->vector.dim); break; default: FEwrong_type_nth_arg(@[si::aset], 1, x, @[array]); } v = ecl_va_arg(dims); @(return ecl_aset_unsafe(x, j, v)) } @) cl_object ecl_aset_unsafe(cl_object x, cl_index index, cl_object value) { switch (x->array.elttype) { case ecl_aet_object: x->array.self.t[index] = value; break; case ecl_aet_bc: /* INV: ecl_char_code() checks the type of `value' */ x->base_string.self[index] = ecl_char_code(value); break; #ifdef ECL_UNICODE case ecl_aet_ch: x->string.self[index] = ecl_char_code(value); break; #endif case ecl_aet_bit: { cl_fixnum i = ecl_to_bit(value); index += x->vector.offset; if (i == 0) x->vector.self.bit[index/CHAR_BIT] &= ~(0200>>index%CHAR_BIT); else x->vector.self.bit[index/CHAR_BIT] |= 0200>>index%CHAR_BIT; break; } case ecl_aet_fix: x->array.self.fix[index] = ecl_to_fix(value); break; case ecl_aet_index: x->array.self.index[index] = ecl_to_size(value); break; case ecl_aet_sf: x->array.self.sf[index] = ecl_to_float(value); break; case ecl_aet_df: x->array.self.df[index] = ecl_to_double(value); break; case ecl_aet_b8: x->array.self.b8[index] = ecl_to_uint8_t(value); break; case ecl_aet_i8: x->array.self.i8[index] = ecl_to_int8_t(value); break; #ifdef ecl_uint16_t case ecl_aet_b16: x->array.self.b16[index] = ecl_to_uint16_t(value); break; case ecl_aet_i16: x->array.self.i16[index] = ecl_to_int16_t(value); break; #endif #ifdef ecl_uint32_t case ecl_aet_b32: x->array.self.b32[index] = ecl_to_uint32_t(value); break; case ecl_aet_i32: x->array.self.i32[index] = ecl_to_int32_t(value); break; #endif #ifdef ecl_uint64_t case ecl_aet_b64: x->array.self.b64[index] = ecl_to_uint64_t(value); break; case ecl_aet_i64: x->array.self.i64[index] = ecl_to_int64_t(value); break; #endif } return(value); } cl_object ecl_aset(cl_object x, cl_index index, cl_object value) { if (ecl_unlikely(!ECL_ARRAYP(x))) { FEwrong_type_nth_arg(@[si::aset], 1, x, @[array]); } if (ecl_unlikely(index >= x->array.dim)) { out_of_bounds_error(index, x); } return ecl_aset_unsafe(x, index, value); } cl_object ecl_aset1(cl_object x, cl_index index, cl_object value) { if (ecl_unlikely(!ECL_VECTORP(x))) { FEwrong_type_nth_arg(@[si::aset], 1, x, @[array]); } if (ecl_unlikely(index >= x->array.dim)) { out_of_bounds_error(index, x); } return ecl_aset_unsafe(x, index, value); } /* Internal function for making arrays of more than one dimension: (si:make-pure-array dimension-list element-type adjustable displaced-to displaced-index-offset) */ cl_object si_make_pure_array(cl_object etype, cl_object dims, cl_object adj, cl_object fillp, cl_object displ, cl_object disploff) { cl_index r, s, i, j; cl_object x; if (ECL_FIXNUMP(dims)) { return si_make_vector(etype, dims, adj, fillp, displ, disploff); } else if (ecl_unlikely(!ECL_LISTP(dims))) { FEwrong_type_nth_arg(@[make-array], 1, dims, cl_list(3, @'or', @'list', @'fixnum')); } r = ecl_length(dims); if (ecl_unlikely(r >= ECL_ARRAY_RANK_LIMIT)) { FEerror("The array rank, ~R, is too large.", 1, ecl_make_fixnum(r)); } else if (r == 1) { return si_make_vector(etype, ECL_CONS_CAR(dims), adj, fillp, displ, disploff); } else if (ecl_unlikely(!Null(fillp))) { FEerror(":FILL-POINTER may not be specified for an array of rank ~D", 1, ecl_make_fixnum(r)); } x = ecl_alloc_object(t_array); x->array.displaced = ECL_NIL; x->array.self.t = NULL; /* for GC sake */ x->array.rank = r; x->array.elttype = (short)ecl_symbol_to_elttype(etype); x->array.flags = 0; /* no fill pointer, no adjustable */ x->array.dims = (cl_index *)ecl_alloc_atomic_align(sizeof(cl_index)*r, sizeof(cl_index)); for (i = 0, s = 1; i < r; i++, dims = ECL_CONS_CDR(dims)) { cl_object d = ECL_CONS_CAR(dims); if (ecl_unlikely(!ECL_FIXNUMP(d) || ecl_fixnum_minusp(d) || ecl_fixnum_greater(d, ecl_make_fixnum(ECL_ARRAY_DIMENSION_LIMIT)))) { cl_object type = ecl_make_integer_type(ecl_make_fixnum(0), ecl_make_fixnum(ECL_ARRAY_DIMENSION_LIMIT)); FEwrong_type_nth_arg(@[make-array], 1, d, type); } j = ecl_fixnum(d); s *= (x->array.dims[i] = j); if (ecl_unlikely(s > ECL_ARRAY_TOTAL_LIMIT)) { cl_object type = ecl_make_integer_type(ecl_make_fixnum(0), ecl_make_fixnum(ECL_ARRAY_TOTAL_LIMIT)); FEwrong_type_key_arg(@[make-array], @[array-total-size], ecl_make_fixnum(s), type); } } x->array.dim = s; if (adj != ECL_NIL) { x->array.flags |= ECL_FLAG_ADJUSTABLE; } if (Null(displ)) ecl_array_allocself(x); else ecl_displace(x, displ, disploff); @(return x); } /* Internal function for making vectors: (si:make-vector element-type dimension adjustable fill-pointer displaced-to displaced-index-offset) */ cl_object si_make_vector(cl_object etype, cl_object dim, cl_object adj, cl_object fillp, cl_object displ, cl_object disploff) { cl_index d, f; cl_object x; cl_elttype aet; AGAIN: aet = ecl_symbol_to_elttype(etype); if (ecl_unlikely(!ECL_FIXNUMP(dim) || ecl_fixnum_minusp(dim) || ecl_fixnum_greater(dim, ECL_ARRAY_DIMENSION_LIMIT))) { cl_object type = ecl_make_integer_type(ecl_make_fixnum(0), ecl_make_fixnum(ECL_ARRAY_DIMENSION_LIMIT)); FEwrong_type_nth_arg(@[make-array], 1, dim, type); } d = ecl_fixnum(dim); if (aet == ecl_aet_bc) { x = ecl_alloc_object(t_base_string); x->base_string.elttype = (short)aet; } else if (aet == ecl_aet_bit) { x = ecl_alloc_object(t_bitvector); x->vector.elttype = (short)aet; #ifdef ECL_UNICODE } else if (aet == ecl_aet_ch) { x = ecl_alloc_object(t_string); x->string.elttype = (short)aet; #endif } else { x = ecl_alloc_object(t_vector); x->vector.elttype = (short)aet; } x->vector.self.t = NULL; /* for GC sake */ x->vector.displaced = ECL_NIL; x->vector.dim = d; x->vector.flags = 0; if (adj != ECL_NIL) { x->vector.flags |= ECL_FLAG_ADJUSTABLE; } if (Null(fillp)) { f = d; } else if (fillp == ECL_T) { x->vector.flags |= ECL_FLAG_HAS_FILL_POINTER; f = d; } else if (ECL_FIXNUMP(fillp) && ecl_fixnum_geq(fillp,ecl_make_fixnum(0)) && ((f = ecl_fixnum(fillp)) <= d)) { x->vector.flags |= ECL_FLAG_HAS_FILL_POINTER; } else { fillp = ecl_type_error(@'make-array',"fill pointer",fillp, cl_list(3,@'or',cl_list(3,@'member',ECL_NIL,ECL_T), cl_list(3,@'integer',ecl_make_fixnum(0), dim))); goto AGAIN; } x->vector.fillp = f; if (Null(displ)) ecl_array_allocself(x); else ecl_displace(x, displ, disploff); @(return x) } cl_object * alloc_pointerfull_memory(cl_index l) { cl_object *p = ecl_alloc_align(sizeof(cl_object) * l, sizeof(cl_object)); cl_index i; for (i = 0; l--;) p[i++] = ECL_NIL; return p; } void ecl_array_allocself(cl_object x) { cl_elttype t = x->array.elttype; cl_index d = x->array.dim; switch (t) { /* assign self field only after it has been filled, for GC sake */ case ecl_aet_object: x->array.self.t = alloc_pointerfull_memory(d); return; #ifdef ECL_UNICODE case ecl_aet_ch: { ecl_character *elts; d *= sizeof(ecl_character); elts = (ecl_character *)ecl_alloc_atomic_align(d, sizeof(ecl_character)); x->string.self = elts; return; } #endif case ecl_aet_bc: { cl_index elt_size = 1; x->vector.self.bc = (ecl_base_char *)ecl_alloc_atomic(d+1); /* Null terminate the string */ x->vector.self.bc[d] = 0; break; } case ecl_aet_bit: d = (d + (CHAR_BIT-1)) / CHAR_BIT; x->vector.self.bit = (byte *)ecl_alloc_atomic(d); x->vector.offset = 0; break; default: { cl_index elt_size = ecl_aet_size[t]; d *= elt_size; x->vector.self.bc = (ecl_base_char *)ecl_alloc_atomic_align(d, elt_size); } } } cl_object ecl_alloc_simple_vector(cl_index l, cl_elttype aet) { cl_object x; switch (aet) { case ecl_aet_bc: x = ecl_alloc_compact_object(t_base_string, l+1); x->base_string.self = ECL_COMPACT_OBJECT_EXTRA(x); x->base_string.self[l] = 0; break; #ifdef ECL_UNICODE case ecl_aet_ch: { cl_index bytes = sizeof(ecl_character) * l; x = ecl_alloc_compact_object(t_string, bytes); x->string.self = ECL_COMPACT_OBJECT_EXTRA(x); } break; #endif case ecl_aet_bit: { cl_index bytes = (l + (CHAR_BIT-1))/CHAR_BIT; x = ecl_alloc_compact_object(t_bitvector, bytes); x->vector.self.bit = ECL_COMPACT_OBJECT_EXTRA(x); x->vector.offset = 0; } break; case ecl_aet_object: { x = ecl_alloc_object(t_vector); x->vector.self.t = alloc_pointerfull_memory(l); } break; default: x = ecl_alloc_compact_object(t_vector, l * ecl_aet_size[aet]); x->vector.self.bc = ECL_COMPACT_OBJECT_EXTRA(x); } x->base_string.elttype = aet; x->base_string.flags = 0; /* no fill pointer, not adjustable */ x->base_string.displaced = ECL_NIL; x->base_string.dim = x->base_string.fillp = l; return x; } cl_elttype ecl_symbol_to_elttype(cl_object x) { BEGIN: if (x == @'base-char') return(ecl_aet_bc); #ifdef ECL_UNICODE if (x == @'character') return(ecl_aet_ch); #endif else if (x == @'bit') return(ecl_aet_bit); else if (x == @'ext::cl-fixnum') return(ecl_aet_fix); else if (x == @'ext::cl-index') return(ecl_aet_index); else if (x == @'single-float' || x == @'short-float') return(ecl_aet_sf); else if (x == @'double-float') return(ecl_aet_df); else if (x == @'long-float') { #ifdef ECL_LONG_FLOAT return(ecl_aet_object); #else return(ecl_aet_df); #endif } else if (x == @'ext::byte8') return(ecl_aet_b8); else if (x == @'ext::integer8') return(ecl_aet_i8); #ifdef ecl_uint16_t else if (x == @'ext::byte16') return(ecl_aet_b16); else if (x == @'ext::integer16') return(ecl_aet_i16); #endif #ifdef ecl_uint32_t else if (x == @'ext::byte32') return(ecl_aet_b32); else if (x == @'ext::integer32') return(ecl_aet_i32); #endif #ifdef ecl_uint64_t else if (x == @'ext::byte64') return(ecl_aet_b64); else if (x == @'ext::integer64') return(ecl_aet_i64); #endif else if (x == @'t') return(ecl_aet_object); else if (x == ECL_NIL) { FEerror("ECL does not support arrays with element type NIL", 0); } x = cl_upgraded_array_element_type(1, x); goto BEGIN; } cl_object ecl_elttype_to_symbol(cl_elttype aet) { return ecl_aet_name[aet]; } cl_object si_array_element_type_byte_size(cl_object type) { cl_elttype aet = ECL_ARRAYP(type) ? type->array.elttype : ecl_symbol_to_elttype(type); cl_object size = ecl_make_fixnum(ecl_aet_size[aet]); if (aet == ecl_aet_bit) size = ecl_make_ratio(ecl_make_fixnum(1),ecl_make_fixnum(CHAR_BIT)); @(return size ecl_elttype_to_symbol(aet)) } static void * address_inc(void *address, cl_fixnum inc, cl_elttype elt_type) { union ecl_array_data aux; aux.t = address; switch (elt_type) { case ecl_aet_object: return aux.t + inc; case ecl_aet_fix: return aux.fix + inc; case ecl_aet_index: return aux.fix + inc; case ecl_aet_sf: return aux.sf + inc; case ecl_aet_bc: return aux.bc + inc; #ifdef ECL_UNICODE case ecl_aet_ch: return aux.c + inc; #endif case ecl_aet_df: return aux.df + inc; case ecl_aet_b8: case ecl_aet_i8: return aux.b8 + inc; #ifdef ecl_uint16_t case ecl_aet_b16: case ecl_aet_i16: return aux.b16 + inc; #endif #ifdef ecl_uint32_t case ecl_aet_b32: case ecl_aet_i32: return aux.b32 + inc; #endif #ifdef ecl_uint64_t case ecl_aet_b64: case ecl_aet_i64: return aux.b64 + inc; #endif default: FEbad_aet(); } } cl_object cl_array_element_type(cl_object a) { @(return ecl_elttype_to_symbol(ecl_array_elttype(a))) } /* Displace(from, to, offset) displaces the from-array to the to-array (the original array) by the specified offset. It changes the a_displaced field of both arrays. The field is a cons; the car of the from-array points to the to-array and the cdr of the to-array is a list of arrays displaced to the to-array, so the from-array is pushed to the cdr of the to-array's array.displaced. */ void ecl_displace(cl_object from, cl_object to, cl_object offset) { cl_index j; void *base; cl_elttype totype, fromtype; fromtype = from->array.elttype; if (ecl_unlikely(!ECL_FIXNUMP(offset) || ((j = ecl_fixnum(offset)) < 0))) { FEwrong_type_key_arg(@[adjust-array], @[:displaced-index-offset], offset, @[fixnum]); } if (ecl_t_of(to) == t_foreign) { if (fromtype == ecl_aet_bit || fromtype == ecl_aet_object) { FEerror("Cannot displace arrays with element type T or BIT onto foreign data",0); } base = to->foreign.data; from->array.displaced = to; } else { cl_fixnum maxdim; totype = to->array.elttype; if (totype != fromtype) FEerror("Cannot displace the array, " "because the element types don't match.", 0); maxdim = to->array.dim - from->array.dim; if (maxdim < 0) FEerror("Cannot displace the array, " "because the total size of the to-array" "is too small.", 0); if (j > maxdim) { cl_object type = ecl_make_integer_type(ecl_make_fixnum(0), ecl_make_fixnum(maxdim)); FEwrong_type_key_arg(@[adjust-array], @[:displaced-index-offset], offset, type); } from->array.displaced = ecl_list1(to); /* We only need to keep track of the arrays that displace to us * when this one array is adjustable */ if (ECL_ADJUSTABLE_ARRAY_P(to)) { cl_object track_list = to->array.displaced; if (Null(track_list)) to->array.displaced = track_list = ecl_list1(ECL_NIL); ECL_RPLACD(track_list, CONS(from, ECL_CONS_CDR(track_list))); } if (fromtype == ecl_aet_bit) { j += to->vector.offset; from->vector.offset = j%CHAR_BIT; from->vector.self.bit = to->vector.self.bit + j/CHAR_BIT; return; } base = to->array.self.t; } from->array.self.t = address_inc(base, j, fromtype); } cl_object si_array_raw_data(cl_object x) { cl_elttype et = ecl_array_elttype(x); cl_index total_size = x->vector.dim * ecl_aet_size[et]; cl_object output, to_array; uint8_t *data; if (et == ecl_aet_object) { FEerror("EXT:ARRAY-RAW-DATA can not get data " "from an array with element type T.", 0); } data = x->vector.self.b8; to_array = x->array.displaced; if (to_array == ECL_NIL || ((to_array = ECL_CONS_CAR(to_array)) == ECL_NIL)) { cl_index used_size = total_size; int flags = 0; if (ECL_ARRAY_HAS_FILL_POINTER_P(x)) { used_size = x->vector.fillp * ecl_aet_size[et]; flags = ECL_FLAG_HAS_FILL_POINTER; } output = ecl_alloc_object(t_vector); output->vector.elttype = ecl_aet_b8; output->vector.self.b8 = data; output->vector.dim = total_size; output->vector.fillp = used_size; output->vector.flags = flags; output->vector.displaced = ECL_NIL; } else { cl_index displ = data - to_array->vector.self.b8; cl_object fillp = ECL_NIL; if (ECL_ARRAY_HAS_FILL_POINTER_P(x)) { fillp = ecl_make_fixnum(x->vector.fillp * ecl_aet_size[et]); } output = si_make_vector(@'ext::byte8', ecl_make_fixnum(total_size), ECL_NIL, fillp, si_array_raw_data(to_array), ecl_make_fixnum(displ)); } @(return output) } cl_elttype ecl_array_elttype(cl_object x) { if (ecl_unlikely(!ECL_ARRAYP(x))) FEwrong_type_argument(@[array], x); return x->array.elttype; } cl_object cl_array_rank(cl_object a) { @(return ecl_make_fixnum(ecl_array_rank(a))) } cl_index ecl_array_rank(cl_object a) { switch (ecl_t_of(a)) { case t_array: return a->array.rank; #ifdef ECL_UNICODE case t_string: #endif case t_base_string: case t_vector: case t_bitvector: return 1; default: FEwrong_type_only_arg(@[array-dimension], a, @[array]); } } cl_object cl_array_dimension(cl_object a, cl_object index) { @(return ecl_make_fixnum(ecl_array_dimension(a, ecl_to_size(index)))) } cl_index ecl_array_dimension(cl_object a, cl_index index) { switch (ecl_t_of(a)) { case t_array: { if (ecl_unlikely(index > a->array.rank)) FEwrong_dimensions(a, index+1); return a->array.dims[index]; } #ifdef ECL_UNICODE case t_string: #endif case t_base_string: case t_vector: case t_bitvector: if (ecl_unlikely(index)) FEwrong_dimensions(a, index+1); return a->vector.dim; default: FEwrong_type_only_arg(@[array-dimension], a, @[array]); } } cl_object cl_array_total_size(cl_object a) { if (ecl_unlikely(!ECL_ARRAYP(a))) FEwrong_type_only_arg(@[array-total-size], a, @[array]); @(return ecl_make_fixnum(a->array.dim)) } cl_object cl_adjustable_array_p(cl_object a) { if (ecl_unlikely(!ECL_ARRAYP(a))) FEwrong_type_only_arg(@[adjustable-array-p], a, @[array]); @(return (ECL_ADJUSTABLE_ARRAY_P(a) ? ECL_T : ECL_NIL)) } /* Internal function for checking if an array is displaced. */ cl_object cl_array_displacement(cl_object a) { const cl_env_ptr the_env = ecl_process_env(); cl_object to_array; cl_index offset; if (ecl_unlikely(!ECL_ARRAYP(a))) FEwrong_type_only_arg(@[array-displacement], a, @[array]); to_array = a->array.displaced; if (Null(to_array)) { offset = 0; } else if (Null(to_array = CAR(a->array.displaced))) { offset = 0; } else { switch (a->array.elttype) { case ecl_aet_object: offset = a->array.self.t - to_array->array.self.t; break; case ecl_aet_bc: offset = a->array.self.bc - to_array->array.self.bc; break; #ifdef ECL_UNICODE case ecl_aet_ch: offset = a->array.self.c - to_array->array.self.c; break; #endif case ecl_aet_bit: offset = a->array.self.bit - to_array->array.self.bit; offset = offset * CHAR_BIT + a->array.offset - to_array->array.offset; break; case ecl_aet_fix: offset = a->array.self.fix - to_array->array.self.fix; break; case ecl_aet_index: offset = a->array.self.fix - to_array->array.self.fix; break; case ecl_aet_sf: offset = a->array.self.sf - to_array->array.self.sf; break; case ecl_aet_df: offset = a->array.self.df - to_array->array.self.df; break; case ecl_aet_b8: case ecl_aet_i8: offset = a->array.self.b8 - to_array->array.self.b8; break; #ifdef ecl_uint16_t case ecl_aet_b16: case ecl_aet_i16: offset = a->array.self.b16 - to_array->array.self.b16; break; #endif #ifdef ecl_uint32_t case ecl_aet_b32: case ecl_aet_i32: offset = a->array.self.b32 - to_array->array.self.b32; break; #endif #ifdef ecl_uint64_t case ecl_aet_b64: case ecl_aet_i64: offset = a->array.self.b64 - to_array->array.self.b64; break; #endif default: FEbad_aet(); } } ecl_return2(the_env, to_array, ecl_make_fixnum(offset)); } cl_object cl_svref(cl_object x, cl_object index) { const cl_env_ptr the_env = ecl_process_env(); cl_index i; if (ecl_unlikely(ecl_t_of(x) != t_vector || (x->vector.flags & (ECL_FLAG_ADJUSTABLE | ECL_FLAG_HAS_FILL_POINTER)) || CAR(x->vector.displaced) != ECL_NIL || (cl_elttype)x->vector.elttype != ecl_aet_object)) { FEwrong_type_nth_arg(@[svref],1,x,@[simple-vector]); } i = checked_index(@[svref], x, -1, index, x->vector.dim); ecl_return1(the_env, x->vector.self.t[i]); } cl_object si_svset(cl_object x, cl_object index, cl_object v) { const cl_env_ptr the_env = ecl_process_env(); cl_index i; if (ecl_unlikely(ecl_t_of(x) != t_vector || (x->vector.flags & (ECL_FLAG_ADJUSTABLE | ECL_FLAG_HAS_FILL_POINTER)) || CAR(x->vector.displaced) != ECL_NIL || (cl_elttype)x->vector.elttype != ecl_aet_object)) { FEwrong_type_nth_arg(@[si::svset],1,x,@[simple-vector]); } i = checked_index(@[svref], x, -1, index, x->vector.dim); ecl_return1(the_env, x->vector.self.t[i] = v); } cl_object cl_array_has_fill_pointer_p(cl_object a) { const cl_env_ptr the_env = ecl_process_env(); cl_object r; switch (ecl_t_of(a)) { case t_array: r = ECL_NIL; break; case t_vector: case t_bitvector: #ifdef ECL_UNICODE case t_string: #endif case t_base_string: r = ECL_ARRAY_HAS_FILL_POINTER_P(a)? ECL_T : ECL_NIL; break; default: FEwrong_type_nth_arg(@[array-has-fill-pointer-p],1,a,@[array]); } ecl_return1(the_env, r); } cl_object cl_fill_pointer(cl_object a) { const cl_env_ptr the_env = ecl_process_env(); if (ecl_unlikely(!ECL_VECTORP(a))) FEwrong_type_only_arg(@[fill-pointer], a, @[vector]); if (ecl_unlikely(!ECL_ARRAY_HAS_FILL_POINTER_P(a))) { const char *type = "(AND VECTOR (SATISFIES ARRAY-HAS-FILL-POINTER-P))"; FEwrong_type_nth_arg(@[fill-pointer], 1, a, ecl_read_from_cstring(type)); } ecl_return1(the_env, ecl_make_fixnum(a->vector.fillp)); } /* Internal function for setting fill pointer. */ cl_object si_fill_pointer_set(cl_object a, cl_object fp) { const cl_env_ptr the_env = ecl_process_env(); cl_fixnum i; if (ecl_unlikely(!ECL_VECTORP(a) || !ECL_ARRAY_HAS_FILL_POINTER_P(a))) { const char *type = "(AND VECTOR (SATISFIES ARRAY-HAS-FILL-POINTER-P))"; FEwrong_type_nth_arg(@[adjust-array], 1, a, ecl_read_from_cstring(type)); } if (ecl_unlikely(!ECL_FIXNUMP(fp) || ((i = ecl_fixnum(fp)) < 0) || (i > a->vector.dim))) { cl_object type = ecl_make_integer_type(ecl_make_fixnum(0), ecl_make_fixnum(a->vector.dim-1)); FEwrong_type_key_arg(@[adjust-array], @[:fill-pointer], fp, type); } a->vector.fillp = i; ecl_return1(the_env, fp); } /* Internal function for replacing the contents of arrays: (si:replace-array old-array new-array). Used in ADJUST-ARRAY. */ cl_object si_replace_array(cl_object olda, cl_object newa) { const cl_env_ptr the_env = ecl_process_env(); cl_object dlist; if (ecl_t_of(olda) != ecl_t_of(newa) || (ecl_t_of(olda) == t_array && olda->array.rank != newa->array.rank)) goto CANNOT; if (!ECL_ADJUSTABLE_ARRAY_P(olda)) { /* When an array is not adjustable, we simply output the new array */ olda = newa; goto OUTPUT; } for (dlist = CDR(olda->array.displaced); dlist != ECL_NIL; dlist = CDR(dlist)) { cl_object other_array = CAR(dlist); cl_object offset; cl_array_displacement(other_array); offset = ecl_nth_value(the_env, 1); ecl_displace(other_array, newa, offset); } switch (ecl_t_of(olda)) { case t_array: case t_vector: case t_bitvector: olda->array = newa->array; break; #ifdef ECL_UNICODE case t_string: #endif case t_base_string: olda->base_string = newa->base_string; break; default: CANNOT: FEerror("Cannot replace the array ~S by the array ~S.", 2, olda, newa); } OUTPUT: ecl_return1(the_env, olda); } void ecl_copy_subarray(cl_object dest, cl_index i0, cl_object orig, cl_index i1, cl_index l) { cl_elttype t = ecl_array_elttype(dest); if (i0 + l > dest->array.dim) { l = dest->array.dim - i0; } if (i1 + l > orig->array.dim) { l = orig->array.dim - i1; } if (t != ecl_array_elttype(orig) || t == ecl_aet_bit) { if (dest == orig && i0 > i1) { for (i0 += l, i1 += l; l--; ) { ecl_aset_unsafe(dest, --i0, ecl_aref_unsafe(orig, --i1)); } } else { while (l--) { ecl_aset_unsafe(dest, i0++, ecl_aref_unsafe(orig, i1++)); } } } else { /* We could have singled out also dest == orig and used memcpy * but gcc-4.6 breaks this code even when i0 < i1 if the regions * overlap sufficiently. */ cl_index elt_size = ecl_aet_size[t]; memmove(dest->array.self.bc + i0 * elt_size, orig->array.self.bc + i1 * elt_size, l * elt_size); } } void ecl_reverse_subarray(cl_object x, cl_index i0, cl_index i1) { cl_elttype t = ecl_array_elttype(x); cl_index i, j; if (x->array.dim == 0) { return; } if (i1 >= x->array.dim) { i1 = x->array.dim; } switch (t) { case ecl_aet_object: case ecl_aet_fix: case ecl_aet_index: for (i = i0, j = i1-1; i < j; i++, --j) { cl_object y = x->vector.self.t[i]; x->vector.self.t[i] = x->vector.self.t[j]; x->vector.self.t[j] = y; } break; case ecl_aet_sf: for (i = i0, j = i1-1; i < j; i++, --j) { float y = x->array.self.sf[i]; x->array.self.sf[i] = x->array.self.sf[j]; x->array.self.sf[j] = y; } break; case ecl_aet_df: for (i = i0, j = i1-1; i < j; i++, --j) { double y = x->array.self.df[i]; x->array.self.df[i] = x->array.self.df[j]; x->array.self.df[j] = y; } break; case ecl_aet_bc: for (i = i0, j = i1-1; i < j; i++, --j) { ecl_base_char y = x->array.self.bc[i]; x->array.self.bc[i] = x->array.self.bc[j]; x->array.self.bc[j] = y; } break; case ecl_aet_b8: case ecl_aet_i8: for (i = i0, j = i1-1; i < j; i++, --j) { ecl_uint8_t y = x->array.self.b8[i]; x->array.self.b8[i] = x->array.self.b8[j]; x->array.self.b8[j] = y; } break; #ifdef ecl_uint16_t case ecl_aet_b16: case ecl_aet_i16: for (i = i0, j = i1-1; i < j; i++, --j) { ecl_uint16_t y = x->array.self.b16[i]; x->array.self.b16[i] = x->array.self.b16[j]; x->array.self.b16[j] = y; } break; #endif #ifdef ecl_uint32_t case ecl_aet_b32: case ecl_aet_i32: for (i = i0, j = i1-1; i < j; i++, --j) { ecl_uint32_t y = x->array.self.b32[i]; x->array.self.b32[i] = x->array.self.b32[j]; x->array.self.b32[j] = y; } break; #endif #ifdef ecl_uint64_t case ecl_aet_b64: case ecl_aet_i64: for (i = i0, j = i1-1; i < j; i++, --j) { ecl_uint64_t y = x->array.self.b64[i]; x->array.self.b64[i] = x->array.self.b64[j]; x->array.self.b64[j] = y; } break; #endif #ifdef ECL_UNICODE case ecl_aet_ch: for (i = i0, j = i1-1; i < j; i++, --j) { ecl_character y = x->array.self.c[i]; x->array.self.c[i] = x->array.self.c[j]; x->array.self.c[j] = y; } break; #endif case ecl_aet_bit: for (i = i0 + x->vector.offset, j = i1 + x->vector.offset - 1; i < j; i++, --j) { int k = x->array.self.bit[i/CHAR_BIT]&(0200>>i%CHAR_BIT); if (x->array.self.bit[j/CHAR_BIT]&(0200>>j%CHAR_BIT)) x->array.self.bit[i/CHAR_BIT] |= 0200>>i%CHAR_BIT; else x->array.self.bit[i/CHAR_BIT] &= ~(0200>>i%CHAR_BIT); if (k) x->array.self.bit[j/CHAR_BIT] |= 0200>>j%CHAR_BIT; else x->array.self.bit[j/CHAR_BIT] &= ~(0200>>j%CHAR_BIT); } break; default: FEbad_aet(); } } cl_object si_copy_subarray(cl_object dest, cl_object start0, cl_object orig, cl_object start1, cl_object length) { ecl_copy_subarray(dest, ecl_to_size(start0), orig, ecl_to_size(start1), ecl_to_size(length)); @(return dest) } cl_object si_fill_array_with_elt(cl_object x, cl_object elt, cl_object start, cl_object end) { cl_elttype t = ecl_array_elttype(x); cl_index first = ecl_to_size(start); cl_index last = Null(end)? x->array.dim : ecl_to_size(end); if (first >= last) { goto END; } switch (t) { case ecl_aet_object: { cl_object *p = x->vector.self.t + first; for (first = last - first; first; --first, ++p) { *p = elt; } break; } case ecl_aet_bc: { ecl_base_char e = ecl_char_code(elt); ecl_base_char *p = x->vector.self.bc + first; for (first = last - first; first; --first, ++p) { *p = e; } break; } #ifdef ECL_UNICODE case ecl_aet_ch: { ecl_character e = ecl_char_code(elt); ecl_character *p = x->vector.self.c + first; for (first = last - first; first; --first, ++p) { *p = e; } break; } #endif case ecl_aet_fix: { cl_fixnum e = ecl_to_fix(elt); cl_fixnum *p = x->vector.self.fix + first; for (first = last - first; first; --first, ++p) { *p = e; } break; } case ecl_aet_index: { cl_index e = ecl_to_size(elt); cl_index *p = x->vector.self.index + first; for (first = last - first; first; --first, ++p) { *p = e; } break; } case ecl_aet_sf: { float e = ecl_to_float(elt); float *p = x->vector.self.sf + first; for (first = last - first; first; --first, ++p) { *p = e; } break; } case ecl_aet_df: { double e = ecl_to_double(elt); double *p = x->vector.self.df + first; for (first = last - first; first; --first, ++p) { *p = e; } break; } case ecl_aet_b8: { uint8_t e = ecl_to_uint8_t(elt); uint8_t *p = x->vector.self.b8 + first; for (first = last - first; first; --first, ++p) { *p = e; } break; } case ecl_aet_i8: { int8_t e = ecl_to_int8_t(elt); int8_t *p = x->vector.self.i8 + first; for (first = last - first; first; --first, ++p) { *p = e; } break; } #ifdef ecl_uint16_t case ecl_aet_b16: { ecl_uint16_t e = ecl_to_uint16_t(elt); ecl_uint16_t *p = x->vector.self.b16 + first; for (first = last - first; first; --first, ++p) { *p = e; } break; } case ecl_aet_i16: { ecl_int16_t e = ecl_to_int16_t(elt); ecl_int16_t *p = x->vector.self.i16 + first; for (first = last - first; first; --first, ++p) { *p = e; } break; } #endif #ifdef ecl_uint32_t case ecl_aet_b32: { ecl_uint32_t e = ecl_to_uint32_t(elt); ecl_uint32_t *p = x->vector.self.b32 + first; for (first = last - first; first; --first, ++p) { *p = e; } break; } case ecl_aet_i32: { ecl_int32_t e = ecl_to_int32_t(elt); ecl_int32_t *p = x->vector.self.i32 + first; for (first = last - first; first; --first, ++p) { *p = e; } break; } #endif #ifdef ecl_uint64_t case ecl_aet_b64: { ecl_uint64_t e = ecl_to_uint64_t(elt); ecl_uint64_t *p = x->vector.self.b64 + first; for (first = last - first; first; --first, ++p) { *p = e; } break; } case ecl_aet_i64: { ecl_int64_t e = ecl_to_int64_t(elt); ecl_int64_t *p = x->vector.self.i64 + first; for (first = last - first; first; --first, ++p) { *p = e; } break; } #endif case ecl_aet_bit: { int i = ecl_to_bit(elt); for (last -= first, first += x->vector.offset; last; --last, ++first) { int mask = 0200>>first%CHAR_BIT; if (i == 0) x->vector.self.bit[first/CHAR_BIT] &= ~mask; else x->vector.self.bit[first/CHAR_BIT] |= mask; } break; } default: FEbad_aet(); } END: @(return x) } ecl-16.1.2/src/c/assignment.d000066400000000000000000000172361266352375300157170ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* assignment.c -- Assignment. */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #include #include static void FEconstant_assignment(cl_object var) ecl_attr_noreturn; static void FEconstant_assignment(cl_object var) { FEinvalid_variable("Cannot assign to the constant ~S.", var); } cl_object cl_set(cl_object var, cl_object value) { const cl_env_ptr env = ecl_process_env(); unlikely_if (Null(var)) { FEconstant_assignment(var); } unlikely_if (ecl_t_of(var) != t_symbol) { FEwrong_type_nth_arg(@[setq], 1, var, @[symbol]); } unlikely_if (var->symbol.stype & ecl_stp_constant) FEconstant_assignment(var); ecl_return1(env, ECL_SETQ(env, var, value)); } cl_object ecl_setq(cl_env_ptr env, cl_object var, cl_object value) { unlikely_if (Null(var)) { FEconstant_assignment(var); } unlikely_if (ecl_t_of(var) != t_symbol) { FEwrong_type_nth_arg(@[setq], 1, var, @[symbol]); } return ECL_SETQ(env, var, value); } static cl_object unbound_setf_function_error(cl_narg narg, ...) { const cl_env_ptr the_env = ecl_process_env(); cl_object name = the_env->function->cclosure.env; FEundefined_function(cl_list(2, @'setf', name)); } static cl_object make_setf_function_error(cl_object name) { return ecl_make_cclosure_va((cl_objectfn)unbound_setf_function_error, name, ECL_NIL); } cl_object ecl_setf_definition(cl_object sym, cl_object createp) { cl_env_ptr the_env = ecl_process_env(); cl_object pair; ECL_WITH_GLOBAL_ENV_RDLOCK_BEGIN(the_env) { pair = ecl_gethash_safe(sym, cl_core.setf_definitions, ECL_NIL); if (Null(pair) && !Null(createp)) { createp = make_setf_function_error(sym); pair = ecl_cons(createp, ECL_NIL); ecl_sethash(sym, cl_core.setf_definitions, pair); } } ECL_WITH_GLOBAL_ENV_RDLOCK_END; return pair; } cl_object si_setf_definition(cl_object sym, cl_object value) { @(return ecl_setf_definition(sym, value)) } static void ecl_rem_setf_definition(cl_object sym) { cl_env_ptr the_env = ecl_process_env(); ECL_WITH_GLOBAL_ENV_WRLOCK_BEGIN(the_env) { cl_object pair = ecl_gethash_safe(sym, cl_core.setf_definitions, ECL_NIL); if (!Null(pair)) { ECL_RPLACA(pair, make_setf_function_error(sym)); ECL_RPLACD(pair, ECL_NIL); /* FIXME: This leaks resources We actually cannot remove it, because some compiled code might be using it! ecl_remhash(sym, cl_core.setf_definitions); */ } } ECL_WITH_GLOBAL_ENV_WRLOCK_END; } @(defun si::fset (fname def &optional macro pprint) cl_object sym = si_function_block_name(fname); cl_object pack; bool mflag; int type; @ if (Null(cl_functionp(def))) FEinvalid_function(def); pack = ecl_symbol_package(sym); if (pack != ECL_NIL && pack->pack.locked) { CEpackage_error("Attempt to redefine function ~S in locked package.", "Ignore lock and proceed", pack, 1, fname); } mflag = !Null(macro); type = ecl_symbol_type(sym); if ((type & ecl_stp_special_form) && !mflag) { FEerror("Given that ~S is a special form, ~S cannot be defined as a function.", 2, sym, fname); } if (ECL_SYMBOLP(fname)) { if (mflag) { type |= ecl_stp_macro; } else { type &= ~ecl_stp_macro; } ecl_symbol_type_set(sym, type); ECL_SYM_FUN(sym) = def; ecl_clear_compiler_properties(sym); #ifndef ECL_CMU_FORMAT if (pprint == ECL_NIL) si_rem_sysprop(sym, @'si::pretty-print-format'); else si_put_sysprop(sym, @'si::pretty-print-format', pprint); #endif } else if (mflag) { FEerror("~S is not a valid name for a macro.", 1, fname); } else { cl_object pair = ecl_setf_definition(sym, def); ECL_RPLACA(pair, def); ECL_RPLACD(pair, sym); } @(return def) @) cl_object cl_makunbound(cl_object sym) { if (ecl_symbol_type(sym) & ecl_stp_constant) FEinvalid_variable("Cannot unbind the constant ~S.", sym); /* FIXME! The semantics of MAKUNBOUND is not very clear with local bindings ... */ ECL_SET(sym, OBJNULL); @(return sym) } cl_object cl_fmakunbound(cl_object fname) { cl_object sym = si_function_block_name(fname); cl_object pack = ecl_symbol_package(sym); if (pack != ECL_NIL && pack->pack.locked) { CEpackage_error("Attempt to redefine function ~S in locked package.", "Ignore lock and proceed", pack, 1, fname); } if (ECL_SYMBOLP(fname)) { ecl_clear_compiler_properties(sym); ECL_SYM_FUN(sym) = ECL_NIL; ecl_symbol_type_set(sym, ecl_symbol_type(sym) & ~ecl_stp_macro); } else { ecl_rem_setf_definition(sym); si_rem_sysprop(sym, @'si::setf-method'); } @(return fname) } void ecl_clear_compiler_properties(cl_object sym) { if (ecl_option_values[ECL_OPT_BOOTED]) { funcall(2, @'si::clear-compiler-properties', sym); } } cl_object si_get_sysprop(cl_object sym, cl_object prop) { cl_env_ptr the_env = ecl_process_env(); ECL_WITH_GLOBAL_ENV_RDLOCK_BEGIN(the_env) { cl_object plist = ecl_gethash_safe(sym, cl_core.system_properties, ECL_NIL); prop = ecl_getf(plist, prop, OBJNULL); } ECL_WITH_GLOBAL_ENV_RDLOCK_END; if (prop == OBJNULL) { @(return ECL_NIL ECL_NIL); } else { @(return prop ECL_T); } } cl_object si_put_sysprop(cl_object sym, cl_object prop, cl_object value) { cl_env_ptr the_env = ecl_process_env(); ECL_WITH_GLOBAL_ENV_WRLOCK_BEGIN(the_env) { cl_object plist = ecl_gethash_safe(sym, cl_core.system_properties, ECL_NIL); ecl_sethash(sym, cl_core.system_properties, si_put_f(plist, value, prop)); } ECL_WITH_GLOBAL_ENV_WRLOCK_END; @(return value); } cl_object si_rem_sysprop(cl_object sym, cl_object prop) { const cl_env_ptr the_env = ecl_process_env(); cl_object plist, found; plist = ecl_gethash_safe(sym, cl_core.system_properties, ECL_NIL); plist = si_rem_f(plist, prop); found = ecl_nth_value(the_env, 1); ecl_sethash(sym, cl_core.system_properties, plist); ecl_return1(the_env, found); } ecl-16.1.2/src/c/backq.d000066400000000000000000000176541266352375300146340ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* backq.c -- Backquote mechanism. */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #include /******************************* ------- ******************************/ #define QUOTE 1 #define EVAL 2 #define LIST 3 #define LISTX 4 #define APPEND 5 #define NCONC 6 extern int _cl_backq_car(cl_object *px); static cl_object backq(cl_object x); static cl_object kwote(cl_object x) { cl_type t = ecl_t_of(x); if ((t == t_symbol && !Null(x) && !ecl_keywordp(x)) || t == t_list || t == t_vector) x = CONS(@'quote', ecl_list1(x)); return x; } /* _cl_backq_cdr(&x) puts result into x and returns one of QUOTE the form should be quoted EVAL the form should be evaluated LIST the form should be applied to LIST LISTX the form should be applied to LIST* APPEND the form should be applied to APPEND NCONC the form should be applied to NCONC */ static int _cl_backq_cdr(cl_object *px) { cl_object x = *px, ax, dx; int a, d, out; if (ECL_ATOM(x)) return(QUOTE); if (CAR(x) == @'si::unquote') { *px = CADR(x); return(EVAL); } if (CAR(x) == @'si::unquote-splice' || CAR(x) == @'si::unquote-nsplice') FEerror(",@@ or ,. has appeared in an illegal position.", 0); ax = CAR(x); dx = CDR(x); a = _cl_backq_car(&ax); d = _cl_backq_cdr(&dx); if (d == QUOTE) { switch (a) { case QUOTE: return(QUOTE); case EVAL: if (Null(dx)) { out = LIST; } else if (CONSP(dx) && Null(CDR(dx))) { dx = ecl_list1(kwote(CAR(dx))); out = LIST; } else { dx = ecl_list1(kwote(dx)); out = LISTX; } break; case APPEND: case NCONC: if (Null(dx)) { *px = ax; return EVAL; } else { dx = ecl_list1(kwote(dx)); out = a; } break; default: ecl_internal_error("backquote botch"); } } else if (d == EVAL) { switch (a) { case QUOTE: ax = kwote(ax); dx = ecl_list1(dx); out = LISTX; break; case EVAL: dx = ecl_list1(dx); out = LISTX; break; case APPEND: case NCONC: dx = ecl_list1(dx); out = a; break; default: ecl_internal_error("backquote botch"); } } else if (d == a) { out = d; } else { switch (d) { case LIST: if (a == QUOTE) { ax = kwote(ax); out = LIST; goto OUTPUT; } else if (a == EVAL) { out = LIST; goto OUTPUT; } dx = CONS(@'list', dx); break; case LISTX: if (a == QUOTE) { ax = kwote(ax); out = LISTX; goto OUTPUT; } else if (a == EVAL) { out = LISTX; goto OUTPUT; } dx = CONS(@'list*', dx); break; case APPEND: dx = CONS(@'append', dx); break; case NCONC: dx = CONS(@'nconc', dx); break; default: ecl_internal_error("backquote botch"); } switch (a) { case QUOTE: ax = kwote(ax); dx = ecl_list1(dx); out = LISTX; break; case EVAL: dx = ecl_list1(dx); out = LISTX; break; case APPEND: case NCONC: dx = ecl_list1(dx); out = a; break; default: ecl_internal_error("backquote botch"); } } OUTPUT: *px = CONS(ax, dx); return out; } /* _cl_backq_car(&x) puts result into x and returns one of QUOTE the form should be quoted EVAL the form should be evaluated APPEND the form should be appended into the outer form NCONC the form should be nconc'ed into the outer form */ int _cl_backq_car(cl_object *px) { cl_object x = *px; int d; AGAIN: if (ECL_ATOM(x)) return(QUOTE); if (CAR(x) == @'si::quasiquote') { x = *px = backq(CADR(x)); goto AGAIN; } if (CAR(x) == @'si::unquote') { *px = CADR(x); return EVAL; } if (CAR(x) == @'si::unquote-splice') { *px = CADR(x); return APPEND; } if (CAR(x) == @'si::unquote-nsplice') { *px = CADR(x); return NCONC; } d = _cl_backq_cdr(px); switch (d) { case QUOTE: case EVAL: return(d); case LIST: *px = CONS(@'list', *px); break; case LISTX: *px = CONS(@'list*', *px); break; case APPEND: *px = CONS(@'append', *px); break; case NCONC: *px = CONS(@'nconc', *px); break; default: ecl_internal_error("backquote botch"); } return(EVAL); } static cl_object backq(cl_object x) { int a; a = _cl_backq_car(&x); if (a == APPEND || a == NCONC) FEerror(",@@ or ,. has appeared in an illegal position.", 0); if (a == QUOTE) return(kwote(x)); return(x); } static cl_object quasiquote_macro(cl_object whole, cl_object env) { if (ecl_length(whole) != 2) { FEprogram_error("Syntax error: ~S.", 1, whole); } @(return backq(CADR(whole))) } void init_backq(void) { ecl_def_c_macro(@'si::quasiquote', quasiquote_macro, 2); } ecl-16.1.2/src/c/big.d000066400000000000000000000350231266352375300143020ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* big.c -- Bignum routines. */ /* Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #define ECL_INCLUDE_MATH_H #include #include #include /* * Using GMP multiple precision integers. */ void _ecl_big_register_free(cl_object x) { return; /* We only need to free the integer when it gets too large */ if (ECL_BIGNUM_DIM(x) > 3 * ECL_BIG_REGISTER_SIZE) { mpz_realloc2(x->big.big_num, ECL_BIG_REGISTER_SIZE * GMP_LIMB_BITS); } } static cl_object _ecl_alloc_compact_bignum(cl_index limbs) { #if 1 cl_index bytes = limbs * sizeof(mp_limb_t); cl_object new_big = ecl_alloc_compact_object(t_bignum, bytes); ECL_BIGNUM_LIMBS(new_big) = ECL_COMPACT_OBJECT_EXTRA(new_big); ECL_BIGNUM_SIZE(new_big) = 0; ECL_BIGNUM_DIM(new_big) = limbs; #else cl_object new_big = ecl_alloc_object(t_bignum); mpz_init2(new_big->big.big_num, limbs * GMP_LIMB_BITS); #endif return new_big; } static cl_object _ecl_big_copy(cl_object old) { cl_fixnum size = ECL_BIGNUM_SIZE(old); cl_index dim = (size < 0)? (-size) : size; cl_index bytes = dim * sizeof(mp_limb_t); cl_object new_big = _ecl_alloc_compact_bignum(dim); ECL_BIGNUM_SIZE(new_big) = size; memcpy(ECL_BIGNUM_LIMBS(new_big), ECL_BIGNUM_LIMBS(old), bytes); return new_big; } cl_object _ecl_big_register_copy(cl_object old) { cl_object new_big = _ecl_big_copy(old); _ecl_big_register_free(old); return new_big; } static cl_object big_normalize(cl_object x) { int s = ECL_BIGNUM_SIZE(x); if (s == 0) return(ecl_make_fixnum(0)); if (s == 1) { mp_limb_t y = ECL_BIGNUM_LIMBS(x)[0]; if (y <= MOST_POSITIVE_FIXNUM) return ecl_make_fixnum(y); } else if (s == -1) { mp_limb_t y = ECL_BIGNUM_LIMBS(x)[0]; if (y <= -MOST_NEGATIVE_FIXNUM) return ecl_make_fixnum(-y); } return x; } cl_object _ecl_big_register_normalize(cl_object x) { int s = ECL_BIGNUM_SIZE(x); if (s == 0) return(ecl_make_fixnum(0)); if (s == 1) { mp_limb_t y = ECL_BIGNUM_LIMBS(x)[0]; if (y <= MOST_POSITIVE_FIXNUM) return ecl_make_fixnum(y); } else if (s == -1) { mp_limb_t y = ECL_BIGNUM_LIMBS(x)[0]; if (y <= -MOST_NEGATIVE_FIXNUM) return ecl_make_fixnum(-y); } return _ecl_big_register_copy(x); } #if GMP_LIMB_BITS >= ECL_FIXNUM_BITS static const int limbs_per_fixnum = 1; #else static const int limbs_per_fixnum = (ECL_FIXNUM_BITS + GMP_LIMB_BITS - 1) / GMP_LIMB_BITS; #endif #define ECL_BIGNUM_ABS_SIZE(x) \ (ECL_BIGNUM_SIZE(x)<0? -ECL_BIGNUM_SIZE(x) : ECL_BIGNUM_SIZE(x)) cl_object _ecl_fix_times_fix(cl_fixnum x, cl_fixnum y) { #if ECL_LONG_BITS >= ECL_FIXNUM_BITS ECL_WITH_TEMP_BIGNUM(z,4); _ecl_big_set_si(z, x); _ecl_big_mul_si(z, z, y); #else ECL_WITH_TEMP_BIGNUM(z,4); ECL_WITH_TEMP_BIGNUM(w,4); _ecl_big_set_fixnum(z, x); _ecl_big_set_fixnum(w, y); _ecl_big_mul(z, z, w); #endif { cl_object y = big_normalize(z); if (y == z) y = _ecl_big_copy(z); return y; } } cl_object _ecl_big_times_big(cl_object a, cl_object b) { cl_index size_a = ECL_BIGNUM_ABS_SIZE(a); cl_index size_b = ECL_BIGNUM_ABS_SIZE(b); cl_index size = size_a + size_b; cl_object z = _ecl_alloc_compact_bignum(size); _ecl_big_mul(z, a, b); return z; } cl_object _ecl_big_times_fix(cl_object b, cl_fixnum i) { cl_index size; cl_object z; if (i == 0) return ecl_make_fixnum(0); if (i == 1) return b; size = ECL_BIGNUM_ABS_SIZE(b); size += limbs_per_fixnum; z = _ecl_alloc_compact_bignum(size); #if ECL_LONG_BITS >= ECL_FIXNUM_BITS _ecl_big_mul_si(z, b, i); #else { ECL_WITH_TEMP_BIGNUM(w,4); _ecl_big_set_fixnum(w, i); _ecl_big_mul(z, b, w); } #endif return z; } cl_object _ecl_big_plus_fix(cl_object a, cl_fixnum b) { ECL_WITH_TEMP_BIGNUM(big_b, 2); _ecl_big_set_fixnum(big_b, b); return _ecl_big_plus_big(a, big_b); } cl_object _ecl_big_plus_big(cl_object a, cl_object b) { cl_index size_a = ECL_BIGNUM_ABS_SIZE(a); cl_index size_b = ECL_BIGNUM_ABS_SIZE(b); cl_index size_z = (size_a < size_b)? (size_b + 1) : (size_a + 1); cl_object z = _ecl_alloc_compact_bignum(size_z); _ecl_big_add(z, a, b); return big_normalize(z); } cl_object _ecl_big_minus_big(cl_object a, cl_object b) { cl_index size_a = ECL_BIGNUM_ABS_SIZE(a); cl_index size_b = ECL_BIGNUM_ABS_SIZE(b); cl_index size_z = (size_a < size_b)? (size_b + 1) : (size_a + 1); cl_object z = _ecl_alloc_compact_bignum(size_z); mpz_sub(z->big.big_num, a->big.big_num, b->big.big_num); return big_normalize(z); } cl_object _ecl_fix_minus_big(cl_fixnum a, cl_object b) { cl_index size_b = ECL_BIGNUM_ABS_SIZE(b); cl_index size_z = size_b + limbs_per_fixnum; cl_object z = _ecl_alloc_compact_bignum(size_z); _ecl_big_set_fixnum(z, a); mpz_sub(z->big.big_num, z->big.big_num, b->big.big_num); return big_normalize(z); } cl_object _ecl_big_negate(cl_object a) { cl_index size_a = ECL_BIGNUM_ABS_SIZE(a); cl_object z = _ecl_alloc_compact_bignum(size_a); mpz_neg(z->big.big_num, a->big.big_num); return big_normalize(z); } cl_object _ecl_big_divided_by_big(cl_object a, cl_object b) { cl_object z; cl_index size_a = ECL_BIGNUM_ABS_SIZE(a); cl_index size_b = ECL_BIGNUM_ABS_SIZE(b); cl_fixnum size_z = size_a - size_b + 1; if (size_z <= 0) size_z = 1; z = _ecl_alloc_compact_bignum(size_z); mpz_tdiv_q(z->big.big_num,a->big.big_num,b->big.big_num); return big_normalize(z); } cl_object _ecl_big_gcd(cl_object a, cl_object b) { cl_object z = _ecl_big_register0(); mpz_gcd(z->big.big_num, a->big.big_num, b->big.big_num); return _ecl_big_register_normalize(z); } cl_object _ecl_big_divided_by_fix(cl_object x, cl_fixnum y) { ECL_WITH_TEMP_BIGNUM(by, 2); _ecl_big_set_fixnum(by, y); return _ecl_big_divided_by_big(x, by); } cl_object _ecl_big_ceiling(cl_object a, cl_object b, cl_object *pr) { cl_object q = _ecl_big_register0(); cl_object r = _ecl_big_register1(); mpz_cdiv_qr(q->big.big_num, r->big.big_num, a->big.big_num, b->big.big_num); *pr = _ecl_big_register_normalize(r); return _ecl_big_register_normalize(q); } cl_object _ecl_big_floor(cl_object a, cl_object b, cl_object *pr) { cl_object q = _ecl_big_register0(); cl_object r = _ecl_big_register1(); mpz_fdiv_qr(q->big.big_num, r->big.big_num, a->big.big_num, b->big.big_num); *pr = _ecl_big_register_normalize(r); return _ecl_big_register_normalize(q); } cl_object _ecl_fix_divided_by_big(cl_fixnum x, cl_object y) { ECL_WITH_TEMP_BIGNUM(bx, 2); _ecl_big_set_fixnum(bx, x); return _ecl_big_divided_by_big(bx, y); } static void * mp_alloc(size_t size) { return ecl_alloc_uncollectable(size); } static void mp_free(void *ptr, size_t size) { ecl_free_uncollectable(ptr); } static void * mp_realloc(void *ptr, size_t osize, size_t nsize) { mp_limb_t *p = mp_alloc(nsize); memcpy(p, ptr, (osize < nsize)? osize : nsize); mp_free(ptr, osize); return p; } cl_fixnum fixint(cl_object x) { if (ECL_FIXNUMP(x)) return ecl_fixnum(x); if (ECL_BIGNUMP(x)) { if (mpz_fits_slong_p(x->big.big_num)) { return mpz_get_si(x->big.big_num); } } FEwrong_type_argument(@[fixnum], x); } cl_index fixnnint(cl_object x) { if (ECL_FIXNUMP(x)) { cl_fixnum i = ecl_fixnum(x); if (i >= 0) return i; } else if (ECL_BIGNUMP(x)) { if (mpz_fits_ulong_p(x->big.big_num)) { return mpz_get_ui(x->big.big_num); } } FEwrong_type_argument(cl_list(3, @'integer', ecl_make_fixnum(0), ecl_make_fixnum(MOST_POSITIVE_FIXNUM)), x); } #undef _ecl_big_set_fixnum #undef _ecl_big_set_index #if ECL_LONG_BITS >= ECL_FIXNUM_BITS cl_object _ecl_big_set_fixnum(cl_object x, cl_fixnum f) { mpz_set_si((x)->big.big_num,(f)); return x; } cl_object _ecl_big_set_index(cl_object x, cl_index f) { mpz_set_ui((x)->big.big_num,(f)); return x; } cl_fixnum _ecl_big_get_fixnum(cl_object x) { return mpz_get_si((x)->big.big_num); } cl_index _ecl_big_get_index(cl_object x) { return mpz_get_ui((x)->big.big_num); } #elif GMP_LIMB_BITS >= ECL_FIXNUM_BITS cl_object _ecl_big_set_fixnum(cl_object x, cl_fixnum f) { if (f == 0) { mpz_set_si(x->big.big_num, 0); } else if (f > 0) { ECL_BIGNUM_SIZE(x) = 1; ECL_BIGNUM_LIMBS(x)[0] = f; } else if (f < 0) { ECL_BIGNUM_SIZE(x) = -1; ECL_BIGNUM_LIMBS(x)[0] = -f; } } cl_object _ecl_big_set_index(cl_object x, cl_index f) { if (f == 0) { mpz_set_si(x->big.big_num, 0); } else if (f > 0) { ECL_BIGNUM_SIZE(x) = 1; ECL_BIGNUM_LIMBS(x)[0] = f; } } cl_fixnum _ecl_big_get_fixnum(cl_object x) { /* INV: x is a bignum and thus size != 0 */ cl_fixnum output = ECL_BIGNUM_LIMBS(x)[0]; return (ECL_BIGNUM_SIZE(x) > 0) ? output : -output; } cl_index _ecl_big_get_index(cl_object x) { /* INV: x is a bignum and thus size != 0 */ cl_index output = ECL_BIGNUM_LIMBS(x)[0]; return (ECL_BIGNUM_SIZE(x) > 0)? output : ~(output - 1); } bool _ecl_big_fits_in_index(cl_object x) { /* INV: x is a bignum and thus size != 0 */ return (ECL_BIGNUM_SIZE(x) ^ 1) == 0; } #else # error "ECL cannot build with GMP when both long and mp_limb_t are smaller than cl_fixnum" #endif /* ECL_FIXNUM_BITS > GMP_LIMB_BITS, ECL_LONG_BITS */ #ifdef ECL_LONG_FLOAT long double _ecl_big_to_long_double(cl_object o) { long double output = 0; int i, l = mpz_size(o->big.big_num), exp = 0; for (i = 0; i < l; i++) { output += ldexpl(mpz_getlimbn(o->big.big_num, i), exp); exp += GMP_LIMB_BITS; } return (mpz_sgn(o->big.big_num) < 0)? -output : output; } #endif static void mpz_ior_op(cl_object out, cl_object i, cl_object j) { mpz_ior(out->big.big_num, i->big.big_num, j->big.big_num); } static void mpz_xor_op(cl_object out, cl_object i, cl_object j) { mpz_xor(out->big.big_num, i->big.big_num, j->big.big_num); } static void mpz_and_op(cl_object out, cl_object i, cl_object j) { mpz_and(out->big.big_num, i->big.big_num, j->big.big_num); } static void mpz_eqv_op(cl_object out, cl_object i, cl_object j) { mpz_xor(out->big.big_num, i->big.big_num, j->big.big_num); mpz_com(out->big.big_num, out->big.big_num); } static void mpz_nand_op(cl_object out, cl_object i, cl_object j) { mpz_and(out->big.big_num, i->big.big_num, j->big.big_num); mpz_com(out->big.big_num, out->big.big_num); } static void mpz_nor_op(cl_object out, cl_object i, cl_object j) { mpz_ior(out->big.big_num, i->big.big_num, j->big.big_num); mpz_com(out->big.big_num, out->big.big_num); } static void mpz_andc1_op(cl_object out, cl_object i, cl_object j) { mpz_com(out->big.big_num, i->big.big_num); mpz_and(out->big.big_num, out->big.big_num, j->big.big_num); } static void mpz_orc1_op(cl_object out, cl_object i, cl_object j) { mpz_com(out->big.big_num, i->big.big_num); mpz_ior(out->big.big_num, out->big.big_num, j->big.big_num); } static void mpz_andc2_op(cl_object out, cl_object i, cl_object j) { /* (i & ~j) = ~((~i) | j) */ mpz_orc1_op(out, i, j); mpz_com(out->big.big_num, out->big.big_num); } static void mpz_orc2_op(cl_object out, cl_object i, cl_object j) { /* (i | ~j) = ~((~i) & j) */ mpz_andc1_op(out, i, j); mpz_com(out->big.big_num, out->big.big_num); } static void mpz_b_clr_op(cl_object out, cl_object i, cl_object j) { mpz_set_si(out->big.big_num, 0); } static void mpz_b_set_op(cl_object o, cl_object i, cl_object j) { mpz_set_si(o->big.big_num, -1); } static void mpz_b_1_op(cl_object out, cl_object i, cl_object j) { if (i != out) mpz_set(out->big.big_num, i->big.big_num); } static void mpz_b_2_op(cl_object out, cl_object i, cl_object j) { mpz_set(out->big.big_num, j->big.big_num); } static void mpz_b_c1_op(cl_object out, cl_object i, cl_object j) { mpz_com(out->big.big_num, i->big.big_num); } static void mpz_b_c2_op(cl_object out, cl_object i, cl_object j) { mpz_com(out->big.big_num, j->big.big_num); } static _ecl_big_binary_op bignum_operations[16] = { mpz_b_clr_op, mpz_and_op, mpz_andc2_op, mpz_b_1_op, mpz_andc1_op, mpz_b_2_op, mpz_xor_op, mpz_ior_op, mpz_nor_op, mpz_eqv_op, mpz_b_c2_op, mpz_orc2_op, mpz_b_c1_op, mpz_orc1_op, mpz_nand_op, mpz_b_set_op}; _ecl_big_binary_op _ecl_big_boole_operator(int op) { unlikely_if((op < 0) || (op >= 16)) { ecl_internal_error("_ecl_big_boole_operator passed " "an invalid operator"); } return bignum_operations[op]; } void init_big() { if (ecl_option_values[ECL_OPT_SET_GMP_MEMORY_FUNCTIONS]) mp_set_memory_functions(mp_alloc, mp_realloc, mp_free); } ecl-16.1.2/src/c/big_ll.d000066400000000000000000000103341266352375300147670ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* big_ll.c -- Bignum emulation with long long. */ /* Copyright (c) 2005, Maciek Pasternacki. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #include void _ecl_big_register_free(cl_object x) {} cl_object _ecl_big_register_copy(cl_object old) { cl_object new_big = ecl_alloc_object(t_bignum); new_big->big.big_num = old->big.big_num; return new_big; } static cl_object big_normalize(cl_object x) { if (x->big.big_num == 0ll) return(ecl_make_fixnum(0)); if (x->big.big_num <= MOST_POSITIVE_FIXNUM && x->big.big_num >= MOST_NEGATIVE_FIXNUM) return(ecl_make_fixnum(x->big.big_num)); return x; } cl_object _ecl_big_register_normalize(cl_object x) { if (x->big.big_num == 0ll) return(ecl_make_fixnum(0)); if (x->big.big_num <= MOST_POSITIVE_FIXNUM && x->big.big_num >= MOST_NEGATIVE_FIXNUM) return(ecl_make_fixnum(x->big.big_num)); return _ecl_big_register_copy(x); } static cl_object big_alloc(int size) { volatile cl_object x = ecl_alloc_object(t_bignum); if (size <= 0) ecl_internal_error("negative or zero size for bignum in big_alloc"); x->big.big_num = 0ll; return x; } static cl_object _ecl_big_copy(cl_object x) { volatile cl_object y = ecl_alloc_object(t_bignum); y->big.big_num = x->big.big_num; return y; } cl_object _ecl_big_gcd(cl_object x, cl_object y) { big_num_t i = x->big.big_num, j = y->big.big_num; cl_object gcd = ecl_alloc_object(t_bignum); while ( 1 ) { big_num_t k; if ( ibig.big_num = k; return gcd; } k = i % j; i = j; j = k; } } int _ecl_big_num_t_sgn(big_num_t x) { return ( x == (big_num_t)0 ) ? 0 : (x < (big_num_t)0) ? -1 : 1; } cl_object _ecl_big_times_big(cl_object x, cl_object y) { cl_object z = ecl_alloc_object(t_bignum); z->big.big_num = x->big.big_num * y->big.big_num; return z; } cl_object _ecl_big_times_fix(cl_object x, cl_fixnum y) { cl_object z = ecl_alloc_object(t_bignum); z->big.big_num = x->big.big_num * y; return big_normalize(z); } cl_object _ecl_big_plus_big(cl_object x, cl_object y) { cl_object z = ecl_alloc_object(t_bignum); z->big.big_num = x->big.big_num + y->big.big_num; return z; } cl_object _ecl_big_plus_fix(cl_object x, cl_fixnum y) { cl_object z = ecl_alloc_object(t_bignum); z->big.big_num = x->big.big_num + y; return big_normalize(z); } cl_object _ecl_fix_times_fix(cl_fixnum x, cl_fixnum y) { cl_object z = ecl_alloc_object(t_bignum); z->big.big_num = x * y; return big_normalize(z); } cl_object _ecl_big_ceiling(cl_object a, cl_object b, cl_object *pr) { cl_object q = ecl_alloc_object(t_bignum); cl_object r = ecl_alloc_object(t_bignum); q->big.num = x->big.num / y->big.big_num; r->big.num = x->big.num % y->big.big_num; *pr = big_normalize(r); return big_normalize(q); } cl_object _ecl_big_floor(cl_object a, cl_object b, cl_object *pr) { cl_object q = ecl_alloc_object(t_bignum); cl_object r = ecl_alloc_object(t_bignum); q->big.num = x->big.num / y->big.big_num; r->big.num = x->big.num % y->big.big_num; *pr = big_normalize(r); return big_normalize(q); } cl_object _ecl_big_negate(cl_object x) { cl_object z = ecl_alloc_object(t_bignum); z->big.big_num = -x->big.big_num; return z; } void init_big(void) { } ecl-16.1.2/src/c/cfun.d000066400000000000000000000157701266352375300145030ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* cfun.c -- Compiled functions. */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #include /* for memmove() */ #include "cfun_dispatch.d" cl_object ecl_make_cfun(cl_objectfn_fixed c_function, cl_object name, cl_object cblock, int narg) { cl_object cf; cf = ecl_alloc_object(t_cfunfixed); cf->cfunfixed.entry = dispatch_table[narg]; cf->cfunfixed.entry_fixed = c_function; cf->cfunfixed.name = name; cf->cfunfixed.block = cblock; cf->cfunfixed.file = ECL_NIL; cf->cfunfixed.file_position = ecl_make_fixnum(-1); cf->cfunfixed.narg = narg; if (ecl_unlikely(narg < 0 || narg > ECL_C_ARGUMENTS_LIMIT)) FEprogram_error_noreturn("ecl_make_cfun: function requires " "too many arguments.",0); return cf; } cl_object ecl_make_cfun_va(cl_objectfn c_function, cl_object name, cl_object cblock) { cl_object cf; cf = ecl_alloc_object(t_cfun); cf->cfun.entry = c_function; cf->cfun.name = name; cf->cfun.block = cblock; cf->cfun.narg = -1; cf->cfun.file = ECL_NIL; cf->cfun.file_position = ecl_make_fixnum(-1); return cf; } cl_object ecl_make_cclosure_va(cl_objectfn c_function, cl_object env, cl_object block) { cl_object cc; cc = ecl_alloc_object(t_cclosure); cc->cclosure.entry = c_function; cc->cclosure.env = env; cc->cclosure.block = block; cc->cclosure.file = ECL_NIL; cc->cclosure.file_position = ecl_make_fixnum(-1); return cc; } void ecl_def_c_function(cl_object sym, cl_objectfn_fixed c_function, int narg) { si_fset(2, sym, ecl_make_cfun(c_function, sym, ecl_symbol_value(@'si::*cblock*'), narg)); } void ecl_def_c_macro(cl_object sym, cl_objectfn_fixed c_function, int narg) { si_fset(3, sym, ecl_make_cfun(c_function, sym, ecl_symbol_value(@'si::*cblock*'), 2), ECL_T); } void ecl_def_c_macro_va(cl_object sym, cl_objectfn c_function) { si_fset(3, sym, ecl_make_cfun_va(c_function, sym, ecl_symbol_value(@'si::*cblock*')), ECL_T); } void ecl_def_c_function_va(cl_object sym, cl_objectfn c_function) { si_fset(2, sym, ecl_make_cfun_va(c_function, sym, ecl_symbol_value(@'si::*cblock*'))); } cl_object si_compiled_function_name(cl_object fun) { cl_env_ptr the_env = ecl_process_env(); cl_object output; switch(ecl_t_of(fun)) { case t_bclosure: fun = fun->bclosure.code; case t_bytecodes: output = fun->bytecodes.name; break; case t_cfun: case t_cfunfixed: output = fun->cfun.name; break; case t_cclosure: output = ECL_NIL; break; default: FEinvalid_function(fun); } ecl_return1(the_env, output); } cl_object cl_function_lambda_expression(cl_object fun) { cl_env_ptr the_env = ecl_process_env(); cl_object output, name = ECL_NIL, lex = ECL_NIL; switch(ecl_t_of(fun)) { case t_bclosure: lex = fun->bclosure.lex; fun = fun->bclosure.code; case t_bytecodes: name = fun->bytecodes.name; output = fun->bytecodes.definition; if (name == ECL_NIL) output = cl_cons(@'lambda', output); else if (name != @'si::bytecodes') output = @list*(3, @'ext::lambda-block', name, output); break; case t_cfun: case t_cfunfixed: name = fun->cfun.name; lex = ECL_NIL; output = ECL_NIL; break; case t_cclosure: name = ECL_NIL; lex = ECL_T; output = ECL_NIL; break; case t_instance: if (fun->instance.isgf) { name = ECL_NIL; lex = ECL_NIL; output = ECL_NIL; break; } default: FEinvalid_function(fun); } ecl_return3(the_env, output, lex, name); } cl_object si_compiled_function_block(cl_object fun) { cl_object output; switch(ecl_t_of(fun)) { case t_cfun: output = fun->cfun.block; break; case t_cfunfixed: output = fun->cfunfixed.block; break; case t_cclosure: output = fun->cclosure.block; break; default: FEerror("~S is not a C compiled function.", 1, fun); } @(return output) } cl_object si_compiled_function_file(cl_object b) { cl_env_ptr the_env = ecl_process_env(); BEGIN: switch (ecl_t_of(b)) { case t_bclosure: b = b->bclosure.code; goto BEGIN; case t_bytecodes: ecl_return2(the_env, b->bytecodes.file, b->bytecodes.file_position); case t_cfun: ecl_return2(the_env, b->cfun.file, b->cfun.file_position); case t_cfunfixed: ecl_return2(the_env, b->cfunfixed.file, b->cfunfixed.file_position); case t_cclosure: ecl_return2(the_env, b->cclosure.file, b->cclosure.file_position); default: ecl_return2(the_env, ECL_NIL, ECL_NIL); } } void ecl_set_function_source_file_info(cl_object b, cl_object source, cl_object position) { BEGIN: switch (ecl_t_of(b)) { case t_bclosure: b = b->bclosure.code; goto BEGIN; case t_bytecodes: b->bytecodes.file = source; b->bytecodes.file_position = position; break; case t_cfun: b->cfun.file = source; b->cfun.file_position = position; break; case t_cfunfixed: b->cfunfixed.file = source; b->cfunfixed.file_position = position; break; case t_cclosure: b->cclosure.file = source; b->cclosure.file_position = position; break; default: FEerror("~S is not a compiled function.", 1, b); } } void ecl_cmp_defmacro(cl_object fun) { si_fset(3, fun->cfun.name, fun, ECL_T); } void ecl_cmp_defun(cl_object fun) { si_fset(2, fun->cfun.name, fun); } ecl-16.1.2/src/c/cfun_dispatch.d000066400000000000000000001547061266352375300163650ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* cfun_dispatch.c -- Trampolines for functions */ static cl_object dispatch0 (cl_narg narg) { const cl_env_ptr the_env = ecl_process_env(); cl_object fun = the_env->function; if (ecl_unlikely(narg != 0)) FEwrong_num_arguments(fun); return fun->cfunfixed.entry_fixed(); } static cl_object dispatch1 (cl_narg narg, cl_object x0) { const cl_env_ptr the_env = ecl_process_env(); cl_object fun = the_env->function; if (ecl_unlikely(narg != 1)) FEwrong_num_arguments(fun); return fun->cfunfixed.entry_fixed(x0); } static cl_object dispatch2 (cl_narg narg, cl_object x0, cl_object x1) { const cl_env_ptr the_env = ecl_process_env(); cl_object fun = the_env->function; if (ecl_unlikely(narg != 2)) FEwrong_num_arguments(fun); return fun->cfunfixed.entry_fixed(x0, x1); } static cl_object dispatch3 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2) { const cl_env_ptr the_env = ecl_process_env(); cl_object fun = the_env->function; if (ecl_unlikely(narg != 3)) FEwrong_num_arguments(fun); return fun->cfunfixed.entry_fixed(x0, x1, x2); } static cl_object dispatch4 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3) { const cl_env_ptr the_env = ecl_process_env(); cl_object fun = the_env->function; if (ecl_unlikely(narg != 4)) FEwrong_num_arguments(fun); return fun->cfunfixed.entry_fixed(x0, x1, x2, x3); } static cl_object dispatch5 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4) { const cl_env_ptr the_env = ecl_process_env(); cl_object fun = the_env->function; if (ecl_unlikely(narg != 5)) FEwrong_num_arguments(fun); return fun->cfunfixed.entry_fixed(x0, x1, x2, x3, x4); } static cl_object dispatch6 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5) { const cl_env_ptr the_env = ecl_process_env(); cl_object fun = the_env->function; if (ecl_unlikely(narg != 6)) FEwrong_num_arguments(fun); return fun->cfunfixed.entry_fixed(x0, x1, x2, x3, x4, x5); } static cl_object dispatch7 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6) { const cl_env_ptr the_env = ecl_process_env(); cl_object fun = the_env->function; if (ecl_unlikely(narg != 7)) FEwrong_num_arguments(fun); return fun->cfunfixed.entry_fixed(x0, x1, x2, x3, x4, x5, x6); } static cl_object dispatch8 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7) { const cl_env_ptr the_env = ecl_process_env(); cl_object fun = the_env->function; if (ecl_unlikely(narg != 8)) FEwrong_num_arguments(fun); return fun->cfunfixed.entry_fixed(x0, x1, x2, x3, x4, x5, x6, x7); } static cl_object dispatch9 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8) { const cl_env_ptr the_env = ecl_process_env(); cl_object fun = the_env->function; if (ecl_unlikely(narg != 9)) FEwrong_num_arguments(fun); return fun->cfunfixed.entry_fixed(x0, x1, x2, x3, x4, x5, x6, x7, x8); } static cl_object dispatch10 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9) { const cl_env_ptr the_env = ecl_process_env(); cl_object fun = the_env->function; if (ecl_unlikely(narg != 10)) FEwrong_num_arguments(fun); return fun->cfunfixed.entry_fixed(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9); } static cl_object dispatch11 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10) { const cl_env_ptr the_env = ecl_process_env(); cl_object fun = the_env->function; if (ecl_unlikely(narg != 11)) FEwrong_num_arguments(fun); return fun->cfunfixed.entry_fixed(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10); } static cl_object dispatch12 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11) { const cl_env_ptr the_env = ecl_process_env(); cl_object fun = the_env->function; if (ecl_unlikely(narg != 12)) FEwrong_num_arguments(fun); return fun->cfunfixed.entry_fixed(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11); } static cl_object dispatch13 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12) { const cl_env_ptr the_env = ecl_process_env(); cl_object fun = the_env->function; if (ecl_unlikely(narg != 13)) FEwrong_num_arguments(fun); return fun->cfunfixed.entry_fixed(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12); } static cl_object dispatch14 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13) { const cl_env_ptr the_env = ecl_process_env(); cl_object fun = the_env->function; if (ecl_unlikely(narg != 14)) FEwrong_num_arguments(fun); return fun->cfunfixed.entry_fixed(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13); } static cl_object dispatch15 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14) { const cl_env_ptr the_env = ecl_process_env(); cl_object fun = the_env->function; if (ecl_unlikely(narg != 15)) FEwrong_num_arguments(fun); return fun->cfunfixed.entry_fixed(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14); } static cl_object dispatch16 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15) { const cl_env_ptr the_env = ecl_process_env(); cl_object fun = the_env->function; if (ecl_unlikely(narg != 16)) FEwrong_num_arguments(fun); return fun->cfunfixed.entry_fixed(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15); } static cl_object dispatch17 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16) { const cl_env_ptr the_env = ecl_process_env(); cl_object fun = the_env->function; if (ecl_unlikely(narg != 17)) FEwrong_num_arguments(fun); return fun->cfunfixed.entry_fixed(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16); } static cl_object dispatch18 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17) { const cl_env_ptr the_env = ecl_process_env(); cl_object fun = the_env->function; if (ecl_unlikely(narg != 18)) FEwrong_num_arguments(fun); return fun->cfunfixed.entry_fixed(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17); } static cl_object dispatch19 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18) { const cl_env_ptr the_env = ecl_process_env(); cl_object fun = the_env->function; if (ecl_unlikely(narg != 19)) FEwrong_num_arguments(fun); return fun->cfunfixed.entry_fixed(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18); } static cl_object dispatch20 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19) { const cl_env_ptr the_env = ecl_process_env(); cl_object fun = the_env->function; if (ecl_unlikely(narg != 20)) FEwrong_num_arguments(fun); return fun->cfunfixed.entry_fixed(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19); } static cl_object dispatch21 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20) { const cl_env_ptr the_env = ecl_process_env(); cl_object fun = the_env->function; if (ecl_unlikely(narg != 21)) FEwrong_num_arguments(fun); return fun->cfunfixed.entry_fixed(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20); } static cl_object dispatch22 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21) { const cl_env_ptr the_env = ecl_process_env(); cl_object fun = the_env->function; if (ecl_unlikely(narg != 22)) FEwrong_num_arguments(fun); return fun->cfunfixed.entry_fixed(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21); } static cl_object dispatch23 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22) { const cl_env_ptr the_env = ecl_process_env(); cl_object fun = the_env->function; if (ecl_unlikely(narg != 23)) FEwrong_num_arguments(fun); return fun->cfunfixed.entry_fixed(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22); } static cl_object dispatch24 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23) { const cl_env_ptr the_env = ecl_process_env(); cl_object fun = the_env->function; if (ecl_unlikely(narg != 24)) FEwrong_num_arguments(fun); return fun->cfunfixed.entry_fixed(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23); } static cl_object dispatch25 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24) { const cl_env_ptr the_env = ecl_process_env(); cl_object fun = the_env->function; if (ecl_unlikely(narg != 25)) FEwrong_num_arguments(fun); return fun->cfunfixed.entry_fixed(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24); } static cl_object dispatch26 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25) { const cl_env_ptr the_env = ecl_process_env(); cl_object fun = the_env->function; if (ecl_unlikely(narg != 26)) FEwrong_num_arguments(fun); return fun->cfunfixed.entry_fixed(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25); } static cl_object dispatch27 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26) { const cl_env_ptr the_env = ecl_process_env(); cl_object fun = the_env->function; if (ecl_unlikely(narg != 27)) FEwrong_num_arguments(fun); return fun->cfunfixed.entry_fixed(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26); } static cl_object dispatch28 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27) { const cl_env_ptr the_env = ecl_process_env(); cl_object fun = the_env->function; if (ecl_unlikely(narg != 28)) FEwrong_num_arguments(fun); return fun->cfunfixed.entry_fixed(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27); } static cl_object dispatch29 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28) { const cl_env_ptr the_env = ecl_process_env(); cl_object fun = the_env->function; if (ecl_unlikely(narg != 29)) FEwrong_num_arguments(fun); return fun->cfunfixed.entry_fixed(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28); } static cl_object dispatch30 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29) { const cl_env_ptr the_env = ecl_process_env(); cl_object fun = the_env->function; if (ecl_unlikely(narg != 30)) FEwrong_num_arguments(fun); return fun->cfunfixed.entry_fixed(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29); } static cl_object dispatch31 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30) { const cl_env_ptr the_env = ecl_process_env(); cl_object fun = the_env->function; if (ecl_unlikely(narg != 31)) FEwrong_num_arguments(fun); return fun->cfunfixed.entry_fixed(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30); } static cl_object dispatch32 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31) { const cl_env_ptr the_env = ecl_process_env(); cl_object fun = the_env->function; if (ecl_unlikely(narg != 32)) FEwrong_num_arguments(fun); return fun->cfunfixed.entry_fixed(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31); } static cl_object dispatch33 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32) { const cl_env_ptr the_env = ecl_process_env(); cl_object fun = the_env->function; if (ecl_unlikely(narg != 33)) FEwrong_num_arguments(fun); return fun->cfunfixed.entry_fixed(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32); } static cl_object dispatch34 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33) { const cl_env_ptr the_env = ecl_process_env(); cl_object fun = the_env->function; if (ecl_unlikely(narg != 34)) FEwrong_num_arguments(fun); return fun->cfunfixed.entry_fixed(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33); } static cl_object dispatch35 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34) { const cl_env_ptr the_env = ecl_process_env(); cl_object fun = the_env->function; if (ecl_unlikely(narg != 35)) FEwrong_num_arguments(fun); return fun->cfunfixed.entry_fixed(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34); } static cl_object dispatch36 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35) { const cl_env_ptr the_env = ecl_process_env(); cl_object fun = the_env->function; if (ecl_unlikely(narg != 36)) FEwrong_num_arguments(fun); return fun->cfunfixed.entry_fixed(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35); } static cl_object dispatch37 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36) { const cl_env_ptr the_env = ecl_process_env(); cl_object fun = the_env->function; if (ecl_unlikely(narg != 37)) FEwrong_num_arguments(fun); return fun->cfunfixed.entry_fixed(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36); } static cl_object dispatch38 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37) { const cl_env_ptr the_env = ecl_process_env(); cl_object fun = the_env->function; if (ecl_unlikely(narg != 38)) FEwrong_num_arguments(fun); return fun->cfunfixed.entry_fixed(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37); } static cl_object dispatch39 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38) { const cl_env_ptr the_env = ecl_process_env(); cl_object fun = the_env->function; if (ecl_unlikely(narg != 39)) FEwrong_num_arguments(fun); return fun->cfunfixed.entry_fixed(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38); } static cl_object dispatch40 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39) { const cl_env_ptr the_env = ecl_process_env(); cl_object fun = the_env->function; if (ecl_unlikely(narg != 40)) FEwrong_num_arguments(fun); return fun->cfunfixed.entry_fixed(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39); } static cl_object dispatch41 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39, cl_object x40) { const cl_env_ptr the_env = ecl_process_env(); cl_object fun = the_env->function; if (ecl_unlikely(narg != 41)) FEwrong_num_arguments(fun); return fun->cfunfixed.entry_fixed(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40); } static cl_object dispatch42 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39, cl_object x40, cl_object x41) { const cl_env_ptr the_env = ecl_process_env(); cl_object fun = the_env->function; if (ecl_unlikely(narg != 42)) FEwrong_num_arguments(fun); return fun->cfunfixed.entry_fixed(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41); } static cl_object dispatch43 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39, cl_object x40, cl_object x41, cl_object x42) { const cl_env_ptr the_env = ecl_process_env(); cl_object fun = the_env->function; if (ecl_unlikely(narg != 43)) FEwrong_num_arguments(fun); return fun->cfunfixed.entry_fixed(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42); } static cl_object dispatch44 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39, cl_object x40, cl_object x41, cl_object x42, cl_object x43) { const cl_env_ptr the_env = ecl_process_env(); cl_object fun = the_env->function; if (ecl_unlikely(narg != 44)) FEwrong_num_arguments(fun); return fun->cfunfixed.entry_fixed(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43); } static cl_object dispatch45 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39, cl_object x40, cl_object x41, cl_object x42, cl_object x43, cl_object x44) { const cl_env_ptr the_env = ecl_process_env(); cl_object fun = the_env->function; if (ecl_unlikely(narg != 45)) FEwrong_num_arguments(fun); return fun->cfunfixed.entry_fixed(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44); } static cl_object dispatch46 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39, cl_object x40, cl_object x41, cl_object x42, cl_object x43, cl_object x44, cl_object x45) { const cl_env_ptr the_env = ecl_process_env(); cl_object fun = the_env->function; if (ecl_unlikely(narg != 46)) FEwrong_num_arguments(fun); return fun->cfunfixed.entry_fixed(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45); } static cl_object dispatch47 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39, cl_object x40, cl_object x41, cl_object x42, cl_object x43, cl_object x44, cl_object x45, cl_object x46) { const cl_env_ptr the_env = ecl_process_env(); cl_object fun = the_env->function; if (ecl_unlikely(narg != 47)) FEwrong_num_arguments(fun); return fun->cfunfixed.entry_fixed(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46); } static cl_object dispatch48 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39, cl_object x40, cl_object x41, cl_object x42, cl_object x43, cl_object x44, cl_object x45, cl_object x46, cl_object x47) { const cl_env_ptr the_env = ecl_process_env(); cl_object fun = the_env->function; if (ecl_unlikely(narg != 48)) FEwrong_num_arguments(fun); return fun->cfunfixed.entry_fixed(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47); } static cl_object dispatch49 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39, cl_object x40, cl_object x41, cl_object x42, cl_object x43, cl_object x44, cl_object x45, cl_object x46, cl_object x47, cl_object x48) { const cl_env_ptr the_env = ecl_process_env(); cl_object fun = the_env->function; if (ecl_unlikely(narg != 49)) FEwrong_num_arguments(fun); return fun->cfunfixed.entry_fixed(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48); } static cl_object dispatch50 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39, cl_object x40, cl_object x41, cl_object x42, cl_object x43, cl_object x44, cl_object x45, cl_object x46, cl_object x47, cl_object x48, cl_object x49) { const cl_env_ptr the_env = ecl_process_env(); cl_object fun = the_env->function; if (ecl_unlikely(narg != 50)) FEwrong_num_arguments(fun); return fun->cfunfixed.entry_fixed(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49); } static cl_object dispatch51 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39, cl_object x40, cl_object x41, cl_object x42, cl_object x43, cl_object x44, cl_object x45, cl_object x46, cl_object x47, cl_object x48, cl_object x49, cl_object x50) { const cl_env_ptr the_env = ecl_process_env(); cl_object fun = the_env->function; if (ecl_unlikely(narg != 51)) FEwrong_num_arguments(fun); return fun->cfunfixed.entry_fixed(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50); } static cl_object dispatch52 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39, cl_object x40, cl_object x41, cl_object x42, cl_object x43, cl_object x44, cl_object x45, cl_object x46, cl_object x47, cl_object x48, cl_object x49, cl_object x50, cl_object x51) { const cl_env_ptr the_env = ecl_process_env(); cl_object fun = the_env->function; if (ecl_unlikely(narg != 52)) FEwrong_num_arguments(fun); return fun->cfunfixed.entry_fixed(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51); } static cl_object dispatch53 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39, cl_object x40, cl_object x41, cl_object x42, cl_object x43, cl_object x44, cl_object x45, cl_object x46, cl_object x47, cl_object x48, cl_object x49, cl_object x50, cl_object x51, cl_object x52) { const cl_env_ptr the_env = ecl_process_env(); cl_object fun = the_env->function; if (ecl_unlikely(narg != 53)) FEwrong_num_arguments(fun); return fun->cfunfixed.entry_fixed(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52); } static cl_object dispatch54 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39, cl_object x40, cl_object x41, cl_object x42, cl_object x43, cl_object x44, cl_object x45, cl_object x46, cl_object x47, cl_object x48, cl_object x49, cl_object x50, cl_object x51, cl_object x52, cl_object x53) { const cl_env_ptr the_env = ecl_process_env(); cl_object fun = the_env->function; if (ecl_unlikely(narg != 54)) FEwrong_num_arguments(fun); return fun->cfunfixed.entry_fixed(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53); } static cl_object dispatch55 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39, cl_object x40, cl_object x41, cl_object x42, cl_object x43, cl_object x44, cl_object x45, cl_object x46, cl_object x47, cl_object x48, cl_object x49, cl_object x50, cl_object x51, cl_object x52, cl_object x53, cl_object x54) { const cl_env_ptr the_env = ecl_process_env(); cl_object fun = the_env->function; if (ecl_unlikely(narg != 55)) FEwrong_num_arguments(fun); return fun->cfunfixed.entry_fixed(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54); } static cl_object dispatch56 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39, cl_object x40, cl_object x41, cl_object x42, cl_object x43, cl_object x44, cl_object x45, cl_object x46, cl_object x47, cl_object x48, cl_object x49, cl_object x50, cl_object x51, cl_object x52, cl_object x53, cl_object x54, cl_object x55) { const cl_env_ptr the_env = ecl_process_env(); cl_object fun = the_env->function; if (ecl_unlikely(narg != 56)) FEwrong_num_arguments(fun); return fun->cfunfixed.entry_fixed(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55); } static cl_object dispatch57 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39, cl_object x40, cl_object x41, cl_object x42, cl_object x43, cl_object x44, cl_object x45, cl_object x46, cl_object x47, cl_object x48, cl_object x49, cl_object x50, cl_object x51, cl_object x52, cl_object x53, cl_object x54, cl_object x55, cl_object x56) { const cl_env_ptr the_env = ecl_process_env(); cl_object fun = the_env->function; if (ecl_unlikely(narg != 57)) FEwrong_num_arguments(fun); return fun->cfunfixed.entry_fixed(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56); } static cl_object dispatch58 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39, cl_object x40, cl_object x41, cl_object x42, cl_object x43, cl_object x44, cl_object x45, cl_object x46, cl_object x47, cl_object x48, cl_object x49, cl_object x50, cl_object x51, cl_object x52, cl_object x53, cl_object x54, cl_object x55, cl_object x56, cl_object x57) { const cl_env_ptr the_env = ecl_process_env(); cl_object fun = the_env->function; if (ecl_unlikely(narg != 58)) FEwrong_num_arguments(fun); return fun->cfunfixed.entry_fixed(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57); } static cl_object dispatch59 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39, cl_object x40, cl_object x41, cl_object x42, cl_object x43, cl_object x44, cl_object x45, cl_object x46, cl_object x47, cl_object x48, cl_object x49, cl_object x50, cl_object x51, cl_object x52, cl_object x53, cl_object x54, cl_object x55, cl_object x56, cl_object x57, cl_object x58) { const cl_env_ptr the_env = ecl_process_env(); cl_object fun = the_env->function; if (ecl_unlikely(narg != 59)) FEwrong_num_arguments(fun); return fun->cfunfixed.entry_fixed(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58); } static cl_object dispatch60 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39, cl_object x40, cl_object x41, cl_object x42, cl_object x43, cl_object x44, cl_object x45, cl_object x46, cl_object x47, cl_object x48, cl_object x49, cl_object x50, cl_object x51, cl_object x52, cl_object x53, cl_object x54, cl_object x55, cl_object x56, cl_object x57, cl_object x58, cl_object x59) { const cl_env_ptr the_env = ecl_process_env(); cl_object fun = the_env->function; if (ecl_unlikely(narg != 60)) FEwrong_num_arguments(fun); return fun->cfunfixed.entry_fixed(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58, x59); } static cl_object dispatch61 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39, cl_object x40, cl_object x41, cl_object x42, cl_object x43, cl_object x44, cl_object x45, cl_object x46, cl_object x47, cl_object x48, cl_object x49, cl_object x50, cl_object x51, cl_object x52, cl_object x53, cl_object x54, cl_object x55, cl_object x56, cl_object x57, cl_object x58, cl_object x59, cl_object x60) { const cl_env_ptr the_env = ecl_process_env(); cl_object fun = the_env->function; if (ecl_unlikely(narg != 61)) FEwrong_num_arguments(fun); return fun->cfunfixed.entry_fixed(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58, x59, x60); } static cl_object dispatch62 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39, cl_object x40, cl_object x41, cl_object x42, cl_object x43, cl_object x44, cl_object x45, cl_object x46, cl_object x47, cl_object x48, cl_object x49, cl_object x50, cl_object x51, cl_object x52, cl_object x53, cl_object x54, cl_object x55, cl_object x56, cl_object x57, cl_object x58, cl_object x59, cl_object x60, cl_object x61) { const cl_env_ptr the_env = ecl_process_env(); cl_object fun = the_env->function; if (ecl_unlikely(narg != 62)) FEwrong_num_arguments(fun); return fun->cfunfixed.entry_fixed(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58, x59, x60, x61); } static cl_object dispatch63 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39, cl_object x40, cl_object x41, cl_object x42, cl_object x43, cl_object x44, cl_object x45, cl_object x46, cl_object x47, cl_object x48, cl_object x49, cl_object x50, cl_object x51, cl_object x52, cl_object x53, cl_object x54, cl_object x55, cl_object x56, cl_object x57, cl_object x58, cl_object x59, cl_object x60, cl_object x61, cl_object x62) { const cl_env_ptr the_env = ecl_process_env(); cl_object fun = the_env->function; if (ecl_unlikely(narg != 63)) FEwrong_num_arguments(fun); return fun->cfunfixed.entry_fixed(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58, x59, x60, x61, x62); } static cl_objectfn dispatch_table[ECL_C_ARGUMENTS_LIMIT+1] = { (cl_objectfn)dispatch0, (cl_objectfn)dispatch1, (cl_objectfn)dispatch2, (cl_objectfn)dispatch3, (cl_objectfn)dispatch4, (cl_objectfn)dispatch5, (cl_objectfn)dispatch6, (cl_objectfn)dispatch7, (cl_objectfn)dispatch8, (cl_objectfn)dispatch9, (cl_objectfn)dispatch10, (cl_objectfn)dispatch11, (cl_objectfn)dispatch12, (cl_objectfn)dispatch13, (cl_objectfn)dispatch14, (cl_objectfn)dispatch15, (cl_objectfn)dispatch16, (cl_objectfn)dispatch17, (cl_objectfn)dispatch18, (cl_objectfn)dispatch19, (cl_objectfn)dispatch20, (cl_objectfn)dispatch21, (cl_objectfn)dispatch22, (cl_objectfn)dispatch23, (cl_objectfn)dispatch24, (cl_objectfn)dispatch25, (cl_objectfn)dispatch26, (cl_objectfn)dispatch27, (cl_objectfn)dispatch28, (cl_objectfn)dispatch29, (cl_objectfn)dispatch30, (cl_objectfn)dispatch31, (cl_objectfn)dispatch32, (cl_objectfn)dispatch33, (cl_objectfn)dispatch34, (cl_objectfn)dispatch35, (cl_objectfn)dispatch36, (cl_objectfn)dispatch37, (cl_objectfn)dispatch38, (cl_objectfn)dispatch39, (cl_objectfn)dispatch40, (cl_objectfn)dispatch41, (cl_objectfn)dispatch42, (cl_objectfn)dispatch43, (cl_objectfn)dispatch44, (cl_objectfn)dispatch45, (cl_objectfn)dispatch46, (cl_objectfn)dispatch47, (cl_objectfn)dispatch48, (cl_objectfn)dispatch49, (cl_objectfn)dispatch50, (cl_objectfn)dispatch51, (cl_objectfn)dispatch52, (cl_objectfn)dispatch53, (cl_objectfn)dispatch54, (cl_objectfn)dispatch55, (cl_objectfn)dispatch56, (cl_objectfn)dispatch57, (cl_objectfn)dispatch58, (cl_objectfn)dispatch59, (cl_objectfn)dispatch60, (cl_objectfn)dispatch61, (cl_objectfn)dispatch62, (cl_objectfn)dispatch63}; ecl-16.1.2/src/c/char_ctype.d000066400000000000000000000073171266352375300156670ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* char_ctype.d -- Character properties. */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2015, Daniel KochmaХ„ski. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #ifndef ECL_UNICODE #include bool ecl_graphic_char_p(ecl_character code) { return code == ' ' || isgraph(code); } bool ecl_alpha_char_p(ecl_character code) { return isalpha(code); } bool ecl_upper_case_p(ecl_character code) { return isupper(code); } bool ecl_lower_case_p(ecl_character code) { return islower(code); } bool ecl_both_case_p(ecl_character code) { return islower(code) || isupper(code); } bool ecl_alphanumericp(ecl_character i) { return isalnum(i); } ecl_character ecl_char_upcase(ecl_character code) { return toupper(code); } ecl_character ecl_char_downcase(ecl_character code) { return tolower(code); } #else /* ECL_UNICODE */ extern const unsigned char ecl_ucd_misc_table[]; extern const unsigned char *ecl_ucd_page_table[]; extern const unsigned char ecl_ucd_page_table_1[]; /* * 21-bits Unicode (0 to #x110000 char codes) */ #if ECL_UNICODE > 16 const unsigned char * ucd_char_data(ecl_character code) { const unsigned char *page = ecl_ucd_page_table[code >> 8]; return page + (4 * (code & 0xFF)); } static cl_index ucd_value_0(ecl_character code) { if (ecl_unlikely((code >= 0x110000))) FEerror("The value ~A is not of type (MOD 1114112)", 1, code); return ucd_char_data(code)[0]; } #define read_case_bytes(c) (c[1] + (c[2] << 8) + (c[3] << 16)) #endif /* * 16-bits Unicode (0 to #x110000 char codes) * Each character occupies 3 bytes */ #if ECL_UNICODE <= 16 const unsigned char * ucd_char_data(ecl_character code) { const unsigned char *page = ecl_ucd_page_table[code >> 8]; return page + (3 * (code & 0xFF)); } static cl_index ucd_value_0(ecl_character code) { return ucd_char_data(code)[0]; } #define read_case_bytes(c) (c[1] + (c[2] << 8)) #endif static int ucd_general_category(ecl_character code) { return ecl_ucd_misc_table[8 * ucd_value_0(code)]; } static int ucd_decimal_digit(ecl_character code) { return ecl_ucd_misc_table[3 + 8 * ucd_value_0(code)]; } bool ecl_graphic_char_p(ecl_character code) { /* compatible to SBCL */ return code > 159 || ((31 < code) && (code < 127)); } bool ecl_alpha_char_p(ecl_character code) { return ucd_general_category(code) < 5; } bool ecl_upper_case_p(ecl_character code) { return ucd_value_0(code) == 0; } bool ecl_lower_case_p(ecl_character code) { return ucd_value_0(code) == 1; } bool ecl_both_case_p(ecl_character code) { return ucd_value_0(code) < 2; } bool ecl_alphanumericp(ecl_character i) { int gc = ucd_general_category(i); return (gc < 5) || (gc == 12); } ecl_character ecl_char_upcase(ecl_character code) { const unsigned char *c = ucd_char_data(code); if (c[0] == 1) { return read_case_bytes(c); } else { return code; } } ecl_character ecl_char_downcase(ecl_character code) { const unsigned char *c = ucd_char_data(code); if (c[0] == 0) { return read_case_bytes(c); } else { return code; } } #endif ecl-16.1.2/src/c/character.d000066400000000000000000000362251266352375300155020ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* character.d -- Character routines. */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2015, Daniel KochmaХ„ski. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #include #include "char_ctype.d" ecl_character ecl_char_code(cl_object c) { if (ecl_unlikely(!ECL_CHARACTERP(c))) FEwrong_type_only_arg(@[char-code], c, @[character]); return ECL_CHAR_CODE(c); } ecl_base_char ecl_base_char_code(cl_object c) { #ifdef ECL_UNICODE if (ECL_CHARACTERP(c)) { cl_fixnum code = ECL_CHAR_CODE(c); if (code <= 255) { return (int)code; } } FEwrong_type_only_arg(@[char-code], c, @[base-char]); #else return ecl_char_code(c); #endif } cl_object cl_standard_char_p(cl_object c) { /* INV: ecl_char_code() checks the type */ cl_fixnum i = ecl_char_code(c); @(return (ecl_standard_char_p(i)? ECL_T : ECL_NIL)) } bool ecl_standard_char_p(ecl_character code) { return ((' ' <= code) && (code < '\177')) || (code == '\n'); } bool ecl_base_char_p(ecl_character c) { return c <= 255; } cl_object cl_graphic_char_p(cl_object c) { /* INV: ecl_char_code() checks the type */ @(return (ecl_graphic_char_p(ecl_char_code(c))? ECL_T : ECL_NIL)) } cl_object cl_alpha_char_p(cl_object c) { /* INV: ecl_char_code() checks the type */ @(return (ecl_alpha_char_p(ecl_char_code(c))? ECL_T : ECL_NIL)) } cl_object cl_upper_case_p(cl_object c) { /* INV: ecl_char_code() checks the type */ @(return (ecl_upper_case_p(ecl_char_code(c))? ECL_T : ECL_NIL)) } cl_object cl_lower_case_p(cl_object c) { /* INV: ecl_char_code() checks the type */ @(return (ecl_lower_case_p(ecl_char_code(c))? ECL_T : ECL_NIL)) } cl_object cl_both_case_p(cl_object c) { /* INV: ecl_char_code() checks the type */ @(return (ecl_both_case_p(ecl_char_code(c))? ECL_T : ECL_NIL)) } int ecl_string_case(cl_object s) { int upcase; cl_index i; ecl_base_char *text; switch (ecl_t_of(s)) { #ifdef ECL_UNICODE case t_string: s = si_coerce_to_base_string(s); #endif case t_base_string: text = (ecl_base_char*)s->base_string.self; for (i = 0, upcase = 0; i < s->base_string.dim; i++) { if (ecl_upper_case_p(text[i])) { if (upcase < 0) return 0; upcase = +1; } else if (ecl_lower_case_p(text[i])) { if (upcase > 0) return 0; upcase = -1; } } break; default: FEwrong_type_argument(@[string], s); } return upcase; } @(defun digit_char_p (c &optional (radix ecl_make_fixnum(10))) @ { cl_fixnum basis, value; if (ecl_unlikely(!ECL_FIXNUMP(radix) || ecl_fixnum_lower(radix, ecl_make_fixnum(2)) || ecl_fixnum_greater(radix, ecl_make_fixnum(36)))) { FEwrong_type_nth_arg(@[digit-char-p], 2, radix, ecl_make_integer_type(ecl_make_fixnum(2), ecl_make_fixnum(36))); } basis = ecl_fixnum(radix); value = ecl_digitp(ecl_char_code(c), basis); @(return ((value < 0)? ECL_NIL: ecl_make_fixnum(value))); } @) /* Ecl_Digitp(i, r) returns the weight of code i as a digit of radix r, which must be 1 < r <= 36. If i is not a digit, -1 is returned. */ int ecl_digitp(ecl_character i, int r) { if (('0' <= i) && (i <= '9') && (i < '0' + r)) return i - '0'; if (('A' <= i) && (10 < r) && (i < 'A' + (r - 10))) return i - 'A' + 10; if (('a' <= i) && (10 < r) && (i < 'a' + (r - 10))) return i - 'a' + 10; #ifdef ECL_UNICODE if (i > 255) { int number = ucd_decimal_digit(i); if (number < r) return number; } #endif return -1; } cl_object cl_alphanumericp(cl_object c) { /* INV: ecl_char_code() checks type of `c' */ cl_fixnum i = ecl_char_code(c); @(return (ecl_alphanumericp(i)? ECL_T : ECL_NIL)) } @(defun char= (c &rest cs) @ /* INV: ecl_char_eq() checks types of `c' and `cs' */ while (--narg) if (!ecl_char_eq(c, ecl_va_arg(cs))) @(return ECL_NIL) @(return ECL_T) @) bool ecl_char_eq(cl_object x, cl_object y) { return ecl_char_code(x) == ecl_char_code(y); } @(defun char/= (&rest cs) int i, j; cl_object c; @ /* INV: ecl_char_eq() checks types of its arguments */ if (narg == 0) FEwrong_num_arguments(@[char/=]); c = ecl_va_arg(cs); for (i = 2; i<=narg; i++) { ecl_va_list ds; ecl_va_start(ds, narg, narg, 0); c = ecl_va_arg(cs); for (j = 1; j (&rest args) @ return Lchar_cmp(the_env, narg,-1, 1, args); @) @(defun char<= (&rest args) @ return Lchar_cmp(the_env, narg, 1, 0, args); @) @(defun char>= (&rest args) @ return Lchar_cmp(the_env, narg,-1, 0, args); @) @(defun char_equal (c &rest cs) int i; @ /* INV: ecl_char_equal() checks the type of its arguments */ for (narg--, i = 0; i < narg; i++) { if (!ecl_char_equal(c, ecl_va_arg(cs))) @(return ECL_NIL) } @(return ECL_T) @) #define char_equal_code(x) ecl_char_upcase(ecl_char_code(x)) bool ecl_char_equal(cl_object x, cl_object y) { return char_equal_code(x) == char_equal_code(y); } @(defun char-not-equal (&rest cs) int i, j; cl_object c; @ /* INV: ecl_char_equal() checks the type of its arguments */ if (narg == 0) FEwrong_num_arguments(@[char-not-equal]); c = ecl_va_arg(cs); for (i = 2; i<=narg; i++) { ecl_va_list ds; ecl_va_start(ds, narg, narg, 0); c = ecl_va_arg(cs); for (j=1; jsymbol.name); #ifdef ECL_UNICODE case t_string: if (x->string.fillp == 1) { x = ECL_CODE_CHAR(x->string.self[0]); break; } goto ERROR; #endif case t_base_string: if (x->base_string.fillp == 1) { x = ECL_CODE_CHAR(x->base_string.self[0]); break; } default: ERROR: FEwrong_type_nth_arg(@[character], 1, x, ecl_read_from_cstring("(OR CHARACTER SYMBOL (ARRAY CHARACTER (1)) (ARRAY BASE-CHAR (1)))")); } @(return x) } cl_object cl_char_code(cl_object c) { /* INV: ecl_char_code() checks the type of `c' */ @(return ecl_make_fixnum(ecl_char_code(c))) } cl_object cl_code_char(cl_object c) { cl_fixnum fc; switch (ecl_t_of(c)) { case t_fixnum: fc = ecl_fixnum(c); if (fc < ECL_CHAR_CODE_LIMIT && fc >= 0) { c = ECL_CODE_CHAR(fc); break; } case t_bignum: c = ECL_NIL; break; default: FEwrong_type_only_arg(@[code-char], c, @[integer]); } @(return c) } cl_object cl_char_upcase(cl_object c) { /* INV: ecl_char_code() checks the type of `c' */ cl_fixnum code = ecl_char_code(c); @(return ECL_CODE_CHAR(ecl_char_upcase(code))) } cl_object cl_char_downcase(cl_object c) { /* INV: ecl_char_code() checks the type of `c' */ cl_fixnum code = ecl_char_code(c); @(return ECL_CODE_CHAR(ecl_char_downcase(code))) } @(defun digit_char (weight &optional (radix ecl_make_fixnum(10))) @ { cl_fixnum basis; cl_object output = ECL_NIL; if (ecl_unlikely(!ECL_FIXNUMP(radix) || ecl_fixnum_lower(radix, ecl_make_fixnum(2)) || ecl_fixnum_greater(radix, ecl_make_fixnum(36)))) { FEwrong_type_nth_arg(@[digit-char], 2, radix, ecl_make_integer_type(ecl_make_fixnum(2), ecl_make_fixnum(36))); } basis = ecl_fixnum(radix); switch (ecl_t_of(weight)) { case t_fixnum: { cl_fixnum value = ecl_fixnum(weight); if (value >= 0) { int dw = ecl_digit_char(value, basis); if (dw >= 0) { output = ECL_CODE_CHAR(dw); } } break; } case t_bignum: break; default: FEwrong_type_nth_arg(@[digit-char],1,weight,@[integer]); } @(return output) } @) short ecl_digit_char(cl_fixnum w, cl_fixnum r) { if (r < 2 || r > 36 || w < 0 || w >= r) return(-1); if (w < 10) return(w + '0'); else return(w - 10 + 'A'); } cl_object cl_char_int(cl_object c) { const cl_env_ptr the_env = ecl_process_env(); /* INV: ecl_char_code() checks the type of `c' */ ecl_return1(the_env, ecl_make_fixnum(ecl_char_code(c))); } /* here we give every character an implicit name of the form 'u#' where # is a hexadecimal number, corresponding to a unicode code point. #\u14ea should work, for example */ cl_object cl_char_name(cl_object c) { ecl_character code = ecl_char_code(c); cl_object output; if (code <= 127) { output = ecl_gethash_safe(ecl_make_fixnum(code), cl_core.char_names, ECL_NIL); } #ifdef ECL_UNICODE_NAMES else if (!Null(output = _ecl_ucd_code_to_name(code))) { (void)0; } #endif else { ecl_base_char name[8]; ecl_base_char *start; name[7] = 0; name[6] = ecl_digit_char(code & 0xF, 16); code >>= 4; name[5] = ecl_digit_char(code & 0xF, 16); code >>= 4; name[4] = ecl_digit_char(code & 0xF, 16); code >>= 4; name[3] = ecl_digit_char(code & 0xF, 16); code >>= 4; if (code == 0) { start = name + 2; } else { name[2] = ecl_digit_char(code & 0xF, 16); code >>= 4; name[1] = ecl_digit_char(code & 0xF, 16); start = name; } start[0] = 'U'; output = make_base_string_copy((const char*)start); } @(return output); } cl_object cl_name_char(cl_object name) { const cl_env_ptr the_env = ecl_process_env(); cl_object c; cl_index l; name = cl_string(name); c = ecl_gethash_safe(name, cl_core.char_names, ECL_NIL); if (c != ECL_NIL) { ecl_return1(the_env, ECL_CODE_CHAR(ecl_fixnum(c))); } #ifdef ECL_UNICODE_NAMES c = _ecl_ucd_name_to_code(name); if (c != ECL_NIL) { ecl_return1(the_env, cl_code_char(c)); } #endif if (ecl_stringp(name) && (l = ecl_length(name))) { c = cl_char(name, ecl_make_fixnum(0)); if (l == 1) { (void)0; } else if (c != ECL_CODE_CHAR('u') && c != ECL_CODE_CHAR('U')) { c = ECL_NIL; } else { cl_index used_l; cl_index end = name->base_string.fillp; cl_index real_end = end; c = ecl_parse_integer(name, 1, end, &real_end, 16); used_l = real_end; if (!ECL_FIXNUMP(c) || (used_l == (l - 1))) { c = ECL_NIL; } else { c = ECL_CODE_CHAR(ecl_fixnum(c)); } } } ecl_return1(the_env, c); } ecl-16.1.2/src/c/cinit.d000066400000000000000000000145611266352375300146530ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* init.c -- Lisp Initialization. */ /* Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #include #include /* * HOOKS. * * The following functions are only used to bootstrap ECL. They divert * the calls to the interpreted code which is loaded by bare.lsp. Once * the whole of ECL is built, the file cinit.o will be replaced by the * actual initialization code, and the compiled function will be * called instead. */ extern cl_object cl_upgraded_array_element_type(cl_narg narg, cl_object type, ...) { return _ecl_funcall2(@'upgraded-array-element-type', type); } extern cl_object si_safe_eval(cl_narg narg, cl_object form, cl_object env, ...) { if (narg == 3) { cl_object err_value; va_list args; va_start(args, env); err_value = va_arg(args, cl_object); return _ecl_funcall4(@'ext::safe-eval', form, env, err_value); } return _ecl_funcall3(@'ext::safe-eval', form, env); } extern cl_object cl_slot_value(cl_object instance, cl_object name) { return _ecl_funcall3(@'slot-value', instance, name); } extern cl_object clos_slot_value_set(cl_object value, cl_object instance, cl_object name) { return _ecl_funcall4(@'clos::slot-value-set', value, instance, name); } extern cl_object clos_std_compute_applicable_methods(cl_object gf, cl_object arglist) { return _ecl_funcall3(@'clos::std-compute-applicable-methods', gf, arglist); } extern cl_object si_bind_simple_restarts(cl_object tag, cl_object names) { if (ECL_SYM_FUN(@'si::bind-simple-restarts') != Cnil) return _ecl_funcall3(@'si::bind-simple-restarts', tag, names); else return ECL_SYM_VAL(ecl_process_env(), @'si::*restart-clusters*'); } extern cl_object si_bind_simple_handlers(cl_object tag, cl_object names) { if (ECL_SYM_FUN(@'si::bind-simple-handlers') != Cnil) return _ecl_funcall3(@'si::bind-simple-handlers', tag, names); else return ECL_SYM_VAL(ecl_process_env(), @'si::*handler-clusters*'); } extern cl_object clos_std_compute_effective_method(cl_object gf, cl_object combination, cl_object methods_list) { return _ecl_funcall4(@'clos::std-compute-effective-method', gf, combination, methods_list); } extern cl_object clos_compute_effective_method_function(cl_object gf, cl_object combination, cl_object methods_list) { return _ecl_funcall4(@'clos::compute-effective-method-function', gf, combination, methods_list); } extern cl_object si_string_to_object(cl_narg narg, cl_object string, ...) { if (narg == 2) { cl_object err_value; va_list args; va_start(args, string); err_value = va_arg(args, cl_object); return _ecl_funcall3(@'si::string-to-object', string, err_value); } return _ecl_funcall2(@'si::string-to-object', string); } extern cl_object si_signal_simple_error(cl_narg narg, cl_object condition, cl_object continuable, cl_object format, cl_object format_args, ...) { ecl_va_list args; cl_object rest; ecl_va_start(args, format_args, narg, 4); rest = cl_grab_rest_args(args); return cl_apply(6, @'si::signal-simple-error', condition, continuable, format, format_args, rest); } extern cl_object cl_set_difference(cl_narg narg, cl_object l1, cl_object l2, ...) { @(return l1) } extern cl_object cl_array_dimensions(cl_object array) { return _ecl_funcall2(@'ARRAY-DIMENSIONS', array); } extern cl_object si_find_relative_package(cl_narg narg, cl_object package, ...) { @(return ECL_NIL); } extern cl_object si_wrong_type_argument(cl_narg narg, cl_object object, cl_object type, ...) { return _ecl_funcall3(@'si::wrong-type-argument', object, type); } extern cl_object si_make_encoding(cl_object mapping) { return _ecl_funcall2(@'ext::make-encoding', mapping); } static cl_object si_simple_toplevel () { cl_env_ptr env = ecl_process_env(); cl_object output = cl_core.standard_output; cl_object sentence; int i; /* Simple minded top level loop */ ECL_CATCH_ALL_BEGIN(env) { writestr_stream(";*** Lisp core booted ****\n" "ECL (Embeddable Common Lisp)\n", output); ecl_force_output(output); for (i = 1; i ", output); sentence = @read(3, ECL_NIL, ECL_NIL, OBJNULL); if (sentence == OBJNULL) @(return); sentence = si_eval_with_env(1, sentence); ecl_prin1(sentence, output); } } ECL_CATCH_ALL_END; } int main(int argc, char **args) { cl_object top_level, features; /* This should be always the first call */ cl_boot(argc, args); /* We are computing unnormalized numbers at some point */ si_trap_fpe(ECL_T, ECL_NIL); #ifdef ECL_CMU_FORMAT ECL_SET(@'*load-verbose*', ECL_NIL); #endif ECL_SET(@'*package*', cl_core.system_package); features = ecl_symbol_value(@'*features*'); features = CONS(ecl_make_keyword("ECL-MIN"), features); #ifdef HAVE_UNAME features = CONS(ecl_make_keyword("UNAME"), features); #endif ECL_SET(@'*features*', features); top_level = _ecl_intern("TOP-LEVEL", cl_core.system_package); ecl_def_c_function(top_level, si_simple_toplevel, 0); _ecl_funcall1(top_level); return(0); } #ifdef __cplusplus extern "C" void init_lib_LSP(cl_object); #endif void init_lib_LSP(cl_object o) {} ecl-16.1.2/src/c/clos/000077500000000000000000000000001266352375300143315ustar00rootroot00000000000000ecl-16.1.2/src/c/clos/accessor.d000066400000000000000000000154721266352375300163110ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* gfun.c -- Dispatch for generic functions. */ /* Copyright (c) 1990, Giuseppe Attardi. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #include #include #include #include static void no_applicable_method(cl_env_ptr env, cl_object gfun, cl_object args) { env->values[0] = cl_apply(3, @'no-applicable-method', gfun, args); } static cl_object fill_spec_vector(cl_object vector, cl_object gfun, cl_object instance) { cl_object *argtype = vector->vector.self.t; argtype[0] = gfun; argtype[1] = ECL_CLASS_OF(instance); vector->vector.fillp = 2; return vector; } static cl_object slot_method_name(cl_object gfun, cl_object args) { cl_object methods = _ecl_funcall3(@'compute-applicable-methods', gfun, args); unlikely_if (Null(methods)) { return OBJNULL; } else { cl_object first = ECL_CONS_CAR(methods); cl_object slotd = _ecl_funcall3(@'slot-value', first, @'clos::slot-definition'); return _ecl_funcall3(@'slot-value', slotd, @'clos::name'); } } static cl_object slot_method_index(cl_object gfun, cl_object instance, cl_object args) { cl_object slot_name = slot_method_name(gfun, args); unlikely_if (slot_name == OBJNULL) return OBJNULL; else { cl_object table = _ecl_funcall3(@'slot-value', ECL_CLASS_OF(instance), @'clos::location-table'); /* The class might not be a standard class. This happens * when a nonstandard class inherits from a standard class * and does not add any new slot accessor. */ unlikely_if (Null(table)) return slot_name; return ecl_gethash_safe(slot_name, table, OBJNULL); } } static ecl_cache_record_ptr search_slot_index(const cl_env_ptr env, cl_object gfun, cl_object instance) { ecl_cache_ptr cache = env->slot_cache; fill_spec_vector(cache->keys, gfun, instance); return ecl_search_cache(cache); } static ecl_cache_record_ptr add_new_index(const cl_env_ptr env, cl_object gfun, cl_object instance, cl_object args) { /* The keys and the cache may change while we compute the * applicable methods. We must save the keys and recompute the * cache location if it was filled. */ cl_object index = slot_method_index(gfun, instance, args); unlikely_if (index == OBJNULL) { no_applicable_method(env, gfun, args); return 0; } { ecl_cache_record_ptr e; ecl_cache_ptr cache = env->slot_cache; fill_spec_vector(cache->keys, gfun, instance); e = ecl_search_cache(cache); e->key = cl_copy_seq(cache->keys); e->value = index; return e; } } static void ensure_up_to_date_instance(cl_object instance) { cl_object clas = ECL_CLASS_OF(instance); cl_object slots = ECL_CLASS_SLOTS(clas); unlikely_if (slots != ECL_UNBOUND && instance->instance.sig != slots) { _ecl_funcall2(@'clos::update-instance', instance); } } cl_object ecl_slot_reader_dispatch(cl_narg narg, cl_object instance) { const cl_env_ptr env = ecl_process_env(); cl_object gfun = env->function; cl_object index, value; ecl_cache_record_ptr e; unlikely_if (narg != 1) FEwrong_num_arguments(gfun); unlikely_if (!ECL_INSTANCEP(instance)) { no_applicable_method(env, gfun, ecl_list1(instance)); return env->values[0]; } e = search_slot_index(env, gfun, instance); unlikely_if (e->key == OBJNULL) { cl_object args = ecl_list1(instance); e = add_new_index(env, gfun, instance, args); /* no_applicable_method() was called */ unlikely_if (e == 0) { return env->values[0]; } } ensure_up_to_date_instance(instance); index = e->value; if (ECL_FIXNUMP(index)) { value = instance->instance.slots[ecl_fixnum(index)]; } else if (ecl_unlikely(!ECL_LISTP(index))) { value = cl_slot_value(instance, index); } else if (ecl_unlikely(Null(index))) { FEerror("Error when accessing method cache for ~A", 1, gfun); } else { value = ECL_CONS_CAR(index); } unlikely_if (value == ECL_UNBOUND) { cl_object slot_name = slot_method_name(gfun, ecl_list1(instance)); value = _ecl_funcall4(@'slot-unbound', ECL_CLASS_OF(instance), instance, slot_name); } @(return value) } cl_object ecl_slot_writer_dispatch(cl_narg narg, cl_object value, cl_object instance) { const cl_env_ptr env = ecl_process_env(); cl_object gfun = env->function; ecl_cache_record_ptr e; cl_object index; unlikely_if (narg != 2) { FEwrong_num_arguments(gfun); } unlikely_if (!ECL_INSTANCEP(instance)) { no_applicable_method(env, gfun, cl_list(2, value, instance)); return env->values[0]; } e = search_slot_index(env, gfun, instance); unlikely_if (e->key == OBJNULL) { cl_object args = cl_list(2, value, instance); e = add_new_index(env, gfun, instance, args); /* no_applicable_method() was called */ unlikely_if (e == 0) { return env->values[0]; } } index = e->value; if (ECL_FIXNUMP(index)) { instance->instance.slots[ecl_fixnum(index)] = value; } else if (ecl_unlikely(!ECL_LISTP(index))) { clos_slot_value_set(value, instance, index); } else if (ecl_unlikely(Null(index))) { FEerror("Error when accessing method cache for ~A", 1, gfun); } else { ECL_RPLACA(index, value); } @(return value) } ecl-16.1.2/src/c/clos/cache.d000066400000000000000000000170211266352375300155420ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* cache.d -- thread-local cache for a variety of operations */ /* Copyright (c) 2011, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #include #include #include "newhash.h" #define RECORD_KEY(e) ((e)[0]) #define RECORD_VALUE(e) ((e)[1]) #define RECORD_GEN(e) ecl_fixnum((e+2)[0]) #define RECORD_GEN_SET(e,v) ((e+2)[0]=ecl_make_fixnum(v)) static void empty_cache(ecl_cache_ptr cache) { cl_object table = cache->table; cl_index i, total_size = table->vector.dim; cache->generation = 0; for (i = 0; i < total_size; i+=3) { table->vector.self.t[i] = OBJNULL; table->vector.self.t[i+1] = OBJNULL; table->vector.self.fix[i+2] = 0; } #ifdef ECL_THREADS cache->clear_list = ECL_NIL; #endif } static void clear_one_from_cache(ecl_cache_ptr cache, cl_object target) { cl_object table = cache->table; cl_index i, total_size = table->vector.dim; for (i = 0; i < total_size; i+=3) { cl_object key = table->vector.self.t[i]; if (key != OBJNULL) { if (target == key->vector.self.t[0]) { table->vector.self.t[i] = OBJNULL; table->vector.self.fix[i+2] = 0; } } } } #ifdef ECL_THREADS static void clear_list_from_cache(ecl_cache_ptr cache) { cl_object list = ecl_atomic_get(&cache->clear_list); cl_object table = cache->table; cl_index i, total_size = table->vector.dim; for (i = 0; i < total_size; i+=3) { cl_object key = table->vector.self.t[i]; if (key != OBJNULL) { if (ecl_member_eq(key->vector.self.t[0], list)) { table->vector.self.t[i] = OBJNULL; table->vector.self.fix[i+2] = 0; } } } } #endif ecl_cache_ptr ecl_make_cache(cl_index key_size, cl_index cache_size) { ecl_cache_ptr cache = ecl_alloc(sizeof(struct ecl_cache)); cache->keys = si_make_vector(ECL_T, /* element type */ ecl_make_fixnum(key_size), /* Maximum size */ ECL_T, /* adjustable */ ecl_make_fixnum(0), /* fill pointer */ ECL_NIL, /* displaced */ ECL_NIL); cache->table = si_make_vector(ECL_T, /* element type */ ecl_make_fixnum(3*cache_size), /* Maximum size */ ECL_NIL, /* adjustable */ ECL_NIL, /* fill pointer */ ECL_NIL, /* displaced */ ECL_NIL); empty_cache(cache); return cache; } void ecl_cache_remove_one(ecl_cache_ptr cache, cl_object first_key) { #ifdef ECL_THREADS ecl_atomic_push(&cache->clear_list, first_key); #else clear_one_from_cache(cache, first_key); #endif } static cl_index vector_hash_key(cl_object keys) { cl_index c, n, a = GOLDEN_RATIO, b = GOLDEN_RATIO; for (c = 0, n = keys->vector.fillp; n >= 3; ) { c += keys->vector.self.index[--n]; b += keys->vector.self.index[--n]; a += keys->vector.self.index[--n]; mix(a, b, c); } switch (n) { case 2: b += keys->vector.self.index[--n]; case 1: a += keys->vector.self.index[--n]; c += keys->vector.dim; mix(a,b,c); } return c; } /* * variation of ecl_gethash from hash.d, which takes an array of objects as key * It also assumes that entries are never removed except by clrhash. */ ecl_cache_record_ptr ecl_search_cache(ecl_cache_ptr cache) { #ifdef ECL_THREADS if (!Null(cache->clear_list)) { clear_list_from_cache(cache); } #endif { cl_object table = cache->table; cl_object keys = cache->keys; cl_index argno = keys->vector.fillp; cl_index i = vector_hash_key(keys); cl_index total_size = table->vector.dim; cl_fixnum min_gen, gen; cl_object *min_e; int k; i = i % total_size; i = i - (i % 3); min_gen = cache->generation; min_e = 0; for (k = 20; k--; ) { cl_object *e = table->vector.self.t + i; cl_object hkey = RECORD_KEY(e); if (hkey == OBJNULL) { min_gen = -1; min_e = e; if (RECORD_VALUE(e) == OBJNULL) { /* This record is not only deleted but empty * Hence we cannot find our method ahead */ break; } /* Else we only know that the record has been * delete, but we might find our data ahead. */ } else if (argno == hkey->vector.fillp) { cl_index n; for (n = 0; n < argno; n++) { if (keys->vector.self.t[n] != hkey->vector.self.t[n]) goto NO_MATCH; } min_e = e; goto FOUND; } else if (min_gen >= 0) { NO_MATCH: /* Unless we have found a deleted record, keep * looking for the oldest record that we can * overwrite with the new data. */ gen = RECORD_GEN(e); if (gen < min_gen) { min_gen = gen; min_e = e; } } i += 3; if (i >= total_size) i = 0; } if (min_e == 0) { ecl_internal_error("search_method_hash"); } RECORD_KEY(min_e) = OBJNULL; cache->generation++; FOUND: /* * Once we have reached here, we set the new generation of * this record and perform a global shift so that the total * generation number does not become too large and we can * expire some elements. */ gen = cache->generation; RECORD_GEN_SET(min_e, gen); if (gen >= total_size/2) { cl_object *e = table->vector.self.t; gen = 0.5*gen; cache->generation -= gen; for (i = table->vector.dim; i; i-= 3, e += 3) { cl_fixnum g = RECORD_GEN(e) - gen; if (g <= 0) { RECORD_KEY(e) = OBJNULL; RECORD_VALUE(e) = ECL_NIL; g = 0; } RECORD_GEN_SET(e, g); } } return (ecl_cache_record_ptr)min_e; } } ecl-16.1.2/src/c/cmpaux.d000066400000000000000000000160261266352375300150400ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* cmpaux.c -- Auxiliaries used in compiled Lisp code. */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #include #include cl_object si_specialp(cl_object sym) { @(return ((ecl_symbol_type(sym) & ecl_stp_special)? ECL_T : ECL_NIL)) } cl_fixnum ecl_ifloor(cl_fixnum x, cl_fixnum y) { if (y == 0) FEerror("Zero divizor", 0); else if (y > 0) if (x >= 0) return(x/y); else return(-((-x+y-1))/y); else if (x >= 0) return(-((x-y-1)/(-y))); else return((-x)/(-y)); } cl_fixnum ecl_imod(cl_fixnum x, cl_fixnum y) { return(x - ecl_ifloor(x, y)*y); } /* * ---------------------------------------------------------------------- * Conversions to C * ---------------------------------------------------------------------- */ char ecl_to_char(cl_object x) { switch (ecl_t_of(x)) { case t_fixnum: return ecl_fixnum(x); case t_character: return ECL_CHAR_CODE(x); default: FEerror("~S cannot be coerced to a C char.", 1, x); } } cl_fixnum ecl_to_fixnum(cl_object x) { switch (ecl_t_of(x)) { case t_fixnum: case t_bignum: return fixint(x); /* case t_character: return (cl_fixnum)ECL_CHAR_CODE(x); */ case t_ratio: return (cl_fixnum)ecl_to_double(x); case t_singlefloat: return (cl_fixnum)ecl_single_float(x); case t_doublefloat: return (cl_fixnum)ecl_double_float(x); #ifdef ECL_LONG_FLOAT case t_longfloat: return (cl_fixnum)ecl_long_float(x); #endif default: FEerror("~S cannot be coerced to a C int.", 1, x); } } cl_index ecl_to_unsigned_integer(cl_object x) { switch (ecl_t_of(x)) { case t_fixnum: case t_bignum: return fixnnint(x); case t_ratio: return (cl_index)ecl_to_double(x); case t_singlefloat: return (cl_index)ecl_single_float(x); case t_doublefloat: return (cl_index)ecl_double_float(x); #ifdef ECL_LONG_FLOAT case t_longfloat: return (cl_index)ecl_long_float(x); #endif default: FEerror("~S cannot be coerced to a C unsigned int.", 1, x); } } int ecl_aref_bv(cl_object x, cl_index index) { index += x->vector.offset; return ((x->vector.self.bit[index/CHAR_BIT] & (0200>>index%CHAR_BIT)) != 0); } int ecl_aset_bv(cl_object x, cl_index index, int value) { index += x->vector.offset; if (value == 0) x->vector.self.bit[index/CHAR_BIT] &= ~(0200>>index%CHAR_BIT); else x->vector.self.bit[index/CHAR_BIT] |= 0200>>index%CHAR_BIT; return value; } void cl_throw(cl_object tag) { ecl_frame_ptr fr = frs_sch(tag); if (fr == NULL) FEcontrol_error("THROW: The catch ~S is undefined.", 1, tag); ecl_unwind(ecl_process_env(), fr); } void cl_return_from(cl_object block_id, cl_object block_name) { ecl_frame_ptr fr = frs_sch(block_id); if (fr == NULL) FEcontrol_error("RETURN-FROM: The block ~S with id ~S is missing.", 2, block_name, block_id); ecl_unwind(ecl_process_env(), fr); } void cl_go(cl_object tag_id, cl_object label) { const cl_env_ptr the_env = ecl_process_env(); ecl_frame_ptr fr = frs_sch(tag_id); if (fr == NULL) FEcontrol_error("GO: The tagbody ~S is missing.", 1, tag_id); the_env->values[0] = label; the_env->nvalues = 1; ecl_unwind(the_env, fr); } cl_object cl_grab_rest_args(ecl_va_list args) { cl_object rest = ECL_NIL; cl_object *r = &rest; while (args[0].narg) { *r = ecl_list1(ecl_va_arg(args)); r = &ECL_CONS_CDR(*r); } return rest; } void cl_parse_key( ecl_va_list args, /* actual args */ int nkey, /* number of keywords */ cl_object *keys, /* keywords for the function */ cl_object *vars, /* where to put values (vars[0..nkey-1]) and suppliedp (vars[nkey..2*nkey-1]) */ cl_object *rest, /* if rest != NULL, where to collect rest values */ bool allow_other_keys) /* whether other key are allowed */ { int i; cl_object supplied_allow_other_keys = OBJNULL; cl_object unknown_keyword = OBJNULL; if (rest != NULL) *rest = ECL_NIL; for (i = 0; i < 2*nkey; i++) vars[i] = ECL_NIL; /* default values: NIL, supplied: NIL */ if (args[0].narg <= 0) return; for (; args[0].narg > 1; ) { cl_object keyword = ecl_va_arg(args); cl_object value = ecl_va_arg(args); if (ecl_unlikely(!ECL_SYMBOLP(keyword))) FEprogram_error_noreturn("LAMBDA: Keyword expected, got ~S.", 1, keyword); if (rest != NULL) { rest = &ECL_CONS_CDR(*rest = ecl_list1(keyword)); rest = &ECL_CONS_CDR(*rest = ecl_list1(value)); } for (i = 0; i < nkey; i++) { if (keys[i] == keyword) { if (vars[nkey+i] == ECL_NIL) { vars[i] = value; vars[nkey+i] = ECL_T; } goto goon; } } /* the key is a new one */ if (keyword == @':allow-other-keys') { if (supplied_allow_other_keys == OBJNULL) supplied_allow_other_keys = value; } else if (unknown_keyword == OBJNULL) unknown_keyword = keyword; goon:; } if (ecl_unlikely(args[0].narg != 0)) FEprogram_error_noreturn("Odd number of keys", 0); if (ecl_unlikely(unknown_keyword != OBJNULL && !allow_other_keys && (supplied_allow_other_keys == ECL_NIL || supplied_allow_other_keys == OBJNULL))) FEprogram_error("Unknown keyword ~S", 1, unknown_keyword); } ecl-16.1.2/src/c/compiler.d000066400000000000000000003405241266352375300153600ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* compiler.c -- Bytecode compiler */ /* Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ /* Remarks: [1] The virtual machine has a word size of 16 bits. Operands and arguments have this very size, so that for instance, a jump OP_JMP increment takes two words of memory: one for the operator and one for the argument. The interpreter is written with this assumption in mind, but it should be easily modifed, because arguments are retrieved with "next_arg" and operators with "next_op". Parts which will require a careful modification are marked with flag [1]. */ #include #include #include #include #include /********************* EXPORTS *********************/ #define REGISTER_SPECIALS 1 #define IGNORE_DECLARATIONS 0 /* Flags for the compilation routines: */ /* + Push the output of this form */ #define FLAG_PUSH 1 /* + Set the output of this form in VALUES */ #define FLAG_VALUES 2 /* + Set the output of this form in REG0 */ #define FLAG_REG0 4 /* + Search function binding in the global environment */ #define FLAG_GLOBAL 8 /* + Ignore this form */ #define FLAG_IGNORE 0 #define FLAG_USEFUL (FLAG_PUSH | FLAG_VALUES | FLAG_REG0) #define FLAG_EXECUTE 16 #define FLAG_LOAD 32 #define FLAG_COMPILE 64 #define FLAG_ONLY_LOAD 128 #define ENV_RECORD_LOCATION(r) CADDDR(r) #define ECL_SPECIAL_VAR_REF -2 #define ECL_UNDEFINED_VAR_REF -1 /********************* PRIVATE ********************/ typedef struct cl_compiler_env *cl_compiler_ptr; #define asm_begin(env) current_pc(env) #define current_pc(env) ECL_STACK_INDEX(env) #define set_pc(env,n) asm_clear(env,n) #define asm_ref(env,n) (cl_fixnum)((env)->stack[n]) static void asm_clear(cl_env_ptr env, cl_index h); static void asm_op(cl_env_ptr env, cl_fixnum op); static void asm_op2(cl_env_ptr env, int op, int arg); static cl_object asm_end(cl_env_ptr env, cl_index handle, cl_object definition); static cl_index asm_jmp(cl_env_ptr env, register int op); static void asm_complete(cl_env_ptr env, register int op, register cl_index original); static cl_fixnum c_var_ref(cl_env_ptr env, cl_object var, int allow_symbol_macro, bool ensure_defined); static int c_block(cl_env_ptr env, cl_object args, int flags); static int c_case(cl_env_ptr env, cl_object args, int flags); static int c_catch(cl_env_ptr env, cl_object args, int flags); static int c_compiler_let(cl_env_ptr env, cl_object args, int flags); static int c_cond(cl_env_ptr env, cl_object args, int flags); static int c_eval_when(cl_env_ptr env, cl_object args, int flags); static int c_flet(cl_env_ptr env, cl_object args, int flags); static int c_funcall(cl_env_ptr env, cl_object args, int flags); static int c_function(cl_env_ptr env, cl_object args, int flags); static int c_go(cl_env_ptr env, cl_object args, int flags); static int c_if(cl_env_ptr env, cl_object args, int flags); static int c_labels(cl_env_ptr env, cl_object args, int flags); static int c_let(cl_env_ptr env, cl_object args, int flags); static int c_leta(cl_env_ptr env, cl_object args, int flags); static int c_load_time_value(cl_env_ptr env, cl_object args, int flags); static int c_locally(cl_env_ptr env, cl_object args, int flags); static int c_macrolet(cl_env_ptr env, cl_object args, int flags); static int c_multiple_value_bind(cl_env_ptr env, cl_object args, int flags); static int c_multiple_value_call(cl_env_ptr env, cl_object args, int flags); static int c_multiple_value_prog1(cl_env_ptr env, cl_object args, int flags); static int c_multiple_value_setq(cl_env_ptr env, cl_object args, int flags); static int c_not(cl_env_ptr env, cl_object args, int flags); static int c_nth_value(cl_env_ptr env, cl_object args, int flags); static int c_prog1(cl_env_ptr env, cl_object args, int flags); static int c_progv(cl_env_ptr env, cl_object args, int flags); static int c_psetq(cl_env_ptr env, cl_object args, int flags); static int c_quote(cl_env_ptr env, cl_object args, int flags); static int c_values(cl_env_ptr env, cl_object args, int flags); static int c_setq(cl_env_ptr env, cl_object args, int flags); static int c_return(cl_env_ptr env, cl_object args, int flags); static int c_return_from(cl_env_ptr env, cl_object args, int flags); static int c_symbol_macrolet(cl_env_ptr env, cl_object args, int flags); static int c_tagbody(cl_env_ptr env, cl_object args, int flags); static int c_the(cl_env_ptr env, cl_object args, int flags); static int c_throw(cl_env_ptr env, cl_object args, int flags); static int c_unwind_protect(cl_env_ptr env, cl_object args, int flags); static int c_while(cl_env_ptr env, cl_object args, int flags); static int c_with_backend(cl_env_ptr env, cl_object args, int flags); static int c_until(cl_env_ptr env, cl_object args, int flags); static void eval_form(cl_env_ptr env, cl_object form); static int execute_each_form(cl_env_ptr env, cl_object body); static int compile_toplevel_body(cl_env_ptr env, cl_object args, int flags); static int compile_body(cl_env_ptr env, cl_object args, int flags); static int compile_form(cl_env_ptr env, cl_object args, int push); static int compile_with_load_time_forms(cl_env_ptr env, cl_object form, int flags); static int compile_constant(cl_env_ptr env, cl_object stmt, int flags); static int c_cons(cl_env_ptr env, cl_object args, int push); static int c_endp(cl_env_ptr env, cl_object args, int push); static int c_car(cl_env_ptr env, cl_object args, int push); static int c_cdr(cl_env_ptr env, cl_object args, int push); static int c_list(cl_env_ptr env, cl_object args, int push); static int c_listA(cl_env_ptr env, cl_object args, int push); static cl_object ecl_make_lambda(cl_env_ptr env, cl_object name, cl_object lambda); static void FEillegal_variable_name(cl_object) ecl_attr_noreturn; static void FEill_formed_input(void) ecl_attr_noreturn; /* -------------------- SAFE LIST HANDLING -------------------- */ static cl_object pop(cl_object *l) { cl_object head, list = *l; unlikely_if (ECL_ATOM(list)) FEill_formed_input(); head = ECL_CONS_CAR(list); *l = ECL_CONS_CDR(list); return head; } static cl_object pop_maybe_nil(cl_object *l) { cl_object head, list = *l; if (list == ECL_NIL) return ECL_NIL; unlikely_if (!ECL_LISTP(list)) FEill_formed_input(); head = ECL_CONS_CAR(list); *l = ECL_CONS_CDR(list); return head; } /* ------------------------------ ASSEMBLER ------------------------------ */ static cl_object asm_end(cl_env_ptr env, cl_index beginning, cl_object definition) { const cl_compiler_ptr c_env = env->c_env; cl_object bytecodes; cl_index code_size, i; cl_opcode *code; cl_object file = ECL_SYM_VAL(env,@'ext::*source-location*'), position; if (Null(file)) { file = ECL_SYM_VAL(env,@'*load-truename*'); position = ecl_make_fixnum(0); } else { position = cl_cdr(file); file = cl_car(file); } /* Save bytecodes from this session in a new vector */ code_size = current_pc(env) - beginning; bytecodes = ecl_alloc_object(t_bytecodes); bytecodes->bytecodes.name = @'si::bytecodes'; bytecodes->bytecodes.definition = definition; bytecodes->bytecodes.code_size = code_size; bytecodes->bytecodes.code = ecl_alloc_atomic(code_size * sizeof(cl_opcode)); bytecodes->bytecodes.data = c_env->constants; for (i = 0, code = (cl_opcode *)bytecodes->bytecodes.code; i < code_size; i++) { code[i] = (cl_opcode)(cl_fixnum)(env->stack[beginning+i]); } bytecodes->bytecodes.entry = _ecl_bytecodes_dispatch_vararg; ecl_set_function_source_file_info(bytecodes, (file == OBJNULL)? ECL_NIL : file, (file == OBJNULL)? ECL_NIL : position); asm_clear(env, beginning); return bytecodes; } #if defined(ECL_SMALL_BYTECODES) static void asm_arg(cl_env_ptr env, int n) { #ifdef WORDS_BIGENDIAN asm_op(env, (n >> 8) & 0xFF); asm_op(env, n & 0xFF); #else asm_op(env, n & 0xFF); asm_op(env, (n >> 8) & 0xFF); #endif } #else #define asm_arg(env,n) asm_op(env,n) #endif static void asm_op(cl_env_ptr env, cl_fixnum code) { cl_object v = (cl_object)code; ECL_STACK_PUSH(env,v); } static void asm_clear(cl_env_ptr env, cl_index h) { ECL_STACK_SET_INDEX(env, h); } static void asm_op2(cl_env_ptr env, int code, int n) { if (ecl_unlikely(n < -MAX_OPARG || MAX_OPARG < n)) FEprogram_error_noreturn("Argument to bytecode is too large", 0); asm_op(env, code); asm_arg(env, n); } static cl_index asm_constant(cl_env_ptr env, cl_object c) { const cl_compiler_ptr c_env = env->c_env; cl_object constants = c_env->constants; cl_vector_push_extend(2, c, constants); return constants->vector.fillp-1; } static cl_index asm_jmp(cl_env_ptr env, int op) { cl_index output; asm_op(env, op); output = current_pc(env); asm_arg(env, 0); return output; } static void asm_complete(cl_env_ptr env, int op, cl_index pc) { cl_fixnum delta = current_pc(env) - pc; /* [1] */ if (ecl_unlikely(op && (asm_ref(env, pc-1) != op))) FEprogram_error_noreturn("Non matching codes in ASM-COMPLETE2", 0); else if (ecl_unlikely(delta < -MAX_OPARG || delta > MAX_OPARG)) FEprogram_error_noreturn("Too large jump", 0); else { #ifdef ECL_SMALL_BYTECODES unsigned char low = delta & 0xFF; char high = delta >> 8; # ifdef WORDS_BIGENDIAN env->stack[pc] = (cl_object)(cl_fixnum)high; env->stack[pc+1] = (cl_object)(cl_fixnum)low; # else env->stack[pc] = (cl_object)(cl_fixnum)low; env->stack[pc+1] = (cl_object)(cl_fixnum)high; # endif #else env->stack[pc] = (cl_object)(cl_fixnum)delta; #endif } } /* ------------------------------ COMPILER ------------------------------ */ typedef struct { void *symbol; int (*compiler)(cl_env_ptr, cl_object, int); int lexical_increment; } compiler_record; static compiler_record database[] = { {@'block', c_block, 1}, {@'case', c_case, 1}, {@'catch', c_catch, 1}, {@'ext::compiler-let', c_compiler_let, 0}, {@'cond', c_cond, 1}, {@'eval-when', c_eval_when, 0}, {@'flet', c_flet, 1}, {@'function', c_function, 1}, {@'funcall', c_funcall, 1}, {@'go', c_go, 1}, {@'if', c_if, 1}, {@'labels', c_labels, 1}, {@'let', c_let, 1}, {@'let*', c_leta, 1}, {@'locally', c_locally, 0}, {@'load-time-value', c_load_time_value, 1}, {@'macrolet', c_macrolet, 0}, {@'multiple-value-bind', c_multiple_value_bind, 1}, {@'multiple-value-call', c_multiple_value_call, 1}, {@'multiple-value-prog1', c_multiple_value_prog1, 1}, {@'multiple-value-setq', c_multiple_value_setq, 1}, {@'not', c_not, 1}, {@'nth-value', c_nth_value, 1}, {@'null', c_not, 1}, {@'progn', compile_toplevel_body, 0}, {@'prog1', c_prog1, 1}, {@'progv', c_progv, 1}, {@'psetq', c_psetq, 1}, {@'quote', c_quote, 1}, {@'return', c_return, 1}, {@'return-from', c_return_from, 1}, {@'setq', c_setq, 1}, {@'symbol-macrolet', c_symbol_macrolet, 0}, {@'tagbody', c_tagbody, 1}, {@'the', c_the, 0}, {@'ext::truly-the', c_the, 0}, {@'throw', c_throw, 1}, {@'unwind-protect', c_unwind_protect, 1}, {@'values', c_values, 1}, {@'si::while', c_while, 0}, {@'ext::with-backend', c_with_backend, 0}, {@'si::until', c_until, 0}, /* Extras */ {@'cons', c_cons, 1}, {@'car', c_car, 1}, {@'cdr', c_cdr, 1}, {@'first', c_car, 1}, {@'rest', c_cdr, 1}, {@'list', c_list, 1}, {@'list*', c_listA, 1}, {@'endp', c_endp, 1}, {@'si::cons-car', c_car, 1}, {@'si::cons-cdr', c_cdr, 1}, {NULL, NULL, 1} }; /* ----------------- LEXICAL ENVIRONMENT HANDLING -------------------- */ static void assert_type_symbol(cl_object v) { if (ecl_t_of(v) != t_symbol) FEprogram_error_noreturn("Expected a symbol, found ~S.", 1, v); } static void FEillegal_variable_name(cl_object v) { FEprogram_error_noreturn("Not a valid variable name ~S.", 1, v); } static void FEill_formed_input() { FEprogram_error_noreturn("Syntax error: list with too few elements or improperly terminated.", 0); } static int c_search_constant(cl_env_ptr env, cl_object c) { const cl_compiler_ptr c_env = env->c_env; cl_object p = c_env->constants; int n; for (n = 0; n < p->vector.fillp; n++) { if (ecl_eql(p->vector.self.t[n], c)) { return n; } } return -1; } static int c_register_constant(cl_env_ptr env, cl_object c) { int n = c_search_constant(env, c); return (n < 0)? asm_constant(env, c) : n; } static void asm_c(cl_env_ptr env, cl_object o) { asm_arg(env, c_register_constant(env, o)); } static void asm_op2c(cl_env_ptr env, int code, cl_object o) { asm_op2(env, code, c_register_constant(env, o)); } /* * Note: the following should match the definitions in cmp/cmpenv.lsp, as * well as CMP-ENV-REGISTER-MACROLET (lsp/defmacro.lsp) * * The compiler environment consists of two lists, one stored in * env->variables, the other one stored in env->macros. * * variable-record = (:block block-name [used-p | block-object] location) | * (:tag ({tag-name}*) [NIL | tag-object] location) | * (:function function-name used-p [location]) | * (var-name {:special | nil} bound-p [location]) | * (symbol si::symbol-macro macro-function) | * CB | LB | UNWIND-PROTECT | * (:declare declaration-arguments*) * macro-record = (function-name FUNCTION [| function-object]) | * (macro-name si::macro macro-function) * CB | LB | UNWIND-PROTECT * * A *-NAME is a symbol. A TAG-ID is either a symbol or a number. A * MACRO-FUNCTION is a function that provides us with the expansion * for that local macro or symbol macro. BOUND-P is true when the * variable has been bound by an enclosing form, while it is NIL if * the variable-record corresponds just to a special declaration. * CB, LB and UNWIND-PROTECT are only used by the C compiler and they * denote closure, lexical environment and unwind-protect boundaries. * * The brackets [] denote differences between the bytecodes and C * compiler environments, with the first option belonging to the * interpreter and the second alternative to the compiler. * * A LOCATION object is proper to the bytecodes compiler and denotes * the position of this variable, block, tag or function, in the * lexical environment. Currently, it is a CONS with two integers * (DEPTH . ORDER), denoting the depth of the nested environments and * the position in the environment (from the beginning, not from the * tail). * * The BLOCK-, TAG- and FUNCTION- objects are proper of the compiler * and carry further information. * * The last variable records are devoted to declarations and are only * used by the C compiler. Read cmpenv.lsp for more details on the * structure of these declaration forms, as they do not completely * match those of Common-Lisp. */ #if 0 #define new_location(env,x) ecl_make_fixnum(0) #else static cl_object new_location(const cl_compiler_ptr c_env) { return CONS(ecl_make_fixnum(c_env->env_depth), ecl_make_fixnum(c_env->env_size++)); } #endif static cl_index c_register_block(cl_env_ptr env, cl_object name) { const cl_compiler_ptr c_env = env->c_env; cl_object loc = new_location(c_env); c_env->variables = CONS(cl_list(4, @':block', name, ECL_NIL, loc), c_env->variables); return ecl_fixnum(ECL_CONS_CDR(loc)); } static cl_index c_register_tags(cl_env_ptr env, cl_object all_tags) { const cl_compiler_ptr c_env = env->c_env; cl_object loc = new_location(c_env); c_env->variables = CONS(cl_list(4, @':tag', all_tags, ECL_NIL, loc), c_env->variables); return ecl_fixnum(ECL_CONS_CDR(loc)); } static void c_register_function(cl_env_ptr env, cl_object name) { const cl_compiler_ptr c_env = env->c_env; c_env->variables = CONS(cl_list(4, @':function', name, ECL_NIL, new_location(c_env)), c_env->variables); c_env->macros = CONS(cl_list(2, name, @'function'), c_env->macros); } static cl_object c_macro_expand1(cl_env_ptr env, cl_object stmt) { const cl_compiler_ptr c_env = env->c_env; return cl_macroexpand_1(2, stmt, CONS(c_env->variables, c_env->macros)); } static void c_register_symbol_macro(cl_env_ptr env, cl_object name, cl_object exp_fun) { const cl_compiler_ptr c_env = env->c_env; c_env->variables = CONS(cl_list(3, name, @'si::symbol-macro', exp_fun), c_env->variables); } /* UNUSED static void c_register_macro(cl_env_ptr env, cl_object name, cl_object exp_fun) { const cl_compiler_ptr c_env = env->c_env; c_env->macros = CONS(cl_list(3, name, @'si::macro', exp_fun), c_env->macros); } */ static void c_register_var(cl_env_ptr env, cl_object var, bool special, bool bound) { const cl_compiler_ptr c_env = env->c_env; c_env->variables = CONS(cl_list(4, var, special? @'special' : ECL_NIL, bound? ECL_T : ECL_NIL, new_location(c_env)), c_env->variables); } static void guess_environment(cl_env_ptr env, cl_object interpreter_env) { if (!LISTP(interpreter_env)) return; /* * Given the environment of an interpreted function, we guess a * suitable compiler enviroment to compile forms that access the * variables and local functions of this interpreted code. */ for (interpreter_env = @revappend(interpreter_env, ECL_NIL); !Null(interpreter_env); interpreter_env = ECL_CONS_CDR(interpreter_env)) { cl_object record = ECL_CONS_CAR(interpreter_env); if (!LISTP(record)) { c_register_function(env, record); } else { cl_object record0 = ECL_CONS_CAR(record); cl_object record1 = ECL_CONS_CDR(record); if (ECL_SYMBOLP(record0)) { c_register_var(env, record0, FALSE, TRUE); } else if (record1 == ecl_make_fixnum(0)) { c_register_tags(env, ECL_NIL); } else { c_register_block(env, record1); } } } } static void c_new_env(cl_env_ptr the_env, cl_compiler_env_ptr new, cl_object env, cl_compiler_env_ptr old) { the_env->c_env = new; if (old) { *new = *old; new->env_depth = old->env_depth + 1; } else { new->code_walker = ECL_SYM_VAL(the_env, @'si::*code-walker*'); new->constants = si_make_vector(ECL_T, ecl_make_fixnum(16), ECL_T, /* Adjustable */ ecl_make_fixnum(0), /* Fillp */ ECL_NIL, /* displacement */ ECL_NIL); new->stepping = 0; new->lexical_level = 0; new->load_time_forms = ECL_NIL; new->env_depth = 0; new->macros = CDR(env); new->variables = CAR(env); for (env = new->variables; !Null(env); env = CDR(env)) { cl_object record = CAR(env); if (ECL_ATOM(record)) continue; if (ECL_SYMBOLP(CAR(record)) && CADR(record) != @'si::symbol-macro') { continue; } else { new->lexical_level = 1; break; } } new->mode = FLAG_EXECUTE; } new->env_size = 0; } static cl_object c_tag_ref(cl_env_ptr env, cl_object the_tag, cl_object the_type) { cl_fixnum n = 0; cl_object l; const cl_compiler_ptr c_env = env->c_env; for (l = c_env->variables; CONSP(l); l = ECL_CONS_CDR(l)) { cl_object type, name, record = ECL_CONS_CAR(l); if (ECL_ATOM(record)) continue; type = ECL_CONS_CAR(record); record = ECL_CONS_CDR(record); name = ECL_CONS_CAR(record); if (type == @':tag') { if (type == the_type) { cl_object label = ecl_assql(the_tag, name); if (!Null(label)) { return CONS(ecl_make_fixnum(n), ECL_CONS_CDR(label)); } } n++; } else if (type == @':block' || type == @':function') { /* We compare with EQUAL, because of (SETF fname) */ if (type == the_type && ecl_equal(name, the_tag)) { /* Mark as used */ record = ECL_CONS_CDR(record); ECL_RPLACA(record, ECL_T); return ecl_make_fixnum(n); } n++; } else if (Null(name)) { n++; } else { /* We are counting only locals and ignore specials * and other declarations */ } } return ECL_NIL; } ecl_def_ct_base_string(undefined_variable, "Undefined variable referenced in interpreted code" ".~%Name: ~A", 60, static, const); static cl_fixnum c_var_ref(cl_env_ptr env, cl_object var, int allow_symbol_macro, bool ensure_defined) { cl_fixnum n = 0; cl_object l, record, special, name; const cl_compiler_ptr c_env = env->c_env; for (l = c_env->variables; CONSP(l); l = ECL_CONS_CDR(l)) { record = ECL_CONS_CAR(l); if (ECL_ATOM(record)) continue; name = ECL_CONS_CAR(record); record = ECL_CONS_CDR(record); special = ECL_CONS_CAR(record); if (name == @':block' || name == @':tag' || name == @':function') { n++; } else if (name == @':declare') { /* Ignored */ } else if (name != var) { /* Symbol not yet found. Only count locals. */ if (Null(special)) n++; } else if (special == @'si::symbol-macro') { /* We can only get here when we try to redefine a symbol macro */ if (allow_symbol_macro) return -1; FEprogram_error_noreturn("Internal error: symbol macro ~S" " used as variable", 1, var); } else if (Null(special)) { return n; } else { return ECL_SPECIAL_VAR_REF; } } if (ensure_defined) { l = ecl_symbol_value(@'ext::*action-on-undefined-variable*'); if (l != ECL_NIL) { funcall(3, l, undefined_variable, var); } } return ECL_UNDEFINED_VAR_REF; } static bool c_declared_special(register cl_object var, register cl_object specials) { return ((ecl_symbol_type(var) & ecl_stp_special) || ecl_member_eq(var, specials)); } static void c_declare_specials(cl_env_ptr env, cl_object specials) { while (!Null(specials)) { int ndx; cl_object var = pop(&specials); ndx = c_var_ref(env, var, 1, FALSE); if (ndx >= 0 || ndx == ECL_UNDEFINED_VAR_REF) c_register_var(env, var, TRUE, FALSE); } } static cl_object c_process_declarations(cl_object body) { const cl_env_ptr the_env = ecl_process_env(); @si::process-declarations(1, body); body = ecl_nth_value(the_env, 1); return body; } static bool c_pbind(cl_env_ptr env, cl_object var, cl_object specials) { bool special; if (!ECL_SYMBOLP(var)) FEillegal_variable_name(var); else if ((special = c_declared_special(var, specials))) { c_register_var(env, var, TRUE, TRUE); asm_op2c(env, OP_PBINDS, var); } else { c_register_var(env, var, FALSE, TRUE); asm_op2c(env, OP_PBIND, var); } return special; } static bool c_bind(cl_env_ptr env, cl_object var, cl_object specials) { bool special; if (!ECL_SYMBOLP(var)) FEillegal_variable_name(var); else if ((special = c_declared_special(var, specials))) { c_register_var(env, var, TRUE, TRUE); asm_op2c(env, OP_BINDS, var); } else { c_register_var(env, var, FALSE, TRUE); asm_op2c(env, OP_BIND, var); } return special; } static void c_undo_bindings(cl_env_ptr the_env, cl_object old_vars, int only_specials) { cl_object env; cl_index num_lexical = 0; cl_index num_special = 0; const cl_compiler_ptr c_env = the_env->c_env; for (env = c_env->variables; env != old_vars && !Null(env); env = ECL_CONS_CDR(env)) { cl_object record, name, special; record = ECL_CONS_CAR(env); name = ECL_CONS_CAR(record); record = ECL_CONS_CDR(record); special = ECL_CONS_CAR(record); if (name == @':block' || name == @':tag') { (void)0; } else if (name == @':function' || Null(special)) { if (!only_specials) ++num_lexical; } else if (name == @':declare') { /* Ignored */ } else if (special != @'si::symbol-macro') { /* If (third special) = NIL, the variable was declared special, but there is no binding! */ record = ECL_CONS_CDR(record); if (!Null(ECL_CONS_CAR(record))) { num_special++; } } } c_env->variables = env; if (num_lexical) asm_op2(the_env, OP_UNBIND, num_lexical); if (num_special) asm_op2(the_env, OP_UNBINDS, num_special); } static void compile_setq(cl_env_ptr env, int op, cl_object var) { cl_fixnum ndx; if (!ECL_SYMBOLP(var)) FEillegal_variable_name(var); ndx = c_var_ref(env, var,0,TRUE); if (ndx < 0) { /* Not a lexical variable */ if (ecl_symbol_type(var) & ecl_stp_constant) { FEassignment_to_constant(var); } ndx = c_register_constant(env, var); if (op == OP_SETQ) op = OP_SETQS; else if (op == OP_PSETQ) op = OP_PSETQS; else if (op == OP_VSETQ) op = OP_VSETQS; } asm_op2(env, op, ndx); } /* * This routine is used to change the compilation flags in optimizers * that do not want to push values onto the stack. Its purpose is to * keep ignorable forms ignored, while preserving the value of useful * forms. Qualitative behavior: * FLAG_PUSH -> FLAG_VALUES * FLAG_VALUES -> FLAG_VALUES * FLAG_REG0 -> FLAG_REG0 * FLAG_IGNORE -> FLAG_IGNORE */ static int maybe_values_or_reg0(int flags) { if (flags & FLAG_PUSH) return (flags | FLAG_VALUES) & ~FLAG_PUSH; else return flags; } /* * This routine is used to change the compilation flags in optimizers * that do not want to push values onto the stack, but also do not want * to use REG0 (maybe because the call a nested ecl_interpret()). Ignorable * forms are kept ignored: * FLAG_PUSH -> FLAG_VALUES * FLAG_VALUES -> FLAG_VALUES * FLAG_REG0 -> FLAG_VALUES * FLAG_IGNORE -> FLAG_IGNORE */ static int maybe_values(int flags) { if (flags & FLAG_USEFUL) return (flags & ~(FLAG_PUSH | FLAG_REG0)) | FLAG_VALUES; else return flags; } /* * This routine is used to change the compilation flags in optimizers * that do not want to push values onto the stack. Its purpose is to * keep ignorable forms ignored, while preserving the value of useful * forms. Qualitative behavior: * FLAG_PUSH -> FLAG_REG0 * FLAG_VALUES -> FLAG_REG0 * FLAG_REG0 -> FLAG_REG0 * FLAG_IGNORE -> FLAG_IGNORE */ static int maybe_reg0(int flags) { if (flags & FLAG_USEFUL) return (flags & ~(FLAG_VALUES | FLAG_PUSH)) | FLAG_REG0; else return flags; } /* -------------------- THE COMPILER -------------------- */ /* The OP_BLOCK operator encloses several forms within a block named BLOCK_NAME, thus catching any OP_RETFROM whose argument matches BLOCK_NAME. The end of this block is marked both by the OP_EXIT operator and the LABELZ which is packed within the OP_BLOCK operator. [OP_BLOCK + name + labelz] .... OP_EXIT_FRAME labelz: ... */ static int c_block(cl_env_ptr env, cl_object body, int old_flags) { struct cl_compiler_env old_env; cl_object name = pop(&body); cl_object block_record; cl_index labelz, pc, loc, constants; int flags; if (!ECL_SYMBOLP(name)) FEprogram_error_noreturn("BLOCK: Not a valid block name, ~S", 1, name); old_env = *(env->c_env); constants = old_env.constants->vector.fillp; pc = current_pc(env); flags = maybe_values_or_reg0(old_flags); loc = c_register_block(env, name); block_record = ECL_CONS_CAR(env->c_env->variables); if (Null(name)) { asm_op(env, OP_DO); } else { asm_op2c(env, OP_BLOCK, name); } labelz = asm_jmp(env, OP_FRAME); compile_body(env, body, flags); if (CADDR(block_record) == ECL_NIL) { /* Block unused. We remove the enclosing OP_BLOCK/OP_DO */ /* We also have to remove the constants we compiled, because */ /* some of them might be from load-time-value */ old_env.constants->vector.fillp = constants; *(env->c_env) = old_env; set_pc(env, pc); return compile_body(env, body, old_flags); } else { c_undo_bindings(env, old_env.variables, 0); asm_op(env, OP_EXIT_FRAME); asm_complete(env, 0, labelz); return flags; } } /* There are several ways to invoke functions and to handle the output arguments. These are [OP_CALL + nargs] function_name [OP_FCALL + nargs] OP_CALL and OP_FCALL leave all arguments in the VALUES() array, while OP_PCALL and OP_PFCALL leave the first argument in the stack. OP_CALL and OP_PCALL use the value in VALUES(0) to retrieve the function, while OP_FCALL and OP_PFCALL use a value from the stack. */ static int c_arguments(cl_env_ptr env, cl_object args) { cl_index nargs; for (nargs = 0; !Null(args); nargs++) { compile_form(env, pop(&args), FLAG_PUSH); } return nargs; } static int asm_function(cl_env_ptr env, cl_object args, int flags); static int c_call(cl_env_ptr env, cl_object args, int flags) { cl_object name; cl_index nargs; name = pop(&args); if (name >= (cl_object)cl_symbols && name < (cl_object)(cl_symbols + cl_num_symbols_in_core)) { cl_object f = ECL_SYM_FUN(name); cl_type t = (f == OBJNULL)? t_other : ecl_t_of(f); if (t == t_cfunfixed) { cl_index n = ecl_length(args); if (f->cfun.narg == 1 && n == 1) { compile_form(env, ECL_CONS_CAR(args), FLAG_REG0); asm_op2c(env, OP_CALLG1, name); return FLAG_VALUES; } else if (f->cfun.narg == 2 && n == 2) { compile_form(env, ECL_CONS_CAR(args), FLAG_PUSH); args = ECL_CONS_CDR(args); compile_form(env, ECL_CONS_CAR(args), FLAG_REG0); asm_op2c(env, OP_CALLG2, name); return FLAG_VALUES; } } } nargs = c_arguments(env, args); if (env->c_env->stepping) { /* When stepping, we only have one opcode to do function * calls: OP_STEPFCALL. */ asm_function(env, name, (flags & FLAG_GLOBAL) | FLAG_REG0); asm_op2(env, OP_STEPCALL, nargs); flags = FLAG_VALUES; } else if (ECL_SYMBOLP(name) && ((flags & FLAG_GLOBAL) || Null(c_tag_ref(env, name, @':function')))) { asm_op2(env, OP_CALLG, nargs); asm_c(env, name); flags = FLAG_VALUES; } else { /* Fixme!! We can optimize the case of global functions! */ asm_function(env, name, (flags & FLAG_GLOBAL) | FLAG_REG0); asm_op2(env, OP_CALL, nargs); flags = FLAG_VALUES; } return flags; } static int c_funcall(cl_env_ptr env, cl_object args, int flags) { cl_object name; cl_index nargs; name = pop(&args); if (CONSP(name)) { cl_object kind = ECL_CONS_CAR(name); if (kind == @'function') { if (cl_list_length(name) != ecl_make_fixnum(2)) FEprogram_error_noreturn("FUNCALL: Invalid function name ~S", 1, name); return c_call(env, CONS(CADR(name), args), flags); } if (kind == @'quote') { if (cl_list_length(name) != ecl_make_fixnum(2)) FEprogram_error_noreturn("FUNCALL: Invalid function name ~S", 1, name); return c_call(env, CONS(CADR(name), args), flags | FLAG_GLOBAL); } } compile_form(env, name, FLAG_PUSH); nargs = c_arguments(env, args); if (env->c_env->stepping) { asm_op2(env, OP_STEPCALL, nargs); flags = FLAG_VALUES; } else { asm_op2(env, OP_FCALL, nargs); flags = FLAG_VALUES; } asm_op(env, OP_POP1); return flags; } static int perform_c_case(cl_env_ptr env, cl_object args, int flags) { cl_object test, clause; do { if (Null(args)) return compile_body(env, ECL_NIL, flags); clause = pop(&args); if (ECL_ATOM(clause)) FEprogram_error_noreturn("CASE: Illegal clause ~S.",1,clause); test = pop(&clause); } while (test == ECL_NIL); if (@'otherwise' == test || test == ECL_T) { unlikely_if (args != ECL_NIL) { FEprogram_error_noreturn("CASE: The selector ~A can only appear at the last position.", 1, test); } compile_body(env, clause, flags); } else { cl_index labeln, labelz; if (CONSP(test)) { cl_index n = ecl_length(test); while (n-- > 1) { cl_object v = pop(&test); asm_op(env, OP_JEQL); asm_c(env, v); asm_arg(env, n * (OPCODE_SIZE + OPARG_SIZE * 2) + OPARG_SIZE); } test = ECL_CONS_CAR(test); } asm_op(env, OP_JNEQL); asm_c(env, test); labeln = current_pc(env); asm_arg(env, 0); compile_body(env, clause, flags); if (Null(args) && !(flags & FLAG_USEFUL)) { /* Ther is no otherwise. The test has failed and we need no output value. We simply close jumps. */ asm_complete(env, 0 & OP_JNEQL, labeln); } else { labelz = asm_jmp(env, OP_JMP); asm_complete(env, 0 & OP_JNEQL, labeln); perform_c_case(env, args, flags); asm_complete(env, OP_JMP, labelz); } } return flags; } static int c_case(cl_env_ptr env, cl_object clause, int flags) { compile_form(env, pop(&clause), FLAG_REG0); return perform_c_case(env, clause, maybe_values_or_reg0(flags)); } /* The OP_CATCH takes the object in VALUES(0) and uses it to catch any OP_THROW operation which uses that value as argument. If a catch occurs, or when all forms have been properly executed, it jumps to LABELZ. LABELZ is packed within the OP_CATCH operator. [OP_CATCH + labelz] ... "forms to be caught" ... OP_EXIT_FRAME labelz: ... */ static int c_catch(cl_env_ptr env, cl_object args, int flags) { cl_index labelz, loc; cl_object old_env; /* Compile evaluation of tag */ compile_form(env, pop(&args), FLAG_REG0); /* Compile binding of tag */ old_env = env->c_env->variables; loc = c_register_block(env, ecl_make_fixnum(0)); asm_op(env, OP_CATCH); /* Compile jump point */ labelz = asm_jmp(env, OP_FRAME); /* Compile body of CATCH */ compile_body(env, args, FLAG_VALUES); c_undo_bindings(env, old_env, 0); asm_op(env, OP_EXIT_FRAME); asm_complete(env, 0, labelz); return FLAG_VALUES; } static int c_compiler_let(cl_env_ptr env, cl_object args, int flags) { cl_object bindings; cl_index old_bds_top_index = env->bds_top - env->bds_org; for (bindings = pop(&args); !Null(bindings); ) { cl_object form = pop(&bindings); cl_object var = pop(&form); cl_object value = pop_maybe_nil(&form); ecl_bds_bind(env, var, value); } flags = compile_toplevel_body(env, args, flags); ecl_bds_unwind(env, old_bds_top_index); return flags; } /* There are three operators which perform explicit jumps, but almost all other operators use labels in one way or another. 1) Jumps are always relative to the place where the jump label is retrieved so that if the label is in vector[0], then the destination is roughly vector + vector[0]. 2) The three jump forms are [OP_JMP + label] ; Unconditional jump [OP_JNIL + label] ; Jump if VALUES(0) == ECL_NIL [OP_JT + label] ; Jump if VALUES(0) != ECL_NIL It is important to remark that both OP_JNIL and OP_JT truncate the values stack, so that always NVALUES = 1 after performing any of these operations. */ static int c_cond(cl_env_ptr env, cl_object args, int flags) { cl_object test, clause; cl_index label_nil, label_exit; if (Null(args)) return compile_form(env, ECL_NIL, flags); clause = pop(&args); if (ECL_ATOM(clause)) FEprogram_error_noreturn("COND: Illegal clause ~S.",1,clause); test = pop(&clause); flags = maybe_values_or_reg0(flags); if (ECL_T == test) { /* Default sentence. If no forms, just output T. */ if (Null(clause)) compile_form(env, ECL_T, flags); else compile_body(env, clause, flags); } else { /* Compile the test. If no more forms, just output the first value (this is guaranteed by OP_JT), but make sure it is stored in the appropriate place. */ if (Null(args)) { if (Null(clause)) { c_values(env, cl_list(1,test), flags); } else { compile_form(env, test, FLAG_REG0); if (flags & FLAG_VALUES) asm_op(env, OP_VALUEREG0); label_nil = asm_jmp(env, OP_JNIL); compile_body(env, clause, flags); asm_complete(env, OP_JNIL, label_nil); } } else if (Null(clause)) { compile_form(env, test, FLAG_REG0); if (flags & FLAG_VALUES) asm_op(env, OP_VALUEREG0); label_exit = asm_jmp(env, OP_JT); c_cond(env, args, flags); asm_complete(env, OP_JT, label_exit); } else { compile_form(env, test, FLAG_REG0); label_nil = asm_jmp(env, OP_JNIL); compile_body(env, clause, flags); label_exit = asm_jmp(env, OP_JMP); asm_complete(env, OP_JNIL, label_nil); c_cond(env, args, flags); asm_complete(env, OP_JMP, label_exit); } } return flags; } /* The OP_DO operator saves the lexical environment and establishes a NIL block to execute the enclosed forms, which are typically like the ones shown below. At the exit of the block, either by means of a OP_RETFROM jump or because of normal termination, the lexical environment is restored, and all bindings undone. [OP_DO + labelz] ... ; bindings [JMP + labelt] labelb: ... ; body ... ; stepping forms labelt: ... ; test form [JNIL + label] ... ; output form OP_EXIT_FRAME labelz: */ static int c_while_until(cl_env_ptr env, cl_object body, int flags, bool is_while) { cl_object test = pop(&body); cl_index labelt, labelb; flags = maybe_reg0(flags); /* Jump to test */ labelt = asm_jmp(env, OP_JMP); /* Compile body */ labelb = current_pc(env); c_tagbody(env, body, flags); /* Compile test */ asm_complete(env, OP_JMP, labelt); compile_form(env, test, FLAG_REG0); asm_op(env, is_while? OP_JT : OP_JNIL); asm_arg(env, labelb - current_pc(env)); return flags; } static int c_while(cl_env_ptr env, cl_object body, int flags) { return c_while_until(env, body, flags, 1); } static int c_until(cl_env_ptr env, cl_object body, int flags) { return c_while_until(env, body, flags, 0); } static int c_with_backend(cl_env_ptr env, cl_object args, int flags) { cl_object forms = ECL_NIL; while (!Null(args)) { cl_object tag = pop(&args); cl_object form = pop(&args); if (tag == @':bytecodes') forms = CONS(form, forms); } return compile_toplevel_body(env, forms, flags); } static int eval_when_flags(cl_object situation) { int code = 0; cl_object p; for (p = situation; p != ECL_NIL; p = ECL_CONS_CDR(p)) { cl_object keyword; unlikely_if (!ECL_LISTP(p)) FEtype_error_proper_list(situation); keyword = ECL_CONS_CAR(p); if (keyword == @'load') code |= FLAG_LOAD; else if (keyword == @':load-toplevel') code |= FLAG_LOAD; else if (keyword == @'compile') code |= FLAG_COMPILE; else if (keyword == @':compile-toplevel') code |= FLAG_COMPILE; else if (keyword == @'eval') code |= FLAG_EXECUTE; else if (keyword == @':execute') code |= FLAG_EXECUTE; } return code; } #define when_load_p(s) ((s) & FLAG_LOAD) #define when_compile_p(s) ((s) & FLAG_COMPILE) #define when_execute_p(s) ((s) & FLAG_EXECUTE) static int c_eval_when(cl_env_ptr env, cl_object args, int flags) { cl_object situation_list = pop(&args); int situation = eval_when_flags(situation_list); const cl_compiler_ptr c_env = env->c_env; int mode = c_env->mode; if (mode == FLAG_EXECUTE) { if (!when_execute_p(situation)) args = ECL_NIL; } else if (c_env->lexical_level) { if (!when_execute_p(situation)) args = ECL_NIL; } else if (mode == FLAG_LOAD) { if (when_compile_p(situation)) { env->c_env->mode = FLAG_COMPILE; execute_each_form(env, args); env->c_env->mode = FLAG_LOAD; if (!when_load_p(situation)) args = ECL_NIL; } else if (when_load_p(situation)) { env->c_env->mode = FLAG_ONLY_LOAD; flags = compile_toplevel_body(env, args, flags); env->c_env->mode = FLAG_LOAD; return flags; } else { args = ECL_NIL; } } else if (mode == FLAG_ONLY_LOAD) { if (!when_load_p(situation)) args = ECL_NIL; } else { /* FLAG_COMPILE */ if (when_execute_p(situation) || when_compile_p(situation)) { execute_each_form(env, args); } args = ECL_NIL; } return compile_toplevel_body(env, args, flags); } /* The OP_FLET/OP_FLABELS operators change the lexical environment to add a few local functions. [OP_FLET/OP_FLABELS + nfun + fun1] ... OP_UNBIND nfun labelz: */ static cl_index c_register_functions(cl_env_ptr env, cl_object l) { cl_index nfun; for (nfun = 0; !Null(l); nfun++) { cl_object definition = pop(&l); cl_object name = pop(&definition); c_register_function(env, name); } return nfun; } static int c_labels_flet(cl_env_ptr env, int op, cl_object args, int flags) { #define push(v,l) { cl_object c = *l = CONS(v, *l); l = &ECL_CONS_CDR(c); } cl_object l, def_list = pop(&args); cl_object old_vars = env->c_env->variables; cl_object old_funs = env->c_env->macros; cl_object fnames = ECL_NIL; cl_object v, *f = &fnames; cl_index nfun; if (def_list == ECL_NIL) { return c_locally(env, args, flags); } /* ANSI doesn't specify what should happen if we define multiple functions of the same name in the flet/labels block т€“ ECL treats this undefined behavior as an error */ for (l = def_list, nfun = 0; !Null(l); nfun++) { v = CAR(pop(&l)); if (ecl_member_eq(v, fnames)) FEprogram_error_noreturn ("~s: The function ~s was already defined.", 2, (op == OP_LABELS ? @'LABELS' : @'FLET'), v); push(v, f); } /* If compiling a LABELS form, add the function names to the lexical environment before compiling the functions */ if (op == OP_LABELS) c_register_functions(env, def_list); /* Push the operator (OP_LABELS/OP_FLET) with the number of functions */ asm_op2(env, op, nfun); /* Compile the local functions now. */ for (l = def_list; !Null(l); ) { cl_object definition = pop(&l); cl_object name = pop(&definition); cl_object lambda = ecl_make_lambda(env, name, definition); cl_index c = c_register_constant(env, lambda); asm_arg(env, c); } /* If compiling a FLET form, add the function names to the lexical environment after compiling the functions */ if (op == OP_FLET) c_register_functions(env, def_list); /* Compile the body of the form with the local functions in the lexical environment. */ flags = c_locally(env, args, flags); /* Restore and return */ c_undo_bindings(env, old_vars, 0); env->c_env->macros = old_funs; return flags; #undef push } static int c_flet(cl_env_ptr env, cl_object args, int flags) { return c_labels_flet(env, OP_FLET, args, flags); } /* There are two operators that produce functions. The first one is [OP_FUNCTION + name] which takes the function binding of SYMBOL. The second one is OP_CLOSE interpreted which encloses the INTERPRETED function in the current lexical environment. */ static int c_function(cl_env_ptr env, cl_object args, int flags) { cl_object function = pop(&args); if (!Null(args)) FEprogram_error_noreturn("FUNCTION: Too many arguments.", 0); return asm_function(env, function, flags); } static int asm_function(cl_env_ptr env, cl_object function, int flags) { if (!Null(si_valid_function_name_p(function))) { cl_object ndx = c_tag_ref(env, function, @':function'); if (Null(ndx)) { /* Globally defined function */ asm_op2c(env, OP_FUNCTION, function); return FLAG_REG0; } else { /* Function from a FLET/LABELS form */ asm_op2(env, OP_LFUNCTION, ecl_fixnum(ndx)); return FLAG_REG0; } } if (CONSP(function)) { cl_object kind = ECL_CONS_CAR(function); cl_object body = ECL_CONS_CDR(function); cl_object name; if (kind == @'lambda') { name = ECL_NIL; } else if (kind == @'ext::lambda-block') { name = ECL_CONS_CAR(body); body = ECL_CONS_CDR(body); } else { goto ERROR; } { const cl_compiler_ptr c_env = env->c_env; asm_op2c(env, (Null(c_env->variables) && Null(c_env->macros))? OP_QUOTE : OP_CLOSE, ecl_make_lambda(env, name, body)); } return FLAG_REG0; } ERROR: FEprogram_error_noreturn("FUNCTION: Not a valid argument ~S.", 1, function); return FLAG_REG0; } static int c_go(cl_env_ptr env, cl_object args, int flags) { cl_object tag = pop(&args); cl_object info = c_tag_ref(env, tag, @':tag'); if (Null(info)) FEprogram_error_noreturn("GO: Unknown tag ~S.", 1, tag); if (!Null(args)) FEprogram_error_noreturn("GO: Too many arguments.",0); asm_op2(env, OP_GO, ecl_fixnum(CAR(info))); asm_arg(env, ecl_fixnum(CDR(info))); return flags; } /* (if a b) -> (cond (a b)) (if a b c) -> (cond (a b) (t c)) */ static int c_if(cl_env_ptr env, cl_object form, int flags) { cl_object test = pop(&form); cl_object then = pop(&form); then = cl_list(2, test, then); if (Null(form)) { return c_cond(env, ecl_list1(then), flags); } else { return c_cond(env, cl_list(2, then, CONS(ECL_T, form)), flags); } } static int c_labels(cl_env_ptr env, cl_object args, int flags) { return c_labels_flet(env, OP_LABELS, args, flags); } /* The OP_PUSHENV saves the current lexical environment to allow several bindings. OP_PUSHENV ... ; binding forms ... ; body OP_EXIT There are four forms which perform bindings OP_PBIND name ; Bind NAME in the lexical env. using ; a value from the stack OP_PBINDS name ; Bind NAME as special variable using ; a value from the stack OP_BIND name ; Bind NAME in the lexical env. using ; VALUES(0) OP_BINDS name ; Bind NAME as special variable using ; VALUES(0) After a variable has been bound, there are several ways to refer to it. 1) Refer to the n-th variable in the lexical environment [SYMVAL + n] 2) Refer to the value of a special variable or constant SYMVALS name 3) Push the value of the n-th variable of the lexical environment [PUSHV + n] 4) Push the value of a special variable or constant PUSHVS name */ static int c_let_leta(cl_env_ptr env, int op, cl_object args, int flags) { cl_object bindings, specials, body, l, vars; cl_object old_variables = env->c_env->variables; bindings = cl_car(args); body = c_process_declarations(ECL_CONS_CDR(args)); specials = env->values[3]; /* Optimize some common cases */ if (bindings == ECL_NIL) return c_locally(env, CDR(args), flags); if (ECL_CONS_CDR(bindings) == ECL_NIL) op = OP_BIND; for (vars=ECL_NIL, l=bindings; !Null(l); ) { cl_object aux = pop(&l); cl_object var, value; if (ECL_ATOM(aux)) { var = aux; value = ECL_NIL; } else { var = pop(&aux); value = pop_maybe_nil(&aux); if (!Null(aux)) FEprogram_error_noreturn("LET: Ill formed declaration.",0); } if (!ECL_SYMBOLP(var)) FEillegal_variable_name(var); if (op == OP_PBIND) { compile_form(env, value, FLAG_PUSH); if (ecl_member_eq(var, vars)) FEprogram_error_noreturn ("LET: The variable ~s occurs more than " "once in the LET.", 1, var); vars = CONS(var, vars); } else { compile_form(env, value, FLAG_REG0); c_bind(env, var, specials); } } while (!Null(vars)) c_pbind(env, pop(&vars), specials); /* We have to register all specials, because in the list * there might be some variable that is not bound by this LET form */ c_declare_specials(env, specials); flags = compile_body(env, body, flags); c_undo_bindings(env, old_variables, 0); return flags; } static int c_let(cl_env_ptr env, cl_object args, int flags) { return c_let_leta(env, OP_PBIND, args, flags); } static int c_leta(cl_env_ptr env, cl_object args, int flags) { return c_let_leta(env, OP_BIND, args, flags); } static int c_load_time_value(cl_env_ptr env, cl_object args, int flags) { const cl_compiler_ptr c_env = env->c_env; cl_object value; unlikely_if (Null(args) || cl_cddr(args) != ECL_NIL) FEprogram_error_noreturn("LOAD-TIME-VALUE: Wrong number of arguments.", 0); value = ECL_CONS_CAR(args); if (c_env->mode != FLAG_LOAD && c_env->mode != FLAG_ONLY_LOAD) { value = si_eval_with_env(1, value); } else if (ECL_SYMBOLP(value) || ECL_LISTP(value)) { /* Using the form as constant, we force the system to coalesce multiple * copies of the same load-time-value form */ c_env->load_time_forms = ecl_cons(cl_list(3, args, value, ECL_NIL), c_env->load_time_forms); value = args; } return compile_constant(env, value, flags); } static int c_locally(cl_env_ptr env, cl_object args, int flags) { cl_object old_env = env->c_env->variables; /* First use declarations by declaring special variables... */ args = c_process_declarations(args); c_declare_specials(env, env->values[3]); /* ...and then process body */ flags = compile_toplevel_body(env, args, flags); c_undo_bindings(env, old_env, 0); return flags; } /* MACROLET The current lexical environment is saved. A new one is prepared with the definitions of these macros, and this environment is used to compile the body. */ static int c_macrolet(cl_env_ptr the_env, cl_object args, int flags) { const cl_compiler_ptr c_env = the_env->c_env; cl_object old_env = c_env->macros; cl_object env = funcall(3, @'si::cmp-env-register-macrolet', pop(&args), CONS(c_env->variables, c_env->macros)); c_env->macros = CDR(env); flags = c_locally(the_env, args, flags); c_env->macros = old_env; return flags; } static void c_vbind(cl_env_ptr env, cl_object var, int n, cl_object specials) { if (c_declared_special(var, specials)) { c_register_var(env, var, FLAG_PUSH, TRUE); if (n) { asm_op2(env, OP_VBINDS, n); } else { asm_op(env, OP_BINDS); } } else { c_register_var(env, var, FALSE, TRUE); if (n) { asm_op2(env, OP_VBIND, n); } else { asm_op(env, OP_BIND); } } asm_c(env, var); } static int c_multiple_value_bind(cl_env_ptr env, cl_object args, int flags) { cl_object vars = pop(&args); int n = ecl_length(vars); switch (n) { case 0: return c_locally(env, args, flags); case 1: vars = ECL_CONS_CAR(vars); vars = ecl_list1(cl_list(2, vars, pop(&args))); return c_leta(env, cl_listX(2, vars, args), flags); default: { cl_object value = pop(&args); cl_object old_variables = env->c_env->variables; cl_object body = c_process_declarations(args); cl_object specials = env->values[3]; compile_form(env, value, FLAG_VALUES); for (vars=cl_reverse(vars); n--; ) { cl_object var = pop(&vars); if (!ECL_SYMBOLP(var)) FEillegal_variable_name(var); c_vbind(env, var, n, specials); } c_declare_specials(env, specials); flags = compile_body(env, body, flags); c_undo_bindings(env, old_variables, 0); return flags; }} } static int c_multiple_value_call(cl_env_ptr env, cl_object args, int flags) { cl_object name; int op; name = pop(&args); if (Null(args)) { /* If no arguments, just use ordinary call */ return c_funcall(env, cl_list(1, name), flags); } compile_form(env, name, FLAG_PUSH); for (op = OP_PUSHVALUES; !Null(args); op = OP_PUSHMOREVALUES) { compile_form(env, pop(&args), FLAG_VALUES); asm_op(env, op); } asm_op(env, OP_MCALL); asm_op(env, OP_POP1); return FLAG_VALUES; } static int c_multiple_value_prog1(cl_env_ptr env, cl_object args, int flags) { compile_form(env, pop(&args), FLAG_VALUES); if (!Null(args)) { asm_op(env, OP_PUSHVALUES); compile_body(env, args, FLAG_IGNORE); asm_op(env, OP_POPVALUES); } return FLAG_VALUES; } static int c_multiple_value_setq(cl_env_ptr env, cl_object orig_args, int flags) { cl_object args = orig_args; cl_object orig_vars; cl_object vars = ECL_NIL, values; cl_object old_variables = env->c_env->variables; cl_index nvars = 0; /* Look for symbol macros, building the list of variables and the list of late assignments. */ for (orig_vars = pop(&args); !Null(orig_vars); ) { cl_object v = pop(&orig_vars); if (!ECL_SYMBOLP(v)) FEillegal_variable_name(v); v = c_macro_expand1(env, v); if (!ECL_SYMBOLP(v)) { /* If any of the places to be set is not a variable, * transform MULTIPLE-VALUE-SETQ into (SETF (VALUES ...)) */ args = orig_args; return compile_form(env, cl_listX(3, @'setf', CONS(@'values', CAR(args)), CDR(args)), flags); } vars = CONS(v, vars); nvars++; } /* Compile values */ values = pop(&args); if (args != ECL_NIL) FEprogram_error_noreturn("MULTIPLE-VALUE-SETQ: Too many arguments.", 0); if (nvars == 0) { /* No variables */ return compile_form(env, cl_list(2, @'values', values), flags); } compile_form(env, values, FLAG_VALUES); /* Compile variables */ for (nvars = 0, vars = cl_nreverse(vars); vars != ECL_NIL; nvars++, vars = ECL_CONS_CDR(vars)) { if (nvars) { compile_setq(env, OP_VSETQ, ECL_CONS_CAR(vars)); asm_arg(env, nvars); } else { compile_setq(env, OP_SETQ, ECL_CONS_CAR(vars)); } } c_undo_bindings(env, old_variables, 0); return FLAG_REG0; } /* The OP_NOT operator reverses the boolean value of VALUES(0). */ static int c_not(cl_env_ptr env, cl_object args, int flags) { flags = maybe_reg0(flags); if (flags & FLAG_USEFUL) { /* The value is useful */ compile_form(env, pop(&args), FLAG_REG0); asm_op(env, OP_NOT); } else { /* The value may be ignored. */ flags = compile_form(env, pop(&args), flags); } if (!Null(args)) FEprogram_error_noreturn("NOT/NULL: Too many arguments.", 0); return flags; } /* The OP_NTHVAL operator moves a value from VALUES(ndx) to VALUES(0). The index NDX is taken from the stack. OP_NTHVAL */ static int c_nth_value(cl_env_ptr env, cl_object args, int flags) { compile_form(env, pop(&args), FLAG_PUSH); /* INDEX */ compile_form(env, pop(&args), FLAG_VALUES); /* VALUES */ if (args != ECL_NIL) FEprogram_error_noreturn("NTH-VALUE: Too many arguments.",0); asm_op(env, OP_NTHVAL); return FLAG_REG0; } static int c_prog1(cl_env_ptr env, cl_object args, int flags) { cl_object form = pop(&args); if (!(flags & FLAG_USEFUL) || (flags & FLAG_PUSH)) { flags = compile_form(env, form, flags); compile_body(env, args, FLAG_IGNORE); } else { flags = FLAG_REG0; compile_form(env, form, FLAG_PUSH); compile_body(env, args, FLAG_IGNORE); asm_op(env, OP_POP); } return flags; } /* The OP_PROGV operator exectures a set of statements in a lexical environment that has been extended with special variables. The list of special variables is taken from the top of the stack, while the list of values is in VALUES(0). ... ; list of variables OP_PUSH ... ; list of values OP_PROGV ... ; body of progv OP_EXIT */ static int c_progv(cl_env_ptr env, cl_object args, int flags) { cl_object vars = pop(&args); cl_object values = pop(&args); /* The list of variables is in the stack */ compile_form(env, vars, FLAG_PUSH); /* The list of values is in reg0 */ compile_form(env, values, FLAG_REG0); /* The body is interpreted within an extended lexical environment. However, as all the new variables are special, the compiler need not take care of them */ asm_op(env, OP_PROGV); flags = compile_body(env, args, FLAG_VALUES); asm_op(env, OP_EXIT_PROGV); return flags; } /* There are four assignment operators. They are 1) Assign VALUES(0) to the lexical variable which occupies the N-th position [OP_SETQ + n] 2) Assign VALUES(0) to the special variable NAME [OP_SETQS + name] 3) Pop a value from the stack and assign it to the lexical variable in the N-th position. [OP_PSETQ + n] 4) Pop a value from the stack and assign it to the special variable denoted by NAME [OP_PSETQS + name] */ static int c_psetq(cl_env_ptr env, cl_object old_args, int flags) { cl_object args = ECL_NIL, vars = ECL_NIL; bool use_psetf = FALSE; cl_index nvars = 0; if (Null(old_args)) return compile_body(env, ECL_NIL, flags); /* We have to make sure that non of the variables which are to be assigned is actually a symbol macro. If that is the case, we invoke (PSETF ...) to handle the macro expansions. */ do { cl_object var = pop(&old_args); cl_object value = pop(&old_args); if (!ECL_SYMBOLP(var)) FEillegal_variable_name(var); var = c_macro_expand1(env, var); if (!ECL_SYMBOLP(var)) use_psetf = TRUE; args = ecl_nconc(args, cl_list(2, var, value)); nvars++; } while (!Null(old_args)); if (use_psetf) { return compile_form(env, CONS(@'psetf', args), flags); } do { cl_object var = pop(&args); cl_object value = pop(&args); vars = CONS(var, vars); compile_form(env, value, FLAG_PUSH); } while (!Null(args)); do { compile_setq(env, OP_PSETQ, pop(&vars)); } while (!Null(vars)); return compile_form(env, ECL_NIL, flags); } /* The OP_RETFROM operator returns from a block using the objects in VALUES() as output values. ... ; output form OP_RETFROM tag ; object which names the block */ static int c_return_aux(cl_env_ptr env, cl_object name, cl_object stmt, int flags) { cl_object ndx = c_tag_ref(env, name, @':block'); cl_object output = pop_maybe_nil(&stmt); if (!ECL_SYMBOLP(name) || Null(ndx)) FEprogram_error_noreturn("RETURN-FROM: Unknown block name ~S.", 1, name); if (stmt != ECL_NIL) FEprogram_error_noreturn("RETURN-FROM: Too many arguments.", 0); compile_form(env, output, FLAG_VALUES); asm_op2(env, OP_RETURN, ecl_fixnum(ndx)); return FLAG_VALUES; } static int c_return(cl_env_ptr env, cl_object stmt, int flags) { return c_return_aux(env, ECL_NIL, stmt, flags); } static int c_return_from(cl_env_ptr env, cl_object stmt, int flags) { cl_object name = pop(&stmt); return c_return_aux(env, name, stmt, flags); } static int c_setq(cl_env_ptr env, cl_object args, int flags) { if (Null(args)) return compile_form(env, ECL_NIL, flags); do { cl_object var = pop(&args); cl_object value = pop(&args); if (!ECL_SYMBOLP(var)) FEillegal_variable_name(var); var = c_macro_expand1(env, var); if (ECL_SYMBOLP(var)) { flags = FLAG_REG0; compile_form(env, value, FLAG_REG0); compile_setq(env, OP_SETQ, var); } else { flags = ecl_endp(args)? FLAG_VALUES : FLAG_REG0; compile_form(env, cl_list(3, @'setf', var, value), flags); } } while (!Null(args)); return flags; } static int c_symbol_macrolet(cl_env_ptr env, cl_object args, int flags) { cl_object def_list, specials, body; cl_object old_variables = env->c_env->variables; def_list = pop(&args); body = c_process_declarations(args); specials = env->values[3]; /* Scan the list of definitions */ while (!Null(def_list)) { cl_object definition = pop(&def_list); cl_object name = pop(&definition); cl_object expansion = pop(&definition); cl_object arglist = cl_list(2, @gensym(0), @gensym(0)); cl_object function; if ((ecl_symbol_type(name) & (ecl_stp_constant|ecl_stp_special)) || ecl_member_eq(name, specials)) { FEprogram_error_noreturn("SYMBOL-MACROLET: Symbol ~A cannot be \ declared special and appear in a symbol-macrolet.", 1, name); } definition = cl_list(2, arglist, cl_list(2, @'quote', expansion)); function = ecl_make_lambda(env, name, definition); c_register_symbol_macro(env, name, function); } c_declare_specials(env, specials); flags = compile_toplevel_body(env, body, flags); c_undo_bindings(env, old_variables, 0); return flags; } static int c_tagbody(cl_env_ptr env, cl_object args, int flags) { cl_object old_env = env->c_env->variables; cl_index tag_base; cl_object labels = ECL_NIL, label, body; cl_type item_type; int nt, i; /* count the tags */ for (nt = 0, body = args; !Null(body); ) { label = pop(&body); item_type = ecl_t_of(label); if (item_type == t_symbol || item_type == t_fixnum || item_type == t_bignum) { labels = CONS(CONS(label,ecl_make_fixnum(nt)), labels); nt += 1; } } if (nt == 0) { compile_body(env, args, 0); return compile_form(env, ECL_NIL, flags); } asm_op2c(env, OP_BLOCK, ecl_make_fixnum(0)); c_register_tags(env, labels); asm_op2(env, OP_TAGBODY, nt); tag_base = current_pc(env); for (i = nt; i; i--) asm_arg(env, 0); for (body = args; !Null(body); ) { label = pop(&body); item_type = ecl_t_of(label); if (item_type == t_symbol || item_type == t_fixnum || item_type == t_bignum) { asm_complete(env, 0, tag_base); tag_base += OPARG_SIZE; } else { compile_form(env, label, FLAG_IGNORE); } } asm_op(env, OP_EXIT_TAGBODY); c_undo_bindings(env, old_env, 0); return FLAG_REG0; } static int c_the(cl_env_ptr env, cl_object stmt, int flags) { cl_object type = pop(&stmt); cl_object value = pop(&stmt); if (stmt != ECL_NIL) { FEprogram_error_noreturn("THE: Too many arguments",0); } return compile_form(env, value, flags); } /* The OP_THROW jumps to an enclosing OP_CATCH whose tag matches the one of the throw. The tag is taken from the stack, while the output values are left in VALUES(). */ static int c_throw(cl_env_ptr env, cl_object stmt, int flags) { cl_object tag = pop(&stmt); cl_object form = pop(&stmt); if (stmt != ECL_NIL) FEprogram_error_noreturn("THROW: Too many arguments.",0); compile_form(env, tag, FLAG_PUSH); compile_form(env, form, FLAG_VALUES); asm_op(env, OP_THROW); return flags; } static int c_unwind_protect(cl_env_ptr env, cl_object args, int flags) { cl_index label = asm_jmp(env, OP_PROTECT); flags = maybe_values(flags); /* Compile form to be protected */ flags = compile_form(env, pop(&args), flags); asm_op(env, OP_PROTECT_NORMAL); /* Compile exit clause */ asm_complete(env, OP_PROTECT, label); compile_body(env, args, FLAG_IGNORE); asm_op(env, OP_PROTECT_EXIT); return flags; } /* The OP_VALUES moves N values from the stack to VALUES(). [OP_VALUES + n] */ static int c_values(cl_env_ptr env, cl_object args, int flags) { if (!(flags & FLAG_USEFUL)) { /* This value will be discarded. We do not care to push it or to save it in VALUES */ if (Null(args)) return flags; return compile_body(env, args, flags); } else if (flags & FLAG_PUSH) { /* We only need the first value. However, the rest of arguments HAVE to be be evaluated */ if (Null(args)) return compile_form(env, ECL_NIL, flags); flags = compile_form(env, pop(&args), FLAG_PUSH); compile_body(env, args, FLAG_IGNORE); return flags; } else if (Null(args)) { asm_op(env, OP_NOP); } else { int n = 0; while (!Null(args)) { compile_form(env, pop_maybe_nil(&args), FLAG_PUSH); n++; } asm_op2(env, OP_VALUES, n); } return FLAG_VALUES; } static int need_to_make_load_form_p(cl_object o) { switch (ecl_t_of(o)) { case t_character: case t_fixnum: case t_bignum: case t_ratio: case t_singlefloat: case t_doublefloat: #ifdef ECL_LONG_FLOAT case t_longfloat: #endif case t_complex: case t_symbol: case t_pathname: #ifdef ECL_UNICODE case t_string: #endif case t_base_string: case t_bitvector: return 0; case t_list: if (Null(o)) return 0; default: return _ecl_funcall3(@'clos::need-to-make-load-form-p', o, ECL_NIL) != ECL_NIL; } } static void maybe_make_load_forms(cl_env_ptr env, cl_object constant) { const cl_compiler_ptr c_env = env->c_env; cl_object init, make; if (c_env->mode != FLAG_LOAD && c_env->mode != FLAG_ONLY_LOAD) return; if (c_search_constant(env, constant) >= 0) return; if (!need_to_make_load_form_p(constant)) return; make = _ecl_funcall2(@'make-load-form', constant); init = (env->nvalues > 1)? env->values[1] : ECL_NIL; c_env->load_time_forms = ecl_cons(cl_list(3, constant, make, init), c_env->load_time_forms); } static int compile_constant(cl_env_ptr env, cl_object stmt, int flags) { if (flags & FLAG_USEFUL) { bool push = flags & FLAG_PUSH; cl_fixnum n; maybe_make_load_forms(env, stmt); if (stmt == ECL_NIL) { asm_op(env, push? OP_PUSHNIL : OP_NIL); } else if (ECL_FIXNUMP(stmt) && (n = ecl_fixnum(stmt)) <= MAX_OPARG && n >= -MAX_OPARG) { asm_op2(env, push? OP_PINT : OP_INT, n); } else { asm_op2c(env, push? OP_PUSHQ : OP_QUOTE, stmt); } if (flags & FLAG_VALUES) flags = (flags & ~FLAG_VALUES) | FLAG_REG0; } return flags; } static int c_quote(cl_env_ptr env, cl_object args, int flags) { if (ECL_ATOM(args) || ECL_CONS_CDR(args) != ECL_NIL) FEill_formed_input(); return compile_constant(env, ECL_CONS_CAR(args), flags); } static int compile_symbol(cl_env_ptr env, cl_object stmt, int flags) { cl_object stmt1 = c_macro_expand1(env, stmt); if (stmt1 != stmt) { return compile_form(env, stmt1, flags); } else { cl_fixnum index = c_var_ref(env, stmt,0,FALSE); bool push = flags & FLAG_PUSH; if (index >= 0) { asm_op2(env, push? OP_PUSHV : OP_VAR, index); } else { asm_op2c(env, push? OP_PUSHVS : OP_VARS, stmt); } if (flags & FLAG_VALUES) return (flags & ~FLAG_VALUES) | FLAG_REG0; else return flags; } } static int compile_form(cl_env_ptr env, cl_object stmt, int flags) { const cl_compiler_ptr c_env = env->c_env; cl_object function; int new_flags; ecl_bds_bind(env, @'si::*current-form*', stmt); BEGIN: if (c_env->code_walker != OBJNULL) { stmt = funcall(3, c_env->code_walker, stmt, CONS(c_env->variables, c_env->macros)); } /* * First try with variable references and quoted constants */ if (Null(stmt)) { new_flags = compile_constant(env, stmt, flags); goto OUTPUT; } if (!ECL_LISTP(stmt)) { if (ECL_SYMBOLP(stmt)) { new_flags = compile_symbol(env, stmt, flags); } else { new_flags = compile_constant(env, stmt, flags); } goto OUTPUT; } /* * Next try with special forms. */ function = ECL_CONS_CAR(stmt); if (ECL_SYMBOLP(function)) { cl_object index = ecl_gethash(function, cl_core.compiler_dispatch); if (index != OBJNULL) { compiler_record *l = database + ecl_fixnum(index); c_env->lexical_level += l->lexical_increment; if (c_env->stepping && function != @'function' && c_env->lexical_level) asm_op2c(env, OP_STEPIN, stmt); new_flags = (*(l->compiler))(env, ECL_CONS_CDR(stmt), flags); if (c_env->stepping && function != @'function' && c_env->lexical_level) asm_op(env, OP_STEPOUT); c_env->lexical_level -= l->lexical_increment; goto OUTPUT; } /* * Next try to macroexpand */ { cl_object new_stmt = c_macro_expand1(env, stmt); if (new_stmt != stmt){ stmt = new_stmt; goto BEGIN; } } } /* * Finally resort to ordinary function calls. */ if (c_env->stepping) asm_op2c(env, OP_STEPIN, stmt); c_env->lexical_level++; new_flags = c_call(env, stmt, flags); c_env->lexical_level--; OUTPUT: /* flags new_flags action PUSH PUSH --- PUSH VALUES OP_PUSH PUSH REG0 OP_PUSH VALUES PUSH Impossible VALUES VALUES --- VALUES REG0 OP_VALUEREG0 REG0 PUSH Impossible REG0 VALUES --- REG0 REG0 --- */ if (flags & FLAG_PUSH) { if (new_flags & (FLAG_REG0 | FLAG_VALUES)) asm_op(env, OP_PUSH); } else if (flags & FLAG_VALUES) { if (new_flags & FLAG_REG0) { asm_op(env, OP_VALUEREG0); } else if (new_flags & FLAG_PUSH) { FEerror("Internal error in bytecodes compiler", 0); } } else if (new_flags & FLAG_PUSH) { FEerror("Internal error in bytecodes compiler", 0); } ecl_bds_unwind1(env); return flags; } static void eval_nontrivial_form(cl_env_ptr env, cl_object form) { const cl_compiler_ptr old_c_env = env->c_env; struct cl_compiler_env new_c_env = *old_c_env; cl_index handle; cl_object bytecodes; struct ecl_stack_frame frame; frame.t = t_frame; frame.stack = frame.base = 0; frame.size = 0; frame.env = env; env->nvalues = 0; env->values[0] = ECL_NIL; new_c_env.constants = si_make_vector(ECL_T, ecl_make_fixnum(16), ECL_T, /* Adjustable */ ecl_make_fixnum(0), /* Fillp */ ECL_NIL, /* displacement */ ECL_NIL); new_c_env.load_time_forms = ECL_NIL; new_c_env.env_depth = 0; new_c_env.env_size = 0; env->c_env = &new_c_env; handle = asm_begin(env); compile_with_load_time_forms(env, form, FLAG_VALUES); if (current_pc(env) != handle) { asm_op(env, OP_EXIT); bytecodes = asm_end(env, handle, form); env->values[0] = ecl_interpret((cl_object)&frame, new_c_env.lex_env, bytecodes); #ifdef GBC_BOEHM GC_free(bytecodes->bytecodes.code); GC_free(bytecodes); #endif } env->c_env = old_c_env; } static void eval_form(cl_env_ptr env, cl_object form) { if (ECL_LISTP(form) || ECL_SYMBOLP(form)) { eval_nontrivial_form(env, form); } else { env->values[0] = form; env->nvalues = 1; } } static int execute_each_form(cl_env_ptr env, cl_object body) { cl_object form = ECL_NIL, next_form; for (form = ECL_NIL; !Null(body); form = next_form) { unlikely_if (!ECL_LISTP(body)) FEtype_error_proper_list(body); next_form = ECL_CONS_CAR(body); body = ECL_CONS_CDR(body); eval_form(env, form); } eval_form(env, form); return FLAG_VALUES; } static cl_index * save_bytecodes(cl_env_ptr env, cl_index start, cl_index end) { #ifdef GBC_BOEHM cl_index l = end - start; cl_index *bytecodes = ecl_alloc_atomic((l + 1) * sizeof(cl_index)); cl_index *p = bytecodes; for (*(p++) = l; end > start; end--, p++) { *p = (cl_index)ECL_STACK_POP_UNSAFE(env); } return bytecodes; #else #error "Pointer references outside of recognizable object" #endif } static void restore_bytecodes(cl_env_ptr env, cl_index *bytecodes) { cl_index *p = bytecodes; cl_index l; for (l = *p; l; l--) { ECL_STACK_PUSH(env, (cl_object)p[l]); } ecl_dealloc(bytecodes); } static int compile_with_load_time_forms(cl_env_ptr env, cl_object form, int flags) { /* * First compile the form as usual. */ const cl_compiler_ptr c_env = env->c_env; cl_index handle = asm_begin(env); int output_flags = compile_form(env, form, flags); /* * If some constants need to be built, we insert the * code _before_ the actual forms; */ if (c_env->load_time_forms != ECL_NIL) { cl_index *bytecodes = save_bytecodes(env, handle, current_pc(env)); cl_object p, forms_list = c_env->load_time_forms; c_env->load_time_forms = ECL_NIL; p = forms_list; do { cl_object r = ECL_CONS_CAR(p); cl_object constant = pop(&r); cl_object make_form = pop(&r); cl_object init_form = pop(&r); cl_index loc = c_register_constant(env, constant); compile_with_load_time_forms(env, make_form, FLAG_REG0); asm_op2(env, OP_CSET, loc); compile_with_load_time_forms(env, init_form, FLAG_IGNORE); ECL_RPLACA(p, ecl_make_fixnum(loc)); p = ECL_CONS_CDR(p); } while (p != ECL_NIL); p = forms_list; do { cl_index loc = ecl_fixnum(ECL_CONS_CAR(p)); /* Clear created constants (they cannot be printed) */ c_env->constants->vector.self.t[loc] = ecl_make_fixnum(0); p = ECL_CONS_CDR(p); } while (p != ECL_NIL); restore_bytecodes(env, bytecodes); } return output_flags; } static int compile_each_form(cl_env_ptr env, cl_object body, int flags) { cl_object form = ECL_NIL, next_form; for (form = ECL_NIL; !Null(body); form = next_form) { unlikely_if (!ECL_LISTP(body)) FEtype_error_proper_list(body); next_form = ECL_CONS_CAR(body); body = ECL_CONS_CDR(body); compile_with_load_time_forms(env, form, FLAG_IGNORE); } return compile_with_load_time_forms(env, form, flags); } static int compile_toplevel_body(cl_env_ptr env, cl_object body, int flags) { const cl_compiler_ptr c_env = env->c_env; if (!c_env->lexical_level) { if (c_env->mode == FLAG_EXECUTE) return execute_each_form(env, body); else return compile_each_form(env, body, flags); } else { return compile_body(env, body, flags); } } static int compile_body(cl_env_ptr env, cl_object body, int flags) { cl_object form = ECL_NIL, next_form; for (form = ECL_NIL; !Null(body); form = next_form) { unlikely_if (!ECL_LISTP(body)) FEtype_error_proper_list(body); next_form = ECL_CONS_CAR(body); body = ECL_CONS_CDR(body); compile_form(env, form, FLAG_IGNORE); } return compile_form(env, form, flags); } /* ------------------------ INLINED FUNCTIONS -------------------------------- */ static int c_cons(cl_env_ptr env, cl_object args, int flags) { if (ecl_length(args) != 2) { FEprogram_error_noreturn("CONS: Wrong number of arguments", 0); } compile_form(env, cl_first(args), FLAG_PUSH); compile_form(env, cl_second(args), FLAG_REG0); asm_op(env, OP_CONS); return FLAG_REG0; } static int c_endp(cl_env_ptr env, cl_object args, int flags) { cl_object list = pop(&args); if (args != ECL_NIL) { FEprogram_error_noreturn("ENDP: Too many arguments", 0); } compile_form(env, list, FLAG_REG0); asm_op(env, OP_ENDP); return FLAG_REG0; } static int c_car(cl_env_ptr env, cl_object args, int flags) { cl_object list = pop(&args); if (args != ECL_NIL) { FEprogram_error_noreturn("CAR: Too many arguments", 0); } compile_form(env, list, FLAG_REG0); asm_op(env, OP_CAR); return FLAG_REG0; } static int c_cdr(cl_env_ptr env, cl_object args, int flags) { cl_object list = pop(&args); if (args != ECL_NIL) { FEprogram_error_noreturn("CDR: Too many arguments", 0); } compile_form(env, list, FLAG_REG0); asm_op(env, OP_CDR); return FLAG_REG0; } static int c_list_listA(cl_env_ptr env, cl_object args, int flags, int op) { cl_index n = ecl_length(args); if (n == 0) { return compile_form(env, ECL_NIL, flags); } else { while (ECL_CONS_CDR(args) != ECL_NIL) { compile_form(env, ECL_CONS_CAR(args), FLAG_PUSH); args = ECL_CONS_CDR(args); } compile_form(env, ECL_CONS_CAR(args), FLAG_REG0); asm_op2(env, op, n); return FLAG_REG0; } } static int c_list(cl_env_ptr env, cl_object args, int flags) { return c_list_listA(env, args, flags, OP_LIST); } static int c_listA(cl_env_ptr env, cl_object args, int flags) { return c_list_listA(env, args, flags, OP_LISTA); } /* ----------------------------- PUBLIC INTERFACE ---------------------------- */ /* ------------------------------------------------------------ LAMBDA OBJECTS: An interpreted function is a vector made of the following components #(LAMBDA {block-name | NIL} {variable-env | NIL} {function-env | NIL} {block-env | NIL} (list of variables declared special) Nreq {var}* ; required arguments Nopt {var value flag}* ; optional arguments {rest-var NIL} ; rest variable {T | NIL} ; allow other keys? Nkey {key var value flag}* ; keyword arguments Naux {var init} ; auxiliary variables documentation-string list-of-declarations {form}* ; body) ------------------------------------------------------------ */ /* Handles special declarations, removes declarations from body */ @(defun si::process-declarations (body &optional doc) cl_object documentation = ECL_NIL, declarations = ECL_NIL, specials = ECL_NIL; @ for (; !Null(body); body = ECL_CONS_CDR(body)) { cl_object form; unlikely_if (!ECL_LISTP(body)) FEill_formed_input(); form = ECL_CONS_CAR(body); if (!Null(doc) && ecl_stringp(form) && !Null(ECL_CONS_CDR(body))) { if (documentation != ECL_NIL) break; documentation = form; continue; } if (ECL_ATOM(form) || (ECL_CONS_CAR(form) != @'declare')) { break; } for (form = ECL_CONS_CDR(form); !Null(form); ) { cl_object sentence = pop(&form); declarations = ecl_cons(sentence, declarations); if (pop(&sentence) == @'special') { while (!Null(sentence)) { cl_object v = pop(&sentence); assert_type_symbol(v); specials = ecl_cons(v, specials); } } } } @(return cl_nreverse(declarations) body documentation specials) @) cl_object si_process_lambda(cl_object lambda) { cl_object documentation, declarations, specials; cl_object lambda_list, body; const cl_env_ptr env = ecl_process_env(); unlikely_if (ECL_ATOM(lambda)) FEprogram_error_noreturn("LAMBDA: No lambda list.", 0); lambda_list = ECL_CONS_CAR(lambda); body = ECL_CONS_CDR(lambda); declarations = @si::process-declarations(2, body, ECL_T); body = env->values[1]; documentation = env->values[2]; specials = env->values[3]; lambda_list = si_process_lambda_list(lambda_list, @'function'); { cl_index n = env->nvalues; env->values[0] = lambda_list; env->values[n++] = documentation; env->values[n++] = specials; env->values[n++] = declarations; env->values[n++] = body; env->nvalues = n; } return lambda_list; } /* * (si::process-lambda-list lambda-list context) * * Parses different types of lambda lists. CONTEXT may be MACRO, * FTYPE, FUNCTION, METHOD or DESTRUCTURING-BIND, and determines the * valid sytax. The output is made of several values: * * VALUES(0) = (N req1 ... ) ; required values * VALUES(1) = (N opt1 init1 flag1 ... ) ; optional values * VALUES(2) = rest-var ; rest-variable, if any * VALUES(3) = key-flag ; T if &key was supplied * VALUES(4) = (N key1 var1 init1 flag1 ... ) ; keyword arguments * VALUES(5) = allow-other-keys ; flag &allow-other-keys * VALUES(6) = (N aux1 init1 ... ) ; auxiliary variables * * 1ТА) The prefix "N" is an integer value denoting the number of * variables which are declared within this section of the lambda * list. * * 2ТА) The INIT* arguments are lisp forms which are evaluated when * no value is provided. * * 3ТА) The FLAG* arguments is the name of a variable which holds a * boolean value in case an optional or keyword argument was * provided. If it is NIL, no such variable exists. */ cl_object si_process_lambda_list(cl_object org_lambda_list, cl_object context) { #define push(v,l) { cl_object c = *l = CONS(v, *l); l = &ECL_CONS_CDR(c); } #define assert_var_name(v) \ if (context == @'function') { \ unlikely_if (ecl_symbol_type(v) & ecl_stp_constant) \ FEillegal_variable_name(v); } cl_object lists[4] = {ECL_NIL, ECL_NIL, ECL_NIL, ECL_NIL}; cl_object *reqs = lists, *opts = lists+1, *keys = lists+2, *auxs = lists+3; cl_object v, rest = ECL_NIL, lambda_list = org_lambda_list; int nreq = 0, nopt = 0, nkey = 0, naux = 0; cl_object allow_other_keys = ECL_NIL; cl_object key_flag = ECL_NIL; enum { AT_REQUIREDS, AT_OPTIONALS, AT_REST, AT_KEYS, AT_OTHER_KEYS, AT_AUXS } stage = AT_REQUIREDS; if (!ECL_LISTP(lambda_list)) goto ILLEGAL_LAMBDA; LOOP: if (Null(lambda_list)) goto OUTPUT; if (!ECL_LISTP(lambda_list)) { unlikely_if (context == @'function' || context == @'ftype') goto ILLEGAL_LAMBDA; v = lambda_list; lambda_list = ECL_NIL; goto REST; } v = ECL_CONS_CAR(lambda_list); lambda_list = ECL_CONS_CDR(lambda_list); if (v == @'&optional') { unlikely_if (stage >= AT_OPTIONALS) goto ILLEGAL_LAMBDA; stage = AT_OPTIONALS; goto LOOP; } if (v == @'&rest' || (v == @'&body' && (context == @'si::macro' || context == @'destructuring-bind'))) { unlikely_if (ECL_ATOM(lambda_list)) goto ILLEGAL_LAMBDA; v = ECL_CONS_CAR(lambda_list); lambda_list = ECL_CONS_CDR(lambda_list); REST: unlikely_if (stage >= AT_REST) goto ILLEGAL_LAMBDA; stage = AT_REST; rest = v; goto LOOP; } if (v == @'&key') { unlikely_if (stage >= AT_KEYS) goto ILLEGAL_LAMBDA; key_flag = ECL_T; stage = AT_KEYS; goto LOOP; } if (v == @'&aux') { unlikely_if (stage >= AT_AUXS) goto ILLEGAL_LAMBDA; stage = AT_AUXS; goto LOOP; } if (v == @'&allow-other-keys') { allow_other_keys = ECL_T; unlikely_if (stage != AT_KEYS) goto ILLEGAL_LAMBDA; stage = AT_OTHER_KEYS; goto LOOP; } switch (stage) { case AT_REQUIREDS: nreq++; assert_var_name(v); if (context == @'function' && ecl_member_eq(v, lists[0])) /* note: ftype isn't valid context for this check */ FEprogram_error_noreturn ("The variable ~s occurs more than once as the " "required parameter in the lambda list.", 1, v); push(v, reqs); break; case AT_OPTIONALS: { cl_object spp = ECL_NIL; cl_object init = ECL_NIL; if (!ECL_ATOM(v) && (context != @'ftype')) { cl_object x = v; unlikely_if (!ECL_LISTP(x)) goto ILLEGAL_LAMBDA; v = ECL_CONS_CAR(x); x = ECL_CONS_CDR(x); if (!Null(x)) { unlikely_if (!ECL_LISTP(x)) goto ILLEGAL_LAMBDA; init = ECL_CONS_CAR(x); x = ECL_CONS_CDR(x); if (!Null(x)) { unlikely_if (!ECL_LISTP(x)) goto ILLEGAL_LAMBDA; spp = ECL_CONS_CAR(x); x = ECL_CONS_CDR(x); if (spp != ECL_NIL) assert_var_name(spp); unlikely_if (!Null(x)) goto ILLEGAL_LAMBDA; } } } nopt++; assert_var_name(v); push(v, opts); push(init, opts); push(spp, opts); break; } case AT_REST: /* If we get here, the user has declared more than one * &rest variable, as in (lambda (&rest x y) ...) */ goto ILLEGAL_LAMBDA; case AT_KEYS: { cl_object init = ECL_NIL; cl_object spp = ECL_NIL; cl_object key; if (context == @'ftype') { unlikely_if (ECL_ATOM(v)) goto ILLEGAL_LAMBDA; key = ECL_CONS_CAR(v); v = CADR(v); goto KEY_PUSH; } if (!ECL_ATOM(v)) { cl_object x = v; v = ECL_CONS_CAR(x); x = ECL_CONS_CDR(x); if (!Null(x)) { unlikely_if (!ECL_LISTP(x)) goto ILLEGAL_LAMBDA; init = ECL_CONS_CAR(x); x = ECL_CONS_CDR(x); if (!Null(x)) { unlikely_if (!ECL_LISTP(x)) goto ILLEGAL_LAMBDA; spp = ECL_CONS_CAR(x); x = ECL_CONS_CDR(x); unlikely_if (!Null(x)) goto ILLEGAL_LAMBDA; if (spp != ECL_NIL) assert_var_name(spp); } } } if (CONSP(v)) { key = ECL_CONS_CAR(v); v = ECL_CONS_CDR(v); unlikely_if (ECL_ATOM(v) || !Null(ECL_CONS_CDR(v))) goto ILLEGAL_LAMBDA; v = ECL_CONS_CAR(v); if (context == @'function') assert_type_symbol(v); assert_type_symbol(key); } else { int intern_flag; key = ecl_intern(ecl_symbol_name(v), cl_core.keyword_package, &intern_flag); } KEY_PUSH: nkey++; push(key, keys); assert_var_name(v); push(v, keys); push(init, keys); push(spp, keys); break; } default: { cl_object init; if (ECL_ATOM(v)) { init = ECL_NIL; } else if (Null(CDDR(v))) { cl_object x = v; v = ECL_CONS_CAR(x); init = CADR(x); } else goto ILLEGAL_LAMBDA; naux++; assert_var_name(v); push(v, auxs); push(init, auxs); } } goto LOOP; OUTPUT: if ((nreq+nopt+(!Null(rest))+nkey) >= ECL_CALL_ARGUMENTS_LIMIT) FEprogram_error_noreturn("LAMBDA: Argument list ist too long, ~S.", 1, org_lambda_list); @(return CONS(ecl_make_fixnum(nreq), lists[0]) CONS(ecl_make_fixnum(nopt), lists[1]) rest key_flag CONS(ecl_make_fixnum(nkey), lists[2]) allow_other_keys lists[3]) ILLEGAL_LAMBDA: FEprogram_error_noreturn("LAMBDA: Illegal lambda list ~S.", 1, org_lambda_list); #undef push #undef assert_var_name } static void c_default(cl_env_ptr env, cl_object var, cl_object stmt, cl_object flag, cl_object specials) { /* Flag is in REG0, value, if it exists, in stack */ cl_index label; label = asm_jmp(env, OP_JT); compile_form(env, stmt, FLAG_PUSH); if (Null(flag)) { asm_complete(env, OP_JT, label); } else { compile_form(env, ECL_NIL, FLAG_REG0); asm_complete(env, OP_JT, label); c_bind(env, flag, specials); } c_pbind(env, var, specials); } cl_object ecl_make_lambda(cl_env_ptr env, cl_object name, cl_object lambda) { cl_object reqs, opts, rest, key, keys, auxs, allow_other_keys; cl_object specials, doc, decl, body, output; cl_index handle; struct cl_compiler_env *old_c_env, new_c_env; ecl_bds_bind(env, @'si::*current-form*', @list*(3, @'ext::lambda-block', name, lambda)); old_c_env = env->c_env; c_new_env(env, &new_c_env, ECL_NIL, old_c_env); new_c_env.lexical_level++; reqs = si_process_lambda(lambda); opts = env->values[1]; rest = env->values[2]; key = env->values[3]; keys = env->values[4]; allow_other_keys = env->values[5]; auxs = env->values[6]; doc = env->values[7]; specials = env->values[8]; decl = env->values[9]; body = env->values[10]; handle = asm_begin(env); /* Transform (SETF fname) => fname */ if (!Null(name) && Null(si_valid_function_name_p(name))) FEprogram_error_noreturn("LAMBDA: Not a valid function name ~S",1,name); /* We register as special variable a symbol which is not * to be used. We use this to mark the boundary of a function * environment and when code-walking */ c_register_var(env, @'si::function-boundary', TRUE, FALSE); reqs = ECL_CONS_CDR(reqs); /* Required arguments */ while (!Null(reqs)) { cl_object var = pop(&reqs); asm_op(env, OP_POPREQ); c_bind(env, var, specials); } opts = ECL_CONS_CDR(opts); while (!Null(opts)) { /* Optional arguments */ cl_object var = pop(&opts); cl_object stmt = pop(&opts); cl_object flag = pop(&opts); asm_op(env, OP_POPOPT); c_default(env, var, stmt, flag, specials); } if (Null(rest) && Null(key)) { /* Check no excess arguments */ asm_op(env, OP_NOMORE); } if (!Null(rest)) { /* &rest argument */ asm_op(env, OP_POPREST); c_bind(env, rest, specials); } if (!Null(key)) { cl_object aux = CONS(allow_other_keys,ECL_NIL); cl_object names = ECL_NIL; asm_op2c(env, OP_PUSHKEYS, aux); keys = ECL_CONS_CDR(keys); while (!Null(keys)) { cl_object name = pop(&keys); cl_object var = pop(&keys); cl_object stmt = pop(&keys); cl_object flag = pop(&keys); names = CONS(name, names); asm_op(env, OP_POP); c_default(env, var, stmt, flag, specials); } ECL_RPLACD(aux, names); } while (!Null(auxs)) { /* Local bindings */ cl_object var = pop(&auxs); cl_object value = pop(&auxs); compile_form(env, value, FLAG_REG0); c_bind(env, var, specials); } c_declare_specials(env, specials); if (!Null(name)) { compile_form(env, @list*(3, @'block', si_function_block_name(name), body), FLAG_VALUES); } else { while (!Null(decl)) { cl_object l = ECL_CONS_CAR(decl); if (ECL_CONSP(l) && ECL_CONS_CAR(l) == @'si::function-block-name') { name = ECL_CONS_CAR(ECL_CONS_CDR(l)); break; } decl = ECL_CONS_CDR(decl); } compile_body(env, body, FLAG_VALUES); } /* Only undo special bindings */ c_undo_bindings(env, old_c_env->variables, 1); asm_op(env, OP_EXIT); if (Null(ecl_symbol_value(@'si::*keep-definitions*'))) lambda = ECL_NIL; output = asm_end(env, handle, lambda); output->bytecodes.name = name; old_c_env->load_time_forms = env->c_env->load_time_forms; env->c_env = old_c_env; ecl_bds_unwind1(env); return output; } static cl_object ecl_function_block_name(cl_object name) { if (ECL_SYMBOLP(name)) { return name; } else if (CONSP(name) && ECL_CONS_CAR(name) == @'setf') { name = ECL_CONS_CDR(name); if (CONSP(name)) { cl_object output = ECL_CONS_CAR(name); if (ECL_SYMBOLP(output) && Null(ECL_CONS_CDR(name))) return output; } } return NULL; } cl_object si_function_block_name(cl_object name) { cl_object output = ecl_function_block_name(name); if (!output) FEinvalid_function_name(name); @(return output) } cl_object si_valid_function_name_p(cl_object name) { name = ecl_function_block_name(name); @(return (name? ECL_T : ECL_NIL)) } cl_object si_make_lambda(cl_object name, cl_object rest) { cl_object lambda; const cl_env_ptr the_env = ecl_process_env(); volatile cl_compiler_env_ptr old_c_env = the_env->c_env; struct cl_compiler_env new_c_env; c_new_env(the_env, &new_c_env, ECL_NIL, 0); ECL_UNWIND_PROTECT_BEGIN(the_env) { lambda = ecl_make_lambda(the_env, name, rest); } ECL_UNWIND_PROTECT_EXIT { the_env->c_env = old_c_env; } ECL_UNWIND_PROTECT_END; @(return lambda) } @(defun si::eval-with-env (form &optional (env ECL_NIL) (stepping ECL_NIL) (compiler_env_p ECL_NIL) (execute ECL_T)) volatile cl_compiler_env_ptr old_c_env; struct cl_compiler_env new_c_env; cl_object interpreter_env, compiler_env; @ /* * Compile to bytecodes. */ if (compiler_env_p == ECL_NIL) { interpreter_env = env; compiler_env = ECL_NIL; } else { interpreter_env = ECL_NIL; compiler_env = env; } old_c_env = the_env->c_env; c_new_env(the_env, &new_c_env, compiler_env, 0); guess_environment(the_env, interpreter_env); new_c_env.lex_env = env; new_c_env.stepping = stepping != ECL_NIL; ECL_UNWIND_PROTECT_BEGIN(the_env) { if (Null(execute)) { cl_index handle = asm_begin(the_env); new_c_env.mode = FLAG_LOAD; /*cl_print(1,form);*/ compile_with_load_time_forms(the_env, form, FLAG_VALUES); asm_op(the_env, OP_EXIT); the_env->values[0] = asm_end(the_env, handle, form); the_env->nvalues = 1; } else { eval_form(the_env, form); } } ECL_UNWIND_PROTECT_EXIT { /* Clear up */ the_env->c_env = old_c_env; memset(&new_c_env, 0, sizeof(new_c_env)); } ECL_UNWIND_PROTECT_END; return the_env->values[0]; @) void init_compiler() { cl_object dispatch_table = cl_core.compiler_dispatch = cl__make_hash_table(@'eq', ecl_make_fixnum(128), /* size */ cl_core.rehash_size, cl_core.rehash_threshold); int i; for (i = 0; database[i].symbol; i++) { ecl_sethash(database[i].symbol, dispatch_table, ecl_make_fixnum(i)); } } ecl-16.1.2/src/c/cons.d000066400000000000000000000601631266352375300145060ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* cons.d -- list manipulation macros & functions */ /* Copyright (c) 2011, Juan Jose Garcia-Ripoll ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #include /* BEGIN-GENERATED (gen-cons-d) */ #if !ECL_CAN_INLINE cl_object _ecl_car(cl_object x) { if (Null(x)) return x; x = ECL_CONS_CAR(x); return x; } cl_object _ecl_cdr(cl_object x) { if (Null(x)) return x; x = ECL_CONS_CDR(x); return x; } cl_object _ecl_caar(cl_object x) { if (Null(x)) return x; x = ECL_CONS_CAR(x); if (Null(x)) return x; x = ECL_CONS_CAR(x); return x; } cl_object _ecl_cdar(cl_object x) { if (Null(x)) return x; x = ECL_CONS_CAR(x); if (Null(x)) return x; x = ECL_CONS_CDR(x); return x; } cl_object _ecl_cadr(cl_object x) { if (Null(x)) return x; x = ECL_CONS_CDR(x); if (Null(x)) return x; x = ECL_CONS_CAR(x); return x; } cl_object _ecl_cddr(cl_object x) { if (Null(x)) return x; x = ECL_CONS_CDR(x); if (Null(x)) return x; x = ECL_CONS_CDR(x); return x; } cl_object _ecl_caaar(cl_object x) { if (Null(x)) return x; x = ECL_CONS_CAR(x); if (Null(x)) return x; x = ECL_CONS_CAR(x); if (Null(x)) return x; x = ECL_CONS_CAR(x); return x; } cl_object _ecl_cdaar(cl_object x) { if (Null(x)) return x; x = ECL_CONS_CAR(x); if (Null(x)) return x; x = ECL_CONS_CAR(x); if (Null(x)) return x; x = ECL_CONS_CDR(x); return x; } cl_object _ecl_cadar(cl_object x) { if (Null(x)) return x; x = ECL_CONS_CAR(x); if (Null(x)) return x; x = ECL_CONS_CDR(x); if (Null(x)) return x; x = ECL_CONS_CAR(x); return x; } cl_object _ecl_cddar(cl_object x) { if (Null(x)) return x; x = ECL_CONS_CAR(x); if (Null(x)) return x; x = ECL_CONS_CDR(x); if (Null(x)) return x; x = ECL_CONS_CDR(x); return x; } cl_object _ecl_caadr(cl_object x) { if (Null(x)) return x; x = ECL_CONS_CDR(x); if (Null(x)) return x; x = ECL_CONS_CAR(x); if (Null(x)) return x; x = ECL_CONS_CAR(x); return x; } cl_object _ecl_cdadr(cl_object x) { if (Null(x)) return x; x = ECL_CONS_CDR(x); if (Null(x)) return x; x = ECL_CONS_CAR(x); if (Null(x)) return x; x = ECL_CONS_CDR(x); return x; } cl_object _ecl_caddr(cl_object x) { if (Null(x)) return x; x = ECL_CONS_CDR(x); if (Null(x)) return x; x = ECL_CONS_CDR(x); if (Null(x)) return x; x = ECL_CONS_CAR(x); return x; } cl_object _ecl_cdddr(cl_object x) { if (Null(x)) return x; x = ECL_CONS_CDR(x); if (Null(x)) return x; x = ECL_CONS_CDR(x); if (Null(x)) return x; x = ECL_CONS_CDR(x); return x; } cl_object _ecl_caaaar(cl_object x) { if (Null(x)) return x; x = ECL_CONS_CAR(x); if (Null(x)) return x; x = ECL_CONS_CAR(x); if (Null(x)) return x; x = ECL_CONS_CAR(x); if (Null(x)) return x; x = ECL_CONS_CAR(x); return x; } cl_object _ecl_cdaaar(cl_object x) { if (Null(x)) return x; x = ECL_CONS_CAR(x); if (Null(x)) return x; x = ECL_CONS_CAR(x); if (Null(x)) return x; x = ECL_CONS_CAR(x); if (Null(x)) return x; x = ECL_CONS_CDR(x); return x; } cl_object _ecl_cadaar(cl_object x) { if (Null(x)) return x; x = ECL_CONS_CAR(x); if (Null(x)) return x; x = ECL_CONS_CAR(x); if (Null(x)) return x; x = ECL_CONS_CDR(x); if (Null(x)) return x; x = ECL_CONS_CAR(x); return x; } cl_object _ecl_cddaar(cl_object x) { if (Null(x)) return x; x = ECL_CONS_CAR(x); if (Null(x)) return x; x = ECL_CONS_CAR(x); if (Null(x)) return x; x = ECL_CONS_CDR(x); if (Null(x)) return x; x = ECL_CONS_CDR(x); return x; } cl_object _ecl_caadar(cl_object x) { if (Null(x)) return x; x = ECL_CONS_CAR(x); if (Null(x)) return x; x = ECL_CONS_CDR(x); if (Null(x)) return x; x = ECL_CONS_CAR(x); if (Null(x)) return x; x = ECL_CONS_CAR(x); return x; } cl_object _ecl_cdadar(cl_object x) { if (Null(x)) return x; x = ECL_CONS_CAR(x); if (Null(x)) return x; x = ECL_CONS_CDR(x); if (Null(x)) return x; x = ECL_CONS_CAR(x); if (Null(x)) return x; x = ECL_CONS_CDR(x); return x; } cl_object _ecl_caddar(cl_object x) { if (Null(x)) return x; x = ECL_CONS_CAR(x); if (Null(x)) return x; x = ECL_CONS_CDR(x); if (Null(x)) return x; x = ECL_CONS_CDR(x); if (Null(x)) return x; x = ECL_CONS_CAR(x); return x; } cl_object _ecl_cdddar(cl_object x) { if (Null(x)) return x; x = ECL_CONS_CAR(x); if (Null(x)) return x; x = ECL_CONS_CDR(x); if (Null(x)) return x; x = ECL_CONS_CDR(x); if (Null(x)) return x; x = ECL_CONS_CDR(x); return x; } cl_object _ecl_caaadr(cl_object x) { if (Null(x)) return x; x = ECL_CONS_CDR(x); if (Null(x)) return x; x = ECL_CONS_CAR(x); if (Null(x)) return x; x = ECL_CONS_CAR(x); if (Null(x)) return x; x = ECL_CONS_CAR(x); return x; } cl_object _ecl_cdaadr(cl_object x) { if (Null(x)) return x; x = ECL_CONS_CDR(x); if (Null(x)) return x; x = ECL_CONS_CAR(x); if (Null(x)) return x; x = ECL_CONS_CAR(x); if (Null(x)) return x; x = ECL_CONS_CDR(x); return x; } cl_object _ecl_cadadr(cl_object x) { if (Null(x)) return x; x = ECL_CONS_CDR(x); if (Null(x)) return x; x = ECL_CONS_CAR(x); if (Null(x)) return x; x = ECL_CONS_CDR(x); if (Null(x)) return x; x = ECL_CONS_CAR(x); return x; } cl_object _ecl_cddadr(cl_object x) { if (Null(x)) return x; x = ECL_CONS_CDR(x); if (Null(x)) return x; x = ECL_CONS_CAR(x); if (Null(x)) return x; x = ECL_CONS_CDR(x); if (Null(x)) return x; x = ECL_CONS_CDR(x); return x; } cl_object _ecl_caaddr(cl_object x) { if (Null(x)) return x; x = ECL_CONS_CDR(x); if (Null(x)) return x; x = ECL_CONS_CDR(x); if (Null(x)) return x; x = ECL_CONS_CAR(x); if (Null(x)) return x; x = ECL_CONS_CAR(x); return x; } cl_object _ecl_cdaddr(cl_object x) { if (Null(x)) return x; x = ECL_CONS_CDR(x); if (Null(x)) return x; x = ECL_CONS_CDR(x); if (Null(x)) return x; x = ECL_CONS_CAR(x); if (Null(x)) return x; x = ECL_CONS_CDR(x); return x; } cl_object _ecl_cadddr(cl_object x) { if (Null(x)) return x; x = ECL_CONS_CDR(x); if (Null(x)) return x; x = ECL_CONS_CDR(x); if (Null(x)) return x; x = ECL_CONS_CDR(x); if (Null(x)) return x; x = ECL_CONS_CAR(x); return x; } cl_object _ecl_cddddr(cl_object x) { if (Null(x)) return x; x = ECL_CONS_CDR(x); if (Null(x)) return x; x = ECL_CONS_CDR(x); if (Null(x)) return x; x = ECL_CONS_CDR(x); if (Null(x)) return x; x = ECL_CONS_CDR(x); return x; } #endif /* !ECL_CAN_INLINE */ cl_object ecl_car(cl_object x) { if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CAR(x); return x; } cl_object ecl_cdr(cl_object x) { if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CDR(x); return x; } cl_object ecl_caar(cl_object x) { if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CAR(x); if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CAR(x); return x; } cl_object ecl_cdar(cl_object x) { if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CAR(x); if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CDR(x); return x; } cl_object ecl_cadr(cl_object x) { if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CDR(x); if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CAR(x); return x; } cl_object ecl_cddr(cl_object x) { if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CDR(x); if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CDR(x); return x; } cl_object ecl_caaar(cl_object x) { if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CAR(x); if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CAR(x); if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CAR(x); return x; } cl_object ecl_cdaar(cl_object x) { if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CAR(x); if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CAR(x); if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CDR(x); return x; } cl_object ecl_cadar(cl_object x) { if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CAR(x); if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CDR(x); if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CAR(x); return x; } cl_object ecl_cddar(cl_object x) { if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CAR(x); if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CDR(x); if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CDR(x); return x; } cl_object ecl_caadr(cl_object x) { if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CDR(x); if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CAR(x); if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CAR(x); return x; } cl_object ecl_cdadr(cl_object x) { if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CDR(x); if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CAR(x); if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CDR(x); return x; } cl_object ecl_caddr(cl_object x) { if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CDR(x); if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CDR(x); if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CAR(x); return x; } cl_object ecl_cdddr(cl_object x) { if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CDR(x); if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CDR(x); if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CDR(x); return x; } cl_object ecl_caaaar(cl_object x) { if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CAR(x); if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CAR(x); if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CAR(x); if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CAR(x); return x; } cl_object ecl_cdaaar(cl_object x) { if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CAR(x); if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CAR(x); if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CAR(x); if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CDR(x); return x; } cl_object ecl_cadaar(cl_object x) { if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CAR(x); if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CAR(x); if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CDR(x); if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CAR(x); return x; } cl_object ecl_cddaar(cl_object x) { if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CAR(x); if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CAR(x); if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CDR(x); if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CDR(x); return x; } cl_object ecl_caadar(cl_object x) { if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CAR(x); if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CDR(x); if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CAR(x); if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CAR(x); return x; } cl_object ecl_cdadar(cl_object x) { if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CAR(x); if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CDR(x); if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CAR(x); if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CDR(x); return x; } cl_object ecl_caddar(cl_object x) { if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CAR(x); if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CDR(x); if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CDR(x); if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CAR(x); return x; } cl_object ecl_cdddar(cl_object x) { if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CAR(x); if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CDR(x); if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CDR(x); if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CDR(x); return x; } cl_object ecl_caaadr(cl_object x) { if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CDR(x); if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CAR(x); if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CAR(x); if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CAR(x); return x; } cl_object ecl_cdaadr(cl_object x) { if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CDR(x); if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CAR(x); if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CAR(x); if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CDR(x); return x; } cl_object ecl_cadadr(cl_object x) { if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CDR(x); if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CAR(x); if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CDR(x); if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CAR(x); return x; } cl_object ecl_cddadr(cl_object x) { if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CDR(x); if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CAR(x); if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CDR(x); if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CDR(x); return x; } cl_object ecl_caaddr(cl_object x) { if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CDR(x); if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CDR(x); if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CAR(x); if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CAR(x); return x; } cl_object ecl_cdaddr(cl_object x) { if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CDR(x); if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CDR(x); if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CAR(x); if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CDR(x); return x; } cl_object ecl_cadddr(cl_object x) { if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CDR(x); if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CDR(x); if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CDR(x); if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CAR(x); return x; } cl_object ecl_cddddr(cl_object x) { if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CDR(x); if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CDR(x); if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CDR(x); if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]); if (Null(x)) return x; x = ECL_CONS_CDR(x); return x; } cl_object cl_car(cl_object x) { const cl_env_ptr the_env = ecl_process_env(); ecl_return1(the_env, ecl_car(x)); } cl_object cl_cdr(cl_object x) { const cl_env_ptr the_env = ecl_process_env(); ecl_return1(the_env, ecl_cdr(x)); } cl_object cl_caar(cl_object x) { const cl_env_ptr the_env = ecl_process_env(); ecl_return1(the_env, ecl_caar(x)); } cl_object cl_cdar(cl_object x) { const cl_env_ptr the_env = ecl_process_env(); ecl_return1(the_env, ecl_cdar(x)); } cl_object cl_cadr(cl_object x) { const cl_env_ptr the_env = ecl_process_env(); ecl_return1(the_env, ecl_cadr(x)); } cl_object cl_cddr(cl_object x) { const cl_env_ptr the_env = ecl_process_env(); ecl_return1(the_env, ecl_cddr(x)); } cl_object cl_caaar(cl_object x) { const cl_env_ptr the_env = ecl_process_env(); ecl_return1(the_env, ecl_caaar(x)); } cl_object cl_cdaar(cl_object x) { const cl_env_ptr the_env = ecl_process_env(); ecl_return1(the_env, ecl_cdaar(x)); } cl_object cl_cadar(cl_object x) { const cl_env_ptr the_env = ecl_process_env(); ecl_return1(the_env, ecl_cadar(x)); } cl_object cl_cddar(cl_object x) { const cl_env_ptr the_env = ecl_process_env(); ecl_return1(the_env, ecl_cddar(x)); } cl_object cl_caadr(cl_object x) { const cl_env_ptr the_env = ecl_process_env(); ecl_return1(the_env, ecl_caadr(x)); } cl_object cl_cdadr(cl_object x) { const cl_env_ptr the_env = ecl_process_env(); ecl_return1(the_env, ecl_cdadr(x)); } cl_object cl_caddr(cl_object x) { const cl_env_ptr the_env = ecl_process_env(); ecl_return1(the_env, ecl_caddr(x)); } cl_object cl_cdddr(cl_object x) { const cl_env_ptr the_env = ecl_process_env(); ecl_return1(the_env, ecl_cdddr(x)); } cl_object cl_caaaar(cl_object x) { const cl_env_ptr the_env = ecl_process_env(); ecl_return1(the_env, ecl_caaaar(x)); } cl_object cl_cdaaar(cl_object x) { const cl_env_ptr the_env = ecl_process_env(); ecl_return1(the_env, ecl_cdaaar(x)); } cl_object cl_cadaar(cl_object x) { const cl_env_ptr the_env = ecl_process_env(); ecl_return1(the_env, ecl_cadaar(x)); } cl_object cl_cddaar(cl_object x) { const cl_env_ptr the_env = ecl_process_env(); ecl_return1(the_env, ecl_cddaar(x)); } cl_object cl_caadar(cl_object x) { const cl_env_ptr the_env = ecl_process_env(); ecl_return1(the_env, ecl_caadar(x)); } cl_object cl_cdadar(cl_object x) { const cl_env_ptr the_env = ecl_process_env(); ecl_return1(the_env, ecl_cdadar(x)); } cl_object cl_caddar(cl_object x) { const cl_env_ptr the_env = ecl_process_env(); ecl_return1(the_env, ecl_caddar(x)); } cl_object cl_cdddar(cl_object x) { const cl_env_ptr the_env = ecl_process_env(); ecl_return1(the_env, ecl_cdddar(x)); } cl_object cl_caaadr(cl_object x) { const cl_env_ptr the_env = ecl_process_env(); ecl_return1(the_env, ecl_caaadr(x)); } cl_object cl_cdaadr(cl_object x) { const cl_env_ptr the_env = ecl_process_env(); ecl_return1(the_env, ecl_cdaadr(x)); } cl_object cl_cadadr(cl_object x) { const cl_env_ptr the_env = ecl_process_env(); ecl_return1(the_env, ecl_cadadr(x)); } cl_object cl_cddadr(cl_object x) { const cl_env_ptr the_env = ecl_process_env(); ecl_return1(the_env, ecl_cddadr(x)); } cl_object cl_caaddr(cl_object x) { const cl_env_ptr the_env = ecl_process_env(); ecl_return1(the_env, ecl_caaddr(x)); } cl_object cl_cdaddr(cl_object x) { const cl_env_ptr the_env = ecl_process_env(); ecl_return1(the_env, ecl_cdaddr(x)); } cl_object cl_cadddr(cl_object x) { const cl_env_ptr the_env = ecl_process_env(); ecl_return1(the_env, ecl_cadddr(x)); } cl_object cl_cddddr(cl_object x) { const cl_env_ptr the_env = ecl_process_env(); ecl_return1(the_env, ecl_cddddr(x)); } /* END-GENERATED */ ecl-16.1.2/src/c/coverity/000077500000000000000000000000001266352375300152355ustar00rootroot00000000000000ecl-16.1.2/src/c/coverity/model.c000066400000000000000000000025201266352375300165000ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* This is free and unencumbered software released into the public domain. */ /** * Coverity Scan model for ECL. * * This is a modeling file for the Coverity Scan static analysis service. * Modeling helps to avoid false positives. Some rules for model files: * * - A model file cannot import any header files. * - Therefore only built-in standard language symbols are available; * for example, `char`, `int`, and `void` are defined, `NULL` isn't. * - Modeling doesn't require genuine definitions for structs and typedefs. * Typedefs that expand to rudimentary structs will suffice. * - Uninitialized local pointers are not errors, but rather signify that * a variable could either be `NULL` or point at some data. * * Note that Coverity Scan doesn't automatically pick up changes to this * file. New versions of the model file must be uploaded by an admin at: * https://scan.coverity.com/projects/3235?tab=analysis_settings * * @author Arto Bendiken * @see https://scan.coverity.com/tune */ #define NULL ((void*)0) typedef void* cl_object; typedef int cl_narg; void FEwrong_type_nth_arg(cl_object function, cl_narg narg, cl_object value, cl_object type) { __coverity_panic__(); } ecl-16.1.2/src/c/disassembler.d000066400000000000000000000632471266352375300162270ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* disassembler.c -- Byte compiler and function evaluator */ /* Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #include #include #include static cl_opcode *disassemble(cl_object bytecodes, cl_opcode *vector); static cl_opcode *base = NULL; static void print_noarg(const char *s) { ecl_princ_str(s, ECL_NIL); } static void print_oparg(const char *s, cl_fixnum n) { ecl_princ_str(s, ECL_NIL); ecl_princ(ecl_make_fixnum(n), ECL_NIL); } static void print_arg(const char *s, cl_object x) { ecl_princ_str(s, ECL_NIL); ecl_princ(x, ECL_NIL); } static void print_oparg_arg(const char *s, cl_fixnum n, cl_object x) { ecl_princ_str(s, ECL_NIL); ecl_princ(ecl_make_fixnum(n), ECL_NIL); ecl_princ_str(",", ECL_NIL); ecl_princ(x, ECL_NIL); } #define GET_DATA(r,v,data) { \ cl_oparg ndx; \ GET_OPARG(ndx, v); \ r = data[ndx]; \ } static void disassemble_lambda(cl_object bytecodes) { const cl_env_ptr env = ecl_process_env(); cl_object *data; cl_opcode *vector; ecl_bds_bind(env, @'*print-pretty*', ECL_NIL); /* Print required arguments */ data = bytecodes->bytecodes.data->vector.self.t; cl_print(1,bytecodes->bytecodes.data); /* Name of LAMBDA */ print_arg("\nName:\t\t", bytecodes->bytecodes.name); if (bytecodes->bytecodes.name == OBJNULL || bytecodes->bytecodes.name == @'si::bytecodes') { print_noarg("\nEvaluated form:"); goto NO_ARGS; } NO_ARGS: base = vector = (cl_opcode *)bytecodes->bytecodes.code; disassemble(bytecodes, vector); ecl_bds_unwind1(env); } /* -------------------- DISASSEMBLER CORE -------------------- */ /* OP_FLET nfun{arg}, fun1{object} ... Executes the enclosed code in a lexical enviroment extended with the functions "fun1" ... "funn". */ static cl_opcode * disassemble_flet(cl_object bytecodes, cl_opcode *vector) { cl_index nfun; cl_object *data = bytecodes->bytecodes.data->vector.self.t; GET_OPARG(nfun, vector); print_noarg("FLET"); while (nfun--) { cl_object fun; GET_DATA(fun, vector, data); print_arg("\n\tFLET\t", fun->bytecodes.name); } return vector; } /* OP_LABELS nfun{arg}, fun1{object} ... Executes the enclosed code in a lexical enviroment extended with the functions "fun1" ... "funn". */ static cl_opcode * disassemble_labels(cl_object bytecodes, cl_opcode *vector) { cl_index nfun; cl_object *data = bytecodes->bytecodes.data->vector.self.t; GET_OPARG(nfun, vector); print_noarg("LABELS"); while (nfun--) { cl_object fun; GET_DATA(fun, vector, data); print_arg("\n\tLABELS\t", fun->bytecodes.name); } return vector; } /* OP_PROGV bindings{list} ... OP_EXIT Execute the code enclosed with the special variables in BINDINGS set to the values in the list which was passed in VALUES(0). */ static cl_opcode * disassemble_progv(cl_object bytecodes, cl_opcode *vector) { print_noarg("PROGV"); vector = disassemble(bytecodes, vector); print_noarg("\t\t; progv"); return vector; } /* OP_TAGBODY n{arg} label1 ... labeln label1: ... labeln: ... OP_EXIT High level construct for the TAGBODY form. */ static cl_opcode * disassemble_tagbody(cl_object bytecodes, cl_opcode *vector) { cl_index i, ntags; cl_opcode *destination; GET_OPARG(ntags, vector); print_noarg("TAGBODY"); for (i=0; ibytecodes.data->vector.self.t; cl_object line_no; if (cl_fboundp(@'si::formatter-aux') != ECL_NIL) line_format = make_constant_base_string("~%~4d\t"); else line_format = ECL_NIL; BEGIN: if (1) { line_no = ecl_make_fixnum(vector-base); } else { line_no = @'*'; } if (line_format != ECL_NIL) { cl_format(3, ECL_T, line_format, line_no); } else { ecl_princ_char('\n', ECL_NIL); ecl_princ(line_no, ECL_NIL); ecl_princ_char('\t', ECL_NIL); } switch (GET_OPCODE(vector)) { /* OP_NOP Sets VALUES(0) = NIL and NVALUES = 1 */ case OP_NOP: string = "NOP"; goto NOARG; case OP_INT: string = "QUOTE\t"; GET_OPARG(n, vector); goto OPARG; case OP_PINT: string = "PUSH\t"; GET_OPARG(n, vector); goto OPARG; /* OP_QUOTE Sets VALUES(0) to an immediate value. */ case OP_QUOTE: string = "QUOTE\t"; GET_DATA(o, vector, data); goto ARG; /* OP_CSET n{arg} Replace constant with a computed value */ case OP_CSET: string = "CSET\t"; GET_OPARG(n, vector); goto OPARG; /* OP_VAR n{arg} Sets NVALUES=1 and VALUES(0) to the value of the n-th local. */ case OP_VAR: string = "VAR\t"; GET_OPARG(n, vector); goto OPARG; /* OP_VARS var{symbol} Sets NVALUES=1 and VALUES(0) to the value of the symbol VAR. VAR should be either a special variable or a constant. */ case OP_VARS: string = "VARS\t"; GET_DATA(o, vector, data); goto ARG; /* OP_PUSH Pushes the object in VALUES(0). */ case OP_PUSH: string = "PUSH\tVALUES(0)"; goto NOARG; case OP_VALUEREG0: string = "SET\tVALUES(0),REG0"; goto NOARG; /* OP_PUSHV n{arg} Pushes the value of the n-th local onto the stack. */ case OP_PUSHV: string = "PUSHV\t"; GET_OPARG(n, vector); goto OPARG; /* OP_PUSHVS var{symbol} Pushes the value of the symbol VAR onto the stack. VAR should be either a special variable or a constant. */ case OP_PUSHVS: string = "PUSHVS\t"; GET_DATA(o, vector, data); goto ARG; /* OP_PUSHQ value{object} Pushes "value" onto the stack. */ case OP_PUSHQ: string = "PUSH\t'"; GET_DATA(o, vector, data); goto ARG; /* OP_PUSHVALUES Pushes the values output by the last form, plus the number of values. */ case OP_PUSHVALUES: string = "PUSH\tVALUES"; goto NOARG; /* OP_PUSHMOREVALUES Adds more values to the ones pushed by OP_PUSHVALUES. */ case OP_PUSHMOREVALUES: string = "PUSH\tMORE VALUES"; goto NOARG; /* OP_POP Pops a single value pushed by a OP_PUSH[V[S]] operator. */ case OP_POP: string = "POP"; goto NOARG; /* OP_POP1 Pops a single value pushed by a OP_PUSH[V[S]] operator. */ case OP_POP1: string = "POP1"; goto NOARG; /* OP_POPVALUES Pops all values pushed by a OP_PUSHVALUES operator. */ case OP_POPVALUES: string = "POP\tVALUES"; goto NOARG; case OP_BLOCK: string = "BLOCK\t"; GET_DATA(o, vector, data); goto ARG; case OP_CATCH: string = "CATCH\tREG0"; goto NOARG; case OP_DO: string = "BLOCK\t"; o = ECL_NIL; goto ARG; case OP_FRAME: string = "FRAME\t"; goto JMP; /* OP_CALL n{arg} Calls the function in VALUES(0) with N arguments which have been deposited in the stack. The output values are left in VALUES(...) */ case OP_CALL: string = "CALL\t"; GET_OPARG(n, vector); goto OPARG; /* OP_CALLG n{arg}, name{arg} Calls the function NAME with N arguments which have been deposited in the stack. The output values are left in VALUES. */ case OP_CALLG: string = "CALLG\t"; GET_OPARG(n, vector); GET_DATA(o, vector, data); goto OPARG_ARG; /* OP_FCALL n{arg} Calls the function in the stack with N arguments which have been also deposited in the stack. The output values are left in VALUES(...) */ case OP_STEPCALL: case OP_FCALL: string = "FCALL\t"; GET_OPARG(n, vector); goto OPARG; /* OP_MCALL Similar to FCALL, but gets the number of arguments from the stack (They all have been deposited by OP_PUSHVALUES) */ case OP_MCALL: string = "MCALL"; goto NOARG; /* OP_POPREQ Extracts next required argument. */ case OP_POPREQ: string = "POP\tREQ"; goto NOARG; /* OP_NOMORE Ensure there are no more arguments. */ case OP_NOMORE: string = "NOMORE"; goto NOARG; /* OP_POPOPT Extracts next optional argument. */ case OP_POPOPT: string = "POP\tOPT"; goto NOARG; /* OP_POPREST Extracts list of remaining arguments. */ case OP_POPREST: string = "POP\tREST"; goto NOARG; /* OP_PUSHKEYS Parses the keyword arguments */ case OP_PUSHKEYS: string = "PUSH\tKEYS "; GET_DATA(o, vector, data); goto ARG; /* OP_EXIT Marks the end of a high level construct */ case OP_EXIT: print_noarg("EXIT"); return vector; /* OP_EXIT_FRAME Marks the end of a high level construct (BLOCK, CATCH...) */ case OP_EXIT_FRAME: string = "EXIT\tFRAME"; goto NOARG; /* OP_EXIT_TAGBODY Marks the end of a high level construct (TAGBODY) */ case OP_EXIT_TAGBODY: print_noarg("EXIT\tTAGBODY"); return vector; case OP_FLET: vector = disassemble_flet(bytecodes, vector); break; case OP_LABELS: vector = disassemble_labels(bytecodes, vector); break; /* OP_LFUNCTION name{symbol} Extracts the function associated to a symbol. The function may be defined in the global environment or in the local environment. This last value takes precedence. */ case OP_LFUNCTION: string = "LOCFUNC\t"; GET_OPARG(n, vector); goto OPARG; /* OP_FUNCTION name{symbol} Extracts the function associated to a symbol. The function may be defined in the global environment or in the local environment. This last value takes precedence. */ case OP_FUNCTION: string = "SYMFUNC\t"; GET_DATA(o, vector, data); goto ARG; /* OP_CLOSE name{arg} Extracts the function associated to a symbol. The function may be defined in the global environment or in the local environment. This last value takes precedence. */ case OP_CLOSE: string = "CLOSE\t"; GET_DATA(o, vector, data); goto ARG; /* OP_GO n{arg}, tag-ndx{arg} OP_QUOTE tag-name{symbol} Jumps to the tag which is defined at the n-th position in the lexical environment. TAG-NAME is kept for debugging purposes. */ case OP_GO: string = "GO\t"; GET_OPARG(n, vector); GET_OPARG(m, vector); o = ecl_make_fixnum(m); goto OPARG_ARG; /* OP_RETURN n{arg} Returns from the block whose record in the lexical environment occuppies the n-th position. */ case OP_RETURN: string = "RETFROM"; GET_OPARG(n, vector); goto OPARG; /* OP_THROW Jumps to an enclosing CATCH form whose tag matches the one of the THROW. The tag is taken from the stack, while the output values are left in VALUES(...). */ case OP_THROW: string = "THROW"; goto NOARG; /* OP_JMP label{arg} OP_JNIL label{arg} OP_JT label{arg} OP_JEQ label{arg}, value{object} OP_JNEQ label{arg}, value{object} Direct or conditional jumps. The conditional jumps are made comparing with the value of VALUES(0). */ case OP_JMP: string = "JMP\t"; goto JMP; case OP_JNIL: string = "JNIL\t"; goto JMP; case OP_JT: string = "JT\t"; JMP: { GET_OPARG(m, vector); n = vector + m - OPARG_SIZE - base; goto OPARG; } case OP_JEQL: string = "JEQL\t"; goto JEQL; case OP_JNEQL: string = "JNEQL\t"; JEQL: { GET_DATA(o, vector, data); GET_OPARG(m, vector); n = vector + m - OPARG_SIZE - base; goto OPARG_ARG; } case OP_NOT: string = "NOT"; goto NOARG; /* OP_UNBIND n{arg} Undo "n" bindings of lexical variables. */ case OP_UNBIND: string = "UNBIND\t"; GET_OPARG(n, vector); goto OPARG; /* OP_UNBINDS n{arg} Undo "n" bindings of special variables. */ case OP_UNBINDS: string = "UNBINDS\t"; GET_OPARG(n, vector); goto OPARG; /* OP_BIND name{symbol} OP_PBIND name{symbol} OP_BINDS name{symbol} OP_PBINDS name{symbol} Binds a lexical or special variable to the either the value of VALUES(0), to the first value of the stack, or to the n-th value of VALUES(...). */ case OP_BIND: string = "BIND\t"; GET_DATA(o, vector, data); goto ARG; case OP_PBIND: string = "PBIND\t"; GET_DATA(o, vector, data); goto ARG; case OP_VBIND: string = "VBIND\t"; GET_OPARG(n, vector); GET_DATA(o, vector, data); goto OPARG_ARG; case OP_BINDS: string = "BINDS\t"; GET_DATA(o, vector, data); goto ARG; case OP_PBINDS: string = "PBINDS\t"; GET_DATA(o, vector, data); goto ARG; case OP_VBINDS: string = "VBINDS\t"; GET_OPARG(n, vector); GET_DATA(o, vector, data); goto OPARG_ARG; /* OP_SETQ n{arg} OP_PSETQ n{arg} OP_SETQS var-name{symbol} OP_PSETQS var-name{symbol} Sets either the n-th local or a special variable VAR-NAME, to either the value in VALUES(0) (OP_SETQ[S]) or to the first value on the stack (OP_PSETQ[S]). */ case OP_SETQ: string = "SETQ\t"; GET_OPARG(n, vector); goto OPARG; case OP_PSETQ: string = "PSETQ\t"; GET_OPARG(n, vector); goto OPARG; case OP_VSETQ: string = "VSETQ\t"; GET_OPARG(m, vector); o = ecl_make_fixnum(m); GET_OPARG(n, vector); goto OPARG_ARG; case OP_SETQS: string = "SETQS\t"; GET_DATA(o, vector, data); goto ARG; case OP_PSETQS: string = "PSETQS\t"; GET_DATA(o, vector, data); goto ARG; case OP_VSETQS: string = "VSETQS\t"; GET_DATA(o, vector, data); GET_OPARG(n, vector); goto OPARG_ARG; case OP_PROGV: vector = disassemble_progv(bytecodes, vector); break; case OP_EXIT_PROGV: print_noarg("PROGV\tEXIT"); return vector; /* OP_VALUES n{arg} Pop N values from the stack and store them in VALUES(...) */ case OP_VALUES: string = "VALUES\t"; GET_OPARG(n, vector); goto OPARG; /* OP_NTHVAL Set VALUES(0) to the N-th value of the VALUES(...) list. The index N-th is extracted from the top of the stack. */ case OP_NTHVAL: string = "NTHVAL\t"; goto NOARG; case OP_TAGBODY: vector = disassemble_tagbody(bytecodes, vector); break; case OP_PROTECT: string = "PROTECT\t"; goto JMP; case OP_PROTECT_NORMAL: string = "PROTECT\tNORMAL"; goto NOARG; case OP_PROTECT_EXIT: string = "PROTECT\tEXIT"; goto NOARG; case OP_NIL: string = "QUOTE\tNIL"; goto NOARG; case OP_PUSHNIL: string = "PUSH\t'NIL"; goto NOARG; case OP_STEPIN: string = "STEP\tIN,"; GET_DATA(o, vector, data); goto ARG; case OP_STEPOUT: string = "STEP\tOUT"; goto NOARG; case OP_CONS: string = "CONS"; goto NOARG; case OP_ENDP: string = "ENDP\tREG0"; goto NOARG; case OP_CAR: string = "CAR\tREG0"; goto NOARG; case OP_CDR: string = "CDR\tREG0"; goto NOARG; case OP_LIST: string = "LIST\t"; GET_OPARG(n, vector); goto OPARG; case OP_LISTA: string = "LIST*\t"; GET_OPARG(n, vector); goto OPARG; case OP_CALLG1: string = "CALLG1\t"; GET_DATA(o, vector, data); goto ARG; case OP_CALLG2: string = "CALLG2\t"; GET_DATA(o, vector, data); goto ARG; default: FEerror("Unknown code ~S", 1, ecl_make_fixnum(*(vector-1))); return vector; NOARG: print_noarg(string); break; ARG: print_noarg(string); @prin1(1, o); break; OPARG: print_oparg(string, n); break; OPARG_ARG: print_oparg_arg(string, n, o); break; } goto BEGIN; } cl_object si_bc_disassemble(cl_object v) { if (ecl_t_of(v) == t_bclosure) { v = v->bclosure.code; } if (ecl_t_of(v) == t_bytecodes) { disassemble_lambda(v); @(return v) } @(return ECL_NIL) } cl_object si_bc_split(cl_object b) { cl_object vector, data, name, lex = ECL_NIL; if (ecl_t_of(b) == t_bclosure) { b = b->bclosure.code; lex = b->bclosure.lex; } if (ecl_t_of(b) != t_bytecodes) { vector = ECL_NIL; data = ECL_NIL; name = ECL_NIL; } else { vector = ecl_alloc_simple_vector(b->bytecodes.code_size * sizeof(cl_opcode), ecl_aet_b8); vector->vector.self.b8 = (uint8_t*)b->bytecodes.code; data = cl_copy_seq(b->bytecodes.data); name = b->bytecodes.name; } @(return lex vector data name) } cl_object si_bc_join(cl_object lex, cl_object code, cl_object data, cl_object name) { cl_object output; if (lex != ECL_NIL) { output = ecl_alloc_object(t_bclosure); output->bclosure.code = si_bc_join(ECL_NIL, code, data, name); output->bclosure.lex = lex; output->bclosure.entry = _ecl_bclosure_dispatch_vararg; } else { /* Ensure minimal sanity of data */ unlikely_if (!ECL_VECTORP(code) || (code->vector.elttype != ecl_aet_b8)) { FEwrong_type_nth_arg(@[si::bc-join], 0, code, cl_list(2, @'simple-array', @'ext::byte8')); } unlikely_if (!ECL_VECTORP(code) || (data->vector.elttype != ecl_aet_object)) { FEwrong_type_nth_arg(@[si::bc-join], 0, code, cl_list(2, @'simple-array', ECL_T)); } /* Duplicate the vectors and steal their data pointers */ code = cl_copy_seq(code); data = cl_copy_seq(data); output = ecl_alloc_object(t_bytecodes); output->bytecodes.name = ECL_NIL; output->bytecodes.definition = ECL_NIL; output->bytecodes.entry = _ecl_bytecodes_dispatch_vararg; output->bytecodes.code_size = code->vector.fillp / sizeof(cl_opcode); output->bytecodes.code = (void*)code->vector.self.b8; output->bytecodes.data = data; output->bytecodes.file = ECL_NIL; output->bytecodes.file_position = ECL_NIL; } @(return output) } ecl-16.1.2/src/c/dosdummy.d000066400000000000000000000003631266352375300154010ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ #define DUM(a) int a(int n) {} DUM(alarm) DUM(getpid) DUM(getuid) DUM(popen) DUM(pclose) DUM(getpwuid) DUM(getpwnam) ecl-16.1.2/src/c/dostimes.d000066400000000000000000000006511266352375300153670ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ #include #include #ifdef __ZTC__ #define HZ 100 #endif times(struct tms *x) { int hz; struct rusage ru; getrusage(RUSAGE_SELF,&ru); hz = ru.ru_utime.tv_sec * HZ + (ru.ru_utime.tv_usec * HZ)/1000000; x->tms_utime = hz; x->tms_stime = hz; return 0; } ecl-16.1.2/src/c/dpp.c000077500000000000000000000631251266352375300143320ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* dpp.c -- Defun preprocessor. */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ /* Usage: dpp [in-file [out-file]] The file named in-file is preprocessed and the output will be written to the file whose name is out-file. If in-file is "-" program is read from standard input, while if out-file is "-" C-program is written to standard output. The function definition: @(defun name ({var}* [&optional {var | (var [initform [svar]])}*] [&rest var] [&key {var | ({var | (keyword var)} [initform [svar]])}* [&allow_other_keys]] [&aux {var | (var [initform])}*]) C-declaration @ C-body @) name can be either an identifier or a full C procedure header enclosed in quotes ('). &optional may be abbreviated as &o. &rest may be abbreviated as &r. &key may be abbreviated as &k. &allow_other_keys may be abbreviated as &aok. &aux may be abbreviated as &a. Each variable becomes a C variable. Each supplied-p parameter becomes a boolean C variable. Initforms are C expressions. If an expression contains non-alphanumeric characters, it should be surrounded by backquotes (`). Function return: @(return {form}*) */ #include #include #include #include #define DPP #include #include "symbols_list2.h" /* #define POOLSIZE 2048 */ #define POOLSIZE 4096 #define MAXREQ 16 #define MAXOPT 16 #define MAXKEY 16 #define MAXAUX 16 #define MAXRES 16 #define TRUE 1 #define FALSE 0 #ifndef __cplusplus typedef int bool; #endif FILE *in, *out; char filename[BUFSIZ]; int lineno; int tab; int tab_save; char pool[POOLSIZE]; char *poolp; char *function; int function_code; char *function_symbol; char *function_c_name; char *required[MAXREQ]; int nreq; int the_env_defined = 0; struct optional { char *o_var; char *o_init; char *o_svar; } optional[MAXOPT]; int nopt; bool rest_flag; char *rest_var; bool key_flag; struct keyword { char *k_key; char *k_var; char *k_init; char *k_svar; } keyword[MAXKEY]; int nkey; bool allow_other_keys_flag; struct aux { char *a_var; char *a_init; } aux[MAXAUX]; int naux; char *result[MAXRES]; int nres; void put_lineno(void) { static int flag = 0; if (flag) fprintf(out, "#line %d\n", lineno); else { flag++; fprintf(out, "#line %d \"%s\"\n", lineno, filename); } } void error(char *s) { printf("Error in line %d: %s.\n", lineno, s); exit(1); } void error_symbol(char *s) { printf("Error in line %d: illegal symbol %s.\n", lineno, s); exit(1); } int readc(void) { int c; c = getc(in); if (feof(in)) { if (function != NULL) error("unexpected end of file"); exit(0); } if (c == '\n') { lineno++; tab = 0; } else if (c == '\t') tab++; return(c); } int nextc(void) { int c; while (isspace(c = readc())) ; return(c); } void unreadc(int c) { if (c == '\n') --lineno; else if (c == '\t') --tab; ungetc(c, in); } void put_tabs(int n) { put_lineno(); while (n--) putc('\t', out); } void pushc(int c) { if (poolp >= &pool[POOLSIZE]) error("buffer pool overflow"); *poolp++ = c; } void pushstr(const char *s) { while (*s) pushc(*(s++)); } int search_keyword(const char *name) { int i; char c[256]; for (i=0; name[i] && i<255; i++) if (name[i] == '_') c[i] = '-'; else c[i] = name[i]; if (i == 255) error("Too long keyword"); c[i] = 0; for (i = 0; cl_symbols[i].name != NULL; i++) { if (cl_symbols[i].name[0] == ':') if (!strcasecmp(c, cl_symbols[i].name+1)) return i; } printf("Keyword not found: %s.\n", c); return 0; } char * search_symbol(char *name, int *symbol_code, int code) { int i; for (i = 0; cl_symbols[i].name != NULL; i++) { if (!strcasecmp(name, cl_symbols[i].name)) { name = poolp; if (code) { pushstr("ecl_make_fixnum(/*"); pushstr(cl_symbols[i].name); pushstr("*/"); if (i >= 1000) pushc((i / 1000) % 10 + '0'); if (i >= 100) pushc((i / 100) % 10 + '0'); if (i >= 10) pushc((i / 10) % 10 + '0'); pushc(i % 10 + '0'); pushstr(")"); pushc(0); } else if (i == 0) { pushstr("ECL_NIL"); pushc(0); } else { pushstr("ECL_SYM(\""); pushstr(cl_symbols[i].name); pushstr("\","); if (i >= 1000) pushc((i / 1000) % 10 + '0'); if (i >= 100) pushc((i / 100) % 10 + '0'); if (i >= 10) pushc((i / 10) % 10 + '0'); pushc(i % 10 + '0'); pushstr(")"); pushc(0); } if (symbol_code) *symbol_code = i; return name; } } return NULL; } char * read_symbol(int code) { char c, *name = poolp; char end = code? ']' : '\''; c = readc(); while (c != end) { if (c == '_') c = '-'; pushc(c); c = readc(); } pushc(0); name = search_symbol(poolp = name, 0, code); if (name == NULL) { name = poolp; printf("\nUnknown symbol: %s\n", name); pushstr("unknown"); } return name; } char * search_function(char *name) { int i; for (i = 0; cl_symbols[i].name != NULL; i++) { if (cl_symbols[i].translation != NULL && !strcasecmp(name, cl_symbols[i].name)) { name = poolp; pushstr(cl_symbols[i].translation); pushc(0); return name; } } return name; } char * read_function() { char c, *name = poolp; c = readc(); if (c == '"') { c = readc(); while (c != '"') { pushc(c); c = readc(); } pushc(0); return name; } while (c != '(' && !isspace(c) && c != ')' && c != ',') { if (c == '_') c = '-'; pushc(c); c = readc(); } unreadc(c); pushc(0); return name; } char * translate_function(char *name) { char *output = search_function(name); if (output == NULL) { printf("\nUnknown function: %s\n", name); pushstr("unknown"); output = poolp; } return output; } char * read_token(void) { int c; int left_paren = 0; char *p; p = poolp; c = readc(); while (isspace(c)) c = readc(); do { if (c == '(') { left_paren++; pushc(c); } else if (c == ')') { if (left_paren == 0) { break; } else { left_paren--; pushc(c); } } else if (isspace(c) && left_paren == 0) { do c = readc(); while (isspace(c)); break; } else if (c == '@') { c = readc(); if (c == '\'') { (void)read_symbol(0); poolp--; } else if (c == '[') { (void)read_symbol(1); poolp--; } else if (c == '@') { pushc(c); } else { char *name; unreadc(c); poolp = name = read_function(); (void)translate_function(poolp); } } else { pushc(c); } c = readc(); } while (1); unreadc(c); pushc('\0'); return(p); } void reset(void) { int i; the_env_defined = 0; poolp = pool; function = NULL; function_symbol = ""; function_c_name = ""; nreq = 0; for (i = 0; i < MAXREQ; i++) required[i] = NULL; nopt = 0; for (i = 0; i < MAXOPT; i++) optional[i].o_var = optional[i].o_init = optional[i].o_svar = NULL; rest_flag = FALSE; rest_var = "ARGS"; key_flag = FALSE; nkey = 0; for (i = 0; i < MAXKEY; i++) keyword[i].k_key = keyword[i].k_var = keyword[i].k_init = keyword[i].k_svar = NULL; allow_other_keys_flag = FALSE; naux = 0; for (i = 0; i < MAXAUX; i++) aux[i].a_var = aux[i].a_init = NULL; } void get_function(void) { function = read_function(); function_symbol = search_symbol(function, &function_code, 0); if (function_symbol == NULL) { function_symbol = poolp; pushstr("ECL_NIL"); pushc('\0'); } function_c_name = translate_function(function); } void get_lambda_list(void) { int c; char *p; if ((c = nextc()) != '(') error("( expected"); for (;;) { if ((c = nextc()) == ')') return; if (c == '&') { p = read_token(); goto _OPT; } unreadc(c); p = read_token(); if (nreq >= MAXREQ) error("too many required variables"); required[nreq++] = p; } _OPT: if (strcmp(p, "optional") != 0 && strcmp(p, "o") != 0) goto _REST; for (;; nopt++) { if ((c = nextc()) == ')') return; if (c == '&') { p = read_token(); goto _REST; } if (nopt >= MAXOPT) error("too many optional argument"); if (c == '(') { optional[nopt].o_var = read_token(); if ((c = nextc()) == ')') continue; unreadc(c); optional[nopt].o_init = read_token(); if ((c = nextc()) == ')') continue; unreadc(c); optional[nopt].o_svar = read_token(); if (nextc() != ')') error(") expected"); } else { unreadc(c); optional[nopt].o_var = read_token(); } } _REST: if (strcmp(p, "rest") != 0 && strcmp(p, "r") != 0) goto _KEY; rest_flag = TRUE; if ((c = nextc()) == ')' || c == '&') error("&rest var missing"); unreadc(c); rest_var = read_token(); if ((c = nextc()) == ')') return; if (c != '&') error("& expected"); p = read_token(); _KEY: if (strcmp(p, "key") != 0 && strcmp(p, "k") != 0) goto _AUX; key_flag = TRUE; for (;; nkey++) { if ((c = nextc()) == ')') return; if (c == '&') { p = read_token(); if (strcmp(p, "allow_other_keys") == 0 || strcmp(p, "aok") == 0) { allow_other_keys_flag = TRUE; if ((c = nextc()) == ')') return; if (c != '&') error("& expected"); p = read_token(); } goto _AUX; } if (nkey >= MAXKEY) error("too many optional argument"); if (c == '(') { if ((c = nextc()) == '(') { p = read_token(); if (p[0] != ':' || p[1] == '\0') error("keyword expected"); keyword[nkey].k_key = p + 1; keyword[nkey].k_var = read_token(); if (nextc() != ')') error(") expected"); } else { unreadc(c); keyword[nkey].k_key = keyword[nkey].k_var = read_token(); } if ((c = nextc()) == ')') continue; unreadc(c); keyword[nkey].k_init = read_token(); if ((c = nextc()) == ')') continue; unreadc(c); keyword[nkey].k_svar = read_token(); if (nextc() != ')') error(") expected"); } else { unreadc(c); keyword[nkey].k_key = keyword[nkey].k_var = read_token(); } } _AUX: if (strcmp(p, "aux") != 0 && strcmp(p, "a") != 0) error("illegal lambda-list keyword"); for (;;) { if ((c = nextc()) == ')') return; if (c == '&') error("illegal lambda-list keyword"); if (naux >= MAXAUX) error("too many auxiliary variable"); if (c == '(') { aux[naux].a_var = read_token(); if ((c = nextc()) == ')') continue; unreadc(c); aux[naux].a_init = read_token(); if (nextc() != ')') error(") expected"); } else { unreadc(c); aux[naux].a_var = read_token(); } naux++; } } void get_return(void) { int c; nres = 0; for (;;) { if ((c = nextc()) == ')') return; unreadc(c); result[nres++] = read_token(); } } void put_fhead(void) { int i; put_lineno(); fprintf(out, "cl_object %s(cl_narg narg", function_c_name); for (i = 0; i < nreq; i++) fprintf(out, ", cl_object %s", required[i]); if (nopt > 0 || rest_flag || key_flag) fprintf(out, ", ..."); fprintf(out, ")\n{\n"); } void put_declaration(void) { int i; int simple_varargs; put_lineno(); the_env_defined = 1; fprintf(out, "\tconst cl_env_ptr the_env = ecl_process_env();\n"); for (i = 0; i < nopt; i++) { put_lineno(); fprintf(out, "\tcl_object %s;\n", optional[i].o_var); } for (i = 0; i < nopt; i++) if (optional[i].o_svar != NULL) { put_lineno(); fprintf(out, "\tbool %s;\n", optional[i].o_svar); } if (key_flag) { put_lineno(); if (nkey) { fprintf(out, "\tstatic cl_object KEYS[%d] = {", nkey); for (i = 0; i < nkey; i++) { if (i > 0) fprintf(out, ", "); fprintf(out, "(cl_object)(cl_symbols+%d)", search_keyword(keyword[i].k_key)); } fprintf(out, "};\n"); } else { fprintf(out, "\tcl_object *KEYS = NULL;\n"); } } for (i = 0; i < nkey; i++) { fprintf(out, "\tcl_object %s;\n", keyword[i].k_var); if (keyword[i].k_svar != NULL) fprintf(out, "\tbool %s;\n", keyword[i].k_svar); } for (i = 0; i < naux; i++) { put_lineno(); fprintf(out, "\tcl_object %s;\n", aux[i].a_var); } if (nopt == 0 && !rest_flag && !key_flag) { put_lineno(); fprintf(out, "\tif (ecl_unlikely(narg!=%d))", nreq); fprintf(out, "\t FEwrong_num_arguments(ecl_make_fixnum(%d));\n", function_code); } else { simple_varargs = !rest_flag && !key_flag && ((nreq + nopt) < 32); if (key_flag) { put_lineno(); /* We do this because Microsoft VC++ does not support arrays of zero size */ if (nkey) { fprintf(out, "\tcl_object KEY_VARS[%d];\n", 2*nkey); } else { fprintf(out, "\tcl_object *KEY_VARS = NULL;\n"); } } put_lineno(); if (simple_varargs) fprintf(out,"\tva_list %s;\n\tva_start(%s, %s);\n", rest_var, rest_var, ((nreq > 0) ? required[nreq-1] : "narg")); else fprintf(out,"\tecl_va_list %s;\n\tecl_va_start(%s, %s, narg, %d);\n", rest_var, rest_var, ((nreq > 0) ? required[nreq-1] : "narg"), nreq); put_lineno(); fprintf(out, "\tif (ecl_unlikely(narg < %d", nreq); if (nopt > 0 && !rest_flag && !key_flag) { fprintf(out, "|| narg > %d", nreq + nopt); } fprintf(out, ")) FEwrong_num_arguments(ecl_make_fixnum(%d));\n", function_code); for (i = 0; i < nopt; i++) { put_lineno(); fprintf(out, "\tif (narg > %d) {\n", nreq+i); put_lineno(); fprintf(out, simple_varargs? "\t\t%s = va_arg(%s,cl_object);\n": "\t\t%s = ecl_va_arg(%s);\n", optional[i].o_var, rest_var); if (optional[i].o_svar) { put_lineno(); fprintf(out, "\t\t%s = TRUE;\n", optional[i].o_svar); } put_lineno(); fprintf(out, "\t} else {\n"); put_lineno(); fprintf(out, "\t\t%s = %s;\n", optional[i].o_var, optional[i].o_init == NULL ? "ECL_NIL" : optional[i].o_init); if (optional[i].o_svar) { put_lineno(); fprintf(out, "\t\t%s = FALSE;\n", optional[i].o_svar); } put_lineno(); fprintf(out, "\t}\n"); } if (key_flag) { put_lineno(); fprintf(out, "\tcl_parse_key(ARGS, %d, KEYS, KEY_VARS, NULL, %d);\n", nkey, allow_other_keys_flag); for (i = 0; i < nkey; i++) { put_lineno(); fprintf(out, "\tif (KEY_VARS[%d]==ECL_NIL) {\n", nkey+i); if (keyword[i].k_init != NULL) { put_lineno(); fprintf(out, "\t %s = %s;\n", keyword[i].k_var, keyword[i].k_init); } else { put_lineno(); fprintf(out, "\t %s = ECL_NIL;\n", keyword[i].k_var); } if (keyword[i].k_svar != NULL) { put_lineno(); fprintf(out, "\t %s = FALSE;\n", keyword[i].k_svar); } fprintf(out, "\t} else {\n"); if (keyword[i].k_svar != NULL) { put_lineno(); fprintf(out, "\t %s = TRUE;\n", keyword[i].k_svar); } put_lineno(); fprintf(out, "\t %s = KEY_VARS[%d];\n\t}\n", keyword[i].k_var, i); } } } for (i = 0; i < naux; i++) { put_lineno(); fprintf(out, "\t%s = %s;\n", aux[i].a_var, aux[i].a_init == NULL ? "ECL_NIL" : aux[i].a_init); } } void put_return(void) { int i, t; t = tab_save+1; fprintf(out, "{\n"); if (!the_env_defined) { put_tabs(t); fprintf(out, "const cl_env_ptr the_env = ecl_process_env();\n"); } if (nres == 0) { fprintf(out, "the_env->nvalues = 0; return ECL_NIL;\n"); } else { put_tabs(t); for (i = 0; i < nres; i++) { put_tabs(t); fprintf(out, "cl_object __value%d = %s;\n", i, result[i]); } put_tabs(t); fprintf(out, "the_env->nvalues = %d;\n", nres); for (i = nres-1; i > 0; i--) { put_tabs(t); fprintf(out, "the_env->values[%d] = __value%d;\n", i, i); } put_tabs(t); fprintf(out, "return __value0;\n"); } put_tabs(tab_save); fprintf(out, "}\n"); } int jump_to_at(void) { int c; GO_ON: while ((c = readc()) != '@') putc(c, out); if ((c = readc()) == '@') { putc(c, out); goto GO_ON; } return c; } void main_loop(void) { int c; int in_defun=0; char *p; lineno = 1; reset(); put_lineno(); LOOP: c = jump_to_at(); if (c == ')') { if (!in_defun) error("unmatched @) found"); in_defun = 0; putc('}',out); reset(); goto LOOP; } else if (c == '\'') { char *p; poolp = pool; p = read_symbol(0); pushc('\0'); fprintf(out,"%s",p); goto LOOP; } else if (c == '[') { char *p; poolp = pool; p = read_symbol(1); pushc('\0'); fprintf(out,"%s",p); goto LOOP; } else if (c != '(') { char *p; unreadc(c); poolp = pool; poolp = p = read_function(); fprintf(out,"%s",translate_function(poolp)); goto LOOP; } p = read_token(); if (strcmp(p, "defun") == 0) { if (in_defun) error("@) expected before new function definition"); in_defun = 1; get_function(); get_lambda_list(); put_fhead(); put_lineno(); c = jump_to_at(); put_declaration(); put_lineno(); } else if (strcmp(p, "return") == 0) { tab_save = tab; get_return(); put_return(); } else error_symbol(p); goto LOOP; } int main(int argc, char **argv) { char outfile[BUFSIZ]; #ifdef _MSC_VER char *p; #endif if (argc < 2 || !strcmp(argv[1],"-")) { in = stdin; strcpy(filename, "-"); } else { in = fopen(argv[1],"r"); strncpy(filename, argv[1], BUFSIZ-1); filename[BUFSIZ-1] = '\0'; } #ifdef _MSC_VER /* Convert all backslashes in filename into slashes, * to avoid warnings when compiling with MSVC */ for ( p=filename; *p; p++ ) if ( *p == '\\' ) *p = '/'; #endif if (argc < 3 || !strcmp(argv[2],"-")) { out = stdout; strcpy(outfile, "-"); } else { out = fopen(argv[2],"w"); strncpy(outfile, argv[2], BUFSIZ-1); outfile[BUFSIZ-1] = '\0'; } if (in == NULL) error("can't open input file"); if (out == NULL) error("can't open output file"); printf("dpp: %s -> %s\n", filename, outfile); main_loop(); return 0; } ecl-16.1.2/src/c/earith.d000066400000000000000000000300551266352375300150150ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* earith.c -- Support for bignum arithmetic. */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ /* EXTENDED_MUL and EXTENDED_DIV perform 32 bit multiplication and division, respectively. EXTENDED_MUL(D,Q,R,HP,LP) calculates D*Q+R and saves the result into the locations HP and LP. D, Q, and R are 32 bit non-negative integers and HP and LP are word addresses. The word at LP will contain the lower 31 (not 32) bits of the result and its most significant bit is set 0. The word at HP will contain the rest of the result and its MSB is also set 0. EXTENDED_DIV(D,H,L,QP,RP) divides [H:L] by D and saves the quotient and the remainder into the locations QP and RP, respectively. D, H, L are 32 bit non-negative integers and QP and RP are word addresses. Here, [H:L] means the 64 bit integer (imaginary) represented by H and L as follows. 63 62 31 30 0 |0|0||| Although [H:L] is 64 bits, you can assume that the quotient is always represented as 32 bit non-negative integer. */ #include #ifdef CONVEX static void extended_mul(int d, int q, int r, int *hp, int *lp) { long long int ld, lq, lr, z; int zh, zl; ld = d; lq = q; lr = r; z = ld*lq+lr; zl = (z & 0x000000007fffffffLL); zh = (z >> 31LL); *hp = zh; *lp = zl; } static void extended_div(int d, int h, int l, int *qp, int *rp) { long long int lh, ld, ll; ld = d; lh = h; ll = l; lh = (lh << 31LL); lh = (lh | ll); *qp = (lh/ld); *rp = (lh%ld); } #endif /* CONVEX */ #ifdef i386 static void extended_mul(int d, int q, int r, int *hp, int *lp) { asm("pushl %ecx"); asm("movl 8(%ebp),%eax"); asm("mull 12(%ebp)"); asm("addl 16(%ebp),%eax"); asm("adcl $0,%edx"); asm("shll $1,%edx"); asm("btrl $31,%eax"); asm("adcl $0,%edx"); asm("movl 20(%ebp),%ecx"); asm("movl %edx, (%ecx)"); asm("movl 24(%ebp), %ecx"); asm("movl %eax, (%ecx)"); asm("popl %ecx"); } static void extended_div(int d, int h, int l, int *qp, int *rp) { asm("pushl %ebx"); asm("movl 12(%ebp),%edx"); asm("movl 16(%ebp),%eax"); asm("btl $0,%edx"); asm("jae 1f"); asm("btsl $31,%eax"); asm("1: shrl $1,%edx"); asm("idivl 8(%ebp)"); asm("movl 20(%ebp),%ebx"); asm("movl %eax,(%ebx)"); asm("movl 24(%ebp),%ebx"); asm("movl %edx,(%ebx)"); asm("popl %ebx"); } #endif /* i386 */ #ifdef IBMRT static void extended_mul(int d, int q, int r, int *hp, int *lp) { /* d=L750+20, q=L750+24, etc. */ asm(" get r0,L750+20(r13)"); /* get an argument */ asm(" mts r10,r0"); /* put in MQ */ asm(" get r2,L750+24(r13)"); /* get the other argument */ asm(" s r0,r0"); /* zero partial product. set carry to 1. */ asm(" m r0,r2 m r0,r2 m r0,r2 m r0,r2 m r0,r2 m r0,r2 m r0,r2 m r0,r2 m r0,r2 m r0,r2 m r0,r2 m r0,r2 m r0,r2 m r0,r2 m r0,r2 m r0,r2"); /* Now (r0)//mq has the 64 bit product; overflow is ignored. */ asm(" mfs r10,r2"); /* set r2 = low order word of result * so product is in (r0)//(r2). */ /* * Force product into two single precision words. */ asm(" get r3,$1f sli r0,1 ar2,r2 bnc0r r3"); /* branch if carry = 0 */ asm(" oil r0,r0,1 1: sri r2,1"); /* Now add in the third argument. */ asm(" get r4,$2f get r3,L750+28(r13) a r2,r3 bnmr r4"); /* branch if not minus */ asm(" clrbu r2,0 lis r3,1 a r0,r3 2: get r3,L750+32(r13) put r0,0(r3) get r3,L750+36(r13) put r2,0(r3) "); } static void extended_div(int d, int h, int l, int *qp, int *rp) { /* d=L754+20, h=L754+24, etc. */ /* Move arguments into registers. */ asm(" get r0,L754+28(r13)"); /* Low order word of dividend. */ asm(" get r2,L754+24(r13)"); /* High order word of dividend. */ asm(" mttbil r2,15 mftbiu r0,0 sri r2,1 mts r10,r0 get r3,L754+20(r13)") /* Divisor. */ /* Perform 32 steps of division. */ asm(" d r2,r3 d r2,r3 d r2,r3 d r2,r3 d r2,r3 d r2,r3 d r2,r3 d r2,r3 d r2,r3 d r2,r3 d r2,r3 d r2,r3 d r2,r3 d r2,r3 d r2,r3 d r2,r3 d r2,r3 d r2,r3 d r2,r3 d r2,r3 d r2,r3 d r2,r3 d r2,r3 d r2,r3 d r2,r3 d r2,r3 d r2,r3 d r2,r3 d r2,r3 d r2,r3 d r2,r3 d r2,r3"); /* Now MQ has the quotient, R2 the remainder, and R3 is * the unchanged divisor. */ asm(" mttbiu r2,0"); /* Do add-back if necessary. */ asm(" jntb 1f a r2,r3 1: mfs r10,r0 c r2,r3"); /* Remainder : divisor. */ asm(" jne 2f inc r0,1 x r2,r2 2:"); /* Now r0 has the quotient and r2 has the remainder. */ asm(" get r3,L754+32(r13)"); /* Quotient address. */ asm(" put r0,0(r3)"); asm(" get r3,L754+36(r13)"); /* Remainder address. */ asm(" put r2,0(r3)"); } #endif /* IBMRT */ #if defined(NEWS) || defined(MAC) static void extended_mul(int d, int q, int r, int *hp, int *lp) { asm(" move.l d2,-(sp) clr.l d2 move.l (8,fp),d0 mulu.l (12,fp),d1:d0 add.l (16,fp),d0 addx.l d2,d1 lsl.l #1,d0 roxl.l #1,d1 lsr.l #1,d0 move.l (20,fp),a0 move.l d1,(a0) move.l (24,a6),a0 move.l d0,(a0)"); } static void extended_div(int d, int h, int l, int *qp, int *rp) { asm("movem.l (12,fp),#0x303 lsl.l #1,d1 lsr.l #1,d0 roxr.l #1,d1 divu.l (8,fp),d0:d1 move.l d0,(a1) move.l d1,(a0) "); } #endif /* NEWS || MAC */ #ifdef __mips /* earith.s for MIPS R2000 processor by Doug Katzman version 2.1.d dated 7/13/89 15:31 EDT */ /* Register names: #define v0 $2 return value #define v1 $3 #define a0 $4 argument registers #define a1 $5 #define a2 $6 #define a3 $7 #define t7 $15 */ static void extended_mul(unsigned int d, unsigned int q, unsigned int r, unsigned int *hp, unsigned int *lp) { asm("mult $4, $5"); /* [hi:lo] = d * q */ asm("mfhi $5"); /* a1 = hi */ asm("sll $5, 1"); asm("mflo $4"); asm("srl $15, $4, 31"); asm("and $4, 0x7fffffff"); asm("or $5, $15"); asm("addu $4, $6"); /* [a1:a0] += r */ asm("srl $15, $4, 31"); asm("and $4, 0x7fffffff"); asm("addu $5, $15"); asm("sw $5, 0($7)"); /* *hp = a1 */ #ifdef __GNUC__ asm("lw $7, %0" :: "g" (lp)); #else asm("lw $7, 16($sp)"); /* fetch fifth actual argument from stack */ #endif asm("sw $4, 0($7)"); /* *lp = a0 */ } static void extended_div(unsigned int d, unsigned int h, unsigned int l, unsigned int *qp, unsigned int *rp) { asm("sll $6, 1"); asm("li $2, 31"); /* v0 holds number of shifts */ asm("loop: srl $15, $6, 31"); asm("sll $5, 1"); asm("or $5, $15"); asm("sll $6, 1"); asm("subu $15, $5, $4"); /* t = h - d */ asm("bltz $15, underflow"); asm("move $5, $15"); asm("or $6, 1"); asm("underflow: subu $2, 1"); asm("bnez $2, loop"); asm("sw $6, 0($7)"); /* *qp = l */ #ifdef __GNUC__ asm("lw $7, %0" :: "g" (rp)); #else asm("lw $7, 16($sp)"); /* fetch fifth actual argument from stack */ #endif asm("sw $5, 0($7)"); /* *rp = h */ } #endif /* __mips */ #if defined(sun3) || (defined __NeXT) static void extended_mul(int d, int q, int r, int *hp, int *lp) { asm(" movl d2,a7@- clrl d2 movl a6@(8),d0 mulul a6@(12),d1:d0 addl a6@(16),d0 addxl d2,d1 lsll #1,d0 roxll #1,d1 lsrl #1,d0 movl a6@(20),a0 movl d1,a0@ movl a6@(24),a0 movl d0,a0@ movl a7@+,d2 "); } static void extended_div(int d, int h, int l, int *qp, int *rp) { asm("moveml a6@(12),#0x303 lsll #1,d1 lsrl #1,d0 roxrl #1,d1 divul a6@(8),d0:d1 movl d0,a1@ movl d1,a0@ "); } #endif /* sun3 */ /* Possible assembler version: #ifdef sparc _extended_mul: !#PROLOGUE# 0 !#PROLOGUE# 1 save %sp,-96,%sp mov %i0,%o0 call .umul,2 mov %i1,%o1 addcc %o0,%i2,%i0 addx %o1,0,%o1 sll %o1,1,%o1 tst %i0 bge L77003 sethi %hi(0x7fffffff),%o3 or %o3,%lo(0x7fffffff),%o3 ! [internal] and %i0,%o3,%i0 inc %o1 L77003: st %i0,[%i4] st %o1,[%i3] ret restore %g0,0,%o0 #endif sparc */ #if defined(sparc) || defined(APOLLO) || defined(hpux) || defined(UNIGRAPH)n /* for the time being use the C version:*/ static void extended_mul(unsigned int d, unsigned int q, unsigned int r, unsigned int *hp, unsigned int *lp) { register unsigned short dlo = d & 0xffff, dhi = d >> 16, qlo = q & 0xffff, qhi = q >> 16; unsigned int d0 = dhi * qlo + dlo * qhi, d1 = dhi * qhi, d2 = dlo * qlo; d1 = (d1 << 1) + (d0 >> 15); /* add 17 MSB of d0 */ d1 += d2 >> 31; /* add MSB of d2 */ d2 &= 0x7fffffff; /* clear MSB of d2 */ d2 += (d0 & 0x7fff) << 16; /* add 15 LSB of d0: no overflow occurs */ d1 += d2 >> 31; /* add MSB of d2 */ d2 &= 0x7fffffff; /* clear MSB of d2 */ d2 += r; d1 += d2 >> 31; /* add MSB of d2 */ d2 &= 0x7fffffff; /* clear MSB of d2 */ *hp = d1; *lp = d2; } static void extended_div(unsigned int d, unsigned int h, unsigned int l, unsigned int *qp, unsigned int *rp) { int i; int borrow; l = (l << 1) | 1; for (i = 31; i >= 0;) { if (h >= d) { h -= d; borrow = 0; } else borrow = 1; if (i--) h = (h << 1) | ((unsigned)l >> 31); l = (l << 1) | borrow; } l = - l - 1; *qp = l; *rp = h; } #endif /* sparc */ #ifdef vax static void extended_mul(int d, int q, int r, int *hp, int *lp) { asm(" emul 4(ap),8(ap),12(ap),r0"); asm(" ashq $1,r0,r0"); asm(" rotl $-1,r0,r0"); asm(" movl r0,*20(ap)"); asm(" movl r1,*16(ap)"); } static void extended_div(int d, int h, int l, int *qp, int *rp) { asm(" clrl r0"); asm(" movl 8(ap),r1"); asm(" ashq $-1,r0,r0"); asm(" addl2 12(ap),r0"); asm(" ediv 4(ap),r0,*16(ap),*20(ap)"); } #endif /* vax */ ecl-16.1.2/src/c/ecl_constants.h000066400000000000000000000054631266352375300164110ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* ecl_constants.c -- constant values for all_symbols.d */ /* Copyright (c) 2010, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #include ecl_def_ct_single_float(flt_max,FLT_MAX,static,const); ecl_def_ct_single_float(flt_max_neg,-FLT_MAX,static,const); ecl_def_ct_single_float(flt_min,FLT_MIN,static,const); ecl_def_ct_single_float(flt_min_neg,-FLT_MIN,static,const); #define ECL_LEAST_POSITIVE_SINGLE_FLOAT (cl_object)(&flt_min_data) #define ECL_LEAST_NEGATIVE_SINGLE_FLOAT (cl_object)(&flt_min_neg_data) #define ECL_MOST_POSITIVE_SINGLE_FLOAT (cl_object)(&flt_max_data) #define ECL_MOST_NEGATIVE_SINGLE_FLOAT (cl_object)(&flt_max_neg_data) #define ECL_LEAST_POSITIVE_SHORT_FLOAT (cl_object)(&flt_min_data) #define ECL_LEAST_NEGATIVE_SHORT_FLOAT (cl_object)(&flt_min_neg_data) #define ECL_MOST_POSITIVE_SHORT_FLOAT (cl_object)(&flt_max_data) #define ECL_MOST_NEGATIVE_SHORT_FLOAT (cl_object)(&flt_max_neg_data) ecl_def_ct_double_float(dbl_max,DBL_MAX,static,const); ecl_def_ct_double_float(dbl_max_neg,-DBL_MAX,static,const); ecl_def_ct_double_float(dbl_min,DBL_MIN,static,const); ecl_def_ct_double_float(dbl_min_neg,-DBL_MIN,static,const); #define ECL_LEAST_POSITIVE_DOUBLE_FLOAT (cl_object)(&dbl_min_data) #define ECL_LEAST_NEGATIVE_DOUBLE_FLOAT (cl_object)(&dbl_min_neg_data) #define ECL_MOST_POSITIVE_DOUBLE_FLOAT (cl_object)(&dbl_max_data) #define ECL_MOST_NEGATIVE_DOUBLE_FLOAT (cl_object)(&dbl_max_neg_data) #ifdef ECL_LONG_FLOAT ecl_def_ct_long_float(ldbl_max,LDBL_MAX,static,const); ecl_def_ct_long_float(ldbl_max_neg,-LDBL_MAX,static,const); ecl_def_ct_long_float(ldbl_min,LDBL_MIN,static,const); ecl_def_ct_long_float(ldbl_min_neg,-LDBL_MIN,static,const); #define ECL_LEAST_POSITIVE_LONG_FLOAT (cl_object)(&ldbl_min_data) #define ECL_LEAST_NEGATIVE_LONG_FLOAT (cl_object)(&ldbl_min_neg_data) #define ECL_MOST_POSITIVE_LONG_FLOAT (cl_object)(&ldbl_max_data) #define ECL_MOST_NEGATIVE_LONG_FLOAT (cl_object)(&ldbl_max_neg_data) #else #define ECL_LEAST_POSITIVE_LONG_FLOAT (cl_object)(&dbl_min_data) #define ECL_LEAST_NEGATIVE_LONG_FLOAT (cl_object)(&dbl_min_neg_data) #define ECL_MOST_POSITIVE_LONG_FLOAT (cl_object)(&dbl_max_data) #define ECL_MOST_NEGATIVE_LONG_FLOAT (cl_object)(&dbl_max_neg_data) #endif #ifdef ECL_LONG_FLOAT ecl_def_ct_long_float(float_pi,ECL_PI_L,static,const); #else ecl_def_ct_double_float(float_pi,ECL_PI_D,static,const); #endif #define ECL_PI (cl_object)(&float_pi_data) ecl-16.1.2/src/c/ecl_features.h000066400000000000000000000071561266352375300162140ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* features.h -- names of features compiled into ECL */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ ecl_def_string_array(feature_names,static,const) = { ecl_def_string_array_elt("ECL"), ecl_def_string_array_elt("COMMON"), ecl_def_string_array_elt(ECL_ARCHITECTURE), ecl_def_string_array_elt("FFI"), ecl_def_string_array_elt("PREFIXED-API"), #ifdef ECL_IEEE_FP ecl_def_string_array_elt("IEEE-FLOATING-POINT"), #endif ecl_def_string_array_elt("COMMON-LISP"), ecl_def_string_array_elt("ANSI-CL"), #if defined(GBC_BOEHM) ecl_def_string_array_elt("BOEHM-GC"), #endif #ifdef ECL_THREADS ecl_def_string_array_elt("THREADS"), #endif ecl_def_string_array_elt("CLOS"), #ifdef ENABLE_DLOPEN ecl_def_string_array_elt("DLOPEN"), #endif #ifdef ECL_OLD_LOOP ecl_def_string_array_elt("OLD-LOOP"), #endif ecl_def_string_array_elt("ECL-PDE"), #if defined(unix) || defined(netbsd) || defined(openbsd) || defined(linux) || defined(darwin) || \ defined(freebsd) || defined(dragonfly) || defined(kfreebsd) || defined(gnu) || defined(nsk) ecl_def_string_array_elt("UNIX"), #endif #ifdef BSD ecl_def_string_array_elt("BSD"), #endif #ifdef SYSV ecl_def_string_array_elt("SYSTEM-V"), #endif #ifdef MSDOS ecl_def_string_array_elt("MS-DOS"), #endif #if defined(__MINGW32__) ecl_def_string_array_elt("MINGW32"), ecl_def_string_array_elt("WIN32"), #endif #if defined(__WIN64__) ecl_def_string_array_elt("WIN64"), #endif #ifdef _MSC_VER ecl_def_string_array_elt("MSVC"), #endif #if defined(ECL_MS_WINDOWS_HOST) ecl_def_string_array_elt("WINDOWS"), #endif #ifdef ECL_CMU_FORMAT ecl_def_string_array_elt("CMU-FORMAT"), #endif #ifdef ECL_CLOS_STREAMS ecl_def_string_array_elt("CLOS-STREAMS"), #endif #if defined(ECL_DYNAMIC_FFI) || defined(HAVE_LIBFFI) ecl_def_string_array_elt("DFFI"), #endif #ifdef ECL_UNICODE ecl_def_string_array_elt("UNICODE"), #endif #ifdef ECL_LONG_FLOAT ecl_def_string_array_elt("LONG-FLOAT"), #endif #ifdef ECL_RELATIVE_PACKAGE_NAMES ecl_def_string_array_elt("RELATIVE-PACKAGE-NAMES"), #endif #ifdef ecl_uint16_t ecl_def_string_array_elt("UINT16-T"), #endif #ifdef ecl_uint32_t ecl_def_string_array_elt("UINT32-T"), #endif #ifdef ecl_uint64_t ecl_def_string_array_elt("UINT64-T"), #endif #ifdef ecl_long_long_t ecl_def_string_array_elt("LONG-LONG"), #endif #ifdef ECL_EXTERNALIZABLE ecl_def_string_array_elt("EXTERNALIZABLE"), #endif #ifdef __cplusplus ecl_def_string_array_elt("C++"), #endif #ifdef ECL_SSE2 ecl_def_string_array_elt("SSE2"), #endif #ifdef ECL_SEMAPHORES ecl_def_string_array_elt("SEMAPHORES"), #endif #ifdef ECL_RWLOCK ecl_def_string_array_elt("ECL-READ-WRITE-LOCK"), #endif #ifdef WORDS_BIGENDIAN ecl_def_string_array_elt("BIG-ENDIAN"), #else ecl_def_string_array_elt("LITTLE-ENDIAN"), #endif #ifdef ECL_WEAK_HASH ecl_def_string_array_elt("ECL-WEAK-HASH"), #endif ecl_def_string_array_elt(0) }; ecl-16.1.2/src/c/error.d000066400000000000000000000446641266352375300147050ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* error.c -- Error handling. */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #include #include #include #include #include #if defined(ECL_MS_WINDOWS_HOST) || defined(cygwin) # include #endif #include #include static cl_object cl_symbol_or_object(cl_object x) { if (ECL_FIXNUMP(x)) return (cl_object)(cl_symbols + ecl_fixnum(x)); return x; } void _ecl_unexpected_return() { ecl_internal_error( "*** \n" "*** A call to ERROR returned without handling the error.\n" "*** This should have never happened and is usually a signal\n" "*** that the debugger or the universal error handler were\n" "*** improperly coded or altered. Please contact the maintainers\n" "***\n"); } void ecl_internal_error(const char *s) { int saved_errno = errno; fprintf(stderr, "\nInternal or unrecoverable error in:\n%s\n", s); if (saved_errno) { fprintf(stderr, " [%d: %s]\n", saved_errno, strerror(saved_errno)); } fflush(stderr); si_dump_c_backtrace(ecl_make_fixnum(32)); #ifdef SIGIOT signal(SIGIOT, SIG_DFL); /* avoid getting into a loop with abort */ #endif abort(); } void ecl_unrecoverable_error(cl_env_ptr the_env, const char *message) { /* * Right now we have no means of specifying a jump point * for really bad events. We just jump to the outermost * frame, which is equivalent to quitting, and wait for * someone to intercept this jump. */ ecl_frame_ptr destination; cl_object tag; /* * We output the error message with very low level routines * because we can not risk another stack overflow. */ writestr_stream(message, cl_core.error_output); tag = ECL_SYM_VAL(the_env, @'si::*quit-tag*'); the_env->nvalues = 0; if (tag) { destination = frs_sch(tag); if (destination) { ecl_unwind(the_env, destination); } } if (the_env->frs_org <= the_env->frs_top) { destination = ecl_process_env()->frs_org; ecl_unwind(the_env, destination); } else { ecl_internal_error("\n;;;\n;;; No frame to jump to\n;;; Aborting ECL\n;;;"); } } /*****************************************************************************/ /* Support for Lisp Error Handler */ /*****************************************************************************/ void FEerror(const char *s, int narg, ...) { ecl_va_list args; ecl_va_start(args, narg, narg, 0); ecl_enable_interrupts(); funcall(4, @'si::universal-error-handler', ECL_NIL, /* not correctable */ make_constant_base_string(s), /* condition text */ cl_grab_rest_args(args)); _ecl_unexpected_return(); } cl_object CEerror(cl_object c, const char *err, int narg, ...) { ecl_va_list args; ecl_va_start(args, narg, narg, 0); ecl_enable_interrupts(); return funcall(4, @'si::universal-error-handler', c, /* correctable */ make_constant_base_string(err), /* continue-format-string */ cl_grab_rest_args(args)); } /*********************** * Conditions signaler * ***********************/ void FEprogram_error(const char *s, int narg, ...) { cl_object real_args, text; ecl_va_list args; ecl_va_start(args, narg, narg, 0); text = make_constant_base_string(s); real_args = cl_grab_rest_args(args); if (cl_boundp(@'si::*current-form*') != ECL_NIL) { /* When FEprogram_error is invoked from the compiler, we can * provide information about the offending form. */ cl_object stmt = ecl_symbol_value(@'si::*current-form*'); if (stmt != ECL_NIL) { real_args = @list(3, stmt, text, real_args); text = make_constant_base_string("In form~%~S~%~?"); } } si_signal_simple_error(4, @'program-error', /* condition name */ ECL_NIL, /* not correctable */ text, real_args); } void FEprogram_error_noreturn(const char *s, int narg, ...) { cl_object real_args, text; ecl_va_list args; ecl_va_start(args, narg, narg, 0); text = make_constant_base_string(s); real_args = cl_grab_rest_args(args); if (cl_boundp(@'si::*current-form*') != ECL_NIL) { /* When FEprogram_error is invoked from the compiler, we can * provide information about the offending form. */ cl_object stmt = ecl_symbol_value(@'si::*current-form*'); if (stmt != ECL_NIL) { real_args = @list(3, stmt, text, real_args); text = make_constant_base_string("In form~%~S~%~?"); } } si_signal_simple_error(4, @'program-error', /* condition name */ ECL_NIL, /* not correctable */ text, real_args); } void FEcontrol_error(const char *s, int narg, ...) { ecl_va_list args; ecl_va_start(args, narg, narg, 0); si_signal_simple_error(4, @'control-error', /* condition name */ ECL_NIL, /* not correctable */ make_constant_base_string(s), /* format control */ cl_grab_rest_args(args)); /* format args */ } void FEreader_error(const char *s, cl_object stream, int narg, ...) { cl_object message = make_constant_base_string(s); cl_object args_list; ecl_va_list args; ecl_va_start(args, narg, narg, 0); args_list = cl_grab_rest_args(args); if (Null(stream)) { /* Parser error */ si_signal_simple_error(4, @'parse-error', /* condition name */ ECL_NIL, /* not correctable */ message, /* format control */ args_list); } else { /* Actual reader error */ cl_object prefix = make_constant_base_string("Reader error in file ~S, " "position ~D:~%"); cl_object position = cl_file_position(1, stream); message = si_base_string_concatenate(2, prefix, message); args_list = cl_listX(3, stream, position, args_list); si_signal_simple_error(6, @'reader-error', /* condition name */ ECL_NIL, /* not correctable */ message, /* format control */ args_list, /* format args */ @':stream', stream); } } void FEcannot_open(cl_object fn) { cl_error(3, @'file-error', @':pathname', fn); } void FEend_of_file(cl_object strm) { cl_error(3, @'end-of-file', @':stream', strm); } void FEclosed_stream(cl_object strm) { cl_error(3, @'stream-error', @':stream', strm); } cl_object si_signal_type_error(cl_object value, cl_object type) { return cl_error(5, @'type-error', @':expected-type', type, @':datum', value); } void FEwrong_type_argument(cl_object type, cl_object value) { si_signal_type_error(value, cl_symbol_or_object(type)); } void FEwrong_type_only_arg(cl_object function, cl_object value, cl_object type) { const char *message = "In ~:[an anonymous function~;~:*function ~A~], " "the value of the only argument is~& ~S~&which is " "not of the expected type ~A"; cl_env_ptr env = ecl_process_env(); struct ecl_ihs_frame tmp_ihs; function = cl_symbol_or_object(function); type = cl_symbol_or_object(type); if (!Null(function) && env->ihs_top && env->ihs_top->function != function) { ecl_ihs_push(env,&tmp_ihs,function,ECL_NIL); } si_signal_simple_error(8, @'type-error', /* condition name */ ECL_NIL, /* not correctable */ make_constant_base_string(message), /* format control */ cl_list(3, function, value, type), @':expected-type', type, @':datum', value); } void FEwrong_type_nth_arg(cl_object function, cl_narg narg, cl_object value, cl_object type) { const char *message = "In ~:[an anonymous function~;~:*function ~A~], " "the value of the ~:R argument is~& ~S~&which is " "not of the expected type ~A"; cl_env_ptr env = ecl_process_env(); struct ecl_ihs_frame tmp_ihs; function = cl_symbol_or_object(function); type = cl_symbol_or_object(type); if (!Null(function) && env->ihs_top && env->ihs_top->function != function) { ecl_ihs_push(env,&tmp_ihs,function,ECL_NIL); } si_signal_simple_error(8, @'type-error', /* condition name */ ECL_NIL, /* not correctable */ make_constant_base_string(message), /* format control */ cl_list(4, function, ecl_make_fixnum(narg), value, type), @':expected-type', type, @':datum', value); } void FEwrong_type_key_arg(cl_object function, cl_object key, cl_object value, cl_object type) { const char *message = "In ~:[an anonymous function~;~:*function ~A~], " "the value of the argument ~S is~& ~S~&which is " "not of the expected type ~A"; cl_env_ptr env = ecl_process_env(); struct ecl_ihs_frame tmp_ihs; function = cl_symbol_or_object(function); type = cl_symbol_or_object(type); key = cl_symbol_or_object(key); if (!Null(function) && env->ihs_top && env->ihs_top->function != function) { ecl_ihs_push(env,&tmp_ihs,function,ECL_NIL); } si_signal_simple_error(8, @'type-error', /* condition name */ ECL_NIL, /* not correctable */ make_constant_base_string(message), /* format control */ cl_list(4, function, key, value, type), @':expected-type', type, @':datum', value); } void FEwrong_index(cl_object function, cl_object a, int which, cl_object ndx, cl_index nonincl_limit) { const char *message1 = "In ~:[an anonymous function~;~:*function ~A~], " "the ~*index into the object~% ~A.~%" "takes a value ~D out of the range ~A."; const char *message2 = "In ~:[an anonymous function~;~:*function ~A~], " "the ~:R index into the object~% ~A~%" "takes a value ~D out of the range ~A."; cl_object limit = ecl_make_integer(nonincl_limit-1); cl_object type = ecl_make_integer_type(ecl_make_fixnum(0), limit); cl_object message = make_constant_base_string((which<0) ? message1 : message2); cl_env_ptr env = ecl_process_env(); struct ecl_ihs_frame tmp_ihs; function = cl_symbol_or_object(function); if (!Null(function) && env->ihs_top && env->ihs_top->function != function) { ecl_ihs_push(env,&tmp_ihs,function,ECL_NIL); } cl_error(9, @'simple-type-error', /* condition name */ @':format-control', message, @':format-arguments', cl_list(5, function, ecl_make_fixnum(which+1), a, ndx, type), @':expected-type', type, @':datum', ndx); } void FEunbound_variable(cl_object sym) { cl_error(3, @'unbound-variable', @':name', sym); } void FEundefined_function(cl_object fname) { cl_error(3, @'undefined-function', @':name', fname); } void FEprint_not_readable(cl_object x) { cl_error(3, @'print-not-readable', @':object', x); } /************* * Shortcuts * *************/ void FEwrong_num_arguments(cl_object fun) { fun = cl_symbol_or_object(fun); FEprogram_error("Wrong number of arguments passed to function ~S.", 1, fun); } void FEwrong_num_arguments_anonym(void) { FEprogram_error("Wrong number of arguments passed to an anonymous function", 0); } void FEinvalid_macro_call(cl_object name) { FEerror("Invalid macro call to ~S.", 1, name); } void FEinvalid_variable(const char *s, cl_object obj) { FEerror(s, 1, obj); } void FEassignment_to_constant(cl_object v) { FEprogram_error("SETQ: Tried to assign a value to the constant ~S.", 1, v); } void FEinvalid_function(cl_object obj) { FEwrong_type_argument(@'function', obj); } void FEinvalid_function_name(cl_object fname) { cl_error(9, @'simple-type-error', @':format-control', make_constant_base_string("Not a valid function name ~D"), @':format-arguments', cl_list(1, fname), @':expected-type', cl_list(2, @'satisfies', @'si::valid-function-name-p'), @':datum', fname); } /* bootstrap version */ static int recursive_error = 0; static cl_object universal_error_handler(cl_object continue_string, cl_object datum, cl_object args) { const cl_env_ptr the_env = ecl_process_env(); cl_object stream; if (recursive_error) goto ABORT; recursive_error = 1; stream = cl_core.error_output; if (!Null(stream)) { ecl_bds_bind(the_env, @'*print-readably*', ECL_NIL); ecl_bds_bind(the_env, @'*print-level*', ecl_make_fixnum(3)); ecl_bds_bind(the_env, @'*print-length*', ecl_make_fixnum(3)); ecl_bds_bind(the_env, @'*print-circle*', ECL_NIL); ecl_bds_bind(the_env, @'*print-base*', ecl_make_fixnum(10)); writestr_stream("\n;;; Unhandled lisp initialization error", stream); writestr_stream("\n;;; Message:\n", stream); si_write_ugly_object(datum, stream); writestr_stream("\n;;; Arguments:\n", stream); si_write_ugly_object(args, stream); ecl_bds_unwind_n(the_env, 5); } ABORT: ecl_internal_error("\nLisp initialization error.\n"); } void FEdivision_by_zero(cl_object x, cl_object y) { cl_error(5, @'division-by-zero', @':operation', @'/', @':operands', cl_list(2, x, y)); } cl_object _ecl_strerror(int code) { const char *error = strerror(code); return make_base_string_copy(error); } /************************************* * Errors generated by the C library * *************************************/ /* * Interprets an error code from the C library according to the POSIX * standard, and produces a suitable error message by combining the user * supplied format with an explanation of the cause of the error. */ void FElibc_error(const char *msg, int narg, ...) { ecl_va_list args; cl_object rest, error = _ecl_strerror(errno); ecl_va_start(args, narg, narg, 0); rest = cl_grab_rest_args(args); FEerror("~?~%C library explanation: ~A.", 3, make_constant_base_string(msg), rest, error); } #if defined(ECL_MS_WINDOWS_HOST) || defined(cygwin) ecl_def_ct_base_string(unknown_error,"[Unable to get error message]",28,static,const); void FEwin32_error(const char *msg, int narg, ...) { ecl_va_list args; cl_object rest, win_msg_obj; char *win_msg; if (FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_ALLOCATE_BUFFER, 0, GetLastError(), 0, (void*)&win_msg, 0, NULL) == 0) win_msg_obj = unknown_error; else { win_msg_obj = make_base_string_copy(win_msg); LocalFree(win_msg); } ecl_va_start(args, narg, narg, 0); rest = cl_grab_rest_args(args); FEerror("~?~%Windows library explanation: ~A.", 3, make_constant_base_string(msg), rest, win_msg_obj); } #endif /************************************ * Higher level interface to errors * ************************************/ @(defun error (eformat &rest args) @ ecl_enable_interrupts(); funcall(4, @'si::universal-error-handler', ECL_NIL, eformat, cl_grab_rest_args(args)); _ecl_unexpected_return(); @(return); @) @(defun cerror (cformat eformat &rest args) @ ecl_enable_interrupts(); return funcall(4, @'si::universal-error-handler', cformat, eformat, cl_grab_rest_args(args)); @) @(defun si::serror (cformat eformat &rest args) @ ecl_enable_interrupts(); return funcall(4, @'si::stack-error-handler', cformat, eformat, cl_grab_rest_args(args)); @) void init_error(void) { ecl_def_c_function(@'si::universal-error-handler', (cl_objectfn_fixed)universal_error_handler, 3); } ecl-16.1.2/src/c/eval.d000066400000000000000000000205461266352375300144740ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* eval.c -- Eval. */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #include #include cl_object * _ecl_va_sp(cl_narg narg) { return ecl_process_env()->stack_top - narg; } /* Calling conventions: Compiled C code calls lisp function supplying #args, and args. Linking function performs check_args, gets jmp_buf with _setjmp, then if cfun then stores C code address into function link location and transfers to jmp_buf at cf_self if cclosure then replaces #args with cc_env and calls cc_self otherwise, it emulates funcall. */ cl_object ecl_apply_from_stack_frame(cl_object frame, cl_object x) { cl_object *sp = frame->frame.base; cl_index narg = frame->frame.size; cl_object fun = x; AGAIN: frame->frame.env->function = fun; if (ecl_unlikely(fun == OBJNULL || fun == ECL_NIL)) FEundefined_function(x); switch (ecl_t_of(fun)) { case t_cfunfixed: if (ecl_unlikely(narg != (cl_index)fun->cfun.narg)) FEwrong_num_arguments(fun); return APPLY_fixed(narg, fun->cfunfixed.entry_fixed, sp); case t_cfun: return APPLY(narg, fun->cfun.entry, sp); case t_cclosure: return APPLY(narg, fun->cclosure.entry, sp); case t_instance: switch (fun->instance.isgf) { case ECL_STANDARD_DISPATCH: case ECL_RESTRICTED_DISPATCH: return _ecl_standard_dispatch(frame, fun); case ECL_USER_DISPATCH: fun = fun->instance.slots[fun->instance.length - 1]; goto AGAIN; case ECL_READER_DISPATCH: case ECL_WRITER_DISPATCH: return APPLY(narg, fun->instance.entry, sp); default: FEinvalid_function(fun); } case t_symbol: if (ecl_unlikely(fun->symbol.stype & ecl_stp_macro)) FEundefined_function(x); fun = ECL_SYM_FUN(fun); goto AGAIN; case t_bytecodes: return ecl_interpret(frame, ECL_NIL, fun); case t_bclosure: return ecl_interpret(frame, fun->bclosure.lex, fun->bclosure.code); default: FEinvalid_function(x); } } cl_objectfn ecl_function_dispatch(cl_env_ptr env, cl_object x) { cl_object fun = x; AGAIN: if (ecl_unlikely(fun == OBJNULL || fun == ECL_NIL)) FEundefined_function(x); switch (ecl_t_of(fun)) { case t_cfunfixed: env->function = fun; return fun->cfunfixed.entry; case t_cfun: env->function = fun; return fun->cfun.entry; case t_cclosure: env->function = fun; return fun->cclosure.entry; case t_instance: env->function = fun; return fun->instance.entry; case t_symbol: if (ecl_unlikely(fun->symbol.stype & ecl_stp_macro)) FEundefined_function(x); fun = ECL_SYM_FUN(fun); goto AGAIN; case t_bytecodes: env->function = fun; return fun->bytecodes.entry; case t_bclosure: env->function = fun; return fun->bclosure.entry; default: FEinvalid_function(x); } } cl_object cl_funcall(cl_narg narg, cl_object function, ...) { cl_object output; --narg; { ECL_STACK_FRAME_VARARGS_BEGIN(narg, function, frame); output = ecl_apply_from_stack_frame(frame, function); ECL_STACK_FRAME_VARARGS_END(frame); } return output; } @(defun apply (fun lastarg &rest args) @ if (narg == 2 && ecl_t_of(lastarg) == t_frame) { return ecl_apply_from_stack_frame(lastarg, fun); } else { cl_object out; cl_index i; struct ecl_stack_frame frame_aux; const cl_object frame = ecl_stack_frame_open(the_env, (cl_object)&frame_aux, narg -= 2); for (i = 0; i < narg; i++) { ECL_STACK_FRAME_SET(frame, i, lastarg); lastarg = ecl_va_arg(args); } if (ecl_t_of(lastarg) == t_frame) { /* This could be replaced with a memcpy() */ for (i = 0; i < lastarg->frame.size; i++) { ecl_stack_frame_push(frame, lastarg->frame.base[i]); } } else loop_for_in (lastarg) { if (ecl_unlikely(i >= ECL_CALL_ARGUMENTS_LIMIT)) { ecl_stack_frame_close(frame); FEprogram_error_noreturn("CALL-ARGUMENTS-LIMIT exceeded",0); } ecl_stack_frame_push(frame, CAR(lastarg)); i++; } end_loop_for_in; out = ecl_apply_from_stack_frame(frame, fun); ecl_stack_frame_close(frame); return out; } @) cl_object cl_eval(cl_object form) { return si_eval_with_env(1, form); } @(defun constantp (arg &optional env) @ return _ecl_funcall3(@'ext::constantp-inner', arg, env); @) @(defun ext::constantp-inner (form &optional env) cl_object value; @ AGAIN: switch (ecl_t_of(form)) { case t_list: if (Null(form)) { value = ECL_T; break; } if (ECL_CONS_CAR(form) == @'quote') { value = ECL_T; break; } /* value = cl_macroexpand(2, form, env); if (value != form) { form = value; goto AGAIN; } */ value = ECL_NIL; break; case t_symbol: value = cl_macroexpand(2, form, env); if (value != form) { form = value; goto AGAIN; } if (!(form->symbol.stype & ecl_stp_constant)) { value = ECL_NIL; break; } default: value = ECL_T; } ecl_return1(the_env, value); @) @(defun ext::constant-form-value (form &optional env) cl_object value; @ { AGAIN: switch (ecl_t_of(form)) { case t_list: if (Null(form)) { value = ECL_NIL; break; } if (ECL_CONS_CAR(form) == @'quote') { return cl_second(form); } /* value = cl_macroexpand(2, form, env); if (value != form) { form = value; goto AGAIN; } */ ERROR: FEerror("EXT:CONSTANT-FORM-VALUE invoked with a non-constant form ~A", 0, form); break; case t_symbol: value = cl_macroexpand(2, form, env); if (value != form) { form = value; goto AGAIN; } value = ECL_SYM_VAL(the_env, value); break; default: value = form; } @(return value); } @) ecl-16.1.2/src/c/ffi.d000066400000000000000000001072721266352375300143130ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* ffi.c -- User defined data types and foreign functions interface. */ /* Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #define ECL_INCLUDE_FFI_H #include #include static const cl_object ecl_aet_to_ffi_table[ecl_aet_bc+1] = { @':void', /* ecl_aet_object */ @':float', /* ecl_aet_df */ @':double', /* ecl_aet_df */ @':void', /* ecl_aet_bit */ #if ECL_FIXNUM_BITS == 32 && defined(ecl_uint32_t) @':int32-t', /* ecl_aet_fix */ @':uint32-t', /* ecl_aet_index */ #else # if ECL_FIXNUM_BITS == 64 && defined(ecl_uint64_t) @':int64-t', /* ecl_aet_fix */ @':uint64-t', /* ecl_aet_index */ # else @':void', /* ecl_aet_fix */ @':void', /* ecl_aet_index */ # endif #endif @':uint8-t', /* ecl_aet_b8 */ @':int8-t', /* ecl_aet_i8 */ #ifdef ecl_uint16_t @':uint16-t', /* ecl_aet_b16 */ @':int16-t', /* ecl_aet_i16 */ #endif #ifdef ecl_uint32_t @':uint32-t', /* ecl_aet_b32 */ @':int32-t', /* ecl_aet_i32 */ #endif #ifdef ecl_uint64_t @':uint64-t', /* ecl_aet_b64 */ @':int64-t', /* ecl_aet_i64 */ #endif #ifdef ECL_UNICODE # ifdef ecl_int32_t @':int32-t', /* ecl_aet_ch */ # else @':void', /* ecl_aet_ch */ # endif #endif @':char' /* ecl_aet_bc */ }; #define AUX_PTR(type) \ ((struct { char a[1]; union { type c[1]; char d[sizeof(type)]; } b; } *)0) #ifdef __GNUC__ typedef struct { cl_object name; cl_index size; cl_index alignment; } ecl_foreign_type_record; # define ALIGNMENT(tag) (ecl_foreign_type_table[tag].alignment) # define FFI_DESC(symbol,type) \ {symbol, sizeof(type), (AUX_PTR(type)->b.d - AUX_PTR(type)->a)} #else typedef struct { cl_object name; cl_index size; char *d, *a; } ecl_foreign_type_record; #define ALIGNMENT(tag) (ecl_foreign_type_table[tag].d - ecl_foreign_type_table[tag].a) #define AUX_PTR(type) \ ((struct { char a[1]; union { type c[1]; char d[sizeof(type)]; } b; } *)0) #define FFI_DESC(symbol,type) \ {symbol, sizeof(type), AUX_PTR(type)->b.d, AUX_PTR(type)->a} #endif static const ecl_foreign_type_record ecl_foreign_type_table[] = { FFI_DESC(@':char', char), FFI_DESC(@':unsigned-char', unsigned char), FFI_DESC(@':byte', ecl_int8_t), FFI_DESC(@':unsigned-byte', ecl_uint8_t), FFI_DESC(@':short', short), FFI_DESC(@':unsigned-short', unsigned short), FFI_DESC(@':int', int), FFI_DESC(@':unsigned-int', unsigned int), FFI_DESC(@':long', long), FFI_DESC(@':unsigned-long', unsigned long), #ifdef ecl_uint8_t FFI_DESC(@':int8-t', ecl_int8_t), FFI_DESC(@':uint8-t', ecl_uint8_t), #endif #ifdef ecl_uint16_t FFI_DESC(@':int16-t', ecl_int16_t), FFI_DESC(@':uint16-t', ecl_uint16_t), #endif #ifdef ecl_uint32_t FFI_DESC(@':int32-t', ecl_int32_t), FFI_DESC(@':uint32-t', ecl_uint32_t), #endif #ifdef ecl_uint64_t FFI_DESC(@':int64-t', ecl_int64_t), FFI_DESC(@':uint64-t', ecl_uint64_t), #endif #ifdef ecl_long_long_t FFI_DESC(@':long-long', long long), FFI_DESC(@':unsigned-long-long', unsigned long long), #endif FFI_DESC(@':pointer-void', void *), FFI_DESC(@':cstring', char *), FFI_DESC(@':object', cl_object), FFI_DESC(@':float', float), FFI_DESC(@':double', double), {@':void', 0, 0} }; #ifdef ECL_DYNAMIC_FFI static const cl_object ecl_foreign_cc_table[] = { @':cdecl', @':stdcall' }; #endif #ifdef HAVE_LIBFFI static struct { const cl_object symbol; ffi_abi abi; } ecl_foreign_cc_table[] = { {@':default', FFI_DEFAULT_ABI}, #ifdef X86_WIN32 {@':cdecl', FFI_SYSV}, {@':sysv', FFI_SYSV}, {@':stdcall', FFI_STDCALL}, #elif defined(X86_WIN64) {@':win64', FFI_WIN64}, #elif defined(X86_ANY) || defined(X86) || defined(X86_64) {@':cdecl', FFI_SYSV}, {@':sysv', FFI_SYSV}, {@':unix64', FFI_UNIX64}, #endif }; static ffi_type *ecl_type_to_libffi_type[] = { &ffi_type_schar, /*@':char',*/ &ffi_type_uchar, /*@':unsigned-char',*/ &ffi_type_sint8, /*@':byte',*/ &ffi_type_uint8, /*@':unsigned-byte',*/ &ffi_type_sshort, /*@':short',*/ &ffi_type_ushort, /*@':unsigned-short',*/ &ffi_type_sint, /*@':int',*/ &ffi_type_uint, /*@':unsigned-int',*/ &ffi_type_slong, /*@':long',*/ &ffi_type_ulong, /*@':unsigned-long',*/ #ifdef ecl_uint8_t &ffi_type_sint8, /*@':int8-t',*/ &ffi_type_uint8, /*@':uint8-t',*/ #endif #ifdef ecl_uint16_t &ffi_type_sint16, /*@':int16-t',*/ &ffi_type_uint16, /*@':uint16-t',*/ #endif #ifdef ecl_uint32_t &ffi_type_sint32, /*@':int32-t',*/ &ffi_type_uint32, /*@':uint32-t',*/ #endif #ifdef ecl_uint64_t &ffi_type_sint64, /*@':int64-t',*/ &ffi_type_uint64, /*@':uint64-t',*/ #endif #ifdef ecl_long_long_t &ffi_type_sint64, /*@':long-long',*/ /*FIXME! libffi does not have long long */ &ffi_type_uint64, /*@':unsigned-long-long',*/ #endif &ffi_type_pointer, /*@':pointer-void',*/ &ffi_type_pointer, /*@':cstring',*/ &ffi_type_pointer, /*@':object',*/ &ffi_type_float, /*@':float',*/ &ffi_type_double, /*@':double',*/ &ffi_type_void /*@':void'*/ }; #endif /* HAVE_LIBFFI */ cl_object ecl_make_foreign_data(cl_object tag, cl_index size, void *data) { cl_object output = ecl_alloc_object(t_foreign); output->foreign.tag = tag == ECL_NIL ? @':void' : tag; output->foreign.size = size; output->foreign.data = (char*)data; return output; } cl_object ecl_allocate_foreign_data(cl_object tag, cl_index size) { cl_object output = ecl_alloc_object(t_foreign); output->foreign.tag = tag; output->foreign.size = size; output->foreign.data = (char*)ecl_alloc_atomic(size); return output; } void * ecl_foreign_data_pointer_safe(cl_object f) { if (ecl_unlikely(ecl_t_of(f) != t_foreign)) { FEwrong_type_only_arg(@[si::foreign-data-pointer], f, @[si::foreign-data]); } return f->foreign.data; } char * ecl_base_string_pointer_safe(cl_object f) { unsigned char *s; /* FIXME! Is there a better function name? */ f = ecl_check_cl_type(@'si::make-foreign-data-from-array', f, t_base_string); s = f->base_string.self; if (ecl_unlikely(ECL_ARRAY_HAS_FILL_POINTER_P(f) && s[f->base_string.fillp] != 0)) { FEerror("Cannot coerce a string with fill pointer to (char *)", 0); } return (char *)s; } cl_object ecl_null_terminated_base_string(cl_object f) { /* FIXME! Is there a better function name? */ f = ecl_check_cl_type(@'si::make-foreign-data-from-array', f, t_base_string); if (ECL_ARRAY_HAS_FILL_POINTER_P(f) && f->base_string.self[f->base_string.fillp] != 0) { return cl_copy_seq(f); } else { return f; } } cl_object si_allocate_foreign_data(cl_object tag, cl_object size) { cl_object output = ecl_alloc_object(t_foreign); cl_index bytes = ecl_to_size(size); output->foreign.tag = tag; output->foreign.size = bytes; /* FIXME! Should be atomic uncollectable or malloc, but we do not export * that garbage collector interface and malloc may be overwritten * by the GC library */ output->foreign.data = bytes? ecl_alloc_uncollectable(bytes) : NULL; @(return output) } cl_object si_free_foreign_data(cl_object f) { if (ecl_unlikely(ecl_t_of(f) != t_foreign)) { FEwrong_type_only_arg(@[si::free-foreign-data], f, @[si::foreign-data]); } if (f->foreign.size) { /* See si_allocate_foreign_data() */ ecl_free_uncollectable(f->foreign.data); } f->foreign.size = 0; f->foreign.data = NULL; @(return) } cl_object si_make_foreign_data_from_array(cl_object array) { cl_object tag; if (!ECL_ARRAYP (array)) FEwrong_type_only_arg(@[si::make-foreign-data-from-array], array, @[array]); tag = ecl_aet_to_ffi_table[array->array.elttype]; if (ecl_unlikely(Null(tag))) { FEerror("Cannot make foreign object from array " "with element type ~S.", 1, ecl_elttype_to_symbol(array->array.elttype)); } @(return ecl_make_foreign_data(tag, 0, array->array.self.bc)); } cl_object si_foreign_data_p(cl_object f) { @(return (ECL_FOREIGN_DATA_P(f)? ECL_T : ECL_NIL)) } cl_object si_foreign_data_address(cl_object f) { if (ecl_unlikely(ecl_t_of(f) != t_foreign)) { FEwrong_type_only_arg(@[si::foreign-data-address], f, @[si::foreign-data]); } @(return ecl_make_unsigned_integer((cl_index)f->foreign.data)) } cl_object si_foreign_data_tag(cl_object f) { if (ecl_unlikely(ecl_t_of(f) != t_foreign)) { FEwrong_type_only_arg(@[si::foreign-data-tag], f, @[si::foreign-data]); } @(return f->foreign.tag); } cl_object si_foreign_data_equal(cl_object f1, cl_object f2) { if (ecl_unlikely(!ECL_FOREIGN_DATA_P(f1))) { FEwrong_type_only_arg(@[si::foreign-data-address], f1, @[si::foreign-data]); } if (ecl_unlikely(!ECL_FOREIGN_DATA_P(f2))) { FEwrong_type_only_arg(@[si::foreign-data-address], f2, @[si::foreign-data]); } @(return ((f1->foreign.data == f2->foreign.data)? ECL_T : ECL_NIL)) } cl_object si_foreign_data_pointer(cl_object f, cl_object andx, cl_object asize, cl_object tag) { cl_index ndx = ecl_to_size(andx); cl_index size = ecl_to_size(asize); cl_object output; if (ecl_unlikely(ecl_t_of(f) != t_foreign)) { FEwrong_type_only_arg(@[si::foreign-data-pointer], f, @[si::foreign-data]); } if (ecl_unlikely(ndx >= f->foreign.size || (f->foreign.size - ndx) < size)) { FEerror("Out of bounds reference into foreign data type ~A.", 1, f); } output = ecl_alloc_object(t_foreign); output->foreign.tag = tag; output->foreign.size = size; output->foreign.data = f->foreign.data + ndx; @(return output) } cl_object si_foreign_data_ref(cl_object f, cl_object andx, cl_object asize, cl_object tag) { cl_index ndx = ecl_to_size(andx); cl_index size = ecl_to_size(asize); cl_object output; if (ecl_unlikely(ecl_t_of(f) != t_foreign)) { FEwrong_type_nth_arg(@[si::foreign-data-ref], 1, f, @[si::foreign-data]); } if (ecl_unlikely(ndx >= f->foreign.size || (f->foreign.size - ndx) < size)) { FEerror("Out of bounds reference into foreign data type ~A.", 1, f); } output = ecl_allocate_foreign_data(tag, size); memcpy(output->foreign.data, f->foreign.data + ndx, size); @(return output) } cl_object si_foreign_data_set(cl_object f, cl_object andx, cl_object value) { cl_index ndx = ecl_to_size(andx); cl_index size, limit; if (ecl_unlikely(ecl_t_of(f) != t_foreign)) { FEwrong_type_nth_arg(@[si::foreign-data-set], 1, f, @[si::foreign-data]); } if (ecl_unlikely(ecl_t_of(value) != t_foreign)) { FEwrong_type_nth_arg(@[si::foreign-data-set], 3, value, @[si::foreign-data]); } size = value->foreign.size; limit = f->foreign.size; if (ecl_unlikely(ndx >= limit || (limit - ndx) < size)) { FEerror("Out of bounds reference into foreign data type ~A.", 1, f); } memcpy(f->foreign.data + ndx, value->foreign.data, size); @(return value) } static int foreign_type_code(cl_object type) { int i; for (i = 0; i <= ECL_FFI_VOID; i++) { if (type == ecl_foreign_type_table[i].name) return i; } return -1; } enum ecl_ffi_tag ecl_foreign_type_code(cl_object type) { int i = foreign_type_code(type); if (ecl_unlikely(i < 0)) { FEerror("~A does not denote an elementary foreign type.", 1, type); } return (enum ecl_ffi_tag)i; } #ifdef HAVE_LIBFFI ffi_abi ecl_foreign_cc_code(cl_object cc) { int i; for (i = 0; i <= ECL_FFI_CC_STDCALL; i++) { if (cc == ecl_foreign_cc_table[i].symbol) return ecl_foreign_cc_table[i].abi; } FEerror("~A does no denote a valid calling convention.", 1, cc); return ECL_FFI_CC_CDECL; } #endif #ifdef ECL_DYNAMIC_FFI enum ecl_ffi_calling_convention ecl_foreign_cc_code(cl_object cc) { int i; for (i = 0; i <= ECL_FFI_CC_STDCALL; i++) { if (cc == ecl_foreign_cc_table[i]) return (enum ecl_ffi_calling_convention)i; } FEerror("~A does no denote a valid calling convention.", 1, cc); return ECL_FFI_CC_CDECL; } #endif static void wrong_ffi_tag(enum ecl_ffi_tag tag) ecl_attr_noreturn; static void wrong_ffi_tag(enum ecl_ffi_tag tag) { FEerror("Invalid ecl_ffi_tag code ~D", 1, ecl_make_integer(tag)); } cl_object ecl_foreign_data_ref_elt(void *p, enum ecl_ffi_tag tag) { switch (tag) { case ECL_FFI_CHAR: return ECL_CODE_CHAR(*(char *)p); case ECL_FFI_UNSIGNED_CHAR: return ECL_CODE_CHAR(*(unsigned char *)p); case ECL_FFI_BYTE: return ecl_make_fixnum(*(int8_t *)p); case ECL_FFI_UNSIGNED_BYTE: return ecl_make_fixnum(*(uint8_t *)p); case ECL_FFI_SHORT: return ecl_make_fixnum(*(short *)p); case ECL_FFI_UNSIGNED_SHORT: return ecl_make_fixnum(*(unsigned short *)p); case ECL_FFI_INT: return ecl_make_integer(*(int *)p); case ECL_FFI_UNSIGNED_INT: return ecl_make_unsigned_integer(*(unsigned int *)p); case ECL_FFI_LONG: return ecl_make_integer(*(long *)p); #ifdef ecl_uint8_t case ECL_FFI_INT8_T: return ecl_make_fixnum(*(ecl_int8_t *)p); case ECL_FFI_UINT8_T: return ecl_make_fixnum(*(ecl_uint8_t *)p); #endif #ifdef ecl_uint16_t case ECL_FFI_INT16_T: return ecl_make_int16_t(*(ecl_int16_t *)p); case ECL_FFI_UINT16_T: return ecl_make_uint16_t(*(ecl_uint16_t *)p); #endif #ifdef ecl_uint32_t case ECL_FFI_INT32_T: return ecl_make_int32_t(*(ecl_int32_t *)p); case ECL_FFI_UINT32_T: return ecl_make_uint32_t(*(ecl_uint32_t *)p); #endif #ifdef ecl_uint64_t case ECL_FFI_INT64_T: return ecl_make_int64_t(*(ecl_int64_t *)p); case ECL_FFI_UINT64_T: return ecl_make_uint64_t(*(ecl_uint64_t *)p); #endif #ifdef ecl_long_long_t case ECL_FFI_LONG_LONG: return ecl_make_long_long(*(ecl_long_long_t *)p); case ECL_FFI_UNSIGNED_LONG_LONG: return ecl_make_ulong_long(*(ecl_ulong_long_t *)p); #endif case ECL_FFI_UNSIGNED_LONG: return ecl_make_unsigned_integer(*(unsigned long *)p); case ECL_FFI_POINTER_VOID: return ecl_make_foreign_data(@':pointer-void', 0, *(void **)p); case ECL_FFI_CSTRING: return *(char **)p ? ecl_make_simple_base_string(*(char **)p, -1) : ECL_NIL; case ECL_FFI_OBJECT: return *(cl_object *)p; case ECL_FFI_FLOAT: return ecl_make_single_float(*(float *)p); case ECL_FFI_DOUBLE: return ecl_make_double_float(*(double *)p); case ECL_FFI_VOID: return ECL_NIL; default: wrong_ffi_tag(tag); } } void ecl_foreign_data_set_elt(void *p, enum ecl_ffi_tag tag, cl_object value) { switch (tag) { case ECL_FFI_CHAR: *(char *)p = (char)ecl_base_char_code(value); break; case ECL_FFI_UNSIGNED_CHAR: *(unsigned char*)p = (unsigned char)ecl_base_char_code(value); break; case ECL_FFI_BYTE: *(int8_t *)p = ecl_to_int8_t(value); break; case ECL_FFI_UNSIGNED_BYTE: *(uint8_t *)p = ecl_to_uint8_t(value); break; case ECL_FFI_SHORT: *(short *)p = ecl_to_short(value); break; case ECL_FFI_UNSIGNED_SHORT: *(unsigned short *)p = ecl_to_ushort(value); break; case ECL_FFI_INT: *(int *)p = ecl_to_int(value); break; case ECL_FFI_UNSIGNED_INT: *(unsigned int *)p = ecl_to_uint(value); break; case ECL_FFI_LONG: *(long *)p = ecl_to_long(value); break; case ECL_FFI_UNSIGNED_LONG: *(unsigned long *)p = ecl_to_ulong(value); break; case ECL_FFI_INT8_T: *(ecl_int8_t *)p = ecl_to_int8_t(value); break; case ECL_FFI_UINT8_T: *(ecl_uint8_t *)p = ecl_to_uint8_t(value); break; #ifdef ecl_uint16_t case ECL_FFI_INT16_T: *(ecl_int16_t *)p = ecl_to_int16_t(value); break; case ECL_FFI_UINT16_T: *(ecl_uint16_t *)p = ecl_to_uint16_t(value); break; #endif #ifdef ecl_uint32_t case ECL_FFI_INT32_T: *(ecl_int32_t *)p = ecl_to_int32_t(value); break; case ECL_FFI_UINT32_T: *(ecl_uint32_t *)p = ecl_to_uint32_t(value); break; #endif #ifdef ecl_uint64_t case ECL_FFI_INT64_T: *(ecl_int64_t *)p = ecl_to_int64_t(value); break; case ECL_FFI_UINT64_T: *(ecl_uint64_t *)p = ecl_to_uint64_t(value); break; #endif #ifdef ecl_long_long_t case ECL_FFI_LONG_LONG: *(ecl_long_long_t *)p = ecl_to_long_long(value); break; case ECL_FFI_UNSIGNED_LONG_LONG: *(ecl_ulong_long_t *)p = ecl_to_ulong_long(value); break; #endif case ECL_FFI_POINTER_VOID: *(void **)p = ecl_foreign_data_pointer_safe(value); break; case ECL_FFI_CSTRING: *(char **)p = value == ECL_NIL ? NULL : (char*)value->base_string.self; break; case ECL_FFI_OBJECT: *(cl_object *)p = value; break; case ECL_FFI_FLOAT: *(float *)p = ecl_to_float(value); break; case ECL_FFI_DOUBLE: *(double *)p = ecl_to_double(value); break; case ECL_FFI_VOID: break; default: wrong_ffi_tag(tag); } } cl_object si_foreign_data_ref_elt(cl_object f, cl_object andx, cl_object type) { cl_index ndx = ecl_to_size(andx); cl_index limit = f->foreign.size; enum ecl_ffi_tag tag = ecl_foreign_type_code(type); if (ecl_unlikely(ndx >= limit || (ndx + ecl_foreign_type_table[tag].size > limit))) { FEerror("Out of bounds reference into foreign data type ~A.", 1, f); } if (ecl_unlikely(ecl_t_of(f) != t_foreign)) { FEwrong_type_nth_arg(@[si::foreign-data-ref-elt], 1, f, @[si::foreign-data]); } @(return ecl_foreign_data_ref_elt((void*)(f->foreign.data + ndx), tag)) } cl_object si_foreign_data_set_elt(cl_object f, cl_object andx, cl_object type, cl_object value) { cl_index ndx = ecl_to_size(andx); cl_index limit = f->foreign.size; enum ecl_ffi_tag tag = ecl_foreign_type_code(type); if (ecl_unlikely(ndx >= limit || ndx + ecl_foreign_type_table[tag].size > limit)) { FEerror("Out of bounds reference into foreign data type ~A.", 1, f); } if (ecl_unlikely(ecl_t_of(f) != t_foreign)) { FEwrong_type_nth_arg(@[si::foreign-data-set-elt], 1, f, @[si::foreign-data]); } ecl_foreign_data_set_elt((void*)(f->foreign.data + ndx), tag, value); @(return value) } cl_object si_size_of_foreign_elt_type(cl_object type) { enum ecl_ffi_tag tag = ecl_foreign_type_code(type); @(return ecl_make_fixnum(ecl_foreign_type_table[tag].size)) } cl_object si_alignment_of_foreign_elt_type(cl_object type) { enum ecl_ffi_tag tag = ecl_foreign_type_code(type); @(return ecl_make_fixnum(ALIGNMENT(tag))) } cl_object si_foreign_elt_type_p(cl_object type) { @(return ((foreign_type_code(type) < 0)? ECL_NIL : ECL_T)) } cl_object si_null_pointer_p(cl_object f) { if (ecl_unlikely(ecl_t_of(f) != t_foreign)) FEwrong_type_only_arg(@[si::null-pointer-p], f, @[si::foreign-data]); @(return ((f->foreign.data == NULL)? ECL_T : ECL_NIL)) } cl_object si_foreign_data_recast(cl_object f, cl_object size, cl_object tag) { if (ecl_unlikely(ecl_t_of(f) != t_foreign)) FEwrong_type_nth_arg(@[si::foreign-data-recast], 1, f, @[si::foreign-data]); f->foreign.size = ecl_to_size(size); f->foreign.tag = tag; @(return f) } cl_object si_load_foreign_module(cl_object filename) { #if !defined(ENABLE_DLOPEN) FEerror("SI:LOAD-FOREIGN-MODULE does not work when ECL is statically linked", 0); #else cl_object output; # ifdef ECL_THREADS mp_get_lock(1, ecl_symbol_value(@'mp::+load-compile-lock+')); ECL_UNWIND_PROTECT_BEGIN(ecl_process_env()) { # endif output = ecl_library_open(filename, 0); if (output->cblock.handle == NULL) { cl_object aux = ecl_library_error(output); ecl_library_close(output); output = aux; } # ifdef ECL_THREADS (void)0; /* MSVC complains about missing ';' before '}' */ } ECL_UNWIND_PROTECT_EXIT { mp_giveup_lock(ecl_symbol_value(@'mp::+load-compile-lock+')); } ECL_UNWIND_PROTECT_END; # endif if (ecl_unlikely(ecl_t_of(output) != t_codeblock)) { FEerror("LOAD-FOREIGN-MODULE: Could not load " "foreign module ~S (Error: ~S)", 2, filename, output); } output->cblock.locked |= 1; @(return output) #endif } cl_object si_unload_foreign_module(cl_object module) { #if !defined(ENABLE_DLOPEN) FEerror("SI:UNLOAD-FOREIGN-MODULE does not work when ECL is statically linked", 0); #else cl_object output = ECL_NIL; if (ecl_unlikely(ecl_t_of(module) != t_codeblock)) { FEerror("UNLOAD-FOREIGN-MODULE: Argument is not a foreign module: ~S ", 1, module); } # ifdef ECL_THREADS mp_get_lock(1, ecl_symbol_value(@'mp::+load-compile-lock+')); ECL_UNWIND_PROTECT_BEGIN(ecl_process_env()) { # endif if (ecl_likely(ecl_library_close(module))) output = ECL_T; # ifdef ECL_THREADS (void)0; /* MSVC complains about missing ';' before '}' */ } ECL_UNWIND_PROTECT_EXIT { mp_giveup_lock(ecl_symbol_value(@'mp::+load-compile-lock+')); } ECL_UNWIND_PROTECT_END; # endif @(return output) #endif } cl_object si_find_foreign_symbol(cl_object var, cl_object module, cl_object type, cl_object size) { #if !defined(ENABLE_DLOPEN) FEerror("SI:FIND-FOREIGN-SYMBOL does not work when ECL is statically linked", 0); #else cl_object block; cl_object output = ECL_NIL; void *sym; block = (module == @':default' ? module : si_load_foreign_module(module)); var = ecl_null_terminated_base_string(var); sym = ecl_library_symbol(block, (char*)var->base_string.self, 1); if (sym == NULL) { if (block != @':default') output = ecl_library_error(block); goto OUTPUT; } output = ecl_make_foreign_data(type, ecl_to_fixnum(size), sym); OUTPUT: if (ecl_unlikely(ecl_t_of(output) != t_foreign)) FEerror("FIND-FOREIGN-SYMBOL: Could not load " "foreign symbol ~S from module ~S (Error: ~S)", 3, var, module, output); @(return output) #endif } #ifdef ECL_DYNAMIC_FFI static void ecl_fficall_overflow() { FEerror("Stack overflow on SI:CALL-CFUN", 0); } void ecl_fficall_prepare(cl_object return_type, cl_object arg_type, cl_object cc_type) { struct ecl_fficall *fficall = cl_env.fficall; fficall->buffer_sp = fficall->buffer; fficall->buffer_size = 0; fficall->cstring = ECL_NIL; fficall->cc = ecl_foreign_cc_code(cc_type); fficall->registers = ecl_fficall_prepare_extra(fficall->registers); } void ecl_fficall_push_bytes(void *data, size_t bytes) { struct ecl_fficall *fficall = cl_env.fficall; fficall->buffer_size += bytes; if (fficall->buffer_size >= ECL_FFICALL_LIMIT) ecl_fficall_overflow(); memcpy(fficall->buffer_sp, (char*)data, bytes); fficall->buffer_sp += bytes; } void ecl_fficall_push_int(int data) { ecl_fficall_push_bytes(&data, sizeof(int)); } void ecl_fficall_align(int data) { struct ecl_fficall *fficall = cl_env.fficall; if (data == 1) return; else { size_t sp = fficall->buffer_sp - fficall->buffer; size_t mask = data - 1; size_t new_sp = (sp + mask) & ~mask; if (new_sp >= ECL_FFICALL_LIMIT) ecl_fficall_overflow(); fficall->buffer_sp = fficall->buffer + new_sp; fficall->buffer_size = new_sp; } } @(defun si::call-cfun (fun return_type arg_types args &optional (cc_type @':cdecl')) struct ecl_fficall *fficall = cl_env.fficall; void *cfun = ecl_foreign_data_pointer_safe(fun); cl_object object; enum ecl_ffi_tag return_type_tag = ecl_foreign_type_code(return_type); @ ecl_fficall_prepare(return_type, arg_types, cc_type); while (CONSP(arg_types)) { enum ecl_ffi_tag type; if (!CONSP(args)) { FEerror("In SI:CALL-CFUN, mismatch between argument types and argument list: ~A vs ~A", 0); } type = ecl_foreign_type_code(CAR(arg_types)); if (type == ECL_FFI_CSTRING) { object = ecl_null_terminated_base_string(CAR(args)); if (CAR(args) != object) fficall->cstring = CONS(object, fficall->cstring); } else { object = CAR(args); } ecl_foreign_data_set_elt(&fficall->output, type, object); ecl_fficall_push_arg(&fficall->output, type); arg_types = CDR(arg_types); args = CDR(args); } ecl_fficall_execute(cfun, fficall, return_type_tag); object = ecl_foreign_data_ref_elt(&fficall->output, return_type_tag); fficall->buffer_size = 0; fficall->buffer_sp = fficall->buffer; fficall->cstring = ECL_NIL; @(return object) @) @(defun si::make-dynamic-callback (fun sym rtype argtypes &optional (cctype @':cdecl')) cl_object data; cl_object cbk; @ data = cl_list(3, fun, rtype, argtypes); cbk = ecl_make_foreign_data(@':pointer-void', 0, ecl_dynamic_callback_make(data, ecl_foreign_cc_code(cctype))); si_put_sysprop(sym, @':callback', CONS(cbk, data)); @(return cbk) @) #endif /* ECL_DYNAMIC_FFI */ #ifdef HAVE_LIBFFI static void resize_call_stack(cl_env_ptr env, cl_index new_size) { cl_index i; ffi_type **types = ecl_alloc_atomic((new_size + 1) * sizeof(ffi_type*)); union ecl_ffi_values *values = ecl_alloc_atomic((new_size + 1) * sizeof(union ecl_ffi_values)); union ecl_ffi_values **values_ptrs = ecl_alloc_atomic(new_size * sizeof(union ecl_ffi_values *)); memcpy(types, env->ffi_types, env->ffi_args_limit * sizeof(ffi_type*)); memcpy(values, env->ffi_values, env->ffi_args_limit * sizeof(union ecl_ffi_values)); for (i = 0; i < new_size; i++) { values_ptrs[i] = (values + i + 1); } env->ffi_args_limit = new_size; ecl_dealloc(env->ffi_types); env->ffi_types = types; ecl_dealloc(env->ffi_values); env->ffi_values = values; ecl_dealloc(env->ffi_values_ptrs); env->ffi_values_ptrs = values_ptrs; } static int prepare_cif(cl_env_ptr the_env, ffi_cif *cif, cl_object return_type, cl_object arg_types, cl_object args, cl_object cc_type, ffi_type ***output_copy) { int n, ok; ffi_type **types; enum ecl_ffi_tag type = ecl_foreign_type_code(return_type); if (!the_env->ffi_args_limit) resize_call_stack(the_env, 32); the_env->ffi_types[0] = ecl_type_to_libffi_type[type]; for (n=0; !Null(arg_types); ) { if (!LISTP(arg_types)) { FEerror("In CALL-CFUN, types lists is not a proper list", 0); } if (n >= the_env->ffi_args_limit) { resize_call_stack(the_env, n + 32); } type = ecl_foreign_type_code(ECL_CONS_CAR(arg_types)); arg_types = ECL_CONS_CDR(arg_types); the_env->ffi_types[++n] = ecl_type_to_libffi_type[type]; if (CONSP(args)) { cl_object object = ECL_CONS_CAR(args); args = ECL_CONS_CDR(args); if (type == ECL_FFI_CSTRING) { object = ecl_null_terminated_base_string(CAR(args)); if (ECL_CONS_CAR(args) != object) { ECL_STACK_PUSH(the_env, object); } } ecl_foreign_data_set_elt(the_env->ffi_values + n, type, object); } } if (output_copy) { cl_index bytes = (n + 1) * sizeof(ffi_type*); *output_copy = types = (ffi_type**)ecl_alloc_atomic(bytes); memcpy(types, the_env->ffi_types, bytes); } else { types = the_env->ffi_types; } ok = ffi_prep_cif(cif, ecl_foreign_cc_code(cc_type), n, types[0], types + 1); if (ok != FFI_OK) { if (ok == FFI_BAD_ABI) { FEerror("In CALL-CFUN, not a valid ABI: ~A", 1, cc_type); } if (ok == FFI_BAD_TYPEDEF) { FEerror("In CALL-CFUN, wrong or malformed argument types", 0); } } return n; } @(defun si::call-cfun (fun return_type arg_types args &optional (cc_type @':default')) void *cfun = ecl_foreign_data_pointer_safe(fun); cl_object object; volatile cl_index sp; ffi_cif cif; @ { sp = ECL_STACK_INDEX(the_env); prepare_cif(the_env, &cif, return_type, arg_types, args, cc_type, NULL); ffi_call(&cif, cfun, the_env->ffi_values, (void **)the_env->ffi_values_ptrs); object = ecl_foreign_data_ref_elt(the_env->ffi_values, ecl_foreign_type_code(return_type)); ECL_STACK_SET_INDEX(the_env, sp); @(return object) } @) static void callback_executor(ffi_cif *cif, void *result, void **args, void *userdata) { cl_object data = (cl_object)userdata; cl_object fun = ECL_CONS_CAR(data); cl_object ret_type = (data = ECL_CONS_CDR(data), ECL_CONS_CAR(data)); cl_object arg_types = (data = ECL_CONS_CDR(data), ECL_CONS_CAR(data)); cl_env_ptr the_env = ecl_process_env(); struct ecl_stack_frame frame_aux; const cl_object frame = ecl_stack_frame_open(the_env, (cl_object)&frame_aux, 0); cl_object x; while (arg_types != ECL_NIL) { cl_object type = ECL_CONS_CAR(arg_types); enum ecl_ffi_tag tag = ecl_foreign_type_code(type); x = ecl_foreign_data_ref_elt(*args, tag); ecl_stack_frame_push(frame, x); arg_types = ECL_CONS_CDR(arg_types); args++; } x = ecl_apply_from_stack_frame(frame, fun); ecl_stack_frame_close(frame); ecl_foreign_data_set_elt(result, ecl_foreign_type_code(ret_type), x); } cl_object si_free_ffi_closure(cl_object closure) { ffi_closure_free(ecl_foreign_data_pointer_safe(closure)); @(return); } @(defun si::make-dynamic-callback (fun sym return_type arg_types &optional (cc_type @':default')) @ { ffi_cif *cif = ecl_alloc(sizeof(ffi_cif)); ffi_type **types; int n = prepare_cif(the_env, cif, return_type, arg_types, ECL_NIL, cc_type, &types); /* libffi allocates executable memory for us. ffi_closure_alloc() * returns a pointer to memory and a pointer to the beginning of * the actual executable region (executable_closure) which is * where the code resides. */ void *executable_region; ffi_closure *closure = ffi_closure_alloc(sizeof(ffi_closure), &executable_region); cl_object closure_object = ecl_make_foreign_data(@':pointer-void', sizeof(ffi_closure), closure); si_set_finalizer(closure_object, @'si::free-ffi-closure'); cl_object data = cl_list(6, closure_object, fun, return_type, arg_types, cc_type, ecl_make_foreign_data(@':pointer-void', sizeof(*cif), cif), ecl_make_foreign_data(@':pointer-void', (n + 1) * sizeof(ffi_type*), types)); int status = ffi_prep_closure_loc(closure, cif, callback_executor, ECL_CONS_CDR(data), executable_region); if (status != FFI_OK) { FEerror("Unable to build callback. libffi returns ~D", 1, ecl_make_fixnum(status)); } si_put_sysprop(sym, @':callback', data); @(return closure_object); } @) #endif /* HAVE_LIBFFI */ ecl-16.1.2/src/c/ffi/000077500000000000000000000000001266352375300141355ustar00rootroot00000000000000ecl-16.1.2/src/c/ffi/backtrace.d000066400000000000000000000104351266352375300162240ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* backtrace.d -- C backtraces */ /* Copyright (c) 2010, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #include #include #ifdef HAVE_DLADDR # ifdef HAVE_DLFCN_H # include # endif #endif #if defined(HAVE_BACKTRACE) || defined(HAVE_BACKTRACE_SYMBOLS) # include #endif #if !defined(HAVE_BACKTRACE) && defined(HAVE___BUILTIN_RETURN_ADDRESS) #define HAVE_BACKTRACE static int backtrace(void **buffer, int n) { int nframes = (n > 32)? 32 : n; int i; switch (nframes) { case 32: buffer[31] = __builtin_return_address(31); case 31: buffer[30] = __builtin_return_address(30); case 30: buffer[29] = __builtin_return_address(29); case 29: buffer[28] = __builtin_return_address(28); case 28: buffer[27] = __builtin_return_address(27); case 27: buffer[26] = __builtin_return_address(26); case 26: buffer[25] = __builtin_return_address(25); case 25: buffer[24] = __builtin_return_address(24); case 24: buffer[23] = __builtin_return_address(23); case 23: buffer[22] = __builtin_return_address(22); case 22: buffer[21] = __builtin_return_address(21); case 21: buffer[20] = __builtin_return_address(20); case 20: buffer[19] = __builtin_return_address(19); case 19: buffer[18] = __builtin_return_address(18); case 18: buffer[17] = __builtin_return_address(17); case 17: buffer[16] = __builtin_return_address(16); case 16: buffer[15] = __builtin_return_address(15); case 15: buffer[14] = __builtin_return_address(14); case 14: buffer[13] = __builtin_return_address(13); case 13: buffer[12] = __builtin_return_address(12); case 12: buffer[11] = __builtin_return_address(11); case 11: buffer[10] = __builtin_return_address(10); case 10: buffer[9] = __builtin_return_address(9); case 9: buffer[8] = __builtin_return_address(8); case 8: buffer[7] = __builtin_return_address(7); case 7: buffer[6] = __builtin_return_address(6); case 6: buffer[5] = __builtin_return_address(5); case 5: buffer[4] = __builtin_return_address(4); case 4: buffer[3] = __builtin_return_address(3); case 3: buffer[2] = __builtin_return_address(2); case 2: buffer[1] = __builtin_return_address(1); case 1: buffer[0] = __builtin_return_address(0); } return nframes; } #endif #if !defined(HAVE_BACKTRACE_SYMBOLS) # if defined(HAVE_BACKTRACE) && defined(HAVE_DLADDR) # define HAVE_BACKTRACE_SYMBOLS # define BACKTRACE_SYMBOLS_SIMPLE static char ** backtrace_symbols(void **buffer, int nframes) { Dl_info data[1]; int i; char **strings = malloc(nframes * sizeof(char*)); for (i = 0; i < nframes; i++) { if (dladdr(buffer[i], data)) { strings[i] = data->dli_sname; } else { strings[i] = "unknown"; } } return strings; } # endif /* HAVE_BACKTRACE && HAVE_DLADDR */ #endif /* !HAVE_BACKTRACE_SYMBOLS */ cl_object si_dump_c_backtrace(cl_object size) { cl_env_ptr the_env = ecl_process_env(); #ifdef HAVE_BACKTRACE_SYMBOLS { void *pointers[32]; int nframes = backtrace(pointers, 32); char **names = backtrace_symbols(pointers, nframes); int i; fprintf(stderr, "\n;;; ECL C Backtrace\n"); for (i = 0; i < nframes; i++) { #ifdef BACKTRACE_SYMBOLS_SIMPLE fprintf(stderr, ";;; %4d %s (%p) \n", i, names[i], pointers[i]); #else fprintf(stderr, ";;; %s\n", names[i]); #endif } fflush(stderr); free(names); } ecl_return1(the_env, ECL_T); #else ecl_return1(the_env, ECL_NIL); #endif } cl_object si_backtrace(cl_object start, cl_object end) { @(return ECL_NIL) } ecl-16.1.2/src/c/ffi/cdata.d000066400000000000000000000054541266352375300153660ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* cdata.d -- Data for compiled files. */ /* Copyright (c) 2011, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #include #include #define HEADER_PREFIX "eClDaTa20110719" #define HEADER_PREFIX_LENGTH 15 typedef struct { char code[16]; cl_index offset, size; } cdata_header; ecl_def_ct_base_string(str_no_data,"",0,static,const); cl_object si_get_cdata(cl_object filename) { cl_object map, array, displaced; cdata_header *header; map = si_mmap(3, filename, @':direction', @':input'); array = si_mmap_array(map); { char *v = (char*)array->base_string.self + array->base_string.dim - sizeof(cdata_header); header = (cdata_header*)v; } if (memcmp(header->code, HEADER_PREFIX, HEADER_PREFIX_LENGTH)) { displaced = str_no_data; } else { displaced = cl_funcall(8, @'make-array', ecl_make_fixnum(header->size), @':element-type', @'base-char', @':displaced-to', array, @':displaced-index-offset', ecl_make_fixnum(header->offset)); } @(return map displaced); } cl_object si_add_cdata(cl_object filename, cl_object data) { cl_object stream, offset; cdata_header header; data = si_copy_to_simple_base_string(data); stream = cl_open(9, filename, @':element-type', @'base-char', @':direction', @':output', @':if-does-not-exist', @':error', @':if-exists', @':append'); offset = ecl_file_length(stream); ecl_file_position_set(stream, offset); cl_write_sequence(2, data, stream); memcpy(header.code, HEADER_PREFIX, HEADER_PREFIX_LENGTH); header.offset = fixnnint(offset); header.size = data->base_string.dim; { unsigned char *c = (unsigned char *)&header; int i; for (i = 0; i < sizeof(header); i++) { ecl_write_byte(ecl_make_fixnum(c[i]), stream); } } cl_close(1, stream); @(return) } ecl-16.1.2/src/c/ffi/libraries.d000066400000000000000000000375761266352375300163000ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* load.d -- Shared library and bundle opening / copying / closing */ /* Copyright (c) 1990, Giuseppe Attardi and William F. Schelter. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include /* * Choosing the interface for loading binary files. Currently we recognize * three different methods: * - Windows API, provided by ECL_MS_WINDOWS_HOST * - dlopen, provided HAVE_DLFCN_H is defined * - NSLinkModule, provided HAVE_MACH_O_DYLD_H is defined * They are chosen in this precise order. In order to make the code for these * methods mutually exclusive, when one method is present, the other macros * get undefined. Handling of dynamically loaded libraries is constrained to * this file and thus the changes can be limited to this file. */ #ifdef ECL_MS_WINDOWS_HOST # ifdef HAVE_DLFCN_H # undef HAVE_DLFCN_H # endif # ifdef HAVE_MACH_O_DYLD_H # undef HAVE_MACH_O_DYLD_H # endif #endif #ifdef HAVE_DLFCN_H # ifdef HAVE_MACH_O_DYLD_H # undef HAVE_MACH_O_DYLD_H # endif #endif #ifdef ENABLE_DLOPEN # ifdef cygwin # include # include # endif # ifdef HAVE_DLFCN_H # include # define INIT_PREFIX "init_fas_" # ifdef bool # undef bool # endif # endif # ifdef HAVE_MACH_O_DYLD_H # include # define INIT_PREFIX "_init_fas_" # endif # ifdef HAVE_LINK_H # include # endif # if defined(ECL_MS_WINDOWS_HOST) # include # include # include # include # define INIT_PREFIX "init_fas_" # else # include # endif #endif /* ENABLE_DLOPEN */ #include #include #define GC_call_with_alloc_lock(f,arg) f(arg) cl_object ecl_make_codeblock() { cl_object block = ecl_alloc(t_codeblock); block = ecl_alloc_object(t_codeblock); block->cblock.self_destruct = 0; block->cblock.locked = 0; block->cblock.handle = NULL; block->cblock.data = NULL; block->cblock.data_size = 0; block->cblock.temp_data = NULL; block->cblock.temp_data_size = 0; block->cblock.data_text = NULL; block->cblock.next = ECL_NIL; block->cblock.name = ECL_NIL; block->cblock.links = ECL_NIL; block->cblock.cfuns_size = 0; block->cblock.cfuns = NULL; block->cblock.source = ECL_NIL; block->cblock.error = ECL_NIL; block->cblock.refs = ecl_make_fixnum(0); si_set_finalizer(block, ECL_T); return block; } static cl_object copy_object_file(cl_object original) { int err; cl_object copy = make_constant_base_string("TMP:ECL"); copy = si_coerce_to_filename(si_mkstemp(copy)); /* * We either have to make a full copy to convince the loader to load this object * file again, or we want to retain the possibility of overwriting the object * file we load later on (case of Windows, which locks files that are loaded). * The symlinks do not seem to work in latest versions of Linux. */ #if defined(ECL_MS_WINDOWS_HOST) ecl_disable_interrupts(); err = !CopyFile(original->base_string.self, copy->base_string.self, 0); ecl_enable_interrupts(); if (err) { FEwin32_error("Error when copying file from~&~3T~A~&to~&~3T~A", 2, original, copy); } #else err = Null(si_copy_file(original, copy)); if (err) { FEerror("Error when copying file from~&~3T~A~&to~&~3T~A", 2, original, copy); } #endif #ifdef cygwin { cl_object new_copy = make_constant_base_string(".dll"); new_copy = si_base_string_concatenate(2, copy, new_copy); cl_rename_file(2, copy, new_copy); copy = new_copy; } ecl_disable_interrupts(); err = chmod(copy->base_string.self, S_IRWXU) < 0; ecl_enable_interrupts(); if (err) { FElibc_error("Unable to give executable permissions to ~A", 1, copy); } #endif return copy; } #ifdef ENABLE_DLOPEN static void set_library_error(cl_object block) { cl_object output; ecl_disable_interrupts(); #ifdef HAVE_DLFCN_H output = make_base_string_copy(dlerror()); #endif #ifdef HAVE_MACH_O_DYLD_H { NSLinkEditErrors c; int number; const char *filename; NSLinkEditError(&c, &number, &filename, &message); output = make_base_string_copy(message); } #endif #if defined(ECL_MS_WINDOWS_HOST) { const char *message; FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ALLOCATE_BUFFER, 0, GetLastError(), 0, (void*)&message, 0, NULL); output = make_base_string_copy(message); LocalFree(message); } #endif ecl_enable_interrupts(); block->cblock.error = output; } static void dlopen_wrapper(cl_object block) { cl_object filename = block->cblock.name; char *filename_string = (char*)filename->base_string.self; #ifdef HAVE_DLFCN_H block->cblock.handle = dlopen(filename_string, RTLD_NOW|RTLD_GLOBAL); #endif #ifdef HAVE_MACH_O_DYLD_H { NSObjectFileImage file; static NSObjectFileImageReturnCode code; code = NSCreateObjectFileImageFromFile(filename_string, &file); if (code != NSObjectFileImageSuccess) { block->cblock.handle = NULL; } else { NSModule out = NSLinkModule(file, filename_string, NSLINKMODULE_OPTION_PRIVATE| NSLINKMODULE_OPTION_BINDNOW| NSLINKMODULE_OPTION_RETURN_ON_ERROR); block->cblock.handle = out; }} #endif #if defined(ECL_MS_WINDOWS_HOST) block->cblock.handle = LoadLibrary(filename_string); #endif if (block->cblock.handle == NULL) set_library_error(block); } static int dlclose_wrapper(cl_object block) { if (block->cblock.handle != NULL) { #ifdef HAVE_DLFCN_H dlclose(block->cblock.handle); #endif #ifdef HAVE_MACH_O_DYLD_H NSUnLinkModule(block->cblock.handle, NSUNLINKMODULE_OPTION_NONE); #endif #if defined(ECL_MS_WINDOWS_HOST) FreeLibrary(block->cblock.handle); #endif block->cblock.handle = NULL; return TRUE; } return FALSE; } static cl_object ecl_library_find_by_name(cl_object filename) { cl_object l; for (l = cl_core.libraries; l != ECL_NIL; l = ECL_CONS_CDR(l)) { cl_object other = ECL_CONS_CAR(l); cl_object name = other->cblock.name; if (!Null(name) && ecl_string_eq(name, filename)) { return other; } } return ECL_NIL; } static cl_object ecl_library_find_by_handle(void *handle) { cl_object l; for (l = cl_core.libraries; l != ECL_NIL; l = ECL_CONS_CDR(l)) { cl_object other = ECL_CONS_CAR(l); if (handle == other->cblock.handle) { return other; } } return ECL_NIL; } static cl_object ecl_library_open_inner(cl_object filename, bool self_destruct) { const cl_env_ptr the_env = ecl_process_env(); cl_object block = ecl_make_codeblock(); block->cblock.self_destruct = self_destruct; block->cblock.name = filename; block->cblock.refs = ecl_make_fixnum(1); ECL_WITH_GLOBAL_LOCK_BEGIN(the_env) { ecl_disable_interrupts(); GC_call_with_alloc_lock(dlopen_wrapper, block); if (block->cblock.handle != NULL) { /* Have we already loaded this library? If so, then unload this * copy and increase the reference counter so that we can keep * track (in lisp) of how many copies we use. */ cl_object other = ecl_library_find_by_handle(block->cblock.handle); if (other != ECL_NIL) { GC_call_with_alloc_lock(dlclose_wrapper, block); block = other; block->cblock.refs = ecl_one_plus(block->cblock.refs); } else { si_set_finalizer(block, ECL_T); cl_core.libraries = CONS(block, cl_core.libraries); } } ecl_enable_interrupts(); } ECL_WITH_GLOBAL_LOCK_END; return block; } cl_object ecl_library_open(cl_object filename, bool force_reload) { cl_object block; bool self_destruct = 0; char *filename_string; /* Coerces to a file name but does not merge with cwd */ filename = coerce_to_physical_pathname(filename); filename = ecl_namestring(filename, ECL_NAMESTRING_TRUNCATE_IF_ERROR | ECL_NAMESTRING_FORCE_BASE_STRING); if (!force_reload) { /* When loading a foreign library, such as a dll or a * so, it cannot contain any executable top level * code. In that case force_reload=0 and there is no * need to reload it if it has already been loaded. */ block = ecl_library_find_by_name(filename); if (!Null(block)) { return block; } } else { /* We are using shared libraries as modules and * force_reload=1. Here we have to face the problem * that many operating systems do not allow to load a * shared library twice, even if it has changed. Hence * we have to make a unique copy to be able to load * the same FASL twice. In Windows this copy is * _always_ made because otherwise it cannot be * overwritten. In Unix we need only do that when the * file has been previously loaded. */ #if defined(ECL_MS_WINDOWS_HOST) || defined(cygwin) filename = copy_object_file(filename); self_destruct = 1; #else block = ecl_library_find_by_name(filename); if (!Null(block)) { filename = copy_object_file(filename); self_destruct = 1; } #endif } DO_LOAD: block = ecl_library_open_inner(filename, self_destruct); /* * A second pass to ensure that the dlopen routine has not * returned a library that we had already loaded. If this is * the case, we close the new copy to ensure we do refcounting * right. */ if (block->cblock.refs != ecl_make_fixnum(1)) { if (force_reload) { ecl_library_close(block); filename = copy_object_file(filename); self_destruct = 1; goto DO_LOAD; } } return block; } void * ecl_library_symbol(cl_object block, const char *symbol, bool lock) { void *p; if (block == @':default') { cl_object l; for (l = cl_core.libraries; l != ECL_NIL; l = ECL_CONS_CDR(l)) { cl_object block = ECL_CONS_CAR(l); p = ecl_library_symbol(block, symbol, lock); if (p) return p; } ecl_disable_interrupts(); #if defined(ECL_MS_WINDOWS_HOST) { HANDLE hndSnap = NULL; HANDLE hnd = NULL; hndSnap = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, GetCurrentProcessId()); if (hndSnap != INVALID_HANDLE_VALUE) { MODULEENTRY32 me32; me32.dwSize = sizeof(MODULEENTRY32); if (Module32First(hndSnap, &me32)) { do hnd = GetProcAddress(me32.hModule, symbol); while (hnd == NULL && Module32Next(hndSnap, &me32)); } CloseHandle(hndSnap); } p = (void*)hnd; } #endif #ifdef HAVE_DLFCN_H p = dlsym(0, symbol); #endif #if !defined(ECL_MS_WINDOWS_HOST) && !defined(HAVE_DLFCN_H) p = 0; #endif ecl_enable_interrupts(); } else { ecl_disable_interrupts(); #ifdef HAVE_DLFCN_H p = dlsym(block->cblock.handle, symbol); #endif #if defined(ECL_MS_WINDOWS_HOST) { HMODULE h = (HMODULE)(block->cblock.handle); p = GetProcAddress(h, symbol); } #endif #ifdef HAVE_MACH_O_DYLD_H NSSymbol sym; sym = NSLookupSymbolInModule((NSModule)(block->cblock.handle), symbol); if (sym == 0) { p = 0; } else { p = NSAddressOfSymbol(sym); } #endif ecl_enable_interrupts(); /* Libraries whose symbols are being referenced by the FFI should not * get garbage collected. Until we find a better solution we simply lock * them for the rest of the runtime */ if (p) { block->cblock.locked |= lock; } } if (!p) set_library_error(block); return p; } cl_object ecl_library_error(cl_object block) { return block->cblock.error; } bool ecl_library_close(cl_object block) { const cl_env_ptr the_env = ecl_process_env(); bool success = TRUE; ECL_WITH_GLOBAL_LOCK_BEGIN(the_env) { ecl_disable_interrupts(); /* is it ever a case? no matter how many times i call load-foreign-module it seems that block->cblock.refs = 1 */ if (block->cblock.refs > ecl_make_fixnum(1)) { block->cblock.refs = ecl_one_minus(block->cblock.refs); block = ECL_NIL; } else if (block->cblock.handle != NULL) { success = GC_call_with_alloc_lock(dlclose_wrapper, block); cl_core.libraries = ecl_remove_eq(block, cl_core.libraries); } else { /* block not loaded */ success = FALSE; } ecl_enable_interrupts(); } ECL_WITH_GLOBAL_LOCK_END; if (block != ECL_NIL && block->cblock.self_destruct) { if (!Null(block->cblock.name)) { unlink((char*)block->cblock.name->base_string.self); } } return success; } void ecl_library_close_all(void) { while (cl_core.libraries != ECL_NIL) { ecl_library_close(ECL_CONS_CAR(cl_core.libraries)); } } ecl_def_ct_base_string(init_prefix, INIT_PREFIX, sizeof(INIT_PREFIX)-1, static, const); cl_object _ecl_library_init_prefix(void) { return init_prefix; } ecl_def_ct_base_string(default_entry, INIT_PREFIX "CODE", sizeof(INIT_PREFIX "CODE")-1, static, const); cl_object _ecl_library_default_entry(void) { return default_entry; } #endif /* ENABLE_DLOPEN */ ecl-16.1.2/src/c/ffi/mmap.d000066400000000000000000000107761266352375300152470ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* mmap.d -- Mapping of binary files. */ /* Copyright (c) 2011, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #ifdef HAVE_SYS_MMAN_H # include #endif #include #include @(defun ext::mmap (filename &key (length ECL_NIL) (offset ecl_make_fixnum(0)) (direction @':input') (element_type @'base-char') (if_exists @':new-version') (if_does_not_exist @':error') (external_format @':default')) @ #ifdef HAVE_SYS_MMAN_H { cl_object output, stream; int c_prot, c_flags, fd; size_t len; void *pa; if (direction == @':input') c_prot = PROT_READ; else if (direction == @':output') c_prot = PROT_WRITE; else if (direction == @':io') c_prot = PROT_READ | PROT_WRITE; else c_prot = PROT_NONE; if (Null(filename)) { c_flags = MAP_ANON | MAP_PRIVATE; fd = -1; len = ecl_to_unsigned_integer(length); stream = ECL_NIL; } else { c_flags = MAP_SHARED; stream = cl_open(13, filename, @':direction', direction, @':element-type', element_type, @':if-exists', if_exists, @':if-does-not-exist', if_does_not_exist, @':external-format', @':default', @':cstream', ECL_NIL); fd = ecl_to_int(si_file_stream_fd(stream)); if (Null(length)) len = ecl_to_unsigned_integer(ecl_file_length(stream)); else len = ecl_to_unsigned_integer(length); } output = si_make_vector(element_type, ecl_make_fixnum(0), ECL_NIL, ECL_NIL, ECL_NIL, ECL_NIL); pa = mmap(0, len, c_prot, c_flags, fd, ecl_integer_to_off_t(offset)); if (pa == MAP_FAILED) { FElibc_error("EXT::MMAP failed.", 0); } else { output->base_string.self = pa; output->base_string.dim = output->base_string.fillp = len; } @(return CONS(output, stream)) } #else { cl_object output, vector; if (Null(filename)) { output = si_make_vector(element_type, length, ECL_NIL, ECL_NIL, ECL_NIL, ECL_NIL); } else { cl_object stream = cl_open(13, filename, @':direction', direction, @':element-type', element_type, @':if-exists', if_exists, @':if-does-not-exist', if_does_not_exist, @':external-format', @':pass-through', @':cstream', ECL_T); if (Null(length)) length = ecl_file_length(stream); else length = ecl_to_unsigned_integer(length); output = si_make_vector(element_type, length, ECL_NIL, ECL_NIL, ECL_NIL, ECL_NIL); cl_read_sequence(2, output, stream); cl_close(1, stream); } @(return output) } #endif @) cl_object si_mmap_array(cl_object map) { #ifdef HAVE_SYS_MMAN_H @(return cl_car(map)); #else @(return map); #endif } cl_object si_munmap(cl_object map) { #ifdef HAVE_SYS_MMAN_H cl_object array = cl_car(map); cl_object stream = cl_cdr(map); int code = munmap(array->base_string.self, array->base_string.dim); if (code < 0) { FElibc_error("Error when unmapping file.", 0); } cl_close(1, stream); #endif @(return ECL_NIL) } ecl-16.1.2/src/c/file.d000077500000000000000000005267741266352375300145050ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* file.d -- File interface. */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ /* IMPLEMENTATION-DEPENDENT The file contains code to reclaim the I/O buffer by accessing the FILE structure of C. */ #include #include #ifndef _MSC_VER # include #endif #include #if !defined(_MSC_VER) && !defined(__MINGW32__) # include /* it isn't pulled in by fcntl.h */ #endif #include #include #include #include #define ECL_DEFINE_AET_SIZE #include #ifdef HAVE_SELECT # ifdef HAVE_SYS_SELECT_H # include # endif # include # include # include #elif defined(ECL_MS_WINDOWS_HOST) # include # include # include # define STDIN_FILENO 0 # define STDOUT_FILENO 1 # define STDERR_FILENO 2 # define HAVE_SELECT #elif defined(HAVE_SYS_IOCTL_H) && !defined(MSDOS) && !defined(cygwin) # include #endif /* Maximum number of bytes required to encode a character. * This currently corresponds to (4 + 2) for the ISO-2022-JP-* encodings * with 4 being the charset prefix, 2 for the character. */ #define ENCODING_BUFFER_MAX_SIZE 6 static cl_index ecl_read_byte8(cl_object stream, unsigned char *c, cl_index n); static cl_index ecl_write_byte8(cl_object stream, unsigned char *c, cl_index n); struct ecl_file_ops *duplicate_dispatch_table(const struct ecl_file_ops *ops); const struct ecl_file_ops *stream_dispatch_table(cl_object strm); static int flisten(cl_object, FILE *); static int file_listen(cl_object, int); static cl_object alloc_stream(); static void cannot_close(cl_object stream) ecl_attr_noreturn; static void file_libc_error(cl_object error_type, cl_object stream, const char *msg, int narg, ...) ecl_attr_noreturn; static cl_object not_a_file_stream(cl_object fn) ecl_attr_noreturn; static void not_an_input_stream(cl_object fn) ecl_attr_noreturn; static void not_an_output_stream(cl_object fn) ecl_attr_noreturn; static void not_a_character_stream(cl_object s) ecl_attr_noreturn; static void not_a_binary_stream(cl_object s) ecl_attr_noreturn; static int restartable_io_error(cl_object strm, const char *s); static void unread_error(cl_object strm); static void unread_twice(cl_object strm); static void io_error(cl_object strm) ecl_attr_noreturn; #ifdef ECL_UNICODE static cl_index encoding_error(cl_object strm, unsigned char *buffer, ecl_character c); static ecl_character decoding_error(cl_object strm, unsigned char *buffer, int length); #endif static void wrong_file_handler(cl_object strm) ecl_attr_noreturn; #if defined(ECL_WSOCK) static void wsock_error( const char *err_msg, cl_object strm ) ecl_attr_noreturn; #endif /********************************************************************** * NOT IMPLEMENTED or NOT APPLICABLE OPERATIONS */ static cl_index not_output_write_byte8(cl_object strm, unsigned char *c, cl_index n) { not_an_output_stream(strm); return 0; } static cl_index not_input_read_byte8(cl_object strm, unsigned char *c, cl_index n) { not_an_input_stream(strm); return 0; } static cl_index not_binary_read_byte8(cl_object strm, unsigned char *c, cl_index n) { not_a_binary_stream(strm); return 0; } static void not_output_write_byte(cl_object c, cl_object strm) { not_an_output_stream(strm); } static cl_object not_input_read_byte(cl_object strm) { not_an_input_stream(strm); return OBJNULL; } static void not_binary_write_byte(cl_object c, cl_object strm) { not_a_binary_stream(strm); } static cl_object not_binary_read_byte(cl_object strm) { not_a_binary_stream(strm); return OBJNULL; } static ecl_character not_input_read_char(cl_object strm) { not_an_input_stream(strm); return -1; } static ecl_character not_output_write_char(cl_object strm, ecl_character c) { not_an_output_stream(strm); return c; } static void not_input_unread_char(cl_object strm, ecl_character c) { not_an_input_stream(strm); } static int not_input_listen(cl_object strm) { not_an_input_stream(strm); return -1; } static ecl_character not_character_read_char(cl_object strm) { not_a_character_stream(strm); return -1; } static ecl_character not_character_write_char(cl_object strm, ecl_character c) { not_a_character_stream(strm); return c; } static void not_input_clear_input(cl_object strm) { not_an_input_stream(strm); return; } static void not_output_clear_output(cl_object strm) { not_an_output_stream(strm); } static void not_output_force_output(cl_object strm) { not_an_output_stream(strm); } static void not_output_finish_output(cl_object strm) { not_an_output_stream(strm); } #if defined(ECL_WSOCK) static cl_object not_implemented_get_position(cl_object strm) { FEerror("file-position not implemented for stream ~S", 1, strm); return ECL_NIL; } static cl_object not_implemented_set_position(cl_object strm, cl_object pos) { FEerror("file-position not implemented for stream ~S", 1, strm); return ECL_NIL; } #endif /********************************************************************** * CLOSED STREAM OPS */ static cl_index closed_stream_read_byte8(cl_object strm, unsigned char *c, cl_index n) { FEclosed_stream(strm); return 0; } static cl_index closed_stream_write_byte8(cl_object strm, unsigned char *c, cl_index n) { FEclosed_stream(strm); return 0; } static ecl_character closed_stream_read_char(cl_object strm) { FEclosed_stream(strm); return 0; } static ecl_character closed_stream_write_char(cl_object strm, ecl_character c) { FEclosed_stream(strm); return c; } static void closed_stream_unread_char(cl_object strm, ecl_character c) { FEclosed_stream(strm); } static int closed_stream_listen(cl_object strm) { FEclosed_stream(strm); return 0; } static void closed_stream_clear_input(cl_object strm) { FEclosed_stream(strm); } #define closed_stream_clear_output closed_stream_clear_input #define closed_stream_force_output closed_stream_clear_input #define closed_stream_finish_output closed_stream_clear_input static cl_object closed_stream_length(cl_object strm) { FEclosed_stream(strm); } #define closed_stream_get_position closed_stream_length static cl_object closed_stream_set_position(cl_object strm, cl_object position) { FEclosed_stream(strm); } /********************************************************************** * GENERIC OPERATIONS * * Versions of the methods which are defined in terms of others */ /* * Byte operations based on octet operators. */ static cl_object generic_read_byte_unsigned8(cl_object strm) { unsigned char c; if (strm->stream.ops->read_byte8(strm, &c, 1) < 1) { return ECL_NIL; } return ecl_make_fixnum(c); } static void generic_write_byte_unsigned8(cl_object byte, cl_object strm) { unsigned char c = ecl_to_uint8_t(byte); strm->stream.ops->write_byte8(strm, &c, 1); } static cl_object generic_read_byte_signed8(cl_object strm) { signed char c; if (strm->stream.ops->read_byte8(strm, (unsigned char *)&c, 1) < 1) return ECL_NIL; return ecl_make_fixnum(c); } static void generic_write_byte_signed8(cl_object byte, cl_object strm) { signed char c = fixint(byte); strm->stream.ops->write_byte8(strm, (unsigned char *)&c, 1); } static cl_object generic_read_byte_le(cl_object strm) { cl_index (*read_byte8)(cl_object, unsigned char *, cl_index); unsigned char c; cl_index nb, bs; cl_object output = ecl_make_fixnum(0); read_byte8 = strm->stream.ops->read_byte8; bs = strm->stream.byte_size; for (nb = 0; bs >= 8; bs -= 8, nb += 8) { cl_object aux; if (read_byte8(strm, &c, 1) < 1) return ECL_NIL; if (bs <= 8 && (strm->stream.flags & ECL_STREAM_SIGNED_BYTES)) aux = ecl_make_fixnum((signed char)c); else aux = ecl_make_fixnum((unsigned char)c); output = cl_logior(2, output, cl_ash(aux, ecl_make_fixnum(nb))); } return output; } static void generic_write_byte_le(cl_object c, cl_object strm) { cl_index (*write_byte8)(cl_object strm, unsigned char *c, cl_index n); cl_index bs; write_byte8 = strm->stream.ops->write_byte8; bs = strm->stream.byte_size; do { cl_object b = cl_logand(2, c, ecl_make_fixnum(0xFF)); unsigned char aux = (unsigned char)ecl_fixnum(b); if (write_byte8(strm, &aux, 1) < 1) break; c = cl_ash(c, ecl_make_fixnum(-8)); bs -= 8; } while (bs); } static cl_object generic_read_byte(cl_object strm) { cl_index (*read_byte8)(cl_object, unsigned char *, cl_index); unsigned char c; cl_object output = NULL; cl_index bs; read_byte8 = strm->stream.ops->read_byte8; bs = strm->stream.byte_size; for (; bs >= 8; bs -= 8) { if (read_byte8(strm, &c, 1) < 1) return ECL_NIL; if (output) { output = cl_logior(2, ecl_make_fixnum(c), cl_ash(output, ecl_make_fixnum(8))); } else if (strm->stream.flags & ECL_STREAM_SIGNED_BYTES) { output = ecl_make_fixnum((signed char)c); } else { output = ecl_make_fixnum((unsigned char)c); } } return output; } static void generic_write_byte(cl_object c, cl_object strm) { cl_index (*write_byte8)(cl_object strm, unsigned char *c, cl_index n); cl_index bs; write_byte8 = strm->stream.ops->write_byte8; bs = strm->stream.byte_size; do { unsigned char aux; cl_object b; bs -= 8; b = cl_logand(2, ecl_make_fixnum(0xFF), bs? cl_ash(c, ecl_make_fixnum(-bs)) : c); aux = (unsigned char)ecl_fixnum(b); if (write_byte8(strm, &aux, 1) < 1) break; } while (bs); } static ecl_character generic_peek_char(cl_object strm) { ecl_character out = ecl_read_char(strm); if (out != EOF) ecl_unread_char(out, strm); return out; } static void generic_void(cl_object strm) { } static int generic_always_true(cl_object strm) { return 1; } static int generic_always_false(cl_object strm) { return 0; } static cl_object generic_always_nil(cl_object strm) { return ECL_NIL; } static int generic_column(cl_object strm) { return 0; } static cl_object generic_set_position(cl_object strm, cl_object pos) { return ECL_NIL; } static cl_object generic_close(cl_object strm) { struct ecl_file_ops *ops = strm->stream.ops; if (ecl_input_stream_p(strm)) { ops->read_byte8 = closed_stream_read_byte8; ops->read_char = closed_stream_read_char; ops->unread_char = closed_stream_unread_char; ops->listen = closed_stream_listen; ops->clear_input = closed_stream_clear_input; } if (ecl_output_stream_p(strm)) { ops->write_byte8 = closed_stream_write_byte8; ops->write_char = closed_stream_write_char; ops->clear_output = closed_stream_clear_output; ops->force_output = closed_stream_force_output; ops->finish_output = closed_stream_finish_output; } ops->get_position = closed_stream_get_position; ops->set_position = closed_stream_set_position; ops->length = closed_stream_length; ops->close = generic_close; strm->stream.closed = 1; return ECL_T; } static cl_index generic_write_vector(cl_object strm, cl_object data, cl_index start, cl_index end) { cl_elttype elttype; const struct ecl_file_ops *ops; if (start >= end) return start; ops = stream_dispatch_table(strm); elttype = ecl_array_elttype(data); if (elttype == ecl_aet_bc || #ifdef ECL_UNICODE elttype == ecl_aet_ch || #endif (elttype == ecl_aet_object && ECL_CHARACTERP(ecl_elt(data, 0)))) { ecl_character (*write_char)(cl_object, ecl_character) = ops->write_char; for (; start < end; start++) { write_char(strm, ecl_char_code(ecl_elt(data, start))); } } else { void (*write_byte)(cl_object, cl_object) = ops->write_byte; for (; start < end; start++) { write_byte(ecl_elt(data, start), strm); } } return start; } static cl_index generic_read_vector(cl_object strm, cl_object data, cl_index start, cl_index end) { const struct ecl_file_ops *ops; cl_object expected_type; if (start >= end) return start; expected_type = ecl_stream_element_type(strm); ops = stream_dispatch_table(strm); if (expected_type == @'base-char' || expected_type == @'character') { ecl_character (*read_char)(cl_object) = ops->read_char; for (; start < end; start++) { cl_fixnum c = read_char(strm); if (c == EOF) break; ecl_elt_set(data, start, ECL_CODE_CHAR(c)); } } else { cl_object (*read_byte)(cl_object) = ops->read_byte; for (; start < end; start++) { cl_object x = read_byte(strm); if (Null(x)) break; ecl_elt_set(data, start, x); } } return start; } /********************************************************************** * CHARACTER AND EXTERNAL FORMAT SUPPORT */ static void eformat_unread_char(cl_object strm, ecl_character c) { unlikely_if (c != strm->stream.last_char) { unread_twice(strm); } { unsigned char buffer[2*ENCODING_BUFFER_MAX_SIZE]; int ndx = 0; cl_object l = strm->stream.byte_stack; cl_fixnum i = strm->stream.last_code[0]; if (i != EOF) { ndx += strm->stream.encoder(strm, buffer, i); } i = strm->stream.last_code[1]; if (i != EOF) { ndx += strm->stream.encoder(strm, buffer+ndx, i); } while (ndx != 0) { l = CONS(ecl_make_fixnum(buffer[--ndx]), l); } strm->stream.byte_stack = l; strm->stream.last_char = EOF; } } static ecl_character eformat_read_char(cl_object strm) { ecl_character c = strm->stream.decoder(strm); unlikely_if (c == strm->stream.eof_char) return EOF; if (c != EOF) { strm->stream.last_char = c; strm->stream.last_code[0] = c; strm->stream.last_code[1] = EOF; } return c; } static ecl_character eformat_write_char(cl_object strm, ecl_character c) { unsigned char buffer[ENCODING_BUFFER_MAX_SIZE]; ecl_character nbytes; nbytes = strm->stream.encoder(strm, buffer, c); strm->stream.ops->write_byte8(strm, buffer, nbytes); if (c == '\n') strm->stream.column = 0; else if (c == '\t') strm->stream.column = (strm->stream.column & ~((cl_index)07)) + 8; else strm->stream.column++; fflush(stdout); return c; } static ecl_character eformat_read_char_cr(cl_object strm) { ecl_character c = eformat_read_char(strm); if (c == ECL_CHAR_CODE_RETURN) { c = ECL_CHAR_CODE_NEWLINE; strm->stream.last_char = c; } return c; } static ecl_character eformat_write_char_cr(cl_object strm, ecl_character c) { if (c == ECL_CHAR_CODE_NEWLINE) { eformat_write_char(strm, ECL_CHAR_CODE_RETURN); strm->stream.column = 0; return c; } return eformat_write_char(strm, c); } static ecl_character eformat_read_char_crlf(cl_object strm) { ecl_character c = eformat_read_char(strm); if (c == ECL_CHAR_CODE_RETURN) { c = eformat_read_char(strm); if (c == ECL_CHAR_CODE_LINEFEED) { strm->stream.last_code[0] = ECL_CHAR_CODE_RETURN; strm->stream.last_code[1] = c; c = ECL_CHAR_CODE_NEWLINE; } else { eformat_unread_char(strm, c); c = ECL_CHAR_CODE_RETURN; strm->stream.last_code[0] = c; strm->stream.last_code[1] = EOF; } strm->stream.last_char = c; } return c; } static ecl_character eformat_write_char_crlf(cl_object strm, ecl_character c) { if (c == ECL_CHAR_CODE_NEWLINE) { eformat_write_char(strm, ECL_CHAR_CODE_RETURN); eformat_write_char(strm, ECL_CHAR_CODE_LINEFEED); strm->stream.column = 0; return c; } return eformat_write_char(strm, c); } /* * If we use Unicode, this is LATIN-1, ISO-8859-1, that is the 256 * lowest codes of Unicode. Otherwise, we simply assume the file and * the strings use the same format. */ static ecl_character passthrough_decoder(cl_object stream) { unsigned char aux; if (ecl_read_byte8(stream, &aux, 1) < 1) return EOF; else return aux; } static int passthrough_encoder(cl_object stream, unsigned char *buffer, ecl_character c) { #ifdef ECL_UNICODE unlikely_if (c > 0xFF) { return encoding_error(stream, buffer, c); } #endif buffer[0] = c; return 1; } #ifdef ECL_UNICODE /* * US ASCII, that is the 128 (0-127) lowest codes of Unicode */ static ecl_character ascii_decoder(cl_object stream) { unsigned char aux; if (ecl_read_byte8(stream, &aux, 1) < 1) { return EOF; } else if (aux > 127) { return decoding_error(stream, &aux, 1); } else { return aux; } } static int ascii_encoder(cl_object stream, unsigned char *buffer, ecl_character c) { unlikely_if (c > 127) { return encoding_error(stream, buffer, c); } buffer[0] = c; return 1; } /* * UCS-4 BIG ENDIAN */ static ecl_character ucs_4be_decoder(cl_object stream) { unsigned char buffer[4]; if (ecl_read_byte8(stream, buffer, 4) < 4) { return EOF; } else { return buffer[3]+(buffer[2]<<8)+(buffer[1]<<16)+(buffer[0]<<24); } } static int ucs_4be_encoder(cl_object stream, unsigned char *buffer, ecl_character c) { buffer[3] = c & 0xFF; c >>= 8; buffer[2] = c & 0xFF; c >>= 8; buffer[1] = c & 0xFF; c >>= 8; buffer[0] = c; return 4; } /* * UCS-4 LITTLE ENDIAN */ static ecl_character ucs_4le_decoder(cl_object stream) { unsigned char buffer[4]; if (ecl_read_byte8(stream, buffer, 4) < 4) { return EOF; } else { return buffer[0]+(buffer[1]<<8)+(buffer[2]<<16)+(buffer[3]<<24); } } static int ucs_4le_encoder(cl_object stream, unsigned char *buffer, ecl_character c) { buffer[0] = c & 0xFF; c >>= 8; buffer[1] = c & 0xFF; c >>= 8; buffer[2] = c & 0xFF; c >>= 8; buffer[3] = c; return 4; } /* * UCS-4 BOM ENDIAN */ static ecl_character ucs_4_decoder(cl_object stream) { cl_fixnum c = ucs_4be_decoder(stream); if (c == 0xFEFF) { stream->stream.decoder = ucs_4be_decoder; stream->stream.encoder = ucs_4be_encoder; return ucs_4be_decoder(stream); } else if (c == 0xFFFE0000) { stream->stream.decoder = ucs_4le_decoder; stream->stream.encoder = ucs_4le_encoder; return ucs_4le_decoder(stream); } else { stream->stream.decoder = ucs_4be_decoder; stream->stream.encoder = ucs_4be_encoder; return c; } } static int ucs_4_encoder(cl_object stream, unsigned char *buffer, ecl_character c) { stream->stream.decoder = ucs_4be_decoder; stream->stream.encoder = ucs_4be_encoder; buffer[0] = 0xFF; buffer[1] = 0xFE; buffer[2] = buffer[3] = 0; return 4 + ucs_4be_encoder(stream, buffer+4, c); } /* * UTF-16 BIG ENDIAN */ static ecl_character ucs_2be_decoder(cl_object stream) { unsigned char buffer[2] = {0,0}; if (ecl_read_byte8(stream, buffer, 2) < 2) { return EOF; } else { ecl_character c = ((ecl_character)buffer[0] << 8) | buffer[1]; if ((buffer[0] & 0xFC) == 0xD8) { if (ecl_read_byte8(stream, buffer, 2) < 2) { return EOF; } else { ecl_character aux; if ((buffer[1] & 0xFC) != 0xDC) { return decoding_error(stream, buffer, 1); } aux = ((ecl_character)buffer[0] << 8) | buffer[1]; return ((c & 0x3FFF) << 10) + (aux & 0x3FFF) + 0x10000; } } return c; } } static int ucs_2be_encoder(cl_object stream, unsigned char *buffer, ecl_character c) { if (c >= 0x10000) { c -= 0x10000; ucs_2be_encoder(stream, buffer, (c >> 10) | 0xD800); ucs_2be_encoder(stream, buffer+2, (c & 0x3FFF) | 0xDC00); return 4; } else { buffer[1] = c & 0xFF; c >>= 8; buffer[0] = c; return 2; } } /* * UTF-16 LITTLE ENDIAN */ static ecl_character ucs_2le_decoder(cl_object stream) { unsigned char buffer[2]; if (ecl_read_byte8(stream, buffer, 2) < 2) { return EOF; } else { ecl_character c = ((ecl_character)buffer[1] << 8) | buffer[0]; if ((buffer[1] & 0xFC) == 0xD8) { if (ecl_read_byte8(stream, buffer, 2) < 2) { return EOF; } else { ecl_character aux; if ((buffer[1] & 0xFC) != 0xDC) { return decoding_error(stream, buffer, 2); } aux = ((ecl_character)buffer[1] << 8) | buffer[0]; return ((c & 0x3FFF) << 10) + (aux & 0x3FFF) + 0x10000; } } return c; } } static int ucs_2le_encoder(cl_object stream, unsigned char *buffer, ecl_character c) { if (c >= 0x10000) { c -= 0x10000; ucs_2le_encoder(stream, buffer, (c >> 10) | 0xD8000); ucs_2le_encoder(stream, buffer+2, (c & 0x3FFF) | 0xD800); return 4; } else { buffer[0] = c & 0xFF; c >>= 8; buffer[1] = c & 0xFF; return 2; } } /* * UTF-16 BOM ENDIAN */ static ecl_character ucs_2_decoder(cl_object stream) { ecl_character c = ucs_2be_decoder(stream); if (c == 0xFEFF) { stream->stream.decoder = ucs_2be_decoder; stream->stream.encoder = ucs_2be_encoder; return ucs_2be_decoder(stream); } else if (c == 0xFFFE) { stream->stream.decoder = ucs_2le_decoder; stream->stream.encoder = ucs_2le_encoder; return ucs_2le_decoder(stream); } else { stream->stream.decoder = ucs_2be_decoder; stream->stream.encoder = ucs_2be_encoder; return c; } } static int ucs_2_encoder(cl_object stream, unsigned char *buffer, ecl_character c) { stream->stream.decoder = ucs_2be_decoder; stream->stream.encoder = ucs_2be_encoder; buffer[0] = 0xFF; buffer[1] = 0xFE; return 2 + ucs_2be_encoder(stream, buffer+2, c); } /* * USER DEFINED ENCODINGS. SIMPLE CASE. */ static ecl_character user_decoder(cl_object stream) { cl_object table = stream->stream.format_table; cl_object character; unsigned char buffer[2]; if (ecl_read_byte8(stream, buffer, 1) < 1) { return EOF; } character = ecl_gethash_safe(ecl_make_fixnum(buffer[0]), table, ECL_NIL); unlikely_if (Null(character)) { return decoding_error(stream, buffer, 1); } if (character == ECL_T) { if (ecl_read_byte8(stream, buffer+1, 1) < 1) { return EOF; } else { cl_fixnum byte = (buffer[0]<<8) + buffer[1]; character = ecl_gethash_safe(ecl_make_fixnum(byte), table, ECL_NIL); unlikely_if (Null(character)) { return decoding_error(stream, buffer, 2); } } } return ECL_CHAR_CODE(character); } static int user_encoder(cl_object stream, unsigned char *buffer, ecl_character c) { cl_object byte = ecl_gethash_safe(ECL_CODE_CHAR(c), stream->stream.format_table, ECL_NIL); if (Null(byte)) { return encoding_error(stream, buffer, c); } else { cl_fixnum code = ecl_fixnum(byte); if (code > 0xFF) { buffer[1] = code & 0xFF; code >>= 8; buffer[0] = code; return 2; } else { buffer[0] = code; return 1; } } } /* * USER DEFINED ENCODINGS. SIMPLE CASE. */ static ecl_character user_multistate_decoder(cl_object stream) { cl_object table_list = stream->stream.format_table; cl_object table = ECL_CONS_CAR(table_list); cl_object character; cl_fixnum i, j; unsigned char buffer[ENCODING_BUFFER_MAX_SIZE]; for (i = j = 0; i < ENCODING_BUFFER_MAX_SIZE; i++) { if (ecl_read_byte8(stream, buffer+i, 1) < 1) { return EOF; } j = (j << 8) | buffer[i]; character = ecl_gethash_safe(ecl_make_fixnum(j), table, ECL_NIL); if (ECL_CHARACTERP(character)) { return ECL_CHAR_CODE(character); } unlikely_if (Null(character)) { return decoding_error(stream, buffer, i); } if (character == ECL_T) { /* Need more characters */ continue; } if (CONSP(character)) { /* Changed the state. */ stream->stream.format_table = table_list = character; table = ECL_CONS_CAR(table_list); i = j = 0; continue; } break; } FEerror("Internal error in decoder table.", 0); } static int user_multistate_encoder(cl_object stream, unsigned char *buffer, ecl_character c) { cl_object table_list = stream->stream.format_table; cl_object p = table_list; do { cl_object table = ECL_CONS_CAR(p); cl_object byte = ecl_gethash_safe(ECL_CODE_CHAR(c), table, ECL_NIL); if (!Null(byte)) { cl_fixnum code = ecl_fixnum(byte); ecl_character n = 0; if (p != table_list) { /* Must output a escape sequence */ cl_object x = ecl_gethash_safe(ECL_T, table, ECL_NIL); while (!Null(x)) { buffer[0] = ecl_fixnum(ECL_CONS_CAR(x)); buffer++; x = ECL_CONS_CDR(x); n++; } stream->stream.format_table = p; } if (code > 0xFF) { buffer[1] = code & 0xFF; code >>= 8; buffer[0] = code; return n+2; } else { buffer[0] = code; return n+1; } } p = ECL_CONS_CDR(p); } while (p != table_list); /* Exhausted all lists */ return encoding_error(stream, buffer, c); } /* * UTF-8 */ static ecl_character utf_8_decoder(cl_object stream) { /* In understanding this code: * 0x8 = 1000, 0xC = 1100, 0xE = 1110, 0xF = 1111 * 0x1 = 0001, 0x3 = 0011, 0x7 = 0111, 0xF = 1111 */ ecl_character cum = 0; unsigned char buffer[5]; int nbytes, i; if (ecl_read_byte8(stream, buffer, 1) < 1) return EOF; if ((buffer[0] & 0x80) == 0) { return buffer[0]; } unlikely_if ((buffer[0] & 0x40) == 0) return decoding_error(stream, buffer, 1); if ((buffer[0] & 0x20) == 0) { cum = buffer[0] & 0x1F; nbytes = 1; } else if ((buffer[0] & 0x10) == 0) { cum = buffer[0] & 0x0F; nbytes = 2; } else if ((buffer[0] & 0x08) == 0) { cum = buffer[0] & 0x07; nbytes = 3; } else { return decoding_error(stream, buffer, 1); } if (ecl_read_byte8(stream, buffer+1, nbytes) < nbytes) return EOF; for (i = 1; i <= nbytes; i++) { unsigned char c = buffer[i]; /*printf(": %04x :", c);*/ unlikely_if ((c & 0xC0) != 0x80) return decoding_error(stream, buffer, nbytes+1); cum = (cum << 6) | (c & 0x3F); unlikely_if (cum == 0) return decoding_error(stream, buffer, nbytes+1); } if (cum >= 0xd800) { unlikely_if (cum <= 0xdfff) return decoding_error(stream, buffer, nbytes+1); unlikely_if (cum >= 0xFFFE && cum <= 0xFFFF) return decoding_error(stream, buffer, nbytes+1); } /*printf("; %04x ;", cum);*/ return cum; } static int utf_8_encoder(cl_object stream, unsigned char *buffer, ecl_character c) { int nbytes; if (c < 0) { nbytes = 0; } else if (c <= 0x7F) { buffer[0] = c; nbytes = 1; } else if (c <= 0x7ff) { buffer[1] = (c & 0x3f) | 0x80; c >>= 6; buffer[0] = c | 0xC0; /*printf("\n; %04x ;: %04x :: %04x :\n", c_orig, buffer[0], buffer[1]);*/ nbytes = 2; } else if (c <= 0xFFFF) { buffer[2] = (c & 0x3f) | 0x80; c >>= 6; buffer[1] = (c & 0x3f) | 0x80; c >>= 6; buffer[0] = c | 0xE0; nbytes = 3; } else if (c <= 0x1FFFFFL) { buffer[3] = (c & 0x3f) | 0x80; c >>= 6; buffer[2] = (c & 0x3f) | 0x80; c >>= 6; buffer[1] = (c & 0x3f) | 0x80; c >>= 6; buffer[0] = c | 0xF0; nbytes = 4; } return nbytes; } #endif /******************************************************************************** * CLOS STREAMS */ #ifdef ECL_CLOS_STREAMS static cl_index clos_stream_read_byte8(cl_object strm, unsigned char *c, cl_index n) { cl_index i; for (i = 0; i < n; i++) { cl_object byte = _ecl_funcall2(@'gray::stream-read-byte', strm); if (!ECL_FIXNUMP(byte)) break; c[i] = ecl_fixnum(byte); } return i; } static cl_index clos_stream_write_byte8(cl_object strm, unsigned char *c, cl_index n) { cl_index i; for (i = 0; i < n; i++) { cl_object byte = _ecl_funcall3(@'gray::stream-write-byte', strm, ecl_make_fixnum(c[i])); if (!ECL_FIXNUMP(byte)) break; } return i; } static cl_object clos_stream_read_byte(cl_object strm) { cl_object b = _ecl_funcall2(@'gray::stream-read-byte', strm); if (b == @':eof') b = ECL_NIL; return b; } static void clos_stream_write_byte(cl_object c, cl_object strm) { _ecl_funcall3(@'gray::stream-write-byte', strm, c); } static ecl_character clos_stream_read_char(cl_object strm) { cl_object output = _ecl_funcall2(@'gray::stream-read-char', strm); cl_fixnum value; if (ECL_CHARACTERP(output)) value = ECL_CHAR_CODE(output); else if (ECL_FIXNUMP(output)) value = ecl_fixnum(output); else if (output == ECL_NIL || output == @':eof') return EOF; else value = -1; unlikely_if (value < 0 || value > ECL_CHAR_CODE_LIMIT) FEerror("Unknown character ~A", 1, output); return value; } static ecl_character clos_stream_write_char(cl_object strm, ecl_character c) { _ecl_funcall3(@'gray::stream-write-char', strm, ECL_CODE_CHAR(c)); return c; } static void clos_stream_unread_char(cl_object strm, ecl_character c) { _ecl_funcall3(@'gray::stream-unread-char', strm, ECL_CODE_CHAR(c)); } static int clos_stream_peek_char(cl_object strm) { cl_object out = _ecl_funcall2(@'gray::stream-peek-char', strm); if (out == @':eof') return EOF; return ecl_char_code(out); } static int clos_stream_listen(cl_object strm) { return !Null(_ecl_funcall2(@'gray::stream-listen', strm)); } static void clos_stream_clear_input(cl_object strm) { _ecl_funcall2(@'gray::stream-clear-input', strm); } static void clos_stream_clear_output(cl_object strm) { _ecl_funcall2(@'gray::stream-clear-output', strm); return; } static void clos_stream_force_output(cl_object strm) { _ecl_funcall2(@'gray::stream-force-output', strm); } static void clos_stream_finish_output(cl_object strm) { _ecl_funcall2(@'gray::stream-finish-output', strm); } static int clos_stream_input_p(cl_object strm) { return !Null(_ecl_funcall2(@'gray::input-stream-p', strm)); } static int clos_stream_output_p(cl_object strm) { return !Null(_ecl_funcall2(@'gray::output-stream-p', strm)); } static int clos_stream_interactive_p(cl_object strm) { return !Null(_ecl_funcall2(@'gray::stream-interactive-p', strm)); } static cl_object clos_stream_element_type(cl_object strm) { return _ecl_funcall2(@'gray::stream-element-type', strm); } #define clos_stream_length not_a_file_stream static cl_object clos_stream_get_position(cl_object strm) { return _ecl_funcall2(@'gray::stream-file-position', strm); } static cl_object clos_stream_set_position(cl_object strm, cl_object pos) { return _ecl_funcall3(@'gray::stream-file-position', strm, pos); } static int clos_stream_column(cl_object strm) { cl_object col = _ecl_funcall2(@'gray::stream-line-column', strm); /* FIXME! The Gray streams specifies NIL is a valid * value but means "unknown". Should we make it * zero? */ return Null(col)? 0 : ecl_to_size(col); } static cl_object clos_stream_close(cl_object strm) { return _ecl_funcall2(@'gray::close', strm); } const struct ecl_file_ops clos_stream_ops = { clos_stream_write_byte8, clos_stream_read_byte8, clos_stream_write_byte, clos_stream_read_byte, clos_stream_read_char, clos_stream_write_char, clos_stream_unread_char, clos_stream_peek_char, generic_read_vector, generic_write_vector, clos_stream_listen, clos_stream_clear_input, clos_stream_clear_output, clos_stream_finish_output, clos_stream_force_output, clos_stream_input_p, clos_stream_output_p, clos_stream_interactive_p, clos_stream_element_type, clos_stream_length, clos_stream_get_position, clos_stream_set_position, clos_stream_column, clos_stream_close }; #endif /* ECL_CLOS_STREAMS */ /********************************************************************** * STRING OUTPUT STREAMS */ static ecl_character str_out_write_char(cl_object strm, ecl_character c) { int column = strm->stream.column; if (c == '\n') strm->stream.column = 0; else if (c == '\t') strm->stream.column = (column&~(cl_index)7) + 8; else strm->stream.column++; ecl_string_push_extend(STRING_OUTPUT_STRING(strm), c); return c; } static cl_object str_out_element_type(cl_object strm) { cl_object string = STRING_OUTPUT_STRING(strm); if (ECL_BASE_STRING_P(string)) return @'base-char'; return @'character'; } static cl_object str_out_get_position(cl_object strm) { return ecl_make_unsigned_integer(STRING_OUTPUT_STRING(strm)->base_string.fillp); } static cl_object str_out_set_position(cl_object strm, cl_object pos) { cl_object string = STRING_OUTPUT_STRING(strm); cl_fixnum disp; if (Null(pos)) { disp = strm->base_string.dim; } else { disp = ecl_to_size(pos); } if (disp < string->base_string.fillp) { string->base_string.fillp = disp; } else { disp -= string->base_string.fillp; while (disp-- > 0) ecl_write_char(' ', strm); } return ECL_T; } static int str_out_column(cl_object strm) { return strm->stream.column; } const struct ecl_file_ops str_out_ops = { not_output_write_byte8, not_binary_read_byte8, not_binary_write_byte, not_input_read_byte, not_input_read_char, str_out_write_char, not_input_unread_char, generic_peek_char, generic_read_vector, generic_write_vector, not_input_listen, not_input_clear_input, generic_void, /* clear-output */ generic_void, /* finish-output */ generic_void, /* force-output */ generic_always_false, /* input_p */ generic_always_true, /* output_p */ generic_always_false, str_out_element_type, not_a_file_stream, /* length */ str_out_get_position, str_out_set_position, str_out_column, generic_close }; cl_object si_make_string_output_stream_from_string(cl_object s) { cl_object strm = alloc_stream(); unlikely_if (!ECL_STRINGP(s) || !ECL_ARRAY_HAS_FILL_POINTER_P(s)) FEerror("~S is not a -string with a fill-pointer.", 1, s); strm->stream.ops = duplicate_dispatch_table(&str_out_ops); strm->stream.mode = (short)ecl_smm_string_output; STRING_OUTPUT_STRING(strm) = s; strm->stream.column = 0; #if !defined(ECL_UNICODE) strm->stream.format = @':pass-through'; strm->stream.flags = ECL_STREAM_DEFAULT_FORMAT; strm->stream.byte_size = 8; #else if (ECL_BASE_STRING_P(s)) { strm->stream.format = @':latin-1'; strm->stream.flags = ECL_STREAM_LATIN_1; strm->stream.byte_size = 8; } else { strm->stream.format = @':ucs-4'; strm->stream.flags = ECL_STREAM_UCS_4; strm->stream.byte_size = 32; } #endif @(return strm) } cl_object ecl_make_string_output_stream(cl_index line_length, int extended) { #ifdef ECL_UNICODE cl_object s = extended? ecl_alloc_adjustable_extended_string(line_length) : ecl_alloc_adjustable_base_string(line_length); #else cl_object s = ecl_alloc_adjustable_base_string(line_length); #endif return si_make_string_output_stream_from_string(s); } @(defun make-string-output-stream (&key (element_type @'character')) int extended = 0; @ if (element_type == @'base-char') { (void)0; } else if (element_type == @'character') { #ifdef ECL_UNICODE extended = 1; #endif } else if (!Null(_ecl_funcall3(@'subtypep', element_type, @'base-char'))) { (void)0; } else if (!Null(_ecl_funcall3(@'subtypep', element_type, @'character'))) { #ifdef ECL_UNICODE extended = 1; #endif } else { FEerror("In MAKE-STRING-OUTPUT-STREAM, the argument :ELEMENT-TYPE (~A) must be a subtype of character", 1, element_type); } @(return ecl_make_string_output_stream(128, extended)) @) cl_object cl_get_output_stream_string(cl_object strm) { cl_object strng; unlikely_if (!ECL_ANSI_STREAM_TYPE_P(strm, ecl_smm_string_output)) FEwrong_type_only_arg(@[get-output-stream-string], strm, @[string-stream]); strng = cl_copy_seq(STRING_OUTPUT_STRING(strm)); STRING_OUTPUT_STRING(strm)->base_string.fillp = 0; @(return strng) } /********************************************************************** * STRING INPUT STREAMS */ static ecl_character str_in_read_char(cl_object strm) { cl_fixnum curr_pos = STRING_INPUT_POSITION(strm); ecl_character c; if (curr_pos >= STRING_INPUT_LIMIT(strm)) { c = EOF; } else { c = ecl_char(STRING_INPUT_STRING(strm), curr_pos); STRING_INPUT_POSITION(strm) = curr_pos+1; } return c; } static void str_in_unread_char(cl_object strm, ecl_character c) { cl_fixnum curr_pos = STRING_INPUT_POSITION(strm); unlikely_if (c <= 0) { unread_error(strm); } STRING_INPUT_POSITION(strm) = curr_pos - 1; } static ecl_character str_in_peek_char(cl_object strm) { cl_index pos = STRING_INPUT_POSITION(strm); if (pos >= STRING_INPUT_LIMIT(strm)) { return EOF; } else { return ecl_char(STRING_INPUT_STRING(strm), pos); } } static int str_in_listen(cl_object strm) { if (STRING_INPUT_POSITION(strm) < STRING_INPUT_LIMIT(strm)) return ECL_LISTEN_AVAILABLE; else return ECL_LISTEN_EOF; } static cl_object str_in_element_type(cl_object strm) { cl_object string = STRING_INPUT_STRING(strm); if (ECL_BASE_STRING_P(string)) return @'base-char'; return @'character'; } static cl_object str_in_get_position(cl_object strm) { return ecl_make_unsigned_integer(STRING_INPUT_POSITION(strm)); } static cl_object str_in_set_position(cl_object strm, cl_object pos) { cl_fixnum disp; if (Null(pos)) { disp = STRING_INPUT_LIMIT(strm); } else { disp = ecl_to_size(pos); if (disp >= STRING_INPUT_LIMIT(strm)) { disp = STRING_INPUT_LIMIT(strm); } } STRING_INPUT_POSITION(strm) = disp; return ECL_T; } const struct ecl_file_ops str_in_ops = { not_output_write_byte8, not_binary_read_byte8, not_output_write_byte, not_binary_read_byte, str_in_read_char, not_output_write_char, str_in_unread_char, str_in_peek_char, generic_read_vector, generic_write_vector, str_in_listen, generic_void, /* clear-input */ not_output_clear_output, not_output_finish_output, not_output_force_output, generic_always_true, /* input_p */ generic_always_false, /* output_p */ generic_always_false, str_in_element_type, not_a_file_stream, /* length */ str_in_get_position, str_in_set_position, generic_column, generic_close }; cl_object ecl_make_string_input_stream(cl_object strng, cl_index istart, cl_index iend) { cl_object strm; strm = alloc_stream(); strm->stream.ops = duplicate_dispatch_table(&str_in_ops); strm->stream.mode = (short)ecl_smm_string_input; STRING_INPUT_STRING(strm) = strng; STRING_INPUT_POSITION(strm) = istart; STRING_INPUT_LIMIT(strm) = iend; #if !defined(ECL_UNICODE) strm->stream.format = @':pass-through'; strm->stream.flags = ECL_STREAM_DEFAULT_FORMAT; strm->stream.byte_size = 8; #else if (ECL_BASE_STRING_P(strng) == t_base_string) { strm->stream.format = @':latin-1'; strm->stream.flags = ECL_STREAM_LATIN_1; strm->stream.byte_size = 8; } else { strm->stream.format = @':ucs-4'; strm->stream.flags = ECL_STREAM_UCS_4; strm->stream.byte_size = 32; } #endif return strm; } @(defun make_string_input_stream (strng &o (istart ecl_make_fixnum(0)) iend) cl_index_pair p; @ strng = cl_string(strng); p = ecl_vector_start_end(@[make-string-input-stream], strng, istart, iend); @(return (ecl_make_string_input_stream(strng, p.start, p.end))) @) /********************************************************************** * TWO WAY STREAM */ static cl_index two_way_read_byte8(cl_object strm, unsigned char *c, cl_index n) { if (strm == cl_core.terminal_io) ecl_force_output(TWO_WAY_STREAM_OUTPUT(cl_core.terminal_io)); return ecl_read_byte8(TWO_WAY_STREAM_INPUT(strm), c, n); } static cl_index two_way_write_byte8(cl_object strm, unsigned char *c, cl_index n) { return ecl_write_byte8(TWO_WAY_STREAM_OUTPUT(strm), c, n); } static void two_way_write_byte(cl_object byte, cl_object stream) { ecl_write_byte(byte, TWO_WAY_STREAM_OUTPUT(stream)); } static cl_object two_way_read_byte(cl_object stream) { return ecl_read_byte(TWO_WAY_STREAM_INPUT(stream)); } static ecl_character two_way_read_char(cl_object strm) { return ecl_read_char(TWO_WAY_STREAM_INPUT(strm)); } static ecl_character two_way_write_char(cl_object strm, ecl_character c) { return ecl_write_char(c, TWO_WAY_STREAM_OUTPUT(strm)); } static void two_way_unread_char(cl_object strm, ecl_character c) { ecl_unread_char(c, TWO_WAY_STREAM_INPUT(strm)); } static ecl_character two_way_peek_char(cl_object strm) { return ecl_peek_char(TWO_WAY_STREAM_INPUT(strm)); } static cl_index two_way_read_vector(cl_object strm, cl_object data, cl_index start, cl_index n) { strm = TWO_WAY_STREAM_INPUT(strm); return stream_dispatch_table(strm)->read_vector(strm, data, start, n); } static cl_index two_way_write_vector(cl_object strm, cl_object data, cl_index start, cl_index n) { strm = TWO_WAY_STREAM_OUTPUT(strm); return stream_dispatch_table(strm)->write_vector(strm, data, start, n); } static int two_way_listen(cl_object strm) { return ecl_listen_stream(TWO_WAY_STREAM_INPUT(strm)); } static void two_way_clear_input(cl_object strm) { ecl_clear_input(TWO_WAY_STREAM_INPUT(strm)); } static void two_way_clear_output(cl_object strm) { ecl_clear_output(TWO_WAY_STREAM_OUTPUT(strm)); } static void two_way_force_output(cl_object strm) { ecl_force_output(TWO_WAY_STREAM_OUTPUT(strm)); } static void two_way_finish_output(cl_object strm) { ecl_finish_output(TWO_WAY_STREAM_OUTPUT(strm)); } static int two_way_interactive_p(cl_object strm) { return ecl_interactive_stream_p(TWO_WAY_STREAM_INPUT(strm)); } static cl_object two_way_element_type(cl_object strm) { return ecl_stream_element_type(TWO_WAY_STREAM_INPUT(strm)); } static int two_way_column(cl_object strm) { return ecl_file_column(TWO_WAY_STREAM_OUTPUT(strm)); } static cl_object two_way_close(cl_object strm) { if (strm->stream.flags & ECL_STREAM_CLOSE_COMPONENTS) { cl_close(1, TWO_WAY_STREAM_INPUT(strm)); cl_close(1, TWO_WAY_STREAM_OUTPUT(strm)); } return generic_close(strm); } const struct ecl_file_ops two_way_ops = { two_way_write_byte8, two_way_read_byte8, two_way_write_byte, two_way_read_byte, two_way_read_char, two_way_write_char, two_way_unread_char, two_way_peek_char, two_way_read_vector, two_way_write_vector, two_way_listen, two_way_clear_input, two_way_clear_output, two_way_finish_output, two_way_force_output, generic_always_true, /* input_p */ generic_always_true, /* output_p */ two_way_interactive_p, two_way_element_type, not_a_file_stream, /* length */ generic_always_nil, /* get_position */ generic_set_position, two_way_column, two_way_close }; cl_object cl_make_two_way_stream(cl_object istrm, cl_object ostrm) { cl_object strm; if (!ecl_input_stream_p(istrm)) not_an_input_stream(istrm); if (!ecl_output_stream_p(ostrm)) not_an_output_stream(ostrm); strm = alloc_stream(); strm->stream.format = cl_stream_external_format(istrm); strm->stream.mode = (short)ecl_smm_two_way; strm->stream.ops = duplicate_dispatch_table(&two_way_ops); TWO_WAY_STREAM_INPUT(strm) = istrm; TWO_WAY_STREAM_OUTPUT(strm) = ostrm; @(return strm) } cl_object cl_two_way_stream_input_stream(cl_object strm) { unlikely_if (!ECL_ANSI_STREAM_TYPE_P(strm,ecl_smm_two_way)) FEwrong_type_only_arg(@[two-way-stream-input-stream], strm, @[two-way-stream]); @(return TWO_WAY_STREAM_INPUT(strm)); } cl_object cl_two_way_stream_output_stream(cl_object strm) { unlikely_if (!ECL_ANSI_STREAM_TYPE_P(strm, ecl_smm_two_way)) FEwrong_type_only_arg(@[two-way-stream-output-stream], strm, @[two-way-stream]); @(return TWO_WAY_STREAM_OUTPUT(strm)) } /********************************************************************** * BROADCAST STREAM */ static cl_index broadcast_write_byte8(cl_object strm, unsigned char *c, cl_index n) { cl_object l; cl_index out = n; for (l = BROADCAST_STREAM_LIST(strm); !Null(l); l = ECL_CONS_CDR(l)) { out = ecl_write_byte8(ECL_CONS_CAR(l), c, n); } return out; } static ecl_character broadcast_write_char(cl_object strm, ecl_character c) { cl_object l; for (l = BROADCAST_STREAM_LIST(strm); !Null(l); l = ECL_CONS_CDR(l)) { ecl_write_char(c, ECL_CONS_CAR(l)); } return c; } static void broadcast_write_byte(cl_object c, cl_object strm) { cl_object l; for (l = BROADCAST_STREAM_LIST(strm); !Null(l); l = ECL_CONS_CDR(l)) { ecl_write_byte(c, ECL_CONS_CAR(l)); } } static void broadcast_clear_output(cl_object strm) { cl_object l; for (l = BROADCAST_STREAM_LIST(strm); !Null(l); l = ECL_CONS_CDR(l)) { ecl_clear_output(ECL_CONS_CAR(l)); } } static void broadcast_force_output(cl_object strm) { cl_object l; for (l = BROADCAST_STREAM_LIST(strm); !Null(l); l = ECL_CONS_CDR(l)) { ecl_force_output(ECL_CONS_CAR(l)); } } static void broadcast_finish_output(cl_object strm) { cl_object l; for (l = BROADCAST_STREAM_LIST(strm); !Null(l); l = ECL_CONS_CDR(l)) { ecl_finish_output(ECL_CONS_CAR(l)); } } static cl_object broadcast_element_type(cl_object strm) { cl_object l = BROADCAST_STREAM_LIST(strm); if (Null(l)) return ECL_T; return ecl_stream_element_type(ECL_CONS_CAR(l)); } static cl_object broadcast_length(cl_object strm) { cl_object l = BROADCAST_STREAM_LIST(strm); if (Null(l)) return ecl_make_fixnum(0); return ecl_file_length(ECL_CONS_CAR(l)); } static cl_object broadcast_get_position(cl_object strm) { cl_object l = BROADCAST_STREAM_LIST(strm); if (Null(l)) return ecl_make_fixnum(0); return ecl_file_position(ECL_CONS_CAR(l)); } static cl_object broadcast_set_position(cl_object strm, cl_object pos) { cl_object l = BROADCAST_STREAM_LIST(strm); if (Null(l)) return ECL_NIL; return ecl_file_position_set(ECL_CONS_CAR(l), pos); } static int broadcast_column(cl_object strm) { cl_object l = BROADCAST_STREAM_LIST(strm); if (Null(l)) return 0; return ecl_file_column(ECL_CONS_CAR(l)); } static cl_object broadcast_close(cl_object strm) { if (strm->stream.flags & ECL_STREAM_CLOSE_COMPONENTS) { cl_mapc(2, @'close', BROADCAST_STREAM_LIST(strm)); } return generic_close(strm); } const struct ecl_file_ops broadcast_ops = { broadcast_write_byte8, not_input_read_byte8, broadcast_write_byte, not_input_read_byte, not_input_read_char, broadcast_write_char, not_input_unread_char, generic_peek_char, generic_read_vector, generic_write_vector, not_input_listen, broadcast_force_output, /* clear_input */ /* FIXME! This is legacy behaviour */ broadcast_clear_output, broadcast_finish_output, broadcast_force_output, generic_always_false, /* input_p */ generic_always_true, /* output_p */ generic_always_false, broadcast_element_type, broadcast_length, broadcast_get_position, broadcast_set_position, broadcast_column, broadcast_close }; @(defun make_broadcast_stream (&rest ap) cl_object x, streams; int i; @ streams = ECL_NIL; for (i = 0; i < narg; i++) { x = ecl_va_arg(ap); unlikely_if (!ecl_output_stream_p(x)) not_an_output_stream(x); streams = CONS(x, streams); } x = alloc_stream(); x->stream.format = @':default'; x->stream.ops = duplicate_dispatch_table(&broadcast_ops); x->stream.mode = (short)ecl_smm_broadcast; BROADCAST_STREAM_LIST(x) = cl_nreverse(streams); @(return x) @) cl_object cl_broadcast_stream_streams(cl_object strm) { unlikely_if (!ECL_ANSI_STREAM_TYPE_P(strm, ecl_smm_broadcast)) FEwrong_type_only_arg(@[broadcast-stream-streams], strm, @[broadcast-stream]); return cl_copy_list(BROADCAST_STREAM_LIST(strm)); } /********************************************************************** * ECHO STREAM */ static cl_index echo_read_byte8(cl_object strm, unsigned char *c, cl_index n) { cl_index out = ecl_read_byte8(ECHO_STREAM_INPUT(strm), c, n); return ecl_write_byte8(ECHO_STREAM_OUTPUT(strm), c, out); } static cl_index echo_write_byte8(cl_object strm, unsigned char *c, cl_index n) { return ecl_write_byte8(ECHO_STREAM_OUTPUT(strm), c, n); } static void echo_write_byte(cl_object c, cl_object strm) { ecl_write_byte(c, ECHO_STREAM_OUTPUT(strm)); } static cl_object echo_read_byte(cl_object strm) { cl_object out = ecl_read_byte(ECHO_STREAM_INPUT(strm)); if (!Null(out)) ecl_write_byte(out, ECHO_STREAM_OUTPUT(strm)); return out; } static ecl_character echo_read_char(cl_object strm) { ecl_character c = strm->stream.last_code[0]; if (c == EOF) { c = ecl_read_char(ECHO_STREAM_INPUT(strm)); if (c != EOF) ecl_write_char(c, ECHO_STREAM_OUTPUT(strm)); } else { strm->stream.last_code[0] = EOF; ecl_read_char(ECHO_STREAM_INPUT(strm)); } return c; } static ecl_character echo_write_char(cl_object strm, ecl_character c) { return ecl_write_char(c, ECHO_STREAM_OUTPUT(strm)); } static void echo_unread_char(cl_object strm, ecl_character c) { unlikely_if (strm->stream.last_code[0] != EOF) { unread_twice(strm); } strm->stream.last_code[0] = c; ecl_unread_char(c, ECHO_STREAM_INPUT(strm)); } static ecl_character echo_peek_char(cl_object strm) { ecl_character c = strm->stream.last_code[0]; if (c == EOF) { c = ecl_peek_char(ECHO_STREAM_INPUT(strm)); } return c; } static int echo_listen(cl_object strm) { return ecl_listen_stream(ECHO_STREAM_INPUT(strm)); } static void echo_clear_input(cl_object strm) { ecl_clear_input(ECHO_STREAM_INPUT(strm)); } static void echo_clear_output(cl_object strm) { ecl_clear_output(ECHO_STREAM_OUTPUT(strm)); } static void echo_force_output(cl_object strm) { ecl_force_output(ECHO_STREAM_OUTPUT(strm)); } static void echo_finish_output(cl_object strm) { ecl_finish_output(ECHO_STREAM_OUTPUT(strm)); } static cl_object echo_element_type(cl_object strm) { return ecl_stream_element_type(ECHO_STREAM_INPUT(strm)); } static int echo_column(cl_object strm) { return ecl_file_column(ECHO_STREAM_OUTPUT(strm)); } static cl_object echo_close(cl_object strm) { if (strm->stream.flags & ECL_STREAM_CLOSE_COMPONENTS) { cl_close(1, ECHO_STREAM_INPUT(strm)); cl_close(1, ECHO_STREAM_OUTPUT(strm)); } return generic_close(strm); } const struct ecl_file_ops echo_ops = { echo_write_byte8, echo_read_byte8, echo_write_byte, echo_read_byte, echo_read_char, echo_write_char, echo_unread_char, echo_peek_char, generic_read_vector, generic_write_vector, echo_listen, echo_clear_input, echo_clear_output, echo_finish_output, echo_force_output, generic_always_true, /* input_p */ generic_always_true, /* output_p */ generic_always_false, echo_element_type, not_a_file_stream, /* length */ generic_always_nil, /* get_position */ generic_set_position, echo_column, echo_close }; cl_object cl_make_echo_stream(cl_object strm1, cl_object strm2) { cl_object strm; unlikely_if (!ecl_input_stream_p(strm1)) not_an_input_stream(strm1); unlikely_if (!ecl_output_stream_p(strm2)) not_an_output_stream(strm2); strm = alloc_stream(); strm->stream.format = cl_stream_external_format(strm1); strm->stream.mode = (short)ecl_smm_echo; strm->stream.ops = duplicate_dispatch_table(&echo_ops); ECHO_STREAM_INPUT(strm) = strm1; ECHO_STREAM_OUTPUT(strm) = strm2; @(return strm) } cl_object cl_echo_stream_input_stream(cl_object strm) { unlikely_if (!ECL_ANSI_STREAM_TYPE_P(strm, ecl_smm_echo)) FEwrong_type_only_arg(@[echo-stream-input-stream], strm, @[echo-stream]); @(return ECHO_STREAM_INPUT(strm)) } cl_object cl_echo_stream_output_stream(cl_object strm) { unlikely_if (!ECL_ANSI_STREAM_TYPE_P(strm, ecl_smm_echo)) FEwrong_type_only_arg(@[echo-stream-output-stream], strm, @[echo-stream]); @(return ECHO_STREAM_OUTPUT(strm)) } /********************************************************************** * CONCATENATED STREAM */ static cl_index concatenated_read_byte8(cl_object strm, unsigned char *c, cl_index n) { cl_object l = CONCATENATED_STREAM_LIST(strm); cl_index out = 0; while (out < n && !Null(l)) { cl_index delta = ecl_read_byte8(ECL_CONS_CAR(l), c + out, n - out); out += delta; if (out == n) break; CONCATENATED_STREAM_LIST(strm) = l = ECL_CONS_CDR(l); } return out; } static cl_object concatenated_read_byte(cl_object strm) { cl_object l = CONCATENATED_STREAM_LIST(strm); cl_object c = ECL_NIL; while (!Null(l)) { c = ecl_read_byte(ECL_CONS_CAR(l)); if (c != ECL_NIL) break; CONCATENATED_STREAM_LIST(strm) = l = ECL_CONS_CDR(l); } return c; } static ecl_character concatenated_read_char(cl_object strm) { cl_object l = CONCATENATED_STREAM_LIST(strm); ecl_character c = EOF; while (!Null(l)) { c = ecl_read_char(ECL_CONS_CAR(l)); if (c != EOF) break; CONCATENATED_STREAM_LIST(strm) = l = ECL_CONS_CDR(l); } return c; } static void concatenated_unread_char(cl_object strm, ecl_character c) { cl_object l = CONCATENATED_STREAM_LIST(strm); unlikely_if (Null(l)) unread_error(strm); ecl_unread_char(c, ECL_CONS_CAR(l)); } static int concatenated_listen(cl_object strm) { cl_object l = CONCATENATED_STREAM_LIST(strm); while (!Null(l)) { int f = ecl_listen_stream(ECL_CONS_CAR(l)); l = ECL_CONS_CDR(l); if (f == ECL_LISTEN_EOF) { CONCATENATED_STREAM_LIST(strm) = l; } else { return f; } } return ECL_LISTEN_EOF; } static cl_object concatenated_close(cl_object strm) { if (strm->stream.flags & ECL_STREAM_CLOSE_COMPONENTS) { cl_mapc(2, @'close', CONCATENATED_STREAM_LIST(strm)); } return generic_close(strm); } const struct ecl_file_ops concatenated_ops = { not_output_write_byte8, concatenated_read_byte8, not_output_write_byte, concatenated_read_byte, concatenated_read_char, not_output_write_char, concatenated_unread_char, generic_peek_char, generic_read_vector, generic_write_vector, concatenated_listen, generic_void, /* clear_input */ not_output_clear_output, not_output_finish_output, not_output_force_output, generic_always_true, /* input_p */ generic_always_false, /* output_p */ generic_always_false, broadcast_element_type, not_a_file_stream, /* length */ generic_always_nil, /* get_position */ generic_set_position, generic_column, concatenated_close }; @(defun make_concatenated_stream (&rest ap) cl_object x, streams; int i; @ streams = ECL_NIL; for (i = 0; i < narg; i++) { x = ecl_va_arg(ap); unlikely_if (!ecl_input_stream_p(x)) not_an_input_stream(x); streams = CONS(x, streams); } x = alloc_stream(); if (Null(streams)) { x->stream.format = @':pass-through'; } else { x->stream.format = cl_stream_external_format(ECL_CONS_CAR(streams)); } x->stream.mode = (short)ecl_smm_concatenated; x->stream.ops = duplicate_dispatch_table(&concatenated_ops); CONCATENATED_STREAM_LIST(x) = cl_nreverse(streams); @(return x) @) cl_object cl_concatenated_stream_streams(cl_object strm) { unlikely_if (!ECL_ANSI_STREAM_TYPE_P(strm, ecl_smm_concatenated)) FEwrong_type_only_arg(@[concatenated-stream-streams], strm, @[concatenated-stream]); return cl_copy_list(CONCATENATED_STREAM_LIST(strm)); } /********************************************************************** * SYNONYM STREAM */ static cl_index synonym_read_byte8(cl_object strm, unsigned char *c, cl_index n) { return ecl_read_byte8(SYNONYM_STREAM_STREAM(strm), c, n); } static cl_index synonym_write_byte8(cl_object strm, unsigned char *c, cl_index n) { return ecl_write_byte8(SYNONYM_STREAM_STREAM(strm), c, n); } static void synonym_write_byte(cl_object c, cl_object strm) { ecl_write_byte(c, SYNONYM_STREAM_STREAM(strm)); } static cl_object synonym_read_byte(cl_object strm) { return ecl_read_byte(SYNONYM_STREAM_STREAM(strm)); } static ecl_character synonym_read_char(cl_object strm) { return ecl_read_char(SYNONYM_STREAM_STREAM(strm)); } static ecl_character synonym_write_char(cl_object strm, ecl_character c) { return ecl_write_char(c, SYNONYM_STREAM_STREAM(strm)); } static void synonym_unread_char(cl_object strm, ecl_character c) { ecl_unread_char(c, SYNONYM_STREAM_STREAM(strm)); } static ecl_character synonym_peek_char(cl_object strm) { return ecl_peek_char(SYNONYM_STREAM_STREAM(strm)); } static cl_index synonym_read_vector(cl_object strm, cl_object data, cl_index start, cl_index n) { strm = SYNONYM_STREAM_STREAM(strm); return stream_dispatch_table(strm)->read_vector(strm, data, start, n); } static cl_index synonym_write_vector(cl_object strm, cl_object data, cl_index start, cl_index n) { strm = SYNONYM_STREAM_STREAM(strm); return stream_dispatch_table(strm)->write_vector(strm, data, start, n); } static int synonym_listen(cl_object strm) { return ecl_listen_stream(SYNONYM_STREAM_STREAM(strm)); } static void synonym_clear_input(cl_object strm) { ecl_clear_input(SYNONYM_STREAM_STREAM(strm)); } static void synonym_clear_output(cl_object strm) { ecl_clear_output(SYNONYM_STREAM_STREAM(strm)); } static void synonym_force_output(cl_object strm) { ecl_force_output(SYNONYM_STREAM_STREAM(strm)); } static void synonym_finish_output(cl_object strm) { ecl_finish_output(SYNONYM_STREAM_STREAM(strm)); } static int synonym_input_p(cl_object strm) { return ecl_input_stream_p(SYNONYM_STREAM_STREAM(strm)); } static int synonym_output_p(cl_object strm) { return ecl_output_stream_p(SYNONYM_STREAM_STREAM(strm)); } static int synonym_interactive_p(cl_object strm) { return ecl_interactive_stream_p(SYNONYM_STREAM_STREAM(strm)); } static cl_object synonym_element_type(cl_object strm) { return ecl_stream_element_type(SYNONYM_STREAM_STREAM(strm)); } static cl_object synonym_length(cl_object strm) { return ecl_file_length(SYNONYM_STREAM_STREAM(strm)); } static cl_object synonym_get_position(cl_object strm) { return ecl_file_position(SYNONYM_STREAM_STREAM(strm)); } static cl_object synonym_set_position(cl_object strm, cl_object pos) { return ecl_file_position_set(SYNONYM_STREAM_STREAM(strm), pos); } static int synonym_column(cl_object strm) { return ecl_file_column(SYNONYM_STREAM_STREAM(strm)); } const struct ecl_file_ops synonym_ops = { synonym_write_byte8, synonym_read_byte8, synonym_write_byte, synonym_read_byte, synonym_read_char, synonym_write_char, synonym_unread_char, synonym_peek_char, synonym_read_vector, synonym_write_vector, synonym_listen, synonym_clear_input, synonym_clear_output, synonym_finish_output, synonym_force_output, synonym_input_p, synonym_output_p, synonym_interactive_p, synonym_element_type, synonym_length, synonym_get_position, synonym_set_position, synonym_column, generic_close }; cl_object cl_make_synonym_stream(cl_object sym) { cl_object x; sym = ecl_check_cl_type(@'make-synonym-stream',sym,t_symbol); x = alloc_stream(); x->stream.ops = duplicate_dispatch_table(&synonym_ops); x->stream.mode = (short)ecl_smm_synonym; SYNONYM_STREAM_SYMBOL(x) = sym; @(return x) } cl_object cl_synonym_stream_symbol(cl_object strm) { unlikely_if (!ECL_ANSI_STREAM_TYPE_P(strm, ecl_smm_synonym)) FEwrong_type_only_arg(@[synonym-stream-symbol], strm, @[synonym-stream]); @(return SYNONYM_STREAM_SYMBOL(strm)) } /********************************************************************** * UNINTERRUPTED OPERATIONS */ #ifdef ECL_MS_WINDOWS_HOST #define ecl_mode_t int #else #define ecl_mode_t mode_t #endif static int safe_open(const char *filename, int flags, ecl_mode_t mode) { const cl_env_ptr the_env = ecl_process_env(); int output; ecl_disable_interrupts_env(the_env); output = open(filename, flags, mode); ecl_enable_interrupts_env(the_env); return output; } static int safe_close(int f) { const cl_env_ptr the_env = ecl_process_env(); int output; ecl_disable_interrupts_env(the_env); output = close(f); ecl_enable_interrupts_env(the_env); return output; } static FILE * safe_fopen(const char *filename, const char *mode) { const cl_env_ptr the_env = ecl_process_env(); FILE *output; ecl_disable_interrupts_env(the_env); output = fopen(filename, mode); ecl_enable_interrupts_env(the_env); return output; } static FILE * safe_fdopen(int fildes, const char *mode) { const cl_env_ptr the_env = ecl_process_env(); FILE *output; ecl_disable_interrupts_env(the_env); output = fdopen(fildes, mode); ecl_enable_interrupts_env(the_env); return output; } static int safe_fclose(FILE *stream) { const cl_env_ptr the_env = ecl_process_env(); int output; ecl_disable_interrupts_env(the_env); output = fclose(stream); ecl_enable_interrupts_env(the_env); return output; } /********************************************************************** * POSIX FILE STREAM */ static cl_index consume_byte_stack(cl_object strm, unsigned char *c, cl_index n) { cl_index out = 0; while (n) { cl_object l = strm->stream.byte_stack; if (l == ECL_NIL) return out + strm->stream.ops->read_byte8(strm, c, n); *(c++) = ecl_fixnum(ECL_CONS_CAR(l)); out++; n--; strm->stream.byte_stack = l = ECL_CONS_CDR(l); } return out; } static cl_index io_file_read_byte8(cl_object strm, unsigned char *c, cl_index n) { unlikely_if (strm->stream.byte_stack != ECL_NIL) { return consume_byte_stack(strm, c, n); } else { int f = IO_FILE_DESCRIPTOR(strm); cl_fixnum out = 0; ecl_disable_interrupts(); do { out = read(f, c, sizeof(char)*n); } while (out < 0 && restartable_io_error(strm, "read")); ecl_enable_interrupts(); return out; } } static cl_index output_file_write_byte8(cl_object strm, unsigned char *c, cl_index n) { int f = IO_FILE_DESCRIPTOR(strm); cl_fixnum out; ecl_disable_interrupts(); do { out = write(f, c, sizeof(char)*n); } while (out < 0 && restartable_io_error(strm, "write")); ecl_enable_interrupts(); return out; } static cl_index io_file_write_byte8(cl_object strm, unsigned char *c, cl_index n) { unlikely_if (strm->stream.byte_stack != ECL_NIL) { /* Try to move to the beginning of the unread characters */ cl_object aux = ecl_file_position(strm); if (!Null(aux)) ecl_file_position_set(strm, aux); strm->stream.byte_stack = ECL_NIL; } return output_file_write_byte8(strm, c, n); } static int io_file_listen(cl_object strm) { if (strm->stream.byte_stack != ECL_NIL) return ECL_LISTEN_AVAILABLE; if (strm->stream.flags & ECL_STREAM_MIGHT_SEEK) { cl_env_ptr the_env = ecl_process_env(); int f = IO_FILE_DESCRIPTOR(strm); ecl_off_t disp, new; ecl_disable_interrupts_env(the_env); disp = lseek(f, 0, SEEK_CUR); ecl_enable_interrupts_env(the_env); if (disp != (ecl_off_t)-1) { ecl_disable_interrupts_env(the_env); new = lseek(f, 0, SEEK_END); ecl_enable_interrupts_env(the_env); lseek(f, disp, SEEK_SET); if (new == disp) { return ECL_LISTEN_NO_CHAR; } else if (new != (ecl_off_t)-1) { return ECL_LISTEN_AVAILABLE; } } } return file_listen(strm, IO_FILE_DESCRIPTOR(strm)); } #if defined(ECL_MS_WINDOWS_HOST) static int isaconsole(int i) { HANDLE h = (HANDLE)_get_osfhandle(i); DWORD mode; return !!GetConsoleMode(h, &mode); } #define isatty isaconsole #endif static void io_file_clear_input(cl_object strm) { int f = IO_FILE_DESCRIPTOR(strm); #if defined(ECL_MS_WINDOWS_HOST) if (isatty(f)) { /* Flushes Win32 console */ if (!FlushConsoleInputBuffer((HANDLE)_get_osfhandle(f))) FEwin32_error("FlushConsoleInputBuffer() failed", 0); /* Do not stop here: the FILE structure needs also to be flushed */ } #endif while (file_listen(strm, f) == ECL_LISTEN_AVAILABLE) { ecl_character c = eformat_read_char(strm); if (c == EOF) return; } } #define io_file_clear_output generic_void #define io_file_force_output generic_void #define io_file_finish_output io_file_force_output static int io_file_interactive_p(cl_object strm) { int f = IO_FILE_DESCRIPTOR(strm); return isatty(f); } static cl_object io_file_element_type(cl_object strm) { return IO_FILE_ELT_TYPE(strm); } static cl_object io_file_length(cl_object strm) { int f = IO_FILE_DESCRIPTOR(strm); cl_object output = ecl_file_len(f); if (strm->stream.byte_size != 8) { const cl_env_ptr the_env = ecl_process_env(); cl_index bs = strm->stream.byte_size; output = ecl_floor2(output, ecl_make_fixnum(bs/8)); unlikely_if (ecl_nth_value(the_env, 1) != ecl_make_fixnum(0)) { FEerror("File length is not on byte boundary", 0); } } return output; } static cl_object io_file_get_position(cl_object strm) { cl_object output; ecl_off_t offset; int f = IO_FILE_DESCRIPTOR(strm); if (isatty(f)) return(ECL_NIL); ecl_disable_interrupts(); offset = lseek(f, 0, SEEK_CUR); ecl_enable_interrupts(); unlikely_if (offset < 0) if (errno == ESPIPE) return(ECL_NIL); else io_error(strm); if (sizeof(ecl_off_t) == sizeof(long)) { output = ecl_make_integer(offset); } else { output = ecl_off_t_to_integer(offset); } { /* If there are unread octets, we return the position at which * these bytes begin! */ cl_object l = strm->stream.byte_stack; while (CONSP(l)) { output = ecl_one_minus(output); l = ECL_CONS_CDR(l); } } if (strm->stream.byte_size != 8) { output = ecl_floor2(output, ecl_make_fixnum(strm->stream.byte_size / 8)); } return output; } static cl_object io_file_set_position(cl_object strm, cl_object large_disp) { ecl_off_t disp; int mode; int f = IO_FILE_DESCRIPTOR(strm); if (isatty(f)) return(ECL_NIL); if (Null(large_disp)) { disp = 0; mode = SEEK_END; } else { if (strm->stream.byte_size != 8) { large_disp = ecl_times(large_disp, ecl_make_fixnum(strm->stream.byte_size / 8)); } disp = ecl_integer_to_off_t(large_disp); mode = SEEK_SET; } disp = lseek(f, disp, mode); return (disp == (ecl_off_t)-1)? ECL_NIL : ECL_T; } static int io_file_column(cl_object strm) { return strm->stream.column; } static cl_object io_file_close(cl_object strm) { int f = IO_FILE_DESCRIPTOR(strm); int failed; unlikely_if (f == STDOUT_FILENO) FEerror("Cannot close the standard output", 0); unlikely_if (f == STDIN_FILENO) FEerror("Cannot close the standard input", 0); failed = safe_close(f); unlikely_if (failed < 0) cannot_close(strm); IO_FILE_DESCRIPTOR(strm) = -1; return generic_close(strm); } static cl_index io_file_read_vector(cl_object strm, cl_object data, cl_index start, cl_index end) { cl_elttype t = ecl_array_elttype(data); if (start >= end) return start; if (t == ecl_aet_b8 || t == ecl_aet_i8) { if (strm->stream.byte_size == 8) { void *aux = data->vector.self.bc + start; return start + strm->stream.ops->read_byte8(strm, aux, end-start); } } else if (t == ecl_aet_fix || t == ecl_aet_index) { if (strm->stream.byte_size == sizeof(cl_fixnum)*8) { void *aux = data->vector.self.fix + start; cl_index bytes = (end - start) * sizeof(cl_fixnum); bytes = strm->stream.ops->read_byte8(strm, aux, bytes); return start + bytes / sizeof(cl_fixnum); } } return generic_read_vector(strm, data, start, end); } static cl_index io_file_write_vector(cl_object strm, cl_object data, cl_index start, cl_index end) { cl_elttype t = ecl_array_elttype(data); if (start >= end) return start; if (t == ecl_aet_b8 || t == ecl_aet_i8) { if (strm->stream.byte_size == 8) { void *aux = data->vector.self.bc + start; return strm->stream.ops->write_byte8(strm, aux, end-start); } } else if (t == ecl_aet_fix || t == ecl_aet_index) { if (strm->stream.byte_size == sizeof(cl_fixnum)*8) { void *aux = data->vector.self.fix + start; cl_index bytes = (end - start) * sizeof(cl_fixnum); bytes = strm->stream.ops->write_byte8(strm, aux, bytes); return start + bytes / sizeof(cl_fixnum); } } return generic_write_vector(strm, data, start, end); } const struct ecl_file_ops io_file_ops = { io_file_write_byte8, io_file_read_byte8, generic_write_byte, generic_read_byte, eformat_read_char, eformat_write_char, eformat_unread_char, generic_peek_char, io_file_read_vector, io_file_write_vector, io_file_listen, io_file_clear_input, io_file_clear_output, io_file_finish_output, io_file_force_output, generic_always_true, /* input_p */ generic_always_true, /* output_p */ io_file_interactive_p, io_file_element_type, io_file_length, io_file_get_position, io_file_set_position, io_file_column, io_file_close }; const struct ecl_file_ops output_file_ops = { output_file_write_byte8, not_input_read_byte8, generic_write_byte, not_input_read_byte, not_input_read_char, eformat_write_char, not_input_unread_char, not_input_read_char, generic_read_vector, io_file_write_vector, not_input_listen, not_input_clear_input, io_file_clear_output, io_file_finish_output, io_file_force_output, generic_always_false, /* input_p */ generic_always_true, /* output_p */ generic_always_false, io_file_element_type, io_file_length, io_file_get_position, io_file_set_position, io_file_column, io_file_close }; const struct ecl_file_ops input_file_ops = { not_output_write_byte8, io_file_read_byte8, not_output_write_byte, generic_read_byte, eformat_read_char, not_output_write_char, eformat_unread_char, generic_peek_char, io_file_read_vector, generic_write_vector, io_file_listen, io_file_clear_input, not_output_clear_output, not_output_finish_output, not_output_force_output, generic_always_true, /* input_p */ generic_always_false, /* output_p */ io_file_interactive_p, io_file_element_type, io_file_length, io_file_get_position, io_file_set_position, generic_column, io_file_close }; static int parse_external_format(cl_object stream, cl_object format, int flags) { if (format == @':default') { format = ecl_symbol_value(@'ext::*default-external-format*'); } if (CONSP(format)) { flags = parse_external_format(stream, ECL_CONS_CDR(format), flags); format = ECL_CONS_CAR(format); } if (format == ECL_T) { #ifdef ECL_UNICODE return (flags & ~ECL_STREAM_FORMAT) | ECL_STREAM_UTF_8; #else return (flags & ~ECL_STREAM_FORMAT) | ECL_STREAM_DEFAULT_FORMAT; #endif } if (format == ECL_NIL) { return flags; } if (format == @':CR') { return (flags | ECL_STREAM_CR) & ~ECL_STREAM_LF; } if (format == @':LF') { return (flags | ECL_STREAM_LF) & ~ECL_STREAM_CR; } if (format == @':CRLF') { return flags | (ECL_STREAM_CR+ECL_STREAM_LF); } if (format == @':LITTLE-ENDIAN') { return flags | ECL_STREAM_LITTLE_ENDIAN; } if (format == @':BIG-ENDIAN') { return flags & ~ECL_STREAM_LITTLE_ENDIAN; } if (format == @':pass-through') { #ifdef ECL_UNICODE return (flags & ~ECL_STREAM_FORMAT) | ECL_STREAM_LATIN_1; #else return (flags & ~ECL_STREAM_FORMAT) | ECL_STREAM_DEFAULT_FORMAT; #endif } #ifdef ECL_UNICODE PARSE_SYMBOLS: if (format == @':UTF-8') { return (flags & ~ECL_STREAM_FORMAT) | ECL_STREAM_UTF_8; } if (format == @':UCS-2') { return (flags & ~ECL_STREAM_FORMAT) | ECL_STREAM_UCS_2; } if (format == @':UCS-2BE') { return (flags & ~ECL_STREAM_FORMAT) | ECL_STREAM_UCS_2BE; } if (format == @':UCS-2LE') { return (flags & ~ECL_STREAM_FORMAT) | ECL_STREAM_UCS_2LE; } if (format == @':UCS-4') { return (flags & ~ECL_STREAM_FORMAT) | ECL_STREAM_UCS_4; } if (format == @':UCS-4BE') { return (flags & ~ECL_STREAM_FORMAT) | ECL_STREAM_UCS_4BE; } if (format == @':UCS-4LE') { return (flags & ~ECL_STREAM_FORMAT) | ECL_STREAM_UCS_4LE; } if (format == @':ISO-8859-1') { return (flags & ~ECL_STREAM_FORMAT) | ECL_STREAM_ISO_8859_1; } if (format == @':LATIN-1') { return (flags & ~ECL_STREAM_FORMAT) | ECL_STREAM_LATIN_1; } if (format == @':US-ASCII') { return (flags & ~ECL_STREAM_FORMAT) | ECL_STREAM_US_ASCII; } if (ECL_HASH_TABLE_P(format)) { stream->stream.format_table = format; return (flags & ~ECL_STREAM_FORMAT) | ECL_STREAM_USER_FORMAT; } if (ECL_SYMBOLP(format)) { format = si_make_encoding(format); if (ECL_SYMBOLP(format)) goto PARSE_SYMBOLS; stream->stream.format_table = format; return (flags & ~ECL_STREAM_FORMAT) | ECL_STREAM_USER_FORMAT; } #endif FEerror("Unknown or unsupported external format: ~A", 1, format); return ECL_STREAM_DEFAULT_FORMAT; } static void set_stream_elt_type(cl_object stream, cl_fixnum byte_size, int flags, cl_object external_format) { cl_object t; if (byte_size < 0) { byte_size = -byte_size; flags |= ECL_STREAM_SIGNED_BYTES; t = @'signed-byte'; } else { flags &= ~ECL_STREAM_SIGNED_BYTES; t = @'unsigned-byte'; } flags = parse_external_format(stream, external_format, flags); stream->stream.ops->read_char = eformat_read_char; stream->stream.ops->write_char = eformat_write_char; switch (flags & ECL_STREAM_FORMAT) { case ECL_STREAM_BINARY: IO_STREAM_ELT_TYPE(stream) = cl_list(2, t, ecl_make_fixnum(byte_size)); stream->stream.format = t; stream->stream.ops->read_char = not_character_read_char; stream->stream.ops->write_char = not_character_write_char; break; #ifdef ECL_UNICODE /*case ECL_ISO_8859_1:*/ case ECL_STREAM_LATIN_1: IO_STREAM_ELT_TYPE(stream) = @'base-char'; byte_size = 8; stream->stream.format = @':latin-1'; stream->stream.encoder = passthrough_encoder; stream->stream.decoder = passthrough_decoder; break; case ECL_STREAM_UTF_8: IO_STREAM_ELT_TYPE(stream) = @'character'; byte_size = 8; stream->stream.format = @':utf-8'; stream->stream.encoder = utf_8_encoder; stream->stream.decoder = utf_8_decoder; break; case ECL_STREAM_UCS_2: IO_STREAM_ELT_TYPE(stream) = @'character'; byte_size = 8*2; stream->stream.format = @':ucs-2'; stream->stream.encoder = ucs_2_encoder; stream->stream.decoder = ucs_2_decoder; break; case ECL_STREAM_UCS_2BE: IO_STREAM_ELT_TYPE(stream) = @'character'; byte_size = 8*2; if (flags & ECL_STREAM_LITTLE_ENDIAN) { stream->stream.format = @':ucs-2le'; stream->stream.encoder = ucs_2le_encoder; stream->stream.decoder = ucs_2le_decoder; } else { stream->stream.format = @':ucs-2be'; stream->stream.encoder = ucs_2be_encoder; stream->stream.decoder = ucs_2be_decoder; } break; case ECL_STREAM_UCS_4: IO_STREAM_ELT_TYPE(stream) = @'character'; byte_size = 8*4; stream->stream.format = @':ucs-4be'; stream->stream.encoder = ucs_4_encoder; stream->stream.decoder = ucs_4_decoder; break; case ECL_STREAM_UCS_4BE: IO_STREAM_ELT_TYPE(stream) = @'character'; byte_size = 8*4; if (flags & ECL_STREAM_LITTLE_ENDIAN) { stream->stream.format = @':ucs-4le'; stream->stream.encoder = ucs_4le_encoder; stream->stream.decoder = ucs_4le_decoder; } else { stream->stream.format = @':ucs-4be'; stream->stream.encoder = ucs_4be_encoder; stream->stream.decoder = ucs_4be_decoder; } break; case ECL_STREAM_USER_FORMAT: IO_STREAM_ELT_TYPE(stream) = @'character'; byte_size = 8; stream->stream.format = stream->stream.format_table; if (CONSP(stream->stream.format)) { stream->stream.encoder = user_multistate_encoder; stream->stream.decoder = user_multistate_decoder; } else { stream->stream.encoder = user_encoder; stream->stream.decoder = user_decoder; } break; case ECL_STREAM_US_ASCII: IO_STREAM_ELT_TYPE(stream) = @'base-char'; byte_size = 8; stream->stream.format = @':us-ascii'; stream->stream.encoder = ascii_encoder; stream->stream.decoder = ascii_decoder; break; #else case ECL_STREAM_DEFAULT_FORMAT: IO_STREAM_ELT_TYPE(stream) = @'base-char'; byte_size = 8; stream->stream.format = @':pass-through'; stream->stream.encoder = passthrough_encoder; stream->stream.decoder = passthrough_decoder; break; #endif default: FEerror("Invalid or unsupported external format ~A with code ~D", 2, external_format, ecl_make_fixnum(flags)); } t = @':LF'; if (stream->stream.ops->write_char == eformat_write_char && (flags & ECL_STREAM_CR)) { if (flags & ECL_STREAM_LF) { stream->stream.ops->read_char = eformat_read_char_crlf; stream->stream.ops->write_char = eformat_write_char_crlf; t = @':CRLF'; } else { stream->stream.ops->read_char = eformat_read_char_cr; stream->stream.ops->write_char = eformat_write_char_cr; t = @':CR'; } } stream->stream.format = cl_list(2, stream->stream.format, t); { cl_object (*read_byte)(cl_object); void (*write_byte)(cl_object,cl_object); byte_size = (byte_size+7)&(~(cl_fixnum)7); if (byte_size == 8) { if (flags & ECL_STREAM_SIGNED_BYTES) { read_byte = generic_read_byte_signed8; write_byte = generic_write_byte_signed8; } else { read_byte = generic_read_byte_unsigned8; write_byte = generic_write_byte_unsigned8; } } else if (flags & ECL_STREAM_LITTLE_ENDIAN) { read_byte = generic_read_byte_le; write_byte = generic_write_byte_le; } else { read_byte = generic_read_byte; write_byte = generic_write_byte; } if (ecl_input_stream_p(stream)) { stream->stream.ops->read_byte = read_byte; } if (ecl_output_stream_p(stream)) { stream->stream.ops->write_byte = write_byte; } } stream->stream.flags = flags; stream->stream.byte_size = byte_size; } cl_object si_stream_external_format_set(cl_object stream, cl_object format) { #ifdef ECL_CLOS_STREAMS unlikely_if (ECL_INSTANCEP(stream)) { FEerror("Cannot change external format of stream ~A", 1, stream); } #endif switch (stream->stream.mode) { case ecl_smm_input: case ecl_smm_input_file: case ecl_smm_output: case ecl_smm_output_file: case ecl_smm_io: case ecl_smm_io_file: #ifdef ECL_WSOCK case ecl_smm_input_wsock: case ecl_smm_output_wsock: case ecl_smm_io_wsock: case ecl_smm_io_wcon: #endif { cl_object elt_type = ecl_stream_element_type(stream); unlikely_if (elt_type != @'character' && elt_type != @'base-char') FEerror("Cannot change external format" "of binary stream ~A", 1, stream); set_stream_elt_type(stream, stream->stream.byte_size, stream->stream.flags, format); } break; default: FEerror("Cannot change external format of stream ~A", 1, stream); } @(return) } cl_object ecl_make_file_stream_from_fd(cl_object fname, int fd, enum ecl_smmode smm, cl_fixnum byte_size, int flags, cl_object external_format) { cl_object stream = alloc_stream(); switch(smm) { case ecl_smm_input: smm = ecl_smm_input_file; case ecl_smm_input_file: case ecl_smm_probe: stream->stream.ops = duplicate_dispatch_table(&input_file_ops); break; case ecl_smm_output: smm = ecl_smm_output_file; case ecl_smm_output_file: stream->stream.ops = duplicate_dispatch_table(&output_file_ops); break; case ecl_smm_io: smm = ecl_smm_io_file; case ecl_smm_io_file: stream->stream.ops = duplicate_dispatch_table(&io_file_ops); break; default: FEerror("make_stream: wrong mode", 0); } stream->stream.mode = (short)smm; stream->stream.closed = 0; set_stream_elt_type(stream, byte_size, flags, external_format); IO_FILE_FILENAME(stream) = fname; /* not really used */ stream->stream.column = 0; IO_FILE_DESCRIPTOR(stream) = fd; stream->stream.last_op = 0; si_set_finalizer(stream, ECL_T); return stream; } /********************************************************************** * C STREAMS */ static cl_index input_stream_read_byte8(cl_object strm, unsigned char *c, cl_index n) { unlikely_if (strm->stream.byte_stack != ECL_NIL) { return consume_byte_stack(strm, c, n); } else { FILE *f = IO_STREAM_FILE(strm); cl_fixnum out = 0; ecl_disable_interrupts(); #ifdef FILE_CNT do { out = fread(c, sizeof(char), n, f); } while (out < n && ferror(f) && restartable_io_error(strm, "fread")); #else /* We can't use fread here due to the buffering. It makes impossible checking if we have some data available in the buffer what renders listen returning incorrect result. */ do { out = read(fileno(f), c, sizeof(char)*n); } while (out < 0 && restartable_io_error(strm, "read")); #endif ecl_enable_interrupts(); return out; } } static cl_index output_stream_write_byte8(cl_object strm, unsigned char *c, cl_index n) { cl_index out; ecl_disable_interrupts(); do { out = fwrite(c, sizeof(char), n, IO_STREAM_FILE(strm)); } while (out < n && restartable_io_error(strm, "fwrite")); ecl_enable_interrupts(); return out; } static cl_index io_stream_write_byte8(cl_object strm, unsigned char *c, cl_index n) { /* When using the same stream for input and output operations, we have to * use some file position operation before reading again. Besides this, if * there were unread octets, we have to move to the position at the * begining of them. */ if (strm->stream.byte_stack != ECL_NIL) { cl_object aux = ecl_file_position(strm); if (!Null(aux)) ecl_file_position_set(strm, aux); } else if (strm->stream.last_op > 0) { ecl_fseeko(IO_STREAM_FILE(strm), 0, SEEK_CUR); } strm->stream.last_op = -1; return output_stream_write_byte8(strm, c, n); } static void io_stream_force_output(cl_object strm); static cl_index io_stream_read_byte8(cl_object strm, unsigned char *c, cl_index n) { /* When using the same stream for input and output operations, we have to * flush the stream before reading. */ if (strm->stream.last_op < 0) { io_stream_force_output(strm); } strm->stream.last_op = +1; return input_stream_read_byte8(strm, c, n); } static int io_stream_listen(cl_object strm) { if (strm->stream.byte_stack != ECL_NIL) return ECL_LISTEN_AVAILABLE; return flisten(strm, IO_STREAM_FILE(strm)); } static void io_stream_clear_input(cl_object strm) { FILE *fp = IO_STREAM_FILE(strm); #if defined(ECL_MS_WINDOWS_HOST) int f = fileno(fp); if (isatty(f)) { /* Flushes Win32 console */ unlikely_if (!FlushConsoleInputBuffer((HANDLE)_get_osfhandle(f))) FEwin32_error("FlushConsoleInputBuffer() failed", 0); /* Do not stop here: the FILE structure needs also to be flushed */ } #endif while (flisten(strm, fp) == ECL_LISTEN_AVAILABLE) { ecl_disable_interrupts(); getc(fp); ecl_enable_interrupts(); } } #define io_stream_clear_output generic_void static void io_stream_force_output(cl_object strm) { FILE *f = IO_STREAM_FILE(strm); ecl_disable_interrupts(); while ((fflush(f) == EOF) && restartable_io_error(strm, "fflush")) (void)0; ecl_enable_interrupts(); } #define io_stream_finish_output io_stream_force_output static int io_stream_interactive_p(cl_object strm) { FILE *f = IO_STREAM_FILE(strm); return isatty(fileno(f)); } static cl_object io_stream_length(cl_object strm) { FILE *f = IO_STREAM_FILE(strm); cl_object output = ecl_file_len(fileno(f)); if (strm->stream.byte_size != 8) { const cl_env_ptr the_env = ecl_process_env(); cl_index bs = strm->stream.byte_size; output = ecl_floor2(output, ecl_make_fixnum(bs/8)); unlikely_if (ecl_nth_value(the_env, 1) != ecl_make_fixnum(0)) { FEerror("File length is not on byte boundary", 0); } } return output; } static cl_object io_stream_get_position(cl_object strm) { FILE *f = IO_STREAM_FILE(strm); cl_object output; ecl_off_t offset; ecl_disable_interrupts(); offset = ecl_ftello(f); ecl_enable_interrupts(); if (offset < 0) io_error(strm); if (sizeof(ecl_off_t) == sizeof(long)) { output = ecl_make_integer(offset); } else { output = ecl_off_t_to_integer(offset); } { /* If there are unread octets, we return the position at which * these bytes begin! */ cl_object l = strm->stream.byte_stack; while (CONSP(l)) { output = ecl_one_minus(output); l = ECL_CONS_CDR(l); } } if (strm->stream.byte_size != 8) { output = ecl_floor2(output, ecl_make_fixnum(strm->stream.byte_size / 8)); } return output; } static cl_object io_stream_set_position(cl_object strm, cl_object large_disp) { FILE *f = IO_STREAM_FILE(strm); ecl_off_t disp; int mode; if (Null(large_disp)) { disp = 0; mode = SEEK_END; } else { if (strm->stream.byte_size != 8) { large_disp = ecl_times(large_disp, ecl_make_fixnum(strm->stream.byte_size / 8)); } disp = ecl_integer_to_off_t(large_disp); mode = SEEK_SET; } ecl_disable_interrupts(); mode = ecl_fseeko(f, disp, mode); ecl_enable_interrupts(); return mode? ECL_NIL : ECL_T; } static int io_stream_column(cl_object strm) { return strm->stream.column; } static cl_object io_stream_close(cl_object strm) { FILE *f = IO_STREAM_FILE(strm); int failed; unlikely_if (f == stdout) FEerror("Cannot close the standard output", 0); unlikely_if (f == stdin) FEerror("Cannot close the standard input", 0); unlikely_if (f == NULL) wrong_file_handler(strm); if (ecl_output_stream_p(strm)) { ecl_force_output(strm); } failed = safe_fclose(f); unlikely_if (failed) cannot_close(strm); #if !defined(GBC_BOEHM) ecl_dealloc(strm->stream.buffer); IO_STREAM_FILE(strm) = NULL; #endif return generic_close(strm); } /* * Specialized sequence operations */ #define io_stream_read_vector io_file_read_vector #define io_stream_write_vector io_file_write_vector const struct ecl_file_ops io_stream_ops = { io_stream_write_byte8, io_stream_read_byte8, generic_write_byte, generic_read_byte, eformat_read_char, eformat_write_char, eformat_unread_char, generic_peek_char, io_file_read_vector, io_file_write_vector, io_stream_listen, io_stream_clear_input, io_stream_clear_output, io_stream_finish_output, io_stream_force_output, generic_always_true, /* input_p */ generic_always_true, /* output_p */ io_stream_interactive_p, io_file_element_type, io_stream_length, io_stream_get_position, io_stream_set_position, io_stream_column, io_stream_close }; const struct ecl_file_ops output_stream_ops = { output_stream_write_byte8, not_input_read_byte8, generic_write_byte, not_input_read_byte, not_input_read_char, eformat_write_char, not_input_unread_char, not_input_read_char, generic_read_vector, io_file_write_vector, not_input_listen, generic_void, io_stream_clear_output, io_stream_finish_output, io_stream_force_output, generic_always_false, /* input_p */ generic_always_true, /* output_p */ generic_always_false, io_file_element_type, io_stream_length, io_stream_get_position, io_stream_set_position, io_stream_column, io_stream_close }; const struct ecl_file_ops input_stream_ops = { not_output_write_byte8, input_stream_read_byte8, not_output_write_byte, generic_read_byte, eformat_read_char, not_output_write_char, eformat_unread_char, generic_peek_char, io_file_read_vector, generic_write_vector, io_stream_listen, io_stream_clear_input, generic_void, generic_void, generic_void, generic_always_true, /* input_p */ generic_always_false, /* output_p */ io_stream_interactive_p, io_file_element_type, io_stream_length, io_stream_get_position, io_stream_set_position, generic_column, io_stream_close }; /********************************************************************** * WINSOCK STREAMS */ #if defined(ECL_WSOCK) #define winsock_stream_element_type io_file_element_type static cl_index winsock_stream_read_byte8(cl_object strm, unsigned char *c, cl_index n) { cl_index len = 0; unlikely_if (strm->stream.byte_stack != ECL_NIL) { return consume_byte_stack(strm, c, n); } if(n > 0) { SOCKET s = (SOCKET)IO_FILE_DESCRIPTOR(strm); unlikely_if (INVALID_SOCKET == s) { wrong_file_handler(strm); } else { ecl_disable_interrupts(); len = recv(s, c, n, 0); unlikely_if (len == SOCKET_ERROR) wsock_error("Cannot read bytes from Windows " "socket ~S.~%~A", strm); ecl_enable_interrupts(); } } return (len > 0) ? len : EOF; } static cl_index winsock_stream_write_byte8(cl_object strm, unsigned char *c, cl_index n) { cl_index out = 0; unsigned char *endp; unsigned char *p; SOCKET s = (SOCKET)IO_FILE_DESCRIPTOR(strm); unlikely_if (INVALID_SOCKET == s) { wrong_file_handler(strm); } else { ecl_disable_interrupts(); do { cl_index res = send(s, c + out, n, 0); unlikely_if (res == SOCKET_ERROR) { wsock_error("Cannot write bytes to Windows" " socket ~S.~%~A", strm); break; /* stop writing */ } else { out += res; n -= res; } } while (n > 0); ecl_enable_interrupts(); } return out; } static int winsock_stream_listen(cl_object strm) { SOCKET s; unlikely_if (strm->stream.byte_stack != ECL_NIL) { return ECL_LISTEN_AVAILABLE; } s = (SOCKET)IO_FILE_DESCRIPTOR(strm); unlikely_if (INVALID_SOCKET == s) { wrong_file_handler(strm); } { struct timeval tv = { 0, 0 }; fd_set fds; cl_index result; FD_ZERO( &fds ); FD_SET(s, &fds); ecl_disable_interrupts(); result = select( 0, &fds, NULL, NULL, &tv ); unlikely_if (result == SOCKET_ERROR) wsock_error("Cannot listen on Windows " "socket ~S.~%~A", strm ); ecl_enable_interrupts(); return ( result > 0 ? ECL_LISTEN_AVAILABLE : ECL_LISTEN_NO_CHAR ); } } static void winsock_stream_clear_input(cl_object strm) { while (winsock_stream_listen(strm) == ECL_LISTEN_AVAILABLE) { eformat_read_char(strm); } } static cl_object winsock_stream_close(cl_object strm) { SOCKET s = (SOCKET) IO_FILE_DESCRIPTOR(strm); int failed; ecl_disable_interrupts(); failed = closesocket(s); ecl_enable_interrupts(); unlikely_if (failed < 0) cannot_close(strm); IO_FILE_DESCRIPTOR(strm) = (int)INVALID_SOCKET; return generic_close(strm); } const struct ecl_file_ops winsock_stream_io_ops = { winsock_stream_write_byte8, winsock_stream_read_byte8, generic_write_byte, generic_read_byte, eformat_read_char, eformat_write_char, eformat_unread_char, generic_peek_char, generic_read_vector, generic_write_vector, winsock_stream_listen, winsock_stream_clear_input, generic_void, generic_void, generic_void, generic_always_true, /* input_p */ generic_always_true, /* output_p */ generic_always_false, winsock_stream_element_type, not_a_file_stream, not_implemented_get_position, not_implemented_set_position, generic_column, winsock_stream_close }; const struct ecl_file_ops winsock_stream_output_ops = { winsock_stream_write_byte8, not_input_read_byte8, generic_write_byte, not_input_read_byte, not_input_read_char, eformat_write_char, not_input_unread_char, generic_peek_char, generic_read_vector, generic_write_vector, not_input_listen, not_input_clear_input, generic_void, generic_void, generic_void, generic_always_false, /* input_p */ generic_always_true, /* output_p */ generic_always_false, winsock_stream_element_type, not_a_file_stream, not_implemented_get_position, not_implemented_set_position, generic_column, winsock_stream_close }; const struct ecl_file_ops winsock_stream_input_ops = { not_output_write_byte8, winsock_stream_read_byte8, not_output_write_byte, generic_read_byte, eformat_read_char, not_output_write_char, eformat_unread_char, generic_peek_char, generic_read_vector, generic_write_vector, winsock_stream_listen, winsock_stream_clear_input, not_output_clear_output, not_output_finish_output, not_output_force_output, generic_always_true, /* input_p */ generic_always_false, /* output_p */ generic_always_false, winsock_stream_element_type, not_a_file_stream, not_implemented_get_position, not_implemented_set_position, generic_column, winsock_stream_close }; #endif /********************************************************************** * WINCONSOLE STREAM */ #if defined(ECL_MS_WINDOWS_HOST) #define wcon_stream_element_type io_file_element_type static cl_index wcon_stream_read_byte8(cl_object strm, unsigned char *c, cl_index n) { unlikely_if (strm->stream.byte_stack != ECL_NIL) { return consume_byte_stack(strm, c, n); } else { cl_index len = 0; cl_env_ptr the_env = ecl_process_env(); HANDLE h = (HANDLE)IO_FILE_DESCRIPTOR(strm); DWORD nchars; unsigned char aux[4]; for (len = 0; len < n; ) { int i, ok; ecl_disable_interrupts_env(the_env); ok = ReadConsole(h, &aux, 1, &nchars, NULL); ecl_enable_interrupts_env(the_env); unlikely_if (!ok) { FEwin32_error("Cannot read from console", 0); } for (i = 0; i < nchars; i++) { if (len < n) { c[len++] = aux[i]; } else { strm->stream.byte_stack = ecl_nconc(strm->stream.byte_stack, ecl_list1(ecl_make_fixnum(aux[i]))); } } } return (len > 0) ? len : EOF; } } static cl_index wcon_stream_write_byte8(cl_object strm, unsigned char *c, cl_index n) { HANDLE h = (HANDLE)IO_FILE_DESCRIPTOR(strm); DWORD nchars; unlikely_if(!WriteConsole(h, c, n, &nchars, NULL)) { FEwin32_error("Cannot write to console.", 0); } return nchars; } static int wcon_stream_listen(cl_object strm) { HANDLE h = (HANDLE)IO_FILE_DESCRIPTOR(strm); INPUT_RECORD aux; DWORD nevents; do { unlikely_if(!PeekConsoleInput(h, &aux, 1, &nevents)) FEwin32_error("Cannot read from console.", 0); if (nevents == 0) return 0; if (aux.EventType == KEY_EVENT) return 1; unlikely_if(!ReadConsoleInput(h, &aux, 1, &nevents)) FEwin32_error("Cannot read from console.", 0); } while (1); } static void wcon_stream_clear_input(cl_object strm) { FlushConsoleInputBuffer((HANDLE)IO_FILE_DESCRIPTOR(strm)); } static void wcon_stream_force_output(cl_object strm) { DWORD nchars; WriteConsole((HANDLE)IO_FILE_DESCRIPTOR(strm), 0, 0, &nchars, NULL); } const struct ecl_file_ops wcon_stream_io_ops = { wcon_stream_write_byte8, wcon_stream_read_byte8, generic_write_byte, generic_read_byte, eformat_read_char, eformat_write_char, eformat_unread_char, generic_peek_char, generic_read_vector, generic_write_vector, wcon_stream_listen, wcon_stream_clear_input, generic_void, wcon_stream_force_output, wcon_stream_force_output, generic_always_true, /* input_p */ generic_always_true, /* output_p */ generic_always_false, wcon_stream_element_type, not_a_file_stream, not_implemented_get_position, not_implemented_set_position, generic_column, generic_close, }; #define CONTROL_Z 26 static cl_object maybe_make_windows_console_FILE(cl_object fname, FILE *f, enum ecl_smmode smm, cl_fixnum byte_size, int flags, cl_object external_format) { int desc = fileno(f); cl_object output; if (isatty(desc)) { output = ecl_make_stream_from_FILE (fname, (void*)_get_osfhandle(desc), ecl_smm_io_wcon, byte_size, flags, external_format); output->stream.eof_char = CONTROL_Z; } else { output = ecl_make_stream_from_FILE (fname, f, smm, byte_size, flags, external_format); } return output; } static cl_object maybe_make_windows_console_fd(cl_object fname, int desc, enum ecl_smmode smm, cl_fixnum byte_size, int flags, cl_object external_format) { cl_object output; if (isatty(desc)) { output = ecl_make_stream_from_FILE (fname, (void*)_get_osfhandle(desc), ecl_smm_io_wcon, byte_size, flags, external_format); output->stream.eof_char = CONTROL_Z; } else { /* Windows changes the newline characters for \r\n * even when using read()/write() */ if (ecl_option_values[ECL_OPT_USE_SETMODE_ON_FILES]) { _setmode(desc, _O_BINARY); } else { external_format = ECL_CONS_CDR(external_format); } output = ecl_make_file_stream_from_fd (fname, desc, smm, byte_size, flags, external_format); } return output; } #else #define maybe_make_windows_console_FILE ecl_make_stream_from_FILE #define maybe_make_windows_console_fd ecl_make_file_stream_from_fd #endif cl_object si_set_buffering_mode(cl_object stream, cl_object buffer_mode_symbol) { enum ecl_smmode mode = stream->stream.mode; int buffer_mode; unlikely_if (!ECL_ANSI_STREAM_P(stream)) { FEerror("Cannot set buffer of ~A", 1, stream); } if (buffer_mode_symbol == @':none' || Null(buffer_mode_symbol)) buffer_mode = _IONBF; else if (buffer_mode_symbol == @':line' || buffer_mode_symbol == @':line-buffered') buffer_mode = _IOLBF; else if (buffer_mode_symbol == @':full' || buffer_mode_symbol == @':fully-buffered') buffer_mode = _IOFBF; else FEerror("Not a valid buffering mode: ~A", 1, buffer_mode_symbol); if (mode == ecl_smm_output || mode == ecl_smm_io || mode == ecl_smm_input) { FILE *fp = IO_STREAM_FILE(stream); if (buffer_mode != _IONBF) { cl_index buffer_size = BUFSIZ; char *new_buffer = ecl_alloc_atomic(buffer_size); stream->stream.buffer = new_buffer; setvbuf(fp, new_buffer, buffer_mode, buffer_size); } else setvbuf(fp, NULL, _IONBF, 0); } @(return stream) } cl_object ecl_make_stream_from_FILE(cl_object fname, void *f, enum ecl_smmode smm, cl_fixnum byte_size, int flags, cl_object external_format) { cl_object stream; stream = alloc_stream(); stream->stream.mode = (short)smm; stream->stream.closed = 0; switch (smm) { case ecl_smm_io: stream->stream.ops = duplicate_dispatch_table(&io_stream_ops); break; case ecl_smm_probe: case ecl_smm_input: stream->stream.ops = duplicate_dispatch_table(&input_stream_ops); break; case ecl_smm_output: stream->stream.ops = duplicate_dispatch_table(&output_stream_ops); break; #if defined(ECL_WSOCK) case ecl_smm_input_wsock: stream->stream.ops = duplicate_dispatch_table(&winsock_stream_input_ops); break; case ecl_smm_output_wsock: stream->stream.ops = duplicate_dispatch_table(&winsock_stream_output_ops); break; case ecl_smm_io_wsock: stream->stream.ops = duplicate_dispatch_table(&winsock_stream_io_ops); break; case ecl_smm_io_wcon: stream->stream.ops = duplicate_dispatch_table(&wcon_stream_io_ops); break; #endif default: FEerror("Not a valid mode ~D for ecl_make_stream_from_FILE", 1, ecl_make_fixnum(smm)); } set_stream_elt_type(stream, byte_size, flags, external_format); IO_STREAM_FILENAME(stream) = fname; /* not really used */ stream->stream.column = 0; IO_STREAM_FILE(stream) = f; stream->stream.last_op = 0; si_set_finalizer(stream, ECL_T); return stream; } cl_object ecl_make_stream_from_fd(cl_object fname, int fd, enum ecl_smmode smm, cl_fixnum byte_size, int flags, cl_object external_format) { char *mode; /* file open mode */ FILE *fp; /* file pointer */ switch(smm) { case ecl_smm_input: mode = OPEN_R; break; case ecl_smm_output: mode = OPEN_W; break; case ecl_smm_io: mode = OPEN_RW; break; #if defined(ECL_WSOCK) case ecl_smm_input_wsock: case ecl_smm_output_wsock: case ecl_smm_io_wsock: case ecl_smm_io_wcon: break; #endif default: FEerror("make_stream: wrong mode", 0); } #if defined(ECL_WSOCK) if (smm == ecl_smm_input_wsock || smm == ecl_smm_output_wsock || smm == ecl_smm_io_wsock || smm == ecl_smm_io_wcon) fp = (FILE*)fd; else fp = safe_fdopen(fd, mode); #else fp = safe_fdopen(fd, mode); #endif if (fp == NULL) { FElibc_error("Unable to create stream for file descriptor ~D", 1, ecl_make_integer(fd)); } return ecl_make_stream_from_FILE(fname, fp, smm, byte_size, flags, external_format); } int ecl_stream_to_handle(cl_object s, bool output) { BEGIN: if (ecl_unlikely(!ECL_ANSI_STREAM_P(s))) return -1; switch ((enum ecl_smmode)s->stream.mode) { case ecl_smm_input: if (output) return -1; return fileno(IO_STREAM_FILE(s)); case ecl_smm_input_file: if (output) return -1; return IO_FILE_DESCRIPTOR(s); case ecl_smm_output: if (!output) return -1; return fileno(IO_STREAM_FILE(s)); case ecl_smm_output_file: if (!output) return -1; return IO_FILE_DESCRIPTOR(s); case ecl_smm_io: return fileno(IO_STREAM_FILE(s)); case ecl_smm_io_file: return IO_FILE_DESCRIPTOR(s); case ecl_smm_synonym: s = SYNONYM_STREAM_STREAM(s); goto BEGIN; case ecl_smm_two_way: s = output? TWO_WAY_STREAM_OUTPUT(s) : TWO_WAY_STREAM_INPUT(s); goto BEGIN; #if defined(ECL_WSOCK) case ecl_smm_input_wsock: case ecl_smm_output_wsock: case ecl_smm_io_wsock: #endif #if defined(ECL_MS_WINDOWS_HOST) case ecl_smm_io_wcon: #endif default: return -1; } } cl_object si_file_stream_fd(cl_object s) { cl_object ret; unlikely_if (!ECL_ANSI_STREAM_P(s)) FEerror("file_stream_fd: not a stream", 0); switch ((enum ecl_smmode)s->stream.mode) { case ecl_smm_input: case ecl_smm_output: case ecl_smm_io: ret = ecl_make_fixnum(fileno(IO_STREAM_FILE(s))); break; case ecl_smm_input_file: case ecl_smm_output_file: case ecl_smm_io_file: ret = ecl_make_fixnum(IO_FILE_DESCRIPTOR(s)); break; default: ecl_internal_error("not a file stream"); } @(return ret); } /********************************************************************** * SEQUENCE INPUT STREAMS */ static cl_index seq_in_read_byte8(cl_object strm, unsigned char *c, cl_index n) { cl_fixnum curr_pos = SEQ_INPUT_POSITION(strm); cl_fixnum last = SEQ_INPUT_LIMIT(strm); cl_fixnum delta = last - curr_pos; if (delta > 0) { cl_object vector = SEQ_INPUT_VECTOR(strm); if (delta > n) delta = n; memcpy(c, vector->vector.self.bc + curr_pos, delta); SEQ_INPUT_POSITION(strm) += delta; return delta; } return 0; } static void seq_in_unread_char(cl_object strm, ecl_character c) { eformat_unread_char(strm, c); SEQ_INPUT_POSITION(strm) -= ecl_length(strm->stream.byte_stack); strm->stream.byte_stack = ECL_NIL; } static int seq_in_listen(cl_object strm) { if (SEQ_INPUT_POSITION(strm) < SEQ_INPUT_LIMIT(strm)) return ECL_LISTEN_AVAILABLE; else return ECL_LISTEN_EOF; } static cl_object seq_in_get_position(cl_object strm) { return ecl_make_unsigned_integer(SEQ_INPUT_POSITION(strm)); } static cl_object seq_in_set_position(cl_object strm, cl_object pos) { cl_fixnum disp; if (Null(pos)) { disp = SEQ_INPUT_LIMIT(strm); } else { disp = ecl_to_size(pos); if (disp >= SEQ_INPUT_LIMIT(strm)) { disp = SEQ_INPUT_LIMIT(strm); } } SEQ_INPUT_POSITION(strm) = disp; return ECL_T; } const struct ecl_file_ops seq_in_ops = { not_output_write_byte8, seq_in_read_byte8, not_output_write_byte, generic_read_byte, eformat_read_char, not_output_write_char, seq_in_unread_char, generic_peek_char, generic_read_vector, generic_write_vector, seq_in_listen, generic_void, /* clear-input */ not_output_clear_output, not_output_finish_output, not_output_force_output, generic_always_true, /* input_p */ generic_always_false, /* output_p */ generic_always_false, io_file_element_type, not_a_file_stream, /* length */ seq_in_get_position, seq_in_set_position, generic_column, generic_close }; static cl_object make_sequence_input_stream(cl_object vector, cl_index istart, cl_index iend, cl_object external_format) { cl_object strm; cl_elttype type; cl_object type_name; int byte_size; int flags = 0; if (!ECL_VECTORP(vector) || ((type = ecl_array_elttype(vector)) < ecl_aet_b8 && type > ecl_aet_bc) || ecl_aet_size[type] != 1) { FEerror("MAKE-SEQUENCE-INPUT-STREAM only accepts vectors whose element has a size of 1 byte.~%~A", 1, vector); } type_name = ecl_elttype_to_symbol(type); byte_size = ecl_normalize_stream_element_type(type_name); /* Character streams always get some external format. For binary * sequences it has to be explicitly mentioned. */ strm = alloc_stream(); strm->stream.ops = duplicate_dispatch_table(&seq_in_ops); strm->stream.mode = (short)ecl_smm_sequence_input; if (!byte_size) { #if defined(ECL_UNICODE) if (ECL_BASE_STRING_P(vector)) { if (Null(external_format)) external_format = @':default'; } else { if (Null(external_format)) { # ifdef WORDS_BIGENDIAN external_format = @':ucs-4be'; # else external_format = @':ucs-4le'; # endif } } #else if (Null(external_format)) { external_format = @':default'; } #endif } set_stream_elt_type(strm, byte_size, flags, external_format); /* Override byte size and elt type */ if (byte_size) strm->stream.byte_size = byte_size; SEQ_INPUT_VECTOR(strm) = vector; SEQ_INPUT_POSITION(strm) = istart; SEQ_INPUT_LIMIT(strm) = iend; return strm; } @(defun ext::make_sequence_input_stream (vector &key (start ecl_make_fixnum(0)) (end ECL_NIL) (external_format ECL_NIL)) cl_index_pair p; @ p = ecl_vector_start_end(@[ext::make-sequence-input-stream], vector, start, end); @(return make_sequence_input_stream(vector, p.start, p.end, external_format)) @) /********************************************************************** * SEQUENCE OUTPUT STREAMS */ static cl_index seq_out_write_byte8(cl_object strm, unsigned char *c, cl_index n) { AGAIN: { cl_object vector = SEQ_OUTPUT_VECTOR(strm); cl_fixnum curr_pos = SEQ_OUTPUT_POSITION(strm); cl_fixnum last = vector->vector.dim; cl_fixnum delta = last - curr_pos; if (delta < n) { /* Not enough space, enlarge */ vector = _ecl_funcall3(@'adjust-array', vector, ecl_ash(ecl_make_fixnum(last), 1)); SEQ_OUTPUT_VECTOR(strm) = vector; goto AGAIN; } memcpy(vector->vector.self.bc + curr_pos, c, n); SEQ_OUTPUT_POSITION(strm) = curr_pos += n; if (vector->vector.fillp < curr_pos) vector->vector.fillp = curr_pos; } return n; } static cl_object seq_out_get_position(cl_object strm) { return ecl_make_unsigned_integer(SEQ_OUTPUT_POSITION(strm)); } static cl_object seq_out_set_position(cl_object strm, cl_object pos) { cl_object vector = SEQ_OUTPUT_VECTOR(strm); cl_fixnum disp; if (Null(pos)) { disp = vector->vector.fillp; } else { disp = ecl_to_size(pos); if (disp >= vector->vector.dim) { disp = vector->vector.fillp; } } SEQ_OUTPUT_POSITION(strm) = disp; return ECL_T; } const struct ecl_file_ops seq_out_ops = { seq_out_write_byte8, not_input_read_byte8, generic_write_byte, not_input_read_byte, not_input_read_char, eformat_write_char, not_input_unread_char, generic_peek_char, generic_read_vector, generic_write_vector, not_input_listen, not_input_clear_input, generic_void, /* clear-output */ generic_void, /* finish-output */ generic_void, /* force-output */ generic_always_false, /* input_p */ generic_always_true, /* output_p */ generic_always_false, io_file_element_type, not_a_file_stream, /* length */ seq_out_get_position, seq_out_set_position, generic_column, generic_close }; static cl_object make_sequence_output_stream(cl_object vector, cl_object external_format) { cl_object strm; cl_elttype type; cl_object type_name; int byte_size; int flags = 0; if (!ECL_VECTORP(vector) || ((type = ecl_array_elttype(vector)) < ecl_aet_b8 && type > ecl_aet_bc) || ecl_aet_size[type] != 1) { FEerror("MAKE-SEQUENCE-OUTPUT-STREAM only accepts vectors whose element has a size of 1 byte.~%~A", 1, vector); } type_name = ecl_elttype_to_symbol(type); byte_size = ecl_normalize_stream_element_type(type_name); /* Character streams always get some external format. For binary * sequences it has to be explicitly mentioned. */ strm = alloc_stream(); strm->stream.ops = duplicate_dispatch_table(&seq_out_ops); strm->stream.mode = (short)ecl_smm_sequence_output; if (!byte_size) { #if defined(ECL_UNICODE) if (ECL_BASE_STRING_P(vector)) { if (Null(external_format)) external_format = @':default'; } else { if (Null(external_format)) { # ifdef WORDS_BIGENDIAN external_format = @':ucs-4be'; # else external_format = @':ucs-4le'; # endif } } #else if (Null(external_format)) { external_format = @':default'; } #endif } set_stream_elt_type(strm, byte_size, flags, external_format); /* Override byte size and elt type */ if (byte_size) strm->stream.byte_size = byte_size; SEQ_OUTPUT_VECTOR(strm) = vector; SEQ_OUTPUT_POSITION(strm) = vector->vector.fillp; return strm; } @(defun ext::make_sequence_output_stream (vector &key (external_format ECL_NIL)) @ @(return make_sequence_output_stream(vector, external_format)) @) /********************************************************************** * MEDIUM LEVEL INTERFACE */ struct ecl_file_ops * duplicate_dispatch_table(const struct ecl_file_ops *ops) { struct ecl_file_ops *new_ops = ecl_alloc_atomic(sizeof(*ops)); *new_ops = *ops; return new_ops; } const struct ecl_file_ops * stream_dispatch_table(cl_object strm) { #ifdef ECL_CLOS_STREAMS if (ECL_INSTANCEP(strm)) { return &clos_stream_ops; } #endif if (!ECL_ANSI_STREAM_P(strm)) FEwrong_type_argument(@[stream], strm); return (const struct ecl_file_ops *)strm->stream.ops; } static cl_index ecl_read_byte8(cl_object strm, unsigned char *c, cl_index n) { return stream_dispatch_table(strm)->read_byte8(strm, c, n); } static cl_index ecl_write_byte8(cl_object strm, unsigned char *c, cl_index n) { return stream_dispatch_table(strm)->write_byte8(strm, c, n); } ecl_character ecl_read_char(cl_object strm) { return stream_dispatch_table(strm)->read_char(strm); } ecl_character ecl_read_char_noeof(cl_object strm) { ecl_character c = ecl_read_char(strm); if (c == EOF) FEend_of_file(strm); return c; } cl_object ecl_read_byte(cl_object strm) { return stream_dispatch_table(strm)->read_byte(strm); } void ecl_write_byte(cl_object c, cl_object strm) { stream_dispatch_table(strm)->write_byte(c, strm); } ecl_character ecl_write_char(ecl_character c, cl_object strm) { return stream_dispatch_table(strm)->write_char(strm, c); } void ecl_unread_char(ecl_character c, cl_object strm) { stream_dispatch_table(strm)->unread_char(strm, c); } int ecl_listen_stream(cl_object strm) { return stream_dispatch_table(strm)->listen(strm); } void ecl_clear_input(cl_object strm) { stream_dispatch_table(strm)->clear_input(strm); } void ecl_clear_output(cl_object strm) { stream_dispatch_table(strm)->clear_output(strm); } void ecl_force_output(cl_object strm) { stream_dispatch_table(strm)->force_output(strm); } void ecl_finish_output(cl_object strm) { stream_dispatch_table(strm)->finish_output(strm); } int ecl_file_column(cl_object strm) { return stream_dispatch_table(strm)->column(strm); } cl_object ecl_file_length(cl_object strm) { return stream_dispatch_table(strm)->length(strm); } cl_object ecl_file_position(cl_object strm) { return stream_dispatch_table(strm)->get_position(strm); } cl_object ecl_file_position_set(cl_object strm, cl_object pos) { return stream_dispatch_table(strm)->set_position(strm, pos); } bool ecl_input_stream_p(cl_object strm) { return stream_dispatch_table(strm)->input_p(strm); } bool ecl_output_stream_p(cl_object strm) { return stream_dispatch_table(strm)->output_p(strm); } cl_object ecl_stream_element_type(cl_object strm) { return stream_dispatch_table(strm)->element_type(strm); } int ecl_interactive_stream_p(cl_object strm) { return stream_dispatch_table(strm)->interactive_p(strm); } /* * ecl_read_char(s) tries to read a character from the stream S. It outputs * either the code of the character read, or EOF. Whe compiled with * CLOS-STREAMS and S is an instance object, STREAM-READ-CHAR is invoked * to retrieve the character. Then STREAM-READ-CHAR should either * output the character, or NIL, indicating EOF. * * INV: ecl_read_char(strm) checks the type of STRM. */ ecl_character ecl_peek_char(cl_object strm) { return stream_dispatch_table(strm)->peek_char(strm); } /*******************************tl*************************************** * SEQUENCES I/O */ void writestr_stream(const char *s, cl_object strm) { while (*s != '\0') ecl_write_char(*s++, strm); } static cl_index compute_char_size(cl_object stream, ecl_character c) { unsigned char buffer[5]; int l = 0; if (c == ECL_CHAR_CODE_NEWLINE) { int flags = stream->stream.flags; if (flags & ECL_STREAM_CR) { l += stream->stream.encoder(stream, buffer, ECL_CHAR_CODE_RETURN); if (flags & ECL_STREAM_LF) l += stream->stream.encoder(stream, buffer, ECL_CHAR_CODE_LINEFEED); } else { l += stream->stream.encoder(stream, buffer, ECL_CHAR_CODE_LINEFEED); } } else { l += stream->stream.encoder(stream, buffer, c); } return l; } cl_object cl_file_string_length(cl_object stream, cl_object string) { cl_fixnum l = 0; /* This is a stupid requirement from the spec. Why returning 1??? * Why not simply leaving the value unspecified, as with other * streams one cannot write to??? */ BEGIN: #ifdef ECL_CLOS_STREAMS if (ECL_INSTANCEP(stream)) { @(return ECL_NIL) } #endif unlikely_if (!ECL_ANSI_STREAM_P(stream)) { FEwrong_type_only_arg(@[file-string-length], stream, @[stream]); } if (stream->stream.mode == ecl_smm_broadcast) { stream = BROADCAST_STREAM_LIST(stream); if (Null(stream)) { @(return ecl_make_fixnum(1)); } else { goto BEGIN; } } unlikely_if (!ECL_FILE_STREAM_P(stream)) { not_a_file_stream(stream); } switch (ecl_t_of(string)) { #ifdef ECL_UNICODE case t_string: #endif case t_base_string: { cl_index i; for (i = 0; i < string->base_string.fillp; i++) { l += compute_char_size(stream, ecl_char(string, i)); } break; } case t_character: l = compute_char_size(stream, ECL_CHAR_CODE(string)); break; default: FEwrong_type_nth_arg(@[file-string-length], 2, string, @[string]); } @(return ecl_make_fixnum(l)) } cl_object si_do_write_sequence(cl_object seq, cl_object stream, cl_object s, cl_object e) { const struct ecl_file_ops *ops; cl_fixnum start,limit,end; /* Since we have called ecl_length(), we know that SEQ is a valid sequence. Therefore, we only need to check the type of the object, and seq == ECL_NIL i.f.f. t = t_symbol */ limit = ecl_length(seq); if (ecl_unlikely(!ECL_FIXNUMP(s) || ((start = ecl_fixnum(s)) < 0) || (start > limit))) { FEwrong_type_key_arg(@[write-sequence], @[:start], s, ecl_make_integer_type(ecl_make_fixnum(0), ecl_make_fixnum(limit-1))); } if (e == ECL_NIL) { end = limit; } else if (ecl_unlikely(!ECL_FIXNUMP(e) || ((end = ecl_fixnum(e)) < 0) || (end > limit))) { FEwrong_type_key_arg(@[write-sequence], @[:end], e, ecl_make_integer_type(ecl_make_fixnum(0), ecl_make_fixnum(limit))); } if (end <= start) { goto OUTPUT; } ops = stream_dispatch_table(stream); if (LISTP(seq)) { cl_object elt_type = cl_stream_element_type(stream); bool ischar = (elt_type == @'base-char') || (elt_type == @'character'); cl_object s = ecl_nthcdr(start, seq); loop_for_in(s) { if (start < end) { cl_object elt = CAR(s); if (ischar) ops->write_char(stream, ecl_char_code(elt)); else ops->write_byte(elt, stream); start++; } else { goto OUTPUT; } } end_loop_for_in; } else { ops->write_vector(stream, seq, start, end); } OUTPUT: @(return seq); } cl_object si_do_read_sequence(cl_object seq, cl_object stream, cl_object s, cl_object e) { const struct ecl_file_ops *ops; cl_fixnum start,limit,end; /* Since we have called ecl_length(), we know that SEQ is a valid sequence. Therefore, we only need to check the type of the object, and seq == ECL_NIL i.f.f. t = t_symbol */ limit = ecl_length(seq); if (ecl_unlikely(!ECL_FIXNUMP(s) || ((start = ecl_fixnum(s)) < 0) || (start > limit))) { FEwrong_type_key_arg(@[read-sequence], @[:start], s, ecl_make_integer_type(ecl_make_fixnum(0), ecl_make_fixnum(limit-1))); } if (e == ECL_NIL) { end = limit; } else if (ecl_unlikely(!ECL_FIXNUMP(e) || ((end = ecl_fixnum(e)) < 0) || (end > limit))) { FEwrong_type_key_arg(@[read-sequence], @[:end], e, ecl_make_integer_type(ecl_make_fixnum(0), ecl_make_fixnum(limit))); } if (end <= start) { goto OUTPUT; } ops = stream_dispatch_table(stream); if (LISTP(seq)) { cl_object elt_type = cl_stream_element_type(stream); bool ischar = (elt_type == @'base-char') || (elt_type == @'character'); seq = ecl_nthcdr(start, seq); loop_for_in(seq) { if (start >= end) { goto OUTPUT; } else { cl_object c; if (ischar) { int i = ops->read_char(stream); if (i < 0) goto OUTPUT; c = ECL_CODE_CHAR(i); } else { c = ops->read_byte(stream); if (c == ECL_NIL) goto OUTPUT; } ECL_RPLACA(seq, c); start++; } } end_loop_for_in; } else { start = ops->read_vector(stream, seq, start, end); } OUTPUT: @(return ecl_make_fixnum(start)) } /********************************************************************** * LISP LEVEL INTERFACE */ cl_object si_file_column(cl_object strm) { @(return ecl_make_fixnum(ecl_file_column(strm))) } cl_object cl_file_length(cl_object strm) { @(return ecl_file_length(strm)) } @(defun file-position (file_stream &o position) cl_object output; @ if (Null(position)) { output = ecl_file_position(file_stream); } else { if (position == @':start') { position = ecl_make_fixnum(0); } else if (position == @':end') { position = ECL_NIL; } output = ecl_file_position_set(file_stream, position); } @(return output) @) cl_object cl_input_stream_p(cl_object strm) { @(return (ecl_input_stream_p(strm) ? ECL_T : ECL_NIL)) } cl_object cl_output_stream_p(cl_object strm) { @(return (ecl_output_stream_p(strm) ? ECL_T : ECL_NIL)) } cl_object cl_interactive_stream_p(cl_object strm) { @(return (stream_dispatch_table(strm)->interactive_p(strm)? ECL_T : ECL_NIL)) } cl_object cl_open_stream_p(cl_object strm) { /* ANSI and Cltl2 specify that open-stream-p should work on closed streams, and that a stream is only closed when #'close has been applied on it */ #ifdef ECL_CLOS_STREAMS if (ECL_INSTANCEP(strm)) { return _ecl_funcall2(@'gray::open-stream-p', strm); } #endif unlikely_if (!ECL_ANSI_STREAM_P(strm)) FEwrong_type_only_arg(@'open-stream-p', strm, @'stream'); @(return (strm->stream.closed ? ECL_NIL : ECL_T)) } cl_object cl_stream_element_type(cl_object strm) { @(return ecl_stream_element_type(strm)) } cl_object cl_stream_external_format(cl_object strm) { cl_object output; cl_type t; AGAIN: t= ecl_t_of(strm); #ifdef ECL_CLOS_STREAMS if (t == t_instance) output = @':default'; else #endif unlikely_if (t != t_stream) FEwrong_type_only_arg(@[stream-external-format], strm, @[stream]); if (strm->stream.mode == ecl_smm_synonym) { strm = SYNONYM_STREAM_STREAM(strm); goto AGAIN; } output = strm->stream.format; @(return output) } cl_object cl_streamp(cl_object strm) { #ifdef ECL_CLOS_STREAMS if (ECL_INSTANCEP(strm)) { return _ecl_funcall2(@'gray::streamp', strm); } #endif @(return (ECL_ANSI_STREAM_P(strm) ? ECL_T : ECL_NIL)) } /********************************************************************** * OTHER TOOLS */ cl_object si_copy_stream(cl_object in, cl_object out) { ecl_character c; for (c = ecl_read_char(in); c != EOF; c = ecl_read_char(in)) { ecl_write_char(c, out); } ecl_force_output(out); @(return ECL_T) } /********************************************************************** * FILE OPENING AND CLOSING */ cl_fixnum ecl_normalize_stream_element_type(cl_object element_type) { cl_fixnum sign = 0; cl_index size; if (element_type == @'signed-byte' || element_type == @'ext::integer8') { return -8; } else if (element_type == @'unsigned-byte' || element_type == @'ext::byte8') { return 8; } else if (element_type == @':default') { return 0; } else if (element_type == @'base-char' || element_type == @'character') { return 0; } else if (_ecl_funcall3(@'subtypep', element_type, @'character') != ECL_NIL) { return 0; } else if (_ecl_funcall3(@'subtypep', element_type, @'unsigned-byte') != ECL_NIL) { sign = +1; } else if (_ecl_funcall3(@'subtypep', element_type, @'signed-byte') != ECL_NIL) { sign = -1; } else { FEerror("Not a valid stream element type: ~A", 1, element_type); } if (CONSP(element_type)) { if (CAR(element_type) == @'unsigned-byte') return ecl_to_size(cl_cadr(element_type)); if (CAR(element_type) == @'signed-byte') return -ecl_to_size(cl_cadr(element_type)); } for (size = 8; 1; size++) { cl_object type; type = cl_list(2, sign>0? @'unsigned-byte' : @'signed-byte', ecl_make_fixnum(size)); if (_ecl_funcall3(@'subtypep', element_type, type) != ECL_NIL) { return size * sign; } } FEerror("Not a valid stream element type: ~A", 1, element_type); } static void FEinvalid_option(cl_object option, cl_object value) { FEerror("Invalid value op option ~A: ~A", 2, option, value); } cl_object ecl_open_stream(cl_object fn, enum ecl_smmode smm, cl_object if_exists, cl_object if_does_not_exist, cl_fixnum byte_size, int flags, cl_object external_format) { cl_object output; int f; #if defined(ECL_MS_WINDOWS_HOST) ecl_mode_t mode = _S_IREAD | _S_IWRITE; #else ecl_mode_t mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH; #endif cl_object filename = si_coerce_to_filename(fn); char *fname = (char*)filename->base_string.self; bool appending = 0; bool exists = si_file_kind(filename, ECL_T) != ECL_NIL; if (smm == ecl_smm_input || smm == ecl_smm_probe) { if (!exists) { if (if_does_not_exist == @':error') { FEcannot_open(fn); } else if (if_does_not_exist == @':create') { f = safe_open(fname, O_WRONLY|O_CREAT, mode); unlikely_if (f < 0) FEcannot_open(fn); safe_close(f); } else if (Null(if_does_not_exist)) { return ECL_NIL; } else { FEinvalid_option(@':if-does-not-exist', if_does_not_exist); } } f = safe_open(fname, O_RDONLY, mode); unlikely_if (f < 0) FEcannot_open(fn); } else if (smm == ecl_smm_output || smm == ecl_smm_io) { int base = (smm == ecl_smm_output)? O_WRONLY : O_RDWR; if (if_exists == @':new_version' && if_does_not_exist == @':create') { exists = 0; if_does_not_exist = @':create'; } if (exists) { if (if_exists == @':error') { FEcannot_open(fn); } else if (if_exists == @':rename') { f = ecl_backup_open(fname, base|O_CREAT, mode); unlikely_if (f < 0) FEcannot_open(fn); } else if (if_exists == @':rename_and_delete' || if_exists == @':new_version' || if_exists == @':supersede') { f = safe_open(fname, base|O_TRUNC, mode); unlikely_if (f < 0) FEcannot_open(fn); } else if (if_exists == @':overwrite' || if_exists == @':append') { f = safe_open(fname, base, mode); unlikely_if (f < 0) FEcannot_open(fn); appending = (if_exists == @':append'); } else if (Null(if_exists)) { return ECL_NIL; } else { FEinvalid_option(@':if-exists', if_exists); } } else { if (if_does_not_exist == @':error') { FEcannot_open(fn); } else if (if_does_not_exist == @':create') { f = safe_open(fname, base | O_CREAT | O_TRUNC, mode); unlikely_if (f < 0) FEcannot_open(fn); } else if (Null(if_does_not_exist)) { return ECL_NIL; } else { FEinvalid_option(@':if-does-not-exist', if_does_not_exist); } } } else { FEerror("Illegal stream mode ~S", 1, ecl_make_fixnum(smm)); } if (flags & ECL_STREAM_C_STREAM) { FILE *fp; safe_close(f); /* We do not use fdopen() because Windows seems to * have problems with the resulting streams. Furthermore, even for * output we open with w+ because we do not want to * overwrite the file. */ switch (smm) { case ecl_smm_probe: case ecl_smm_input: fp = safe_fopen(fname, OPEN_R); break; case ecl_smm_output: case ecl_smm_io: fp = safe_fopen(fname, OPEN_RW); break; default:; /* never reached */ } output = ecl_make_stream_from_FILE(fn, fp, smm, byte_size, flags, external_format); si_set_buffering_mode(output, byte_size? @':full' : @':line'); } else { output = ecl_make_file_stream_from_fd(fn, f, smm, byte_size, flags, external_format); } if (smm == ecl_smm_probe) { cl_close(1, output); } else { output->stream.flags |= ECL_STREAM_MIGHT_SEEK; si_set_finalizer(output, ECL_T); /* Set file pointer to the correct position */ ecl_file_position_set(output, appending? ECL_NIL : ecl_make_fixnum(0)); } return output; } @(defun open (filename &key (direction @':input') (element_type @'character') (if_exists ECL_NIL iesp) (if_does_not_exist ECL_NIL idnesp) (external_format @':default') (cstream ECL_T) &aux strm) enum ecl_smmode smm; int flags = 0; cl_fixnum byte_size; @ /* INV: ecl_open_stream() checks types */ if (direction == @':input') { smm = ecl_smm_input; if (!idnesp) if_does_not_exist = @':error'; } else if (direction == @':output') { smm = ecl_smm_output; if (!iesp) if_exists = @':new_version'; if (!idnesp) { if (if_exists == @':overwrite' || if_exists == @':append') if_does_not_exist = @':error'; else if_does_not_exist = @':create'; } } else if (direction == @':io') { smm = ecl_smm_io; if (!iesp) if_exists = @':new_version'; if (!idnesp) { if (if_exists == @':overwrite' || if_exists == @':append') if_does_not_exist = @':error'; else if_does_not_exist = @':create'; } } else if (direction == @':probe') { smm = ecl_smm_probe; if (!idnesp) if_does_not_exist = ECL_NIL; } else { FEerror("~S is an illegal DIRECTION for OPEN.", 1, direction); } byte_size = ecl_normalize_stream_element_type(element_type); if (byte_size != 0) { external_format = ECL_NIL; } if (!Null(cstream)) { flags |= ECL_STREAM_C_STREAM; } strm = ecl_open_stream(filename, smm, if_exists, if_does_not_exist, byte_size, flags, external_format); @(return strm) @) @(defun close (strm &key (abort @'nil')) @ @(return stream_dispatch_table(strm)->close(strm)); @) /********************************************************************** * BACKEND */ static int file_listen(cl_object stream, int fileno) { #if !defined(ECL_MS_WINDOWS_HOST) # if defined(HAVE_SELECT) fd_set fds; int retv; struct timeval tv = { 0, 0 }; /* * Note that the following code is fragile. If the file is closed (/dev/null) * then select() may return 1 (at least on OS X), so that we return a flag * saying characters are available but will find none to read. See also the * code in cl_clear_input(). */ FD_ZERO(&fds); FD_SET(fileno, &fds); retv = select(fileno + 1, &fds, NULL, NULL, &tv); if (ecl_unlikely(retv < 0)) file_libc_error(@[stream-error], stream, "Error while listening to stream.", 0); else if (retv > 0) return ECL_LISTEN_AVAILABLE; else return ECL_LISTEN_NO_CHAR; # elif defined(FIONREAD) { long c = 0; ioctl(fileno, FIONREAD, &c); return (c > 0)? ECL_LISTEN_AVAILABLE : ECL_LISTEN_NO_CHAR; } # endif /* FIONREAD */ #else HANDLE hnd = (HANDLE)_get_osfhandle(fileno); switch (GetFileType(hnd)) { case FILE_TYPE_CHAR: { DWORD dw, dw_read, cm; if (GetNumberOfConsoleInputEvents(hnd, &dw)) { unlikely_if (!GetConsoleMode(hnd, &cm)) FEwin32_error("GetConsoleMode() failed", 0); if (dw > 0) { PINPUT_RECORD recs = (PINPUT_RECORD)GC_malloc(sizeof(INPUT_RECORD)*dw); int i; unlikely_if (!PeekConsoleInput(hnd, recs, dw, &dw_read)) FEwin32_error("PeekConsoleInput failed()", 0); if (dw_read > 0) { if (cm & ENABLE_LINE_INPUT) { for (i=0; i 0 ? ECL_LISTEN_AVAILABLE : ECL_LISTEN_NO_CHAR); else if (GetLastError() == ERROR_BROKEN_PIPE) return ECL_LISTEN_EOF; else FEwin32_error("PeekNamedPipe() failed", 0); break; } default: FEerror("Unsupported Windows file type: ~A", 1, ecl_make_fixnum(GetFileType(hnd))); break; } #endif return -3; } static int flisten(cl_object stream, FILE *fp) { int aux; if (feof(fp)) return ECL_LISTEN_EOF; #ifdef FILE_CNT if (FILE_CNT(fp) > 0) return ECL_LISTEN_AVAILABLE; #endif aux = file_listen(stream, fileno(fp)); if (aux != -3) return aux; /* This code is portable, and implements the expected behavior for regular files. It will fail on noninteractive streams. */ { /* regular file */ ecl_off_t old_pos = ecl_ftello(fp), end_pos; unlikely_if (ecl_fseeko(fp, 0, SEEK_END) != 0) file_libc_error(@[file-error], stream, "Unable to check file position", 0); end_pos = ecl_ftello(fp); unlikely_if (ecl_fseeko(fp, old_pos, SEEK_SET) != 0) file_libc_error(@[file-error], stream, "Unable to check file position", 0); return (end_pos > old_pos ? ECL_LISTEN_AVAILABLE : ECL_LISTEN_EOF); } return !ECL_LISTEN_AVAILABLE; } cl_object ecl_off_t_to_integer(ecl_off_t offset) { cl_object output; if (sizeof(ecl_off_t) == sizeof(cl_fixnum)) { output = ecl_make_integer(offset); } else if (offset <= MOST_POSITIVE_FIXNUM) { output = ecl_make_fixnum((cl_fixnum)offset); } else { cl_object y = _ecl_big_register0(); if (sizeof(ECL_BIGNUM_LIMBS(y)[0]) == sizeof(cl_index)) { ECL_BIGNUM_LIMBS(y)[0] = (cl_index)offset; offset >>= ECL_FIXNUM_BITS; ECL_BIGNUM_LIMBS(y)[1] = offset; ECL_BIGNUM_SIZE(y) = offset? 2 : 1; } else if (sizeof(ECL_BIGNUM_LIMBS(y)[0]) >= sizeof(ecl_off_t)) { ECL_BIGNUM_LIMBS(y)[0] = offset; ECL_BIGNUM_SIZE(y) = 1; } output = _ecl_big_register_normalize(y); } return output; } ecl_off_t ecl_integer_to_off_t(cl_object offset) { ecl_off_t output = 0; if (sizeof(ecl_off_t) == sizeof(cl_fixnum)) { output = fixint(offset); } else if (ECL_FIXNUMP(offset)) { output = fixint(offset); } else if (ECL_BIGNUMP(offset)) { if (sizeof(ECL_BIGNUM_LIMBS(offset)[0]) == sizeof(cl_index)) { if (ECL_BIGNUM_SIZE(offset) > 2) { goto ERROR; } if (ECL_BIGNUM_SIZE(offset) == 2) { output = ECL_BIGNUM_LIMBS(offset)[1]; output <<= ECL_FIXNUM_BITS; } output += ECL_BIGNUM_LIMBS(offset)[0]; } else if (sizeof(ECL_BIGNUM_LIMBS(offset)[0]) >= sizeof(ecl_off_t)) { if (ECL_BIGNUM_SIZE(offset) > 1) { goto ERROR; } output = ECL_BIGNUM_LIMBS(offset)[0]; } } else { ERROR: FEerror("Not a valid file offset: ~S", 1, offset); } return output; } static cl_object alloc_stream() { cl_object x = ecl_alloc_object(t_stream); x->stream.closed = 0; x->stream.file.descriptor = -1; x->stream.object0 = x->stream.object1 = OBJNULL; x->stream.int0 = x->stream.int1 = 0; x->stream.format = ECL_NIL; x->stream.flags = 0; x->stream.byte_size = 8; x->stream.buffer = NULL; x->stream.encoder = NULL; x->stream.decoder = NULL; x->stream.last_char = EOF; x->stream.byte_stack = ECL_NIL; x->stream.last_code[0] = x->stream.last_code[1] = EOF; x->stream.eof_char = EOF; return x; } /********************************************************************** * ERROR MESSAGES */ static cl_object not_a_file_stream(cl_object strm) { return cl_error(9, @'simple-type-error', @':format-control', make_constant_base_string("~A is not an file stream"), @':format-arguments', cl_list(1, strm), @':expected-type', @'file-stream', @':datum', strm); } static void not_an_input_stream(cl_object strm) { cl_error(9, @'simple-type-error', @':format-control', make_constant_base_string("~A is not an input stream"), @':format-arguments', cl_list(1, strm), @':expected-type', cl_list(2, @'satisfies', @'input-stream-p'), @':datum', strm); } static void not_an_output_stream(cl_object strm) { cl_error(9, @'simple-type-error', @':format-control', make_constant_base_string("~A is not an output stream"), @':format-arguments', cl_list(1, strm), @':expected-type', cl_list(2, @'satisfies', @'output-stream-p'), @':datum', strm); } static void not_a_character_stream(cl_object s) { cl_error(9, @'simple-type-error', @':format-control', make_constant_base_string("~A is not a character stream"), @':format-arguments', cl_list(1, s), @':expected-type', @'character', @':datum', cl_stream_element_type(s)); } static void not_a_binary_stream(cl_object s) { cl_error(9, @'simple-type-error', @':format-control', make_constant_base_string("~A is not a binary stream"), @':format-arguments', cl_list(1, s), @':expected-type', @'integer', @':datum', cl_stream_element_type(s)); } static void cannot_close(cl_object stream) { file_libc_error(@[file-error], stream, "Stream cannot be closed", 0); } static void file_libc_error(cl_object error_type, cl_object stream, const char *msg, int narg, ...) { ecl_va_list args; cl_object rest, error = _ecl_strerror(errno); ecl_va_start(args, narg, narg, 0); rest = cl_grab_rest_args(args); si_signal_simple_error(4, (cl_object)(cl_symbols + ecl_fixnum(error_type)), Cnil, make_constant_base_string("~?~%C library explanation: ~A."), cl_list(3, make_constant_base_string(msg), rest, error)); } static void unread_error(cl_object s) { CEerror(ECL_T, "Error when using UNREAD-CHAR on stream ~D", 1, s); } static void unread_twice(cl_object s) { CEerror(ECL_T, "Used UNREAD-CHAR twice on stream ~D", 1, s); } static void maybe_clearerr(cl_object strm) { int t = strm->stream.mode; if (t == ecl_smm_io || t == ecl_smm_output || t == ecl_smm_input) { FILE *f = IO_STREAM_FILE(strm); if (f != NULL) clearerr(f); } } static int restartable_io_error(cl_object strm, const char *s) { cl_env_ptr the_env = ecl_process_env(); volatile int old_errno = errno; /* ecl_disable_interrupts(); ** done by caller */ maybe_clearerr(strm); ecl_enable_interrupts_env(the_env); if (old_errno == EINTR) { return 1; } else { file_libc_error(@[stream-error], strm, "C operation (~A) signaled an error.", 1, ecl_make_constant_base_string(s, strlen(s))); return 0; } } static void io_error(cl_object strm) { cl_env_ptr the_env = ecl_process_env(); /* ecl_disable_interrupts(); ** done by caller */ maybe_clearerr(strm); ecl_enable_interrupts_env(the_env); file_libc_error(@[stream-error], strm, "Read or write operation signaled an error", 0); } static void wrong_file_handler(cl_object strm) { FEerror("Internal error: stream ~S has no valid C file handler.", 1, strm); } #ifdef ECL_UNICODE static cl_index encoding_error(cl_object stream, unsigned char *buffer, ecl_character c) { cl_object code = _ecl_funcall4(@'ext::encoding-error', stream, cl_stream_external_format(stream), ecl_make_integer(c)); if (Null(code)) { /* Output nothing */ return 0; } else { /* Try with supplied character */ return stream->stream.encoder(stream, buffer, ecl_char_code(code)); } } static ecl_character decoding_error(cl_object stream, unsigned char *buffer, int length) { cl_object octets = ECL_NIL, code; while (length > 0) { octets = CONS(ecl_make_fixnum(buffer[--length]), octets); } code = _ecl_funcall4(@'ext::decoding-error', stream, cl_stream_external_format(stream), octets); if (Null(code)) { /* Go for next character */ return stream->stream.decoder(stream); } else { /* Return supplied character */ return ecl_char_code(code); } } #endif #if defined(ECL_WSOCK) static void wsock_error( const char *err_msg, cl_object strm ) { char *msg; cl_object msg_obj; /* ecl_disable_interrupts(); ** done by caller */ { FormatMessage( FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ALLOCATE_BUFFER, 0, WSAGetLastError(), 0, ( void* )&msg, 0, NULL ); msg_obj = make_base_string_copy( msg ); LocalFree( msg ); } ecl_enable_interrupts(); FEerror( err_msg, 2, strm, msg_obj ); } #endif void init_file(void) { int flags; cl_object standard_input; cl_object standard_output; cl_object error_output; cl_object aux; cl_object null_stream; cl_object external_format = ECL_NIL; #if defined(ECL_MS_WINDOWS_HOST) # ifdef ECL_UNICODE external_format = cl_list(2, @':latin-1', @':crlf'); flags = 0; # else external_format = cl_list(2, @':crlf', @':pass-through'); flags = ECL_STREAM_DEFAULT_FORMAT; # endif #else flags = ECL_STREAM_DEFAULT_FORMAT; #endif null_stream = ecl_make_stream_from_FILE(make_constant_base_string("/dev/null"), NULL, ecl_smm_io, 8, flags, external_format); generic_close(null_stream); null_stream = cl_make_two_way_stream(null_stream, cl_make_broadcast_stream(0)); cl_core.null_stream = null_stream; /* We choose C streams by default only when _not_ using threads. * The reason is that C streams block on I/O operations. */ #if !defined(ECL_THREADS) standard_input = maybe_make_windows_console_FILE(make_constant_base_string("stdin"), stdin, ecl_smm_input, 8, flags, external_format); standard_output = maybe_make_windows_console_FILE(make_constant_base_string("stdout"), stdout, ecl_smm_output, 8, flags, external_format); error_output = maybe_make_windows_console_FILE(make_constant_base_string("stderr"), stderr, ecl_smm_output, 8, flags, external_format); #else standard_input = maybe_make_windows_console_fd(make_constant_base_string("stdin"), STDIN_FILENO, ecl_smm_input_file, 8, flags, external_format); standard_output = maybe_make_windows_console_fd(make_constant_base_string("stdout"), STDOUT_FILENO, ecl_smm_output_file, 8, flags, external_format); error_output = maybe_make_windows_console_fd(make_constant_base_string("stderr"), STDERR_FILENO, ecl_smm_output_file, 8, flags, external_format); #endif cl_core.standard_input = standard_input; ECL_SET(@'ext::+process-standard-input+', standard_input); ECL_SET(@'*standard-input*', standard_input); cl_core.standard_output = standard_output; ECL_SET(@'ext::+process-standard-output+', standard_output); ECL_SET(@'*standard-output*', standard_output); ECL_SET(@'*trace-output*', standard_output); cl_core.error_output = error_output; ECL_SET(@'ext::+process-error-output+', error_output); ECL_SET(@'*error-output*', error_output); cl_core.terminal_io = aux = cl_make_two_way_stream(standard_input, standard_output); ECL_SET(@'*terminal-io*', aux); aux = cl_make_synonym_stream(@'*terminal-io*'); ECL_SET(@'*query-io*', aux); ECL_SET(@'*debug-io*', aux); } ecl-16.1.2/src/c/format.d000066400000000000000000002246701266352375300150410ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* format.c -- Format. */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #include #define ECL_INCLUDE_MATH_H #include #include #include #include #if !defined(ECL_CMU_FORMAT) #warning "The old version of FORMAT is not ANSI compliant" #define FMT_MAX_PARAM 8 typedef struct format_stack_struct { cl_object stream; cl_object aux_stream; cl_object aux_string; cl_index ctl_index, ctl_end; cl_object ctl_str; cl_object args, current; jmp_buf *jmp_buf; cl_index indents; cl_index spare_spaces; cl_index line_length; cl_object param[FMT_MAX_PARAM]; int nparam; } *format_stack; #if MOST_POSITIVE_FIXNUM_VAL < INT_MAX # define FMT_VALUE_UPPER_LIMIT MOST_POSITIVE_FIXNUM #else # define FMT_VALUE_UPPER_LIMIT INT_MAX #endif #if MOST_NEGATIVE_FIXNUM_VAL > INT_MIN # define FMT_VALUE_LOWER_LIMIT MOST_NEGATIVE_FIXNUM #else # define FMT_VALUE_LOWER_LIMIT INT_MIN #endif /******************* COMMON ***************************/ #define NONE 0 #define INT 1 #define CHAR 2 static const char *fmt_big_numeral[] = { "thousand", "million", "billion", "trillion", "quadrillion", "quintillion", "sextillion", "septillion", "octillion" }; static const char *fmt_numeral[] = { "zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen", "zero", "ten", "twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety" }; static const char *fmt_ordinal[] = { "zeroth", "first", "second", "third", "fourth", "fifth", "sixth", "seventh", "eighth", "ninth", "tenth", "eleventh", "twelfth", "thirteenth", "fourteenth", "fifteenth", "sixteenth", "seventeenth", "eighteenth", "nineteenth", "zeroth", "tenth", "twentieth", "thirtieth", "fortieth", "fiftieth", "sixtieth", "seventieth", "eightieth", "ninetieth" }; static void format(format_stack, cl_index, cl_index); static cl_object doformat(cl_narg narg, cl_object strm, cl_object string, ecl_va_list args, bool in_formatter); static cl_object get_aux_stream(void) { cl_env_ptr env = ecl_process_env(); cl_object stream; ecl_disable_interrupts_env(env); if (env->fmt_aux_stream == ECL_NIL) { stream = ecl_make_string_output_stream(64, 1); } else { stream = env->fmt_aux_stream; env->fmt_aux_stream = ECL_NIL; } ecl_enable_interrupts_env(env); return stream; } static void fmt_error(format_stack fmt, const char *s) { cl_error(7, @'si::format-error', @':format-control', make_constant_base_string(s), @':control-string', fmt->ctl_str, @':offset', ecl_make_fixnum(fmt->ctl_index)); } static ecl_character tempstr(format_stack fmt, int s) { return ecl_char(fmt->aux_string,s); } static ecl_character ctl_advance(format_stack fmt) { if (fmt->ctl_index >= fmt->ctl_end) fmt_error(fmt, "unexpected end of control string"); return ecl_char(fmt->ctl_str, fmt->ctl_index++); } static void fmt_go(format_stack fmt, cl_fixnum n) { cl_object p; if (n < 0) fmt_error(fmt, "can't goto"); if ((p = ecl_nthcdr(n, fmt->args)) == ECL_NIL) fmt_error(fmt, "can't goto"); fmt->current = p; } static cl_index fmt_index(format_stack fmt) { cl_object p = fmt->args, target = fmt->current; cl_index n = 0; if (target == ECL_NIL) return ecl_length(p); while (p != fmt->current) { p = CDR(p); if (p == ECL_NIL) fmt_error(fmt, "Overflow"); n++; } return n; } static cl_object fmt_back_up(format_stack fmt) { fmt_go(fmt, fmt_index(fmt) - 1); } static bool fmt_more_args_p(format_stack fmt) { return fmt->current != ECL_NIL; } static cl_index fmt_args_left(format_stack fmt) { return ecl_length(fmt->current); } static cl_object fmt_advance(format_stack fmt) { cl_object output, l = fmt->current; if (l == ECL_NIL) fmt_error(fmt, "arguments exhausted"); output = CAR(l); fmt->current = CDR(l); return output; } static void fmt_set_arg_list(format_stack fmt, cl_object l) { assert_type_proper_list(l); fmt->current = fmt->args = cl_copy_list(l); } static int fmt_skip(format_stack fmt) { ecl_character c; int level = 0; LOOP: if (ctl_advance(fmt) != '~') goto LOOP; for (;;) switch (c = ctl_advance(fmt)) { case '\'': ctl_advance(fmt); case ',': case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': case '+': case '-': case 'v': case 'V': case '#': case ':': case '@@': continue; default: goto DIRECTIVE; } DIRECTIVE: switch (c) { case '(': case '[': case '<': case '{': level++; break; case ')': case ']': case '>': case '}': if (level == 0) return(fmt->ctl_index); else --level; break; case ';': if (level == 0) return(fmt->ctl_index); break; } goto LOOP; } static void ensure_param(format_stack fmt, int n) { if (fmt->nparam > n) fmt_error(fmt, "too many parameters"); while (n-- > fmt->nparam) fmt->param[n] = ECL_NIL; } static void fmt_not_colon(format_stack fmt, bool colon) { if (colon) fmt_error(fmt, "illegal :"); } static void fmt_not_atsign(format_stack fmt, bool atsign) { if (atsign) fmt_error(fmt, "illegal @@"); } static void fmt_not_colon_atsign(format_stack fmt, bool colon, bool atsign) { if (colon && atsign) fmt_error(fmt, "illegal :@@"); } static cl_object set_param(format_stack fmt, int i, int t, cl_object v) { if (i >= fmt->nparam || fmt->param[i] == ECL_NIL) return v; else if ((t != INT && t != CHAR) || (t == INT && !cl_integerp(fmt->param[i])) || (t == CHAR && !ECL_CHARACTERP(fmt->param[i]))) fmt_error(fmt, "illegal parameter type"); return fmt->param[i]; } static int set_param_positive(format_stack fmt, int i, const char *message) { if (i >= fmt->nparam || fmt->param[i] == ECL_NIL) return -1; else if (cl_integerp(fmt->param[i]) == ECL_NIL) fmt_error(fmt, "illegal parameter type"); else { cl_object p = fmt->param[i]; if (ecl_minusp(p)) fmt_error(fmt, message); return ecl_to_fix(p); } } static void fmt_copy(format_stack fmt_copy, format_stack fmt) { *fmt_copy = *fmt; } static void fmt_copy1(format_stack fmt_copy, format_stack fmt) { fmt_copy->stream = fmt->stream; fmt_copy->ctl_str = fmt->ctl_str; fmt_copy->ctl_index = fmt->ctl_index; fmt_copy->ctl_end = fmt->ctl_end; fmt_copy->jmp_buf = fmt->jmp_buf; fmt_copy->indents = fmt->indents; } static void fmt_prepare_aux_stream(format_stack fmt) { fmt->aux_string->base_string.fillp = 0; fmt->aux_stream->stream.int0 = ecl_file_column(fmt->stream); fmt->aux_stream->stream.int1 = ecl_file_column(fmt->stream); } static void fmt_ascii(format_stack fmt, bool colon, bool atsign) { int mincol, colinc, minpad; ecl_character padchar; cl_object x; int l, i; ensure_param(fmt, 4); mincol = ecl_to_fix(set_param(fmt, 0, INT, ecl_make_fixnum(0))); colinc = ecl_to_fix(set_param(fmt, 1, INT, ecl_make_fixnum(1))); minpad = ecl_to_fix(set_param(fmt, 2, INT, ecl_make_fixnum(0))); padchar = ECL_CHAR_CODE(set_param(fmt, 3, CHAR, ECL_CODE_CHAR(' '))); fmt_prepare_aux_stream(fmt); x = fmt_advance(fmt); if (colon && Null(x)) writestr_stream("()", fmt->aux_stream); else if (mincol == 0 && minpad == 0) { ecl_princ(x, fmt->stream); return; } else ecl_princ(x, fmt->aux_stream); l = fmt->aux_string->base_string.fillp; for (i = minpad; l + i < mincol; i += colinc) ; if (!atsign) { ecl_write_string(fmt->aux_string, fmt->stream); while (i-- > 0) ecl_write_char(padchar, fmt->stream); } else { while (i-- > 0) ecl_write_char(padchar, fmt->stream); ecl_write_string(fmt->aux_string, fmt->stream); } } static void fmt_S_expression(format_stack fmt, bool colon, bool atsign) { int mincol, colinc, minpad; ecl_character padchar; cl_object x; int l, i; ensure_param(fmt, 4); mincol = ecl_to_fix(set_param(fmt, 0, INT, ecl_make_fixnum(0))); colinc = ecl_to_fix(set_param(fmt, 1, INT, ecl_make_fixnum(1))); minpad = ecl_to_fix(set_param(fmt, 2, INT, ecl_make_fixnum(0))); padchar = ECL_CHAR_CODE(set_param(fmt, 3, CHAR, ECL_CODE_CHAR(' '))); fmt_prepare_aux_stream(fmt); x = fmt_advance(fmt); if (colon && Null(x)) writestr_stream("()", fmt->aux_stream); else if (mincol == 0 && minpad == 0) { ecl_prin1(x, fmt->stream); return; } else ecl_prin1(x, fmt->aux_stream); l = fmt->aux_string->base_string.fillp; for (i = minpad; l + i < mincol; i += colinc) ; if (!atsign) { ecl_write_string(fmt->aux_string, fmt->stream); while (i-- > 0) ecl_write_char(padchar, fmt->stream); } else { while (i-- > 0) ecl_write_char(padchar, fmt->stream); ecl_write_string(fmt->aux_string, fmt->stream); } } static void fmt_integer(format_stack fmt, cl_object x, bool colon, bool atsign, int radix, int mincol, ecl_character padchar, ecl_character commachar) { const cl_env_ptr env = ecl_process_env(); int l, l1; int s; if (!ECL_FIXNUMP(x) && ecl_t_of(x) != t_bignum) { fmt_prepare_aux_stream(fmt); ecl_bds_bind(env, @'*print-escape*', ECL_NIL); ecl_bds_bind(env, @'*print-base*', ecl_make_fixnum(radix)); si_write_object(x, fmt->aux_stream); ecl_bds_unwind_n(env, 2); l = fmt->aux_string->base_string.fillp; mincol -= l; while (mincol-- > 0) ecl_write_char(padchar, fmt->stream); ecl_write_string(fmt->aux_string, fmt->stream); return; } fmt_prepare_aux_stream(fmt); ecl_bds_bind(env, @'*print-radix*', ECL_NIL); ecl_bds_bind(env, @'*print-base*', ecl_make_fixnum(radix)); si_write_object(x, fmt->aux_stream); ecl_bds_unwind_n(env, 2); l = l1 = fmt->aux_string->base_string.fillp; s = 0; if (tempstr(fmt, s) == '-') --l1; mincol -= l; if (colon) mincol -= (l1 - 1)/3; if (atsign && tempstr(fmt, s) != '-') --mincol; while (mincol-- > 0) ecl_write_char(padchar, fmt->stream); if (tempstr(fmt, s) == '-') { s++; ecl_write_char('-', fmt->stream); } else if (atsign) ecl_write_char('+', fmt->stream); while (l1-- > 0) { ecl_write_char(tempstr(fmt, s++), fmt->stream); if (colon && l1 > 0 && l1%3 == 0) ecl_write_char(commachar, fmt->stream); } } static void fmt_decimal(format_stack fmt, bool colon, bool atsign) { int mincol; ecl_character padchar, commachar; ensure_param(fmt, 3); mincol = ecl_to_fix(set_param(fmt, 0, INT, ecl_make_fixnum(0))); padchar = ECL_CHAR_CODE(set_param(fmt, 1, CHAR, ECL_CODE_CHAR(' '))); commachar = ECL_CHAR_CODE(set_param(fmt, 2, CHAR, ECL_CODE_CHAR(','))); fmt_integer(fmt, fmt_advance(fmt), colon, atsign, 10, mincol, padchar, commachar); } static void fmt_binary(format_stack fmt, bool colon, bool atsign) { int mincol; ecl_character padchar, commachar; ensure_param(fmt, 3); mincol = ecl_to_fix(set_param(fmt, 0, INT, ecl_make_fixnum(0))); padchar = ECL_CHAR_CODE(set_param(fmt, 1, CHAR, ECL_CODE_CHAR(' '))); commachar = ECL_CHAR_CODE(set_param(fmt, 2, CHAR, ECL_CODE_CHAR(','))); fmt_integer(fmt, fmt_advance(fmt), colon, atsign, 2, mincol, padchar, commachar); } static void fmt_octal(format_stack fmt, bool colon, bool atsign) { int mincol; ecl_character padchar, commachar; ensure_param(fmt, 3); mincol = ecl_to_fix(set_param(fmt, 0, INT, ecl_make_fixnum(0))); padchar = ECL_CHAR_CODE(set_param(fmt, 1, CHAR, ECL_CODE_CHAR(' '))); commachar = ECL_CHAR_CODE(set_param(fmt, 2, CHAR, ECL_CODE_CHAR(','))); fmt_integer(fmt, fmt_advance(fmt), colon, atsign, 8, mincol, padchar, commachar); } static void fmt_hexadecimal(format_stack fmt, bool colon, bool atsign) { int mincol; ecl_character padchar, commachar; ensure_param(fmt, 3); mincol = ecl_to_fix(set_param(fmt, 0, INT, ecl_make_fixnum(0))); padchar = ECL_CHAR_CODE(set_param(fmt, 1, CHAR, ECL_CODE_CHAR(' '))); commachar = ECL_CHAR_CODE(set_param(fmt, 2, CHAR, ECL_CODE_CHAR(','))); fmt_integer(fmt, fmt_advance(fmt), colon, atsign, 16, mincol, padchar, commachar); } static void fmt_write_numeral(format_stack fmt, int s, int i) { writestr_stream(fmt_numeral[tempstr(fmt, s) - '0' + i], fmt->stream); } static void fmt_write_ordinal(format_stack fmt, int s, int i) { writestr_stream(fmt_ordinal[tempstr(fmt, s) - '0' + i], fmt->stream); } static bool fmt_thousand(format_stack fmt, int s, int i, bool b, bool o, int t) { if (i == 3 && tempstr(fmt, s) > '0') { if (b) ecl_write_char(' ', fmt->stream); fmt_write_numeral(fmt, s, 0); writestr_stream(" hundred", fmt->stream); --i; s++; b = TRUE; if (o && (s > t)) writestr_stream("th", fmt->stream); } if (i == 3) { --i; s++; } if (i == 2 && tempstr(fmt, s) > '0') { if (b) ecl_write_char(' ', fmt->stream); if (tempstr(fmt, s) == '1') { if (o && (s + 2 > t)) fmt_write_ordinal(fmt, ++s, 10); else fmt_write_numeral(fmt, ++s, 10); return(TRUE); } else { if (o && (s + 1 > t)) fmt_write_ordinal(fmt, s, 20); else fmt_write_numeral(fmt, s, 20); s++; if (tempstr(fmt, s) > '0') { ecl_write_char('-', fmt->stream); if (o && s + 1 > t) fmt_write_ordinal(fmt, s, 0); else fmt_write_numeral(fmt, s, 0); } return(TRUE); } } if (i == 2) s++; if (tempstr(fmt, s) > '0') { if (b) ecl_write_char(' ', fmt->stream); if (o && s + 1 > t) fmt_write_ordinal(fmt, s, 0); else fmt_write_numeral(fmt, s, 0); return(TRUE); } return(b); } static bool fmt_nonillion(format_stack fmt, int s, int i, bool b, bool o, int t) { int j; for (; i > 3; i -= j) { b = fmt_thousand(fmt, s, j = (i+2)%3+1, b, FALSE, t); if (j != 3 || tempstr(fmt, s) != '0' || tempstr(fmt, s+1) != '0' || tempstr(fmt, s+2) != '0') { ecl_write_char(' ', fmt->stream); writestr_stream(fmt_big_numeral[(i - 1)/3 - 1], fmt->stream); s += j; if (o && s > t) writestr_stream("th", fmt->stream); } else s += j; } return(fmt_thousand(fmt, s, i, b, o, t)); } static void fmt_roman(format_stack fmt, int i, int one, int five, int ten, bool colon) { int j; if (i == 0) return; if ((!colon && i < 4) || (colon && i < 5)) for (j = 0; j < i; j++) ecl_write_char(one, fmt->stream); else if (!colon && i == 4) { ecl_write_char(one, fmt->stream); ecl_write_char(five, fmt->stream); } else if ((!colon && i < 9) || colon) { ecl_write_char(five, fmt->stream); for (j = 5; j < i; j++) ecl_write_char(one, fmt->stream); } else if (!colon && i == 9) { ecl_write_char(one, fmt->stream); ecl_write_char(ten, fmt->stream); } } static void fmt_radix(format_stack fmt, bool colon, bool atsign) { const cl_env_ptr env = ecl_process_env(); int radix, mincol; ecl_character padchar, commachar; cl_object x; int i, j, k; int s, t; bool b; if (fmt->nparam == 0) { x = fmt_advance(fmt); assert_type_integer(x); if (atsign) { if (ECL_FIXNUMP(x)) i = ecl_fixnum(x); else i = -1; if ((!colon && (i <= 0 || i >= 4000)) || (colon && (i <= 0 || i >= 5000))) { fmt_integer(fmt, x, FALSE, FALSE, 10, 0, ' ', ','); return; } fmt_roman(fmt, i/1000, 'M', '*', '*', colon); fmt_roman(fmt, i%1000/100, 'C', 'D', 'M', colon); fmt_roman(fmt, i%100/10, 'X', 'L', 'C', colon); fmt_roman(fmt, i%10, 'I', 'V', 'X', colon); return; } fmt_prepare_aux_stream(fmt); ecl_bds_bind(env, @'*print-radix*', ECL_NIL); ecl_bds_bind(env, @'*print-base*', ecl_make_fixnum(10)); si_write_object(x, fmt->aux_stream); ecl_bds_unwind_n(env, 2); s = 0; i = fmt->aux_string->base_string.fillp; if (i == 1 && tempstr(fmt, s) == '0') { writestr_stream("zero", fmt->stream); if (colon) writestr_stream("th", fmt->stream); return; } else if (tempstr(fmt, s) == '-') { writestr_stream("minus ", fmt->stream); --i; s++; } t = fmt->aux_string->base_string.fillp; for (; tempstr(fmt, --t) == '0' ;) ; for (b = FALSE; i > 0; i -= j) { b = fmt_nonillion(fmt, s, j = (i+29)%30+1, b, i<=30&&colon, t); s += j; if (b && i > 30) { for (k = (i - 1)/30; k > 0; --k) writestr_stream(" nonillion", fmt->stream); if (colon && s > t) writestr_stream("th", fmt->stream); } } return; } ensure_param(fmt, 4); radix = ecl_to_fix(set_param(fmt, 0, INT, ecl_make_fixnum(10))); mincol = ecl_to_fix(set_param(fmt, 1, INT, ecl_make_fixnum(0))); padchar = ECL_CHAR_CODE(set_param(fmt, 2, CHAR, ECL_CODE_CHAR(' '))); commachar = ECL_CHAR_CODE(set_param(fmt, 3, CHAR, ECL_CODE_CHAR(','))); x = fmt_advance(fmt); assert_type_integer(x); if (radix < 0 || radix > 36) FEerror("~D is illegal as a radix.", 1, ecl_make_fixnum(radix)); fmt_integer(fmt, x, colon, atsign, radix, mincol, padchar, commachar); } static void fmt_plural(format_stack fmt, bool colon, bool atsign) { ensure_param(fmt, 0); if (colon) { fmt_back_up(fmt); } if (ecl_eql(fmt_advance(fmt), ecl_make_fixnum(1))) { if (atsign) ecl_write_char('y', fmt->stream); } else if (atsign) writestr_stream("ies", fmt->stream); else ecl_write_char('s', fmt->stream); } static void fmt_character(format_stack fmt, bool colon, bool atsign) { cl_object x; cl_index i; ensure_param(fmt, 0); x = fmt_advance(fmt); x = ecl_check_cl_type(@'format',x,t_character); if (!colon && !atsign) { ecl_write_char(ECL_CHAR_CODE(x), fmt->stream); } else { fmt_prepare_aux_stream(fmt); ecl_prin1(x, fmt->aux_stream); if (!colon && atsign) i = 0; else i = 2; for (; i < fmt->aux_string->base_string.fillp; i++) ecl_write_char(tempstr(fmt, i), fmt->stream); } } /* The floating point precision is required to make the most-positive-long-float printed expression readable. If this is too small, then the rounded off fraction, may be too big to read */ /* Maximum number of significant digits required to represent accurately * a double or single float. */ #define LOG10_2 0.30103 #define DBL_SIG ((int)(DBL_MANT_DIG * LOG10_2 + 1)) #define FLT_SIG ((int)(FLT_MANT_DIG * LOG10_2 + 1)) /* This is the maximum number of decimal digits that our numbers will have. * Notice that we leave some extra margin, to ensure that reading the number * again will produce the same floating point number. */ #ifdef ECL_LONG_FLOAT # define LDBL_SIG ((int)(LDBL_MANT_DIG * LOG10_2 + 1)) # define DBL_MAX_DIGITS (LDBL_SIG + 3) # define DBL_EXPONENT_SIZE (1 + 1 + 4) #else # define DBL_MAX_DIGITS (DBL_SIG + 3) # define DBL_EXPONENT_SIZE (1 + 1 + 3) /* Exponent marker 'e' + sign + digits .*/ #endif /* The sinificant digits + the possible sign + the decimal dot. */ #define DBL_MANTISSA_SIZE (DBL_MAX_DIGITS + 1 + 1) /* Total estimated size that a floating point number can take. */ #define DBL_SIZE (DBL_MANTISSA_SIZE + DBL_EXPONENT_SIZE) #ifdef ECL_LONG_FLOAT #define EXP_STRING "Le" #define G_EXP_STRING "Lg" #define DBL_TYPE long double #define strtod strtold extern long double strtold(const char *nptr, char **endptr); #else #define EXP_STRING "e" #define G_EXP_STRING "g" #define DBL_TYPE double #endif static int edit_double(int n, DBL_TYPE d, int *sp, char *s, int *ep) { char *exponent, buff[DBL_SIZE + 1]; int length; ECL_WITHOUT_FPE_BEGIN { unlikely_if (isnan(d) || !isfinite(d)) { FEerror("Can't print a non-number.", 0); } if (n < -DBL_MAX_DIGITS) n = DBL_MAX_DIGITS; if (n < 0) { DBL_TYPE aux; n = -n; do { sprintf(buff, "%- *.*" EXP_STRING, n + 1 + 1 + DBL_EXPONENT_SIZE, n-1, d); aux = strtod(buff, NULL); #ifdef ECL_LONG_FLOAT if (n < LDBL_SIG) aux = (double) aux; #endif if (n < DBL_SIG) aux = (float)aux; n++; } while (d != aux && n <= DBL_MAX_DIGITS); n--; } else { sprintf(buff, "%- *.*" EXP_STRING, DBL_SIZE, (n <= DBL_MAX_DIGITS)? (n-1) : (DBL_MAX_DIGITS-1), d); } exponent = strchr(buff, 'e'); /* Get the exponent */ *ep = strtol(exponent+1, NULL, 10); /* Get the sign */ *sp = (buff[0] == '-') ? -1 : +1; /* Get the digits of the mantissa */ buff[2] = buff[1]; /* Get the actual number of digits in the mantissa */ length = exponent - (buff + 2); /* The output consists of a string {d1,d2,d3,...,dn} with all N digits of the mantissa. If we ask for more digits than there are, the last ones are set to zero. */ if (n <= length) { memcpy(s, buff+2, n); } else { cl_index i; memcpy(s, buff+2, length); for (i = length; i < n; i++) s[i] = '0'; } s[n] = '\0'; } ECL_WITHOUT_FPE_END; return length; } static void fmt_fix_float(format_stack fmt, bool colon, bool atsign) { int w, d, k; ecl_character overflowchar, padchar; double f; int sign; char buff[256], *b, buff1[256]; int exp; int i, j; cl_object x; int n, m; b = buff1 + 1; fmt_not_colon(fmt, colon); ensure_param(fmt, 5); w = set_param_positive(fmt, 0, "illegal width"); d = set_param_positive(fmt, 1, "illegal number of digits"); k = ecl_to_fix(set_param(fmt, 2, INT, ecl_make_fixnum(0))); overflowchar = ECL_CHAR_CODE(set_param(fmt, 3, CHAR, ECL_CODE_CHAR('\0'))); padchar = ECL_CHAR_CODE(set_param(fmt, 4, CHAR, ECL_CODE_CHAR(' '))); x = fmt_advance(fmt); if (ECL_FIXNUMP(x) || ecl_t_of(x) == t_bignum || ecl_t_of(x) == t_ratio) x = ecl_make_single_float(ecl_to_float(x)); if (!ECL_REAL_TYPE_P(ecl_t_of(x))) { if (fmt->nparam > 1) fmt->nparam = 1; fmt_back_up(fmt); fmt_decimal(fmt, colon, atsign); return; } if (ecl_t_of(x) == t_doublefloat) n = 16; else n = 7; f = ecl_to_double(x); edit_double(n, f, &sign, buff, &exp); if (exp + k > 100 || exp + k < -100 || d > 100) { ecl_prin1(x, fmt->stream); return; } if (d >= 0) m = d + exp + k + 1; else if (w >= 0) { if (exp + k >= 0) m = w - 1; else m = w + exp + k - 2; if (sign < 0 || atsign) --m; if (m == 0) m = 1; } else m = n; if (m <= 0) { if (m == 0 && buff[0] >= '5') { exp++; n = m = 1; buff[0] = '1'; } else n = m = 0; } else if (m < n) { n = m; edit_double(n, f, &sign, buff, &exp); } while (n >= 0) if (buff[n - 1] == '0') --n; else break; exp += k; j = 0; if (exp >= 0) { for (i = 0; i <= exp; i++) b[j++] = i < n ? buff[i] : '0'; b[j++] = '.'; if (d >= 0) for (m = i + d; i < m; i++) b[j++] = i < n ? buff[i] : '0'; else for (; i < n; i++) b[j++] = buff[i]; } else { b[j++] = '.'; if (d >= 0) { for (i = 0; i < (-exp) - 1 && i < d; i++) b[j++] = '0'; for (m = d - i, i = 0; i < m; i++) b[j++] = i < n ? buff[i] : '0'; } else if (n > 0) { for (i = 0; i < (-exp) - 1; i++) b[j++] = '0'; for (i = 0; i < n; i++) b[j++] = buff[i]; } } b[j] = '\0'; if (w >= 0) { if (sign < 0 || atsign) --w; if (j > w && overflowchar != '\0') { w = ecl_to_fix(set_param(fmt, 0, INT, ecl_make_fixnum(0))); for (i = 0; i < w; i++) ecl_write_char(overflowchar, fmt->stream); return; } if (j < w && d < 0 && b[j-1] == '.') { b[j++] = '0'; b[j] = '\0'; } if (j < w && b[0] == '.') { *--b = '0'; j++; } for (i = j; i < w; i++) ecl_write_char(padchar, fmt->stream); } else { if (b[0] == '.') { *--b = '0'; j++; } if (d < 0 && b[j-1] == '.') { b[j++] = '0'; b[j] = '\0'; } } if (sign < 0) ecl_write_char('-', fmt->stream); else if (atsign) ecl_write_char('+', fmt->stream); writestr_stream(b, fmt->stream); } static int fmt_exponent_length(int e) { int i; if (e == 0) return(1); if (e < 0) e = -e; for (i = 0; e > 0; i++, e /= 10) ; return(i); } static void fmt_exponent1(cl_object stream, int e) { if (e == 0) return; fmt_exponent1(stream, e/10); ecl_write_char('0' + e%10, stream); } static void fmt_exponent(format_stack fmt, int e) { if (e == 0) { ecl_write_char('0', fmt->stream); return; } if (e < 0) e = -e; fmt_exponent1(fmt->stream, e); } static void fmt_exponential_float(format_stack fmt, bool colon, bool atsign) { int w, d, e, k; ecl_character overflowchar, padchar, exponentchar; double f; int sign; char buff[256], *b, buff1[256]; int exp; int i, j; cl_object x, y; int n, m; cl_type t; b = buff1 + 1; fmt_not_colon(fmt, colon); ensure_param(fmt, 7); w = set_param_positive(fmt, 0, "illegal width"); d = set_param_positive(fmt, 1, "illegal number of digits"); e = set_param_positive(fmt, 2, "illegal number of digits in exponent"); k = ecl_to_fix(set_param(fmt, 3, INT, ecl_make_fixnum(1))); overflowchar = ECL_CHAR_CODE(set_param(fmt, 4, CHAR, ECL_CODE_CHAR('\0'))); padchar = ECL_CHAR_CODE(set_param(fmt, 5, CHAR, ECL_CODE_CHAR(' '))); exponentchar = ECL_CHAR_CODE(set_param(fmt, 6, CHAR, ECL_CODE_CHAR('\0'))); x = fmt_advance(fmt); if (ECL_FIXNUMP(x) || ecl_t_of(x) == t_bignum || ecl_t_of(x) == t_ratio) x = ecl_make_single_float(ecl_to_float(x)); if (!ECL_REAL_TYPE_P(ecl_t_of(x))) { if (fmt->nparam > 1) fmt->nparam = 1; fmt_back_up(fmt); fmt_decimal(fmt, colon, atsign); return; } if (ecl_t_of(x) == t_doublefloat) n = 16; else n = 7; f = ecl_to_double(x); edit_double(n, f, &sign, buff, &exp); if (d >= 0) { if (k > 0) { if (!(k < d + 2)) fmt_error(fmt, "illegal scale factor"); m = d + 1; } else { if (!(k > -d)) fmt_error(fmt, "illegal scale factor"); m = d + k; } } else if (w >= 0) { if (k > 0) m = w - 1; else m = w + k - 1; if (sign < 0 || atsign) --m; if (e >= 0) m -= e + 2; else m -= fmt_exponent_length(e - k + 1) + 2; } else m = n; if (m <= 0) { if (m == 0 && buff[0] >= '5') { exp++; n = m = 1; buff[0] = '1'; } else n = m = 0; } else if (m < n) { n = m; edit_double(n, f, &sign, buff, &exp); } while (n >= 0) if (buff[n - 1] == '0') --n; else break; exp = exp - k + 1; j = 0; if (k > 0) { for (i = 0; i < k; i++) b[j++] = i < n ? buff[i] : '0'; b[j++] = '.'; if (d >= 0) for (m = i + (d - k + 1); i < m; i++) b[j++] = i < n ? buff[i] : '0'; else for (; i < n; i++) b[j++] = buff[i]; } else { b[j++] = '.'; if (d >= 0) { for (i = 0; i < -k && i < d; i++) b[j++] = '0'; for (m = d - i, i = 0; i < m; i++) b[j++] = i < n ? buff[i] : '0'; } else if (n > 0) { for (i = 0; i < -k; i++) b[j++] = '0'; for (i = 0; i < n; i++) b[j++] = buff[i]; } } b[j] = '\0'; if (w >= 0) { if (sign < 0 || atsign) --w; i = fmt_exponent_length(exp); if (e >= 0) { if (i > e) { if (overflowchar != '\0') goto OVER; else e = i; } w -= e + 2; } else w -= i + 2; if (j > w && overflowchar != '\0') goto OVER; if (j < w && b[0] == '.') { *--b = '0'; j++; } for (i = j; i < w; i++) ecl_write_char(padchar, fmt->stream); } else { if (b[j-1] == '.') { b[j++] = '0'; b[j] = '\0'; } if (d < 0 && b[0] == '.') { *--b = '0'; j++; } } if (sign < 0) ecl_write_char('-', fmt->stream); else if (atsign) ecl_write_char('+', fmt->stream); writestr_stream(b, fmt->stream); y = ecl_symbol_value(@'*read-default-float-format*'); if (exponentchar < 0) { if (y == @'long-float') { #ifdef ECL_LONG_FLOAT t = t_longfloat; #else t = t_doublefloat; #endif } else if (y == @'double-float') { t = t_doublefloat; } else if (y == @'single-float') { t = t_singlefloat; } else { t = t_singlefloat; } if (ecl_t_of(x) == t) exponentchar = 'E'; else if (ecl_t_of(x) == t_singlefloat) exponentchar = 'F'; #ifdef ECL_LONG_FLOAT else if (ecl_t_of(x) == t_longfloat) exponentchar = 'L'; #endif else exponentchar = 'D'; } ecl_write_char(exponentchar, fmt->stream); if (exp < 0) ecl_write_char('-', fmt->stream); else ecl_write_char('+', fmt->stream); if (e >= 0) for (i = e - fmt_exponent_length(exp); i > 0; --i) ecl_write_char('0', fmt->stream); fmt_exponent(fmt, exp); return; OVER: w = ecl_to_fix(set_param(fmt, 0, INT, ecl_make_fixnum(0))); for (i = 0; i < w; i++) ecl_write_char(overflowchar, fmt->stream); return; } static void fmt_general_float(format_stack fmt, bool colon, bool atsign) { int w, d, e, k; ecl_character overflowchar, padchar, exponentchar; int sign, exp; char buff[256]; cl_object x; int n, ee, ww, q, dd; fmt_not_colon(fmt, colon); ensure_param(fmt, 7); w = set_param_positive(fmt, 0, "illegal width"); d = set_param_positive(fmt, 1, "illegal number of digits"); e = set_param_positive(fmt, 2, "illegal number of digits in exponent"); k = ecl_to_fix(set_param(fmt, 3, INT, ecl_make_fixnum(1))); overflowchar = ECL_CHAR_CODE(set_param(fmt, 4, CHAR, ECL_CODE_CHAR('\0'))); padchar = ECL_CHAR_CODE(set_param(fmt, 5, CHAR, ECL_CODE_CHAR(' '))); exponentchar = ECL_CHAR_CODE(set_param(fmt, 6, CHAR, ECL_CODE_CHAR('\0'))); x = fmt_advance(fmt); if (!ECL_REAL_TYPE_P(ecl_t_of(x))) { if (fmt->nparam > 1) fmt->nparam = 1; fmt_back_up(fmt); fmt_decimal(fmt, colon, atsign); return; } if (ecl_t_of(x) == t_doublefloat) q = 16; else q = 7; edit_double(q, ecl_to_double(x), &sign, buff, &exp); n = exp + 1; while (q >= 0) if (buff[q - 1] == '0') --q; else break; if (e >= 0) ee = e + 2; else ee = 4; ww = w - ee; if (d < 0) { d = n < 7 ? n : 7; d = q > d ? q : d; } dd = d - n; if (0 <= dd && dd <= d) { fmt->nparam = 5; fmt->param[0] = ecl_make_fixnum(ww); fmt->param[1] = ecl_make_fixnum(dd); fmt->param[2] = ECL_NIL; fmt->param[3] = fmt->param[4]; fmt->param[4] = fmt->param[5]; fmt_back_up(fmt); fmt_fix_float(fmt, colon, atsign); if (w >= 0) while (ww++ < w) ecl_write_char(padchar, fmt->stream); return; } fmt->param[1] = ecl_make_fixnum(d); fmt_back_up(fmt); fmt_exponential_float(fmt, colon, atsign); } static void fmt_dollars_float(format_stack fmt, bool colon, bool atsign) { int d, n, w; ecl_character padchar; double f; int sign; char buff[256]; int exp; int q, i; cl_object x; ensure_param(fmt, 4); d = set_param_positive(fmt, 0, "illegal number of digits"); if (d < 0) d = 2; n = set_param_positive(fmt, 1, "illegal number of digits"); if (n < 0) n = 1; w = set_param_positive(fmt, 2, "illegal width"); if (w < 0) w = 0; padchar = ECL_CHAR_CODE(set_param(fmt, 3, CHAR, ECL_CODE_CHAR(' '))); x = fmt_advance(fmt); if (!ECL_REAL_TYPE_P(ecl_t_of(x))) { if (fmt->nparam < 3) fmt->nparam = 0; else { fmt->nparam = 1; fmt->param[0] = fmt->param[2]; } fmt_back_up(fmt); fmt_decimal(fmt, colon, atsign); return; } q = 7; if (ecl_t_of(x) == t_doublefloat) q = 16; f = ecl_to_double(x); edit_double(q, f, &sign, buff, &exp); if ((q = exp + d + 1) > 0) edit_double(q, f, &sign, buff, &exp); exp++; if (w > 100 || exp > 100 || exp < -100) { fmt->nparam = 6; fmt->param[0] = fmt->param[2]; fmt->param[1] = ecl_make_fixnum(d + n - 1); fmt->param[5] = fmt->param[3]; fmt->param[2] = fmt->param[3] = fmt->param[4] = ECL_NIL; fmt_back_up(fmt); fmt_exponential_float(fmt, colon, atsign); } if (exp > n) n = exp; if (sign < 0 || atsign) --w; if (colon) { if (sign < 0) ecl_write_char('-', fmt->stream); else if (atsign) ecl_write_char('+', fmt->stream); while (--w > n + d) ecl_write_char(padchar, fmt->stream); } else { while (--w > n + d) ecl_write_char(padchar, fmt->stream); if (sign < 0) ecl_write_char('-', fmt->stream); else if (atsign) ecl_write_char('+', fmt->stream); } for (i = n - exp; i > 0; --i) ecl_write_char('0', fmt->stream); for (i = 0; i < exp; i++) ecl_write_char((i < q ? buff[i] : '0'), fmt->stream); ecl_write_char('.', fmt->stream); for (d += i; i < d; i++) ecl_write_char((i < q ? buff[i] : '0'), fmt->stream); } static void fmt_percent(format_stack fmt, bool colon, bool atsign) { int n, i; ensure_param(fmt, 1); n = ecl_to_fix(set_param(fmt, 0, INT, ecl_make_fixnum(1))); fmt_not_colon(fmt, colon); fmt_not_atsign(fmt, atsign); while (n-- > 0) { ecl_write_char('\n', fmt->stream); if (n == 0) for (i = fmt->indents; i > 0; --i) ecl_write_char(' ', fmt->stream); } } static void fmt_ampersand(format_stack fmt, bool colon, bool atsign) { int n; ensure_param(fmt, 1); n = ecl_to_fix(set_param(fmt, 0, INT, ecl_make_fixnum(1))); fmt_not_colon(fmt, colon); fmt_not_atsign(fmt, atsign); if (n == 0) return; if (ecl_file_column(fmt->stream) != 0) ecl_write_char('\n', fmt->stream); while (--n > 0) ecl_write_char('\n', fmt->stream); fmt->indents = 0; } static void fmt_bar(format_stack fmt, bool colon, bool atsign) { int n; ensure_param(fmt, 1); n = ecl_to_fix(set_param(fmt, 0, INT, ecl_make_fixnum(1))); fmt_not_colon(fmt, colon); fmt_not_atsign(fmt, atsign); while (n-- > 0) ecl_write_char('\f', fmt->stream); } static void fmt_tilde(format_stack fmt, bool colon, bool atsign) { int n; ensure_param(fmt, 1); n = ecl_to_fix(set_param(fmt, 0, INT, ecl_make_fixnum(1))); fmt_not_colon(fmt, colon); fmt_not_atsign(fmt, atsign); while (n-- > 0) ecl_write_char('~', fmt->stream); } static void fmt_newline(format_stack fmt, bool colon, bool atsign) { ensure_param(fmt, 0); fmt_not_colon_atsign(fmt, colon, atsign); if (atsign) ecl_write_char('\n', fmt->stream); while (fmt->ctl_index < fmt->ctl_end && isspace(ecl_char(fmt->ctl_str, fmt->ctl_index))) { if (colon) ecl_write_char(ecl_char(fmt->ctl_str, fmt->ctl_index), fmt->stream); fmt->ctl_index++; } } static void fmt_tabulate(format_stack fmt, bool colon, bool atsign) { int colnum, colinc; int c, i; ensure_param(fmt, 2); fmt_not_colon(fmt, colon); colnum = ecl_to_fix(set_param(fmt, 0, INT, ecl_make_fixnum(1))); colinc = ecl_to_fix(set_param(fmt, 1, INT, ecl_make_fixnum(1))); if (!atsign) { c = ecl_file_column(fmt->stream); if (c < 0) { writestr_stream(" ", fmt->stream); return; } if (c > colnum && colinc <= 0) return; while (c > colnum) colnum += colinc; for (i = colnum - c; i > 0; --i) ecl_write_char(' ', fmt->stream); } else { for (i = colnum; i > 0; --i) ecl_write_char(' ', fmt->stream); c = ecl_file_column(fmt->stream); if (c < 0 || colinc <= 0) return; colnum = 0; while (c > colnum) colnum += colinc; for (i = colnum - c; i > 0; --i) ecl_write_char(' ', fmt->stream); } } static void fmt_asterisk(format_stack fmt, bool colon, bool atsign) { int n; ensure_param(fmt, 1); fmt_not_colon_atsign(fmt, colon, atsign); if (atsign) { n = ecl_to_fix(set_param(fmt, 0, INT, ecl_make_fixnum(0))); fmt_go(fmt, n); } else if (colon) { n = ecl_to_fix(set_param(fmt, 0, INT, ecl_make_fixnum(1))); fmt_go(fmt, fmt_index(fmt) - n); } else { n = ecl_to_fix(set_param(fmt, 0, INT, ecl_make_fixnum(1))); while (n-- > 0) fmt_advance(fmt); } } static void fmt_indirection(format_stack fmt, bool colon, bool atsign) { cl_object s, l; struct format_stack_struct fmt_old; jmp_buf fmt_jmp_buf0; int up_colon; ensure_param(fmt, 0); fmt_not_colon(fmt, colon); s = fmt_advance(fmt); switch (ecl_t_of(s)) { #ifdef ECL_UNICODE case t_string: #endif case t_base_string: break; default: fmt_error(fmt, "control string expected"); } if (atsign) { fmt_copy(&fmt_old, fmt); fmt->jmp_buf = &fmt_jmp_buf0; fmt->ctl_str = s; if ((up_colon = ecl_setjmp(*fmt->jmp_buf))) { if (--up_colon) fmt_error(fmt, "illegal ~~:^"); } else format(fmt, 0, s->base_string.fillp); fmt_copy1(fmt, &fmt_old); } else { l = fmt_advance(fmt); fmt_copy(&fmt_old, fmt); fmt_set_arg_list(fmt, l); fmt->jmp_buf = &fmt_jmp_buf0; fmt->ctl_str = s; if ((up_colon = ecl_setjmp(*fmt->jmp_buf))) { if (--up_colon) fmt_error(fmt, "illegal ~~:^"); } else format(fmt, 0, s->base_string.fillp); fmt_copy(fmt, &fmt_old); } } static void fmt_case(format_stack fmt, bool colon, bool atsign) { cl_object x; cl_index i; int j; ecl_character c; struct format_stack_struct fmt_old; jmp_buf fmt_jmp_buf0; int up_colon; bool b; x = ecl_make_string_output_stream(64, 1); i = fmt->ctl_index; j = fmt_skip(fmt); if (ecl_char(fmt->ctl_str, --j) != ')' || ecl_char(fmt->ctl_str, --j) != '~') fmt_error(fmt, "~~) expected"); fmt_copy(&fmt_old, fmt); fmt->stream = x; fmt->jmp_buf = &fmt_jmp_buf0; if ((up_colon = ecl_setjmp(*fmt->jmp_buf))) ; else format(fmt, i, j); fmt_copy1(fmt, &fmt_old); x = STRING_OUTPUT_STRING(x); if (!colon && !atsign) for (i = 0; i < x->base_string.fillp; i++) { if (ecl_upper_case_p(c = ecl_char(x, i))) c = ecl_char_downcase(c); ecl_write_char(c, fmt->stream); } else if (colon && !atsign) for (b = TRUE, i = 0; i < x->base_string.fillp; i++) { if (ecl_lower_case_p(c = ecl_char(x, i))) { if (b) c = ecl_char_upcase(c); b = FALSE; } else if (ecl_upper_case_p(c)) { if (!b) c = ecl_char_downcase(c); b = FALSE; } else if (ecl_digitp(c,10) == -1) b = TRUE; ecl_write_char(c, fmt->stream); } else if (!colon && atsign) for (b = TRUE, i = 0; i < x->base_string.fillp; i++) { if (ecl_lower_case_p(c = ecl_char(x, i))) { if (b) c = ecl_char_upcase(c); b = FALSE; } else if (ecl_upper_case_p(c)) { if (!b) c = ecl_char_downcase(c); b = FALSE; } ecl_write_char(c, fmt->stream); } else for (i = 0; i < x->base_string.fillp; i++) { if (ecl_lower_case_p(c = ecl_char(x, i))) c = ecl_char_upcase(c); ecl_write_char(c, fmt->stream); } if (up_colon) ecl_longjmp(*fmt->jmp_buf, up_colon); } static void fmt_conditional(format_stack fmt, bool colon, bool atsign) { int i, j, k; cl_object x; int n; bool done; struct format_stack_struct fmt_old; fmt_not_colon_atsign(fmt, colon, atsign); if (colon) { ensure_param(fmt, 0); i = fmt->ctl_index; j = fmt_skip(fmt); if (ecl_char(fmt->ctl_str, --j) != ';' || ecl_char(fmt->ctl_str, --j) != '~') fmt_error(fmt, "~~; expected"); k = fmt_skip(fmt); if (ecl_char(fmt->ctl_str, --k) != ']' || ecl_char(fmt->ctl_str, --k) != '~') fmt_error(fmt, "~~] expected"); if (Null(fmt_advance(fmt))) { fmt_copy(&fmt_old, fmt); format(fmt, i, j); fmt_copy1(fmt, &fmt_old); } else { fmt_copy(&fmt_old, fmt); format(fmt, j + 2, k); fmt_copy1(fmt, &fmt_old); } } else if (atsign) { i = fmt->ctl_index; j = fmt_skip(fmt); if (ecl_char(fmt->ctl_str, --j) != ']' || ecl_char(fmt->ctl_str, --j) != '~') fmt_error(fmt, "~~] expected"); if (Null(fmt_advance(fmt))) ; else { fmt_back_up(fmt); fmt_copy(&fmt_old, fmt); format(fmt, i, j); fmt_copy1(fmt, &fmt_old); } } else { ensure_param(fmt, 1); if (fmt->nparam == 0) { x = fmt_advance(fmt); if (!ECL_FIXNUMP(x)) fmt_error(fmt, "illegal argument for conditional"); n = ecl_fixnum(x); } else n = ecl_to_fix(set_param(fmt, 0, INT, ecl_make_fixnum(0))); i = fmt->ctl_index; for (done = FALSE;; --n) { j = fmt_skip(fmt); for (k = j; ecl_char(fmt->ctl_str, --k) != '~';) ; if (n == 0) { fmt_copy(&fmt_old, fmt); format(fmt, i, k); fmt_copy1(fmt, &fmt_old); done = TRUE; } i = j; if (ecl_char(fmt->ctl_str, --j) == ']') { if (ecl_char(fmt->ctl_str, --j) != '~') fmt_error(fmt, "~~] expected"); return; } if (ecl_char(fmt->ctl_str, j) == ';') { if (ecl_char(fmt->ctl_str, --j) == '~') continue; if (ecl_char(fmt->ctl_str, j) == ':') goto ELSE; } fmt_error(fmt, "~~; or ~~] expected"); } ELSE: if (ecl_char(fmt->ctl_str, --j) != '~') fmt_error(fmt, "~~:; expected"); j = fmt_skip(fmt); if (ecl_char(fmt->ctl_str, --j) != ']' || ecl_char(fmt->ctl_str, --j) != '~') fmt_error(fmt, "~~] expected"); if (!done) { fmt_copy(&fmt_old, fmt); format(fmt, i, j); fmt_copy1(fmt, &fmt_old); } } } static void fmt_iteration(format_stack fmt, bool colon, bool atsign) { int n, i; volatile int j; bool colon_close = FALSE; cl_object l; struct format_stack_struct fmt_old; jmp_buf fmt_jmp_buf0; int up_colon; ensure_param(fmt, 1); n = ecl_to_fix(set_param(fmt, 0, INT, ecl_make_fixnum(1000000))); i = fmt->ctl_index; j = fmt_skip(fmt); if (ecl_char(fmt->ctl_str, --j) != '}') fmt_error(fmt, "~~} expected"); if (ecl_char(fmt->ctl_str, --j) == ':') { colon_close = TRUE; --j; } if (ecl_char(fmt->ctl_str, j) != '~') fmt_error(fmt, "syntax error"); if (!colon && !atsign) { l = fmt_advance(fmt); fmt_copy(&fmt_old, fmt); fmt_set_arg_list(fmt, l); fmt->jmp_buf = &fmt_jmp_buf0; if (colon_close) goto L1; while (fmt_more_args_p(fmt)) { L1: if (n-- <= 0) break; if ((up_colon = ecl_setjmp(*fmt->jmp_buf))) { if (--up_colon) fmt_error(fmt, "illegal ~~:^"); break; } format(fmt, i, j); } fmt_copy(fmt, &fmt_old); } else if (colon && !atsign) { int fl = 0; volatile cl_object l0; l0 = fmt_advance(fmt); fmt_copy(&fmt_old, fmt); for (l = l0; !ecl_endp(l); l = CDR(l)) fl += ecl_length(CAR(l)); fmt->jmp_buf = &fmt_jmp_buf0; if (colon_close) goto L2; while (!ecl_endp(l0)) { L2: if (n-- <= 0) break; l = CAR(l0); l0 = CDR(l0); fmt_set_arg_list(fmt, l); if ((up_colon = ecl_setjmp(*fmt->jmp_buf))) { if (--up_colon) break; else continue; } format(fmt, i, j); } fmt_copy(fmt, &fmt_old); } else if (!colon && atsign) { fmt_copy(&fmt_old, fmt); fmt->jmp_buf = &fmt_jmp_buf0; if (colon_close) goto L3; while (fmt_more_args_p(fmt)) { L3: if (n-- <= 0) break; if ((up_colon = ecl_setjmp(*fmt->jmp_buf))) { if (--up_colon) fmt_error(fmt, "illegal ~~:^"); break; } format(fmt, i, j); } fmt_copy1(fmt, &fmt_old); } else if (colon && atsign) { if (colon_close) goto L4; while (fmt_more_args_p(fmt)) { L4: if (n-- <= 0) break; l = fmt_advance(fmt); fmt_copy(&fmt_old, fmt); fmt_set_arg_list(fmt, l); fmt->jmp_buf = &fmt_jmp_buf0; if ((up_colon = ecl_setjmp(*fmt->jmp_buf))) { fmt_copy(fmt, &fmt_old); if (--up_colon) break; else continue; } format(fmt, i, j); fmt_copy(fmt, &fmt_old); } } } static void fmt_justification(format_stack fmt, volatile bool colon, bool atsign) { int mincol, colinc; ecl_character minpad, padchar; volatile cl_object fields; cl_object p; struct format_stack_struct fmt_old; jmp_buf fmt_jmp_buf0; volatile int i, j, k, l, m, j0, l0; int up_colon; volatile cl_object special = ECL_NIL; volatile int spare_spaces, line_length; ensure_param(fmt, 4); mincol = ecl_to_fix(set_param(fmt, 0, INT, ecl_make_fixnum(0))); colinc = ecl_to_fix(set_param(fmt, 1, INT, ecl_make_fixnum(1))); minpad = ecl_to_fix(set_param(fmt, 2, INT, ecl_make_fixnum(0))); padchar = ECL_CHAR_CODE(set_param(fmt, 3, CHAR, ECL_CODE_CHAR(' '))); fields = ECL_NIL; for (;;) { cl_object this_field = ecl_make_string_output_stream(64, 1); i = fmt->ctl_index; j0 = j = fmt_skip(fmt); while (ecl_char(fmt->ctl_str, --j) != '~') ; fmt_copy(&fmt_old, fmt); fmt->jmp_buf = &fmt_jmp_buf0; if ((up_colon = ecl_setjmp(*fmt->jmp_buf))) { if (--up_colon) fmt_error(fmt, "illegal ~~:^"); fmt_copy1(fmt, &fmt_old); while (ecl_char(fmt->ctl_str, --j0) != '>') j0 = fmt_skip(fmt); if (ecl_char(fmt->ctl_str, --j0) != '~') fmt_error(fmt, "~~> expected"); break; } fmt->stream = this_field; format(fmt, i, j); fields = CONS(STRING_OUTPUT_STRING(this_field), fields); fmt_copy1(fmt, &fmt_old); if (ecl_char(fmt->ctl_str, --j0) == '>') { if (ecl_char(fmt->ctl_str, --j0) != '~') fmt_error(fmt, "~~> expected"); break; } else if (ecl_char(fmt->ctl_str, j0) != ';') fmt_error(fmt, "~~; expected"); else if (ecl_char(fmt->ctl_str, --j0) == ':') { if (ecl_length(fields) != 1 || !Null(special)) fmt_error(fmt, "illegal ~~:;"); special = CAR(fields); fields = CDR(fields); for (j = j0; ecl_char(fmt->ctl_str, j) != '~'; --j) ; fmt_copy(&fmt_old, fmt); format(fmt, j, j0 + 2); fmt_copy1(fmt, &fmt_old); spare_spaces = fmt->spare_spaces; line_length = fmt->line_length; } else if (ecl_char(fmt->ctl_str, j0) != '~') fmt_error(fmt, "~~; expected"); } /* * Compute the length of items to be output. If the clause ~:; was * found, the first item is not included. */ fields = cl_nreverse(fields); for (p = fields, l = 0; p != ECL_NIL; p = CDR(p)) l += CAR(p)->base_string.fillp; /* * Count the number of segments that need padding, "M". If the colon * modifier, the first item needs padding. If the @@ modifier is * present, the last modifier also needs padding. */ m = ecl_length(fields) - 1; if (m <= 0 && !colon && !atsign) { m = 0; colon = TRUE; } if (colon) m++; if (atsign) m++; /* * Count the minimal length in which the text fits. This length must * the smallest integer of the form l = mincol + k * colinc. If the * length exceeds the line length, the text before the ~:; is output * first. */ l0 = l; l += minpad * m; for (k = 0; mincol + k * colinc < l; k++) ; l = mincol + k * colinc; if (special != ECL_NIL && ecl_file_column(fmt->stream) + l + spare_spaces > line_length) ecl_princ(special, fmt->stream); /* * Output the text with the padding segments. The total number of * padchars is kept in "l", and it is shared equally among all segments. */ l -= l0; for (p = fields; p != ECL_NIL; p = CDR(p)) { if (p != fields || colon) for (j = l / m, l -= j, --m; j > 0; --j) ecl_write_char(padchar, fmt->stream); ecl_princ(CAR(p), fmt->stream); } if (atsign) for (j = l; j > 0; --j) ecl_write_char(padchar, fmt->stream); } static void fmt_up_and_out(format_stack fmt, bool colon, bool atsign) { int i, j, k; ensure_param(fmt, 3); fmt_not_atsign(fmt, atsign); if (fmt->nparam == 0) { if (!fmt_more_args_p(fmt)) ecl_longjmp(*fmt->jmp_buf, ++colon); } else if (fmt->nparam == 1) { i = ecl_to_fix(set_param(fmt, 0, INT, ecl_make_fixnum(0))); if (i == 0) ecl_longjmp(*fmt->jmp_buf, ++colon); } else if (fmt->nparam == 2) { i = ecl_to_fix(set_param(fmt, 0, INT, ecl_make_fixnum(0))); j = ecl_to_fix(set_param(fmt, 1, INT, ecl_make_fixnum(0))); if (i == j) ecl_longjmp(*fmt->jmp_buf, ++colon); } else { i = ecl_to_fix(set_param(fmt, 0, INT, ecl_make_fixnum(0))); j = ecl_to_fix(set_param(fmt, 1, INT, ecl_make_fixnum(0))); k = ecl_to_fix(set_param(fmt, 2, INT, ecl_make_fixnum(0))); if (i <= j && j <= k) ecl_longjmp(*fmt->jmp_buf, ++colon); } } static void fmt_semicolon(format_stack fmt, bool colon, bool atsign) { fmt_not_atsign(fmt, atsign); if (!colon) fmt_error(fmt, "~~:; expected"); ensure_param(fmt, 2); fmt->spare_spaces = ecl_to_fix(set_param(fmt, 0, INT, ecl_make_fixnum(0))); fmt->line_length = ecl_to_fix(set_param(fmt, 1, INT, ecl_make_fixnum(72))); } @(defun si::formatter-aux (strm string &rest args) @ @(return doformat(narg, strm, string, args, TRUE)) @) static cl_object doformat(cl_narg narg, cl_object strm, cl_object string, ecl_va_list args, bool in_formatter) { struct format_stack_struct fmt; jmp_buf fmt_jmp_buf0; int colon; cl_object output = cl_grab_rest_args(args); while(!ecl_stringp(string)) #ifdef ECL_UNICODE string = ecl_type_error(@'format', "argument", string, @'string'); #else string = ecl_type_error(@'format', "argument", string, @'base-string'); #endif fmt.stream = strm; fmt_set_arg_list(&fmt, output); fmt.jmp_buf = &fmt_jmp_buf0; if (ecl_symbol_value(@'si::*indent-formatted-output*') != ECL_NIL) fmt.indents = ecl_file_column(strm); else fmt.indents = 0; fmt.ctl_str = string; fmt.aux_stream = get_aux_stream(); fmt.aux_string = STRING_OUTPUT_STRING(fmt.aux_stream); if ((colon = ecl_setjmp(*fmt.jmp_buf))) { if (--colon) fmt_error(&fmt, "illegal ~~:^"); } else { format(&fmt, 0, string->base_string.fillp); ecl_force_output(strm); } ecl_process_env()->fmt_aux_stream = fmt.aux_stream; if (!in_formatter) output = ECL_NIL; return output; } static void format(format_stack fmt, cl_index start, cl_index end) { ecl_character c; cl_index i, n; bool colon, atsign; cl_object x; fmt->ctl_index = start; fmt->ctl_end = end; LOOP: if (fmt->ctl_index >= fmt->ctl_end) return; if ((c = ctl_advance(fmt)) != '~') { ecl_write_char(c, fmt->stream); goto LOOP; } n = 0; for (;;) { switch (c = ctl_advance(fmt)) { case ',': fmt->param[n] = ECL_NIL; break; case '+': case '-': case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': i = fmt->ctl_index - 1; do { c = ctl_advance(fmt); } while (ecl_digitp(c,10) != -1); x = ecl_parse_integer(fmt->ctl_str, i, fmt->ctl_index, &i, 10); INTEGER: /* FIXME! A hack to solve the problem of bignums in arguments */ if (x == OBJNULL || !ecl_numberp(x)) fmt_error(fmt, "integer expected"); if (ecl_number_compare(x, ecl_make_fixnum(FMT_VALUE_UPPER_LIMIT)) > 0) { fmt->param[n] = ecl_make_fixnum(FMT_VALUE_UPPER_LIMIT); } else if (ecl_number_compare(x, ecl_make_fixnum(FMT_VALUE_LOWER_LIMIT)) < 0) { fmt->param[n] = ecl_make_fixnum(FMT_VALUE_LOWER_LIMIT); } else { fmt->param[n] = x; } if (ECL_FIXNUMP(x)) { fmt->param[n] = x; } else if (ecl_plusp(x)) { fmt->param[n] = ecl_make_fixnum(MOST_POSITIVE_FIXNUM); } else { fmt->param[n] = ecl_make_fixnum(MOST_NEGATIVE_FIXNUM); } break; case '\'': fmt->param[n] = ECL_CODE_CHAR(ctl_advance(fmt)); c = ctl_advance(fmt); break; case 'v': case 'V': x = fmt_advance(fmt); c = ctl_advance(fmt); if (ecl_t_of(x) == t_character) { fmt->param[n] = x; } else { goto INTEGER; } break; case '#': fmt->param[n] = ecl_make_fixnum(fmt_args_left(fmt)); c = ctl_advance(fmt); break; default: if (n > 0) fmt_error(fmt, "illegal ,"); else goto DIRECTIVE; } n++; if (n == FMT_MAX_PARAM) fmt_error(fmt, "too many parameters"); if (c != ',') break; } DIRECTIVE: colon = atsign = FALSE; if (c == ':') { colon = TRUE; c = ctl_advance(fmt); } if (c == '@@') { atsign = TRUE; c = ctl_advance(fmt); } fmt->nparam = n; switch (c) { case 'a': case 'A': fmt_ascii(fmt, colon, atsign); break; case 's': case 'S': fmt_S_expression(fmt, colon, atsign); break; case 'd': case 'D': fmt_decimal(fmt, colon, atsign); break; case 'b': case 'B': fmt_binary(fmt, colon, atsign); break; case 'o': case 'O': fmt_octal(fmt, colon, atsign); break; case 'x': case 'X': fmt_hexadecimal(fmt, colon, atsign); break; case 'r': case 'R': fmt_radix(fmt, colon, atsign); break; case 'p': case 'P': fmt_plural(fmt, colon, atsign); break; case 'c': case 'C': fmt_character(fmt, colon, atsign); break; case 'f': case 'F': fmt_fix_float(fmt, colon, atsign); break; case 'e': case 'E': fmt_exponential_float(fmt, colon, atsign); break; case 'g': case 'G': fmt_general_float(fmt, colon, atsign); break; case '$': fmt_dollars_float(fmt, colon, atsign); break; case '%': fmt_percent(fmt, colon, atsign); break; case '&': fmt_ampersand(fmt, colon, atsign); break; case '|': fmt_bar(fmt, colon, atsign); break; case '~': fmt_tilde(fmt, colon, atsign); break; case '\n': case '\r': fmt_newline(fmt, colon, atsign); break; case 't': case 'T': fmt_tabulate(fmt, colon, atsign); break; case '*': fmt_asterisk(fmt, colon, atsign); break; case '?': fmt_indirection(fmt, colon, atsign); break; case '(': fmt_case(fmt, colon, atsign); break; case '[': fmt_conditional(fmt, colon, atsign); break; case '{': fmt_iteration(fmt, colon, atsign); break; case '<': fmt_justification(fmt, colon, atsign); break; case '^': fmt_up_and_out(fmt, colon, atsign); break; case ';': fmt_semicolon(fmt, colon, atsign); break; default: fmt_error(fmt, "illegal directive"); } goto LOOP; } #endif /* !ECL_CMU_FORMAT */ @(defun format (strm string &rest args) cl_object output = ECL_NIL; int null_strm = 0; @ if (Null(strm)) { #ifdef ECL_UNICODE strm = ecl_alloc_adjustable_extended_string(64); #else strm = ecl_alloc_adjustable_base_string(64); #endif null_strm = 1; } else if (strm == ECL_T) { strm = ecl_symbol_value(@'*standard-output*'); } if (ecl_stringp(strm)) { output = strm; if (!ECL_ARRAY_HAS_FILL_POINTER_P(output)) { cl_error(7, @'si::format-error', @':format-control', make_constant_base_string( "Cannot output to a non adjustable string."), @':control-string', string, @':offset', ecl_make_fixnum(0)); } strm = si_make_string_output_stream_from_string(strm); if (null_strm == 0) output = ECL_NIL; } if (!Null(cl_functionp(string))) { cl_apply(3, string, strm, cl_grab_rest_args(args)); } else { #ifdef ECL_CMU_FORMAT _ecl_funcall4(@'si::formatter-aux', strm, string, cl_grab_rest_args(args)); #else doformat(narg, strm, string, args, FALSE); #endif } output = cl_copy_seq(output); @(return output) @) ecl-16.1.2/src/c/gbc-new.d000066400000000000000000000705101266352375300150630ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* gbc.c -- Garbage collector. */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi and William F. Schelter. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include "ecl.h" #include "page.h" /******************************* EXPORTS ******************************/ bool GC_enable; int gc_time; /* Beppe */ /******************************* ------- ******************************/ /* mark_table[m]:i represents word w = 128*m + 4*i, where m = addr-DATA_START. Therefore m = w >> 7, i = (w / 4) % 32 = (w >> 2) & 0x1f. */ static int *mark_table; static void inline set_mark_bit(void *x) { int w = (int)x; int m = (w - DATA_START) >> 7; int i = (w >> 2) & 0x1f; mark_table[m] |= (1 << i); } static int inline get_mark_bit(void *x) { int w = (int)x; int m = (w - DATA_START) >> 7; int i = (w >> 2) & 0x1f; return (mark_table[m] >> i) & 1; } #define inheap(pp) ((unsigned long)(pp) < (unsigned long)heap_end) #define VALID_DATA_ADDRESS(pp) \ !ECL_IMMEDIATE(pp) && (cl_index)DATA_START <= (cl_index)(pp) && (cl_index)(pp) < (cl_index)heap_end cl_object siVgc_verbose; cl_object siVgc_message; static bool debug = FALSE; static int maxpage; #define GC_ROOT_MAX 200 static cl_object *gc_root[GC_ROOT_MAX]; static int gc_roots; static bool collect_blocks; /* We must register location, since value may be reassigned (e.g. malloc_list) */ static void _mark_object (cl_object x); static void _mark_contblock (void *p, size_t s); extern void sigint (void); void register_root(cl_object *p) { if (gc_roots >= GC_ROOT_MAX) error("too many roots"); gc_root[gc_roots++] = p; } @(defun gc (area) @ if (!GC_enabled()) error("GC is not enabled"); if (Null(area)) gc(t_cons); else gc(t_contiguous); @(return) @) /*---------------------------------------------------------------------- * Mark phase *---------------------------------------------------------------------- */ /* Whenever two arrays are linked together by displacement, if one is live, the other will be made live */ #define mark_displaced(ar) mark_object(ar) #define mark_contblock(x,s) {if (collect_blocks) _mark_contblock(x,s); } #if 1 #define mark_object(x) if ((x != OBJNULL) && !ECL_IMMEDIATE(x)) _mark_object(x) #define mark_next(a) if ((a != OBJNULL) && !ECL_IMMEDIATE(a)) { x=(a); goto BEGIN; } #else #define mark_object(x) _mark_object(x) #define mark_next(a) x=(a); goto BEGIN #endif /* We make bitvectors multiple of sizeof(int) in size allocated Assume 8 = number of bits in char */ #define W_SIZE (8*sizeof(int)) static void _mark_object(cl_object x) { size_t i, j; cl_object *p, y; char *cp; cs_check(x); BEGIN: #if 0 /* We cannot get here because mark_object() and mark_next() already check this */ if (ECL_IMMEDIATE(x)) return; /* fixnum, character or locative */ if (x == OBJNULL) return; #endif if (get_mark_bit(x)) return; set_mark_bit(x); switch (ecl_t_of(x)) { case t_bignum: #ifdef WITH_GMP if (collect_blocks) { /* GMP may set num.alloc before actually allocating anything. With these checks we make sure we do not move anything we don't have to. Besides, we use big_dim as the size of the object, because big_size might even be smaller. */ char *limbs = (char *)x->big.big_limbs; size_t size = x->big.big_dim * sizeof(mp_limb_t); if (size) mark_contblock(limbs, size); } #endif /* WITH_GMP */ break; case t_ratio: mark_object(x->ratio.num); mark_next(x->ratio.den); break; #ifdef ECL_SSE2 case t_sse_pack: #endif case t_singlefloat: case t_doublefloat: break; case t_complex: mark_object(x->complex.imag); mark_next(x->complex.real); break; case t_character: break; case t_symbol: mark_object(x->symbol.name); mark_object(x->symbol.plist); mark_object(ECL_SYM_FUN(x)); mark_next(SYM_VAL(x)); break; case t_package: mark_object(x->pack.name); mark_object(x->pack.nicknames); mark_object(x->pack.shadowings); mark_object(x->pack.uses); mark_object(x->pack.usedby); mark_object(x->pack.internal); mark_next(x->pack.external); break; case t_cons: mark_object(CAR(x)); mark_next(CDR(x)); break; case t_hashtable: mark_object(x->hash.rehash_size); mark_object(x->hash.threshold); if (x->hash.data == NULL) break; for (i = 0, j = x->hash.size; i < j; i++) { mark_object(x->hash.data[i].key); mark_object(x->hash.data[i].value); } mark_contblock(x->hash.data, j * sizeof(struct hashtable_entry)); break; case t_array: mark_contblock(x->array.dims, sizeof(x->array.dims[0])*x->array.rank); #ifdef ECL_UNICODE case t_string: #endif case t_vector: if ((y = x->array.displaced) != ECL_NIL) mark_displaced(y); cp = (char *)x->array.self.t; if (cp == NULL) break; switch ((enum aelttype)x->array.elttype) { #ifdef ECL_UNICODE case ecl_aet_ch: #endif case ecl_aet_object: if (x->array.displaced == ECL_NIL || CAR(x->array.displaced) == ECL_NIL) { cl_object *p = x->array.self.t; cl_index i; if (x->array.t == t_vector && x->vector.hasfillp) i = x->vector.fillp; else i = x->vector.dim; while (i-- > 0) mark_object(p[i]); } j = sizeof(cl_object)*x->array.dim; break; case ecl_aet_bc: j = x->array.dim; break; case ecl_aet_bit: j = sizeof(int) * ((x->vector.offset + x->vector.dim + W_SIZE -1)/W_SIZE); break; case ecl_aet_fix: j = x->array.dim * sizeof(cl_fixnum); break; case ecl_aet_sf: j = x->array.dim * sizeof(float); break; case ecl_aet_df: j = x->array.dim * sizeof(double); break; default: error("Allocation botch: unknown array element type"); } goto COPY_ARRAY; case t_base_string: if ((y = x->base_string.displaced) != ECL_NIL) mark_displaced(y); cp = x->base_string.self; if (cp == NULL) break; j = x->base_string.dim; COPY_ARRAY: mark_contblock(cp, j); break; case t_bitvector: if ((y = x->vector.displaced) != ECL_NIL) mark_displaced(y); cp = x->vector.self.bit; if (cp == NULL) break; j= sizeof(int) * ((x->vector.offset + x->vector.dim + W_SIZE -1)/W_SIZE); goto COPY_ARRAY; case t_stream: switch ((enum smmode)x->stream.mode) { case ecl_smm_closed: /* Rest of fields are NULL */ mark_next(x->stream.object1); break; case ecl_smm_input: case ecl_smm_output: case ecl_smm_io: case ecl_smm_probe: mark_object(x->stream.object0); mark_object(x->stream.object1); mark_contblock(x->stream.buffer, BUFSIZ); break; case ecl_smm_synonym: mark_next(x->stream.object0); break; case ecl_smm_broadcast: case ecl_smm_concatenated: mark_next(x->stream.object0); break; case ecl_smm_two_way: case ecl_smm_echo: mark_object(x->stream.object0); mark_next(x->stream.object1); break; case ecl_smm_string_input: case ecl_smm_string_output: mark_next(x->stream.object0); break; default: error("mark stream botch"); } break; case t_random: break; case t_readtable: if (x->readtable.table == NULL) break; mark_contblock((char *)(x->readtable.table), RTABSIZE*sizeof(struct readtable_entry)); for (i = 0; i < RTABSIZE; i++) { cl_object *p = x->readtable.table[i].dispatch_table; mark_object(x->readtable.table[i].macro); if (p != NULL) { mark_contblock(p, RTABSIZE*sizeof(cl_object)); for (j = 0; j < RTABSIZE; j++) mark_object(p[j]); } } break; case t_pathname: mark_object(x->pathname.host); mark_object(x->pathname.device); mark_object(x->pathname.directory); mark_object(x->pathname.name); mark_object(x->pathname.type); mark_object(x->pathname.version); break; case t_bytecodes: { cl_index i, size; size = x->bytecodes.size; mark_object(x->bytecodes.lex); mark_contblock(x->bytecodes.data, size * sizeof(cl_object)); for (i=0; ibytecodes.data[i]); break; } case t_cfun: mark_object(x->cfun.block); mark_object(x->cfun.name); break; case t_cclosure: mark_object(x->cfun.block); mark_object(x->cclosure.env); break; #ifdef THREADS case t_cont: mark_next(x->cn.cn_thread); break; case t_thread: /* Already marked by malloc mark_contblock(x->thread.data, x->thread.size); */ mark_next(x->thread.entry); break; #endif THREADS case t_instance: mark_object(x->instance.class); p = x->instance.slots; if (p == NULL) break; for (i = 0, j = x->instance.length; i < j; i++) mark_object(p[i]); mark_contblock(p, j*sizeof(cl_object)); break; case t_gfun: mark_object(x->gfun.name); mark_object(x->gfun.method_hash); mark_object(x->gfun.instance); p = x->gfun.specializers; if (p == NULL) break; for (i = 0, j = x->gfun.arg_no; i < j; i++) mark_object(p[i]); mark_contblock(p, j*sizeof(cl_object)); break; case t_codeblock: mark_object(x->cblock.name); mark_contblock(x->cblock.start, x->cblock.size); if (x->cblock.data) { cl_index i = x->cblock.data_size; cl_object *p = x->cblock.data; while (i--) mark_object(p[i]); } break; default: if (debug) printf("\ttype = %d\n", ecl_t_of(x)); error("mark botch"); } } static void mark_stack_conservative(int *top, int *bottom) { int p, m; cl_object x; struct typemanager *tm; register int *j; if (debug) { printf("Traversing C stack .."); fflush(stdout); } /* On machines which align local pointers on multiple of 2 rather than 4 we need to mark twice if (offset) mark_stack_conservative(bottom, ((char *) top) + offset, 0); */ for (j = top ; j >= bottom ; j--) { /* improved Beppe: */ if (VALID_DATA_ADDRESS(*j) && type_map[p = page(*j)] < (char)t_end) { tm = tm_of((enum type)type_map[p]); x = (cl_object)(*j - (*j - (int)pagetochar(p)) % tm->tm_size); if (!get_mark_bit(x)) mark_object(x); } } if (debug) {printf(". done.\n"); fflush(stdout); } } static void mark_phase(void) { register int i; register struct package *pp; register ecl_bds_ptr bdp; register ecl_frame_ptr frp; register ecl_ihs_ptr ihsp; mark_object(ECL_NIL); mark_object(ECL_T); #ifdef THREADS { pd *pdp; lpd *old_clwp = clwp; for (pdp = running_head; pdp != (pd *)NULL; pdp = pdp->pd_next) { clwp = pdp->pd_lpd; #endif THREADS for (i=0; ibds_sym); mark_object(bdp->bds_val); } for (frp = frs_org; frp <= frs_top; frp++) { mark_object(frp->frs_val); mark_object(frp->frs_lex); } for (ihsp = ihs_org; ihsp <= ihs_top; ihsp++) { mark_object(ihsp->ihs_function); mark_object(ihsp->ihs_base); } mark_object(lex_env); #ifdef THREADS /* added to mark newly allocated objects */ mark_object(clwp->lwp_alloc_temporary); mark_object(clwp->lwp_fmt_temporary_stream); mark_object(clwp->lwp_PRINTstream); mark_object(clwp->lwp_PRINTcase); mark_object(clwp->lwp_READtable); mark_object(clwp->lwp_delimiting_char); mark_object(clwp->lwp_token); /* (current-thread) can return it at any time */ mark_object(clwp->lwp_thread); #endif THREADS /* now collect from the c-stack of the thread ... */ { int *where; volatile jmp_buf buf; /* ensure flushing of register caches */ if (ecl_setjmp(buf) == 0) ecl_longjmp(buf, 1); #ifdef THREADS if (clwp != old_clwp) /* is not the executing stack */ # ifdef __linux where = (int *)pdp->pd_env[0].__jmpbuf[0].__sp; # else where = (int *)pdp->pd_env[JB_SP]; # endif else #endif THREADS where = (int *)&where ; /* If the locals of type object in a C function could be aligned other than on multiples of sizeof (char *) we would have to mark twice */ if (where > cs_org) mark_stack_conservative(where, cs_org); else mark_stack_conservative(cs_org, where); } #ifdef THREADS } clwp = old_clwp; } #endif THREADS /* mark roots */ for (i = 0; i < gc_roots; i++) mark_object(*gc_root[i]); /* mark registered symbols & keywords */ { const struct keyword_info *k; const struct symbol_info *s; for (k = all_keywords; k->loc != NULL; k++) mark_object(*(k->loc)); for (s = all_symbols; s->loc != NULL; s++) mark_object(*(s->loc)); } if (debug) { printf("symbol navigation\n"); fflush(stdout); } } static void sweep_phase(void) { register int i, j, k; register cl_object x; register char *p; register struct typemanager *tm; register cl_object f; ECL_NIL->symbol.m = FALSE; ECL_T->symbol.m = FALSE; if (debug) printf("type map\n"); for (i = 0; i < maxpage; i++) { if (type_map[i] == (int)t_contiguous) { if (debug) { printf("-"); continue; } } if (type_map[i] >= (int)t_end) continue; tm = tm_of((enum type)type_map[i]); /* general sweeper */ if (debug) printf("%c", tm->tm_name[0]); p = pagetochar(i); f = tm->tm_free; k = 0; for (j = tm->tm_nppage; j > 0; --j, p += tm->tm_size) { x = (cl_object)p; if (!get_mark_bit(x)) { ((struct freelist *)x)->f_link = f; f = x; k++; } } tm->tm_free = f; tm->tm_nfree += k; tm->tm_nused -= k; } if (debug) { putchar('\n'); fflush(stdout); } } static void contblock_sweep_phase(void) { register int i, j; register char *s, *e, *p, *q; register struct contblock *cbp; cb_pointer = NULL; ncb = 0; for (i = 0; i < maxpage;) { if (type_map[i] != (int)t_contiguous) { i++; continue; } for (j = i+1; j < maxpage && type_map[j] == (int)t_contiguous; j++) ; s = pagetochar(i); e = pagetochar(j); for (p = s; p < e;) { if (get_mark_bit((int *)p)) { p += 4; continue; } q = p + 4; while (q < e && !get_mark_bit((int *)q)) q += 4; dealloc(p, q - p); p = q + 4; } i = j + 1; } if (debug) { for (cbp = cb_pointer; cbp != NULL; cbp = cbp->cb_link) printf("0x%p %d\n", cbp, cbp->cb_size); fflush(stdout); } } cl_object (*GC_enter_hook)() = NULL; cl_object (*GC_exit_hook)() = NULL; #ifdef THREADS /* * We execute the GC routine in the main stack. * The idea is to switch over the main stack that is stopped in the intha * and to call the GC from there on garbage_parameter. Then you can switch * back after. * In addition the interrupt is disabled. */ static int i, j; static sigjmp_buf old_env; static int val; static lpd *old_clwp; static enum type t; static bool stack_switched = FALSE; static enum type garbage_parameter; void gc(enum type new_name) { int tm; int gc_start = runtime(); start_critical_section(); t = new_name; garbage_parameter = new_name; #else void gc(enum type t) { int i, j; int tm; int gc_start = runtime(); #endif THREADS if (!GC_enabled()) return; if (SYM_VAL(siVgc_verbose) != ECL_NIL) { printf("\n[GC .."); /* To use this should add entries in tm_table for reloc and contig. fprintf(stdout, "\n[GC for %d %s pages ..", tm_of(t)->tm_npage, tm_table[(int)t].tm_name + 1); */ fflush(stdout); } debug = symbol_value(siVgc_message) != ECL_NIL; #ifdef THREADS if (clwp != &main_lpd) { if (debug) { printf("*STACK SWITCH*\n"); fflush (stdout); } stack_switched = TRUE; val = sigsetjmp(old_env, 1); if (val == 0) { /* informations used by the garbage collector need to be updated */ # ifdef __linux running_head->pd_env[0].__jmpbuf[0].__sp = old_env[0].__jmpbuf[0].__sp; # else running_head->pd_env[JB_SP] = old_env[JB_SP]; # endif old_clwp = clwp; Values = main_lpd.lwp_Values; clwp = &main_lpd; siglongjmp(main_pd.pd_env, 2); /* new line */ } } else val = 1; if (val == 1) { #endif THREADS if (GC_enter_hook != NULL) (*GC_enter_hook)(0); interrupt_enable = FALSE; collect_blocks = t > t_end; if (collect_blocks) cbgccount++; else tm_table[(int)t].tm_gccount++; if (debug) { if (collect_blocks) printf("GC entered for collecting blocks\n"); else printf("GC entered for collecting %s\n", tm_table[(int)t].tm_name); fflush(stdout); } maxpage = page(heap_end); if (collect_blocks) { /* 1 page = 512 word 512 bit = 16 word */ int mark_table_size = maxpage * (LISP_PAGESIZE / 32); extern void resize_hole(size_t); if (holepage < mark_table_size*sizeof(int)/LISP_PAGESIZE + 1) new_holepage = mark_table_size*sizeof(int)/LISP_PAGESIZE + 1; if (new_holepage < HOLEPAGE) new_holepage = HOLEPAGE; resize_hole(new_holepage); mark_table = (int*)heap_end; for (i = 0; i < mark_table_size; i++) mark_table[i] = 0; } if (debug) { printf("mark phase\n"); fflush(stdout); tm = runtime(); } mark_phase(); if (debug) { printf("mark ended (%d)\n", runtime() - tm); printf("sweep phase\n"); fflush(stdout); tm = runtime(); } sweep_phase(); if (debug) { printf("sweep ended (%d)\n", runtime() - tm); fflush(stdout); } if (t == t_contiguous) { if (debug) { printf("contblock sweep phase\n"); fflush(stdout); tm = runtime(); } contblock_sweep_phase(); if (debug) printf("contblock sweep ended (%d)\n", runtime() - tm); } if (debug) { for (i = 0, j = 0; i < (int)t_end; i++) { if (tm_table[i].tm_type == (enum type)i) { printf("%13s: %8d used %8d free %4d/%d pages\n", tm_table[i].tm_name, tm_table[i].tm_nused, tm_table[i].tm_nfree, tm_table[i].tm_npage, tm_table[i].tm_maxpage); j += tm_table[i].tm_npage; } else printf("%13s: linked to %s\n", tm_table[i].tm_name, tm_table[(int)tm_table[i].tm_type].tm_name); } printf("contblock: %d blocks %d pages\n", ncb, ncbpage); printf("hole: %d pages\n", holepage); printf("GC ended\n"); fflush(stdout); } interrupt_enable = TRUE; if (GC_exit_hook != NULL) (*GC_exit_hook)(); #ifdef THREADS /* * Back in the right stack */ if (stack_switched) { if (debug) { printf("*STACK BACK*\n"); fflush (stdout); } stack_switched = FALSE; end_critical_section(); /* we get here from the GC call in scheduler */ clwp = old_clwp; Values = clwp->lwp_Values; siglongjmp(old_env, 2); } } #endif THREADS gc_time += (gc_start = runtime() - gc_start); if (SYM_VAL(siVgc_verbose) != ECL_NIL) { /* Don't use fprintf since on Linux it calls malloc() */ printf(". finished in %.2f\"]", gc_start/60.0); fflush(stdout); } #ifdef unix if (interrupt_flag) sigint(); #endif unix #ifdef THREADS end_critical_section(); #endif THREADS } /* *---------------------------------------------------------------------- * * mark_contblock -- * sets the mark bit for words from address p to address p+s. * Both p and p+s are rounded to word boundaries. * * Results: * none. * * Side effects: * mark_table * *---------------------------------------------------------------------- */ static void _mark_contblock(void *x, size_t s) { register char *p = x, *q; register ptrdiff_t pg = page(p); if (pg < 0 || (enum type)type_map[pg] != t_contiguous) return; #if 1 q = p + s; p = (char *)((int)p&~3); q = (char *)(((int)q+3)&~3); for (; p < q; p+= 4) set_mark_bit(p); #elif 0 { int bit_start = ((int)p - DATA_START) >> 2; int bit_end = ((int)p + s + 3 - DATA_START) >> 2; int *w = &mark_table[bit_start >> 5]; int b = bit_start & (32 - 1); int mask = ~0 << b; int bits = b + bit_end - bit_start; while (bits >= 32) { *w |= mask; w++; bits -= 32; mask = ~0; } mask &= ~(~0 << bits); *w |= mask; } #else { int bit_start = ((int)p - DATA_START) >> 2; int bits = ((int)p + s + 3 - DATA_START) >> 2 - bit_start; int mask = 1 << bit_start & (32 - 1); int *w = &mark_table[bit_start >> 5]; while (bits) { *w |= mask; mask <<= 1; if (!mask) { mask = 1; w++; } } } #endif } /*---------------------------------------------------------------------- * Utilities *---------------------------------------------------------------------- */ @(defun si::room-report () int i; cl_object *tl; @ NValues = 8; VALUES(0) = ecl_make_fixnum(real_maxpage); VALUES(1) = ecl_make_fixnum(available_pages()); VALUES(2) = ecl_make_fixnum(ncbpage); VALUES(3) = ecl_make_fixnum(maxcbpage); VALUES(4) = ecl_make_fixnum(ncb); VALUES(5) = ecl_make_fixnum(cbgccount); VALUES(6) = ecl_make_fixnum(holepage); VALUES(7) = ECL_NIL; tl = &VALUES(7); for (i = 0; i < (int)t_end; i++) { if (tm_table[i].tm_type == (enum type)i) { tl = &CDR(*tl = CONS(ecl_make_fixnum(tm_table[i].tm_nused), ECL_NIL)); tl = &CDR(*tl = CONS(ecl_make_fixnum(tm_table[i].tm_nfree), ECL_NIL)); tl = &CDR(*tl = CONS(ecl_make_fixnum(tm_table[i].tm_npage), ECL_NIL)); tl = &CDR(*tl = CONS(ecl_make_fixnum(tm_table[i].tm_maxpage), ECL_NIL)); tl = &CDR(*tl = CONS(ecl_make_fixnum(tm_table[i].tm_gccount), ECL_NIL)); } else { tl = &CDR(*tl = CONS(ECL_NIL, ECL_NIL)); tl = &CDR(*tl = CONS(ecl_make_fixnum(tm_table[i].tm_type), ECL_NIL)); tl = &CDR(*tl = CONS(ECL_NIL, ECL_NIL)); tl = &CDR(*tl = CONS(ECL_NIL, ECL_NIL)); tl = &CDR(*tl = CONS(ECL_NIL, ECL_NIL)); } } return VALUES(0); @) @(defun si::reset-gc-count () int i; @ cbgccount = 0; for (i = 0; i < (int)t_end; i++) tm_table[i].tm_gccount = 0; @(return) @) @(defun si::gc-time () @ @(return ecl_make_fixnum(gc_time)) @) void init_GC(void) { register_root(&siVgc_verbose); register_root(&siVgc_message); siVgc_verbose = make_si_special("*GC-VERBOSE*", ECL_NIL); siVgc_message = make_si_special("*GC-MESSAGE*", ECL_NIL); GC_enable(); gc_time = 0; } ecl-16.1.2/src/c/gbc.d000066400000000000000000000760461266352375300143060ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* gbc.c -- Garbage collector. */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi and William F. Schelter. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #ifdef ECL_THREADS #include #endif #include #include #include #include #include /******************************* EXPORTS ******************************/ bool GC_enable; /******************************* ------- ******************************/ /* mark_table[m]:i represents word w = 128*m + 4*i, where m = addr-DATA_START. Therefore m = w >> 7, i = (w / 4) % 32 = (w >> 2) & 0x1f. */ static int *mark_table; #define MTbit(x) ((ptr2int(x) >> 2) & 0x1f) #define MTword(x) mark_table[((cl_ptr)x - heap_start) >> 7] #define get_mark_bit(x) (MTword(x) >> MTbit(x) & 1) #define set_mark_bit(x) (MTword(x) |= (1 << MTbit(x))) #define clear_mark_bit(x) (MTword(x) ~= (~1 << MTbit(x))) #define VALID_DATA_ADDRESS(pp) \ (!ECL_IMMEDIATE(pp) && (heap_start <= (cl_ptr)(pp)) && ((cl_ptr)(pp) < heap_end)) static bool debug = FALSE; static int maxpage; #define GC_ROOT_MAX 200 static cl_object *gc_root[GC_ROOT_MAX]; static int gc_roots; static bool collect_blocks; static int gc_time; /* Beppe */ /* We must register location, since value may be reassigned (e.g. malloc_list) */ static void _mark_object(cl_object x); static void _mark_contblock(void *p, cl_index s); static void mark_cl_env(struct cl_env_struct *env); extern void sigint (void); void ecl_register_root(cl_object *p) { if (gc_roots >= GC_ROOT_MAX) ecl_internal_error("too many roots"); gc_root[gc_roots++] = p; } cl_object si_gc(cl_object area) { if (!GC_enabled()) ecl_internal_error("GC is not enabled"); if (Null(area)) ecl_gc(t_cons); else ecl_gc(t_contiguous); @(return) } /*---------------------------------------------------------------------- * Mark phase *---------------------------------------------------------------------- */ /* Whenever two arrays are linked together by displacement, if one is live, the other will be made live */ #define mark_displaced(ar) mark_object(ar) #define mark_contblock(x,s) {if (collect_blocks) _mark_contblock(x,s); } #if 1 #define mark_object(x) if ((x != OBJNULL) && !ECL_IMMEDIATE(x)) _mark_object(x) #define mark_next(a) if ((a != OBJNULL) && !ECL_IMMEDIATE(a)) { x=(a); goto BEGIN; } #else #define mark_object(x) _mark_object(x) #define mark_next(a) x=(a); goto BEGIN #endif /* We make bitvectors multiple of sizeof(int) in size allocated Assume 8 = number of bits in char */ #define W_SIZE (8*sizeof(int)) static void _mark_object(cl_object x) { cl_index i, j; cl_object *p, y; cl_ptr cp; BEGIN: #if 0 /* We cannot get here because mark_object() and mark_next() already check this */ if (ECL_IMMEDIATE(x)) return; /* fixnum, character or locative */ if (x == OBJNULL) return; #endif /* We need this, because sometimes we arrive to data structures * which have been created in the C stack (t_frame in gfun.d, * for instance) */ if (!VALID_DATA_ADDRESS(x)) return; if (x->d.m) { if (x->d.m == FREE) ecl_internal_error("mark_object: pointer to free object."); else return; } x->d.m = TRUE; switch (ecl_t_of(x)) { case t_bignum: { /* GMP may set num.alloc before actually allocating anything. With these checks we make sure we do not move anything we don't have to. Besides, we use big_dim as the size of the object, because big_size might even be smaller. */ cl_ptr limbs = (cl_ptr)x->big.big_limbs; cl_index size = x->big.big_dim * sizeof(mp_limb_t); if (size) mark_contblock(limbs, size); break; } case t_ratio: mark_object(x->ratio.num); mark_next(x->ratio.den); break; #ifdef ECL_SSE2 case t_sse_pack: #endif case t_singlefloat: case t_doublefloat: #ifdef ECL_LONG_FLOAT case t_longfloat: #endif break; case t_complex: mark_object(x->complex.imag); mark_next(x->complex.real); break; case t_character: break; case t_symbol: mark_object(x->symbol.hpack); mark_object(x->symbol.name); mark_object(x->symbol.plist); mark_object(x->symbol.gfdef); mark_next(x->symbol.value); break; case t_package: mark_object(x->pack.name); mark_object(x->pack.nicknames); mark_object(x->pack.shadowings); mark_object(x->pack.uses); mark_object(x->pack.usedby); mark_object(x->pack.internal); mark_next(x->pack.external); break; case t_cons: mark_object(CAR(x)); mark_next(CDR(x)); break; case t_hashtable: mark_object(x->hash.rehash_size); mark_object(x->hash.threshold); if (x->hash.data == NULL) break; for (i = 0, j = x->hash.size; i < j; i++) { mark_object(x->hash.data[i].key); mark_object(x->hash.data[i].value); } mark_contblock(x->hash.data, j * sizeof(struct ecl_hashtable_entry)); break; case t_array: mark_contblock(x->array.dims, sizeof(x->array.dims[0])*x->array.rank); #ifdef ECL_UNICODE case t_string: #endif case t_vector: if ((y = x->array.displaced) != ECL_NIL) mark_displaced(y); cp = (cl_ptr)x->array.self.t; if (cp == NULL) break; switch ((cl_elttype)x->array.elttype) { #ifdef ECL_UNICODE case ecl_aet_ch: #endif case ecl_aet_object: if (x->array.displaced == ECL_NIL || CAR(x->array.displaced) == ECL_NIL) { i = x->vector.dim; p = x->array.self.t; goto MARK_DATA; } j = sizeof(cl_object)*x->array.dim; break; case ecl_aet_bc: j = x->array.dim; break; case ecl_aet_bit: j = sizeof(int) * ((x->vector.offset + x->vector.dim + W_SIZE -1)/W_SIZE); break; case ecl_aet_fix: j = x->array.dim * sizeof(cl_fixnum); break; case ecl_aet_index: j = x->array.dim * sizeof(cl_index); break; case ecl_aet_sf: j = x->array.dim * sizeof(float); break; case ecl_aet_df: j = x->array.dim * sizeof(double); break; case ecl_aet_b8: j = x->array.dim * sizeof(uint8_t); break; case ecl_aet_i8: j = x->array.dim * sizeof(int8_t); break; default: ecl_internal_error("Allocation botch: unknown array element type"); } goto COPY_ARRAY; case t_base_string: if ((y = x->base_string.displaced) != ECL_NIL) mark_displaced(y); cp = x->base_string.self; if (cp == NULL) break; j = x->base_string.dim+1; COPY_ARRAY: mark_contblock(cp, j); break; case t_bitvector: if ((y = x->vector.displaced) != ECL_NIL) mark_displaced(y); cp = x->vector.self.bit; if (cp == NULL) break; j= sizeof(int) * ((x->vector.offset + x->vector.dim + W_SIZE -1)/W_SIZE); goto COPY_ARRAY; case t_stream: switch ((enum ecl_smmode)x->stream.mode) { case ecl_smm_input: case ecl_smm_output: case ecl_smm_io: case ecl_smm_probe: mark_contblock(x->stream.buffer, BUFSIZ); mark_object(x->stream.object0); mark_next(x->stream.object1); break; case ecl_smm_synonym: mark_next(x->stream.object0); break; case ecl_smm_broadcast: case ecl_smm_concatenated: mark_next(x->stream.object0); break; case ecl_smm_two_way: case ecl_smm_echo: mark_object(x->stream.object0); mark_next(x->stream.object1); break; case ecl_smm_string_input: case ecl_smm_string_output: mark_next(x->stream.object0); break; default: ecl_internal_error("mark stream botch"); } break; case t_random: break; case t_readtable: if (x->readtable.table == NULL) break; mark_contblock((cl_ptr)(x->readtable.table), RTABSIZE*sizeof(struct ecl_readtable_entry)); for (i = 0; i < RTABSIZE; i++) { cl_object *p = x->readtable.table[i].dispatch_table; mark_object(x->readtable.table[i].macro); if (p != NULL) { mark_contblock(p, RTABSIZE*sizeof(cl_object)); for (j = 0; j < RTABSIZE; j++) mark_object(p[j]); } } break; case t_pathname: mark_object(x->pathname.host); mark_object(x->pathname.device); mark_object(x->pathname.version); mark_object(x->pathname.name); mark_object(x->pathname.type); mark_next(x->pathname.directory); break; case t_bytecodes: mark_object(x->bytecodes.name); mark_object(x->bytecodes.lex); mark_object(x->bytecodes.specials); mark_object(x->bytecodes.definition); mark_contblock(x->bytecodes.code, x->bytecodes.code_size * sizeof(cl_opcode)); mark_next(x->bytecodes.data); break; case t_bclosure: mark_object(x->bclosure.code); mark_next(x->bclosure.lex); break; case t_cfun: case t_cfunfixed: mark_object(x->cfun.block); mark_next(x->cfun.name); break; case t_cclosure: mark_object(x->cfun.block); mark_next(x->cclosure.env); break; #ifdef ECL_THREADS case t_process: /* Already marked by malloc: x->process.env */ mark_object(x->process.name); mark_object(x->process.interrupt); mark_object(x->process.function); mark_cl_env(x->process.env); mark_next(x->process.args); break; case t_lock: mark_next(x->lock.name); mark_next(x->lock.holder); break; case t_condition_variable: break; #endif /* THREADS */ #ifdef ECL_SEMAPHORES case t_semaphore: break; #endif case t_instance: mark_object(x->instance.clas); mark_object(x->instance.sig); p = x->instance.slots; i = x->instance.length; goto MARK_DATA; case t_codeblock: mark_object(x->cblock.name); mark_object(x->cblock.next); mark_object(x->cblock.links); p = x->cblock.temp_data; if (p) { i = x->cblock.temp_data_size; mark_contblock(p, i * sizeof(cl_object)); while (i-- > 0) mark_object(p[i]); } i = x->cblock.data_size; p = x->cblock.data; goto MARK_DATA; case t_foreign: if (x->foreign.size) mark_contblock(x->foreign.data, x->foreign.size); mark_next(x->foreign.tag); break; MARK_DATA: if (p) { mark_contblock(p, i * sizeof(cl_object)); while (i-- > 0) mark_object(p[i]); } return; default: if (debug) printf("\ttype = %d\n", ecl_t_of(x)); ecl_internal_error("mark botch"); } } static void mark_stack_conservative(cl_ptr bottom, cl_ptr top) { int p, m; cl_object x; struct typemanager *tm; cl_ptr j; if (debug) { printf("Traversing C stack .."); fflush(stdout); } /* On machines which align local pointers on multiple of 2 rather than 4 we need to mark twice if (offset) mark_stack_conservative(bottom, ((char *) top) + offset, 0); */ for (j = bottom ; j < top ; j+=sizeof(cl_ptr)) { cl_ptr aux = *((cl_ptr*)j); /* improved Beppe: */ if (VALID_DATA_ADDRESS(aux) && type_map[p = page(aux)] < (char)t_end) { tm = tm_of((cl_type)type_map[p]); x = (cl_object)(aux - (aux - pagetochar(p)) % tm->tm_size); m = x->d.m; if (m != FREE && m != TRUE) { if (m) { fprintf(stderr, "** bad value %d of d.m in gc page %d skipping mark **", m, p); fflush(stderr); } else { mark_object(x); } } } } if (debug) { printf(". done.\n"); fflush(stdout); } } static void mark_cl_env(struct cl_env_struct *env) { int i = 0; cl_object where = 0; ecl_bds_ptr bdp = 0; ecl_frame_ptr frp = 0; ecl_ihs_ptr ihs = 0; mark_contblock(env, sizeof(*env)); mark_object(env->lex_env); mark_contblock(env->stack, env->stack_size * sizeof(cl_object)); mark_stack_conservative((cl_ptr)env->stack, (cl_ptr)env->stack_top); if ((bdp = env->bds_org)) { mark_contblock(bdp, env->bds_size * sizeof(*bdp)); for (; bdp <= env->bds_top; bdp++) { mark_object(bdp->symbol); mark_object(bdp->value); } } mark_object(env->bindings_hash); if ((frp = env->frs_org)) { mark_contblock(frp, env->frs_size * sizeof(*frp)); for (; frp <= env->frs_top; frp++) { mark_object(frp->frs_val); } } for (ihs = env->ihs_top; ihs; ihs = ihs->next) { mark_object(ihs->function); mark_object(ihs->lex_env); } for (i=0; invalues; i++) mark_object(env->values[i]); mark_object(env->string_pool); if (env->c_env) { mark_object(env->c_env->variables); mark_object(env->c_env->macros); mark_object(env->c_env->constants); } mark_object(env->fmt_aux_stream); mark_contblock(env->queue, sizeof(short) * ECL_PPRINT_QUEUE_SIZE); mark_contblock(env->indent_stack, sizeof(short) * ECL_PPRINT_INDENTATION_STACK_SIZE); mark_object(env->big_register[0]); mark_object(env->big_register[1]); mark_object(env->big_register[2]); #ifdef ECL_THREADS mark_object(env->method_hash_clear_list); #endif mark_object(env->method_hash); mark_object(env->method_spec_vector); #ifdef ECL_THREADS /* We should mark the stacks of the threads somehow!!! */ #error "The old garbage collector does not support threads" #else # ifdef ECL_DOWN_STACK mark_stack_conservative((cl_ptr)(&where), (cl_ptr)env->cs_org); # else mark_stack_conservative((cl_ptr)env->cs_org, (cl_ptr)(&where)); # endif /* ECL_DOWN_STACK */ #endif /* THREADS */ #ifdef ECL_FFICALL mark_contblock(env->fficall, sizeof(struct ecl_fficall)); mark_object(((struct ecl_fficall*)env->fficall)->cstring); #endif } static void mark_phase(void) { int i; cl_object s; /* save registers on the stack */ jmp_buf volatile registers; ecl_setjmp(registers); /* mark registered symbols & keywords */ for (i=0; isymbol.m = FALSE; } for (i=0; ivector.fillp; i++) { cl_object dll = s->vector.self.t[i]; if (dll->cblock.locked) { mark_object(dll); } } s->vector.elttype = ecl_aet_fix; mark_object(s); s->vector.elttype = ecl_aet_object; } mark_stack_conservative((cl_ptr)&cl_core, (cl_ptr)(&cl_core + 1)); /* mark roots */ for (i = 0; i < gc_roots; i++) mark_object(*gc_root[i]); #ifdef ECL_THREADS mark_object(cl_core.processes); #else mark_cl_env(&cl_env); #endif } static void sweep_phase(void) { register int i, j, k; register cl_object x; register cl_ptr p; register struct typemanager *tm; register cl_object f; ECL_NIL->symbol.m = FALSE; ECL_T->symbol.m = FALSE; if (debug) printf("type map\n"); for (i = 0; i < maxpage; i++) { if (type_map[i] == (int)t_contiguous) { if (debug) { printf("-"); continue; } } if (type_map[i] >= (int)t_end) continue; tm = tm_of((cl_type)type_map[i]); /* general sweeper */ if (debug) printf("%c", tm->tm_name[0]); p = pagetochar(i); f = tm->tm_free; k = 0; for (j = tm->tm_nppage; j > 0; --j, p += tm->tm_size) { x = (cl_object)p; if (x->d.m == FREE) continue; else if (x->d.m) { x->d.m = FALSE; continue; } /* INV: Make sure this is the same as in alloc_2.d */ switch (x->d.t) { #ifdef ENABLE_DLOPEN case t_codeblock: ecl_library_close(x); break; #endif case t_stream: if (!x->stream.closed) cl_close(1, x); break; #ifdef ECL_THREADS case t_lock: #if defined(ECL_MS_WINDOWS_HOST) CloseHandle(x->lock.mutex); #else pthread_mutex_destroy(&x->lock.mutex); #endif break; case t_condition_variable: #if defined(ECL_MS_WINDOWS_HOST) CloseHandle(x->condition_variable.cv); #else pthread_cond_destroy(&x->condition_variable.cv); #endif break; #endif #ifdef ECL_SEMAPHORES case t_semaphore: #error "Unfinished" break; #endif default:; } ((struct freelist *)x)->f_link = f; x->d.m = FREE; f = x; k++; } tm->tm_free = f; tm->tm_nfree += k; tm->tm_nused -= k; } if (debug) { putchar('\n'); fflush(stdout); } } static void contblock_sweep_phase(void) { register int i, j; register cl_ptr s, e, p, q; register struct contblock *cbp; cb_pointer = NULL; ncb = 0; for (i = 0; i < maxpage;) { if (type_map[i] != (int)t_contiguous) { i++; continue; } for (j = i+1; j < maxpage && type_map[j] == (int)t_contiguous; j++) ; s = pagetochar(i); e = pagetochar(j); for (p = s; p < e;) { if (get_mark_bit((int *)p)) { p += 4; continue; } q = p + 4; while (q < e && !get_mark_bit((int *)q)) q += 4; ecl_dealloc(p); p = q + 4; } i = j + 1; } if (debug) { for (cbp = cb_pointer; cbp != NULL; cbp = cbp->cb_link) printf("0x%p %d\n", cbp, cbp->cb_size); fflush(stdout); } } cl_object (*GC_enter_hook)() = NULL; cl_object (*GC_exit_hook)() = NULL; void ecl_gc(cl_type t) { const cl_env_ptr env = ecl_process_env(); int i, j; int tm; int gc_start = ecl_runtime(); bool interrupts; if (!GC_enabled()) return; GC_disable(); CL_NEWENV_BEGIN { if (SYM_VAL(@'si::*gc-verbose*') != ECL_NIL) { printf("\n[GC .."); /* To use this should add entries in tm_table for reloc and contig. fprintf(stdout, "\n[GC for %d %s pages ..", tm_of(t)->tm_npage, tm_table[(int)t].tm_name + 1); */ fflush(stdout); } debug = ecl_symbol_value(@'si::*gc-message*') != ECL_NIL; if (GC_enter_hook != NULL) (*GC_enter_hook)(); #ifdef THREADS #error "We need to stop all other threads" #endif /* THREADS */ interrupts = env->disable_interrupts; env->disable_interrupts = 1; collect_blocks = t > t_end; if (collect_blocks) cbgccount++; else tm_table[(int)t].tm_gccount++; if (debug) { if (collect_blocks) printf("GC entered for collecting blocks\n"); else printf("GC entered for collecting %s\n", tm_table[(int)t].tm_name); fflush(stdout); } maxpage = page(heap_end); if (collect_blocks) { /* 1 page = 512 word 512 bit = 16 word */ int mark_table_size = maxpage * (LISP_PAGESIZE / 32); extern void cl_resize_hole(cl_index); if (holepage < mark_table_size*sizeof(int)/LISP_PAGESIZE + 1) new_holepage = mark_table_size*sizeof(int)/LISP_PAGESIZE + 1; if (new_holepage < HOLEPAGE) new_holepage = HOLEPAGE; cl_resize_hole(new_holepage); mark_table = (int*)heap_end; for (i = 0; i < mark_table_size; i++) mark_table[i] = 0; } if (debug) { printf("mark phase\n"); fflush(stdout); tm = ecl_runtime(); } mark_phase(); if (debug) { printf("mark ended (%d)\n", ecl_runtime() - tm); printf("sweep phase\n"); fflush(stdout); tm = ecl_runtime(); } sweep_phase(); if (debug) { printf("sweep ended (%d)\n", ecl_runtime() - tm); fflush(stdout); } if (t == t_contiguous) { if (debug) { printf("contblock sweep phase\n"); fflush(stdout); tm = ecl_runtime(); } contblock_sweep_phase(); if (debug) printf("contblock sweep ended (%d)\n", ecl_runtime() - tm); } if (debug) { for (i = 0, j = 0; i < (int)t_end; i++) { if (tm_table[i].tm_type == (cl_type)i) { printf("%13s: %8d used %8d free %4d/%d pages\n", tm_table[i].tm_name, tm_table[i].tm_nused, tm_table[i].tm_nfree, tm_table[i].tm_npage, tm_table[i].tm_maxpage); j += tm_table[i].tm_npage; } else printf("%13s: linked to %s\n", tm_table[i].tm_name, tm_table[(int)tm_table[i].tm_type].tm_name); } printf("contblock: %d blocks %d pages\n", ncb, ncbpage); printf("hole: %d pages\n", holepage); printf("GC ended\n"); fflush(stdout); } env->disable_interrupts = interrupts; if (GC_exit_hook != NULL) (*GC_exit_hook)(); } CL_NEWENV_END; GC_enable(); #ifdef THREADS #error "We need to activate all other threads again" #endif /* THREADS */ gc_time += (gc_start = ecl_runtime() - gc_start); if (SYM_VAL(@'si::*gc-verbose*') != ECL_NIL) { /* Don't use fprintf since on Linux it calls malloc() */ printf(". finished in %.2f\"]", gc_start/60.0); fflush(stdout); } if (env->interrupt_pending) ecl_check_pending_interrupts(); } /* *---------------------------------------------------------------------- * * mark_contblock -- * sets the mark bit for words from address p to address p+s. * Both p and p+s are rounded to word boundaries. * * Results: * none. * * Side effects: * mark_table * *---------------------------------------------------------------------- */ static void _mark_contblock(void *x, cl_index s) { cl_ptr p = x; if (p >= heap_start && p < data_end) { ptrdiff_t pg = page(p); if ((cl_type)type_map[pg] == t_contiguous) { cl_ptr q = p + s; p = int2ptr(ptr2int(p) & ~3); q = int2ptr(ptr2int(q + 3) & ~3); for (; p < q; p+= 4) set_mark_bit(p); } } } /*---------------------------------------------------------------------- * Utilities *---------------------------------------------------------------------- */ @(defun si::room-report () int i; cl_object *tl; @ the_env->nvalues = 8; the_env->values[0] = ecl_make_fixnum(real_maxpage); the_env->values[1] = ecl_make_fixnum(available_pages()); the_env->values[2] = ecl_make_fixnum(ncbpage); the_env->values[3] = ecl_make_fixnum(maxcbpage); the_env->values[4] = ecl_make_fixnum(ncb); the_env->values[5] = ecl_make_fixnum(cbgccount); the_env->values[6] = ecl_make_fixnum(holepage); the_env->values[7] = ECL_NIL; tl = &the_env->values[7]; for (i = 0; i < (int)t_end; i++) { if (tm_table[i].tm_type == (cl_type)i) { tl = &CDR(*tl = CONS(ecl_make_fixnum(tm_table[i].tm_nused), ECL_NIL)); tl = &CDR(*tl = CONS(ecl_make_fixnum(tm_table[i].tm_nfree), ECL_NIL)); tl = &CDR(*tl = CONS(ecl_make_fixnum(tm_table[i].tm_npage), ECL_NIL)); tl = &CDR(*tl = CONS(ecl_make_fixnum(tm_table[i].tm_maxpage), ECL_NIL)); tl = &CDR(*tl = CONS(ecl_make_fixnum(tm_table[i].tm_gccount), ECL_NIL)); } else { tl = &CDR(*tl = CONS(ECL_NIL, ECL_NIL)); tl = &CDR(*tl = CONS(ecl_make_fixnum(tm_table[i].tm_type), ECL_NIL)); tl = &CDR(*tl = CONS(ECL_NIL, ECL_NIL)); tl = &CDR(*tl = CONS(ECL_NIL, ECL_NIL)); tl = &CDR(*tl = CONS(ECL_NIL, ECL_NIL)); } } return the_env->values[0]; @) @(defun si::reset-gc-count () int i; @ cbgccount = 0; for (i = 0; i < (int)t_end; i++) tm_table[i].tm_gccount = 0; @(return) @) @(defun si::gc-time () @ @(return ecl_make_fixnum(gc_time)) @) cl_object si_get_finalizer(cl_object o) { @(return ECL_NIL) } cl_object si_set_finalizer(cl_object o, cl_object finalizer) { @(return) } void init_GC(void) { GC_enable(); gc_time = 0; } ecl-16.1.2/src/c/gfun.d000066400000000000000000000263561266352375300145110ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* gfun.c -- Dispatch for generic functions. */ /* Copyright (c) 1990, Giuseppe Attardi. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #include #include #include #include static cl_object generic_function_dispatch_vararg(cl_narg, ...); cl_object FEnot_funcallable_fixed() { cl_env_ptr env = ecl_process_env(); cl_object fun = env->function; FEerror("Not a funcallable instance ~A.", 1, fun); @(return); } cl_object FEnot_funcallable_vararg(cl_narg narg, ...) { return FEnot_funcallable_fixed(); } static cl_object user_function_dispatch(cl_narg narg, ...) { int i; cl_object output; cl_env_ptr env = ecl_process_env(); cl_object fun = env->function; struct ecl_stack_frame frame_aux; const cl_object frame = ecl_stack_frame_open(env, (cl_object)&frame_aux, narg); ecl_va_list args; ecl_va_start(args, narg, narg, 0); for (i = 0; i < narg; i++) { ECL_STACK_FRAME_SET(frame, i, ecl_va_arg(args)); } fun = fun->instance.slots[fun->instance.length - 1]; output = ecl_apply_from_stack_frame(frame, fun); ecl_stack_frame_close(frame); return output; } static void reshape_instance(cl_object x, int delta) { cl_fixnum size = x->instance.length + delta; cl_object aux = ecl_allocate_instance(ECL_CLASS_OF(x), size); /* Except for the different size, this must match si_copy_instance */ aux->instance.sig = x->instance.sig; memcpy(aux->instance.slots, x->instance.slots, (delta < 0 ? aux->instance.length : x->instance.length) * sizeof(cl_object)); x->instance = aux->instance; } cl_object clos_set_funcallable_instance_function(cl_object x, cl_object function_or_t) { if (ecl_unlikely(!ECL_INSTANCEP(x))) FEwrong_type_nth_arg(@[clos::set-funcallable-instance-function], 1, x, @[ext::instance]); if (x->instance.isgf == ECL_USER_DISPATCH) { reshape_instance(x, -1); x->instance.isgf = ECL_NOT_FUNCALLABLE; } if (function_or_t == ECL_T) { x->instance.isgf = ECL_STANDARD_DISPATCH; x->instance.entry = generic_function_dispatch_vararg; } else if (function_or_t == @'standard-generic-function') { x->instance.isgf = ECL_RESTRICTED_DISPATCH; x->instance.entry = generic_function_dispatch_vararg; } else if (function_or_t == ECL_NIL) { x->instance.isgf = ECL_NOT_FUNCALLABLE; x->instance.entry = FEnot_funcallable_vararg; } else if (function_or_t == @'clos::standard-optimized-reader-method') { /* WARNING: We assume that f(a,...) behaves as f(a,b) */ x->instance.isgf = ECL_READER_DISPATCH; x->instance.entry = (cl_objectfn)ecl_slot_reader_dispatch; } else if (function_or_t == @'clos::standard-optimized-writer-method') { /* WARNING: We assume that f(a,...) behaves as f(a,b) */ x->instance.isgf = ECL_WRITER_DISPATCH; x->instance.entry = (cl_objectfn)ecl_slot_writer_dispatch; } else if (Null(cl_functionp(function_or_t))) { FEwrong_type_argument(@'function', function_or_t); } else { reshape_instance(x, +1); x->instance.slots[x->instance.length - 1] = function_or_t; x->instance.isgf = ECL_USER_DISPATCH; x->instance.entry = user_function_dispatch; } @(return x) } cl_object si_generic_function_p(cl_object x) { @(return ((ECL_INSTANCEP(x) && (x->instance.isgf))? ECL_T : ECL_NIL)) } static cl_object fill_spec_vector(cl_object vector, cl_object frame, cl_object gf) { cl_object *args = frame->frame.base; cl_index narg = frame->frame.size; cl_object spec_how_list = GFUN_SPEC(gf); cl_object *argtype = vector->vector.self.t; int spec_no = 1; argtype[0] = gf; loop_for_on_unsafe(spec_how_list) { cl_object spec_how = ECL_CONS_CAR(spec_how_list); cl_object spec_type = ECL_CONS_CAR(spec_how); int spec_position = ecl_fixnum(ECL_CONS_CDR(spec_how)); cl_object eql_spec; unlikely_if (spec_position >= narg) FEwrong_num_arguments(gf); unlikely_if (spec_no >= vector->vector.dim) ecl_internal_error("Too many arguments to fill_spec_vector()"); /* Need to differentiate between EQL specializers and class specializers, because the EQL value can be a class, and may clash with a class specializer. Store the cons cell containing the EQL value. */ if (ECL_LISTP(spec_type) && !Null(eql_spec = ecl_memql(args[spec_position], spec_type))) { argtype[spec_no++] = eql_spec; } else { argtype[spec_no++] = cl_class_of(args[spec_position]); } } end_loop_for_on_unsafe(spec_how_list); vector->vector.fillp = spec_no; return vector; } static cl_object frame_to_list(cl_object frame) { cl_object arglist, *p; for (p = frame->frame.base + frame->frame.size, arglist = ECL_NIL; p != frame->frame.base; ) { arglist = CONS(*(--p), arglist); } return arglist; } static cl_object frame_to_classes(cl_object frame) { cl_object arglist, *p; for (p = frame->frame.base + frame->frame.size, arglist = ECL_NIL; p != frame->frame.base; ) { arglist = CONS(cl_class_of(*(--p)), arglist); } return arglist; } static cl_object generic_compute_applicable_method(cl_env_ptr env, cl_object frame, cl_object gf) { /* method not cached */ cl_object memoize; cl_object methods = _ecl_funcall3(@'clos::compute-applicable-methods-using-classes', gf, frame_to_classes(frame)); unlikely_if (Null(memoize = env->values[1])) { cl_object arglist = frame_to_list(frame); methods = _ecl_funcall3(@'compute-applicable-methods', gf, arglist); unlikely_if (methods == ECL_NIL) { env->values[1] = ECL_NIL; return methods; } } methods = clos_compute_effective_method_function(gf, GFUN_COMB(gf), methods); env->values[1] = ECL_T; return methods; } static cl_object restricted_compute_applicable_method(cl_env_ptr env, cl_object frame, cl_object gf) { /* method not cached */ cl_object arglist = frame_to_list(frame); cl_object methods = clos_std_compute_applicable_methods(gf, arglist); unlikely_if (methods == ECL_NIL) { env->values[1] = ECL_NIL; return methods; } methods = clos_std_compute_effective_method(gf, GFUN_COMB(gf), methods); env->values[1] = ECL_T; return methods; } static cl_object compute_applicable_method(cl_env_ptr env, cl_object frame, cl_object gf) { if (gf->instance.isgf == ECL_RESTRICTED_DISPATCH) return restricted_compute_applicable_method(env, frame, gf); else return generic_compute_applicable_method(env, frame, gf); } cl_object _ecl_standard_dispatch(cl_object frame, cl_object gf) { cl_object func, vector; const cl_env_ptr env = frame->frame.env; ecl_cache_ptr cache = env->method_cache; ecl_cache_record_ptr e; /* * We have to copy the frame because it might be stored in cl_env.values * which will be wiped out by the next function call. However this only * happens when we cannot reuse the values in the C stack. */ #if !defined(ECL_USE_VARARG_AS_POINTER) struct ecl_stack_frame frame_aux; if (frame->frame.stack == (void*)0x1) { const cl_object new_frame = (cl_object)&frame_aux; ECL_STACK_FRAME_COPY(new_frame, frame); frame = new_frame; } #endif vector = fill_spec_vector(cache->keys, frame, gf); e = ecl_search_cache(cache); if (e->key != OBJNULL) { func = e->value; } else { /* The keys and the cache may change while we * compute the applicable methods. We must save * the keys and recompute the cache location if * it was filled. */ cl_object keys = cl_copy_seq(vector); func = compute_applicable_method(env, frame, gf); if (env->values[1] != ECL_NIL) { if (e->key != OBJNULL) { e = ecl_search_cache(cache); } e->key = keys; e->value = func; } } if (func == ECL_NIL) func = cl_apply(3, @'no-applicable-method', gf, frame); else func = _ecl_funcall3(func, frame, ECL_NIL); /* Only need to close the copy */ #if !defined(ECL_USE_VARARG_AS_POINTER) if (frame == (cl_object)&frame_aux) ecl_stack_frame_close(frame); #endif return func; } static cl_object generic_function_dispatch_vararg(cl_narg narg, ...) { cl_object output; ECL_STACK_FRAME_VARARGS_BEGIN(narg, narg, frame) { output = _ecl_standard_dispatch(frame, frame->frame.env->function); } ECL_STACK_FRAME_VARARGS_END(frame); return output; } cl_object si_clear_gfun_hash(cl_object what) { /* * This function clears the generic function call hashes selectively. * what = ECL_T means clear the hash completely * what = generic function, means cleans only these entries * If we work on a multithreaded environment, we simply enqueue these * operations and wait for the destination thread to update its own hash. */ cl_env_ptr the_env = ecl_process_env(); #ifdef ECL_THREADS cl_object list; for (list = mp_all_processes(); !Null(list); list = ECL_CONS_CDR(list)) { cl_object process = ECL_CONS_CAR(list); struct cl_env_struct *env = process->process.env; if (the_env != env) { ecl_cache_remove_one(env->method_cache, what); ecl_cache_remove_one(env->slot_cache, what); } } #endif ecl_cache_remove_one(the_env->method_cache, what); ecl_cache_remove_one(the_env->slot_cache, what); ecl_return0(the_env); } ecl-16.1.2/src/c/hash.d000066400000000000000000001140161266352375300144640ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* hash.d -- Hash tables. */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ /* for ECL_MATHERR_* */ #define ECL_INCLUDE_MATH_H #include #include #include #include #include #include #include "newhash.h" #define SYMBOL_NAME(x) (Null(x)? ECL_NIL_SYMBOL->symbol.name : (x)->symbol.name) static void ECL_INLINE assert_type_hash_table(cl_object function, cl_narg narg, cl_object p) { unlikely_if (!ECL_HASH_TABLE_P(p)) FEwrong_type_nth_arg(function, narg, p, @[hash-table]); } static cl_hashkey _hash_eql(cl_hashkey h, cl_object x) { switch (ecl_t_of(x)) { case t_bignum: return hash_string(h, (unsigned char*)ECL_BIGNUM_LIMBS(x), labs(ECL_BIGNUM_SIZE(x)) * sizeof(mp_limb_t)); case t_ratio: h = _hash_eql(h, x->ratio.num); return _hash_eql(h, x->ratio.den); case t_singlefloat: return hash_string(h, (unsigned char*)&ecl_single_float(x), sizeof(ecl_single_float(x))); case t_doublefloat: return hash_string(h, (unsigned char*)&ecl_double_float(x), sizeof(ecl_double_float(x))); #ifdef ECL_LONG_FLOAT case t_longfloat: { /* We coerce to double because long double has extra bits * that give rise to different hash key and are not * meaningful */ struct { double mantissa; int exponent; int sign; } aux; aux.mantissa = frexpl(ecl_long_float(x), &aux.exponent); aux.sign = (ecl_long_float(x) < 0)? -1: 1; return hash_string(h, (unsigned char*)&aux, sizeof(aux)); } #endif case t_complex: h = _hash_eql(h, x->complex.real); return _hash_eql(h, x->complex.imag); case t_character: return hash_word(h, ECL_CHAR_CODE(x)); #ifdef ECL_SSE2 case t_sse_pack: return hash_string(h, x->sse.data.b8, 16); #endif default: return hash_word(h, ((cl_hashkey)x >> 2)); } } static cl_hashkey _hash_equal(int depth, cl_hashkey h, cl_object x) { switch (ecl_t_of(x)) { case t_list: if (Null(x)) { return _hash_equal(depth, h, ECL_NIL_SYMBOL->symbol.name); } if (--depth == 0) { return h; } else { h = _hash_equal(depth, h, ECL_CONS_CAR(x)); return _hash_equal(depth, h, ECL_CONS_CDR(x)); } case t_symbol: x = x->symbol.name; #ifdef ECL_UNICODE case t_base_string: return hash_base_string((ecl_base_char *)x->base_string.self, x->base_string.fillp, h); case t_string: return hash_full_string(x->string.self, x->string.fillp, h); #else case t_base_string: return hash_string(h, (ecl_base_char *)x->base_string.self, x->base_string.fillp); #endif case t_pathname: h = _hash_equal(0, h, x->pathname.directory); h = _hash_equal(0, h, x->pathname.name); h = _hash_equal(0, h, x->pathname.type); h = _hash_equal(0, h, x->pathname.host); h = _hash_equal(0, h, x->pathname.device); return _hash_equal(0, h, x->pathname.version); case t_bitvector: /* Notice that we may round out some bits. We must do this * because the fill pointer may be set in the middle of a byte. * If so, the extra bits _must_ _not_ take part in the hash, * because otherwise two bit arrays which are EQUAL might * have different hash keys. */ return hash_string(h, x->vector.self.bc, x->vector.fillp / 8); case t_random: { cl_object array = x->random.value; return hash_string (h, (unsigned char*)array->vector.self.b8, 4*624); } #ifdef ECL_SIGNED_ZERO case t_singlefloat: { float f = ecl_single_float(x); if (f == 0.0) f = 0.0; return hash_string(h, (unsigned char*)&f, sizeof(f)); } case t_doublefloat: { double f = ecl_double_float(x); if (f == 0.0) f = 0.0; return hash_string(h, (unsigned char*)&f, sizeof(f)); } # ifdef ECL_LONG_FLOAT case t_longfloat: { /* We coerce to double because long double has extra bits * that give rise to different hash key and are not * meaningful */ struct { double mantissa; int exponent; int sign; } aux; aux.mantissa = frexpl(ecl_long_float(x), &aux.exponent); aux.sign = (ecl_long_float(x) < 0)? -1: 1; if (aux.mantissa == 0.0) aux.mantissa = 0.0; return hash_string(h, (unsigned char*)&aux, sizeof(aux)); } # endif case t_complex: { h = _hash_equal(depth, h, x->complex.real); return _hash_equal(depth, h, x->complex.imag); } #endif default: return _hash_eql(h, x); } } static cl_hashkey _hash_equalp(int depth, cl_hashkey h, cl_object x) { cl_index i, len; switch (ecl_t_of(x)) { case t_character: return hash_word(h, ecl_char_upcase(ECL_CHAR_CODE(x))); case t_list: if (Null(x)) { return _hash_equalp(depth, h, ECL_NIL_SYMBOL->symbol.name); } if (--depth == 0) { return h; } else { h = _hash_equalp(depth, h, ECL_CONS_CAR(x)); return _hash_equalp(depth, h, ECL_CONS_CDR(x)); } #ifdef ECL_UNICODE case t_string: #endif case t_base_string: case t_vector: case t_bitvector: len = x->vector.fillp; goto SCAN; case t_array: len = x->vector.dim; SCAN: if (--depth) { for (i = 0; i < len; i++) { h = _hash_equalp(depth, h, ecl_aref_unsafe(x, i)); } } return h; case t_fixnum: return hash_word(h, ecl_fixnum(x)); case t_singlefloat: /* FIXME! We should be more precise here! */ return hash_word(h, (cl_index)ecl_single_float(x)); case t_doublefloat: /* FIXME! We should be more precise here! */ return hash_word(h, (cl_index)ecl_double_float(x)); case t_bignum: /* FIXME! We should be more precise here! */ return hash_string(h, (unsigned char*)x->big.big_num->_mp_d, abs(x->big.big_num->_mp_size) * sizeof(mp_limb_t)); case t_ratio: h = _hash_equalp(0, h, x->ratio.num); return _hash_equalp(0, h, x->ratio.den); case t_complex: h = _hash_equalp(0, h, x->complex.real); return _hash_equalp(0, h, x->complex.imag); case t_instance: case t_hashtable: /* FIXME! We should be more precise here! */ return hash_word(h, 42); default: return _hash_equal(depth, h, x); } } #define HASH_TABLE_LOOP(hkey,hvalue,h,HASH_TABLE_LOOP_TEST) { \ cl_index hsize = hashtable->hash.size; \ cl_index i = h % hsize, j = hsize, k; \ for (k = 0; k < hsize; i = (i + 1) % hsize, k++) { \ struct ecl_hashtable_entry *e = hashtable->hash.data + i; \ cl_object hkey = e->key, hvalue = e->value; \ if (hkey == OBJNULL) { \ if (e->value == OBJNULL) { \ if (j == hsize) \ return e; \ else \ return hashtable->hash.data + j; \ } else { \ if (j == hsize) \ j = i; \ else if (j == i) \ return e; \ } \ continue; \ } \ if (HASH_TABLE_LOOP_TEST) return hashtable->hash.data + i; \ } \ return hashtable->hash.data + j; \ } #if 0 #define HASH_TABLE_SET(h,loop,compute_key,store_key) #else #define HASH_TABLE_SET(h,loop,compute_key,store_key) { \ cl_hashkey h = compute_key; \ struct ecl_hashtable_entry *e; \ AGAIN: \ e = loop(h, key, hashtable); \ if (e->key == OBJNULL) { \ cl_index i = hashtable->hash.entries + 1; \ if (i >= hashtable->hash.limit) { \ hashtable = ecl_extend_hashtable(hashtable); \ goto AGAIN; \ } \ hashtable->hash.entries = i; \ e->key = store_key; \ } \ e->value = value; \ return hashtable; \ } #endif /* * EQ HASHTABLES */ #if 0 #define _hash_eq(k) ((cl_hashkey)(k) ^ ((cl_hashkey)(k) >> 16)) #else #define _hash_eq(k) ((cl_hashkey)(k) >> 2) #endif static struct ecl_hashtable_entry * _ecl_hash_loop_eq(cl_hashkey h, cl_object key, cl_object hashtable) { HASH_TABLE_LOOP(hkey, hvalue, h, key == hkey); } static cl_object _ecl_gethash_eq(cl_object key, cl_object hashtable, cl_object def) { cl_hashkey h = _hash_eq(key); struct ecl_hashtable_entry *e = _ecl_hash_loop_eq(h, key, hashtable); return (e->key == OBJNULL)? def : e->value; } static bool _ecl_remhash_eq(cl_object key, cl_object hashtable) { cl_hashkey h = _hash_eq(key); struct ecl_hashtable_entry *e = _ecl_hash_loop_eq(h, key, hashtable); if (e->key == OBJNULL) { return 0; } else { e->key = OBJNULL; e->value = ECL_NIL; hashtable->hash.entries--; return 1; } } static cl_object _ecl_sethash_eq(cl_object key, cl_object hashtable, cl_object value) { HASH_TABLE_SET(h, _ecl_hash_loop_eq, _hash_eq(key), key); } /* * EQL HASHTABLES */ static struct ecl_hashtable_entry * _ecl_hash_loop_eql(cl_hashkey h, cl_object key, cl_object hashtable) { HASH_TABLE_LOOP(hkey, hvalue, h, ecl_eql(key, hkey)); } static cl_object _ecl_gethash_eql(cl_object key, cl_object hashtable, cl_object def) { cl_hashkey h = _hash_eql(0, key); struct ecl_hashtable_entry *e = _ecl_hash_loop_eql(h, key, hashtable); return (e->key == OBJNULL)? def : e->value; } static cl_object _ecl_sethash_eql(cl_object key, cl_object hashtable, cl_object value) { HASH_TABLE_SET(h, _ecl_hash_loop_eql, _hash_eql(0, key), key); } static bool _ecl_remhash_eql(cl_object key, cl_object hashtable) { cl_hashkey h = _hash_eql(0, key); struct ecl_hashtable_entry *e = _ecl_hash_loop_eql(h, key, hashtable); if (e->key == OBJNULL) { return 0; } else { e->key = OBJNULL; e->value = ECL_NIL; hashtable->hash.entries--; return 1; } } /* * EQUAL HASHTABLES */ static struct ecl_hashtable_entry * _ecl_hash_loop_equal(cl_hashkey h, cl_object key, cl_object hashtable) { HASH_TABLE_LOOP(hkey, hvalue, h, ecl_equal(key, hkey)); } static cl_object _ecl_gethash_equal(cl_object key, cl_object hashtable, cl_object def) { cl_hashkey h = _hash_equal(3, 0, key); struct ecl_hashtable_entry *e = _ecl_hash_loop_equal(h, key, hashtable); return (e->key == OBJNULL)? def : e->value; } static cl_object _ecl_sethash_equal(cl_object key, cl_object hashtable, cl_object value) { HASH_TABLE_SET(h, _ecl_hash_loop_equal, _hash_equal(3, 0, key), key); } static bool _ecl_remhash_equal(cl_object key, cl_object hashtable) { cl_hashkey h = _hash_equal(3, 0, key); struct ecl_hashtable_entry *e = _ecl_hash_loop_equal(h, key, hashtable); if (e->key == OBJNULL) { return 0; } else { e->key = OBJNULL; e->value = ECL_NIL; hashtable->hash.entries--; return 1; } } /* * EQUALP HASHTABLES */ static struct ecl_hashtable_entry * _ecl_hash_loop_equalp(cl_hashkey h, cl_object key, cl_object hashtable) { HASH_TABLE_LOOP(hkey, hvalue, h, ecl_equalp(key, hkey)); } static cl_object _ecl_gethash_equalp(cl_object key, cl_object hashtable, cl_object def) { cl_hashkey h = _hash_equalp(3, 0, key); struct ecl_hashtable_entry *e = _ecl_hash_loop_equalp(h, key, hashtable); return (e->key == OBJNULL)? def : e->value; } static cl_object _ecl_sethash_equalp(cl_object key, cl_object hashtable, cl_object value) { HASH_TABLE_SET(h, _ecl_hash_loop_equalp, _hash_equalp(3, 0, key), key); } static bool _ecl_remhash_equalp(cl_object key, cl_object hashtable) { cl_hashkey h = _hash_equalp(3, 0, key); struct ecl_hashtable_entry *e = _ecl_hash_loop_equalp(h, key, hashtable); if (e->key == OBJNULL) { return 0; } else { e->key = OBJNULL; e->value = ECL_NIL; hashtable->hash.entries--; return 1; } } /* * PACKAGE HASHTABLES */ static struct ecl_hashtable_entry * _ecl_hash_loop_pack(cl_hashkey h, cl_object key, cl_object hashtable) { cl_object ho = ecl_make_fixnum(h & 0xFFFFFFF); HASH_TABLE_LOOP(hkey, hvalue, h, (ho==hkey) && ecl_string_eq(key,SYMBOL_NAME(hvalue))); } static cl_object _ecl_gethash_pack(cl_object key, cl_object hashtable, cl_object def) { cl_hashkey h = _hash_equal(3, 0, key); struct ecl_hashtable_entry *e = _ecl_hash_loop_pack(h, key, hashtable); return (e->key == OBJNULL)? def : e->value; } static cl_object _ecl_sethash_pack(cl_object key, cl_object hashtable, cl_object value) { HASH_TABLE_SET(h, _ecl_hash_loop_pack, _hash_equal(3, 0, key), ecl_make_fixnum(h & 0xFFFFFFF)); } static bool _ecl_remhash_pack(cl_object key, cl_object hashtable) { cl_hashkey h = _hash_equal(3, 0, key); struct ecl_hashtable_entry *e = _ecl_hash_loop_pack(h, key, hashtable); if (e->key == OBJNULL) { return 0; } else { e->key = OBJNULL; e->value = ECL_NIL; hashtable->hash.entries--; return 1; } } /* * WEAK HASH TABLES */ #ifndef ECL_WEAK_HASH #define copy_entry(e,h) *(e) #endif #ifdef ECL_WEAK_HASH static cl_hashkey _ecl_hash_key(cl_object h, cl_object o) { switch (h->hash.test) { case ecl_htt_eq: return _hash_eq(o); case ecl_htt_eql: return _hash_eql(0, o); case ecl_htt_equal: return _hash_equal(3, 0, o); case ecl_htt_equalp: default: return _hash_equalp(3, 0, o); } } static void * normalize_weak_key_entry(struct ecl_hashtable_entry *e) { return (void*)(e->key = e->key->weak.value); } static void * normalize_weak_value_entry(struct ecl_hashtable_entry *e) { return (void*)(e->value = e->value->weak.value); } static void * normalize_weak_key_and_value_entry(struct ecl_hashtable_entry *e) { if ((e->key = e->key->weak.value) && (e->value = e->value->weak.value)) return (void*)e; else return 0; } static struct ecl_hashtable_entry copy_entry(struct ecl_hashtable_entry *e, cl_object h) { if (e->key == OBJNULL) { return *e; } else { struct ecl_hashtable_entry output = *e; switch (h->hash.weak) { case ecl_htt_weak_key: if (GC_call_with_alloc_lock(normalize_weak_key_entry, &output)) { return output; } break; case ecl_htt_weak_value: if (GC_call_with_alloc_lock(normalize_weak_value_entry, &output)) { return output; } break; case ecl_htt_weak_key_and_value: if (GC_call_with_alloc_lock(normalize_weak_key_and_value_entry, &output)) { return output; } break; case ecl_htt_not_weak: default: return output; } h->hash.entries--; output.key = OBJNULL; output.value = ECL_NIL; return *e = output; } } static struct ecl_hashtable_entry * _ecl_weak_hash_loop(cl_hashkey h, cl_object key, cl_object hashtable, struct ecl_hashtable_entry *aux) { cl_index hsize = hashtable->hash.size; cl_index i = h % hsize, j = hsize, k; for (k = 0; k < hsize; i = (i + 1) % hsize, k++) { struct ecl_hashtable_entry *p = hashtable->hash.data + i; struct ecl_hashtable_entry e = *aux = copy_entry(p, hashtable); if (e.key == OBJNULL) { if (e.value == OBJNULL) { if (j == hsize) { return p; } else { return hashtable->hash.data + j; } } else { if (j == hsize) { j = i; } else if (j == i) { return p; } } continue; } switch (hashtable->hash.test) { case ecl_htt_eq: if (e.key == key) return p; case ecl_htt_eql: if (ecl_eql(e.key, key)) return p; case ecl_htt_equal: if (ecl_equal(e.key, key)) return p; case ecl_htt_equalp: if (ecl_equalp(e.key, key)) return p; } } return hashtable->hash.data + j; } static cl_object _ecl_gethash_weak(cl_object key, cl_object hashtable, cl_object def) { cl_hashkey h = _ecl_hash_key(hashtable, key); struct ecl_hashtable_entry aux[1]; _ecl_weak_hash_loop(h, key, hashtable, aux); if (aux->key != OBJNULL) { return aux->value; } else { return def; } } static cl_object _ecl_sethash_weak(cl_object key, cl_object hashtable, cl_object value) { cl_hashkey h = _ecl_hash_key(hashtable, key); struct ecl_hashtable_entry aux[1]; struct ecl_hashtable_entry *e; AGAIN: e = _ecl_weak_hash_loop(h, key, hashtable, aux); if (aux->key == OBJNULL) { cl_index i = hashtable->hash.entries + 1; if (i >= hashtable->hash.limit) { hashtable = ecl_extend_hashtable(hashtable); goto AGAIN; } hashtable->hash.entries = i; switch (hashtable->hash.weak) { case ecl_htt_weak_key: key = si_make_weak_pointer(key); break; case ecl_htt_weak_value: value = si_make_weak_pointer(value); break; case ecl_htt_weak_key_and_value: default: key = si_make_weak_pointer(key); value = si_make_weak_pointer(value); break; } e->key = key; } e->value = value; return hashtable; } static bool _ecl_remhash_weak(cl_object key, cl_object hashtable) { cl_hashkey h = _ecl_hash_key(hashtable, key); struct ecl_hashtable_entry aux[1]; struct ecl_hashtable_entry *e = _ecl_weak_hash_loop(h, key, hashtable, aux); if (aux->key != OBJNULL) { hashtable->hash.entries--; e->key = OBJNULL; e->value = ECL_NIL; return 1; } else { return 0; } } #endif /* * HIGHER LEVEL INTERFACE */ cl_object ecl_gethash(cl_object key, cl_object hashtable) { assert_type_hash_table(@[gethash], 2, hashtable); return hashtable->hash.get(key, hashtable, OBJNULL); } cl_object ecl_gethash_safe(cl_object key, cl_object hashtable, cl_object def) { assert_type_hash_table(@[gethash], 2, hashtable); return hashtable->hash.get(key, hashtable, def); } cl_object _ecl_sethash(cl_object key, cl_object hashtable, cl_object value) { return hashtable->hash.set(key, hashtable, value); } cl_object ecl_sethash(cl_object key, cl_object hashtable, cl_object value) { assert_type_hash_table(@[si::hash-set], 2, hashtable); hashtable = hashtable->hash.set(key, hashtable, value); return hashtable; } cl_object ecl_extend_hashtable(cl_object hashtable) { cl_object old, new; cl_index old_size, new_size, i; cl_object new_size_obj; assert_type_hash_table(@[si::hash-set], 2, hashtable); old_size = hashtable->hash.size; /* We do the computation with lisp datatypes, just in case the sizes contain * weird numbers */ if (ECL_FIXNUMP(hashtable->hash.rehash_size)) { new_size_obj = ecl_plus(hashtable->hash.rehash_size, ecl_make_fixnum(old_size)); } else { new_size_obj = ecl_times(hashtable->hash.rehash_size, ecl_make_fixnum(old_size)); new_size_obj = ecl_ceiling1(new_size_obj); } if (!ECL_FIXNUMP(new_size_obj)) { /* New size is too large */ new_size = old_size * 2; } else { new_size = ecl_fixnum(new_size_obj); } if (hashtable->hash.test == ecl_htt_pack) { new = ecl_alloc_object(t_hashtable); new->hash = hashtable->hash; old = hashtable; } else { old = ecl_alloc_object(t_hashtable); old->hash = hashtable->hash; new = hashtable; } new->hash.data = NULL; /* for GC sake */ new->hash.entries = 0; new->hash.size = new_size; new->hash.limit = new->hash.size * new->hash.factor; new->hash.data = (struct ecl_hashtable_entry *) ecl_alloc(new_size * sizeof(struct ecl_hashtable_entry)); for (i = 0; i < new_size; i++) { new->hash.data[i].key = OBJNULL; new->hash.data[i].value = OBJNULL; } for (i = 0; i < old_size; i++) { struct ecl_hashtable_entry e = copy_entry(old->hash.data + i, old); if (e.key != OBJNULL) { new = new->hash.set(new->hash.test == ecl_htt_pack? SYMBOL_NAME(e.value) : e.key, new, e.value); } } return new; } @(defun make_hash_table (&key (test @'eql') (weakness ECL_NIL) (size ecl_make_fixnum(1024)) (rehash_size cl_core.rehash_size) (rehash_threshold cl_core.rehash_threshold)) @ { cl_object hash = cl__make_hash_table(test, size, rehash_size, rehash_threshold); #ifdef ECL_WEAK_HASH if (!Null(weakness)) { if (weakness == @':key') { hash->hash.weak = ecl_htt_weak_key; } else if (weakness == @':value') { hash->hash.weak = ecl_htt_weak_value; } else if (weakness == @':key-and-value') { hash->hash.weak = ecl_htt_weak_key_and_value; } else { FEwrong_type_key_arg(@[make-hash-table], @[:weakness], cl_list(5, @'member', ECL_NIL, @':key', @':value', @':key-and-value'), weakness); } hash->hash.get = _ecl_gethash_weak; hash->hash.set = _ecl_sethash_weak; hash->hash.rem = _ecl_remhash_weak; } #endif @(return hash) } @) static void do_clrhash(cl_object ht) { /* * Fill a hash with null pointers and ensure it does not have * any entry. We separate this routine because it is needed * both by clrhash and hash table initialization. */ cl_index i; ht->hash.entries = 0; for(i = 0; i < ht->hash.size; i++) { ht->hash.data[i].key = OBJNULL; ht->hash.data[i].value = OBJNULL; } } ecl_def_ct_single_float(min_threshold, 0.1, static, const); cl_object cl__make_hash_table(cl_object test, cl_object size, cl_object rehash_size, cl_object rehash_threshold) { int htt; cl_index hsize; cl_object h; cl_object (*get)(cl_object, cl_object, cl_object); cl_object (*set)(cl_object, cl_object, cl_object); bool (*rem)(cl_object, cl_object); /* * Argument checking */ if (test == @'eq' || test == ECL_SYM_FUN(@'eq')) { htt = ecl_htt_eq; get = _ecl_gethash_eq; set = _ecl_sethash_eq; rem = _ecl_remhash_eq; } else if (test == @'eql' || test == ECL_SYM_FUN(@'eql')) { htt = ecl_htt_eql; get = _ecl_gethash_eql; set = _ecl_sethash_eql; rem = _ecl_remhash_eql; } else if (test == @'equal' || test == ECL_SYM_FUN(@'equal')) { htt = ecl_htt_equal; get = _ecl_gethash_equal; set = _ecl_sethash_equal; rem = _ecl_remhash_equal; } else if (test == @'equalp' || test == ECL_SYM_FUN(@'equalp')) { htt = ecl_htt_equalp; get = _ecl_gethash_equalp; set = _ecl_sethash_equalp; rem = _ecl_remhash_equalp; } else if (test == @'package') { htt = ecl_htt_pack; get = _ecl_gethash_pack; set = _ecl_sethash_pack; rem = _ecl_remhash_pack; } else { FEerror("~S is an illegal hash-table test function.", 1, test); } if (ecl_unlikely(!ECL_FIXNUMP(size) || ecl_fixnum_minusp(size) || ecl_fixnum_geq(size,ecl_make_fixnum(ECL_ARRAY_TOTAL_LIMIT)))) { FEwrong_type_key_arg(@[make-hash-table], @[:size], size, ecl_make_integer_type(ecl_make_fixnum(0), ecl_make_fixnum(ECL_ARRAY_TOTAL_LIMIT))); } hsize = ecl_fixnum(size); if (hsize < 16) { hsize = 16; } AGAIN: if (ecl_minusp(rehash_size)) { ERROR1: rehash_size = ecl_type_error(@'make-hash-table',"rehash-size", rehash_size, ecl_read_from_cstring("(OR (INTEGER 1 *) (FLOAT 0 (1)))")); goto AGAIN; } if (floatp(rehash_size)) { if (ecl_number_compare(rehash_size, ecl_make_fixnum(1)) < 0 || ecl_minusp(rehash_size)) { goto ERROR1; } rehash_size = ecl_make_double_float(ecl_to_double(rehash_size)); } else if (!ECL_FIXNUMP(rehash_size)) { goto ERROR1; } while (!ecl_numberp(rehash_threshold) || ecl_minusp(rehash_threshold) || ecl_number_compare(rehash_threshold, ecl_make_fixnum(1)) > 0) { rehash_threshold = ecl_type_error(@'make-hash-table',"rehash-threshold", rehash_threshold, ecl_read_from_cstring("(REAL 0 1)")); } /* * Build actual hash. */ h = ecl_alloc_object(t_hashtable); h->hash.test = htt; h->hash.weak = ecl_htt_not_weak; h->hash.get = get; h->hash.set = set; h->hash.rem = rem; h->hash.size = hsize; h->hash.entries = 0; h->hash.rehash_size = rehash_size; h->hash.threshold = rehash_threshold; rehash_threshold = cl_max(2, min_threshold, rehash_threshold); h->hash.factor = ecl_to_double(rehash_threshold); h->hash.limit = h->hash.size * h->hash.factor; h->hash.data = NULL; /* for GC sake */ h->hash.data = (struct ecl_hashtable_entry *) ecl_alloc(hsize * sizeof(struct ecl_hashtable_entry)); do_clrhash(h); return h; } cl_object cl_hash_table_p(cl_object ht) { @(return (ECL_HASH_TABLE_P(ht) ? ECL_T : ECL_NIL)) } cl_object si_hash_table_weakness(cl_object ht) { cl_object output = ECL_NIL; #ifdef ECL_WEAK_HASH switch (ht->hash.weak) { case ecl_htt_weak_key: output = @':key'; break; case ecl_htt_weak_value: output = @':value'; break; case ecl_htt_weak_key_and_value: output = @':key-and-value'; break; case ecl_htt_not_weak: default: output = ECL_NIL; break; } #endif @(return output) } @(defun gethash (key ht &optional (no_value ECL_NIL)) @ { assert_type_hash_table(@[gethash], 2, ht); { cl_object v = ht->hash.get(key, ht, OBJNULL); if (v != OBJNULL) { @(return v ECL_T); } else { @(return no_value ECL_NIL); } } } @) cl_object si_hash_set(cl_object key, cl_object ht, cl_object val) { /* INV: ecl_sethash() checks the type of hashtable */ ecl_sethash(key, ht, val); @(return val) } bool ecl_remhash(cl_object key, cl_object hashtable) { assert_type_hash_table(@[remhash], 2, hashtable); return hashtable->hash.rem(key, hashtable); } cl_object cl_remhash(cl_object key, cl_object ht) { /* INV: _ecl_remhash() checks the type of hashtable */ @(return (ecl_remhash(key, ht)? ECL_T : ECL_NIL)); } cl_object cl_clrhash(cl_object ht) { assert_type_hash_table(@[clrhash], 1, ht); if (ht->hash.entries) { do_clrhash(ht); } @(return ht) } cl_object cl_hash_table_test(cl_object ht) { cl_object output; assert_type_hash_table(@[hash-table-test], 1, ht); switch(ht->hash.test) { case ecl_htt_eq: output = @'eq'; break; case ecl_htt_eql: output = @'eql'; break; case ecl_htt_equal: output = @'equal'; break; case ecl_htt_equalp: output = @'equalp'; break; case ecl_htt_pack: default: output = @'equal'; } @(return output) } cl_object cl_hash_table_size(cl_object ht) { assert_type_hash_table(@[hash-table-size], 1, ht); @(return ecl_make_fixnum(ht->hash.size)) } cl_index ecl_hash_table_count(cl_object ht) { if (ht->hash.weak == ecl_htt_not_weak) { return ht->hash.entries; } else if (ht->hash.size) { cl_index i, j; for (i = j = 0; i < ht->hash.size; i++) { struct ecl_hashtable_entry output = copy_entry(ht->hash.data + i, ht); if (output.key != OBJNULL) { if (++j == ht->hash.size) break; } } return ht->hash.entries = j; } else { return 0; } } cl_object cl_hash_table_count(cl_object ht) { assert_type_hash_table(@[hash-table-count], 1, ht); @(return (ecl_make_fixnum(ecl_hash_table_count(ht)))) } static cl_object si_hash_table_iterate(cl_narg narg) { const cl_env_ptr the_env = ecl_process_env(); cl_object env = the_env->function->cclosure.env; cl_object index = CAR(env); cl_object ht = CADR(env); cl_fixnum i; if (!Null(index)) { i = ecl_fixnum(index); if (i < 0) i = -1; for (; ++i < ht->hash.size; ) { struct ecl_hashtable_entry e = copy_entry(ht->hash.data + i, ht); if (e.key != OBJNULL) { cl_object ndx = ecl_make_fixnum(i); ECL_RPLACA(env, ndx); @(return ndx e.key e.value) } } ECL_RPLACA(env, ECL_NIL); } @(return ECL_NIL) } cl_object si_hash_table_iterator(cl_object ht) { assert_type_hash_table(@[si::hash-table-iterator], 1, ht); @(return ecl_make_cclosure_va((cl_objectfn)si_hash_table_iterate, cl_list(2, ecl_make_fixnum(-1), ht), @'si::hash-table-iterator')) } cl_object cl_hash_table_rehash_size(cl_object ht) { assert_type_hash_table(@[hash-table-rehash-size], 1, ht); @(return ht->hash.rehash_size) } cl_object cl_hash_table_rehash_threshold(cl_object ht) { assert_type_hash_table(@[hash-table-rehash-threshold], 1, ht); @(return ht->hash.threshold) } cl_object cl_sxhash(cl_object key) { cl_index output = _hash_equal(3, 0, key); const cl_index mask = ((cl_index)1 << (ECL_FIXNUM_BITS - 3)) - 1; @(return ecl_make_fixnum(output & mask)) } @(defun si::hash-eql (&rest args) cl_index h; @ for (h = 0; narg; narg--) { cl_object o = ecl_va_arg(args); h = _hash_eql(h, o); } @(return ecl_make_fixnum(h)) @) @(defun si::hash-equal (&rest args) cl_index h; @ for (h = 0; narg; narg--) { cl_object o = ecl_va_arg(args); h = _hash_equal(3, h, o); } @(return ecl_make_fixnum(h)) @) @(defun si::hash-equalp (&rest args) cl_index h; @ for (h = 0; narg; narg--) { cl_object o = ecl_va_arg(args); h = _hash_equalp(3, h, o); } @(return ecl_make_fixnum(h)) @) cl_object cl_maphash(cl_object fun, cl_object ht) { cl_index i; assert_type_hash_table(@[maphash], 2, ht); for (i = 0; i < ht->hash.size; i++) { struct ecl_hashtable_entry e = ht->hash.data[i]; if(e.key != OBJNULL) funcall(3, fun, e.key, e.value); } @(return ECL_NIL) } cl_object si_hash_table_content(cl_object ht) { cl_index i; cl_object output = ECL_NIL; assert_type_hash_table(@[ext::hash-table-content], 2, ht); for (i = 0; i < ht->hash.size; i++) { struct ecl_hashtable_entry e = ht->hash.data[i]; if (e.key != OBJNULL) output = ecl_cons(ecl_cons(e.key, e.value), output); } @(return output) } cl_object si_hash_table_fill(cl_object ht, cl_object values) { assert_type_hash_table(@[ext::hash-table-fill], 2, ht); while (!Null(values)) { cl_object pair = ecl_car(values); cl_object key = ecl_car(pair); cl_object value = ECL_CONS_CDR(pair); values = ECL_CONS_CDR(values); ecl_sethash(key, ht, value); } @(return ht) } cl_object si_copy_hash_table(cl_object orig) { cl_object hash; hash = cl__make_hash_table(cl_hash_table_test(orig), cl_hash_table_size(orig), cl_hash_table_rehash_size(orig), cl_hash_table_rehash_threshold(orig)); memcpy(hash->hash.data, orig->hash.data, orig->hash.size * sizeof(*orig->hash.data)); hash->hash.entries = orig->hash.entries; @(return hash) } ecl-16.1.2/src/c/instance.d000066400000000000000000000321331266352375300153440ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* instance.c -- CLOS interface. */ /* Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #include #include cl_object ecl_allocate_instance(cl_object clas, cl_index size) { cl_object x = ecl_alloc_instance(size); cl_index i; ECL_CLASS_OF(x) = clas; for (i = 0; i < size; i++) x->instance.slots[i] = ECL_UNBOUND; return x; } cl_object si_allocate_raw_instance(cl_object orig, cl_object clas, cl_object size) { cl_object output = ecl_allocate_instance(clas, ecl_to_size(size)); if (orig == ECL_NIL) { orig = output; } else { orig->instance.clas = clas; orig->instance.length = output->instance.length; orig->instance.slots = output->instance.slots; } @(return orig) } cl_object si_instance_sig(cl_object x) { @(return x->instance.sig); } cl_object si_instance_sig_set(cl_object x) { @(return (x->instance.sig = ECL_CLASS_SLOTS(ECL_CLASS_OF(x)))); } cl_object si_instance_class(cl_object x) { if (ecl_unlikely(!ECL_INSTANCEP(x))) FEwrong_type_only_arg(@[class-of], x, @[ext::instance]); @(return ECL_CLASS_OF(x)) } cl_object si_instance_class_set(cl_object x, cl_object y) { if (ecl_unlikely(!ECL_INSTANCEP(x))) FEwrong_type_nth_arg(@[si::instance-class-set], 1, x, @[ext::instance]); if (ecl_unlikely(!ECL_INSTANCEP(y))) FEwrong_type_nth_arg(@[si::instance-class-set], 2, y, @[ext::instance]); ECL_CLASS_OF(x) = y; @(return x) } cl_object ecl_instance_ref(cl_object x, cl_fixnum i) { if (ecl_unlikely(!ECL_INSTANCEP(x))) FEwrong_type_nth_arg(@[si::instance-ref], 1, x, @[ext::instance]); if (ecl_unlikely(i < 0 || i >= (cl_fixnum)x->instance.length)) FEtype_error_index(x, i); return(x->instance.slots[i]); } cl_object si_instance_ref(cl_object x, cl_object index) { cl_fixnum i; if (ecl_unlikely(!ECL_INSTANCEP(x))) FEwrong_type_nth_arg(@[si::instance-ref], 1, x, @[ext::instance]); if (ecl_unlikely(!ECL_FIXNUMP(index))) FEwrong_type_nth_arg(@[si::instance-ref], 2, index, @[fixnum]); i = ecl_fixnum(index); if (ecl_unlikely(i < 0 || i >= (cl_fixnum)x->instance.length)) FEtype_error_index(x, i); @(return x->instance.slots[i]) } cl_object clos_safe_instance_ref(cl_object x, cl_object index) { cl_fixnum i; if (ecl_unlikely(!ECL_INSTANCEP(x))) FEwrong_type_nth_arg(@[si::instance-ref], 1, x, @[ext::instance]); if (ecl_unlikely(!ECL_FIXNUMP(index))) FEwrong_type_nth_arg(@[si::instance-ref], 2, index, @[fixnum]); i = ecl_fixnum(index); if (ecl_unlikely(i < 0 || i >= x->instance.length)) FEtype_error_index(x, i); x = x->instance.slots[i]; if (ecl_unlikely(x == ECL_UNBOUND)) x = _ecl_funcall4(@'slot-unbound', ECL_NIL, x, index); @(return x) } cl_object ecl_instance_set(cl_object x, cl_fixnum i, cl_object v) { if (ecl_unlikely(!ECL_INSTANCEP(x))) FEwrong_type_nth_arg(@[si::instance-set], 1, x, @[ext::instance]); if (ecl_unlikely(i >= x->instance.length || i < 0)) FEtype_error_index(x, i); x->instance.slots[i] = v; return(v); } cl_object si_instance_set(cl_object x, cl_object index, cl_object value) { cl_fixnum i; if (ecl_unlikely(!ECL_INSTANCEP(x))) FEwrong_type_nth_arg(@[si::instance-set], 1, x, @[ext::instance]); if (ecl_unlikely(!ECL_FIXNUMP(index))) FEwrong_type_nth_arg(@[si::instance-set], 2, index, @[fixnum]); i = ecl_fixnum(index); if (ecl_unlikely(i >= (cl_fixnum)x->instance.length || i < 0)) FEtype_error_index(x, i); x->instance.slots[i] = value; @(return value) } cl_object si_instancep(cl_object x) { @(return (ECL_INSTANCEP(x) ? ecl_make_fixnum(x->instance.length) : ECL_NIL)) } cl_object si_unbound() { /* Returns an object that cannot be read or written and which is used to represent an unitialized slot */ @(return ECL_UNBOUND) } cl_object si_sl_boundp(cl_object x) { @(return ((x == ECL_UNBOUND) ? ECL_NIL : ECL_T)) } cl_object si_sl_makunbound(cl_object x, cl_object index) { cl_fixnum i; if (ecl_unlikely(!ECL_INSTANCEP(x))) FEwrong_type_nth_arg(@[si::sl-makunbound], 1, x, @[ext::instance]); if (ecl_unlikely(!ECL_FIXNUMP(index))) FEwrong_type_nth_arg(@[si::sl-makunbound], 2, index, @[fixnum]); i = ecl_fixnum(index); unlikely_if (i >= x->instance.length || i < 0) FEtype_error_index(x, i); x->instance.slots[i] = ECL_UNBOUND; @(return x) } cl_object si_copy_instance(cl_object x) { cl_object y; if (ecl_unlikely(!ECL_INSTANCEP(x))) FEwrong_type_nth_arg(@[si::copy-instance], 1, x, @[ext::instance]); y = ecl_allocate_instance(x->instance.clas, x->instance.length); y->instance.sig = x->instance.sig; memcpy(y->instance.slots, x->instance.slots, x->instance.length * sizeof(cl_object)); @(return y) } @(defun find-class (name &optional (errorp ECL_T) env) cl_object class, hash; @ hash = ECL_SYM_VAL(the_env, @'si::*class-name-hash-table*'); class = ecl_gethash_safe(name, hash, ECL_NIL); if (class == ECL_NIL) { if (!Null(errorp)) FEerror("No class named ~S.", 1, name); } @(return class) @) cl_object ecl_slot_value(cl_object x, const char *slot) { cl_object slot_name = ecl_read_from_cstring(slot); return funcall(3, @'slot-value', x, slot_name); } cl_object ecl_slot_value_set(cl_object x, const char *slot, cl_object value) { cl_object slot_name = ecl_read_from_cstring(slot); cl_object slot_setter = ecl_read_from_cstring("(SETF SLOT-VALUE)"); return funcall(4, ecl_fdefinition(slot_setter), value, x, slot_name); } /********************************************************************** * IMPORTANT: THE FOLLOWING LIST IS LINKED TO src/clos/builtin.lsp **********************************************************************/ enum ecl_built_in_classes { ECL_BUILTIN_T = 0, ECL_BUILTIN_SEQUENCE, ECL_BUILTIN_LIST, ECL_BUILTIN_CONS, ECL_BUILTIN_ARRAY, ECL_BUILTIN_VECTOR, ECL_BUILTIN_STRING, #ifdef ECL_UNICODE ECL_BUILTIN_BASE_STRING, #endif ECL_BUILTIN_BIT_VECTOR, ECL_BUILTIN_STREAM, ECL_BUILTIN_ANSI_STREAM, ECL_BUILTIN_FILE_STREAM, ECL_BUILTIN_ECHO_STREAM, ECL_BUILTIN_STRING_STREAM, ECL_BUILTIN_TWO_WAY_STREAM, ECL_BUILTIN_SYNONYM_STREAM, ECL_BUILTIN_BROADCAST_STREAM, ECL_BUILTIN_CONCATENATED_STREAM, ECL_BUILTIN_SEQUENCE_STREAM, ECL_BUILTIN_CHARACTER, ECL_BUILTIN_NUMBER, ECL_BUILTIN_REAL, ECL_BUILTIN_RATIONAL, ECL_BUILTIN_INTEGER, ECL_BUILTIN_FIXNUM, ECL_BUILTIN_BIGNUM, ECL_BUILTIN_RATIO, ECL_BUILTIN_FLOAT, ECL_BUILTIN_SINGLE_FLOAT, ECL_BUILTIN_DOUBLE_FLOAT, ECL_BUILTIN_COMPLEX, ECL_BUILTIN_SYMBOL, ECL_BUILTIN_NULL, ECL_BUILTIN_KEYWORD, ECL_BUILTIN_PACKAGE, ECL_BUILTIN_FUNCTION, ECL_BUILTIN_PATHNAME, ECL_BUILTIN_LOGICAL_PATHNAME, ECL_BUILTIN_HASH_TABLE, ECL_BUILTIN_RANDOM_STATE, ECL_BUILTIN_READTABLE, ECL_BUILTIN_CODE_BLOCK, ECL_BUILTIN_FOREIGN_DATA, ECL_BUILTIN_FRAME, ECL_BUILTIN_WEAK_POINTER #ifdef ECL_THREADS , ECL_BUILTIN_PROCESS, ECL_BUILTIN_LOCK, ECL_BUILTIN_RWLOCK, ECL_BUILTIN_CONDITION_VARIABLE, ECL_BUILTIN_SEMAPHORE, ECL_BUILTIN_BARRIER, ECL_BUILTIN_MAILBOX #endif #ifdef ECL_SSE2 , ECL_BUILTIN_SSE_PACK #endif }; cl_object cl_class_of(cl_object x) { size_t index; switch (ecl_t_of(x)) { case t_instance: @(return ECL_CLASS_OF(x)) case t_fixnum: index = ECL_BUILTIN_FIXNUM; break; case t_bignum: index = ECL_BUILTIN_BIGNUM; break; case t_ratio: index = ECL_BUILTIN_RATIO; break; case t_singlefloat: index = ECL_BUILTIN_SINGLE_FLOAT; break; case t_doublefloat: index = ECL_BUILTIN_DOUBLE_FLOAT; break; #ifdef ECL_LONG_FLOAT case t_longfloat: index = ECL_BUILTIN_FLOAT; break; /* XXX index = ECL_BUILTIN_LONG_FLOAT; break; */ #endif case t_complex: index = ECL_BUILTIN_COMPLEX; break; case t_character: index = ECL_BUILTIN_CHARACTER; break; case t_symbol: if (x->symbol.hpack == cl_core.keyword_package) index = ECL_BUILTIN_KEYWORD; else index = ECL_BUILTIN_SYMBOL; break; case t_package: index = ECL_BUILTIN_PACKAGE; break; case t_list: index = Null(x)? ECL_BUILTIN_NULL : ECL_BUILTIN_CONS; break; case t_hashtable: index = ECL_BUILTIN_HASH_TABLE; break; case t_array: index = ECL_BUILTIN_ARRAY; break; case t_vector: index = ECL_BUILTIN_VECTOR; break; #ifdef ECL_UNICODE case t_string: index = ECL_BUILTIN_STRING; break; case t_base_string: index = ECL_BUILTIN_BASE_STRING; break; #else case t_base_string: index = ECL_BUILTIN_STRING; break; #endif case t_bitvector: index = ECL_BUILTIN_BIT_VECTOR; break; case t_stream: switch (x->stream.mode) { case ecl_smm_synonym: index = ECL_BUILTIN_SYNONYM_STREAM; break; case ecl_smm_broadcast: index = ECL_BUILTIN_BROADCAST_STREAM; break; case ecl_smm_concatenated: index = ECL_BUILTIN_CONCATENATED_STREAM; break; case ecl_smm_two_way: index = ECL_BUILTIN_TWO_WAY_STREAM; break; case ecl_smm_string_input: case ecl_smm_string_output: index = ECL_BUILTIN_STRING_STREAM; break; case ecl_smm_echo: index = ECL_BUILTIN_ECHO_STREAM; break; case ecl_smm_sequence_input: case ecl_smm_sequence_output: index = ECL_BUILTIN_SEQUENCE_STREAM; break; default: index = ECL_BUILTIN_FILE_STREAM; break; } break; case t_readtable: index = ECL_BUILTIN_READTABLE; break; case t_pathname: index = ECL_BUILTIN_PATHNAME; break; case t_random: index = ECL_BUILTIN_RANDOM_STATE; break; case t_bytecodes: case t_bclosure: case t_cfun: case t_cfunfixed: case t_cclosure: index = ECL_BUILTIN_FUNCTION; break; #ifdef ECL_THREADS case t_process: index = ECL_BUILTIN_PROCESS; break; case t_lock: index = ECL_BUILTIN_LOCK; break; case t_condition_variable: index = ECL_BUILTIN_CONDITION_VARIABLE; break; case t_semaphore: index = ECL_BUILTIN_SEMAPHORE; break; case t_barrier: index = ECL_BUILTIN_BARRIER; break; case t_mailbox: index = ECL_BUILTIN_MAILBOX; break; #endif case t_codeblock: index = ECL_BUILTIN_CODE_BLOCK; break; case t_foreign: index = ECL_BUILTIN_FOREIGN_DATA; break; case t_frame: index = ECL_BUILTIN_FRAME; break; case t_weak_pointer: index = ECL_BUILTIN_WEAK_POINTER; break; #ifdef ECL_SSE2 case t_sse_pack: index = ECL_BUILTIN_SSE_PACK; break; #endif default: ecl_internal_error("not a lisp data object"); } { /* We have to be careful because +builtin-classes+ might be empty! */ /* In any case, since +builtin-classes+ is a constant, we may * optimize the slot access */ cl_object v = @'clos::+builtin-classes+'->symbol.value; cl_object output = Null(v)? cl_find_class(1,@'t') : v->vector.self.t[index]; @(return output) } } ecl-16.1.2/src/c/interpreter.d000066400000000000000000001347431266352375300161150ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* interpreter.c -- Bytecode interpreter. */ /* Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #include #include #include #include #include #include /* -------------------- INTERPRETER STACK -------------------- */ cl_object * ecl_stack_set_size(cl_env_ptr env, cl_index tentative_new_size) { cl_index top = env->stack_top - env->stack; cl_object *new_stack, *old_stack; cl_index safety_area = ecl_option_values[ECL_OPT_LISP_STACK_SAFETY_AREA]; cl_index new_size = tentative_new_size + 2*safety_area; /* Round to page size */ new_size = (new_size + (LISP_PAGESIZE-1))/LISP_PAGESIZE * new_size; if (ecl_unlikely(top > new_size)) { FEerror("Internal error: cannot shrink stack below stack top.",0); } old_stack = env->stack; new_stack = (cl_object *)ecl_alloc_atomic(new_size * sizeof(cl_object)); ecl_disable_interrupts_env(env); memcpy(new_stack, old_stack, env->stack_size * sizeof(cl_object)); env->stack_size = new_size; env->stack_limit_size = new_size - 2*safety_area; env->stack = new_stack; env->stack_top = env->stack + top; env->stack_limit = env->stack + (new_size - 2*safety_area); ecl_enable_interrupts_env(env); /* A stack always has at least one element. This is assumed by cl__va_start * and friends, which take a sp=0 to have no arguments. */ if (top == 0) { *(env->stack_top++) = ecl_make_fixnum(0); } return env->stack_top; } void FEstack_underflow(void) { FEerror("Internal error: stack underflow.",0); } void FEstack_advance(void) { FEerror("Internal error: stack advance beyond current point.",0); } cl_object * ecl_stack_grow(cl_env_ptr env) { return ecl_stack_set_size(env, env->stack_size + env->stack_size / 2); } cl_index ecl_stack_push_values(cl_env_ptr env) { cl_index i = env->nvalues; cl_object *b = env->stack_top; cl_object *p = b + i; if (p >= env->stack_limit) { b = ecl_stack_grow(env); p = b + i; } env->stack_top = p; memcpy(b, env->values, i * sizeof(cl_object)); return i; } void ecl_stack_pop_values(cl_env_ptr env, cl_index n) { cl_object *p = env->stack_top - n; if (ecl_unlikely(p < env->stack)) FEstack_underflow(); env->nvalues = n; env->stack_top = p; memcpy(env->values, p, n * sizeof(cl_object)); } cl_object ecl_stack_frame_open(cl_env_ptr env, cl_object f, cl_index size) { cl_object *base = env->stack_top; if (size) { if ((env->stack_limit - base) < size) { base = ecl_stack_set_size(env, env->stack_size + size); } } f->frame.t = t_frame; f->frame.stack = env->stack; f->frame.base = base; f->frame.size = size; f->frame.env = env; env->stack_top = (base + size); return f; } void ecl_stack_frame_push(cl_object f, cl_object o) { cl_env_ptr env = f->frame.env; cl_object *top = env->stack_top; if (top >= env->stack_limit) { top = ecl_stack_grow(env); } *top = o; env->stack_top = ++top; f->frame.base = top - (++(f->frame.size)); f->frame.stack = env->stack; } void ecl_stack_frame_push_values(cl_object f) { cl_env_ptr env = f->frame.env; ecl_stack_push_values(env); f->frame.base = env->stack_top - (f->frame.size += env->nvalues); f->frame.stack = env->stack; } cl_object ecl_stack_frame_pop_values(cl_object f) { cl_env_ptr env = f->frame.env; cl_index n = f->frame.size % ECL_MULTIPLE_VALUES_LIMIT; cl_object o; env->nvalues = n; env->values[0] = o = ECL_NIL; while (n--) { env->values[n] = o = f->frame.base[n]; } return o; } void ecl_stack_frame_close(cl_object f) { if (f->frame.stack) { ECL_STACK_SET_INDEX(f->frame.env, f->frame.base - f->frame.stack); } } /* ------------------------------ LEXICAL ENV. ------------------------------ */ #define bind_var(env, var, val) CONS(CONS(var, val), (env)) #define bind_function(env, name, fun) CONS(fun, (env)) #define bind_frame(env, id, name) CONS(CONS(id, name), (env)) static cl_object ecl_lex_env_get_record(register cl_object env, register int s) { do { if (s-- == 0) return ECL_CONS_CAR(env); env = ECL_CONS_CDR(env); } while(1); } #define ecl_lex_env_get_var(env,x) ECL_CONS_CDR(ecl_lex_env_get_record(env,x)) #define ecl_lex_env_set_var(env,x,v) ECL_RPLACD(ecl_lex_env_get_record(env,x),(v)) #define ecl_lex_env_get_fun(env,x) ecl_lex_env_get_record(env,x) #define ecl_lex_env_get_tag(env,x) ECL_CONS_CAR(ecl_lex_env_get_record(env,x)) /* -------------------- AIDS TO THE INTERPRETER -------------------- */ cl_object _ecl_bytecodes_dispatch_vararg(cl_narg narg, ...) { cl_object output; ECL_STACK_FRAME_VARARGS_BEGIN(narg, narg, frame) { output = ecl_interpret(frame, ECL_NIL, frame->frame.env->function); } ECL_STACK_FRAME_VARARGS_END(frame); return output; } cl_object _ecl_bclosure_dispatch_vararg(cl_narg narg, ...) { cl_object output; ECL_STACK_FRAME_VARARGS_BEGIN(narg, narg, frame) { cl_object fun = frame->frame.env->function; output = ecl_interpret(frame, fun->bclosure.lex, fun->bclosure.code); } ECL_STACK_FRAME_VARARGS_END(frame); return output; } static cl_object close_around(cl_object fun, cl_object lex) { cl_object v = ecl_alloc_object(t_bclosure); if (ecl_t_of(fun) != t_bytecodes) FEerror("!!!", 0); v->bclosure.code = fun; v->bclosure.lex = lex; v->bclosure.entry = _ecl_bclosure_dispatch_vararg; return v; } #define SETUP_ENV(the_env) { ihs.lex_env = lex_env; } /* * INTERPRET-FUNCALL is one of the few ways to "exit" the interpreted * environment and get into the C/lisp world. Since almost all data * from the interpreter is kept in local variables, and frame stacks, * binding stacks, etc, are already handled by the C core, only the * lexical environment needs to be saved. */ #define INTERPRET_FUNCALL(reg0, the_env, frame, narg, fun) { \ cl_index __n = narg; \ SETUP_ENV(the_env); \ frame.stack = the_env->stack; \ frame.base = the_env->stack_top - (frame.size = __n); \ reg0 = ecl_apply_from_stack_frame((cl_object)&frame, fun); \ the_env->stack_top -= __n; } static void too_many_arguments(cl_object bytecodes, cl_object frame) ecl_attr_noreturn; static void odd_number_of_keywords(cl_object bytecodes) ecl_attr_noreturn; static void unknown_keyword(cl_object bytecodes, cl_object frame) ecl_attr_noreturn; static void too_many_arguments(register cl_object bytecodes, register cl_object frame) { FEprogram_error("Too many arguments passed to " "function ~A~&Argument list: ~S", 2, bytecodes, cl_apply(2, @'list', frame)); } static void odd_number_of_keywords(register cl_object bytecodes) { FEprogram_error("Function ~A called with odd number " "of keyword arguments.", 1, bytecodes); } static void unknown_keyword(register cl_object bytecodes, register cl_object frame) { FEprogram_error("Unknown keyword argument passed to function ~S.~&" "Argument list: ~S", 2, bytecodes, cl_apply(2, @'list', frame)); } /* -------------------- THE INTERPRETER -------------------- */ cl_object ecl_interpret(cl_object frame, cl_object env, cl_object bytecodes) { ECL_OFFSET_TABLE const cl_env_ptr the_env = frame->frame.env; volatile cl_index frame_index = 0; cl_opcode *vector = (cl_opcode*)bytecodes->bytecodes.code; cl_object *data = bytecodes->bytecodes.data->vector.self.t; cl_object reg0 = ECL_NIL, reg1 = ECL_NIL, lex_env = env; cl_index narg; struct ecl_stack_frame frame_aux; volatile struct ecl_ihs_frame ihs; /* INV: bytecodes is of type t_bytecodes */ ecl_cs_check(the_env, ihs); ecl_ihs_push(the_env, &ihs, bytecodes, lex_env); frame_aux.t = t_frame; frame_aux.stack = frame_aux.base = 0; frame_aux.size = 0; frame_aux.env = the_env; BEGIN: BEGIN_SWITCH { CASE(OP_NOP); { reg0 = ECL_NIL; the_env->nvalues = 0; THREAD_NEXT; } /* OP_QUOTE Sets REG0 to an immediate value. */ CASE(OP_QUOTE); { GET_DATA(reg0, vector, data); THREAD_NEXT; } /* OP_VAR n{arg}, var{symbol} Sets REG0 to the value of the n-th local. VAR is the name of the variable for readability purposes. */ CASE(OP_VAR); { int lex_env_index; GET_OPARG(lex_env_index, vector); reg0 = ecl_lex_env_get_var(lex_env, lex_env_index); THREAD_NEXT; } /* OP_VARS var{symbol} Sets REG0 to the value of the symbol VAR. VAR should be either a special variable or a constant. */ CASE(OP_VARS); { cl_object var_name; GET_DATA(var_name, vector, data); reg0 = ECL_SYM_VAL(the_env, var_name); if (ecl_unlikely(reg0 == OBJNULL)) FEunbound_variable(var_name); THREAD_NEXT; } /* OP_CONS, OP_CAR, OP_CDR, etc Inlined forms for some functions which act on reg0 and stack. */ CASE(OP_CONS); { cl_object car = ECL_STACK_POP_UNSAFE(the_env); reg0 = CONS(car, reg0); THREAD_NEXT; } CASE(OP_CAR); { if (ecl_unlikely(!LISTP(reg0))) FEwrong_type_only_arg(@[car], reg0, @[cons]); reg0 = CAR(reg0); THREAD_NEXT; } CASE(OP_CDR); { if (ecl_unlikely(!LISTP(reg0))) FEwrong_type_only_arg(@[cdr], reg0, @[cons]); reg0 = CDR(reg0); THREAD_NEXT; } CASE(OP_LIST); reg0 = ecl_list1(reg0); CASE(OP_LISTA); { cl_index n; GET_OPARG(n, vector); while (--n) { reg0 = CONS(ECL_STACK_POP_UNSAFE(the_env), reg0); } THREAD_NEXT; } CASE(OP_INT); { cl_fixnum n; GET_OPARG(n, vector); reg0 = ecl_make_fixnum(n); THREAD_NEXT; } CASE(OP_PINT); { cl_fixnum n; GET_OPARG(n, vector); ECL_STACK_PUSH(the_env, ecl_make_fixnum(n)); THREAD_NEXT; } /* OP_PUSH Pushes the object in VALUES(0). */ CASE(OP_PUSH); { ECL_STACK_PUSH(the_env, reg0); THREAD_NEXT; } /* OP_PUSHV n{arg} Pushes the value of the n-th local onto the stack. */ CASE(OP_PUSHV); { int lex_env_index; GET_OPARG(lex_env_index, vector); ECL_STACK_PUSH(the_env, ecl_lex_env_get_var(lex_env, lex_env_index)); THREAD_NEXT; } /* OP_PUSHVS var{symbol} Pushes the value of the symbol VAR onto the stack. VAR should be either a special variable or a constant. */ CASE(OP_PUSHVS); { cl_object var_name, value; GET_DATA(var_name, vector, data); value = ECL_SYM_VAL(the_env, var_name); if (ecl_unlikely(value == OBJNULL)) FEunbound_variable(var_name); ECL_STACK_PUSH(the_env, value); THREAD_NEXT; } /* OP_PUSHQ value{object} Pushes "value" onto the stack. */ CASE(OP_PUSHQ); { cl_object aux; GET_DATA(aux, vector, data); ECL_STACK_PUSH(the_env, aux); THREAD_NEXT; } CASE(OP_CALLG1); { cl_object s; cl_objectfn f; GET_DATA(s, vector, data); f = ecl_function_dispatch(the_env, ECL_SYM_FUN(s)); SETUP_ENV(the_env); reg0 = f(1, reg0); THREAD_NEXT; } CASE(OP_CALLG2); { cl_object s; cl_objectfn f; GET_DATA(s, vector, data); f = ecl_function_dispatch(the_env, ECL_SYM_FUN(s)); SETUP_ENV(the_env); reg0 = f(2, ECL_STACK_POP_UNSAFE(the_env), reg0); THREAD_NEXT; } /* OP_CALL n{arg} Calls the function in REG0 with N arguments which have been deposited in the stack. The first output value is pushed on the stack. */ CASE(OP_CALL); { GET_OPARG(narg, vector); goto DO_CALL; } /* OP_CALLG n{arg}, name{arg} Calls the function NAME with N arguments which have been deposited in the stack. The first output value is pushed on the stack. */ CASE(OP_CALLG); { GET_OPARG(narg, vector); GET_DATA(reg0, vector, data); goto DO_CALL; } /* OP_FCALL n{arg} Calls a function in the stack with N arguments which have been also deposited in the stack. The output values are left in VALUES(...) */ CASE(OP_FCALL); { GET_OPARG(narg, vector); reg0 = ECL_STACK_REF(the_env,-narg-1); goto DO_CALL; } /* OP_MCALL Similar to FCALL, but gets the number of arguments from the stack (They all have been deposited by OP_PUSHVALUES) */ CASE(OP_MCALL); { narg = ecl_fixnum(ECL_STACK_POP_UNSAFE(the_env)); reg0 = ECL_STACK_REF(the_env,-narg-1); goto DO_CALL; } DO_CALL: { cl_object x = reg0; cl_object frame = (cl_object)&frame_aux; frame_aux.size = narg; frame_aux.base = the_env->stack_top - narg; SETUP_ENV(the_env); AGAIN: if (ecl_unlikely(reg0 == OBJNULL || reg0 == ECL_NIL)) FEundefined_function(x); switch (ecl_t_of(reg0)) { case t_cfunfixed: if (ecl_unlikely(narg != (cl_index)reg0->cfunfixed.narg)) FEwrong_num_arguments(reg0); reg0 = APPLY_fixed(narg, reg0->cfunfixed.entry_fixed, frame_aux.base); break; case t_cfun: reg0 = APPLY(narg, reg0->cfun.entry, frame_aux.base); break; case t_cclosure: the_env->function = reg0; reg0 = APPLY(narg, reg0->cclosure.entry, frame_aux.base); break; case t_instance: switch (reg0->instance.isgf) { case ECL_STANDARD_DISPATCH: case ECL_RESTRICTED_DISPATCH: reg0 = _ecl_standard_dispatch(frame, reg0); break; case ECL_USER_DISPATCH: reg0 = reg0->instance.slots[reg0->instance.length - 1]; goto AGAIN; case ECL_READER_DISPATCH: case ECL_WRITER_DISPATCH: the_env->function = reg0; reg0 = APPLY(narg, reg0->instance.entry, frame_aux.base); break; default: FEinvalid_function(reg0); } break; case t_symbol: if (ecl_unlikely(reg0->symbol.stype & ecl_stp_macro)) FEundefined_function(x); reg0 = ECL_SYM_FUN(reg0); goto AGAIN; case t_bytecodes: reg0 = ecl_interpret(frame, ECL_NIL, reg0); break; case t_bclosure: reg0 = ecl_interpret(frame, reg0->bclosure.lex, reg0->bclosure.code); break; default: FEinvalid_function(reg0); } ECL_STACK_POP_N_UNSAFE(the_env, narg); THREAD_NEXT; } /* OP_POP Pops a singe value pushed by a OP_PUSH* operator. */ CASE(OP_POP); { reg0 = ECL_STACK_POP_UNSAFE(the_env); THREAD_NEXT; } /* OP_POP1 Pops a singe value pushed by a OP_PUSH* operator, ignoring it. */ CASE(OP_POP1); { (void)ECL_STACK_POP_UNSAFE(the_env); THREAD_NEXT; } /* OP_POPREQ Checks the arguments list. If there are remaining arguments, REG0 = T and the value is on the stack, otherwise REG0 = NIL. */ CASE(OP_POPREQ); { if (ecl_unlikely(frame_index >= frame->frame.size)) { FEwrong_num_arguments(bytecodes->bytecodes.name); } reg0 = frame->frame.base[frame_index++]; THREAD_NEXT; } /* OP_POPOPT Checks the arguments list. If there are remaining arguments, REG0 = T and the value is on the stack, otherwise REG0 = NIL. */ CASE(OP_POPOPT); { if (frame_index >= frame->frame.size) { reg0 = ECL_NIL; } else { ECL_STACK_PUSH(the_env,frame->frame.base[frame_index++]); reg0 = ECL_T; } THREAD_NEXT; } /* OP_NOMORE No more arguments. */ CASE(OP_NOMORE); { if (ecl_unlikely(frame_index < frame->frame.size)) too_many_arguments(bytecodes, frame); THREAD_NEXT; } /* OP_POPREST Makes a list out of the remaining arguments. */ CASE(OP_POPREST); { cl_object *first = frame->frame.base + frame_index; cl_object *last = frame->frame.base + frame->frame.size; for (reg0 = ECL_NIL; last > first; ) { reg0 = CONS(*(--last), reg0); } THREAD_NEXT; } /* OP_PUSHKEYS {names-list} Checks the stack frame for keyword arguments. */ CASE(OP_PUSHKEYS); { cl_object keys_list, aok, *first, *last; cl_index count; GET_DATA(keys_list, vector, data); first = frame->frame.base + frame_index; count = frame->frame.size - frame_index; last = first + count; if (ecl_unlikely(count & 1)) { odd_number_of_keywords(bytecodes); } aok = ECL_CONS_CAR(keys_list); for (; (keys_list = ECL_CONS_CDR(keys_list), !Null(keys_list)); ) { cl_object name = ECL_CONS_CAR(keys_list); cl_object flag = ECL_NIL; cl_object value = ECL_NIL; cl_object *p = first; for (; p != last; ++p) { if (*(p++) == name) { count -= 2; if (flag == ECL_NIL) { flag = ECL_T; value = *p; } } } if (flag != ECL_NIL) ECL_STACK_PUSH(the_env, value); ECL_STACK_PUSH(the_env, flag); } if (count) { if (Null(aok)) { int aok = 0, mask = 1; cl_object *p = first; for (; p != last; ++p) { if (*(p++) == @':allow-other-keys') { if (!Null(*p)) aok |= mask; mask <<= 1; count -= 2; } } if (ecl_unlikely(count && (aok & 1) == 0)) { unknown_keyword(bytecodes, frame); } } } THREAD_NEXT; } /* OP_EXIT Marks the end of a high level construct (BLOCK, CATCH...) or a function. */ CASE(OP_EXIT); { ecl_ihs_pop(the_env); return reg0; } /* OP_FLET nfun{arg}, fun1{object} ... OP_UNBIND nfun Executes the enclosed code in a lexical enviroment extended with the functions "fun1" ... "funn". Note that we only record the index of the first function: the others are after this one. Note that nfun > 0. */ CASE(OP_FLET); { int nfun; cl_object old_lex; GET_OPARG(nfun, vector); /* Copy the environment so that functions get it without references to themselves, and then add new closures to the environment. */ old_lex = lex_env; do { cl_object f; GET_DATA(f, vector, data); f = close_around(f, old_lex); lex_env = bind_function(lex_env, f->bytecodes.name, f); } while (--nfun); THREAD_NEXT; } /* OP_LABELS nfun{arg} fun1{object} ... funn{object} ... OP_UNBIND n Executes the enclosed code in a lexical enviroment extended with the functions "fun1" ... "funn". */ CASE(OP_LABELS); { cl_index nfun; GET_OPARG(nfun, vector); /* Build up a new environment with all functions */ { cl_index i = nfun; do { cl_object f; GET_DATA(f, vector, data); lex_env = bind_function(lex_env, f->bytecodes.name, f); } while (--i); } /* Update the closures so that all functions can call each other */ { cl_object l = lex_env; do { ECL_RPLACA(l, close_around(ECL_CONS_CAR(l), lex_env)); l = ECL_CONS_CDR(l); } while (--nfun); } THREAD_NEXT; } /* OP_LFUNCTION n{arg}, function-name{symbol} Calls the local or global function with N arguments which have been deposited in the stack. */ CASE(OP_LFUNCTION); { int lex_env_index; GET_OPARG(lex_env_index, vector); reg0 = ecl_lex_env_get_fun(lex_env, lex_env_index); THREAD_NEXT; } /* OP_FUNCTION name{symbol} Extracts the function associated to a symbol. The function may be defined in the global environment or in the local environment. This last value takes precedence. */ CASE(OP_FUNCTION); { GET_DATA(reg0, vector, data); reg0 = ecl_fdefinition(reg0); THREAD_NEXT; } /* OP_CLOSE name{symbol} Extracts the function associated to a symbol. The function may be defined in the global environment or in the local environment. This last value takes precedence. */ CASE(OP_CLOSE); { GET_DATA(reg0, vector, data); reg0 = close_around(reg0, lex_env); THREAD_NEXT; } /* OP_GO n{arg}, tag-ndx{arg} Jumps to the tag which is defined for the tagbody frame registered at the n-th position in the lexical environment. TAG-NDX is the number of tag in the list. */ CASE(OP_GO); { cl_index lex_env_index; cl_fixnum tag_ndx; GET_OPARG(lex_env_index, vector); GET_OPARG(tag_ndx, vector); cl_go(ecl_lex_env_get_tag(lex_env, lex_env_index), ecl_make_fixnum(tag_ndx)); THREAD_NEXT; } /* OP_RETURN n{arg} Returns from the block whose record in the lexical environment occuppies the n-th position. */ CASE(OP_RETURN); { int lex_env_index; cl_object block_record; GET_OPARG(lex_env_index, vector); /* record = (id . name) */ block_record = ecl_lex_env_get_record(lex_env, lex_env_index); the_env->values[0] = reg0; cl_return_from(ECL_CONS_CAR(block_record), ECL_CONS_CDR(block_record)); THREAD_NEXT; } /* OP_THROW Jumps to an enclosing CATCH form whose tag matches the one of the THROW. The tag is taken from the stack, while the output values are left in VALUES(...). */ CASE(OP_THROW); { cl_object tag_name = ECL_STACK_POP_UNSAFE(the_env); the_env->values[0] = reg0; cl_throw(tag_name); THREAD_NEXT; } /* OP_JMP label{arg} OP_JNIL label{arg} OP_JT label{arg} OP_JEQ value{object}, label{arg} OP_JNEQ value{object}, label{arg} Direct or conditional jumps. The conditional jumps are made comparing with the value of REG0. */ CASE(OP_JMP); { cl_oparg jump; GET_OPARG(jump, vector); vector += jump - OPARG_SIZE; THREAD_NEXT; } CASE(OP_JNIL); { cl_oparg jump; GET_OPARG(jump, vector); if (Null(reg0)) vector += jump - OPARG_SIZE; THREAD_NEXT; } CASE(OP_JT); { cl_oparg jump; GET_OPARG(jump, vector); if (!Null(reg0)) vector += jump - OPARG_SIZE; THREAD_NEXT; } CASE(OP_JEQL); { cl_oparg value, jump; GET_OPARG(value, vector); GET_OPARG(jump, vector); if (ecl_eql(reg0, data[value])) vector += jump - OPARG_SIZE; THREAD_NEXT; } CASE(OP_JNEQL); { cl_oparg value, jump; GET_OPARG(value, vector); GET_OPARG(jump, vector); if (!ecl_eql(reg0, data[value])) vector += jump - OPARG_SIZE; THREAD_NEXT; } CASE(OP_ENDP); if (ecl_unlikely(!LISTP(reg0))) FEwrong_type_only_arg(@[endp], reg0, @[list]); CASE(OP_NOT); { reg0 = (reg0 == ECL_NIL)? ECL_T : ECL_NIL; THREAD_NEXT; } /* OP_UNBIND n{arg} Undo "n" local bindings. */ CASE(OP_UNBIND); { cl_oparg n; GET_OPARG(n, vector); while (n--) lex_env = ECL_CONS_CDR(lex_env); THREAD_NEXT; } /* OP_UNBINDS n{arg} Undo "n" bindings of special variables. */ CASE(OP_UNBINDS); { cl_oparg n; GET_OPARG(n, vector); ecl_bds_unwind_n(the_env, n); THREAD_NEXT; } /* OP_BIND name{symbol} OP_PBIND name{symbol} OP_VBIND nvalue{arg}, name{symbol} OP_BINDS name{symbol} OP_PBINDS name{symbol} OP_VBINDS nvalue{arg}, name{symbol} Binds a lexical or special variable to the the value of REG0, the first value of the stack (PBIND) or to a given value in the values array. */ CASE(OP_BIND); { cl_object var_name; GET_DATA(var_name, vector, data); lex_env = bind_var(lex_env, var_name, reg0); THREAD_NEXT; } CASE(OP_PBIND); { cl_object var_name; GET_DATA(var_name, vector, data); lex_env = bind_var(lex_env, var_name, ECL_STACK_POP_UNSAFE(the_env)); THREAD_NEXT; } CASE(OP_VBIND); { cl_index n; cl_object var_name; GET_OPARG(n, vector); GET_DATA(var_name, vector, data); lex_env = bind_var(lex_env, var_name, (n < the_env->nvalues) ? the_env->values[n] : ECL_NIL); THREAD_NEXT; } CASE(OP_BINDS); { cl_object var_name; GET_DATA(var_name, vector, data); ecl_bds_bind(the_env, var_name, reg0); THREAD_NEXT; } CASE(OP_PBINDS); { cl_object var_name; GET_DATA(var_name, vector, data); ecl_bds_bind(the_env, var_name, ECL_STACK_POP_UNSAFE(the_env)); THREAD_NEXT; } CASE(OP_VBINDS); { cl_index n; cl_object var_name; GET_OPARG(n, vector); GET_DATA(var_name, vector, data); ecl_bds_bind(the_env, var_name, (n < the_env->nvalues) ? the_env->values[n] : ECL_NIL); THREAD_NEXT; } /* OP_SETQ n{arg} OP_PSETQ n{arg} OP_SETQS var-name{symbol} OP_PSETQS var-name{symbol} OP_VSETQ n{arg}, nvalue{arg} OP_VSETQS var-name{symbol}, nvalue{arg} Sets either the n-th local or a special variable VAR-NAME, to either the value in REG0 (OP_SETQ[S]) or to the first value on the stack (OP_PSETQ[S]), or to a given value from the multiple values array (OP_VSETQ[S]). Note that NVALUE > 0 strictly. */ CASE(OP_SETQ); { int lex_env_index; GET_OPARG(lex_env_index, vector); ecl_lex_env_set_var(lex_env, lex_env_index, reg0); THREAD_NEXT; } CASE(OP_SETQS); { cl_object var; GET_DATA(var, vector, data); /* INV: Not NIL, and of type t_symbol */ if (ecl_unlikely(var->symbol.stype & ecl_stp_constant)) FEassignment_to_constant(var); ECL_SETQ(the_env, var, reg0); THREAD_NEXT; } CASE(OP_PSETQ); { int lex_env_index; GET_OPARG(lex_env_index, vector); ecl_lex_env_set_var(lex_env, lex_env_index, ECL_STACK_POP_UNSAFE(the_env)); THREAD_NEXT; } CASE(OP_PSETQS); { cl_object var; GET_DATA(var, vector, data); /* INV: Not NIL, and of type t_symbol */ ECL_SETQ(the_env, var, ECL_STACK_POP_UNSAFE(the_env)); THREAD_NEXT; } CASE(OP_VSETQ); { cl_index lex_env_index; cl_oparg index; GET_OPARG(lex_env_index, vector); GET_OPARG(index, vector); ecl_lex_env_set_var(lex_env, lex_env_index, (index >= the_env->nvalues)? ECL_NIL : the_env->values[index]); THREAD_NEXT; } CASE(OP_VSETQS); { cl_object var, v; cl_oparg index; GET_DATA(var, vector, data); GET_OPARG(index, vector); v = (index >= the_env->nvalues)? ECL_NIL : the_env->values[index]; ECL_SETQ(the_env, var, v); THREAD_NEXT; } /* OP_BLOCK constant OP_DO OP_CATCH OP_FRAME label{arg} ... OP_EXIT_FRAME label: */ CASE(OP_BLOCK); { GET_DATA(reg0, vector, data); reg1 = ecl_make_fixnum(the_env->frame_id++); lex_env = bind_frame(lex_env, reg1, reg0); THREAD_NEXT; } CASE(OP_DO); { reg0 = ECL_NIL; reg1 = ecl_make_fixnum(the_env->frame_id++); lex_env = bind_frame(lex_env, reg1, reg0); THREAD_NEXT; } CASE(OP_CATCH); { reg1 = reg0; lex_env = bind_frame(lex_env, reg1, reg0); THREAD_NEXT; } CASE(OP_FRAME); { cl_opcode *exit; GET_LABEL(exit, vector); ECL_STACK_PUSH(the_env, lex_env); ECL_STACK_PUSH(the_env, (cl_object)exit); if (ecl_frs_push(the_env,reg1) == 0) { THREAD_NEXT; } else { reg0 = the_env->values[0]; vector = (cl_opcode *)ECL_STACK_REF(the_env,-1); /* FIXME! */ lex_env = ECL_STACK_REF(the_env,-2); goto DO_EXIT_FRAME; } } /* OP_FRAMEID 0 OP_TAGBODY n{arg} label1 ... labeln label1: ... labeln: ... OP_EXIT_TAGBODY High level construct for the TAGBODY form. */ CASE(OP_TAGBODY); { int n; GET_OPARG(n, vector); ECL_STACK_PUSH(the_env, lex_env); ECL_STACK_PUSH(the_env, (cl_object)vector); /* FIXME! */ vector += n * OPARG_SIZE; if (ecl_frs_push(the_env,reg1) != 0) { /* Wait here for gotos. Each goto sets VALUES(0) to an integer which ranges from 0 to ntags-1, depending on the tag. These numbers are indices into the jump table and are computed at compile time. */ cl_opcode *table = (cl_opcode *)ECL_STACK_REF(the_env,-1); lex_env = ECL_STACK_REF(the_env,-2); table = table + ecl_fixnum(the_env->values[0]) * OPARG_SIZE; vector = table + *(cl_oparg *)table; } THREAD_NEXT; } CASE(OP_EXIT_TAGBODY); { reg0 = ECL_NIL; } CASE(OP_EXIT_FRAME); { DO_EXIT_FRAME: ecl_frs_pop(the_env); ECL_STACK_POP_N_UNSAFE(the_env, 2); lex_env = ECL_CONS_CDR(lex_env); THREAD_NEXT; } CASE(OP_NIL); { reg0 = ECL_NIL; THREAD_NEXT; } CASE(OP_PUSHNIL); { ECL_STACK_PUSH(the_env, ECL_NIL); THREAD_NEXT; } CASE(OP_VALUEREG0); { the_env->nvalues = 1; THREAD_NEXT; } /* OP_PUSHVALUES Pushes the values output by the last form, plus the number of values. */ PUSH_VALUES: CASE(OP_PUSHVALUES); { cl_index i = the_env->nvalues; ECL_STACK_PUSH_N(the_env, i+1); the_env->values[0] = reg0; memcpy(&ECL_STACK_REF(the_env, -(i+1)), the_env->values, i * sizeof(cl_object)); ECL_STACK_REF(the_env, -1) = ecl_make_fixnum(the_env->nvalues); THREAD_NEXT; } /* OP_PUSHMOREVALUES Adds more values to the ones pushed by OP_PUSHVALUES. */ CASE(OP_PUSHMOREVALUES); { cl_index n = ecl_fixnum(ECL_STACK_REF(the_env,-1)); cl_index i = the_env->nvalues; ECL_STACK_PUSH_N(the_env, i); the_env->values[0] = reg0; memcpy(&ECL_STACK_REF(the_env, -(i+1)), the_env->values, i * sizeof(cl_object)); ECL_STACK_REF(the_env, -1) = ecl_make_fixnum(n + i); THREAD_NEXT; } /* OP_POPVALUES Pops all values pushed by a OP_PUSHVALUES operator. */ CASE(OP_POPVALUES); { cl_object *dest = the_env->values; int n = the_env->nvalues = ecl_fixnum(ECL_STACK_POP_UNSAFE(the_env)); if (n == 0) { *dest = reg0 = ECL_NIL; THREAD_NEXT; } else if (n == 1) { *dest = reg0 = ECL_STACK_POP_UNSAFE(the_env); THREAD_NEXT; } else { ECL_STACK_POP_N_UNSAFE(the_env,n); memcpy(dest, &ECL_STACK_REF(the_env,0), n * sizeof(cl_object)); reg0 = *dest; THREAD_NEXT; } } /* OP_VALUES n{arg} Pop N values from the stack and store them in VALUES(...) Note that N is strictly > 0. */ CASE(OP_VALUES); { cl_fixnum n; GET_OPARG(n, vector); the_env->nvalues = n; ECL_STACK_POP_N_UNSAFE(the_env, n); memcpy(the_env->values, &ECL_STACK_REF(the_env, 0), n * sizeof(cl_object)); reg0 = the_env->values[0]; THREAD_NEXT; } /* OP_NTHVAL Set VALUES(0) to the N-th value of the VALUES(...) list. The index N-th is extracted from the top of the stack. */ CASE(OP_NTHVAL); { cl_fixnum n = ecl_fixnum(ECL_STACK_POP_UNSAFE(the_env)); if (ecl_unlikely(n < 0)) { FEerror("Wrong index passed to NTH-VAL", 1, ecl_make_fixnum(n)); } else if ((cl_index)n >= the_env->nvalues) { reg0 = ECL_NIL; } else if (n) { reg0 = the_env->values[n]; } THREAD_NEXT; } /* OP_PROTECT label ... ; code to be protected and whose value is output OP_PROTECT_NORMAL label: ... ; code executed at exit OP_PROTECT_EXIT High level construct for UNWIND-PROTECT. The first piece of code is executed and its output value is saved. Then the second piece of code is executed and the output values restored. The second piece of code is always executed, even if a THROW, RETURN or GO happen within the first piece of code. */ CASE(OP_PROTECT); { cl_opcode *exit; GET_LABEL(exit, vector); ECL_STACK_PUSH(the_env, lex_env); ECL_STACK_PUSH(the_env, (cl_object)exit); if (ecl_frs_push(the_env,ECL_PROTECT_TAG) != 0) { ecl_frs_pop(the_env); vector = (cl_opcode *)ECL_STACK_POP_UNSAFE(the_env); lex_env = ECL_STACK_POP_UNSAFE(the_env); reg0 = the_env->values[0]; ECL_STACK_PUSH(the_env, ecl_make_fixnum(the_env->nlj_fr - the_env->frs_top)); goto PUSH_VALUES; } THREAD_NEXT; } CASE(OP_PROTECT_NORMAL); { ecl_bds_unwind(the_env, the_env->frs_top->frs_bds_top_index); ecl_frs_pop(the_env); (void)ECL_STACK_POP_UNSAFE(the_env); lex_env = ECL_STACK_POP_UNSAFE(the_env); ECL_STACK_PUSH(the_env, ecl_make_fixnum(1)); goto PUSH_VALUES; } CASE(OP_PROTECT_EXIT); { volatile cl_fixnum n = the_env->nvalues = ecl_fixnum(ECL_STACK_POP_UNSAFE(the_env)); while (n--) the_env->values[n] = ECL_STACK_POP_UNSAFE(the_env); reg0 = the_env->values[0]; n = ecl_fixnum(ECL_STACK_POP_UNSAFE(the_env)); if (n <= 0) ecl_unwind(the_env, the_env->frs_top + n); THREAD_NEXT; } /* OP_PROGV bindings{list} ... OP_EXIT Execute the code enclosed with the special variables in BINDINGS set to the values in the list which was passed in VALUES(0). */ CASE(OP_PROGV); { cl_object values = reg0; cl_object vars = ECL_STACK_POP_UNSAFE(the_env); cl_index n = ecl_progv(the_env, vars, values); ECL_STACK_PUSH(the_env, ecl_make_fixnum(n)); THREAD_NEXT; } CASE(OP_EXIT_PROGV); { cl_index n = ecl_fixnum(ECL_STACK_POP_UNSAFE(the_env)); ecl_bds_unwind(the_env, n); THREAD_NEXT; } CASE(OP_CSET); { cl_object *p; GET_DATA_PTR(p, vector, data); *p = reg0; THREAD_NEXT; } CASE(OP_STEPIN); { cl_object form; cl_object a = ECL_SYM_VAL(the_env, @'si::*step-action*'); cl_index n; GET_DATA(form, vector, data); SETUP_ENV(the_env); the_env->values[0] = reg0; n = ecl_stack_push_values(the_env); if (a == ECL_T) { /* We are stepping in, but must first ask the user * what to do. */ ECL_SETQ(the_env, @'si::*step-level*', cl_1P(ECL_SYM_VAL(the_env, @'si::*step-level*'))); ECL_STACK_PUSH(the_env, form); INTERPRET_FUNCALL(form, the_env, frame_aux, 1, @'si::stepper'); } else if (a != ECL_NIL) { /* The user told us to step over. *step-level* contains * an integer number that, when it becomes 0, means * that we have finished stepping over. */ ECL_SETQ(the_env, @'si::*step-action*', cl_1P(a)); } else { /* We are not inside a STEP form. This should * actually never happen. */ } ecl_stack_pop_values(the_env, n); reg0 = the_env->values[0]; THREAD_NEXT; } CASE(OP_STEPCALL); { /* We are going to call a function. However, we would * like to step _in_ the function. STEPPER takes care of * that. */ cl_fixnum n; GET_OPARG(n, vector); SETUP_ENV(the_env); if (ECL_SYM_VAL(the_env, @'si::*step-action*') == ECL_T) { ECL_STACK_PUSH(the_env, reg0); INTERPRET_FUNCALL(reg0, the_env, frame_aux, 1, @'si::stepper'); } INTERPRET_FUNCALL(reg0, the_env, frame_aux, n, reg0); } CASE(OP_STEPOUT); { cl_object a = ECL_SYM_VAL(the_env, @'si::*step-action*'); cl_index n; SETUP_ENV(the_env); the_env->values[0] = reg0; n = ecl_stack_push_values(the_env); if (a == ECL_T) { /* We exit one stepping level */ ECL_SETQ(the_env, @'si::*step-level*', cl_1M(ECL_SYM_VAL(the_env, @'si::*step-level*'))); } else if (a == ecl_make_fixnum(0)) { /* We are back to the level in which the user * selected to step over. */ ECL_SETQ(the_env, @'si::*step-action*', ECL_T); } else if (a != ECL_NIL) { ECL_SETQ(the_env, @'si::*step-action*', cl_1M(a)); } else { /* Not stepping, nothing to be done. */ } ecl_stack_pop_values(the_env, n); reg0 = the_env->values[0]; THREAD_NEXT; } } } @(defun si::interpreter-stack () @ @(return ECL_NIL) @) ecl-16.1.2/src/c/iso_latin_names.h000066400000000000000000000200161266352375300167050ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* iso_latin_names.h -- character names in ISO-LATIN-1 */ /* Copyright (c) 2008, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ ecl_def_string_array(char_names,static,const) = { ecl_def_string_array_elt("Nul"), ecl_def_string_array_elt("Soh"), ecl_def_string_array_elt("Stx"), ecl_def_string_array_elt("Etx"), ecl_def_string_array_elt("Eot"), ecl_def_string_array_elt("Enq"), ecl_def_string_array_elt("Ack"), ecl_def_string_array_elt("Bel"), ecl_def_string_array_elt("Backspace"), ecl_def_string_array_elt("Tab"), ecl_def_string_array_elt("Newline"), ecl_def_string_array_elt("Vt"), ecl_def_string_array_elt("Page"), ecl_def_string_array_elt("Return"), ecl_def_string_array_elt("So"), ecl_def_string_array_elt("Si"), ecl_def_string_array_elt("Dle"), ecl_def_string_array_elt("Dc1"), ecl_def_string_array_elt("Dc2"), ecl_def_string_array_elt("Dc3"), ecl_def_string_array_elt("Dc4"), ecl_def_string_array_elt("Nak"), ecl_def_string_array_elt("Syn"), ecl_def_string_array_elt("Etb"), ecl_def_string_array_elt("Can"), ecl_def_string_array_elt("Em"), ecl_def_string_array_elt("Sub"), ecl_def_string_array_elt("Esc"), ecl_def_string_array_elt("Fs"), ecl_def_string_array_elt("Gs"), ecl_def_string_array_elt("Rs"), ecl_def_string_array_elt("Us"), ecl_def_string_array_elt("Space"), ecl_def_string_array_elt("EXCLAMATION_MARK"), ecl_def_string_array_elt("QUOTATION_MARK"), ecl_def_string_array_elt("NUMBER_SIGN"), ecl_def_string_array_elt("DOLLAR_SIGN"), ecl_def_string_array_elt("PERCENT_SIGN"), ecl_def_string_array_elt("AMPERSAND"), ecl_def_string_array_elt("APOSTROPHE"), ecl_def_string_array_elt("LEFT_PARENTHESIS"), ecl_def_string_array_elt("RIGHT_PARENTHESIS"), ecl_def_string_array_elt("ASTERISK"), ecl_def_string_array_elt("PLUS_SIGN"), ecl_def_string_array_elt("COMMA"), ecl_def_string_array_elt("HYPHEN-MINUS"), ecl_def_string_array_elt("FULL_STOP"), ecl_def_string_array_elt("SOLIDUS"), ecl_def_string_array_elt("DIGIT_ZERO"), ecl_def_string_array_elt("DIGIT_ONE"), ecl_def_string_array_elt("DIGIT_TWO"), ecl_def_string_array_elt("DIGIT_THREE"), ecl_def_string_array_elt("DIGIT_FOUR"), ecl_def_string_array_elt("DIGIT_FIVE"), ecl_def_string_array_elt("DIGIT_SIX"), ecl_def_string_array_elt("DIGIT_SEVEN"), ecl_def_string_array_elt("DIGIT_EIGHT"), ecl_def_string_array_elt("DIGIT_NINE"), ecl_def_string_array_elt("COLON"), ecl_def_string_array_elt("SEMICOLON"), ecl_def_string_array_elt("LESS-THAN_SIGN"), ecl_def_string_array_elt("EQUALS_SIGN"), ecl_def_string_array_elt("GREATER-THAN_SIGN"), ecl_def_string_array_elt("QUESTION_MARK"), ecl_def_string_array_elt("COMMERCIAL_AT"), ecl_def_string_array_elt("LATIN_CAPITAL_LETTER_A"), ecl_def_string_array_elt("LATIN_CAPITAL_LETTER_B"), ecl_def_string_array_elt("LATIN_CAPITAL_LETTER_C"), ecl_def_string_array_elt("LATIN_CAPITAL_LETTER_D"), ecl_def_string_array_elt("LATIN_CAPITAL_LETTER_E"), ecl_def_string_array_elt("LATIN_CAPITAL_LETTER_F"), ecl_def_string_array_elt("LATIN_CAPITAL_LETTER_G"), ecl_def_string_array_elt("LATIN_CAPITAL_LETTER_H"), ecl_def_string_array_elt("LATIN_CAPITAL_LETTER_I"), ecl_def_string_array_elt("LATIN_CAPITAL_LETTER_J"), ecl_def_string_array_elt("LATIN_CAPITAL_LETTER_K"), ecl_def_string_array_elt("LATIN_CAPITAL_LETTER_L"), ecl_def_string_array_elt("LATIN_CAPITAL_LETTER_M"), ecl_def_string_array_elt("LATIN_CAPITAL_LETTER_N"), ecl_def_string_array_elt("LATIN_CAPITAL_LETTER_O"), ecl_def_string_array_elt("LATIN_CAPITAL_LETTER_P"), ecl_def_string_array_elt("LATIN_CAPITAL_LETTER_Q"), ecl_def_string_array_elt("LATIN_CAPITAL_LETTER_R"), ecl_def_string_array_elt("LATIN_CAPITAL_LETTER_S"), ecl_def_string_array_elt("LATIN_CAPITAL_LETTER_T"), ecl_def_string_array_elt("LATIN_CAPITAL_LETTER_U"), ecl_def_string_array_elt("LATIN_CAPITAL_LETTER_V"), ecl_def_string_array_elt("LATIN_CAPITAL_LETTER_W"), ecl_def_string_array_elt("LATIN_CAPITAL_LETTER_X"), ecl_def_string_array_elt("LATIN_CAPITAL_LETTER_Y"), ecl_def_string_array_elt("LATIN_CAPITAL_LETTER_Z"), ecl_def_string_array_elt("LEFT_SQUARE_BRACKET"), ecl_def_string_array_elt("REVERSE_SOLIDUS"), ecl_def_string_array_elt("RIGHT_SQUARE_BRACKET"), ecl_def_string_array_elt("CIRCUMFLEX_ACCENT"), ecl_def_string_array_elt("LOW_LINE"), ecl_def_string_array_elt("GRAVE_ACCENT"), ecl_def_string_array_elt("LATIN_SMALL_LETTER_A"), ecl_def_string_array_elt("LATIN_SMALL_LETTER_B"), ecl_def_string_array_elt("LATIN_SMALL_LETTER_C"), ecl_def_string_array_elt("LATIN_SMALL_LETTER_D"), ecl_def_string_array_elt("LATIN_SMALL_LETTER_E"), ecl_def_string_array_elt("LATIN_SMALL_LETTER_F"), ecl_def_string_array_elt("LATIN_SMALL_LETTER_G"), ecl_def_string_array_elt("LATIN_SMALL_LETTER_H"), ecl_def_string_array_elt("LATIN_SMALL_LETTER_I"), ecl_def_string_array_elt("LATIN_SMALL_LETTER_J"), ecl_def_string_array_elt("LATIN_SMALL_LETTER_K"), ecl_def_string_array_elt("LATIN_SMALL_LETTER_L"), ecl_def_string_array_elt("LATIN_SMALL_LETTER_M"), ecl_def_string_array_elt("LATIN_SMALL_LETTER_N"), ecl_def_string_array_elt("LATIN_SMALL_LETTER_O"), ecl_def_string_array_elt("LATIN_SMALL_LETTER_P"), ecl_def_string_array_elt("LATIN_SMALL_LETTER_Q"), ecl_def_string_array_elt("LATIN_SMALL_LETTER_R"), ecl_def_string_array_elt("LATIN_SMALL_LETTER_S"), ecl_def_string_array_elt("LATIN_SMALL_LETTER_T"), ecl_def_string_array_elt("LATIN_SMALL_LETTER_U"), ecl_def_string_array_elt("LATIN_SMALL_LETTER_V"), ecl_def_string_array_elt("LATIN_SMALL_LETTER_W"), ecl_def_string_array_elt("LATIN_SMALL_LETTER_X"), ecl_def_string_array_elt("LATIN_SMALL_LETTER_Y"), ecl_def_string_array_elt("LATIN_SMALL_LETTER_Z"), ecl_def_string_array_elt("LEFT_CURLY_BRACKET"), ecl_def_string_array_elt("VERTICAL_LINE"), ecl_def_string_array_elt("RIGHT_CURLY_BRACKET"), ecl_def_string_array_elt("TILDE"), ecl_def_string_array_elt("Rubout"), ecl_def_string_array_elt(0) }; /* Linefeed is redundant with one of the names given in * iso_latin_names.h, but it can not be associated to the code * 10, because the default name must be Newline. Similar to * the other codes. */ ecl_def_string_array(extra_char_names,static,const) = { ecl_def_string_array_elt("Null"), /* 0 */ ecl_def_string_array_elt("Bell"), /* 7 */ ecl_def_string_array_elt("Bs"), /* 8 */ ecl_def_string_array_elt("Ht"), /* 9 */ ecl_def_string_array_elt("Linefeed"), /* 10 */ ecl_def_string_array_elt("Lf"), /* 10 */ ecl_def_string_array_elt("Escape"), /* 27 */ ecl_def_string_array_elt("Ff"), /* 12 */ ecl_def_string_array_elt("Cr"), /* 13 */ ecl_def_string_array_elt("Sp"), /* 32 */ ecl_def_string_array_elt("Del"), /* 127 */ ecl_def_string_array_elt("Delete") /* 127 */ }; static const unsigned char extra_char_codes[] = { 0, 7, 8, 9, 10, 10, 27, 12, 13, 32, 127, 127 }; #define extra_char_names_size 12 ecl-16.1.2/src/c/list.d000066400000000000000000000725561266352375300145300ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* list.d -- List manipulating routines. */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #include struct cl_test { bool (*test_c_function)(struct cl_test *, cl_object); cl_object (*key_c_function)(struct cl_test *, cl_object); cl_env_ptr env; cl_object key_function; cl_objectfn key_fn; cl_object test_function; cl_objectfn test_fn; cl_object item_compared; }; static cl_object subst(struct cl_test *t, cl_object new_obj, cl_object tree); static cl_object nsubst(struct cl_test *t, cl_object new_obj, cl_object tree); static cl_object sublis(struct cl_test *t, cl_object alist, cl_object tree); static cl_object nsublis(struct cl_test *t, cl_object alist, cl_object tree); static cl_object do_assoc(struct cl_test *t, cl_object alist); #define TEST(t,k) ((t)->test_c_function)((t),(k)) #define KEY(t,x) ((t)->key_c_function)((t),(x)) #define close_test(t) (void)0 static bool test_compare(struct cl_test *t, cl_object x) { x = KEY(t,x); t->env->function = t->test_function; return t->test_fn(2, t->item_compared, x) != ECL_NIL; } static bool test_compare_not(struct cl_test *t, cl_object x) { x = KEY(t,x); t->env->function = t->test_function; return t->test_fn(2, t->item_compared, x) == ECL_NIL; } static bool test_eq(struct cl_test *t, cl_object x) { return (t->item_compared == KEY(t,x)); } static bool test_eql(struct cl_test *t, cl_object x) { return ecl_eql(t->item_compared, KEY(t,x)); } static bool test_equal(struct cl_test *t, cl_object x) { return ecl_equal(t->item_compared, KEY(t,x)); } static bool test_equalp(struct cl_test *t, cl_object x) { return ecl_equalp(t->item_compared, KEY(t,x)); } static cl_object key_function(struct cl_test *t, cl_object x) { t->env->function = t->key_function; return t->key_fn(1,x); } static cl_object key_identity(struct cl_test *t, cl_object x) { return x; } static void setup_test(struct cl_test *t, cl_object item, cl_object test, cl_object test_not, cl_object key) { cl_env_ptr env = t->env = ecl_process_env(); t->item_compared = item; if (test != ECL_NIL) { if (test_not != ECL_NIL) FEerror("Both :TEST and :TEST-NOT are specified.", 0); t->test_function = test = si_coerce_to_function(test); if (test == ECL_SYM_FUN(@'eq')) { t->test_c_function = test_eq; } else if (test == ECL_SYM_FUN(@'eql')) { t->test_c_function = test_eql; } else if (test == ECL_SYM_FUN(@'equal')) { t->test_c_function = test_equal; } else if (test == ECL_SYM_FUN(@'equalp')) { t->test_c_function = test_equalp; } else { t->test_c_function = test_compare; t->test_fn = ecl_function_dispatch(env, test); t->test_function = env->function; } } else if (test_not != ECL_NIL) { t->test_c_function = test_compare_not; test_not = si_coerce_to_function(test_not); t->test_fn = ecl_function_dispatch(env, test_not); t->test_function = env->function; } else { t->test_c_function = test_eql; } if (key != ECL_NIL) { key = si_coerce_to_function(key); t->key_fn = ecl_function_dispatch(env, key); t->key_function = env->function; t->key_c_function = key_function; } else { t->key_c_function = key_identity; } } @(defun list (&rest args) cl_object head = ECL_NIL; @ if (narg--) { cl_object tail = head = ecl_list1(ecl_va_arg(args)); while (narg--) { cl_object cons = ecl_list1(ecl_va_arg(args)); ECL_RPLACD(tail, cons); tail = cons; } } @(return head) @) @(defun list* (&rest args) cl_object head; @ if (narg == 0) FEwrong_num_arguments(@[list*]); head = ecl_va_arg(args); if (--narg) { cl_object tail = head = ecl_list1(head); while (--narg) { cl_object cons = ecl_list1(ecl_va_arg(args)); ECL_RPLACD(tail, cons); tail = cons; } ECL_RPLACD(tail, ecl_va_arg(args)); } @(return head) @) static cl_object * append_into(cl_object head, cl_object *tail, cl_object l) { if (!Null(*tail)) { /* (APPEND '(1 . 2) 3) */ FEtype_error_proper_list(head); } while (CONSP(l)) { cl_object cons = ecl_list1(ECL_CONS_CAR(l)); *tail = cons; tail = &ECL_CONS_CDR(cons); l = ECL_CONS_CDR(l); } *tail = l; return tail; } @(defun append (&rest rest) cl_object head = ECL_NIL, *tail = &head; @ for (; narg > 1; narg--) { cl_object other = ecl_va_arg(rest); tail = append_into(head, tail, other); } if (narg) { if (!Null(*tail)) { /* (APPEND '(1 . 2) 3) */ FEtype_error_proper_list(head); } *tail = ecl_va_arg(rest); } @(return head) @) cl_object ecl_append(cl_object x, cl_object y) { cl_object head = ECL_NIL; cl_object *tail = &head; if (!Null(x)) { tail = append_into(head, tail, x); } if (!Null(*tail)) { /* (APPEND '(1 . 2) 3) */ FEtype_error_proper_list(head); } *tail = y; return head; } #define LENTH(n) (cl_object x) { \ const cl_env_ptr the_env = ecl_process_env(); \ ecl_return1(the_env, ecl_nth(n, x)); \ } cl_object @fifth LENTH(4) cl_object @sixth LENTH(5) cl_object @seventh LENTH(6) cl_object @eighth LENTH(7) cl_object @ninth LENTH(8) cl_object @tenth LENTH(9) #undef LENTH static bool tree_equal(struct cl_test *t, cl_object x, cl_object y) { BEGIN: if (CONSP(x)) { if (CONSP(y)) { if (tree_equal(t, ECL_CONS_CAR(x), ECL_CONS_CAR(y))) { x = ECL_CONS_CDR(x); y = ECL_CONS_CDR(y); goto BEGIN; } else { return(FALSE); } } else { return(FALSE); } } else { t->item_compared = x; if (TEST(t, y)) return(TRUE); else return(FALSE); } } @(defun tree_equal (x y &key test test_not) struct cl_test t; cl_object output; @ setup_test(&t, ECL_NIL, test, test_not, ECL_NIL); output = tree_equal(&t, x, y)? ECL_T : ECL_NIL; close_test(&t); @(return output) @) cl_object cl_endp(cl_object x) { cl_object output = ECL_NIL; if (Null(x)) { output = ECL_T; } else if (ecl_unlikely(!LISTP(x))) { FEwrong_type_only_arg(@[endp], x, @[list]); } @(return output); } bool ecl_endp(cl_object x) { if (Null(x)) { return TRUE; } else if (ecl_unlikely(!LISTP(x))) { FEwrong_type_only_arg(@[endp], x, @[list]); } return FALSE; } cl_object cl_list_length(cl_object x) { cl_fixnum n; cl_object fast, slow; /* INV: A list's length always fits in a fixnum */ fast = slow = x; for (n = 0; !Null(fast); n++, fast = ECL_CONS_CDR(fast)) { if (ecl_unlikely(!LISTP(fast))) { FEtype_error_list(fast); } if (n & 1) { /* Circular list? */ if (slow == fast) @(return ECL_NIL); slow = ECL_CONS_CDR(slow); } } @(return ecl_make_fixnum(n)); } cl_object si_proper_list_p(cl_object x) { cl_fixnum n; cl_object fast, slow, test = ECL_T; /* INV: A list's length always fits in a fixnum */ fast = slow = x; for (n = 0; !Null(fast); n++, fast = ECL_CONS_CDR(fast)) { if (!LISTP(fast)) { test = ECL_NIL; break; } if (n & 1) { /* Circular list? */ if (slow == fast) { test = ECL_NIL; break; } slow = ECL_CONS_CDR(slow); } } @(return test); } cl_object cl_nth(cl_object n, cl_object x) { @(return ecl_nth(ecl_to_size(n), x)) } cl_object ecl_nth(cl_fixnum n, cl_object x) { if (n < 0) FEtype_error_index(x, n); /* INV: No need to check for circularity since we visit at most `n' conses */ for (; n > 0 && CONSP(x); n--) x = ECL_CONS_CDR(x); if (Null(x)) return ECL_NIL; if (!LISTP(x)) FEtype_error_list(x); return ECL_CONS_CAR(x); } cl_object cl_nthcdr(cl_object n, cl_object x) { @(return ecl_nthcdr(ecl_to_size(n), x)) } cl_object ecl_nthcdr(cl_fixnum n, cl_object x) { if (n < 0) FEtype_error_index(x, n); while (n-- > 0 && !Null(x)) { if (LISTP(x)) { x = ECL_CONS_CDR(x); } else { FEtype_error_list(x); } } return x; } cl_object ecl_last(cl_object l, cl_index n) { /* The algorithm is very simple. We run over the list with * two pointers, "l" and "r". The separation between both * must be "n", so that when "l" finds no more conses, "r" * contains the output. */ cl_object r; for (r = l; n && CONSP(r); n--, r = ECL_CONS_CDR(r)) ; /* If "l" has not moved, we have to ensure that it is a list */ if (r == l) { if (!LISTP(r)) FEtype_error_list(l); while (CONSP(r)) { r = ECL_CONS_CDR(r); } return r; } else if (n == 0) { while (CONSP(r)) { r = ECL_CONS_CDR(r); l = ECL_CONS_CDR(l); } return l; } else { return l; } } @(defun last (l &optional (k ecl_make_fixnum(1))) @ if (ecl_t_of(k) == t_bignum) @(return l) @(return ecl_last(l, ecl_to_size(k))) @) @(defun make_list (size &key initial_element &aux x) cl_fixnum i; @ /* INV: ecl_to_size() signals a type-error if SIZE is not a integer >=0 */ i = ecl_to_size(size); while (i-- > 0) x = CONS(initial_element, x); @(return x) @) cl_object cl_copy_list(cl_object x) { cl_object copy; if (ecl_unlikely(!LISTP(x))) { FEwrong_type_only_arg(@[copy-list], x, @[list]); } copy = ECL_NIL; if (!Null(x)) { cl_object tail = copy = ecl_list1(CAR(x)); while (x = ECL_CONS_CDR(x), CONSP(x)) { cl_object cons = ecl_list1(ECL_CONS_CAR(x)); ECL_RPLACD(tail, cons); tail = cons; } ECL_RPLACD(tail, x); } @(return copy); } static cl_object duplicate_pairs(cl_object x) { cl_object p = ECL_CONS_CAR(x); if (CONSP(p)) p = CONS(ECL_CONS_CAR(p), ECL_CONS_CDR(p)); return ecl_list1(p); } cl_object cl_copy_alist(cl_object x) { cl_object copy; if (ecl_unlikely(!LISTP(x))) { FEwrong_type_only_arg(@[copy-alist], x, @[list]); } copy = ECL_NIL; if (!Null(x)) { cl_object tail = copy = duplicate_pairs(x); while (x = ECL_CONS_CDR(x), !Null(x)) { if (!LISTP(x)) { FEtype_error_list(x); } else { cl_object cons = duplicate_pairs(x); tail = ECL_RPLACD(tail, cons); tail = cons; } } } @(return copy); } static cl_object do_copy_tree(cl_object x) { if (CONSP(x)) { x = CONS(do_copy_tree(ECL_CONS_CAR(x)), do_copy_tree(ECL_CONS_CDR(x))); } return x; } cl_object cl_copy_tree(cl_object x) { @(return do_copy_tree(x)) } cl_object cl_revappend(cl_object x, cl_object y) { loop_for_in(x) { y = CONS(ECL_CONS_CAR(x),y); } end_loop_for_in; @(return y) } @(defun nconc (&rest lists) cl_object head = ECL_NIL, tail = ECL_NIL; @ while (narg--) { cl_object new_tail, other = ecl_va_arg(lists); if (Null(other)) { new_tail = tail; } else if (CONSP(other)) { new_tail = ecl_last(other, 1); } else { if (narg) FEtype_error_list(other); new_tail = tail; } if (Null(head)) { head = other; } else { ECL_RPLACD(tail, other); } tail = new_tail; } @(return head) @) cl_object ecl_nconc(cl_object l, cl_object y) { if (Null(l)) { return y; } else { ECL_RPLACD(ecl_last(l, 1), y); return l; } } cl_object cl_nreconc(cl_object l, cl_object y) { cl_object x, z; /* INV: when a circular list is "reconc'ed", the pointer ends up at the beginning of the original list, hence we need no slow pointer */ for (x = l; !Null(x); ) { if (!LISTP(x)) FEtype_error_list(x); z = x; x = ECL_CONS_CDR(x); if (x == l) FEcircular_list(l); ECL_RPLACD(z, y); y = z; } @(return y) } cl_object ecl_butlast(cl_object l, cl_index n) { /* See LAST for details on this algorithm */ cl_object r; for (r = l; n && CONSP(r); n--, r = ECL_CONS_CDR(r)) ; if (Null(r)) { return ECL_NIL; } else if (!LISTP(r)) { /* We reach here either because l is shorter than n conses, * or because it is not a list */ if (r == l) FEtype_error_list(r); return ECL_NIL; } else { /* We reach here because l has at least n conses and * thus we can take CAR(l) */ cl_object head, tail; head = tail = ecl_list1(CAR(l)); while (l = ECL_CONS_CDR(l), r = ECL_CONS_CDR(r), CONSP(r)) { cl_object cons = ecl_list1(ECL_CONS_CAR(l)); ECL_RPLACD(tail, cons); tail = cons; } return head; } } @(defun butlast (lis &optional (nn ecl_make_fixnum(1))) @ /* INV: No list has more than MOST_POSITIVE_FIXNUM elements */ if (ecl_t_of(nn) == t_bignum) @(return ECL_NIL); /* INV: ecl_to_size() signals a type-error if NN is not an integer >=0 */ @(return ecl_butlast(lis, ecl_to_size(nn))) @) cl_object ecl_nbutlast(cl_object l, cl_index n) { cl_object r; if (ecl_unlikely(!LISTP(l))) FEwrong_type_only_arg(@[nbutlast], l, @[list]); for (n++, r = l; n && CONSP(r); n--, r = ECL_CONS_CDR(r)) ; if (n == 0) { cl_object tail = l; while (CONSP(r)) { tail = ECL_CONS_CDR(tail); r = ECL_CONS_CDR(r); } ECL_RPLACD(tail, ECL_NIL); return l; } return ECL_NIL; } @(defun nbutlast (lis &optional (nn ecl_make_fixnum(1))) @ /* INV: No list has more than MOST_POSITIVE_FIXNUM elements */ if (ecl_t_of(nn) == t_bignum) @(return ECL_NIL) /* INV: ecl_to_size() signas a type-error if NN is not an integer >=0 */ @(return ecl_nbutlast(lis, ecl_to_size(nn))) @) cl_object cl_ldiff(cl_object x, cl_object y) { cl_object head = ECL_NIL; if (ecl_unlikely(!LISTP(x))) { FEwrong_type_only_arg(@[ldiff], x, @[list]); } /* Here we use that, if X or Y are CONS, then (EQL X Y) * only when X == Y */ if (!Null(x) && (x != y)) { cl_object tail = head = ecl_list1(ECL_CONS_CAR(x)); while (1) { x = ECL_CONS_CDR(x); if (!CONSP(x)) { if (!ecl_eql(x, y)) { ECL_RPLACD(tail, x); } break; } else if (x == y) { break; } else { cl_object cons = ecl_list1(ECL_CONS_CAR(x)); ECL_RPLACD(tail, cons); tail = cons; } } } @(return head) } cl_object cl_rplaca(cl_object x, cl_object v) { if (ecl_unlikely(!CONSP(x))) FEwrong_type_nth_arg(@[rplaca], 1, x, @[cons]); ECL_RPLACA(x, v); @(return x) } cl_object cl_rplacd(cl_object x, cl_object v) { if (ecl_unlikely(!CONSP(x))) FEwrong_type_nth_arg(@[rplacd], 1, x, @[cons]); ECL_RPLACD(x, v); @(return x) } @(defun subst (new_obj old_obj tree &key test test_not key) struct cl_test t; cl_object output; @ setup_test(&t, old_obj, test, test_not, key); output = subst(&t, new_obj, tree); close_test(&t); @(return output) @) static cl_object subst(struct cl_test *t, cl_object new_obj, cl_object tree) { if (TEST(t, tree)) { return new_obj; } else if (ECL_ATOM(tree)) { return tree; } else { cl_object head, tail = ECL_NIL; do { cl_object cons = subst(t, new_obj, ECL_CONS_CAR(tree)); cons = ecl_cons(cons, tree = ECL_CONS_CDR(tree)); if (Null(tail)) { head = cons; } else { ECL_RPLACD(tail, cons); } tail = cons; if (TEST(t, tree)) { ECL_RPLACD(tail, new_obj); return head; } } while (CONSP(tree)); return head; } } @(defun nsubst (new_obj old_obj tree &key test test_not key) struct cl_test t; @ setup_test(&t, old_obj, test, test_not, key); tree = nsubst(&t, new_obj, tree); close_test(&t); @(return tree) @) static cl_object nsubst_cons(struct cl_test *t, cl_object new_obj, cl_object tree) { cl_object l = tree; do { cl_object o = ECL_CONS_CAR(l); if (TEST(t, o)) { ECL_RPLACA(l, new_obj); } else if (CONSP(o)) { nsubst_cons(t, new_obj, o); } o = ECL_CONS_CDR(l); if (TEST(t, o)) { ECL_RPLACD(l, new_obj); return tree; } l = o; } while (CONSP(l)); return tree; } static cl_object nsubst(struct cl_test *t, cl_object new_obj, cl_object tree) { if (TEST(t, tree)) return new_obj; if (CONSP(tree)) return nsubst_cons(t, new_obj, tree); return tree; } @(defun sublis (alist tree &key test test_not key) /* t[0] is the test for the objects in the tree, configured with test, test_not and key. t[1] is the test for searching in the association list. */ struct cl_test t[2]; @ setup_test(t, ECL_NIL, ECL_NIL, ECL_NIL, key); setup_test(t+1, ECL_NIL, test, test_not, ECL_NIL); tree = sublis(t, alist, tree); close_test(t+1); close_test(t); @(return tree) @) /* Sublis(alist, tree) returns result of substituting tree by alist. */ static cl_object sublis(struct cl_test *t, cl_object alist, cl_object tree) { cl_object node; t[1].item_compared = KEY(t, tree); node = do_assoc(t+1, alist); if (!Null(node)) { return ECL_CONS_CDR(node); } if (CONSP(tree)) { tree = CONS(sublis(t, alist, ECL_CONS_CAR(tree)), sublis(t, alist, ECL_CONS_CDR(tree))); } return tree; } @(defun nsublis (alist tree &key test test_not key) /* t[0] is the test for the objects in the tree, configured with test, test_not and key. t[1] is the test for searching in the association list. */ struct cl_test t[2]; @ setup_test(t, ECL_NIL, ECL_NIL, ECL_NIL, key); setup_test(t+1, ECL_NIL, test, test_not, ECL_NIL); tree = nsublis(t, alist, tree); close_test(t+1); close_test(t); @(return tree) @) /* Nsublis(alist, treep) stores the result of substiting *treep by alist to *treep. */ static cl_object nsublis(struct cl_test *t, cl_object alist, cl_object tree) { cl_object node; t[1].item_compared = KEY(t, tree); node = do_assoc(t+1, alist); if (!Null(node)) { return ECL_CONS_CDR(node); } if (CONSP(tree)) { ECL_RPLACA(tree, nsublis(t, alist, ECL_CONS_CAR(tree))); ECL_RPLACD(tree, nsublis(t, alist, ECL_CONS_CDR(tree))); } return tree; } @(defun member (item list &key test test_not key) struct cl_test t; @ setup_test(&t, item, test, test_not, key); loop_for_in(list) { if (TEST(&t, ECL_CONS_CAR(list))) break; } end_loop_for_in; close_test(&t); @(return list) @) bool ecl_member_eq(cl_object x, cl_object l) { loop_for_in(l) { if (x == ECL_CONS_CAR(l)) return(TRUE); } end_loop_for_in; return(FALSE); } cl_object si_memq(cl_object x, cl_object l) { loop_for_in(l) { if (x == ECL_CONS_CAR(l)) @(return l) } end_loop_for_in; @(return ECL_NIL) } /* Added for use by the compiler, instead of open coding them. Beppe */ cl_object ecl_memql(cl_object x, cl_object l) { loop_for_in(l) { if (ecl_eql(x, ECL_CONS_CAR(l))) return(l); } end_loop_for_in; return(ECL_NIL); } cl_object ecl_member(cl_object x, cl_object l) { loop_for_in(l) { if (ecl_equal(x, ECL_CONS_CAR(l))) return(l); } end_loop_for_in; return(ECL_NIL); } /* End of addition. Beppe */ cl_object si_member1(cl_object item, cl_object list, cl_object test, cl_object test_not, cl_object key) { struct cl_test t; if (key != ECL_NIL) item = funcall(2, key, item); setup_test(&t, item, test, test_not, key); loop_for_in(list) { if (TEST(&t, ECL_CONS_CAR(list))) break; } end_loop_for_in; close_test(&t); @(return list) } cl_object cl_tailp(cl_object y, cl_object x) { loop_for_on(x) { if (ecl_eql(x, y)) @(return ECL_T); } end_loop_for_on(x); return cl_eql(x, y); } @(defun adjoin (item list &key test test_not key) cl_object output; @ if (narg < 2) FEwrong_num_arguments(@[adjoin]); output = @si::member1(item, list, test, test_not, key); if (Null(output)) output = CONS(item, list); else output = list; @(return output) @) cl_object cl_cons(cl_object x, cl_object y) { @(return CONS(x, y)) } cl_object cl_acons(cl_object x, cl_object y, cl_object z) { @(return CONS(CONS(x, y), z)) } @(defun pairlis (keys data &optional a_list) cl_object k, d; @ k = keys; d = data; loop_for_in(k) { if (ecl_endp(d)) goto error; a_list = CONS(CONS(ECL_CONS_CAR(k), ECL_CONS_CAR(d)), a_list); d = CDR(d); } end_loop_for_in; if (!ecl_endp(d)) error: FEerror("The keys ~S and the data ~S are not of the same length", 2, keys, data); @(return a_list) @) @(defun assoc (item a_list &key test test_not key) struct cl_test t; @ setup_test(&t, item, test, test_not, key); a_list = do_assoc(&t, a_list); close_test(&t); @(return a_list) @) static cl_object do_assoc(struct cl_test *t, cl_object a_list) { loop_for_in(a_list) { cl_object pair = ECL_CONS_CAR(a_list); if (!Null(pair)) { if (!LISTP(pair)) FEtype_error_list(pair); if (TEST(t, ECL_CONS_CAR(pair))) return pair; } } end_loop_for_in; return ECL_NIL; } @(defun rassoc (item a_list &key test test_not key) struct cl_test t; @ setup_test(&t, item, test, test_not, key); loop_for_in(a_list) { cl_object pair = ECL_CONS_CAR(a_list); if (!Null(pair)) { if (!LISTP(pair)) FEtype_error_list(pair); if (TEST(&t, ECL_CONS_CDR(pair))) { a_list = pair; break; } } } end_loop_for_in; close_test(&t); @(return a_list) @) cl_object ecl_remove_eq(cl_object x, cl_object l) { cl_object head = ECL_NIL, tail = ECL_NIL; loop_for_on_unsafe(l) { if (ECL_CONS_CAR(l) != x) { cl_object cons = ecl_list1(ECL_CONS_CAR(l)); if (Null(tail)) { head = tail = cons; } else { ECL_RPLACD(tail, cons); tail = cons; } } } end_loop_for_on_unsafe(l); return head; } cl_object ecl_delete_eq(cl_object x, cl_object l) { cl_object head = l; cl_object *p = &head; while (!ECL_ATOM(l)) { if (ECL_CONS_CAR(l) == x) { *p = l = ECL_CONS_CDR(l); } else { p = &ECL_CONS_CDR(l); l = *p; } } return head; } /* Added for use by the compiler, instead of open coding them. Beppe */ cl_object ecl_assq(cl_object x, cl_object l) { loop_for_in(l) { cl_object pair = ECL_CONS_CAR(l); if (x == CAR(pair)) return pair; } end_loop_for_in; return(ECL_NIL); } cl_object ecl_assql(cl_object x, cl_object l) { loop_for_in(l) { cl_object pair = ECL_CONS_CAR(l); if (ecl_eql(x, CAR(pair))) return pair; } end_loop_for_in; return(ECL_NIL); } cl_object ecl_assoc(cl_object x, cl_object l) { loop_for_in(l) { cl_object pair = ECL_CONS_CAR(l); if (ecl_equal(x, CAR(pair))) return pair; } end_loop_for_in; return(ECL_NIL); } cl_object ecl_assqlp(cl_object x, cl_object l) { loop_for_in(l) { cl_object pair = ECL_CONS_CAR(l); if (ecl_equalp(x, CAR(pair))) return pair; } end_loop_for_in; return(ECL_NIL); } /* End of addition. Beppe */ ecl-16.1.2/src/c/load.d000066400000000000000000000315451266352375300144650ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* load.d -- Binary loader (contains also open_fasl_data). */ /* Copyright (c) 1990, Giuseppe Attardi and William F. Schelter. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #include #include #ifdef ENABLE_DLOPEN cl_object si_load_binary(cl_object filename, cl_object verbose, cl_object print, cl_object external_format) { const cl_env_ptr the_env = ecl_process_env(); cl_object block, map, array; cl_object basename; cl_object init_prefix, prefix; cl_object output; /* We need the full pathname */ filename = cl_truename(filename); /* Try to load shared object file */ block = ecl_library_open(filename, 1); if (block->cblock.handle == NULL) { output = ecl_library_error(block); goto OUTPUT; } /* Fist try to call "init_CODE()" */ init_prefix = _ecl_library_default_entry(); block->cblock.entry = ecl_library_symbol(block, (char *)init_prefix->base_string.self, 0); if (block->cblock.entry != NULL) goto GO_ON; /* Next try to call "init_FILE()" where FILE is the file name */ prefix = ecl_symbol_value(@'si::*init-function-prefix*'); init_prefix = _ecl_library_init_prefix(); if (Null(prefix)) { prefix = init_prefix; } else { prefix = @si::base-string-concatenate(3, init_prefix, prefix, make_constant_base_string("_")); } basename = cl_pathname_name(1,filename); basename = @si::base-string-concatenate(2, prefix, @string-upcase(1, funcall(4, @'nsubstitute', ECL_CODE_CHAR('_'), ECL_CODE_CHAR('-'), basename))); block->cblock.entry = ecl_library_symbol(block, (char*)basename->base_string.self, 0); if (block->cblock.entry == NULL) { output = ecl_library_error(block); ecl_library_close(block); goto OUTPUT; } GO_ON: /* Finally, perform initialization */ ecl_init_module(block, (void (*)(cl_object))(block->cblock.entry)); output = ECL_NIL; OUTPUT: ecl_return1(the_env, output); } #endif /* !ENABLE_DLOPEN */ cl_object si_load_source(cl_object source, cl_object verbose, cl_object print, cl_object external_format) { cl_env_ptr the_env = ecl_process_env(); cl_object x, strm; /* Source may be either a stream or a filename */ if (ecl_t_of(source) != t_pathname && ecl_t_of(source) != t_base_string) { /* INV: if "source" is not a valid stream, file.d will complain */ strm = source; } else { strm = ecl_open_stream(source, ecl_smm_input, ECL_NIL, ECL_NIL, 8, ECL_STREAM_C_STREAM, external_format); if (Null(strm)) @(return ECL_NIL) } ECL_UNWIND_PROTECT_BEGIN(the_env) { cl_object form_index = ecl_make_fixnum(0); cl_object pathname = ECL_SYM_VAL(the_env, @'*load-pathname*'); cl_object location = CONS(pathname, form_index); ecl_bds_bind(the_env, @'ext::*source-location*', location); for (;;) { form_index = ecl_file_position(strm); ECL_RPLACD(location, form_index); x = si_read_object_or_ignore(strm, OBJNULL); if (x == OBJNULL) break; if (the_env->nvalues) { si_eval_with_env(1, x); if (print != ECL_NIL) { @write(1, x); @terpri(0); } } } ecl_bds_unwind1(the_env); } ECL_UNWIND_PROTECT_EXIT { /* We do not want to come back here if close_stream fails, therefore, first we frs_pop() current jump point, then try to close the stream, and then jump to next catch point */ if (strm != source) cl_close(3, strm, @':abort', @'t'); } ECL_UNWIND_PROTECT_END; @(return ECL_NIL) } cl_object si_load_bytecodes(cl_object source, cl_object verbose, cl_object print, cl_object external_format) { cl_env_ptr env = ecl_process_env(); cl_object forms, strm; cl_object old_eptbc = env->packages_to_be_created; /* Source may be either a stream or a filename */ if (ecl_t_of(source) != t_pathname && ecl_t_of(source) != t_base_string) { /* INV: if "source" is not a valid stream, file.d will complain */ strm = source; } else { strm = ecl_open_stream(source, ecl_smm_input, ECL_NIL, ECL_NIL, 8, ECL_STREAM_C_STREAM, external_format); if (Null(strm)) @(return ECL_NIL) } ECL_UNWIND_PROTECT_BEGIN(env) { { cl_object progv_list = ECL_SYM_VAL(env, @'si::+ecl-syntax-progv-list+'); cl_index bds_ndx = ecl_progv(env, ECL_CONS_CAR(progv_list), ECL_CONS_CDR(progv_list)); env->packages_to_be_created_p = ECL_T; forms = cl_read(1, strm); env->packages_to_be_created_p = ECL_NIL; ecl_bds_unwind(env, bds_ndx); } while (!Null(forms)) { if (ECL_LISTP(forms)) { cl_object x = ECL_CONS_CAR(forms); forms = ECL_CONS_CDR(forms); if (ecl_t_of(x) == t_bytecodes) { _ecl_funcall1(x); continue; } } FEerror("Corrupt bytecodes file ~S", 1, source); } { cl_object x; x = cl_set_difference(2, env->packages_to_be_created, old_eptbc); old_eptbc = env->packages_to_be_created; unlikely_if (!Null(x)) { CEerror(ECL_T, Null(ECL_CONS_CDR(x))? "Package ~A referenced in " "compiled file~& ~A~&but has not been created": "The packages~& ~A~&were referenced in " "compiled file~& ~A~&but have not been created", 2, x, source); } } } ECL_UNWIND_PROTECT_EXIT { /* We do not want to come back here if close_stream fails, therefore, first we frs_pop() current jump point, then try to close the stream, and then jump to next catch point */ if (strm != source) cl_close(3, strm, @':abort', @'t'); } ECL_UNWIND_PROTECT_END; @(return ECL_NIL) } @(defun load (source &key (verbose ecl_symbol_value(@'*load-verbose*')) (print ecl_symbol_value(@'*load-print*')) (if_does_not_exist @':error') (external_format @':default') (search_list ecl_symbol_value(@'si::*load-search-list*')) &aux pathname pntype hooks filename function ok) bool not_a_filename = 0; @ /* If source is a stream, read conventional lisp code from it */ if (ecl_t_of(source) != t_pathname && !ecl_stringp(source)) { /* INV: if "source" is not a valid stream, file.d will complain */ filename = source; function = ECL_NIL; not_a_filename = 1; goto NOT_A_FILENAME; } /* INV: coerce_to_file_pathname() creates a fresh new pathname object */ source = cl_merge_pathnames(1, source); pathname = coerce_to_file_pathname(source); pntype = pathname->pathname.type; filename = ECL_NIL; hooks = ecl_symbol_value(@'ext::*load-hooks*'); if (Null(pathname->pathname.directory) && Null(pathname->pathname.host) && Null(pathname->pathname.device) && !Null(search_list)) { loop_for_in(search_list) { cl_object d = CAR(search_list); cl_object f = cl_merge_pathnames(2, pathname, d); cl_object ok = cl_load(11, f, @':verbose', verbose, @':print', print, @':if-does-not-exist', ECL_NIL, @':external-format', external_format, @':search-list', ECL_NIL); if (!Null(ok)) { @(return ok); } } end_loop_for_in; } if (!Null(pntype) && (pntype != @':wild')) { /* If filename already has an extension, make sure that the file exists */ cl_object kind; filename = si_coerce_to_filename(pathname); kind = si_file_kind(filename, ECL_T); if (kind != @':file' && kind != @':special') { filename = ECL_NIL; } else { function = cl_cdr(ecl_assoc(pathname->pathname.type, hooks)); } } else loop_for_in(hooks) { /* Otherwise try with known extensions until a matching file is found */ cl_object kind; filename = pathname; filename->pathname.type = CAAR(hooks); function = CDAR(hooks); kind = si_file_kind(filename, ECL_T); if (kind == @':file' || kind == @':special') break; else filename = ECL_NIL; } end_loop_for_in; if (Null(filename)) { if (Null(if_does_not_exist)) @(return ECL_NIL) else FEcannot_open(source); } NOT_A_FILENAME: if (verbose != ECL_NIL) { cl_format(3, ECL_T, make_constant_base_string("~&;;; Loading ~s~%"), filename); } ecl_bds_bind(the_env, @'*package*', ecl_symbol_value(@'*package*')); ecl_bds_bind(the_env, @'*readtable*', ecl_symbol_value(@'*readtable*')); ecl_bds_bind(the_env, @'*load-pathname*', not_a_filename? ECL_NIL : source); ecl_bds_bind(the_env, @'*load-truename*', not_a_filename? ECL_NIL : (filename = cl_truename(filename))); if (!Null(function)) { ok = funcall(5, function, filename, verbose, print, external_format); } else { #if 0 /* defined(ENABLE_DLOPEN) && !defined(ECL_MS_WINDOWS_HOST)*/ /* * DISABLED BECAUSE OF SECURITY ISSUES! * In systems where we can do this, we try to load the file * as a binary. When it fails, we will revert to source * loading below. Is this safe? Well, it depends on whether * your op.sys. checks integrity of binary exectables or * just loads _anything_. */ if (not_a_filename) { ok = ECL_T; } else { ok = si_load_binary(filename, verbose, print); } if (!Null(ok)) #endif ok = si_load_source(filename, verbose, print, external_format); } ecl_bds_unwind_n(the_env, 4); if (!Null(ok)) FEerror("LOAD: Could not load file ~S (Error: ~S)", 2, filename, ok); if (print != ECL_NIL) { cl_format(3, ECL_T, make_constant_base_string("~&;;; Loading ~s~%"), filename); } @(return filename) @) ecl-16.1.2/src/c/macros.d000066400000000000000000000144631266352375300150320ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* macros.c -- Macros. */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #include /******************************* ------- ******************************/ /* * The are two kinds of lisp environments. One of them is by the interpreter * when executing bytecodes and it contains local variable and function * definitions. * * The other environment is shared by the bytecodes compiler and by the C * compiler and it contains information for the compiler, including local * variable definitions, and local function and macro definitions. The * structure is as follows: * * env -> ( var-list . fun-list ) * fun-list -> ( { definition | atomic-marker }* ) * definition -> ( macro-name SI::MACRO { extra-data }* ) * | ( function-name FUNCTION { extra-data }* ) * | ( a-symbol anything { extra-data }* ) * atomic-marker -> CB | LB * * The main difference between the bytecode and C compilers is on the extra * information. On the other hand, both environments are similar enough that * the functions MACROEXPAND-1, MACROEXPAND and MACRO-FUNCTION can find the * required information. */ static cl_object search_symbol_macro(cl_object name, cl_object env) { for (env = CAR(env); env != ECL_NIL; env = CDR(env)) { cl_object record = CAR(env); if (CONSP(record) && CAR(record) == name) { if (CADR(record) == @'si::symbol-macro') return CADDR(record); return ECL_NIL; } } return si_get_sysprop(name, @'si::symbol-macro'); } static cl_object search_macro_function(cl_object name, cl_object env) { int type = ecl_symbol_type(name); if (env != ECL_NIL) { /* When the environment has been produced by the compiler, there might be atoms/symbols signalling closure and block boundaries. */ while (!Null(env = CDR(env))) { cl_object record = CAR(env); if (CONSP(record) && CAR(record) == name) { cl_object tag = CADR(record); if (tag == @'si::macro') return CADDR(record); if (tag == @'function') return ECL_NIL; break; } } } if (type & ecl_stp_macro) { return ECL_SYM_FUN(name); } else { return ECL_NIL; } } @(defun macro_function (sym &optional env) @ @(return (search_macro_function(sym, env))) @) /* Analyze a form and expand it once if it is a macro form. VALUES(0) contains either the expansion or the original form. VALUES(1) is true when there was a macroexpansion. */ @(defun macroexpand_1 (form &optional (env ECL_NIL)) cl_object exp_fun = ECL_NIL; @ if (ECL_ATOM(form)) { if (ECL_SYMBOLP(form)) exp_fun = search_symbol_macro(form, env); } else { cl_object head = CAR(form); if (ECL_SYMBOLP(head)) exp_fun = search_macro_function(head, env); } if (!Null(exp_fun)) { cl_object hook = ecl_symbol_value(@'*macroexpand-hook*'); if (hook == @'funcall') form = _ecl_funcall3(exp_fun, form, env); else form = _ecl_funcall4(hook, exp_fun, form, env); } @(return form exp_fun) @) /* Expands a form as many times as possible and returns the finally expanded form. */ @(defun macroexpand (form &optional env) cl_object done, old_form; @ done = ECL_NIL; do { form = cl_macroexpand_1(2, old_form = form, env); if (ecl_nth_value(the_env, 1) == ECL_NIL) { break; } else if (old_form == form) { FEerror("Infinite loop when expanding macro form ~A", 1, old_form); } else { done = ECL_T; } } while (1); @(return form done) @) static cl_object or_macro(cl_object whole, cl_object env) { cl_object output = ECL_NIL; whole = CDR(whole); if (Null(whole)) /* (OR) => NIL */ @(return ECL_NIL); while (!Null(CDR(whole))) { output = CONS(CONS(CAR(whole), ECL_NIL), output); whole = CDR(whole); } if (Null(output)) /* (OR form1) => form1 */ @(return CAR(whole)); /* (OR form1 ... formn forml) => (COND (form1) ... (formn) (t forml)) */ output = CONS(cl_list(2, ECL_T, CAR(whole)), output); @(return CONS(@'cond', cl_nreverse(output))) } static cl_object expand_and(cl_object whole) { if (Null(whole)) return ECL_T; if (Null(CDR(whole))) return CAR(whole); return cl_list(3, @'if', CAR(whole), expand_and(CDR(whole))); } static cl_object and_macro(cl_object whole, cl_object env) { @(return expand_and(CDR(whole))) } static cl_object when_macro(cl_object whole, cl_object env) { cl_object args = CDR(whole); if (ecl_unlikely(ecl_endp(args))) FEprogram_error_noreturn("Syntax error: ~S.", 1, whole); return cl_list(3, @'if', CAR(args), CONS(@'progn', CDR(args))); } void init_macros(void) { ECL_SET(@'*macroexpand-hook*', @'funcall'); ecl_def_c_macro(@'or', or_macro, 2); ecl_def_c_macro(@'and', and_macro, 2); ecl_def_c_macro(@'when', when_macro, 2); } ecl-16.1.2/src/c/main.d000077500000000000000000001004571266352375300144740ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* main.c -- */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ /******************************** IMPORTS *****************************/ #include #include #if defined(ECL_MS_WINDOWS_HOST) # include # include # define MAXPATHLEN 512 #endif #ifndef MAXPATHLEN # ifdef PATH_MAX # define MAXPATHLEN PATH_MAX # else # define NO_PATH_MAX # include # endif #endif #ifdef ECL_USE_MPROTECT # include # ifndef MAP_FAILED # define MAP_FAILED -1 # endif #endif #include #include #include #include #include #include #include "ecl_features.h" #include "iso_latin_names.h" /******************************* EXPORTS ******************************/ #if !defined(ECL_THREADS) cl_env_ptr cl_env_p = NULL; #elif defined(WITH___THREAD) __thread cl_env_ptr cl_env_p = NULL; #endif const char *ecl_self; /************************ GLOBAL INITIALIZATION ***********************/ /* HEAP */ #if ECL_FIXNUM_BITS <= 32 /* 1GB */ #define HEAP_SIZE_DEFAULT 1073741824L #else /* 4GB */ #define HEAP_SIZE_DEFAULT 4294967296L #endif static int ARGC; static char **ARGV; cl_fixnum ecl_option_values[ECL_OPT_LIMIT+1] = { #ifdef GBC_BOEHM_GENGC 1, /* ECL_OPT_INCREMENTAL_GC */ #else 0, /* ECL_OPT_INCREMENTAL_GC */ #endif 1, /* ECL_OPT_TRAP_SIGSEGV */ 1, /* ECL_OPT_TRAP_SIGFPE */ 1, /* ECL_OPT_TRAP_SIGINT */ 1, /* ECL_OPT_TRAP_SIGILL */ 1, /* ECL_OPT_TRAP_SIGBUS */ 1, /* ECL_OPT_TRAP_SIGPIPE */ 1, /* ECL_OPT_TRAP_SIGCHLD */ 1, /* ECL_OPT_TRAP_INTERRUPT_SIGNAL */ 1, /* ECL_OPT_SIGNAL_HANDLING_THREAD */ 16, /* ECL_OPT_SIGNAL_QUEUE_SIZE */ 0, /* ECL_OPT_BOOTED */ 8192, /* ECL_OPT_BIND_STACK_SIZE */ 1024, /* ECL_OPT_BIND_STACK_SAFETY_AREA */ 2048, /* ECL_OPT_FRAME_STACK_SIZE */ 128, /* ECL_OPT_FRAME_STACK_SAFETY_AREA */ 32768, /* ECL_OPT_LISP_STACK_SIZE */ 128, /* ECL_OPT_LISP_STACK_SAFETY_AREA */ 128*sizeof(cl_index)*1024, /* ECL_OPT_C_STACK_SIZE */ 4*sizeof(cl_index)*1024, /* ECL_OPT_C_STACK_SAFETY_AREA */ 1, /* ECL_OPT_SIGALTSTACK_SIZE */ HEAP_SIZE_DEFAULT, /* ECL_OPT_HEAP_SIZE */ 1024*1024, /* ECL_OPT_HEAP_SAFETY_AREA */ 0, /* ECL_OPT_THREAD_INTERRUPT_SIGNAL */ 1, /* ECL_OPT_SET_GMP_MEMORY_FUNCTIONS */ 1, /* ECL_OPT_USE_SETMODE_ON_FILES */ 0}; #if !defined(GBC_BOEHM) static char stdin_buf[BUFSIZ]; static char stdout_buf[BUFSIZ]; #endif cl_fixnum ecl_get_option(int option) { if (option >= ECL_OPT_LIMIT || option < 0) { FEerror("Invalid boot option ~D", 1, ecl_make_fixnum(option)); } return ecl_option_values[option]; } void ecl_set_option(int option, cl_fixnum value) { if (option > ECL_OPT_LIMIT || option < 0) { FEerror("Invalid boot option ~D", 1, ecl_make_fixnum(option)); } else { if (option < ECL_OPT_BOOTED && ecl_option_values[ECL_OPT_BOOTED]) { FEerror("Cannot change option ~D while ECL is running", 1, ecl_make_fixnum(option)); } ecl_option_values[option] = value; } } void ecl_init_env(cl_env_ptr env) { env->c_env = NULL; #if defined(ECL_THREADS) env->cleanup = 0; #else env->own_process = ECL_NIL; #endif env->string_pool = ECL_NIL; env->stack = NULL; env->stack_top = NULL; env->stack_limit = NULL; env->stack_size = 0; ecl_stack_set_size(env, ecl_option_values[ECL_OPT_LISP_STACK_SIZE]); #if !defined(ECL_CMU_FORMAT) env->fmt_aux_stream = ecl_make_string_output_stream(64, 1); #endif #ifdef HAVE_LIBFFI env->ffi_args_limit = 0; env->ffi_types = 0; env->ffi_values = 0; env->ffi_values_ptrs = 0; #endif #ifdef ECL_DYNAMIC_FFI env->fficall = ecl_alloc(sizeof(struct ecl_fficall)); ((struct ecl_fficall*)env->fficall)->registers = 0; #endif env->method_cache = ecl_make_cache(64, 4096); env->slot_cache = ecl_make_cache(3, 4096); env->pending_interrupt = ECL_NIL; { int size = ecl_option_values[ECL_OPT_SIGNAL_QUEUE_SIZE]; env->signal_queue = cl_make_list(1, ecl_make_fixnum(size)); } init_stacks(env); { int i; for (i = 0; i < 3; i++) { cl_object x = ecl_alloc_object(t_bignum); _ecl_big_init2(x, ECL_BIG_REGISTER_SIZE); env->big_register[i] = x; } } env->trap_fpe_bits = 0; env->packages_to_be_created = ECL_NIL; env->packages_to_be_created_p = ECL_NIL; env->fault_address = env; } void _ecl_dealloc_env(cl_env_ptr env) { /* * Environment cleanup. This is only required when the environment is * allocated using mmap or some other method. We could do more, cleaning * up stacks, etc, but we actually do not do it because that would need * a lisp environment set up -- the allocator assumes one -- and we * may have already cleaned up the value of ecl_process_env() */ #if defined(ECL_USE_MPROTECT) if (munmap(env, sizeof(*env))) ecl_internal_error("Unable to deallocate environment structure."); #else # if defined(ECL_USE_GUARD_PAGE) if (VirtualFree(env, sizeof(*env), MEM_RELEASE)) ecl_internal_error("Unable to deallocate environment structure."); # endif #endif } cl_env_ptr _ecl_alloc_env(cl_env_ptr parent) { /* * Allocates the lisp environment for a thread. Depending on which * mechanism we use for detecting delayed signals, we may allocate * the environment using mmap or the garbage collector. */ cl_env_ptr output; #if defined(ECL_USE_MPROTECT) output = mmap(0, sizeof(*output), PROT_READ | PROT_WRITE, MAP_ANON | MAP_PRIVATE, -1, 0); if (output == MAP_FAILED) ecl_internal_error("Unable to allocate environment structure."); #else # if defined(ECL_USE_GUARD_PAGE) output = VirtualAlloc(0, sizeof(*output), MEM_COMMIT, PAGE_READWRITE); if (output == NULL) ecl_internal_error("Unable to allocate environment structure."); # else static struct cl_env_struct first_env; if (!ecl_option_values[ECL_OPT_BOOTED]) { /* We have not set up any environment. Hence, we cannot call ecl_alloc() * because it will need to stop interrupts and currently we rely on * the environment for that */ output = ecl_alloc_unprotected(sizeof(*output)); } else { output = ecl_alloc(sizeof(*output)); } # endif #endif { size_t bytes = cl_core.default_sigmask_bytes; if (bytes == 0) { output->default_sigmask = 0; } else if (parent) { output->default_sigmask = ecl_alloc_atomic(bytes); memcpy(output->default_sigmask, parent->default_sigmask, bytes); } else { output->default_sigmask = cl_core.default_sigmask; } } /* * An uninitialized environment _always_ disables interrupts. They * are activated later on by the thread entry point or init_unixint(). */ output->disable_interrupts = 1; output->pending_interrupt = ECL_NIL; output->signal_queue_spinlock = ECL_NIL; return output; } void cl_shutdown(void) { if (ecl_option_values[ECL_OPT_BOOTED] > 0) { cl_object l = ecl_symbol_value(@'si::*exit-hooks*'); cl_object form = cl_list(2, @'funcall', ECL_NIL); while (CONSP(l)) { ecl_elt_set(form, 1, ECL_CONS_CAR(l)); si_safe_eval(3, form, ECL_NIL, OBJNULL); l = CDR(l); ECL_SET(@'si::*exit-hooks*', l); } #ifdef ENABLE_DLOPEN ecl_library_close_all(); #endif #ifdef TCP ecl_tcp_close_all(); #endif } ecl_set_option(ECL_OPT_BOOTED, -1); } ecl_def_ct_single_float(default_rehash_size,1.5f,static,const); ecl_def_ct_single_float(default_rehash_threshold,0.75f,static,const); ecl_def_ct_base_string(str_common_lisp,"COMMON-LISP",11,static,const); ecl_def_ct_base_string(str_common_lisp_user,"COMMON-LISP-USER",16,static,const); ecl_def_ct_base_string(str_cl,"CL",2,static,const); ecl_def_ct_base_string(str_cl_user,"CL-USER",7,static,const); ecl_def_ct_base_string(str_LISP,"LISP",4,static,const); ecl_def_ct_base_string(str_c,"C",1,static,const); ecl_def_ct_base_string(str_compiler,"COMPILER",8,static,const); ecl_def_ct_base_string(str_ffi,"FFI",3,static,const); ecl_def_ct_base_string(str_user,"USER",4,static,const); ecl_def_ct_base_string(str_keyword,"KEYWORD",7,static,const); ecl_def_ct_base_string(str_si,"SI",2,static,const); ecl_def_ct_base_string(str_sys,"SYS",3,static,const); ecl_def_ct_base_string(str_system,"SYSTEM",6,static,const); ecl_def_ct_base_string(str_ext,"EXT",3,static,const); ecl_def_ct_base_string(str_clos,"CLOS",4,static,const); ecl_def_ct_base_string(str_mop,"MOP",3,static,const); ecl_def_ct_base_string(str_mp,"MP",2,static,const); ecl_def_ct_base_string(str_multiprocessing,"MULTIPROCESSING",15,static,const); #ifdef ECL_CLOS_STREAMS ecl_def_ct_base_string(str_gray,"GRAY",4,static,const); #endif ecl_def_ct_base_string(str_star_dot_star,"*.*",3,static,const); ecl_def_ct_base_string(str_rel_star_dot_star,"./*.*",5,static,const); ecl_def_ct_base_string(str_empty,"",0,static,const); ecl_def_ct_base_string(str_G,"G",1,static,const); ecl_def_ct_base_string(str_T,"T",1,static,const); #ifdef ENABLE_DLOPEN ecl_def_ct_base_string(str_fas,"fas",3,static,const); ecl_def_ct_base_string(str_fasl,"fasl",4,static,const); #endif ecl_def_ct_base_string(str_fasb,"fasb",4,static,const); ecl_def_ct_base_string(str_fasc,"fasc",4,static,const); ecl_def_ct_base_string(str_FASB,"FASB",4,static,const); ecl_def_ct_base_string(str_FASC,"FASC",4,static,const); ecl_def_ct_base_string(str_lsp,"lsp",3,static,const); ecl_def_ct_base_string(str_LSP,"LSP",3,static,const); ecl_def_ct_base_string(str_lisp,"lisp",4,static,const); ecl_def_ct_base_string(str_NIL,"NIL",3,static,const); ecl_def_ct_base_string(str_slash,"/",1,static,const); ecl_def_ct_single_float(flt_zero,0,static,const); ecl_def_ct_single_float(flt_zero_neg,-0.0,static,const); ecl_def_ct_double_float(dbl_zero,0,static,const); ecl_def_ct_double_float(dbl_zero_neg,-0.0,static,const); #ifdef ECL_LONG_FLOAT ecl_def_ct_long_float(ldbl_zero,0,static,const); ecl_def_ct_long_float(ldbl_zero_neg,-0.0l,static,const); #endif ecl_def_ct_ratio(plus_half,ecl_make_fixnum(1),ecl_make_fixnum(2),static,const); ecl_def_ct_ratio(minus_half,ecl_make_fixnum(-1),ecl_make_fixnum(2),static,const); ecl_def_ct_single_float(flt_one,1,static,const); ecl_def_ct_single_float(flt_one_neg,-1,static,const); ecl_def_ct_single_float(flt_two,2,static,const); ecl_def_ct_complex(flt_imag_unit,&flt_zero_data,&flt_one_data,static,const); ecl_def_ct_complex(flt_imag_unit_neg,&flt_zero_data,&flt_one_neg_data,static,const); ecl_def_ct_complex(flt_imag_two,&flt_zero_data,&flt_two_data,static,const); struct cl_core_struct cl_core = { ECL_NIL, /* packages */ ECL_NIL, /* lisp_package */ ECL_NIL, /* user_package */ ECL_NIL, /* keyword_package */ ECL_NIL, /* system_package */ ECL_NIL, /* ext_package */ ECL_NIL, /* clos_package */ # ifdef ECL_CLOS_STREAMS ECL_NIL, /* gray_package */ # endif ECL_NIL, /* mp_package */ ECL_NIL, /* c_package */ ECL_NIL, /* ffi_package */ ECL_NIL, /* pathname_translations */ ECL_NIL, /* library_pathname */ ECL_NIL, /* terminal_io */ ECL_NIL, /* null_stream */ ECL_NIL, /* standard_input */ ECL_NIL, /* standard_output */ ECL_NIL, /* error_output */ ECL_NIL, /* standard_readtable */ ECL_NIL, /* dispatch_reader */ ECL_NIL, /* default_dispatch_macro */ ECL_NIL, /* char_names */ (cl_object)&str_empty_data, /* null_string */ (cl_object)&plus_half_data, /* plus_half */ (cl_object)&minus_half_data, /* minus_half */ (cl_object)&flt_imag_unit_data, /* imag_unit */ (cl_object)&flt_imag_unit_neg_data, /* minus_imag_unit */ (cl_object)&flt_imag_two_data, /* imag_two */ (cl_object)&flt_zero_data, /* singlefloat_zero */ (cl_object)&dbl_zero_data, /* doublefloat_zero */ (cl_object)&flt_zero_neg_data, /* singlefloat_minus_zero */ (cl_object)&dbl_zero_neg_data, /* doublefloat_minus_zero */ #ifdef ECL_LONG_FLOAT (cl_object)&ldbl_zero_data, /* longfloat_zero */ (cl_object)&ldbl_zero_neg_data, /* longfloat_minus_zero */ #endif (cl_object)&str_G_data, /* gensym_prefix */ (cl_object)&str_T_data, /* gentemp_prefix */ ecl_make_fixnum(0), /* gentemp_counter */ ECL_NIL, /* Jan1st1970UT */ ECL_NIL, /* system_properties */ ECL_NIL, /* setf_definition */ #ifdef ECL_THREADS ECL_NIL, /* processes */ ECL_NIL, /* processes_spinlock */ ECL_NIL, /* global_lock */ ECL_NIL, /* error_lock */ ECL_NIL, /* global_env_lock */ #endif /* LIBRARIES is an adjustable vector of objects. It behaves as a vector of weak pointers thanks to the magic in gbc.d/alloc_2.d */ ECL_NIL, /* libraries */ 0, /* max_heap_size */ ECL_NIL, /* bytes_consed */ ECL_NIL, /* gc_counter */ 0, /* gc_stats */ 0, /* path_max */ #ifdef GBC_BOEHM NULL, /* safety_region */ #endif NULL, /* default_sigmask */ 0, /* default_sigmask_bytes */ #ifdef ECL_THREADS 0, /* last_var_index */ ECL_NIL, /* reused_indices */ #endif (cl_object)&str_slash_data, /* slash */ ECL_NIL, /* compiler_dispatch */ (cl_object)&default_rehash_size_data, /* rehash_size */ (cl_object)&default_rehash_threshold_data, /* rehash_threshold */ ECL_NIL, /* external_processes */ ECL_NIL, /* external_processes_lock */ ECL_NIL /* known_signals */ }; #if !defined(ECL_MS_WINDOWS_HOST) #define maybe_fix_console_stream(strm) (void)0 #else static void maybe_fix_console_stream(cl_object stream) { DWORD cp = GetConsoleCP(); const char *encoding; cl_object external_format; int i; static const struct { int code; const char *name; } known_cp[] = { {874, "WINDOWS-CP874"}, {932, "WINDOWS-CP932"}, {936, "WINDOWS-CP936"}, {949, "WINDOWS-CP949"}, {950, "WINDOWS-CP950"}, {1200, "WINDOWS-CP1200"}, {1201, "WINDOWS-CP1201"}, {1250, "WINDOWS-CP1250"}, {1251, "WINDOWS-CP1251"}, {1252, "WINDOWS-CP1252"}, {1253, "WINDOWS-CP1253"}, {1254, "WINDOWS-CP1254"}, {1255, "WINDOWS-CP1255"}, {1256, "WINDOWS-CP1256"}, {1257, "WINDOWS-CP1257"}, {1258, "WINDOWS-CP1258"}, {65001, "UTF8"}, {0,"LATIN-1"} }; if (stream->stream.mode != ecl_smm_io_wcon) return; for (i = 0; known_cp[i].code && known_cp[i].code != cp; i++) {} external_format = cl_list(2, ecl_make_keyword(known_cp[i].name), @':crlf'); si_stream_external_format_set(stream, external_format); stream->stream.eof_char = 26; } #endif int cl_boot(int argc, char **argv) { cl_object aux; cl_object features; int i; cl_env_ptr env; i = ecl_option_values[ECL_OPT_BOOTED]; if (i) { if (i < 0) { /* We have called cl_shutdown and want to use ECL again. */ ecl_set_option(ECL_OPT_BOOTED, 1); } return 1; } /*ecl_set_option(ECL_OPT_SIGNAL_HANDLING_THREAD, 0);*/ #if !defined(GBC_BOEHM) setbuf(stdin, stdin_buf); setbuf(stdout, stdout_buf); #endif ARGC = argc; ARGV = argv; ecl_self = argv[0]; init_unixint(0); init_alloc(); GC_disable(); env = _ecl_alloc_env(0); #ifdef ECL_THREADS init_threads(env); #else cl_env_p = env; #endif /* * 1) Initialize symbols and packages */ ECL_NIL_SYMBOL->symbol.t = t_symbol; ECL_NIL_SYMBOL->symbol.dynamic = 0; ECL_NIL_SYMBOL->symbol.value = ECL_NIL; ECL_NIL_SYMBOL->symbol.name = str_NIL; ECL_NIL_SYMBOL->symbol.gfdef = ECL_NIL; ECL_NIL_SYMBOL->symbol.plist = ECL_NIL; ECL_NIL_SYMBOL->symbol.hpack = ECL_NIL; ECL_NIL_SYMBOL->symbol.stype = ecl_stp_constant; #ifdef ECL_THREADS ECL_NIL_SYMBOL->symbol.binding = ECL_MISSING_SPECIAL_BINDING; #endif cl_num_symbols_in_core=1; ECL_T->symbol.t = (short)t_symbol; ECL_T->symbol.dynamic = 0; ECL_T->symbol.value = ECL_T; ECL_T->symbol.name = str_T; ECL_T->symbol.gfdef = ECL_NIL; ECL_T->symbol.plist = ECL_NIL; ECL_T->symbol.hpack = ECL_NIL; ECL_T->symbol.stype = ecl_stp_constant; #ifdef ECL_THREADS ECL_T->symbol.binding = ECL_MISSING_SPECIAL_BINDING; #endif cl_num_symbols_in_core=2; #ifdef NO_PATH_MAX cl_core.path_max = sysconf(_PC_PATH_MAX); #else cl_core.path_max = MAXPATHLEN; #endif env->packages_to_be_created = ECL_NIL; cl_core.lisp_package = ecl_make_package(str_common_lisp, cl_list(2, str_cl, str_LISP), ECL_NIL); cl_core.user_package = ecl_make_package(str_common_lisp_user, cl_list(2, str_cl_user, str_user), ecl_list1(cl_core.lisp_package)); cl_core.keyword_package = ecl_make_package(str_keyword, ECL_NIL, ECL_NIL); cl_core.ext_package = ecl_make_package(str_ext, ECL_NIL, ecl_list1(cl_core.lisp_package)); cl_core.system_package = ecl_make_package(str_si, cl_list(2,str_system,str_sys), cl_list(2,cl_core.ext_package, cl_core.lisp_package)); cl_core.c_package = ecl_make_package(str_c, ecl_list1(str_compiler), ecl_list1(cl_core.lisp_package)); cl_core.clos_package = ecl_make_package(str_clos, ecl_list1(str_mop), ecl_list1(cl_core.lisp_package)); cl_core.mp_package = ecl_make_package(str_mp, ecl_list1(str_multiprocessing), ecl_list1(cl_core.lisp_package)); #ifdef ECL_CLOS_STREAMS cl_core.gray_package = ecl_make_package(str_gray, ECL_NIL, CONS(cl_core.lisp_package, ECL_NIL)); #endif cl_core.ffi_package = ecl_make_package(str_ffi, ECL_NIL, cl_list(3,cl_core.lisp_package, cl_core.system_package, cl_core.ext_package)); ECL_NIL_SYMBOL->symbol.hpack = cl_core.lisp_package; cl_import2(ECL_NIL, cl_core.lisp_package); cl_export2(ECL_NIL, cl_core.lisp_package); ECL_T->symbol.hpack = cl_core.lisp_package; cl_import2(ECL_T, cl_core.lisp_package); cl_export2(ECL_T, cl_core.lisp_package); /* At exit, clean up */ atexit(cl_shutdown); /* These must come _after_ the packages and NIL/T have been created */ init_all_symbols(); /* * Initialize the per-thread data. * This cannot come later, because some routines need the * frame stack immediately (for instance SI:PATHNAME-TRANSLATIONS). */ init_big(); ecl_init_env(env); ecl_cs_set_org(env); #if !defined(GBC_BOEHM) /* We need this because a lot of stuff is to be created */ init_GC(); #endif GC_enable(); /* * Initialize default pathnames */ #if 1 ECL_SET(@'*default-pathname-defaults*', si_getcwd(0)); #else ECL_SET(@'*default-pathname-defaults*', ecl_make_pathname(ECL_NIL, ECL_NIL, ECL_NIL, ECL_NIL, ECL_NIL, ECL_NIL, @':local')); #endif #ifdef ECL_THREADS env->bindings_array = si_make_vector(ECL_T, ecl_make_fixnum(1024), ECL_NIL, ECL_NIL, ECL_NIL, ECL_NIL); si_fill_array_with_elt(env->bindings_array, ECL_NO_TL_BINDING, ecl_make_fixnum(0), ECL_NIL); env->thread_local_bindings_size = env->bindings_array->vector.dim; env->thread_local_bindings = env->bindings_array->vector.self.t; ECL_SET(@'mp::*current-process*', env->own_process); #endif /* * Load character names. The following hash table is a map * from names to character codes and viceversa. Note that we * need EQUALP because it has to be case insensitive. */ cl_core.char_names = aux = cl__make_hash_table(@'equalp', ecl_make_fixnum(128), /* size */ cl_core.rehash_size, cl_core.rehash_threshold); for (i = 0; char_names[i].elt.self; i++) { cl_object name = (cl_object)(char_names + i); cl_object code = ecl_make_fixnum(i); ecl_sethash(name, aux, code); ecl_sethash(code, aux, name); } for (i = 0; i < extra_char_names_size; i++) { cl_object name = (cl_object)(extra_char_names + i); cl_object code = ecl_make_fixnum(extra_char_codes[i]); ecl_sethash(name, aux, code); } /* * Initialize logical pathname translations. This must come after * the character database has been filled. */ @si::pathname-translations(2,str_sys, ecl_list1(cl_list(2,str_star_dot_star, str_rel_star_dot_star))); /* * Initialize constants (strings, numbers and time). */ cl_core.system_properties = cl__make_hash_table(@'equal', ecl_make_fixnum(1024), /* size */ cl_core.rehash_size, cl_core.rehash_threshold); cl_core.setf_definitions = cl__make_hash_table(@'eq', ecl_make_fixnum(256), /* size */ cl_core.rehash_size, cl_core.rehash_threshold); ECL_SET(@'*random-state*', ecl_make_random_state(ECL_T)); ECL_SET(@'ffi::c-int-max', ecl_make_integer(INT_MAX)); ECL_SET(@'ffi::c-int-min', ecl_make_integer(INT_MIN)); ECL_SET(@'ffi::c-long-max', ecl_make_integer(LONG_MAX)); ECL_SET(@'ffi::c-long-min', ecl_make_integer(LONG_MIN)); ECL_SET(@'ffi::c-uint-max', ecl_make_unsigned_integer(UINT_MAX)); ECL_SET(@'ffi::c-ulong-max', ecl_make_unsigned_integer(ULONG_MAX)); #ifdef ecl_long_long_t ECL_SET(@'ffi::c-long-long-max', ecl_make_long_long(LLONG_MAX)); ECL_SET(@'ffi::c-ulong-long-max', ecl_make_ulong_long(ULLONG_MAX)); #endif init_unixtime(); /* * Initialize I/O subsystem. */ init_file(); init_read(); ECL_SET(@'*print-case*', @':upcase'); /* * Set up hooks for LOAD, errors and macros. */ #ifdef ECL_THREADS ECL_SET(@'mp::+load-compile-lock+', ecl_make_lock(@'mp::+load-compile-lock+', 1)); #endif aux = cl_list( #ifdef ENABLE_DLOPEN 11, CONS(str_fas, @'si::load-binary'), CONS(str_fasl, @'si::load-binary'), CONS(str_fasb, @'si::load-binary'), CONS(str_FASB, @'si::load-binary'), #else 7, #endif CONS(str_lsp, @'si::load-source'), CONS(str_lisp, @'si::load-source'), CONS(str_LSP, @'si::load-source'), CONS(str_LISP, @'si::load-source'), CONS(str_fasc, @'si::load-bytecodes'), CONS(str_FASC, @'si::load-bytecodes'), CONS(ECL_NIL, @'si::load-source')); ECL_SET(@'ext::*load-hooks*', aux); init_error(); init_macros(); init_compiler(); /* * Set up infrastructure for CLOS. */ ECL_SET(@'si::*class-name-hash-table*', cl__make_hash_table(@'eq', ecl_make_fixnum(1024), /* size */ cl_core.rehash_size, cl_core.rehash_threshold)); /* * Features. */ ECL_SET(@'LAMBDA-LIST-KEYWORDS', cl_list(8, @'&optional', @'&rest', @'&key', @'&allow-other-keys', @'&aux', @'&whole', @'&environment', @'&body')); for (i = 0, features = ECL_NIL; feature_names[i].elt.self; i++) { int flag; cl_object name = (cl_object)(feature_names + i); cl_object key = ecl_intern(name, cl_core.keyword_package, &flag); features = CONS(key, features); } ECL_SET(@'*features*', features); ECL_SET(@'*package*', cl_core.lisp_package); /* This has to come before init_LSP/CLOS, because we need * ecl_clear_compiler_properties() to work in init_CLOS(). */ ecl_set_option(ECL_OPT_BOOTED, 1); ecl_init_module(OBJNULL,init_lib_LSP); if (cl_fboundp(@'ext::make-encoding') != ECL_NIL) { maybe_fix_console_stream(cl_core.standard_input); maybe_fix_console_stream(cl_core.standard_output); maybe_fix_console_stream(cl_core.error_output); } /* Jump to top level */ ECL_SET(@'*package*', cl_core.user_package); init_unixint(1); return 1; } /************************* ENVIRONMENT ROUTINES ***********************/ @(defun ext::quit (&optional (code ecl_make_fixnum(0)) (kill_all_threads ECL_T)) @ { #ifdef ECL_THREADS if (!Null(kill_all_threads)) { cl_object this = the_env->own_process; cl_object p, all_threads = mp_all_processes(); for (p = all_threads; !Null(p); p = ECL_CONS_CDR(p)) { cl_object process = ECL_CONS_CAR(p); if (process != this) mp_process_kill(process); } for (p = all_threads; !Null(p); p = ECL_CONS_CDR(p)) { cl_object process = ECL_CONS_CAR(p); if (process != this) mp_process_join(process); } /* FIXME! We need to do this because of a problem in GC * When the thread exits, sometimes the dyld library gets * called, and if we call dlopen() at the same time we * cause ECL to hang */ ecl_musleep(1e-3, 1); } #endif ECL_SET(@'ext::*program-exit-code*', code); if (the_env->frs_org <= the_env->frs_top) ecl_unwind(the_env, the_env->frs_org); si_exit(1, code); } @) @(defun ext::exit (&optional (code ECL_SYM_VAL(ecl_process_env(),@'ext::*program-exit-code*'))) @ cl_shutdown(); exit(ECL_FIXNUMP(code)? ecl_fixnum(code) : 0); @) cl_object si_argc() { @(return ecl_make_fixnum(ARGC)) } cl_object si_argv(cl_object index) { if (ECL_FIXNUMP(index)) { cl_fixnum i = ecl_fixnum(index); if (i >= 0 && i < ARGC) @(return make_base_string_copy(ARGV[i])); } FEerror("Illegal argument index: ~S.", 1, index); } cl_object si_getenv(cl_object var) { const char *value; /* Strings have to be null terminated base strings */ var = si_copy_to_simple_base_string(var); value = getenv((char*)var->base_string.self); @(return ((value == NULL)? ECL_NIL : make_base_string_copy(value))) } #if defined(HAVE_SETENV) || defined(HAVE_PUTENV) cl_object si_setenv(cl_object var, cl_object value) { const cl_env_ptr the_env = ecl_process_env(); cl_fixnum ret_val; /* Strings have to be null terminated base strings */ var = si_copy_to_simple_base_string(var); if (value == ECL_NIL) { #ifdef HAVE_SETENV /* Remove the variable when setting to nil, so that * (si:setenv "foo" nil), then (si:getenv "foo) returns * the right thing. */ unsetenv((char*)var->base_string.self); #else #if defined(ECL_MS_WINDOWS_HOST) si_setenv(var, cl_core.null_string); #else putenv((char*)var->base_string.self); #endif #endif ret_val = 0; } else { #ifdef HAVE_SETENV value = si_copy_to_simple_base_string(value); ret_val = setenv((char*)var->base_string.self, (char*)value->base_string.self, 1); #else value = cl_format(4, ECL_NIL, make_constant_base_string("~A=~A"), var, value); value = si_copy_to_simple_base_string(value); putenv((char*)value->base_string.self); #endif } if (ret_val == -1) CEerror(ECL_T, "SI:SETENV failed: insufficient space in environment.", 1, ECL_NIL); ecl_return1(the_env, value); } #endif cl_object si_environ(void) { cl_object output = ECL_NIL; #ifdef HAVE_ENVIRON char **p; extern char **environ; for (p = environ; *p; p++) { output = CONS(make_constant_base_string(*p), output); } output = cl_nreverse(output); #else # if defined(ECL_MS_WINDOWS_HOST) LPTCH p; for (p = GetEnvironmentStrings(); *p; ) { output = CONS(make_constant_base_string(p), output); do { (void)0; } while (*(p++)); } output = cl_nreverse(output); # endif #endif /* HAVE_ENVIRON */ @(return output) } cl_object si_pointer(cl_object x) { const cl_env_ptr the_env = ecl_process_env(); ecl_return1(the_env, ecl_make_unsigned_integer((cl_index)x)); } #if defined(ECL_MS_WINDOWS_HOST) void ecl_get_commandline_args(int* argc, char*** argv) { LPWSTR *wArgs; int i; if (argc == NULL || argv == NULL) return; wArgs = CommandLineToArgvW(GetCommandLineW(), argc); *argv = (char**)malloc(sizeof(char*)*(*argc)); for (i=0; i<*argc; i++) { int len = wcslen(wArgs[i]); (*argv)[i] = (char*)malloc(2*(len+1)); wcstombs((*argv)[i], wArgs[i], len+1); } LocalFree(wArgs); } #endif ecl-16.1.2/src/c/mapfun.d000066400000000000000000000164601266352375300150330ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* mapfun.c -- Mapping. */ /* Copyright (c) 1993, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #include #include #define PREPARE_MAP(env, list, cdrs_frame, cars_frame, narg) \ struct ecl_stack_frame frames_aux[2]; \ const cl_object cdrs_frame = (cl_object)frames_aux; \ const cl_object cars_frame = (cl_object)(frames_aux+1); \ ECL_STACK_FRAME_FROM_VA_LIST(env,cdrs_frame,list); \ ECL_STACK_FRAME_COPY(cars_frame, cdrs_frame); \ narg = cars_frame->frame.size; \ if (ecl_unlikely(narg == 0)) { \ FEprogram_error_noreturn("MAP*: Too few arguments", 0); \ } @(defun mapcar (fun &rest lists) cl_object res, *val = &res; @ { PREPARE_MAP(the_env, lists, cdrs_frame, cars_frame, narg); res = ECL_NIL; while (TRUE) { cl_index i; for (i = 0; i < narg; i++) { cl_object cdr = ECL_STACK_FRAME_REF(cdrs_frame, i); if (ecl_unlikely(!LISTP(cdr))) FEwrong_type_nth_arg(@[mapcar], i+2, cdr, @[list]); if (Null(cdr)) { ecl_stack_frame_close(cars_frame); ecl_stack_frame_close(cdrs_frame); @(return res) } ECL_STACK_FRAME_SET(cars_frame, i, ECL_CONS_CAR(cdr)); ECL_STACK_FRAME_SET(cdrs_frame, i, ECL_CONS_CDR(cdr)); } *val = ecl_list1(ecl_apply_from_stack_frame(cars_frame, fun)); val = &ECL_CONS_CDR(*val); } } @) @(defun maplist (fun &rest lists) cl_object res, *val = &res; @ { PREPARE_MAP(the_env, lists, cdrs_frame, cars_frame, narg); res = ECL_NIL; while (TRUE) { cl_index i; for (i = 0; i < narg; i++) { cl_object cdr = ECL_STACK_FRAME_REF(cdrs_frame, i); if (ecl_unlikely(!LISTP(cdr))) FEwrong_type_nth_arg(@[maplist], i+2, cdr, @[list]); if (Null(cdr)) { ecl_stack_frame_close(cars_frame); ecl_stack_frame_close(cdrs_frame); @(return res) } ECL_STACK_FRAME_SET(cars_frame, i, cdr); ECL_STACK_FRAME_SET(cdrs_frame, i, ECL_CONS_CDR(cdr)); } *val = ecl_list1(ecl_apply_from_stack_frame(cars_frame, fun)); val = &ECL_CONS_CDR(*val); } } @) @(defun mapc (fun &rest lists) cl_object onelist; @ { PREPARE_MAP(the_env, lists, cdrs_frame, cars_frame, narg); onelist = ECL_STACK_FRAME_REF(cdrs_frame, 0); while (TRUE) { cl_index i; for (i = 0; i < narg; i++) { cl_object cdr = ECL_STACK_FRAME_REF(cdrs_frame, i); if (ecl_unlikely(!LISTP(cdr))) FEwrong_type_nth_arg(@[mapc], i+2, cdr, @[list]); if (Null(cdr)) { ecl_stack_frame_close(cars_frame); ecl_stack_frame_close(cdrs_frame); @(return onelist) } ECL_STACK_FRAME_SET(cars_frame, i, ECL_CONS_CAR(cdr)); ECL_STACK_FRAME_SET(cdrs_frame, i, ECL_CONS_CDR(cdr)); } ecl_apply_from_stack_frame(cars_frame, fun); } } @) @(defun mapl (fun &rest lists) cl_object onelist; @ { PREPARE_MAP(the_env, lists, cdrs_frame, cars_frame, narg); onelist = ECL_STACK_FRAME_REF(cdrs_frame, 0); while (TRUE) { cl_index i; for (i = 0; i < narg; i++) { cl_object cdr = ECL_STACK_FRAME_REF(cdrs_frame, i); if (ecl_unlikely(!LISTP(cdr))) FEwrong_type_nth_arg(@[mapl], i+2, cdr, @[list]); if (Null(cdr)) { ecl_stack_frame_close(cars_frame); ecl_stack_frame_close(cdrs_frame); @(return onelist) } ECL_STACK_FRAME_SET(cars_frame, i, cdr); ECL_STACK_FRAME_SET(cdrs_frame, i, ECL_CONS_CDR(cdr)); } ecl_apply_from_stack_frame(cars_frame, fun); } } @) @(defun mapcan (fun &rest lists) cl_object res, *val = &res; @ { PREPARE_MAP(the_env, lists, cdrs_frame, cars_frame, narg); res = ECL_NIL; while (TRUE) { cl_index i; for (i = 0; i < narg; i++) { cl_object cdr = ECL_STACK_FRAME_REF(cdrs_frame, i); if (ecl_unlikely(!LISTP(cdr))) FEwrong_type_nth_arg(@[mapcan], i+2, cdr, @[list]); if (Null(cdr)) { ecl_stack_frame_close(cars_frame); ecl_stack_frame_close(cdrs_frame); @(return res) } ECL_STACK_FRAME_SET(cars_frame, i, ECL_CONS_CAR(cdr)); ECL_STACK_FRAME_SET(cdrs_frame, i, ECL_CONS_CDR(cdr)); } *val = ecl_apply_from_stack_frame(cars_frame, fun); while (CONSP(*val)) val = &ECL_CONS_CDR(*val); } } @) @(defun mapcon (fun &rest lists) cl_object res, *val = &res; @ { PREPARE_MAP(the_env, lists, cdrs_frame, cars_frame, narg); res = ECL_NIL; while (TRUE) { cl_index i; for (i = 0; i < narg; i++) { cl_object cdr = ECL_STACK_FRAME_REF(cdrs_frame, i); if (ecl_unlikely(!LISTP(cdr))) FEwrong_type_nth_arg(@[mapcon], i+2, cdr, @[list]); if (Null(cdr)) { ecl_stack_frame_close(cars_frame); ecl_stack_frame_close(cdrs_frame); @(return res) } ECL_STACK_FRAME_SET(cars_frame, i, cdr); ECL_STACK_FRAME_SET(cdrs_frame, i, ECL_CONS_CDR(cdr)); } *val = ecl_apply_from_stack_frame(cars_frame, fun); while (CONSP(*val)) val = &ECL_CONS_CDR(*val); } } @) ecl-16.1.2/src/c/multival.d000066400000000000000000000032041266352375300153720ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* multival.c -- Multiple Values. */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. ECoLisp is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #include @(defun values (&rest args) cl_object output; @ unlikely_if (narg > ECL_MULTIPLE_VALUES_LIMIT) FEerror("Too many values in VALUES",0); the_env->nvalues = narg; output = ECL_NIL; if (narg) { int i = 0; do { the_env->values[i] = ecl_va_arg(args); } while (++i < narg); output = the_env->values[0]; } return output; @) cl_object cl_values_list(cl_object list) { cl_env_ptr the_env = ecl_process_env(); int i; the_env->values[0] = ECL_NIL; for (i = 0; !Null(list); list=ECL_CONS_CDR(list)) { unlikely_if (!LISTP(list)) FEtype_error_list(list); unlikely_if (i == ECL_MULTIPLE_VALUES_LIMIT) FEerror("Too many values in VALUES-LIST",0); the_env->values[i++] = ECL_CONS_CAR(list); } the_env->nvalues = i; return the_env->values[0]; } ecl-16.1.2/src/c/newhash.h000066400000000000000000000142331266352375300152020ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /******************** * HASHING ROUTINES * ********************/ /* * SBCL's newest algorithm. Leads to few collisions, and it is faster. */ #if ECL_FIXNUM_BITS > 32 /* * 64 bit version */ #define GOLDEN_RATIO 0x9e3779b97f4a7c13L #define mix(a,b,c) \ { \ a=a-b; a=a-c; a=a^(c>>43); \ b=b-c; b=b-a; b=b^(a<<9); \ c=c-a; c=c-b; c=c^(b>>8); \ a=a-b; a=a-c; a=a^(c>>38); \ b=b-c; b=b-a; b=b^(a<<23); \ c=c-a; c=c-b; c=c^(b>>5); \ a=a-b; a=a-c; a=a^(c>>35); \ b=b-c; b=b-a; b=b^(a<<49); \ c=c-a; c=c-b; c=c^(b>>11); \ a=a-b; a=a-c; a=a^(c>>12); \ b=b-c; b=b-a; b=b^(a<<18); \ c=c-a; c=c-b; c=c^(b>>22); \ } #define extract_word(k) \ (k[0]+((cl_index)k[1]<<8)+((cl_index)k[2]<<16)+((cl_index)k[3]<<24)+ \ ((cl_index)k[4]<<32)+((cl_index)k[5]<<40)+((cl_index)k[6]<<48)+ \ ((cl_index)k[7]<<52)) static cl_index hash_string(cl_index initval, const unsigned char *k, cl_index length) { register cl_index a = GOLDEN_RATIO, b = GOLDEN_RATIO, c = initval; register cl_index len; for (len = length; len >= 24; len -= 24) { a += extract_word(k); k+=8; b += extract_word(k); k+=8; c += extract_word(k); k+=8; mix(a,b,c); } /*------------------------------------- handle the last 11 bytes */ c += length; switch(len) { /* all the case statements fall through */ case 23: c+=((cl_index)k[22]<<52); case 22: c+=((cl_index)k[21]<<48); case 21: c+=((cl_index)k[20]<<40); case 20: c+=((cl_index)k[19]<<32); case 19: c+=((cl_index)k[18]<<24); case 18: c+=((cl_index)k[17]<<16); case 17: c+=((cl_index)k[16]<<8); /* the first byte of c is reserved for the length */ case 16: b+=((cl_index)k[15]<<52); case 15: b+=((cl_index)k[14]<<48); case 14: b+=((cl_index)k[13]<<40); case 13: b+=((cl_index)k[12]<<32); case 12: b+=((cl_index)k[11]<<24); case 11: b+=((cl_index)k[10]<<16); case 10: b+=((cl_index)k[9]<<8); case 9 : b+=k[8]; case 8 : a+=((cl_index)k[7]<<52); case 7 : a+=((cl_index)k[6]<<48); case 6 : a+=((cl_index)k[5]<<40); case 5 : a+=((cl_index)k[4]<<32); case 4 : a+=((cl_index)k[3]<<24); case 3 : a+=((cl_index)k[2]<<16); case 2 : a+=((cl_index)k[1]<<8); case 1 : a+=k[0]; /* case 0: nothing left to add */ } mix(a,b,c); /*-------------------------------------------- report the result */ return c; } #else /* * 32 bit version */ #define GOLDEN_RATIO 0x9e3779b9L #define mix(a,b,c) \ { \ a -= b; a -= c; a ^= (c>>13); \ b -= c; b -= a; b ^= (a<<8); \ c -= a; c -= b; c ^= (b>>13); \ a -= b; a -= c; a ^= (c>>12); \ b -= c; b -= a; b ^= (a<<16); \ c -= a; c -= b; c ^= (b>>5); \ a -= b; a -= c; a ^= (c>>3); \ b -= c; b -= a; b ^= (a<<10); \ c -= a; c -= b; c ^= (b>>15); \ } #define extract_word(k) \ (k[0]+((cl_index)k[1]<<8)+((cl_index)k[2]<<16)+((cl_index)k[3]<<24)) static cl_index hash_string(cl_index initval, const unsigned char *k, cl_index length) { register cl_index a = GOLDEN_RATIO, b = GOLDEN_RATIO, c = initval; register cl_index len; for (len = length; len >= 12; len -= 12) { a += extract_word(k); k += 4; b += extract_word(k); k += 4; c += extract_word(k); k += 4; mix(a,b,c); } /*------------------------------------- handle the last 11 bytes */ c += length; switch(len) { /* all the case statements fall through */ case 11: c+=((cl_index)k[10]<<24); case 10: c+=((cl_index)k[9]<<16); case 9 : c+=((cl_index)k[8]<<8); /* the first byte of c is reserved for the length */ case 8 : b+=((cl_index)k[7]<<24); case 7 : b+=((cl_index)k[6]<<16); case 6 : b+=((cl_index)k[5]<<8); case 5 : b+=k[4]; case 4 : a+=((cl_index)k[3]<<24); case 3 : a+=((cl_index)k[2]<<16); case 2 : a+=((cl_index)k[1]<<8); case 1 : a+=k[0]; /* case 0: nothing left to add */ } mix(a,b,c); /*-------------------------------------------- report the result */ return c; } #endif static cl_index hash_word(cl_index c, cl_index w) { cl_index a = w + GOLDEN_RATIO, b = GOLDEN_RATIO; mix(a, b, c); return c; } static cl_index hash_base_string(const ecl_base_char *s, cl_index len, cl_index h) { cl_index a = GOLDEN_RATIO, b = GOLDEN_RATIO, i; for (i = len; i >= 3; i -= 3) { a += *s; s++; b += *s; s++; h += *s; s++; mix(a, b, h); } switch (i) { case 2: a += *s; s++; case 1: b += *s; default: h += len; } mix(a, b, h); return h; } #ifdef ECL_UNICODE static cl_index hash_full_string(const ecl_character *s, cl_index len, cl_index h) { cl_index a = GOLDEN_RATIO, b = GOLDEN_RATIO, i; for (i = len; i >= 3; i -= 3) { a += (*s); s++; b += (*s); s++; h += (*s); s++; mix(a, b, h); } switch (i) { case 2: a += (*s); s++; case 1: b += (*s); default: h += len; } mix(a, b, h); return h; } #endif ecl-16.1.2/src/c/num_arith.d000066400000000000000000000067301266352375300155320ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* num_arith.c -- Arithmetic operations */ /* Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #include #include cl_object ecl_integer_divide(cl_object x, cl_object y) { cl_type tx, ty; tx = ecl_t_of(x); ty = ecl_t_of(y); if (tx == t_fixnum) { if (ty == t_fixnum) { if (y == ecl_make_fixnum(0)) FEdivision_by_zero(x, y); return ecl_make_fixnum(ecl_fixnum(x) / ecl_fixnum(y)); } else if (ty == t_bignum) { return _ecl_fix_divided_by_big(ecl_fixnum(x), y); } else { FEwrong_type_nth_arg(@[round], 2, y, @[integer]); } } if (tx == t_bignum) { if (ty == t_bignum) { return _ecl_big_divided_by_big(x, y); } else if (ty == t_fixnum) { return _ecl_big_divided_by_fix(x, ecl_fixnum(y)); } else { FEwrong_type_nth_arg(@[round], 2, y, @[integer]); } } FEwrong_type_nth_arg(@[round], 1, x, @[integer]); } @(defun gcd (&rest nums) cl_object gcd; @ if (narg == 0) @(return ecl_make_fixnum(0)) /* INV: ecl_gcd() checks types */ gcd = ecl_va_arg(nums); if (narg == 1) { assert_type_integer(gcd); @(return (ecl_minusp(gcd) ? ecl_negate(gcd) : gcd)) } while (--narg) gcd = ecl_gcd(gcd, ecl_va_arg(nums)); @(return gcd) @) cl_object ecl_gcd(cl_object x, cl_object y) { ECL_WITH_TEMP_BIGNUM(x_big,1); ECL_WITH_TEMP_BIGNUM(y_big,1); switch (ecl_t_of(x)) { case t_fixnum: _ecl_big_set_fixnum(x_big, ecl_fixnum(x)); x = x_big; case t_bignum: break; default: FEwrong_type_nth_arg(@[gcd], 1, x, @[integer]); } switch (ecl_t_of(y)) { case t_fixnum: _ecl_big_set_fixnum(y_big, ecl_fixnum(y)); y = y_big; case t_bignum: break; default: FEwrong_type_nth_arg(@[gcd], 2, y, @[integer]); } return _ecl_big_gcd(x, y); } @(defun lcm (&rest nums) cl_object lcm; @ if (narg == 0) @(return ecl_make_fixnum(1)) /* INV: ecl_gcd() checks types. By placing `numi' before `lcm' in this call, we make sure that errors point to `numi' */ lcm = ecl_va_arg(nums); assert_type_integer(lcm); while (narg-- > 1) { cl_object numi = ecl_va_arg(nums); cl_object t = ecl_times(lcm, numi); cl_object g = ecl_gcd(numi, lcm); if (g != ecl_make_fixnum(0)) lcm = ecl_divide(t, g); } @(return (ecl_minusp(lcm) ? ecl_negate(lcm) : lcm)) @) ecl-16.1.2/src/c/num_co.d000066400000000000000000000327201266352375300150220ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* num_co.c -- Operations on floating-point numbers. */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ /* IMPLEMENTATION-DEPENDENT This file contains those functions that know the representation of floating-point numbers. */ #define ECL_INCLUDE_MATH_H #include #include #ifndef HAVE_ISOC99 # define floorf floor # define ceilf ceil # define fabsf fabs # define frexpf frexp # define ldexpf ldexp # define cosf cos # define coshf cosh # define expf exp # define logf log # define sinf sin # define sqrtf sqrt # define tanf tan # define tanhf tanh #endif #include /* Coerce X to single-float if one arg, otherwise coerce to same float type as second arg */ @(defun float (x &optional (y OBJNULL)) cl_type ty, tx; @ if (y != OBJNULL) { ty = ecl_t_of(y); } else { ty = t_singlefloat; } switch (tx = ecl_t_of(x)) { case t_singlefloat: case t_doublefloat: #ifdef ECL_LONG_FLOAT case t_longfloat: #endif if (y == OBJNULL || ty == tx) break; case t_fixnum: case t_bignum: case t_ratio: switch (ty) { case t_singlefloat: x = ecl_make_single_float(ecl_to_double(x)); break; case t_doublefloat: x = ecl_make_double_float(ecl_to_double(x)); break; #ifdef ECL_LONG_FLOAT case t_longfloat: x = ecl_make_long_float(ecl_to_long_double(x)); break; #endif default: FEwrong_type_nth_arg(@[float],2,y,@[float]); } break; default: FEwrong_type_nth_arg(@[float],1,x,@[real]); } @(return x) @) cl_object cl_numerator(cl_object x) { switch (ecl_t_of(x)) { case t_ratio: x = x->ratio.num; break; case t_fixnum: case t_bignum: break; default: FEwrong_type_nth_arg(@[numerator],1,x,@[rational]); } @(return x) } cl_object cl_denominator(cl_object x) { switch (ecl_t_of(x)) { case t_ratio: x = x->ratio.den; break; case t_fixnum: case t_bignum: x = ecl_make_fixnum(1); break; default: FEwrong_type_nth_arg(@[numerator],1,x,@[rational]); } @(return x) } cl_object cl_mod(cl_object x, cl_object y) { const cl_env_ptr the_env = ecl_process_env(); /* INV: #'floor always outputs two values */ @floor(2, x, y); ecl_return1(the_env, the_env->values[1]); } cl_object cl_rem(cl_object x, cl_object y) { const cl_env_ptr the_env = ecl_process_env(); @truncate(2, x, y); ecl_return1(the_env, the_env->values[1]); } cl_object cl_decode_float(cl_object x) { const cl_env_ptr the_env = ecl_process_env(); int e, s; cl_type tx = ecl_t_of(x); float f; switch (tx) { case t_singlefloat: { f = ecl_single_float(x); if (f >= 0.0) { s = 1; } else { f = -f; s = 0; } f = frexpf(f, &e); x = ecl_make_single_float(f); break; } case t_doublefloat: { double d = ecl_double_float(x); if (d >= 0.0) { s = 1; } else { d = -d; s = 0; } d = frexp(d, &e); x = ecl_make_double_float(d); break; } #ifdef ECL_LONG_FLOAT case t_longfloat: { long double d = ecl_long_float(x); if (d >= 0.0) s = 1; else { d = -d; s = 0; } d = frexpl(d, &e); x = ecl_make_long_float(d); break; } #endif default: FEwrong_type_nth_arg(@[decode-float],1,x,@[float]); } ecl_return3(the_env, x, ecl_make_fixnum(e), ecl_make_single_float(s)); } cl_object cl_scale_float(cl_object x, cl_object y) { const cl_env_ptr the_env = ecl_process_env(); cl_fixnum k; if (ECL_FIXNUMP(y)) { k = ecl_fixnum(y); } else { FEwrong_type_nth_arg(@[scale-float],2,y,@[fixnum]); } switch (ecl_t_of(x)) { case t_singlefloat: x = ecl_make_single_float(ldexpf(ecl_single_float(x), k)); break; case t_doublefloat: x = ecl_make_double_float(ldexp(ecl_double_float(x), k)); break; #ifdef ECL_LONG_FLOAT case t_longfloat: x = ecl_make_long_float(ldexpl(ecl_long_float(x), k)); break; #endif default: FEwrong_type_nth_arg(@[scale-float],1,x,@[float]); } ecl_return1(the_env, x); } cl_object cl_float_radix(cl_object x) { const cl_env_ptr the_env = ecl_process_env(); if (ecl_unlikely(cl_floatp(x) != ECL_T)) { FEwrong_type_nth_arg(@[float-radix],1,x,@[float]); } ecl_return1(the_env, ecl_make_fixnum(FLT_RADIX)); } int ecl_signbit(cl_object x) { switch (ecl_t_of(x)) { case t_singlefloat: return signbit(ecl_single_float(x)); case t_doublefloat: return signbit(ecl_double_float(x)); #ifdef ECL_LONG_FLOAT case t_longfloat: return signbit(ecl_long_float(x)); #endif default: FEwrong_type_nth_arg(@[float-sign],1,x,@[float]); } } @(defun float_sign (x &optional (y x yp)) int negativep; @ if (!yp) { y = cl_float(2, ecl_make_fixnum(1), x); } negativep = ecl_signbit(x); switch (ecl_t_of(y)) { case t_singlefloat: { float f = ecl_single_float(y); if (signbit(f) != negativep) y = ecl_make_single_float(-f); break; } case t_doublefloat: { double f = ecl_double_float(y); if (signbit(f) != negativep) y = ecl_make_double_float(-f); break; } #ifdef ECL_LONG_FLOAT case t_longfloat: { long double f = ecl_long_float(y); if (signbit(f) != negativep) y = ecl_make_long_float(-f); break; } #endif default: FEwrong_type_nth_arg(@[float-sign],2,y,@[float]); } @(return y); @) cl_object cl_float_digits(cl_object x) { const cl_env_ptr the_env = ecl_process_env(); switch (ecl_t_of(x)) { case t_singlefloat: x = ecl_make_fixnum(FLT_MANT_DIG); break; case t_doublefloat: x = ecl_make_fixnum(DBL_MANT_DIG); break; #ifdef ECL_LONG_FLOAT case t_longfloat: x = ecl_make_fixnum(LDBL_MANT_DIG); break; #endif default: FEwrong_type_nth_arg(@[float-digits],1,x,@[float]); } ecl_return1(the_env, x); } cl_object cl_float_precision(cl_object x) { const cl_env_ptr the_env = ecl_process_env(); int precision; switch (ecl_t_of(x)) { case t_singlefloat: { float f = ecl_single_float(x); if (f == 0.0) { precision = 0; } else { int exp; frexpf(f, &exp); if (exp >= FLT_MIN_EXP) { precision = FLT_MANT_DIG; } else { precision = FLT_MANT_DIG - (FLT_MIN_EXP - exp); } } break; } case t_doublefloat: { double f = ecl_double_float(x); if (f == 0.0) { precision = 0; } else { int exp; frexp(f, &exp); if (exp >= DBL_MIN_EXP) { precision = DBL_MANT_DIG; } else { precision = DBL_MANT_DIG - (DBL_MIN_EXP - exp); } } break; } #ifdef ECL_LONG_FLOAT case t_longfloat: { long double f = ecl_long_float(x); if (f == 0.0) { precision = 0; } else { int exp; frexp(f, &exp); if (exp >= LDBL_MIN_EXP) { precision = LDBL_MANT_DIG; } else { precision = LDBL_MANT_DIG - (LDBL_MIN_EXP - exp); } } break; } #endif default: FEwrong_type_nth_arg(@[float-precision],1,x,@[float]); } ecl_return1(the_env, ecl_make_fixnum(precision)); } cl_object cl_integer_decode_float(cl_object x) { const cl_env_ptr the_env = ecl_process_env(); int e, s = 1; switch (ecl_t_of(x)) { #ifdef ECL_LONG_FLOAT case t_longfloat: { long double d = ecl_long_float(x); if (signbit(d)) { s = -1; d = -d; } if (d == 0.0) { e = 0; x = ecl_make_fixnum(0); } else { d = frexpl(d, &e); x = _ecl_long_double_to_integer(ldexpl(d, LDBL_MANT_DIG)); e -= LDBL_MANT_DIG; } break; } #endif case t_doublefloat: { double d = ecl_double_float(x); if (signbit(d)) { s = -1; d = -d; } if (d == 0.0) { e = 0; x = ecl_make_fixnum(0); } else { d = frexp(d, &e); x = _ecl_double_to_integer(ldexp(d, DBL_MANT_DIG)); e -= DBL_MANT_DIG; } break; } case t_singlefloat: { float d = ecl_single_float(x); if (signbit(d)) { s = -1; d = -d; } if (d == 0.0) { e = 0; x = ecl_make_fixnum(0); } else { d = frexpf(d, &e); x = _ecl_double_to_integer(ldexp(d, FLT_MANT_DIG)); e -= FLT_MANT_DIG; } break; } default: FEwrong_type_nth_arg(@[integer-decode-float],1,x,@[float]); } ecl_return3(the_env, x, ecl_make_fixnum(e), ecl_make_fixnum(s)); } @(defun complex (r &optional (i ecl_make_fixnum(0))) @ /* INV: ecl_make_complex() checks types */ @(return ecl_make_complex(r, i)) @) cl_object cl_realpart(cl_object x) { switch (ecl_t_of(x)) { case t_fixnum: case t_bignum: case t_ratio: case t_singlefloat: case t_doublefloat: #ifdef ECL_LONG_FLOAT case t_longfloat: #endif break; case t_complex: x = x->complex.real; break; default: FEwrong_type_nth_arg(@[realpart],1,x,@[number]); } @(return x) } cl_object cl_imagpart(cl_object x) { switch (ecl_t_of(x)) { case t_fixnum: case t_bignum: case t_ratio: x = ecl_make_fixnum(0); break; case t_singlefloat: if (signbit(ecl_single_float(x))) x = cl_core.singlefloat_minus_zero; else x = cl_core.singlefloat_zero; break; case t_doublefloat: if (signbit(ecl_double_float(x))) x = cl_core.doublefloat_minus_zero; else x = cl_core.doublefloat_zero; break; #ifdef ECL_LONG_FLOAT case t_longfloat: if (signbit(ecl_long_float(x))) x = cl_core.longfloat_minus_zero; else x = cl_core.longfloat_zero; break; #endif case t_complex: x = x->complex.imag; break; default: FEwrong_type_nth_arg(@[imagpart],1,x,@[number]); } @(return x) } ecl-16.1.2/src/c/num_log.d000066400000000000000000000437631266352375300152130ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* num_log.c -- Logical operations on numbers. */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #include #include /* * BIT OPERATIONS FOR FIXNUMS */ static cl_fixnum ior_op(cl_fixnum i, cl_fixnum j) { return(i | j); } static cl_fixnum xor_op(cl_fixnum i, cl_fixnum j) { return(i ^ j); } static cl_fixnum and_op(cl_fixnum i, cl_fixnum j) { return(i & j); } static cl_fixnum eqv_op(cl_fixnum i, cl_fixnum j) { return(~(i ^ j)); } static cl_fixnum nand_op(cl_fixnum i, cl_fixnum j) { return(~(i & j)); } static cl_fixnum nor_op(cl_fixnum i, cl_fixnum j) { return(~(i | j)); } static cl_fixnum andc1_op(cl_fixnum i, cl_fixnum j) { return((~i) & j); } static cl_fixnum andc2_op(cl_fixnum i, cl_fixnum j) { return(i & (~j)); } static cl_fixnum orc1_op(cl_fixnum i, cl_fixnum j) { return((~i) | j); } static cl_fixnum orc2_op(cl_fixnum i, cl_fixnum j) { return(i | (~j)); } static cl_fixnum b_clr_op(cl_fixnum i, cl_fixnum j) { return(0); } static cl_fixnum b_set_op(cl_fixnum i, cl_fixnum j) { return(-1); } static cl_fixnum b_1_op(cl_fixnum i, cl_fixnum j) { return(i); } static cl_fixnum b_2_op(cl_fixnum i, cl_fixnum j) { return(j); } static cl_fixnum b_c1_op(cl_fixnum i, cl_fixnum j) { return(~i); } static cl_fixnum b_c2_op(cl_fixnum i, cl_fixnum j) { return(~j); } typedef cl_fixnum (*bit_operator)(cl_fixnum, cl_fixnum); static bit_operator fixnum_operations[16] = { b_clr_op, and_op, andc2_op, b_1_op, andc1_op, b_2_op, xor_op, ior_op, nor_op, eqv_op, b_c2_op, orc2_op, b_c1_op, orc1_op, nand_op, b_set_op}; static cl_object log_op(cl_narg narg, int op, ecl_va_list ARGS) { cl_object x, y; /* FIXME! This can be optimized */ x = ecl_va_arg(ARGS); if (narg-- == 1) { assert_type_integer(x); } else { do { y = ecl_va_arg(ARGS); x = ecl_boole(op, x, y); } while (--narg); } return x; } cl_object ecl_boole(int op, cl_object x, cl_object y) { switch (ecl_t_of(x)) { case t_fixnum: switch (ecl_t_of(y)) { case t_fixnum: { cl_fixnum z = fixnum_operations[op](ecl_fixnum(x), ecl_fixnum(y)); return ecl_make_fixnum(z); } case t_bignum: { cl_object x_copy = _ecl_big_register0(); _ecl_big_set_fixnum(x_copy, ecl_fixnum(x)); (_ecl_big_boole_operator(op))(x_copy, x_copy, y); return _ecl_big_register_normalize(x_copy); } default: FEwrong_type_nth_arg(@[boole], 2, y, @[integer]); } break; case t_bignum: { cl_object x_copy = _ecl_big_register0(); switch (ecl_t_of(y)) { case t_fixnum: { cl_object z = _ecl_big_register1(); _ecl_big_set_fixnum(z,ecl_fixnum(y)); (_ecl_big_boole_operator(op))(x_copy, x, z); _ecl_big_register_free(z); break; } case t_bignum: (_ecl_big_boole_operator(op))(x_copy, x, y); break; default: FEwrong_type_nth_arg(@[boole], 2, y, @[integer]); } return _ecl_big_register_normalize(x_copy); } default: FEwrong_type_nth_arg(@[boole], 1, x, @[integer]); } return x; } cl_object cl_lognot(cl_object x) { return @logxor(2,x,ecl_make_fixnum(-1)); } static cl_fixnum count_bits(cl_object x) { cl_fixnum count; switch (ecl_t_of(x)) { case t_fixnum: { cl_fixnum i = ecl_fixnum(x); cl_fixnum j = (i < 0) ? ~i : i; for (count=0 ; j ; j >>= 1) if (j & 1) count++; break; } case t_bignum: if (_ecl_big_sign(x) >= 0) count = mpz_popcount(x->big.big_num); else { cl_object z = _ecl_big_register0(); mpz_com(z->big.big_num, x->big.big_num); count = mpz_popcount(z->big.big_num); _ecl_big_register_free(z); } break; default: FEwrong_type_only_arg(@[logcount], x, @[integer]); } return count; } /* Left shift if w > 0, right shift if w < 0. */ cl_object ecl_ash(cl_object x, cl_fixnum w) { cl_object y; if (w == 0) return(x); y = _ecl_big_register0(); if (w < 0) { cl_index bits = -w; if (ECL_FIXNUMP(x)) { /* The result of shifting a number further than the number * of digits it has is unpredictable in C. For instance, GCC * on intel masks out all bits of "bits" beyond the 5 and * it may happen that a shift of 37 becomes a shift of 5. * Furthermore, in general, shifting negative numbers leads * to implementation-specific results :-/ */ cl_fixnum y = ecl_fixnum(x); if (bits >= ECL_FIXNUM_BITS) { y = (y < 0)? -1 : 0; } else { y >>= bits; } return ecl_make_fixnum(y); } mpz_div_2exp(y->big.big_num, x->big.big_num, bits); } else { if (ECL_FIXNUMP(x)) { _ecl_big_set_fixnum(y, ecl_fixnum(x)); x = y; } mpz_mul_2exp(y->big.big_num, x->big.big_num, (unsigned long)w); } return _ecl_big_register_normalize(y); } int ecl_fixnum_bit_length(cl_fixnum i) { int count; if (i < 0) i = ~i; for (count = 0; i && (count < ECL_FIXNUM_BITS); i >>= 1, count++) ; return count; } @(defun logior (&rest nums) @ if (narg == 0) @(return ecl_make_fixnum(0)) /* INV: log_op() checks types and outputs first argument as default. */ @(return log_op(narg, ECL_BOOLIOR, nums)) @) @(defun logxor (&rest nums) @ if (narg == 0) @(return ecl_make_fixnum(0)) /* INV: log_op() checks types and outputs first argument as default. */ @(return log_op(narg, ECL_BOOLXOR, nums)) @) @(defun logand (&rest nums) @ if (narg == 0) @(return ecl_make_fixnum(-1)) /* INV: log_op() checks types and outputs first argument as default. */ @(return log_op(narg, ECL_BOOLAND, nums)) @) @(defun logeqv (&rest nums) @ if (narg == 0) @(return ecl_make_fixnum(-1)) /* INV: log_op() checks types and outputs first argument as default. */ @(return log_op(narg, ECL_BOOLEQV, nums)) @) cl_object cl_lognand(cl_object x, cl_object y) { @(return ecl_boole(ECL_BOOLNAND, x, y)) } cl_object cl_lognor(cl_object x, cl_object y) { @(return ecl_boole(ECL_BOOLNOR, x, y)) } cl_object cl_logandc1(cl_object x, cl_object y) { @(return ecl_boole(ECL_BOOLANDC1, x, y)) } cl_object cl_logandc2(cl_object x, cl_object y) { @(return ecl_boole(ECL_BOOLANDC2, x, y)) } cl_object cl_logorc1(cl_object x, cl_object y) { @(return ecl_boole(ECL_BOOLORC1, x, y)) } cl_object cl_logorc2(cl_object x, cl_object y) { @(return ecl_boole(ECL_BOOLORC2, x, y)) } static int coerce_to_logical_operator(cl_object o) { cl_fixnum op; op = ecl_to_fix(o); if (op < 0 || op > ECL_BOOLSET) FEerror("~S is an invalid logical operator.", 1, o); return op; } cl_object cl_boole(cl_object o, cl_object x, cl_object y) { /* INV: log_op2() checks types */ @(return ecl_boole(coerce_to_logical_operator(o), x, y)) } cl_object cl_logbitp(cl_object p, cl_object x) { bool i; assert_type_integer(x); if (ECL_FIXNUMP(p)) { cl_index n = ecl_to_size(p); if (ECL_FIXNUMP(x)) { cl_fixnum y = ecl_fixnum(x); if (n >= ECL_FIXNUM_BITS) { i = (y < 0); } else { i = ((y >> n) & 1); } } else { i = mpz_tstbit(x->big.big_num, n); } } else { assert_type_non_negative_integer(p); if (ECL_FIXNUMP(x)) i = (ecl_fixnum(x) < 0); else i = (_ecl_big_sign(x) < 0); } @(return (i ? ECL_T : ECL_NIL)) } cl_object cl_ash(cl_object x, cl_object y) { cl_object r; int sign_x; assert_type_integer(x); assert_type_integer(y); if (ECL_FIXNUMP(y)) r = ecl_ash(x, ecl_fixnum(y)); else { /* bit position represented by bignum is probably out of our address space. So, result is returned according to sign of integer. */ if (ECL_FIXNUMP(x)) if (ecl_fixnum_minusp(x)) sign_x = -1; else if (x == ecl_make_fixnum(0)) sign_x = 0; else sign_x = 1; else sign_x = _ecl_big_sign(x); if (_ecl_big_sign(y) < 0) if (sign_x < 0) r = ecl_make_fixnum(-1); else r = ecl_make_fixnum(0); else if (sign_x == 0) r = x; else FEerror("Insufficient memory.", 0); } @(return r) } cl_object cl_logcount(cl_object x) { @(return ecl_make_fixnum(count_bits(x))) } cl_index ecl_integer_length(cl_object x) { int count; cl_fixnum i; switch (ecl_t_of(x)) { case t_fixnum: i = ecl_fixnum(x); count = ecl_fixnum_bit_length(i); break; case t_bignum: if (_ecl_big_sign(x) < 0) x = cl_lognot(x); count = mpz_sizeinbase(x->big.big_num, 2); break; default: FEwrong_type_only_arg(@[integer-length], x, @[integer]); } return count; } cl_object cl_integer_length(cl_object x) { @(return ecl_make_fixnum(ecl_integer_length(x))) } cl_object si_bit_array_op(cl_object o, cl_object x, cl_object y, cl_object r) { cl_fixnum i, j, n, d; cl_object r0; bit_operator op; bool replace = FALSE; int xi, yi, ri; byte *xp, *yp, *rp; int xo, yo, ro; if (ecl_t_of(x) == t_bitvector) { d = x->vector.dim; xp = x->vector.self.bit; xo = x->vector.offset; if (ecl_t_of(y) != t_bitvector) goto ERROR; if (d != y->vector.dim) goto ERROR; yp = y->vector.self.bit; yo = y->vector.offset; if (r == ECL_T) r = x; if (r != ECL_NIL) { if (ecl_t_of(r) != t_bitvector) goto ERROR; if (r->vector.dim != d) goto ERROR; i = (r->vector.self.bit - xp)*8 + (r->vector.offset - xo); if ((i > 0 && i < d) || (i < 0 && -i < d)) { r0 = r; r = ECL_NIL; replace = TRUE; goto L1; } i = (r->vector.self.bit - yp)*8 + (r->vector.offset - yo); if ((i > 0 && i < d) || (i < 0 && -i < d)) { r0 = r; r = ECL_NIL; replace = TRUE; } } L1: if (Null(r)) { r = ecl_alloc_simple_vector(d, ecl_aet_bit); } } else { if (ecl_t_of(x) != t_array) goto ERROR; if ((cl_elttype)x->array.elttype != ecl_aet_bit) goto ERROR; d = x->array.dim; xp = x->vector.self.bit; xo = x->vector.offset; if (ecl_t_of(y) != t_array) goto ERROR; if ((cl_elttype)y->array.elttype != ecl_aet_bit) goto ERROR; if (x->array.rank != y->array.rank) goto ERROR; yp = y->vector.self.bit; yo = y->vector.offset; for (i = 0; i < x->array.rank; i++) if (x->array.dims[i] != y->array.dims[i]) goto ERROR; if (r == ECL_T) r = x; if (r != ECL_NIL) { if (ecl_t_of(r) != t_array) goto ERROR; if ((cl_elttype)r->array.elttype != ecl_aet_bit) goto ERROR; if (r->array.rank != x->array.rank) goto ERROR; for (i = 0; i < x->array.rank; i++) if (r->array.dims[i] != x->array.dims[i]) goto ERROR; i = (r->vector.self.bit - xp)*8 + (r->vector.offset - xo); if ((i > 0 && i < d) || (i < 0 && -i < d)) { r0 = r; r = ECL_NIL; replace = TRUE; goto L2; } i = (r->vector.self.bit - yp)*8 + (r->vector.offset - yo); if ((i > 0 && i < d) || (i < 0 && -i < d)) { r0 = r; r = ECL_NIL; replace = TRUE; } } L2: if (Null(r)) { r = ecl_alloc_object(t_array); r->array.self.t = NULL; r->array.displaced = ECL_NIL; r->array.rank = x->array.rank; r->array.dims = x->array.dims; r->array.elttype = ecl_aet_bit; r->array.dim = x->array.dim; r->array.flags = 0; /* no fill pointer, not adjustable */ ecl_array_allocself(r); } } rp = r->vector.self.bit; ro = r->vector.offset; op = fixnum_operations[coerce_to_logical_operator(o)]; #define set_high(place, nbits, value) \ (place)=((place)&~(-0400>>(nbits)))|((value)&(-0400>>(nbits))) #define set_low(place, nbits, value) \ (place)=((place)&(-0400>>(8-(nbits))))|((value)&~(-0400>>(8-(nbits)))) #define extract_byte(integer, pointer, index, offset) \ (integer) = (pointer)[(index)+1] & 0377; \ (integer) = ((pointer)[index]<<(offset))|((integer)>>(8-(offset))) #define store_byte(pointer, index, offset, value) \ set_low((pointer)[index], 8-(offset), (value)>>(offset)); \ set_high((pointer)[(index)+1], offset, (value)<<(8-(offset))) if (xo == 0 && yo == 0 && ro == 0) { for (n = d/8, i = 0; i < n; i++) rp[i] = (*op)(xp[i], yp[i]); if ((j = d%8) > 0) set_high(rp[n], j, (*op)(xp[n], yp[n])); if (!replace) @(return r) } else { for (n = d/8, i = 0; i <= n; i++) { extract_byte(xi, xp, i, xo); extract_byte(yi, yp, i, yo); if (i == n) { if ((j = d%8) == 0) break; extract_byte(ri, rp, n, ro); set_high(ri, j, (*op)(xi, yi)); } else ri = (*op)(xi, yi); store_byte(rp, i, ro, ri); } if (!replace) @(return r) } rp = r0->vector.self.bit; ro = r0->vector.offset; for (n = d/8, i = 0; i <= n; i++) { if (i == n) { if ((j = d%8) == 0) break; extract_byte(ri, rp, n, ro); set_high(ri, j, r->vector.self.bit[n]); } else ri = r->vector.self.bit[i]; store_byte(rp, i, ro, ri); } @(return r0) ERROR: FEerror("Illegal arguments for bit-array operation.", 0); } ecl-16.1.2/src/c/num_pred.d000066400000000000000000000041611266352375300153510ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* num_pred.c -- Predicates on numbers. */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #define ECL_INCLUDE_MATH_H #include #include #include int ecl_oddp(cl_object x) { if (ECL_FIXNUMP(x)) return ecl_fixnum(x) & 1; unlikely_if (!ECL_BIGNUMP(x)) FEwrong_type_only_arg(@[oddp], x, @[integer]); return _ecl_big_odd_p(x); } int ecl_evenp(cl_object x) { if (ECL_FIXNUMP(x)) return ~ecl_fixnum(x) & 1; unlikely_if (!ECL_BIGNUMP(x)) FEwrong_type_only_arg(@[evenp], x, @[integer]); return _ecl_big_even_p(x); } cl_object cl_oddp(cl_object x) { /* INV: ecl_oddp() checks type */ @(return (ecl_oddp(x) ? ECL_T : ECL_NIL)) } cl_object cl_evenp(cl_object x) { /* INV: ecl_evenp() checks_type */ @(return (ecl_evenp(x) ? ECL_T : ECL_NIL)) } cl_object si_float_nan_p(cl_object x) { @(return (ecl_float_nan_p(x)? ECL_T : ECL_NIL)) } cl_object si_float_infinity_p(cl_object x) { @(return (ecl_float_infinity_p(x)? ECL_T : ECL_NIL)) } bool ecl_float_nan_p(cl_object x) { return !ecl_number_equalp(x,x); } bool ecl_float_infinity_p(cl_object x) { switch (ecl_t_of(x)) { case t_singlefloat: return !isfinite(ecl_single_float(x)); case t_doublefloat: return !isfinite(ecl_double_float(x)); #ifdef ECL_LONG_FLOAT case t_longfloat: return !isfinite(ecl_long_float(x)); #endif default: return 0; } } ecl-16.1.2/src/c/num_rand.d000066400000000000000000000232071266352375300153450ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* num_rand.c -- Random numbers. n*/ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. Copyright (c) 2015, Daniel KochmaХ„ski. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #include #include #include #include #include #if !defined(ECL_MS_WINDOWS_HOST) # include #endif #if !defined(_MSC_VER) && !defined(__MINGW32__) # include /* it isn't pulled in by fcntl.h */ #endif /* * Mersenne-Twister random number generator */ #if ECL_FIXNUM_BITS > 32 /* * 64 bit version */ /* Period parameters */ #define MT_N 312 #define MT_M 156 #define MATRIX_A 0xB5026F5AA96619E9ULL /* constant vector a */ #define UPPER_MASK 0xFFFFFFFF80000000ULL /* most significant 33 bits */ #define LOWER_MASK 0x7FFFFFFFULL /* least significant 31 bits */ #define ulong uint64_t static cl_object init_genrand(ulong seed) { cl_object array = ecl_alloc_simple_vector((MT_N + 1), ecl_aet_b64); ulong *mt = array->vector.self.b64; int j; mt[0] = seed; for (j=1; j> 62)) + j); mt[MT_N] = MT_N+1; return array; } static ulong generate_int64(cl_object state) { static mag01[2]={0x0UL, MATRIX_A}; ulong y; ulong *mt = state->vector.self.b64; if (mt[MT_N] >= MT_N) { /* refresh data */ int kk; for (kk=0; kk < (MT_N - MT_M); kk++) { y = (mt[kk] & UPPER_MASK) | (mt[kk+1] & LOWER_MASK); mt[kk] = mt[kk + MT_M] ^ (y >> 1) ^ mag01[y & 0x1ULL]; } for (; kk < (MT_N - 1); kk++) { y = (mt[kk] & UPPER_MASK) | (mt[kk+1] & LOWER_MASK); mt[kk] = mt[kk+(MT_M-MT_N)] ^ (y >> 1) ^ mag01[y & 0x1ULL]; } y = (mt[MT_N-1] & UPPER_MASK) | (mt[0] & LOWER_MASK); mt[MT_N-1] = mt[MT_M-1] ^ (y >> 1) ^ mag01[y & 0x1ULL]; mt[MT_N] = 0; } /* get random 64 bit num */ y = mt[mt[MT_N]++]; /* Tempering */ y ^= (y >> 29) & 0x5555555555555555ULL; y ^= (y << 17) & 0x71D67FFFEDA60000ULL; y ^= (y << 37) & 0xFFF7EEE000000000ULL; y ^= (y >> 43); return y; } static double generate_double(cl_object state) { return (generate_int64(state) >> 11) * (1.0 / 9007199254740991.0); } static mp_limb_t generate_limb(cl_object state) { #if GMP_LIMB_BITS <= 32 return generate_int64(state); #else # if GMP_LIMB_BITS <= 64 return generate_int64(state); # else # if GMP_LIMB_BITS <= 128 mp_limb_t high = generate_int64(state); return (high << 64) | generate_int64(state); # endif # endif #endif } #else /* * 32 bit version */ /* Period parameters */ #define MT_N 624 #define MT_M 397 #define MATRIX_A 0x9908b0dfUL /* constant vector a */ #define UPPER_MASK 0x80000000UL /* most significant w-r bits */ #define LOWER_MASK 0x7fffffffUL /* least significant r bits */ #define ulong uint32_t static cl_object init_genrand(ulong seed) { cl_object array = ecl_alloc_simple_vector((MT_N + 1), ecl_aet_b32); ulong *mt = array->vector.self.b32; int j; mt[0] = seed; for (j=1; j < MT_N; j++) mt[j] = (1812433253UL * (mt[j-1] ^ (mt[j-1] >> 30)) + j); mt[MT_N] = MT_N+1; return array; } static ulong generate_int32(cl_object state) { static mag01[2]={0x0UL, MATRIX_A}; ulong y; ulong *mt = state->vector.self.b32; if (mt[MT_N] >= MT_N) { /* refresh data */ int kk; for (kk=0; kk < (MT_N - MT_M); kk++) { y = (mt[kk] & UPPER_MASK) | (mt[kk+1] & LOWER_MASK); mt[kk] = mt[kk + MT_M] ^ (y >> 1) ^ mag01[y & 0x1UL]; } for (; kk < (MT_N - 1); kk++) { y = (mt[kk] & UPPER_MASK) | (mt[kk+1] & LOWER_MASK); mt[kk] = mt[kk+(MT_M-MT_N)] ^ (y >> 1) ^ mag01[y & 0x1UL]; } y = (mt[MT_N-1] & UPPER_MASK) | (mt[0] & LOWER_MASK); mt[MT_N-1] = mt[MT_M-1] ^ (y >> 1) ^ mag01[y & 0x1UL]; mt[MT_N] = 0; } /* get random 32 bit num */ y = mt[mt[MT_N]++]; /* Tempering */ y ^= (y >> 11); y ^= (y << 7) & 0x9d2c5680UL; y ^= (y << 15) & 0xefc60000UL; y ^= (y >> 18); return y; } static double generate_double(cl_object state) { return generate_int32(state) * (1.0 / 4294967296.0); } static mp_limb_t generate_limb(cl_object state) { #if GMP_LIMB_BITS <= 32 return generate_int32(state); #else # if GMP_LIMB_BITS <= 64 mp_limb_t high = generate_int32(state); return (high << 32) | generate_int32(state); # else # if GMP_LIMB_BITS <= 128 mp_limb_t word0 = generate_int32(state); mp_limb_t word1 = generate_int32(state); mp_limb_t word2 = generate_int32(state); mp_limb_t word3 = generate_int32(state); return (word3 << 96) | (word3 << 64) | (word1 << 32) || word0; # endif # endif #endif } #endif cl_object init_random_state(void) { ulong seed; #if !defined(ECL_MS_WINDOWS_HOST) /* fopen() might read full 4kB blocks and discard * a lot of entropy, so use open() */ int file_handler = open("/dev/urandom", O_RDONLY); if (file_handler != -1) { read(file_handler, &seed, sizeof(ulong)); close(file_handler); } else #endif { /* cant get urandom, use crappy source */ /* and/or fill rest of area */ seed = (rand() + time(0)); } return init_genrand(seed); } static cl_object random_integer(cl_object limit, cl_object state) { cl_index bit_length = ecl_integer_length(limit); cl_object buffer; if (bit_length <= ECL_FIXNUM_BITS) bit_length = ECL_FIXNUM_BITS; buffer = ecl_ash(ecl_make_fixnum(1), bit_length); for (bit_length = mpz_size(buffer->big.big_num); bit_length; ) { ECL_BIGNUM_LIMBS(buffer)[--bit_length] = generate_limb(state); } return cl_mod(buffer, limit); } static cl_object rando(cl_object x, cl_object rs) { cl_object z; if (!ecl_plusp(x)) { goto ERROR; } switch (ecl_t_of(x)) { case t_fixnum: #if ECL_FIXNUM_BITS <= 32 z = ecl_make_fixnum(generate_int32(rs->random.value) % ecl_fixnum(x)); break; #endif case t_bignum: z = random_integer(x, rs->random.value); break; case t_singlefloat: z = ecl_make_single_float(ecl_single_float(x) * (float)generate_double(rs->random.value)); break; case t_doublefloat: z = ecl_make_double_float(ecl_double_float(x) * generate_double(rs->random.value)); break; #ifdef ECL_LONG_FLOAT case t_longfloat: z = ecl_make_long_float(ecl_long_float(x) * (long double)generate_double(rs->random.value)); break; #endif default: ERROR: { const char *type = "(OR (INTEGER (0) *) (FLOAT (0) *))"; FEwrong_type_nth_arg(@[random],1,x, ecl_read_from_cstring(type)); } } return z; } cl_object ecl_make_random_state(cl_object rs) { cl_object z = ecl_alloc_object(t_random); if (rs == ECL_T) { z->random.value = init_random_state(); return z; } if (Null(rs)) rs = ecl_symbol_value(@'*random-state*'); switch (ecl_t_of(rs)) { case t_random: z->random.value = cl_copy_seq(rs->random.value); break; case t_vector: z->random.value = cl_copy_seq(rs); break; case t_fixnum: /* XXX: If we'll decide to use 64-bit algorithm for appropriate platforms then this will be replaced with ecl_to_ulong_long from number.d, which takes widest available type (32 or 64 bit) automatically. */ z->random.value = init_genrand(ecl_fixnum(rs)); break; default: { const char *type = "(OR RANDOM-STATE (SIMPLE-VECTOR *) (INTEGER 0 *))"; FEwrong_type_only_arg(@[make-random-state], rs, ecl_read_from_cstring(type)); } } return(z); } @(defun random (x &optional (rs ecl_symbol_value(@'*random-state*'))) @ rs = ecl_check_cl_type(@'random', rs, t_random); @(return rando(x, rs)); @) @(defun make_random_state (&optional (rs ECL_NIL)) @ @(return ecl_make_random_state(rs)) @) cl_object cl_random_state_p(cl_object x) { @(return (ECL_RANDOM_STATE_P(x) ? ECL_T : ECL_NIL)) } ecl-16.1.2/src/c/number.d000066400000000000000000000746111266352375300150370ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* number.c -- constructing numbers. */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #include #include #define ECL_INCLUDE_MATH_H #include #include #include #include #if defined(ECL_IEEE_FP) && defined(HAVE_FEENABLEEXCEPT) /* * We are using IEEE arithmetics and can rely on FPE exceptions * to be raised when invalid operations are performed. */ # define DO_DETECT_FPE(f) ecl_detect_fpe() #else /* * Either we can not rely on C signals or we do not want IEEE NaNs and * infinities. The first case typically happens for instance under OS * X, where the status of the FPE control word is changed by * printf. We have two alternatives. */ # define DO_DETECT_FPE(f) do { \ unlikely_if (isnan(f)) ecl_deliver_fpe(FE_INVALID); \ unlikely_if (!isfinite(f)) ecl_deliver_fpe(FE_OVERFLOW); \ } while (0) #endif #if !ECL_CAN_INLINE cl_fixnum ecl_to_fix(cl_object f) { if (ecl_unlikely(!ECL_FIXNUMP(f))) FEtype_error_fixnum(f); return ecl_fixnum(f); } cl_index ecl_to_size(cl_object f) { cl_fixnum aux; if (ecl_likely(ECL_FIXNUMP(f))) { cl_fixnum aux = ecl_fixnum(f); if (ecl_likely(aux >= 0)) return aux; } FEtype_error_size(f); } #endif /* !ECL_CAN_INLINE */ cl_object ecl_make_integer(cl_fixnum l) { if (l > MOST_POSITIVE_FIXNUM || l < MOST_NEGATIVE_FIXNUM) { cl_object z = _ecl_big_register0(); _ecl_big_set_fixnum(z, l); return _ecl_big_register_copy(z); } return ecl_make_fixnum(l); } cl_object ecl_make_unsigned_integer(cl_index l) { if (l > MOST_POSITIVE_FIXNUM) { cl_object z = _ecl_big_register0(); _ecl_big_set_index(z, l); return _ecl_big_register_copy(z); } return ecl_make_fixnum(l); } int ecl_to_bit(cl_object x) { if (ecl_unlikely((x != ecl_make_fixnum(0)) && (x != ecl_make_fixnum(1)))) FEwrong_type_nth_arg(@[coerce], 1, x, @[bit]); return x == ecl_make_fixnum(1); } ecl_uint8_t ecl_to_uint8_t(cl_object x) { if (ecl_likely(ECL_FIXNUMP(x))) { cl_fixnum aux = ecl_fixnum(x); if (ecl_likely(aux >= 0 && aux <= 255)) return (ecl_uint8_t)aux; } FEwrong_type_argument(cl_list(2, @'unsigned-byte', ecl_make_fixnum(8)), x); } ecl_int8_t ecl_to_int8_t(cl_object x) { if (ecl_likely(ECL_FIXNUMP(x))) { cl_fixnum aux = ecl_fixnum(x); if (ecl_likely(aux >= -128 && aux <= 127)) return (ecl_uint8_t)aux; } FEwrong_type_argument(cl_list(2, @'signed-byte', ecl_make_fixnum(8)), x); } unsigned short ecl_to_ushort(cl_object x) { const unsigned short ushort_max = USHRT_MAX; if (ecl_likely(ECL_FIXNUMP(x))) { cl_fixnum y = ecl_fixnum(x); if (ecl_likely(y >= 0 && y <= ushort_max)) { return (unsigned short)y; } } FEwrong_type_argument(cl_list(3,@'integer', ecl_make_fixnum(0), ecl_make_fixnum(ushort_max)), x); } short ecl_to_short(cl_object x) { const short short_min = SHRT_MIN; const short short_max = SHRT_MAX; if (ecl_likely(ECL_FIXNUMP(x))) { cl_fixnum y = ecl_fixnum(x); if (ecl_likely(y >= short_min && y <= short_max)) { return (short)y; } } FEwrong_type_argument(cl_list(3,@'integer', ecl_make_fixnum(short_min), ecl_make_fixnum(short_max)), x); } #if ECL_FIXNUM_BITS < 32 # error "Unsupported platform with cl_fixnum < ecl_uint32_t" #endif #ifdef ecl_uint16_t ecl_uint16_t ecl_to_uint16_t(cl_object x) { const uint16_t uint16_max = 0xFFFFL; if (ecl_likely(ECL_FIXNUMP(x))) { cl_fixnum y = ecl_fixnum(x); if (ecl_likely(y >= 0 && y <= uint16_max)) { return (ecl_uint16_t)y; } } FEwrong_type_argument(cl_list(3,@'integer', ecl_make_fixnum(0), ecl_make_fixnum(uint16_max)), x); } ecl_int16_t ecl_to_int16_t(cl_object x) { const int16_t int16_min = -0x8000; const int16_t int16_max = 0x7FFF; if (ecl_likely(ECL_FIXNUMP(x))) { cl_fixnum y = ecl_fixnum(x); if (ecl_likely(y >= int16_min && y <= int16_max)) { return (ecl_int16_t)y; } } FEwrong_type_argument(cl_list(3,@'integer', ecl_make_fixnum(int16_min), ecl_make_fixnum(int16_max)), x); } #endif /* ecl_uint16_t */ #if defined(ecl_uint32_t) && (ECL_FIXNUM_BITS > 32) ecl_uint32_t ecl_to_uint32_t(cl_object x) { const uint32_t uint32_max = 0xFFFFFFFFUL; if (ecl_likely(ECL_FIXNUMP(x))) { cl_fixnum y = ecl_fixnum(x); if (ecl_likely(y >= 0 && y <= uint32_max)) { return (ecl_uint32_t)y; } } FEwrong_type_argument(cl_list(3,@'integer',ecl_make_fixnum(0), ecl_make_unsigned_integer(uint32_max)), x); } ecl_int32_t ecl_to_int32_t(cl_object x) { const int32_t int32_min = -0x80000000L; const int32_t int32_max = 0x7FFFFFFFL; if (ecl_likely(ECL_FIXNUMP(x))) { cl_fixnum y = ecl_fixnum(x); if (ecl_likely(y >= int32_min && y <= int32_max)) { return (ecl_int32_t)y; } } FEwrong_type_argument(cl_list(3,@'integer', ecl_make_integer(int32_min), ecl_make_integer(int32_max)), x); } #endif /* ecl_uint32_t */ #if defined(ecl_uint64_t) && (ECL_FIXNUM_BITS < 64) ecl_uint64_t ecl_to_uint64_t(cl_object x) { if (!ecl_minusp(x)) { if (ECL_FIXNUMP(x)) { return (ecl_uint64_t)ecl_fixnum(x); } else if (!ECL_BIGNUMP(x)) { (void)0; } else if (mpz_fits_ulong_p(x->big.big_num)) { return (ecl_uint64_t)mpz_get_ui(x->big.big_num); } else { cl_object copy = _ecl_big_register0(); mpz_fdiv_q_2exp(copy->big.big_num, x->big.big_num, 32); if (mpz_fits_ulong_p(copy->big.big_num)) { volatile ecl_uint64_t output; output = (ecl_uint64_t)mpz_get_ui(copy->big.big_num); output = (output << 32) + (ecl_uint64_t)mpz_get_ui(x->big.big_num); _ecl_big_register_free(copy); return output; } } } FEwrong_type_argument(cl_list(3,@'integer',ecl_make_fixnum(0), ecl_one_minus(ecl_ash(ecl_make_fixnum(1), 64))), x); } ecl_int64_t ecl_to_int64_t(cl_object x) { if (ECL_FIXNUMP(x)) { return (ecl_int64_t)ecl_fixnum(x); } else if (!ECL_BIGNUMP(x)) { (void)0; } else if (mpz_fits_slong_p(x->big.big_num)) { return (ecl_int64_t)mpz_get_si(x->big.big_num); } else { cl_object copy = _ecl_big_register0(); mpz_fdiv_q_2exp(copy->big.big_num, x->big.big_num, 32); if (mpz_fits_slong_p(copy->big.big_num)) { ecl_int64_t output; output = (ecl_int64_t)mpz_get_si(copy->big.big_num); mpz_fdiv_r_2exp(copy->big.big_num, x->big.big_num, 32); return (output << 32) + mpz_get_ui(copy->big.big_num); } } FEwrong_type_argument(cl_list(3,@'integer', ecl_negate(ecl_ash(ecl_make_fixnum(1), 63)), ecl_one_minus(ecl_ash(ecl_make_fixnum(1), 63))), x); } cl_object ecl_make_uint64_t(ecl_uint64_t i) { if (i <= MOST_POSITIVE_FIXNUM) { return ecl_make_fixnum(i); } else if (i <= ~(ecl_uint32_t)0) { return ecl_make_uint32_t(i); } else { cl_object aux = ecl_make_uint32_t(i >> 32); return cl_logior(2, ecl_ash(aux, 32), ecl_make_uint32_t((ecl_uint32_t)i)); } } cl_object ecl_make_int64_t(ecl_int64_t i) { if (i >= MOST_NEGATIVE_FIXNUM && i <= MOST_POSITIVE_FIXNUM) { return ecl_make_fixnum(i); } else { cl_object aux = ecl_make_int32_t(i >> 32); return cl_logior(2, ecl_ash(aux, 32), ecl_make_uint32_t((ecl_uint32_t)i)); } } #endif /* ecl_uint64_t */ #if defined(ecl_ulong_long_t) # if defined(ecl_uint32_t) && ECL_LONG_LONG_BITS == 32 ecl_ulong_long_t ecl_to_ulong_long(cl_object x) { return (ecl_ulong_long_t)ecl_to_uint32_t(x); } ecl_long_long_t ecl_to_long_long(cl_object x) { return (ecl_long_long_t)ecl_to_int32_t(x); } cl_object ecl_make_ulong_long(ecl_ulong_long_t i) { return ecl_make_uint32_t(i); } cl_object ecl_make_long_long(ecl_long_long_t i) { return ecl_make_int32_t(i); } # else # if defined(ecl_uint64_t) && ECL_LONG_LONG_BITS == 64 ecl_ulong_long_t ecl_to_ulong_long(cl_object x) { return (ecl_ulong_long_t)ecl_to_uint64_t(x); } ecl_long_long_t ecl_to_long_long(cl_object x) { return (ecl_long_long_t)ecl_to_int64_t(x); } cl_object ecl_make_ulong_long(ecl_ulong_long_t i) { return ecl_make_uint64_t(i); } cl_object ecl_make_long_long(ecl_long_long_t i) { return ecl_make_int64_t(i); } # else ecl_ulong_long_t ecl_to_ulong_long(cl_object x) { if (!ecl_minusp(x)) { if (ECL_FIXNUMP(x)) { return (ecl_ulong_long_t)ecl_fixnum(x); } else if (!ECL_BIGNUMP(x)) { (void)0; } else if (mpz_fits_ulong_p(x->big.big_num)) { return (ecl_ulong_long_t)mpz_get_ui(x->big.big_num); } else { cl_object copy = _ecl_big_register0(); int i = ECL_LONG_LONG_BITS - ECL_FIXNUM_BITS; mpz_fdiv_q_2exp(copy->bit.big_num, x->big.big_num, i); if (mpz_fits_ulong_p(copy->big.big_num)) { volatile ecl_ulong_long_t output; output = mpz_get_ui(copy->big.big_num); for (i -= ECL_FIXNUM_BITS; i; i-= ECL_FIXNUM_BITS) { output = (output << ECL_FIXNUM_BITS); output += mpz_get_ui(x->big.big_num); } return output; } } } FEwrong_type_argument(cl_list(3,@'integer',ecl_make_fixnum(0), ecl_one_minus(ecl_ash(ecl_make_fixnum(1), ECL_LONG_LONG_BITS))), x); } ecl_long_long_t ecl_to_long_long(cl_object x) { if (ECL_FIXNUMP(x)) { return (ecl_long_long_t)ecl_fixnum(x); } else if (!ECL_BIGNUMP(x)) { (void)0; } else if (mpz_fits_slong_p(x->big.big_num)) { return (ecl_long_long_t)mpz_get_si(x->big.big_num); } else { cl_object copy = _ecl_big_register0(); int i = ECL_LONG_LONG_BITS - ECL_FIXNUM_BITS; mpz_fdiv_q_2exp(copy->bit.big_num, x->big.big_num, i); if (mpz_fits_ulong_p(copy->big.big_num)) { volatile ecl_long_long_t output; output = mpz_get_si(copy->big.big_num); for (i -= ECL_FIXNUM_BITS; i; i-= ECL_FIXNUM_BITS) { output = (output << ECL_FIXNUM_BITS); output += mpz_get_ui(x->big.big_num); } return output; } } FEwrong_type_argument(cl_list(3,@'integer', ecl_negate(ecl_ash(ecl_make_fixnum(1), ECL_LONG_LONG_BITS-1)), ecl_one_minus(ecl_ash(ecl_make_fixnum(1), ECL_LONG_LONG_BITS-1))), x); } cl_object ecl_make_ulong_long(ecl_ulong_long_t i) { if (i <= MOST_POSITIVE_FIXNUM) { return ecl_make_fixnum(i); } else if (i <= ~(ecl_uint32_t)0) { return ecl_make_uint32_t(i); } else { cl_object aux = ecl_make_uint32_t(i >> 32); return cl_logior(2, ecl_ash(aux, 32), ecl_make_uint32_t((ecl_uint32_t)i)); } } cl_object ecl_make_long_long(ecl_long_long_t i) { if (i >= MOST_NEGATIVE_FIXNUM && i <= MOST_POSITIVE_FIXNUM) { return ecl_make_fixnum(i); } else { cl_object aux = ecl_make_int32_t(i >> 32); return cl_logior(2, ecl_ash(aux, 32), ecl_make_uint32_t((ecl_uint32_t)i)); } } # endif # endif #endif /* ecl_ulong_long_t */ cl_object ecl_make_ratio(cl_object num, cl_object den) { cl_object g, r; /* INV: the arguments NUM & DEN are integers */ if (den == ecl_make_fixnum(0)) FEdivision_by_zero(num, den); if (num == ecl_make_fixnum(0) || den == ecl_make_fixnum(1)) return(num); if (ecl_minusp(den)) { num = ecl_negate(num); den = ecl_negate(den); } g = ecl_gcd(num, den); if (g != ecl_make_fixnum(1)) { num = ecl_integer_divide(num, g); den = ecl_integer_divide(den, g); } if (den == ecl_make_fixnum(1)) return num; if (den == ecl_make_fixnum(-1)) return ecl_negate(num); r = ecl_alloc_object(t_ratio); r->ratio.num = num; r->ratio.den = den; return(r); } void ecl_deliver_fpe(int status) { cl_env_ptr env = ecl_process_env(); int bits = status & env->trap_fpe_bits; feclearexcept(FE_ALL_EXCEPT); if (bits) { cl_object condition; if (bits & FE_DIVBYZERO) condition = @'division-by-zero'; else if (bits & FE_INVALID) condition = @'floating-point-invalid-operation'; else if (bits & FE_OVERFLOW) condition = @'floating-point-overflow'; else if (bits & FE_UNDERFLOW) condition = @'floating-point-underflow'; else if (bits & FE_INEXACT) condition = @'floating-point-inexact'; else condition = @'arithmetic-error'; cl_error(1, condition); } } cl_object ecl_make_single_float(float f) { cl_object x; DO_DETECT_FPE(f); if (f == (float)0.0) { #if defined(ECL_SIGNED_ZERO) if (signbit(f)) return cl_core.singlefloat_minus_zero; #endif return cl_core.singlefloat_zero; } x = ecl_alloc_object(t_singlefloat); ecl_single_float(x) = f; return(x); } cl_object ecl_make_double_float(double f) { cl_object x; DO_DETECT_FPE(f); if (f == (double)0.0) { #if defined(ECL_SIGNED_ZERO) if (signbit(f)) return cl_core.doublefloat_minus_zero; #endif return cl_core.doublefloat_zero; } x = ecl_alloc_object(t_doublefloat); ecl_double_float(x) = f; return(x); } #ifdef ECL_LONG_FLOAT cl_object ecl_make_long_float(long double f) { cl_object x; DO_DETECT_FPE(f); if (f == (long double)0.0) { #if defined(ECL_SIGNED_ZERO) if (signbit(f)) return cl_core.longfloat_minus_zero; #endif return cl_core.longfloat_zero; } x = ecl_alloc_object(t_longfloat); x->longfloat.value = f; return x; } #endif cl_object ecl_make_complex(cl_object r, cl_object i) { cl_object c; cl_type ti; AGAIN: ti = ecl_t_of(i); /* Both R and I are promoted to a common type */ switch (ecl_t_of(r)) { case t_fixnum: case t_bignum: case t_ratio: switch (ti) { case t_fixnum: if (i == ecl_make_fixnum(0)) return(r); case t_bignum: case t_ratio: break; case t_singlefloat: r = ecl_make_single_float((float)ecl_to_double(r)); break; case t_doublefloat: r = ecl_make_double_float(ecl_to_double(r)); break; #ifdef ECL_LONG_FLOAT case t_longfloat: r = ecl_make_long_float(ecl_to_double(r)); break; #endif default: i = ecl_type_error(@'complex',"imaginary part", i, @'real'); goto AGAIN; } break; case t_singlefloat: switch (ti) { case t_fixnum: case t_bignum: case t_ratio: i = ecl_make_single_float((float)ecl_to_double(i)); break; case t_singlefloat: break; case t_doublefloat: r = ecl_make_double_float((double)(ecl_single_float(r))); break; #ifdef ECL_LONG_FLOAT case t_longfloat: r = ecl_make_long_float((long double)ecl_single_float(r)); break; #endif default: i = ecl_type_error(@'complex',"imaginary part", i, @'real'); goto AGAIN; } break; case t_doublefloat: switch (ti) { case t_fixnum: case t_bignum: case t_ratio: case t_singlefloat: i = ecl_make_double_float(ecl_to_double(i)); case t_doublefloat: break; #ifdef ECL_LONG_FLOAT case t_longfloat: r = ecl_make_long_float((long double)ecl_double_float(r)); break; #endif default: i = ecl_type_error(@'complex',"imaginary part", i, @'real'); goto AGAIN; } break; #ifdef ECL_LONG_FLOAT case t_longfloat: if (ti != t_longfloat) i = ecl_make_long_float((long double)ecl_to_double(i)); break; #endif default: r = ecl_type_error(@'complex',"real part", r, @'real'); goto AGAIN; } c = ecl_alloc_object(t_complex); c->complex.real = r; c->complex.imag = i; return(c); } static cl_object into_bignum(cl_object bignum, cl_object integer) { if (ECL_FIXNUMP(integer)) { _ecl_big_set_fixnum(bignum, ecl_fixnum(integer)); } else { mpz_set(bignum->big.big_num, integer->big.big_num); } return bignum; } static cl_fixnum remove_zeros(cl_object *integer) { cl_object buffer = into_bignum(_ecl_big_register0(), *integer); unsigned long den_twos = mpz_scan1(buffer->big.big_num, 0); if (den_twos < ULONG_MAX) { mpz_div_2exp(buffer->big.big_num, buffer->big.big_num, den_twos); *integer = _ecl_big_register_normalize(buffer); return -den_twos; } else { _ecl_big_register_free(buffer); return 0; } } static cl_object prepare_ratio_to_float(cl_object num, cl_object den, int digits, cl_fixnum *scaleout) { /* We have to cook our own routine because GMP does not round. * The recipe is simple: we multiply the numberator by a large * enough number so that the division by the denominator fits * the floating point number. The result is scaled back by the * appropriate exponent. */ /* Scale down the denominator, eliminating the zeros * so that we have smaller operands. */ cl_fixnum scale = remove_zeros(&den); cl_fixnum num_size = ecl_integer_length(num); cl_fixnum delta = ecl_integer_length(den) - num_size; scale -= delta; { cl_fixnum adjust = digits + delta + 1; if (adjust > 0) { num = ecl_ash(num, adjust); } else if (adjust < 0) { den = ecl_ash(den, -adjust); } } do { const cl_env_ptr the_env = ecl_process_env(); cl_object fraction = ecl_truncate2(num, den); cl_object rem = ecl_nth_value(the_env, 1); cl_fixnum len = ecl_integer_length(fraction); if ((len - digits) == 1) { if (ecl_oddp(fraction)) { cl_object one = ecl_minusp(num)? ecl_make_fixnum(-1) : ecl_make_fixnum(1); if (rem == ecl_make_fixnum(0)) { if (cl_logbitp(ecl_make_fixnum(1), fraction) != ECL_NIL) fraction = ecl_plus(fraction, one); } else { fraction = ecl_plus(fraction, one); } } *scaleout = scale - (digits + 1); return fraction; } den = ecl_ash(den, 1); scale++; } while (1); } #if 0 /* Unused, we do not have ecl_to_float() */ static float ratio_to_float(cl_object num, cl_object den) { cl_fixnum scale; cl_object bits = prepare_ratio_to_float(num, den, FLT_MANT_DIG, &scale); #if (FIXNUM_BITS-ECL_TAG_BITS) >= FLT_MANT_DIG /* The output of prepare_ratio_to_float will always fit an integer */ float output = ecl_fixnum(bits); #else float output = ECL_FIXNUMP(bits)? ecl_fixnum(bits) : _ecl_big_to_double(bits); #endif return ldexpf(output, scale); } #endif static double ratio_to_double(cl_object num, cl_object den) { cl_fixnum scale; cl_object bits = prepare_ratio_to_float(num, den, DBL_MANT_DIG, &scale); #if (FIXNUM_BITS-ECL_TAG_BITS) >= DBL_MANT_DIG /* The output of prepare_ratio_to_float will always fit an integer */ double output = ecl_fixnum(bits); #else double output = ECL_FIXNUMP(bits)? ecl_fixnum(bits) : _ecl_big_to_double(bits); #endif return ldexp(output, scale); } #ifdef ECL_LONG_FLOAT static long double ratio_to_long_double(cl_object num, cl_object den) { cl_fixnum scale; cl_object bits = prepare_ratio_to_float(num, den, LDBL_MANT_DIG, &scale); #if (FIXNUM_BITS-ECL_TAG_BITS) >= LDBL_MANT_DIG /* The output of prepare_ratio_to_float will always fit an integer */ long double output = ecl_fixnum(bits); #else long double output = ECL_FIXNUMP(bits)? (long double)ecl_fixnum(bits) : _ecl_big_to_long_double(bits); #endif return ldexpl(output, scale); } #endif /* ECL_LONG_FLOAT */ float ecl_to_float(cl_object x) { if (ECL_FIXNUMP(x)) return(ecl_fixnum(x)); /* Immediate fixnum */ switch (ecl_t_of(x)) { case t_fixnum: return (float)ecl_fixnum(x); case t_bignum: return (float)ratio_to_double(x, ecl_make_fixnum(1)); case t_ratio: return (float)ratio_to_double(x->ratio.num, x->ratio.den); case t_singlefloat: return ecl_single_float(x); case t_doublefloat: return (float)ecl_double_float(x); #ifdef ECL_LONG_FLOAT case t_longfloat: return (float)ecl_long_float(x); #endif default: FEwrong_type_nth_arg(@[coerce], 1, x, @[real]); } } double ecl_to_double(cl_object x) { switch(ecl_t_of(x)) { case t_fixnum: return((double)(ecl_fixnum(x))); case t_bignum: return ratio_to_double(x, ecl_make_fixnum(1)); case t_ratio: return ratio_to_double(x->ratio.num, x->ratio.den); case t_singlefloat: return (double)ecl_single_float(x); case t_doublefloat: return(ecl_double_float(x)); #ifdef ECL_LONG_FLOAT case t_longfloat: return (double)ecl_long_float(x); #endif default: FEwrong_type_nth_arg(@[coerce], 1, x, @[real]); } } #ifdef ECL_LONG_FLOAT long double ecl_to_long_double(cl_object x) { switch(ecl_t_of(x)) { case t_fixnum: return (long double)ecl_fixnum(x); case t_bignum: return ratio_to_long_double(x, ecl_make_fixnum(1)); case t_ratio: return ratio_to_long_double(x->ratio.num, x->ratio.den); case t_singlefloat: return (long double)ecl_single_float(x); case t_doublefloat: return (long double)ecl_double_float(x); case t_longfloat: return ecl_long_float(x); default: FEwrong_type_nth_arg(@[coerce], 1, x, @[real]); } } #endif cl_object cl_rational(cl_object x) { double d; AGAIN: switch (ecl_t_of(x)) { case t_fixnum: case t_bignum: case t_ratio: break; case t_singlefloat: d = ecl_single_float(x); goto GO_ON; case t_doublefloat: d = ecl_double_float(x); GO_ON: if (d == 0) { x = ecl_make_fixnum(0); } else { int e; d = frexp(d, &e); e -= DBL_MANT_DIG; x = _ecl_double_to_integer(ldexp(d, DBL_MANT_DIG)); if (e != 0) { x = ecl_times(ecl_expt(ecl_make_fixnum(FLT_RADIX), ecl_make_fixnum(e)), x); } } break; #ifdef ECL_LONG_FLOAT case t_longfloat: { long double d = ecl_long_float(x); if (d == 0) { x = ecl_make_fixnum(0); } else { int e; d = frexpl(d, &e); e -= LDBL_MANT_DIG; d = ldexpl(d, LDBL_MANT_DIG); x = _ecl_long_double_to_integer(d); if (e != 0) { x = ecl_times(ecl_expt(ecl_make_fixnum(FLT_RADIX), ecl_make_fixnum(e)), x); } } break; } #endif default: x = ecl_type_error(@'rational',"argument",x,@'number'); goto AGAIN; } @(return x) } #ifdef ECL_LONG_FLOAT cl_object _ecl_long_double_to_integer(long double d0) { const int fb = ECL_FIXNUM_BITS - 3; int e; long double d = frexpl(d0, &e); if (e <= fb) { return ecl_make_fixnum((cl_fixnum)d0); } else if (e > LDBL_MANT_DIG) { return ecl_ash(_ecl_long_double_to_integer(ldexp(d, LDBL_MANT_DIG)), e - LDBL_MANT_DIG); } else { long double d1 = floorl(d = ldexpl(d, fb)); int newe = e - fb; cl_object o = ecl_ash(_ecl_long_double_to_integer(d1), newe); long double d2 = ldexpl(d - d1, newe); if (d2) o = ecl_plus(o, _ecl_long_double_to_integer(d2)); return o; } } #endif cl_object _ecl_double_to_integer(double d) { if (d <= MOST_POSITIVE_FIXNUM && d >= MOST_NEGATIVE_FIXNUM) return ecl_make_fixnum((cl_fixnum)d); else { cl_object z = _ecl_big_register0(); _ecl_big_set_d(z, d); return _ecl_big_register_copy(z); } } cl_object _ecl_float_to_integer(float d) { if (d <= MOST_POSITIVE_FIXNUM && d >= MOST_NEGATIVE_FIXNUM) return ecl_make_fixnum((cl_fixnum)d); else { cl_object z = _ecl_big_register0(); _ecl_big_set_d(z, d); return _ecl_big_register_copy(z); } } ecl-16.1.2/src/c/numbers/000077500000000000000000000000001266352375300150445ustar00rootroot00000000000000ecl-16.1.2/src/c/numbers/abs.d000066400000000000000000000053041266352375300157600ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* abs.d -- Absolute value. */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #define ECL_INCLUDE_MATH_H #include #include #include cl_object cl_abs(cl_object x) { @(return ecl_abs(x)); } static cl_object ecl_abs_fixnum(cl_object x) { return ecl_fixnum_minusp(x)? ecl_make_integer(-ecl_fixnum(x)) : x; } static cl_object ecl_abs_bignum(cl_object x) { return (_ecl_big_sign(x) < 0)? _ecl_big_negate(x) : x; } static cl_object ecl_abs_rational(cl_object x) { return (ecl_minusp(x->ratio.num))? ecl_make_ratio(ecl_negate(x->ratio.num), x->ratio.den) : x; } static cl_object ecl_abs_single_float(cl_object x) { float f = ecl_single_float(x); return (f < 0)? ecl_make_single_float(-f) : x; } static cl_object ecl_abs_double_float(cl_object x) { double f = ecl_double_float(x); return (f < 0)? ecl_make_double_float(-f) : x; } #ifdef ECL_LONG_FLOAT static cl_object ecl_abs_long_float(cl_object x) { long double f = ecl_long_float(x); return (f < 0)? ecl_make_long_float(-f) : x; } #endif static cl_object ecl_abs_complex(cl_object x) { /* Compute sqrt(r*r + i*i) carefully to prevent overflow. * Assume |i| >= |r|. Then sqrt(i*i + r*r) = |i|*sqrt(1 +(r/i)^2). */ cl_object r = ecl_abs(x->complex.real); cl_object i = ecl_abs(x->complex.imag); int comparison; comparison = ecl_number_compare(r, i); if (comparison == 0) { r = ecl_times(r, r); return ecl_sqrt(ecl_plus(r, r)); } else { if (comparison > 0) { cl_object aux = i; i = r; r = aux; } r = ecl_divide(r, i); r = ecl_plus(ecl_make_fixnum(1), ecl_times(r, r)); return ecl_times(cl_sqrt(r), i); } } MATH_DEF_DISPATCH1_NE(abs, @[abs], @[number], ecl_abs_fixnum, ecl_abs_bignum, ecl_abs_rational, ecl_abs_single_float, ecl_abs_double_float, ecl_abs_long_float, ecl_abs_complex); ecl-16.1.2/src/c/numbers/atan.d000066400000000000000000000120411266352375300161320ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* atan1.d -- Trascendental functions: arc tangent */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #define ECL_INCLUDE_MATH_H #include #include #include #pragma STDC FENV_ACCESS ON static double ecl_atan2_double(double y, double x) { if (signbit(x)) { if (signbit(y)) { return -ECL_PI_D + atan(-y / -x); } else if (y == 0) { return ECL_PI_D; } else { return ECL_PI_D - atan(y / -x); } } else if (x == 0) { if (signbit(y)) { return -ECL_PI2_D; } else if (y == 0) { return x / y; /* Produces a NaN */ } else { return ECL_PI2_D; } } else { if (signbit(y)) { return -atan(-y / x); } else if (y == 0) { return (double)0; } else { return atan(y / x); } } } #ifdef ECL_LONG_FLOAT static long double ecl_atan2_long_double(long double y, long double x) { if (signbit(x)) { if (signbit(y)) { return -ECL_PI_L + atanl(-y / -x); } else if (y == 0) { return ECL_PI_L; } else { return ECL_PI_L - atanl(y / -x); } } else if (x == 0) { if (signbit(y)) { return -ECL_PI2_L; } else if (y == 0) { return x / y; /* Produces a NaN */ } else { return ECL_PI2_L; } } else { if (signbit(y)) { return -atanl(-y / x); } else if (y == 0) { return (long double)0; } else { return atanl(y / x); } } } #endif cl_object ecl_atan2(cl_object y, cl_object x) { cl_object output; ECL_MATHERR_CLEAR; { #ifdef ECL_LONG_FLOAT int tx = ecl_t_of(x); int ty = ecl_t_of(y); if (tx < ty) tx = ty; if (tx == t_longfloat) { long double d = ecl_atan2_long_double(ecl_to_long_double(y), ecl_to_long_double(x)); output = ecl_make_long_float(d); } else { double dx = ecl_to_double(x); double dy = ecl_to_double(y); double dz = ecl_atan2_double(dy, dx); if (tx == t_doublefloat) { output = ecl_make_double_float(dz); } else { output = ecl_make_single_float(dz); } } #else double dy = ecl_to_double(y); double dx = ecl_to_double(x); double dz = ecl_atan2_double(dy, dx); if (ECL_DOUBLE_FLOAT_P(x) || ECL_DOUBLE_FLOAT_P(y)) { output = ecl_make_double_float(dz); } else { output = ecl_make_single_float(dz); } #endif } ECL_MATHERR_TEST; return output; } cl_object ecl_atan1(cl_object y) { if (ECL_COMPLEXP(y)) { #if 0 /* ANSI states it should be this first part */ cl_object z = ecl_times(cl_core.imag_unit, y); z = ecl_plus(ecl_log1(ecl_one_plus(z)), ecl_log1(ecl_minus(ecl_make_fixnum(1), z))); z = ecl_divide(z, ecl_times(ecl_make_fixnum(2), cl_core.imag_unit)); #else cl_object z1, z = ecl_times(cl_core.imag_unit, y); z = ecl_one_plus(z); z1 = ecl_times(y, y); z1 = ecl_one_plus(z1); z1 = ecl_sqrt(z1); z = ecl_divide(z, z1); z = ecl_log1(z); z = ecl_times(cl_core.minus_imag_unit, z); #endif /* ANSI */ return z; } else { return ecl_atan2(y, ecl_make_fixnum(1)); } } @(defun atan (x &optional (y OBJNULL)) @ /* INV: type check in ecl_atan() & ecl_atan2() */ /* FIXME ecl_atan() and ecl_atan2() produce generic errors without recovery and function information. */ if (y == OBJNULL) @(return ecl_atan1(x)) @(return ecl_atan2(x, y)) @) ecl-16.1.2/src/c/numbers/ceiling.d000066400000000000000000000210611266352375300166230ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* ceiling.d -- Implementation of CL:CEILING */ /* Copyright (c) 2010, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../../Copyright' for full details. */ #define ECL_INCLUDE_MATH_H #include #include #ifndef HAVE_ISOC99 # define ceilf ceil #endif #include @(defun ceiling (x &optional (y OBJNULL)) @ if (narg == 1) return ecl_ceiling1(x); else return ecl_ceiling2(x, y); @) cl_object ecl_ceiling1(cl_object x) { cl_object v0, v1; switch (ecl_t_of(x)) { case t_fixnum: case t_bignum: v0 = x; v1 = ecl_make_fixnum(0); break; case t_ratio: { const cl_env_ptr the_env = ecl_process_env(); v0 = ecl_ceiling2(x->ratio.num, x->ratio.den); v1 = ecl_make_ratio(ecl_nth_value(the_env, 1), x->ratio.den); break; } case t_singlefloat: { float d = ecl_single_float(x); float y = ceilf(d); v0 = _ecl_float_to_integer(y); v1 = ecl_make_single_float(d - y); break; } case t_doublefloat: { double d = ecl_double_float(x); double y = ceil(d); v0 = _ecl_double_to_integer(y); v1 = ecl_make_double_float(d - y); break; } #ifdef ECL_LONG_FLOAT case t_longfloat: { long double d = ecl_long_float(x); long double y = ceill(d); v0 = _ecl_long_double_to_integer(y); v1 = ecl_make_long_float(d - y); break; } #endif default: FEwrong_type_nth_arg(@[ceiling],1,x,@[real]); } @(return v0 v1) } cl_object ecl_ceiling2(cl_object x, cl_object y) { const cl_env_ptr the_env = ecl_process_env(); cl_object v0, v1; cl_type ty; ty = ecl_t_of(y); if (ecl_unlikely(!ECL_REAL_TYPE_P(ty))) { FEwrong_type_nth_arg(@[ceiling],2, y, @[real]); } switch(ecl_t_of(x)) { case t_fixnum: switch(ty) { case t_fixnum: { /* FIX / FIX */ cl_fixnum a = ecl_fixnum(x); cl_fixnum b = ecl_fixnum(y); cl_fixnum q = a / b; cl_fixnum r = a % b; if ((r^b) > 0 && r) { /* same signs and some remainder */ v0 = ecl_make_fixnum(q+1); v1 = ecl_make_fixnum(r-b); } else { v0 = ecl_make_fixnum(q); v1 = ecl_make_fixnum(r); } break; } case t_bignum: { /* FIX / BIG */ /* We must perform the division because there is the * pathological case * x = MOST_NEGATIVE_FIXNUM * y = - MOST_NEGATIVE_FIXNUM */ ECL_WITH_TEMP_BIGNUM(bx,4); _ecl_big_set_fixnum(bx, ecl_fixnum(x)); v0 = _ecl_big_ceiling(bx, y, &v1); break; } case t_ratio: /* FIX / RAT */ v0 = ecl_ceiling2(ecl_times(x, y->ratio.den), y->ratio.num); v1 = ecl_make_ratio(ecl_nth_value(the_env, 1), y->ratio.den); break; case t_singlefloat: { /* FIX / SF */ float n = ecl_single_float(y); float p = ecl_fixnum(x)/n; float q = ceilf(p); v0 = _ecl_float_to_integer(q); v1 = ecl_make_single_float(p*n - q*n); break; } case t_doublefloat: { /* FIX / DF */ double n = ecl_double_float(y); double p = ecl_fixnum(x)/n; double q = ceil(p); v0 = _ecl_double_to_integer(q); v1 = ecl_make_double_float(p*n - q*n); break; } #ifdef ECL_LONG_FLOAT case t_longfloat: { /* FIX / LF */ long double n = ecl_long_float(y); long double p = ecl_fixnum(x)/n; long double q = ceill(p); v0 = _ecl_long_double_to_integer(q); v1 = ecl_make_long_float(p*n - q*n); break; } #endif default: (void)0; /*Never reached */ } break; case t_bignum: switch(ecl_t_of(y)) { case t_fixnum: { /* BIG / FIX */ ECL_WITH_TEMP_BIGNUM(by,4); _ecl_big_set_fixnum(by, ecl_fixnum(y)); v0 = _ecl_big_ceiling(x, by, &v1); break; } case t_bignum: { /* BIG / BIG */ v0 = _ecl_big_ceiling(x, y, &v1); break; } case t_ratio: /* BIG / RAT */ v0 = ecl_ceiling2(ecl_times(x, y->ratio.den), y->ratio.num); v1 = ecl_make_ratio(ecl_nth_value(the_env, 1), y->ratio.den); break; case t_singlefloat: { /* BIG / SF */ float n = ecl_single_float(y); float p = _ecl_big_to_double(x)/n; float q = ceilf(p); v0 = _ecl_float_to_integer(q); v1 = ecl_make_single_float(p*n - q*n); break; } case t_doublefloat: { /* BIG / DF */ double n = ecl_double_float(y); double p = _ecl_big_to_double(x)/n; double q = ceil(p); v0 = _ecl_double_to_integer(q); v1 = ecl_make_double_float(p*n - q*n); break; } #ifdef ECL_LONG_FLOAT case t_longfloat: { /* BIG / LF */ long double n = ecl_long_float(y); long double p = _ecl_big_to_double(x)/n; long double q = ceill(p); v0 = _ecl_long_double_to_integer(q); v1 = ecl_make_long_float(p*n - q*n); break; } #endif default: (void)0; /*Never reached */ } break; case t_ratio: switch(ecl_t_of(y)) { case t_ratio: /* RAT / RAT */ v0 = ecl_ceiling2(ecl_times(x->ratio.num, y->ratio.den), ecl_times(x->ratio.den, y->ratio.num)); v1 = ecl_make_ratio(ecl_nth_value(the_env, 1), ecl_times(x->ratio.den, y->ratio.den)); break; default: /* RAT / ANY */ v0 = ecl_ceiling2(x->ratio.num, ecl_times(x->ratio.den, y)); v1 = ecl_divide(ecl_nth_value(the_env, 1), x->ratio.den); } break; case t_singlefloat: { /* SF / ANY */ float n = ecl_to_double(y); float p = ecl_single_float(x)/n; float q = ceilf(p); v0 = _ecl_float_to_integer(q); v1 = ecl_make_single_float(p*n - q*n); break; } case t_doublefloat: { /* DF / ANY */ double n = ecl_to_double(y); double p = ecl_double_float(x)/n; double q = ceil(p); v0 = _ecl_double_to_integer(q); v1 = ecl_make_double_float(p*n - q*n); break; } #ifdef ECL_LONG_FLOAT case t_longfloat: { /* LF / ANY */ long double n = ecl_to_long_double(y); long double p = ecl_long_float(x)/n; long double q = ceill(p); v0 = _ecl_long_double_to_integer(q); v1 = ecl_make_long_float(p*n - q*n); break; } #endif default: FEwrong_type_nth_arg(@[ceiling], 1, x, @[real]); } ecl_return2(the_env, v0, v1); } ecl-16.1.2/src/c/numbers/conjugate.d000066400000000000000000000024001266352375300171640ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* conjugate.d -- Trascendental functions: conjugateine */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #include cl_object cl_conjugate(cl_object x) { @(return ecl_conjugate(x)); } static cl_object ecl_conjugate_real(cl_object x) { return x; } static cl_object ecl_conjugate_complex(cl_object x) { return ecl_make_complex(x->complex.real, ecl_negate(x->complex.imag)); } MATH_DEF_DISPATCH1_NE(conjugate, @[conjugate], @[number], ecl_conjugate_real, ecl_conjugate_real, ecl_conjugate_real, ecl_conjugate_real, ecl_conjugate_real, ecl_conjugate_real, ecl_conjugate_complex); ecl-16.1.2/src/c/numbers/cos.d000066400000000000000000000036451266352375300160050ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* cos.d -- Trascendental functions: cosine */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #define ECL_INCLUDE_MATH_H #include #include #include #pragma STDC FENV_ACCESS ON cl_object cl_cos(cl_object x) { @(return ecl_cos(x)); } static cl_object ecl_cos_rational(cl_object x) { return ecl_make_single_float(cosf(ecl_to_float(x))); } static cl_object ecl_cos_single_float(cl_object x) { return ecl_make_single_float(cosf(ecl_single_float(x))); } static cl_object ecl_cos_double_float(cl_object x) { return ecl_make_double_float(cos(ecl_double_float(x))); } #ifdef ECL_LONG_FLOAT static cl_object ecl_cos_long_float(cl_object x) { return ecl_make_long_float(cosl(ecl_long_float(x))); } #endif static cl_object ecl_cos_complex(cl_object x) { /* z = x + I y cos(z) = cosh(I z) = cosh(-y + I x) */ cl_object dx = x->complex.real; cl_object dy = x->complex.imag; cl_object a = ecl_times(ecl_cos(dx), ecl_cosh(dy)); cl_object b = ecl_times(ecl_negate(ecl_sin(dx)), ecl_sinh(dy)); return ecl_make_complex(a, b); } MATH_DEF_DISPATCH1(cos, @[cos], @[number], ecl_cos_rational, ecl_cos_rational, ecl_cos_rational, ecl_cos_single_float, ecl_cos_double_float, ecl_cos_long_float, ecl_cos_complex); ecl-16.1.2/src/c/numbers/cosh.d000066400000000000000000000040521266352375300161460ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* cosh.d -- Trascendental functions: hyperbolic cosine */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #define ECL_INCLUDE_MATH_H #include #include #include #pragma STDC FENV_ACCESS ON cl_object cl_cosh(cl_object x) { @(return ecl_cosh(x)); } static cl_object ecl_cosh_rational(cl_object x) { return ecl_make_single_float(coshf(ecl_to_float(x))); } static cl_object ecl_cosh_single_float(cl_object x) { return ecl_make_single_float(coshf(ecl_single_float(x))); } static cl_object ecl_cosh_double_float(cl_object x) { return ecl_make_double_float(cosh(ecl_double_float(x))); } #ifdef ECL_LONG_FLOAT static cl_object ecl_cosh_long_float(cl_object x) { return ecl_make_long_float(coshl(ecl_long_float(x))); } #endif static cl_object ecl_cosh_complex(cl_object x) { /* z = x + I y cosh(z) = (exp(z)+exp(-z))/2 = (exp(x)*(cos(y)+Isin(y))+exp(-x)*(cos(y)-Isin(y)))/2 = cosh(x)*cos(y) + Isinh(x)*sin(y); */ cl_object dx = x->complex.real; cl_object dy = x->complex.imag; cl_object a = ecl_times(ecl_cosh(dx), ecl_cos(dy)); cl_object b = ecl_times(ecl_sinh(dx), ecl_sin(dy)); return ecl_make_complex(a, b); } MATH_DEF_DISPATCH1(cosh, @[cosh], @[number], ecl_cosh_rational, ecl_cosh_rational, ecl_cosh_rational, ecl_cosh_single_float, ecl_cosh_double_float, ecl_cosh_long_float, ecl_cosh_complex); ecl-16.1.2/src/c/numbers/divide.d000066400000000000000000000315231266352375300164610ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* divde.d -- Implementation of CL:/ */ /* Copyright (c) 2010, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../../Copyright' for full details. */ #include #include @(defun / (num &rest nums) @ /* INV: type check is in ecl_divide() */ if (narg == 0) FEwrong_num_arguments(@[/]); if (narg == 1) @(return ecl_divide(ecl_make_fixnum(1), num)) while (--narg) num = ecl_divide(num, ecl_va_arg(nums)); @(return num) @) #ifdef MATH_DISPATCH2_BEGIN static cl_object complex_divide(cl_object ar, cl_object ai, cl_object br, cl_object bi) { /* #C(z1 z2) = #C(xr xi) * #C(yr -yi) */ cl_object z1 = ecl_plus(ecl_times(ar, br), ecl_times(ai, bi)); cl_object z2 = ecl_minus(ecl_times(ai, br), ecl_times(ar, bi)); cl_object absB = ecl_plus(ecl_times(br, br), ecl_times(bi, bi)); return ecl_make_complex(ecl_divide(z1, absB), ecl_divide(z2, absB)); } cl_object ecl_divide(cl_object x, cl_object y) { MATH_DISPATCH2_BEGIN(x,y) { CASE_FIXNUM_FIXNUM; CASE_BIGNUM_FIXNUM { if (y == ecl_make_fixnum(0)) FEdivision_by_zero(x, y); } CASE_FIXNUM_BIGNUM; CASE_BIGNUM_BIGNUM { return ecl_make_ratio(x, y); } CASE_FIXNUM_RATIO; CASE_BIGNUM_RATIO { return ecl_make_ratio(ecl_times(x, y->ratio.den), y->ratio.num); } CASE_FIXNUM_SINGLE_FLOAT { return ecl_make_single_float(ecl_fixnum(x) / ecl_single_float(y)); } CASE_FIXNUM_DOUBLE_FLOAT { return ecl_make_double_float(ecl_fixnum(x) / ecl_double_float(y)); } CASE_BIGNUM_SINGLE_FLOAT; CASE_RATIO_SINGLE_FLOAT { return ecl_make_single_float(ecl_to_float(x) / ecl_single_float(y)); } CASE_BIGNUM_DOUBLE_FLOAT; CASE_RATIO_DOUBLE_FLOAT { return ecl_make_double_float(ecl_to_double(x) / ecl_double_float(y)); } CASE_RATIO_FIXNUM { if (y == ecl_make_fixnum(0)) { FEdivision_by_zero(x,y); } } CASE_RATIO_BIGNUM { cl_object z = ecl_times(x->ratio.den, y); return ecl_make_ratio(x->ratio.num, z); } CASE_RATIO_RATIO { cl_object num = ecl_times(x->ratio.num,y->ratio.den); cl_object den = ecl_times(x->ratio.den,y->ratio.num); return ecl_make_ratio(num, den); } CASE_SINGLE_FLOAT_FIXNUM { return ecl_make_single_float(ecl_single_float(x) / ecl_fixnum(y)); } CASE_SINGLE_FLOAT_BIGNUM; CASE_SINGLE_FLOAT_RATIO { return ecl_make_single_float(ecl_single_float(x) / ecl_to_float(y)); } CASE_SINGLE_FLOAT_SINGLE_FLOAT { return ecl_make_single_float(ecl_single_float(x) / ecl_single_float(y)); } CASE_SINGLE_FLOAT_DOUBLE_FLOAT { return ecl_make_double_float(ecl_single_float(x) / ecl_double_float(y)); } CASE_DOUBLE_FLOAT_FIXNUM { return ecl_make_double_float(ecl_double_float(x) / ecl_fixnum(y)); } CASE_DOUBLE_FLOAT_BIGNUM; CASE_DOUBLE_FLOAT_RATIO { return ecl_make_double_float(ecl_double_float(x) / ecl_to_double(y)); } CASE_DOUBLE_FLOAT_SINGLE_FLOAT { return ecl_make_double_float(ecl_double_float(x) / ecl_single_float(y)); } CASE_DOUBLE_FLOAT_DOUBLE_FLOAT { return ecl_make_double_float(ecl_double_float(x) / ecl_double_float(y)); } #ifdef ECL_LONG_FLOAT CASE_FIXNUM_LONG_FLOAT { return ecl_make_long_float(ecl_fixnum(x) / ecl_long_float(y)); } CASE_BIGNUM_LONG_FLOAT; CASE_RATIO_LONG_FLOAT { return ecl_make_long_float(ecl_to_long_double(x) / ecl_long_float(y)); } CASE_SINGLE_FLOAT_LONG_FLOAT { return ecl_make_long_float(ecl_single_float(x) / ecl_long_float(y)); } CASE_DOUBLE_FLOAT_LONG_FLOAT { return ecl_make_long_float(ecl_double_float(x) / ecl_long_float(y)); } CASE_LONG_FLOAT_FIXNUM { return ecl_make_long_float(ecl_long_float(x) / ecl_fixnum(y)); } CASE_LONG_FLOAT_BIGNUM; CASE_LONG_FLOAT_RATIO { return ecl_make_long_float(ecl_long_float(x) / ecl_to_long_double(y)); } CASE_LONG_FLOAT_SINGLE_FLOAT { return ecl_make_long_float(ecl_long_float(x) / ecl_single_float(y)); } CASE_LONG_FLOAT_DOUBLE_FLOAT { return ecl_make_long_float(ecl_long_float(x) / ecl_double_float(y)); } CASE_LONG_FLOAT_LONG_FLOAT { return ecl_make_long_float(ecl_long_float(x) / ecl_long_float(y)); } CASE_LONG_FLOAT_COMPLEX { goto COMPLEX_Y; } CASE_COMPLEX_LONG_FLOAT; { goto COMPLEX_X; } #endif CASE_COMPLEX_FIXNUM; CASE_COMPLEX_BIGNUM; CASE_COMPLEX_RATIO; CASE_COMPLEX_SINGLE_FLOAT; CASE_COMPLEX_DOUBLE_FLOAT; COMPLEX_X: { return ecl_make_complex(ecl_divide(x->complex.real, y), ecl_divide(x->complex.imag, y)); } CASE_BIGNUM_COMPLEX; CASE_RATIO_COMPLEX; CASE_SINGLE_FLOAT_COMPLEX; CASE_DOUBLE_FLOAT_COMPLEX; CASE_FIXNUM_COMPLEX { COMPLEX_Y: return complex_divide(x, ecl_make_fixnum(0), y->complex.real, y->complex.imag); } CASE_COMPLEX_COMPLEX { return complex_divide(x->complex.real, x->complex.imag, y->complex.real, y->complex.imag); } CASE_UNKNOWN(@[/],x,y,@[number]); } MATH_DISPATCH2_END; } #else cl_object ecl_divide(cl_object x, cl_object y) { cl_object z, z1, z2; switch (ecl_t_of(x)) { case t_fixnum: case t_bignum: switch (ecl_t_of(y)) { case t_fixnum: if (y == ecl_make_fixnum(0)) FEdivision_by_zero(x, y); case t_bignum: if (ecl_minusp(y) == TRUE) { x = ecl_negate(x); y = ecl_negate(y); } return ecl_make_ratio(x, y); case t_ratio: z = ecl_times(x, y->ratio.den); return ecl_make_ratio(z, y->ratio.num); case t_singlefloat: return ecl_make_single_float(ecl_to_double(x) / ecl_single_float(y)); case t_doublefloat: return ecl_make_double_float(ecl_to_double(x) / ecl_double_float(y)); #ifdef ECL_LONG_FLOAT case t_longfloat: return ecl_make_long_float(ecl_to_double(x) / ecl_long_float(y)); #endif case t_complex: goto COMPLEX; default: FEwrong_type_nth_arg(@[/], 2, y, @[number]); } case t_ratio: switch (ecl_t_of(y)) { case t_fixnum: if (y == ecl_make_fixnum(0)) FEdivision_by_zero(x, y); case t_bignum: z = ecl_times(x->ratio.den, y); return ecl_make_ratio(x->ratio.num, z); case t_ratio: z = ecl_times(x->ratio.num,y->ratio.den); z1 = ecl_times(x->ratio.den,y->ratio.num); return ecl_make_ratio(z, z1); case t_singlefloat: return ecl_make_single_float(ecl_to_double(x) / ecl_single_float(y)); case t_doublefloat: return ecl_make_double_float(ecl_to_double(x) / ecl_double_float(y)); #ifdef ECL_LONG_FLOAT case t_longfloat: return ecl_make_long_float(ecl_to_double(x) / ecl_long_float(y)); #endif case t_complex: goto COMPLEX; default: FEwrong_type_nth_arg(@[/], 2, y, @[number]); } case t_singlefloat: switch (ecl_t_of(y)) { case t_fixnum: return ecl_make_single_float(ecl_single_float(x) / ecl_fixnum(y)); case t_bignum: case t_ratio: return ecl_make_single_float(ecl_single_float(x) / ecl_to_double(y)); case t_singlefloat: return ecl_make_single_float(ecl_single_float(x) / ecl_single_float(y)); case t_doublefloat: return ecl_make_double_float(ecl_single_float(x) / ecl_double_float(y)); #ifdef ECL_LONG_FLOAT case t_longfloat: return ecl_make_long_float(ecl_single_float(x) / ecl_long_float(y)); #endif case t_complex: goto COMPLEX; default: FEwrong_type_nth_arg(@[/], 2, y, @[number]); } case t_doublefloat: switch (ecl_t_of(y)) { case t_fixnum: return ecl_make_double_float(ecl_double_float(x) / ecl_fixnum(y)); case t_bignum: case t_ratio: return ecl_make_double_float(ecl_double_float(x) / ecl_to_double(y)); case t_singlefloat: return ecl_make_double_float(ecl_double_float(x) / ecl_single_float(y)); case t_doublefloat: return ecl_make_double_float(ecl_double_float(x) / ecl_double_float(y)); #ifdef ECL_LONG_FLOAT case t_longfloat: return ecl_make_long_float(ecl_double_float(x) / ecl_long_float(y)); #endif case t_complex: goto COMPLEX; default: FEwrong_type_nth_arg(@[/], 2, y, @[number]); } #ifdef ECL_LONG_FLOAT case t_longfloat: switch (ecl_t_of(y)) { case t_fixnum: return ecl_make_long_float(ecl_long_float(x) / ecl_fixnum(y)); case t_bignum: case t_ratio: return ecl_make_long_float(ecl_long_float(x) / ecl_to_double(y)); case t_singlefloat: return ecl_make_long_float(ecl_long_float(x) / ecl_single_float(y)); case t_doublefloat: return ecl_make_long_float(ecl_long_float(x) / ecl_double_float(y)); case t_longfloat: return ecl_make_long_float(ecl_long_float(x) / ecl_long_float(y)); case t_complex: goto COMPLEX; default: FEwrong_type_nth_arg(@[/], 2, y, @[number]); } #endif case t_complex: if (ecl_t_of(y) != t_complex) { z1 = ecl_divide(x->complex.real, y); z2 = ecl_divide(x->complex.imag, y); return ecl_make_complex(z1, z2); } else if (1) { /* #C(z1 z2) = #C(xr xi) * #C(yr -yi) */ z1 = ecl_plus(ecl_times(x->complex.real, y->complex.real), ecl_times(x->complex.imag, y->complex.imag)); z2 = ecl_minus(ecl_times(x->complex.imag, y->complex.real), ecl_times(x->complex.real, y->complex.imag)); } else { COMPLEX: /* INV: x is real, y is complex */ /* #C(z1 z2) = x * #C(yr -yi) */ z1 = ecl_times(x, y->complex.real); z2 = ecl_negate(ecl_times(x, y->complex.imag)); } z = ecl_plus(ecl_times(y->complex.real, y->complex.real), ecl_times(y->complex.imag, y->complex.imag)); z = ecl_make_complex(ecl_divide(z1, z), ecl_divide(z2, z)); return(z); default: FEwrong_type_nth_arg(@[/], 1, x, @[number]); } } #endif ecl-16.1.2/src/c/numbers/exp.d000066400000000000000000000034611266352375300160110ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* sinh.d -- Trascendental functions: exponential */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #define ECL_INCLUDE_MATH_H #include #include #include #pragma STDC FENV_ACCESS ON cl_object cl_exp(cl_object x) { @(return ecl_exp(x)); } static cl_object ecl_exp_rational(cl_object x) { return ecl_make_single_float(expf(ecl_to_float(x))); } static cl_object ecl_exp_single_float(cl_object x) { return ecl_make_single_float(expf(ecl_single_float(x))); } static cl_object ecl_exp_double_float(cl_object x) { return ecl_make_double_float(exp(ecl_double_float(x))); } #ifdef ECL_LONG_FLOAT static cl_object ecl_exp_long_float(cl_object x) { return ecl_make_long_float(expl(ecl_long_float(x))); } #endif static cl_object ecl_exp_complex(cl_object x) { cl_object y, y1; y = x->complex.imag; x = ecl_exp(x->complex.real); y1 = ecl_cos(y); y = ecl_sin(y); y = ecl_make_complex(y1, y); return ecl_times(x, y); } MATH_DEF_DISPATCH1(exp, @[exp], @[number], ecl_exp_rational, ecl_exp_rational, ecl_exp_rational, ecl_exp_single_float, ecl_exp_double_float, ecl_exp_long_float, ecl_exp_complex); ecl-16.1.2/src/c/numbers/expt.d000066400000000000000000000101631266352375300161720ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* expt.d -- Exponentiate. */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #define ECL_INCLUDE_MATH_H #include #include #include #include #include #include /* for abort() */ #pragma STDC FENV_ACCESS ON cl_fixnum ecl_fixnum_expt(cl_fixnum x, cl_fixnum y) { cl_fixnum z = 1; while (y > 0) if (y%2 == 0) { x *= x; y /= 2; } else { z *= x; --y; } return(z); } cl_object cl_expt(cl_object x, cl_object y) { @(return ecl_expt(x, y)); } ecl_def_ct_single_float(singlefloat_one,1,static,const); ecl_def_ct_double_float(doublefloat_one,1,static,const); #ifdef ECL_LONG_FLOAT ecl_def_ct_long_float(longfloat_one,1,static,const); #endif static cl_object expt_zero(cl_object x, cl_object y) { cl_type ty, tx; cl_object z; ty = ecl_t_of(y); tx = ecl_t_of(x); if (ecl_unlikely(!ECL_NUMBER_TYPE_P(tx))) { FEwrong_type_nth_arg(@[expt], 1, x, @[number]); } /* INV: The most specific numeric types come first. */ switch ((ty > tx)? ty : tx) { case t_fixnum: case t_bignum: case t_ratio: return ecl_make_fixnum(1); case t_singlefloat: return singlefloat_one; case t_doublefloat: return doublefloat_one; #ifdef ECL_LONG_FLOAT case t_longfloat: return longfloat_one; #endif case t_complex: z = expt_zero((tx == t_complex)? x->complex.real : x, (ty == t_complex)? y->complex.real : y); return ecl_make_complex(z, ecl_make_fixnum(0)); default: /* We will never reach this */ abort(); } } cl_object ecl_expt(cl_object x, cl_object y) { cl_type ty, tx; cl_object z; if (ecl_unlikely(ecl_zerop(y))) { return expt_zero(x, y); } ty = ecl_t_of(y); tx = ecl_t_of(x); if (ecl_unlikely(!ECL_NUMBER_TYPE_P(tx))) { FEwrong_type_nth_arg(@[expt], 1, x, @[number]); } if (ecl_zerop(x)) { z = ecl_times(x, y); if (!ecl_plusp(ty==t_complex?y->complex.real:y)) z = ecl_divide(ecl_make_fixnum(1), z); } else if (ty != t_fixnum && ty != t_bignum) { /* The following could be just z = ecl_log1(x); however, Maxima expects EXPT to have double accuracy when the first argument is integer and the second is double-float */ z = ecl_log1(ecl_times(x, expt_zero(x, y))); z = ecl_times(z, y); z = ecl_exp(z); } else if (ecl_minusp(y)) { z = ecl_negate(y); z = ecl_expt(x, z); z = ecl_divide(ecl_make_fixnum(1), z); } else { ECL_MATHERR_CLEAR; z = ecl_make_fixnum(1); do { /* INV: ecl_integer_divide outputs an integer */ if (!ecl_evenp(y)) z = ecl_times(z, x); y = ecl_integer_divide(y, ecl_make_fixnum(2)); if (ecl_zerop(y)) break; x = ecl_times(x, x); } while (1); ECL_MATHERR_TEST; } return z; } ecl-16.1.2/src/c/numbers/float_fix_compare.d000066400000000000000000000047611266352375300207020ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* num_comp.c -- Comparisons on numbers. */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ /* * In Common Lisp, comparisons between floats and integers are performed * via an intermediate rationalization of the floating point number. In C, * on the other hand, the comparison is performed by converting the integer * into a floating point number. However, if the double type is too small * this may lead to a loss of precision and two numbers being told equal * when, by Common Lisp standards, would not. */ static int double_fix_compare(cl_fixnum n, double d) { if ((double)n < d) { return -1; } else if ((double)n > d) { return +1; } else if (sizeof(double) > sizeof(cl_fixnum)) { return 0; } else { /* When we reach here, the double type has no * significant decimal part. However, as explained * above, the double type is too small and integers * may coerce to the same double number giving a false * positive. Hence we perform the comparison in * integer space. */ cl_fixnum m = d; if (n == m) { return 0; } else if (n > m) { return +1; } else { return -1; } } } #ifdef ECL_LONG_FLOAT static int long_double_fix_compare(cl_fixnum n, long double d) { if ((long double)n < d) { return -1; } else if ((long double)n > d) { return +1; } else if (sizeof(long double) > sizeof(cl_fixnum)) { return 0; } else { cl_fixnum m = d; if (n == m) { return 0; } else if (n > m) { return +1; } else { return -1; } } } #endif ecl-16.1.2/src/c/numbers/floor.d000066400000000000000000000210541266352375300163340ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* floor.d -- Implementation of CL:FLOOR */ /* Copyright (c) 2010, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../../Copyright' for full details. */ #define ECL_INCLUDE_MATH_H #include #include #ifndef HAVE_ISOC99 # define floorf floor #endif #include #include @(defun floor (x &optional (y OBJNULL)) @ if (narg == 1) return ecl_floor1(x); else return ecl_floor2(x, y); @) cl_object ecl_floor1(cl_object x) { const cl_env_ptr the_env = ecl_process_env(); cl_object v0, v1; switch (ecl_t_of(x)) { case t_fixnum: case t_bignum: v0 = x; v1 = ecl_make_fixnum(0); break; case t_ratio: v0 = ecl_floor2(x->ratio.num, x->ratio.den); v1 = ecl_make_ratio(ecl_nth_value(the_env, 1), x->ratio.den); break; case t_singlefloat: { float d = ecl_single_float(x); float y = floorf(d); v0 = _ecl_float_to_integer(y); v1 = ecl_make_single_float(d - y); break; } case t_doublefloat: { double d = ecl_double_float(x); double y = floor(d); v0 = _ecl_double_to_integer(y); v1 = ecl_make_double_float(d - y); break; } #ifdef ECL_LONG_FLOAT case t_longfloat: { long double d = ecl_long_float(x); long double y = floorl(d); v0 = _ecl_long_double_to_integer(y); v1 = ecl_make_long_float(d - y); break; } #endif default: FEwrong_type_nth_arg(@[floor],1,x,@[real]); } ecl_return2(the_env, v0, v1); } cl_object ecl_floor2(cl_object x, cl_object y) { const cl_env_ptr the_env = ecl_process_env(); cl_object v0, v1; MATH_DISPATCH2_BEGIN(x,y) { CASE_FIXNUM_FIXNUM { cl_fixnum a = ecl_fixnum(x), b = ecl_fixnum(y); cl_fixnum q = a / b, r = a % b; if ((r^b) < 0 && r) { /* opposite sign and some remainder*/ v0 = ecl_make_fixnum(q-1); v1 = ecl_make_fixnum(r+b); } else { v0 = ecl_make_fixnum(q); v1 = ecl_make_fixnum(r); } break; } CASE_FIXNUM_BIGNUM { /* We must perform the division because there is the * pathological case * x = MOST_NEGATIVE_FIXNUM * y = - MOST_NEGATIVE_FIXNUM */ ECL_WITH_TEMP_BIGNUM(bx,4); _ecl_big_set_fixnum(bx, ecl_fixnum(x)); v0 = _ecl_big_floor(bx, y, &v1); break; } CASE_FIXNUM_RATIO { v0 = ecl_floor2(ecl_times(x, y->ratio.den), y->ratio.num); v1 = ecl_make_ratio(ecl_nth_value(the_env, 1), y->ratio.den); break; } CASE_FIXNUM_SINGLE_FLOAT { float n = ecl_single_float(y); float p = ecl_fixnum(x) / n; float q = floorf(p); v0 = _ecl_float_to_integer(q); v1 = ecl_make_single_float((p - q)*n); break; } CASE_FIXNUM_DOUBLE_FLOAT { double n = ecl_double_float(y); double p = ecl_fixnum(x) / n; double q = floor(p); v0 = _ecl_double_to_integer(q); v1 = ecl_make_double_float((p - q)*n); break; } #ifdef ECL_LONG_FLOAT CASE_FIXNUM_LONG_FLOAT { /* FIX / LF */ long double n = ecl_long_float(y); long double p = ecl_fixnum(x) / n; long double q = floorl(p); v0 = _ecl_long_double_to_integer(q); v1 = ecl_make_long_float((p - q)*n); break; } #endif CASE_BIGNUM_FIXNUM { ECL_WITH_TEMP_BIGNUM(by,4); _ecl_big_set_fixnum(by, ecl_fixnum(y)); v0 = _ecl_big_floor(x, by, &v1); break; } CASE_BIGNUM_BIGNUM { v0 = _ecl_big_floor(x, y, &v1); break; } CASE_BIGNUM_RATIO { v0 = ecl_floor2(ecl_times(x, y->ratio.den), y->ratio.num); v1 = ecl_make_ratio(ecl_nth_value(the_env, 1), y->ratio.den); break; } CASE_BIGNUM_SINGLE_FLOAT { float n = ecl_single_float(y); float p = _ecl_big_to_double(x) / n; float q = floorf(p); v0 = _ecl_float_to_integer(q); v1 = ecl_make_single_float((p - q)*n); break; } CASE_BIGNUM_DOUBLE_FLOAT { double n = ecl_double_float(y); double p = _ecl_big_to_double(x) / n; double q = floor(p); v0 = _ecl_double_to_integer(q); v1 = ecl_make_double_float((p - q)*n); break; } #ifdef ECL_LONG_FLOAT CASE_BIGNUM_LONG_FLOAT { long double n = ecl_long_float(y); long double p = _ecl_big_to_double(x) / n; long double q = floorl(p); v0 = _ecl_long_double_to_integer(q); v1 = ecl_make_long_float((p - q)*n); break; } #endif CASE_RATIO_RATIO { v0 = ecl_floor2(ecl_times(x->ratio.num, y->ratio.den), ecl_times(x->ratio.den, y->ratio.num)); v1 = ecl_make_ratio(ecl_nth_value(the_env, 1), ecl_times(x->ratio.den, y->ratio.den)); break; } CASE_RATIO_FIXNUM; CASE_RATIO_BIGNUM; CASE_RATIO_SINGLE_FLOAT; #ifdef ECL_LONG_FLOAT CASE_RATIO_LONG_FLOAT; #endif CASE_RATIO_DOUBLE_FLOAT { v0 = ecl_floor2(x->ratio.num, ecl_times(x->ratio.den, y)); v1 = ecl_divide(ecl_nth_value(the_env, 1), x->ratio.den); break; } CASE_SINGLE_FLOAT_FIXNUM; CASE_SINGLE_FLOAT_BIGNUM; CASE_SINGLE_FLOAT_RATIO; CASE_SINGLE_FLOAT_DOUBLE_FLOAT; #ifdef ECL_LONG_FLOAT CASE_SINGLE_FLOAT_LONG_FLOAT; #endif CASE_SINGLE_FLOAT_SINGLE_FLOAT { float n = ecl_to_double(y); float p = ecl_single_float(x)/n; float q = floorf(p); v0 = _ecl_float_to_integer(q); /* We cannot factor these two multiplications because * if we have signed zeros (1 - 1) * (-1) = -0 while * 1*(-1) - 1*(-1) = +0 */ v1 = ecl_make_single_float(p*n - q*n); break; } CASE_DOUBLE_FLOAT_FIXNUM; CASE_DOUBLE_FLOAT_BIGNUM; CASE_DOUBLE_FLOAT_RATIO; CASE_DOUBLE_FLOAT_SINGLE_FLOAT; #ifdef ECL_LONG_FLOAT CASE_DOUBLE_FLOAT_LONG_FLOAT; #endif CASE_DOUBLE_FLOAT_DOUBLE_FLOAT { double n = ecl_to_double(y); double p = ecl_double_float(x)/n; double q = floor(p); v0 = _ecl_double_to_integer(q); v1 = ecl_make_double_float(p*n - q*n); break; } #ifdef ECL_LONG_FLOAT CASE_LONG_FLOAT_FIXNUM; CASE_LONG_FLOAT_BIGNUM; CASE_LONG_FLOAT_RATIO; CASE_LONG_FLOAT_SINGLE_FLOAT; CASE_LONG_FLOAT_DOUBLE_FLOAT; CASE_LONG_FLOAT_LONG_FLOAT { long double n = ecl_to_long_double(y); long double p = ecl_long_float(x)/n; long double q = floorl(p); v0 = _ecl_long_double_to_integer(q); v1 = ecl_make_long_float(p*n - q*n); break; } #endif default: DISPATCH2_ERROR: { if (!ecl_realp(x)) FEwrong_type_nth_arg(@[floor], 1, x, @[real]); else FEwrong_type_nth_arg(@[floor], 2, y, @[real]); } } MATH_DISPATCH2_END; ecl_return2(the_env, v0, v1); } ecl-16.1.2/src/c/numbers/log.d000066400000000000000000000136671266352375300160070ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* log1.d -- Trascendental functions: log(x) */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #define ECL_INCLUDE_MATH_H #include #include #include #pragma STDC FENV_ACCESS ON static cl_object ecl_log1_complex_inner(cl_object r, cl_object i) { cl_object a = ecl_abs(r); cl_object p = ecl_abs(i); int rel = ecl_number_compare(a, p); if (rel > 0) { cl_object aux = p; p = a; a = aux; } else if (rel == 0) { /* if a == p, * log(sqrt(a^2+p^2)) = log(2a^2)/2 */ a = ecl_times(a, a); a = ecl_divide(ecl_log1(ecl_plus(a, a)), ecl_make_fixnum(2)); goto OUTPUT; } /* For the real part of the output we use the formula * log(sqrt(p^2 + a^2)) = log(sqrt(p^2*(1 + (a/p)^2))) * = log(p) + log(1 + (a/p)^2)/2; */ a = ecl_divide(a, p); a = ecl_plus(ecl_divide(ecl_log1p(ecl_times(a,a)), ecl_make_fixnum(2)), ecl_log1(p)); OUTPUT: p = ecl_atan2(i, r); return ecl_make_complex(a, p); } static cl_object ecl_log1_bignum(cl_object x) { if (ecl_minusp(x)) { return ecl_log1_complex_inner(x, ecl_make_fixnum(0)); } else { cl_fixnum l = ecl_integer_length(x) - 1; cl_object r = ecl_make_ratio(x, ecl_ash(ecl_make_fixnum(1), l)); float d = logf(ecl_to_float(r)) + l * logf(2.0); return ecl_make_single_float(d); } } static cl_object ecl_log1_rational(cl_object x) { float f = ecl_to_float(x); if (f < 0) return ecl_log1_complex_inner(x, ecl_make_fixnum(0)); return ecl_make_single_float(logf(ecl_to_float(x))); } static cl_object ecl_log1_single_float(cl_object x) { float f = ecl_single_float(x); if (isnan(f)) return x; if (f < 0) return ecl_log1_complex_inner(x, ecl_make_fixnum(0)); return ecl_make_single_float(logf(f)); } static cl_object ecl_log1_double_float(cl_object x) { double f = ecl_double_float(x); if (isnan(f)) return x; if (f < 0) return ecl_log1_complex_inner(x, ecl_make_fixnum(0)); return ecl_make_double_float(log(f)); } #ifdef ECL_LONG_FLOAT static cl_object ecl_log1_long_float(cl_object x) { long double f = ecl_long_float(x); if (isnan(f)) return x; if (f < 0) return ecl_log1_complex_inner(x, ecl_make_fixnum(0)); return ecl_make_long_float(logl(f)); } #endif static cl_object ecl_log1_complex(cl_object x) { return ecl_log1_complex_inner(x->complex.real, x->complex.imag); } MATH_DEF_DISPATCH1(log1, @[log], @[number], ecl_log1_rational, ecl_log1_bignum, ecl_log1_rational, ecl_log1_single_float, ecl_log1_double_float, ecl_log1_long_float, ecl_log1_complex); cl_object ecl_log2(cl_object x, cl_object y) { return ecl_divide(ecl_log1(y), ecl_log1(x)); } @(defun log (x &optional (y OBJNULL)) @ /* INV: type check in ecl_log1() and ecl_log2() */ if (y == OBJNULL) @(return ecl_log1(x)) @(return ecl_log2(y, x)) @) #ifndef HAVE_LOG1P double log1p(double x) { double u = 1.0 + x; if (u == 1) { return 0.0; } else { return (log(u) * x)/(u - 1.0); } } #endif #ifndef HAVE_LOG1PF float log1pf(float x) { float u = (float)1 + x; if (u == 1) { return (float)0; } else { return (logf(u) * x)/(u - (float)1); } } #endif #if !defined(HAVE_LOG1PL) && defined(ECL_LONG_FLOAT) long double log1pl(long double x) { long double u = (long double)1 + x; if (u == 1) { return (long double)1; } else { return (logl(u) * x)/(u - (long double)1); } } #endif cl_object si_log1p(cl_object x) { @(return ecl_log1p(x)); } static cl_object ecl_log1p_simple(cl_object x) { return ecl_log1_complex_inner(ecl_one_plus(x), ecl_make_fixnum(0)); } static cl_object ecl_log1p_rational(cl_object x) { float f = ecl_to_float(x); if (f < -1) return ecl_log1p_simple(x); return ecl_make_single_float(log1pf(ecl_to_float(x))); } static cl_object ecl_log1p_single_float(cl_object x) { float f = ecl_single_float(x); if (isnan(f)) return x; if (f < -1) return ecl_log1p_simple(x); return ecl_make_single_float(log1pf(f)); } static cl_object ecl_log1p_double_float(cl_object x) { double f = ecl_double_float(x); if (isnan(f)) return x; if (f < -1) return ecl_log1p_simple(x); return ecl_make_double_float(log1p(f)); } #ifdef ECL_LONG_FLOAT static cl_object ecl_log1p_long_float(cl_object x) { long double f = ecl_long_float(x); if (isnan(f)) return x; if (f < -1) return ecl_log1p_simple(x); return ecl_make_long_float(log1pl(f)); } #endif static cl_object ecl_log1p_complex(cl_object x) { return ecl_log1_complex_inner(ecl_one_plus(x->complex.real), x->complex.imag); } MATH_DEF_DISPATCH1(log1p, @[si::log1p], @[number], ecl_log1p_rational, ecl_log1p_simple, ecl_log1p_rational, ecl_log1p_single_float, ecl_log1p_double_float, ecl_log1p_long_float, ecl_log1p_complex); ecl-16.1.2/src/c/numbers/minmax.d000066400000000000000000000030211266352375300164760ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* minmax.c -- number sorting. */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include @(defun max (max &rest nums) @ /* INV: type check occurs in ecl_number_compare() for the rest of numbers, but for the first argument it happens in ecl_zerop(). */ if (narg-- == 1) { ecl_zerop(max); } else do { cl_object numi = ecl_va_arg(nums); if (ecl_number_compare(max, numi) < 0) max = numi; } while (--narg); @(return max) @) @(defun min (min &rest nums) @ /* INV: type check occurs in ecl_number_compare() for the rest of numbers, but for the first argument it happens in ecl_zerop(). */ if (narg-- == 1) { ecl_zerop(min); } else do { cl_object numi = ecl_va_arg(nums); if (ecl_number_compare(min, numi) > 0) min = numi; } while (--narg); @(return min) @) ecl-16.1.2/src/c/numbers/minus.d000066400000000000000000000320151266352375300163450ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* minus.d -- Implementation of CL:- */ /* Copyright (c) 2010, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../../Copyright' for full details. */ #include #include @(defun - (num &rest nums) cl_object diff; @ /* INV: argument type check in number_{negate,minus}() */ if (narg == 1) @(return ecl_negate(num)) for (diff = num; --narg; ) diff = ecl_minus(diff, ecl_va_arg(nums)); @(return diff) @) #ifdef MATH_DISPATCH2_BEGIN cl_object ecl_minus(cl_object x, cl_object y) { MATH_DISPATCH2_BEGIN(x,y) { CASE_FIXNUM_FIXNUM { return ecl_make_integer(ecl_fixnum(x) - ecl_fixnum(y)); } CASE_FIXNUM_BIGNUM { return _ecl_fix_minus_big(ecl_fixnum(x), y); } CASE_FIXNUM_RATIO; CASE_BIGNUM_RATIO { cl_object z = ecl_times(x, y->ratio.den); z = ecl_minus(z, y->ratio.num); return ecl_make_ratio(z, y->ratio.den); } CASE_FIXNUM_SINGLE_FLOAT { return ecl_make_single_float(ecl_fixnum(x) - ecl_single_float(y)); } CASE_FIXNUM_DOUBLE_FLOAT { return ecl_make_double_float(ecl_fixnum(x) - ecl_double_float(y)); } CASE_BIGNUM_FIXNUM { return _ecl_big_plus_fix(x, -ecl_fixnum(y)); } CASE_BIGNUM_BIGNUM { return _ecl_big_minus_big(x, y); } CASE_BIGNUM_SINGLE_FLOAT; CASE_RATIO_SINGLE_FLOAT { return ecl_make_single_float(ecl_to_float(x) - ecl_single_float(y)); } CASE_BIGNUM_DOUBLE_FLOAT; CASE_RATIO_DOUBLE_FLOAT { return ecl_make_double_float(ecl_to_double(x) - ecl_double_float(y)); } CASE_RATIO_FIXNUM; CASE_RATIO_BIGNUM { cl_object z = ecl_times(x->ratio.den, y); z = ecl_minus(x->ratio.num, z); return ecl_make_ratio(z, x->ratio.den); } CASE_RATIO_RATIO { cl_object z1 = ecl_times(x->ratio.num,y->ratio.den); cl_object z = ecl_times(x->ratio.den,y->ratio.num); z = ecl_minus(z1, z); z1 = ecl_times(x->ratio.den,y->ratio.den); return ecl_make_ratio(z, z1); } CASE_SINGLE_FLOAT_FIXNUM { return ecl_make_single_float(ecl_single_float(x) - ecl_fixnum(y)); } CASE_SINGLE_FLOAT_BIGNUM; CASE_SINGLE_FLOAT_RATIO { return ecl_make_single_float(ecl_single_float(x) - ecl_to_float(y)); } CASE_SINGLE_FLOAT_SINGLE_FLOAT { return ecl_make_single_float(ecl_single_float(x) - ecl_single_float(y)); } CASE_SINGLE_FLOAT_DOUBLE_FLOAT { return ecl_make_double_float(ecl_single_float(x) - ecl_double_float(y)); } CASE_DOUBLE_FLOAT_FIXNUM { return ecl_make_double_float(ecl_double_float(x) - ecl_fixnum(y)); } CASE_DOUBLE_FLOAT_BIGNUM; CASE_DOUBLE_FLOAT_RATIO { return ecl_make_double_float(ecl_double_float(x) - ecl_to_double(y)); } CASE_DOUBLE_FLOAT_SINGLE_FLOAT { return ecl_make_double_float(ecl_double_float(x) - ecl_single_float(y)); } CASE_DOUBLE_FLOAT_DOUBLE_FLOAT { return ecl_make_double_float(ecl_double_float(x) - ecl_double_float(y)); } #ifdef ECL_LONG_FLOAT CASE_FIXNUM_LONG_FLOAT { return ecl_make_long_float(ecl_fixnum(x) - ecl_long_float(y)); } CASE_BIGNUM_LONG_FLOAT { return ecl_make_long_float(ecl_to_long_double(x) - ecl_long_float(y)); } CASE_RATIO_LONG_FLOAT { return ecl_make_long_float(ecl_to_long_double(x) - ecl_long_float(y)); } CASE_SINGLE_FLOAT_LONG_FLOAT { return ecl_make_long_float(ecl_single_float(x) - ecl_long_float(y)); } CASE_DOUBLE_FLOAT_LONG_FLOAT { return ecl_make_long_float(ecl_double_float(x) - ecl_long_float(y)); } CASE_LONG_FLOAT_FIXNUM { return ecl_make_long_float(ecl_long_float(x) - ecl_fixnum(y)); } CASE_LONG_FLOAT_BIGNUM; CASE_LONG_FLOAT_RATIO { return ecl_make_long_float(ecl_long_float(x) - ecl_to_long_double(y)); } CASE_LONG_FLOAT_SINGLE_FLOAT { return ecl_make_long_float(ecl_long_float(x) - ecl_single_float(y)); } CASE_LONG_FLOAT_DOUBLE_FLOAT { return ecl_make_long_float(ecl_long_float(x) - ecl_double_float(y)); } CASE_LONG_FLOAT_LONG_FLOAT { return ecl_make_long_float(ecl_long_float(x) - ecl_long_float(y)); } CASE_LONG_FLOAT_COMPLEX { goto COMPLEX_Y; } CASE_COMPLEX_LONG_FLOAT; { goto COMPLEX_X; } #endif CASE_COMPLEX_FIXNUM; CASE_COMPLEX_BIGNUM; CASE_COMPLEX_RATIO; CASE_COMPLEX_SINGLE_FLOAT; CASE_COMPLEX_DOUBLE_FLOAT { COMPLEX_X: return ecl_make_complex(ecl_minus(x->complex.real, y), x->complex.imag); } CASE_BIGNUM_COMPLEX; CASE_RATIO_COMPLEX; CASE_SINGLE_FLOAT_COMPLEX; CASE_DOUBLE_FLOAT_COMPLEX; CASE_FIXNUM_COMPLEX { COMPLEX_Y: return ecl_make_complex(ecl_minus(x, y->complex.real), ecl_negate(y->complex.imag)); } CASE_COMPLEX_COMPLEX { cl_object z = ecl_minus(x->complex.real, y->complex.real); cl_object z1 = ecl_minus(x->complex.imag, y->complex.imag); return ecl_make_complex(z, z1); } CASE_UNKNOWN(@[-],x,y,@[number]); } MATH_DISPATCH2_END; } #else cl_object ecl_minus(cl_object x, cl_object y) { cl_fixnum i, j, k; cl_object z, z1; switch (ecl_t_of(x)) { case t_fixnum: switch(ecl_t_of(y)) { case t_fixnum: return ecl_make_integer(ecl_fixnum(x) - ecl_fixnum(y)); case t_bignum: return _ecl_fix_minus_big(ecl_fixnum(x), y); case t_ratio: z = ecl_times(x, y->ratio.den); z = ecl_minus(z, y->ratio.num); return ecl_make_ratio(z, y->ratio.den); case t_singlefloat: return ecl_make_single_float(ecl_fixnum(x) - ecl_single_float(y)); case t_doublefloat: return ecl_make_double_float(ecl_fixnum(x) - ecl_double_float(y)); #ifdef ECL_LONG_FLOAT case t_longfloat: return ecl_make_long_float(ecl_fixnum(x) - ecl_long_float(y)); #endif case t_complex: goto COMPLEX; default: FEwrong_type_nth_arg(@[-], 2, y, @[number]); } case t_bignum: switch (ecl_t_of(y)) { case t_fixnum: return _ecl_big_plus_fix(x, -ecl_fixnum(y)); case t_bignum: return _ecl_big_minus_big(x, y); case t_ratio: z = ecl_times(x, y->ratio.den); z = ecl_minus(z, y->ratio.num); return ecl_make_ratio(z, y->ratio.den); case t_singlefloat: return ecl_make_single_float(ecl_to_double(x) - ecl_single_float(y)); case t_doublefloat: return ecl_make_double_float(ecl_to_double(x) - ecl_double_float(y)); #ifdef ECL_LONG_FLOAT case t_longfloat: return ecl_make_long_float(ecl_to_double(x) - ecl_long_float(y)); #endif case t_complex: goto COMPLEX; default: FEwrong_type_nth_arg(@[-], 2, y, @[number]); } case t_ratio: switch (ecl_t_of(y)) { case t_fixnum: case t_bignum: z = ecl_times(x->ratio.den, y); z = ecl_minus(x->ratio.num, z); return ecl_make_ratio(z, x->ratio.den); case t_ratio: z = ecl_times(x->ratio.num,y->ratio.den); z1 = ecl_times(x->ratio.den,y->ratio.num); z = ecl_minus(z, z1); z1 = ecl_times(x->ratio.den,y->ratio.den); return ecl_make_ratio(z, z1); case t_singlefloat: return ecl_make_single_float(ecl_to_double(x) - ecl_single_float(y)); case t_doublefloat: return ecl_make_double_float(ecl_to_double(x) - ecl_double_float(y)); #ifdef ECL_LONG_FLOAT case t_longfloat: return ecl_make_long_float(ecl_to_double(x) - ecl_long_float(y)); #endif case t_complex: goto COMPLEX; default: FEwrong_type_nth_arg(@[-], 2, y, @[number]); } case t_singlefloat: switch (ecl_t_of(y)) { case t_fixnum: return ecl_make_single_float(ecl_single_float(x) - ecl_fixnum(y)); case t_bignum: case t_ratio: return ecl_make_single_float(ecl_single_float(x) - ecl_to_double(y)); case t_singlefloat: return ecl_make_single_float(ecl_single_float(x) - ecl_single_float(y)); case t_doublefloat: return ecl_make_double_float(ecl_single_float(x) - ecl_double_float(y)); #ifdef ECL_LONG_FLOAT case t_longfloat: return ecl_make_long_float(ecl_single_float(x) - ecl_long_float(y)); #endif case t_complex: goto COMPLEX; default: FEwrong_type_nth_arg(@[-], 2, y, @[number]); } case t_doublefloat: switch (ecl_t_of(y)) { case t_fixnum: return ecl_make_double_float(ecl_double_float(x) - ecl_fixnum(y)); case t_bignum: case t_ratio: return ecl_make_double_float(ecl_double_float(x) - ecl_to_double(y)); case t_singlefloat: return ecl_make_double_float(ecl_double_float(x) - ecl_single_float(y)); case t_doublefloat: return ecl_make_double_float(ecl_double_float(x) - ecl_double_float(y)); #ifdef ECL_LONG_FLOAT case t_longfloat: return ecl_make_long_float(ecl_double_float(x) - ecl_long_float(y)); #endif case t_complex: goto COMPLEX; default: FEwrong_type_nth_arg(@[-], 2, y, @[number]); } #ifdef ECL_LONG_FLOAT case t_longfloat: switch (ecl_t_of(y)) { case t_fixnum: return ecl_make_long_float(ecl_long_float(x) - fix(y)); case t_bignum: case t_ratio: return ecl_make_long_float(ecl_long_float(x) - ecl_to_double(y)); case t_singlefloat: return ecl_make_long_float(ecl_long_float(x) - ecl_single_float(y)); case t_doublefloat: return ecl_make_long_float(ecl_long_float(x) - ecl_double_float(y)); case t_longfloat: return ecl_make_long_float(ecl_long_float(x) - ecl_long_float(y)); case t_complex: goto COMPLEX; default: FEwrong_type_nth_arg(@[-], 2, y, @[number]); } #endif COMPLEX: return ecl_make_complex(ecl_minus(x, y->complex.real), ecl_negate(y->complex.imag)); case t_complex: if (ecl_t_of(y) != t_complex) { z = ecl_minus(x->complex.real, y); z1 = x->complex.imag; } else { z = ecl_minus(x->complex.real, y->complex.real); z1 = ecl_minus(x->complex.imag, y->complex.imag); } return ecl_make_complex(z, z1); default: FEwrong_type_nth_arg(@[-], 1, x, @[number]); } } #endif ecl-16.1.2/src/c/numbers/minusp.d000066400000000000000000000032041266352375300165230ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* minusp.d -- Implementation of CL:MINUSP */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #include cl_object cl_minusp(cl_object x) { /* INV: ecl_minusp() checks type */ @(return (ecl_minusp(x) ? ECL_T : ECL_NIL)) } static int ecl_minusp_fixnum(cl_object x) { return ecl_fixnum_minusp(x); } static int ecl_minusp_big(cl_object x) { return _ecl_big_sign(x) < 0; } static int ecl_minusp_ratio(cl_object x) { return ecl_minusp(x->ratio.num); } static int ecl_minusp_single_float(cl_object x) { return ecl_single_float(x) < 0; } static int ecl_minusp_double_float(cl_object x) { return ecl_double_float(x) < 0; } #ifdef ECL_LONG_FLOAT static int ecl_minusp_long_float(cl_object x) { return ecl_long_float(x) < 0; } #endif MATH_DEF_DISPATCH1_BOOL(minusp, @[minusp], @[real], ecl_minusp_fixnum, ecl_minusp_big, ecl_minusp_ratio, ecl_minusp_single_float, ecl_minusp_double_float, ecl_minusp_long_float, minuspfailed) ecl-16.1.2/src/c/numbers/negate.d000066400000000000000000000034621266352375300164610ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* negate.d -- Trascendental functions: negateine */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #include static cl_object ecl_negate_fix(cl_object x) { return ecl_make_integer(-ecl_fixnum(x)); } static cl_object ecl_negate_big(cl_object x) { return _ecl_big_negate(x); } static cl_object ecl_negate_ratio(cl_object x) { return ecl_make_ratio(ecl_negate(x->ratio.num), x->ratio.den); } static cl_object ecl_negate_single_float(cl_object x) { return ecl_make_single_float(-ecl_single_float(x)); } static cl_object ecl_negate_double_float(cl_object x) { return ecl_make_double_float(-ecl_double_float(x)); } #ifdef ECL_LONG_FLOAT static cl_object ecl_negate_long_float(cl_object x) { return ecl_make_long_float(-ecl_long_float(x)); } #endif static cl_object ecl_negate_complex(cl_object x) { return ecl_make_complex(ecl_negate(x->complex.real), ecl_negate(x->complex.imag)); } MATH_DEF_DISPATCH1_NE(negate, @[-], @[number], ecl_negate_fix, ecl_negate_big, ecl_negate_ratio, ecl_negate_single_float, ecl_negate_double_float, ecl_negate_long_float, ecl_negate_complex); ecl-16.1.2/src/c/numbers/number_compare.d000066400000000000000000000156551266352375300202230ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* number_compare.c -- number comparison. */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #include #include "numbers/float_fix_compare.d" /* The value of ecl_number_compare(x, y) is -1 if x < y 0 if x = y 1 if x > y. If x or y is not real, it fails. */ int ecl_number_compare(cl_object x, cl_object y) { cl_fixnum ix, iy; double dx, dy; #ifdef ECL_LONG_FLOAT long double ldx, ldy; #endif cl_type ty; BEGIN: ty = ecl_t_of(y); switch (ecl_t_of(x)) { case t_fixnum: ix = ecl_fixnum(x); switch (ty) { case t_fixnum: iy = ecl_fixnum(y); if (ix < iy) return(-1); else return(ix != iy); case t_bignum: /* INV: (= x y) can't be zero since fixnum != bignum */ return _ecl_big_sign(y) < 0? 1 : -1; case t_ratio: x = ecl_times(x, y->ratio.den); y = y->ratio.num; return(ecl_number_compare(x, y)); case t_singlefloat: return double_fix_compare(ix, ecl_single_float(y)); case t_doublefloat: return double_fix_compare(ix, ecl_double_float(y)); #ifdef ECL_LONG_FLOAT case t_longfloat: return long_double_fix_compare(ix, ecl_long_float(y)); #endif default: FEwrong_type_nth_arg(@[<], 2, y, @[real]); } case t_bignum: switch (ty) { case t_fixnum: return _ecl_big_sign(x) < 0 ? -1 : 1; case t_bignum: return(_ecl_big_compare(x, y)); case t_ratio: x = ecl_times(x, y->ratio.den); y = y->ratio.num; return(ecl_number_compare(x, y)); case t_singlefloat: case t_doublefloat: #ifdef ECL_LONG_FLOAT case t_longfloat: #endif y = cl_rational(y); goto BEGIN; default: FEwrong_type_nth_arg(@[<], 2, y, @[real]); } case t_ratio: switch (ty) { case t_fixnum: case t_bignum: y = ecl_times(y, x->ratio.den); x = x->ratio.num; return(ecl_number_compare(x, y)); case t_ratio: return(ecl_number_compare(ecl_times(x->ratio.num, y->ratio.den), ecl_times(y->ratio.num, x->ratio.den))); case t_singlefloat: case t_doublefloat: #ifdef ECL_LONG_FLOAT case t_longfloat: #endif y = cl_rational(y); goto BEGIN; default: FEwrong_type_nth_arg(@[<], 2, y, @[real]); } case t_singlefloat: dx = (double)(ecl_single_float(x)); goto DOUBLEFLOAT0; case t_doublefloat: dx = ecl_double_float(x); DOUBLEFLOAT0: switch (ty) { case t_fixnum: return -double_fix_compare(ecl_fixnum(y), dx); case t_bignum: case t_ratio: x = cl_rational(x); goto BEGIN; case t_singlefloat: dy = (double)(ecl_single_float(y)); break; case t_doublefloat: dy = ecl_double_float(y); break; #ifdef ECL_LONG_FLOAT case t_longfloat: ldx = dx; ldy = ecl_long_float(y); goto LONGFLOAT; #endif default: FEwrong_type_nth_arg(@[<], 2, y, @[real]); } DOUBLEFLOAT: if (dx == dy) return(0); else if (dx < dy) return(-1); else return(1); #ifdef ECL_LONG_FLOAT case t_longfloat: ldx = ecl_long_float(x); switch (ty) { case t_fixnum: return -long_double_fix_compare(ecl_fixnum(y), ldx); case t_bignum: case t_ratio: x = cl_rational(x); goto BEGIN; case t_singlefloat: ldy = ecl_single_float(y); break; case t_doublefloat: ldy = ecl_double_float(y); break; case t_longfloat: ldy = ecl_long_float(y); break; default: FEwrong_type_nth_arg(@[<], 2, y, @[real]); } LONGFLOAT: if (ldx == ldy) return 0; else if (ldx < ldy) return -1; else return 1; break; #endif default: FEwrong_type_nth_arg(@[<], 1, x, @[real]); } } static cl_object monotonic(int s, int t, int narg, ecl_va_list nums) { cl_object c, d; if (narg == 0) FEwrong_num_arguments_anonym(); /* INV: type check occurs in ecl_number_compare() */ for (c = ecl_va_arg(nums); --narg; c = d) { d = ecl_va_arg(nums); if (s*ecl_number_compare(d, c) < t) return1(ECL_NIL); } return1(ECL_T); } #define MONOTONIC(i, j) (cl_narg narg, ...) \ { ecl_va_list nums; ecl_va_start(nums, narg, narg, 0); \ return monotonic(i, j, narg, nums); } cl_object @<= MONOTONIC( 1, 0) cl_object @>= MONOTONIC(-1, 0) cl_object @< MONOTONIC( 1, 1) cl_object @> MONOTONIC(-1, 1) ecl-16.1.2/src/c/numbers/number_equalp.d000066400000000000000000000155271266352375300200620ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* number_compare.c -- number comparison and sorting. */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #include #include "numbers/float_fix_compare.d" @(defun = (num &rest nums) int i; @ /* ANSI: Need not signal error for 1 argument */ /* INV: For >= 2 arguments, ecl_number_equalp() performs checks */ for (i = 1; i < narg; i++) if (!ecl_number_equalp(num, ecl_va_arg(nums))) @(return ECL_NIL) @(return ECL_T) @) /* Returns 1 if both numbers compare to equal */ int ecl_number_equalp(cl_object x, cl_object y) { double dx; /* INV: (= fixnum bignum) => 0 */ /* INV: (= fixnum ratio) => 0 */ /* INV: (= bignum ratio) => 0 */ BEGIN: switch (ecl_t_of(x)) { case t_fixnum: switch (ecl_t_of(y)) { case t_fixnum: return x == y; case t_bignum: case t_ratio: return 0; case t_singlefloat: return double_fix_compare(ecl_fixnum(x), ecl_single_float(y)) == 0; case t_doublefloat: return double_fix_compare(ecl_fixnum(x), ecl_double_float(y)) == 0; #ifdef ECL_LONG_FLOAT case t_longfloat: return long_double_fix_compare(ecl_fixnum(x), ecl_long_float(y)) == 0; #endif case t_complex: goto Y_COMPLEX; default: FEwrong_type_nth_arg(@[=], 2, y, @[number]); } case t_bignum: switch (ecl_t_of(y)) { case t_fixnum: return 0; case t_bignum: return _ecl_big_compare(x, y)==0; case t_ratio: return 0; case t_singlefloat: case t_doublefloat: #ifdef ECL_LONG_FLOAT case t_longfloat: #endif y = cl_rational(y); goto BEGIN; case t_complex: goto Y_COMPLEX; default: FEwrong_type_nth_arg(@[=], 2, y, @[number]); } case t_ratio: switch (ecl_t_of(y)) { case t_fixnum: case t_bignum: return 0; case t_ratio: return (ecl_number_equalp(x->ratio.num, y->ratio.num) && ecl_number_equalp(x->ratio.den, y->ratio.den)); case t_singlefloat: case t_doublefloat: #ifdef ECL_LONG_FLOAT case t_longfloat: #endif y = cl_rational(y); goto BEGIN; case t_complex: goto Y_COMPLEX; default: FEwrong_type_nth_arg(@[=], 2, y, @[number]); } case t_singlefloat: dx = ecl_single_float(x); goto FLOAT_ECL; case t_doublefloat: dx = ecl_double_float(x); FLOAT_ECL: switch (ecl_t_of(y)) { case t_fixnum: return double_fix_compare(ecl_fixnum(y), dx) == 0; case t_bignum: case t_ratio: x = cl_rational(x); goto BEGIN; case t_singlefloat: return dx == ecl_single_float(y); case t_doublefloat: return dx == ecl_double_float(y); #ifdef ECL_LONG_FLOAT case t_longfloat: return dx == ecl_long_float(y); #endif case t_complex: goto Y_COMPLEX; default: FEwrong_type_nth_arg(@[=], 2, y, @[number]); } #ifdef ECL_LONG_FLOAT case t_longfloat: { long double dx = ecl_long_float(x); switch (ecl_t_of(y)) { case t_fixnum: return long_double_fix_compare(ecl_fixnum(y), dx) == 0; case t_bignum: case t_ratio: x = cl_rational(x); goto BEGIN; case t_singlefloat: return dx == ecl_single_float(y); case t_doublefloat: return dx == ecl_double_float(y); case t_longfloat: return dx == ecl_long_float(y); case t_complex: goto Y_COMPLEX; default: FEwrong_type_nth_arg(@[=], 2, y, @[number]); } } #endif Y_COMPLEX: if (!ecl_zerop(y->complex.imag)) return 0; return ecl_number_equalp(x, y->complex.real); case t_complex: switch (ecl_t_of(y)) { case t_complex: return (ecl_number_equalp(x->complex.real, y->complex.real) && ecl_number_equalp(x->complex.imag, y->complex.imag)); case t_fixnum: case t_bignum: case t_ratio: case t_singlefloat: case t_doublefloat: #ifdef ECL_LONG_FLOAT case t_longfloat: #endif if (ecl_zerop(x->complex.imag)) return ecl_number_equalp(x->complex.real, y) != 0; else return 0; default: FEwrong_type_nth_arg(@[=], 2, y, @[number]); } default: FEwrong_type_nth_arg(@[=], 1, x, @[number]); } } @(defun /= (&rest nums &aux numi) int i, j; @ if (narg == 0) FEwrong_num_arguments_anonym(); numi = ecl_va_arg(nums); for (i = 2; i<=narg; i++) { ecl_va_list numb; ecl_va_start(numb, narg, narg, 0); numi = ecl_va_arg(nums); for (j = 1; j #include static cl_object ecl_one_minus_fix(cl_object x) { if (x == ecl_make_fixnum(MOST_NEGATIVE_FIXNUM)) return ecl_make_integer(MOST_NEGATIVE_FIXNUM-1); return (cl_object)((cl_fixnum)x - ((cl_fixnum)ecl_make_fixnum(1) - ECL_FIXNUM_TAG)); } static cl_object ecl_one_minus_big(cl_object x) { return ecl_minus(x, ecl_make_fixnum(1)); } static cl_object ecl_one_minus_ratio(cl_object x) { return ecl_make_ratio(ecl_minus(x->ratio.num,x->ratio.den), x->ratio.den); } static cl_object ecl_one_minus_single_float(cl_object x) { return ecl_make_single_float(ecl_single_float(x) - 1); } static cl_object ecl_one_minus_double_float(cl_object x) { return ecl_make_double_float(ecl_double_float(x) - 1); } #ifdef ECL_LONG_FLOAT static cl_object ecl_one_minus_long_float(cl_object x) { return ecl_make_long_float(ecl_long_float(x) - 1); } #endif static cl_object ecl_one_minus_complex(cl_object x) { return ecl_make_complex(ecl_one_minus(x->complex.real), x->complex.imag); } MATH_DEF_DISPATCH1_NE(one_minus, @[1-], @[number], ecl_one_minus_fix, ecl_one_minus_big, ecl_one_minus_ratio, ecl_one_minus_single_float, ecl_one_minus_double_float, ecl_one_minus_long_float, ecl_one_minus_complex); /* (1- x) */ cl_object @1-(cl_object x) { /* INV: type check is in ecl_one_minus() */ @(return ecl_one_minus(x)) } ecl-16.1.2/src/c/numbers/one_plus.d000066400000000000000000000042101266352375300170320ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* one_plus.d -- Implementation of CL:1+ */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #include static cl_object ecl_one_plus_fix(cl_object x) { if (x == ecl_make_fixnum(MOST_POSITIVE_FIXNUM)) return ecl_make_integer(MOST_POSITIVE_FIXNUM+1); return (cl_object)((cl_fixnum)x + ((cl_fixnum)ecl_make_fixnum(1) - ECL_FIXNUM_TAG)); } static cl_object ecl_one_plus_big(cl_object x) { return ecl_plus(x, ecl_make_fixnum(1)); } static cl_object ecl_one_plus_ratio(cl_object x) { return ecl_make_ratio(ecl_plus(x->ratio.num,x->ratio.den), x->ratio.den); } static cl_object ecl_one_plus_single_float(cl_object x) { return ecl_make_single_float(ecl_single_float(x) + 1); } static cl_object ecl_one_plus_double_float(cl_object x) { return ecl_make_double_float(ecl_double_float(x) + 1); } #ifdef ECL_LONG_FLOAT static cl_object ecl_one_plus_long_float(cl_object x) { return ecl_make_long_float(ecl_long_float(x) + 1); } #endif static cl_object ecl_one_plus_complex(cl_object x) { return ecl_make_complex(ecl_one_plus(x->complex.real), x->complex.imag); } MATH_DEF_DISPATCH1_NE(one_plus, @[1+], @[number], ecl_one_plus_fix, ecl_one_plus_big, ecl_one_plus_ratio, ecl_one_plus_single_float, ecl_one_plus_double_float, ecl_one_plus_long_float, ecl_one_plus_complex); /* (1+ x) */ cl_object @1+(cl_object x) { /* INV: type check is in ecl_one_plus() */ @(return ecl_one_plus(x)) } ecl-16.1.2/src/c/numbers/plus.d000066400000000000000000000315411266352375300162000ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* plus.d -- Implementation of CL:+ */ /* Copyright (c) 2010, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../../Copyright' for full details. */ #include #include @(defun + (&rest nums) cl_object sum = ecl_make_fixnum(0); @ /* INV: type check is in ecl_plus() */ while (narg--) sum = ecl_plus(sum, ecl_va_arg(nums)); @(return sum) @) #ifdef MATH_DISPATCH2_BEGIN cl_object ecl_plus(cl_object x, cl_object y) { MATH_DISPATCH2_BEGIN(x,y) { CASE_FIXNUM_FIXNUM { return ecl_make_integer(ecl_fixnum(x) + ecl_fixnum(y)); } CASE_FIXNUM_BIGNUM { return _ecl_big_plus_fix(y, ecl_fixnum(x)); } CASE_FIXNUM_RATIO; CASE_BIGNUM_RATIO { cl_object z = ecl_times(x, y->ratio.den); z = ecl_plus(z, y->ratio.num); return ecl_make_ratio(z, y->ratio.den); } CASE_FIXNUM_SINGLE_FLOAT { return ecl_make_single_float(ecl_fixnum(x) + ecl_single_float(y)); } CASE_FIXNUM_DOUBLE_FLOAT { return ecl_make_double_float(ecl_fixnum(x) + ecl_double_float(y)); } CASE_BIGNUM_FIXNUM { return _ecl_big_plus_fix(x, ecl_fixnum(y)); } CASE_BIGNUM_BIGNUM { return _ecl_big_plus_big(x, y); } CASE_BIGNUM_SINGLE_FLOAT; CASE_RATIO_SINGLE_FLOAT { return ecl_make_single_float(ecl_to_float(x) + ecl_single_float(y)); } CASE_BIGNUM_DOUBLE_FLOAT; CASE_RATIO_DOUBLE_FLOAT { return ecl_make_double_float(ecl_to_double(x) + ecl_double_float(y)); } CASE_RATIO_FIXNUM; CASE_RATIO_BIGNUM { cl_object z = ecl_times(x->ratio.den, y); z = ecl_plus(x->ratio.num, z); return ecl_make_ratio(z, x->ratio.den); } CASE_RATIO_RATIO { cl_object z1 = ecl_times(x->ratio.num,y->ratio.den); cl_object z = ecl_times(x->ratio.den,y->ratio.num); z = ecl_plus(z1, z); z1 = ecl_times(x->ratio.den,y->ratio.den); return ecl_make_ratio(z, z1); } CASE_SINGLE_FLOAT_FIXNUM { return ecl_make_single_float(ecl_single_float(x) + ecl_fixnum(y)); } CASE_SINGLE_FLOAT_BIGNUM; CASE_SINGLE_FLOAT_RATIO { return ecl_make_single_float(ecl_single_float(x) + ecl_to_float(y)); } CASE_SINGLE_FLOAT_SINGLE_FLOAT { return ecl_make_single_float(ecl_single_float(x) + ecl_single_float(y)); } CASE_SINGLE_FLOAT_DOUBLE_FLOAT { return ecl_make_double_float(ecl_single_float(x) + ecl_double_float(y)); } CASE_DOUBLE_FLOAT_FIXNUM { return ecl_make_double_float(ecl_double_float(x) + ecl_fixnum(y)); } CASE_DOUBLE_FLOAT_BIGNUM; CASE_DOUBLE_FLOAT_RATIO { return ecl_make_double_float(ecl_double_float(x) + ecl_to_double(y)); } CASE_DOUBLE_FLOAT_SINGLE_FLOAT { return ecl_make_double_float(ecl_double_float(x) + ecl_single_float(y)); } CASE_DOUBLE_FLOAT_DOUBLE_FLOAT { return ecl_make_double_float(ecl_double_float(x) + ecl_double_float(y)); } #ifdef ECL_LONG_FLOAT CASE_FIXNUM_LONG_FLOAT { return ecl_make_long_float(ecl_fixnum(x) + ecl_long_float(y)); } CASE_BIGNUM_LONG_FLOAT { return ecl_make_long_float(ecl_to_long_double(x) + ecl_long_float(y)); } CASE_RATIO_LONG_FLOAT { return ecl_make_long_float(ecl_to_long_double(x) + ecl_long_float(y)); } CASE_SINGLE_FLOAT_LONG_FLOAT { return ecl_make_long_float(ecl_single_float(x) + ecl_long_float(y)); } CASE_DOUBLE_FLOAT_LONG_FLOAT { return ecl_make_long_float(ecl_double_float(x) + ecl_long_float(y)); } CASE_LONG_FLOAT_FIXNUM { return ecl_make_long_float(ecl_long_float(x) + ecl_fixnum(y)); } CASE_LONG_FLOAT_BIGNUM; CASE_LONG_FLOAT_RATIO { return ecl_make_long_float(ecl_long_float(x) + ecl_to_long_double(y)); } CASE_LONG_FLOAT_SINGLE_FLOAT { return ecl_make_long_float(ecl_long_float(x) + ecl_single_float(y)); } CASE_LONG_FLOAT_DOUBLE_FLOAT { return ecl_make_long_float(ecl_long_float(x) + ecl_double_float(y)); } CASE_LONG_FLOAT_LONG_FLOAT { return ecl_make_long_float(ecl_long_float(x) + ecl_long_float(y)); } CASE_LONG_FLOAT_COMPLEX { goto COMPLEX_Y; } CASE_COMPLEX_LONG_FLOAT; { goto COMPLEX_X; } #endif CASE_COMPLEX_FIXNUM; CASE_COMPLEX_BIGNUM; CASE_COMPLEX_RATIO; CASE_COMPLEX_SINGLE_FLOAT; CASE_COMPLEX_DOUBLE_FLOAT; COMPLEX_X: { cl_object aux = x; x = y; y = aux; goto COMPLEX_Y; } CASE_BIGNUM_COMPLEX; CASE_RATIO_COMPLEX; CASE_SINGLE_FLOAT_COMPLEX; CASE_DOUBLE_FLOAT_COMPLEX; CASE_FIXNUM_COMPLEX { COMPLEX_Y: return ecl_make_complex(ecl_plus(x, y->complex.real), y->complex.imag); } CASE_COMPLEX_COMPLEX { cl_object z = ecl_plus(x->complex.real, y->complex.real); cl_object z1 = ecl_plus(x->complex.imag, y->complex.imag); return ecl_make_complex(z, z1); } CASE_UNKNOWN(@[+],x,y,@[number]); } MATH_DISPATCH2_END; } #else cl_object ecl_plus(cl_object x, cl_object y) { cl_fixnum i, j; cl_object z, z1; switch (ecl_t_of(x)) { case t_fixnum: switch (ecl_t_of(y)) { case t_fixnum: return ecl_make_integer(ecl_fixnum(x) + ecl_fixnum(y)); case t_bignum: return _ecl_big_plus_fix(y, ecl_fixnum(x)); case t_ratio: z = ecl_times(x, y->ratio.den); z = ecl_plus(z, y->ratio.num); return ecl_make_ratio(z, y->ratio.den); case t_singlefloat: return ecl_make_single_float(ecl_fixnum(x) + ecl_single_float(y)); case t_doublefloat: return ecl_make_double_float(ecl_fixnum(x) + ecl_double_float(y)); #ifdef ECL_LONG_FLOAT case t_longfloat: return ecl_make_long_float(ecl_fixnum(x) + ecl_long_float(y)); #endif case t_complex: COMPLEX: /* INV: x is real, y is complex */ return ecl_make_complex(ecl_plus(x, y->complex.real), y->complex.imag); default: FEwrong_type_nth_arg(@[+], 2, y, @[number]); } case t_bignum: switch (ecl_t_of(y)) { case t_fixnum: return _ecl_big_plus_fix(x, ecl_fixnum(y)); case t_bignum: return _ecl_big_plus_big(x, y); case t_ratio: z = ecl_times(x, y->ratio.den); z = ecl_plus(z, y->ratio.num); return ecl_make_ratio(z, y->ratio.den); case t_singlefloat: return ecl_make_single_float(ecl_to_double(x) + ecl_single_float(y)); case t_doublefloat: return ecl_make_double_float(ecl_to_double(x) + ecl_double_float(y)); #ifdef ECL_LONG_FLOAT case t_longfloat: return ecl_make_long_float(ecl_to_double(x) + ecl_long_float(y)); #endif case t_complex: goto COMPLEX; default: FEwrong_type_nth_arg(@[+], 2, y, @[number]); } case t_ratio: switch (ecl_t_of(y)) { case t_fixnum: case t_bignum: z = ecl_times(x->ratio.den, y); z = ecl_plus(x->ratio.num, z); return ecl_make_ratio(z, x->ratio.den); case t_ratio: z1 = ecl_times(x->ratio.num,y->ratio.den); z = ecl_times(x->ratio.den,y->ratio.num); z = ecl_plus(z1, z); z1 = ecl_times(x->ratio.den,y->ratio.den); return ecl_make_ratio(z, z1); case t_singlefloat: return ecl_make_single_float(ecl_to_double(x) + ecl_single_float(y)); case t_doublefloat: return ecl_make_double_float(ecl_to_double(x) + ecl_double_float(y)); #ifdef ECL_LONG_FLOAT case t_longfloat: return ecl_make_long_float(ecl_to_double(x) + ecl_long_float(y)); #endif case t_complex: goto COMPLEX; default: FEwrong_type_nth_arg(@[+], 2, y, @[number]); } case t_singlefloat: switch (ecl_t_of(y)) { case t_fixnum: return ecl_make_single_float(ecl_single_float(x) + ecl_fixnum(y)); case t_bignum: case t_ratio: return ecl_make_single_float(ecl_single_float(x) + ecl_to_double(y)); case t_singlefloat: return ecl_make_single_float(ecl_single_float(x) + ecl_single_float(y)); case t_doublefloat: return ecl_make_double_float(ecl_single_float(x) + ecl_double_float(y)); #ifdef ECL_LONG_FLOAT case t_longfloat: return ecl_make_long_float(ecl_single_float(x) + ecl_long_float(y)); #endif case t_complex: goto COMPLEX; default: FEwrong_type_nth_arg(@[+], 2, y, @[number]); } case t_doublefloat: switch (ecl_t_of(y)) { case t_fixnum: return ecl_make_double_float(ecl_double_float(x) + ecl_fixnum(y)); case t_bignum: case t_ratio: return ecl_make_double_float(ecl_double_float(x) + ecl_to_double(y)); case t_singlefloat: return ecl_make_double_float(ecl_double_float(x) + ecl_single_float(y)); case t_doublefloat: return ecl_make_double_float(ecl_double_float(x) + ecl_double_float(y)); #ifdef ECL_LONG_FLOAT case t_longfloat: return ecl_make_long_float(ecl_double_float(x) + ecl_long_float(y)); #endif case t_complex: goto COMPLEX; default: FEwrong_type_nth_arg(@[+], 2, y, @[number]); } #ifdef ECL_LONG_FLOAT case t_longfloat: switch (ecl_t_of(y)) { case t_fixnum: return ecl_make_long_float(ecl_long_float(x) + ecl_fixnum(y)); case t_bignum: case t_ratio: return ecl_make_long_float(ecl_long_float(x) + ecl_to_double(y)); case t_singlefloat: return ecl_make_long_float(ecl_long_float(x) + ecl_single_float(y)); case t_doublefloat: return ecl_make_long_float(ecl_long_float(x) + ecl_double_float(y)); case t_longfloat: return ecl_make_long_float(ecl_long_float(x) + ecl_long_float(y)); case t_complex: goto COMPLEX; default: FEwrong_type_nth_arg(@[+], 2, y, @[number]); } #endif case t_complex: if (ecl_t_of(y) != t_complex) { cl_object aux = x; x = y; y = aux; goto COMPLEX; } z = ecl_plus(x->complex.real, y->complex.real); z1 = ecl_plus(x->complex.imag, y->complex.imag); return ecl_make_complex(z, z1); default: FEwrong_type_nth_arg(@[+], 1, x, @[number]); } } #endif ecl-16.1.2/src/c/numbers/plusp.d000066400000000000000000000031571266352375300163620ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* plusp.d -- Implementation of CL:PLUSP */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #include cl_object cl_plusp(cl_object x) { /* INV: ecl_plusp() checks type */ @(return (ecl_plusp(x) ? ECL_T : ECL_NIL)) } static int ecl_plusp_fixnum(cl_object x) { return ecl_fixnum_plusp(x); } static int ecl_plusp_big(cl_object x) { return _ecl_big_sign(x) > 0; } static int ecl_plusp_ratio(cl_object x) { return ecl_plusp(x->ratio.num); } static int ecl_plusp_single_float(cl_object x) { return ecl_single_float(x) > 0; } static int ecl_plusp_double_float(cl_object x) { return ecl_double_float(x) > 0; } #ifdef ECL_LONG_FLOAT static int ecl_plusp_long_float(cl_object x) { return ecl_long_float(x) > 0; } #endif MATH_DEF_DISPATCH1_BOOL(plusp, @[plusp], @[real], ecl_plusp_fixnum, ecl_plusp_big, ecl_plusp_ratio, ecl_plusp_single_float, ecl_plusp_double_float, ecl_plusp_long_float, pluspfailed) ecl-16.1.2/src/c/numbers/round.d000066400000000000000000000111021266352375300163330ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* round.d -- Implementation of CL:ROUND */ /* Copyright (c) 2010, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../../Copyright' for full details. */ #define ECL_INCLUDE_MATH_H #include #include #include #include #ifndef HAVE_ISOC99 # define floorf floor #endif #include @(defun round (x &optional (y OBJNULL)) @ if (narg == 1) return ecl_round1(x); else return ecl_round2(x, y); @) static cl_object number_remainder(cl_object x, cl_object y, cl_object q) { cl_object z; z = ecl_times(q, y); z = ecl_minus(x, z); return(z); } static double round_double(double d) { if (d >= 0) { double q = floor(d += 0.5); if (q == d) { int i = (int)fmod(q, 10); if (i & 1) { return q-1; } } return q; } else { return -round_double(-d); } } #ifdef ECL_LONG_FLOAT static long double round_long_double(long double d) { if (d >= 0) { long double q = floorl(d += 0.5); if (q == d) { int i = (int)fmodl(q, 10); if (i & 1) { return q-1; } } return q; } else { return -round_long_double(-d); } } #endif static cl_object ecl_round2_integer(const cl_env_ptr the_env, cl_object x, cl_object y, cl_object q) { cl_object q1 = ecl_integer_divide(q->ratio.num, q->ratio.den); cl_object r = ecl_minus(q, q1); if (ecl_minusp(r)) { int c = ecl_number_compare(cl_core.minus_half, r); if (c > 0 || (c == 0 && ecl_oddp(q1))) { q1 = ecl_one_minus(q1); } } else { int c = ecl_number_compare(r, cl_core.plus_half); if (c > 0 || (c == 0 && ecl_oddp(q1))) { q1 = ecl_one_plus(q1); } } r = number_remainder(x, y, q1); ecl_return2(the_env, q1, r); } cl_object ecl_round1(cl_object x) { const cl_env_ptr the_env = ecl_process_env(); cl_object v0, v1; switch (ecl_t_of(x)) { case t_fixnum: case t_bignum: v0 = x; v1 = ecl_make_fixnum(0); break; case t_ratio: v0 = ecl_round2_integer(the_env, x->ratio.num, x->ratio.den, x); v1 = ecl_make_ratio(ecl_nth_value(the_env, 1), x->ratio.den); break; case t_singlefloat: { float d = ecl_single_float(x); float q = round_double(d); v0 = _ecl_float_to_integer(q); v1 = ecl_make_single_float(d - q); break; } case t_doublefloat: { double d = ecl_double_float(x); double q = round_double(d); v0 = _ecl_double_to_integer(q); v1 = ecl_make_double_float(d - q); break; } #ifdef ECL_LONG_FLOAT case t_longfloat: { long double d = ecl_long_float(x); long double q = round_long_double(d); v0 = _ecl_long_double_to_integer(q); v1 = ecl_make_long_float(d - q); break; } #endif default: FEwrong_type_nth_arg(@[round],1,x,@[real]); } ecl_return2(the_env, v0, v1); } cl_object ecl_round2(cl_object x, cl_object y) { const cl_env_ptr the_env = ecl_process_env(); cl_object v0, v1; cl_object q; q = ecl_divide(x, y); switch (ecl_t_of(q)) { case t_fixnum: case t_bignum: v0 = q; v1 = ecl_make_fixnum(0); break; case t_ratio: return ecl_round2_integer(the_env, x, y, q); default: v0 = q = ecl_round1(q); v1 = number_remainder(x, y, q); } ecl_return2(the_env, v0, v1); } ecl-16.1.2/src/c/numbers/sin.d000066400000000000000000000036661266352375300160150ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* sin.d -- Trascendental functions: sine */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #define ECL_INCLUDE_MATH_H #include #include #include #pragma STDC FENV_ACCESS ON cl_object cl_sin(cl_object x) { @(return ecl_sin(x)); } static cl_object ecl_sin_rational(cl_object x) { return ecl_make_single_float(sinf(ecl_to_float(x))); } static cl_object ecl_sin_single_float(cl_object x) { return ecl_make_single_float(sinf(ecl_single_float(x))); } static cl_object ecl_sin_double_float(cl_object x) { return ecl_make_double_float(sin(ecl_double_float(x))); } #ifdef ECL_LONG_FLOAT static cl_object ecl_sin_long_float(cl_object x) { return ecl_make_long_float(sinl(ecl_long_float(x))); } #endif static cl_object ecl_sin_complex(cl_object x) { /* z = x + I y z = x + I y sin(z) = sinh(I z) = sinh(-y + I x) */ cl_object dx = x->complex.real; cl_object dy = x->complex.imag; cl_object a = ecl_times(ecl_sin(dx), ecl_cosh(dy)); cl_object b = ecl_times(ecl_cos(dx), ecl_sinh(dy)); return ecl_make_complex(a, b); } MATH_DEF_DISPATCH1(sin, @[sin], @[number], ecl_sin_rational, ecl_sin_rational, ecl_sin_rational, ecl_sin_single_float, ecl_sin_double_float, ecl_sin_long_float, ecl_sin_complex); ecl-16.1.2/src/c/numbers/sinh.d000066400000000000000000000040501266352375300161510ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* sinh.d -- Trascendental functions: hyperbolic sine */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #define ECL_INCLUDE_MATH_H #include #include #include #pragma STDC FENV_ACCESS ON cl_object cl_sinh(cl_object x) { @(return ecl_sinh(x)); } static cl_object ecl_sinh_rational(cl_object x) { return ecl_make_single_float(sinhf(ecl_to_float(x))); } static cl_object ecl_sinh_single_float(cl_object x) { return ecl_make_single_float(sinhf(ecl_single_float(x))); } static cl_object ecl_sinh_double_float(cl_object x) { return ecl_make_double_float(sinh(ecl_double_float(x))); } #ifdef ECL_LONG_FLOAT static cl_object ecl_sinh_long_float(cl_object x) { return ecl_make_long_float(sinhl(ecl_long_float(x))); } #endif static cl_object ecl_sinh_complex(cl_object x) { /* z = x + I y sinh(z) = (exp(z)-exp(-z))/2 = (exp(x)*(cos(y)+Isin(y))-exp(-x)*(cos(y)-Isin(y)))/2 = sinh(x)*cos(y) + Icosh(x)*sin(y); */ cl_object dx = x->complex.real; cl_object dy = x->complex.imag; cl_object a = ecl_times(ecl_sinh(dx), ecl_cos(dy)); cl_object b = ecl_times(ecl_cosh(dx), ecl_sin(dy)); return ecl_make_complex(a, b); } MATH_DEF_DISPATCH1(sinh, @[sinh], @[number], ecl_sinh_rational, ecl_sinh_rational, ecl_sinh_rational, ecl_sinh_single_float, ecl_sinh_double_float, ecl_sinh_long_float, ecl_sinh_complex); ecl-16.1.2/src/c/numbers/sqrt.d000066400000000000000000000047001266352375300162030ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* sqrt.d -- Square root. */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #define ECL_INCLUDE_MATH_H #include #include #include #pragma STDC FENV_ACCESS ON cl_object cl_sqrt(cl_object x) { @(return ecl_sqrt(x)); } static cl_object ecl_sqrt_rational(cl_object x) { if (ecl_minusp(x)) { x = ecl_sqrt_rational(ecl_negate(x)); return ecl_make_complex(ecl_make_fixnum(0), x); } else { return ecl_make_single_float(sqrtf(ecl_to_float(x))); } } static cl_object ecl_sqrt_single_float(cl_object x) { float f = ecl_single_float(x); if (f < 0) { return ecl_make_complex(ecl_make_fixnum(0), ecl_make_single_float(sqrtf(-f))); } else { return ecl_make_single_float(sqrtf(f)); } } static cl_object ecl_sqrt_double_float(cl_object x) { double f = ecl_double_float(x); if (f < 0) { return ecl_make_complex(ecl_make_fixnum(0), ecl_make_double_float(sqrt(-f))); } else { return ecl_make_double_float(sqrt(f)); } } #ifdef ECL_LONG_FLOAT static cl_object ecl_sqrt_long_float(cl_object x) { long double f = ecl_long_float(x); if (f < 0) { return ecl_make_complex(ecl_make_fixnum(0), ecl_make_long_float(sqrtl(-f))); } else { return ecl_make_long_float(sqrtl(f)); } } #endif static cl_object ecl_sqrt_complex(cl_object x) { return ecl_expt(x, cl_core.plus_half); } MATH_DEF_DISPATCH1(sqrt, @[sqrt], @[number], ecl_sqrt_rational, ecl_sqrt_rational, ecl_sqrt_rational, ecl_sqrt_single_float, ecl_sqrt_double_float, ecl_sqrt_long_float, ecl_sqrt_complex); ecl-16.1.2/src/c/numbers/tan.d000066400000000000000000000043661266352375300160040ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* tan.d -- Trascendental functions: tangent */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #define ECL_INCLUDE_MATH_H #include #include #include #pragma STDC FENV_ACCESS ON /* * As of 2006-10-13 I found this bug in GLIBC's tanf, which overflows * when the argument is pi/4. It is 2008 and this has not yet been * solved. Not only that, but if we use tan() on float, GCC automatically * and stupidly forces the use of tanf(). * As of 2013-03-31, this problem persists also on other platforms, such * as ARM, or PowerPC64. We thus extend the conditional to all GLIB copies. */ #if /*defined(__amd64__) && */ defined(__GLIBC__) static double safe_tanf(double x) { return tan(x); } #else # define safe_tanf(x) tanf(x) #endif cl_object cl_tan(cl_object x) { @(return ecl_tan(x)); } static cl_object ecl_tan_rational(cl_object x) { return ecl_make_single_float(safe_tanf(ecl_to_float(x))); } static cl_object ecl_tan_single_float(cl_object x) { return ecl_make_single_float(safe_tanf(ecl_single_float(x))); } static cl_object ecl_tan_double_float(cl_object x) { return ecl_make_double_float(tan(ecl_double_float(x))); } #ifdef ECL_LONG_FLOAT static cl_object ecl_tan_long_float(cl_object x) { return ecl_make_long_float(tanl(ecl_long_float(x))); } #endif static cl_object ecl_tan_complex(cl_object x) { cl_object a = ecl_sin(x); cl_object b = ecl_cos(x); return ecl_divide(a, b); } MATH_DEF_DISPATCH1(tan, @[tan], @[number], ecl_tan_rational, ecl_tan_rational, ecl_tan_rational, ecl_tan_single_float, ecl_tan_double_float, ecl_tan_long_float, ecl_tan_complex); ecl-16.1.2/src/c/numbers/tanh.d000066400000000000000000000033411266352375300161440ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* tanh.d -- Trascendental functions: hyperbolic tangent */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #define ECL_INCLUDE_MATH_H #include #include #include #pragma STDC FENV_ACCESS ON cl_object cl_tanh(cl_object x) { @(return ecl_tanh(x)); } static cl_object ecl_tanh_rational(cl_object x) { return ecl_make_single_float(tanhf(ecl_to_float(x))); } static cl_object ecl_tanh_single_float(cl_object x) { return ecl_make_single_float(tanhf(ecl_single_float(x))); } static cl_object ecl_tanh_double_float(cl_object x) { return ecl_make_double_float(tanh(ecl_double_float(x))); } #ifdef ECL_LONG_FLOAT static cl_object ecl_tanh_long_float(cl_object x) { return ecl_make_long_float(tanhl(ecl_long_float(x))); } #endif static cl_object ecl_tanh_complex(cl_object x) { cl_object a = ecl_sinh(x); cl_object b = ecl_cosh(x); return ecl_divide(a, b); } MATH_DEF_DISPATCH1(tanh, @[tanh], @[number], ecl_tanh_rational, ecl_tanh_rational, ecl_tanh_rational, ecl_tanh_single_float, ecl_tanh_double_float, ecl_tanh_long_float, ecl_tanh_complex); ecl-16.1.2/src/c/numbers/times.d000066400000000000000000000316751266352375300163460ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* times.d -- Implementation of CL:* */ /* Copyright (c) 2010, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../../Copyright' for full details. */ #include #include @(defun * (&rest nums) cl_object prod = ecl_make_fixnum(1); @ /* INV: type check in ecl_times() */ while (narg--) prod = ecl_times(prod, ecl_va_arg(nums)); @(return prod) @) #ifdef MATH_DISPATCH2_BEGIN cl_object ecl_times(cl_object x, cl_object y) { MATH_DISPATCH2_BEGIN(x,y) { CASE_FIXNUM_FIXNUM { return _ecl_fix_times_fix(ecl_fixnum(x), ecl_fixnum(y)); } CASE_FIXNUM_BIGNUM { return _ecl_big_times_fix(y, ecl_fixnum(x)); } CASE_FIXNUM_RATIO; CASE_BIGNUM_RATIO { return ecl_make_ratio(ecl_times(x, y->ratio.num), y->ratio.den); } CASE_FIXNUM_SINGLE_FLOAT { return ecl_make_single_float(ecl_fixnum(x) * ecl_single_float(y)); } CASE_FIXNUM_DOUBLE_FLOAT { return ecl_make_double_float(ecl_fixnum(x) * ecl_double_float(y)); } CASE_BIGNUM_FIXNUM { return _ecl_big_times_fix(x, ecl_fixnum(y)); } CASE_BIGNUM_BIGNUM { return _ecl_big_times_big(x, y); } CASE_BIGNUM_SINGLE_FLOAT { return ecl_make_single_float(ecl_to_float(x) * ecl_single_float(y)); } CASE_BIGNUM_DOUBLE_FLOAT { return ecl_make_double_float(ecl_to_double(x) * ecl_double_float(y)); } CASE_RATIO_FIXNUM; CASE_RATIO_BIGNUM { cl_object z = ecl_times(x->ratio.num, y); return ecl_make_ratio(z, x->ratio.den); } CASE_RATIO_RATIO { cl_object num = ecl_times(x->ratio.num,y->ratio.num); cl_object den = ecl_times(x->ratio.den,y->ratio.den); return ecl_make_ratio(num, den); } CASE_RATIO_SINGLE_FLOAT { return ecl_make_single_float(ecl_to_float(x) * ecl_single_float(y)); } CASE_RATIO_DOUBLE_FLOAT { return ecl_make_double_float(ecl_to_double(x) * ecl_double_float(y)); } CASE_SINGLE_FLOAT_FIXNUM { return ecl_make_single_float(ecl_single_float(x) * ecl_fixnum(y)); } CASE_SINGLE_FLOAT_BIGNUM; CASE_SINGLE_FLOAT_RATIO { return ecl_make_single_float(ecl_single_float(x) * ecl_to_float(y)); } CASE_SINGLE_FLOAT_SINGLE_FLOAT { return ecl_make_single_float(ecl_single_float(x) * ecl_single_float(y)); } CASE_SINGLE_FLOAT_DOUBLE_FLOAT { return ecl_make_double_float(ecl_single_float(x) * ecl_double_float(y)); } CASE_DOUBLE_FLOAT_FIXNUM { return ecl_make_double_float(ecl_double_float(x) * ecl_fixnum(y)); } CASE_DOUBLE_FLOAT_BIGNUM; CASE_DOUBLE_FLOAT_RATIO { return ecl_make_double_float(ecl_double_float(x) * ecl_to_double(y)); } CASE_DOUBLE_FLOAT_SINGLE_FLOAT { return ecl_make_double_float(ecl_double_float(x) * ecl_single_float(y)); } CASE_DOUBLE_FLOAT_DOUBLE_FLOAT { return ecl_make_double_float(ecl_double_float(x) * ecl_double_float(y)); } #ifdef ECL_LONG_FLOAT CASE_FIXNUM_LONG_FLOAT { return ecl_make_long_float(ecl_fixnum(x) * ecl_long_float(y)); } CASE_BIGNUM_LONG_FLOAT; CASE_RATIO_LONG_FLOAT { return ecl_make_long_float(ecl_to_long_double(x) * ecl_long_float(y)); } CASE_SINGLE_FLOAT_LONG_FLOAT { return ecl_make_long_float(ecl_single_float(x) * ecl_long_float(y)); } CASE_DOUBLE_FLOAT_LONG_FLOAT { return ecl_make_long_float(ecl_double_float(x) * ecl_long_float(y)); } CASE_LONG_FLOAT_FIXNUM { return ecl_make_long_float(ecl_long_float(x) * ecl_fixnum(y)); } CASE_LONG_FLOAT_BIGNUM; CASE_LONG_FLOAT_RATIO { return ecl_make_long_float(ecl_long_float(x) * ecl_to_long_double(y)); } CASE_LONG_FLOAT_SINGLE_FLOAT { return ecl_make_long_float(ecl_long_float(x) * ecl_single_float(y)); } CASE_LONG_FLOAT_DOUBLE_FLOAT { return ecl_make_long_float(ecl_long_float(x) * ecl_double_float(y)); } CASE_LONG_FLOAT_LONG_FLOAT { return ecl_make_long_float(ecl_long_float(x) * ecl_long_float(y)); } CASE_LONG_FLOAT_COMPLEX { goto COMPLEX_Y; } CASE_COMPLEX_LONG_FLOAT; { goto COMPLEX_X; } #endif CASE_COMPLEX_FIXNUM; CASE_COMPLEX_BIGNUM; CASE_COMPLEX_RATIO; CASE_COMPLEX_SINGLE_FLOAT; CASE_COMPLEX_DOUBLE_FLOAT; COMPLEX_X: { cl_object aux = x; x = y; y = aux; goto COMPLEX_Y; } CASE_BIGNUM_COMPLEX; CASE_RATIO_COMPLEX; CASE_SINGLE_FLOAT_COMPLEX; CASE_DOUBLE_FLOAT_COMPLEX; CASE_FIXNUM_COMPLEX { COMPLEX_Y: return ecl_make_complex(ecl_times(x, y->complex.real), ecl_times(x, y->complex.imag)); } CASE_COMPLEX_COMPLEX { cl_object z11 = ecl_times(x->complex.real, y->complex.real); cl_object z12 = ecl_times(x->complex.imag, y->complex.imag); cl_object z21 = ecl_times(x->complex.imag, y->complex.real); cl_object z22 = ecl_times(x->complex.real, y->complex.imag); return ecl_make_complex(ecl_minus(z11, z12), ecl_plus(z21, z22)); } CASE_UNKNOWN(@[*],x,y,@[number]); } MATH_DISPATCH2_END; } #else cl_object ecl_times(cl_object x, cl_object y) { cl_object z, z1; switch (ecl_t_of(x)) { case t_fixnum: switch (ecl_t_of(y)) { case t_fixnum: return _ecl_fix_times_fix(ecl_fixnum(x),ecl_fixnum(y)); case t_bignum: return _ecl_big_times_fix(y, ecl_fixnum(x)); case t_ratio: z = ecl_times(x, y->ratio.num); return ecl_make_ratio(z, y->ratio.den); case t_singlefloat: return ecl_make_single_float(ecl_fixnum(x) * ecl_single_float(y)); case t_doublefloat: return ecl_make_double_float(ecl_fixnum(x) * ecl_double_float(y)); #ifdef ECL_LONG_FLOAT case t_longfloat: return ecl_make_long_float(ecl_fixnum(x) * ecl_long_float(y)); #endif case t_complex: goto COMPLEX; default: FEwrong_type_nth_arg(@[*], 2, y, @[number]); } case t_bignum: switch (ecl_t_of(y)) { case t_fixnum: return _ecl_big_times_fix(x, ecl_fixnum(y)); case t_bignum: return _ecl_big_times_big(x, y); case t_ratio: z = ecl_times(x, y->ratio.num); return ecl_make_ratio(z, y->ratio.den); case t_singlefloat: return ecl_make_single_float(ecl_to_double(x) * ecl_single_float(y)); case t_doublefloat: return ecl_make_double_float(ecl_to_double(x) * ecl_double_float(y)); #ifdef ECL_LONG_FLOAT case t_longfloat: return ecl_make_long_float(ecl_to_double(x) * ecl_long_float(y)); #endif case t_complex: goto COMPLEX; default: FEwrong_type_nth_arg(@[*], 2, y, @[number]); } case t_ratio: switch (ecl_t_of(y)) { case t_fixnum: case t_bignum: z = ecl_times(x->ratio.num, y); return ecl_make_ratio(z, x->ratio.den); case t_ratio: z = ecl_times(x->ratio.num,y->ratio.num); z1 = ecl_times(x->ratio.den,y->ratio.den); return ecl_make_ratio(z, z1); case t_singlefloat: return ecl_make_single_float(ecl_to_double(x) * ecl_single_float(y)); case t_doublefloat: return ecl_make_double_float(ecl_to_double(x) * ecl_double_float(y)); #ifdef ECL_LONG_FLOAT case t_longfloat: return ecl_make_long_float(ecl_to_double(x) * ecl_long_float(y)); #endif case t_complex: goto COMPLEX; default: FEwrong_type_nth_arg(@[*], 2, y, @[number]); } case t_singlefloat: { float fx = ecl_single_float(x); switch (ecl_t_of(y)) { case t_fixnum: return ecl_make_single_float(fx * ecl_fixnum(y)); case t_bignum: case t_ratio: return ecl_make_single_float(fx * ecl_to_double(y)); case t_singlefloat: return ecl_make_single_float(fx * ecl_single_float(y)); case t_doublefloat: return ecl_make_double_float(fx * ecl_double_float(y)); #ifdef ECL_LONG_FLOAT case t_longfloat: return ecl_make_long_float(fx * ecl_long_float(y)); #endif case t_complex: goto COMPLEX; default: FEwrong_type_nth_arg(@[*], 2, y, @[number]); } } case t_doublefloat: { switch (ecl_t_of(y)) { case t_fixnum: return ecl_make_double_float(ecl_double_float(x) * ecl_fixnum(y)); case t_bignum: case t_ratio: return ecl_make_double_float(ecl_double_float(x) * ecl_to_double(y)); case t_singlefloat: return ecl_make_double_float(ecl_double_float(x) * ecl_single_float(y)); case t_doublefloat: return ecl_make_double_float(ecl_double_float(x) * ecl_double_float(y)); #ifdef ECL_LONG_FLOAT case t_longfloat: return ecl_make_long_float(ecl_double_float(x) * ecl_long_float(y)); #endif case t_complex: { COMPLEX: /* INV: x is real, y is complex */ return ecl_make_complex(ecl_times(x, y->complex.real), ecl_times(x, y->complex.imag)); } default: FEwrong_type_nth_arg(@[*], 2, y, @[number]); } } #ifdef ECL_LONG_FLOAT case t_longfloat: { long double lx = ecl_long_float(x); switch (ecl_t_of(y)) { case t_fixnum: return ecl_make_long_float(lx * ecl_fixnum(y)); case t_bignum: case t_ratio: return ecl_make_long_float(lx * ecl_to_double(y)); case t_singlefloat: return ecl_make_long_float(lx * ecl_single_float(y)); case t_doublefloat: return ecl_make_long_float(lx * ecl_double_float(y)); case t_longfloat: return ecl_make_long_float(lx * ecl_long_float(y)); case t_complex: goto COMPLEX; default: FEwrong_type_nth_arg(@[*], 2, y, @[number]); } } #endif case t_complex: { cl_object z11, z12, z21, z22; if (ecl_t_of(y) != t_complex) { cl_object aux = x; x = y; y = aux; goto COMPLEX; } z11 = ecl_times(x->complex.real, y->complex.real); z12 = ecl_times(x->complex.imag, y->complex.imag); z21 = ecl_times(x->complex.imag, y->complex.real); z22 = ecl_times(x->complex.real, y->complex.imag); return ecl_make_complex(ecl_minus(z11, z12), ecl_plus(z21, z22)); } default: FEwrong_type_nth_arg(@[*], 1, x, @[number]); } } #endif ecl-16.1.2/src/c/numbers/truncate.d000066400000000000000000000047441266352375300170470ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* truncate.d -- Implementation of CL:TRUNCATE */ /* Copyright (c) 2010, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../../Copyright' for full details. */ #define ECL_INCLUDE_MATH_H #include #include #ifndef HAVE_ISOC99 # define floorf floor # define ceilf ceil #endif #include cl_object ecl_truncate1(cl_object x) { cl_object v0, v1; switch (ecl_t_of(x)) { case t_fixnum: case t_bignum: v0 = x; v1 = ecl_make_fixnum(0); break; case t_ratio: if (ecl_plusp(x->ratio.num)) return ecl_floor1(x); else return ecl_ceiling1(x); case t_singlefloat: { float d = ecl_single_float(x); float y = d > 0? floorf(d) : ceilf(d); v0 = _ecl_float_to_integer(y); v1 = ecl_make_single_float(d - y); break; } case t_doublefloat: { double d = ecl_double_float(x); double y = d > 0? floor(d) : ceil(d); v0 = _ecl_double_to_integer(y); v1 = ecl_make_double_float(d - y); break; } #ifdef ECL_LONG_FLOAT case t_longfloat: { long double d = ecl_long_float(x); long double y = d > 0? floorl(d) : ceill(d); v0 = _ecl_long_double_to_integer(y); v1 = ecl_make_long_float(d - y); break; } #endif default: FEwrong_type_nth_arg(@[truncate],1,x,@[real]); } { const cl_env_ptr the_env = ecl_process_env(); ecl_return2(the_env, v0, v1); } } cl_object ecl_truncate2(cl_object x, cl_object y) { if (ecl_plusp(x) != ecl_plusp(y)) return ecl_ceiling2(x, y); else return ecl_floor2(x, y); } @(defun truncate (x &optional (y OBJNULL)) @ if (narg == 1) return ecl_truncate1(x); else return ecl_truncate2(x, y); @) ecl-16.1.2/src/c/numbers/zerop.d000066400000000000000000000032211266352375300163460ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* zerop.d -- Implementation of CL:ZEROP */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #include cl_object cl_zerop(cl_object x) { /* INV: ecl_zerop() checks type */ @(return (ecl_zerop(x) ? ECL_T : ECL_NIL)) } static int ecl_zerop_fixnum(cl_object x) { return x == ecl_make_fixnum(0); } static int ecl_zerop_ratio(cl_object x) { return 0; } static int ecl_zerop_single_float(cl_object x) { return ecl_single_float(x) == 0; } static int ecl_zerop_double_float(cl_object x) { return ecl_double_float(x) == 0; } #ifdef ECL_LONG_FLOAT static int ecl_zerop_long_float(cl_object x) { return ecl_long_float(x) == 0; } #endif static int ecl_zerop_complex(cl_object x) { return ecl_zerop(x->complex.real) && ecl_zerop(x->complex.imag); } MATH_DEF_DISPATCH1_BOOL(zerop, @[zerop], @[number], ecl_zerop_fixnum, ecl_zerop_ratio, ecl_zerop_ratio, ecl_zerop_single_float, ecl_zerop_double_float, ecl_zerop_long_float, ecl_zerop_complex) ecl-16.1.2/src/c/package.d000066400000000000000000001153631266352375300151420ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* package.d -- Packages. */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #include #include #include /******************************* ------- ******************************/ /* * NOTE 1: we only need to use the package locks when reading/writing the hash * tables, or changing the fields of a package. We do not need the locks to * read lists from the packages (i.e. list of shadowing symbols, used * packages, etc), or from the global environment (cl_core.packages_list) if * we do not destructively modify them (For instance, use ecl_remove_eq * instead of ecl_delete_eq). */ /* * NOTE 2: Operations between locks must be guaranteed not fail, or, if * they signal an error, they should undo all locks they had before. */ static cl_object find_symbol_inner(cl_object name, cl_object p, int *intern_flag); static void FEpackage_error(const char *message, cl_object package, int narg, ...) { ecl_va_list args; ecl_va_start(args, narg, narg, 0); si_signal_simple_error(6, @'package-error', ECL_NIL, /* not correctable */ make_constant_base_string(message), /* format control */ narg? cl_grab_rest_args(args) : cl_list(1,package), /* format args */ @':package', package); /* extra arguments */ } void CEpackage_error(const char *message, const char *continue_message, cl_object package, int narg, ...) { ecl_va_list args; ecl_va_start(args, narg, narg, 0); si_signal_simple_error(6, @'package-error', make_constant_base_string(continue_message), make_constant_base_string(message), /* format control */ narg? cl_grab_rest_args(args) : cl_list(1,package), @':package', package); } static bool member_string_eq(cl_object x, cl_object l) { /* INV: l is a proper list */ loop_for_on_unsafe(l) { if (ecl_string_eq(x, ECL_CONS_CAR(l))) return TRUE; } end_loop_for_on_unsafe(l); return FALSE; } #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__)) #define INLINE inline #else #define INLINE #endif static INLINE void symbol_remove_package(cl_object s, cl_object p) { if (Null(s)) s = ECL_NIL_SYMBOL; if (s->symbol.hpack == p) s->symbol.hpack = ECL_NIL; } static INLINE void symbol_add_package(cl_object s, cl_object p) { if (Null(s)) s = ECL_NIL_SYMBOL; if (s->symbol.hpack == ECL_NIL) s->symbol.hpack = p; } /* ecl_make_package(n, ns, ul) makes a package with name n, which must be a string or a symbol, and nicknames ns, which must be a list of strings or symbols, and uses packages in list ul, which must be a list of packages or package names i.e. strings or symbols. */ static cl_object make_package_hashtable() { return cl__make_hash_table(@'package', /* package hash table */ ecl_make_fixnum(128), /* initial size */ cl_core.rehash_size, cl_core.rehash_threshold); } static cl_object alloc_package(cl_object name) { cl_object p = ecl_alloc_object(t_package); p->pack.internal = make_package_hashtable(); p->pack.external = make_package_hashtable(); p->pack.name = name; p->pack.nicknames = ECL_NIL; p->pack.shadowings = ECL_NIL; p->pack.uses = ECL_NIL; p->pack.usedby = ECL_NIL; p->pack.locked = FALSE; return p; } cl_object _ecl_package_to_be_created(const cl_env_ptr env, cl_object name) { cl_object package = ecl_assoc(name, env->packages_to_be_created); if (Null(package)) { const cl_env_ptr env = ecl_process_env(); package = alloc_package(name); env->packages_to_be_created = cl_acons(name, package, env->packages_to_be_created); } else { package = ECL_CONS_CDR(package); } return package; } static cl_object find_pending_package(cl_env_ptr env, cl_object name, cl_object nicknames) { if (ecl_option_values[ECL_OPT_BOOTED]) { cl_object l = env->packages_to_be_created; while (!Null(l)) { cl_object pair = ECL_CONS_CAR(l); cl_object other_name = ECL_CONS_CAR(pair); if (ecl_equal(other_name, name) || _ecl_funcall5(@'member', other_name, nicknames, @':test', @'string=') != ECL_NIL) { cl_object x = ECL_CONS_CDR(pair); env->packages_to_be_created = ecl_remove_eq(pair, env->packages_to_be_created); return x; } l = ECL_CONS_CDR(l); } } return ECL_NIL; } static cl_object process_nicknames(cl_object nicknames) { cl_object l; nicknames = cl_copy_list(nicknames); for (l = nicknames; l != ECL_NIL; l = ECL_CONS_CDR(l)) ECL_RPLACA(l, cl_string(ECL_CONS_CAR(l))); return nicknames; } static cl_object process_package_list(cl_object packages) { cl_object l; packages = cl_copy_list(packages); for (l = packages; l != ECL_NIL; l = ECL_CONS_CDR(l)) ECL_RPLACA(l, si_coerce_to_package(ECL_CONS_CAR(l))); return packages; } cl_object ecl_make_package(cl_object name, cl_object nicknames, cl_object use_list) { const cl_env_ptr env = ecl_process_env(); cl_object x, other = ECL_NIL; /* Type checking, coercions, and the like, happen before we * acquire the lock */ name = cl_string(name); nicknames = process_nicknames(nicknames); use_list = process_package_list(use_list); ECL_WITH_GLOBAL_ENV_WRLOCK_BEGIN(env) { /* Find a similarly named package in the list of * packages to be created and use it or try to build a * new package */ x = find_pending_package(env, name, nicknames); if (Null(x)) { other = ecl_find_package_nolock(name); if (other != ECL_NIL) { goto OUTPUT; } else { x = alloc_package(name); } } loop_for_in(nicknames) { cl_object nick = ECL_CONS_CAR(nicknames); other = ecl_find_package_nolock(nick); if (other != ECL_NIL) { name = nick; goto OUTPUT; } x->pack.nicknames = CONS(nick, x->pack.nicknames); } end_loop_for_in; loop_for_in(use_list) { cl_object y = ECL_CONS_CAR(use_list); x->pack.uses = CONS(y, x->pack.uses); y->pack.usedby = CONS(x, y->pack.usedby); } end_loop_for_in; /* Finally, add it to the list of packages */ cl_core.packages = CONS(x, cl_core.packages); OUTPUT: (void)0; } ECL_WITH_GLOBAL_ENV_WRLOCK_END; if (!Null(other)) { CEpackage_error("A package with the name ~A already exists.", "Return existing package", other, 1, name); return other; } return x; } cl_object ecl_rename_package(cl_object x, cl_object name, cl_object nicknames) { bool error; name = cl_string(name); nicknames = process_nicknames(nicknames); x = si_coerce_to_package(x); if (x->pack.locked) { CEpackage_error("Cannot rename locked package ~S.", "Ignore lock and proceed", x, 0); } nicknames = ecl_cons(name, nicknames); error = 0; ECL_WITH_GLOBAL_ENV_WRLOCK_BEGIN(ecl_process_env()) { cl_object l; for (l = nicknames; l != ECL_NIL; l = ECL_CONS_CDR(l)) { cl_object nick = ECL_CONS_CAR(l); cl_object p = ecl_find_package_nolock(nick); if ((p != ECL_NIL) && (p != x)) { name = nick; error = 1; break; } } if (!error) { x->pack.name = name; x->pack.nicknames = ECL_CONS_CDR(nicknames); } } ECL_WITH_GLOBAL_ENV_WRLOCK_END; if (error) { FEpackage_error("A package with name ~S already exists.", x, 1, name); } return x; } /* ecl_find_package_nolock(n) seaches for a package with name n, where n is a valid string designator, or simply outputs n if it is a package. This is not a locking routine and someone may replace the list of packages while we are scanning it. Nevertheless, the list IS NOT be destructively modified, which means that we are on the safe side. Routines which need to ensure that the package list remains constant should enforce a global lock with PACKAGE_OP_LOCK(). */ cl_object ecl_find_package_nolock(cl_object name) { cl_object l, p; if (ECL_PACKAGEP(name)) return name; name = cl_string(name); l = cl_core.packages; loop_for_on_unsafe(l) { p = ECL_CONS_CAR(l); if (ecl_string_eq(name, p->pack.name)) return p; if (member_string_eq(name, p->pack.nicknames)) return p; } end_loop_for_on_unsafe(l); #ifdef ECL_RELATIVE_PACKAGE_NAMES /* Note that this function may actually be called _before_ symbols are set up * are bound! */ if (ecl_option_values[ECL_OPT_BOOTED] && ECL_SYM_VAL(ecl_process_env(), @'si::*relative-package-names*') != ECL_NIL) { return si_find_relative_package(1, name); } #endif return ECL_NIL; } cl_object ecl_find_package(const char *p) { ecl_def_ct_base_string(pack_name,p,strlen(p),,); return cl_find_package(pack_name); } cl_object si_coerce_to_package(cl_object p) { /* INV: ecl_find_package_nolock() signals an error if "p" is neither a package nor a string */ cl_object pp = ecl_find_package_nolock(p); if (Null(pp)) { FEpackage_error("There exists no package with name ~S", p, 0); } @(return pp); } cl_object ecl_current_package(void) { cl_object x = ecl_symbol_value(@'*package*'); unlikely_if (!ECL_PACKAGEP(x)) { const cl_env_ptr env = ecl_process_env(); ECL_SETQ(env, @'*package*', cl_core.user_package); FEerror("The value of *PACKAGE*, ~S, was not a package", 1, x); } return x; } /* Ecl_Intern(st, p) interns string st in package p. */ cl_object _ecl_intern(const char *s, cl_object p) { int intern_flag; cl_object str = make_constant_base_string(s); return ecl_intern(str, p, &intern_flag); } cl_object ecl_intern(cl_object name, cl_object p, int *intern_flag) { cl_object s; bool error, ignore_error = 0; if (ecl_unlikely(!ECL_STRINGP(name))) FEwrong_type_nth_arg(@[intern], 1, name, @[string]); p = si_coerce_to_package(p); AGAIN: ECL_WITH_GLOBAL_ENV_WRLOCK_BEGIN(ecl_process_env()) { s = find_symbol_inner(name, p, intern_flag); if (*intern_flag) { error = 0; } else if (p->pack.locked && !ignore_error) { error = 1; } else { s = cl_make_symbol(name); s->symbol.hpack = p; *intern_flag = 0; if (p == cl_core.keyword_package) { ecl_symbol_type_set(s, ecl_symbol_type(s) | ecl_stp_constant); ECL_SET(s, s); p->pack.external = _ecl_sethash(name, p->pack.external, s); } else { p->pack.internal = _ecl_sethash(name, p->pack.internal, s); } error = 0; } } ECL_WITH_GLOBAL_ENV_WRLOCK_END; if (error) { CEpackage_error("Cannot intern symbol ~S in locked package ~S.", "Ignore lock and proceed", p, 2, name, p); ignore_error = 1; goto AGAIN; } return s; } /* find_symbol_inner(st, len, p) searches for string st of length len in package p. */ static cl_object find_symbol_inner(cl_object name, cl_object p, int *intern_flag) { cl_object s, ul; s = ecl_gethash_safe(name, p->pack.external, OBJNULL); if (s != OBJNULL) { *intern_flag = ECL_EXTERNAL; goto OUTPUT; } if (p == cl_core.keyword_package) goto NOTHING; s = ecl_gethash_safe(name, p->pack.internal, OBJNULL); if (s != OBJNULL) { *intern_flag = ECL_INTERNAL; goto OUTPUT; } ul = p->pack.uses; loop_for_on_unsafe(ul) { s = ecl_gethash_safe(name, ECL_CONS_CAR(ul)->pack.external, OBJNULL); if (s != OBJNULL) { *intern_flag = ECL_INHERITED; goto OUTPUT; } } end_loop_for_on_unsafe(ul); NOTHING: *intern_flag = 0; s = ECL_NIL; OUTPUT: return s; } cl_object ecl_find_symbol(cl_object n, cl_object p, int *intern_flag) { cl_object s; if (ecl_unlikely(!ECL_STRINGP(n))) FEwrong_type_nth_arg(@[find-symbol], 1, n, @[string]); p = si_coerce_to_package(p); ECL_WITH_GLOBAL_ENV_RDLOCK_BEGIN(ecl_process_env()) { s = find_symbol_inner(n, p, intern_flag); } ECL_WITH_GLOBAL_ENV_RDLOCK_END; return s; } static cl_object potential_unintern_conflict(cl_object name, cl_object s, cl_object p) { cl_object x = OBJNULL; cl_object l = p->pack.uses; loop_for_on_unsafe(l) { cl_object other_p = ECL_CONS_CAR(l); cl_object y = ecl_gethash_safe(name, other_p->pack.external, OBJNULL); if (y != OBJNULL) { if (x == OBJNULL) { x = y; } else if (x != y) { return ecl_cons(x, y); } } } end_loop_for_on_unsafe(l); return ECL_NIL; } bool ecl_unintern(cl_object s, cl_object p) { cl_object conflict; bool output = FALSE; cl_object name = ecl_symbol_name(s); p = si_coerce_to_package(p); if (p->pack.locked) { CEpackage_error("Cannot unintern symbol ~S from locked package ~S.", "Ignore lock and proceed", p, 2, s, p); } conflict = ECL_NIL; ECL_WITH_GLOBAL_ENV_WRLOCK_BEGIN(ecl_process_env()) { cl_object hash = p->pack.internal; cl_object x = ecl_gethash_safe(name, hash, OBJNULL); if (x != s) { hash = p->pack.external; x = ecl_gethash_safe(name, hash, OBJNULL); if (x != s) goto OUTPUT; } if (ecl_member_eq(s, p->pack.shadowings)) { conflict = potential_unintern_conflict(name, s, p); if (conflict != ECL_NIL) { goto OUTPUT; } p->pack.shadowings = ecl_remove_eq(s, p->pack.shadowings); } ecl_remhash(name, hash); symbol_remove_package(s, p); output = TRUE; OUTPUT: (void)0; } ECL_WITH_GLOBAL_ENV_WRLOCK_END; if (conflict != ECL_NIL) { FEpackage_error("Cannot unintern the shadowing symbol ~S~%" "from ~S,~%" "because ~S and ~S will cause~%" "a name conflict.", p, 4, s, p, ECL_CONS_CAR(conflict), ECL_CONS_CDR(conflict)); } return output; } static cl_object potential_export_conflict(cl_object name, cl_object s, cl_object p) { cl_object l = p->pack.usedby; loop_for_on_unsafe(l) { int intern_flag; cl_object other_p = ECL_CONS_CAR(l); cl_object x = find_symbol_inner(name, other_p, &intern_flag); if (intern_flag && s != x && !ecl_member_eq(x, other_p->pack.shadowings)) { return other_p; } } end_loop_for_on_unsafe(l); return ECL_NIL; } void cl_export2(cl_object s, cl_object p) { int intern_flag, error; cl_object other_p, name = ecl_symbol_name(s); p = si_coerce_to_package(p); if (p->pack.locked) CEpackage_error("Cannot export symbol ~S from locked package ~S.", "Ignore lock and proceed", p, 2, s, p); AGAIN: ECL_WITH_GLOBAL_ENV_WRLOCK_BEGIN(ecl_process_env()) { cl_object x = find_symbol_inner(name, p, &intern_flag); if (!intern_flag) { error = 1; } else if (x != s) { error = 2; } else if (intern_flag == ECL_EXTERNAL) { error = 0; } else if ((other_p = potential_export_conflict(name, s, p)) != ECL_NIL) { error = 3; } else { if (intern_flag == ECL_INTERNAL) ecl_remhash(name, p->pack.internal); p->pack.external = _ecl_sethash(name, p->pack.external, s); error = 0; } } ECL_WITH_GLOBAL_ENV_WRLOCK_END; if (error == 1) { CEpackage_error("The symbol ~S is not accessible from ~S " "and cannot be exported.", "Import the symbol in the package and proceed.", p, 2, s, p); cl_import2(s, p); goto AGAIN; } else if (error == 2) { FEpackage_error("Cannot export the symbol ~S from ~S,~%" "because there is already a symbol with the same name~%" "in the package.", p, 2, s, p); } else if (error == 3) { FEpackage_error("Cannot export the symbol ~S~%" "from ~S,~%" "because it will cause a name conflict~%" "in ~S.", p, 3, s, p, other_p); } } cl_object cl_delete_package(cl_object p) { cl_object hash, l; cl_index i; /* 1) Try to remove the package from the global list */ p = ecl_find_package_nolock(p); if (Null(p)) { CEpackage_error("Package ~S not found. Cannot delete it.", "Ignore error and continue", p, 0); @(return ECL_NIL); } if (p->pack.locked) CEpackage_error("Cannot delete locked package ~S.", "Ignore lock and proceed", p, 0); if (p == cl_core.lisp_package || p == cl_core.keyword_package) { FEpackage_error("Cannot remove package ~S", p, 0); } /* 2) Now remove the package from the other packages that use it * and empty the package. */ if (Null(p->pack.name)) { @(return ECL_NIL) } while (!Null(l = p->pack.uses)) { ecl_unuse_package(ECL_CONS_CAR(l), p); } while (!Null(l = p->pack.usedby)) { ecl_unuse_package(p, ECL_CONS_CAR(l)); } ECL_WITH_GLOBAL_ENV_WRLOCK_BEGIN(ecl_process_env()) { for (hash = p->pack.internal, i = 0; i < hash->hash.size; i++) if (hash->hash.data[i].key != OBJNULL) { cl_object s = hash->hash.data[i].value; symbol_remove_package(s, p); } cl_clrhash(p->pack.internal); for (hash = p->pack.external, i = 0; i < hash->hash.size; i++) if (hash->hash.data[i].key != OBJNULL) { cl_object s = hash->hash.data[i].value; symbol_remove_package(s, p); } cl_clrhash(p->pack.external); p->pack.shadowings = ECL_NIL; p->pack.name = ECL_NIL; /* 2) Only at the end, remove the package from the list of packages. */ cl_core.packages = ecl_remove_eq(p, cl_core.packages); } ECL_WITH_GLOBAL_ENV_WRLOCK_END; @(return ECL_T) } void cl_unexport2(cl_object s, cl_object p) { cl_object name = ecl_symbol_name(s); bool error; p = si_coerce_to_package(p); if (p == cl_core.keyword_package) { FEpackage_error("Cannot unexport a symbol from the keyword package.", cl_core.keyword_package, 0); } if (p->pack.locked) { CEpackage_error("Cannot unexport symbol ~S from locked package ~S.", "Ignore lock and proceed", p, 2, s, p); } ECL_WITH_GLOBAL_ENV_WRLOCK_BEGIN(ecl_process_env()) { int intern_flag; cl_object x = find_symbol_inner(name, p, &intern_flag); if (intern_flag == 0 || x != s) { error = 1; } else if (intern_flag != ECL_EXTERNAL) { /* According to ANSI & Cltl, internal symbols are ignored in unexport */ error = 0; } else { ecl_remhash(name, p->pack.external); p->pack.internal = _ecl_sethash(name, p->pack.internal, s); error = 0; } } ECL_WITH_GLOBAL_ENV_WRLOCK_END; if (error) { FEpackage_error("Cannot unexport ~S because it does not " "belong to package ~S.", p, 2, s, p); } } void cl_import2(cl_object s, cl_object p) { int intern_flag, error, ignore_error = 0; cl_object name = ecl_symbol_name(s); p = si_coerce_to_package(p); if (p->pack.locked) { CEpackage_error("Cannot import symbol ~S into locked package ~S.", "Ignore lock and proceed", p, 2, s, p); } ECL_WITH_GLOBAL_ENV_WRLOCK_BEGIN(ecl_process_env()) { cl_object x = find_symbol_inner(name, p, &intern_flag); if (intern_flag) { if (x != s && !ignore_error) { error = 1; goto OUTPUT; } if (intern_flag == ECL_INTERNAL || intern_flag == ECL_EXTERNAL) { error = 0; goto OUTPUT; } } p->pack.internal = _ecl_sethash(name, p->pack.internal, s); symbol_add_package(s, p); error = 0; OUTPUT: (void)0; } ECL_WITH_GLOBAL_ENV_WRLOCK_END; if (error) { CEpackage_error("Cannot import the symbol ~S " "from package ~A,~%" "because there is already a symbol with the same name~%" "in the package.", "Ignore conflict and proceed", p, 2, s, p); ignore_error = 1; } } void ecl_shadowing_import(cl_object s, cl_object p) { int intern_flag; cl_object x; cl_object name = ecl_symbol_name(s); p = si_coerce_to_package(p); if (p->pack.locked) CEpackage_error("Cannot shadowing-import symbol ~S into " "locked package ~S.", "Ignore lock and proceed", p, 2, s, p); ECL_WITH_GLOBAL_ENV_WRLOCK_BEGIN(ecl_process_env()) { x = find_symbol_inner(name, p, &intern_flag); if (intern_flag && intern_flag != ECL_INHERITED) { if (x == s) { if (!ecl_member_eq(x, p->pack.shadowings)) p->pack.shadowings = CONS(x, p->pack.shadowings); goto OUTPUT; } if(ecl_member_eq(x, p->pack.shadowings)) p->pack.shadowings = ecl_remove_eq(x, p->pack.shadowings); if (intern_flag == ECL_INTERNAL) ecl_remhash(name, p->pack.internal); else ecl_remhash(name, p->pack.external); symbol_remove_package(x, p); } p->pack.shadowings = CONS(s, p->pack.shadowings); p->pack.internal = _ecl_sethash(name, p->pack.internal, s); OUTPUT: (void)0; } ECL_WITH_GLOBAL_ENV_WRLOCK_END; } void ecl_shadow(cl_object s, cl_object p) { int intern_flag; cl_object x; /* Contrary to CLTL, in ANSI CL, SHADOW operates on strings. */ s = cl_string(s); p = si_coerce_to_package(p); if (p->pack.locked) CEpackage_error("Cannot shadow symbol ~S in locked package ~S.", "Ignore lock and proceed", p, 2, s, p); ECL_WITH_GLOBAL_ENV_WRLOCK_BEGIN(ecl_process_env()) { x = find_symbol_inner(s, p, &intern_flag); if (intern_flag != ECL_INTERNAL && intern_flag != ECL_EXTERNAL) { x = cl_make_symbol(s); p->pack.internal = _ecl_sethash(s, p->pack.internal, x); x->symbol.hpack = p; } p->pack.shadowings = CONS(x, p->pack.shadowings); } ECL_WITH_GLOBAL_ENV_WRLOCK_END; } void ecl_use_package(cl_object x, cl_object p) { struct ecl_hashtable_entry *hash_entries; cl_index i, hash_length; cl_object here, there, name; int intern_flag, error = 0; x = si_coerce_to_package(x); if (x == cl_core.keyword_package) FEpackage_error("Cannot use keyword package.", cl_core.keyword_package, 0); p = si_coerce_to_package(p); if (p == x) return; if (ecl_member_eq(x, p->pack.uses)) return; if (p == cl_core.keyword_package) FEpackage_error("Cannot apply USE-PACKAGE on keyword package.", cl_core.keyword_package, 0); if (p->pack.locked) CEpackage_error("Cannot use package ~S in locked package ~S.", "Ignore lock and proceed", p, 2, x, p); ECL_WITH_GLOBAL_ENV_WRLOCK_BEGIN(ecl_process_env()) { hash_entries = x->pack.external->hash.data; hash_length = x->pack.external->hash.size; for (i = 0, error = 0; i < hash_length; i++) { if (hash_entries[i].key != OBJNULL) { here = hash_entries[i].value; name = ecl_symbol_name(here); there = find_symbol_inner(name, p, &intern_flag); if (intern_flag && here != there && ! ecl_member_eq(there, p->pack.shadowings)) { error = 1; break; } } } if (!error) { p->pack.uses = CONS(x, p->pack.uses); x->pack.usedby = CONS(p, x->pack.usedby); } } ECL_WITH_GLOBAL_ENV_WRLOCK_END; if (error) { FEpackage_error("Cannot use ~S~%" "from ~S,~%" "because ~S and ~S will cause~%" "a name conflict.", p, 4, x, p, here, there); } } void ecl_unuse_package(cl_object x, cl_object p) { x = si_coerce_to_package(x); p = si_coerce_to_package(p); if (p->pack.locked) CEpackage_error("Cannot unuse package ~S from locked package ~S.", "Ignore lock and proceed", p, 2, x, p); ECL_WITH_GLOBAL_ENV_WRLOCK_BEGIN(ecl_process_env()) { p->pack.uses = ecl_remove_eq(x, p->pack.uses); x->pack.usedby = ecl_remove_eq(p, x->pack.usedby); } ECL_WITH_GLOBAL_ENV_WRLOCK_END; } @(defun make_package (pack_name &key nicknames (use CONS(cl_core.lisp_package, ECL_NIL))) @ /* INV: ecl_make_package() performs type checking */ @(return ecl_make_package(pack_name, nicknames, use)) @) cl_object si_select_package(cl_object pack_name) { const cl_env_ptr the_env = ecl_process_env(); cl_object p = si_coerce_to_package(pack_name); ecl_return1(the_env, ECL_SETQ(the_env, @'*package*', p)); } cl_object cl_find_package(cl_object p) { @(return ecl_find_package_nolock(p)) } cl_object cl_package_name(cl_object p) { /* FIXME: name should be a fresh one */ p = si_coerce_to_package(p); @(return p->pack.name) } cl_object cl_package_nicknames(cl_object p) { /* FIXME: list should be a fresh one */ p = si_coerce_to_package(p); @(return p->pack.nicknames) } @(defun rename_package (pack new_name &o new_nicknames) @ /* INV: ecl_rename_package() type checks and coerces pack to package */ @(return ecl_rename_package(pack, new_name, new_nicknames)) @) cl_object cl_package_use_list(cl_object p) { return cl_copy_list(si_coerce_to_package(p)->pack.uses); } cl_object cl_package_used_by_list(cl_object p) { return cl_copy_list(si_coerce_to_package(p)->pack.usedby); } cl_object cl_package_shadowing_symbols(cl_object p) { return cl_copy_list(si_coerce_to_package(p)->pack.shadowings); } cl_object si_package_lock(cl_object p, cl_object t) { bool previous; p = si_coerce_to_package(p); previous = p->pack.locked; p->pack.locked = (t != ECL_NIL); @(return (previous? ECL_T : ECL_NIL)) } cl_object cl_list_all_packages() { return cl_copy_list(cl_core.packages); } @(defun intern (strng &optional (p ecl_current_package()) &aux sym) int intern_flag; @ sym = ecl_intern(strng, p, &intern_flag); if (intern_flag == ECL_INTERNAL) @(return sym @':internal') if (intern_flag == ECL_EXTERNAL) @(return sym @':external') if (intern_flag == ECL_INHERITED) @(return sym @':inherited') @(return sym ECL_NIL) @) @(defun find_symbol (strng &optional (p ecl_current_package())) cl_object x; int intern_flag; @ x = ecl_find_symbol(strng, p, &intern_flag); if (intern_flag == ECL_INTERNAL) @(return x @':internal') if (intern_flag == ECL_EXTERNAL) @(return x @':external') if (intern_flag == ECL_INHERITED) @(return x @':inherited') @(return ECL_NIL ECL_NIL) @) @(defun unintern (symbl &optional (p ecl_current_package())) @ @(return (ecl_unintern(symbl, p) ? ECL_T : ECL_NIL)) @) @(defun export (symbols &o (pack ecl_current_package())) @ switch (ecl_t_of(symbols)) { case t_symbol: cl_export2(symbols, pack); break; case t_list: pack = si_coerce_to_package(pack); loop_for_in(symbols) { cl_export2(ECL_CONS_CAR(symbols), pack); } end_loop_for_in; break; default: FEwrong_type_nth_arg(@[export],1,symbols, cl_list(3,@'or',@'symbol',@'list')); } @(return ECL_T) @) @(defun unexport (symbols &o (pack ecl_current_package())) @ switch (ecl_t_of(symbols)) { case t_symbol: cl_unexport2(symbols, pack); break; case t_list: pack = si_coerce_to_package(pack); loop_for_in(symbols) { cl_unexport2(ECL_CONS_CAR(symbols), pack); } end_loop_for_in; break; default: FEwrong_type_nth_arg(@[unexport],1,symbols, cl_list(3,@'or',@'symbol',@'list')); } @(return ECL_T) @) @(defun import (symbols &o (pack ecl_current_package())) @ switch (ecl_t_of(symbols)) { case t_symbol: cl_import2(symbols, pack); break; case t_list: pack = si_coerce_to_package(pack); loop_for_in(symbols) { cl_import2(ECL_CONS_CAR(symbols), pack); } end_loop_for_in; break; default: FEwrong_type_nth_arg(@[import],1,symbols, cl_list(3,@'or',@'symbol',@'list')); } @(return ECL_T) @) @(defun shadowing_import (symbols &o (pack ecl_current_package())) @ switch (ecl_t_of(symbols)) { case t_symbol: ecl_shadowing_import(symbols, pack); break; case t_list: pack = si_coerce_to_package(pack); loop_for_in(symbols) { ecl_shadowing_import(ECL_CONS_CAR(symbols), pack); } end_loop_for_in; break; default: FEwrong_type_nth_arg(@[shadowing-import],1,symbols, cl_list(3,@'or',@'symbol',@'list')); } @(return ECL_T) @) @(defun shadow (symbols &o (pack ecl_current_package())) @ switch (ecl_t_of(symbols)) { #ifdef ECL_UNICODE case t_string: #endif case t_base_string: case t_symbol: case t_character: /* Arguments to SHADOW may be: string designators ... */ ecl_shadow(symbols, pack); break; case t_list: /* ... or lists of string designators */ pack = si_coerce_to_package(pack); loop_for_in(symbols) { ecl_shadow(ECL_CONS_CAR(symbols), pack); } end_loop_for_in; break; default: FEwrong_type_nth_arg(@[shadow],1,symbols, cl_list(3,@'or',@'symbol',@'list')); } @(return ECL_T) @) @(defun use_package (pack &o (pa ecl_current_package())) @ switch (ecl_t_of(pack)) { case t_symbol: case t_character: case t_base_string: #ifdef ECL_UNICODE case t_string: #endif case t_package: ecl_use_package(pack, pa); break; case t_list: pa = si_coerce_to_package(pa); loop_for_in(pack) { ecl_use_package(ECL_CONS_CAR(pack), pa); } end_loop_for_in; break; default: FEwrong_type_nth_arg(@[use-package], 1, pack, ecl_read_from_cstring("(OR SYMBOL CHARACTER STRING LIST PACKAGE)")); } @(return ECL_T) @) @(defun unuse_package (pack &o (pa ecl_current_package())) @ switch (ecl_t_of(pack)) { case t_symbol: case t_character: case t_base_string: #ifdef ECL_UNICODE case t_string: #endif case t_package: ecl_unuse_package(pack, pa); break; case t_list: pa = si_coerce_to_package(pa); loop_for_in(pack) { ecl_unuse_package(ECL_CONS_CAR(pack), pa); } end_loop_for_in; break; default: FEwrong_type_nth_arg(@[unuse-package], 1, pack, ecl_read_from_cstring("(OR SYMBOL CHARACTER STRING LIST PACKAGE)")); } @(return ECL_T) @) cl_object si_package_hash_tables(cl_object p) { const cl_env_ptr the_env = ecl_process_env(); cl_object he, hi, u; unlikely_if (!ECL_PACKAGEP(p)) FEwrong_type_only_arg(@[si::package-hash-tables], p, @[package]); ECL_WITH_GLOBAL_ENV_WRLOCK_BEGIN(the_env) { he = si_copy_hash_table(p->pack.external); hi = si_copy_hash_table(p->pack.internal); u = cl_copy_list(p->pack.uses); } ECL_WITH_GLOBAL_ENV_WRLOCK_END; @(return he hi u) } ecl-16.1.2/src/c/pathname.d000066400000000000000000002065711266352375300153460ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* pathname.d -- Pathnames. */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. Copyright (c) 2015, Daniel KochmaХ„ski. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ /* O.S. DEPENDENT This file contains those functions that interpret namestrings. */ #include #include #include #include #include #include typedef int (*delim_fn)(int); /* * Translates a string into the host's preferred case. * See CLHS 19.2.2.1.2.2 Common Case in Pathname Components. */ /* We use UN*X conventions, so lower case is default. * However, this really should be conditionalised to the OS type, * and it should translate to _opposite_ of the local case. */ static cl_object normalize_case(cl_object path, cl_object cas) { if (cas == @':local') { if (path->pathname.logical) return @':upcase'; return @':downcase'; } else if (cas == @':common' || cas == @':downcase' || cas == @':upcase') { return cas; } else { FEerror("Not a valid pathname case :~%~A", 1, cas); } } static bool in_local_case_p(cl_object str, cl_object cas) { if (cas == @':downcase') return ecl_string_case(str) < 0; return 1; } static bool in_antilocal_case_p(cl_object str, cl_object cas) { if (cas == @':downcase') return ecl_string_case(str) > 0; return 0; } static cl_object to_local_case(cl_object str, cl_object cas) { if (cas == @':downcase') return cl_string_downcase(1, str); return cl_string_upcase(1, str); } static cl_object host_case(cl_object host) { if (Null(host)) return @':local'; if (ecl_logical_hostname_p(host)) return @':upcase'; return @':downcase'; } static cl_object to_antilocal_case(cl_object str, cl_object cas) { if (cas == @':downcase') return cl_string_upcase(1, str); return cl_string_upcase(1, str); } static cl_object translate_from_common(cl_object str, cl_object tocase) { int string_case = ecl_string_case(str); if (string_case > 0) { /* ALL_UPPER */ return to_local_case(str, tocase); } else if (string_case < 0) { /* ALL_LOWER */ return to_antilocal_case(str, tocase); } else { /* Mixed case goes unchanged */ return str; } } static cl_object translate_to_common(cl_object str, cl_object fromcase) { if (in_local_case_p(str, fromcase)) { return cl_string_upcase(1, str); } else if (in_antilocal_case_p(str, fromcase)) { return cl_string_downcase(1, str); } else { return str; } } static cl_object translate_component_case(cl_object str, cl_object fromcase, cl_object tocase) { /* Pathnames may contain some other objects, such as symbols, * numbers, etc, which need not be translated */ if (str == OBJNULL) { return str; } else if (!ECL_STRINGP(str)) { return str; } else if (tocase == fromcase) { return str; } else if (tocase == @':common') { return translate_to_common(str, fromcase); } else if (fromcase == @':common') { return translate_from_common(str, tocase); } else { str = translate_to_common(str, fromcase); return translate_from_common(str, tocase); } } static cl_object translate_list_case(cl_object list, cl_object fromcase, cl_object tocase) { /* If the argument is really a list, translate all strings in it and * return this new list, else assume it is a string and translate it. */ if (!CONSP(list)) { return translate_component_case(list, fromcase, tocase); } else { cl_object l; list = cl_copy_list(list); for (l = list; !ecl_endp(l); l = CDR(l)) { /* It is safe to pass anything to translate_component_case, * because it will only transform strings, leaving other * object (such as symbols) unchanged.*/ cl_object name = ECL_CONS_CAR(l); name = ECL_LISTP(name)? translate_list_case(name, fromcase, tocase) : translate_component_case(name, fromcase, tocase); ECL_RPLACA(l, name); } return list; } } static void push_substring(cl_object buffer, cl_object string, cl_index start, cl_index end) { string = cl_string(string); while (start < end) { ecl_string_push_extend(buffer, ecl_char(string, start)); start++; } } static void push_string(cl_object buffer, cl_object string) { push_substring(buffer, string, 0, ecl_length(string)); } static cl_object destructively_check_directory(cl_object directory, bool logical, bool delete_back) { /* This function performs two tasks * 1) It ensures that the list is a valid directory list * 2) It ensures that all strings in the list are valid C strings without fill pointer * All strings are copied, thus avoiding problems with the user modifying the * list that was passed to MAKE-PATHNAME. * 3) Redundant :back are removed. */ /* INV: directory is always a list */ cl_object ptr; int i; if (!LISTP(directory)) return @':error'; if (Null(directory)) return directory; if (ECL_CONS_CAR(directory) != @':absolute' && ECL_CONS_CAR(directory) != @':relative') return @':error'; BEGIN: for (i=0, ptr=directory; CONSP(ptr); ptr = ECL_CONS_CDR(ptr), i++) { cl_object item = ECL_CONS_CAR(ptr); if (item == @':back') { if (i == 0) return @':error'; item = ecl_nth(i-1, directory); if (item == @':absolute' || item == @':wild-inferiors') return @':error'; if (delete_back && i >= 2) { cl_object next = ECL_CONS_CDR(ptr); ptr = ecl_nthcdr(i-2, directory); ECL_RPLACD(ptr, next); i = i-2; } } else if (item == @':up') { if (i == 0) return @':error'; item = ecl_nth(i-1, directory); if (item == @':absolute' || item == @':wild-inferiors') return @':error'; } else if (item == @':relative' || item == @':absolute') { if (i > 0) return @':error'; } else if (ecl_stringp(item)) { cl_index l = ecl_length(item); item = cl_copy_seq(item); ECL_RPLACA(ptr, item); if (logical) continue; if (l && ecl_char(item,0) == '.') { if (l == 1) { /* Single dot */ if (i == 0) return @':error'; ECL_RPLACD(ecl_nthcdr(--i, directory), ECL_CONS_CDR(ptr)); } else if (l == 2 && ecl_char(item,1) == '.') { ECL_RPLACA(ptr, @':up'); goto BEGIN; } } } else if (item != @':wild' && item != @':wild-inferiors') { return @':error'; } } return directory; } cl_object ecl_make_pathname(cl_object host, cl_object device, cl_object directory, cl_object name, cl_object type, cl_object version, cl_object fromcase) { cl_object x, p, component; p = ecl_alloc_object(t_pathname); if (ecl_stringp(host)) p->pathname.logical = ecl_logical_hostname_p(host); else if (host == ECL_NIL) p->pathname.logical = FALSE; else { x = directory; component = @':host'; goto ERROR; } if (device != ECL_NIL && device != @':unspecific' && !(!p->pathname.logical && ecl_stringp(device))) { x = device; component = @':device'; goto ERROR; } if (name != ECL_NIL && name != @':wild' && !ecl_stringp(name)) { x = name; component = @':name'; goto ERROR; } if (type != ECL_NIL && type != @':unspecific' && type != @':wild' && !ecl_stringp(type)) { x = type; component = @':type'; goto ERROR; } if (version != @':unspecific' && version != @':newest' && version != @':wild' && version != ECL_NIL && !ECL_FIXNUMP(version)) { x = version; component = @':version'; ERROR: FEerror("~s is not a valid pathname-~a component", 2, x, component); } switch (ecl_t_of(directory)) { #ifdef ECL_UNICODE case t_string: #endif case t_base_string: directory = cl_list(2, @':absolute', directory); break; case t_symbol: if (directory == @':wild') { directory = cl_list(2, @':absolute', @':wild-inferiors'); break; } x = directory; component = @':directory'; goto ERROR; case t_list: directory = cl_copy_list(directory); break; default: x = directory; component = @':directory'; goto ERROR; } p->pathname.host = host; { cl_object tocase = normalize_case(p, @':local'); if (p->pathname.logical) fromcase = @':common'; else fromcase = normalize_case(p, fromcase); p->pathname.host = translate_component_case(host, fromcase, tocase); p->pathname.device = translate_component_case(device, fromcase, tocase); p->pathname.directory = directory = translate_list_case(directory, fromcase, tocase); p->pathname.name = translate_component_case(name, fromcase, tocase); p->pathname.type = translate_component_case(type, fromcase, tocase); p->pathname.version = version; } directory = destructively_check_directory(directory, p->pathname.logical, 0); unlikely_if (directory == @':error') { cl_error(3, @'file-error', @':pathname', p); } p->pathname.directory = directory; return(p); } static cl_object tilde_expand(cl_object pathname) { /* * If the pathname is a physical one, without hostname, without device * and the first element is either a tilde '~' or '~' followed by * a user name, we merge the user homedir pathname with this one. */ cl_object directory, head; if (pathname->pathname.logical || pathname->pathname.host != ECL_NIL || pathname->pathname.device != ECL_NIL) { return pathname; } directory = pathname->pathname.directory; if (!CONSP(directory) || ECL_CONS_CAR(directory) != @':relative' || ECL_CONS_CDR(directory) == ECL_NIL) { return pathname; } head = CADR(directory); if (ecl_stringp(head) && ecl_length(head) > 0 && ecl_char(head,0) == '~') { /* Remove the tilde component */ ECL_RPLACD(directory, CDDR(directory)); pathname = cl_merge_pathnames(2, pathname, ecl_homedir_pathname(head)); } return pathname; } #define WORD_INCLUDE_DELIM 1 #define WORD_ALLOW_ASTERISK 2 #define WORD_EMPTY_IS_NIL 4 #define WORD_LOGICAL 8 #define WORD_SEARCH_LAST_DOT 16 #define WORD_ALLOW_LEADING_DOT 32 #define WORD_DISALLOW_SLASH 64 #define WORD_DISALLOW_SEMICOLON 128 static cl_object make_one(cl_object s, cl_index start, cl_index end) { return cl_subseq(3, s, ecl_make_fixnum(start), ecl_make_fixnum(end)); } static int is_colon(int c) { return c == ':'; } static int is_slash(int c) { return IS_DIR_SEPARATOR(c); } static int is_semicolon(int c) { return c == ';'; } static int is_dot(int c) { return c == '.'; } static int is_null(int c) { return c == '\0'; } /* * Parses a word from string `S' until either: * 1) character `DELIM' is found * 2) end of string is reached * 3) a non valid character is found * Output is either * 1) :error in case (3) above * 2) :wild, :wild-inferiors, :up * 3) "" or ECL_NIL when word has no elements * 5) A non empty string */ static cl_object parse_word(cl_object s, delim_fn delim, int flags, cl_index start, cl_index end, cl_index *end_of_word) { cl_index i, j, last_delim = end; bool wild_inferiors = FALSE; i = j = start; for (; i < end; i++) { bool valid_char; cl_index c = ecl_char(s, i); if (delim(c)) { if ((i == start) && (flags & WORD_ALLOW_LEADING_DOT)) { /* Leading dot is included */ continue; } last_delim = i; if (!(flags & WORD_SEARCH_LAST_DOT)) { break; } } if (c == '*') { if (!(flags & WORD_ALLOW_ASTERISK)) valid_char = FALSE; /* Asterisks not allowed in this word */ else { wild_inferiors = (i > start && ecl_char(s, i-1) == '*'); valid_char = TRUE; /* single "*" */ } } else if (c == ';' && (flags & WORD_DISALLOW_SEMICOLON)) { valid_char = 0; } else if (c == '/' && (flags & WORD_DISALLOW_SLASH)) { valid_char = 0; } else { valid_char = c != 0; } if (!valid_char) { *end_of_word = start; return @':error'; } } if (i > last_delim) { /* Go back to the position of the last delimiter */ i = last_delim; } if (i < end) { *end_of_word = i+1; } else { *end_of_word = end; /* We have reached the end of the string without finding the proper delimiter */ if (flags & WORD_INCLUDE_DELIM) { *end_of_word = start; return ECL_NIL; } } switch(i-j) { case 0: if (flags & WORD_EMPTY_IS_NIL) return ECL_NIL; return cl_core.null_string; case 1: if (ecl_char(s,j) == '*') return @':wild'; break; case 2: { cl_index c0 = ecl_char(s,j); cl_index c1 = ecl_char(s,j+1); if (c0 == '*' && c1 == '*') return @':wild-inferiors'; if (!(flags & WORD_LOGICAL) && c0 == '.' && c1 == '.') return @':up'; break; } default: if (wild_inferiors) /* '**' surrounded by other characters */ return @':error'; } return make_one(s, j, i); } /* * Parses a logical or physical directory tree. Output is always a * list of valid directory components, which may be just NIL. * * INV: When parsing of directory components has failed, a valid list * is also returned, and it will be later in the parsing of * pathname-name or pathname-type when the same error is detected. */ static cl_object parse_directories(cl_object s, int flags, cl_index start, cl_index end, cl_index *end_of_dir) { cl_index i, j; cl_object path = ECL_NIL; delim_fn delim = (flags & WORD_LOGICAL) ? is_semicolon : is_slash; flags |= WORD_INCLUDE_DELIM | WORD_ALLOW_ASTERISK; *end_of_dir = start; for (i = j = start; i < end; j = i) { cl_object part = parse_word(s, delim, flags, j, end, &i); if (part == @':error' || part == ECL_NIL) break; if (part == cl_core.null_string) { /* "/", ";" */ if (j != start) { if (flags & WORD_LOGICAL) return @':error'; *end_of_dir = i; continue; } part = (flags & WORD_LOGICAL) ? @':relative' : @':absolute'; } *end_of_dir = i; path = ecl_cons(part, path); } return cl_nreverse(path); } bool ecl_logical_hostname_p(cl_object host) { if (!ecl_stringp(host)) return FALSE; return !Null(@assoc(4, host, cl_core.pathname_translations, @':test', @'string-equal')); } /* * Parses a lisp namestring until the whole substring is parsed or an * error is found. It returns a valid pathname or NIL, plus the place * where parsing ended in *END_OF_PARSING. * * The rules are as follows: * * 1) If a hostname is supplied it determines whether the namestring * will be parsed as logical or as physical. * * 2) If no hostname is supplied, first it tries parsing using logical * pathname rules and, if no logical hostname is found, then it * tries the physical pathname format. * * 3) Logical pathname syntax: * [logical-hostname:][;][logical-directory-component;][pathname-name][.pathname-type] * * 4) Physical pathname syntax: * [device:][[//hostname]/][directory-component/]*[pathname-name][.pathname-type] * * logical-hostname, device, hostname = word * logical-directory-component = word | wildcard-word * directory-component = word | wildcard-word | '..' | '.' * pathname-name, pathname-type = word | wildcard-word | "" * */ cl_object ecl_parse_namestring(cl_object s, cl_index start, cl_index end, cl_index *ep, cl_object default_host) { cl_object host, device, path, name, type, aux, version; bool logical; if (start == end) { host = device = path = name = type = aux = version = @'nil'; logical = 0; goto make_it; } /* We first try parsing as logical-pathname. In case of * failure, physical-pathname parsing is performed only when * there is no supplied *logical* host name. All other failures * result in ECL_NIL as output. */ host = parse_word(s, is_colon, WORD_LOGICAL | WORD_INCLUDE_DELIM | WORD_DISALLOW_SEMICOLON, start, end, ep); if (default_host != ECL_NIL) { if (host == ECL_NIL || host == @':error') host = default_host; } if (!ecl_logical_hostname_p(host)) goto physical; /* * Logical pathname format: * [logical-hostname:][;][logical-directory-component;][pathname-name][.pathname-type] */ logical = TRUE; device = @':unspecific'; path = parse_directories(s, WORD_LOGICAL, *ep, end, ep); if (CONSP(path)) { if (ECL_CONS_CAR(path) != @':relative' && ECL_CONS_CAR(path) != @':absolute') path = CONS(@':absolute', path); path = destructively_check_directory(path, TRUE, FALSE); } else { path = CONS(@':absolute', path); } if (path == @':error') return ECL_NIL; name = parse_word(s, is_dot, WORD_LOGICAL | WORD_ALLOW_ASTERISK | WORD_EMPTY_IS_NIL, *ep, end, ep); if (name == @':error') return ECL_NIL; type = ECL_NIL; version = ECL_NIL; if (*ep == start || ecl_char(s, *ep-1) != '.') goto make_it; type = parse_word(s, is_dot, WORD_LOGICAL | WORD_ALLOW_ASTERISK | WORD_EMPTY_IS_NIL, *ep, end, ep); if (type == @':error') return ECL_NIL; if (*ep == start || ecl_char(s, *ep-1) != '.') goto make_it; aux = parse_word(s, is_null, WORD_LOGICAL | WORD_ALLOW_ASTERISK | WORD_EMPTY_IS_NIL, *ep, end, ep); if (aux == @':error') { return ECL_NIL; } else if (ECL_SYMBOLP(aux)) { version = aux; } else { const cl_env_ptr the_env = ecl_process_env(); cl_object parsed_length; version = cl_parse_integer(3, aux, @':junk-allowed', ECL_T); parsed_length = ecl_nth_value(the_env, 1); if (ecl_fixnum(parsed_length) == ecl_length(aux) && cl_integerp(version) != ECL_NIL && ecl_plusp(version)) ; else if (cl_string_equal(2, aux, @':newest') != ECL_NIL) version = @':newest'; else return ECL_NIL; } goto make_it; physical: /* * Physical pathname format: * [[device:[//hostname]]/][directory-component/]*[pathname-name][.pathname-type] */ logical = FALSE; /* We only parse a hostname when the device was present. This * requisite is a bit stupid and only applies to the Unix port, * where "//home/" is equivalent to "/home" However, in Windows * we need "//FOO/" to be separately handled, for it is a shared * resource. */ #if defined(ECL_MS_WINDOWS_HOST) if ((start+1 <= end) && is_slash(ecl_char(s, start))) { device = ECL_NIL; goto maybe_parse_host; } #endif device = parse_word(s, is_colon, WORD_INCLUDE_DELIM | WORD_EMPTY_IS_NIL | WORD_DISALLOW_SLASH, start, end, ep); if (device == @':error' || device == ECL_NIL) { device = ECL_NIL; host = ECL_NIL; goto done_device_and_host; } if (!ecl_stringp(device)) { return ECL_NIL; } maybe_parse_host: /* Files have no effective device. */ if (@string-equal(2, device, @':file') == ECL_T) device = ECL_NIL; start = *ep; host = ECL_NIL; if ((start+2) <= end && is_slash(ecl_char(s, start)) && is_slash(ecl_char(s, start+1))) { host = parse_word(s, is_slash, WORD_EMPTY_IS_NIL, start+2, end, ep); if (host == @':error') { host = ECL_NIL; } else if (host != ECL_NIL) { if (!ecl_stringp(host)) return ECL_NIL; start = *ep; if (is_slash(ecl_char(s,--start))) *ep = start; } } if (ecl_length(device) == 0) device = ECL_NIL; done_device_and_host: path = parse_directories(s, 0, *ep, end, ep); if (CONSP(path)) { if (ECL_CONS_CAR(path) != @':relative' && ECL_CONS_CAR(path) != @':absolute') path = CONS(@':relative', path); path = destructively_check_directory(path, FALSE, FALSE); } if (path == @':error') return ECL_NIL; start = *ep; name = parse_word(s, is_dot, WORD_ALLOW_LEADING_DOT | WORD_SEARCH_LAST_DOT | WORD_ALLOW_ASTERISK | WORD_EMPTY_IS_NIL, start, end, ep); if (name == @':error') return ECL_NIL; if ((*ep - start) <= 1 || ecl_char(s, *ep-1) != '.') { type = ECL_NIL; } else { type = parse_word(s, is_null, WORD_ALLOW_ASTERISK, *ep, end, ep); if (type == @':error') return ECL_NIL; } version = (name != ECL_NIL || type != ECL_NIL) ? @':newest' : ECL_NIL; make_it: if (*ep >= end) *ep = end; path = ecl_make_pathname(host, device, path, name, type, version, @':local'); path->pathname.logical = logical; return tilde_expand(path); } cl_object si_default_pathname_defaults(void) { /* This routine outputs the value of *default-pathname-defaults* * coerced to type PATHNAME. Special care is taken so that we do * not enter an infinite loop when using PARSE-NAMESTRING, because * this routine might itself try to use the value of this variable. */ cl_object path = ecl_symbol_value(@'*default-pathname-defaults*'); unlikely_if (!ECL_PATHNAMEP(path)) { const cl_env_ptr the_env = ecl_process_env(); ecl_bds_bind(the_env, @'*default-pathname-defaults*', si_getcwd(0)); FEwrong_type_key_arg(@[pathname], @[*default-pathname-defaults*], path, @'pathname'); } @(return path) } cl_object cl_pathname(cl_object x) { L: switch (ecl_t_of(x)) { #ifdef ECL_UNICODE case t_string: #endif case t_base_string: x = cl_parse_namestring(1, x); case t_pathname: break; case t_stream: switch ((enum ecl_smmode)x->stream.mode) { case ecl_smm_input: case ecl_smm_output: case ecl_smm_probe: case ecl_smm_io: case ecl_smm_input_file: case ecl_smm_output_file: case ecl_smm_io_file: x = IO_STREAM_FILENAME(x); goto L; case ecl_smm_synonym: x = SYNONYM_STREAM_STREAM(x); goto L; default: ;/* Fall through to error message */ } default: { const char *type = "(OR FILE-STREAM STRING PATHNAME)"; FEwrong_type_only_arg(@[pathname], x, ecl_read_from_cstring(type)); } } @(return x) } cl_object cl_logical_pathname(cl_object x) { x = cl_pathname(x); if (!x->pathname.logical) { cl_error(9, @'simple-type-error', @':format-control', make_constant_base_string("~S cannot be coerced to a logical pathname."), @':format-arguments', cl_list(1, x), @':expected-type', @'logical-pathname', @':datum', x); } @(return x); } /* FIXME! WILD-PATHNAME-P is missing! */ @(defun wild-pathname-p (pathname &optional component) bool checked = 0; @ pathname = cl_pathname(pathname); if (component == ECL_NIL || component == @':host') { if (pathname->pathname.host == @':wild') @(return ECL_T); checked = 1; } if (component == ECL_NIL || component == @':device') { if (pathname->pathname.device == @':wild') @(return ECL_T); checked = 1; } if (component == ECL_NIL || component == @':version') { if (pathname->pathname.version == @':wild') @(return ECL_T); checked = 1; } if (component == ECL_NIL || component == @':name') { cl_object name = pathname->pathname.name; if (name != ECL_NIL && (name == @':wild' || ecl_wild_string_p(name))) @(return ECL_T); checked = 1; } if (component == ECL_NIL || component == @':type') { cl_object name = pathname->pathname.type; if (name != ECL_NIL && (name == @':wild' || ecl_wild_string_p(name))) @(return ECL_T); checked = 1; } if (component == ECL_NIL || component == @':directory') { cl_object list = pathname->pathname.directory; checked = 1; loop_for_on_unsafe(list) { cl_object name = ECL_CONS_CAR(list); if (name != ECL_NIL && (name == @':wild' || name == @':wild-inferiors' || ecl_wild_string_p(name))) { @(return ECL_T) } } end_loop_for_on_unsafe(list); } if (checked == 0) { FEerror("~A is not a valid pathname component", 1, component); } @(return ECL_NIL) @) /* * coerce_to_file_pathname(P) converts P to a physical pathname, * for a file which is accesible in our filesystem. * INV: Wildcards are allowed. * INV: A fresh new copy of the pathname is created. * INV: The pathname is absolute. */ cl_object coerce_to_file_pathname(cl_object pathname) { pathname = coerce_to_physical_pathname(pathname); pathname = cl_merge_pathnames(1, pathname); #if 0 #if !defined(cygwin) && !defined(ECL_MS_WINDOWS_HOST) if (pathname->pathname.device != ECL_NIL) FEerror("Device ~S not yet supported.", 1, pathname->pathname.device); if (pathname->pathname.host != ECL_NIL) FEerror("Access to remote files not yet supported.", 0); #endif #endif if (pathname->pathname.directory == ECL_NIL || ECL_CONS_CAR(pathname->pathname.directory) == @':relative') { pathname = cl_merge_pathnames(2, pathname, si_getcwd(0)); } return pathname; } /* * coerce_to_physical_pathname(P) converts P to a physical pathname, * performing the appropiate transformation if P was a logical pathname. */ cl_object coerce_to_physical_pathname(cl_object x) { x = cl_pathname(x); if (x->pathname.logical) return cl_translate_logical_pathname(1, x); return x; } /* * si_coerce_to_filename(P) converts P to a physical pathname and then to * a namestring. The output must always be a new simple-string which can * be used by the C library. * INV: No wildcards are allowed. */ cl_object si_coerce_to_filename(cl_object pathname_orig) { cl_object namestring, pathname; /* We always go through the pathname representation and thus * cl_namestring() always outputs a fresh new string */ pathname = coerce_to_file_pathname(pathname_orig); if (cl_wild_pathname_p(1,pathname) != ECL_NIL) cl_error(3, @'file-error', @':pathname', pathname_orig); namestring = ecl_namestring(pathname, ECL_NAMESTRING_TRUNCATE_IF_ERROR | ECL_NAMESTRING_FORCE_BASE_STRING); if (namestring == ECL_NIL) { FEerror("Pathname without a physical namestring:" "~% :HOST ~A" "~% :DEVICE ~A" "~% :DIRECTORY ~A" "~% :NAME ~A" "~% :TYPE ~A" "~% :VERSION ~A", 6, pathname_orig->pathname.host, pathname_orig->pathname.device, pathname_orig->pathname.directory, pathname_orig->pathname.name, pathname_orig->pathname.type, pathname_orig->pathname.version); } if (cl_core.path_max != -1 && ecl_length(namestring) >= cl_core.path_max - 16) FEerror("Too long filename: ~S.", 1, namestring); return namestring; } #define default_device(host) ECL_NIL cl_object ecl_merge_pathnames(cl_object path, cl_object defaults, cl_object default_version) { cl_object host, device, directory, name, type, version; cl_object tocase; defaults = cl_pathname(defaults); path = cl_parse_namestring(1, path, ECL_NIL, defaults); if (Null(host = path->pathname.host)) host = defaults->pathname.host; tocase = host_case(host); if (Null(path->pathname.device)) { if (Null(path->pathname.host)) device = cl_pathname_device(3, defaults, @':case', tocase); else if (path->pathname.host == defaults->pathname.host) device = defaults->pathname.device; else device = default_device(path->pathname.host); } else { device = path->pathname.device; } if (Null(path->pathname.directory)) { directory = cl_pathname_directory(3, defaults, @':case', tocase); } else if (ECL_CONS_CAR(path->pathname.directory) == @':absolute') { directory = path->pathname.directory; } else if (!Null(defaults->pathname.directory)) { directory = ecl_append(cl_pathname_directory(3, defaults, @':case', tocase), CDR(path->pathname.directory)); /* Eliminate redundant :back */ directory = destructively_check_directory(directory, TRUE, TRUE); } else { directory = path->pathname.directory; } if (Null(name = path->pathname.name)) { name = cl_pathname_name(3, defaults, @':case', tocase); } if (Null(type = path->pathname.type)) { type = cl_pathname_type(3, defaults, @':case', tocase); } version = path->pathname.version; if (Null(path->pathname.name)) { if (Null(version)) version = defaults->pathname.version; } if (Null(version)) { version = default_version; } if (default_version == @':default') { if (Null(name) && Null(type)) { version = ECL_NIL; } else { version = @':newest'; } } /* In this implementation, version is not considered */ defaults = ecl_make_pathname(host, device, directory, name, type, version, tocase); return defaults; } /* ecl_namestring(x, flag) converts a pathname to a namestring. if flag is true, then the pathname may be coerced to the requirements of the filesystem, removing fields that have no meaning (such as version, or type, etc); otherwise, when it is not possible to produce a readable representation of the pathname, NIL is returned. */ cl_object ecl_namestring(cl_object x, int flags) { bool logical; cl_object l, y; cl_object buffer, host; bool truncate_if_unreadable = flags & ECL_NAMESTRING_TRUNCATE_IF_ERROR; x = cl_pathname(x); /* INV: Pathnames can only be created by mergin, parsing namestrings * or using ecl_make_pathname(). In all of these cases ECL will complain * at creation time if the pathname has wrong components. */ buffer = ecl_make_string_output_stream(128, 1); logical = x->pathname.logical; host = x->pathname.host; if (logical) { if ((y = x->pathname.device) != @':unspecific' && truncate_if_unreadable) return ECL_NIL; if (host != ECL_NIL) { si_do_write_sequence(host, buffer, ecl_make_fixnum(0), ECL_NIL); writestr_stream(":", buffer); } } else { if ((y = x->pathname.device) != ECL_NIL) { si_do_write_sequence(y, buffer, ecl_make_fixnum(0), ECL_NIL); writestr_stream(":", buffer); } if (host != ECL_NIL) { #if !defined(ECL_MS_WINDOWS_HOST) if (y == ECL_NIL) { writestr_stream("file:", buffer); } #endif writestr_stream("//", buffer); si_do_write_sequence(host, buffer, ecl_make_fixnum(0), ECL_NIL); } } l = x->pathname.directory; if (ecl_endp(l)) goto NO_DIRECTORY; y = ECL_CONS_CAR(l); if (y == @':relative') { if (logical) ecl_write_char(';', buffer); } else { if (!logical) ecl_write_char(DIR_SEPARATOR, buffer); } l = ECL_CONS_CDR(l); loop_for_in(l) { y = ECL_CONS_CAR(l); if (y == @':up') { writestr_stream("..", buffer); } else if (y == @':wild') { writestr_stream("*", buffer); } else if (y == @':wild-inferiors') { writestr_stream("**", buffer); } else if (y != @':back') { si_do_write_sequence(y, buffer, ecl_make_fixnum(0), ECL_NIL); } else { /* Directory :back has no namestring representation */ return ECL_NIL; } ecl_write_char(logical? ';' : DIR_SEPARATOR, buffer); } end_loop_for_in; NO_DIRECTORY: if (ecl_file_position(buffer) == ecl_make_fixnum(0)) { if ((ecl_stringp(x->pathname.name) && ecl_member_char(':', x->pathname.name)) || (ecl_stringp(x->pathname.type) && ecl_member_char(':', x->pathname.type))) writestr_stream(":", buffer); } y = x->pathname.name; if (y != ECL_NIL) { if (y == @':wild') { writestr_stream("*", buffer); } else { si_do_write_sequence(y, buffer, ecl_make_fixnum(0), ECL_NIL); } } else if (!logical && !Null(x->pathname.type)) { /* #P".txt" is :NAME = ".txt" :TYPE = NIL and hence :NAME = NIL and :TYPE != NIL does not have a printed representation */ return ECL_NIL; } y = x->pathname.type; if (y == @':unspecific') { return ECL_NIL; } else if (y != ECL_NIL) { if (y == @':wild') { writestr_stream(".*", buffer); } else { writestr_stream(".", buffer); si_do_write_sequence(y, buffer, ecl_make_fixnum(0), ECL_NIL); } } y = x->pathname.version; if (logical) { if (y != ECL_NIL) { writestr_stream(".", buffer); if (y == @':wild') { writestr_stream("*", buffer); } else if (y == @':newest') { si_do_write_sequence(ecl_symbol_name(y), buffer, ecl_make_fixnum(0), ECL_NIL); } else { /* Since the printer is not reentrant, * we cannot use cl_write and friends. */ int n = ecl_fixnum(y), i; char b[ECL_FIXNUM_BITS / 2]; for (i = 0; n; i++) { b[i] = n%10 + '0'; n = n/10; } if (i == 0) b[i++] = '0'; while (i--) { ecl_write_char(b[i], buffer); } } } } else if (!truncate_if_unreadable) { /* Namestrings of physical pathnames have restrictions... */ if (Null(x->pathname.name) && Null(x->pathname.type)) { /* Directories cannot have a version number */ if (y != ECL_NIL) return ECL_NIL; } else if (y != @':newest') { /* Filenames have an implicit version :newest */ return ECL_NIL; } } buffer = cl_get_output_stream_string(buffer); #ifdef ECL_UNICODE if (ECL_EXTENDED_STRING_P(buffer) && (flags & ECL_NAMESTRING_FORCE_BASE_STRING)) { unlikely_if (!ecl_fits_in_base_string(buffer)) FEerror("The filesystem does not accept filenames " "with extended characters: ~S", 1, buffer); buffer = si_copy_to_simple_base_string(buffer); } #endif return buffer; } cl_object cl_namestring(cl_object x) { @(return ecl_namestring(x, ECL_NAMESTRING_TRUNCATE_IF_ERROR)) } @(defun parse_namestring (thing &o host (defaults si_default_pathname_defaults()) &k (start ecl_make_fixnum(0)) end junk_allowed &a output) @ if (host != ECL_NIL) { host = cl_string(host); } if (!ecl_stringp(thing)) { output = cl_pathname(thing); } else { cl_object default_host = host; cl_index_pair p; cl_index ee; if (default_host == ECL_NIL && defaults != ECL_NIL) { defaults = cl_pathname(defaults); default_host = defaults->pathname.host; } p = ecl_vector_start_end(@[parse-namestring], thing, start, end); output = ecl_parse_namestring(thing, p.start, p.end, &ee, default_host); start = ecl_make_fixnum(ee); if (output == ECL_NIL || ee != p.end) { if (Null(junk_allowed)) { FEparse_error("Cannot parse the namestring ~S~%" "from ~S to ~S.", ECL_NIL, 3, thing, start, end); } goto OUTPUT; } } if (host != ECL_NIL && !ecl_equal(output->pathname.host, host)) { FEerror("The pathname ~S does not contain the required host ~S.", 2, thing, host); } OUTPUT: @(return output start) @) @(defun merge_pathnames (path &o (defaults si_default_pathname_defaults()) (default_version @':newest')) @ path = cl_pathname(path); defaults = cl_pathname(defaults); @(return ecl_merge_pathnames(path, defaults, default_version)) @) @(defun make_pathname (&key (host ECL_NIL hostp) (device ECL_NIL devicep) (directory ECL_NIL directoryp) (name ECL_NIL namep) (type ECL_NIL typep) (version ECL_NIL versionp) ((:case scase) @':local') defaults &aux x) @ if (Null(defaults)) { defaults = si_default_pathname_defaults(); defaults = ecl_make_pathname(defaults->pathname.host, ECL_NIL, ECL_NIL, ECL_NIL, ECL_NIL, ECL_NIL, @':local'); } else { defaults = cl_pathname(defaults); } if (!hostp) host = defaults->pathname.host; x = ecl_make_pathname(host, device, directory, name, type, version, scase); if (!devicep) x->pathname.device = defaults->pathname.device; if (!directoryp) x->pathname.directory = defaults->pathname.directory; if (!namep) x->pathname.name = defaults->pathname.name; if (!typep) x->pathname.type = defaults->pathname.type; if (!versionp) x->pathname.version = defaults->pathname.version; @(return x) @) cl_object cl_pathnamep(cl_object pname) { @(return (ECL_PATHNAMEP(pname) ? ECL_T : ECL_NIL)) } cl_object si_logical_pathname_p(cl_object pname) { @(return ((ECL_PATHNAMEP(pname) && pname->pathname.logical)? ECL_T : ECL_NIL)) } @(defun pathname_host (pname &key ((:case scase) @':local')) @ pname = cl_pathname(pname); @(return translate_component_case(pname->pathname.host, normalize_case(pname, @':local'), normalize_case(pname, scase))) @) @(defun pathname_device (pname &key ((:case scase) @':local')) @ pname = cl_pathname(pname); @(return translate_component_case(pname->pathname.device, normalize_case(pname, @':local'), normalize_case(pname, scase))) @) @(defun pathname_directory (pname &key ((:case scase) @':local')) @ pname = cl_pathname(pname); @(return translate_list_case(pname->pathname.directory, normalize_case(pname, @':local'), normalize_case(pname, scase))) @) @(defun pathname_name(pname &key ((:case scase) @':local')) @ pname = cl_pathname(pname); @(return translate_component_case(pname->pathname.name, normalize_case(pname, @':local'), normalize_case(pname, scase))) @) @(defun pathname_type(pname &key ((:case scase) @':local')) @ pname = cl_pathname(pname); @(return translate_component_case(pname->pathname.type, normalize_case(pname, @':local'), normalize_case(pname, scase))) @) cl_object cl_pathname_version(cl_object pname) { pname = cl_pathname(pname); @(return pname->pathname.version) } cl_object cl_file_namestring(cl_object pname) { pname = cl_pathname(pname); @(return ecl_namestring(ecl_make_pathname(ECL_NIL, ECL_NIL, ECL_NIL, pname->pathname.name, pname->pathname.type, pname->pathname.version, @':local'), ECL_NAMESTRING_TRUNCATE_IF_ERROR)) } cl_object cl_directory_namestring(cl_object pname) { pname = cl_pathname(pname); @(return ecl_namestring(ecl_make_pathname(ECL_NIL, ECL_NIL, pname->pathname.directory, ECL_NIL, ECL_NIL, ECL_NIL, @':local'), ECL_NAMESTRING_TRUNCATE_IF_ERROR)) } cl_object cl_host_namestring(cl_object pname) { pname = cl_pathname(pname); pname = pname->pathname.host; if (Null(pname) || pname == @':wild') pname = cl_core.null_string; @(return pname) } #define EN_MATCH(p1,p2,el) (ecl_equalp(p1->pathname.el, p2->pathname.el)? ECL_NIL : p1->pathname.el) @(defun enough_namestring (path &o (defaults si_default_pathname_defaults())) cl_object newpath, pathdir, defaultdir, fname; @ defaults = cl_pathname(defaults); path = cl_pathname(path); pathdir = path->pathname.directory; defaultdir = defaults->pathname.directory; if (Null(pathdir)) { pathdir = ecl_list1(@':relative'); } else if (Null(defaultdir)) { /* The defaults pathname does not have a directory. */ } else if (ECL_CONS_CAR(pathdir) == @':relative') { /* The pathname is relative to the default one one, so we just output the original one */ } else { /* The new pathname is an absolute one. We compare it with the defaults and if they have some common elements, we just output the remaining ones. */ cl_object dir_begin = funcall(5, @'mismatch', pathdir, defaultdir, @':test', @'equal'); if (dir_begin == ECL_NIL) { pathdir = ECL_NIL; } else if (dir_begin == cl_length(defaultdir)) { pathdir = funcall(3, @'subseq', pathdir, dir_begin); pathdir = CONS(@':relative', pathdir); } } fname = EN_MATCH(path, defaults, name); if (fname == ECL_NIL) fname = path->pathname.name; /* Create a path with all elements that do not match the default */ newpath = ecl_make_pathname(EN_MATCH(path, defaults, host), EN_MATCH(path, defaults, device), pathdir, fname, EN_MATCH(path, defaults, type), EN_MATCH(path, defaults, version), @':local'); newpath->pathname.logical = path->pathname.logical; @(return ecl_namestring(newpath, ECL_NAMESTRING_TRUNCATE_IF_ERROR)) @) #undef EN_MATCH /* --------------- PATHNAME MATCHING ------------------ */ bool ecl_wild_string_p(cl_object item) { if (ECL_STRINGP(item)) { cl_index i, l = ecl_length(item); for (i = 0; i < l; i++) { ecl_character c = ecl_char(item, i); if (c == '\\' || c == '*' || c == '?') return 1; } } return 0; } /* * Take two C strings and check if the first (s) one matches against * the pattern given by the second one (p). The pattern is that of a * Unix shell except for brackets and curly braces */ bool ecl_string_match(cl_object s, cl_index j, cl_index ls, cl_object p, cl_index i, cl_index lp) { while (i < lp) { cl_index cp = ecl_char(p, i); switch (cp) { case '*': { /* An asterisk in the pattern matches any * number of characters. We try the shortest * sequence that matches. */ cl_index cn = 0, next; for (next = i+1; next < lp && ((cn = ecl_char(p, next)) == '*'); next++) ; if (next == lp) { return TRUE; } while (j < ls) { if (ecl_string_match(s, j, ls, p, next, lp)) { return TRUE; } j++; } return FALSE; break; } case '?': /* Match any character */ if (j > ls) return FALSE; i++; j++; break; case '\\': /* Interpret a pattern character literally. Trailing slash is interpreted as a slash. */ if (++i >= lp) i--; default: if ((j >= ls) || (cp != ecl_char(s, j))) { /* Either there are no characters left in "s" * or the next character does not match. */ return FALSE; } i++; j++; } } /* At the end all characters should have been matched */ return (j >= ls); } static bool path_item_match(cl_object a, cl_object mask) { if (mask == @':wild') return TRUE; /* If a component in the tested path is a wildcard field, this can only be matched by the same wildcard field in the mask */ if (!ecl_stringp(a) || mask == ECL_NIL) return (a == mask); if (!ecl_stringp(mask)) FEerror("~S is not supported as mask for pathname-match-p", 1, mask); return ecl_string_match(a, 0, ecl_length(a), mask, 0, ecl_length(mask)); } static bool path_list_match(cl_object a, cl_object mask) { cl_object item_mask; while (!ecl_endp(mask)) { item_mask = CAR(mask); mask = CDR(mask); if (item_mask == @':wild-inferiors') { if (ecl_endp(mask)) return TRUE; while (!ecl_endp(a)) { if (path_list_match(a, mask)) return TRUE; a = CDR(a); } return FALSE; } else if (ecl_endp(a)) { /* A NIL directory should match against :absolute or :relative, in order to perform suitable translations. */ if (item_mask != @':absolute' && item_mask != @':relative') return FALSE; } else if (!path_item_match(CAR(a), item_mask)) { return FALSE; } else { a = CDR(a); } } if (!ecl_endp(a)) return FALSE; return TRUE; } cl_object cl_pathname_match_p(cl_object path, cl_object mask) { cl_object output = ECL_NIL; path = cl_pathname(path); mask = cl_pathname(mask); if (path->pathname.logical != mask->pathname.logical) goto OUTPUT; #if 0 /* INV: This was checked in the calling routine */ if (!path_item_match(path->pathname.host, mask->pathname.host)) goto OUTPUT; #endif /* Missing components default to :WILD */ if (!Null(mask->pathname.directory) && !path_list_match(path->pathname.directory, mask->pathname.directory)) goto OUTPUT; if (!path_item_match(path->pathname.name, mask->pathname.name)) goto OUTPUT; if (!path_item_match(path->pathname.type, mask->pathname.type)) goto OUTPUT; if (Null(mask->pathname.version) || path_item_match(path->pathname.version, mask->pathname.version)) output = ECL_T; OUTPUT: @(return output) } /* --------------- PATHNAME TRANSLATIONS ------------------ */ static cl_object coerce_to_from_pathname(cl_object x, cl_object host) { switch (ecl_t_of(x)) { #ifdef ECL_UNICODE case t_string: #endif case t_base_string: x = cl_parse_namestring(2, x, host); case t_pathname: if (x->pathname.logical) return x; default: FEerror("~S is not a valid from-pathname translation", 1, x); } } @(defun si::pathname-translations (host &optional (set OBJNULL)) cl_index parsed_len, len; cl_object pair, l; @ /* Check that host is a valid host name */ if (ecl_unlikely(!ECL_STRINGP(host))) FEwrong_type_nth_arg(@[si::pathname-translations], 1, host, @[string]); host = cl_string_upcase(1, host); len = ecl_length(host); parse_word(host, is_null, WORD_LOGICAL, 0, len, &parsed_len); if (parsed_len < len) { FEerror("Wrong host syntax ~S", 1, host); } /* Find its translation list */ pair = @assoc(4, host, cl_core.pathname_translations, @':test', @'string-equal'); if (set == OBJNULL) { @(return ((pair == ECL_NIL)? ECL_NIL : CADR(pair))); } /* Set the new translation list */ if (ecl_unlikely(!LISTP(set))) { FEwrong_type_nth_arg(@[si::pathname-translations], 2, set, @[list]); } if (pair == ECL_NIL) { pair = CONS(host, CONS(ECL_NIL, ECL_NIL)); cl_core.pathname_translations = CONS(pair, cl_core.pathname_translations); } for (l = set, set = ECL_NIL; !ecl_endp(l); l = CDR(l)) { cl_object item = CAR(l); cl_object from = coerce_to_from_pathname(cl_car(item), host); cl_object to = cl_pathname(cl_cadr(item)); set = CONS(CONS(from, CONS(to, ECL_NIL)), set); } set = cl_nreverse(set); ECL_RPLACA(ECL_CONS_CDR(pair), set); @(return set) @) static cl_object find_wilds(cl_object l, cl_object source, cl_object match) { cl_index i, j, k, ls, lm; if (match == @':wild') return ecl_list1(source); if (!ecl_stringp(match) || !ecl_stringp(source)) { if (match != source) return @':error'; return l; } ls = ecl_length(source); lm = ecl_length(match); for(i = j = 0; i < ls && j < lm; ) { cl_index pattern_char = ecl_char(match,j); if (pattern_char == '*') { for (j++, k = i; k < ls && ecl_char(source,k) != pattern_char; k++) ; l = CONS(make_one(source, i, k), l); i = k; continue; } if (ecl_char(source,i) != pattern_char) return @':error'; i++, j++; } if (i < ls || j < lm) return @':error'; return l; } static cl_object find_list_wilds(cl_object a, cl_object mask) { cl_object l = ECL_NIL, l2; while (!ecl_endp(mask)) { cl_object item_mask = CAR(mask); mask = CDR(mask); if (item_mask == @':wild-inferiors') { l2 = ECL_NIL; while (!path_list_match(a, mask)) { if (ecl_endp(a)) return @':error'; l2 = CONS(CAR(a),l2); a = CDR(a); } l = CONS(l2, l); } else if (ecl_endp(a)) { /* A NIL directory should match against :absolute or :relative, in order to perform suitable translations. */ if (item_mask != @':absolute' && item_mask != @':relative') return @':error'; } else { l2 = find_wilds(l, CAR(a), item_mask); if (l == @':error') return @':error'; if (!Null(l2)) l = CONS(l2, l); a = CDR(a); } } return @nreverse(l); } static cl_object copy_wildcards(cl_object *wilds_list, cl_object pattern) { cl_index i, l, j; bool new_string; cl_object wilds = *wilds_list, token; if (pattern == @':wild') { if (ecl_endp(wilds)) return @':error'; pattern = CAR(wilds); *wilds_list = CDR(wilds); return pattern; } if (pattern == @':wild-inferiors') return @':error'; if (!ecl_stringp(pattern)) return pattern; new_string = FALSE; l = ecl_length(pattern); token = si_get_buffer_string(); for (j = i = 0; i < l; ) { cl_index c = ecl_char(pattern, i); if (c != '*') { i++; continue; } if (i != j) { push_substring(token, pattern, j, i); } new_string = TRUE; if (ecl_endp(wilds)) { return @':error'; } push_string(token, CAR(wilds)); wilds = CDR(wilds); j = i++; } /* Only create a new string when needed */ if (new_string) { pattern = cl_copy_seq(token); } si_put_buffer_string(token); *wilds_list = wilds; return pattern; } static cl_object copy_list_wildcards(cl_object *wilds, cl_object to) { cl_object l = ECL_NIL; while (!ecl_endp(to)) { cl_object d, mask = CAR(to); if (mask == @':wild-inferiors') { cl_object list = *wilds; if (ecl_endp(list)) return @':error'; else { cl_object dirlist = CAR(list); if (CONSP(dirlist)) l = ecl_append(CAR(list), l); else if (!Null(CAR(list))) return @':error'; } *wilds = CDR(list); } else { d = copy_wildcards(wilds, CAR(to)); if (d == @':error') return d; l = CONS(d, l); } to = CDR(to); } if (CONSP(l)) l = @nreverse(l); return l; } @(defun translate-pathname (source from to &key ((:case scase) @':local')) cl_object wilds, d; cl_object host, device, directory, name, type, version; cl_object fromcase, tocase; @ /* The pathname from which we get the data */ source = cl_pathname(source); /* The mask applied to the source pathname */ from = cl_pathname(from); fromcase = normalize_case(from, @':local'); /* The pattern which says what the output should look like */ to = cl_pathname(to); tocase = normalize_case(to, @':local'); if (source->pathname.logical != from->pathname.logical) goto error; /* Match host names */ if (cl_string_equal(2, source->pathname.host, from->pathname.host) == ECL_NIL) goto error; host = to->pathname.host; /* Logical pathnames do not have devices. We just overwrite it. */ device = to->pathname.device; /* Match directories */ wilds = find_list_wilds(source->pathname.directory, from->pathname.directory); if (wilds == @':error') goto error; if (Null(to->pathname.directory)) { /* Missing components are replaced */ d = translate_list_case(source->pathname.directory, fromcase, tocase); } else { wilds = translate_list_case(wilds, fromcase, tocase); d = copy_list_wildcards(&wilds, to->pathname.directory); if (d == @':error') goto error; if (wilds != ECL_NIL) goto error2; } directory = d; /* Match name */ wilds = find_wilds(ECL_NIL, source->pathname.name, from->pathname.name); if (wilds == @':error') goto error2; if (Null(to->pathname.name)) { d = translate_component_case(source->pathname.name, fromcase, tocase); } else { wilds = translate_list_case(wilds, fromcase, tocase); d = copy_wildcards(&wilds, to->pathname.name); if (d == @':error') goto error; if (wilds != ECL_NIL) goto error2; } name = d; /* Match type */ wilds = find_wilds(ECL_NIL, source->pathname.type, from->pathname.type); if (wilds == @':error') goto error2; if (Null(to->pathname.type)) { d = translate_component_case(source->pathname.type, fromcase, tocase); } else { wilds = translate_list_case(wilds, fromcase, tocase); d = copy_wildcards(&wilds, to->pathname.type); if (d == @':error') goto error; if (wilds != ECL_NIL) goto error2; } type = d; /* Match version */ version = to->pathname.version; if (from->pathname.version == @':wild') { if (to->pathname.version == @':wild') { version = source->pathname.version; } } @(return ecl_make_pathname(host, device, directory, name, type, version, tocase)); error: FEerror("~S is not a specialization of path ~S", 2, source, from); error2: FEerror("Number of wildcards in ~S do not match ~S", 2, from, to); @) @(defun translate-logical-pathname (source &key) cl_object l, pair; cl_object pathname; @ pathname = cl_pathname(source); begin: if (!pathname->pathname.logical) { @(return pathname) } l = @si::pathname-translations(1, pathname->pathname.host); for(; !ecl_endp(l); l = CDR(l)) { pair = CAR(l); if (!Null(cl_pathname_match_p(pathname, CAR(pair)))) { pathname = cl_translate_pathname(3, pathname, CAR(pair), CADR(pair)); goto begin; } } FEerror("~S admits no logical pathname translations", 1, pathname); @) ecl-16.1.2/src/c/predicate.d000066400000000000000000000351471266352375300155100ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* predicate.c -- Predicates. */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #define ECL_INCLUDE_MATH_H #include #include cl_object cl_identity(cl_object x) { @(return x) } cl_object cl_null(cl_object x) { @(return (Null(x) ? ECL_T : ECL_NIL)) } cl_object cl_symbolp(cl_object x) { @(return (ECL_SYMBOLP(x) ? ECL_T : ECL_NIL)) } cl_object cl_atom(cl_object x) { @(return (ECL_ATOM(x) ? ECL_T : ECL_NIL)) } cl_object cl_consp(cl_object x) { @(return (CONSP(x) ? ECL_T : ECL_NIL)) } cl_object cl_listp(cl_object x) { @(return ((Null(x) || CONSP(x)) ? ECL_T : ECL_NIL)) } cl_object cl_numberp(cl_object x) { cl_type t = ecl_t_of(x); @(return (ECL_NUMBER_TYPE_P(t) ? ECL_T : ECL_NIL)) } /* Used in compiled code */ bool ecl_numberp(cl_object x) { cl_type t = ecl_t_of(x); return ECL_NUMBER_TYPE_P(t); } cl_object cl_integerp(cl_object x) { cl_type t = ecl_t_of(x); @(return ((t == t_fixnum || t == t_bignum) ? ECL_T : ECL_NIL)) } cl_object cl_rationalp(cl_object x) { cl_type t = ecl_t_of(x); @(return ((t == t_fixnum || t == t_bignum || t == t_ratio) ? ECL_T : ECL_NIL)) } cl_object cl_floatp(cl_object x) { @(return (floatp(x)? ECL_T : ECL_NIL)) } bool floatp(cl_object x) { cl_type t = ecl_t_of(x); return (t == t_singlefloat) || (t == t_doublefloat) #ifdef ECL_LONG_FLOAT || (t == t_longfloat) #endif ; } cl_object cl_realp(cl_object x) { cl_type t = ecl_t_of(x); @(return (ECL_REAL_TYPE_P(t) ? ECL_T : ECL_NIL)) } bool ecl_realp(cl_object x) { cl_type t = ecl_t_of(x); return ECL_REAL_TYPE_P(t); } cl_object cl_complexp(cl_object x) { @(return (ECL_COMPLEXP(x) ? ECL_T : ECL_NIL)) } cl_object cl_characterp(cl_object x) { @(return (ECL_CHARACTERP(x) ? ECL_T : ECL_NIL)) } #ifdef ECL_UNICODE cl_object si_base_char_p(cl_object c) { @(return ((ECL_CHARACTERP(c) && ECL_BASE_CHAR_P(c))? ECL_T : ECL_NIL)) } #endif bool ecl_stringp(cl_object x) { cl_type t = ecl_t_of(x); #ifdef ECL_UNICODE return t == t_base_string || t == t_string; #else return t == t_base_string; #endif } cl_object cl_stringp(cl_object x) { @(return (ECL_STRINGP(x)? ECL_T : ECL_NIL)) } cl_object cl_bit_vector_p(cl_object x) { @(return (ECL_BIT_VECTOR_P(x) ? ECL_T : ECL_NIL)) } cl_object cl_vectorp(cl_object x) { @(return (ECL_VECTORP(x) ? ECL_T : ECL_NIL)) } cl_object cl_simple_string_p(cl_object x) { @(return ((ECL_STRINGP(x) && !ECL_ADJUSTABLE_ARRAY_P(x) && !ECL_ARRAY_HAS_FILL_POINTER_P(x) && Null(CAR(x->base_string.displaced))) ? ECL_T : ECL_NIL)) } #ifdef ECL_UNICODE cl_object si_base_string_p(cl_object x) { @(return (ECL_BASE_STRING_P(x) ? ECL_T : ECL_NIL)) } #endif cl_object cl_simple_bit_vector_p(cl_object x) { @(return ((ECL_BIT_VECTOR_P(x) && !ECL_ADJUSTABLE_ARRAY_P(x) && !ECL_ARRAY_HAS_FILL_POINTER_P(x) && Null(CAR(x->vector.displaced))) ? ECL_T : ECL_NIL)) } cl_object cl_simple_vector_p(cl_object x) { cl_type t = ecl_t_of(x); @(return ((t == t_vector && !ECL_ADJUSTABLE_ARRAY_P(x) && !ECL_ARRAY_HAS_FILL_POINTER_P(x) && Null(CAR(x->vector.displaced)) && (cl_elttype)x->vector.elttype == ecl_aet_object) ? ECL_T : ECL_NIL)) } cl_object cl_arrayp(cl_object x) { @(return (ECL_ARRAYP(x) ? ECL_T : ECL_NIL)) } cl_object cl_packagep(cl_object x) { @(return (ECL_PACKAGEP(x) ? ECL_T : ECL_NIL)) } cl_object cl_functionp(cl_object x) { cl_type t; cl_object output; t = ecl_t_of(x); if (t == t_bytecodes || t == t_bclosure || t == t_cfun || t == t_cfunfixed || t == t_cclosure || (t == t_instance && x->instance.isgf)) output = ECL_T; else output = ECL_NIL; @(return output) } cl_object cl_compiled_function_p(cl_object x) { cl_type t = ecl_t_of(x); @(return ((t == t_bytecodes || t == t_bclosure || t == t_cfun || t == t_cfunfixed || t == t_cclosure) ? ECL_T : ECL_NIL)) } cl_object cl_eq(cl_object x, cl_object y) { @(return ((x == y) ? ECL_T : ECL_NIL)) } /* * EQL-comparison of floats. If we are using signed zeros and NaNs, * numeric comparison of floating points is not equivalent to bit-wise * equality. In particular every two NaNs always give false * (= #1=(/ 0.0 0.0) #1#) => NIL * and signed zeros always compare equal * (= 0 -0.0) => T * which is not the same as what EQL should return * (EQL #1=(/ 0.0 0.0) #1#) => T * (EQL 0 -0.0) => NIL * * Furthermore, we can not use bit comparisons because in some platforms * long double has unused bits that makes two long floats be = but not eql. */ #if !defined(ECL_SIGNED_ZERO) && !defined(ECL_IEEE_FP) # define FLOAT_EQL(a,b,type) return (a) == (b) #else # define FLOAT_EQL(a,b,type) { \ type xa = (a), xb = (b); \ if (xa == xb) { \ return signbit(xa) == signbit(xb); \ } else if (isnan(xa) || isnan(xb)) { \ return !memcmp(&xa, &xb, sizeof(type)); \ } else { \ return 0; \ } } #endif bool ecl_eql(cl_object x, cl_object y) { if (x == y) return TRUE; if (ECL_IMMEDIATE(x) || ECL_IMMEDIATE(y)) return FALSE; if (x->d.t != y->d.t) return FALSE; switch (x->d.t) { case t_bignum: return (_ecl_big_compare(x, y) == 0); case t_ratio: return (ecl_eql(x->ratio.num, y->ratio.num) && ecl_eql(x->ratio.den, y->ratio.den)); case t_singlefloat: FLOAT_EQL(ecl_single_float(x), ecl_single_float(y), float); case t_doublefloat: FLOAT_EQL(ecl_double_float(x), ecl_double_float(y), double); #ifdef ECL_LONG_FLOAT case t_longfloat: FLOAT_EQL(ecl_long_float(x), ecl_long_float(y), long double); #endif case t_complex: return (ecl_eql(x->complex.real, y->complex.real) && ecl_eql(x->complex.imag, y->complex.imag)); #ifdef ECL_SSE2 case t_sse_pack: return !memcmp(x->sse.data.b8, y->sse.data.b8, 16); #endif default: return FALSE; } } cl_object cl_eql(cl_object x, cl_object y) { @(return (ecl_eql(x, y) ? ECL_T : ECL_NIL)) } bool ecl_equal(register cl_object x, cl_object y) { cl_type tx, ty; BEGIN: if (x==y) return(TRUE); tx = ecl_t_of(x); ty = ecl_t_of(y); switch (tx) { case t_list: if (Null(x) || Null(y)) { /* If X is NIL, then X and Y must be EQ */ return FALSE; } if (tx != ty || !ecl_equal(CAR(x), CAR(y))) return FALSE; x = CDR(x); y = CDR(y); goto BEGIN; case t_symbol: case t_vector: case t_array: case t_fixnum: return FALSE; case t_bignum: return (tx == ty) && (_ecl_big_compare(x,y) == 0); case t_ratio: return (tx == ty) && ecl_eql(x->ratio.num, y->ratio.num) && ecl_eql(x->ratio.den, y->ratio.den); case t_singlefloat: { if (tx != ty) return 0; FLOAT_EQL(ecl_single_float(x), ecl_single_float(y), float); } case t_doublefloat: { if (tx != ty) return 0; FLOAT_EQL(ecl_double_float(x), ecl_double_float(y), double); } #ifdef ECL_LONG_FLOAT case t_longfloat: { if (tx != ty) return 0; FLOAT_EQL(ecl_long_float(x), ecl_long_float(y), long double); } #endif case t_complex: return (tx == ty) && ecl_eql(x->complex.real, y->complex.real) && ecl_eql(x->complex.imag, y->complex.imag); case t_character: return (tx == ty) && (ECL_CHAR_CODE(x) == ECL_CHAR_CODE(y)); case t_base_string: #ifdef ECL_UNICODE case t_string: if (ty != t_base_string && ty != t_string) return FALSE; #else if (ty != t_base_string) return FALSE; #endif return ecl_string_eq(x, y); case t_bitvector: { cl_index i, ox, oy; if (ty != tx) return FALSE; if (x->vector.fillp != y->vector.fillp) return(FALSE); ox = x->vector.offset; oy = y->vector.offset; for (i = 0; i < x->vector.fillp; i++) if((x->vector.self.bit[(i+ox)/8] & (0200>>(i+ox)%8)) !=(y->vector.self.bit[(i+oy)/8] & (0200>>(i+oy)%8))) return(FALSE); return(TRUE); } case t_pathname: return ty == tx && ecl_equal(x->pathname.host, y->pathname.host) && ecl_equal(x->pathname.device, y->pathname.device) && ecl_equal(x->pathname.directory, y->pathname.directory) && ecl_equal(x->pathname.name, y->pathname.name) && ecl_equal(x->pathname.type, y->pathname.type) && ecl_equal(x->pathname.version, y->pathname.version); case t_foreign: return (tx == ty) && (x->foreign.data == y->foreign.data); default: return FALSE; } } cl_object cl_equal(cl_object x, cl_object y) { @(return (ecl_equal(x, y) ? ECL_T : ECL_NIL)) } bool ecl_equalp(cl_object x, cl_object y) { cl_type tx, ty; cl_index j; BEGIN: if (x == y) return TRUE; tx = ecl_t_of(x); ty = ecl_t_of(y); switch (tx) { case t_fixnum: case t_bignum: case t_ratio: case t_singlefloat: case t_doublefloat: #ifdef ECL_LONG_FLOAT case t_longfloat: #endif case t_complex: return ECL_NUMBER_TYPE_P(ty) && ecl_number_equalp(x, y); case t_vector: case t_base_string: case t_bitvector: #ifdef ECL_UNICODE case t_string: if (ty != t_vector && ty != t_base_string && ty != t_bitvector && ty != t_string) return FALSE; #else if (ty != t_vector && ty != t_base_string && ty != t_bitvector) return FALSE; #endif j = x->vector.fillp; if (j != y->vector.fillp) return FALSE; goto ARRAY; case t_array: if (ty != t_array || x->array.rank != y->array.rank) return FALSE; if (x->array.rank > 1) { cl_index i = 0; for (i = 0; i < x->array.rank; i++) if (x->array.dims[i] != y->array.dims[i]) return(FALSE); } if (x->array.dim != y->array.dim) return(FALSE); j=x->array.dim; ARRAY: { cl_index i; for (i = 0; i < j; i++) if (!ecl_equalp(ecl_aref_unsafe(x, i), ecl_aref_unsafe(y, i))) return(FALSE); return(TRUE); } case t_character: return (ty == tx) && ecl_char_equal(x, y); case t_list: if ((tx != ty) || Null(x) || Null(y)) { /* X is NIL but it is not EQ to Y */ return FALSE; } if (!ecl_equalp(CAR(x), CAR(y))) return(FALSE); x = CDR(x); y = CDR(y); goto BEGIN; case t_instance: { cl_index i; if ((ty != tx) || (ECL_CLASS_OF(x) != ECL_CLASS_OF(y))) return(FALSE); for (i = 0; i < x->instance.length; i++) if (!ecl_equalp(x->instance.slots[i], y->instance.slots[i])) return(FALSE); return(TRUE); } case t_pathname: return (tx == ty) && ecl_equal(x, y); case t_hashtable: { if (tx != ty || x->hash.entries != y->hash.entries || x->hash.test != y->hash.test) return(FALSE); { cl_env_ptr env = ecl_process_env(); cl_object iterator = si_hash_table_iterator(x); do { cl_object ndx = _ecl_funcall1(iterator); if (Null(ndx)) { return TRUE; } else { cl_object key = env->values[1]; if (ecl_gethash_safe(key, y, OBJNULL) == OBJNULL) return FALSE; } } while (1); } } case t_random: return (tx == ty) && ecl_equalp(x->random.value, y->random.value); default: return ecl_eql(x,y); } } cl_object cl_equalp(cl_object x, cl_object y) { @(return (ecl_equalp(x, y) ? ECL_T : ECL_NIL)) } cl_object si_fixnump(cl_object x) { @(return (ECL_FIXNUMP(x) ? ECL_T : ECL_NIL)) } ecl-16.1.2/src/c/print.d000066400000000000000000000300241266352375300146710ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* print.d -- Print. */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #include #include cl_object _ecl_stream_or_default_output(cl_object stream) { if (Null(stream)) return ecl_symbol_value(@'*standard-output*'); else if (stream == ECL_T) return ecl_symbol_value(@'*terminal-io*'); return stream; } int ecl_print_base(void) { cl_object object = ecl_symbol_value(@'*print-base*'); cl_fixnum base; unlikely_if (!ECL_FIXNUMP(object) || (base = ecl_fixnum(object)) < 2 || base > 36) { ECL_SETQ(ecl_process_env(), @'*print-base*', ecl_make_fixnum(10)); FEerror("The value of *PRINT-BASE*~% ~S~%" "is not of the expected type (INTEGER 2 36)", 1, object); } return base; } cl_fixnum ecl_print_level(void) { cl_object object = ecl_symbol_value(@'*print-level*'); cl_fixnum level; if (object == ECL_NIL) { level = MOST_POSITIVE_FIXNUM; } else if (ECL_FIXNUMP(object)) { level = ecl_fixnum(object); if (level < 0) { ERROR: ECL_SETQ(ecl_process_env(), @'*print-level*', ECL_NIL); FEerror("The value of *PRINT-LEVEL*~% ~S~%" "is not of the expected type (OR NULL (INTEGER 0 *))", 1, object); } } else if (ecl_unlikely(!ECL_BIGNUMP(object))) { goto ERROR; } else { level = MOST_POSITIVE_FIXNUM; } return level; } cl_fixnum ecl_print_length(void) { cl_object object = ecl_symbol_value(@'*print-length*'); cl_fixnum length; if (object == ECL_NIL) { length = MOST_POSITIVE_FIXNUM; } else if (ECL_FIXNUMP(object)) { length = ecl_fixnum(object); unlikely_if (length < 0) { ERROR: ECL_SETQ(ecl_process_env(), @'*print-length*', ECL_NIL); FEerror("The value of *PRINT-LENGTH*~% ~S~%" "is not of the expected type (OR NULL (INTEGER 0 *))", 1, object); } } else if (ecl_unlikely(!ECL_BIGNUMP(object))) { goto ERROR; } else { length = MOST_POSITIVE_FIXNUM; } return length; } bool ecl_print_radix(void) { return ecl_symbol_value(@'*print-radix*') != ECL_NIL; } cl_object ecl_print_case(void) { cl_object output = ecl_symbol_value(@'*print-case*'); unlikely_if (output != @':upcase' && output != @':downcase' && output != @':capitalize') { ECL_SETQ(ecl_process_env(), @'*print-case*', @':downcase'); FEerror("The value of *PRINT-CASE*~% ~S~%" "is not of the expected type " "(MEMBER :UPCASE :DOWNCASE :CAPITALIZE)", 1, output); } return output; } bool ecl_print_gensym(void) { return ecl_symbol_value(@'*print-gensym*') != ECL_NIL; } bool ecl_print_array(void) { return ecl_symbol_value(@'*print-array*') != ECL_NIL; } bool ecl_print_readably(void) { return ecl_symbol_value(@'*print-readably*') != ECL_NIL; } bool ecl_print_escape(void) { return ecl_symbol_value(@'*print-escape*') != ECL_NIL; } bool ecl_print_circle(void) { return ecl_symbol_value(@'*print-circle*') != ECL_NIL; } @(defun write (x &key ((:stream strm) ECL_NIL) (array ecl_symbol_value(@'*print-array*')) (base ecl_symbol_value(@'*print-base*')) ((:case cas) ecl_symbol_value(@'*print-case*')) (circle ecl_symbol_value(@'*print-circle*')) (escape ecl_symbol_value(@'*print-escape*')) (gensym ecl_symbol_value(@'*print-gensym*')) (length ecl_symbol_value(@'*print-length*')) (level ecl_symbol_value(@'*print-level*')) (lines ecl_symbol_value(@'*print-lines*')) (miser_width ecl_symbol_value(@'*print-miser-width*')) (pprint_dispatch ecl_symbol_value(@'*print-pprint-dispatch*')) (pretty ecl_symbol_value(@'*print-pretty*')) (radix ecl_symbol_value(@'*print-radix*')) (readably ecl_symbol_value(@'*print-readably*')) (right_margin ecl_symbol_value(@'*print-right-margin*'))) @{ ecl_bds_bind(the_env, @'*print-array*', array); ecl_bds_bind(the_env, @'*print-base*', base); ecl_bds_bind(the_env, @'*print-case*', cas); ecl_bds_bind(the_env, @'*print-circle*', circle); ecl_bds_bind(the_env, @'*print-escape*', escape); ecl_bds_bind(the_env, @'*print-gensym*', gensym); ecl_bds_bind(the_env, @'*print-level*', level); ecl_bds_bind(the_env, @'*print-length*', length); ecl_bds_bind(the_env, @'*print-lines*', lines); ecl_bds_bind(the_env, @'*print-miser-width*', miser_width); ecl_bds_bind(the_env, @'*print-pprint-dispatch*', pprint_dispatch); ecl_bds_bind(the_env, @'*print-pretty*', pretty); ecl_bds_bind(the_env, @'*print-radix*', radix); ecl_bds_bind(the_env, @'*print-readably*', readably); ecl_bds_bind(the_env, @'*print-right-margin*', right_margin); strm = _ecl_stream_or_default_output(strm); si_write_object(x, strm); ecl_force_output(strm); ecl_bds_unwind_n(the_env, 15); @(return x) @) @(defun prin1 (obj &optional strm) @ ecl_prin1(obj, strm); @(return obj) @) @(defun print (obj &optional strm) @ ecl_print(obj, strm); @(return obj) @) @(defun pprint (obj &optional strm) @ strm = _ecl_stream_or_default_output(strm); ecl_bds_bind(the_env, @'*print-escape*', ECL_T); ecl_bds_bind(the_env, @'*print-pretty*', ECL_T); ecl_write_char('\n', strm); si_write_object(obj, strm); ecl_force_output(strm); ecl_bds_unwind_n(the_env, 2); @(return) @) @(defun princ (obj &optional strm) @ ecl_princ(obj, strm); @(return obj) @) @(defun write-char (c &optional strm) @ /* INV: ecl_char_code() checks the type of `c' */ strm = _ecl_stream_or_default_output(strm); c = ECL_CODE_CHAR(ecl_write_char(ecl_char_code(c), strm)); @(return c) @) @(defun write-string (strng &o strm &k (start ecl_make_fixnum(0)) end) @ unlikely_if (!ECL_STRINGP(strng)) FEwrong_type_nth_arg(@[write-string], 1, strng, @[string]); strm = _ecl_stream_or_default_output(strm); #ifdef ECL_CLOS_STREAMS if (!ECL_ANSI_STREAM_P(strm)) _ecl_funcall5(@'gray::stream-write-string', strm, strng, start, end); else #endif si_do_write_sequence(strng, strm, start, end); @(return strng) @) @(defun write-line (strng &o strm &k (start ecl_make_fixnum(0)) end) @ unlikely_if (!ECL_STRINGP(strng)) FEwrong_type_nth_arg(@[write-line], 1, strng, @[string]); strm = _ecl_stream_or_default_output(strm); #ifdef ECL_CLOS_STREAMS if (!ECL_ANSI_STREAM_P(strm)) _ecl_funcall5(@'gray::stream-write-string', strm, strng, start, end); else #endif si_do_write_sequence(strng, strm, start, end); ecl_terpri(strm); @(return strng) @) @(defun terpri (&optional strm) @ ecl_terpri(strm); @(return ECL_NIL) @) @(defun fresh-line (&optional strm) @ strm = _ecl_stream_or_default_output(strm); #ifdef ECL_CLOS_STREAMS if (!ECL_ANSI_STREAM_P(strm)) { return _ecl_funcall2(@'gray::stream-fresh-line', strm); } #endif if (ecl_file_column(strm) == 0) @(return ECL_NIL) ecl_write_char('\n', strm); ecl_force_output(strm); @(return ECL_T) @) @(defun finish-output (&o strm) @ strm = _ecl_stream_or_default_output(strm); #ifdef ECL_CLOS_STREAMS if (!ECL_ANSI_STREAM_P(strm)) { return _ecl_funcall2(@'gray::stream-finish-output', strm); } #endif ecl_force_output(strm); @(return ECL_NIL) @) @(defun force-output (&o strm) @ strm = _ecl_stream_or_default_output(strm); ecl_force_output(strm); @(return ECL_NIL) @) @(defun clear-output (&o strm) @ strm = _ecl_stream_or_default_output(strm); ecl_clear_output(strm); @(return ECL_NIL) @) cl_object cl_write_byte(cl_object integer, cl_object binary_output_stream) { ecl_write_byte(integer, binary_output_stream); @(return integer) } @(defun write-sequence (sequence stream &key (start ecl_make_fixnum(0)) end) @ #ifdef ECL_CLOS_STREAMS if (!ECL_ANSI_STREAM_P(stream)) { return _ecl_funcall5(@'gray::stream-write-sequence', stream, sequence, start, end); } else #endif return si_do_write_sequence(sequence, stream, start, end); @) cl_object ecl_princ(cl_object obj, cl_object strm) { const cl_env_ptr the_env = ecl_process_env(); strm = _ecl_stream_or_default_output(strm); ecl_bds_bind(the_env, @'*print-escape*', ECL_NIL); ecl_bds_bind(the_env, @'*print-readably*', ECL_NIL); si_write_object(obj, strm); ecl_bds_unwind_n(the_env, 2); return obj; } cl_object ecl_prin1(cl_object obj, cl_object strm) { const cl_env_ptr the_env = ecl_process_env(); strm = _ecl_stream_or_default_output(strm); ecl_bds_bind(the_env, @'*print-escape*', ECL_T); si_write_object(obj, strm); ecl_force_output(strm); ecl_bds_unwind1(the_env); return obj; } cl_object ecl_print(cl_object obj, cl_object strm) { strm = _ecl_stream_or_default_output(strm); ecl_terpri(strm); ecl_prin1(obj, strm); ecl_princ_char(' ', strm); return obj; } cl_object ecl_terpri(cl_object strm) { strm = _ecl_stream_or_default_output(strm); #ifdef ECL_CLOS_STREAMS if (!ECL_ANSI_STREAM_P(strm)) { return _ecl_funcall2(@'gray::stream-terpri', strm); } #endif ecl_write_char('\n', strm); ecl_force_output(strm); return(ECL_NIL); } void ecl_write_string(cl_object strng, cl_object strm) { cl_index i; strm = _ecl_stream_or_default_output(strm); switch(ecl_t_of(strng)) { #ifdef ECL_UNICODE case t_string: for (i = 0; i < strng->string.fillp; i++) ecl_write_char(strng->string.self[i], strm); break; #endif case t_base_string: for (i = 0; i < strng->base_string.fillp; i++) ecl_write_char(strng->base_string.self[i], strm); break; default: FEwrong_type_nth_arg(@[write-string], 1, strng, @[string]); } ecl_force_output(strm); } /* THE ULTRA-SPECIAL-DINNER-SERVICE OPTIMIZATION */ void ecl_princ_str(const char *s, cl_object strm) { strm = _ecl_stream_or_default_output(strm); writestr_stream(s, strm); } int ecl_princ_char(int c, cl_object strm) { strm = _ecl_stream_or_default_output(strm); ecl_write_char(c, strm); if (c == '\n') { ecl_force_output(strm); } return c; } ecl-16.1.2/src/c/printer/000077500000000000000000000000001266352375300150545ustar00rootroot00000000000000ecl-16.1.2/src/c/printer/float_string_old.d000066400000000000000000000343121266352375300205550ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* Copyright (c) 2010, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../../Copyright' for full details. */ #include #include /* * This is a port of CMUCL's FLOAT-STRING routine which converts a * floating point number of arbitrary representation into a text * representation which contains the least number of digits for the * given precision. */ /* Written by Bill Maddox * Translated to C by Juan Jose Garcia Ripoll * * FLONUM-TO-STRING (and its subsidiary function FLOAT-STRING) does most of * the work for all printing of floating point numbers in the printer and in * FORMAT. It converts a floating point number to a string in a free or * fixed format with no exponent. The interpretation of the arguments is as * follows: * * X - The floating point number to convert, which must not be * negative. * WIDTH - The preferred field width, used to determine the number * of fraction digits to produce if the FDIGITS parameter * is unspecified or NIL. If the non-fraction digits and the * decimal point alone exceed this width, no fraction digits * will be produced unless a non-NIL value of FDIGITS has been * specified. Field overflow is not considerd an error at this * level. * FDIGITS - The number of fractional digits to produce. Insignificant * trailing zeroes may be introduced as needed. May be * unspecified or NIL, in which case as many digits as possible * are generated, subject to the constraint that there are no * trailing zeroes. * SCALE - If this parameter is specified or non-NIL, then the number * printed is (* x (expt 10 scale)). This scaling is exact, * and cannot lose precision. * FMIN - This parameter, if specified or non-NIL, is the minimum * number of fraction digits which will be produced, regardless * of the value of WIDTH or FDIGITS. This feature is used by * the ~E format directive to prevent complete loss of * significance in the printed value due to a bogus choice of * scale factor. * * Most of the optional arguments are for the benefit for FORMAT and are not * used by the printer. * * Returns: * (VALUES DIGIT-STRING DIGIT-LENGTH LEADING-POINT TRAILING-POINT DECPNT) * where the results have the following interpretation: * * DIGIT-STRING - The decimal representation of X, with decimal point. * DIGIT-LENGTH - The length of the string DIGIT-STRING. * LEADING-POINT - True if the first character of DIGIT-STRING is the * decimal point. * TRAILING-POINT - True if the last character of DIGIT-STRING is the * decimal point. * POINT-POS - The position of the digit preceding the decimal * point. Zero indicates point before first digit. * * NOTE: FLONUM-TO-STRING goes to a lot of trouble to guarantee accuracy. * Specifically, the decimal number printed is the closest possible * approximation to the true value of the binary number to be printed from * among all decimal representations with the same number of digits. In * free-format output, i.e. with the number of digits unconstrained, it is * guaranteed that all the information is preserved, so that a properly- * rounding reader can reconstruct the original binary number, bit-for-bit, * from its printed decimal representation. Furthermore, only as many digits * as necessary to satisfy this condition will be printed. * * * FLOAT-STRING actually generates the digits for positive numbers. The * algorithm is essentially that of algorithm Dragon4 in "How to Print * Floating-Point Numbers Accurately" by Steele and White. The current * (draft) version of this paper may be found in [CMUC]tradix.press. * DO NOT EVEN THINK OF ATTEMPTING TO UNDERSTAND THIS CODE WITHOUT READING * THE PAPER! */ static bool large_mantissa(cl_object r, cl_object mp, cl_object s) { return ecl_greatereq(ecl_plus(ecl_ash(r,1), mp), ecl_ash(s, 1)); } static cl_fixnum assert_floating_point_width(cl_object width) { if (!ECL_FIXNUMP(width) || ecl_lower(width,ecl_make_fixnum(1))) { FEerror("Invalid number of floating point digits." "~%~A~%is not an integer within bounds", 1, width); } return ecl_fixnum(width); } static cl_object float_string(cl_object digits_string, cl_object fraction, cl_object exponent, cl_object precision, cl_object width, cl_object fdigits, cl_object scale, cl_object fmin) { cl_object r = fraction; cl_object s = ecl_make_fixnum(1); cl_object mm = s; cl_object mp = s; cl_fixnum i, k = 0, digits = 0, decpnt = 0, cutoff = 0; cl_object u; char *buffer; bool roundup = 0, cutoffp = 0, low = 0, high = 0; if (Null(digits_string)) { digits_string = si_make_vector(@'base-char', ecl_make_fixnum(10), ECL_T /* adjustable */, ecl_make_fixnum(0) /* fill pointer */, ECL_NIL /* displacement */, ECL_NIL /* displ. offset */); } /* Represent fraction as r/s, error bounds as m+/s and m-/s. * Rational arithmetic avoids loss of precision in subsequent * calculations. */ { int sign = ecl_number_compare(exponent, ecl_make_fixnum(0)); if (sign > 0) { r = cl_ash(fraction, exponent); mm = cl_ash(ecl_make_fixnum(1), exponent); mp = mm; } else if (sign < 0) { s = cl_ash(ecl_make_fixnum(1), ecl_negate(exponent)); } } /* Adjust error bounds m+ and m- for unequal gaps */ if (ecl_number_equalp(fraction, cl_ash(ecl_make_fixnum(1), precision))) { mp = ecl_ash(mm, 1); r = ecl_ash(r, 1); s = ecl_ash(s, 1); } /* Scale value by requested amount and update error bounds */ if (!Null(scale)) { if (ecl_minusp(scale)) { cl_object factor = cl_expt(ecl_make_fixnum(10), ecl_negate(scale)); s = ecl_times(s, factor); } else { cl_object factor = cl_expt(ecl_make_fixnum(10), scale); r = ecl_times(r, factor); mm = ecl_times(mm, factor); mp = ecl_times(mp, factor); } } while (ecl_lower(r, ecl_ceiling2(s, ecl_make_fixnum(10)))) { k--; r = ecl_times(r, ecl_make_fixnum(10)); mm = ecl_times(r, ecl_make_fixnum(10)); mp = ecl_times(r, ecl_make_fixnum(10)); } do { /* Ensure mantissa (r + m+)/s is smaller than one */ while (large_mantissa(r, mp, s)) { s = ecl_times(s, ecl_make_fixnum(10)); k++; } /* Determine the number of digits to generate */ if (!Null(fdigits)) { cutoffp = 1; cutoff = assert_floating_point_width(width); } else if (!Null(width)) { cutoffp = 1; cutoff = assert_floating_point_width(width); if (k < 0) { cutoff = cutoff - 1; } else { cutoff = cutoff - k + 1; } } /* ... and ensure it is never less than fmin */ if (cutoffp) { cl_fixnum a, i; cl_object y; if (!Null(fmin)) { cl_fixnum f = assert_floating_point_width(fmin); if (cutoff < f) cutoff = f; } /* If we decided to cut off digit generation before precision * has been exhausted, rounding the last digit may cause a * carry propagation. We can prevent this, preserving * left-to-right digit generation, with a few magical * adjustments to m- and m+. Of course, correct rounding is * also preserved. */ a = k - cutoff; y = s; if (a < 0) { for (i = 0, a = -a; i < a; i++) { y = ecl_ceiling2(y, ecl_make_fixnum(10)); } } else { for (i = 0, a = -a; i < a; i++) { y = ecl_times(y, ecl_make_fixnum(10)); } } mm = cl_max(2, y, mm); mp = cl_max(2, y, mp); roundup = ecl_number_equalp(mp, y); } } while (large_mantissa(r, mp, s)); /* Zero-fill before fraction if no integer part */ if (k < 0) { decpnt = digits; ecl_string_push_extend(digits_string, '.'); for (i = k; i; i++) { digits++; ecl_string_push_extend(digits_string, '0'); } } /* Generate least significant digits */ do { int sign; if (--k == -1) { ecl_string_push_extend(digits_string, '.'); decpnt = digits; } u = ecl_truncate2(ecl_times(r, ecl_make_fixnum(10)), s); r = VALUES(1); mm = ecl_times(mm, ecl_make_fixnum(10)); mp = ecl_times(mp, ecl_make_fixnum(10)); low = ecl_lower(ecl_ash(r,1), mm); sign = ecl_number_compare(ecl_ash(r,1), ecl_minus(ecl_ash(s,1),mp)); high = roundup? (sign >= 0) : (sign > 0); /* stop when either precision is exhausted or we have printed as many * fraction digits as permitted */ if (low || high || (cutoffp && (k + cutoff <= 0))) break; ecl_string_push_extend(digits_string, ecl_digit_char(ecl_fixnum(u), 10)); digits++; } while(1); /* If cutof occured before first digit, then no digits generated at all */ if (!cutoffp || (k + cutoff) >= 0) { /* Last digit may need rounding */ int digit = ecl_fixnum(u); if (low && !high) digit = ecl_fixnum(u); else if (high && !low) digit = ecl_fixnum(u)+1; else if (ecl_lower(ecl_ash(r,1), s)) digit = ecl_fixnum(u); else digit = ecl_fixnum(u) + 1; ecl_string_push_extend(digits_string, ecl_digit_char(digit, 10)); digits++; } /* Zero-fill after integer part if no fraction */ if (k >= 0) { for (i = 0; i < k; i++) { ecl_string_push_extend(digits_string, '0'); digits++; } ecl_string_push_extend(digits_string, '.'); decpnt = digits; } /* Add trailing zeroes to pad fraction if fdigits needed */ if (!Null(fdigits)) { cl_fixnum f = assert_floating_point_width(fdigits) - (digits - decpnt); for (i = 0; i < f; i++) { ecl_string_push_extend(digits_string, '0'); digits++; } } /* All done */ @(return digits_string ecl_make_fixnum(1+digits) ((decpnt == 0)? ECL_T : ECL_NIL) ((decpnt == digits)? ECL_T : ECL_NIL) ecl_make_fixnum(decpnt)) } ecl_def_ct_base_string(str_dot,".",1,static,const); @(defun ext::float-string (string x &optional width fdigits scale fmin) @ { if (ecl_zerop(x)) { if (Null(fdigits)) { cl_object s = cl_make_string(3, ecl_one_plus(fdigits), @':initial-element', ECL_CODE_CHAR('0')); ecl_char_set(s, 0, '.'); @(return s cl_length(s) ECL_T cl_zerop(fdigits) ecl_make_fixnum(0)); } else { @(return str_dot ecl_make_fixnum(1) ECL_T ECL_T ecl_make_fixnum(0)); } } else { cl_object sig = cl_integer_decode_float(x); cl_object exp = VALUES(1); cl_object precision = cl_float_precision(x); cl_object digits = cl_float_digits(x); cl_object fudge = ecl_minus(digits, precision); cl_object w = Null(width)? ECL_NIL : cl_max(2, width, ecl_make_fixnum(1)); return float_string(string, cl_ash(sig, ecl_negate(fudge)), ecl_plus(exp, fudge), precision, w, fdigits, scale, fmin); } } @) ecl-16.1.2/src/c/printer/float_to_digits.d000066400000000000000000000174131266352375300204010ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* Copyright (c) 2010, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../../Copyright' for full details. */ #define ECL_INCLUDE_MATH_H #include #include #include #define PRINT_BASE ecl_make_fixnum(10) #define EXPT_RADIX(x) ecl_ash(ecl_make_fixnum(1),x) typedef struct { cl_object r; cl_object s; cl_object mm; cl_object mp; bool high_ok; bool low_ok; } float_approx; static cl_object times2(cl_object x) { return ecl_plus(x, x); } static float_approx * setup(cl_object number, float_approx *approx) { cl_object f = cl_integer_decode_float(number); cl_fixnum e = ecl_fixnum(VALUES(1)), min_e; bool limit_f = 0; switch (ecl_t_of(number)) { case t_singlefloat: min_e = FLT_MIN_EXP; limit_f = (number->SF.SFVAL == ldexpf(FLT_RADIX, FLT_MANT_DIG-1)); break; case t_doublefloat: min_e = DBL_MIN_EXP; limit_f = (number->DF.DFVAL == ldexp(FLT_RADIX, DBL_MANT_DIG-1)); break; #ifdef ECL_LONG_FLOAT case t_longfloat: min_e = LDBL_MIN_EXP; limit_f = (number->longfloat.value == ldexpl(FLT_RADIX, LDBL_MANT_DIG-1)); #endif } approx->low_ok = approx->high_ok = ecl_evenp(f); if (e > 0) { cl_object be = EXPT_RADIX(e); if (limit_f) { cl_object be1 = ecl_times(be, ecl_make_fixnum(FLT_RADIX)); approx->r = times2(ecl_times(f, be1)); approx->s = ecl_make_fixnum(FLT_RADIX*2); approx->mm = be; approx->mp = be1; } else { approx->r = times2(ecl_times(f, be)); approx->s = ecl_make_fixnum(2); approx->mm = be; approx->mp = be; } } else if (!limit_f || (e == min_e)) { approx->r = times2(f); approx->s = times2(EXPT_RADIX(-e)); approx->mp = ecl_make_fixnum(1); approx->mm = ecl_make_fixnum(1); } else { approx->r = times2(ecl_make_fixnum(FLT_RADIX)); approx->s = times2(EXPT_RADIX(1-e)); approx->mp = ecl_make_fixnum(FLT_RADIX); approx->mm = ecl_make_fixnum(1); } return approx; } static cl_fixnum scale(float_approx *approx) { cl_fixnum k = 0; cl_object x = ecl_plus(approx->r, approx->mp); int sign; do { sign = ecl_number_compare(x, approx->s); if (approx->high_ok) { if (sign < 0) break; } else { if (sign <= 0) break; } approx->s = ecl_times(approx->s, PRINT_BASE); k++; } while(1); do { x = ecl_times(x, PRINT_BASE); sign = ecl_number_compare(x, approx->s); if (approx->high_ok) { if (sign >= 0) break; } else { if (sign > 0) break; } k--; approx->r = ecl_times(approx->r, PRINT_BASE); approx->mm = ecl_times(approx->mm, PRINT_BASE); approx->mp = ecl_times(approx->mp, PRINT_BASE); } while(1); return k; } static cl_object generate(cl_object digits, float_approx *approx) { cl_object d, x; cl_fixnum digit; bool tc1, tc2; do { d = ecl_truncate2(ecl_times(approx->r, PRINT_BASE), approx->s); approx->r = VALUES(1); approx->mp = ecl_times(approx->mp, PRINT_BASE); approx->mm = ecl_times(approx->mm, PRINT_BASE); tc1 = approx->low_ok? ecl_lowereq(approx->r, approx->mm) : ecl_lower(approx->r, approx->mm); x = ecl_plus(approx->r, approx->mp); tc2 = approx->high_ok? ecl_greatereq(x, approx->s) : ecl_greater(x, approx->s); if (tc1 || tc2) { break; } ecl_string_push_extend(digits, ecl_digit_char(ecl_fixnum(d), 10)); } while (1); if (tc2 && !tc1) { digit = ecl_fixnum(d) + 1; } else if (tc1 && !tc2) { digit = ecl_fixnum(d); } else if (ecl_lower(times2(approx->r), approx->s)) { digit = ecl_fixnum(d); } else { digit = ecl_fixnum(d) + 1; } ecl_string_push_extend(digits, ecl_digit_char(digit, 10)); return digits; } static void change_precision(float_approx *approx, cl_object position, cl_object relativep) { cl_fixnum pos; if (Null(position)) return; pos = ecl_fixnum(position); if (!Null(relativep)) { cl_object k = ecl_make_fixnum(0); cl_object l = ecl_make_fixnum(1); while (ecl_lower(ecl_times(approx->s, l), ecl_plus(approx->r, approx->mp))) { k = ecl_one_plus(k); l = ecl_times(l, PRINT_BASE); } position = ecl_minus(k, position); { cl_object e1 = cl_expt(PRINT_BASE, position); cl_object e2 = ecl_divide(e1, ecl_make_fixnum(2)); cl_object e3 = cl_expt(PRINT_BASE, k); if (ecl_greatereq(ecl_plus(approx->r, ecl_times(approx->s, e1)), ecl_times(approx->s, e2))) position = ecl_one_minus(position); } } { cl_object x = ecl_times(approx->s, cl_expt(PRINT_BASE, position)); cl_object e = ecl_divide(x, ecl_make_fixnum(2)); cl_object low = cl_max(2, approx->mm, e); cl_object high = cl_max(2, approx->mp, e); if (ecl_lowereq(approx->mm, low)) { approx->mm = low; approx->low_ok = 1; } if (ecl_lowereq(approx->mp, high)) { approx->mp = high; approx->high_ok = 1; } } } cl_object si_float_to_digits(cl_object digits, cl_object number, cl_object position, cl_object relativep) { cl_fixnum k; float_approx approx[1]; setup(number, approx); change_precision(approx, position, relativep); k = scale(approx); if (Null(digits)) digits = si_make_vector(@'base-char', ecl_make_fixnum(10), ECL_T /* adjustable */, ecl_make_fixnum(0) /* fill pointer */, ECL_NIL /* displacement */, ECL_NIL /* displ. offset */); generate(digits, approx); @(return ecl_make_fixnum(k) digits) } ecl-16.1.2/src/c/printer/float_to_string.d000066400000000000000000000107651266352375300204270ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* Copyright (c) 2010, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../../Copyright' for full details. */ #define ECL_INCLUDE_MATH_H #include #include #include cl_object _ecl_ensure_buffer(cl_object buffer, cl_fixnum length) { if (Null(buffer)) { buffer = si_make_vector(@'base-char', ecl_make_fixnum(length), ECL_T /* adjustable */, ecl_make_fixnum(0) /* fill pointer */, ECL_NIL /* displacement */, ECL_NIL /* displ. offset */); } return buffer; } void _ecl_string_push_c_string(cl_object s, const char *c) { for (; *c; c++) { ecl_string_push_extend(s, *c); } } static void insert_char(cl_object buffer, cl_index where, cl_fixnum c) { cl_fixnum end = buffer->base_string.fillp; ecl_string_push_extend(buffer, '.'); ecl_copy_subarray(buffer, where+1, buffer, where, end - where); ecl_char_set(buffer, where, c); } static cl_object push_base_string(cl_object buffer, cl_object s) { buffer = _ecl_ensure_buffer(buffer, s->base_string.fillp); _ecl_string_push_c_string(buffer, (char *)s->base_string.self); return buffer; } /********************************************************************** * FREE FORMAT (FIXED OR EXPONENT) OF FLOATS */ static void print_float_exponent(cl_object buffer, cl_object number, cl_fixnum exp) { cl_object r = ecl_symbol_value(@'*read-default-float-format*'); cl_fixnum e; switch (ecl_t_of(number)) { case t_singlefloat: e = (r == @'single-float' || r == @'short-float')? 'e' : 'f'; break; #ifdef ECL_LONG_FLOAT case t_longfloat: e = (r == @'long-float') ? 'e' : 'l'; break; case t_doublefloat: e = (r == @'double-float')? 'e' : 'd'; break; #else case t_doublefloat: e = (r == @'double-float' || r == @'long-float')? 'e' : 'd'; break; #endif } if (e != 'e' || exp != 0) { ecl_string_push_extend(buffer, e); si_integer_to_string(buffer, ecl_make_fixnum(exp), ecl_make_fixnum(10), ECL_NIL, ECL_NIL); } } cl_object si_float_to_string_free(cl_object buffer_or_nil, cl_object number, cl_object e_min, cl_object e_max) { cl_fixnum base, e; cl_object exp, buffer; if (ecl_float_nan_p(number)) { cl_object s = funcall(2, @'ext::float-nan-string', number); @(return push_base_string(buffer_or_nil, si_coerce_to_base_string(s))); } else if (ecl_float_infinity_p(number)) { cl_object s = funcall(2, @'ext::float-infinity-string', number); @(return push_base_string(buffer_or_nil, si_coerce_to_base_string(s))); } base = ecl_length(buffer_or_nil); exp = si_float_to_digits(buffer_or_nil, number, ECL_NIL, ECL_NIL); buffer = VALUES(1); e = ecl_fixnum(exp); if (ecl_signbit(number)) { insert_char(buffer, base++, '-'); } /* Do we have to print in exponent notation? */ if (ecl_lowereq(exp, e_min) || ecl_lowereq(e_max, exp)) { insert_char(buffer, base+1, '.'); print_float_exponent(buffer, number, e-1); } else if (e > 0) { cl_fixnum l = buffer->base_string.fillp - base; while (l++ <= e) { ecl_string_push_extend(buffer, '0'); } insert_char(buffer, base+e, '.'); print_float_exponent(buffer, number, 0); } else { insert_char(buffer, base++, '0'); insert_char(buffer, base++, '.'); for (e = -e; e; e--) { insert_char(buffer, base++, '0'); } print_float_exponent(buffer, number, 0); } @(return buffer); } ecl-16.1.2/src/c/printer/integer_to_string.d000066400000000000000000000070641266352375300207550ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* Copyright (c) 2010, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../../Copyright' for full details. */ #define ECL_INCLUDE_MATH_H #include #include #include static cl_object bignum_to_string(cl_object buffer, cl_object x, cl_object base) { cl_index str_size; int b; if (!ECL_FIXNUMP(base) || ((b = ecl_fixnum(base)) < 2) || (b > 36)) { FEwrong_type_nth_arg(@[si::integer-to-string], 3, base, cl_list(3, @'integer', ecl_make_fixnum(2), ecl_make_fixnum(36))); } str_size = mpz_sizeinbase(x->big.big_num, b); buffer = _ecl_ensure_buffer(buffer, str_size+1); if (str_size <= 62) { /* With the leading sign and the trailing null character, * only 62 digits fit in this buffer. */ char txt[64]; mpz_get_str(txt, -b, x->big.big_num); _ecl_string_push_c_string(buffer, txt); } else { char *txt = ecl_alloc_atomic(str_size + 2); mpz_get_str(txt, -b, x->big.big_num); _ecl_string_push_c_string(buffer, txt); ecl_dealloc(txt); } return buffer; } static void write_base_prefix(cl_object buffer, int base) { if (base == 2) { _ecl_string_push_c_string(buffer, "#b"); } else if (base == 8) { _ecl_string_push_c_string(buffer, "#o"); } else if (base == 16) { _ecl_string_push_c_string(buffer, "#x"); } else if (base >= 10) { char prefix[5] = "#00r"; prefix[1] = base/10 + '0'; prefix[2] = base%10 + '0'; _ecl_string_push_c_string(buffer, prefix); } else { char prefix[4] = "#0r"; prefix[1] = base + '0'; _ecl_string_push_c_string(buffer, prefix); } } cl_object si_integer_to_string(cl_object buffer, cl_object integer, cl_object base, cl_object radix, cl_object decimalp) { if (!Null(radix)) { if (Null(decimalp) || base != ecl_make_fixnum(10)) { buffer = _ecl_ensure_buffer(buffer, 10); write_base_prefix(buffer, ecl_fixnum(base)); } buffer = si_integer_to_string(buffer, integer, base, ECL_NIL, ECL_NIL); if (!Null(decimalp) && base == ecl_make_fixnum(10)) { _ecl_string_push_c_string(buffer, "."); } @(return buffer) } switch (ecl_t_of(integer)) { case t_fixnum: { cl_object big = _ecl_big_register0(); _ecl_big_set_fixnum(big, ecl_fixnum(integer)); buffer = bignum_to_string(buffer, big, base); _ecl_big_register_free(big); return buffer; } case t_bignum: return bignum_to_string(buffer, integer, base); default: FEwrong_type_nth_arg(@[si::integer-to-string], 2, @'integer', integer); } } ecl-16.1.2/src/c/printer/print_unreadable.d000066400000000000000000000053411266352375300205420ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* print_unreadable.d -- helper for print-unreadable-object macro */ /* Copyright (c) 2010, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #include void _ecl_write_addr(cl_object x, cl_object stream) { cl_fixnum i, j; i = (cl_index)x; for (j = sizeof(i)*8-4; j >= 0; j -= 4) { int k = (i>>j) & 0xf; if (k < 10) ecl_write_char('0' + k, stream); else ecl_write_char('a' + k - 10, stream); } } void _ecl_write_unreadable(cl_object x, const char *prefix, cl_object name, cl_object stream) { if (ecl_print_readably()) FEprint_not_readable(x); ecl_write_char('#', stream); ecl_write_char('<', stream); writestr_stream(prefix, stream); ecl_write_char(' ', stream); if (!Null(name)) { si_write_ugly_object(name, stream); } else { _ecl_write_addr(x, stream); } ecl_write_char('>', stream); } cl_object si_print_unreadable_object_function(cl_object o, cl_object stream, cl_object type, cl_object id, cl_object function) { if (ecl_print_readably()) FEprint_not_readable(o); stream = _ecl_stream_or_default_output(stream); if (ecl_print_level() == 0) { ecl_write_char('#', stream); } else { writestr_stream("#<", stream); if (!Null(type)) { cl_index i, l; type = cl_type_of(o); if (!ECL_SYMBOLP(type)) { type = @'standard-object'; } type = type->symbol.name; for (i = 0, l = ecl_length(type); i < l; i++) ecl_write_char(ecl_char_downcase(ecl_char(type, i)), stream); ecl_write_char(' ', stream); } if (!Null(function)) { _ecl_funcall1(function); } if (!Null(id)) { ecl_write_char(' ', stream); _ecl_write_addr(o, stream); } ecl_write_char('>', stream); } @(return ECL_NIL) } ecl-16.1.2/src/c/printer/write_array.d000066400000000000000000000164211266352375300175550ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* write_array.d -- File interface. */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #include static void write_array_inner(bool vector, cl_object x, cl_object stream) { cl_env_ptr env = ecl_process_env(); const cl_index *adims; cl_index subscripts[ECL_ARRAY_RANK_LIMIT]; cl_fixnum n, j, m, k, i; cl_fixnum print_length; cl_fixnum print_level; bool readably = ecl_print_readably(); if (vector) { adims = &x->vector.fillp; n = 1; } else { adims = x->array.dims; n = x->array.rank; } if (readably) { print_length = MOST_POSITIVE_FIXNUM; print_level = MOST_POSITIVE_FIXNUM; } else { if (!ecl_print_array()) { writestr_stream(vector? "#', stream); return; } print_level = ecl_print_level(); print_length = ecl_print_length(); } ecl_write_char('#', stream); if (print_level == 0) return; if (readably) { ecl_write_char('A', stream); ecl_write_char('(', stream); si_write_object(ecl_elttype_to_symbol(ecl_array_elttype(x)), stream); ecl_write_char(' ', stream); if (n > 0) { ecl_write_char('(', stream); for (j=0; j= n) { /* We can write the elements of the array */ print_level -= n; ecl_bds_bind(env, @'*print-level*', ecl_make_fixnum(print_level)); } else { /* The elements of the array are not printed */ n = print_level; print_level = -1; } for (j = 0; j < n; j++) subscripts[j] = 0; for (m = 0, j = 0;;) { for (i = j; i < n; i++) { if (subscripts[i] == 0) { ecl_write_char('(', stream); if (adims[i] == 0) { ecl_write_char(')', stream); j = i-1; k = 0; goto INC; } } if (subscripts[i] > 0) ecl_write_char(' ', stream); if (subscripts[i] >= print_length) { writestr_stream("...)", stream); k=adims[i]-subscripts[i]; subscripts[i] = 0; for (j = i+1; j < n; j++) k *= adims[j]; j = i-1; goto INC; } } /* FIXME: This conses! */ if (print_level >= 0) si_write_object(ecl_aref_unsafe(x, m), stream); else ecl_write_char('#', stream); j = n-1; k = 1; INC: while (j >= 0) { if (++subscripts[j] < adims[j]) break; subscripts[j] = 0; ecl_write_char(')', stream); --j; } if (j < 0) break; m += k; } if (print_level >= 0) { ecl_bds_unwind1(env); } if (readably) { ecl_write_char(')', stream); } } void _ecl_write_array(cl_object x, cl_object stream) { write_array_inner(0, x, stream); } void _ecl_write_vector(cl_object x, cl_object stream) { write_array_inner(1, x, stream); } #ifdef ECL_UNICODE void _ecl_write_string(cl_object x, cl_object stream) { cl_index ndx; if (!ecl_print_escape() && !ecl_print_readably()) { for (ndx = 0; ndx < x->string.fillp; ndx++) ecl_write_char(x->string.self[ndx], stream); } else { ecl_write_char('"', stream); for (ndx = 0; ndx < x->string.fillp; ndx++) { ecl_character c = x->string.self[ndx]; if (c == '"' || c == '\\') ecl_write_char('\\', stream); ecl_write_char(c, stream); } ecl_write_char('"', stream); } } #endif void _ecl_write_base_string(cl_object x, cl_object stream) { cl_index ndx; if (!ecl_print_escape() && !ecl_print_readably()) { for (ndx = 0; ndx < x->base_string.fillp; ndx++) ecl_write_char(x->base_string.self[ndx], stream); } else { ecl_write_char('"', stream); for (ndx = 0; ndx < x->base_string.fillp; ndx++) { int c = x->base_string.self[ndx]; if (c == '"' || c == '\\') ecl_write_char('\\', stream); ecl_write_char(c, stream); } ecl_write_char('"', stream); } } void _ecl_write_bitvector(cl_object x, cl_object stream) { if (!ecl_print_array() && !ecl_print_readably()) { writestr_stream("#', stream); } else { cl_index ndx; writestr_stream("#*", stream); for (ndx = 0; ndx < x->vector.fillp; ndx++) if (x->vector.self.bit[(ndx+x->vector.offset)/8] & (0200 >> (ndx+x->vector.offset)%8)) ecl_write_char('1', stream); else ecl_write_char('0', stream); } } ecl-16.1.2/src/c/printer/write_code.d000066400000000000000000000053371266352375300173550ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* write_list.d -- ugly printer for bytecodes and functions */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #include #include void _ecl_write_bytecodes(cl_object x, cl_object stream) { if (ecl_print_readably()) { cl_index i; cl_object lex = ECL_NIL; cl_object code_l=ECL_NIL; for ( i=x->bytecodes.code_size-1 ; i<(cl_index)(-1l) ; i-- ) code_l = ecl_cons(ecl_make_fixnum(((cl_opcode*)(x->bytecodes.code))[i]), code_l); writestr_stream("#Y", stream); si_write_ugly_object(cl_list(7, x->bytecodes.name, lex, ECL_NIL /* x->bytecodes.definition */, code_l, x->bytecodes.data, x->bytecodes.file, x->bytecodes.file_position), stream); } else { cl_object name = x->bytecodes.name; writestr_stream("#', stream); } } void _ecl_write_bclosure(cl_object x, cl_object stream) { if (ecl_print_readably()) { cl_object lex = x->bclosure.lex; if (Null(lex)) { _ecl_write_bytecodes(x->bclosure.code, stream); } else { writestr_stream("#Y", stream); si_write_ugly_object(cl_list(2, x->bclosure.code, lex), stream); } } else { cl_object name = x->bytecodes.name; writestr_stream("#', stream); } } ecl-16.1.2/src/c/printer/write_list.d000066400000000000000000000104041266352375300174050ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* write_list.d -- ugly printer for lists */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #include void _ecl_write_list(cl_object x, cl_object stream) { const cl_env_ptr env = ecl_process_env(); bool circle; cl_fixnum print_level, print_length; cl_index i; cl_object y; if (Null(x)) { _ecl_write_symbol(x, stream); return; } if (CAR(x) == @'si::#!') { writestr_stream("#!", stream); x = CDR(x); si_write_object(x, stream); return; } if (CONSP(CDR(x)) && Null(CDDR(x))) { if (CAR(x) == @'quote') { ecl_write_char('\'', stream); x = CADR(x); si_write_object(x, stream); return; } if (CAR(x) == @'function') { ecl_write_char('#', stream); ecl_write_char('\'', stream); x = CADR(x); si_write_object(x, stream); return; } if (CAR(x) == @'si::quasiquote') { ecl_write_char('`', stream); x = CADR(x); si_write_object(x, stream); return; } if (CAR(x) == @'si::unquote') { ecl_write_char(',', stream); x = CADR(x); si_write_object(x, stream); return; } if (CAR(x) == @'si::unquote-splice') { writestr_stream(",@@", stream); x = CADR(x); si_write_object(x, stream); return; } if (CAR(x) == @'si::unquote-nsplice') { writestr_stream(",.", stream); x = CADR(x); si_write_object(x, stream); return; } } circle = ecl_print_circle(); if (ecl_print_readably()) { print_level = MOST_POSITIVE_FIXNUM; print_length = MOST_POSITIVE_FIXNUM; } else { print_level = ecl_print_level(); print_length = ecl_print_length(); } if (print_level == 0) { ecl_write_char('#', stream); return; } ecl_bds_bind(env, @'*print-level*', ecl_make_fixnum(print_level-1)); ecl_write_char('(', stream); for (i = 0; ; i++) { if (i >= print_length) { writestr_stream("...", stream); break; } y = CAR(x); x = CDR(x); si_write_object(y, stream); /* FIXME! */ if (x == OBJNULL || ECL_ATOM(x) || (circle && _ecl_will_print_as_hash(x))) { if (x != ECL_NIL) { ecl_write_char(' ', stream); writestr_stream(". ", stream); si_write_object(x, stream); } break; } if (i == 0 && y != OBJNULL && ecl_t_of(y) == t_symbol) ecl_write_char(' ', stream); else ecl_write_char(' ', stream); } ecl_write_char(')', stream); ecl_bds_unwind1(env); } ecl-16.1.2/src/c/printer/write_object.d000066400000000000000000000141371266352375300177070ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* write_object.d -- basic printer routine. */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #include #include bool _ecl_will_print_as_hash(cl_object x) { cl_object circle_counter = ecl_symbol_value(@'si::*circle-counter*'); cl_object circle_stack = ecl_symbol_value(@'si::*circle-stack*'); cl_object code = ecl_gethash_safe(x, circle_stack, OBJNULL); if (ECL_FIXNUMP(circle_counter)) { return !(code == OBJNULL || code == ECL_NIL); } else if (code == OBJNULL) { /* Was not found before */ _ecl_sethash(x, circle_stack, ECL_NIL); return 0; } else { return 1; } } /* To print circular structures, we traverse the structure by adding a pair to the interpreter stack for each element visited. flag is initially NIL and becomes T if the element is visited again. After the visit we squeeze out all the non circular elements. The flags is used during printing to distinguish between the first visit to the element. */ static cl_fixnum search_print_circle(cl_object x) { cl_object circle_counter = ecl_symbol_value(@'si::*circle-counter*'); cl_object circle_stack = ecl_symbol_value(@'si::*circle-stack*'); cl_object code; if (!ECL_FIXNUMP(circle_counter)) { code = ecl_gethash_safe(x, circle_stack, OBJNULL); if (code == OBJNULL) { /* Was not found before */ _ecl_sethash(x, circle_stack, ECL_NIL); return 0; } else if (code == ECL_NIL) { /* This object is referenced twice */ _ecl_sethash(x, circle_stack, ECL_T); return 1; } else { return 2; } } else { code = ecl_gethash_safe(x, circle_stack, OBJNULL); if (code == OBJNULL || code == ECL_NIL) { /* Is not referenced or was not found before */ /* _ecl_sethash(x, circle_stack, ECL_NIL); */ return 0; } else if (code == ECL_T) { /* This object is referenced twice, but has no code yet */ cl_fixnum new_code = ecl_fixnum(circle_counter) + 1; circle_counter = ecl_make_fixnum(new_code); _ecl_sethash(x, circle_stack, circle_counter); ECL_SETQ(ecl_process_env(), @'si::*circle-counter*', circle_counter); return -new_code; } else { return ecl_fixnum(code); } } } cl_object si_write_object(cl_object x, cl_object stream) { bool circle; #ifdef ECL_CMU_FORMAT if (ecl_symbol_value(@'*print-pretty*') != ECL_NIL) { cl_object f = _ecl_funcall2(@'pprint-dispatch', x); if (VALUES(1) != ECL_NIL) { _ecl_funcall3(f, stream, x); goto OUTPUT; } } #endif /* ECL_CMU_FORMAT */ circle = ecl_print_circle(); if (circle && !Null(x) && !ECL_FIXNUMP(x) && !ECL_CHARACTERP(x) && (LISTP(x) || (x->d.t != t_symbol) || (Null(x->symbol.hpack)))) { cl_object circle_counter; cl_fixnum code; circle_counter = ecl_symbol_value(@'si::*circle-counter*'); if (circle_counter == ECL_NIL) { cl_env_ptr env = ecl_process_env(); cl_object hash = cl__make_hash_table(@'eq', ecl_make_fixnum(1024), cl_core.rehash_size, cl_core.rehash_threshold); ecl_bds_bind(env, @'si::*circle-counter*', ECL_T); ecl_bds_bind(env, @'si::*circle-stack*', hash); si_write_object(x, cl_core.null_stream); ECL_SETQ(env, @'si::*circle-counter*', ecl_make_fixnum(0)); si_write_object(x, stream); cl_clrhash(hash); ecl_bds_unwind_n(env, 2); goto OUTPUT; } code = search_print_circle(x); if (!ECL_FIXNUMP(circle_counter)) { /* We are only inspecting the object to be printed. */ /* Only run X if it was not referenced before */ if (code != 0) goto OUTPUT; } else if (code == 0) { /* Object is not referenced twice */ } else if (code < 0) { /* Object is referenced twice. We print its definition */ ecl_write_char('#', stream); _ecl_write_fixnum(-code, stream); ecl_write_char('=', stream); } else { /* Second reference to the object */ ecl_write_char('#', stream); _ecl_write_fixnum(code, stream); ecl_write_char('#', stream); goto OUTPUT; } } return si_write_ugly_object(x, stream); OUTPUT: @(return x) } ecl-16.1.2/src/c/printer/write_sse.d000066400000000000000000000060441266352375300172310ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* write_list.d -- ugly printer for SSE types */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #include #ifdef ECL_SSE2 static int is_all_FF(void *ptr, int size) { int i; for (i = 0; i < size; i++) if (((unsigned char*)ptr)[i] != 0xFF) return 0; return 1; } static void write_sse_float(float v, cl_object stream) { if (is_all_FF(&v, sizeof(float))) { writestr_stream(" TRUE", stream); } else { ecl_write_char(' ', stream); si_write_ugly_object(ecl_make_single_float(v), stream); } } static void write_sse_double(double v, cl_object stream) { if (is_all_FF(&v, sizeof(double))) writestr_stream(" TRUE", stream); else { ecl_write_char(' ', stream); si_write_ugly_object(ecl_make_double_float(v), stream); } } static void write_sse_pack(cl_object x, cl_object stream) { int i; cl_elttype etype = x->sse.elttype; cl_object mode = ecl_symbol_value(@'ext::*sse-pack-print-mode*'); if (mode != ECL_NIL) { if (mode == @':float') etype = ecl_aet_sf; else if (mode == @':double') etype = ecl_aet_df; else etype = ecl_aet_b8; } switch (etype) { case ecl_aet_sf: for (i = 0; i < 4; i++) write_sse_float(x->sse.data.sf[i], stream); break; case ecl_aet_df: write_sse_double(x->sse.data.df[0], stream); write_sse_double(x->sse.data.df[1], stream); break; default: { cl_object buffer = si_get_buffer_string(); for (i = 0; i < 16; i++) { ecl_string_push_extend(buffer, ' '); if (i%4 == 0) ecl_string_push_extend(buffer, ' '); si_integer_to_string(buffer, ecl_make_fixnum(x->sse.data.b8[i]), ecl_make_fixnum(16), ECL_NIL, ECL_NIL); } si_do_write_sequence(buffer, stream, ecl_make_fixnum(0), ECL_NIL); si_put_buffer_string(buffer); break; } } } void _ecl_write_sse(cl_object x, cl_object stream) { if (ecl_print_readably()) FEprint_not_readable(x); writestr_stream("#', stream); } #endif ecl-16.1.2/src/c/printer/write_symbol.d000066400000000000000000000204601266352375300177420ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* write_symbol.d -- print a symbol. */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #include static bool potential_number_p(cl_object s, int base) { /* See ANSI 2.3.1.1 */ static cl_index i, l; ecl_character c; /* A potential number must contain at least one digit */ bool some_digit = FALSE; l = s->base_string.fillp; if (l == 0) return FALSE; c = ecl_char(s, 0); /* A potential number must begin with a digit, sign or extension character (^ _) */ if (ecl_digitp(c,base) >= 0) some_digit = TRUE; else if (c != '+' && c != '-' && c != '^' && c != '_') return FALSE; /* A potential number cannot end with a sign */ c = ecl_char(s, l-1); if (c == '+' || c == '-') return FALSE; for (i = 1; i < l; i++) { c = ecl_char(s, i); /* It can only contain digits, signs, ratio markers, * extension characters and number markers. Number * markers are letters, but two adjacent letters fail * to be a number marker. */ if (ecl_digitp(c, base) >= 0) { some_digit = TRUE; } else if (c == '+' || c == '-' || c == '/' || c == '.' || c == '^' || c == '_') { continue; } else if (ecl_alpha_char_p(c) && (((i+1) >= l) || !ecl_alpha_char_p(ecl_char(s, i+1)))) { continue; } else { return FALSE; } } return some_digit; } #define needs_to_be_inverted(s) (ecl_string_case(s) != 0) static bool all_dots(cl_object s) { cl_index i; for (i = 0; i < s->base_string.fillp; i++) if (ecl_char(s, i) != '.') return 0; return 1; } static bool needs_to_be_escaped(cl_object s, cl_object readtable, cl_object print_case) { int action = readtable->readtable.read_case; cl_index i; if (potential_number_p(s, ecl_print_base())) return 1; /* The value of *PRINT-ESCAPE* is T. We need to check whether the * symbol name S needs to be escaped. This will happen if it has some * strange character, or if it has a lowercase character (because such * a character cannot be read with the standard readtable) or if the * string has to be escaped according to readtable case and the rules * of 22.1.3.3.2. */ for (i = 0; i < s->base_string.fillp; i++) { int c = ecl_char(s, i); int syntax = ecl_readtable_get(readtable, c, 0); if (syntax != cat_constituent || ecl_invalid_character_p(c) || (c) == ':') return 1; if ((action == ecl_case_downcase) && ecl_upper_case_p(c)) return 1; if (ecl_lower_case_p(c)) return 1; } return 0; } static void write_symbol_string(cl_object s, int action, cl_object print_case, cl_object stream, bool escape) { cl_index i; bool capitalize; if (action == ecl_case_invert) { if (!needs_to_be_inverted(s)) action = ecl_case_preserve; } if (escape) ecl_write_char('|', stream); capitalize = 1; for (i = 0; i < s->base_string.fillp; i++) { int c = ecl_char(s, i); if (escape) { if (c == '|' || c == '\\') { ecl_write_char('\\', stream); } } else if (action != ecl_case_preserve) { if (ecl_upper_case_p(c)) { if ((action == ecl_case_invert) || ((action == ecl_case_upcase) && ((print_case == @':downcase') || ((print_case == @':capitalize') && !capitalize)))) { c = ecl_char_downcase(c); } capitalize = 0; } else if (ecl_lower_case_p(c)) { if ((action == ecl_case_invert) || ((action == ecl_case_downcase) && ((print_case == @':upcase') || ((print_case == @':capitalize') && capitalize)))) { c = ecl_char_upcase(c); } capitalize = 0; } else { capitalize = !ecl_alphanumericp(c); } } ecl_write_char(c, stream); } if (escape) ecl_write_char('|', stream); } static bool forced_print_package(cl_object package) { cl_object print_package = ecl_symbol_value(@'si::*print-package*'); return !Null(print_package) && (print_package != package); } void _ecl_write_symbol(cl_object x, cl_object stream) { cl_object readtable = ecl_current_readtable(); cl_object print_case = ecl_print_case(); cl_object package; cl_object name; int intern_flag; bool print_readably = ecl_print_readably(); bool forced_package = 0; if (Null(x)) { package = ECL_NIL_SYMBOL->symbol.hpack; name = ECL_NIL_SYMBOL->symbol.name; } else { package = x->symbol.hpack; name = x->symbol.name; } if (!print_readably && !ecl_print_escape()) { write_symbol_string(name, readtable->readtable.read_case, print_case, stream, 0); return; } /* From here on, print-escape is true which means that it should * be possible to recover the same symbol by reading it with * the standard readtable (which has readtable-case = :UPCASE) */ if (Null(package)) { if (print_readably || ecl_print_gensym()) writestr_stream("#:", stream); } else if (package == cl_core.keyword_package) { ecl_write_char(':', stream); } else if ((forced_package = forced_print_package(package)) || ecl_find_symbol(name, ecl_current_package(), &intern_flag) != x || (intern_flag == 0)) { cl_object name = package->pack.name; write_symbol_string(name, readtable->readtable.read_case, print_case, stream, needs_to_be_escaped(name, readtable, print_case)); if (ecl_find_symbol(ecl_symbol_name(x), package, &intern_flag) != x) ecl_internal_error("can't print symbol"); if (intern_flag == ECL_INTERNAL || forced_package) { writestr_stream("::", stream); } else if (intern_flag == ECL_EXTERNAL) { ecl_write_char(':', stream); } else { FEerror("Pathological symbol --- cannot print.", 0); } } write_symbol_string(name, readtable->readtable.read_case, print_case, stream, needs_to_be_escaped(name, readtable, print_case) || all_dots(name)); } ecl-16.1.2/src/c/printer/write_ugly.d000066400000000000000000000351331266352375300174200ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* print.d -- Print. */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #include #include #ifndef _MSC_VER # include #endif #include #include static void write_readable_pathname(cl_object path, cl_object stream) { cl_object l = cl_list(15, @'make-pathname', @':host', path->pathname.host, @':device', path->pathname.device, @':directory', _ecl_funcall2(@'ext::maybe-quote', path->pathname.directory), @':name', path->pathname.name, @':type', path->pathname.type, @':version', path->pathname.version, @':defaults', ECL_NIL); writestr_stream("#.", stream); si_write_object(l, stream); } static void write_pathname(cl_object path, cl_object stream) { cl_object namestring = ecl_namestring(path, 0); bool readably = ecl_print_readably(); if (namestring == ECL_NIL) { if (readably) { write_readable_pathname(path, stream); return; } namestring = ecl_namestring(path, 1); if (namestring == ECL_NIL) { writestr_stream("#", stream); return; } } if (readably || ecl_print_escape()) writestr_stream("#P", stream); si_write_ugly_object(namestring, stream); } static void write_integer(cl_object number, cl_object stream) { cl_object s = si_get_buffer_string(); int print_base = ecl_print_base(); si_integer_to_string(s, number, ecl_make_fixnum(print_base), ecl_symbol_value(@'*print-radix*'), ECL_T /* decimal syntax */); si_do_write_sequence(s, stream, ecl_make_fixnum(0), ECL_NIL); si_put_buffer_string(s); } void _ecl_write_fixnum(cl_fixnum i, cl_object stream) { cl_object s = si_get_buffer_string(); si_integer_to_string(s, ecl_make_fixnum(i), ecl_make_fixnum(10), ECL_NIL, ECL_NIL); si_do_write_sequence(s, stream, ecl_make_fixnum(0), ECL_NIL); si_put_buffer_string(s); } static void write_ratio(cl_object r, cl_object stream) { cl_object s = si_get_buffer_string(); int print_base = ecl_print_base(); si_integer_to_string(s, r->ratio.num, ecl_make_fixnum(print_base), ecl_symbol_value(@'*print-radix*'), ECL_NIL /* decimal syntax */); ecl_string_push_extend(s, '/'); si_integer_to_string(s, r->ratio.den, ecl_make_fixnum(print_base), ECL_NIL, ECL_NIL); si_do_write_sequence(s, stream, ecl_make_fixnum(0), ECL_NIL); si_put_buffer_string(s); } static void write_complex(cl_object x, cl_object stream) { writestr_stream("#C(", stream); si_write_ugly_object(x->complex.real, stream); ecl_write_char(' ', stream); si_write_ugly_object(x->complex.imag, stream); ecl_write_char(')', stream); } static void write_float(cl_object f, cl_object stream) { cl_object s = si_get_buffer_string(); s = si_float_to_string_free(s, f, ecl_make_fixnum(-3), ecl_make_fixnum(8)); si_do_write_sequence(s, stream, ecl_make_fixnum(0), ECL_NIL); si_put_buffer_string(s); } static void write_character(cl_object x, cl_object stream) { int i = ECL_CHAR_CODE(x); if (!ecl_print_escape() && !ecl_print_readably()) { ecl_write_char(i, stream); } else { writestr_stream("#\\", stream); if (i < 32 || i >= 127) { cl_object name = cl_char_name(ECL_CODE_CHAR(i)); writestr_stream((char*)name->base_string.self, stream); } else { ecl_write_char(i, stream); } } } static void write_package(cl_object x, cl_object stream) { if (ecl_print_readably()) FEprint_not_readable(x); writestr_stream("#<", stream); si_write_ugly_object(x->pack.name, stream); writestr_stream(" package>", stream); } static void write_hashtable(cl_object x, cl_object stream) { if (ecl_print_readably() && !Null(ecl_symbol_value(@'*read-eval*'))) { cl_object make = cl_list(9, @'make-hash-table', @':size', cl_hash_table_size(x), @':rehash-size', cl_hash_table_rehash_size(x), @':rehash-threshold', cl_hash_table_rehash_threshold(x), @':test', cl_list(2, @'quote', cl_hash_table_test(x))); cl_object init = cl_list(3, @'ext::hash-table-fill', make, cl_list(2, @'quote', si_hash_table_content(x))); writestr_stream("#.", stream); si_write_ugly_object(init, stream); } else { _ecl_write_unreadable(x, "hash-table", ECL_NIL, stream); } } static void write_random(cl_object x, cl_object stream) { if (ecl_print_readably()) { writestr_stream("#$", stream); _ecl_write_vector(x->random.value, stream); } else { _ecl_write_unreadable(x->random.value, "random-state", ECL_NIL, stream); } } static void write_stream(cl_object x, cl_object stream) { const char *prefix; cl_object tag; union cl_lispunion str; #ifdef ECL_UNICODE ecl_character buffer[10]; #else ecl_base_char buffer[10]; #endif switch ((enum ecl_smmode)x->stream.mode) { case ecl_smm_input_file: prefix = "closed input file"; tag = IO_STREAM_FILENAME(x); break; case ecl_smm_input: prefix = "closed input stream"; tag = IO_STREAM_FILENAME(x); break; case ecl_smm_output_file: prefix = "closed output file"; tag = IO_STREAM_FILENAME(x); break; case ecl_smm_output: prefix = "closed output stream"; tag = IO_STREAM_FILENAME(x); break; #ifdef ECL_MS_WINDOWS_HOST case ecl_smm_input_wsock: prefix = "closed input win32 socket stream"; tag = IO_STREAM_FILENAME(x); break; case ecl_smm_output_wsock: prefix = "closed output win32 socket stream"; tag = IO_STREAM_FILENAME(x); break; case ecl_smm_io_wsock: prefix = "closed i/o win32 socket stream"; tag = IO_STREAM_FILENAME(x); break; case ecl_smm_io_wcon: prefix = "closed i/o win32 console stream"; tag = IO_STREAM_FILENAME(x); break; #endif case ecl_smm_io_file: prefix = "closed io file"; tag = IO_STREAM_FILENAME(x); break; case ecl_smm_io: prefix = "closed io stream"; tag = IO_STREAM_FILENAME(x); break; case ecl_smm_probe: prefix = "closed probe stream"; tag = IO_STREAM_FILENAME(x); break; case ecl_smm_synonym: prefix = "closed synonym stream to"; tag = SYNONYM_STREAM_SYMBOL(x); break; case ecl_smm_broadcast: prefix = "closed broadcast stream"; tag = ECL_NIL; break; case ecl_smm_concatenated: prefix = "closed concatenated stream"; tag = ECL_NIL; break; case ecl_smm_two_way: prefix = "closed two-way stream"; tag = ECL_NIL; break; case ecl_smm_echo: prefix = "closed echo stream"; tag = ECL_NIL; break; case ecl_smm_string_input: { cl_object text = x->stream.object0; cl_index ndx, l = ecl_length(text); for (ndx = 0; (ndx < 8) && (ndx < l); ndx++) { buffer[ndx] = ecl_char(text, ndx); } if (l > ndx) { buffer[ndx-1] = '.'; buffer[ndx-2] = '.'; buffer[ndx-3] = '.'; } buffer[ndx++] = 0; prefix = "closed string-input stream from"; tag = &str; #ifdef ECL_UNICODE tag->string.t = t_string; tag->string.self = buffer; #else tag->base_string.t = t_base_string; tag->base_string.self = buffer; #endif tag->base_string.dim = ndx; tag->base_string.fillp = ndx-1; break; } case ecl_smm_string_output: prefix = "closed string-output stream"; tag = ECL_NIL; break; case ecl_smm_sequence_input: prefix = "closed sequence-input stream"; tag = ECL_NIL; break; case ecl_smm_sequence_output: prefix = "closed sequence-output stream"; tag = ECL_NIL; break; default: ecl_internal_error("illegal stream mode"); } if (!x->stream.closed) prefix = prefix + 7; _ecl_write_unreadable(x, prefix, tag, stream); } static void write_instance(cl_object x, cl_object stream) { _ecl_funcall3(@'print-object', x, stream); } static void write_readtable(cl_object x, cl_object stream) { _ecl_write_unreadable(x, "readtable", ECL_NIL, stream); } static void write_cfun(cl_object x, cl_object stream) { _ecl_write_unreadable(x, "compiled-function", x->cfun.name, stream); } static void write_codeblock(cl_object x, cl_object stream) { _ecl_write_unreadable(x, "codeblock", x->cblock.name, stream); } static void write_cclosure(cl_object x, cl_object stream) { _ecl_write_unreadable(x, "compiled-closure", ECL_NIL, stream); } static void write_foreign(cl_object x, cl_object stream) { _ecl_write_unreadable(x, "foreign", x->foreign.tag, stream); } static void write_frame(cl_object x, cl_object stream) { _ecl_write_unreadable(x, "frame", ecl_make_fixnum(x->frame.size), stream); } static void write_weak_pointer(cl_object x, cl_object stream) { _ecl_write_unreadable(x, "weak-pointer", ECL_NIL, stream); } #ifdef ECL_THREADS static void write_process(cl_object x, cl_object stream) { _ecl_write_unreadable(x, "process", x->process.name, stream); } static void write_lock(cl_object x, cl_object stream) { const char *prefix = x->lock.recursive? "lock" : "lock (nonrecursive)"; _ecl_write_unreadable(x, prefix, x->lock.name, stream); } static void write_condition_variable(cl_object x, cl_object stream) { _ecl_write_unreadable(x, "semaphore", ECL_NIL, stream); } static void write_semaphore(cl_object x, cl_object stream) { _ecl_write_unreadable(x, "semaphore", ECL_NIL, stream); } static void write_barrier(cl_object x, cl_object stream) { _ecl_write_unreadable(x, "barrier", ECL_NIL, stream); } static void write_mailbox(cl_object x, cl_object stream) { _ecl_write_unreadable(x, "mailbox", ECL_NIL, stream); } #endif /* ECL_THREADS */ static void write_illegal(cl_object x, cl_object stream) { _ecl_write_unreadable(x, "illegal pointer", ECL_NIL, stream); } typedef void (*printer)(cl_object x, cl_object stream); static printer dispatch[FREE+1] = { 0 /* t_start = 0 */, _ecl_write_list, /* t_list = 1 */ write_character, /* t_character = 2 */ write_integer, /* t_fixnum = 3 */ write_integer, /* t_bignum = 4 */ write_ratio, /* t_ratio */ /* write_float, */ /* t_shortfloat */ write_float, /* t_singlefloat */ write_float, /* t_doublefloat */ #ifdef ECL_LONG_FLOAT write_float, /* t_longfloat */ #endif write_complex, /* t_complex */ _ecl_write_symbol, /* t_symbol */ write_package, /* t_package */ write_hashtable, /* t_hashtable */ _ecl_write_array, /* t_array */ _ecl_write_vector, /* t_vector */ #ifdef ECL_UNICODE _ecl_write_string, /* t_string */ #endif _ecl_write_base_string, /* t_base_string */ _ecl_write_bitvector, /* t_bitvector */ write_stream, /* t_stream */ write_random, /* t_random */ write_readtable, /* t_readtable */ write_pathname, /* t_pathname */ _ecl_write_bytecodes, /* t_bytecodes */ _ecl_write_bclosure, /* t_bclosure */ write_cfun, /* t_cfun */ write_cfun, /* t_cfunfixed */ write_cclosure, /* t_cclosure */ write_instance, /* t_instance */ #ifdef ECL_THREADS write_process, /* t_process */ write_lock, /* t_lock */ write_lock, /* t_rwlock */ write_condition_variable, /* t_condition_variable */ write_semaphore, /* t_semaphore */ write_barrier, /* t_barrier */ write_mailbox, /* t_mailbox */ #endif write_codeblock, /* t_codeblock */ write_foreign, /* t_foreign */ write_frame, /* t_frame */ write_weak_pointer, /* t_weak_pointer */ #ifdef ECL_SSE2 _ecl_write_sse, /* t_sse_pack */ #endif /* t_end */ }; cl_object si_write_ugly_object(cl_object x, cl_object stream) { if (x == OBJNULL) { if (ecl_print_readably()) FEprint_not_readable(x); writestr_stream("#", stream); } else { int t = ecl_t_of(x); printer f = (t >= t_end)? write_illegal : dispatch[t]; f(x, stream); } @(return x) } ecl-16.1.2/src/c/read.d000066400000000000000000002666671266352375300145000ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* read.d -- Read. */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #define ECL_INCLUDE_MATH_H #include #include #include /* for assert() */ #include #include #include #include #include #include #include #include #undef _complex static cl_object dispatch_macro_character(cl_object table, cl_object strm, int c); #define read_suppress (ecl_symbol_value(@'*read-suppress*') != ECL_NIL) #ifdef ECL_UNICODE # define TOKEN_STRING_DIM(s) ((s)->string.dim) # define TOKEN_STRING_FILLP(s) ((s)->string.fillp) # define TOKEN_STRING_CHAR(s,n) ((s)->string.self[n]) # define TOKEN_STRING_CHAR_SET(s,n,c) (s)->string.self[n]=(c) # define TOKEN_STRING_CHAR_CMP(s,n,c) ((s)->string.self[n]==(c)) #else # define TOKEN_STRING_DIM(s) ((s)->base_string.dim) # define TOKEN_STRING_FILLP(s) ((s)->base_string.fillp) # define TOKEN_STRING_CHAR(s,n) ((s)->base_string.self[n]) # define TOKEN_STRING_CHAR_SET(s,n,c) ((s)->base_string.self[n]=(c)) # define TOKEN_STRING_CHAR_CMP(s,n,c) ((s)->base_string.self[n]==(c)) #endif #define ECL_READ_ONLY_TOKEN 1 #define ECL_READ_RETURN_IGNORABLE 3 #define ECL_READ_LIST_DOT 4 cl_object si_get_buffer_string() { const cl_env_ptr env = ecl_process_env(); cl_object pool = env->string_pool; cl_object output; if (pool == ECL_NIL) { #ifdef ECL_UNICODE output = ecl_alloc_adjustable_extended_string(ECL_BUFFER_STRING_SIZE); #else output = ecl_alloc_adjustable_base_string(ECL_BUFFER_STRING_SIZE); #endif } else { output = CAR(pool); env->string_pool = CDR(pool); } TOKEN_STRING_FILLP(output) = 0; @(return output) } cl_object si_put_buffer_string(cl_object string) { if (string != ECL_NIL) { const cl_env_ptr env = ecl_process_env(); cl_object pool = env->string_pool; cl_index l = 0; if (pool != ECL_NIL) { /* We store the size of the pool in the string index */ l = TOKEN_STRING_FILLP(ECL_CONS_CAR(pool)); } if (l < ECL_MAX_STRING_POOL_SIZE) { /* Ok, by ignoring the following code, here we * are doing like SBCL: we simply grow the * input buffer and do not care about its * size. */ #if 0 if (TOKEN_STRING_DIM(string) > 32*ECL_BUFFER_STRING_SIZE) { /* String has been enlarged. Cut it. */ #ifdef ECL_UNICODE string = ecl_alloc_adjustable_extended_string(ECL_BUFFER_STRING_SIZE); #else string = ecl_alloc_adjustable_base_string(ECL_BUFFER_STRING_SIZE); #endif } #endif TOKEN_STRING_FILLP(string) = l+1; env->string_pool = CONS(string, pool); } } @(return) } static void extra_argument (int c, cl_object stream, cl_object d); static cl_object patch_sharp(const cl_env_ptr env, cl_object x); static cl_object do_read_delimited_list(int d, cl_object strm, bool proper_list); cl_object ecl_read_object_non_recursive(cl_object in) { cl_object x; const cl_env_ptr env = ecl_process_env(); ecl_bds_bind(env, @'si::*sharp-eq-context*', ECL_NIL); ecl_bds_bind(env, @'si::*backq-level*', ecl_make_fixnum(0)); x = ecl_read_object(in); x = patch_sharp(env, x); ecl_bds_unwind_n(env, 2); return x; } /* * This routine inverts the case of the characters in the buffer which * were not escaped. ESCAPE_LIST is a list of intevals of characters * that were escaped, as in ({(low-limit . high-limit)}*). The list * goes from the last interval to the first one, in reverse order, * and thus we run the buffer from the end to the beginning. */ static void invert_buffer_case(cl_object x, cl_object escape_list, int sign) { cl_fixnum high_limit, low_limit; cl_fixnum i = TOKEN_STRING_FILLP(x)-1; do { if (escape_list != ECL_NIL) { cl_object escape_interval = CAR(escape_list); high_limit = ecl_fixnum(CAR(escape_interval)); low_limit = ecl_fixnum(CDR(escape_interval)); escape_list = CDR(escape_list); } else { high_limit = low_limit = -1; } for (; i > high_limit; i--) { /* The character is not escaped */ int c = TOKEN_STRING_CHAR(x,i); if (ecl_upper_case_p(c) && (sign < 0)) { c = ecl_char_downcase(c); } else if (ecl_lower_case_p(c) && (sign > 0)) { c = ecl_char_upcase(c); } TOKEN_STRING_CHAR_SET(x,i,c); } for (; i > low_limit; i--) { /* The character is within an escaped interval */ ; } } while (i >= 0); } static cl_object ecl_read_object_with_delimiter(cl_object in, int delimiter, int flags, enum ecl_chattrib a) { cl_object x, token; int c, base; cl_object p; cl_index length, i; int colon, intern_flag; bool external_symbol; cl_env_ptr the_env = ecl_process_env(); cl_object rtbl = ecl_current_readtable(); enum ecl_readtable_case read_case = rtbl->readtable.read_case; cl_object escape_list; /* intervals of escaped characters */ cl_fixnum upcase; /* # uppercase characters - # downcase characters */ cl_fixnum count; /* number of unescaped characters */ bool suppress = read_suppress; if (a != cat_constituent) { c = 0; goto LOOP; } BEGIN: do { c = ecl_read_char(in); if (c == delimiter) { the_env->nvalues = 0; return OBJNULL; } if (c == EOF) FEend_of_file(in); a = ecl_readtable_get(rtbl, c, &x); } while (a == cat_whitespace); if ((a == cat_terminating || a == cat_non_terminating) && (flags != ECL_READ_ONLY_TOKEN)) { cl_object o; if (ECL_HASH_TABLE_P(x)) { o = dispatch_macro_character(x, in, c); } else { o = _ecl_funcall3(x, in, ECL_CODE_CHAR(c)); } if (the_env->nvalues == 0) { if (flags == ECL_READ_RETURN_IGNORABLE) return ECL_NIL; goto BEGIN; } unlikely_if (the_env->nvalues > 1) { FEerror("The readmacro ~S returned ~D values.", 2, x, ecl_make_fixnum(the_env->nvalues)); } return o; } LOOP: p = escape_list = ECL_NIL; upcase = count = length = 0; external_symbol = colon = 0; token = si_get_buffer_string(); for (;;) { if (c == ':' && (flags != ECL_READ_ONLY_TOKEN) && a == cat_constituent) { colon++; goto NEXT; } if (colon > 2) { while (colon--) { ecl_string_push_extend(token, ':'); length++; } } else if (colon) { external_symbol = (colon == 1); TOKEN_STRING_CHAR_SET(token,length,'\0'); /* If the readtable case was :INVERT and all non-escaped characters * had the same case, we revert their case. */ if (read_case == ecl_case_invert && count != 0) { if (upcase == count) { invert_buffer_case(token, escape_list, -1); } else if (upcase == -count) { invert_buffer_case(token, escape_list, +1); } } if (length == 0) { p = cl_core.keyword_package; external_symbol = 0; } else { p = ecl_find_package_nolock(token); } if (Null(p) && !suppress) { /* When loading binary files, we sometimes must create symbols whose package has not yet been maked. We allow it, but later on in ecl_init_module we make sure that all referenced packages have been properly built. */ cl_object name = cl_copy_seq(token); unlikely_if (Null(the_env->packages_to_be_created_p)) { FEerror("There is no package with the name ~A.", 1, name); } p = _ecl_package_to_be_created(the_env, name); } TOKEN_STRING_FILLP(token) = length = 0; upcase = count = colon = 0; escape_list = ECL_NIL; } if (a == cat_single_escape) { c = ecl_read_char_noeof(in); a = cat_constituent; if (read_case == ecl_case_invert) { escape_list = CONS(CONS(ecl_make_fixnum(length), ecl_make_fixnum(length-1)), escape_list); } else { escape_list = ECL_T; } ecl_string_push_extend(token, c); length++; goto NEXT; } if (a == cat_multiple_escape) { cl_index begin = length; for (;;) { c = ecl_read_char_noeof(in); a = ecl_readtable_get(rtbl, c, NULL); if (a == cat_single_escape) { c = ecl_read_char_noeof(in); a = cat_constituent; } else if (a == cat_multiple_escape) break; ecl_string_push_extend(token, c); length++; } if (read_case == ecl_case_invert) { escape_list = CONS(CONS(ecl_make_fixnum(begin), ecl_make_fixnum(length-1)), escape_list); } else { escape_list = ECL_T; } goto NEXT; } if (a == cat_whitespace || a == cat_terminating) { ecl_unread_char(c, in); break; } unlikely_if (ecl_invalid_character_p(c)) { FEreader_error("Found invalid character ~:C", in, 1, ECL_CODE_CHAR(c)); } if (read_case != ecl_case_preserve) { if (ecl_upper_case_p(c)) { upcase++; count++; if (read_case == ecl_case_downcase) c = ecl_char_downcase(c); } else if (ecl_lower_case_p(c)) { upcase--; count++; if (read_case == ecl_case_upcase) c = ecl_char_upcase(c); } } ecl_string_push_extend(token, c); length++; NEXT: c = ecl_read_char(in); if (c == EOF) break; a = ecl_readtable_get(rtbl, c, NULL); } if (suppress) { x = ECL_NIL; goto OUTPUT; } /* If there are some escaped characters, it must be a symbol */ if ((flags == ECL_READ_ONLY_TOKEN) || p != ECL_NIL || escape_list != ECL_NIL || length == 0) goto SYMBOL; /* The case in which the buffer is full of dots has to be especial cased */ if (length == 1 && TOKEN_STRING_CHAR_CMP(token,0,'.')) { if (flags == ECL_READ_LIST_DOT) { x = @'si::.'; goto OUTPUT; } else { FEreader_error("Dots appeared illegally.", in, 0); } } else { int i; for (i = 0; i < length; i++) { if (!TOKEN_STRING_CHAR_CMP(token,i,'.')) goto MAYBE_NUMBER; } FEreader_error("Dots appeared illegally.", in, 0); } MAYBE_NUMBER: /* Here we try to parse a number from the content of the buffer */ base = ecl_current_read_base(); if ((base <= 10) && ecl_alpha_char_p(TOKEN_STRING_CHAR(token,0))) goto SYMBOL; x = ecl_parse_number(token, 0, TOKEN_STRING_FILLP(token), &i, base); unlikely_if (x == ECL_NIL) FEreader_error("Syntax error when reading number.~%Offending string: ~S.", in, 1, token); if (x != OBJNULL && length == i) goto OUTPUT; SYMBOL: if (flags == ECL_READ_ONLY_TOKEN) { the_env->nvalues = 1; return token; } /*TOKEN_STRING_CHAR_SET(token,length,'\0');*/ /* If the readtable case was :INVERT and all non-escaped characters * had the same case, we revert their case. */ if (read_case == ecl_case_invert && count != 0) { if (upcase == count) { invert_buffer_case(token, escape_list, -1); } else if (upcase == -count) { invert_buffer_case(token, escape_list, +1); } } if (external_symbol) { x = ecl_find_symbol(token, p, &intern_flag); unlikely_if (intern_flag != ECL_EXTERNAL) { FEerror("Cannot find the external symbol ~A in ~S.", 2, cl_copy_seq(token), p); } } else { if (p == ECL_NIL) { p = ecl_current_package(); } /* INV: cl_make_symbol() copies the string */ x = ecl_intern(token, p, &intern_flag); } OUTPUT: si_put_buffer_string(token); the_env->nvalues = 1; return x; } /* ecl_read_object(in) reads an object from stream in. This routine corresponds to COMMON Lisp function READ. */ cl_object ecl_read_object(cl_object in) { return ecl_read_object_with_delimiter(in, EOF, 0, cat_constituent); } cl_object si_read_object_or_ignore(cl_object in, cl_object eof) { cl_object x; const cl_env_ptr env = ecl_process_env(); ecl_bds_bind(env, @'si::*sharp-eq-context*', ECL_NIL); ecl_bds_bind(env, @'si::*backq-level*', ecl_make_fixnum(0)); x = ecl_read_object_with_delimiter(in, EOF, ECL_READ_RETURN_IGNORABLE, cat_constituent); if (x == OBJNULL) { env->nvalues = 1; x = eof; } else if (env->nvalues) { x = patch_sharp(env, x); } ecl_bds_unwind_n(env, 2); return x; } static cl_object right_parenthesis_reader(cl_object in, cl_object character) { FEreader_error("Unmatched right parenthesis, #\\)", in, 0); } static cl_object left_parenthesis_reader(cl_object in, cl_object character) { const char c = ')'; @(return do_read_delimited_list(c, in, 0)) } /* * BACKQUOTE READER */ static cl_object comma_reader(cl_object in, cl_object c) { cl_object x, y; const cl_env_ptr env = ecl_process_env(); cl_fixnum backq_level = ecl_fixnum(ECL_SYM_VAL(env, @'si::*backq-level*')); unlikely_if (backq_level <= 0) FEreader_error("A comma has appeared out of a backquote.", in, 0); /* Read character & complain at EOF */ c = cl_peek_char(2,ECL_NIL,in); if (c == ECL_CODE_CHAR('@@')) { x = @'si::unquote-splice'; ecl_read_char(in); } else if (c == ECL_CODE_CHAR('.')) { x = @'si::unquote-nsplice'; ecl_read_char(in); } else { x = @'si::unquote'; } ECL_SETQ(env, @'si::*backq-level*', ecl_make_fixnum(backq_level-1)); y = ecl_read_object(in); ECL_SETQ(env, @'si::*backq-level*', ecl_make_fixnum(backq_level)); return cl_list(2, x, y); } static cl_object backquote_reader(cl_object in, cl_object c) { const cl_env_ptr the_env = ecl_process_env(); cl_fixnum backq_level = ecl_fixnum(ECL_SYM_VAL(the_env, @'si::*backq-level*')); ECL_SETQ(the_env, @'si::*backq-level*', ecl_make_fixnum(backq_level+1)); c = ecl_read_object(in); ECL_SETQ(the_env, @'si::*backq-level*', ecl_make_fixnum(backq_level)); unlikely_if (c == OBJNULL) FEend_of_file(in); #if 0 @(return cl_macroexpand_1(2, cl_list(2, @'si::quasiquote', in), ECL_NIL)); #else @(return cl_list(2,@'si::quasiquote',c)) #endif } /* read_constituent(in) reads a sequence of constituent characters from stream in and places it in token. As a help, it returns TRUE or FALSE depending on the value of *READ-SUPPRESS*. */ static cl_object read_constituent(cl_object in) { int store = !read_suppress; cl_object rtbl = ecl_current_readtable(); bool not_first = 0; cl_object token = si_get_buffer_string(); do { int c = ecl_read_char(in); enum ecl_chattrib c_cat; if (c == EOF) { break; } c_cat = ecl_readtable_get(rtbl, c, NULL); if (c_cat == cat_constituent || ((c_cat == cat_non_terminating) && not_first)) { if (store) { ecl_string_push_extend(token, c); } } else { ecl_unread_char(c, in); break; } not_first = 1; } while(1); return (read_suppress)? ECL_NIL : token; } static cl_object double_quote_reader(cl_object in, cl_object c) { int delim = ECL_CHAR_CODE(c); cl_object rtbl = ecl_current_readtable(); cl_object token = si_get_buffer_string(); cl_object output; for (;;) { int c = ecl_read_char_noeof(in); if (c == delim) break; else if (ecl_readtable_get(rtbl, c, NULL) == cat_single_escape) c = ecl_read_char_noeof(in); ecl_string_push_extend(token, c); } /* Must be kept a (SIMPLE-ARRAY CHARACTERS (*)), see * http://sourceforge.net/p/ecls/mailman/message/32272388/ */ output = cl_copy_seq(token); si_put_buffer_string(token); @(return output) } static cl_object dispatch_reader_fun(cl_object in, cl_object dc) { cl_object readtable = ecl_current_readtable(); cl_object dispatch_table; int c = ecl_char_code(dc); ecl_readtable_get(readtable, c, &dispatch_table); unlikely_if (!ECL_HASH_TABLE_P(dispatch_table)) FEreader_error("~C is not a dispatching macro character", in, 1, dc); return dispatch_macro_character(dispatch_table, in, c); } static cl_object dispatch_macro_character(cl_object table, cl_object in, int c) { cl_object arg; int d; c = ecl_read_char_noeof(in); d = ecl_digitp(c, 10); if (d >= 0) { cl_fixnum i = 0; do { i = 10*i + d; c = ecl_read_char_noeof(in); d = ecl_digitp(c, 10); } while (d >= 0); arg = ecl_make_fixnum(i); } else { arg = ECL_NIL; } { cl_object dc = ECL_CODE_CHAR(c); cl_object fun = ecl_gethash_safe(dc, table, ECL_NIL); unlikely_if (Null(fun)) { FEreader_error("No dispatch function defined " "for character ~S", in, 1, dc); } return _ecl_funcall4(fun, in, dc, arg); } } static cl_object single_quote_reader(cl_object in, cl_object c) { c = ecl_read_object(in); unlikely_if (c == OBJNULL) FEend_of_file(in); @(return cl_list(2, @'quote', c)) } static cl_object void_reader(cl_object in, cl_object c) { /* no result */ @(return) } static cl_object semicolon_reader(cl_object in, cl_object c) { int auxc; do auxc = ecl_read_char(in); while (auxc != '\n' && auxc != EOF); /* no result */ @(return) } /* sharpmacro routines */ static cl_object sharp_C_reader(cl_object in, cl_object c, cl_object d) { const cl_env_ptr the_env = ecl_process_env(); cl_object x, real, imag; if (d != ECL_NIL && !read_suppress) extra_argument('C', in, d); x = ecl_read_object(in); unlikely_if (x == OBJNULL) FEend_of_file(in); if (read_suppress) @(return ECL_NIL); unlikely_if (!ECL_CONSP(x) || ecl_length(x) != 2) FEreader_error("Reader macro #C should be followed by a list", in, 0); real = CAR(x); imag = CADR(x); /* INV: ecl_make_complex() checks its types. When reading circular structures, we cannot check the types of the elements, and we must build the complex number by hand. */ if ((CONSP(real) || CONSP(imag)) && !Null(ECL_SYM_VAL(the_env, @'si::*sharp-eq-context*'))) { x = ecl_alloc_object(t_complex); x->complex.real = real; x->complex.imag = imag; } else { x = ecl_make_complex(real, imag); } @(return x) } static cl_object sharp_backslash_reader(cl_object in, cl_object c, cl_object d) { const cl_env_ptr the_env = ecl_process_env(); cl_object token; if (d != ECL_NIL && !read_suppress) { unlikely_if (!ECL_FIXNUMP(d) || d != ecl_make_fixnum(0)) { FEreader_error("~S is an illegal CHAR-FONT.", in, 1, d); } } token = ecl_read_object_with_delimiter(in, EOF, ECL_READ_ONLY_TOKEN, cat_single_escape); if (token == ECL_NIL) { c = ECL_NIL; } else if (TOKEN_STRING_FILLP(token) == 1) { c = ECL_CODE_CHAR(TOKEN_STRING_CHAR(token,0)); } else if (TOKEN_STRING_FILLP(token) == 2 && TOKEN_STRING_CHAR_CMP(token,0,'^')) { /* #\^x */ c = ECL_CODE_CHAR(TOKEN_STRING_CHAR(token,1) & 037); } else { cl_object nc = cl_name_char(token); unlikely_if (Null(nc)) { FEreader_error("~S is an illegal character name.", in, 1, token); } c = nc; } si_put_buffer_string(token); ecl_return1(the_env, c); } static cl_object sharp_single_quote_reader(cl_object in, cl_object c, cl_object d) { bool suppress = read_suppress; if(d != ECL_NIL && !suppress) extra_argument('\'', in, d); c = ecl_read_object(in); unlikely_if (c == OBJNULL) { FEend_of_file(in); } else if (suppress) { c = ECL_NIL; } else { c = cl_list(2, @'function', c); } @(return c) } static cl_object sharp_Y_reader(cl_object in, cl_object c, cl_object d) { cl_index i; cl_object x, rv, nth, lex; if (d != ECL_NIL && !read_suppress) extra_argument('C', in, d); x = ecl_read_object(in); unlikely_if (x == OBJNULL) { FEend_of_file(in); } if (read_suppress) { @(return ECL_NIL); } unlikely_if (!ECL_CONSP(x) || ecl_length(x) < 5) { FEreader_error("Reader macro #Y should be followed by a list", in, 0); } if (ecl_length(x) == 2) { rv = ecl_alloc_object(t_bclosure); rv->bclosure.code = ECL_CONS_CAR(x); x = ECL_CONS_CDR(x); rv->bclosure.lex = ECL_CONS_CAR(x); rv->bclosure.entry = _ecl_bclosure_dispatch_vararg; @(return rv); } rv = ecl_alloc_object(t_bytecodes); rv->bytecodes.name = ECL_CONS_CAR(x); x = ECL_CONS_CDR(x); lex = ECL_CONS_CAR(x); x = ECL_CONS_CDR(x); rv->bytecodes.definition = ECL_CONS_CAR(x); x = ECL_CONS_CDR(x); nth = ECL_CONS_CAR(x); x = ECL_CONS_CDR(x); rv->bytecodes.code_size = ecl_to_fix(cl_list_length(nth)); rv->bytecodes.code = ecl_alloc_atomic(rv->bytecodes.code_size * sizeof(uint16_t)); for ( i=0; !ecl_endp(nth) ; i++, nth=ECL_CONS_CDR(nth) ) ((cl_opcode*)(rv->bytecodes.code))[i] = ecl_to_fix(ECL_CONS_CAR(nth)); nth = ECL_CONS_CAR(x); x = ECL_CONS_CDR(x); rv->bytecodes.data = nth; if (ECL_ATOM(x)) { nth = ECL_NIL; } else { nth = ECL_CONS_CAR(x); x = ECL_CONS_CDR(x); } rv->bytecodes.file = nth; if (ECL_ATOM(x)) { nth = ecl_make_fixnum(0); } else { nth = ECL_CONS_CAR(x); x = ECL_CONS_CDR(x); } rv->bytecodes.file_position = nth; rv->bytecodes.entry = _ecl_bytecodes_dispatch_vararg; @(return rv); } #define QUOTE 1 #define EVAL 2 #define LIST 3 #define LISTX 4 #define APPEND 5 #define NCONC 6 /* *---------------------------------------------------------------------- * Stack of unknown size *---------------------------------------------------------------------- */ cl_object si_make_backq_vector(cl_object d, cl_object data, cl_object in) { const cl_env_ptr the_env = ecl_process_env(); cl_object v, last; cl_index dim, i; if (Null(d)) { dim = ecl_length(data); } else { dim = ecl_fixnum(d); } v = ecl_alloc_simple_vector(dim, ecl_aet_object); for (i = 0, last = ECL_NIL; i < dim; i++) { if (data == ECL_NIL) { /* ... we fill the vector with the last element read (or NIL). */ for (; i < dim; i++) { ecl_aset_unsafe(v, i, last); } break; } ecl_aset_unsafe(v, i, last = ecl_car(data)); data = ECL_CONS_CDR(data); } unlikely_if (data != ECL_NIL) { if (in != ECL_NIL) { FEreader_error("Vector larger than specified length," "~D.", in, 1, d); } else { FEerror("Vector larger than specified length, ~D", 1, d); } } ecl_return1(the_env, v); } static cl_object sharp_left_parenthesis_reader(cl_object in, cl_object c, cl_object d) { extern int _cl_backq_car(cl_object *); const cl_env_ptr the_env = ecl_process_env(); cl_object v; unlikely_if (!Null(d) && (!ECL_FIXNUMP(d) || ecl_fixnum_minusp(d) || ecl_fixnum_greater(d, ecl_make_fixnum(ECL_ARRAY_DIMENSION_LIMIT)))) { FEreader_error("Invalid dimension size ~D in #()", in, 1, d); } if (ecl_fixnum_plusp(ECL_SYM_VAL(the_env, @'si::*backq-level*'))) { /* First case: ther might be unquoted elements in the vector. * Then we just create a form that generates the vector. */ cl_object x = do_read_delimited_list(')', in, 1); cl_index a = _cl_backq_car(&x); if (a != QUOTE) { v = cl_list(2, @'si::unquote', cl_list(4, @'si::make-backq-vector', d, x, ECL_NIL)); } else { return si_make_backq_vector(d, x, in); } } else if (read_suppress) { /* Second case: *read-suppress* = t, we ignore the data */ do_read_delimited_list(')', in, 1); v = ECL_NIL; } else if (Null(d)) { /* Third case: no dimension provided. Read a list and coerce it to vector. */ return si_make_backq_vector(d, do_read_delimited_list(')', in, 1), in); } else { /* Finally: Both dimension and data are provided. The amount of data cannot exceed the length, but it may be smaller, and in that case...*/ cl_object last; cl_index dim = ecl_fixnum(d), i; v = ecl_alloc_simple_vector(dim, ecl_aet_object); for (i = 0, last = ECL_NIL;; i++) { cl_object aux = ecl_read_object_with_delimiter(in, ')', 0, cat_constituent); if (aux == OBJNULL) break; unlikely_if (i >= dim) { FEreader_error("Vector larger than specified length," "~D.", in, 1, d); } ecl_aset_unsafe(v, i, last = aux); } /* ... we fill the vector with the last element read (or NIL). */ for (; i < dim; i++) { ecl_aset_unsafe(v, i, last); } } @(return v) } static cl_object sharp_asterisk_reader(cl_object in, cl_object c, cl_object d) { cl_env_ptr env = ecl_process_env(); cl_index sp = ECL_STACK_INDEX(env); cl_object last, elt, x; cl_index dim, dimcount, i; cl_object rtbl = ecl_current_readtable(); enum ecl_chattrib a; if (read_suppress) { read_constituent(in); @(return ECL_NIL) } for (dimcount = 0 ;; dimcount++) { int x = ecl_read_char(in); if (x == EOF) break; a = ecl_readtable_get(rtbl, x, NULL); if (a == cat_terminating || a == cat_whitespace) { ecl_unread_char(x, in); break; } unlikely_if (a == cat_single_escape || a == cat_multiple_escape || (x != '0' && x != '1')) { FEreader_error("Character ~:C is not allowed after #*", in, 1, ECL_CODE_CHAR(x)); } ECL_STACK_PUSH(env, ecl_make_fixnum(x == '1')); } if (Null(d)) { dim = dimcount; } else { unlikely_if (!ECL_FIXNUMP(d) || ((dim = ecl_fixnum(d)) < 0) || (dim > ECL_ARRAY_DIMENSION_LIMIT)) { FEreader_error("Wrong vector dimension size ~D in #*.", in, 1, d); } unlikely_if (dimcount > dim) FEreader_error("Too many elements in #*.", in, 0); unlikely_if (dim && (dimcount == 0)) FEreader_error("Cannot fill the bit-vector #*.", in, 0); } last = ECL_STACK_REF(env,-1); x = ecl_alloc_simple_vector(dim, ecl_aet_bit); for (i = 0; i < dim; i++) { elt = (i < dimcount) ? env->stack[sp+i] : last; if (elt == ecl_make_fixnum(0)) x->vector.self.bit[i/CHAR_BIT] &= ~(0200 >> i%CHAR_BIT); else x->vector.self.bit[i/CHAR_BIT] |= 0200 >> i%CHAR_BIT; } ECL_STACK_POP_N_UNSAFE(env, dimcount); @(return x) } static cl_object sharp_colon_reader(cl_object in, cl_object ch, cl_object d) { cl_object rtbl = ecl_current_readtable(); enum ecl_chattrib a; bool escape_flag; int c; cl_object output, token; if (d != ECL_NIL && !read_suppress) extra_argument(':', in, d); c = ecl_read_char_noeof(in); a = ecl_readtable_get(rtbl, c, NULL); escape_flag = FALSE; token = si_get_buffer_string(); goto L; for (;;) { ecl_string_push_extend(token, c); K: c = ecl_read_char(in); if (c == EOF) goto M; a = ecl_readtable_get(rtbl, c, NULL); L: if (a == cat_single_escape) { c = ecl_read_char_noeof(in); a = cat_constituent; escape_flag = TRUE; } else if (a == cat_multiple_escape) { escape_flag = TRUE; for (;;) { c = ecl_read_char_noeof(in); a = ecl_readtable_get(rtbl, c, NULL); if (a == cat_single_escape) { c = ecl_read_char_noeof(in); a = cat_constituent; } else if (a == cat_multiple_escape) break; ecl_string_push_extend(token, c); } goto K; } else if (ecl_lower_case_p(c)) c = ecl_char_upcase(c); if (a == cat_whitespace || a == cat_terminating) break; } ecl_unread_char(c, in); M: if (read_suppress) { output = ECL_NIL; } else { output = cl_make_symbol(token); } si_put_buffer_string(token); @(return output) } static cl_object sharp_dot_reader(cl_object in, cl_object c, cl_object d) { const cl_env_ptr env = ecl_process_env(); if (d != ECL_NIL && !read_suppress) extra_argument('.', in, d); c = ecl_read_object(in); unlikely_if (c == OBJNULL) FEend_of_file(in); if (read_suppress) @(return ECL_NIL); unlikely_if (ecl_symbol_value(@'*read-eval*') == ECL_NIL) FEreader_error("Cannot evaluate the form #.~A", in, 1, c); /* FIXME! We should do something here to ensure that the #. * only uses the #n# that have been defined */ c = patch_sharp(env, c); c = si_eval_with_env(1, c); @(return c) } static cl_object read_number(cl_object in, int radix, cl_object macro_char) { cl_index i; cl_object x; cl_object token = read_constituent(in); if (token == ECL_NIL) { x = ECL_NIL; } else { x = ecl_parse_number(token, 0, TOKEN_STRING_FILLP(token), &i, radix); unlikely_if (x == OBJNULL || x == ECL_NIL || i != TOKEN_STRING_FILLP(token)) { FEreader_error("Cannot parse the #~A readmacro.", in, 1, macro_char); } unlikely_if (cl_rationalp(x) == ECL_NIL) { FEreader_error("The float ~S appeared after the #~A readmacro.", in, 2, x, macro_char); } si_put_buffer_string(token); } return x; } static cl_object sharp_B_reader(cl_object in, cl_object c, cl_object d) { if(d != ECL_NIL && !read_suppress) extra_argument('B', in, d); @(return (read_number(in, 2, ECL_CODE_CHAR('B')))) } static cl_object sharp_O_reader(cl_object in, cl_object c, cl_object d) { if(d != ECL_NIL && !read_suppress) extra_argument('O', in, d); @(return (read_number(in, 8, ECL_CODE_CHAR('O')))) } static cl_object sharp_X_reader(cl_object in, cl_object c, cl_object d) { if(d != ECL_NIL && !read_suppress) extra_argument('X', in, d); @(return (read_number(in, 16, ECL_CODE_CHAR('X')))) } static cl_object sharp_R_reader(cl_object in, cl_object c, cl_object d) { int radix; if (read_suppress) { radix = 10; } else unlikely_if (!ECL_FIXNUMP(d)) { FEreader_error("No radix was supplied in the #R readmacro.", in, 0); } else { radix = ecl_fixnum(d); unlikely_if (radix > 36 || radix < 2) { FEreader_error("~S is an illegal radix.", in, 1, d); } } @(return (read_number(in, radix, ECL_CODE_CHAR('R')))) } #define sharp_A_reader void_reader #define sharp_S_reader void_reader static cl_object sharp_eq_reader(cl_object in, cl_object c, cl_object d) { const cl_env_ptr the_env = ecl_process_env(); cl_object pair, value; cl_object sharp_eq_context = ECL_SYM_VAL(the_env, @'si::*sharp-eq-context*'); if (read_suppress) @(return); unlikely_if (Null(d)) { FEreader_error("The #= readmacro requires an argument.", in, 0); } unlikely_if (ecl_assq(d, sharp_eq_context) != ECL_NIL) { FEreader_error("Duplicate definitions for #~D=.", in, 1, d); } pair = CONS(d, OBJNULL); ECL_SETQ(the_env, @'si::*sharp-eq-context*', CONS(pair, sharp_eq_context)); value = ecl_read_object(in); unlikely_if (value == pair) { FEreader_error("#~D# is defined by itself.", in, 1, d); } ECL_RPLACD(pair, value); ecl_return1(the_env, value); } static cl_object sharp_sharp_reader(cl_object in, cl_object c, cl_object d) { const cl_env_ptr the_env = ecl_process_env(); cl_object pair; if (read_suppress) ecl_return1(the_env, ECL_NIL); unlikely_if (Null(d)) { FEreader_error("The ## readmacro requires an argument.", in, 0); } pair = ecl_assq(d, ECL_SYM_VAL(the_env, @'si::*sharp-eq-context*')); unlikely_if (pair == ECL_NIL) { FEreader_error("#~D# is undefined.", in, 1, d); } else { cl_object value = ECL_CONS_CDR(pair); ecl_return1(the_env, (value == OBJNULL)? pair : value); } } static cl_object do_patch_sharp(cl_object x, cl_object table) #if 1 { /* The hash table maintains an association as follows: * * [1] object -> itself * The object has been processed by patch_sharp, us as it is. * [2] object -> nothing * The object has to be processed by do_patch_sharp. * [3] (# . object) -> object * This is the value of a #n# statement. The object migt * or might not yet be processed by do_patch_sharp(). */ AGAIN: switch (ecl_t_of(x)) { case t_list: { cl_object y; if (Null(x)) return x; y = ecl_gethash_safe(x, table, table); if (y == table) { /* case [2] */ break; } else if (y == x) { /* case [1] */ return x; } else { /* case [3] */ x = y; goto AGAIN; } } case t_vector: case t_array: case t_complex: case t_bclosure: case t_bytecodes: { cl_object y = ecl_gethash_safe(x, table, table); if (y == table) { /* case [2] */ break; } /* it can only be case [1] */ } default: return x; } /* We eagerly mark the object as processed, to avoid infinite * recursion. */ _ecl_sethash(x, table, x); switch (ecl_t_of(x)) { case t_list: ECL_RPLACA(x, do_patch_sharp(ECL_CONS_CAR(x), table)); ECL_RPLACD(x, do_patch_sharp(ECL_CONS_CDR(x), table)); break; case t_vector: if (x->vector.elttype == ecl_aet_object) { cl_index i; for (i = 0; i < x->vector.fillp; i++) x->vector.self.t[i] = do_patch_sharp(x->vector.self.t[i], table); } break; case t_array: if (x->vector.elttype == ecl_aet_object) { cl_index i, j = x->array.dim; for (i = 0; i < j; i++) x->array.self.t[i] = do_patch_sharp(x->array.self.t[i], table); } break; case t_complex: { cl_object r = do_patch_sharp(x->complex.real, table); cl_object i = do_patch_sharp(x->complex.imag, table); if (r != x->complex.real || i != x->complex.imag) { cl_object c = ecl_make_complex(r, i); x->complex = c->complex; } break; } case t_bclosure: { x->bclosure.lex = do_patch_sharp(x->bclosure.lex, table); x = x->bclosure.code = do_patch_sharp(x->bclosure.code, table); break; } case t_bytecodes: { x->bytecodes.name = do_patch_sharp(x->bytecodes.name, table); x->bytecodes.definition = do_patch_sharp(x->bytecodes.definition, table); x->bytecodes.data = do_patch_sharp(x->bytecodes.data, table); break; } default:; } return x; } #else { switch (ecl_t_of(x)) { case t_list: if (Null(x)) return x; case t_vector: case t_array: case t_complex: case t_bclosure: case t_bytecodes: { cl_object y = ecl_gethash_safe(x, table, table); if (y == table) break; x = y; } default: return x; } switch (ecl_t_of(x)) { case t_list: ECL_RPLACA(x, do_patch_sharp(ECL_CONS_CAR(x), table)); ECL_RPLACD(x, do_patch_sharp(ECL_CONS_CDR(x), table)); break; case t_vector: if (x->vector.elttype == ecl_aet_object) { cl_index i; for (i = 0; i < x->vector.fillp; i++) x->vector.self.t[i] = do_patch_sharp(x->vector.self.t[i], table); } break; case t_array: if (x->vector.elttype == ecl_aet_object) { cl_index i, j = x->array.dim; for (i = 0; i < j; i++) x->array.self.t[i] = do_patch_sharp(x->array.self.t[i], table); } break; case t_complex: { cl_object r = do_patch_sharp(x->complex.real, table); cl_object i = do_patch_sharp(x->complex.imag, table); if (r != x->complex.real || i != x->complex.imag) { cl_object c = ecl_make_complex(r, i); x->complex = c->complex; } break; } case t_bclosure: { x->bclosure.lex = do_patch_sharp(x->bclosure.lex, table); x = x->bclosure.code = do_patch_sharp(x->bclosure.code, table); break; } case t_bytecodes: { x->bytecodes.name = do_patch_sharp(x->bytecodes.name, table); x->bytecodes.definition = do_patch_sharp(x->bytecodes.definition, table); x->bytecodes.data = do_patch_sharp(x->bytecodes.data, table); break; } default:; } _ecl_sethash(x, table, x); return x; } #endif static cl_object patch_sharp(const cl_env_ptr the_env, cl_object x) { cl_object pairs = ECL_SYM_VAL(the_env, @'si::*sharp-eq-context*'); if (pairs == ECL_NIL) { return x; } else { cl_object table = cl__make_hash_table(@'eq', ecl_make_fixnum(20), /* size */ cl_core.rehash_size, cl_core.rehash_threshold); do { cl_object pair = ECL_CONS_CAR(pairs); _ecl_sethash(pair, table, ECL_CONS_CDR(pair)); pairs = ECL_CONS_CDR(pairs); } while (pairs != ECL_NIL); return do_patch_sharp(x, table); } } #define sharp_plus_reader void_reader #define sharp_minus_reader void_reader #define sharp_less_than_reader void_reader #define sharp_whitespace_reader void_reader #define sharp_right_parenthesis_reader void_reader static cl_object sharp_vertical_bar_reader(cl_object in, cl_object ch, cl_object d) { int c; int level = 0; if (d != ECL_NIL && !read_suppress) extra_argument('|', in, d); for (;;) { c = ecl_read_char_noeof(in); L: if (c == '#') { c = ecl_read_char_noeof(in); if (c == '|') level++; } else if (c == '|') { c = ecl_read_char_noeof(in); if (c == '#') { if (level == 0) break; else --level; } else goto L; } } @(return) /* no result */ } static cl_object default_dispatch_macro_fun(cl_object in, cl_object c, cl_object d) { FEreader_error("No dispatch function defined for character ~s.", in, 1, c); } /* #P" ... " returns the pathname with namestring ... . */ static cl_object sharp_P_reader(cl_object in, cl_object c, cl_object d) { bool suppress = read_suppress; if (d != ECL_NIL && !suppress) extra_argument('P', in, d); d = ecl_read_object(in); if (suppress) { d = ECL_NIL; } else { d = cl_parse_namestring(3, d, ECL_NIL, ECL_NIL); } @(return d) } /* #$ fixnum returns a random-state with the fixnum as its content. */ static cl_object sharp_dollar_reader(cl_object in, cl_object c, cl_object d) { cl_object rs; if (d != ECL_NIL && !read_suppress) extra_argument('$', in, d); c = ecl_read_object(in); rs = ecl_make_random_state(c); @(return rs) } /* readtable routines */ static void ECL_INLINE assert_type_readtable(cl_object function, cl_narg narg, cl_object p) { unlikely_if (!ECL_READTABLEP(p)) { FEwrong_type_nth_arg(function, narg, p, @[readtable]); } } cl_object ecl_copy_readtable(cl_object from, cl_object to) { struct ecl_readtable_entry *from_rtab, *to_rtab; cl_index i; size_t entry_bytes = sizeof(struct ecl_readtable_entry); size_t total_bytes = entry_bytes * RTABSIZE; cl_object output; assert_type_readtable(@[copy-readtable], 1, from); /* For the sake of garbage collector and thread safety we * create an incomplete object and only copy to the destination * at the end in a more or less "atomic" (meaning "fast") way. */ output = ecl_alloc_object(t_readtable); output->readtable.locked = 0; output->readtable.table = to_rtab = (struct ecl_readtable_entry *) ecl_alloc_align(total_bytes, entry_bytes); from_rtab = from->readtable.table; memcpy(to_rtab, from_rtab, total_bytes); for (i = 0; i < RTABSIZE; i++) { cl_object d = from_rtab[i].dispatch; if (ECL_HASH_TABLE_P(d)) { d = si_copy_hash_table(d); } to_rtab[i].dispatch = d; } output->readtable.read_case = from->readtable.read_case; #ifdef ECL_UNICODE if (!Null(from->readtable.hash)) { output->readtable.hash = si_copy_hash_table(from->readtable.hash); } else { output->readtable.hash = ECL_NIL; } #endif if (!Null(to)) { assert_type_readtable(@[copy-readtable], 2, to); to->readtable = output->readtable; output = to; } return output; } cl_object ecl_current_readtable(void) { const cl_env_ptr the_env = ecl_process_env(); cl_object r; /* INV: *readtable* always has a value */ r = ECL_SYM_VAL(the_env, @'*readtable*'); unlikely_if (!ECL_READTABLEP(r)) { ECL_SETQ(the_env, @'*readtable*', cl_core.standard_readtable); FEerror("The value of *READTABLE*, ~S, was not a readtable.", 1, r); } return r; } int ecl_current_read_base(void) { const cl_env_ptr the_env = ecl_process_env(); /* INV: *READ-BASE* always has a value */ cl_object x = ECL_SYM_VAL(the_env, @'*read-base*'); cl_fixnum b; unlikely_if (!ECL_FIXNUMP(x) || ((b = ecl_fixnum(x)) < 2) || (b > 36)) { ECL_SETQ(the_env, @'*read-base*', ecl_make_fixnum(10)); FEerror("The value of *READ-BASE*~& ~S~%" "is not in the range (INTEGER 2 36)", 1, x); } return b; } char ecl_current_read_default_float_format(void) { const cl_env_ptr the_env = ecl_process_env(); cl_object x; /* INV: *READ-DEFAULT-FLOAT-FORMAT* is always bound to something */ x = ECL_SYM_VAL(the_env, @'*read-default-float-format*'); if (x == @'single-float' || x == @'short-float') return 'F'; if (x == @'double-float') return 'D'; if (x == @'long-float') { #ifdef ECL_LONG_FLOAT return 'L'; #else return 'D'; #endif } ECL_SETQ(the_env, @'*read-default-float-format*', @'single-float'); FEerror("The value of *READ-DEFAULT-FLOAT-FORMAT*~& ~S~%" "is not one of (SINGLE-FLOAT SHORT-FLOAT DOUBLE-FLOAT LONG-FLOAT)", 1, x); } static cl_object stream_or_default_input(cl_object stream) { const cl_env_ptr the_env = ecl_process_env(); if (Null(stream)) return ECL_SYM_VAL(the_env, @'*standard-input*'); if (stream == ECL_T) return ECL_SYM_VAL(the_env, @'*terminal-io*'); return stream; } @(defun read (&optional (strm ECL_NIL) (eof_errorp ECL_T) eof_value recursivep) cl_object x; @ strm = stream_or_default_input(strm); if (Null(recursivep)) { x = ecl_read_object_non_recursive(strm); } else { x = ecl_read_object(strm); } if (x == OBJNULL) { if (Null(eof_errorp)) @(return eof_value) FEend_of_file(strm); } /* Skip whitespace characters, but stop at beginning of new line or token */ if (Null(recursivep)) { cl_object rtbl = ecl_current_readtable(); int c = ecl_read_char(strm); if (c != EOF && (ecl_readtable_get(rtbl, c, NULL) != cat_whitespace)) { ecl_unread_char(c, strm); } } @(return x) @) @(defun read_preserving_whitespace (&optional (strm ECL_NIL) (eof_errorp ECL_T) eof_value recursivep) cl_object x; @ strm = stream_or_default_input(strm); if (Null(recursivep)) { x = ecl_read_object_non_recursive(strm); } else { x = ecl_read_object(strm); } if (x == OBJNULL) { if (Null(eof_errorp)) @(return eof_value) FEend_of_file(strm); } @(return x) @) static cl_object do_read_delimited_list(int d, cl_object in, bool proper_list) { int after_dot = 0; bool suppress = read_suppress; cl_object x, y = ECL_NIL; cl_object *p = &y; do { x = ecl_read_object_with_delimiter(in, d, ECL_READ_LIST_DOT, cat_constituent); if (x == OBJNULL) { /* End of the list. */ unlikely_if (after_dot == 1) { /* Something like (1 . ) */ FEreader_error("Object missing after a list dot", in, 0); } return y; } else if (x == @'si::.') { unlikely_if (proper_list) { FEreader_error("A dotted list was found where a proper list was expected.", in, 0); } unlikely_if (p == &y) { /* Something like (. 2) */ FEreader_error("A dot appeared after a left parenthesis.", in, 0); } unlikely_if (after_dot) { /* Something like (1 . . 2) */ FEreader_error("Two dots appeared consecutively.", in, 0); } after_dot = 1; } else if (after_dot) { unlikely_if (after_dot++ > 1) { /* Something like (1 . 2 3) */ FEreader_error("Too many objects after a list dot", in, 0); } *p = x; } else if (!suppress) { *p = ecl_list1(x); p = &ECL_CONS_CDR(*p); } } while (1); } @(defun read_delimited_list (d &optional (strm ECL_NIL) recursivep) cl_object l; int delimiter; @ delimiter = ecl_char_code(d); strm = stream_or_default_input(strm); if (!Null(recursivep)) { l = do_read_delimited_list(delimiter, strm, 1); } else { ecl_bds_bind(the_env, @'si::*sharp-eq-context*', ECL_NIL); ecl_bds_bind(the_env, @'si::*backq-level*', ecl_make_fixnum(0)); l = do_read_delimited_list(delimiter, strm, 1); l = patch_sharp(the_env, l); ecl_bds_unwind_n(the_env, 2); } @(return l) @) @(defun read_line (&optional (strm ECL_NIL) (eof_errorp ECL_T) eof_value recursivep) int c; cl_object token, value0, value1; @ strm = stream_or_default_input(strm); #ifdef ECL_CLOS_STREAMS if (!ECL_ANSI_STREAM_P(strm)) { value0 = _ecl_funcall2(@'gray::stream-read-line', strm); value1 = ecl_nth_value(the_env, 1); if (!Null(value1)) { if (!Null(eof_errorp)) FEend_of_file(strm); value0 = eof_value; value1 = ECL_T; } goto OUTPUT; } #endif token = si_get_buffer_string(); do { c = ecl_read_char(strm); if (c == EOF || c == '\n') break; ecl_string_push_extend(token, c); } while(1); if (c == EOF && TOKEN_STRING_FILLP(token) == 0) { if (!Null(eof_errorp)) FEend_of_file(strm); value0 = eof_value; value1 = ECL_T; } else { #ifdef ECL_NEWLINE_IS_CRLF /* From \r\n, ignore \r */ if (TOKEN_STRING_FILLP(token) > 0 && TOKEN_STRING_CHAR_CMP(token,TOKEN_STRING_FILLP(token)-1,'\r')) TOKEN_STRING_FILLP(token)--; #endif #ifdef ECL_NEWLINE_IS_LFCR /* From \n\r, ignore \r */ ecl_read_char(strm); #endif value0 = cl_copy_seq(token); value1 = (c == EOF? ECL_T : ECL_NIL); } si_put_buffer_string(token); OUTPUT: @(return value0 value1) @) @(defun read-char (&optional (strm ECL_NIL) (eof_errorp ECL_T) eof_value recursivep) int c; cl_object output; @ strm = stream_or_default_input(strm); c = ecl_read_char(strm); if (c != EOF) output = ECL_CODE_CHAR(c); else if (Null(eof_errorp)) output = eof_value; else FEend_of_file(strm); @(return output) @) @(defun unread_char (c &optional (strm ECL_NIL)) @ /* INV: unread_char() checks the type `c' */ strm = stream_or_default_input(strm); ecl_unread_char(ecl_char_code(c), strm); @(return ECL_NIL) @) @(defun peek-char (&optional peek_type (strm ECL_NIL) (eof_errorp ECL_T) eof_value recursivep) int c; cl_object rtbl = ecl_current_readtable(); @ strm = stream_or_default_input(strm); c = ecl_peek_char(strm); if (c != EOF && !Null(peek_type)) { if (peek_type == ECL_T) { do { /* If the character is not a whitespace, output */ if (ecl_readtable_get(rtbl, c, NULL) != cat_whitespace) break; /* Otherwise, read the whitespace and peek the * next character */ ecl_read_char(strm); c = ecl_peek_char(strm); } while (c != EOF); } else { do { /* If the character belongs to the given class, * we're done. */ if (ecl_char_eq(ECL_CODE_CHAR(c), peek_type)) break; /* Otherwise, consume the character and * peek the next one. */ ecl_read_char(strm); c = ecl_peek_char(strm); } while (c != EOF); } } if (c != EOF) { eof_value = ECL_CODE_CHAR(c); } else if (!Null(eof_errorp)) { FEend_of_file(strm); } @(return eof_value) @) @(defun listen (&optional (strm ECL_NIL)) @ strm = stream_or_default_input(strm); @(return ((ecl_listen_stream(strm) == ECL_LISTEN_AVAILABLE)? ECL_T : ECL_NIL)) @) @(defun read_char_no_hang (&optional (strm ECL_NIL) (eof_errorp ECL_T) eof_value recursivep) int f; @ strm = stream_or_default_input(strm); #ifdef ECL_CLOS_STREAMS if (!ECL_ANSI_STREAM_P(strm)) { cl_object output = _ecl_funcall2(@'gray::stream-read-char-no-hang', strm); if (output == @':eof') goto END_OF_FILE; @(return output); } #endif f = ecl_listen_stream(strm); if (f == ECL_LISTEN_AVAILABLE) { int c = ecl_read_char(strm); if (c != EOF) { @(return ECL_CODE_CHAR(c)); } } else if (f == ECL_LISTEN_NO_CHAR) { @(return @'nil'); } /* We reach here if there was an EOF */ END_OF_FILE: if (Null(eof_errorp)) @(return eof_value) else FEend_of_file(strm); @) @(defun clear_input (&optional (strm ECL_NIL)) @ strm = stream_or_default_input(strm); ecl_clear_input(strm); @(return ECL_NIL) @) @(defun read_byte (binary_input_stream &optional (eof_errorp ECL_T) eof_value) cl_object c; @ c = ecl_read_byte(binary_input_stream); if (c == ECL_NIL) { if (Null(eof_errorp)) @(return eof_value) else FEend_of_file(binary_input_stream); } @(return c) @) @(defun read_sequence (sequence stream &key (start ecl_make_fixnum(0)) end) @ #ifdef ECL_CLOS_STREAMS if (!ECL_ANSI_STREAM_P(stream)) return funcall(5, @'gray::stream-read-sequence', stream, sequence, start, end); else #endif return si_do_read_sequence(sequence, stream, start, end); @) @(defun copy_readtable (&o (from ecl_current_readtable()) to) @ if (Null(from)) { to = ecl_copy_readtable(cl_core.standard_readtable, to); } else { to = ecl_copy_readtable(from, to); } @(return to) @) cl_object cl_readtable_case(cl_object r) { assert_type_readtable(@[readtable-case], 1, r); switch (r->readtable.read_case) { case ecl_case_upcase: r = @':upcase'; break; case ecl_case_downcase: r = @':downcase'; break; case ecl_case_invert: r = @':invert'; break; case ecl_case_preserve: r = @':preserve'; } @(return r) } static void error_locked_readtable(cl_object r) { cl_error(2, make_constant_base_string("Cannot modify locked readtable ~A."), r); } cl_object si_readtable_case_set(cl_object r, cl_object mode) { assert_type_readtable(@[readtable-case], 1, r); if (r->readtable.locked) { error_locked_readtable(r); } if (mode == @':upcase') { r->readtable.read_case = ecl_case_upcase; } else if (mode == @':downcase') { r->readtable.read_case = ecl_case_downcase; } else if (mode == @':preserve') { r->readtable.read_case = ecl_case_preserve; } else if (mode == @':invert') { r->readtable.read_case = ecl_case_invert; } else { const char *type = "(member :upcase :downcase :preserve :invert)"; FEwrong_type_nth_arg(@[si::readtable-case-set], 2, mode, ecl_read_from_cstring(type)); } @(return mode) } cl_object cl_readtablep(cl_object readtable) { @(return (ECL_READTABLEP(readtable) ? ECL_T : ECL_NIL)) } int ecl_readtable_get(cl_object readtable, int c, cl_object *macro_or_table) { cl_object m; enum ecl_chattrib cat; #ifdef ECL_UNICODE if (c >= RTABSIZE) { cl_object hash = readtable->readtable.hash; cat = cat_constituent; m = ECL_NIL; if (!Null(hash)) { cl_object pair = ecl_gethash_safe(ECL_CODE_CHAR(c), hash, ECL_NIL); if (!Null(pair)) { cat = ecl_fixnum(ECL_CONS_CAR(pair)); m = ECL_CONS_CDR(pair); } } } else #endif { m = readtable->readtable.table[c].dispatch; cat = readtable->readtable.table[c].syntax_type; } if (macro_or_table) *macro_or_table = m; return cat; } void ecl_readtable_set(cl_object readtable, int c, enum ecl_chattrib cat, cl_object macro_or_table) { if (readtable->readtable.locked) { error_locked_readtable(readtable); } #ifdef ECL_UNICODE if (c >= RTABSIZE) { cl_object hash = readtable->readtable.hash; if (Null(hash)) { hash = cl__make_hash_table(@'eql', ecl_make_fixnum(128), cl_core.rehash_size, cl_core.rehash_threshold); readtable->readtable.hash = hash; } _ecl_sethash(ECL_CODE_CHAR(c), hash, CONS(ecl_make_fixnum(cat), macro_or_table)); } else #endif { readtable->readtable.table[c].dispatch = macro_or_table; readtable->readtable.table[c].syntax_type = cat; } } bool ecl_invalid_character_p(int c) { return (c <= 32) || (c == 127); } @(defun set_syntax_from_char (tochr fromchr &o (tordtbl ecl_current_readtable()) fromrdtbl) enum ecl_chattrib cat; cl_object dispatch; cl_fixnum fc, tc; @ if (tordtbl->readtable.locked) { error_locked_readtable(tordtbl); } if (Null(fromrdtbl)) fromrdtbl = cl_core.standard_readtable; assert_type_readtable(@[readtable-case], 1, tordtbl); assert_type_readtable(@[readtable-case], 2, fromrdtbl); fc = ecl_char_code(fromchr); tc = ecl_char_code(tochr); cat = ecl_readtable_get(fromrdtbl, fc, &dispatch); if (ECL_READTABLEP(dispatch)) { dispatch = si_copy_hash_table(dispatch); } ecl_readtable_set(tordtbl, tc, cat, dispatch); @(return ECL_T) @) @(defun set_macro_character (c function &optional non_terminating_p (readtable ecl_current_readtable())) @ ecl_readtable_set(readtable, ecl_char_code(c), Null(non_terminating_p)? cat_terminating : cat_non_terminating, function); @(return ECL_T) @) @(defun get_macro_character (c &optional (readtable ecl_current_readtable())) enum ecl_chattrib cat; cl_object dispatch; @ if (Null(readtable)) readtable = cl_core.standard_readtable; cat = ecl_readtable_get(readtable, ecl_char_code(c), &dispatch); if (ECL_HASH_TABLE_P(dispatch)) dispatch = cl_core.dispatch_reader; @(return dispatch ((cat == cat_non_terminating)? ECL_T : ECL_NIL)) @) @(defun make_dispatch_macro_character (chr &optional non_terminating_p (readtable ecl_current_readtable())) enum ecl_chattrib cat; cl_object table; int c; @ assert_type_readtable(@[make-dispatch-macro-character], 3, readtable); c = ecl_char_code(chr); cat = Null(non_terminating_p)? cat_terminating : cat_non_terminating; table = cl__make_hash_table(@'eql', ecl_make_fixnum(128), cl_core.rehash_size, cl_core.rehash_threshold); ecl_readtable_set(readtable, c, cat, table); @(return ECL_T) @) @(defun set_dispatch_macro_character (dspchr subchr fnc &optional (readtable ecl_current_readtable())) cl_object table; cl_fixnum subcode; @ assert_type_readtable(@[set-dispatch-macro-character], 4, readtable); ecl_readtable_get(readtable, ecl_char_code(dspchr), &table); unlikely_if (readtable->readtable.locked) { error_locked_readtable(readtable); } unlikely_if (!ECL_HASH_TABLE_P(table)) { FEerror("~S is not a dispatch character.", 1, dspchr); } subcode = ecl_char_code(subchr); if (Null(fnc)) { ecl_remhash(ECL_CODE_CHAR(subcode), table); } else { _ecl_sethash(ECL_CODE_CHAR(subcode), table, fnc); } if (ecl_lower_case_p(subcode)) { subcode = ecl_char_upcase(subcode); } else if (ecl_upper_case_p(subcode)) { subcode = ecl_char_downcase(subcode); } if (Null(fnc)) { ecl_remhash(ECL_CODE_CHAR(subcode), table); } else { _ecl_sethash(ECL_CODE_CHAR(subcode), table, fnc); } @(return ECL_T) @) @(defun get_dispatch_macro_character (dspchr subchr &optional (readtable ecl_current_readtable())) cl_object table; cl_fixnum c; @ if (Null(readtable)) { readtable = cl_core.standard_readtable; } assert_type_readtable(@[get-dispatch-macro-character], 3, readtable); c = ecl_char_code(dspchr); ecl_readtable_get(readtable, c, &table); unlikely_if (!ECL_HASH_TABLE_P(table)) { FEerror("~S is not a dispatch character.", 1, dspchr); } c = ecl_char_code(subchr); /* Since macro characters may take a number as argument, it is not allowed to turn digits into dispatch macro characters */ if (ecl_digitp(c, 10) >= 0) @(return ECL_NIL) @(return ecl_gethash_safe(subchr, table, ECL_NIL)) @) cl_object si_standard_readtable() { @(return cl_core.standard_readtable) } @(defun ext::readtable-lock (r &optional yesno) cl_object output; @ assert_type_readtable(@[ext::readtable-lock], 1, r); output = (r->readtable.locked)? ECL_T : ECL_NIL; if (narg > 1) { r->readtable.locked = !Null(yesno); } @(return output) @) static void extra_argument(int c, cl_object stream, cl_object d) { FEreader_error("~S is an extra argument for the #~C readmacro.", stream, 2, d, ECL_CODE_CHAR(c)); } #define make_cf2(f) ecl_make_cfun((f), ECL_NIL, NULL, 2) #define make_cf3(f) ecl_make_cfun((f), ECL_NIL, NULL, 3) void init_read(void) { struct ecl_readtable_entry *rtab; cl_object r; int i; cl_core.standard_readtable = r = ecl_alloc_object(t_readtable); r->readtable.locked = 0; r->readtable.read_case = ecl_case_upcase; r->readtable.table = rtab = (struct ecl_readtable_entry *) ecl_alloc(RTABSIZE * sizeof(struct ecl_readtable_entry)); for (i = 0; i < RTABSIZE; i++) { rtab[i].syntax_type = cat_constituent; rtab[i].dispatch = ECL_NIL; } #ifdef ECL_UNICODE r->readtable.hash = ECL_NIL; #endif cl_core.dispatch_reader = make_cf2(dispatch_reader_fun); ecl_readtable_set(r, '\t', cat_whitespace, ECL_NIL); ecl_readtable_set(r, '\n', cat_whitespace, ECL_NIL); ecl_readtable_set(r, '\f', cat_whitespace, ECL_NIL); ecl_readtable_set(r, '\r', cat_whitespace, ECL_NIL); ecl_readtable_set(r, ' ', cat_whitespace, ECL_NIL); ecl_readtable_set(r, '"', cat_terminating, make_cf2(double_quote_reader)); ecl_readtable_set(r, '\'', cat_terminating, make_cf2(single_quote_reader)); ecl_readtable_set(r, '(', cat_terminating, make_cf2(left_parenthesis_reader)); ecl_readtable_set(r, ')', cat_terminating, make_cf2(right_parenthesis_reader)); ecl_readtable_set(r, ',', cat_terminating, make_cf2(comma_reader)); ecl_readtable_set(r, ';', cat_terminating, make_cf2(semicolon_reader)); ecl_readtable_set(r, '\\', cat_single_escape, ECL_NIL); ecl_readtable_set(r, '`', cat_terminating, make_cf2(backquote_reader)); ecl_readtable_set(r, '|', cat_multiple_escape, ECL_NIL); cl_core.default_dispatch_macro = make_cf3(default_dispatch_macro_fun); cl_make_dispatch_macro_character(3, ECL_CODE_CHAR('#'), ECL_T /* non terminating */, r); cl_set_dispatch_macro_character(4, ECL_CODE_CHAR('#'), ECL_CODE_CHAR('C'), make_cf3(sharp_C_reader), r); cl_set_dispatch_macro_character(4, ECL_CODE_CHAR('#'), ECL_CODE_CHAR('\\'), make_cf3(sharp_backslash_reader), r); cl_set_dispatch_macro_character(4, ECL_CODE_CHAR('#'), ECL_CODE_CHAR('\''), make_cf3(sharp_single_quote_reader), r); cl_set_dispatch_macro_character(4, ECL_CODE_CHAR('#'), ECL_CODE_CHAR('('), make_cf3(sharp_left_parenthesis_reader), r); cl_set_dispatch_macro_character(4, ECL_CODE_CHAR('#'), ECL_CODE_CHAR('*'), make_cf3(sharp_asterisk_reader), r); cl_set_dispatch_macro_character(4, ECL_CODE_CHAR('#'), ECL_CODE_CHAR(':'), make_cf3(sharp_colon_reader), r); cl_set_dispatch_macro_character(4, ECL_CODE_CHAR('#'), ECL_CODE_CHAR('.'), make_cf3(sharp_dot_reader), r); /* Used for fasload only. */ cl_set_dispatch_macro_character(4, ECL_CODE_CHAR('#'), ECL_CODE_CHAR('B'), make_cf3(sharp_B_reader), r); cl_set_dispatch_macro_character(4, ECL_CODE_CHAR('#'), ECL_CODE_CHAR('O'), make_cf3(sharp_O_reader), r); cl_set_dispatch_macro_character(4, ECL_CODE_CHAR('#'), ECL_CODE_CHAR('X'), make_cf3(sharp_X_reader), r); cl_set_dispatch_macro_character(4, ECL_CODE_CHAR('#'), ECL_CODE_CHAR('R'), make_cf3(sharp_R_reader), r); cl_set_dispatch_macro_character(4, ECL_CODE_CHAR('#'), ECL_CODE_CHAR('A'), @'si::sharp-a-reader', r); cl_set_dispatch_macro_character(4, ECL_CODE_CHAR('#'), ECL_CODE_CHAR('S'), @'si::sharp-s-reader', r); cl_set_dispatch_macro_character(4, ECL_CODE_CHAR('#'), ECL_CODE_CHAR('P'), make_cf3(sharp_P_reader), r); cl_set_dispatch_macro_character(4, ECL_CODE_CHAR('#'), ECL_CODE_CHAR('='), make_cf3(sharp_eq_reader), r); cl_set_dispatch_macro_character(4, ECL_CODE_CHAR('#'), ECL_CODE_CHAR('#'), make_cf3(sharp_sharp_reader), r); cl_set_dispatch_macro_character(4, ECL_CODE_CHAR('#'), ECL_CODE_CHAR('+'), make_cf3(sharp_plus_reader), r); cl_set_dispatch_macro_character(4, ECL_CODE_CHAR('#'), ECL_CODE_CHAR('-'), make_cf3(sharp_minus_reader), r); cl_set_dispatch_macro_character(4, ECL_CODE_CHAR('#'), ECL_CODE_CHAR('|'), make_cf3(sharp_vertical_bar_reader), r); /* This is specific to this implementation */ cl_set_dispatch_macro_character(4, ECL_CODE_CHAR('#'), ECL_CODE_CHAR('$'), make_cf3(sharp_dollar_reader), r); /* This is specific to this implementation */ cl_set_dispatch_macro_character(4, ECL_CODE_CHAR('#'), ECL_CODE_CHAR('Y'), make_cf3(sharp_Y_reader), r); /* This is specific to this implementation: ignore BOM */ #ifdef ECL_UNICODE ecl_readtable_set(r, 0xfeff, cat_whitespace, ECL_NIL); #endif /* Lock the standard read table so that we do not have to make copies * to keep it unchanged */ r->readtable.locked = 1; init_backq(); ECL_SET(@'*readtable*', r=ecl_copy_readtable(cl_core.standard_readtable, ECL_NIL)); cl_set_dispatch_macro_character(4, ECL_CODE_CHAR('#'), ECL_CODE_CHAR('!'), ECL_NIL, r); ECL_SET(@'*read-default-float-format*', @'single-float'); { cl_object var, val; var = cl_list(24, @'*print-pprint-dispatch*', /* See end of pprint.lsp */ @'*print-array*', @'*print-base*', @'*print-case*', @'*print-circle*', @'*print-escape*', @'*print-gensym*', @'*print-length*', @'*print-level*', @'*print-lines*', @'*print-miser-width*', @'*print-pretty*', @'*print-radix*', @'*print-readably*', @'*print-right-margin*', @'*read-base*', @'*read-default-float-format*', @'*read-eval*', @'*read-suppress*', @'*readtable*', @'si::*print-package*', @'si::*print-structure*', @'si::*sharp-eq-context*', @'si::*circle-counter*'); val = cl_list(24, /**pprint-dispatch-table**/ ECL_NIL, /**print-array**/ ECL_T, /**print-base**/ ecl_make_fixnum(10), /**print-case**/ @':downcase', /**print-circle**/ ECL_T, /**print-escape**/ ECL_T, /**print-gensym**/ ECL_T, /**print-length**/ ECL_NIL, /**print-level**/ ECL_NIL, /**print-lines**/ ECL_NIL, /**print-miser-width**/ ECL_NIL, /**print-pretty**/ ECL_NIL, /**print-radix**/ ECL_NIL, /**print-readably**/ ECL_T, /**print-right-margin**/ ECL_NIL, /**read-base**/ ecl_make_fixnum(10), /**read-default-float-format**/ @'single-float', /**read-eval**/ ECL_T, /**read-suppress**/ ECL_NIL, /**readtable**/ cl_core.standard_readtable, /*si::*print-package**/ cl_core.lisp_package, /*si::*print-structure**/ ECL_T, /*si::*sharp-eq-context**/ ECL_NIL, /*si::*cicle-counter**/ ECL_NIL); ECL_SET(@'si::+ecl-syntax-progv-list+', CONS(var,val)); var = cl_list(23, @'*print-pprint-dispatch*', /* See end of pprint.lsp */ @'*print-array*', @'*print-base*', @'*print-case*', @'*print-circle*', @'*print-escape*', @'*print-gensym*', @'*print-length*', @'*print-level*', @'*print-lines*', @'*print-miser-width*', @'*print-pretty*', @'*print-radix*', @'*print-readably*', @'*print-right-margin*', @'*read-base*', @'*read-default-float-format*', @'*read-eval*', @'*read-suppress*', @'*readtable*', @'*package*', @'si::*sharp-eq-context*', @'si::*circle-counter*'); val = cl_list(23, /**pprint-dispatch-table**/ ECL_NIL, /**print-array**/ ECL_T, /**print-base**/ ecl_make_fixnum(10), /**print-case**/ @':upcase', /**print-circle**/ ECL_NIL, /**print-escape**/ ECL_T, /**print-gensym**/ ECL_T, /**print-length**/ ECL_NIL, /**print-level**/ ECL_NIL, /**print-lines**/ ECL_NIL, /**print-miser-width**/ ECL_NIL, /**print-pretty**/ ECL_NIL, /**print-radix**/ ECL_NIL, /**print-readably**/ ECL_T, /**print-right-margin**/ ECL_NIL, /**read-base**/ ecl_make_fixnum(10), /**read-default-float-format**/ @'single-float', /**read-eval**/ ECL_T, /**read-suppress**/ ECL_NIL, /**readtable**/ cl_core.standard_readtable, /**package**/ cl_core.user_package, /*si::*sharp-eq-context**/ ECL_NIL, /*si::*cicle-counter**/ ECL_NIL); ECL_SET(@'si::+io-syntax-progv-list+', CONS(var,val)); } } /* *---------------------------------------------------------------------- * * ecl_init_module -- * reads the data vector from stream into vector VV * * Results: * a vector. * *---------------------------------------------------------------------- */ static cl_object make_one_data_stream(const cl_object string) { #ifdef ECL_UNICODE return si_make_sequence_input_stream(3, string, @':external-format', @':utf-8'); #else return ecl_make_string_input_stream(string, 0, ecl_length(string)); #endif } static cl_object make_data_stream(const cl_object *data) { if (data == 0 || data[0] == NULL) { return cl_core.null_stream; } if (data[1] == NULL) { return make_one_data_stream(data[0]); } else { cl_object stream_list = ECL_NIL; cl_index i; for (i = 0; data[i]; i++) { cl_object s = make_one_data_stream(data[i]); stream_list = ecl_cons(s, stream_list); } return cl_apply(2, @'make-concatenated-stream', cl_nreverse(stream_list)); } } cl_object ecl_init_module(cl_object block, void (*entry_point)(cl_object)) { const cl_env_ptr env = ecl_process_env(); volatile cl_object old_eptbc = env->packages_to_be_created; volatile cl_object x; cl_index i, len, perm_len, temp_len; cl_object in; cl_object *VV = NULL, *VVtemp = NULL; if (block == NULL) block = ecl_make_codeblock(); block->cblock.entry = entry_point; in = OBJNULL; ECL_UNWIND_PROTECT_BEGIN(env) { cl_index bds_ndx; cl_object progv_list; ecl_bds_bind(env, @'si::*cblock*', block); env->packages_to_be_created_p = ECL_T; /* Communicate the library which Cblock we are using, and get * back the amount of data to be processed. */ (*entry_point)(block); perm_len = block->cblock.data_size; temp_len = block->cblock.temp_data_size; len = perm_len + temp_len; if (block->cblock.data_text == 0) { if (len) { /* Code from COMPILE uses data in *compiler-constants* */ cl_object v = ECL_SYM_VAL(env,@'si::*compiler-constants*'); unlikely_if (ecl_t_of(v) != t_vector || v->vector.dim != len || v->vector.elttype != ecl_aet_object) FEerror("Internal error: corrupted data in " "si::*compiler-constants*", 0); VV = block->cblock.data = v->vector.self.t; VVtemp = block->cblock.temp_data = NULL; } goto NO_DATA_LABEL; } if (len == 0) { VV = VVtemp = NULL; goto NO_DATA_LABEL; } #ifdef ECL_DYNAMIC_VV VV = block->cblock.data = perm_len? (cl_object *)ecl_alloc(perm_len * sizeof(cl_object)) : NULL; #else VV = block->cblock.data; #endif memset(VV, 0, perm_len * sizeof(*VV)); VVtemp = block->cblock.temp_data = temp_len? (cl_object *)ecl_alloc(temp_len * sizeof(cl_object)) : NULL; memset(VVtemp, 0, temp_len * sizeof(*VVtemp)); /* Read all data for the library */ #ifdef ECL_EXTERNALIZABLE { cl_object v = ecl_deserialize(block->cblock.data_text); unlikely_if (v->vector.dim < len) FEreader_error("Not enough data while loading" "binary file", in, 0); memcpy(VV, v->vector.self.t, len * sizeof(cl_object)); } #else in = make_data_stream(block->cblock.data_text); progv_list = ECL_SYM_VAL(env, @'si::+ecl-syntax-progv-list+'); bds_ndx = ecl_progv(env, ECL_CONS_CAR(progv_list), ECL_CONS_CDR(progv_list)); for (i = 0 ; i < len; i++) { x = ecl_read_object(in); if (x == OBJNULL) break; if (i < perm_len) VV[i] = x; else VVtemp[i-perm_len] = x; } if (!Null(ECL_SYM_VAL(env, @'si::*sharp-eq-context*'))) { while (i--) { if (i < perm_len) { VV[i] = patch_sharp(env, VV[i]); } else { VVtemp[i-perm_len] = patch_sharp(env, VVtemp[i-perm_len]); } } } ecl_bds_unwind(env, bds_ndx); unlikely_if (i < len) FEreader_error("Not enough data while loading" "binary file", in, 0); cl_close(1,in); in = OBJNULL; #endif NO_DATA_LABEL: env->packages_to_be_created_p = ECL_NIL; assert(block->cblock.cfuns_size == 0 || VV != NULL); for (i = 0; i < block->cblock.cfuns_size; i++) { const struct ecl_cfun *prototype = block->cblock.cfuns+i; cl_index fname_location = ecl_fixnum(prototype->block); cl_object fname = VV[fname_location]; cl_index location = ecl_fixnum(prototype->name); cl_object position = prototype->file_position; int narg = prototype->narg; VV[location] = narg<0? ecl_make_cfun_va((cl_objectfn)prototype->entry, fname, block) : ecl_make_cfun((cl_objectfn_fixed)prototype->entry, fname, block, narg); /* Add source file info */ if (position != ecl_make_fixnum(-1)) { ecl_set_function_source_file_info(VV[location], block->cblock.source, position); } } /* Execute top-level code */ (*entry_point)(OBJNULL); x = cl_set_difference(2, env->packages_to_be_created, old_eptbc); old_eptbc = env->packages_to_be_created; unlikely_if (!Null(x)) { CEerror(ECL_T, Null(ECL_CONS_CDR(x))? "Package ~A referenced in " "compiled file~& ~A~&but has not been created": "The packages~& ~A~&were referenced in " "compiled file~& ~A~&but have not been created", 2, x, block->cblock.name); } if (VVtemp) { block->cblock.temp_data = NULL; block->cblock.temp_data_size = 0; ecl_dealloc(VVtemp); } ecl_bds_unwind1(env); } ECL_UNWIND_PROTECT_EXIT { if (in != OBJNULL) cl_close(1,in); env->packages_to_be_created = old_eptbc; env->packages_to_be_created_p = ECL_NIL; } ECL_UNWIND_PROTECT_END; return block; } ecl-16.1.2/src/c/reader/000077500000000000000000000000001266352375300146335ustar00rootroot00000000000000ecl-16.1.2/src/c/reader/parse_integer.d000066400000000000000000000075071266352375300176400ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../../Copyright' for full details. */ #include #include #include #define basep(d) (d <= 36) cl_object ecl_parse_integer(cl_object str, cl_index start, cl_index end, cl_index *ep, unsigned int radix) { int sign, d; cl_object integer_part, output; cl_index i, c; if (start >= end || !basep(radix)) { *ep = start; return OBJNULL; } sign = 1; c = ecl_char(str, start); if (c == '+') { start++; } else if (c == '-') { sign = -1; start++; } integer_part = _ecl_big_register0(); _ecl_big_set_ui(integer_part, 0); for (i = start; i < end; i++) { c = ecl_char(str, i); d = ecl_digitp(c, radix); if (d < 0) { break; } _ecl_big_mul_ui(integer_part, integer_part, radix); _ecl_big_add_ui(integer_part, integer_part, d); } if (sign < 0) { _ecl_big_complement(integer_part, integer_part); } output = _ecl_big_register_normalize(integer_part); *ep = i; return (i == start)? OBJNULL : output; } @(defun parse_integer (strng &key (start ecl_make_fixnum(0)) end (radix ecl_make_fixnum(10)) junk_allowed &aux x) cl_index s, e, ep; cl_object rtbl = ecl_current_readtable(); @ { unlikely_if (!ECL_STRINGP(strng)) { FEwrong_type_nth_arg(@[parse-integer], 1, strng, @[string]); } unlikely_if (!ECL_FIXNUMP(radix) || ecl_fixnum_lower(radix, ecl_make_fixnum(2)) || ecl_fixnum_greater(radix, ecl_make_fixnum(36))) { FEerror("~S is an illegal radix.", 1, radix); } { cl_index_pair p = ecl_vector_start_end(@[parse-integer], strng, start, end); s = p.start; e = p.end; } while (s < e && ecl_readtable_get(rtbl, ecl_char(strng, s), NULL) == cat_whitespace) { s++; } if (s >= e) { if (junk_allowed != ECL_NIL) @(return ECL_NIL ecl_make_fixnum(s)) else goto CANNOT_PARSE; } x = ecl_parse_integer(strng, s, e, &ep, ecl_fixnum(radix)); if (x == OBJNULL) { if (junk_allowed != ECL_NIL) { @(return ECL_NIL ecl_make_fixnum(ep)); } else { goto CANNOT_PARSE; } } if (junk_allowed != ECL_NIL) { @(return x ecl_make_fixnum(ep)); } for (s = ep; s < e; s++) { unlikely_if (ecl_readtable_get(rtbl, ecl_char(strng, s), NULL) != cat_whitespace) { CANNOT_PARSE: FEparse_error("Cannot parse an integer in the string ~S.", ECL_NIL, 1, strng); } } @(return x ecl_make_fixnum(e)); } @) ecl-16.1.2/src/c/reader/parse_number.d000066400000000000000000000207451266352375300174720ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../../Copyright' for full details. */ #include static bool exponent_charp(cl_fixnum c) { return (c == 'e') || (c == 'E') || (c == 'f') || (c == 'F') || (c == 's') || (c == 'S') || (c == 'd') || (c == 'D') || (c == 'l') || (c == 'L'); } static cl_object expt10(cl_index expt) { cl_object accum = _ecl_big_register0(); cl_object factor = _ecl_big_register1(); _ecl_big_set_ui(accum, 1); _ecl_big_set_ui(factor, 10); for (; expt; expt >>= 1) { if (expt & 1) { _ecl_big_mul(accum, accum, factor); } _ecl_big_mul(factor, factor, factor); } _ecl_big_register_free(factor); return _ecl_big_register_normalize(accum); } static cl_object infinity(cl_index exp_char, int sign) { cl_object var; switch (exp_char) { case 'e': case 'E': return infinity(ecl_current_read_default_float_format(), sign); case 's': case 'S': case 'f': case 'F': var = (sign<0)? @'ext::single-float-negative-infinity' : @'ext::single-float-positive-infinity'; break; case 'l': case 'L': #ifdef ECL_LONG_FLOAT var = (sign<0)? @'ext::long-float-negative-infinity' : @'ext::long-float-positive-infinity'; break; #endif case 'd': case 'D': var = (sign<0)? @'ext::double-float-negative-infinity' : @'ext::double-float-positive-infinity'; break; default: return OBJNULL; } return ecl_symbol_value(var); } static cl_object make_float(cl_object num, cl_object exp, cl_index exp_char, int sign) { if (!ECL_FIXNUMP(exp)) { return infinity(exp_char, sign); } else { cl_fixnum fix_exp = ecl_fixnum(exp); if (fix_exp > 0) { num = ecl_times(num, expt10(fix_exp)); } else if (fix_exp < 0) { num = ecl_divide(num, expt10(-fix_exp)); } } AGAIN: switch (exp_char) { case 'e': case 'E': exp_char = ecl_current_read_default_float_format(); goto AGAIN; case 's': case 'S': case 'f': case 'F': return ecl_make_single_float(sign * ecl_to_double(num)); case 'l': case 'L': #ifdef ECL_LONG_FLOAT return ecl_make_long_float(sign * ecl_to_long_double(num)); #endif case 'd': case 'D': { return ecl_make_double_float(sign * ecl_to_double(num)); } default: return OBJNULL; } } /* ecl_parse_number(str, start, end, ep, radix) parses C string str up to (but not including) str[end] using radix as the radix for the rational number. (For floating numbers, the radix is ignored and replaced with 10) When parsing succeeds, the index of the next character is assigned to *ep, and the number is returned as a lisp data object. If not, OBJNULL is returned. */ cl_object ecl_parse_number(cl_object str, cl_index start, cl_index end, cl_index *ep, unsigned int radix) { int sign = -1, d; cl_index c, i, decimal = end; cl_object num = _ecl_big_register0(); bool some_digit = 0; if (end <= start || radix > 36) { *ep = start; return OBJNULL; } AGAIN: _ecl_big_set_ui(num, 0); c = ecl_char(str, i = start); sign = 1; if (c == '+') { if (++i == end) goto NOT_A_NUMBER; c = ecl_char(str, i); } else if (c == '-') { sign = -1; if (++i == end) goto NOT_A_NUMBER; c = ecl_char(str, i); } if (c == '/') { goto NOT_A_NUMBER; } for (; i < end; i++) { c = ecl_char(str, i); if (c == '/') { cl_object den; if (sign < 0) _ecl_big_complement(num, num); num = _ecl_big_register_normalize(num); c = ecl_char(str, ++i); if (ecl_digitp(c, radix) < 0) goto NOT_A_NUMBER; den = ecl_parse_integer(str, i, end, ep, radix); if (den == OBJNULL || (*ep < end)) { return OBJNULL; } else if (den == ecl_make_fixnum(0)) { return ECL_NIL; } else { return ecl_make_ratio(num, den); } } else if (c == '.') { if (decimal <= i) { goto NOT_A_NUMBER; } if (radix != 10) { radix = 10; goto AGAIN; } /* For a number xxxx.1234...nEyyy * we have stored in num the number xxxx1234...n and * will get in the exponent yyy. What we do is to simply * shift the exponent by -n. */ decimal = i+1; } else if ((d = ecl_digitp(c, radix)) >= 0) { _ecl_big_mul_ui(num, num, radix); _ecl_big_add_ui(num, num, d); some_digit = 1; } else if (exponent_charp(c)) { cl_object exp, decimals; if (!some_digit) goto NOT_A_NUMBER; if (radix != 10) { radix = 10; goto AGAIN; } num = _ecl_big_register_normalize(num); decimals = (decimal < i) ? ecl_make_fixnum(decimal - i): ecl_make_fixnum(0); exp = ecl_parse_integer(str, ++i, end, ep, 10); if (exp == OBJNULL || (*ep < end)) return OBJNULL; return make_float(num, ecl_plus(decimals, exp), c, sign); } else if (radix != 10) { _ecl_big_register_free(num); num = ecl_parse_number(str, start, end, ep, 10); if (num != OBJNULL) { if (floatp(num)) return num; if (ECL_FIXNUMP(num) || ECL_BIGNUMP(num)) { i = *ep; if (i > start && ecl_char(str, i-1) == '.') return num; } } return OBJNULL; } else { NOT_A_NUMBER: *ep = i; _ecl_big_register_free(num); return OBJNULL; } } /* If we have reached the end without decimals (for instance * 1., 2, 13., etc) we return an integer */ *ep = i; if (decimal < i) { if (!some_digit) goto NOT_A_NUMBER; return make_float(_ecl_big_register_normalize(num), ecl_make_fixnum(decimal - i), 'e', sign); } else { if (sign < 0) _ecl_big_complement(num, num); return _ecl_big_register_normalize(num); } } ecl-16.1.2/src/c/reference.d000066400000000000000000000132441266352375300155000ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* reference.c -- Reference in Constants and Variables. */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #include #include /* Symbol-function returns function-closure for function (macro . function-closure) for macros special for special forms. */ cl_object cl_symbol_function(cl_object sym) { cl_object output; int type = ecl_symbol_type(sym); if (type & ecl_stp_special_form) { output = @'special'; } else if (Null(sym) || (ECL_SYM_FUN(sym) == ECL_NIL)) { FEundefined_function(sym); } else if (type & ecl_stp_macro) { output = CONS(@'si::macro', ECL_SYM_FUN(sym)); } else { output = ECL_SYM_FUN(sym); } @(return output) } cl_object cl_fdefinition(cl_object fname) { @(return ((ECL_SYMBOLP(fname))? cl_symbol_function(fname) : ecl_fdefinition(fname))) } cl_object cl_fboundp(cl_object fname) { if (Null(fname)) { @(return ECL_NIL); } else if (ECL_SYMBOLP(fname)) { @(return (((fname->symbol.stype & ecl_stp_special_form) || ECL_SYM_FUN(fname) != ECL_NIL)? ECL_T : ECL_NIL)) } else if (LISTP(fname)) { if (CAR(fname) == @'setf') { cl_object sym = CDR(fname); if (CONSP(sym) && CDR(sym) == ECL_NIL) { cl_object pair; sym = CAR(sym); if (ECL_SYMBOLP(sym)) { pair = ecl_setf_definition(sym, ECL_NIL); @(return ecl_cdr(pair)); } } } } FEinvalid_function_name(fname); } cl_object ecl_fdefinition(cl_object fun) { cl_type t = ecl_t_of(fun); cl_object output; if (t == t_symbol) { output = ECL_SYM_FUN(fun); unlikely_if (output == ECL_NIL) FEundefined_function(fun); unlikely_if (fun->symbol.stype & (ecl_stp_macro | ecl_stp_special_form)) FEundefined_function(fun); } else unlikely_if (Null(fun)) { FEundefined_function(fun); } else if (t == t_list) { cl_object sym = CDR(fun); unlikely_if (!CONSP(sym)) FEinvalid_function_name(fun); if (CAR(fun) == @'setf') { unlikely_if (CDR(sym) != ECL_NIL) FEinvalid_function_name(fun); sym = CAR(sym); unlikely_if (ecl_t_of(sym) != t_symbol) FEinvalid_function_name(fun); output = ecl_setf_definition(sym, ECL_NIL); unlikely_if (Null(ecl_cdr(output))) FEundefined_function(fun); output = ECL_CONS_CAR(output); } else if (CAR(fun) == @'lambda') { return si_make_lambda(ECL_NIL, sym); } else if (CAR(fun) == @'ext::lambda-block') { return si_make_lambda(CAR(sym), CDR(sym)); } else { FEinvalid_function_name(fun); } } else { FEinvalid_function_name(fun); } return output; } cl_object si_coerce_to_function(cl_object fun) { cl_type t = ecl_t_of(fun); if (!(t == t_cfun || t == t_cfunfixed || t == t_cclosure || t == t_bytecodes || t == t_bclosure || (t == t_instance && fun->instance.isgf))) { fun = ecl_fdefinition(fun); } @(return fun) } cl_object cl_symbol_value(cl_object sym) { const cl_env_ptr the_env = ecl_process_env(); cl_object value; if (Null(sym)) { value = sym; } else { if (ecl_unlikely(!ECL_SYMBOLP(sym))) { FEwrong_type_only_arg(@[symbol-value], sym, @[symbol]); } value = ECL_SYM_VAL(the_env, sym); if (ecl_unlikely(value == OBJNULL)) { FEunbound_variable(sym); } } @(return value) } bool ecl_boundp(cl_env_ptr env, cl_object sym) { if (Null(sym)) { return 1; } else { if (ecl_unlikely(!ECL_SYMBOLP(sym))) FEwrong_type_only_arg(@[boundp], sym, @[symbol]); return ECL_SYM_VAL(env, sym) != OBJNULL; } } cl_object cl_boundp(cl_object sym) { const cl_env_ptr the_env = ecl_process_env(); ecl_return1(the_env, ecl_boundp(the_env,sym)? ECL_T : ECL_NIL); } cl_object cl_special_operator_p(cl_object form) { const cl_env_ptr the_env = ecl_process_env(); int special = ecl_symbol_type(form) & ecl_stp_special_form; ecl_return1(the_env, special? ECL_T : ECL_NIL); } ecl-16.1.2/src/c/sequence.d000066400000000000000000000211071266352375300153470ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* sequence.d -- Sequence routines. */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #include #include #include cl_index_pair ecl_sequence_start_end(cl_object fun, cl_object sequence, cl_object start, cl_object end) { cl_index_pair p; cl_index l; p.length = l = ecl_length(sequence); unlikely_if (!ECL_FIXNUMP(start) || ecl_fixnum_minusp(start)) { FEwrong_type_key_arg(fun, @[:start], start, @[unsigned-byte]); } p.start = ecl_fixnum(start); if (Null(end)) { p.end = l; } else { unlikely_if (!ECL_FIXNUMP(end) || ecl_fixnum_minusp(end)) { FEwrong_type_key_arg(fun, @[:end], end, ecl_read_from_cstring("(OR NULL UNSIGNED-BYTE)")); } p.end = ecl_fixnum(end); unlikely_if (p.end > l) { cl_object fillp = ecl_make_fixnum(l); FEwrong_type_key_arg(fun, @[:end], end, ecl_make_integer_type(start, fillp)); } } unlikely_if (p.end < p.start) { FEwrong_type_key_arg(fun, @[:start], start, ecl_make_integer_type(ecl_make_fixnum(0), ecl_make_fixnum(p.end))); } return p; } cl_object si_sequence_start_end(cl_object fun, cl_object sequence, cl_object start, cl_object end) { cl_index_pair p = ecl_sequence_start_end(fun, sequence, start, end); @(return ecl_make_fixnum(p.start) ecl_make_fixnum(p.end) ecl_make_fixnum(p.length)); } cl_object cl_elt(cl_object x, cl_object i) { @(return ecl_elt(x, ecl_to_size(i))) } cl_object ecl_elt(cl_object seq, cl_fixnum index) { cl_fixnum i; cl_object l; if (index < 0) goto E; switch (ecl_t_of(seq)) { case t_list: for (i = index, l = seq; i > 0; --i) { if (!LISTP(l)) goto E0; if (Null(l)) goto E; l = ECL_CONS_CDR(l); } if (!LISTP(l)) goto E0; if (Null(l)) goto E; return ECL_CONS_CAR(l); #ifdef ECL_UNICODE case t_string: #endif case t_vector: case t_bitvector: case t_base_string: if (index >= seq->vector.fillp) goto E; return ecl_aref_unsafe(seq, index); default: E0: FEtype_error_sequence(seq); } E: FEtype_error_index(seq, index); } cl_object si_elt_set(cl_object seq, cl_object index, cl_object val) { @(return ecl_elt_set(seq, ecl_to_size(index), val)) } cl_object ecl_elt_set(cl_object seq, cl_fixnum index, cl_object val) { cl_fixnum i; cl_object l; if (index < 0) goto E; switch (ecl_t_of(seq)) { case t_list: for (i = index, l = seq; i > 0; --i) { if (!LISTP(l)) goto E0; if (Null(l)) goto E; l = ECL_CONS_CDR(l); } if (!LISTP(l)) goto E0; if (Null(l)) goto E; ECL_RPLACA(l, val); return val; #ifdef ECL_UNICODE case t_string: #endif case t_vector: case t_bitvector: case t_base_string: if (index >= seq->vector.fillp) goto E; return ecl_aset_unsafe(seq, index, val); default: E0: FEtype_error_sequence(seq); } E: FEtype_error_index(seq, index); } cl_object ecl_subseq(cl_object sequence, cl_index start, cl_index limit) { switch (ecl_t_of(sequence)) { case t_list: if (start) sequence = ecl_nthcdr(start, sequence); { cl_object x = ECL_NIL; cl_object *z = &x; while (!Null(sequence) && (limit--)) { if (ECL_ATOM(sequence)) FEtype_error_cons(sequence); z = &ECL_CONS_CDR(*z = ecl_list1(ECL_CONS_CAR(sequence))); sequence = ECL_CONS_CDR(sequence); } return x; } #ifdef ECL_UNICODE case t_string: #endif case t_vector: case t_bitvector: case t_base_string: { cl_index size; cl_object x; if (start > sequence->vector.fillp) { x = ecl_alloc_simple_vector(0, ecl_array_elttype(sequence)); } else { size = sequence->vector.fillp - start; if (size > limit) size = limit; x = ecl_alloc_simple_vector(size, ecl_array_elttype(sequence)); ecl_copy_subarray(x, 0, sequence, start, size); } return x; } default: FEtype_error_sequence(sequence); } } cl_object ecl_copy_seq(cl_object sequence) { return ecl_subseq(sequence, 0, MOST_POSITIVE_FIXNUM); } @(defun subseq (sequence start &optional end &aux x) cl_index_pair p; @ p = ecl_sequence_start_end(@[subseq], sequence, start, end); sequence = ecl_subseq(sequence, p.start, p.end - p.start); @(return sequence); @) cl_object cl_copy_seq(cl_object x) { @(return ecl_subseq(x, 0, MOST_POSITIVE_FIXNUM)); } cl_object cl_length(cl_object x) { @(return ecl_make_fixnum(ecl_length(x))) } cl_fixnum ecl_length(cl_object x) { cl_fixnum i; switch (ecl_t_of(x)) { case t_list: /* INV: A list's length always fits in a fixnum */ i = 0; loop_for_in(x) { i++; } end_loop_for_in; return(i); #ifdef ECL_UNICODE case t_string: #endif case t_vector: case t_base_string: case t_bitvector: return(x->vector.fillp); default: FEtype_error_sequence(x); } } cl_object cl_reverse(cl_object seq) { cl_object output, x; switch (ecl_t_of(seq)) { case t_list: { for (x = seq, output = ECL_NIL; !Null(x); x = ECL_CONS_CDR(x)) { if (!LISTP(x)) goto E; output = CONS(ECL_CONS_CAR(x), output); } break; } #ifdef ECL_UNICODE case t_string: #endif case t_vector: case t_bitvector: case t_base_string: output = ecl_alloc_simple_vector(seq->vector.fillp, ecl_array_elttype(seq)); ecl_copy_subarray(output, 0, seq, 0, seq->vector.fillp); ecl_reverse_subarray(output, 0, seq->vector.fillp); break; default: E: FEtype_error_sequence(seq); } @(return output) } cl_object cl_nreverse(cl_object seq) { switch (ecl_t_of(seq)) { case t_list: { cl_object x, y, z; for (x = seq, y = ECL_NIL; !Null(x); ) { if (!LISTP(x)) FEtype_error_list(x); z = x; x = ECL_CONS_CDR(x); if (x == seq) FEcircular_list(seq); ECL_RPLACD(z, y); y = z; } seq = y; break; } #ifdef ECL_UNICODE case t_string: #endif case t_vector: case t_base_string: case t_bitvector: ecl_reverse_subarray(seq, 0, seq->vector.fillp); break; default: FEtype_error_sequence(seq); } @(return seq) } ecl-16.1.2/src/c/serialize.d000066400000000000000000000475451266352375300155440ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* serialize.d -- Serialize a bunch of lisp data. */ /* Copyright (c) 2010, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #include #define ECL_DEFINE_AET_SIZE #include struct fake_package { _ECL_HDR; cl_object name; }; struct fake_symbol { _ECL_HDR; cl_object name; cl_object pack; }; #define ROUND_TO_WORD(int) \ ((int + sizeof(cl_fixnum) - 1) & ~(sizeof(cl_fixnum) - 1)) #define ROUNDED_SIZE(name) \ ROUND_TO_WORD(sizeof(struct name)) static cl_index object_size[] = { 0, /* t_start */ ROUNDED_SIZE(ecl_cons), /* t_list */ 0, /* t_character = 2 */ 0, /* t_fixnum = 3 */ ROUNDED_SIZE(ecl_bignum), /* t_bignum = 4 */ ROUNDED_SIZE(ecl_ratio), /* t_ratio */ ROUNDED_SIZE(ecl_singlefloat), /* t_singlefloat */ ROUNDED_SIZE(ecl_doublefloat), /* t_doublefloat */ #ifdef ECL_LONG_FLOAT ROUNDED_SIZE(ecl_long_float), /* t_longfloat */ #endif ROUNDED_SIZE(ecl_complex), /* t_complex */ ROUNDED_SIZE(fake_symbol), /* t_symbol */ ROUNDED_SIZE(fake_package), /* t_package */ ROUNDED_SIZE(ecl_hashtable), /* t_hashtable */ ROUNDED_SIZE(ecl_array), /* t_array */ ROUNDED_SIZE(ecl_vector), /* t_vector */ #ifdef ECL_UNICODE ROUNDED_SIZE(ecl_string), /* t_string */ #endif ROUNDED_SIZE(ecl_base_string), /* t_base_string */ ROUNDED_SIZE(ecl_vector), /* t_bitvector */ ROUNDED_SIZE(ecl_stream), /* t_stream */ ROUNDED_SIZE(ecl_random), /* t_random */ ROUNDED_SIZE(ecl_readtable), /* t_readtable */ ROUNDED_SIZE(ecl_pathname), /* t_pathname */ ROUNDED_SIZE(ecl_bytecodes), /* t_bytecodes */ ROUNDED_SIZE(ecl_bclosure), /* t_bclosure */ ROUNDED_SIZE(ecl_cfun), /* t_cfun */ ROUNDED_SIZE(ecl_cfunfixed), /* t_cfunfixed */ ROUNDED_SIZE(ecl_cclosure), /* t_cclosure */ ROUNDED_SIZE(ecl_instance), /* t_instance */ #ifdef ECL_THREADS ROUNDED_SIZE(ecl_process), /* t_process */ ROUNDED_SIZE(ecl_lock), /* t_lock */ ROUNDED_SIZE(ecl_rwlock), /* t_rwlock */ ROUNDED_SIZE(ecl_condition_variable), /* t_condition_variable */ ROUNDED_SIZE(ecl_semaphore), /* t_semaphore */ ROUNDED_SIZE(ecl_barrier), /* t_barrier */ ROUNDED_SIZE(ecl_mailbox), /* t_mailbox */ #endif ROUNDED_SIZE(ecl_codeblock), /* t_codeblock */ ROUNDED_SIZE(ecl_foreign), /* t_foreign */ ROUNDED_SIZE(ecl_frame), /* t_frame */ ROUNDED_SIZE(ecl_weak_pointer) /* t_weak_pointer */ #ifdef ECL_SSE2 , ROUNDED_SIZE(ecl_sse_pack) /* t_sse_pack */ #endif }; typedef struct pool { cl_object data; cl_object hash; cl_object queue; cl_object last; } *pool_t; static cl_index alloc(pool_t pool, cl_index size) { cl_index bytes = ROUND_TO_WORD(size); cl_index fillp = pool->data->vector.fillp; cl_index next_fillp = fillp + bytes; if (next_fillp >= pool->data->vector.dim) { cl_index new_dim = next_fillp + next_fillp / 2; pool->data = _ecl_funcall3(@'adjust-array', pool->data, ecl_make_fixnum(new_dim)); } pool->data->vector.fillp = next_fillp; return fillp; } static cl_object fix_to_ptr(cl_object ptr) { cl_fixnum i = (cl_fixnum)ptr; return (cl_object)(i & ~ECL_IMMEDIATE_TAG); } static cl_object enqueue(pool_t pool, cl_object what) { cl_object record, index; if (ECL_FIXNUMP(what) || ECL_CHARACTERP(what) || what == OBJNULL) { return what; } #ifdef ECL_SMALL_CONS if (Null(what)) return what; #endif index = ecl_gethash_safe(what, pool->hash, OBJNULL); if (index == OBJNULL) { cl_object cons; index = ecl_make_fixnum(pool->hash->hash.entries); ecl_sethash(what, pool->hash, index); cons = ecl_cons(what, ECL_NIL); ECL_RPLACD(pool->last, cons); pool->last = cons; } return fix_to_ptr(index); } #ifdef ECL_SMALL_CONS typedef struct { _ECL_HDR; cl_object car, cdr; } large_cons; typedef large_cons *large_cons_ptr; #endif static cl_index serialize_bits(pool_t pool, void *data, cl_index size) { cl_index index = alloc(pool, size); memcpy(pool->data->vector.self.b8 + index, data, size); return index; } static void serialize_object_ptr(pool_t pool, cl_object *ptr, cl_index dim) { cl_index index = serialize_bits(pool, ptr, dim*sizeof(cl_object)); for (; dim; dim--, index += sizeof(cl_object)) { cl_object *p = (cl_object *)(pool->data->vector.self.b8 + index); *p = enqueue(pool, *p); p++; } } static void serialize_vector(pool_t pool, cl_object v); static void serialize_displaced_vector(pool_t pool, cl_object v) { cl_object disp = v->vector.displaced; cl_object to = ECL_CONS_CAR(disp); if (Null(to)) { v->vector.displaced = ECL_NIL; serialize_vector(pool, v); } else { cl_index index = v->vector.self.b8 - to->vector.self.b8; v->vector.displaced = enqueue(pool, to); v->vector.self.b8 = (uint8_t*)index; } } static void serialize_vector(pool_t pool, cl_object v) { if (!Null(v->vector.displaced)) { serialize_displaced_vector(pool, v); } else if (v->vector.elttype == ecl_aet_object) { serialize_object_ptr(pool, v->vector.self.t, v->vector.dim); } else { serialize_bits(pool, v->vector.self.b8, v->vector.dim * ecl_aet_size[v->vector.elttype]); } } static void serialize_array(pool_t pool, cl_object a) { serialize_bits(pool, a->array.dims, sizeof(cl_index) * a->array.rank); serialize_vector(pool, a); } static void serialize_one(pool_t pool, cl_object what) { cl_index bytes, index; cl_object buffer; #ifdef ECL_SMALL_CONS if (ECL_LISTP(what)) { cl_index bytes = ROUND_TO_WORD(sizeof(large_cons)); cl_index index = alloc(pool, bytes); large_cons_ptr cons = (large_cons_ptr)(pool->data->vector.self.b8 + index); memset(cons, 0, bytes); cons->t = t_list; cons->car = enqueue(pool, ECL_CONS_CAR(what)); cons->cdr = enqueue(pool, ECL_CONS_CDR(what)); return; } #endif bytes = object_size[what->d.t]; index = alloc(pool, bytes); buffer = (cl_object)(pool->data->vector.self.b8 + index); memcpy(buffer, what, bytes); switch (buffer->d.t) { case t_singlefloat: case t_doublefloat: #ifdef ECL_LONG_FLOAT case t_longfloat: #endif break; #ifndef ECL_SMALL_CONS case t_list: buffer->cons.car = enqueue(pool, buffer->cons.car); buffer->cons.cdr = enqueue(pool, buffer->cons.car); break; #endif case t_bignum: { cl_fixnum size = ECL_BIGNUM_SIZE(buffer); cl_index dim = ((size < 0) ? (-size) : size); cl_index bytes = dim * sizeof(mp_limb_t); serialize_bits(pool, ECL_BIGNUM_LIMBS(buffer), bytes); break; } case t_ratio: { buffer->ratio.den = enqueue(pool, buffer->ratio.den); buffer->ratio.num = enqueue(pool, buffer->ratio.num); break; } case t_complex: { buffer->complex.real = enqueue(pool, buffer->complex.real); buffer->complex.imag = enqueue(pool, buffer->complex.imag); break; } #ifdef ECL_UNICODE case t_string: #endif case t_vector: case t_bitvector: case t_base_string: { serialize_vector(pool, buffer); break; } case t_array: { cl_index bytes = ROUND_TO_WORD(buffer->array.rank * sizeof(cl_index)); serialize_bits(pool, buffer->array.dims, bytes); serialize_vector(pool, buffer); break; } case t_package: { struct fake_package *p = (struct fake_package *)buffer; p->name = enqueue(pool, what->pack.name); break; } case t_symbol: { struct fake_symbol *p = (struct fake_symbol *)buffer; p->name = enqueue(pool, what->symbol.name); p->pack = enqueue(pool, what->symbol.hpack); break; } case t_pathname: buffer->pathname.host = enqueue(pool, buffer->pathname.host); buffer->pathname.device = enqueue(pool, buffer->pathname.device); buffer->pathname.directory = enqueue(pool, buffer->pathname.directory); buffer->pathname.name = enqueue(pool, buffer->pathname.name); buffer->pathname.type = enqueue(pool, buffer->pathname.type); buffer->pathname.version = enqueue(pool, buffer->pathname.version); break; case t_random: { buffer->random.value = enqueue(pool, buffer->random.value); break; } case t_bclosure: { buffer->bclosure.code = enqueue(pool, buffer->bclosure.code); buffer->bclosure.lex = enqueue(pool, buffer->bclosure.lex); } case t_bytecodes: { buffer->bytecodes.name = enqueue(pool, buffer->bytecodes.name); buffer->bytecodes.definition = enqueue(pool, buffer->bytecodes.definition); buffer->bytecodes.data = enqueue(pool, buffer->bytecodes.data); buffer->bytecodes.file = enqueue(pool, buffer->bytecodes.file); buffer->bytecodes.file_position = enqueue(pool, buffer->bytecodes.file_position); buffer->bytecodes.code = serialize_bits(pool, buffer->bytecodes.code, buffer->bytecodes.code_size); } default: FEerror("Unable to serialize object ~A", 1, what); } } static void init_pool(pool_t pool, cl_object root) { pool->data = si_make_vector(@'ext::byte8', ecl_make_fixnum(1024), ECL_T, ecl_make_fixnum(2 * sizeof(cl_index)), ECL_NIL, ecl_make_fixnum(0)); pool->hash = cl__make_hash_table(@'eql', ecl_make_fixnum(256), cl_core.rehash_size, cl_core.rehash_threshold); ecl_sethash(root, pool->hash, ecl_make_fixnum(0)); pool->queue = ecl_list1(root); pool->last = pool->queue; } static cl_object close_pool(pool_t pool) { pool->data->vector.self.index[0] = pool->data->vector.fillp; pool->data->vector.self.index[1] = pool->hash->hash.entries; return pool->data; } cl_object si_serialize(cl_object root) { struct pool pool[1]; init_pool(pool, root); while (!Null(pool->queue)) { cl_object what = ECL_CONS_CAR(pool->queue); serialize_one(pool, what); pool->queue = ECL_CONS_CDR(pool->queue); } @(return close_pool(pool)); } static void * reconstruct_bits(uint8_t *data, cl_index bytes) { void *output = ecl_alloc_atomic(bytes); memcpy(output, data, bytes); return output; } static void * reconstruct_object_ptr(uint8_t *data, cl_index bytes) { void *output = ecl_alloc(bytes); memcpy(output, data, bytes); return output; } static uint8_t * reconstruct_bytecodes(cl_object o, uint8_t *data) { o->bytecodes.code = reconstruct_bits(data, o->bytecodes.code_size); data += o->bytecodes.code_size; return data; } static uint8_t * reconstruct_vector(cl_object v, uint8_t *data) { if (v->vector.displaced == ECL_NIL) { cl_type t = v->vector.elttype; cl_index size = v->vector.dim * ecl_aet_size[t]; cl_index bytes = ROUND_TO_WORD(size); if (t == ecl_aet_object) { v->vector.self.t = reconstruct_object_ptr(data, bytes); } else { v->vector.self.t = reconstruct_bits(data, size); } data += bytes; } return data; } static uint8_t * reconstruct_array(cl_object a, uint8_t *data) { cl_index bytes = ROUND_TO_WORD(a->array.rank * sizeof(cl_index)); a->array.dims = reconstruct_bits(data, bytes); return reconstruct_vector(a, data + bytes); } static uint8_t * duplicate_object(uint8_t *data, cl_object *output) { cl_type t = ((cl_object)data)->d.t; cl_object o = ecl_alloc_object(t); cl_index bytes = object_size[t]; memcpy(o, data, bytes); *output = o; return data + bytes; } static uint8_t * reconstruct_one(uint8_t *data, cl_object *output) { cl_object o = (cl_object)data; switch (o->d.t) { #ifdef ECL_SMALL_CONS case t_list: { large_cons_ptr c = (large_cons_ptr)data; *output = ecl_cons(c->car, c->cdr); data += ROUND_TO_WORD(sizeof(large_cons)); break; } #endif #ifdef ECL_UNICODE case t_string: #endif case t_base_string: case t_vector: case t_bitvector: data = duplicate_object(data, output); data = reconstruct_vector(*output, data); break; case t_array: data = duplicate_object(data, output); data = reconstruct_array(*output, data); break; case t_package: *output = (cl_object)data; data += ROUND_TO_WORD(sizeof(struct fake_package)); break; case t_symbol: *output = (cl_object)data; data += ROUND_TO_WORD(sizeof(struct fake_symbol)); break; case t_bytecodes: data = duplicate_object(data, output); data = reconstruct_bytecodes(*output, data); default: data = duplicate_object(data, output); } return data; } static cl_object get_object(cl_object o_or_index, cl_object *o_list) { if (ECL_IMMEDIATE(o_or_index)) { return o_or_index; } else { cl_index i = (cl_index)o_or_index >> 2; return o_list[i]; } } static void fixup_vector(cl_object v, cl_object *o_list) { if (!ECL_IMMEDIATE(v->vector.displaced)) { cl_object disp = get_object(v->vector.displaced, o_list); cl_object to = ECL_CONS_CAR(disp); if (to != ECL_NIL) { cl_index offset = (cl_index)v->vector.self.b8; v->vector.displaced = ECL_NIL; ecl_displace(v, to, ecl_make_fixnum(offset)); return; } } if (v->vector.elttype == ecl_aet_object) { cl_index i; cl_object *p = v->vector.self.t; for (i = v->vector.dim; i; i--, p++) { *p = get_object(*p, o_list); } } } static void fixup(cl_object o, cl_object *o_list) { #ifdef ECL_SMALL_CONS if (ECL_LISTP(o)) { ECL_RPLACA(o, get_object(ECL_CONS_CAR(o), o_list)); ECL_RPLACD(o, get_object(ECL_CONS_CDR(o), o_list)); return; } #endif switch (o->d.t) { case t_ratio: o->ratio.den = get_object(o->ratio.den, o_list); o->ratio.num = get_object(o->ratio.num, o_list); break; case t_complex: o->complex.real = get_object(o->complex.real, o_list); o->complex.imag = get_object(o->complex.imag, o_list); break; #ifdef ECL_UNICODE case t_string: #endif case t_base_string: case t_vector: case t_bitvector: case t_array: fixup_vector(o, o_list); break; case t_pathname: o->pathname.host = get_object(o->pathname.host, o_list); o->pathname.device = get_object(o->pathname.device, o_list); o->pathname.directory = get_object(o->pathname.directory, o_list); o->pathname.name = get_object(o->pathname.name, o_list); o->pathname.type = get_object(o->pathname.type, o_list); o->pathname.version = get_object(o->pathname.version, o_list); break; case t_random: o->random.value = get_object(o->random.value, o_list); break; case t_bclosure: o->bclosure.code = get_object(o->bclosure.code, o_list); o->bclosure.lex = get_object(o->bclosure.lex, o_list); o->bclosure.entry = _ecl_bclosure_dispatch_vararg; break; case t_bytecodes: o->bytecodes.name = get_object(o->bytecodes.name, o_list); o->bytecodes.definition = get_object(o->bytecodes.definition, o_list); o->bytecodes.data = get_object(o->bytecodes.data, o_list); o->bytecodes.file = get_object(o->bytecodes.file, o_list); o->bytecodes.file_position = get_object(o->bytecodes.file_position, o_list); o->bytecodes.entry = _ecl_bytecodes_dispatch_vararg; break; default: break; } } cl_object ecl_deserialize(uint8_t *raw) { cl_index *data = (cl_index*)raw; cl_index i, num_el = data[1]; cl_object *output = ecl_alloc(sizeof(cl_object) * num_el); raw += 2*sizeof(cl_index); for (i = 0; i < num_el; i++) { raw = reconstruct_one(raw, output+i); } for (i = 0; i < num_el; i++) { cl_object package = output[i]; if (!ECL_IMMEDIATE(package) && package->d.t == t_package) { cl_object name = get_object(package->pack.name, output); output[i] = ecl_find_package_nolock(name); } } for (i = 0; i < num_el; i++) { cl_object symbol = output[i]; if (!ECL_IMMEDIATE(symbol) && symbol->d.t == t_symbol) { struct fake_symbol *s = (struct fake_symbol *)symbol; cl_object name = get_object(s->name, output); cl_object pack = get_object(s->pack, output); int flag; output[i] = ecl_intern(name, pack, &flag); } } for (i = 0; i < num_el; i++) { fixup(output[i], output); } return output[0]; } cl_object si_deserialize(cl_object data) { @(return ecl_deserialize(data->vector.self.b8)) } ecl-16.1.2/src/c/sse2.d000066400000000000000000000120721266352375300144140ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* sse2.c -- SSE2 vector type support */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #include #include #define ECL_DEFINE_AET_SIZE #include #ifdef ECL_SSE2 /* Predicates */ cl_object si_sse_pack_p(cl_object x) { @(return (ECL_SSE_PACK_P(x) ? ECL_T : ECL_NIL)) } /* Element type substitution */ static void verify_sse_elttype(cl_elttype eltt) { switch (eltt) { case ecl_aet_sf: case ecl_aet_df: case ecl_aet_b8: case ecl_aet_i8: #ifdef ecl_uint16_t case ecl_aet_b16: case ecl_aet_i16: #endif #ifdef ecl_uint32_t case ecl_aet_b32: case ecl_aet_i32: #endif #ifdef ecl_uint64_t case ecl_aet_b64: case ecl_aet_i64: #endif break; /* OK */ default: FEerror("Invalid element type for an SSE pack: ~S", 1, ecl_elttype_to_symbol(eltt)); } } static cl_elttype symbol_to_sse_elttype(cl_object type) { cl_elttype eltt = ecl_symbol_to_elttype(type); verify_sse_elttype(eltt); return eltt; } cl_object si_sse_pack_as_elt_type(cl_object x, cl_object type) { cl_elttype rtype; if (ecl_unlikely(!ECL_SSE_PACK_P(x))) { FEwrong_type_nth_arg(@[ext::sse-pack-as-elt-type], 1, x, @[ext::sse-pack]); } rtype = symbol_to_sse_elttype(type); if (x->sse.elttype != rtype) { cl_object new = ecl_alloc_object(t_sse_pack); new->sse.elttype = rtype; new->sse.data.vi = x->sse.data.vi; x = new; } @(return x) } cl_object si_sse_pack_element_type(cl_object x) { if (ecl_unlikely(!ECL_SSE_PACK_P(x))) { FEwrong_type_nth_arg(@[ext::sse-pack-element-type], 1, x, @[ext::sse-pack]); } @(return ecl_elttype_to_symbol(x->sse.elttype) ecl_make_fixnum(x->sse.elttype)); } /* Conversion to and from specialized vectors */ cl_object si_sse_pack_to_vector(cl_object x, cl_object elt_type) { cl_elttype etype; cl_object vec; if (ecl_unlikely(!ECL_SSE_PACK_P(x))) { FEwrong_type_nth_arg(@[ext::sse-pack-to-vector], 1, x, @[ext::sse-pack]); } etype = x->sse.elttype; if (elt_type != ECL_NIL) etype = symbol_to_sse_elttype(elt_type); vec = ecl_alloc_simple_vector(16/ecl_aet_size[etype], etype); memcpy(vec->vector.self.b8, x->sse.data.b8, 16); @(return vec) } cl_object si_vector_to_sse_pack(cl_object x) { cl_object ssev; if (ecl_unlikely(!ECL_ARRAYP(x))) { FEwrong_type_nth_arg(@[ext::vector-to-sse-pack], 1, x, @[array]); } verify_sse_elttype(x->vector.elttype); if (ecl_unlikely(x->vector.dim * ecl_aet_size[x->vector.elttype] != 16)) FEerror("Wrong vector size in VECTOR-TO-SSE-PACK: ~S",1,ecl_make_fixnum(x->vector.dim)); ssev = ecl_alloc_object(t_sse_pack); ssev->sse.elttype = x->vector.elttype; memcpy(ssev->sse.data.b8, x->vector.self.b8, 16); @(return ssev) } /* Boxing and unboxing. The unboxing primitives accept any kind of sse-pack on purpose. */ cl_object ecl_make_int_sse_pack(__m128i value) { cl_object obj = ecl_alloc_object(t_sse_pack); obj->sse.elttype = ecl_aet_b8; obj->sse.data.vi = value; @(return obj); } __m128i ecl_unbox_int_sse_pack(cl_object x) { do { if (ECL_SSE_PACK_P(x)) return x->sse.data.vi; x = ecl_type_error(@'coerce', "variable", x, @'ext::sse-pack'); } while(1); } cl_object ecl_make_float_sse_pack(__m128 value) { cl_object obj = ecl_alloc_object(t_sse_pack); obj->sse.elttype = ecl_aet_sf; obj->sse.data.vf = value; @(return obj); } __m128 ecl_unbox_float_sse_pack(cl_object x) { do { if (ECL_SSE_PACK_P(x)) return x->sse.data.vf; x = ecl_type_error(@'coerce', "variable", x, @'ext::sse-pack'); } while(1); } cl_object ecl_make_double_sse_pack(__m128d value) { cl_object obj = ecl_alloc_object(t_sse_pack); obj->sse.elttype = ecl_aet_df; obj->sse.data.vd = value; @(return obj); } __m128d ecl_unbox_double_sse_pack(cl_object x) { do { if (ECL_SSE_PACK_P(x)) return x->sse.data.vd; x = ecl_type_error(@'coerce', "variable", x, @'ext::sse-pack'); } while(1); } #endif // ECL_SSE2 ecl-16.1.2/src/c/stacks.d000066400000000000000000000531231266352375300150320ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* stacks.c -- Binding/History/Frame stacks. */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #include #include #ifdef HAVE_SYS_RESOURCE_H # include # include #endif #include /************************ C STACK ***************************/ static void cs_set_size(cl_env_ptr env, cl_index new_size) { volatile char foo = 0; cl_index margin = ecl_option_values[ECL_OPT_C_STACK_SAFETY_AREA]; env->cs_limit_size = new_size - 2*margin; #ifdef ECL_DOWN_STACK if (&foo > env->cs_org - new_size + 16) { env->cs_limit = env->cs_org - new_size + 2*margin; if (env->cs_limit < env->cs_barrier) env->cs_barrier = env->cs_limit; } #else if (&foo < env->cs_org + new_size - 16) { env->cs_limit = env->cs_org + new_size - 2*margin; if (env->cs_limit > env->cs_barrier) env->cs_barrier = env->cs_limit; } #endif else ecl_internal_error("can't reset env->cs_limit."); env->cs_size = new_size; } void ecl_cs_overflow(void) { static const char *stack_overflow_msg = "\n;;;\n;;; Stack overflow.\n" ";;; Jumping to the outermost toplevel prompt\n" ";;;\n\n"; cl_env_ptr env = ecl_process_env(); cl_index margin = ecl_option_values[ECL_OPT_C_STACK_SAFETY_AREA]; cl_index size = env->cs_size; #ifdef ECL_DOWN_STACK if (env->cs_limit > env->cs_org - size) env->cs_limit -= margin; #else if (env->cs_limit < env->cs_org + size) env->cs_limit += margin; #endif else ecl_unrecoverable_error(env, stack_overflow_msg); if (env->cs_max_size == (cl_index)0 || env->cs_size < env->cs_max_size) si_serror(6, make_constant_base_string("Extend stack size"), @'ext::stack-overflow', @':size', ecl_make_fixnum(size), @':type', @'ext::c-stack'); else si_serror(6, ECL_NIL, @'ext::stack-overflow', @':size', ECL_NIL, @':type', @'ext::c-stack'); size += size/2; if (size > env->cs_max_size) size = env->cs_max_size; cs_set_size(env, size); } void ecl_cs_set_org(cl_env_ptr env) { /* Rough estimate. Not very safe. We assume that cl_boot() * is invoked from the main() routine of the program. */ env->cs_org = (char*)(&env); env->cs_barrier = env->cs_org; env->cs_max_size = 0; #if defined(HAVE_SYS_RESOURCE_H) && defined(RLIMIT_STACK) && !defined(NACL) { struct rlimit rl; cl_index size; getrlimit(RLIMIT_STACK, &rl); if (rl.rlim_cur != RLIM_INFINITY) { env->cs_max_size = rl.rlim_cur; size = rl.rlim_cur / 2; if (size > (cl_index)ecl_option_values[ECL_OPT_C_STACK_SIZE]) ecl_set_option(ECL_OPT_C_STACK_SIZE, size); #ifdef ECL_DOWN_STACK env->cs_barrier = env->cs_org - rl.rlim_cur - 1024; #else env->cs_barrier = env->cs_org + rl.rlim_cur + 1024; #endif } } #endif cs_set_size(env, ecl_option_values[ECL_OPT_C_STACK_SIZE]); } /********************* BINDING STACK ************************/ void ecl_bds_unwind_n(cl_env_ptr env, int n) { while (n--) ecl_bds_unwind1(env); } static void ecl_bds_set_size(cl_env_ptr env, cl_index new_size) { ecl_bds_ptr old_org = env->bds_org; cl_index limit = env->bds_top - old_org; if (new_size <= limit) { FEerror("Cannot shrink the binding stack below ~D.", 1, ecl_make_unsigned_integer(limit)); } else { cl_index margin = ecl_option_values[ECL_OPT_BIND_STACK_SAFETY_AREA]; ecl_bds_ptr org; env->bds_limit_size = new_size - 2*margin; org = ecl_alloc_atomic(new_size * sizeof(*org)); ecl_disable_interrupts_env(env); memcpy(org, old_org, (limit + 1) * sizeof(*org)); env->bds_top = org + limit; env->bds_org = org; env->bds_limit = org + (new_size - 2*margin); env->bds_size = new_size; ecl_enable_interrupts_env(env); ecl_dealloc(old_org); } } ecl_bds_ptr ecl_bds_overflow(void) { static const char *stack_overflow_msg = "\n;;;\n;;; Binding stack overflow.\n" ";;; Jumping to the outermost toplevel prompt\n" ";;;\n\n"; cl_env_ptr env = ecl_process_env(); cl_index margin = ecl_option_values[ECL_OPT_BIND_STACK_SAFETY_AREA]; cl_index size = env->bds_size; ecl_bds_ptr org = env->bds_org; ecl_bds_ptr last = org + size; if (env->bds_limit >= last) { ecl_unrecoverable_error(env, stack_overflow_msg); } env->bds_limit += margin; si_serror(6, make_constant_base_string("Extend stack size"), @'ext::stack-overflow', @':size', ecl_make_fixnum(size), @':type', @'ext::binding-stack'); ecl_bds_set_size(env, size + (size / 2)); return env->bds_top; } void ecl_bds_unwind(cl_env_ptr env, cl_index new_bds_top_index) { ecl_bds_ptr new_bds_top = new_bds_top_index + env->bds_org; ecl_bds_ptr bds = env->bds_top; for (; bds > new_bds_top; bds--) #ifdef ECL_THREADS ecl_bds_unwind1(env); #else bds->symbol->symbol.value = bds->value; #endif env->bds_top = new_bds_top; } cl_index ecl_progv(cl_env_ptr env, cl_object vars0, cl_object values0) { cl_object vars = vars0, values = values0; cl_index n = env->bds_top - env->bds_org; for (; LISTP(vars) && LISTP(values); vars = ECL_CONS_CDR(vars)) { if (Null(vars)) { return n; } else { cl_object var = ECL_CONS_CAR(vars); if (Null(values)) { ecl_bds_bind(env, var, OBJNULL); } else { ecl_bds_bind(env, var, ECL_CONS_CAR(values)); values = ECL_CONS_CDR(values); } } } FEerror("Wrong arguments to special form PROGV. Either~%" "~A~%or~%~A~%are not proper lists", 2, vars0, values0); } static ecl_bds_ptr get_bds_ptr(cl_object x) { if (ECL_FIXNUMP(x)) { cl_env_ptr env = ecl_process_env(); ecl_bds_ptr p = env->bds_org + ecl_fixnum(x); if (env->bds_org <= p && p <= env->bds_top) return(p); } FEerror("~S is an illegal bds index.", 1, x); } cl_object si_bds_top() { cl_env_ptr env = ecl_process_env(); @(return ecl_make_fixnum(env->bds_top - env->bds_org)) } cl_object si_bds_var(cl_object arg) { @(return get_bds_ptr(arg)->symbol) } cl_object si_bds_val(cl_object arg) { cl_object v = get_bds_ptr(arg)->value; @(return ((v == OBJNULL)? ECL_UNBOUND : v)) } #ifdef ecl_bds_bind # undef ecl_bds_bind # undef ecl_bds_push # undef ecl_bds_unwind1 #endif #ifdef ecl_bds_read # undef ecl_bds_read # undef ecl_bds_set # undef ecl_bds_ref #endif #ifdef ECL_THREADS static cl_index ecl_new_binding_index(cl_env_ptr env, cl_object symbol) { cl_object pool; cl_index new_index = symbol->symbol.binding; if (new_index == ECL_MISSING_SPECIAL_BINDING) { pool = ecl_atomic_pop(&cl_core.reused_indices); if (!Null(pool)) { new_index = ecl_fixnum(ECL_CONS_CAR(pool)); } else { new_index = ecl_atomic_index_incf(&cl_core.last_var_index); } symbol->symbol.binding = new_index; symbol->symbol.dynamic |= 1; } si_set_finalizer(symbol, ECL_T); return new_index; } static cl_object ecl_extend_bindings_array(cl_object vector) { cl_index new_size = cl_core.last_var_index * 1.25; cl_object new_vector = si_make_vector(ECL_T, ecl_make_fixnum(new_size), ECL_NIL, ECL_NIL, ECL_NIL, ECL_NIL); si_fill_array_with_elt(new_vector, ECL_NO_TL_BINDING, ecl_make_fixnum(0), ECL_NIL); ecl_copy_subarray(new_vector, 0, vector, 0, vector->vector.dim); return new_vector; } static cl_index invalid_or_too_large_binding_index(cl_env_ptr env, cl_object s) { cl_index index = s->symbol.binding; if (index == ECL_MISSING_SPECIAL_BINDING) { index = ecl_new_binding_index(env, s); } if (index >= env->thread_local_bindings_size) { cl_object vector = env->bindings_array; env->bindings_array = vector = ecl_extend_bindings_array(vector); env->thread_local_bindings_size = vector->vector.dim; env->thread_local_bindings = vector->vector.self.t; } return index; } #endif /* ECL_THREADS */ /* * The following routines must match the inline forms in stacks.h */ void ecl_bds_bind(cl_env_ptr env, cl_object s, cl_object v) { #ifdef ECL_THREADS cl_object *location; ecl_bds_ptr slot; cl_index index = s->symbol.binding; if (index >= env->thread_local_bindings_size) { index = invalid_or_too_large_binding_index(env,s); } location = env->thread_local_bindings + index; slot = ++env->bds_top; if (slot >= env->bds_limit) slot = ecl_bds_overflow(); slot->symbol = s; slot->value = *location; *location = v; #else ecl_bds_check(env); (++(env->bds_top))->symbol = s; env->bds_top->value = s->symbol.value; \ s->symbol.value = v; #endif } void ecl_bds_push(cl_env_ptr env, cl_object s) { #ifdef ECL_THREADS cl_object *location; ecl_bds_ptr slot; cl_index index = s->symbol.binding; if (index >= env->thread_local_bindings_size) { index = invalid_or_too_large_binding_index(env,s); } location = env->thread_local_bindings + index; slot = ++env->bds_top; if (slot >= env->bds_limit) slot = ecl_bds_overflow(); slot->symbol = s; slot->value = *location; if (*location == ECL_NO_TL_BINDING) *location = s->symbol.value; #else ecl_bds_check(env); (++(env->bds_top))->symbol = s; env->bds_top->value = s->symbol.value; #endif } void ecl_bds_unwind1(cl_env_ptr env) { ecl_bds_ptr slot = env->bds_top--; cl_object s = slot->symbol; #ifdef ECL_THREADS cl_object *location = env->thread_local_bindings + s->symbol.binding; *location = slot->value; #else s->symbol.value = slot->value; #endif } #ifdef ECL_THREADS cl_object ecl_bds_read(cl_env_ptr env, cl_object s) { cl_index index = s->symbol.binding; if (index < env->thread_local_bindings_size) { cl_object x = env->thread_local_bindings[index]; if (x != ECL_NO_TL_BINDING) return x; } return s->symbol.value; } cl_object * ecl_bds_ref(cl_env_ptr env, cl_object s) { cl_index index = s->symbol.binding; if (index < env->thread_local_bindings_size) { cl_object *location = env->thread_local_bindings + index; if (*location != ECL_NO_TL_BINDING) return location; } return &(s->symbol.value); } cl_object ecl_bds_set(cl_env_ptr env, cl_object s, cl_object value) { return *ecl_bds_ref(env, s) = value; } #endif /* ECL_THREADS */ /******************** INVOCATION STACK **********************/ static cl_object ihs_function_name(cl_object x) { cl_object y; switch (ecl_t_of(x)) { case t_symbol: return(x); case t_bclosure: x = x->bclosure.code; case t_bytecodes: y = x->bytecodes.name; if (Null(y)) return(@'lambda'); else return y; case t_cfun: case t_cfunfixed: return(x->cfun.name); default: return(ECL_NIL); } } static ecl_ihs_ptr get_ihs_ptr(cl_index n) { cl_env_ptr env = ecl_process_env(); ecl_ihs_ptr p = env->ihs_top; if (n > p->index) FEerror("~D is an illegal IHS index.", 1, ecl_make_fixnum(n)); while (n < p->index) p = p->next; return p; } cl_object si_ihs_top(void) { cl_env_ptr env = ecl_process_env(); @(return ecl_make_fixnum(env->ihs_top->index)) } cl_object si_ihs_prev(cl_object x) { @(return cl_1M(x)) } cl_object si_ihs_next(cl_object x) { @(return cl_1P(x)) } cl_object si_ihs_bds(cl_object arg) { @(return ecl_make_fixnum(get_ihs_ptr(ecl_to_size(arg))->bds)) } cl_object si_ihs_fun(cl_object arg) { @(return get_ihs_ptr(ecl_to_size(arg))->function) } cl_object si_ihs_env(cl_object arg) { @(return get_ihs_ptr(ecl_to_size(arg))->lex_env) } /********************** FRAME STACK *************************/ static void frs_set_size(cl_env_ptr env, cl_index new_size) { ecl_frame_ptr old_org = env->frs_org; cl_index limit = env->frs_top - old_org; if (new_size <= limit) { FEerror("Cannot shrink frame stack below ~D.", 1, ecl_make_unsigned_integer(limit)); } else { cl_index margin = ecl_option_values[ECL_OPT_FRAME_STACK_SAFETY_AREA]; ecl_frame_ptr org; env->frs_limit_size = new_size - 2*margin; org = ecl_alloc_atomic(new_size * sizeof(*org)); ecl_disable_interrupts_env(env); memcpy(org, old_org, (limit + 1) * sizeof(*org)); env->frs_top = org + limit; env->frs_org = org; env->frs_limit = org + (new_size - 2*margin); env->frs_size = new_size; ecl_enable_interrupts_env(env); ecl_dealloc(old_org); } } static void frs_overflow(void) /* used as condition in list.d */ { static const char *stack_overflow_msg = "\n;;;\n;;; Frame stack overflow.\n" ";;; Jumping to the outermost toplevel prompt\n" ";;;\n\n"; cl_env_ptr env = ecl_process_env(); cl_index margin = ecl_option_values[ECL_OPT_FRAME_STACK_SAFETY_AREA]; cl_index size = env->frs_size; ecl_frame_ptr org = env->frs_org; ecl_frame_ptr last = org + size; if (env->frs_limit >= last) { ecl_unrecoverable_error(env, stack_overflow_msg); } env->frs_limit += margin; si_serror(6, make_constant_base_string("Extend stack size"), @'ext::stack-overflow', @':size', ecl_make_fixnum(size), @':type', @'ext::frame-stack'); frs_set_size(env, size + size / 2); } ecl_frame_ptr _ecl_frs_push(register cl_env_ptr env, register cl_object val) { ecl_frame_ptr output = ++env->frs_top; if (output >= env->frs_limit) { frs_overflow(); output = env->frs_top; } output->frs_bds_top_index = env->bds_top - env->bds_org; output->frs_val = val; output->frs_ihs = env->ihs_top; output->frs_sp = ECL_STACK_INDEX(env); return output; } void ecl_unwind(cl_env_ptr env, ecl_frame_ptr fr) { env->nlj_fr = fr; while (env->frs_top != fr && env->frs_top->frs_val != ECL_PROTECT_TAG) --env->frs_top; env->ihs_top = env->frs_top->frs_ihs; ecl_bds_unwind(env, env->frs_top->frs_bds_top_index); ECL_STACK_SET_INDEX(env, env->frs_top->frs_sp); ecl_longjmp(env->frs_top->frs_jmpbuf, 1); /* never reached */ } ecl_frame_ptr frs_sch (cl_object frame_id) { cl_env_ptr env = ecl_process_env(); ecl_frame_ptr top; for (top = env->frs_top; top >= env->frs_org; top--) if (top->frs_val == frame_id) return(top); return(NULL); } static ecl_frame_ptr get_frame_ptr(cl_object x) { if (ECL_FIXNUMP(x)) { cl_env_ptr env = ecl_process_env(); ecl_frame_ptr p = env->frs_org + ecl_fixnum(x); if (env->frs_org <= p && p <= env->frs_top) return p; } FEerror("~S is an illegal frs index.", 1, x); } cl_object si_frs_top() { cl_env_ptr env = ecl_process_env(); @(return ecl_make_fixnum(env->frs_top - env->frs_org)) } cl_object si_frs_bds(cl_object arg) { @(return ecl_make_fixnum(get_frame_ptr(arg)->frs_bds_top_index)) } cl_object si_frs_tag(cl_object arg) { @(return get_frame_ptr(arg)->frs_val) } cl_object si_frs_ihs(cl_object arg) { @(return ecl_make_fixnum(get_frame_ptr(arg)->frs_ihs->index)) } cl_object si_sch_frs_base(cl_object fr, cl_object ihs) { cl_env_ptr env = ecl_process_env(); ecl_frame_ptr x; cl_index y = ecl_to_size(ihs); for (x = get_frame_ptr(fr); x <= env->frs_top && x->frs_ihs->index < y; x++); @(return ((x > env->frs_top) ? ECL_NIL : ecl_make_fixnum(x - env->frs_org))) } /********************* INITIALIZATION ***********************/ cl_object si_set_limit(cl_object type, cl_object limit) { cl_env_ptr env = ecl_process_env(); cl_index margin; if (type == @'ext::frame-stack') { cl_index the_size = ecl_to_size(limit); margin = ecl_option_values[ECL_OPT_FRAME_STACK_SAFETY_AREA]; frs_set_size(env, the_size + 2*margin); } else if (type == @'ext::binding-stack') { cl_index the_size = ecl_to_size(limit); margin = ecl_option_values[ECL_OPT_BIND_STACK_SAFETY_AREA]; ecl_bds_set_size(env, the_size + 2*margin); } else if (type == @'ext::c-stack') { cl_index the_size = ecl_to_size(limit); margin = ecl_option_values[ECL_OPT_C_STACK_SAFETY_AREA]; cs_set_size(env, the_size + 2*margin); } else if (type == @'ext::lisp-stack') { cl_index the_size = ecl_to_size(limit); ecl_stack_set_size(env, the_size); } else { /* * size_t can be larger than cl_index, and ecl_to_size() * creates a fixnum which is too small for size_t on 32-bit. */ size_t the_size = (size_t)ecl_to_ulong(limit); _ecl_set_max_heap_size(the_size); } return si_get_limit(type); } cl_object si_get_limit(cl_object type) { cl_env_ptr env = ecl_process_env(); cl_index output; if (type == @'ext::frame-stack') output = env->frs_limit_size; else if (type == @'ext::binding-stack') output = env->bds_limit_size; else if (type == @'ext::c-stack') output = env->cs_limit_size; else if (type == @'ext::lisp-stack') output = env->stack_limit_size; else /* size_t can be larger than cl_index */ @(return ecl_make_unsigned_integer(cl_core.max_heap_size)); @(return ecl_make_unsigned_integer(output)) } cl_object si_reset_margin(cl_object type) { cl_env_ptr env = ecl_process_env(); if (type == @'ext::frame-stack') frs_set_size(env, env->frs_size); else if (type == @'ext::binding-stack') ecl_bds_set_size(env, env->bds_size); else if (type == @'ext::c-stack') cs_set_size(env, env->cs_size); else return ECL_NIL; return ECL_T; } void init_stacks(cl_env_ptr env) { static struct ecl_ihs_frame ihs_org = { NULL, NULL, NULL, 0}; cl_index size, margin; margin = ecl_option_values[ECL_OPT_FRAME_STACK_SAFETY_AREA]; size = ecl_option_values[ECL_OPT_FRAME_STACK_SIZE] + 2 * margin; env->frs_size = size; env->frs_org = (ecl_frame_ptr)ecl_alloc_atomic(size * sizeof(*env->frs_org)); env->frs_top = env->frs_org-1; env->frs_limit = &env->frs_org[size - 2*margin]; margin = ecl_option_values[ECL_OPT_BIND_STACK_SAFETY_AREA]; size = ecl_option_values[ECL_OPT_BIND_STACK_SIZE] + 2 * margin; env->bds_size = size; env->bds_org = (ecl_bds_ptr)ecl_alloc_atomic(size * sizeof(*env->bds_org)); env->bds_top = env->bds_org-1; env->bds_limit = &env->bds_org[size - 2*margin]; env->ihs_top = &ihs_org; ihs_org.function = ECL_NIL; ihs_org.lex_env = ECL_NIL; ihs_org.index = 0; } ecl-16.1.2/src/c/string.d000066400000000000000000000660461266352375300150600ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* string.d -- String routines. */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under thep terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #include #include #include typedef ecl_character (*ecl_casefun)(ecl_character, bool *); static cl_object do_make_base_string(cl_index s, ecl_base_char code) { cl_object x = ecl_alloc_simple_base_string(s); cl_index i; for (i = 0; i < s; i++) x->base_string.self[i] = code; return x; } #ifdef ECL_UNICODE static cl_object do_make_string(cl_index s, ecl_character code) { cl_object x = ecl_alloc_simple_extended_string(s); cl_index i; for (i = 0; i < s; i++) x->string.self[i] = code; return x; } #else #define do_make_string do_make_base_string #endif @(defun make_string (size &key (initial_element ECL_CODE_CHAR(' ')) (element_type @'character')) cl_index s; cl_object x; @ s = ecl_to_index(size); /* INV: ecl_[base_]char_code() checks the type of initial_element() */ if (element_type == @'base-char' || element_type == @'standard-char') { int code = ecl_base_char_code(initial_element); x = do_make_base_string(s, code); } else if (element_type == @'character') { cl_index code = ecl_char_code(initial_element); x = do_make_string(s, code); } else if (_ecl_funcall3(@'subtypep', element_type, @'base-char') == ECL_T) { int code = ecl_base_char_code(initial_element); x = do_make_base_string(s, code); } else if (_ecl_funcall3(@'subtypep', element_type, @'character') == ECL_T) { cl_index code = ecl_char_code(initial_element); x = do_make_string(s, code); } else { FEerror("The type ~S is not a valid string char type.", 1, element_type); } @(return x) @) /* Make a string of a certain size, with some eading zeros to keep C happy. The string must be adjustable, to allow further growth. (See unixfsys.c for its use). */ cl_object ecl_alloc_adjustable_base_string(cl_index l) { cl_object output = ecl_alloc_object(t_base_string); output->base_string.self = (ecl_base_char *)ecl_alloc_atomic(l+1); output->base_string.self[l] = 0; output->base_string.flags = ECL_FLAG_HAS_FILL_POINTER | ECL_FLAG_ADJUSTABLE; output->base_string.elttype = ecl_aet_bc; output->base_string.displaced = ECL_NIL; output->base_string.dim = l; output->base_string.fillp = 0; return output; } #ifdef ECL_UNICODE cl_object ecl_alloc_adjustable_extended_string(cl_index l) { cl_index bytes = sizeof(ecl_character) * l; cl_object output = ecl_alloc_object(t_string); output->string.self = (ecl_character *)ecl_alloc_atomic(bytes); output->string.flags = ECL_FLAG_HAS_FILL_POINTER | ECL_FLAG_ADJUSTABLE; output->string.elttype = ecl_aet_ch; output->string.displaced = ECL_NIL; output->string.dim = l; output->string.fillp = 0; return output; } #endif /* Make_simple_base_string(s) makes a simple-base string from C string s. */ cl_object ecl_make_simple_base_string(char *s, cl_fixnum l) { cl_object x = ecl_alloc_object(t_base_string); x->base_string.elttype = ecl_aet_bc; x->base_string.flags = 0; /* no fill pointer, no adjustable */ x->base_string.displaced = ECL_NIL; if (l < 0) l = strlen(s); x->base_string.dim = (x->base_string.fillp = l); x->base_string.self = (ecl_base_char *)s; return x; } cl_object make_base_string_copy(const char *s) { cl_object x; cl_index l = strlen(s); x = ecl_alloc_simple_base_string(l); memcpy(x->base_string.self, s, l); return x; } cl_object ecl_cstring_to_base_string_or_nil(const char *s) { if (s == NULL) return ECL_NIL; else return make_base_string_copy(s); } bool ecl_fits_in_base_string(cl_object s) { switch (ecl_t_of(s)) { #ifdef ECL_UNICODE case t_string: { cl_index i; for (i = 0; i < s->string.fillp; i++) { if (!ECL_BASE_CHAR_CODE_P(s->string.self[i])) return 0; } return 1; } #endif case t_base_string: return 1; default: FEwrong_type_nth_arg(@[si::copy-to-simple-base-string],1,s,@[string]); } } cl_object si_copy_to_simple_base_string(cl_object x) { cl_object y; AGAIN: switch(ecl_t_of(x)) { case t_symbol: x = x->symbol.name; goto AGAIN; case t_character: x = cl_string(x); goto AGAIN; #ifdef ECL_UNICODE case t_string: { cl_index index, length = x->string.fillp; y = ecl_alloc_simple_base_string(length); for (index=0; index < length; index++) { ecl_character c = x->string.self[index]; if (!ECL_BASE_CHAR_CODE_P(c)) FEerror("Cannot coerce string ~A to a base-string", 1, x); y->base_string.self[index] = c; } break; } #endif case t_base_string: { cl_index length = x->base_string.fillp; y = ecl_alloc_simple_base_string(length); memcpy(y->base_string.self, x->base_string.self, length); break; } case t_list: if (Null(x)) { x = ECL_NIL_SYMBOL->symbol.name; goto AGAIN; } default: FEwrong_type_nth_arg(@[si::copy-to-simple-base-string],1,x,@[string]); } @(return y) } cl_object cl_string(cl_object x) { switch (ecl_t_of(x)) { case t_symbol: x = x->symbol.name; break; case t_character: { cl_object y; ecl_character c = ECL_CHAR_CODE(x); #ifdef ECL_UNICODE if (ECL_BASE_CHAR_CODE_P(c)) { y = ecl_alloc_simple_base_string(1); y->base_string.self[0] = c; x = y; } else { y = ecl_alloc_simple_extended_string(1); y->string.self[0] = c; x = y; } #else y = ecl_alloc_simple_base_string(1); y->base_string.self[0] = c; x = y; break; #endif } #ifdef ECL_UNICODE case t_string: #endif case t_base_string: break; case t_list: if (Null(x)) { x = ECL_NIL_SYMBOL->symbol.name; break; } default: FEwrong_type_nth_arg(@[string],1,x,@[string]); } @(return x) } #ifdef ECL_UNICODE cl_object si_coerce_to_base_string(cl_object x) { if (!ECL_BASE_STRING_P(x)) { x = si_copy_to_simple_base_string(x); } @(return x) } cl_object si_coerce_to_extended_string(cl_object x) { cl_object y; AGAIN: switch (ecl_t_of(x)) { case t_symbol: x = x->symbol.name; goto AGAIN; case t_character: y = ecl_alloc_simple_extended_string(1); y->string.self[0] = ECL_CHAR_CODE(x); break; case t_base_string: { cl_index index, len = x->base_string.dim; y = ecl_alloc_simple_extended_string(x->base_string.fillp); for(index=0; index < len; index++) { y->string.self[index] = x->base_string.self[index]; } y->string.fillp = x->base_string.fillp; } case t_string: y = x; break; case t_list: if (Null(x)) { x = ECL_NIL_SYMBOL->symbol.name; goto AGAIN; } default: FEwrong_type_nth_arg(@[si::coerce-to-extended-string],1,x,@[string]); } @(return y) } #endif cl_object cl_char(cl_object object, cl_object index) { cl_index position = ecl_to_index(index); @(return ECL_CODE_CHAR(ecl_char(object, position))) } ecl_character ecl_char(cl_object object, cl_index index) { /* CHAR bypasses fill pointers when accessing strings */ switch(ecl_t_of(object)) { #ifdef ECL_UNICODE case t_string: if (index >= object->string.dim) FEtype_error_index(object, index); return object->string.self[index]; #endif case t_base_string: if (index >= object->base_string.dim) FEtype_error_index(object, index); return object->base_string.self[index]; default: FEwrong_type_nth_arg(@[char],1,object,@[string]); } } cl_object si_char_set(cl_object object, cl_object index, cl_object value) { cl_index position = ecl_to_index(index); cl_index c = ecl_char_code(value); ecl_char_set(object, position, c); @(return value) } ecl_character ecl_char_set(cl_object object, cl_index index, ecl_character value) { /* CHAR bypasses fill pointers when accessing strings */ switch(ecl_t_of(object)) { #ifdef ECL_UNICODE case t_string: if (index >= object->string.dim) FEtype_error_index(object, index); return object->string.self[index] = value; #endif case t_base_string: if (index >= object->base_string.dim) FEtype_error_index(object, index); return object->base_string.self[index] = value; default: FEwrong_type_nth_arg(@[si::char-set],1,object,@[string]); } } #ifdef ECL_UNICODE static int compare_strings(cl_object string1, cl_index s1, cl_index e1, cl_object string2, cl_index s2, cl_index e2, int case_sensitive, cl_index *m) { cl_index c1, c2; for (; s1 < e1; s1++, s2++) { if (s2 >= e2) { /* s1 is longer than s2, therefore s2 < s1 */ *m = s1; return +1; } c1 = ecl_char(string1, s1); c2 = ecl_char(string2, s2); if (!case_sensitive) { c1 = ecl_char_upcase(c1); c2 = ecl_char_upcase(c2); } if (c1 < c2) { *m = s1; return -1; } else if (c1 > c2) { *m = s1; return +1; } } *m = s1; if (s2 >= e2) { return 0; } else { /* s1 is shorter than s2, hence s1 < s2 */ return -1; } } #endif static int compare_base(unsigned char *s1, cl_index l1, unsigned char *s2, cl_index l2, int case_sensitive, cl_index *m) { cl_index l, c1, c2; for (l = 0; l < l1; l++, s1++, s2++) { if (l == l2) { /* s1 is longer than s2, therefore s2 < s1 */ *m = l; return +1; } c1 = *s1; c2 = *s2; if (!case_sensitive) { c1 = ecl_char_upcase(c1); c2 = ecl_char_upcase(c2); } if (c1 < c2) { *m = l; return -1; } else if (c1 > c2) { *m = l; return +1; } } *m = l; if (l1 == l2) return 0; else { /* s1 is shorter than s2, hence s1 < s2 */ return -1; } } @(defun string= (string1 string2 &key (start1 ecl_make_fixnum(0)) end1 (start2 ecl_make_fixnum(0)) end2) cl_index_pair p; cl_index s1, e1, s2, e2; @ { string1 = cl_string(string1); string2 = cl_string(string2); p = ecl_vector_start_end(@[string=], string1, start1, end1); s1 = p.start; e1 = p.end; p = ecl_vector_start_end(@[string=], string2, start2, end2); s2 = p.start; e2 = p.end; if (e1 - s1 != e2 - s2) @(return ECL_NIL); #ifdef ECL_UNICODE if (string1->string.t == t_string) { if (string2->string.t == t_string) { while (s1 < e1) if (string1->string.self[s1++] != string2->string.self[s2++]) @(return ECL_NIL); @(return ECL_T); } else { while (s1 < e1) if (string1->string.self[s1++] != string2->base_string.self[s2++]) @(return ECL_NIL); @(return ECL_T); } } else { if (string2->string.t == t_string) { while (s1 < e1) if (string1->base_string.self[s1++] != string2->string.self[s2++]) @(return ECL_NIL); @(return ECL_T); } else { while (s1 < e1) if (string1->base_string.self[s1++] != string2->base_string.self[s2++]) @(return ECL_NIL); @(return ECL_T); } } #else while (s1 < e1) if (string1->base_string.self[s1++] != string2->base_string.self[s2++]) @(return ECL_NIL); #endif @(return ECL_T); } @) /* This correponds to string= (just the string equality). */ bool ecl_string_eq(cl_object x, cl_object y) { cl_index i, j; i = x->base_string.fillp; j = y->base_string.fillp; if (i != j) return 0; #ifdef ECL_UNICODE switch(ecl_t_of(x)) { case t_string: switch(ecl_t_of(y)) { case t_string: return memcmp(x->string.self, y->string.self, i * sizeof *x->string.self) == 0; case t_base_string: { cl_index index; for(index=0; indexstring.self[index] != y->base_string.self[index]) return 0; return 1; } default: FEwrong_type_nth_arg(@[string=],2,y,@[string]); } break; case t_base_string: switch(ecl_t_of(y)) { case t_string: return ecl_string_eq(y, x); case t_base_string: return memcmp(x->base_string.self, y->base_string.self, i) == 0; default: FEwrong_type_nth_arg(@[string=],2,y,@[string]); } break; default: FEwrong_type_nth_arg(@[string=],2,x,@[string]); } #else return memcmp(x->base_string.self, y->base_string.self, i) == 0; #endif } @(defun string_equal (string1 string2 &key (start1 ecl_make_fixnum(0)) end1 (start2 ecl_make_fixnum(0)) end2) cl_index s1, e1, s2, e2; cl_index_pair p; int output; @ string1 = cl_string(string1); string2 = cl_string(string2); p = ecl_vector_start_end(@[string=], string1, start1, end1); s1 = p.start; e1 = p.end; p = ecl_vector_start_end(@[string=], string2, start2, end2); s2 = p.start; e2 = p.end; if (e1 - s1 != e2 - s2) @(return ECL_NIL); #ifdef ECL_UNICODE if (ECL_EXTENDED_STRING_P(string1) || ECL_EXTENDED_STRING_P(string2)) { output = compare_strings(string1, s1, e1, string2, s2, e2, 0, &e1); } else #endif output = compare_base(string1->base_string.self + s1, e1 - s1, string2->base_string.self + s2, e2 - s2, 0, &e1); @(return ((output == 0)? ECL_T : ECL_NIL)) @) static cl_object string_compare(cl_narg narg, int sign1, int sign2, int case_sensitive, ecl_va_list ARGS) { cl_object string1 = ecl_va_arg(ARGS); cl_object string2 = ecl_va_arg(ARGS); cl_index s1, e1, s2, e2; cl_index_pair p; int output; cl_object result; cl_object KEYS[4]; #define start1 KEY_VARS[0] #define end1 KEY_VARS[1] #define start2 KEY_VARS[2] #define end2 KEY_VARS[3] #define start1p KEY_VARS[4] #define start2p KEY_VARS[6] cl_object KEY_VARS[8]; if (narg < 2) FEwrong_num_arguments_anonym(); KEYS[0]=@':start1'; KEYS[1]=@':end1'; KEYS[2]=@':start2'; KEYS[3]=@':end2'; cl_parse_key(ARGS, 4, KEYS, KEY_VARS, NULL, FALSE); string1 = cl_string(string1); string2 = cl_string(string2); if (start1p == ECL_NIL) start1 = ecl_make_fixnum(0); if (start2p == ECL_NIL) start2 = ecl_make_fixnum(0); p = ecl_vector_start_end(@[string=], string1, start1, end1); s1 = p.start; e1 = p.end; p = ecl_vector_start_end(@[string=], string2, start2, end2); s2 = p.start; e2 = p.end; #ifdef ECL_UNICODE if (ECL_EXTENDED_STRING_P(string1) || ECL_EXTENDED_STRING_P(string2)) { output = compare_strings(string1, s1, e1, string2, s2, e2, case_sensitive, &e1); } else #endif { output = compare_base(string1->base_string.self + s1, e1 - s1, string2->base_string.self + s2, e2 - s2, case_sensitive, &e1); e1 += s1; } if (output == sign1 || output == sign2) { result = ecl_make_fixnum(e1); } else { result = ECL_NIL; } @(return result) #undef start1p #undef start2p #undef start1 #undef end1 #undef start2 #undef end2 } @(defun string< (&rest args) @ return string_compare(narg, -1, -1, 1, args); @) @(defun string> (&rest args) @ return string_compare(narg, +1, +1, 1, args); @) @(defun string<= (&rest args) @ return string_compare(narg, -1, 0, 1, args); @) @(defun string>= (&rest args) @ return string_compare(narg, 0, +1, 1, args); @) @(defun string/= (&rest args) @ return string_compare(narg, -1, +1, 1, args); @) @(defun string-lessp (&rest args) @ return string_compare(narg, -1, -1, 0, args); @) @(defun string-greaterp (&rest args) @ return string_compare(narg, +1, +1, 0, args); @) @(defun string-not-greaterp (&rest args) @ return string_compare(narg, -1, 0, 0, args); @) @(defun string-not-lessp (&rest args) @ return string_compare(narg, 0, +1, 0, args); @) @(defun string-not-equal (&rest args) @ return string_compare(narg, -1, +1, 0, args); @) bool ecl_member_char(ecl_character c, cl_object char_bag) { cl_index i, f; switch (ecl_t_of(char_bag)) { case t_list: loop_for_in(char_bag) { cl_object other = CAR(char_bag); if (ECL_CHARACTERP(other) && c == ECL_CHAR_CODE(other)) return(TRUE); } end_loop_for_in; return(FALSE); case t_vector: for (i = 0, f = char_bag->vector.fillp; i < f; i++) { cl_object other = char_bag->vector.self.t[i]; if (ECL_CHARACTERP(other) && c == ECL_CHAR_CODE(other)) return(TRUE); } return(FALSE); #ifdef ECL_UNICODE case t_string: for (i = 0, f = char_bag->string.fillp; i < f; i++) { if (c == char_bag->string.self[i]) return(TRUE); } return(FALSE); #endif case t_base_string: for (i = 0, f = char_bag->base_string.fillp; i < f; i++) { if (c == char_bag->base_string.self[i]) return(TRUE); } return(FALSE); case t_bitvector: return(FALSE); default: FEwrong_type_nth_arg(@[member],2,char_bag,@[sequence]); } } static cl_object string_trim0(bool left_trim, bool right_trim, cl_object char_bag, cl_object strng) { cl_index i, j; strng = cl_string(strng); i = 0; j = ecl_length(strng); if (left_trim) { for (; i < j; i++) { cl_index c = ecl_char(strng, i); if (!ecl_member_char(c, char_bag)) break; } } if (right_trim) { for (; j > i; j--) { cl_index c = ecl_char(strng, j-1); if (!ecl_member_char(c, char_bag)) { break; } } } return cl_subseq(3, strng, ecl_make_fixnum(i), ecl_make_fixnum(j)); } cl_object cl_string_trim(cl_object char_bag, cl_object strng) { return string_trim0(TRUE, TRUE, char_bag, strng); } cl_object cl_string_left_trim(cl_object char_bag, cl_object strng) { return string_trim0(TRUE, FALSE, char_bag, strng); } cl_object cl_string_right_trim(cl_object char_bag, cl_object strng) { return string_trim0(FALSE, TRUE, char_bag, strng); } static cl_object string_case(cl_narg narg, cl_object fun, ecl_casefun casefun, ecl_va_list ARGS) { cl_object strng = ecl_va_arg(ARGS); cl_index_pair p; cl_index i; bool b; cl_object KEYS[2]; #define kstart KEY_VARS[0] #define kend KEY_VARS[1] #define kstartp KEY_VARS[2] cl_object KEY_VARS[4]; if (narg < 1) FEwrong_num_arguments_anonym(); KEYS[0]=@':start'; KEYS[1]=@':end'; cl_parse_key(ARGS, 2, KEYS, KEY_VARS, NULL, FALSE); strng = cl_string(strng); strng = cl_copy_seq(strng); if (kstartp == ECL_NIL) kstart = ecl_make_fixnum(0); p = ecl_vector_start_end(fun, strng, kstart, kend); b = TRUE; #ifdef ECL_UNICODE if (ECL_EXTENDED_STRING_P(strng)) { for (i = p.start; i < p.end; i++) strng->string.self[i] = (*casefun)(strng->string.self[i], &b); } else #endif for (i = p.start; i < p.end; i++) strng->base_string.self[i] = (*casefun)(strng->base_string.self[i], &b); @(return strng) #undef kstartp #undef kstart #undef kend } static ecl_character char_upcase(ecl_character c, bool *bp) { return ecl_char_upcase(c); } @(defun string-upcase (&rest args) @ return string_case(narg, @[string-upcase], char_upcase, args); @) static ecl_character char_downcase(ecl_character c, bool *bp) { return ecl_char_downcase(c); } @(defun string-downcase (&rest args) @ return string_case(narg, @[string-downcase], char_downcase, args); @) static ecl_character char_capitalize(ecl_character c, bool *bp) { if (ecl_lower_case_p(c)) { if (*bp) c = ecl_char_upcase(c); *bp = FALSE; } else if (ecl_upper_case_p(c)) { if (!*bp) c = ecl_char_downcase(c); *bp = FALSE; } else { *bp = !ecl_alphanumericp(c); } return c; } @(defun string-capitalize (&rest args) @ return string_case(narg, @[string-capitalize], char_capitalize, args); @) static cl_object nstring_case(cl_narg narg, cl_object fun, ecl_casefun casefun, ecl_va_list ARGS) { cl_object strng = ecl_va_arg(ARGS); cl_index_pair p; cl_index i; bool b; cl_object KEYS[2]; #define kstart KEY_VARS[0] #define kend KEY_VARS[1] #define kstartp KEY_VARS[2] cl_object KEY_VARS[4]; if (narg < 1) FEwrong_num_arguments_anonym(); KEYS[0]=@':start'; KEYS[1]=@':end'; cl_parse_key(ARGS, 2, KEYS, KEY_VARS, NULL, FALSE); if (ecl_unlikely(!ECL_STRINGP(strng))) FEwrong_type_nth_arg(fun, 1, strng, @[string]); if (kstartp == ECL_NIL) kstart = ecl_make_fixnum(0); p = ecl_vector_start_end(fun, strng, kstart, kend); b = TRUE; #ifdef ECL_UNICODE if (ECL_EXTENDED_STRING_P(strng)) { for (i = p.start; i < p.end; i++) strng->string.self[i] = (*casefun)(strng->string.self[i], &b); } else #endif for (i = p.start; i < p.end; i++) strng->base_string.self[i] = (*casefun)(strng->base_string.self[i], &b); @(return strng) #undef kstartp #undef kstart #undef kend } @(defun nstring-upcase (&rest args) @ return nstring_case(narg, @'nstring-upcase', char_upcase, args); @) @(defun nstring-downcase (&rest args) @ return nstring_case(narg, @'nstring-downcase', char_downcase, args); @) @(defun nstring-capitalize (&rest args) @ return nstring_case(narg, @'nstring-capitalize', char_capitalize, args); @) @(defun si::base-string-concatenate (&rest args) cl_index l; int i; cl_object output; @ /* Compute final size and store NONEMPTY coerced strings. */ for (i = 0, l = 0; i < narg; i++) { cl_object s = si_coerce_to_base_string(ecl_va_arg(args)); if (s->base_string.fillp) { ECL_STACK_PUSH(the_env, s); l += s->base_string.fillp; } } /* Do actual copying by recovering those strings */ output = ecl_alloc_simple_base_string(l); while (l) { cl_object s = ECL_STACK_POP_UNSAFE(the_env); size_t bytes = s->base_string.fillp; l -= bytes; memcpy(output->base_string.self + l, s->base_string.self, bytes); } @(return output); @) ecl-16.1.2/src/c/structure.d000066400000000000000000000106441266352375300156030ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* structure.c -- Structure interface. */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #include #include /******************************* ------- ******************************/ static bool structure_subtypep(cl_object x, cl_object y) { if (ECL_CLASS_NAME(x) == y) { return TRUE; } else { cl_object superiors = ECL_CLASS_SUPERIORS(x); loop_for_on_unsafe(superiors) { if (structure_subtypep(ECL_CONS_CAR(superiors), y)) return TRUE; } end_loop_for_on_unsafe(superiors); return FALSE; } } cl_object si_structure_subtype_p(cl_object x, cl_object y) { @(return ((ecl_t_of(x) == T_STRUCTURE && structure_subtypep(ECL_STRUCT_TYPE(x), y)) ? ECL_T : ECL_NIL)) } @(defun si::make-structure (type &rest args) cl_object x; int i; @ x = ecl_alloc_object(T_STRUCTURE); ECL_STRUCT_TYPE(x) = type; ECL_STRUCT_SLOTS(x) = NULL; /* for GC sake */ ECL_STRUCT_LENGTH(x) = --narg; ECL_STRUCT_SLOTS(x) = (cl_object *)ecl_alloc_align(sizeof(cl_object)*narg, sizeof(cl_object)); x->instance.sig = ECL_UNBOUND; if (narg >= ECL_SLOTS_LIMIT) FEerror("Limit on structure size exceeded: ~S slots requested.", 1, ecl_make_fixnum(narg)); for (i = 0; i < narg; i++) ECL_STRUCT_SLOT(x, i) = ecl_va_arg(args); @(return x) @) #define ecl_copy_structure si_copy_instance cl_object cl_copy_structure(cl_object s) { switch (ecl_t_of(s)) { case t_instance: s = ecl_copy_structure(s); break; case t_list: #ifdef ECL_UNICODE case t_string: #endif case t_base_string: case t_bitvector: case t_vector: s = cl_copy_seq(s); break; default: FEwrong_type_only_arg(@[copy-structure], s, @[structure]); } @(return s) } /* Kept only for compatibility. One should use class-of or type-of. */ cl_object si_structure_name(cl_object s) { if (ecl_unlikely(Null(si_structurep(s)))) FEwrong_type_only_arg(@[si::structure-name], s, @[structure]); @(return ECL_STRUCT_NAME(s)) } cl_object si_structure_ref(cl_object x, cl_object type, cl_object index) { if (ecl_unlikely(ecl_t_of(x) != T_STRUCTURE || !structure_subtypep(ECL_STRUCT_TYPE(x), type))) FEwrong_type_nth_arg(@[si::structure-ref], 1, x, type); @(return ECL_STRUCT_SLOT(x, ecl_fixnum(index))) } cl_object ecl_structure_ref(cl_object x, cl_object type, int n) { if (ecl_unlikely(ecl_t_of(x) != T_STRUCTURE || !structure_subtypep(ECL_STRUCT_TYPE(x), type))) FEwrong_type_nth_arg(@[si::structure-ref], 1, x, type); return(ECL_STRUCT_SLOT(x, n)); } cl_object si_structure_set(cl_object x, cl_object type, cl_object index, cl_object val) { if (ecl_unlikely(ecl_t_of(x) != T_STRUCTURE || !structure_subtypep(ECL_STRUCT_TYPE(x), type))) FEwrong_type_nth_arg(@[si::structure-set], 1, x, type); ECL_STRUCT_SLOT(x, ecl_fixnum(index)) = val; @(return val) } cl_object ecl_structure_set(cl_object x, cl_object type, int n, cl_object v) { if (ecl_unlikely(ecl_t_of(x) != T_STRUCTURE || !structure_subtypep(ECL_STRUCT_TYPE(x), type))) FEwrong_type_nth_arg(@[si::structure-set], 1, x, type); ECL_STRUCT_SLOT(x, n) = v; return(v); } cl_object si_structurep(cl_object s) { if (ECL_INSTANCEP(s) && structure_subtypep(ECL_CLASS_OF(s), @'structure-object')) return ECL_T; else return ECL_NIL; } ecl-16.1.2/src/c/symbol.d000066400000000000000000000333511266352375300150500ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* symbol.d -- Symbols. */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #include #include /******************************* ------- ******************************/ /* FIXME! CURRENTLY SYMBOLS ARE RESTRICTED TO HAVE NON-UNICODE NAMES */ cl_object ecl_symbol_package(cl_object s) { if (Null(s)) return ECL_NIL_SYMBOL->symbol.hpack; if (ecl_t_of(s) == t_symbol) return s->symbol.hpack; FEwrong_type_nth_arg(@[symbol-package], 1, s, @[symbol]); } int ecl_symbol_type(cl_object s) { if (Null(s)) return ECL_NIL_SYMBOL->symbol.stype; if (ecl_t_of(s) == t_symbol) return s->symbol.stype; FEwrong_type_nth_arg(@[symbol-name], 1, s, @[symbol]); } void ecl_symbol_type_set(cl_object s, int type) { if (Null(s)) { ECL_NIL_SYMBOL->symbol.stype = type; return; } if (ecl_t_of(s) == t_symbol) { s->symbol.stype = type; return; } FEwrong_type_nth_arg(@[symbol-name], 1, s, @[symbol]); } cl_object ecl_symbol_name(cl_object s) { if (Null(s)) { return ECL_NIL_SYMBOL->symbol.name; } if (ecl_t_of(s) == t_symbol) { return s->symbol.name; } FEwrong_type_nth_arg(@[symbol-name], 1, s, @[symbol]); } static cl_object * ecl_symbol_plist(cl_object s) { if (Null(s)) { return &ECL_NIL_SYMBOL->symbol.plist; } if (ecl_t_of(s) == t_symbol) { return &s->symbol.plist; } FEwrong_type_nth_arg(@[symbol-plist], 1, s, @[symbol]); } /**********************************************************************/ static void FEtype_error_plist(cl_object x) /*__attribute__((noreturn))*/; cl_object cl_make_symbol(cl_object str) { cl_object x; /* INV: In several places it is assumed that we copy the string! */ switch (ecl_t_of(str)) { #ifdef ECL_UNICODE case t_string: if (!ecl_fits_in_base_string(str)) { str = cl_copy_seq(str); } else { str = si_copy_to_simple_base_string(str); } break; #endif case t_base_string: str = si_copy_to_simple_base_string(str); break; default: FEwrong_type_nth_arg(@[make-symbol],1,str,@[string]); } x = ecl_alloc_object(t_symbol); x->symbol.name = str; x->symbol.dynamic = 0; #ifdef ECL_THREADS x->symbol.binding = ECL_MISSING_SPECIAL_BINDING; #endif /* */ ECL_SET(x,OBJNULL); ECL_SYM_FUN(x) = ECL_NIL; x->symbol.plist = ECL_NIL; x->symbol.hpack = ECL_NIL; x->symbol.stype = ecl_stp_ordinary; @(return x) } /* ecl_make_keyword(s) makes a keyword from C string s. */ cl_object ecl_make_keyword(const char *s) { cl_object x = _ecl_intern(s, cl_core.keyword_package); /* cl_export(x, keyword_package); this is implicit in ecl_intern() */ return x; } cl_object ecl_make_symbol(const char *s, const char *p) { cl_object package = ecl_find_package(p); cl_object x = _ecl_intern(s, package); /* cl_export(x, keyword_package); this is implicit in ecl_intern() */ return x; } cl_object ecl_symbol_value(cl_object s) { if (Null(s)) { return s; } else { /* FIXME: Should we check symbol type? */ const cl_env_ptr the_env = ecl_process_env(); cl_object value = ECL_SYM_VAL(the_env, s); unlikely_if (value == OBJNULL) FEunbound_variable(s); return value; } } static void FEtype_error_plist(cl_object x) { cl_error(9, @'simple-type-error', @':format-control', make_constant_base_string("Not a valid property list ~D"), @':format-arguments', cl_list(1, x), @':expected-type', @'si::property-list', @':datum', x); } cl_object ecl_getf(cl_object place, cl_object indicator, cl_object deflt) { cl_object l; #ifdef ECL_SAFE assert_type_proper_list(place); #endif for (l = place; CONSP(l); ) { cl_object cdr_l = ECL_CONS_CDR(l); if (!CONSP(cdr_l)) break; if (ECL_CONS_CAR(l) == indicator) return ECL_CONS_CAR(cdr_l); l = ECL_CONS_CDR(cdr_l); } if (l != ECL_NIL) FEtype_error_plist(place); return(deflt); } cl_object ecl_get(cl_object s, cl_object p, cl_object d) { return ecl_getf(*ecl_symbol_plist(s), p, d); } /* (SI:PUT-F plist value indicator) returns the new property list with value for property indicator. It will be used in SETF for GETF. */ cl_object si_put_f(cl_object place, cl_object value, cl_object indicator) { cl_object l; #ifdef ECL_SAFE assert_type_proper_list(place); #endif /* This loop guarantees finishing for circular lists */ for (l = place; CONSP(l); ) { cl_object cdr_l = ECL_CONS_CDR(l); if (!CONSP(cdr_l)) break; if (ECL_CONS_CAR(l) == indicator) { ECL_RPLACA(cdr_l, value); @(return place); } l = ECL_CONS_CDR(cdr_l); } if (l != ECL_NIL) FEtype_error_plist(place); place = CONS(value, place); @(return CONS(indicator, place)); } /* Remf(p, i) removes property i from the property list pointed by p, which is a pointer to an cl_object. The returned value of remf(p, i) is: TRUE if the property existed FALSE otherwise. */ static bool remf(cl_object *place, cl_object indicator) { cl_object l = *place, tail = ECL_NIL; while (!Null(l)) { cl_object ind; if (!LISTP(l)) FEtype_error_plist(*place); ind = ECL_CONS_CAR(l); l = ECL_CONS_CDR(l); if (!CONSP(l)) FEtype_error_plist(*place); if (ind == indicator) { l = ECL_CONS_CDR(l); if (Null(tail)) *place = l; else ECL_RPLACD(tail, l); return TRUE; } tail = l; l = ECL_CONS_CDR(l); } return FALSE; } bool ecl_keywordp(cl_object s) { return (ecl_t_of(s) == t_symbol) && (s->symbol.hpack == cl_core.keyword_package); } @(defun get (sym indicator &optional deflt) cl_object *plist; @ plist = ecl_symbol_plist(sym); @(return ecl_getf(*plist, indicator, deflt)) @) cl_object cl_remprop(cl_object sym, cl_object prop) { cl_object *plist = ecl_symbol_plist(sym); @(return (remf(plist, prop)? ECL_T: ECL_NIL)) } cl_object cl_symbol_plist(cl_object sym) { @(return *ecl_symbol_plist(sym)) } @(defun getf (place indicator &optional deflt) @ @(return ecl_getf(place, indicator, deflt)) @) cl_object cl_get_properties(cl_object place, cl_object indicator_list) { const cl_env_ptr the_env = ecl_process_env(); cl_object l; #ifdef ECL_SAFE assert_type_proper_list(place); #endif for (l = place; CONSP(l); ) { cl_object cdr_l = ECL_CONS_CDR(l); if (!CONSP(cdr_l)) break; if (ecl_member_eq(ECL_CONS_CAR(l), indicator_list)) ecl_return3(the_env,ECL_CONS_CAR(l),ECL_CONS_CAR(cdr_l),l); l = ECL_CONS_CDR(cdr_l); } if (l != ECL_NIL) FEtype_error_plist(place); ecl_return3(the_env, ECL_NIL, ECL_NIL, ECL_NIL); } cl_object cl_symbol_name(cl_object x) { ecl_return1(ecl_process_env(), ecl_symbol_name(x)); } @(defun copy_symbol (sym &optional cp &aux x) @ if (Null(sym)) sym = ECL_NIL_SYMBOL; x = cl_make_symbol(ecl_symbol_name(sym)); if (!Null(cp)) { x->symbol.dynamic = 0; x->symbol.stype = sym->symbol.stype; x->symbol.value = sym->symbol.value; x->symbol.gfdef = sym->symbol.gfdef; x->symbol.plist = cl_copy_list(sym->symbol.plist); #ifdef ECL_THREADS x->symbol.binding = ECL_MISSING_SPECIAL_BINDING; #endif /* FIXME!!! We should also copy the system property list */ } @(return x) @) @(defun gensym (&optional (prefix cl_core.gensym_prefix)) cl_type t; cl_object counter, output; bool increment; @ { if (ecl_stringp(prefix)) { counter = ECL_SYM_VAL(the_env, @'*gensym-counter*'); increment = 1; } else if ((t = ecl_t_of(prefix)) == t_fixnum || t == t_bignum) { counter = prefix; prefix = cl_core.gensym_prefix; increment = 0; } else { FEwrong_type_nth_arg(@[gensym],2,prefix, cl_list(3, @'or', @'string', @'integer')); } output = ecl_make_string_output_stream(64, 1); ecl_bds_bind(the_env, @'*print-escape*', ECL_NIL); ecl_bds_bind(the_env, @'*print-readably*', ECL_NIL); ecl_bds_bind(the_env, @'*print-base*', ecl_make_fixnum(10)); ecl_bds_bind(the_env, @'*print-radix*', ECL_NIL); si_write_ugly_object(prefix, output); si_write_ugly_object(counter, output); ecl_bds_unwind_n(the_env, 4); output = cl_make_symbol(cl_get_output_stream_string(output)); if (increment) ECL_SETQ(the_env, @'*gensym-counter*',ecl_one_plus(counter)); @(return output); } @) @(defun gentemp (&optional (prefix cl_core.gentemp_prefix) (pack ecl_current_package())) cl_object output, s; int intern_flag; @ unlikely_if (!ECL_STRINGP(prefix)) FEwrong_type_nth_arg(@[gentemp], 1, prefix, @[string]); pack = si_coerce_to_package(pack); ONCE_MORE: output = ecl_make_string_output_stream(64, 1); ecl_bds_bind(the_env, @'*print-escape*', ECL_NIL); ecl_bds_bind(the_env, @'*print-readably*', ECL_NIL); ecl_bds_bind(the_env, @'*print-base*', ecl_make_fixnum(10)); ecl_bds_bind(the_env, @'*print-radix*', ECL_NIL); si_write_ugly_object(prefix, output); si_write_ugly_object(cl_core.gentemp_counter, output); ecl_bds_unwind_n(the_env, 4); cl_core.gentemp_counter = ecl_one_plus(cl_core.gentemp_counter); s = ecl_intern(cl_get_output_stream_string(output), pack, &intern_flag); if (intern_flag != 0) goto ONCE_MORE; @(return s) @) cl_object cl_symbol_package(cl_object sym) { @(return ecl_symbol_package(sym)) } cl_object cl_keywordp(cl_object sym) { @(return (ecl_keywordp(sym)? ECL_T: ECL_NIL)) } /* (SI:REM-F plist indicator) returns two values: * the new property list in which property indcator is removed * T if really removed NIL otherwise. It will be used for macro REMF. */ cl_object si_rem_f(cl_object plist, cl_object indicator) { cl_env_ptr the_env = ecl_process_env(); bool found = remf(&plist, indicator); ecl_return2(the_env, plist, (found? ECL_T : ECL_NIL)); } cl_object si_set_symbol_plist(cl_object sym, cl_object plist) { *ecl_symbol_plist(sym) = plist; @(return plist) } cl_object si_putprop(cl_object sym, cl_object value, cl_object indicator) { cl_object *plist = ecl_symbol_plist(sym); *plist = si_put_f(*plist, value, indicator); @(return value) } /* Added for defstruct. Beppe */ @(defun si::put-properties (sym &rest ind_values) @ while (--narg >= 2) { cl_object prop = ecl_va_arg(ind_values); si_putprop(sym, ecl_va_arg(ind_values), prop); narg--; } @(return sym) @) cl_object @si::*make-special(cl_object sym) { int type = ecl_symbol_type(sym); if (type & ecl_stp_constant) FEerror("~S is a constant.", 1, sym); ecl_symbol_type_set(sym, type | ecl_stp_special); cl_remprop(sym, @'si::symbol-macro'); @(return sym) } cl_object @si::*make-constant(cl_object sym, cl_object val) { int type = ecl_symbol_type(sym); if (type & ecl_stp_special) FEerror("The argument ~S to DEFCONSTANT is a special variable.", 1, sym); ecl_symbol_type_set(sym, type | ecl_stp_constant); ECL_SET(sym, val); @(return sym) } void ecl_defvar(cl_object sym, cl_object val) { si_safe_eval(3, cl_list(3, @'defvar', sym, cl_list(2, @'quote', val)), ECL_NIL, ECL_NIL); } void ecl_defparameter(cl_object sym, cl_object val) { si_safe_eval(3, cl_list(3, @'defparameter', sym, cl_list(2, @'quote', val)), ECL_NIL, ECL_NIL); } ecl-16.1.2/src/c/symbols_list.h000077500000000000000000003730251266352375300163020ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ #ifdef ECL_CMU_FORMAT # define ECL_NAME_PPRINT(x) ECL_NAME(x) #else # define ECL_NAME_PPRINT(x) NULL #endif #ifdef ECL_FINAL # define ECL_NAME(x) x #else # define ECL_NAME(x) NULL #endif #ifdef ECL_RELATIVE_PACKAGE_NAMES # define RELATIVE_PACKAGES_P ECL_T #else # define RELATIVE_PACKAGES_P ECL_NIL #endif #ifdef DPP #define CLOS_ "CLOS::" #define EXT_ "EXT::" #define SYS_ "SI::" #define MP_ "MP::" #define KEY_ ":" #define GRAY_ "GRAY::" #define FFI_ "FFI::" typedef struct { const char *name, *translation; } cl_symbol_initializer; #else #include "ecl_constants.h" #define CLOS_ #define EXT_ #define SYS_ #define MP_ #define KEY_ #define GRAY_ #define FFI_ #endif /* * Conditional addition of functions and symbols. The list of symbols can * not depend on the features, because otherwise the sources will and we will * not be able to cross-compile. */ #ifdef ECL_THREADS # define IF_MP(x) x #else # define IF_MP(x) NULL #endif #ifdef TCP # define IF_TCP(x) x #else # define IF_TCP(x) NULL #endif #ifdef PROFILE # define IF_PROFILE(x) x #else # define IF_PROFILE(x) NULL #endif #ifdef ECL_RELATIVE_PACKAGE_NAMES # define IF_RELPACK(x) x #else # define IF_RELPACK(x) NULL #endif #ifndef ECL_CLOS_STREAMS # undef GRAY_ # define GRAY_ SYS_ #endif #ifdef ECL_SSE2 # define IF_SSE2(x) x #else # define IF_SSE2(x) NULL #endif #if defined(HAVE_LIBFFI) || defined(ECL_DYNAMIC_FFI) # define IF_DFFI(x) x #else # define IF_DFFI(x) NULL #endif #if defined(HAVE_LIBFFI) # define IF_LIBFFI(x) x #else # define IF_LIBFFI(x) NULL #endif cl_symbol_initializer cl_symbols[] = { {"NIL", CL_ORDINARY, NULL, -1, OBJNULL}, {"T", CL_ORDINARY, NULL, -1, OBJNULL}, {SYS_ "UNBOUND", SI_CONSTANT, si_unbound, 0, ECL_UNBOUND}, {SYS_ "PROTECT-TAG", SI_ORDINARY, NULL, -1, OBJNULL}, {SYS_ "*RESTART-CLUSTERS*", SI_SPECIAL, NULL, -1, Cnil}, {SYS_ "*HANDLER-CLUSTERS*", SI_SPECIAL, NULL, -1, Cnil}, /* LISP PACKAGE */ {"&ALLOW-OTHER-KEYS", CL_ORDINARY, NULL, -1, OBJNULL}, {"&AUX", CL_ORDINARY, NULL, -1, OBJNULL}, {"&BODY", CL_ORDINARY, NULL, -1, OBJNULL}, {"&ENVIRONMENT", CL_ORDINARY, NULL, -1, OBJNULL}, {"&KEY", CL_ORDINARY, NULL, -1, OBJNULL}, {"&OPTIONAL", CL_ORDINARY, NULL, -1, OBJNULL}, {"&REST", CL_ORDINARY, NULL, -1, OBJNULL}, {"&WHOLE", CL_ORDINARY, NULL, -1, OBJNULL}, {"+", CL_SPECIAL, cl_P, -1, ECL_NIL}, {"++", CL_SPECIAL, NULL, -1, ECL_NIL}, {"+++", CL_SPECIAL, NULL, -1, ECL_NIL}, {"-", CL_SPECIAL, cl_M, -1, ECL_NIL}, {"*", CL_SPECIAL, cl_X, -1, ECL_NIL}, {"**", CL_SPECIAL, NULL, -1, ECL_NIL}, {"***", CL_SPECIAL, NULL, -1, ECL_NIL}, {"/", CL_SPECIAL, cl_N, -1, ECL_NIL}, {"//", CL_SPECIAL, NULL, -1, ECL_NIL}, {"///", CL_SPECIAL, NULL, -1, ECL_NIL}, {"/=", CL_ORDINARY, cl_NE, -1, OBJNULL}, {"*BREAK-ON-SIGNALS*", CL_SPECIAL, NULL, -1, ECL_NIL}, {"*COMPILE-FILE-PATHNAME*", CL_SPECIAL, NULL, -1, ECL_NIL}, {"*COMPILE-FILE-TRUENAME*", CL_SPECIAL, NULL, -1, ECL_NIL}, {"*COMPILE-PRINT*", CL_SPECIAL, NULL, -1, ECL_T}, {"*COMPILE-VERBOSE*", CL_SPECIAL, NULL, -1, ECL_T}, {"*DEBUG-IO*", CL_SPECIAL, NULL, -1, OBJNULL}, {"*DEBUGGER-HOOK*", CL_SPECIAL, NULL, -1, ECL_NIL}, {"*DEFAULT-PATHNAME-DEFAULTS*", CL_SPECIAL, NULL, -1, OBJNULL}, {"*ERROR-OUTPUT*", CL_SPECIAL, NULL, -1, OBJNULL}, {"*FEATURES*", CL_SPECIAL, NULL, -1, OBJNULL}, {"*GENSYM-COUNTER*", CL_SPECIAL, NULL, -1, ecl_make_fixnum(0)}, {"*LOAD-PATHNAME*", CL_SPECIAL, NULL, -1, ECL_NIL}, {"*LOAD-PRINT*", CL_SPECIAL, NULL, -1, ECL_NIL}, {"*LOAD-TRUENAME*", CL_SPECIAL, NULL, -1, ECL_NIL}, {"*LOAD-VERBOSE*", CL_SPECIAL, NULL, -1, ECL_T}, {"*MACROEXPAND-HOOK*", CL_SPECIAL, NULL, -1, OBJNULL}, {"*MODULES*", CL_SPECIAL, NULL, -1, OBJNULL}, {EXT_ "*MODULE-PROVIDER-FUNCTIONS*", EXT_SPECIAL, NULL, -1, OBJNULL}, {"*PACKAGE*", CL_SPECIAL, NULL, -1, OBJNULL}, {"*PRINT-ARRAY*", CL_SPECIAL, NULL, -1, ECL_T}, {"*PRINT-BASE*", CL_SPECIAL, NULL, -1, ecl_make_fixnum(10)}, {"*PRINT-CASE*", CL_SPECIAL, NULL, -1, OBJNULL}, {"*PRINT-CIRCLE*", CL_SPECIAL, NULL, -1, ECL_NIL}, {"*PRINT-ESCAPE*", CL_SPECIAL, NULL, -1, ECL_T}, {"*PRINT-GENSYM*", CL_SPECIAL, NULL, -1, ECL_T}, {"*PRINT-LENGTH*", CL_SPECIAL, NULL, -1, ECL_NIL}, {"*PRINT-LEVEL*", CL_SPECIAL, NULL, -1, ECL_NIL}, {"*PRINT-LINES*", CL_SPECIAL, NULL, -1, ECL_NIL}, {"*PRINT-MISER-WIDTH*", CL_SPECIAL, NULL, -1, ECL_NIL}, {"*PRINT-PPRINT-DISPATCH*", CL_SPECIAL, NULL, -1, ECL_NIL}, #if defined(ECL_CMU_FORMAT) {"*PRINT-PRETTY*", CL_SPECIAL, NULL, -1, ECL_NIL}, #else {"*PRINT-PRETTY*", CL_SPECIAL, NULL, -1, ECL_T}, #endif {"*PRINT-RADIX*", CL_SPECIAL, NULL, -1, ECL_NIL}, {"*PRINT-READABLY*", CL_SPECIAL, NULL, -1, ECL_NIL}, {"*PRINT-RIGHT-MARGIN*", CL_SPECIAL, NULL, -1, ECL_NIL}, {"*QUERY-IO*", CL_SPECIAL, NULL, -1, OBJNULL}, {"*RANDOM-STATE*", CL_SPECIAL, NULL, -1, OBJNULL}, {"*READ-BASE*", CL_SPECIAL, NULL, -1, ecl_make_fixnum(10)}, {"*READ-DEFAULT-FLOAT-FORMAT*", CL_SPECIAL, NULL, -1, OBJNULL}, {"*READ-EVAL*", CL_SPECIAL, NULL, -1, ECL_T}, {"*READ-SUPPRESS*", CL_SPECIAL, NULL, -1, ECL_NIL}, {"*READTABLE*", CL_SPECIAL, NULL, -1, OBJNULL}, {"*STANDARD-INPUT*", CL_SPECIAL, NULL, -1, OBJNULL}, {"*STANDARD-OUTPUT*", CL_SPECIAL, NULL, -1, OBJNULL}, {"*TERMINAL-IO*", CL_SPECIAL, NULL, -1, OBJNULL}, {"*TRACE-OUTPUT*", CL_SPECIAL, NULL, -1, OBJNULL}, {"1+", CL_ORDINARY, cl_1P, 1, OBJNULL}, {"1-", CL_ORDINARY, cl_1M, 1, OBJNULL}, {"<", CL_ORDINARY, cl_L, -1, OBJNULL}, {"<=", CL_ORDINARY, cl_LE, -1, OBJNULL}, {"=", CL_ORDINARY, cl_E, -1, OBJNULL}, {">", CL_ORDINARY, cl_G, -1, OBJNULL}, {">=", CL_ORDINARY, cl_GE, -1, OBJNULL}, {"ABORT", CL_ORDINARY, ECL_NAME(cl_abort), -1, OBJNULL}, {"ABS", CL_ORDINARY, cl_abs, 1, OBJNULL}, {"ACONS", CL_ORDINARY, cl_acons, 3, OBJNULL}, {"ACOS", CL_ORDINARY, ECL_NAME(cl_acos), 1, OBJNULL}, {"ACOSH", CL_ORDINARY, ECL_NAME(cl_acosh), 1, OBJNULL}, {"ADJOIN", CL_ORDINARY, cl_adjoin, -1, OBJNULL}, {"ADJUST-ARRAY", CL_ORDINARY, ECL_NAME(cl_adjust_array), -1, OBJNULL}, {"ADJUSTABLE-ARRAY-P", CL_ORDINARY, cl_adjustable_array_p, 1, OBJNULL}, {"ALPHA-CHAR-P", CL_ORDINARY, cl_alpha_char_p, 1, OBJNULL}, {"ALPHANUMERICP", CL_ORDINARY, cl_alphanumericp, 1, OBJNULL}, {"AND", CL_ORDINARY, NULL, -1, OBJNULL}, {"APPEND", CL_ORDINARY, cl_append, -1, OBJNULL}, {"APPLY", CL_ORDINARY, cl_apply, -1, OBJNULL}, {"APROPOS", CL_ORDINARY, ECL_NAME(cl_apropos), -1, OBJNULL}, {"APROPOS-LIST", CL_ORDINARY, ECL_NAME(cl_apropos_list), -1, OBJNULL}, {"AREF", CL_ORDINARY, cl_aref, -1, OBJNULL}, {"ARITHMETIC-ERROR", CL_ORDINARY, NULL, -1, OBJNULL}, {"ARITHMETIC-ERROR-OPERANDS", CL_ORDINARY, NULL, -1, OBJNULL}, {"ARITHMETIC-ERROR-OPERATION", CL_ORDINARY, NULL, -1, OBJNULL}, {"ARRAY", CL_ORDINARY, NULL, -1, OBJNULL}, {"ARRAY-DIMENSION", CL_ORDINARY, cl_array_dimension, 2, OBJNULL}, {"ARRAY-DIMENSION-LIMIT", CL_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_ARRAY_DIMENSION_LIMIT)}, {"ARRAY-DIMENSIONS", CL_ORDINARY, ECL_NAME(cl_array_dimensions), 1, OBJNULL}, {"ARRAY-DISPLACEMENT", CL_ORDINARY, cl_array_displacement, 1, OBJNULL}, {"ARRAY-ELEMENT-TYPE", CL_ORDINARY, cl_array_element_type, 1, OBJNULL}, {"ARRAY-HAS-FILL-POINTER-P", CL_ORDINARY, cl_array_has_fill_pointer_p, 1, OBJNULL}, {"ARRAY-IN-BOUNDS-P", CL_ORDINARY, ECL_NAME(cl_array_in_bounds_p), -1, OBJNULL}, {"ARRAY-RANK", CL_ORDINARY, cl_array_rank, 1, OBJNULL}, {"ARRAY-RANK-LIMIT", CL_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_ARRAY_RANK_LIMIT)}, {"ARRAY-ROW-MAJOR-INDEX", CL_ORDINARY, ECL_NAME(cl_array_row_major_index), -1, OBJNULL}, {"ARRAY-TOTAL-SIZE", CL_ORDINARY, cl_array_total_size, 1, OBJNULL}, {"ARRAY-TOTAL-SIZE-LIMIT", CL_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_ARRAY_TOTAL_LIMIT)}, {"ARRAYP", CL_ORDINARY, cl_arrayp, 1, OBJNULL}, {"ASH", CL_ORDINARY, cl_ash, 2, OBJNULL}, {"ASIN", CL_ORDINARY, ECL_NAME(cl_asin), 1, OBJNULL}, {"ASINH", CL_ORDINARY, ECL_NAME(cl_asinh), 1, OBJNULL}, {"ASSERT", CL_ORDINARY, NULL, -1, OBJNULL}, {"ASSOC", CL_ORDINARY, cl_assoc, -1, OBJNULL}, {"ASSOC-IF", CL_ORDINARY, ECL_NAME(cl_assoc_if), -1, OBJNULL}, {"ASSOC-IF-NOT", CL_ORDINARY, ECL_NAME(cl_assoc_if_not), -1, OBJNULL}, {"ATAN", CL_ORDINARY, cl_atan, -1, OBJNULL}, {"ATANH", CL_ORDINARY, ECL_NAME(cl_atanh), 1, OBJNULL}, {"ATOM", CL_ORDINARY, cl_atom, 1, OBJNULL}, {"BASE-CHAR", CL_ORDINARY, NULL, -1, OBJNULL}, {"BASE-STRING", CL_ORDINARY, NULL, -1, OBJNULL}, {"BIGNUM", CL_ORDINARY, NULL, -1, OBJNULL}, {"BIT", CL_ORDINARY, ECL_NAME(cl_bit), -1, OBJNULL}, {"BIT-AND", CL_ORDINARY, ECL_NAME(cl_bit_and), -1, OBJNULL}, {"BIT-ANDC1", CL_ORDINARY, ECL_NAME(cl_bit_andc1), -1, OBJNULL}, {"BIT-ANDC2", CL_ORDINARY, ECL_NAME(cl_bit_andc2), -1, OBJNULL}, {"BIT-EQV", CL_ORDINARY, ECL_NAME(cl_bit_eqv), -1, OBJNULL}, {"BIT-IOR", CL_ORDINARY, ECL_NAME(cl_bit_ior), -1, OBJNULL}, {"BIT-NAND", CL_ORDINARY, ECL_NAME(cl_bit_nand), -1, OBJNULL}, {"BIT-NOR", CL_ORDINARY, ECL_NAME(cl_bit_nor), -1, OBJNULL}, {"BIT-NOT", CL_ORDINARY, ECL_NAME(cl_bit_not), -1, OBJNULL}, {"BIT-ORC1", CL_ORDINARY, ECL_NAME(cl_bit_orc1), -1, OBJNULL}, {"BIT-ORC2", CL_ORDINARY, ECL_NAME(cl_bit_orc2), -1, OBJNULL}, {"BIT-VECTOR", CL_ORDINARY, NULL, -1, OBJNULL}, {"BIT-VECTOR-P", CL_ORDINARY, cl_bit_vector_p, 1, OBJNULL}, {"BIT-XOR", CL_ORDINARY, ECL_NAME(cl_bit_xor), -1, OBJNULL}, {"BLOCK", CL_FORM, NULL, -1, OBJNULL}, {"BOOLE", CL_ORDINARY, cl_boole, 3, OBJNULL}, {"BOOLE-1", CL_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_BOOL1)}, {"BOOLE-2", CL_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_BOOL2)}, {"BOOLE-AND", CL_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_BOOLAND)}, {"BOOLE-ANDC1", CL_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_BOOLANDC1)}, {"BOOLE-ANDC2", CL_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_BOOLANDC2)}, {"BOOLE-C1", CL_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_BOOLC1)}, {"BOOLE-C2", CL_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_BOOLC2)}, {"BOOLE-CLR", CL_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_BOOLCLR)}, {"BOOLE-EQV", CL_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_BOOLEQV)}, {"BOOLE-IOR", CL_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_BOOLIOR)}, {"BOOLE-NAND", CL_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_BOOLNAND)}, {"BOOLE-NOR", CL_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_BOOLNOR)}, {"BOOLE-ORC1", CL_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_BOOLORC1)}, {"BOOLE-ORC2", CL_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_BOOLORC2)}, {"BOOLE-SET", CL_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_BOOLSET)}, {"BOOLE-XOR", CL_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_BOOLXOR)}, {"BOOLEAN", CL_ORDINARY, NULL, -1, OBJNULL}, {"BOTH-CASE-P", CL_ORDINARY, cl_both_case_p, 1, OBJNULL}, {"BOUNDP", CL_ORDINARY, cl_boundp, 1, OBJNULL}, {"BREAK", CL_ORDINARY, NULL, -1, OBJNULL}, {"BROADCAST-STREAM", CL_ORDINARY, NULL, -1, OBJNULL}, {"BROADCAST-STREAM-STREAMS", CL_ORDINARY, cl_broadcast_stream_streams, 1, OBJNULL}, {"BUTLAST", CL_ORDINARY, cl_butlast, -1, OBJNULL}, {"BYTE", CL_ORDINARY, ECL_NAME(cl_byte), 2, OBJNULL}, {"BYTE-POSITION", CL_ORDINARY, ECL_NAME(cl_byte_position), 1, OBJNULL}, {"BYTE-SIZE", CL_ORDINARY, ECL_NAME(cl_byte_size), 1, OBJNULL}, {"CAAAAR", CL_ORDINARY, cl_caaaar, 1, OBJNULL}, {"CAAADR", CL_ORDINARY, cl_caaadr, 1, OBJNULL}, {"CAAAR", CL_ORDINARY, cl_caaar, 1, OBJNULL}, {"CAADAR", CL_ORDINARY, cl_caadar, 1, OBJNULL}, {"CAADDR", CL_ORDINARY, cl_caaddr, 1, OBJNULL}, {"CAADR", CL_ORDINARY, cl_caadr, 1, OBJNULL}, {"CAAR", CL_ORDINARY, cl_caar, 1, OBJNULL}, {"CADAAR", CL_ORDINARY, cl_cadaar, 1, OBJNULL}, {"CADADR", CL_ORDINARY, cl_cadadr, 1, OBJNULL}, {"CADAR", CL_ORDINARY, cl_cadar, 1, OBJNULL}, {"CADDAR", CL_ORDINARY, cl_caddar, 1, OBJNULL}, {"CADDDR", CL_ORDINARY, cl_cadddr, 1, OBJNULL}, {"CADDR", CL_ORDINARY, cl_caddr, 1, OBJNULL}, {"CADR", CL_ORDINARY, cl_cadr, 1, OBJNULL}, {"CALL-ARGUMENTS-LIMIT", CL_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_CALL_ARGUMENTS_LIMIT)}, {"CAR", CL_ORDINARY, cl_car, 1, OBJNULL}, {"CASE", CL_FORM, NULL, -1, OBJNULL}, {"CATCH", CL_FORM, NULL, -1, OBJNULL}, {"CCASE", CL_ORDINARY, NULL, -1, OBJNULL}, {"CDAAAR", CL_ORDINARY, cl_cdaaar, 1, OBJNULL}, {"CDAADR", CL_ORDINARY, cl_cdaadr, 1, OBJNULL}, {"CDAAR", CL_ORDINARY, cl_cdaar, 1, OBJNULL}, {"CDADAR", CL_ORDINARY, cl_cdadar, 1, OBJNULL}, {"CDADDR", CL_ORDINARY, cl_cdaddr, 1, OBJNULL}, {"CDADR", CL_ORDINARY, cl_cdadr, 1, OBJNULL}, {"CDAR", CL_ORDINARY, cl_cdar, 1, OBJNULL}, {"CDDAAR", CL_ORDINARY, cl_cddaar, 1, OBJNULL}, {"CDDADR", CL_ORDINARY, cl_cddadr, 1, OBJNULL}, {"CDDAR", CL_ORDINARY, cl_cddar, 1, OBJNULL}, {"CDDDAR", CL_ORDINARY, cl_cdddar, 1, OBJNULL}, {"CDDDDR", CL_ORDINARY, cl_cddddr, 1, OBJNULL}, {"CDDDR", CL_ORDINARY, cl_cdddr, 1, OBJNULL}, {"CDDR", CL_ORDINARY, cl_cddr, 1, OBJNULL}, {"CDR", CL_ORDINARY, cl_cdr, 1, OBJNULL}, {"CEILING", CL_ORDINARY, cl_ceiling, -1, OBJNULL}, {"CELL-ERROR", CL_ORDINARY, NULL, -1, OBJNULL}, {"CELL-ERROR-NAME", CL_ORDINARY, NULL, -1, OBJNULL}, {"CERROR", CL_ORDINARY, cl_cerror, -1, OBJNULL}, {"CHAR", CL_ORDINARY, cl_char, 2, OBJNULL}, {"CHAR-CODE", CL_ORDINARY, cl_char_code, 1, OBJNULL}, {"CHAR-CODE-LIMIT", CL_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_CHAR_CODE_LIMIT)}, {"CHAR-DOWNCASE", CL_ORDINARY, cl_char_downcase, 1, OBJNULL}, {"CHAR-EQUAL", CL_ORDINARY, cl_char_equal, -1, OBJNULL}, {"CHAR-GREATERP", CL_ORDINARY, cl_char_greaterp, -1, OBJNULL}, {"CHAR-INT", CL_ORDINARY, cl_char_int, 1, OBJNULL}, {"CHAR-LESSP", CL_ORDINARY, cl_char_lessp, -1, OBJNULL}, {"CHAR-NAME", CL_ORDINARY, cl_char_name, 1, OBJNULL}, {"CHAR-NOT-EQUAL", CL_ORDINARY, cl_char_not_equal, -1, OBJNULL}, {"CHAR-NOT-GREATERP", CL_ORDINARY, cl_char_not_greaterp, -1, OBJNULL}, {"CHAR-NOT-LESSP", CL_ORDINARY, cl_char_not_lessp, -1, OBJNULL}, {"CHAR-UPCASE", CL_ORDINARY, cl_char_upcase, 1, OBJNULL}, {"CHAR/=", CL_ORDINARY, cl_charNE, -1, OBJNULL}, {"CHAR<", CL_ORDINARY, cl_charL, -1, OBJNULL}, {"CHAR<=", CL_ORDINARY, cl_charLE, -1, OBJNULL}, {"CHAR=", CL_ORDINARY, cl_charE, -1, OBJNULL}, {"CHAR>", CL_ORDINARY, cl_charG, -1, OBJNULL}, {"CHAR>=", CL_ORDINARY, cl_charGE, -1, OBJNULL}, {"CHARACTER", CL_ORDINARY, cl_character, 1, OBJNULL}, {"CHARACTERP", CL_ORDINARY, cl_characterp, 1, OBJNULL}, {"CHECK-TYPE", CL_ORDINARY, NULL, -1, OBJNULL}, {"CIS", CL_ORDINARY, ECL_NAME(cl_cis), 1, OBJNULL}, {"CLEAR-INPUT", CL_ORDINARY, cl_clear_input, -1, OBJNULL}, {"CLEAR-OUTPUT", CL_ORDINARY, cl_clear_output, -1, OBJNULL}, {"CLOSE", CL_ORDINARY, cl_close, -1, OBJNULL}, {"CLRHASH", CL_ORDINARY, cl_clrhash, 1, OBJNULL}, {"CODE-CHAR", CL_ORDINARY, cl_code_char, 1, OBJNULL}, {"COERCE", CL_ORDINARY, ECL_NAME(cl_coerce), 2, OBJNULL}, {"COMPILATION-SPEED", CL_ORDINARY, NULL, -1, OBJNULL}, {"COMPILE", CL_ORDINARY, NULL, -1, OBJNULL}, {"COMPILE-FILE", CL_ORDINARY, NULL, -1, OBJNULL}, {"COMPILE-FILE-PATHNAME", CL_ORDINARY, NULL, -1, OBJNULL}, {"COMPILED-FUNCTION", CL_ORDINARY, NULL, -1, OBJNULL}, {"COMPILED-FUNCTION-P", CL_ORDINARY, cl_compiled_function_p, 1, OBJNULL}, {"COMPILER-MACRO", CL_ORDINARY, NULL, -1, OBJNULL}, {"COMPILER-MACRO-FUNCTION", CL_ORDINARY, NULL, -1, OBJNULL}, {"COMPLEMENT", CL_ORDINARY, ECL_NAME(cl_complement), 1, OBJNULL}, {"COMPLEX", CL_ORDINARY, cl_complex, -1, OBJNULL}, {"COMPLEXP", CL_ORDINARY, cl_complexp, 1, OBJNULL}, {"COMPUTE-RESTARTS", CL_ORDINARY, ECL_NAME(cl_compute_restarts), -1, OBJNULL}, {"CONCATENATE", CL_ORDINARY, ECL_NAME(cl_concatenate), -1, OBJNULL}, {"CONCATENATED-STREAM", CL_ORDINARY, NULL, -1, OBJNULL}, {"CONCATENATED-STREAM-STREAMS", CL_ORDINARY, cl_concatenated_stream_streams, 1, OBJNULL}, {"COND", CL_FORM, NULL, -1, OBJNULL}, {"CONDITION", CL_ORDINARY, NULL, -1, OBJNULL}, {"CONJUGATE", CL_ORDINARY, cl_conjugate, 1, OBJNULL}, {"CONTINUE", CL_ORDINARY, ECL_NAME(cl_continue), -1, OBJNULL}, {"CONS", CL_ORDINARY, cl_cons, 2, OBJNULL}, {"CONSP", CL_ORDINARY, cl_consp, 1, OBJNULL}, {"CONSTANTLY", CL_ORDINARY, ECL_NAME(cl_constantly), 1, OBJNULL}, {"CONSTANTP", CL_ORDINARY, cl_constantp, -1, OBJNULL}, {"CONTROL-ERROR", CL_ORDINARY, NULL, -1, OBJNULL}, {"COPY-ALIST", CL_ORDINARY, cl_copy_alist, 1, OBJNULL}, {"COPY-LIST", CL_ORDINARY, cl_copy_list, 1, OBJNULL}, {"COPY-PPRINT-DISPATCH", CL_ORDINARY, ECL_NAME_PPRINT(cl_copy_pprint_dispatch), -1, OBJNULL}, {"COPY-READTABLE", CL_ORDINARY, cl_copy_readtable, -1, OBJNULL}, {"COPY-SEQ", CL_ORDINARY, cl_copy_seq, 1, OBJNULL}, {"COPY-STRUCTURE", CL_ORDINARY, cl_copy_structure, 1, OBJNULL}, {"COPY-SYMBOL", CL_ORDINARY, cl_copy_symbol, -1, OBJNULL}, {"COPY-TREE", CL_ORDINARY, cl_copy_tree, 1, OBJNULL}, {"COS", CL_ORDINARY, cl_cos, 1, OBJNULL}, {"COSH", CL_ORDINARY, cl_cosh, 1, OBJNULL}, {"COUNT", CL_ORDINARY, ECL_NAME(cl_count), -1, OBJNULL}, {"COUNT-IF", CL_ORDINARY, ECL_NAME(cl_count_if), -1, OBJNULL}, {"COUNT-IF-NOT", CL_ORDINARY, ECL_NAME(cl_count_if_not), -1, OBJNULL}, {"CTYPECASE", CL_ORDINARY, NULL, -1, OBJNULL}, {"DEBUG", CL_ORDINARY, NULL, -1, OBJNULL}, {"DECF", CL_ORDINARY, NULL, -1, OBJNULL}, {"DECLAIM", CL_ORDINARY, NULL, -1, OBJNULL}, {"DECLARATION", CL_ORDINARY, NULL, -1, OBJNULL}, {"DECLARE", CL_ORDINARY, NULL, -1, OBJNULL}, {"DECODE-FLOAT", CL_ORDINARY, cl_decode_float, 1, OBJNULL}, {"DECODE-UNIVERSAL-TIME", CL_ORDINARY, ECL_NAME(cl_decode_universal_time), -1, OBJNULL}, {"DEFCONSTANT", CL_ORDINARY, NULL, -1, OBJNULL}, {"DEFINE-CONDITION", CL_ORDINARY, NULL, -1, OBJNULL}, {"DEFINE-COMPILER-MACRO", CL_ORDINARY, NULL, -1, OBJNULL}, {"DEFINE-MODIFY-MACRO", CL_ORDINARY, NULL, -1, OBJNULL}, {"DEFINE-SETF-EXPANDER", CL_ORDINARY, NULL, -1, OBJNULL}, {"DEFINE-SYMBOL-MACRO", CL_ORDINARY, NULL, -1, OBJNULL}, {"DEFMACRO", CL_ORDINARY, NULL, -1, OBJNULL}, {"DEFPACKAGE", CL_ORDINARY, NULL, -1, OBJNULL}, {"DEFPARAMETER", CL_ORDINARY, NULL, -1, OBJNULL}, {"DEFSETF", CL_ORDINARY, NULL, -1, OBJNULL}, {"DEFSTRUCT", CL_ORDINARY, NULL, -1, OBJNULL}, {"DEFTYPE", CL_ORDINARY, NULL, -1, OBJNULL}, {"DEFUN", CL_ORDINARY, NULL, -1, OBJNULL}, {"DEFVAR", CL_ORDINARY, NULL, -1, OBJNULL}, {"DELETE", CL_ORDINARY, ECL_NAME(cl_delete), -1, OBJNULL}, {"DELETE-DUPLICATES", CL_ORDINARY, ECL_NAME(cl_delete_duplicates), -1, OBJNULL}, {"DELETE-FILE", CL_ORDINARY, cl_delete_file, 1, OBJNULL}, {"DELETE-IF", CL_ORDINARY, ECL_NAME(cl_delete_if), -1, OBJNULL}, {"DELETE-IF-NOT", CL_ORDINARY, ECL_NAME(cl_delete_if_not), -1, OBJNULL}, {"DELETE-PACKAGE", CL_ORDINARY, cl_delete_package, 1, OBJNULL}, {"DENOMINATOR", CL_ORDINARY, cl_denominator, 1, OBJNULL}, {"DEPOSIT-FIELD", CL_ORDINARY, ECL_NAME(cl_deposit_field), 3, OBJNULL}, {"DESCRIBE", CL_ORDINARY, ECL_NAME(cl_describe), -1, OBJNULL}, {"DESTRUCTURING-BIND", CL_ORDINARY, NULL, -1, OBJNULL}, {"DIGIT-CHAR", CL_ORDINARY, cl_digit_char, -1, OBJNULL}, {"DIGIT-CHAR-P", CL_ORDINARY, cl_digit_char_p, -1, OBJNULL}, {"DIRECTORY", CL_ORDINARY, cl_directory, -1, OBJNULL}, {"DIRECTORY-NAMESTRING", CL_ORDINARY, cl_directory_namestring, 1, OBJNULL}, {"DISASSEMBLE", CL_ORDINARY, NULL, -1, OBJNULL}, {"DIVISION-BY-ZERO", CL_ORDINARY, NULL, -1, OBJNULL}, {"DO", CL_FORM, NULL, -1, OBJNULL}, {"DO*", CL_FORM, NULL, -1, OBJNULL}, {"DO-ALL-SYMBOLS", CL_ORDINARY, NULL, -1, OBJNULL}, {"DO-EXTERNAL-SYMBOLS", CL_ORDINARY, NULL, -1, OBJNULL}, {"DO-SYMBOLS", CL_ORDINARY, NULL, -1, OBJNULL}, {"DOCUMENTATION", CL_ORDINARY, NULL, -1, OBJNULL}, {"DOLIST", CL_FORM, NULL, -1, OBJNULL}, {"DOTIMES", CL_FORM, NULL, -1, OBJNULL}, {"DOUBLE-FLOAT", CL_ORDINARY, NULL, -1, OBJNULL}, {"DOUBLE-FLOAT-EPSILON", CL_CONSTANT, NULL, -1, OBJNULL}, {"DOUBLE-FLOAT-NEGATIVE-EPSILON", CL_CONSTANT, NULL, -1, OBJNULL}, {"DPB", CL_ORDINARY, ECL_NAME(cl_dpb), 3, OBJNULL}, {"DRIBBLE", CL_ORDINARY, ECL_NAME(cl_dribble), -1, OBJNULL}, {"DYNAMIC-EXTENT", CL_ORDINARY, NULL, -1, OBJNULL}, {"ECASE", CL_ORDINARY, NULL, -1, OBJNULL}, {"ECHO-STREAM", CL_ORDINARY, NULL, -1, OBJNULL}, {"ECHO-STREAM-INPUT-STREAM", CL_ORDINARY, cl_echo_stream_input_stream, 1, OBJNULL}, {"ECHO-STREAM-OUTPUT-STREAM", CL_ORDINARY, cl_echo_stream_output_stream, 1, OBJNULL}, {"ED", CL_ORDINARY, NULL, -1, OBJNULL}, {"EIGHTH", CL_ORDINARY, cl_eighth, 1, OBJNULL}, {"ELT", CL_ORDINARY, cl_elt, 2, OBJNULL}, {"ENCODE-UNIVERSAL-TIME", CL_ORDINARY, ECL_NAME(cl_encode_universal_time), -1, OBJNULL}, {"END-OF-FILE", CL_ORDINARY, NULL, -1, OBJNULL}, {"ENDP", CL_ORDINARY, cl_endp, 1, OBJNULL}, {"ENOUGH-NAMESTRING", CL_ORDINARY, cl_enough_namestring, -1, OBJNULL}, {"ENSURE-DIRECTORIES-EXIST", CL_ORDINARY, ECL_NAME(cl_ensure_directories_exist), -1, OBJNULL}, {"EQ", CL_ORDINARY, cl_eq, 2, OBJNULL}, {"EQL", CL_ORDINARY, cl_eql, 2, OBJNULL}, {"EQUAL", CL_ORDINARY, cl_equal, 2, OBJNULL}, {"EQUALP", CL_ORDINARY, cl_equalp, 2, OBJNULL}, {"ERROR", CL_ORDINARY, cl_error, -1, OBJNULL}, {"ETYPECASE", CL_ORDINARY, NULL, -1, OBJNULL}, {"EVAL", CL_ORDINARY, cl_eval, 1, OBJNULL}, {"EVAL-WHEN", CL_FORM, NULL, -1, OBJNULL}, {"EVENP", CL_ORDINARY, cl_evenp, 1, OBJNULL}, {"EVERY", CL_ORDINARY, ECL_NAME(cl_every), -1, OBJNULL}, {"EXP", CL_ORDINARY, cl_exp, 1, OBJNULL}, {"EXPORT", CL_ORDINARY, cl_export, -1, OBJNULL}, {"EXPT", CL_ORDINARY, cl_expt, 2, OBJNULL}, {"EXTENDED-CHAR", CL_ORDINARY, NULL, -1, OBJNULL}, {"FBOUNDP", CL_ORDINARY, cl_fboundp, 1, OBJNULL}, {"FCEILING", CL_ORDINARY, ECL_NAME(cl_fceiling), -1, OBJNULL}, {"FDEFINITION", CL_ORDINARY, cl_fdefinition, 1, OBJNULL}, {"FFLOOR", CL_ORDINARY, ECL_NAME(cl_ffloor), -1, OBJNULL}, {"FIFTH", CL_ORDINARY, cl_fifth, 1, OBJNULL}, {"FILE-AUTHOR", CL_ORDINARY, cl_file_author, 1, OBJNULL}, {"FILE-ERROR", CL_ORDINARY, NULL, -1, OBJNULL}, {"FILE-ERROR-PATHNAME", CL_ORDINARY, NULL, -1, OBJNULL}, {"FILE-LENGTH", CL_ORDINARY, cl_file_length, 1, OBJNULL}, {"FILE-NAMESTRING", CL_ORDINARY, cl_file_namestring, 1, OBJNULL}, {"FILE-POSITION", CL_ORDINARY, cl_file_position, -1, OBJNULL}, {"FILE-STREAM", CL_ORDINARY, NULL, -1, OBJNULL}, {"FILE-STRING-LENGTH", CL_ORDINARY, cl_file_string_length, 2, OBJNULL}, {"FILE-WRITE-DATE", CL_ORDINARY, cl_file_write_date, 1, OBJNULL}, {"FILL", CL_ORDINARY, ECL_NAME(cl_fill), -1, OBJNULL}, {"FILL-POINTER", CL_ORDINARY, cl_fill_pointer, 1, OBJNULL}, {"FIND", CL_ORDINARY, ECL_NAME(cl_find), -1, OBJNULL}, {"FIND-ALL-SYMBOLS", CL_ORDINARY, ECL_NAME(cl_find_all_symbols), 1, OBJNULL}, {"FIND-IF", CL_ORDINARY, ECL_NAME(cl_find_if), -1, OBJNULL}, {"FIND-IF-NOT", CL_ORDINARY, ECL_NAME(cl_find_if_not), -1, OBJNULL}, {"FIND-PACKAGE", CL_ORDINARY, cl_find_package, 1, OBJNULL}, {"FIND-RESTART", CL_ORDINARY, ECL_NAME(cl_find_restart), -1, OBJNULL}, {"FIND-SYMBOL", CL_ORDINARY, cl_find_symbol, -1, OBJNULL}, {"FINISH-OUTPUT", CL_ORDINARY, cl_finish_output, -1, OBJNULL}, {"FIRST", CL_ORDINARY, cl_car, 1, OBJNULL}, {"FIXNUM", CL_ORDINARY, NULL, -1, OBJNULL}, {"FLET", CL_FORM, NULL, -1, OBJNULL}, {"FLOAT", CL_ORDINARY, cl_float, -1, OBJNULL}, {"FLOAT-DIGITS", CL_ORDINARY, cl_float_digits, 1, OBJNULL}, {"FLOAT-PRECISION", CL_ORDINARY, cl_float_precision, 1, OBJNULL}, {"FLOAT-RADIX", CL_ORDINARY, cl_float_radix, 1, OBJNULL}, {"FLOAT-SIGN", CL_ORDINARY, cl_float_sign, -1, OBJNULL}, {"FLOATING-POINT-INEXACT", CL_ORDINARY, NULL, -1, OBJNULL}, {"FLOATING-POINT-INVALID-OPERATION", CL_ORDINARY, NULL, -1, OBJNULL}, {"FLOATING-POINT-OVERFLOW", CL_ORDINARY, NULL, -1, OBJNULL}, {"FLOATING-POINT-UNDERFLOW", CL_ORDINARY, NULL, -1, OBJNULL}, {"FLOATP", CL_ORDINARY, cl_floatp, 1, OBJNULL}, {"FLOOR", CL_ORDINARY, cl_floor, -1, OBJNULL}, {"FMAKUNBOUND", CL_ORDINARY, cl_fmakunbound, 1, OBJNULL}, {"FORCE-OUTPUT", CL_ORDINARY, cl_force_output, -1, OBJNULL}, {"FORMAT", CL_ORDINARY, cl_format, -1, OBJNULL}, {"FORMATTER", CL_ORDINARY, NULL, -1, OBJNULL}, {"FOURTH", CL_ORDINARY, cl_cadddr, 1, OBJNULL}, {"FRESH-LINE", CL_ORDINARY, cl_fresh_line, -1, OBJNULL}, {"FROUND", CL_ORDINARY, ECL_NAME(cl_fround), -1, OBJNULL}, {"FTRUNCATE", CL_ORDINARY, ECL_NAME(cl_ftruncate), -1, OBJNULL}, {"FTYPE", CL_ORDINARY, NULL, -1, OBJNULL}, {"FUNCALL", CL_ORDINARY, cl_funcall, -1, OBJNULL}, {"FUNCTION-LAMBDA-EXPRESSION", CL_ORDINARY, cl_function_lambda_expression, 1, OBJNULL}, {"FUNCTION", CL_FORM, NULL, -1, OBJNULL}, {"FUNCTION-KEYWORDS", CL_ORDINARY, NULL, -1, OBJNULL}, {"FUNCTIONP", CL_ORDINARY, cl_functionp, 1, OBJNULL}, {"GCD", CL_ORDINARY, cl_gcd, -1, OBJNULL}, {"GENSYM", CL_ORDINARY, cl_gensym, -1, OBJNULL}, {"GENTEMP", CL_ORDINARY, cl_gentemp, -1, OBJNULL}, {"GET", CL_ORDINARY, cl_get, -1, OBJNULL}, {"GET-DECODED-TIME", CL_ORDINARY, ECL_NAME(cl_get_decoded_time), 0, OBJNULL}, {"GET-DISPATCH-MACRO-CHARACTER", CL_ORDINARY, cl_get_dispatch_macro_character, -1, OBJNULL}, {"GET-INTERNAL-REAL-TIME", CL_ORDINARY, cl_get_internal_real_time, 0, OBJNULL}, {"GET-INTERNAL-RUN-TIME", CL_ORDINARY, cl_get_internal_run_time, 0, OBJNULL}, {"GET-MACRO-CHARACTER", CL_ORDINARY, cl_get_macro_character, -1, OBJNULL}, {"GET-OUTPUT-STREAM-STRING", CL_ORDINARY, cl_get_output_stream_string, 1, OBJNULL}, {"GET-PROPERTIES", CL_ORDINARY, cl_get_properties, 2, OBJNULL}, {"GET-SETF-EXPANSION", CL_ORDINARY, NULL, -1, OBJNULL}, {"GET-UNIVERSAL-TIME", CL_ORDINARY, cl_get_universal_time, 0, OBJNULL}, {"GETF", CL_ORDINARY, cl_getf, -1, OBJNULL}, {"GETHASH", CL_ORDINARY, cl_gethash, -1, OBJNULL}, {"GO", CL_FORM, NULL, -1, OBJNULL}, {"GRAPHIC-CHAR-P", CL_ORDINARY, cl_graphic_char_p, 1, OBJNULL}, {"HANDLER-CASE", CL_ORDINARY, NULL, -1, OBJNULL}, {"HANDLER-BIND", CL_ORDINARY, NULL, -1, OBJNULL}, {"HASH-TABLE", CL_ORDINARY, NULL, -1, OBJNULL}, {"HASH-TABLE-COUNT", CL_ORDINARY, cl_hash_table_count, 1, OBJNULL}, {"HASH-TABLE-P", CL_ORDINARY, cl_hash_table_p, 1, OBJNULL}, {"HASH-TABLE-REHASH-SIZE", CL_ORDINARY, cl_hash_table_rehash_size, 1, OBJNULL}, {"HASH-TABLE-REHASH-THRESHOLD", CL_ORDINARY, cl_hash_table_rehash_threshold, 1, OBJNULL}, {"HASH-TABLE-SIZE", CL_ORDINARY, cl_hash_table_size, 1, OBJNULL}, {"HASH-TABLE-TEST", CL_ORDINARY, cl_hash_table_test, 1, OBJNULL}, {"HOST-NAMESTRING", CL_ORDINARY, cl_host_namestring, 1, OBJNULL}, {"IDENTITY", CL_ORDINARY, cl_identity, 1, OBJNULL}, {"IGNORABLE", CL_ORDINARY, NULL, -1, OBJNULL}, {"IGNORE", CL_ORDINARY, NULL, -1, OBJNULL}, {"IGNORE-ERRORS", CL_ORDINARY, NULL, -1, OBJNULL}, {"IMAGPART", CL_ORDINARY, cl_imagpart, 1, OBJNULL}, {"IMPORT", CL_ORDINARY, cl_import, -1, OBJNULL}, {"IN-PACKAGE", CL_ORDINARY, NULL, -1, OBJNULL}, {"INCF", CL_ORDINARY, NULL, -1, OBJNULL}, {"INLINE", CL_ORDINARY, NULL, -1, OBJNULL}, {"INPUT-STREAM-P", CL_ORDINARY, cl_input_stream_p, 1, OBJNULL}, {"INSPECT", CL_ORDINARY, ECL_NAME(cl_inspect), 1, OBJNULL}, {"INTEGER", CL_ORDINARY, NULL, -1, OBJNULL}, {"INTEGER-DECODE-FLOAT", CL_ORDINARY, cl_integer_decode_float, 1, OBJNULL}, {"INTEGER-LENGTH", CL_ORDINARY, cl_integer_length, 1, OBJNULL}, {"INTEGERP", CL_ORDINARY, cl_integerp, 1, OBJNULL}, {"INTERACTIVE-STREAM-P", CL_ORDINARY, cl_interactive_stream_p, 1, OBJNULL}, {"INTERN", CL_ORDINARY, cl_intern, -1, OBJNULL}, {"INTERNAL-TIME-UNITS-PER-SECOND", CL_CONSTANT, NULL, -1, OBJNULL}, {"INTERSECTION", CL_ORDINARY, ECL_NAME(cl_intersection), -1, OBJNULL}, {"INVOKE-DEBUGGER", CL_ORDINARY, NULL, -1, OBJNULL}, {"INVOKE-RESTART", CL_ORDINARY, ECL_NAME(cl_invoke_restart), -1, OBJNULL}, {"INVOKE-RESTART-INTERACTIVELY", CL_ORDINARY, ECL_NAME(cl_invoke_restart_interactively), 1, OBJNULL}, {"ISQRT", CL_ORDINARY, ECL_NAME(cl_isqrt), 1, OBJNULL}, {"KEYWORD", CL_ORDINARY, NULL, -1, OBJNULL}, {"KEYWORDP", CL_ORDINARY, cl_keywordp, 1, OBJNULL}, {"LABELS", CL_FORM, NULL, -1, OBJNULL}, {"LAMBDA", CL_FORM, NULL, -1, OBJNULL}, {"LAMBDA-LIST-KEYWORDS", CL_CONSTANT, NULL, -1, OBJNULL}, {"LAMBDA-PARAMETERS-LIMIT", CL_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_LAMBDA_PARAMETERS_LIMIT)}, {"LAST", CL_ORDINARY, cl_last, -1, OBJNULL}, {"LCM", CL_ORDINARY, cl_lcm, -1, OBJNULL}, {"LDB", CL_ORDINARY, ECL_NAME(cl_ldb), 2, OBJNULL}, {"LDB-TEST", CL_ORDINARY, ECL_NAME(cl_ldb_test), 2, OBJNULL}, {"LDIFF", CL_ORDINARY, cl_ldiff, 2, OBJNULL}, {"LEAST-NEGATIVE-DOUBLE-FLOAT", CL_CONSTANT, NULL, -1, ECL_LEAST_NEGATIVE_DOUBLE_FLOAT}, {"LEAST-NEGATIVE-LONG-FLOAT", CL_CONSTANT, NULL, -1, ECL_LEAST_NEGATIVE_LONG_FLOAT}, {"LEAST-NEGATIVE-NORMALIZED-DOUBLE-FLOAT", CL_CONSTANT, NULL, -1, ECL_LEAST_NEGATIVE_DOUBLE_FLOAT}, {"LEAST-NEGATIVE-NORMALIZED-LONG-FLOAT", CL_CONSTANT, NULL, -1, ECL_LEAST_NEGATIVE_LONG_FLOAT}, {"LEAST-NEGATIVE-NORMALIZED-SHORT-FLOAT", CL_CONSTANT, NULL, -1, ECL_LEAST_NEGATIVE_SHORT_FLOAT}, {"LEAST-NEGATIVE-NORMALIZED-SINGLE-FLOAT", CL_CONSTANT, NULL, -1, ECL_LEAST_NEGATIVE_SINGLE_FLOAT}, {"LEAST-NEGATIVE-SHORT-FLOAT", CL_CONSTANT, NULL, -1, ECL_LEAST_NEGATIVE_SHORT_FLOAT}, {"LEAST-NEGATIVE-SINGLE-FLOAT", CL_CONSTANT, NULL, -1, ECL_LEAST_NEGATIVE_SINGLE_FLOAT}, {"LEAST-POSITIVE-DOUBLE-FLOAT", CL_CONSTANT, NULL, -1, ECL_LEAST_POSITIVE_DOUBLE_FLOAT}, {"LEAST-POSITIVE-LONG-FLOAT", CL_CONSTANT, NULL, -1, ECL_LEAST_POSITIVE_LONG_FLOAT}, {"LEAST-POSITIVE-NORMALIZED-DOUBLE-FLOAT", CL_CONSTANT, NULL, -1, ECL_LEAST_POSITIVE_DOUBLE_FLOAT}, {"LEAST-POSITIVE-NORMALIZED-LONG-FLOAT", CL_CONSTANT, NULL, -1, ECL_LEAST_POSITIVE_LONG_FLOAT}, {"LEAST-POSITIVE-NORMALIZED-SHORT-FLOAT", CL_CONSTANT, NULL, -1, ECL_LEAST_POSITIVE_SHORT_FLOAT}, {"LEAST-POSITIVE-NORMALIZED-SINGLE-FLOAT", CL_CONSTANT, NULL, -1, ECL_LEAST_POSITIVE_SINGLE_FLOAT}, {"LEAST-POSITIVE-SHORT-FLOAT", CL_CONSTANT, NULL, -1, ECL_LEAST_POSITIVE_SHORT_FLOAT}, {"LEAST-POSITIVE-SINGLE-FLOAT", CL_CONSTANT, NULL, -1, ECL_LEAST_POSITIVE_SINGLE_FLOAT}, {"LENGTH", CL_ORDINARY, cl_length, 1, OBJNULL}, {"LET", CL_FORM, NULL, -1, OBJNULL}, {"LET*", CL_FORM, NULL, -1, OBJNULL}, {"LISP-IMPLEMENTATION-TYPE", CL_ORDINARY, ECL_NAME(cl_lisp_implementation_type), 0, OBJNULL}, {"LISP-IMPLEMENTATION-VERSION", CL_ORDINARY, ECL_NAME(cl_lisp_implementation_version), 0, OBJNULL}, {"LIST", CL_ORDINARY, cl_list, -1, OBJNULL}, {"LIST*", CL_ORDINARY, cl_listX, -1, OBJNULL}, {"LIST-ALL-PACKAGES", CL_ORDINARY, cl_list_all_packages, 0, OBJNULL}, {"LIST-LENGTH", CL_ORDINARY, cl_list_length, 1, OBJNULL}, {"LISTEN", CL_ORDINARY, cl_listen, -1, OBJNULL}, {"LISTP", CL_ORDINARY, cl_listp, 1, OBJNULL}, {"LOAD", CL_ORDINARY, cl_load, -1, OBJNULL}, {"LOAD-LOGICAL-PATHNAME-TRANSLATIONS", CL_ORDINARY, ECL_NAME(cl_load_logical_pathname_translations), 1, OBJNULL}, {"LOAD-TIME-VALUE", CL_FORM, NULL, -1, OBJNULL}, {"LOCALLY", CL_FORM, NULL, -1, OBJNULL}, {"LOG", CL_ORDINARY, cl_log, -1, OBJNULL}, {"LOGAND", CL_ORDINARY, cl_logand, -1, OBJNULL}, {"LOGANDC1", CL_ORDINARY, cl_logandc1, 2, OBJNULL}, {"LOGANDC2", CL_ORDINARY, cl_logandc2, 2, OBJNULL}, {"LOGBITP", CL_ORDINARY, cl_logbitp, 2, OBJNULL}, {"LOGCOUNT", CL_ORDINARY, cl_logcount, 1, OBJNULL}, {"LOGEQV", CL_ORDINARY, cl_logeqv, -1, OBJNULL}, {"LOGICAL-PATHNAME", CL_ORDINARY, cl_logical_pathname, 1, OBJNULL}, {"LOGICAL-PATHNAME-TRANSLATIONS", CL_ORDINARY, ECL_NAME(cl_logical_pathname_translations), 1, OBJNULL}, {"LOGIOR", CL_ORDINARY, cl_logior, -1, OBJNULL}, {"LOGNAND", CL_ORDINARY, cl_lognand, 2, OBJNULL}, {"LOGNOR", CL_ORDINARY, cl_lognor, 2, OBJNULL}, {"LOGNOT", CL_ORDINARY, cl_lognot, 1, OBJNULL}, {"LOGORC1", CL_ORDINARY, cl_logorc1, 2, OBJNULL}, {"LOGORC2", CL_ORDINARY, cl_logorc2, 2, OBJNULL}, {"LOGTEST", CL_ORDINARY, ECL_NAME(cl_logtest), 2, OBJNULL}, {"LOGXOR", CL_ORDINARY, cl_logxor, -1, OBJNULL}, {"LONG-FLOAT", CL_ORDINARY, NULL, -1, OBJNULL}, {"LONG-FLOAT-EPSILON", CL_CONSTANT, NULL, -1, OBJNULL}, {"LONG-FLOAT-NEGATIVE-EPSILON", CL_CONSTANT, NULL, -1, OBJNULL}, {"LONG-SITE-NAME", CL_ORDINARY, ECL_NAME(cl_long_site_name), 0, OBJNULL}, {"LOOP", CL_ORDINARY, NULL, -1, OBJNULL}, {"LOOP-FINISH", CL_ORDINARY, NULL, -1, OBJNULL}, {"LOWER-CASE-P", CL_ORDINARY, cl_lower_case_p, 1, OBJNULL}, {"MACHINE-INSTANCE", CL_ORDINARY, ECL_NAME(cl_machine_instance), 0, OBJNULL}, {"MACHINE-TYPE", CL_ORDINARY, ECL_NAME(cl_machine_type), 0, OBJNULL}, {"MACHINE-VERSION", CL_ORDINARY, ECL_NAME(cl_machine_version), 0, OBJNULL}, {"MACRO-FUNCTION", CL_ORDINARY, cl_macro_function, -1, OBJNULL}, {"MACROEXPAND", CL_ORDINARY, cl_macroexpand, -1, OBJNULL}, {"MACROEXPAND-1", CL_ORDINARY, cl_macroexpand_1, -1, OBJNULL}, {"MACROLET", CL_FORM, NULL, -1, OBJNULL}, {"MAKE-ARRAY", CL_ORDINARY, ECL_NAME(cl_make_array), -1, OBJNULL}, {"MAKE-BROADCAST-STREAM", CL_ORDINARY, cl_make_broadcast_stream, -1, OBJNULL}, {"MAKE-CONDITION", CL_ORDINARY, ECL_NAME(cl_make_condition), -1, OBJNULL}, {"MAKE-CONCATENATED-STREAM", CL_ORDINARY, cl_make_concatenated_stream, -1, OBJNULL}, {"MAKE-DISPATCH-MACRO-CHARACTER", CL_ORDINARY, cl_make_dispatch_macro_character, -1, OBJNULL}, {"MAKE-ECHO-STREAM", CL_ORDINARY, cl_make_echo_stream, 2, OBJNULL}, {"MAKE-HASH-TABLE", CL_ORDINARY, cl_make_hash_table, -1, OBJNULL}, {"MAKE-LIST", CL_ORDINARY, cl_make_list, -1, OBJNULL}, {"MAKE-PACKAGE", CL_ORDINARY, cl_make_package, -1, OBJNULL}, {"MAKE-PATHNAME", CL_ORDINARY, cl_make_pathname, -1, OBJNULL}, {"MAKE-RANDOM-STATE", CL_ORDINARY, cl_make_random_state, -1, OBJNULL}, {"MAKE-SEQUENCE", CL_ORDINARY, ECL_NAME(cl_make_sequence), -1, OBJNULL}, {"MAKE-STRING", CL_ORDINARY, cl_make_string, -1, OBJNULL}, {"MAKE-STRING-INPUT-STREAM", CL_ORDINARY, cl_make_string_input_stream, -1, OBJNULL}, {"MAKE-STRING-OUTPUT-STREAM", CL_ORDINARY, cl_make_string_output_stream, -1, OBJNULL}, {"MAKE-SYMBOL", CL_ORDINARY, cl_make_symbol, 1, OBJNULL}, {"MAKE-SYNONYM-STREAM", CL_ORDINARY, cl_make_synonym_stream, 1, OBJNULL}, {"MAKE-TWO-WAY-STREAM", CL_ORDINARY, cl_make_two_way_stream, 2, OBJNULL}, {"MAKUNBOUND", CL_ORDINARY, cl_makunbound, 1, OBJNULL}, {"MAP", CL_ORDINARY, ECL_NAME(cl_map), -1, OBJNULL}, {"MAP-INTO", CL_ORDINARY, ECL_NAME(cl_map_into), -1, OBJNULL}, {"MAPC", CL_ORDINARY, cl_mapc, -1, OBJNULL}, {"MAPCAN", CL_ORDINARY, cl_mapcan, -1, OBJNULL}, {"MAPCAR", CL_ORDINARY, cl_mapcar, -1, OBJNULL}, {"MAPCON", CL_ORDINARY, cl_mapcon, -1, OBJNULL}, {"MAPHASH", CL_ORDINARY, cl_maphash, 2, OBJNULL}, {"MAPL", CL_ORDINARY, cl_mapl, -1, OBJNULL}, {"MAPLIST", CL_ORDINARY, cl_maplist, -1, OBJNULL}, {"MASK-FIELD", CL_ORDINARY, ECL_NAME(cl_mask_field), 2, OBJNULL}, {"MAX", CL_ORDINARY, cl_max, -1, OBJNULL}, {"MEMBER", CL_ORDINARY, cl_member, -1, OBJNULL}, {"MEMBER-IF", CL_ORDINARY, ECL_NAME(cl_member_if), -1, OBJNULL}, {"MEMBER-IF-NOT", CL_ORDINARY, ECL_NAME(cl_member_if_not), -1, OBJNULL}, {"MERGE", CL_ORDINARY, ECL_NAME(cl_merge), -1, OBJNULL}, {"MERGE-PATHNAMES", CL_ORDINARY, cl_merge_pathnames, -1, OBJNULL}, {"MIN", CL_ORDINARY, cl_min, -1, OBJNULL}, {"MINUSP", CL_ORDINARY, cl_minusp, 1, OBJNULL}, {"MISMATCH", CL_ORDINARY, ECL_NAME(cl_mismatch), -1, OBJNULL}, {"MOD", CL_ORDINARY, cl_mod, 2, OBJNULL}, {"MOST-NEGATIVE-DOUBLE-FLOAT", CL_CONSTANT, NULL, -1, ECL_MOST_NEGATIVE_DOUBLE_FLOAT}, {"MOST-NEGATIVE-FIXNUM", CL_CONSTANT, NULL, -1, ecl_make_fixnum(MOST_NEGATIVE_FIXNUM)}, {"MOST-NEGATIVE-LONG-FLOAT", CL_CONSTANT, NULL, -1, ECL_MOST_NEGATIVE_LONG_FLOAT}, {"MOST-NEGATIVE-SHORT-FLOAT", CL_CONSTANT, NULL, -1, ECL_MOST_NEGATIVE_SHORT_FLOAT}, {"MOST-NEGATIVE-SINGLE-FLOAT", CL_CONSTANT, NULL, -1, ECL_MOST_NEGATIVE_SINGLE_FLOAT}, {"MOST-POSITIVE-DOUBLE-FLOAT", CL_CONSTANT, NULL, -1, ECL_MOST_POSITIVE_DOUBLE_FLOAT}, {"MOST-POSITIVE-FIXNUM", CL_CONSTANT, NULL, -1, ecl_make_fixnum(MOST_POSITIVE_FIXNUM)}, {"MOST-POSITIVE-LONG-FLOAT", CL_CONSTANT, NULL, -1, ECL_MOST_POSITIVE_LONG_FLOAT}, {"MOST-POSITIVE-SHORT-FLOAT", CL_CONSTANT, NULL, -1, ECL_MOST_POSITIVE_SHORT_FLOAT}, {"MOST-POSITIVE-SINGLE-FLOAT", CL_CONSTANT, NULL, -1, ECL_MOST_POSITIVE_SINGLE_FLOAT}, {"MUFFLE-WARNING", CL_ORDINARY, ECL_NAME(cl_muffle_warning), -1, OBJNULL}, {"MULTIPLE-VALUE-BIND", CL_FORM, NULL, -1, OBJNULL}, {"MULTIPLE-VALUE-CALL", CL_FORM, NULL, -1, OBJNULL}, {"MULTIPLE-VALUE-LIST", CL_FORM, NULL, -1, OBJNULL}, {"MULTIPLE-VALUE-PROG1", CL_FORM, NULL, -1, OBJNULL}, {"MULTIPLE-VALUE-SETQ", CL_FORM, NULL, -1, OBJNULL}, {"MULTIPLE-VALUES-LIMIT", CL_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_MULTIPLE_VALUES_LIMIT)}, {"NAME-CHAR", CL_ORDINARY, cl_name_char, 1, OBJNULL}, {"NAMESTRING", CL_ORDINARY, cl_namestring, 1, OBJNULL}, {"NBUTLAST", CL_ORDINARY, cl_nbutlast, -1, OBJNULL}, {"NCONC", CL_ORDINARY, cl_nconc, -1, OBJNULL}, {"NINTERSECTION", CL_ORDINARY, ECL_NAME(cl_nintersection), -1, OBJNULL}, {"NINTH", CL_ORDINARY, cl_ninth, 1, OBJNULL}, {"NOT", CL_ORDINARY, cl_not, 1, OBJNULL}, {"NOTANY", CL_ORDINARY, ECL_NAME(cl_notany), -1, OBJNULL}, {"NOTEVERY", CL_ORDINARY, ECL_NAME(cl_notevery), -1, OBJNULL}, {"NOTINLINE", CL_ORDINARY, NULL, -1, OBJNULL}, {"NRECONC", CL_ORDINARY, cl_nreconc, 2, OBJNULL}, {"NREVERSE", CL_ORDINARY, cl_nreverse, 1, OBJNULL}, {"NSET-DIFFERENCE", CL_ORDINARY, ECL_NAME(cl_nset_difference), -1, OBJNULL}, {"NSET-EXCLUSIVE-OR", CL_ORDINARY, ECL_NAME(cl_nset_exclusive_or), -1, OBJNULL}, {"NSTRING-CAPITALIZE", CL_ORDINARY, cl_nstring_capitalize, -1, OBJNULL}, {"NSTRING-DOWNCASE", CL_ORDINARY, cl_nstring_downcase, -1, OBJNULL}, {"NSTRING-UPCASE", CL_ORDINARY, cl_nstring_upcase, -1, OBJNULL}, {"NSUBLIS", CL_ORDINARY, cl_nsublis, -1, OBJNULL}, {"NSUBST", CL_ORDINARY, cl_nsubst, -1, OBJNULL}, {"NSUBST-IF", CL_ORDINARY, ECL_NAME(cl_nsubst_if), -1, OBJNULL}, {"NSUBST-IF-NOT", CL_ORDINARY, ECL_NAME(cl_nsubst_if_not), -1, OBJNULL}, {"NSUBSTITUTE", CL_ORDINARY, ECL_NAME(cl_nsubstitute), -1, OBJNULL}, {"NSUBSTITUTE-IF", CL_ORDINARY, ECL_NAME(cl_nsubstitute_if), -1, OBJNULL}, {"NSUBSTITUTE-IF-NOT", CL_ORDINARY, ECL_NAME(cl_nsubstitute_if_not), -1, OBJNULL}, {"NTH", CL_ORDINARY, cl_nth, 2, OBJNULL}, {"NTH-VALUE", CL_FORM, NULL, -1, OBJNULL}, {"NTHCDR", CL_ORDINARY, cl_nthcdr, 2, OBJNULL}, {"NULL", CL_ORDINARY, cl_null, 1, OBJNULL}, {"NUMBER", CL_ORDINARY, NULL, -1, OBJNULL}, {"NUMBERP", CL_ORDINARY, cl_numberp, 1, OBJNULL}, {"NUMERATOR", CL_ORDINARY, cl_numerator, 1, OBJNULL}, {"NUNION", CL_ORDINARY, ECL_NAME(cl_nunion), -1, OBJNULL}, {"ODDP", CL_ORDINARY, cl_oddp, 1, OBJNULL}, {"OPEN", CL_ORDINARY, cl_open, -1, OBJNULL}, {"OPEN-STREAM-P", CL_ORDINARY, cl_open_stream_p, 1, OBJNULL}, {"OPTIMIZE", CL_ORDINARY, NULL, -1, OBJNULL}, {"OR", CL_ORDINARY, NULL, -1, OBJNULL}, {"OTHERWISE", CL_ORDINARY, NULL, -1, OBJNULL}, {"OUTPUT-STREAM-P", CL_ORDINARY, cl_output_stream_p, 1, OBJNULL}, {"PACKAGE", CL_ORDINARY, NULL, -1, OBJNULL}, {"PACKAGE-ERROR", CL_ORDINARY, NULL, -1, OBJNULL}, {"PACKAGE-ERROR-PACKAGE", CL_ORDINARY, NULL, -1, OBJNULL}, {"PACKAGE-NAME", CL_ORDINARY, cl_package_name, 1, OBJNULL}, {"PACKAGE-NICKNAMES", CL_ORDINARY, cl_package_nicknames, 1, OBJNULL}, {"PACKAGE-SHADOWING-SYMBOLS", CL_ORDINARY, cl_package_shadowing_symbols, 1, OBJNULL}, {"PACKAGE-USE-LIST", CL_ORDINARY, cl_package_use_list, 1, OBJNULL}, {"PACKAGE-USED-BY-LIST", CL_ORDINARY, cl_package_used_by_list, 1, OBJNULL}, {"PACKAGEP", CL_ORDINARY, cl_packagep, 1, OBJNULL}, {"PAIRLIS", CL_ORDINARY, cl_pairlis, -1, OBJNULL}, {"PARSE-ERROR", CL_ORDINARY, NULL, -1, OBJNULL}, {"PARSE-INTEGER", CL_ORDINARY, cl_parse_integer, -1, OBJNULL}, {"PARSE-NAMESTRING", CL_ORDINARY, cl_parse_namestring, -1, OBJNULL}, {"PATHNAME", CL_ORDINARY, cl_pathname, 1, OBJNULL}, {"PATHNAME-DEVICE", CL_ORDINARY, cl_pathname_device, -1, OBJNULL}, {"PATHNAME-DIRECTORY", CL_ORDINARY, cl_pathname_directory, -1, OBJNULL}, {"PATHNAME-HOST", CL_ORDINARY, cl_pathname_host, -1, OBJNULL}, {"PATHNAME-MATCH-P", CL_ORDINARY, cl_pathname_match_p, 2, OBJNULL}, {"PATHNAME-NAME", CL_ORDINARY, cl_pathname_name, -1, OBJNULL}, {"PATHNAME-TYPE", CL_ORDINARY, cl_pathname_type, -1, OBJNULL}, {"PATHNAME-VERSION", CL_ORDINARY, cl_pathname_version, 1, OBJNULL}, {"PATHNAMEP", CL_ORDINARY, cl_pathnamep, 1, OBJNULL}, {"PEEK-CHAR", CL_ORDINARY, cl_peek_char, -1, OBJNULL}, {"PHASE", CL_ORDINARY, ECL_NAME(cl_phase), 1, OBJNULL}, {"PI", CL_CONSTANT, NULL, -1, ECL_PI}, {"PLUSP", CL_ORDINARY, cl_plusp, 1, OBJNULL}, {"POP", CL_ORDINARY, NULL, -1, OBJNULL}, {"POSITION", CL_ORDINARY, ECL_NAME(cl_position), -1, OBJNULL}, {"POSITION-IF", CL_ORDINARY, ECL_NAME(cl_position_if), -1, OBJNULL}, {"POSITION-IF-NOT", CL_ORDINARY, ECL_NAME(cl_position_if_not), -1, OBJNULL}, {"PPRINT", CL_ORDINARY, cl_pprint, -1, OBJNULL}, {"PPRINT-DISPATCH", CL_ORDINARY, ECL_NAME_PPRINT(cl_pprint_dispatch), -1, OBJNULL}, {"PPRINT-EXIT-IF-LIST-EXHAUSTED", CL_ORDINARY, NULL, -1, OBJNULL}, {"PPRINT-FILL", CL_ORDINARY, ECL_NAME_PPRINT(cl_pprint_fill), -1, OBJNULL}, {"PPRINT-INDENT", CL_ORDINARY, ECL_NAME_PPRINT(cl_pprint_indent), -1, OBJNULL}, {"PPRINT-LINEAR", CL_ORDINARY, ECL_NAME_PPRINT(cl_pprint_linear), -1, OBJNULL}, {"PPRINT-LOGICAL-BLOCK", CL_ORDINARY, NULL, -1, OBJNULL}, {"PPRINT-NEWLINE", CL_ORDINARY, ECL_NAME_PPRINT(cl_pprint_newline), -1, OBJNULL}, {"PPRINT-POP", CL_ORDINARY, NULL, -1, OBJNULL}, {"PPRINT-TAB", CL_ORDINARY, ECL_NAME_PPRINT(cl_pprint_tab), -1, OBJNULL}, {"PPRINT-TABULAR", CL_ORDINARY, ECL_NAME_PPRINT(cl_pprint_tabular), -1, OBJNULL}, {"PRIN1", CL_ORDINARY, cl_prin1, -1, OBJNULL}, {"PRIN1-TO-STRING", CL_ORDINARY, ECL_NAME(cl_prin1_to_string), 1, OBJNULL}, {"PRINC", CL_ORDINARY, cl_princ, -1, OBJNULL}, {"PRINC-TO-STRING", CL_ORDINARY, ECL_NAME(cl_princ_to_string), 1, OBJNULL}, {"PRINT", CL_ORDINARY, cl_print, -1, OBJNULL}, {"PRINT-NOT-READABLE", CL_ORDINARY, NULL, -1, OBJNULL}, {"PRINT-NOT-READABLE-OBJECT", CL_ORDINARY, NULL, -1, OBJNULL}, {"PROBE-FILE", CL_ORDINARY, cl_probe_file, 1, OBJNULL}, {"PROCLAIM", CL_ORDINARY, NULL, -1, OBJNULL}, {"PROG", CL_FORM, NULL, -1, OBJNULL}, {"PROG*", CL_FORM, NULL, -1, OBJNULL}, {"PROG1", CL_FORM, NULL, -1, OBJNULL}, {"PROG2", CL_FORM, NULL, -1, OBJNULL}, {"PROGN", CL_FORM, NULL, -1, OBJNULL}, {"PROGRAM-ERROR", CL_ORDINARY, NULL, -1, OBJNULL}, {"PROGV", CL_FORM, NULL, -1, OBJNULL}, {"PROVIDE", CL_ORDINARY, ECL_NAME(cl_provide), 1, OBJNULL}, {"PSETF", CL_ORDINARY, NULL, -1, OBJNULL}, {"PSETQ", CL_FORM, NULL, -1, OBJNULL}, {"PUSH", CL_ORDINARY, NULL, -1, OBJNULL}, {"PUSHNEW", CL_ORDINARY, NULL, -1, OBJNULL}, {"QUOTE", CL_FORM, NULL, -1, OBJNULL}, {"RANDOM", CL_ORDINARY, cl_random, -1, OBJNULL}, {"RANDOM-STATE", CL_ORDINARY, NULL, -1, OBJNULL}, {"RANDOM-STATE-P", CL_ORDINARY, cl_random_state_p, 1, OBJNULL}, {"RASSOC", CL_ORDINARY, cl_rassoc, -1, OBJNULL}, {"RASSOC-IF", CL_ORDINARY, ECL_NAME(cl_rassoc_if), -1, OBJNULL}, {"RASSOC-IF-NOT", CL_ORDINARY, ECL_NAME(cl_rassoc_if_not), -1, OBJNULL}, {"RATIO", CL_ORDINARY, NULL, -1, OBJNULL}, {"RATIONAL", CL_ORDINARY, cl_rational, 1, OBJNULL}, {"RATIONALIZE", CL_ORDINARY, cl_rationalize, 1, OBJNULL}, {"RATIONALP", CL_ORDINARY, cl_rationalp, 1, OBJNULL}, {"READ", CL_ORDINARY, cl_read, -1, OBJNULL}, {"READ-BYTE", CL_ORDINARY, cl_read_byte, -1, OBJNULL}, {"READ-CHAR", CL_ORDINARY, cl_read_char, -1, OBJNULL}, {"READ-CHAR-NO-HANG", CL_ORDINARY, cl_read_char_no_hang, -1, OBJNULL}, {"READ-DELIMITED-LIST", CL_ORDINARY, cl_read_delimited_list, -1, OBJNULL}, {"READ-FROM-STRING", CL_ORDINARY, ECL_NAME(cl_read_from_string), -1, OBJNULL}, {"READ-LINE", CL_ORDINARY, cl_read_line, -1, OBJNULL}, {"READ-PRESERVING-WHITESPACE", CL_ORDINARY, cl_read_preserving_whitespace, -1, OBJNULL}, {"READ-SEQUENCE", CL_ORDINARY, cl_read_sequence, -1, OBJNULL}, {"READER-ERROR", CL_ORDINARY, NULL, -1, OBJNULL}, {"READTABLE", CL_ORDINARY, NULL, -1, OBJNULL}, {"READTABLE-CASE", CL_ORDINARY, cl_readtable_case, 1, OBJNULL}, {"READTABLEP", CL_ORDINARY, cl_readtablep, 1, OBJNULL}, {"REAL", CL_ORDINARY, NULL, -1, OBJNULL}, {"REALP", CL_ORDINARY, cl_realp, 1, OBJNULL}, {"REALPART", CL_ORDINARY, cl_realpart, 1, OBJNULL}, {"REDUCE", CL_ORDINARY, ECL_NAME(cl_reduce), -1, OBJNULL}, {"REM", CL_ORDINARY, cl_rem, 2, OBJNULL}, {"REMF", CL_ORDINARY, NULL, -1, OBJNULL}, {"REMHASH", CL_ORDINARY, cl_remhash, 2, OBJNULL}, {"REMOVE", CL_ORDINARY, ECL_NAME(cl_remove), -1, OBJNULL}, {"REMOVE-DUPLICATES", CL_ORDINARY, ECL_NAME(cl_remove_duplicates), -1, OBJNULL}, {"REMOVE-IF", CL_ORDINARY, ECL_NAME(cl_remove_if), -1, OBJNULL}, {"REMOVE-IF-NOT", CL_ORDINARY, ECL_NAME(cl_remove_if_not), -1, OBJNULL}, {"REMPROP", CL_ORDINARY, cl_remprop, 2, OBJNULL}, {"RENAME-FILE", CL_ORDINARY, cl_rename_file, -1, OBJNULL}, {"RENAME-PACKAGE", CL_ORDINARY, cl_rename_package, -1, OBJNULL}, {"REPLACE", CL_ORDINARY, ECL_NAME(cl_replace), -1, OBJNULL}, {"REQUIRE", CL_ORDINARY, ECL_NAME(cl_require), -1, OBJNULL}, {"REST", CL_ORDINARY, cl_cdr, 1, OBJNULL}, {"RESTART", CL_ORDINARY, NULL, 1, OBJNULL}, {"RESTART-BIND", CL_ORDINARY, NULL, 1, OBJNULL}, {"RESTART-CASE", CL_ORDINARY, NULL, 1, OBJNULL}, {"RESTART-NAME", CL_ORDINARY, NULL, 1, OBJNULL}, {"RETURN", CL_FORM, NULL, -1, OBJNULL}, {"RETURN-FROM", CL_FORM, NULL, -1, OBJNULL}, {"REVAPPEND", CL_ORDINARY, cl_revappend, 2, OBJNULL}, {"REVERSE", CL_ORDINARY, cl_reverse, 1, OBJNULL}, {"ROOM", CL_ORDINARY, NULL, -1, OBJNULL}, {"ROTATEF", CL_ORDINARY, NULL, -1, OBJNULL}, {"ROUND", CL_ORDINARY, cl_round, -1, OBJNULL}, {"ROW-MAJOR-AREF", CL_ORDINARY, cl_row_major_aref, 2, OBJNULL}, {"RPLACA", CL_ORDINARY, cl_rplaca, 2, OBJNULL}, {"RPLACD", CL_ORDINARY, cl_rplacd, 2, OBJNULL}, {"SAFETY", CL_ORDINARY, NULL, -1, OBJNULL}, {"SATISFIES", CL_ORDINARY, NULL, -1, OBJNULL}, {"SBIT", CL_ORDINARY, ECL_NAME(cl_sbit), -1, OBJNULL}, {"SCALE-FLOAT", CL_ORDINARY, cl_scale_float, 2, OBJNULL}, {"SCHAR", CL_ORDINARY, cl_char, 2, OBJNULL}, {"SEARCH", CL_ORDINARY, ECL_NAME(cl_search), -1, OBJNULL}, {"SECOND", CL_ORDINARY, cl_cadr, 1, OBJNULL}, {"SEQUENCE", CL_ORDINARY, NULL, -1, OBJNULL}, {"SERIOUS-CONDITION", CL_ORDINARY, NULL, -1, OBJNULL}, {"SET", CL_ORDINARY, cl_set, 2, OBJNULL}, {"SET-DIFFERENCE", CL_ORDINARY, ECL_NAME(cl_set_difference), -1, OBJNULL}, {"SET-DISPATCH-MACRO-CHARACTER", CL_ORDINARY, cl_set_dispatch_macro_character, -1, OBJNULL}, {"SET-EXCLUSIVE-OR", CL_ORDINARY, ECL_NAME(cl_set_exclusive_or), -1, OBJNULL}, {"SET-MACRO-CHARACTER", CL_ORDINARY, cl_set_macro_character, -1, OBJNULL}, {"SET-PPRINT-DISPATCH", CL_ORDINARY, ECL_NAME_PPRINT(cl_set_pprint_dispatch), -1, OBJNULL}, {"SET-SYNTAX-FROM-CHAR", CL_ORDINARY, cl_set_syntax_from_char, -1, OBJNULL}, {"SETF", CL_ORDINARY, NULL, -1, OBJNULL}, {"SETQ", CL_FORM, NULL, -1, OBJNULL}, {"SEVENTH", CL_ORDINARY, cl_seventh, 1, OBJNULL}, {"SHADOW", CL_ORDINARY, cl_shadow, -1, OBJNULL}, {"SHADOWING-IMPORT", CL_ORDINARY, cl_shadowing_import, -1, OBJNULL}, {"SHIFTF", CL_ORDINARY, NULL, -1, OBJNULL}, {"SHORT-FLOAT", CL_ORDINARY, NULL, -1, OBJNULL}, {"SHORT-FLOAT-EPSILON", CL_CONSTANT, NULL, -1, OBJNULL}, {"SHORT-FLOAT-NEGATIVE-EPSILON", CL_CONSTANT, NULL, -1, OBJNULL}, {"SHORT-SITE-NAME", CL_ORDINARY, ECL_NAME(cl_short_site_name), 0, OBJNULL}, {"SIGNAL", CL_ORDINARY, NULL, -1, OBJNULL}, {"SIGNED-BYTE", CL_ORDINARY, NULL, -1, OBJNULL}, {"SIGNUM", CL_ORDINARY, ECL_NAME(cl_signum), 1, OBJNULL}, {"SIMPLE-ARRAY", CL_ORDINARY, NULL, -1, OBJNULL}, {"SIMPLE-BASE-STRING", CL_ORDINARY, NULL, -1, OBJNULL}, {"SIMPLE-BIT-VECTOR", CL_ORDINARY, NULL, -1, OBJNULL}, {"SIMPLE-BIT-VECTOR-P", CL_ORDINARY, cl_simple_bit_vector_p, 1, OBJNULL}, {"SIMPLE-CONDITION", CL_ORDINARY, NULL, -1, OBJNULL}, {"SIMPLE-CONDITION-FORMAT-CONTROL", CL_ORDINARY, NULL, -1, OBJNULL}, {"SIMPLE-CONDITION-FORMAT-ARGUMENTS", CL_ORDINARY, NULL, -1, OBJNULL}, {"SIMPLE-ERROR", CL_ORDINARY, NULL, -1, OBJNULL}, {"SIMPLE-STRING", CL_ORDINARY, NULL, -1, OBJNULL}, {"SIMPLE-STRING-P", CL_ORDINARY, cl_simple_string_p, 1, OBJNULL}, {"SIMPLE-TYPE-ERROR", CL_ORDINARY, NULL, -1, OBJNULL}, {"SIMPLE-VECTOR", CL_ORDINARY, NULL, -1, OBJNULL}, {"SIMPLE-VECTOR-P", CL_ORDINARY, cl_simple_vector_p, 1, OBJNULL}, {"SIMPLE-WARNING", CL_ORDINARY, NULL, -1, OBJNULL}, {"SIN", CL_ORDINARY, cl_sin, 1, OBJNULL}, {"SINGLE-FLOAT", CL_ORDINARY, NULL, -1, OBJNULL}, {"SINGLE-FLOAT-EPSILON", CL_CONSTANT, NULL, -1, OBJNULL}, {"SINGLE-FLOAT-NEGATIVE-EPSILON", CL_CONSTANT, NULL, -1, OBJNULL}, {"SINH", CL_ORDINARY, cl_sinh, 1, OBJNULL}, {"SIXTH", CL_ORDINARY, cl_sixth, 1, OBJNULL}, {"SLEEP", CL_ORDINARY, cl_sleep, 1, OBJNULL}, {"SOFTWARE-TYPE", CL_ORDINARY, ECL_NAME(cl_software_type), 0, OBJNULL}, {"SOFTWARE-VERSION", CL_ORDINARY, ECL_NAME(cl_software_version), 0, OBJNULL}, {"SOME", CL_ORDINARY, ECL_NAME(cl_some), -1, OBJNULL}, {"SORT", CL_ORDINARY, ECL_NAME(cl_sort), -1, OBJNULL}, {"SPACE", CL_ORDINARY, NULL, -1, OBJNULL}, {"SPECIAL", CL_ORDINARY, NULL, -1, OBJNULL}, {"SPECIAL-OPERATOR-P", CL_ORDINARY, cl_special_operator_p, 1, OBJNULL}, {"SPEED", CL_ORDINARY, NULL, -1, OBJNULL}, {"SQRT", CL_ORDINARY, cl_sqrt, 1, OBJNULL}, {"STABLE-SORT", CL_ORDINARY, ECL_NAME(cl_stable_sort), -1, OBJNULL}, {"STANDARD-CHAR", CL_ORDINARY, NULL, -1, OBJNULL}, {"STANDARD-CHAR-P", CL_ORDINARY, cl_standard_char_p, 1, OBJNULL}, {"STEP", CL_ORDINARY, NULL, -1, OBJNULL}, {"STORAGE-CONDITION", CL_ORDINARY, NULL, -1, OBJNULL}, {"STORE-VALUE", CL_ORDINARY, ECL_NAME(cl_store_value), -1, OBJNULL}, {"STREAM", CL_ORDINARY, NULL, -1, OBJNULL}, {"STREAM-ELEMENT-TYPE", CL_ORDINARY, cl_stream_element_type, 1, OBJNULL}, {"STREAM-ERROR", CL_ORDINARY, NULL, -1, OBJNULL}, {"STREAM-ERROR-STREAM", CL_ORDINARY, NULL, -1, OBJNULL}, {"STREAM-EXTERNAL-FORMAT", CL_ORDINARY, cl_stream_external_format, 1, OBJNULL}, {"STREAMP", CL_ORDINARY, cl_streamp, 1, OBJNULL}, {"STRING", CL_ORDINARY, cl_string, 1, OBJNULL}, {"STRING-DOWNCASE", CL_ORDINARY, cl_string_downcase, -1, OBJNULL}, {"STRING-CAPITALIZE", CL_ORDINARY, cl_string_capitalize, -1, OBJNULL}, {"STRING-EQUAL", CL_ORDINARY, cl_string_equal, -1, OBJNULL}, {"STRING-GREATERP", CL_ORDINARY, cl_string_greaterp, -1, OBJNULL}, {"STRING-LEFT-TRIM", CL_ORDINARY, cl_string_left_trim, 2, OBJNULL}, {"STRING-LESSP", CL_ORDINARY, cl_string_lessp, -1, OBJNULL}, {"STRING-NOT-EQUAL", CL_ORDINARY, cl_string_not_equal, -1, OBJNULL}, {"STRING-NOT-GREATERP", CL_ORDINARY, cl_string_not_greaterp, -1, OBJNULL}, {"STRING-NOT-LESSP", CL_ORDINARY, cl_string_not_lessp, -1, OBJNULL}, {"STRING-RIGHT-TRIM", CL_ORDINARY, cl_string_right_trim, 2, OBJNULL}, {"STRING-STREAM", CL_ORDINARY, NULL, -1, OBJNULL}, {"STRING-TRIM", CL_ORDINARY, cl_string_trim, 2, OBJNULL}, {"STRING-UPCASE", CL_ORDINARY, cl_string_upcase, -1, OBJNULL}, {"STRING/=", CL_ORDINARY, cl_stringNE, -1, OBJNULL}, {"STRING<", CL_ORDINARY, cl_stringL, -1, OBJNULL}, {"STRING<=", CL_ORDINARY, cl_stringLE, -1, OBJNULL}, {"STRING=", CL_ORDINARY, cl_stringE, -1, OBJNULL}, {"STRING>", CL_ORDINARY, cl_stringG, -1, OBJNULL}, {"STRING>=", CL_ORDINARY, cl_stringGE, -1, OBJNULL}, {"STRINGP", CL_ORDINARY, cl_stringp, 1, OBJNULL}, {"STRUCTURE", CL_ORDINARY, NULL, -1, OBJNULL}, {"STYLE-WARNING", CL_ORDINARY, NULL, -1, OBJNULL}, {"SUBLIS", CL_ORDINARY, cl_sublis, -1, OBJNULL}, {"SUBSEQ", CL_ORDINARY, cl_subseq, -1, OBJNULL}, {"SUBSETP", CL_ORDINARY, ECL_NAME(cl_subsetp), -1, OBJNULL}, {"SUBST", CL_ORDINARY, cl_subst, -1, OBJNULL}, {"SUBST-IF", CL_ORDINARY, ECL_NAME(cl_subst_if), -1, OBJNULL}, {"SUBST-IF-NOT", CL_ORDINARY, ECL_NAME(cl_subst_if_not), -1, OBJNULL}, {"SUBSTITUTE", CL_ORDINARY, ECL_NAME(cl_substitute), -1, OBJNULL}, {"SUBSTITUTE-IF", CL_ORDINARY, ECL_NAME(cl_substitute_if), -1, OBJNULL}, {"SUBSTITUTE-IF-NOT", CL_ORDINARY, ECL_NAME(cl_substitute_if_not), -1, OBJNULL}, {"SUBTYPEP", CL_ORDINARY, ECL_NAME(cl_subtypep), -1, OBJNULL}, {"SVREF", CL_ORDINARY, cl_svref, 2, OBJNULL}, {"SXHASH", CL_ORDINARY, cl_sxhash, 1, OBJNULL}, {"SYMBOL", CL_ORDINARY, NULL, -1, OBJNULL}, {"SYMBOL-FUNCTION", CL_ORDINARY, cl_symbol_function, 1, OBJNULL}, {"SYMBOL-MACROLET", CL_FORM, NULL, -1, OBJNULL}, {"SYMBOL-NAME", CL_ORDINARY, cl_symbol_name, 1, OBJNULL}, {"SYMBOL-PACKAGE", CL_ORDINARY, cl_symbol_package, 1, OBJNULL}, {"SYMBOL-PLIST", CL_ORDINARY, cl_symbol_plist, 1, OBJNULL}, {"SYMBOL-VALUE", CL_ORDINARY, cl_symbol_value, 1, OBJNULL}, {"SYMBOLP", CL_ORDINARY, cl_symbolp, 1, OBJNULL}, {"SYNONYM-STREAM", CL_ORDINARY, NULL, -1, OBJNULL}, {"SYNONYM-STREAM-SYMBOL", CL_ORDINARY, cl_synonym_stream_symbol, 1, OBJNULL}, {"TAGBODY", CL_FORM, NULL, -1, OBJNULL}, {"TAILP", CL_ORDINARY, cl_tailp, 2, OBJNULL}, {"TAN", CL_ORDINARY, cl_tan, 1, OBJNULL}, {"TANH", CL_ORDINARY, cl_tanh, 1, OBJNULL}, {"TENTH", CL_ORDINARY, cl_tenth, 1, OBJNULL}, {"TERPRI", CL_ORDINARY, cl_terpri, -1, OBJNULL}, {"THE", CL_FORM, NULL, -1, OBJNULL}, {"THIRD", CL_ORDINARY, cl_caddr, 1, OBJNULL}, {"THROW", CL_FORM, NULL, -1, OBJNULL}, {"TIME", CL_ORDINARY, NULL, -1, OBJNULL}, {"TRACE", CL_ORDINARY, NULL, -1, OBJNULL}, {"TRANSLATE-LOGICAL-PATHNAME", CL_ORDINARY, cl_translate_logical_pathname, -1, OBJNULL}, {"TRANSLATE-PATHNAME", CL_ORDINARY, cl_translate_pathname, -1, OBJNULL}, {"TREE-EQUAL", CL_ORDINARY, cl_tree_equal, -1, OBJNULL}, {"TRUENAME", CL_ORDINARY, cl_truename, 1, OBJNULL}, {"TRUNCATE", CL_ORDINARY, cl_truncate, -1, OBJNULL}, {"TWO-WAY-STREAM", CL_ORDINARY, NULL, -1, OBJNULL}, {"TWO-WAY-STREAM-INPUT-STREAM", CL_ORDINARY, cl_two_way_stream_input_stream, 1, OBJNULL}, {"TWO-WAY-STREAM-OUTPUT-STREAM", CL_ORDINARY, cl_two_way_stream_output_stream, 1, OBJNULL}, {"TYPE", CL_ORDINARY, NULL, -1, OBJNULL}, {"TYPE-ERROR", CL_ORDINARY, NULL, -1, OBJNULL}, {"TYPE-ERROR-DATUM", CL_ORDINARY, NULL, -1, OBJNULL}, {"TYPE-ERROR-EXPECTED-TYPE", CL_ORDINARY, NULL, -1, OBJNULL}, {"TYPE-OF", CL_ORDINARY, cl_type_of, 1, OBJNULL}, {"TYPECASE", CL_ORDINARY, NULL, -1, OBJNULL}, {"TYPEP", CL_ORDINARY, ECL_NAME(cl_typep), -1, OBJNULL}, {"UNBOUND-SLOT", CL_ORDINARY, NULL, -1, OBJNULL}, {"UNBOUND-SLOT-INSTANCE", CL_ORDINARY, NULL, -1, OBJNULL}, {"UNBOUND-VARIABLE", CL_ORDINARY, NULL, -1, OBJNULL}, {"UNDEFINED-FUNCTION", CL_ORDINARY, NULL, -1, OBJNULL}, {"UNEXPORT", CL_ORDINARY, cl_unexport, -1, OBJNULL}, {"UNINTERN", CL_ORDINARY, cl_unintern, -1, OBJNULL}, {"UNION", CL_ORDINARY, ECL_NAME(cl_union), -1, OBJNULL}, {"UNLESS", CL_FORM, NULL, -1, OBJNULL}, {"UNREAD-CHAR", CL_ORDINARY, cl_unread_char, -1, OBJNULL}, {"UNSIGNED-BYTE", CL_ORDINARY, NULL, -1, OBJNULL}, {"UNTRACE", CL_ORDINARY, NULL, -1, OBJNULL}, {"UNUSE-PACKAGE", CL_ORDINARY, cl_unuse_package, -1, OBJNULL}, {"UNWIND-PROTECT", CL_FORM, NULL, -1, OBJNULL}, {"UPGRADED-ARRAY-ELEMENT-TYPE", CL_ORDINARY, ECL_NAME(cl_upgraded_array_element_type), -1, OBJNULL}, {"UPGRADED-COMPLEX-PART-TYPE", CL_ORDINARY, ECL_NAME(cl_upgraded_complex_part_type), -1, OBJNULL}, {"UPPER-CASE-P", CL_ORDINARY, cl_upper_case_p, 1, OBJNULL}, {"USE-PACKAGE", CL_ORDINARY, cl_use_package, -1, OBJNULL}, {"USE-VALUE", CL_ORDINARY, ECL_NAME(cl_use_value), -1, OBJNULL}, {"USER-HOMEDIR-PATHNAME", CL_ORDINARY, cl_user_homedir_pathname, -1, OBJNULL}, {"VALUES", CL_ORDINARY, cl_values, -1, OBJNULL}, {"VALUES-LIST", CL_ORDINARY, cl_values_list, 1, OBJNULL}, {"VARIABLE", CL_ORDINARY, NULL, -1, OBJNULL}, {"VECTOR", CL_ORDINARY, ECL_NAME(cl_vector), -1, OBJNULL}, {"VECTOR-POP", CL_ORDINARY, ECL_NAME(cl_vector_pop), 1, OBJNULL}, {"VECTOR-PUSH", CL_ORDINARY, cl_vector_push, 2, OBJNULL}, {"VECTOR-PUSH-EXTEND", CL_ORDINARY, cl_vector_push_extend, -1, OBJNULL}, {"VECTORP", CL_ORDINARY, cl_vectorp, 1, OBJNULL}, {"WARN", CL_ORDINARY, NULL, -1, OBJNULL}, {"WARNING", CL_ORDINARY, NULL, -1, OBJNULL}, {"WHEN", CL_FORM, NULL, -1, OBJNULL}, {"WILD-PATHNAME-P", CL_ORDINARY, cl_wild_pathname_p, -1, OBJNULL}, {"WITH-COMPILATION-UNIT", CL_ORDINARY, NULL, -1, OBJNULL}, {"WITH-CONDITION-RESTARTS", CL_ORDINARY, NULL, -1, OBJNULL}, {"WITH-HASH-TABLE-ITERATOR", CL_ORDINARY, NULL, -1, OBJNULL}, {"WITH-INPUT-FROM-STRING", CL_ORDINARY, NULL, -1, OBJNULL}, {"WITH-OPEN-FILE", CL_ORDINARY, NULL, -1, OBJNULL}, {"WITH-OPEN-STREAM", CL_ORDINARY, NULL, -1, OBJNULL}, {"WITH-OUTPUT-TO-STRING", CL_ORDINARY, NULL, -1, OBJNULL}, {"WITH-PACKAGE-ITERATOR", CL_ORDINARY, NULL, -1, OBJNULL}, {"WITH-SIMPLE-RESTART", CL_ORDINARY, NULL, -1, OBJNULL}, {"WITH-STANDARD-IO-SYNTAX", CL_ORDINARY, NULL, -1, OBJNULL}, {"WRITE", CL_ORDINARY, cl_write, -1, OBJNULL}, {"WRITE-BYTE", CL_ORDINARY, cl_write_byte, 2, OBJNULL}, {"WRITE-CHAR", CL_ORDINARY, cl_write_char, -1, OBJNULL}, {"WRITE-LINE", CL_ORDINARY, cl_write_line, -1, OBJNULL}, {"WRITE-SEQUENCE", CL_ORDINARY, cl_write_sequence, -1, OBJNULL}, {"WRITE-STRING", CL_ORDINARY, cl_write_string, -1, OBJNULL}, {"WRITE-TO-STRING", CL_ORDINARY, ECL_NAME(cl_write_to_string), -1, OBJNULL}, {"Y-OR-N-P", CL_ORDINARY, ECL_NAME(cl_y_or_n_p), -1, OBJNULL}, {"YES-OR-NO-P", CL_ORDINARY, ECL_NAME(cl_yes_or_no_p), -1, OBJNULL}, {"ZEROP", CL_ORDINARY, cl_zerop, 1, OBJNULL}, {"ALLOCATE-INSTANCE", CL_ORDINARY, NULL, 2, OBJNULL}, {"ADD-METHOD", CL_ORDINARY, NULL, -1, OBJNULL}, {"BUILT-IN-CLASS", CL_ORDINARY, NULL, -1, OBJNULL}, {"CALL-METHOD", CL_ORDINARY, NULL, -1, OBJNULL}, {"CALL-NEXT-METHOD", CL_ORDINARY, NULL, -1, OBJNULL}, {"CHANGE-CLASS", CL_ORDINARY, NULL, -1, OBJNULL}, {"CLASS", CL_ORDINARY, NULL, -1, OBJNULL}, {"CLASS-NAME", CL_ORDINARY, NULL, -1, OBJNULL}, {"CLASS-OF", CL_ORDINARY, cl_class_of, 1, OBJNULL}, {"COMPUTE-APPLICABLE-METHODS", CL_ORDINARY, NULL, -1, OBJNULL}, {"DEFCLASS", CL_ORDINARY, NULL, -1, OBJNULL}, {"DEFGENERIC", CL_ORDINARY, NULL, -1, OBJNULL}, {"DEFINE-METHOD-COMBINATION", CL_ORDINARY, NULL, -1, OBJNULL}, {"DEFMETHOD", CL_ORDINARY, NULL, -1, OBJNULL}, {"DESCRIBE-OBJECT", CL_ORDINARY, NULL, -1, OBJNULL}, {"ENSURE-GENERIC-FUNCTION", CL_ORDINARY, NULL, -1, OBJNULL}, {"FIND-CLASS", CL_ORDINARY, cl_find_class, -1, OBJNULL}, {"FIND-METHOD", CL_ORDINARY, NULL, -1, OBJNULL}, {"GENERIC-FUNCTION", CL_ORDINARY, NULL, -1, OBJNULL}, {"IF", CL_FORM, NULL, -1, OBJNULL}, {"INITIALIZE-INSTANCE", CL_ORDINARY, NULL, -1, OBJNULL}, {"INVALID-METHOD-ERROR", CL_ORDINARY, ECL_NAME(cl_invalid_method_error), -1, OBJNULL}, {"MAKE-INSTANCE", CL_ORDINARY, NULL, -1, OBJNULL}, {"MAKE-INSTANCES-OBSOLETE", CL_ORDINARY, NULL, -1, OBJNULL}, {"MAKE-LOAD-FORM", CL_ORDINARY, NULL, -1, OBJNULL}, {"MAKE-LOAD-FORM-SAVING-SLOTS", CL_ORDINARY, NULL, -1, OBJNULL}, {"MAKE-METHOD", CL_ORDINARY, NULL, -1, OBJNULL}, {"METHOD", CL_ORDINARY, NULL, -1, OBJNULL}, {"METHOD-COMBINATION-ERROR", CL_ORDINARY, ECL_NAME(cl_method_combination_error), -1, OBJNULL}, {"METHOD-COMBINATION", CL_ORDINARY, NULL, -1, OBJNULL}, {"METHOD-QUALIFIERS", CL_ORDINARY, NULL, -1, OBJNULL}, {"NEXT-METHOD-P", CL_ORDINARY, NULL, -1, OBJNULL}, {"NO-APPLICABLE-METHOD", CL_ORDINARY, NULL, -1, OBJNULL}, {"NO-NEXT-METHOD", CL_ORDINARY, NULL, -1, OBJNULL}, {"PRINT-OBJECT", CL_ORDINARY, NULL, -1, OBJNULL}, {"PRINT-UNREADABLE-OBJECT", CL_ORDINARY, NULL, -1, OBJNULL}, {"REINITIALIZE-INSTANCE", CL_ORDINARY, NULL, -1, OBJNULL}, {"REMOVE-METHOD", CL_ORDINARY, NULL, -1, OBJNULL}, {"SHARED-INITIALIZE", CL_ORDINARY, NULL, -1, OBJNULL}, {"SLOT-BOUNDP", CL_ORDINARY, ECL_NAME(cl_slot_boundp), 2, OBJNULL}, {"SLOT-EXISTS-P", CL_ORDINARY, ECL_NAME(cl_slot_exists_p), 2, OBJNULL}, {"SLOT-MAKUNBOUND", CL_ORDINARY, ECL_NAME(cl_slot_makunbound), 2, OBJNULL}, {"SLOT-MISSING", CL_ORDINARY, NULL, -1, OBJNULL}, {"SLOT-UNBOUND", CL_ORDINARY, NULL, -1, OBJNULL}, {"SLOT-VALUE", CL_ORDINARY, cl_slot_value, 2, OBJNULL}, {"STANDARD", CL_ORDINARY, NULL, -1, OBJNULL}, {"STANDARD-CLASS", CL_ORDINARY, NULL, -1, OBJNULL}, {"STANDARD-GENERIC-FUNCTION", CL_ORDINARY, NULL, -1, OBJNULL}, {"STANDARD-METHOD", CL_ORDINARY, NULL, -1, OBJNULL}, {"STANDARD-OBJECT", CL_ORDINARY, NULL, -1, OBJNULL}, {"STRUCTURE-CLASS", CL_ORDINARY, NULL, -1, OBJNULL}, {"STRUCTURE-OBJECT", CL_ORDINARY, NULL, -1, OBJNULL}, {"UPDATE-INSTANCE-FOR-DIFFERENT-CLASS", CL_ORDINARY, NULL, -1, OBJNULL}, {"UPDATE-INSTANCE-FOR-REDEFINED-CLASS", CL_ORDINARY, NULL, -1, OBJNULL}, {"WITH-ACCESSORS", CL_ORDINARY, NULL, -1, OBJNULL}, {"WITH-SLOTS", CL_ORDINARY, NULL, -1, OBJNULL}, {KEY_ "ACCESSOR", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "ARGUMENT-PRECEDENCE-ORDER", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "ALLOCATION", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "DECLARE", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "DEFAULT-INITARGS", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "DESCRIPTION", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "DIRECT-DEFAULT-INITARGS", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "DIRECT-SLOTS", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "DIRECT-SUPERCLASSES", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "GENERIC-FUNCTION-CLASS", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "IDENTITY-WITH-ONE-ARGUMENT", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "INITARG", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "INITARGS", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "INITFORM", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "INITFUNCTION", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "LAMBDA-LIST", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "LOCATION", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "METACLASS", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "METHOD", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "METHOD-CLASS", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "METHOD-COMBINATION", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "OPERATOR", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "ORDER", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "READER", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "READERS", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "REQUIRED", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "WRITER", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "WRITERS", KEYWORD, NULL, -1, OBJNULL}, /* SYSTEM PACKAGE */ {SYS_ "#!", SI_ORDINARY, NULL, -1, OBJNULL}, {SYS_ "*BACKQ-LEVEL*", SI_SPECIAL, NULL, -1, ecl_make_fixnum(0)}, {SYS_ "*CBLOCK*", SI_SPECIAL, NULL, -1, ECL_NIL}, {SYS_ "*CIRCLE-COUNTER*", SI_SPECIAL, NULL, -1, ECL_NIL}, {SYS_ "*CIRCLE-STACK*", SI_SPECIAL, NULL, -1, OBJNULL}, {SYS_ "*CLASS-NAME-HASH-TABLE*", SI_SPECIAL, NULL, -1, OBJNULL}, {SYS_ "*COMPILER-CONSTANTS*", SI_SPECIAL, NULL, -1, OBJNULL}, {SYS_ "*GC-MESSAGE*", SI_SPECIAL, NULL, -1, ECL_NIL}, {SYS_ "*GC-VERBOSE*", SI_SPECIAL, NULL, -1, ECL_NIL}, {SYS_ "*IGNORE-EOF-ON-TERMINAL-IO*", SI_SPECIAL, NULL, -1, ECL_NIL}, {SYS_ "*INDENT-FORMATTED-OUTPUT*", SI_SPECIAL, NULL, -1, ECL_NIL}, {SYS_ "*INIT-FUNCTION-PREFIX*", SI_SPECIAL, NULL, -1, ECL_NIL}, {EXT_ "*INTERRUPTS-ENABLED*", EXT_SPECIAL, NULL, 1, ECL_T}, {SYS_ "*KEEP-DEFINITIONS*", SI_SPECIAL, NULL, -1, ECL_T}, {EXT_ "*LOAD-HOOKS*", EXT_SPECIAL, NULL, -1, OBJNULL}, {SYS_ "*LOAD-SEARCH-LIST*", SI_SPECIAL, NULL, -1, ECL_NIL}, {SYS_ "*MAKE-CONSTANT", SI_ORDINARY, si_Xmake_constant, 2, OBJNULL}, {SYS_ "*MAKE-SPECIAL", SI_ORDINARY, si_Xmake_special, 1, OBJNULL}, {SYS_ "*PRINT-PACKAGE*", SI_SPECIAL, NULL, -1, ECL_NIL}, {SYS_ "*PRINT-STRUCTURE*", SI_SPECIAL, NULL, -1, ECL_NIL}, {SYS_ "*SHARP-EQ-CONTEXT*", SI_SPECIAL, NULL, -1, ECL_NIL}, {SYS_ "*STEP-LEVEL*", SI_SPECIAL, OBJNULL, -1, ecl_make_fixnum(0)}, {SYS_ "*STEP-ACTION*", SI_SPECIAL, OBJNULL, -1, ECL_NIL}, {SYS_ ".", SI_ORDINARY, NULL, -1, OBJNULL}, {SYS_ "UNQUOTE", SI_ORDINARY, NULL, -1, OBJNULL}, {SYS_ "UNQUOTE-NSPLICE", SI_ORDINARY, NULL, -1, OBJNULL}, {SYS_ "UNQUOTE-SPLICE", SI_ORDINARY, NULL, -1, OBJNULL}, {SYS_ "ALLOCATE-RAW-INSTANCE", SI_ORDINARY, si_allocate_raw_instance, 3, OBJNULL}, {EXT_ "ARGC", EXT_ORDINARY, si_argc, 0, OBJNULL}, {EXT_ "ARGV", EXT_ORDINARY, si_argv, 1, OBJNULL}, {SYS_ "ASET", SI_ORDINARY, si_aset, -1, OBJNULL}, {SYS_ "BASE-CHAR-P", SI_ORDINARY, si_base_char_p, 1, OBJNULL}, {SYS_ "BASE-STRING-P", SI_ORDINARY, si_base_string_p, 1, OBJNULL}, {SYS_ "BC-DISASSEMBLE", SI_ORDINARY, si_bc_disassemble, 1, OBJNULL}, {SYS_ "BC-SPLIT", SI_ORDINARY, si_bc_split, 1, OBJNULL}, {SYS_ "BC-JOIN", SI_ORDINARY, si_bc_join, 4, OBJNULL}, {SYS_ "BDS-TOP", SI_ORDINARY, si_bds_top, 0, OBJNULL}, {SYS_ "BDS-VAL", SI_ORDINARY, si_bds_val, 1, OBJNULL}, {SYS_ "BDS-VAR", SI_ORDINARY, si_bds_var, 1, OBJNULL}, {SYS_ "BIT-ARRAY-OP", SI_ORDINARY, si_bit_array_op, 4, OBJNULL}, {SYS_ "C-ARGUMENTS-LIMIT", SI_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_C_ARGUMENTS_LIMIT)}, {SYS_ "CHAR-SET", SI_ORDINARY, si_char_set, 3, OBJNULL}, {EXT_ "CHDIR", EXT_ORDINARY, si_chdir, -1, OBJNULL}, {SYS_ "CLEAR-COMPILER-PROPERTIES", SI_ORDINARY, cl_identity, 1, OBJNULL}, {SYS_ "COERCE-TO-BASE-STRING", SI_ORDINARY, si_coerce_to_base_string, 1, OBJNULL}, {SYS_ "COERCE-TO-EXTENDED-STRING", SI_ORDINARY, si_coerce_to_extended_string, 1, OBJNULL}, {SYS_ "COERCE-TO-FILENAME", SI_ORDINARY, si_coerce_to_filename, 1, OBJNULL}, {SYS_ "COERCE-TO-FUNCTION", SI_ORDINARY, si_coerce_to_function, 1, OBJNULL}, {SYS_ "COERCE-TO-PACKAGE", SI_ORDINARY, si_coerce_to_package, 1, OBJNULL}, {SYS_ "COPY-TO-SIMPLE-BASE-STRING", SI_ORDINARY, si_copy_to_simple_base_string, 1, OBJNULL}, {SYS_ "COMPILED-FUNCTION-BLOCK", SI_ORDINARY, si_compiled_function_block, 1, OBJNULL}, {EXT_ "COMPILED-FUNCTION-NAME", EXT_ORDINARY, si_compiled_function_name, 1, OBJNULL}, {SYS_ "COPY-STREAM", SI_ORDINARY, si_copy_stream, 1, OBJNULL}, {SYS_ "DESTRUCTURE", SI_ORDINARY, NULL, -1, OBJNULL}, {SYS_ "DO-READ-SEQUENCE", SI_ORDINARY, si_do_read_sequence, 4, OBJNULL}, {SYS_ "DO-WRITE-SEQUENCE", SI_ORDINARY, si_do_write_sequence, 4, OBJNULL}, {SYS_ "ELT-SET", SI_ORDINARY, si_elt_set, 3, OBJNULL}, {SYS_ "EVAL-WITH-ENV", SI_ORDINARY, si_eval_with_env, -1, OBJNULL}, {SYS_ "EXPAND-DEFMACRO", SI_ORDINARY, NULL, -1, OBJNULL}, {SYS_ "FILE-COLUMN", SI_ORDINARY, si_file_column, 1, OBJNULL}, {EXT_ "FILE-KIND", EXT_ORDINARY, si_file_kind, 2, OBJNULL}, {SYS_ "FILL-POINTER-SET", SI_ORDINARY, si_fill_pointer_set, 2, OBJNULL}, {EXT_ "FILE-STREAM-FD", EXT_ORDINARY, si_file_stream_fd, 1, OBJNULL}, {EXT_ "FIXNUMP", EXT_ORDINARY, si_fixnump, 1, OBJNULL}, {SYS_ "FORMAT-ERROR", SI_ORDINARY, NULL, -1, OBJNULL}, #ifdef ECL_CMU_FORMAT {SYS_ "FORMATTER-AUX", SI_ORDINARY, NULL, -1, OBJNULL}, #else {SYS_ "FORMATTER-AUX", SI_ORDINARY, si_formatter_aux, -1, OBJNULL}, #endif {SYS_ "FRS-BDS", SI_ORDINARY, si_frs_bds, 1, OBJNULL}, {SYS_ "FRS-IHS", SI_ORDINARY, si_frs_ihs, 1, OBJNULL}, {SYS_ "FRS-TAG", SI_ORDINARY, si_frs_tag, 1, OBJNULL}, {SYS_ "FRS-TOP", SI_ORDINARY, si_frs_top, 0, OBJNULL}, {SYS_ "FSET", SI_ORDINARY, si_fset, -1, OBJNULL}, {SYS_ "FUNCTION-BLOCK-NAME", SI_ORDINARY, si_function_block_name, 1, OBJNULL}, {SYS_ "GET-LIBRARY-PATHNAME", SI_ORDINARY, si_get_library_pathname, 0, OBJNULL}, {SYS_ "GET-SYSPROP", SI_ORDINARY, si_get_sysprop, 2, OBJNULL}, {EXT_ "GETENV", EXT_ORDINARY, si_getenv, 1, OBJNULL}, {EXT_ "GETCWD", EXT_ORDINARY, si_getcwd, -1, OBJNULL}, {EXT_ "GETPID", EXT_ORDINARY, si_getpid, 0, OBJNULL}, {EXT_ "GETUID", EXT_ORDINARY, si_getuid, 0, OBJNULL}, {SYS_ "HASH-SET", SI_ORDINARY, si_hash_set, 3, OBJNULL}, {SYS_ "HASH-TABLE-ITERATOR", SI_ORDINARY, si_hash_table_iterator, 1, OBJNULL}, {SYS_ "IHS-BDS", SI_ORDINARY, si_ihs_bds, 1, OBJNULL}, {SYS_ "IHS-ENV", SI_ORDINARY, si_ihs_env, 1, OBJNULL}, {SYS_ "IHS-FUN", SI_ORDINARY, si_ihs_fun, 1, OBJNULL}, {SYS_ "IHS-NEXT", SI_ORDINARY, si_ihs_next, 1, OBJNULL}, {SYS_ "IHS-PREV", SI_ORDINARY, si_ihs_prev, 1, OBJNULL}, {SYS_ "IHS-TOP", SI_ORDINARY, si_ihs_top, 0, OBJNULL}, {SYS_ "INTERPRETER-STACK", SI_ORDINARY, si_interpreter_stack, -1, OBJNULL}, {SYS_ "LINK-FROM", SI_ORDINARY, NULL, -1, OBJNULL}, {SYS_ "LINK-TO", SI_ORDINARY, NULL, -1, OBJNULL}, {SYS_ "LOAD-SOURCE", SI_ORDINARY, si_load_source, 4, OBJNULL}, {SYS_ "LOGICAL-PATHNAME-P", SI_ORDINARY, si_logical_pathname_p, 1, OBJNULL}, {SYS_ "MACRO", SI_ORDINARY, NULL, -1, OBJNULL}, {SYS_ "MAKE-LAMBDA", SI_ORDINARY, si_make_lambda, 2, OBJNULL}, {SYS_ "MAKE-PURE-ARRAY", SI_ORDINARY, si_make_pure_array, 6, OBJNULL}, {SYS_ "MAKE-STRING-OUTPUT-STREAM-FROM-STRING", SI_ORDINARY, si_make_string_output_stream_from_string, 1, OBJNULL}, {SYS_ "MAKE-STRUCTURE", SI_ORDINARY, si_make_structure, -1, OBJNULL}, {SYS_ "MAKE-VECTOR", SI_ORDINARY, si_make_vector, 6, OBJNULL}, {SYS_ "MANGLE-NAME", SI_ORDINARY, si_mangle_name, -1, OBJNULL}, {SYS_ "MEMBER1", SI_ORDINARY, si_member1, 5, OBJNULL}, {SYS_ "MEMQ", SI_ORDINARY, si_memq, 2, OBJNULL}, {SYS_ "MKDIR", SI_ORDINARY, si_mkdir, 2, OBJNULL}, {EXT_ "MKSTEMP", EXT_ORDINARY, si_mkstemp, 1, OBJNULL}, {SYS_ "RMDIR", SI_ORDINARY, si_rmdir, 1, OBJNULL}, {EXT_ "MAKE-PIPE", EXT_ORDINARY, si_make_pipe, 0, OBJNULL}, {EXT_ "PACKAGE-LOCK", EXT_ORDINARY, si_package_lock, 2, OBJNULL}, {SYS_ "PACKAGE-HASH-TABLES", SI_ORDINARY, si_package_hash_tables, 1, OBJNULL}, {SYS_ "PATHNAME-TRANSLATIONS", SI_ORDINARY, si_pathname_translations, -1, OBJNULL}, {SYS_ "POINTER", SI_ORDINARY, si_pointer, 1, OBJNULL}, {SYS_ "PRETTY-PRINT-FORMAT", SI_ORDINARY, NULL, -1, OBJNULL}, {SYS_ "PROCESS-DECLARATIONS", SI_ORDINARY, si_process_declarations, -1, OBJNULL}, {SYS_ "PROCESS-LAMBDA", SI_ORDINARY, si_process_lambda, 1, OBJNULL}, {SYS_ "PROCESS-LAMBDA-LIST", SI_ORDINARY, si_process_lambda_list, 2, OBJNULL}, {SYS_ "PUT-F", SI_ORDINARY, si_put_f, 3, OBJNULL}, {SYS_ "PUT-PROPERTIES", SI_ORDINARY, si_put_properties, -1, OBJNULL}, {SYS_ "PUT-SYSPROP", SI_ORDINARY, si_put_sysprop, 3, OBJNULL}, {SYS_ "PUTPROP", SI_ORDINARY, si_putprop, 3, OBJNULL}, {SYS_ "READTABLE-CASE-SET", SI_ORDINARY, si_readtable_case_set, 2, OBJNULL}, {SYS_ "REM-F", SI_ORDINARY, si_rem_f, 2, OBJNULL}, {SYS_ "REM-SYSPROP", SI_ORDINARY, si_rem_sysprop, 2, OBJNULL}, {SYS_ "REPLACE-ARRAY", SI_ORDINARY, si_replace_array, 2, OBJNULL}, {SYS_ "ROW-MAJOR-ASET", SI_ORDINARY, si_row_major_aset, 3, OBJNULL}, {EXT_ "RUN-PROGRAM", EXT_ORDINARY, si_run_program, -1, OBJNULL}, {SYS_ "WAIT-FOR-ALL-PROCESSES", SI_ORDINARY, si_wait_for_all_processes, -1, OBJNULL}, {EXT_ "SAFE-EVAL", EXT_ORDINARY, ECL_NAME(si_safe_eval), -1, OBJNULL}, {SYS_ "SCH-FRS-BASE", SI_ORDINARY, si_sch_frs_base, 2, OBJNULL}, {SYS_ "SCHAR-SET", SI_ORDINARY, si_char_set, 3, OBJNULL}, {SYS_ "SERROR", SI_ORDINARY, si_serror, -1, OBJNULL}, {SYS_ "SHARP-A-READER", SI_ORDINARY, NULL, -1, OBJNULL}, {SYS_ "SHARP-S-READER", SI_ORDINARY, NULL, -1, OBJNULL}, {SYS_ "SELECT-PACKAGE", SI_ORDINARY, si_select_package, 1, OBJNULL}, {SYS_ "SET-SYMBOL-PLIST", SI_ORDINARY, si_set_symbol_plist, 2, OBJNULL}, #if defined(HAVE_PUTENV) || defined(HAVE_SETENV) {EXT_ "SETENV", EXT_ORDINARY, si_setenv, 2, OBJNULL}, #else {EXT_ "SETENV", EXT_ORDINARY, NULL, -1, OBJNULL}, #endif {SYS_ "SETF-METHOD", SI_ORDINARY, NULL, -1, OBJNULL}, {SYS_ "SETF-NAMEP", SI_ORDINARY, NULL, -1, OBJNULL}, {SYS_ "SIMPLE-PROGRAM-ERROR", SI_ORDINARY, ECL_NAME(si_simple_program_error), -1, OBJNULL}, {SYS_ "SIGNAL-SIMPLE-ERROR", SI_ORDINARY, si_signal_simple_error, -1, OBJNULL}, {SYS_ "SIGNAL-TYPE-ERROR", SI_ORDINARY, si_signal_type_error, 2, OBJNULL}, {SYS_ "SPECIALP", SI_ORDINARY, si_specialp, 1, OBJNULL}, {SYS_ "STANDARD-READTABLE", SI_ORDINARY, si_standard_readtable, 0, OBJNULL}, {SYS_ "STEPPER", SI_ORDINARY, OBJNULL, -1, OBJNULL}, {SYS_ "BASE-STRING-CONCATENATE", SI_ORDINARY, si_base_string_concatenate, -1, OBJNULL}, {SYS_ "STRING-TO-OBJECT", SI_ORDINARY, ECL_NAME(si_string_to_object), -1, OBJNULL}, {SYS_ "STRUCTURE-NAME", SI_ORDINARY, si_structure_name, 1, OBJNULL}, {SYS_ "STRUCTURE-PRINT-FUNCTION", SI_ORDINARY, NULL, -1, OBJNULL}, {SYS_ "STRUCTURE-REF", SI_ORDINARY, si_structure_ref, 3, OBJNULL}, {SYS_ "STRUCTURE-SET", SI_ORDINARY, si_structure_set, 4, OBJNULL}, {SYS_ "STRUCTURE-SLOT-DESCRIPTIONS", SI_ORDINARY, NULL, -1, OBJNULL}, {SYS_ "STRUCTURE-SUBTYPE-P", SI_ORDINARY, si_structure_subtype_p, 2, OBJNULL}, {SYS_ "STRUCTUREP", SI_ORDINARY, si_structurep, 1, OBJNULL}, {SYS_ "SVSET", SI_ORDINARY, si_svset, 3, OBJNULL}, {SYS_ "SYMBOL-MACRO", SI_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "SYSTEM", EXT_ORDINARY, ECL_NAME(si_system), 1, OBJNULL}, {SYS_ "TERMINAL-INTERRUPT", SI_ORDINARY, NULL, -1, OBJNULL}, {SYS_ "TOP-LEVEL", SI_ORDINARY, NULL, -1, OBJNULL}, {SYS_ "UNIVERSAL-ERROR-HANDLER", SI_ORDINARY, NULL, -1, OBJNULL}, {SYS_ "STACK-ERROR-HANDLER", SI_ORDINARY, NULL, -1, OBJNULL}, {SYS_ "VALID-FUNCTION-NAME-P", SI_ORDINARY, si_valid_function_name_p, 1, OBJNULL}, {SYS_ "WRITE-OBJECT", SI_SPECIAL, si_write_object, 2, OBJNULL}, {SYS_ "WRITE-UGLY-OBJECT", SI_SPECIAL, si_write_ugly_object, 2, OBJNULL}, {SYS_ "COPY-INSTANCE", SI_ORDINARY, si_copy_instance, 1, OBJNULL}, {SYS_ "GENERIC-FUNCTION-P", SI_ORDINARY, si_generic_function_p, 1, OBJNULL}, {SYS_ "INSTANCE-REF", SI_ORDINARY, si_instance_ref, 2, OBJNULL}, {SYS_ "INSTANCE-SET", SI_ORDINARY, si_instance_set, 3, OBJNULL}, {SYS_ "INSTANCE-SIG", SI_ORDINARY, si_instance_sig, 1, OBJNULL}, {SYS_ "INSTANCE-SIG-SET", SI_ORDINARY, si_instance_sig_set, 1, OBJNULL}, {SYS_ "INSTANCE-CLASS", SI_ORDINARY, si_instance_class, 1, OBJNULL}, {SYS_ "INSTANCE-CLASS-SET", SI_ORDINARY, si_instance_class_set, 2, OBJNULL}, {SYS_ "INSTANCEP", SI_ORDINARY, si_instancep, 1, OBJNULL}, {SYS_ "SL-BOUNDP", SI_ORDINARY, si_sl_boundp, 1, OBJNULL}, {SYS_ "SL-MAKUNBOUND", SI_ORDINARY, si_sl_makunbound, 2, OBJNULL}, {SYS_ "SUBCLASSP", SI_ORDINARY, ECL_NAME(si_subclassp), -1, OBJNULL}, {SYS_ "OF-CLASS-P", SI_ORDINARY, ECL_NAME(si_of_class_p), -1, OBJNULL}, /*{SYS_ "UNBOUND", SI_ORDINARY, si_unbound, 0, OBJNULL}, */ {EXT_ "*SOURCE-LOCATION*", EXT_SPECIAL, NULL, -1, ECL_NIL}, {EXT_ "*REGISTER-WITH-PDE-HOOK*", EXT_SPECIAL, NULL, -1, ECL_NIL}, {EXT_ "REGISTER-WITH-PDE", EXT_ORDINARY, NULL, -1, OBJNULL}, /* #ifdef PROFILE */ {SYS_ "PROFILE", SI_ORDINARY, IF_PROFILE(si_profile), -1, OBJNULL}, {SYS_ "CLEAR-PROFILE", SI_ORDINARY, IF_PROFILE(si_clear_profile), -1, OBJNULL}, {SYS_ "DISPLAY-PROFILE", SI_ORDINARY, IF_PROFILE(si_display_profile), -1, OBJNULL}, /* #endif PROFILE */ /* #ifdef TCP */ {SYS_ "*PROFILE-ARRAY*", SI_SPECIAL, NULL, -1, OBJNULL}, {SYS_ "OPEN-CLIENT-STREAM", SI_ORDINARY, IF_TCP(si_open_client_stream), 2, OBJNULL}, {SYS_ "OPEN-SERVER-STREAM", SI_ORDINARY, IF_TCP(si_open_server_stream), 1, OBJNULL}, {SYS_ "OPEN-UNIX-SOCKET-STREAM", SI_ORDINARY, IF_TCP(si_open_unix_socket_stream), 1, OBJNULL}, {SYS_ "LOOKUP-HOST-ENTRY", SI_ORDINARY, IF_TCP(si_lookup_host_entry), 1, OBJNULL}, /* #endif TCP */ {EXT_ "CATCH-SIGNAL", EXT_ORDINARY, si_catch_signal, -1, OBJNULL}, {EXT_ "GET-SIGNAL-HANDLER", EXT_ORDINARY, si_get_signal_handler, 1, OBJNULL}, {EXT_ "SET-SIGNAL-HANDLER", EXT_ORDINARY, si_set_signal_handler, 2, OBJNULL}, /* KEYWORD PACKAGE */ {KEY_ "ADJUSTABLE", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "ABORT", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "ABSOLUTE", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "ALLOW-OTHER-KEYS", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "APPEND", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "ARRAY", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "BACK", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "BASE", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "BLOCK", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "CAPITALIZE", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "CATCH", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "CASE", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "CIRCLE", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "COMPILE-TOPLEVEL", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "COMMON",KEYWORD,NULL,-1,OBJNULL}, {KEY_ "CONC-NAME", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "CONSTRUCTOR", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "CONTROL-STRING", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "COPIER", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "CREATE", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "DATUM", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "DEFAULT", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "DEFAULTS", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "DEVICE", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "DIRECTION", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "DIRECTORY", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "DISPLACED-INDEX-OFFSET", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "DISPLACED-TO", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "DOCUMENTATION", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "DOWNCASE", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "ELEMENT-TYPE", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "END", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "END1", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "END2", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "EOF", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "ERROR", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "ESCAPE", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "EXECUTE", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "EXPECTED-TYPE", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "EXPORT", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "EXPORT-FROM", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "EXTERNAL", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "EXTERNAL-FORMAT", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "FILE", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "FILL-POINTER", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "FORMAT-ARGUMENTS", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "FORMAT-CONTROL", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "FUNCTION", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "GENSYM", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "HOST", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "IF-DOES-NOT-EXIST", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "IF-ERROR-EXISTS", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "IF-EXISTS", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "IF-INPUT-DOES-NOT-EXIST", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "IF-OUTPUT-EXISTS", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "IGNORE", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "IMPORT-FROM", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "INCLUDE", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "INHERITED", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "INITIAL-ELEMENT", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "INITIAL-CONTENTS", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "INITIAL-OFFSET", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "INPUT", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "INTERACTIVE", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "INSTANCE", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "INTERN", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "INTERNAL", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "INVERT", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "IO", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "JUNK-ALLOWED", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "KEY", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "LENGTH", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "LEVEL", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "LINES", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "LINK", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "LIST-ALL", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "LOCAL",KEYWORD,NULL,-1,OBJNULL}, {KEY_ "LOCKABLE", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "LOAD-TOPLEVEL", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "MASK", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "MISER-WIDTH", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "NAME", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "NAMED", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "NEW-VERSION", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "NEWEST", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "NICKNAMES", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "OBJECT", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "OFFSET", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "OPERATION", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "OPERANDS", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "OUTPUT", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "OVERWRITE", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "PACKAGE", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "PATHNAME", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "PPRINT-DISPATCH", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "PREDICATE", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "PRESERVE", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "PRETTY", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "PRINT", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "PRINT-FUNCTION", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "PRINT-OBJECT", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "PROBE", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "PROCESS", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "RADIX", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "READABLY", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "REHASH-SIZE", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "REHASH-THRESHOLD", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "RELATIVE", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "RENAME", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "RENAME-AND-DELETE", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "REPORT", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "RIGHT-MARGIN", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "SET-DEFAULT-PATHNAME", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "SEARCH-LIST", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "SHADOW", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "SHADOWING-IMPORT", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "SIZE", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "SPECIAL", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "START", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "START1", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "START2", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "STREAM", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "SUPERSEDE", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "TAG", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "TEST", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "TEST-NOT", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "TYPE", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "UNSPECIFIC", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "UNMASK", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "UP", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "UPCASE", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "USE", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "CSTREAM", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "VERBOSE", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "VERSION", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "WILD", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "WILD-INFERIORS", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "WAIT", KEYWORD, NULL, -1, OBJNULL}, {EXT_ "BYTE8", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "BYTE16", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "BYTE32", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "BYTE64", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "COMPILER-LET", EXT_FORM, NULL, -1, OBJNULL}, {EXT_ "INTEGER8", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "INTEGER16", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "INTEGER32", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "INTEGER64", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "LAMBDA-BLOCK", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "QUIT", EXT_ORDINARY, si_quit, -1, OBJNULL}, {EXT_ "GET-METHOD", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "INSTANCE", EXT_ORDINARY, NULL, -1, OBJNULL}, {SYS_ "ALLOCATE-FOREIGN-DATA", SI_ORDINARY, si_allocate_foreign_data, 2, OBJNULL}, {SYS_ "FIND-FOREIGN-SYMBOL", SI_ORDINARY, si_find_foreign_symbol, 4, OBJNULL}, {SYS_ "FOREIGN-DATA", SI_ORDINARY, NULL, -1, OBJNULL}, {SYS_ "FOREIGN-DATA-ADDRESS", SI_ORDINARY, si_foreign_data_address, 1, OBJNULL}, {SYS_ "FOREIGN-DATA-EQUAL", SI_ORDINARY, si_foreign_data_equal, 2, OBJNULL}, {SYS_ "FOREIGN-DATA-P", SI_ORDINARY, si_foreign_data_p, 1, OBJNULL}, {SYS_ "FOREIGN-DATA-POINTER", SI_ORDINARY, si_foreign_data_pointer, 4, OBJNULL}, {SYS_ "FOREIGN-DATA-RECAST", SI_ORDINARY, si_foreign_data_recast, 3, OBJNULL}, {SYS_ "FOREIGN-DATA-REF", SI_ORDINARY, si_foreign_data_ref, 4, OBJNULL}, {SYS_ "FOREIGN-DATA-REF-ELT", SI_ORDINARY, si_foreign_data_ref_elt, 3, OBJNULL}, {SYS_ "FOREIGN-DATA-SET", SI_ORDINARY, si_foreign_data_set, 3, OBJNULL}, {SYS_ "FOREIGN-DATA-SET-ELT", SI_ORDINARY, si_foreign_data_set_elt, 4, OBJNULL}, {SYS_ "FOREIGN-DATA-TAG", SI_ORDINARY, si_foreign_data_tag, 1, OBJNULL}, {SYS_ "FOREIGN-ELT-TYPE-P", SI_ORDINARY, si_foreign_elt_type_p, 1, OBJNULL}, {SYS_ "FREE-FOREIGN-DATA", SI_ORDINARY, si_free_foreign_data, 1, OBJNULL}, {SYS_ "MAKE-FOREIGN-DATA-FROM-ARRAY", SI_ORDINARY, si_make_foreign_data_from_array, 1, OBJNULL}, {SYS_ "LOAD-FOREIGN-MODULE", SI_ORDINARY, si_load_foreign_module, 1, OBJNULL}, {SYS_ "UNLOAD-FOREIGN-MODULE", SI_ORDINARY, si_unload_foreign_module, 1, OBJNULL}, {SYS_ "NULL-POINTER-P", SI_ORDINARY, si_null_pointer_p, 1, OBJNULL}, {SYS_ "SIZE-OF-FOREIGN-ELT-TYPE", SI_ORDINARY, si_size_of_foreign_elt_type, 1, OBJNULL}, {SYS_ "ALIGNMENT-OF-FOREIGN-ELT-TYPE", SI_ORDINARY, si_alignment_of_foreign_elt_type, 1, OBJNULL}, {KEY_ "BYTE", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "CHAR", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "CSTRING", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "DOUBLE", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "FIXNUM", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "FLOAT", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "INT", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "INT8-T", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "INT16-T", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "INT32-T", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "INT64-T", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "LONG", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "LONG-LONG", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "POINTER-SELF", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "POINTER-VOID", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "SHORT", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "STRUCT", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "UNION", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "VOID", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "UINT8-T", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "UINT16-T", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "UINT32-T", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "UINT64-T", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "UNSIGNED-BYTE", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "UNSIGNED-CHAR", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "UNSIGNED-INT", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "UNSIGNED-LONG", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "UNSIGNED-LONG-LONG", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "UNSIGNED-SHORT", KEYWORD, NULL, -1, OBJNULL}, #ifdef GBC_BOEHM {EXT_ "GC", EXT_ORDINARY, si_gc, -1, OBJNULL}, {SYS_ "GC-DUMP", SI_ORDINARY, si_gc_dump, 0, OBJNULL}, {SYS_ "GC-STATS", SI_ORDINARY, si_gc_stats, 1, OBJNULL}, #else {EXT_ "GC", EXT_ORDINARY, si_gc, 1, OBJNULL}, {SYS_ "ALLOCATE", SI_ORDINARY, si_allocate, -1, OBJNULL}, {SYS_ "ALLOCATED-PAGES", SI_ORDINARY, si_allocated_pages, -1, OBJNULL}, {SYS_ "MAXIMUM-ALLOCATABLE-PAGES", SI_ORDINARY, si_maximum_allocatable_pages, -1, OBJNULL}, {SYS_ "ALLOCATE-CONTIGUOUS-PAGES", SI_ORDINARY, si_allocate_contiguous_pages, -1, OBJNULL}, {SYS_ "ALLOCATED-CONTIGUOUS-PAGES", SI_ORDINARY, si_allocated_contiguous_pages, -1, OBJNULL}, {SYS_ "MAXIMUM-CONTIGUOUS-PAGES", SI_ORDINARY, si_maximum_contiguous_pages, -1, OBJNULL}, {SYS_ "GC-TIME", SI_ORDINARY, si_gc_time, -1, OBJNULL}, {SYS_ "GET-HOLE-SIZE", SI_ORDINARY, si_get_hole_size, -1, OBJNULL}, {SYS_ "SET-HOLE-SIZE", SI_ORDINARY, si_set_hole_size, -1, OBJNULL}, {SYS_ "IGNORE-MAXIMUM-PAGES", SI_ORDINARY, si_ignore_maximum_pages, -1, OBJNULL}, {SYS_ "ROOM-REPORT", SI_ORDINARY, si_room_report, -1, OBJNULL}, {SYS_ "RESET-GC-COUNT", SI_ORDINARY, si_reset_gc_count, -1, OBJNULL}, #endif /* !GBC_BOEHM */ /* #ifdef ECL_THREADS */ {MP_ "PROCESS", MP_ORDINARY, NULL, -1, OBJNULL}, {MP_ "LOCK", MP_ORDINARY, NULL, -1, OBJNULL}, {MP_ "CONDITION-VARIABLE", MP_ORDINARY, NULL, -1, OBJNULL}, {MP_ "*CURRENT-PROCESS*", MP_SPECIAL, NULL, -1, OBJNULL}, {MP_ "ALL-PROCESSES", MP_ORDINARY, IF_MP(mp_all_processes), 0, OBJNULL}, {MP_ "EXIT-PROCESS", MP_ORDINARY, IF_MP(mp_exit_process), 0, OBJNULL}, {MP_ "MAKE-PROCESS", MP_ORDINARY, IF_MP(mp_make_process), -1, OBJNULL}, {MP_ "PROCESS-ACTIVE-P", MP_ORDINARY, IF_MP(mp_process_active_p), 1, OBJNULL}, {MP_ "PROCESS-ENABLE", MP_ORDINARY, IF_MP(mp_process_enable), 1, OBJNULL}, {MP_ "PROCESS-YIELD", MP_ORDINARY, IF_MP(mp_process_yield), 0, OBJNULL}, {MP_ "PROCESS-KILL", MP_ORDINARY, IF_MP(mp_process_kill), 1, OBJNULL}, {MP_ "PROCESS-NAME", MP_ORDINARY, IF_MP(mp_process_name), 1, OBJNULL}, {MP_ "PROCESS-PRESET", MP_ORDINARY, IF_MP(mp_process_preset), -1, OBJNULL}, {MP_ "PROCESS-RUN-FUNCTION", MP_ORDINARY, IF_MP(mp_process_run_function), -1, OBJNULL}, {MP_ "PROCESS-WHOSTATE", MP_ORDINARY, IF_MP(mp_process_whostate), 1, OBJNULL}, {MP_ "PROCESS-JOIN", MP_ORDINARY, IF_MP(mp_process_join), 1, OBJNULL}, {MP_ "MAKE-LOCK", MP_ORDINARY, IF_MP(mp_make_lock), -1, OBJNULL}, {KEY_ "RECURSIVE", KEYWORD, NULL, -1, OBJNULL}, {MP_ "RECURSIVE-LOCK-P", MP_ORDINARY, IF_MP(mp_recursive_lock_p), 1, OBJNULL}, {MP_ "LOCK-NAME", MP_ORDINARY, IF_MP(mp_lock_name), 1, OBJNULL}, {MP_ "LOCK-OWNER", MP_ORDINARY, IF_MP(mp_lock_owner), 1, OBJNULL}, {MP_ "LOCK-COUNT", MP_ORDINARY, IF_MP(mp_lock_count), 1, OBJNULL}, {MP_ "GET-LOCK", MP_ORDINARY, IF_MP(mp_get_lock), -1, OBJNULL}, {MP_ "GIVEUP-LOCK", MP_ORDINARY, IF_MP(mp_giveup_lock), 1, OBJNULL}, {MP_ "MAKE-CONDITION-VARIABLE", MP_ORDINARY, IF_MP(mp_make_condition_variable), 0, OBJNULL}, {MP_ "CONDITION-VARIABLE-WAIT", MP_ORDINARY, IF_MP(mp_condition_variable_wait), 2, OBJNULL}, {MP_ "CONDITION-VARIABLE-TIMEDWAIT", MP_ORDINARY, IF_MP(mp_condition_variable_timedwait), 3, OBJNULL}, {MP_ "CONDITION-VARIABLE-SIGNAL", MP_ORDINARY, IF_MP(mp_condition_variable_signal), 1, OBJNULL}, {MP_ "CONDITION-VARIABLE-BROADCAST", MP_ORDINARY, IF_MP(mp_condition_variable_broadcast), 1, OBJNULL}, {KEY_ "INITIAL-BINDINGS", KEYWORD, NULL, -1, OBJNULL}, {MP_ "INTERRUPT-PROCESS", MP_ORDINARY, IF_MP(mp_interrupt_process), 2, OBJNULL}, {MP_ "+LOAD-COMPILE-LOCK+", MP_CONSTANT, NULL, -1, OBJNULL}, {MP_ "WITH-LOCK", MP_CONSTANT, NULL, -1, OBJNULL}, {MP_ "WITH-RWLOCK", MP_CONSTANT, NULL, -1, OBJNULL}, {MP_ "BLOCK-SIGNALS", MP_ORDINARY, IF_MP(mp_block_signals), 0, OBJNULL}, {MP_ "RESTORE-SIGNALS", MP_ORDINARY, IF_MP(mp_restore_signals), 1, OBJNULL}, {MP_ "PROCESS-SUSPEND", MP_ORDINARY, IF_MP(mp_process_suspend), 1, OBJNULL}, {MP_ "PROCESS-RESUME", MP_ORDINARY, IF_MP(mp_process_resume), 1, OBJNULL}, {MP_ "SUSPEND-LOOP", MP_ORDINARY, IF_MP(mp_suspend_loop), 0, OBJNULL}, {MP_ "BREAK-SUSPEND-LOOP", MP_ORDINARY, IF_MP(mp_break_suspend_loop), 0, OBJNULL}, {MP_ "MAKE-RWLOCK", MP_ORDINARY, IF_MP(mp_make_rwlock), -1, OBJNULL}, {MP_ "RWLOCK", MP_ORDINARY, NULL, -1, OBJNULL}, {MP_ "RWLOCK-NAME", MP_ORDINARY, IF_MP(mp_rwlock_name), 1, OBJNULL}, {MP_ "GET-RWLOCK-READ", MP_ORDINARY, IF_MP(mp_get_rwlock_read), -1, OBJNULL}, {MP_ "GET-RWLOCK-WRITE", MP_ORDINARY, IF_MP(mp_get_rwlock_write), -1, OBJNULL}, {MP_ "GIVEUP-RWLOCK-READ", MP_ORDINARY, IF_MP(mp_giveup_rwlock_read), 1, OBJNULL}, {MP_ "GIVEUP-RWLOCK-WRITE", MP_ORDINARY, IF_MP(mp_giveup_rwlock_write), 1, OBJNULL}, {MP_ "GLOBAL-LOCK", MP_ORDINARY, NULL, -1, OBJNULL}, {MP_ "ERROR-LOCK", MP_ORDINARY, NULL, -1, OBJNULL}, {MP_ "SEMAPHORE", MP_ORDINARY, NULL, -1, OBJNULL}, {MP_ "MAKE-SEMAPHORE", MP_ORDINARY, IF_MP(mp_make_semaphore), -1, OBJNULL}, {MP_ "SIGNAL-SEMAPHORE", MP_ORDINARY, IF_MP(mp_signal_semaphore), -1, OBJNULL}, {MP_ "WAIT-ON-SEMAPHORE", MP_ORDINARY, IF_MP(mp_wait_on_semaphore), 1, OBJNULL}, {MP_ "TRY-GET-SEMAPHORE", MP_ORDINARY, IF_MP(mp_try_get_semaphore), 1, OBJNULL}, {MP_ "SEMAPHORE-COUNT", MP_ORDINARY, IF_MP(mp_semaphore_count), 1, OBJNULL}, {MP_ "SEMAPHORE-NAME", MP_ORDINARY, IF_MP(mp_semaphore_name), 1, OBJNULL}, {MP_ "SEMAPHORE-WAIT-COUNT", MP_ORDINARY, IF_MP(mp_semaphore_wait_count), 1, OBJNULL}, {KEY_ "COUNT", KEYWORD, NULL, -1, OBJNULL}, {MP_ "BARRIER", MP_ORDINARY, NULL, -1, OBJNULL}, {MP_ "MAKE-BARRIER", MP_ORDINARY, IF_MP(mp_make_barrier), -1, OBJNULL}, {MP_ "BARRIER-UNBLOCK", MP_ORDINARY, IF_MP(mp_barrier_unblock), -1, OBJNULL}, {MP_ "BARRIER-WAIT", MP_ORDINARY, IF_MP(mp_barrier_wait), -1, OBJNULL}, {MP_ "BARRIER-COUNT", MP_ORDINARY, IF_MP(mp_barrier_count), 1, OBJNULL}, {MP_ "BARRIER-NAME", MP_ORDINARY, IF_MP(mp_barrier_name), 1, OBJNULL}, {MP_ "BARRIER-ARRIVERS-COUNT", MP_ORDINARY, IF_MP(mp_barrier_arrivers_count), 1, OBJNULL}, {KEY_ "DISABLE", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "RESET-COUNT", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "KILL-WAITING", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "UNBLOCKED", KEYWORD, NULL, -1, OBJNULL}, {MP_ "MAILBOX", MP_ORDINARY, NULL, -1, OBJNULL}, {MP_ "MAKE-MAILBOX", MP_ORDINARY, IF_MP(mp_make_mailbox), -1, OBJNULL}, {MP_ "MAILBOX-NAME", MP_ORDINARY, IF_MP(mp_mailbox_name), 1, OBJNULL}, {MP_ "MAILBOX-COUNT", MP_ORDINARY, IF_MP(mp_mailbox_count), 1, OBJNULL}, {MP_ "MAILBOX-EMPTY-P", MP_ORDINARY, IF_MP(mp_mailbox_empty_p), 1, OBJNULL}, {MP_ "MAILBOX-READ", MP_ORDINARY, IF_MP(mp_mailbox_read), 1, OBJNULL}, {MP_ "MAILBOX-TRY-READ", MP_ORDINARY, IF_MP(mp_mailbox_try_read), 1, OBJNULL}, {MP_ "MAILBOX-SEND", MP_ORDINARY, IF_MP(mp_mailbox_send), 2, OBJNULL}, {MP_ "MAILBOX-TRY-SEND", MP_ORDINARY, IF_MP(mp_mailbox_try_send), 2, OBJNULL}, /* #endif defined(ECL_THREADS) */ {SYS_ "WHILE", SI_ORDINARY, NULL, -1, OBJNULL}, {SYS_ "UNTIL", SI_ORDINARY, NULL, -1, OBJNULL}, {SYS_ "QUASIQUOTE", SI_ORDINARY, NULL, -1, OBJNULL}, {SYS_ "*EXIT-HOOKS*", SI_SPECIAL, NULL, -1, ECL_NIL}, {CLOS_ ".COMBINED-METHOD-ARGS.", CLOS_SPECIAL, NULL, -1, ECL_NIL}, {CLOS_ "+BUILTIN-CLASSES+", CLOS_ORDINARY, NULL, -1, ECL_NIL}, {CLOS_ "*NEXT-METHODS*", CLOS_SPECIAL, NULL, -1, ECL_NIL}, {CLOS_ "*OPTIMIZE-SLOT-ACCESS*", CLOS_SPECIAL, NULL, -1, ECL_T}, {CLOS_ "+THE-T-CLASS+", CLOS_ORDINARY, NULL, -1, ECL_NIL}, {CLOS_ "+THE-CLASS+", CLOS_ORDINARY, NULL, -1, ECL_NIL}, {CLOS_ "+THE-STD-CLASS+", CLOS_ORDINARY, NULL, -1, ECL_NIL}, {CLOS_ "+THE-STANDARD-CLASS+", CLOS_ORDINARY, NULL, -1, ECL_NIL}, {CLOS_ "+THE-FUNCALLABLE-STANDARD-CLASS+", CLOS_ORDINARY, NULL, -1, ECL_NIL}, {CLOS_ "ACCESSOR-METHOD-SLOT-DEFINITION", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "ADD-DEPENDENT", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "ADD-DIRECT-METHOD", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "ADD-DIRECT-SUBCLASS", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "CLASS-DEFAULT-INITARGS", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "CLASS-DIRECT-DEFAULT-INITARGS", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "CLASS-DIRECT-SLOTS", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "CLASS-DIRECT-SUBCLASSES", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "CLASS-DIRECT-SUPERCLASSES", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "CLASS-FINALIZED-P", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "CLASS-PRECEDENCE-LIST", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "CLASS-PROTOTYPE", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "CLASS-SLOTS", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "COMPUTE-APPLICABLE-METHODS-USING-CLASSES", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "COMPUTE-CLASS-PRECEDENCE-LIST", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "COMPUTE-DEFAULT-INITARGS", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "COMPUTE-DISCRIMINATING-FUNCTION", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "COMPUTE-EFFECTIVE-METHOD", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "COMPUTE-EFFECTIVE-SLOT-DEFINITION", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "COMPUTE-SLOTS", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "DIRECT-SLOT-DEFINITION", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "DIRECT-SLOT-DEFINITION-CLASS", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "EFFECTIVE-SLOT-DEFINITION", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "EFFECTIVE-SLOT-DEFINITION-CLASS", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "ENSURE-CLASS", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "ENSURE-CLASS-USING-CLASS", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "ENSURE-GENERIC-FUNCTION-USING-CLASS", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "EQL-SPECIALIZER", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "EQL-SPECIALIZER-OBJECT", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "EXTRACT-LAMBDA-LIST", CLOS_ORDINARY, ECL_NAME(clos_extract_lambda_list), 1, OBJNULL}, {CLOS_ "EXTRACT-SPECIALIZER-NAMES", CLOS_ORDINARY, ECL_NAME(clos_extract_specializer_names), 1, OBJNULL}, {CLOS_ "FINALIZE-INHERITANCE", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "FIND-METHOD-COMBINATION", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "FORWARD-REFERENCED-CLASS", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "FUNCALLABLE-STANDARD-CLASS", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "FUNCALLABLE-STANDARD-INSTANCE-ACCESS", CLOS_ORDINARY, ECL_NAME(clos_funcallable_standard_instance_access), 2, OBJNULL}, {CLOS_ "FUNCALLABLE-STANDARD-OBJECT", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "GENERIC-FUNCTION-ARGUMENT-PRECEDENCE-ORDER", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "GENERIC-FUNCTION-DECLARATIONS", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "GENERIC-FUNCTION-LAMBDA-LIST", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "GENERIC-FUNCTION-METHOD-CLASS", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "GENERIC-FUNCTION-METHOD-COMBINATION", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "GENERIC-FUNCTION-METHODS", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "GENERIC-FUNCTION-NAME", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "INTERN-EQL-SPECIALIZER", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "LOCATION-TABLE", CLOS_ORDINARY | PRIVATE, NULL, -1, OBJNULL}, {CLOS_ "MAKE-METHOD-LAMBDA", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "MAP-DEPENDENTS", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "METAOBJECT", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "METHOD-FUNCTION", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "METHOD-GENERIC-FUNCTION", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "METHOD-LAMBDA-LIST", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "METHOD-SPECIALIZERS", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "NAME", CLOS_ORDINARY | PRIVATE, NULL, -1, OBJNULL}, {CLOS_ "READER-METHOD-CLASS", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "REMOVE-DEPENDENT", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "REMOVE-DIRECT-METHOD", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "REMOVE-DIRECT-SUBCLASS", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "SET-FUNCALLABLE-INSTANCE-FUNCTION", CLOS_ORDINARY, clos_set_funcallable_instance_function, 2, OBJNULL}, {CLOS_ "SLOT-BOUNDP-USING-CLASS", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "SLOT-DEFINITION", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "SLOT-DEFINITION-ALLOCATION", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "SLOT-DEFINITION-INITARGS", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "SLOT-DEFINITION-INITFORM", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "SLOT-DEFINITION-INITFUNCTION", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "SLOT-DEFINITION-LOCATION", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "SLOT-DEFINITION-NAME", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "SLOT-DEFINITION-READERS", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "SLOT-DEFINITION-TYPE", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "SLOT-DEFINITION-WRITERS", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "SLOT-MAKUNBOUND-USING-CLASS", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "SLOT-VALUE-USING-CLASS", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "SLOT-VALUE-SET", CLOS_ORDINARY, clos_slot_value_set, 3, OBJNULL}, {CLOS_ "SLOT-TABLE", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "SPECIALIZER", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "SPECIALIZER-DIRECT-GENERIC-FUNCTIONS", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "SPECIALIZER-DIRECT-METHODS", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "STANDARD-ACCESSOR-METHOD", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "STANDARD-DIRECT-SLOT-DEFINITION", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "STANDARD-EFFECTIVE-SLOT-DEFINITION", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "STANDARD-INSTANCE-ACCESS", CLOS_ORDINARY, ECL_NAME(clos_standard_instance_access), 2, OBJNULL}, {CLOS_ "STANDARD-INSTANCE-SET", CLOS_ORDINARY, ECL_NAME(clos_standard_instance_set), 3, OBJNULL}, {CLOS_ "STANDARD-READER-METHOD", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "STANDARD-SLOT-DEFINITION", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "STANDARD-WRITER-METHOD", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "STANDARD-OPTIMIZED-READER-METHOD", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "STANDARD-OPTIMIZED-WRITER-METHOD", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "STD-COMPUTE-APPLICABLE-METHODS", CLOS_ORDINARY, ECL_NAME(clos_std_compute_applicable_methods), 2, OBJNULL}, {CLOS_ "STD-COMPUTE-APPLICABLE-METHODS-USING-CLASSES", CLOS_ORDINARY, NULL, 2, OBJNULL}, {CLOS_ "STD-COMPUTE-EFFECTIVE-METHOD", CLOS_ORDINARY, ECL_NAME(clos_std_compute_effective_method), 3, OBJNULL}, {CLOS_ "COMPUTE-EFFECTIVE-METHOD-FUNCTION", CLOS_ORDINARY, ECL_NAME(clos_compute_effective_method_function), 3, OBJNULL}, {CLOS_ "UPDATE-DEPENDENT", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "UPDATE-INSTANCE", CLOS_ORDINARY, NULL, 1, OBJNULL}, {CLOS_ "VALIDATE-SUPERCLASS", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "WRITER-METHOD-CLASS", CLOS_ORDINARY, NULL, -1, OBJNULL}, {SYS_ "CLEAR-GFUN-HASH", SI_ORDINARY, si_clear_gfun_hash, 1, OBJNULL}, {CLOS_ "NEED-TO-MAKE-LOAD-FORM-P", CLOS_ORDINARY, ECL_NAME(clos_need_to_make_load_form_p), 2, OBJNULL}, {CLOS_ "LOAD-DEFCLASS", CLOS_ORDINARY, ECL_NAME(clos_load_defclass), 4, OBJNULL}, {CLOS_ "DOCSTRING", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "SAFE-INSTANCE-REF", CLOS_ORDINARY, clos_safe_instance_ref, 2, OBJNULL}, {SYS_ "CL-FIXNUM-BITS", SI_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_FIXNUM_BITS)}, {EXT_ "CL-FIXNUM", EXT_ORDINARY, NULL, -1, NULL}, {EXT_ "CL-INDEX", EXT_ORDINARY, NULL, -1, NULL}, {SYS_ "DO-DEFTYPE", SI_ORDINARY, ECL_NAME(si_do_deftype), -1, OBJNULL}, {SYS_ "CREATE-TYPE-NAME", SI_ORDINARY, NULL, -1, OBJNULL}, {SYS_ "*ALIEN-DECLARATIONS*", SI_SPECIAL, NULL, -1, ECL_NIL}, #ifdef ENABLE_DLOPEN {SYS_ "LOAD-BINARY", SI_ORDINARY, si_load_binary, 4, OBJNULL}, #else {SYS_ "LOAD-BINARY", SI_ORDINARY, NULL, -1, OBJNULL}, #endif {SYS_ "*CODE-WALKER*", SI_SPECIAL, NULL, -1, OBJNULL}, /* #if defined(HAVE_LIBFFI) || defined(ECL_DYNAMIC_FFI) */ {SYS_ "CALL-CFUN", SI_ORDINARY, IF_DFFI(si_call_cfun), -1, OBJNULL}, {KEY_ "CALLBACK", KEYWORD, NULL, -1, OBJNULL}, {SYS_ "MAKE-DYNAMIC-CALLBACK", SI_ORDINARY, IF_DFFI(si_make_dynamic_callback), -1, OBJNULL}, {SYS_ "FREE-FFI-CLOSURE", SI_ORDINARY, IF_LIBFFI(si_free_ffi_closure), 1, OBJNULL}, /* #endif defined(HAVE_LIBFFI) || defined(ECL_DYNAMIC_FFI) */ {KEY_ "CDECL", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "STDCALL", KEYWORD, NULL, -1, OBJNULL}, {SYS_ "TRAP-FPE", SI_ORDINARY, si_trap_fpe, 2, OBJNULL}, {EXT_ "*ACTION-ON-UNDEFINED-VARIABLE*", EXT_SPECIAL, NULL, -1, ECL_NIL}, {SYS_ "SET-BUFFERING-MODE", SI_ORDINARY, si_set_buffering_mode, 2, OBJNULL}, {KEY_ "NONE", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "LINE-BUFFERED", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "FULLY-BUFFERED", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "LINE", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "FULL", KEYWORD, NULL, -1, OBJNULL}, {SYS_ "CMP-ENV-REGISTER-MACROLET", SI_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "GET-FINALIZER", EXT_ORDINARY, si_get_finalizer, 1, OBJNULL}, {EXT_ "SET-FINALIZER", EXT_ORDINARY, si_set_finalizer, 2, OBJNULL}, /* #ifdef ECL_RELATIVE_PACKAGE_NAMES */ {SYS_ "*RELATIVE-PACKAGE-NAMES*", SI_SPECIAL, NULL, -1, RELATIVE_PACKAGES_P}, {KEY_ "RELATIVE-PACKAGE-NAMES", KEYWORD, NULL, -1, OBJNULL}, {SYS_ "FIND-RELATIVE-PACKAGE", SI_ORDINARY, IF_RELPACK(si_find_relative_package), -1, OBJNULL}, {SYS_ "PACKAGE-PARENT", SI_ORDINARY, NULL, -1, OBJNULL}, {SYS_ "PACKAGE-CHILDREN", SI_ORDINARY, NULL, -1, OBJNULL}, /* #endif ECL_RELATIVE_PACKAGE_NAMES */ {SYS_ "WRONG-TYPE-ARGUMENT", SI_ORDINARY, si_wrong_type_argument, -1, OBJNULL}, {SYS_ "*CURRENT-FORM*", SI_SPECIAL, NULL, -1, OBJNULL}, {SYS_ "CODE-BLOCK", SI_ORDINARY, NULL, -1, OBJNULL}, {SYS_ "FRAME", SI_ORDINARY, NULL, -1, OBJNULL}, {SYS_ "APPLY-FROM-STACK-FRAME", SI_ORDINARY, si_apply_from_stack_frame, 2, OBJNULL}, #ifdef ECL_CLOS_STREAMS {GRAY_ "CLOSE", GRAY_ORDINARY, NULL, -1, OBJNULL}, {GRAY_ "STREAMP", GRAY_ORDINARY, NULL, -1, OBJNULL}, {GRAY_ "INPUT-STREAM-P", GRAY_ORDINARY, NULL, 1, OBJNULL}, {GRAY_ "OUTPUT-STREAM-P", GRAY_ORDINARY, NULL, 1, OBJNULL}, {GRAY_ "OPEN-STREAM-P", GRAY_ORDINARY, NULL, 1, OBJNULL}, {GRAY_ "STREAM-ADVANCE-TO-COLUMN", GRAY_ORDINARY, NULL, -1, OBJNULL}, {GRAY_ "STREAM-CLEAR-INPUT", GRAY_ORDINARY, NULL, -1, OBJNULL}, {GRAY_ "STREAM-CLEAR-OUTPUT", GRAY_ORDINARY, NULL, -1, OBJNULL}, {GRAY_ "STREAM-ELEMENT-TYPE", GRAY_ORDINARY, NULL, 1, OBJNULL}, {GRAY_ "STREAM-FILE-DESCRIPTOR", GRAY_ORDINARY, NULL, -1, OBJNULL}, {GRAY_ "STREAM-FILE-POSITION", GRAY_ORDINARY, NULL, -1, OBJNULL}, {GRAY_ "STREAM-FINISH-OUTPUT", GRAY_ORDINARY, NULL, -1, OBJNULL}, {GRAY_ "STREAM-FORCE-OUTPUT", GRAY_ORDINARY, NULL, -1, OBJNULL}, {GRAY_ "STREAM-FRESH-LINE", GRAY_ORDINARY, NULL, -1, OBJNULL}, {GRAY_ "STREAM-INTERACTIVE-P", GRAY_ORDINARY, NULL, -1, OBJNULL}, {GRAY_ "STREAM-LINE-COLUMN", GRAY_ORDINARY, NULL, -1, OBJNULL}, {GRAY_ "STREAM-LISTEN", GRAY_ORDINARY, NULL, -1, OBJNULL}, {GRAY_ "STREAM-PEEK-CHAR", GRAY_ORDINARY, NULL, -1, OBJNULL}, {GRAY_ "STREAM-READ-BYTE", GRAY_ORDINARY, NULL, -1, OBJNULL}, {GRAY_ "STREAM-READ-CHAR", GRAY_ORDINARY, NULL, -1, OBJNULL}, {GRAY_ "STREAM-READ-CHAR-NO-HANG", GRAY_ORDINARY, NULL, -1, OBJNULL}, {GRAY_ "STREAM-READ-LINE", GRAY_ORDINARY, NULL, -1, OBJNULL}, {GRAY_ "STREAM-READ-SEQUENCE", GRAY_ORDINARY, NULL, -1, OBJNULL}, {GRAY_ "STREAM-START-LINE-P", GRAY_ORDINARY, NULL, -1, OBJNULL}, {GRAY_ "STREAM-TERPRI", GRAY_ORDINARY, NULL, -1, OBJNULL}, {GRAY_ "STREAM-UNREAD-CHAR", GRAY_ORDINARY, NULL, -1, OBJNULL}, {GRAY_ "STREAM-WRITE-BYTE", GRAY_ORDINARY, NULL, -1, OBJNULL}, {GRAY_ "STREAM-WRITE-CHAR", GRAY_ORDINARY, NULL, -1, OBJNULL}, {GRAY_ "STREAM-WRITE-SEQUENCE", GRAY_ORDINARY, NULL, -1, OBJNULL}, {GRAY_ "STREAM-WRITE-STRING", GRAY_ORDINARY, NULL, -1, OBJNULL}, {GRAY_ "FUNDAMENTAL-STREAM", GRAY_ORDINARY, NULL, -1, OBJNULL}, {GRAY_ "FUNDAMENTAL-INPUT-STREAM", GRAY_ORDINARY, NULL, -1, OBJNULL}, {GRAY_ "FUNDAMENTAL-OUTPUT-STREAM", GRAY_ORDINARY, NULL, -1, OBJNULL}, {GRAY_ "FUNDAMENTAL-CHARACTER-STREAM", GRAY_ORDINARY, NULL, -1, OBJNULL}, {GRAY_ "FUNDAMENTAL-BINARY-STREAM", GRAY_ORDINARY, NULL, -1, OBJNULL}, {GRAY_ "FUNDAMENTAL-CHARACTER-INPUT-STREAM", GRAY_ORDINARY, NULL, -1, OBJNULL}, {GRAY_ "FUNDAMENTAL-CHARACTER-OUTPUT-STREAM", GRAY_ORDINARY, NULL, -1, OBJNULL}, {GRAY_ "FUNDAMENTAL-BINARY-INPUT-STREAM", GRAY_ORDINARY, NULL, -1, OBJNULL}, {GRAY_ "FUNDAMENTAL-BINARY-OUTPUT-STREAM", GRAY_ORDINARY, NULL, -1, OBJNULL}, #endif /* ECL_CLOS_STREAMS */ {SYS_ "LOG1P", SI_ORDINARY, si_log1p, 1, OBJNULL}, {EXT_ "BC-FILE", EXT_ORDINARY, si_compiled_function_file, 1, ECL_NIL}, {EXT_ "COMPILED-FUNCTION-FILE", EXT_ORDINARY, si_compiled_function_file, 1, ECL_NIL}, {SYS_ "PROPERTY-LIST", SI_ORDINARY, NULL, 1, OBJNULL}, {SYS_ "BYTECODES", SI_ORDINARY, NULL, 1, OBJNULL}, {SYS_ "HASH-EQL", SI_ORDINARY, si_hash_eql, -1, OBJNULL}, {SYS_ "HASH-EQUAL", SI_ORDINARY, si_hash_equal, -1, OBJNULL}, {SYS_ "HASH-EQUALP", SI_ORDINARY, si_hash_equalp, -1, OBJNULL}, {EXT_ "INTERACTIVE-INTERRUPT", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "STORAGE-EXHAUSTED", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "STACK-OVERFLOW", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "STACK-OVERFLOW-SIZE", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "STACK-OVERFLOW-TYPE", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "BINDING-STACK", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "FRAME-STACK", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "LISP-STACK", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "C-STACK", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "HEAP-SIZE", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "ILLEGAL-INSTRUCTION", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "SET-LIMIT", EXT_ORDINARY, si_set_limit, 2, OBJNULL}, {EXT_ "GET-LIMIT", EXT_ORDINARY, si_get_limit, 1, OBJNULL}, {SYS_ "RESET-MARGIN", EXT_ORDINARY, si_reset_margin, 1, OBJNULL}, {EXT_ "SEGMENTATION-VIOLATION", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "EXTENDED-STRING", EXT_ORDINARY, NULL, -1, OBJNULL}, {SYS_ "CHECK-PENDING-INTERRUPTS", SI_ORDINARY, si_check_pending_interrupts, 0, OBJNULL}, {KEY_ "LATIN-1", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "ISO-8859-1", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "UTF-8", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "UCS-2", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "UCS-4", KEYWORD, NULL, -1, OBJNULL}, {EXT_ "CONSTANTLY-T", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "CONSTANTLY-NIL", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "MAYBE-QUOTE", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "MAYBE-UNQUOTE", EXT_ORDINARY, NULL, -1, OBJNULL}, {KEY_ "CR", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "LF", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "CRLF", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "UCS-2BE", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "UCS-4BE", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "UCS-2LE", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "UCS-4LE", KEYWORD, NULL, -1, OBJNULL}, {EXT_ "LOAD-ENCODING", EXT_ORDINARY, ECL_NAME(si_load_encoding), 1, OBJNULL}, {EXT_ "MAKE-ENCODING", EXT_ORDINARY, si_make_encoding, 1, OBJNULL}, {EXT_ "ALL-ENCODINGS", EXT_ORDINARY, NULL, -1, OBJNULL}, {KEY_ "US-ASCII", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "LITTLE-ENDIAN", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "BIG-ENDIAN", KEYWORD, NULL, -1, OBJNULL}, {SYS_ "+UNICODE-DATABASE+", SI_CONSTANT, NULL, -1, ECL_NIL}, {EXT_ "COPY-FILE", EXT_ORDINARY, si_copy_file, 2, OBJNULL}, {EXT_ "FILL-ARRAY-WITH-ELT", EXT_ORDINARY, si_fill_array_with_elt, 4, OBJNULL}, {EXT_ "+ECL-VERSION-NUMBER+", EXT_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_VERSION_NUMBER)}, {EXT_ "*BYTECODES-COMPILER*", EXT_SPECIAL, NULL, -1, ECL_NIL}, {EXT_ "SHORT-FLOAT-POSITIVE-INFINITY", EXT_CONSTANT, NULL, -1, OBJNULL}, {EXT_ "SINGLE-FLOAT-POSITIVE-INFINITY", EXT_CONSTANT, NULL, -1, OBJNULL}, {EXT_ "DOUBLE-FLOAT-POSITIVE-INFINITY", EXT_CONSTANT, NULL, -1, OBJNULL}, {EXT_ "LONG-FLOAT-POSITIVE-INFINITY", EXT_CONSTANT, NULL, -1, OBJNULL}, {EXT_ "SHORT-FLOAT-NEGATIVE-INFINITY", EXT_CONSTANT, NULL, -1, OBJNULL}, {EXT_ "SINGLE-FLOAT-NEGATIVE-INFINITY", EXT_CONSTANT, NULL, -1, OBJNULL}, {EXT_ "DOUBLE-FLOAT-NEGATIVE-INFINITY", EXT_CONSTANT, NULL, -1, OBJNULL}, {EXT_ "LONG-FLOAT-NEGATIVE-INFINITY", EXT_CONSTANT, NULL, -1, OBJNULL}, {EXT_ "FLOAT-NAN-P", EXT_ORDINARY, si_float_nan_p, 1, OBJNULL}, {EXT_ "FLOAT-INFINITY-P", EXT_ORDINARY, si_float_infinity_p, 1, OBJNULL}, {SYS_ "READ-OBJECT-OR-IGNORE", EXT_ORDINARY, si_read_object_or_ignore, 2, OBJNULL}, {EXT_ "FLOAT-NAN-STRING", EXT_ORDINARY, NULL, 1, OBJNULL}, {EXT_ "FLOAT-INFINITY-STRING", EXT_ORDINARY, NULL, 1, OBJNULL}, {EXT_ "READTABLE-LOCK", EXT_ORDINARY, si_readtable_lock, -1, OBJNULL}, {SYS_ "+IO-SYNTAX-PROGV-LIST+", SI_CONSTANT, NULL, -1, OBJNULL}, {SYS_ "+ECL-SYNTAX-PROGV-LIST+", SI_CONSTANT, NULL, -1, OBJNULL}, {SYS_ "WITH-ECL-IO-SYNTAX", SI_ORDINARY, NULL, -1, OBJNULL}, {SYS_ "STREAM-EXTERNAL-FORMAT-SET", SI_ORDINARY, si_stream_external_format_set, 2, OBJNULL}, {KEY_ "SYSV", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "UNIX64", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "WIN64", KEYWORD, NULL, -1, OBJNULL}, {EXT_ "WEAK-POINTER", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "MAKE-WEAK-POINTER", EXT_ORDINARY, si_make_weak_pointer, 1, OBJNULL}, {EXT_ "WEAK-POINTER-VALUE", EXT_ORDINARY, si_weak_pointer_value, 1, OBJNULL}, {SYS_ "*ALLOW-WITH-INTERRUPTS*", SI_SPECIAL, NULL, -1, ECL_T}, {EXT_ "WITH-UNIQUE-NAMES", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "WITH-CLEAN-SYMBOLS", EXT_ORDINARY, NULL, -1, OBJNULL}, {SYS_ "HANDLE-SIGNAL", SI_ORDINARY, si_handle_signal, 2, OBJNULL}, {EXT_ "WITH-INTERRUPTS", MP_CONSTANT, NULL, -1, OBJNULL}, {EXT_ "WITHOUT-INTERRUPTS", MP_CONSTANT, NULL, -1, OBJNULL}, {EXT_ "WITH-LOCAL-INTERRUPTS", MP_CONSTANT, NULL, -1, OBJNULL}, {EXT_ "ALLOW-WITH-INTERRUPTS", MP_CONSTANT, NULL, -1, OBJNULL}, {SYS_ "*QUIT-TAG*", SI_SPECIAL, NULL, -1, OBJNULL}, {EXT_ "ARRAY-RAW-DATA", EXT_ORDINARY, si_array_raw_data, 1, OBJNULL}, {EXT_ "*PROGRAM-EXIT-CODE*", EXT_SPECIAL, NULL, -1, ecl_make_fixnum(0)}, {EXT_ "EXIT", EXT_ORDINARY, si_exit, -1, OBJNULL}, {EXT_ "ENVIRON", EXT_ORDINARY, si_environ, 0, OBJNULL}, {KEY_ "ENVIRON", KEYWORD, NULL, -1, OBJNULL}, {EXT_ "MAKE-EXTERNAL-PROCESS", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "EXTERNAL-PROCESS", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "EXTERNAL-PROCESS-PID", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "EXTERNAL-PROCESS-INPUT", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "EXTERNAL-PROCESS-OUTPUT", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "EXTERNAL-PROCESS-ERROR-STREAM", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "EXTERNAL-PROCESS-STATUS", EXT_ORDINARY, NULL, -1, OBJNULL}, {KEY_ "RUNNING", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "EXITED", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "SIGNALED", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "STOPPED", KEYWORD, NULL, -1, OBJNULL}, {EXT_ "EXTERNAL-PROCESS-WAIT", EXT_ORDINARY, si_external_process_wait, -1, OBJNULL}, #if defined(ECL_MS_WINDOWS_HOST) || defined(cygwin) {SYS_ "CLOSE-WINDOWS-HANDLE", SI_ORDINARY, si_close_windows_handle, 1, OBJNULL}, #else {SYS_ "CLOSE-WINDOWS-HANDLE", SI_ORDINARY, NULL, -1, OBJNULL}, #endif {EXT_ "*INVOKE-DEBUGGER-HOOK*", EXT_SPECIAL, NULL, -1, ECL_NIL}, {EXT_ "*DOCUMENTATION-POOL*", EXT_SPECIAL, NULL, -1, ECL_NIL}, {EXT_ "ANNOTATE", EXT_ORDINARY, NULL, -1, ECL_NIL}, {EXT_ "GET-ANNOTATION", EXT_ORDINARY, NULL, -1, ECL_NIL}, {EXT_ "REMOVE-ANNOTATION", EXT_ORDINARY, NULL, -1, ECL_NIL}, {EXT_ "FUNCTION-LAMBDA-LIST", EXT_ORDINARY, NULL, -1, ECL_NIL}, {EXT_ "DEFAULT-ANNOTATION-LOGIC", EXT_ORDINARY, NULL, -1, ECL_NIL}, {EXT_ "OPTIONAL-ANNOTATION", EXT_ORDINARY, NULL, -1, ECL_NIL}, {EXT_ "LOCATION", EXT_ORDINARY, NULL, -1, ECL_NIL}, {EXT_ "LISP-IMPLEMENTATION-VCS-ID", EXT_ORDINARY, ECL_NAME(si_lisp_implementation_vcs_id), 0, ECL_NIL}, {SYS_ "SIGNAL-SERVICING", SI_ORDINARY, NULL, -1, ECL_NIL}, {EXT_ "*DEFAULT-EXTERNAL-FORMAT*", EXT_SPECIAL, NULL, -1, ECL_T}, {KEY_ "PASS-THROUGH", KEYWORD, NULL, -1, OBJNULL}, {EXT_ "WITH-BACKEND", EXT_ORDINARY, NULL, -1, OBJNULL}, {KEY_ "BYTECODES", KEYWORD, NULL, 1, OBJNULL}, {KEY_ "C/C++", KEYWORD, NULL, 1, OBJNULL}, {EXT_ "ARRAY-INDEX", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "ANSI-STREAM", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "COMPLEX-ARRAY", EXT_ORDINARY, NULL, -1, OBJNULL}, {SYS_ "SEQUENCE-START-END", SI_ORDINARY, si_sequence_start_end, 4, OBJNULL}, {SYS_ "SEQUENCE-COUNT", SI_ORDINARY, NULL, -1, OBJNULL}, {SYS_ "SHRINK-VECTOR", SI_ORDINARY, NULL, -1, OBJNULL}, {SYS_ "COPY-SUBARRAY", SI_ORDINARY, si_copy_subarray, 5, OBJNULL}, {SYS_ "CONS-CAR", SI_ORDINARY, cl_car, 1, OBJNULL}, {SYS_ "CONS-CDR", SI_ORDINARY, cl_cdr, 1, OBJNULL}, {EXT_ "COMPILER-TYPECASE", EXT_ORDINARY, NULL, -1, OBJNULL}, {SYS_ "ASSERT-FAILURE", SI_ORDINARY, ECL_NAME(si_assert_failure), -1, OBJNULL}, {SYS_ "CCASE-ERROR", SI_ORDINARY, ECL_NAME(si_ccase_error), 3, OBJNULL}, {SYS_ "ECASE-ERROR", SI_ORDINARY, ECL_NAME(si_ecase_error), 2, OBJNULL}, {SYS_ "ETYPECASE-ERROR", SI_ORDINARY, ECL_NAME(si_etypecase_error), 2, OBJNULL}, {SYS_ "CTYPECASE-ERROR", SI_ORDINARY, ECL_NAME(si_ctypecase_error), 3, OBJNULL}, {SYS_ "DO-CHECK-TYPE", SI_ORDINARY, ECL_NAME(si_do_check_type), 4, OBJNULL}, {SYS_ "SERIALIZE", SI_ORDINARY, si_serialize, 1, OBJNULL}, {SYS_ "DESERIALIZE", SI_ORDINARY, si_deserialize, 1, OBJNULL}, {EXT_ "ARRAY-ELEMENT-TYPE-BYTE-SIZE", EXT_ORDINARY, si_array_element_type_byte_size, 1, OBJNULL}, /* #ifdef ECL_SSE2 */ {EXT_ "SSE-PACK", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "SSE-PACK-P", EXT_ORDINARY, IF_SSE2(si_sse_pack_p), 1, OBJNULL}, {EXT_ "SSE-PACK-AS-ELT-TYPE", EXT_ORDINARY, IF_SSE2(si_sse_pack_as_elt_type), 2, OBJNULL}, {EXT_ "VECTOR-TO-SSE-PACK", EXT_ORDINARY, IF_SSE2(si_vector_to_sse_pack), 1, OBJNULL}, {EXT_ "SSE-PACK-TO-VECTOR", EXT_ORDINARY, IF_SSE2(si_sse_pack_to_vector), 2, OBJNULL}, {EXT_ "INT-SSE-PACK", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "FLOAT-SSE-PACK", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "DOUBLE-SSE-PACK", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "SSE-PACK-ELEMENT-TYPE", EXT_ORDINARY, IF_SSE2(si_sse_pack_element_type), 1, OBJNULL}, {EXT_ "*SSE-PACK-PRINT-MODE*", EXT_SPECIAL, NULL, -1, ECL_NIL}, /* #endif ECL_SSE2 */ {EXT_ "UNIX-SIGNAL-RECEIVED", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "UNIX-SIGNAL-RECEIVED-CODE", EXT_ORDINARY, NULL, -1, OBJNULL}, {KEY_ "CODE", KEYWORD, NULL, -1, OBJNULL}, {EXT_ "ASSUME-RIGHT-TYPE", EXT_ORDINARY, NULL, -1, OBJNULL}, {SYS_ "FLOAT-TO-DIGITS", SI_ORDINARY, si_float_to_digits, 4, OBJNULL}, {SYS_ "FLOAT-TO-STRING-FREE", SI_ORDINARY, si_float_to_string_free, 4, OBJNULL}, {SYS_ "INTEGER-TO-STRING", SI_ORDINARY, si_integer_to_string, 5, OBJNULL}, {SYS_ "PRINT-UNREADABLE-OBJECT-FUNCTION", SI_ORDINARY, si_print_unreadable_object_function, 5, OBJNULL}, {EXT_ "DUMP-C-BACKTRACE", EXT_ORDINARY, si_dump_c_backtrace, 1, OBJNULL}, {EXT_ "+PROCESS-STANDARD-INPUT+", EXT_CONSTANT, NULL, -1, ECL_NIL}, {EXT_ "+PROCESS-STANDARD-OUTPUT+", EXT_CONSTANT, NULL, -1, ECL_NIL}, {EXT_ "+PROCESS-ERROR-OUTPUT+", EXT_CONSTANT, NULL, -1, ECL_NIL}, {EXT_ "*HELP-MESSAGE*", EXT_SPECIAL, NULL, -1, ECL_NIL}, {EXT_ "*LISP-INIT-FILE-LIST*", EXT_SPECIAL, NULL, -1, ECL_NIL}, {EXT_ "+DEFAULT-COMMAND-ARG-RULES+", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "COMMAND-ARGS", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "*COMMAND-ARGS*", EXT_SPECIAL, NULL, -1, ECL_NIL}, {EXT_ "PROCESS-COMMAND-ARGS", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "*UNPROCESSED-ECL-COMMAND-ARGS*", EXT_SPECIAL, NULL, -1, ECL_NIL}, /* #ifdef ECL_UNICODE */ {KEY_ "OCTETS", KEYWORD, NULL, -1, OBJNULL}, {EXT_ "CHARACTER-CODING-ERROR", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "CHARACTER-CODING-ERROR-EXTERNAL-FORMAT", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "CHARACTER-ENCODING-ERROR", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "CHARACTER-ENCODING-ERROR-CODE", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "CHARACTER-DECODING-ERROR", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "CHARACTER-DECODING-ERROR-OCTETS", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "STREAM-DECODING-ERROR", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "STREAM-ENCODING-ERROR", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "DECODING-ERROR", EXT_ORDINARY, NULL, 3, OBJNULL}, {EXT_ "ENCODING-ERROR", EXT_ORDINARY, NULL, 3, OBJNULL}, /* #endif ECL_UNICODE */ {SYS_ "PROPER-LIST-P", SI_ORDINARY, si_proper_list_p, 1, OBJNULL}, {SYS_ "TRACED-OLD-DEFINITION", SI_ORDINARY, ECL_NAME(si_traced_old_definition), 1, OBJNULL}, {SYS_ "*TRACE-LIST*", SI_SPECIAL, NULL, -1, ECL_NIL}, {SYS_ "FUNCTION-BOUNDARY", SI_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "*INSPECTOR-HOOK*", EXT_SPECIAL, NULL, -1, ECL_NIL}, {KEY_ "RESOLVE-SYMLINKS", KEYWORD, NULL, -1, OBJNULL}, {SYS_ "LOAD-BYTECODES", SI_ORDINARY, si_load_bytecodes, 4, OBJNULL}, {KEY_ "SHARED", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "PRIVATE", KEYWORD, NULL, -1, OBJNULL}, {EXT_ "MMAP", EXT_ORDINARY, si_mmap, -1, OBJNULL}, {EXT_ "MUNMAP", EXT_ORDINARY, si_munmap, 1, OBJNULL}, {EXT_ "MMAP-ARRAY", EXT_ORDINARY, si_mmap_array, 1, OBJNULL}, {SYS_ "GET-CDATA", SI_ORDINARY, si_get_cdata, 1, OBJNULL}, {SYS_ "ADD-CDATA", SI_ORDINARY, si_add_cdata, 2, OBJNULL}, /* * CDR-5 http://cdr.eurolisp.org/document/5/extra-num-types.html */ {EXT_ "NEGATIVE-FIXNUM", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "NON-NEGATIVE-FIXNUM", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "NON-POSITIVE-FIXNUM", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "POSITIVE-FIXNUM", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "NEGATIVE-FIXNUM-P", EXT_ORDINARY, ECL_NAME(si_negative_fixnum_p), 1, OBJNULL}, {EXT_ "POSITIVE-FIXNUM-P", EXT_ORDINARY, ECL_NAME(si_positive_fixnum_p), 1, OBJNULL}, {EXT_ "NON-NEGATIVE-FIXNUM-P", EXT_ORDINARY, ECL_NAME(si_non_negative_fixnum_p), 1, OBJNULL}, {EXT_ "NON-POSITIVE-FIXNUM-P", EXT_ORDINARY, ECL_NAME(si_non_positive_fixnum_p), 1, OBJNULL}, {EXT_ "NEGATIVE-INTEGER", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "NON-NEGATIVE-INTEGER", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "NON-POSITIVE-INTEGER", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "POSITIVE-INTEGER", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "NEGATIVE-INTEGER-P", EXT_ORDINARY, ECL_NAME(si_negative_integer_p), 1, OBJNULL}, {EXT_ "POSITIVE-INTEGER-P", EXT_ORDINARY, ECL_NAME(si_positive_integer_p), 1, OBJNULL}, {EXT_ "NON-NEGATIVE-INTEGER-P", EXT_ORDINARY, ECL_NAME(si_non_negative_integer_p), 1, OBJNULL}, {EXT_ "NON-POSITIVE-INTEGER-P", EXT_ORDINARY, ECL_NAME(si_non_positive_integer_p), 1, OBJNULL}, {EXT_ "NEGATIVE-RATIONAL", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "NON-NEGATIVE-RATIONAL", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "NON-POSITIVE-RATIONAL", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "POSITIVE-RATIONAL", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "NEGATIVE-RATIONAL-P", EXT_ORDINARY, ECL_NAME(si_negative_rational_p), 1, OBJNULL}, {EXT_ "POSITIVE-RATIONAL-P", EXT_ORDINARY, ECL_NAME(si_positive_rational_p), 1, OBJNULL}, {EXT_ "NON-NEGATIVE-RATIONAL-P", EXT_ORDINARY, ECL_NAME(si_non_negative_rational_p), 1, OBJNULL}, {EXT_ "NON-POSITIVE-RATIONAL-P", EXT_ORDINARY, ECL_NAME(si_non_positive_rational_p), 1, OBJNULL}, {EXT_ "NEGATIVE-RATIO", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "NON-NEGATIVE-RATIO", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "NON-POSITIVE-RATIO", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "POSITIVE-RATIO", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "NEGATIVE-RATIO-P", EXT_ORDINARY, ECL_NAME(si_negative_ratio_p), 1, OBJNULL}, {EXT_ "POSITIVE-RATIO-P", EXT_ORDINARY, ECL_NAME(si_positive_ratio_p), 1, OBJNULL}, {EXT_ "NON-NEGATIVE-RATIO-P", EXT_ORDINARY, ECL_NAME(si_non_negative_ratio_p), 1, OBJNULL}, {EXT_ "NON-POSITIVE-RATIO-P", EXT_ORDINARY, ECL_NAME(si_non_positive_ratio_p), 1, OBJNULL}, {EXT_ "NEGATIVE-REAL", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "NON-NEGATIVE-REAL", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "NON-POSITIVE-REAL", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "POSITIVE-REAL", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "NEGATIVE-REAL-P", EXT_ORDINARY, ECL_NAME(si_negative_real_p), 1, OBJNULL}, {EXT_ "POSITIVE-REAL-P", EXT_ORDINARY, ECL_NAME(si_positive_real_p), 1, OBJNULL}, {EXT_ "NON-NEGATIVE-REAL-P", EXT_ORDINARY, ECL_NAME(si_non_negative_real_p), 1, OBJNULL}, {EXT_ "NON-POSITIVE-REAL-P", EXT_ORDINARY, ECL_NAME(si_non_positive_real_p), 1, OBJNULL}, {EXT_ "NEGATIVE-FLOAT", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "NON-NEGATIVE-FLOAT", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "NON-POSITIVE-FLOAT", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "POSITIVE-FLOAT", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "NEGATIVE-FLOAT-P", EXT_ORDINARY, ECL_NAME(si_negative_float_p), 1, OBJNULL}, {EXT_ "POSITIVE-FLOAT-P", EXT_ORDINARY, ECL_NAME(si_positive_float_p), 1, OBJNULL}, {EXT_ "NON-NEGATIVE-FLOAT-P", EXT_ORDINARY, ECL_NAME(si_non_negative_float_p), 1, OBJNULL}, {EXT_ "NON-POSITIVE-FLOAT-P", EXT_ORDINARY, ECL_NAME(si_non_positive_float_p), 1, OBJNULL}, {EXT_ "NEGATIVE-SHORT-FLOAT", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "NON-NEGATIVE-SHORT-FLOAT", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "NON-POSITIVE-SHORT-FLOAT", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "POSITIVE-SHORT-FLOAT", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "NEGATIVE-SHORT-FLOAT-P", EXT_ORDINARY, ECL_NAME(si_negative_short_float_p), 1, OBJNULL}, {EXT_ "POSITIVE-SHORT-FLOAT-P", EXT_ORDINARY, ECL_NAME(si_positive_short_float_p), 1, OBJNULL}, {EXT_ "NON-NEGATIVE-SHORT-FLOAT-P", EXT_ORDINARY, ECL_NAME(si_non_negative_short_float_p), 1, OBJNULL}, {EXT_ "NON-POSITIVE-SHORT-FLOAT-P", EXT_ORDINARY, ECL_NAME(si_non_positive_short_float_p), 1, OBJNULL}, {EXT_ "NEGATIVE-SINGLE-FLOAT", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "NON-NEGATIVE-SINGLE-FLOAT", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "NON-POSITIVE-SINGLE-FLOAT", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "POSITIVE-SINGLE-FLOAT", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "NEGATIVE-SINGLE-FLOAT-P", EXT_ORDINARY, ECL_NAME(si_negative_single_float_p), 1, OBJNULL}, {EXT_ "POSITIVE-SINGLE-FLOAT-P", EXT_ORDINARY, ECL_NAME(si_positive_single_float_p), 1, OBJNULL}, {EXT_ "NON-NEGATIVE-SINGLE-FLOAT-P", EXT_ORDINARY, ECL_NAME(si_non_negative_single_float_p), 1, OBJNULL}, {EXT_ "NON-POSITIVE-SINGLE-FLOAT-P", EXT_ORDINARY, ECL_NAME(si_non_positive_single_float_p), 1, OBJNULL}, {EXT_ "NEGATIVE-DOUBLE-FLOAT", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "NON-NEGATIVE-DOUBLE-FLOAT", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "NON-POSITIVE-DOUBLE-FLOAT", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "POSITIVE-DOUBLE-FLOAT", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "NEGATIVE-DOUBLE-FLOAT-P", EXT_ORDINARY, ECL_NAME(si_negative_double_float_p), 1, OBJNULL}, {EXT_ "POSITIVE-DOUBLE-FLOAT-P", EXT_ORDINARY, ECL_NAME(si_positive_double_float_p), 1, OBJNULL}, {EXT_ "NON-NEGATIVE-DOUBLE-FLOAT-P", EXT_ORDINARY, ECL_NAME(si_non_negative_double_float_p), 1, OBJNULL}, {EXT_ "NON-POSITIVE-DOUBLE-FLOAT-P", EXT_ORDINARY, ECL_NAME(si_non_positive_double_float_p), 1, OBJNULL}, {EXT_ "NEGATIVE-LONG-FLOAT", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "NON-NEGATIVE-LONG-FLOAT", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "NON-POSITIVE-LONG-FLOAT", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "POSITIVE-LONG-FLOAT", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "NEGATIVE-LONG-FLOAT-P", EXT_ORDINARY, ECL_NAME(si_negative_long_float_p), 1, OBJNULL}, {EXT_ "POSITIVE-LONG-FLOAT-P", EXT_ORDINARY, ECL_NAME(si_positive_long_float_p), 1, OBJNULL}, {EXT_ "NON-NEGATIVE-LONG-FLOAT-P", EXT_ORDINARY, ECL_NAME(si_non_negative_long_float_p), 1, OBJNULL}, {EXT_ "NON-POSITIVE-LONG-FLOAT-P", EXT_ORDINARY, ECL_NAME(si_non_positive_long_float_p), 1, OBJNULL}, {EXT_ "ARRAY-INDEX-P", EXT_ORDINARY, ECL_NAME(si_array_index_p), 1, OBJNULL}, {EXT_ "SEQUENCE-STREAM", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "MAKE-SEQUENCE-INPUT-STREAM", EXT_ORDINARY, si_make_sequence_input_stream, -1, OBJNULL}, {EXT_ "MAKE-SEQUENCE-OUTPUT-STREAM", EXT_ORDINARY, si_make_sequence_output_stream, -1, OBJNULL}, {EXT_ "CHMOD", EXT_ORDINARY, si_chmod, 2, OBJNULL}, {SYS_ "MISSING-KEYWORD", SI_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "HASH-TABLE-CONTENT", EXT_ORDINARY, si_hash_table_content, 1, OBJNULL}, {EXT_ "HASH-TABLE-FILL", EXT_ORDINARY, si_hash_table_fill, 2, OBJNULL}, {SYS_ "REPORT-FUNCTION", SI_ORDINARY, NULL, -1, OBJNULL}, {SYS_ "DO-DEFSETF", SI_ORDINARY, ECL_NAME(si_do_defsetf), -1, OBJNULL}, {SYS_ "DO-DEFINE-SETF-METHOD", SI_ORDINARY, ECL_NAME(si_do_define_setf_method), 2, OBJNULL}, {SYS_ "SETF-DEFINITION", SI_ORDINARY, ECL_NAME(si_setf_definition), 2, OBJNULL}, {EXT_ "ASSUME-NO-ERRORS", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "ASSUME-TYPES-DONT-CHANGE", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "CHECK-ARGUMENTS-TYPE", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "INLINE-ACCESSORS", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "INLINE-TYPE-CHECKS", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "EVALUATE-FORMS", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "TYPE-ASSERTIONS", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "CHECK-STACK-OVERFLOW", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "ARRAY-BOUNDS-CHECK", EXT_ORDINARY, NULL, -1, OBJNULL}, {KEY_ "VALUE", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "KEY-AND-VALUE", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "WEAKNESS", KEYWORD, NULL, -1, OBJNULL}, {EXT_ "HASH-TABLE-WEAKNESS", EXT_ORDINARY, si_hash_table_weakness, 1, OBJNULL}, {EXT_ "TRULY-THE", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "CHECKED-VALUE", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "INSTALL-BYTECODES-COMPILER", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "INSTALL-C-COMPILER", EXT_ORDINARY, NULL, -1, OBJNULL}, {FFI_ "C-CHAR-BIT", FFI_CONSTANT, NULL, -1, ecl_make_fixnum(CHAR_BIT)}, {FFI_ "C-CHAR-MAX", FFI_CONSTANT, NULL, -1, ecl_make_fixnum(CHAR_MAX)}, {FFI_ "C-CHAR-MIN", FFI_CONSTANT, NULL, -1, ecl_make_fixnum(CHAR_MIN)}, {FFI_ "C-INT-MAX", FFI_CONSTANT, NULL, -1, OBJNULL}, /* See main.d */ {FFI_ "C-INT-MIN", FFI_CONSTANT, NULL, -1, OBJNULL}, /* See main.d */ {FFI_ "C-SHORT-MAX", FFI_CONSTANT, NULL, -1, ecl_make_fixnum(SHRT_MAX)}, {FFI_ "C-SHORT-MIN", FFI_CONSTANT, NULL, -1, ecl_make_fixnum(SHRT_MIN)}, {FFI_ "C-LONG-MAX", FFI_CONSTANT, NULL, -1, OBJNULL}, /* See main.d */ {FFI_ "C-LONG-MIN", FFI_CONSTANT, NULL, -1, OBJNULL}, /* See main.d */ {FFI_ "C-LONG-LONG-MAX",FFI_CONSTANT,NULL,-1,OBJNULL}, /* See main.d */ {FFI_ "C-UCHAR-MAX", FFI_CONSTANT, NULL, -1, ecl_make_fixnum(UCHAR_MAX)}, {FFI_ "C-UINT-MAX", FFI_CONSTANT, NULL, -1, OBJNULL}, /* See main.d */ {FFI_ "C-USHORT-MAX", FFI_CONSTANT, NULL, -1, ecl_make_fixnum(USHRT_MAX)}, {FFI_ "C-ULONG-MAX", FFI_CONSTANT, NULL, -1, OBJNULL}, /* See main.d */ {FFI_ "C-ULONG-LONG-MAX",FFI_CONSTANT,NULL,-1,OBJNULL}, /* See main.d */ #ifdef ecl_long_long_t {FFI_ "C-LONG-LONG-BIT", FFI_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_LONG_LONG_BITS)}, #else {FFI_ "C-LONG-LONG-BIT", FFI_CONSTANT, NULL, -1, OBJNULL}, #endif {FFI_ "*USE-DFFI*", FFI_ORDINARY, NULL, -1, OBJNULL}, {FFI_ "+NULL-CSTRING-POINTER+", FFI_ORDINARY, NULL, -1, OBJNULL}, {FFI_ "ALLOCATE-FOREIGN-OBJECT", FFI_ORDINARY, NULL, -1, OBJNULL}, {FFI_ "ALLOCATE-FOREIGN-STRING", FFI_ORDINARY, NULL, -1, OBJNULL}, {FFI_ "C-INLINE", FFI_ORDINARY, NULL, -1, OBJNULL}, {FFI_ "C-PROGN", FFI_ORDINARY, NULL, -1, OBJNULL}, {FFI_ "CALLBACK", FFI_ORDINARY, NULL, -1, OBJNULL}, {FFI_ "CHAR*", FFI_ORDINARY, NULL, -1, OBJNULL}, {FFI_ "CHAR-ARRAY-TO-POINTER", FFI_ORDINARY, NULL, -1, OBJNULL}, {FFI_ "CLINES", FFI_ORDINARY, NULL, -1, OBJNULL}, {FFI_ "CONVERT-FROM-CSTRING", FFI_ORDINARY, NULL, -1, OBJNULL}, {FFI_ "CONVERT-FROM-FOREIGN-STRING", FFI_ORDINARY, NULL, -1, OBJNULL}, {FFI_ "CONVERT-TO-CSTRING", FFI_ORDINARY, NULL, -1, OBJNULL}, {FFI_ "CONVERT-TO-FOREIGN-STRING", FFI_ORDINARY, NULL, -1, OBJNULL}, {FFI_ "DEF-ARRAY", FFI_ORDINARY, NULL, -1, OBJNULL}, {FFI_ "DEF-ARRAY-POINTER", FFI_ORDINARY, NULL, -1, OBJNULL}, {FFI_ "DEF-CONSTANT", FFI_ORDINARY, NULL, -1, OBJNULL}, {FFI_ "DEF-ENUM", FFI_ORDINARY, NULL, -1, OBJNULL}, {FFI_ "DEF-FOREIGN-TYPE", FFI_ORDINARY, NULL, -1, OBJNULL}, {FFI_ "DEF-FOREIGN-VAR", FFI_ORDINARY, NULL, -1, OBJNULL}, {FFI_ "DEF-FUNCTION", FFI_ORDINARY, NULL, -1, OBJNULL}, {FFI_ "DEF-STRUCT", FFI_ORDINARY, NULL, -1, OBJNULL}, {FFI_ "DEF-TYPE", FFI_ORDINARY, NULL, -1, OBJNULL}, {FFI_ "DEF-UNION", FFI_ORDINARY, NULL, -1, OBJNULL}, {FFI_ "DEFCALLBACK", FFI_ORDINARY, NULL, -1, OBJNULL}, {FFI_ "DEFCBODY", FFI_ORDINARY, NULL, -1, OBJNULL}, {FFI_ "DEFENTRY", FFI_ORDINARY, NULL, -1, OBJNULL}, {FFI_ "DEFINLINE", FFI_ORDINARY, NULL, -1, OBJNULL}, {FFI_ "DEFLA", FFI_ORDINARY, NULL, -1, OBJNULL}, {FFI_ "DEREF-ARRAY", FFI_ORDINARY, NULL, -1, OBJNULL}, {FFI_ "DEREF-POINTER", FFI_ORDINARY, NULL, -1, OBJNULL}, {FFI_ "DOUBLE", FFI_ORDINARY, NULL, -1, OBJNULL}, {FFI_ "ENSURE-CHAR-CHARACTER", FFI_ORDINARY, NULL, -1, OBJNULL}, {FFI_ "ENSURE-CHAR-INTEGER", FFI_ORDINARY, NULL, -1, OBJNULL}, {FFI_ "ENSURE-CHAR-STORABLE", FFI_ORDINARY, NULL, -1, OBJNULL}, {FFI_ "FIND-FOREIGN-LIBRARY", FFI_ORDINARY, NULL, -1, OBJNULL}, {FFI_ "FOREIGN-STRING-LENGTH", FFI_ORDINARY, NULL, -1, OBJNULL}, {FFI_ "FREE-CSTRING", FFI_ORDINARY, NULL, -1, OBJNULL}, {FFI_ "FREE-FOREIGN-OBJECT", FFI_ORDINARY, NULL, -1, OBJNULL}, {FFI_ "GET-SLOT-POINTER", FFI_ORDINARY, NULL, -1, OBJNULL}, {FFI_ "GET-SLOT-VALUE", FFI_ORDINARY, NULL, -1, OBJNULL}, {FFI_ "INT", FFI_ORDINARY, NULL, -1, OBJNULL}, {FFI_ "LOAD-FOREIGN-LIBRARY", FFI_ORDINARY, NULL, -1, OBJNULL}, {FFI_ "MAKE-NULL-POINTER", FFI_ORDINARY, NULL, -1, OBJNULL}, {FFI_ "MAKE-POINTER", FFI_ORDINARY, NULL, -1, OBJNULL}, {FFI_ "NULL-CHAR-P", FFI_ORDINARY, NULL, -1, OBJNULL}, {FFI_ "OBJECT", FFI_ORDINARY, NULL, -1, OBJNULL}, {FFI_ "POINTER-ADDRESS", FFI_ORDINARY, NULL, -1, OBJNULL}, {FFI_ "SIZE-OF-FOREIGN-TYPE", FFI_ORDINARY, NULL, -1, OBJNULL}, {FFI_ "VOID", FFI_ORDINARY, NULL, -1, OBJNULL}, {FFI_ "WITH-CAST-POINTER", FFI_ORDINARY, NULL, -1, OBJNULL}, {FFI_ "WITH-CSTRING", FFI_ORDINARY, NULL, -1, OBJNULL}, {FFI_ "WITH-CSTRINGS", FFI_ORDINARY, NULL, -1, OBJNULL}, {FFI_ "WITH-FOREIGN-OBJECT", FFI_ORDINARY, NULL, -1, OBJNULL}, {FFI_ "WITH-FOREIGN-OBJECTS", FFI_ORDINARY, NULL, -1, OBJNULL}, {FFI_ "WITH-FOREIGN-STRING", FFI_ORDINARY, NULL, -1, OBJNULL}, {FFI_ "WITH-FOREIGN-STRINGS", FFI_ORDINARY, NULL, -1, OBJNULL}, {SYS_ "BIND-SIMPLE-RESTARTS", SI_ORDINARY, ECL_NAME(si_bind_simple_restarts), 2, OBJNULL}, {SYS_ "BIND-SIMPLE-HANDLERS", SI_ORDINARY, ECL_NAME(si_bind_simple_handlers), 2, OBJNULL}, {EXT_ "CONSTANT-FORM-VALUE", EXT_ORDINARY, si_constant_form_value, -1, OBJNULL}, {EXT_ "CONSTANTP-INNER", EXT_ORDINARY, si_constantp_inner, -1, OBJNULL}, {SYS_ "MAKE-BACKQ-VECTOR", SI_ORDINARY, si_make_backq_vector, 3, OBJNULL}, {SYS_ "RATIOP", SI_ORDINARY, ECL_NAME(si_ratiop), 1, OBJNULL}, {SYS_ "SHORT-FLOAT-P", SI_ORDINARY, ECL_NAME(si_short_float_p), 1, OBJNULL}, {SYS_ "SINGLE-FLOAT-P", SI_ORDINARY, ECL_NAME(si_single_float_p), 1, OBJNULL}, {SYS_ "DOUBLE-FLOAT-P", SI_ORDINARY, ECL_NAME(si_double_float_p), 1, OBJNULL}, {SYS_ "LONG-FLOAT-P", SI_ORDINARY, ECL_NAME(si_long_float_p), 1, OBJNULL}, {SYS_ "COPY-HASH-TABLE", SI_ORDINARY, si_copy_hash_table, 1, OBJNULL}, /* Tag for end of list */ {NULL, CL_ORDINARY, NULL, -1, OBJNULL}}; ecl-16.1.2/src/c/symbols_list2.h000066400000000000000000002211031266352375300163460ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ #ifdef ECL_CMU_FORMAT # define ECL_NAME_PPRINT(x) ECL_NAME(x) #else # define ECL_NAME_PPRINT(x) NULL #endif #ifdef ECL_FINAL # define ECL_NAME(x) x #else # define ECL_NAME(x) NULL #endif #ifdef ECL_RELATIVE_PACKAGE_NAMES # define RELATIVE_PACKAGES_P ECL_T #else # define RELATIVE_PACKAGES_P ECL_NIL #endif #ifdef DPP #define CLOS_ "CLOS::" #define EXT_ "EXT::" #define SYS_ "SI::" #define MP_ "MP::" #define KEY_ ":" #define GRAY_ "GRAY::" #define FFI_ "FFI::" typedef struct { const char *name, *translation; } cl_symbol_initializer; #else #include "ecl_constants.h" #define CLOS_ #define EXT_ #define SYS_ #define MP_ #define KEY_ #define GRAY_ #define FFI_ #endif /* * Conditional addition of functions and symbols. The list of symbols can * not depend on the features, because otherwise the sources will and we will * not be able to cross-compile. */ #ifdef ECL_THREADS # define IF_MP(x) x #else # define IF_MP(x) NULL #endif #ifdef TCP # define IF_TCP(x) x #else # define IF_TCP(x) NULL #endif #ifdef PROFILE # define IF_PROFILE(x) x #else # define IF_PROFILE(x) NULL #endif #ifdef ECL_RELATIVE_PACKAGE_NAMES # define IF_RELPACK(x) x #else # define IF_RELPACK(x) NULL #endif #ifndef ECL_CLOS_STREAMS # undef GRAY_ # define GRAY_ SYS_ #endif #ifdef ECL_SSE2 # define IF_SSE2(x) x #else # define IF_SSE2(x) NULL #endif #if defined(HAVE_LIBFFI) || defined(ECL_DYNAMIC_FFI) # define IF_DFFI(x) x #else # define IF_DFFI(x) NULL #endif #if defined(HAVE_LIBFFI) # define IF_LIBFFI(x) x #else # define IF_LIBFFI(x) NULL #endif cl_symbol_initializer cl_symbols[] = { {"NIL",NULL}, {"T",NULL}, {SYS_ "UNBOUND","si_unbound"}, {SYS_ "PROTECT-TAG",NULL}, {SYS_ "*RESTART-CLUSTERS*",NULL}, {SYS_ "*HANDLER-CLUSTERS*",NULL}, /* LISP PACKAGE */ {"&ALLOW-OTHER-KEYS",NULL}, {"&AUX",NULL}, {"&BODY",NULL}, {"&ENVIRONMENT",NULL}, {"&KEY",NULL}, {"&OPTIONAL",NULL}, {"&REST",NULL}, {"&WHOLE",NULL}, {"+","cl_P"}, {"++",NULL}, {"+++",NULL}, {"-","cl_M"}, {"*","cl_X"}, {"**",NULL}, {"***",NULL}, {"/","cl_N"}, {"//",NULL}, {"///",NULL}, {"/=","cl_NE"}, {"*BREAK-ON-SIGNALS*",NULL}, {"*COMPILE-FILE-PATHNAME*",NULL}, {"*COMPILE-FILE-TRUENAME*",NULL}, {"*COMPILE-PRINT*",NULL}, {"*COMPILE-VERBOSE*",NULL}, {"*DEBUG-IO*",NULL}, {"*DEBUGGER-HOOK*",NULL}, {"*DEFAULT-PATHNAME-DEFAULTS*",NULL}, {"*ERROR-OUTPUT*",NULL}, {"*FEATURES*",NULL}, {"*GENSYM-COUNTER*",NULL}, {"*LOAD-PATHNAME*",NULL}, {"*LOAD-PRINT*",NULL}, {"*LOAD-TRUENAME*",NULL}, {"*LOAD-VERBOSE*",NULL}, {"*MACROEXPAND-HOOK*",NULL}, {"*MODULES*",NULL}, {EXT_ "*MODULE-PROVIDER-FUNCTIONS*",NULL}, {"*PACKAGE*",NULL}, {"*PRINT-ARRAY*",NULL}, {"*PRINT-BASE*",NULL}, {"*PRINT-CASE*",NULL}, {"*PRINT-CIRCLE*",NULL}, {"*PRINT-ESCAPE*",NULL}, {"*PRINT-GENSYM*",NULL}, {"*PRINT-LENGTH*",NULL}, {"*PRINT-LEVEL*",NULL}, {"*PRINT-LINES*",NULL}, {"*PRINT-MISER-WIDTH*",NULL}, {"*PRINT-PPRINT-DISPATCH*",NULL}, #if defined(ECL_CMU_FORMAT) {"*PRINT-PRETTY*",NULL}, #else {"*PRINT-PRETTY*",NULL}, #endif {"*PRINT-RADIX*",NULL}, {"*PRINT-READABLY*",NULL}, {"*PRINT-RIGHT-MARGIN*",NULL}, {"*QUERY-IO*",NULL}, {"*RANDOM-STATE*",NULL}, {"*READ-BASE*",NULL}, {"*READ-DEFAULT-FLOAT-FORMAT*",NULL}, {"*READ-EVAL*",NULL}, {"*READ-SUPPRESS*",NULL}, {"*READTABLE*",NULL}, {"*STANDARD-INPUT*",NULL}, {"*STANDARD-OUTPUT*",NULL}, {"*TERMINAL-IO*",NULL}, {"*TRACE-OUTPUT*",NULL}, {"1+","cl_1P"}, {"1-","cl_1M"}, {"<","cl_L"}, {"<=","cl_LE"}, {"=","cl_E"}, {">","cl_G"}, {">=","cl_GE"}, {"ABORT","ECL_NAME(cl_abort)"}, {"ABS","cl_abs"}, {"ACONS","cl_acons"}, {"ACOS","ECL_NAME(cl_acos)"}, {"ACOSH","ECL_NAME(cl_acosh)"}, {"ADJOIN","cl_adjoin"}, {"ADJUST-ARRAY","ECL_NAME(cl_adjust_array)"}, {"ADJUSTABLE-ARRAY-P","cl_adjustable_array_p"}, {"ALPHA-CHAR-P","cl_alpha_char_p"}, {"ALPHANUMERICP","cl_alphanumericp"}, {"AND",NULL}, {"APPEND","cl_append"}, {"APPLY","cl_apply"}, {"APROPOS","ECL_NAME(cl_apropos)"}, {"APROPOS-LIST","ECL_NAME(cl_apropos_list)"}, {"AREF","cl_aref"}, {"ARITHMETIC-ERROR",NULL}, {"ARITHMETIC-ERROR-OPERANDS",NULL}, {"ARITHMETIC-ERROR-OPERATION",NULL}, {"ARRAY",NULL}, {"ARRAY-DIMENSION","cl_array_dimension"}, {"ARRAY-DIMENSION-LIMIT",NULL}, {"ARRAY-DIMENSIONS","ECL_NAME(cl_array_dimensions)"}, {"ARRAY-DISPLACEMENT","cl_array_displacement"}, {"ARRAY-ELEMENT-TYPE","cl_array_element_type"}, {"ARRAY-HAS-FILL-POINTER-P","cl_array_has_fill_pointer_p"}, {"ARRAY-IN-BOUNDS-P","ECL_NAME(cl_array_in_bounds_p)"}, {"ARRAY-RANK","cl_array_rank"}, {"ARRAY-RANK-LIMIT",NULL}, {"ARRAY-ROW-MAJOR-INDEX","ECL_NAME(cl_array_row_major_index)"}, {"ARRAY-TOTAL-SIZE","cl_array_total_size"}, {"ARRAY-TOTAL-SIZE-LIMIT",NULL}, {"ARRAYP","cl_arrayp"}, {"ASH","cl_ash"}, {"ASIN","ECL_NAME(cl_asin)"}, {"ASINH","ECL_NAME(cl_asinh)"}, {"ASSERT",NULL}, {"ASSOC","cl_assoc"}, {"ASSOC-IF","ECL_NAME(cl_assoc_if)"}, {"ASSOC-IF-NOT","ECL_NAME(cl_assoc_if_not)"}, {"ATAN","cl_atan"}, {"ATANH","ECL_NAME(cl_atanh)"}, {"ATOM","cl_atom"}, {"BASE-CHAR",NULL}, {"BASE-STRING",NULL}, {"BIGNUM",NULL}, {"BIT","ECL_NAME(cl_bit)"}, {"BIT-AND","ECL_NAME(cl_bit_and)"}, {"BIT-ANDC1","ECL_NAME(cl_bit_andc1)"}, {"BIT-ANDC2","ECL_NAME(cl_bit_andc2)"}, {"BIT-EQV","ECL_NAME(cl_bit_eqv)"}, {"BIT-IOR","ECL_NAME(cl_bit_ior)"}, {"BIT-NAND","ECL_NAME(cl_bit_nand)"}, {"BIT-NOR","ECL_NAME(cl_bit_nor)"}, {"BIT-NOT","ECL_NAME(cl_bit_not)"}, {"BIT-ORC1","ECL_NAME(cl_bit_orc1)"}, {"BIT-ORC2","ECL_NAME(cl_bit_orc2)"}, {"BIT-VECTOR",NULL}, {"BIT-VECTOR-P","cl_bit_vector_p"}, {"BIT-XOR","ECL_NAME(cl_bit_xor)"}, {"BLOCK",NULL}, {"BOOLE","cl_boole"}, {"BOOLE-1",NULL}, {"BOOLE-2",NULL}, {"BOOLE-AND",NULL}, {"BOOLE-ANDC1",NULL}, {"BOOLE-ANDC2",NULL}, {"BOOLE-C1",NULL}, {"BOOLE-C2",NULL}, {"BOOLE-CLR",NULL}, {"BOOLE-EQV",NULL}, {"BOOLE-IOR",NULL}, {"BOOLE-NAND",NULL}, {"BOOLE-NOR",NULL}, {"BOOLE-ORC1",NULL}, {"BOOLE-ORC2",NULL}, {"BOOLE-SET",NULL}, {"BOOLE-XOR",NULL}, {"BOOLEAN",NULL}, {"BOTH-CASE-P","cl_both_case_p"}, {"BOUNDP","cl_boundp"}, {"BREAK",NULL}, {"BROADCAST-STREAM",NULL}, {"BROADCAST-STREAM-STREAMS","cl_broadcast_stream_streams"}, {"BUTLAST","cl_butlast"}, {"BYTE","ECL_NAME(cl_byte)"}, {"BYTE-POSITION","ECL_NAME(cl_byte_position)"}, {"BYTE-SIZE","ECL_NAME(cl_byte_size)"}, {"CAAAAR","cl_caaaar"}, {"CAAADR","cl_caaadr"}, {"CAAAR","cl_caaar"}, {"CAADAR","cl_caadar"}, {"CAADDR","cl_caaddr"}, {"CAADR","cl_caadr"}, {"CAAR","cl_caar"}, {"CADAAR","cl_cadaar"}, {"CADADR","cl_cadadr"}, {"CADAR","cl_cadar"}, {"CADDAR","cl_caddar"}, {"CADDDR","cl_cadddr"}, {"CADDR","cl_caddr"}, {"CADR","cl_cadr"}, {"CALL-ARGUMENTS-LIMIT",NULL}, {"CAR","cl_car"}, {"CASE",NULL}, {"CATCH",NULL}, {"CCASE",NULL}, {"CDAAAR","cl_cdaaar"}, {"CDAADR","cl_cdaadr"}, {"CDAAR","cl_cdaar"}, {"CDADAR","cl_cdadar"}, {"CDADDR","cl_cdaddr"}, {"CDADR","cl_cdadr"}, {"CDAR","cl_cdar"}, {"CDDAAR","cl_cddaar"}, {"CDDADR","cl_cddadr"}, {"CDDAR","cl_cddar"}, {"CDDDAR","cl_cdddar"}, {"CDDDDR","cl_cddddr"}, {"CDDDR","cl_cdddr"}, {"CDDR","cl_cddr"}, {"CDR","cl_cdr"}, {"CEILING","cl_ceiling"}, {"CELL-ERROR",NULL}, {"CELL-ERROR-NAME",NULL}, {"CERROR","cl_cerror"}, {"CHAR","cl_char"}, {"CHAR-CODE","cl_char_code"}, {"CHAR-CODE-LIMIT",NULL}, {"CHAR-DOWNCASE","cl_char_downcase"}, {"CHAR-EQUAL","cl_char_equal"}, {"CHAR-GREATERP","cl_char_greaterp"}, {"CHAR-INT","cl_char_int"}, {"CHAR-LESSP","cl_char_lessp"}, {"CHAR-NAME","cl_char_name"}, {"CHAR-NOT-EQUAL","cl_char_not_equal"}, {"CHAR-NOT-GREATERP","cl_char_not_greaterp"}, {"CHAR-NOT-LESSP","cl_char_not_lessp"}, {"CHAR-UPCASE","cl_char_upcase"}, {"CHAR/=","cl_charNE"}, {"CHAR<","cl_charL"}, {"CHAR<=","cl_charLE"}, {"CHAR=","cl_charE"}, {"CHAR>","cl_charG"}, {"CHAR>=","cl_charGE"}, {"CHARACTER","cl_character"}, {"CHARACTERP","cl_characterp"}, {"CHECK-TYPE",NULL}, {"CIS","ECL_NAME(cl_cis)"}, {"CLEAR-INPUT","cl_clear_input"}, {"CLEAR-OUTPUT","cl_clear_output"}, {"CLOSE","cl_close"}, {"CLRHASH","cl_clrhash"}, {"CODE-CHAR","cl_code_char"}, {"COERCE","ECL_NAME(cl_coerce)"}, {"COMPILATION-SPEED",NULL}, {"COMPILE",NULL}, {"COMPILE-FILE",NULL}, {"COMPILE-FILE-PATHNAME",NULL}, {"COMPILED-FUNCTION",NULL}, {"COMPILED-FUNCTION-P","cl_compiled_function_p"}, {"COMPILER-MACRO",NULL}, {"COMPILER-MACRO-FUNCTION",NULL}, {"COMPLEMENT","ECL_NAME(cl_complement)"}, {"COMPLEX","cl_complex"}, {"COMPLEXP","cl_complexp"}, {"COMPUTE-RESTARTS","ECL_NAME(cl_compute_restarts)"}, {"CONCATENATE","ECL_NAME(cl_concatenate)"}, {"CONCATENATED-STREAM",NULL}, {"CONCATENATED-STREAM-STREAMS","cl_concatenated_stream_streams"}, {"COND",NULL}, {"CONDITION",NULL}, {"CONJUGATE","cl_conjugate"}, {"CONTINUE","ECL_NAME(cl_continue)"}, {"CONS","cl_cons"}, {"CONSP","cl_consp"}, {"CONSTANTLY","ECL_NAME(cl_constantly)"}, {"CONSTANTP","cl_constantp"}, {"CONTROL-ERROR",NULL}, {"COPY-ALIST","cl_copy_alist"}, {"COPY-LIST","cl_copy_list"}, {"COPY-PPRINT-DISPATCH","ECL_NAME_PPRINT(cl_copy_pprint_dispatch)"}, {"COPY-READTABLE","cl_copy_readtable"}, {"COPY-SEQ","cl_copy_seq"}, {"COPY-STRUCTURE","cl_copy_structure"}, {"COPY-SYMBOL","cl_copy_symbol"}, {"COPY-TREE","cl_copy_tree"}, {"COS","cl_cos"}, {"COSH","cl_cosh"}, {"COUNT","ECL_NAME(cl_count)"}, {"COUNT-IF","ECL_NAME(cl_count_if)"}, {"COUNT-IF-NOT","ECL_NAME(cl_count_if_not)"}, {"CTYPECASE",NULL}, {"DEBUG",NULL}, {"DECF",NULL}, {"DECLAIM",NULL}, {"DECLARATION",NULL}, {"DECLARE",NULL}, {"DECODE-FLOAT","cl_decode_float"}, {"DECODE-UNIVERSAL-TIME","ECL_NAME(cl_decode_universal_time)"}, {"DEFCONSTANT",NULL}, {"DEFINE-CONDITION",NULL}, {"DEFINE-COMPILER-MACRO",NULL}, {"DEFINE-MODIFY-MACRO",NULL}, {"DEFINE-SETF-EXPANDER",NULL}, {"DEFINE-SYMBOL-MACRO",NULL}, {"DEFMACRO",NULL}, {"DEFPACKAGE",NULL}, {"DEFPARAMETER",NULL}, {"DEFSETF",NULL}, {"DEFSTRUCT",NULL}, {"DEFTYPE",NULL}, {"DEFUN",NULL}, {"DEFVAR",NULL}, {"DELETE","ECL_NAME(cl_delete)"}, {"DELETE-DUPLICATES","ECL_NAME(cl_delete_duplicates)"}, {"DELETE-FILE","cl_delete_file"}, {"DELETE-IF","ECL_NAME(cl_delete_if)"}, {"DELETE-IF-NOT","ECL_NAME(cl_delete_if_not)"}, {"DELETE-PACKAGE","cl_delete_package"}, {"DENOMINATOR","cl_denominator"}, {"DEPOSIT-FIELD","ECL_NAME(cl_deposit_field)"}, {"DESCRIBE","ECL_NAME(cl_describe)"}, {"DESTRUCTURING-BIND",NULL}, {"DIGIT-CHAR","cl_digit_char"}, {"DIGIT-CHAR-P","cl_digit_char_p"}, {"DIRECTORY","cl_directory"}, {"DIRECTORY-NAMESTRING","cl_directory_namestring"}, {"DISASSEMBLE",NULL}, {"DIVISION-BY-ZERO",NULL}, {"DO",NULL}, {"DO*",NULL}, {"DO-ALL-SYMBOLS",NULL}, {"DO-EXTERNAL-SYMBOLS",NULL}, {"DO-SYMBOLS",NULL}, {"DOCUMENTATION",NULL}, {"DOLIST",NULL}, {"DOTIMES",NULL}, {"DOUBLE-FLOAT",NULL}, {"DOUBLE-FLOAT-EPSILON",NULL}, {"DOUBLE-FLOAT-NEGATIVE-EPSILON",NULL}, {"DPB","ECL_NAME(cl_dpb)"}, {"DRIBBLE","ECL_NAME(cl_dribble)"}, {"DYNAMIC-EXTENT",NULL}, {"ECASE",NULL}, {"ECHO-STREAM",NULL}, {"ECHO-STREAM-INPUT-STREAM","cl_echo_stream_input_stream"}, {"ECHO-STREAM-OUTPUT-STREAM","cl_echo_stream_output_stream"}, {"ED",NULL}, {"EIGHTH","cl_eighth"}, {"ELT","cl_elt"}, {"ENCODE-UNIVERSAL-TIME","ECL_NAME(cl_encode_universal_time)"}, {"END-OF-FILE",NULL}, {"ENDP","cl_endp"}, {"ENOUGH-NAMESTRING","cl_enough_namestring"}, {"ENSURE-DIRECTORIES-EXIST","ECL_NAME(cl_ensure_directories_exist)"}, {"EQ","cl_eq"}, {"EQL","cl_eql"}, {"EQUAL","cl_equal"}, {"EQUALP","cl_equalp"}, {"ERROR","cl_error"}, {"ETYPECASE",NULL}, {"EVAL","cl_eval"}, {"EVAL-WHEN",NULL}, {"EVENP","cl_evenp"}, {"EVERY","ECL_NAME(cl_every)"}, {"EXP","cl_exp"}, {"EXPORT","cl_export"}, {"EXPT","cl_expt"}, {"EXTENDED-CHAR",NULL}, {"FBOUNDP","cl_fboundp"}, {"FCEILING","ECL_NAME(cl_fceiling)"}, {"FDEFINITION","cl_fdefinition"}, {"FFLOOR","ECL_NAME(cl_ffloor)"}, {"FIFTH","cl_fifth"}, {"FILE-AUTHOR","cl_file_author"}, {"FILE-ERROR",NULL}, {"FILE-ERROR-PATHNAME",NULL}, {"FILE-LENGTH","cl_file_length"}, {"FILE-NAMESTRING","cl_file_namestring"}, {"FILE-POSITION","cl_file_position"}, {"FILE-STREAM",NULL}, {"FILE-STRING-LENGTH","cl_file_string_length"}, {"FILE-WRITE-DATE","cl_file_write_date"}, {"FILL","ECL_NAME(cl_fill)"}, {"FILL-POINTER","cl_fill_pointer"}, {"FIND","ECL_NAME(cl_find)"}, {"FIND-ALL-SYMBOLS","ECL_NAME(cl_find_all_symbols)"}, {"FIND-IF","ECL_NAME(cl_find_if)"}, {"FIND-IF-NOT","ECL_NAME(cl_find_if_not)"}, {"FIND-PACKAGE","cl_find_package"}, {"FIND-RESTART","ECL_NAME(cl_find_restart)"}, {"FIND-SYMBOL","cl_find_symbol"}, {"FINISH-OUTPUT","cl_finish_output"}, {"FIRST","cl_car"}, {"FIXNUM",NULL}, {"FLET",NULL}, {"FLOAT","cl_float"}, {"FLOAT-DIGITS","cl_float_digits"}, {"FLOAT-PRECISION","cl_float_precision"}, {"FLOAT-RADIX","cl_float_radix"}, {"FLOAT-SIGN","cl_float_sign"}, {"FLOATING-POINT-INEXACT",NULL}, {"FLOATING-POINT-INVALID-OPERATION",NULL}, {"FLOATING-POINT-OVERFLOW",NULL}, {"FLOATING-POINT-UNDERFLOW",NULL}, {"FLOATP","cl_floatp"}, {"FLOOR","cl_floor"}, {"FMAKUNBOUND","cl_fmakunbound"}, {"FORCE-OUTPUT","cl_force_output"}, {"FORMAT","cl_format"}, {"FORMATTER",NULL}, {"FOURTH","cl_cadddr"}, {"FRESH-LINE","cl_fresh_line"}, {"FROUND","ECL_NAME(cl_fround)"}, {"FTRUNCATE","ECL_NAME(cl_ftruncate)"}, {"FTYPE",NULL}, {"FUNCALL","cl_funcall"}, {"FUNCTION-LAMBDA-EXPRESSION","cl_function_lambda_expression"}, {"FUNCTION",NULL}, {"FUNCTION-KEYWORDS",NULL}, {"FUNCTIONP","cl_functionp"}, {"GCD","cl_gcd"}, {"GENSYM","cl_gensym"}, {"GENTEMP","cl_gentemp"}, {"GET","cl_get"}, {"GET-DECODED-TIME","ECL_NAME(cl_get_decoded_time)"}, {"GET-DISPATCH-MACRO-CHARACTER","cl_get_dispatch_macro_character"}, {"GET-INTERNAL-REAL-TIME","cl_get_internal_real_time"}, {"GET-INTERNAL-RUN-TIME","cl_get_internal_run_time"}, {"GET-MACRO-CHARACTER","cl_get_macro_character"}, {"GET-OUTPUT-STREAM-STRING","cl_get_output_stream_string"}, {"GET-PROPERTIES","cl_get_properties"}, {"GET-SETF-EXPANSION",NULL}, {"GET-UNIVERSAL-TIME","cl_get_universal_time"}, {"GETF","cl_getf"}, {"GETHASH","cl_gethash"}, {"GO",NULL}, {"GRAPHIC-CHAR-P","cl_graphic_char_p"}, {"HANDLER-CASE",NULL}, {"HANDLER-BIND",NULL}, {"HASH-TABLE",NULL}, {"HASH-TABLE-COUNT","cl_hash_table_count"}, {"HASH-TABLE-P","cl_hash_table_p"}, {"HASH-TABLE-REHASH-SIZE","cl_hash_table_rehash_size"}, {"HASH-TABLE-REHASH-THRESHOLD","cl_hash_table_rehash_threshold"}, {"HASH-TABLE-SIZE","cl_hash_table_size"}, {"HASH-TABLE-TEST","cl_hash_table_test"}, {"HOST-NAMESTRING","cl_host_namestring"}, {"IDENTITY","cl_identity"}, {"IGNORABLE",NULL}, {"IGNORE",NULL}, {"IGNORE-ERRORS",NULL}, {"IMAGPART","cl_imagpart"}, {"IMPORT","cl_import"}, {"IN-PACKAGE",NULL}, {"INCF",NULL}, {"INLINE",NULL}, {"INPUT-STREAM-P","cl_input_stream_p"}, {"INSPECT","ECL_NAME(cl_inspect)"}, {"INTEGER",NULL}, {"INTEGER-DECODE-FLOAT","cl_integer_decode_float"}, {"INTEGER-LENGTH","cl_integer_length"}, {"INTEGERP","cl_integerp"}, {"INTERACTIVE-STREAM-P","cl_interactive_stream_p"}, {"INTERN","cl_intern"}, {"INTERNAL-TIME-UNITS-PER-SECOND",NULL}, {"INTERSECTION","ECL_NAME(cl_intersection)"}, {"INVOKE-DEBUGGER",NULL}, {"INVOKE-RESTART","ECL_NAME(cl_invoke_restart)"}, {"INVOKE-RESTART-INTERACTIVELY","ECL_NAME(cl_invoke_restart_interactively)"}, {"ISQRT","ECL_NAME(cl_isqrt)"}, {"KEYWORD",NULL}, {"KEYWORDP","cl_keywordp"}, {"LABELS",NULL}, {"LAMBDA",NULL}, {"LAMBDA-LIST-KEYWORDS",NULL}, {"LAMBDA-PARAMETERS-LIMIT",NULL}, {"LAST","cl_last"}, {"LCM","cl_lcm"}, {"LDB","ECL_NAME(cl_ldb)"}, {"LDB-TEST","ECL_NAME(cl_ldb_test)"}, {"LDIFF","cl_ldiff"}, {"LEAST-NEGATIVE-DOUBLE-FLOAT",NULL}, {"LEAST-NEGATIVE-LONG-FLOAT",NULL}, {"LEAST-NEGATIVE-NORMALIZED-DOUBLE-FLOAT",NULL}, {"LEAST-NEGATIVE-NORMALIZED-LONG-FLOAT",NULL}, {"LEAST-NEGATIVE-NORMALIZED-SHORT-FLOAT",NULL}, {"LEAST-NEGATIVE-NORMALIZED-SINGLE-FLOAT",NULL}, {"LEAST-NEGATIVE-SHORT-FLOAT",NULL}, {"LEAST-NEGATIVE-SINGLE-FLOAT",NULL}, {"LEAST-POSITIVE-DOUBLE-FLOAT",NULL}, {"LEAST-POSITIVE-LONG-FLOAT",NULL}, {"LEAST-POSITIVE-NORMALIZED-DOUBLE-FLOAT",NULL}, {"LEAST-POSITIVE-NORMALIZED-LONG-FLOAT",NULL}, {"LEAST-POSITIVE-NORMALIZED-SHORT-FLOAT",NULL}, {"LEAST-POSITIVE-NORMALIZED-SINGLE-FLOAT",NULL}, {"LEAST-POSITIVE-SHORT-FLOAT",NULL}, {"LEAST-POSITIVE-SINGLE-FLOAT",NULL}, {"LENGTH","cl_length"}, {"LET",NULL}, {"LET*",NULL}, {"LISP-IMPLEMENTATION-TYPE","ECL_NAME(cl_lisp_implementation_type)"}, {"LISP-IMPLEMENTATION-VERSION","ECL_NAME(cl_lisp_implementation_version)"}, {"LIST","cl_list"}, {"LIST*","cl_listX"}, {"LIST-ALL-PACKAGES","cl_list_all_packages"}, {"LIST-LENGTH","cl_list_length"}, {"LISTEN","cl_listen"}, {"LISTP","cl_listp"}, {"LOAD","cl_load"}, {"LOAD-LOGICAL-PATHNAME-TRANSLATIONS","ECL_NAME(cl_load_logical_pathname_translations)"}, {"LOAD-TIME-VALUE",NULL}, {"LOCALLY",NULL}, {"LOG","cl_log"}, {"LOGAND","cl_logand"}, {"LOGANDC1","cl_logandc1"}, {"LOGANDC2","cl_logandc2"}, {"LOGBITP","cl_logbitp"}, {"LOGCOUNT","cl_logcount"}, {"LOGEQV","cl_logeqv"}, {"LOGICAL-PATHNAME","cl_logical_pathname"}, {"LOGICAL-PATHNAME-TRANSLATIONS","ECL_NAME(cl_logical_pathname_translations)"}, {"LOGIOR","cl_logior"}, {"LOGNAND","cl_lognand"}, {"LOGNOR","cl_lognor"}, {"LOGNOT","cl_lognot"}, {"LOGORC1","cl_logorc1"}, {"LOGORC2","cl_logorc2"}, {"LOGTEST","ECL_NAME(cl_logtest)"}, {"LOGXOR","cl_logxor"}, {"LONG-FLOAT",NULL}, {"LONG-FLOAT-EPSILON",NULL}, {"LONG-FLOAT-NEGATIVE-EPSILON",NULL}, {"LONG-SITE-NAME","ECL_NAME(cl_long_site_name)"}, {"LOOP",NULL}, {"LOOP-FINISH",NULL}, {"LOWER-CASE-P","cl_lower_case_p"}, {"MACHINE-INSTANCE","ECL_NAME(cl_machine_instance)"}, {"MACHINE-TYPE","ECL_NAME(cl_machine_type)"}, {"MACHINE-VERSION","ECL_NAME(cl_machine_version)"}, {"MACRO-FUNCTION","cl_macro_function"}, {"MACROEXPAND","cl_macroexpand"}, {"MACROEXPAND-1","cl_macroexpand_1"}, {"MACROLET",NULL}, {"MAKE-ARRAY","ECL_NAME(cl_make_array)"}, {"MAKE-BROADCAST-STREAM","cl_make_broadcast_stream"}, {"MAKE-CONDITION","ECL_NAME(cl_make_condition)"}, {"MAKE-CONCATENATED-STREAM","cl_make_concatenated_stream"}, {"MAKE-DISPATCH-MACRO-CHARACTER","cl_make_dispatch_macro_character"}, {"MAKE-ECHO-STREAM","cl_make_echo_stream"}, {"MAKE-HASH-TABLE","cl_make_hash_table"}, {"MAKE-LIST","cl_make_list"}, {"MAKE-PACKAGE","cl_make_package"}, {"MAKE-PATHNAME","cl_make_pathname"}, {"MAKE-RANDOM-STATE","cl_make_random_state"}, {"MAKE-SEQUENCE","ECL_NAME(cl_make_sequence)"}, {"MAKE-STRING","cl_make_string"}, {"MAKE-STRING-INPUT-STREAM","cl_make_string_input_stream"}, {"MAKE-STRING-OUTPUT-STREAM","cl_make_string_output_stream"}, {"MAKE-SYMBOL","cl_make_symbol"}, {"MAKE-SYNONYM-STREAM","cl_make_synonym_stream"}, {"MAKE-TWO-WAY-STREAM","cl_make_two_way_stream"}, {"MAKUNBOUND","cl_makunbound"}, {"MAP","ECL_NAME(cl_map)"}, {"MAP-INTO","ECL_NAME(cl_map_into)"}, {"MAPC","cl_mapc"}, {"MAPCAN","cl_mapcan"}, {"MAPCAR","cl_mapcar"}, {"MAPCON","cl_mapcon"}, {"MAPHASH","cl_maphash"}, {"MAPL","cl_mapl"}, {"MAPLIST","cl_maplist"}, {"MASK-FIELD","ECL_NAME(cl_mask_field)"}, {"MAX","cl_max"}, {"MEMBER","cl_member"}, {"MEMBER-IF","ECL_NAME(cl_member_if)"}, {"MEMBER-IF-NOT","ECL_NAME(cl_member_if_not)"}, {"MERGE","ECL_NAME(cl_merge)"}, {"MERGE-PATHNAMES","cl_merge_pathnames"}, {"MIN","cl_min"}, {"MINUSP","cl_minusp"}, {"MISMATCH","ECL_NAME(cl_mismatch)"}, {"MOD","cl_mod"}, {"MOST-NEGATIVE-DOUBLE-FLOAT",NULL}, {"MOST-NEGATIVE-FIXNUM",NULL}, {"MOST-NEGATIVE-LONG-FLOAT",NULL}, {"MOST-NEGATIVE-SHORT-FLOAT",NULL}, {"MOST-NEGATIVE-SINGLE-FLOAT",NULL}, {"MOST-POSITIVE-DOUBLE-FLOAT",NULL}, {"MOST-POSITIVE-FIXNUM",NULL}, {"MOST-POSITIVE-LONG-FLOAT",NULL}, {"MOST-POSITIVE-SHORT-FLOAT",NULL}, {"MOST-POSITIVE-SINGLE-FLOAT",NULL}, {"MUFFLE-WARNING","ECL_NAME(cl_muffle_warning)"}, {"MULTIPLE-VALUE-BIND",NULL}, {"MULTIPLE-VALUE-CALL",NULL}, {"MULTIPLE-VALUE-LIST",NULL}, {"MULTIPLE-VALUE-PROG1",NULL}, {"MULTIPLE-VALUE-SETQ",NULL}, {"MULTIPLE-VALUES-LIMIT",NULL}, {"NAME-CHAR","cl_name_char"}, {"NAMESTRING","cl_namestring"}, {"NBUTLAST","cl_nbutlast"}, {"NCONC","cl_nconc"}, {"NINTERSECTION","ECL_NAME(cl_nintersection)"}, {"NINTH","cl_ninth"}, {"NOT","cl_not"}, {"NOTANY","ECL_NAME(cl_notany)"}, {"NOTEVERY","ECL_NAME(cl_notevery)"}, {"NOTINLINE",NULL}, {"NRECONC","cl_nreconc"}, {"NREVERSE","cl_nreverse"}, {"NSET-DIFFERENCE","ECL_NAME(cl_nset_difference)"}, {"NSET-EXCLUSIVE-OR","ECL_NAME(cl_nset_exclusive_or)"}, {"NSTRING-CAPITALIZE","cl_nstring_capitalize"}, {"NSTRING-DOWNCASE","cl_nstring_downcase"}, {"NSTRING-UPCASE","cl_nstring_upcase"}, {"NSUBLIS","cl_nsublis"}, {"NSUBST","cl_nsubst"}, {"NSUBST-IF","ECL_NAME(cl_nsubst_if)"}, {"NSUBST-IF-NOT","ECL_NAME(cl_nsubst_if_not)"}, {"NSUBSTITUTE","ECL_NAME(cl_nsubstitute)"}, {"NSUBSTITUTE-IF","ECL_NAME(cl_nsubstitute_if)"}, {"NSUBSTITUTE-IF-NOT","ECL_NAME(cl_nsubstitute_if_not)"}, {"NTH","cl_nth"}, {"NTH-VALUE",NULL}, {"NTHCDR","cl_nthcdr"}, {"NULL","cl_null"}, {"NUMBER",NULL}, {"NUMBERP","cl_numberp"}, {"NUMERATOR","cl_numerator"}, {"NUNION","ECL_NAME(cl_nunion)"}, {"ODDP","cl_oddp"}, {"OPEN","cl_open"}, {"OPEN-STREAM-P","cl_open_stream_p"}, {"OPTIMIZE",NULL}, {"OR",NULL}, {"OTHERWISE",NULL}, {"OUTPUT-STREAM-P","cl_output_stream_p"}, {"PACKAGE",NULL}, {"PACKAGE-ERROR",NULL}, {"PACKAGE-ERROR-PACKAGE",NULL}, {"PACKAGE-NAME","cl_package_name"}, {"PACKAGE-NICKNAMES","cl_package_nicknames"}, {"PACKAGE-SHADOWING-SYMBOLS","cl_package_shadowing_symbols"}, {"PACKAGE-USE-LIST","cl_package_use_list"}, {"PACKAGE-USED-BY-LIST","cl_package_used_by_list"}, {"PACKAGEP","cl_packagep"}, {"PAIRLIS","cl_pairlis"}, {"PARSE-ERROR",NULL}, {"PARSE-INTEGER","cl_parse_integer"}, {"PARSE-NAMESTRING","cl_parse_namestring"}, {"PATHNAME","cl_pathname"}, {"PATHNAME-DEVICE","cl_pathname_device"}, {"PATHNAME-DIRECTORY","cl_pathname_directory"}, {"PATHNAME-HOST","cl_pathname_host"}, {"PATHNAME-MATCH-P","cl_pathname_match_p"}, {"PATHNAME-NAME","cl_pathname_name"}, {"PATHNAME-TYPE","cl_pathname_type"}, {"PATHNAME-VERSION","cl_pathname_version"}, {"PATHNAMEP","cl_pathnamep"}, {"PEEK-CHAR","cl_peek_char"}, {"PHASE","ECL_NAME(cl_phase)"}, {"PI",NULL}, {"PLUSP","cl_plusp"}, {"POP",NULL}, {"POSITION","ECL_NAME(cl_position)"}, {"POSITION-IF","ECL_NAME(cl_position_if)"}, {"POSITION-IF-NOT","ECL_NAME(cl_position_if_not)"}, {"PPRINT","cl_pprint"}, {"PPRINT-DISPATCH","ECL_NAME_PPRINT(cl_pprint_dispatch)"}, {"PPRINT-EXIT-IF-LIST-EXHAUSTED",NULL}, {"PPRINT-FILL","ECL_NAME_PPRINT(cl_pprint_fill)"}, {"PPRINT-INDENT","ECL_NAME_PPRINT(cl_pprint_indent)"}, {"PPRINT-LINEAR","ECL_NAME_PPRINT(cl_pprint_linear)"}, {"PPRINT-LOGICAL-BLOCK",NULL}, {"PPRINT-NEWLINE","ECL_NAME_PPRINT(cl_pprint_newline)"}, {"PPRINT-POP",NULL}, {"PPRINT-TAB","ECL_NAME_PPRINT(cl_pprint_tab)"}, {"PPRINT-TABULAR","ECL_NAME_PPRINT(cl_pprint_tabular)"}, {"PRIN1","cl_prin1"}, {"PRIN1-TO-STRING","ECL_NAME(cl_prin1_to_string)"}, {"PRINC","cl_princ"}, {"PRINC-TO-STRING","ECL_NAME(cl_princ_to_string)"}, {"PRINT","cl_print"}, {"PRINT-NOT-READABLE",NULL}, {"PRINT-NOT-READABLE-OBJECT",NULL}, {"PROBE-FILE","cl_probe_file"}, {"PROCLAIM",NULL}, {"PROG",NULL}, {"PROG*",NULL}, {"PROG1",NULL}, {"PROG2",NULL}, {"PROGN",NULL}, {"PROGRAM-ERROR",NULL}, {"PROGV",NULL}, {"PROVIDE","ECL_NAME(cl_provide)"}, {"PSETF",NULL}, {"PSETQ",NULL}, {"PUSH",NULL}, {"PUSHNEW",NULL}, {"QUOTE",NULL}, {"RANDOM","cl_random"}, {"RANDOM-STATE",NULL}, {"RANDOM-STATE-P","cl_random_state_p"}, {"RASSOC","cl_rassoc"}, {"RASSOC-IF","ECL_NAME(cl_rassoc_if)"}, {"RASSOC-IF-NOT","ECL_NAME(cl_rassoc_if_not)"}, {"RATIO",NULL}, {"RATIONAL","cl_rational"}, {"RATIONALIZE","cl_rationalize"}, {"RATIONALP","cl_rationalp"}, {"READ","cl_read"}, {"READ-BYTE","cl_read_byte"}, {"READ-CHAR","cl_read_char"}, {"READ-CHAR-NO-HANG","cl_read_char_no_hang"}, {"READ-DELIMITED-LIST","cl_read_delimited_list"}, {"READ-FROM-STRING","ECL_NAME(cl_read_from_string)"}, {"READ-LINE","cl_read_line"}, {"READ-PRESERVING-WHITESPACE","cl_read_preserving_whitespace"}, {"READ-SEQUENCE","cl_read_sequence"}, {"READER-ERROR",NULL}, {"READTABLE",NULL}, {"READTABLE-CASE","cl_readtable_case"}, {"READTABLEP","cl_readtablep"}, {"REAL",NULL}, {"REALP","cl_realp"}, {"REALPART","cl_realpart"}, {"REDUCE","ECL_NAME(cl_reduce)"}, {"REM","cl_rem"}, {"REMF",NULL}, {"REMHASH","cl_remhash"}, {"REMOVE","ECL_NAME(cl_remove)"}, {"REMOVE-DUPLICATES","ECL_NAME(cl_remove_duplicates)"}, {"REMOVE-IF","ECL_NAME(cl_remove_if)"}, {"REMOVE-IF-NOT","ECL_NAME(cl_remove_if_not)"}, {"REMPROP","cl_remprop"}, {"RENAME-FILE","cl_rename_file"}, {"RENAME-PACKAGE","cl_rename_package"}, {"REPLACE","ECL_NAME(cl_replace)"}, {"REQUIRE","ECL_NAME(cl_require)"}, {"REST","cl_cdr"}, {"RESTART",NULL}, {"RESTART-BIND",NULL}, {"RESTART-CASE",NULL}, {"RESTART-NAME",NULL}, {"RETURN",NULL}, {"RETURN-FROM",NULL}, {"REVAPPEND","cl_revappend"}, {"REVERSE","cl_reverse"}, {"ROOM",NULL}, {"ROTATEF",NULL}, {"ROUND","cl_round"}, {"ROW-MAJOR-AREF","cl_row_major_aref"}, {"RPLACA","cl_rplaca"}, {"RPLACD","cl_rplacd"}, {"SAFETY",NULL}, {"SATISFIES",NULL}, {"SBIT","ECL_NAME(cl_sbit)"}, {"SCALE-FLOAT","cl_scale_float"}, {"SCHAR","cl_char"}, {"SEARCH","ECL_NAME(cl_search)"}, {"SECOND","cl_cadr"}, {"SEQUENCE",NULL}, {"SERIOUS-CONDITION",NULL}, {"SET","cl_set"}, {"SET-DIFFERENCE","ECL_NAME(cl_set_difference)"}, {"SET-DISPATCH-MACRO-CHARACTER","cl_set_dispatch_macro_character"}, {"SET-EXCLUSIVE-OR","ECL_NAME(cl_set_exclusive_or)"}, {"SET-MACRO-CHARACTER","cl_set_macro_character"}, {"SET-PPRINT-DISPATCH","ECL_NAME_PPRINT(cl_set_pprint_dispatch)"}, {"SET-SYNTAX-FROM-CHAR","cl_set_syntax_from_char"}, {"SETF",NULL}, {"SETQ",NULL}, {"SEVENTH","cl_seventh"}, {"SHADOW","cl_shadow"}, {"SHADOWING-IMPORT","cl_shadowing_import"}, {"SHIFTF",NULL}, {"SHORT-FLOAT",NULL}, {"SHORT-FLOAT-EPSILON",NULL}, {"SHORT-FLOAT-NEGATIVE-EPSILON",NULL}, {"SHORT-SITE-NAME","ECL_NAME(cl_short_site_name)"}, {"SIGNAL",NULL}, {"SIGNED-BYTE",NULL}, {"SIGNUM","ECL_NAME(cl_signum)"}, {"SIMPLE-ARRAY",NULL}, {"SIMPLE-BASE-STRING",NULL}, {"SIMPLE-BIT-VECTOR",NULL}, {"SIMPLE-BIT-VECTOR-P","cl_simple_bit_vector_p"}, {"SIMPLE-CONDITION",NULL}, {"SIMPLE-CONDITION-FORMAT-CONTROL",NULL}, {"SIMPLE-CONDITION-FORMAT-ARGUMENTS",NULL}, {"SIMPLE-ERROR",NULL}, {"SIMPLE-STRING",NULL}, {"SIMPLE-STRING-P","cl_simple_string_p"}, {"SIMPLE-TYPE-ERROR",NULL}, {"SIMPLE-VECTOR",NULL}, {"SIMPLE-VECTOR-P","cl_simple_vector_p"}, {"SIMPLE-WARNING",NULL}, {"SIN","cl_sin"}, {"SINGLE-FLOAT",NULL}, {"SINGLE-FLOAT-EPSILON",NULL}, {"SINGLE-FLOAT-NEGATIVE-EPSILON",NULL}, {"SINH","cl_sinh"}, {"SIXTH","cl_sixth"}, {"SLEEP","cl_sleep"}, {"SOFTWARE-TYPE","ECL_NAME(cl_software_type)"}, {"SOFTWARE-VERSION","ECL_NAME(cl_software_version)"}, {"SOME","ECL_NAME(cl_some)"}, {"SORT","ECL_NAME(cl_sort)"}, {"SPACE",NULL}, {"SPECIAL",NULL}, {"SPECIAL-OPERATOR-P","cl_special_operator_p"}, {"SPEED",NULL}, {"SQRT","cl_sqrt"}, {"STABLE-SORT","ECL_NAME(cl_stable_sort)"}, {"STANDARD-CHAR",NULL}, {"STANDARD-CHAR-P","cl_standard_char_p"}, {"STEP",NULL}, {"STORAGE-CONDITION",NULL}, {"STORE-VALUE","ECL_NAME(cl_store_value)"}, {"STREAM",NULL}, {"STREAM-ELEMENT-TYPE","cl_stream_element_type"}, {"STREAM-ERROR",NULL}, {"STREAM-ERROR-STREAM",NULL}, {"STREAM-EXTERNAL-FORMAT","cl_stream_external_format"}, {"STREAMP","cl_streamp"}, {"STRING","cl_string"}, {"STRING-DOWNCASE","cl_string_downcase"}, {"STRING-CAPITALIZE","cl_string_capitalize"}, {"STRING-EQUAL","cl_string_equal"}, {"STRING-GREATERP","cl_string_greaterp"}, {"STRING-LEFT-TRIM","cl_string_left_trim"}, {"STRING-LESSP","cl_string_lessp"}, {"STRING-NOT-EQUAL","cl_string_not_equal"}, {"STRING-NOT-GREATERP","cl_string_not_greaterp"}, {"STRING-NOT-LESSP","cl_string_not_lessp"}, {"STRING-RIGHT-TRIM","cl_string_right_trim"}, {"STRING-STREAM",NULL}, {"STRING-TRIM","cl_string_trim"}, {"STRING-UPCASE","cl_string_upcase"}, {"STRING/=","cl_stringNE"}, {"STRING<","cl_stringL"}, {"STRING<=","cl_stringLE"}, {"STRING=","cl_stringE"}, {"STRING>","cl_stringG"}, {"STRING>=","cl_stringGE"}, {"STRINGP","cl_stringp"}, {"STRUCTURE",NULL}, {"STYLE-WARNING",NULL}, {"SUBLIS","cl_sublis"}, {"SUBSEQ","cl_subseq"}, {"SUBSETP","ECL_NAME(cl_subsetp)"}, {"SUBST","cl_subst"}, {"SUBST-IF","ECL_NAME(cl_subst_if)"}, {"SUBST-IF-NOT","ECL_NAME(cl_subst_if_not)"}, {"SUBSTITUTE","ECL_NAME(cl_substitute)"}, {"SUBSTITUTE-IF","ECL_NAME(cl_substitute_if)"}, {"SUBSTITUTE-IF-NOT","ECL_NAME(cl_substitute_if_not)"}, {"SUBTYPEP","ECL_NAME(cl_subtypep)"}, {"SVREF","cl_svref"}, {"SXHASH","cl_sxhash"}, {"SYMBOL",NULL}, {"SYMBOL-FUNCTION","cl_symbol_function"}, {"SYMBOL-MACROLET",NULL}, {"SYMBOL-NAME","cl_symbol_name"}, {"SYMBOL-PACKAGE","cl_symbol_package"}, {"SYMBOL-PLIST","cl_symbol_plist"}, {"SYMBOL-VALUE","cl_symbol_value"}, {"SYMBOLP","cl_symbolp"}, {"SYNONYM-STREAM",NULL}, {"SYNONYM-STREAM-SYMBOL","cl_synonym_stream_symbol"}, {"TAGBODY",NULL}, {"TAILP","cl_tailp"}, {"TAN","cl_tan"}, {"TANH","cl_tanh"}, {"TENTH","cl_tenth"}, {"TERPRI","cl_terpri"}, {"THE",NULL}, {"THIRD","cl_caddr"}, {"THROW",NULL}, {"TIME",NULL}, {"TRACE",NULL}, {"TRANSLATE-LOGICAL-PATHNAME","cl_translate_logical_pathname"}, {"TRANSLATE-PATHNAME","cl_translate_pathname"}, {"TREE-EQUAL","cl_tree_equal"}, {"TRUENAME","cl_truename"}, {"TRUNCATE","cl_truncate"}, {"TWO-WAY-STREAM",NULL}, {"TWO-WAY-STREAM-INPUT-STREAM","cl_two_way_stream_input_stream"}, {"TWO-WAY-STREAM-OUTPUT-STREAM","cl_two_way_stream_output_stream"}, {"TYPE",NULL}, {"TYPE-ERROR",NULL}, {"TYPE-ERROR-DATUM",NULL}, {"TYPE-ERROR-EXPECTED-TYPE",NULL}, {"TYPE-OF","cl_type_of"}, {"TYPECASE",NULL}, {"TYPEP","ECL_NAME(cl_typep)"}, {"UNBOUND-SLOT",NULL}, {"UNBOUND-SLOT-INSTANCE",NULL}, {"UNBOUND-VARIABLE",NULL}, {"UNDEFINED-FUNCTION",NULL}, {"UNEXPORT","cl_unexport"}, {"UNINTERN","cl_unintern"}, {"UNION","ECL_NAME(cl_union)"}, {"UNLESS",NULL}, {"UNREAD-CHAR","cl_unread_char"}, {"UNSIGNED-BYTE",NULL}, {"UNTRACE",NULL}, {"UNUSE-PACKAGE","cl_unuse_package"}, {"UNWIND-PROTECT",NULL}, {"UPGRADED-ARRAY-ELEMENT-TYPE","ECL_NAME(cl_upgraded_array_element_type)"}, {"UPGRADED-COMPLEX-PART-TYPE","ECL_NAME(cl_upgraded_complex_part_type)"}, {"UPPER-CASE-P","cl_upper_case_p"}, {"USE-PACKAGE","cl_use_package"}, {"USE-VALUE","ECL_NAME(cl_use_value)"}, {"USER-HOMEDIR-PATHNAME","cl_user_homedir_pathname"}, {"VALUES","cl_values"}, {"VALUES-LIST","cl_values_list"}, {"VARIABLE",NULL}, {"VECTOR","ECL_NAME(cl_vector)"}, {"VECTOR-POP","ECL_NAME(cl_vector_pop)"}, {"VECTOR-PUSH","cl_vector_push"}, {"VECTOR-PUSH-EXTEND","cl_vector_push_extend"}, {"VECTORP","cl_vectorp"}, {"WARN",NULL}, {"WARNING",NULL}, {"WHEN",NULL}, {"WILD-PATHNAME-P","cl_wild_pathname_p"}, {"WITH-COMPILATION-UNIT",NULL}, {"WITH-CONDITION-RESTARTS",NULL}, {"WITH-HASH-TABLE-ITERATOR",NULL}, {"WITH-INPUT-FROM-STRING",NULL}, {"WITH-OPEN-FILE",NULL}, {"WITH-OPEN-STREAM",NULL}, {"WITH-OUTPUT-TO-STRING",NULL}, {"WITH-PACKAGE-ITERATOR",NULL}, {"WITH-SIMPLE-RESTART",NULL}, {"WITH-STANDARD-IO-SYNTAX",NULL}, {"WRITE","cl_write"}, {"WRITE-BYTE","cl_write_byte"}, {"WRITE-CHAR","cl_write_char"}, {"WRITE-LINE","cl_write_line"}, {"WRITE-SEQUENCE","cl_write_sequence"}, {"WRITE-STRING","cl_write_string"}, {"WRITE-TO-STRING","ECL_NAME(cl_write_to_string)"}, {"Y-OR-N-P","ECL_NAME(cl_y_or_n_p)"}, {"YES-OR-NO-P","ECL_NAME(cl_yes_or_no_p)"}, {"ZEROP","cl_zerop"}, {"ALLOCATE-INSTANCE",NULL}, {"ADD-METHOD",NULL}, {"BUILT-IN-CLASS",NULL}, {"CALL-METHOD",NULL}, {"CALL-NEXT-METHOD",NULL}, {"CHANGE-CLASS",NULL}, {"CLASS",NULL}, {"CLASS-NAME",NULL}, {"CLASS-OF","cl_class_of"}, {"COMPUTE-APPLICABLE-METHODS",NULL}, {"DEFCLASS",NULL}, {"DEFGENERIC",NULL}, {"DEFINE-METHOD-COMBINATION",NULL}, {"DEFMETHOD",NULL}, {"DESCRIBE-OBJECT",NULL}, {"ENSURE-GENERIC-FUNCTION",NULL}, {"FIND-CLASS","cl_find_class"}, {"FIND-METHOD",NULL}, {"GENERIC-FUNCTION",NULL}, {"IF",NULL}, {"INITIALIZE-INSTANCE",NULL}, {"INVALID-METHOD-ERROR","ECL_NAME(cl_invalid_method_error)"}, {"MAKE-INSTANCE",NULL}, {"MAKE-INSTANCES-OBSOLETE",NULL}, {"MAKE-LOAD-FORM",NULL}, {"MAKE-LOAD-FORM-SAVING-SLOTS",NULL}, {"MAKE-METHOD",NULL}, {"METHOD",NULL}, {"METHOD-COMBINATION-ERROR","ECL_NAME(cl_method_combination_error)"}, {"METHOD-COMBINATION",NULL}, {"METHOD-QUALIFIERS",NULL}, {"NEXT-METHOD-P",NULL}, {"NO-APPLICABLE-METHOD",NULL}, {"NO-NEXT-METHOD",NULL}, {"PRINT-OBJECT",NULL}, {"PRINT-UNREADABLE-OBJECT",NULL}, {"REINITIALIZE-INSTANCE",NULL}, {"REMOVE-METHOD",NULL}, {"SHARED-INITIALIZE",NULL}, {"SLOT-BOUNDP","ECL_NAME(cl_slot_boundp)"}, {"SLOT-EXISTS-P","ECL_NAME(cl_slot_exists_p)"}, {"SLOT-MAKUNBOUND","ECL_NAME(cl_slot_makunbound)"}, {"SLOT-MISSING",NULL}, {"SLOT-UNBOUND",NULL}, {"SLOT-VALUE","cl_slot_value"}, {"STANDARD",NULL}, {"STANDARD-CLASS",NULL}, {"STANDARD-GENERIC-FUNCTION",NULL}, {"STANDARD-METHOD",NULL}, {"STANDARD-OBJECT",NULL}, {"STRUCTURE-CLASS",NULL}, {"STRUCTURE-OBJECT",NULL}, {"UPDATE-INSTANCE-FOR-DIFFERENT-CLASS",NULL}, {"UPDATE-INSTANCE-FOR-REDEFINED-CLASS",NULL}, {"WITH-ACCESSORS",NULL}, {"WITH-SLOTS",NULL}, {KEY_ "ACCESSOR",NULL}, {KEY_ "ARGUMENT-PRECEDENCE-ORDER",NULL}, {KEY_ "ALLOCATION",NULL}, {KEY_ "DECLARE",NULL}, {KEY_ "DEFAULT-INITARGS",NULL}, {KEY_ "DESCRIPTION",NULL}, {KEY_ "DIRECT-DEFAULT-INITARGS",NULL}, {KEY_ "DIRECT-SLOTS",NULL}, {KEY_ "DIRECT-SUPERCLASSES",NULL}, {KEY_ "GENERIC-FUNCTION-CLASS",NULL}, {KEY_ "IDENTITY-WITH-ONE-ARGUMENT",NULL}, {KEY_ "INITARG",NULL}, {KEY_ "INITARGS",NULL}, {KEY_ "INITFORM",NULL}, {KEY_ "INITFUNCTION",NULL}, {KEY_ "LAMBDA-LIST",NULL}, {KEY_ "LOCATION",NULL}, {KEY_ "METACLASS",NULL}, {KEY_ "METHOD",NULL}, {KEY_ "METHOD-CLASS",NULL}, {KEY_ "METHOD-COMBINATION",NULL}, {KEY_ "OPERATOR",NULL}, {KEY_ "ORDER",NULL}, {KEY_ "READER",NULL}, {KEY_ "READERS",NULL}, {KEY_ "REQUIRED",NULL}, {KEY_ "WRITER",NULL}, {KEY_ "WRITERS",NULL}, /* SYSTEM PACKAGE */ {SYS_ "#!",NULL}, {SYS_ "*BACKQ-LEVEL*",NULL}, {SYS_ "*CBLOCK*",NULL}, {SYS_ "*CIRCLE-COUNTER*",NULL}, {SYS_ "*CIRCLE-STACK*",NULL}, {SYS_ "*CLASS-NAME-HASH-TABLE*",NULL}, {SYS_ "*COMPILER-CONSTANTS*",NULL}, {SYS_ "*GC-MESSAGE*",NULL}, {SYS_ "*GC-VERBOSE*",NULL}, {SYS_ "*IGNORE-EOF-ON-TERMINAL-IO*",NULL}, {SYS_ "*INDENT-FORMATTED-OUTPUT*",NULL}, {SYS_ "*INIT-FUNCTION-PREFIX*",NULL}, {EXT_ "*INTERRUPTS-ENABLED*",NULL}, {SYS_ "*KEEP-DEFINITIONS*",NULL}, {EXT_ "*LOAD-HOOKS*",NULL}, {SYS_ "*LOAD-SEARCH-LIST*",NULL}, {SYS_ "*MAKE-CONSTANT","si_Xmake_constant"}, {SYS_ "*MAKE-SPECIAL","si_Xmake_special"}, {SYS_ "*PRINT-PACKAGE*",NULL}, {SYS_ "*PRINT-STRUCTURE*",NULL}, {SYS_ "*SHARP-EQ-CONTEXT*",NULL}, {SYS_ "*STEP-LEVEL*","OBJNULL"}, {SYS_ "*STEP-ACTION*","OBJNULL"}, {SYS_ ".",NULL}, {SYS_ "UNQUOTE",NULL}, {SYS_ "UNQUOTE-NSPLICE",NULL}, {SYS_ "UNQUOTE-SPLICE",NULL}, {SYS_ "ALLOCATE-RAW-INSTANCE","si_allocate_raw_instance"}, {EXT_ "ARGC","si_argc"}, {EXT_ "ARGV","si_argv"}, {SYS_ "ASET","si_aset"}, {SYS_ "BASE-CHAR-P","si_base_char_p"}, {SYS_ "BASE-STRING-P","si_base_string_p"}, {SYS_ "BC-DISASSEMBLE","si_bc_disassemble"}, {SYS_ "BC-SPLIT","si_bc_split"}, {SYS_ "BC-JOIN","si_bc_join"}, {SYS_ "BDS-TOP","si_bds_top"}, {SYS_ "BDS-VAL","si_bds_val"}, {SYS_ "BDS-VAR","si_bds_var"}, {SYS_ "BIT-ARRAY-OP","si_bit_array_op"}, {SYS_ "C-ARGUMENTS-LIMIT",NULL}, {SYS_ "CHAR-SET","si_char_set"}, {EXT_ "CHDIR","si_chdir"}, {SYS_ "CLEAR-COMPILER-PROPERTIES","cl_identity"}, {SYS_ "COERCE-TO-BASE-STRING","si_coerce_to_base_string"}, {SYS_ "COERCE-TO-EXTENDED-STRING","si_coerce_to_extended_string"}, {SYS_ "COERCE-TO-FILENAME","si_coerce_to_filename"}, {SYS_ "COERCE-TO-FUNCTION","si_coerce_to_function"}, {SYS_ "COERCE-TO-PACKAGE","si_coerce_to_package"}, {SYS_ "COPY-TO-SIMPLE-BASE-STRING","si_copy_to_simple_base_string"}, {SYS_ "COMPILED-FUNCTION-BLOCK","si_compiled_function_block"}, {EXT_ "COMPILED-FUNCTION-NAME","si_compiled_function_name"}, {SYS_ "COPY-STREAM","si_copy_stream"}, {SYS_ "DESTRUCTURE",NULL}, {SYS_ "DO-READ-SEQUENCE","si_do_read_sequence"}, {SYS_ "DO-WRITE-SEQUENCE","si_do_write_sequence"}, {SYS_ "ELT-SET","si_elt_set"}, {SYS_ "EVAL-WITH-ENV","si_eval_with_env"}, {SYS_ "EXPAND-DEFMACRO",NULL}, {SYS_ "FILE-COLUMN","si_file_column"}, {EXT_ "FILE-KIND","si_file_kind"}, {SYS_ "FILL-POINTER-SET","si_fill_pointer_set"}, {EXT_ "FILE-STREAM-FD","si_file_stream_fd"}, {EXT_ "FIXNUMP","si_fixnump"}, {SYS_ "FORMAT-ERROR",NULL}, #ifdef ECL_CMU_FORMAT {SYS_ "FORMATTER-AUX",NULL}, #else {SYS_ "FORMATTER-AUX","si_formatter_aux"}, #endif {SYS_ "FRS-BDS","si_frs_bds"}, {SYS_ "FRS-IHS","si_frs_ihs"}, {SYS_ "FRS-TAG","si_frs_tag"}, {SYS_ "FRS-TOP","si_frs_top"}, {SYS_ "FSET","si_fset"}, {SYS_ "FUNCTION-BLOCK-NAME","si_function_block_name"}, {SYS_ "GET-LIBRARY-PATHNAME","si_get_library_pathname"}, {SYS_ "GET-SYSPROP","si_get_sysprop"}, {EXT_ "GETENV","si_getenv"}, {EXT_ "GETCWD","si_getcwd"}, {EXT_ "GETPID","si_getpid"}, {EXT_ "GETUID","si_getuid"}, {SYS_ "HASH-SET","si_hash_set"}, {SYS_ "HASH-TABLE-ITERATOR","si_hash_table_iterator"}, {SYS_ "IHS-BDS","si_ihs_bds"}, {SYS_ "IHS-ENV","si_ihs_env"}, {SYS_ "IHS-FUN","si_ihs_fun"}, {SYS_ "IHS-NEXT","si_ihs_next"}, {SYS_ "IHS-PREV","si_ihs_prev"}, {SYS_ "IHS-TOP","si_ihs_top"}, {SYS_ "INTERPRETER-STACK","si_interpreter_stack"}, {SYS_ "LINK-FROM",NULL}, {SYS_ "LINK-TO",NULL}, {SYS_ "LOAD-SOURCE","si_load_source"}, {SYS_ "LOGICAL-PATHNAME-P","si_logical_pathname_p"}, {SYS_ "MACRO",NULL}, {SYS_ "MAKE-LAMBDA","si_make_lambda"}, {SYS_ "MAKE-PURE-ARRAY","si_make_pure_array"}, {SYS_ "MAKE-STRING-OUTPUT-STREAM-FROM-STRING","si_make_string_output_stream_from_string"}, {SYS_ "MAKE-STRUCTURE","si_make_structure"}, {SYS_ "MAKE-VECTOR","si_make_vector"}, {SYS_ "MANGLE-NAME","si_mangle_name"}, {SYS_ "MEMBER1","si_member1"}, {SYS_ "MEMQ","si_memq"}, {SYS_ "MKDIR","si_mkdir"}, {EXT_ "MKSTEMP","si_mkstemp"}, {SYS_ "RMDIR","si_rmdir"}, {EXT_ "MAKE-PIPE","si_make_pipe"}, {EXT_ "PACKAGE-LOCK","si_package_lock"}, {SYS_ "PACKAGE-HASH-TABLES","si_package_hash_tables"}, {SYS_ "PATHNAME-TRANSLATIONS","si_pathname_translations"}, {SYS_ "POINTER","si_pointer"}, {SYS_ "PRETTY-PRINT-FORMAT",NULL}, {SYS_ "PROCESS-DECLARATIONS","si_process_declarations"}, {SYS_ "PROCESS-LAMBDA","si_process_lambda"}, {SYS_ "PROCESS-LAMBDA-LIST","si_process_lambda_list"}, {SYS_ "PUT-F","si_put_f"}, {SYS_ "PUT-PROPERTIES","si_put_properties"}, {SYS_ "PUT-SYSPROP","si_put_sysprop"}, {SYS_ "PUTPROP","si_putprop"}, {SYS_ "READTABLE-CASE-SET","si_readtable_case_set"}, {SYS_ "REM-F","si_rem_f"}, {SYS_ "REM-SYSPROP","si_rem_sysprop"}, {SYS_ "REPLACE-ARRAY","si_replace_array"}, {SYS_ "ROW-MAJOR-ASET","si_row_major_aset"}, {EXT_ "RUN-PROGRAM","si_run_program"}, {SYS_ "WAIT-FOR-ALL-PROCESSES","si_wait_for_all_processes"}, {EXT_ "SAFE-EVAL","ECL_NAME(si_safe_eval)"}, {SYS_ "SCH-FRS-BASE","si_sch_frs_base"}, {SYS_ "SCHAR-SET","si_char_set"}, {SYS_ "SERROR","si_serror"}, {SYS_ "SHARP-A-READER",NULL}, {SYS_ "SHARP-S-READER",NULL}, {SYS_ "SELECT-PACKAGE","si_select_package"}, {SYS_ "SET-SYMBOL-PLIST","si_set_symbol_plist"}, #if defined(HAVE_PUTENV) || defined(HAVE_SETENV) {EXT_ "SETENV","si_setenv"}, #else {EXT_ "SETENV",NULL}, #endif {SYS_ "SETF-METHOD",NULL}, {SYS_ "SETF-NAMEP",NULL}, {SYS_ "SIMPLE-PROGRAM-ERROR","ECL_NAME(si_simple_program_error)"}, {SYS_ "SIGNAL-SIMPLE-ERROR","si_signal_simple_error"}, {SYS_ "SIGNAL-TYPE-ERROR","si_signal_type_error"}, {SYS_ "SPECIALP","si_specialp"}, {SYS_ "STANDARD-READTABLE","si_standard_readtable"}, {SYS_ "STEPPER","OBJNULL"}, {SYS_ "BASE-STRING-CONCATENATE","si_base_string_concatenate"}, {SYS_ "STRING-TO-OBJECT","ECL_NAME(si_string_to_object)"}, {SYS_ "STRUCTURE-NAME","si_structure_name"}, {SYS_ "STRUCTURE-PRINT-FUNCTION",NULL}, {SYS_ "STRUCTURE-REF","si_structure_ref"}, {SYS_ "STRUCTURE-SET","si_structure_set"}, {SYS_ "STRUCTURE-SLOT-DESCRIPTIONS",NULL}, {SYS_ "STRUCTURE-SUBTYPE-P","si_structure_subtype_p"}, {SYS_ "STRUCTUREP","si_structurep"}, {SYS_ "SVSET","si_svset"}, {SYS_ "SYMBOL-MACRO",NULL}, {EXT_ "SYSTEM","ECL_NAME(si_system)"}, {SYS_ "TERMINAL-INTERRUPT",NULL}, {SYS_ "TOP-LEVEL",NULL}, {SYS_ "UNIVERSAL-ERROR-HANDLER",NULL}, {SYS_ "STACK-ERROR-HANDLER",NULL}, {SYS_ "VALID-FUNCTION-NAME-P","si_valid_function_name_p"}, {SYS_ "WRITE-OBJECT","si_write_object"}, {SYS_ "WRITE-UGLY-OBJECT","si_write_ugly_object"}, {SYS_ "COPY-INSTANCE","si_copy_instance"}, {SYS_ "GENERIC-FUNCTION-P","si_generic_function_p"}, {SYS_ "INSTANCE-REF","si_instance_ref"}, {SYS_ "INSTANCE-SET","si_instance_set"}, {SYS_ "INSTANCE-SIG","si_instance_sig"}, {SYS_ "INSTANCE-SIG-SET","si_instance_sig_set"}, {SYS_ "INSTANCE-CLASS","si_instance_class"}, {SYS_ "INSTANCE-CLASS-SET","si_instance_class_set"}, {SYS_ "INSTANCEP","si_instancep"}, {SYS_ "SL-BOUNDP","si_sl_boundp"}, {SYS_ "SL-MAKUNBOUND","si_sl_makunbound"}, {SYS_ "SUBCLASSP","ECL_NAME(si_subclassp)"}, {SYS_ "OF-CLASS-P","ECL_NAME(si_of_class_p)"}, /*{SYS_ "UNBOUND","si_unbound"}, */ {EXT_ "*SOURCE-LOCATION*",NULL}, {EXT_ "*REGISTER-WITH-PDE-HOOK*",NULL}, {EXT_ "REGISTER-WITH-PDE",NULL}, /* #ifdef PROFILE */ {SYS_ "PROFILE",IF_PROFILE("si_profile")}, {SYS_ "CLEAR-PROFILE",IF_PROFILE("si_clear_profile")}, {SYS_ "DISPLAY-PROFILE",IF_PROFILE("si_display_profile")}, /* #endif PROFILE */ /* #ifdef TCP */ {SYS_ "*PROFILE-ARRAY*",NULL}, {SYS_ "OPEN-CLIENT-STREAM",IF_TCP("si_open_client_stream")}, {SYS_ "OPEN-SERVER-STREAM",IF_TCP("si_open_server_stream")}, {SYS_ "OPEN-UNIX-SOCKET-STREAM",IF_TCP("si_open_unix_socket_stream")}, {SYS_ "LOOKUP-HOST-ENTRY",IF_TCP("si_lookup_host_entry")}, /* #endif TCP */ {EXT_ "CATCH-SIGNAL","si_catch_signal"}, {EXT_ "GET-SIGNAL-HANDLER","si_get_signal_handler"}, {EXT_ "SET-SIGNAL-HANDLER","si_set_signal_handler"}, /* KEYWORD PACKAGE */ {KEY_ "ADJUSTABLE",NULL}, {KEY_ "ABORT",NULL}, {KEY_ "ABSOLUTE",NULL}, {KEY_ "ALLOW-OTHER-KEYS",NULL}, {KEY_ "APPEND",NULL}, {KEY_ "ARRAY",NULL}, {KEY_ "BACK",NULL}, {KEY_ "BASE",NULL}, {KEY_ "BLOCK",NULL}, {KEY_ "CAPITALIZE",NULL}, {KEY_ "CATCH",NULL}, {KEY_ "CASE",NULL}, {KEY_ "CIRCLE",NULL}, {KEY_ "COMPILE-TOPLEVEL",NULL}, {KEY_ "COMMON",NULL}, {KEY_ "CONC-NAME",NULL}, {KEY_ "CONSTRUCTOR",NULL}, {KEY_ "CONTROL-STRING",NULL}, {KEY_ "COPIER",NULL}, {KEY_ "CREATE",NULL}, {KEY_ "DATUM",NULL}, {KEY_ "DEFAULT",NULL}, {KEY_ "DEFAULTS",NULL}, {KEY_ "DEVICE",NULL}, {KEY_ "DIRECTION",NULL}, {KEY_ "DIRECTORY",NULL}, {KEY_ "DISPLACED-INDEX-OFFSET",NULL}, {KEY_ "DISPLACED-TO",NULL}, {KEY_ "DOCUMENTATION",NULL}, {KEY_ "DOWNCASE",NULL}, {KEY_ "ELEMENT-TYPE",NULL}, {KEY_ "END",NULL}, {KEY_ "END1",NULL}, {KEY_ "END2",NULL}, {KEY_ "EOF",NULL}, {KEY_ "ERROR",NULL}, {KEY_ "ESCAPE",NULL}, {KEY_ "EXECUTE",NULL}, {KEY_ "EXPECTED-TYPE",NULL}, {KEY_ "EXPORT",NULL}, {KEY_ "EXPORT-FROM",NULL}, {KEY_ "EXTERNAL",NULL}, {KEY_ "EXTERNAL-FORMAT",NULL}, {KEY_ "FILE",NULL}, {KEY_ "FILL-POINTER",NULL}, {KEY_ "FORMAT-ARGUMENTS",NULL}, {KEY_ "FORMAT-CONTROL",NULL}, {KEY_ "FUNCTION",NULL}, {KEY_ "GENSYM",NULL}, {KEY_ "HOST",NULL}, {KEY_ "IF-DOES-NOT-EXIST",NULL}, {KEY_ "IF-ERROR-EXISTS",NULL}, {KEY_ "IF-EXISTS",NULL}, {KEY_ "IF-INPUT-DOES-NOT-EXIST",NULL}, {KEY_ "IF-OUTPUT-EXISTS",NULL}, {KEY_ "IGNORE",NULL}, {KEY_ "IMPORT-FROM",NULL}, {KEY_ "INCLUDE",NULL}, {KEY_ "INHERITED",NULL}, {KEY_ "INITIAL-ELEMENT",NULL}, {KEY_ "INITIAL-CONTENTS",NULL}, {KEY_ "INITIAL-OFFSET",NULL}, {KEY_ "INPUT",NULL}, {KEY_ "INTERACTIVE",NULL}, {KEY_ "INSTANCE",NULL}, {KEY_ "INTERN",NULL}, {KEY_ "INTERNAL",NULL}, {KEY_ "INVERT",NULL}, {KEY_ "IO",NULL}, {KEY_ "JUNK-ALLOWED",NULL}, {KEY_ "KEY",NULL}, {KEY_ "LENGTH",NULL}, {KEY_ "LEVEL",NULL}, {KEY_ "LINES",NULL}, {KEY_ "LINK",NULL}, {KEY_ "LIST-ALL",NULL}, {KEY_ "LOCAL",NULL}, {KEY_ "LOCKABLE",NULL}, {KEY_ "LOAD-TOPLEVEL",NULL}, {KEY_ "MASK",NULL}, {KEY_ "MISER-WIDTH",NULL}, {KEY_ "NAME",NULL}, {KEY_ "NAMED",NULL}, {KEY_ "NEW-VERSION",NULL}, {KEY_ "NEWEST",NULL}, {KEY_ "NICKNAMES",NULL}, {KEY_ "OBJECT",NULL}, {KEY_ "OFFSET",NULL}, {KEY_ "OPERATION",NULL}, {KEY_ "OPERANDS",NULL}, {KEY_ "OUTPUT",NULL}, {KEY_ "OVERWRITE",NULL}, {KEY_ "PACKAGE",NULL}, {KEY_ "PATHNAME",NULL}, {KEY_ "PPRINT-DISPATCH",NULL}, {KEY_ "PREDICATE",NULL}, {KEY_ "PRESERVE",NULL}, {KEY_ "PRETTY",NULL}, {KEY_ "PRINT",NULL}, {KEY_ "PRINT-FUNCTION",NULL}, {KEY_ "PRINT-OBJECT",NULL}, {KEY_ "PROBE",NULL}, {KEY_ "PROCESS",NULL}, {KEY_ "RADIX",NULL}, {KEY_ "READABLY",NULL}, {KEY_ "REHASH-SIZE",NULL}, {KEY_ "REHASH-THRESHOLD",NULL}, {KEY_ "RELATIVE",NULL}, {KEY_ "RENAME",NULL}, {KEY_ "RENAME-AND-DELETE",NULL}, {KEY_ "REPORT",NULL}, {KEY_ "RIGHT-MARGIN",NULL}, {KEY_ "SET-DEFAULT-PATHNAME",NULL}, {KEY_ "SEARCH-LIST",NULL}, {KEY_ "SHADOW",NULL}, {KEY_ "SHADOWING-IMPORT",NULL}, {KEY_ "SIZE",NULL}, {KEY_ "SPECIAL",NULL}, {KEY_ "START",NULL}, {KEY_ "START1",NULL}, {KEY_ "START2",NULL}, {KEY_ "STREAM",NULL}, {KEY_ "SUPERSEDE",NULL}, {KEY_ "TAG",NULL}, {KEY_ "TEST",NULL}, {KEY_ "TEST-NOT",NULL}, {KEY_ "TYPE",NULL}, {KEY_ "UNSPECIFIC",NULL}, {KEY_ "UNMASK",NULL}, {KEY_ "UP",NULL}, {KEY_ "UPCASE",NULL}, {KEY_ "USE",NULL}, {KEY_ "CSTREAM",NULL}, {KEY_ "VERBOSE",NULL}, {KEY_ "VERSION",NULL}, {KEY_ "WILD",NULL}, {KEY_ "WILD-INFERIORS",NULL}, {KEY_ "WAIT",NULL}, {EXT_ "BYTE8",NULL}, {EXT_ "BYTE16",NULL}, {EXT_ "BYTE32",NULL}, {EXT_ "BYTE64",NULL}, {EXT_ "COMPILER-LET",NULL}, {EXT_ "INTEGER8",NULL}, {EXT_ "INTEGER16",NULL}, {EXT_ "INTEGER32",NULL}, {EXT_ "INTEGER64",NULL}, {EXT_ "LAMBDA-BLOCK",NULL}, {EXT_ "QUIT","si_quit"}, {EXT_ "GET-METHOD",NULL}, {EXT_ "INSTANCE",NULL}, {SYS_ "ALLOCATE-FOREIGN-DATA","si_allocate_foreign_data"}, {SYS_ "FIND-FOREIGN-SYMBOL","si_find_foreign_symbol"}, {SYS_ "FOREIGN-DATA",NULL}, {SYS_ "FOREIGN-DATA-ADDRESS","si_foreign_data_address"}, {SYS_ "FOREIGN-DATA-EQUAL","si_foreign_data_equal"}, {SYS_ "FOREIGN-DATA-P","si_foreign_data_p"}, {SYS_ "FOREIGN-DATA-POINTER","si_foreign_data_pointer"}, {SYS_ "FOREIGN-DATA-RECAST","si_foreign_data_recast"}, {SYS_ "FOREIGN-DATA-REF","si_foreign_data_ref"}, {SYS_ "FOREIGN-DATA-REF-ELT","si_foreign_data_ref_elt"}, {SYS_ "FOREIGN-DATA-SET","si_foreign_data_set"}, {SYS_ "FOREIGN-DATA-SET-ELT","si_foreign_data_set_elt"}, {SYS_ "FOREIGN-DATA-TAG","si_foreign_data_tag"}, {SYS_ "FOREIGN-ELT-TYPE-P","si_foreign_elt_type_p"}, {SYS_ "FREE-FOREIGN-DATA","si_free_foreign_data"}, {SYS_ "MAKE-FOREIGN-DATA-FROM-ARRAY","si_make_foreign_data_from_array"}, {SYS_ "LOAD-FOREIGN-MODULE","si_load_foreign_module"}, {SYS_ "UNLOAD-FOREIGN-MODULE","si_unload_foreign_module"}, {SYS_ "NULL-POINTER-P","si_null_pointer_p"}, {SYS_ "SIZE-OF-FOREIGN-ELT-TYPE","si_size_of_foreign_elt_type"}, {SYS_ "ALIGNMENT-OF-FOREIGN-ELT-TYPE","si_alignment_of_foreign_elt_type"}, {KEY_ "BYTE",NULL}, {KEY_ "CHAR",NULL}, {KEY_ "CSTRING",NULL}, {KEY_ "DOUBLE",NULL}, {KEY_ "FIXNUM",NULL}, {KEY_ "FLOAT",NULL}, {KEY_ "INT",NULL}, {KEY_ "INT8-T",NULL}, {KEY_ "INT16-T",NULL}, {KEY_ "INT32-T",NULL}, {KEY_ "INT64-T",NULL}, {KEY_ "LONG",NULL}, {KEY_ "LONG-LONG",NULL}, {KEY_ "POINTER-SELF",NULL}, {KEY_ "POINTER-VOID",NULL}, {KEY_ "SHORT",NULL}, {KEY_ "STRUCT",NULL}, {KEY_ "UNION",NULL}, {KEY_ "VOID",NULL}, {KEY_ "UINT8-T",NULL}, {KEY_ "UINT16-T",NULL}, {KEY_ "UINT32-T",NULL}, {KEY_ "UINT64-T",NULL}, {KEY_ "UNSIGNED-BYTE",NULL}, {KEY_ "UNSIGNED-CHAR",NULL}, {KEY_ "UNSIGNED-INT",NULL}, {KEY_ "UNSIGNED-LONG",NULL}, {KEY_ "UNSIGNED-LONG-LONG",NULL}, {KEY_ "UNSIGNED-SHORT",NULL}, #ifdef GBC_BOEHM {EXT_ "GC","si_gc"}, {SYS_ "GC-DUMP","si_gc_dump"}, {SYS_ "GC-STATS","si_gc_stats"}, #else {EXT_ "GC","si_gc"}, {SYS_ "ALLOCATE","si_allocate"}, {SYS_ "ALLOCATED-PAGES","si_allocated_pages"}, {SYS_ "MAXIMUM-ALLOCATABLE-PAGES","si_maximum_allocatable_pages"}, {SYS_ "ALLOCATE-CONTIGUOUS-PAGES","si_allocate_contiguous_pages"}, {SYS_ "ALLOCATED-CONTIGUOUS-PAGES","si_allocated_contiguous_pages"}, {SYS_ "MAXIMUM-CONTIGUOUS-PAGES","si_maximum_contiguous_pages"}, {SYS_ "GC-TIME","si_gc_time"}, {SYS_ "GET-HOLE-SIZE","si_get_hole_size"}, {SYS_ "SET-HOLE-SIZE","si_set_hole_size"}, {SYS_ "IGNORE-MAXIMUM-PAGES","si_ignore_maximum_pages"}, {SYS_ "ROOM-REPORT","si_room_report"}, {SYS_ "RESET-GC-COUNT","si_reset_gc_count"}, #endif /* !GBC_BOEHM */ /* #ifdef ECL_THREADS */ {MP_ "PROCESS",NULL}, {MP_ "LOCK",NULL}, {MP_ "CONDITION-VARIABLE",NULL}, {MP_ "*CURRENT-PROCESS*",NULL}, {MP_ "ALL-PROCESSES",IF_MP("mp_all_processes")}, {MP_ "EXIT-PROCESS",IF_MP("mp_exit_process")}, {MP_ "MAKE-PROCESS",IF_MP("mp_make_process")}, {MP_ "PROCESS-ACTIVE-P",IF_MP("mp_process_active_p")}, {MP_ "PROCESS-ENABLE",IF_MP("mp_process_enable")}, {MP_ "PROCESS-YIELD",IF_MP("mp_process_yield")}, {MP_ "PROCESS-KILL",IF_MP("mp_process_kill")}, {MP_ "PROCESS-NAME",IF_MP("mp_process_name")}, {MP_ "PROCESS-PRESET",IF_MP("mp_process_preset")}, {MP_ "PROCESS-RUN-FUNCTION",IF_MP("mp_process_run_function")}, {MP_ "PROCESS-WHOSTATE",IF_MP("mp_process_whostate")}, {MP_ "PROCESS-JOIN",IF_MP("mp_process_join")}, {MP_ "MAKE-LOCK",IF_MP("mp_make_lock")}, {KEY_ "RECURSIVE",NULL}, {MP_ "RECURSIVE-LOCK-P",IF_MP("mp_recursive_lock_p")}, {MP_ "LOCK-NAME",IF_MP("mp_lock_name")}, {MP_ "LOCK-OWNER",IF_MP("mp_lock_owner")}, {MP_ "LOCK-COUNT",IF_MP("mp_lock_count")}, {MP_ "GET-LOCK",IF_MP("mp_get_lock")}, {MP_ "GIVEUP-LOCK",IF_MP("mp_giveup_lock")}, {MP_ "MAKE-CONDITION-VARIABLE",IF_MP("mp_make_condition_variable")}, {MP_ "CONDITION-VARIABLE-WAIT",IF_MP("mp_condition_variable_wait")}, {MP_ "CONDITION-VARIABLE-TIMEDWAIT",IF_MP("mp_condition_variable_timedwait")}, {MP_ "CONDITION-VARIABLE-SIGNAL",IF_MP("mp_condition_variable_signal")}, {MP_ "CONDITION-VARIABLE-BROADCAST",IF_MP("mp_condition_variable_broadcast")}, {KEY_ "INITIAL-BINDINGS",NULL}, {MP_ "INTERRUPT-PROCESS",IF_MP("mp_interrupt_process")}, {MP_ "+LOAD-COMPILE-LOCK+",NULL}, {MP_ "WITH-LOCK",NULL}, {MP_ "WITH-RWLOCK",NULL}, {MP_ "BLOCK-SIGNALS",IF_MP("mp_block_signals")}, {MP_ "RESTORE-SIGNALS",IF_MP("mp_restore_signals")}, {MP_ "PROCESS-SUSPEND",IF_MP("mp_process_suspend")}, {MP_ "PROCESS-RESUME",IF_MP("mp_process_resume")}, {MP_ "SUSPEND-LOOP",IF_MP("mp_suspend_loop")}, {MP_ "BREAK-SUSPEND-LOOP",IF_MP("mp_break_suspend_loop")}, {MP_ "MAKE-RWLOCK",IF_MP("mp_make_rwlock")}, {MP_ "RWLOCK",NULL}, {MP_ "RWLOCK-NAME",IF_MP("mp_rwlock_name")}, {MP_ "GET-RWLOCK-READ",IF_MP("mp_get_rwlock_read")}, {MP_ "GET-RWLOCK-WRITE",IF_MP("mp_get_rwlock_write")}, {MP_ "GIVEUP-RWLOCK-READ",IF_MP("mp_giveup_rwlock_read")}, {MP_ "GIVEUP-RWLOCK-WRITE",IF_MP("mp_giveup_rwlock_write")}, {MP_ "GLOBAL-LOCK",NULL}, {MP_ "ERROR-LOCK",NULL}, {MP_ "SEMAPHORE",NULL}, {MP_ "MAKE-SEMAPHORE",IF_MP("mp_make_semaphore")}, {MP_ "SIGNAL-SEMAPHORE",IF_MP("mp_signal_semaphore")}, {MP_ "WAIT-ON-SEMAPHORE",IF_MP("mp_wait_on_semaphore")}, {MP_ "TRY-GET-SEMAPHORE",IF_MP("mp_try_get_semaphore")}, {MP_ "SEMAPHORE-COUNT",IF_MP("mp_semaphore_count")}, {MP_ "SEMAPHORE-NAME",IF_MP("mp_semaphore_name")}, {MP_ "SEMAPHORE-WAIT-COUNT",IF_MP("mp_semaphore_wait_count")}, {KEY_ "COUNT",NULL}, {MP_ "BARRIER",NULL}, {MP_ "MAKE-BARRIER",IF_MP("mp_make_barrier")}, {MP_ "BARRIER-UNBLOCK",IF_MP("mp_barrier_unblock")}, {MP_ "BARRIER-WAIT",IF_MP("mp_barrier_wait")}, {MP_ "BARRIER-COUNT",IF_MP("mp_barrier_count")}, {MP_ "BARRIER-NAME",IF_MP("mp_barrier_name")}, {MP_ "BARRIER-ARRIVERS-COUNT",IF_MP("mp_barrier_arrivers_count")}, {KEY_ "DISABLE",NULL}, {KEY_ "RESET-COUNT",NULL}, {KEY_ "KILL-WAITING",NULL}, {KEY_ "UNBLOCKED",NULL}, {MP_ "MAILBOX",NULL}, {MP_ "MAKE-MAILBOX",IF_MP("mp_make_mailbox")}, {MP_ "MAILBOX-NAME",IF_MP("mp_mailbox_name")}, {MP_ "MAILBOX-COUNT",IF_MP("mp_mailbox_count")}, {MP_ "MAILBOX-EMPTY-P",IF_MP("mp_mailbox_empty_p")}, {MP_ "MAILBOX-READ",IF_MP("mp_mailbox_read")}, {MP_ "MAILBOX-TRY-READ",IF_MP("mp_mailbox_try_read")}, {MP_ "MAILBOX-SEND",IF_MP("mp_mailbox_send")}, {MP_ "MAILBOX-TRY-SEND",IF_MP("mp_mailbox_try_send")}, /* #endif defined(ECL_THREADS) */ {SYS_ "WHILE",NULL}, {SYS_ "UNTIL",NULL}, {SYS_ "QUASIQUOTE",NULL}, {SYS_ "*EXIT-HOOKS*",NULL}, {CLOS_ ".COMBINED-METHOD-ARGS.",NULL}, {CLOS_ "+BUILTIN-CLASSES+",NULL}, {CLOS_ "*NEXT-METHODS*",NULL}, {CLOS_ "*OPTIMIZE-SLOT-ACCESS*",NULL}, {CLOS_ "+THE-T-CLASS+",NULL}, {CLOS_ "+THE-CLASS+",NULL}, {CLOS_ "+THE-STD-CLASS+",NULL}, {CLOS_ "+THE-STANDARD-CLASS+",NULL}, {CLOS_ "+THE-FUNCALLABLE-STANDARD-CLASS+",NULL}, {CLOS_ "ACCESSOR-METHOD-SLOT-DEFINITION",NULL}, {CLOS_ "ADD-DEPENDENT",NULL}, {CLOS_ "ADD-DIRECT-METHOD",NULL}, {CLOS_ "ADD-DIRECT-SUBCLASS",NULL}, {CLOS_ "CLASS-DEFAULT-INITARGS",NULL}, {CLOS_ "CLASS-DIRECT-DEFAULT-INITARGS",NULL}, {CLOS_ "CLASS-DIRECT-SLOTS",NULL}, {CLOS_ "CLASS-DIRECT-SUBCLASSES",NULL}, {CLOS_ "CLASS-DIRECT-SUPERCLASSES",NULL}, {CLOS_ "CLASS-FINALIZED-P",NULL}, {CLOS_ "CLASS-PRECEDENCE-LIST",NULL}, {CLOS_ "CLASS-PROTOTYPE",NULL}, {CLOS_ "CLASS-SLOTS",NULL}, {CLOS_ "COMPUTE-APPLICABLE-METHODS-USING-CLASSES",NULL}, {CLOS_ "COMPUTE-CLASS-PRECEDENCE-LIST",NULL}, {CLOS_ "COMPUTE-DEFAULT-INITARGS",NULL}, {CLOS_ "COMPUTE-DISCRIMINATING-FUNCTION",NULL}, {CLOS_ "COMPUTE-EFFECTIVE-METHOD",NULL}, {CLOS_ "COMPUTE-EFFECTIVE-SLOT-DEFINITION",NULL}, {CLOS_ "COMPUTE-SLOTS",NULL}, {CLOS_ "DIRECT-SLOT-DEFINITION",NULL}, {CLOS_ "DIRECT-SLOT-DEFINITION-CLASS",NULL}, {CLOS_ "EFFECTIVE-SLOT-DEFINITION",NULL}, {CLOS_ "EFFECTIVE-SLOT-DEFINITION-CLASS",NULL}, {CLOS_ "ENSURE-CLASS",NULL}, {CLOS_ "ENSURE-CLASS-USING-CLASS",NULL}, {CLOS_ "ENSURE-GENERIC-FUNCTION-USING-CLASS",NULL}, {CLOS_ "EQL-SPECIALIZER",NULL}, {CLOS_ "EQL-SPECIALIZER-OBJECT",NULL}, {CLOS_ "EXTRACT-LAMBDA-LIST","ECL_NAME(clos_extract_lambda_list)"}, {CLOS_ "EXTRACT-SPECIALIZER-NAMES","ECL_NAME(clos_extract_specializer_names)"}, {CLOS_ "FINALIZE-INHERITANCE",NULL}, {CLOS_ "FIND-METHOD-COMBINATION",NULL}, {CLOS_ "FORWARD-REFERENCED-CLASS",NULL}, {CLOS_ "FUNCALLABLE-STANDARD-CLASS",NULL}, {CLOS_ "FUNCALLABLE-STANDARD-INSTANCE-ACCESS","ECL_NAME(clos_funcallable_standard_instance_access)"}, {CLOS_ "FUNCALLABLE-STANDARD-OBJECT",NULL}, {CLOS_ "GENERIC-FUNCTION-ARGUMENT-PRECEDENCE-ORDER",NULL}, {CLOS_ "GENERIC-FUNCTION-DECLARATIONS",NULL}, {CLOS_ "GENERIC-FUNCTION-LAMBDA-LIST",NULL}, {CLOS_ "GENERIC-FUNCTION-METHOD-CLASS",NULL}, {CLOS_ "GENERIC-FUNCTION-METHOD-COMBINATION",NULL}, {CLOS_ "GENERIC-FUNCTION-METHODS",NULL}, {CLOS_ "GENERIC-FUNCTION-NAME",NULL}, {CLOS_ "INTERN-EQL-SPECIALIZER",NULL}, {CLOS_ "LOCATION-TABLE",NULL}, {CLOS_ "MAKE-METHOD-LAMBDA",NULL}, {CLOS_ "MAP-DEPENDENTS",NULL}, {CLOS_ "METAOBJECT",NULL}, {CLOS_ "METHOD-FUNCTION",NULL}, {CLOS_ "METHOD-GENERIC-FUNCTION",NULL}, {CLOS_ "METHOD-LAMBDA-LIST",NULL}, {CLOS_ "METHOD-SPECIALIZERS",NULL}, {CLOS_ "NAME",NULL}, {CLOS_ "READER-METHOD-CLASS",NULL}, {CLOS_ "REMOVE-DEPENDENT",NULL}, {CLOS_ "REMOVE-DIRECT-METHOD",NULL}, {CLOS_ "REMOVE-DIRECT-SUBCLASS",NULL}, {CLOS_ "SET-FUNCALLABLE-INSTANCE-FUNCTION","clos_set_funcallable_instance_function"}, {CLOS_ "SLOT-BOUNDP-USING-CLASS",NULL}, {CLOS_ "SLOT-DEFINITION",NULL}, {CLOS_ "SLOT-DEFINITION-ALLOCATION",NULL}, {CLOS_ "SLOT-DEFINITION-INITARGS",NULL}, {CLOS_ "SLOT-DEFINITION-INITFORM",NULL}, {CLOS_ "SLOT-DEFINITION-INITFUNCTION",NULL}, {CLOS_ "SLOT-DEFINITION-LOCATION",NULL}, {CLOS_ "SLOT-DEFINITION-NAME",NULL}, {CLOS_ "SLOT-DEFINITION-READERS",NULL}, {CLOS_ "SLOT-DEFINITION-TYPE",NULL}, {CLOS_ "SLOT-DEFINITION-WRITERS",NULL}, {CLOS_ "SLOT-MAKUNBOUND-USING-CLASS",NULL}, {CLOS_ "SLOT-VALUE-USING-CLASS",NULL}, {CLOS_ "SLOT-VALUE-SET","clos_slot_value_set"}, {CLOS_ "SLOT-TABLE",NULL}, {CLOS_ "SPECIALIZER",NULL}, {CLOS_ "SPECIALIZER-DIRECT-GENERIC-FUNCTIONS",NULL}, {CLOS_ "SPECIALIZER-DIRECT-METHODS",NULL}, {CLOS_ "STANDARD-ACCESSOR-METHOD",NULL}, {CLOS_ "STANDARD-DIRECT-SLOT-DEFINITION",NULL}, {CLOS_ "STANDARD-EFFECTIVE-SLOT-DEFINITION",NULL}, {CLOS_ "STANDARD-INSTANCE-ACCESS","ECL_NAME(clos_standard_instance_access)"}, {CLOS_ "STANDARD-INSTANCE-SET","ECL_NAME(clos_standard_instance_set)"}, {CLOS_ "STANDARD-READER-METHOD",NULL}, {CLOS_ "STANDARD-SLOT-DEFINITION",NULL}, {CLOS_ "STANDARD-WRITER-METHOD",NULL}, {CLOS_ "STANDARD-OPTIMIZED-READER-METHOD",NULL}, {CLOS_ "STANDARD-OPTIMIZED-WRITER-METHOD",NULL}, {CLOS_ "STD-COMPUTE-APPLICABLE-METHODS","ECL_NAME(clos_std_compute_applicable_methods)"}, {CLOS_ "STD-COMPUTE-APPLICABLE-METHODS-USING-CLASSES",NULL}, {CLOS_ "STD-COMPUTE-EFFECTIVE-METHOD","ECL_NAME(clos_std_compute_effective_method)"}, {CLOS_ "COMPUTE-EFFECTIVE-METHOD-FUNCTION","ECL_NAME(clos_compute_effective_method_function)"}, {CLOS_ "UPDATE-DEPENDENT",NULL}, {CLOS_ "UPDATE-INSTANCE",NULL}, {CLOS_ "VALIDATE-SUPERCLASS",NULL}, {CLOS_ "WRITER-METHOD-CLASS",NULL}, {SYS_ "CLEAR-GFUN-HASH","si_clear_gfun_hash"}, {CLOS_ "NEED-TO-MAKE-LOAD-FORM-P","ECL_NAME(clos_need_to_make_load_form_p)"}, {CLOS_ "LOAD-DEFCLASS","ECL_NAME(clos_load_defclass)"}, {CLOS_ "DOCSTRING",NULL}, {CLOS_ "SAFE-INSTANCE-REF","clos_safe_instance_ref"}, {SYS_ "CL-FIXNUM-BITS",NULL}, {EXT_ "CL-FIXNUM",NULL}, {EXT_ "CL-INDEX",NULL}, {SYS_ "DO-DEFTYPE","ECL_NAME(si_do_deftype)"}, {SYS_ "CREATE-TYPE-NAME",NULL}, {SYS_ "*ALIEN-DECLARATIONS*",NULL}, #ifdef ENABLE_DLOPEN {SYS_ "LOAD-BINARY","si_load_binary"}, #else {SYS_ "LOAD-BINARY",NULL}, #endif {SYS_ "*CODE-WALKER*",NULL}, /* #if defined(HAVE_LIBFFI) || defined(ECL_DYNAMIC_FFI) */ {SYS_ "CALL-CFUN",IF_DFFI("si_call_cfun")}, {KEY_ "CALLBACK",NULL}, {SYS_ "MAKE-DYNAMIC-CALLBACK",IF_DFFI("si_make_dynamic_callback")}, {SYS_ "FREE-FFI-CLOSURE",IF_LIBFFI("si_free_ffi_closure")}, /* #endif defined(HAVE_LIBFFI) || defined(ECL_DYNAMIC_FFI) */ {KEY_ "CDECL",NULL}, {KEY_ "STDCALL",NULL}, {SYS_ "TRAP-FPE","si_trap_fpe"}, {EXT_ "*ACTION-ON-UNDEFINED-VARIABLE*",NULL}, {SYS_ "SET-BUFFERING-MODE","si_set_buffering_mode"}, {KEY_ "NONE",NULL}, {KEY_ "LINE-BUFFERED",NULL}, {KEY_ "FULLY-BUFFERED",NULL}, {KEY_ "LINE",NULL}, {KEY_ "FULL",NULL}, {SYS_ "CMP-ENV-REGISTER-MACROLET",NULL}, {EXT_ "GET-FINALIZER","si_get_finalizer"}, {EXT_ "SET-FINALIZER","si_set_finalizer"}, /* #ifdef ECL_RELATIVE_PACKAGE_NAMES */ {SYS_ "*RELATIVE-PACKAGE-NAMES*",NULL}, {KEY_ "RELATIVE-PACKAGE-NAMES",NULL}, {SYS_ "FIND-RELATIVE-PACKAGE",IF_RELPACK("si_find_relative_package")}, {SYS_ "PACKAGE-PARENT",NULL}, {SYS_ "PACKAGE-CHILDREN",NULL}, /* #endif ECL_RELATIVE_PACKAGE_NAMES */ {SYS_ "WRONG-TYPE-ARGUMENT","si_wrong_type_argument"}, {SYS_ "*CURRENT-FORM*",NULL}, {SYS_ "CODE-BLOCK",NULL}, {SYS_ "FRAME",NULL}, {SYS_ "APPLY-FROM-STACK-FRAME","si_apply_from_stack_frame"}, #ifdef ECL_CLOS_STREAMS {GRAY_ "CLOSE",NULL}, {GRAY_ "STREAMP",NULL}, {GRAY_ "INPUT-STREAM-P",NULL}, {GRAY_ "OUTPUT-STREAM-P",NULL}, {GRAY_ "OPEN-STREAM-P",NULL}, {GRAY_ "STREAM-ADVANCE-TO-COLUMN",NULL}, {GRAY_ "STREAM-CLEAR-INPUT",NULL}, {GRAY_ "STREAM-CLEAR-OUTPUT",NULL}, {GRAY_ "STREAM-ELEMENT-TYPE",NULL}, {GRAY_ "STREAM-FILE-DESCRIPTOR",NULL}, {GRAY_ "STREAM-FILE-POSITION",NULL}, {GRAY_ "STREAM-FINISH-OUTPUT",NULL}, {GRAY_ "STREAM-FORCE-OUTPUT",NULL}, {GRAY_ "STREAM-FRESH-LINE",NULL}, {GRAY_ "STREAM-INTERACTIVE-P",NULL}, {GRAY_ "STREAM-LINE-COLUMN",NULL}, {GRAY_ "STREAM-LISTEN",NULL}, {GRAY_ "STREAM-PEEK-CHAR",NULL}, {GRAY_ "STREAM-READ-BYTE",NULL}, {GRAY_ "STREAM-READ-CHAR",NULL}, {GRAY_ "STREAM-READ-CHAR-NO-HANG",NULL}, {GRAY_ "STREAM-READ-LINE",NULL}, {GRAY_ "STREAM-READ-SEQUENCE",NULL}, {GRAY_ "STREAM-START-LINE-P",NULL}, {GRAY_ "STREAM-TERPRI",NULL}, {GRAY_ "STREAM-UNREAD-CHAR",NULL}, {GRAY_ "STREAM-WRITE-BYTE",NULL}, {GRAY_ "STREAM-WRITE-CHAR",NULL}, {GRAY_ "STREAM-WRITE-SEQUENCE",NULL}, {GRAY_ "STREAM-WRITE-STRING",NULL}, {GRAY_ "FUNDAMENTAL-STREAM",NULL}, {GRAY_ "FUNDAMENTAL-INPUT-STREAM",NULL}, {GRAY_ "FUNDAMENTAL-OUTPUT-STREAM",NULL}, {GRAY_ "FUNDAMENTAL-CHARACTER-STREAM",NULL}, {GRAY_ "FUNDAMENTAL-BINARY-STREAM",NULL}, {GRAY_ "FUNDAMENTAL-CHARACTER-INPUT-STREAM",NULL}, {GRAY_ "FUNDAMENTAL-CHARACTER-OUTPUT-STREAM",NULL}, {GRAY_ "FUNDAMENTAL-BINARY-INPUT-STREAM",NULL}, {GRAY_ "FUNDAMENTAL-BINARY-OUTPUT-STREAM",NULL}, #endif /* ECL_CLOS_STREAMS */ {SYS_ "LOG1P","si_log1p"}, {EXT_ "BC-FILE","si_compiled_function_file"}, {EXT_ "COMPILED-FUNCTION-FILE","si_compiled_function_file"}, {SYS_ "PROPERTY-LIST",NULL}, {SYS_ "BYTECODES",NULL}, {SYS_ "HASH-EQL","si_hash_eql"}, {SYS_ "HASH-EQUAL","si_hash_equal"}, {SYS_ "HASH-EQUALP","si_hash_equalp"}, {EXT_ "INTERACTIVE-INTERRUPT",NULL}, {EXT_ "STORAGE-EXHAUSTED",NULL}, {EXT_ "STACK-OVERFLOW",NULL}, {EXT_ "STACK-OVERFLOW-SIZE",NULL}, {EXT_ "STACK-OVERFLOW-TYPE",NULL}, {EXT_ "BINDING-STACK",NULL}, {EXT_ "FRAME-STACK",NULL}, {EXT_ "LISP-STACK",NULL}, {EXT_ "C-STACK",NULL}, {EXT_ "HEAP-SIZE",NULL}, {EXT_ "ILLEGAL-INSTRUCTION",NULL}, {EXT_ "SET-LIMIT","si_set_limit"}, {EXT_ "GET-LIMIT","si_get_limit"}, {SYS_ "RESET-MARGIN","si_reset_margin"}, {EXT_ "SEGMENTATION-VIOLATION",NULL}, {EXT_ "EXTENDED-STRING",NULL}, {SYS_ "CHECK-PENDING-INTERRUPTS","si_check_pending_interrupts"}, {KEY_ "LATIN-1",NULL}, {KEY_ "ISO-8859-1",NULL}, {KEY_ "UTF-8",NULL}, {KEY_ "UCS-2",NULL}, {KEY_ "UCS-4",NULL}, {EXT_ "CONSTANTLY-T",NULL}, {EXT_ "CONSTANTLY-NIL",NULL}, {EXT_ "MAYBE-QUOTE",NULL}, {EXT_ "MAYBE-UNQUOTE",NULL}, {KEY_ "CR",NULL}, {KEY_ "LF",NULL}, {KEY_ "CRLF",NULL}, {KEY_ "UCS-2BE",NULL}, {KEY_ "UCS-4BE",NULL}, {KEY_ "UCS-2LE",NULL}, {KEY_ "UCS-4LE",NULL}, {EXT_ "LOAD-ENCODING","ECL_NAME(si_load_encoding)"}, {EXT_ "MAKE-ENCODING","si_make_encoding"}, {EXT_ "ALL-ENCODINGS",NULL}, {KEY_ "US-ASCII",NULL}, {KEY_ "LITTLE-ENDIAN",NULL}, {KEY_ "BIG-ENDIAN",NULL}, {SYS_ "+UNICODE-DATABASE+",NULL}, {EXT_ "COPY-FILE","si_copy_file"}, {EXT_ "FILL-ARRAY-WITH-ELT","si_fill_array_with_elt"}, {EXT_ "+ECL-VERSION-NUMBER+",NULL}, {EXT_ "*BYTECODES-COMPILER*",NULL}, {EXT_ "SHORT-FLOAT-POSITIVE-INFINITY",NULL}, {EXT_ "SINGLE-FLOAT-POSITIVE-INFINITY",NULL}, {EXT_ "DOUBLE-FLOAT-POSITIVE-INFINITY",NULL}, {EXT_ "LONG-FLOAT-POSITIVE-INFINITY",NULL}, {EXT_ "SHORT-FLOAT-NEGATIVE-INFINITY",NULL}, {EXT_ "SINGLE-FLOAT-NEGATIVE-INFINITY",NULL}, {EXT_ "DOUBLE-FLOAT-NEGATIVE-INFINITY",NULL}, {EXT_ "LONG-FLOAT-NEGATIVE-INFINITY",NULL}, {EXT_ "FLOAT-NAN-P","si_float_nan_p"}, {EXT_ "FLOAT-INFINITY-P","si_float_infinity_p"}, {SYS_ "READ-OBJECT-OR-IGNORE","si_read_object_or_ignore"}, {EXT_ "FLOAT-NAN-STRING",NULL}, {EXT_ "FLOAT-INFINITY-STRING",NULL}, {EXT_ "READTABLE-LOCK","si_readtable_lock"}, {SYS_ "+IO-SYNTAX-PROGV-LIST+",NULL}, {SYS_ "+ECL-SYNTAX-PROGV-LIST+",NULL}, {SYS_ "WITH-ECL-IO-SYNTAX",NULL}, {SYS_ "STREAM-EXTERNAL-FORMAT-SET","si_stream_external_format_set"}, {KEY_ "SYSV",NULL}, {KEY_ "UNIX64",NULL}, {KEY_ "WIN64",NULL}, {EXT_ "WEAK-POINTER",NULL}, {EXT_ "MAKE-WEAK-POINTER","si_make_weak_pointer"}, {EXT_ "WEAK-POINTER-VALUE","si_weak_pointer_value"}, {SYS_ "*ALLOW-WITH-INTERRUPTS*",NULL}, {EXT_ "WITH-UNIQUE-NAMES",NULL}, {EXT_ "WITH-CLEAN-SYMBOLS",NULL}, {SYS_ "HANDLE-SIGNAL","si_handle_signal"}, {EXT_ "WITH-INTERRUPTS",NULL}, {EXT_ "WITHOUT-INTERRUPTS",NULL}, {EXT_ "WITH-LOCAL-INTERRUPTS",NULL}, {EXT_ "ALLOW-WITH-INTERRUPTS",NULL}, {SYS_ "*QUIT-TAG*",NULL}, {EXT_ "ARRAY-RAW-DATA","si_array_raw_data"}, {EXT_ "*PROGRAM-EXIT-CODE*",NULL}, {EXT_ "EXIT","si_exit"}, {EXT_ "ENVIRON","si_environ"}, {KEY_ "ENVIRON",NULL}, {EXT_ "MAKE-EXTERNAL-PROCESS",NULL}, {EXT_ "EXTERNAL-PROCESS",NULL}, {EXT_ "EXTERNAL-PROCESS-PID",NULL}, {EXT_ "EXTERNAL-PROCESS-INPUT",NULL}, {EXT_ "EXTERNAL-PROCESS-OUTPUT",NULL}, {EXT_ "EXTERNAL-PROCESS-ERROR-STREAM",NULL}, {EXT_ "EXTERNAL-PROCESS-STATUS",NULL}, {KEY_ "RUNNING",NULL}, {KEY_ "EXITED",NULL}, {KEY_ "SIGNALED",NULL}, {KEY_ "STOPPED",NULL}, {EXT_ "EXTERNAL-PROCESS-WAIT","si_external_process_wait"}, #if defined(ECL_MS_WINDOWS_HOST) || defined(cygwin) {SYS_ "CLOSE-WINDOWS-HANDLE","si_close_windows_handle"}, #else {SYS_ "CLOSE-WINDOWS-HANDLE",NULL}, #endif {EXT_ "*INVOKE-DEBUGGER-HOOK*",NULL}, {EXT_ "*DOCUMENTATION-POOL*",NULL}, {EXT_ "ANNOTATE",NULL}, {EXT_ "GET-ANNOTATION",NULL}, {EXT_ "REMOVE-ANNOTATION",NULL}, {EXT_ "FUNCTION-LAMBDA-LIST",NULL}, {EXT_ "DEFAULT-ANNOTATION-LOGIC",NULL}, {EXT_ "OPTIONAL-ANNOTATION",NULL}, {EXT_ "LOCATION",NULL}, {EXT_ "LISP-IMPLEMENTATION-VCS-ID","ECL_NAME(si_lisp_implementation_vcs_id)"}, {SYS_ "SIGNAL-SERVICING",NULL}, {EXT_ "*DEFAULT-EXTERNAL-FORMAT*",NULL}, {KEY_ "PASS-THROUGH",NULL}, {EXT_ "WITH-BACKEND",NULL}, {KEY_ "BYTECODES",NULL}, {KEY_ "C/C++",NULL}, {EXT_ "ARRAY-INDEX",NULL}, {EXT_ "ANSI-STREAM",NULL}, {EXT_ "COMPLEX-ARRAY",NULL}, {SYS_ "SEQUENCE-START-END","si_sequence_start_end"}, {SYS_ "SEQUENCE-COUNT",NULL}, {SYS_ "SHRINK-VECTOR",NULL}, {SYS_ "COPY-SUBARRAY","si_copy_subarray"}, {SYS_ "CONS-CAR","cl_car"}, {SYS_ "CONS-CDR","cl_cdr"}, {EXT_ "COMPILER-TYPECASE",NULL}, {SYS_ "ASSERT-FAILURE","ECL_NAME(si_assert_failure)"}, {SYS_ "CCASE-ERROR","ECL_NAME(si_ccase_error)"}, {SYS_ "ECASE-ERROR","ECL_NAME(si_ecase_error)"}, {SYS_ "ETYPECASE-ERROR","ECL_NAME(si_etypecase_error)"}, {SYS_ "CTYPECASE-ERROR","ECL_NAME(si_ctypecase_error)"}, {SYS_ "DO-CHECK-TYPE","ECL_NAME(si_do_check_type)"}, {SYS_ "SERIALIZE","si_serialize"}, {SYS_ "DESERIALIZE","si_deserialize"}, {EXT_ "ARRAY-ELEMENT-TYPE-BYTE-SIZE","si_array_element_type_byte_size"}, /* #ifdef ECL_SSE2 */ {EXT_ "SSE-PACK",NULL}, {EXT_ "SSE-PACK-P",IF_SSE2("si_sse_pack_p")}, {EXT_ "SSE-PACK-AS-ELT-TYPE",IF_SSE2("si_sse_pack_as_elt_type")}, {EXT_ "VECTOR-TO-SSE-PACK",IF_SSE2("si_vector_to_sse_pack")}, {EXT_ "SSE-PACK-TO-VECTOR",IF_SSE2("si_sse_pack_to_vector")}, {EXT_ "INT-SSE-PACK",NULL}, {EXT_ "FLOAT-SSE-PACK",NULL}, {EXT_ "DOUBLE-SSE-PACK",NULL}, {EXT_ "SSE-PACK-ELEMENT-TYPE",IF_SSE2("si_sse_pack_element_type")}, {EXT_ "*SSE-PACK-PRINT-MODE*",NULL}, /* #endif ECL_SSE2 */ {EXT_ "UNIX-SIGNAL-RECEIVED",NULL}, {EXT_ "UNIX-SIGNAL-RECEIVED-CODE",NULL}, {KEY_ "CODE",NULL}, {EXT_ "ASSUME-RIGHT-TYPE",NULL}, {SYS_ "FLOAT-TO-DIGITS","si_float_to_digits"}, {SYS_ "FLOAT-TO-STRING-FREE","si_float_to_string_free"}, {SYS_ "INTEGER-TO-STRING","si_integer_to_string"}, {SYS_ "PRINT-UNREADABLE-OBJECT-FUNCTION","si_print_unreadable_object_function"}, {EXT_ "DUMP-C-BACKTRACE","si_dump_c_backtrace"}, {EXT_ "+PROCESS-STANDARD-INPUT+",NULL}, {EXT_ "+PROCESS-STANDARD-OUTPUT+",NULL}, {EXT_ "+PROCESS-ERROR-OUTPUT+",NULL}, {EXT_ "*HELP-MESSAGE*",NULL}, {EXT_ "*LISP-INIT-FILE-LIST*",NULL}, {EXT_ "+DEFAULT-COMMAND-ARG-RULES+",NULL}, {EXT_ "COMMAND-ARGS",NULL}, {EXT_ "*COMMAND-ARGS*",NULL}, {EXT_ "PROCESS-COMMAND-ARGS",NULL}, {EXT_ "*UNPROCESSED-ECL-COMMAND-ARGS*",NULL}, /* #ifdef ECL_UNICODE */ {KEY_ "OCTETS",NULL}, {EXT_ "CHARACTER-CODING-ERROR",NULL}, {EXT_ "CHARACTER-CODING-ERROR-EXTERNAL-FORMAT",NULL}, {EXT_ "CHARACTER-ENCODING-ERROR",NULL}, {EXT_ "CHARACTER-ENCODING-ERROR-CODE",NULL}, {EXT_ "CHARACTER-DECODING-ERROR",NULL}, {EXT_ "CHARACTER-DECODING-ERROR-OCTETS",NULL}, {EXT_ "STREAM-DECODING-ERROR",NULL}, {EXT_ "STREAM-ENCODING-ERROR",NULL}, {EXT_ "DECODING-ERROR",NULL}, {EXT_ "ENCODING-ERROR",NULL}, /* #endif ECL_UNICODE */ {SYS_ "PROPER-LIST-P","si_proper_list_p"}, {SYS_ "TRACED-OLD-DEFINITION","ECL_NAME(si_traced_old_definition)"}, {SYS_ "*TRACE-LIST*",NULL}, {SYS_ "FUNCTION-BOUNDARY",NULL}, {EXT_ "*INSPECTOR-HOOK*",NULL}, {KEY_ "RESOLVE-SYMLINKS",NULL}, {SYS_ "LOAD-BYTECODES","si_load_bytecodes"}, {KEY_ "SHARED",NULL}, {KEY_ "PRIVATE",NULL}, {EXT_ "MMAP","si_mmap"}, {EXT_ "MUNMAP","si_munmap"}, {EXT_ "MMAP-ARRAY","si_mmap_array"}, {SYS_ "GET-CDATA","si_get_cdata"}, {SYS_ "ADD-CDATA","si_add_cdata"}, /* * CDR-5 http://cdr.eurolisp.org/document/5/extra-num-types.html */ {EXT_ "NEGATIVE-FIXNUM",NULL}, {EXT_ "NON-NEGATIVE-FIXNUM",NULL}, {EXT_ "NON-POSITIVE-FIXNUM",NULL}, {EXT_ "POSITIVE-FIXNUM",NULL}, {EXT_ "NEGATIVE-FIXNUM-P","ECL_NAME(si_negative_fixnum_p)"}, {EXT_ "POSITIVE-FIXNUM-P","ECL_NAME(si_positive_fixnum_p)"}, {EXT_ "NON-NEGATIVE-FIXNUM-P","ECL_NAME(si_non_negative_fixnum_p)"}, {EXT_ "NON-POSITIVE-FIXNUM-P","ECL_NAME(si_non_positive_fixnum_p)"}, {EXT_ "NEGATIVE-INTEGER",NULL}, {EXT_ "NON-NEGATIVE-INTEGER",NULL}, {EXT_ "NON-POSITIVE-INTEGER",NULL}, {EXT_ "POSITIVE-INTEGER",NULL}, {EXT_ "NEGATIVE-INTEGER-P","ECL_NAME(si_negative_integer_p)"}, {EXT_ "POSITIVE-INTEGER-P","ECL_NAME(si_positive_integer_p)"}, {EXT_ "NON-NEGATIVE-INTEGER-P","ECL_NAME(si_non_negative_integer_p)"}, {EXT_ "NON-POSITIVE-INTEGER-P","ECL_NAME(si_non_positive_integer_p)"}, {EXT_ "NEGATIVE-RATIONAL",NULL}, {EXT_ "NON-NEGATIVE-RATIONAL",NULL}, {EXT_ "NON-POSITIVE-RATIONAL",NULL}, {EXT_ "POSITIVE-RATIONAL",NULL}, {EXT_ "NEGATIVE-RATIONAL-P","ECL_NAME(si_negative_rational_p)"}, {EXT_ "POSITIVE-RATIONAL-P","ECL_NAME(si_positive_rational_p)"}, {EXT_ "NON-NEGATIVE-RATIONAL-P","ECL_NAME(si_non_negative_rational_p)"}, {EXT_ "NON-POSITIVE-RATIONAL-P","ECL_NAME(si_non_positive_rational_p)"}, {EXT_ "NEGATIVE-RATIO",NULL}, {EXT_ "NON-NEGATIVE-RATIO",NULL}, {EXT_ "NON-POSITIVE-RATIO",NULL}, {EXT_ "POSITIVE-RATIO",NULL}, {EXT_ "NEGATIVE-RATIO-P","ECL_NAME(si_negative_ratio_p)"}, {EXT_ "POSITIVE-RATIO-P","ECL_NAME(si_positive_ratio_p)"}, {EXT_ "NON-NEGATIVE-RATIO-P","ECL_NAME(si_non_negative_ratio_p)"}, {EXT_ "NON-POSITIVE-RATIO-P","ECL_NAME(si_non_positive_ratio_p)"}, {EXT_ "NEGATIVE-REAL",NULL}, {EXT_ "NON-NEGATIVE-REAL",NULL}, {EXT_ "NON-POSITIVE-REAL",NULL}, {EXT_ "POSITIVE-REAL",NULL}, {EXT_ "NEGATIVE-REAL-P","ECL_NAME(si_negative_real_p)"}, {EXT_ "POSITIVE-REAL-P","ECL_NAME(si_positive_real_p)"}, {EXT_ "NON-NEGATIVE-REAL-P","ECL_NAME(si_non_negative_real_p)"}, {EXT_ "NON-POSITIVE-REAL-P","ECL_NAME(si_non_positive_real_p)"}, {EXT_ "NEGATIVE-FLOAT",NULL}, {EXT_ "NON-NEGATIVE-FLOAT",NULL}, {EXT_ "NON-POSITIVE-FLOAT",NULL}, {EXT_ "POSITIVE-FLOAT",NULL}, {EXT_ "NEGATIVE-FLOAT-P","ECL_NAME(si_negative_float_p)"}, {EXT_ "POSITIVE-FLOAT-P","ECL_NAME(si_positive_float_p)"}, {EXT_ "NON-NEGATIVE-FLOAT-P","ECL_NAME(si_non_negative_float_p)"}, {EXT_ "NON-POSITIVE-FLOAT-P","ECL_NAME(si_non_positive_float_p)"}, {EXT_ "NEGATIVE-SHORT-FLOAT",NULL}, {EXT_ "NON-NEGATIVE-SHORT-FLOAT",NULL}, {EXT_ "NON-POSITIVE-SHORT-FLOAT",NULL}, {EXT_ "POSITIVE-SHORT-FLOAT",NULL}, {EXT_ "NEGATIVE-SHORT-FLOAT-P","ECL_NAME(si_negative_short_float_p)"}, {EXT_ "POSITIVE-SHORT-FLOAT-P","ECL_NAME(si_positive_short_float_p)"}, {EXT_ "NON-NEGATIVE-SHORT-FLOAT-P","ECL_NAME(si_non_negative_short_float_p)"}, {EXT_ "NON-POSITIVE-SHORT-FLOAT-P","ECL_NAME(si_non_positive_short_float_p)"}, {EXT_ "NEGATIVE-SINGLE-FLOAT",NULL}, {EXT_ "NON-NEGATIVE-SINGLE-FLOAT",NULL}, {EXT_ "NON-POSITIVE-SINGLE-FLOAT",NULL}, {EXT_ "POSITIVE-SINGLE-FLOAT",NULL}, {EXT_ "NEGATIVE-SINGLE-FLOAT-P","ECL_NAME(si_negative_single_float_p)"}, {EXT_ "POSITIVE-SINGLE-FLOAT-P","ECL_NAME(si_positive_single_float_p)"}, {EXT_ "NON-NEGATIVE-SINGLE-FLOAT-P","ECL_NAME(si_non_negative_single_float_p)"}, {EXT_ "NON-POSITIVE-SINGLE-FLOAT-P","ECL_NAME(si_non_positive_single_float_p)"}, {EXT_ "NEGATIVE-DOUBLE-FLOAT",NULL}, {EXT_ "NON-NEGATIVE-DOUBLE-FLOAT",NULL}, {EXT_ "NON-POSITIVE-DOUBLE-FLOAT",NULL}, {EXT_ "POSITIVE-DOUBLE-FLOAT",NULL}, {EXT_ "NEGATIVE-DOUBLE-FLOAT-P","ECL_NAME(si_negative_double_float_p)"}, {EXT_ "POSITIVE-DOUBLE-FLOAT-P","ECL_NAME(si_positive_double_float_p)"}, {EXT_ "NON-NEGATIVE-DOUBLE-FLOAT-P","ECL_NAME(si_non_negative_double_float_p)"}, {EXT_ "NON-POSITIVE-DOUBLE-FLOAT-P","ECL_NAME(si_non_positive_double_float_p)"}, {EXT_ "NEGATIVE-LONG-FLOAT",NULL}, {EXT_ "NON-NEGATIVE-LONG-FLOAT",NULL}, {EXT_ "NON-POSITIVE-LONG-FLOAT",NULL}, {EXT_ "POSITIVE-LONG-FLOAT",NULL}, {EXT_ "NEGATIVE-LONG-FLOAT-P","ECL_NAME(si_negative_long_float_p)"}, {EXT_ "POSITIVE-LONG-FLOAT-P","ECL_NAME(si_positive_long_float_p)"}, {EXT_ "NON-NEGATIVE-LONG-FLOAT-P","ECL_NAME(si_non_negative_long_float_p)"}, {EXT_ "NON-POSITIVE-LONG-FLOAT-P","ECL_NAME(si_non_positive_long_float_p)"}, {EXT_ "ARRAY-INDEX-P","ECL_NAME(si_array_index_p)"}, {EXT_ "SEQUENCE-STREAM",NULL}, {EXT_ "MAKE-SEQUENCE-INPUT-STREAM","si_make_sequence_input_stream"}, {EXT_ "MAKE-SEQUENCE-OUTPUT-STREAM","si_make_sequence_output_stream"}, {EXT_ "CHMOD","si_chmod"}, {SYS_ "MISSING-KEYWORD",NULL}, {EXT_ "HASH-TABLE-CONTENT","si_hash_table_content"}, {EXT_ "HASH-TABLE-FILL","si_hash_table_fill"}, {SYS_ "REPORT-FUNCTION",NULL}, {SYS_ "DO-DEFSETF","ECL_NAME(si_do_defsetf)"}, {SYS_ "DO-DEFINE-SETF-METHOD","ECL_NAME(si_do_define_setf_method)"}, {SYS_ "SETF-DEFINITION","ECL_NAME(si_setf_definition)"}, {EXT_ "ASSUME-NO-ERRORS",NULL}, {EXT_ "ASSUME-TYPES-DONT-CHANGE",NULL}, {EXT_ "CHECK-ARGUMENTS-TYPE",NULL}, {EXT_ "INLINE-ACCESSORS",NULL}, {EXT_ "INLINE-TYPE-CHECKS",NULL}, {EXT_ "EVALUATE-FORMS",NULL}, {EXT_ "TYPE-ASSERTIONS",NULL}, {EXT_ "CHECK-STACK-OVERFLOW",NULL}, {EXT_ "ARRAY-BOUNDS-CHECK",NULL}, {KEY_ "VALUE",NULL}, {KEY_ "KEY-AND-VALUE",NULL}, {KEY_ "WEAKNESS",NULL}, {EXT_ "HASH-TABLE-WEAKNESS","si_hash_table_weakness"}, {EXT_ "TRULY-THE",NULL}, {EXT_ "CHECKED-VALUE",NULL}, {EXT_ "INSTALL-BYTECODES-COMPILER",NULL}, {EXT_ "INSTALL-C-COMPILER",NULL}, {FFI_ "C-CHAR-BIT",NULL}, {FFI_ "C-CHAR-MAX",NULL}, {FFI_ "C-CHAR-MIN",NULL}, {FFI_ "C-INT-MAX",NULL}, /* See main.d */ {FFI_ "C-INT-MIN",NULL}, /* See main.d */ {FFI_ "C-SHORT-MAX",NULL}, {FFI_ "C-SHORT-MIN",NULL}, {FFI_ "C-LONG-MAX",NULL}, /* See main.d */ {FFI_ "C-LONG-MIN",NULL}, /* See main.d */ {FFI_ "C-LONG-LONG-MAX",NULL}, /* See main.d */ {FFI_ "C-UCHAR-MAX",NULL}, {FFI_ "C-UINT-MAX",NULL}, /* See main.d */ {FFI_ "C-USHORT-MAX",NULL}, {FFI_ "C-ULONG-MAX",NULL}, /* See main.d */ {FFI_ "C-ULONG-LONG-MAX",NULL}, /* See main.d */ #ifdef ecl_long_long_t {FFI_ "C-LONG-LONG-BIT",NULL}, #else {FFI_ "C-LONG-LONG-BIT",NULL}, #endif {FFI_ "*USE-DFFI*",NULL}, {FFI_ "+NULL-CSTRING-POINTER+",NULL}, {FFI_ "ALLOCATE-FOREIGN-OBJECT",NULL}, {FFI_ "ALLOCATE-FOREIGN-STRING",NULL}, {FFI_ "C-INLINE",NULL}, {FFI_ "C-PROGN",NULL}, {FFI_ "CALLBACK",NULL}, {FFI_ "CHAR*",NULL}, {FFI_ "CHAR-ARRAY-TO-POINTER",NULL}, {FFI_ "CLINES",NULL}, {FFI_ "CONVERT-FROM-CSTRING",NULL}, {FFI_ "CONVERT-FROM-FOREIGN-STRING",NULL}, {FFI_ "CONVERT-TO-CSTRING",NULL}, {FFI_ "CONVERT-TO-FOREIGN-STRING",NULL}, {FFI_ "DEF-ARRAY",NULL}, {FFI_ "DEF-ARRAY-POINTER",NULL}, {FFI_ "DEF-CONSTANT",NULL}, {FFI_ "DEF-ENUM",NULL}, {FFI_ "DEF-FOREIGN-TYPE",NULL}, {FFI_ "DEF-FOREIGN-VAR",NULL}, {FFI_ "DEF-FUNCTION",NULL}, {FFI_ "DEF-STRUCT",NULL}, {FFI_ "DEF-TYPE",NULL}, {FFI_ "DEF-UNION",NULL}, {FFI_ "DEFCALLBACK",NULL}, {FFI_ "DEFCBODY",NULL}, {FFI_ "DEFENTRY",NULL}, {FFI_ "DEFINLINE",NULL}, {FFI_ "DEFLA",NULL}, {FFI_ "DEREF-ARRAY",NULL}, {FFI_ "DEREF-POINTER",NULL}, {FFI_ "DOUBLE",NULL}, {FFI_ "ENSURE-CHAR-CHARACTER",NULL}, {FFI_ "ENSURE-CHAR-INTEGER",NULL}, {FFI_ "ENSURE-CHAR-STORABLE",NULL}, {FFI_ "FIND-FOREIGN-LIBRARY",NULL}, {FFI_ "FOREIGN-STRING-LENGTH",NULL}, {FFI_ "FREE-CSTRING",NULL}, {FFI_ "FREE-FOREIGN-OBJECT",NULL}, {FFI_ "GET-SLOT-POINTER",NULL}, {FFI_ "GET-SLOT-VALUE",NULL}, {FFI_ "INT",NULL}, {FFI_ "LOAD-FOREIGN-LIBRARY",NULL}, {FFI_ "MAKE-NULL-POINTER",NULL}, {FFI_ "MAKE-POINTER",NULL}, {FFI_ "NULL-CHAR-P",NULL}, {FFI_ "OBJECT",NULL}, {FFI_ "POINTER-ADDRESS",NULL}, {FFI_ "SIZE-OF-FOREIGN-TYPE",NULL}, {FFI_ "VOID",NULL}, {FFI_ "WITH-CAST-POINTER",NULL}, {FFI_ "WITH-CSTRING",NULL}, {FFI_ "WITH-CSTRINGS",NULL}, {FFI_ "WITH-FOREIGN-OBJECT",NULL}, {FFI_ "WITH-FOREIGN-OBJECTS",NULL}, {FFI_ "WITH-FOREIGN-STRING",NULL}, {FFI_ "WITH-FOREIGN-STRINGS",NULL}, {SYS_ "BIND-SIMPLE-RESTARTS","ECL_NAME(si_bind_simple_restarts)"}, {SYS_ "BIND-SIMPLE-HANDLERS","ECL_NAME(si_bind_simple_handlers)"}, {EXT_ "CONSTANT-FORM-VALUE","si_constant_form_value"}, {EXT_ "CONSTANTP-INNER","si_constantp_inner"}, {SYS_ "MAKE-BACKQ-VECTOR","si_make_backq_vector"}, {SYS_ "RATIOP","ECL_NAME(si_ratiop)"}, {SYS_ "SHORT-FLOAT-P","ECL_NAME(si_short_float_p)"}, {SYS_ "SINGLE-FLOAT-P","ECL_NAME(si_single_float_p)"}, {SYS_ "DOUBLE-FLOAT-P","ECL_NAME(si_double_float_p)"}, {SYS_ "LONG-FLOAT-P","ECL_NAME(si_long_float_p)"}, {SYS_ "COPY-HASH-TABLE","si_copy_hash_table"}, /* Tag for end of list */ {NULL,NULL}}; ecl-16.1.2/src/c/tcp.d000066400000000000000000000304531266352375300143310ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* tcp.c -- stream interface to TCP */ /* Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU General Library Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #include #include #include #if defined(ECL_MS_WINDOWS_HOST) #include #else #ifdef __ANDROID__ #include #else extern int errno; #endif #include #include #include #include #include #include #include #endif #include #if defined(ECL_MS_WINDOWS_HOST) #include #else #include #endif /* Maximum length for a unix socket pathname */ #define UNIX_MAX_PATH 107 #if defined(ECL_MS_WINDOWS_HOST) WSADATA wsadata; int wsock_initialized = 0; #define INIT_TCP \ if ( !wsock_initialized ) \ { \ if ( WSAStartup( MAKEWORD( 2, 2 ), &wsadata ) != NO_ERROR ) \ FEerror( "Unable to initialize Windows socket library.", 0 ); \ else \ wsock_initialized = 1; \ } #else #define INIT_TCP #endif void ecl_tcp_close_all(void) { #if defined(ECL_MS_WINDOWS_HOST) if ( wsock_initialized ) { WSACleanup(); wsock_initialized = 0; } #endif } /*********************************************************************** * Client side **********************************************************************/ /* * Attempts to connect to server, given host and port. Returns file * descriptor (network socket) or 0 if connection fails. */ static int connect_to_server(char *host, int port) { struct sockaddr_in inaddr; /* INET socket address. */ struct sockaddr *addr; /* address to connect to */ struct hostent *host_ptr; int addrlen; /* length of address */ #if !defined(ECL_MS_WINDOWS_HOST) extern char *getenv(); extern struct hostent *gethostbyname(); #endif int fd; /* Network socket */ INIT_TCP /* Get the statistics on the specified host. */ if ((inaddr.sin_addr.s_addr = inet_addr(host)) == -1) { if ((host_ptr = gethostbyname(host)) == NULL) { /* No such host! */ errno = EINVAL; return(0); } /* Check the address type for an internet host. */ if (host_ptr->h_addrtype != AF_INET) { /* Not an Internet host! */ #if defined(ECL_MS_WINDOWS_HOST) errno = WSAEPROTOTYPE; #else errno = EPROTOTYPE; #endif return(0); } /* Set up the socket data. */ inaddr.sin_family = host_ptr->h_addrtype; memcpy((char *)&inaddr.sin_addr, (char *)host_ptr->h_addr, sizeof(inaddr.sin_addr)); } else inaddr.sin_family = AF_INET; addr = (struct sockaddr *) &inaddr; addrlen = sizeof (struct sockaddr_in); inaddr.sin_port = port; inaddr.sin_port = htons(inaddr.sin_port); /* * Open the network connection. */ if ((fd = socket((int) addr->sa_family, SOCK_STREAM, 0)) < 0) return(0); /* errno set by system call. */ ecl_disable_interrupts(); #ifdef TCP_NODELAY /* make sure to turn off TCP coalescence */ #if defined(ECL_MS_WINDOWS_HOST) { char mi; setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, &mi, sizeof (char)); } #else { int mi; setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, &mi, sizeof (int)); } #endif #endif if (connect(fd, addr, addrlen) == -1) { #if defined(ECL_MS_WINDOWS_HOST) closesocket(fd); #else (void) close (fd); #endif fd = 0; } ecl_enable_interrupts(); return(fd); } /*********************************************************************** * Server side **********************************************************************/ /* * Creates a server port. Returns file * descriptor (network socket) or 0 if connection fails. */ int create_server_port(int port) { struct sockaddr_in inaddr; /* INET socket address. */ struct sockaddr *addr; /* address to connect to */ int addrlen; /* length of address */ int request, conn; /* Network socket */ INIT_TCP /* * Open the network connection. */ if ((request = socket(AF_INET, SOCK_STREAM, 0)) < 0) { return(0); /* errno set by system call. */ } #ifdef SO_REUSEADDR /* Necesary to restart the server without a reboot */ #if defined(ECL_MS_WINDOWS_HOST) { char one = 1; setsockopt(request, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(char)); } #else { int one = 1; setsockopt(request, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(int)); } #endif #endif /* SO_REUSEADDR */ #ifdef TCP_NODELAY /* make sure to turn off TCP coalescence */ #if defined(ECL_MS_WINDOWS_HOST) { char mi; setsockopt(request, IPPROTO_TCP, TCP_NODELAY, &mi, sizeof (char)); } #else { int mi; setsockopt(request, IPPROTO_TCP, TCP_NODELAY, &mi, sizeof (int)); } #endif #endif /* Set up the socket data. */ memset((char *)&inaddr, 0, sizeof(inaddr)); inaddr.sin_family = AF_INET; #if defined(ECL_MS_WINDOWS_HOST) inaddr.sin_port = htons((unsigned short)port); #else inaddr.sin_port = htons(port); #endif inaddr.sin_addr.s_addr = htonl(INADDR_ANY); if (bind(request, (struct sockaddr *)&inaddr, sizeof (inaddr))) FElibc_error("Binding TCP socket", 0); if (listen(request, 1)) FElibc_error("TCP listening", 0); #if 0 && defined(ECL_THREADS) /* Don't make this file-descriptor non-blocking * just block on it before we attempt to accept from it * Think _hard_ about moving this out of here, into somewhere sane * and creating an 'accepting' stream type, which is bound to a port * on reading returns streams */ { FILE *fp; /* need to use FILE *'s rather than fd... *sigh* */ if ((fp = fdopen(request, "r")) == (FILE *)0) printf("fdopen didn't work on accept fd!\n"); fflush(stdout); fcntl(request, F_SETFL, O_NONBLOCK); clearerr(fp); loop: errno = 0; if ((conn = accept(request, (struct sockaddr *)NULL, (int *)NULL)) < 0) if (errno) { lwpblockon(active, fp, PD_INPUT); clearerr(fp); goto loop; } else { fclose(fp); FElibc_error("Accepting requests", 0); } fclose(fp); } #else if ((conn = accept(request, (struct sockaddr *)NULL, NULL)) < 0) FElibc_error("Accepting requests", 0); #endif /* THREADS */ return(conn); } /*********************************************************************** * Public interface to lisp environment **********************************************************************/ /* @open-client-stream -- To test this function, try: (setq s (si:open-client-stream "host" 13)) (read-line s) "Wed Jun 22 19:44:36 METDST 1994" */ cl_object si_open_client_stream(cl_object host, cl_object port) { int fd, p; /* file descriptor */ cl_object stream; /* Ensure "host" is a string that we can pass to a C function */ host = si_copy_to_simple_base_string(host); if (ecl_unlikely(!ECL_FIXNUMP(port) || ecl_fixnum_minusp(port) || ecl_fixnum_greater(port,ecl_make_fixnum(65536)))) { FEwrong_type_nth_arg(@[si::open-client-stream], 2, port, ecl_read_from_cstring("(INTEGER 0 65535)")); } p = ecl_fixnum(port); if (host->base_string.fillp > BUFSIZ - 1) FEerror("~S is a too long file name.", 1, host); ecl_disable_interrupts(); fd = connect_to_server((char*)host->base_string.self, ecl_fixnum(port)); ecl_enable_interrupts(); if (fd == 0) @(return ECL_NIL) #if defined(ECL_MS_WINDOWS_HOST) stream = ecl_make_stream_from_fd(host, fd, ecl_smm_io_wsock, 8, 0, ECL_NIL); #else stream = ecl_make_stream_from_fd(host, fd, ecl_smm_io, 8, 0, ECL_NIL); #endif @(return stream) } cl_object si_open_server_stream(cl_object port) { int fd; /* file descriptor */ cl_index p; if (ecl_unlikely(!ECL_FIXNUMP(port) || ecl_fixnum_minusp(port) || ecl_fixnum_greater(port,ecl_make_fixnum(65536)))) { FEwrong_type_only_arg(@[si::open-client-stream], port, ecl_read_from_cstring("(INTEGER 0 65535)")); } p = ecl_fixnum(port); ecl_disable_interrupts(); fd = create_server_port(p); ecl_enable_interrupts(); @(return ((fd == 0)? ECL_NIL : ecl_make_stream_from_fd(ECL_NIL, fd, ecl_smm_io, 8, 0, ECL_NIL))) } /************************************************************ * Unix sockets * ************************************************************/ cl_object si_open_unix_socket_stream(cl_object path) { #if defined(ECL_MS_WINDOWS_HOST) FEerror("UNIX socket not supported under Win32 platform", 0); #else int fd; /* file descriptor */ struct sockaddr_un addr; if (ecl_unlikely(!ECL_STRINGP(path))) FEwrong_type_nth_arg(@[si::open-unix-socket-stream], 1, path, @[string]); path = si_coerce_to_base_string(path); if (path->base_string.fillp > UNIX_MAX_PATH-1) FEerror("~S is a too long file name.", 1, path); fd = socket(PF_UNIX, SOCK_STREAM, 0); if (fd < 0) { FElibc_error("Unable to create unix socket", 0); @(return ECL_NIL) } memcpy(addr.sun_path, path->base_string.self, path->base_string.fillp); addr.sun_path[path->base_string.fillp] = 0; addr.sun_family = AF_UNIX; if (connect(fd, (struct sockaddr *)&addr, sizeof(addr)) < 0) { close(fd); FElibc_error("Unable to connect to unix socket ~A", 1, path); @(return ECL_NIL) } @(return ecl_make_stream_from_fd(path, fd, ecl_smm_io, 8, 0, ECL_NIL)) #endif } /************************************************************ * Hostname resolution * ************************************************************/ cl_object si_lookup_host_entry(cl_object host_or_address) { struct hostent *he; unsigned long l; char address[4]; cl_object name, aliases, addresses; int i; INIT_TCP switch (ecl_t_of(host_or_address)) { #ifdef ECL_UNICODE case t_string: #endif case t_base_string: host_or_address = si_copy_to_simple_base_string(host_or_address); he = gethostbyname((char*)host_or_address->base_string.self); break; case t_fixnum: l = ecl_fixnum(host_or_address); goto addr; case t_bignum: l = _ecl_big_to_ulong(host_or_address); addr: address[0] = l & 0xFF; address[1] = (l >> 8) & 0xFF; address[2] = (l >> 16) & 0xFF; address[3] = (l >> 24) & 0xFF; he = gethostbyaddr(&address, 4, AF_INET); break; default: FEerror("LOOKUP-HOST-ENTRY: Number or string expected, got ~S", 1, host_or_address); } if (he == NULL) @(return ECL_NIL ECL_NIL ECL_NIL) name = make_base_string_copy(he->h_name); aliases = ECL_NIL; for (i = 0; he->h_aliases[i] != 0; i++) aliases = CONS(make_base_string_copy(he->h_aliases[i]), aliases); addresses = ECL_NIL; for (i = 0; he->h_addr_list[i]; i++) { unsigned long *s = (unsigned long*)(he->h_addr_list[i]); l = *s; addresses = CONS(ecl_make_integer(l), addresses); } @(return name aliases addresses) } ecl-16.1.2/src/c/threads/000077500000000000000000000000001266352375300150235ustar00rootroot00000000000000ecl-16.1.2/src/c/threads/atomic.d000077500000000000000000000034731266352375300164560ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* atomic.d -- atomic operations. */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #include #ifdef ECL_THREADS #include "threads/ecl_atomics.h" cl_object ecl_atomic_get(cl_object *slot) { cl_object old; do { old = (cl_object)AO_load((AO_t*)slot); } while (!AO_compare_and_swap_full((AO_t*)slot, (AO_t)old, (AO_t)ECL_NIL)); return old; } void ecl_atomic_push(cl_object *slot, cl_object c) { cl_object cons = ecl_list1(c), car; do { car = (cl_object)AO_load((AO_t*)slot); ECL_RPLACD(cons, car); } while (!AO_compare_and_swap_full((AO_t*)slot, (AO_t)car, (AO_t)cons)); } cl_object ecl_atomic_pop(cl_object *slot) { cl_object cons, rest; do { cons = (cl_object)AO_load((AO_t*)slot); rest = CDR(cons); } while (!AO_compare_and_swap_full((AO_t*)slot, (AO_t)cons, (AO_t)rest)); return cons; } cl_index ecl_atomic_index_incf(cl_index *slot) { AO_t old; AO_t next; do { old = AO_load((AO_t*)slot); next = old+1; } while (!AO_compare_and_swap_full((AO_t*)slot, (AO_t)old, (AO_t)next)); return (cl_index)next; } #endif /* ECL_THREADS */ ecl-16.1.2/src/c/threads/barrier.d000077500000000000000000000127031266352375300166240ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* barrier.d -- wait barriers */ /* Copyright (c) 2012, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #define AO_ASSUME_WINDOWS98 /* We need this for CAS */ #include #include #include "threads/ecl_atomics.h" static ECL_INLINE void FEerror_not_a_barrier(cl_object barrier) { FEwrong_type_argument(@'mp::barrier', barrier); } cl_object ecl_make_barrier(cl_object name, cl_index count) { cl_object output = ecl_alloc_object(t_barrier); output->barrier.name = name; output->barrier.arrivers_count = count; output->barrier.count = count; output->barrier.queue_list = ECL_NIL; output->barrier.queue_spinlock = ECL_NIL; return output; } @(defun mp::make-barrier (count &key name) @ if (count == ECL_T) count = ecl_make_fixnum(MOST_POSITIVE_FIXNUM); @(return ecl_make_barrier(name, fixnnint(count))) @) cl_object mp_barrier_name(cl_object barrier) { cl_env_ptr env = ecl_process_env(); unlikely_if (ecl_t_of(barrier) != t_barrier) { FEerror_not_a_barrier(barrier); } ecl_return1(env, barrier->barrier.name); } cl_object mp_barrier_count(cl_object barrier) { cl_env_ptr env = ecl_process_env(); unlikely_if (ecl_t_of(barrier) != t_barrier) { FEerror_not_a_barrier(barrier); } ecl_return1(env, ecl_make_fixnum(barrier->barrier.count)); } cl_object mp_barrier_arrivers_count(cl_object barrier) { cl_fixnum arrivers, count; cl_env_ptr env = ecl_process_env(); unlikely_if (ecl_t_of(barrier) != t_barrier) { FEerror_not_a_barrier(barrier); } arrivers = barrier->barrier.arrivers_count; count = barrier->barrier.count; if (arrivers < 0) arrivers = 0; /* Disabled barrier */ else arrivers = count - arrivers; ecl_return1(env, ecl_make_fixnum(arrivers)); } @(defun mp::barrier-unblock (barrier &key reset_count disable kill_waiting) int ping_flags = ECL_WAKEUP_RESET_FLAG | ECL_WAKEUP_ALL; int kill_flags = ECL_WAKEUP_RESET_FLAG | ECL_WAKEUP_KILL | ECL_WAKEUP_ALL; @ unlikely_if (ecl_t_of(barrier) != t_barrier) { FEerror_not_a_barrier(barrier); } if (!Null(reset_count)) barrier->barrier.count = fixnnint(reset_count); if (!Null(disable)) barrier->barrier.arrivers_count = -1; else barrier->barrier.arrivers_count = barrier->barrier.count; ecl_wakeup_waiters(the_env, barrier, Null(kill_waiting)? ping_flags : kill_flags); @(return) @) static cl_object barrier_wait_condition(cl_env_ptr env, cl_object barrier) { /* We were signaled */ if (env->own_process->process.woken_up != ECL_NIL) return ECL_T; /* Disabled barrier */ else if (barrier->barrier.arrivers_count < 0) return ECL_T; else return ECL_NIL; } static cl_fixnum decrement_counter(cl_fixnum *counter) { /* The logic is as follows: * - If the counter is negative, we abort. This is a way of * disabling the counter. * - Otherwise, we decrease the counter only if it is positive * - If the counter is currently zero, then we block. This * situation implies that some other thread is unblocking. */ cl_fixnum c; do { c = *counter; if (c < 0) { return c; } else if (c > 0) { if (AO_compare_and_swap_full((AO_t*)counter, (AO_t)c, (AO_t)(c-1))) return c; } } while (1); } @(defun mp::barrier-wait (barrier &key) cl_object output; cl_fixnum counter; @ { cl_object own_process = the_env->own_process; unlikely_if (ecl_t_of(barrier) != t_barrier) { FEerror_not_a_barrier(barrier); } ecl_disable_interrupts_env(the_env); counter = decrement_counter(&barrier->barrier.arrivers_count); if (counter == 0) { print_lock("barrier %p saturated", barrier, barrier); /* There are (count-1) threads in the queue and we * are the last one. We thus unblock all threads and * proceed. */ mp_barrier_unblock(1, barrier); ecl_enable_interrupts_env(the_env); output = @':unblocked'; } else if (counter > 0) { print_lock("barrier %p waiting", barrier, barrier); ecl_enable_interrupts_env(the_env); ecl_wait_on(the_env, barrier_wait_condition, barrier); output = ECL_T; } else { print_lock("barrier %p pass-through", barrier, barrier); /* Barrier disabled */ output = ECL_NIL; } @(return output) } @) ecl-16.1.2/src/c/threads/condition_variable.d000066400000000000000000000072761266352375300210370ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* condition_variable.d -- Native threads. */ /* Copyright (c) 2003, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #include /*---------------------------------------------------------------------- * CONDITION VARIABLES */ cl_object mp_make_condition_variable(void) { cl_object output = ecl_alloc_object(t_condition_variable); output->condition_variable.queue_list = ECL_NIL; output->condition_variable.queue_spinlock = ECL_NIL; output->condition_variable.lock = ECL_NIL; @(return output) } static cl_object condition_variable_wait(cl_env_ptr env, cl_object cv) { cl_object lock = cv->condition_variable.lock; cl_object own_process = env->own_process; /* We have entered the queue and still own the mutex? */ print_lock("cv lock %p is %p =? %p", cv, lock, lock->lock.owner, own_process); if (lock->lock.owner == own_process) { mp_giveup_lock(lock); } /* We always return when we have been explicitly awaken */ return own_process->process.woken_up; } cl_object mp_condition_variable_wait(cl_object cv, cl_object lock) { cl_env_ptr env = ecl_process_env(); cl_object own_process = env->own_process; unlikely_if (ecl_t_of(cv) != t_condition_variable) { FEwrong_type_nth_arg(@[mp::condition-variable-wait], 1, cv, @[mp::condition-variable]); } unlikely_if (ecl_t_of(lock) != t_lock) { FEwrong_type_nth_arg(@[mp::condition-variable-wait], 2, lock, @[mp::lock]); } unlikely_if (cv->condition_variable.lock != ECL_NIL && cv->condition_variable.lock != lock) { FEerror("Attempt to associate lock ~A~%with condition variable ~A," "~%which is already associated to lock ~A", 2, lock, cv, cv->condition_variable.lock); } unlikely_if (lock->lock.owner != own_process) { FEerror("Attempt to wait on a condition variable using lock~%~S" "~%which is not owned by process~%~S", 2, lock, own_process); } unlikely_if (lock->lock.counter > 1) { FEerror("mp:condition-variable-wait can not be used with recursive" " locks:~%~S", 1, lock); } print_lock("waiting cv %p", cv, cv); cv->condition_variable.lock = lock; ecl_wait_on(env, condition_variable_wait, cv); mp_get_lock_wait(lock); @(return ECL_T) } cl_object mp_condition_variable_timedwait(cl_object cv, cl_object lock, cl_object seconds) { FEerror("Timed condition variables are not supported.", 0); } cl_object mp_condition_variable_signal(cl_object cv) { print_lock("signal cv %p", cv, cv); ecl_wakeup_waiters(ecl_process_env(), cv, ECL_WAKEUP_RESET_FLAG | ECL_WAKEUP_ONE | ECL_WAKEUP_DELETE); @(return ECL_T) } cl_object mp_condition_variable_broadcast(cl_object cv) { print_lock("broadcast cv %p", cv); ecl_wakeup_waiters(ecl_process_env(), cv, ECL_WAKEUP_RESET_FLAG | ECL_WAKEUP_ALL | ECL_WAKEUP_DELETE); @(return ECL_T) } ecl-16.1.2/src/c/threads/ecl_atomics.h000077500000000000000000000017301266352375300174620ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* ecl_atomics.h -- alternative definitions for atomic operations */ /* Copyright (c) 2012, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #ifndef ECL_ATOMICS_H #define AO_ASSUME_WINDOWS98 #include #if !defined(AO_HAVE_compare_and_swap_full) # error "ECL needs AO_compare_and_swap_full or an equivalent" #endif #if !defined(AO_HAVE_compare_and_swap) # error "ECL needs AO_compare_and_swap or an equivalent" #endif #if !defined(AO_HAVE_fetch_and_add1) # error "Cannot implement mailboxs without AO_fetch_and_add1" #endif #endif /* ECL_ATOMICS_H */ ecl-16.1.2/src/c/threads/mailbox.d000077500000000000000000000126351266352375300166350ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* mailbox.d -- thread communication queue */ /* Copyright (c) 2012, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #define AO_ASSUME_WINDOWS98 /* We need this for CAS */ #include #include #include "threads/ecl_atomics.h" static ECL_INLINE void FEerror_not_a_mailbox(cl_object mailbox) { FEwrong_type_argument(@'mp::mailbox', mailbox); } cl_object ecl_make_mailbox(cl_object name, cl_fixnum count) { cl_object output = ecl_alloc_object(t_mailbox); cl_fixnum mask; for (mask = 1; mask < count; mask <<= 1) {} if (mask == 1) mask = 63; count = mask; mask = count - 1; output->mailbox.name = name; output->mailbox.data = si_make_vector(ECL_T, /* element type */ ecl_make_fixnum(count), /* size */ ECL_NIL, /* adjustable */ ECL_NIL, /* fill pointer */ ECL_NIL, /* displaced to */ ECL_NIL); /* displacement */ output->mailbox.reader_semaphore = ecl_make_semaphore(name, 0); output->mailbox.writer_semaphore = ecl_make_semaphore(name, count); output->mailbox.read_pointer = 0; output->mailbox.write_pointer = 0; output->mailbox.mask = mask; return output; } @(defun mp::make-mailbox (&key name (count ecl_make_fixnum(128))) @ { @(return ecl_make_mailbox(name, fixnnint(count))) } @) cl_object mp_mailbox_name(cl_object mailbox) { cl_env_ptr env = ecl_process_env(); unlikely_if (ecl_t_of(mailbox) != t_mailbox) { FEerror_not_a_mailbox(mailbox); } ecl_return1(env, mailbox->mailbox.name); } cl_object mp_mailbox_count(cl_object mailbox) { cl_env_ptr env = ecl_process_env(); unlikely_if (ecl_t_of(mailbox) != t_mailbox) { FEerror_not_a_mailbox(mailbox); } ecl_return1(env, ecl_make_fixnum(mailbox->mailbox.data->vector.dim)); } cl_object mp_mailbox_empty_p(cl_object mailbox) { cl_env_ptr env = ecl_process_env(); unlikely_if (ecl_t_of(mailbox) != t_mailbox) { FEerror_not_a_mailbox(mailbox); } ecl_return1(env, mailbox->mailbox.reader_semaphore->semaphore.counter? ECL_NIL : ECL_T); } cl_object mp_mailbox_read(cl_object mailbox) { cl_env_ptr env = ecl_process_env(); cl_fixnum ndx; cl_object output; unlikely_if (ecl_t_of(mailbox) != t_mailbox) { FEerror_not_a_mailbox(mailbox); } mp_wait_on_semaphore(mailbox->mailbox.reader_semaphore); { ndx = AO_fetch_and_add1((AO_t*)&mailbox->mailbox.read_pointer) & mailbox->mailbox.mask; output = mailbox->mailbox.data->vector.self.t[ndx]; } mp_signal_semaphore(1, mailbox->mailbox.writer_semaphore); ecl_return1(env, output); } cl_object mp_mailbox_try_read(cl_object mailbox) { cl_env_ptr env = ecl_process_env(); cl_fixnum ndx; cl_object output; unlikely_if (ecl_t_of(mailbox) != t_mailbox) { FEerror_not_a_mailbox(mailbox); } output = mp_try_get_semaphore(mailbox->mailbox.reader_semaphore); if (output != ECL_NIL) { ndx = AO_fetch_and_add1((AO_t*)&mailbox->mailbox.read_pointer) & mailbox->mailbox.mask; output = mailbox->mailbox.data->vector.self.t[ndx]; mp_signal_semaphore(1, mailbox->mailbox.writer_semaphore); } ecl_return1(env, output); } cl_object mp_mailbox_send(cl_object mailbox, cl_object msg) { cl_env_ptr env = ecl_process_env(); cl_fixnum ndx; unlikely_if (ecl_t_of(mailbox) != t_mailbox) { FEerror_not_a_mailbox(mailbox); } mp_wait_on_semaphore(mailbox->mailbox.writer_semaphore); { ndx = AO_fetch_and_add1((AO_t*)&mailbox->mailbox.write_pointer) & mailbox->mailbox.mask; mailbox->mailbox.data->vector.self.t[ndx] = msg; } mp_signal_semaphore(1, mailbox->mailbox.reader_semaphore); ecl_return0(env); } cl_object mp_mailbox_try_send(cl_object mailbox, cl_object msg) { cl_env_ptr env = ecl_process_env(); cl_object output; cl_fixnum ndx; unlikely_if (ecl_t_of(mailbox) != t_mailbox) { FEerror_not_a_mailbox(mailbox); } output = mp_try_get_semaphore(mailbox->mailbox.writer_semaphore); if (output != ECL_NIL) { output = msg; ndx = AO_fetch_and_add1((AO_t*)&mailbox->mailbox.write_pointer) & mailbox->mailbox.mask; mailbox->mailbox.data->vector.self.t[ndx] = msg; mp_signal_semaphore(1, mailbox->mailbox.reader_semaphore); } ecl_return1(env, output); } ecl-16.1.2/src/c/threads/mutex.d000077500000000000000000000134511266352375300163410ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* mutex.d -- mutually exclusive locks. */ /* Copyright (c) 2003, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #define AO_ASSUME_WINDOWS98 /* We need this for CAS */ #include #include #include "threads/ecl_atomics.h" /*---------------------------------------------------------------------- * LOCKS or MUTEX */ static void FEerror_not_a_lock(cl_object lock) { FEwrong_type_argument(@'mp::lock', lock); } static void FEerror_not_a_recursive_lock(cl_object lock) { FEerror("Attempted to recursively lock ~S which is already owned by ~S", 2, lock, lock->lock.owner); } static void FEerror_not_owned(cl_object lock) { FEerror("Attempted to give up lock ~S that is not owned by process ~S", 2, lock, mp_current_process()); } cl_object ecl_make_lock(cl_object name, bool recursive) { cl_object output = ecl_alloc_object(t_lock); output->lock.name = name; output->lock.owner = ECL_NIL; output->lock.counter = 0; output->lock.recursive = recursive; output->lock.queue_list = ECL_NIL; output->lock.queue_spinlock = ECL_NIL; return output; } @(defun mp::make-lock (&key name ((:recursive recursive) ECL_NIL)) @ @(return ecl_make_lock(name, !Null(recursive))) @) cl_object mp_recursive_lock_p(cl_object lock) { cl_env_ptr env = ecl_process_env(); unlikely_if (ecl_t_of(lock) != t_lock) FEerror_not_a_lock(lock); ecl_return1(env, lock->lock.recursive? ECL_T : ECL_NIL); } cl_object mp_lock_name(cl_object lock) { cl_env_ptr env = ecl_process_env(); unlikely_if (ecl_t_of(lock) != t_lock) { FEerror_not_a_lock(lock); } ecl_return1(env, lock->lock.name); } cl_object mp_lock_owner(cl_object lock) { cl_env_ptr env = ecl_process_env(); unlikely_if (ecl_t_of(lock) != t_lock) { FEerror_not_a_lock(lock); } ecl_return1(env, lock->lock.owner); } cl_object mp_lock_count(cl_object lock) { cl_env_ptr env = ecl_process_env(); unlikely_if (ecl_t_of(lock) != t_lock) { FEerror_not_a_lock(lock); } ecl_return1(env, ecl_make_fixnum(lock->lock.counter)); } cl_object mp_giveup_lock(cl_object lock) { /* Must be called with interrupts disabled. */ cl_env_ptr env = ecl_process_env(); cl_object own_process = env->own_process; unlikely_if (ecl_t_of(lock) != t_lock) { FEerror_not_a_lock(lock); } unlikely_if (lock->lock.owner != own_process) { FEerror_not_owned(lock); } if (--lock->lock.counter == 0) { cl_object first = ecl_waiter_pop(env, lock);; if (first == ECL_NIL) { lock->lock.owner = ECL_NIL; } else { lock->lock.counter = 1; lock->lock.owner = first; ecl_wakeup_process(first); } } ecl_return1(env, ECL_T); } static cl_object get_lock_inner(cl_env_ptr env, cl_object lock) { cl_object output; cl_object own_process = env->own_process; ecl_disable_interrupts_env(env); if (AO_compare_and_swap_full((AO_t*)&(lock->lock.owner), (AO_t)ECL_NIL, (AO_t)own_process)) { lock->lock.counter = 1; output = ECL_T; print_lock("acquired %p\t", lock, lock); } else if (lock->lock.owner == own_process) { unlikely_if (!lock->lock.recursive) { FEerror_not_a_recursive_lock(lock); } ++lock->lock.counter; output = ECL_T; } else { print_lock("failed acquiring %p for %d\t", lock, lock, lock->lock.owner); output = ECL_NIL; } ecl_enable_interrupts_env(env); return output; } cl_object mp_get_lock_nowait(cl_object lock) { cl_env_ptr env = ecl_process_env(); unlikely_if (ecl_t_of(lock) != t_lock) { FEerror_not_a_lock(lock); } ecl_return1(env, get_lock_inner(env, lock)); } static cl_object own_or_get_lock(cl_env_ptr env, cl_object lock) { cl_object output; cl_object own_process = env->own_process; ecl_disable_interrupts_env(env); if (AO_compare_and_swap_full((AO_t*)&(lock->lock.owner), (AO_t)ECL_NIL, (AO_t)own_process)) { lock->lock.counter = 1; output = ECL_T; print_lock("acquired %p\t", lock, lock); } else if (lock->lock.owner == own_process) { output = ECL_T; } else { output = ECL_NIL; } ecl_enable_interrupts_env(env); return output; } cl_object mp_get_lock_wait(cl_object lock) { cl_env_ptr env = ecl_process_env(); unlikely_if (ecl_t_of(lock) != t_lock) { FEerror_not_a_lock(lock); } if (get_lock_inner(env, lock) == ECL_NIL) { ecl_wait_on(env, own_or_get_lock, lock); } @(return ECL_T) } @(defun mp::get-lock (lock &optional (wait ECL_T)) @ if (Null(wait)) return mp_get_lock_nowait(lock); else return mp_get_lock_wait(lock); @) ecl-16.1.2/src/c/threads/process.d000077500000000000000000000636311266352375300166620ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* threads.d -- Native threads. */ /* Copyright (c) 2003, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #ifndef __sun__ /* See unixinit.d for this */ #define _XOPEN_SOURCE 600 /* For pthread mutex attributes */ #endif #include #include #include #define ECL_INCLUDE_MATH_H #include #ifdef ECL_WINDOWS_THREADS # include #else # include #endif #ifdef HAVE_GETTIMEOFDAY # include #endif #include #include #include "threads/ecl_atomics.h" #ifdef ECL_WINDOWS_THREADS /* * We have to put this explicit definition here because Boehm GC * is designed to produce a DLL and we rather want a static * reference */ # include extern HANDLE WINAPI GC_CreateThread( LPSECURITY_ATTRIBUTES lpThreadAttributes, DWORD dwStackSize, LPTHREAD_START_ROUTINE lpStartAddress, LPVOID lpParameter, DWORD dwCreationFlags, LPDWORD lpThreadId ); # ifndef WITH___THREAD DWORD cl_env_key; # endif #else # ifndef WITH___THREAD static pthread_key_t cl_env_key; # endif #endif /* ECL_WINDOWS_THREADS */ extern void ecl_init_env(struct cl_env_struct *env); #if !defined(WITH___THREAD) cl_env_ptr ecl_process_env(void) { #ifdef ECL_WINDOWS_THREADS return TlsGetValue(cl_env_key); #else struct cl_env_struct *rv = pthread_getspecific(cl_env_key); if (rv) return rv; FElibc_error("pthread_getspecific() failed.", 0); return NULL; #endif } #endif static void ecl_set_process_env(cl_env_ptr env) { #ifdef WITH___THREAD cl_env_p = env; #else # ifdef ECL_WINDOWS_THREADS TlsSetValue(cl_env_key, env); # else if (pthread_setspecific(cl_env_key, env)) FElibc_error("pthread_setspecific() failed.", 0); # endif #endif } cl_object mp_current_process(void) { return ecl_process_env()->own_process; } /*---------------------------------------------------------------------- * PROCESS LIST */ static void extend_process_vector() { cl_object v = cl_core.processes; cl_index new_size = v->vector.dim + v->vector.dim/2; cl_env_ptr the_env = ecl_process_env(); ECL_WITH_SPINLOCK_BEGIN(the_env, &cl_core.processes_spinlock) { cl_object other = cl_core.processes; if (new_size > other->vector.dim) { cl_object new = si_make_vector(ECL_T, ecl_make_fixnum(new_size), ecl_make_fixnum(other->vector.fillp), ECL_NIL, ECL_NIL, ECL_NIL); ecl_copy_subarray(new, 0, other, 0, other->vector.dim); cl_core.processes = new; } } ECL_WITH_SPINLOCK_END; } static void ecl_list_process(cl_object process) { cl_env_ptr the_env = ecl_process_env(); bool ok = 0; do { ECL_WITH_SPINLOCK_BEGIN(the_env, &cl_core.processes_spinlock) { cl_object vector = cl_core.processes; cl_index size = vector->vector.dim; cl_index ndx = vector->vector.fillp; if (ndx < size) { vector->vector.self.t[ndx++] = process; vector->vector.fillp = ndx; ok = 1; } } ECL_WITH_SPINLOCK_END; if (ok) break; extend_process_vector(); } while (1); } static void ecl_unlist_process(cl_object process) { cl_env_ptr the_env = ecl_process_env(); ECL_WITH_SPINLOCK_BEGIN(the_env, &cl_core.processes_spinlock) { cl_object vector = cl_core.processes; cl_index i; for (i = 0; i < vector->vector.fillp; i++) { if (vector->vector.self.t[i] == process) { vector->vector.fillp--; do { vector->vector.self.t[i] = vector->vector.self.t[i+1]; } while (++i < vector->vector.fillp); break; } } } ECL_WITH_SPINLOCK_END; } static cl_object ecl_process_list() { cl_env_ptr the_env = ecl_process_env(); cl_object output = ECL_NIL; ECL_WITH_SPINLOCK_BEGIN(the_env, &cl_core.processes_spinlock) { cl_object vector = cl_core.processes; cl_object *data = vector->vector.self.t; cl_index i; for (i = 0; i < vector->vector.fillp; i++) { cl_object p = data[i]; if (p != ECL_NIL) output = ecl_cons(p, output); } } ECL_WITH_SPINLOCK_END; return output; } /*---------------------------------------------------------------------- * THREAD OBJECT */ static void assert_type_process(cl_object o) { if (ecl_t_of(o) != t_process) FEwrong_type_argument(@[mp::process], o); } static void thread_cleanup(void *aux) { /* This routine performs some cleanup before a thread is completely * killed. For instance, it has to remove the associated process * object from the list, an it has to dealloc some memory. * * NOTE: thread_cleanup() does not provide enough "protection". In * order to ensure that all UNWIND-PROTECT forms are properly * executed, never use pthread_cancel() to kill a process, but * rather use the lisp functions mp_interrupt_process() and * mp_process_kill(). */ cl_object process = (cl_object)aux; cl_env_ptr env = process->process.env; /* The following flags will disable all interrupts. */ AO_store_full((AO_t*)&process->process.phase, ECL_PROCESS_EXITING); ecl_disable_interrupts_env(env); #ifdef HAVE_SIGPROCMASK /* ...but we might get stray signals. */ { sigset_t new[1]; sigemptyset(new); sigaddset(new, ecl_option_values[ECL_OPT_THREAD_INTERRUPT_SIGNAL]); pthread_sigmask(SIG_BLOCK, new, NULL); } #endif process->process.env = NULL; ecl_unlist_process(process); mp_barrier_unblock(3, process->process.exit_barrier, @':disable', ECL_T); ecl_set_process_env(NULL); if (env) _ecl_dealloc_env(env); AO_store_release((AO_t*)&process->process.phase, ECL_PROCESS_INACTIVE); } #ifdef ECL_WINDOWS_THREADS static DWORD WINAPI thread_entry_point(void *arg) #else static void * thread_entry_point(void *arg) #endif { cl_object process = (cl_object)arg; cl_env_ptr env = process->process.env; /* * Upon entering this routine * process.env = our environment for lisp * process.phase = ECL_PROCESS_BOOTING * signals are disabled in the environment * the communication interrupt is disabled (sigmasked) * * This process will not receive signals that originate from * other processes. Furthermore, we expect not to get any * other interrupts (SIGSEGV, SIGFPE) if we do things right. */ /* 1) Setup the environment for the execution of the thread */ ecl_set_process_env(env = process->process.env); #ifndef ECL_WINDOWS_THREADS pthread_cleanup_push(thread_cleanup, (void *)process); #endif ecl_cs_set_org(env); ecl_get_spinlock(env, &process->process.start_spinlock); print_lock("ENVIRON %p %p %p %p", ECL_NIL, process, env->bds_org, env->bds_top, env->bds_limit); /* 2) Execute the code. The CATCH_ALL point is the destination * provides us with an elegant way to exit the thread: we just * do an unwind up to frs_top. */ ECL_CATCH_ALL_BEGIN(env) { #ifdef HAVE_SIGPROCMASK { sigset_t *new = (sigset_t*)env->default_sigmask; pthread_sigmask(SIG_SETMASK, new, NULL); } #endif process->process.phase = ECL_PROCESS_ACTIVE; ecl_enable_interrupts_env(env); si_trap_fpe(@'last', ECL_T); ecl_bds_bind(env, @'mp::*current-process*', process); ECL_RESTART_CASE_BEGIN(env, @'abort') { env->values[0] = cl_apply(2, process->process.function, process->process.args); { cl_object output = ECL_NIL; int i = env->nvalues; while (i--) { output = CONS(env->values[i], output); } process->process.exit_values = output; } } ECL_RESTART_CASE(1,args) { /* ABORT restart. */ process->process.exit_values = args; } ECL_RESTART_CASE_END; /* This will disable interrupts during the exit * so that the unwinding is not interrupted. */ process->process.phase = ECL_PROCESS_EXITING; ecl_bds_unwind1(env); } ECL_CATCH_ALL_END; /* 4) If everything went right, we should be exiting the thread * through this point. thread_cleanup is automatically invoked * marking the process as inactive. */ #ifdef ECL_WINDOWS_THREADS thread_cleanup(process); return 1; #else pthread_cleanup_pop(1); return NULL; #endif } static cl_object alloc_process(cl_object name, cl_object initial_bindings) { cl_object process = ecl_alloc_object(t_process), array; process->process.phase = ECL_PROCESS_INACTIVE; process->process.name = name; process->process.function = ECL_NIL; process->process.args = ECL_NIL; process->process.interrupt = ECL_NIL; process->process.exit_values = ECL_NIL; process->process.env = NULL; if (initial_bindings != OBJNULL) { array = si_make_vector(ECL_T, ecl_make_fixnum(256), ECL_NIL, ECL_NIL, ECL_NIL, ECL_NIL); si_fill_array_with_elt(array, ECL_NO_TL_BINDING, ecl_make_fixnum(0), ECL_NIL); } else { array = cl_copy_seq(ecl_process_env()->bindings_array); } process->process.initial_bindings = array; process->process.woken_up = ECL_NIL; process->process.start_spinlock = ECL_NIL; process->process.queue_record = ecl_list1(process); /* Creates the exit barrier so that processes can wait for termination, * but it is created in a disabled state. */ process->process.exit_barrier = ecl_make_barrier(name, MOST_POSITIVE_FIXNUM); mp_barrier_unblock(3, process->process.exit_barrier, @':disable', ECL_T); return process; } bool ecl_import_current_thread(cl_object name, cl_object bindings) { struct cl_env_struct env_aux[1]; cl_object process; pthread_t current; cl_env_ptr env; int registered; struct GC_stack_base stack; #ifdef ECL_WINDOWS_THREADS { HANDLE aux = GetCurrentThread(); DuplicateHandle(GetCurrentProcess(), aux, GetCurrentProcess(), ¤t, 0, FALSE, DUPLICATE_SAME_ACCESS); CloseHandle(current); } #else current = pthread_self(); #endif #ifdef GBC_BOEHM GC_get_stack_base(&stack); switch (GC_register_my_thread(&stack)) { case GC_SUCCESS: registered = 1; break; case GC_DUPLICATE: /* Thread was probably created using the GC hooks * for thread creation */ registered = 0; break; default: return 0; } #endif { cl_object processes = cl_core.processes; cl_index i, size; for (i = 0, size = processes->vector.dim; i < size; i++) { cl_object p = processes->vector.self.t[i]; if (!Null(p) && p->process.thread == current) return 0; } } /* We need a fake env to allow for interrupts blocking. */ env_aux->disable_interrupts = 1; ecl_set_process_env(env_aux); env = _ecl_alloc_env(0); ecl_set_process_env(env); env->cleanup = registered; /* Link environment and process together */ env->own_process = process = alloc_process(name, bindings); process->process.env = env; process->process.phase = ECL_PROCESS_BOOTING; process->process.thread = current; ecl_list_process(process); ecl_init_env(env); env->bindings_array = process->process.initial_bindings; env->thread_local_bindings_size = env->bindings_array->vector.dim; env->thread_local_bindings = env->bindings_array->vector.self.t; ecl_enable_interrupts_env(env); /* Activate the barrier so that processes can immediately start waiting. */ mp_barrier_unblock(1, process->process.exit_barrier); process->process.phase = ECL_PROCESS_ACTIVE; ecl_bds_bind(env, @'mp::*current-process*', process); return 1; } void ecl_release_current_thread(void) { cl_env_ptr env = ecl_process_env(); int cleanup = env->cleanup; thread_cleanup(env->own_process); #ifdef GBC_BOEHM if (cleanup) { GC_unregister_my_thread(); } #endif } @(defun mp::make-process (&key name ((:initial-bindings initial_bindings) ECL_T)) cl_object process; @ process = alloc_process(name, initial_bindings); @(return process) @) cl_object mp_process_preset(cl_narg narg, cl_object process, cl_object function, ...) { ecl_va_list args; ecl_va_start(args, function, narg, 2); if (narg < 2) FEwrong_num_arguments(@[mp::process-preset]); assert_type_process(process); process->process.function = function; process->process.args = cl_grab_rest_args(args); @(return process) } cl_object mp_interrupt_process(cl_object process, cl_object function) { unlikely_if (mp_process_active_p(process) == ECL_NIL) FEerror("Cannot interrupt the inactive process ~A", 1, process); ecl_interrupt_process(process, function); @(return ECL_T) } cl_object mp_suspend_loop() { cl_env_ptr env = ecl_process_env(); ECL_CATCH_BEGIN(env,@'mp::suspend-loop') { for ( ; ; ) { cl_sleep(ecl_make_fixnum(100)); } } ECL_CATCH_END; ecl_return0(env); } cl_object mp_break_suspend_loop() { cl_env_ptr the_env = ecl_process_env(); if (frs_sch(@'mp::suspend-loop')) { cl_throw(@'mp::suspend-loop'); } ecl_return0(the_env); } cl_object mp_process_suspend(cl_object process) { return mp_interrupt_process(process, @'mp::suspend-loop'); } cl_object mp_process_resume(cl_object process) { return mp_interrupt_process(process, @'mp::break-suspend-loop'); } cl_object mp_process_kill(cl_object process) { return mp_interrupt_process(process, @'mp::exit-process'); } cl_object mp_process_yield(void) { ecl_process_yield(); @(return) } cl_object mp_process_enable(cl_object process) { cl_env_ptr process_env; int ok; /* Try to gain exclusive access to the process at the same * time we ensure that it is inactive. This prevents two * concurrent calls to process-enable from different threads * on the same process */ unlikely_if (!AO_compare_and_swap_full((AO_t*)&process->process.phase, ECL_PROCESS_INACTIVE, ECL_PROCESS_BOOTING)) { FEerror("Cannot enable the running process ~A.", 1, process); } process->process.parent = mp_current_process(); process->process.trap_fpe_bits = process->process.parent->process.env->trap_fpe_bits; ecl_list_process(process); /* Link environment and process together */ process_env = _ecl_alloc_env(ecl_process_env()); process_env->own_process = process; process->process.env = process_env; ecl_init_env(process_env); process_env->trap_fpe_bits = process->process.trap_fpe_bits; process_env->bindings_array = process->process.initial_bindings; process_env->thread_local_bindings_size = process_env->bindings_array->vector.dim; process_env->thread_local_bindings = process_env->bindings_array->vector.self.t; /* Activate the barrier so that processes can immediately start waiting. */ mp_barrier_unblock(1, process->process.exit_barrier); /* Block the thread with this spinlock until it is ready */ process->process.start_spinlock = ECL_T; #ifdef ECL_WINDOWS_THREADS { HANDLE code; DWORD threadId; code = (HANDLE)CreateThread(NULL, 0, thread_entry_point, process, 0, &threadId); ok = (process->process.thread = code) != NULL; } #else { int code; pthread_attr_t pthreadattr; pthread_attr_init(&pthreadattr); pthread_attr_setdetachstate(&pthreadattr, PTHREAD_CREATE_DETACHED); /* * We launch the thread with the signal mask specified in cl_core. * The reason is that we might need to block certain signals * to be processed by the signal handling thread in unixint.d */ #ifdef HAVE_SIGPROCMASK { sigset_t new, previous; sigfillset(&new); pthread_sigmask(SIG_BLOCK, &new, &previous); code = pthread_create(&process->process.thread, &pthreadattr, thread_entry_point, process); pthread_sigmask(SIG_SETMASK, &previous, NULL); } #else code = pthread_create(&process->process.thread, &pthreadattr, thread_entry_point, process); #endif ok = (code == 0); } #endif if (!ok) { ecl_unlist_process(process); /* Disable the barrier and alert possible waiting processes. */ mp_barrier_unblock(3, process->process.exit_barrier, @':disable', ECL_T); process->process.phase = ECL_PROCESS_INACTIVE; process->process.env = NULL; _ecl_dealloc_env(process_env); } /* Unleash the thread */ process->process.start_spinlock = ECL_NIL; @(return (ok? process : ECL_NIL)) } cl_object mp_exit_process(void) { /* We simply undo the whole of the frame stack. This brings up back to the thread entry point, going through all possible UNWIND-PROTECT. */ const cl_env_ptr the_env = ecl_process_env(); ecl_unwind(the_env, the_env->frs_org); /* Never reached */ } cl_object mp_all_processes(void) { /* No race condition here because this list is never destructively * modified. When we add or remove processes, we create new lists. */ @(return ecl_process_list()) } cl_object mp_process_name(cl_object process) { assert_type_process(process); @(return process->process.name) } cl_object mp_process_active_p(cl_object process) { assert_type_process(process); @(return (process->process.phase? ECL_T : ECL_NIL)) } cl_object mp_process_whostate(cl_object process) { assert_type_process(process); @(return (cl_core.null_string)) } cl_object mp_process_join(cl_object process) { assert_type_process(process); if (process->process.phase) { /* We try to acquire a lock that is only owned by the process * while it is active. */ mp_barrier_wait(1, process->process.exit_barrier); } return cl_values_list(process->process.exit_values); } cl_object mp_process_run_function(cl_narg narg, cl_object name, cl_object function, ...) { cl_object process; ecl_va_list args; ecl_va_start(args, function, narg, 2); if (narg < 2) FEwrong_num_arguments(@[mp::process-run-function]); if (CONSP(name)) { process = cl_apply(2, @'mp::make-process', name); } else { process = mp_make_process(2, @':name', name); } cl_apply(4, @'mp::process-preset', process, function, cl_grab_rest_args(args)); return mp_process_enable(process); } cl_object mp_process_run_function_wait(cl_narg narg, ...) { cl_object process; ecl_va_list args; ecl_va_start(args, narg, narg, 0); process = cl_apply(2, @'mp::process-run-function', cl_grab_rest_args(args)); if (!Null(process)) { ecl_def_ct_single_float(wait, 0.001, static, const); while (process->process.phase < ECL_PROCESS_ACTIVE) { cl_sleep(wait); } } @(return process) } /*---------------------------------------------------------------------- * INTERRUPTS */ #ifndef ECL_WINDOWS_THREADS static cl_object mp_get_sigmask(void) { cl_object data = ecl_alloc_simple_vector(sizeof(sigset_t), ecl_aet_b8); sigset_t *mask_ptr = (sigset_t*)data->vector.self.b8; sigset_t no_signals; sigemptyset(&no_signals); if (pthread_sigmask(SIG_BLOCK, &no_signals, mask_ptr)) FElibc_error("MP:GET-SIGMASK failed in a call to pthread_sigmask", 0); @(return data) } static cl_object mp_set_sigmask(cl_object data) { sigset_t *mask_ptr = (sigset_t*)data->vector.self.b8; if (pthread_sigmask(SIG_SETMASK, mask_ptr, NULL)) FElibc_error("MP:SET-SIGMASK failed in a call to pthread_sigmask", 0); @(return data) } #endif cl_object mp_block_signals(void) { #ifdef ECL_WINDOWS_THREADS cl_env_ptr the_env = ecl_process_env(); cl_object previous = ecl_symbol_value(@'ext::*interrupts-enabled*'); ECL_SETQ(the_env, @'ext::*interrupts-enabled*', ECL_NIL); @(return previous) #else cl_object previous = mp_get_sigmask(); sigset_t all_signals; sigfillset(&all_signals); if (pthread_sigmask(SIG_SETMASK, &all_signals, NULL)) FElibc_error("MP:BLOCK-SIGNALS failed in a call to pthread_sigmask",0); @(return previous) #endif } cl_object mp_restore_signals(cl_object sigmask) { #ifdef ECL_WINDOWS_THREADS cl_env_ptr the_env = ecl_process_env(); ECL_SETQ(the_env, @'ext::*interrupts-enabled*', sigmask); ecl_check_pending_interrupts(the_env); @(return sigmask) #else return mp_set_sigmask(sigmask); #endif } /*---------------------------------------------------------------------- * INITIALIZATION */ void init_threads(cl_env_ptr env) { cl_object process; pthread_t main_thread; cl_core.processes = OBJNULL; /* We have to set the environment before any allocation takes place, * so that the interrupt handling code works. */ #if !defined(WITH___THREAD) # if defined(ECL_WINDOWS_THREADS) cl_env_key = TlsAlloc(); # else pthread_key_create(&cl_env_key, NULL); # endif #endif ecl_set_process_env(env); #ifdef ECL_WINDOWS_THREADS { HANDLE aux = GetCurrentThread(); DuplicateHandle(GetCurrentProcess(), aux, GetCurrentProcess(), &main_thread, 0, FALSE, DUPLICATE_SAME_ACCESS); } #else main_thread = pthread_self(); #endif process = ecl_alloc_object(t_process); process->process.phase = ECL_PROCESS_ACTIVE; process->process.name = @'si::top-level'; process->process.function = ECL_NIL; process->process.args = ECL_NIL; process->process.thread = main_thread; process->process.env = env; process->process.woken_up = ECL_NIL; process->process.queue_record = ecl_list1(process); process->process.start_spinlock = ECL_NIL; process->process.exit_barrier = ecl_make_barrier(process->process.name, MOST_POSITIVE_FIXNUM); env->own_process = process; { cl_object v = si_make_vector(ECL_T, /* Element type */ ecl_make_fixnum(256), /* Size */ ecl_make_fixnum(0), /* fill pointer */ ECL_NIL, ECL_NIL, ECL_NIL); v->vector.self.t[0] = process; v->vector.fillp = 1; cl_core.processes = v; cl_core.global_lock = ecl_make_lock(@'mp::global-lock', 1); cl_core.error_lock = ecl_make_lock(@'mp::error-lock', 1); cl_core.global_env_lock = ecl_make_rwlock(@'ext::package-lock'); } } ecl-16.1.2/src/c/threads/queue.d000077500000000000000000000361161266352375300163260ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* queue.d -- waiting queue for threads. */ /* Copyright (c) 2011, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #ifdef HAVE_SCHED_H #include #endif #include #include #include #include "threads/ecl_atomics.h" void ECL_INLINE ecl_process_yield() { #if defined(ECL_WINDOWS_THREADS) Sleep(0); #elif defined(HAVE_SCHED_H) sched_yield(); #else ecl_musleep(0.0, 1);*/ #endif } void ECL_INLINE ecl_get_spinlock(cl_env_ptr the_env, cl_object *lock) { cl_object own_process = the_env->own_process; while (!AO_compare_and_swap_full((AO_t*)lock, (AO_t)ECL_NIL, (AO_t)own_process)) { ecl_process_yield(); } } void ECL_INLINE ecl_giveup_spinlock(cl_object *lock) { AO_store((AO_t*)lock, (AO_t)ECL_NIL); } static ECL_INLINE void wait_queue_nconc(cl_env_ptr the_env, cl_object q, cl_object new_tail) { ecl_get_spinlock(the_env, &q->queue.spinlock); q->queue.list = ecl_nconc(q->queue.list, new_tail); ecl_giveup_spinlock(&q->queue.spinlock); } static ECL_INLINE cl_object wait_queue_pop_all(cl_env_ptr the_env, cl_object q) { cl_object output; ecl_disable_interrupts_env(the_env); { ecl_get_spinlock(the_env, &q->queue.spinlock); output = q->queue.list; q->queue.list = ECL_NIL; ecl_giveup_spinlock(&q->queue.spinlock); } ecl_enable_interrupts_env(the_env); return output; } static ECL_INLINE void wait_queue_delete(cl_env_ptr the_env, cl_object q, cl_object item) { ecl_get_spinlock(the_env, &q->queue.spinlock); q->queue.list = ecl_delete_eq(item, q->queue.list); ecl_giveup_spinlock(&q->queue.spinlock); } /*---------------------------------------------------------------------- * THREAD SCHEDULER & WAITING */ static cl_object bignum_set_time(cl_object bignum, struct ecl_timeval *time) { _ecl_big_set_index(bignum, time->tv_sec); _ecl_big_mul_ui(bignum, bignum, 1000); _ecl_big_add_ui(bignum, bignum, (time->tv_usec + 999) / 1000); return bignum; } static cl_object elapsed_time(struct ecl_timeval *start) { cl_object delta_big = _ecl_big_register0(); cl_object aux_big = _ecl_big_register1(); struct ecl_timeval now; ecl_get_internal_real_time(&now); bignum_set_time(aux_big, start); bignum_set_time(delta_big, &now); _ecl_big_sub(delta_big, delta_big, aux_big); _ecl_big_register_free(aux_big); return delta_big; } static double waiting_time(cl_index iteration, struct ecl_timeval *start) { /* Waiting time is smaller than 0.10 s */ double time; cl_object top = ecl_make_fixnum(10 * 1000); cl_object delta_big = elapsed_time(start); _ecl_big_div_ui(delta_big, delta_big, iteration); if (ecl_number_compare(delta_big, top) < 0) { time = ecl_to_double(delta_big) * 1.5; } else { time = 0.10; } _ecl_big_register_free(delta_big); return time; } static cl_object ecl_wait_on_timed(cl_env_ptr env, cl_object (*condition)(cl_env_ptr, cl_object), cl_object o) { volatile const cl_env_ptr the_env = env; volatile cl_object own_process = the_env->own_process; volatile cl_object record; volatile cl_object output; cl_fixnum iteration = 0; struct ecl_timeval start; ecl_get_internal_real_time(&start); /* This spinlock is here because the default path (fair) is * too slow */ for (iteration = 0; iteration < 10; iteration++) { cl_object output = condition(the_env,o); if (output != ECL_NIL) return output; } /* 0) We reserve a record for the queue. In order to avoid * using the garbage collector, we reuse records */ record = own_process->process.queue_record; unlikely_if (record == ECL_NIL) { record = ecl_list1(own_process); } else { own_process->process.queue_record = ECL_NIL; } ecl_bds_bind(the_env, @'ext::*interrupts-enabled*', ECL_NIL); ECL_UNWIND_PROTECT_BEGIN(the_env) { /* 2) Now we add ourselves to the queue. In order to * avoid a call to the GC, we try to reuse records. */ print_lock("adding to queue", o); own_process->process.woken_up = ECL_NIL; wait_queue_nconc(the_env, o, record); ecl_bds_bind(the_env, @'ext::*interrupts-enabled*', ECL_T); ecl_check_pending_interrupts(the_env); /* 3) Unlike the sigsuspend() implementation, this * implementation does not block signals and the * wakeup event might be lost before the sleep * function is invoked. We must thus spin over short * intervals of time to ensure that we check the * condition periodically. */ while (Null(output = condition(the_env, o))) { ecl_musleep(waiting_time(iteration++, &start), 1); } ecl_bds_unwind1(the_env); } ECL_UNWIND_PROTECT_EXIT { /* 4) At this point we wrap up. We remove ourselves * from the queue and unblock the lisp interrupt * signal. Note that we recover the cons for later use.*/ wait_queue_delete(the_env, o, own_process); own_process->process.queue_record = record; ECL_RPLACD(record, ECL_NIL); /* 5) When this process exits, it may be because it * aborts (which we know because output == ECL_NIL), or * because the condition is satisfied. In both cases * we allow the first in the queue to test again its * condition. This is needed for objects, such as * semaphores, where the condition may be satisfied * more than once. */ if (Null(output)) { ecl_wakeup_waiters(the_env, o, ECL_WAKEUP_ONE); } } ECL_UNWIND_PROTECT_END; ecl_bds_unwind1(the_env); return output; } /********************************************************************** * BLOCKING WAIT QUEUE ALGORITHM * * This object keeps a list of processes waiting for a condition to * happen. The queue is ordered and the only processes that check for * the condition are * - The first process to arrive to the queue, * - Each process which is awoken. * - The first process after the list of awoken processes. * * The idea is that this will ensure some fairness when unblocking the * processes, which is important for abstractions such as mutexes or * semaphores, where we want equal sharing of resources among processes. * * This also implies that the waiting processes depend on others to signal * when to check for a condition. This happens in two situations * - External code that changes the fields of the queue object * must signal ecl_wakeup_waiters() (See mutex.d, semaphore.d, etc) * - When a process exits ecl_wait_on() it always resignals the next * process in the queue, because a condition may be satisfied more * than once (for instance when a semaphore is changed, more than * one process may be released) * * The critical part of this algorithm is the fact that processes * communicating the change of conditions may do so before, during or * after a process has been registered. Since we do not want those signals * to be lost, a proper ordering of steps is required. */ cl_object ecl_wait_on(cl_env_ptr env, cl_object (*condition)(cl_env_ptr, cl_object), cl_object o) { #if defined(HAVE_SIGPROCMASK) volatile const cl_env_ptr the_env = env; volatile cl_object own_process = the_env->own_process; volatile cl_object record; volatile sigset_t original; volatile cl_object output; /* 0) We reserve a record for the queue. In order to avoid * using the garbage collector, we reuse records */ record = own_process->process.queue_record; unlikely_if (record == ECL_NIL) { record = ecl_list1(own_process); } else { own_process->process.queue_record = ECL_NIL; } /* 1) First we block lisp interrupt signals. This ensures that * any awake signal that is issued from here is not lost. */ { int code = ecl_option_values[ECL_OPT_THREAD_INTERRUPT_SIGNAL]; sigset_t empty; sigemptyset(&empty); sigaddset(&empty, code); pthread_sigmask(SIG_BLOCK, &empty, &original); } /* 2) Now we add ourselves to the queue. */ own_process->process.woken_up = ECL_NIL; wait_queue_nconc(the_env, o, record); ECL_UNWIND_PROTECT_BEGIN(the_env) { /* 3) At this point we may receive signals, but we * might have missed a wakeup event if that happened * between 0) and 2), which is why we start with the * check*/ while (Null(output = condition(the_env, o))) { /* This will wait until we get a signal that * demands some code being executed. Note that * this includes our communication signals and * the signals used by the GC. Note also that * as a consequence we might throw / return * which is why need to protect it all with * UNWIND-PROTECT. */ sigsuspend(&original); } } ECL_UNWIND_PROTECT_EXIT { /* 4) At this point we wrap up. We remove ourselves * from the queue and unblock the lisp interrupt * signal. Note that we recover the cons for later use.*/ wait_queue_delete(the_env, o, own_process); own_process->process.queue_record = record; ECL_RPLACD(record, ECL_NIL); /* 5) When this process exits, it may be because it * aborts (which we know because output == ECL_NIL), or * because the condition is satisfied. In both cases * we allow the first in the queue to test again its * condition. This is needed for objects, such as * semaphores, where the condition may be satisfied * more than once. */ if (Null(output)) { ecl_wakeup_waiters(the_env, o, ECL_WAKEUP_ONE); } /* 6) Restoring signals is done last, to ensure that * all cleanup steps are performed. */ pthread_sigmask(SIG_SETMASK, &original, NULL); } ECL_UNWIND_PROTECT_END; return output; #else return ecl_wait_on_timed(env, condition, o); #endif } cl_object ecl_waiter_pop(cl_env_ptr the_env, cl_object q) { cl_object output; ecl_disable_interrupts_env(the_env); ecl_get_spinlock(the_env, &q->queue.spinlock); { cl_object l; output = ECL_NIL; for (l = q->queue.list; l != ECL_NIL; l = ECL_CONS_CDR(l)) { cl_object p = ECL_CONS_CAR(l); if (p->process.phase != ECL_PROCESS_INACTIVE && p->process.phase != ECL_PROCESS_EXITING) { output = p; break; } } } ecl_giveup_spinlock(&q->queue.spinlock); ecl_enable_interrupts_env(the_env); return output; } void ecl_wakeup_waiters(cl_env_ptr the_env, cl_object q, int flags) { ecl_disable_interrupts_env(the_env); ecl_get_spinlock(the_env, &q->queue.spinlock); if (q->queue.list != ECL_NIL) { /* We scan the list of waiting processes, awaking one * or more, depending on flags. In running through the list * we eliminate zombie processes --- they should not be here * because of the UNWIND-PROTECT in ecl_wait_on(), but * sometimes shit happens */ cl_object *tail, l; for (tail = &q->queue.list; (l = *tail) != ECL_NIL; ) { cl_object p = ECL_CONS_CAR(l); if (p->process.phase == ECL_PROCESS_INACTIVE || p->process.phase == ECL_PROCESS_EXITING) { print_lock("removing %p", q, p); *tail = ECL_CONS_CDR(l); } else { print_lock("awaking %p", q, p); /* If the process is active, we then * simply awake it with a signal.*/ p->process.woken_up = ECL_T; if (flags & ECL_WAKEUP_DELETE) *tail = ECL_CONS_CDR(l); tail = &ECL_CONS_CDR(l); if (flags & ECL_WAKEUP_KILL) mp_process_kill(p); else ecl_wakeup_process(p); if (!(flags & ECL_WAKEUP_ALL)) break; } } } ecl_giveup_spinlock(&q->queue.spinlock); ecl_process_yield(); } #undef print_lock void print_lock(char *prefix, cl_object l, ...) { static cl_object lock = ECL_NIL; va_list args; va_start(args, l); if (l == ECL_NIL || type_of(l) == t_condition_variable || ECL_FIXNUMP(l->lock.name)) { cl_env_ptr env = ecl_process_env(); ecl_get_spinlock(env, &lock); printf("\n%ld\t", ecl_fixnum(env->own_process->process.name)); vprintf(prefix, args); if (l != ECL_NIL) { cl_object p = l->lock.queue_list; while (p != ECL_NIL) { printf(" %lx", ecl_fixnum(ECL_CONS_CAR(p)->process.name)); p = ECL_CONS_CDR(p); } } fflush(stdout); ecl_giveup_spinlock(&lock); } } /*#define print_lock(a,b,c) (void)0*/ ecl-16.1.2/src/c/threads/rwlock.d000066400000000000000000000142421266352375300164740ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* rwlock.d -- POSIX read-write locks */ /* Copyright (c) 2003, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #ifndef __sun__ /* See unixinit.d for this */ #define _XOPEN_SOURCE 600 /* For pthread mutex attributes */ #endif #include #include #ifdef ECL_WINDOWS_THREADS # include #else # include #endif #include /*---------------------------------------------------------------------- * READ/WRITE LOCKS */ static void FEerror_not_a_rwlock(cl_object lock) { FEwrong_type_argument(@'mp::rwlock', lock); } static void FEunknown_rwlock_error(cl_object lock, int rc) { #ifdef ECL_WINDOWS_THREADS FEwin32_error("When acting on rwlock ~A, got an unexpected error.", 1, lock); #else const char *msg = NULL; switch (rc) { case EINVAL: msg = "The value specified by rwlock is invalid"; break; case EPERM: msg = "Read/write lock not owned by us"; break; case EDEADLK: msg = "Thread already owns this lock"; break; case ENOMEM: msg = "Out of memory"; break; default: FElibc_error("When acting on rwlock ~A, got an unexpected error.", 1, lock); } FEerror("When acting on rwlock ~A, got the following C library error:~%" "~A", 2, lock, make_constant_base_string(msg)); #endif } cl_object ecl_make_rwlock(cl_object name) { const cl_env_ptr the_env = ecl_process_env(); cl_object output = ecl_alloc_object(t_rwlock); #ifdef ECL_RWLOCK int rc; ecl_disable_interrupts_env(the_env); rc = pthread_rwlock_init(&output->rwlock.mutex, NULL); ecl_enable_interrupts_env(the_env); if (rc) { FEerror("Unable to create read/write lock", 0); } ecl_set_finalizer_unprotected(output, ECL_T); #else output->rwlock.mutex = ecl_make_lock(name, 0); #endif output->rwlock.name = name; return output; } @(defun mp::make-rwlock (&key name) @ @(return ecl_make_rwlock(name)) @) cl_object mp_rwlock_name(cl_object lock) { const cl_env_ptr env = ecl_process_env(); if (ecl_t_of(lock) != t_rwlock) FEerror_not_a_rwlock(lock); ecl_return1(env, lock->rwlock.name); } cl_object mp_giveup_rwlock_read(cl_object lock) { /* Must be called with interrupts disabled. */ if (ecl_t_of(lock) != t_rwlock) FEerror_not_a_rwlock(lock); #ifdef ECL_RWLOCK { int rc = pthread_rwlock_unlock(&lock->rwlock.mutex); if (rc) FEunknown_rwlock_error(lock, rc); @(return ECL_T); } #else return mp_giveup_lock(lock->rwlock.mutex); #endif } cl_object mp_giveup_rwlock_write(cl_object lock) { return mp_giveup_rwlock_read(lock); } cl_object mp_get_rwlock_read_nowait(cl_object lock) { if (ecl_t_of(lock) != t_rwlock) FEerror_not_a_rwlock(lock); #ifdef ECL_RWLOCK { const cl_env_ptr env = ecl_process_env(); cl_object output = ECL_T; int rc = pthread_rwlock_tryrdlock(&lock->rwlock.mutex); if (rc == 0) { output = ECL_T; } else if (rc == EBUSY) { output = ECL_NIL; } else { FEunknown_rwlock_error(lock, rc); } ecl_return1(env, output); } #else return mp_get_lock_nowait(lock->rwlock.mutex); #endif } cl_object mp_get_rwlock_read_wait(cl_object lock) { if (ecl_t_of(lock) != t_rwlock) FEerror_not_a_rwlock(lock); #ifdef ECL_RWLOCK { const cl_env_ptr env = ecl_process_env(); int rc = pthread_rwlock_rdlock(&lock->rwlock.mutex); if (rc != 0) { FEunknown_rwlock_error(lock, rc); } ecl_return1(env, ECL_T); } #else return mp_get_lock_wait(lock->rwlock.mutex); #endif } @(defun mp::get-rwlock-read (lock &optional (wait ECL_T)) @ if (Null(wait)) return mp_get_rwlock_read_nowait(lock); else return mp_get_rwlock_read_wait(lock); @) cl_object mp_get_rwlock_write_nowait(cl_object lock) { if (ecl_t_of(lock) != t_rwlock) FEerror_not_a_rwlock(lock); #ifdef ECL_RWLOCK { const cl_env_ptr env = ecl_process_env(); cl_object output = ECL_T; int rc = pthread_rwlock_trywrlock(&lock->rwlock.mutex); if (rc == 0) { output = ECL_T; } else if (rc == EBUSY) { output = ECL_NIL; } else { FEunknown_rwlock_error(lock, rc); } ecl_return1(env, output); } #else return mp_get_lock_nowait(lock->rwlock.mutex); #endif } cl_object mp_get_rwlock_write_wait(cl_object lock) { cl_env_ptr env = ecl_process_env(); if (ecl_t_of(lock) != t_rwlock) FEerror_not_a_rwlock(lock); #ifdef ECL_RWLOCK { int rc = pthread_rwlock_wrlock(&lock->rwlock.mutex); if (rc != 0) { FEunknown_rwlock_error(lock, rc); } @(return ECL_T) } #else return mp_get_lock_wait(lock->rwlock.mutex); #endif } @(defun mp::get-rwlock-write (lock &optional (wait ECL_T)) @ if (Null(wait)) return mp_get_rwlock_write_nowait(lock); else return mp_get_rwlock_write_wait(lock); @) ecl-16.1.2/src/c/threads/semaphore.d000066400000000000000000000102021266352375300171460ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* semaphore.d -- POSIX-like semaphores */ /* Copyright (c) 2011, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #define AO_ASSUME_WINDOWS98 /* We need this for CAS */ #include #include #if !defined(AO_HAVE_fetch_and_add_full) #error "Cannot implement semaphores without AO_fetch_and_add_full" #endif static ECL_INLINE void FEerror_not_a_semaphore(cl_object semaphore) { FEwrong_type_argument(@'mp::semaphore', semaphore); } cl_object ecl_make_semaphore(cl_object name, cl_fixnum count) { cl_object output = ecl_alloc_object(t_semaphore); output->semaphore.name = name; output->semaphore.counter = count; output->semaphore.queue_list = ECL_NIL; output->semaphore.queue_spinlock = ECL_NIL; return output; } @(defun mp::make-semaphore (&key name (count ecl_make_fixnum(0))) @ { @(return ecl_make_semaphore(name, fixnnint(count))) } @) cl_object mp_semaphore_name(cl_object semaphore) { cl_env_ptr env = ecl_process_env(); unlikely_if (ecl_t_of(semaphore) != t_semaphore) { FEerror_not_a_semaphore(semaphore); } ecl_return1(env, semaphore->semaphore.name); } cl_object mp_semaphore_count(cl_object semaphore) { cl_env_ptr env = ecl_process_env(); unlikely_if (ecl_t_of(semaphore) != t_semaphore) { FEerror_not_a_semaphore(semaphore); } ecl_return1(env, ecl_make_fixnum(semaphore->semaphore.counter)); } cl_object mp_semaphore_wait_count(cl_object semaphore) { cl_env_ptr env = ecl_process_env(); unlikely_if (ecl_t_of(semaphore) != t_semaphore) { FEerror_not_a_semaphore(semaphore); } ecl_return1(env, cl_length(semaphore->semaphore.queue_list)); } @(defun mp::signal-semaphore (semaphore &optional (count ecl_make_fixnum(1))) @ { cl_fixnum n = fixnnint(count); cl_env_ptr env = ecl_process_env(); unlikely_if (ecl_t_of(semaphore) != t_semaphore) { FEerror_not_a_semaphore(semaphore); } AO_fetch_and_add((AO_t*)&semaphore->semaphore.counter, n); if (semaphore->semaphore.queue_list != ECL_NIL) { ecl_wakeup_waiters(env, semaphore, ECL_WAKEUP_ONE); } @(return) } @) static cl_object get_semaphore_inner(cl_env_ptr env, cl_object semaphore) { cl_object output; ecl_disable_interrupts_env(env); do { cl_fixnum counter = semaphore->semaphore.counter; if (!counter) { output = ECL_NIL; break; } if (AO_compare_and_swap_full((AO_t*)&(semaphore->semaphore.counter), (AO_t)counter, (AO_t)(counter-1))) { output = ecl_make_fixnum(counter); break; } ecl_process_yield(); } while (1); ecl_enable_interrupts_env(env); return output; } cl_object mp_wait_on_semaphore(cl_object semaphore) { cl_env_ptr env = ecl_process_env(); cl_object output; unlikely_if (ecl_t_of(semaphore) != t_semaphore) { FEerror_not_a_semaphore(semaphore); } output = get_semaphore_inner(env, semaphore); if (Null(output)) { output = ecl_wait_on(env, get_semaphore_inner, semaphore); } ecl_return1(env, output); } cl_object mp_try_get_semaphore(cl_object semaphore) { cl_env_ptr env = ecl_process_env(); cl_object output; unlikely_if (ecl_t_of(semaphore) != t_semaphore) { FEerror_not_a_semaphore(semaphore); } ecl_return1(env, get_semaphore_inner(env, semaphore)); } ecl-16.1.2/src/c/time.d000066400000000000000000000162051266352375300145000ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* time.c -- Time routines. */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #include #ifndef _MSC_VER # include # include #endif #if defined(_MSC_VER) || defined(__MINGW32__) # include # include #endif #define ECL_INCLUDE_MATH_H #include #include #include #ifdef HAVE_TIMES # include #endif #ifdef HAVE_GETRUSAGE # include # include #endif #ifdef HAVE_GETTIMEOFDAY # include #endif #include static struct ecl_timeval beginning; void ecl_get_internal_real_time(struct ecl_timeval *tv) { #if defined(HAVE_GETTIMEOFDAY) && !defined(ECL_MS_WINDOWS_HOST) struct timezone tz; struct timeval aux; gettimeofday(&aux, &tz); tv->tv_usec = aux.tv_usec; tv->tv_sec = aux.tv_sec; #else # if defined(ECL_MS_WINDOWS_HOST) union { FILETIME filetime; DWORDLONG hundred_ns; } system_time; GetSystemTimeAsFileTime(&system_time.filetime); system_time.hundred_ns /= 10000; tv->tv_sec = system_time.hundred_ns / 1000; tv->tv_usec = (system_time.hundred_ns % 1000) * 1000; # else time_t = time(0); tv->tv_sec = time_t; tv->tv_usec = 0; # endif #endif } void ecl_get_internal_run_time(struct ecl_timeval *tv) { #ifdef HAVE_GETRUSAGE struct rusage r; getrusage(RUSAGE_SELF, &r); tv->tv_usec = r.ru_utime.tv_usec; tv->tv_sec = r.ru_utime.tv_sec; #else # ifdef HAVE_TIMES struct tms buf; times(&buf); tv->tv_sec = buf.tms_utime / CLK_TCK; tv->tv_usec = (buf.tms_utime % CLK_TCK) * 1000000; # else # if defined(ECL_MS_WINDOWS_HOST) union { FILETIME filetime; DWORDLONG hundred_ns; } kernel_time, user_time, creation_time, exit_time; if (!GetProcessTimes(GetCurrentProcess(), &creation_time.filetime, &exit_time.filetime, &kernel_time.filetime, &user_time.filetime)) FEwin32_error("GetProcessTimes() failed", 0); kernel_time.hundred_ns += user_time.hundred_ns; kernel_time.hundred_ns /= 10000; tv->tv_sec = kernel_time.hundred_ns / 1000; tv->tv_usec = (kernel_time.hundred_ns % 1000) * 1000; # else ecl_get_internal_real_time(tv); # endif # endif #endif } void ecl_musleep(double time, bool alertable) { #ifdef HAVE_NANOSLEEP struct timespec tm; int code; tm.tv_sec = (time_t)floor(time); tm.tv_nsec = (long)((time - floor(time)) * 1e9); AGAIN: code = nanosleep(&tm, &tm); { int old_errno = errno; if (code < 0 && old_errno == EINTR && !alertable) { goto AGAIN; } } #else #if defined (ECL_MS_WINDOWS_HOST) /* Maximum waiting time that fits in SleepEx. This is the * largest integer that fits safely in DWORD in milliseconds * and has to be converted to 100ns (1e-3 / 100e-9 = 1e4) */ const DWORDLONG maxtime = (DWORDLONG)0xfffffff * (DWORDLONG)10000; DWORDLONG wait = time * 1e7; union { FILETIME filetime; DWORDLONG hundred_ns; } end, now; if (alertable) { GetSystemTimeAsFileTime(&end.filetime); end.hundred_ns += wait; } do { DWORDLONG interval; if (wait > maxtime) { interval = maxtime; wait -= maxtime; } else { interval = wait; wait = 0; } if (SleepEx(interval/10000, alertable) != 0) { if (alertable) { break; } else { GetSystemTimeAsFileTime(&now.filetime); if (now.hundred_ns >= end.hundred_ns) break; else wait = end.hundred_ns - now.hundred_ns; } } } while (wait); #else int t = (int)time; for (t = (time + 0.5); t > 1000; t -= 1000) sleep(1000); sleep(t); #endif #endif } cl_fixnum ecl_runtime(void) { struct ecl_timeval tv; ecl_get_internal_run_time(&tv); return tv.tv_sec * 1000 + tv.tv_usec / 1000; } cl_object cl_sleep(cl_object z) { double time; /* INV: ecl_minusp() makes sure `z' is real */ if (ecl_minusp(z)) cl_error(9, @'simple-type-error', @':format-control', make_constant_base_string("Not a non-negative number ~S"), @':format-arguments', cl_list(1, z), @':expected-type', @'real', @':datum', z); /* Compute time without overflows */ ECL_WITHOUT_FPE_BEGIN { time = ecl_to_double(z); if (isnan(time) || !isfinite(time) || (time > INT_MAX)) { time = INT_MAX; } else if (time < 1e-9) { time = 1e-9; } } ECL_WITHOUT_FPE_END; ecl_musleep(time, 0); @(return ECL_NIL) } static cl_object timeval_to_time(long sec, long usec) { cl_object milliseconds = ecl_plus(ecl_times(ecl_make_integer(sec), ecl_make_fixnum(1000)), ecl_make_integer(usec / 1000)); @(return milliseconds); } cl_object cl_get_internal_run_time() { struct ecl_timeval tv; ecl_get_internal_run_time(&tv); return timeval_to_time(tv.tv_sec, tv.tv_usec); } cl_object cl_get_internal_real_time() { struct ecl_timeval tv; ecl_get_internal_real_time(&tv); return timeval_to_time(tv.tv_sec - beginning.tv_sec, tv.tv_usec - beginning.tv_usec); } cl_object cl_get_universal_time() { cl_object utc = ecl_make_integer(time(0)); @(return ecl_plus(utc, cl_core.Jan1st1970UT)) } void init_unixtime(void) { ecl_get_internal_real_time(&beginning); ECL_SET(@'internal-time-units-per-second', ecl_make_fixnum(1000)); cl_core.Jan1st1970UT = ecl_times(ecl_make_fixnum(24 * 60 * 60), ecl_make_fixnum(17 + 365 * 70)); } ecl-16.1.2/src/c/typespec.d000066400000000000000000000262011266352375300153730ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* typespec.c -- Type specifier routines. */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include void FEtype_error_fixnum(cl_object x) { FEwrong_type_argument(@[fixnum], x); } void FEtype_error_size(cl_object x) { FEwrong_type_argument(cl_list(3, @'integer', ecl_make_fixnum(0), ecl_make_fixnum(MOST_POSITIVE_FIXNUM)), x); } void FEtype_error_cons(cl_object x) { FEwrong_type_argument(@[cons], x); } void FEtype_error_list(cl_object x) { FEwrong_type_argument(@[list], x); } void FEtype_error_proper_list(cl_object x) { cl_error(9, @'simple-type-error', @':format-control', make_constant_base_string("Not a proper list ~D"), @':format-arguments', cl_list(1, x), @':expected-type', ecl_read_from_cstring("si::proper-list"), @':datum', x); } void FEcircular_list(cl_object x) { /* FIXME: Is this the right way to rebind it? */ ecl_bds_bind(ecl_process_env(), @'*print-circle*', ECL_T); cl_error(9, @'simple-type-error', @':format-control', make_constant_base_string("Circular list ~D"), @':format-arguments', cl_list(1, x), @':expected-type', @'list', @':datum', x); } void FEtype_error_index(cl_object seq, cl_fixnum ndx) { cl_object n = ecl_make_fixnum(ndx); cl_index l = ECL_INSTANCEP(seq)? seq->instance.length : ecl_length(seq); cl_error(9, @'simple-type-error', @':format-control', make_constant_base_string("~S is not a valid index into the object ~S"), @':format-arguments', cl_list(2, n, seq), @':expected-type', cl_list(3, @'integer', ecl_make_fixnum(0), ecl_make_fixnum(l-1)), @':datum', n); } void FEtype_error_array(cl_object v) { FEwrong_type_argument(@[array], v); } void FEtype_error_vector(cl_object v) { FEwrong_type_argument(@[vector], v); } void FEtype_error_sequence(cl_object x) { FEwrong_type_argument(@[sequence], x); } cl_object ecl_type_error(cl_object function, const char *place, cl_object o, cl_object type) { si_wrong_type_argument(4, o, type, (*place? make_constant_base_string(place) : ECL_NIL), function); } /**********************************************************************/ static cl_object ecl_type_to_symbol(cl_type t) { switch(t) { case t_character: return @'character'; case t_fixnum: return @'fixnum'; case t_bignum: return @'bignum'; case t_ratio: return @'ratio'; case t_singlefloat: return @'single-float'; case t_doublefloat: return @'double-float'; #ifdef ECL_LONG_FLOAT case t_longfloat: return @'long-float'; #endif case t_complex: return @'complex'; case t_symbol: return @'symbol'; case t_package: return @'package'; case t_list: return @'list'; case t_hashtable: return @'hash-table'; case t_array: return @'array'; case t_vector: return @'vector'; case t_bitvector: return @'bit-vector'; #ifdef ECL_UNICODE case t_string: return @'string'; #endif case t_base_string: return @'base-string'; case t_stream: return @'stream'; case t_readtable: return @'readtable'; case t_pathname: return @'pathname'; case t_random: return @'random-state'; case t_bytecodes: case t_bclosure: case t_cfun: case t_cfunfixed: case t_cclosure: return @'compiled-function'; #ifdef ECL_THREADS case t_process: return @'mp::process'; case t_lock: return @'mp::lock'; case t_condition_variable: return @'mp::condition-variable'; case t_semaphore: return @'mp::semaphore'; case t_barrier: return @'mp::barrier'; case t_mailbox: return @'mp::mailbox'; #endif case t_codeblock: return @'si::code-block'; case t_foreign: return @'si::foreign-data'; case t_frame: return @'si::frame'; case t_weak_pointer: return @'ext::weak-pointer'; #ifdef ECL_SSE2 case t_sse_pack: return @'ext::sse-pack'; #endif default: ecl_internal_error("not a lisp data object"); } } cl_object ecl_check_cl_type(cl_object fun, cl_object p, cl_type t) { while (ecl_t_of(p) != t) { p = ecl_type_error(fun, "argument", p, ecl_type_to_symbol(t)); } return p; } void assert_type_integer(cl_object p) { cl_type t = ecl_t_of(p); if (t != t_fixnum && t != t_bignum) FEwrong_type_nth_arg(@[coerce], 1, p, @[integer]); } void assert_type_non_negative_integer(cl_object p) { cl_type t = ecl_t_of(p); if (t == t_fixnum) { if (ecl_fixnum_plusp(p)) return; } else if (t == t_bignum) { if (_ecl_big_sign(p) >= 0) return; } FEwrong_type_argument(cl_list(3,@'integer',ecl_make_fixnum(0),@'*'), p); } void assert_type_proper_list(cl_object p) { if (ECL_ATOM(p) && p != ECL_NIL) FEtype_error_list(p); if (cl_list_length(p) == ECL_NIL) FEcircular_list(p); } cl_object cl_type_of(cl_object x) { cl_object t; cl_type tx = ecl_t_of(x); switch (tx) { case t_instance: { cl_object cl = ECL_CLASS_OF(x); t = ECL_CLASS_NAME(cl); if (t == ECL_NIL || cl != cl_find_class(2, t, ECL_NIL)) t = cl; break; } case t_fixnum: case t_bignum: t = cl_list(3, @'integer', x, x); break; case t_character: { int i = ECL_CHAR_CODE(x); if (ecl_standard_char_p(i)) { t = @'standard-char'; } else if (ecl_base_char_p(i)) { t = @'base-char'; } else { t = @'character'; } break; } case t_symbol: if (x == ECL_T) t = @'boolean'; else if (x->symbol.hpack == cl_core.keyword_package) t = @'keyword'; else t = @'symbol'; break; case t_array: if (ECL_ADJUSTABLE_ARRAY_P(x) || !Null(CAR(x->array.displaced))) t = @'array'; else t = @'simple-array'; t = cl_list(3, t, ecl_elttype_to_symbol(ecl_array_elttype(x)), cl_array_dimensions(x)); break; case t_vector: if (ECL_ADJUSTABLE_ARRAY_P(x) || !Null(CAR(x->vector.displaced))) { t = cl_list(3, @'vector', ecl_elttype_to_symbol(ecl_array_elttype(x)), ecl_make_fixnum(x->vector.dim)); } else if (ECL_ARRAY_HAS_FILL_POINTER_P(x) || (cl_elttype)x->vector.elttype != ecl_aet_object) { t = cl_list(3, @'simple-array', ecl_elttype_to_symbol(ecl_array_elttype(x)), cl_array_dimensions(x)); } else { t = cl_list(2, @'simple-vector', ecl_make_fixnum(x->vector.dim)); } break; #ifdef ECL_UNICODE case t_string: if (ECL_ADJUSTABLE_ARRAY_P(x) || ECL_ARRAY_HAS_FILL_POINTER_P(x) || !Null(CAR(x->string.displaced))) t = @'array'; else t = @'simple-array'; t = cl_list(3, t, @'character', cl_list(1, ecl_make_fixnum(x->string.dim))); break; #endif case t_base_string: if (ECL_ADJUSTABLE_ARRAY_P(x) || ECL_ARRAY_HAS_FILL_POINTER_P(x) || !Null(CAR(x->base_string.displaced))) t = @'array'; else t = @'simple-array'; t = cl_list(3, t, @'base-char', cl_list(1, ecl_make_fixnum(x->base_string.dim))); break; case t_bitvector: if (ECL_ADJUSTABLE_ARRAY_P(x) || ECL_ARRAY_HAS_FILL_POINTER_P(x) || !Null(CAR(x->vector.displaced))) t = @'array'; else t = @'simple-array'; t = cl_list(3, t, @'bit', cl_list(1, ecl_make_fixnum(x->vector.dim))); break; case t_stream: switch (x->stream.mode) { case ecl_smm_synonym: t = @'synonym-stream'; break; case ecl_smm_broadcast: t = @'broadcast-stream'; break; case ecl_smm_concatenated: t = @'concatenated-stream'; break; case ecl_smm_two_way: t = @'two-way-stream'; break; case ecl_smm_string_input: case ecl_smm_string_output: t = @'string-stream'; break; case ecl_smm_echo: t = @'echo-stream'; break; case ecl_smm_sequence_input: case ecl_smm_sequence_output: t = @'ext::sequence-stream'; break; default: t = @'file-stream'; break; } break; case t_pathname: t = x->pathname.logical? @'logical-pathname' : @'pathname'; break; case t_list: t = Null(x) ? @'null' : @'cons'; break; #ifdef ECL_SSE2 case t_sse_pack: t = @'ext::sse-pack'; break; #endif default: t = ecl_type_to_symbol(tx); } @(return t) } cl_object ecl_make_integer_type(cl_object min, cl_object max) { return cl_list(3, @'integer', min, max); } ecl-16.1.2/src/c/unicode/000077500000000000000000000000001266352375300150175ustar00rootroot00000000000000ecl-16.1.2/src/c/unicode/ucd-0000.c000066400000000000000000001251401266352375300163160ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ const unsigned char ecl_ucd_page_table_0[] = { 216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 }; const unsigned char ecl_ucd_page_table_1[] = { 14,0,0,0 ,14,0,0,0 ,14,0,0,0 ,14,0,0,0 ,14,0,0,0 ,14,0,0,0 ,14,0,0,0 ,14,0,0,0 ,14,0,0,0 ,15,0,0,0 ,13,0,0,0 ,15,0,0,0 ,16,0,0,0 ,13,0,0,0 ,14,0,0,0 ,14,0,0,0 ,14,0,0,0 ,14,0,0,0 ,14,0,0,0 ,14,0,0,0 ,14,0,0,0 ,14,0,0,0 ,14,0,0,0 ,14,0,0,0 ,14,0,0,0 ,14,0,0,0 ,14,0,0,0 ,14,0,0,0 ,13,0,0,0 ,13,0,0,0 ,13,0,0,0 ,15,0,0,0 ,216,0,0,0 ,193,0,0,0 ,193,0,0,0 ,191,0,0,0 ,198,0,0,0 ,191,0,0,0 ,193,0,0,0 ,193,0,0,0 ,196,0,0,0 ,183,0,0,0 ,193,0,0,0 ,204,0,0,0 ,190,0,0,0 ,179,0,0,0 ,190,0,0,0 ,190,0,0,0 ,99,0,0,0 ,100,0,0,0 ,101,0,0,0 ,102,0,0,0 ,103,0,0,0 ,104,0,0,0 ,105,0,0,0 ,106,0,0,0 ,107,0,0,0 ,108,0,0,0 ,190,0,0,0 ,193,0,0,0 ,208,0,0,0 ,207,0,0,0 ,208,0,0,0 ,193,0,0,0 ,193,0,0,0 ,0,97,0,0 ,0,98,0,0 ,0,99,0,0 ,0,100,0,0 ,0,101,0,0 ,0,102,0,0 ,0,103,0,0 ,0,104,0,0 ,0,105,0,0 ,0,106,0,0 ,0,107,0,0 ,0,108,0,0 ,0,109,0,0 ,0,110,0,0 ,0,111,0,0 ,0,112,0,0 ,0,113,0,0 ,0,114,0,0 ,0,115,0,0 ,0,116,0,0 ,0,117,0,0 ,0,118,0,0 ,0,119,0,0 ,0,120,0,0 ,0,121,0,0 ,0,122,0,0 ,196,0,0,0 ,193,0,0,0 ,183,0,0,0 ,201,0,0,0 ,178,0,0,0 ,201,0,0,0 ,1,65,0,0 ,1,66,0,0 ,1,67,0,0 ,1,68,0,0 ,1,69,0,0 ,1,70,0,0 ,1,71,0,0 ,1,72,0,0 ,1,73,0,0 ,1,74,0,0 ,1,75,0,0 ,1,76,0,0 ,1,77,0,0 ,1,78,0,0 ,1,79,0,0 ,1,80,0,0 ,1,81,0,0 ,1,82,0,0 ,1,83,0,0 ,1,84,0,0 ,1,85,0,0 ,1,86,0,0 ,1,87,0,0 ,1,88,0,0 ,1,89,0,0 ,1,90,0,0 ,196,0,0,0 ,207,0,0,0 ,183,0,0,0 ,207,0,0,0 ,14,0,0,0 ,14,0,0,0 ,14,0,0,0 ,14,0,0,0 ,14,0,0,0 ,14,0,0,0 ,13,0,0,0 ,14,0,0,0 ,14,0,0,0 ,14,0,0,0 ,14,0,0,0 ,14,0,0,0 ,14,0,0,0 ,14,0,0,0 ,14,0,0,0 ,14,0,0,0 ,14,0,0,0 ,14,0,0,0 ,14,0,0,0 ,14,0,0,0 ,14,0,0,0 ,14,0,0,0 ,14,0,0,0 ,14,0,0,0 ,14,0,0,0 ,14,0,0,0 ,14,0,0,0 ,14,0,0,0 ,14,0,0,0 ,14,0,0,0 ,14,0,0,0 ,14,0,0,0 ,14,0,0,0 ,215,0,0,0 ,193,0,0,0 ,198,0,0,0 ,198,0,0,0 ,198,0,0,0 ,198,0,0,0 ,212,0,0,0 ,212,0,0,0 ,201,0,0,0 ,212,0,0,0 ,4,0,0,0 ,187,0,0,0 ,207,0,0,0 ,18,0,0,0 ,212,0,0,0 ,201,0,0,0 ,210,0,0,0 ,205,0,0,0 ,144,0,0,0 ,145,0,0,0 ,201,0,0,0 ,4,156,3,0 ,212,0,0,0 ,193,0,0,0 ,201,0,0,0 ,143,0,0,0 ,4,0,0,0 ,185,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,193,0,0,0 ,0,224,0,0 ,0,225,0,0 ,0,226,0,0 ,0,227,0,0 ,0,228,0,0 ,0,229,0,0 ,0,230,0,0 ,0,231,0,0 ,0,232,0,0 ,0,233,0,0 ,0,234,0,0 ,0,235,0,0 ,0,236,0,0 ,0,237,0,0 ,0,238,0,0 ,0,239,0,0 ,0,240,0,0 ,0,241,0,0 ,0,242,0,0 ,0,243,0,0 ,0,244,0,0 ,0,245,0,0 ,0,246,0,0 ,207,0,0,0 ,0,248,0,0 ,0,249,0,0 ,0,250,0,0 ,0,251,0,0 ,0,252,0,0 ,0,253,0,0 ,0,254,0,0 ,4,0,0,0 ,1,192,0,0 ,1,193,0,0 ,1,194,0,0 ,1,195,0,0 ,1,196,0,0 ,1,197,0,0 ,1,198,0,0 ,1,199,0,0 ,1,200,0,0 ,1,201,0,0 ,1,202,0,0 ,1,203,0,0 ,1,204,0,0 ,1,205,0,0 ,1,206,0,0 ,1,207,0,0 ,1,208,0,0 ,1,209,0,0 ,1,210,0,0 ,1,211,0,0 ,1,212,0,0 ,1,213,0,0 ,1,214,0,0 ,207,0,0,0 ,1,216,0,0 ,1,217,0,0 ,1,218,0,0 ,1,219,0,0 ,1,220,0,0 ,1,221,0,0 ,1,222,0,0 ,1,120,1,0 }; const unsigned char ecl_ucd_page_table_2[] = { 0,1,1,0 ,1,0,1,0 ,0,3,1,0 ,1,2,1,0 ,0,5,1,0 ,1,4,1,0 ,0,7,1,0 ,1,6,1,0 ,0,9,1,0 ,1,8,1,0 ,0,11,1,0 ,1,10,1,0 ,0,13,1,0 ,1,12,1,0 ,0,15,1,0 ,1,14,1,0 ,0,17,1,0 ,1,16,1,0 ,0,19,1,0 ,1,18,1,0 ,0,21,1,0 ,1,20,1,0 ,0,23,1,0 ,1,22,1,0 ,0,25,1,0 ,1,24,1,0 ,0,27,1,0 ,1,26,1,0 ,0,29,1,0 ,1,28,1,0 ,0,31,1,0 ,1,30,1,0 ,0,33,1,0 ,1,32,1,0 ,0,35,1,0 ,1,34,1,0 ,0,37,1,0 ,1,36,1,0 ,0,39,1,0 ,1,38,1,0 ,0,41,1,0 ,1,40,1,0 ,0,43,1,0 ,1,42,1,0 ,0,45,1,0 ,1,44,1,0 ,0,47,1,0 ,1,46,1,0 ,3,105,0,0 ,4,73,0,0 ,0,51,1,0 ,1,50,1,0 ,0,53,1,0 ,1,52,1,0 ,0,55,1,0 ,1,54,1,0 ,4,0,0,0 ,0,58,1,0 ,1,57,1,0 ,0,60,1,0 ,1,59,1,0 ,0,62,1,0 ,1,61,1,0 ,0,64,1,0 ,1,63,1,0 ,0,66,1,0 ,1,65,1,0 ,0,68,1,0 ,1,67,1,0 ,0,70,1,0 ,1,69,1,0 ,0,72,1,0 ,1,71,1,0 ,4,0,0,0 ,0,75,1,0 ,1,74,1,0 ,0,77,1,0 ,1,76,1,0 ,0,79,1,0 ,1,78,1,0 ,0,81,1,0 ,1,80,1,0 ,0,83,1,0 ,1,82,1,0 ,0,85,1,0 ,1,84,1,0 ,0,87,1,0 ,1,86,1,0 ,0,89,1,0 ,1,88,1,0 ,0,91,1,0 ,1,90,1,0 ,0,93,1,0 ,1,92,1,0 ,0,95,1,0 ,1,94,1,0 ,0,97,1,0 ,1,96,1,0 ,0,99,1,0 ,1,98,1,0 ,0,101,1,0 ,1,100,1,0 ,0,103,1,0 ,1,102,1,0 ,0,105,1,0 ,1,104,1,0 ,0,107,1,0 ,1,106,1,0 ,0,109,1,0 ,1,108,1,0 ,0,111,1,0 ,1,110,1,0 ,0,113,1,0 ,1,112,1,0 ,0,115,1,0 ,1,114,1,0 ,0,117,1,0 ,1,116,1,0 ,0,119,1,0 ,1,118,1,0 ,0,255,0,0 ,0,122,1,0 ,1,121,1,0 ,0,124,1,0 ,1,123,1,0 ,0,126,1,0 ,1,125,1,0 ,4,83,0,0 ,1,67,2,0 ,0,83,2,0 ,0,131,1,0 ,1,130,1,0 ,0,133,1,0 ,1,132,1,0 ,0,84,2,0 ,0,136,1,0 ,1,135,1,0 ,0,86,2,0 ,0,87,2,0 ,0,140,1,0 ,1,139,1,0 ,4,0,0,0 ,0,221,1,0 ,0,89,2,0 ,0,91,2,0 ,0,146,1,0 ,1,145,1,0 ,0,96,2,0 ,0,99,2,0 ,1,246,1,0 ,0,105,2,0 ,0,104,2,0 ,0,153,1,0 ,1,152,1,0 ,1,61,2,0 ,4,0,0,0 ,0,111,2,0 ,0,114,2,0 ,1,32,2,0 ,0,117,2,0 ,0,161,1,0 ,1,160,1,0 ,0,163,1,0 ,1,162,1,0 ,0,165,1,0 ,1,164,1,0 ,0,128,2,0 ,0,168,1,0 ,1,167,1,0 ,0,131,2,0 ,4,0,0,0 ,4,0,0,0 ,0,173,1,0 ,1,172,1,0 ,0,136,2,0 ,0,176,1,0 ,1,175,1,0 ,0,138,2,0 ,0,139,2,0 ,0,180,1,0 ,1,179,1,0 ,0,182,1,0 ,1,181,1,0 ,0,146,2,0 ,0,185,1,0 ,1,184,1,0 ,4,0,0,0 ,11,0,0,0 ,0,189,1,0 ,1,188,1,0 ,4,0,0,0 ,1,247,1,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,0,198,1,0 ,5,196,1,0 ,1,196,1,0 ,0,201,1,0 ,5,199,1,0 ,1,199,1,0 ,0,204,1,0 ,5,202,1,0 ,1,202,1,0 ,0,206,1,0 ,1,205,1,0 ,0,208,1,0 ,1,207,1,0 ,0,210,1,0 ,1,209,1,0 ,0,212,1,0 ,1,211,1,0 ,0,214,1,0 ,1,213,1,0 ,0,216,1,0 ,1,215,1,0 ,0,218,1,0 ,1,217,1,0 ,0,220,1,0 ,1,219,1,0 ,1,142,1,0 ,0,223,1,0 ,1,222,1,0 ,0,225,1,0 ,1,224,1,0 ,0,227,1,0 ,1,226,1,0 ,0,229,1,0 ,1,228,1,0 ,0,231,1,0 ,1,230,1,0 ,0,233,1,0 ,1,232,1,0 ,0,235,1,0 ,1,234,1,0 ,0,237,1,0 ,1,236,1,0 ,0,239,1,0 ,1,238,1,0 ,4,0,0,0 ,0,243,1,0 ,5,241,1,0 ,1,241,1,0 ,0,245,1,0 ,1,244,1,0 ,0,149,1,0 ,0,191,1,0 ,0,249,1,0 ,1,248,1,0 ,0,251,1,0 ,1,250,1,0 ,0,253,1,0 ,1,252,1,0 ,0,255,1,0 ,1,254,1,0 }; const unsigned char ecl_ucd_page_table_3[] = { 0,1,2,0 ,1,0,2,0 ,0,3,2,0 ,1,2,2,0 ,0,5,2,0 ,1,4,2,0 ,0,7,2,0 ,1,6,2,0 ,0,9,2,0 ,1,8,2,0 ,0,11,2,0 ,1,10,2,0 ,0,13,2,0 ,1,12,2,0 ,0,15,2,0 ,1,14,2,0 ,0,17,2,0 ,1,16,2,0 ,0,19,2,0 ,1,18,2,0 ,0,21,2,0 ,1,20,2,0 ,0,23,2,0 ,1,22,2,0 ,0,25,2,0 ,1,24,2,0 ,0,27,2,0 ,1,26,2,0 ,0,29,2,0 ,1,28,2,0 ,0,31,2,0 ,1,30,2,0 ,0,158,1,0 ,4,0,0,0 ,0,35,2,0 ,1,34,2,0 ,0,37,2,0 ,1,36,2,0 ,0,39,2,0 ,1,38,2,0 ,0,41,2,0 ,1,40,2,0 ,0,43,2,0 ,1,42,2,0 ,0,45,2,0 ,1,44,2,0 ,0,47,2,0 ,1,46,2,0 ,0,49,2,0 ,1,48,2,0 ,0,51,2,0 ,1,50,2,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,0,101,44,0 ,0,60,2,0 ,1,59,2,0 ,0,154,1,0 ,0,102,44,0 ,1,126,44,0 ,1,127,44,0 ,0,66,2,0 ,1,65,2,0 ,0,128,1,0 ,0,137,2,0 ,0,140,2,0 ,0,71,2,0 ,1,70,2,0 ,0,73,2,0 ,1,72,2,0 ,0,75,2,0 ,1,74,2,0 ,0,77,2,0 ,1,76,2,0 ,0,79,2,0 ,1,78,2,0 ,1,111,44,0 ,1,109,44,0 ,1,112,44,0 ,1,129,1,0 ,1,134,1,0 ,4,0,0,0 ,1,137,1,0 ,1,138,1,0 ,4,0,0,0 ,1,143,1,0 ,4,0,0,0 ,1,144,1,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,1,147,1,0 ,4,0,0,0 ,4,0,0,0 ,1,148,1,0 ,4,0,0,0 ,1,141,167,0 ,4,0,0,0 ,4,0,0,0 ,1,151,1,0 ,1,150,1,0 ,4,0,0,0 ,1,98,44,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,1,156,1,0 ,4,0,0,0 ,1,110,44,0 ,1,157,1,0 ,4,0,0,0 ,4,0,0,0 ,1,159,1,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,1,100,44,0 ,4,0,0,0 ,4,0,0,0 ,1,166,1,0 ,4,0,0,0 ,4,0,0,0 ,1,169,1,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,1,174,1,0 ,1,68,2,0 ,1,177,1,0 ,1,178,1,0 ,1,69,2,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,1,183,1,0 ,4,0,0,0 ,11,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,8,0,0,0 ,8,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,201,0,0,0 ,201,0,0,0 ,201,0,0,0 ,201,0,0,0 ,8,0,0,0 ,8,0,0,0 ,8,0,0,0 ,8,0,0,0 ,8,0,0,0 ,8,0,0,0 ,8,0,0,0 ,8,0,0,0 ,8,0,0,0 ,8,0,0,0 ,7,0,0,0 ,7,0,0,0 ,201,0,0,0 ,201,0,0,0 ,201,0,0,0 ,201,0,0,0 ,201,0,0,0 ,201,0,0,0 ,201,0,0,0 ,201,0,0,0 ,201,0,0,0 ,201,0,0,0 ,201,0,0,0 ,201,0,0,0 ,201,0,0,0 ,201,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,201,0,0,0 ,201,0,0,0 ,201,0,0,0 ,201,0,0,0 ,201,0,0,0 ,201,0,0,0 ,201,0,0,0 ,8,0,0,0 ,201,0,0,0 ,7,0,0,0 ,201,0,0,0 ,201,0,0,0 ,201,0,0,0 ,201,0,0,0 ,201,0,0,0 ,201,0,0,0 ,201,0,0,0 ,201,0,0,0 ,201,0,0,0 ,201,0,0,0 ,201,0,0,0 ,201,0,0,0 ,201,0,0,0 ,201,0,0,0 ,201,0,0,0 ,201,0,0,0 ,201,0,0,0 }; const unsigned char ecl_ucd_page_table_4[] = { 84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,85,0,0,0 ,80,0,0,0 ,80,0,0,0 ,80,0,0,0 ,80,0,0,0 ,85,0,0,0 ,78,0,0,0 ,80,0,0,0 ,80,0,0,0 ,80,0,0,0 ,80,0,0,0 ,80,0,0,0 ,76,0,0,0 ,76,0,0,0 ,80,0,0,0 ,80,0,0,0 ,80,0,0,0 ,80,0,0,0 ,76,0,0,0 ,76,0,0,0 ,80,0,0,0 ,80,0,0,0 ,80,0,0,0 ,80,0,0,0 ,80,0,0,0 ,80,0,0,0 ,80,0,0,0 ,80,0,0,0 ,80,0,0,0 ,80,0,0,0 ,80,0,0,0 ,36,0,0,0 ,36,0,0,0 ,36,0,0,0 ,36,0,0,0 ,36,0,0,0 ,80,0,0,0 ,80,0,0,0 ,80,0,0,0 ,80,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,88,153,3,0 ,84,0,0,0 ,80,0,0,0 ,80,0,0,0 ,80,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,80,0,0,0 ,80,0,0,0 ,35,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,80,0,0,0 ,80,0,0,0 ,80,0,0,0 ,80,0,0,0 ,84,0,0,0 ,85,0,0,0 ,80,0,0,0 ,80,0,0,0 ,84,0,0,0 ,86,0,0,0 ,87,0,0,0 ,87,0,0,0 ,86,0,0,0 ,87,0,0,0 ,87,0,0,0 ,86,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,0,113,3,0 ,1,112,3,0 ,0,115,3,0 ,1,114,3,0 ,8,0,0,0 ,201,0,0,0 ,0,119,3,0 ,1,118,3,0 ,216,0,0,0 ,216,0,0,0 ,7,0,0,0 ,1,253,3,0 ,1,254,3,0 ,1,255,3,0 ,193,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,201,0,0,0 ,201,0,0,0 ,0,172,3,0 ,193,0,0,0 ,0,173,3,0 ,0,174,3,0 ,0,175,3,0 ,216,0,0,0 ,0,204,3,0 ,216,0,0,0 ,0,205,3,0 ,0,206,3,0 ,4,0,0,0 ,0,177,3,0 ,0,178,3,0 ,0,179,3,0 ,0,180,3,0 ,0,181,3,0 ,0,182,3,0 ,0,183,3,0 ,0,184,3,0 ,0,185,3,0 ,0,186,3,0 ,0,187,3,0 ,0,188,3,0 ,0,189,3,0 ,0,190,3,0 ,0,191,3,0 ,0,192,3,0 ,0,193,3,0 ,216,0,0,0 ,0,195,3,0 ,0,196,3,0 ,0,197,3,0 ,0,198,3,0 ,0,199,3,0 ,0,200,3,0 ,0,201,3,0 ,0,202,3,0 ,0,203,3,0 ,1,134,3,0 ,1,136,3,0 ,1,137,3,0 ,1,138,3,0 ,4,0,0,0 ,1,145,3,0 ,1,146,3,0 ,1,147,3,0 ,1,148,3,0 ,1,149,3,0 ,1,150,3,0 ,1,151,3,0 ,1,152,3,0 ,1,153,3,0 ,1,154,3,0 ,1,155,3,0 ,1,156,3,0 ,1,157,3,0 ,1,158,3,0 ,1,159,3,0 ,1,160,3,0 ,1,161,3,0 ,4,163,3,0 ,1,163,3,0 ,1,164,3,0 ,1,165,3,0 ,1,166,3,0 ,1,167,3,0 ,1,168,3,0 ,1,169,3,0 ,1,170,3,0 ,1,171,3,0 ,1,140,3,0 ,1,142,3,0 ,1,143,3,0 ,0,215,3,0 ,4,146,3,0 ,4,152,3,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,4,166,3,0 ,4,160,3,0 ,1,207,3,0 ,0,217,3,0 ,1,216,3,0 ,0,219,3,0 ,1,218,3,0 ,0,221,3,0 ,1,220,3,0 ,0,223,3,0 ,1,222,3,0 ,0,225,3,0 ,1,224,3,0 ,0,227,3,0 ,1,226,3,0 ,0,229,3,0 ,1,228,3,0 ,0,231,3,0 ,1,230,3,0 ,0,233,3,0 ,1,232,3,0 ,0,235,3,0 ,1,234,3,0 ,0,237,3,0 ,1,236,3,0 ,0,239,3,0 ,1,238,3,0 ,4,154,3,0 ,4,161,3,0 ,1,249,3,0 ,4,0,0,0 ,3,184,3,0 ,4,149,3,0 ,207,0,0,0 ,0,248,3,0 ,1,247,3,0 ,0,242,3,0 ,0,251,3,0 ,1,250,3,0 ,4,0,0,0 ,0,123,3,0 ,0,124,3,0 ,0,125,3,0 }; const unsigned char ecl_ucd_page_table_5[] = { 0,80,4,0 ,0,81,4,0 ,0,82,4,0 ,0,83,4,0 ,0,84,4,0 ,0,85,4,0 ,0,86,4,0 ,0,87,4,0 ,0,88,4,0 ,0,89,4,0 ,0,90,4,0 ,0,91,4,0 ,0,92,4,0 ,0,93,4,0 ,0,94,4,0 ,0,95,4,0 ,0,48,4,0 ,0,49,4,0 ,0,50,4,0 ,0,51,4,0 ,0,52,4,0 ,0,53,4,0 ,0,54,4,0 ,0,55,4,0 ,0,56,4,0 ,0,57,4,0 ,0,58,4,0 ,0,59,4,0 ,0,60,4,0 ,0,61,4,0 ,0,62,4,0 ,0,63,4,0 ,0,64,4,0 ,0,65,4,0 ,0,66,4,0 ,0,67,4,0 ,0,68,4,0 ,0,69,4,0 ,0,70,4,0 ,0,71,4,0 ,0,72,4,0 ,0,73,4,0 ,0,74,4,0 ,0,75,4,0 ,0,76,4,0 ,0,77,4,0 ,0,78,4,0 ,0,79,4,0 ,1,16,4,0 ,1,17,4,0 ,1,18,4,0 ,1,19,4,0 ,1,20,4,0 ,1,21,4,0 ,1,22,4,0 ,1,23,4,0 ,1,24,4,0 ,1,25,4,0 ,1,26,4,0 ,1,27,4,0 ,1,28,4,0 ,1,29,4,0 ,1,30,4,0 ,1,31,4,0 ,1,32,4,0 ,1,33,4,0 ,1,34,4,0 ,1,35,4,0 ,1,36,4,0 ,1,37,4,0 ,1,38,4,0 ,1,39,4,0 ,1,40,4,0 ,1,41,4,0 ,1,42,4,0 ,1,43,4,0 ,1,44,4,0 ,1,45,4,0 ,1,46,4,0 ,1,47,4,0 ,1,0,4,0 ,1,1,4,0 ,1,2,4,0 ,1,3,4,0 ,1,4,4,0 ,1,5,4,0 ,1,6,4,0 ,1,7,4,0 ,1,8,4,0 ,1,9,4,0 ,1,10,4,0 ,1,11,4,0 ,1,12,4,0 ,1,13,4,0 ,1,14,4,0 ,1,15,4,0 ,0,97,4,0 ,1,96,4,0 ,0,99,4,0 ,1,98,4,0 ,0,101,4,0 ,1,100,4,0 ,0,103,4,0 ,1,102,4,0 ,0,105,4,0 ,1,104,4,0 ,0,107,4,0 ,1,106,4,0 ,0,109,4,0 ,1,108,4,0 ,0,111,4,0 ,1,110,4,0 ,0,113,4,0 ,1,112,4,0 ,0,115,4,0 ,1,114,4,0 ,0,117,4,0 ,1,116,4,0 ,0,119,4,0 ,1,118,4,0 ,0,121,4,0 ,1,120,4,0 ,0,123,4,0 ,1,122,4,0 ,0,125,4,0 ,1,124,4,0 ,0,127,4,0 ,1,126,4,0 ,0,129,4,0 ,1,128,4,0 ,211,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,33,0,0,0 ,33,0,0,0 ,0,139,4,0 ,1,138,4,0 ,0,141,4,0 ,1,140,4,0 ,0,143,4,0 ,1,142,4,0 ,0,145,4,0 ,1,144,4,0 ,0,147,4,0 ,1,146,4,0 ,0,149,4,0 ,1,148,4,0 ,0,151,4,0 ,1,150,4,0 ,0,153,4,0 ,1,152,4,0 ,0,155,4,0 ,1,154,4,0 ,0,157,4,0 ,1,156,4,0 ,0,159,4,0 ,1,158,4,0 ,0,161,4,0 ,1,160,4,0 ,0,163,4,0 ,1,162,4,0 ,0,165,4,0 ,1,164,4,0 ,0,167,4,0 ,1,166,4,0 ,0,169,4,0 ,1,168,4,0 ,0,171,4,0 ,1,170,4,0 ,0,173,4,0 ,1,172,4,0 ,0,175,4,0 ,1,174,4,0 ,0,177,4,0 ,1,176,4,0 ,0,179,4,0 ,1,178,4,0 ,0,181,4,0 ,1,180,4,0 ,0,183,4,0 ,1,182,4,0 ,0,185,4,0 ,1,184,4,0 ,0,187,4,0 ,1,186,4,0 ,0,189,4,0 ,1,188,4,0 ,0,191,4,0 ,1,190,4,0 ,0,207,4,0 ,0,194,4,0 ,1,193,4,0 ,0,196,4,0 ,1,195,4,0 ,0,198,4,0 ,1,197,4,0 ,0,200,4,0 ,1,199,4,0 ,0,202,4,0 ,1,201,4,0 ,0,204,4,0 ,1,203,4,0 ,0,206,4,0 ,1,205,4,0 ,1,192,4,0 ,0,209,4,0 ,1,208,4,0 ,0,211,4,0 ,1,210,4,0 ,0,213,4,0 ,1,212,4,0 ,0,215,4,0 ,1,214,4,0 ,0,217,4,0 ,1,216,4,0 ,0,219,4,0 ,1,218,4,0 ,0,221,4,0 ,1,220,4,0 ,0,223,4,0 ,1,222,4,0 ,0,225,4,0 ,1,224,4,0 ,0,227,4,0 ,1,226,4,0 ,0,229,4,0 ,1,228,4,0 ,0,231,4,0 ,1,230,4,0 ,0,233,4,0 ,1,232,4,0 ,0,235,4,0 ,1,234,4,0 ,0,237,4,0 ,1,236,4,0 ,0,239,4,0 ,1,238,4,0 ,0,241,4,0 ,1,240,4,0 ,0,243,4,0 ,1,242,4,0 ,0,245,4,0 ,1,244,4,0 ,0,247,4,0 ,1,246,4,0 ,0,249,4,0 ,1,248,4,0 ,0,251,4,0 ,1,250,4,0 ,0,253,4,0 ,1,252,4,0 ,0,255,4,0 ,1,254,4,0 }; const unsigned char ecl_ucd_page_table_6[] = { 0,1,5,0 ,1,0,5,0 ,0,3,5,0 ,1,2,5,0 ,0,5,5,0 ,1,4,5,0 ,0,7,5,0 ,1,6,5,0 ,0,9,5,0 ,1,8,5,0 ,0,11,5,0 ,1,10,5,0 ,0,13,5,0 ,1,12,5,0 ,0,15,5,0 ,1,14,5,0 ,0,17,5,0 ,1,16,5,0 ,0,19,5,0 ,1,18,5,0 ,0,21,5,0 ,1,20,5,0 ,0,23,5,0 ,1,22,5,0 ,0,25,5,0 ,1,24,5,0 ,0,27,5,0 ,1,26,5,0 ,0,29,5,0 ,1,28,5,0 ,0,31,5,0 ,1,30,5,0 ,0,33,5,0 ,1,32,5,0 ,0,35,5,0 ,1,34,5,0 ,0,37,5,0 ,1,36,5,0 ,0,39,5,0 ,1,38,5,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,0,97,5,0 ,0,98,5,0 ,0,99,5,0 ,0,100,5,0 ,0,101,5,0 ,0,102,5,0 ,0,103,5,0 ,0,104,5,0 ,0,105,5,0 ,0,106,5,0 ,0,107,5,0 ,0,108,5,0 ,0,109,5,0 ,0,110,5,0 ,0,111,5,0 ,0,112,5,0 ,0,113,5,0 ,0,114,5,0 ,0,115,5,0 ,0,116,5,0 ,0,117,5,0 ,0,118,5,0 ,0,119,5,0 ,0,120,5,0 ,0,121,5,0 ,0,122,5,0 ,0,123,5,0 ,0,124,5,0 ,0,125,5,0 ,0,126,5,0 ,0,127,5,0 ,0,128,5,0 ,0,129,5,0 ,0,130,5,0 ,0,131,5,0 ,0,132,5,0 ,0,133,5,0 ,0,134,5,0 ,216,0,0,0 ,216,0,0,0 ,7,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,216,0,0,0 ,1,49,5,0 ,1,50,5,0 ,1,51,5,0 ,1,52,5,0 ,1,53,5,0 ,1,54,5,0 ,1,55,5,0 ,1,56,5,0 ,1,57,5,0 ,1,58,5,0 ,1,59,5,0 ,1,60,5,0 ,1,61,5,0 ,1,62,5,0 ,1,63,5,0 ,1,64,5,0 ,1,65,5,0 ,1,66,5,0 ,1,67,5,0 ,1,68,5,0 ,1,69,5,0 ,1,70,5,0 ,1,71,5,0 ,1,72,5,0 ,1,73,5,0 ,1,74,5,0 ,1,75,5,0 ,1,76,5,0 ,1,77,5,0 ,1,78,5,0 ,1,79,5,0 ,1,80,5,0 ,1,81,5,0 ,1,82,5,0 ,1,83,5,0 ,1,84,5,0 ,1,85,5,0 ,1,86,5,0 ,4,0,0,0 ,216,0,0,0 ,192,0,0,0 ,180,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,80,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,80,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,81,0,0,0 ,80,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,80,0,0,0 ,80,0,0,0 ,80,0,0,0 ,80,0,0,0 ,80,0,0,0 ,80,0,0,0 ,84,0,0,0 ,84,0,0,0 ,80,0,0,0 ,84,0,0,0 ,84,0,0,0 ,81,0,0,0 ,83,0,0,0 ,84,0,0,0 ,40,0,0,0 ,41,0,0,0 ,42,0,0,0 ,43,0,0,0 ,44,0,0,0 ,45,0,0,0 ,46,0,0,0 ,47,0,0,0 ,48,0,0,0 ,49,0,0,0 ,49,0,0,0 ,50,0,0,0 ,51,0,0,0 ,52,0,0,0 ,181,0,0,0 ,53,0,0,0 ,194,0,0,0 ,54,0,0,0 ,55,0,0,0 ,194,0,0,0 ,84,0,0,0 ,80,0,0,0 ,194,0,0,0 ,48,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,194,0,0,0 ,194,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 }; const unsigned char ecl_ucd_page_table_7[] = { 17,0,0,0 ,17,0,0,0 ,17,0,0,0 ,17,0,0,0 ,216,0,0,0 ,216,0,0,0 ,207,0,0,0 ,207,0,0,0 ,202,0,0,0 ,191,0,0,0 ,191,0,0,0 ,197,0,0,0 ,190,0,0,0 ,188,0,0,0 ,212,0,0,0 ,212,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,60,0,0,0 ,61,0,0,0 ,62,0,0,0 ,188,0,0,0 ,216,0,0,0 ,216,0,0,0 ,188,0,0,0 ,188,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,6,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,57,0,0,0 ,58,0,0,0 ,59,0,0,0 ,60,0,0,0 ,61,0,0,0 ,62,0,0,0 ,63,0,0,0 ,64,0,0,0 ,84,0,0,0 ,84,0,0,0 ,80,0,0,0 ,80,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,80,0,0,0 ,84,0,0,0 ,84,0,0,0 ,80,0,0,0 ,89,0,0,0 ,90,0,0,0 ,91,0,0,0 ,92,0,0,0 ,93,0,0,0 ,94,0,0,0 ,95,0,0,0 ,96,0,0,0 ,97,0,0,0 ,98,0,0,0 ,191,0,0,0 ,189,0,0,0 ,189,0,0,0 ,188,0,0,0 ,10,0,0,0 ,10,0,0,0 ,65,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,188,0,0,0 ,10,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,17,0,0,0 ,212,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,80,0,0,0 ,84,0,0,0 ,6,0,0,0 ,6,0,0,0 ,84,0,0,0 ,84,0,0,0 ,212,0,0,0 ,80,0,0,0 ,84,0,0,0 ,84,0,0,0 ,80,0,0,0 ,10,0,0,0 ,10,0,0,0 ,99,0,0,0 ,100,0,0,0 ,101,0,0,0 ,102,0,0,0 ,103,0,0,0 ,104,0,0,0 ,105,0,0,0 ,106,0,0,0 ,107,0,0,0 ,108,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,209,0,0,0 ,209,0,0,0 ,10,0,0,0 }; const unsigned char ecl_ucd_page_table_8[] = { 188,0,0,0 ,188,0,0,0 ,188,0,0,0 ,188,0,0,0 ,188,0,0,0 ,188,0,0,0 ,188,0,0,0 ,188,0,0,0 ,188,0,0,0 ,188,0,0,0 ,188,0,0,0 ,188,0,0,0 ,188,0,0,0 ,188,0,0,0 ,216,0,0,0 ,17,0,0,0 ,10,0,0,0 ,66,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,84,0,0,0 ,80,0,0,0 ,84,0,0,0 ,84,0,0,0 ,80,0,0,0 ,84,0,0,0 ,84,0,0,0 ,80,0,0,0 ,80,0,0,0 ,80,0,0,0 ,84,0,0,0 ,80,0,0,0 ,80,0,0,0 ,84,0,0,0 ,80,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,80,0,0,0 ,84,0,0,0 ,80,0,0,0 ,84,0,0,0 ,80,0,0,0 ,84,0,0,0 ,80,0,0,0 ,84,0,0,0 ,84,0,0,0 ,216,0,0,0 ,216,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,10,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,119,0,0,0 ,120,0,0,0 ,121,0,0,0 ,122,0,0,0 ,123,0,0,0 ,124,0,0,0 ,125,0,0,0 ,126,0,0,0 ,127,0,0,0 ,128,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,80,0,0,0 ,84,0,0,0 ,9,0,0,0 ,9,0,0,0 ,212,0,0,0 ,193,0,0,0 ,193,0,0,0 ,193,0,0,0 ,9,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 }; const unsigned char ecl_ucd_page_table_9[] = { 12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,9,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,9,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,9,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,216,0,0,0 ,216,0,0,0 ,194,0,0,0 ,194,0,0,0 ,194,0,0,0 ,194,0,0,0 ,194,0,0,0 ,194,0,0,0 ,194,0,0,0 ,194,0,0,0 ,194,0,0,0 ,194,0,0,0 ,194,0,0,0 ,194,0,0,0 ,194,0,0,0 ,194,0,0,0 ,194,0,0,0 ,216,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,80,0,0,0 ,80,0,0,0 ,80,0,0,0 ,216,0,0,0 ,216,0,0,0 ,194,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 }; const unsigned char ecl_ucd_page_table_10[] = { 35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,29,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,35,0,0,0 ,29,0,0,0 ,37,0,0,0 ,11,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,39,0,0,0 ,29,0,0,0 ,29,0,0,0 ,11,0,0,0 ,84,0,0,0 ,80,0,0,0 ,84,0,0,0 ,84,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,35,0,0,0 ,35,0,0,0 ,192,0,0,0 ,192,0,0,0 ,109,0,0,0 ,110,0,0,0 ,111,0,0,0 ,112,0,0,0 ,113,0,0,0 ,114,0,0,0 ,115,0,0,0 ,116,0,0,0 ,117,0,0,0 ,118,0,0,0 ,192,0,0,0 ,7,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,35,0,0,0 ,29,0,0,0 ,29,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,37,0,0,0 ,11,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,216,0,0,0 ,216,0,0,0 ,29,0,0,0 ,29,0,0,0 ,216,0,0,0 ,216,0,0,0 ,29,0,0,0 ,29,0,0,0 ,39,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,29,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,35,0,0,0 ,35,0,0,0 ,216,0,0,0 ,216,0,0,0 ,109,0,0,0 ,110,0,0,0 ,111,0,0,0 ,112,0,0,0 ,113,0,0,0 ,114,0,0,0 ,115,0,0,0 ,116,0,0,0 ,117,0,0,0 ,118,0,0,0 ,11,0,0,0 ,11,0,0,0 ,198,0,0,0 ,198,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,211,0,0,0 ,198,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 }; const unsigned char ecl_ucd_page_table_11[] = { 216,0,0,0 ,35,0,0,0 ,35,0,0,0 ,29,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,37,0,0,0 ,216,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,35,0,0,0 ,35,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,35,0,0,0 ,35,0,0,0 ,216,0,0,0 ,216,0,0,0 ,35,0,0,0 ,35,0,0,0 ,39,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,35,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,109,0,0,0 ,110,0,0,0 ,111,0,0,0 ,112,0,0,0 ,113,0,0,0 ,114,0,0,0 ,115,0,0,0 ,116,0,0,0 ,117,0,0,0 ,118,0,0,0 ,35,0,0,0 ,35,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,35,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,35,0,0,0 ,35,0,0,0 ,29,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,37,0,0,0 ,11,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,216,0,0,0 ,35,0,0,0 ,35,0,0,0 ,29,0,0,0 ,216,0,0,0 ,29,0,0,0 ,29,0,0,0 ,39,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,35,0,0,0 ,35,0,0,0 ,216,0,0,0 ,216,0,0,0 ,109,0,0,0 ,110,0,0,0 ,111,0,0,0 ,112,0,0,0 ,113,0,0,0 ,114,0,0,0 ,115,0,0,0 ,116,0,0,0 ,117,0,0,0 ,118,0,0,0 ,216,0,0,0 ,198,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 }; const unsigned char ecl_ucd_page_table_12[] = { 216,0,0,0 ,35,0,0,0 ,29,0,0,0 ,29,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,37,0,0,0 ,11,0,0,0 ,29,0,0,0 ,35,0,0,0 ,29,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,216,0,0,0 ,216,0,0,0 ,29,0,0,0 ,29,0,0,0 ,216,0,0,0 ,216,0,0,0 ,29,0,0,0 ,29,0,0,0 ,39,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,35,0,0,0 ,29,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,35,0,0,0 ,35,0,0,0 ,216,0,0,0 ,216,0,0,0 ,109,0,0,0 ,110,0,0,0 ,111,0,0,0 ,112,0,0,0 ,113,0,0,0 ,114,0,0,0 ,115,0,0,0 ,116,0,0,0 ,117,0,0,0 ,118,0,0,0 ,211,0,0,0 ,11,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,35,0,0,0 ,11,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,11,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,29,0,0,0 ,29,0,0,0 ,35,0,0,0 ,29,0,0,0 ,29,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,216,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,39,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,29,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,109,0,0,0 ,110,0,0,0 ,111,0,0,0 ,112,0,0,0 ,113,0,0,0 ,114,0,0,0 ,115,0,0,0 ,116,0,0,0 ,117,0,0,0 ,118,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,198,0,0,0 ,212,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 }; const unsigned char ecl_ucd_page_table_13[] = { 216,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,216,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,216,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,39,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,67,0,0,0 ,68,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,35,0,0,0 ,35,0,0,0 ,216,0,0,0 ,216,0,0,0 ,109,0,0,0 ,110,0,0,0 ,111,0,0,0 ,112,0,0,0 ,113,0,0,0 ,114,0,0,0 ,115,0,0,0 ,116,0,0,0 ,117,0,0,0 ,118,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,211,0,0,0 ,216,0,0,0 ,216,0,0,0 ,29,0,0,0 ,29,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,37,0,0,0 ,11,0,0,0 ,29,0,0,0 ,34,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,216,0,0,0 ,34,0,0,0 ,29,0,0,0 ,29,0,0,0 ,216,0,0,0 ,29,0,0,0 ,29,0,0,0 ,35,0,0,0 ,39,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,29,0,0,0 ,29,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,35,0,0,0 ,35,0,0,0 ,216,0,0,0 ,216,0,0,0 ,109,0,0,0 ,110,0,0,0 ,111,0,0,0 ,112,0,0,0 ,113,0,0,0 ,114,0,0,0 ,115,0,0,0 ,116,0,0,0 ,117,0,0,0 ,118,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 }; const unsigned char ecl_ucd_page_table_14[] = { 216,0,0,0 ,216,0,0,0 ,29,0,0,0 ,29,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,216,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,216,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,39,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,29,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,35,0,0,0 ,35,0,0,0 ,216,0,0,0 ,216,0,0,0 ,109,0,0,0 ,110,0,0,0 ,111,0,0,0 ,112,0,0,0 ,113,0,0,0 ,114,0,0,0 ,115,0,0,0 ,116,0,0,0 ,117,0,0,0 ,118,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,211,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,29,0,0,0 ,29,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,39,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,216,0,0,0 ,35,0,0,0 ,216,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,29,0,0,0 ,29,0,0,0 ,192,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 }; const unsigned char ecl_ucd_page_table_15[] = { 216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,35,0,0,0 ,11,0,0,0 ,11,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,69,0,0,0 ,69,0,0,0 ,39,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,198,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,7,0,0,0 ,35,0,0,0 ,70,0,0,0 ,70,0,0,0 ,70,0,0,0 ,70,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,192,0,0,0 ,109,0,0,0 ,110,0,0,0 ,111,0,0,0 ,112,0,0,0 ,113,0,0,0 ,114,0,0,0 ,115,0,0,0 ,116,0,0,0 ,117,0,0,0 ,118,0,0,0 ,192,0,0,0 ,192,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,11,0,0,0 ,216,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,35,0,0,0 ,11,0,0,0 ,11,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,71,0,0,0 ,71,0,0,0 ,216,0,0,0 ,35,0,0,0 ,35,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,7,0,0,0 ,216,0,0,0 ,72,0,0,0 ,72,0,0,0 ,72,0,0,0 ,72,0,0,0 ,35,0,0,0 ,35,0,0,0 ,216,0,0,0 ,216,0,0,0 ,109,0,0,0 ,110,0,0,0 ,111,0,0,0 ,112,0,0,0 ,113,0,0,0 ,114,0,0,0 ,115,0,0,0 ,116,0,0,0 ,117,0,0,0 ,118,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 }; ecl-16.1.2/src/c/unicode/ucd-0016.c000066400000000000000000001244151266352375300163310ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ const unsigned char ecl_ucd_page_table_16[] = { 11,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,80,0,0,0 ,80,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,109,0,0,0 ,110,0,0,0 ,111,0,0,0 ,112,0,0,0 ,113,0,0,0 ,114,0,0,0 ,115,0,0,0 ,116,0,0,0 ,117,0,0,0 ,118,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,211,0,0,0 ,80,0,0,0 ,211,0,0,0 ,80,0,0,0 ,211,0,0,0 ,78,0,0,0 ,196,0,0,0 ,183,0,0,0 ,196,0,0,0 ,183,0,0,0 ,29,0,0,0 ,29,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,73,0,0,0 ,74,0,0,0 ,35,0,0,0 ,75,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,74,0,0,0 ,74,0,0,0 ,74,0,0,0 ,74,0,0,0 ,35,0,0,0 ,29,0,0,0 ,74,0,0,0 ,35,0,0,0 ,84,0,0,0 ,84,0,0,0 ,39,0,0,0 ,192,0,0,0 ,84,0,0,0 ,84,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,216,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,216,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,80,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,216,0,0,0 ,211,0,0,0 ,211,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,192,0,0,0 ,192,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 }; const unsigned char ecl_ucd_page_table_17[] = { 11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,29,0,0,0 ,29,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,29,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,37,0,0,0 ,29,0,0,0 ,39,0,0,0 ,39,0,0,0 ,29,0,0,0 ,29,0,0,0 ,35,0,0,0 ,35,0,0,0 ,11,0,0,0 ,109,0,0,0 ,110,0,0,0 ,111,0,0,0 ,112,0,0,0 ,113,0,0,0 ,114,0,0,0 ,115,0,0,0 ,116,0,0,0 ,117,0,0,0 ,118,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,29,0,0,0 ,29,0,0,0 ,35,0,0,0 ,35,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,11,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,11,0,0,0 ,11,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,35,0,0,0 ,29,0,0,0 ,29,0,0,0 ,35,0,0,0 ,35,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,80,0,0,0 ,11,0,0,0 ,29,0,0,0 ,109,0,0,0 ,110,0,0,0 ,111,0,0,0 ,112,0,0,0 ,113,0,0,0 ,114,0,0,0 ,115,0,0,0 ,116,0,0,0 ,117,0,0,0 ,118,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,35,0,0,0 ,211,0,0,0 ,211,0,0,0 ,0,0,45,0 ,0,1,45,0 ,0,2,45,0 ,0,3,45,0 ,0,4,45,0 ,0,5,45,0 ,0,6,45,0 ,0,7,45,0 ,0,8,45,0 ,0,9,45,0 ,0,10,45,0 ,0,11,45,0 ,0,12,45,0 ,0,13,45,0 ,0,14,45,0 ,0,15,45,0 ,0,16,45,0 ,0,17,45,0 ,0,18,45,0 ,0,19,45,0 ,0,20,45,0 ,0,21,45,0 ,0,22,45,0 ,0,23,45,0 ,0,24,45,0 ,0,25,45,0 ,0,26,45,0 ,0,27,45,0 ,0,28,45,0 ,0,29,45,0 ,0,30,45,0 ,0,31,45,0 ,0,32,45,0 ,0,33,45,0 ,0,34,45,0 ,0,35,45,0 ,0,36,45,0 ,0,37,45,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,192,0,0,0 ,7,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 }; const unsigned char ecl_ucd_page_table_18[] = { 11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 }; const unsigned char ecl_ucd_page_table_19[] = { 11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,11,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,11,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 }; const unsigned char ecl_ucd_page_table_20[] = { 11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,211,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,153,0,0,0 ,154,0,0,0 ,155,0,0,0 ,156,0,0,0 ,157,0,0,0 ,158,0,0,0 ,159,0,0,0 ,160,0,0,0 ,161,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 }; const unsigned char ecl_ucd_page_table_21[] = { 180,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 }; const unsigned char ecl_ucd_page_table_22[] = { 11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,192,0,0,0 ,192,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,196,0,0,0 ,183,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 }; const unsigned char ecl_ucd_page_table_23[] = { 11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,35,0,0,0 ,35,0,0,0 ,39,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,35,0,0,0 ,35,0,0,0 ,39,0,0,0 ,192,0,0,0 ,192,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,35,0,0,0 ,35,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,35,0,0,0 ,35,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,19,0,0,0 ,19,0,0,0 ,29,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,35,0,0,0 ,29,0,0,0 ,29,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,39,0,0,0 ,35,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,7,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,198,0,0,0 ,11,0,0,0 ,84,0,0,0 ,216,0,0,0 ,216,0,0,0 ,109,0,0,0 ,110,0,0,0 ,111,0,0,0 ,112,0,0,0 ,113,0,0,0 ,114,0,0,0 ,115,0,0,0 ,116,0,0,0 ,117,0,0,0 ,118,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 }; const unsigned char ecl_ucd_page_table_24[] = { 193,0,0,0 ,193,0,0,0 ,193,0,0,0 ,193,0,0,0 ,193,0,0,0 ,193,0,0,0 ,180,0,0,0 ,193,0,0,0 ,193,0,0,0 ,193,0,0,0 ,193,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,216,0,0,0 ,216,0,0,0 ,109,0,0,0 ,110,0,0,0 ,111,0,0,0 ,112,0,0,0 ,113,0,0,0 ,114,0,0,0 ,115,0,0,0 ,116,0,0,0 ,117,0,0,0 ,118,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,7,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,83,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 }; const unsigned char ecl_ucd_page_table_25[] = { 11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,35,0,0,0 ,35,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,29,0,0,0 ,29,0,0,0 ,35,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,81,0,0,0 ,84,0,0,0 ,80,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,212,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,193,0,0,0 ,193,0,0,0 ,109,0,0,0 ,110,0,0,0 ,111,0,0,0 ,112,0,0,0 ,113,0,0,0 ,114,0,0,0 ,115,0,0,0 ,116,0,0,0 ,117,0,0,0 ,118,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,29,0,0,0 ,29,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,109,0,0,0 ,110,0,0,0 ,111,0,0,0 ,112,0,0,0 ,113,0,0,0 ,114,0,0,0 ,115,0,0,0 ,116,0,0,0 ,117,0,0,0 ,118,0,0,0 ,153,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 }; const unsigned char ecl_ucd_page_table_26[] = { 11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,84,0,0,0 ,80,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,216,0,0,0 ,216,0,0,0 ,192,0,0,0 ,192,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,29,0,0,0 ,35,0,0,0 ,29,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,216,0,0,0 ,39,0,0,0 ,29,0,0,0 ,35,0,0,0 ,29,0,0,0 ,29,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,35,0,0,0 ,35,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,216,0,0,0 ,216,0,0,0 ,80,0,0,0 ,109,0,0,0 ,110,0,0,0 ,111,0,0,0 ,112,0,0,0 ,113,0,0,0 ,114,0,0,0 ,115,0,0,0 ,116,0,0,0 ,117,0,0,0 ,118,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,109,0,0,0 ,110,0,0,0 ,111,0,0,0 ,112,0,0,0 ,113,0,0,0 ,114,0,0,0 ,115,0,0,0 ,116,0,0,0 ,117,0,0,0 ,118,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,7,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 }; const unsigned char ecl_ucd_page_table_27[] = { 35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,29,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,37,0,0,0 ,29,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,29,0,0,0 ,35,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,35,0,0,0 ,29,0,0,0 ,30,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,109,0,0,0 ,110,0,0,0 ,111,0,0,0 ,112,0,0,0 ,113,0,0,0 ,114,0,0,0 ,115,0,0,0 ,116,0,0,0 ,117,0,0,0 ,118,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,84,0,0,0 ,80,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,35,0,0,0 ,35,0,0,0 ,29,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,29,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,29,0,0,0 ,29,0,0,0 ,35,0,0,0 ,35,0,0,0 ,30,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,109,0,0,0 ,110,0,0,0 ,111,0,0,0 ,112,0,0,0 ,113,0,0,0 ,114,0,0,0 ,115,0,0,0 ,116,0,0,0 ,117,0,0,0 ,118,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,37,0,0,0 ,29,0,0,0 ,35,0,0,0 ,35,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,35,0,0,0 ,29,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,30,0,0,0 ,30,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 }; const unsigned char ecl_ucd_page_table_28[] = { 11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,29,0,0,0 ,29,0,0,0 ,35,0,0,0 ,37,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,109,0,0,0 ,110,0,0,0 ,111,0,0,0 ,112,0,0,0 ,113,0,0,0 ,114,0,0,0 ,115,0,0,0 ,116,0,0,0 ,117,0,0,0 ,118,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,109,0,0,0 ,110,0,0,0 ,111,0,0,0 ,112,0,0,0 ,113,0,0,0 ,114,0,0,0 ,115,0,0,0 ,116,0,0,0 ,117,0,0,0 ,118,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,192,0,0,0 ,192,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,192,0,0,0 ,36,0,0,0 ,80,0,0,0 ,80,0,0,0 ,80,0,0,0 ,80,0,0,0 ,80,0,0,0 ,84,0,0,0 ,84,0,0,0 ,80,0,0,0 ,80,0,0,0 ,80,0,0,0 ,80,0,0,0 ,84,0,0,0 ,29,0,0,0 ,36,0,0,0 ,36,0,0,0 ,36,0,0,0 ,36,0,0,0 ,36,0,0,0 ,36,0,0,0 ,36,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,80,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,29,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 }; const unsigned char ecl_ucd_page_table_29[] = { 4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,7,0,0,0 ,1,125,167,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,1,99,44,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,84,0,0,0 ,84,0,0,0 ,80,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,80,0,0,0 ,84,0,0,0 ,84,0,0,0 ,87,0,0,0 ,77,0,0,0 ,80,0,0,0 ,76,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,86,0,0,0 ,80,0,0,0 ,84,0,0,0 ,80,0,0,0 }; const unsigned char ecl_ucd_page_table_30[] = { 0,1,30,0 ,1,0,30,0 ,0,3,30,0 ,1,2,30,0 ,0,5,30,0 ,1,4,30,0 ,0,7,30,0 ,1,6,30,0 ,0,9,30,0 ,1,8,30,0 ,0,11,30,0 ,1,10,30,0 ,0,13,30,0 ,1,12,30,0 ,0,15,30,0 ,1,14,30,0 ,0,17,30,0 ,1,16,30,0 ,0,19,30,0 ,1,18,30,0 ,0,21,30,0 ,1,20,30,0 ,0,23,30,0 ,1,22,30,0 ,0,25,30,0 ,1,24,30,0 ,0,27,30,0 ,1,26,30,0 ,0,29,30,0 ,1,28,30,0 ,0,31,30,0 ,1,30,30,0 ,0,33,30,0 ,1,32,30,0 ,0,35,30,0 ,1,34,30,0 ,0,37,30,0 ,1,36,30,0 ,0,39,30,0 ,1,38,30,0 ,0,41,30,0 ,1,40,30,0 ,0,43,30,0 ,1,42,30,0 ,0,45,30,0 ,1,44,30,0 ,0,47,30,0 ,1,46,30,0 ,0,49,30,0 ,1,48,30,0 ,0,51,30,0 ,1,50,30,0 ,0,53,30,0 ,1,52,30,0 ,0,55,30,0 ,1,54,30,0 ,0,57,30,0 ,1,56,30,0 ,0,59,30,0 ,1,58,30,0 ,0,61,30,0 ,1,60,30,0 ,0,63,30,0 ,1,62,30,0 ,0,65,30,0 ,1,64,30,0 ,0,67,30,0 ,1,66,30,0 ,0,69,30,0 ,1,68,30,0 ,0,71,30,0 ,1,70,30,0 ,0,73,30,0 ,1,72,30,0 ,0,75,30,0 ,1,74,30,0 ,0,77,30,0 ,1,76,30,0 ,0,79,30,0 ,1,78,30,0 ,0,81,30,0 ,1,80,30,0 ,0,83,30,0 ,1,82,30,0 ,0,85,30,0 ,1,84,30,0 ,0,87,30,0 ,1,86,30,0 ,0,89,30,0 ,1,88,30,0 ,0,91,30,0 ,1,90,30,0 ,0,93,30,0 ,1,92,30,0 ,0,95,30,0 ,1,94,30,0 ,0,97,30,0 ,1,96,30,0 ,0,99,30,0 ,1,98,30,0 ,0,101,30,0 ,1,100,30,0 ,0,103,30,0 ,1,102,30,0 ,0,105,30,0 ,1,104,30,0 ,0,107,30,0 ,1,106,30,0 ,0,109,30,0 ,1,108,30,0 ,0,111,30,0 ,1,110,30,0 ,0,113,30,0 ,1,112,30,0 ,0,115,30,0 ,1,114,30,0 ,0,117,30,0 ,1,116,30,0 ,0,119,30,0 ,1,118,30,0 ,0,121,30,0 ,1,120,30,0 ,0,123,30,0 ,1,122,30,0 ,0,125,30,0 ,1,124,30,0 ,0,127,30,0 ,1,126,30,0 ,0,129,30,0 ,1,128,30,0 ,0,131,30,0 ,1,130,30,0 ,0,133,30,0 ,1,132,30,0 ,0,135,30,0 ,1,134,30,0 ,0,137,30,0 ,1,136,30,0 ,0,139,30,0 ,1,138,30,0 ,0,141,30,0 ,1,140,30,0 ,0,143,30,0 ,1,142,30,0 ,0,145,30,0 ,1,144,30,0 ,0,147,30,0 ,1,146,30,0 ,0,149,30,0 ,1,148,30,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,96,30,0 ,4,0,0,0 ,4,0,0,0 ,3,223,0,0 ,4,0,0,0 ,0,161,30,0 ,1,160,30,0 ,0,163,30,0 ,1,162,30,0 ,0,165,30,0 ,1,164,30,0 ,0,167,30,0 ,1,166,30,0 ,0,169,30,0 ,1,168,30,0 ,0,171,30,0 ,1,170,30,0 ,0,173,30,0 ,1,172,30,0 ,0,175,30,0 ,1,174,30,0 ,0,177,30,0 ,1,176,30,0 ,0,179,30,0 ,1,178,30,0 ,0,181,30,0 ,1,180,30,0 ,0,183,30,0 ,1,182,30,0 ,0,185,30,0 ,1,184,30,0 ,0,187,30,0 ,1,186,30,0 ,0,189,30,0 ,1,188,30,0 ,0,191,30,0 ,1,190,30,0 ,0,193,30,0 ,1,192,30,0 ,0,195,30,0 ,1,194,30,0 ,0,197,30,0 ,1,196,30,0 ,0,199,30,0 ,1,198,30,0 ,0,201,30,0 ,1,200,30,0 ,0,203,30,0 ,1,202,30,0 ,0,205,30,0 ,1,204,30,0 ,0,207,30,0 ,1,206,30,0 ,0,209,30,0 ,1,208,30,0 ,0,211,30,0 ,1,210,30,0 ,0,213,30,0 ,1,212,30,0 ,0,215,30,0 ,1,214,30,0 ,0,217,30,0 ,1,216,30,0 ,0,219,30,0 ,1,218,30,0 ,0,221,30,0 ,1,220,30,0 ,0,223,30,0 ,1,222,30,0 ,0,225,30,0 ,1,224,30,0 ,0,227,30,0 ,1,226,30,0 ,0,229,30,0 ,1,228,30,0 ,0,231,30,0 ,1,230,30,0 ,0,233,30,0 ,1,232,30,0 ,0,235,30,0 ,1,234,30,0 ,0,237,30,0 ,1,236,30,0 ,0,239,30,0 ,1,238,30,0 ,0,241,30,0 ,1,240,30,0 ,0,243,30,0 ,1,242,30,0 ,0,245,30,0 ,1,244,30,0 ,0,247,30,0 ,1,246,30,0 ,0,249,30,0 ,1,248,30,0 ,0,251,30,0 ,1,250,30,0 ,0,253,30,0 ,1,252,30,0 ,0,255,30,0 ,1,254,30,0 }; const unsigned char ecl_ucd_page_table_31[] = { 1,8,31,0 ,1,9,31,0 ,1,10,31,0 ,1,11,31,0 ,1,12,31,0 ,1,13,31,0 ,1,14,31,0 ,1,15,31,0 ,0,0,31,0 ,0,1,31,0 ,0,2,31,0 ,0,3,31,0 ,0,4,31,0 ,0,5,31,0 ,0,6,31,0 ,0,7,31,0 ,1,24,31,0 ,1,25,31,0 ,1,26,31,0 ,1,27,31,0 ,1,28,31,0 ,1,29,31,0 ,216,0,0,0 ,216,0,0,0 ,0,16,31,0 ,0,17,31,0 ,0,18,31,0 ,0,19,31,0 ,0,20,31,0 ,0,21,31,0 ,216,0,0,0 ,216,0,0,0 ,1,40,31,0 ,1,41,31,0 ,1,42,31,0 ,1,43,31,0 ,1,44,31,0 ,1,45,31,0 ,1,46,31,0 ,1,47,31,0 ,0,32,31,0 ,0,33,31,0 ,0,34,31,0 ,0,35,31,0 ,0,36,31,0 ,0,37,31,0 ,0,38,31,0 ,0,39,31,0 ,1,56,31,0 ,1,57,31,0 ,1,58,31,0 ,1,59,31,0 ,1,60,31,0 ,1,61,31,0 ,1,62,31,0 ,1,63,31,0 ,0,48,31,0 ,0,49,31,0 ,0,50,31,0 ,0,51,31,0 ,0,52,31,0 ,0,53,31,0 ,0,54,31,0 ,0,55,31,0 ,1,72,31,0 ,1,73,31,0 ,1,74,31,0 ,1,75,31,0 ,1,76,31,0 ,1,77,31,0 ,216,0,0,0 ,216,0,0,0 ,0,64,31,0 ,0,65,31,0 ,0,66,31,0 ,0,67,31,0 ,0,68,31,0 ,0,69,31,0 ,216,0,0,0 ,216,0,0,0 ,4,0,0,0 ,1,89,31,0 ,4,0,0,0 ,1,91,31,0 ,4,0,0,0 ,1,93,31,0 ,4,0,0,0 ,1,95,31,0 ,216,0,0,0 ,0,81,31,0 ,216,0,0,0 ,0,83,31,0 ,216,0,0,0 ,0,85,31,0 ,216,0,0,0 ,0,87,31,0 ,1,104,31,0 ,1,105,31,0 ,1,106,31,0 ,1,107,31,0 ,1,108,31,0 ,1,109,31,0 ,1,110,31,0 ,1,111,31,0 ,0,96,31,0 ,0,97,31,0 ,0,98,31,0 ,0,99,31,0 ,0,100,31,0 ,0,101,31,0 ,0,102,31,0 ,0,103,31,0 ,1,186,31,0 ,1,187,31,0 ,1,200,31,0 ,1,201,31,0 ,1,202,31,0 ,1,203,31,0 ,1,218,31,0 ,1,219,31,0 ,1,248,31,0 ,1,249,31,0 ,1,234,31,0 ,1,235,31,0 ,1,250,31,0 ,1,251,31,0 ,216,0,0,0 ,216,0,0,0 ,1,136,31,0 ,1,137,31,0 ,1,138,31,0 ,1,139,31,0 ,1,140,31,0 ,1,141,31,0 ,1,142,31,0 ,1,143,31,0 ,5,128,31,0 ,5,129,31,0 ,5,130,31,0 ,5,131,31,0 ,5,132,31,0 ,5,133,31,0 ,5,134,31,0 ,5,135,31,0 ,1,152,31,0 ,1,153,31,0 ,1,154,31,0 ,1,155,31,0 ,1,156,31,0 ,1,157,31,0 ,1,158,31,0 ,1,159,31,0 ,5,144,31,0 ,5,145,31,0 ,5,146,31,0 ,5,147,31,0 ,5,148,31,0 ,5,149,31,0 ,5,150,31,0 ,5,151,31,0 ,1,168,31,0 ,1,169,31,0 ,1,170,31,0 ,1,171,31,0 ,1,172,31,0 ,1,173,31,0 ,1,174,31,0 ,1,175,31,0 ,5,160,31,0 ,5,161,31,0 ,5,162,31,0 ,5,163,31,0 ,5,164,31,0 ,5,165,31,0 ,5,166,31,0 ,5,167,31,0 ,1,184,31,0 ,1,185,31,0 ,4,0,0,0 ,1,188,31,0 ,4,0,0,0 ,216,0,0,0 ,4,0,0,0 ,4,0,0,0 ,0,176,31,0 ,0,177,31,0 ,0,112,31,0 ,0,113,31,0 ,5,179,31,0 ,201,0,0,0 ,4,153,3,0 ,201,0,0,0 ,201,0,0,0 ,201,0,0,0 ,4,0,0,0 ,1,204,31,0 ,4,0,0,0 ,216,0,0,0 ,4,0,0,0 ,4,0,0,0 ,0,114,31,0 ,0,115,31,0 ,0,116,31,0 ,0,117,31,0 ,5,195,31,0 ,201,0,0,0 ,201,0,0,0 ,201,0,0,0 ,1,216,31,0 ,1,217,31,0 ,4,0,0,0 ,4,0,0,0 ,216,0,0,0 ,216,0,0,0 ,4,0,0,0 ,4,0,0,0 ,0,208,31,0 ,0,209,31,0 ,0,118,31,0 ,0,119,31,0 ,216,0,0,0 ,201,0,0,0 ,201,0,0,0 ,201,0,0,0 ,1,232,31,0 ,1,233,31,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,1,236,31,0 ,4,0,0,0 ,4,0,0,0 ,0,224,31,0 ,0,225,31,0 ,0,122,31,0 ,0,123,31,0 ,0,229,31,0 ,201,0,0,0 ,201,0,0,0 ,201,0,0,0 ,216,0,0,0 ,216,0,0,0 ,4,0,0,0 ,1,252,31,0 ,4,0,0,0 ,216,0,0,0 ,4,0,0,0 ,4,0,0,0 ,0,120,31,0 ,0,121,31,0 ,0,124,31,0 ,0,125,31,0 ,5,243,31,0 ,201,0,0,0 ,201,0,0,0 ,216,0,0,0 }; ecl-16.1.2/src/c/unicode/ucd-0032.c000066400000000000000000001316751266352375300163350ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ const unsigned char ecl_ucd_page_table_32[] = { 216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,19,0,0,0 ,24,0,0,0 ,180,0,0,0 ,180,0,0,0 ,180,0,0,0 ,180,0,0,0 ,180,0,0,0 ,180,0,0,0 ,193,0,0,0 ,193,0,0,0 ,186,0,0,0 ,184,0,0,0 ,195,0,0,0 ,186,0,0,0 ,186,0,0,0 ,184,0,0,0 ,195,0,0,0 ,186,0,0,0 ,193,0,0,0 ,193,0,0,0 ,193,0,0,0 ,193,0,0,0 ,193,0,0,0 ,193,0,0,0 ,193,0,0,0 ,193,0,0,0 ,213,0,0,0 ,214,0,0,0 ,20,0,0,0 ,25,0,0,0 ,23,0,0,0 ,21,0,0,0 ,26,0,0,0 ,215,0,0,0 ,191,0,0,0 ,191,0,0,0 ,191,0,0,0 ,191,0,0,0 ,191,0,0,0 ,193,0,0,0 ,193,0,0,0 ,193,0,0,0 ,193,0,0,0 ,187,0,0,0 ,185,0,0,0 ,193,0,0,0 ,193,0,0,0 ,193,0,0,0 ,193,0,0,0 ,178,0,0,0 ,178,0,0,0 ,193,0,0,0 ,193,0,0,0 ,193,0,0,0 ,203,0,0,0 ,196,0,0,0 ,183,0,0,0 ,193,0,0,0 ,193,0,0,0 ,193,0,0,0 ,193,0,0,0 ,193,0,0,0 ,193,0,0,0 ,193,0,0,0 ,193,0,0,0 ,193,0,0,0 ,193,0,0,0 ,193,0,0,0 ,207,0,0,0 ,193,0,0,0 ,178,0,0,0 ,193,0,0,0 ,193,0,0,0 ,193,0,0,0 ,193,0,0,0 ,193,0,0,0 ,193,0,0,0 ,193,0,0,0 ,193,0,0,0 ,193,0,0,0 ,193,0,0,0 ,216,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,142,0,0,0 ,7,0,0,0 ,216,0,0,0 ,216,0,0,0 ,146,0,0,0 ,147,0,0,0 ,148,0,0,0 ,149,0,0,0 ,150,0,0,0 ,151,0,0,0 ,204,0,0,0 ,204,0,0,0 ,207,0,0,0 ,196,0,0,0 ,183,0,0,0 ,7,0,0,0 ,142,0,0,0 ,143,0,0,0 ,144,0,0,0 ,145,0,0,0 ,146,0,0,0 ,147,0,0,0 ,148,0,0,0 ,149,0,0,0 ,150,0,0,0 ,151,0,0,0 ,204,0,0,0 ,204,0,0,0 ,207,0,0,0 ,196,0,0,0 ,183,0,0,0 ,216,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,198,0,0,0 ,198,0,0,0 ,198,0,0,0 ,198,0,0,0 ,198,0,0,0 ,198,0,0,0 ,198,0,0,0 ,198,0,0,0 ,198,0,0,0 ,198,0,0,0 ,198,0,0,0 ,198,0,0,0 ,198,0,0,0 ,198,0,0,0 ,198,0,0,0 ,198,0,0,0 ,198,0,0,0 ,198,0,0,0 ,198,0,0,0 ,198,0,0,0 ,198,0,0,0 ,198,0,0,0 ,198,0,0,0 ,198,0,0,0 ,198,0,0,0 ,198,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,84,0,0,0 ,84,0,0,0 ,36,0,0,0 ,36,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,36,0,0,0 ,36,0,0,0 ,36,0,0,0 ,84,0,0,0 ,84,0,0,0 ,33,0,0,0 ,33,0,0,0 ,33,0,0,0 ,33,0,0,0 ,84,0,0,0 ,33,0,0,0 ,33,0,0,0 ,33,0,0,0 ,36,0,0,0 ,36,0,0,0 ,84,0,0,0 ,80,0,0,0 ,84,0,0,0 ,36,0,0,0 ,36,0,0,0 ,80,0,0,0 ,80,0,0,0 ,80,0,0,0 ,80,0,0,0 ,84,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 }; const unsigned char ecl_ucd_page_table_33[] = { 212,0,0,0 ,212,0,0,0 ,3,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,3,0,0,0 ,212,0,0,0 ,212,0,0,0 ,4,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,4,0,0,0 ,4,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,4,0,0,0 ,212,0,0,0 ,3,0,0,0 ,212,0,0,0 ,212,0,0,0 ,207,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,3,0,0,0 ,212,0,0,0 ,3,201,3,0 ,212,0,0,0 ,3,0,0,0 ,212,0,0,0 ,3,107,0,0 ,3,229,0,0 ,3,0,0,0 ,3,0,0,0 ,210,0,0,0 ,4,0,0,0 ,3,0,0,0 ,3,0,0,0 ,0,78,33,0 ,3,0,0,0 ,4,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,4,0,0,0 ,212,0,0,0 ,212,0,0,0 ,4,0,0,0 ,4,0,0,0 ,3,0,0,0 ,3,0,0,0 ,208,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,3,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,212,0,0,0 ,207,0,0,0 ,212,0,0,0 ,212,0,0,0 ,1,50,33,0 ,211,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,129,112,33,0 ,129,113,33,0 ,129,114,33,0 ,129,115,33,0 ,129,116,33,0 ,129,117,33,0 ,129,118,33,0 ,129,119,33,0 ,129,120,33,0 ,129,121,33,0 ,129,122,33,0 ,129,123,33,0 ,129,124,33,0 ,129,125,33,0 ,129,126,33,0 ,129,127,33,0 ,129,96,33,0 ,129,97,33,0 ,129,98,33,0 ,129,99,33,0 ,129,100,33,0 ,129,101,33,0 ,129,102,33,0 ,129,103,33,0 ,129,104,33,0 ,129,105,33,0 ,129,106,33,0 ,129,107,33,0 ,129,108,33,0 ,129,109,33,0 ,129,110,33,0 ,129,111,33,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,0,132,33,0 ,1,131,33,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,162,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,207,0,0,0 ,207,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,207,0,0,0 ,212,0,0,0 ,212,0,0,0 ,207,0,0,0 ,212,0,0,0 ,212,0,0,0 ,207,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,207,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,207,0,0,0 ,207,0,0,0 ,212,0,0,0 ,212,0,0,0 ,207,0,0,0 ,212,0,0,0 ,207,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 }; const unsigned char ecl_ucd_page_table_34[] = { 207,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,208,0,0,0 ,204,0,0,0 ,205,0,0,0 ,207,0,0,0 ,208,0,0,0 ,208,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,207,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,207,0,0,0 ,208,0,0,0 ,207,0,0,0 ,208,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,208,0,0,0 ,207,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,208,0,0,0 ,208,0,0,0 ,207,0,0,0 ,208,0,0,0 ,207,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,207,0,0,0 ,207,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,207,0,0,0 ,207,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,208,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,208,0,0,0 ,208,0,0,0 ,207,0,0,0 ,207,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,208,0,0,0 ,208,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,207,0,0,0 ,207,0,0,0 ,208,0,0,0 ,208,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,207,0,0,0 ,207,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 }; const unsigned char ecl_ucd_page_table_35[] = { 212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,208,0,0,0 ,208,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,196,0,0,0 ,183,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,212,0,0,0 ,207,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,211,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 }; const unsigned char ecl_ucd_page_table_36[] = { 212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,164,0,0,0 ,165,0,0,0 ,166,0,0,0 ,167,0,0,0 ,168,0,0,0 ,169,0,0,0 ,170,0,0,0 ,171,0,0,0 ,172,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,164,0,0,0 ,165,0,0,0 ,166,0,0,0 ,167,0,0,0 ,168,0,0,0 ,169,0,0,0 ,170,0,0,0 ,171,0,0,0 ,172,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,143,0,0,0 ,144,0,0,0 ,145,0,0,0 ,146,0,0,0 ,147,0,0,0 ,148,0,0,0 ,149,0,0,0 ,150,0,0,0 ,151,0,0,0 ,141,0,0,0 ,141,0,0,0 ,141,0,0,0 ,141,0,0,0 ,141,0,0,0 ,141,0,0,0 ,141,0,0,0 ,141,0,0,0 ,141,0,0,0 ,141,0,0,0 ,141,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,208,36,0 ,211,209,36,0 ,211,210,36,0 ,211,211,36,0 ,211,212,36,0 ,211,213,36,0 ,211,214,36,0 ,211,215,36,0 ,211,216,36,0 ,211,217,36,0 ,211,218,36,0 ,211,219,36,0 ,211,220,36,0 ,211,221,36,0 ,211,222,36,0 ,211,223,36,0 ,211,224,36,0 ,211,225,36,0 ,211,226,36,0 ,211,227,36,0 ,211,228,36,0 ,211,229,36,0 ,211,230,36,0 ,211,231,36,0 ,211,232,36,0 ,211,233,36,0 ,211,182,36,0 ,211,183,36,0 ,211,184,36,0 ,211,185,36,0 ,211,186,36,0 ,211,187,36,0 ,211,188,36,0 ,211,189,36,0 ,211,190,36,0 ,211,191,36,0 ,211,192,36,0 ,211,193,36,0 ,211,194,36,0 ,211,195,36,0 ,211,196,36,0 ,211,197,36,0 ,211,198,36,0 ,211,199,36,0 ,211,200,36,0 ,211,201,36,0 ,211,202,36,0 ,211,203,36,0 ,211,204,36,0 ,211,205,36,0 ,211,206,36,0 ,211,207,36,0 ,163,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,164,0,0,0 ,165,0,0,0 ,166,0,0,0 ,167,0,0,0 ,168,0,0,0 ,169,0,0,0 ,170,0,0,0 ,171,0,0,0 ,172,0,0,0 ,162,0,0,0 ,163,0,0,0 }; const unsigned char ecl_ucd_page_table_37[] = { 212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,207,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,207,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 }; const unsigned char ecl_ucd_page_table_38[] = { 212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,207,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,211,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 }; const unsigned char ecl_ucd_page_table_39[] = { 216,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,196,0,0,0 ,183,0,0,0 ,196,0,0,0 ,183,0,0,0 ,196,0,0,0 ,183,0,0,0 ,196,0,0,0 ,183,0,0,0 ,196,0,0,0 ,183,0,0,0 ,196,0,0,0 ,183,0,0,0 ,196,0,0,0 ,183,0,0,0 ,164,0,0,0 ,165,0,0,0 ,166,0,0,0 ,167,0,0,0 ,168,0,0,0 ,169,0,0,0 ,170,0,0,0 ,171,0,0,0 ,172,0,0,0 ,162,0,0,0 ,164,0,0,0 ,165,0,0,0 ,166,0,0,0 ,167,0,0,0 ,168,0,0,0 ,169,0,0,0 ,170,0,0,0 ,171,0,0,0 ,172,0,0,0 ,162,0,0,0 ,164,0,0,0 ,165,0,0,0 ,166,0,0,0 ,167,0,0,0 ,168,0,0,0 ,169,0,0,0 ,170,0,0,0 ,171,0,0,0 ,172,0,0,0 ,162,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,208,0,0,0 ,207,0,0,0 ,207,0,0,0 ,208,0,0,0 ,208,0,0,0 ,196,0,0,0 ,183,0,0,0 ,207,0,0,0 ,208,0,0,0 ,208,0,0,0 ,207,0,0,0 ,216,0,0,0 ,208,0,0,0 ,216,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,196,0,0,0 ,183,0,0,0 ,196,0,0,0 ,183,0,0,0 ,196,0,0,0 ,183,0,0,0 ,196,0,0,0 ,183,0,0,0 ,196,0,0,0 ,183,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 }; const unsigned char ecl_ucd_page_table_40[] = { 211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 }; const unsigned char ecl_ucd_page_table_41[] = { 207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,196,0,0,0 ,183,0,0,0 ,196,0,0,0 ,183,0,0,0 ,196,0,0,0 ,183,0,0,0 ,196,0,0,0 ,183,0,0,0 ,196,0,0,0 ,183,0,0,0 ,196,0,0,0 ,183,0,0,0 ,196,0,0,0 ,183,0,0,0 ,196,0,0,0 ,183,0,0,0 ,196,0,0,0 ,183,0,0,0 ,196,0,0,0 ,183,0,0,0 ,196,0,0,0 ,183,0,0,0 ,207,0,0,0 ,207,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,208,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,208,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,207,0,0,0 ,208,0,0,0 ,208,0,0,0 ,207,0,0,0 ,207,0,0,0 ,196,0,0,0 ,183,0,0,0 ,196,0,0,0 ,183,0,0,0 ,208,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,208,0,0,0 ,207,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,207,0,0,0 ,207,0,0,0 ,208,0,0,0 ,208,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,207,0,0,0 ,207,0,0,0 ,196,0,0,0 ,183,0,0,0 ,207,0,0,0 ,207,0,0,0 }; const unsigned char ecl_ucd_page_table_42[] = { 207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,207,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,207,0,0,0 ,207,0,0,0 ,208,0,0,0 ,207,0,0,0 ,208,0,0,0 ,207,0,0,0 ,207,0,0,0 ,208,0,0,0 ,207,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,208,0,0,0 ,208,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,208,0,0,0 ,208,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,208,0,0,0 ,208,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,207,0,0,0 ,208,0,0,0 ,208,0,0,0 ,207,0,0,0 ,207,0,0,0 ,208,0,0,0 ,208,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,207,0,0,0 ,207,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,207,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,208,0,0,0 ,207,0,0,0 ,208,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,208,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,208,0,0,0 ,207,0,0,0 ,208,0,0,0 ,207,0,0,0 ,207,0,0,0 }; const unsigned char ecl_ucd_page_table_43[] = { 212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,212,0,0,0 ,212,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 }; const unsigned char ecl_ucd_page_table_44[] = { 0,48,44,0 ,0,49,44,0 ,0,50,44,0 ,0,51,44,0 ,0,52,44,0 ,0,53,44,0 ,0,54,44,0 ,0,55,44,0 ,0,56,44,0 ,0,57,44,0 ,0,58,44,0 ,0,59,44,0 ,0,60,44,0 ,0,61,44,0 ,0,62,44,0 ,0,63,44,0 ,0,64,44,0 ,0,65,44,0 ,0,66,44,0 ,0,67,44,0 ,0,68,44,0 ,0,69,44,0 ,0,70,44,0 ,0,71,44,0 ,0,72,44,0 ,0,73,44,0 ,0,74,44,0 ,0,75,44,0 ,0,76,44,0 ,0,77,44,0 ,0,78,44,0 ,0,79,44,0 ,0,80,44,0 ,0,81,44,0 ,0,82,44,0 ,0,83,44,0 ,0,84,44,0 ,0,85,44,0 ,0,86,44,0 ,0,87,44,0 ,0,88,44,0 ,0,89,44,0 ,0,90,44,0 ,0,91,44,0 ,0,92,44,0 ,0,93,44,0 ,0,94,44,0 ,216,0,0,0 ,1,0,44,0 ,1,1,44,0 ,1,2,44,0 ,1,3,44,0 ,1,4,44,0 ,1,5,44,0 ,1,6,44,0 ,1,7,44,0 ,1,8,44,0 ,1,9,44,0 ,1,10,44,0 ,1,11,44,0 ,1,12,44,0 ,1,13,44,0 ,1,14,44,0 ,1,15,44,0 ,1,16,44,0 ,1,17,44,0 ,1,18,44,0 ,1,19,44,0 ,1,20,44,0 ,1,21,44,0 ,1,22,44,0 ,1,23,44,0 ,1,24,44,0 ,1,25,44,0 ,1,26,44,0 ,1,27,44,0 ,1,28,44,0 ,1,29,44,0 ,1,30,44,0 ,1,31,44,0 ,1,32,44,0 ,1,33,44,0 ,1,34,44,0 ,1,35,44,0 ,1,36,44,0 ,1,37,44,0 ,1,38,44,0 ,1,39,44,0 ,1,40,44,0 ,1,41,44,0 ,1,42,44,0 ,1,43,44,0 ,1,44,44,0 ,1,45,44,0 ,1,46,44,0 ,216,0,0,0 ,0,97,44,0 ,1,96,44,0 ,0,107,2,0 ,0,125,29,0 ,0,125,2,0 ,1,58,2,0 ,1,62,2,0 ,0,104,44,0 ,1,103,44,0 ,0,106,44,0 ,1,105,44,0 ,0,108,44,0 ,1,107,44,0 ,0,81,2,0 ,0,113,2,0 ,0,80,2,0 ,0,82,2,0 ,4,0,0,0 ,0,115,44,0 ,1,114,44,0 ,4,0,0,0 ,0,118,44,0 ,1,117,44,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,7,0,0,0 ,0,63,2,0 ,0,64,2,0 ,0,129,44,0 ,1,128,44,0 ,0,131,44,0 ,1,130,44,0 ,0,133,44,0 ,1,132,44,0 ,0,135,44,0 ,1,134,44,0 ,0,137,44,0 ,1,136,44,0 ,0,139,44,0 ,1,138,44,0 ,0,141,44,0 ,1,140,44,0 ,0,143,44,0 ,1,142,44,0 ,0,145,44,0 ,1,144,44,0 ,0,147,44,0 ,1,146,44,0 ,0,149,44,0 ,1,148,44,0 ,0,151,44,0 ,1,150,44,0 ,0,153,44,0 ,1,152,44,0 ,0,155,44,0 ,1,154,44,0 ,0,157,44,0 ,1,156,44,0 ,0,159,44,0 ,1,158,44,0 ,0,161,44,0 ,1,160,44,0 ,0,163,44,0 ,1,162,44,0 ,0,165,44,0 ,1,164,44,0 ,0,167,44,0 ,1,166,44,0 ,0,169,44,0 ,1,168,44,0 ,0,171,44,0 ,1,170,44,0 ,0,173,44,0 ,1,172,44,0 ,0,175,44,0 ,1,174,44,0 ,0,177,44,0 ,1,176,44,0 ,0,179,44,0 ,1,178,44,0 ,0,181,44,0 ,1,180,44,0 ,0,183,44,0 ,1,182,44,0 ,0,185,44,0 ,1,184,44,0 ,0,187,44,0 ,1,186,44,0 ,0,189,44,0 ,1,188,44,0 ,0,191,44,0 ,1,190,44,0 ,0,193,44,0 ,1,192,44,0 ,0,195,44,0 ,1,194,44,0 ,0,197,44,0 ,1,196,44,0 ,0,199,44,0 ,1,198,44,0 ,0,201,44,0 ,1,200,44,0 ,0,203,44,0 ,1,202,44,0 ,0,205,44,0 ,1,204,44,0 ,0,207,44,0 ,1,206,44,0 ,0,209,44,0 ,1,208,44,0 ,0,211,44,0 ,1,210,44,0 ,0,213,44,0 ,1,212,44,0 ,0,215,44,0 ,1,214,44,0 ,0,217,44,0 ,1,216,44,0 ,0,219,44,0 ,1,218,44,0 ,0,221,44,0 ,1,220,44,0 ,0,223,44,0 ,1,222,44,0 ,0,225,44,0 ,1,224,44,0 ,0,227,44,0 ,1,226,44,0 ,4,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,0,236,44,0 ,1,235,44,0 ,0,238,44,0 ,1,237,44,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,193,0,0,0 ,193,0,0,0 ,193,0,0,0 ,193,0,0,0 ,162,0,0,0 ,193,0,0,0 ,193,0,0,0 }; const unsigned char ecl_ucd_page_table_45[] = { 1,160,16,0 ,1,161,16,0 ,1,162,16,0 ,1,163,16,0 ,1,164,16,0 ,1,165,16,0 ,1,166,16,0 ,1,167,16,0 ,1,168,16,0 ,1,169,16,0 ,1,170,16,0 ,1,171,16,0 ,1,172,16,0 ,1,173,16,0 ,1,174,16,0 ,1,175,16,0 ,1,176,16,0 ,1,177,16,0 ,1,178,16,0 ,1,179,16,0 ,1,180,16,0 ,1,181,16,0 ,1,182,16,0 ,1,183,16,0 ,1,184,16,0 ,1,185,16,0 ,1,186,16,0 ,1,187,16,0 ,1,188,16,0 ,1,189,16,0 ,1,190,16,0 ,1,191,16,0 ,1,192,16,0 ,1,193,16,0 ,1,194,16,0 ,1,195,16,0 ,1,196,16,0 ,1,197,16,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,7,0,0,0 ,192,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,39,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 }; const unsigned char ecl_ucd_page_table_46[] = { 193,0,0,0 ,193,0,0,0 ,187,0,0,0 ,185,0,0,0 ,187,0,0,0 ,185,0,0,0 ,193,0,0,0 ,193,0,0,0 ,193,0,0,0 ,187,0,0,0 ,185,0,0,0 ,193,0,0,0 ,187,0,0,0 ,185,0,0,0 ,193,0,0,0 ,193,0,0,0 ,193,0,0,0 ,193,0,0,0 ,193,0,0,0 ,193,0,0,0 ,193,0,0,0 ,193,0,0,0 ,193,0,0,0 ,180,0,0,0 ,193,0,0,0 ,193,0,0,0 ,180,0,0,0 ,193,0,0,0 ,187,0,0,0 ,185,0,0,0 ,193,0,0,0 ,193,0,0,0 ,187,0,0,0 ,185,0,0,0 ,196,0,0,0 ,183,0,0,0 ,196,0,0,0 ,183,0,0,0 ,196,0,0,0 ,183,0,0,0 ,196,0,0,0 ,183,0,0,0 ,193,0,0,0 ,193,0,0,0 ,193,0,0,0 ,193,0,0,0 ,193,0,0,0 ,8,0,0,0 ,193,0,0,0 ,193,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,216,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 }; const unsigned char ecl_ucd_page_table_47[] = { 212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 }; ecl-16.1.2/src/c/unicode/ucd-0048.c000066400000000000000000001253501266352375300163350ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ const unsigned char ecl_ucd_page_table_48[] = { 216,0,0,0 ,193,0,0,0 ,193,0,0,0 ,193,0,0,0 ,212,0,0,0 ,7,0,0,0 ,11,0,0,0 ,129,0,0,0 ,196,0,0,0 ,183,0,0,0 ,196,0,0,0 ,183,0,0,0 ,196,0,0,0 ,183,0,0,0 ,196,0,0,0 ,183,0,0,0 ,196,0,0,0 ,183,0,0,0 ,212,0,0,0 ,212,0,0,0 ,196,0,0,0 ,183,0,0,0 ,196,0,0,0 ,183,0,0,0 ,196,0,0,0 ,183,0,0,0 ,196,0,0,0 ,183,0,0,0 ,180,0,0,0 ,195,0,0,0 ,182,0,0,0 ,182,0,0,0 ,212,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,79,0,0,0 ,83,0,0,0 ,85,0,0,0 ,81,0,0,0 ,82,0,0,0 ,82,0,0,0 ,180,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,212,0,0,0 ,212,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,7,0,0,0 ,11,0,0,0 ,193,0,0,0 ,212,0,0,0 ,212,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,38,0,0,0 ,38,0,0,0 ,201,0,0,0 ,201,0,0,0 ,7,0,0,0 ,7,0,0,0 ,11,0,0,0 ,180,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,193,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,11,0,0,0 }; const unsigned char ecl_ucd_page_table_49[] = { 216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,211,0,0,0 ,211,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 }; const unsigned char ecl_ucd_page_table_50[] = { 211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,212,0,0,0 ,212,0,0,0 ,216,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,212,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,211,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,216,0,0,0 }; const unsigned char ecl_ucd_page_table_51[] = { 211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,212,0,0,0 ,212,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,212,0,0,0 }; const unsigned char ecl_ucd_page_table_52[] = { 11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 }; const unsigned char ecl_ucd_page_table_53[] = { 11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 }; const unsigned char ecl_ucd_page_table_54[] = { 11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,7,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 }; const unsigned char ecl_ucd_page_table_55[] = { 11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,7,0,0,0 ,192,0,0,0 ,192,0,0,0 }; const unsigned char ecl_ucd_page_table_56[] = { 11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,7,0,0,0 ,193,0,0,0 ,193,0,0,0 ,193,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,109,0,0,0 ,110,0,0,0 ,111,0,0,0 ,112,0,0,0 ,113,0,0,0 ,114,0,0,0 ,115,0,0,0 ,116,0,0,0 ,117,0,0,0 ,118,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,0,65,166,0 ,1,64,166,0 ,0,67,166,0 ,1,66,166,0 ,0,69,166,0 ,1,68,166,0 ,0,71,166,0 ,1,70,166,0 ,0,73,166,0 ,1,72,166,0 ,0,75,166,0 ,1,74,166,0 ,0,77,166,0 ,1,76,166,0 ,0,79,166,0 ,1,78,166,0 ,0,81,166,0 ,1,80,166,0 ,0,83,166,0 ,1,82,166,0 ,0,85,166,0 ,1,84,166,0 ,0,87,166,0 ,1,86,166,0 ,0,89,166,0 ,1,88,166,0 ,0,91,166,0 ,1,90,166,0 ,0,93,166,0 ,1,92,166,0 ,0,95,166,0 ,1,94,166,0 ,0,97,166,0 ,1,96,166,0 ,0,99,166,0 ,1,98,166,0 ,0,101,166,0 ,1,100,166,0 ,0,103,166,0 ,1,102,166,0 ,0,105,166,0 ,1,104,166,0 ,0,107,166,0 ,1,106,166,0 ,0,109,166,0 ,1,108,166,0 ,11,0,0,0 ,84,0,0,0 ,33,0,0,0 ,33,0,0,0 ,33,0,0,0 ,193,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,84,0,0,0 ,84,0,0,0 ,193,0,0,0 ,8,0,0,0 ,0,129,166,0 ,1,128,166,0 ,0,131,166,0 ,1,130,166,0 ,0,133,166,0 ,1,132,166,0 ,0,135,166,0 ,1,134,166,0 ,0,137,166,0 ,1,136,166,0 ,0,139,166,0 ,1,138,166,0 ,0,141,166,0 ,1,140,166,0 ,0,143,166,0 ,1,142,166,0 ,0,145,166,0 ,1,144,166,0 ,0,147,166,0 ,1,146,166,0 ,0,149,166,0 ,1,148,166,0 ,0,151,166,0 ,1,150,166,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,84,0,0,0 ,84,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 }; const unsigned char ecl_ucd_page_table_57[] = { 201,0,0,0 ,201,0,0,0 ,201,0,0,0 ,201,0,0,0 ,201,0,0,0 ,201,0,0,0 ,201,0,0,0 ,201,0,0,0 ,201,0,0,0 ,201,0,0,0 ,201,0,0,0 ,201,0,0,0 ,201,0,0,0 ,201,0,0,0 ,201,0,0,0 ,201,0,0,0 ,201,0,0,0 ,201,0,0,0 ,201,0,0,0 ,201,0,0,0 ,201,0,0,0 ,201,0,0,0 ,201,0,0,0 ,8,0,0,0 ,8,0,0,0 ,8,0,0,0 ,8,0,0,0 ,8,0,0,0 ,8,0,0,0 ,8,0,0,0 ,8,0,0,0 ,8,0,0,0 ,201,0,0,0 ,201,0,0,0 ,0,35,167,0 ,1,34,167,0 ,0,37,167,0 ,1,36,167,0 ,0,39,167,0 ,1,38,167,0 ,0,41,167,0 ,1,40,167,0 ,0,43,167,0 ,1,42,167,0 ,0,45,167,0 ,1,44,167,0 ,0,47,167,0 ,1,46,167,0 ,4,0,0,0 ,4,0,0,0 ,0,51,167,0 ,1,50,167,0 ,0,53,167,0 ,1,52,167,0 ,0,55,167,0 ,1,54,167,0 ,0,57,167,0 ,1,56,167,0 ,0,59,167,0 ,1,58,167,0 ,0,61,167,0 ,1,60,167,0 ,0,63,167,0 ,1,62,167,0 ,0,65,167,0 ,1,64,167,0 ,0,67,167,0 ,1,66,167,0 ,0,69,167,0 ,1,68,167,0 ,0,71,167,0 ,1,70,167,0 ,0,73,167,0 ,1,72,167,0 ,0,75,167,0 ,1,74,167,0 ,0,77,167,0 ,1,76,167,0 ,0,79,167,0 ,1,78,167,0 ,0,81,167,0 ,1,80,167,0 ,0,83,167,0 ,1,82,167,0 ,0,85,167,0 ,1,84,167,0 ,0,87,167,0 ,1,86,167,0 ,0,89,167,0 ,1,88,167,0 ,0,91,167,0 ,1,90,167,0 ,0,93,167,0 ,1,92,167,0 ,0,95,167,0 ,1,94,167,0 ,0,97,167,0 ,1,96,167,0 ,0,99,167,0 ,1,98,167,0 ,0,101,167,0 ,1,100,167,0 ,0,103,167,0 ,1,102,167,0 ,0,105,167,0 ,1,104,167,0 ,0,107,167,0 ,1,106,167,0 ,0,109,167,0 ,1,108,167,0 ,0,111,167,0 ,1,110,167,0 ,7,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,0,122,167,0 ,1,121,167,0 ,0,124,167,0 ,1,123,167,0 ,0,121,29,0 ,0,127,167,0 ,1,126,167,0 ,0,129,167,0 ,1,128,167,0 ,0,131,167,0 ,1,130,167,0 ,0,133,167,0 ,1,132,167,0 ,0,135,167,0 ,1,134,167,0 ,8,0,0,0 ,200,0,0,0 ,200,0,0,0 ,0,140,167,0 ,1,139,167,0 ,0,101,2,0 ,4,0,0,0 ,216,0,0,0 ,0,145,167,0 ,1,144,167,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,0,161,167,0 ,1,160,167,0 ,0,163,167,0 ,1,162,167,0 ,0,165,167,0 ,1,164,167,0 ,0,167,167,0 ,1,166,167,0 ,0,169,167,0 ,1,168,167,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,4,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 }; const unsigned char ecl_ucd_page_table_58[] = { 11,0,0,0 ,11,0,0,0 ,35,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,39,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,35,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,29,0,0,0 ,29,0,0,0 ,35,0,0,0 ,35,0,0,0 ,29,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,211,0,0,0 ,211,0,0,0 ,198,0,0,0 ,210,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,193,0,0,0 ,193,0,0,0 ,193,0,0,0 ,193,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,29,0,0,0 ,29,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,39,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,192,0,0,0 ,192,0,0,0 ,109,0,0,0 ,110,0,0,0 ,111,0,0,0 ,112,0,0,0 ,113,0,0,0 ,114,0,0,0 ,115,0,0,0 ,116,0,0,0 ,117,0,0,0 ,118,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 }; const unsigned char ecl_ucd_page_table_59[] = { 109,0,0,0 ,110,0,0,0 ,111,0,0,0 ,112,0,0,0 ,113,0,0,0 ,114,0,0,0 ,115,0,0,0 ,116,0,0,0 ,117,0,0,0 ,118,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,80,0,0,0 ,80,0,0,0 ,80,0,0,0 ,192,0,0,0 ,192,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,29,0,0,0 ,30,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,192,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,29,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,37,0,0,0 ,29,0,0,0 ,29,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,29,0,0,0 ,29,0,0,0 ,35,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,30,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,216,0,0,0 ,7,0,0,0 ,109,0,0,0 ,110,0,0,0 ,111,0,0,0 ,112,0,0,0 ,113,0,0,0 ,114,0,0,0 ,115,0,0,0 ,116,0,0,0 ,117,0,0,0 ,118,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,192,0,0,0 ,192,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 }; const unsigned char ecl_ucd_page_table_60[] = { 11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,29,0,0,0 ,29,0,0,0 ,35,0,0,0 ,35,0,0,0 ,29,0,0,0 ,29,0,0,0 ,35,0,0,0 ,35,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,35,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,35,0,0,0 ,29,0,0,0 ,216,0,0,0 ,216,0,0,0 ,109,0,0,0 ,110,0,0,0 ,111,0,0,0 ,112,0,0,0 ,113,0,0,0 ,114,0,0,0 ,115,0,0,0 ,116,0,0,0 ,117,0,0,0 ,118,0,0,0 ,216,0,0,0 ,216,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,7,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,11,0,0,0 ,29,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,84,0,0,0 ,11,0,0,0 ,84,0,0,0 ,84,0,0,0 ,80,0,0,0 ,11,0,0,0 ,11,0,0,0 ,84,0,0,0 ,84,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,84,0,0,0 ,84,0,0,0 ,11,0,0,0 ,84,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,7,0,0,0 ,192,0,0,0 ,192,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 }; const unsigned char ecl_ucd_page_table_61[] = { 216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,29,0,0,0 ,29,0,0,0 ,35,0,0,0 ,29,0,0,0 ,29,0,0,0 ,35,0,0,0 ,29,0,0,0 ,29,0,0,0 ,192,0,0,0 ,29,0,0,0 ,39,0,0,0 ,216,0,0,0 ,216,0,0,0 ,109,0,0,0 ,110,0,0,0 ,111,0,0,0 ,112,0,0,0 ,113,0,0,0 ,114,0,0,0 ,115,0,0,0 ,116,0,0,0 ,117,0,0,0 ,118,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 }; const unsigned char ecl_ucd_page_table_62[] = { 11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 }; const unsigned char ecl_ucd_page_table_63[] = { 28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 ,28,0,0,0 }; ecl-16.1.2/src/c/unicode/ucd-0064.c000066400000000000000000001253321266352375300163330ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ const unsigned char ecl_ucd_page_table_64[] = { 27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 }; const unsigned char ecl_ucd_page_table_65[] = { 11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 }; const unsigned char ecl_ucd_page_table_66[] = { 4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,12,0,0,0 ,56,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,204,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,216,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,216,0,0,0 ,12,0,0,0 ,216,0,0,0 ,12,0,0,0 ,12,0,0,0 ,216,0,0,0 ,12,0,0,0 ,12,0,0,0 ,216,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,199,0,0,0 ,199,0,0,0 ,199,0,0,0 ,199,0,0,0 ,199,0,0,0 ,199,0,0,0 ,199,0,0,0 ,199,0,0,0 ,199,0,0,0 ,199,0,0,0 ,199,0,0,0 ,199,0,0,0 ,199,0,0,0 ,199,0,0,0 ,199,0,0,0 ,199,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 }; const unsigned char ecl_ucd_page_table_67[] = { 10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 }; const unsigned char ecl_ucd_page_table_68[] = { 10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,195,0,0,0 ,182,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,216,0,0,0 ,216,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,197,0,0,0 ,212,0,0,0 ,216,0,0,0 ,216,0,0,0 }; const unsigned char ecl_ucd_page_table_69[] = { 35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,193,0,0,0 ,193,0,0,0 ,193,0,0,0 ,193,0,0,0 ,193,0,0,0 ,193,0,0,0 ,193,0,0,0 ,195,0,0,0 ,182,0,0,0 ,193,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,193,0,0,0 ,180,0,0,0 ,180,0,0,0 ,178,0,0,0 ,178,0,0,0 ,195,0,0,0 ,182,0,0,0 ,195,0,0,0 ,182,0,0,0 ,195,0,0,0 ,182,0,0,0 ,195,0,0,0 ,182,0,0,0 ,195,0,0,0 ,182,0,0,0 ,195,0,0,0 ,182,0,0,0 ,195,0,0,0 ,182,0,0,0 ,195,0,0,0 ,182,0,0,0 ,193,0,0,0 ,193,0,0,0 ,195,0,0,0 ,182,0,0,0 ,193,0,0,0 ,193,0,0,0 ,193,0,0,0 ,193,0,0,0 ,178,0,0,0 ,178,0,0,0 ,178,0,0,0 ,190,0,0,0 ,193,0,0,0 ,190,0,0,0 ,216,0,0,0 ,193,0,0,0 ,190,0,0,0 ,193,0,0,0 ,193,0,0,0 ,180,0,0,0 ,196,0,0,0 ,183,0,0,0 ,196,0,0,0 ,183,0,0,0 ,196,0,0,0 ,183,0,0,0 ,191,0,0,0 ,193,0,0,0 ,193,0,0,0 ,204,0,0,0 ,179,0,0,0 ,208,0,0,0 ,208,0,0,0 ,207,0,0,0 ,216,0,0,0 ,193,0,0,0 ,198,0,0,0 ,191,0,0,0 ,193,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,216,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,10,0,0,0 ,216,0,0,0 ,216,0,0,0 ,18,0,0,0 }; const unsigned char ecl_ucd_page_table_70[] = { 216,0,0,0 ,193,0,0,0 ,193,0,0,0 ,191,0,0,0 ,198,0,0,0 ,191,0,0,0 ,193,0,0,0 ,193,0,0,0 ,196,0,0,0 ,183,0,0,0 ,193,0,0,0 ,204,0,0,0 ,190,0,0,0 ,179,0,0,0 ,190,0,0,0 ,190,0,0,0 ,99,0,0,0 ,100,0,0,0 ,101,0,0,0 ,102,0,0,0 ,103,0,0,0 ,104,0,0,0 ,105,0,0,0 ,106,0,0,0 ,107,0,0,0 ,108,0,0,0 ,190,0,0,0 ,193,0,0,0 ,208,0,0,0 ,207,0,0,0 ,208,0,0,0 ,193,0,0,0 ,193,0,0,0 ,0,65,255,0 ,0,66,255,0 ,0,67,255,0 ,0,68,255,0 ,0,69,255,0 ,0,70,255,0 ,0,71,255,0 ,0,72,255,0 ,0,73,255,0 ,0,74,255,0 ,0,75,255,0 ,0,76,255,0 ,0,77,255,0 ,0,78,255,0 ,0,79,255,0 ,0,80,255,0 ,0,81,255,0 ,0,82,255,0 ,0,83,255,0 ,0,84,255,0 ,0,85,255,0 ,0,86,255,0 ,0,87,255,0 ,0,88,255,0 ,0,89,255,0 ,0,90,255,0 ,196,0,0,0 ,193,0,0,0 ,183,0,0,0 ,201,0,0,0 ,178,0,0,0 ,201,0,0,0 ,1,33,255,0 ,1,34,255,0 ,1,35,255,0 ,1,36,255,0 ,1,37,255,0 ,1,38,255,0 ,1,39,255,0 ,1,40,255,0 ,1,41,255,0 ,1,42,255,0 ,1,43,255,0 ,1,44,255,0 ,1,45,255,0 ,1,46,255,0 ,1,47,255,0 ,1,48,255,0 ,1,49,255,0 ,1,50,255,0 ,1,51,255,0 ,1,52,255,0 ,1,53,255,0 ,1,54,255,0 ,1,55,255,0 ,1,56,255,0 ,1,57,255,0 ,1,58,255,0 ,196,0,0,0 ,207,0,0,0 ,183,0,0,0 ,207,0,0,0 ,196,0,0,0 ,183,0,0,0 ,193,0,0,0 ,196,0,0,0 ,183,0,0,0 ,193,0,0,0 ,193,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,7,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,7,0,0,0 ,7,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,198,0,0,0 ,198,0,0,0 ,207,0,0,0 ,201,0,0,0 ,212,0,0,0 ,198,0,0,0 ,198,0,0,0 ,216,0,0,0 ,212,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,207,0,0,0 ,212,0,0,0 ,212,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,22,0,0,0 ,22,0,0,0 ,22,0,0,0 ,212,0,0,0 ,212,0,0,0 ,216,0,0,0 ,216,0,0,0 }; const unsigned char ecl_ucd_page_table_71[] = { 11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 }; const unsigned char ecl_ucd_page_table_72[] = { 192,0,0,0 ,193,0,0,0 ,211,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,130,0,0,0 ,130,0,0,0 ,130,0,0,0 ,130,0,0,0 ,130,0,0,0 ,130,0,0,0 ,130,0,0,0 ,130,0,0,0 ,130,0,0,0 ,130,0,0,0 ,130,0,0,0 ,130,0,0,0 ,130,0,0,0 ,130,0,0,0 ,130,0,0,0 ,130,0,0,0 ,130,0,0,0 ,130,0,0,0 ,130,0,0,0 ,130,0,0,0 ,130,0,0,0 ,130,0,0,0 ,130,0,0,0 ,130,0,0,0 ,130,0,0,0 ,130,0,0,0 ,130,0,0,0 ,130,0,0,0 ,130,0,0,0 ,130,0,0,0 ,130,0,0,0 ,130,0,0,0 ,130,0,0,0 ,130,0,0,0 ,130,0,0,0 ,130,0,0,0 ,130,0,0,0 ,130,0,0,0 ,130,0,0,0 ,130,0,0,0 ,130,0,0,0 ,130,0,0,0 ,130,0,0,0 ,130,0,0,0 ,130,0,0,0 ,130,0,0,0 ,130,0,0,0 ,130,0,0,0 ,130,0,0,0 ,130,0,0,0 ,130,0,0,0 ,130,0,0,0 ,130,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,162,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,80,0,0,0 ,216,0,0,0 ,216,0,0,0 }; const unsigned char ecl_ucd_page_table_73[] = { 216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 }; const unsigned char ecl_ucd_page_table_74[] = { 11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,129,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,129,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,192,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,192,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 }; const unsigned char ecl_ucd_page_table_75[] = { 0,40,4,1 ,0,41,4,1 ,0,42,4,1 ,0,43,4,1 ,0,44,4,1 ,0,45,4,1 ,0,46,4,1 ,0,47,4,1 ,0,48,4,1 ,0,49,4,1 ,0,50,4,1 ,0,51,4,1 ,0,52,4,1 ,0,53,4,1 ,0,54,4,1 ,0,55,4,1 ,0,56,4,1 ,0,57,4,1 ,0,58,4,1 ,0,59,4,1 ,0,60,4,1 ,0,61,4,1 ,0,62,4,1 ,0,63,4,1 ,0,64,4,1 ,0,65,4,1 ,0,66,4,1 ,0,67,4,1 ,0,68,4,1 ,0,69,4,1 ,0,70,4,1 ,0,71,4,1 ,0,72,4,1 ,0,73,4,1 ,0,74,4,1 ,0,75,4,1 ,0,76,4,1 ,0,77,4,1 ,0,78,4,1 ,0,79,4,1 ,1,0,4,1 ,1,1,4,1 ,1,2,4,1 ,1,3,4,1 ,1,4,4,1 ,1,5,4,1 ,1,6,4,1 ,1,7,4,1 ,1,8,4,1 ,1,9,4,1 ,1,10,4,1 ,1,11,4,1 ,1,12,4,1 ,1,13,4,1 ,1,14,4,1 ,1,15,4,1 ,1,16,4,1 ,1,17,4,1 ,1,18,4,1 ,1,19,4,1 ,1,20,4,1 ,1,21,4,1 ,1,22,4,1 ,1,23,4,1 ,1,24,4,1 ,1,25,4,1 ,1,26,4,1 ,1,27,4,1 ,1,28,4,1 ,1,29,4,1 ,1,30,4,1 ,1,31,4,1 ,1,32,4,1 ,1,33,4,1 ,1,34,4,1 ,1,35,4,1 ,1,36,4,1 ,1,37,4,1 ,1,38,4,1 ,1,39,4,1 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,109,0,0,0 ,110,0,0,0 ,111,0,0,0 ,112,0,0,0 ,113,0,0,0 ,114,0,0,0 ,115,0,0,0 ,116,0,0,0 ,117,0,0,0 ,118,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 }; const unsigned char ecl_ucd_page_table_76[] = { 12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,216,0,0,0 ,216,0,0,0 ,12,0,0,0 ,216,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,216,0,0,0 ,12,0,0,0 ,12,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,12,0,0,0 ,216,0,0,0 ,216,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,216,0,0,0 ,194,0,0,0 ,173,0,0,0 ,173,0,0,0 ,173,0,0,0 ,173,0,0,0 ,173,0,0,0 ,173,0,0,0 ,173,0,0,0 ,173,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 }; const unsigned char ecl_ucd_page_table_77[] = { 12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,173,0,0,0 ,173,0,0,0 ,173,0,0,0 ,173,0,0,0 ,173,0,0,0 ,173,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,193,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,194,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 }; const unsigned char ecl_ucd_page_table_78[] = { 12,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,216,0,0,0 ,35,0,0,0 ,35,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,35,0,0,0 ,80,0,0,0 ,35,0,0,0 ,84,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,216,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,216,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,84,0,0,0 ,36,0,0,0 ,80,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,39,0,0,0 ,174,0,0,0 ,175,0,0,0 ,176,0,0,0 ,177,0,0,0 ,173,0,0,0 ,173,0,0,0 ,173,0,0,0 ,173,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,194,0,0,0 ,194,0,0,0 ,194,0,0,0 ,194,0,0,0 ,194,0,0,0 ,194,0,0,0 ,194,0,0,0 ,194,0,0,0 ,194,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,173,0,0,0 ,173,0,0,0 ,194,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 }; const unsigned char ecl_ucd_page_table_79[] = { 12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,193,0,0,0 ,193,0,0,0 ,193,0,0,0 ,193,0,0,0 ,193,0,0,0 ,193,0,0,0 ,193,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,216,0,0,0 ,216,0,0,0 ,173,0,0,0 ,173,0,0,0 ,173,0,0,0 ,173,0,0,0 ,173,0,0,0 ,173,0,0,0 ,173,0,0,0 ,173,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,173,0,0,0 ,173,0,0,0 ,173,0,0,0 ,173,0,0,0 ,173,0,0,0 ,173,0,0,0 ,173,0,0,0 ,173,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 }; ecl-16.1.2/src/c/unicode/ucd-0080.c000066400000000000000000001251731266352375300163340ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ const unsigned char ecl_ucd_page_table_80[] = { 12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,12,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 }; const unsigned char ecl_ucd_page_table_81[] = { 216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,132,0,0,0 ,133,0,0,0 ,134,0,0,0 ,135,0,0,0 ,136,0,0,0 ,137,0,0,0 ,138,0,0,0 ,139,0,0,0 ,140,0,0,0 ,131,0,0,0 ,131,0,0,0 ,131,0,0,0 ,131,0,0,0 ,131,0,0,0 ,131,0,0,0 ,131,0,0,0 ,131,0,0,0 ,131,0,0,0 ,131,0,0,0 ,131,0,0,0 ,131,0,0,0 ,131,0,0,0 ,131,0,0,0 ,131,0,0,0 ,131,0,0,0 ,131,0,0,0 ,131,0,0,0 ,131,0,0,0 ,131,0,0,0 ,131,0,0,0 ,131,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 }; const unsigned char ecl_ucd_page_table_82[] = { 29,0,0,0 ,35,0,0,0 ,29,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,39,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,164,0,0,0 ,165,0,0,0 ,166,0,0,0 ,167,0,0,0 ,168,0,0,0 ,169,0,0,0 ,170,0,0,0 ,171,0,0,0 ,172,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,162,0,0,0 ,109,0,0,0 ,110,0,0,0 ,111,0,0,0 ,112,0,0,0 ,113,0,0,0 ,114,0,0,0 ,115,0,0,0 ,116,0,0,0 ,117,0,0,0 ,118,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,35,0,0,0 ,35,0,0,0 ,29,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,29,0,0,0 ,29,0,0,0 ,29,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,29,0,0,0 ,29,0,0,0 ,39,0,0,0 ,37,0,0,0 ,192,0,0,0 ,192,0,0,0 ,19,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 }; const unsigned char ecl_ucd_page_table_83[] = { 11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 }; const unsigned char ecl_ucd_page_table_84[] = { 129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,129,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,192,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 }; const unsigned char ecl_ucd_page_table_85[] = { 11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 }; const unsigned char ecl_ucd_page_table_86[] = { 11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 }; const unsigned char ecl_ucd_page_table_87[] = { 11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 }; const unsigned char ecl_ucd_page_table_88[] = { 211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 }; const unsigned char ecl_ucd_page_table_89[] = { 211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,216,0,0,0 ,216,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,31,0,0,0 ,31,0,0,0 ,36,0,0,0 ,36,0,0,0 ,36,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,32,0,0,0 ,31,0,0,0 ,31,0,0,0 ,31,0,0,0 ,31,0,0,0 ,31,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,80,0,0,0 ,80,0,0,0 ,80,0,0,0 ,80,0,0,0 ,80,0,0,0 ,80,0,0,0 ,80,0,0,0 ,80,0,0,0 ,211,0,0,0 ,211,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,80,0,0,0 ,80,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 }; const unsigned char ecl_ucd_page_table_90[] = { 212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,84,0,0,0 ,84,0,0,0 ,84,0,0,0 ,212,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 }; const unsigned char ecl_ucd_page_table_91[] = { 212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,152,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 }; const unsigned char ecl_ucd_page_table_92[] = { 3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,216,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,3,0,0,0 ,216,0,0,0 ,3,0,0,0 ,3,0,0,0 ,216,0,0,0 ,216,0,0,0 ,3,0,0,0 ,216,0,0,0 ,216,0,0,0 ,3,0,0,0 ,3,0,0,0 ,216,0,0,0 ,216,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,216,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,216,0,0,0 ,4,0,0,0 ,216,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,216,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 }; const unsigned char ecl_ucd_page_table_93[] = { 4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,3,0,0,0 ,3,0,0,0 ,216,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,216,0,0,0 ,216,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,216,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,216,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,3,0,0,0 ,3,0,0,0 ,216,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,216,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,216,0,0,0 ,3,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,216,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 }; const unsigned char ecl_ucd_page_table_94[] = { 4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,216,0,0,0 ,216,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,206,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,208,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,206,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 }; const unsigned char ecl_ucd_page_table_95[] = { 4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,208,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,206,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,208,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,206,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,208,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,3,0,0,0 ,206,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,208,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,4,0,0,0 ,3,0,0,0 ,4,0,0,0 ,216,0,0,0 ,216,0,0,0 ,99,0,0,0 ,100,0,0,0 ,101,0,0,0 ,102,0,0,0 ,103,0,0,0 ,104,0,0,0 ,105,0,0,0 ,106,0,0,0 ,107,0,0,0 ,108,0,0,0 ,99,0,0,0 ,100,0,0,0 ,101,0,0,0 ,102,0,0,0 ,103,0,0,0 ,104,0,0,0 ,105,0,0,0 ,106,0,0,0 ,107,0,0,0 ,108,0,0,0 ,99,0,0,0 ,100,0,0,0 ,101,0,0,0 ,102,0,0,0 ,103,0,0,0 ,104,0,0,0 ,105,0,0,0 ,106,0,0,0 ,107,0,0,0 ,108,0,0,0 ,99,0,0,0 ,100,0,0,0 ,101,0,0,0 ,102,0,0,0 ,103,0,0,0 ,104,0,0,0 ,105,0,0,0 ,106,0,0,0 ,107,0,0,0 ,108,0,0,0 ,99,0,0,0 ,100,0,0,0 ,101,0,0,0 ,102,0,0,0 ,103,0,0,0 ,104,0,0,0 ,105,0,0,0 ,106,0,0,0 ,107,0,0,0 ,108,0,0,0 }; ecl-16.1.2/src/c/unicode/ucd-0096.c000066400000000000000000001144131266352375300163360ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ const unsigned char ecl_ucd_page_table_96[] = { 212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,216,0,0,0 ,216,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,216,0,0,0 ,216,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,216,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 }; const unsigned char ecl_ucd_page_table_97[] = { 142,0,0,0 ,142,0,0,0 ,143,0,0,0 ,144,0,0,0 ,145,0,0,0 ,146,0,0,0 ,147,0,0,0 ,148,0,0,0 ,149,0,0,0 ,150,0,0,0 ,151,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,216,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 }; const unsigned char ecl_ucd_page_table_98[] = { 211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,211,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,211,0,0,0 ,211,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 }; const unsigned char ecl_ucd_page_table_99[] = { 212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,216,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,216,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 }; const unsigned char ecl_ucd_page_table_100[] = { 212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,216,0,0,0 ,212,0,0,0 ,216,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,211,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,216,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 }; const unsigned char ecl_ucd_page_table_101[] = { 212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,211,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 }; const unsigned char ecl_ucd_page_table_102[] = { 216,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,216,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,216,0,0,0 ,212,0,0,0 ,216,0,0,0 ,212,0,0,0 ,216,0,0,0 ,212,0,0,0 ,216,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,216,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,216,0,0,0 ,216,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,216,0,0,0 ,212,0,0,0 ,216,0,0,0 ,216,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,216,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 }; const unsigned char ecl_ucd_page_table_103[] = { 212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,212,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 }; const unsigned char ecl_ucd_page_table_104[] = { 11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 }; const unsigned char ecl_ucd_page_table_105[] = { 11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 }; const unsigned char ecl_ucd_page_table_106[] = { 11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,11,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 }; const unsigned char ecl_ucd_page_table_107[] = { 216,0,0,0 ,18,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,18,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 }; const unsigned char ecl_ucd_page_table_108[] = { 35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,35,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 ,216,0,0,0 }; const unsigned char ecl_ucd_page_table_109[] = { 27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,27,0,0,0 ,216,0,0,0 ,216,0,0,0 }; ecl-16.1.2/src/c/unicode/ucd.c000066400000000000000000003245511266352375300157500ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ extern const unsigned char ecl_ucd_page_table_0[]; extern const unsigned char ecl_ucd_page_table_1[]; extern const unsigned char ecl_ucd_page_table_2[]; extern const unsigned char ecl_ucd_page_table_3[]; extern const unsigned char ecl_ucd_page_table_4[]; extern const unsigned char ecl_ucd_page_table_5[]; extern const unsigned char ecl_ucd_page_table_6[]; extern const unsigned char ecl_ucd_page_table_7[]; extern const unsigned char ecl_ucd_page_table_8[]; extern const unsigned char ecl_ucd_page_table_9[]; extern const unsigned char ecl_ucd_page_table_10[]; extern const unsigned char ecl_ucd_page_table_11[]; extern const unsigned char ecl_ucd_page_table_12[]; extern const unsigned char ecl_ucd_page_table_13[]; extern const unsigned char ecl_ucd_page_table_14[]; extern const unsigned char ecl_ucd_page_table_15[]; extern const unsigned char ecl_ucd_page_table_16[]; extern const unsigned char ecl_ucd_page_table_17[]; extern const unsigned char ecl_ucd_page_table_18[]; extern const unsigned char ecl_ucd_page_table_19[]; extern const unsigned char ecl_ucd_page_table_20[]; extern const unsigned char ecl_ucd_page_table_21[]; extern const unsigned char ecl_ucd_page_table_22[]; extern const unsigned char ecl_ucd_page_table_23[]; extern const unsigned char ecl_ucd_page_table_24[]; extern const unsigned char ecl_ucd_page_table_25[]; extern const unsigned char ecl_ucd_page_table_26[]; extern const unsigned char ecl_ucd_page_table_27[]; extern const unsigned char ecl_ucd_page_table_28[]; extern const unsigned char ecl_ucd_page_table_29[]; extern const unsigned char ecl_ucd_page_table_30[]; extern const unsigned char ecl_ucd_page_table_31[]; extern const unsigned char ecl_ucd_page_table_32[]; extern const unsigned char ecl_ucd_page_table_33[]; extern const unsigned char ecl_ucd_page_table_34[]; extern const unsigned char ecl_ucd_page_table_35[]; extern const unsigned char ecl_ucd_page_table_36[]; extern const unsigned char ecl_ucd_page_table_37[]; extern const unsigned char ecl_ucd_page_table_38[]; extern const unsigned char ecl_ucd_page_table_39[]; extern const unsigned char ecl_ucd_page_table_40[]; extern const unsigned char ecl_ucd_page_table_41[]; extern const unsigned char ecl_ucd_page_table_42[]; extern const unsigned char ecl_ucd_page_table_43[]; extern const unsigned char ecl_ucd_page_table_44[]; extern const unsigned char ecl_ucd_page_table_45[]; extern const unsigned char ecl_ucd_page_table_46[]; extern const unsigned char ecl_ucd_page_table_47[]; extern const unsigned char ecl_ucd_page_table_48[]; extern const unsigned char ecl_ucd_page_table_49[]; extern const unsigned char ecl_ucd_page_table_50[]; extern const unsigned char ecl_ucd_page_table_51[]; extern const unsigned char ecl_ucd_page_table_52[]; extern const unsigned char ecl_ucd_page_table_53[]; extern const unsigned char ecl_ucd_page_table_54[]; extern const unsigned char ecl_ucd_page_table_55[]; extern const unsigned char ecl_ucd_page_table_56[]; extern const unsigned char ecl_ucd_page_table_57[]; extern const unsigned char ecl_ucd_page_table_58[]; extern const unsigned char ecl_ucd_page_table_59[]; extern const unsigned char ecl_ucd_page_table_60[]; extern const unsigned char ecl_ucd_page_table_61[]; extern const unsigned char ecl_ucd_page_table_62[]; extern const unsigned char ecl_ucd_page_table_63[]; extern const unsigned char ecl_ucd_page_table_64[]; extern const unsigned char ecl_ucd_page_table_65[]; extern const unsigned char ecl_ucd_page_table_66[]; extern const unsigned char ecl_ucd_page_table_67[]; extern const unsigned char ecl_ucd_page_table_68[]; extern const unsigned char ecl_ucd_page_table_69[]; extern const unsigned char ecl_ucd_page_table_70[]; extern const unsigned char ecl_ucd_page_table_71[]; extern const unsigned char ecl_ucd_page_table_72[]; extern const unsigned char ecl_ucd_page_table_73[]; extern const unsigned char ecl_ucd_page_table_74[]; extern const unsigned char ecl_ucd_page_table_75[]; extern const unsigned char ecl_ucd_page_table_76[]; extern const unsigned char ecl_ucd_page_table_77[]; extern const unsigned char ecl_ucd_page_table_78[]; extern const unsigned char ecl_ucd_page_table_79[]; extern const unsigned char ecl_ucd_page_table_80[]; extern const unsigned char ecl_ucd_page_table_81[]; extern const unsigned char ecl_ucd_page_table_82[]; extern const unsigned char ecl_ucd_page_table_83[]; extern const unsigned char ecl_ucd_page_table_84[]; extern const unsigned char ecl_ucd_page_table_85[]; extern const unsigned char ecl_ucd_page_table_86[]; extern const unsigned char ecl_ucd_page_table_87[]; extern const unsigned char ecl_ucd_page_table_88[]; extern const unsigned char ecl_ucd_page_table_89[]; extern const unsigned char ecl_ucd_page_table_90[]; extern const unsigned char ecl_ucd_page_table_91[]; extern const unsigned char ecl_ucd_page_table_92[]; extern const unsigned char ecl_ucd_page_table_93[]; extern const unsigned char ecl_ucd_page_table_94[]; extern const unsigned char ecl_ucd_page_table_95[]; extern const unsigned char ecl_ucd_page_table_96[]; extern const unsigned char ecl_ucd_page_table_97[]; extern const unsigned char ecl_ucd_page_table_98[]; extern const unsigned char ecl_ucd_page_table_99[]; extern const unsigned char ecl_ucd_page_table_100[]; extern const unsigned char ecl_ucd_page_table_101[]; extern const unsigned char ecl_ucd_page_table_102[]; extern const unsigned char ecl_ucd_page_table_103[]; extern const unsigned char ecl_ucd_page_table_104[]; extern const unsigned char ecl_ucd_page_table_105[]; extern const unsigned char ecl_ucd_page_table_106[]; extern const unsigned char ecl_ucd_page_table_107[]; extern const unsigned char ecl_ucd_page_table_108[]; extern const unsigned char ecl_ucd_page_table_109[]; const unsigned char ecl_ucd_misc_table[1736] = { 0, 8, 0, 255, 255, 0, 0, 0 ,1, 8, 0, 255, 255, 0, 0, 0 ,0, 0, 0, 255, 255, 0, 0, 0 ,0, 8, 0, 255, 255, 0, 0, 0 ,1, 8, 0, 255, 255, 0, 0, 0 ,2, 8, 0, 255, 255, 0, 0, 0 ,3, 0, 0, 255, 255, 0, 0, 0 ,3, 8, 0, 255, 255, 0, 0, 0 ,3, 12, 0, 255, 255, 0, 0, 0 ,3, 14, 0, 255, 255, 0, 0, 0 ,4, 0, 0, 255, 255, 0, 0, 0 ,4, 8, 0, 255, 255, 0, 0, 0 ,4, 14, 0, 255, 255, 0, 0, 0 ,5, 2, 0, 255, 255, 0, 0, 0 ,5, 3, 0, 255, 255, 0, 0, 0 ,5, 17, 0, 255, 255, 0, 0, 0 ,5, 18, 0, 255, 255, 0, 0, 0 ,6, 1, 0, 255, 255, 0, 0, 0 ,6, 3, 0, 255, 255, 0, 0, 0 ,6, 8, 0, 255, 255, 0, 0, 0 ,6, 9, 0, 255, 255, 0, 0, 0 ,6, 10, 0, 255, 255, 0, 0, 0 ,6, 12, 0, 255, 255, 0, 0, 0 ,6, 13, 0, 255, 255, 0, 0, 0 ,6, 14, 0, 255, 255, 0, 0, 0 ,6, 15, 0, 255, 255, 0, 0, 0 ,6, 16, 0, 255, 255, 0, 0, 0 ,7, 8, 0, 255, 255, 0, 0, 0 ,8, 8, 0, 255, 255, 0, 0, 0 ,9, 8, 0, 255, 255, 0, 0, 0 ,9, 8, 9, 255, 255, 0, 0, 0 ,9, 8, 216, 255, 255, 0, 0, 0 ,9, 8, 226, 255, 255, 0, 0, 0 ,10, 11, 0, 255, 255, 0, 0, 0 ,11, 8, 0, 255, 255, 0, 0, 0 ,11, 11, 0, 255, 255, 0, 0, 0 ,11, 11, 1, 255, 255, 0, 0, 0 ,11, 11, 7, 255, 255, 0, 0, 0 ,11, 11, 8, 255, 255, 0, 0, 0 ,11, 11, 9, 255, 255, 0, 0, 0 ,11, 11, 10, 255, 255, 0, 0, 0 ,11, 11, 11, 255, 255, 0, 0, 0 ,11, 11, 12, 255, 255, 0, 0, 0 ,11, 11, 13, 255, 255, 0, 0, 0 ,11, 11, 14, 255, 255, 0, 0, 0 ,11, 11, 15, 255, 255, 0, 0, 0 ,11, 11, 16, 255, 255, 0, 0, 0 ,11, 11, 17, 255, 255, 0, 0, 0 ,11, 11, 18, 255, 255, 0, 0, 0 ,11, 11, 19, 255, 255, 0, 0, 0 ,11, 11, 20, 255, 255, 0, 0, 0 ,11, 11, 21, 255, 255, 0, 0, 0 ,11, 11, 22, 255, 255, 0, 0, 0 ,11, 11, 23, 255, 255, 0, 0, 0 ,11, 11, 24, 255, 255, 0, 0, 0 ,11, 11, 25, 255, 255, 0, 0, 0 ,11, 11, 26, 255, 255, 0, 0, 0 ,11, 11, 27, 255, 255, 0, 0, 0 ,11, 11, 28, 255, 255, 0, 0, 0 ,11, 11, 29, 255, 255, 0, 0, 0 ,11, 11, 30, 255, 255, 0, 0, 0 ,11, 11, 31, 255, 255, 0, 0, 0 ,11, 11, 32, 255, 255, 0, 0, 0 ,11, 11, 33, 255, 255, 0, 0, 0 ,11, 11, 34, 255, 255, 0, 0, 0 ,11, 11, 35, 255, 255, 0, 0, 0 ,11, 11, 36, 255, 255, 0, 0, 0 ,11, 11, 84, 255, 255, 0, 0, 0 ,11, 11, 91, 255, 255, 0, 0, 0 ,11, 11, 103, 255, 255, 0, 0, 0 ,11, 11, 107, 255, 255, 0, 0, 0 ,11, 11, 118, 255, 255, 0, 0, 0 ,11, 11, 122, 255, 255, 0, 0, 0 ,11, 11, 129, 255, 255, 0, 0, 0 ,11, 11, 130, 255, 255, 0, 0, 0 ,11, 11, 132, 255, 255, 0, 0, 0 ,11, 11, 202, 255, 255, 0, 0, 0 ,11, 11, 214, 255, 255, 0, 0, 0 ,11, 11, 216, 255, 255, 0, 0, 0 ,11, 11, 218, 255, 255, 0, 0, 0 ,11, 11, 220, 255, 255, 0, 0, 0 ,11, 11, 222, 255, 255, 0, 0, 0 ,11, 11, 224, 255, 255, 0, 0, 0 ,11, 11, 228, 255, 255, 0, 0, 0 ,11, 11, 230, 255, 255, 0, 0, 0 ,11, 11, 232, 255, 255, 0, 0, 0 ,11, 11, 233, 255, 255, 0, 0, 0 ,11, 11, 234, 255, 255, 0, 0, 0 ,11, 11, 240, 255, 255, 0, 0, 0 ,12, 1, 0, 0, 0, 0, 0, 0 ,12, 1, 0, 1, 1, 0, 0, 0 ,12, 1, 0, 2, 2, 0, 0, 0 ,12, 1, 0, 3, 3, 0, 0, 0 ,12, 1, 0, 4, 4, 0, 0, 0 ,12, 1, 0, 5, 5, 0, 0, 0 ,12, 1, 0, 6, 6, 0, 0, 0 ,12, 1, 0, 7, 7, 0, 0, 0 ,12, 1, 0, 8, 8, 0, 0, 0 ,12, 1, 0, 9, 9, 0, 0, 0 ,12, 5, 0, 0, 0, 0, 0, 0 ,12, 5, 0, 1, 1, 0, 0, 0 ,12, 5, 0, 2, 2, 0, 0, 0 ,12, 5, 0, 3, 3, 0, 0, 0 ,12, 5, 0, 4, 4, 0, 0, 0 ,12, 5, 0, 5, 5, 0, 0, 0 ,12, 5, 0, 6, 6, 0, 0, 0 ,12, 5, 0, 7, 7, 0, 0, 0 ,12, 5, 0, 8, 8, 0, 0, 0 ,12, 5, 0, 9, 9, 0, 0, 0 ,12, 8, 0, 0, 0, 0, 0, 0 ,12, 8, 0, 1, 1, 0, 0, 0 ,12, 8, 0, 2, 2, 0, 0, 0 ,12, 8, 0, 3, 3, 0, 0, 0 ,12, 8, 0, 4, 4, 0, 0, 0 ,12, 8, 0, 5, 5, 0, 0, 0 ,12, 8, 0, 6, 6, 0, 0, 0 ,12, 8, 0, 7, 7, 0, 0, 0 ,12, 8, 0, 8, 8, 0, 0, 0 ,12, 8, 0, 9, 9, 0, 0, 0 ,12, 14, 0, 0, 0, 0, 0, 0 ,12, 14, 0, 1, 1, 0, 0, 0 ,12, 14, 0, 2, 2, 0, 0, 0 ,12, 14, 0, 3, 3, 0, 0, 0 ,12, 14, 0, 4, 4, 0, 0, 0 ,12, 14, 0, 5, 5, 0, 0, 0 ,12, 14, 0, 6, 6, 0, 0, 0 ,12, 14, 0, 7, 7, 0, 0, 0 ,12, 14, 0, 8, 8, 0, 0, 0 ,12, 14, 0, 9, 9, 0, 0, 0 ,13, 8, 0, 255, 255, 0, 0, 0 ,13, 12, 0, 255, 255, 0, 0, 0 ,14, 1, 0, 255, 255, 0, 0, 0 ,14, 1, 0, 255, 1, 0, 0, 0 ,14, 1, 0, 255, 2, 0, 0, 0 ,14, 1, 0, 255, 3, 0, 0, 0 ,14, 1, 0, 255, 4, 0, 0, 0 ,14, 1, 0, 255, 5, 0, 0, 0 ,14, 1, 0, 255, 6, 0, 0, 0 ,14, 1, 0, 255, 7, 0, 0, 0 ,14, 1, 0, 255, 8, 0, 0, 0 ,14, 1, 0, 255, 9, 0, 0, 0 ,14, 5, 0, 255, 255, 0, 0, 0 ,14, 5, 0, 255, 0, 0, 0, 0 ,14, 5, 0, 255, 1, 0, 0, 0 ,14, 5, 0, 255, 2, 0, 0, 0 ,14, 5, 0, 255, 3, 0, 0, 0 ,14, 5, 0, 255, 4, 0, 0, 0 ,14, 5, 0, 255, 5, 0, 0, 0 ,14, 5, 0, 255, 6, 0, 0, 0 ,14, 5, 0, 255, 7, 0, 0, 0 ,14, 5, 0, 255, 8, 0, 0, 0 ,14, 5, 0, 255, 9, 0, 0, 0 ,14, 8, 0, 255, 255, 0, 0, 0 ,14, 8, 0, 255, 1, 0, 0, 0 ,14, 8, 0, 255, 2, 0, 0, 0 ,14, 8, 0, 255, 3, 0, 0, 0 ,14, 8, 0, 255, 4, 0, 0, 0 ,14, 8, 0, 255, 5, 0, 0, 0 ,14, 8, 0, 255, 6, 0, 0, 0 ,14, 8, 0, 255, 7, 0, 0, 0 ,14, 8, 0, 255, 8, 0, 0, 0 ,14, 8, 0, 255, 9, 0, 0, 0 ,14, 12, 0, 255, 255, 0, 0, 0 ,14, 12, 0, 255, 0, 0, 0, 0 ,14, 12, 0, 255, 1, 0, 0, 0 ,14, 12, 0, 255, 2, 0, 0, 0 ,14, 12, 0, 255, 3, 0, 0, 0 ,14, 12, 0, 255, 4, 0, 0, 0 ,14, 12, 0, 255, 5, 0, 0, 0 ,14, 12, 0, 255, 6, 0, 0, 0 ,14, 12, 0, 255, 7, 0, 0, 0 ,14, 12, 0, 255, 8, 0, 0, 0 ,14, 12, 0, 255, 9, 0, 0, 0 ,14, 14, 0, 255, 255, 0, 0, 0 ,14, 14, 0, 255, 1, 0, 0, 0 ,14, 14, 0, 255, 2, 0, 0, 0 ,14, 14, 0, 255, 3, 0, 0, 0 ,14, 14, 0, 255, 4, 0, 0, 0 ,15, 12, 0, 255, 255, 0, 0, 0 ,16, 6, 0, 255, 255, 0, 0, 0 ,16, 12, 0, 255, 255, 0, 0, 0 ,16, 14, 0, 255, 255, 0, 0, 0 ,17, 12, 0, 255, 255, 0, 0, 0 ,17, 12, 0, 255, 255, 1, 0, 0 ,18, 12, 0, 255, 255, 0, 0, 0 ,18, 12, 0, 255, 255, 1, 0, 0 ,19, 12, 0, 255, 255, 0, 0, 0 ,19, 12, 0, 255, 255, 1, 0, 0 ,20, 0, 0, 255, 255, 0, 0, 0 ,20, 1, 0, 255, 255, 0, 0, 0 ,20, 4, 0, 255, 255, 0, 0, 0 ,20, 7, 0, 255, 255, 0, 0, 0 ,20, 8, 0, 255, 255, 0, 0, 0 ,20, 12, 0, 255, 255, 0, 0, 0 ,20, 14, 0, 255, 255, 0, 0, 0 ,21, 12, 0, 255, 255, 0, 0, 0 ,21, 12, 0, 255, 255, 1, 0, 0 ,22, 0, 0, 255, 255, 0, 0, 0 ,22, 7, 0, 255, 255, 0, 0, 0 ,23, 0, 0, 255, 255, 0, 0, 0 ,23, 8, 0, 255, 255, 0, 0, 0 ,23, 12, 0, 255, 255, 0, 0, 0 ,24, 0, 0, 255, 255, 0, 0, 0 ,24, 4, 0, 255, 255, 0, 0, 0 ,24, 6, 0, 255, 255, 0, 0, 0 ,24, 7, 0, 255, 255, 0, 0, 0 ,24, 8, 0, 255, 255, 0, 0, 0 ,24, 12, 0, 255, 255, 0, 0, 0 ,24, 12, 0, 255, 255, 1, 0, 0 ,25, 0, 0, 255, 255, 0, 0, 0 ,25, 7, 0, 255, 255, 0, 0, 0 ,25, 8, 0, 255, 255, 0, 0, 0 ,25, 12, 0, 255, 255, 0, 0, 0 ,26, 18, 0, 255, 255, 0, 0, 0 ,27, 2, 0, 255, 255, 0, 0, 0 ,28, 4, 0, 255, 255, 0, 0, 0 ,28, 18, 0, 255, 255, 0, 0, 0 }; const unsigned char *const ecl_ucd_page_table[4352] = { ecl_ucd_page_table_1 ,ecl_ucd_page_table_2 ,ecl_ucd_page_table_3 ,ecl_ucd_page_table_4 ,ecl_ucd_page_table_5 ,ecl_ucd_page_table_6 ,ecl_ucd_page_table_7 ,ecl_ucd_page_table_8 ,ecl_ucd_page_table_9 ,ecl_ucd_page_table_10 ,ecl_ucd_page_table_11 ,ecl_ucd_page_table_12 ,ecl_ucd_page_table_13 ,ecl_ucd_page_table_14 ,ecl_ucd_page_table_15 ,ecl_ucd_page_table_16 ,ecl_ucd_page_table_17 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_19 ,ecl_ucd_page_table_20 ,ecl_ucd_page_table_21 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_22 ,ecl_ucd_page_table_23 ,ecl_ucd_page_table_24 ,ecl_ucd_page_table_25 ,ecl_ucd_page_table_26 ,ecl_ucd_page_table_27 ,ecl_ucd_page_table_28 ,ecl_ucd_page_table_29 ,ecl_ucd_page_table_30 ,ecl_ucd_page_table_31 ,ecl_ucd_page_table_32 ,ecl_ucd_page_table_33 ,ecl_ucd_page_table_34 ,ecl_ucd_page_table_35 ,ecl_ucd_page_table_36 ,ecl_ucd_page_table_37 ,ecl_ucd_page_table_38 ,ecl_ucd_page_table_39 ,ecl_ucd_page_table_40 ,ecl_ucd_page_table_41 ,ecl_ucd_page_table_42 ,ecl_ucd_page_table_43 ,ecl_ucd_page_table_44 ,ecl_ucd_page_table_45 ,ecl_ucd_page_table_46 ,ecl_ucd_page_table_47 ,ecl_ucd_page_table_48 ,ecl_ucd_page_table_49 ,ecl_ucd_page_table_50 ,ecl_ucd_page_table_51 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_52 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_53 ,ecl_ucd_page_table_54 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_55 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_56 ,ecl_ucd_page_table_57 ,ecl_ucd_page_table_58 ,ecl_ucd_page_table_59 ,ecl_ucd_page_table_60 ,ecl_ucd_page_table_61 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_62 ,ecl_ucd_page_table_63 ,ecl_ucd_page_table_63 ,ecl_ucd_page_table_63 ,ecl_ucd_page_table_63 ,ecl_ucd_page_table_63 ,ecl_ucd_page_table_63 ,ecl_ucd_page_table_63 ,ecl_ucd_page_table_63 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_65 ,ecl_ucd_page_table_66 ,ecl_ucd_page_table_67 ,ecl_ucd_page_table_68 ,ecl_ucd_page_table_69 ,ecl_ucd_page_table_70 ,ecl_ucd_page_table_71 ,ecl_ucd_page_table_72 ,ecl_ucd_page_table_73 ,ecl_ucd_page_table_74 ,ecl_ucd_page_table_75 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_76 ,ecl_ucd_page_table_77 ,ecl_ucd_page_table_78 ,ecl_ucd_page_table_79 ,ecl_ucd_page_table_80 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_81 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_82 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_83 ,ecl_ucd_page_table_84 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_85 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_86 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_87 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_88 ,ecl_ucd_page_table_89 ,ecl_ucd_page_table_90 ,ecl_ucd_page_table_91 ,ecl_ucd_page_table_92 ,ecl_ucd_page_table_93 ,ecl_ucd_page_table_94 ,ecl_ucd_page_table_95 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_96 ,ecl_ucd_page_table_97 ,ecl_ucd_page_table_98 ,ecl_ucd_page_table_99 ,ecl_ucd_page_table_100 ,ecl_ucd_page_table_101 ,ecl_ucd_page_table_102 ,ecl_ucd_page_table_103 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_104 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_105 ,ecl_ucd_page_table_106 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_106 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_107 ,ecl_ucd_page_table_108 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_0 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_109 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_109 }; ecl-16.1.2/src/c/unicode/ucd16-0000.c000066400000000000000000001051401266352375300164630ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ const unsigned char ecl_ucd_page_table_0[] = { 216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 }; const unsigned char ecl_ucd_page_table_1[] = { 14,0,0 ,14,0,0 ,14,0,0 ,14,0,0 ,14,0,0 ,14,0,0 ,14,0,0 ,14,0,0 ,14,0,0 ,15,0,0 ,13,0,0 ,15,0,0 ,16,0,0 ,13,0,0 ,14,0,0 ,14,0,0 ,14,0,0 ,14,0,0 ,14,0,0 ,14,0,0 ,14,0,0 ,14,0,0 ,14,0,0 ,14,0,0 ,14,0,0 ,14,0,0 ,14,0,0 ,14,0,0 ,13,0,0 ,13,0,0 ,13,0,0 ,15,0,0 ,216,0,0 ,193,0,0 ,193,0,0 ,191,0,0 ,198,0,0 ,191,0,0 ,193,0,0 ,193,0,0 ,196,0,0 ,183,0,0 ,193,0,0 ,204,0,0 ,190,0,0 ,179,0,0 ,190,0,0 ,190,0,0 ,99,0,0 ,100,0,0 ,101,0,0 ,102,0,0 ,103,0,0 ,104,0,0 ,105,0,0 ,106,0,0 ,107,0,0 ,108,0,0 ,190,0,0 ,193,0,0 ,208,0,0 ,207,0,0 ,208,0,0 ,193,0,0 ,193,0,0 ,0,97,0 ,0,98,0 ,0,99,0 ,0,100,0 ,0,101,0 ,0,102,0 ,0,103,0 ,0,104,0 ,0,105,0 ,0,106,0 ,0,107,0 ,0,108,0 ,0,109,0 ,0,110,0 ,0,111,0 ,0,112,0 ,0,113,0 ,0,114,0 ,0,115,0 ,0,116,0 ,0,117,0 ,0,118,0 ,0,119,0 ,0,120,0 ,0,121,0 ,0,122,0 ,196,0,0 ,193,0,0 ,183,0,0 ,201,0,0 ,178,0,0 ,201,0,0 ,1,65,0 ,1,66,0 ,1,67,0 ,1,68,0 ,1,69,0 ,1,70,0 ,1,71,0 ,1,72,0 ,1,73,0 ,1,74,0 ,1,75,0 ,1,76,0 ,1,77,0 ,1,78,0 ,1,79,0 ,1,80,0 ,1,81,0 ,1,82,0 ,1,83,0 ,1,84,0 ,1,85,0 ,1,86,0 ,1,87,0 ,1,88,0 ,1,89,0 ,1,90,0 ,196,0,0 ,207,0,0 ,183,0,0 ,207,0,0 ,14,0,0 ,14,0,0 ,14,0,0 ,14,0,0 ,14,0,0 ,14,0,0 ,13,0,0 ,14,0,0 ,14,0,0 ,14,0,0 ,14,0,0 ,14,0,0 ,14,0,0 ,14,0,0 ,14,0,0 ,14,0,0 ,14,0,0 ,14,0,0 ,14,0,0 ,14,0,0 ,14,0,0 ,14,0,0 ,14,0,0 ,14,0,0 ,14,0,0 ,14,0,0 ,14,0,0 ,14,0,0 ,14,0,0 ,14,0,0 ,14,0,0 ,14,0,0 ,14,0,0 ,215,0,0 ,193,0,0 ,198,0,0 ,198,0,0 ,198,0,0 ,198,0,0 ,212,0,0 ,212,0,0 ,201,0,0 ,212,0,0 ,4,0,0 ,187,0,0 ,207,0,0 ,18,0,0 ,212,0,0 ,201,0,0 ,210,0,0 ,205,0,0 ,144,0,0 ,145,0,0 ,201,0,0 ,4,156,3 ,212,0,0 ,193,0,0 ,201,0,0 ,143,0,0 ,4,0,0 ,185,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,193,0,0 ,0,224,0 ,0,225,0 ,0,226,0 ,0,227,0 ,0,228,0 ,0,229,0 ,0,230,0 ,0,231,0 ,0,232,0 ,0,233,0 ,0,234,0 ,0,235,0 ,0,236,0 ,0,237,0 ,0,238,0 ,0,239,0 ,0,240,0 ,0,241,0 ,0,242,0 ,0,243,0 ,0,244,0 ,0,245,0 ,0,246,0 ,207,0,0 ,0,248,0 ,0,249,0 ,0,250,0 ,0,251,0 ,0,252,0 ,0,253,0 ,0,254,0 ,4,0,0 ,1,192,0 ,1,193,0 ,1,194,0 ,1,195,0 ,1,196,0 ,1,197,0 ,1,198,0 ,1,199,0 ,1,200,0 ,1,201,0 ,1,202,0 ,1,203,0 ,1,204,0 ,1,205,0 ,1,206,0 ,1,207,0 ,1,208,0 ,1,209,0 ,1,210,0 ,1,211,0 ,1,212,0 ,1,213,0 ,1,214,0 ,207,0,0 ,1,216,0 ,1,217,0 ,1,218,0 ,1,219,0 ,1,220,0 ,1,221,0 ,1,222,0 ,1,120,1 }; const unsigned char ecl_ucd_page_table_2[] = { 0,1,1 ,1,0,1 ,0,3,1 ,1,2,1 ,0,5,1 ,1,4,1 ,0,7,1 ,1,6,1 ,0,9,1 ,1,8,1 ,0,11,1 ,1,10,1 ,0,13,1 ,1,12,1 ,0,15,1 ,1,14,1 ,0,17,1 ,1,16,1 ,0,19,1 ,1,18,1 ,0,21,1 ,1,20,1 ,0,23,1 ,1,22,1 ,0,25,1 ,1,24,1 ,0,27,1 ,1,26,1 ,0,29,1 ,1,28,1 ,0,31,1 ,1,30,1 ,0,33,1 ,1,32,1 ,0,35,1 ,1,34,1 ,0,37,1 ,1,36,1 ,0,39,1 ,1,38,1 ,0,41,1 ,1,40,1 ,0,43,1 ,1,42,1 ,0,45,1 ,1,44,1 ,0,47,1 ,1,46,1 ,3,105,0 ,4,73,0 ,0,51,1 ,1,50,1 ,0,53,1 ,1,52,1 ,0,55,1 ,1,54,1 ,4,0,0 ,0,58,1 ,1,57,1 ,0,60,1 ,1,59,1 ,0,62,1 ,1,61,1 ,0,64,1 ,1,63,1 ,0,66,1 ,1,65,1 ,0,68,1 ,1,67,1 ,0,70,1 ,1,69,1 ,0,72,1 ,1,71,1 ,4,0,0 ,0,75,1 ,1,74,1 ,0,77,1 ,1,76,1 ,0,79,1 ,1,78,1 ,0,81,1 ,1,80,1 ,0,83,1 ,1,82,1 ,0,85,1 ,1,84,1 ,0,87,1 ,1,86,1 ,0,89,1 ,1,88,1 ,0,91,1 ,1,90,1 ,0,93,1 ,1,92,1 ,0,95,1 ,1,94,1 ,0,97,1 ,1,96,1 ,0,99,1 ,1,98,1 ,0,101,1 ,1,100,1 ,0,103,1 ,1,102,1 ,0,105,1 ,1,104,1 ,0,107,1 ,1,106,1 ,0,109,1 ,1,108,1 ,0,111,1 ,1,110,1 ,0,113,1 ,1,112,1 ,0,115,1 ,1,114,1 ,0,117,1 ,1,116,1 ,0,119,1 ,1,118,1 ,0,255,0 ,0,122,1 ,1,121,1 ,0,124,1 ,1,123,1 ,0,126,1 ,1,125,1 ,4,83,0 ,1,67,2 ,0,83,2 ,0,131,1 ,1,130,1 ,0,133,1 ,1,132,1 ,0,84,2 ,0,136,1 ,1,135,1 ,0,86,2 ,0,87,2 ,0,140,1 ,1,139,1 ,4,0,0 ,0,221,1 ,0,89,2 ,0,91,2 ,0,146,1 ,1,145,1 ,0,96,2 ,0,99,2 ,1,246,1 ,0,105,2 ,0,104,2 ,0,153,1 ,1,152,1 ,1,61,2 ,4,0,0 ,0,111,2 ,0,114,2 ,1,32,2 ,0,117,2 ,0,161,1 ,1,160,1 ,0,163,1 ,1,162,1 ,0,165,1 ,1,164,1 ,0,128,2 ,0,168,1 ,1,167,1 ,0,131,2 ,4,0,0 ,4,0,0 ,0,173,1 ,1,172,1 ,0,136,2 ,0,176,1 ,1,175,1 ,0,138,2 ,0,139,2 ,0,180,1 ,1,179,1 ,0,182,1 ,1,181,1 ,0,146,2 ,0,185,1 ,1,184,1 ,4,0,0 ,11,0,0 ,0,189,1 ,1,188,1 ,4,0,0 ,1,247,1 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,0,198,1 ,5,196,1 ,1,196,1 ,0,201,1 ,5,199,1 ,1,199,1 ,0,204,1 ,5,202,1 ,1,202,1 ,0,206,1 ,1,205,1 ,0,208,1 ,1,207,1 ,0,210,1 ,1,209,1 ,0,212,1 ,1,211,1 ,0,214,1 ,1,213,1 ,0,216,1 ,1,215,1 ,0,218,1 ,1,217,1 ,0,220,1 ,1,219,1 ,1,142,1 ,0,223,1 ,1,222,1 ,0,225,1 ,1,224,1 ,0,227,1 ,1,226,1 ,0,229,1 ,1,228,1 ,0,231,1 ,1,230,1 ,0,233,1 ,1,232,1 ,0,235,1 ,1,234,1 ,0,237,1 ,1,236,1 ,0,239,1 ,1,238,1 ,4,0,0 ,0,243,1 ,5,241,1 ,1,241,1 ,0,245,1 ,1,244,1 ,0,149,1 ,0,191,1 ,0,249,1 ,1,248,1 ,0,251,1 ,1,250,1 ,0,253,1 ,1,252,1 ,0,255,1 ,1,254,1 }; const unsigned char ecl_ucd_page_table_3[] = { 0,1,2 ,1,0,2 ,0,3,2 ,1,2,2 ,0,5,2 ,1,4,2 ,0,7,2 ,1,6,2 ,0,9,2 ,1,8,2 ,0,11,2 ,1,10,2 ,0,13,2 ,1,12,2 ,0,15,2 ,1,14,2 ,0,17,2 ,1,16,2 ,0,19,2 ,1,18,2 ,0,21,2 ,1,20,2 ,0,23,2 ,1,22,2 ,0,25,2 ,1,24,2 ,0,27,2 ,1,26,2 ,0,29,2 ,1,28,2 ,0,31,2 ,1,30,2 ,0,158,1 ,4,0,0 ,0,35,2 ,1,34,2 ,0,37,2 ,1,36,2 ,0,39,2 ,1,38,2 ,0,41,2 ,1,40,2 ,0,43,2 ,1,42,2 ,0,45,2 ,1,44,2 ,0,47,2 ,1,46,2 ,0,49,2 ,1,48,2 ,0,51,2 ,1,50,2 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,0,101,44 ,0,60,2 ,1,59,2 ,0,154,1 ,0,102,44 ,1,126,44 ,1,127,44 ,0,66,2 ,1,65,2 ,0,128,1 ,0,137,2 ,0,140,2 ,0,71,2 ,1,70,2 ,0,73,2 ,1,72,2 ,0,75,2 ,1,74,2 ,0,77,2 ,1,76,2 ,0,79,2 ,1,78,2 ,1,111,44 ,1,109,44 ,1,112,44 ,1,129,1 ,1,134,1 ,4,0,0 ,1,137,1 ,1,138,1 ,4,0,0 ,1,143,1 ,4,0,0 ,1,144,1 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,1,147,1 ,4,0,0 ,4,0,0 ,1,148,1 ,4,0,0 ,1,141,167 ,4,0,0 ,4,0,0 ,1,151,1 ,1,150,1 ,4,0,0 ,1,98,44 ,4,0,0 ,4,0,0 ,4,0,0 ,1,156,1 ,4,0,0 ,1,110,44 ,1,157,1 ,4,0,0 ,4,0,0 ,1,159,1 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,1,100,44 ,4,0,0 ,4,0,0 ,1,166,1 ,4,0,0 ,4,0,0 ,1,169,1 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,1,174,1 ,1,68,2 ,1,177,1 ,1,178,1 ,1,69,2 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,1,183,1 ,4,0,0 ,11,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,8,0,0 ,8,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,201,0,0 ,201,0,0 ,201,0,0 ,201,0,0 ,8,0,0 ,8,0,0 ,8,0,0 ,8,0,0 ,8,0,0 ,8,0,0 ,8,0,0 ,8,0,0 ,8,0,0 ,8,0,0 ,7,0,0 ,7,0,0 ,201,0,0 ,201,0,0 ,201,0,0 ,201,0,0 ,201,0,0 ,201,0,0 ,201,0,0 ,201,0,0 ,201,0,0 ,201,0,0 ,201,0,0 ,201,0,0 ,201,0,0 ,201,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,201,0,0 ,201,0,0 ,201,0,0 ,201,0,0 ,201,0,0 ,201,0,0 ,201,0,0 ,8,0,0 ,201,0,0 ,7,0,0 ,201,0,0 ,201,0,0 ,201,0,0 ,201,0,0 ,201,0,0 ,201,0,0 ,201,0,0 ,201,0,0 ,201,0,0 ,201,0,0 ,201,0,0 ,201,0,0 ,201,0,0 ,201,0,0 ,201,0,0 ,201,0,0 ,201,0,0 }; const unsigned char ecl_ucd_page_table_4[] = { 84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,85,0,0 ,80,0,0 ,80,0,0 ,80,0,0 ,80,0,0 ,85,0,0 ,78,0,0 ,80,0,0 ,80,0,0 ,80,0,0 ,80,0,0 ,80,0,0 ,76,0,0 ,76,0,0 ,80,0,0 ,80,0,0 ,80,0,0 ,80,0,0 ,76,0,0 ,76,0,0 ,80,0,0 ,80,0,0 ,80,0,0 ,80,0,0 ,80,0,0 ,80,0,0 ,80,0,0 ,80,0,0 ,80,0,0 ,80,0,0 ,80,0,0 ,36,0,0 ,36,0,0 ,36,0,0 ,36,0,0 ,36,0,0 ,80,0,0 ,80,0,0 ,80,0,0 ,80,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,88,153,3 ,84,0,0 ,80,0,0 ,80,0,0 ,80,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,80,0,0 ,80,0,0 ,35,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,80,0,0 ,80,0,0 ,80,0,0 ,80,0,0 ,84,0,0 ,85,0,0 ,80,0,0 ,80,0,0 ,84,0,0 ,86,0,0 ,87,0,0 ,87,0,0 ,86,0,0 ,87,0,0 ,87,0,0 ,86,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,0,113,3 ,1,112,3 ,0,115,3 ,1,114,3 ,8,0,0 ,201,0,0 ,0,119,3 ,1,118,3 ,216,0,0 ,216,0,0 ,7,0,0 ,1,253,3 ,1,254,3 ,1,255,3 ,193,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,201,0,0 ,201,0,0 ,0,172,3 ,193,0,0 ,0,173,3 ,0,174,3 ,0,175,3 ,216,0,0 ,0,204,3 ,216,0,0 ,0,205,3 ,0,206,3 ,4,0,0 ,0,177,3 ,0,178,3 ,0,179,3 ,0,180,3 ,0,181,3 ,0,182,3 ,0,183,3 ,0,184,3 ,0,185,3 ,0,186,3 ,0,187,3 ,0,188,3 ,0,189,3 ,0,190,3 ,0,191,3 ,0,192,3 ,0,193,3 ,216,0,0 ,0,195,3 ,0,196,3 ,0,197,3 ,0,198,3 ,0,199,3 ,0,200,3 ,0,201,3 ,0,202,3 ,0,203,3 ,1,134,3 ,1,136,3 ,1,137,3 ,1,138,3 ,4,0,0 ,1,145,3 ,1,146,3 ,1,147,3 ,1,148,3 ,1,149,3 ,1,150,3 ,1,151,3 ,1,152,3 ,1,153,3 ,1,154,3 ,1,155,3 ,1,156,3 ,1,157,3 ,1,158,3 ,1,159,3 ,1,160,3 ,1,161,3 ,4,163,3 ,1,163,3 ,1,164,3 ,1,165,3 ,1,166,3 ,1,167,3 ,1,168,3 ,1,169,3 ,1,170,3 ,1,171,3 ,1,140,3 ,1,142,3 ,1,143,3 ,0,215,3 ,4,146,3 ,4,152,3 ,3,0,0 ,3,0,0 ,3,0,0 ,4,166,3 ,4,160,3 ,1,207,3 ,0,217,3 ,1,216,3 ,0,219,3 ,1,218,3 ,0,221,3 ,1,220,3 ,0,223,3 ,1,222,3 ,0,225,3 ,1,224,3 ,0,227,3 ,1,226,3 ,0,229,3 ,1,228,3 ,0,231,3 ,1,230,3 ,0,233,3 ,1,232,3 ,0,235,3 ,1,234,3 ,0,237,3 ,1,236,3 ,0,239,3 ,1,238,3 ,4,154,3 ,4,161,3 ,1,249,3 ,4,0,0 ,3,184,3 ,4,149,3 ,207,0,0 ,0,248,3 ,1,247,3 ,0,242,3 ,0,251,3 ,1,250,3 ,4,0,0 ,0,123,3 ,0,124,3 ,0,125,3 }; const unsigned char ecl_ucd_page_table_5[] = { 0,80,4 ,0,81,4 ,0,82,4 ,0,83,4 ,0,84,4 ,0,85,4 ,0,86,4 ,0,87,4 ,0,88,4 ,0,89,4 ,0,90,4 ,0,91,4 ,0,92,4 ,0,93,4 ,0,94,4 ,0,95,4 ,0,48,4 ,0,49,4 ,0,50,4 ,0,51,4 ,0,52,4 ,0,53,4 ,0,54,4 ,0,55,4 ,0,56,4 ,0,57,4 ,0,58,4 ,0,59,4 ,0,60,4 ,0,61,4 ,0,62,4 ,0,63,4 ,0,64,4 ,0,65,4 ,0,66,4 ,0,67,4 ,0,68,4 ,0,69,4 ,0,70,4 ,0,71,4 ,0,72,4 ,0,73,4 ,0,74,4 ,0,75,4 ,0,76,4 ,0,77,4 ,0,78,4 ,0,79,4 ,1,16,4 ,1,17,4 ,1,18,4 ,1,19,4 ,1,20,4 ,1,21,4 ,1,22,4 ,1,23,4 ,1,24,4 ,1,25,4 ,1,26,4 ,1,27,4 ,1,28,4 ,1,29,4 ,1,30,4 ,1,31,4 ,1,32,4 ,1,33,4 ,1,34,4 ,1,35,4 ,1,36,4 ,1,37,4 ,1,38,4 ,1,39,4 ,1,40,4 ,1,41,4 ,1,42,4 ,1,43,4 ,1,44,4 ,1,45,4 ,1,46,4 ,1,47,4 ,1,0,4 ,1,1,4 ,1,2,4 ,1,3,4 ,1,4,4 ,1,5,4 ,1,6,4 ,1,7,4 ,1,8,4 ,1,9,4 ,1,10,4 ,1,11,4 ,1,12,4 ,1,13,4 ,1,14,4 ,1,15,4 ,0,97,4 ,1,96,4 ,0,99,4 ,1,98,4 ,0,101,4 ,1,100,4 ,0,103,4 ,1,102,4 ,0,105,4 ,1,104,4 ,0,107,4 ,1,106,4 ,0,109,4 ,1,108,4 ,0,111,4 ,1,110,4 ,0,113,4 ,1,112,4 ,0,115,4 ,1,114,4 ,0,117,4 ,1,116,4 ,0,119,4 ,1,118,4 ,0,121,4 ,1,120,4 ,0,123,4 ,1,122,4 ,0,125,4 ,1,124,4 ,0,127,4 ,1,126,4 ,0,129,4 ,1,128,4 ,211,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,33,0,0 ,33,0,0 ,0,139,4 ,1,138,4 ,0,141,4 ,1,140,4 ,0,143,4 ,1,142,4 ,0,145,4 ,1,144,4 ,0,147,4 ,1,146,4 ,0,149,4 ,1,148,4 ,0,151,4 ,1,150,4 ,0,153,4 ,1,152,4 ,0,155,4 ,1,154,4 ,0,157,4 ,1,156,4 ,0,159,4 ,1,158,4 ,0,161,4 ,1,160,4 ,0,163,4 ,1,162,4 ,0,165,4 ,1,164,4 ,0,167,4 ,1,166,4 ,0,169,4 ,1,168,4 ,0,171,4 ,1,170,4 ,0,173,4 ,1,172,4 ,0,175,4 ,1,174,4 ,0,177,4 ,1,176,4 ,0,179,4 ,1,178,4 ,0,181,4 ,1,180,4 ,0,183,4 ,1,182,4 ,0,185,4 ,1,184,4 ,0,187,4 ,1,186,4 ,0,189,4 ,1,188,4 ,0,191,4 ,1,190,4 ,0,207,4 ,0,194,4 ,1,193,4 ,0,196,4 ,1,195,4 ,0,198,4 ,1,197,4 ,0,200,4 ,1,199,4 ,0,202,4 ,1,201,4 ,0,204,4 ,1,203,4 ,0,206,4 ,1,205,4 ,1,192,4 ,0,209,4 ,1,208,4 ,0,211,4 ,1,210,4 ,0,213,4 ,1,212,4 ,0,215,4 ,1,214,4 ,0,217,4 ,1,216,4 ,0,219,4 ,1,218,4 ,0,221,4 ,1,220,4 ,0,223,4 ,1,222,4 ,0,225,4 ,1,224,4 ,0,227,4 ,1,226,4 ,0,229,4 ,1,228,4 ,0,231,4 ,1,230,4 ,0,233,4 ,1,232,4 ,0,235,4 ,1,234,4 ,0,237,4 ,1,236,4 ,0,239,4 ,1,238,4 ,0,241,4 ,1,240,4 ,0,243,4 ,1,242,4 ,0,245,4 ,1,244,4 ,0,247,4 ,1,246,4 ,0,249,4 ,1,248,4 ,0,251,4 ,1,250,4 ,0,253,4 ,1,252,4 ,0,255,4 ,1,254,4 }; const unsigned char ecl_ucd_page_table_6[] = { 0,1,5 ,1,0,5 ,0,3,5 ,1,2,5 ,0,5,5 ,1,4,5 ,0,7,5 ,1,6,5 ,0,9,5 ,1,8,5 ,0,11,5 ,1,10,5 ,0,13,5 ,1,12,5 ,0,15,5 ,1,14,5 ,0,17,5 ,1,16,5 ,0,19,5 ,1,18,5 ,0,21,5 ,1,20,5 ,0,23,5 ,1,22,5 ,0,25,5 ,1,24,5 ,0,27,5 ,1,26,5 ,0,29,5 ,1,28,5 ,0,31,5 ,1,30,5 ,0,33,5 ,1,32,5 ,0,35,5 ,1,34,5 ,0,37,5 ,1,36,5 ,0,39,5 ,1,38,5 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,0,97,5 ,0,98,5 ,0,99,5 ,0,100,5 ,0,101,5 ,0,102,5 ,0,103,5 ,0,104,5 ,0,105,5 ,0,106,5 ,0,107,5 ,0,108,5 ,0,109,5 ,0,110,5 ,0,111,5 ,0,112,5 ,0,113,5 ,0,114,5 ,0,115,5 ,0,116,5 ,0,117,5 ,0,118,5 ,0,119,5 ,0,120,5 ,0,121,5 ,0,122,5 ,0,123,5 ,0,124,5 ,0,125,5 ,0,126,5 ,0,127,5 ,0,128,5 ,0,129,5 ,0,130,5 ,0,131,5 ,0,132,5 ,0,133,5 ,0,134,5 ,216,0,0 ,216,0,0 ,7,0,0 ,192,0,0 ,192,0,0 ,192,0,0 ,192,0,0 ,192,0,0 ,192,0,0 ,216,0,0 ,1,49,5 ,1,50,5 ,1,51,5 ,1,52,5 ,1,53,5 ,1,54,5 ,1,55,5 ,1,56,5 ,1,57,5 ,1,58,5 ,1,59,5 ,1,60,5 ,1,61,5 ,1,62,5 ,1,63,5 ,1,64,5 ,1,65,5 ,1,66,5 ,1,67,5 ,1,68,5 ,1,69,5 ,1,70,5 ,1,71,5 ,1,72,5 ,1,73,5 ,1,74,5 ,1,75,5 ,1,76,5 ,1,77,5 ,1,78,5 ,1,79,5 ,1,80,5 ,1,81,5 ,1,82,5 ,1,83,5 ,1,84,5 ,1,85,5 ,1,86,5 ,4,0,0 ,216,0,0 ,192,0,0 ,180,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,80,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,80,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,81,0,0 ,80,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,80,0,0 ,80,0,0 ,80,0,0 ,80,0,0 ,80,0,0 ,80,0,0 ,84,0,0 ,84,0,0 ,80,0,0 ,84,0,0 ,84,0,0 ,81,0,0 ,83,0,0 ,84,0,0 ,40,0,0 ,41,0,0 ,42,0,0 ,43,0,0 ,44,0,0 ,45,0,0 ,46,0,0 ,47,0,0 ,48,0,0 ,49,0,0 ,49,0,0 ,50,0,0 ,51,0,0 ,52,0,0 ,181,0,0 ,53,0,0 ,194,0,0 ,54,0,0 ,55,0,0 ,194,0,0 ,84,0,0 ,80,0,0 ,194,0,0 ,48,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,194,0,0 ,194,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 }; const unsigned char ecl_ucd_page_table_7[] = { 17,0,0 ,17,0,0 ,17,0,0 ,17,0,0 ,216,0,0 ,216,0,0 ,207,0,0 ,207,0,0 ,202,0,0 ,191,0,0 ,191,0,0 ,197,0,0 ,190,0,0 ,188,0,0 ,212,0,0 ,212,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,60,0,0 ,61,0,0 ,62,0,0 ,188,0,0 ,216,0,0 ,216,0,0 ,188,0,0 ,188,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,6,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,57,0,0 ,58,0,0 ,59,0,0 ,60,0,0 ,61,0,0 ,62,0,0 ,63,0,0 ,64,0,0 ,84,0,0 ,84,0,0 ,80,0,0 ,80,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,80,0,0 ,84,0,0 ,84,0,0 ,80,0,0 ,89,0,0 ,90,0,0 ,91,0,0 ,92,0,0 ,93,0,0 ,94,0,0 ,95,0,0 ,96,0,0 ,97,0,0 ,98,0,0 ,191,0,0 ,189,0,0 ,189,0,0 ,188,0,0 ,10,0,0 ,10,0,0 ,65,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,188,0,0 ,10,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,17,0,0 ,212,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,80,0,0 ,84,0,0 ,6,0,0 ,6,0,0 ,84,0,0 ,84,0,0 ,212,0,0 ,80,0,0 ,84,0,0 ,84,0,0 ,80,0,0 ,10,0,0 ,10,0,0 ,99,0,0 ,100,0,0 ,101,0,0 ,102,0,0 ,103,0,0 ,104,0,0 ,105,0,0 ,106,0,0 ,107,0,0 ,108,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,209,0,0 ,209,0,0 ,10,0,0 }; const unsigned char ecl_ucd_page_table_8[] = { 188,0,0 ,188,0,0 ,188,0,0 ,188,0,0 ,188,0,0 ,188,0,0 ,188,0,0 ,188,0,0 ,188,0,0 ,188,0,0 ,188,0,0 ,188,0,0 ,188,0,0 ,188,0,0 ,216,0,0 ,17,0,0 ,10,0,0 ,66,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,84,0,0 ,80,0,0 ,84,0,0 ,84,0,0 ,80,0,0 ,84,0,0 ,84,0,0 ,80,0,0 ,80,0,0 ,80,0,0 ,84,0,0 ,80,0,0 ,80,0,0 ,84,0,0 ,80,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,80,0,0 ,84,0,0 ,80,0,0 ,84,0,0 ,80,0,0 ,84,0,0 ,80,0,0 ,84,0,0 ,84,0,0 ,216,0,0 ,216,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,10,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,119,0,0 ,120,0,0 ,121,0,0 ,122,0,0 ,123,0,0 ,124,0,0 ,125,0,0 ,126,0,0 ,127,0,0 ,128,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,80,0,0 ,84,0,0 ,9,0,0 ,9,0,0 ,212,0,0 ,193,0,0 ,193,0,0 ,193,0,0 ,9,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 }; const unsigned char ecl_ucd_page_table_9[] = { 12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,9,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,9,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,9,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,216,0,0 ,216,0,0 ,194,0,0 ,194,0,0 ,194,0,0 ,194,0,0 ,194,0,0 ,194,0,0 ,194,0,0 ,194,0,0 ,194,0,0 ,194,0,0 ,194,0,0 ,194,0,0 ,194,0,0 ,194,0,0 ,194,0,0 ,216,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,80,0,0 ,80,0,0 ,80,0,0 ,216,0,0 ,216,0,0 ,194,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 }; const unsigned char ecl_ucd_page_table_10[] = { 35,0,0 ,35,0,0 ,35,0,0 ,29,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,35,0,0 ,29,0,0 ,37,0,0 ,11,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,39,0,0 ,29,0,0 ,29,0,0 ,11,0,0 ,84,0,0 ,80,0,0 ,84,0,0 ,84,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,35,0,0 ,35,0,0 ,192,0,0 ,192,0,0 ,109,0,0 ,110,0,0 ,111,0,0 ,112,0,0 ,113,0,0 ,114,0,0 ,115,0,0 ,116,0,0 ,117,0,0 ,118,0,0 ,192,0,0 ,7,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,35,0,0 ,29,0,0 ,29,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,37,0,0 ,11,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,216,0,0 ,216,0,0 ,29,0,0 ,29,0,0 ,216,0,0 ,216,0,0 ,29,0,0 ,29,0,0 ,39,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,29,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,35,0,0 ,35,0,0 ,216,0,0 ,216,0,0 ,109,0,0 ,110,0,0 ,111,0,0 ,112,0,0 ,113,0,0 ,114,0,0 ,115,0,0 ,116,0,0 ,117,0,0 ,118,0,0 ,11,0,0 ,11,0,0 ,198,0,0 ,198,0,0 ,152,0,0 ,152,0,0 ,152,0,0 ,152,0,0 ,152,0,0 ,152,0,0 ,211,0,0 ,198,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 }; const unsigned char ecl_ucd_page_table_11[] = { 216,0,0 ,35,0,0 ,35,0,0 ,29,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,37,0,0 ,216,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,35,0,0 ,35,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,35,0,0 ,35,0,0 ,216,0,0 ,216,0,0 ,35,0,0 ,35,0,0 ,39,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,35,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,109,0,0 ,110,0,0 ,111,0,0 ,112,0,0 ,113,0,0 ,114,0,0 ,115,0,0 ,116,0,0 ,117,0,0 ,118,0,0 ,35,0,0 ,35,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,35,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,35,0,0 ,35,0,0 ,29,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,37,0,0 ,11,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,216,0,0 ,35,0,0 ,35,0,0 ,29,0,0 ,216,0,0 ,29,0,0 ,29,0,0 ,39,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,35,0,0 ,35,0,0 ,216,0,0 ,216,0,0 ,109,0,0 ,110,0,0 ,111,0,0 ,112,0,0 ,113,0,0 ,114,0,0 ,115,0,0 ,116,0,0 ,117,0,0 ,118,0,0 ,216,0,0 ,198,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 }; const unsigned char ecl_ucd_page_table_12[] = { 216,0,0 ,35,0,0 ,29,0,0 ,29,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,37,0,0 ,11,0,0 ,29,0,0 ,35,0,0 ,29,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,216,0,0 ,216,0,0 ,29,0,0 ,29,0,0 ,216,0,0 ,216,0,0 ,29,0,0 ,29,0,0 ,39,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,35,0,0 ,29,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,35,0,0 ,35,0,0 ,216,0,0 ,216,0,0 ,109,0,0 ,110,0,0 ,111,0,0 ,112,0,0 ,113,0,0 ,114,0,0 ,115,0,0 ,116,0,0 ,117,0,0 ,118,0,0 ,211,0,0 ,11,0,0 ,152,0,0 ,152,0,0 ,152,0,0 ,152,0,0 ,152,0,0 ,152,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,35,0,0 ,11,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,11,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,29,0,0 ,29,0,0 ,35,0,0 ,29,0,0 ,29,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,216,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,39,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,29,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,109,0,0 ,110,0,0 ,111,0,0 ,112,0,0 ,113,0,0 ,114,0,0 ,115,0,0 ,116,0,0 ,117,0,0 ,118,0,0 ,152,0,0 ,152,0,0 ,152,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,198,0,0 ,212,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 }; const unsigned char ecl_ucd_page_table_13[] = { 216,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,216,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,216,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,39,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,67,0,0 ,68,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,35,0,0 ,35,0,0 ,216,0,0 ,216,0,0 ,109,0,0 ,110,0,0 ,111,0,0 ,112,0,0 ,113,0,0 ,114,0,0 ,115,0,0 ,116,0,0 ,117,0,0 ,118,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,211,0,0 ,216,0,0 ,216,0,0 ,29,0,0 ,29,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,37,0,0 ,11,0,0 ,29,0,0 ,34,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,216,0,0 ,34,0,0 ,29,0,0 ,29,0,0 ,216,0,0 ,29,0,0 ,29,0,0 ,35,0,0 ,39,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,29,0,0 ,29,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,35,0,0 ,35,0,0 ,216,0,0 ,216,0,0 ,109,0,0 ,110,0,0 ,111,0,0 ,112,0,0 ,113,0,0 ,114,0,0 ,115,0,0 ,116,0,0 ,117,0,0 ,118,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 }; const unsigned char ecl_ucd_page_table_14[] = { 216,0,0 ,216,0,0 ,29,0,0 ,29,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,216,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,216,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,39,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,29,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,35,0,0 ,35,0,0 ,216,0,0 ,216,0,0 ,109,0,0 ,110,0,0 ,111,0,0 ,112,0,0 ,113,0,0 ,114,0,0 ,115,0,0 ,116,0,0 ,117,0,0 ,118,0,0 ,152,0,0 ,152,0,0 ,152,0,0 ,152,0,0 ,152,0,0 ,152,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,211,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,29,0,0 ,29,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,39,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,216,0,0 ,35,0,0 ,216,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,29,0,0 ,29,0,0 ,192,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 }; const unsigned char ecl_ucd_page_table_15[] = { 216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,35,0,0 ,11,0,0 ,11,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,69,0,0 ,69,0,0 ,39,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,198,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,7,0,0 ,35,0,0 ,70,0,0 ,70,0,0 ,70,0,0 ,70,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,192,0,0 ,109,0,0 ,110,0,0 ,111,0,0 ,112,0,0 ,113,0,0 ,114,0,0 ,115,0,0 ,116,0,0 ,117,0,0 ,118,0,0 ,192,0,0 ,192,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,11,0,0 ,216,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,35,0,0 ,11,0,0 ,11,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,71,0,0 ,71,0,0 ,216,0,0 ,35,0,0 ,35,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,7,0,0 ,216,0,0 ,72,0,0 ,72,0,0 ,72,0,0 ,72,0,0 ,35,0,0 ,35,0,0 ,216,0,0 ,216,0,0 ,109,0,0 ,110,0,0 ,111,0,0 ,112,0,0 ,113,0,0 ,114,0,0 ,115,0,0 ,116,0,0 ,117,0,0 ,118,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 }; ecl-16.1.2/src/c/unicode/ucd16-0016.c000066400000000000000000001044151266352375300164760ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ const unsigned char ecl_ucd_page_table_16[] = { 11,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,192,0,0 ,192,0,0 ,192,0,0 ,192,0,0 ,192,0,0 ,192,0,0 ,192,0,0 ,192,0,0 ,192,0,0 ,192,0,0 ,192,0,0 ,192,0,0 ,192,0,0 ,192,0,0 ,192,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,80,0,0 ,80,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,109,0,0 ,110,0,0 ,111,0,0 ,112,0,0 ,113,0,0 ,114,0,0 ,115,0,0 ,116,0,0 ,117,0,0 ,118,0,0 ,152,0,0 ,152,0,0 ,152,0,0 ,152,0,0 ,152,0,0 ,152,0,0 ,152,0,0 ,152,0,0 ,152,0,0 ,152,0,0 ,211,0,0 ,80,0,0 ,211,0,0 ,80,0,0 ,211,0,0 ,78,0,0 ,196,0,0 ,183,0,0 ,196,0,0 ,183,0,0 ,29,0,0 ,29,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,73,0,0 ,74,0,0 ,35,0,0 ,75,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,74,0,0 ,74,0,0 ,74,0,0 ,74,0,0 ,35,0,0 ,29,0,0 ,74,0,0 ,35,0,0 ,84,0,0 ,84,0,0 ,39,0,0 ,192,0,0 ,84,0,0 ,84,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,216,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,216,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,80,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,216,0,0 ,211,0,0 ,211,0,0 ,192,0,0 ,192,0,0 ,192,0,0 ,192,0,0 ,192,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,192,0,0 ,192,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 }; const unsigned char ecl_ucd_page_table_17[] = { 11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,29,0,0 ,29,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,29,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,37,0,0 ,29,0,0 ,39,0,0 ,39,0,0 ,29,0,0 ,29,0,0 ,35,0,0 ,35,0,0 ,11,0,0 ,109,0,0 ,110,0,0 ,111,0,0 ,112,0,0 ,113,0,0 ,114,0,0 ,115,0,0 ,116,0,0 ,117,0,0 ,118,0,0 ,192,0,0 ,192,0,0 ,192,0,0 ,192,0,0 ,192,0,0 ,192,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,29,0,0 ,29,0,0 ,35,0,0 ,35,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,11,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,11,0,0 ,11,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,35,0,0 ,29,0,0 ,29,0,0 ,35,0,0 ,35,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,80,0,0 ,11,0,0 ,29,0,0 ,109,0,0 ,110,0,0 ,111,0,0 ,112,0,0 ,113,0,0 ,114,0,0 ,115,0,0 ,116,0,0 ,117,0,0 ,118,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,35,0,0 ,211,0,0 ,211,0,0 ,0,0,45 ,0,1,45 ,0,2,45 ,0,3,45 ,0,4,45 ,0,5,45 ,0,6,45 ,0,7,45 ,0,8,45 ,0,9,45 ,0,10,45 ,0,11,45 ,0,12,45 ,0,13,45 ,0,14,45 ,0,15,45 ,0,16,45 ,0,17,45 ,0,18,45 ,0,19,45 ,0,20,45 ,0,21,45 ,0,22,45 ,0,23,45 ,0,24,45 ,0,25,45 ,0,26,45 ,0,27,45 ,0,28,45 ,0,29,45 ,0,30,45 ,0,31,45 ,0,32,45 ,0,33,45 ,0,34,45 ,0,35,45 ,0,36,45 ,0,37,45 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,192,0,0 ,7,0,0 ,216,0,0 ,216,0,0 ,216,0,0 }; const unsigned char ecl_ucd_page_table_18[] = { 11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 }; const unsigned char ecl_ucd_page_table_19[] = { 11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,11,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,11,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 }; const unsigned char ecl_ucd_page_table_20[] = { 11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,211,0,0 ,192,0,0 ,192,0,0 ,192,0,0 ,192,0,0 ,192,0,0 ,192,0,0 ,192,0,0 ,192,0,0 ,153,0,0 ,154,0,0 ,155,0,0 ,156,0,0 ,157,0,0 ,158,0,0 ,159,0,0 ,160,0,0 ,161,0,0 ,152,0,0 ,152,0,0 ,152,0,0 ,152,0,0 ,152,0,0 ,152,0,0 ,152,0,0 ,152,0,0 ,152,0,0 ,152,0,0 ,152,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 }; const unsigned char ecl_ucd_page_table_21[] = { 180,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 }; const unsigned char ecl_ucd_page_table_22[] = { 11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,192,0,0 ,192,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,196,0,0 ,183,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,192,0,0 ,192,0,0 ,192,0,0 ,129,0,0 ,129,0,0 ,129,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 }; const unsigned char ecl_ucd_page_table_23[] = { 11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,35,0,0 ,35,0,0 ,39,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,35,0,0 ,35,0,0 ,39,0,0 ,192,0,0 ,192,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,35,0,0 ,35,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,35,0,0 ,35,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,19,0,0 ,19,0,0 ,29,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,35,0,0 ,29,0,0 ,29,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,39,0,0 ,35,0,0 ,192,0,0 ,192,0,0 ,192,0,0 ,7,0,0 ,192,0,0 ,192,0,0 ,192,0,0 ,198,0,0 ,11,0,0 ,84,0,0 ,216,0,0 ,216,0,0 ,109,0,0 ,110,0,0 ,111,0,0 ,112,0,0 ,113,0,0 ,114,0,0 ,115,0,0 ,116,0,0 ,117,0,0 ,118,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 }; const unsigned char ecl_ucd_page_table_24[] = { 193,0,0 ,193,0,0 ,193,0,0 ,193,0,0 ,193,0,0 ,193,0,0 ,180,0,0 ,193,0,0 ,193,0,0 ,193,0,0 ,193,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,216,0,0 ,216,0,0 ,109,0,0 ,110,0,0 ,111,0,0 ,112,0,0 ,113,0,0 ,114,0,0 ,115,0,0 ,116,0,0 ,117,0,0 ,118,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,7,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,83,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 }; const unsigned char ecl_ucd_page_table_25[] = { 11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,35,0,0 ,35,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,29,0,0 ,29,0,0 ,35,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,81,0,0 ,84,0,0 ,80,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,212,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,193,0,0 ,193,0,0 ,109,0,0 ,110,0,0 ,111,0,0 ,112,0,0 ,113,0,0 ,114,0,0 ,115,0,0 ,116,0,0 ,117,0,0 ,118,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,29,0,0 ,29,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,109,0,0 ,110,0,0 ,111,0,0 ,112,0,0 ,113,0,0 ,114,0,0 ,115,0,0 ,116,0,0 ,117,0,0 ,118,0,0 ,153,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 }; const unsigned char ecl_ucd_page_table_26[] = { 11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,84,0,0 ,80,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,216,0,0 ,216,0,0 ,192,0,0 ,192,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,29,0,0 ,35,0,0 ,29,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,216,0,0 ,39,0,0 ,29,0,0 ,35,0,0 ,29,0,0 ,29,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,35,0,0 ,35,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,216,0,0 ,216,0,0 ,80,0,0 ,109,0,0 ,110,0,0 ,111,0,0 ,112,0,0 ,113,0,0 ,114,0,0 ,115,0,0 ,116,0,0 ,117,0,0 ,118,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,109,0,0 ,110,0,0 ,111,0,0 ,112,0,0 ,113,0,0 ,114,0,0 ,115,0,0 ,116,0,0 ,117,0,0 ,118,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,192,0,0 ,192,0,0 ,192,0,0 ,192,0,0 ,192,0,0 ,192,0,0 ,192,0,0 ,7,0,0 ,192,0,0 ,192,0,0 ,192,0,0 ,192,0,0 ,192,0,0 ,192,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 }; const unsigned char ecl_ucd_page_table_27[] = { 35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,29,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,37,0,0 ,29,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,29,0,0 ,35,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,35,0,0 ,29,0,0 ,30,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,109,0,0 ,110,0,0 ,111,0,0 ,112,0,0 ,113,0,0 ,114,0,0 ,115,0,0 ,116,0,0 ,117,0,0 ,118,0,0 ,192,0,0 ,192,0,0 ,192,0,0 ,192,0,0 ,192,0,0 ,192,0,0 ,192,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,84,0,0 ,80,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,35,0,0 ,35,0,0 ,29,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,29,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,29,0,0 ,29,0,0 ,35,0,0 ,35,0,0 ,30,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,109,0,0 ,110,0,0 ,111,0,0 ,112,0,0 ,113,0,0 ,114,0,0 ,115,0,0 ,116,0,0 ,117,0,0 ,118,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,37,0,0 ,29,0,0 ,35,0,0 ,35,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,35,0,0 ,29,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,30,0,0 ,30,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,192,0,0 ,192,0,0 ,192,0,0 ,192,0,0 }; const unsigned char ecl_ucd_page_table_28[] = { 11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,29,0,0 ,29,0,0 ,35,0,0 ,37,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,192,0,0 ,192,0,0 ,192,0,0 ,192,0,0 ,192,0,0 ,109,0,0 ,110,0,0 ,111,0,0 ,112,0,0 ,113,0,0 ,114,0,0 ,115,0,0 ,116,0,0 ,117,0,0 ,118,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,109,0,0 ,110,0,0 ,111,0,0 ,112,0,0 ,113,0,0 ,114,0,0 ,115,0,0 ,116,0,0 ,117,0,0 ,118,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,192,0,0 ,192,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,192,0,0 ,36,0,0 ,80,0,0 ,80,0,0 ,80,0,0 ,80,0,0 ,80,0,0 ,84,0,0 ,84,0,0 ,80,0,0 ,80,0,0 ,80,0,0 ,80,0,0 ,84,0,0 ,29,0,0 ,36,0,0 ,36,0,0 ,36,0,0 ,36,0,0 ,36,0,0 ,36,0,0 ,36,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,80,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,29,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 }; const unsigned char ecl_ucd_page_table_29[] = { 4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,7,0,0 ,1,125,167 ,4,0,0 ,4,0,0 ,4,0,0 ,1,99,44 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,84,0,0 ,84,0,0 ,80,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,80,0,0 ,84,0,0 ,84,0,0 ,87,0,0 ,77,0,0 ,80,0,0 ,76,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,86,0,0 ,80,0,0 ,84,0,0 ,80,0,0 }; const unsigned char ecl_ucd_page_table_30[] = { 0,1,30 ,1,0,30 ,0,3,30 ,1,2,30 ,0,5,30 ,1,4,30 ,0,7,30 ,1,6,30 ,0,9,30 ,1,8,30 ,0,11,30 ,1,10,30 ,0,13,30 ,1,12,30 ,0,15,30 ,1,14,30 ,0,17,30 ,1,16,30 ,0,19,30 ,1,18,30 ,0,21,30 ,1,20,30 ,0,23,30 ,1,22,30 ,0,25,30 ,1,24,30 ,0,27,30 ,1,26,30 ,0,29,30 ,1,28,30 ,0,31,30 ,1,30,30 ,0,33,30 ,1,32,30 ,0,35,30 ,1,34,30 ,0,37,30 ,1,36,30 ,0,39,30 ,1,38,30 ,0,41,30 ,1,40,30 ,0,43,30 ,1,42,30 ,0,45,30 ,1,44,30 ,0,47,30 ,1,46,30 ,0,49,30 ,1,48,30 ,0,51,30 ,1,50,30 ,0,53,30 ,1,52,30 ,0,55,30 ,1,54,30 ,0,57,30 ,1,56,30 ,0,59,30 ,1,58,30 ,0,61,30 ,1,60,30 ,0,63,30 ,1,62,30 ,0,65,30 ,1,64,30 ,0,67,30 ,1,66,30 ,0,69,30 ,1,68,30 ,0,71,30 ,1,70,30 ,0,73,30 ,1,72,30 ,0,75,30 ,1,74,30 ,0,77,30 ,1,76,30 ,0,79,30 ,1,78,30 ,0,81,30 ,1,80,30 ,0,83,30 ,1,82,30 ,0,85,30 ,1,84,30 ,0,87,30 ,1,86,30 ,0,89,30 ,1,88,30 ,0,91,30 ,1,90,30 ,0,93,30 ,1,92,30 ,0,95,30 ,1,94,30 ,0,97,30 ,1,96,30 ,0,99,30 ,1,98,30 ,0,101,30 ,1,100,30 ,0,103,30 ,1,102,30 ,0,105,30 ,1,104,30 ,0,107,30 ,1,106,30 ,0,109,30 ,1,108,30 ,0,111,30 ,1,110,30 ,0,113,30 ,1,112,30 ,0,115,30 ,1,114,30 ,0,117,30 ,1,116,30 ,0,119,30 ,1,118,30 ,0,121,30 ,1,120,30 ,0,123,30 ,1,122,30 ,0,125,30 ,1,124,30 ,0,127,30 ,1,126,30 ,0,129,30 ,1,128,30 ,0,131,30 ,1,130,30 ,0,133,30 ,1,132,30 ,0,135,30 ,1,134,30 ,0,137,30 ,1,136,30 ,0,139,30 ,1,138,30 ,0,141,30 ,1,140,30 ,0,143,30 ,1,142,30 ,0,145,30 ,1,144,30 ,0,147,30 ,1,146,30 ,0,149,30 ,1,148,30 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,96,30 ,4,0,0 ,4,0,0 ,3,223,0 ,4,0,0 ,0,161,30 ,1,160,30 ,0,163,30 ,1,162,30 ,0,165,30 ,1,164,30 ,0,167,30 ,1,166,30 ,0,169,30 ,1,168,30 ,0,171,30 ,1,170,30 ,0,173,30 ,1,172,30 ,0,175,30 ,1,174,30 ,0,177,30 ,1,176,30 ,0,179,30 ,1,178,30 ,0,181,30 ,1,180,30 ,0,183,30 ,1,182,30 ,0,185,30 ,1,184,30 ,0,187,30 ,1,186,30 ,0,189,30 ,1,188,30 ,0,191,30 ,1,190,30 ,0,193,30 ,1,192,30 ,0,195,30 ,1,194,30 ,0,197,30 ,1,196,30 ,0,199,30 ,1,198,30 ,0,201,30 ,1,200,30 ,0,203,30 ,1,202,30 ,0,205,30 ,1,204,30 ,0,207,30 ,1,206,30 ,0,209,30 ,1,208,30 ,0,211,30 ,1,210,30 ,0,213,30 ,1,212,30 ,0,215,30 ,1,214,30 ,0,217,30 ,1,216,30 ,0,219,30 ,1,218,30 ,0,221,30 ,1,220,30 ,0,223,30 ,1,222,30 ,0,225,30 ,1,224,30 ,0,227,30 ,1,226,30 ,0,229,30 ,1,228,30 ,0,231,30 ,1,230,30 ,0,233,30 ,1,232,30 ,0,235,30 ,1,234,30 ,0,237,30 ,1,236,30 ,0,239,30 ,1,238,30 ,0,241,30 ,1,240,30 ,0,243,30 ,1,242,30 ,0,245,30 ,1,244,30 ,0,247,30 ,1,246,30 ,0,249,30 ,1,248,30 ,0,251,30 ,1,250,30 ,0,253,30 ,1,252,30 ,0,255,30 ,1,254,30 }; const unsigned char ecl_ucd_page_table_31[] = { 1,8,31 ,1,9,31 ,1,10,31 ,1,11,31 ,1,12,31 ,1,13,31 ,1,14,31 ,1,15,31 ,0,0,31 ,0,1,31 ,0,2,31 ,0,3,31 ,0,4,31 ,0,5,31 ,0,6,31 ,0,7,31 ,1,24,31 ,1,25,31 ,1,26,31 ,1,27,31 ,1,28,31 ,1,29,31 ,216,0,0 ,216,0,0 ,0,16,31 ,0,17,31 ,0,18,31 ,0,19,31 ,0,20,31 ,0,21,31 ,216,0,0 ,216,0,0 ,1,40,31 ,1,41,31 ,1,42,31 ,1,43,31 ,1,44,31 ,1,45,31 ,1,46,31 ,1,47,31 ,0,32,31 ,0,33,31 ,0,34,31 ,0,35,31 ,0,36,31 ,0,37,31 ,0,38,31 ,0,39,31 ,1,56,31 ,1,57,31 ,1,58,31 ,1,59,31 ,1,60,31 ,1,61,31 ,1,62,31 ,1,63,31 ,0,48,31 ,0,49,31 ,0,50,31 ,0,51,31 ,0,52,31 ,0,53,31 ,0,54,31 ,0,55,31 ,1,72,31 ,1,73,31 ,1,74,31 ,1,75,31 ,1,76,31 ,1,77,31 ,216,0,0 ,216,0,0 ,0,64,31 ,0,65,31 ,0,66,31 ,0,67,31 ,0,68,31 ,0,69,31 ,216,0,0 ,216,0,0 ,4,0,0 ,1,89,31 ,4,0,0 ,1,91,31 ,4,0,0 ,1,93,31 ,4,0,0 ,1,95,31 ,216,0,0 ,0,81,31 ,216,0,0 ,0,83,31 ,216,0,0 ,0,85,31 ,216,0,0 ,0,87,31 ,1,104,31 ,1,105,31 ,1,106,31 ,1,107,31 ,1,108,31 ,1,109,31 ,1,110,31 ,1,111,31 ,0,96,31 ,0,97,31 ,0,98,31 ,0,99,31 ,0,100,31 ,0,101,31 ,0,102,31 ,0,103,31 ,1,186,31 ,1,187,31 ,1,200,31 ,1,201,31 ,1,202,31 ,1,203,31 ,1,218,31 ,1,219,31 ,1,248,31 ,1,249,31 ,1,234,31 ,1,235,31 ,1,250,31 ,1,251,31 ,216,0,0 ,216,0,0 ,1,136,31 ,1,137,31 ,1,138,31 ,1,139,31 ,1,140,31 ,1,141,31 ,1,142,31 ,1,143,31 ,5,128,31 ,5,129,31 ,5,130,31 ,5,131,31 ,5,132,31 ,5,133,31 ,5,134,31 ,5,135,31 ,1,152,31 ,1,153,31 ,1,154,31 ,1,155,31 ,1,156,31 ,1,157,31 ,1,158,31 ,1,159,31 ,5,144,31 ,5,145,31 ,5,146,31 ,5,147,31 ,5,148,31 ,5,149,31 ,5,150,31 ,5,151,31 ,1,168,31 ,1,169,31 ,1,170,31 ,1,171,31 ,1,172,31 ,1,173,31 ,1,174,31 ,1,175,31 ,5,160,31 ,5,161,31 ,5,162,31 ,5,163,31 ,5,164,31 ,5,165,31 ,5,166,31 ,5,167,31 ,1,184,31 ,1,185,31 ,4,0,0 ,1,188,31 ,4,0,0 ,216,0,0 ,4,0,0 ,4,0,0 ,0,176,31 ,0,177,31 ,0,112,31 ,0,113,31 ,5,179,31 ,201,0,0 ,4,153,3 ,201,0,0 ,201,0,0 ,201,0,0 ,4,0,0 ,1,204,31 ,4,0,0 ,216,0,0 ,4,0,0 ,4,0,0 ,0,114,31 ,0,115,31 ,0,116,31 ,0,117,31 ,5,195,31 ,201,0,0 ,201,0,0 ,201,0,0 ,1,216,31 ,1,217,31 ,4,0,0 ,4,0,0 ,216,0,0 ,216,0,0 ,4,0,0 ,4,0,0 ,0,208,31 ,0,209,31 ,0,118,31 ,0,119,31 ,216,0,0 ,201,0,0 ,201,0,0 ,201,0,0 ,1,232,31 ,1,233,31 ,4,0,0 ,4,0,0 ,4,0,0 ,1,236,31 ,4,0,0 ,4,0,0 ,0,224,31 ,0,225,31 ,0,122,31 ,0,123,31 ,0,229,31 ,201,0,0 ,201,0,0 ,201,0,0 ,216,0,0 ,216,0,0 ,4,0,0 ,1,252,31 ,4,0,0 ,216,0,0 ,4,0,0 ,4,0,0 ,0,120,31 ,0,121,31 ,0,124,31 ,0,125,31 ,5,243,31 ,201,0,0 ,201,0,0 ,216,0,0 }; ecl-16.1.2/src/c/unicode/ucd16-0032.c000066400000000000000000001116751266352375300165020ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ const unsigned char ecl_ucd_page_table_32[] = { 216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,18,0,0 ,18,0,0 ,18,0,0 ,19,0,0 ,24,0,0 ,180,0,0 ,180,0,0 ,180,0,0 ,180,0,0 ,180,0,0 ,180,0,0 ,193,0,0 ,193,0,0 ,186,0,0 ,184,0,0 ,195,0,0 ,186,0,0 ,186,0,0 ,184,0,0 ,195,0,0 ,186,0,0 ,193,0,0 ,193,0,0 ,193,0,0 ,193,0,0 ,193,0,0 ,193,0,0 ,193,0,0 ,193,0,0 ,213,0,0 ,214,0,0 ,20,0,0 ,25,0,0 ,23,0,0 ,21,0,0 ,26,0,0 ,215,0,0 ,191,0,0 ,191,0,0 ,191,0,0 ,191,0,0 ,191,0,0 ,193,0,0 ,193,0,0 ,193,0,0 ,193,0,0 ,187,0,0 ,185,0,0 ,193,0,0 ,193,0,0 ,193,0,0 ,193,0,0 ,178,0,0 ,178,0,0 ,193,0,0 ,193,0,0 ,193,0,0 ,203,0,0 ,196,0,0 ,183,0,0 ,193,0,0 ,193,0,0 ,193,0,0 ,193,0,0 ,193,0,0 ,193,0,0 ,193,0,0 ,193,0,0 ,193,0,0 ,193,0,0 ,193,0,0 ,207,0,0 ,193,0,0 ,178,0,0 ,193,0,0 ,193,0,0 ,193,0,0 ,193,0,0 ,193,0,0 ,193,0,0 ,193,0,0 ,193,0,0 ,193,0,0 ,193,0,0 ,216,0,0 ,18,0,0 ,18,0,0 ,18,0,0 ,18,0,0 ,18,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,18,0,0 ,18,0,0 ,18,0,0 ,18,0,0 ,18,0,0 ,18,0,0 ,142,0,0 ,7,0,0 ,216,0,0 ,216,0,0 ,146,0,0 ,147,0,0 ,148,0,0 ,149,0,0 ,150,0,0 ,151,0,0 ,204,0,0 ,204,0,0 ,207,0,0 ,196,0,0 ,183,0,0 ,7,0,0 ,142,0,0 ,143,0,0 ,144,0,0 ,145,0,0 ,146,0,0 ,147,0,0 ,148,0,0 ,149,0,0 ,150,0,0 ,151,0,0 ,204,0,0 ,204,0,0 ,207,0,0 ,196,0,0 ,183,0,0 ,216,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,198,0,0 ,198,0,0 ,198,0,0 ,198,0,0 ,198,0,0 ,198,0,0 ,198,0,0 ,198,0,0 ,198,0,0 ,198,0,0 ,198,0,0 ,198,0,0 ,198,0,0 ,198,0,0 ,198,0,0 ,198,0,0 ,198,0,0 ,198,0,0 ,198,0,0 ,198,0,0 ,198,0,0 ,198,0,0 ,198,0,0 ,198,0,0 ,198,0,0 ,198,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,84,0,0 ,84,0,0 ,36,0,0 ,36,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,36,0,0 ,36,0,0 ,36,0,0 ,84,0,0 ,84,0,0 ,33,0,0 ,33,0,0 ,33,0,0 ,33,0,0 ,84,0,0 ,33,0,0 ,33,0,0 ,33,0,0 ,36,0,0 ,36,0,0 ,84,0,0 ,80,0,0 ,84,0,0 ,36,0,0 ,36,0,0 ,80,0,0 ,80,0,0 ,80,0,0 ,80,0,0 ,84,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 }; const unsigned char ecl_ucd_page_table_33[] = { 212,0,0 ,212,0,0 ,3,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,3,0,0 ,212,0,0 ,212,0,0 ,4,0,0 ,3,0,0 ,3,0,0 ,3,0,0 ,4,0,0 ,4,0,0 ,3,0,0 ,3,0,0 ,3,0,0 ,4,0,0 ,212,0,0 ,3,0,0 ,212,0,0 ,212,0,0 ,207,0,0 ,3,0,0 ,3,0,0 ,3,0,0 ,3,0,0 ,3,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,3,0,0 ,212,0,0 ,3,201,3 ,212,0,0 ,3,0,0 ,212,0,0 ,3,107,0 ,3,229,0 ,3,0,0 ,3,0,0 ,210,0,0 ,4,0,0 ,3,0,0 ,3,0,0 ,0,78,33 ,3,0,0 ,4,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,4,0,0 ,212,0,0 ,212,0,0 ,4,0,0 ,4,0,0 ,3,0,0 ,3,0,0 ,208,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,3,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,212,0,0 ,207,0,0 ,212,0,0 ,212,0,0 ,1,50,33 ,211,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,129,112,33 ,129,113,33 ,129,114,33 ,129,115,33 ,129,116,33 ,129,117,33 ,129,118,33 ,129,119,33 ,129,120,33 ,129,121,33 ,129,122,33 ,129,123,33 ,129,124,33 ,129,125,33 ,129,126,33 ,129,127,33 ,129,96,33 ,129,97,33 ,129,98,33 ,129,99,33 ,129,100,33 ,129,101,33 ,129,102,33 ,129,103,33 ,129,104,33 ,129,105,33 ,129,106,33 ,129,107,33 ,129,108,33 ,129,109,33 ,129,110,33 ,129,111,33 ,129,0,0 ,129,0,0 ,129,0,0 ,0,132,33 ,1,131,33 ,129,0,0 ,129,0,0 ,129,0,0 ,129,0,0 ,162,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,207,0,0 ,207,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,207,0,0 ,212,0,0 ,212,0,0 ,207,0,0 ,212,0,0 ,212,0,0 ,207,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,207,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,207,0,0 ,207,0,0 ,212,0,0 ,212,0,0 ,207,0,0 ,212,0,0 ,207,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 }; const unsigned char ecl_ucd_page_table_34[] = { 207,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,208,0,0 ,204,0,0 ,205,0,0 ,207,0,0 ,208,0,0 ,208,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,207,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,207,0,0 ,208,0,0 ,207,0,0 ,208,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,208,0,0 ,207,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,208,0,0 ,208,0,0 ,207,0,0 ,208,0,0 ,207,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,207,0,0 ,207,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,207,0,0 ,207,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,208,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,208,0,0 ,208,0,0 ,207,0,0 ,207,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,208,0,0 ,208,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,207,0,0 ,207,0,0 ,208,0,0 ,208,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,207,0,0 ,207,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 }; const unsigned char ecl_ucd_page_table_35[] = { 212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,208,0,0 ,208,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,196,0,0 ,183,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,212,0,0 ,207,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,211,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 }; const unsigned char ecl_ucd_page_table_36[] = { 212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,164,0,0 ,165,0,0 ,166,0,0 ,167,0,0 ,168,0,0 ,169,0,0 ,170,0,0 ,171,0,0 ,172,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,164,0,0 ,165,0,0 ,166,0,0 ,167,0,0 ,168,0,0 ,169,0,0 ,170,0,0 ,171,0,0 ,172,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,143,0,0 ,144,0,0 ,145,0,0 ,146,0,0 ,147,0,0 ,148,0,0 ,149,0,0 ,150,0,0 ,151,0,0 ,141,0,0 ,141,0,0 ,141,0,0 ,141,0,0 ,141,0,0 ,141,0,0 ,141,0,0 ,141,0,0 ,141,0,0 ,141,0,0 ,141,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,208,36 ,211,209,36 ,211,210,36 ,211,211,36 ,211,212,36 ,211,213,36 ,211,214,36 ,211,215,36 ,211,216,36 ,211,217,36 ,211,218,36 ,211,219,36 ,211,220,36 ,211,221,36 ,211,222,36 ,211,223,36 ,211,224,36 ,211,225,36 ,211,226,36 ,211,227,36 ,211,228,36 ,211,229,36 ,211,230,36 ,211,231,36 ,211,232,36 ,211,233,36 ,211,182,36 ,211,183,36 ,211,184,36 ,211,185,36 ,211,186,36 ,211,187,36 ,211,188,36 ,211,189,36 ,211,190,36 ,211,191,36 ,211,192,36 ,211,193,36 ,211,194,36 ,211,195,36 ,211,196,36 ,211,197,36 ,211,198,36 ,211,199,36 ,211,200,36 ,211,201,36 ,211,202,36 ,211,203,36 ,211,204,36 ,211,205,36 ,211,206,36 ,211,207,36 ,163,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,164,0,0 ,165,0,0 ,166,0,0 ,167,0,0 ,168,0,0 ,169,0,0 ,170,0,0 ,171,0,0 ,172,0,0 ,162,0,0 ,163,0,0 }; const unsigned char ecl_ucd_page_table_37[] = { 212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,207,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,207,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 }; const unsigned char ecl_ucd_page_table_38[] = { 212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,207,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,211,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 }; const unsigned char ecl_ucd_page_table_39[] = { 216,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,196,0,0 ,183,0,0 ,196,0,0 ,183,0,0 ,196,0,0 ,183,0,0 ,196,0,0 ,183,0,0 ,196,0,0 ,183,0,0 ,196,0,0 ,183,0,0 ,196,0,0 ,183,0,0 ,164,0,0 ,165,0,0 ,166,0,0 ,167,0,0 ,168,0,0 ,169,0,0 ,170,0,0 ,171,0,0 ,172,0,0 ,162,0,0 ,164,0,0 ,165,0,0 ,166,0,0 ,167,0,0 ,168,0,0 ,169,0,0 ,170,0,0 ,171,0,0 ,172,0,0 ,162,0,0 ,164,0,0 ,165,0,0 ,166,0,0 ,167,0,0 ,168,0,0 ,169,0,0 ,170,0,0 ,171,0,0 ,172,0,0 ,162,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,208,0,0 ,207,0,0 ,207,0,0 ,208,0,0 ,208,0,0 ,196,0,0 ,183,0,0 ,207,0,0 ,208,0,0 ,208,0,0 ,207,0,0 ,216,0,0 ,208,0,0 ,216,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,196,0,0 ,183,0,0 ,196,0,0 ,183,0,0 ,196,0,0 ,183,0,0 ,196,0,0 ,183,0,0 ,196,0,0 ,183,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 }; const unsigned char ecl_ucd_page_table_40[] = { 211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 }; const unsigned char ecl_ucd_page_table_41[] = { 207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,196,0,0 ,183,0,0 ,196,0,0 ,183,0,0 ,196,0,0 ,183,0,0 ,196,0,0 ,183,0,0 ,196,0,0 ,183,0,0 ,196,0,0 ,183,0,0 ,196,0,0 ,183,0,0 ,196,0,0 ,183,0,0 ,196,0,0 ,183,0,0 ,196,0,0 ,183,0,0 ,196,0,0 ,183,0,0 ,207,0,0 ,207,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,208,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,208,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,207,0,0 ,208,0,0 ,208,0,0 ,207,0,0 ,207,0,0 ,196,0,0 ,183,0,0 ,196,0,0 ,183,0,0 ,208,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,208,0,0 ,207,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,207,0,0 ,207,0,0 ,208,0,0 ,208,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,207,0,0 ,207,0,0 ,196,0,0 ,183,0,0 ,207,0,0 ,207,0,0 }; const unsigned char ecl_ucd_page_table_42[] = { 207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,207,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,207,0,0 ,207,0,0 ,208,0,0 ,207,0,0 ,208,0,0 ,207,0,0 ,207,0,0 ,208,0,0 ,207,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,208,0,0 ,208,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,208,0,0 ,208,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,208,0,0 ,208,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,207,0,0 ,208,0,0 ,208,0,0 ,207,0,0 ,207,0,0 ,208,0,0 ,208,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,207,0,0 ,207,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,207,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,208,0,0 ,207,0,0 ,208,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,208,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,208,0,0 ,207,0,0 ,208,0,0 ,207,0,0 ,207,0,0 }; const unsigned char ecl_ucd_page_table_43[] = { 212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,212,0,0 ,212,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 }; const unsigned char ecl_ucd_page_table_44[] = { 0,48,44 ,0,49,44 ,0,50,44 ,0,51,44 ,0,52,44 ,0,53,44 ,0,54,44 ,0,55,44 ,0,56,44 ,0,57,44 ,0,58,44 ,0,59,44 ,0,60,44 ,0,61,44 ,0,62,44 ,0,63,44 ,0,64,44 ,0,65,44 ,0,66,44 ,0,67,44 ,0,68,44 ,0,69,44 ,0,70,44 ,0,71,44 ,0,72,44 ,0,73,44 ,0,74,44 ,0,75,44 ,0,76,44 ,0,77,44 ,0,78,44 ,0,79,44 ,0,80,44 ,0,81,44 ,0,82,44 ,0,83,44 ,0,84,44 ,0,85,44 ,0,86,44 ,0,87,44 ,0,88,44 ,0,89,44 ,0,90,44 ,0,91,44 ,0,92,44 ,0,93,44 ,0,94,44 ,216,0,0 ,1,0,44 ,1,1,44 ,1,2,44 ,1,3,44 ,1,4,44 ,1,5,44 ,1,6,44 ,1,7,44 ,1,8,44 ,1,9,44 ,1,10,44 ,1,11,44 ,1,12,44 ,1,13,44 ,1,14,44 ,1,15,44 ,1,16,44 ,1,17,44 ,1,18,44 ,1,19,44 ,1,20,44 ,1,21,44 ,1,22,44 ,1,23,44 ,1,24,44 ,1,25,44 ,1,26,44 ,1,27,44 ,1,28,44 ,1,29,44 ,1,30,44 ,1,31,44 ,1,32,44 ,1,33,44 ,1,34,44 ,1,35,44 ,1,36,44 ,1,37,44 ,1,38,44 ,1,39,44 ,1,40,44 ,1,41,44 ,1,42,44 ,1,43,44 ,1,44,44 ,1,45,44 ,1,46,44 ,216,0,0 ,0,97,44 ,1,96,44 ,0,107,2 ,0,125,29 ,0,125,2 ,1,58,2 ,1,62,2 ,0,104,44 ,1,103,44 ,0,106,44 ,1,105,44 ,0,108,44 ,1,107,44 ,0,81,2 ,0,113,2 ,0,80,2 ,0,82,2 ,4,0,0 ,0,115,44 ,1,114,44 ,4,0,0 ,0,118,44 ,1,117,44 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,7,0,0 ,0,63,2 ,0,64,2 ,0,129,44 ,1,128,44 ,0,131,44 ,1,130,44 ,0,133,44 ,1,132,44 ,0,135,44 ,1,134,44 ,0,137,44 ,1,136,44 ,0,139,44 ,1,138,44 ,0,141,44 ,1,140,44 ,0,143,44 ,1,142,44 ,0,145,44 ,1,144,44 ,0,147,44 ,1,146,44 ,0,149,44 ,1,148,44 ,0,151,44 ,1,150,44 ,0,153,44 ,1,152,44 ,0,155,44 ,1,154,44 ,0,157,44 ,1,156,44 ,0,159,44 ,1,158,44 ,0,161,44 ,1,160,44 ,0,163,44 ,1,162,44 ,0,165,44 ,1,164,44 ,0,167,44 ,1,166,44 ,0,169,44 ,1,168,44 ,0,171,44 ,1,170,44 ,0,173,44 ,1,172,44 ,0,175,44 ,1,174,44 ,0,177,44 ,1,176,44 ,0,179,44 ,1,178,44 ,0,181,44 ,1,180,44 ,0,183,44 ,1,182,44 ,0,185,44 ,1,184,44 ,0,187,44 ,1,186,44 ,0,189,44 ,1,188,44 ,0,191,44 ,1,190,44 ,0,193,44 ,1,192,44 ,0,195,44 ,1,194,44 ,0,197,44 ,1,196,44 ,0,199,44 ,1,198,44 ,0,201,44 ,1,200,44 ,0,203,44 ,1,202,44 ,0,205,44 ,1,204,44 ,0,207,44 ,1,206,44 ,0,209,44 ,1,208,44 ,0,211,44 ,1,210,44 ,0,213,44 ,1,212,44 ,0,215,44 ,1,214,44 ,0,217,44 ,1,216,44 ,0,219,44 ,1,218,44 ,0,221,44 ,1,220,44 ,0,223,44 ,1,222,44 ,0,225,44 ,1,224,44 ,0,227,44 ,1,226,44 ,4,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,0,236,44 ,1,235,44 ,0,238,44 ,1,237,44 ,84,0,0 ,84,0,0 ,84,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,193,0,0 ,193,0,0 ,193,0,0 ,193,0,0 ,162,0,0 ,193,0,0 ,193,0,0 }; const unsigned char ecl_ucd_page_table_45[] = { 1,160,16 ,1,161,16 ,1,162,16 ,1,163,16 ,1,164,16 ,1,165,16 ,1,166,16 ,1,167,16 ,1,168,16 ,1,169,16 ,1,170,16 ,1,171,16 ,1,172,16 ,1,173,16 ,1,174,16 ,1,175,16 ,1,176,16 ,1,177,16 ,1,178,16 ,1,179,16 ,1,180,16 ,1,181,16 ,1,182,16 ,1,183,16 ,1,184,16 ,1,185,16 ,1,186,16 ,1,187,16 ,1,188,16 ,1,189,16 ,1,190,16 ,1,191,16 ,1,192,16 ,1,193,16 ,1,194,16 ,1,195,16 ,1,196,16 ,1,197,16 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,7,0,0 ,192,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,39,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 }; const unsigned char ecl_ucd_page_table_46[] = { 193,0,0 ,193,0,0 ,187,0,0 ,185,0,0 ,187,0,0 ,185,0,0 ,193,0,0 ,193,0,0 ,193,0,0 ,187,0,0 ,185,0,0 ,193,0,0 ,187,0,0 ,185,0,0 ,193,0,0 ,193,0,0 ,193,0,0 ,193,0,0 ,193,0,0 ,193,0,0 ,193,0,0 ,193,0,0 ,193,0,0 ,180,0,0 ,193,0,0 ,193,0,0 ,180,0,0 ,193,0,0 ,187,0,0 ,185,0,0 ,193,0,0 ,193,0,0 ,187,0,0 ,185,0,0 ,196,0,0 ,183,0,0 ,196,0,0 ,183,0,0 ,196,0,0 ,183,0,0 ,196,0,0 ,183,0,0 ,193,0,0 ,193,0,0 ,193,0,0 ,193,0,0 ,193,0,0 ,8,0,0 ,193,0,0 ,193,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,216,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 }; const unsigned char ecl_ucd_page_table_47[] = { 212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 }; ecl-16.1.2/src/c/unicode/ucd16-0048.c000066400000000000000000001053501266352375300165020ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ const unsigned char ecl_ucd_page_table_48[] = { 216,0,0 ,193,0,0 ,193,0,0 ,193,0,0 ,212,0,0 ,7,0,0 ,11,0,0 ,129,0,0 ,196,0,0 ,183,0,0 ,196,0,0 ,183,0,0 ,196,0,0 ,183,0,0 ,196,0,0 ,183,0,0 ,196,0,0 ,183,0,0 ,212,0,0 ,212,0,0 ,196,0,0 ,183,0,0 ,196,0,0 ,183,0,0 ,196,0,0 ,183,0,0 ,196,0,0 ,183,0,0 ,180,0,0 ,195,0,0 ,182,0,0 ,182,0,0 ,212,0,0 ,129,0,0 ,129,0,0 ,129,0,0 ,129,0,0 ,129,0,0 ,129,0,0 ,129,0,0 ,129,0,0 ,129,0,0 ,79,0,0 ,83,0,0 ,85,0,0 ,81,0,0 ,82,0,0 ,82,0,0 ,180,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,212,0,0 ,212,0,0 ,129,0,0 ,129,0,0 ,129,0,0 ,7,0,0 ,11,0,0 ,193,0,0 ,212,0,0 ,212,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,38,0,0 ,38,0,0 ,201,0,0 ,201,0,0 ,7,0,0 ,7,0,0 ,11,0,0 ,180,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,193,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,11,0,0 }; const unsigned char ecl_ucd_page_table_49[] = { 216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,211,0,0 ,211,0,0 ,152,0,0 ,152,0,0 ,152,0,0 ,152,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 }; const unsigned char ecl_ucd_page_table_50[] = { 211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,212,0,0 ,212,0,0 ,216,0,0 ,152,0,0 ,152,0,0 ,152,0,0 ,152,0,0 ,152,0,0 ,152,0,0 ,152,0,0 ,152,0,0 ,152,0,0 ,152,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,212,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,211,0,0 ,152,0,0 ,152,0,0 ,152,0,0 ,152,0,0 ,152,0,0 ,152,0,0 ,152,0,0 ,152,0,0 ,152,0,0 ,152,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,162,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,216,0,0 }; const unsigned char ecl_ucd_page_table_51[] = { 211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,212,0,0 ,212,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,212,0,0 }; const unsigned char ecl_ucd_page_table_52[] = { 11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 }; const unsigned char ecl_ucd_page_table_53[] = { 11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 }; const unsigned char ecl_ucd_page_table_54[] = { 11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,7,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 }; const unsigned char ecl_ucd_page_table_55[] = { 11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,7,0,0 ,192,0,0 ,192,0,0 }; const unsigned char ecl_ucd_page_table_56[] = { 11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,7,0,0 ,193,0,0 ,193,0,0 ,193,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,109,0,0 ,110,0,0 ,111,0,0 ,112,0,0 ,113,0,0 ,114,0,0 ,115,0,0 ,116,0,0 ,117,0,0 ,118,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,0,65,166 ,1,64,166 ,0,67,166 ,1,66,166 ,0,69,166 ,1,68,166 ,0,71,166 ,1,70,166 ,0,73,166 ,1,72,166 ,0,75,166 ,1,74,166 ,0,77,166 ,1,76,166 ,0,79,166 ,1,78,166 ,0,81,166 ,1,80,166 ,0,83,166 ,1,82,166 ,0,85,166 ,1,84,166 ,0,87,166 ,1,86,166 ,0,89,166 ,1,88,166 ,0,91,166 ,1,90,166 ,0,93,166 ,1,92,166 ,0,95,166 ,1,94,166 ,0,97,166 ,1,96,166 ,0,99,166 ,1,98,166 ,0,101,166 ,1,100,166 ,0,103,166 ,1,102,166 ,0,105,166 ,1,104,166 ,0,107,166 ,1,106,166 ,0,109,166 ,1,108,166 ,11,0,0 ,84,0,0 ,33,0,0 ,33,0,0 ,33,0,0 ,193,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,84,0,0 ,84,0,0 ,193,0,0 ,8,0,0 ,0,129,166 ,1,128,166 ,0,131,166 ,1,130,166 ,0,133,166 ,1,132,166 ,0,135,166 ,1,134,166 ,0,137,166 ,1,136,166 ,0,139,166 ,1,138,166 ,0,141,166 ,1,140,166 ,0,143,166 ,1,142,166 ,0,145,166 ,1,144,166 ,0,147,166 ,1,146,166 ,0,149,166 ,1,148,166 ,0,151,166 ,1,150,166 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,129,0,0 ,129,0,0 ,129,0,0 ,129,0,0 ,129,0,0 ,129,0,0 ,129,0,0 ,129,0,0 ,129,0,0 ,129,0,0 ,84,0,0 ,84,0,0 ,192,0,0 ,192,0,0 ,192,0,0 ,192,0,0 ,192,0,0 ,192,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 }; const unsigned char ecl_ucd_page_table_57[] = { 201,0,0 ,201,0,0 ,201,0,0 ,201,0,0 ,201,0,0 ,201,0,0 ,201,0,0 ,201,0,0 ,201,0,0 ,201,0,0 ,201,0,0 ,201,0,0 ,201,0,0 ,201,0,0 ,201,0,0 ,201,0,0 ,201,0,0 ,201,0,0 ,201,0,0 ,201,0,0 ,201,0,0 ,201,0,0 ,201,0,0 ,8,0,0 ,8,0,0 ,8,0,0 ,8,0,0 ,8,0,0 ,8,0,0 ,8,0,0 ,8,0,0 ,8,0,0 ,201,0,0 ,201,0,0 ,0,35,167 ,1,34,167 ,0,37,167 ,1,36,167 ,0,39,167 ,1,38,167 ,0,41,167 ,1,40,167 ,0,43,167 ,1,42,167 ,0,45,167 ,1,44,167 ,0,47,167 ,1,46,167 ,4,0,0 ,4,0,0 ,0,51,167 ,1,50,167 ,0,53,167 ,1,52,167 ,0,55,167 ,1,54,167 ,0,57,167 ,1,56,167 ,0,59,167 ,1,58,167 ,0,61,167 ,1,60,167 ,0,63,167 ,1,62,167 ,0,65,167 ,1,64,167 ,0,67,167 ,1,66,167 ,0,69,167 ,1,68,167 ,0,71,167 ,1,70,167 ,0,73,167 ,1,72,167 ,0,75,167 ,1,74,167 ,0,77,167 ,1,76,167 ,0,79,167 ,1,78,167 ,0,81,167 ,1,80,167 ,0,83,167 ,1,82,167 ,0,85,167 ,1,84,167 ,0,87,167 ,1,86,167 ,0,89,167 ,1,88,167 ,0,91,167 ,1,90,167 ,0,93,167 ,1,92,167 ,0,95,167 ,1,94,167 ,0,97,167 ,1,96,167 ,0,99,167 ,1,98,167 ,0,101,167 ,1,100,167 ,0,103,167 ,1,102,167 ,0,105,167 ,1,104,167 ,0,107,167 ,1,106,167 ,0,109,167 ,1,108,167 ,0,111,167 ,1,110,167 ,7,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,0,122,167 ,1,121,167 ,0,124,167 ,1,123,167 ,0,121,29 ,0,127,167 ,1,126,167 ,0,129,167 ,1,128,167 ,0,131,167 ,1,130,167 ,0,133,167 ,1,132,167 ,0,135,167 ,1,134,167 ,8,0,0 ,200,0,0 ,200,0,0 ,0,140,167 ,1,139,167 ,0,101,2 ,4,0,0 ,216,0,0 ,0,145,167 ,1,144,167 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,0,161,167 ,1,160,167 ,0,163,167 ,1,162,167 ,0,165,167 ,1,164,167 ,0,167,167 ,1,166,167 ,0,169,167 ,1,168,167 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,4,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 }; const unsigned char ecl_ucd_page_table_58[] = { 11,0,0 ,11,0,0 ,35,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,39,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,35,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,29,0,0 ,29,0,0 ,35,0,0 ,35,0,0 ,29,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,212,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,152,0,0 ,152,0,0 ,152,0,0 ,152,0,0 ,152,0,0 ,152,0,0 ,211,0,0 ,211,0,0 ,198,0,0 ,210,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,193,0,0 ,193,0,0 ,193,0,0 ,193,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,29,0,0 ,29,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,39,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,192,0,0 ,192,0,0 ,109,0,0 ,110,0,0 ,111,0,0 ,112,0,0 ,113,0,0 ,114,0,0 ,115,0,0 ,116,0,0 ,117,0,0 ,118,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,192,0,0 ,192,0,0 ,192,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 }; const unsigned char ecl_ucd_page_table_59[] = { 109,0,0 ,110,0,0 ,111,0,0 ,112,0,0 ,113,0,0 ,114,0,0 ,115,0,0 ,116,0,0 ,117,0,0 ,118,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,80,0,0 ,80,0,0 ,80,0,0 ,192,0,0 ,192,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,29,0,0 ,30,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,192,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,29,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,37,0,0 ,29,0,0 ,29,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,29,0,0 ,29,0,0 ,35,0,0 ,29,0,0 ,29,0,0 ,29,0,0 ,30,0,0 ,192,0,0 ,192,0,0 ,192,0,0 ,192,0,0 ,192,0,0 ,192,0,0 ,192,0,0 ,192,0,0 ,192,0,0 ,192,0,0 ,192,0,0 ,192,0,0 ,192,0,0 ,216,0,0 ,7,0,0 ,109,0,0 ,110,0,0 ,111,0,0 ,112,0,0 ,113,0,0 ,114,0,0 ,115,0,0 ,116,0,0 ,117,0,0 ,118,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,192,0,0 ,192,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 }; const unsigned char ecl_ucd_page_table_60[] = { 11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,29,0,0 ,29,0,0 ,35,0,0 ,35,0,0 ,29,0,0 ,29,0,0 ,35,0,0 ,35,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,35,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,35,0,0 ,29,0,0 ,216,0,0 ,216,0,0 ,109,0,0 ,110,0,0 ,111,0,0 ,112,0,0 ,113,0,0 ,114,0,0 ,115,0,0 ,116,0,0 ,117,0,0 ,118,0,0 ,216,0,0 ,216,0,0 ,192,0,0 ,192,0,0 ,192,0,0 ,192,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,7,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,211,0,0 ,211,0,0 ,211,0,0 ,11,0,0 ,29,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,84,0,0 ,11,0,0 ,84,0,0 ,84,0,0 ,80,0,0 ,11,0,0 ,11,0,0 ,84,0,0 ,84,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,84,0,0 ,84,0,0 ,11,0,0 ,84,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,7,0,0 ,192,0,0 ,192,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 }; const unsigned char ecl_ucd_page_table_61[] = { 216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,29,0,0 ,29,0,0 ,35,0,0 ,29,0,0 ,29,0,0 ,35,0,0 ,29,0,0 ,29,0,0 ,192,0,0 ,29,0,0 ,39,0,0 ,216,0,0 ,216,0,0 ,109,0,0 ,110,0,0 ,111,0,0 ,112,0,0 ,113,0,0 ,114,0,0 ,115,0,0 ,116,0,0 ,117,0,0 ,118,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 }; const unsigned char ecl_ucd_page_table_62[] = { 11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 }; const unsigned char ecl_ucd_page_table_63[] = { 28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 ,28,0,0 }; ecl-16.1.2/src/c/unicode/ucd16-0064.c000066400000000000000000000356151266352375300165060ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ const unsigned char ecl_ucd_page_table_64[] = { 27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 ,27,0,0 }; const unsigned char ecl_ucd_page_table_65[] = { 11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 }; const unsigned char ecl_ucd_page_table_66[] = { 4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,4,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,12,0,0 ,56,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,204,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,216,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,216,0,0 ,12,0,0 ,216,0,0 ,12,0,0 ,12,0,0 ,216,0,0 ,12,0,0 ,12,0,0 ,216,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,12,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,199,0,0 ,199,0,0 ,199,0,0 ,199,0,0 ,199,0,0 ,199,0,0 ,199,0,0 ,199,0,0 ,199,0,0 ,199,0,0 ,199,0,0 ,199,0,0 ,199,0,0 ,199,0,0 ,199,0,0 ,199,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 }; const unsigned char ecl_ucd_page_table_67[] = { 10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 }; const unsigned char ecl_ucd_page_table_68[] = { 10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,195,0,0 ,182,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,216,0,0 ,216,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,197,0,0 ,212,0,0 ,216,0,0 ,216,0,0 }; const unsigned char ecl_ucd_page_table_69[] = { 35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,35,0,0 ,193,0,0 ,193,0,0 ,193,0,0 ,193,0,0 ,193,0,0 ,193,0,0 ,193,0,0 ,195,0,0 ,182,0,0 ,193,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,84,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,193,0,0 ,180,0,0 ,180,0,0 ,178,0,0 ,178,0,0 ,195,0,0 ,182,0,0 ,195,0,0 ,182,0,0 ,195,0,0 ,182,0,0 ,195,0,0 ,182,0,0 ,195,0,0 ,182,0,0 ,195,0,0 ,182,0,0 ,195,0,0 ,182,0,0 ,195,0,0 ,182,0,0 ,193,0,0 ,193,0,0 ,195,0,0 ,182,0,0 ,193,0,0 ,193,0,0 ,193,0,0 ,193,0,0 ,178,0,0 ,178,0,0 ,178,0,0 ,190,0,0 ,193,0,0 ,190,0,0 ,216,0,0 ,193,0,0 ,190,0,0 ,193,0,0 ,193,0,0 ,180,0,0 ,196,0,0 ,183,0,0 ,196,0,0 ,183,0,0 ,196,0,0 ,183,0,0 ,191,0,0 ,193,0,0 ,193,0,0 ,204,0,0 ,179,0,0 ,208,0,0 ,208,0,0 ,207,0,0 ,216,0,0 ,193,0,0 ,198,0,0 ,191,0,0 ,193,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,216,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,10,0,0 ,216,0,0 ,216,0,0 ,18,0,0 }; const unsigned char ecl_ucd_page_table_70[] = { 216,0,0 ,193,0,0 ,193,0,0 ,191,0,0 ,198,0,0 ,191,0,0 ,193,0,0 ,193,0,0 ,196,0,0 ,183,0,0 ,193,0,0 ,204,0,0 ,190,0,0 ,179,0,0 ,190,0,0 ,190,0,0 ,99,0,0 ,100,0,0 ,101,0,0 ,102,0,0 ,103,0,0 ,104,0,0 ,105,0,0 ,106,0,0 ,107,0,0 ,108,0,0 ,190,0,0 ,193,0,0 ,208,0,0 ,207,0,0 ,208,0,0 ,193,0,0 ,193,0,0 ,0,65,255 ,0,66,255 ,0,67,255 ,0,68,255 ,0,69,255 ,0,70,255 ,0,71,255 ,0,72,255 ,0,73,255 ,0,74,255 ,0,75,255 ,0,76,255 ,0,77,255 ,0,78,255 ,0,79,255 ,0,80,255 ,0,81,255 ,0,82,255 ,0,83,255 ,0,84,255 ,0,85,255 ,0,86,255 ,0,87,255 ,0,88,255 ,0,89,255 ,0,90,255 ,196,0,0 ,193,0,0 ,183,0,0 ,201,0,0 ,178,0,0 ,201,0,0 ,1,33,255 ,1,34,255 ,1,35,255 ,1,36,255 ,1,37,255 ,1,38,255 ,1,39,255 ,1,40,255 ,1,41,255 ,1,42,255 ,1,43,255 ,1,44,255 ,1,45,255 ,1,46,255 ,1,47,255 ,1,48,255 ,1,49,255 ,1,50,255 ,1,51,255 ,1,52,255 ,1,53,255 ,1,54,255 ,1,55,255 ,1,56,255 ,1,57,255 ,1,58,255 ,196,0,0 ,207,0,0 ,183,0,0 ,207,0,0 ,196,0,0 ,183,0,0 ,193,0,0 ,196,0,0 ,183,0,0 ,193,0,0 ,193,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,7,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,7,0,0 ,7,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,11,0,0 ,11,0,0 ,11,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,198,0,0 ,198,0,0 ,207,0,0 ,201,0,0 ,212,0,0 ,198,0,0 ,198,0,0 ,216,0,0 ,212,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,207,0,0 ,212,0,0 ,212,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,216,0,0 ,22,0,0 ,22,0,0 ,22,0,0 ,212,0,0 ,212,0,0 ,216,0,0 ,216,0,0 }; ecl-16.1.2/src/c/unicode/ucd16.c000066400000000000000000000357771266352375300161300ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ extern const char ecl_ucd_page_table_0[]; extern const char ecl_ucd_page_table_1[]; extern const char ecl_ucd_page_table_2[]; extern const char ecl_ucd_page_table_3[]; extern const char ecl_ucd_page_table_4[]; extern const char ecl_ucd_page_table_5[]; extern const char ecl_ucd_page_table_6[]; extern const char ecl_ucd_page_table_7[]; extern const char ecl_ucd_page_table_8[]; extern const char ecl_ucd_page_table_9[]; extern const char ecl_ucd_page_table_10[]; extern const char ecl_ucd_page_table_11[]; extern const char ecl_ucd_page_table_12[]; extern const char ecl_ucd_page_table_13[]; extern const char ecl_ucd_page_table_14[]; extern const char ecl_ucd_page_table_15[]; extern const char ecl_ucd_page_table_16[]; extern const char ecl_ucd_page_table_17[]; extern const char ecl_ucd_page_table_18[]; extern const char ecl_ucd_page_table_19[]; extern const char ecl_ucd_page_table_20[]; extern const char ecl_ucd_page_table_21[]; extern const char ecl_ucd_page_table_22[]; extern const char ecl_ucd_page_table_23[]; extern const char ecl_ucd_page_table_24[]; extern const char ecl_ucd_page_table_25[]; extern const char ecl_ucd_page_table_26[]; extern const char ecl_ucd_page_table_27[]; extern const char ecl_ucd_page_table_28[]; extern const char ecl_ucd_page_table_29[]; extern const char ecl_ucd_page_table_30[]; extern const char ecl_ucd_page_table_31[]; extern const char ecl_ucd_page_table_32[]; extern const char ecl_ucd_page_table_33[]; extern const char ecl_ucd_page_table_34[]; extern const char ecl_ucd_page_table_35[]; extern const char ecl_ucd_page_table_36[]; extern const char ecl_ucd_page_table_37[]; extern const char ecl_ucd_page_table_38[]; extern const char ecl_ucd_page_table_39[]; extern const char ecl_ucd_page_table_40[]; extern const char ecl_ucd_page_table_41[]; extern const char ecl_ucd_page_table_42[]; extern const char ecl_ucd_page_table_43[]; extern const char ecl_ucd_page_table_44[]; extern const char ecl_ucd_page_table_45[]; extern const char ecl_ucd_page_table_46[]; extern const char ecl_ucd_page_table_47[]; extern const char ecl_ucd_page_table_48[]; extern const char ecl_ucd_page_table_49[]; extern const char ecl_ucd_page_table_50[]; extern const char ecl_ucd_page_table_51[]; extern const char ecl_ucd_page_table_52[]; extern const char ecl_ucd_page_table_53[]; extern const char ecl_ucd_page_table_54[]; extern const char ecl_ucd_page_table_55[]; extern const char ecl_ucd_page_table_56[]; extern const char ecl_ucd_page_table_57[]; extern const char ecl_ucd_page_table_58[]; extern const char ecl_ucd_page_table_59[]; extern const char ecl_ucd_page_table_60[]; extern const char ecl_ucd_page_table_61[]; extern const char ecl_ucd_page_table_62[]; extern const char ecl_ucd_page_table_63[]; extern const char ecl_ucd_page_table_64[]; extern const char ecl_ucd_page_table_65[]; extern const char ecl_ucd_page_table_66[]; extern const char ecl_ucd_page_table_67[]; extern const char ecl_ucd_page_table_68[]; extern const char ecl_ucd_page_table_69[]; extern const char ecl_ucd_page_table_70[]; const unsigned char ecl_ucd_misc_table[1736] = { 0, 8, 0, 255, 255, 0, 0, 0 ,1, 8, 0, 255, 255, 0, 0, 0 ,0, 0, 0, 255, 255, 0, 0, 0 ,0, 8, 0, 255, 255, 0, 0, 0 ,1, 8, 0, 255, 255, 0, 0, 0 ,2, 8, 0, 255, 255, 0, 0, 0 ,3, 0, 0, 255, 255, 0, 0, 0 ,3, 8, 0, 255, 255, 0, 0, 0 ,3, 12, 0, 255, 255, 0, 0, 0 ,3, 14, 0, 255, 255, 0, 0, 0 ,4, 0, 0, 255, 255, 0, 0, 0 ,4, 8, 0, 255, 255, 0, 0, 0 ,4, 14, 0, 255, 255, 0, 0, 0 ,5, 2, 0, 255, 255, 0, 0, 0 ,5, 3, 0, 255, 255, 0, 0, 0 ,5, 17, 0, 255, 255, 0, 0, 0 ,5, 18, 0, 255, 255, 0, 0, 0 ,6, 1, 0, 255, 255, 0, 0, 0 ,6, 3, 0, 255, 255, 0, 0, 0 ,6, 8, 0, 255, 255, 0, 0, 0 ,6, 9, 0, 255, 255, 0, 0, 0 ,6, 10, 0, 255, 255, 0, 0, 0 ,6, 12, 0, 255, 255, 0, 0, 0 ,6, 13, 0, 255, 255, 0, 0, 0 ,6, 14, 0, 255, 255, 0, 0, 0 ,6, 15, 0, 255, 255, 0, 0, 0 ,6, 16, 0, 255, 255, 0, 0, 0 ,7, 8, 0, 255, 255, 0, 0, 0 ,8, 8, 0, 255, 255, 0, 0, 0 ,9, 8, 0, 255, 255, 0, 0, 0 ,9, 8, 9, 255, 255, 0, 0, 0 ,9, 8, 216, 255, 255, 0, 0, 0 ,9, 8, 226, 255, 255, 0, 0, 0 ,10, 11, 0, 255, 255, 0, 0, 0 ,11, 8, 0, 255, 255, 0, 0, 0 ,11, 11, 0, 255, 255, 0, 0, 0 ,11, 11, 1, 255, 255, 0, 0, 0 ,11, 11, 7, 255, 255, 0, 0, 0 ,11, 11, 8, 255, 255, 0, 0, 0 ,11, 11, 9, 255, 255, 0, 0, 0 ,11, 11, 10, 255, 255, 0, 0, 0 ,11, 11, 11, 255, 255, 0, 0, 0 ,11, 11, 12, 255, 255, 0, 0, 0 ,11, 11, 13, 255, 255, 0, 0, 0 ,11, 11, 14, 255, 255, 0, 0, 0 ,11, 11, 15, 255, 255, 0, 0, 0 ,11, 11, 16, 255, 255, 0, 0, 0 ,11, 11, 17, 255, 255, 0, 0, 0 ,11, 11, 18, 255, 255, 0, 0, 0 ,11, 11, 19, 255, 255, 0, 0, 0 ,11, 11, 20, 255, 255, 0, 0, 0 ,11, 11, 21, 255, 255, 0, 0, 0 ,11, 11, 22, 255, 255, 0, 0, 0 ,11, 11, 23, 255, 255, 0, 0, 0 ,11, 11, 24, 255, 255, 0, 0, 0 ,11, 11, 25, 255, 255, 0, 0, 0 ,11, 11, 26, 255, 255, 0, 0, 0 ,11, 11, 27, 255, 255, 0, 0, 0 ,11, 11, 28, 255, 255, 0, 0, 0 ,11, 11, 29, 255, 255, 0, 0, 0 ,11, 11, 30, 255, 255, 0, 0, 0 ,11, 11, 31, 255, 255, 0, 0, 0 ,11, 11, 32, 255, 255, 0, 0, 0 ,11, 11, 33, 255, 255, 0, 0, 0 ,11, 11, 34, 255, 255, 0, 0, 0 ,11, 11, 35, 255, 255, 0, 0, 0 ,11, 11, 36, 255, 255, 0, 0, 0 ,11, 11, 84, 255, 255, 0, 0, 0 ,11, 11, 91, 255, 255, 0, 0, 0 ,11, 11, 103, 255, 255, 0, 0, 0 ,11, 11, 107, 255, 255, 0, 0, 0 ,11, 11, 118, 255, 255, 0, 0, 0 ,11, 11, 122, 255, 255, 0, 0, 0 ,11, 11, 129, 255, 255, 0, 0, 0 ,11, 11, 130, 255, 255, 0, 0, 0 ,11, 11, 132, 255, 255, 0, 0, 0 ,11, 11, 202, 255, 255, 0, 0, 0 ,11, 11, 214, 255, 255, 0, 0, 0 ,11, 11, 216, 255, 255, 0, 0, 0 ,11, 11, 218, 255, 255, 0, 0, 0 ,11, 11, 220, 255, 255, 0, 0, 0 ,11, 11, 222, 255, 255, 0, 0, 0 ,11, 11, 224, 255, 255, 0, 0, 0 ,11, 11, 228, 255, 255, 0, 0, 0 ,11, 11, 230, 255, 255, 0, 0, 0 ,11, 11, 232, 255, 255, 0, 0, 0 ,11, 11, 233, 255, 255, 0, 0, 0 ,11, 11, 234, 255, 255, 0, 0, 0 ,11, 11, 240, 255, 255, 0, 0, 0 ,12, 1, 0, 0, 0, 0, 0, 0 ,12, 1, 0, 1, 1, 0, 0, 0 ,12, 1, 0, 2, 2, 0, 0, 0 ,12, 1, 0, 3, 3, 0, 0, 0 ,12, 1, 0, 4, 4, 0, 0, 0 ,12, 1, 0, 5, 5, 0, 0, 0 ,12, 1, 0, 6, 6, 0, 0, 0 ,12, 1, 0, 7, 7, 0, 0, 0 ,12, 1, 0, 8, 8, 0, 0, 0 ,12, 1, 0, 9, 9, 0, 0, 0 ,12, 5, 0, 0, 0, 0, 0, 0 ,12, 5, 0, 1, 1, 0, 0, 0 ,12, 5, 0, 2, 2, 0, 0, 0 ,12, 5, 0, 3, 3, 0, 0, 0 ,12, 5, 0, 4, 4, 0, 0, 0 ,12, 5, 0, 5, 5, 0, 0, 0 ,12, 5, 0, 6, 6, 0, 0, 0 ,12, 5, 0, 7, 7, 0, 0, 0 ,12, 5, 0, 8, 8, 0, 0, 0 ,12, 5, 0, 9, 9, 0, 0, 0 ,12, 8, 0, 0, 0, 0, 0, 0 ,12, 8, 0, 1, 1, 0, 0, 0 ,12, 8, 0, 2, 2, 0, 0, 0 ,12, 8, 0, 3, 3, 0, 0, 0 ,12, 8, 0, 4, 4, 0, 0, 0 ,12, 8, 0, 5, 5, 0, 0, 0 ,12, 8, 0, 6, 6, 0, 0, 0 ,12, 8, 0, 7, 7, 0, 0, 0 ,12, 8, 0, 8, 8, 0, 0, 0 ,12, 8, 0, 9, 9, 0, 0, 0 ,12, 14, 0, 0, 0, 0, 0, 0 ,12, 14, 0, 1, 1, 0, 0, 0 ,12, 14, 0, 2, 2, 0, 0, 0 ,12, 14, 0, 3, 3, 0, 0, 0 ,12, 14, 0, 4, 4, 0, 0, 0 ,12, 14, 0, 5, 5, 0, 0, 0 ,12, 14, 0, 6, 6, 0, 0, 0 ,12, 14, 0, 7, 7, 0, 0, 0 ,12, 14, 0, 8, 8, 0, 0, 0 ,12, 14, 0, 9, 9, 0, 0, 0 ,13, 8, 0, 255, 255, 0, 0, 0 ,13, 12, 0, 255, 255, 0, 0, 0 ,14, 1, 0, 255, 255, 0, 0, 0 ,14, 1, 0, 255, 1, 0, 0, 0 ,14, 1, 0, 255, 2, 0, 0, 0 ,14, 1, 0, 255, 3, 0, 0, 0 ,14, 1, 0, 255, 4, 0, 0, 0 ,14, 1, 0, 255, 5, 0, 0, 0 ,14, 1, 0, 255, 6, 0, 0, 0 ,14, 1, 0, 255, 7, 0, 0, 0 ,14, 1, 0, 255, 8, 0, 0, 0 ,14, 1, 0, 255, 9, 0, 0, 0 ,14, 5, 0, 255, 255, 0, 0, 0 ,14, 5, 0, 255, 0, 0, 0, 0 ,14, 5, 0, 255, 1, 0, 0, 0 ,14, 5, 0, 255, 2, 0, 0, 0 ,14, 5, 0, 255, 3, 0, 0, 0 ,14, 5, 0, 255, 4, 0, 0, 0 ,14, 5, 0, 255, 5, 0, 0, 0 ,14, 5, 0, 255, 6, 0, 0, 0 ,14, 5, 0, 255, 7, 0, 0, 0 ,14, 5, 0, 255, 8, 0, 0, 0 ,14, 5, 0, 255, 9, 0, 0, 0 ,14, 8, 0, 255, 255, 0, 0, 0 ,14, 8, 0, 255, 1, 0, 0, 0 ,14, 8, 0, 255, 2, 0, 0, 0 ,14, 8, 0, 255, 3, 0, 0, 0 ,14, 8, 0, 255, 4, 0, 0, 0 ,14, 8, 0, 255, 5, 0, 0, 0 ,14, 8, 0, 255, 6, 0, 0, 0 ,14, 8, 0, 255, 7, 0, 0, 0 ,14, 8, 0, 255, 8, 0, 0, 0 ,14, 8, 0, 255, 9, 0, 0, 0 ,14, 12, 0, 255, 255, 0, 0, 0 ,14, 12, 0, 255, 0, 0, 0, 0 ,14, 12, 0, 255, 1, 0, 0, 0 ,14, 12, 0, 255, 2, 0, 0, 0 ,14, 12, 0, 255, 3, 0, 0, 0 ,14, 12, 0, 255, 4, 0, 0, 0 ,14, 12, 0, 255, 5, 0, 0, 0 ,14, 12, 0, 255, 6, 0, 0, 0 ,14, 12, 0, 255, 7, 0, 0, 0 ,14, 12, 0, 255, 8, 0, 0, 0 ,14, 12, 0, 255, 9, 0, 0, 0 ,14, 14, 0, 255, 255, 0, 0, 0 ,14, 14, 0, 255, 1, 0, 0, 0 ,14, 14, 0, 255, 2, 0, 0, 0 ,14, 14, 0, 255, 3, 0, 0, 0 ,14, 14, 0, 255, 4, 0, 0, 0 ,15, 12, 0, 255, 255, 0, 0, 0 ,16, 6, 0, 255, 255, 0, 0, 0 ,16, 12, 0, 255, 255, 0, 0, 0 ,16, 14, 0, 255, 255, 0, 0, 0 ,17, 12, 0, 255, 255, 0, 0, 0 ,17, 12, 0, 255, 255, 1, 0, 0 ,18, 12, 0, 255, 255, 0, 0, 0 ,18, 12, 0, 255, 255, 1, 0, 0 ,19, 12, 0, 255, 255, 0, 0, 0 ,19, 12, 0, 255, 255, 1, 0, 0 ,20, 0, 0, 255, 255, 0, 0, 0 ,20, 1, 0, 255, 255, 0, 0, 0 ,20, 4, 0, 255, 255, 0, 0, 0 ,20, 7, 0, 255, 255, 0, 0, 0 ,20, 8, 0, 255, 255, 0, 0, 0 ,20, 12, 0, 255, 255, 0, 0, 0 ,20, 14, 0, 255, 255, 0, 0, 0 ,21, 12, 0, 255, 255, 0, 0, 0 ,21, 12, 0, 255, 255, 1, 0, 0 ,22, 0, 0, 255, 255, 0, 0, 0 ,22, 7, 0, 255, 255, 0, 0, 0 ,23, 0, 0, 255, 255, 0, 0, 0 ,23, 8, 0, 255, 255, 0, 0, 0 ,23, 12, 0, 255, 255, 0, 0, 0 ,24, 0, 0, 255, 255, 0, 0, 0 ,24, 4, 0, 255, 255, 0, 0, 0 ,24, 6, 0, 255, 255, 0, 0, 0 ,24, 7, 0, 255, 255, 0, 0, 0 ,24, 8, 0, 255, 255, 0, 0, 0 ,24, 12, 0, 255, 255, 0, 0, 0 ,24, 12, 0, 255, 255, 1, 0, 0 ,25, 0, 0, 255, 255, 0, 0, 0 ,25, 7, 0, 255, 255, 0, 0, 0 ,25, 8, 0, 255, 255, 0, 0, 0 ,25, 12, 0, 255, 255, 0, 0, 0 ,26, 18, 0, 255, 255, 0, 0, 0 ,27, 2, 0, 255, 255, 0, 0, 0 ,28, 4, 0, 255, 255, 0, 0, 0 ,28, 18, 0, 255, 255, 0, 0, 0 }; const unsigned char *const ecl_ucd_page_table[256] = { ecl_ucd_page_table_1 ,ecl_ucd_page_table_2 ,ecl_ucd_page_table_3 ,ecl_ucd_page_table_4 ,ecl_ucd_page_table_5 ,ecl_ucd_page_table_6 ,ecl_ucd_page_table_7 ,ecl_ucd_page_table_8 ,ecl_ucd_page_table_9 ,ecl_ucd_page_table_10 ,ecl_ucd_page_table_11 ,ecl_ucd_page_table_12 ,ecl_ucd_page_table_13 ,ecl_ucd_page_table_14 ,ecl_ucd_page_table_15 ,ecl_ucd_page_table_16 ,ecl_ucd_page_table_17 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_19 ,ecl_ucd_page_table_20 ,ecl_ucd_page_table_21 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_22 ,ecl_ucd_page_table_23 ,ecl_ucd_page_table_24 ,ecl_ucd_page_table_25 ,ecl_ucd_page_table_26 ,ecl_ucd_page_table_27 ,ecl_ucd_page_table_28 ,ecl_ucd_page_table_29 ,ecl_ucd_page_table_30 ,ecl_ucd_page_table_31 ,ecl_ucd_page_table_32 ,ecl_ucd_page_table_33 ,ecl_ucd_page_table_34 ,ecl_ucd_page_table_35 ,ecl_ucd_page_table_36 ,ecl_ucd_page_table_37 ,ecl_ucd_page_table_38 ,ecl_ucd_page_table_39 ,ecl_ucd_page_table_40 ,ecl_ucd_page_table_41 ,ecl_ucd_page_table_42 ,ecl_ucd_page_table_43 ,ecl_ucd_page_table_44 ,ecl_ucd_page_table_45 ,ecl_ucd_page_table_46 ,ecl_ucd_page_table_47 ,ecl_ucd_page_table_48 ,ecl_ucd_page_table_49 ,ecl_ucd_page_table_50 ,ecl_ucd_page_table_51 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_52 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_53 ,ecl_ucd_page_table_54 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_55 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_56 ,ecl_ucd_page_table_57 ,ecl_ucd_page_table_58 ,ecl_ucd_page_table_59 ,ecl_ucd_page_table_60 ,ecl_ucd_page_table_61 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_62 ,ecl_ucd_page_table_63 ,ecl_ucd_page_table_63 ,ecl_ucd_page_table_63 ,ecl_ucd_page_table_63 ,ecl_ucd_page_table_63 ,ecl_ucd_page_table_63 ,ecl_ucd_page_table_63 ,ecl_ucd_page_table_63 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_64 ,ecl_ucd_page_table_18 ,ecl_ucd_page_table_65 ,ecl_ucd_page_table_66 ,ecl_ucd_page_table_67 ,ecl_ucd_page_table_68 ,ecl_ucd_page_table_69 ,ecl_ucd_page_table_70 }; ecl-16.1.2/src/c/unicode/ucd_names.h000066400000000000000000000016411266352375300171300ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* * UNICODE NAMES DATABASE */ #ifndef ECL_UCD_NAMES_H #define ECL_UCD_NAMES_H 1 #define ECL_UCD_FIRST_PAIR 9699 #define ECL_UCD_TOTAL_PAIRS 37993 #define ECL_UCD_TOTAL_GROUPS 481 #define ECL_UCD_LARGEST_CHAR_NAME 83 #define ECL_UCD_TOTAL_NAMES 32914 typedef struct { unsigned char codes[4]; } ecl_ucd_names_pair_type; typedef struct { int smallest, largest, pair_code; } ecl_ucd_names_char_group; typedef struct { unsigned char pair[2]; unsigned char code[3]; } ecl_ucd_code_and_pair; extern const ecl_ucd_names_pair_type ecl_ucd_names_pair[ECL_UCD_TOTAL_PAIRS]; extern const ecl_ucd_names_char_group ecl_ucd_names_char[ECL_UCD_TOTAL_GROUPS]; extern const char *ecl_ucd_names_word[ECL_UCD_FIRST_PAIR]; extern const ecl_ucd_code_and_pair ecl_ucd_sorted_pairs[ECL_UCD_TOTAL_NAMES]; #endif ecl-16.1.2/src/c/unicode/ucd_names_char.c000066400000000000000000000306561266352375300201300ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* * Dictionary words. */ #include #include #include "ucd_names.h" const ecl_ucd_names_char_group ecl_ucd_names_char[ECL_UCD_TOTAL_GROUPS] = { {32,126,9699} ,{160,887,9794} ,{890,894,10522} ,{900,906,10527} ,{908,908,10534} ,{910,929,10535} ,{931,1317,10555} ,{1329,1366,10942} ,{1369,1375,10980} ,{1377,1415,10987} ,{1417,1418,11026} ,{1425,1479,11028} ,{1488,1514,11083} ,{1520,1524,11110} ,{1536,1539,11115} ,{1542,1563,11119} ,{1566,1567,11141} ,{1569,1630,11143} ,{1632,1805,11205} ,{1807,1866,11379} ,{1869,1969,11439} ,{1984,2042,11540} ,{2048,2093,11599} ,{2096,2110,11645} ,{2304,2361,11660} ,{2364,2382,11718} ,{2384,2389,11737} ,{2392,2418,11743} ,{2425,2431,11770} ,{2433,2435,11777} ,{2437,2444,11780} ,{2447,2448,11788} ,{2451,2472,11790} ,{2474,2480,11812} ,{2482,2482,11819} ,{2486,2489,11820} ,{2492,2500,11824} ,{2503,2504,11833} ,{2507,2510,11835} ,{2519,2519,11839} ,{2524,2525,11840} ,{2527,2531,11842} ,{2534,2555,11847} ,{2561,2563,11869} ,{2565,2570,11872} ,{2575,2576,11878} ,{2579,2600,11880} ,{2602,2608,11902} ,{2610,2611,11909} ,{2613,2614,11911} ,{2616,2617,11913} ,{2620,2620,11915} ,{2622,2626,11916} ,{2631,2632,11921} ,{2635,2637,11923} ,{2641,2641,11926} ,{2649,2652,11927} ,{2654,2654,11931} ,{2662,2677,11932} ,{2689,2691,11948} ,{2693,2701,11951} ,{2703,2705,11960} ,{2707,2728,11963} ,{2730,2736,11985} ,{2738,2739,11992} ,{2741,2745,11994} ,{2748,2757,11999} ,{2759,2761,12009} ,{2763,2765,12012} ,{2768,2768,12015} ,{2784,2787,12016} ,{2790,2799,12020} ,{2801,2801,12030} ,{2817,2819,12031} ,{2821,2828,12034} ,{2831,2832,12042} ,{2835,2856,12044} ,{2858,2864,12066} ,{2866,2867,12073} ,{2869,2873,12075} ,{2876,2884,12080} ,{2887,2888,12089} ,{2891,2893,12091} ,{2902,2903,12094} ,{2908,2909,12096} ,{2911,2915,12098} ,{2918,2929,12103} ,{2946,2947,12115} ,{2949,2954,12117} ,{2958,2960,12123} ,{2962,2965,12126} ,{2969,2970,12130} ,{2972,2972,12132} ,{2974,2975,12133} ,{2979,2980,12135} ,{2984,2986,12137} ,{2990,3001,12140} ,{3006,3010,12152} ,{3014,3016,12157} ,{3018,3021,12160} ,{3024,3024,12164} ,{3031,3031,12165} ,{3046,3066,12166} ,{3073,3075,12187} ,{3077,3084,12190} ,{3086,3088,12198} ,{3090,3112,12201} ,{3114,3123,12224} ,{3125,3129,12234} ,{3133,3140,12239} ,{3142,3144,12247} ,{3146,3149,12250} ,{3157,3158,12254} ,{3160,3161,12256} ,{3168,3171,12258} ,{3174,3183,12262} ,{3192,3199,12272} ,{3202,3203,12280} ,{3205,3212,12282} ,{3214,3216,12290} ,{3218,3240,12293} ,{3242,3251,12316} ,{3253,3257,12326} ,{3260,3268,12331} ,{3270,3272,12340} ,{3274,3277,12343} ,{3285,3286,12347} ,{3294,3294,12349} ,{3296,3299,12350} ,{3302,3311,12354} ,{3313,3314,12364} ,{3330,3331,12366} ,{3333,3340,12368} ,{3342,3344,12376} ,{3346,3368,12379} ,{3370,3385,12402} ,{3389,3396,12418} ,{3398,3400,12426} ,{3402,3405,12429} ,{3415,3415,12433} ,{3424,3427,12434} ,{3430,3445,12438} ,{3449,3455,12454} ,{3458,3459,12461} ,{3461,3478,12463} ,{3482,3505,12481} ,{3507,3515,12505} ,{3517,3517,12514} ,{3520,3526,12515} ,{3530,3530,12522} ,{3535,3540,12523} ,{3542,3542,12529} ,{3544,3551,12530} ,{3570,3572,12538} ,{3585,3642,12541} ,{3647,3675,12599} ,{3713,3714,12628} ,{3716,3716,12630} ,{3719,3720,12631} ,{3722,3722,12633} ,{3725,3725,12634} ,{3732,3735,12635} ,{3737,3743,12639} ,{3745,3747,12646} ,{3749,3749,12649} ,{3751,3751,12650} ,{3754,3755,12651} ,{3757,3769,12653} ,{3771,3773,12666} ,{3776,3780,12669} ,{3782,3782,12674} ,{3784,3789,12675} ,{3792,3801,12681} ,{3804,3805,12691} ,{3840,3911,12693} ,{3913,3948,12765} ,{3953,3979,12801} ,{3984,3991,12828} ,{3993,4028,12836} ,{4030,4044,12872} ,{4046,4056,12887} ,{4096,4293,12898} ,{4304,4348,13096} ,{4352,4680,13141} ,{4682,4685,13470} ,{4688,4694,13474} ,{4696,4696,13481} ,{4698,4701,13482} ,{4704,4744,13486} ,{4746,4749,13527} ,{4752,4784,13531} ,{4786,4789,13564} ,{4792,4798,13568} ,{4800,4800,13575} ,{4802,4805,13576} ,{4808,4822,13580} ,{4824,4880,13595} ,{4882,4885,13652} ,{4888,4954,13656} ,{4959,4988,13723} ,{4992,5017,13753} ,{5024,5108,13779} ,{5120,5788,13864} ,{5792,5872,14533} ,{5888,5900,14614} ,{5902,5908,14627} ,{5920,5942,14634} ,{5952,5971,14657} ,{5984,5996,14677} ,{5998,6000,14690} ,{6002,6003,14693} ,{6016,6109,14695} ,{6112,6121,14789} ,{6128,6137,14799} ,{6144,6158,14809} ,{6160,6169,14824} ,{6176,6263,14834} ,{6272,6314,14922} ,{6320,6389,14965} ,{6400,6428,15035} ,{6432,6443,15064} ,{6448,6459,15076} ,{6464,6464,15088} ,{6468,6509,15089} ,{6512,6516,15131} ,{6528,6571,15136} ,{6576,6601,15180} ,{6608,6618,15206} ,{6622,6683,15217} ,{6686,6750,15279} ,{6752,6780,15344} ,{6783,6793,15373} ,{6800,6809,15384} ,{6816,6829,15394} ,{6912,6987,15408} ,{6992,7036,15484} ,{7040,7082,15529} ,{7086,7097,15572} ,{7168,7223,15584} ,{7227,7241,15640} ,{7245,7295,15655} ,{7376,7410,15706} ,{7424,7654,15741} ,{7677,7957,15972} ,{7960,7965,16253} ,{7968,8005,16259} ,{8008,8013,16297} ,{8016,8023,16303} ,{8025,8025,16311} ,{8027,8027,16312} ,{8029,8029,16313} ,{8031,8061,16314} ,{8064,8116,16345} ,{8118,8132,16398} ,{8134,8147,16413} ,{8150,8155,16427} ,{8157,8175,16433} ,{8178,8180,16452} ,{8182,8190,16455} ,{8192,8292,16464} ,{8298,8305,16565} ,{8308,8334,16573} ,{8336,8340,16600} ,{8352,8376,16605} ,{8400,8432,16630} ,{8448,8585,16663} ,{8592,9192,16801} ,{9216,9254,17402} ,{9280,9290,17441} ,{9312,9933,17452} ,{9935,9953,18074} ,{9955,9955,18093} ,{9960,9983,18094} ,{9985,9988,18118} ,{9990,9993,18122} ,{9996,10023,18126} ,{10025,10059,18154} ,{10061,10061,18189} ,{10063,10066,18190} ,{10070,10078,18194} ,{10081,10132,18203} ,{10136,10159,18255} ,{10161,10174,18279} ,{10176,10186,18293} ,{10188,10188,18304} ,{10192,11084,18305} ,{11088,11097,19198} ,{11264,11310,19208} ,{11312,11358,19255} ,{11360,11505,19302} ,{11513,11557,19448} ,{11568,11621,19493} ,{11631,11631,19547} ,{11648,11670,19548} ,{11680,11686,19571} ,{11688,11694,19578} ,{11696,11702,19585} ,{11704,11710,19592} ,{11712,11718,19599} ,{11720,11726,19606} ,{11728,11734,19613} ,{11736,11742,19620} ,{11744,11825,19627} ,{11904,11929,19709} ,{11931,12019,19735} ,{12032,12245,19824} ,{12272,12283,20038} ,{12288,12351,20050} ,{12353,12438,20114} ,{12441,12543,20200} ,{12549,12589,20303} ,{12593,12686,20344} ,{12688,12727,20438} ,{12736,12771,20478} ,{12784,12830,20514} ,{12832,13054,20561} ,{13056,13311,20784} ,{19904,19967,21040} ,{40960,42124,21104} ,{42128,42182,22269} ,{42192,42539,22324} ,{42560,42591,22672} ,{42594,42611,22704} ,{42620,42647,22722} ,{42656,42743,22750} ,{42752,42892,22838} ,{43003,43051,22979} ,{43056,43065,23028} ,{43072,43127,23038} ,{43136,43204,23094} ,{43214,43225,23163} ,{43232,43259,23175} ,{43264,43347,23203} ,{43359,43388,23287} ,{43392,43469,23317} ,{43471,43481,23395} ,{43486,43487,23406} ,{43520,43574,23408} ,{43584,43597,23463} ,{43600,43609,23477} ,{43612,43643,23487} ,{43648,43714,23519} ,{43739,43743,23586} ,{43968,44013,23591} ,{44016,44025,23637} ,{44032,55203,23647} ,{55216,55238,34819} ,{55243,55291,34842} ,{63744,64045,34891} ,{64048,64109,35193} ,{64112,64217,35255} ,{64256,64262,35361} ,{64275,64279,35368} ,{64285,64310,35373} ,{64312,64316,35399} ,{64318,64318,35404} ,{64320,64321,35405} ,{64323,64324,35407} ,{64326,64433,35409} ,{64467,64831,35517} ,{64848,64911,35882} ,{64914,64967,35946} ,{65008,65021,36000} ,{65024,65049,36014} ,{65056,65062,36040} ,{65072,65106,36047} ,{65108,65126,36082} ,{65128,65131,36101} ,{65136,65140,36105} ,{65142,65276,36110} ,{65279,65279,36245} ,{65281,65470,36246} ,{65474,65479,36436} ,{65482,65487,36442} ,{65490,65495,36448} ,{65498,65500,36454} ,{65504,65510,36457} ,{65512,65518,36464} ,{65529,65533,36471} ,{65536,65547,36476} ,{65549,65574,36488} ,{65576,65594,36514} ,{65596,65597,36533} ,{65599,65613,36535} ,{65616,65629,36550} ,{65664,65786,36564} ,{65792,65794,36687} ,{65799,65843,36690} ,{65847,65930,36735} ,{65936,65947,36819} ,{66000,66045,36831} ,{66176,66204,36877} ,{66208,66256,36906} ,{66304,66334,36955} ,{66336,66339,36986} ,{66352,66378,36990} ,{66432,66461,37017} ,{66463,66499,37047} ,{66504,66517,37084} ,{66560,66717,37098} ,{66720,66729,37256} ,{67584,67589,37266} ,{67592,67592,37272} ,{67594,67637,37273} ,{67639,67640,37317} ,{67644,67644,37319} ,{67647,67669,37320} ,{67671,67679,37343} ,{67840,67867,37352} ,{67871,67897,37380} ,{67903,67903,37407} ,{68096,68099,37408} ,{68101,68102,37412} ,{68108,68115,37414} ,{68117,68119,37422} ,{68121,68147,37425} ,{68152,68154,37452} ,{68159,68167,37455} ,{68176,68184,37464} ,{68192,68223,37473} ,{68352,68405,37505} ,{68409,68437,37559} ,{68440,68466,37588} ,{68472,68479,37615} ,{68608,68680,37623} ,{69216,69246,37696} ,{69760,69825,37727} ,{73728,74606,37793} ,{74752,74850,38672} ,{74864,74867,38771} ,{77824,78894,38775} ,{118784,119029,39846} ,{119040,119078,40092} ,{119081,119261,40131} ,{119296,119365,40312} ,{119552,119638,40382} ,{119648,119665,40469} ,{119808,119892,40487} ,{119894,119964,40572} ,{119966,119967,40643} ,{119970,119970,40645} ,{119973,119974,40646} ,{119977,119980,40648} ,{119982,119993,40652} ,{119995,119995,40664} ,{119997,120003,40665} ,{120005,120069,40672} ,{120071,120074,40737} ,{120077,120084,40741} ,{120086,120092,40749} ,{120094,120121,40756} ,{120123,120126,40784} ,{120128,120132,40788} ,{120134,120134,40793} ,{120138,120144,40794} ,{120146,120485,40801} ,{120488,120779,41141} ,{120782,120831,41433} ,{126976,127019,41483} ,{127024,127123,41527} ,{127232,127242,41627} ,{127248,127278,41638} ,{127281,127281,41669} ,{127293,127293,41670} ,{127295,127295,41671} ,{127298,127298,41672} ,{127302,127302,41673} ,{127306,127310,41674} ,{127319,127319,41679} ,{127327,127327,41680} ,{127353,127353,41681} ,{127355,127356,41682} ,{127359,127359,41684} ,{127370,127373,41685} ,{127376,127376,41689} ,{127488,127488,41690} ,{127504,127537,41691} ,{127552,127560,41725} ,{194560,195101,41734} ,{917505,917505,42276} ,{917536,917631,42277} }; static int search_pair(ecl_character c) { int mid, low = 0, up = ECL_UCD_TOTAL_GROUPS-1; do { mid = (up + low) / 2; if (c < ecl_ucd_names_char[mid].smallest) up = mid-1; else if (c > ecl_ucd_names_char[mid].largest) low = mid+1; else return (c - ecl_ucd_names_char[mid].smallest) + ecl_ucd_names_char[mid].pair_code; } while (low <= up && (low >= 0) && (up < ECL_UCD_TOTAL_GROUPS)); return -1; } static void fill_pair_name(char *buffer, int pair) { if (pair < ECL_UCD_FIRST_PAIR) { strncat(buffer, ecl_ucd_names_word[pair], ECL_UCD_LARGEST_CHAR_NAME+1); /* printf("text=%s\n", ecl_ucd_names_word[pair]); */ } else { const ecl_ucd_names_pair_type p = ecl_ucd_names_pair[pair - ECL_UCD_FIRST_PAIR]; /* printf("ndx=%d\n", pair - ECL_UCD_FIRST_PAIR); printf("c0=%d\n", ecl_ucd_names_pair[pair - ECL_UCD_FIRST_PAIR].codes[0]); printf("c1=%d\n", ecl_ucd_names_pair[pair - ECL_UCD_FIRST_PAIR].codes[1]); printf("c2=%d\n", ecl_ucd_names_pair[pair - ECL_UCD_FIRST_PAIR].codes[2]); printf("c3=%d\n", ecl_ucd_names_pair[pair - ECL_UCD_FIRST_PAIR].codes[3]); */ fill_pair_name(buffer, (((unsigned int)p.codes[1]) << 8) | p.codes[0]); fill_pair_name(buffer, (((unsigned int)p.codes[3]) << 8) | p.codes[2]); } } cl_object _ecl_ucd_code_to_name(ecl_character c) { int pair = search_pair(c); if (pair < 0) return ECL_NIL; else { char buffer[ECL_UCD_LARGEST_CHAR_NAME+1]; buffer[0] = 0; fill_pair_name(buffer, pair); return make_base_string_copy(buffer); } } cl_object _ecl_ucd_name_to_code(cl_object name) { int mid, low = 0, up = ECL_UCD_TOTAL_NAMES-1; int l = ecl_length(name); if (l <= ECL_UCD_LARGEST_CHAR_NAME) { char buffer1[ECL_UCD_LARGEST_CHAR_NAME+1]; char buffer2[ECL_UCD_LARGEST_CHAR_NAME+1]; for (mid = 0; mid < l; mid++) { ecl_character c = ecl_char_upcase(ecl_char(name, mid)); buffer1[mid] = c; if (c < 32 || c > 127) /* All character names are [-A-Z_0-9]* */ return ECL_NIL; } buffer1[mid] = 0; do { ecl_ucd_code_and_pair p = ecl_ucd_sorted_pairs[mid = (low + up) / 2]; int flag, pair = ((unsigned int)p.pair[1] << 8) | p.pair[0]; buffer2[0] = 0; fill_pair_name(buffer2, pair); flag = strcmp(buffer1, buffer2); /* printf("[%d,%d,%d] %s <> (%d)%s -> %d\n", low, mid, up, buffer1, pair, buffer2, flag); */ if (flag == 0) { return ecl_make_fixnum(((unsigned int)p.code[2] << 16) | ((unsigned int)p.code[1] << 8) | p.code[0]); } else if (flag < 0) { up = mid - 1; } else { low = mid + 1; } } while (low <= up); } return ECL_NIL; } ecl-16.1.2/src/c/unicode/ucd_names_codes.c000066400000000000000000033145301266352375300203070ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* * Sorted character names. */ #include #include "ucd_names.h" const ecl_ucd_code_and_pair ecl_ucd_sorted_pairs[ECL_UCD_TOTAL_NAMES] = { {{23, 65}, {0, 33, 0}} ,{{184, 64}, {109, 32, 0}} ,{{182, 64}, {107, 32, 0}} ,{{86, 38}, {180, 0, 0}} ,{{80, 73}, {159, 41, 0}} ,{{247, 67}, {230, 35, 0}} ,{{24, 65}, {1, 33, 0}} ,{{248, 69}, {44, 38, 0}} ,{{81, 143}, {2, 1, 1}} ,{{132, 143}, {60, 1, 1}} ,{{133, 143}, {61, 1, 1}} ,{{134, 143}, {62, 1, 1}} ,{{135, 143}, {63, 1, 1}} ,{{89, 143}, {14, 1, 1}} ,{{98, 143}, {23, 1, 1}} ,{{125, 143}, {50, 1, 1}} ,{{107, 143}, {32, 1, 1}} ,{{116, 143}, {41, 1, 1}} ,{{95, 143}, {20, 1, 1}} ,{{122, 143}, {47, 1, 1}} ,{{86, 143}, {11, 1, 1}} ,{{104, 143}, {29, 1, 1}} ,{{113, 143}, {38, 1, 1}} ,{{94, 143}, {19, 1, 1}} ,{{121, 143}, {46, 1, 1}} ,{{85, 143}, {10, 1, 1}} ,{{103, 143}, {28, 1, 1}} ,{{112, 143}, {37, 1, 1}} ,{{90, 143}, {15, 1, 1}} ,{{99, 143}, {24, 1, 1}} ,{{126, 143}, {51, 1, 1}} ,{{108, 143}, {33, 1, 1}} ,{{117, 143}, {42, 1, 1}} ,{{82, 143}, {7, 1, 1}} ,{{100, 143}, {25, 1, 1}} ,{{109, 143}, {34, 1, 1}} ,{{88, 143}, {13, 1, 1}} ,{{97, 143}, {22, 1, 1}} ,{{124, 143}, {49, 1, 1}} ,{{106, 143}, {31, 1, 1}} ,{{115, 143}, {40, 1, 1}} ,{{87, 143}, {12, 1, 1}} ,{{96, 143}, {21, 1, 1}} ,{{123, 143}, {48, 1, 1}} ,{{105, 143}, {30, 1, 1}} ,{{114, 143}, {39, 1, 1}} ,{{91, 143}, {16, 1, 1}} ,{{118, 143}, {43, 1, 1}} ,{{93, 143}, {18, 1, 1}} ,{{120, 143}, {45, 1, 1}} ,{{84, 143}, {9, 1, 1}} ,{{102, 143}, {27, 1, 1}} ,{{111, 143}, {36, 1, 1}} ,{{92, 143}, {17, 1, 1}} ,{{119, 143}, {44, 1, 1}} ,{{83, 143}, {8, 1, 1}} ,{{101, 143}, {26, 1, 1}} ,{{110, 143}, {35, 1, 1}} ,{{127, 143}, {55, 1, 1}} ,{{128, 143}, {56, 1, 1}} ,{{131, 143}, {59, 1, 1}} ,{{129, 143}, {57, 1, 1}} ,{{130, 143}, {58, 1, 1}} ,{{80, 143}, {1, 1, 1}} ,{{79, 143}, {0, 1, 1}} ,{{116, 43}, {11, 6, 0}} ,{{204, 70}, {8, 39, 0}} ,{{100, 65}, {77, 33, 0}} ,{{76, 65}, {53, 33, 0}} ,{{99, 70}, {151, 38, 0}} ,{{63, 67}, {46, 35, 0}} ,{{93, 66}, {76, 34, 0}} ,{{91, 66}, {74, 34, 0}} ,{{89, 66}, {72, 34, 0}} ,{{32, 74}, {111, 42, 0}} ,{{160, 70}, {213, 38, 0}} ,{{152, 67}, {135, 35, 0}} ,{{240, 73}, {63, 42, 0}} ,{{233, 37}, {38, 0, 0}} ,{{95, 70}, {147, 38, 0}} ,{{130, 71}, {209, 39, 0}} ,{{49, 66}, {32, 34, 0}} ,{{79, 73}, {158, 41, 0}} ,{{85, 73}, {164, 41, 0}} ,{{66, 65}, {43, 33, 0}} ,{{241, 69}, {37, 38, 0}} ,{{241, 72}, {64, 41, 0}} ,{{68, 66}, {51, 34, 0}} ,{{163, 71}, {242, 39, 0}} ,{{194, 73}, {17, 42, 0}} ,{{203, 65}, {186, 33, 0}} ,{{199, 65}, {182, 33, 0}} ,{{139, 67}, {122, 35, 0}} ,{{135, 67}, {118, 35, 0}} ,{{81, 67}, {64, 35, 0}} ,{{90, 67}, {73, 35, 0}} ,{{118, 67}, {101, 35, 0}} ,{{79, 67}, {62, 35, 0}} ,{{112, 67}, {95, 35, 0}} ,{{78, 67}, {61, 35, 0}} ,{{109, 67}, {92, 35, 0}} ,{{123, 67}, {106, 35, 0}} ,{{92, 67}, {75, 35, 0}} ,{{106, 67}, {89, 35, 0}} ,{{115, 67}, {98, 35, 0}} ,{{99, 67}, {82, 35, 0}} ,{{124, 67}, {107, 35, 0}} ,{{107, 67}, {90, 35, 0}} ,{{103, 67}, {86, 35, 0}} ,{{130, 67}, {113, 35, 0}} ,{{119, 67}, {102, 35, 0}} ,{{95, 67}, {78, 35, 0}} ,{{91, 67}, {74, 35, 0}} ,{{136, 67}, {119, 35, 0}} ,{{122, 67}, {105, 35, 0}} ,{{71, 67}, {54, 35, 0}} ,{{132, 67}, {115, 35, 0}} ,{{137, 67}, {120, 35, 0}} ,{{117, 67}, {100, 35, 0}} ,{{108, 67}, {91, 35, 0}} ,{{86, 67}, {69, 35, 0}} ,{{120, 67}, {103, 35, 0}} ,{{134, 67}, {117, 35, 0}} ,{{138, 67}, {121, 35, 0}} ,{{166, 67}, {149, 35, 0}} ,{{83, 67}, {66, 35, 0}} ,{{77, 67}, {60, 35, 0}} ,{{113, 67}, {96, 35, 0}} ,{{101, 67}, {84, 35, 0}} ,{{94, 67}, {77, 35, 0}} ,{{75, 67}, {58, 35, 0}} ,{{74, 67}, {57, 35, 0}} ,{{104, 67}, {87, 35, 0}} ,{{93, 67}, {76, 35, 0}} ,{{73, 67}, {56, 35, 0}} ,{{85, 67}, {68, 35, 0}} ,{{76, 67}, {59, 35, 0}} ,{{88, 67}, {71, 35, 0}} ,{{84, 67}, {67, 35, 0}} ,{{128, 67}, {111, 35, 0}} ,{{129, 67}, {112, 35, 0}} ,{{89, 67}, {72, 35, 0}} ,{{82, 67}, {65, 35, 0}} ,{{97, 67}, {80, 35, 0}} ,{{100, 67}, {83, 35, 0}} ,{{111, 67}, {94, 35, 0}} ,{{105, 67}, {88, 35, 0}} ,{{133, 67}, {116, 35, 0}} ,{{87, 67}, {70, 35, 0}} ,{{127, 67}, {110, 35, 0}} ,{{80, 67}, {63, 35, 0}} ,{{72, 67}, {55, 35, 0}} ,{{116, 67}, {99, 35, 0}} ,{{126, 67}, {109, 35, 0}} ,{{121, 67}, {104, 35, 0}} ,{{96, 67}, {79, 35, 0}} ,{{131, 67}, {114, 35, 0}} ,{{110, 67}, {93, 35, 0}} ,{{114, 67}, {97, 35, 0}} ,{{102, 67}, {85, 35, 0}} ,{{98, 67}, {81, 35, 0}} ,{{125, 67}, {108, 35, 0}} ,{{234, 37}, {39, 0, 0}} ,{{97, 66}, {80, 34, 0}} ,{{87, 66}, {70, 34, 0}} ,{{33, 74}, {112, 42, 0}} ,{{86, 66}, {69, 34, 0}} ,{{99, 66}, {82, 34, 0}} ,{{30, 70}, {82, 38, 0}} ,{{111, 43}, {6, 6, 0}} ,{{205, 43}, {104, 6, 0}} ,{{202, 43}, {101, 6, 0}} ,{{201, 43}, {100, 6, 0}} ,{{206, 43}, {105, 6, 0}} ,{{198, 43}, {97, 6, 0}} ,{{204, 43}, {103, 6, 0}} ,{{203, 43}, {102, 6, 0}} ,{{200, 43}, {99, 6, 0}} ,{{199, 43}, {98, 6, 0}} ,{{197, 43}, {96, 6, 0}} ,{{112, 43}, {7, 6, 0}} ,{{114, 43}, {9, 6, 0}} ,{{115, 43}, {10, 6, 0}} ,{{117, 43}, {12, 6, 0}} ,{{181, 43}, {79, 6, 0}} ,{{178, 43}, {76, 6, 0}} ,{{11, 141}, {114, 254, 0}} ,{{16, 141}, {120, 254, 0}} ,{{17, 141}, {121, 254, 0}} ,{{118, 43}, {13, 6, 0}} ,{{208, 43}, {107, 6, 0}} ,{{80, 44}, {235, 6, 0}} ,{{79, 44}, {234, 6, 0}} ,{{66, 44}, {221, 6, 0}} ,{{180, 43}, {78, 6, 0}} ,{{177, 43}, {75, 6, 0}} ,{{9, 141}, {112, 254, 0}} ,{{14, 141}, {118, 254, 0}} ,{{15, 141}, {119, 254, 0}} ,{{196, 43}, {94, 6, 0}} ,{{210, 43}, {109, 6, 0}} ,{{109, 43}, {2, 6, 0}} ,{{57, 44}, {212, 6, 0}} ,{{186, 43}, {84, 6, 0}} ,{{187, 43}, {85, 6, 0}} ,{{189, 43}, {87, 6, 0}} ,{{182, 43}, {80, 6, 0}} ,{{179, 43}, {77, 6, 0}} ,{{13, 141}, {116, 254, 0}} ,{{18, 141}, {122, 254, 0}} ,{{19, 141}, {123, 254, 0}} ,{{58, 44}, {213, 6, 0}} ,{{159, 43}, {57, 6, 0}} ,{{98, 141}, {202, 254, 0}} ,{{99, 141}, {203, 254, 0}} ,{{97, 141}, {201, 254, 0}} ,{{100, 141}, {204, 254, 0}} ,{{5, 44}, {160, 6, 0}} ,{{192, 44}, {94, 7, 0}} ,{{191, 44}, {93, 7, 0}} ,{{193, 44}, {95, 7, 0}} ,{{141, 43}, {39, 6, 0}} ,{{38, 141}, {142, 254, 0}} ,{{37, 141}, {141, 254, 0}} ,{{175, 43}, {73, 6, 0}} ,{{136, 141}, {240, 254, 0}} ,{{135, 141}, {239, 254, 0}} ,{{214, 43}, {113, 6, 0}} ,{{92, 138}, {81, 251, 0}} ,{{91, 138}, {80, 251, 0}} ,{{214, 44}, {116, 7, 0}} ,{{213, 44}, {115, 7, 0}} ,{{137, 43}, {35, 6, 0}} ,{{28, 141}, {132, 254, 0}} ,{{27, 141}, {131, 254, 0}} ,{{139, 43}, {37, 6, 0}} ,{{32, 141}, {136, 254, 0}} ,{{31, 141}, {135, 254, 0}} ,{{136, 43}, {34, 6, 0}} ,{{26, 141}, {130, 254, 0}} ,{{25, 141}, {129, 254, 0}} ,{{215, 43}, {114, 6, 0}} ,{{216, 43}, {115, 6, 0}} ,{{224, 43}, {123, 6, 0}} ,{{94, 138}, {83, 251, 0}} ,{{95, 138}, {84, 251, 0}} ,{{93, 138}, {82, 251, 0}} ,{{96, 138}, {85, 251, 0}} ,{{142, 43}, {40, 6, 0}} ,{{229, 43}, {128, 6, 0}} ,{{102, 138}, {91, 251, 0}} ,{{103, 138}, {92, 251, 0}} ,{{101, 138}, {90, 251, 0}} ,{{104, 138}, {93, 251, 0}} ,{{40, 141}, {144, 254, 0}} ,{{41, 141}, {145, 254, 0}} ,{{39, 141}, {143, 254, 0}} ,{{42, 141}, {146, 254, 0}} ,{{179, 44}, {81, 7, 0}} ,{{183, 44}, {85, 7, 0}} ,{{184, 44}, {86, 7, 0}} ,{{178, 44}, {80, 7, 0}} ,{{180, 44}, {82, 7, 0}} ,{{181, 44}, {83, 7, 0}} ,{{182, 44}, {84, 7, 0}} ,{{156, 43}, {54, 6, 0}} ,{{86, 141}, {190, 254, 0}} ,{{87, 141}, {191, 254, 0}} ,{{85, 141}, {189, 254, 0}} ,{{88, 141}, {192, 254, 0}} ,{{96, 44}, {251, 6, 0}} ,{{241, 43}, {140, 6, 0}} ,{{144, 138}, {133, 251, 0}} ,{{143, 138}, {132, 251, 0}} ,{{149, 43}, {47, 6, 0}} ,{{66, 141}, {170, 254, 0}} ,{{65, 141}, {169, 254, 0}} ,{{239, 43}, {138, 6, 0}} ,{{240, 43}, {139, 6, 0}} ,{{245, 43}, {144, 6, 0}} ,{{188, 44}, {90, 7, 0}} ,{{83, 44}, {238, 6, 0}} ,{{238, 43}, {137, 6, 0}} ,{{244, 43}, {143, 6, 0}} ,{{187, 44}, {89, 7, 0}} ,{{242, 43}, {141, 6, 0}} ,{{142, 138}, {131, 251, 0}} ,{{141, 138}, {130, 251, 0}} ,{{237, 43}, {136, 6, 0}} ,{{148, 138}, {137, 251, 0}} ,{{147, 138}, {136, 251, 0}} ,{{211, 43}, {110, 6, 0}} ,{{6, 44}, {161, 6, 0}} ,{{212, 43}, {111, 6, 0}} ,{{243, 43}, {142, 6, 0}} ,{{146, 138}, {135, 251, 0}} ,{{145, 138}, {134, 251, 0}} ,{{233, 43}, {132, 6, 0}} ,{{126, 138}, {115, 251, 0}} ,{{127, 138}, {116, 251, 0}} ,{{125, 138}, {114, 251, 0}} ,{{128, 138}, {117, 251, 0}} ,{{53, 44}, {208, 6, 0}} ,{{207, 138}, {229, 251, 0}} ,{{208, 138}, {230, 251, 0}} ,{{206, 138}, {228, 251, 0}} ,{{209, 138}, {231, 251, 0}} ,{{49, 44}, {204, 6, 0}} ,{{231, 138}, {253, 251, 0}} ,{{232, 138}, {254, 251, 0}} ,{{230, 138}, {252, 251, 0}} ,{{233, 138}, {255, 251, 0}} ,{{217, 44}, {119, 7, 0}} ,{{216, 44}, {118, 7, 0}} ,{{215, 44}, {117, 7, 0}} ,{{163, 43}, {61, 6, 0}} ,{{165, 43}, {63, 6, 0}} ,{{164, 43}, {62, 6, 0}} ,{{167, 43}, {65, 6, 0}} ,{{106, 141}, {210, 254, 0}} ,{{107, 141}, {211, 254, 0}} ,{{105, 141}, {209, 254, 0}} ,{{108, 141}, {212, 254, 0}} ,{{8, 44}, {163, 6, 0}} ,{{7, 44}, {162, 6, 0}} ,{{10, 44}, {165, 6, 0}} ,{{195, 44}, {97, 7, 0}} ,{{194, 44}, {96, 7, 0}} ,{{20, 44}, {175, 6, 0}} ,{{158, 138}, {147, 251, 0}} ,{{159, 138}, {148, 251, 0}} ,{{157, 138}, {146, 251, 0}} ,{{160, 138}, {149, 251, 0}} ,{{21, 44}, {176, 6, 0}} ,{{25, 44}, {180, 6, 0}} ,{{23, 44}, {178, 6, 0}} ,{{160, 43}, {58, 6, 0}} ,{{102, 141}, {206, 254, 0}} ,{{103, 141}, {207, 254, 0}} ,{{101, 141}, {205, 254, 0}} ,{{104, 141}, {208, 254, 0}} ,{{97, 44}, {252, 6, 0}} ,{{24, 44}, {179, 6, 0}} ,{{162, 138}, {151, 251, 0}} ,{{163, 138}, {152, 251, 0}} ,{{161, 138}, {150, 251, 0}} ,{{164, 138}, {153, 251, 0}} ,{{147, 43}, {45, 6, 0}} ,{{58, 141}, {162, 254, 0}} ,{{59, 141}, {163, 254, 0}} ,{{57, 141}, {161, 254, 0}} ,{{60, 141}, {164, 254, 0}} ,{{222, 44}, {124, 7, 0}} ,{{230, 43}, {129, 6, 0}} ,{{212, 44}, {114, 7, 0}} ,{{209, 44}, {111, 7, 0}} ,{{208, 44}, {110, 7, 0}} ,{{234, 43}, {133, 6, 0}} ,{{186, 44}, {88, 7, 0}} ,{{185, 44}, {87, 7, 0}} ,{{231, 43}, {130, 6, 0}} ,{{135, 43}, {33, 6, 0}} ,{{24, 141}, {128, 254, 0}} ,{{173, 43}, {71, 6, 0}} ,{{35, 44}, {190, 6, 0}} ,{{182, 138}, {171, 251, 0}} ,{{183, 138}, {172, 251, 0}} ,{{181, 138}, {170, 251, 0}} ,{{184, 138}, {173, 251, 0}} ,{{130, 141}, {234, 254, 0}} ,{{38, 44}, {193, 6, 0}} ,{{178, 138}, {167, 251, 0}} ,{{179, 138}, {168, 251, 0}} ,{{177, 138}, {166, 251, 0}} ,{{180, 138}, {169, 251, 0}} ,{{39, 44}, {194, 6, 0}} ,{{131, 141}, {235, 254, 0}} ,{{129, 141}, {233, 254, 0}} ,{{132, 141}, {236, 254, 0}} ,{{100, 44}, {255, 6, 0}} ,{{37, 44}, {192, 6, 0}} ,{{176, 138}, {165, 251, 0}} ,{{175, 138}, {164, 251, 0}} ,{{217, 43}, {116, 6, 0}} ,{{218, 43}, {117, 6, 0}} ,{{219, 43}, {118, 6, 0}} ,{{221, 43}, {120, 6, 0}} ,{{146, 43}, {44, 6, 0}} ,{{54, 141}, {158, 254, 0}} ,{{55, 141}, {159, 254, 0}} ,{{53, 141}, {157, 254, 0}} ,{{56, 141}, {160, 254, 0}} ,{{253, 43}, {152, 6, 0}} ,{{150, 138}, {139, 251, 0}} ,{{149, 138}, {138, 251, 0}} ,{{169, 43}, {67, 6, 0}} ,{{114, 141}, {218, 254, 0}} ,{{115, 141}, {219, 254, 0}} ,{{113, 141}, {217, 254, 0}} ,{{116, 141}, {220, 254, 0}} ,{{17, 44}, {172, 6, 0}} ,{{16, 44}, {171, 6, 0}} ,{{19, 44}, {174, 6, 0}} ,{{225, 44}, {127, 7, 0}} ,{{14, 44}, {169, 6, 0}} ,{{154, 138}, {143, 251, 0}} ,{{155, 138}, {144, 251, 0}} ,{{153, 138}, {142, 251, 0}} ,{{156, 138}, {145, 251, 0}} ,{{196, 44}, {98, 7, 0}} ,{{197, 44}, {99, 7, 0}} ,{{162, 43}, {60, 6, 0}} ,{{198, 44}, {100, 7, 0}} ,{{161, 43}, {59, 6, 0}} ,{{148, 43}, {46, 6, 0}} ,{{62, 141}, {166, 254, 0}} ,{{63, 141}, {167, 254, 0}} ,{{61, 141}, {165, 254, 0}} ,{{64, 141}, {168, 254, 0}} ,{{42, 44}, {197, 6, 0}} ,{{203, 138}, {225, 251, 0}} ,{{202, 138}, {224, 251, 0}} ,{{46, 44}, {201, 6, 0}} ,{{205, 138}, {227, 251, 0}} ,{{204, 138}, {226, 251, 0}} ,{{170, 43}, {68, 6, 0}} ,{{118, 141}, {222, 254, 0}} ,{{119, 141}, {223, 254, 0}} ,{{117, 141}, {221, 254, 0}} ,{{120, 141}, {224, 254, 0}} ,{{204, 44}, {106, 7, 0}} ,{{27, 44}, {182, 6, 0}} ,{{26, 44}, {181, 6, 0}} ,{{28, 44}, {183, 6, 0}} ,{{29, 44}, {184, 6, 0}} ,{{171, 43}, {69, 6, 0}} ,{{122, 141}, {226, 254, 0}} ,{{123, 141}, {227, 254, 0}} ,{{121, 141}, {225, 254, 0}} ,{{124, 141}, {228, 254, 0}} ,{{199, 44}, {101, 7, 0}} ,{{200, 44}, {102, 7, 0}} ,{{18, 44}, {173, 6, 0}} ,{{22, 44}, {177, 6, 0}} ,{{166, 138}, {155, 251, 0}} ,{{167, 138}, {156, 251, 0}} ,{{165, 138}, {154, 251, 0}} ,{{168, 138}, {157, 251, 0}} ,{{190, 138}, {212, 251, 0}} ,{{191, 138}, {213, 251, 0}} ,{{189, 138}, {211, 251, 0}} ,{{192, 138}, {214, 251, 0}} ,{{172, 43}, {70, 6, 0}} ,{{126, 141}, {230, 254, 0}} ,{{31, 44}, {186, 6, 0}} ,{{170, 138}, {159, 251, 0}} ,{{169, 138}, {158, 251, 0}} ,{{127, 141}, {231, 254, 0}} ,{{125, 141}, {229, 254, 0}} ,{{128, 141}, {232, 254, 0}} ,{{30, 44}, {185, 6, 0}} ,{{33, 44}, {188, 6, 0}} ,{{202, 44}, {104, 7, 0}} ,{{203, 44}, {105, 7, 0}} ,{{34, 44}, {189, 6, 0}} ,{{201, 44}, {103, 7, 0}} ,{{232, 43}, {131, 6, 0}} ,{{130, 138}, {119, 251, 0}} ,{{131, 138}, {120, 251, 0}} ,{{129, 138}, {118, 251, 0}} ,{{132, 138}, {121, 251, 0}} ,{{43, 44}, {198, 6, 0}} ,{{196, 138}, {218, 251, 0}} ,{{195, 138}, {217, 251, 0}} ,{{227, 43}, {126, 6, 0}} ,{{11, 44}, {166, 6, 0}} ,{{122, 138}, {111, 251, 0}} ,{{123, 138}, {112, 251, 0}} ,{{121, 138}, {110, 251, 0}} ,{{124, 138}, {113, 251, 0}} ,{{98, 138}, {87, 251, 0}} ,{{99, 138}, {88, 251, 0}} ,{{97, 138}, {86, 251, 0}} ,{{100, 138}, {89, 251, 0}} ,{{168, 43}, {66, 6, 0}} ,{{110, 141}, {214, 254, 0}} ,{{111, 141}, {215, 254, 0}} ,{{109, 141}, {213, 254, 0}} ,{{112, 141}, {216, 254, 0}} ,{{12, 44}, {167, 6, 0}} ,{{13, 44}, {168, 6, 0}} ,{{151, 43}, {49, 6, 0}} ,{{70, 141}, {174, 254, 0}} ,{{69, 141}, {173, 254, 0}} ,{{249, 43}, {148, 6, 0}} ,{{251, 43}, {150, 6, 0}} ,{{254, 43}, {153, 6, 0}} ,{{206, 44}, {108, 7, 0}} ,{{84, 44}, {239, 6, 0}} ,{{248, 43}, {147, 6, 0}} ,{{211, 44}, {113, 7, 0}} ,{{247, 43}, {146, 6, 0}} ,{{250, 43}, {149, 6, 0}} ,{{189, 44}, {91, 7, 0}} ,{{252, 43}, {151, 6, 0}} ,{{205, 44}, {107, 7, 0}} ,{{32, 44}, {187, 6, 0}} ,{{172, 138}, {161, 251, 0}} ,{{173, 138}, {162, 251, 0}} ,{{171, 138}, {160, 251, 0}} ,{{174, 138}, {163, 251, 0}} ,{{246, 43}, {145, 6, 0}} ,{{152, 138}, {141, 251, 0}} ,{{151, 138}, {140, 251, 0}} ,{{155, 43}, {53, 6, 0}} ,{{82, 141}, {186, 254, 0}} ,{{83, 141}, {187, 254, 0}} ,{{81, 141}, {185, 254, 0}} ,{{84, 141}, {188, 254, 0}} ,{{3, 44}, {158, 6, 0}} ,{{2, 44}, {157, 6, 0}} ,{{153, 43}, {51, 6, 0}} ,{{74, 141}, {178, 254, 0}} ,{{75, 141}, {179, 254, 0}} ,{{73, 141}, {177, 254, 0}} ,{{76, 141}, {180, 254, 0}} ,{{255, 43}, {154, 6, 0}} ,{{223, 44}, {125, 7, 0}} ,{{190, 44}, {92, 7, 0}} ,{{224, 44}, {126, 7, 0}} ,{{210, 44}, {112, 7, 0}} ,{{0, 44}, {155, 6, 0}} ,{{1, 44}, {156, 6, 0}} ,{{207, 44}, {109, 7, 0}} ,{{154, 43}, {52, 6, 0}} ,{{78, 141}, {182, 254, 0}} ,{{79, 141}, {183, 254, 0}} ,{{77, 141}, {181, 254, 0}} ,{{80, 141}, {184, 254, 0}} ,{{95, 44}, {250, 6, 0}} ,{{213, 43}, {112, 6, 0}} ,{{15, 44}, {170, 6, 0}} ,{{157, 43}, {55, 6, 0}} ,{{90, 141}, {194, 254, 0}} ,{{91, 141}, {195, 254, 0}} ,{{89, 141}, {193, 254, 0}} ,{{92, 141}, {196, 254, 0}} ,{{4, 44}, {159, 6, 0}} ,{{235, 43}, {134, 6, 0}} ,{{236, 43}, {135, 6, 0}} ,{{138, 138}, {127, 251, 0}} ,{{139, 138}, {128, 251, 0}} ,{{137, 138}, {126, 251, 0}} ,{{140, 138}, {129, 251, 0}} ,{{134, 138}, {123, 251, 0}} ,{{135, 138}, {124, 251, 0}} ,{{133, 138}, {122, 251, 0}} ,{{136, 138}, {125, 251, 0}} ,{{36, 44}, {191, 6, 0}} ,{{144, 43}, {42, 6, 0}} ,{{228, 43}, {127, 6, 0}} ,{{110, 138}, {99, 251, 0}} ,{{111, 138}, {100, 251, 0}} ,{{109, 138}, {98, 251, 0}} ,{{112, 138}, {101, 251, 0}} ,{{46, 141}, {150, 254, 0}} ,{{47, 141}, {151, 254, 0}} ,{{45, 141}, {149, 254, 0}} ,{{143, 43}, {41, 6, 0}} ,{{44, 141}, {148, 254, 0}} ,{{40, 44}, {195, 6, 0}} ,{{43, 141}, {147, 254, 0}} ,{{48, 141}, {152, 254, 0}} ,{{225, 43}, {124, 6, 0}} ,{{226, 43}, {125, 6, 0}} ,{{150, 43}, {48, 6, 0}} ,{{68, 141}, {172, 254, 0}} ,{{67, 141}, {171, 254, 0}} ,{{145, 43}, {43, 6, 0}} ,{{50, 141}, {154, 254, 0}} ,{{51, 141}, {155, 254, 0}} ,{{49, 141}, {153, 254, 0}} ,{{52, 141}, {156, 254, 0}} ,{{222, 43}, {121, 6, 0}} ,{{223, 43}, {122, 6, 0}} ,{{106, 138}, {95, 251, 0}} ,{{107, 138}, {96, 251, 0}} ,{{105, 138}, {94, 251, 0}} ,{{108, 138}, {97, 251, 0}} ,{{114, 138}, {103, 251, 0}} ,{{115, 138}, {104, 251, 0}} ,{{113, 138}, {102, 251, 0}} ,{{116, 138}, {105, 251, 0}} ,{{44, 44}, {199, 6, 0}} ,{{210, 138}, {232, 251, 0}} ,{{211, 138}, {233, 251, 0}} ,{{194, 138}, {216, 251, 0}} ,{{193, 138}, {215, 251, 0}} ,{{220, 43}, {119, 6, 0}} ,{{199, 138}, {221, 251, 0}} ,{{48, 44}, {203, 6, 0}} ,{{9, 44}, {164, 6, 0}} ,{{118, 138}, {107, 251, 0}} ,{{119, 138}, {108, 251, 0}} ,{{117, 138}, {106, 251, 0}} ,{{120, 138}, {109, 251, 0}} ,{{201, 138}, {223, 251, 0}} ,{{200, 138}, {222, 251, 0}} ,{{174, 43}, {72, 6, 0}} ,{{134, 141}, {238, 254, 0}} ,{{133, 141}, {237, 254, 0}} ,{{52, 44}, {207, 6, 0}} ,{{219, 44}, {121, 7, 0}} ,{{218, 44}, {120, 7, 0}} ,{{138, 43}, {36, 6, 0}} ,{{30, 141}, {134, 254, 0}} ,{{29, 141}, {133, 254, 0}} ,{{41, 44}, {196, 6, 0}} ,{{47, 44}, {202, 6, 0}} ,{{176, 43}, {74, 6, 0}} ,{{55, 44}, {210, 6, 0}} ,{{186, 138}, {175, 251, 0}} ,{{185, 138}, {174, 251, 0}} ,{{221, 44}, {123, 7, 0}} ,{{220, 44}, {122, 7, 0}} ,{{56, 44}, {211, 6, 0}} ,{{188, 138}, {177, 251, 0}} ,{{187, 138}, {176, 251, 0}} ,{{138, 141}, {242, 254, 0}} ,{{139, 141}, {243, 254, 0}} ,{{137, 141}, {241, 254, 0}} ,{{140, 141}, {244, 254, 0}} ,{{140, 43}, {38, 6, 0}} ,{{34, 141}, {138, 254, 0}} ,{{35, 141}, {139, 254, 0}} ,{{33, 141}, {137, 254, 0}} ,{{36, 141}, {140, 254, 0}} ,{{51, 44}, {206, 6, 0}} ,{{50, 44}, {205, 6, 0}} ,{{54, 44}, {209, 6, 0}} ,{{45, 44}, {200, 6, 0}} ,{{198, 138}, {220, 251, 0}} ,{{197, 138}, {219, 251, 0}} ,{{158, 43}, {56, 6, 0}} ,{{94, 141}, {198, 254, 0}} ,{{95, 141}, {199, 254, 0}} ,{{93, 141}, {197, 254, 0}} ,{{96, 141}, {200, 254, 0}} ,{{152, 43}, {50, 6, 0}} ,{{72, 141}, {176, 254, 0}} ,{{71, 141}, {175, 254, 0}} ,{{253, 139}, {19, 253, 0}} ,{{225, 139}, {247, 252, 0}} ,{{164, 139}, {186, 252, 0}} ,{{19, 139}, {41, 252, 0}} ,{{79, 140}, {117, 253, 0}} ,{{156, 140}, {196, 253, 0}} ,{{165, 139}, {187, 252, 0}} ,{{20, 139}, {42, 252, 0}} ,{{82, 140}, {120, 253, 0}} ,{{80, 140}, {118, 253, 0}} ,{{81, 140}, {119, 253, 0}} ,{{142, 140}, {182, 253, 0}} ,{{254, 139}, {20, 253, 0}} ,{{226, 139}, {248, 252, 0}} ,{{163, 140}, {243, 253, 0}} ,{{167, 140}, {247, 253, 0}} ,{{122, 139}, {144, 252, 0}} ,{{71, 139}, {93, 252, 0}} ,{{38, 140}, {60, 253, 0}} ,{{39, 140}, {61, 253, 0}} ,{{162, 140}, {242, 253, 0}} ,{{88, 139}, {110, 252, 0}} ,{{243, 138}, {9, 252, 0}} ,{{135, 139}, {157, 252, 0}} ,{{240, 138}, {6, 252, 0}} ,{{154, 140}, {194, 253, 0}} ,{{138, 139}, {160, 252, 0}} ,{{204, 139}, {226, 252, 0}} ,{{134, 139}, {156, 252, 0}} ,{{239, 138}, {5, 252, 0}} ,{{136, 139}, {158, 252, 0}} ,{{241, 138}, {7, 252, 0}} ,{{118, 140}, {158, 253, 0}} ,{{86, 139}, {108, 252, 0}} ,{{137, 139}, {159, 252, 0}} ,{{242, 138}, {8, 252, 0}} ,{{203, 139}, {225, 252, 0}} ,{{87, 139}, {109, 252, 0}} ,{{84, 139}, {106, 252, 0}} ,{{89, 139}, {111, 252, 0}} ,{{244, 138}, {10, 252, 0}} ,{{85, 139}, {107, 252, 0}} ,{{173, 140}, {253, 253, 0}} ,{{13, 140}, {35, 253, 0}} ,{{241, 139}, {7, 253, 0}} ,{{159, 139}, {181, 252, 0}} ,{{13, 139}, {35, 252, 0}} ,{{72, 140}, {110, 253, 0}} ,{{131, 140}, {171, 253, 0}} ,{{158, 139}, {180, 252, 0}} ,{{12, 139}, {34, 252, 0}} ,{{160, 139}, {182, 252, 0}} ,{{14, 139}, {36, 252, 0}} ,{{73, 140}, {111, 253, 0}} ,{{74, 140}, {112, 253, 0}} ,{{161, 139}, {183, 252, 0}} ,{{15, 139}, {37, 252, 0}} ,{{22, 140}, {44, 253, 0}} ,{{250, 139}, {16, 253, 0}} ,{{14, 140}, {36, 253, 0}} ,{{242, 139}, {8, 253, 0}} ,{{102, 139}, {124, 252, 0}} ,{{27, 139}, {49, 252, 0}} ,{{169, 139}, {191, 252, 0}} ,{{24, 139}, {46, 252, 0}} ,{{168, 139}, {190, 252, 0}} ,{{23, 139}, {45, 252, 0}} ,{{170, 139}, {192, 252, 0}} ,{{25, 139}, {47, 252, 0}} ,{{86, 140}, {124, 253, 0}} ,{{87, 140}, {125, 253, 0}} ,{{171, 139}, {193, 252, 0}} ,{{26, 139}, {48, 252, 0}} ,{{153, 140}, {193, 253, 0}} ,{{103, 139}, {125, 252, 0}} ,{{28, 139}, {50, 252, 0}} ,{{255, 139}, {21, 253, 0}} ,{{227, 139}, {249, 252, 0}} ,{{166, 139}, {188, 252, 0}} ,{{21, 139}, {43, 252, 0}} ,{{167, 139}, {189, 252, 0}} ,{{22, 139}, {44, 252, 0}} ,{{85, 140}, {123, 253, 0}} ,{{83, 140}, {121, 253, 0}} ,{{84, 140}, {122, 253, 0}} ,{{0, 140}, {22, 253, 0}} ,{{228, 139}, {250, 252, 0}} ,{{5, 140}, {27, 253, 0}} ,{{233, 139}, {255, 252, 0}} ,{{147, 139}, {169, 252, 0}} ,{{1, 139}, {23, 252, 0}} ,{{151, 140}, {191, 253, 0}} ,{{148, 139}, {170, 252, 0}} ,{{2, 139}, {24, 252, 0}} ,{{53, 140}, {91, 253, 0}} ,{{52, 140}, {90, 253, 0}} ,{{6, 140}, {28, 253, 0}} ,{{234, 139}, {0, 253, 0}} ,{{61, 139}, {83, 252, 0}} ,{{193, 139}, {215, 252, 0}} ,{{59, 139}, {81, 252, 0}} ,{{194, 139}, {216, 252, 0}} ,{{60, 139}, {82, 252, 0}} ,{{107, 140}, {147, 253, 0}} ,{{108, 140}, {148, 253, 0}} ,{{195, 139}, {217, 252, 0}} ,{{62, 139}, {84, 252, 0}} ,{{171, 140}, {251, 253, 0}} ,{{7, 140}, {29, 253, 0}} ,{{235, 139}, {1, 253, 0}} ,{{145, 139}, {167, 252, 0}} ,{{255, 138}, {21, 252, 0}} ,{{126, 140}, {166, 253, 0}} ,{{150, 140}, {190, 253, 0}} ,{{146, 139}, {168, 252, 0}} ,{{0, 139}, {22, 252, 0}} ,{{127, 140}, {167, 253, 0}} ,{{50, 140}, {88, 253, 0}} ,{{51, 140}, {89, 253, 0}} ,{{125, 140}, {165, 253, 0}} ,{{8, 140}, {30, 253, 0}} ,{{236, 139}, {2, 253, 0}} ,{{106, 139}, {128, 252, 0}} ,{{33, 139}, {55, 252, 0}} ,{{109, 139}, {131, 252, 0}} ,{{39, 139}, {61, 252, 0}} ,{{175, 139}, {197, 252, 0}} ,{{35, 139}, {57, 252, 0}} ,{{174, 139}, {196, 252, 0}} ,{{34, 139}, {56, 252, 0}} ,{{176, 139}, {198, 252, 0}} ,{{36, 139}, {58, 252, 0}} ,{{107, 139}, {129, 252, 0}} ,{{177, 139}, {199, 252, 0}} ,{{37, 139}, {59, 252, 0}} ,{{213, 139}, {235, 252, 0}} ,{{108, 139}, {130, 252, 0}} ,{{178, 139}, {200, 252, 0}} ,{{38, 139}, {60, 252, 0}} ,{{214, 139}, {236, 252, 0}} ,{{147, 140}, {187, 253, 0}} ,{{155, 140}, {195, 253, 0}} ,{{143, 140}, {183, 253, 0}} ,{{110, 139}, {132, 252, 0}} ,{{40, 139}, {62, 252, 0}} ,{{9, 140}, {31, 253, 0}} ,{{237, 139}, {3, 253, 0}} ,{{4, 139}, {26, 252, 0}} ,{{149, 139}, {171, 252, 0}} ,{{3, 139}, {25, 252, 0}} ,{{150, 139}, {172, 252, 0}} ,{{5, 139}, {27, 252, 0}} ,{{10, 140}, {32, 253, 0}} ,{{238, 139}, {4, 253, 0}} ,{{148, 141}, {252, 254, 0}} ,{{147, 141}, {251, 254, 0}} ,{{112, 139}, {134, 252, 0}} ,{{45, 139}, {67, 252, 0}} ,{{144, 141}, {248, 254, 0}} ,{{143, 141}, {247, 254, 0}} ,{{146, 141}, {250, 254, 0}} ,{{145, 141}, {249, 254, 0}} ,{{142, 141}, {246, 254, 0}} ,{{141, 141}, {245, 254, 0}} ,{{180, 139}, {202, 252, 0}} ,{{42, 139}, {64, 252, 0}} ,{{92, 140}, {130, 253, 0}} ,{{90, 140}, {128, 253, 0}} ,{{141, 140}, {181, 253, 0}} ,{{91, 140}, {129, 253, 0}} ,{{183, 139}, {205, 252, 0}} ,{{179, 139}, {201, 252, 0}} ,{{41, 139}, {63, 252, 0}} ,{{94, 140}, {132, 253, 0}} ,{{93, 140}, {131, 253, 0}} ,{{148, 140}, {188, 253, 0}} ,{{146, 140}, {186, 253, 0}} ,{{132, 140}, {172, 253, 0}} ,{{181, 139}, {203, 252, 0}} ,{{43, 139}, {65, 252, 0}} ,{{95, 140}, {133, 253, 0}} ,{{96, 140}, {134, 253, 0}} ,{{111, 139}, {133, 252, 0}} ,{{182, 139}, {204, 252, 0}} ,{{44, 139}, {66, 252, 0}} ,{{215, 139}, {237, 252, 0}} ,{{97, 140}, {135, 253, 0}} ,{{98, 140}, {136, 253, 0}} ,{{133, 140}, {173, 253, 0}} ,{{113, 139}, {135, 252, 0}} ,{{46, 139}, {68, 252, 0}} ,{{114, 139}, {136, 252, 0}} ,{{51, 139}, {73, 252, 0}} ,{{185, 139}, {207, 252, 0}} ,{{48, 139}, {70, 252, 0}} ,{{99, 140}, {137, 253, 0}} ,{{100, 140}, {138, 253, 0}} ,{{101, 140}, {139, 253, 0}} ,{{184, 139}, {206, 252, 0}} ,{{47, 139}, {69, 252, 0}} ,{{102, 140}, {140, 253, 0}} ,{{106, 140}, {146, 253, 0}} ,{{103, 140}, {141, 253, 0}} ,{{152, 140}, {192, 253, 0}} ,{{186, 139}, {208, 252, 0}} ,{{49, 139}, {71, 252, 0}} ,{{104, 140}, {142, 253, 0}} ,{{105, 140}, {143, 253, 0}} ,{{145, 140}, {185, 253, 0}} ,{{115, 139}, {137, 252, 0}} ,{{187, 139}, {209, 252, 0}} ,{{50, 139}, {72, 252, 0}} ,{{137, 140}, {177, 253, 0}} ,{{52, 139}, {74, 252, 0}} ,{{164, 140}, {244, 253, 0}} ,{{120, 139}, {142, 252, 0}} ,{{57, 139}, {79, 252, 0}} ,{{189, 139}, {211, 252, 0}} ,{{54, 139}, {76, 252, 0}} ,{{110, 140}, {150, 253, 0}} ,{{109, 140}, {149, 253, 0}} ,{{139, 140}, {179, 253, 0}} ,{{192, 139}, {214, 252, 0}} ,{{217, 139}, {239, 252, 0}} ,{{188, 139}, {210, 252, 0}} ,{{53, 139}, {75, 252, 0}} ,{{113, 140}, {153, 253, 0}} ,{{149, 140}, {189, 253, 0}} ,{{144, 140}, {184, 253, 0}} ,{{111, 140}, {151, 253, 0}} ,{{112, 140}, {152, 253, 0}} ,{{159, 140}, {199, 253, 0}} ,{{190, 139}, {212, 252, 0}} ,{{55, 139}, {77, 252, 0}} ,{{118, 139}, {140, 252, 0}} ,{{191, 139}, {213, 252, 0}} ,{{56, 139}, {78, 252, 0}} ,{{216, 139}, {238, 252, 0}} ,{{115, 140}, {155, 253, 0}} ,{{114, 140}, {154, 253, 0}} ,{{119, 139}, {141, 252, 0}} ,{{116, 139}, {138, 252, 0}} ,{{121, 139}, {143, 252, 0}} ,{{58, 139}, {80, 252, 0}} ,{{117, 139}, {139, 252, 0}} ,{{104, 139}, {126, 252, 0}} ,{{31, 139}, {53, 252, 0}} ,{{172, 139}, {194, 252, 0}} ,{{29, 139}, {51, 252, 0}} ,{{173, 139}, {195, 252, 0}} ,{{30, 139}, {52, 252, 0}} ,{{88, 140}, {126, 253, 0}} ,{{140, 140}, {180, 253, 0}} ,{{89, 140}, {127, 253, 0}} ,{{138, 140}, {178, 253, 0}} ,{{105, 139}, {127, 252, 0}} ,{{32, 139}, {54, 252, 0}} ,{{161, 140}, {241, 253, 0}} ,{{166, 140}, {246, 253, 0}} ,{{70, 139}, {92, 252, 0}} ,{{11, 140}, {33, 253, 0}} ,{{239, 139}, {5, 253, 0}} ,{{155, 139}, {177, 252, 0}} ,{{10, 139}, {32, 252, 0}} ,{{62, 140}, {100, 253, 0}} ,{{63, 140}, {101, 253, 0}} ,{{129, 140}, {169, 253, 0}} ,{{156, 139}, {178, 252, 0}} ,{{157, 139}, {179, 252, 0}} ,{{11, 139}, {33, 252, 0}} ,{{64, 140}, {102, 253, 0}} ,{{157, 140}, {197, 253, 0}} ,{{21, 140}, {43, 253, 0}} ,{{249, 139}, {15, 253, 0}} ,{{12, 140}, {34, 253, 0}} ,{{240, 139}, {6, 253, 0}} ,{{165, 140}, {245, 253, 0}} ,{{170, 140}, {250, 253, 0}} ,{{169, 140}, {249, 253, 0}} ,{{160, 140}, {240, 253, 0}} ,{{1, 140}, {23, 253, 0}} ,{{229, 139}, {251, 252, 0}} ,{{152, 139}, {174, 252, 0}} ,{{7, 139}, {29, 252, 0}} ,{{31, 140}, {53, 253, 0}} ,{{54, 140}, {92, 253, 0}} ,{{27, 140}, {49, 253, 0}} ,{{210, 139}, {232, 252, 0}} ,{{151, 139}, {173, 252, 0}} ,{{6, 139}, {28, 252, 0}} ,{{30, 140}, {52, 253, 0}} ,{{56, 140}, {94, 253, 0}} ,{{55, 140}, {93, 253, 0}} ,{{153, 139}, {175, 252, 0}} ,{{8, 139}, {30, 252, 0}} ,{{32, 140}, {54, 253, 0}} ,{{128, 140}, {168, 253, 0}} ,{{158, 140}, {198, 253, 0}} ,{{154, 139}, {176, 252, 0}} ,{{9, 139}, {31, 252, 0}} ,{{209, 139}, {231, 252, 0}} ,{{57, 140}, {95, 253, 0}} ,{{58, 140}, {96, 253, 0}} ,{{59, 140}, {97, 253, 0}} ,{{60, 140}, {98, 253, 0}} ,{{61, 140}, {99, 253, 0}} ,{{20, 140}, {42, 253, 0}} ,{{248, 139}, {14, 253, 0}} ,{{2, 140}, {24, 253, 0}} ,{{230, 139}, {252, 252, 0}} ,{{72, 139}, {94, 252, 0}} ,{{75, 139}, {97, 252, 0}} ,{{221, 139}, {243, 252, 0}} ,{{74, 139}, {96, 252, 0}} ,{{220, 139}, {242, 252, 0}} ,{{73, 139}, {95, 252, 0}} ,{{76, 139}, {98, 252, 0}} ,{{222, 139}, {244, 252, 0}} ,{{77, 139}, {99, 252, 0}} ,{{3, 140}, {25, 253, 0}} ,{{231, 139}, {253, 252, 0}} ,{{16, 140}, {38, 253, 0}} ,{{24, 140}, {46, 253, 0}} ,{{244, 139}, {10, 253, 0}} ,{{34, 140}, {56, 253, 0}} ,{{65, 140}, {103, 253, 0}} ,{{66, 140}, {104, 253, 0}} ,{{130, 140}, {170, 253, 0}} ,{{28, 140}, {50, 253, 0}} ,{{212, 139}, {234, 252, 0}} ,{{15, 140}, {37, 253, 0}} ,{{23, 140}, {45, 253, 0}} ,{{243, 139}, {9, 253, 0}} ,{{33, 140}, {55, 253, 0}} ,{{67, 140}, {105, 253, 0}} ,{{17, 140}, {39, 253, 0}} ,{{25, 140}, {47, 253, 0}} ,{{245, 139}, {11, 253, 0}} ,{{35, 140}, {57, 253, 0}} ,{{18, 140}, {40, 253, 0}} ,{{26, 140}, {48, 253, 0}} ,{{246, 139}, {12, 253, 0}} ,{{211, 139}, {233, 252, 0}} ,{{68, 140}, {106, 253, 0}} ,{{69, 140}, {107, 253, 0}} ,{{70, 140}, {108, 253, 0}} ,{{71, 140}, {109, 253, 0}} ,{{19, 140}, {41, 253, 0}} ,{{247, 139}, {13, 253, 0}} ,{{4, 140}, {26, 253, 0}} ,{{232, 139}, {254, 252, 0}} ,{{251, 139}, {17, 253, 0}} ,{{223, 139}, {245, 252, 0}} ,{{162, 139}, {184, 252, 0}} ,{{16, 139}, {38, 252, 0}} ,{{29, 140}, {51, 253, 0}} ,{{17, 139}, {39, 252, 0}} ,{{36, 140}, {58, 253, 0}} ,{{75, 140}, {113, 253, 0}} ,{{76, 140}, {114, 253, 0}} ,{{77, 140}, {115, 253, 0}} ,{{78, 140}, {116, 253, 0}} ,{{252, 139}, {18, 253, 0}} ,{{224, 139}, {246, 252, 0}} ,{{94, 139}, {116, 252, 0}} ,{{249, 138}, {15, 252, 0}} ,{{140, 139}, {162, 252, 0}} ,{{246, 138}, {12, 252, 0}} ,{{43, 140}, {81, 253, 0}} ,{{44, 140}, {82, 253, 0}} ,{{45, 140}, {83, 253, 0}} ,{{143, 139}, {165, 252, 0}} ,{{206, 139}, {228, 252, 0}} ,{{139, 139}, {161, 252, 0}} ,{{245, 138}, {11, 252, 0}} ,{{120, 140}, {160, 253, 0}} ,{{42, 140}, {80, 253, 0}} ,{{119, 140}, {159, 253, 0}} ,{{141, 139}, {163, 252, 0}} ,{{247, 138}, {13, 252, 0}} ,{{122, 140}, {162, 253, 0}} ,{{46, 140}, {84, 253, 0}} ,{{121, 140}, {161, 253, 0}} ,{{92, 139}, {114, 252, 0}} ,{{142, 139}, {164, 252, 0}} ,{{248, 138}, {14, 252, 0}} ,{{205, 139}, {227, 252, 0}} ,{{124, 140}, {164, 253, 0}} ,{{48, 140}, {86, 253, 0}} ,{{47, 140}, {85, 253, 0}} ,{{49, 140}, {87, 253, 0}} ,{{123, 140}, {163, 253, 0}} ,{{93, 139}, {115, 252, 0}} ,{{90, 139}, {112, 252, 0}} ,{{95, 139}, {117, 252, 0}} ,{{250, 138}, {16, 252, 0}} ,{{91, 139}, {113, 252, 0}} ,{{69, 139}, {91, 252, 0}} ,{{100, 139}, {122, 252, 0}} ,{{253, 138}, {19, 252, 0}} ,{{208, 139}, {230, 252, 0}} ,{{251, 138}, {17, 252, 0}} ,{{98, 139}, {120, 252, 0}} ,{{144, 139}, {166, 252, 0}} ,{{252, 138}, {18, 252, 0}} ,{{207, 139}, {229, 252, 0}} ,{{99, 139}, {121, 252, 0}} ,{{96, 139}, {118, 252, 0}} ,{{101, 139}, {123, 252, 0}} ,{{254, 138}, {20, 252, 0}} ,{{97, 139}, {119, 252, 0}} ,{{228, 138}, {250, 251, 0}} ,{{229, 138}, {251, 251, 0}} ,{{227, 138}, {249, 251, 0}} ,{{168, 140}, {248, 253, 0}} ,{{127, 139}, {149, 252, 0}} ,{{67, 139}, {89, 252, 0}} ,{{197, 139}, {219, 252, 0}} ,{{64, 139}, {86, 252, 0}} ,{{134, 140}, {174, 253, 0}} ,{{215, 138}, {237, 251, 0}} ,{{214, 138}, {236, 251, 0}} ,{{213, 138}, {235, 251, 0}} ,{{212, 138}, {234, 251, 0}} ,{{82, 139}, {104, 252, 0}} ,{{237, 138}, {3, 252, 0}} ,{{225, 138}, {247, 251, 0}} ,{{226, 138}, {248, 251, 0}} ,{{224, 138}, {246, 251, 0}} ,{{130, 139}, {152, 252, 0}} ,{{235, 138}, {1, 252, 0}} ,{{133, 139}, {155, 252, 0}} ,{{202, 139}, {224, 252, 0}} ,{{129, 139}, {151, 252, 0}} ,{{234, 138}, {0, 252, 0}} ,{{131, 139}, {153, 252, 0}} ,{{80, 139}, {102, 252, 0}} ,{{132, 139}, {154, 252, 0}} ,{{236, 138}, {2, 252, 0}} ,{{201, 139}, {223, 252, 0}} ,{{81, 139}, {103, 252, 0}} ,{{221, 138}, {243, 251, 0}} ,{{220, 138}, {242, 251, 0}} ,{{78, 139}, {100, 252, 0}} ,{{219, 138}, {241, 251, 0}} ,{{218, 138}, {240, 251, 0}} ,{{217, 138}, {239, 251, 0}} ,{{216, 138}, {238, 251, 0}} ,{{83, 139}, {105, 252, 0}} ,{{238, 138}, {4, 252, 0}} ,{{223, 138}, {245, 251, 0}} ,{{222, 138}, {244, 251, 0}} ,{{79, 139}, {101, 252, 0}} ,{{200, 139}, {222, 252, 0}} ,{{219, 139}, {241, 252, 0}} ,{{196, 139}, {218, 252, 0}} ,{{63, 139}, {85, 252, 0}} ,{{135, 140}, {175, 253, 0}} ,{{198, 139}, {220, 252, 0}} ,{{65, 139}, {87, 252, 0}} ,{{125, 139}, {147, 252, 0}} ,{{199, 139}, {221, 252, 0}} ,{{66, 139}, {88, 252, 0}} ,{{218, 139}, {240, 252, 0}} ,{{116, 140}, {156, 253, 0}} ,{{117, 140}, {157, 253, 0}} ,{{136, 140}, {176, 253, 0}} ,{{126, 139}, {148, 252, 0}} ,{{123, 139}, {145, 252, 0}} ,{{128, 139}, {150, 252, 0}} ,{{68, 139}, {90, 252, 0}} ,{{124, 139}, {146, 252, 0}} ,{{163, 139}, {185, 252, 0}} ,{{18, 139}, {40, 252, 0}} ,{{37, 140}, {59, 253, 0}} ,{{185, 43}, {83, 6, 0}} ,{{190, 43}, {88, 6, 0}} ,{{107, 43}, {0, 6, 0}} ,{{207, 43}, {106, 6, 0}} ,{{78, 44}, {233, 6, 0}} ,{{119, 43}, {14, 6, 0}} ,{{134, 43}, {31, 6, 0}} ,{{113, 43}, {8, 6, 0}} ,{{195, 43}, {93, 6, 0}} ,{{81, 44}, {236, 6, 0}} ,{{132, 43}, {27, 6, 0}} ,{{183, 43}, {81, 6, 0}} ,{{20, 141}, {124, 254, 0}} ,{{21, 141}, {125, 254, 0}} ,{{122, 43}, {17, 6, 0}} ,{{120, 43}, {15, 6, 0}} ,{{124, 43}, {19, 6, 0}} ,{{123, 43}, {18, 6, 0}} ,{{110, 43}, {3, 6, 0}} ,{{121, 43}, {16, 6, 0}} ,{{108, 43}, {1, 6, 0}} ,{{98, 44}, {253, 6, 0}} ,{{99, 44}, {254, 6, 0}} ,{{125, 43}, {20, 6, 0}} ,{{130, 43}, {25, 6, 0}} ,{{129, 43}, {24, 6, 0}} ,{{70, 44}, {225, 6, 0}} ,{{63, 44}, {218, 6, 0}} ,{{62, 44}, {217, 6, 0}} ,{{127, 43}, {22, 6, 0}} ,{{60, 44}, {215, 6, 0}} ,{{59, 44}, {214, 6, 0}} ,{{73, 44}, {228, 6, 0}} ,{{61, 44}, {216, 6, 0}} ,{{71, 44}, {226, 6, 0}} ,{{77, 44}, {232, 6, 0}} ,{{68, 44}, {223, 6, 0}} ,{{65, 44}, {220, 6, 0}} ,{{126, 43}, {21, 6, 0}} ,{{64, 44}, {219, 6, 0}} ,{{69, 44}, {224, 6, 0}} ,{{76, 44}, {231, 6, 0}} ,{{128, 43}, {23, 6, 0}} ,{{131, 43}, {26, 6, 0}} ,{{82, 44}, {237, 6, 0}} ,{{72, 44}, {227, 6, 0}} ,{{74, 44}, {229, 6, 0}} ,{{75, 44}, {230, 6, 0}} ,{{67, 44}, {222, 6, 0}} ,{{188, 43}, {86, 6, 0}} ,{{184, 43}, {82, 6, 0}} ,{{22, 141}, {126, 254, 0}} ,{{23, 141}, {127, 254, 0}} ,{{12, 141}, {115, 254, 0}} ,{{166, 43}, {64, 6, 0}} ,{{10, 141}, {113, 254, 0}} ,{{209, 43}, {108, 6, 0}} ,{{133, 43}, {30, 6, 0}} ,{{194, 43}, {92, 6, 0}} ,{{193, 43}, {91, 6, 0}} ,{{192, 43}, {90, 6, 0}} ,{{191, 43}, {89, 6, 0}} ,{{35, 67}, {18, 35, 0}} ,{{20, 70}, {72, 38, 0}} ,{{234, 42}, {95, 5, 0}} ,{{229, 42}, {90, 5, 0}} ,{{190, 42}, {49, 5, 0}} ,{{191, 42}, {50, 5, 0}} ,{{203, 42}, {62, 5, 0}} ,{{214, 42}, {73, 5, 0}} ,{{208, 42}, {67, 5, 0}} ,{{222, 42}, {81, 5, 0}} ,{{193, 42}, {52, 5, 0}} ,{{194, 42}, {53, 5, 0}} ,{{196, 42}, {55, 5, 0}} ,{{197, 42}, {56, 5, 0}} ,{{227, 42}, {86, 5, 0}} ,{{207, 42}, {66, 5, 0}} ,{{192, 42}, {51, 5, 0}} ,{{205, 42}, {64, 5, 0}} ,{{200, 42}, {59, 5, 0}} ,{{206, 42}, {65, 5, 0}} ,{{216, 42}, {75, 5, 0}} ,{{225, 42}, {84, 5, 0}} ,{{204, 42}, {63, 5, 0}} ,{{201, 42}, {60, 5, 0}} ,{{209, 42}, {68, 5, 0}} ,{{211, 42}, {70, 5, 0}} ,{{226, 42}, {85, 5, 0}} ,{{215, 42}, {74, 5, 0}} ,{{224, 42}, {83, 5, 0}} ,{{217, 42}, {76, 5, 0}} ,{{221, 42}, {80, 5, 0}} ,{{218, 42}, {77, 5, 0}} ,{{212, 42}, {71, 5, 0}} ,{{220, 42}, {79, 5, 0}} ,{{198, 42}, {57, 5, 0}} ,{{219, 42}, {78, 5, 0}} ,{{213, 42}, {72, 5, 0}} ,{{202, 42}, {61, 5, 0}} ,{{210, 42}, {69, 5, 0}} ,{{223, 42}, {82, 5, 0}} ,{{195, 42}, {54, 5, 0}} ,{{199, 42}, {58, 5, 0}} ,{{232, 42}, {93, 5, 0}} ,{{230, 42}, {91, 5, 0}} ,{{231, 42}, {92, 5, 0}} ,{{18, 43}, {137, 5, 0}} ,{{19, 43}, {138, 5, 0}} ,{{228, 42}, {89, 5, 0}} ,{{233, 42}, {94, 5, 0}} ,{{235, 42}, {97, 5, 0}} ,{{236, 42}, {98, 5, 0}} ,{{248, 42}, {110, 5, 0}} ,{{3, 43}, {121, 5, 0}} ,{{253, 42}, {115, 5, 0}} ,{{11, 43}, {129, 5, 0}} ,{{238, 42}, {100, 5, 0}} ,{{239, 42}, {101, 5, 0}} ,{{241, 42}, {103, 5, 0}} ,{{242, 42}, {104, 5, 0}} ,{{16, 43}, {134, 5, 0}} ,{{252, 42}, {114, 5, 0}} ,{{237, 42}, {99, 5, 0}} ,{{250, 42}, {112, 5, 0}} ,{{245, 42}, {107, 5, 0}} ,{{251, 42}, {113, 5, 0}} ,{{5, 43}, {123, 5, 0}} ,{{14, 43}, {132, 5, 0}} ,{{249, 42}, {111, 5, 0}} ,{{246, 42}, {108, 5, 0}} ,{{254, 42}, {116, 5, 0}} ,{{0, 43}, {118, 5, 0}} ,{{15, 43}, {133, 5, 0}} ,{{4, 43}, {122, 5, 0}} ,{{13, 43}, {131, 5, 0}} ,{{6, 43}, {124, 5, 0}} ,{{10, 43}, {128, 5, 0}} ,{{7, 43}, {125, 5, 0}} ,{{1, 43}, {119, 5, 0}} ,{{9, 43}, {127, 5, 0}} ,{{243, 42}, {105, 5, 0}} ,{{8, 43}, {126, 5, 0}} ,{{2, 43}, {120, 5, 0}} ,{{247, 42}, {109, 5, 0}} ,{{255, 42}, {117, 5, 0}} ,{{12, 43}, {130, 5, 0}} ,{{240, 42}, {102, 5, 0}} ,{{244, 42}, {106, 5, 0}} ,{{17, 43}, {135, 5, 0}} ,{{41, 138}, {20, 251, 0}} ,{{42, 138}, {21, 251, 0}} ,{{40, 138}, {19, 251, 0}} ,{{44, 138}, {23, 251, 0}} ,{{43, 138}, {22, 251, 0}} ,{{231, 72}, {54, 41, 0}} ,{{232, 72}, {55, 41, 0}} ,{{230, 72}, {53, 41, 0}} ,{{229, 72}, {52, 41, 0}} ,{{214, 69}, {10, 38, 0}} ,{{183, 66}, {166, 34, 0}} ,{{237, 37}, {42, 0, 0}} ,{{40, 66}, {23, 34, 0}} ,{{146, 64}, {66, 32, 0}} ,{{84, 66}, {67, 34, 0}} ,{{103, 70}, {155, 38, 0}} ,{{240, 64}, {179, 32, 0}} ,{{183, 146}, {57, 11, 1}} ,{{129, 146}, {0, 11, 1}} ,{{130, 146}, {1, 11, 1}} ,{{134, 146}, {5, 11, 1}} ,{{132, 146}, {3, 11, 1}} ,{{135, 146}, {6, 11, 1}} ,{{136, 146}, {7, 11, 1}} ,{{133, 146}, {4, 11, 1}} ,{{131, 146}, {2, 11, 1}} ,{{161, 146}, {32, 11, 1}} ,{{162, 146}, {33, 11, 1}} ,{{152, 146}, {23, 11, 1}} ,{{156, 146}, {27, 11, 1}} ,{{157, 146}, {28, 11, 1}} ,{{137, 146}, {8, 11, 1}} ,{{138, 146}, {9, 11, 1}} ,{{160, 146}, {31, 11, 1}} ,{{149, 146}, {20, 11, 1}} ,{{150, 146}, {21, 11, 1}} ,{{151, 146}, {22, 11, 1}} ,{{182, 146}, {53, 11, 1}} ,{{170, 146}, {41, 11, 1}} ,{{141, 146}, {12, 11, 1}} ,{{142, 146}, {13, 11, 1}} ,{{153, 146}, {24, 11, 1}} ,{{145, 146}, {16, 11, 1}} ,{{175, 146}, {46, 11, 1}} ,{{169, 146}, {40, 11, 1}} ,{{166, 146}, {37, 11, 1}} ,{{163, 146}, {34, 11, 1}} ,{{165, 146}, {36, 11, 1}} ,{{164, 146}, {35, 11, 1}} ,{{168, 146}, {39, 11, 1}} ,{{167, 146}, {38, 11, 1}} ,{{139, 146}, {10, 11, 1}} ,{{140, 146}, {11, 11, 1}} ,{{159, 146}, {30, 11, 1}} ,{{174, 146}, {45, 11, 1}} ,{{176, 146}, {47, 11, 1}} ,{{178, 146}, {49, 11, 1}} ,{{180, 146}, {51, 11, 1}} ,{{181, 146}, {52, 11, 1}} ,{{154, 146}, {25, 11, 1}} ,{{155, 146}, {26, 11, 1}} ,{{158, 146}, {29, 11, 1}} ,{{143, 146}, {14, 11, 1}} ,{{144, 146}, {15, 11, 1}} ,{{173, 146}, {44, 11, 1}} ,{{146, 146}, {17, 11, 1}} ,{{148, 146}, {19, 11, 1}} ,{{147, 146}, {18, 11, 1}} ,{{172, 146}, {43, 11, 1}} ,{{171, 146}, {42, 11, 1}} ,{{177, 146}, {48, 11, 1}} ,{{179, 146}, {50, 11, 1}} ,{{98, 71}, {171, 39, 0}} ,{{116, 60}, {68, 27, 0}} ,{{137, 60}, {93, 27, 0}} ,{{139, 60}, {95, 27, 0}} ,{{138, 60}, {94, 27, 0}} ,{{132, 60}, {88, 27, 0}} ,{{129, 60}, {85, 27, 0}} ,{{128, 60}, {84, 27, 0}} ,{{133, 60}, {89, 27, 0}} ,{{125, 60}, {81, 27, 0}} ,{{131, 60}, {87, 27, 0}} ,{{130, 60}, {86, 27, 0}} ,{{127, 60}, {83, 27, 0}} ,{{126, 60}, {82, 27, 0}} ,{{124, 60}, {80, 27, 0}} ,{{64, 60}, {16, 27, 0}} ,{{53, 60}, {5, 27, 0}} ,{{54, 60}, {6, 27, 0}} ,{{123, 60}, {75, 27, 0}} ,{{89, 60}, {41, 27, 0}} ,{{90, 60}, {42, 27, 0}} ,{{72, 60}, {24, 27, 0}} ,{{73, 60}, {25, 27, 0}} ,{{84, 60}, {36, 27, 0}} ,{{85, 60}, {37, 27, 0}} ,{{79, 60}, {31, 27, 0}} ,{{80, 60}, {32, 27, 0}} ,{{120, 60}, {72, 27, 0}} ,{{63, 60}, {15, 27, 0}} ,{{69, 60}, {21, 27, 0}} ,{{70, 60}, {22, 27, 0}} ,{{99, 60}, {51, 27, 0}} ,{{55, 60}, {7, 27, 0}} ,{{56, 60}, {8, 27, 0}} ,{{74, 60}, {26, 27, 0}} ,{{75, 60}, {27, 27, 0}} ,{{67, 60}, {19, 27, 0}} ,{{117, 60}, {69, 27, 0}} ,{{68, 60}, {20, 27, 0}} ,{{118, 60}, {70, 27, 0}} ,{{94, 60}, {46, 27, 0}} ,{{61, 60}, {13, 27, 0}} ,{{62, 60}, {14, 27, 0}} ,{{91, 60}, {43, 27, 0}} ,{{86, 60}, {38, 27, 0}} ,{{81, 60}, {33, 27, 0}} ,{{71, 60}, {23, 27, 0}} ,{{76, 60}, {28, 27, 0}} ,{{65, 60}, {17, 27, 0}} ,{{66, 60}, {18, 27, 0}} ,{{87, 60}, {39, 27, 0}} ,{{88, 60}, {40, 27, 0}} ,{{93, 60}, {45, 27, 0}} ,{{59, 60}, {11, 27, 0}} ,{{60, 60}, {12, 27, 0}} ,{{98, 60}, {50, 27, 0}} ,{{96, 60}, {48, 27, 0}} ,{{97, 60}, {49, 27, 0}} ,{{82, 60}, {34, 27, 0}} ,{{77, 60}, {29, 27, 0}} ,{{78, 60}, {30, 27, 0}} ,{{83, 60}, {35, 27, 0}} ,{{119, 60}, {71, 27, 0}} ,{{57, 60}, {9, 27, 0}} ,{{58, 60}, {10, 27, 0}} ,{{121, 60}, {73, 27, 0}} ,{{95, 60}, {47, 27, 0}} ,{{92, 60}, {44, 27, 0}} ,{{122, 60}, {74, 27, 0}} ,{{158, 60}, {114, 27, 0}} ,{{152, 60}, {108, 27, 0}} ,{{159, 60}, {115, 27, 0}} ,{{155, 60}, {111, 27, 0}} ,{{154, 60}, {110, 27, 0}} ,{{157, 60}, {113, 27, 0}} ,{{153, 60}, {109, 27, 0}} ,{{156, 60}, {112, 27, 0}} ,{{151, 60}, {107, 27, 0}} ,{{147, 60}, {103, 27, 0}} ,{{149, 60}, {105, 27, 0}} ,{{144, 60}, {100, 27, 0}} ,{{150, 60}, {106, 27, 0}} ,{{145, 60}, {101, 27, 0}} ,{{142, 60}, {98, 27, 0}} ,{{148, 60}, {104, 27, 0}} ,{{146, 60}, {102, 27, 0}} ,{{141, 60}, {97, 27, 0}} ,{{143, 60}, {99, 27, 0}} ,{{166, 60}, {122, 27, 0}} ,{{167, 60}, {123, 27, 0}} ,{{164, 60}, {120, 27, 0}} ,{{168, 60}, {124, 27, 0}} ,{{165, 60}, {121, 27, 0}} ,{{163, 60}, {119, 27, 0}} ,{{162, 60}, {118, 27, 0}} ,{{161, 60}, {117, 27, 0}} ,{{160, 60}, {116, 27, 0}} ,{{135, 60}, {91, 27, 0}} ,{{140, 60}, {96, 27, 0}} ,{{134, 60}, {90, 27, 0}} ,{{52, 60}, {4, 27, 0}} ,{{50, 60}, {2, 27, 0}} ,{{100, 60}, {52, 27, 0}} ,{{51, 60}, {3, 27, 0}} ,{{49, 60}, {1, 27, 0}} ,{{48, 60}, {0, 27, 0}} ,{{108, 60}, {60, 27, 0}} ,{{109, 60}, {61, 27, 0}} ,{{114, 60}, {66, 27, 0}} ,{{115, 60}, {67, 27, 0}} ,{{106, 60}, {58, 27, 0}} ,{{107, 60}, {59, 27, 0}} ,{{104, 60}, {56, 27, 0}} ,{{105, 60}, {57, 27, 0}} ,{{110, 60}, {62, 27, 0}} ,{{111, 60}, {63, 27, 0}} ,{{113, 60}, {65, 27, 0}} ,{{112, 60}, {64, 27, 0}} ,{{101, 60}, {53, 27, 0}} ,{{102, 60}, {54, 27, 0}} ,{{103, 60}, {55, 27, 0}} ,{{136, 60}, {92, 27, 0}} ,{{10, 71}, {73, 39, 0}} ,{{220, 69}, {16, 38, 0}} ,{{221, 69}, {17, 38, 0}} ,{{222, 69}, {18, 38, 0}} ,{{217, 70}, {23, 39, 0}} ,{{50, 89}, {244, 166, 0}} ,{{46, 89}, {240, 166, 0}} ,{{47, 89}, {241, 166, 0}} ,{{51, 89}, {245, 166, 0}} ,{{49, 89}, {243, 166, 0}} ,{{222, 88}, {160, 166, 0}} ,{{226, 88}, {164, 166, 0}} ,{{43, 89}, {237, 166, 0}} ,{{9, 89}, {203, 166, 0}} ,{{23, 89}, {217, 166, 0}} ,{{22, 89}, {216, 166, 0}} ,{{231, 88}, {169, 166, 0}} ,{{223, 88}, {161, 166, 0}} ,{{16, 89}, {210, 166, 0}} ,{{249, 88}, {187, 166, 0}} ,{{2, 89}, {196, 166, 0}} ,{{35, 89}, {229, 166, 0}} ,{{29, 89}, {223, 166, 0}} ,{{45, 89}, {239, 166, 0}} ,{{44, 89}, {238, 166, 0}} ,{{39, 89}, {233, 166, 0}} ,{{225, 88}, {163, 166, 0}} ,{{248, 88}, {186, 166, 0}} ,{{232, 88}, {170, 166, 0}} ,{{236, 88}, {174, 166, 0}} ,{{26, 89}, {220, 166, 0}} ,{{28, 89}, {222, 166, 0}} ,{{11, 89}, {205, 166, 0}} ,{{241, 88}, {179, 166, 0}} ,{{33, 89}, {227, 166, 0}} ,{{37, 89}, {231, 166, 0}} ,{{30, 89}, {224, 166, 0}} ,{{237, 88}, {175, 166, 0}} ,{{32, 89}, {226, 166, 0}} ,{{12, 89}, {206, 166, 0}} ,{{36, 89}, {230, 166, 0}} ,{{243, 88}, {181, 166, 0}} ,{{25, 89}, {219, 166, 0}} ,{{239, 88}, {177, 166, 0}} ,{{19, 89}, {213, 166, 0}} ,{{18, 89}, {212, 166, 0}} ,{{17, 89}, {211, 166, 0}} ,{{13, 89}, {207, 166, 0}} ,{{240, 88}, {178, 166, 0}} ,{{4, 89}, {198, 166, 0}} ,{{252, 88}, {190, 166, 0}} ,{{1, 89}, {195, 166, 0}} ,{{5, 89}, {199, 166, 0}} ,{{41, 89}, {235, 166, 0}} ,{{251, 88}, {189, 166, 0}} ,{{250, 88}, {188, 166, 0}} ,{{230, 88}, {168, 166, 0}} ,{{229, 88}, {167, 166, 0}} ,{{233, 88}, {171, 166, 0}} ,{{8, 89}, {202, 166, 0}} ,{{3, 89}, {197, 166, 0}} ,{{27, 89}, {221, 166, 0}} ,{{21, 89}, {215, 166, 0}} ,{{6, 89}, {200, 166, 0}} ,{{15, 89}, {209, 166, 0}} ,{{227, 88}, {165, 166, 0}} ,{{31, 89}, {225, 166, 0}} ,{{14, 89}, {208, 166, 0}} ,{{235, 88}, {173, 166, 0}} ,{{234, 88}, {172, 166, 0}} ,{{10, 89}, {204, 166, 0}} ,{{42, 89}, {236, 166, 0}} ,{{247, 88}, {185, 166, 0}} ,{{246, 88}, {184, 166, 0}} ,{{244, 88}, {182, 166, 0}} ,{{20, 89}, {214, 166, 0}} ,{{254, 88}, {192, 166, 0}} ,{{245, 88}, {183, 166, 0}} ,{{242, 88}, {180, 166, 0}} ,{{238, 88}, {176, 166, 0}} ,{{228, 88}, {166, 166, 0}} ,{{40, 89}, {234, 166, 0}} ,{{38, 89}, {232, 166, 0}} ,{{34, 89}, {228, 166, 0}} ,{{224, 88}, {162, 166, 0}} ,{{24, 89}, {218, 166, 0}} ,{{7, 89}, {201, 166, 0}} ,{{0, 89}, {194, 166, 0}} ,{{253, 88}, {191, 166, 0}} ,{{255, 88}, {193, 166, 0}} ,{{48, 89}, {242, 166, 0}} ,{{53, 89}, {247, 166, 0}} ,{{52, 89}, {246, 166, 0}} ,{{138, 70}, {190, 38, 0}} ,{{55, 70}, {107, 38, 0}} ,{{56, 70}, {108, 38, 0}} ,{{70, 66}, {53, 34, 0}} ,{{143, 67}, {126, 35, 0}} ,{{63, 46}, {215, 9, 0}} ,{{90, 46}, {249, 9, 0}} ,{{88, 46}, {247, 9, 0}} ,{{85, 46}, {244, 9, 0}} ,{{89, 46}, {248, 9, 0}} ,{{87, 46}, {246, 9, 0}} ,{{86, 46}, {245, 9, 0}} ,{{79, 46}, {238, 9, 0}} ,{{76, 46}, {235, 9, 0}} ,{{75, 46}, {234, 9, 0}} ,{{80, 46}, {239, 9, 0}} ,{{72, 46}, {231, 9, 0}} ,{{78, 46}, {237, 9, 0}} ,{{77, 46}, {236, 9, 0}} ,{{74, 46}, {233, 9, 0}} ,{{73, 46}, {232, 9, 0}} ,{{71, 46}, {230, 9, 0}} ,{{92, 46}, {251, 9, 0}} ,{{91, 46}, {250, 9, 0}} ,{{4, 46}, {133, 9, 0}} ,{{5, 46}, {134, 9, 0}} ,{{13, 46}, {144, 9, 0}} ,{{15, 46}, {148, 9, 0}} ,{{38, 46}, {172, 9, 0}} ,{{39, 46}, {173, 9, 0}} ,{{21, 46}, {154, 9, 0}} ,{{22, 46}, {155, 9, 0}} ,{{33, 46}, {166, 9, 0}} ,{{28, 46}, {161, 9, 0}} ,{{29, 46}, {162, 9, 0}} ,{{34, 46}, {167, 9, 0}} ,{{12, 46}, {143, 9, 0}} ,{{18, 46}, {151, 9, 0}} ,{{19, 46}, {152, 9, 0}} ,{{47, 46}, {185, 9, 0}} ,{{6, 46}, {135, 9, 0}} ,{{7, 46}, {136, 9, 0}} ,{{23, 46}, {156, 9, 0}} ,{{24, 46}, {157, 9, 0}} ,{{16, 46}, {149, 9, 0}} ,{{17, 46}, {150, 9, 0}} ,{{62, 46}, {206, 9, 0}} ,{{43, 46}, {178, 9, 0}} ,{{40, 46}, {174, 9, 0}} ,{{35, 46}, {168, 9, 0}} ,{{20, 46}, {153, 9, 0}} ,{{30, 46}, {163, 9, 0}} ,{{25, 46}, {158, 9, 0}} ,{{14, 46}, {147, 9, 0}} ,{{36, 46}, {170, 9, 0}} ,{{37, 46}, {171, 9, 0}} ,{{42, 46}, {176, 9, 0}} ,{{82, 46}, {241, 9, 0}} ,{{81, 46}, {240, 9, 0}} ,{{65, 46}, {221, 9, 0}} ,{{64, 46}, {220, 9, 0}} ,{{46, 46}, {184, 9, 0}} ,{{44, 46}, {182, 9, 0}} ,{{45, 46}, {183, 9, 0}} ,{{31, 46}, {164, 9, 0}} ,{{32, 46}, {165, 9, 0}} ,{{26, 46}, {159, 9, 0}} ,{{27, 46}, {160, 9, 0}} ,{{8, 46}, {137, 9, 0}} ,{{9, 46}, {138, 9, 0}} ,{{11, 46}, {140, 9, 0}} ,{{68, 46}, {225, 9, 0}} ,{{10, 46}, {139, 9, 0}} ,{{67, 46}, {224, 9, 0}} ,{{41, 46}, {175, 9, 0}} ,{{66, 46}, {223, 9, 0}} ,{{83, 46}, {242, 9, 0}} ,{{84, 46}, {243, 9, 0}} ,{{2, 46}, {130, 9, 0}} ,{{49, 46}, {189, 9, 0}} ,{{1, 46}, {129, 9, 0}} ,{{48, 46}, {188, 9, 0}} ,{{61, 46}, {205, 9, 0}} ,{{3, 46}, {131, 9, 0}} ,{{50, 46}, {190, 9, 0}} ,{{58, 46}, {200, 9, 0}} ,{{60, 46}, {204, 9, 0}} ,{{57, 46}, {199, 9, 0}} ,{{51, 46}, {191, 9, 0}} ,{{52, 46}, {192, 9, 0}} ,{{59, 46}, {203, 9, 0}} ,{{53, 46}, {193, 9, 0}} ,{{54, 46}, {194, 9, 0}} ,{{69, 46}, {226, 9, 0}} ,{{70, 46}, {227, 9, 0}} ,{{55, 46}, {195, 9, 0}} ,{{56, 46}, {196, 9, 0}} ,{{61, 67}, {44, 35, 0}} ,{{244, 67}, {227, 35, 0}} ,{{125, 66}, {108, 34, 0}} ,{{77, 65}, {54, 33, 0}} ,{{170, 73}, {249, 41, 0}} ,{{169, 73}, {248, 41, 0}} ,{{239, 69}, {35, 38, 0}} ,{{108, 71}, {182, 39, 0}} ,{{107, 71}, {181, 39, 0}} ,{{106, 71}, {180, 39, 0}} ,{{68, 65}, {45, 33, 0}} ,{{35, 65}, {12, 33, 0}} ,{{40, 65}, {17, 33, 0}} ,{{51, 65}, {28, 33, 0}} ,{{63, 65}, {40, 33, 0}} ,{{132, 73}, {211, 41, 0}} ,{{237, 70}, {44, 39, 0}} ,{{41, 70}, {93, 38, 0}} ,{{38, 70}, {90, 38, 0}} ,{{42, 70}, {94, 38, 0}} ,{{43, 70}, {95, 38, 0}} ,{{39, 70}, {91, 38, 0}} ,{{40, 70}, {92, 38, 0}} ,{{155, 69}, {207, 37, 0}} ,{{158, 73}, {237, 41, 0}} ,{{85, 70}, {137, 38, 0}} ,{{84, 70}, {136, 38, 0}} ,{{47, 70}, {99, 38, 0}} ,{{174, 70}, {232, 38, 0}} ,{{146, 69}, {198, 37, 0}} ,{{18, 71}, {86, 39, 0}} ,{{50, 70}, {102, 38, 0}} ,{{155, 73}, {234, 41, 0}} ,{{138, 69}, {190, 37, 0}} ,{{136, 69}, {188, 37, 0}} ,{{143, 70}, {195, 38, 0}} ,{{142, 70}, {194, 38, 0}} ,{{93, 70}, {145, 38, 0}} ,{{0, 71}, {63, 39, 0}} ,{{232, 70}, {38, 39, 0}} ,{{49, 70}, {101, 38, 0}} ,{{211, 74}, {34, 43, 0}} ,{{221, 74}, {44, 43, 0}} ,{{136, 73}, {215, 41, 0}} ,{{213, 74}, {36, 43, 0}} ,{{204, 74}, {27, 43, 0}} ,{{144, 69}, {196, 37, 0}} ,{{142, 69}, {194, 37, 0}} ,{{140, 69}, {192, 37, 0}} ,{{156, 64}, {76, 32, 0}} ,{{163, 70}, {216, 38, 0}} ,{{230, 69}, {26, 38, 0}} ,{{175, 69}, {227, 37, 0}} ,{{174, 69}, {226, 37, 0}} ,{{156, 73}, {235, 41, 0}} ,{{214, 74}, {37, 43, 0}} ,{{216, 74}, {39, 43, 0}} ,{{202, 69}, {254, 37, 0}} ,{{200, 69}, {252, 37, 0}} ,{{132, 70}, {184, 38, 0}} ,{{212, 70}, {18, 39, 0}} ,{{124, 69}, {176, 37, 0}} ,{{208, 74}, {31, 43, 0}} ,{{120, 69}, {172, 37, 0}} ,{{1, 75}, {83, 43, 0}} ,{{134, 69}, {186, 37, 0}} ,{{132, 69}, {184, 37, 0}} ,{{130, 69}, {182, 37, 0}} ,{{88, 71}, {161, 39, 0}} ,{{91, 71}, {164, 39, 0}} ,{{157, 64}, {77, 32, 0}} ,{{231, 69}, {27, 38, 0}} ,{{199, 70}, {2, 39, 0}} ,{{227, 69}, {23, 38, 0}} ,{{218, 74}, {41, 43, 0}} ,{{219, 74}, {42, 43, 0}} ,{{118, 69}, {170, 37, 0}} ,{{255, 74}, {81, 43, 0}} ,{{7, 70}, {59, 38, 0}} ,{{147, 70}, {199, 38, 0}} ,{{44, 70}, {96, 38, 0}} ,{{108, 69}, {160, 37, 0}} ,{{209, 69}, {5, 38, 0}} ,{{204, 69}, {0, 38, 0}} ,{{218, 69}, {14, 38, 0}} ,{{170, 70}, {223, 38, 0}} ,{{161, 70}, {214, 38, 0}} ,{{71, 70}, {123, 38, 0}} ,{{128, 69}, {180, 37, 0}} ,{{126, 69}, {178, 37, 0}} ,{{176, 69}, {228, 37, 0}} ,{{177, 69}, {229, 37, 0}} ,{{223, 74}, {46, 43, 0}} ,{{122, 69}, {174, 37, 0}} ,{{206, 74}, {29, 43, 0}} ,{{28, 68}, {34, 36, 0}} ,{{253, 79}, {183, 49, 0}} ,{{252, 79}, {182, 49, 0}} ,{{250, 79}, {180, 49, 0}} ,{{251, 79}, {181, 49, 0}} ,{{100, 79}, {26, 49, 0}} ,{{104, 79}, {30, 49, 0}} ,{{244, 79}, {174, 49, 0}} ,{{246, 79}, {176, 49, 0}} ,{{108, 79}, {34, 49, 0}} ,{{110, 79}, {36, 49, 0}} ,{{239, 79}, {169, 49, 0}} ,{{106, 79}, {32, 49, 0}} ,{{245, 79}, {175, 49, 0}} ,{{79, 79}, {5, 49, 0}} ,{{230, 79}, {160, 49, 0}} ,{{98, 79}, {24, 49, 0}} ,{{94, 79}, {20, 49, 0}} ,{{83, 79}, {9, 49, 0}} ,{{102, 79}, {28, 49, 0}} ,{{234, 79}, {164, 49, 0}} ,{{103, 79}, {29, 49, 0}} ,{{105, 79}, {31, 49, 0}} ,{{109, 79}, {35, 49, 0}} ,{{111, 79}, {37, 49, 0}} ,{{235, 79}, {165, 49, 0}} ,{{112, 79}, {38, 49, 0}} ,{{82, 79}, {8, 49, 0}} ,{{87, 79}, {13, 49, 0}} ,{{118, 79}, {44, 49, 0}} ,{{233, 79}, {163, 49, 0}} ,{{89, 79}, {15, 49, 0}} ,{{113, 79}, {39, 49, 0}} ,{{119, 79}, {45, 49, 0}} ,{{242, 79}, {172, 49, 0}} ,{{240, 79}, {170, 49, 0}} ,{{249, 79}, {179, 49, 0}} ,{{238, 79}, {168, 49, 0}} ,{{115, 79}, {41, 49, 0}} ,{{90, 79}, {16, 49, 0}} ,{{232, 79}, {162, 49, 0}} ,{{88, 79}, {14, 49, 0}} ,{{86, 79}, {12, 49, 0}} ,{{81, 79}, {7, 49, 0}} ,{{85, 79}, {11, 49, 0}} ,{{117, 79}, {43, 49, 0}} ,{{243, 79}, {173, 49, 0}} ,{{101, 79}, {27, 49, 0}} ,{{247, 79}, {177, 49, 0}} ,{{248, 79}, {178, 49, 0}} ,{{237, 79}, {167, 49, 0}} ,{{236, 79}, {166, 49, 0}} ,{{107, 79}, {33, 49, 0}} ,{{80, 79}, {6, 49, 0}} ,{{91, 79}, {17, 49, 0}} ,{{96, 79}, {22, 49, 0}} ,{{99, 79}, {25, 49, 0}} ,{{95, 79}, {21, 49, 0}} ,{{84, 79}, {10, 49, 0}} ,{{114, 79}, {40, 49, 0}} ,{{241, 79}, {171, 49, 0}} ,{{116, 79}, {42, 49, 0}} ,{{92, 79}, {18, 49, 0}} ,{{97, 79}, {23, 49, 0}} ,{{93, 79}, {19, 49, 0}} ,{{231, 79}, {161, 49, 0}} ,{{236, 72}, {59, 41, 0}} ,{{240, 67}, {223, 35, 0}} ,{{50, 67}, {33, 35, 0}} ,{{47, 67}, {30, 35, 0}} ,{{30, 67}, {13, 35, 0}} ,{{239, 76}, {36, 46, 0}} ,{{238, 67}, {221, 35, 0}} ,{{48, 67}, {31, 35, 0}} ,{{29, 67}, {12, 35, 0}} ,{{240, 76}, {37, 46, 0}} ,{{198, 67}, {181, 35, 0}} ,{{199, 67}, {182, 35, 0}} ,{{242, 67}, {225, 35, 0}} ,{{217, 66}, {200, 34, 0}} ,{{130, 73}, {209, 41, 0}} ,{{131, 73}, {210, 41, 0}} ,{{50, 69}, {102, 37, 0}} ,{{35, 69}, {87, 37, 0}} ,{{32, 69}, {84, 37, 0}} ,{{28, 69}, {80, 37, 0}} ,{{53, 69}, {105, 37, 0}} ,{{41, 69}, {93, 37, 0}} ,{{38, 69}, {90, 37, 0}} ,{{29, 69}, {81, 37, 0}} ,{{56, 69}, {108, 37, 0}} ,{{47, 69}, {99, 37, 0}} ,{{44, 69}, {96, 37, 0}} ,{{49, 69}, {101, 37, 0}} ,{{34, 69}, {86, 37, 0}} ,{{31, 69}, {83, 37, 0}} ,{{252, 68}, {48, 37, 0}} ,{{222, 68}, {18, 37, 0}} ,{{243, 68}, {39, 37, 0}} ,{{218, 68}, {14, 37, 0}} ,{{235, 68}, {31, 37, 0}} ,{{13, 69}, {65, 37, 0}} ,{{251, 68}, {47, 37, 0}} ,{{221, 68}, {17, 37, 0}} ,{{245, 68}, {41, 37, 0}} ,{{217, 68}, {13, 37, 0}} ,{{237, 68}, {33, 37, 0}} ,{{19, 69}, {71, 37, 0}} ,{{48, 69}, {100, 37, 0}} ,{{33, 69}, {85, 37, 0}} ,{{30, 69}, {82, 37, 0}} ,{{25, 69}, {77, 37, 0}} ,{{27, 69}, {79, 37, 0}} ,{{71, 69}, {123, 37, 0}} ,{{255, 68}, {51, 37, 0}} ,{{223, 68}, {19, 37, 0}} ,{{219, 68}, {15, 37, 0}} ,{{205, 68}, {1, 37, 0}} ,{{68, 69}, {120, 37, 0}} ,{{74, 69}, {126, 37, 0}} ,{{213, 68}, {9, 37, 0}} ,{{215, 68}, {11, 37, 0}} ,{{70, 69}, {122, 37, 0}} ,{{209, 68}, {5, 37, 0}} ,{{211, 68}, {7, 37, 0}} ,{{69, 69}, {121, 37, 0}} ,{{7, 69}, {59, 37, 0}} ,{{231, 68}, {27, 37, 0}} ,{{75, 69}, {127, 37, 0}} ,{{227, 68}, {23, 37, 0}} ,{{207, 68}, {3, 37, 0}} ,{{23, 69}, {75, 37, 0}} ,{{247, 68}, {43, 37, 0}} ,{{239, 68}, {35, 37, 0}} ,{{17, 69}, {69, 37, 0}} ,{{249, 68}, {45, 37, 0}} ,{{1, 69}, {53, 37, 0}} ,{{9, 69}, {61, 37, 0}} ,{{254, 68}, {50, 37, 0}} ,{{6, 69}, {58, 37, 0}} ,{{22, 69}, {74, 37, 0}} ,{{15, 69}, {67, 37, 0}} ,{{58, 69}, {110, 37, 0}} ,{{57, 69}, {109, 37, 0}} ,{{59, 69}, {111, 37, 0}} ,{{60, 69}, {112, 37, 0}} ,{{63, 69}, {115, 37, 0}} ,{{62, 69}, {114, 37, 0}} ,{{61, 69}, {113, 37, 0}} ,{{24, 69}, {76, 37, 0}} ,{{26, 69}, {78, 37, 0}} ,{{67, 69}, {119, 37, 0}} ,{{248, 68}, {44, 37, 0}} ,{{220, 68}, {16, 37, 0}} ,{{216, 68}, {12, 37, 0}} ,{{204, 68}, {0, 37, 0}} ,{{64, 69}, {116, 37, 0}} ,{{72, 69}, {124, 37, 0}} ,{{212, 68}, {8, 37, 0}} ,{{214, 68}, {10, 37, 0}} ,{{66, 69}, {118, 37, 0}} ,{{208, 68}, {4, 37, 0}} ,{{210, 68}, {6, 37, 0}} ,{{65, 69}, {117, 37, 0}} ,{{73, 69}, {125, 37, 0}} ,{{0, 69}, {52, 37, 0}} ,{{228, 68}, {24, 37, 0}} ,{{224, 68}, {20, 37, 0}} ,{{206, 68}, {2, 37, 0}} ,{{8, 69}, {60, 37, 0}} ,{{240, 68}, {36, 37, 0}} ,{{232, 68}, {28, 37, 0}} ,{{18, 69}, {70, 37, 0}} ,{{250, 68}, {46, 37, 0}} ,{{2, 69}, {54, 37, 0}} ,{{10, 69}, {62, 37, 0}} ,{{253, 68}, {49, 37, 0}} ,{{5, 69}, {57, 37, 0}} ,{{21, 69}, {73, 37, 0}} ,{{16, 69}, {68, 37, 0}} ,{{52, 69}, {104, 37, 0}} ,{{40, 69}, {92, 37, 0}} ,{{37, 69}, {89, 37, 0}} ,{{12, 69}, {64, 37, 0}} ,{{4, 69}, {56, 37, 0}} ,{{242, 68}, {38, 37, 0}} ,{{230, 68}, {26, 37, 0}} ,{{234, 68}, {30, 37, 0}} ,{{226, 68}, {22, 37, 0}} ,{{20, 69}, {72, 37, 0}} ,{{3, 69}, {55, 37, 0}} ,{{246, 68}, {42, 37, 0}} ,{{229, 68}, {25, 37, 0}} ,{{238, 68}, {34, 37, 0}} ,{{225, 68}, {21, 37, 0}} ,{{51, 69}, {103, 37, 0}} ,{{39, 69}, {91, 37, 0}} ,{{36, 69}, {88, 37, 0}} ,{{55, 69}, {107, 37, 0}} ,{{46, 69}, {98, 37, 0}} ,{{43, 69}, {95, 37, 0}} ,{{14, 69}, {66, 37, 0}} ,{{244, 68}, {40, 37, 0}} ,{{236, 68}, {32, 37, 0}} ,{{11, 69}, {63, 37, 0}} ,{{241, 68}, {37, 37, 0}} ,{{233, 68}, {29, 37, 0}} ,{{54, 69}, {106, 37, 0}} ,{{45, 69}, {97, 37, 0}} ,{{42, 69}, {94, 37, 0}} ,{{177, 71}, {0, 40, 0}} ,{{178, 71}, {1, 40, 0}} ,{{180, 71}, {3, 40, 0}} ,{{184, 71}, {7, 40, 0}} ,{{192, 71}, {15, 40, 0}} ,{{208, 71}, {31, 40, 0}} ,{{240, 71}, {63, 40, 0}} ,{{48, 72}, {127, 40, 0}} ,{{176, 72}, {255, 40, 0}} ,{{112, 72}, {191, 40, 0}} ,{{16, 72}, {95, 40, 0}} ,{{144, 72}, {223, 40, 0}} ,{{80, 72}, {159, 40, 0}} ,{{224, 71}, {47, 40, 0}} ,{{32, 72}, {111, 40, 0}} ,{{160, 72}, {239, 40, 0}} ,{{96, 72}, {175, 40, 0}} ,{{0, 72}, {79, 40, 0}} ,{{128, 72}, {207, 40, 0}} ,{{64, 72}, {143, 40, 0}} ,{{200, 71}, {23, 40, 0}} ,{{232, 71}, {55, 40, 0}} ,{{40, 72}, {119, 40, 0}} ,{{168, 72}, {247, 40, 0}} ,{{104, 72}, {183, 40, 0}} ,{{8, 72}, {87, 40, 0}} ,{{136, 72}, {215, 40, 0}} ,{{72, 72}, {151, 40, 0}} ,{{216, 71}, {39, 40, 0}} ,{{24, 72}, {103, 40, 0}} ,{{152, 72}, {231, 40, 0}} ,{{88, 72}, {167, 40, 0}} ,{{248, 71}, {71, 40, 0}} ,{{120, 72}, {199, 40, 0}} ,{{56, 72}, {135, 40, 0}} ,{{188, 71}, {11, 40, 0}} ,{{204, 71}, {27, 40, 0}} ,{{236, 71}, {59, 40, 0}} ,{{44, 72}, {123, 40, 0}} ,{{172, 72}, {251, 40, 0}} ,{{108, 72}, {187, 40, 0}} ,{{12, 72}, {91, 40, 0}} ,{{140, 72}, {219, 40, 0}} ,{{76, 72}, {155, 40, 0}} ,{{220, 71}, {43, 40, 0}} ,{{28, 72}, {107, 40, 0}} ,{{156, 72}, {235, 40, 0}} ,{{92, 72}, {171, 40, 0}} ,{{252, 71}, {75, 40, 0}} ,{{124, 72}, {203, 40, 0}} ,{{60, 72}, {139, 40, 0}} ,{{196, 71}, {19, 40, 0}} ,{{228, 71}, {51, 40, 0}} ,{{36, 72}, {115, 40, 0}} ,{{164, 72}, {243, 40, 0}} ,{{100, 72}, {179, 40, 0}} ,{{4, 72}, {83, 40, 0}} ,{{132, 72}, {211, 40, 0}} ,{{68, 72}, {147, 40, 0}} ,{{212, 71}, {35, 40, 0}} ,{{20, 72}, {99, 40, 0}} ,{{148, 72}, {227, 40, 0}} ,{{84, 72}, {163, 40, 0}} ,{{244, 71}, {67, 40, 0}} ,{{116, 72}, {195, 40, 0}} ,{{52, 72}, {131, 40, 0}} ,{{182, 71}, {5, 40, 0}} ,{{190, 71}, {13, 40, 0}} ,{{206, 71}, {29, 40, 0}} ,{{238, 71}, {61, 40, 0}} ,{{46, 72}, {125, 40, 0}} ,{{174, 72}, {253, 40, 0}} ,{{110, 72}, {189, 40, 0}} ,{{14, 72}, {93, 40, 0}} ,{{142, 72}, {221, 40, 0}} ,{{78, 72}, {157, 40, 0}} ,{{222, 71}, {45, 40, 0}} ,{{30, 72}, {109, 40, 0}} ,{{158, 72}, {237, 40, 0}} ,{{94, 72}, {173, 40, 0}} ,{{254, 71}, {77, 40, 0}} ,{{126, 72}, {205, 40, 0}} ,{{62, 72}, {141, 40, 0}} ,{{198, 71}, {21, 40, 0}} ,{{230, 71}, {53, 40, 0}} ,{{38, 72}, {117, 40, 0}} ,{{166, 72}, {245, 40, 0}} ,{{102, 72}, {181, 40, 0}} ,{{6, 72}, {85, 40, 0}} ,{{134, 72}, {213, 40, 0}} ,{{70, 72}, {149, 40, 0}} ,{{214, 71}, {37, 40, 0}} ,{{22, 72}, {101, 40, 0}} ,{{150, 72}, {229, 40, 0}} ,{{86, 72}, {165, 40, 0}} ,{{246, 71}, {69, 40, 0}} ,{{118, 72}, {197, 40, 0}} ,{{54, 72}, {133, 40, 0}} ,{{186, 71}, {9, 40, 0}} ,{{202, 71}, {25, 40, 0}} ,{{234, 71}, {57, 40, 0}} ,{{42, 72}, {121, 40, 0}} ,{{170, 72}, {249, 40, 0}} ,{{106, 72}, {185, 40, 0}} ,{{10, 72}, {89, 40, 0}} ,{{138, 72}, {217, 40, 0}} ,{{74, 72}, {153, 40, 0}} ,{{218, 71}, {41, 40, 0}} ,{{26, 72}, {105, 40, 0}} ,{{154, 72}, {233, 40, 0}} ,{{90, 72}, {169, 40, 0}} ,{{250, 71}, {73, 40, 0}} ,{{122, 72}, {201, 40, 0}} ,{{58, 72}, {137, 40, 0}} ,{{194, 71}, {17, 40, 0}} ,{{226, 71}, {49, 40, 0}} ,{{34, 72}, {113, 40, 0}} ,{{162, 72}, {241, 40, 0}} ,{{98, 72}, {177, 40, 0}} ,{{2, 72}, {81, 40, 0}} ,{{130, 72}, {209, 40, 0}} ,{{66, 72}, {145, 40, 0}} ,{{210, 71}, {33, 40, 0}} ,{{18, 72}, {97, 40, 0}} ,{{146, 72}, {225, 40, 0}} ,{{82, 72}, {161, 40, 0}} ,{{242, 71}, {65, 40, 0}} ,{{114, 72}, {193, 40, 0}} ,{{50, 72}, {129, 40, 0}} ,{{179, 71}, {2, 40, 0}} ,{{183, 71}, {6, 40, 0}} ,{{191, 71}, {14, 40, 0}} ,{{207, 71}, {30, 40, 0}} ,{{239, 71}, {62, 40, 0}} ,{{47, 72}, {126, 40, 0}} ,{{175, 72}, {254, 40, 0}} ,{{111, 72}, {190, 40, 0}} ,{{15, 72}, {94, 40, 0}} ,{{143, 72}, {222, 40, 0}} ,{{79, 72}, {158, 40, 0}} ,{{223, 71}, {46, 40, 0}} ,{{31, 72}, {110, 40, 0}} ,{{159, 72}, {238, 40, 0}} ,{{95, 72}, {174, 40, 0}} ,{{255, 71}, {78, 40, 0}} ,{{127, 72}, {206, 40, 0}} ,{{63, 72}, {142, 40, 0}} ,{{199, 71}, {22, 40, 0}} ,{{231, 71}, {54, 40, 0}} ,{{39, 72}, {118, 40, 0}} ,{{167, 72}, {246, 40, 0}} ,{{103, 72}, {182, 40, 0}} ,{{7, 72}, {86, 40, 0}} ,{{135, 72}, {214, 40, 0}} ,{{71, 72}, {150, 40, 0}} ,{{215, 71}, {38, 40, 0}} ,{{23, 72}, {102, 40, 0}} ,{{151, 72}, {230, 40, 0}} ,{{87, 72}, {166, 40, 0}} ,{{247, 71}, {70, 40, 0}} ,{{119, 72}, {198, 40, 0}} ,{{55, 72}, {134, 40, 0}} ,{{187, 71}, {10, 40, 0}} ,{{203, 71}, {26, 40, 0}} ,{{235, 71}, {58, 40, 0}} ,{{43, 72}, {122, 40, 0}} ,{{171, 72}, {250, 40, 0}} ,{{107, 72}, {186, 40, 0}} ,{{11, 72}, {90, 40, 0}} ,{{139, 72}, {218, 40, 0}} ,{{75, 72}, {154, 40, 0}} ,{{219, 71}, {42, 40, 0}} ,{{27, 72}, {106, 40, 0}} ,{{155, 72}, {234, 40, 0}} ,{{91, 72}, {170, 40, 0}} ,{{251, 71}, {74, 40, 0}} ,{{123, 72}, {202, 40, 0}} ,{{59, 72}, {138, 40, 0}} ,{{195, 71}, {18, 40, 0}} ,{{227, 71}, {50, 40, 0}} ,{{35, 72}, {114, 40, 0}} ,{{163, 72}, {242, 40, 0}} ,{{99, 72}, {178, 40, 0}} ,{{3, 72}, {82, 40, 0}} ,{{131, 72}, {210, 40, 0}} ,{{67, 72}, {146, 40, 0}} ,{{211, 71}, {34, 40, 0}} ,{{19, 72}, {98, 40, 0}} ,{{147, 72}, {226, 40, 0}} ,{{83, 72}, {162, 40, 0}} ,{{243, 71}, {66, 40, 0}} ,{{115, 72}, {194, 40, 0}} ,{{51, 72}, {130, 40, 0}} ,{{181, 71}, {4, 40, 0}} ,{{189, 71}, {12, 40, 0}} ,{{205, 71}, {28, 40, 0}} ,{{237, 71}, {60, 40, 0}} ,{{45, 72}, {124, 40, 0}} ,{{173, 72}, {252, 40, 0}} ,{{109, 72}, {188, 40, 0}} ,{{13, 72}, {92, 40, 0}} ,{{141, 72}, {220, 40, 0}} ,{{77, 72}, {156, 40, 0}} ,{{221, 71}, {44, 40, 0}} ,{{29, 72}, {108, 40, 0}} ,{{157, 72}, {236, 40, 0}} ,{{93, 72}, {172, 40, 0}} ,{{253, 71}, {76, 40, 0}} ,{{125, 72}, {204, 40, 0}} ,{{61, 72}, {140, 40, 0}} ,{{197, 71}, {20, 40, 0}} ,{{229, 71}, {52, 40, 0}} ,{{37, 72}, {116, 40, 0}} ,{{165, 72}, {244, 40, 0}} ,{{101, 72}, {180, 40, 0}} ,{{5, 72}, {84, 40, 0}} ,{{133, 72}, {212, 40, 0}} ,{{69, 72}, {148, 40, 0}} ,{{213, 71}, {36, 40, 0}} ,{{21, 72}, {100, 40, 0}} ,{{149, 72}, {228, 40, 0}} ,{{85, 72}, {164, 40, 0}} ,{{245, 71}, {68, 40, 0}} ,{{117, 72}, {196, 40, 0}} ,{{53, 72}, {132, 40, 0}} ,{{185, 71}, {8, 40, 0}} ,{{201, 71}, {24, 40, 0}} ,{{233, 71}, {56, 40, 0}} ,{{41, 72}, {120, 40, 0}} ,{{169, 72}, {248, 40, 0}} ,{{105, 72}, {184, 40, 0}} ,{{9, 72}, {88, 40, 0}} ,{{137, 72}, {216, 40, 0}} ,{{73, 72}, {152, 40, 0}} ,{{217, 71}, {40, 40, 0}} ,{{25, 72}, {104, 40, 0}} ,{{153, 72}, {232, 40, 0}} ,{{89, 72}, {168, 40, 0}} ,{{249, 71}, {72, 40, 0}} ,{{121, 72}, {200, 40, 0}} ,{{57, 72}, {136, 40, 0}} ,{{193, 71}, {16, 40, 0}} ,{{225, 71}, {48, 40, 0}} ,{{33, 72}, {112, 40, 0}} ,{{161, 72}, {240, 40, 0}} ,{{97, 72}, {176, 40, 0}} ,{{1, 72}, {80, 40, 0}} ,{{129, 72}, {208, 40, 0}} ,{{65, 72}, {144, 40, 0}} ,{{209, 71}, {32, 40, 0}} ,{{17, 72}, {96, 40, 0}} ,{{145, 72}, {224, 40, 0}} ,{{81, 72}, {160, 40, 0}} ,{{241, 71}, {64, 40, 0}} ,{{113, 72}, {192, 40, 0}} ,{{49, 72}, {128, 40, 0}} ,{{122, 40}, {216, 2, 0}} ,{{72, 38}, {166, 0, 0}} ,{{156, 67}, {139, 35, 0}} ,{{176, 59}, {31, 26, 0}} ,{{168, 59}, {21, 26, 0}} ,{{152, 59}, {5, 26, 0}} ,{{159, 59}, {12, 26, 0}} ,{{156, 59}, {9, 26, 0}} ,{{148, 59}, {1, 26, 0}} ,{{169, 59}, {22, 26, 0}} ,{{160, 59}, {13, 26, 0}} ,{{147, 59}, {0, 26, 0}} ,{{165, 59}, {18, 26, 0}} ,{{153, 59}, {6, 26, 0}} ,{{154, 59}, {7, 26, 0}} ,{{157, 59}, {10, 26, 0}} ,{{149, 59}, {2, 26, 0}} ,{{150, 59}, {3, 26, 0}} ,{{158, 59}, {11, 26, 0}} ,{{161, 59}, {14, 26, 0}} ,{{162, 59}, {15, 26, 0}} ,{{151, 59}, {4, 26, 0}} ,{{164, 59}, {17, 26, 0}} ,{{167, 59}, {20, 26, 0}} ,{{155, 59}, {8, 26, 0}} ,{{166, 59}, {19, 26, 0}} ,{{163, 59}, {16, 26, 0}} ,{{175, 59}, {30, 26, 0}} ,{{174, 59}, {27, 26, 0}} ,{{172, 59}, {25, 26, 0}} ,{{170, 59}, {23, 26, 0}} ,{{173, 59}, {26, 26, 0}} ,{{171, 59}, {24, 26, 0}} ,{{65, 57}, {64, 23, 0}} ,{{75, 57}, {74, 23, 0}} ,{{72, 57}, {71, 23, 0}} ,{{69, 57}, {68, 23, 0}} ,{{82, 57}, {81, 23, 0}} ,{{66, 57}, {65, 23, 0}} ,{{68, 57}, {67, 23, 0}} ,{{79, 57}, {78, 23, 0}} ,{{76, 57}, {75, 23, 0}} ,{{73, 57}, {72, 23, 0}} ,{{70, 57}, {69, 23, 0}} ,{{74, 57}, {73, 23, 0}} ,{{78, 57}, {77, 23, 0}} ,{{81, 57}, {80, 23, 0}} ,{{71, 57}, {70, 23, 0}} ,{{67, 57}, {66, 23, 0}} ,{{80, 57}, {79, 23, 0}} ,{{77, 57}, {76, 23, 0}} ,{{83, 57}, {82, 23, 0}} ,{{84, 57}, {83, 23, 0}} ,{{114, 64}, {34, 32, 0}} ,{{42, 66}, {25, 34, 0}} ,{{154, 69}, {206, 37, 0}} ,{{66, 156}, {156, 208, 1}} ,{{65, 156}, {155, 208, 1}} ,{{69, 156}, {159, 208, 1}} ,{{70, 156}, {160, 208, 1}} ,{{68, 156}, {158, 208, 1}} ,{{67, 156}, {157, 208, 1}} ,{{64, 156}, {154, 208, 1}} ,{{71, 156}, {161, 208, 1}} ,{{206, 155}, {40, 208, 1}} ,{{8, 156}, {98, 208, 1}} ,{{2, 156}, {92, 208, 1}} ,{{179, 155}, {13, 208, 1}} ,{{217, 155}, {51, 208, 1}} ,{{43, 156}, {133, 208, 1}} ,{{200, 155}, {34, 208, 1}} ,{{42, 156}, {132, 208, 1}} ,{{248, 155}, {82, 208, 1}} ,{{83, 156}, {173, 208, 1}} ,{{183, 155}, {17, 208, 1}} ,{{184, 155}, {18, 208, 1}} ,{{247, 155}, {81, 208, 1}} ,{{201, 155}, {35, 208, 1}} ,{{61, 156}, {151, 208, 1}} ,{{25, 156}, {115, 208, 1}} ,{{146, 156}, {236, 208, 1}} ,{{145, 156}, {235, 208, 1}} ,{{147, 156}, {237, 208, 1}} ,{{149, 156}, {239, 208, 1}} ,{{143, 156}, {233, 208, 1}} ,{{144, 156}, {234, 208, 1}} ,{{148, 156}, {238, 208, 1}} ,{{252, 155}, {86, 208, 1}} ,{{190, 155}, {24, 208, 1}} ,{{225, 155}, {59, 208, 1}} ,{{13, 156}, {103, 208, 1}} ,{{111, 156}, {201, 208, 1}} ,{{112, 156}, {202, 208, 1}} ,{{110, 156}, {200, 208, 1}} ,{{167, 155}, {1, 208, 1}} ,{{63, 156}, {153, 208, 1}} ,{{129, 156}, {219, 208, 1}} ,{{128, 156}, {218, 208, 1}} ,{{130, 156}, {220, 208, 1}} ,{{131, 156}, {221, 208, 1}} ,{{118, 156}, {208, 208, 1}} ,{{120, 156}, {210, 208, 1}} ,{{119, 156}, {209, 208, 1}} ,{{117, 156}, {207, 208, 1}} ,{{121, 156}, {211, 208, 1}} ,{{116, 156}, {206, 208, 1}} ,{{141, 156}, {231, 208, 1}} ,{{56, 156}, {146, 208, 1}} ,{{58, 156}, {148, 208, 1}} ,{{57, 156}, {147, 208, 1}} ,{{59, 156}, {149, 208, 1}} ,{{140, 156}, {230, 208, 1}} ,{{44, 156}, {134, 208, 1}} ,{{38, 156}, {128, 208, 1}} ,{{213, 155}, {47, 208, 1}} ,{{10, 156}, {100, 208, 1}} ,{{251, 155}, {85, 208, 1}} ,{{92, 156}, {182, 208, 1}} ,{{33, 156}, {123, 208, 1}} ,{{14, 156}, {104, 208, 1}} ,{{26, 156}, {116, 208, 1}} ,{{6, 156}, {96, 208, 1}} ,{{180, 155}, {14, 208, 1}} ,{{86, 156}, {176, 208, 1}} ,{{85, 156}, {175, 208, 1}} ,{{84, 156}, {174, 208, 1}} ,{{107, 156}, {197, 208, 1}} ,{{218, 155}, {52, 208, 1}} ,{{95, 156}, {185, 208, 1}} ,{{99, 156}, {189, 208, 1}} ,{{101, 156}, {191, 208, 1}} ,{{97, 156}, {187, 208, 1}} ,{{104, 156}, {194, 208, 1}} ,{{103, 156}, {193, 208, 1}} ,{{96, 156}, {186, 208, 1}} ,{{102, 156}, {192, 208, 1}} ,{{114, 156}, {204, 208, 1}} ,{{113, 156}, {203, 208, 1}} ,{{105, 156}, {195, 208, 1}} ,{{106, 156}, {196, 208, 1}} ,{{98, 156}, {188, 208, 1}} ,{{109, 156}, {199, 208, 1}} ,{{108, 156}, {198, 208, 1}} ,{{100, 156}, {190, 208, 1}} ,{{126, 156}, {216, 208, 1}} ,{{127, 156}, {217, 208, 1}} ,{{188, 155}, {22, 208, 1}} ,{{53, 156}, {143, 208, 1}} ,{{155, 156}, {245, 208, 1}} ,{{54, 156}, {144, 208, 1}} ,{{55, 156}, {145, 208, 1}} ,{{24, 156}, {114, 208, 1}} ,{{90, 156}, {180, 208, 1}} ,{{91, 156}, {181, 208, 1}} ,{{235, 155}, {69, 208, 1}} ,{{229, 155}, {63, 208, 1}} ,{{62, 156}, {152, 208, 1}} ,{{93, 156}, {183, 208, 1}} ,{{219, 155}, {53, 208, 1}} ,{{94, 156}, {184, 208, 1}} ,{{82, 156}, {172, 208, 1}} ,{{192, 155}, {26, 208, 1}} ,{{236, 155}, {70, 208, 1}} ,{{32, 156}, {122, 208, 1}} ,{{221, 155}, {55, 208, 1}} ,{{173, 155}, {7, 208, 1}} ,{{182, 155}, {16, 208, 1}} ,{{194, 155}, {28, 208, 1}} ,{{244, 155}, {78, 208, 1}} ,{{152, 156}, {242, 208, 1}} ,{{150, 156}, {240, 208, 1}} ,{{193, 155}, {27, 208, 1}} ,{{245, 155}, {79, 208, 1}} ,{{153, 156}, {243, 208, 1}} ,{{151, 156}, {241, 208, 1}} ,{{202, 155}, {36, 208, 1}} ,{{37, 156}, {127, 208, 1}} ,{{154, 156}, {244, 208, 1}} ,{{224, 155}, {58, 208, 1}} ,{{232, 155}, {66, 208, 1}} ,{{47, 156}, {137, 208, 1}} ,{{240, 155}, {74, 208, 1}} ,{{216, 155}, {50, 208, 1}} ,{{40, 156}, {130, 208, 1}} ,{{39, 156}, {129, 208, 1}} ,{{41, 156}, {131, 208, 1}} ,{{242, 155}, {76, 208, 1}} ,{{250, 155}, {84, 208, 1}} ,{{178, 155}, {12, 208, 1}} ,{{7, 156}, {97, 208, 1}} ,{{49, 156}, {139, 208, 1}} ,{{48, 156}, {138, 208, 1}} ,{{52, 156}, {142, 208, 1}} ,{{51, 156}, {141, 208, 1}} ,{{50, 156}, {140, 208, 1}} ,{{212, 155}, {46, 208, 1}} ,{{3, 156}, {93, 208, 1}} ,{{75, 156}, {165, 208, 1}} ,{{73, 156}, {163, 208, 1}} ,{{74, 156}, {164, 208, 1}} ,{{80, 156}, {170, 208, 1}} ,{{81, 156}, {171, 208, 1}} ,{{89, 156}, {179, 208, 1}} ,{{72, 156}, {162, 208, 1}} ,{{88, 156}, {178, 208, 1}} ,{{78, 156}, {168, 208, 1}} ,{{79, 156}, {169, 208, 1}} ,{{77, 156}, {167, 208, 1}} ,{{76, 156}, {166, 208, 1}} ,{{87, 156}, {177, 208, 1}} ,{{253, 155}, {87, 208, 1}} ,{{230, 155}, {64, 208, 1}} ,{{187, 155}, {21, 208, 1}} ,{{237, 155}, {71, 208, 1}} ,{{1, 156}, {91, 208, 1}} ,{{198, 155}, {32, 208, 1}} ,{{170, 155}, {4, 208, 1}} ,{{169, 155}, {3, 208, 1}} ,{{238, 155}, {72, 208, 1}} ,{{210, 155}, {44, 208, 1}} ,{{27, 156}, {117, 208, 1}} ,{{227, 155}, {61, 208, 1}} ,{{5, 156}, {95, 208, 1}} ,{{175, 155}, {9, 208, 1}} ,{{228, 155}, {62, 208, 1}} ,{{4, 156}, {94, 208, 1}} ,{{196, 155}, {30, 208, 1}} ,{{222, 155}, {56, 208, 1}} ,{{243, 155}, {77, 208, 1}} ,{{168, 155}, {2, 208, 1}} ,{{231, 155}, {65, 208, 1}} ,{{239, 155}, {73, 208, 1}} ,{{241, 155}, {75, 208, 1}} ,{{204, 155}, {38, 208, 1}} ,{{255, 155}, {89, 208, 1}} ,{{18, 156}, {108, 208, 1}} ,{{223, 155}, {57, 208, 1}} ,{{0, 156}, {90, 208, 1}} ,{{21, 156}, {111, 208, 1}} ,{{23, 156}, {113, 208, 1}} ,{{166, 155}, {0, 208, 1}} ,{{189, 155}, {23, 208, 1}} ,{{226, 155}, {60, 208, 1}} ,{{203, 155}, {37, 208, 1}} ,{{195, 155}, {29, 208, 1}} ,{{207, 155}, {41, 208, 1}} ,{{15, 156}, {105, 208, 1}} ,{{136, 156}, {226, 208, 1}} ,{{137, 156}, {227, 208, 1}} ,{{139, 156}, {229, 208, 1}} ,{{138, 156}, {228, 208, 1}} ,{{132, 156}, {222, 208, 1}} ,{{133, 156}, {223, 208, 1}} ,{{135, 156}, {225, 208, 1}} ,{{134, 156}, {224, 208, 1}} ,{{36, 156}, {126, 208, 1}} ,{{197, 155}, {31, 208, 1}} ,{{142, 156}, {232, 208, 1}} ,{{234, 155}, {68, 208, 1}} ,{{208, 155}, {42, 208, 1}} ,{{209, 155}, {43, 208, 1}} ,{{11, 156}, {101, 208, 1}} ,{{185, 155}, {19, 208, 1}} ,{{12, 156}, {102, 208, 1}} ,{{174, 155}, {8, 208, 1}} ,{{181, 155}, {15, 208, 1}} ,{{215, 155}, {49, 208, 1}} ,{{46, 156}, {136, 208, 1}} ,{{211, 155}, {45, 208, 1}} ,{{28, 156}, {118, 208, 1}} ,{{29, 156}, {119, 208, 1}} ,{{30, 156}, {120, 208, 1}} ,{{31, 156}, {121, 208, 1}} ,{{186, 155}, {20, 208, 1}} ,{{205, 155}, {39, 208, 1}} ,{{214, 155}, {48, 208, 1}} ,{{60, 156}, {150, 208, 1}} ,{{45, 156}, {135, 208, 1}} ,{{19, 156}, {109, 208, 1}} ,{{233, 155}, {67, 208, 1}} ,{{220, 155}, {54, 208, 1}} ,{{9, 156}, {99, 208, 1}} ,{{20, 156}, {110, 208, 1}} ,{{17, 156}, {107, 208, 1}} ,{{22, 156}, {112, 208, 1}} ,{{199, 155}, {33, 208, 1}} ,{{172, 155}, {6, 208, 1}} ,{{171, 155}, {5, 208, 1}} ,{{254, 155}, {88, 208, 1}} ,{{191, 155}, {25, 208, 1}} ,{{16, 156}, {106, 208, 1}} ,{{35, 156}, {125, 208, 1}} ,{{34, 156}, {124, 208, 1}} ,{{122, 156}, {212, 208, 1}} ,{{124, 156}, {214, 208, 1}} ,{{123, 156}, {213, 208, 1}} ,{{125, 156}, {215, 208, 1}} ,{{115, 156}, {205, 208, 1}} ,{{176, 155}, {10, 208, 1}} ,{{177, 155}, {11, 208, 1}} ,{{249, 155}, {83, 208, 1}} ,{{246, 155}, {80, 208, 1}} ,{{29, 65}, {6, 33, 0}} ,{{240, 69}, {36, 38, 0}} ,{{50, 54}, {10, 20, 0}} ,{{51, 54}, {11, 20, 0}} ,{{42, 54}, {2, 20, 0}} ,{{119, 58}, {178, 24, 0}} ,{{68, 54}, {28, 20, 0}} ,{{215, 55}, {175, 21, 0}} ,{{86, 54}, {46, 20, 0}} ,{{230, 54}, {190, 20, 0}} ,{{46, 55}, {6, 21, 0}} ,{{118, 58}, {177, 24, 0}} ,{{184, 58}, {243, 24, 0}} ,{{185, 58}, {244, 24, 0}} ,{{103, 55}, {63, 21, 0}} ,{{219, 55}, {179, 21, 0}} ,{{216, 55}, {176, 21, 0}} ,{{217, 55}, {177, 21, 0}} ,{{231, 55}, {191, 21, 0}} ,{{228, 55}, {188, 21, 0}} ,{{229, 55}, {189, 21, 0}} ,{{230, 55}, {190, 21, 0}} ,{{227, 55}, {187, 21, 0}} ,{{224, 55}, {184, 21, 0}} ,{{225, 55}, {185, 21, 0}} ,{{226, 55}, {186, 21, 0}} ,{{218, 55}, {178, 21, 0}} ,{{48, 55}, {8, 21, 0}} ,{{167, 56}, {127, 22, 0}} ,{{223, 55}, {183, 21, 0}} ,{{220, 55}, {180, 21, 0}} ,{{221, 55}, {181, 21, 0}} ,{{222, 55}, {182, 21, 0}} ,{{201, 54}, {161, 20, 0}} ,{{184, 54}, {144, 20, 0}} ,{{185, 54}, {145, 20, 0}} ,{{178, 54}, {138, 20, 0}} ,{{142, 56}, {102, 22, 0}} ,{{139, 56}, {99, 22, 0}} ,{{140, 56}, {100, 22, 0}} ,{{141, 56}, {101, 22, 0}} ,{{138, 56}, {98, 22, 0}} ,{{137, 56}, {97, 22, 0}} ,{{123, 54}, {83, 20, 0}} ,{{179, 58}, {238, 24, 0}} ,{{186, 58}, {245, 24, 0}} ,{{124, 54}, {84, 20, 0}} ,{{85, 56}, {45, 22, 0}} ,{{82, 56}, {42, 22, 0}} ,{{83, 56}, {43, 22, 0}} ,{{84, 56}, {44, 22, 0}} ,{{81, 56}, {41, 22, 0}} ,{{80, 56}, {40, 22, 0}} ,{{117, 56}, {77, 22, 0}} ,{{114, 56}, {74, 22, 0}} ,{{115, 56}, {75, 22, 0}} ,{{116, 56}, {76, 22, 0}} ,{{113, 56}, {73, 22, 0}} ,{{112, 56}, {72, 22, 0}} ,{{48, 54}, {8, 20, 0}} ,{{28, 56}, {244, 21, 0}} ,{{180, 58}, {239, 24, 0}} ,{{25, 56}, {241, 21, 0}} ,{{26, 56}, {242, 21, 0}} ,{{241, 55}, {201, 21, 0}} ,{{238, 55}, {198, 21, 0}} ,{{239, 55}, {199, 21, 0}} ,{{240, 55}, {200, 21, 0}} ,{{237, 55}, {197, 21, 0}} ,{{236, 55}, {196, 21, 0}} ,{{27, 56}, {243, 21, 0}} ,{{24, 56}, {240, 21, 0}} ,{{23, 56}, {239, 21, 0}} ,{{181, 58}, {240, 24, 0}} ,{{178, 58}, {237, 24, 0}} ,{{115, 54}, {75, 20, 0}} ,{{94, 54}, {54, 20, 0}} ,{{95, 54}, {55, 20, 0}} ,{{3, 56}, {219, 21, 0}} ,{{0, 56}, {216, 21, 0}} ,{{1, 56}, {217, 21, 0}} ,{{2, 56}, {218, 21, 0}} ,{{255, 55}, {215, 21, 0}} ,{{254, 55}, {214, 21, 0}} ,{{49, 54}, {9, 20, 0}} ,{{111, 56}, {71, 22, 0}} ,{{67, 56}, {27, 22, 0}} ,{{63, 56}, {23, 22, 0}} ,{{64, 56}, {24, 22, 0}} ,{{65, 56}, {25, 22, 0}} ,{{73, 56}, {33, 22, 0}} ,{{70, 56}, {30, 22, 0}} ,{{71, 56}, {31, 22, 0}} ,{{72, 56}, {32, 22, 0}} ,{{69, 56}, {29, 22, 0}} ,{{68, 56}, {28, 22, 0}} ,{{62, 56}, {22, 22, 0}} ,{{60, 56}, {20, 22, 0}} ,{{183, 58}, {242, 24, 0}} ,{{34, 56}, {250, 21, 0}} ,{{31, 56}, {247, 21, 0}} ,{{32, 56}, {248, 21, 0}} ,{{33, 56}, {249, 21, 0}} ,{{30, 56}, {246, 21, 0}} ,{{29, 56}, {245, 21, 0}} ,{{41, 56}, {1, 22, 0}} ,{{40, 56}, {0, 22, 0}} ,{{37, 56}, {253, 21, 0}} ,{{38, 56}, {254, 21, 0}} ,{{39, 56}, {255, 21, 0}} ,{{36, 56}, {252, 21, 0}} ,{{35, 56}, {251, 21, 0}} ,{{79, 56}, {39, 22, 0}} ,{{76, 56}, {36, 22, 0}} ,{{77, 56}, {37, 22, 0}} ,{{91, 56}, {51, 22, 0}} ,{{88, 56}, {48, 22, 0}} ,{{89, 56}, {49, 22, 0}} ,{{90, 56}, {50, 22, 0}} ,{{87, 56}, {47, 22, 0}} ,{{86, 56}, {46, 22, 0}} ,{{78, 56}, {38, 22, 0}} ,{{75, 56}, {35, 22, 0}} ,{{74, 56}, {34, 22, 0}} ,{{53, 56}, {13, 22, 0}} ,{{50, 56}, {10, 22, 0}} ,{{51, 56}, {11, 22, 0}} ,{{52, 56}, {12, 22, 0}} ,{{49, 56}, {9, 22, 0}} ,{{48, 56}, {8, 22, 0}} ,{{47, 56}, {7, 22, 0}} ,{{44, 56}, {4, 22, 0}} ,{{45, 56}, {5, 22, 0}} ,{{249, 54}, {209, 20, 0}} ,{{46, 56}, {6, 22, 0}} ,{{43, 56}, {3, 22, 0}} ,{{42, 56}, {2, 22, 0}} ,{{22, 56}, {238, 21, 0}} ,{{21, 56}, {237, 21, 0}} ,{{18, 56}, {234, 21, 0}} ,{{19, 56}, {235, 21, 0}} ,{{20, 56}, {236, 21, 0}} ,{{17, 56}, {233, 21, 0}} ,{{16, 56}, {232, 21, 0}} ,{{247, 55}, {207, 21, 0}} ,{{244, 55}, {204, 21, 0}} ,{{245, 55}, {205, 21, 0}} ,{{246, 55}, {206, 21, 0}} ,{{243, 55}, {203, 21, 0}} ,{{242, 55}, {202, 21, 0}} ,{{123, 56}, {83, 22, 0}} ,{{120, 56}, {80, 22, 0}} ,{{121, 56}, {81, 22, 0}} ,{{130, 56}, {90, 22, 0}} ,{{129, 56}, {89, 22, 0}} ,{{126, 56}, {86, 22, 0}} ,{{127, 56}, {87, 22, 0}} ,{{128, 56}, {88, 22, 0}} ,{{125, 56}, {85, 22, 0}} ,{{124, 56}, {84, 22, 0}} ,{{122, 56}, {82, 22, 0}} ,{{119, 56}, {79, 22, 0}} ,{{118, 56}, {78, 22, 0}} ,{{9, 56}, {225, 21, 0}} ,{{6, 56}, {222, 21, 0}} ,{{7, 56}, {223, 21, 0}} ,{{8, 56}, {224, 21, 0}} ,{{5, 56}, {221, 21, 0}} ,{{4, 56}, {220, 21, 0}} ,{{103, 56}, {63, 22, 0}} ,{{100, 56}, {60, 22, 0}} ,{{101, 56}, {61, 22, 0}} ,{{97, 56}, {57, 22, 0}} ,{{94, 56}, {54, 22, 0}} ,{{95, 56}, {55, 22, 0}} ,{{96, 56}, {56, 22, 0}} ,{{93, 56}, {53, 22, 0}} ,{{92, 56}, {52, 22, 0}} ,{{102, 56}, {62, 22, 0}} ,{{99, 56}, {59, 22, 0}} ,{{98, 56}, {58, 22, 0}} ,{{136, 56}, {96, 22, 0}} ,{{133, 56}, {93, 22, 0}} ,{{134, 56}, {94, 22, 0}} ,{{135, 56}, {95, 22, 0}} ,{{132, 56}, {92, 22, 0}} ,{{131, 56}, {91, 22, 0}} ,{{15, 56}, {231, 21, 0}} ,{{12, 56}, {228, 21, 0}} ,{{13, 56}, {229, 21, 0}} ,{{14, 56}, {230, 21, 0}} ,{{11, 56}, {227, 21, 0}} ,{{148, 56}, {108, 22, 0}} ,{{145, 56}, {105, 22, 0}} ,{{146, 56}, {106, 22, 0}} ,{{147, 56}, {107, 22, 0}} ,{{144, 56}, {104, 22, 0}} ,{{143, 56}, {103, 22, 0}} ,{{10, 56}, {226, 21, 0}} ,{{253, 55}, {213, 21, 0}} ,{{250, 55}, {210, 21, 0}} ,{{251, 55}, {211, 21, 0}} ,{{252, 55}, {212, 21, 0}} ,{{249, 55}, {209, 21, 0}} ,{{248, 55}, {208, 21, 0}} ,{{59, 56}, {19, 22, 0}} ,{{56, 56}, {16, 22, 0}} ,{{57, 56}, {17, 22, 0}} ,{{58, 56}, {18, 22, 0}} ,{{55, 56}, {15, 22, 0}} ,{{54, 56}, {14, 22, 0}} ,{{110, 56}, {70, 22, 0}} ,{{109, 56}, {69, 22, 0}} ,{{106, 56}, {66, 22, 0}} ,{{107, 56}, {67, 22, 0}} ,{{108, 56}, {68, 22, 0}} ,{{105, 56}, {65, 22, 0}} ,{{104, 56}, {64, 22, 0}} ,{{177, 54}, {137, 20, 0}} ,{{149, 56}, {109, 22, 0}} ,{{179, 54}, {139, 20, 0}} ,{{180, 54}, {140, 20, 0}} ,{{181, 54}, {141, 20, 0}} ,{{182, 54}, {142, 20, 0}} ,{{196, 54}, {156, 20, 0}} ,{{198, 54}, {158, 20, 0}} ,{{186, 54}, {146, 20, 0}} ,{{188, 54}, {148, 20, 0}} ,{{190, 54}, {150, 20, 0}} ,{{192, 54}, {152, 20, 0}} ,{{194, 54}, {154, 20, 0}} ,{{41, 54}, {1, 20, 0}} ,{{161, 58}, {220, 24, 0}} ,{{83, 54}, {43, 20, 0}} ,{{133, 55}, {93, 21, 0}} ,{{129, 55}, {89, 21, 0}} ,{{130, 55}, {90, 21, 0}} ,{{124, 55}, {84, 21, 0}} ,{{123, 55}, {83, 21, 0}} ,{{125, 55}, {85, 21, 0}} ,{{126, 55}, {86, 21, 0}} ,{{71, 54}, {31, 20, 0}} ,{{73, 54}, {33, 20, 0}} ,{{77, 54}, {37, 20, 0}} ,{{78, 54}, {38, 20, 0}} ,{{82, 54}, {42, 20, 0}} ,{{72, 54}, {32, 20, 0}} ,{{79, 54}, {39, 20, 0}} ,{{81, 54}, {41, 20, 0}} ,{{164, 58}, {223, 24, 0}} ,{{75, 54}, {35, 20, 0}} ,{{76, 54}, {36, 20, 0}} ,{{80, 54}, {40, 20, 0}} ,{{163, 58}, {222, 24, 0}} ,{{74, 54}, {34, 20, 0}} ,{{127, 55}, {87, 21, 0}} ,{{128, 55}, {88, 21, 0}} ,{{150, 56}, {110, 22, 0}} ,{{131, 55}, {91, 21, 0}} ,{{70, 54}, {30, 20, 0}} ,{{165, 55}, {125, 21, 0}} ,{{40, 54}, {0, 20, 0}} ,{{43, 54}, {3, 20, 0}} ,{{44, 54}, {4, 20, 0}} ,{{84, 54}, {44, 20, 0}} ,{{171, 54}, {131, 20, 0}} ,{{154, 54}, {114, 20, 0}} ,{{155, 54}, {115, 20, 0}} ,{{148, 54}, {108, 20, 0}} ,{{125, 58}, {184, 24, 0}} ,{{147, 54}, {107, 20, 0}} ,{{149, 54}, {109, 20, 0}} ,{{150, 54}, {110, 20, 0}} ,{{151, 54}, {111, 20, 0}} ,{{152, 54}, {112, 20, 0}} ,{{172, 54}, {132, 20, 0}} ,{{166, 54}, {126, 20, 0}} ,{{168, 54}, {128, 20, 0}} ,{{126, 58}, {185, 24, 0}} ,{{156, 54}, {116, 20, 0}} ,{{158, 54}, {118, 20, 0}} ,{{160, 54}, {120, 20, 0}} ,{{162, 54}, {122, 20, 0}} ,{{164, 54}, {124, 20, 0}} ,{{18, 55}, {234, 20, 0}} ,{{2, 55}, {218, 20, 0}} ,{{3, 55}, {219, 20, 0}} ,{{252, 54}, {212, 20, 0}} ,{{130, 58}, {189, 24, 0}} ,{{251, 54}, {211, 20, 0}} ,{{206, 55}, {166, 21, 0}} ,{{204, 55}, {164, 21, 0}} ,{{205, 55}, {165, 21, 0}} ,{{200, 55}, {160, 21, 0}} ,{{201, 55}, {161, 21, 0}} ,{{202, 55}, {162, 21, 0}} ,{{203, 55}, {163, 21, 0}} ,{{253, 54}, {213, 20, 0}} ,{{254, 54}, {214, 20, 0}} ,{{255, 54}, {215, 20, 0}} ,{{0, 55}, {216, 20, 0}} ,{{14, 55}, {230, 20, 0}} ,{{16, 55}, {232, 20, 0}} ,{{4, 55}, {220, 20, 0}} ,{{6, 55}, {222, 20, 0}} ,{{8, 55}, {224, 20, 0}} ,{{10, 55}, {226, 20, 0}} ,{{12, 55}, {228, 20, 0}} ,{{227, 54}, {187, 20, 0}} ,{{210, 54}, {170, 20, 0}} ,{{211, 54}, {171, 20, 0}} ,{{204, 54}, {164, 20, 0}} ,{{127, 58}, {186, 24, 0}} ,{{203, 54}, {163, 20, 0}} ,{{20, 55}, {236, 20, 0}} ,{{122, 55}, {82, 21, 0}} ,{{229, 54}, {189, 20, 0}} ,{{205, 54}, {165, 20, 0}} ,{{206, 54}, {166, 20, 0}} ,{{207, 54}, {167, 20, 0}} ,{{208, 54}, {168, 20, 0}} ,{{49, 55}, {9, 21, 0}} ,{{222, 54}, {182, 20, 0}} ,{{224, 54}, {184, 20, 0}} ,{{212, 54}, {172, 20, 0}} ,{{214, 54}, {174, 20, 0}} ,{{216, 54}, {176, 20, 0}} ,{{218, 54}, {178, 20, 0}} ,{{220, 54}, {180, 20, 0}} ,{{248, 54}, {208, 20, 0}} ,{{135, 55}, {95, 21, 0}} ,{{137, 55}, {97, 21, 0}} ,{{139, 55}, {99, 21, 0}} ,{{239, 54}, {199, 20, 0}} ,{{240, 54}, {200, 20, 0}} ,{{233, 54}, {193, 20, 0}} ,{{200, 54}, {160, 20, 0}} ,{{170, 54}, {130, 20, 0}} ,{{226, 54}, {186, 20, 0}} ,{{247, 54}, {207, 20, 0}} ,{{51, 55}, {11, 21, 0}} ,{{55, 55}, {15, 21, 0}} ,{{50, 55}, {10, 21, 0}} ,{{54, 55}, {14, 21, 0}} ,{{52, 55}, {12, 21, 0}} ,{{53, 55}, {13, 21, 0}} ,{{44, 55}, {4, 21, 0}} ,{{141, 54}, {101, 20, 0}} ,{{67, 54}, {27, 20, 0}} ,{{62, 54}, {22, 20, 0}} ,{{101, 55}, {61, 21, 0}} ,{{129, 58}, {188, 24, 0}} ,{{232, 54}, {192, 20, 0}} ,{{189, 55}, {149, 21, 0}} ,{{187, 55}, {147, 21, 0}} ,{{188, 55}, {148, 21, 0}} ,{{182, 55}, {142, 21, 0}} ,{{152, 56}, {112, 22, 0}} ,{{183, 55}, {143, 21, 0}} ,{{184, 55}, {144, 21, 0}} ,{{185, 55}, {145, 21, 0}} ,{{186, 55}, {146, 21, 0}} ,{{250, 54}, {210, 20, 0}} ,{{234, 54}, {194, 20, 0}} ,{{235, 54}, {195, 20, 0}} ,{{190, 55}, {150, 21, 0}} ,{{157, 56}, {117, 22, 0}} ,{{158, 56}, {118, 22, 0}} ,{{153, 56}, {113, 22, 0}} ,{{154, 56}, {114, 22, 0}} ,{{155, 56}, {115, 22, 0}} ,{{156, 56}, {116, 22, 0}} ,{{236, 54}, {196, 20, 0}} ,{{237, 54}, {197, 20, 0}} ,{{128, 58}, {187, 24, 0}} ,{{163, 55}, {123, 21, 0}} ,{{161, 55}, {121, 21, 0}} ,{{162, 55}, {122, 21, 0}} ,{{156, 55}, {116, 21, 0}} ,{{157, 55}, {117, 21, 0}} ,{{158, 55}, {118, 21, 0}} ,{{159, 55}, {119, 21, 0}} ,{{160, 55}, {120, 21, 0}} ,{{164, 55}, {124, 21, 0}} ,{{243, 54}, {203, 20, 0}} ,{{245, 54}, {205, 20, 0}} ,{{241, 54}, {201, 20, 0}} ,{{139, 58}, {198, 24, 0}} ,{{141, 58}, {200, 24, 0}} ,{{143, 58}, {202, 24, 0}} ,{{145, 58}, {204, 24, 0}} ,{{45, 54}, {5, 20, 0}} ,{{156, 58}, {215, 24, 0}} ,{{155, 58}, {214, 24, 0}} ,{{157, 58}, {216, 24, 0}} ,{{158, 58}, {217, 24, 0}} ,{{140, 58}, {199, 24, 0}} ,{{142, 58}, {201, 24, 0}} ,{{144, 58}, {203, 24, 0}} ,{{146, 58}, {205, 24, 0}} ,{{153, 58}, {212, 24, 0}} ,{{159, 58}, {218, 24, 0}} ,{{160, 58}, {219, 24, 0}} ,{{154, 58}, {213, 24, 0}} ,{{85, 54}, {45, 20, 0}} ,{{46, 54}, {6, 20, 0}} ,{{117, 58}, {176, 24, 0}} ,{{113, 54}, {73, 20, 0}} ,{{96, 54}, {56, 20, 0}} ,{{97, 54}, {57, 20, 0}} ,{{88, 54}, {48, 20, 0}} ,{{122, 58}, {181, 24, 0}} ,{{87, 54}, {47, 20, 0}} ,{{89, 54}, {49, 20, 0}} ,{{90, 54}, {50, 20, 0}} ,{{91, 54}, {51, 20, 0}} ,{{92, 54}, {52, 20, 0}} ,{{121, 58}, {180, 24, 0}} ,{{108, 54}, {68, 20, 0}} ,{{110, 54}, {70, 20, 0}} ,{{98, 54}, {58, 20, 0}} ,{{100, 54}, {60, 20, 0}} ,{{102, 54}, {62, 20, 0}} ,{{104, 54}, {64, 20, 0}} ,{{106, 54}, {66, 20, 0}} ,{{123, 58}, {182, 24, 0}} ,{{173, 55}, {133, 21, 0}} ,{{171, 55}, {131, 21, 0}} ,{{172, 55}, {132, 21, 0}} ,{{166, 55}, {126, 21, 0}} ,{{151, 56}, {111, 22, 0}} ,{{167, 55}, {127, 21, 0}} ,{{168, 55}, {128, 21, 0}} ,{{169, 55}, {129, 21, 0}} ,{{170, 55}, {130, 21, 0}} ,{{120, 55}, {80, 21, 0}} ,{{107, 55}, {67, 21, 0}} ,{{165, 58}, {224, 24, 0}} ,{{115, 55}, {75, 21, 0}} ,{{116, 55}, {76, 21, 0}} ,{{109, 55}, {69, 21, 0}} ,{{138, 58}, {197, 24, 0}} ,{{106, 55}, {66, 21, 0}} ,{{110, 55}, {70, 21, 0}} ,{{111, 55}, {71, 21, 0}} ,{{112, 55}, {72, 21, 0}} ,{{113, 55}, {73, 21, 0}} ,{{152, 58}, {211, 24, 0}} ,{{118, 55}, {78, 21, 0}} ,{{147, 58}, {206, 24, 0}} ,{{148, 58}, {207, 24, 0}} ,{{149, 58}, {208, 24, 0}} ,{{150, 58}, {209, 24, 0}} ,{{151, 58}, {210, 24, 0}} ,{{45, 55}, {5, 21, 0}} ,{{28, 55}, {244, 20, 0}} ,{{29, 55}, {245, 20, 0}} ,{{22, 55}, {238, 20, 0}} ,{{132, 58}, {191, 24, 0}} ,{{235, 55}, {195, 21, 0}} ,{{232, 55}, {192, 21, 0}} ,{{233, 55}, {193, 21, 0}} ,{{234, 55}, {194, 21, 0}} ,{{177, 58}, {236, 24, 0}} ,{{66, 56}, {26, 22, 0}} ,{{61, 56}, {21, 22, 0}} ,{{182, 58}, {241, 24, 0}} ,{{231, 54}, {191, 20, 0}} ,{{194, 55}, {154, 21, 0}} ,{{191, 55}, {151, 21, 0}} ,{{192, 55}, {152, 21, 0}} ,{{193, 55}, {153, 21, 0}} ,{{176, 58}, {235, 24, 0}} ,{{175, 58}, {234, 24, 0}} ,{{202, 54}, {162, 20, 0}} ,{{105, 55}, {65, 21, 0}} ,{{21, 55}, {237, 20, 0}} ,{{77, 55}, {37, 21, 0}} ,{{61, 55}, {21, 21, 0}} ,{{62, 55}, {22, 21, 0}} ,{{134, 58}, {193, 24, 0}} ,{{56, 55}, {16, 21, 0}} ,{{57, 55}, {17, 21, 0}} ,{{58, 55}, {18, 21, 0}} ,{{59, 55}, {19, 21, 0}} ,{{60, 55}, {20, 21, 0}} ,{{133, 58}, {192, 24, 0}} ,{{73, 55}, {33, 21, 0}} ,{{75, 55}, {35, 21, 0}} ,{{63, 55}, {23, 21, 0}} ,{{65, 55}, {25, 21, 0}} ,{{67, 55}, {27, 21, 0}} ,{{69, 55}, {29, 21, 0}} ,{{71, 55}, {31, 21, 0}} ,{{135, 58}, {194, 24, 0}} ,{{23, 55}, {239, 20, 0}} ,{{24, 55}, {240, 20, 0}} ,{{25, 55}, {241, 20, 0}} ,{{26, 55}, {242, 20, 0}} ,{{176, 54}, {136, 20, 0}} ,{{173, 54}, {133, 20, 0}} ,{{174, 54}, {134, 20, 0}} ,{{175, 54}, {135, 20, 0}} ,{{131, 58}, {190, 24, 0}} ,{{47, 55}, {7, 21, 0}} ,{{40, 55}, {0, 21, 0}} ,{{42, 55}, {2, 21, 0}} ,{{30, 55}, {246, 20, 0}} ,{{32, 55}, {248, 20, 0}} ,{{34, 55}, {250, 20, 0}} ,{{36, 55}, {252, 20, 0}} ,{{38, 55}, {254, 20, 0}} ,{{142, 54}, {102, 20, 0}} ,{{125, 54}, {85, 20, 0}} ,{{126, 54}, {86, 20, 0}} ,{{117, 54}, {77, 20, 0}} ,{{124, 58}, {183, 24, 0}} ,{{116, 54}, {76, 20, 0}} ,{{146, 55}, {106, 21, 0}} ,{{214, 55}, {174, 21, 0}} ,{{212, 55}, {172, 21, 0}} ,{{213, 55}, {173, 21, 0}} ,{{207, 55}, {167, 21, 0}} ,{{208, 55}, {168, 21, 0}} ,{{209, 55}, {169, 21, 0}} ,{{210, 55}, {170, 21, 0}} ,{{211, 55}, {171, 21, 0}} ,{{142, 55}, {102, 21, 0}} ,{{143, 55}, {103, 21, 0}} ,{{134, 55}, {94, 21, 0}} ,{{136, 55}, {96, 21, 0}} ,{{138, 55}, {98, 21, 0}} ,{{140, 55}, {100, 21, 0}} ,{{141, 55}, {101, 21, 0}} ,{{169, 58}, {228, 24, 0}} ,{{144, 55}, {104, 21, 0}} ,{{168, 58}, {227, 24, 0}} ,{{118, 54}, {78, 20, 0}} ,{{119, 54}, {79, 20, 0}} ,{{177, 55}, {137, 21, 0}} ,{{174, 55}, {134, 21, 0}} ,{{175, 55}, {135, 21, 0}} ,{{176, 55}, {136, 21, 0}} ,{{174, 58}, {233, 24, 0}} ,{{173, 58}, {232, 24, 0}} ,{{120, 54}, {80, 20, 0}} ,{{121, 54}, {81, 20, 0}} ,{{146, 54}, {106, 20, 0}} ,{{143, 54}, {103, 20, 0}} ,{{151, 55}, {111, 21, 0}} ,{{150, 55}, {110, 21, 0}} ,{{172, 58}, {231, 24, 0}} ,{{147, 55}, {107, 21, 0}} ,{{148, 55}, {108, 21, 0}} ,{{149, 55}, {109, 21, 0}} ,{{171, 58}, {230, 24, 0}} ,{{170, 58}, {229, 24, 0}} ,{{144, 54}, {104, 20, 0}} ,{{145, 54}, {105, 20, 0}} ,{{137, 54}, {97, 20, 0}} ,{{139, 54}, {99, 20, 0}} ,{{127, 54}, {87, 20, 0}} ,{{129, 54}, {89, 20, 0}} ,{{131, 54}, {91, 20, 0}} ,{{133, 54}, {93, 20, 0}} ,{{135, 54}, {95, 20, 0}} ,{{155, 55}, {115, 21, 0}} ,{{152, 55}, {112, 21, 0}} ,{{153, 55}, {113, 21, 0}} ,{{154, 55}, {114, 21, 0}} ,{{63, 54}, {23, 20, 0}} ,{{65, 54}, {25, 20, 0}} ,{{120, 58}, {179, 24, 0}} ,{{52, 54}, {12, 20, 0}} ,{{197, 54}, {157, 20, 0}} ,{{199, 54}, {159, 20, 0}} ,{{187, 54}, {147, 20, 0}} ,{{189, 54}, {149, 20, 0}} ,{{191, 54}, {151, 20, 0}} ,{{193, 54}, {153, 20, 0}} ,{{195, 54}, {155, 20, 0}} ,{{132, 55}, {92, 21, 0}} ,{{167, 54}, {127, 20, 0}} ,{{169, 54}, {129, 20, 0}} ,{{157, 54}, {117, 20, 0}} ,{{159, 54}, {119, 20, 0}} ,{{161, 54}, {121, 20, 0}} ,{{163, 54}, {123, 20, 0}} ,{{165, 54}, {125, 20, 0}} ,{{19, 55}, {235, 20, 0}} ,{{117, 55}, {77, 21, 0}} ,{{167, 58}, {226, 24, 0}} ,{{108, 55}, {68, 21, 0}} ,{{114, 55}, {74, 21, 0}} ,{{166, 58}, {225, 24, 0}} ,{{15, 55}, {231, 20, 0}} ,{{17, 55}, {233, 20, 0}} ,{{5, 55}, {221, 20, 0}} ,{{7, 55}, {223, 20, 0}} ,{{9, 55}, {225, 20, 0}} ,{{11, 55}, {227, 20, 0}} ,{{13, 55}, {229, 20, 0}} ,{{228, 54}, {188, 20, 0}} ,{{223, 54}, {183, 20, 0}} ,{{225, 54}, {185, 20, 0}} ,{{213, 54}, {173, 20, 0}} ,{{215, 54}, {175, 20, 0}} ,{{217, 54}, {177, 20, 0}} ,{{219, 54}, {179, 20, 0}} ,{{221, 54}, {181, 20, 0}} ,{{244, 54}, {204, 20, 0}} ,{{246, 54}, {206, 20, 0}} ,{{242, 54}, {202, 20, 0}} ,{{114, 54}, {74, 20, 0}} ,{{109, 54}, {69, 20, 0}} ,{{111, 54}, {71, 20, 0}} ,{{99, 54}, {59, 20, 0}} ,{{101, 54}, {61, 20, 0}} ,{{103, 54}, {63, 20, 0}} ,{{105, 54}, {65, 20, 0}} ,{{107, 54}, {67, 20, 0}} ,{{121, 55}, {81, 21, 0}} ,{{181, 55}, {141, 21, 0}} ,{{178, 55}, {138, 21, 0}} ,{{179, 55}, {139, 21, 0}} ,{{180, 55}, {140, 21, 0}} ,{{119, 55}, {79, 21, 0}} ,{{74, 55}, {34, 21, 0}} ,{{76, 55}, {36, 21, 0}} ,{{64, 55}, {24, 21, 0}} ,{{66, 55}, {26, 21, 0}} ,{{68, 55}, {28, 21, 0}} ,{{70, 55}, {30, 21, 0}} ,{{72, 55}, {32, 21, 0}} ,{{41, 55}, {1, 21, 0}} ,{{43, 55}, {3, 21, 0}} ,{{31, 55}, {247, 20, 0}} ,{{33, 55}, {249, 20, 0}} ,{{35, 55}, {251, 20, 0}} ,{{37, 55}, {253, 20, 0}} ,{{39, 55}, {255, 20, 0}} ,{{145, 55}, {105, 21, 0}} ,{{138, 54}, {98, 20, 0}} ,{{140, 54}, {100, 20, 0}} ,{{128, 54}, {88, 20, 0}} ,{{130, 54}, {90, 20, 0}} ,{{132, 54}, {92, 20, 0}} ,{{134, 54}, {94, 20, 0}} ,{{136, 54}, {96, 20, 0}} ,{{64, 54}, {24, 20, 0}} ,{{66, 54}, {26, 20, 0}} ,{{53, 54}, {13, 20, 0}} ,{{55, 54}, {15, 20, 0}} ,{{57, 54}, {17, 20, 0}} ,{{59, 54}, {19, 20, 0}} ,{{61, 54}, {21, 20, 0}} ,{{104, 55}, {64, 21, 0}} ,{{98, 55}, {58, 21, 0}} ,{{100, 55}, {60, 21, 0}} ,{{88, 55}, {48, 21, 0}} ,{{90, 55}, {50, 21, 0}} ,{{92, 55}, {52, 21, 0}} ,{{94, 55}, {54, 21, 0}} ,{{96, 55}, {56, 21, 0}} ,{{162, 58}, {221, 24, 0}} ,{{54, 54}, {14, 20, 0}} ,{{56, 54}, {16, 20, 0}} ,{{58, 54}, {18, 20, 0}} ,{{60, 54}, {20, 20, 0}} ,{{166, 56}, {126, 22, 0}} ,{{199, 55}, {159, 21, 0}} ,{{198, 55}, {158, 21, 0}} ,{{195, 55}, {155, 21, 0}} ,{{196, 55}, {156, 21, 0}} ,{{197, 55}, {157, 21, 0}} ,{{164, 56}, {124, 22, 0}} ,{{165, 56}, {125, 22, 0}} ,{{159, 56}, {119, 22, 0}} ,{{160, 56}, {120, 22, 0}} ,{{161, 56}, {121, 22, 0}} ,{{162, 56}, {122, 22, 0}} ,{{163, 56}, {123, 22, 0}} ,{{102, 55}, {62, 21, 0}} ,{{183, 54}, {143, 20, 0}} ,{{153, 54}, {113, 20, 0}} ,{{1, 55}, {217, 20, 0}} ,{{209, 54}, {169, 20, 0}} ,{{238, 54}, {198, 20, 0}} ,{{47, 54}, {7, 20, 0}} ,{{93, 54}, {53, 20, 0}} ,{{112, 54}, {72, 20, 0}} ,{{27, 55}, {243, 20, 0}} ,{{122, 54}, {82, 20, 0}} ,{{69, 54}, {29, 20, 0}} ,{{84, 55}, {44, 21, 0}} ,{{85, 55}, {45, 21, 0}} ,{{86, 55}, {46, 21, 0}} ,{{79, 55}, {39, 21, 0}} ,{{137, 58}, {196, 24, 0}} ,{{78, 55}, {38, 21, 0}} ,{{80, 55}, {40, 21, 0}} ,{{81, 55}, {41, 21, 0}} ,{{82, 55}, {42, 21, 0}} ,{{83, 55}, {43, 21, 0}} ,{{136, 58}, {195, 24, 0}} ,{{97, 55}, {57, 21, 0}} ,{{99, 55}, {59, 21, 0}} ,{{87, 55}, {47, 21, 0}} ,{{89, 55}, {49, 21, 0}} ,{{91, 55}, {51, 21, 0}} ,{{93, 55}, {53, 21, 0}} ,{{95, 55}, {55, 21, 0}} ,{{132, 165}, {127, 0, 14}} ,{{23, 70}, {75, 38, 0}} ,{{29, 70}, {81, 38, 0}} ,{{136, 64}, {56, 32, 0}} ,{{145, 64}, {65, 32, 0}} ,{{28, 65}, {5, 33, 0}} ,{{42, 144}, {160, 2, 1}} ,{{49, 144}, {167, 2, 1}} ,{{51, 144}, {169, 2, 1}} ,{{59, 144}, {177, 2, 1}} ,{{80, 144}, {198, 2, 1}} ,{{44, 144}, {162, 2, 1}} ,{{54, 144}, {172, 2, 1}} ,{{68, 144}, {186, 2, 1}} ,{{89, 144}, {207, 2, 1}} ,{{74, 144}, {192, 2, 1}} ,{{75, 144}, {193, 2, 1}} ,{{67, 144}, {185, 2, 1}} ,{{79, 144}, {197, 2, 1}} ,{{70, 144}, {188, 2, 1}} ,{{71, 144}, {189, 2, 1}} ,{{45, 144}, {163, 2, 1}} ,{{48, 144}, {166, 2, 1}} ,{{88, 144}, {206, 2, 1}} ,{{52, 144}, {170, 2, 1}} ,{{84, 144}, {202, 2, 1}} ,{{85, 144}, {203, 2, 1}} ,{{86, 144}, {204, 2, 1}} ,{{87, 144}, {205, 2, 1}} ,{{63, 144}, {181, 2, 1}} ,{{72, 144}, {190, 2, 1}} ,{{78, 144}, {196, 2, 1}} ,{{61, 144}, {179, 2, 1}} ,{{53, 144}, {171, 2, 1}} ,{{65, 144}, {183, 2, 1}} ,{{43, 144}, {161, 2, 1}} ,{{50, 144}, {168, 2, 1}} ,{{47, 144}, {165, 2, 1}} ,{{83, 144}, {201, 2, 1}} ,{{58, 144}, {176, 2, 1}} ,{{56, 144}, {174, 2, 1}} ,{{57, 144}, {175, 2, 1}} ,{{66, 144}, {184, 2, 1}} ,{{76, 144}, {194, 2, 1}} ,{{77, 144}, {195, 2, 1}} ,{{55, 144}, {173, 2, 1}} ,{{81, 144}, {199, 2, 1}} ,{{64, 144}, {182, 2, 1}} ,{{60, 144}, {178, 2, 1}} ,{{73, 144}, {191, 2, 1}} ,{{46, 144}, {164, 2, 1}} ,{{82, 144}, {200, 2, 1}} ,{{90, 144}, {208, 2, 1}} ,{{69, 144}, {187, 2, 1}} ,{{62, 144}, {180, 2, 1}} ,{{105, 40}, {199, 2, 0}} ,{{155, 70}, {208, 38, 0}} ,{{177, 70}, {235, 38, 0}} ,{{237, 69}, {33, 38, 0}} ,{{90, 38}, {184, 0, 0}} ,{{242, 64}, {181, 32, 0}} ,{{237, 140}, {78, 254, 0}} ,{{233, 140}, {74, 254, 0}} ,{{27, 65}, {4, 33, 0}} ,{{68, 38}, {162, 0, 0}} ,{{127, 70}, {179, 38, 0}} ,{{158, 70}, {211, 38, 0}} ,{{180, 91}, {77, 170, 0}} ,{{179, 91}, {76, 170, 0}} ,{{170, 91}, {67, 170, 0}} ,{{165, 91}, {53, 170, 0}} ,{{164, 91}, {52, 170, 0}} ,{{166, 91}, {54, 170, 0}} ,{{163, 91}, {51, 170, 0}} ,{{189, 91}, {88, 170, 0}} ,{{186, 91}, {85, 170, 0}} ,{{185, 91}, {84, 170, 0}} ,{{190, 91}, {89, 170, 0}} ,{{182, 91}, {81, 170, 0}} ,{{188, 91}, {87, 170, 0}} ,{{187, 91}, {86, 170, 0}} ,{{184, 91}, {83, 170, 0}} ,{{183, 91}, {82, 170, 0}} ,{{181, 91}, {80, 170, 0}} ,{{112, 91}, {0, 170, 0}} ,{{116, 91}, {4, 170, 0}} ,{{141, 91}, {29, 170, 0}} ,{{145, 91}, {33, 170, 0}} ,{{142, 91}, {30, 170, 0}} ,{{124, 91}, {12, 170, 0}} ,{{125, 91}, {13, 170, 0}} ,{{133, 91}, {21, 170, 0}} ,{{137, 91}, {25, 170, 0}} ,{{134, 91}, {22, 170, 0}} ,{{115, 91}, {3, 170, 0}} ,{{171, 91}, {68, 170, 0}} ,{{168, 91}, {65, 170, 0}} ,{{167, 91}, {64, 170, 0}} ,{{177, 91}, {74, 170, 0}} ,{{173, 91}, {70, 170, 0}} ,{{169, 91}, {66, 170, 0}} ,{{174, 91}, {71, 170, 0}} ,{{176, 91}, {73, 170, 0}} ,{{178, 91}, {75, 170, 0}} ,{{172, 91}, {69, 170, 0}} ,{{175, 91}, {72, 170, 0}} ,{{120, 91}, {8, 170, 0}} ,{{121, 91}, {9, 170, 0}} ,{{152, 91}, {40, 170, 0}} ,{{113, 91}, {1, 170, 0}} ,{{126, 91}, {14, 170, 0}} ,{{127, 91}, {15, 170, 0}} ,{{118, 91}, {6, 170, 0}} ,{{119, 91}, {7, 170, 0}} ,{{148, 91}, {36, 170, 0}} ,{{144, 91}, {32, 170, 0}} ,{{143, 91}, {31, 170, 0}} ,{{136, 91}, {24, 170, 0}} ,{{123, 91}, {11, 170, 0}} ,{{122, 91}, {10, 170, 0}} ,{{129, 91}, {17, 170, 0}} ,{{130, 91}, {18, 170, 0}} ,{{128, 91}, {16, 170, 0}} ,{{135, 91}, {23, 170, 0}} ,{{117, 91}, {5, 170, 0}} ,{{138, 91}, {26, 170, 0}} ,{{140, 91}, {28, 170, 0}} ,{{139, 91}, {27, 170, 0}} ,{{147, 91}, {35, 170, 0}} ,{{151, 91}, {39, 170, 0}} ,{{150, 91}, {38, 170, 0}} ,{{131, 91}, {19, 170, 0}} ,{{132, 91}, {20, 170, 0}} ,{{114, 91}, {2, 170, 0}} ,{{149, 91}, {37, 170, 0}} ,{{146, 91}, {34, 170, 0}} ,{{192, 91}, {93, 170, 0}} ,{{193, 91}, {94, 170, 0}} ,{{191, 91}, {92, 170, 0}} ,{{194, 91}, {95, 170, 0}} ,{{153, 91}, {41, 170, 0}} ,{{160, 91}, {48, 170, 0}} ,{{161, 91}, {49, 170, 0}} ,{{156, 91}, {44, 170, 0}} ,{{154, 91}, {42, 170, 0}} ,{{155, 91}, {43, 170, 0}} ,{{159, 91}, {47, 170, 0}} ,{{158, 91}, {46, 170, 0}} ,{{157, 91}, {45, 170, 0}} ,{{162, 91}, {50, 170, 0}} ,{{144, 64}, {64, 32, 0}} ,{{213, 70}, {19, 39, 0}} ,{{211, 53}, {160, 19, 0}} ,{{6, 54}, {211, 19, 0}} ,{{8, 54}, {213, 19, 0}} ,{{10, 54}, {215, 19, 0}} ,{{15, 54}, {220, 19, 0}} ,{{12, 54}, {217, 19, 0}} ,{{13, 54}, {218, 19, 0}} ,{{14, 54}, {219, 19, 0}} ,{{212, 53}, {161, 19, 0}} ,{{217, 53}, {166, 19, 0}} ,{{219, 53}, {168, 19, 0}} ,{{220, 53}, {169, 19, 0}} ,{{221, 53}, {170, 19, 0}} ,{{222, 53}, {171, 19, 0}} ,{{223, 53}, {172, 19, 0}} ,{{224, 53}, {173, 19, 0}} ,{{225, 53}, {174, 19, 0}} ,{{226, 53}, {175, 19, 0}} ,{{242, 53}, {191, 19, 0}} ,{{227, 53}, {176, 19, 0}} ,{{228, 53}, {177, 19, 0}} ,{{229, 53}, {178, 19, 0}} ,{{213, 53}, {162, 19, 0}} ,{{218, 53}, {167, 19, 0}} ,{{230, 53}, {179, 19, 0}} ,{{231, 53}, {180, 19, 0}} ,{{232, 53}, {181, 19, 0}} ,{{233, 53}, {182, 19, 0}} ,{{234, 53}, {183, 19, 0}} ,{{235, 53}, {184, 19, 0}} ,{{236, 53}, {185, 19, 0}} ,{{237, 53}, {186, 19, 0}} ,{{238, 53}, {187, 19, 0}} ,{{239, 53}, {188, 19, 0}} ,{{240, 53}, {189, 19, 0}} ,{{241, 53}, {190, 19, 0}} ,{{243, 53}, {192, 19, 0}} ,{{244, 53}, {193, 19, 0}} ,{{245, 53}, {194, 19, 0}} ,{{246, 53}, {195, 19, 0}} ,{{247, 53}, {196, 19, 0}} ,{{248, 53}, {197, 19, 0}} ,{{214, 53}, {163, 19, 0}} ,{{249, 53}, {198, 19, 0}} ,{{250, 53}, {199, 19, 0}} ,{{251, 53}, {200, 19, 0}} ,{{252, 53}, {201, 19, 0}} ,{{253, 53}, {202, 19, 0}} ,{{254, 53}, {203, 19, 0}} ,{{0, 54}, {205, 19, 0}} ,{{255, 53}, {204, 19, 0}} ,{{1, 54}, {206, 19, 0}} ,{{2, 54}, {207, 19, 0}} ,{{3, 54}, {208, 19, 0}} ,{{4, 54}, {209, 19, 0}} ,{{5, 54}, {210, 19, 0}} ,{{7, 54}, {212, 19, 0}} ,{{9, 54}, {214, 19, 0}} ,{{11, 54}, {216, 19, 0}} ,{{16, 54}, {221, 19, 0}} ,{{17, 54}, {222, 19, 0}} ,{{18, 54}, {223, 19, 0}} ,{{19, 54}, {224, 19, 0}} ,{{20, 54}, {225, 19, 0}} ,{{21, 54}, {226, 19, 0}} ,{{22, 54}, {227, 19, 0}} ,{{23, 54}, {228, 19, 0}} ,{{24, 54}, {229, 19, 0}} ,{{25, 54}, {230, 19, 0}} ,{{26, 54}, {231, 19, 0}} ,{{27, 54}, {232, 19, 0}} ,{{215, 53}, {164, 19, 0}} ,{{216, 53}, {165, 19, 0}} ,{{28, 54}, {233, 19, 0}} ,{{29, 54}, {234, 19, 0}} ,{{30, 54}, {235, 19, 0}} ,{{31, 54}, {236, 19, 0}} ,{{32, 54}, {237, 19, 0}} ,{{33, 54}, {238, 19, 0}} ,{{34, 54}, {239, 19, 0}} ,{{35, 54}, {240, 19, 0}} ,{{36, 54}, {241, 19, 0}} ,{{37, 54}, {242, 19, 0}} ,{{38, 54}, {243, 19, 0}} ,{{39, 54}, {244, 19, 0}} ,{{131, 70}, {183, 38, 0}} ,{{243, 69}, {39, 38, 0}} ,{{176, 70}, {234, 38, 0}} ,{{109, 73}, {188, 41, 0}} ,{{172, 66}, {155, 34, 0}} ,{{112, 73}, {191, 41, 0}} ,{{195, 162}, {45, 241, 1}} ,{{157, 70}, {210, 38, 0}} ,{{174, 66}, {157, 34, 0}} ,{{51, 68}, {103, 36, 0}} ,{{48, 68}, {100, 36, 0}} ,{{47, 68}, {99, 36, 0}} ,{{52, 68}, {104, 36, 0}} ,{{44, 68}, {96, 36, 0}} ,{{50, 68}, {102, 36, 0}} ,{{49, 68}, {101, 36, 0}} ,{{46, 68}, {98, 36, 0}} ,{{45, 68}, {97, 36, 0}} ,{{182, 68}, {234, 36, 0}} ,{{233, 73}, {56, 42, 0}} ,{{169, 66}, {152, 34, 0}} ,{{170, 66}, {153, 34, 0}} ,{{173, 66}, {156, 34, 0}} ,{{114, 73}, {193, 41, 0}} ,{{154, 80}, {105, 50, 0}} ,{{168, 80}, {119, 50, 0}} ,{{153, 80}, {104, 50, 0}} ,{{167, 80}, {118, 50, 0}} ,{{158, 80}, {109, 50, 0}} ,{{172, 80}, {123, 50, 0}} ,{{152, 80}, {103, 50, 0}} ,{{166, 80}, {117, 50, 0}} ,{{175, 80}, {126, 50, 0}} ,{{155, 80}, {106, 50, 0}} ,{{169, 80}, {120, 50, 0}} ,{{145, 80}, {96, 50, 0}} ,{{159, 80}, {110, 50, 0}} ,{{149, 80}, {100, 50, 0}} ,{{163, 80}, {114, 50, 0}} ,{{146, 80}, {97, 50, 0}} ,{{160, 80}, {111, 50, 0}} ,{{157, 80}, {108, 50, 0}} ,{{171, 80}, {122, 50, 0}} ,{{150, 80}, {101, 50, 0}} ,{{164, 80}, {115, 50, 0}} ,{{148, 80}, {99, 50, 0}} ,{{162, 80}, {113, 50, 0}} ,{{151, 80}, {102, 50, 0}} ,{{165, 80}, {116, 50, 0}} ,{{156, 80}, {107, 50, 0}} ,{{170, 80}, {121, 50, 0}} ,{{147, 80}, {98, 50, 0}} ,{{161, 80}, {112, 50, 0}} ,{{104, 71}, {178, 39, 0}} ,{{154, 67}, {137, 35, 0}} ,{{224, 80}, {175, 50, 0}} ,{{208, 80}, {159, 50, 0}} ,{{214, 80}, {165, 50, 0}} ,{{200, 80}, {151, 50, 0}} ,{{211, 80}, {162, 50, 0}} ,{{212, 80}, {163, 50, 0}} ,{{192, 80}, {143, 50, 0}} ,{{184, 80}, {135, 50, 0}} ,{{222, 80}, {173, 50, 0}} ,{{206, 80}, {157, 50, 0}} ,{{204, 80}, {155, 50, 0}} ,{{199, 80}, {150, 50, 0}} ,{{188, 80}, {139, 50, 0}} ,{{181, 80}, {132, 50, 0}} ,{{180, 80}, {131, 50, 0}} ,{{195, 80}, {146, 50, 0}} ,{{213, 80}, {164, 50, 0}} ,{{209, 80}, {160, 50, 0}} ,{{118, 80}, {69, 50, 0}} ,{{120, 80}, {71, 50, 0}} ,{{201, 80}, {152, 50, 0}} ,{{216, 80}, {167, 50, 0}} ,{{215, 80}, {166, 50, 0}} ,{{203, 80}, {154, 50, 0}} ,{{218, 80}, {169, 50, 0}} ,{{191, 80}, {142, 50, 0}} ,{{187, 80}, {138, 50, 0}} ,{{197, 80}, {148, 50, 0}} ,{{225, 80}, {176, 50, 0}} ,{{185, 80}, {136, 50, 0}} ,{{177, 80}, {128, 50, 0}} ,{{207, 80}, {158, 50, 0}} ,{{117, 80}, {68, 50, 0}} ,{{219, 80}, {170, 50, 0}} ,{{223, 80}, {174, 50, 0}} ,{{210, 80}, {161, 50, 0}} ,{{217, 80}, {168, 50, 0}} ,{{119, 80}, {70, 50, 0}} ,{{202, 80}, {153, 50, 0}} ,{{183, 80}, {134, 50, 0}} ,{{182, 80}, {133, 50, 0}} ,{{196, 80}, {147, 50, 0}} ,{{198, 80}, {149, 50, 0}} ,{{194, 80}, {145, 50, 0}} ,{{220, 80}, {171, 50, 0}} ,{{205, 80}, {156, 50, 0}} ,{{193, 80}, {144, 50, 0}} ,{{221, 80}, {172, 50, 0}} ,{{186, 80}, {137, 50, 0}} ,{{179, 80}, {130, 50, 0}} ,{{178, 80}, {129, 50, 0}} ,{{189, 80}, {140, 50, 0}} ,{{190, 80}, {141, 50, 0}} ,{{193, 162}, {43, 241, 1}} ,{{194, 162}, {44, 241, 1}} ,{{1, 81}, {208, 50, 0}} ,{{4, 81}, {211, 50, 0}} ,{{26, 81}, {233, 50, 0}} ,{{29, 81}, {236, 50, 0}} ,{{27, 81}, {234, 50, 0}} ,{{30, 81}, {237, 50, 0}} ,{{28, 81}, {235, 50, 0}} ,{{2, 81}, {209, 50, 0}} ,{{6, 81}, {213, 50, 0}} ,{{9, 81}, {216, 50, 0}} ,{{7, 81}, {214, 50, 0}} ,{{10, 81}, {217, 50, 0}} ,{{8, 81}, {215, 50, 0}} ,{{31, 81}, {238, 50, 0}} ,{{34, 81}, {241, 50, 0}} ,{{32, 81}, {239, 50, 0}} ,{{35, 81}, {242, 50, 0}} ,{{33, 81}, {240, 50, 0}} ,{{21, 81}, {228, 50, 0}} ,{{24, 81}, {231, 50, 0}} ,{{22, 81}, {229, 50, 0}} ,{{25, 81}, {232, 50, 0}} ,{{23, 81}, {230, 50, 0}} ,{{5, 81}, {212, 50, 0}} ,{{39, 81}, {246, 50, 0}} ,{{42, 81}, {249, 50, 0}} ,{{40, 81}, {247, 50, 0}} ,{{43, 81}, {250, 50, 0}} ,{{41, 81}, {248, 50, 0}} ,{{11, 81}, {218, 50, 0}} ,{{14, 81}, {221, 50, 0}} ,{{12, 81}, {219, 50, 0}} ,{{15, 81}, {222, 50, 0}} ,{{13, 81}, {220, 50, 0}} ,{{16, 81}, {223, 50, 0}} ,{{19, 81}, {226, 50, 0}} ,{{17, 81}, {224, 50, 0}} ,{{20, 81}, {227, 50, 0}} ,{{18, 81}, {225, 50, 0}} ,{{3, 81}, {210, 50, 0}} ,{{44, 81}, {251, 50, 0}} ,{{46, 81}, {253, 50, 0}} ,{{45, 81}, {252, 50, 0}} ,{{47, 81}, {254, 50, 0}} ,{{36, 81}, {243, 50, 0}} ,{{38, 81}, {245, 50, 0}} ,{{37, 81}, {244, 50, 0}} ,{{173, 80}, {124, 50, 0}} ,{{174, 80}, {125, 50, 0}} ,{{130, 68}, {182, 36, 0}} ,{{131, 68}, {183, 36, 0}} ,{{132, 68}, {184, 36, 0}} ,{{133, 68}, {185, 36, 0}} ,{{134, 68}, {186, 36, 0}} ,{{135, 68}, {187, 36, 0}} ,{{136, 68}, {188, 36, 0}} ,{{137, 68}, {189, 36, 0}} ,{{138, 68}, {190, 36, 0}} ,{{139, 68}, {191, 36, 0}} ,{{140, 68}, {192, 36, 0}} ,{{141, 68}, {193, 36, 0}} ,{{142, 68}, {194, 36, 0}} ,{{143, 68}, {195, 36, 0}} ,{{144, 68}, {196, 36, 0}} ,{{145, 68}, {197, 36, 0}} ,{{146, 68}, {198, 36, 0}} ,{{147, 68}, {199, 36, 0}} ,{{148, 68}, {200, 36, 0}} ,{{149, 68}, {201, 36, 0}} ,{{150, 68}, {202, 36, 0}} ,{{151, 68}, {203, 36, 0}} ,{{152, 68}, {204, 36, 0}} ,{{153, 68}, {205, 36, 0}} ,{{154, 68}, {206, 36, 0}} ,{{155, 68}, {207, 36, 0}} ,{{156, 68}, {208, 36, 0}} ,{{157, 68}, {209, 36, 0}} ,{{158, 68}, {210, 36, 0}} ,{{159, 68}, {211, 36, 0}} ,{{160, 68}, {212, 36, 0}} ,{{161, 68}, {213, 36, 0}} ,{{162, 68}, {214, 36, 0}} ,{{163, 68}, {215, 36, 0}} ,{{164, 68}, {216, 36, 0}} ,{{165, 68}, {217, 36, 0}} ,{{166, 68}, {218, 36, 0}} ,{{167, 68}, {219, 36, 0}} ,{{168, 68}, {220, 36, 0}} ,{{169, 68}, {221, 36, 0}} ,{{170, 68}, {222, 36, 0}} ,{{171, 68}, {223, 36, 0}} ,{{172, 68}, {224, 36, 0}} ,{{173, 68}, {225, 36, 0}} ,{{174, 68}, {226, 36, 0}} ,{{175, 68}, {227, 36, 0}} ,{{176, 68}, {228, 36, 0}} ,{{177, 68}, {229, 36, 0}} ,{{178, 68}, {230, 36, 0}} ,{{179, 68}, {231, 36, 0}} ,{{180, 68}, {232, 36, 0}} ,{{181, 68}, {233, 36, 0}} ,{{113, 73}, {192, 41, 0}} ,{{167, 66}, {150, 34, 0}} ,{{231, 73}, {54, 42, 0}} ,{{61, 68}, {113, 36, 0}} ,{{128, 80}, {79, 50, 0}} ,{{54, 68}, {106, 36, 0}} ,{{58, 68}, {110, 36, 0}} ,{{240, 80}, {191, 50, 0}} ,{{125, 80}, {76, 50, 0}} ,{{230, 80}, {181, 50, 0}} ,{{238, 80}, {189, 50, 0}} ,{{235, 80}, {186, 50, 0}} ,{{234, 80}, {185, 50, 0}} ,{{239, 80}, {190, 50, 0}} ,{{231, 80}, {182, 50, 0}} ,{{124, 80}, {75, 50, 0}} ,{{237, 80}, {188, 50, 0}} ,{{236, 80}, {187, 50, 0}} ,{{233, 80}, {184, 50, 0}} ,{{232, 80}, {183, 50, 0}} ,{{57, 68}, {109, 36, 0}} ,{{62, 68}, {114, 36, 0}} ,{{60, 68}, {112, 36, 0}} ,{{127, 80}, {78, 50, 0}} ,{{59, 68}, {111, 36, 0}} ,{{126, 80}, {77, 50, 0}} ,{{53, 68}, {105, 36, 0}} ,{{121, 80}, {72, 50, 0}} ,{{56, 68}, {108, 36, 0}} ,{{139, 80}, {90, 50, 0}} ,{{228, 80}, {179, 50, 0}} ,{{144, 80}, {95, 50, 0}} ,{{143, 80}, {94, 50, 0}} ,{{229, 80}, {180, 50, 0}} ,{{140, 80}, {91, 50, 0}} ,{{123, 80}, {74, 50, 0}} ,{{227, 80}, {178, 50, 0}} ,{{226, 80}, {177, 50, 0}} ,{{142, 80}, {93, 50, 0}} ,{{141, 80}, {92, 50, 0}} ,{{55, 68}, {107, 36, 0}} ,{{63, 68}, {115, 36, 0}} ,{{137, 80}, {88, 50, 0}} ,{{134, 80}, {85, 50, 0}} ,{{133, 80}, {84, 50, 0}} ,{{138, 80}, {89, 50, 0}} ,{{130, 80}, {81, 50, 0}} ,{{122, 80}, {73, 50, 0}} ,{{136, 80}, {87, 50, 0}} ,{{135, 80}, {86, 50, 0}} ,{{132, 80}, {83, 50, 0}} ,{{131, 80}, {82, 50, 0}} ,{{3, 71}, {66, 39, 0}} ,{{104, 73}, {183, 41, 0}} ,{{106, 73}, {185, 41, 0}} ,{{166, 66}, {149, 34, 0}} ,{{136, 78}, {54, 48, 0}} ,{{105, 73}, {184, 41, 0}} ,{{171, 66}, {154, 34, 0}} ,{{168, 66}, {151, 34, 0}} ,{{155, 67}, {138, 35, 0}} ,{{103, 73}, {182, 41, 0}} ,{{111, 73}, {190, 41, 0}} ,{{235, 70}, {42, 39, 0}} ,{{196, 162}, {46, 241, 1}} ,{{107, 73}, {186, 41, 0}} ,{{161, 69}, {213, 37, 0}} ,{{102, 73}, {181, 41, 0}} ,{{156, 69}, {208, 37, 0}} ,{{158, 69}, {210, 37, 0}} ,{{157, 69}, {209, 37, 0}} ,{{115, 73}, {194, 41, 0}} ,{{108, 73}, {187, 41, 0}} ,{{116, 73}, {195, 41, 0}} ,{{159, 69}, {211, 37, 0}} ,{{160, 69}, {212, 37, 0}} ,{{153, 69}, {205, 37, 0}} ,{{193, 73}, {16, 42, 0}} ,{{33, 38}, {94, 0, 0}} ,{{6, 163}, {0, 248, 2}} ,{{7, 163}, {1, 248, 2}} ,{{8, 163}, {2, 248, 2}} ,{{9, 163}, {3, 248, 2}} ,{{10, 163}, {4, 248, 2}} ,{{11, 163}, {5, 248, 2}} ,{{12, 163}, {6, 248, 2}} ,{{13, 163}, {7, 248, 2}} ,{{14, 163}, {8, 248, 2}} ,{{15, 163}, {9, 248, 2}} ,{{16, 163}, {10, 248, 2}} ,{{17, 163}, {11, 248, 2}} ,{{18, 163}, {12, 248, 2}} ,{{19, 163}, {13, 248, 2}} ,{{20, 163}, {14, 248, 2}} ,{{21, 163}, {15, 248, 2}} ,{{22, 163}, {16, 248, 2}} ,{{23, 163}, {17, 248, 2}} ,{{24, 163}, {18, 248, 2}} ,{{25, 163}, {19, 248, 2}} ,{{26, 163}, {20, 248, 2}} ,{{27, 163}, {21, 248, 2}} ,{{28, 163}, {22, 248, 2}} ,{{29, 163}, {23, 248, 2}} ,{{30, 163}, {24, 248, 2}} ,{{31, 163}, {25, 248, 2}} ,{{32, 163}, {26, 248, 2}} ,{{33, 163}, {27, 248, 2}} ,{{34, 163}, {28, 248, 2}} ,{{35, 163}, {29, 248, 2}} ,{{36, 163}, {30, 248, 2}} ,{{37, 163}, {31, 248, 2}} ,{{38, 163}, {32, 248, 2}} ,{{39, 163}, {33, 248, 2}} ,{{40, 163}, {34, 248, 2}} ,{{41, 163}, {35, 248, 2}} ,{{42, 163}, {36, 248, 2}} ,{{43, 163}, {37, 248, 2}} ,{{44, 163}, {38, 248, 2}} ,{{45, 163}, {39, 248, 2}} ,{{46, 163}, {40, 248, 2}} ,{{47, 163}, {41, 248, 2}} ,{{48, 163}, {42, 248, 2}} ,{{49, 163}, {43, 248, 2}} ,{{50, 163}, {44, 248, 2}} ,{{51, 163}, {45, 248, 2}} ,{{52, 163}, {46, 248, 2}} ,{{53, 163}, {47, 248, 2}} ,{{54, 163}, {48, 248, 2}} ,{{55, 163}, {49, 248, 2}} ,{{56, 163}, {50, 248, 2}} ,{{57, 163}, {51, 248, 2}} ,{{58, 163}, {52, 248, 2}} ,{{59, 163}, {53, 248, 2}} ,{{60, 163}, {54, 248, 2}} ,{{61, 163}, {55, 248, 2}} ,{{62, 163}, {56, 248, 2}} ,{{63, 163}, {57, 248, 2}} ,{{64, 163}, {58, 248, 2}} ,{{65, 163}, {59, 248, 2}} ,{{66, 163}, {60, 248, 2}} ,{{67, 163}, {61, 248, 2}} ,{{68, 163}, {62, 248, 2}} ,{{69, 163}, {63, 248, 2}} ,{{70, 163}, {64, 248, 2}} ,{{71, 163}, {65, 248, 2}} ,{{72, 163}, {66, 248, 2}} ,{{73, 163}, {67, 248, 2}} ,{{74, 163}, {68, 248, 2}} ,{{75, 163}, {69, 248, 2}} ,{{76, 163}, {70, 248, 2}} ,{{77, 163}, {71, 248, 2}} ,{{78, 163}, {72, 248, 2}} ,{{79, 163}, {73, 248, 2}} ,{{80, 163}, {74, 248, 2}} ,{{81, 163}, {75, 248, 2}} ,{{82, 163}, {76, 248, 2}} ,{{83, 163}, {77, 248, 2}} ,{{84, 163}, {78, 248, 2}} ,{{85, 163}, {79, 248, 2}} ,{{86, 163}, {80, 248, 2}} ,{{87, 163}, {81, 248, 2}} ,{{88, 163}, {82, 248, 2}} ,{{89, 163}, {83, 248, 2}} ,{{90, 163}, {84, 248, 2}} ,{{91, 163}, {85, 248, 2}} ,{{92, 163}, {86, 248, 2}} ,{{93, 163}, {87, 248, 2}} ,{{94, 163}, {88, 248, 2}} ,{{95, 163}, {89, 248, 2}} ,{{96, 163}, {90, 248, 2}} ,{{97, 163}, {91, 248, 2}} ,{{98, 163}, {92, 248, 2}} ,{{99, 163}, {93, 248, 2}} ,{{100, 163}, {94, 248, 2}} ,{{101, 163}, {95, 248, 2}} ,{{102, 163}, {96, 248, 2}} ,{{103, 163}, {97, 248, 2}} ,{{104, 163}, {98, 248, 2}} ,{{105, 163}, {99, 248, 2}} ,{{106, 163}, {100, 248, 2}} ,{{107, 163}, {101, 248, 2}} ,{{108, 163}, {102, 248, 2}} ,{{109, 163}, {103, 248, 2}} ,{{110, 163}, {104, 248, 2}} ,{{111, 163}, {105, 248, 2}} ,{{112, 163}, {106, 248, 2}} ,{{113, 163}, {107, 248, 2}} ,{{114, 163}, {108, 248, 2}} ,{{115, 163}, {109, 248, 2}} ,{{116, 163}, {110, 248, 2}} ,{{117, 163}, {111, 248, 2}} ,{{118, 163}, {112, 248, 2}} ,{{119, 163}, {113, 248, 2}} ,{{120, 163}, {114, 248, 2}} ,{{121, 163}, {115, 248, 2}} ,{{122, 163}, {116, 248, 2}} ,{{123, 163}, {117, 248, 2}} ,{{124, 163}, {118, 248, 2}} ,{{125, 163}, {119, 248, 2}} ,{{126, 163}, {120, 248, 2}} ,{{127, 163}, {121, 248, 2}} ,{{128, 163}, {122, 248, 2}} ,{{129, 163}, {123, 248, 2}} ,{{130, 163}, {124, 248, 2}} ,{{131, 163}, {125, 248, 2}} ,{{132, 163}, {126, 248, 2}} ,{{133, 163}, {127, 248, 2}} ,{{134, 163}, {128, 248, 2}} ,{{135, 163}, {129, 248, 2}} ,{{136, 163}, {130, 248, 2}} ,{{137, 163}, {131, 248, 2}} ,{{138, 163}, {132, 248, 2}} ,{{139, 163}, {133, 248, 2}} ,{{140, 163}, {134, 248, 2}} ,{{141, 163}, {135, 248, 2}} ,{{142, 163}, {136, 248, 2}} ,{{143, 163}, {137, 248, 2}} ,{{144, 163}, {138, 248, 2}} ,{{145, 163}, {139, 248, 2}} ,{{146, 163}, {140, 248, 2}} ,{{147, 163}, {141, 248, 2}} ,{{148, 163}, {142, 248, 2}} ,{{149, 163}, {143, 248, 2}} ,{{150, 163}, {144, 248, 2}} ,{{151, 163}, {145, 248, 2}} ,{{152, 163}, {146, 248, 2}} ,{{153, 163}, {147, 248, 2}} ,{{154, 163}, {148, 248, 2}} ,{{155, 163}, {149, 248, 2}} ,{{156, 163}, {150, 248, 2}} ,{{157, 163}, {151, 248, 2}} ,{{158, 163}, {152, 248, 2}} ,{{159, 163}, {153, 248, 2}} ,{{160, 163}, {154, 248, 2}} ,{{161, 163}, {155, 248, 2}} ,{{162, 163}, {156, 248, 2}} ,{{163, 163}, {157, 248, 2}} ,{{164, 163}, {158, 248, 2}} ,{{165, 163}, {159, 248, 2}} ,{{166, 163}, {160, 248, 2}} ,{{167, 163}, {161, 248, 2}} ,{{168, 163}, {162, 248, 2}} ,{{169, 163}, {163, 248, 2}} ,{{170, 163}, {164, 248, 2}} ,{{171, 163}, {165, 248, 2}} ,{{172, 163}, {166, 248, 2}} ,{{173, 163}, {167, 248, 2}} ,{{174, 163}, {168, 248, 2}} ,{{175, 163}, {169, 248, 2}} ,{{176, 163}, {170, 248, 2}} ,{{177, 163}, {171, 248, 2}} ,{{178, 163}, {172, 248, 2}} ,{{179, 163}, {173, 248, 2}} ,{{180, 163}, {174, 248, 2}} ,{{181, 163}, {175, 248, 2}} ,{{182, 163}, {176, 248, 2}} ,{{183, 163}, {177, 248, 2}} ,{{184, 163}, {178, 248, 2}} ,{{185, 163}, {179, 248, 2}} ,{{186, 163}, {180, 248, 2}} ,{{187, 163}, {181, 248, 2}} ,{{188, 163}, {182, 248, 2}} ,{{189, 163}, {183, 248, 2}} ,{{190, 163}, {184, 248, 2}} ,{{191, 163}, {185, 248, 2}} ,{{192, 163}, {186, 248, 2}} ,{{193, 163}, {187, 248, 2}} ,{{194, 163}, {188, 248, 2}} ,{{195, 163}, {189, 248, 2}} ,{{196, 163}, {190, 248, 2}} ,{{197, 163}, {191, 248, 2}} ,{{198, 163}, {192, 248, 2}} ,{{199, 163}, {193, 248, 2}} ,{{200, 163}, {194, 248, 2}} ,{{201, 163}, {195, 248, 2}} ,{{202, 163}, {196, 248, 2}} ,{{203, 163}, {197, 248, 2}} ,{{204, 163}, {198, 248, 2}} ,{{205, 163}, {199, 248, 2}} ,{{206, 163}, {200, 248, 2}} ,{{207, 163}, {201, 248, 2}} ,{{208, 163}, {202, 248, 2}} ,{{209, 163}, {203, 248, 2}} ,{{210, 163}, {204, 248, 2}} ,{{211, 163}, {205, 248, 2}} ,{{212, 163}, {206, 248, 2}} ,{{213, 163}, {207, 248, 2}} ,{{214, 163}, {208, 248, 2}} ,{{215, 163}, {209, 248, 2}} ,{{216, 163}, {210, 248, 2}} ,{{217, 163}, {211, 248, 2}} ,{{218, 163}, {212, 248, 2}} ,{{219, 163}, {213, 248, 2}} ,{{220, 163}, {214, 248, 2}} ,{{221, 163}, {215, 248, 2}} ,{{222, 163}, {216, 248, 2}} ,{{223, 163}, {217, 248, 2}} ,{{224, 163}, {218, 248, 2}} ,{{225, 163}, {219, 248, 2}} ,{{226, 163}, {220, 248, 2}} ,{{227, 163}, {221, 248, 2}} ,{{228, 163}, {222, 248, 2}} ,{{229, 163}, {223, 248, 2}} ,{{230, 163}, {224, 248, 2}} ,{{231, 163}, {225, 248, 2}} ,{{232, 163}, {226, 248, 2}} ,{{233, 163}, {227, 248, 2}} ,{{234, 163}, {228, 248, 2}} ,{{235, 163}, {229, 248, 2}} ,{{236, 163}, {230, 248, 2}} ,{{237, 163}, {231, 248, 2}} ,{{238, 163}, {232, 248, 2}} ,{{239, 163}, {233, 248, 2}} ,{{240, 163}, {234, 248, 2}} ,{{241, 163}, {235, 248, 2}} ,{{242, 163}, {236, 248, 2}} ,{{243, 163}, {237, 248, 2}} ,{{244, 163}, {238, 248, 2}} ,{{245, 163}, {239, 248, 2}} ,{{246, 163}, {240, 248, 2}} ,{{247, 163}, {241, 248, 2}} ,{{248, 163}, {242, 248, 2}} ,{{249, 163}, {243, 248, 2}} ,{{250, 163}, {244, 248, 2}} ,{{251, 163}, {245, 248, 2}} ,{{252, 163}, {246, 248, 2}} ,{{253, 163}, {247, 248, 2}} ,{{254, 163}, {248, 248, 2}} ,{{255, 163}, {249, 248, 2}} ,{{0, 164}, {250, 248, 2}} ,{{1, 164}, {251, 248, 2}} ,{{2, 164}, {252, 248, 2}} ,{{3, 164}, {253, 248, 2}} ,{{4, 164}, {254, 248, 2}} ,{{5, 164}, {255, 248, 2}} ,{{6, 164}, {0, 249, 2}} ,{{7, 164}, {1, 249, 2}} ,{{8, 164}, {2, 249, 2}} ,{{9, 164}, {3, 249, 2}} ,{{10, 164}, {4, 249, 2}} ,{{11, 164}, {5, 249, 2}} ,{{12, 164}, {6, 249, 2}} ,{{13, 164}, {7, 249, 2}} ,{{14, 164}, {8, 249, 2}} ,{{15, 164}, {9, 249, 2}} ,{{16, 164}, {10, 249, 2}} ,{{17, 164}, {11, 249, 2}} ,{{18, 164}, {12, 249, 2}} ,{{19, 164}, {13, 249, 2}} ,{{20, 164}, {14, 249, 2}} ,{{21, 164}, {15, 249, 2}} ,{{22, 164}, {16, 249, 2}} ,{{23, 164}, {17, 249, 2}} ,{{24, 164}, {18, 249, 2}} ,{{25, 164}, {19, 249, 2}} ,{{26, 164}, {20, 249, 2}} ,{{27, 164}, {21, 249, 2}} ,{{28, 164}, {22, 249, 2}} ,{{29, 164}, {23, 249, 2}} ,{{30, 164}, {24, 249, 2}} ,{{31, 164}, {25, 249, 2}} ,{{32, 164}, {26, 249, 2}} ,{{33, 164}, {27, 249, 2}} ,{{34, 164}, {28, 249, 2}} ,{{35, 164}, {29, 249, 2}} ,{{36, 164}, {30, 249, 2}} ,{{37, 164}, {31, 249, 2}} ,{{38, 164}, {32, 249, 2}} ,{{39, 164}, {33, 249, 2}} ,{{40, 164}, {34, 249, 2}} ,{{41, 164}, {35, 249, 2}} ,{{42, 164}, {36, 249, 2}} ,{{43, 164}, {37, 249, 2}} ,{{44, 164}, {38, 249, 2}} ,{{45, 164}, {39, 249, 2}} ,{{46, 164}, {40, 249, 2}} ,{{47, 164}, {41, 249, 2}} ,{{48, 164}, {42, 249, 2}} ,{{49, 164}, {43, 249, 2}} ,{{50, 164}, {44, 249, 2}} ,{{51, 164}, {45, 249, 2}} ,{{52, 164}, {46, 249, 2}} ,{{53, 164}, {47, 249, 2}} ,{{54, 164}, {48, 249, 2}} ,{{55, 164}, {49, 249, 2}} ,{{56, 164}, {50, 249, 2}} ,{{57, 164}, {51, 249, 2}} ,{{58, 164}, {52, 249, 2}} ,{{59, 164}, {53, 249, 2}} ,{{60, 164}, {54, 249, 2}} ,{{61, 164}, {55, 249, 2}} ,{{62, 164}, {56, 249, 2}} ,{{63, 164}, {57, 249, 2}} ,{{64, 164}, {58, 249, 2}} ,{{65, 164}, {59, 249, 2}} ,{{66, 164}, {60, 249, 2}} ,{{67, 164}, {61, 249, 2}} ,{{68, 164}, {62, 249, 2}} ,{{69, 164}, {63, 249, 2}} ,{{70, 164}, {64, 249, 2}} ,{{71, 164}, {65, 249, 2}} ,{{72, 164}, {66, 249, 2}} ,{{73, 164}, {67, 249, 2}} ,{{74, 164}, {68, 249, 2}} ,{{75, 164}, {69, 249, 2}} ,{{76, 164}, {70, 249, 2}} ,{{77, 164}, {71, 249, 2}} ,{{78, 164}, {72, 249, 2}} ,{{79, 164}, {73, 249, 2}} ,{{80, 164}, {74, 249, 2}} ,{{81, 164}, {75, 249, 2}} ,{{82, 164}, {76, 249, 2}} ,{{83, 164}, {77, 249, 2}} ,{{84, 164}, {78, 249, 2}} ,{{85, 164}, {79, 249, 2}} ,{{86, 164}, {80, 249, 2}} ,{{87, 164}, {81, 249, 2}} ,{{88, 164}, {82, 249, 2}} ,{{89, 164}, {83, 249, 2}} ,{{90, 164}, {84, 249, 2}} ,{{91, 164}, {85, 249, 2}} ,{{92, 164}, {86, 249, 2}} ,{{93, 164}, {87, 249, 2}} ,{{94, 164}, {88, 249, 2}} ,{{95, 164}, {89, 249, 2}} ,{{96, 164}, {90, 249, 2}} ,{{97, 164}, {91, 249, 2}} ,{{98, 164}, {92, 249, 2}} ,{{99, 164}, {93, 249, 2}} ,{{100, 164}, {94, 249, 2}} ,{{101, 164}, {95, 249, 2}} ,{{102, 164}, {96, 249, 2}} ,{{103, 164}, {97, 249, 2}} ,{{104, 164}, {98, 249, 2}} ,{{105, 164}, {99, 249, 2}} ,{{106, 164}, {100, 249, 2}} ,{{107, 164}, {101, 249, 2}} ,{{108, 164}, {102, 249, 2}} ,{{109, 164}, {103, 249, 2}} ,{{110, 164}, {104, 249, 2}} ,{{111, 164}, {105, 249, 2}} ,{{112, 164}, {106, 249, 2}} ,{{113, 164}, {107, 249, 2}} ,{{114, 164}, {108, 249, 2}} ,{{115, 164}, {109, 249, 2}} ,{{116, 164}, {110, 249, 2}} ,{{117, 164}, {111, 249, 2}} ,{{118, 164}, {112, 249, 2}} ,{{119, 164}, {113, 249, 2}} ,{{120, 164}, {114, 249, 2}} ,{{121, 164}, {115, 249, 2}} ,{{122, 164}, {116, 249, 2}} ,{{123, 164}, {117, 249, 2}} ,{{124, 164}, {118, 249, 2}} ,{{125, 164}, {119, 249, 2}} ,{{126, 164}, {120, 249, 2}} ,{{127, 164}, {121, 249, 2}} ,{{128, 164}, {122, 249, 2}} ,{{129, 164}, {123, 249, 2}} ,{{130, 164}, {124, 249, 2}} ,{{131, 164}, {125, 249, 2}} ,{{132, 164}, {126, 249, 2}} ,{{133, 164}, {127, 249, 2}} ,{{134, 164}, {128, 249, 2}} ,{{135, 164}, {129, 249, 2}} ,{{136, 164}, {130, 249, 2}} ,{{137, 164}, {131, 249, 2}} ,{{138, 164}, {132, 249, 2}} ,{{139, 164}, {133, 249, 2}} ,{{140, 164}, {134, 249, 2}} ,{{141, 164}, {135, 249, 2}} ,{{142, 164}, {136, 249, 2}} ,{{143, 164}, {137, 249, 2}} ,{{144, 164}, {138, 249, 2}} ,{{145, 164}, {139, 249, 2}} ,{{146, 164}, {140, 249, 2}} ,{{147, 164}, {141, 249, 2}} ,{{148, 164}, {142, 249, 2}} ,{{149, 164}, {143, 249, 2}} ,{{150, 164}, {144, 249, 2}} ,{{151, 164}, {145, 249, 2}} ,{{152, 164}, {146, 249, 2}} ,{{153, 164}, {147, 249, 2}} ,{{154, 164}, {148, 249, 2}} ,{{155, 164}, {149, 249, 2}} ,{{156, 164}, {150, 249, 2}} ,{{157, 164}, {151, 249, 2}} ,{{158, 164}, {152, 249, 2}} ,{{159, 164}, {153, 249, 2}} ,{{160, 164}, {154, 249, 2}} ,{{161, 164}, {155, 249, 2}} ,{{162, 164}, {156, 249, 2}} ,{{163, 164}, {157, 249, 2}} ,{{164, 164}, {158, 249, 2}} ,{{165, 164}, {159, 249, 2}} ,{{166, 164}, {160, 249, 2}} ,{{167, 164}, {161, 249, 2}} ,{{168, 164}, {162, 249, 2}} ,{{169, 164}, {163, 249, 2}} ,{{170, 164}, {164, 249, 2}} ,{{171, 164}, {165, 249, 2}} ,{{172, 164}, {166, 249, 2}} ,{{173, 164}, {167, 249, 2}} ,{{174, 164}, {168, 249, 2}} ,{{175, 164}, {169, 249, 2}} ,{{176, 164}, {170, 249, 2}} ,{{177, 164}, {171, 249, 2}} ,{{178, 164}, {172, 249, 2}} ,{{179, 164}, {173, 249, 2}} ,{{180, 164}, {174, 249, 2}} ,{{181, 164}, {175, 249, 2}} ,{{182, 164}, {176, 249, 2}} ,{{183, 164}, {177, 249, 2}} ,{{184, 164}, {178, 249, 2}} ,{{185, 164}, {179, 249, 2}} ,{{186, 164}, {180, 249, 2}} ,{{187, 164}, {181, 249, 2}} ,{{188, 164}, {182, 249, 2}} ,{{189, 164}, {183, 249, 2}} ,{{190, 164}, {184, 249, 2}} ,{{191, 164}, {185, 249, 2}} ,{{192, 164}, {186, 249, 2}} ,{{193, 164}, {187, 249, 2}} ,{{194, 164}, {188, 249, 2}} ,{{195, 164}, {189, 249, 2}} ,{{196, 164}, {190, 249, 2}} ,{{197, 164}, {191, 249, 2}} ,{{198, 164}, {192, 249, 2}} ,{{199, 164}, {193, 249, 2}} ,{{200, 164}, {194, 249, 2}} ,{{201, 164}, {195, 249, 2}} ,{{202, 164}, {196, 249, 2}} ,{{203, 164}, {197, 249, 2}} ,{{204, 164}, {198, 249, 2}} ,{{205, 164}, {199, 249, 2}} ,{{206, 164}, {200, 249, 2}} ,{{207, 164}, {201, 249, 2}} ,{{208, 164}, {202, 249, 2}} ,{{209, 164}, {203, 249, 2}} ,{{210, 164}, {204, 249, 2}} ,{{211, 164}, {205, 249, 2}} ,{{212, 164}, {206, 249, 2}} ,{{213, 164}, {207, 249, 2}} ,{{214, 164}, {208, 249, 2}} ,{{215, 164}, {209, 249, 2}} ,{{216, 164}, {210, 249, 2}} ,{{217, 164}, {211, 249, 2}} ,{{218, 164}, {212, 249, 2}} ,{{219, 164}, {213, 249, 2}} ,{{220, 164}, {214, 249, 2}} ,{{221, 164}, {215, 249, 2}} ,{{222, 164}, {216, 249, 2}} ,{{223, 164}, {217, 249, 2}} ,{{224, 164}, {218, 249, 2}} ,{{225, 164}, {219, 249, 2}} ,{{226, 164}, {220, 249, 2}} ,{{227, 164}, {221, 249, 2}} ,{{228, 164}, {222, 249, 2}} ,{{229, 164}, {223, 249, 2}} ,{{230, 164}, {224, 249, 2}} ,{{231, 164}, {225, 249, 2}} ,{{232, 164}, {226, 249, 2}} ,{{233, 164}, {227, 249, 2}} ,{{234, 164}, {228, 249, 2}} ,{{235, 164}, {229, 249, 2}} ,{{236, 164}, {230, 249, 2}} ,{{237, 164}, {231, 249, 2}} ,{{238, 164}, {232, 249, 2}} ,{{239, 164}, {233, 249, 2}} ,{{240, 164}, {234, 249, 2}} ,{{241, 164}, {235, 249, 2}} ,{{242, 164}, {236, 249, 2}} ,{{243, 164}, {237, 249, 2}} ,{{244, 164}, {238, 249, 2}} ,{{245, 164}, {239, 249, 2}} ,{{246, 164}, {240, 249, 2}} ,{{247, 164}, {241, 249, 2}} ,{{248, 164}, {242, 249, 2}} ,{{249, 164}, {243, 249, 2}} ,{{250, 164}, {244, 249, 2}} ,{{251, 164}, {245, 249, 2}} ,{{252, 164}, {246, 249, 2}} ,{{253, 164}, {247, 249, 2}} ,{{254, 164}, {248, 249, 2}} ,{{255, 164}, {249, 249, 2}} ,{{0, 165}, {250, 249, 2}} ,{{1, 165}, {251, 249, 2}} ,{{2, 165}, {252, 249, 2}} ,{{3, 165}, {253, 249, 2}} ,{{4, 165}, {254, 249, 2}} ,{{5, 165}, {255, 249, 2}} ,{{6, 165}, {0, 250, 2}} ,{{7, 165}, {1, 250, 2}} ,{{8, 165}, {2, 250, 2}} ,{{9, 165}, {3, 250, 2}} ,{{10, 165}, {4, 250, 2}} ,{{11, 165}, {5, 250, 2}} ,{{12, 165}, {6, 250, 2}} ,{{13, 165}, {7, 250, 2}} ,{{14, 165}, {8, 250, 2}} ,{{15, 165}, {9, 250, 2}} ,{{16, 165}, {10, 250, 2}} ,{{17, 165}, {11, 250, 2}} ,{{18, 165}, {12, 250, 2}} ,{{19, 165}, {13, 250, 2}} ,{{20, 165}, {14, 250, 2}} ,{{21, 165}, {15, 250, 2}} ,{{22, 165}, {16, 250, 2}} ,{{23, 165}, {17, 250, 2}} ,{{24, 165}, {18, 250, 2}} ,{{25, 165}, {19, 250, 2}} ,{{26, 165}, {20, 250, 2}} ,{{27, 165}, {21, 250, 2}} ,{{28, 165}, {22, 250, 2}} ,{{29, 165}, {23, 250, 2}} ,{{30, 165}, {24, 250, 2}} ,{{31, 165}, {25, 250, 2}} ,{{32, 165}, {26, 250, 2}} ,{{33, 165}, {27, 250, 2}} ,{{34, 165}, {28, 250, 2}} ,{{35, 165}, {29, 250, 2}} ,{{75, 136}, {0, 249, 0}} ,{{76, 136}, {1, 249, 0}} ,{{77, 136}, {2, 249, 0}} ,{{78, 136}, {3, 249, 0}} ,{{79, 136}, {4, 249, 0}} ,{{80, 136}, {5, 249, 0}} ,{{81, 136}, {6, 249, 0}} ,{{82, 136}, {7, 249, 0}} ,{{83, 136}, {8, 249, 0}} ,{{84, 136}, {9, 249, 0}} ,{{85, 136}, {10, 249, 0}} ,{{86, 136}, {11, 249, 0}} ,{{87, 136}, {12, 249, 0}} ,{{88, 136}, {13, 249, 0}} ,{{89, 136}, {14, 249, 0}} ,{{90, 136}, {15, 249, 0}} ,{{91, 136}, {16, 249, 0}} ,{{92, 136}, {17, 249, 0}} ,{{93, 136}, {18, 249, 0}} ,{{94, 136}, {19, 249, 0}} ,{{95, 136}, {20, 249, 0}} ,{{96, 136}, {21, 249, 0}} ,{{97, 136}, {22, 249, 0}} ,{{98, 136}, {23, 249, 0}} ,{{99, 136}, {24, 249, 0}} ,{{100, 136}, {25, 249, 0}} ,{{101, 136}, {26, 249, 0}} ,{{102, 136}, {27, 249, 0}} ,{{103, 136}, {28, 249, 0}} ,{{104, 136}, {29, 249, 0}} ,{{105, 136}, {30, 249, 0}} ,{{106, 136}, {31, 249, 0}} ,{{107, 136}, {32, 249, 0}} ,{{108, 136}, {33, 249, 0}} ,{{109, 136}, {34, 249, 0}} ,{{110, 136}, {35, 249, 0}} ,{{111, 136}, {36, 249, 0}} ,{{112, 136}, {37, 249, 0}} ,{{113, 136}, {38, 249, 0}} ,{{114, 136}, {39, 249, 0}} ,{{115, 136}, {40, 249, 0}} ,{{116, 136}, {41, 249, 0}} ,{{117, 136}, {42, 249, 0}} ,{{118, 136}, {43, 249, 0}} ,{{119, 136}, {44, 249, 0}} ,{{120, 136}, {45, 249, 0}} ,{{121, 136}, {46, 249, 0}} ,{{122, 136}, {47, 249, 0}} ,{{123, 136}, {48, 249, 0}} ,{{124, 136}, {49, 249, 0}} ,{{125, 136}, {50, 249, 0}} ,{{126, 136}, {51, 249, 0}} ,{{127, 136}, {52, 249, 0}} ,{{128, 136}, {53, 249, 0}} ,{{129, 136}, {54, 249, 0}} ,{{130, 136}, {55, 249, 0}} ,{{131, 136}, {56, 249, 0}} ,{{132, 136}, {57, 249, 0}} ,{{133, 136}, {58, 249, 0}} ,{{134, 136}, {59, 249, 0}} ,{{135, 136}, {60, 249, 0}} ,{{136, 136}, {61, 249, 0}} ,{{137, 136}, {62, 249, 0}} ,{{138, 136}, {63, 249, 0}} ,{{139, 136}, {64, 249, 0}} ,{{140, 136}, {65, 249, 0}} ,{{141, 136}, {66, 249, 0}} ,{{142, 136}, {67, 249, 0}} ,{{143, 136}, {68, 249, 0}} ,{{144, 136}, {69, 249, 0}} ,{{145, 136}, {70, 249, 0}} ,{{146, 136}, {71, 249, 0}} ,{{147, 136}, {72, 249, 0}} ,{{148, 136}, {73, 249, 0}} ,{{149, 136}, {74, 249, 0}} ,{{150, 136}, {75, 249, 0}} ,{{151, 136}, {76, 249, 0}} ,{{152, 136}, {77, 249, 0}} ,{{153, 136}, {78, 249, 0}} ,{{154, 136}, {79, 249, 0}} ,{{155, 136}, {80, 249, 0}} ,{{156, 136}, {81, 249, 0}} ,{{157, 136}, {82, 249, 0}} ,{{158, 136}, {83, 249, 0}} ,{{159, 136}, {84, 249, 0}} ,{{160, 136}, {85, 249, 0}} ,{{161, 136}, {86, 249, 0}} ,{{162, 136}, {87, 249, 0}} ,{{163, 136}, {88, 249, 0}} ,{{164, 136}, {89, 249, 0}} ,{{165, 136}, {90, 249, 0}} ,{{166, 136}, {91, 249, 0}} ,{{167, 136}, {92, 249, 0}} ,{{168, 136}, {93, 249, 0}} ,{{169, 136}, {94, 249, 0}} ,{{170, 136}, {95, 249, 0}} ,{{171, 136}, {96, 249, 0}} ,{{172, 136}, {97, 249, 0}} ,{{173, 136}, {98, 249, 0}} ,{{174, 136}, {99, 249, 0}} ,{{175, 136}, {100, 249, 0}} ,{{176, 136}, {101, 249, 0}} ,{{177, 136}, {102, 249, 0}} ,{{178, 136}, {103, 249, 0}} ,{{179, 136}, {104, 249, 0}} ,{{180, 136}, {105, 249, 0}} ,{{181, 136}, {106, 249, 0}} ,{{182, 136}, {107, 249, 0}} ,{{183, 136}, {108, 249, 0}} ,{{184, 136}, {109, 249, 0}} ,{{185, 136}, {110, 249, 0}} ,{{186, 136}, {111, 249, 0}} ,{{187, 136}, {112, 249, 0}} ,{{188, 136}, {113, 249, 0}} ,{{189, 136}, {114, 249, 0}} ,{{190, 136}, {115, 249, 0}} ,{{191, 136}, {116, 249, 0}} ,{{192, 136}, {117, 249, 0}} ,{{193, 136}, {118, 249, 0}} ,{{194, 136}, {119, 249, 0}} ,{{195, 136}, {120, 249, 0}} ,{{196, 136}, {121, 249, 0}} ,{{197, 136}, {122, 249, 0}} ,{{198, 136}, {123, 249, 0}} ,{{199, 136}, {124, 249, 0}} ,{{200, 136}, {125, 249, 0}} ,{{201, 136}, {126, 249, 0}} ,{{202, 136}, {127, 249, 0}} ,{{203, 136}, {128, 249, 0}} ,{{204, 136}, {129, 249, 0}} ,{{205, 136}, {130, 249, 0}} ,{{206, 136}, {131, 249, 0}} ,{{207, 136}, {132, 249, 0}} ,{{208, 136}, {133, 249, 0}} ,{{209, 136}, {134, 249, 0}} ,{{210, 136}, {135, 249, 0}} ,{{211, 136}, {136, 249, 0}} ,{{212, 136}, {137, 249, 0}} ,{{213, 136}, {138, 249, 0}} ,{{214, 136}, {139, 249, 0}} ,{{215, 136}, {140, 249, 0}} ,{{216, 136}, {141, 249, 0}} ,{{217, 136}, {142, 249, 0}} ,{{218, 136}, {143, 249, 0}} ,{{219, 136}, {144, 249, 0}} ,{{220, 136}, {145, 249, 0}} ,{{221, 136}, {146, 249, 0}} ,{{222, 136}, {147, 249, 0}} ,{{223, 136}, {148, 249, 0}} ,{{224, 136}, {149, 249, 0}} ,{{225, 136}, {150, 249, 0}} ,{{226, 136}, {151, 249, 0}} ,{{227, 136}, {152, 249, 0}} ,{{228, 136}, {153, 249, 0}} ,{{229, 136}, {154, 249, 0}} ,{{230, 136}, {155, 249, 0}} ,{{231, 136}, {156, 249, 0}} ,{{232, 136}, {157, 249, 0}} ,{{233, 136}, {158, 249, 0}} ,{{234, 136}, {159, 249, 0}} ,{{235, 136}, {160, 249, 0}} ,{{236, 136}, {161, 249, 0}} ,{{237, 136}, {162, 249, 0}} ,{{238, 136}, {163, 249, 0}} ,{{239, 136}, {164, 249, 0}} ,{{240, 136}, {165, 249, 0}} ,{{241, 136}, {166, 249, 0}} ,{{242, 136}, {167, 249, 0}} ,{{243, 136}, {168, 249, 0}} ,{{244, 136}, {169, 249, 0}} ,{{245, 136}, {170, 249, 0}} ,{{246, 136}, {171, 249, 0}} ,{{247, 136}, {172, 249, 0}} ,{{248, 136}, {173, 249, 0}} ,{{249, 136}, {174, 249, 0}} ,{{250, 136}, {175, 249, 0}} ,{{251, 136}, {176, 249, 0}} ,{{252, 136}, {177, 249, 0}} ,{{253, 136}, {178, 249, 0}} ,{{254, 136}, {179, 249, 0}} ,{{255, 136}, {180, 249, 0}} ,{{0, 137}, {181, 249, 0}} ,{{1, 137}, {182, 249, 0}} ,{{2, 137}, {183, 249, 0}} ,{{3, 137}, {184, 249, 0}} ,{{4, 137}, {185, 249, 0}} ,{{5, 137}, {186, 249, 0}} ,{{6, 137}, {187, 249, 0}} ,{{7, 137}, {188, 249, 0}} ,{{8, 137}, {189, 249, 0}} ,{{9, 137}, {190, 249, 0}} ,{{10, 137}, {191, 249, 0}} ,{{11, 137}, {192, 249, 0}} ,{{12, 137}, {193, 249, 0}} ,{{13, 137}, {194, 249, 0}} ,{{14, 137}, {195, 249, 0}} ,{{15, 137}, {196, 249, 0}} ,{{16, 137}, {197, 249, 0}} ,{{17, 137}, {198, 249, 0}} ,{{18, 137}, {199, 249, 0}} ,{{19, 137}, {200, 249, 0}} ,{{20, 137}, {201, 249, 0}} ,{{21, 137}, {202, 249, 0}} ,{{22, 137}, {203, 249, 0}} ,{{23, 137}, {204, 249, 0}} ,{{24, 137}, {205, 249, 0}} ,{{25, 137}, {206, 249, 0}} ,{{26, 137}, {207, 249, 0}} ,{{27, 137}, {208, 249, 0}} ,{{28, 137}, {209, 249, 0}} ,{{29, 137}, {210, 249, 0}} ,{{30, 137}, {211, 249, 0}} ,{{31, 137}, {212, 249, 0}} ,{{32, 137}, {213, 249, 0}} ,{{33, 137}, {214, 249, 0}} ,{{34, 137}, {215, 249, 0}} ,{{35, 137}, {216, 249, 0}} ,{{36, 137}, {217, 249, 0}} ,{{37, 137}, {218, 249, 0}} ,{{38, 137}, {219, 249, 0}} ,{{39, 137}, {220, 249, 0}} ,{{40, 137}, {221, 249, 0}} ,{{41, 137}, {222, 249, 0}} ,{{42, 137}, {223, 249, 0}} ,{{43, 137}, {224, 249, 0}} ,{{44, 137}, {225, 249, 0}} ,{{45, 137}, {226, 249, 0}} ,{{46, 137}, {227, 249, 0}} ,{{47, 137}, {228, 249, 0}} ,{{48, 137}, {229, 249, 0}} ,{{49, 137}, {230, 249, 0}} ,{{50, 137}, {231, 249, 0}} ,{{51, 137}, {232, 249, 0}} ,{{52, 137}, {233, 249, 0}} ,{{53, 137}, {234, 249, 0}} ,{{54, 137}, {235, 249, 0}} ,{{55, 137}, {236, 249, 0}} ,{{56, 137}, {237, 249, 0}} ,{{57, 137}, {238, 249, 0}} ,{{58, 137}, {239, 249, 0}} ,{{59, 137}, {240, 249, 0}} ,{{60, 137}, {241, 249, 0}} ,{{61, 137}, {242, 249, 0}} ,{{62, 137}, {243, 249, 0}} ,{{63, 137}, {244, 249, 0}} ,{{64, 137}, {245, 249, 0}} ,{{65, 137}, {246, 249, 0}} ,{{66, 137}, {247, 249, 0}} ,{{67, 137}, {248, 249, 0}} ,{{68, 137}, {249, 249, 0}} ,{{69, 137}, {250, 249, 0}} ,{{70, 137}, {251, 249, 0}} ,{{71, 137}, {252, 249, 0}} ,{{72, 137}, {253, 249, 0}} ,{{73, 137}, {254, 249, 0}} ,{{74, 137}, {255, 249, 0}} ,{{75, 137}, {0, 250, 0}} ,{{76, 137}, {1, 250, 0}} ,{{77, 137}, {2, 250, 0}} ,{{78, 137}, {3, 250, 0}} ,{{79, 137}, {4, 250, 0}} ,{{80, 137}, {5, 250, 0}} ,{{81, 137}, {6, 250, 0}} ,{{82, 137}, {7, 250, 0}} ,{{83, 137}, {8, 250, 0}} ,{{84, 137}, {9, 250, 0}} ,{{85, 137}, {10, 250, 0}} ,{{86, 137}, {11, 250, 0}} ,{{87, 137}, {12, 250, 0}} ,{{88, 137}, {13, 250, 0}} ,{{89, 137}, {14, 250, 0}} ,{{90, 137}, {15, 250, 0}} ,{{91, 137}, {16, 250, 0}} ,{{92, 137}, {17, 250, 0}} ,{{93, 137}, {18, 250, 0}} ,{{94, 137}, {19, 250, 0}} ,{{95, 137}, {20, 250, 0}} ,{{96, 137}, {21, 250, 0}} ,{{97, 137}, {22, 250, 0}} ,{{98, 137}, {23, 250, 0}} ,{{99, 137}, {24, 250, 0}} ,{{100, 137}, {25, 250, 0}} ,{{101, 137}, {26, 250, 0}} ,{{102, 137}, {27, 250, 0}} ,{{103, 137}, {28, 250, 0}} ,{{104, 137}, {29, 250, 0}} ,{{105, 137}, {30, 250, 0}} ,{{106, 137}, {31, 250, 0}} ,{{107, 137}, {32, 250, 0}} ,{{108, 137}, {33, 250, 0}} ,{{109, 137}, {34, 250, 0}} ,{{110, 137}, {35, 250, 0}} ,{{111, 137}, {36, 250, 0}} ,{{112, 137}, {37, 250, 0}} ,{{113, 137}, {38, 250, 0}} ,{{114, 137}, {39, 250, 0}} ,{{115, 137}, {40, 250, 0}} ,{{116, 137}, {41, 250, 0}} ,{{117, 137}, {42, 250, 0}} ,{{118, 137}, {43, 250, 0}} ,{{119, 137}, {44, 250, 0}} ,{{120, 137}, {45, 250, 0}} ,{{121, 137}, {48, 250, 0}} ,{{122, 137}, {49, 250, 0}} ,{{123, 137}, {50, 250, 0}} ,{{124, 137}, {51, 250, 0}} ,{{125, 137}, {52, 250, 0}} ,{{126, 137}, {53, 250, 0}} ,{{127, 137}, {54, 250, 0}} ,{{128, 137}, {55, 250, 0}} ,{{129, 137}, {56, 250, 0}} ,{{130, 137}, {57, 250, 0}} ,{{131, 137}, {58, 250, 0}} ,{{132, 137}, {59, 250, 0}} ,{{133, 137}, {60, 250, 0}} ,{{134, 137}, {61, 250, 0}} ,{{135, 137}, {62, 250, 0}} ,{{136, 137}, {63, 250, 0}} ,{{137, 137}, {64, 250, 0}} ,{{138, 137}, {65, 250, 0}} ,{{139, 137}, {66, 250, 0}} ,{{140, 137}, {67, 250, 0}} ,{{141, 137}, {68, 250, 0}} ,{{142, 137}, {69, 250, 0}} ,{{143, 137}, {70, 250, 0}} ,{{144, 137}, {71, 250, 0}} ,{{145, 137}, {72, 250, 0}} ,{{146, 137}, {73, 250, 0}} ,{{147, 137}, {74, 250, 0}} ,{{148, 137}, {75, 250, 0}} ,{{149, 137}, {76, 250, 0}} ,{{150, 137}, {77, 250, 0}} ,{{151, 137}, {78, 250, 0}} ,{{152, 137}, {79, 250, 0}} ,{{153, 137}, {80, 250, 0}} ,{{154, 137}, {81, 250, 0}} ,{{155, 137}, {82, 250, 0}} ,{{156, 137}, {83, 250, 0}} ,{{157, 137}, {84, 250, 0}} ,{{158, 137}, {85, 250, 0}} ,{{159, 137}, {86, 250, 0}} ,{{160, 137}, {87, 250, 0}} ,{{161, 137}, {88, 250, 0}} ,{{162, 137}, {89, 250, 0}} ,{{163, 137}, {90, 250, 0}} ,{{164, 137}, {91, 250, 0}} ,{{165, 137}, {92, 250, 0}} ,{{166, 137}, {93, 250, 0}} ,{{167, 137}, {94, 250, 0}} ,{{168, 137}, {95, 250, 0}} ,{{169, 137}, {96, 250, 0}} ,{{170, 137}, {97, 250, 0}} ,{{171, 137}, {98, 250, 0}} ,{{172, 137}, {99, 250, 0}} ,{{173, 137}, {100, 250, 0}} ,{{174, 137}, {101, 250, 0}} ,{{175, 137}, {102, 250, 0}} ,{{176, 137}, {103, 250, 0}} ,{{177, 137}, {104, 250, 0}} ,{{178, 137}, {105, 250, 0}} ,{{179, 137}, {106, 250, 0}} ,{{180, 137}, {107, 250, 0}} ,{{181, 137}, {108, 250, 0}} ,{{182, 137}, {109, 250, 0}} ,{{183, 137}, {112, 250, 0}} ,{{184, 137}, {113, 250, 0}} ,{{185, 137}, {114, 250, 0}} ,{{186, 137}, {115, 250, 0}} ,{{187, 137}, {116, 250, 0}} ,{{188, 137}, {117, 250, 0}} ,{{189, 137}, {118, 250, 0}} ,{{190, 137}, {119, 250, 0}} ,{{191, 137}, {120, 250, 0}} ,{{192, 137}, {121, 250, 0}} ,{{193, 137}, {122, 250, 0}} ,{{194, 137}, {123, 250, 0}} ,{{195, 137}, {124, 250, 0}} ,{{196, 137}, {125, 250, 0}} ,{{197, 137}, {126, 250, 0}} ,{{198, 137}, {127, 250, 0}} ,{{199, 137}, {128, 250, 0}} ,{{200, 137}, {129, 250, 0}} ,{{201, 137}, {130, 250, 0}} ,{{202, 137}, {131, 250, 0}} ,{{203, 137}, {132, 250, 0}} ,{{204, 137}, {133, 250, 0}} ,{{205, 137}, {134, 250, 0}} ,{{206, 137}, {135, 250, 0}} ,{{207, 137}, {136, 250, 0}} ,{{208, 137}, {137, 250, 0}} ,{{209, 137}, {138, 250, 0}} ,{{210, 137}, {139, 250, 0}} ,{{211, 137}, {140, 250, 0}} ,{{212, 137}, {141, 250, 0}} ,{{213, 137}, {142, 250, 0}} ,{{214, 137}, {143, 250, 0}} ,{{215, 137}, {144, 250, 0}} ,{{216, 137}, {145, 250, 0}} ,{{217, 137}, {146, 250, 0}} ,{{218, 137}, {147, 250, 0}} ,{{219, 137}, {148, 250, 0}} ,{{220, 137}, {149, 250, 0}} ,{{221, 137}, {150, 250, 0}} ,{{222, 137}, {151, 250, 0}} ,{{223, 137}, {152, 250, 0}} ,{{224, 137}, {153, 250, 0}} ,{{225, 137}, {154, 250, 0}} ,{{226, 137}, {155, 250, 0}} ,{{227, 137}, {156, 250, 0}} ,{{228, 137}, {157, 250, 0}} ,{{229, 137}, {158, 250, 0}} ,{{230, 137}, {159, 250, 0}} ,{{231, 137}, {160, 250, 0}} ,{{232, 137}, {161, 250, 0}} ,{{233, 137}, {162, 250, 0}} ,{{234, 137}, {163, 250, 0}} ,{{235, 137}, {164, 250, 0}} ,{{236, 137}, {165, 250, 0}} ,{{237, 137}, {166, 250, 0}} ,{{238, 137}, {167, 250, 0}} ,{{239, 137}, {168, 250, 0}} ,{{240, 137}, {169, 250, 0}} ,{{241, 137}, {170, 250, 0}} ,{{242, 137}, {171, 250, 0}} ,{{243, 137}, {172, 250, 0}} ,{{244, 137}, {173, 250, 0}} ,{{245, 137}, {174, 250, 0}} ,{{246, 137}, {175, 250, 0}} ,{{247, 137}, {176, 250, 0}} ,{{248, 137}, {177, 250, 0}} ,{{249, 137}, {178, 250, 0}} ,{{250, 137}, {179, 250, 0}} ,{{251, 137}, {180, 250, 0}} ,{{252, 137}, {181, 250, 0}} ,{{253, 137}, {182, 250, 0}} ,{{254, 137}, {183, 250, 0}} ,{{255, 137}, {184, 250, 0}} ,{{0, 138}, {185, 250, 0}} ,{{1, 138}, {186, 250, 0}} ,{{2, 138}, {187, 250, 0}} ,{{3, 138}, {188, 250, 0}} ,{{4, 138}, {189, 250, 0}} ,{{5, 138}, {190, 250, 0}} ,{{6, 138}, {191, 250, 0}} ,{{7, 138}, {192, 250, 0}} ,{{8, 138}, {193, 250, 0}} ,{{9, 138}, {194, 250, 0}} ,{{10, 138}, {195, 250, 0}} ,{{11, 138}, {196, 250, 0}} ,{{12, 138}, {197, 250, 0}} ,{{13, 138}, {198, 250, 0}} ,{{14, 138}, {199, 250, 0}} ,{{15, 138}, {200, 250, 0}} ,{{16, 138}, {201, 250, 0}} ,{{17, 138}, {202, 250, 0}} ,{{18, 138}, {203, 250, 0}} ,{{19, 138}, {204, 250, 0}} ,{{20, 138}, {205, 250, 0}} ,{{21, 138}, {206, 250, 0}} ,{{22, 138}, {207, 250, 0}} ,{{23, 138}, {208, 250, 0}} ,{{24, 138}, {209, 250, 0}} ,{{25, 138}, {210, 250, 0}} ,{{26, 138}, {211, 250, 0}} ,{{27, 138}, {212, 250, 0}} ,{{28, 138}, {213, 250, 0}} ,{{29, 138}, {214, 250, 0}} ,{{30, 138}, {215, 250, 0}} ,{{31, 138}, {216, 250, 0}} ,{{32, 138}, {217, 250, 0}} ,{{42, 77}, {174, 46, 0}} ,{{84, 77}, {216, 46, 0}} ,{{38, 77}, {170, 46, 0}} ,{{95, 77}, {227, 46, 0}} ,{{3, 77}, {134, 46, 0}} ,{{54, 77}, {186, 46, 0}} ,{{55, 77}, {187, 46, 0}} ,{{98, 77}, {230, 46, 0}} ,{{71, 77}, {203, 46, 0}} ,{{108, 77}, {240, 46, 0}} ,{{92, 77}, {224, 46, 0}} ,{{104, 77}, {236, 46, 0}} ,{{97, 77}, {229, 46, 0}} ,{{88, 77}, {220, 46, 0}} ,{{102, 77}, {234, 46, 0}} ,{{80, 77}, {212, 46, 0}} ,{{76, 77}, {208, 46, 0}} ,{{94, 77}, {226, 46, 0}} ,{{86, 77}, {218, 46, 0}} ,{{79, 77}, {211, 46, 0}} ,{{99, 77}, {231, 46, 0}} ,{{65, 77}, {197, 46, 0}} ,{{69, 77}, {201, 46, 0}} ,{{44, 77}, {176, 46, 0}} ,{{68, 77}, {200, 46, 0}} ,{{85, 77}, {217, 46, 0}} ,{{106, 77}, {238, 46, 0}} ,{{111, 77}, {243, 46, 0}} ,{{87, 77}, {219, 46, 0}} ,{{23, 77}, {155, 46, 0}} ,{{75, 77}, {207, 46, 0}} ,{{28, 77}, {160, 46, 0}} ,{{254, 76}, {129, 46, 0}} ,{{62, 77}, {194, 46, 0}} ,{{35, 77}, {167, 46, 0}} ,{{26, 77}, {158, 46, 0}} ,{{7, 77}, {138, 46, 0}} ,{{36, 77}, {168, 46, 0}} ,{{89, 77}, {221, 46, 0}} ,{{91, 77}, {223, 46, 0}} ,{{90, 77}, {222, 46, 0}} ,{{52, 77}, {184, 46, 0}} ,{{39, 77}, {171, 46, 0}} ,{{31, 77}, {163, 46, 0}} ,{{70, 77}, {202, 46, 0}} ,{{96, 77}, {228, 46, 0}} ,{{58, 77}, {190, 46, 0}} ,{{60, 77}, {192, 46, 0}} ,{{59, 77}, {191, 46, 0}} ,{{21, 77}, {152, 46, 0}} ,{{93, 77}, {225, 46, 0}} ,{{19, 77}, {150, 46, 0}} ,{{20, 77}, {151, 46, 0}} ,{{67, 77}, {199, 46, 0}} ,{{107, 77}, {239, 46, 0}} ,{{103, 77}, {235, 46, 0}} ,{{105, 77}, {237, 46, 0}} ,{{110, 77}, {242, 46, 0}} ,{{37, 77}, {169, 46, 0}} ,{{5, 77}, {136, 46, 0}} ,{{6, 77}, {137, 46, 0}} ,{{14, 77}, {145, 46, 0}} ,{{11, 77}, {142, 46, 0}} ,{{13, 77}, {144, 46, 0}} ,{{12, 77}, {143, 46, 0}} ,{{77, 77}, {209, 46, 0}} ,{{78, 77}, {210, 46, 0}} ,{{56, 77}, {188, 46, 0}} ,{{49, 77}, {181, 46, 0}} ,{{25, 77}, {157, 46, 0}} ,{{57, 77}, {189, 46, 0}} ,{{27, 77}, {159, 46, 0}} ,{{81, 77}, {213, 46, 0}} ,{{82, 77}, {214, 46, 0}} ,{{48, 77}, {180, 46, 0}} ,{{45, 77}, {177, 46, 0}} ,{{47, 77}, {179, 46, 0}} ,{{46, 77}, {178, 46, 0}} ,{{53, 77}, {185, 46, 0}} ,{{32, 77}, {164, 46, 0}} ,{{33, 77}, {165, 46, 0}} ,{{2, 77}, {133, 46, 0}} ,{{83, 77}, {215, 46, 0}} ,{{51, 77}, {183, 46, 0}} ,{{22, 77}, {153, 46, 0}} ,{{253, 76}, {128, 46, 0}} ,{{8, 77}, {139, 46, 0}} ,{{255, 76}, {130, 46, 0}} ,{{1, 77}, {132, 46, 0}} ,{{0, 77}, {131, 46, 0}} ,{{50, 77}, {182, 46, 0}} ,{{43, 77}, {175, 46, 0}} ,{{34, 77}, {166, 46, 0}} ,{{66, 77}, {198, 46, 0}} ,{{72, 77}, {204, 46, 0}} ,{{100, 77}, {232, 46, 0}} ,{{101, 77}, {233, 46, 0}} ,{{9, 77}, {140, 46, 0}} ,{{10, 77}, {141, 46, 0}} ,{{15, 77}, {146, 46, 0}} ,{{17, 77}, {148, 46, 0}} ,{{18, 77}, {149, 46, 0}} ,{{40, 77}, {172, 46, 0}} ,{{41, 77}, {173, 46, 0}} ,{{24, 77}, {156, 46, 0}} ,{{4, 77}, {135, 46, 0}} ,{{16, 77}, {147, 46, 0}} ,{{61, 77}, {193, 46, 0}} ,{{109, 77}, {241, 46, 0}} ,{{73, 77}, {205, 46, 0}} ,{{74, 77}, {206, 46, 0}} ,{{29, 77}, {161, 46, 0}} ,{{30, 77}, {162, 46, 0}} ,{{63, 77}, {195, 46, 0}} ,{{64, 77}, {196, 46, 0}} ,{{1, 80}, {195, 49, 0}} ,{{18, 80}, {212, 49, 0}} ,{{14, 80}, {208, 49, 0}} ,{{20, 80}, {214, 49, 0}} ,{{5, 80}, {199, 49, 0}} ,{{10, 80}, {204, 49, 0}} ,{{30, 80}, {224, 49, 0}} ,{{19, 80}, {213, 49, 0}} ,{{4, 80}, {198, 49, 0}} ,{{8, 80}, {202, 49, 0}} ,{{11, 80}, {205, 49, 0}} ,{{6, 80}, {200, 49, 0}} ,{{3, 80}, {197, 49, 0}} ,{{9, 80}, {203, 49, 0}} ,{{12, 80}, {206, 49, 0}} ,{{31, 80}, {225, 49, 0}} ,{{13, 80}, {207, 49, 0}} ,{{16, 80}, {210, 49, 0}} ,{{25, 80}, {219, 49, 0}} ,{{32, 80}, {226, 49, 0}} ,{{26, 80}, {220, 49, 0}} ,{{33, 80}, {227, 49, 0}} ,{{15, 80}, {209, 49, 0}} ,{{24, 80}, {218, 49, 0}} ,{{17, 80}, {211, 49, 0}} ,{{23, 80}, {217, 49, 0}} ,{{2, 80}, {196, 49, 0}} ,{{29, 80}, {223, 49, 0}} ,{{22, 80}, {216, 49, 0}} ,{{21, 80}, {215, 49, 0}} ,{{7, 80}, {201, 49, 0}} ,{{28, 80}, {222, 49, 0}} ,{{254, 79}, {192, 49, 0}} ,{{27, 80}, {221, 49, 0}} ,{{255, 79}, {193, 49, 0}} ,{{0, 80}, {194, 49, 0}} ,{{171, 67}, {154, 35, 0}} ,{{242, 72}, {65, 41, 0}} ,{{67, 66}, {50, 34, 0}} ,{{164, 71}, {243, 39, 0}} ,{{66, 66}, {49, 34, 0}} ,{{204, 65}, {187, 33, 0}} ,{{200, 65}, {183, 33, 0}} ,{{254, 73}, {77, 42, 0}} ,{{128, 74}, {207, 42, 0}} ,{{130, 74}, {209, 42, 0}} ,{{129, 74}, {208, 42, 0}} ,{{131, 74}, {210, 42, 0}} ,{{253, 73}, {76, 42, 0}} ,{{1, 74}, {80, 42, 0}} ,{{160, 64}, {80, 32, 0}} ,{{205, 69}, {1, 38, 0}} ,{{124, 70}, {176, 38, 0}} ,{{253, 37}, {58, 0, 0}} ,{{101, 66}, {84, 34, 0}} ,{{222, 64}, {161, 32, 0}} ,{{70, 62}, {201, 29, 0}} ,{{68, 62}, {199, 29, 0}} ,{{163, 40}, {1, 3, 0}} ,{{185, 40}, {23, 3, 0}} ,{{227, 40}, {65, 3, 0}} ,{{238, 40}, {76, 3, 0}} ,{{100, 62}, {253, 29, 0}} ,{{13, 65}, {231, 32, 0}} ,{{250, 64}, {212, 32, 0}} ,{{0, 65}, {218, 32, 0}} ,{{22, 65}, {240, 32, 0}} ,{{251, 40}, {89, 3, 0}} ,{{168, 40}, {6, 3, 0}} ,{{72, 62}, {203, 29, 0}} ,{{208, 40}, {46, 3, 0}} ,{{232, 40}, {70, 3, 0}} ,{{204, 40}, {42, 3, 0}} ,{{178, 40}, {16, 3, 0}} ,{{174, 40}, {12, 3, 0}} ,{{206, 40}, {44, 3, 0}} ,{{201, 40}, {39, 3, 0}} ,{{164, 40}, {2, 3, 0}} ,{{207, 40}, {45, 3, 0}} ,{{251, 64}, {213, 32, 0}} ,{{255, 64}, {217, 32, 0}} ,{{181, 40}, {19, 3, 0}} ,{{183, 40}, {21, 3, 0}} ,{{200, 40}, {38, 3, 0}} ,{{206, 140}, {38, 254, 0}} ,{{29, 42}, {133, 4, 0}} ,{{191, 88}, {113, 166, 0}} ,{{32, 42}, {136, 4, 0}} ,{{194, 88}, {124, 166, 0}} ,{{193, 76}, {246, 45, 0}} ,{{171, 76}, {224, 45, 0}} ,{{201, 76}, {254, 45, 0}} ,{{188, 76}, {241, 45, 0}} ,{{174, 76}, {227, 45, 0}} ,{{195, 76}, {248, 45, 0}} ,{{178, 76}, {231, 45, 0}} ,{{179, 76}, {232, 45, 0}} ,{{180, 76}, {233, 45, 0}} ,{{183, 76}, {236, 45, 0}} ,{{184, 76}, {237, 45, 0}} ,{{192, 76}, {245, 45, 0}} ,{{191, 76}, {244, 45, 0}} ,{{173, 76}, {226, 45, 0}} ,{{186, 76}, {239, 45, 0}} ,{{194, 76}, {247, 45, 0}} ,{{199, 76}, {252, 45, 0}} ,{{202, 76}, {255, 45, 0}} ,{{177, 76}, {230, 45, 0}} ,{{200, 76}, {253, 45, 0}} ,{{196, 76}, {249, 45, 0}} ,{{181, 76}, {234, 45, 0}} ,{{182, 76}, {235, 45, 0}} ,{{189, 76}, {242, 45, 0}} ,{{190, 76}, {243, 45, 0}} ,{{185, 76}, {238, 45, 0}} ,{{187, 76}, {240, 45, 0}} ,{{172, 76}, {225, 45, 0}} ,{{197, 76}, {250, 45, 0}} ,{{198, 76}, {251, 45, 0}} ,{{176, 76}, {229, 45, 0}} ,{{175, 76}, {228, 45, 0}} ,{{33, 42}, {137, 4, 0}} ,{{28, 42}, {132, 4, 0}} ,{{195, 88}, {125, 166, 0}} ,{{31, 42}, {135, 4, 0}} ,{{30, 42}, {134, 4, 0}} ,{{190, 88}, {112, 166, 0}} ,{{192, 88}, {114, 166, 0}} ,{{27, 42}, {131, 4, 0}} ,{{189, 88}, {111, 166, 0}} ,{{143, 90}, {232, 168, 0}} ,{{140, 90}, {229, 168, 0}} ,{{139, 90}, {228, 168, 0}} ,{{144, 90}, {233, 168, 0}} ,{{136, 90}, {225, 168, 0}} ,{{142, 90}, {231, 168, 0}} ,{{141, 90}, {230, 168, 0}} ,{{138, 90}, {227, 168, 0}} ,{{137, 90}, {226, 168, 0}} ,{{135, 90}, {224, 168, 0}} ,{{145, 90}, {234, 168, 0}} ,{{147, 90}, {236, 168, 0}} ,{{148, 90}, {237, 168, 0}} ,{{149, 90}, {238, 168, 0}} ,{{150, 90}, {239, 168, 0}} ,{{146, 90}, {235, 168, 0}} ,{{151, 90}, {240, 168, 0}} ,{{152, 90}, {241, 168, 0}} ,{{170, 40}, {8, 3, 0}} ,{{198, 40}, {36, 3, 0}} ,{{62, 62}, {193, 29, 0}} ,{{61, 62}, {192, 29, 0}} ,{{169, 40}, {7, 3, 0}} ,{{250, 40}, {88, 3, 0}} ,{{197, 40}, {35, 3, 0}} ,{{173, 40}, {11, 3, 0}} ,{{255, 40}, {93, 3, 0}} ,{{254, 40}, {92, 3, 0}} ,{{74, 62}, {205, 29, 0}} ,{{177, 40}, {15, 3, 0}} ,{{3, 41}, {97, 3, 0}} ,{{213, 40}, {51, 3, 0}} ,{{0, 41}, {94, 3, 0}} ,{{1, 41}, {95, 3, 0}} ,{{225, 40}, {63, 3, 0}} ,{{4, 41}, {98, 3, 0}} ,{{252, 40}, {90, 3, 0}} ,{{2, 41}, {96, 3, 0}} ,{{202, 140}, {34, 254, 0}} ,{{203, 140}, {35, 254, 0}} ,{{176, 40}, {14, 3, 0}} ,{{234, 40}, {72, 3, 0}} ,{{12, 65}, {230, 32, 0}} ,{{192, 40}, {30, 3, 0}} ,{{3, 65}, {221, 32, 0}} ,{{6, 65}, {224, 32, 0}} ,{{5, 65}, {223, 32, 0}} ,{{9, 65}, {227, 32, 0}} ,{{8, 65}, {226, 32, 0}} ,{{4, 65}, {222, 32, 0}} ,{{10, 65}, {228, 32, 0}} ,{{233, 40}, {71, 3, 0}} ,{{244, 40}, {82, 3, 0}} ,{{2, 65}, {220, 32, 0}} ,{{241, 40}, {79, 3, 0}} ,{{69, 62}, {200, 29, 0}} ,{{66, 62}, {197, 29, 0}} ,{{162, 40}, {0, 3, 0}} ,{{184, 40}, {22, 3, 0}} ,{{226, 40}, {64, 3, 0}} ,{{230, 40}, {68, 3, 0}} ,{{229, 40}, {67, 3, 0}} ,{{188, 157}, {68, 210, 1}} ,{{187, 157}, {67, 210, 1}} ,{{186, 157}, {66, 210, 1}} ,{{228, 40}, {66, 3, 0}} ,{{231, 40}, {69, 3, 0}} ,{{237, 40}, {75, 3, 0}} ,{{171, 40}, {9, 3, 0}} ,{{189, 40}, {27, 3, 0}} ,{{179, 40}, {17, 3, 0}} ,{{209, 40}, {47, 3, 0}} ,{{220, 40}, {58, 3, 0}} ,{{205, 40}, {43, 3, 0}} ,{{77, 62}, {208, 29, 0}} ,{{233, 78}, {154, 48, 0}} ,{{232, 78}, {153, 48, 0}} ,{{88, 62}, {219, 29, 0}} ,{{91, 62}, {222, 29, 0}} ,{{92, 62}, {223, 29, 0}} ,{{94, 62}, {225, 29, 0}} ,{{95, 62}, {226, 29, 0}} ,{{5, 41}, {99, 3, 0}} ,{{81, 62}, {212, 29, 0}} ,{{82, 62}, {213, 29, 0}} ,{{83, 62}, {214, 29, 0}} ,{{10, 41}, {104, 3, 0}} ,{{84, 62}, {215, 29, 0}} ,{{11, 41}, {105, 3, 0}} ,{{6, 41}, {100, 3, 0}} ,{{86, 62}, {217, 29, 0}} ,{{80, 62}, {211, 29, 0}} ,{{87, 62}, {218, 29, 0}} ,{{12, 41}, {106, 3, 0}} ,{{7, 41}, {101, 3, 0}} ,{{85, 62}, {216, 29, 0}} ,{{89, 62}, {220, 29, 0}} ,{{90, 62}, {221, 29, 0}} ,{{98, 62}, {229, 29, 0}} ,{{13, 41}, {107, 3, 0}} ,{{93, 62}, {224, 29, 0}} ,{{8, 41}, {102, 3, 0}} ,{{14, 41}, {108, 3, 0}} ,{{71, 62}, {202, 29, 0}} ,{{96, 62}, {227, 29, 0}} ,{{97, 62}, {228, 29, 0}} ,{{15, 41}, {109, 3, 0}} ,{{9, 41}, {103, 3, 0}} ,{{16, 41}, {110, 3, 0}} ,{{17, 41}, {111, 3, 0}} ,{{99, 62}, {230, 29, 0}} ,{{16, 65}, {234, 32, 0}} ,{{19, 65}, {237, 32, 0}} ,{{188, 40}, {26, 3, 0}} ,{{235, 40}, {73, 3, 0}} ,{{101, 62}, {254, 29, 0}} ,{{246, 40}, {84, 3, 0}} ,{{252, 64}, {214, 32, 0}} ,{{20, 65}, {238, 32, 0}} ,{{243, 40}, {81, 3, 0}} ,{{190, 40}, {28, 3, 0}} ,{{246, 64}, {208, 32, 0}} ,{{7, 65}, {225, 32, 0}} ,{{239, 40}, {77, 3, 0}} ,{{186, 40}, {24, 3, 0}} ,{{200, 140}, {32, 254, 0}} ,{{201, 140}, {33, 254, 0}} ,{{17, 65}, {235, 32, 0}} ,{{218, 40}, {56, 3, 0}} ,{{216, 40}, {54, 3, 0}} ,{{248, 64}, {210, 32, 0}} ,{{212, 40}, {50, 3, 0}} ,{{166, 40}, {4, 3, 0}} ,{{65, 62}, {196, 29, 0}} ,{{73, 62}, {204, 29, 0}} ,{{67, 62}, {198, 29, 0}} ,{{211, 40}, {49, 3, 0}} ,{{204, 140}, {36, 254, 0}} ,{{205, 140}, {37, 254, 0}} ,{{194, 40}, {32, 3, 0}} ,{{236, 40}, {74, 3, 0}} ,{{202, 40}, {40, 3, 0}} ,{{75, 62}, {206, 29, 0}} ,{{167, 40}, {5, 3, 0}} ,{{195, 40}, {33, 3, 0}} ,{{193, 40}, {31, 3, 0}} ,{{196, 40}, {34, 3, 0}} ,{{182, 40}, {20, 3, 0}} ,{{11, 65}, {229, 32, 0}} ,{{18, 65}, {236, 32, 0}} ,{{242, 40}, {80, 3, 0}} ,{{102, 62}, {255, 29, 0}} ,{{248, 40}, {86, 3, 0}} ,{{247, 40}, {85, 3, 0}} ,{{253, 64}, {215, 32, 0}} ,{{21, 65}, {239, 32, 0}} ,{{249, 40}, {87, 3, 0}} ,{{219, 40}, {57, 3, 0}} ,{{247, 64}, {209, 32, 0}} ,{{187, 40}, {25, 3, 0}} ,{{172, 40}, {10, 3, 0}} ,{{199, 40}, {37, 3, 0}} ,{{254, 64}, {216, 32, 0}} ,{{222, 40}, {60, 3, 0}} ,{{217, 40}, {55, 3, 0}} ,{{215, 40}, {53, 3, 0}} ,{{249, 64}, {211, 32, 0}} ,{{63, 62}, {194, 29, 0}} ,{{221, 40}, {59, 3, 0}} ,{{64, 62}, {195, 29, 0}} ,{{1, 65}, {219, 32, 0}} ,{{165, 40}, {3, 3, 0}} ,{{210, 40}, {48, 3, 0}} ,{{214, 40}, {52, 3, 0}} ,{{14, 65}, {232, 32, 0}} ,{{180, 40}, {18, 3, 0}} ,{{240, 40}, {78, 3, 0}} ,{{191, 40}, {29, 3, 0}} ,{{78, 62}, {209, 29, 0}} ,{{79, 62}, {210, 29, 0}} ,{{175, 40}, {13, 3, 0}} ,{{203, 40}, {41, 3, 0}} ,{{224, 40}, {62, 3, 0}} ,{{15, 65}, {233, 32, 0}} ,{{223, 40}, {61, 3, 0}} ,{{245, 40}, {83, 3, 0}} ,{{253, 40}, {91, 3, 0}} ,{{76, 62}, {207, 29, 0}} ,{{208, 69}, {4, 38, 0}} ,{{239, 37}, {44, 0, 0}} ,{{3, 38}, {64, 0, 0}} ,{{162, 64}, {82, 32, 0}} ,{{18, 66}, {1, 34, 0}} ,{{149, 67}, {132, 35, 0}} ,{{30, 74}, {109, 42, 0}} ,{{67, 67}, {50, 35, 0}} ,{{216, 69}, {12, 38, 0}} ,{{28, 66}, {11, 34, 0}} ,{{196, 66}, {179, 34, 0}} ,{{198, 66}, {181, 34, 0}} ,{{11, 67}, {250, 34, 0}} ,{{14, 67}, {253, 34, 0}} ,{{12, 67}, {251, 34, 0}} ,{{146, 67}, {129, 35, 0}} ,{{63, 66}, {46, 34, 0}} ,{{206, 75}, {200, 44, 0}} ,{{134, 75}, {128, 44, 0}} ,{{200, 75}, {194, 44, 0}} ,{{188, 75}, {182, 44, 0}} ,{{243, 75}, {237, 44, 0}} ,{{194, 75}, {188, 44, 0}} ,{{241, 75}, {235, 44, 0}} ,{{140, 75}, {134, 44, 0}} ,{{134, 41}, {238, 3, 0}} ,{{184, 75}, {178, 44, 0}} ,{{208, 75}, {202, 44, 0}} ,{{190, 75}, {184, 44, 0}} ,{{192, 75}, {186, 44, 0}} ,{{142, 75}, {136, 44, 0}} ,{{124, 41}, {228, 3, 0}} ,{{176, 75}, {170, 44, 0}} ,{{138, 75}, {132, 44, 0}} ,{{130, 41}, {234, 3, 0}} ,{{148, 75}, {142, 44, 0}} ,{{128, 41}, {232, 3, 0}} ,{{152, 75}, {146, 44, 0}} ,{{154, 75}, {148, 44, 0}} ,{{126, 41}, {230, 3, 0}} ,{{178, 75}, {172, 44, 0}} ,{{162, 75}, {156, 44, 0}} ,{{214, 75}, {208, 44, 0}} ,{{156, 75}, {150, 44, 0}} ,{{158, 75}, {152, 44, 0}} ,{{160, 75}, {154, 44, 0}} ,{{164, 75}, {158, 44, 0}} ,{{186, 75}, {180, 44, 0}} ,{{222, 75}, {216, 44, 0}} ,{{204, 75}, {198, 44, 0}} ,{{220, 75}, {214, 44, 0}} ,{{212, 75}, {206, 44, 0}} ,{{218, 75}, {212, 44, 0}} ,{{216, 75}, {210, 44, 0}} ,{{210, 75}, {204, 44, 0}} ,{{196, 75}, {190, 44, 0}} ,{{202, 75}, {196, 44, 0}} ,{{224, 75}, {218, 44, 0}} ,{{228, 75}, {222, 44, 0}} ,{{230, 75}, {224, 44, 0}} ,{{226, 75}, {220, 44, 0}} ,{{232, 75}, {226, 44, 0}} ,{{182, 75}, {176, 44, 0}} ,{{166, 75}, {160, 44, 0}} ,{{180, 75}, {174, 44, 0}} ,{{168, 75}, {162, 44, 0}} ,{{198, 75}, {192, 44, 0}} ,{{122, 41}, {226, 3, 0}} ,{{132, 41}, {236, 3, 0}} ,{{170, 75}, {164, 44, 0}} ,{{144, 75}, {138, 44, 0}} ,{{172, 75}, {166, 44, 0}} ,{{150, 75}, {144, 44, 0}} ,{{174, 75}, {168, 44, 0}} ,{{136, 75}, {130, 44, 0}} ,{{146, 75}, {140, 44, 0}} ,{{245, 75}, {239, 44, 0}} ,{{246, 75}, {240, 44, 0}} ,{{247, 75}, {241, 44, 0}} ,{{252, 75}, {253, 44, 0}} ,{{253, 75}, {254, 44, 0}} ,{{254, 75}, {255, 44, 0}} ,{{249, 75}, {250, 44, 0}} ,{{248, 75}, {249, 44, 0}} ,{{250, 75}, {251, 44, 0}} ,{{251, 75}, {252, 44, 0}} ,{{207, 75}, {201, 44, 0}} ,{{135, 75}, {129, 44, 0}} ,{{201, 75}, {195, 44, 0}} ,{{189, 75}, {183, 44, 0}} ,{{244, 75}, {238, 44, 0}} ,{{195, 75}, {189, 44, 0}} ,{{242, 75}, {236, 44, 0}} ,{{141, 75}, {135, 44, 0}} ,{{135, 41}, {239, 3, 0}} ,{{185, 75}, {179, 44, 0}} ,{{209, 75}, {203, 44, 0}} ,{{191, 75}, {185, 44, 0}} ,{{193, 75}, {187, 44, 0}} ,{{143, 75}, {137, 44, 0}} ,{{125, 41}, {229, 3, 0}} ,{{177, 75}, {171, 44, 0}} ,{{139, 75}, {133, 44, 0}} ,{{131, 41}, {235, 3, 0}} ,{{149, 75}, {143, 44, 0}} ,{{129, 41}, {233, 3, 0}} ,{{153, 75}, {147, 44, 0}} ,{{155, 75}, {149, 44, 0}} ,{{127, 41}, {231, 3, 0}} ,{{179, 75}, {173, 44, 0}} ,{{163, 75}, {157, 44, 0}} ,{{215, 75}, {209, 44, 0}} ,{{157, 75}, {151, 44, 0}} ,{{159, 75}, {153, 44, 0}} ,{{161, 75}, {155, 44, 0}} ,{{165, 75}, {159, 44, 0}} ,{{187, 75}, {181, 44, 0}} ,{{223, 75}, {217, 44, 0}} ,{{205, 75}, {199, 44, 0}} ,{{221, 75}, {215, 44, 0}} ,{{213, 75}, {207, 44, 0}} ,{{219, 75}, {213, 44, 0}} ,{{217, 75}, {211, 44, 0}} ,{{211, 75}, {205, 44, 0}} ,{{197, 75}, {191, 44, 0}} ,{{203, 75}, {197, 44, 0}} ,{{225, 75}, {219, 44, 0}} ,{{229, 75}, {223, 44, 0}} ,{{231, 75}, {225, 44, 0}} ,{{227, 75}, {221, 44, 0}} ,{{233, 75}, {227, 44, 0}} ,{{183, 75}, {177, 44, 0}} ,{{167, 75}, {161, 44, 0}} ,{{181, 75}, {175, 44, 0}} ,{{169, 75}, {163, 44, 0}} ,{{199, 75}, {193, 44, 0}} ,{{123, 41}, {227, 3, 0}} ,{{133, 41}, {237, 3, 0}} ,{{171, 75}, {165, 44, 0}} ,{{145, 75}, {139, 44, 0}} ,{{173, 75}, {167, 44, 0}} ,{{151, 75}, {145, 44, 0}} ,{{175, 75}, {169, 44, 0}} ,{{137, 75}, {131, 44, 0}} ,{{147, 75}, {141, 44, 0}} ,{{234, 75}, {228, 44, 0}} ,{{239, 75}, {233, 44, 0}} ,{{235, 75}, {229, 44, 0}} ,{{236, 75}, {230, 44, 0}} ,{{240, 75}, {234, 44, 0}} ,{{237, 75}, {231, 44, 0}} ,{{238, 75}, {232, 44, 0}} ,{{75, 38}, {169, 0, 0}} ,{{105, 66}, {88, 34, 0}} ,{{69, 67}, {52, 35, 0}} ,{{70, 67}, {53, 35, 0}} ,{{37, 158}, {112, 211, 1}} ,{{34, 158}, {109, 211, 1}} ,{{33, 158}, {108, 211, 1}} ,{{38, 158}, {113, 211, 1}} ,{{30, 158}, {105, 211, 1}} ,{{36, 158}, {111, 211, 1}} ,{{35, 158}, {110, 211, 1}} ,{{32, 158}, {107, 211, 1}} ,{{31, 158}, {106, 211, 1}} ,{{28, 158}, {103, 211, 1}} ,{{25, 158}, {100, 211, 1}} ,{{24, 158}, {99, 211, 1}} ,{{29, 158}, {104, 211, 1}} ,{{21, 158}, {96, 211, 1}} ,{{27, 158}, {102, 211, 1}} ,{{26, 158}, {101, 211, 1}} ,{{23, 158}, {98, 211, 1}} ,{{22, 158}, {97, 211, 1}} ,{{213, 162}, {138, 241, 1}} ,{{96, 70}, {148, 38, 0}} ,{{152, 70}, {204, 38, 0}} ,{{245, 69}, {41, 38, 0}} ,{{244, 69}, {40, 38, 0}} ,{{223, 64}, {162, 32, 0}} ,{{44, 66}, {27, 34, 0}} ,{{22, 151}, {6, 36, 1}} ,{{29, 151}, {13, 36, 1}} ,{{44, 151}, {28, 36, 1}} ,{{58, 151}, {42, 36, 1}} ,{{35, 151}, {19, 36, 1}} ,{{84, 151}, {68, 36, 1}} ,{{85, 151}, {69, 36, 1}} ,{{19, 151}, {3, 36, 1}} ,{{93, 151}, {77, 36, 1}} ,{{100, 151}, {84, 36, 1}} ,{{101, 151}, {85, 36, 1}} ,{{73, 151}, {57, 36, 1}} ,{{26, 151}, {10, 36, 1}} ,{{41, 151}, {25, 36, 1}} ,{{50, 151}, {34, 36, 1}} ,{{55, 151}, {39, 36, 1}} ,{{65, 151}, {49, 36, 1}} ,{{108, 151}, {92, 36, 1}} ,{{32, 151}, {16, 36, 1}} ,{{18, 151}, {2, 36, 1}} ,{{92, 151}, {76, 36, 1}} ,{{98, 151}, {82, 36, 1}} ,{{99, 151}, {83, 36, 1}} ,{{72, 151}, {56, 36, 1}} ,{{25, 151}, {9, 36, 1}} ,{{40, 151}, {24, 36, 1}} ,{{49, 151}, {33, 36, 1}} ,{{54, 151}, {38, 36, 1}} ,{{64, 151}, {48, 36, 1}} ,{{31, 151}, {15, 36, 1}} ,{{76, 151}, {60, 36, 1}} ,{{77, 151}, {61, 36, 1}} ,{{78, 151}, {62, 36, 1}} ,{{79, 151}, {63, 36, 1}} ,{{103, 151}, {87, 36, 1}} ,{{102, 151}, {86, 36, 1}} ,{{23, 151}, {7, 36, 1}} ,{{30, 151}, {14, 36, 1}} ,{{45, 151}, {29, 36, 1}} ,{{59, 151}, {43, 36, 1}} ,{{36, 151}, {20, 36, 1}} ,{{86, 151}, {70, 36, 1}} ,{{87, 151}, {71, 36, 1}} ,{{88, 151}, {72, 36, 1}} ,{{89, 151}, {73, 36, 1}} ,{{114, 151}, {98, 36, 1}} ,{{113, 151}, {97, 36, 1}} ,{{95, 151}, {79, 36, 1}} ,{{68, 151}, {52, 36, 1}} ,{{111, 151}, {95, 36, 1}} ,{{104, 151}, {88, 36, 1}} ,{{37, 151}, {21, 36, 1}} ,{{46, 151}, {30, 36, 1}} ,{{112, 151}, {96, 36, 1}} ,{{60, 151}, {44, 36, 1}} ,{{106, 151}, {90, 36, 1}} ,{{109, 151}, {93, 36, 1}} ,{{21, 151}, {5, 36, 1}} ,{{28, 151}, {12, 36, 1}} ,{{43, 151}, {27, 36, 1}} ,{{57, 151}, {41, 36, 1}} ,{{34, 151}, {18, 36, 1}} ,{{81, 151}, {65, 36, 1}} ,{{82, 151}, {66, 36, 1}} ,{{83, 151}, {67, 36, 1}} ,{{66, 151}, {50, 36, 1}} ,{{67, 151}, {51, 36, 1}} ,{{20, 151}, {4, 36, 1}} ,{{94, 151}, {78, 36, 1}} ,{{27, 151}, {11, 36, 1}} ,{{42, 151}, {26, 36, 1}} ,{{56, 151}, {40, 36, 1}} ,{{33, 151}, {17, 36, 1}} ,{{80, 151}, {64, 36, 1}} ,{{17, 151}, {1, 36, 1}} ,{{91, 151}, {75, 36, 1}} ,{{97, 151}, {81, 36, 1}} ,{{70, 151}, {54, 36, 1}} ,{{71, 151}, {55, 36, 1}} ,{{24, 151}, {8, 36, 1}} ,{{39, 151}, {23, 36, 1}} ,{{48, 151}, {32, 36, 1}} ,{{52, 151}, {36, 36, 1}} ,{{53, 151}, {37, 36, 1}} ,{{62, 151}, {46, 36, 1}} ,{{63, 151}, {47, 36, 1}} ,{{74, 151}, {58, 36, 1}} ,{{75, 151}, {59, 36, 1}} ,{{16, 151}, {0, 36, 1}} ,{{90, 151}, {74, 36, 1}} ,{{96, 151}, {80, 36, 1}} ,{{69, 151}, {53, 36, 1}} ,{{105, 151}, {89, 36, 1}} ,{{38, 151}, {22, 36, 1}} ,{{47, 151}, {31, 36, 1}} ,{{51, 151}, {35, 36, 1}} ,{{61, 151}, {45, 36, 1}} ,{{107, 151}, {91, 36, 1}} ,{{110, 151}, {94, 36, 1}} ,{{117, 151}, {114, 36, 1}} ,{{118, 151}, {115, 36, 1}} ,{{115, 151}, {112, 36, 1}} ,{{116, 151}, {113, 36, 1}} ,{{161, 147}, {0, 32, 1}} ,{{170, 147}, {9, 32, 1}} ,{{171, 147}, {10, 32, 1}} ,{{183, 147}, {22, 32, 1}} ,{{184, 147}, {23, 32, 1}} ,{{185, 147}, {24, 32, 1}} ,{{186, 147}, {25, 32, 1}} ,{{187, 147}, {26, 32, 1}} ,{{188, 147}, {27, 32, 1}} ,{{182, 147}, {21, 32, 1}} ,{{172, 147}, {11, 32, 1}} ,{{173, 147}, {12, 32, 1}} ,{{174, 147}, {13, 32, 1}} ,{{175, 147}, {14, 32, 1}} ,{{176, 147}, {15, 32, 1}} ,{{177, 147}, {16, 32, 1}} ,{{178, 147}, {17, 32, 1}} ,{{179, 147}, {18, 32, 1}} ,{{180, 147}, {19, 32, 1}} ,{{181, 147}, {20, 32, 1}} ,{{189, 147}, {28, 32, 1}} ,{{190, 147}, {29, 32, 1}} ,{{191, 147}, {30, 32, 1}} ,{{192, 147}, {31, 32, 1}} ,{{193, 147}, {32, 32, 1}} ,{{202, 147}, {41, 32, 1}} ,{{203, 147}, {42, 32, 1}} ,{{194, 147}, {33, 32, 1}} ,{{195, 147}, {34, 32, 1}} ,{{196, 147}, {35, 32, 1}} ,{{197, 147}, {36, 32, 1}} ,{{198, 147}, {37, 32, 1}} ,{{199, 147}, {38, 32, 1}} ,{{200, 147}, {39, 32, 1}} ,{{201, 147}, {40, 32, 1}} ,{{204, 147}, {43, 32, 1}} ,{{205, 147}, {44, 32, 1}} ,{{206, 147}, {45, 32, 1}} ,{{211, 147}, {50, 32, 1}} ,{{207, 147}, {46, 32, 1}} ,{{209, 147}, {48, 32, 1}} ,{{210, 147}, {49, 32, 1}} ,{{208, 147}, {47, 32, 1}} ,{{212, 147}, {51, 32, 1}} ,{{213, 147}, {52, 32, 1}} ,{{214, 147}, {53, 32, 1}} ,{{215, 147}, {54, 32, 1}} ,{{216, 147}, {55, 32, 1}} ,{{217, 147}, {56, 32, 1}} ,{{223, 147}, {62, 32, 1}} ,{{224, 147}, {63, 32, 1}} ,{{219, 147}, {58, 32, 1}} ,{{221, 147}, {60, 32, 1}} ,{{222, 147}, {61, 32, 1}} ,{{220, 147}, {59, 32, 1}} ,{{218, 147}, {57, 32, 1}} ,{{162, 147}, {1, 32, 1}} ,{{163, 147}, {2, 32, 1}} ,{{164, 147}, {3, 32, 1}} ,{{165, 147}, {4, 32, 1}} ,{{166, 147}, {5, 32, 1}} ,{{167, 147}, {6, 32, 1}} ,{{168, 147}, {7, 32, 1}} ,{{169, 147}, {8, 32, 1}} ,{{225, 147}, {64, 32, 1}} ,{{226, 147}, {65, 32, 1}} ,{{227, 147}, {66, 32, 1}} ,{{228, 147}, {67, 32, 1}} ,{{229, 147}, {68, 32, 1}} ,{{231, 147}, {70, 32, 1}} ,{{230, 147}, {69, 32, 1}} ,{{232, 147}, {71, 32, 1}} ,{{233, 147}, {72, 32, 1}} ,{{234, 147}, {73, 32, 1}} ,{{235, 147}, {74, 32, 1}} ,{{236, 147}, {75, 32, 1}} ,{{237, 147}, {76, 32, 1}} ,{{238, 147}, {77, 32, 1}} ,{{242, 147}, {81, 32, 1}} ,{{243, 147}, {82, 32, 1}} ,{{244, 147}, {83, 32, 1}} ,{{245, 147}, {84, 32, 1}} ,{{241, 147}, {80, 32, 1}} ,{{239, 147}, {78, 32, 1}} ,{{240, 147}, {79, 32, 1}} ,{{246, 147}, {85, 32, 1}} ,{{247, 147}, {86, 32, 1}} ,{{249, 147}, {88, 32, 1}} ,{{248, 147}, {87, 32, 1}} ,{{250, 147}, {89, 32, 1}} ,{{251, 147}, {90, 32, 1}} ,{{252, 147}, {91, 32, 1}} ,{{253, 147}, {92, 32, 1}} ,{{254, 147}, {93, 32, 1}} ,{{255, 147}, {94, 32, 1}} ,{{0, 148}, {95, 32, 1}} ,{{1, 148}, {96, 32, 1}} ,{{2, 148}, {97, 32, 1}} ,{{3, 148}, {98, 32, 1}} ,{{4, 148}, {99, 32, 1}} ,{{5, 148}, {100, 32, 1}} ,{{6, 148}, {101, 32, 1}} ,{{8, 148}, {103, 32, 1}} ,{{7, 148}, {102, 32, 1}} ,{{9, 148}, {104, 32, 1}} ,{{10, 148}, {105, 32, 1}} ,{{11, 148}, {106, 32, 1}} ,{{12, 148}, {107, 32, 1}} ,{{13, 148}, {108, 32, 1}} ,{{14, 148}, {109, 32, 1}} ,{{15, 148}, {110, 32, 1}} ,{{16, 148}, {111, 32, 1}} ,{{17, 148}, {112, 32, 1}} ,{{18, 148}, {113, 32, 1}} ,{{19, 148}, {114, 32, 1}} ,{{20, 148}, {115, 32, 1}} ,{{21, 148}, {116, 32, 1}} ,{{23, 148}, {118, 32, 1}} ,{{22, 148}, {117, 32, 1}} ,{{24, 148}, {119, 32, 1}} ,{{25, 148}, {120, 32, 1}} ,{{26, 148}, {121, 32, 1}} ,{{27, 148}, {122, 32, 1}} ,{{31, 148}, {126, 32, 1}} ,{{33, 148}, {128, 32, 1}} ,{{32, 148}, {127, 32, 1}} ,{{34, 148}, {129, 32, 1}} ,{{35, 148}, {130, 32, 1}} ,{{36, 148}, {131, 32, 1}} ,{{37, 148}, {132, 32, 1}} ,{{38, 148}, {133, 32, 1}} ,{{39, 148}, {134, 32, 1}} ,{{40, 148}, {135, 32, 1}} ,{{41, 148}, {136, 32, 1}} ,{{42, 148}, {137, 32, 1}} ,{{29, 148}, {124, 32, 1}} ,{{28, 148}, {123, 32, 1}} ,{{30, 148}, {125, 32, 1}} ,{{43, 148}, {138, 32, 1}} ,{{46, 148}, {141, 32, 1}} ,{{47, 148}, {142, 32, 1}} ,{{48, 148}, {143, 32, 1}} ,{{49, 148}, {144, 32, 1}} ,{{50, 148}, {145, 32, 1}} ,{{51, 148}, {146, 32, 1}} ,{{52, 148}, {147, 32, 1}} ,{{53, 148}, {148, 32, 1}} ,{{54, 148}, {149, 32, 1}} ,{{55, 148}, {150, 32, 1}} ,{{56, 148}, {151, 32, 1}} ,{{60, 148}, {155, 32, 1}} ,{{61, 148}, {156, 32, 1}} ,{{62, 148}, {157, 32, 1}} ,{{57, 148}, {152, 32, 1}} ,{{58, 148}, {153, 32, 1}} ,{{59, 148}, {154, 32, 1}} ,{{63, 148}, {158, 32, 1}} ,{{64, 148}, {159, 32, 1}} ,{{65, 148}, {160, 32, 1}} ,{{66, 148}, {161, 32, 1}} ,{{67, 148}, {162, 32, 1}} ,{{70, 148}, {165, 32, 1}} ,{{68, 148}, {163, 32, 1}} ,{{69, 148}, {164, 32, 1}} ,{{71, 148}, {166, 32, 1}} ,{{72, 148}, {167, 32, 1}} ,{{73, 148}, {168, 32, 1}} ,{{74, 148}, {169, 32, 1}} ,{{75, 148}, {170, 32, 1}} ,{{76, 148}, {171, 32, 1}} ,{{77, 148}, {172, 32, 1}} ,{{78, 148}, {173, 32, 1}} ,{{79, 148}, {174, 32, 1}} ,{{80, 148}, {175, 32, 1}} ,{{81, 148}, {176, 32, 1}} ,{{82, 148}, {177, 32, 1}} ,{{83, 148}, {178, 32, 1}} ,{{84, 148}, {179, 32, 1}} ,{{85, 148}, {180, 32, 1}} ,{{45, 148}, {140, 32, 1}} ,{{44, 148}, {139, 32, 1}} ,{{86, 148}, {181, 32, 1}} ,{{88, 148}, {183, 32, 1}} ,{{142, 148}, {237, 32, 1}} ,{{92, 148}, {187, 32, 1}} ,{{93, 148}, {188, 32, 1}} ,{{94, 148}, {189, 32, 1}} ,{{95, 148}, {190, 32, 1}} ,{{89, 148}, {184, 32, 1}} ,{{90, 148}, {185, 32, 1}} ,{{91, 148}, {186, 32, 1}} ,{{96, 148}, {191, 32, 1}} ,{{97, 148}, {192, 32, 1}} ,{{98, 148}, {193, 32, 1}} ,{{99, 148}, {194, 32, 1}} ,{{100, 148}, {195, 32, 1}} ,{{101, 148}, {196, 32, 1}} ,{{102, 148}, {197, 32, 1}} ,{{103, 148}, {198, 32, 1}} ,{{104, 148}, {199, 32, 1}} ,{{105, 148}, {200, 32, 1}} ,{{106, 148}, {201, 32, 1}} ,{{107, 148}, {202, 32, 1}} ,{{108, 148}, {203, 32, 1}} ,{{109, 148}, {204, 32, 1}} ,{{110, 148}, {205, 32, 1}} ,{{111, 148}, {206, 32, 1}} ,{{112, 148}, {207, 32, 1}} ,{{113, 148}, {208, 32, 1}} ,{{115, 148}, {210, 32, 1}} ,{{116, 148}, {211, 32, 1}} ,{{114, 148}, {209, 32, 1}} ,{{117, 148}, {212, 32, 1}} ,{{118, 148}, {213, 32, 1}} ,{{119, 148}, {214, 32, 1}} ,{{120, 148}, {215, 32, 1}} ,{{121, 148}, {216, 32, 1}} ,{{122, 148}, {217, 32, 1}} ,{{123, 148}, {218, 32, 1}} ,{{124, 148}, {219, 32, 1}} ,{{125, 148}, {220, 32, 1}} ,{{126, 148}, {221, 32, 1}} ,{{127, 148}, {222, 32, 1}} ,{{128, 148}, {223, 32, 1}} ,{{129, 148}, {224, 32, 1}} ,{{130, 148}, {225, 32, 1}} ,{{131, 148}, {226, 32, 1}} ,{{132, 148}, {227, 32, 1}} ,{{133, 148}, {228, 32, 1}} ,{{134, 148}, {229, 32, 1}} ,{{135, 148}, {230, 32, 1}} ,{{136, 148}, {231, 32, 1}} ,{{137, 148}, {232, 32, 1}} ,{{138, 148}, {233, 32, 1}} ,{{139, 148}, {234, 32, 1}} ,{{140, 148}, {235, 32, 1}} ,{{141, 148}, {236, 32, 1}} ,{{143, 148}, {238, 32, 1}} ,{{144, 148}, {239, 32, 1}} ,{{145, 148}, {240, 32, 1}} ,{{146, 148}, {241, 32, 1}} ,{{147, 148}, {242, 32, 1}} ,{{149, 148}, {244, 32, 1}} ,{{148, 148}, {243, 32, 1}} ,{{150, 148}, {245, 32, 1}} ,{{151, 148}, {246, 32, 1}} ,{{152, 148}, {247, 32, 1}} ,{{155, 148}, {250, 32, 1}} ,{{154, 148}, {249, 32, 1}} ,{{153, 148}, {248, 32, 1}} ,{{156, 148}, {251, 32, 1}} ,{{157, 148}, {252, 32, 1}} ,{{158, 148}, {253, 32, 1}} ,{{87, 148}, {182, 32, 1}} ,{{159, 148}, {254, 32, 1}} ,{{160, 148}, {255, 32, 1}} ,{{161, 148}, {0, 33, 1}} ,{{165, 148}, {4, 33, 1}} ,{{167, 148}, {6, 33, 1}} ,{{166, 148}, {5, 33, 1}} ,{{168, 148}, {7, 33, 1}} ,{{169, 148}, {8, 33, 1}} ,{{170, 148}, {9, 33, 1}} ,{{171, 148}, {10, 33, 1}} ,{{172, 148}, {11, 33, 1}} ,{{173, 148}, {12, 33, 1}} ,{{174, 148}, {13, 33, 1}} ,{{175, 148}, {14, 33, 1}} ,{{176, 148}, {15, 33, 1}} ,{{177, 148}, {16, 33, 1}} ,{{178, 148}, {17, 33, 1}} ,{{179, 148}, {18, 33, 1}} ,{{182, 148}, {21, 33, 1}} ,{{180, 148}, {19, 33, 1}} ,{{181, 148}, {20, 33, 1}} ,{{164, 148}, {3, 33, 1}} ,{{162, 148}, {1, 33, 1}} ,{{163, 148}, {2, 33, 1}} ,{{183, 148}, {22, 33, 1}} ,{{185, 148}, {24, 33, 1}} ,{{190, 148}, {29, 33, 1}} ,{{186, 148}, {25, 33, 1}} ,{{187, 148}, {26, 33, 1}} ,{{188, 148}, {27, 33, 1}} ,{{189, 148}, {28, 33, 1}} ,{{191, 148}, {30, 33, 1}} ,{{194, 148}, {33, 33, 1}} ,{{192, 148}, {31, 33, 1}} ,{{193, 148}, {32, 33, 1}} ,{{195, 148}, {34, 33, 1}} ,{{196, 148}, {35, 33, 1}} ,{{197, 148}, {36, 33, 1}} ,{{198, 148}, {37, 33, 1}} ,{{199, 148}, {38, 33, 1}} ,{{200, 148}, {39, 33, 1}} ,{{201, 148}, {40, 33, 1}} ,{{184, 148}, {23, 33, 1}} ,{{202, 148}, {41, 33, 1}} ,{{205, 148}, {44, 33, 1}} ,{{204, 148}, {43, 33, 1}} ,{{203, 148}, {42, 33, 1}} ,{{206, 148}, {45, 33, 1}} ,{{207, 148}, {46, 33, 1}} ,{{208, 148}, {47, 33, 1}} ,{{209, 148}, {48, 33, 1}} ,{{210, 148}, {49, 33, 1}} ,{{211, 148}, {50, 33, 1}} ,{{212, 148}, {51, 33, 1}} ,{{213, 148}, {52, 33, 1}} ,{{214, 148}, {53, 33, 1}} ,{{215, 148}, {54, 33, 1}} ,{{216, 148}, {55, 33, 1}} ,{{217, 148}, {56, 33, 1}} ,{{218, 148}, {57, 33, 1}} ,{{219, 148}, {58, 33, 1}} ,{{220, 148}, {59, 33, 1}} ,{{221, 148}, {60, 33, 1}} ,{{222, 148}, {61, 33, 1}} ,{{223, 148}, {62, 33, 1}} ,{{224, 148}, {63, 33, 1}} ,{{226, 148}, {65, 33, 1}} ,{{227, 148}, {66, 33, 1}} ,{{228, 148}, {67, 33, 1}} ,{{229, 148}, {68, 33, 1}} ,{{230, 148}, {69, 33, 1}} ,{{231, 148}, {70, 33, 1}} ,{{232, 148}, {71, 33, 1}} ,{{235, 148}, {74, 33, 1}} ,{{234, 148}, {73, 33, 1}} ,{{233, 148}, {72, 33, 1}} ,{{236, 148}, {75, 33, 1}} ,{{238, 148}, {77, 33, 1}} ,{{237, 148}, {76, 33, 1}} ,{{239, 148}, {78, 33, 1}} ,{{244, 148}, {83, 33, 1}} ,{{241, 148}, {80, 33, 1}} ,{{242, 148}, {81, 33, 1}} ,{{243, 148}, {82, 33, 1}} ,{{240, 148}, {79, 33, 1}} ,{{245, 148}, {84, 33, 1}} ,{{246, 148}, {85, 33, 1}} ,{{247, 148}, {86, 33, 1}} ,{{225, 148}, {64, 33, 1}} ,{{248, 148}, {87, 33, 1}} ,{{46, 149}, {141, 33, 1}} ,{{47, 149}, {142, 33, 1}} ,{{48, 149}, {143, 33, 1}} ,{{49, 149}, {144, 33, 1}} ,{{50, 149}, {145, 33, 1}} ,{{51, 149}, {146, 33, 1}} ,{{52, 149}, {147, 33, 1}} ,{{53, 149}, {148, 33, 1}} ,{{54, 149}, {149, 33, 1}} ,{{55, 149}, {150, 33, 1}} ,{{56, 149}, {151, 33, 1}} ,{{58, 149}, {153, 33, 1}} ,{{57, 149}, {152, 33, 1}} ,{{59, 149}, {154, 33, 1}} ,{{60, 149}, {155, 33, 1}} ,{{61, 149}, {156, 33, 1}} ,{{62, 149}, {157, 33, 1}} ,{{63, 149}, {158, 33, 1}} ,{{249, 148}, {88, 33, 1}} ,{{250, 148}, {89, 33, 1}} ,{{251, 148}, {90, 33, 1}} ,{{252, 148}, {91, 33, 1}} ,{{253, 148}, {92, 33, 1}} ,{{254, 148}, {93, 33, 1}} ,{{255, 148}, {94, 33, 1}} ,{{0, 149}, {95, 33, 1}} ,{{1, 149}, {96, 33, 1}} ,{{2, 149}, {97, 33, 1}} ,{{3, 149}, {98, 33, 1}} ,{{4, 149}, {99, 33, 1}} ,{{5, 149}, {100, 33, 1}} ,{{6, 149}, {101, 33, 1}} ,{{7, 149}, {102, 33, 1}} ,{{8, 149}, {103, 33, 1}} ,{{9, 149}, {104, 33, 1}} ,{{11, 149}, {106, 33, 1}} ,{{10, 149}, {105, 33, 1}} ,{{12, 149}, {107, 33, 1}} ,{{13, 149}, {108, 33, 1}} ,{{14, 149}, {109, 33, 1}} ,{{15, 149}, {110, 33, 1}} ,{{16, 149}, {111, 33, 1}} ,{{17, 149}, {112, 33, 1}} ,{{18, 149}, {113, 33, 1}} ,{{19, 149}, {114, 33, 1}} ,{{20, 149}, {115, 33, 1}} ,{{21, 149}, {116, 33, 1}} ,{{22, 149}, {117, 33, 1}} ,{{23, 149}, {118, 33, 1}} ,{{24, 149}, {119, 33, 1}} ,{{25, 149}, {120, 33, 1}} ,{{26, 149}, {121, 33, 1}} ,{{27, 149}, {122, 33, 1}} ,{{28, 149}, {123, 33, 1}} ,{{29, 149}, {124, 33, 1}} ,{{30, 149}, {125, 33, 1}} ,{{31, 149}, {126, 33, 1}} ,{{32, 149}, {127, 33, 1}} ,{{33, 149}, {128, 33, 1}} ,{{34, 149}, {129, 33, 1}} ,{{35, 149}, {130, 33, 1}} ,{{36, 149}, {131, 33, 1}} ,{{37, 149}, {132, 33, 1}} ,{{38, 149}, {133, 33, 1}} ,{{39, 149}, {134, 33, 1}} ,{{40, 149}, {135, 33, 1}} ,{{41, 149}, {136, 33, 1}} ,{{42, 149}, {137, 33, 1}} ,{{43, 149}, {138, 33, 1}} ,{{44, 149}, {139, 33, 1}} ,{{45, 149}, {140, 33, 1}} ,{{64, 149}, {159, 33, 1}} ,{{65, 149}, {160, 33, 1}} ,{{69, 149}, {164, 33, 1}} ,{{70, 149}, {165, 33, 1}} ,{{71, 149}, {166, 33, 1}} ,{{72, 149}, {167, 33, 1}} ,{{73, 149}, {168, 33, 1}} ,{{74, 149}, {169, 33, 1}} ,{{66, 149}, {161, 33, 1}} ,{{67, 149}, {162, 33, 1}} ,{{68, 149}, {163, 33, 1}} ,{{75, 149}, {170, 33, 1}} ,{{77, 149}, {172, 33, 1}} ,{{78, 149}, {173, 33, 1}} ,{{79, 149}, {174, 33, 1}} ,{{80, 149}, {175, 33, 1}} ,{{81, 149}, {176, 33, 1}} ,{{82, 149}, {177, 33, 1}} ,{{83, 149}, {178, 33, 1}} ,{{84, 149}, {179, 33, 1}} ,{{85, 149}, {180, 33, 1}} ,{{86, 149}, {181, 33, 1}} ,{{76, 149}, {171, 33, 1}} ,{{87, 149}, {182, 33, 1}} ,{{88, 149}, {183, 33, 1}} ,{{89, 149}, {184, 33, 1}} ,{{140, 149}, {235, 33, 1}} ,{{90, 149}, {185, 33, 1}} ,{{94, 149}, {189, 33, 1}} ,{{95, 149}, {190, 33, 1}} ,{{96, 149}, {191, 33, 1}} ,{{91, 149}, {186, 33, 1}} ,{{92, 149}, {187, 33, 1}} ,{{93, 149}, {188, 33, 1}} ,{{97, 149}, {192, 33, 1}} ,{{98, 149}, {193, 33, 1}} ,{{99, 149}, {194, 33, 1}} ,{{100, 149}, {195, 33, 1}} ,{{101, 149}, {196, 33, 1}} ,{{102, 149}, {197, 33, 1}} ,{{103, 149}, {198, 33, 1}} ,{{104, 149}, {199, 33, 1}} ,{{105, 149}, {200, 33, 1}} ,{{106, 149}, {201, 33, 1}} ,{{107, 149}, {202, 33, 1}} ,{{108, 149}, {203, 33, 1}} ,{{109, 149}, {204, 33, 1}} ,{{110, 149}, {205, 33, 1}} ,{{111, 149}, {206, 33, 1}} ,{{112, 149}, {207, 33, 1}} ,{{113, 149}, {208, 33, 1}} ,{{114, 149}, {209, 33, 1}} ,{{115, 149}, {210, 33, 1}} ,{{116, 149}, {211, 33, 1}} ,{{117, 149}, {212, 33, 1}} ,{{118, 149}, {213, 33, 1}} ,{{119, 149}, {214, 33, 1}} ,{{120, 149}, {215, 33, 1}} ,{{121, 149}, {216, 33, 1}} ,{{122, 149}, {217, 33, 1}} ,{{123, 149}, {218, 33, 1}} ,{{124, 149}, {219, 33, 1}} ,{{125, 149}, {220, 33, 1}} ,{{126, 149}, {221, 33, 1}} ,{{127, 149}, {222, 33, 1}} ,{{128, 149}, {223, 33, 1}} ,{{129, 149}, {224, 33, 1}} ,{{130, 149}, {225, 33, 1}} ,{{131, 149}, {226, 33, 1}} ,{{132, 149}, {227, 33, 1}} ,{{133, 149}, {228, 33, 1}} ,{{134, 149}, {229, 33, 1}} ,{{137, 149}, {232, 33, 1}} ,{{138, 149}, {233, 33, 1}} ,{{139, 149}, {234, 33, 1}} ,{{135, 149}, {230, 33, 1}} ,{{136, 149}, {231, 33, 1}} ,{{141, 149}, {236, 33, 1}} ,{{144, 149}, {239, 33, 1}} ,{{145, 149}, {240, 33, 1}} ,{{142, 149}, {237, 33, 1}} ,{{143, 149}, {238, 33, 1}} ,{{146, 149}, {241, 33, 1}} ,{{147, 149}, {242, 33, 1}} ,{{148, 149}, {243, 33, 1}} ,{{149, 149}, {244, 33, 1}} ,{{150, 149}, {245, 33, 1}} ,{{151, 149}, {246, 33, 1}} ,{{152, 149}, {247, 33, 1}} ,{{153, 149}, {248, 33, 1}} ,{{154, 149}, {249, 33, 1}} ,{{155, 149}, {250, 33, 1}} ,{{156, 149}, {251, 33, 1}} ,{{158, 149}, {253, 33, 1}} ,{{179, 149}, {18, 34, 1}} ,{{180, 149}, {19, 34, 1}} ,{{182, 149}, {21, 34, 1}} ,{{181, 149}, {20, 34, 1}} ,{{178, 149}, {17, 34, 1}} ,{{159, 149}, {254, 33, 1}} ,{{160, 149}, {255, 33, 1}} ,{{161, 149}, {0, 34, 1}} ,{{162, 149}, {1, 34, 1}} ,{{163, 149}, {2, 34, 1}} ,{{164, 149}, {3, 34, 1}} ,{{165, 149}, {4, 34, 1}} ,{{166, 149}, {5, 34, 1}} ,{{167, 149}, {6, 34, 1}} ,{{168, 149}, {7, 34, 1}} ,{{169, 149}, {8, 34, 1}} ,{{171, 149}, {10, 34, 1}} ,{{170, 149}, {9, 34, 1}} ,{{172, 149}, {11, 34, 1}} ,{{173, 149}, {12, 34, 1}} ,{{174, 149}, {13, 34, 1}} ,{{176, 149}, {15, 34, 1}} ,{{175, 149}, {14, 34, 1}} ,{{177, 149}, {16, 34, 1}} ,{{183, 149}, {22, 34, 1}} ,{{184, 149}, {23, 34, 1}} ,{{186, 149}, {25, 34, 1}} ,{{185, 149}, {24, 34, 1}} ,{{187, 149}, {26, 34, 1}} ,{{188, 149}, {27, 34, 1}} ,{{189, 149}, {28, 34, 1}} ,{{190, 149}, {29, 34, 1}} ,{{191, 149}, {30, 34, 1}} ,{{192, 149}, {31, 34, 1}} ,{{157, 149}, {252, 33, 1}} ,{{193, 149}, {32, 34, 1}} ,{{196, 149}, {35, 34, 1}} ,{{197, 149}, {36, 34, 1}} ,{{198, 149}, {37, 34, 1}} ,{{199, 149}, {38, 34, 1}} ,{{200, 149}, {39, 34, 1}} ,{{195, 149}, {34, 34, 1}} ,{{194, 149}, {33, 34, 1}} ,{{201, 149}, {40, 34, 1}} ,{{202, 149}, {41, 34, 1}} ,{{203, 149}, {42, 34, 1}} ,{{204, 149}, {43, 34, 1}} ,{{205, 149}, {44, 34, 1}} ,{{207, 149}, {46, 34, 1}} ,{{208, 149}, {47, 34, 1}} ,{{209, 149}, {48, 34, 1}} ,{{210, 149}, {49, 34, 1}} ,{{211, 149}, {50, 34, 1}} ,{{218, 149}, {57, 34, 1}} ,{{222, 149}, {61, 34, 1}} ,{{219, 149}, {58, 34, 1}} ,{{220, 149}, {59, 34, 1}} ,{{221, 149}, {60, 34, 1}} ,{{217, 149}, {56, 34, 1}} ,{{215, 149}, {54, 34, 1}} ,{{216, 149}, {55, 34, 1}} ,{{212, 149}, {51, 34, 1}} ,{{213, 149}, {52, 34, 1}} ,{{214, 149}, {53, 34, 1}} ,{{206, 149}, {45, 34, 1}} ,{{223, 149}, {62, 34, 1}} ,{{224, 149}, {63, 34, 1}} ,{{225, 149}, {64, 34, 1}} ,{{229, 149}, {68, 34, 1}} ,{{226, 149}, {65, 34, 1}} ,{{228, 149}, {67, 34, 1}} ,{{227, 149}, {66, 34, 1}} ,{{231, 149}, {70, 34, 1}} ,{{232, 149}, {71, 34, 1}} ,{{230, 149}, {69, 34, 1}} ,{{233, 149}, {72, 34, 1}} ,{{236, 149}, {75, 34, 1}} ,{{234, 149}, {73, 34, 1}} ,{{235, 149}, {74, 34, 1}} ,{{237, 149}, {76, 34, 1}} ,{{239, 149}, {78, 34, 1}} ,{{240, 149}, {79, 34, 1}} ,{{241, 149}, {80, 34, 1}} ,{{242, 149}, {81, 34, 1}} ,{{243, 149}, {82, 34, 1}} ,{{244, 149}, {83, 34, 1}} ,{{245, 149}, {84, 34, 1}} ,{{246, 149}, {85, 34, 1}} ,{{247, 149}, {86, 34, 1}} ,{{248, 149}, {87, 34, 1}} ,{{249, 149}, {88, 34, 1}} ,{{250, 149}, {89, 34, 1}} ,{{251, 149}, {90, 34, 1}} ,{{253, 149}, {92, 34, 1}} ,{{254, 149}, {93, 34, 1}} ,{{252, 149}, {91, 34, 1}} ,{{255, 149}, {94, 34, 1}} ,{{0, 150}, {95, 34, 1}} ,{{1, 150}, {96, 34, 1}} ,{{238, 149}, {77, 34, 1}} ,{{2, 150}, {97, 34, 1}} ,{{3, 150}, {98, 34, 1}} ,{{4, 150}, {99, 34, 1}} ,{{14, 150}, {109, 34, 1}} ,{{15, 150}, {110, 34, 1}} ,{{16, 150}, {111, 34, 1}} ,{{17, 150}, {112, 34, 1}} ,{{18, 150}, {113, 34, 1}} ,{{19, 150}, {114, 34, 1}} ,{{20, 150}, {115, 34, 1}} ,{{21, 150}, {116, 34, 1}} ,{{22, 150}, {117, 34, 1}} ,{{23, 150}, {118, 34, 1}} ,{{24, 150}, {119, 34, 1}} ,{{25, 150}, {120, 34, 1}} ,{{26, 150}, {121, 34, 1}} ,{{12, 150}, {107, 34, 1}} ,{{13, 150}, {108, 34, 1}} ,{{5, 150}, {100, 34, 1}} ,{{6, 150}, {101, 34, 1}} ,{{7, 150}, {102, 34, 1}} ,{{8, 150}, {103, 34, 1}} ,{{9, 150}, {104, 34, 1}} ,{{11, 150}, {106, 34, 1}} ,{{10, 150}, {105, 34, 1}} ,{{27, 150}, {122, 34, 1}} ,{{28, 150}, {123, 34, 1}} ,{{29, 150}, {124, 34, 1}} ,{{30, 150}, {125, 34, 1}} ,{{31, 150}, {126, 34, 1}} ,{{32, 150}, {127, 34, 1}} ,{{43, 150}, {138, 34, 1}} ,{{47, 150}, {142, 34, 1}} ,{{44, 150}, {139, 34, 1}} ,{{45, 150}, {140, 34, 1}} ,{{46, 150}, {141, 34, 1}} ,{{42, 150}, {137, 34, 1}} ,{{33, 150}, {128, 34, 1}} ,{{34, 150}, {129, 34, 1}} ,{{35, 150}, {130, 34, 1}} ,{{36, 150}, {131, 34, 1}} ,{{37, 150}, {132, 34, 1}} ,{{38, 150}, {133, 34, 1}} ,{{39, 150}, {134, 34, 1}} ,{{40, 150}, {135, 34, 1}} ,{{41, 150}, {136, 34, 1}} ,{{48, 150}, {143, 34, 1}} ,{{49, 150}, {144, 34, 1}} ,{{50, 150}, {145, 34, 1}} ,{{51, 150}, {146, 34, 1}} ,{{52, 150}, {147, 34, 1}} ,{{54, 150}, {149, 34, 1}} ,{{73, 150}, {168, 34, 1}} ,{{53, 150}, {148, 34, 1}} ,{{72, 150}, {167, 34, 1}} ,{{55, 150}, {150, 34, 1}} ,{{56, 150}, {151, 34, 1}} ,{{57, 150}, {152, 34, 1}} ,{{58, 150}, {153, 34, 1}} ,{{59, 150}, {154, 34, 1}} ,{{60, 150}, {155, 34, 1}} ,{{61, 150}, {156, 34, 1}} ,{{62, 150}, {157, 34, 1}} ,{{63, 150}, {158, 34, 1}} ,{{64, 150}, {159, 34, 1}} ,{{65, 150}, {160, 34, 1}} ,{{66, 150}, {161, 34, 1}} ,{{67, 150}, {162, 34, 1}} ,{{68, 150}, {163, 34, 1}} ,{{69, 150}, {164, 34, 1}} ,{{70, 150}, {165, 34, 1}} ,{{71, 150}, {166, 34, 1}} ,{{74, 150}, {169, 34, 1}} ,{{75, 150}, {170, 34, 1}} ,{{76, 150}, {171, 34, 1}} ,{{77, 150}, {172, 34, 1}} ,{{78, 150}, {173, 34, 1}} ,{{79, 150}, {174, 34, 1}} ,{{80, 150}, {175, 34, 1}} ,{{81, 150}, {176, 34, 1}} ,{{82, 150}, {177, 34, 1}} ,{{83, 150}, {178, 34, 1}} ,{{84, 150}, {179, 34, 1}} ,{{85, 150}, {180, 34, 1}} ,{{86, 150}, {181, 34, 1}} ,{{87, 150}, {182, 34, 1}} ,{{88, 150}, {183, 34, 1}} ,{{89, 150}, {184, 34, 1}} ,{{90, 150}, {185, 34, 1}} ,{{91, 150}, {186, 34, 1}} ,{{95, 150}, {190, 34, 1}} ,{{96, 150}, {191, 34, 1}} ,{{97, 150}, {192, 34, 1}} ,{{98, 150}, {193, 34, 1}} ,{{99, 150}, {194, 34, 1}} ,{{92, 150}, {187, 34, 1}} ,{{93, 150}, {188, 34, 1}} ,{{94, 150}, {189, 34, 1}} ,{{100, 150}, {195, 34, 1}} ,{{101, 150}, {196, 34, 1}} ,{{102, 150}, {197, 34, 1}} ,{{103, 150}, {198, 34, 1}} ,{{104, 150}, {199, 34, 1}} ,{{105, 150}, {200, 34, 1}} ,{{106, 150}, {201, 34, 1}} ,{{107, 150}, {202, 34, 1}} ,{{108, 150}, {203, 34, 1}} ,{{109, 150}, {204, 34, 1}} ,{{110, 150}, {205, 34, 1}} ,{{111, 150}, {206, 34, 1}} ,{{112, 150}, {207, 34, 1}} ,{{113, 150}, {208, 34, 1}} ,{{114, 150}, {209, 34, 1}} ,{{115, 150}, {210, 34, 1}} ,{{116, 150}, {211, 34, 1}} ,{{118, 150}, {213, 34, 1}} ,{{117, 150}, {212, 34, 1}} ,{{119, 150}, {214, 34, 1}} ,{{120, 150}, {215, 34, 1}} ,{{122, 150}, {217, 34, 1}} ,{{123, 150}, {218, 34, 1}} ,{{121, 150}, {216, 34, 1}} ,{{124, 150}, {219, 34, 1}} ,{{126, 150}, {221, 34, 1}} ,{{127, 150}, {222, 34, 1}} ,{{128, 150}, {223, 34, 1}} ,{{129, 150}, {224, 34, 1}} ,{{130, 150}, {225, 34, 1}} ,{{125, 150}, {220, 34, 1}} ,{{131, 150}, {226, 34, 1}} ,{{133, 150}, {228, 34, 1}} ,{{134, 150}, {229, 34, 1}} ,{{135, 150}, {230, 34, 1}} ,{{136, 150}, {231, 34, 1}} ,{{137, 150}, {232, 34, 1}} ,{{138, 150}, {233, 34, 1}} ,{{139, 150}, {234, 34, 1}} ,{{132, 150}, {227, 34, 1}} ,{{140, 150}, {235, 34, 1}} ,{{145, 150}, {240, 34, 1}} ,{{146, 150}, {241, 34, 1}} ,{{147, 150}, {242, 34, 1}} ,{{148, 150}, {243, 34, 1}} ,{{149, 150}, {244, 34, 1}} ,{{150, 150}, {245, 34, 1}} ,{{151, 150}, {246, 34, 1}} ,{{152, 150}, {247, 34, 1}} ,{{153, 150}, {248, 34, 1}} ,{{154, 150}, {249, 34, 1}} ,{{155, 150}, {250, 34, 1}} ,{{156, 150}, {251, 34, 1}} ,{{141, 150}, {236, 34, 1}} ,{{144, 150}, {239, 34, 1}} ,{{142, 150}, {237, 34, 1}} ,{{143, 150}, {238, 34, 1}} ,{{157, 150}, {252, 34, 1}} ,{{158, 150}, {253, 34, 1}} ,{{159, 150}, {254, 34, 1}} ,{{161, 150}, {0, 35, 1}} ,{{162, 150}, {1, 35, 1}} ,{{164, 150}, {3, 35, 1}} ,{{165, 150}, {4, 35, 1}} ,{{163, 150}, {2, 35, 1}} ,{{160, 150}, {255, 34, 1}} ,{{166, 150}, {5, 35, 1}} ,{{167, 150}, {6, 35, 1}} ,{{168, 150}, {7, 35, 1}} ,{{169, 150}, {8, 35, 1}} ,{{170, 150}, {9, 35, 1}} ,{{171, 150}, {10, 35, 1}} ,{{172, 150}, {11, 35, 1}} ,{{178, 150}, {17, 35, 1}} ,{{179, 150}, {18, 35, 1}} ,{{180, 150}, {19, 35, 1}} ,{{189, 150}, {28, 35, 1}} ,{{186, 150}, {25, 35, 1}} ,{{181, 150}, {20, 35, 1}} ,{{187, 150}, {26, 35, 1}} ,{{188, 150}, {27, 35, 1}} ,{{182, 150}, {21, 35, 1}} ,{{183, 150}, {22, 35, 1}} ,{{184, 150}, {23, 35, 1}} ,{{185, 150}, {24, 35, 1}} ,{{190, 150}, {29, 35, 1}} ,{{195, 150}, {34, 35, 1}} ,{{196, 150}, {35, 35, 1}} ,{{197, 150}, {36, 35, 1}} ,{{198, 150}, {37, 35, 1}} ,{{191, 150}, {30, 35, 1}} ,{{192, 150}, {31, 35, 1}} ,{{193, 150}, {32, 35, 1}} ,{{194, 150}, {33, 35, 1}} ,{{199, 150}, {38, 35, 1}} ,{{200, 150}, {39, 35, 1}} ,{{201, 150}, {40, 35, 1}} ,{{204, 150}, {43, 35, 1}} ,{{207, 150}, {46, 35, 1}} ,{{205, 150}, {44, 35, 1}} ,{{206, 150}, {45, 35, 1}} ,{{208, 150}, {47, 35, 1}} ,{{209, 150}, {48, 35, 1}} ,{{210, 150}, {49, 35, 1}} ,{{211, 150}, {50, 35, 1}} ,{{212, 150}, {51, 35, 1}} ,{{213, 150}, {52, 35, 1}} ,{{214, 150}, {53, 35, 1}} ,{{215, 150}, {54, 35, 1}} ,{{216, 150}, {55, 35, 1}} ,{{240, 150}, {79, 35, 1}} ,{{241, 150}, {80, 35, 1}} ,{{217, 150}, {56, 35, 1}} ,{{218, 150}, {57, 35, 1}} ,{{219, 150}, {58, 35, 1}} ,{{220, 150}, {59, 35, 1}} ,{{221, 150}, {60, 35, 1}} ,{{222, 150}, {61, 35, 1}} ,{{223, 150}, {62, 35, 1}} ,{{224, 150}, {63, 35, 1}} ,{{225, 150}, {64, 35, 1}} ,{{226, 150}, {65, 35, 1}} ,{{227, 150}, {66, 35, 1}} ,{{228, 150}, {67, 35, 1}} ,{{229, 150}, {68, 35, 1}} ,{{230, 150}, {69, 35, 1}} ,{{231, 150}, {70, 35, 1}} ,{{232, 150}, {71, 35, 1}} ,{{233, 150}, {72, 35, 1}} ,{{234, 150}, {73, 35, 1}} ,{{235, 150}, {74, 35, 1}} ,{{236, 150}, {75, 35, 1}} ,{{238, 150}, {77, 35, 1}} ,{{239, 150}, {78, 35, 1}} ,{{237, 150}, {76, 35, 1}} ,{{202, 150}, {41, 35, 1}} ,{{203, 150}, {42, 35, 1}} ,{{242, 150}, {81, 35, 1}} ,{{248, 150}, {87, 35, 1}} ,{{249, 150}, {88, 35, 1}} ,{{247, 150}, {86, 35, 1}} ,{{243, 150}, {82, 35, 1}} ,{{244, 150}, {83, 35, 1}} ,{{245, 150}, {84, 35, 1}} ,{{246, 150}, {85, 35, 1}} ,{{250, 150}, {89, 35, 1}} ,{{251, 150}, {90, 35, 1}} ,{{252, 150}, {91, 35, 1}} ,{{253, 150}, {92, 35, 1}} ,{{173, 150}, {12, 35, 1}} ,{{175, 150}, {14, 35, 1}} ,{{176, 150}, {15, 35, 1}} ,{{177, 150}, {16, 35, 1}} ,{{174, 150}, {13, 35, 1}} ,{{254, 150}, {93, 35, 1}} ,{{1, 151}, {96, 35, 1}} ,{{2, 151}, {97, 35, 1}} ,{{0, 151}, {95, 35, 1}} ,{{255, 150}, {94, 35, 1}} ,{{3, 151}, {98, 35, 1}} ,{{4, 151}, {99, 35, 1}} ,{{6, 151}, {101, 35, 1}} ,{{7, 151}, {102, 35, 1}} ,{{8, 151}, {103, 35, 1}} ,{{9, 151}, {104, 35, 1}} ,{{10, 151}, {105, 35, 1}} ,{{5, 151}, {100, 35, 1}} ,{{11, 151}, {106, 35, 1}} ,{{12, 151}, {107, 35, 1}} ,{{13, 151}, {108, 35, 1}} ,{{14, 151}, {109, 35, 1}} ,{{15, 151}, {110, 35, 1}} ,{{196, 70}, {254, 38, 0}} ,{{187, 67}, {170, 35, 0}} ,{{224, 66}, {207, 34, 0}} ,{{223, 66}, {206, 34, 0}} ,{{70, 38}, {164, 0, 0}} ,{{27, 71}, {97, 39, 0}} ,{{62, 67}, {45, 35, 0}} ,{{146, 145}, {0, 8, 1}} ,{{147, 145}, {1, 8, 1}} ,{{148, 145}, {2, 8, 1}} ,{{151, 145}, {5, 8, 1}} ,{{152, 145}, {8, 8, 1}} ,{{153, 145}, {10, 8, 1}} ,{{154, 145}, {11, 8, 1}} ,{{155, 145}, {12, 8, 1}} ,{{156, 145}, {13, 8, 1}} ,{{157, 145}, {14, 8, 1}} ,{{158, 145}, {15, 8, 1}} ,{{159, 145}, {16, 8, 1}} ,{{160, 145}, {17, 8, 1}} ,{{161, 145}, {18, 8, 1}} ,{{162, 145}, {19, 8, 1}} ,{{163, 145}, {20, 8, 1}} ,{{164, 145}, {21, 8, 1}} ,{{165, 145}, {22, 8, 1}} ,{{166, 145}, {23, 8, 1}} ,{{167, 145}, {24, 8, 1}} ,{{168, 145}, {25, 8, 1}} ,{{169, 145}, {26, 8, 1}} ,{{170, 145}, {27, 8, 1}} ,{{171, 145}, {28, 8, 1}} ,{{172, 145}, {29, 8, 1}} ,{{149, 145}, {3, 8, 1}} ,{{173, 145}, {30, 8, 1}} ,{{174, 145}, {31, 8, 1}} ,{{175, 145}, {32, 8, 1}} ,{{176, 145}, {33, 8, 1}} ,{{177, 145}, {34, 8, 1}} ,{{178, 145}, {35, 8, 1}} ,{{179, 145}, {36, 8, 1}} ,{{180, 145}, {37, 8, 1}} ,{{181, 145}, {38, 8, 1}} ,{{182, 145}, {39, 8, 1}} ,{{183, 145}, {40, 8, 1}} ,{{184, 145}, {41, 8, 1}} ,{{185, 145}, {42, 8, 1}} ,{{186, 145}, {43, 8, 1}} ,{{187, 145}, {44, 8, 1}} ,{{188, 145}, {45, 8, 1}} ,{{189, 145}, {46, 8, 1}} ,{{190, 145}, {47, 8, 1}} ,{{191, 145}, {48, 8, 1}} ,{{192, 145}, {49, 8, 1}} ,{{150, 145}, {4, 8, 1}} ,{{193, 145}, {50, 8, 1}} ,{{194, 145}, {51, 8, 1}} ,{{195, 145}, {52, 8, 1}} ,{{196, 145}, {53, 8, 1}} ,{{197, 145}, {55, 8, 1}} ,{{198, 145}, {56, 8, 1}} ,{{199, 145}, {60, 8, 1}} ,{{200, 145}, {63, 8, 1}} ,{{168, 41}, {16, 4, 0}} ,{{84, 42}, {188, 4, 0}} ,{{86, 42}, {190, 4, 0}} ,{{120, 42}, {224, 4, 0}} ,{{64, 42}, {168, 4, 0}} ,{{182, 42}, {30, 5, 0}} ,{{104, 42}, {208, 4, 0}} ,{{106, 42}, {210, 4, 0}} ,{{128, 42}, {232, 4, 0}} ,{{130, 42}, {234, 4, 0}} ,{{56, 42}, {160, 4, 0}} ,{{169, 41}, {17, 4, 0}} ,{{2, 42}, {106, 4, 0}} ,{{184, 88}, {106, 166, 0}} ,{{170, 88}, {90, 166, 0}} ,{{156, 88}, {76, 166, 0}} ,{{158, 41}, {6, 4, 0}} ,{{204, 88}, {134, 166, 0}} ,{{191, 41}, {39, 4, 0}} ,{{78, 42}, {182, 4, 0}} ,{{140, 42}, {244, 4, 0}} ,{{80, 42}, {184, 4, 0}} ,{{168, 88}, {88, 166, 0}} ,{{172, 41}, {20, 4, 0}} ,{{154, 41}, {2, 4, 0}} ,{{152, 88}, {72, 166, 0}} ,{{186, 88}, {108, 166, 0}} ,{{198, 88}, {128, 166, 0}} ,{{157, 41}, {5, 4, 0}} ,{{146, 88}, {66, 166, 0}} ,{{167, 41}, {15, 4, 0}} ,{{200, 88}, {130, 166, 0}} ,{{206, 88}, {136, 166, 0}} ,{{197, 41}, {45, 4, 0}} ,{{188, 41}, {36, 4, 0}} ,{{179, 41}, {27, 4, 0}} ,{{170, 42}, {18, 5, 0}} ,{{184, 42}, {32, 5, 0}} ,{{93, 42}, {197, 4, 0}} ,{{180, 41}, {28, 4, 0}} ,{{101, 42}, {205, 4, 0}} ,{{181, 41}, {29, 4, 0}} ,{{58, 42}, {162, 4, 0}} ,{{95, 42}, {199, 4, 0}} ,{{186, 42}, {34, 5, 0}} ,{{97, 42}, {201, 4, 0}} ,{{184, 41}, {32, 4, 0}} ,{{38, 42}, {142, 4, 0}} ,{{185, 41}, {33, 4, 0}} ,{{66, 42}, {170, 4, 0}} ,{{132, 42}, {236, 4, 0}} ,{{10, 42}, {114, 4, 0}} ,{{171, 41}, {19, 4, 0}} ,{{142, 42}, {246, 4, 0}} ,{{44, 42}, {148, 4, 0}} ,{{42, 42}, {146, 4, 0}} ,{{146, 42}, {250, 4, 0}} ,{{40, 42}, {144, 4, 0}} ,{{155, 41}, {3, 4, 0}} ,{{189, 41}, {37, 4, 0}} ,{{194, 41}, {42, 4, 0}} ,{{74, 42}, {178, 4, 0}} ,{{148, 42}, {252, 4, 0}} ,{{150, 42}, {254, 4, 0}} ,{{218, 88}, {148, 166, 0}} ,{{176, 41}, {24, 4, 0}} ,{{173, 41}, {21, 4, 0}} ,{{110, 42}, {214, 4, 0}} ,{{152, 41}, {0, 4, 0}} ,{{153, 41}, {1, 4, 0}} ,{{150, 88}, {70, 166, 0}} ,{{166, 88}, {86, 166, 0}} ,{{4, 42}, {108, 4, 0}} ,{{172, 88}, {92, 166, 0}} ,{{252, 41}, {100, 4, 0}} ,{{0, 42}, {104, 4, 0}} ,{{162, 88}, {82, 166, 0}} ,{{12, 42}, {116, 4, 0}} ,{{14, 42}, {118, 4, 0}} ,{{124, 42}, {228, 4, 0}} ,{{165, 41}, {13, 4, 0}} ,{{122, 42}, {226, 4, 0}} ,{{160, 41}, {8, 4, 0}} ,{{178, 41}, {26, 4, 0}} ,{{50, 42}, {154, 4, 0}} ,{{91, 42}, {195, 4, 0}} ,{{54, 42}, {158, 4, 0}} ,{{52, 42}, {156, 4, 0}} ,{{99, 42}, {203, 4, 0}} ,{{164, 41}, {12, 4, 0}} ,{{152, 42}, {0, 5, 0}} ,{{154, 42}, {2, 5, 0}} ,{{158, 42}, {6, 5, 0}} ,{{160, 42}, {8, 5, 0}} ,{{162, 42}, {10, 5, 0}} ,{{164, 42}, {12, 5, 0}} ,{{166, 42}, {14, 5, 0}} ,{{156, 42}, {4, 5, 0}} ,{{24, 42}, {128, 4, 0}} ,{{6, 42}, {110, 4, 0}} ,{{172, 42}, {20, 5, 0}} ,{{254, 41}, {102, 4, 0}} ,{{161, 41}, {9, 4, 0}} ,{{182, 88}, {104, 166, 0}} ,{{154, 88}, {74, 166, 0}} ,{{158, 88}, {78, 166, 0}} ,{{162, 41}, {10, 4, 0}} ,{{182, 41}, {30, 4, 0}} ,{{248, 41}, {96, 4, 0}} ,{{20, 42}, {124, 4, 0}} ,{{22, 42}, {126, 4, 0}} ,{{126, 42}, {230, 4, 0}} ,{{183, 41}, {31, 4, 0}} ,{{188, 42}, {36, 5, 0}} ,{{62, 42}, {166, 4, 0}} ,{{8, 42}, {112, 4, 0}} ,{{178, 42}, {26, 5, 0}} ,{{148, 88}, {68, 166, 0}} ,{{164, 88}, {84, 166, 0}} ,{{168, 42}, {16, 5, 0}} ,{{174, 42}, {22, 5, 0}} ,{{18, 42}, {122, 4, 0}} ,{{112, 42}, {216, 4, 0}} ,{{114, 42}, {218, 4, 0}} ,{{36, 42}, {140, 4, 0}} ,{{192, 41}, {40, 4, 0}} ,{{193, 41}, {41, 4, 0}} ,{{82, 42}, {186, 4, 0}} ,{{177, 41}, {25, 4, 0}} ,{{34, 42}, {138, 4, 0}} ,{{166, 41}, {14, 4, 0}} ,{{220, 88}, {150, 166, 0}} ,{{176, 88}, {98, 166, 0}} ,{{178, 88}, {100, 166, 0}} ,{{180, 88}, {102, 166, 0}} ,{{196, 41}, {44, 4, 0}} ,{{70, 42}, {174, 4, 0}} ,{{72, 42}, {176, 4, 0}} ,{{216, 88}, {146, 166, 0}} ,{{186, 41}, {34, 4, 0}} ,{{68, 42}, {172, 4, 0}} ,{{208, 88}, {138, 166, 0}} ,{{190, 41}, {38, 4, 0}} ,{{163, 41}, {11, 4, 0}} ,{{214, 88}, {144, 166, 0}} ,{{212, 88}, {142, 166, 0}} ,{{210, 88}, {140, 166, 0}} ,{{187, 41}, {35, 4, 0}} ,{{16, 42}, {120, 4, 0}} ,{{156, 41}, {4, 4, 0}} ,{{136, 42}, {240, 4, 0}} ,{{138, 42}, {242, 4, 0}} ,{{134, 42}, {238, 4, 0}} ,{{170, 41}, {18, 4, 0}} ,{{180, 42}, {28, 5, 0}} ,{{199, 41}, {47, 4, 0}} ,{{176, 42}, {24, 5, 0}} ,{{250, 41}, {98, 4, 0}} ,{{195, 41}, {43, 4, 0}} ,{{160, 88}, {80, 166, 0}} ,{{144, 42}, {248, 4, 0}} ,{{159, 41}, {7, 4, 0}} ,{{174, 88}, {94, 166, 0}} ,{{198, 41}, {46, 4, 0}} ,{{175, 41}, {23, 4, 0}} ,{{144, 88}, {64, 166, 0}} ,{{48, 42}, {152, 4, 0}} ,{{118, 42}, {222, 4, 0}} ,{{174, 41}, {22, 4, 0}} ,{{89, 42}, {193, 4, 0}} ,{{46, 42}, {150, 4, 0}} ,{{116, 42}, {220, 4, 0}} ,{{202, 88}, {132, 166, 0}} ,{{108, 42}, {212, 4, 0}} ,{{60, 42}, {164, 4, 0}} ,{{76, 42}, {180, 4, 0}} ,{{196, 88}, {126, 166, 0}} ,{{188, 88}, {110, 166, 0}} ,{{88, 42}, {192, 4, 0}} ,{{168, 61}, {43, 29, 0}} ,{{197, 88}, {127, 166, 0}} ,{{200, 41}, {48, 4, 0}} ,{{85, 42}, {189, 4, 0}} ,{{87, 42}, {191, 4, 0}} ,{{121, 42}, {225, 4, 0}} ,{{65, 42}, {169, 4, 0}} ,{{183, 42}, {31, 5, 0}} ,{{105, 42}, {209, 4, 0}} ,{{107, 42}, {211, 4, 0}} ,{{129, 42}, {233, 4, 0}} ,{{131, 42}, {235, 4, 0}} ,{{57, 42}, {161, 4, 0}} ,{{201, 41}, {49, 4, 0}} ,{{3, 42}, {107, 4, 0}} ,{{185, 88}, {107, 166, 0}} ,{{171, 88}, {91, 166, 0}} ,{{157, 88}, {77, 166, 0}} ,{{238, 41}, {86, 4, 0}} ,{{205, 88}, {135, 166, 0}} ,{{223, 41}, {71, 4, 0}} ,{{79, 42}, {183, 4, 0}} ,{{141, 42}, {245, 4, 0}} ,{{81, 42}, {185, 4, 0}} ,{{169, 88}, {89, 166, 0}} ,{{204, 41}, {52, 4, 0}} ,{{234, 41}, {82, 4, 0}} ,{{153, 88}, {73, 166, 0}} ,{{187, 88}, {109, 166, 0}} ,{{199, 88}, {129, 166, 0}} ,{{237, 41}, {85, 4, 0}} ,{{147, 88}, {67, 166, 0}} ,{{247, 41}, {95, 4, 0}} ,{{201, 88}, {131, 166, 0}} ,{{207, 88}, {137, 166, 0}} ,{{229, 41}, {77, 4, 0}} ,{{220, 41}, {68, 4, 0}} ,{{211, 41}, {59, 4, 0}} ,{{171, 42}, {19, 5, 0}} ,{{185, 42}, {33, 5, 0}} ,{{94, 42}, {198, 4, 0}} ,{{212, 41}, {60, 4, 0}} ,{{102, 42}, {206, 4, 0}} ,{{213, 41}, {61, 4, 0}} ,{{59, 42}, {163, 4, 0}} ,{{96, 42}, {200, 4, 0}} ,{{187, 42}, {35, 5, 0}} ,{{98, 42}, {202, 4, 0}} ,{{216, 41}, {64, 4, 0}} ,{{39, 42}, {143, 4, 0}} ,{{217, 41}, {65, 4, 0}} ,{{67, 42}, {171, 4, 0}} ,{{133, 42}, {237, 4, 0}} ,{{11, 42}, {115, 4, 0}} ,{{203, 41}, {51, 4, 0}} ,{{143, 42}, {247, 4, 0}} ,{{45, 42}, {149, 4, 0}} ,{{43, 42}, {147, 4, 0}} ,{{147, 42}, {251, 4, 0}} ,{{41, 42}, {145, 4, 0}} ,{{235, 41}, {83, 4, 0}} ,{{221, 41}, {69, 4, 0}} ,{{226, 41}, {74, 4, 0}} ,{{75, 42}, {179, 4, 0}} ,{{149, 42}, {253, 4, 0}} ,{{151, 42}, {255, 4, 0}} ,{{219, 88}, {149, 166, 0}} ,{{208, 41}, {56, 4, 0}} ,{{205, 41}, {53, 4, 0}} ,{{111, 42}, {215, 4, 0}} ,{{232, 41}, {80, 4, 0}} ,{{233, 41}, {81, 4, 0}} ,{{151, 88}, {71, 166, 0}} ,{{167, 88}, {87, 166, 0}} ,{{5, 42}, {109, 4, 0}} ,{{173, 88}, {93, 166, 0}} ,{{253, 41}, {101, 4, 0}} ,{{1, 42}, {105, 4, 0}} ,{{163, 88}, {83, 166, 0}} ,{{13, 42}, {117, 4, 0}} ,{{15, 42}, {119, 4, 0}} ,{{125, 42}, {229, 4, 0}} ,{{245, 41}, {93, 4, 0}} ,{{123, 42}, {227, 4, 0}} ,{{240, 41}, {88, 4, 0}} ,{{210, 41}, {58, 4, 0}} ,{{51, 42}, {155, 4, 0}} ,{{92, 42}, {196, 4, 0}} ,{{55, 42}, {159, 4, 0}} ,{{53, 42}, {157, 4, 0}} ,{{100, 42}, {204, 4, 0}} ,{{244, 41}, {92, 4, 0}} ,{{153, 42}, {1, 5, 0}} ,{{155, 42}, {3, 5, 0}} ,{{159, 42}, {7, 5, 0}} ,{{161, 42}, {9, 5, 0}} ,{{163, 42}, {11, 5, 0}} ,{{165, 42}, {13, 5, 0}} ,{{167, 42}, {15, 5, 0}} ,{{157, 42}, {5, 5, 0}} ,{{25, 42}, {129, 4, 0}} ,{{7, 42}, {111, 4, 0}} ,{{173, 42}, {21, 5, 0}} ,{{255, 41}, {103, 4, 0}} ,{{241, 41}, {89, 4, 0}} ,{{183, 88}, {105, 166, 0}} ,{{155, 88}, {75, 166, 0}} ,{{159, 88}, {79, 166, 0}} ,{{242, 41}, {90, 4, 0}} ,{{214, 41}, {62, 4, 0}} ,{{249, 41}, {97, 4, 0}} ,{{21, 42}, {125, 4, 0}} ,{{23, 42}, {127, 4, 0}} ,{{127, 42}, {231, 4, 0}} ,{{103, 42}, {207, 4, 0}} ,{{215, 41}, {63, 4, 0}} ,{{189, 42}, {37, 5, 0}} ,{{63, 42}, {167, 4, 0}} ,{{9, 42}, {113, 4, 0}} ,{{179, 42}, {27, 5, 0}} ,{{149, 88}, {69, 166, 0}} ,{{165, 88}, {85, 166, 0}} ,{{169, 42}, {17, 5, 0}} ,{{175, 42}, {23, 5, 0}} ,{{19, 42}, {123, 4, 0}} ,{{113, 42}, {217, 4, 0}} ,{{115, 42}, {219, 4, 0}} ,{{37, 42}, {141, 4, 0}} ,{{224, 41}, {72, 4, 0}} ,{{225, 41}, {73, 4, 0}} ,{{83, 42}, {187, 4, 0}} ,{{209, 41}, {57, 4, 0}} ,{{35, 42}, {139, 4, 0}} ,{{246, 41}, {94, 4, 0}} ,{{221, 88}, {151, 166, 0}} ,{{177, 88}, {99, 166, 0}} ,{{179, 88}, {101, 166, 0}} ,{{181, 88}, {103, 166, 0}} ,{{228, 41}, {76, 4, 0}} ,{{71, 42}, {175, 4, 0}} ,{{73, 42}, {177, 4, 0}} ,{{217, 88}, {147, 166, 0}} ,{{218, 41}, {66, 4, 0}} ,{{69, 42}, {173, 4, 0}} ,{{209, 88}, {139, 166, 0}} ,{{222, 41}, {70, 4, 0}} ,{{243, 41}, {91, 4, 0}} ,{{215, 88}, {145, 166, 0}} ,{{213, 88}, {143, 166, 0}} ,{{211, 88}, {141, 166, 0}} ,{{219, 41}, {67, 4, 0}} ,{{17, 42}, {121, 4, 0}} ,{{236, 41}, {84, 4, 0}} ,{{137, 42}, {241, 4, 0}} ,{{139, 42}, {243, 4, 0}} ,{{135, 42}, {239, 4, 0}} ,{{202, 41}, {50, 4, 0}} ,{{181, 42}, {29, 5, 0}} ,{{231, 41}, {79, 4, 0}} ,{{177, 42}, {25, 5, 0}} ,{{251, 41}, {99, 4, 0}} ,{{227, 41}, {75, 4, 0}} ,{{161, 88}, {81, 166, 0}} ,{{145, 42}, {249, 4, 0}} ,{{239, 41}, {87, 4, 0}} ,{{175, 88}, {95, 166, 0}} ,{{230, 41}, {78, 4, 0}} ,{{207, 41}, {55, 4, 0}} ,{{145, 88}, {65, 166, 0}} ,{{49, 42}, {153, 4, 0}} ,{{119, 42}, {223, 4, 0}} ,{{206, 41}, {54, 4, 0}} ,{{90, 42}, {194, 4, 0}} ,{{47, 42}, {151, 4, 0}} ,{{117, 42}, {221, 4, 0}} ,{{203, 88}, {133, 166, 0}} ,{{109, 42}, {213, 4, 0}} ,{{61, 42}, {165, 4, 0}} ,{{77, 42}, {181, 4, 0}} ,{{26, 42}, {130, 4, 0}} ,{{112, 64}, {32, 32, 0}} ,{{79, 65}, {56, 33, 0}} ,{{95, 69}, {147, 37, 0}} ,{{236, 140}, {77, 254, 0}} ,{{232, 140}, {73, 254, 0}} ,{{86, 71}, {159, 39, 0}} ,{{249, 67}, {232, 35, 0}} ,{{167, 67}, {150, 35, 0}} ,{{26, 65}, {3, 33, 0}} ,{{32, 65}, {9, 33, 0}} ,{{82, 38}, {176, 0, 0}} ,{{109, 66}, {92, 34, 0}} ,{{218, 67}, {201, 35, 0}} ,{{210, 67}, {193, 35, 0}} ,{{213, 67}, {196, 35, 0}} ,{{216, 67}, {199, 35, 0}} ,{{219, 67}, {202, 35, 0}} ,{{211, 67}, {194, 35, 0}} ,{{214, 67}, {197, 35, 0}} ,{{217, 67}, {200, 35, 0}} ,{{221, 67}, {204, 35, 0}} ,{{208, 67}, {191, 35, 0}} ,{{220, 67}, {203, 35, 0}} ,{{207, 67}, {190, 35, 0}} ,{{215, 67}, {198, 35, 0}} ,{{209, 67}, {192, 35, 0}} ,{{212, 67}, {195, 35, 0}} ,{{215, 69}, {11, 38, 0}} ,{{246, 144}, {12, 4, 1}} ,{{252, 144}, {18, 4, 1}} ,{{255, 144}, {21, 4, 1}} ,{{254, 144}, {20, 4, 1}} ,{{3, 145}, {25, 4, 1}} ,{{12, 145}, {34, 4, 1}} ,{{13, 145}, {35, 4, 1}} ,{{14, 145}, {36, 4, 1}} ,{{15, 145}, {37, 4, 1}} ,{{11, 145}, {33, 4, 1}} ,{{7, 145}, {29, 4, 1}} ,{{9, 145}, {31, 4, 1}} ,{{5, 145}, {27, 4, 1}} ,{{17, 145}, {39, 4, 1}} ,{{2, 145}, {24, 4, 1}} ,{{250, 144}, {16, 4, 1}} ,{{0, 145}, {22, 4, 1}} ,{{1, 145}, {23, 4, 1}} ,{{236, 144}, {2, 4, 1}} ,{{237, 144}, {3, 4, 1}} ,{{235, 144}, {1, 4, 1}} ,{{234, 144}, {0, 4, 1}} ,{{238, 144}, {4, 4, 1}} ,{{239, 144}, {5, 4, 1}} ,{{16, 145}, {38, 4, 1}} ,{{247, 144}, {13, 4, 1}} ,{{251, 144}, {17, 4, 1}} ,{{242, 144}, {8, 4, 1}} ,{{243, 144}, {9, 4, 1}} ,{{241, 144}, {7, 4, 1}} ,{{240, 144}, {6, 4, 1}} ,{{244, 144}, {10, 4, 1}} ,{{245, 144}, {11, 4, 1}} ,{{253, 144}, {19, 4, 1}} ,{{6, 145}, {28, 4, 1}} ,{{4, 145}, {26, 4, 1}} ,{{248, 144}, {14, 4, 1}} ,{{249, 144}, {15, 4, 1}} ,{{8, 145}, {30, 4, 1}} ,{{10, 145}, {32, 4, 1}} ,{{30, 145}, {52, 4, 1}} ,{{36, 145}, {58, 4, 1}} ,{{39, 145}, {61, 4, 1}} ,{{38, 145}, {60, 4, 1}} ,{{43, 145}, {65, 4, 1}} ,{{52, 145}, {74, 4, 1}} ,{{53, 145}, {75, 4, 1}} ,{{54, 145}, {76, 4, 1}} ,{{55, 145}, {77, 4, 1}} ,{{51, 145}, {73, 4, 1}} ,{{47, 145}, {69, 4, 1}} ,{{49, 145}, {71, 4, 1}} ,{{45, 145}, {67, 4, 1}} ,{{57, 145}, {79, 4, 1}} ,{{42, 145}, {64, 4, 1}} ,{{34, 145}, {56, 4, 1}} ,{{40, 145}, {62, 4, 1}} ,{{41, 145}, {63, 4, 1}} ,{{20, 145}, {42, 4, 1}} ,{{21, 145}, {43, 4, 1}} ,{{19, 145}, {41, 4, 1}} ,{{18, 145}, {40, 4, 1}} ,{{22, 145}, {44, 4, 1}} ,{{23, 145}, {45, 4, 1}} ,{{56, 145}, {78, 4, 1}} ,{{31, 145}, {53, 4, 1}} ,{{35, 145}, {57, 4, 1}} ,{{26, 145}, {48, 4, 1}} ,{{27, 145}, {49, 4, 1}} ,{{25, 145}, {47, 4, 1}} ,{{24, 145}, {46, 4, 1}} ,{{28, 145}, {50, 4, 1}} ,{{29, 145}, {51, 4, 1}} ,{{37, 145}, {59, 4, 1}} ,{{46, 145}, {68, 4, 1}} ,{{44, 145}, {66, 4, 1}} ,{{32, 145}, {54, 4, 1}} ,{{33, 145}, {55, 4, 1}} ,{{48, 145}, {70, 4, 1}} ,{{50, 145}, {72, 4, 1}} ,{{247, 45}, {112, 9, 0}} ,{{221, 45}, {84, 9, 0}} ,{{161, 90}, {250, 168, 0}} ,{{235, 45}, {100, 9, 0}} ,{{245, 45}, {110, 9, 0}} ,{{242, 45}, {107, 9, 0}} ,{{241, 45}, {106, 9, 0}} ,{{246, 45}, {111, 9, 0}} ,{{238, 45}, {103, 9, 0}} ,{{244, 45}, {109, 9, 0}} ,{{243, 45}, {108, 9, 0}} ,{{240, 45}, {105, 9, 0}} ,{{239, 45}, {104, 9, 0}} ,{{237, 45}, {102, 9, 0}} ,{{236, 45}, {101, 9, 0}} ,{{160, 90}, {249, 168, 0}} ,{{220, 45}, {83, 9, 0}} ,{{162, 90}, {251, 168, 0}} ,{{145, 45}, {5, 9, 0}} ,{{146, 45}, {6, 9, 0}} ,{{156, 45}, {16, 9, 0}} ,{{160, 45}, {20, 9, 0}} ,{{184, 45}, {44, 9, 0}} ,{{0, 46}, {127, 9, 0}} ,{{185, 45}, {45, 9, 0}} ,{{166, 45}, {26, 9, 0}} ,{{249, 45}, {114, 9, 0}} ,{{153, 45}, {13, 9, 0}} ,{{157, 45}, {17, 9, 0}} ,{{167, 45}, {27, 9, 0}} ,{{178, 45}, {38, 9, 0}} ,{{173, 45}, {33, 9, 0}} ,{{255, 45}, {126, 9, 0}} ,{{227, 45}, {92, 9, 0}} ,{{174, 45}, {34, 9, 0}} ,{{179, 45}, {39, 9, 0}} ,{{155, 45}, {15, 9, 0}} ,{{229, 45}, {94, 9, 0}} ,{{163, 45}, {23, 9, 0}} ,{{252, 45}, {123, 9, 0}} ,{{164, 45}, {24, 9, 0}} ,{{225, 45}, {90, 9, 0}} ,{{254, 45}, {125, 9, 0}} ,{{197, 45}, {57, 9, 0}} ,{{251, 45}, {122, 9, 0}} ,{{147, 45}, {7, 9, 0}} ,{{148, 45}, {8, 9, 0}} ,{{168, 45}, {28, 9, 0}} ,{{169, 45}, {29, 9, 0}} ,{{253, 45}, {124, 9, 0}} ,{{161, 45}, {21, 9, 0}} ,{{162, 45}, {22, 9, 0}} ,{{224, 45}, {89, 9, 0}} ,{{190, 45}, {50, 9, 0}} ,{{191, 45}, {51, 9, 0}} ,{{192, 45}, {52, 9, 0}} ,{{186, 45}, {46, 9, 0}} ,{{180, 45}, {40, 9, 0}} ,{{165, 45}, {25, 9, 0}} ,{{175, 45}, {35, 9, 0}} ,{{181, 45}, {41, 9, 0}} ,{{170, 45}, {30, 9, 0}} ,{{159, 45}, {19, 9, 0}} ,{{182, 45}, {42, 9, 0}} ,{{183, 45}, {43, 9, 0}} ,{{223, 45}, {88, 9, 0}} ,{{188, 45}, {48, 9, 0}} ,{{228, 45}, {93, 9, 0}} ,{{189, 45}, {49, 9, 0}} ,{{196, 45}, {56, 9, 0}} ,{{194, 45}, {54, 9, 0}} ,{{144, 45}, {4, 9, 0}} ,{{154, 45}, {14, 9, 0}} ,{{158, 45}, {18, 9, 0}} ,{{195, 45}, {55, 9, 0}} ,{{176, 45}, {36, 9, 0}} ,{{177, 45}, {37, 9, 0}} ,{{171, 45}, {31, 9, 0}} ,{{172, 45}, {32, 9, 0}} ,{{149, 45}, {9, 9, 0}} ,{{150, 45}, {10, 9, 0}} ,{{193, 45}, {53, 9, 0}} ,{{152, 45}, {12, 9, 0}} ,{{232, 45}, {97, 9, 0}} ,{{151, 45}, {11, 9, 0}} ,{{231, 45}, {96, 9, 0}} ,{{187, 45}, {47, 9, 0}} ,{{230, 45}, {95, 9, 0}} ,{{226, 45}, {91, 9, 0}} ,{{250, 45}, {121, 9, 0}} ,{{217, 45}, {80, 9, 0}} ,{{142, 45}, {2, 9, 0}} ,{{199, 45}, {61, 9, 0}} ,{{141, 45}, {1, 9, 0}} ,{{158, 90}, {247, 168, 0}} ,{{157, 90}, {246, 168, 0}} ,{{156, 90}, {245, 168, 0}} ,{{154, 90}, {243, 168, 0}} ,{{155, 90}, {244, 168, 0}} ,{{248, 45}, {113, 9, 0}} ,{{140, 45}, {0, 9, 0}} ,{{198, 45}, {60, 9, 0}} ,{{159, 90}, {248, 168, 0}} ,{{153, 90}, {242, 168, 0}} ,{{215, 45}, {77, 9, 0}} ,{{143, 45}, {3, 9, 0}} ,{{219, 45}, {82, 9, 0}} ,{{218, 45}, {81, 9, 0}} ,{{200, 45}, {62, 9, 0}} ,{{210, 45}, {72, 9, 0}} ,{{214, 45}, {76, 9, 0}} ,{{207, 45}, {69, 9, 0}} ,{{222, 45}, {85, 9, 0}} ,{{211, 45}, {73, 9, 0}} ,{{209, 45}, {71, 9, 0}} ,{{201, 45}, {63, 9, 0}} ,{{202, 45}, {64, 9, 0}} ,{{213, 45}, {75, 9, 0}} ,{{216, 45}, {78, 9, 0}} ,{{208, 45}, {70, 9, 0}} ,{{212, 45}, {74, 9, 0}} ,{{203, 45}, {65, 9, 0}} ,{{204, 45}, {66, 9, 0}} ,{{233, 45}, {98, 9, 0}} ,{{234, 45}, {99, 9, 0}} ,{{205, 45}, {67, 9, 0}} ,{{206, 45}, {68, 9, 0}} ,{{74, 38}, {168, 0, 0}} ,{{17, 67}, {0, 35, 0}} ,{{213, 66}, {196, 34, 0}} ,{{202, 74}, {25, 43, 0}} ,{{199, 74}, {22, 43, 0}} ,{{200, 74}, {23, 43, 0}} ,{{201, 74}, {24, 43, 0}} ,{{76, 70}, {128, 38, 0}} ,{{77, 70}, {129, 38, 0}} ,{{78, 70}, {130, 38, 0}} ,{{79, 70}, {131, 38, 0}} ,{{80, 70}, {132, 38, 0}} ,{{81, 70}, {133, 38, 0}} ,{{96, 66}, {79, 34, 0}} ,{{251, 37}, {56, 0, 0}} ,{{164, 162}, {9, 241, 1}} ,{{91, 68}, {143, 36, 0}} ,{{248, 37}, {53, 0, 0}} ,{{161, 162}, {6, 241, 1}} ,{{88, 68}, {140, 36, 0}} ,{{247, 37}, {52, 0, 0}} ,{{160, 162}, {5, 241, 1}} ,{{87, 68}, {139, 36, 0}} ,{{252, 37}, {57, 0, 0}} ,{{165, 162}, {10, 241, 1}} ,{{92, 68}, {144, 36, 0}} ,{{244, 37}, {49, 0, 0}} ,{{157, 162}, {2, 241, 1}} ,{{84, 68}, {136, 36, 0}} ,{{250, 37}, {55, 0, 0}} ,{{163, 162}, {8, 241, 1}} ,{{90, 68}, {142, 36, 0}} ,{{249, 37}, {54, 0, 0}} ,{{162, 162}, {7, 241, 1}} ,{{89, 68}, {141, 36, 0}} ,{{246, 37}, {51, 0, 0}} ,{{159, 162}, {4, 241, 1}} ,{{86, 68}, {138, 36, 0}} ,{{245, 37}, {50, 0, 0}} ,{{158, 162}, {3, 241, 1}} ,{{85, 68}, {137, 36, 0}} ,{{243, 37}, {48, 0, 0}} ,{{156, 162}, {1, 241, 1}} ,{{155, 162}, {0, 241, 1}} ,{{195, 157}, {5, 211, 1}} ,{{193, 157}, {3, 211, 1}} ,{{194, 157}, {4, 211, 1}} ,{{88, 70}, {140, 38, 0}} ,{{91, 70}, {143, 38, 0}} ,{{191, 157}, {1, 211, 1}} ,{{192, 157}, {2, 211, 1}} ,{{90, 70}, {142, 38, 0}} ,{{89, 70}, {141, 38, 0}} ,{{66, 67}, {49, 35, 0}} ,{{65, 71}, {135, 39, 0}} ,{{62, 71}, {132, 39, 0}} ,{{61, 71}, {131, 39, 0}} ,{{66, 71}, {136, 39, 0}} ,{{58, 71}, {128, 39, 0}} ,{{64, 71}, {134, 39, 0}} ,{{63, 71}, {133, 39, 0}} ,{{60, 71}, {130, 39, 0}} ,{{59, 71}, {129, 39, 0}} ,{{67, 71}, {137, 39, 0}} ,{{55, 71}, {125, 39, 0}} ,{{52, 71}, {122, 39, 0}} ,{{51, 71}, {121, 39, 0}} ,{{56, 71}, {126, 39, 0}} ,{{48, 71}, {118, 39, 0}} ,{{54, 71}, {124, 39, 0}} ,{{53, 71}, {123, 39, 0}} ,{{50, 71}, {120, 39, 0}} ,{{49, 71}, {119, 39, 0}} ,{{57, 71}, {127, 39, 0}} ,{{75, 71}, {145, 39, 0}} ,{{72, 71}, {142, 39, 0}} ,{{71, 71}, {141, 39, 0}} ,{{76, 71}, {146, 39, 0}} ,{{68, 71}, {138, 39, 0}} ,{{74, 71}, {144, 39, 0}} ,{{73, 71}, {143, 39, 0}} ,{{70, 71}, {140, 39, 0}} ,{{69, 71}, {139, 39, 0}} ,{{77, 71}, {147, 39, 0}} ,{{164, 67}, {147, 35, 0}} ,{{153, 70}, {205, 38, 0}} ,{{147, 67}, {130, 35, 0}} ,{{85, 78}, {3, 48, 0}} ,{{52, 66}, {35, 34, 0}} ,{{153, 38}, {247, 0, 0}} ,{{38, 66}, {21, 34, 0}} ,{{216, 66}, {199, 34, 0}} ,{{122, 70}, {174, 38, 0}} ,{{29, 66}, {12, 34, 0}} ,{{252, 66}, {235, 34, 0}} ,{{254, 66}, {237, 34, 0}} ,{{53, 66}, {36, 34, 0}} ,{{159, 74}, {238, 42, 0}} ,{{191, 66}, {174, 34, 0}} ,{{145, 66}, {128, 34, 0}} ,{{241, 66}, {224, 34, 0}} ,{{189, 66}, {172, 34, 0}} ,{{146, 66}, {129, 34, 0}} ,{{242, 66}, {225, 34, 0}} ,{{231, 37}, {36, 0, 0}} ,{{56, 162}, {49, 240, 1}} ,{{57, 162}, {50, 240, 1}} ,{{58, 162}, {51, 240, 1}} ,{{59, 162}, {52, 240, 1}} ,{{60, 162}, {53, 240, 1}} ,{{61, 162}, {54, 240, 1}} ,{{62, 162}, {55, 240, 1}} ,{{63, 162}, {56, 240, 1}} ,{{64, 162}, {57, 240, 1}} ,{{65, 162}, {58, 240, 1}} ,{{66, 162}, {59, 240, 1}} ,{{67, 162}, {60, 240, 1}} ,{{68, 162}, {61, 240, 1}} ,{{69, 162}, {62, 240, 1}} ,{{70, 162}, {63, 240, 1}} ,{{71, 162}, {64, 240, 1}} ,{{72, 162}, {65, 240, 1}} ,{{73, 162}, {66, 240, 1}} ,{{74, 162}, {67, 240, 1}} ,{{75, 162}, {68, 240, 1}} ,{{76, 162}, {69, 240, 1}} ,{{77, 162}, {70, 240, 1}} ,{{78, 162}, {71, 240, 1}} ,{{79, 162}, {72, 240, 1}} ,{{80, 162}, {73, 240, 1}} ,{{81, 162}, {74, 240, 1}} ,{{82, 162}, {75, 240, 1}} ,{{83, 162}, {76, 240, 1}} ,{{84, 162}, {77, 240, 1}} ,{{85, 162}, {78, 240, 1}} ,{{86, 162}, {79, 240, 1}} ,{{87, 162}, {80, 240, 1}} ,{{88, 162}, {81, 240, 1}} ,{{89, 162}, {82, 240, 1}} ,{{90, 162}, {83, 240, 1}} ,{{91, 162}, {84, 240, 1}} ,{{92, 162}, {85, 240, 1}} ,{{93, 162}, {86, 240, 1}} ,{{94, 162}, {87, 240, 1}} ,{{95, 162}, {88, 240, 1}} ,{{96, 162}, {89, 240, 1}} ,{{97, 162}, {90, 240, 1}} ,{{98, 162}, {91, 240, 1}} ,{{99, 162}, {92, 240, 1}} ,{{100, 162}, {93, 240, 1}} ,{{101, 162}, {94, 240, 1}} ,{{102, 162}, {95, 240, 1}} ,{{103, 162}, {96, 240, 1}} ,{{104, 162}, {97, 240, 1}} ,{{55, 162}, {48, 240, 1}} ,{{106, 162}, {99, 240, 1}} ,{{107, 162}, {100, 240, 1}} ,{{108, 162}, {101, 240, 1}} ,{{109, 162}, {102, 240, 1}} ,{{110, 162}, {103, 240, 1}} ,{{111, 162}, {104, 240, 1}} ,{{112, 162}, {105, 240, 1}} ,{{113, 162}, {106, 240, 1}} ,{{114, 162}, {107, 240, 1}} ,{{115, 162}, {108, 240, 1}} ,{{116, 162}, {109, 240, 1}} ,{{117, 162}, {110, 240, 1}} ,{{118, 162}, {111, 240, 1}} ,{{119, 162}, {112, 240, 1}} ,{{120, 162}, {113, 240, 1}} ,{{121, 162}, {114, 240, 1}} ,{{122, 162}, {115, 240, 1}} ,{{123, 162}, {116, 240, 1}} ,{{124, 162}, {117, 240, 1}} ,{{125, 162}, {118, 240, 1}} ,{{126, 162}, {119, 240, 1}} ,{{127, 162}, {120, 240, 1}} ,{{128, 162}, {121, 240, 1}} ,{{129, 162}, {122, 240, 1}} ,{{130, 162}, {123, 240, 1}} ,{{131, 162}, {124, 240, 1}} ,{{132, 162}, {125, 240, 1}} ,{{133, 162}, {126, 240, 1}} ,{{134, 162}, {127, 240, 1}} ,{{135, 162}, {128, 240, 1}} ,{{136, 162}, {129, 240, 1}} ,{{137, 162}, {130, 240, 1}} ,{{138, 162}, {131, 240, 1}} ,{{139, 162}, {132, 240, 1}} ,{{140, 162}, {133, 240, 1}} ,{{141, 162}, {134, 240, 1}} ,{{142, 162}, {135, 240, 1}} ,{{143, 162}, {136, 240, 1}} ,{{144, 162}, {137, 240, 1}} ,{{145, 162}, {138, 240, 1}} ,{{146, 162}, {139, 240, 1}} ,{{147, 162}, {140, 240, 1}} ,{{148, 162}, {141, 240, 1}} ,{{149, 162}, {142, 240, 1}} ,{{150, 162}, {143, 240, 1}} ,{{151, 162}, {144, 240, 1}} ,{{152, 162}, {145, 240, 1}} ,{{153, 162}, {146, 240, 1}} ,{{154, 162}, {147, 240, 1}} ,{{105, 162}, {98, 240, 1}} ,{{232, 64}, {171, 32, 0}} ,{{152, 69}, {204, 37, 0}} ,{{172, 64}, {92, 32, 0}} ,{{74, 73}, {153, 41, 0}} ,{{222, 76}, {19, 46, 0}} ,{{225, 76}, {22, 46, 0}} ,{{203, 74}, {26, 43, 0}} ,{{211, 76}, {8, 46, 0}} ,{{123, 40}, {217, 2, 0}} ,{{73, 66}, {56, 34, 0}} ,{{214, 66}, {197, 34, 0}} ,{{37, 66}, {20, 34, 0}} ,{{144, 73}, {223, 41, 0}} ,{{75, 74}, {154, 42, 0}} ,{{74, 74}, {153, 42, 0}} ,{{77, 74}, {156, 42, 0}} ,{{76, 74}, {155, 42, 0}} ,{{171, 74}, {250, 42, 0}} ,{{170, 74}, {249, 42, 0}} ,{{25, 65}, {2, 33, 0}} ,{{85, 65}, {62, 33, 0}} ,{{36, 65}, {13, 33, 0}} ,{{44, 65}, {21, 33, 0}} ,{{48, 65}, {25, 33, 0}} ,{{86, 65}, {63, 33, 0}} ,{{49, 65}, {26, 33, 0}} ,{{52, 65}, {29, 33, 0}} ,{{59, 65}, {36, 33, 0}} ,{{92, 65}, {69, 33, 0}} ,{{93, 65}, {70, 33, 0}} ,{{94, 65}, {71, 33, 0}} ,{{95, 65}, {72, 33, 0}} ,{{96, 65}, {73, 33, 0}} ,{{87, 65}, {64, 33, 0}} ,{{84, 65}, {61, 33, 0}} ,{{83, 65}, {60, 33, 0}} ,{{110, 70}, {162, 38, 0}} ,{{111, 70}, {163, 38, 0}} ,{{127, 40}, {221, 2, 0}} ,{{200, 68}, {252, 36, 0}} ,{{197, 68}, {249, 36, 0}} ,{{196, 68}, {248, 36, 0}} ,{{201, 68}, {253, 36, 0}} ,{{193, 68}, {245, 36, 0}} ,{{199, 68}, {251, 36, 0}} ,{{198, 68}, {250, 36, 0}} ,{{195, 68}, {247, 36, 0}} ,{{194, 68}, {246, 36, 0}} ,{{202, 68}, {254, 36, 0}} ,{{37, 74}, {116, 42, 0}} ,{{113, 64}, {33, 32, 0}} ,{{155, 74}, {234, 42, 0}} ,{{140, 64}, {60, 32, 0}} ,{{111, 64}, {31, 32, 0}} ,{{61, 66}, {44, 34, 0}} ,{{227, 66}, {210, 34, 0}} ,{{70, 73}, {149, 41, 0}} ,{{4, 74}, {83, 42, 0}} ,{{5, 74}, {84, 42, 0}} ,{{110, 64}, {30, 32, 0}} ,{{103, 64}, {23, 32, 0}} ,{{83, 74}, {162, 42, 0}} ,{{82, 74}, {161, 42, 0}} ,{{84, 74}, {163, 42, 0}} ,{{226, 76}, {23, 46, 0}} ,{{171, 73}, {250, 41, 0}} ,{{108, 74}, {187, 42, 0}} ,{{131, 64}, {51, 32, 0}} ,{{112, 78}, {30, 48, 0}} ,{{151, 64}, {71, 32, 0}} ,{{71, 73}, {150, 41, 0}} ,{{174, 74}, {253, 42, 0}} ,{{255, 73}, {78, 42, 0}} ,{{0, 74}, {79, 42, 0}} ,{{157, 74}, {236, 42, 0}} ,{{225, 66}, {208, 34, 0}} ,{{109, 74}, {188, 42, 0}} ,{{226, 66}, {209, 34, 0}} ,{{228, 66}, {211, 34, 0}} ,{{156, 74}, {235, 42, 0}} ,{{150, 74}, {229, 42, 0}} ,{{188, 66}, {171, 34, 0}} ,{{148, 74}, {227, 42, 0}} ,{{102, 64}, {22, 32, 0}} ,{{235, 140}, {76, 254, 0}} ,{{153, 73}, {232, 41, 0}} ,{{154, 73}, {233, 41, 0}} ,{{223, 76}, {20, 46, 0}} ,{{164, 65}, {147, 33, 0}} ,{{184, 65}, {167, 33, 0}} ,{{6, 66}, {245, 33, 0}} ,{{196, 72}, {19, 41, 0}} ,{{198, 65}, {181, 33, 0}} ,{{240, 65}, {223, 33, 0}} ,{{185, 72}, {8, 41, 0}} ,{{195, 65}, {178, 33, 0}} ,{{196, 65}, {179, 33, 0}} ,{{184, 74}, {7, 43, 0}} ,{{244, 65}, {227, 33, 0}} ,{{228, 65}, {211, 33, 0}} ,{{212, 65}, {195, 33, 0}} ,{{22, 73}, {101, 41, 0}} ,{{32, 73}, {111, 41, 0}} ,{{18, 73}, {97, 41, 0}} ,{{10, 73}, {89, 41, 0}} ,{{211, 65}, {194, 33, 0}} ,{{14, 73}, {93, 41, 0}} ,{{6, 73}, {85, 41, 0}} ,{{219, 65}, {202, 33, 0}} ,{{162, 71}, {241, 39, 0}} ,{{188, 72}, {11, 41, 0}} ,{{178, 65}, {161, 33, 0}} ,{{250, 65}, {233, 33, 0}} ,{{192, 65}, {175, 33, 0}} ,{{21, 67}, {4, 35, 0}} ,{{48, 73}, {127, 41, 0}} ,{{2, 67}, {241, 34, 0}} ,{{181, 66}, {164, 34, 0}} ,{{162, 74}, {241, 42, 0}} ,{{236, 64}, {175, 32, 0}} ,{{82, 71}, {155, 39, 0}} ,{{165, 70}, {218, 38, 0}} ,{{13, 70}, {65, 38, 0}} ,{{235, 67}, {218, 35, 0}} ,{{61, 70}, {113, 38, 0}} ,{{217, 76}, {14, 46, 0}} ,{{119, 151}, {0, 48, 1}} ,{{120, 151}, {1, 48, 1}} ,{{121, 151}, {2, 48, 1}} ,{{122, 151}, {3, 48, 1}} ,{{123, 151}, {4, 48, 1}} ,{{124, 151}, {5, 48, 1}} ,{{125, 151}, {6, 48, 1}} ,{{126, 151}, {7, 48, 1}} ,{{127, 151}, {8, 48, 1}} ,{{128, 151}, {9, 48, 1}} ,{{129, 151}, {10, 48, 1}} ,{{130, 151}, {11, 48, 1}} ,{{131, 151}, {12, 48, 1}} ,{{132, 151}, {13, 48, 1}} ,{{133, 151}, {14, 48, 1}} ,{{134, 151}, {15, 48, 1}} ,{{135, 151}, {16, 48, 1}} ,{{136, 151}, {17, 48, 1}} ,{{137, 151}, {18, 48, 1}} ,{{138, 151}, {19, 48, 1}} ,{{139, 151}, {20, 48, 1}} ,{{140, 151}, {21, 48, 1}} ,{{141, 151}, {22, 48, 1}} ,{{142, 151}, {23, 48, 1}} ,{{143, 151}, {24, 48, 1}} ,{{144, 151}, {25, 48, 1}} ,{{145, 151}, {26, 48, 1}} ,{{146, 151}, {27, 48, 1}} ,{{147, 151}, {28, 48, 1}} ,{{148, 151}, {29, 48, 1}} ,{{149, 151}, {30, 48, 1}} ,{{150, 151}, {31, 48, 1}} ,{{151, 151}, {32, 48, 1}} ,{{152, 151}, {33, 48, 1}} ,{{153, 151}, {34, 48, 1}} ,{{154, 151}, {35, 48, 1}} ,{{155, 151}, {36, 48, 1}} ,{{156, 151}, {37, 48, 1}} ,{{157, 151}, {38, 48, 1}} ,{{158, 151}, {39, 48, 1}} ,{{159, 151}, {40, 48, 1}} ,{{160, 151}, {41, 48, 1}} ,{{161, 151}, {42, 48, 1}} ,{{162, 151}, {43, 48, 1}} ,{{163, 151}, {44, 48, 1}} ,{{164, 151}, {45, 48, 1}} ,{{165, 151}, {46, 48, 1}} ,{{166, 151}, {47, 48, 1}} ,{{167, 151}, {48, 48, 1}} ,{{168, 151}, {49, 48, 1}} ,{{169, 151}, {50, 48, 1}} ,{{170, 151}, {51, 48, 1}} ,{{171, 151}, {52, 48, 1}} ,{{172, 151}, {53, 48, 1}} ,{{173, 151}, {54, 48, 1}} ,{{174, 151}, {55, 48, 1}} ,{{175, 151}, {56, 48, 1}} ,{{176, 151}, {57, 48, 1}} ,{{177, 151}, {58, 48, 1}} ,{{178, 151}, {59, 48, 1}} ,{{179, 151}, {60, 48, 1}} ,{{180, 151}, {61, 48, 1}} ,{{181, 151}, {62, 48, 1}} ,{{182, 151}, {63, 48, 1}} ,{{183, 151}, {64, 48, 1}} ,{{184, 151}, {65, 48, 1}} ,{{185, 151}, {66, 48, 1}} ,{{186, 151}, {67, 48, 1}} ,{{187, 151}, {68, 48, 1}} ,{{188, 151}, {69, 48, 1}} ,{{189, 151}, {70, 48, 1}} ,{{190, 151}, {71, 48, 1}} ,{{191, 151}, {72, 48, 1}} ,{{192, 151}, {73, 48, 1}} ,{{193, 151}, {74, 48, 1}} ,{{194, 151}, {75, 48, 1}} ,{{195, 151}, {76, 48, 1}} ,{{196, 151}, {77, 48, 1}} ,{{197, 151}, {78, 48, 1}} ,{{198, 151}, {79, 48, 1}} ,{{132, 155}, {13, 52, 1}} ,{{133, 155}, {14, 52, 1}} ,{{134, 155}, {15, 52, 1}} ,{{135, 155}, {16, 52, 1}} ,{{136, 155}, {17, 52, 1}} ,{{137, 155}, {18, 52, 1}} ,{{138, 155}, {19, 52, 1}} ,{{139, 155}, {20, 52, 1}} ,{{140, 155}, {21, 52, 1}} ,{{141, 155}, {22, 52, 1}} ,{{142, 155}, {23, 52, 1}} ,{{143, 155}, {24, 52, 1}} ,{{144, 155}, {25, 52, 1}} ,{{145, 155}, {26, 52, 1}} ,{{146, 155}, {27, 52, 1}} ,{{147, 155}, {28, 52, 1}} ,{{148, 155}, {29, 52, 1}} ,{{149, 155}, {30, 52, 1}} ,{{150, 155}, {31, 52, 1}} ,{{151, 155}, {32, 52, 1}} ,{{152, 155}, {33, 52, 1}} ,{{153, 155}, {34, 52, 1}} ,{{154, 155}, {35, 52, 1}} ,{{155, 155}, {36, 52, 1}} ,{{156, 155}, {37, 52, 1}} ,{{157, 155}, {38, 52, 1}} ,{{158, 155}, {39, 52, 1}} ,{{159, 155}, {40, 52, 1}} ,{{160, 155}, {41, 52, 1}} ,{{161, 155}, {42, 52, 1}} ,{{162, 155}, {43, 52, 1}} ,{{163, 155}, {44, 52, 1}} ,{{164, 155}, {45, 52, 1}} ,{{165, 155}, {46, 52, 1}} ,{{199, 151}, {80, 48, 1}} ,{{200, 151}, {81, 48, 1}} ,{{201, 151}, {82, 48, 1}} ,{{202, 151}, {83, 48, 1}} ,{{203, 151}, {84, 48, 1}} ,{{204, 151}, {85, 48, 1}} ,{{205, 151}, {86, 48, 1}} ,{{206, 151}, {87, 48, 1}} ,{{207, 151}, {88, 48, 1}} ,{{208, 151}, {89, 48, 1}} ,{{209, 151}, {90, 48, 1}} ,{{210, 151}, {91, 48, 1}} ,{{211, 151}, {92, 48, 1}} ,{{212, 151}, {93, 48, 1}} ,{{213, 151}, {94, 48, 1}} ,{{214, 151}, {95, 48, 1}} ,{{215, 151}, {96, 48, 1}} ,{{216, 151}, {97, 48, 1}} ,{{217, 151}, {98, 48, 1}} ,{{218, 151}, {99, 48, 1}} ,{{219, 151}, {100, 48, 1}} ,{{220, 151}, {101, 48, 1}} ,{{221, 151}, {102, 48, 1}} ,{{222, 151}, {103, 48, 1}} ,{{223, 151}, {104, 48, 1}} ,{{224, 151}, {105, 48, 1}} ,{{225, 151}, {106, 48, 1}} ,{{226, 151}, {107, 48, 1}} ,{{227, 151}, {108, 48, 1}} ,{{228, 151}, {109, 48, 1}} ,{{229, 151}, {110, 48, 1}} ,{{230, 151}, {111, 48, 1}} ,{{231, 151}, {112, 48, 1}} ,{{232, 151}, {113, 48, 1}} ,{{233, 151}, {114, 48, 1}} ,{{234, 151}, {115, 48, 1}} ,{{235, 151}, {116, 48, 1}} ,{{236, 151}, {117, 48, 1}} ,{{237, 151}, {118, 48, 1}} ,{{238, 151}, {119, 48, 1}} ,{{239, 151}, {120, 48, 1}} ,{{240, 151}, {121, 48, 1}} ,{{241, 151}, {122, 48, 1}} ,{{242, 151}, {123, 48, 1}} ,{{243, 151}, {124, 48, 1}} ,{{244, 151}, {125, 48, 1}} ,{{245, 151}, {126, 48, 1}} ,{{246, 151}, {127, 48, 1}} ,{{247, 151}, {128, 48, 1}} ,{{248, 151}, {129, 48, 1}} ,{{249, 151}, {130, 48, 1}} ,{{250, 151}, {131, 48, 1}} ,{{251, 151}, {132, 48, 1}} ,{{252, 151}, {133, 48, 1}} ,{{253, 151}, {134, 48, 1}} ,{{254, 151}, {135, 48, 1}} ,{{255, 151}, {136, 48, 1}} ,{{0, 152}, {137, 48, 1}} ,{{1, 152}, {138, 48, 1}} ,{{2, 152}, {139, 48, 1}} ,{{3, 152}, {140, 48, 1}} ,{{4, 152}, {141, 48, 1}} ,{{5, 152}, {142, 48, 1}} ,{{6, 152}, {143, 48, 1}} ,{{7, 152}, {144, 48, 1}} ,{{8, 152}, {145, 48, 1}} ,{{9, 152}, {146, 48, 1}} ,{{10, 152}, {147, 48, 1}} ,{{11, 152}, {148, 48, 1}} ,{{12, 152}, {149, 48, 1}} ,{{13, 152}, {150, 48, 1}} ,{{14, 152}, {151, 48, 1}} ,{{15, 152}, {152, 48, 1}} ,{{16, 152}, {153, 48, 1}} ,{{17, 152}, {154, 48, 1}} ,{{18, 152}, {155, 48, 1}} ,{{19, 152}, {156, 48, 1}} ,{{20, 152}, {157, 48, 1}} ,{{21, 152}, {158, 48, 1}} ,{{22, 152}, {159, 48, 1}} ,{{23, 152}, {160, 48, 1}} ,{{24, 152}, {161, 48, 1}} ,{{25, 152}, {162, 48, 1}} ,{{26, 152}, {163, 48, 1}} ,{{27, 152}, {164, 48, 1}} ,{{28, 152}, {165, 48, 1}} ,{{29, 152}, {166, 48, 1}} ,{{30, 152}, {167, 48, 1}} ,{{31, 152}, {168, 48, 1}} ,{{32, 152}, {169, 48, 1}} ,{{33, 152}, {170, 48, 1}} ,{{34, 152}, {171, 48, 1}} ,{{35, 152}, {172, 48, 1}} ,{{36, 152}, {173, 48, 1}} ,{{37, 152}, {174, 48, 1}} ,{{38, 152}, {175, 48, 1}} ,{{39, 152}, {176, 48, 1}} ,{{40, 152}, {177, 48, 1}} ,{{41, 152}, {178, 48, 1}} ,{{42, 152}, {179, 48, 1}} ,{{43, 152}, {180, 48, 1}} ,{{44, 152}, {181, 48, 1}} ,{{45, 152}, {182, 48, 1}} ,{{46, 152}, {183, 48, 1}} ,{{47, 152}, {184, 48, 1}} ,{{48, 152}, {185, 48, 1}} ,{{49, 152}, {186, 48, 1}} ,{{50, 152}, {187, 48, 1}} ,{{51, 152}, {188, 48, 1}} ,{{52, 152}, {189, 48, 1}} ,{{53, 152}, {190, 48, 1}} ,{{54, 152}, {191, 48, 1}} ,{{55, 152}, {192, 48, 1}} ,{{56, 152}, {193, 48, 1}} ,{{57, 152}, {194, 48, 1}} ,{{58, 152}, {195, 48, 1}} ,{{59, 152}, {196, 48, 1}} ,{{60, 152}, {197, 48, 1}} ,{{61, 152}, {198, 48, 1}} ,{{62, 152}, {199, 48, 1}} ,{{63, 152}, {200, 48, 1}} ,{{64, 152}, {201, 48, 1}} ,{{65, 152}, {202, 48, 1}} ,{{66, 152}, {203, 48, 1}} ,{{67, 152}, {204, 48, 1}} ,{{68, 152}, {205, 48, 1}} ,{{69, 152}, {206, 48, 1}} ,{{70, 152}, {207, 48, 1}} ,{{71, 152}, {208, 48, 1}} ,{{72, 152}, {209, 48, 1}} ,{{73, 152}, {210, 48, 1}} ,{{74, 152}, {211, 48, 1}} ,{{75, 152}, {212, 48, 1}} ,{{76, 152}, {213, 48, 1}} ,{{77, 152}, {214, 48, 1}} ,{{78, 152}, {215, 48, 1}} ,{{79, 152}, {216, 48, 1}} ,{{80, 152}, {217, 48, 1}} ,{{81, 152}, {218, 48, 1}} ,{{82, 152}, {219, 48, 1}} ,{{83, 152}, {220, 48, 1}} ,{{84, 152}, {221, 48, 1}} ,{{85, 152}, {222, 48, 1}} ,{{86, 152}, {223, 48, 1}} ,{{87, 152}, {224, 48, 1}} ,{{88, 152}, {225, 48, 1}} ,{{89, 152}, {226, 48, 1}} ,{{90, 152}, {227, 48, 1}} ,{{91, 152}, {228, 48, 1}} ,{{92, 152}, {229, 48, 1}} ,{{93, 152}, {230, 48, 1}} ,{{94, 152}, {231, 48, 1}} ,{{95, 152}, {232, 48, 1}} ,{{96, 152}, {233, 48, 1}} ,{{97, 152}, {234, 48, 1}} ,{{98, 152}, {235, 48, 1}} ,{{99, 152}, {236, 48, 1}} ,{{100, 152}, {237, 48, 1}} ,{{101, 152}, {238, 48, 1}} ,{{102, 152}, {239, 48, 1}} ,{{103, 152}, {240, 48, 1}} ,{{104, 152}, {241, 48, 1}} ,{{105, 152}, {242, 48, 1}} ,{{106, 152}, {243, 48, 1}} ,{{107, 152}, {244, 48, 1}} ,{{108, 152}, {245, 48, 1}} ,{{109, 152}, {246, 48, 1}} ,{{110, 152}, {247, 48, 1}} ,{{111, 152}, {248, 48, 1}} ,{{112, 152}, {249, 48, 1}} ,{{113, 152}, {250, 48, 1}} ,{{114, 152}, {251, 48, 1}} ,{{115, 152}, {252, 48, 1}} ,{{116, 152}, {253, 48, 1}} ,{{117, 152}, {254, 48, 1}} ,{{118, 152}, {255, 48, 1}} ,{{119, 152}, {0, 49, 1}} ,{{120, 152}, {1, 49, 1}} ,{{121, 152}, {2, 49, 1}} ,{{122, 152}, {3, 49, 1}} ,{{123, 152}, {4, 49, 1}} ,{{124, 152}, {5, 49, 1}} ,{{125, 152}, {6, 49, 1}} ,{{126, 152}, {7, 49, 1}} ,{{127, 152}, {8, 49, 1}} ,{{128, 152}, {9, 49, 1}} ,{{129, 152}, {10, 49, 1}} ,{{130, 152}, {11, 49, 1}} ,{{131, 152}, {12, 49, 1}} ,{{132, 152}, {13, 49, 1}} ,{{133, 152}, {14, 49, 1}} ,{{134, 152}, {15, 49, 1}} ,{{135, 152}, {16, 49, 1}} ,{{136, 152}, {17, 49, 1}} ,{{137, 152}, {18, 49, 1}} ,{{138, 152}, {19, 49, 1}} ,{{139, 152}, {20, 49, 1}} ,{{140, 152}, {21, 49, 1}} ,{{141, 152}, {22, 49, 1}} ,{{142, 152}, {23, 49, 1}} ,{{143, 152}, {24, 49, 1}} ,{{144, 152}, {25, 49, 1}} ,{{145, 152}, {26, 49, 1}} ,{{146, 152}, {27, 49, 1}} ,{{147, 152}, {28, 49, 1}} ,{{148, 152}, {29, 49, 1}} ,{{149, 152}, {30, 49, 1}} ,{{150, 152}, {31, 49, 1}} ,{{151, 152}, {32, 49, 1}} ,{{152, 152}, {33, 49, 1}} ,{{153, 152}, {34, 49, 1}} ,{{154, 152}, {35, 49, 1}} ,{{155, 152}, {36, 49, 1}} ,{{156, 152}, {37, 49, 1}} ,{{157, 152}, {38, 49, 1}} ,{{158, 152}, {39, 49, 1}} ,{{159, 152}, {40, 49, 1}} ,{{160, 152}, {41, 49, 1}} ,{{161, 152}, {42, 49, 1}} ,{{162, 152}, {43, 49, 1}} ,{{163, 152}, {44, 49, 1}} ,{{164, 152}, {45, 49, 1}} ,{{165, 152}, {46, 49, 1}} ,{{166, 152}, {47, 49, 1}} ,{{167, 152}, {48, 49, 1}} ,{{168, 152}, {49, 49, 1}} ,{{169, 152}, {50, 49, 1}} ,{{170, 152}, {51, 49, 1}} ,{{171, 152}, {52, 49, 1}} ,{{172, 152}, {53, 49, 1}} ,{{173, 152}, {54, 49, 1}} ,{{174, 152}, {55, 49, 1}} ,{{175, 152}, {56, 49, 1}} ,{{176, 152}, {57, 49, 1}} ,{{177, 152}, {58, 49, 1}} ,{{178, 152}, {59, 49, 1}} ,{{179, 152}, {60, 49, 1}} ,{{180, 152}, {61, 49, 1}} ,{{181, 152}, {62, 49, 1}} ,{{182, 152}, {63, 49, 1}} ,{{183, 152}, {64, 49, 1}} ,{{184, 152}, {65, 49, 1}} ,{{185, 152}, {66, 49, 1}} ,{{186, 152}, {67, 49, 1}} ,{{187, 152}, {68, 49, 1}} ,{{188, 152}, {69, 49, 1}} ,{{189, 152}, {70, 49, 1}} ,{{190, 152}, {71, 49, 1}} ,{{191, 152}, {72, 49, 1}} ,{{192, 152}, {73, 49, 1}} ,{{193, 152}, {74, 49, 1}} ,{{194, 152}, {75, 49, 1}} ,{{195, 152}, {76, 49, 1}} ,{{196, 152}, {77, 49, 1}} ,{{197, 152}, {78, 49, 1}} ,{{198, 152}, {79, 49, 1}} ,{{199, 152}, {80, 49, 1}} ,{{200, 152}, {81, 49, 1}} ,{{201, 152}, {82, 49, 1}} ,{{202, 152}, {83, 49, 1}} ,{{203, 152}, {84, 49, 1}} ,{{204, 152}, {85, 49, 1}} ,{{205, 152}, {86, 49, 1}} ,{{206, 152}, {87, 49, 1}} ,{{207, 152}, {88, 49, 1}} ,{{208, 152}, {89, 49, 1}} ,{{209, 152}, {90, 49, 1}} ,{{210, 152}, {91, 49, 1}} ,{{211, 152}, {92, 49, 1}} ,{{212, 152}, {93, 49, 1}} ,{{213, 152}, {94, 49, 1}} ,{{214, 152}, {95, 49, 1}} ,{{215, 152}, {96, 49, 1}} ,{{216, 152}, {97, 49, 1}} ,{{217, 152}, {98, 49, 1}} ,{{218, 152}, {99, 49, 1}} ,{{219, 152}, {100, 49, 1}} ,{{220, 152}, {101, 49, 1}} ,{{221, 152}, {102, 49, 1}} ,{{222, 152}, {103, 49, 1}} ,{{223, 152}, {104, 49, 1}} ,{{224, 152}, {105, 49, 1}} ,{{225, 152}, {106, 49, 1}} ,{{226, 152}, {107, 49, 1}} ,{{227, 152}, {108, 49, 1}} ,{{228, 152}, {109, 49, 1}} ,{{229, 152}, {110, 49, 1}} ,{{230, 152}, {111, 49, 1}} ,{{231, 152}, {112, 49, 1}} ,{{232, 152}, {113, 49, 1}} ,{{233, 152}, {114, 49, 1}} ,{{234, 152}, {115, 49, 1}} ,{{235, 152}, {116, 49, 1}} ,{{236, 152}, {117, 49, 1}} ,{{237, 152}, {118, 49, 1}} ,{{238, 152}, {119, 49, 1}} ,{{239, 152}, {120, 49, 1}} ,{{240, 152}, {121, 49, 1}} ,{{241, 152}, {122, 49, 1}} ,{{242, 152}, {123, 49, 1}} ,{{243, 152}, {124, 49, 1}} ,{{244, 152}, {125, 49, 1}} ,{{245, 152}, {126, 49, 1}} ,{{246, 152}, {127, 49, 1}} ,{{247, 152}, {128, 49, 1}} ,{{248, 152}, {129, 49, 1}} ,{{249, 152}, {130, 49, 1}} ,{{250, 152}, {131, 49, 1}} ,{{251, 152}, {132, 49, 1}} ,{{252, 152}, {133, 49, 1}} ,{{253, 152}, {134, 49, 1}} ,{{254, 152}, {135, 49, 1}} ,{{255, 152}, {136, 49, 1}} ,{{0, 153}, {137, 49, 1}} ,{{1, 153}, {138, 49, 1}} ,{{2, 153}, {139, 49, 1}} ,{{3, 153}, {140, 49, 1}} ,{{4, 153}, {141, 49, 1}} ,{{5, 153}, {142, 49, 1}} ,{{6, 153}, {143, 49, 1}} ,{{7, 153}, {144, 49, 1}} ,{{8, 153}, {145, 49, 1}} ,{{9, 153}, {146, 49, 1}} ,{{10, 153}, {147, 49, 1}} ,{{11, 153}, {148, 49, 1}} ,{{12, 153}, {149, 49, 1}} ,{{13, 153}, {150, 49, 1}} ,{{14, 153}, {151, 49, 1}} ,{{15, 153}, {152, 49, 1}} ,{{16, 153}, {153, 49, 1}} ,{{17, 153}, {154, 49, 1}} ,{{18, 153}, {155, 49, 1}} ,{{19, 153}, {156, 49, 1}} ,{{20, 153}, {157, 49, 1}} ,{{21, 153}, {158, 49, 1}} ,{{22, 153}, {159, 49, 1}} ,{{23, 153}, {160, 49, 1}} ,{{24, 153}, {161, 49, 1}} ,{{25, 153}, {162, 49, 1}} ,{{26, 153}, {163, 49, 1}} ,{{27, 153}, {164, 49, 1}} ,{{28, 153}, {165, 49, 1}} ,{{29, 153}, {166, 49, 1}} ,{{30, 153}, {167, 49, 1}} ,{{31, 153}, {168, 49, 1}} ,{{32, 153}, {169, 49, 1}} ,{{33, 153}, {170, 49, 1}} ,{{34, 153}, {171, 49, 1}} ,{{35, 153}, {172, 49, 1}} ,{{36, 153}, {173, 49, 1}} ,{{37, 153}, {174, 49, 1}} ,{{38, 153}, {175, 49, 1}} ,{{39, 153}, {176, 49, 1}} ,{{40, 153}, {177, 49, 1}} ,{{41, 153}, {178, 49, 1}} ,{{42, 153}, {179, 49, 1}} ,{{43, 153}, {180, 49, 1}} ,{{44, 153}, {181, 49, 1}} ,{{45, 153}, {182, 49, 1}} ,{{46, 153}, {183, 49, 1}} ,{{47, 153}, {184, 49, 1}} ,{{48, 153}, {185, 49, 1}} ,{{49, 153}, {186, 49, 1}} ,{{50, 153}, {187, 49, 1}} ,{{51, 153}, {188, 49, 1}} ,{{52, 153}, {189, 49, 1}} ,{{53, 153}, {190, 49, 1}} ,{{54, 153}, {191, 49, 1}} ,{{55, 153}, {192, 49, 1}} ,{{56, 153}, {193, 49, 1}} ,{{57, 153}, {194, 49, 1}} ,{{58, 153}, {195, 49, 1}} ,{{59, 153}, {196, 49, 1}} ,{{60, 153}, {197, 49, 1}} ,{{61, 153}, {198, 49, 1}} ,{{62, 153}, {199, 49, 1}} ,{{63, 153}, {200, 49, 1}} ,{{64, 153}, {201, 49, 1}} ,{{65, 153}, {202, 49, 1}} ,{{66, 153}, {203, 49, 1}} ,{{67, 153}, {204, 49, 1}} ,{{68, 153}, {205, 49, 1}} ,{{69, 153}, {206, 49, 1}} ,{{70, 153}, {207, 49, 1}} ,{{71, 153}, {208, 49, 1}} ,{{72, 153}, {209, 49, 1}} ,{{73, 153}, {210, 49, 1}} ,{{74, 153}, {211, 49, 1}} ,{{75, 153}, {212, 49, 1}} ,{{76, 153}, {213, 49, 1}} ,{{77, 153}, {214, 49, 1}} ,{{78, 153}, {215, 49, 1}} ,{{79, 153}, {216, 49, 1}} ,{{80, 153}, {217, 49, 1}} ,{{81, 153}, {218, 49, 1}} ,{{82, 153}, {219, 49, 1}} ,{{83, 153}, {220, 49, 1}} ,{{84, 153}, {221, 49, 1}} ,{{85, 153}, {222, 49, 1}} ,{{86, 153}, {223, 49, 1}} ,{{87, 153}, {224, 49, 1}} ,{{88, 153}, {225, 49, 1}} ,{{89, 153}, {226, 49, 1}} ,{{90, 153}, {227, 49, 1}} ,{{91, 153}, {228, 49, 1}} ,{{92, 153}, {229, 49, 1}} ,{{93, 153}, {230, 49, 1}} ,{{94, 153}, {231, 49, 1}} ,{{95, 153}, {232, 49, 1}} ,{{96, 153}, {233, 49, 1}} ,{{97, 153}, {234, 49, 1}} ,{{98, 153}, {235, 49, 1}} ,{{99, 153}, {236, 49, 1}} ,{{100, 153}, {237, 49, 1}} ,{{101, 153}, {238, 49, 1}} ,{{102, 153}, {239, 49, 1}} ,{{103, 153}, {240, 49, 1}} ,{{104, 153}, {241, 49, 1}} ,{{105, 153}, {242, 49, 1}} ,{{106, 153}, {243, 49, 1}} ,{{107, 153}, {244, 49, 1}} ,{{108, 153}, {245, 49, 1}} ,{{109, 153}, {246, 49, 1}} ,{{110, 153}, {247, 49, 1}} ,{{111, 153}, {248, 49, 1}} ,{{112, 153}, {249, 49, 1}} ,{{113, 153}, {250, 49, 1}} ,{{114, 153}, {251, 49, 1}} ,{{115, 153}, {252, 49, 1}} ,{{116, 153}, {253, 49, 1}} ,{{117, 153}, {254, 49, 1}} ,{{118, 153}, {255, 49, 1}} ,{{119, 153}, {0, 50, 1}} ,{{120, 153}, {1, 50, 1}} ,{{121, 153}, {2, 50, 1}} ,{{122, 153}, {3, 50, 1}} ,{{123, 153}, {4, 50, 1}} ,{{124, 153}, {5, 50, 1}} ,{{125, 153}, {6, 50, 1}} ,{{126, 153}, {7, 50, 1}} ,{{127, 153}, {8, 50, 1}} ,{{128, 153}, {9, 50, 1}} ,{{129, 153}, {10, 50, 1}} ,{{130, 153}, {11, 50, 1}} ,{{131, 153}, {12, 50, 1}} ,{{132, 153}, {13, 50, 1}} ,{{133, 153}, {14, 50, 1}} ,{{134, 153}, {15, 50, 1}} ,{{135, 153}, {16, 50, 1}} ,{{136, 153}, {17, 50, 1}} ,{{137, 153}, {18, 50, 1}} ,{{138, 153}, {19, 50, 1}} ,{{139, 153}, {20, 50, 1}} ,{{140, 153}, {21, 50, 1}} ,{{141, 153}, {22, 50, 1}} ,{{142, 153}, {23, 50, 1}} ,{{143, 153}, {24, 50, 1}} ,{{144, 153}, {25, 50, 1}} ,{{145, 153}, {26, 50, 1}} ,{{146, 153}, {27, 50, 1}} ,{{147, 153}, {28, 50, 1}} ,{{148, 153}, {29, 50, 1}} ,{{149, 153}, {30, 50, 1}} ,{{150, 153}, {31, 50, 1}} ,{{151, 153}, {32, 50, 1}} ,{{152, 153}, {33, 50, 1}} ,{{153, 153}, {34, 50, 1}} ,{{154, 153}, {35, 50, 1}} ,{{155, 153}, {36, 50, 1}} ,{{156, 153}, {37, 50, 1}} ,{{157, 153}, {38, 50, 1}} ,{{158, 153}, {39, 50, 1}} ,{{159, 153}, {40, 50, 1}} ,{{160, 153}, {41, 50, 1}} ,{{161, 153}, {42, 50, 1}} ,{{162, 153}, {43, 50, 1}} ,{{163, 153}, {44, 50, 1}} ,{{164, 153}, {45, 50, 1}} ,{{165, 153}, {46, 50, 1}} ,{{166, 153}, {47, 50, 1}} ,{{167, 153}, {48, 50, 1}} ,{{168, 153}, {49, 50, 1}} ,{{169, 153}, {50, 50, 1}} ,{{170, 153}, {51, 50, 1}} ,{{171, 153}, {52, 50, 1}} ,{{172, 153}, {53, 50, 1}} ,{{173, 153}, {54, 50, 1}} ,{{174, 153}, {55, 50, 1}} ,{{175, 153}, {56, 50, 1}} ,{{176, 153}, {57, 50, 1}} ,{{177, 153}, {58, 50, 1}} ,{{178, 153}, {59, 50, 1}} ,{{179, 153}, {60, 50, 1}} ,{{180, 153}, {61, 50, 1}} ,{{181, 153}, {62, 50, 1}} ,{{182, 153}, {63, 50, 1}} ,{{183, 153}, {64, 50, 1}} ,{{184, 153}, {65, 50, 1}} ,{{185, 153}, {66, 50, 1}} ,{{186, 153}, {67, 50, 1}} ,{{187, 153}, {68, 50, 1}} ,{{188, 153}, {69, 50, 1}} ,{{189, 153}, {70, 50, 1}} ,{{190, 153}, {71, 50, 1}} ,{{191, 153}, {72, 50, 1}} ,{{192, 153}, {73, 50, 1}} ,{{193, 153}, {74, 50, 1}} ,{{194, 153}, {75, 50, 1}} ,{{195, 153}, {76, 50, 1}} ,{{196, 153}, {77, 50, 1}} ,{{197, 153}, {78, 50, 1}} ,{{198, 153}, {79, 50, 1}} ,{{199, 153}, {80, 50, 1}} ,{{200, 153}, {81, 50, 1}} ,{{201, 153}, {82, 50, 1}} ,{{202, 153}, {83, 50, 1}} ,{{203, 153}, {84, 50, 1}} ,{{204, 153}, {85, 50, 1}} ,{{205, 153}, {86, 50, 1}} ,{{206, 153}, {87, 50, 1}} ,{{207, 153}, {88, 50, 1}} ,{{208, 153}, {89, 50, 1}} ,{{209, 153}, {90, 50, 1}} ,{{210, 153}, {91, 50, 1}} ,{{211, 153}, {92, 50, 1}} ,{{212, 153}, {93, 50, 1}} ,{{213, 153}, {94, 50, 1}} ,{{214, 153}, {95, 50, 1}} ,{{215, 153}, {96, 50, 1}} ,{{216, 153}, {97, 50, 1}} ,{{217, 153}, {98, 50, 1}} ,{{218, 153}, {99, 50, 1}} ,{{219, 153}, {100, 50, 1}} ,{{220, 153}, {101, 50, 1}} ,{{221, 153}, {102, 50, 1}} ,{{222, 153}, {103, 50, 1}} ,{{223, 153}, {104, 50, 1}} ,{{224, 153}, {105, 50, 1}} ,{{225, 153}, {106, 50, 1}} ,{{226, 153}, {107, 50, 1}} ,{{227, 153}, {108, 50, 1}} ,{{228, 153}, {109, 50, 1}} ,{{229, 153}, {110, 50, 1}} ,{{230, 153}, {111, 50, 1}} ,{{231, 153}, {112, 50, 1}} ,{{232, 153}, {113, 50, 1}} ,{{233, 153}, {114, 50, 1}} ,{{234, 153}, {115, 50, 1}} ,{{235, 153}, {116, 50, 1}} ,{{236, 153}, {117, 50, 1}} ,{{237, 153}, {118, 50, 1}} ,{{238, 153}, {119, 50, 1}} ,{{239, 153}, {120, 50, 1}} ,{{240, 153}, {121, 50, 1}} ,{{241, 153}, {122, 50, 1}} ,{{242, 153}, {123, 50, 1}} ,{{243, 153}, {124, 50, 1}} ,{{244, 153}, {125, 50, 1}} ,{{245, 153}, {126, 50, 1}} ,{{246, 153}, {127, 50, 1}} ,{{247, 153}, {128, 50, 1}} ,{{248, 153}, {129, 50, 1}} ,{{249, 153}, {130, 50, 1}} ,{{250, 153}, {131, 50, 1}} ,{{251, 153}, {132, 50, 1}} ,{{252, 153}, {133, 50, 1}} ,{{253, 153}, {134, 50, 1}} ,{{254, 153}, {135, 50, 1}} ,{{255, 153}, {136, 50, 1}} ,{{0, 154}, {137, 50, 1}} ,{{1, 154}, {138, 50, 1}} ,{{2, 154}, {139, 50, 1}} ,{{3, 154}, {140, 50, 1}} ,{{4, 154}, {141, 50, 1}} ,{{5, 154}, {142, 50, 1}} ,{{6, 154}, {143, 50, 1}} ,{{7, 154}, {144, 50, 1}} ,{{8, 154}, {145, 50, 1}} ,{{9, 154}, {146, 50, 1}} ,{{10, 154}, {147, 50, 1}} ,{{11, 154}, {148, 50, 1}} ,{{12, 154}, {149, 50, 1}} ,{{13, 154}, {150, 50, 1}} ,{{14, 154}, {151, 50, 1}} ,{{15, 154}, {152, 50, 1}} ,{{16, 154}, {153, 50, 1}} ,{{17, 154}, {154, 50, 1}} ,{{18, 154}, {155, 50, 1}} ,{{19, 154}, {156, 50, 1}} ,{{20, 154}, {157, 50, 1}} ,{{21, 154}, {158, 50, 1}} ,{{22, 154}, {159, 50, 1}} ,{{23, 154}, {160, 50, 1}} ,{{24, 154}, {161, 50, 1}} ,{{25, 154}, {162, 50, 1}} ,{{26, 154}, {163, 50, 1}} ,{{27, 154}, {164, 50, 1}} ,{{28, 154}, {165, 50, 1}} ,{{29, 154}, {166, 50, 1}} ,{{30, 154}, {167, 50, 1}} ,{{31, 154}, {168, 50, 1}} ,{{32, 154}, {169, 50, 1}} ,{{33, 154}, {170, 50, 1}} ,{{34, 154}, {171, 50, 1}} ,{{35, 154}, {172, 50, 1}} ,{{36, 154}, {173, 50, 1}} ,{{37, 154}, {174, 50, 1}} ,{{38, 154}, {175, 50, 1}} ,{{39, 154}, {176, 50, 1}} ,{{40, 154}, {177, 50, 1}} ,{{41, 154}, {178, 50, 1}} ,{{42, 154}, {179, 50, 1}} ,{{43, 154}, {180, 50, 1}} ,{{44, 154}, {181, 50, 1}} ,{{45, 154}, {182, 50, 1}} ,{{46, 154}, {183, 50, 1}} ,{{47, 154}, {184, 50, 1}} ,{{48, 154}, {185, 50, 1}} ,{{49, 154}, {186, 50, 1}} ,{{50, 154}, {187, 50, 1}} ,{{51, 154}, {188, 50, 1}} ,{{52, 154}, {189, 50, 1}} ,{{53, 154}, {190, 50, 1}} ,{{54, 154}, {191, 50, 1}} ,{{55, 154}, {192, 50, 1}} ,{{56, 154}, {193, 50, 1}} ,{{57, 154}, {194, 50, 1}} ,{{58, 154}, {195, 50, 1}} ,{{59, 154}, {196, 50, 1}} ,{{60, 154}, {197, 50, 1}} ,{{61, 154}, {198, 50, 1}} ,{{62, 154}, {199, 50, 1}} ,{{63, 154}, {200, 50, 1}} ,{{64, 154}, {201, 50, 1}} ,{{65, 154}, {202, 50, 1}} ,{{66, 154}, {203, 50, 1}} ,{{67, 154}, {204, 50, 1}} ,{{68, 154}, {205, 50, 1}} ,{{69, 154}, {206, 50, 1}} ,{{70, 154}, {207, 50, 1}} ,{{71, 154}, {208, 50, 1}} ,{{72, 154}, {209, 50, 1}} ,{{73, 154}, {210, 50, 1}} ,{{74, 154}, {211, 50, 1}} ,{{75, 154}, {212, 50, 1}} ,{{76, 154}, {213, 50, 1}} ,{{77, 154}, {214, 50, 1}} ,{{78, 154}, {215, 50, 1}} ,{{79, 154}, {216, 50, 1}} ,{{80, 154}, {217, 50, 1}} ,{{81, 154}, {218, 50, 1}} ,{{82, 154}, {219, 50, 1}} ,{{83, 154}, {220, 50, 1}} ,{{84, 154}, {221, 50, 1}} ,{{85, 154}, {222, 50, 1}} ,{{86, 154}, {223, 50, 1}} ,{{87, 154}, {224, 50, 1}} ,{{88, 154}, {225, 50, 1}} ,{{89, 154}, {226, 50, 1}} ,{{90, 154}, {227, 50, 1}} ,{{91, 154}, {228, 50, 1}} ,{{92, 154}, {229, 50, 1}} ,{{93, 154}, {230, 50, 1}} ,{{94, 154}, {231, 50, 1}} ,{{95, 154}, {232, 50, 1}} ,{{96, 154}, {233, 50, 1}} ,{{97, 154}, {234, 50, 1}} ,{{98, 154}, {235, 50, 1}} ,{{99, 154}, {236, 50, 1}} ,{{100, 154}, {237, 50, 1}} ,{{101, 154}, {238, 50, 1}} ,{{102, 154}, {239, 50, 1}} ,{{103, 154}, {240, 50, 1}} ,{{104, 154}, {241, 50, 1}} ,{{105, 154}, {242, 50, 1}} ,{{106, 154}, {243, 50, 1}} ,{{107, 154}, {244, 50, 1}} ,{{108, 154}, {245, 50, 1}} ,{{109, 154}, {246, 50, 1}} ,{{110, 154}, {247, 50, 1}} ,{{111, 154}, {248, 50, 1}} ,{{112, 154}, {249, 50, 1}} ,{{113, 154}, {250, 50, 1}} ,{{114, 154}, {251, 50, 1}} ,{{115, 154}, {252, 50, 1}} ,{{116, 154}, {253, 50, 1}} ,{{117, 154}, {254, 50, 1}} ,{{118, 154}, {255, 50, 1}} ,{{119, 154}, {0, 51, 1}} ,{{120, 154}, {1, 51, 1}} ,{{121, 154}, {2, 51, 1}} ,{{122, 154}, {3, 51, 1}} ,{{123, 154}, {4, 51, 1}} ,{{124, 154}, {5, 51, 1}} ,{{125, 154}, {6, 51, 1}} ,{{126, 154}, {7, 51, 1}} ,{{127, 154}, {8, 51, 1}} ,{{128, 154}, {9, 51, 1}} ,{{129, 154}, {10, 51, 1}} ,{{130, 154}, {11, 51, 1}} ,{{131, 154}, {12, 51, 1}} ,{{132, 154}, {13, 51, 1}} ,{{133, 154}, {14, 51, 1}} ,{{134, 154}, {15, 51, 1}} ,{{135, 154}, {16, 51, 1}} ,{{136, 154}, {17, 51, 1}} ,{{137, 154}, {18, 51, 1}} ,{{138, 154}, {19, 51, 1}} ,{{139, 154}, {20, 51, 1}} ,{{140, 154}, {21, 51, 1}} ,{{141, 154}, {22, 51, 1}} ,{{142, 154}, {23, 51, 1}} ,{{143, 154}, {24, 51, 1}} ,{{144, 154}, {25, 51, 1}} ,{{145, 154}, {26, 51, 1}} ,{{146, 154}, {27, 51, 1}} ,{{147, 154}, {28, 51, 1}} ,{{148, 154}, {29, 51, 1}} ,{{149, 154}, {30, 51, 1}} ,{{150, 154}, {31, 51, 1}} ,{{151, 154}, {32, 51, 1}} ,{{152, 154}, {33, 51, 1}} ,{{153, 154}, {34, 51, 1}} ,{{154, 154}, {35, 51, 1}} ,{{155, 154}, {36, 51, 1}} ,{{156, 154}, {37, 51, 1}} ,{{157, 154}, {38, 51, 1}} ,{{158, 154}, {39, 51, 1}} ,{{159, 154}, {40, 51, 1}} ,{{160, 154}, {41, 51, 1}} ,{{161, 154}, {42, 51, 1}} ,{{162, 154}, {43, 51, 1}} ,{{163, 154}, {44, 51, 1}} ,{{164, 154}, {45, 51, 1}} ,{{165, 154}, {46, 51, 1}} ,{{166, 154}, {47, 51, 1}} ,{{167, 154}, {48, 51, 1}} ,{{168, 154}, {49, 51, 1}} ,{{169, 154}, {50, 51, 1}} ,{{170, 154}, {51, 51, 1}} ,{{171, 154}, {52, 51, 1}} ,{{172, 154}, {53, 51, 1}} ,{{173, 154}, {54, 51, 1}} ,{{174, 154}, {55, 51, 1}} ,{{175, 154}, {56, 51, 1}} ,{{176, 154}, {57, 51, 1}} ,{{177, 154}, {58, 51, 1}} ,{{178, 154}, {59, 51, 1}} ,{{179, 154}, {60, 51, 1}} ,{{180, 154}, {61, 51, 1}} ,{{181, 154}, {62, 51, 1}} ,{{182, 154}, {63, 51, 1}} ,{{183, 154}, {64, 51, 1}} ,{{184, 154}, {65, 51, 1}} ,{{185, 154}, {66, 51, 1}} ,{{186, 154}, {67, 51, 1}} ,{{187, 154}, {68, 51, 1}} ,{{188, 154}, {69, 51, 1}} ,{{189, 154}, {70, 51, 1}} ,{{190, 154}, {71, 51, 1}} ,{{191, 154}, {72, 51, 1}} ,{{192, 154}, {73, 51, 1}} ,{{193, 154}, {74, 51, 1}} ,{{194, 154}, {75, 51, 1}} ,{{195, 154}, {76, 51, 1}} ,{{196, 154}, {77, 51, 1}} ,{{197, 154}, {78, 51, 1}} ,{{198, 154}, {79, 51, 1}} ,{{199, 154}, {80, 51, 1}} ,{{200, 154}, {81, 51, 1}} ,{{201, 154}, {82, 51, 1}} ,{{202, 154}, {83, 51, 1}} ,{{203, 154}, {84, 51, 1}} ,{{204, 154}, {85, 51, 1}} ,{{205, 154}, {86, 51, 1}} ,{{206, 154}, {87, 51, 1}} ,{{207, 154}, {88, 51, 1}} ,{{208, 154}, {89, 51, 1}} ,{{209, 154}, {90, 51, 1}} ,{{210, 154}, {91, 51, 1}} ,{{211, 154}, {92, 51, 1}} ,{{212, 154}, {93, 51, 1}} ,{{213, 154}, {94, 51, 1}} ,{{214, 154}, {95, 51, 1}} ,{{215, 154}, {96, 51, 1}} ,{{216, 154}, {97, 51, 1}} ,{{217, 154}, {98, 51, 1}} ,{{218, 154}, {99, 51, 1}} ,{{219, 154}, {100, 51, 1}} ,{{220, 154}, {101, 51, 1}} ,{{221, 154}, {102, 51, 1}} ,{{222, 154}, {103, 51, 1}} ,{{223, 154}, {104, 51, 1}} ,{{224, 154}, {105, 51, 1}} ,{{225, 154}, {106, 51, 1}} ,{{226, 154}, {107, 51, 1}} ,{{227, 154}, {108, 51, 1}} ,{{228, 154}, {109, 51, 1}} ,{{229, 154}, {110, 51, 1}} ,{{230, 154}, {111, 51, 1}} ,{{231, 154}, {112, 51, 1}} ,{{232, 154}, {113, 51, 1}} ,{{233, 154}, {114, 51, 1}} ,{{234, 154}, {115, 51, 1}} ,{{235, 154}, {116, 51, 1}} ,{{236, 154}, {117, 51, 1}} ,{{237, 154}, {118, 51, 1}} ,{{238, 154}, {119, 51, 1}} ,{{239, 154}, {120, 51, 1}} ,{{240, 154}, {121, 51, 1}} ,{{241, 154}, {122, 51, 1}} ,{{242, 154}, {123, 51, 1}} ,{{243, 154}, {124, 51, 1}} ,{{244, 154}, {125, 51, 1}} ,{{245, 154}, {126, 51, 1}} ,{{246, 154}, {127, 51, 1}} ,{{247, 154}, {128, 51, 1}} ,{{248, 154}, {129, 51, 1}} ,{{249, 154}, {130, 51, 1}} ,{{250, 154}, {131, 51, 1}} ,{{251, 154}, {132, 51, 1}} ,{{252, 154}, {133, 51, 1}} ,{{253, 154}, {134, 51, 1}} ,{{254, 154}, {135, 51, 1}} ,{{255, 154}, {136, 51, 1}} ,{{0, 155}, {137, 51, 1}} ,{{1, 155}, {138, 51, 1}} ,{{2, 155}, {139, 51, 1}} ,{{3, 155}, {140, 51, 1}} ,{{4, 155}, {141, 51, 1}} ,{{5, 155}, {142, 51, 1}} ,{{6, 155}, {143, 51, 1}} ,{{7, 155}, {144, 51, 1}} ,{{8, 155}, {145, 51, 1}} ,{{9, 155}, {146, 51, 1}} ,{{10, 155}, {147, 51, 1}} ,{{11, 155}, {148, 51, 1}} ,{{12, 155}, {149, 51, 1}} ,{{13, 155}, {150, 51, 1}} ,{{14, 155}, {151, 51, 1}} ,{{15, 155}, {152, 51, 1}} ,{{16, 155}, {153, 51, 1}} ,{{17, 155}, {154, 51, 1}} ,{{18, 155}, {155, 51, 1}} ,{{19, 155}, {156, 51, 1}} ,{{20, 155}, {157, 51, 1}} ,{{21, 155}, {158, 51, 1}} ,{{22, 155}, {159, 51, 1}} ,{{23, 155}, {160, 51, 1}} ,{{24, 155}, {161, 51, 1}} ,{{25, 155}, {162, 51, 1}} ,{{26, 155}, {163, 51, 1}} ,{{27, 155}, {164, 51, 1}} ,{{28, 155}, {165, 51, 1}} ,{{29, 155}, {166, 51, 1}} ,{{30, 155}, {167, 51, 1}} ,{{31, 155}, {168, 51, 1}} ,{{32, 155}, {169, 51, 1}} ,{{33, 155}, {170, 51, 1}} ,{{34, 155}, {171, 51, 1}} ,{{35, 155}, {172, 51, 1}} ,{{36, 155}, {173, 51, 1}} ,{{37, 155}, {174, 51, 1}} ,{{38, 155}, {175, 51, 1}} ,{{39, 155}, {176, 51, 1}} ,{{40, 155}, {177, 51, 1}} ,{{41, 155}, {178, 51, 1}} ,{{42, 155}, {179, 51, 1}} ,{{43, 155}, {180, 51, 1}} ,{{44, 155}, {181, 51, 1}} ,{{45, 155}, {182, 51, 1}} ,{{46, 155}, {183, 51, 1}} ,{{47, 155}, {184, 51, 1}} ,{{48, 155}, {185, 51, 1}} ,{{49, 155}, {186, 51, 1}} ,{{50, 155}, {187, 51, 1}} ,{{51, 155}, {188, 51, 1}} ,{{52, 155}, {189, 51, 1}} ,{{53, 155}, {190, 51, 1}} ,{{54, 155}, {191, 51, 1}} ,{{55, 155}, {192, 51, 1}} ,{{56, 155}, {193, 51, 1}} ,{{57, 155}, {194, 51, 1}} ,{{58, 155}, {195, 51, 1}} ,{{59, 155}, {196, 51, 1}} ,{{60, 155}, {197, 51, 1}} ,{{61, 155}, {198, 51, 1}} ,{{62, 155}, {199, 51, 1}} ,{{63, 155}, {200, 51, 1}} ,{{64, 155}, {201, 51, 1}} ,{{65, 155}, {202, 51, 1}} ,{{66, 155}, {203, 51, 1}} ,{{67, 155}, {204, 51, 1}} ,{{68, 155}, {205, 51, 1}} ,{{69, 155}, {206, 51, 1}} ,{{70, 155}, {207, 51, 1}} ,{{71, 155}, {208, 51, 1}} ,{{72, 155}, {209, 51, 1}} ,{{73, 155}, {210, 51, 1}} ,{{74, 155}, {211, 51, 1}} ,{{75, 155}, {212, 51, 1}} ,{{76, 155}, {213, 51, 1}} ,{{77, 155}, {214, 51, 1}} ,{{78, 155}, {215, 51, 1}} ,{{79, 155}, {216, 51, 1}} ,{{80, 155}, {217, 51, 1}} ,{{81, 155}, {218, 51, 1}} ,{{82, 155}, {219, 51, 1}} ,{{83, 155}, {220, 51, 1}} ,{{84, 155}, {221, 51, 1}} ,{{85, 155}, {222, 51, 1}} ,{{86, 155}, {223, 51, 1}} ,{{87, 155}, {224, 51, 1}} ,{{88, 155}, {225, 51, 1}} ,{{89, 155}, {226, 51, 1}} ,{{90, 155}, {227, 51, 1}} ,{{91, 155}, {228, 51, 1}} ,{{92, 155}, {229, 51, 1}} ,{{93, 155}, {230, 51, 1}} ,{{94, 155}, {231, 51, 1}} ,{{95, 155}, {232, 51, 1}} ,{{96, 155}, {233, 51, 1}} ,{{97, 155}, {234, 51, 1}} ,{{98, 155}, {235, 51, 1}} ,{{99, 155}, {236, 51, 1}} ,{{100, 155}, {237, 51, 1}} ,{{101, 155}, {238, 51, 1}} ,{{102, 155}, {239, 51, 1}} ,{{103, 155}, {240, 51, 1}} ,{{104, 155}, {241, 51, 1}} ,{{105, 155}, {242, 51, 1}} ,{{106, 155}, {243, 51, 1}} ,{{107, 155}, {244, 51, 1}} ,{{108, 155}, {245, 51, 1}} ,{{109, 155}, {246, 51, 1}} ,{{110, 155}, {247, 51, 1}} ,{{111, 155}, {248, 51, 1}} ,{{112, 155}, {249, 51, 1}} ,{{113, 155}, {250, 51, 1}} ,{{114, 155}, {251, 51, 1}} ,{{115, 155}, {252, 51, 1}} ,{{116, 155}, {253, 51, 1}} ,{{117, 155}, {254, 51, 1}} ,{{118, 155}, {255, 51, 1}} ,{{119, 155}, {0, 52, 1}} ,{{120, 155}, {1, 52, 1}} ,{{121, 155}, {2, 52, 1}} ,{{122, 155}, {3, 52, 1}} ,{{123, 155}, {4, 52, 1}} ,{{124, 155}, {5, 52, 1}} ,{{125, 155}, {6, 52, 1}} ,{{126, 155}, {7, 52, 1}} ,{{127, 155}, {8, 52, 1}} ,{{128, 155}, {9, 52, 1}} ,{{129, 155}, {10, 52, 1}} ,{{130, 155}, {11, 52, 1}} ,{{131, 155}, {12, 52, 1}} ,{{54, 70}, {106, 38, 0}} ,{{2, 71}, {65, 39, 0}} ,{{245, 70}, {52, 39, 0}} ,{{246, 70}, {53, 39, 0}} ,{{248, 70}, {55, 39, 0}} ,{{244, 70}, {51, 39, 0}} ,{{11, 71}, {74, 39, 0}} ,{{224, 67}, {207, 35, 0}} ,{{248, 67}, {231, 35, 0}} ,{{18, 67}, {1, 35, 0}} ,{{25, 66}, {8, 34, 0}} ,{{138, 74}, {217, 42, 0}} ,{{131, 71}, {210, 39, 0}} ,{{6, 67}, {245, 34, 0}} ,{{3, 67}, {242, 34, 0}} ,{{7, 67}, {246, 34, 0}} ,{{10, 67}, {249, 34, 0}} ,{{9, 67}, {248, 34, 0}} ,{{4, 67}, {243, 34, 0}} ,{{148, 67}, {131, 35, 0}} ,{{22, 66}, {5, 34, 0}} ,{{101, 73}, {180, 41, 0}} ,{{98, 73}, {177, 41, 0}} ,{{100, 73}, {179, 41, 0}} ,{{99, 73}, {178, 41, 0}} ,{{100, 64}, {20, 32, 0}} ,{{81, 64}, {1, 32, 0}} ,{{83, 64}, {3, 32, 0}} ,{{31, 66}, {14, 34, 0}} ,{{151, 67}, {134, 35, 0}} ,{{205, 70}, {9, 39, 0}} ,{{99, 64}, {19, 32, 0}} ,{{80, 64}, {0, 32, 0}} ,{{82, 64}, {2, 32, 0}} ,{{102, 66}, {85, 34, 0}} ,{{0, 38}, {61, 0, 0}} ,{{241, 74}, {64, 43, 0}} ,{{34, 74}, {113, 42, 0}} ,{{34, 73}, {113, 41, 0}} ,{{36, 74}, {115, 42, 0}} ,{{148, 73}, {227, 41, 0}} ,{{149, 73}, {228, 41, 0}} ,{{95, 74}, {174, 42, 0}} ,{{23, 74}, {102, 42, 0}} ,{{40, 74}, {119, 42, 0}} ,{{31, 74}, {110, 42, 0}} ,{{230, 66}, {213, 34, 0}} ,{{110, 66}, {93, 34, 0}} ,{{238, 66}, {221, 34, 0}} ,{{237, 66}, {220, 34, 0}} ,{{239, 66}, {222, 34, 0}} ,{{240, 66}, {223, 34, 0}} ,{{107, 66}, {90, 34, 0}} ,{{94, 66}, {77, 34, 0}} ,{{41, 74}, {120, 42, 0}} ,{{60, 67}, {43, 35, 0}} ,{{55, 67}, {38, 35, 0}} ,{{164, 73}, {243, 41, 0}} ,{{162, 73}, {241, 41, 0}} ,{{160, 73}, {239, 41, 0}} ,{{163, 73}, {242, 41, 0}} ,{{161, 73}, {240, 41, 0}} ,{{159, 73}, {238, 41, 0}} ,{{69, 65}, {46, 33, 0}} ,{{106, 66}, {89, 34, 0}} ,{{161, 53}, {101, 19, 0}} ,{{155, 53}, {95, 19, 0}} ,{{159, 53}, {99, 19, 0}} ,{{172, 53}, {112, 19, 0}} ,{{169, 53}, {109, 19, 0}} ,{{168, 53}, {108, 19, 0}} ,{{173, 53}, {113, 19, 0}} ,{{165, 53}, {105, 19, 0}} ,{{171, 53}, {111, 19, 0}} ,{{170, 53}, {110, 19, 0}} ,{{167, 53}, {107, 19, 0}} ,{{166, 53}, {106, 19, 0}} ,{{158, 53}, {98, 19, 0}} ,{{181, 53}, {121, 19, 0}} ,{{178, 53}, {118, 19, 0}} ,{{177, 53}, {117, 19, 0}} ,{{183, 53}, {123, 19, 0}} ,{{182, 53}, {122, 19, 0}} ,{{180, 53}, {120, 19, 0}} ,{{179, 53}, {119, 19, 0}} ,{{174, 53}, {114, 19, 0}} ,{{184, 53}, {124, 19, 0}} ,{{176, 53}, {116, 19, 0}} ,{{175, 53}, {115, 19, 0}} ,{{164, 53}, {104, 19, 0}} ,{{162, 53}, {102, 19, 0}} ,{{163, 53}, {103, 19, 0}} ,{{156, 53}, {96, 19, 0}} ,{{160, 53}, {100, 19, 0}} ,{{174, 52}, {96, 18, 0}} ,{{177, 52}, {99, 18, 0}} ,{{179, 52}, {101, 18, 0}} ,{{178, 52}, {100, 18, 0}} ,{{176, 52}, {98, 18, 0}} ,{{180, 52}, {102, 18, 0}} ,{{97, 76}, {133, 45, 0}} ,{{175, 52}, {97, 18, 0}} ,{{181, 52}, {103, 18, 0}} ,{{192, 53}, {135, 19, 0}} ,{{191, 53}, {134, 19, 0}} ,{{190, 53}, {133, 19, 0}} ,{{198, 52}, {120, 18, 0}} ,{{201, 52}, {123, 18, 0}} ,{{122, 76}, {168, 45, 0}} ,{{125, 76}, {171, 45, 0}} ,{{127, 76}, {173, 45, 0}} ,{{126, 76}, {172, 45, 0}} ,{{136, 76}, {184, 45, 0}} ,{{139, 76}, {187, 45, 0}} ,{{141, 76}, {189, 45, 0}} ,{{140, 76}, {188, 45, 0}} ,{{138, 76}, {186, 45, 0}} ,{{142, 76}, {190, 45, 0}} ,{{137, 76}, {185, 45, 0}} ,{{124, 76}, {170, 45, 0}} ,{{128, 76}, {174, 45, 0}} ,{{123, 76}, {169, 45, 0}} ,{{203, 52}, {125, 18, 0}} ,{{202, 52}, {124, 18, 0}} ,{{104, 53}, {40, 19, 0}} ,{{107, 53}, {43, 19, 0}} ,{{109, 53}, {45, 19, 0}} ,{{108, 53}, {44, 19, 0}} ,{{106, 53}, {42, 19, 0}} ,{{110, 53}, {46, 19, 0}} ,{{108, 76}, {144, 45, 0}} ,{{105, 53}, {41, 19, 0}} ,{{111, 53}, {47, 19, 0}} ,{{200, 52}, {122, 18, 0}} ,{{204, 52}, {126, 18, 0}} ,{{99, 76}, {135, 45, 0}} ,{{199, 52}, {121, 18, 0}} ,{{205, 52}, {127, 18, 0}} ,{{51, 53}, {240, 18, 0}} ,{{54, 53}, {243, 18, 0}} ,{{59, 53}, {248, 18, 0}} ,{{62, 53}, {251, 18, 0}} ,{{64, 53}, {253, 18, 0}} ,{{63, 53}, {252, 18, 0}} ,{{61, 53}, {250, 18, 0}} ,{{65, 53}, {254, 18, 0}} ,{{105, 76}, {141, 45, 0}} ,{{60, 53}, {249, 18, 0}} ,{{66, 53}, {255, 18, 0}} ,{{56, 53}, {245, 18, 0}} ,{{55, 53}, {244, 18, 0}} ,{{53, 53}, {242, 18, 0}} ,{{57, 53}, {246, 18, 0}} ,{{104, 76}, {140, 45, 0}} ,{{52, 53}, {241, 18, 0}} ,{{58, 53}, {247, 18, 0}} ,{{136, 53}, {72, 19, 0}} ,{{139, 53}, {75, 19, 0}} ,{{141, 53}, {77, 19, 0}} ,{{140, 53}, {76, 19, 0}} ,{{138, 53}, {74, 19, 0}} ,{{142, 53}, {78, 19, 0}} ,{{137, 53}, {73, 19, 0}} ,{{143, 53}, {79, 19, 0}} ,{{196, 53}, {139, 19, 0}} ,{{195, 53}, {138, 19, 0}} ,{{194, 53}, {137, 19, 0}} ,{{154, 53}, {90, 19, 0}} ,{{75, 53}, {8, 19, 0}} ,{{78, 53}, {11, 19, 0}} ,{{80, 53}, {13, 19, 0}} ,{{79, 53}, {12, 19, 0}} ,{{88, 53}, {24, 19, 0}} ,{{91, 53}, {27, 19, 0}} ,{{93, 53}, {29, 19, 0}} ,{{92, 53}, {28, 19, 0}} ,{{90, 53}, {26, 19, 0}} ,{{94, 53}, {30, 19, 0}} ,{{89, 53}, {25, 19, 0}} ,{{111, 76}, {147, 45, 0}} ,{{95, 53}, {31, 19, 0}} ,{{114, 76}, {150, 45, 0}} ,{{113, 76}, {149, 45, 0}} ,{{112, 76}, {148, 45, 0}} ,{{77, 53}, {10, 19, 0}} ,{{235, 52}, {160, 18, 0}} ,{{238, 52}, {163, 18, 0}} ,{{240, 52}, {165, 18, 0}} ,{{239, 52}, {164, 18, 0}} ,{{237, 52}, {162, 18, 0}} ,{{241, 52}, {166, 18, 0}} ,{{102, 76}, {138, 45, 0}} ,{{236, 52}, {161, 18, 0}} ,{{242, 52}, {167, 18, 0}} ,{{81, 53}, {14, 19, 0}} ,{{82, 53}, {15, 19, 0}} ,{{76, 53}, {9, 19, 0}} ,{{83, 53}, {16, 19, 0}} ,{{85, 53}, {19, 19, 0}} ,{{87, 53}, {21, 19, 0}} ,{{86, 53}, {20, 19, 0}} ,{{84, 53}, {18, 19, 0}} ,{{164, 76}, {216, 45, 0}} ,{{167, 76}, {219, 45, 0}} ,{{169, 76}, {221, 45, 0}} ,{{168, 76}, {220, 45, 0}} ,{{166, 76}, {218, 45, 0}} ,{{170, 76}, {222, 45, 0}} ,{{165, 76}, {217, 45, 0}} ,{{85, 52}, {0, 18, 0}} ,{{88, 52}, {3, 18, 0}} ,{{90, 52}, {5, 18, 0}} ,{{89, 52}, {4, 18, 0}} ,{{101, 52}, {16, 18, 0}} ,{{104, 52}, {19, 18, 0}} ,{{106, 52}, {21, 18, 0}} ,{{105, 52}, {20, 18, 0}} ,{{103, 52}, {18, 18, 0}} ,{{107, 52}, {22, 18, 0}} ,{{102, 52}, {17, 18, 0}} ,{{108, 52}, {23, 18, 0}} ,{{87, 52}, {2, 18, 0}} ,{{91, 52}, {6, 18, 0}} ,{{92, 52}, {7, 18, 0}} ,{{86, 52}, {1, 18, 0}} ,{{67, 53}, {0, 19, 0}} ,{{70, 53}, {3, 19, 0}} ,{{72, 53}, {5, 19, 0}} ,{{71, 53}, {4, 19, 0}} ,{{69, 53}, {2, 19, 0}} ,{{73, 53}, {6, 19, 0}} ,{{106, 76}, {142, 45, 0}} ,{{68, 53}, {1, 19, 0}} ,{{74, 53}, {7, 19, 0}} ,{{243, 52}, {168, 18, 0}} ,{{246, 52}, {171, 18, 0}} ,{{248, 52}, {173, 18, 0}} ,{{247, 52}, {172, 18, 0}} ,{{245, 52}, {170, 18, 0}} ,{{249, 52}, {174, 18, 0}} ,{{250, 52}, {175, 18, 0}} ,{{244, 52}, {169, 18, 0}} ,{{251, 52}, {176, 18, 0}} ,{{253, 52}, {179, 18, 0}} ,{{255, 52}, {181, 18, 0}} ,{{254, 52}, {180, 18, 0}} ,{{252, 52}, {178, 18, 0}} ,{{0, 53}, {184, 18, 0}} ,{{3, 53}, {187, 18, 0}} ,{{5, 53}, {189, 18, 0}} ,{{4, 53}, {188, 18, 0}} ,{{2, 53}, {186, 18, 0}} ,{{6, 53}, {190, 18, 0}} ,{{1, 53}, {185, 18, 0}} ,{{7, 53}, {192, 18, 0}} ,{{9, 53}, {195, 18, 0}} ,{{11, 53}, {197, 18, 0}} ,{{10, 53}, {196, 18, 0}} ,{{8, 53}, {194, 18, 0}} ,{{150, 76}, {200, 45, 0}} ,{{153, 76}, {203, 45, 0}} ,{{155, 76}, {205, 45, 0}} ,{{154, 76}, {204, 45, 0}} ,{{152, 76}, {202, 45, 0}} ,{{156, 76}, {206, 45, 0}} ,{{151, 76}, {201, 45, 0}} ,{{93, 52}, {8, 18, 0}} ,{{96, 52}, {11, 18, 0}} ,{{98, 52}, {13, 18, 0}} ,{{97, 52}, {12, 18, 0}} ,{{95, 52}, {10, 18, 0}} ,{{99, 52}, {14, 18, 0}} ,{{92, 76}, {128, 45, 0}} ,{{94, 52}, {9, 18, 0}} ,{{100, 52}, {15, 18, 0}} ,{{109, 52}, {24, 18, 0}} ,{{112, 52}, {27, 18, 0}} ,{{114, 52}, {29, 18, 0}} ,{{113, 52}, {28, 18, 0}} ,{{111, 52}, {26, 18, 0}} ,{{115, 52}, {30, 18, 0}} ,{{93, 76}, {129, 45, 0}} ,{{110, 52}, {25, 18, 0}} ,{{116, 52}, {31, 18, 0}} ,{{188, 53}, {131, 19, 0}} ,{{187, 53}, {130, 19, 0}} ,{{186, 53}, {129, 19, 0}} ,{{153, 53}, {89, 19, 0}} ,{{219, 52}, {144, 18, 0}} ,{{222, 52}, {147, 18, 0}} ,{{224, 52}, {149, 18, 0}} ,{{223, 52}, {148, 18, 0}} ,{{221, 52}, {146, 18, 0}} ,{{225, 52}, {150, 18, 0}} ,{{100, 76}, {136, 45, 0}} ,{{220, 52}, {145, 18, 0}} ,{{226, 52}, {151, 18, 0}} ,{{227, 52}, {152, 18, 0}} ,{{230, 52}, {155, 18, 0}} ,{{232, 52}, {157, 18, 0}} ,{{231, 52}, {156, 18, 0}} ,{{229, 52}, {154, 18, 0}} ,{{233, 52}, {158, 18, 0}} ,{{101, 76}, {137, 45, 0}} ,{{228, 52}, {153, 18, 0}} ,{{234, 52}, {159, 18, 0}} ,{{144, 53}, {80, 19, 0}} ,{{147, 53}, {83, 19, 0}} ,{{149, 53}, {85, 19, 0}} ,{{148, 53}, {84, 19, 0}} ,{{112, 53}, {48, 19, 0}} ,{{115, 53}, {51, 19, 0}} ,{{20, 53}, {208, 18, 0}} ,{{23, 53}, {211, 18, 0}} ,{{25, 53}, {213, 18, 0}} ,{{24, 53}, {212, 18, 0}} ,{{22, 53}, {210, 18, 0}} ,{{26, 53}, {214, 18, 0}} ,{{21, 53}, {209, 18, 0}} ,{{117, 53}, {53, 19, 0}} ,{{116, 53}, {52, 19, 0}} ,{{114, 53}, {50, 19, 0}} ,{{118, 53}, {54, 19, 0}} ,{{109, 76}, {145, 45, 0}} ,{{113, 53}, {49, 19, 0}} ,{{119, 53}, {55, 19, 0}} ,{{146, 53}, {82, 19, 0}} ,{{150, 53}, {86, 19, 0}} ,{{110, 76}, {146, 45, 0}} ,{{145, 53}, {81, 19, 0}} ,{{151, 53}, {87, 19, 0}} ,{{200, 53}, {143, 19, 0}} ,{{199, 53}, {142, 19, 0}} ,{{198, 53}, {141, 19, 0}} ,{{149, 52}, {64, 18, 0}} ,{{152, 52}, {67, 18, 0}} ,{{154, 52}, {69, 18, 0}} ,{{153, 52}, {68, 18, 0}} ,{{162, 52}, {80, 18, 0}} ,{{165, 52}, {83, 18, 0}} ,{{167, 52}, {85, 18, 0}} ,{{166, 52}, {84, 18, 0}} ,{{164, 52}, {82, 18, 0}} ,{{168, 52}, {86, 18, 0}} ,{{163, 52}, {81, 18, 0}} ,{{169, 52}, {88, 18, 0}} ,{{171, 52}, {91, 18, 0}} ,{{173, 52}, {93, 18, 0}} ,{{172, 52}, {92, 18, 0}} ,{{170, 52}, {90, 18, 0}} ,{{151, 52}, {66, 18, 0}} ,{{155, 52}, {70, 18, 0}} ,{{156, 52}, {71, 18, 0}} ,{{150, 52}, {65, 18, 0}} ,{{157, 52}, {72, 18, 0}} ,{{159, 52}, {75, 18, 0}} ,{{161, 52}, {77, 18, 0}} ,{{160, 52}, {76, 18, 0}} ,{{158, 52}, {74, 18, 0}} ,{{143, 76}, {192, 45, 0}} ,{{146, 76}, {195, 45, 0}} ,{{148, 76}, {197, 45, 0}} ,{{147, 76}, {196, 45, 0}} ,{{145, 76}, {194, 45, 0}} ,{{149, 76}, {198, 45, 0}} ,{{144, 76}, {193, 45, 0}} ,{{125, 52}, {40, 18, 0}} ,{{128, 52}, {43, 18, 0}} ,{{130, 52}, {45, 18, 0}} ,{{129, 52}, {44, 18, 0}} ,{{127, 52}, {42, 18, 0}} ,{{131, 52}, {46, 18, 0}} ,{{94, 76}, {130, 45, 0}} ,{{126, 52}, {41, 18, 0}} ,{{132, 52}, {47, 18, 0}} ,{{152, 53}, {88, 19, 0}} ,{{133, 52}, {48, 18, 0}} ,{{136, 52}, {51, 18, 0}} ,{{138, 52}, {53, 18, 0}} ,{{189, 53}, {132, 19, 0}} ,{{193, 53}, {136, 19, 0}} ,{{185, 53}, {128, 19, 0}} ,{{197, 53}, {140, 19, 0}} ,{{137, 52}, {52, 18, 0}} ,{{141, 52}, {56, 18, 0}} ,{{144, 52}, {59, 18, 0}} ,{{146, 52}, {61, 18, 0}} ,{{145, 52}, {60, 18, 0}} ,{{143, 52}, {58, 18, 0}} ,{{147, 52}, {62, 18, 0}} ,{{96, 76}, {132, 45, 0}} ,{{142, 52}, {57, 18, 0}} ,{{148, 52}, {63, 18, 0}} ,{{135, 52}, {50, 18, 0}} ,{{139, 52}, {54, 18, 0}} ,{{95, 76}, {131, 45, 0}} ,{{115, 76}, {160, 45, 0}} ,{{118, 76}, {163, 45, 0}} ,{{120, 76}, {165, 45, 0}} ,{{119, 76}, {164, 45, 0}} ,{{117, 76}, {162, 45, 0}} ,{{121, 76}, {166, 45, 0}} ,{{116, 76}, {161, 45, 0}} ,{{134, 52}, {49, 18, 0}} ,{{140, 52}, {55, 18, 0}} ,{{117, 52}, {32, 18, 0}} ,{{120, 52}, {35, 18, 0}} ,{{122, 52}, {37, 18, 0}} ,{{121, 52}, {36, 18, 0}} ,{{119, 52}, {34, 18, 0}} ,{{123, 52}, {38, 18, 0}} ,{{118, 52}, {33, 18, 0}} ,{{124, 52}, {39, 18, 0}} ,{{190, 52}, {112, 18, 0}} ,{{193, 52}, {115, 18, 0}} ,{{195, 52}, {117, 18, 0}} ,{{194, 52}, {116, 18, 0}} ,{{96, 53}, {32, 19, 0}} ,{{99, 53}, {35, 19, 0}} ,{{101, 53}, {37, 19, 0}} ,{{100, 53}, {36, 19, 0}} ,{{98, 53}, {34, 19, 0}} ,{{102, 53}, {38, 19, 0}} ,{{107, 76}, {143, 45, 0}} ,{{97, 53}, {33, 19, 0}} ,{{103, 53}, {39, 19, 0}} ,{{192, 52}, {114, 18, 0}} ,{{196, 52}, {118, 18, 0}} ,{{98, 76}, {134, 45, 0}} ,{{120, 53}, {56, 19, 0}} ,{{123, 53}, {59, 19, 0}} ,{{125, 53}, {61, 19, 0}} ,{{124, 53}, {60, 19, 0}} ,{{122, 53}, {58, 19, 0}} ,{{126, 53}, {62, 19, 0}} ,{{121, 53}, {57, 19, 0}} ,{{127, 53}, {63, 19, 0}} ,{{191, 52}, {113, 18, 0}} ,{{197, 52}, {119, 18, 0}} ,{{128, 53}, {64, 19, 0}} ,{{131, 53}, {67, 19, 0}} ,{{133, 53}, {69, 19, 0}} ,{{132, 53}, {68, 19, 0}} ,{{130, 53}, {66, 19, 0}} ,{{134, 53}, {70, 19, 0}} ,{{135, 53}, {71, 19, 0}} ,{{129, 53}, {65, 19, 0}} ,{{182, 52}, {104, 18, 0}} ,{{185, 52}, {107, 18, 0}} ,{{187, 52}, {109, 18, 0}} ,{{186, 52}, {108, 18, 0}} ,{{184, 52}, {106, 18, 0}} ,{{188, 52}, {110, 18, 0}} ,{{183, 52}, {105, 18, 0}} ,{{189, 52}, {111, 18, 0}} ,{{12, 53}, {200, 18, 0}} ,{{15, 53}, {203, 18, 0}} ,{{17, 53}, {205, 18, 0}} ,{{16, 53}, {204, 18, 0}} ,{{14, 53}, {202, 18, 0}} ,{{18, 53}, {206, 18, 0}} ,{{19, 53}, {207, 18, 0}} ,{{13, 53}, {201, 18, 0}} ,{{206, 52}, {128, 18, 0}} ,{{209, 52}, {131, 18, 0}} ,{{211, 52}, {133, 18, 0}} ,{{210, 52}, {132, 18, 0}} ,{{208, 52}, {130, 18, 0}} ,{{212, 52}, {134, 18, 0}} ,{{213, 52}, {135, 18, 0}} ,{{207, 52}, {129, 18, 0}} ,{{214, 52}, {136, 18, 0}} ,{{216, 52}, {139, 18, 0}} ,{{218, 52}, {141, 18, 0}} ,{{217, 52}, {140, 18, 0}} ,{{215, 52}, {138, 18, 0}} ,{{157, 76}, {208, 45, 0}} ,{{160, 76}, {211, 45, 0}} ,{{162, 76}, {213, 45, 0}} ,{{161, 76}, {212, 45, 0}} ,{{159, 76}, {210, 45, 0}} ,{{163, 76}, {214, 45, 0}} ,{{158, 76}, {209, 45, 0}} ,{{43, 53}, {232, 18, 0}} ,{{46, 53}, {235, 18, 0}} ,{{48, 53}, {237, 18, 0}} ,{{47, 53}, {236, 18, 0}} ,{{45, 53}, {234, 18, 0}} ,{{49, 53}, {238, 18, 0}} ,{{50, 53}, {239, 18, 0}} ,{{44, 53}, {233, 18, 0}} ,{{27, 53}, {216, 18, 0}} ,{{30, 53}, {219, 18, 0}} ,{{32, 53}, {221, 18, 0}} ,{{31, 53}, {220, 18, 0}} ,{{35, 53}, {224, 18, 0}} ,{{38, 53}, {227, 18, 0}} ,{{40, 53}, {229, 18, 0}} ,{{39, 53}, {228, 18, 0}} ,{{37, 53}, {226, 18, 0}} ,{{41, 53}, {230, 18, 0}} ,{{36, 53}, {225, 18, 0}} ,{{42, 53}, {231, 18, 0}} ,{{29, 53}, {218, 18, 0}} ,{{33, 53}, {222, 18, 0}} ,{{103, 76}, {139, 45, 0}} ,{{28, 53}, {217, 18, 0}} ,{{34, 53}, {223, 18, 0}} ,{{129, 76}, {176, 45, 0}} ,{{132, 76}, {179, 45, 0}} ,{{134, 76}, {181, 45, 0}} ,{{133, 76}, {180, 45, 0}} ,{{131, 76}, {178, 45, 0}} ,{{135, 76}, {182, 45, 0}} ,{{130, 76}, {177, 45, 0}} ,{{207, 53}, {150, 19, 0}} ,{{202, 53}, {145, 19, 0}} ,{{209, 53}, {152, 19, 0}} ,{{205, 53}, {148, 19, 0}} ,{{208, 53}, {151, 19, 0}} ,{{206, 53}, {149, 19, 0}} ,{{210, 53}, {153, 19, 0}} ,{{203, 53}, {146, 19, 0}} ,{{204, 53}, {147, 19, 0}} ,{{201, 53}, {144, 19, 0}} ,{{157, 53}, {97, 19, 0}} ,{{30, 65}, {7, 33, 0}} ,{{221, 64}, {160, 32, 0}} ,{{233, 64}, {172, 32, 0}} ,{{74, 66}, {57, 34, 0}} ,{{228, 37}, {33, 0, 0}} ,{{153, 64}, {73, 32, 0}} ,{{93, 44}, {248, 6, 0}} ,{{90, 44}, {245, 6, 0}} ,{{89, 44}, {244, 6, 0}} ,{{94, 44}, {249, 6, 0}} ,{{86, 44}, {241, 6, 0}} ,{{92, 44}, {247, 6, 0}} ,{{91, 44}, {246, 6, 0}} ,{{88, 44}, {243, 6, 0}} ,{{87, 44}, {242, 6, 0}} ,{{85, 44}, {240, 6, 0}} ,{{82, 65}, {59, 33, 0}} ,{{224, 72}, {47, 41, 0}} ,{{221, 72}, {44, 41, 0}} ,{{169, 70}, {222, 38, 0}} ,{{247, 69}, {43, 38, 0}} ,{{12, 70}, {64, 38, 0}} ,{{76, 38}, {170, 0, 0}} ,{{186, 70}, {244, 38, 0}} ,{{98, 64}, {18, 32, 0}} ,{{87, 64}, {7, 32, 0}} ,{{190, 73}, {13, 42, 0}} ,{{9, 70}, {61, 38, 0}} ,{{149, 69}, {201, 37, 0}} ,{{248, 76}, {45, 46, 0}} ,{{169, 64}, {89, 32, 0}} ,{{185, 70}, {243, 38, 0}} ,{{246, 67}, {229, 35, 0}} ,{{104, 70}, {156, 38, 0}} ,{{32, 71}, {102, 39, 0}} ,{{100, 70}, {152, 38, 0}} ,{{165, 64}, {85, 32, 0}} ,{{186, 66}, {169, 34, 0}} ,{{219, 76}, {16, 46, 0}} ,{{141, 74}, {220, 42, 0}} ,{{17, 66}, {0, 34, 0}} ,{{184, 70}, {242, 38, 0}} ,{{85, 64}, {5, 32, 0}} ,{{45, 66}, {28, 34, 0}} ,{{229, 70}, {35, 39, 0}} ,{{231, 70}, {37, 39, 0}} ,{{171, 64}, {91, 32, 0}} ,{{168, 64}, {88, 32, 0}} ,{{228, 70}, {34, 39, 0}} ,{{118, 65}, {95, 33, 0}} ,{{148, 64}, {68, 32, 0}} ,{{224, 64}, {163, 32, 0}} ,{{99, 71}, {172, 39, 0}} ,{{51, 67}, {34, 35, 0}} ,{{195, 70}, {253, 38, 0}} ,{{155, 141}, {6, 255, 0}} ,{{156, 141}, {7, 255, 0}} ,{{159, 141}, {10, 255, 0}} ,{{109, 142}, {228, 255, 0}} ,{{105, 142}, {224, 255, 0}} ,{{211, 141}, {62, 255, 0}} ,{{175, 141}, {26, 255, 0}} ,{{161, 141}, {12, 255, 0}} ,{{181, 141}, {32, 255, 0}} ,{{173, 141}, {24, 255, 0}} ,{{170, 141}, {21, 255, 0}} ,{{169, 141}, {20, 255, 0}} ,{{174, 141}, {25, 255, 0}} ,{{166, 141}, {17, 255, 0}} ,{{172, 141}, {23, 255, 0}} ,{{171, 141}, {22, 255, 0}} ,{{168, 141}, {19, 255, 0}} ,{{167, 141}, {18, 255, 0}} ,{{165, 141}, {16, 255, 0}} ,{{153, 141}, {4, 255, 0}} ,{{178, 141}, {29, 255, 0}} ,{{150, 141}, {1, 255, 0}} ,{{163, 141}, {14, 255, 0}} ,{{213, 141}, {64, 255, 0}} ,{{179, 141}, {30, 255, 0}} ,{{162, 141}, {13, 255, 0}} ,{{182, 141}, {33, 255, 0}} ,{{183, 141}, {34, 255, 0}} ,{{184, 141}, {35, 255, 0}} ,{{185, 141}, {36, 255, 0}} ,{{186, 141}, {37, 255, 0}} ,{{187, 141}, {38, 255, 0}} ,{{188, 141}, {39, 255, 0}} ,{{189, 141}, {40, 255, 0}} ,{{190, 141}, {41, 255, 0}} ,{{191, 141}, {42, 255, 0}} ,{{192, 141}, {43, 255, 0}} ,{{193, 141}, {44, 255, 0}} ,{{194, 141}, {45, 255, 0}} ,{{195, 141}, {46, 255, 0}} ,{{196, 141}, {47, 255, 0}} ,{{197, 141}, {48, 255, 0}} ,{{198, 141}, {49, 255, 0}} ,{{199, 141}, {50, 255, 0}} ,{{200, 141}, {51, 255, 0}} ,{{201, 141}, {52, 255, 0}} ,{{202, 141}, {53, 255, 0}} ,{{203, 141}, {54, 255, 0}} ,{{204, 141}, {55, 255, 0}} ,{{205, 141}, {56, 255, 0}} ,{{206, 141}, {57, 255, 0}} ,{{207, 141}, {58, 255, 0}} ,{{214, 141}, {65, 255, 0}} ,{{215, 141}, {66, 255, 0}} ,{{216, 141}, {67, 255, 0}} ,{{217, 141}, {68, 255, 0}} ,{{218, 141}, {69, 255, 0}} ,{{219, 141}, {70, 255, 0}} ,{{220, 141}, {71, 255, 0}} ,{{221, 141}, {72, 255, 0}} ,{{222, 141}, {73, 255, 0}} ,{{223, 141}, {74, 255, 0}} ,{{224, 141}, {75, 255, 0}} ,{{225, 141}, {76, 255, 0}} ,{{226, 141}, {77, 255, 0}} ,{{227, 141}, {78, 255, 0}} ,{{228, 141}, {79, 255, 0}} ,{{229, 141}, {80, 255, 0}} ,{{230, 141}, {81, 255, 0}} ,{{231, 141}, {82, 255, 0}} ,{{232, 141}, {83, 255, 0}} ,{{233, 141}, {84, 255, 0}} ,{{234, 141}, {85, 255, 0}} ,{{235, 141}, {86, 255, 0}} ,{{236, 141}, {87, 255, 0}} ,{{237, 141}, {88, 255, 0}} ,{{238, 141}, {89, 255, 0}} ,{{239, 141}, {90, 255, 0}} ,{{240, 141}, {91, 255, 0}} ,{{157, 141}, {8, 255, 0}} ,{{208, 141}, {59, 255, 0}} ,{{244, 141}, {95, 255, 0}} ,{{177, 141}, {28, 255, 0}} ,{{212, 141}, {63, 255, 0}} ,{{108, 142}, {227, 255, 0}} ,{{107, 142}, {226, 255, 0}} ,{{152, 141}, {3, 255, 0}} ,{{154, 141}, {5, 255, 0}} ,{{160, 141}, {11, 255, 0}} ,{{106, 142}, {225, 255, 0}} ,{{180, 141}, {31, 255, 0}} ,{{151, 141}, {2, 255, 0}} ,{{209, 141}, {60, 255, 0}} ,{{242, 141}, {93, 255, 0}} ,{{158, 141}, {9, 255, 0}} ,{{210, 141}, {61, 255, 0}} ,{{245, 141}, {96, 255, 0}} ,{{176, 141}, {27, 255, 0}} ,{{164, 141}, {15, 255, 0}} ,{{243, 141}, {94, 255, 0}} ,{{241, 141}, {92, 255, 0}} ,{{111, 142}, {230, 255, 0}} ,{{110, 142}, {229, 255, 0}} ,{{84, 69}, {136, 37, 0}} ,{{136, 71}, {215, 39, 0}} ,{{241, 37}, {46, 0, 0}} ,{{177, 64}, {97, 32, 0}} ,{{125, 70}, {177, 38, 0}} ,{{236, 67}, {219, 35, 0}} ,{{101, 70}, {153, 38, 0}} ,{{179, 70}, {237, 38, 0}} ,{{180, 70}, {238, 38, 0}} ,{{22, 70}, {74, 38, 0}} ,{{98, 66}, {81, 34, 0}} ,{{95, 66}, {78, 34, 0}} ,{{75, 66}, {58, 34, 0}} ,{{2, 51}, {160, 16, 0}} ,{{3, 51}, {161, 16, 0}} ,{{28, 51}, {186, 16, 0}} ,{{31, 51}, {189, 16, 0}} ,{{27, 51}, {185, 16, 0}} ,{{30, 51}, {188, 16, 0}} ,{{5, 51}, {163, 16, 0}} ,{{6, 51}, {164, 16, 0}} ,{{4, 51}, {162, 16, 0}} ,{{24, 51}, {182, 16, 0}} ,{{34, 51}, {192, 16, 0}} ,{{38, 51}, {196, 16, 0}} ,{{35, 51}, {193, 16, 0}} ,{{36, 51}, {194, 16, 0}} ,{{39, 51}, {197, 16, 0}} ,{{10, 51}, {168, 16, 0}} ,{{33, 51}, {191, 16, 0}} ,{{29, 51}, {187, 16, 0}} ,{{11, 51}, {169, 16, 0}} ,{{23, 51}, {181, 16, 0}} ,{{12, 51}, {170, 16, 0}} ,{{13, 51}, {171, 16, 0}} ,{{14, 51}, {172, 16, 0}} ,{{15, 51}, {173, 16, 0}} ,{{16, 51}, {174, 16, 0}} ,{{22, 51}, {180, 16, 0}} ,{{25, 51}, {183, 16, 0}} ,{{18, 51}, {176, 16, 0}} ,{{19, 51}, {177, 16, 0}} ,{{26, 51}, {184, 16, 0}} ,{{9, 51}, {167, 16, 0}} ,{{20, 51}, {178, 16, 0}} ,{{21, 51}, {179, 16, 0}} ,{{7, 51}, {165, 16, 0}} ,{{37, 51}, {195, 16, 0}} ,{{32, 51}, {190, 16, 0}} ,{{8, 51}, {166, 16, 0}} ,{{17, 51}, {175, 16, 0}} ,{{82, 51}, {250, 16, 0}} ,{{40, 51}, {208, 16, 0}} ,{{41, 51}, {209, 16, 0}} ,{{66, 51}, {234, 16, 0}} ,{{69, 51}, {237, 16, 0}} ,{{65, 51}, {233, 16, 0}} ,{{68, 51}, {236, 16, 0}} ,{{43, 51}, {211, 16, 0}} ,{{80, 51}, {248, 16, 0}} ,{{44, 51}, {212, 16, 0}} ,{{78, 51}, {246, 16, 0}} ,{{42, 51}, {210, 16, 0}} ,{{62, 51}, {230, 16, 0}} ,{{72, 51}, {240, 16, 0}} ,{{76, 51}, {244, 16, 0}} ,{{73, 51}, {241, 16, 0}} ,{{74, 51}, {242, 16, 0}} ,{{77, 51}, {245, 16, 0}} ,{{48, 51}, {216, 16, 0}} ,{{71, 51}, {239, 16, 0}} ,{{67, 51}, {235, 16, 0}} ,{{49, 51}, {217, 16, 0}} ,{{61, 51}, {229, 16, 0}} ,{{50, 51}, {218, 16, 0}} ,{{51, 51}, {219, 16, 0}} ,{{52, 51}, {220, 16, 0}} ,{{53, 51}, {221, 16, 0}} ,{{54, 51}, {222, 16, 0}} ,{{60, 51}, {228, 16, 0}} ,{{63, 51}, {231, 16, 0}} ,{{56, 51}, {224, 16, 0}} ,{{57, 51}, {225, 16, 0}} ,{{64, 51}, {232, 16, 0}} ,{{47, 51}, {215, 16, 0}} ,{{58, 51}, {226, 16, 0}} ,{{81, 51}, {249, 16, 0}} ,{{59, 51}, {227, 16, 0}} ,{{45, 51}, {213, 16, 0}} ,{{75, 51}, {243, 16, 0}} ,{{70, 51}, {238, 16, 0}} ,{{79, 51}, {247, 16, 0}} ,{{46, 51}, {214, 16, 0}} ,{{55, 51}, {223, 16, 0}} ,{{83, 51}, {251, 16, 0}} ,{{255, 75}, {0, 45, 0}} ,{{0, 76}, {1, 45, 0}} ,{{25, 76}, {26, 45, 0}} ,{{28, 76}, {29, 45, 0}} ,{{24, 76}, {25, 45, 0}} ,{{27, 76}, {28, 45, 0}} ,{{2, 76}, {3, 45, 0}} ,{{3, 76}, {4, 45, 0}} ,{{1, 76}, {2, 45, 0}} ,{{21, 76}, {22, 45, 0}} ,{{31, 76}, {32, 45, 0}} ,{{35, 76}, {36, 45, 0}} ,{{32, 76}, {33, 45, 0}} ,{{33, 76}, {34, 45, 0}} ,{{36, 76}, {37, 45, 0}} ,{{7, 76}, {8, 45, 0}} ,{{30, 76}, {31, 45, 0}} ,{{26, 76}, {27, 45, 0}} ,{{8, 76}, {9, 45, 0}} ,{{20, 76}, {21, 45, 0}} ,{{9, 76}, {10, 45, 0}} ,{{10, 76}, {11, 45, 0}} ,{{11, 76}, {12, 45, 0}} ,{{12, 76}, {13, 45, 0}} ,{{13, 76}, {14, 45, 0}} ,{{19, 76}, {20, 45, 0}} ,{{22, 76}, {23, 45, 0}} ,{{15, 76}, {16, 45, 0}} ,{{16, 76}, {17, 45, 0}} ,{{23, 76}, {24, 45, 0}} ,{{6, 76}, {7, 45, 0}} ,{{17, 76}, {18, 45, 0}} ,{{18, 76}, {19, 45, 0}} ,{{4, 76}, {5, 45, 0}} ,{{34, 76}, {35, 45, 0}} ,{{29, 76}, {30, 45, 0}} ,{{5, 76}, {6, 45, 0}} ,{{14, 76}, {15, 45, 0}} ,{{237, 64}, {176, 32, 0}} ,{{101, 78}, {19, 48, 0}} ,{{78, 65}, {55, 33, 0}} ,{{8, 75}, {0, 44, 0}} ,{{48, 75}, {40, 44, 0}} ,{{9, 75}, {1, 44, 0}} ,{{37, 75}, {29, 44, 0}} ,{{20, 75}, {12, 44, 0}} ,{{12, 75}, {4, 44, 0}} ,{{15, 75}, {7, 44, 0}} ,{{50, 75}, {42, 44, 0}} ,{{31, 75}, {23, 44, 0}} ,{{11, 75}, {3, 44, 0}} ,{{32, 75}, {24, 44, 0}} ,{{19, 75}, {11, 44, 0}} ,{{18, 75}, {10, 44, 0}} ,{{49, 75}, {41, 44, 0}} ,{{47, 75}, {39, 44, 0}} ,{{17, 75}, {9, 44, 0}} ,{{51, 75}, {43, 44, 0}} ,{{21, 75}, {13, 44, 0}} ,{{54, 75}, {46, 44, 0}} ,{{22, 75}, {14, 44, 0}} ,{{23, 75}, {15, 44, 0}} ,{{24, 75}, {16, 44, 0}} ,{{25, 75}, {17, 44, 0}} ,{{33, 75}, {25, 44, 0}} ,{{34, 75}, {26, 44, 0}} ,{{26, 75}, {18, 44, 0}} ,{{27, 75}, {19, 44, 0}} ,{{38, 75}, {30, 44, 0}} ,{{35, 75}, {27, 44, 0}} ,{{52, 75}, {44, 44, 0}} ,{{28, 75}, {20, 44, 0}} ,{{44, 75}, {36, 44, 0}} ,{{45, 75}, {37, 44, 0}} ,{{42, 75}, {34, 44, 0}} ,{{53, 75}, {45, 44, 0}} ,{{36, 75}, {28, 44, 0}} ,{{29, 75}, {21, 44, 0}} ,{{30, 75}, {22, 44, 0}} ,{{10, 75}, {2, 44, 0}} ,{{41, 75}, {33, 44, 0}} ,{{40, 75}, {32, 44, 0}} ,{{39, 75}, {31, 44, 0}} ,{{13, 75}, {5, 44, 0}} ,{{46, 75}, {38, 44, 0}} ,{{43, 75}, {35, 44, 0}} ,{{16, 75}, {8, 44, 0}} ,{{14, 75}, {6, 44, 0}} ,{{55, 75}, {48, 44, 0}} ,{{95, 75}, {88, 44, 0}} ,{{56, 75}, {49, 44, 0}} ,{{84, 75}, {77, 44, 0}} ,{{67, 75}, {60, 44, 0}} ,{{59, 75}, {52, 44, 0}} ,{{62, 75}, {55, 44, 0}} ,{{97, 75}, {90, 44, 0}} ,{{78, 75}, {71, 44, 0}} ,{{58, 75}, {51, 44, 0}} ,{{79, 75}, {72, 44, 0}} ,{{66, 75}, {59, 44, 0}} ,{{65, 75}, {58, 44, 0}} ,{{96, 75}, {89, 44, 0}} ,{{94, 75}, {87, 44, 0}} ,{{64, 75}, {57, 44, 0}} ,{{98, 75}, {91, 44, 0}} ,{{68, 75}, {61, 44, 0}} ,{{101, 75}, {94, 44, 0}} ,{{69, 75}, {62, 44, 0}} ,{{70, 75}, {63, 44, 0}} ,{{71, 75}, {64, 44, 0}} ,{{72, 75}, {65, 44, 0}} ,{{80, 75}, {73, 44, 0}} ,{{81, 75}, {74, 44, 0}} ,{{73, 75}, {66, 44, 0}} ,{{74, 75}, {67, 44, 0}} ,{{85, 75}, {78, 44, 0}} ,{{82, 75}, {75, 44, 0}} ,{{99, 75}, {92, 44, 0}} ,{{75, 75}, {68, 44, 0}} ,{{91, 75}, {84, 44, 0}} ,{{92, 75}, {85, 44, 0}} ,{{89, 75}, {82, 44, 0}} ,{{100, 75}, {93, 44, 0}} ,{{83, 75}, {76, 44, 0}} ,{{76, 75}, {69, 44, 0}} ,{{77, 75}, {70, 44, 0}} ,{{57, 75}, {50, 44, 0}} ,{{88, 75}, {81, 44, 0}} ,{{87, 75}, {80, 44, 0}} ,{{86, 75}, {79, 44, 0}} ,{{60, 75}, {53, 44, 0}} ,{{93, 75}, {86, 44, 0}} ,{{90, 75}, {83, 44, 0}} ,{{63, 75}, {56, 44, 0}} ,{{61, 75}, {54, 44, 0}} ,{{151, 73}, {230, 41, 0}} ,{{126, 144}, {48, 3, 1}} ,{{130, 144}, {52, 3, 1}} ,{{127, 144}, {49, 3, 1}} ,{{129, 144}, {51, 3, 1}} ,{{135, 144}, {57, 3, 1}} ,{{148, 144}, {70, 3, 1}} ,{{128, 144}, {50, 3, 1}} ,{{133, 144}, {55, 3, 1}} ,{{150, 144}, {72, 3, 1}} ,{{149, 144}, {71, 3, 1}} ,{{132, 144}, {54, 3, 1}} ,{{140, 144}, {62, 3, 1}} ,{{136, 144}, {58, 3, 1}} ,{{137, 144}, {59, 3, 1}} ,{{138, 144}, {60, 3, 1}} ,{{139, 144}, {61, 3, 1}} ,{{143, 144}, {65, 3, 1}} ,{{152, 144}, {74, 3, 1}} ,{{151, 144}, {73, 3, 1}} ,{{142, 144}, {64, 3, 1}} ,{{131, 144}, {53, 3, 1}} ,{{144, 144}, {66, 3, 1}} ,{{145, 144}, {67, 3, 1}} ,{{146, 144}, {68, 3, 1}} ,{{134, 144}, {56, 3, 1}} ,{{141, 144}, {63, 3, 1}} ,{{147, 144}, {69, 3, 1}} ,{{35, 38}, {96, 0, 0}} ,{{61, 74}, {140, 42, 0}} ,{{67, 74}, {146, 42, 0}} ,{{41, 73}, {120, 41, 0}} ,{{65, 74}, {144, 42, 0}} ,{{63, 74}, {142, 42, 0}} ,{{69, 74}, {148, 42, 0}} ,{{59, 74}, {138, 42, 0}} ,{{57, 74}, {136, 42, 0}} ,{{86, 74}, {165, 42, 0}} ,{{122, 66}, {105, 34, 0}} ,{{248, 66}, {231, 34, 0}} ,{{88, 74}, {167, 42, 0}} ,{{90, 74}, {169, 42, 0}} ,{{236, 66}, {219, 34, 0}} ,{{55, 74}, {134, 42, 0}} ,{{118, 66}, {101, 34, 0}} ,{{132, 66}, {115, 34, 0}} ,{{136, 66}, {119, 34, 0}} ,{{47, 74}, {126, 42, 0}} ,{{51, 74}, {130, 42, 0}} ,{{53, 74}, {132, 42, 0}} ,{{49, 74}, {128, 42, 0}} ,{{85, 74}, {164, 42, 0}} ,{{120, 66}, {103, 34, 0}} ,{{1, 38}, {62, 0, 0}} ,{{43, 74}, {122, 42, 0}} ,{{232, 66}, {215, 34, 0}} ,{{45, 74}, {124, 42, 0}} ,{{140, 143}, {68, 1, 1}} ,{{153, 143}, {81, 1, 1}} ,{{146, 143}, {74, 1, 1}} ,{{143, 143}, {71, 1, 1}} ,{{158, 143}, {86, 1, 1}} ,{{139, 143}, {67, 1, 1}} ,{{141, 143}, {69, 1, 1}} ,{{155, 143}, {83, 1, 1}} ,{{148, 143}, {76, 1, 1}} ,{{151, 143}, {79, 1, 1}} ,{{144, 143}, {72, 1, 1}} ,{{142, 143}, {70, 1, 1}} ,{{150, 143}, {78, 1, 1}} ,{{138, 143}, {66, 1, 1}} ,{{137, 143}, {65, 1, 1}} ,{{154, 143}, {82, 1, 1}} ,{{147, 143}, {75, 1, 1}} ,{{136, 143}, {64, 1, 1}} ,{{156, 143}, {84, 1, 1}} ,{{149, 143}, {77, 1, 1}} ,{{159, 143}, {87, 1, 1}} ,{{152, 143}, {80, 1, 1}} ,{{145, 143}, {73, 1, 1}} ,{{157, 143}, {85, 1, 1}} ,{{183, 143}, {111, 1, 1}} ,{{165, 143}, {93, 1, 1}} ,{{187, 143}, {115, 1, 1}} ,{{180, 143}, {108, 1, 1}} ,{{163, 143}, {91, 1, 1}} ,{{166, 143}, {94, 1, 1}} ,{{160, 143}, {88, 1, 1}} ,{{176, 143}, {104, 1, 1}} ,{{162, 143}, {90, 1, 1}} ,{{170, 143}, {98, 1, 1}} ,{{171, 143}, {99, 1, 1}} ,{{184, 143}, {112, 1, 1}} ,{{188, 143}, {116, 1, 1}} ,{{177, 143}, {105, 1, 1}} ,{{182, 143}, {110, 1, 1}} ,{{186, 143}, {114, 1, 1}} ,{{161, 143}, {89, 1, 1}} ,{{178, 143}, {106, 1, 1}} ,{{185, 143}, {113, 1, 1}} ,{{172, 143}, {100, 1, 1}} ,{{173, 143}, {101, 1, 1}} ,{{179, 143}, {107, 1, 1}} ,{{164, 143}, {92, 1, 1}} ,{{174, 143}, {102, 1, 1}} ,{{175, 143}, {103, 1, 1}} ,{{167, 143}, {95, 1, 1}} ,{{181, 143}, {109, 1, 1}} ,{{168, 143}, {96, 1, 1}} ,{{169, 143}, {97, 1, 1}} ,{{34, 41}, {135, 3, 0}} ,{{207, 143}, {135, 1, 1}} ,{{206, 143}, {134, 1, 1}} ,{{104, 41}, {208, 3, 0}} ,{{150, 41}, {254, 3, 0}} ,{{103, 41}, {207, 3, 0}} ,{{42, 41}, {145, 3, 0}} ,{{112, 63}, {9, 31, 0}} ,{{116, 63}, {13, 31, 0}} ,{{230, 63}, {141, 31, 0}} ,{{118, 63}, {15, 31, 0}} ,{{232, 63}, {143, 31, 0}} ,{{226, 63}, {137, 31, 0}} ,{{114, 63}, {11, 31, 0}} ,{{228, 63}, {139, 31, 0}} ,{{17, 64}, {185, 31, 0}} ,{{19, 64}, {187, 31, 0}} ,{{20, 64}, {188, 31, 0}} ,{{111, 63}, {8, 31, 0}} ,{{115, 63}, {12, 31, 0}} ,{{229, 63}, {140, 31, 0}} ,{{117, 63}, {14, 31, 0}} ,{{231, 63}, {142, 31, 0}} ,{{225, 63}, {136, 31, 0}} ,{{113, 63}, {10, 31, 0}} ,{{227, 63}, {138, 31, 0}} ,{{33, 41}, {134, 3, 0}} ,{{18, 64}, {186, 31, 0}} ,{{16, 64}, {184, 31, 0}} ,{{20, 41}, {114, 3, 0}} ,{{43, 41}, {146, 3, 0}} ,{{63, 41}, {167, 3, 0}} ,{{45, 41}, {148, 3, 0}} ,{{46, 41}, {149, 3, 0}} ,{{126, 63}, {25, 31, 0}} ,{{130, 63}, {29, 31, 0}} ,{{128, 63}, {27, 31, 0}} ,{{32, 64}, {201, 31, 0}} ,{{125, 63}, {24, 31, 0}} ,{{129, 63}, {28, 31, 0}} ,{{127, 63}, {26, 31, 0}} ,{{35, 41}, {136, 3, 0}} ,{{31, 64}, {200, 31, 0}} ,{{48, 41}, {151, 3, 0}} ,{{140, 63}, {41, 31, 0}} ,{{144, 63}, {45, 31, 0}} ,{{246, 63}, {157, 31, 0}} ,{{146, 63}, {47, 31, 0}} ,{{248, 63}, {159, 31, 0}} ,{{242, 63}, {153, 31, 0}} ,{{142, 63}, {43, 31, 0}} ,{{244, 63}, {155, 31, 0}} ,{{34, 64}, {203, 31, 0}} ,{{35, 64}, {204, 31, 0}} ,{{139, 63}, {40, 31, 0}} ,{{143, 63}, {44, 31, 0}} ,{{245, 63}, {156, 31, 0}} ,{{145, 63}, {46, 31, 0}} ,{{247, 63}, {158, 31, 0}} ,{{241, 63}, {152, 31, 0}} ,{{141, 63}, {42, 31, 0}} ,{{243, 63}, {154, 31, 0}} ,{{36, 41}, {137, 3, 0}} ,{{33, 64}, {202, 31, 0}} ,{{44, 41}, {147, 3, 0}} ,{{18, 41}, {112, 3, 0}} ,{{50, 41}, {153, 3, 0}} ,{{156, 63}, {57, 31, 0}} ,{{160, 63}, {61, 31, 0}} ,{{162, 63}, {63, 31, 0}} ,{{158, 63}, {59, 31, 0}} ,{{66, 41}, {170, 3, 0}} ,{{46, 64}, {217, 31, 0}} ,{{48, 64}, {219, 31, 0}} ,{{155, 63}, {56, 31, 0}} ,{{159, 63}, {60, 31, 0}} ,{{161, 63}, {62, 31, 0}} ,{{157, 63}, {58, 31, 0}} ,{{37, 41}, {138, 3, 0}} ,{{47, 64}, {218, 31, 0}} ,{{45, 64}, {216, 31, 0}} ,{{51, 41}, {154, 3, 0}} ,{{52, 41}, {155, 3, 0}} ,{{53, 41}, {156, 3, 0}} ,{{54, 41}, {157, 3, 0}} ,{{65, 41}, {169, 3, 0}} ,{{196, 63}, {105, 31, 0}} ,{{200, 63}, {109, 31, 0}} ,{{6, 64}, {173, 31, 0}} ,{{202, 63}, {111, 31, 0}} ,{{8, 64}, {175, 31, 0}} ,{{2, 64}, {169, 31, 0}} ,{{198, 63}, {107, 31, 0}} ,{{4, 64}, {171, 31, 0}} ,{{76, 64}, {251, 31, 0}} ,{{77, 64}, {252, 31, 0}} ,{{195, 63}, {104, 31, 0}} ,{{199, 63}, {108, 31, 0}} ,{{5, 64}, {172, 31, 0}} ,{{201, 63}, {110, 31, 0}} ,{{7, 64}, {174, 31, 0}} ,{{1, 64}, {168, 31, 0}} ,{{197, 63}, {106, 31, 0}} ,{{3, 64}, {170, 31, 0}} ,{{40, 41}, {143, 3, 0}} ,{{75, 64}, {250, 31, 0}} ,{{56, 41}, {159, 3, 0}} ,{{170, 63}, {73, 31, 0}} ,{{174, 63}, {77, 31, 0}} ,{{172, 63}, {75, 31, 0}} ,{{74, 64}, {249, 31, 0}} ,{{169, 63}, {72, 31, 0}} ,{{173, 63}, {76, 31, 0}} ,{{171, 63}, {74, 31, 0}} ,{{38, 41}, {140, 3, 0}} ,{{73, 64}, {248, 31, 0}} ,{{24, 41}, {118, 3, 0}} ,{{62, 41}, {166, 3, 0}} ,{{57, 41}, {160, 3, 0}} ,{{64, 41}, {168, 3, 0}} ,{{58, 41}, {161, 3, 0}} ,{{64, 64}, {236, 31, 0}} ,{{146, 41}, {250, 3, 0}} ,{{143, 41}, {247, 3, 0}} ,{{59, 41}, {163, 3, 0}} ,{{60, 41}, {164, 3, 0}} ,{{49, 41}, {152, 3, 0}} ,{{61, 41}, {165, 3, 0}} ,{{183, 63}, {89, 31, 0}} ,{{185, 63}, {93, 31, 0}} ,{{186, 63}, {95, 31, 0}} ,{{184, 63}, {91, 31, 0}} ,{{67, 41}, {171, 3, 0}} ,{{61, 64}, {233, 31, 0}} ,{{63, 64}, {235, 31, 0}} ,{{39, 41}, {142, 3, 0}} ,{{62, 64}, {234, 31, 0}} ,{{60, 64}, {232, 31, 0}} ,{{55, 41}, {158, 3, 0}} ,{{47, 41}, {150, 3, 0}} ,{{145, 41}, {249, 3, 0}} ,{{151, 41}, {255, 3, 0}} ,{{149, 41}, {253, 3, 0}} ,{{140, 41}, {244, 3, 0}} ,{{79, 64}, {254, 31, 0}} ,{{50, 64}, {222, 31, 0}} ,{{51, 64}, {223, 31, 0}} ,{{49, 64}, {221, 31, 0}} ,{{66, 64}, {238, 31, 0}} ,{{25, 64}, {193, 31, 0}} ,{{65, 64}, {237, 31, 0}} ,{{32, 41}, {133, 3, 0}} ,{{195, 143}, {123, 1, 1}} ,{{200, 143}, {128, 1, 1}} ,{{199, 143}, {127, 1, 1}} ,{{208, 143}, {136, 1, 1}} ,{{149, 157}, {29, 210, 1}} ,{{155, 157}, {35, 210, 1}} ,{{156, 157}, {36, 210, 1}} ,{{157, 157}, {37, 210, 1}} ,{{158, 157}, {38, 210, 1}} ,{{159, 157}, {39, 210, 1}} ,{{160, 157}, {40, 210, 1}} ,{{161, 157}, {41, 210, 1}} ,{{150, 157}, {30, 210, 1}} ,{{162, 157}, {42, 210, 1}} ,{{163, 157}, {43, 210, 1}} ,{{164, 157}, {44, 210, 1}} ,{{165, 157}, {45, 210, 1}} ,{{166, 157}, {46, 210, 1}} ,{{167, 157}, {47, 210, 1}} ,{{168, 157}, {48, 210, 1}} ,{{169, 157}, {49, 210, 1}} ,{{170, 157}, {50, 210, 1}} ,{{171, 157}, {51, 210, 1}} ,{{172, 157}, {52, 210, 1}} ,{{173, 157}, {53, 210, 1}} ,{{151, 157}, {31, 210, 1}} ,{{174, 157}, {54, 210, 1}} ,{{175, 157}, {55, 210, 1}} ,{{176, 157}, {56, 210, 1}} ,{{177, 157}, {57, 210, 1}} ,{{178, 157}, {58, 210, 1}} ,{{179, 157}, {59, 210, 1}} ,{{180, 157}, {60, 210, 1}} ,{{152, 157}, {32, 210, 1}} ,{{181, 157}, {61, 210, 1}} ,{{182, 157}, {62, 210, 1}} ,{{183, 157}, {63, 210, 1}} ,{{184, 157}, {64, 210, 1}} ,{{185, 157}, {65, 210, 1}} ,{{153, 157}, {33, 210, 1}} ,{{154, 157}, {34, 210, 1}} ,{{111, 41}, {215, 3, 0}} ,{{136, 41}, {240, 3, 0}} ,{{21, 64}, {189, 31, 0}} ,{{202, 143}, {130, 1, 1}} ,{{112, 41}, {216, 3, 0}} ,{{116, 41}, {220, 3, 0}} ,{{118, 41}, {222, 3, 0}} ,{{120, 41}, {224, 3, 0}} ,{{163, 61}, {38, 29, 0}} ,{{164, 61}, {39, 29, 0}} ,{{165, 61}, {40, 29, 0}} ,{{167, 61}, {42, 29, 0}} ,{{166, 61}, {41, 29, 0}} ,{{114, 41}, {218, 3, 0}} ,{{139, 41}, {243, 3, 0}} ,{{203, 143}, {131, 1, 1}} ,{{23, 41}, {117, 3, 0}} ,{{141, 41}, {245, 3, 0}} ,{{138, 41}, {242, 3, 0}} ,{{201, 143}, {129, 1, 1}} ,{{189, 157}, {69, 210, 1}} ,{{22, 41}, {116, 3, 0}} ,{{196, 143}, {124, 1, 1}} ,{{189, 143}, {117, 1, 1}} ,{{190, 143}, {118, 1, 1}} ,{{204, 143}, {132, 1, 1}} ,{{78, 64}, {253, 31, 0}} ,{{24, 64}, {192, 31, 0}} ,{{109, 41}, {213, 3, 0}} ,{{110, 41}, {214, 3, 0}} ,{{22, 64}, {190, 31, 0}} ,{{23, 64}, {191, 31, 0}} ,{{37, 64}, {206, 31, 0}} ,{{38, 64}, {207, 31, 0}} ,{{36, 64}, {205, 31, 0}} ,{{30, 41}, {126, 3, 0}} ,{{142, 41}, {246, 3, 0}} ,{{137, 41}, {241, 3, 0}} ,{{148, 41}, {252, 3, 0}} ,{{28, 41}, {124, 3, 0}} ,{{73, 41}, {177, 3, 0}} ,{{104, 63}, {1, 31, 0}} ,{{108, 63}, {5, 31, 0}} ,{{222, 63}, {133, 31, 0}} ,{{110, 63}, {7, 31, 0}} ,{{224, 63}, {135, 31, 0}} ,{{106, 63}, {3, 31, 0}} ,{{220, 63}, {131, 31, 0}} ,{{218, 63}, {129, 31, 0}} ,{{10, 64}, {177, 31, 0}} ,{{204, 63}, {113, 31, 0}} ,{{13, 64}, {180, 31, 0}} ,{{14, 64}, {182, 31, 0}} ,{{15, 64}, {183, 31, 0}} ,{{103, 63}, {0, 31, 0}} ,{{107, 63}, {4, 31, 0}} ,{{221, 63}, {132, 31, 0}} ,{{109, 63}, {6, 31, 0}} ,{{223, 63}, {134, 31, 0}} ,{{105, 63}, {2, 31, 0}} ,{{219, 63}, {130, 31, 0}} ,{{217, 63}, {128, 31, 0}} ,{{68, 41}, {172, 3, 0}} ,{{203, 63}, {112, 31, 0}} ,{{11, 64}, {178, 31, 0}} ,{{9, 64}, {176, 31, 0}} ,{{12, 64}, {179, 31, 0}} ,{{113, 41}, {217, 3, 0}} ,{{21, 41}, {115, 3, 0}} ,{{74, 41}, {178, 3, 0}} ,{{95, 41}, {199, 3, 0}} ,{{76, 41}, {180, 3, 0}} ,{{117, 41}, {221, 3, 0}} ,{{77, 41}, {181, 3, 0}} ,{{120, 63}, {17, 31, 0}} ,{{124, 63}, {21, 31, 0}} ,{{122, 63}, {19, 31, 0}} ,{{206, 63}, {115, 31, 0}} ,{{119, 63}, {16, 31, 0}} ,{{123, 63}, {20, 31, 0}} ,{{121, 63}, {18, 31, 0}} ,{{69, 41}, {173, 3, 0}} ,{{205, 63}, {114, 31, 0}} ,{{79, 41}, {183, 3, 0}} ,{{132, 63}, {33, 31, 0}} ,{{136, 63}, {37, 31, 0}} ,{{238, 63}, {149, 31, 0}} ,{{138, 63}, {39, 31, 0}} ,{{240, 63}, {151, 31, 0}} ,{{134, 63}, {35, 31, 0}} ,{{236, 63}, {147, 31, 0}} ,{{234, 63}, {145, 31, 0}} ,{{208, 63}, {117, 31, 0}} ,{{28, 64}, {196, 31, 0}} ,{{29, 64}, {198, 31, 0}} ,{{30, 64}, {199, 31, 0}} ,{{131, 63}, {32, 31, 0}} ,{{135, 63}, {36, 31, 0}} ,{{237, 63}, {148, 31, 0}} ,{{137, 63}, {38, 31, 0}} ,{{239, 63}, {150, 31, 0}} ,{{133, 63}, {34, 31, 0}} ,{{235, 63}, {146, 31, 0}} ,{{233, 63}, {144, 31, 0}} ,{{70, 41}, {174, 3, 0}} ,{{207, 63}, {116, 31, 0}} ,{{26, 64}, {194, 31, 0}} ,{{27, 64}, {195, 31, 0}} ,{{90, 41}, {194, 3, 0}} ,{{75, 41}, {179, 3, 0}} ,{{19, 41}, {113, 3, 0}} ,{{81, 41}, {185, 3, 0}} ,{{148, 63}, {49, 31, 0}} ,{{152, 63}, {53, 31, 0}} ,{{154, 63}, {55, 31, 0}} ,{{150, 63}, {51, 31, 0}} ,{{98, 41}, {202, 3, 0}} ,{{42, 64}, {211, 31, 0}} ,{{44, 64}, {215, 31, 0}} ,{{41, 41}, {144, 3, 0}} ,{{41, 64}, {210, 31, 0}} ,{{40, 64}, {209, 31, 0}} ,{{210, 63}, {119, 31, 0}} ,{{43, 64}, {214, 31, 0}} ,{{147, 63}, {48, 31, 0}} ,{{151, 63}, {52, 31, 0}} ,{{153, 63}, {54, 31, 0}} ,{{149, 63}, {50, 31, 0}} ,{{71, 41}, {175, 3, 0}} ,{{209, 63}, {118, 31, 0}} ,{{39, 64}, {208, 31, 0}} ,{{82, 41}, {186, 3, 0}} ,{{119, 41}, {223, 3, 0}} ,{{83, 41}, {187, 3, 0}} ,{{84, 41}, {188, 3, 0}} ,{{85, 41}, {189, 3, 0}} ,{{97, 41}, {201, 3, 0}} ,{{188, 63}, {97, 31, 0}} ,{{192, 63}, {101, 31, 0}} ,{{254, 63}, {165, 31, 0}} ,{{194, 63}, {103, 31, 0}} ,{{0, 64}, {167, 31, 0}} ,{{190, 63}, {99, 31, 0}} ,{{252, 63}, {163, 31, 0}} ,{{250, 63}, {161, 31, 0}} ,{{216, 63}, {125, 31, 0}} ,{{70, 64}, {244, 31, 0}} ,{{71, 64}, {246, 31, 0}} ,{{72, 64}, {247, 31, 0}} ,{{187, 63}, {96, 31, 0}} ,{{191, 63}, {100, 31, 0}} ,{{253, 63}, {164, 31, 0}} ,{{193, 63}, {102, 31, 0}} ,{{255, 63}, {166, 31, 0}} ,{{189, 63}, {98, 31, 0}} ,{{251, 63}, {162, 31, 0}} ,{{249, 63}, {160, 31, 0}} ,{{102, 41}, {206, 3, 0}} ,{{215, 63}, {124, 31, 0}} ,{{68, 64}, {242, 31, 0}} ,{{69, 64}, {243, 31, 0}} ,{{87, 41}, {191, 3, 0}} ,{{164, 63}, {65, 31, 0}} ,{{168, 63}, {69, 31, 0}} ,{{166, 63}, {67, 31, 0}} ,{{212, 63}, {121, 31, 0}} ,{{163, 63}, {64, 31, 0}} ,{{167, 63}, {68, 31, 0}} ,{{165, 63}, {66, 31, 0}} ,{{100, 41}, {204, 3, 0}} ,{{211, 63}, {120, 31, 0}} ,{{25, 41}, {119, 3, 0}} ,{{94, 41}, {198, 3, 0}} ,{{88, 41}, {192, 3, 0}} ,{{96, 41}, {200, 3, 0}} ,{{89, 41}, {193, 3, 0}} ,{{57, 64}, {229, 31, 0}} ,{{56, 64}, {228, 31, 0}} ,{{121, 41}, {225, 3, 0}} ,{{147, 41}, {251, 3, 0}} ,{{144, 41}, {248, 3, 0}} ,{{91, 41}, {195, 3, 0}} ,{{115, 41}, {219, 3, 0}} ,{{92, 41}, {196, 3, 0}} ,{{80, 41}, {184, 3, 0}} ,{{93, 41}, {197, 3, 0}} ,{{176, 63}, {81, 31, 0}} ,{{180, 63}, {85, 31, 0}} ,{{182, 63}, {87, 31, 0}} ,{{178, 63}, {83, 31, 0}} ,{{99, 41}, {203, 3, 0}} ,{{55, 64}, {227, 31, 0}} ,{{59, 64}, {231, 31, 0}} ,{{72, 41}, {176, 3, 0}} ,{{54, 64}, {226, 31, 0}} ,{{53, 64}, {225, 31, 0}} ,{{214, 63}, {123, 31, 0}} ,{{58, 64}, {230, 31, 0}} ,{{175, 63}, {80, 31, 0}} ,{{179, 63}, {84, 31, 0}} ,{{181, 63}, {86, 31, 0}} ,{{177, 63}, {82, 31, 0}} ,{{101, 41}, {205, 3, 0}} ,{{213, 63}, {122, 31, 0}} ,{{52, 64}, {224, 31, 0}} ,{{86, 41}, {190, 3, 0}} ,{{78, 41}, {182, 3, 0}} ,{{29, 41}, {125, 3, 0}} ,{{27, 41}, {123, 3, 0}} ,{{227, 61}, {102, 29, 0}} ,{{231, 61}, {106, 29, 0}} ,{{228, 61}, {103, 29, 0}} ,{{230, 61}, {105, 29, 0}} ,{{229, 61}, {104, 29, 0}} ,{{194, 143}, {122, 1, 1}} ,{{105, 41}, {209, 3, 0}} ,{{198, 143}, {126, 1, 1}} ,{{192, 143}, {120, 1, 1}} ,{{31, 41}, {132, 3, 0}} ,{{209, 143}, {137, 1, 1}} ,{{197, 143}, {125, 1, 1}} ,{{191, 143}, {119, 1, 1}} ,{{107, 41}, {211, 3, 0}} ,{{108, 41}, {212, 3, 0}} ,{{106, 41}, {210, 3, 0}} ,{{67, 64}, {239, 31, 0}} ,{{120, 157}, {0, 210, 1}} ,{{129, 157}, {9, 210, 1}} ,{{130, 157}, {10, 210, 1}} ,{{131, 157}, {11, 210, 1}} ,{{132, 157}, {12, 210, 1}} ,{{133, 157}, {13, 210, 1}} ,{{134, 157}, {14, 210, 1}} ,{{135, 157}, {15, 210, 1}} ,{{136, 157}, {16, 210, 1}} ,{{137, 157}, {17, 210, 1}} ,{{138, 157}, {18, 210, 1}} ,{{121, 157}, {1, 210, 1}} ,{{139, 157}, {19, 210, 1}} ,{{140, 157}, {20, 210, 1}} ,{{141, 157}, {21, 210, 1}} ,{{142, 157}, {22, 210, 1}} ,{{143, 157}, {23, 210, 1}} ,{{122, 157}, {2, 210, 1}} ,{{123, 157}, {3, 210, 1}} ,{{124, 157}, {4, 210, 1}} ,{{144, 157}, {24, 210, 1}} ,{{145, 157}, {25, 210, 1}} ,{{146, 157}, {26, 210, 1}} ,{{147, 157}, {27, 210, 1}} ,{{148, 157}, {28, 210, 1}} ,{{125, 157}, {5, 210, 1}} ,{{126, 157}, {6, 210, 1}} ,{{127, 157}, {7, 210, 1}} ,{{128, 157}, {8, 210, 1}} ,{{205, 143}, {133, 1, 1}} ,{{193, 143}, {121, 1, 1}} ,{{26, 41}, {122, 3, 0}} ,{{210, 143}, {138, 1, 1}} ,{{239, 64}, {178, 32, 0}} ,{{252, 46}, {238, 10, 0}} ,{{249, 46}, {235, 10, 0}} ,{{248, 46}, {234, 10, 0}} ,{{253, 46}, {239, 10, 0}} ,{{245, 46}, {231, 10, 0}} ,{{251, 46}, {237, 10, 0}} ,{{250, 46}, {236, 10, 0}} ,{{247, 46}, {233, 10, 0}} ,{{246, 46}, {232, 10, 0}} ,{{244, 46}, {230, 10, 0}} ,{{175, 46}, {133, 10, 0}} ,{{176, 46}, {134, 10, 0}} ,{{185, 46}, {144, 10, 0}} ,{{188, 46}, {148, 10, 0}} ,{{211, 46}, {172, 10, 0}} ,{{212, 46}, {173, 10, 0}} ,{{194, 46}, {154, 10, 0}} ,{{195, 46}, {155, 10, 0}} ,{{206, 46}, {166, 10, 0}} ,{{201, 46}, {161, 10, 0}} ,{{202, 46}, {162, 10, 0}} ,{{207, 46}, {167, 10, 0}} ,{{184, 46}, {143, 10, 0}} ,{{191, 46}, {151, 10, 0}} ,{{192, 46}, {152, 10, 0}} ,{{222, 46}, {185, 10, 0}} ,{{177, 46}, {135, 10, 0}} ,{{178, 46}, {136, 10, 0}} ,{{196, 46}, {156, 10, 0}} ,{{197, 46}, {157, 10, 0}} ,{{189, 46}, {149, 10, 0}} ,{{190, 46}, {150, 10, 0}} ,{{216, 46}, {178, 10, 0}} ,{{217, 46}, {179, 10, 0}} ,{{213, 46}, {174, 10, 0}} ,{{208, 46}, {168, 10, 0}} ,{{193, 46}, {153, 10, 0}} ,{{203, 46}, {163, 10, 0}} ,{{198, 46}, {158, 10, 0}} ,{{187, 46}, {147, 10, 0}} ,{{209, 46}, {170, 10, 0}} ,{{210, 46}, {171, 10, 0}} ,{{215, 46}, {176, 10, 0}} ,{{221, 46}, {184, 10, 0}} ,{{219, 46}, {182, 10, 0}} ,{{220, 46}, {183, 10, 0}} ,{{204, 46}, {164, 10, 0}} ,{{205, 46}, {165, 10, 0}} ,{{199, 46}, {159, 10, 0}} ,{{200, 46}, {160, 10, 0}} ,{{179, 46}, {137, 10, 0}} ,{{180, 46}, {138, 10, 0}} ,{{218, 46}, {181, 10, 0}} ,{{182, 46}, {140, 10, 0}} ,{{241, 46}, {225, 10, 0}} ,{{181, 46}, {139, 10, 0}} ,{{240, 46}, {224, 10, 0}} ,{{214, 46}, {175, 10, 0}} ,{{239, 46}, {208, 10, 0}} ,{{254, 46}, {241, 10, 0}} ,{{173, 46}, {130, 10, 0}} ,{{224, 46}, {189, 10, 0}} ,{{172, 46}, {129, 10, 0}} ,{{223, 46}, {188, 10, 0}} ,{{238, 46}, {205, 10, 0}} ,{{174, 46}, {131, 10, 0}} ,{{183, 46}, {141, 10, 0}} ,{{186, 46}, {145, 10, 0}} ,{{225, 46}, {190, 10, 0}} ,{{234, 46}, {200, 10, 0}} ,{{237, 46}, {204, 10, 0}} ,{{232, 46}, {197, 10, 0}} ,{{235, 46}, {201, 10, 0}} ,{{233, 46}, {199, 10, 0}} ,{{226, 46}, {191, 10, 0}} ,{{227, 46}, {192, 10, 0}} ,{{236, 46}, {203, 10, 0}} ,{{228, 46}, {193, 10, 0}} ,{{229, 46}, {194, 10, 0}} ,{{242, 46}, {226, 10, 0}} ,{{243, 46}, {227, 10, 0}} ,{{230, 46}, {195, 10, 0}} ,{{231, 46}, {196, 10, 0}} ,{{167, 46}, {113, 10, 0}} ,{{164, 46}, {110, 10, 0}} ,{{161, 46}, {107, 10, 0}} ,{{160, 46}, {106, 10, 0}} ,{{165, 46}, {111, 10, 0}} ,{{157, 46}, {103, 10, 0}} ,{{163, 46}, {109, 10, 0}} ,{{162, 46}, {108, 10, 0}} ,{{159, 46}, {105, 10, 0}} ,{{158, 46}, {104, 10, 0}} ,{{156, 46}, {102, 10, 0}} ,{{170, 46}, {116, 10, 0}} ,{{168, 46}, {114, 10, 0}} ,{{96, 46}, {5, 10, 0}} ,{{97, 46}, {6, 10, 0}} ,{{103, 46}, {16, 10, 0}} ,{{105, 46}, {20, 10, 0}} ,{{128, 46}, {44, 10, 0}} ,{{129, 46}, {45, 10, 0}} ,{{111, 46}, {26, 10, 0}} ,{{112, 46}, {27, 10, 0}} ,{{123, 46}, {38, 10, 0}} ,{{118, 46}, {33, 10, 0}} ,{{119, 46}, {34, 10, 0}} ,{{124, 46}, {39, 10, 0}} ,{{102, 46}, {15, 10, 0}} ,{{155, 46}, {94, 10, 0}} ,{{108, 46}, {23, 10, 0}} ,{{109, 46}, {24, 10, 0}} ,{{152, 46}, {90, 10, 0}} ,{{138, 46}, {57, 10, 0}} ,{{98, 46}, {7, 10, 0}} ,{{99, 46}, {8, 10, 0}} ,{{113, 46}, {28, 10, 0}} ,{{114, 46}, {29, 10, 0}} ,{{106, 46}, {21, 10, 0}} ,{{107, 46}, {22, 10, 0}} ,{{151, 46}, {89, 10, 0}} ,{{133, 46}, {50, 10, 0}} ,{{134, 46}, {51, 10, 0}} ,{{130, 46}, {46, 10, 0}} ,{{125, 46}, {40, 10, 0}} ,{{110, 46}, {25, 10, 0}} ,{{120, 46}, {35, 10, 0}} ,{{115, 46}, {30, 10, 0}} ,{{104, 46}, {19, 10, 0}} ,{{126, 46}, {42, 10, 0}} ,{{127, 46}, {43, 10, 0}} ,{{132, 46}, {48, 10, 0}} ,{{154, 46}, {92, 10, 0}} ,{{137, 46}, {56, 10, 0}} ,{{136, 46}, {54, 10, 0}} ,{{121, 46}, {36, 10, 0}} ,{{122, 46}, {37, 10, 0}} ,{{116, 46}, {31, 10, 0}} ,{{117, 46}, {32, 10, 0}} ,{{100, 46}, {9, 10, 0}} ,{{101, 46}, {10, 10, 0}} ,{{135, 46}, {53, 10, 0}} ,{{131, 46}, {47, 10, 0}} ,{{153, 46}, {91, 10, 0}} ,{{93, 46}, {1, 10, 0}} ,{{94, 46}, {2, 10, 0}} ,{{139, 46}, {60, 10, 0}} ,{{150, 46}, {81, 10, 0}} ,{{149, 46}, {77, 10, 0}} ,{{95, 46}, {3, 10, 0}} ,{{171, 46}, {117, 10, 0}} ,{{166, 46}, {112, 10, 0}} ,{{169, 46}, {115, 10, 0}} ,{{140, 46}, {62, 10, 0}} ,{{146, 46}, {72, 10, 0}} ,{{148, 46}, {76, 10, 0}} ,{{145, 46}, {71, 10, 0}} ,{{141, 46}, {63, 10, 0}} ,{{142, 46}, {64, 10, 0}} ,{{147, 46}, {75, 10, 0}} ,{{143, 46}, {65, 10, 0}} ,{{144, 46}, {66, 10, 0}} ,{{90, 64}, {10, 32, 0}} ,{{117, 142}, {237, 255, 0}} ,{{116, 142}, {236, 255, 0}} ,{{112, 142}, {232, 255, 0}} ,{{53, 142}, {160, 255, 0}} ,{{84, 142}, {194, 255, 0}} ,{{85, 142}, {195, 255, 0}} ,{{79, 142}, {186, 255, 0}} ,{{77, 142}, {184, 255, 0}} ,{{89, 142}, {199, 255, 0}} ,{{88, 142}, {198, 255, 0}} ,{{102, 142}, {218, 255, 0}} ,{{83, 142}, {190, 255, 0}} ,{{104, 142}, {220, 255, 0}} ,{{76, 142}, {183, 255, 0}} ,{{80, 142}, {187, 255, 0}} ,{{54, 142}, {161, 255, 0}} ,{{56, 142}, {163, 255, 0}} ,{{70, 142}, {177, 255, 0}} ,{{57, 142}, {164, 255, 0}} ,{{58, 142}, {165, 255, 0}} ,{{59, 142}, {166, 255, 0}} ,{{92, 142}, {204, 255, 0}} ,{{95, 142}, {207, 255, 0}} ,{{82, 142}, {189, 255, 0}} ,{{71, 142}, {178, 255, 0}} ,{{73, 142}, {180, 255, 0}} ,{{62, 142}, {169, 255, 0}} ,{{69, 142}, {176, 255, 0}} ,{{63, 142}, {170, 255, 0}} ,{{64, 142}, {171, 255, 0}} ,{{68, 142}, {175, 255, 0}} ,{{65, 142}, {172, 255, 0}} ,{{66, 142}, {173, 255, 0}} ,{{67, 142}, {174, 255, 0}} ,{{74, 142}, {181, 255, 0}} ,{{78, 142}, {185, 255, 0}} ,{{55, 142}, {162, 255, 0}} ,{{72, 142}, {179, 255, 0}} ,{{75, 142}, {182, 255, 0}} ,{{61, 142}, {168, 255, 0}} ,{{81, 142}, {188, 255, 0}} ,{{60, 142}, {167, 255, 0}} ,{{97, 142}, {211, 255, 0}} ,{{93, 142}, {205, 255, 0}} ,{{94, 142}, {206, 255, 0}} ,{{99, 142}, {213, 255, 0}} ,{{98, 142}, {212, 255, 0}} ,{{100, 142}, {214, 255, 0}} ,{{86, 142}, {196, 255, 0}} ,{{87, 142}, {197, 255, 0}} ,{{91, 142}, {203, 255, 0}} ,{{90, 142}, {202, 255, 0}} ,{{103, 142}, {219, 255, 0}} ,{{96, 142}, {210, 255, 0}} ,{{101, 142}, {215, 255, 0}} ,{{249, 141}, {100, 255, 0}} ,{{246, 141}, {97, 255, 0}} ,{{5, 142}, {112, 255, 0}} ,{{6, 142}, {113, 255, 0}} ,{{9, 142}, {116, 255, 0}} ,{{31, 142}, {138, 255, 0}} ,{{34, 142}, {141, 255, 0}} ,{{32, 142}, {139, 255, 0}} ,{{35, 142}, {142, 255, 0}} ,{{33, 142}, {140, 255, 0}} ,{{7, 142}, {114, 255, 0}} ,{{11, 142}, {118, 255, 0}} ,{{14, 142}, {121, 255, 0}} ,{{12, 142}, {119, 255, 0}} ,{{15, 142}, {122, 255, 0}} ,{{13, 142}, {120, 255, 0}} ,{{36, 142}, {143, 255, 0}} ,{{39, 142}, {146, 255, 0}} ,{{37, 142}, {144, 255, 0}} ,{{40, 142}, {147, 255, 0}} ,{{38, 142}, {145, 255, 0}} ,{{50, 142}, {157, 255, 0}} ,{{26, 142}, {133, 255, 0}} ,{{29, 142}, {136, 255, 0}} ,{{27, 142}, {134, 255, 0}} ,{{30, 142}, {137, 255, 0}} ,{{28, 142}, {135, 255, 0}} ,{{10, 142}, {117, 255, 0}} ,{{44, 142}, {151, 255, 0}} ,{{47, 142}, {154, 255, 0}} ,{{45, 142}, {152, 255, 0}} ,{{48, 142}, {155, 255, 0}} ,{{46, 142}, {153, 255, 0}} ,{{16, 142}, {123, 255, 0}} ,{{19, 142}, {126, 255, 0}} ,{{17, 142}, {124, 255, 0}} ,{{252, 141}, {103, 255, 0}} ,{{255, 141}, {106, 255, 0}} ,{{253, 141}, {104, 255, 0}} ,{{0, 142}, {107, 255, 0}} ,{{4, 142}, {111, 255, 0}} ,{{254, 141}, {105, 255, 0}} ,{{1, 142}, {108, 255, 0}} ,{{3, 142}, {110, 255, 0}} ,{{2, 142}, {109, 255, 0}} ,{{20, 142}, {127, 255, 0}} ,{{18, 142}, {125, 255, 0}} ,{{21, 142}, {128, 255, 0}} ,{{24, 142}, {131, 255, 0}} ,{{22, 142}, {129, 255, 0}} ,{{25, 142}, {132, 255, 0}} ,{{23, 142}, {130, 255, 0}} ,{{8, 142}, {115, 255, 0}} ,{{49, 142}, {156, 255, 0}} ,{{251, 141}, {102, 255, 0}} ,{{41, 142}, {148, 255, 0}} ,{{43, 142}, {150, 255, 0}} ,{{42, 142}, {149, 255, 0}} ,{{250, 141}, {101, 255, 0}} ,{{52, 142}, {159, 255, 0}} ,{{51, 142}, {158, 255, 0}} ,{{113, 142}, {233, 255, 0}} ,{{247, 141}, {98, 255, 0}} ,{{115, 142}, {235, 255, 0}} ,{{248, 141}, {99, 255, 0}} ,{{114, 142}, {234, 255, 0}} ,{{118, 142}, {238, 255, 0}} ,{{94, 70}, {146, 38, 0}} ,{{249, 69}, {45, 38, 0}} ,{{170, 51}, {85, 17, 0}} ,{{165, 51}, {80, 17, 0}} ,{{147, 51}, {62, 17, 0}} ,{{166, 51}, {81, 17, 0}} ,{{148, 51}, {63, 17, 0}} ,{{99, 51}, {14, 17, 0}} ,{{168, 51}, {83, 17, 0}} ,{{167, 51}, {82, 17, 0}} ,{{169, 51}, {84, 17, 0}} ,{{163, 51}, {78, 17, 0}} ,{{145, 51}, {60, 17, 0}} ,{{164, 51}, {79, 17, 0}} ,{{146, 51}, {61, 17, 0}} ,{{97, 51}, {12, 17, 0}} ,{{162, 51}, {77, 17, 0}} ,{{180, 51}, {95, 17, 0}} ,{{103, 51}, {18, 17, 0}} ,{{19, 91}, {123, 169, 0}} ,{{96, 51}, {11, 17, 0}} ,{{158, 51}, {73, 17, 0}} ,{{157, 51}, {72, 17, 0}} ,{{15, 91}, {119, 169, 0}} ,{{150, 51}, {65, 17, 0}} ,{{152, 51}, {67, 17, 0}} ,{{155, 51}, {70, 17, 0}} ,{{160, 51}, {75, 17, 0}} ,{{153, 51}, {68, 17, 0}} ,{{14, 91}, {118, 169, 0}} ,{{154, 51}, {69, 17, 0}} ,{{159, 51}, {74, 17, 0}} ,{{151, 51}, {66, 17, 0}} ,{{114, 51}, {29, 17, 0}} ,{{172, 51}, {87, 17, 0}} ,{{128, 51}, {43, 17, 0}} ,{{112, 51}, {27, 17, 0}} ,{{129, 51}, {44, 17, 0}} ,{{100, 51}, {15, 17, 0}} ,{{85, 51}, {0, 17, 0}} ,{{175, 51}, {90, 17, 0}} ,{{91, 51}, {6, 17, 0}} ,{{7, 91}, {111, 169, 0}} ,{{113, 51}, {28, 17, 0}} ,{{9, 91}, {113, 169, 0}} ,{{8, 91}, {112, 169, 0}} ,{{87, 51}, {2, 17, 0}} ,{{177, 51}, {92, 17, 0}} ,{{178, 51}, {93, 17, 0}} ,{{104, 51}, {19, 17, 0}} ,{{107, 51}, {22, 17, 0}} ,{{176, 51}, {91, 17, 0}} ,{{106, 51}, {21, 17, 0}} ,{{149, 51}, {64, 17, 0}} ,{{102, 51}, {17, 17, 0}} ,{{18, 91}, {122, 169, 0}} ,{{171, 51}, {86, 17, 0}} ,{{92, 51}, {7, 17, 0}} ,{{125, 51}, {40, 17, 0}} ,{{124, 51}, {39, 17, 0}} ,{{12, 91}, {116, 169, 0}} ,{{11, 91}, {115, 169, 0}} ,{{115, 51}, {30, 17, 0}} ,{{116, 51}, {31, 17, 0}} ,{{127, 51}, {42, 17, 0}} ,{{118, 51}, {33, 17, 0}} ,{{123, 51}, {38, 17, 0}} ,{{119, 51}, {34, 17, 0}} ,{{121, 51}, {36, 17, 0}} ,{{10, 91}, {114, 169, 0}} ,{{120, 51}, {35, 17, 0}} ,{{122, 51}, {37, 17, 0}} ,{{126, 51}, {41, 17, 0}} ,{{117, 51}, {32, 17, 0}} ,{{90, 51}, {5, 17, 0}} ,{{5, 91}, {109, 169, 0}} ,{{111, 51}, {26, 17, 0}} ,{{3, 91}, {107, 169, 0}} ,{{6, 91}, {110, 169, 0}} ,{{252, 90}, {100, 169, 0}} ,{{0, 91}, {104, 169, 0}} ,{{109, 51}, {24, 17, 0}} ,{{1, 91}, {105, 169, 0}} ,{{4, 91}, {108, 169, 0}} ,{{253, 90}, {101, 169, 0}} ,{{2, 91}, {106, 169, 0}} ,{{255, 90}, {103, 169, 0}} ,{{254, 90}, {102, 169, 0}} ,{{94, 51}, {9, 17, 0}} ,{{140, 51}, {55, 17, 0}} ,{{139, 51}, {54, 17, 0}} ,{{144, 51}, {59, 17, 0}} ,{{138, 51}, {53, 17, 0}} ,{{141, 51}, {56, 17, 0}} ,{{130, 51}, {45, 17, 0}} ,{{134, 51}, {49, 17, 0}} ,{{131, 51}, {46, 17, 0}} ,{{143, 51}, {58, 17, 0}} ,{{135, 51}, {50, 17, 0}} ,{{136, 51}, {51, 17, 0}} ,{{133, 51}, {48, 17, 0}} ,{{137, 51}, {52, 17, 0}} ,{{142, 51}, {57, 17, 0}} ,{{132, 51}, {47, 17, 0}} ,{{98, 51}, {13, 17, 0}} ,{{16, 91}, {120, 169, 0}} ,{{173, 51}, {88, 17, 0}} ,{{156, 51}, {71, 17, 0}} ,{{86, 51}, {1, 17, 0}} ,{{105, 51}, {20, 17, 0}} ,{{93, 51}, {8, 17, 0}} ,{{110, 51}, {25, 17, 0}} ,{{95, 51}, {10, 17, 0}} ,{{13, 91}, {117, 169, 0}} ,{{17, 91}, {121, 169, 0}} ,{{89, 51}, {4, 17, 0}} ,{{20, 91}, {124, 169, 0}} ,{{101, 51}, {16, 17, 0}} ,{{88, 51}, {3, 17, 0}} ,{{251, 90}, {99, 169, 0}} ,{{108, 51}, {23, 17, 0}} ,{{248, 90}, {96, 169, 0}} ,{{249, 90}, {97, 169, 0}} ,{{179, 51}, {94, 17, 0}} ,{{250, 90}, {98, 169, 0}} ,{{174, 51}, {89, 17, 0}} ,{{161, 51}, {76, 17, 0}} ,{{129, 78}, {47, 48, 0}} ,{{171, 79}, {100, 49, 0}} ,{{19, 52}, {190, 17, 0}} ,{{18, 52}, {189, 17, 0}} ,{{70, 136}, {247, 215, 0}} ,{{71, 136}, {248, 215, 0}} ,{{23, 52}, {194, 17, 0}} ,{{76, 52}, {247, 17, 0}} ,{{74, 52}, {245, 17, 0}} ,{{77, 52}, {248, 17, 0}} ,{{75, 52}, {246, 17, 0}} ,{{17, 52}, {188, 17, 0}} ,{{68, 52}, {239, 17, 0}} ,{{65, 52}, {236, 17, 0}} ,{{66, 52}, {237, 17, 0}} ,{{55, 52}, {226, 17, 0}} ,{{73, 52}, {244, 17, 0}} ,{{59, 52}, {230, 17, 0}} ,{{44, 136}, {221, 215, 0}} ,{{20, 52}, {191, 17, 0}} ,{{253, 51}, {168, 17, 0}} ,{{81, 52}, {252, 17, 0}} ,{{83, 52}, {254, 17, 0}} ,{{82, 52}, {253, 17, 0}} ,{{79, 52}, {250, 17, 0}} ,{{80, 52}, {251, 17, 0}} ,{{24, 52}, {195, 17, 0}} ,{{255, 51}, {170, 17, 0}} ,{{25, 52}, {196, 17, 0}} ,{{12, 52}, {183, 17, 0}} ,{{53, 52}, {224, 17, 0}} ,{{49, 136}, {226, 215, 0}} ,{{54, 52}, {225, 17, 0}} ,{{47, 52}, {218, 17, 0}} ,{{45, 136}, {222, 215, 0}} ,{{52, 52}, {223, 17, 0}} ,{{49, 52}, {220, 17, 0}} ,{{48, 136}, {225, 215, 0}} ,{{48, 52}, {219, 17, 0}} ,{{50, 52}, {221, 17, 0}} ,{{46, 136}, {223, 215, 0}} ,{{51, 52}, {222, 17, 0}} ,{{0, 52}, {171, 17, 0}} ,{{27, 136}, {204, 215, 0}} ,{{1, 52}, {172, 17, 0}} ,{{2, 52}, {173, 17, 0}} ,{{26, 52}, {197, 17, 0}} ,{{29, 52}, {200, 17, 0}} ,{{26, 136}, {203, 215, 0}} ,{{28, 52}, {199, 17, 0}} ,{{30, 52}, {201, 17, 0}} ,{{27, 52}, {198, 17, 0}} ,{{64, 52}, {235, 17, 0}} ,{{67, 136}, {244, 215, 0}} ,{{66, 136}, {243, 215, 0}} ,{{22, 52}, {193, 17, 0}} ,{{72, 52}, {243, 17, 0}} ,{{73, 136}, {250, 215, 0}} ,{{74, 136}, {251, 215, 0}} ,{{13, 52}, {184, 17, 0}} ,{{56, 136}, {233, 215, 0}} ,{{55, 136}, {232, 215, 0}} ,{{58, 52}, {229, 17, 0}} ,{{52, 136}, {229, 215, 0}} ,{{57, 52}, {228, 17, 0}} ,{{56, 52}, {227, 17, 0}} ,{{51, 136}, {228, 215, 0}} ,{{14, 52}, {185, 17, 0}} ,{{54, 136}, {231, 215, 0}} ,{{50, 136}, {227, 215, 0}} ,{{4, 52}, {175, 17, 0}} ,{{11, 52}, {182, 17, 0}} ,{{42, 52}, {213, 17, 0}} ,{{45, 52}, {216, 17, 0}} ,{{5, 52}, {176, 17, 0}} ,{{37, 136}, {214, 215, 0}} ,{{33, 52}, {204, 17, 0}} ,{{6, 52}, {177, 17, 0}} ,{{39, 136}, {216, 215, 0}} ,{{38, 52}, {209, 17, 0}} ,{{39, 52}, {210, 17, 0}} ,{{34, 52}, {205, 17, 0}} ,{{44, 52}, {215, 17, 0}} ,{{10, 52}, {181, 17, 0}} ,{{7, 52}, {178, 17, 0}} ,{{41, 52}, {212, 17, 0}} ,{{41, 136}, {218, 215, 0}} ,{{40, 52}, {211, 17, 0}} ,{{40, 136}, {217, 215, 0}} ,{{8, 52}, {179, 17, 0}} ,{{36, 136}, {213, 215, 0}} ,{{43, 52}, {214, 17, 0}} ,{{9, 52}, {180, 17, 0}} ,{{35, 52}, {206, 17, 0}} ,{{36, 52}, {207, 17, 0}} ,{{46, 52}, {217, 17, 0}} ,{{43, 136}, {220, 215, 0}} ,{{42, 136}, {219, 215, 0}} ,{{15, 52}, {186, 17, 0}} ,{{63, 136}, {240, 215, 0}} ,{{62, 136}, {239, 215, 0}} ,{{65, 136}, {242, 215, 0}} ,{{58, 136}, {235, 215, 0}} ,{{60, 52}, {231, 17, 0}} ,{{57, 136}, {234, 215, 0}} ,{{61, 136}, {238, 215, 0}} ,{{63, 52}, {234, 17, 0}} ,{{62, 52}, {233, 17, 0}} ,{{64, 136}, {241, 215, 0}} ,{{61, 52}, {232, 17, 0}} ,{{72, 136}, {249, 215, 0}} ,{{67, 52}, {238, 17, 0}} ,{{254, 51}, {169, 17, 0}} ,{{47, 136}, {224, 215, 0}} ,{{84, 52}, {255, 17, 0}} ,{{53, 136}, {230, 215, 0}} ,{{37, 52}, {208, 17, 0}} ,{{38, 136}, {215, 215, 0}} ,{{16, 52}, {187, 17, 0}} ,{{59, 136}, {236, 215, 0}} ,{{60, 136}, {237, 215, 0}} ,{{28, 136}, {205, 215, 0}} ,{{29, 136}, {206, 215, 0}} ,{{21, 52}, {192, 17, 0}} ,{{3, 52}, {174, 17, 0}} ,{{34, 136}, {211, 215, 0}} ,{{33, 136}, {210, 215, 0}} ,{{31, 52}, {202, 17, 0}} ,{{30, 136}, {207, 215, 0}} ,{{32, 52}, {203, 17, 0}} ,{{31, 136}, {208, 215, 0}} ,{{32, 136}, {209, 215, 0}} ,{{35, 136}, {212, 215, 0}} ,{{78, 52}, {249, 17, 0}} ,{{69, 52}, {240, 17, 0}} ,{{69, 136}, {246, 215, 0}} ,{{68, 136}, {245, 215, 0}} ,{{71, 52}, {242, 17, 0}} ,{{70, 52}, {241, 17, 0}} ,{{182, 51}, {97, 17, 0}} ,{{248, 51}, {163, 17, 0}} ,{{203, 51}, {118, 17, 0}} ,{{204, 51}, {119, 17, 0}} ,{{183, 51}, {98, 17, 0}} ,{{243, 51}, {158, 17, 0}} ,{{24, 136}, {197, 215, 0}} ,{{25, 136}, {198, 215, 0}} ,{{244, 51}, {159, 17, 0}} ,{{246, 51}, {161, 17, 0}} ,{{245, 51}, {160, 17, 0}} ,{{187, 51}, {102, 17, 0}} ,{{186, 51}, {101, 17, 0}} ,{{209, 51}, {124, 17, 0}} ,{{207, 51}, {122, 17, 0}} ,{{208, 51}, {123, 17, 0}} ,{{200, 51}, {115, 17, 0}} ,{{12, 136}, {185, 215, 0}} ,{{14, 136}, {187, 215, 0}} ,{{13, 136}, {186, 215, 0}} ,{{235, 51}, {150, 17, 0}} ,{{15, 136}, {188, 215, 0}} ,{{234, 51}, {149, 17, 0}} ,{{181, 51}, {96, 17, 0}} ,{{202, 51}, {117, 17, 0}} ,{{237, 51}, {152, 17, 0}} ,{{242, 51}, {157, 17, 0}} ,{{241, 51}, {156, 17, 0}} ,{{23, 136}, {196, 215, 0}} ,{{239, 51}, {154, 17, 0}} ,{{20, 136}, {193, 215, 0}} ,{{240, 51}, {155, 17, 0}} ,{{238, 51}, {153, 17, 0}} ,{{16, 136}, {189, 215, 0}} ,{{17, 136}, {190, 215, 0}} ,{{19, 136}, {192, 215, 0}} ,{{18, 136}, {191, 215, 0}} ,{{21, 136}, {194, 215, 0}} ,{{22, 136}, {195, 215, 0}} ,{{190, 51}, {105, 17, 0}} ,{{213, 51}, {128, 17, 0}} ,{{212, 51}, {127, 17, 0}} ,{{215, 51}, {130, 17, 0}} ,{{4, 136}, {177, 215, 0}} ,{{216, 51}, {131, 17, 0}} ,{{251, 51}, {166, 17, 0}} ,{{252, 51}, {167, 17, 0}} ,{{214, 51}, {129, 17, 0}} ,{{3, 136}, {176, 215, 0}} ,{{193, 51}, {108, 17, 0}} ,{{247, 51}, {162, 17, 0}} ,{{195, 51}, {110, 17, 0}} ,{{222, 51}, {137, 17, 0}} ,{{223, 51}, {138, 17, 0}} ,{{224, 51}, {139, 17, 0}} ,{{9, 136}, {182, 215, 0}} ,{{226, 51}, {141, 17, 0}} ,{{225, 51}, {140, 17, 0}} ,{{8, 136}, {181, 215, 0}} ,{{191, 51}, {106, 17, 0}} ,{{192, 51}, {107, 17, 0}} ,{{197, 51}, {112, 17, 0}} ,{{196, 51}, {111, 17, 0}} ,{{198, 51}, {113, 17, 0}} ,{{184, 51}, {99, 17, 0}} ,{{205, 51}, {120, 17, 0}} ,{{249, 51}, {164, 17, 0}} ,{{206, 51}, {121, 17, 0}} ,{{185, 51}, {100, 17, 0}} ,{{189, 51}, {104, 17, 0}} ,{{188, 51}, {103, 17, 0}} ,{{210, 51}, {125, 17, 0}} ,{{211, 51}, {126, 17, 0}} ,{{250, 51}, {165, 17, 0}} ,{{201, 51}, {116, 17, 0}} ,{{236, 51}, {151, 17, 0}} ,{{194, 51}, {109, 17, 0}} ,{{5, 136}, {178, 215, 0}} ,{{6, 136}, {179, 215, 0}} ,{{7, 136}, {180, 215, 0}} ,{{221, 51}, {136, 17, 0}} ,{{220, 51}, {135, 17, 0}} ,{{217, 51}, {132, 17, 0}} ,{{218, 51}, {133, 17, 0}} ,{{219, 51}, {134, 17, 0}} ,{{199, 51}, {114, 17, 0}} ,{{227, 51}, {142, 17, 0}} ,{{10, 136}, {183, 215, 0}} ,{{229, 51}, {144, 17, 0}} ,{{228, 51}, {143, 17, 0}} ,{{233, 51}, {148, 17, 0}} ,{{11, 136}, {184, 215, 0}} ,{{232, 51}, {147, 17, 0}} ,{{231, 51}, {146, 17, 0}} ,{{230, 51}, {145, 17, 0}} ,{{150, 79}, {79, 49, 0}} ,{{151, 79}, {80, 49, 0}} ,{{212, 79}, {141, 49, 0}} ,{{213, 79}, {142, 49, 0}} ,{{145, 79}, {74, 49, 0}} ,{{143, 79}, {72, 49, 0}} ,{{155, 79}, {84, 49, 0}} ,{{154, 79}, {83, 49, 0}} ,{{168, 79}, {97, 49, 0}} ,{{149, 79}, {78, 49, 0}} ,{{170, 79}, {99, 49, 0}} ,{{142, 79}, {71, 49, 0}} ,{{184, 79}, {113, 49, 0}} ,{{203, 79}, {132, 49, 0}} ,{{191, 79}, {120, 49, 0}} ,{{192, 79}, {121, 49, 0}} ,{{146, 79}, {75, 49, 0}} ,{{120, 79}, {49, 49, 0}} ,{{122, 79}, {51, 49, 0}} ,{{136, 79}, {65, 49, 0}} ,{{183, 79}, {112, 49, 0}} ,{{181, 79}, {110, 49, 0}} ,{{182, 79}, {111, 49, 0}} ,{{123, 79}, {52, 49, 0}} ,{{124, 79}, {53, 49, 0}} ,{{125, 79}, {54, 49, 0}} ,{{175, 79}, {104, 49, 0}} ,{{174, 79}, {103, 49, 0}} ,{{173, 79}, {102, 49, 0}} ,{{158, 79}, {87, 49, 0}} ,{{161, 79}, {90, 49, 0}} ,{{198, 79}, {127, 49, 0}} ,{{148, 79}, {77, 49, 0}} ,{{137, 79}, {66, 49, 0}} ,{{189, 79}, {118, 49, 0}} ,{{185, 79}, {114, 49, 0}} ,{{139, 79}, {68, 49, 0}} ,{{187, 79}, {116, 49, 0}} ,{{188, 79}, {117, 49, 0}} ,{{190, 79}, {119, 49, 0}} ,{{186, 79}, {115, 49, 0}} ,{{128, 79}, {57, 49, 0}} ,{{135, 79}, {64, 49, 0}} ,{{129, 79}, {58, 49, 0}} ,{{176, 79}, {105, 49, 0}} ,{{130, 79}, {59, 49, 0}} ,{{179, 79}, {108, 49, 0}} ,{{134, 79}, {63, 49, 0}} ,{{131, 79}, {60, 49, 0}} ,{{178, 79}, {107, 49, 0}} ,{{132, 79}, {61, 49, 0}} ,{{133, 79}, {62, 49, 0}} ,{{177, 79}, {106, 49, 0}} ,{{180, 79}, {109, 49, 0}} ,{{140, 79}, {69, 49, 0}} ,{{197, 79}, {126, 49, 0}} ,{{193, 79}, {122, 49, 0}} ,{{194, 79}, {123, 49, 0}} ,{{196, 79}, {125, 49, 0}} ,{{195, 79}, {124, 49, 0}} ,{{144, 79}, {73, 49, 0}} ,{{204, 79}, {133, 49, 0}} ,{{199, 79}, {128, 49, 0}} ,{{121, 79}, {50, 49, 0}} ,{{172, 79}, {101, 49, 0}} ,{{138, 79}, {67, 49, 0}} ,{{141, 79}, {70, 49, 0}} ,{{127, 79}, {56, 49, 0}} ,{{147, 79}, {76, 49, 0}} ,{{126, 79}, {55, 49, 0}} ,{{163, 79}, {92, 49, 0}} ,{{159, 79}, {88, 49, 0}} ,{{160, 79}, {89, 49, 0}} ,{{165, 79}, {94, 49, 0}} ,{{164, 79}, {93, 49, 0}} ,{{166, 79}, {95, 49, 0}} ,{{152, 79}, {81, 49, 0}} ,{{153, 79}, {82, 49, 0}} ,{{157, 79}, {86, 49, 0}} ,{{156, 79}, {85, 49, 0}} ,{{205, 79}, {134, 49, 0}} ,{{200, 79}, {129, 49, 0}} ,{{202, 79}, {131, 49, 0}} ,{{201, 79}, {130, 49, 0}} ,{{169, 79}, {98, 49, 0}} ,{{162, 79}, {91, 49, 0}} ,{{208, 79}, {137, 49, 0}} ,{{206, 79}, {135, 49, 0}} ,{{207, 79}, {136, 49, 0}} ,{{167, 79}, {96, 49, 0}} ,{{211, 79}, {140, 49, 0}} ,{{210, 79}, {139, 49, 0}} ,{{209, 79}, {138, 49, 0}} ,{{128, 78}, {46, 48, 0}} ,{{163, 117}, {68, 197, 0}} ,{{180, 117}, {85, 197, 0}} ,{{181, 117}, {86, 197, 0}} ,{{186, 117}, {91, 197, 0}} ,{{170, 117}, {75, 197, 0}} ,{{191, 117}, {96, 197, 0}} ,{{208, 117}, {113, 197, 0}} ,{{209, 117}, {114, 197, 0}} ,{{214, 117}, {119, 197, 0}} ,{{198, 117}, {103, 197, 0}} ,{{192, 117}, {97, 197, 0}} ,{{193, 117}, {98, 197, 0}} ,{{194, 117}, {99, 197, 0}} ,{{218, 117}, {123, 197, 0}} ,{{213, 117}, {118, 197, 0}} ,{{215, 117}, {120, 197, 0}} ,{{199, 117}, {104, 197, 0}} ,{{202, 117}, {107, 197, 0}} ,{{200, 117}, {105, 197, 0}} ,{{206, 117}, {111, 197, 0}} ,{{201, 117}, {106, 197, 0}} ,{{205, 117}, {110, 197, 0}} ,{{203, 117}, {108, 197, 0}} ,{{204, 117}, {109, 197, 0}} ,{{207, 117}, {112, 197, 0}} ,{{195, 117}, {100, 197, 0}} ,{{212, 117}, {117, 197, 0}} ,{{197, 117}, {102, 197, 0}} ,{{196, 117}, {101, 197, 0}} ,{{217, 117}, {122, 197, 0}} ,{{210, 117}, {115, 197, 0}} ,{{211, 117}, {116, 197, 0}} ,{{216, 117}, {121, 197, 0}} ,{{164, 117}, {69, 197, 0}} ,{{165, 117}, {70, 197, 0}} ,{{166, 117}, {71, 197, 0}} ,{{190, 117}, {95, 197, 0}} ,{{185, 117}, {90, 197, 0}} ,{{187, 117}, {92, 197, 0}} ,{{171, 117}, {76, 197, 0}} ,{{174, 117}, {79, 197, 0}} ,{{172, 117}, {77, 197, 0}} ,{{178, 117}, {83, 197, 0}} ,{{173, 117}, {78, 197, 0}} ,{{177, 117}, {82, 197, 0}} ,{{175, 117}, {80, 197, 0}} ,{{176, 117}, {81, 197, 0}} ,{{179, 117}, {84, 197, 0}} ,{{167, 117}, {72, 197, 0}} ,{{184, 117}, {89, 197, 0}} ,{{169, 117}, {74, 197, 0}} ,{{168, 117}, {73, 197, 0}} ,{{189, 117}, {94, 197, 0}} ,{{182, 117}, {87, 197, 0}} ,{{183, 117}, {88, 197, 0}} ,{{188, 117}, {93, 197, 0}} ,{{115, 108}, {20, 188, 0}} ,{{132, 108}, {37, 188, 0}} ,{{133, 108}, {38, 188, 0}} ,{{138, 108}, {43, 188, 0}} ,{{122, 108}, {27, 188, 0}} ,{{143, 108}, {48, 188, 0}} ,{{160, 108}, {65, 188, 0}} ,{{161, 108}, {66, 188, 0}} ,{{166, 108}, {71, 188, 0}} ,{{150, 108}, {55, 188, 0}} ,{{144, 108}, {49, 188, 0}} ,{{145, 108}, {50, 188, 0}} ,{{146, 108}, {51, 188, 0}} ,{{170, 108}, {75, 188, 0}} ,{{165, 108}, {70, 188, 0}} ,{{167, 108}, {72, 188, 0}} ,{{151, 108}, {56, 188, 0}} ,{{154, 108}, {59, 188, 0}} ,{{152, 108}, {57, 188, 0}} ,{{158, 108}, {63, 188, 0}} ,{{153, 108}, {58, 188, 0}} ,{{157, 108}, {62, 188, 0}} ,{{155, 108}, {60, 188, 0}} ,{{156, 108}, {61, 188, 0}} ,{{159, 108}, {64, 188, 0}} ,{{147, 108}, {52, 188, 0}} ,{{164, 108}, {69, 188, 0}} ,{{149, 108}, {54, 188, 0}} ,{{148, 108}, {53, 188, 0}} ,{{169, 108}, {74, 188, 0}} ,{{162, 108}, {67, 188, 0}} ,{{163, 108}, {68, 188, 0}} ,{{168, 108}, {73, 188, 0}} ,{{116, 108}, {21, 188, 0}} ,{{117, 108}, {22, 188, 0}} ,{{118, 108}, {23, 188, 0}} ,{{142, 108}, {47, 188, 0}} ,{{137, 108}, {42, 188, 0}} ,{{139, 108}, {44, 188, 0}} ,{{123, 108}, {28, 188, 0}} ,{{126, 108}, {31, 188, 0}} ,{{124, 108}, {29, 188, 0}} ,{{130, 108}, {35, 188, 0}} ,{{125, 108}, {30, 188, 0}} ,{{129, 108}, {34, 188, 0}} ,{{127, 108}, {32, 188, 0}} ,{{128, 108}, {33, 188, 0}} ,{{131, 108}, {36, 188, 0}} ,{{119, 108}, {24, 188, 0}} ,{{136, 108}, {41, 188, 0}} ,{{121, 108}, {26, 188, 0}} ,{{120, 108}, {25, 188, 0}} ,{{141, 108}, {46, 188, 0}} ,{{134, 108}, {39, 188, 0}} ,{{135, 108}, {40, 188, 0}} ,{{140, 108}, {45, 188, 0}} ,{{191, 110}, {96, 190, 0}} ,{{208, 110}, {113, 190, 0}} ,{{209, 110}, {114, 190, 0}} ,{{214, 110}, {119, 190, 0}} ,{{198, 110}, {103, 190, 0}} ,{{219, 110}, {124, 190, 0}} ,{{236, 110}, {141, 190, 0}} ,{{237, 110}, {142, 190, 0}} ,{{242, 110}, {147, 190, 0}} ,{{226, 110}, {131, 190, 0}} ,{{220, 110}, {125, 190, 0}} ,{{221, 110}, {126, 190, 0}} ,{{222, 110}, {127, 190, 0}} ,{{246, 110}, {151, 190, 0}} ,{{241, 110}, {146, 190, 0}} ,{{243, 110}, {148, 190, 0}} ,{{227, 110}, {132, 190, 0}} ,{{230, 110}, {135, 190, 0}} ,{{228, 110}, {133, 190, 0}} ,{{234, 110}, {139, 190, 0}} ,{{229, 110}, {134, 190, 0}} ,{{233, 110}, {138, 190, 0}} ,{{231, 110}, {136, 190, 0}} ,{{232, 110}, {137, 190, 0}} ,{{235, 110}, {140, 190, 0}} ,{{223, 110}, {128, 190, 0}} ,{{240, 110}, {145, 190, 0}} ,{{225, 110}, {130, 190, 0}} ,{{224, 110}, {129, 190, 0}} ,{{245, 110}, {150, 190, 0}} ,{{238, 110}, {143, 190, 0}} ,{{239, 110}, {144, 190, 0}} ,{{244, 110}, {149, 190, 0}} ,{{192, 110}, {97, 190, 0}} ,{{193, 110}, {98, 190, 0}} ,{{194, 110}, {99, 190, 0}} ,{{218, 110}, {123, 190, 0}} ,{{213, 110}, {118, 190, 0}} ,{{215, 110}, {120, 190, 0}} ,{{199, 110}, {104, 190, 0}} ,{{202, 110}, {107, 190, 0}} ,{{200, 110}, {105, 190, 0}} ,{{206, 110}, {111, 190, 0}} ,{{201, 110}, {106, 190, 0}} ,{{205, 110}, {110, 190, 0}} ,{{203, 110}, {108, 190, 0}} ,{{204, 110}, {109, 190, 0}} ,{{207, 110}, {112, 190, 0}} ,{{195, 110}, {100, 190, 0}} ,{{212, 110}, {117, 190, 0}} ,{{197, 110}, {102, 190, 0}} ,{{196, 110}, {101, 190, 0}} ,{{217, 110}, {122, 190, 0}} ,{{210, 110}, {115, 190, 0}} ,{{211, 110}, {116, 190, 0}} ,{{216, 110}, {121, 190, 0}} ,{{75, 111}, {236, 190, 0}} ,{{92, 111}, {253, 190, 0}} ,{{93, 111}, {254, 190, 0}} ,{{98, 111}, {3, 191, 0}} ,{{82, 111}, {243, 190, 0}} ,{{76, 111}, {237, 190, 0}} ,{{77, 111}, {238, 190, 0}} ,{{78, 111}, {239, 190, 0}} ,{{102, 111}, {7, 191, 0}} ,{{97, 111}, {2, 191, 0}} ,{{99, 111}, {4, 191, 0}} ,{{83, 111}, {244, 190, 0}} ,{{86, 111}, {247, 190, 0}} ,{{84, 111}, {245, 190, 0}} ,{{90, 111}, {251, 190, 0}} ,{{85, 111}, {246, 190, 0}} ,{{89, 111}, {250, 190, 0}} ,{{87, 111}, {248, 190, 0}} ,{{88, 111}, {249, 190, 0}} ,{{91, 111}, {252, 190, 0}} ,{{79, 111}, {240, 190, 0}} ,{{96, 111}, {1, 191, 0}} ,{{81, 111}, {242, 190, 0}} ,{{80, 111}, {241, 190, 0}} ,{{47, 111}, {208, 190, 0}} ,{{64, 111}, {225, 190, 0}} ,{{65, 111}, {226, 190, 0}} ,{{70, 111}, {231, 190, 0}} ,{{54, 111}, {215, 190, 0}} ,{{48, 111}, {209, 190, 0}} ,{{49, 111}, {210, 190, 0}} ,{{50, 111}, {211, 190, 0}} ,{{74, 111}, {235, 190, 0}} ,{{69, 111}, {230, 190, 0}} ,{{71, 111}, {232, 190, 0}} ,{{55, 111}, {216, 190, 0}} ,{{58, 111}, {219, 190, 0}} ,{{56, 111}, {217, 190, 0}} ,{{62, 111}, {223, 190, 0}} ,{{57, 111}, {218, 190, 0}} ,{{61, 111}, {222, 190, 0}} ,{{59, 111}, {220, 190, 0}} ,{{60, 111}, {221, 190, 0}} ,{{63, 111}, {224, 190, 0}} ,{{51, 111}, {212, 190, 0}} ,{{68, 111}, {229, 190, 0}} ,{{53, 111}, {214, 190, 0}} ,{{52, 111}, {213, 190, 0}} ,{{73, 111}, {234, 190, 0}} ,{{66, 111}, {227, 190, 0}} ,{{67, 111}, {228, 190, 0}} ,{{72, 111}, {233, 190, 0}} ,{{101, 111}, {6, 191, 0}} ,{{94, 111}, {255, 190, 0}} ,{{95, 111}, {0, 191, 0}} ,{{100, 111}, {5, 191, 0}} ,{{183, 112}, {88, 192, 0}} ,{{200, 112}, {105, 192, 0}} ,{{201, 112}, {106, 192, 0}} ,{{206, 112}, {111, 192, 0}} ,{{190, 112}, {95, 192, 0}} ,{{184, 112}, {89, 192, 0}} ,{{185, 112}, {90, 192, 0}} ,{{186, 112}, {91, 192, 0}} ,{{210, 112}, {115, 192, 0}} ,{{205, 112}, {110, 192, 0}} ,{{207, 112}, {112, 192, 0}} ,{{191, 112}, {96, 192, 0}} ,{{194, 112}, {99, 192, 0}} ,{{192, 112}, {97, 192, 0}} ,{{198, 112}, {103, 192, 0}} ,{{193, 112}, {98, 192, 0}} ,{{197, 112}, {102, 192, 0}} ,{{195, 112}, {100, 192, 0}} ,{{196, 112}, {101, 192, 0}} ,{{199, 112}, {104, 192, 0}} ,{{187, 112}, {92, 192, 0}} ,{{204, 112}, {109, 192, 0}} ,{{189, 112}, {94, 192, 0}} ,{{188, 112}, {93, 192, 0}} ,{{209, 112}, {114, 192, 0}} ,{{202, 112}, {107, 192, 0}} ,{{203, 112}, {108, 192, 0}} ,{{208, 112}, {113, 192, 0}} ,{{239, 112}, {144, 192, 0}} ,{{0, 113}, {161, 192, 0}} ,{{1, 113}, {162, 192, 0}} ,{{6, 113}, {167, 192, 0}} ,{{246, 112}, {151, 192, 0}} ,{{240, 112}, {145, 192, 0}} ,{{241, 112}, {146, 192, 0}} ,{{242, 112}, {147, 192, 0}} ,{{10, 113}, {171, 192, 0}} ,{{5, 113}, {166, 192, 0}} ,{{7, 113}, {168, 192, 0}} ,{{247, 112}, {152, 192, 0}} ,{{250, 112}, {155, 192, 0}} ,{{248, 112}, {153, 192, 0}} ,{{254, 112}, {159, 192, 0}} ,{{249, 112}, {154, 192, 0}} ,{{253, 112}, {158, 192, 0}} ,{{251, 112}, {156, 192, 0}} ,{{252, 112}, {157, 192, 0}} ,{{255, 112}, {160, 192, 0}} ,{{243, 112}, {148, 192, 0}} ,{{4, 113}, {165, 192, 0}} ,{{245, 112}, {150, 192, 0}} ,{{244, 112}, {149, 192, 0}} ,{{9, 113}, {170, 192, 0}} ,{{2, 113}, {163, 192, 0}} ,{{3, 113}, {164, 192, 0}} ,{{8, 113}, {169, 192, 0}} ,{{159, 111}, {64, 191, 0}} ,{{176, 111}, {81, 191, 0}} ,{{177, 111}, {82, 191, 0}} ,{{182, 111}, {87, 191, 0}} ,{{166, 111}, {71, 191, 0}} ,{{243, 111}, {148, 191, 0}} ,{{4, 112}, {165, 191, 0}} ,{{5, 112}, {166, 191, 0}} ,{{10, 112}, {171, 191, 0}} ,{{250, 111}, {155, 191, 0}} ,{{244, 111}, {149, 191, 0}} ,{{245, 111}, {150, 191, 0}} ,{{246, 111}, {151, 191, 0}} ,{{14, 112}, {175, 191, 0}} ,{{9, 112}, {170, 191, 0}} ,{{11, 112}, {172, 191, 0}} ,{{251, 111}, {156, 191, 0}} ,{{254, 111}, {159, 191, 0}} ,{{252, 111}, {157, 191, 0}} ,{{2, 112}, {163, 191, 0}} ,{{253, 111}, {158, 191, 0}} ,{{1, 112}, {162, 191, 0}} ,{{255, 111}, {160, 191, 0}} ,{{0, 112}, {161, 191, 0}} ,{{3, 112}, {164, 191, 0}} ,{{247, 111}, {152, 191, 0}} ,{{8, 112}, {169, 191, 0}} ,{{249, 111}, {154, 191, 0}} ,{{248, 111}, {153, 191, 0}} ,{{13, 112}, {174, 191, 0}} ,{{6, 112}, {167, 191, 0}} ,{{7, 112}, {168, 191, 0}} ,{{12, 112}, {173, 191, 0}} ,{{160, 111}, {65, 191, 0}} ,{{161, 111}, {66, 191, 0}} ,{{162, 111}, {67, 191, 0}} ,{{186, 111}, {91, 191, 0}} ,{{181, 111}, {86, 191, 0}} ,{{183, 111}, {88, 191, 0}} ,{{167, 111}, {72, 191, 0}} ,{{170, 111}, {75, 191, 0}} ,{{168, 111}, {73, 191, 0}} ,{{174, 111}, {79, 191, 0}} ,{{169, 111}, {74, 191, 0}} ,{{173, 111}, {78, 191, 0}} ,{{171, 111}, {76, 191, 0}} ,{{172, 111}, {77, 191, 0}} ,{{175, 111}, {80, 191, 0}} ,{{163, 111}, {68, 191, 0}} ,{{180, 111}, {85, 191, 0}} ,{{165, 111}, {70, 191, 0}} ,{{164, 111}, {69, 191, 0}} ,{{185, 111}, {90, 191, 0}} ,{{178, 111}, {83, 191, 0}} ,{{179, 111}, {84, 191, 0}} ,{{184, 111}, {89, 191, 0}} ,{{43, 112}, {204, 191, 0}} ,{{60, 112}, {221, 191, 0}} ,{{61, 112}, {222, 191, 0}} ,{{66, 112}, {227, 191, 0}} ,{{50, 112}, {211, 191, 0}} ,{{44, 112}, {205, 191, 0}} ,{{45, 112}, {206, 191, 0}} ,{{46, 112}, {207, 191, 0}} ,{{70, 112}, {231, 191, 0}} ,{{65, 112}, {226, 191, 0}} ,{{67, 112}, {228, 191, 0}} ,{{51, 112}, {212, 191, 0}} ,{{54, 112}, {215, 191, 0}} ,{{52, 112}, {213, 191, 0}} ,{{58, 112}, {219, 191, 0}} ,{{53, 112}, {214, 191, 0}} ,{{57, 112}, {218, 191, 0}} ,{{55, 112}, {216, 191, 0}} ,{{56, 112}, {217, 191, 0}} ,{{59, 112}, {220, 191, 0}} ,{{47, 112}, {208, 191, 0}} ,{{64, 112}, {225, 191, 0}} ,{{49, 112}, {210, 191, 0}} ,{{48, 112}, {209, 191, 0}} ,{{69, 112}, {230, 191, 0}} ,{{62, 112}, {223, 191, 0}} ,{{63, 112}, {224, 191, 0}} ,{{68, 112}, {229, 191, 0}} ,{{187, 111}, {92, 191, 0}} ,{{204, 111}, {109, 191, 0}} ,{{205, 111}, {110, 191, 0}} ,{{210, 111}, {115, 191, 0}} ,{{194, 111}, {99, 191, 0}} ,{{215, 111}, {120, 191, 0}} ,{{232, 111}, {137, 191, 0}} ,{{233, 111}, {138, 191, 0}} ,{{238, 111}, {143, 191, 0}} ,{{222, 111}, {127, 191, 0}} ,{{216, 111}, {121, 191, 0}} ,{{217, 111}, {122, 191, 0}} ,{{218, 111}, {123, 191, 0}} ,{{242, 111}, {147, 191, 0}} ,{{237, 111}, {142, 191, 0}} ,{{239, 111}, {144, 191, 0}} ,{{223, 111}, {128, 191, 0}} ,{{226, 111}, {131, 191, 0}} ,{{224, 111}, {129, 191, 0}} ,{{230, 111}, {135, 191, 0}} ,{{225, 111}, {130, 191, 0}} ,{{229, 111}, {134, 191, 0}} ,{{227, 111}, {132, 191, 0}} ,{{228, 111}, {133, 191, 0}} ,{{231, 111}, {136, 191, 0}} ,{{219, 111}, {124, 191, 0}} ,{{236, 111}, {141, 191, 0}} ,{{221, 111}, {126, 191, 0}} ,{{220, 111}, {125, 191, 0}} ,{{241, 111}, {146, 191, 0}} ,{{234, 111}, {139, 191, 0}} ,{{235, 111}, {140, 191, 0}} ,{{240, 111}, {145, 191, 0}} ,{{188, 111}, {93, 191, 0}} ,{{189, 111}, {94, 191, 0}} ,{{190, 111}, {95, 191, 0}} ,{{214, 111}, {119, 191, 0}} ,{{209, 111}, {114, 191, 0}} ,{{211, 111}, {116, 191, 0}} ,{{195, 111}, {100, 191, 0}} ,{{198, 111}, {103, 191, 0}} ,{{196, 111}, {101, 191, 0}} ,{{202, 111}, {107, 191, 0}} ,{{197, 111}, {102, 191, 0}} ,{{201, 111}, {106, 191, 0}} ,{{199, 111}, {104, 191, 0}} ,{{200, 111}, {105, 191, 0}} ,{{203, 111}, {108, 191, 0}} ,{{191, 111}, {96, 191, 0}} ,{{208, 111}, {113, 191, 0}} ,{{193, 111}, {98, 191, 0}} ,{{192, 111}, {97, 191, 0}} ,{{213, 111}, {118, 191, 0}} ,{{206, 111}, {111, 191, 0}} ,{{207, 111}, {112, 191, 0}} ,{{212, 111}, {117, 191, 0}} ,{{99, 112}, {4, 192, 0}} ,{{116, 112}, {21, 192, 0}} ,{{117, 112}, {22, 192, 0}} ,{{122, 112}, {27, 192, 0}} ,{{106, 112}, {11, 192, 0}} ,{{100, 112}, {5, 192, 0}} ,{{101, 112}, {6, 192, 0}} ,{{102, 112}, {7, 192, 0}} ,{{126, 112}, {31, 192, 0}} ,{{121, 112}, {26, 192, 0}} ,{{123, 112}, {28, 192, 0}} ,{{107, 112}, {12, 192, 0}} ,{{110, 112}, {15, 192, 0}} ,{{108, 112}, {13, 192, 0}} ,{{114, 112}, {19, 192, 0}} ,{{109, 112}, {14, 192, 0}} ,{{113, 112}, {18, 192, 0}} ,{{111, 112}, {16, 192, 0}} ,{{112, 112}, {17, 192, 0}} ,{{115, 112}, {20, 192, 0}} ,{{103, 112}, {8, 192, 0}} ,{{120, 112}, {25, 192, 0}} ,{{105, 112}, {10, 192, 0}} ,{{104, 112}, {9, 192, 0}} ,{{71, 112}, {232, 191, 0}} ,{{88, 112}, {249, 191, 0}} ,{{89, 112}, {250, 191, 0}} ,{{94, 112}, {255, 191, 0}} ,{{78, 112}, {239, 191, 0}} ,{{72, 112}, {233, 191, 0}} ,{{73, 112}, {234, 191, 0}} ,{{74, 112}, {235, 191, 0}} ,{{98, 112}, {3, 192, 0}} ,{{93, 112}, {254, 191, 0}} ,{{95, 112}, {0, 192, 0}} ,{{79, 112}, {240, 191, 0}} ,{{82, 112}, {243, 191, 0}} ,{{80, 112}, {241, 191, 0}} ,{{86, 112}, {247, 191, 0}} ,{{81, 112}, {242, 191, 0}} ,{{85, 112}, {246, 191, 0}} ,{{83, 112}, {244, 191, 0}} ,{{84, 112}, {245, 191, 0}} ,{{87, 112}, {248, 191, 0}} ,{{75, 112}, {236, 191, 0}} ,{{92, 112}, {253, 191, 0}} ,{{77, 112}, {238, 191, 0}} ,{{76, 112}, {237, 191, 0}} ,{{97, 112}, {2, 192, 0}} ,{{90, 112}, {251, 191, 0}} ,{{91, 112}, {252, 191, 0}} ,{{96, 112}, {1, 192, 0}} ,{{125, 112}, {30, 192, 0}} ,{{118, 112}, {23, 192, 0}} ,{{119, 112}, {24, 192, 0}} ,{{124, 112}, {29, 192, 0}} ,{{127, 112}, {32, 192, 0}} ,{{144, 112}, {49, 192, 0}} ,{{145, 112}, {50, 192, 0}} ,{{150, 112}, {55, 192, 0}} ,{{134, 112}, {39, 192, 0}} ,{{128, 112}, {33, 192, 0}} ,{{129, 112}, {34, 192, 0}} ,{{130, 112}, {35, 192, 0}} ,{{154, 112}, {59, 192, 0}} ,{{149, 112}, {54, 192, 0}} ,{{151, 112}, {56, 192, 0}} ,{{135, 112}, {40, 192, 0}} ,{{138, 112}, {43, 192, 0}} ,{{136, 112}, {41, 192, 0}} ,{{142, 112}, {47, 192, 0}} ,{{137, 112}, {42, 192, 0}} ,{{141, 112}, {46, 192, 0}} ,{{139, 112}, {44, 192, 0}} ,{{140, 112}, {45, 192, 0}} ,{{143, 112}, {48, 192, 0}} ,{{131, 112}, {36, 192, 0}} ,{{148, 112}, {53, 192, 0}} ,{{133, 112}, {38, 192, 0}} ,{{132, 112}, {37, 192, 0}} ,{{153, 112}, {58, 192, 0}} ,{{146, 112}, {51, 192, 0}} ,{{147, 112}, {52, 192, 0}} ,{{152, 112}, {57, 192, 0}} ,{{247, 110}, {152, 190, 0}} ,{{8, 111}, {169, 190, 0}} ,{{9, 111}, {170, 190, 0}} ,{{14, 111}, {175, 190, 0}} ,{{254, 110}, {159, 190, 0}} ,{{19, 111}, {180, 190, 0}} ,{{36, 111}, {197, 190, 0}} ,{{37, 111}, {198, 190, 0}} ,{{42, 111}, {203, 190, 0}} ,{{26, 111}, {187, 190, 0}} ,{{20, 111}, {181, 190, 0}} ,{{21, 111}, {182, 190, 0}} ,{{22, 111}, {183, 190, 0}} ,{{46, 111}, {207, 190, 0}} ,{{41, 111}, {202, 190, 0}} ,{{43, 111}, {204, 190, 0}} ,{{27, 111}, {188, 190, 0}} ,{{30, 111}, {191, 190, 0}} ,{{28, 111}, {189, 190, 0}} ,{{34, 111}, {195, 190, 0}} ,{{29, 111}, {190, 190, 0}} ,{{33, 111}, {194, 190, 0}} ,{{31, 111}, {192, 190, 0}} ,{{32, 111}, {193, 190, 0}} ,{{35, 111}, {196, 190, 0}} ,{{23, 111}, {184, 190, 0}} ,{{40, 111}, {201, 190, 0}} ,{{25, 111}, {186, 190, 0}} ,{{24, 111}, {185, 190, 0}} ,{{45, 111}, {206, 190, 0}} ,{{38, 111}, {199, 190, 0}} ,{{39, 111}, {200, 190, 0}} ,{{44, 111}, {205, 190, 0}} ,{{248, 110}, {153, 190, 0}} ,{{249, 110}, {154, 190, 0}} ,{{250, 110}, {155, 190, 0}} ,{{18, 111}, {179, 190, 0}} ,{{13, 111}, {174, 190, 0}} ,{{15, 111}, {176, 190, 0}} ,{{255, 110}, {160, 190, 0}} ,{{2, 111}, {163, 190, 0}} ,{{0, 111}, {161, 190, 0}} ,{{6, 111}, {167, 190, 0}} ,{{1, 111}, {162, 190, 0}} ,{{5, 111}, {166, 190, 0}} ,{{3, 111}, {164, 190, 0}} ,{{4, 111}, {165, 190, 0}} ,{{7, 111}, {168, 190, 0}} ,{{251, 110}, {156, 190, 0}} ,{{12, 111}, {173, 190, 0}} ,{{253, 110}, {158, 190, 0}} ,{{252, 110}, {157, 190, 0}} ,{{17, 111}, {178, 190, 0}} ,{{10, 111}, {171, 190, 0}} ,{{11, 111}, {172, 190, 0}} ,{{16, 111}, {177, 190, 0}} ,{{131, 111}, {36, 191, 0}} ,{{148, 111}, {53, 191, 0}} ,{{149, 111}, {54, 191, 0}} ,{{154, 111}, {59, 191, 0}} ,{{138, 111}, {43, 191, 0}} ,{{132, 111}, {37, 191, 0}} ,{{133, 111}, {38, 191, 0}} ,{{134, 111}, {39, 191, 0}} ,{{158, 111}, {63, 191, 0}} ,{{153, 111}, {58, 191, 0}} ,{{155, 111}, {60, 191, 0}} ,{{139, 111}, {44, 191, 0}} ,{{142, 111}, {47, 191, 0}} ,{{140, 111}, {45, 191, 0}} ,{{146, 111}, {51, 191, 0}} ,{{141, 111}, {46, 191, 0}} ,{{145, 111}, {50, 191, 0}} ,{{143, 111}, {48, 191, 0}} ,{{144, 111}, {49, 191, 0}} ,{{147, 111}, {52, 191, 0}} ,{{135, 111}, {40, 191, 0}} ,{{152, 111}, {57, 191, 0}} ,{{137, 111}, {42, 191, 0}} ,{{136, 111}, {41, 191, 0}} ,{{103, 111}, {8, 191, 0}} ,{{120, 111}, {25, 191, 0}} ,{{121, 111}, {26, 191, 0}} ,{{126, 111}, {31, 191, 0}} ,{{110, 111}, {15, 191, 0}} ,{{104, 111}, {9, 191, 0}} ,{{105, 111}, {10, 191, 0}} ,{{106, 111}, {11, 191, 0}} ,{{130, 111}, {35, 191, 0}} ,{{125, 111}, {30, 191, 0}} ,{{127, 111}, {32, 191, 0}} ,{{111, 111}, {16, 191, 0}} ,{{114, 111}, {19, 191, 0}} ,{{112, 111}, {17, 191, 0}} ,{{118, 111}, {23, 191, 0}} ,{{113, 111}, {18, 191, 0}} ,{{117, 111}, {22, 191, 0}} ,{{115, 111}, {20, 191, 0}} ,{{116, 111}, {21, 191, 0}} ,{{119, 111}, {24, 191, 0}} ,{{107, 111}, {12, 191, 0}} ,{{124, 111}, {29, 191, 0}} ,{{109, 111}, {14, 191, 0}} ,{{108, 111}, {13, 191, 0}} ,{{129, 111}, {34, 191, 0}} ,{{122, 111}, {27, 191, 0}} ,{{123, 111}, {28, 191, 0}} ,{{128, 111}, {33, 191, 0}} ,{{157, 111}, {62, 191, 0}} ,{{150, 111}, {55, 191, 0}} ,{{151, 111}, {56, 191, 0}} ,{{156, 111}, {61, 191, 0}} ,{{211, 112}, {116, 192, 0}} ,{{228, 112}, {133, 192, 0}} ,{{229, 112}, {134, 192, 0}} ,{{234, 112}, {139, 192, 0}} ,{{218, 112}, {123, 192, 0}} ,{{212, 112}, {117, 192, 0}} ,{{213, 112}, {118, 192, 0}} ,{{214, 112}, {119, 192, 0}} ,{{238, 112}, {143, 192, 0}} ,{{233, 112}, {138, 192, 0}} ,{{235, 112}, {140, 192, 0}} ,{{219, 112}, {124, 192, 0}} ,{{222, 112}, {127, 192, 0}} ,{{220, 112}, {125, 192, 0}} ,{{226, 112}, {131, 192, 0}} ,{{221, 112}, {126, 192, 0}} ,{{225, 112}, {130, 192, 0}} ,{{223, 112}, {128, 192, 0}} ,{{224, 112}, {129, 192, 0}} ,{{227, 112}, {132, 192, 0}} ,{{215, 112}, {120, 192, 0}} ,{{232, 112}, {137, 192, 0}} ,{{217, 112}, {122, 192, 0}} ,{{216, 112}, {121, 192, 0}} ,{{237, 112}, {142, 192, 0}} ,{{230, 112}, {135, 192, 0}} ,{{231, 112}, {136, 192, 0}} ,{{236, 112}, {141, 192, 0}} ,{{15, 112}, {176, 191, 0}} ,{{32, 112}, {193, 191, 0}} ,{{33, 112}, {194, 191, 0}} ,{{38, 112}, {199, 191, 0}} ,{{22, 112}, {183, 191, 0}} ,{{16, 112}, {177, 191, 0}} ,{{17, 112}, {178, 191, 0}} ,{{18, 112}, {179, 191, 0}} ,{{42, 112}, {203, 191, 0}} ,{{37, 112}, {198, 191, 0}} ,{{39, 112}, {200, 191, 0}} ,{{23, 112}, {184, 191, 0}} ,{{26, 112}, {187, 191, 0}} ,{{24, 112}, {185, 191, 0}} ,{{30, 112}, {191, 191, 0}} ,{{25, 112}, {186, 191, 0}} ,{{29, 112}, {190, 191, 0}} ,{{27, 112}, {188, 191, 0}} ,{{28, 112}, {189, 191, 0}} ,{{31, 112}, {192, 191, 0}} ,{{19, 112}, {180, 191, 0}} ,{{36, 112}, {197, 191, 0}} ,{{21, 112}, {182, 191, 0}} ,{{20, 112}, {181, 191, 0}} ,{{41, 112}, {202, 191, 0}} ,{{34, 112}, {195, 191, 0}} ,{{35, 112}, {196, 191, 0}} ,{{40, 112}, {201, 191, 0}} ,{{155, 112}, {60, 192, 0}} ,{{172, 112}, {77, 192, 0}} ,{{173, 112}, {78, 192, 0}} ,{{178, 112}, {83, 192, 0}} ,{{162, 112}, {67, 192, 0}} ,{{156, 112}, {61, 192, 0}} ,{{157, 112}, {62, 192, 0}} ,{{158, 112}, {63, 192, 0}} ,{{182, 112}, {87, 192, 0}} ,{{177, 112}, {82, 192, 0}} ,{{179, 112}, {84, 192, 0}} ,{{163, 112}, {68, 192, 0}} ,{{166, 112}, {71, 192, 0}} ,{{164, 112}, {69, 192, 0}} ,{{170, 112}, {75, 192, 0}} ,{{165, 112}, {70, 192, 0}} ,{{169, 112}, {74, 192, 0}} ,{{167, 112}, {72, 192, 0}} ,{{168, 112}, {73, 192, 0}} ,{{171, 112}, {76, 192, 0}} ,{{159, 112}, {64, 192, 0}} ,{{176, 112}, {81, 192, 0}} ,{{161, 112}, {66, 192, 0}} ,{{160, 112}, {65, 192, 0}} ,{{181, 112}, {86, 192, 0}} ,{{174, 112}, {79, 192, 0}} ,{{175, 112}, {80, 192, 0}} ,{{180, 112}, {85, 192, 0}} ,{{255, 108}, {160, 188, 0}} ,{{16, 109}, {177, 188, 0}} ,{{17, 109}, {178, 188, 0}} ,{{22, 109}, {183, 188, 0}} ,{{6, 109}, {167, 188, 0}} ,{{0, 109}, {161, 188, 0}} ,{{1, 109}, {162, 188, 0}} ,{{2, 109}, {163, 188, 0}} ,{{26, 109}, {187, 188, 0}} ,{{21, 109}, {182, 188, 0}} ,{{23, 109}, {184, 188, 0}} ,{{7, 109}, {168, 188, 0}} ,{{10, 109}, {171, 188, 0}} ,{{8, 109}, {169, 188, 0}} ,{{14, 109}, {175, 188, 0}} ,{{9, 109}, {170, 188, 0}} ,{{13, 109}, {174, 188, 0}} ,{{11, 109}, {172, 188, 0}} ,{{12, 109}, {173, 188, 0}} ,{{15, 109}, {176, 188, 0}} ,{{3, 109}, {164, 188, 0}} ,{{20, 109}, {181, 188, 0}} ,{{5, 109}, {166, 188, 0}} ,{{4, 109}, {165, 188, 0}} ,{{227, 108}, {132, 188, 0}} ,{{244, 108}, {149, 188, 0}} ,{{245, 108}, {150, 188, 0}} ,{{250, 108}, {155, 188, 0}} ,{{234, 108}, {139, 188, 0}} ,{{228, 108}, {133, 188, 0}} ,{{229, 108}, {134, 188, 0}} ,{{230, 108}, {135, 188, 0}} ,{{254, 108}, {159, 188, 0}} ,{{249, 108}, {154, 188, 0}} ,{{251, 108}, {156, 188, 0}} ,{{235, 108}, {140, 188, 0}} ,{{238, 108}, {143, 188, 0}} ,{{236, 108}, {141, 188, 0}} ,{{242, 108}, {147, 188, 0}} ,{{237, 108}, {142, 188, 0}} ,{{241, 108}, {146, 188, 0}} ,{{239, 108}, {144, 188, 0}} ,{{240, 108}, {145, 188, 0}} ,{{243, 108}, {148, 188, 0}} ,{{231, 108}, {136, 188, 0}} ,{{248, 108}, {153, 188, 0}} ,{{233, 108}, {138, 188, 0}} ,{{232, 108}, {137, 188, 0}} ,{{253, 108}, {158, 188, 0}} ,{{246, 108}, {151, 188, 0}} ,{{247, 108}, {152, 188, 0}} ,{{252, 108}, {157, 188, 0}} ,{{25, 109}, {186, 188, 0}} ,{{18, 109}, {179, 188, 0}} ,{{19, 109}, {180, 188, 0}} ,{{24, 109}, {185, 188, 0}} ,{{107, 110}, {12, 190, 0}} ,{{124, 110}, {29, 190, 0}} ,{{125, 110}, {30, 190, 0}} ,{{130, 110}, {35, 190, 0}} ,{{114, 110}, {19, 190, 0}} ,{{108, 110}, {13, 190, 0}} ,{{109, 110}, {14, 190, 0}} ,{{110, 110}, {15, 190, 0}} ,{{134, 110}, {39, 190, 0}} ,{{129, 110}, {34, 190, 0}} ,{{131, 110}, {36, 190, 0}} ,{{115, 110}, {20, 190, 0}} ,{{118, 110}, {23, 190, 0}} ,{{116, 110}, {21, 190, 0}} ,{{122, 110}, {27, 190, 0}} ,{{117, 110}, {22, 190, 0}} ,{{121, 110}, {26, 190, 0}} ,{{119, 110}, {24, 190, 0}} ,{{120, 110}, {25, 190, 0}} ,{{123, 110}, {28, 190, 0}} ,{{111, 110}, {16, 190, 0}} ,{{128, 110}, {33, 190, 0}} ,{{113, 110}, {18, 190, 0}} ,{{112, 110}, {17, 190, 0}} ,{{133, 110}, {38, 190, 0}} ,{{126, 110}, {31, 190, 0}} ,{{127, 110}, {32, 190, 0}} ,{{132, 110}, {37, 190, 0}} ,{{163, 110}, {68, 190, 0}} ,{{180, 110}, {85, 190, 0}} ,{{181, 110}, {86, 190, 0}} ,{{186, 110}, {91, 190, 0}} ,{{170, 110}, {75, 190, 0}} ,{{164, 110}, {69, 190, 0}} ,{{165, 110}, {70, 190, 0}} ,{{166, 110}, {71, 190, 0}} ,{{190, 110}, {95, 190, 0}} ,{{185, 110}, {90, 190, 0}} ,{{187, 110}, {92, 190, 0}} ,{{171, 110}, {76, 190, 0}} ,{{174, 110}, {79, 190, 0}} ,{{172, 110}, {77, 190, 0}} ,{{178, 110}, {83, 190, 0}} ,{{173, 110}, {78, 190, 0}} ,{{177, 110}, {82, 190, 0}} ,{{175, 110}, {80, 190, 0}} ,{{176, 110}, {81, 190, 0}} ,{{179, 110}, {84, 190, 0}} ,{{167, 110}, {72, 190, 0}} ,{{184, 110}, {89, 190, 0}} ,{{169, 110}, {74, 190, 0}} ,{{168, 110}, {73, 190, 0}} ,{{189, 110}, {94, 190, 0}} ,{{182, 110}, {87, 190, 0}} ,{{183, 110}, {88, 190, 0}} ,{{188, 110}, {93, 190, 0}} ,{{83, 109}, {244, 188, 0}} ,{{100, 109}, {5, 189, 0}} ,{{101, 109}, {6, 189, 0}} ,{{106, 109}, {11, 189, 0}} ,{{90, 109}, {251, 188, 0}} ,{{167, 109}, {72, 189, 0}} ,{{184, 109}, {89, 189, 0}} ,{{185, 109}, {90, 189, 0}} ,{{190, 109}, {95, 189, 0}} ,{{174, 109}, {79, 189, 0}} ,{{168, 109}, {73, 189, 0}} ,{{169, 109}, {74, 189, 0}} ,{{170, 109}, {75, 189, 0}} ,{{194, 109}, {99, 189, 0}} ,{{189, 109}, {94, 189, 0}} ,{{191, 109}, {96, 189, 0}} ,{{175, 109}, {80, 189, 0}} ,{{178, 109}, {83, 189, 0}} ,{{176, 109}, {81, 189, 0}} ,{{182, 109}, {87, 189, 0}} ,{{177, 109}, {82, 189, 0}} ,{{181, 109}, {86, 189, 0}} ,{{179, 109}, {84, 189, 0}} ,{{180, 109}, {85, 189, 0}} ,{{183, 109}, {88, 189, 0}} ,{{171, 109}, {76, 189, 0}} ,{{188, 109}, {93, 189, 0}} ,{{173, 109}, {78, 189, 0}} ,{{172, 109}, {77, 189, 0}} ,{{193, 109}, {98, 189, 0}} ,{{186, 109}, {91, 189, 0}} ,{{187, 109}, {92, 189, 0}} ,{{192, 109}, {97, 189, 0}} ,{{84, 109}, {245, 188, 0}} ,{{85, 109}, {246, 188, 0}} ,{{86, 109}, {247, 188, 0}} ,{{110, 109}, {15, 189, 0}} ,{{105, 109}, {10, 189, 0}} ,{{107, 109}, {12, 189, 0}} ,{{91, 109}, {252, 188, 0}} ,{{94, 109}, {255, 188, 0}} ,{{92, 109}, {253, 188, 0}} ,{{98, 109}, {3, 189, 0}} ,{{93, 109}, {254, 188, 0}} ,{{97, 109}, {2, 189, 0}} ,{{95, 109}, {0, 189, 0}} ,{{96, 109}, {1, 189, 0}} ,{{99, 109}, {4, 189, 0}} ,{{87, 109}, {248, 188, 0}} ,{{104, 109}, {9, 189, 0}} ,{{89, 109}, {250, 188, 0}} ,{{88, 109}, {249, 188, 0}} ,{{109, 109}, {14, 189, 0}} ,{{102, 109}, {7, 189, 0}} ,{{103, 109}, {8, 189, 0}} ,{{108, 109}, {13, 189, 0}} ,{{223, 109}, {128, 189, 0}} ,{{240, 109}, {145, 189, 0}} ,{{241, 109}, {146, 189, 0}} ,{{246, 109}, {151, 189, 0}} ,{{230, 109}, {135, 189, 0}} ,{{224, 109}, {129, 189, 0}} ,{{225, 109}, {130, 189, 0}} ,{{226, 109}, {131, 189, 0}} ,{{250, 109}, {155, 189, 0}} ,{{245, 109}, {150, 189, 0}} ,{{247, 109}, {152, 189, 0}} ,{{231, 109}, {136, 189, 0}} ,{{234, 109}, {139, 189, 0}} ,{{232, 109}, {137, 189, 0}} ,{{238, 109}, {143, 189, 0}} ,{{233, 109}, {138, 189, 0}} ,{{237, 109}, {142, 189, 0}} ,{{235, 109}, {140, 189, 0}} ,{{236, 109}, {141, 189, 0}} ,{{239, 109}, {144, 189, 0}} ,{{227, 109}, {132, 189, 0}} ,{{244, 109}, {149, 189, 0}} ,{{229, 109}, {134, 189, 0}} ,{{228, 109}, {133, 189, 0}} ,{{249, 109}, {154, 189, 0}} ,{{242, 109}, {147, 189, 0}} ,{{243, 109}, {148, 189, 0}} ,{{248, 109}, {153, 189, 0}} ,{{111, 109}, {16, 189, 0}} ,{{128, 109}, {33, 189, 0}} ,{{129, 109}, {34, 189, 0}} ,{{134, 109}, {39, 189, 0}} ,{{118, 109}, {23, 189, 0}} ,{{139, 109}, {44, 189, 0}} ,{{156, 109}, {61, 189, 0}} ,{{157, 109}, {62, 189, 0}} ,{{162, 109}, {67, 189, 0}} ,{{146, 109}, {51, 189, 0}} ,{{140, 109}, {45, 189, 0}} ,{{141, 109}, {46, 189, 0}} ,{{142, 109}, {47, 189, 0}} ,{{166, 109}, {71, 189, 0}} ,{{161, 109}, {66, 189, 0}} ,{{163, 109}, {68, 189, 0}} ,{{147, 109}, {52, 189, 0}} ,{{150, 109}, {55, 189, 0}} ,{{148, 109}, {53, 189, 0}} ,{{154, 109}, {59, 189, 0}} ,{{149, 109}, {54, 189, 0}} ,{{153, 109}, {58, 189, 0}} ,{{151, 109}, {56, 189, 0}} ,{{152, 109}, {57, 189, 0}} ,{{155, 109}, {60, 189, 0}} ,{{143, 109}, {48, 189, 0}} ,{{160, 109}, {65, 189, 0}} ,{{145, 109}, {50, 189, 0}} ,{{144, 109}, {49, 189, 0}} ,{{165, 109}, {70, 189, 0}} ,{{158, 109}, {63, 189, 0}} ,{{159, 109}, {64, 189, 0}} ,{{164, 109}, {69, 189, 0}} ,{{112, 109}, {17, 189, 0}} ,{{113, 109}, {18, 189, 0}} ,{{114, 109}, {19, 189, 0}} ,{{138, 109}, {43, 189, 0}} ,{{133, 109}, {38, 189, 0}} ,{{135, 109}, {40, 189, 0}} ,{{119, 109}, {24, 189, 0}} ,{{122, 109}, {27, 189, 0}} ,{{120, 109}, {25, 189, 0}} ,{{126, 109}, {31, 189, 0}} ,{{121, 109}, {26, 189, 0}} ,{{125, 109}, {30, 189, 0}} ,{{123, 109}, {28, 189, 0}} ,{{124, 109}, {29, 189, 0}} ,{{127, 109}, {32, 189, 0}} ,{{115, 109}, {20, 189, 0}} ,{{132, 109}, {37, 189, 0}} ,{{117, 109}, {22, 189, 0}} ,{{116, 109}, {21, 189, 0}} ,{{137, 109}, {42, 189, 0}} ,{{130, 109}, {35, 189, 0}} ,{{131, 109}, {36, 189, 0}} ,{{136, 109}, {41, 189, 0}} ,{{23, 110}, {184, 189, 0}} ,{{40, 110}, {201, 189, 0}} ,{{41, 110}, {202, 189, 0}} ,{{46, 110}, {207, 189, 0}} ,{{30, 110}, {191, 189, 0}} ,{{24, 110}, {185, 189, 0}} ,{{25, 110}, {186, 189, 0}} ,{{26, 110}, {187, 189, 0}} ,{{50, 110}, {211, 189, 0}} ,{{45, 110}, {206, 189, 0}} ,{{47, 110}, {208, 189, 0}} ,{{31, 110}, {192, 189, 0}} ,{{34, 110}, {195, 189, 0}} ,{{32, 110}, {193, 189, 0}} ,{{38, 110}, {199, 189, 0}} ,{{33, 110}, {194, 189, 0}} ,{{37, 110}, {198, 189, 0}} ,{{35, 110}, {196, 189, 0}} ,{{36, 110}, {197, 189, 0}} ,{{39, 110}, {200, 189, 0}} ,{{27, 110}, {188, 189, 0}} ,{{44, 110}, {205, 189, 0}} ,{{29, 110}, {190, 189, 0}} ,{{28, 110}, {189, 189, 0}} ,{{251, 109}, {156, 189, 0}} ,{{12, 110}, {173, 189, 0}} ,{{13, 110}, {174, 189, 0}} ,{{18, 110}, {179, 189, 0}} ,{{2, 110}, {163, 189, 0}} ,{{252, 109}, {157, 189, 0}} ,{{253, 109}, {158, 189, 0}} ,{{254, 109}, {159, 189, 0}} ,{{22, 110}, {183, 189, 0}} ,{{17, 110}, {178, 189, 0}} ,{{19, 110}, {180, 189, 0}} ,{{3, 110}, {164, 189, 0}} ,{{6, 110}, {167, 189, 0}} ,{{4, 110}, {165, 189, 0}} ,{{10, 110}, {171, 189, 0}} ,{{5, 110}, {166, 189, 0}} ,{{9, 110}, {170, 189, 0}} ,{{7, 110}, {168, 189, 0}} ,{{8, 110}, {169, 189, 0}} ,{{11, 110}, {172, 189, 0}} ,{{255, 109}, {160, 189, 0}} ,{{16, 110}, {177, 189, 0}} ,{{1, 110}, {162, 189, 0}} ,{{0, 110}, {161, 189, 0}} ,{{21, 110}, {182, 189, 0}} ,{{14, 110}, {175, 189, 0}} ,{{15, 110}, {176, 189, 0}} ,{{20, 110}, {181, 189, 0}} ,{{49, 110}, {210, 189, 0}} ,{{42, 110}, {203, 189, 0}} ,{{43, 110}, {204, 189, 0}} ,{{48, 110}, {209, 189, 0}} ,{{51, 110}, {212, 189, 0}} ,{{68, 110}, {229, 189, 0}} ,{{69, 110}, {230, 189, 0}} ,{{74, 110}, {235, 189, 0}} ,{{58, 110}, {219, 189, 0}} ,{{52, 110}, {213, 189, 0}} ,{{53, 110}, {214, 189, 0}} ,{{54, 110}, {215, 189, 0}} ,{{78, 110}, {239, 189, 0}} ,{{73, 110}, {234, 189, 0}} ,{{75, 110}, {236, 189, 0}} ,{{59, 110}, {220, 189, 0}} ,{{62, 110}, {223, 189, 0}} ,{{60, 110}, {221, 189, 0}} ,{{66, 110}, {227, 189, 0}} ,{{61, 110}, {222, 189, 0}} ,{{65, 110}, {226, 189, 0}} ,{{63, 110}, {224, 189, 0}} ,{{64, 110}, {225, 189, 0}} ,{{67, 110}, {228, 189, 0}} ,{{55, 110}, {216, 189, 0}} ,{{72, 110}, {233, 189, 0}} ,{{57, 110}, {218, 189, 0}} ,{{56, 110}, {217, 189, 0}} ,{{77, 110}, {238, 189, 0}} ,{{70, 110}, {231, 189, 0}} ,{{71, 110}, {232, 189, 0}} ,{{76, 110}, {237, 189, 0}} ,{{171, 108}, {76, 188, 0}} ,{{188, 108}, {93, 188, 0}} ,{{189, 108}, {94, 188, 0}} ,{{194, 108}, {99, 188, 0}} ,{{178, 108}, {83, 188, 0}} ,{{199, 108}, {104, 188, 0}} ,{{216, 108}, {121, 188, 0}} ,{{217, 108}, {122, 188, 0}} ,{{222, 108}, {127, 188, 0}} ,{{206, 108}, {111, 188, 0}} ,{{200, 108}, {105, 188, 0}} ,{{201, 108}, {106, 188, 0}} ,{{202, 108}, {107, 188, 0}} ,{{226, 108}, {131, 188, 0}} ,{{221, 108}, {126, 188, 0}} ,{{223, 108}, {128, 188, 0}} ,{{207, 108}, {112, 188, 0}} ,{{210, 108}, {115, 188, 0}} ,{{208, 108}, {113, 188, 0}} ,{{214, 108}, {119, 188, 0}} ,{{209, 108}, {114, 188, 0}} ,{{213, 108}, {118, 188, 0}} ,{{211, 108}, {116, 188, 0}} ,{{212, 108}, {117, 188, 0}} ,{{215, 108}, {120, 188, 0}} ,{{203, 108}, {108, 188, 0}} ,{{220, 108}, {125, 188, 0}} ,{{205, 108}, {110, 188, 0}} ,{{204, 108}, {109, 188, 0}} ,{{225, 108}, {130, 188, 0}} ,{{218, 108}, {123, 188, 0}} ,{{219, 108}, {124, 188, 0}} ,{{224, 108}, {129, 188, 0}} ,{{172, 108}, {77, 188, 0}} ,{{173, 108}, {78, 188, 0}} ,{{174, 108}, {79, 188, 0}} ,{{198, 108}, {103, 188, 0}} ,{{193, 108}, {98, 188, 0}} ,{{195, 108}, {100, 188, 0}} ,{{179, 108}, {84, 188, 0}} ,{{182, 108}, {87, 188, 0}} ,{{180, 108}, {85, 188, 0}} ,{{186, 108}, {91, 188, 0}} ,{{181, 108}, {86, 188, 0}} ,{{185, 108}, {90, 188, 0}} ,{{183, 108}, {88, 188, 0}} ,{{184, 108}, {89, 188, 0}} ,{{187, 108}, {92, 188, 0}} ,{{175, 108}, {80, 188, 0}} ,{{192, 108}, {97, 188, 0}} ,{{177, 108}, {82, 188, 0}} ,{{176, 108}, {81, 188, 0}} ,{{197, 108}, {102, 188, 0}} ,{{190, 108}, {95, 188, 0}} ,{{191, 108}, {96, 188, 0}} ,{{196, 108}, {101, 188, 0}} ,{{55, 109}, {216, 188, 0}} ,{{72, 109}, {233, 188, 0}} ,{{73, 109}, {234, 188, 0}} ,{{78, 109}, {239, 188, 0}} ,{{62, 109}, {223, 188, 0}} ,{{56, 109}, {217, 188, 0}} ,{{57, 109}, {218, 188, 0}} ,{{58, 109}, {219, 188, 0}} ,{{82, 109}, {243, 188, 0}} ,{{77, 109}, {238, 188, 0}} ,{{79, 109}, {240, 188, 0}} ,{{63, 109}, {224, 188, 0}} ,{{66, 109}, {227, 188, 0}} ,{{64, 109}, {225, 188, 0}} ,{{70, 109}, {231, 188, 0}} ,{{65, 109}, {226, 188, 0}} ,{{69, 109}, {230, 188, 0}} ,{{67, 109}, {228, 188, 0}} ,{{68, 109}, {229, 188, 0}} ,{{71, 109}, {232, 188, 0}} ,{{59, 109}, {220, 188, 0}} ,{{76, 109}, {237, 188, 0}} ,{{61, 109}, {222, 188, 0}} ,{{60, 109}, {221, 188, 0}} ,{{27, 109}, {188, 188, 0}} ,{{44, 109}, {205, 188, 0}} ,{{45, 109}, {206, 188, 0}} ,{{50, 109}, {211, 188, 0}} ,{{34, 109}, {195, 188, 0}} ,{{28, 109}, {189, 188, 0}} ,{{29, 109}, {190, 188, 0}} ,{{30, 109}, {191, 188, 0}} ,{{54, 109}, {215, 188, 0}} ,{{49, 109}, {210, 188, 0}} ,{{51, 109}, {212, 188, 0}} ,{{35, 109}, {196, 188, 0}} ,{{38, 109}, {199, 188, 0}} ,{{36, 109}, {197, 188, 0}} ,{{42, 109}, {203, 188, 0}} ,{{37, 109}, {198, 188, 0}} ,{{41, 109}, {202, 188, 0}} ,{{39, 109}, {200, 188, 0}} ,{{40, 109}, {201, 188, 0}} ,{{43, 109}, {204, 188, 0}} ,{{31, 109}, {192, 188, 0}} ,{{48, 109}, {209, 188, 0}} ,{{33, 109}, {194, 188, 0}} ,{{32, 109}, {193, 188, 0}} ,{{53, 109}, {214, 188, 0}} ,{{46, 109}, {207, 188, 0}} ,{{47, 109}, {208, 188, 0}} ,{{52, 109}, {213, 188, 0}} ,{{81, 109}, {242, 188, 0}} ,{{74, 109}, {235, 188, 0}} ,{{75, 109}, {236, 188, 0}} ,{{80, 109}, {241, 188, 0}} ,{{135, 110}, {40, 190, 0}} ,{{152, 110}, {57, 190, 0}} ,{{153, 110}, {58, 190, 0}} ,{{158, 110}, {63, 190, 0}} ,{{142, 110}, {47, 190, 0}} ,{{136, 110}, {41, 190, 0}} ,{{137, 110}, {42, 190, 0}} ,{{138, 110}, {43, 190, 0}} ,{{162, 110}, {67, 190, 0}} ,{{157, 110}, {62, 190, 0}} ,{{159, 110}, {64, 190, 0}} ,{{143, 110}, {48, 190, 0}} ,{{146, 110}, {51, 190, 0}} ,{{144, 110}, {49, 190, 0}} ,{{150, 110}, {55, 190, 0}} ,{{145, 110}, {50, 190, 0}} ,{{149, 110}, {54, 190, 0}} ,{{147, 110}, {52, 190, 0}} ,{{148, 110}, {53, 190, 0}} ,{{151, 110}, {56, 190, 0}} ,{{139, 110}, {44, 190, 0}} ,{{156, 110}, {61, 190, 0}} ,{{141, 110}, {46, 190, 0}} ,{{140, 110}, {45, 190, 0}} ,{{161, 110}, {66, 190, 0}} ,{{154, 110}, {59, 190, 0}} ,{{155, 110}, {60, 190, 0}} ,{{160, 110}, {65, 190, 0}} ,{{195, 109}, {100, 189, 0}} ,{{212, 109}, {117, 189, 0}} ,{{213, 109}, {118, 189, 0}} ,{{218, 109}, {123, 189, 0}} ,{{202, 109}, {107, 189, 0}} ,{{196, 109}, {101, 189, 0}} ,{{197, 109}, {102, 189, 0}} ,{{198, 109}, {103, 189, 0}} ,{{222, 109}, {127, 189, 0}} ,{{217, 109}, {122, 189, 0}} ,{{219, 109}, {124, 189, 0}} ,{{203, 109}, {108, 189, 0}} ,{{206, 109}, {111, 189, 0}} ,{{204, 109}, {109, 189, 0}} ,{{210, 109}, {115, 189, 0}} ,{{205, 109}, {110, 189, 0}} ,{{209, 109}, {114, 189, 0}} ,{{207, 109}, {112, 189, 0}} ,{{208, 109}, {113, 189, 0}} ,{{211, 109}, {116, 189, 0}} ,{{199, 109}, {104, 189, 0}} ,{{216, 109}, {121, 189, 0}} ,{{201, 109}, {106, 189, 0}} ,{{200, 109}, {105, 189, 0}} ,{{221, 109}, {126, 189, 0}} ,{{214, 109}, {119, 189, 0}} ,{{215, 109}, {120, 189, 0}} ,{{220, 109}, {125, 189, 0}} ,{{79, 110}, {240, 189, 0}} ,{{96, 110}, {1, 190, 0}} ,{{97, 110}, {2, 190, 0}} ,{{102, 110}, {7, 190, 0}} ,{{86, 110}, {247, 189, 0}} ,{{80, 110}, {241, 189, 0}} ,{{81, 110}, {242, 189, 0}} ,{{82, 110}, {243, 189, 0}} ,{{106, 110}, {11, 190, 0}} ,{{101, 110}, {6, 190, 0}} ,{{103, 110}, {8, 190, 0}} ,{{87, 110}, {248, 189, 0}} ,{{90, 110}, {251, 189, 0}} ,{{88, 110}, {249, 189, 0}} ,{{94, 110}, {255, 189, 0}} ,{{89, 110}, {250, 189, 0}} ,{{93, 110}, {254, 189, 0}} ,{{91, 110}, {252, 189, 0}} ,{{92, 110}, {253, 189, 0}} ,{{95, 110}, {0, 190, 0}} ,{{83, 110}, {244, 189, 0}} ,{{100, 110}, {5, 190, 0}} ,{{85, 110}, {246, 189, 0}} ,{{84, 110}, {245, 189, 0}} ,{{105, 110}, {10, 190, 0}} ,{{98, 110}, {3, 190, 0}} ,{{99, 110}, {4, 190, 0}} ,{{104, 110}, {9, 190, 0}} ,{{135, 124}, {40, 204, 0}} ,{{152, 124}, {57, 204, 0}} ,{{153, 124}, {58, 204, 0}} ,{{158, 124}, {63, 204, 0}} ,{{142, 124}, {47, 204, 0}} ,{{163, 124}, {68, 204, 0}} ,{{180, 124}, {85, 204, 0}} ,{{181, 124}, {86, 204, 0}} ,{{186, 124}, {91, 204, 0}} ,{{170, 124}, {75, 204, 0}} ,{{164, 124}, {69, 204, 0}} ,{{165, 124}, {70, 204, 0}} ,{{166, 124}, {71, 204, 0}} ,{{190, 124}, {95, 204, 0}} ,{{185, 124}, {90, 204, 0}} ,{{187, 124}, {92, 204, 0}} ,{{171, 124}, {76, 204, 0}} ,{{174, 124}, {79, 204, 0}} ,{{172, 124}, {77, 204, 0}} ,{{178, 124}, {83, 204, 0}} ,{{173, 124}, {78, 204, 0}} ,{{177, 124}, {82, 204, 0}} ,{{175, 124}, {80, 204, 0}} ,{{176, 124}, {81, 204, 0}} ,{{179, 124}, {84, 204, 0}} ,{{167, 124}, {72, 204, 0}} ,{{184, 124}, {89, 204, 0}} ,{{169, 124}, {74, 204, 0}} ,{{168, 124}, {73, 204, 0}} ,{{189, 124}, {94, 204, 0}} ,{{182, 124}, {87, 204, 0}} ,{{183, 124}, {88, 204, 0}} ,{{188, 124}, {93, 204, 0}} ,{{136, 124}, {41, 204, 0}} ,{{137, 124}, {42, 204, 0}} ,{{138, 124}, {43, 204, 0}} ,{{162, 124}, {67, 204, 0}} ,{{157, 124}, {62, 204, 0}} ,{{159, 124}, {64, 204, 0}} ,{{143, 124}, {48, 204, 0}} ,{{146, 124}, {51, 204, 0}} ,{{144, 124}, {49, 204, 0}} ,{{150, 124}, {55, 204, 0}} ,{{145, 124}, {50, 204, 0}} ,{{149, 124}, {54, 204, 0}} ,{{147, 124}, {52, 204, 0}} ,{{148, 124}, {53, 204, 0}} ,{{151, 124}, {56, 204, 0}} ,{{139, 124}, {44, 204, 0}} ,{{156, 124}, {61, 204, 0}} ,{{141, 124}, {46, 204, 0}} ,{{140, 124}, {45, 204, 0}} ,{{161, 124}, {66, 204, 0}} ,{{154, 124}, {59, 204, 0}} ,{{155, 124}, {60, 204, 0}} ,{{160, 124}, {65, 204, 0}} ,{{19, 125}, {180, 204, 0}} ,{{36, 125}, {197, 204, 0}} ,{{37, 125}, {198, 204, 0}} ,{{42, 125}, {203, 204, 0}} ,{{26, 125}, {187, 204, 0}} ,{{20, 125}, {181, 204, 0}} ,{{21, 125}, {182, 204, 0}} ,{{22, 125}, {183, 204, 0}} ,{{46, 125}, {207, 204, 0}} ,{{41, 125}, {202, 204, 0}} ,{{43, 125}, {204, 204, 0}} ,{{27, 125}, {188, 204, 0}} ,{{30, 125}, {191, 204, 0}} ,{{28, 125}, {189, 204, 0}} ,{{34, 125}, {195, 204, 0}} ,{{29, 125}, {190, 204, 0}} ,{{33, 125}, {194, 204, 0}} ,{{31, 125}, {192, 204, 0}} ,{{32, 125}, {193, 204, 0}} ,{{35, 125}, {196, 204, 0}} ,{{23, 125}, {184, 204, 0}} ,{{40, 125}, {201, 204, 0}} ,{{25, 125}, {186, 204, 0}} ,{{24, 125}, {185, 204, 0}} ,{{247, 124}, {152, 204, 0}} ,{{8, 125}, {169, 204, 0}} ,{{9, 125}, {170, 204, 0}} ,{{14, 125}, {175, 204, 0}} ,{{254, 124}, {159, 204, 0}} ,{{248, 124}, {153, 204, 0}} ,{{249, 124}, {154, 204, 0}} ,{{250, 124}, {155, 204, 0}} ,{{18, 125}, {179, 204, 0}} ,{{13, 125}, {174, 204, 0}} ,{{15, 125}, {176, 204, 0}} ,{{255, 124}, {160, 204, 0}} ,{{2, 125}, {163, 204, 0}} ,{{0, 125}, {161, 204, 0}} ,{{6, 125}, {167, 204, 0}} ,{{1, 125}, {162, 204, 0}} ,{{5, 125}, {166, 204, 0}} ,{{3, 125}, {164, 204, 0}} ,{{4, 125}, {165, 204, 0}} ,{{7, 125}, {168, 204, 0}} ,{{251, 124}, {156, 204, 0}} ,{{12, 125}, {173, 204, 0}} ,{{253, 124}, {158, 204, 0}} ,{{252, 124}, {157, 204, 0}} ,{{17, 125}, {178, 204, 0}} ,{{10, 125}, {171, 204, 0}} ,{{11, 125}, {172, 204, 0}} ,{{16, 125}, {177, 204, 0}} ,{{45, 125}, {206, 204, 0}} ,{{38, 125}, {199, 204, 0}} ,{{39, 125}, {200, 204, 0}} ,{{44, 125}, {205, 204, 0}} ,{{127, 126}, {32, 206, 0}} ,{{144, 126}, {49, 206, 0}} ,{{145, 126}, {50, 206, 0}} ,{{150, 126}, {55, 206, 0}} ,{{134, 126}, {39, 206, 0}} ,{{128, 126}, {33, 206, 0}} ,{{129, 126}, {34, 206, 0}} ,{{130, 126}, {35, 206, 0}} ,{{154, 126}, {59, 206, 0}} ,{{149, 126}, {54, 206, 0}} ,{{151, 126}, {56, 206, 0}} ,{{135, 126}, {40, 206, 0}} ,{{138, 126}, {43, 206, 0}} ,{{136, 126}, {41, 206, 0}} ,{{142, 126}, {47, 206, 0}} ,{{137, 126}, {42, 206, 0}} ,{{141, 126}, {46, 206, 0}} ,{{139, 126}, {44, 206, 0}} ,{{140, 126}, {45, 206, 0}} ,{{143, 126}, {48, 206, 0}} ,{{131, 126}, {36, 206, 0}} ,{{148, 126}, {53, 206, 0}} ,{{133, 126}, {38, 206, 0}} ,{{132, 126}, {37, 206, 0}} ,{{153, 126}, {58, 206, 0}} ,{{146, 126}, {51, 206, 0}} ,{{147, 126}, {52, 206, 0}} ,{{152, 126}, {57, 206, 0}} ,{{183, 126}, {88, 206, 0}} ,{{200, 126}, {105, 206, 0}} ,{{201, 126}, {106, 206, 0}} ,{{206, 126}, {111, 206, 0}} ,{{190, 126}, {95, 206, 0}} ,{{184, 126}, {89, 206, 0}} ,{{185, 126}, {90, 206, 0}} ,{{186, 126}, {91, 206, 0}} ,{{210, 126}, {115, 206, 0}} ,{{205, 126}, {110, 206, 0}} ,{{207, 126}, {112, 206, 0}} ,{{191, 126}, {96, 206, 0}} ,{{194, 126}, {99, 206, 0}} ,{{192, 126}, {97, 206, 0}} ,{{198, 126}, {103, 206, 0}} ,{{193, 126}, {98, 206, 0}} ,{{197, 126}, {102, 206, 0}} ,{{195, 126}, {100, 206, 0}} ,{{196, 126}, {101, 206, 0}} ,{{199, 126}, {104, 206, 0}} ,{{187, 126}, {92, 206, 0}} ,{{204, 126}, {109, 206, 0}} ,{{189, 126}, {94, 206, 0}} ,{{188, 126}, {93, 206, 0}} ,{{209, 126}, {114, 206, 0}} ,{{202, 126}, {107, 206, 0}} ,{{203, 126}, {108, 206, 0}} ,{{208, 126}, {113, 206, 0}} ,{{103, 125}, {8, 205, 0}} ,{{120, 125}, {25, 205, 0}} ,{{121, 125}, {26, 205, 0}} ,{{126, 125}, {31, 205, 0}} ,{{110, 125}, {15, 205, 0}} ,{{187, 125}, {92, 205, 0}} ,{{204, 125}, {109, 205, 0}} ,{{205, 125}, {110, 205, 0}} ,{{210, 125}, {115, 205, 0}} ,{{194, 125}, {99, 205, 0}} ,{{188, 125}, {93, 205, 0}} ,{{189, 125}, {94, 205, 0}} ,{{190, 125}, {95, 205, 0}} ,{{214, 125}, {119, 205, 0}} ,{{209, 125}, {114, 205, 0}} ,{{211, 125}, {116, 205, 0}} ,{{195, 125}, {100, 205, 0}} ,{{198, 125}, {103, 205, 0}} ,{{196, 125}, {101, 205, 0}} ,{{202, 125}, {107, 205, 0}} ,{{197, 125}, {102, 205, 0}} ,{{201, 125}, {106, 205, 0}} ,{{199, 125}, {104, 205, 0}} ,{{200, 125}, {105, 205, 0}} ,{{203, 125}, {108, 205, 0}} ,{{191, 125}, {96, 205, 0}} ,{{208, 125}, {113, 205, 0}} ,{{193, 125}, {98, 205, 0}} ,{{192, 125}, {97, 205, 0}} ,{{213, 125}, {118, 205, 0}} ,{{206, 125}, {111, 205, 0}} ,{{207, 125}, {112, 205, 0}} ,{{212, 125}, {117, 205, 0}} ,{{104, 125}, {9, 205, 0}} ,{{105, 125}, {10, 205, 0}} ,{{106, 125}, {11, 205, 0}} ,{{130, 125}, {35, 205, 0}} ,{{125, 125}, {30, 205, 0}} ,{{127, 125}, {32, 205, 0}} ,{{111, 125}, {16, 205, 0}} ,{{114, 125}, {19, 205, 0}} ,{{112, 125}, {17, 205, 0}} ,{{118, 125}, {23, 205, 0}} ,{{113, 125}, {18, 205, 0}} ,{{117, 125}, {22, 205, 0}} ,{{115, 125}, {20, 205, 0}} ,{{116, 125}, {21, 205, 0}} ,{{119, 125}, {24, 205, 0}} ,{{107, 125}, {12, 205, 0}} ,{{124, 125}, {29, 205, 0}} ,{{109, 125}, {14, 205, 0}} ,{{108, 125}, {13, 205, 0}} ,{{129, 125}, {34, 205, 0}} ,{{122, 125}, {27, 205, 0}} ,{{123, 125}, {28, 205, 0}} ,{{128, 125}, {33, 205, 0}} ,{{243, 125}, {148, 205, 0}} ,{{4, 126}, {165, 205, 0}} ,{{5, 126}, {166, 205, 0}} ,{{10, 126}, {171, 205, 0}} ,{{250, 125}, {155, 205, 0}} ,{{244, 125}, {149, 205, 0}} ,{{245, 125}, {150, 205, 0}} ,{{246, 125}, {151, 205, 0}} ,{{14, 126}, {175, 205, 0}} ,{{9, 126}, {170, 205, 0}} ,{{11, 126}, {172, 205, 0}} ,{{251, 125}, {156, 205, 0}} ,{{254, 125}, {159, 205, 0}} ,{{252, 125}, {157, 205, 0}} ,{{2, 126}, {163, 205, 0}} ,{{253, 125}, {158, 205, 0}} ,{{1, 126}, {162, 205, 0}} ,{{255, 125}, {160, 205, 0}} ,{{0, 126}, {161, 205, 0}} ,{{3, 126}, {164, 205, 0}} ,{{247, 125}, {152, 205, 0}} ,{{8, 126}, {169, 205, 0}} ,{{249, 125}, {154, 205, 0}} ,{{248, 125}, {153, 205, 0}} ,{{13, 126}, {174, 205, 0}} ,{{6, 126}, {167, 205, 0}} ,{{7, 126}, {168, 205, 0}} ,{{12, 126}, {173, 205, 0}} ,{{131, 125}, {36, 205, 0}} ,{{148, 125}, {53, 205, 0}} ,{{149, 125}, {54, 205, 0}} ,{{154, 125}, {59, 205, 0}} ,{{138, 125}, {43, 205, 0}} ,{{159, 125}, {64, 205, 0}} ,{{176, 125}, {81, 205, 0}} ,{{177, 125}, {82, 205, 0}} ,{{182, 125}, {87, 205, 0}} ,{{166, 125}, {71, 205, 0}} ,{{160, 125}, {65, 205, 0}} ,{{161, 125}, {66, 205, 0}} ,{{162, 125}, {67, 205, 0}} ,{{186, 125}, {91, 205, 0}} ,{{181, 125}, {86, 205, 0}} ,{{183, 125}, {88, 205, 0}} ,{{167, 125}, {72, 205, 0}} ,{{170, 125}, {75, 205, 0}} ,{{168, 125}, {73, 205, 0}} ,{{174, 125}, {79, 205, 0}} ,{{169, 125}, {74, 205, 0}} ,{{173, 125}, {78, 205, 0}} ,{{171, 125}, {76, 205, 0}} ,{{172, 125}, {77, 205, 0}} ,{{175, 125}, {80, 205, 0}} ,{{163, 125}, {68, 205, 0}} ,{{180, 125}, {85, 205, 0}} ,{{165, 125}, {70, 205, 0}} ,{{164, 125}, {69, 205, 0}} ,{{185, 125}, {90, 205, 0}} ,{{178, 125}, {83, 205, 0}} ,{{179, 125}, {84, 205, 0}} ,{{184, 125}, {89, 205, 0}} ,{{132, 125}, {37, 205, 0}} ,{{133, 125}, {38, 205, 0}} ,{{134, 125}, {39, 205, 0}} ,{{158, 125}, {63, 205, 0}} ,{{153, 125}, {58, 205, 0}} ,{{155, 125}, {60, 205, 0}} ,{{139, 125}, {44, 205, 0}} ,{{142, 125}, {47, 205, 0}} ,{{140, 125}, {45, 205, 0}} ,{{146, 125}, {51, 205, 0}} ,{{141, 125}, {46, 205, 0}} ,{{145, 125}, {50, 205, 0}} ,{{143, 125}, {48, 205, 0}} ,{{144, 125}, {49, 205, 0}} ,{{147, 125}, {52, 205, 0}} ,{{135, 125}, {40, 205, 0}} ,{{152, 125}, {57, 205, 0}} ,{{137, 125}, {42, 205, 0}} ,{{136, 125}, {41, 205, 0}} ,{{157, 125}, {62, 205, 0}} ,{{150, 125}, {55, 205, 0}} ,{{151, 125}, {56, 205, 0}} ,{{156, 125}, {61, 205, 0}} ,{{43, 126}, {204, 205, 0}} ,{{60, 126}, {221, 205, 0}} ,{{61, 126}, {222, 205, 0}} ,{{66, 126}, {227, 205, 0}} ,{{50, 126}, {211, 205, 0}} ,{{44, 126}, {205, 205, 0}} ,{{45, 126}, {206, 205, 0}} ,{{46, 126}, {207, 205, 0}} ,{{70, 126}, {231, 205, 0}} ,{{65, 126}, {226, 205, 0}} ,{{67, 126}, {228, 205, 0}} ,{{51, 126}, {212, 205, 0}} ,{{54, 126}, {215, 205, 0}} ,{{52, 126}, {213, 205, 0}} ,{{58, 126}, {219, 205, 0}} ,{{53, 126}, {214, 205, 0}} ,{{57, 126}, {218, 205, 0}} ,{{55, 126}, {216, 205, 0}} ,{{56, 126}, {217, 205, 0}} ,{{59, 126}, {220, 205, 0}} ,{{47, 126}, {208, 205, 0}} ,{{64, 126}, {225, 205, 0}} ,{{49, 126}, {210, 205, 0}} ,{{48, 126}, {209, 205, 0}} ,{{15, 126}, {176, 205, 0}} ,{{32, 126}, {193, 205, 0}} ,{{33, 126}, {194, 205, 0}} ,{{38, 126}, {199, 205, 0}} ,{{22, 126}, {183, 205, 0}} ,{{16, 126}, {177, 205, 0}} ,{{17, 126}, {178, 205, 0}} ,{{18, 126}, {179, 205, 0}} ,{{42, 126}, {203, 205, 0}} ,{{37, 126}, {198, 205, 0}} ,{{39, 126}, {200, 205, 0}} ,{{23, 126}, {184, 205, 0}} ,{{26, 126}, {187, 205, 0}} ,{{24, 126}, {185, 205, 0}} ,{{30, 126}, {191, 205, 0}} ,{{25, 126}, {186, 205, 0}} ,{{29, 126}, {190, 205, 0}} ,{{27, 126}, {188, 205, 0}} ,{{28, 126}, {189, 205, 0}} ,{{31, 126}, {192, 205, 0}} ,{{19, 126}, {180, 205, 0}} ,{{36, 126}, {197, 205, 0}} ,{{21, 126}, {182, 205, 0}} ,{{20, 126}, {181, 205, 0}} ,{{41, 126}, {202, 205, 0}} ,{{34, 126}, {195, 205, 0}} ,{{35, 126}, {196, 205, 0}} ,{{40, 126}, {201, 205, 0}} ,{{69, 126}, {230, 205, 0}} ,{{62, 126}, {223, 205, 0}} ,{{63, 126}, {224, 205, 0}} ,{{68, 126}, {229, 205, 0}} ,{{71, 126}, {232, 205, 0}} ,{{88, 126}, {249, 205, 0}} ,{{89, 126}, {250, 205, 0}} ,{{94, 126}, {255, 205, 0}} ,{{78, 126}, {239, 205, 0}} ,{{72, 126}, {233, 205, 0}} ,{{73, 126}, {234, 205, 0}} ,{{74, 126}, {235, 205, 0}} ,{{98, 126}, {3, 206, 0}} ,{{93, 126}, {254, 205, 0}} ,{{95, 126}, {0, 206, 0}} ,{{79, 126}, {240, 205, 0}} ,{{82, 126}, {243, 205, 0}} ,{{80, 126}, {241, 205, 0}} ,{{86, 126}, {247, 205, 0}} ,{{81, 126}, {242, 205, 0}} ,{{85, 126}, {246, 205, 0}} ,{{83, 126}, {244, 205, 0}} ,{{84, 126}, {245, 205, 0}} ,{{87, 126}, {248, 205, 0}} ,{{75, 126}, {236, 205, 0}} ,{{92, 126}, {253, 205, 0}} ,{{77, 126}, {238, 205, 0}} ,{{76, 126}, {237, 205, 0}} ,{{97, 126}, {2, 206, 0}} ,{{90, 126}, {251, 205, 0}} ,{{91, 126}, {252, 205, 0}} ,{{96, 126}, {1, 206, 0}} ,{{191, 124}, {96, 204, 0}} ,{{208, 124}, {113, 204, 0}} ,{{209, 124}, {114, 204, 0}} ,{{214, 124}, {119, 204, 0}} ,{{198, 124}, {103, 204, 0}} ,{{219, 124}, {124, 204, 0}} ,{{236, 124}, {141, 204, 0}} ,{{237, 124}, {142, 204, 0}} ,{{242, 124}, {147, 204, 0}} ,{{226, 124}, {131, 204, 0}} ,{{220, 124}, {125, 204, 0}} ,{{221, 124}, {126, 204, 0}} ,{{222, 124}, {127, 204, 0}} ,{{246, 124}, {151, 204, 0}} ,{{241, 124}, {146, 204, 0}} ,{{243, 124}, {148, 204, 0}} ,{{227, 124}, {132, 204, 0}} ,{{230, 124}, {135, 204, 0}} ,{{228, 124}, {133, 204, 0}} ,{{234, 124}, {139, 204, 0}} ,{{229, 124}, {134, 204, 0}} ,{{233, 124}, {138, 204, 0}} ,{{231, 124}, {136, 204, 0}} ,{{232, 124}, {137, 204, 0}} ,{{235, 124}, {140, 204, 0}} ,{{223, 124}, {128, 204, 0}} ,{{240, 124}, {145, 204, 0}} ,{{225, 124}, {130, 204, 0}} ,{{224, 124}, {129, 204, 0}} ,{{245, 124}, {150, 204, 0}} ,{{238, 124}, {143, 204, 0}} ,{{239, 124}, {144, 204, 0}} ,{{244, 124}, {149, 204, 0}} ,{{192, 124}, {97, 204, 0}} ,{{193, 124}, {98, 204, 0}} ,{{194, 124}, {99, 204, 0}} ,{{218, 124}, {123, 204, 0}} ,{{213, 124}, {118, 204, 0}} ,{{215, 124}, {120, 204, 0}} ,{{199, 124}, {104, 204, 0}} ,{{202, 124}, {107, 204, 0}} ,{{200, 124}, {105, 204, 0}} ,{{206, 124}, {111, 204, 0}} ,{{201, 124}, {106, 204, 0}} ,{{205, 124}, {110, 204, 0}} ,{{203, 124}, {108, 204, 0}} ,{{204, 124}, {109, 204, 0}} ,{{207, 124}, {112, 204, 0}} ,{{195, 124}, {100, 204, 0}} ,{{212, 124}, {117, 204, 0}} ,{{197, 124}, {102, 204, 0}} ,{{196, 124}, {101, 204, 0}} ,{{217, 124}, {122, 204, 0}} ,{{210, 124}, {115, 204, 0}} ,{{211, 124}, {116, 204, 0}} ,{{216, 124}, {121, 204, 0}} ,{{75, 125}, {236, 204, 0}} ,{{92, 125}, {253, 204, 0}} ,{{93, 125}, {254, 204, 0}} ,{{98, 125}, {3, 205, 0}} ,{{82, 125}, {243, 204, 0}} ,{{76, 125}, {237, 204, 0}} ,{{77, 125}, {238, 204, 0}} ,{{78, 125}, {239, 204, 0}} ,{{102, 125}, {7, 205, 0}} ,{{97, 125}, {2, 205, 0}} ,{{99, 125}, {4, 205, 0}} ,{{83, 125}, {244, 204, 0}} ,{{86, 125}, {247, 204, 0}} ,{{84, 125}, {245, 204, 0}} ,{{90, 125}, {251, 204, 0}} ,{{85, 125}, {246, 204, 0}} ,{{89, 125}, {250, 204, 0}} ,{{87, 125}, {248, 204, 0}} ,{{88, 125}, {249, 204, 0}} ,{{91, 125}, {252, 204, 0}} ,{{79, 125}, {240, 204, 0}} ,{{96, 125}, {1, 205, 0}} ,{{81, 125}, {242, 204, 0}} ,{{80, 125}, {241, 204, 0}} ,{{47, 125}, {208, 204, 0}} ,{{64, 125}, {225, 204, 0}} ,{{65, 125}, {226, 204, 0}} ,{{70, 125}, {231, 204, 0}} ,{{54, 125}, {215, 204, 0}} ,{{48, 125}, {209, 204, 0}} ,{{49, 125}, {210, 204, 0}} ,{{50, 125}, {211, 204, 0}} ,{{74, 125}, {235, 204, 0}} ,{{69, 125}, {230, 204, 0}} ,{{71, 125}, {232, 204, 0}} ,{{55, 125}, {216, 204, 0}} ,{{58, 125}, {219, 204, 0}} ,{{56, 125}, {217, 204, 0}} ,{{62, 125}, {223, 204, 0}} ,{{57, 125}, {218, 204, 0}} ,{{61, 125}, {222, 204, 0}} ,{{59, 125}, {220, 204, 0}} ,{{60, 125}, {221, 204, 0}} ,{{63, 125}, {224, 204, 0}} ,{{51, 125}, {212, 204, 0}} ,{{68, 125}, {229, 204, 0}} ,{{53, 125}, {214, 204, 0}} ,{{52, 125}, {213, 204, 0}} ,{{73, 125}, {234, 204, 0}} ,{{66, 125}, {227, 204, 0}} ,{{67, 125}, {228, 204, 0}} ,{{72, 125}, {233, 204, 0}} ,{{101, 125}, {6, 205, 0}} ,{{94, 125}, {255, 204, 0}} ,{{95, 125}, {0, 205, 0}} ,{{100, 125}, {5, 205, 0}} ,{{155, 126}, {60, 206, 0}} ,{{172, 126}, {77, 206, 0}} ,{{173, 126}, {78, 206, 0}} ,{{178, 126}, {83, 206, 0}} ,{{162, 126}, {67, 206, 0}} ,{{156, 126}, {61, 206, 0}} ,{{157, 126}, {62, 206, 0}} ,{{158, 126}, {63, 206, 0}} ,{{182, 126}, {87, 206, 0}} ,{{177, 126}, {82, 206, 0}} ,{{179, 126}, {84, 206, 0}} ,{{163, 126}, {68, 206, 0}} ,{{166, 126}, {71, 206, 0}} ,{{164, 126}, {69, 206, 0}} ,{{170, 126}, {75, 206, 0}} ,{{165, 126}, {70, 206, 0}} ,{{169, 126}, {74, 206, 0}} ,{{167, 126}, {72, 206, 0}} ,{{168, 126}, {73, 206, 0}} ,{{171, 126}, {76, 206, 0}} ,{{159, 126}, {64, 206, 0}} ,{{176, 126}, {81, 206, 0}} ,{{161, 126}, {66, 206, 0}} ,{{160, 126}, {65, 206, 0}} ,{{181, 126}, {86, 206, 0}} ,{{174, 126}, {79, 206, 0}} ,{{175, 126}, {80, 206, 0}} ,{{180, 126}, {85, 206, 0}} ,{{215, 125}, {120, 205, 0}} ,{{232, 125}, {137, 205, 0}} ,{{233, 125}, {138, 205, 0}} ,{{238, 125}, {143, 205, 0}} ,{{222, 125}, {127, 205, 0}} ,{{216, 125}, {121, 205, 0}} ,{{217, 125}, {122, 205, 0}} ,{{218, 125}, {123, 205, 0}} ,{{242, 125}, {147, 205, 0}} ,{{237, 125}, {142, 205, 0}} ,{{239, 125}, {144, 205, 0}} ,{{223, 125}, {128, 205, 0}} ,{{226, 125}, {131, 205, 0}} ,{{224, 125}, {129, 205, 0}} ,{{230, 125}, {135, 205, 0}} ,{{225, 125}, {130, 205, 0}} ,{{229, 125}, {134, 205, 0}} ,{{227, 125}, {132, 205, 0}} ,{{228, 125}, {133, 205, 0}} ,{{231, 125}, {136, 205, 0}} ,{{219, 125}, {124, 205, 0}} ,{{236, 125}, {141, 205, 0}} ,{{221, 125}, {126, 205, 0}} ,{{220, 125}, {125, 205, 0}} ,{{241, 125}, {146, 205, 0}} ,{{234, 125}, {139, 205, 0}} ,{{235, 125}, {140, 205, 0}} ,{{240, 125}, {145, 205, 0}} ,{{99, 126}, {4, 206, 0}} ,{{116, 126}, {21, 206, 0}} ,{{117, 126}, {22, 206, 0}} ,{{122, 126}, {27, 206, 0}} ,{{106, 126}, {11, 206, 0}} ,{{100, 126}, {5, 206, 0}} ,{{101, 126}, {6, 206, 0}} ,{{102, 126}, {7, 206, 0}} ,{{126, 126}, {31, 206, 0}} ,{{121, 126}, {26, 206, 0}} ,{{123, 126}, {28, 206, 0}} ,{{107, 126}, {12, 206, 0}} ,{{110, 126}, {15, 206, 0}} ,{{108, 126}, {13, 206, 0}} ,{{114, 126}, {19, 206, 0}} ,{{109, 126}, {14, 206, 0}} ,{{113, 126}, {18, 206, 0}} ,{{111, 126}, {16, 206, 0}} ,{{112, 126}, {17, 206, 0}} ,{{115, 126}, {20, 206, 0}} ,{{103, 126}, {8, 206, 0}} ,{{120, 126}, {25, 206, 0}} ,{{105, 126}, {10, 206, 0}} ,{{104, 126}, {9, 206, 0}} ,{{125, 126}, {30, 206, 0}} ,{{118, 126}, {23, 206, 0}} ,{{119, 126}, {24, 206, 0}} ,{{124, 126}, {29, 206, 0}} ,{{67, 99}, {228, 178, 0}} ,{{84, 99}, {245, 178, 0}} ,{{85, 99}, {246, 178, 0}} ,{{90, 99}, {251, 178, 0}} ,{{74, 99}, {235, 178, 0}} ,{{95, 99}, {0, 179, 0}} ,{{112, 99}, {17, 179, 0}} ,{{113, 99}, {18, 179, 0}} ,{{118, 99}, {23, 179, 0}} ,{{102, 99}, {7, 179, 0}} ,{{96, 99}, {1, 179, 0}} ,{{97, 99}, {2, 179, 0}} ,{{98, 99}, {3, 179, 0}} ,{{122, 99}, {27, 179, 0}} ,{{117, 99}, {22, 179, 0}} ,{{119, 99}, {24, 179, 0}} ,{{103, 99}, {8, 179, 0}} ,{{106, 99}, {11, 179, 0}} ,{{104, 99}, {9, 179, 0}} ,{{110, 99}, {15, 179, 0}} ,{{105, 99}, {10, 179, 0}} ,{{109, 99}, {14, 179, 0}} ,{{107, 99}, {12, 179, 0}} ,{{108, 99}, {13, 179, 0}} ,{{111, 99}, {16, 179, 0}} ,{{99, 99}, {4, 179, 0}} ,{{116, 99}, {21, 179, 0}} ,{{101, 99}, {6, 179, 0}} ,{{100, 99}, {5, 179, 0}} ,{{121, 99}, {26, 179, 0}} ,{{114, 99}, {19, 179, 0}} ,{{115, 99}, {20, 179, 0}} ,{{120, 99}, {25, 179, 0}} ,{{68, 99}, {229, 178, 0}} ,{{69, 99}, {230, 178, 0}} ,{{70, 99}, {231, 178, 0}} ,{{94, 99}, {255, 178, 0}} ,{{89, 99}, {250, 178, 0}} ,{{91, 99}, {252, 178, 0}} ,{{75, 99}, {236, 178, 0}} ,{{78, 99}, {239, 178, 0}} ,{{76, 99}, {237, 178, 0}} ,{{82, 99}, {243, 178, 0}} ,{{77, 99}, {238, 178, 0}} ,{{81, 99}, {242, 178, 0}} ,{{79, 99}, {240, 178, 0}} ,{{80, 99}, {241, 178, 0}} ,{{83, 99}, {244, 178, 0}} ,{{71, 99}, {232, 178, 0}} ,{{88, 99}, {249, 178, 0}} ,{{73, 99}, {234, 178, 0}} ,{{72, 99}, {233, 178, 0}} ,{{93, 99}, {254, 178, 0}} ,{{86, 99}, {247, 178, 0}} ,{{87, 99}, {248, 178, 0}} ,{{92, 99}, {253, 178, 0}} ,{{143, 101}, {48, 181, 0}} ,{{160, 101}, {65, 181, 0}} ,{{161, 101}, {66, 181, 0}} ,{{166, 101}, {71, 181, 0}} ,{{150, 101}, {55, 181, 0}} ,{{171, 101}, {76, 181, 0}} ,{{188, 101}, {93, 181, 0}} ,{{189, 101}, {94, 181, 0}} ,{{194, 101}, {99, 181, 0}} ,{{178, 101}, {83, 181, 0}} ,{{172, 101}, {77, 181, 0}} ,{{173, 101}, {78, 181, 0}} ,{{174, 101}, {79, 181, 0}} ,{{198, 101}, {103, 181, 0}} ,{{193, 101}, {98, 181, 0}} ,{{195, 101}, {100, 181, 0}} ,{{179, 101}, {84, 181, 0}} ,{{182, 101}, {87, 181, 0}} ,{{180, 101}, {85, 181, 0}} ,{{186, 101}, {91, 181, 0}} ,{{181, 101}, {86, 181, 0}} ,{{185, 101}, {90, 181, 0}} ,{{183, 101}, {88, 181, 0}} ,{{184, 101}, {89, 181, 0}} ,{{187, 101}, {92, 181, 0}} ,{{175, 101}, {80, 181, 0}} ,{{192, 101}, {97, 181, 0}} ,{{177, 101}, {82, 181, 0}} ,{{176, 101}, {81, 181, 0}} ,{{197, 101}, {102, 181, 0}} ,{{190, 101}, {95, 181, 0}} ,{{191, 101}, {96, 181, 0}} ,{{196, 101}, {101, 181, 0}} ,{{144, 101}, {49, 181, 0}} ,{{145, 101}, {50, 181, 0}} ,{{146, 101}, {51, 181, 0}} ,{{170, 101}, {75, 181, 0}} ,{{165, 101}, {70, 181, 0}} ,{{167, 101}, {72, 181, 0}} ,{{151, 101}, {56, 181, 0}} ,{{154, 101}, {59, 181, 0}} ,{{152, 101}, {57, 181, 0}} ,{{158, 101}, {63, 181, 0}} ,{{153, 101}, {58, 181, 0}} ,{{157, 101}, {62, 181, 0}} ,{{155, 101}, {60, 181, 0}} ,{{156, 101}, {61, 181, 0}} ,{{159, 101}, {64, 181, 0}} ,{{147, 101}, {52, 181, 0}} ,{{164, 101}, {69, 181, 0}} ,{{149, 101}, {54, 181, 0}} ,{{148, 101}, {53, 181, 0}} ,{{169, 101}, {74, 181, 0}} ,{{162, 101}, {67, 181, 0}} ,{{163, 101}, {68, 181, 0}} ,{{168, 101}, {73, 181, 0}} ,{{27, 102}, {188, 181, 0}} ,{{44, 102}, {205, 181, 0}} ,{{45, 102}, {206, 181, 0}} ,{{50, 102}, {211, 181, 0}} ,{{34, 102}, {195, 181, 0}} ,{{28, 102}, {189, 181, 0}} ,{{29, 102}, {190, 181, 0}} ,{{30, 102}, {191, 181, 0}} ,{{54, 102}, {215, 181, 0}} ,{{49, 102}, {210, 181, 0}} ,{{51, 102}, {212, 181, 0}} ,{{35, 102}, {196, 181, 0}} ,{{38, 102}, {199, 181, 0}} ,{{36, 102}, {197, 181, 0}} ,{{42, 102}, {203, 181, 0}} ,{{37, 102}, {198, 181, 0}} ,{{41, 102}, {202, 181, 0}} ,{{39, 102}, {200, 181, 0}} ,{{40, 102}, {201, 181, 0}} ,{{43, 102}, {204, 181, 0}} ,{{31, 102}, {192, 181, 0}} ,{{48, 102}, {209, 181, 0}} ,{{33, 102}, {194, 181, 0}} ,{{32, 102}, {193, 181, 0}} ,{{255, 101}, {160, 181, 0}} ,{{16, 102}, {177, 181, 0}} ,{{17, 102}, {178, 181, 0}} ,{{22, 102}, {183, 181, 0}} ,{{6, 102}, {167, 181, 0}} ,{{0, 102}, {161, 181, 0}} ,{{1, 102}, {162, 181, 0}} ,{{2, 102}, {163, 181, 0}} ,{{26, 102}, {187, 181, 0}} ,{{21, 102}, {182, 181, 0}} ,{{23, 102}, {184, 181, 0}} ,{{7, 102}, {168, 181, 0}} ,{{10, 102}, {171, 181, 0}} ,{{8, 102}, {169, 181, 0}} ,{{14, 102}, {175, 181, 0}} ,{{9, 102}, {170, 181, 0}} ,{{13, 102}, {174, 181, 0}} ,{{11, 102}, {172, 181, 0}} ,{{12, 102}, {173, 181, 0}} ,{{15, 102}, {176, 181, 0}} ,{{3, 102}, {164, 181, 0}} ,{{20, 102}, {181, 181, 0}} ,{{5, 102}, {166, 181, 0}} ,{{4, 102}, {165, 181, 0}} ,{{25, 102}, {186, 181, 0}} ,{{18, 102}, {179, 181, 0}} ,{{19, 102}, {180, 181, 0}} ,{{24, 102}, {185, 181, 0}} ,{{53, 102}, {214, 181, 0}} ,{{46, 102}, {207, 181, 0}} ,{{47, 102}, {208, 181, 0}} ,{{52, 102}, {213, 181, 0}} ,{{135, 103}, {40, 183, 0}} ,{{152, 103}, {57, 183, 0}} ,{{153, 103}, {58, 183, 0}} ,{{158, 103}, {63, 183, 0}} ,{{142, 103}, {47, 183, 0}} ,{{136, 103}, {41, 183, 0}} ,{{137, 103}, {42, 183, 0}} ,{{138, 103}, {43, 183, 0}} ,{{162, 103}, {67, 183, 0}} ,{{157, 103}, {62, 183, 0}} ,{{159, 103}, {64, 183, 0}} ,{{143, 103}, {48, 183, 0}} ,{{146, 103}, {51, 183, 0}} ,{{144, 103}, {49, 183, 0}} ,{{150, 103}, {55, 183, 0}} ,{{145, 103}, {50, 183, 0}} ,{{149, 103}, {54, 183, 0}} ,{{147, 103}, {52, 183, 0}} ,{{148, 103}, {53, 183, 0}} ,{{151, 103}, {56, 183, 0}} ,{{139, 103}, {44, 183, 0}} ,{{156, 103}, {61, 183, 0}} ,{{141, 103}, {46, 183, 0}} ,{{140, 103}, {45, 183, 0}} ,{{161, 103}, {66, 183, 0}} ,{{154, 103}, {59, 183, 0}} ,{{155, 103}, {60, 183, 0}} ,{{160, 103}, {65, 183, 0}} ,{{191, 103}, {96, 183, 0}} ,{{208, 103}, {113, 183, 0}} ,{{209, 103}, {114, 183, 0}} ,{{214, 103}, {119, 183, 0}} ,{{198, 103}, {103, 183, 0}} ,{{192, 103}, {97, 183, 0}} ,{{193, 103}, {98, 183, 0}} ,{{194, 103}, {99, 183, 0}} ,{{218, 103}, {123, 183, 0}} ,{{213, 103}, {118, 183, 0}} ,{{215, 103}, {120, 183, 0}} ,{{199, 103}, {104, 183, 0}} ,{{202, 103}, {107, 183, 0}} ,{{200, 103}, {105, 183, 0}} ,{{206, 103}, {111, 183, 0}} ,{{201, 103}, {106, 183, 0}} ,{{205, 103}, {110, 183, 0}} ,{{203, 103}, {108, 183, 0}} ,{{204, 103}, {109, 183, 0}} ,{{207, 103}, {112, 183, 0}} ,{{195, 103}, {100, 183, 0}} ,{{212, 103}, {117, 183, 0}} ,{{197, 103}, {102, 183, 0}} ,{{196, 103}, {101, 183, 0}} ,{{217, 103}, {122, 183, 0}} ,{{210, 103}, {115, 183, 0}} ,{{211, 103}, {116, 183, 0}} ,{{216, 103}, {121, 183, 0}} ,{{111, 102}, {16, 182, 0}} ,{{128, 102}, {33, 182, 0}} ,{{129, 102}, {34, 182, 0}} ,{{134, 102}, {39, 182, 0}} ,{{118, 102}, {23, 182, 0}} ,{{195, 102}, {100, 182, 0}} ,{{212, 102}, {117, 182, 0}} ,{{213, 102}, {118, 182, 0}} ,{{218, 102}, {123, 182, 0}} ,{{202, 102}, {107, 182, 0}} ,{{196, 102}, {101, 182, 0}} ,{{197, 102}, {102, 182, 0}} ,{{198, 102}, {103, 182, 0}} ,{{222, 102}, {127, 182, 0}} ,{{217, 102}, {122, 182, 0}} ,{{219, 102}, {124, 182, 0}} ,{{203, 102}, {108, 182, 0}} ,{{206, 102}, {111, 182, 0}} ,{{204, 102}, {109, 182, 0}} ,{{210, 102}, {115, 182, 0}} ,{{205, 102}, {110, 182, 0}} ,{{209, 102}, {114, 182, 0}} ,{{207, 102}, {112, 182, 0}} ,{{208, 102}, {113, 182, 0}} ,{{211, 102}, {116, 182, 0}} ,{{199, 102}, {104, 182, 0}} ,{{216, 102}, {121, 182, 0}} ,{{201, 102}, {106, 182, 0}} ,{{200, 102}, {105, 182, 0}} ,{{221, 102}, {126, 182, 0}} ,{{214, 102}, {119, 182, 0}} ,{{215, 102}, {120, 182, 0}} ,{{220, 102}, {125, 182, 0}} ,{{112, 102}, {17, 182, 0}} ,{{113, 102}, {18, 182, 0}} ,{{114, 102}, {19, 182, 0}} ,{{138, 102}, {43, 182, 0}} ,{{133, 102}, {38, 182, 0}} ,{{135, 102}, {40, 182, 0}} ,{{119, 102}, {24, 182, 0}} ,{{122, 102}, {27, 182, 0}} ,{{120, 102}, {25, 182, 0}} ,{{126, 102}, {31, 182, 0}} ,{{121, 102}, {26, 182, 0}} ,{{125, 102}, {30, 182, 0}} ,{{123, 102}, {28, 182, 0}} ,{{124, 102}, {29, 182, 0}} ,{{127, 102}, {32, 182, 0}} ,{{115, 102}, {20, 182, 0}} ,{{132, 102}, {37, 182, 0}} ,{{117, 102}, {22, 182, 0}} ,{{116, 102}, {21, 182, 0}} ,{{137, 102}, {42, 182, 0}} ,{{130, 102}, {35, 182, 0}} ,{{131, 102}, {36, 182, 0}} ,{{136, 102}, {41, 182, 0}} ,{{251, 102}, {156, 182, 0}} ,{{12, 103}, {173, 182, 0}} ,{{13, 103}, {174, 182, 0}} ,{{18, 103}, {179, 182, 0}} ,{{2, 103}, {163, 182, 0}} ,{{252, 102}, {157, 182, 0}} ,{{253, 102}, {158, 182, 0}} ,{{254, 102}, {159, 182, 0}} ,{{22, 103}, {183, 182, 0}} ,{{17, 103}, {178, 182, 0}} ,{{19, 103}, {180, 182, 0}} ,{{3, 103}, {164, 182, 0}} ,{{6, 103}, {167, 182, 0}} ,{{4, 103}, {165, 182, 0}} ,{{10, 103}, {171, 182, 0}} ,{{5, 103}, {166, 182, 0}} ,{{9, 103}, {170, 182, 0}} ,{{7, 103}, {168, 182, 0}} ,{{8, 103}, {169, 182, 0}} ,{{11, 103}, {172, 182, 0}} ,{{255, 102}, {160, 182, 0}} ,{{16, 103}, {177, 182, 0}} ,{{1, 103}, {162, 182, 0}} ,{{0, 103}, {161, 182, 0}} ,{{21, 103}, {182, 182, 0}} ,{{14, 103}, {175, 182, 0}} ,{{15, 103}, {176, 182, 0}} ,{{20, 103}, {181, 182, 0}} ,{{139, 102}, {44, 182, 0}} ,{{156, 102}, {61, 182, 0}} ,{{157, 102}, {62, 182, 0}} ,{{162, 102}, {67, 182, 0}} ,{{146, 102}, {51, 182, 0}} ,{{167, 102}, {72, 182, 0}} ,{{184, 102}, {89, 182, 0}} ,{{185, 102}, {90, 182, 0}} ,{{190, 102}, {95, 182, 0}} ,{{174, 102}, {79, 182, 0}} ,{{168, 102}, {73, 182, 0}} ,{{169, 102}, {74, 182, 0}} ,{{170, 102}, {75, 182, 0}} ,{{194, 102}, {99, 182, 0}} ,{{189, 102}, {94, 182, 0}} ,{{191, 102}, {96, 182, 0}} ,{{175, 102}, {80, 182, 0}} ,{{178, 102}, {83, 182, 0}} ,{{176, 102}, {81, 182, 0}} ,{{182, 102}, {87, 182, 0}} ,{{177, 102}, {82, 182, 0}} ,{{181, 102}, {86, 182, 0}} ,{{179, 102}, {84, 182, 0}} ,{{180, 102}, {85, 182, 0}} ,{{183, 102}, {88, 182, 0}} ,{{171, 102}, {76, 182, 0}} ,{{188, 102}, {93, 182, 0}} ,{{173, 102}, {78, 182, 0}} ,{{172, 102}, {77, 182, 0}} ,{{193, 102}, {98, 182, 0}} ,{{186, 102}, {91, 182, 0}} ,{{187, 102}, {92, 182, 0}} ,{{192, 102}, {97, 182, 0}} ,{{140, 102}, {45, 182, 0}} ,{{141, 102}, {46, 182, 0}} ,{{142, 102}, {47, 182, 0}} ,{{166, 102}, {71, 182, 0}} ,{{161, 102}, {66, 182, 0}} ,{{163, 102}, {68, 182, 0}} ,{{147, 102}, {52, 182, 0}} ,{{150, 102}, {55, 182, 0}} ,{{148, 102}, {53, 182, 0}} ,{{154, 102}, {59, 182, 0}} ,{{149, 102}, {54, 182, 0}} ,{{153, 102}, {58, 182, 0}} ,{{151, 102}, {56, 182, 0}} ,{{152, 102}, {57, 182, 0}} ,{{155, 102}, {60, 182, 0}} ,{{143, 102}, {48, 182, 0}} ,{{160, 102}, {65, 182, 0}} ,{{145, 102}, {50, 182, 0}} ,{{144, 102}, {49, 182, 0}} ,{{165, 102}, {70, 182, 0}} ,{{158, 102}, {63, 182, 0}} ,{{159, 102}, {64, 182, 0}} ,{{164, 102}, {69, 182, 0}} ,{{51, 103}, {212, 182, 0}} ,{{68, 103}, {229, 182, 0}} ,{{69, 103}, {230, 182, 0}} ,{{74, 103}, {235, 182, 0}} ,{{58, 103}, {219, 182, 0}} ,{{52, 103}, {213, 182, 0}} ,{{53, 103}, {214, 182, 0}} ,{{54, 103}, {215, 182, 0}} ,{{78, 103}, {239, 182, 0}} ,{{73, 103}, {234, 182, 0}} ,{{75, 103}, {236, 182, 0}} ,{{59, 103}, {220, 182, 0}} ,{{62, 103}, {223, 182, 0}} ,{{60, 103}, {221, 182, 0}} ,{{66, 103}, {227, 182, 0}} ,{{61, 103}, {222, 182, 0}} ,{{65, 103}, {226, 182, 0}} ,{{63, 103}, {224, 182, 0}} ,{{64, 103}, {225, 182, 0}} ,{{67, 103}, {228, 182, 0}} ,{{55, 103}, {216, 182, 0}} ,{{72, 103}, {233, 182, 0}} ,{{57, 103}, {218, 182, 0}} ,{{56, 103}, {217, 182, 0}} ,{{23, 103}, {184, 182, 0}} ,{{40, 103}, {201, 182, 0}} ,{{41, 103}, {202, 182, 0}} ,{{46, 103}, {207, 182, 0}} ,{{30, 103}, {191, 182, 0}} ,{{24, 103}, {185, 182, 0}} ,{{25, 103}, {186, 182, 0}} ,{{26, 103}, {187, 182, 0}} ,{{50, 103}, {211, 182, 0}} ,{{45, 103}, {206, 182, 0}} ,{{47, 103}, {208, 182, 0}} ,{{31, 103}, {192, 182, 0}} ,{{34, 103}, {195, 182, 0}} ,{{32, 103}, {193, 182, 0}} ,{{38, 103}, {199, 182, 0}} ,{{33, 103}, {194, 182, 0}} ,{{37, 103}, {198, 182, 0}} ,{{35, 103}, {196, 182, 0}} ,{{36, 103}, {197, 182, 0}} ,{{39, 103}, {200, 182, 0}} ,{{27, 103}, {188, 182, 0}} ,{{44, 103}, {205, 182, 0}} ,{{29, 103}, {190, 182, 0}} ,{{28, 103}, {189, 182, 0}} ,{{49, 103}, {210, 182, 0}} ,{{42, 103}, {203, 182, 0}} ,{{43, 103}, {204, 182, 0}} ,{{48, 103}, {209, 182, 0}} ,{{77, 103}, {238, 182, 0}} ,{{70, 103}, {231, 182, 0}} ,{{71, 103}, {232, 182, 0}} ,{{76, 103}, {237, 182, 0}} ,{{79, 103}, {240, 182, 0}} ,{{96, 103}, {1, 183, 0}} ,{{97, 103}, {2, 183, 0}} ,{{102, 103}, {7, 183, 0}} ,{{86, 103}, {247, 182, 0}} ,{{80, 103}, {241, 182, 0}} ,{{81, 103}, {242, 182, 0}} ,{{82, 103}, {243, 182, 0}} ,{{106, 103}, {11, 183, 0}} ,{{101, 103}, {6, 183, 0}} ,{{103, 103}, {8, 183, 0}} ,{{87, 103}, {248, 182, 0}} ,{{90, 103}, {251, 182, 0}} ,{{88, 103}, {249, 182, 0}} ,{{94, 103}, {255, 182, 0}} ,{{89, 103}, {250, 182, 0}} ,{{93, 103}, {254, 182, 0}} ,{{91, 103}, {252, 182, 0}} ,{{92, 103}, {253, 182, 0}} ,{{95, 103}, {0, 183, 0}} ,{{83, 103}, {244, 182, 0}} ,{{100, 103}, {5, 183, 0}} ,{{85, 103}, {246, 182, 0}} ,{{84, 103}, {245, 182, 0}} ,{{105, 103}, {10, 183, 0}} ,{{98, 103}, {3, 183, 0}} ,{{99, 103}, {4, 183, 0}} ,{{104, 103}, {9, 183, 0}} ,{{199, 101}, {104, 181, 0}} ,{{216, 101}, {121, 181, 0}} ,{{217, 101}, {122, 181, 0}} ,{{222, 101}, {127, 181, 0}} ,{{206, 101}, {111, 181, 0}} ,{{227, 101}, {132, 181, 0}} ,{{244, 101}, {149, 181, 0}} ,{{245, 101}, {150, 181, 0}} ,{{250, 101}, {155, 181, 0}} ,{{234, 101}, {139, 181, 0}} ,{{228, 101}, {133, 181, 0}} ,{{229, 101}, {134, 181, 0}} ,{{230, 101}, {135, 181, 0}} ,{{254, 101}, {159, 181, 0}} ,{{249, 101}, {154, 181, 0}} ,{{251, 101}, {156, 181, 0}} ,{{235, 101}, {140, 181, 0}} ,{{238, 101}, {143, 181, 0}} ,{{236, 101}, {141, 181, 0}} ,{{242, 101}, {147, 181, 0}} ,{{237, 101}, {142, 181, 0}} ,{{241, 101}, {146, 181, 0}} ,{{239, 101}, {144, 181, 0}} ,{{240, 101}, {145, 181, 0}} ,{{243, 101}, {148, 181, 0}} ,{{231, 101}, {136, 181, 0}} ,{{248, 101}, {153, 181, 0}} ,{{233, 101}, {138, 181, 0}} ,{{232, 101}, {137, 181, 0}} ,{{253, 101}, {158, 181, 0}} ,{{246, 101}, {151, 181, 0}} ,{{247, 101}, {152, 181, 0}} ,{{252, 101}, {157, 181, 0}} ,{{200, 101}, {105, 181, 0}} ,{{201, 101}, {106, 181, 0}} ,{{202, 101}, {107, 181, 0}} ,{{226, 101}, {131, 181, 0}} ,{{221, 101}, {126, 181, 0}} ,{{223, 101}, {128, 181, 0}} ,{{207, 101}, {112, 181, 0}} ,{{210, 101}, {115, 181, 0}} ,{{208, 101}, {113, 181, 0}} ,{{214, 101}, {119, 181, 0}} ,{{209, 101}, {114, 181, 0}} ,{{213, 101}, {118, 181, 0}} ,{{211, 101}, {116, 181, 0}} ,{{212, 101}, {117, 181, 0}} ,{{215, 101}, {120, 181, 0}} ,{{203, 101}, {108, 181, 0}} ,{{220, 101}, {125, 181, 0}} ,{{205, 101}, {110, 181, 0}} ,{{204, 101}, {109, 181, 0}} ,{{225, 101}, {130, 181, 0}} ,{{218, 101}, {123, 181, 0}} ,{{219, 101}, {124, 181, 0}} ,{{224, 101}, {129, 181, 0}} ,{{83, 102}, {244, 181, 0}} ,{{100, 102}, {5, 182, 0}} ,{{101, 102}, {6, 182, 0}} ,{{106, 102}, {11, 182, 0}} ,{{90, 102}, {251, 181, 0}} ,{{84, 102}, {245, 181, 0}} ,{{85, 102}, {246, 181, 0}} ,{{86, 102}, {247, 181, 0}} ,{{110, 102}, {15, 182, 0}} ,{{105, 102}, {10, 182, 0}} ,{{107, 102}, {12, 182, 0}} ,{{91, 102}, {252, 181, 0}} ,{{94, 102}, {255, 181, 0}} ,{{92, 102}, {253, 181, 0}} ,{{98, 102}, {3, 182, 0}} ,{{93, 102}, {254, 181, 0}} ,{{97, 102}, {2, 182, 0}} ,{{95, 102}, {0, 182, 0}} ,{{96, 102}, {1, 182, 0}} ,{{99, 102}, {4, 182, 0}} ,{{87, 102}, {248, 181, 0}} ,{{104, 102}, {9, 182, 0}} ,{{89, 102}, {250, 181, 0}} ,{{88, 102}, {249, 181, 0}} ,{{55, 102}, {216, 181, 0}} ,{{72, 102}, {233, 181, 0}} ,{{73, 102}, {234, 181, 0}} ,{{78, 102}, {239, 181, 0}} ,{{62, 102}, {223, 181, 0}} ,{{56, 102}, {217, 181, 0}} ,{{57, 102}, {218, 181, 0}} ,{{58, 102}, {219, 181, 0}} ,{{82, 102}, {243, 181, 0}} ,{{77, 102}, {238, 181, 0}} ,{{79, 102}, {240, 181, 0}} ,{{63, 102}, {224, 181, 0}} ,{{66, 102}, {227, 181, 0}} ,{{64, 102}, {225, 181, 0}} ,{{70, 102}, {231, 181, 0}} ,{{65, 102}, {226, 181, 0}} ,{{69, 102}, {230, 181, 0}} ,{{67, 102}, {228, 181, 0}} ,{{68, 102}, {229, 181, 0}} ,{{71, 102}, {232, 181, 0}} ,{{59, 102}, {220, 181, 0}} ,{{76, 102}, {237, 181, 0}} ,{{61, 102}, {222, 181, 0}} ,{{60, 102}, {221, 181, 0}} ,{{81, 102}, {242, 181, 0}} ,{{74, 102}, {235, 181, 0}} ,{{75, 102}, {236, 181, 0}} ,{{80, 102}, {241, 181, 0}} ,{{109, 102}, {14, 182, 0}} ,{{102, 102}, {7, 182, 0}} ,{{103, 102}, {8, 182, 0}} ,{{108, 102}, {13, 182, 0}} ,{{163, 103}, {68, 183, 0}} ,{{180, 103}, {85, 183, 0}} ,{{181, 103}, {86, 183, 0}} ,{{186, 103}, {91, 183, 0}} ,{{170, 103}, {75, 183, 0}} ,{{164, 103}, {69, 183, 0}} ,{{165, 103}, {70, 183, 0}} ,{{166, 103}, {71, 183, 0}} ,{{190, 103}, {95, 183, 0}} ,{{185, 103}, {90, 183, 0}} ,{{187, 103}, {92, 183, 0}} ,{{171, 103}, {76, 183, 0}} ,{{174, 103}, {79, 183, 0}} ,{{172, 103}, {77, 183, 0}} ,{{178, 103}, {83, 183, 0}} ,{{173, 103}, {78, 183, 0}} ,{{177, 103}, {82, 183, 0}} ,{{175, 103}, {80, 183, 0}} ,{{176, 103}, {81, 183, 0}} ,{{179, 103}, {84, 183, 0}} ,{{167, 103}, {72, 183, 0}} ,{{184, 103}, {89, 183, 0}} ,{{169, 103}, {74, 183, 0}} ,{{168, 103}, {73, 183, 0}} ,{{189, 103}, {94, 183, 0}} ,{{182, 103}, {87, 183, 0}} ,{{183, 103}, {88, 183, 0}} ,{{188, 103}, {93, 183, 0}} ,{{223, 102}, {128, 182, 0}} ,{{240, 102}, {145, 182, 0}} ,{{241, 102}, {146, 182, 0}} ,{{246, 102}, {151, 182, 0}} ,{{230, 102}, {135, 182, 0}} ,{{224, 102}, {129, 182, 0}} ,{{225, 102}, {130, 182, 0}} ,{{226, 102}, {131, 182, 0}} ,{{250, 102}, {155, 182, 0}} ,{{245, 102}, {150, 182, 0}} ,{{247, 102}, {152, 182, 0}} ,{{231, 102}, {136, 182, 0}} ,{{234, 102}, {139, 182, 0}} ,{{232, 102}, {137, 182, 0}} ,{{238, 102}, {143, 182, 0}} ,{{233, 102}, {138, 182, 0}} ,{{237, 102}, {142, 182, 0}} ,{{235, 102}, {140, 182, 0}} ,{{236, 102}, {141, 182, 0}} ,{{239, 102}, {144, 182, 0}} ,{{227, 102}, {132, 182, 0}} ,{{244, 102}, {149, 182, 0}} ,{{229, 102}, {134, 182, 0}} ,{{228, 102}, {133, 182, 0}} ,{{249, 102}, {154, 182, 0}} ,{{242, 102}, {147, 182, 0}} ,{{243, 102}, {148, 182, 0}} ,{{248, 102}, {153, 182, 0}} ,{{107, 103}, {12, 183, 0}} ,{{124, 103}, {29, 183, 0}} ,{{125, 103}, {30, 183, 0}} ,{{130, 103}, {35, 183, 0}} ,{{114, 103}, {19, 183, 0}} ,{{108, 103}, {13, 183, 0}} ,{{109, 103}, {14, 183, 0}} ,{{110, 103}, {15, 183, 0}} ,{{134, 103}, {39, 183, 0}} ,{{129, 103}, {34, 183, 0}} ,{{131, 103}, {36, 183, 0}} ,{{115, 103}, {20, 183, 0}} ,{{118, 103}, {23, 183, 0}} ,{{116, 103}, {21, 183, 0}} ,{{122, 103}, {27, 183, 0}} ,{{117, 103}, {22, 183, 0}} ,{{121, 103}, {26, 183, 0}} ,{{119, 103}, {24, 183, 0}} ,{{120, 103}, {25, 183, 0}} ,{{123, 103}, {28, 183, 0}} ,{{111, 103}, {16, 183, 0}} ,{{128, 103}, {33, 183, 0}} ,{{113, 103}, {18, 183, 0}} ,{{112, 103}, {17, 183, 0}} ,{{133, 103}, {38, 183, 0}} ,{{126, 103}, {31, 183, 0}} ,{{127, 103}, {32, 183, 0}} ,{{132, 103}, {37, 183, 0}} ,{{207, 99}, {112, 179, 0}} ,{{224, 99}, {129, 179, 0}} ,{{225, 99}, {130, 179, 0}} ,{{230, 99}, {135, 179, 0}} ,{{214, 99}, {119, 179, 0}} ,{{208, 99}, {113, 179, 0}} ,{{209, 99}, {114, 179, 0}} ,{{210, 99}, {115, 179, 0}} ,{{234, 99}, {139, 179, 0}} ,{{229, 99}, {134, 179, 0}} ,{{231, 99}, {136, 179, 0}} ,{{215, 99}, {120, 179, 0}} ,{{218, 99}, {123, 179, 0}} ,{{216, 99}, {121, 179, 0}} ,{{222, 99}, {127, 179, 0}} ,{{217, 99}, {122, 179, 0}} ,{{221, 99}, {126, 179, 0}} ,{{219, 99}, {124, 179, 0}} ,{{220, 99}, {125, 179, 0}} ,{{223, 99}, {128, 179, 0}} ,{{211, 99}, {116, 179, 0}} ,{{228, 99}, {133, 179, 0}} ,{{213, 99}, {118, 179, 0}} ,{{212, 99}, {117, 179, 0}} ,{{179, 99}, {84, 179, 0}} ,{{196, 99}, {101, 179, 0}} ,{{197, 99}, {102, 179, 0}} ,{{202, 99}, {107, 179, 0}} ,{{186, 99}, {91, 179, 0}} ,{{180, 99}, {85, 179, 0}} ,{{181, 99}, {86, 179, 0}} ,{{182, 99}, {87, 179, 0}} ,{{206, 99}, {111, 179, 0}} ,{{201, 99}, {106, 179, 0}} ,{{203, 99}, {108, 179, 0}} ,{{187, 99}, {92, 179, 0}} ,{{190, 99}, {95, 179, 0}} ,{{188, 99}, {93, 179, 0}} ,{{194, 99}, {99, 179, 0}} ,{{189, 99}, {94, 179, 0}} ,{{193, 99}, {98, 179, 0}} ,{{191, 99}, {96, 179, 0}} ,{{192, 99}, {97, 179, 0}} ,{{195, 99}, {100, 179, 0}} ,{{183, 99}, {88, 179, 0}} ,{{200, 99}, {105, 179, 0}} ,{{185, 99}, {90, 179, 0}} ,{{184, 99}, {89, 179, 0}} ,{{205, 99}, {110, 179, 0}} ,{{198, 99}, {103, 179, 0}} ,{{199, 99}, {104, 179, 0}} ,{{204, 99}, {109, 179, 0}} ,{{233, 99}, {138, 179, 0}} ,{{226, 99}, {131, 179, 0}} ,{{227, 99}, {132, 179, 0}} ,{{232, 99}, {137, 179, 0}} ,{{59, 101}, {220, 180, 0}} ,{{76, 101}, {237, 180, 0}} ,{{77, 101}, {238, 180, 0}} ,{{82, 101}, {243, 180, 0}} ,{{66, 101}, {227, 180, 0}} ,{{60, 101}, {221, 180, 0}} ,{{61, 101}, {222, 180, 0}} ,{{62, 101}, {223, 180, 0}} ,{{86, 101}, {247, 180, 0}} ,{{81, 101}, {242, 180, 0}} ,{{83, 101}, {244, 180, 0}} ,{{67, 101}, {228, 180, 0}} ,{{70, 101}, {231, 180, 0}} ,{{68, 101}, {229, 180, 0}} ,{{74, 101}, {235, 180, 0}} ,{{69, 101}, {230, 180, 0}} ,{{73, 101}, {234, 180, 0}} ,{{71, 101}, {232, 180, 0}} ,{{72, 101}, {233, 180, 0}} ,{{75, 101}, {236, 180, 0}} ,{{63, 101}, {224, 180, 0}} ,{{80, 101}, {241, 180, 0}} ,{{65, 101}, {226, 180, 0}} ,{{64, 101}, {225, 180, 0}} ,{{85, 101}, {246, 180, 0}} ,{{78, 101}, {239, 180, 0}} ,{{79, 101}, {240, 180, 0}} ,{{84, 101}, {245, 180, 0}} ,{{115, 101}, {20, 181, 0}} ,{{132, 101}, {37, 181, 0}} ,{{133, 101}, {38, 181, 0}} ,{{138, 101}, {43, 181, 0}} ,{{122, 101}, {27, 181, 0}} ,{{116, 101}, {21, 181, 0}} ,{{117, 101}, {22, 181, 0}} ,{{118, 101}, {23, 181, 0}} ,{{142, 101}, {47, 181, 0}} ,{{137, 101}, {42, 181, 0}} ,{{139, 101}, {44, 181, 0}} ,{{123, 101}, {28, 181, 0}} ,{{126, 101}, {31, 181, 0}} ,{{124, 101}, {29, 181, 0}} ,{{130, 101}, {35, 181, 0}} ,{{125, 101}, {30, 181, 0}} ,{{129, 101}, {34, 181, 0}} ,{{127, 101}, {32, 181, 0}} ,{{128, 101}, {33, 181, 0}} ,{{131, 101}, {36, 181, 0}} ,{{119, 101}, {24, 181, 0}} ,{{136, 101}, {41, 181, 0}} ,{{121, 101}, {26, 181, 0}} ,{{120, 101}, {25, 181, 0}} ,{{141, 101}, {46, 181, 0}} ,{{134, 101}, {39, 181, 0}} ,{{135, 101}, {40, 181, 0}} ,{{140, 101}, {45, 181, 0}} ,{{35, 100}, {196, 179, 0}} ,{{52, 100}, {213, 179, 0}} ,{{53, 100}, {214, 179, 0}} ,{{58, 100}, {219, 179, 0}} ,{{42, 100}, {203, 179, 0}} ,{{119, 100}, {24, 180, 0}} ,{{136, 100}, {41, 180, 0}} ,{{137, 100}, {42, 180, 0}} ,{{142, 100}, {47, 180, 0}} ,{{126, 100}, {31, 180, 0}} ,{{120, 100}, {25, 180, 0}} ,{{121, 100}, {26, 180, 0}} ,{{122, 100}, {27, 180, 0}} ,{{146, 100}, {51, 180, 0}} ,{{141, 100}, {46, 180, 0}} ,{{143, 100}, {48, 180, 0}} ,{{127, 100}, {32, 180, 0}} ,{{130, 100}, {35, 180, 0}} ,{{128, 100}, {33, 180, 0}} ,{{134, 100}, {39, 180, 0}} ,{{129, 100}, {34, 180, 0}} ,{{133, 100}, {38, 180, 0}} ,{{131, 100}, {36, 180, 0}} ,{{132, 100}, {37, 180, 0}} ,{{135, 100}, {40, 180, 0}} ,{{123, 100}, {28, 180, 0}} ,{{140, 100}, {45, 180, 0}} ,{{125, 100}, {30, 180, 0}} ,{{124, 100}, {29, 180, 0}} ,{{145, 100}, {50, 180, 0}} ,{{138, 100}, {43, 180, 0}} ,{{139, 100}, {44, 180, 0}} ,{{144, 100}, {49, 180, 0}} ,{{36, 100}, {197, 179, 0}} ,{{37, 100}, {198, 179, 0}} ,{{38, 100}, {199, 179, 0}} ,{{62, 100}, {223, 179, 0}} ,{{57, 100}, {218, 179, 0}} ,{{59, 100}, {220, 179, 0}} ,{{43, 100}, {204, 179, 0}} ,{{46, 100}, {207, 179, 0}} ,{{44, 100}, {205, 179, 0}} ,{{50, 100}, {211, 179, 0}} ,{{45, 100}, {206, 179, 0}} ,{{49, 100}, {210, 179, 0}} ,{{47, 100}, {208, 179, 0}} ,{{48, 100}, {209, 179, 0}} ,{{51, 100}, {212, 179, 0}} ,{{39, 100}, {200, 179, 0}} ,{{56, 100}, {217, 179, 0}} ,{{41, 100}, {202, 179, 0}} ,{{40, 100}, {201, 179, 0}} ,{{61, 100}, {222, 179, 0}} ,{{54, 100}, {215, 179, 0}} ,{{55, 100}, {216, 179, 0}} ,{{60, 100}, {221, 179, 0}} ,{{175, 100}, {80, 180, 0}} ,{{192, 100}, {97, 180, 0}} ,{{193, 100}, {98, 180, 0}} ,{{198, 100}, {103, 180, 0}} ,{{182, 100}, {87, 180, 0}} ,{{176, 100}, {81, 180, 0}} ,{{177, 100}, {82, 180, 0}} ,{{178, 100}, {83, 180, 0}} ,{{202, 100}, {107, 180, 0}} ,{{197, 100}, {102, 180, 0}} ,{{199, 100}, {104, 180, 0}} ,{{183, 100}, {88, 180, 0}} ,{{186, 100}, {91, 180, 0}} ,{{184, 100}, {89, 180, 0}} ,{{190, 100}, {95, 180, 0}} ,{{185, 100}, {90, 180, 0}} ,{{189, 100}, {94, 180, 0}} ,{{187, 100}, {92, 180, 0}} ,{{188, 100}, {93, 180, 0}} ,{{191, 100}, {96, 180, 0}} ,{{179, 100}, {84, 180, 0}} ,{{196, 100}, {101, 180, 0}} ,{{181, 100}, {86, 180, 0}} ,{{180, 100}, {85, 180, 0}} ,{{201, 100}, {106, 180, 0}} ,{{194, 100}, {99, 180, 0}} ,{{195, 100}, {100, 180, 0}} ,{{200, 100}, {105, 180, 0}} ,{{63, 100}, {224, 179, 0}} ,{{80, 100}, {241, 179, 0}} ,{{81, 100}, {242, 179, 0}} ,{{86, 100}, {247, 179, 0}} ,{{70, 100}, {231, 179, 0}} ,{{91, 100}, {252, 179, 0}} ,{{108, 100}, {13, 180, 0}} ,{{109, 100}, {14, 180, 0}} ,{{114, 100}, {19, 180, 0}} ,{{98, 100}, {3, 180, 0}} ,{{92, 100}, {253, 179, 0}} ,{{93, 100}, {254, 179, 0}} ,{{94, 100}, {255, 179, 0}} ,{{118, 100}, {23, 180, 0}} ,{{113, 100}, {18, 180, 0}} ,{{115, 100}, {20, 180, 0}} ,{{99, 100}, {4, 180, 0}} ,{{102, 100}, {7, 180, 0}} ,{{100, 100}, {5, 180, 0}} ,{{106, 100}, {11, 180, 0}} ,{{101, 100}, {6, 180, 0}} ,{{105, 100}, {10, 180, 0}} ,{{103, 100}, {8, 180, 0}} ,{{104, 100}, {9, 180, 0}} ,{{107, 100}, {12, 180, 0}} ,{{95, 100}, {0, 180, 0}} ,{{112, 100}, {17, 180, 0}} ,{{97, 100}, {2, 180, 0}} ,{{96, 100}, {1, 180, 0}} ,{{117, 100}, {22, 180, 0}} ,{{110, 100}, {15, 180, 0}} ,{{111, 100}, {16, 180, 0}} ,{{116, 100}, {21, 180, 0}} ,{{64, 100}, {225, 179, 0}} ,{{65, 100}, {226, 179, 0}} ,{{66, 100}, {227, 179, 0}} ,{{90, 100}, {251, 179, 0}} ,{{85, 100}, {246, 179, 0}} ,{{87, 100}, {248, 179, 0}} ,{{71, 100}, {232, 179, 0}} ,{{74, 100}, {235, 179, 0}} ,{{72, 100}, {233, 179, 0}} ,{{78, 100}, {239, 179, 0}} ,{{73, 100}, {234, 179, 0}} ,{{77, 100}, {238, 179, 0}} ,{{75, 100}, {236, 179, 0}} ,{{76, 100}, {237, 179, 0}} ,{{79, 100}, {240, 179, 0}} ,{{67, 100}, {228, 179, 0}} ,{{84, 100}, {245, 179, 0}} ,{{69, 100}, {230, 179, 0}} ,{{68, 100}, {229, 179, 0}} ,{{89, 100}, {250, 179, 0}} ,{{82, 100}, {243, 179, 0}} ,{{83, 100}, {244, 179, 0}} ,{{88, 100}, {249, 179, 0}} ,{{231, 100}, {136, 180, 0}} ,{{248, 100}, {153, 180, 0}} ,{{249, 100}, {154, 180, 0}} ,{{254, 100}, {159, 180, 0}} ,{{238, 100}, {143, 180, 0}} ,{{232, 100}, {137, 180, 0}} ,{{233, 100}, {138, 180, 0}} ,{{234, 100}, {139, 180, 0}} ,{{2, 101}, {163, 180, 0}} ,{{253, 100}, {158, 180, 0}} ,{{255, 100}, {160, 180, 0}} ,{{239, 100}, {144, 180, 0}} ,{{242, 100}, {147, 180, 0}} ,{{240, 100}, {145, 180, 0}} ,{{246, 100}, {151, 180, 0}} ,{{241, 100}, {146, 180, 0}} ,{{245, 100}, {150, 180, 0}} ,{{243, 100}, {148, 180, 0}} ,{{244, 100}, {149, 180, 0}} ,{{247, 100}, {152, 180, 0}} ,{{235, 100}, {140, 180, 0}} ,{{252, 100}, {157, 180, 0}} ,{{237, 100}, {142, 180, 0}} ,{{236, 100}, {141, 180, 0}} ,{{203, 100}, {108, 180, 0}} ,{{220, 100}, {125, 180, 0}} ,{{221, 100}, {126, 180, 0}} ,{{226, 100}, {131, 180, 0}} ,{{210, 100}, {115, 180, 0}} ,{{204, 100}, {109, 180, 0}} ,{{205, 100}, {110, 180, 0}} ,{{206, 100}, {111, 180, 0}} ,{{230, 100}, {135, 180, 0}} ,{{225, 100}, {130, 180, 0}} ,{{227, 100}, {132, 180, 0}} ,{{211, 100}, {116, 180, 0}} ,{{214, 100}, {119, 180, 0}} ,{{212, 100}, {117, 180, 0}} ,{{218, 100}, {123, 180, 0}} ,{{213, 100}, {118, 180, 0}} ,{{217, 100}, {122, 180, 0}} ,{{215, 100}, {120, 180, 0}} ,{{216, 100}, {121, 180, 0}} ,{{219, 100}, {124, 180, 0}} ,{{207, 100}, {112, 180, 0}} ,{{224, 100}, {129, 180, 0}} ,{{209, 100}, {114, 180, 0}} ,{{208, 100}, {113, 180, 0}} ,{{229, 100}, {134, 180, 0}} ,{{222, 100}, {127, 180, 0}} ,{{223, 100}, {128, 180, 0}} ,{{228, 100}, {133, 180, 0}} ,{{1, 101}, {162, 180, 0}} ,{{250, 100}, {155, 180, 0}} ,{{251, 100}, {156, 180, 0}} ,{{0, 101}, {161, 180, 0}} ,{{3, 101}, {164, 180, 0}} ,{{20, 101}, {181, 180, 0}} ,{{21, 101}, {182, 180, 0}} ,{{26, 101}, {187, 180, 0}} ,{{10, 101}, {171, 180, 0}} ,{{4, 101}, {165, 180, 0}} ,{{5, 101}, {166, 180, 0}} ,{{6, 101}, {167, 180, 0}} ,{{30, 101}, {191, 180, 0}} ,{{25, 101}, {186, 180, 0}} ,{{27, 101}, {188, 180, 0}} ,{{11, 101}, {172, 180, 0}} ,{{14, 101}, {175, 180, 0}} ,{{12, 101}, {173, 180, 0}} ,{{18, 101}, {179, 180, 0}} ,{{13, 101}, {174, 180, 0}} ,{{17, 101}, {178, 180, 0}} ,{{15, 101}, {176, 180, 0}} ,{{16, 101}, {177, 180, 0}} ,{{19, 101}, {180, 180, 0}} ,{{7, 101}, {168, 180, 0}} ,{{24, 101}, {185, 180, 0}} ,{{9, 101}, {170, 180, 0}} ,{{8, 101}, {169, 180, 0}} ,{{29, 101}, {190, 180, 0}} ,{{22, 101}, {183, 180, 0}} ,{{23, 101}, {184, 180, 0}} ,{{28, 101}, {189, 180, 0}} ,{{123, 99}, {28, 179, 0}} ,{{140, 99}, {45, 179, 0}} ,{{141, 99}, {46, 179, 0}} ,{{146, 99}, {51, 179, 0}} ,{{130, 99}, {35, 179, 0}} ,{{151, 99}, {56, 179, 0}} ,{{168, 99}, {73, 179, 0}} ,{{169, 99}, {74, 179, 0}} ,{{174, 99}, {79, 179, 0}} ,{{158, 99}, {63, 179, 0}} ,{{152, 99}, {57, 179, 0}} ,{{153, 99}, {58, 179, 0}} ,{{154, 99}, {59, 179, 0}} ,{{178, 99}, {83, 179, 0}} ,{{173, 99}, {78, 179, 0}} ,{{175, 99}, {80, 179, 0}} ,{{159, 99}, {64, 179, 0}} ,{{162, 99}, {67, 179, 0}} ,{{160, 99}, {65, 179, 0}} ,{{166, 99}, {71, 179, 0}} ,{{161, 99}, {66, 179, 0}} ,{{165, 99}, {70, 179, 0}} ,{{163, 99}, {68, 179, 0}} ,{{164, 99}, {69, 179, 0}} ,{{167, 99}, {72, 179, 0}} ,{{155, 99}, {60, 179, 0}} ,{{172, 99}, {77, 179, 0}} ,{{157, 99}, {62, 179, 0}} ,{{156, 99}, {61, 179, 0}} ,{{177, 99}, {82, 179, 0}} ,{{170, 99}, {75, 179, 0}} ,{{171, 99}, {76, 179, 0}} ,{{176, 99}, {81, 179, 0}} ,{{124, 99}, {29, 179, 0}} ,{{125, 99}, {30, 179, 0}} ,{{126, 99}, {31, 179, 0}} ,{{150, 99}, {55, 179, 0}} ,{{145, 99}, {50, 179, 0}} ,{{147, 99}, {52, 179, 0}} ,{{131, 99}, {36, 179, 0}} ,{{134, 99}, {39, 179, 0}} ,{{132, 99}, {37, 179, 0}} ,{{138, 99}, {43, 179, 0}} ,{{133, 99}, {38, 179, 0}} ,{{137, 99}, {42, 179, 0}} ,{{135, 99}, {40, 179, 0}} ,{{136, 99}, {41, 179, 0}} ,{{139, 99}, {44, 179, 0}} ,{{127, 99}, {32, 179, 0}} ,{{144, 99}, {49, 179, 0}} ,{{129, 99}, {34, 179, 0}} ,{{128, 99}, {33, 179, 0}} ,{{149, 99}, {54, 179, 0}} ,{{142, 99}, {47, 179, 0}} ,{{143, 99}, {48, 179, 0}} ,{{148, 99}, {53, 179, 0}} ,{{7, 100}, {168, 179, 0}} ,{{24, 100}, {185, 179, 0}} ,{{25, 100}, {186, 179, 0}} ,{{30, 100}, {191, 179, 0}} ,{{14, 100}, {175, 179, 0}} ,{{8, 100}, {169, 179, 0}} ,{{9, 100}, {170, 179, 0}} ,{{10, 100}, {171, 179, 0}} ,{{34, 100}, {195, 179, 0}} ,{{29, 100}, {190, 179, 0}} ,{{31, 100}, {192, 179, 0}} ,{{15, 100}, {176, 179, 0}} ,{{18, 100}, {179, 179, 0}} ,{{16, 100}, {177, 179, 0}} ,{{22, 100}, {183, 179, 0}} ,{{17, 100}, {178, 179, 0}} ,{{21, 100}, {182, 179, 0}} ,{{19, 100}, {180, 179, 0}} ,{{20, 100}, {181, 179, 0}} ,{{23, 100}, {184, 179, 0}} ,{{11, 100}, {172, 179, 0}} ,{{28, 100}, {189, 179, 0}} ,{{13, 100}, {174, 179, 0}} ,{{12, 100}, {173, 179, 0}} ,{{235, 99}, {140, 179, 0}} ,{{252, 99}, {157, 179, 0}} ,{{253, 99}, {158, 179, 0}} ,{{2, 100}, {163, 179, 0}} ,{{242, 99}, {147, 179, 0}} ,{{236, 99}, {141, 179, 0}} ,{{237, 99}, {142, 179, 0}} ,{{238, 99}, {143, 179, 0}} ,{{6, 100}, {167, 179, 0}} ,{{1, 100}, {162, 179, 0}} ,{{3, 100}, {164, 179, 0}} ,{{243, 99}, {148, 179, 0}} ,{{246, 99}, {151, 179, 0}} ,{{244, 99}, {149, 179, 0}} ,{{250, 99}, {155, 179, 0}} ,{{245, 99}, {150, 179, 0}} ,{{249, 99}, {154, 179, 0}} ,{{247, 99}, {152, 179, 0}} ,{{248, 99}, {153, 179, 0}} ,{{251, 99}, {156, 179, 0}} ,{{239, 99}, {144, 179, 0}} ,{{0, 100}, {161, 179, 0}} ,{{241, 99}, {146, 179, 0}} ,{{240, 99}, {145, 179, 0}} ,{{5, 100}, {166, 179, 0}} ,{{254, 99}, {159, 179, 0}} ,{{255, 99}, {160, 179, 0}} ,{{4, 100}, {165, 179, 0}} ,{{33, 100}, {194, 179, 0}} ,{{26, 100}, {187, 179, 0}} ,{{27, 100}, {188, 179, 0}} ,{{32, 100}, {193, 179, 0}} ,{{87, 101}, {248, 180, 0}} ,{{104, 101}, {9, 181, 0}} ,{{105, 101}, {10, 181, 0}} ,{{110, 101}, {15, 181, 0}} ,{{94, 101}, {255, 180, 0}} ,{{88, 101}, {249, 180, 0}} ,{{89, 101}, {250, 180, 0}} ,{{90, 101}, {251, 180, 0}} ,{{114, 101}, {19, 181, 0}} ,{{109, 101}, {14, 181, 0}} ,{{111, 101}, {16, 181, 0}} ,{{95, 101}, {0, 181, 0}} ,{{98, 101}, {3, 181, 0}} ,{{96, 101}, {1, 181, 0}} ,{{102, 101}, {7, 181, 0}} ,{{97, 101}, {2, 181, 0}} ,{{101, 101}, {6, 181, 0}} ,{{99, 101}, {4, 181, 0}} ,{{100, 101}, {5, 181, 0}} ,{{103, 101}, {8, 181, 0}} ,{{91, 101}, {252, 180, 0}} ,{{108, 101}, {13, 181, 0}} ,{{93, 101}, {254, 180, 0}} ,{{92, 101}, {253, 180, 0}} ,{{113, 101}, {18, 181, 0}} ,{{106, 101}, {11, 181, 0}} ,{{107, 101}, {12, 181, 0}} ,{{112, 101}, {17, 181, 0}} ,{{147, 100}, {52, 180, 0}} ,{{164, 100}, {69, 180, 0}} ,{{165, 100}, {70, 180, 0}} ,{{170, 100}, {75, 180, 0}} ,{{154, 100}, {59, 180, 0}} ,{{148, 100}, {53, 180, 0}} ,{{149, 100}, {54, 180, 0}} ,{{150, 100}, {55, 180, 0}} ,{{174, 100}, {79, 180, 0}} ,{{169, 100}, {74, 180, 0}} ,{{171, 100}, {76, 180, 0}} ,{{155, 100}, {60, 180, 0}} ,{{158, 100}, {63, 180, 0}} ,{{156, 100}, {61, 180, 0}} ,{{162, 100}, {67, 180, 0}} ,{{157, 100}, {62, 180, 0}} ,{{161, 100}, {66, 180, 0}} ,{{159, 100}, {64, 180, 0}} ,{{160, 100}, {65, 180, 0}} ,{{163, 100}, {68, 180, 0}} ,{{151, 100}, {56, 180, 0}} ,{{168, 100}, {73, 180, 0}} ,{{153, 100}, {58, 180, 0}} ,{{152, 100}, {57, 180, 0}} ,{{173, 100}, {78, 180, 0}} ,{{166, 100}, {71, 180, 0}} ,{{167, 100}, {72, 180, 0}} ,{{172, 100}, {77, 180, 0}} ,{{31, 101}, {192, 180, 0}} ,{{48, 101}, {209, 180, 0}} ,{{49, 101}, {210, 180, 0}} ,{{54, 101}, {215, 180, 0}} ,{{38, 101}, {199, 180, 0}} ,{{32, 101}, {193, 180, 0}} ,{{33, 101}, {194, 180, 0}} ,{{34, 101}, {195, 180, 0}} ,{{58, 101}, {219, 180, 0}} ,{{53, 101}, {214, 180, 0}} ,{{55, 101}, {216, 180, 0}} ,{{39, 101}, {200, 180, 0}} ,{{42, 101}, {203, 180, 0}} ,{{40, 101}, {201, 180, 0}} ,{{46, 101}, {207, 180, 0}} ,{{41, 101}, {202, 180, 0}} ,{{45, 101}, {206, 180, 0}} ,{{43, 101}, {204, 180, 0}} ,{{44, 101}, {205, 180, 0}} ,{{47, 101}, {208, 180, 0}} ,{{35, 101}, {196, 180, 0}} ,{{52, 101}, {213, 180, 0}} ,{{37, 101}, {198, 180, 0}} ,{{36, 101}, {197, 180, 0}} ,{{57, 101}, {218, 180, 0}} ,{{50, 101}, {211, 180, 0}} ,{{51, 101}, {212, 180, 0}} ,{{56, 101}, {217, 180, 0}} ,{{47, 118}, {208, 197, 0}} ,{{64, 118}, {225, 197, 0}} ,{{65, 118}, {226, 197, 0}} ,{{70, 118}, {231, 197, 0}} ,{{54, 118}, {215, 197, 0}} ,{{48, 118}, {209, 197, 0}} ,{{49, 118}, {210, 197, 0}} ,{{50, 118}, {211, 197, 0}} ,{{74, 118}, {235, 197, 0}} ,{{69, 118}, {230, 197, 0}} ,{{71, 118}, {232, 197, 0}} ,{{55, 118}, {216, 197, 0}} ,{{58, 118}, {219, 197, 0}} ,{{56, 118}, {217, 197, 0}} ,{{62, 118}, {223, 197, 0}} ,{{57, 118}, {218, 197, 0}} ,{{61, 118}, {222, 197, 0}} ,{{59, 118}, {220, 197, 0}} ,{{60, 118}, {221, 197, 0}} ,{{63, 118}, {224, 197, 0}} ,{{51, 118}, {212, 197, 0}} ,{{68, 118}, {229, 197, 0}} ,{{53, 118}, {214, 197, 0}} ,{{52, 118}, {213, 197, 0}} ,{{19, 118}, {180, 197, 0}} ,{{36, 118}, {197, 197, 0}} ,{{37, 118}, {198, 197, 0}} ,{{42, 118}, {203, 197, 0}} ,{{26, 118}, {187, 197, 0}} ,{{20, 118}, {181, 197, 0}} ,{{21, 118}, {182, 197, 0}} ,{{22, 118}, {183, 197, 0}} ,{{46, 118}, {207, 197, 0}} ,{{41, 118}, {202, 197, 0}} ,{{43, 118}, {204, 197, 0}} ,{{27, 118}, {188, 197, 0}} ,{{30, 118}, {191, 197, 0}} ,{{28, 118}, {189, 197, 0}} ,{{34, 118}, {195, 197, 0}} ,{{29, 118}, {190, 197, 0}} ,{{33, 118}, {194, 197, 0}} ,{{31, 118}, {192, 197, 0}} ,{{32, 118}, {193, 197, 0}} ,{{35, 118}, {196, 197, 0}} ,{{23, 118}, {184, 197, 0}} ,{{40, 118}, {201, 197, 0}} ,{{25, 118}, {186, 197, 0}} ,{{24, 118}, {185, 197, 0}} ,{{45, 118}, {206, 197, 0}} ,{{38, 118}, {199, 197, 0}} ,{{39, 118}, {200, 197, 0}} ,{{44, 118}, {205, 197, 0}} ,{{73, 118}, {234, 197, 0}} ,{{66, 118}, {227, 197, 0}} ,{{67, 118}, {228, 197, 0}} ,{{72, 118}, {233, 197, 0}} ,{{155, 119}, {60, 199, 0}} ,{{172, 119}, {77, 199, 0}} ,{{173, 119}, {78, 199, 0}} ,{{178, 119}, {83, 199, 0}} ,{{162, 119}, {67, 199, 0}} ,{{156, 119}, {61, 199, 0}} ,{{157, 119}, {62, 199, 0}} ,{{158, 119}, {63, 199, 0}} ,{{182, 119}, {87, 199, 0}} ,{{177, 119}, {82, 199, 0}} ,{{179, 119}, {84, 199, 0}} ,{{163, 119}, {68, 199, 0}} ,{{166, 119}, {71, 199, 0}} ,{{164, 119}, {69, 199, 0}} ,{{170, 119}, {75, 199, 0}} ,{{165, 119}, {70, 199, 0}} ,{{169, 119}, {74, 199, 0}} ,{{167, 119}, {72, 199, 0}} ,{{168, 119}, {73, 199, 0}} ,{{171, 119}, {76, 199, 0}} ,{{159, 119}, {64, 199, 0}} ,{{176, 119}, {81, 199, 0}} ,{{161, 119}, {66, 199, 0}} ,{{160, 119}, {65, 199, 0}} ,{{181, 119}, {86, 199, 0}} ,{{174, 119}, {79, 199, 0}} ,{{175, 119}, {80, 199, 0}} ,{{180, 119}, {85, 199, 0}} ,{{95, 92}, {0, 172, 0}} ,{{112, 92}, {17, 172, 0}} ,{{113, 92}, {18, 172, 0}} ,{{118, 92}, {23, 172, 0}} ,{{102, 92}, {7, 172, 0}} ,{{123, 92}, {28, 172, 0}} ,{{140, 92}, {45, 172, 0}} ,{{141, 92}, {46, 172, 0}} ,{{146, 92}, {51, 172, 0}} ,{{130, 92}, {35, 172, 0}} ,{{124, 92}, {29, 172, 0}} ,{{125, 92}, {30, 172, 0}} ,{{126, 92}, {31, 172, 0}} ,{{150, 92}, {55, 172, 0}} ,{{145, 92}, {50, 172, 0}} ,{{147, 92}, {52, 172, 0}} ,{{131, 92}, {36, 172, 0}} ,{{134, 92}, {39, 172, 0}} ,{{132, 92}, {37, 172, 0}} ,{{138, 92}, {43, 172, 0}} ,{{133, 92}, {38, 172, 0}} ,{{137, 92}, {42, 172, 0}} ,{{135, 92}, {40, 172, 0}} ,{{136, 92}, {41, 172, 0}} ,{{139, 92}, {44, 172, 0}} ,{{127, 92}, {32, 172, 0}} ,{{144, 92}, {49, 172, 0}} ,{{129, 92}, {34, 172, 0}} ,{{128, 92}, {33, 172, 0}} ,{{149, 92}, {54, 172, 0}} ,{{142, 92}, {47, 172, 0}} ,{{143, 92}, {48, 172, 0}} ,{{148, 92}, {53, 172, 0}} ,{{96, 92}, {1, 172, 0}} ,{{97, 92}, {2, 172, 0}} ,{{98, 92}, {3, 172, 0}} ,{{122, 92}, {27, 172, 0}} ,{{117, 92}, {22, 172, 0}} ,{{119, 92}, {24, 172, 0}} ,{{103, 92}, {8, 172, 0}} ,{{106, 92}, {11, 172, 0}} ,{{104, 92}, {9, 172, 0}} ,{{110, 92}, {15, 172, 0}} ,{{105, 92}, {10, 172, 0}} ,{{109, 92}, {14, 172, 0}} ,{{107, 92}, {12, 172, 0}} ,{{108, 92}, {13, 172, 0}} ,{{111, 92}, {16, 172, 0}} ,{{99, 92}, {4, 172, 0}} ,{{116, 92}, {21, 172, 0}} ,{{101, 92}, {6, 172, 0}} ,{{100, 92}, {5, 172, 0}} ,{{121, 92}, {26, 172, 0}} ,{{114, 92}, {19, 172, 0}} ,{{115, 92}, {20, 172, 0}} ,{{120, 92}, {25, 172, 0}} ,{{235, 92}, {140, 172, 0}} ,{{252, 92}, {157, 172, 0}} ,{{253, 92}, {158, 172, 0}} ,{{2, 93}, {163, 172, 0}} ,{{242, 92}, {147, 172, 0}} ,{{236, 92}, {141, 172, 0}} ,{{237, 92}, {142, 172, 0}} ,{{238, 92}, {143, 172, 0}} ,{{6, 93}, {167, 172, 0}} ,{{1, 93}, {162, 172, 0}} ,{{3, 93}, {164, 172, 0}} ,{{243, 92}, {148, 172, 0}} ,{{246, 92}, {151, 172, 0}} ,{{244, 92}, {149, 172, 0}} ,{{250, 92}, {155, 172, 0}} ,{{245, 92}, {150, 172, 0}} ,{{249, 92}, {154, 172, 0}} ,{{247, 92}, {152, 172, 0}} ,{{248, 92}, {153, 172, 0}} ,{{251, 92}, {156, 172, 0}} ,{{239, 92}, {144, 172, 0}} ,{{0, 93}, {161, 172, 0}} ,{{241, 92}, {146, 172, 0}} ,{{240, 92}, {145, 172, 0}} ,{{207, 92}, {112, 172, 0}} ,{{224, 92}, {129, 172, 0}} ,{{225, 92}, {130, 172, 0}} ,{{230, 92}, {135, 172, 0}} ,{{214, 92}, {119, 172, 0}} ,{{208, 92}, {113, 172, 0}} ,{{209, 92}, {114, 172, 0}} ,{{210, 92}, {115, 172, 0}} ,{{234, 92}, {139, 172, 0}} ,{{229, 92}, {134, 172, 0}} ,{{231, 92}, {136, 172, 0}} ,{{215, 92}, {120, 172, 0}} ,{{218, 92}, {123, 172, 0}} ,{{216, 92}, {121, 172, 0}} ,{{222, 92}, {127, 172, 0}} ,{{217, 92}, {122, 172, 0}} ,{{221, 92}, {126, 172, 0}} ,{{219, 92}, {124, 172, 0}} ,{{220, 92}, {125, 172, 0}} ,{{223, 92}, {128, 172, 0}} ,{{211, 92}, {116, 172, 0}} ,{{228, 92}, {133, 172, 0}} ,{{213, 92}, {118, 172, 0}} ,{{212, 92}, {117, 172, 0}} ,{{233, 92}, {138, 172, 0}} ,{{226, 92}, {131, 172, 0}} ,{{227, 92}, {132, 172, 0}} ,{{232, 92}, {137, 172, 0}} ,{{5, 93}, {166, 172, 0}} ,{{254, 92}, {159, 172, 0}} ,{{255, 92}, {160, 172, 0}} ,{{4, 93}, {165, 172, 0}} ,{{87, 94}, {248, 173, 0}} ,{{104, 94}, {9, 174, 0}} ,{{105, 94}, {10, 174, 0}} ,{{110, 94}, {15, 174, 0}} ,{{94, 94}, {255, 173, 0}} ,{{88, 94}, {249, 173, 0}} ,{{89, 94}, {250, 173, 0}} ,{{90, 94}, {251, 173, 0}} ,{{114, 94}, {19, 174, 0}} ,{{109, 94}, {14, 174, 0}} ,{{111, 94}, {16, 174, 0}} ,{{95, 94}, {0, 174, 0}} ,{{98, 94}, {3, 174, 0}} ,{{96, 94}, {1, 174, 0}} ,{{102, 94}, {7, 174, 0}} ,{{97, 94}, {2, 174, 0}} ,{{101, 94}, {6, 174, 0}} ,{{99, 94}, {4, 174, 0}} ,{{100, 94}, {5, 174, 0}} ,{{103, 94}, {8, 174, 0}} ,{{91, 94}, {252, 173, 0}} ,{{108, 94}, {13, 174, 0}} ,{{93, 94}, {254, 173, 0}} ,{{92, 94}, {253, 173, 0}} ,{{113, 94}, {18, 174, 0}} ,{{106, 94}, {11, 174, 0}} ,{{107, 94}, {12, 174, 0}} ,{{112, 94}, {17, 174, 0}} ,{{171, 94}, {76, 174, 0}} ,{{188, 94}, {93, 174, 0}} ,{{189, 94}, {94, 174, 0}} ,{{194, 94}, {99, 174, 0}} ,{{178, 94}, {83, 174, 0}} ,{{199, 94}, {104, 174, 0}} ,{{216, 94}, {121, 174, 0}} ,{{217, 94}, {122, 174, 0}} ,{{222, 94}, {127, 174, 0}} ,{{206, 94}, {111, 174, 0}} ,{{200, 94}, {105, 174, 0}} ,{{201, 94}, {106, 174, 0}} ,{{202, 94}, {107, 174, 0}} ,{{226, 94}, {131, 174, 0}} ,{{221, 94}, {126, 174, 0}} ,{{223, 94}, {128, 174, 0}} ,{{207, 94}, {112, 174, 0}} ,{{210, 94}, {115, 174, 0}} ,{{208, 94}, {113, 174, 0}} ,{{214, 94}, {119, 174, 0}} ,{{209, 94}, {114, 174, 0}} ,{{213, 94}, {118, 174, 0}} ,{{211, 94}, {116, 174, 0}} ,{{212, 94}, {117, 174, 0}} ,{{215, 94}, {120, 174, 0}} ,{{203, 94}, {108, 174, 0}} ,{{220, 94}, {125, 174, 0}} ,{{205, 94}, {110, 174, 0}} ,{{204, 94}, {109, 174, 0}} ,{{225, 94}, {130, 174, 0}} ,{{218, 94}, {123, 174, 0}} ,{{219, 94}, {124, 174, 0}} ,{{224, 94}, {129, 174, 0}} ,{{172, 94}, {77, 174, 0}} ,{{173, 94}, {78, 174, 0}} ,{{174, 94}, {79, 174, 0}} ,{{198, 94}, {103, 174, 0}} ,{{193, 94}, {98, 174, 0}} ,{{195, 94}, {100, 174, 0}} ,{{179, 94}, {84, 174, 0}} ,{{182, 94}, {87, 174, 0}} ,{{180, 94}, {85, 174, 0}} ,{{186, 94}, {91, 174, 0}} ,{{181, 94}, {86, 174, 0}} ,{{185, 94}, {90, 174, 0}} ,{{183, 94}, {88, 174, 0}} ,{{184, 94}, {89, 174, 0}} ,{{187, 94}, {92, 174, 0}} ,{{175, 94}, {80, 174, 0}} ,{{192, 94}, {97, 174, 0}} ,{{177, 94}, {82, 174, 0}} ,{{176, 94}, {81, 174, 0}} ,{{197, 94}, {102, 174, 0}} ,{{190, 94}, {95, 174, 0}} ,{{191, 94}, {96, 174, 0}} ,{{196, 94}, {101, 174, 0}} ,{{55, 95}, {216, 174, 0}} ,{{72, 95}, {233, 174, 0}} ,{{73, 95}, {234, 174, 0}} ,{{78, 95}, {239, 174, 0}} ,{{62, 95}, {223, 174, 0}} ,{{56, 95}, {217, 174, 0}} ,{{57, 95}, {218, 174, 0}} ,{{58, 95}, {219, 174, 0}} ,{{82, 95}, {243, 174, 0}} ,{{77, 95}, {238, 174, 0}} ,{{79, 95}, {240, 174, 0}} ,{{63, 95}, {224, 174, 0}} ,{{66, 95}, {227, 174, 0}} ,{{64, 95}, {225, 174, 0}} ,{{70, 95}, {231, 174, 0}} ,{{65, 95}, {226, 174, 0}} ,{{69, 95}, {230, 174, 0}} ,{{67, 95}, {228, 174, 0}} ,{{68, 95}, {229, 174, 0}} ,{{71, 95}, {232, 174, 0}} ,{{59, 95}, {220, 174, 0}} ,{{76, 95}, {237, 174, 0}} ,{{61, 95}, {222, 174, 0}} ,{{60, 95}, {221, 174, 0}} ,{{27, 95}, {188, 174, 0}} ,{{44, 95}, {205, 174, 0}} ,{{45, 95}, {206, 174, 0}} ,{{50, 95}, {211, 174, 0}} ,{{34, 95}, {195, 174, 0}} ,{{28, 95}, {189, 174, 0}} ,{{29, 95}, {190, 174, 0}} ,{{30, 95}, {191, 174, 0}} ,{{54, 95}, {215, 174, 0}} ,{{49, 95}, {210, 174, 0}} ,{{51, 95}, {212, 174, 0}} ,{{35, 95}, {196, 174, 0}} ,{{38, 95}, {199, 174, 0}} ,{{36, 95}, {197, 174, 0}} ,{{42, 95}, {203, 174, 0}} ,{{37, 95}, {198, 174, 0}} ,{{41, 95}, {202, 174, 0}} ,{{39, 95}, {200, 174, 0}} ,{{40, 95}, {201, 174, 0}} ,{{43, 95}, {204, 174, 0}} ,{{31, 95}, {192, 174, 0}} ,{{48, 95}, {209, 174, 0}} ,{{33, 95}, {194, 174, 0}} ,{{32, 95}, {193, 174, 0}} ,{{53, 95}, {214, 174, 0}} ,{{46, 95}, {207, 174, 0}} ,{{47, 95}, {208, 174, 0}} ,{{52, 95}, {213, 174, 0}} ,{{81, 95}, {242, 174, 0}} ,{{74, 95}, {235, 174, 0}} ,{{75, 95}, {236, 174, 0}} ,{{80, 95}, {241, 174, 0}} ,{{163, 96}, {68, 176, 0}} ,{{180, 96}, {85, 176, 0}} ,{{181, 96}, {86, 176, 0}} ,{{186, 96}, {91, 176, 0}} ,{{170, 96}, {75, 176, 0}} ,{{164, 96}, {69, 176, 0}} ,{{165, 96}, {70, 176, 0}} ,{{166, 96}, {71, 176, 0}} ,{{190, 96}, {95, 176, 0}} ,{{185, 96}, {90, 176, 0}} ,{{187, 96}, {92, 176, 0}} ,{{171, 96}, {76, 176, 0}} ,{{174, 96}, {79, 176, 0}} ,{{172, 96}, {77, 176, 0}} ,{{178, 96}, {83, 176, 0}} ,{{173, 96}, {78, 176, 0}} ,{{177, 96}, {82, 176, 0}} ,{{175, 96}, {80, 176, 0}} ,{{176, 96}, {81, 176, 0}} ,{{179, 96}, {84, 176, 0}} ,{{167, 96}, {72, 176, 0}} ,{{184, 96}, {89, 176, 0}} ,{{169, 96}, {74, 176, 0}} ,{{168, 96}, {73, 176, 0}} ,{{189, 96}, {94, 176, 0}} ,{{182, 96}, {87, 176, 0}} ,{{183, 96}, {88, 176, 0}} ,{{188, 96}, {93, 176, 0}} ,{{219, 96}, {124, 176, 0}} ,{{236, 96}, {141, 176, 0}} ,{{237, 96}, {142, 176, 0}} ,{{242, 96}, {147, 176, 0}} ,{{226, 96}, {131, 176, 0}} ,{{220, 96}, {125, 176, 0}} ,{{221, 96}, {126, 176, 0}} ,{{222, 96}, {127, 176, 0}} ,{{246, 96}, {151, 176, 0}} ,{{241, 96}, {146, 176, 0}} ,{{243, 96}, {148, 176, 0}} ,{{227, 96}, {132, 176, 0}} ,{{230, 96}, {135, 176, 0}} ,{{228, 96}, {133, 176, 0}} ,{{234, 96}, {139, 176, 0}} ,{{229, 96}, {134, 176, 0}} ,{{233, 96}, {138, 176, 0}} ,{{231, 96}, {136, 176, 0}} ,{{232, 96}, {137, 176, 0}} ,{{235, 96}, {140, 176, 0}} ,{{223, 96}, {128, 176, 0}} ,{{240, 96}, {145, 176, 0}} ,{{225, 96}, {130, 176, 0}} ,{{224, 96}, {129, 176, 0}} ,{{245, 96}, {150, 176, 0}} ,{{238, 96}, {143, 176, 0}} ,{{239, 96}, {144, 176, 0}} ,{{244, 96}, {149, 176, 0}} ,{{139, 95}, {44, 175, 0}} ,{{156, 95}, {61, 175, 0}} ,{{157, 95}, {62, 175, 0}} ,{{162, 95}, {67, 175, 0}} ,{{146, 95}, {51, 175, 0}} ,{{223, 95}, {128, 175, 0}} ,{{240, 95}, {145, 175, 0}} ,{{241, 95}, {146, 175, 0}} ,{{246, 95}, {151, 175, 0}} ,{{230, 95}, {135, 175, 0}} ,{{224, 95}, {129, 175, 0}} ,{{225, 95}, {130, 175, 0}} ,{{226, 95}, {131, 175, 0}} ,{{250, 95}, {155, 175, 0}} ,{{245, 95}, {150, 175, 0}} ,{{247, 95}, {152, 175, 0}} ,{{231, 95}, {136, 175, 0}} ,{{234, 95}, {139, 175, 0}} ,{{232, 95}, {137, 175, 0}} ,{{238, 95}, {143, 175, 0}} ,{{233, 95}, {138, 175, 0}} ,{{237, 95}, {142, 175, 0}} ,{{235, 95}, {140, 175, 0}} ,{{236, 95}, {141, 175, 0}} ,{{239, 95}, {144, 175, 0}} ,{{227, 95}, {132, 175, 0}} ,{{244, 95}, {149, 175, 0}} ,{{229, 95}, {134, 175, 0}} ,{{228, 95}, {133, 175, 0}} ,{{249, 95}, {154, 175, 0}} ,{{242, 95}, {147, 175, 0}} ,{{243, 95}, {148, 175, 0}} ,{{248, 95}, {153, 175, 0}} ,{{140, 95}, {45, 175, 0}} ,{{141, 95}, {46, 175, 0}} ,{{142, 95}, {47, 175, 0}} ,{{166, 95}, {71, 175, 0}} ,{{161, 95}, {66, 175, 0}} ,{{163, 95}, {68, 175, 0}} ,{{147, 95}, {52, 175, 0}} ,{{150, 95}, {55, 175, 0}} ,{{148, 95}, {53, 175, 0}} ,{{154, 95}, {59, 175, 0}} ,{{149, 95}, {54, 175, 0}} ,{{153, 95}, {58, 175, 0}} ,{{151, 95}, {56, 175, 0}} ,{{152, 95}, {57, 175, 0}} ,{{155, 95}, {60, 175, 0}} ,{{143, 95}, {48, 175, 0}} ,{{160, 95}, {65, 175, 0}} ,{{145, 95}, {50, 175, 0}} ,{{144, 95}, {49, 175, 0}} ,{{165, 95}, {70, 175, 0}} ,{{158, 95}, {63, 175, 0}} ,{{159, 95}, {64, 175, 0}} ,{{164, 95}, {69, 175, 0}} ,{{23, 96}, {184, 175, 0}} ,{{40, 96}, {201, 175, 0}} ,{{41, 96}, {202, 175, 0}} ,{{46, 96}, {207, 175, 0}} ,{{30, 96}, {191, 175, 0}} ,{{24, 96}, {185, 175, 0}} ,{{25, 96}, {186, 175, 0}} ,{{26, 96}, {187, 175, 0}} ,{{50, 96}, {211, 175, 0}} ,{{45, 96}, {206, 175, 0}} ,{{47, 96}, {208, 175, 0}} ,{{31, 96}, {192, 175, 0}} ,{{34, 96}, {195, 175, 0}} ,{{32, 96}, {193, 175, 0}} ,{{38, 96}, {199, 175, 0}} ,{{33, 96}, {194, 175, 0}} ,{{37, 96}, {198, 175, 0}} ,{{35, 96}, {196, 175, 0}} ,{{36, 96}, {197, 175, 0}} ,{{39, 96}, {200, 175, 0}} ,{{27, 96}, {188, 175, 0}} ,{{44, 96}, {205, 175, 0}} ,{{29, 96}, {190, 175, 0}} ,{{28, 96}, {189, 175, 0}} ,{{49, 96}, {210, 175, 0}} ,{{42, 96}, {203, 175, 0}} ,{{43, 96}, {204, 175, 0}} ,{{48, 96}, {209, 175, 0}} ,{{167, 95}, {72, 175, 0}} ,{{184, 95}, {89, 175, 0}} ,{{185, 95}, {90, 175, 0}} ,{{190, 95}, {95, 175, 0}} ,{{174, 95}, {79, 175, 0}} ,{{195, 95}, {100, 175, 0}} ,{{212, 95}, {117, 175, 0}} ,{{213, 95}, {118, 175, 0}} ,{{218, 95}, {123, 175, 0}} ,{{202, 95}, {107, 175, 0}} ,{{196, 95}, {101, 175, 0}} ,{{197, 95}, {102, 175, 0}} ,{{198, 95}, {103, 175, 0}} ,{{222, 95}, {127, 175, 0}} ,{{217, 95}, {122, 175, 0}} ,{{219, 95}, {124, 175, 0}} ,{{203, 95}, {108, 175, 0}} ,{{206, 95}, {111, 175, 0}} ,{{204, 95}, {109, 175, 0}} ,{{210, 95}, {115, 175, 0}} ,{{205, 95}, {110, 175, 0}} ,{{209, 95}, {114, 175, 0}} ,{{207, 95}, {112, 175, 0}} ,{{208, 95}, {113, 175, 0}} ,{{211, 95}, {116, 175, 0}} ,{{199, 95}, {104, 175, 0}} ,{{216, 95}, {121, 175, 0}} ,{{201, 95}, {106, 175, 0}} ,{{200, 95}, {105, 175, 0}} ,{{221, 95}, {126, 175, 0}} ,{{214, 95}, {119, 175, 0}} ,{{215, 95}, {120, 175, 0}} ,{{220, 95}, {125, 175, 0}} ,{{168, 95}, {73, 175, 0}} ,{{169, 95}, {74, 175, 0}} ,{{170, 95}, {75, 175, 0}} ,{{194, 95}, {99, 175, 0}} ,{{189, 95}, {94, 175, 0}} ,{{191, 95}, {96, 175, 0}} ,{{175, 95}, {80, 175, 0}} ,{{178, 95}, {83, 175, 0}} ,{{176, 95}, {81, 175, 0}} ,{{182, 95}, {87, 175, 0}} ,{{177, 95}, {82, 175, 0}} ,{{181, 95}, {86, 175, 0}} ,{{179, 95}, {84, 175, 0}} ,{{180, 95}, {85, 175, 0}} ,{{183, 95}, {88, 175, 0}} ,{{171, 95}, {76, 175, 0}} ,{{188, 95}, {93, 175, 0}} ,{{173, 95}, {78, 175, 0}} ,{{172, 95}, {77, 175, 0}} ,{{193, 95}, {98, 175, 0}} ,{{186, 95}, {91, 175, 0}} ,{{187, 95}, {92, 175, 0}} ,{{192, 95}, {97, 175, 0}} ,{{79, 96}, {240, 175, 0}} ,{{96, 96}, {1, 176, 0}} ,{{97, 96}, {2, 176, 0}} ,{{102, 96}, {7, 176, 0}} ,{{86, 96}, {247, 175, 0}} ,{{80, 96}, {241, 175, 0}} ,{{81, 96}, {242, 175, 0}} ,{{82, 96}, {243, 175, 0}} ,{{106, 96}, {11, 176, 0}} ,{{101, 96}, {6, 176, 0}} ,{{103, 96}, {8, 176, 0}} ,{{87, 96}, {248, 175, 0}} ,{{90, 96}, {251, 175, 0}} ,{{88, 96}, {249, 175, 0}} ,{{94, 96}, {255, 175, 0}} ,{{89, 96}, {250, 175, 0}} ,{{93, 96}, {254, 175, 0}} ,{{91, 96}, {252, 175, 0}} ,{{92, 96}, {253, 175, 0}} ,{{95, 96}, {0, 176, 0}} ,{{83, 96}, {244, 175, 0}} ,{{100, 96}, {5, 176, 0}} ,{{85, 96}, {246, 175, 0}} ,{{84, 96}, {245, 175, 0}} ,{{51, 96}, {212, 175, 0}} ,{{68, 96}, {229, 175, 0}} ,{{69, 96}, {230, 175, 0}} ,{{74, 96}, {235, 175, 0}} ,{{58, 96}, {219, 175, 0}} ,{{52, 96}, {213, 175, 0}} ,{{53, 96}, {214, 175, 0}} ,{{54, 96}, {215, 175, 0}} ,{{78, 96}, {239, 175, 0}} ,{{73, 96}, {234, 175, 0}} ,{{75, 96}, {236, 175, 0}} ,{{59, 96}, {220, 175, 0}} ,{{62, 96}, {223, 175, 0}} ,{{60, 96}, {221, 175, 0}} ,{{66, 96}, {227, 175, 0}} ,{{61, 96}, {222, 175, 0}} ,{{65, 96}, {226, 175, 0}} ,{{63, 96}, {224, 175, 0}} ,{{64, 96}, {225, 175, 0}} ,{{67, 96}, {228, 175, 0}} ,{{55, 96}, {216, 175, 0}} ,{{72, 96}, {233, 175, 0}} ,{{57, 96}, {218, 175, 0}} ,{{56, 96}, {217, 175, 0}} ,{{77, 96}, {238, 175, 0}} ,{{70, 96}, {231, 175, 0}} ,{{71, 96}, {232, 175, 0}} ,{{76, 96}, {237, 175, 0}} ,{{105, 96}, {10, 176, 0}} ,{{98, 96}, {3, 176, 0}} ,{{99, 96}, {4, 176, 0}} ,{{104, 96}, {9, 176, 0}} ,{{107, 96}, {12, 176, 0}} ,{{124, 96}, {29, 176, 0}} ,{{125, 96}, {30, 176, 0}} ,{{130, 96}, {35, 176, 0}} ,{{114, 96}, {19, 176, 0}} ,{{108, 96}, {13, 176, 0}} ,{{109, 96}, {14, 176, 0}} ,{{110, 96}, {15, 176, 0}} ,{{134, 96}, {39, 176, 0}} ,{{129, 96}, {34, 176, 0}} ,{{131, 96}, {36, 176, 0}} ,{{115, 96}, {20, 176, 0}} ,{{118, 96}, {23, 176, 0}} ,{{116, 96}, {21, 176, 0}} ,{{122, 96}, {27, 176, 0}} ,{{117, 96}, {22, 176, 0}} ,{{121, 96}, {26, 176, 0}} ,{{119, 96}, {24, 176, 0}} ,{{120, 96}, {25, 176, 0}} ,{{123, 96}, {28, 176, 0}} ,{{111, 96}, {16, 176, 0}} ,{{128, 96}, {33, 176, 0}} ,{{113, 96}, {18, 176, 0}} ,{{112, 96}, {17, 176, 0}} ,{{133, 96}, {38, 176, 0}} ,{{126, 96}, {31, 176, 0}} ,{{127, 96}, {32, 176, 0}} ,{{132, 96}, {37, 176, 0}} ,{{227, 94}, {132, 174, 0}} ,{{244, 94}, {149, 174, 0}} ,{{245, 94}, {150, 174, 0}} ,{{250, 94}, {155, 174, 0}} ,{{234, 94}, {139, 174, 0}} ,{{255, 94}, {160, 174, 0}} ,{{16, 95}, {177, 174, 0}} ,{{17, 95}, {178, 174, 0}} ,{{22, 95}, {183, 174, 0}} ,{{6, 95}, {167, 174, 0}} ,{{0, 95}, {161, 174, 0}} ,{{1, 95}, {162, 174, 0}} ,{{2, 95}, {163, 174, 0}} ,{{26, 95}, {187, 174, 0}} ,{{21, 95}, {182, 174, 0}} ,{{23, 95}, {184, 174, 0}} ,{{7, 95}, {168, 174, 0}} ,{{10, 95}, {171, 174, 0}} ,{{8, 95}, {169, 174, 0}} ,{{14, 95}, {175, 174, 0}} ,{{9, 95}, {170, 174, 0}} ,{{13, 95}, {174, 174, 0}} ,{{11, 95}, {172, 174, 0}} ,{{12, 95}, {173, 174, 0}} ,{{15, 95}, {176, 174, 0}} ,{{3, 95}, {164, 174, 0}} ,{{20, 95}, {181, 174, 0}} ,{{5, 95}, {166, 174, 0}} ,{{4, 95}, {165, 174, 0}} ,{{25, 95}, {186, 174, 0}} ,{{18, 95}, {179, 174, 0}} ,{{19, 95}, {180, 174, 0}} ,{{24, 95}, {185, 174, 0}} ,{{228, 94}, {133, 174, 0}} ,{{229, 94}, {134, 174, 0}} ,{{230, 94}, {135, 174, 0}} ,{{254, 94}, {159, 174, 0}} ,{{249, 94}, {154, 174, 0}} ,{{251, 94}, {156, 174, 0}} ,{{235, 94}, {140, 174, 0}} ,{{238, 94}, {143, 174, 0}} ,{{236, 94}, {141, 174, 0}} ,{{242, 94}, {147, 174, 0}} ,{{237, 94}, {142, 174, 0}} ,{{241, 94}, {146, 174, 0}} ,{{239, 94}, {144, 174, 0}} ,{{240, 94}, {145, 174, 0}} ,{{243, 94}, {148, 174, 0}} ,{{231, 94}, {136, 174, 0}} ,{{248, 94}, {153, 174, 0}} ,{{233, 94}, {138, 174, 0}} ,{{232, 94}, {137, 174, 0}} ,{{253, 94}, {158, 174, 0}} ,{{246, 94}, {151, 174, 0}} ,{{247, 94}, {152, 174, 0}} ,{{252, 94}, {157, 174, 0}} ,{{111, 95}, {16, 175, 0}} ,{{128, 95}, {33, 175, 0}} ,{{129, 95}, {34, 175, 0}} ,{{134, 95}, {39, 175, 0}} ,{{118, 95}, {23, 175, 0}} ,{{112, 95}, {17, 175, 0}} ,{{113, 95}, {18, 175, 0}} ,{{114, 95}, {19, 175, 0}} ,{{138, 95}, {43, 175, 0}} ,{{133, 95}, {38, 175, 0}} ,{{135, 95}, {40, 175, 0}} ,{{119, 95}, {24, 175, 0}} ,{{122, 95}, {27, 175, 0}} ,{{120, 95}, {25, 175, 0}} ,{{126, 95}, {31, 175, 0}} ,{{121, 95}, {26, 175, 0}} ,{{125, 95}, {30, 175, 0}} ,{{123, 95}, {28, 175, 0}} ,{{124, 95}, {29, 175, 0}} ,{{127, 95}, {32, 175, 0}} ,{{115, 95}, {20, 175, 0}} ,{{132, 95}, {37, 175, 0}} ,{{117, 95}, {22, 175, 0}} ,{{116, 95}, {21, 175, 0}} ,{{83, 95}, {244, 174, 0}} ,{{100, 95}, {5, 175, 0}} ,{{101, 95}, {6, 175, 0}} ,{{106, 95}, {11, 175, 0}} ,{{90, 95}, {251, 174, 0}} ,{{84, 95}, {245, 174, 0}} ,{{85, 95}, {246, 174, 0}} ,{{86, 95}, {247, 174, 0}} ,{{110, 95}, {15, 175, 0}} ,{{105, 95}, {10, 175, 0}} ,{{107, 95}, {12, 175, 0}} ,{{91, 95}, {252, 174, 0}} ,{{94, 95}, {255, 174, 0}} ,{{92, 95}, {253, 174, 0}} ,{{98, 95}, {3, 175, 0}} ,{{93, 95}, {254, 174, 0}} ,{{97, 95}, {2, 175, 0}} ,{{95, 95}, {0, 175, 0}} ,{{96, 95}, {1, 175, 0}} ,{{99, 95}, {4, 175, 0}} ,{{87, 95}, {248, 174, 0}} ,{{104, 95}, {9, 175, 0}} ,{{89, 95}, {250, 174, 0}} ,{{88, 95}, {249, 174, 0}} ,{{109, 95}, {14, 175, 0}} ,{{102, 95}, {7, 175, 0}} ,{{103, 95}, {8, 175, 0}} ,{{108, 95}, {13, 175, 0}} ,{{137, 95}, {42, 175, 0}} ,{{130, 95}, {35, 175, 0}} ,{{131, 95}, {36, 175, 0}} ,{{136, 95}, {41, 175, 0}} ,{{191, 96}, {96, 176, 0}} ,{{208, 96}, {113, 176, 0}} ,{{209, 96}, {114, 176, 0}} ,{{214, 96}, {119, 176, 0}} ,{{198, 96}, {103, 176, 0}} ,{{192, 96}, {97, 176, 0}} ,{{193, 96}, {98, 176, 0}} ,{{194, 96}, {99, 176, 0}} ,{{218, 96}, {123, 176, 0}} ,{{213, 96}, {118, 176, 0}} ,{{215, 96}, {120, 176, 0}} ,{{199, 96}, {104, 176, 0}} ,{{202, 96}, {107, 176, 0}} ,{{200, 96}, {105, 176, 0}} ,{{206, 96}, {111, 176, 0}} ,{{201, 96}, {106, 176, 0}} ,{{205, 96}, {110, 176, 0}} ,{{203, 96}, {108, 176, 0}} ,{{204, 96}, {109, 176, 0}} ,{{207, 96}, {112, 176, 0}} ,{{195, 96}, {100, 176, 0}} ,{{212, 96}, {117, 176, 0}} ,{{197, 96}, {102, 176, 0}} ,{{196, 96}, {101, 176, 0}} ,{{217, 96}, {122, 176, 0}} ,{{210, 96}, {115, 176, 0}} ,{{211, 96}, {116, 176, 0}} ,{{216, 96}, {121, 176, 0}} ,{{251, 95}, {156, 175, 0}} ,{{12, 96}, {173, 175, 0}} ,{{13, 96}, {174, 175, 0}} ,{{18, 96}, {179, 175, 0}} ,{{2, 96}, {163, 175, 0}} ,{{252, 95}, {157, 175, 0}} ,{{253, 95}, {158, 175, 0}} ,{{254, 95}, {159, 175, 0}} ,{{22, 96}, {183, 175, 0}} ,{{17, 96}, {178, 175, 0}} ,{{19, 96}, {180, 175, 0}} ,{{3, 96}, {164, 175, 0}} ,{{6, 96}, {167, 175, 0}} ,{{4, 96}, {165, 175, 0}} ,{{10, 96}, {171, 175, 0}} ,{{5, 96}, {166, 175, 0}} ,{{9, 96}, {170, 175, 0}} ,{{7, 96}, {168, 175, 0}} ,{{8, 96}, {169, 175, 0}} ,{{11, 96}, {172, 175, 0}} ,{{255, 95}, {160, 175, 0}} ,{{16, 96}, {177, 175, 0}} ,{{1, 96}, {162, 175, 0}} ,{{0, 96}, {161, 175, 0}} ,{{21, 96}, {182, 175, 0}} ,{{14, 96}, {175, 175, 0}} ,{{15, 96}, {176, 175, 0}} ,{{20, 96}, {181, 175, 0}} ,{{135, 96}, {40, 176, 0}} ,{{152, 96}, {57, 176, 0}} ,{{153, 96}, {58, 176, 0}} ,{{158, 96}, {63, 176, 0}} ,{{142, 96}, {47, 176, 0}} ,{{136, 96}, {41, 176, 0}} ,{{137, 96}, {42, 176, 0}} ,{{138, 96}, {43, 176, 0}} ,{{162, 96}, {67, 176, 0}} ,{{157, 96}, {62, 176, 0}} ,{{159, 96}, {64, 176, 0}} ,{{143, 96}, {48, 176, 0}} ,{{146, 96}, {51, 176, 0}} ,{{144, 96}, {49, 176, 0}} ,{{150, 96}, {55, 176, 0}} ,{{145, 96}, {50, 176, 0}} ,{{149, 96}, {54, 176, 0}} ,{{147, 96}, {52, 176, 0}} ,{{148, 96}, {53, 176, 0}} ,{{151, 96}, {56, 176, 0}} ,{{139, 96}, {44, 176, 0}} ,{{156, 96}, {61, 176, 0}} ,{{141, 96}, {46, 176, 0}} ,{{140, 96}, {45, 176, 0}} ,{{161, 96}, {66, 176, 0}} ,{{154, 96}, {59, 176, 0}} ,{{155, 96}, {60, 176, 0}} ,{{160, 96}, {65, 176, 0}} ,{{143, 94}, {48, 174, 0}} ,{{160, 94}, {65, 174, 0}} ,{{161, 94}, {66, 174, 0}} ,{{166, 94}, {71, 174, 0}} ,{{150, 94}, {55, 174, 0}} ,{{144, 94}, {49, 174, 0}} ,{{145, 94}, {50, 174, 0}} ,{{146, 94}, {51, 174, 0}} ,{{170, 94}, {75, 174, 0}} ,{{165, 94}, {70, 174, 0}} ,{{167, 94}, {72, 174, 0}} ,{{151, 94}, {56, 174, 0}} ,{{154, 94}, {59, 174, 0}} ,{{152, 94}, {57, 174, 0}} ,{{158, 94}, {63, 174, 0}} ,{{153, 94}, {58, 174, 0}} ,{{157, 94}, {62, 174, 0}} ,{{155, 94}, {60, 174, 0}} ,{{156, 94}, {61, 174, 0}} ,{{159, 94}, {64, 174, 0}} ,{{147, 94}, {52, 174, 0}} ,{{164, 94}, {69, 174, 0}} ,{{149, 94}, {54, 174, 0}} ,{{148, 94}, {53, 174, 0}} ,{{169, 94}, {74, 174, 0}} ,{{162, 94}, {67, 174, 0}} ,{{163, 94}, {68, 174, 0}} ,{{168, 94}, {73, 174, 0}} ,{{63, 93}, {224, 172, 0}} ,{{80, 93}, {241, 172, 0}} ,{{81, 93}, {242, 172, 0}} ,{{86, 93}, {247, 172, 0}} ,{{70, 93}, {231, 172, 0}} ,{{147, 93}, {52, 173, 0}} ,{{164, 93}, {69, 173, 0}} ,{{165, 93}, {70, 173, 0}} ,{{170, 93}, {75, 173, 0}} ,{{154, 93}, {59, 173, 0}} ,{{148, 93}, {53, 173, 0}} ,{{149, 93}, {54, 173, 0}} ,{{150, 93}, {55, 173, 0}} ,{{174, 93}, {79, 173, 0}} ,{{169, 93}, {74, 173, 0}} ,{{171, 93}, {76, 173, 0}} ,{{155, 93}, {60, 173, 0}} ,{{158, 93}, {63, 173, 0}} ,{{156, 93}, {61, 173, 0}} ,{{162, 93}, {67, 173, 0}} ,{{157, 93}, {62, 173, 0}} ,{{161, 93}, {66, 173, 0}} ,{{159, 93}, {64, 173, 0}} ,{{160, 93}, {65, 173, 0}} ,{{163, 93}, {68, 173, 0}} ,{{151, 93}, {56, 173, 0}} ,{{168, 93}, {73, 173, 0}} ,{{153, 93}, {58, 173, 0}} ,{{152, 93}, {57, 173, 0}} ,{{173, 93}, {78, 173, 0}} ,{{166, 93}, {71, 173, 0}} ,{{167, 93}, {72, 173, 0}} ,{{172, 93}, {77, 173, 0}} ,{{64, 93}, {225, 172, 0}} ,{{65, 93}, {226, 172, 0}} ,{{66, 93}, {227, 172, 0}} ,{{90, 93}, {251, 172, 0}} ,{{85, 93}, {246, 172, 0}} ,{{87, 93}, {248, 172, 0}} ,{{71, 93}, {232, 172, 0}} ,{{74, 93}, {235, 172, 0}} ,{{72, 93}, {233, 172, 0}} ,{{78, 93}, {239, 172, 0}} ,{{73, 93}, {234, 172, 0}} ,{{77, 93}, {238, 172, 0}} ,{{75, 93}, {236, 172, 0}} ,{{76, 93}, {237, 172, 0}} ,{{79, 93}, {240, 172, 0}} ,{{67, 93}, {228, 172, 0}} ,{{84, 93}, {245, 172, 0}} ,{{69, 93}, {230, 172, 0}} ,{{68, 93}, {229, 172, 0}} ,{{89, 93}, {250, 172, 0}} ,{{82, 93}, {243, 172, 0}} ,{{83, 93}, {244, 172, 0}} ,{{88, 93}, {249, 172, 0}} ,{{203, 93}, {108, 173, 0}} ,{{220, 93}, {125, 173, 0}} ,{{221, 93}, {126, 173, 0}} ,{{226, 93}, {131, 173, 0}} ,{{210, 93}, {115, 173, 0}} ,{{204, 93}, {109, 173, 0}} ,{{205, 93}, {110, 173, 0}} ,{{206, 93}, {111, 173, 0}} ,{{230, 93}, {135, 173, 0}} ,{{225, 93}, {130, 173, 0}} ,{{227, 93}, {132, 173, 0}} ,{{211, 93}, {116, 173, 0}} ,{{214, 93}, {119, 173, 0}} ,{{212, 93}, {117, 173, 0}} ,{{218, 93}, {123, 173, 0}} ,{{213, 93}, {118, 173, 0}} ,{{217, 93}, {122, 173, 0}} ,{{215, 93}, {120, 173, 0}} ,{{216, 93}, {121, 173, 0}} ,{{219, 93}, {124, 173, 0}} ,{{207, 93}, {112, 173, 0}} ,{{224, 93}, {129, 173, 0}} ,{{209, 93}, {114, 173, 0}} ,{{208, 93}, {113, 173, 0}} ,{{229, 93}, {134, 173, 0}} ,{{222, 93}, {127, 173, 0}} ,{{223, 93}, {128, 173, 0}} ,{{228, 93}, {133, 173, 0}} ,{{91, 93}, {252, 172, 0}} ,{{108, 93}, {13, 173, 0}} ,{{109, 93}, {14, 173, 0}} ,{{114, 93}, {19, 173, 0}} ,{{98, 93}, {3, 173, 0}} ,{{119, 93}, {24, 173, 0}} ,{{136, 93}, {41, 173, 0}} ,{{137, 93}, {42, 173, 0}} ,{{142, 93}, {47, 173, 0}} ,{{126, 93}, {31, 173, 0}} ,{{120, 93}, {25, 173, 0}} ,{{121, 93}, {26, 173, 0}} ,{{122, 93}, {27, 173, 0}} ,{{146, 93}, {51, 173, 0}} ,{{141, 93}, {46, 173, 0}} ,{{143, 93}, {48, 173, 0}} ,{{127, 93}, {32, 173, 0}} ,{{130, 93}, {35, 173, 0}} ,{{128, 93}, {33, 173, 0}} ,{{134, 93}, {39, 173, 0}} ,{{129, 93}, {34, 173, 0}} ,{{133, 93}, {38, 173, 0}} ,{{131, 93}, {36, 173, 0}} ,{{132, 93}, {37, 173, 0}} ,{{135, 93}, {40, 173, 0}} ,{{123, 93}, {28, 173, 0}} ,{{140, 93}, {45, 173, 0}} ,{{125, 93}, {30, 173, 0}} ,{{124, 93}, {29, 173, 0}} ,{{145, 93}, {50, 173, 0}} ,{{138, 93}, {43, 173, 0}} ,{{139, 93}, {44, 173, 0}} ,{{144, 93}, {49, 173, 0}} ,{{92, 93}, {253, 172, 0}} ,{{93, 93}, {254, 172, 0}} ,{{94, 93}, {255, 172, 0}} ,{{118, 93}, {23, 173, 0}} ,{{113, 93}, {18, 173, 0}} ,{{115, 93}, {20, 173, 0}} ,{{99, 93}, {4, 173, 0}} ,{{102, 93}, {7, 173, 0}} ,{{100, 93}, {5, 173, 0}} ,{{106, 93}, {11, 173, 0}} ,{{101, 93}, {6, 173, 0}} ,{{105, 93}, {10, 173, 0}} ,{{103, 93}, {8, 173, 0}} ,{{104, 93}, {9, 173, 0}} ,{{107, 93}, {12, 173, 0}} ,{{95, 93}, {0, 173, 0}} ,{{112, 93}, {17, 173, 0}} ,{{97, 93}, {2, 173, 0}} ,{{96, 93}, {1, 173, 0}} ,{{117, 93}, {22, 173, 0}} ,{{110, 93}, {15, 173, 0}} ,{{111, 93}, {16, 173, 0}} ,{{116, 93}, {21, 173, 0}} ,{{3, 94}, {164, 173, 0}} ,{{20, 94}, {181, 173, 0}} ,{{21, 94}, {182, 173, 0}} ,{{26, 94}, {187, 173, 0}} ,{{10, 94}, {171, 173, 0}} ,{{4, 94}, {165, 173, 0}} ,{{5, 94}, {166, 173, 0}} ,{{6, 94}, {167, 173, 0}} ,{{30, 94}, {191, 173, 0}} ,{{25, 94}, {186, 173, 0}} ,{{27, 94}, {188, 173, 0}} ,{{11, 94}, {172, 173, 0}} ,{{14, 94}, {175, 173, 0}} ,{{12, 94}, {173, 173, 0}} ,{{18, 94}, {179, 173, 0}} ,{{13, 94}, {174, 173, 0}} ,{{17, 94}, {178, 173, 0}} ,{{15, 94}, {176, 173, 0}} ,{{16, 94}, {177, 173, 0}} ,{{19, 94}, {180, 173, 0}} ,{{7, 94}, {168, 173, 0}} ,{{24, 94}, {185, 173, 0}} ,{{9, 94}, {170, 173, 0}} ,{{8, 94}, {169, 173, 0}} ,{{231, 93}, {136, 173, 0}} ,{{248, 93}, {153, 173, 0}} ,{{249, 93}, {154, 173, 0}} ,{{254, 93}, {159, 173, 0}} ,{{238, 93}, {143, 173, 0}} ,{{232, 93}, {137, 173, 0}} ,{{233, 93}, {138, 173, 0}} ,{{234, 93}, {139, 173, 0}} ,{{2, 94}, {163, 173, 0}} ,{{253, 93}, {158, 173, 0}} ,{{255, 93}, {160, 173, 0}} ,{{239, 93}, {144, 173, 0}} ,{{242, 93}, {147, 173, 0}} ,{{240, 93}, {145, 173, 0}} ,{{246, 93}, {151, 173, 0}} ,{{241, 93}, {146, 173, 0}} ,{{245, 93}, {150, 173, 0}} ,{{243, 93}, {148, 173, 0}} ,{{244, 93}, {149, 173, 0}} ,{{247, 93}, {152, 173, 0}} ,{{235, 93}, {140, 173, 0}} ,{{252, 93}, {157, 173, 0}} ,{{237, 93}, {142, 173, 0}} ,{{236, 93}, {141, 173, 0}} ,{{1, 94}, {162, 173, 0}} ,{{250, 93}, {155, 173, 0}} ,{{251, 93}, {156, 173, 0}} ,{{0, 94}, {161, 173, 0}} ,{{29, 94}, {190, 173, 0}} ,{{22, 94}, {183, 173, 0}} ,{{23, 94}, {184, 173, 0}} ,{{28, 94}, {189, 173, 0}} ,{{31, 94}, {192, 173, 0}} ,{{48, 94}, {209, 173, 0}} ,{{49, 94}, {210, 173, 0}} ,{{54, 94}, {215, 173, 0}} ,{{38, 94}, {199, 173, 0}} ,{{32, 94}, {193, 173, 0}} ,{{33, 94}, {194, 173, 0}} ,{{34, 94}, {195, 173, 0}} ,{{58, 94}, {219, 173, 0}} ,{{53, 94}, {214, 173, 0}} ,{{55, 94}, {216, 173, 0}} ,{{39, 94}, {200, 173, 0}} ,{{42, 94}, {203, 173, 0}} ,{{40, 94}, {201, 173, 0}} ,{{46, 94}, {207, 173, 0}} ,{{41, 94}, {202, 173, 0}} ,{{45, 94}, {206, 173, 0}} ,{{43, 94}, {204, 173, 0}} ,{{44, 94}, {205, 173, 0}} ,{{47, 94}, {208, 173, 0}} ,{{35, 94}, {196, 173, 0}} ,{{52, 94}, {213, 173, 0}} ,{{37, 94}, {198, 173, 0}} ,{{36, 94}, {197, 173, 0}} ,{{57, 94}, {218, 173, 0}} ,{{50, 94}, {211, 173, 0}} ,{{51, 94}, {212, 173, 0}} ,{{56, 94}, {217, 173, 0}} ,{{151, 92}, {56, 172, 0}} ,{{168, 92}, {73, 172, 0}} ,{{169, 92}, {74, 172, 0}} ,{{174, 92}, {79, 172, 0}} ,{{158, 92}, {63, 172, 0}} ,{{179, 92}, {84, 172, 0}} ,{{196, 92}, {101, 172, 0}} ,{{197, 92}, {102, 172, 0}} ,{{202, 92}, {107, 172, 0}} ,{{186, 92}, {91, 172, 0}} ,{{180, 92}, {85, 172, 0}} ,{{181, 92}, {86, 172, 0}} ,{{182, 92}, {87, 172, 0}} ,{{206, 92}, {111, 172, 0}} ,{{201, 92}, {106, 172, 0}} ,{{203, 92}, {108, 172, 0}} ,{{187, 92}, {92, 172, 0}} ,{{190, 92}, {95, 172, 0}} ,{{188, 92}, {93, 172, 0}} ,{{194, 92}, {99, 172, 0}} ,{{189, 92}, {94, 172, 0}} ,{{193, 92}, {98, 172, 0}} ,{{191, 92}, {96, 172, 0}} ,{{192, 92}, {97, 172, 0}} ,{{195, 92}, {100, 172, 0}} ,{{183, 92}, {88, 172, 0}} ,{{200, 92}, {105, 172, 0}} ,{{185, 92}, {90, 172, 0}} ,{{184, 92}, {89, 172, 0}} ,{{205, 92}, {110, 172, 0}} ,{{198, 92}, {103, 172, 0}} ,{{199, 92}, {104, 172, 0}} ,{{204, 92}, {109, 172, 0}} ,{{152, 92}, {57, 172, 0}} ,{{153, 92}, {58, 172, 0}} ,{{154, 92}, {59, 172, 0}} ,{{178, 92}, {83, 172, 0}} ,{{173, 92}, {78, 172, 0}} ,{{175, 92}, {80, 172, 0}} ,{{159, 92}, {64, 172, 0}} ,{{162, 92}, {67, 172, 0}} ,{{160, 92}, {65, 172, 0}} ,{{166, 92}, {71, 172, 0}} ,{{161, 92}, {66, 172, 0}} ,{{165, 92}, {70, 172, 0}} ,{{163, 92}, {68, 172, 0}} ,{{164, 92}, {69, 172, 0}} ,{{167, 92}, {72, 172, 0}} ,{{155, 92}, {60, 172, 0}} ,{{172, 92}, {77, 172, 0}} ,{{157, 92}, {62, 172, 0}} ,{{156, 92}, {61, 172, 0}} ,{{177, 92}, {82, 172, 0}} ,{{170, 92}, {75, 172, 0}} ,{{171, 92}, {76, 172, 0}} ,{{176, 92}, {81, 172, 0}} ,{{35, 93}, {196, 172, 0}} ,{{52, 93}, {213, 172, 0}} ,{{53, 93}, {214, 172, 0}} ,{{58, 93}, {219, 172, 0}} ,{{42, 93}, {203, 172, 0}} ,{{36, 93}, {197, 172, 0}} ,{{37, 93}, {198, 172, 0}} ,{{38, 93}, {199, 172, 0}} ,{{62, 93}, {223, 172, 0}} ,{{57, 93}, {218, 172, 0}} ,{{59, 93}, {220, 172, 0}} ,{{43, 93}, {204, 172, 0}} ,{{46, 93}, {207, 172, 0}} ,{{44, 93}, {205, 172, 0}} ,{{50, 93}, {211, 172, 0}} ,{{45, 93}, {206, 172, 0}} ,{{49, 93}, {210, 172, 0}} ,{{47, 93}, {208, 172, 0}} ,{{48, 93}, {209, 172, 0}} ,{{51, 93}, {212, 172, 0}} ,{{39, 93}, {200, 172, 0}} ,{{56, 93}, {217, 172, 0}} ,{{41, 93}, {202, 172, 0}} ,{{40, 93}, {201, 172, 0}} ,{{7, 93}, {168, 172, 0}} ,{{24, 93}, {185, 172, 0}} ,{{25, 93}, {186, 172, 0}} ,{{30, 93}, {191, 172, 0}} ,{{14, 93}, {175, 172, 0}} ,{{8, 93}, {169, 172, 0}} ,{{9, 93}, {170, 172, 0}} ,{{10, 93}, {171, 172, 0}} ,{{34, 93}, {195, 172, 0}} ,{{29, 93}, {190, 172, 0}} ,{{31, 93}, {192, 172, 0}} ,{{15, 93}, {176, 172, 0}} ,{{18, 93}, {179, 172, 0}} ,{{16, 93}, {177, 172, 0}} ,{{22, 93}, {183, 172, 0}} ,{{17, 93}, {178, 172, 0}} ,{{21, 93}, {182, 172, 0}} ,{{19, 93}, {180, 172, 0}} ,{{20, 93}, {181, 172, 0}} ,{{23, 93}, {184, 172, 0}} ,{{11, 93}, {172, 172, 0}} ,{{28, 93}, {189, 172, 0}} ,{{13, 93}, {174, 172, 0}} ,{{12, 93}, {173, 172, 0}} ,{{33, 93}, {194, 172, 0}} ,{{26, 93}, {187, 172, 0}} ,{{27, 93}, {188, 172, 0}} ,{{32, 93}, {193, 172, 0}} ,{{61, 93}, {222, 172, 0}} ,{{54, 93}, {215, 172, 0}} ,{{55, 93}, {216, 172, 0}} ,{{60, 93}, {221, 172, 0}} ,{{115, 94}, {20, 174, 0}} ,{{132, 94}, {37, 174, 0}} ,{{133, 94}, {38, 174, 0}} ,{{138, 94}, {43, 174, 0}} ,{{122, 94}, {27, 174, 0}} ,{{116, 94}, {21, 174, 0}} ,{{117, 94}, {22, 174, 0}} ,{{118, 94}, {23, 174, 0}} ,{{142, 94}, {47, 174, 0}} ,{{137, 94}, {42, 174, 0}} ,{{139, 94}, {44, 174, 0}} ,{{123, 94}, {28, 174, 0}} ,{{126, 94}, {31, 174, 0}} ,{{124, 94}, {29, 174, 0}} ,{{130, 94}, {35, 174, 0}} ,{{125, 94}, {30, 174, 0}} ,{{129, 94}, {34, 174, 0}} ,{{127, 94}, {32, 174, 0}} ,{{128, 94}, {33, 174, 0}} ,{{131, 94}, {36, 174, 0}} ,{{119, 94}, {24, 174, 0}} ,{{136, 94}, {41, 174, 0}} ,{{121, 94}, {26, 174, 0}} ,{{120, 94}, {25, 174, 0}} ,{{141, 94}, {46, 174, 0}} ,{{134, 94}, {39, 174, 0}} ,{{135, 94}, {40, 174, 0}} ,{{140, 94}, {45, 174, 0}} ,{{175, 93}, {80, 173, 0}} ,{{192, 93}, {97, 173, 0}} ,{{193, 93}, {98, 173, 0}} ,{{198, 93}, {103, 173, 0}} ,{{182, 93}, {87, 173, 0}} ,{{176, 93}, {81, 173, 0}} ,{{177, 93}, {82, 173, 0}} ,{{178, 93}, {83, 173, 0}} ,{{202, 93}, {107, 173, 0}} ,{{197, 93}, {102, 173, 0}} ,{{199, 93}, {104, 173, 0}} ,{{183, 93}, {88, 173, 0}} ,{{186, 93}, {91, 173, 0}} ,{{184, 93}, {89, 173, 0}} ,{{190, 93}, {95, 173, 0}} ,{{185, 93}, {90, 173, 0}} ,{{189, 93}, {94, 173, 0}} ,{{187, 93}, {92, 173, 0}} ,{{188, 93}, {93, 173, 0}} ,{{191, 93}, {96, 173, 0}} ,{{179, 93}, {84, 173, 0}} ,{{196, 93}, {101, 173, 0}} ,{{181, 93}, {86, 173, 0}} ,{{180, 93}, {85, 173, 0}} ,{{201, 93}, {106, 173, 0}} ,{{194, 93}, {99, 173, 0}} ,{{195, 93}, {100, 173, 0}} ,{{200, 93}, {105, 173, 0}} ,{{59, 94}, {220, 173, 0}} ,{{76, 94}, {237, 173, 0}} ,{{77, 94}, {238, 173, 0}} ,{{82, 94}, {243, 173, 0}} ,{{66, 94}, {227, 173, 0}} ,{{60, 94}, {221, 173, 0}} ,{{61, 94}, {222, 173, 0}} ,{{62, 94}, {223, 173, 0}} ,{{86, 94}, {247, 173, 0}} ,{{81, 94}, {242, 173, 0}} ,{{83, 94}, {244, 173, 0}} ,{{67, 94}, {228, 173, 0}} ,{{70, 94}, {231, 173, 0}} ,{{68, 94}, {229, 173, 0}} ,{{74, 94}, {235, 173, 0}} ,{{69, 94}, {230, 173, 0}} ,{{73, 94}, {234, 173, 0}} ,{{71, 94}, {232, 173, 0}} ,{{72, 94}, {233, 173, 0}} ,{{75, 94}, {236, 173, 0}} ,{{63, 94}, {224, 173, 0}} ,{{80, 94}, {241, 173, 0}} ,{{65, 94}, {226, 173, 0}} ,{{64, 94}, {225, 173, 0}} ,{{85, 94}, {246, 173, 0}} ,{{78, 94}, {239, 173, 0}} ,{{79, 94}, {240, 173, 0}} ,{{84, 94}, {245, 173, 0}} ,{{183, 133}, {88, 213, 0}} ,{{200, 133}, {105, 213, 0}} ,{{201, 133}, {106, 213, 0}} ,{{206, 133}, {111, 213, 0}} ,{{190, 133}, {95, 213, 0}} ,{{211, 133}, {116, 213, 0}} ,{{228, 133}, {133, 213, 0}} ,{{229, 133}, {134, 213, 0}} ,{{234, 133}, {139, 213, 0}} ,{{218, 133}, {123, 213, 0}} ,{{212, 133}, {117, 213, 0}} ,{{213, 133}, {118, 213, 0}} ,{{214, 133}, {119, 213, 0}} ,{{238, 133}, {143, 213, 0}} ,{{233, 133}, {138, 213, 0}} ,{{235, 133}, {140, 213, 0}} ,{{219, 133}, {124, 213, 0}} ,{{222, 133}, {127, 213, 0}} ,{{220, 133}, {125, 213, 0}} ,{{226, 133}, {131, 213, 0}} ,{{221, 133}, {126, 213, 0}} ,{{225, 133}, {130, 213, 0}} ,{{223, 133}, {128, 213, 0}} ,{{224, 133}, {129, 213, 0}} ,{{227, 133}, {132, 213, 0}} ,{{215, 133}, {120, 213, 0}} ,{{232, 133}, {137, 213, 0}} ,{{217, 133}, {122, 213, 0}} ,{{216, 133}, {121, 213, 0}} ,{{237, 133}, {142, 213, 0}} ,{{230, 133}, {135, 213, 0}} ,{{231, 133}, {136, 213, 0}} ,{{236, 133}, {141, 213, 0}} ,{{184, 133}, {89, 213, 0}} ,{{185, 133}, {90, 213, 0}} ,{{186, 133}, {91, 213, 0}} ,{{210, 133}, {115, 213, 0}} ,{{205, 133}, {110, 213, 0}} ,{{207, 133}, {112, 213, 0}} ,{{191, 133}, {96, 213, 0}} ,{{194, 133}, {99, 213, 0}} ,{{192, 133}, {97, 213, 0}} ,{{198, 133}, {103, 213, 0}} ,{{193, 133}, {98, 213, 0}} ,{{197, 133}, {102, 213, 0}} ,{{195, 133}, {100, 213, 0}} ,{{196, 133}, {101, 213, 0}} ,{{199, 133}, {104, 213, 0}} ,{{187, 133}, {92, 213, 0}} ,{{204, 133}, {109, 213, 0}} ,{{189, 133}, {94, 213, 0}} ,{{188, 133}, {93, 213, 0}} ,{{209, 133}, {114, 213, 0}} ,{{202, 133}, {107, 213, 0}} ,{{203, 133}, {108, 213, 0}} ,{{208, 133}, {113, 213, 0}} ,{{67, 134}, {228, 213, 0}} ,{{84, 134}, {245, 213, 0}} ,{{85, 134}, {246, 213, 0}} ,{{90, 134}, {251, 213, 0}} ,{{74, 134}, {235, 213, 0}} ,{{68, 134}, {229, 213, 0}} ,{{69, 134}, {230, 213, 0}} ,{{70, 134}, {231, 213, 0}} ,{{94, 134}, {255, 213, 0}} ,{{89, 134}, {250, 213, 0}} ,{{91, 134}, {252, 213, 0}} ,{{75, 134}, {236, 213, 0}} ,{{78, 134}, {239, 213, 0}} ,{{76, 134}, {237, 213, 0}} ,{{82, 134}, {243, 213, 0}} ,{{77, 134}, {238, 213, 0}} ,{{81, 134}, {242, 213, 0}} ,{{79, 134}, {240, 213, 0}} ,{{80, 134}, {241, 213, 0}} ,{{83, 134}, {244, 213, 0}} ,{{71, 134}, {232, 213, 0}} ,{{88, 134}, {249, 213, 0}} ,{{73, 134}, {234, 213, 0}} ,{{72, 134}, {233, 213, 0}} ,{{39, 134}, {200, 213, 0}} ,{{56, 134}, {217, 213, 0}} ,{{57, 134}, {218, 213, 0}} ,{{62, 134}, {223, 213, 0}} ,{{46, 134}, {207, 213, 0}} ,{{40, 134}, {201, 213, 0}} ,{{41, 134}, {202, 213, 0}} ,{{42, 134}, {203, 213, 0}} ,{{66, 134}, {227, 213, 0}} ,{{61, 134}, {222, 213, 0}} ,{{63, 134}, {224, 213, 0}} ,{{47, 134}, {208, 213, 0}} ,{{50, 134}, {211, 213, 0}} ,{{48, 134}, {209, 213, 0}} ,{{54, 134}, {215, 213, 0}} ,{{49, 134}, {210, 213, 0}} ,{{53, 134}, {214, 213, 0}} ,{{51, 134}, {212, 213, 0}} ,{{52, 134}, {213, 213, 0}} ,{{55, 134}, {216, 213, 0}} ,{{43, 134}, {204, 213, 0}} ,{{60, 134}, {221, 213, 0}} ,{{45, 134}, {206, 213, 0}} ,{{44, 134}, {205, 213, 0}} ,{{65, 134}, {226, 213, 0}} ,{{58, 134}, {219, 213, 0}} ,{{59, 134}, {220, 213, 0}} ,{{64, 134}, {225, 213, 0}} ,{{93, 134}, {254, 213, 0}} ,{{86, 134}, {247, 213, 0}} ,{{87, 134}, {248, 213, 0}} ,{{92, 134}, {253, 213, 0}} ,{{175, 135}, {80, 215, 0}} ,{{192, 135}, {97, 215, 0}} ,{{193, 135}, {98, 215, 0}} ,{{198, 135}, {103, 215, 0}} ,{{182, 135}, {87, 215, 0}} ,{{176, 135}, {81, 215, 0}} ,{{177, 135}, {82, 215, 0}} ,{{178, 135}, {83, 215, 0}} ,{{202, 135}, {107, 215, 0}} ,{{197, 135}, {102, 215, 0}} ,{{199, 135}, {104, 215, 0}} ,{{183, 135}, {88, 215, 0}} ,{{186, 135}, {91, 215, 0}} ,{{184, 135}, {89, 215, 0}} ,{{190, 135}, {95, 215, 0}} ,{{185, 135}, {90, 215, 0}} ,{{189, 135}, {94, 215, 0}} ,{{187, 135}, {92, 215, 0}} ,{{188, 135}, {93, 215, 0}} ,{{191, 135}, {96, 215, 0}} ,{{179, 135}, {84, 215, 0}} ,{{196, 135}, {101, 215, 0}} ,{{181, 135}, {86, 215, 0}} ,{{180, 135}, {85, 215, 0}} ,{{201, 135}, {106, 215, 0}} ,{{194, 135}, {99, 215, 0}} ,{{195, 135}, {100, 215, 0}} ,{{200, 135}, {105, 215, 0}} ,{{231, 135}, {136, 215, 0}} ,{{248, 135}, {153, 215, 0}} ,{{249, 135}, {154, 215, 0}} ,{{254, 135}, {159, 215, 0}} ,{{238, 135}, {143, 215, 0}} ,{{232, 135}, {137, 215, 0}} ,{{233, 135}, {138, 215, 0}} ,{{234, 135}, {139, 215, 0}} ,{{2, 136}, {163, 215, 0}} ,{{253, 135}, {158, 215, 0}} ,{{255, 135}, {160, 215, 0}} ,{{239, 135}, {144, 215, 0}} ,{{242, 135}, {147, 215, 0}} ,{{240, 135}, {145, 215, 0}} ,{{246, 135}, {151, 215, 0}} ,{{241, 135}, {146, 215, 0}} ,{{245, 135}, {150, 215, 0}} ,{{243, 135}, {148, 215, 0}} ,{{244, 135}, {149, 215, 0}} ,{{247, 135}, {152, 215, 0}} ,{{235, 135}, {140, 215, 0}} ,{{252, 135}, {157, 215, 0}} ,{{237, 135}, {142, 215, 0}} ,{{236, 135}, {141, 215, 0}} ,{{1, 136}, {162, 215, 0}} ,{{250, 135}, {155, 215, 0}} ,{{251, 135}, {156, 215, 0}} ,{{0, 136}, {161, 215, 0}} ,{{151, 134}, {56, 214, 0}} ,{{168, 134}, {73, 214, 0}} ,{{169, 134}, {74, 214, 0}} ,{{174, 134}, {79, 214, 0}} ,{{158, 134}, {63, 214, 0}} ,{{235, 134}, {140, 214, 0}} ,{{252, 134}, {157, 214, 0}} ,{{253, 134}, {158, 214, 0}} ,{{2, 135}, {163, 214, 0}} ,{{242, 134}, {147, 214, 0}} ,{{236, 134}, {141, 214, 0}} ,{{237, 134}, {142, 214, 0}} ,{{238, 134}, {143, 214, 0}} ,{{6, 135}, {167, 214, 0}} ,{{1, 135}, {162, 214, 0}} ,{{3, 135}, {164, 214, 0}} ,{{243, 134}, {148, 214, 0}} ,{{246, 134}, {151, 214, 0}} ,{{244, 134}, {149, 214, 0}} ,{{250, 134}, {155, 214, 0}} ,{{245, 134}, {150, 214, 0}} ,{{249, 134}, {154, 214, 0}} ,{{247, 134}, {152, 214, 0}} ,{{248, 134}, {153, 214, 0}} ,{{251, 134}, {156, 214, 0}} ,{{239, 134}, {144, 214, 0}} ,{{0, 135}, {161, 214, 0}} ,{{241, 134}, {146, 214, 0}} ,{{240, 134}, {145, 214, 0}} ,{{5, 135}, {166, 214, 0}} ,{{254, 134}, {159, 214, 0}} ,{{255, 134}, {160, 214, 0}} ,{{4, 135}, {165, 214, 0}} ,{{152, 134}, {57, 214, 0}} ,{{153, 134}, {58, 214, 0}} ,{{154, 134}, {59, 214, 0}} ,{{178, 134}, {83, 214, 0}} ,{{173, 134}, {78, 214, 0}} ,{{175, 134}, {80, 214, 0}} ,{{159, 134}, {64, 214, 0}} ,{{162, 134}, {67, 214, 0}} ,{{160, 134}, {65, 214, 0}} ,{{166, 134}, {71, 214, 0}} ,{{161, 134}, {66, 214, 0}} ,{{165, 134}, {70, 214, 0}} ,{{163, 134}, {68, 214, 0}} ,{{164, 134}, {69, 214, 0}} ,{{167, 134}, {72, 214, 0}} ,{{155, 134}, {60, 214, 0}} ,{{172, 134}, {77, 214, 0}} ,{{157, 134}, {62, 214, 0}} ,{{156, 134}, {61, 214, 0}} ,{{177, 134}, {82, 214, 0}} ,{{170, 134}, {75, 214, 0}} ,{{171, 134}, {76, 214, 0}} ,{{176, 134}, {81, 214, 0}} ,{{35, 135}, {196, 214, 0}} ,{{52, 135}, {213, 214, 0}} ,{{53, 135}, {214, 214, 0}} ,{{58, 135}, {219, 214, 0}} ,{{42, 135}, {203, 214, 0}} ,{{36, 135}, {197, 214, 0}} ,{{37, 135}, {198, 214, 0}} ,{{38, 135}, {199, 214, 0}} ,{{62, 135}, {223, 214, 0}} ,{{57, 135}, {218, 214, 0}} ,{{59, 135}, {220, 214, 0}} ,{{43, 135}, {204, 214, 0}} ,{{46, 135}, {207, 214, 0}} ,{{44, 135}, {205, 214, 0}} ,{{50, 135}, {211, 214, 0}} ,{{45, 135}, {206, 214, 0}} ,{{49, 135}, {210, 214, 0}} ,{{47, 135}, {208, 214, 0}} ,{{48, 135}, {209, 214, 0}} ,{{51, 135}, {212, 214, 0}} ,{{39, 135}, {200, 214, 0}} ,{{56, 135}, {217, 214, 0}} ,{{41, 135}, {202, 214, 0}} ,{{40, 135}, {201, 214, 0}} ,{{61, 135}, {222, 214, 0}} ,{{54, 135}, {215, 214, 0}} ,{{55, 135}, {216, 214, 0}} ,{{60, 135}, {221, 214, 0}} ,{{179, 134}, {84, 214, 0}} ,{{196, 134}, {101, 214, 0}} ,{{197, 134}, {102, 214, 0}} ,{{202, 134}, {107, 214, 0}} ,{{186, 134}, {91, 214, 0}} ,{{207, 134}, {112, 214, 0}} ,{{224, 134}, {129, 214, 0}} ,{{225, 134}, {130, 214, 0}} ,{{230, 134}, {135, 214, 0}} ,{{214, 134}, {119, 214, 0}} ,{{208, 134}, {113, 214, 0}} ,{{209, 134}, {114, 214, 0}} ,{{210, 134}, {115, 214, 0}} ,{{234, 134}, {139, 214, 0}} ,{{229, 134}, {134, 214, 0}} ,{{231, 134}, {136, 214, 0}} ,{{215, 134}, {120, 214, 0}} ,{{218, 134}, {123, 214, 0}} ,{{216, 134}, {121, 214, 0}} ,{{222, 134}, {127, 214, 0}} ,{{217, 134}, {122, 214, 0}} ,{{221, 134}, {126, 214, 0}} ,{{219, 134}, {124, 214, 0}} ,{{220, 134}, {125, 214, 0}} ,{{223, 134}, {128, 214, 0}} ,{{211, 134}, {116, 214, 0}} ,{{228, 134}, {133, 214, 0}} ,{{213, 134}, {118, 214, 0}} ,{{212, 134}, {117, 214, 0}} ,{{233, 134}, {138, 214, 0}} ,{{226, 134}, {131, 214, 0}} ,{{227, 134}, {132, 214, 0}} ,{{232, 134}, {137, 214, 0}} ,{{180, 134}, {85, 214, 0}} ,{{181, 134}, {86, 214, 0}} ,{{182, 134}, {87, 214, 0}} ,{{206, 134}, {111, 214, 0}} ,{{201, 134}, {106, 214, 0}} ,{{203, 134}, {108, 214, 0}} ,{{187, 134}, {92, 214, 0}} ,{{190, 134}, {95, 214, 0}} ,{{188, 134}, {93, 214, 0}} ,{{194, 134}, {99, 214, 0}} ,{{189, 134}, {94, 214, 0}} ,{{193, 134}, {98, 214, 0}} ,{{191, 134}, {96, 214, 0}} ,{{192, 134}, {97, 214, 0}} ,{{195, 134}, {100, 214, 0}} ,{{183, 134}, {88, 214, 0}} ,{{200, 134}, {105, 214, 0}} ,{{185, 134}, {90, 214, 0}} ,{{184, 134}, {89, 214, 0}} ,{{205, 134}, {110, 214, 0}} ,{{198, 134}, {103, 214, 0}} ,{{199, 134}, {104, 214, 0}} ,{{204, 134}, {109, 214, 0}} ,{{91, 135}, {252, 214, 0}} ,{{108, 135}, {13, 215, 0}} ,{{109, 135}, {14, 215, 0}} ,{{114, 135}, {19, 215, 0}} ,{{98, 135}, {3, 215, 0}} ,{{92, 135}, {253, 214, 0}} ,{{93, 135}, {254, 214, 0}} ,{{94, 135}, {255, 214, 0}} ,{{118, 135}, {23, 215, 0}} ,{{113, 135}, {18, 215, 0}} ,{{115, 135}, {20, 215, 0}} ,{{99, 135}, {4, 215, 0}} ,{{102, 135}, {7, 215, 0}} ,{{100, 135}, {5, 215, 0}} ,{{106, 135}, {11, 215, 0}} ,{{101, 135}, {6, 215, 0}} ,{{105, 135}, {10, 215, 0}} ,{{103, 135}, {8, 215, 0}} ,{{104, 135}, {9, 215, 0}} ,{{107, 135}, {12, 215, 0}} ,{{95, 135}, {0, 215, 0}} ,{{112, 135}, {17, 215, 0}} ,{{97, 135}, {2, 215, 0}} ,{{96, 135}, {1, 215, 0}} ,{{63, 135}, {224, 214, 0}} ,{{80, 135}, {241, 214, 0}} ,{{81, 135}, {242, 214, 0}} ,{{86, 135}, {247, 214, 0}} ,{{70, 135}, {231, 214, 0}} ,{{64, 135}, {225, 214, 0}} ,{{65, 135}, {226, 214, 0}} ,{{66, 135}, {227, 214, 0}} ,{{90, 135}, {251, 214, 0}} ,{{85, 135}, {246, 214, 0}} ,{{87, 135}, {248, 214, 0}} ,{{71, 135}, {232, 214, 0}} ,{{74, 135}, {235, 214, 0}} ,{{72, 135}, {233, 214, 0}} ,{{78, 135}, {239, 214, 0}} ,{{73, 135}, {234, 214, 0}} ,{{77, 135}, {238, 214, 0}} ,{{75, 135}, {236, 214, 0}} ,{{76, 135}, {237, 214, 0}} ,{{79, 135}, {240, 214, 0}} ,{{67, 135}, {228, 214, 0}} ,{{84, 135}, {245, 214, 0}} ,{{69, 135}, {230, 214, 0}} ,{{68, 135}, {229, 214, 0}} ,{{89, 135}, {250, 214, 0}} ,{{82, 135}, {243, 214, 0}} ,{{83, 135}, {244, 214, 0}} ,{{88, 135}, {249, 214, 0}} ,{{117, 135}, {22, 215, 0}} ,{{110, 135}, {15, 215, 0}} ,{{111, 135}, {16, 215, 0}} ,{{116, 135}, {21, 215, 0}} ,{{119, 135}, {24, 215, 0}} ,{{136, 135}, {41, 215, 0}} ,{{137, 135}, {42, 215, 0}} ,{{142, 135}, {47, 215, 0}} ,{{126, 135}, {31, 215, 0}} ,{{120, 135}, {25, 215, 0}} ,{{121, 135}, {26, 215, 0}} ,{{122, 135}, {27, 215, 0}} ,{{146, 135}, {51, 215, 0}} ,{{141, 135}, {46, 215, 0}} ,{{143, 135}, {48, 215, 0}} ,{{127, 135}, {32, 215, 0}} ,{{130, 135}, {35, 215, 0}} ,{{128, 135}, {33, 215, 0}} ,{{134, 135}, {39, 215, 0}} ,{{129, 135}, {34, 215, 0}} ,{{133, 135}, {38, 215, 0}} ,{{131, 135}, {36, 215, 0}} ,{{132, 135}, {37, 215, 0}} ,{{135, 135}, {40, 215, 0}} ,{{123, 135}, {28, 215, 0}} ,{{140, 135}, {45, 215, 0}} ,{{125, 135}, {30, 215, 0}} ,{{124, 135}, {29, 215, 0}} ,{{145, 135}, {50, 215, 0}} ,{{138, 135}, {43, 215, 0}} ,{{139, 135}, {44, 215, 0}} ,{{144, 135}, {49, 215, 0}} ,{{239, 133}, {144, 213, 0}} ,{{0, 134}, {161, 213, 0}} ,{{1, 134}, {162, 213, 0}} ,{{6, 134}, {167, 213, 0}} ,{{246, 133}, {151, 213, 0}} ,{{11, 134}, {172, 213, 0}} ,{{28, 134}, {189, 213, 0}} ,{{29, 134}, {190, 213, 0}} ,{{34, 134}, {195, 213, 0}} ,{{18, 134}, {179, 213, 0}} ,{{12, 134}, {173, 213, 0}} ,{{13, 134}, {174, 213, 0}} ,{{14, 134}, {175, 213, 0}} ,{{38, 134}, {199, 213, 0}} ,{{33, 134}, {194, 213, 0}} ,{{35, 134}, {196, 213, 0}} ,{{19, 134}, {180, 213, 0}} ,{{22, 134}, {183, 213, 0}} ,{{20, 134}, {181, 213, 0}} ,{{26, 134}, {187, 213, 0}} ,{{21, 134}, {182, 213, 0}} ,{{25, 134}, {186, 213, 0}} ,{{23, 134}, {184, 213, 0}} ,{{24, 134}, {185, 213, 0}} ,{{27, 134}, {188, 213, 0}} ,{{15, 134}, {176, 213, 0}} ,{{32, 134}, {193, 213, 0}} ,{{17, 134}, {178, 213, 0}} ,{{16, 134}, {177, 213, 0}} ,{{37, 134}, {198, 213, 0}} ,{{30, 134}, {191, 213, 0}} ,{{31, 134}, {192, 213, 0}} ,{{36, 134}, {197, 213, 0}} ,{{240, 133}, {145, 213, 0}} ,{{241, 133}, {146, 213, 0}} ,{{242, 133}, {147, 213, 0}} ,{{10, 134}, {171, 213, 0}} ,{{5, 134}, {166, 213, 0}} ,{{7, 134}, {168, 213, 0}} ,{{247, 133}, {152, 213, 0}} ,{{250, 133}, {155, 213, 0}} ,{{248, 133}, {153, 213, 0}} ,{{254, 133}, {159, 213, 0}} ,{{249, 133}, {154, 213, 0}} ,{{253, 133}, {158, 213, 0}} ,{{251, 133}, {156, 213, 0}} ,{{252, 133}, {157, 213, 0}} ,{{255, 133}, {160, 213, 0}} ,{{243, 133}, {148, 213, 0}} ,{{4, 134}, {165, 213, 0}} ,{{245, 133}, {150, 213, 0}} ,{{244, 133}, {149, 213, 0}} ,{{9, 134}, {170, 213, 0}} ,{{2, 134}, {163, 213, 0}} ,{{3, 134}, {164, 213, 0}} ,{{8, 134}, {169, 213, 0}} ,{{123, 134}, {28, 214, 0}} ,{{140, 134}, {45, 214, 0}} ,{{141, 134}, {46, 214, 0}} ,{{146, 134}, {51, 214, 0}} ,{{130, 134}, {35, 214, 0}} ,{{124, 134}, {29, 214, 0}} ,{{125, 134}, {30, 214, 0}} ,{{126, 134}, {31, 214, 0}} ,{{150, 134}, {55, 214, 0}} ,{{145, 134}, {50, 214, 0}} ,{{147, 134}, {52, 214, 0}} ,{{131, 134}, {36, 214, 0}} ,{{134, 134}, {39, 214, 0}} ,{{132, 134}, {37, 214, 0}} ,{{138, 134}, {43, 214, 0}} ,{{133, 134}, {38, 214, 0}} ,{{137, 134}, {42, 214, 0}} ,{{135, 134}, {40, 214, 0}} ,{{136, 134}, {41, 214, 0}} ,{{139, 134}, {44, 214, 0}} ,{{127, 134}, {32, 214, 0}} ,{{144, 134}, {49, 214, 0}} ,{{129, 134}, {34, 214, 0}} ,{{128, 134}, {33, 214, 0}} ,{{95, 134}, {0, 214, 0}} ,{{112, 134}, {17, 214, 0}} ,{{113, 134}, {18, 214, 0}} ,{{118, 134}, {23, 214, 0}} ,{{102, 134}, {7, 214, 0}} ,{{96, 134}, {1, 214, 0}} ,{{97, 134}, {2, 214, 0}} ,{{98, 134}, {3, 214, 0}} ,{{122, 134}, {27, 214, 0}} ,{{117, 134}, {22, 214, 0}} ,{{119, 134}, {24, 214, 0}} ,{{103, 134}, {8, 214, 0}} ,{{106, 134}, {11, 214, 0}} ,{{104, 134}, {9, 214, 0}} ,{{110, 134}, {15, 214, 0}} ,{{105, 134}, {10, 214, 0}} ,{{109, 134}, {14, 214, 0}} ,{{107, 134}, {12, 214, 0}} ,{{108, 134}, {13, 214, 0}} ,{{111, 134}, {16, 214, 0}} ,{{99, 134}, {4, 214, 0}} ,{{116, 134}, {21, 214, 0}} ,{{101, 134}, {6, 214, 0}} ,{{100, 134}, {5, 214, 0}} ,{{121, 134}, {26, 214, 0}} ,{{114, 134}, {19, 214, 0}} ,{{115, 134}, {20, 214, 0}} ,{{120, 134}, {25, 214, 0}} ,{{149, 134}, {54, 214, 0}} ,{{142, 134}, {47, 214, 0}} ,{{143, 134}, {48, 214, 0}} ,{{148, 134}, {53, 214, 0}} ,{{203, 135}, {108, 215, 0}} ,{{220, 135}, {125, 215, 0}} ,{{221, 135}, {126, 215, 0}} ,{{226, 135}, {131, 215, 0}} ,{{210, 135}, {115, 215, 0}} ,{{204, 135}, {109, 215, 0}} ,{{205, 135}, {110, 215, 0}} ,{{206, 135}, {111, 215, 0}} ,{{230, 135}, {135, 215, 0}} ,{{225, 135}, {130, 215, 0}} ,{{227, 135}, {132, 215, 0}} ,{{211, 135}, {116, 215, 0}} ,{{214, 135}, {119, 215, 0}} ,{{212, 135}, {117, 215, 0}} ,{{218, 135}, {123, 215, 0}} ,{{213, 135}, {118, 215, 0}} ,{{217, 135}, {122, 215, 0}} ,{{215, 135}, {120, 215, 0}} ,{{216, 135}, {121, 215, 0}} ,{{219, 135}, {124, 215, 0}} ,{{207, 135}, {112, 215, 0}} ,{{224, 135}, {129, 215, 0}} ,{{209, 135}, {114, 215, 0}} ,{{208, 135}, {113, 215, 0}} ,{{229, 135}, {134, 215, 0}} ,{{222, 135}, {127, 215, 0}} ,{{223, 135}, {128, 215, 0}} ,{{228, 135}, {133, 215, 0}} ,{{7, 135}, {168, 214, 0}} ,{{24, 135}, {185, 214, 0}} ,{{25, 135}, {186, 214, 0}} ,{{30, 135}, {191, 214, 0}} ,{{14, 135}, {175, 214, 0}} ,{{8, 135}, {169, 214, 0}} ,{{9, 135}, {170, 214, 0}} ,{{10, 135}, {171, 214, 0}} ,{{34, 135}, {195, 214, 0}} ,{{29, 135}, {190, 214, 0}} ,{{31, 135}, {192, 214, 0}} ,{{15, 135}, {176, 214, 0}} ,{{18, 135}, {179, 214, 0}} ,{{16, 135}, {177, 214, 0}} ,{{22, 135}, {183, 214, 0}} ,{{17, 135}, {178, 214, 0}} ,{{21, 135}, {182, 214, 0}} ,{{19, 135}, {180, 214, 0}} ,{{20, 135}, {181, 214, 0}} ,{{23, 135}, {184, 214, 0}} ,{{11, 135}, {172, 214, 0}} ,{{28, 135}, {189, 214, 0}} ,{{13, 135}, {174, 214, 0}} ,{{12, 135}, {173, 214, 0}} ,{{33, 135}, {194, 214, 0}} ,{{26, 135}, {187, 214, 0}} ,{{27, 135}, {188, 214, 0}} ,{{32, 135}, {193, 214, 0}} ,{{147, 135}, {52, 215, 0}} ,{{164, 135}, {69, 215, 0}} ,{{165, 135}, {70, 215, 0}} ,{{170, 135}, {75, 215, 0}} ,{{154, 135}, {59, 215, 0}} ,{{148, 135}, {53, 215, 0}} ,{{149, 135}, {54, 215, 0}} ,{{150, 135}, {55, 215, 0}} ,{{174, 135}, {79, 215, 0}} ,{{169, 135}, {74, 215, 0}} ,{{171, 135}, {76, 215, 0}} ,{{155, 135}, {60, 215, 0}} ,{{158, 135}, {63, 215, 0}} ,{{156, 135}, {61, 215, 0}} ,{{162, 135}, {67, 215, 0}} ,{{157, 135}, {62, 215, 0}} ,{{161, 135}, {66, 215, 0}} ,{{159, 135}, {64, 215, 0}} ,{{160, 135}, {65, 215, 0}} ,{{163, 135}, {68, 215, 0}} ,{{151, 135}, {56, 215, 0}} ,{{168, 135}, {73, 215, 0}} ,{{153, 135}, {58, 215, 0}} ,{{152, 135}, {57, 215, 0}} ,{{173, 135}, {78, 215, 0}} ,{{166, 135}, {71, 215, 0}} ,{{167, 135}, {72, 215, 0}} ,{{172, 135}, {77, 215, 0}} ,{{211, 119}, {116, 199, 0}} ,{{228, 119}, {133, 199, 0}} ,{{229, 119}, {134, 199, 0}} ,{{234, 119}, {139, 199, 0}} ,{{218, 119}, {123, 199, 0}} ,{{212, 119}, {117, 199, 0}} ,{{213, 119}, {118, 199, 0}} ,{{214, 119}, {119, 199, 0}} ,{{238, 119}, {143, 199, 0}} ,{{233, 119}, {138, 199, 0}} ,{{235, 119}, {140, 199, 0}} ,{{219, 119}, {124, 199, 0}} ,{{222, 119}, {127, 199, 0}} ,{{220, 119}, {125, 199, 0}} ,{{226, 119}, {131, 199, 0}} ,{{221, 119}, {126, 199, 0}} ,{{225, 119}, {130, 199, 0}} ,{{223, 119}, {128, 199, 0}} ,{{224, 119}, {129, 199, 0}} ,{{227, 119}, {132, 199, 0}} ,{{215, 119}, {120, 199, 0}} ,{{232, 119}, {137, 199, 0}} ,{{217, 119}, {122, 199, 0}} ,{{216, 119}, {121, 199, 0}} ,{{237, 119}, {142, 199, 0}} ,{{230, 119}, {135, 199, 0}} ,{{231, 119}, {136, 199, 0}} ,{{236, 119}, {141, 199, 0}} ,{{239, 119}, {144, 199, 0}} ,{{0, 120}, {161, 199, 0}} ,{{1, 120}, {162, 199, 0}} ,{{6, 120}, {167, 199, 0}} ,{{246, 119}, {151, 199, 0}} ,{{11, 120}, {172, 199, 0}} ,{{28, 120}, {189, 199, 0}} ,{{29, 120}, {190, 199, 0}} ,{{34, 120}, {195, 199, 0}} ,{{18, 120}, {179, 199, 0}} ,{{12, 120}, {173, 199, 0}} ,{{13, 120}, {174, 199, 0}} ,{{14, 120}, {175, 199, 0}} ,{{38, 120}, {199, 199, 0}} ,{{33, 120}, {194, 199, 0}} ,{{35, 120}, {196, 199, 0}} ,{{19, 120}, {180, 199, 0}} ,{{22, 120}, {183, 199, 0}} ,{{20, 120}, {181, 199, 0}} ,{{26, 120}, {187, 199, 0}} ,{{21, 120}, {182, 199, 0}} ,{{25, 120}, {186, 199, 0}} ,{{23, 120}, {184, 199, 0}} ,{{24, 120}, {185, 199, 0}} ,{{27, 120}, {188, 199, 0}} ,{{15, 120}, {176, 199, 0}} ,{{32, 120}, {193, 199, 0}} ,{{17, 120}, {178, 199, 0}} ,{{16, 120}, {177, 199, 0}} ,{{37, 120}, {198, 199, 0}} ,{{30, 120}, {191, 199, 0}} ,{{31, 120}, {192, 199, 0}} ,{{36, 120}, {197, 199, 0}} ,{{240, 119}, {145, 199, 0}} ,{{241, 119}, {146, 199, 0}} ,{{242, 119}, {147, 199, 0}} ,{{10, 120}, {171, 199, 0}} ,{{5, 120}, {166, 199, 0}} ,{{7, 120}, {168, 199, 0}} ,{{247, 119}, {152, 199, 0}} ,{{250, 119}, {155, 199, 0}} ,{{248, 119}, {153, 199, 0}} ,{{254, 119}, {159, 199, 0}} ,{{249, 119}, {154, 199, 0}} ,{{253, 119}, {158, 199, 0}} ,{{251, 119}, {156, 199, 0}} ,{{252, 119}, {157, 199, 0}} ,{{255, 119}, {160, 199, 0}} ,{{243, 119}, {148, 199, 0}} ,{{4, 120}, {165, 199, 0}} ,{{245, 119}, {150, 199, 0}} ,{{244, 119}, {149, 199, 0}} ,{{9, 120}, {170, 199, 0}} ,{{2, 120}, {163, 199, 0}} ,{{3, 120}, {164, 199, 0}} ,{{8, 120}, {169, 199, 0}} ,{{123, 120}, {28, 200, 0}} ,{{140, 120}, {45, 200, 0}} ,{{141, 120}, {46, 200, 0}} ,{{146, 120}, {51, 200, 0}} ,{{130, 120}, {35, 200, 0}} ,{{124, 120}, {29, 200, 0}} ,{{125, 120}, {30, 200, 0}} ,{{126, 120}, {31, 200, 0}} ,{{150, 120}, {55, 200, 0}} ,{{145, 120}, {50, 200, 0}} ,{{147, 120}, {52, 200, 0}} ,{{131, 120}, {36, 200, 0}} ,{{134, 120}, {39, 200, 0}} ,{{132, 120}, {37, 200, 0}} ,{{138, 120}, {43, 200, 0}} ,{{133, 120}, {38, 200, 0}} ,{{137, 120}, {42, 200, 0}} ,{{135, 120}, {40, 200, 0}} ,{{136, 120}, {41, 200, 0}} ,{{139, 120}, {44, 200, 0}} ,{{127, 120}, {32, 200, 0}} ,{{144, 120}, {49, 200, 0}} ,{{129, 120}, {34, 200, 0}} ,{{128, 120}, {33, 200, 0}} ,{{95, 120}, {0, 200, 0}} ,{{112, 120}, {17, 200, 0}} ,{{113, 120}, {18, 200, 0}} ,{{118, 120}, {23, 200, 0}} ,{{102, 120}, {7, 200, 0}} ,{{96, 120}, {1, 200, 0}} ,{{97, 120}, {2, 200, 0}} ,{{98, 120}, {3, 200, 0}} ,{{122, 120}, {27, 200, 0}} ,{{117, 120}, {22, 200, 0}} ,{{119, 120}, {24, 200, 0}} ,{{103, 120}, {8, 200, 0}} ,{{106, 120}, {11, 200, 0}} ,{{104, 120}, {9, 200, 0}} ,{{110, 120}, {15, 200, 0}} ,{{105, 120}, {10, 200, 0}} ,{{109, 120}, {14, 200, 0}} ,{{107, 120}, {12, 200, 0}} ,{{108, 120}, {13, 200, 0}} ,{{111, 120}, {16, 200, 0}} ,{{99, 120}, {4, 200, 0}} ,{{116, 120}, {21, 200, 0}} ,{{101, 120}, {6, 200, 0}} ,{{100, 120}, {5, 200, 0}} ,{{121, 120}, {26, 200, 0}} ,{{114, 120}, {19, 200, 0}} ,{{115, 120}, {20, 200, 0}} ,{{120, 120}, {25, 200, 0}} ,{{149, 120}, {54, 200, 0}} ,{{142, 120}, {47, 200, 0}} ,{{143, 120}, {48, 200, 0}} ,{{148, 120}, {53, 200, 0}} ,{{231, 121}, {136, 201, 0}} ,{{248, 121}, {153, 201, 0}} ,{{249, 121}, {154, 201, 0}} ,{{254, 121}, {159, 201, 0}} ,{{238, 121}, {143, 201, 0}} ,{{232, 121}, {137, 201, 0}} ,{{233, 121}, {138, 201, 0}} ,{{234, 121}, {139, 201, 0}} ,{{2, 122}, {163, 201, 0}} ,{{253, 121}, {158, 201, 0}} ,{{255, 121}, {160, 201, 0}} ,{{239, 121}, {144, 201, 0}} ,{{242, 121}, {147, 201, 0}} ,{{240, 121}, {145, 201, 0}} ,{{246, 121}, {151, 201, 0}} ,{{241, 121}, {146, 201, 0}} ,{{245, 121}, {150, 201, 0}} ,{{243, 121}, {148, 201, 0}} ,{{244, 121}, {149, 201, 0}} ,{{247, 121}, {152, 201, 0}} ,{{235, 121}, {140, 201, 0}} ,{{252, 121}, {157, 201, 0}} ,{{237, 121}, {142, 201, 0}} ,{{236, 121}, {141, 201, 0}} ,{{1, 122}, {162, 201, 0}} ,{{250, 121}, {155, 201, 0}} ,{{251, 121}, {156, 201, 0}} ,{{0, 122}, {161, 201, 0}} ,{{31, 122}, {192, 201, 0}} ,{{48, 122}, {209, 201, 0}} ,{{49, 122}, {210, 201, 0}} ,{{54, 122}, {215, 201, 0}} ,{{38, 122}, {199, 201, 0}} ,{{32, 122}, {193, 201, 0}} ,{{33, 122}, {194, 201, 0}} ,{{34, 122}, {195, 201, 0}} ,{{58, 122}, {219, 201, 0}} ,{{53, 122}, {214, 201, 0}} ,{{55, 122}, {216, 201, 0}} ,{{39, 122}, {200, 201, 0}} ,{{42, 122}, {203, 201, 0}} ,{{40, 122}, {201, 201, 0}} ,{{46, 122}, {207, 201, 0}} ,{{41, 122}, {202, 201, 0}} ,{{45, 122}, {206, 201, 0}} ,{{43, 122}, {204, 201, 0}} ,{{44, 122}, {205, 201, 0}} ,{{47, 122}, {208, 201, 0}} ,{{35, 122}, {196, 201, 0}} ,{{52, 122}, {213, 201, 0}} ,{{37, 122}, {198, 201, 0}} ,{{36, 122}, {197, 201, 0}} ,{{57, 122}, {218, 201, 0}} ,{{50, 122}, {211, 201, 0}} ,{{51, 122}, {212, 201, 0}} ,{{56, 122}, {217, 201, 0}} ,{{59, 122}, {220, 201, 0}} ,{{76, 122}, {237, 201, 0}} ,{{77, 122}, {238, 201, 0}} ,{{82, 122}, {243, 201, 0}} ,{{66, 122}, {227, 201, 0}} ,{{87, 122}, {248, 201, 0}} ,{{104, 122}, {9, 202, 0}} ,{{105, 122}, {10, 202, 0}} ,{{110, 122}, {15, 202, 0}} ,{{94, 122}, {255, 201, 0}} ,{{88, 122}, {249, 201, 0}} ,{{89, 122}, {250, 201, 0}} ,{{90, 122}, {251, 201, 0}} ,{{114, 122}, {19, 202, 0}} ,{{109, 122}, {14, 202, 0}} ,{{111, 122}, {16, 202, 0}} ,{{95, 122}, {0, 202, 0}} ,{{98, 122}, {3, 202, 0}} ,{{96, 122}, {1, 202, 0}} ,{{102, 122}, {7, 202, 0}} ,{{97, 122}, {2, 202, 0}} ,{{101, 122}, {6, 202, 0}} ,{{99, 122}, {4, 202, 0}} ,{{100, 122}, {5, 202, 0}} ,{{103, 122}, {8, 202, 0}} ,{{91, 122}, {252, 201, 0}} ,{{108, 122}, {13, 202, 0}} ,{{93, 122}, {254, 201, 0}} ,{{92, 122}, {253, 201, 0}} ,{{113, 122}, {18, 202, 0}} ,{{106, 122}, {11, 202, 0}} ,{{107, 122}, {12, 202, 0}} ,{{112, 122}, {17, 202, 0}} ,{{60, 122}, {221, 201, 0}} ,{{61, 122}, {222, 201, 0}} ,{{62, 122}, {223, 201, 0}} ,{{86, 122}, {247, 201, 0}} ,{{81, 122}, {242, 201, 0}} ,{{83, 122}, {244, 201, 0}} ,{{67, 122}, {228, 201, 0}} ,{{70, 122}, {231, 201, 0}} ,{{68, 122}, {229, 201, 0}} ,{{74, 122}, {235, 201, 0}} ,{{69, 122}, {230, 201, 0}} ,{{73, 122}, {234, 201, 0}} ,{{71, 122}, {232, 201, 0}} ,{{72, 122}, {233, 201, 0}} ,{{75, 122}, {236, 201, 0}} ,{{63, 122}, {224, 201, 0}} ,{{80, 122}, {241, 201, 0}} ,{{65, 122}, {226, 201, 0}} ,{{64, 122}, {225, 201, 0}} ,{{85, 122}, {246, 201, 0}} ,{{78, 122}, {239, 201, 0}} ,{{79, 122}, {240, 201, 0}} ,{{84, 122}, {245, 201, 0}} ,{{199, 122}, {104, 202, 0}} ,{{216, 122}, {121, 202, 0}} ,{{217, 122}, {122, 202, 0}} ,{{222, 122}, {127, 202, 0}} ,{{206, 122}, {111, 202, 0}} ,{{200, 122}, {105, 202, 0}} ,{{201, 122}, {106, 202, 0}} ,{{202, 122}, {107, 202, 0}} ,{{226, 122}, {131, 202, 0}} ,{{221, 122}, {126, 202, 0}} ,{{223, 122}, {128, 202, 0}} ,{{207, 122}, {112, 202, 0}} ,{{210, 122}, {115, 202, 0}} ,{{208, 122}, {113, 202, 0}} ,{{214, 122}, {119, 202, 0}} ,{{209, 122}, {114, 202, 0}} ,{{213, 122}, {118, 202, 0}} ,{{211, 122}, {116, 202, 0}} ,{{212, 122}, {117, 202, 0}} ,{{215, 122}, {120, 202, 0}} ,{{203, 122}, {108, 202, 0}} ,{{220, 122}, {125, 202, 0}} ,{{205, 122}, {110, 202, 0}} ,{{204, 122}, {109, 202, 0}} ,{{171, 122}, {76, 202, 0}} ,{{188, 122}, {93, 202, 0}} ,{{189, 122}, {94, 202, 0}} ,{{194, 122}, {99, 202, 0}} ,{{178, 122}, {83, 202, 0}} ,{{172, 122}, {77, 202, 0}} ,{{173, 122}, {78, 202, 0}} ,{{174, 122}, {79, 202, 0}} ,{{198, 122}, {103, 202, 0}} ,{{193, 122}, {98, 202, 0}} ,{{195, 122}, {100, 202, 0}} ,{{179, 122}, {84, 202, 0}} ,{{182, 122}, {87, 202, 0}} ,{{180, 122}, {85, 202, 0}} ,{{186, 122}, {91, 202, 0}} ,{{181, 122}, {86, 202, 0}} ,{{185, 122}, {90, 202, 0}} ,{{183, 122}, {88, 202, 0}} ,{{184, 122}, {89, 202, 0}} ,{{187, 122}, {92, 202, 0}} ,{{175, 122}, {80, 202, 0}} ,{{192, 122}, {97, 202, 0}} ,{{177, 122}, {82, 202, 0}} ,{{176, 122}, {81, 202, 0}} ,{{197, 122}, {102, 202, 0}} ,{{190, 122}, {95, 202, 0}} ,{{191, 122}, {96, 202, 0}} ,{{196, 122}, {101, 202, 0}} ,{{225, 122}, {130, 202, 0}} ,{{218, 122}, {123, 202, 0}} ,{{219, 122}, {124, 202, 0}} ,{{224, 122}, {129, 202, 0}} ,{{51, 124}, {212, 203, 0}} ,{{68, 124}, {229, 203, 0}} ,{{69, 124}, {230, 203, 0}} ,{{74, 124}, {235, 203, 0}} ,{{58, 124}, {219, 203, 0}} ,{{52, 124}, {213, 203, 0}} ,{{53, 124}, {214, 203, 0}} ,{{54, 124}, {215, 203, 0}} ,{{78, 124}, {239, 203, 0}} ,{{73, 124}, {234, 203, 0}} ,{{75, 124}, {236, 203, 0}} ,{{59, 124}, {220, 203, 0}} ,{{62, 124}, {223, 203, 0}} ,{{60, 124}, {221, 203, 0}} ,{{66, 124}, {227, 203, 0}} ,{{61, 124}, {222, 203, 0}} ,{{65, 124}, {226, 203, 0}} ,{{63, 124}, {224, 203, 0}} ,{{64, 124}, {225, 203, 0}} ,{{67, 124}, {228, 203, 0}} ,{{55, 124}, {216, 203, 0}} ,{{72, 124}, {233, 203, 0}} ,{{57, 124}, {218, 203, 0}} ,{{56, 124}, {217, 203, 0}} ,{{77, 124}, {238, 203, 0}} ,{{70, 124}, {231, 203, 0}} ,{{71, 124}, {232, 203, 0}} ,{{76, 124}, {237, 203, 0}} ,{{107, 124}, {12, 204, 0}} ,{{124, 124}, {29, 204, 0}} ,{{125, 124}, {30, 204, 0}} ,{{130, 124}, {35, 204, 0}} ,{{114, 124}, {19, 204, 0}} ,{{108, 124}, {13, 204, 0}} ,{{109, 124}, {14, 204, 0}} ,{{110, 124}, {15, 204, 0}} ,{{134, 124}, {39, 204, 0}} ,{{129, 124}, {34, 204, 0}} ,{{131, 124}, {36, 204, 0}} ,{{115, 124}, {20, 204, 0}} ,{{118, 124}, {23, 204, 0}} ,{{116, 124}, {21, 204, 0}} ,{{122, 124}, {27, 204, 0}} ,{{117, 124}, {22, 204, 0}} ,{{121, 124}, {26, 204, 0}} ,{{119, 124}, {24, 204, 0}} ,{{120, 124}, {25, 204, 0}} ,{{123, 124}, {28, 204, 0}} ,{{111, 124}, {16, 204, 0}} ,{{128, 124}, {33, 204, 0}} ,{{113, 124}, {18, 204, 0}} ,{{112, 124}, {17, 204, 0}} ,{{133, 124}, {38, 204, 0}} ,{{126, 124}, {31, 204, 0}} ,{{127, 124}, {32, 204, 0}} ,{{132, 124}, {37, 204, 0}} ,{{27, 123}, {188, 202, 0}} ,{{44, 123}, {205, 202, 0}} ,{{45, 123}, {206, 202, 0}} ,{{50, 123}, {211, 202, 0}} ,{{34, 123}, {195, 202, 0}} ,{{111, 123}, {16, 203, 0}} ,{{128, 123}, {33, 203, 0}} ,{{129, 123}, {34, 203, 0}} ,{{134, 123}, {39, 203, 0}} ,{{118, 123}, {23, 203, 0}} ,{{112, 123}, {17, 203, 0}} ,{{113, 123}, {18, 203, 0}} ,{{114, 123}, {19, 203, 0}} ,{{138, 123}, {43, 203, 0}} ,{{133, 123}, {38, 203, 0}} ,{{135, 123}, {40, 203, 0}} ,{{119, 123}, {24, 203, 0}} ,{{122, 123}, {27, 203, 0}} ,{{120, 123}, {25, 203, 0}} ,{{126, 123}, {31, 203, 0}} ,{{121, 123}, {26, 203, 0}} ,{{125, 123}, {30, 203, 0}} ,{{123, 123}, {28, 203, 0}} ,{{124, 123}, {29, 203, 0}} ,{{127, 123}, {32, 203, 0}} ,{{115, 123}, {20, 203, 0}} ,{{132, 123}, {37, 203, 0}} ,{{117, 123}, {22, 203, 0}} ,{{116, 123}, {21, 203, 0}} ,{{137, 123}, {42, 203, 0}} ,{{130, 123}, {35, 203, 0}} ,{{131, 123}, {36, 203, 0}} ,{{136, 123}, {41, 203, 0}} ,{{28, 123}, {189, 202, 0}} ,{{29, 123}, {190, 202, 0}} ,{{30, 123}, {191, 202, 0}} ,{{54, 123}, {215, 202, 0}} ,{{49, 123}, {210, 202, 0}} ,{{51, 123}, {212, 202, 0}} ,{{35, 123}, {196, 202, 0}} ,{{38, 123}, {199, 202, 0}} ,{{36, 123}, {197, 202, 0}} ,{{42, 123}, {203, 202, 0}} ,{{37, 123}, {198, 202, 0}} ,{{41, 123}, {202, 202, 0}} ,{{39, 123}, {200, 202, 0}} ,{{40, 123}, {201, 202, 0}} ,{{43, 123}, {204, 202, 0}} ,{{31, 123}, {192, 202, 0}} ,{{48, 123}, {209, 202, 0}} ,{{33, 123}, {194, 202, 0}} ,{{32, 123}, {193, 202, 0}} ,{{53, 123}, {214, 202, 0}} ,{{46, 123}, {207, 202, 0}} ,{{47, 123}, {208, 202, 0}} ,{{52, 123}, {213, 202, 0}} ,{{167, 123}, {72, 203, 0}} ,{{184, 123}, {89, 203, 0}} ,{{185, 123}, {90, 203, 0}} ,{{190, 123}, {95, 203, 0}} ,{{174, 123}, {79, 203, 0}} ,{{168, 123}, {73, 203, 0}} ,{{169, 123}, {74, 203, 0}} ,{{170, 123}, {75, 203, 0}} ,{{194, 123}, {99, 203, 0}} ,{{189, 123}, {94, 203, 0}} ,{{191, 123}, {96, 203, 0}} ,{{175, 123}, {80, 203, 0}} ,{{178, 123}, {83, 203, 0}} ,{{176, 123}, {81, 203, 0}} ,{{182, 123}, {87, 203, 0}} ,{{177, 123}, {82, 203, 0}} ,{{181, 123}, {86, 203, 0}} ,{{179, 123}, {84, 203, 0}} ,{{180, 123}, {85, 203, 0}} ,{{183, 123}, {88, 203, 0}} ,{{171, 123}, {76, 203, 0}} ,{{188, 123}, {93, 203, 0}} ,{{173, 123}, {78, 203, 0}} ,{{172, 123}, {77, 203, 0}} ,{{193, 123}, {98, 203, 0}} ,{{186, 123}, {91, 203, 0}} ,{{187, 123}, {92, 203, 0}} ,{{192, 123}, {97, 203, 0}} ,{{55, 123}, {216, 202, 0}} ,{{72, 123}, {233, 202, 0}} ,{{73, 123}, {234, 202, 0}} ,{{78, 123}, {239, 202, 0}} ,{{62, 123}, {223, 202, 0}} ,{{83, 123}, {244, 202, 0}} ,{{100, 123}, {5, 203, 0}} ,{{101, 123}, {6, 203, 0}} ,{{106, 123}, {11, 203, 0}} ,{{90, 123}, {251, 202, 0}} ,{{84, 123}, {245, 202, 0}} ,{{85, 123}, {246, 202, 0}} ,{{86, 123}, {247, 202, 0}} ,{{110, 123}, {15, 203, 0}} ,{{105, 123}, {10, 203, 0}} ,{{107, 123}, {12, 203, 0}} ,{{91, 123}, {252, 202, 0}} ,{{94, 123}, {255, 202, 0}} ,{{92, 123}, {253, 202, 0}} ,{{98, 123}, {3, 203, 0}} ,{{93, 123}, {254, 202, 0}} ,{{97, 123}, {2, 203, 0}} ,{{95, 123}, {0, 203, 0}} ,{{96, 123}, {1, 203, 0}} ,{{99, 123}, {4, 203, 0}} ,{{87, 123}, {248, 202, 0}} ,{{104, 123}, {9, 203, 0}} ,{{89, 123}, {250, 202, 0}} ,{{88, 123}, {249, 202, 0}} ,{{109, 123}, {14, 203, 0}} ,{{102, 123}, {7, 203, 0}} ,{{103, 123}, {8, 203, 0}} ,{{108, 123}, {13, 203, 0}} ,{{56, 123}, {217, 202, 0}} ,{{57, 123}, {218, 202, 0}} ,{{58, 123}, {219, 202, 0}} ,{{82, 123}, {243, 202, 0}} ,{{77, 123}, {238, 202, 0}} ,{{79, 123}, {240, 202, 0}} ,{{63, 123}, {224, 202, 0}} ,{{66, 123}, {227, 202, 0}} ,{{64, 123}, {225, 202, 0}} ,{{70, 123}, {231, 202, 0}} ,{{65, 123}, {226, 202, 0}} ,{{69, 123}, {230, 202, 0}} ,{{67, 123}, {228, 202, 0}} ,{{68, 123}, {229, 202, 0}} ,{{71, 123}, {232, 202, 0}} ,{{59, 123}, {220, 202, 0}} ,{{76, 123}, {237, 202, 0}} ,{{61, 123}, {222, 202, 0}} ,{{60, 123}, {221, 202, 0}} ,{{81, 123}, {242, 202, 0}} ,{{74, 123}, {235, 202, 0}} ,{{75, 123}, {236, 202, 0}} ,{{80, 123}, {241, 202, 0}} ,{{223, 123}, {128, 203, 0}} ,{{240, 123}, {145, 203, 0}} ,{{241, 123}, {146, 203, 0}} ,{{246, 123}, {151, 203, 0}} ,{{230, 123}, {135, 203, 0}} ,{{224, 123}, {129, 203, 0}} ,{{225, 123}, {130, 203, 0}} ,{{226, 123}, {131, 203, 0}} ,{{250, 123}, {155, 203, 0}} ,{{245, 123}, {150, 203, 0}} ,{{247, 123}, {152, 203, 0}} ,{{231, 123}, {136, 203, 0}} ,{{234, 123}, {139, 203, 0}} ,{{232, 123}, {137, 203, 0}} ,{{238, 123}, {143, 203, 0}} ,{{233, 123}, {138, 203, 0}} ,{{237, 123}, {142, 203, 0}} ,{{235, 123}, {140, 203, 0}} ,{{236, 123}, {141, 203, 0}} ,{{239, 123}, {144, 203, 0}} ,{{227, 123}, {132, 203, 0}} ,{{244, 123}, {149, 203, 0}} ,{{229, 123}, {134, 203, 0}} ,{{228, 123}, {133, 203, 0}} ,{{195, 123}, {100, 203, 0}} ,{{212, 123}, {117, 203, 0}} ,{{213, 123}, {118, 203, 0}} ,{{218, 123}, {123, 203, 0}} ,{{202, 123}, {107, 203, 0}} ,{{196, 123}, {101, 203, 0}} ,{{197, 123}, {102, 203, 0}} ,{{198, 123}, {103, 203, 0}} ,{{222, 123}, {127, 203, 0}} ,{{217, 123}, {122, 203, 0}} ,{{219, 123}, {124, 203, 0}} ,{{203, 123}, {108, 203, 0}} ,{{206, 123}, {111, 203, 0}} ,{{204, 123}, {109, 203, 0}} ,{{210, 123}, {115, 203, 0}} ,{{205, 123}, {110, 203, 0}} ,{{209, 123}, {114, 203, 0}} ,{{207, 123}, {112, 203, 0}} ,{{208, 123}, {113, 203, 0}} ,{{211, 123}, {116, 203, 0}} ,{{199, 123}, {104, 203, 0}} ,{{216, 123}, {121, 203, 0}} ,{{201, 123}, {106, 203, 0}} ,{{200, 123}, {105, 203, 0}} ,{{221, 123}, {126, 203, 0}} ,{{214, 123}, {119, 203, 0}} ,{{215, 123}, {120, 203, 0}} ,{{220, 123}, {125, 203, 0}} ,{{249, 123}, {154, 203, 0}} ,{{242, 123}, {147, 203, 0}} ,{{243, 123}, {148, 203, 0}} ,{{248, 123}, {153, 203, 0}} ,{{251, 123}, {156, 203, 0}} ,{{12, 124}, {173, 203, 0}} ,{{13, 124}, {174, 203, 0}} ,{{18, 124}, {179, 203, 0}} ,{{2, 124}, {163, 203, 0}} ,{{252, 123}, {157, 203, 0}} ,{{253, 123}, {158, 203, 0}} ,{{254, 123}, {159, 203, 0}} ,{{22, 124}, {183, 203, 0}} ,{{17, 124}, {178, 203, 0}} ,{{19, 124}, {180, 203, 0}} ,{{3, 124}, {164, 203, 0}} ,{{6, 124}, {167, 203, 0}} ,{{4, 124}, {165, 203, 0}} ,{{10, 124}, {171, 203, 0}} ,{{5, 124}, {166, 203, 0}} ,{{9, 124}, {170, 203, 0}} ,{{7, 124}, {168, 203, 0}} ,{{8, 124}, {169, 203, 0}} ,{{11, 124}, {172, 203, 0}} ,{{255, 123}, {160, 203, 0}} ,{{16, 124}, {177, 203, 0}} ,{{1, 124}, {162, 203, 0}} ,{{0, 124}, {161, 203, 0}} ,{{21, 124}, {182, 203, 0}} ,{{14, 124}, {175, 203, 0}} ,{{15, 124}, {176, 203, 0}} ,{{20, 124}, {181, 203, 0}} ,{{115, 122}, {20, 202, 0}} ,{{132, 122}, {37, 202, 0}} ,{{133, 122}, {38, 202, 0}} ,{{138, 122}, {43, 202, 0}} ,{{122, 122}, {27, 202, 0}} ,{{143, 122}, {48, 202, 0}} ,{{160, 122}, {65, 202, 0}} ,{{161, 122}, {66, 202, 0}} ,{{166, 122}, {71, 202, 0}} ,{{150, 122}, {55, 202, 0}} ,{{144, 122}, {49, 202, 0}} ,{{145, 122}, {50, 202, 0}} ,{{146, 122}, {51, 202, 0}} ,{{170, 122}, {75, 202, 0}} ,{{165, 122}, {70, 202, 0}} ,{{167, 122}, {72, 202, 0}} ,{{151, 122}, {56, 202, 0}} ,{{154, 122}, {59, 202, 0}} ,{{152, 122}, {57, 202, 0}} ,{{158, 122}, {63, 202, 0}} ,{{153, 122}, {58, 202, 0}} ,{{157, 122}, {62, 202, 0}} ,{{155, 122}, {60, 202, 0}} ,{{156, 122}, {61, 202, 0}} ,{{159, 122}, {64, 202, 0}} ,{{147, 122}, {52, 202, 0}} ,{{164, 122}, {69, 202, 0}} ,{{149, 122}, {54, 202, 0}} ,{{148, 122}, {53, 202, 0}} ,{{169, 122}, {74, 202, 0}} ,{{162, 122}, {67, 202, 0}} ,{{163, 122}, {68, 202, 0}} ,{{168, 122}, {73, 202, 0}} ,{{116, 122}, {21, 202, 0}} ,{{117, 122}, {22, 202, 0}} ,{{118, 122}, {23, 202, 0}} ,{{142, 122}, {47, 202, 0}} ,{{137, 122}, {42, 202, 0}} ,{{139, 122}, {44, 202, 0}} ,{{123, 122}, {28, 202, 0}} ,{{126, 122}, {31, 202, 0}} ,{{124, 122}, {29, 202, 0}} ,{{130, 122}, {35, 202, 0}} ,{{125, 122}, {30, 202, 0}} ,{{129, 122}, {34, 202, 0}} ,{{127, 122}, {32, 202, 0}} ,{{128, 122}, {33, 202, 0}} ,{{131, 122}, {36, 202, 0}} ,{{119, 122}, {24, 202, 0}} ,{{136, 122}, {41, 202, 0}} ,{{121, 122}, {26, 202, 0}} ,{{120, 122}, {25, 202, 0}} ,{{141, 122}, {46, 202, 0}} ,{{134, 122}, {39, 202, 0}} ,{{135, 122}, {40, 202, 0}} ,{{140, 122}, {45, 202, 0}} ,{{255, 122}, {160, 202, 0}} ,{{16, 123}, {177, 202, 0}} ,{{17, 123}, {178, 202, 0}} ,{{22, 123}, {183, 202, 0}} ,{{6, 123}, {167, 202, 0}} ,{{0, 123}, {161, 202, 0}} ,{{1, 123}, {162, 202, 0}} ,{{2, 123}, {163, 202, 0}} ,{{26, 123}, {187, 202, 0}} ,{{21, 123}, {182, 202, 0}} ,{{23, 123}, {184, 202, 0}} ,{{7, 123}, {168, 202, 0}} ,{{10, 123}, {171, 202, 0}} ,{{8, 123}, {169, 202, 0}} ,{{14, 123}, {175, 202, 0}} ,{{9, 123}, {170, 202, 0}} ,{{13, 123}, {174, 202, 0}} ,{{11, 123}, {172, 202, 0}} ,{{12, 123}, {173, 202, 0}} ,{{15, 123}, {176, 202, 0}} ,{{3, 123}, {164, 202, 0}} ,{{20, 123}, {181, 202, 0}} ,{{5, 123}, {166, 202, 0}} ,{{4, 123}, {165, 202, 0}} ,{{227, 122}, {132, 202, 0}} ,{{244, 122}, {149, 202, 0}} ,{{245, 122}, {150, 202, 0}} ,{{250, 122}, {155, 202, 0}} ,{{234, 122}, {139, 202, 0}} ,{{228, 122}, {133, 202, 0}} ,{{229, 122}, {134, 202, 0}} ,{{230, 122}, {135, 202, 0}} ,{{254, 122}, {159, 202, 0}} ,{{249, 122}, {154, 202, 0}} ,{{251, 122}, {156, 202, 0}} ,{{235, 122}, {140, 202, 0}} ,{{238, 122}, {143, 202, 0}} ,{{236, 122}, {141, 202, 0}} ,{{242, 122}, {147, 202, 0}} ,{{237, 122}, {142, 202, 0}} ,{{241, 122}, {146, 202, 0}} ,{{239, 122}, {144, 202, 0}} ,{{240, 122}, {145, 202, 0}} ,{{243, 122}, {148, 202, 0}} ,{{231, 122}, {136, 202, 0}} ,{{248, 122}, {153, 202, 0}} ,{{233, 122}, {138, 202, 0}} ,{{232, 122}, {137, 202, 0}} ,{{253, 122}, {158, 202, 0}} ,{{246, 122}, {151, 202, 0}} ,{{247, 122}, {152, 202, 0}} ,{{252, 122}, {157, 202, 0}} ,{{25, 123}, {186, 202, 0}} ,{{18, 123}, {179, 202, 0}} ,{{19, 123}, {180, 202, 0}} ,{{24, 123}, {185, 202, 0}} ,{{79, 124}, {240, 203, 0}} ,{{96, 124}, {1, 204, 0}} ,{{97, 124}, {2, 204, 0}} ,{{102, 124}, {7, 204, 0}} ,{{86, 124}, {247, 203, 0}} ,{{80, 124}, {241, 203, 0}} ,{{81, 124}, {242, 203, 0}} ,{{82, 124}, {243, 203, 0}} ,{{106, 124}, {11, 204, 0}} ,{{101, 124}, {6, 204, 0}} ,{{103, 124}, {8, 204, 0}} ,{{87, 124}, {248, 203, 0}} ,{{90, 124}, {251, 203, 0}} ,{{88, 124}, {249, 203, 0}} ,{{94, 124}, {255, 203, 0}} ,{{89, 124}, {250, 203, 0}} ,{{93, 124}, {254, 203, 0}} ,{{91, 124}, {252, 203, 0}} ,{{92, 124}, {253, 203, 0}} ,{{95, 124}, {0, 204, 0}} ,{{83, 124}, {244, 203, 0}} ,{{100, 124}, {5, 204, 0}} ,{{85, 124}, {246, 203, 0}} ,{{84, 124}, {245, 203, 0}} ,{{105, 124}, {10, 204, 0}} ,{{98, 124}, {3, 204, 0}} ,{{99, 124}, {4, 204, 0}} ,{{104, 124}, {9, 204, 0}} ,{{139, 123}, {44, 203, 0}} ,{{156, 123}, {61, 203, 0}} ,{{157, 123}, {62, 203, 0}} ,{{162, 123}, {67, 203, 0}} ,{{146, 123}, {51, 203, 0}} ,{{140, 123}, {45, 203, 0}} ,{{141, 123}, {46, 203, 0}} ,{{142, 123}, {47, 203, 0}} ,{{166, 123}, {71, 203, 0}} ,{{161, 123}, {66, 203, 0}} ,{{163, 123}, {68, 203, 0}} ,{{147, 123}, {52, 203, 0}} ,{{150, 123}, {55, 203, 0}} ,{{148, 123}, {53, 203, 0}} ,{{154, 123}, {59, 203, 0}} ,{{149, 123}, {54, 203, 0}} ,{{153, 123}, {58, 203, 0}} ,{{151, 123}, {56, 203, 0}} ,{{152, 123}, {57, 203, 0}} ,{{155, 123}, {60, 203, 0}} ,{{143, 123}, {48, 203, 0}} ,{{160, 123}, {65, 203, 0}} ,{{145, 123}, {50, 203, 0}} ,{{144, 123}, {49, 203, 0}} ,{{165, 123}, {70, 203, 0}} ,{{158, 123}, {63, 203, 0}} ,{{159, 123}, {64, 203, 0}} ,{{164, 123}, {69, 203, 0}} ,{{23, 124}, {184, 203, 0}} ,{{40, 124}, {201, 203, 0}} ,{{41, 124}, {202, 203, 0}} ,{{46, 124}, {207, 203, 0}} ,{{30, 124}, {191, 203, 0}} ,{{24, 124}, {185, 203, 0}} ,{{25, 124}, {186, 203, 0}} ,{{26, 124}, {187, 203, 0}} ,{{50, 124}, {211, 203, 0}} ,{{45, 124}, {206, 203, 0}} ,{{47, 124}, {208, 203, 0}} ,{{31, 124}, {192, 203, 0}} ,{{34, 124}, {195, 203, 0}} ,{{32, 124}, {193, 203, 0}} ,{{38, 124}, {199, 203, 0}} ,{{33, 124}, {194, 203, 0}} ,{{37, 124}, {198, 203, 0}} ,{{35, 124}, {196, 203, 0}} ,{{36, 124}, {197, 203, 0}} ,{{39, 124}, {200, 203, 0}} ,{{27, 124}, {188, 203, 0}} ,{{44, 124}, {205, 203, 0}} ,{{29, 124}, {190, 203, 0}} ,{{28, 124}, {189, 203, 0}} ,{{49, 124}, {210, 203, 0}} ,{{42, 124}, {203, 203, 0}} ,{{43, 124}, {204, 203, 0}} ,{{48, 124}, {209, 203, 0}} ,{{207, 120}, {112, 200, 0}} ,{{224, 120}, {129, 200, 0}} ,{{225, 120}, {130, 200, 0}} ,{{230, 120}, {135, 200, 0}} ,{{214, 120}, {119, 200, 0}} ,{{35, 121}, {196, 200, 0}} ,{{52, 121}, {213, 200, 0}} ,{{53, 121}, {214, 200, 0}} ,{{58, 121}, {219, 200, 0}} ,{{42, 121}, {203, 200, 0}} ,{{36, 121}, {197, 200, 0}} ,{{37, 121}, {198, 200, 0}} ,{{38, 121}, {199, 200, 0}} ,{{62, 121}, {223, 200, 0}} ,{{57, 121}, {218, 200, 0}} ,{{59, 121}, {220, 200, 0}} ,{{43, 121}, {204, 200, 0}} ,{{46, 121}, {207, 200, 0}} ,{{44, 121}, {205, 200, 0}} ,{{50, 121}, {211, 200, 0}} ,{{45, 121}, {206, 200, 0}} ,{{49, 121}, {210, 200, 0}} ,{{47, 121}, {208, 200, 0}} ,{{48, 121}, {209, 200, 0}} ,{{51, 121}, {212, 200, 0}} ,{{39, 121}, {200, 200, 0}} ,{{56, 121}, {217, 200, 0}} ,{{41, 121}, {202, 200, 0}} ,{{40, 121}, {201, 200, 0}} ,{{61, 121}, {222, 200, 0}} ,{{54, 121}, {215, 200, 0}} ,{{55, 121}, {216, 200, 0}} ,{{60, 121}, {221, 200, 0}} ,{{208, 120}, {113, 200, 0}} ,{{209, 120}, {114, 200, 0}} ,{{210, 120}, {115, 200, 0}} ,{{234, 120}, {139, 200, 0}} ,{{229, 120}, {134, 200, 0}} ,{{231, 120}, {136, 200, 0}} ,{{215, 120}, {120, 200, 0}} ,{{218, 120}, {123, 200, 0}} ,{{216, 120}, {121, 200, 0}} ,{{222, 120}, {127, 200, 0}} ,{{217, 120}, {122, 200, 0}} ,{{221, 120}, {126, 200, 0}} ,{{219, 120}, {124, 200, 0}} ,{{220, 120}, {125, 200, 0}} ,{{223, 120}, {128, 200, 0}} ,{{211, 120}, {116, 200, 0}} ,{{228, 120}, {133, 200, 0}} ,{{213, 120}, {118, 200, 0}} ,{{212, 120}, {117, 200, 0}} ,{{233, 120}, {138, 200, 0}} ,{{226, 120}, {131, 200, 0}} ,{{227, 120}, {132, 200, 0}} ,{{232, 120}, {137, 200, 0}} ,{{91, 121}, {252, 200, 0}} ,{{108, 121}, {13, 201, 0}} ,{{109, 121}, {14, 201, 0}} ,{{114, 121}, {19, 201, 0}} ,{{98, 121}, {3, 201, 0}} ,{{92, 121}, {253, 200, 0}} ,{{93, 121}, {254, 200, 0}} ,{{94, 121}, {255, 200, 0}} ,{{118, 121}, {23, 201, 0}} ,{{113, 121}, {18, 201, 0}} ,{{115, 121}, {20, 201, 0}} ,{{99, 121}, {4, 201, 0}} ,{{102, 121}, {7, 201, 0}} ,{{100, 121}, {5, 201, 0}} ,{{106, 121}, {11, 201, 0}} ,{{101, 121}, {6, 201, 0}} ,{{105, 121}, {10, 201, 0}} ,{{103, 121}, {8, 201, 0}} ,{{104, 121}, {9, 201, 0}} ,{{107, 121}, {12, 201, 0}} ,{{95, 121}, {0, 201, 0}} ,{{112, 121}, {17, 201, 0}} ,{{97, 121}, {2, 201, 0}} ,{{96, 121}, {1, 201, 0}} ,{{117, 121}, {22, 201, 0}} ,{{110, 121}, {15, 201, 0}} ,{{111, 121}, {16, 201, 0}} ,{{116, 121}, {21, 201, 0}} ,{{235, 120}, {140, 200, 0}} ,{{252, 120}, {157, 200, 0}} ,{{253, 120}, {158, 200, 0}} ,{{2, 121}, {163, 200, 0}} ,{{242, 120}, {147, 200, 0}} ,{{7, 121}, {168, 200, 0}} ,{{24, 121}, {185, 200, 0}} ,{{25, 121}, {186, 200, 0}} ,{{30, 121}, {191, 200, 0}} ,{{14, 121}, {175, 200, 0}} ,{{8, 121}, {169, 200, 0}} ,{{9, 121}, {170, 200, 0}} ,{{10, 121}, {171, 200, 0}} ,{{34, 121}, {195, 200, 0}} ,{{29, 121}, {190, 200, 0}} ,{{31, 121}, {192, 200, 0}} ,{{15, 121}, {176, 200, 0}} ,{{18, 121}, {179, 200, 0}} ,{{16, 121}, {177, 200, 0}} ,{{22, 121}, {183, 200, 0}} ,{{17, 121}, {178, 200, 0}} ,{{21, 121}, {182, 200, 0}} ,{{19, 121}, {180, 200, 0}} ,{{20, 121}, {181, 200, 0}} ,{{23, 121}, {184, 200, 0}} ,{{11, 121}, {172, 200, 0}} ,{{28, 121}, {189, 200, 0}} ,{{13, 121}, {174, 200, 0}} ,{{12, 121}, {173, 200, 0}} ,{{33, 121}, {194, 200, 0}} ,{{26, 121}, {187, 200, 0}} ,{{27, 121}, {188, 200, 0}} ,{{32, 121}, {193, 200, 0}} ,{{236, 120}, {141, 200, 0}} ,{{237, 120}, {142, 200, 0}} ,{{238, 120}, {143, 200, 0}} ,{{6, 121}, {167, 200, 0}} ,{{1, 121}, {162, 200, 0}} ,{{3, 121}, {164, 200, 0}} ,{{243, 120}, {148, 200, 0}} ,{{246, 120}, {151, 200, 0}} ,{{244, 120}, {149, 200, 0}} ,{{250, 120}, {155, 200, 0}} ,{{245, 120}, {150, 200, 0}} ,{{249, 120}, {154, 200, 0}} ,{{247, 120}, {152, 200, 0}} ,{{248, 120}, {153, 200, 0}} ,{{251, 120}, {156, 200, 0}} ,{{239, 120}, {144, 200, 0}} ,{{0, 121}, {161, 200, 0}} ,{{241, 120}, {146, 200, 0}} ,{{240, 120}, {145, 200, 0}} ,{{5, 121}, {166, 200, 0}} ,{{254, 120}, {159, 200, 0}} ,{{255, 120}, {160, 200, 0}} ,{{4, 121}, {165, 200, 0}} ,{{147, 121}, {52, 201, 0}} ,{{164, 121}, {69, 201, 0}} ,{{165, 121}, {70, 201, 0}} ,{{170, 121}, {75, 201, 0}} ,{{154, 121}, {59, 201, 0}} ,{{148, 121}, {53, 201, 0}} ,{{149, 121}, {54, 201, 0}} ,{{150, 121}, {55, 201, 0}} ,{{174, 121}, {79, 201, 0}} ,{{169, 121}, {74, 201, 0}} ,{{171, 121}, {76, 201, 0}} ,{{155, 121}, {60, 201, 0}} ,{{158, 121}, {63, 201, 0}} ,{{156, 121}, {61, 201, 0}} ,{{162, 121}, {67, 201, 0}} ,{{157, 121}, {62, 201, 0}} ,{{161, 121}, {66, 201, 0}} ,{{159, 121}, {64, 201, 0}} ,{{160, 121}, {65, 201, 0}} ,{{163, 121}, {68, 201, 0}} ,{{151, 121}, {56, 201, 0}} ,{{168, 121}, {73, 201, 0}} ,{{153, 121}, {58, 201, 0}} ,{{152, 121}, {57, 201, 0}} ,{{119, 121}, {24, 201, 0}} ,{{136, 121}, {41, 201, 0}} ,{{137, 121}, {42, 201, 0}} ,{{142, 121}, {47, 201, 0}} ,{{126, 121}, {31, 201, 0}} ,{{120, 121}, {25, 201, 0}} ,{{121, 121}, {26, 201, 0}} ,{{122, 121}, {27, 201, 0}} ,{{146, 121}, {51, 201, 0}} ,{{141, 121}, {46, 201, 0}} ,{{143, 121}, {48, 201, 0}} ,{{127, 121}, {32, 201, 0}} ,{{130, 121}, {35, 201, 0}} ,{{128, 121}, {33, 201, 0}} ,{{134, 121}, {39, 201, 0}} ,{{129, 121}, {34, 201, 0}} ,{{133, 121}, {38, 201, 0}} ,{{131, 121}, {36, 201, 0}} ,{{132, 121}, {37, 201, 0}} ,{{135, 121}, {40, 201, 0}} ,{{123, 121}, {28, 201, 0}} ,{{140, 121}, {45, 201, 0}} ,{{125, 121}, {30, 201, 0}} ,{{124, 121}, {29, 201, 0}} ,{{145, 121}, {50, 201, 0}} ,{{138, 121}, {43, 201, 0}} ,{{139, 121}, {44, 201, 0}} ,{{144, 121}, {49, 201, 0}} ,{{173, 121}, {78, 201, 0}} ,{{166, 121}, {71, 201, 0}} ,{{167, 121}, {72, 201, 0}} ,{{172, 121}, {77, 201, 0}} ,{{175, 121}, {80, 201, 0}} ,{{192, 121}, {97, 201, 0}} ,{{193, 121}, {98, 201, 0}} ,{{198, 121}, {103, 201, 0}} ,{{182, 121}, {87, 201, 0}} ,{{176, 121}, {81, 201, 0}} ,{{177, 121}, {82, 201, 0}} ,{{178, 121}, {83, 201, 0}} ,{{202, 121}, {107, 201, 0}} ,{{197, 121}, {102, 201, 0}} ,{{199, 121}, {104, 201, 0}} ,{{183, 121}, {88, 201, 0}} ,{{186, 121}, {91, 201, 0}} ,{{184, 121}, {89, 201, 0}} ,{{190, 121}, {95, 201, 0}} ,{{185, 121}, {90, 201, 0}} ,{{189, 121}, {94, 201, 0}} ,{{187, 121}, {92, 201, 0}} ,{{188, 121}, {93, 201, 0}} ,{{191, 121}, {96, 201, 0}} ,{{179, 121}, {84, 201, 0}} ,{{196, 121}, {101, 201, 0}} ,{{181, 121}, {86, 201, 0}} ,{{180, 121}, {85, 201, 0}} ,{{201, 121}, {106, 201, 0}} ,{{194, 121}, {99, 201, 0}} ,{{195, 121}, {100, 201, 0}} ,{{200, 121}, {105, 201, 0}} ,{{39, 120}, {200, 199, 0}} ,{{56, 120}, {217, 199, 0}} ,{{57, 120}, {218, 199, 0}} ,{{62, 120}, {223, 199, 0}} ,{{46, 120}, {207, 199, 0}} ,{{67, 120}, {228, 199, 0}} ,{{84, 120}, {245, 199, 0}} ,{{85, 120}, {246, 199, 0}} ,{{90, 120}, {251, 199, 0}} ,{{74, 120}, {235, 199, 0}} ,{{68, 120}, {229, 199, 0}} ,{{69, 120}, {230, 199, 0}} ,{{70, 120}, {231, 199, 0}} ,{{94, 120}, {255, 199, 0}} ,{{89, 120}, {250, 199, 0}} ,{{91, 120}, {252, 199, 0}} ,{{75, 120}, {236, 199, 0}} ,{{78, 120}, {239, 199, 0}} ,{{76, 120}, {237, 199, 0}} ,{{82, 120}, {243, 199, 0}} ,{{77, 120}, {238, 199, 0}} ,{{81, 120}, {242, 199, 0}} ,{{79, 120}, {240, 199, 0}} ,{{80, 120}, {241, 199, 0}} ,{{83, 120}, {244, 199, 0}} ,{{71, 120}, {232, 199, 0}} ,{{88, 120}, {249, 199, 0}} ,{{73, 120}, {234, 199, 0}} ,{{72, 120}, {233, 199, 0}} ,{{93, 120}, {254, 199, 0}} ,{{86, 120}, {247, 199, 0}} ,{{87, 120}, {248, 199, 0}} ,{{92, 120}, {253, 199, 0}} ,{{40, 120}, {201, 199, 0}} ,{{41, 120}, {202, 199, 0}} ,{{42, 120}, {203, 199, 0}} ,{{66, 120}, {227, 199, 0}} ,{{61, 120}, {222, 199, 0}} ,{{63, 120}, {224, 199, 0}} ,{{47, 120}, {208, 199, 0}} ,{{50, 120}, {211, 199, 0}} ,{{48, 120}, {209, 199, 0}} ,{{54, 120}, {215, 199, 0}} ,{{49, 120}, {210, 199, 0}} ,{{53, 120}, {214, 199, 0}} ,{{51, 120}, {212, 199, 0}} ,{{52, 120}, {213, 199, 0}} ,{{55, 120}, {216, 199, 0}} ,{{43, 120}, {204, 199, 0}} ,{{60, 120}, {221, 199, 0}} ,{{45, 120}, {206, 199, 0}} ,{{44, 120}, {205, 199, 0}} ,{{65, 120}, {226, 199, 0}} ,{{58, 120}, {219, 199, 0}} ,{{59, 120}, {220, 199, 0}} ,{{64, 120}, {225, 199, 0}} ,{{179, 120}, {84, 200, 0}} ,{{196, 120}, {101, 200, 0}} ,{{197, 120}, {102, 200, 0}} ,{{202, 120}, {107, 200, 0}} ,{{186, 120}, {91, 200, 0}} ,{{180, 120}, {85, 200, 0}} ,{{181, 120}, {86, 200, 0}} ,{{182, 120}, {87, 200, 0}} ,{{206, 120}, {111, 200, 0}} ,{{201, 120}, {106, 200, 0}} ,{{203, 120}, {108, 200, 0}} ,{{187, 120}, {92, 200, 0}} ,{{190, 120}, {95, 200, 0}} ,{{188, 120}, {93, 200, 0}} ,{{194, 120}, {99, 200, 0}} ,{{189, 120}, {94, 200, 0}} ,{{193, 120}, {98, 200, 0}} ,{{191, 120}, {96, 200, 0}} ,{{192, 120}, {97, 200, 0}} ,{{195, 120}, {100, 200, 0}} ,{{183, 120}, {88, 200, 0}} ,{{200, 120}, {105, 200, 0}} ,{{185, 120}, {90, 200, 0}} ,{{184, 120}, {89, 200, 0}} ,{{151, 120}, {56, 200, 0}} ,{{168, 120}, {73, 200, 0}} ,{{169, 120}, {74, 200, 0}} ,{{174, 120}, {79, 200, 0}} ,{{158, 120}, {63, 200, 0}} ,{{152, 120}, {57, 200, 0}} ,{{153, 120}, {58, 200, 0}} ,{{154, 120}, {59, 200, 0}} ,{{178, 120}, {83, 200, 0}} ,{{173, 120}, {78, 200, 0}} ,{{175, 120}, {80, 200, 0}} ,{{159, 120}, {64, 200, 0}} ,{{162, 120}, {67, 200, 0}} ,{{160, 120}, {65, 200, 0}} ,{{166, 120}, {71, 200, 0}} ,{{161, 120}, {66, 200, 0}} ,{{165, 120}, {70, 200, 0}} ,{{163, 120}, {68, 200, 0}} ,{{164, 120}, {69, 200, 0}} ,{{167, 120}, {72, 200, 0}} ,{{155, 120}, {60, 200, 0}} ,{{172, 120}, {77, 200, 0}} ,{{157, 120}, {62, 200, 0}} ,{{156, 120}, {61, 200, 0}} ,{{177, 120}, {82, 200, 0}} ,{{170, 120}, {75, 200, 0}} ,{{171, 120}, {76, 200, 0}} ,{{176, 120}, {81, 200, 0}} ,{{205, 120}, {110, 200, 0}} ,{{198, 120}, {103, 200, 0}} ,{{199, 120}, {104, 200, 0}} ,{{204, 120}, {109, 200, 0}} ,{{3, 122}, {164, 201, 0}} ,{{20, 122}, {181, 201, 0}} ,{{21, 122}, {182, 201, 0}} ,{{26, 122}, {187, 201, 0}} ,{{10, 122}, {171, 201, 0}} ,{{4, 122}, {165, 201, 0}} ,{{5, 122}, {166, 201, 0}} ,{{6, 122}, {167, 201, 0}} ,{{30, 122}, {191, 201, 0}} ,{{25, 122}, {186, 201, 0}} ,{{27, 122}, {188, 201, 0}} ,{{11, 122}, {172, 201, 0}} ,{{14, 122}, {175, 201, 0}} ,{{12, 122}, {173, 201, 0}} ,{{18, 122}, {179, 201, 0}} ,{{13, 122}, {174, 201, 0}} ,{{17, 122}, {178, 201, 0}} ,{{15, 122}, {176, 201, 0}} ,{{16, 122}, {177, 201, 0}} ,{{19, 122}, {180, 201, 0}} ,{{7, 122}, {168, 201, 0}} ,{{24, 122}, {185, 201, 0}} ,{{9, 122}, {170, 201, 0}} ,{{8, 122}, {169, 201, 0}} ,{{29, 122}, {190, 201, 0}} ,{{22, 122}, {183, 201, 0}} ,{{23, 122}, {184, 201, 0}} ,{{28, 122}, {189, 201, 0}} ,{{63, 121}, {224, 200, 0}} ,{{80, 121}, {241, 200, 0}} ,{{81, 121}, {242, 200, 0}} ,{{86, 121}, {247, 200, 0}} ,{{70, 121}, {231, 200, 0}} ,{{64, 121}, {225, 200, 0}} ,{{65, 121}, {226, 200, 0}} ,{{66, 121}, {227, 200, 0}} ,{{90, 121}, {251, 200, 0}} ,{{85, 121}, {246, 200, 0}} ,{{87, 121}, {248, 200, 0}} ,{{71, 121}, {232, 200, 0}} ,{{74, 121}, {235, 200, 0}} ,{{72, 121}, {233, 200, 0}} ,{{78, 121}, {239, 200, 0}} ,{{73, 121}, {234, 200, 0}} ,{{77, 121}, {238, 200, 0}} ,{{75, 121}, {236, 200, 0}} ,{{76, 121}, {237, 200, 0}} ,{{79, 121}, {240, 200, 0}} ,{{67, 121}, {228, 200, 0}} ,{{84, 121}, {245, 200, 0}} ,{{69, 121}, {230, 200, 0}} ,{{68, 121}, {229, 200, 0}} ,{{89, 121}, {250, 200, 0}} ,{{82, 121}, {243, 200, 0}} ,{{83, 121}, {244, 200, 0}} ,{{88, 121}, {249, 200, 0}} ,{{203, 121}, {108, 201, 0}} ,{{220, 121}, {125, 201, 0}} ,{{221, 121}, {126, 201, 0}} ,{{226, 121}, {131, 201, 0}} ,{{210, 121}, {115, 201, 0}} ,{{204, 121}, {109, 201, 0}} ,{{205, 121}, {110, 201, 0}} ,{{206, 121}, {111, 201, 0}} ,{{230, 121}, {135, 201, 0}} ,{{225, 121}, {130, 201, 0}} ,{{227, 121}, {132, 201, 0}} ,{{211, 121}, {116, 201, 0}} ,{{214, 121}, {119, 201, 0}} ,{{212, 121}, {117, 201, 0}} ,{{218, 121}, {123, 201, 0}} ,{{213, 121}, {118, 201, 0}} ,{{217, 121}, {122, 201, 0}} ,{{215, 121}, {120, 201, 0}} ,{{216, 121}, {121, 201, 0}} ,{{219, 121}, {124, 201, 0}} ,{{207, 121}, {112, 201, 0}} ,{{224, 121}, {129, 201, 0}} ,{{209, 121}, {114, 201, 0}} ,{{208, 121}, {113, 201, 0}} ,{{229, 121}, {134, 201, 0}} ,{{222, 121}, {127, 201, 0}} ,{{223, 121}, {128, 201, 0}} ,{{228, 121}, {133, 201, 0}} ,{{211, 126}, {116, 206, 0}} ,{{228, 126}, {133, 206, 0}} ,{{229, 126}, {134, 206, 0}} ,{{234, 126}, {139, 206, 0}} ,{{218, 126}, {123, 206, 0}} ,{{239, 126}, {144, 206, 0}} ,{{0, 127}, {161, 206, 0}} ,{{1, 127}, {162, 206, 0}} ,{{6, 127}, {167, 206, 0}} ,{{246, 126}, {151, 206, 0}} ,{{240, 126}, {145, 206, 0}} ,{{241, 126}, {146, 206, 0}} ,{{242, 126}, {147, 206, 0}} ,{{10, 127}, {171, 206, 0}} ,{{5, 127}, {166, 206, 0}} ,{{7, 127}, {168, 206, 0}} ,{{247, 126}, {152, 206, 0}} ,{{250, 126}, {155, 206, 0}} ,{{248, 126}, {153, 206, 0}} ,{{254, 126}, {159, 206, 0}} ,{{249, 126}, {154, 206, 0}} ,{{253, 126}, {158, 206, 0}} ,{{251, 126}, {156, 206, 0}} ,{{252, 126}, {157, 206, 0}} ,{{255, 126}, {160, 206, 0}} ,{{243, 126}, {148, 206, 0}} ,{{4, 127}, {165, 206, 0}} ,{{245, 126}, {150, 206, 0}} ,{{244, 126}, {149, 206, 0}} ,{{9, 127}, {170, 206, 0}} ,{{2, 127}, {163, 206, 0}} ,{{3, 127}, {164, 206, 0}} ,{{8, 127}, {169, 206, 0}} ,{{212, 126}, {117, 206, 0}} ,{{213, 126}, {118, 206, 0}} ,{{214, 126}, {119, 206, 0}} ,{{238, 126}, {143, 206, 0}} ,{{233, 126}, {138, 206, 0}} ,{{235, 126}, {140, 206, 0}} ,{{219, 126}, {124, 206, 0}} ,{{222, 126}, {127, 206, 0}} ,{{220, 126}, {125, 206, 0}} ,{{226, 126}, {131, 206, 0}} ,{{221, 126}, {126, 206, 0}} ,{{225, 126}, {130, 206, 0}} ,{{223, 126}, {128, 206, 0}} ,{{224, 126}, {129, 206, 0}} ,{{227, 126}, {132, 206, 0}} ,{{215, 126}, {120, 206, 0}} ,{{232, 126}, {137, 206, 0}} ,{{217, 126}, {122, 206, 0}} ,{{216, 126}, {121, 206, 0}} ,{{237, 126}, {142, 206, 0}} ,{{230, 126}, {135, 206, 0}} ,{{231, 126}, {136, 206, 0}} ,{{236, 126}, {141, 206, 0}} ,{{95, 127}, {0, 207, 0}} ,{{112, 127}, {17, 207, 0}} ,{{113, 127}, {18, 207, 0}} ,{{118, 127}, {23, 207, 0}} ,{{102, 127}, {7, 207, 0}} ,{{96, 127}, {1, 207, 0}} ,{{97, 127}, {2, 207, 0}} ,{{98, 127}, {3, 207, 0}} ,{{122, 127}, {27, 207, 0}} ,{{117, 127}, {22, 207, 0}} ,{{119, 127}, {24, 207, 0}} ,{{103, 127}, {8, 207, 0}} ,{{106, 127}, {11, 207, 0}} ,{{104, 127}, {9, 207, 0}} ,{{110, 127}, {15, 207, 0}} ,{{105, 127}, {10, 207, 0}} ,{{109, 127}, {14, 207, 0}} ,{{107, 127}, {12, 207, 0}} ,{{108, 127}, {13, 207, 0}} ,{{111, 127}, {16, 207, 0}} ,{{99, 127}, {4, 207, 0}} ,{{116, 127}, {21, 207, 0}} ,{{101, 127}, {6, 207, 0}} ,{{100, 127}, {5, 207, 0}} ,{{67, 127}, {228, 206, 0}} ,{{84, 127}, {245, 206, 0}} ,{{85, 127}, {246, 206, 0}} ,{{90, 127}, {251, 206, 0}} ,{{74, 127}, {235, 206, 0}} ,{{68, 127}, {229, 206, 0}} ,{{69, 127}, {230, 206, 0}} ,{{70, 127}, {231, 206, 0}} ,{{94, 127}, {255, 206, 0}} ,{{89, 127}, {250, 206, 0}} ,{{91, 127}, {252, 206, 0}} ,{{75, 127}, {236, 206, 0}} ,{{78, 127}, {239, 206, 0}} ,{{76, 127}, {237, 206, 0}} ,{{82, 127}, {243, 206, 0}} ,{{77, 127}, {238, 206, 0}} ,{{81, 127}, {242, 206, 0}} ,{{79, 127}, {240, 206, 0}} ,{{80, 127}, {241, 206, 0}} ,{{83, 127}, {244, 206, 0}} ,{{71, 127}, {232, 206, 0}} ,{{88, 127}, {249, 206, 0}} ,{{73, 127}, {234, 206, 0}} ,{{72, 127}, {233, 206, 0}} ,{{93, 127}, {254, 206, 0}} ,{{86, 127}, {247, 206, 0}} ,{{87, 127}, {248, 206, 0}} ,{{92, 127}, {253, 206, 0}} ,{{121, 127}, {26, 207, 0}} ,{{114, 127}, {19, 207, 0}} ,{{115, 127}, {20, 207, 0}} ,{{120, 127}, {25, 207, 0}} ,{{203, 128}, {108, 208, 0}} ,{{220, 128}, {125, 208, 0}} ,{{221, 128}, {126, 208, 0}} ,{{226, 128}, {131, 208, 0}} ,{{210, 128}, {115, 208, 0}} ,{{204, 128}, {109, 208, 0}} ,{{205, 128}, {110, 208, 0}} ,{{206, 128}, {111, 208, 0}} ,{{230, 128}, {135, 208, 0}} ,{{225, 128}, {130, 208, 0}} ,{{227, 128}, {132, 208, 0}} ,{{211, 128}, {116, 208, 0}} ,{{214, 128}, {119, 208, 0}} ,{{212, 128}, {117, 208, 0}} ,{{218, 128}, {123, 208, 0}} ,{{213, 128}, {118, 208, 0}} ,{{217, 128}, {122, 208, 0}} ,{{215, 128}, {120, 208, 0}} ,{{216, 128}, {121, 208, 0}} ,{{219, 128}, {124, 208, 0}} ,{{207, 128}, {112, 208, 0}} ,{{224, 128}, {129, 208, 0}} ,{{209, 128}, {114, 208, 0}} ,{{208, 128}, {113, 208, 0}} ,{{229, 128}, {134, 208, 0}} ,{{222, 128}, {127, 208, 0}} ,{{223, 128}, {128, 208, 0}} ,{{228, 128}, {133, 208, 0}} ,{{3, 129}, {164, 208, 0}} ,{{20, 129}, {181, 208, 0}} ,{{21, 129}, {182, 208, 0}} ,{{26, 129}, {187, 208, 0}} ,{{10, 129}, {171, 208, 0}} ,{{4, 129}, {165, 208, 0}} ,{{5, 129}, {166, 208, 0}} ,{{6, 129}, {167, 208, 0}} ,{{30, 129}, {191, 208, 0}} ,{{25, 129}, {186, 208, 0}} ,{{27, 129}, {188, 208, 0}} ,{{11, 129}, {172, 208, 0}} ,{{14, 129}, {175, 208, 0}} ,{{12, 129}, {173, 208, 0}} ,{{18, 129}, {179, 208, 0}} ,{{13, 129}, {174, 208, 0}} ,{{17, 129}, {178, 208, 0}} ,{{15, 129}, {176, 208, 0}} ,{{16, 129}, {177, 208, 0}} ,{{19, 129}, {180, 208, 0}} ,{{7, 129}, {168, 208, 0}} ,{{24, 129}, {185, 208, 0}} ,{{9, 129}, {170, 208, 0}} ,{{8, 129}, {169, 208, 0}} ,{{29, 129}, {190, 208, 0}} ,{{22, 129}, {183, 208, 0}} ,{{23, 129}, {184, 208, 0}} ,{{28, 129}, {189, 208, 0}} ,{{179, 127}, {84, 207, 0}} ,{{196, 127}, {101, 207, 0}} ,{{197, 127}, {102, 207, 0}} ,{{202, 127}, {107, 207, 0}} ,{{186, 127}, {91, 207, 0}} ,{{7, 128}, {168, 207, 0}} ,{{24, 128}, {185, 207, 0}} ,{{25, 128}, {186, 207, 0}} ,{{30, 128}, {191, 207, 0}} ,{{14, 128}, {175, 207, 0}} ,{{8, 128}, {169, 207, 0}} ,{{9, 128}, {170, 207, 0}} ,{{10, 128}, {171, 207, 0}} ,{{34, 128}, {195, 207, 0}} ,{{29, 128}, {190, 207, 0}} ,{{31, 128}, {192, 207, 0}} ,{{15, 128}, {176, 207, 0}} ,{{18, 128}, {179, 207, 0}} ,{{16, 128}, {177, 207, 0}} ,{{22, 128}, {183, 207, 0}} ,{{17, 128}, {178, 207, 0}} ,{{21, 128}, {182, 207, 0}} ,{{19, 128}, {180, 207, 0}} ,{{20, 128}, {181, 207, 0}} ,{{23, 128}, {184, 207, 0}} ,{{11, 128}, {172, 207, 0}} ,{{28, 128}, {189, 207, 0}} ,{{13, 128}, {174, 207, 0}} ,{{12, 128}, {173, 207, 0}} ,{{33, 128}, {194, 207, 0}} ,{{26, 128}, {187, 207, 0}} ,{{27, 128}, {188, 207, 0}} ,{{32, 128}, {193, 207, 0}} ,{{180, 127}, {85, 207, 0}} ,{{181, 127}, {86, 207, 0}} ,{{182, 127}, {87, 207, 0}} ,{{206, 127}, {111, 207, 0}} ,{{201, 127}, {106, 207, 0}} ,{{203, 127}, {108, 207, 0}} ,{{187, 127}, {92, 207, 0}} ,{{190, 127}, {95, 207, 0}} ,{{188, 127}, {93, 207, 0}} ,{{194, 127}, {99, 207, 0}} ,{{189, 127}, {94, 207, 0}} ,{{193, 127}, {98, 207, 0}} ,{{191, 127}, {96, 207, 0}} ,{{192, 127}, {97, 207, 0}} ,{{195, 127}, {100, 207, 0}} ,{{183, 127}, {88, 207, 0}} ,{{200, 127}, {105, 207, 0}} ,{{185, 127}, {90, 207, 0}} ,{{184, 127}, {89, 207, 0}} ,{{205, 127}, {110, 207, 0}} ,{{198, 127}, {103, 207, 0}} ,{{199, 127}, {104, 207, 0}} ,{{204, 127}, {109, 207, 0}} ,{{63, 128}, {224, 207, 0}} ,{{80, 128}, {241, 207, 0}} ,{{81, 128}, {242, 207, 0}} ,{{86, 128}, {247, 207, 0}} ,{{70, 128}, {231, 207, 0}} ,{{64, 128}, {225, 207, 0}} ,{{65, 128}, {226, 207, 0}} ,{{66, 128}, {227, 207, 0}} ,{{90, 128}, {251, 207, 0}} ,{{85, 128}, {246, 207, 0}} ,{{87, 128}, {248, 207, 0}} ,{{71, 128}, {232, 207, 0}} ,{{74, 128}, {235, 207, 0}} ,{{72, 128}, {233, 207, 0}} ,{{78, 128}, {239, 207, 0}} ,{{73, 128}, {234, 207, 0}} ,{{77, 128}, {238, 207, 0}} ,{{75, 128}, {236, 207, 0}} ,{{76, 128}, {237, 207, 0}} ,{{79, 128}, {240, 207, 0}} ,{{67, 128}, {228, 207, 0}} ,{{84, 128}, {245, 207, 0}} ,{{69, 128}, {230, 207, 0}} ,{{68, 128}, {229, 207, 0}} ,{{89, 128}, {250, 207, 0}} ,{{82, 128}, {243, 207, 0}} ,{{83, 128}, {244, 207, 0}} ,{{88, 128}, {249, 207, 0}} ,{{207, 127}, {112, 207, 0}} ,{{224, 127}, {129, 207, 0}} ,{{225, 127}, {130, 207, 0}} ,{{230, 127}, {135, 207, 0}} ,{{214, 127}, {119, 207, 0}} ,{{235, 127}, {140, 207, 0}} ,{{252, 127}, {157, 207, 0}} ,{{253, 127}, {158, 207, 0}} ,{{2, 128}, {163, 207, 0}} ,{{242, 127}, {147, 207, 0}} ,{{236, 127}, {141, 207, 0}} ,{{237, 127}, {142, 207, 0}} ,{{238, 127}, {143, 207, 0}} ,{{6, 128}, {167, 207, 0}} ,{{1, 128}, {162, 207, 0}} ,{{3, 128}, {164, 207, 0}} ,{{243, 127}, {148, 207, 0}} ,{{246, 127}, {151, 207, 0}} ,{{244, 127}, {149, 207, 0}} ,{{250, 127}, {155, 207, 0}} ,{{245, 127}, {150, 207, 0}} ,{{249, 127}, {154, 207, 0}} ,{{247, 127}, {152, 207, 0}} ,{{248, 127}, {153, 207, 0}} ,{{251, 127}, {156, 207, 0}} ,{{239, 127}, {144, 207, 0}} ,{{0, 128}, {161, 207, 0}} ,{{241, 127}, {146, 207, 0}} ,{{240, 127}, {145, 207, 0}} ,{{5, 128}, {166, 207, 0}} ,{{254, 127}, {159, 207, 0}} ,{{255, 127}, {160, 207, 0}} ,{{4, 128}, {165, 207, 0}} ,{{208, 127}, {113, 207, 0}} ,{{209, 127}, {114, 207, 0}} ,{{210, 127}, {115, 207, 0}} ,{{234, 127}, {139, 207, 0}} ,{{229, 127}, {134, 207, 0}} ,{{231, 127}, {136, 207, 0}} ,{{215, 127}, {120, 207, 0}} ,{{218, 127}, {123, 207, 0}} ,{{216, 127}, {121, 207, 0}} ,{{222, 127}, {127, 207, 0}} ,{{217, 127}, {122, 207, 0}} ,{{221, 127}, {126, 207, 0}} ,{{219, 127}, {124, 207, 0}} ,{{220, 127}, {125, 207, 0}} ,{{223, 127}, {128, 207, 0}} ,{{211, 127}, {116, 207, 0}} ,{{228, 127}, {133, 207, 0}} ,{{213, 127}, {118, 207, 0}} ,{{212, 127}, {117, 207, 0}} ,{{233, 127}, {138, 207, 0}} ,{{226, 127}, {131, 207, 0}} ,{{227, 127}, {132, 207, 0}} ,{{232, 127}, {137, 207, 0}} ,{{119, 128}, {24, 208, 0}} ,{{136, 128}, {41, 208, 0}} ,{{137, 128}, {42, 208, 0}} ,{{142, 128}, {47, 208, 0}} ,{{126, 128}, {31, 208, 0}} ,{{120, 128}, {25, 208, 0}} ,{{121, 128}, {26, 208, 0}} ,{{122, 128}, {27, 208, 0}} ,{{146, 128}, {51, 208, 0}} ,{{141, 128}, {46, 208, 0}} ,{{143, 128}, {48, 208, 0}} ,{{127, 128}, {32, 208, 0}} ,{{130, 128}, {35, 208, 0}} ,{{128, 128}, {33, 208, 0}} ,{{134, 128}, {39, 208, 0}} ,{{129, 128}, {34, 208, 0}} ,{{133, 128}, {38, 208, 0}} ,{{131, 128}, {36, 208, 0}} ,{{132, 128}, {37, 208, 0}} ,{{135, 128}, {40, 208, 0}} ,{{123, 128}, {28, 208, 0}} ,{{140, 128}, {45, 208, 0}} ,{{125, 128}, {30, 208, 0}} ,{{124, 128}, {29, 208, 0}} ,{{91, 128}, {252, 207, 0}} ,{{108, 128}, {13, 208, 0}} ,{{109, 128}, {14, 208, 0}} ,{{114, 128}, {19, 208, 0}} ,{{98, 128}, {3, 208, 0}} ,{{92, 128}, {253, 207, 0}} ,{{93, 128}, {254, 207, 0}} ,{{94, 128}, {255, 207, 0}} ,{{118, 128}, {23, 208, 0}} ,{{113, 128}, {18, 208, 0}} ,{{115, 128}, {20, 208, 0}} ,{{99, 128}, {4, 208, 0}} ,{{102, 128}, {7, 208, 0}} ,{{100, 128}, {5, 208, 0}} ,{{106, 128}, {11, 208, 0}} ,{{101, 128}, {6, 208, 0}} ,{{105, 128}, {10, 208, 0}} ,{{103, 128}, {8, 208, 0}} ,{{104, 128}, {9, 208, 0}} ,{{107, 128}, {12, 208, 0}} ,{{95, 128}, {0, 208, 0}} ,{{112, 128}, {17, 208, 0}} ,{{97, 128}, {2, 208, 0}} ,{{96, 128}, {1, 208, 0}} ,{{117, 128}, {22, 208, 0}} ,{{110, 128}, {15, 208, 0}} ,{{111, 128}, {16, 208, 0}} ,{{116, 128}, {21, 208, 0}} ,{{145, 128}, {50, 208, 0}} ,{{138, 128}, {43, 208, 0}} ,{{139, 128}, {44, 208, 0}} ,{{144, 128}, {49, 208, 0}} ,{{147, 128}, {52, 208, 0}} ,{{164, 128}, {69, 208, 0}} ,{{165, 128}, {70, 208, 0}} ,{{170, 128}, {75, 208, 0}} ,{{154, 128}, {59, 208, 0}} ,{{148, 128}, {53, 208, 0}} ,{{149, 128}, {54, 208, 0}} ,{{150, 128}, {55, 208, 0}} ,{{174, 128}, {79, 208, 0}} ,{{169, 128}, {74, 208, 0}} ,{{171, 128}, {76, 208, 0}} ,{{155, 128}, {60, 208, 0}} ,{{158, 128}, {63, 208, 0}} ,{{156, 128}, {61, 208, 0}} ,{{162, 128}, {67, 208, 0}} ,{{157, 128}, {62, 208, 0}} ,{{161, 128}, {66, 208, 0}} ,{{159, 128}, {64, 208, 0}} ,{{160, 128}, {65, 208, 0}} ,{{163, 128}, {68, 208, 0}} ,{{151, 128}, {56, 208, 0}} ,{{168, 128}, {73, 208, 0}} ,{{153, 128}, {58, 208, 0}} ,{{152, 128}, {57, 208, 0}} ,{{173, 128}, {78, 208, 0}} ,{{166, 128}, {71, 208, 0}} ,{{167, 128}, {72, 208, 0}} ,{{172, 128}, {77, 208, 0}} ,{{11, 127}, {172, 206, 0}} ,{{28, 127}, {189, 206, 0}} ,{{29, 127}, {190, 206, 0}} ,{{34, 127}, {195, 206, 0}} ,{{18, 127}, {179, 206, 0}} ,{{39, 127}, {200, 206, 0}} ,{{56, 127}, {217, 206, 0}} ,{{57, 127}, {218, 206, 0}} ,{{62, 127}, {223, 206, 0}} ,{{46, 127}, {207, 206, 0}} ,{{40, 127}, {201, 206, 0}} ,{{41, 127}, {202, 206, 0}} ,{{42, 127}, {203, 206, 0}} ,{{66, 127}, {227, 206, 0}} ,{{61, 127}, {222, 206, 0}} ,{{63, 127}, {224, 206, 0}} ,{{47, 127}, {208, 206, 0}} ,{{50, 127}, {211, 206, 0}} ,{{48, 127}, {209, 206, 0}} ,{{54, 127}, {215, 206, 0}} ,{{49, 127}, {210, 206, 0}} ,{{53, 127}, {214, 206, 0}} ,{{51, 127}, {212, 206, 0}} ,{{52, 127}, {213, 206, 0}} ,{{55, 127}, {216, 206, 0}} ,{{43, 127}, {204, 206, 0}} ,{{60, 127}, {221, 206, 0}} ,{{45, 127}, {206, 206, 0}} ,{{44, 127}, {205, 206, 0}} ,{{65, 127}, {226, 206, 0}} ,{{58, 127}, {219, 206, 0}} ,{{59, 127}, {220, 206, 0}} ,{{64, 127}, {225, 206, 0}} ,{{12, 127}, {173, 206, 0}} ,{{13, 127}, {174, 206, 0}} ,{{14, 127}, {175, 206, 0}} ,{{38, 127}, {199, 206, 0}} ,{{33, 127}, {194, 206, 0}} ,{{35, 127}, {196, 206, 0}} ,{{19, 127}, {180, 206, 0}} ,{{22, 127}, {183, 206, 0}} ,{{20, 127}, {181, 206, 0}} ,{{26, 127}, {187, 206, 0}} ,{{21, 127}, {182, 206, 0}} ,{{25, 127}, {186, 206, 0}} ,{{23, 127}, {184, 206, 0}} ,{{24, 127}, {185, 206, 0}} ,{{27, 127}, {188, 206, 0}} ,{{15, 127}, {176, 206, 0}} ,{{32, 127}, {193, 206, 0}} ,{{17, 127}, {178, 206, 0}} ,{{16, 127}, {177, 206, 0}} ,{{37, 127}, {198, 206, 0}} ,{{30, 127}, {191, 206, 0}} ,{{31, 127}, {192, 206, 0}} ,{{36, 127}, {197, 206, 0}} ,{{151, 127}, {56, 207, 0}} ,{{168, 127}, {73, 207, 0}} ,{{169, 127}, {74, 207, 0}} ,{{174, 127}, {79, 207, 0}} ,{{158, 127}, {63, 207, 0}} ,{{152, 127}, {57, 207, 0}} ,{{153, 127}, {58, 207, 0}} ,{{154, 127}, {59, 207, 0}} ,{{178, 127}, {83, 207, 0}} ,{{173, 127}, {78, 207, 0}} ,{{175, 127}, {80, 207, 0}} ,{{159, 127}, {64, 207, 0}} ,{{162, 127}, {67, 207, 0}} ,{{160, 127}, {65, 207, 0}} ,{{166, 127}, {71, 207, 0}} ,{{161, 127}, {66, 207, 0}} ,{{165, 127}, {70, 207, 0}} ,{{163, 127}, {68, 207, 0}} ,{{164, 127}, {69, 207, 0}} ,{{167, 127}, {72, 207, 0}} ,{{155, 127}, {60, 207, 0}} ,{{172, 127}, {77, 207, 0}} ,{{157, 127}, {62, 207, 0}} ,{{156, 127}, {61, 207, 0}} ,{{123, 127}, {28, 207, 0}} ,{{140, 127}, {45, 207, 0}} ,{{141, 127}, {46, 207, 0}} ,{{146, 127}, {51, 207, 0}} ,{{130, 127}, {35, 207, 0}} ,{{124, 127}, {29, 207, 0}} ,{{125, 127}, {30, 207, 0}} ,{{126, 127}, {31, 207, 0}} ,{{150, 127}, {55, 207, 0}} ,{{145, 127}, {50, 207, 0}} ,{{147, 127}, {52, 207, 0}} ,{{131, 127}, {36, 207, 0}} ,{{134, 127}, {39, 207, 0}} ,{{132, 127}, {37, 207, 0}} ,{{138, 127}, {43, 207, 0}} ,{{133, 127}, {38, 207, 0}} ,{{137, 127}, {42, 207, 0}} ,{{135, 127}, {40, 207, 0}} ,{{136, 127}, {41, 207, 0}} ,{{139, 127}, {44, 207, 0}} ,{{127, 127}, {32, 207, 0}} ,{{144, 127}, {49, 207, 0}} ,{{129, 127}, {34, 207, 0}} ,{{128, 127}, {33, 207, 0}} ,{{149, 127}, {54, 207, 0}} ,{{142, 127}, {47, 207, 0}} ,{{143, 127}, {48, 207, 0}} ,{{148, 127}, {53, 207, 0}} ,{{177, 127}, {82, 207, 0}} ,{{170, 127}, {75, 207, 0}} ,{{171, 127}, {76, 207, 0}} ,{{176, 127}, {81, 207, 0}} ,{{231, 128}, {136, 208, 0}} ,{{248, 128}, {153, 208, 0}} ,{{249, 128}, {154, 208, 0}} ,{{254, 128}, {159, 208, 0}} ,{{238, 128}, {143, 208, 0}} ,{{232, 128}, {137, 208, 0}} ,{{233, 128}, {138, 208, 0}} ,{{234, 128}, {139, 208, 0}} ,{{2, 129}, {163, 208, 0}} ,{{253, 128}, {158, 208, 0}} ,{{255, 128}, {160, 208, 0}} ,{{239, 128}, {144, 208, 0}} ,{{242, 128}, {147, 208, 0}} ,{{240, 128}, {145, 208, 0}} ,{{246, 128}, {151, 208, 0}} ,{{241, 128}, {146, 208, 0}} ,{{245, 128}, {150, 208, 0}} ,{{243, 128}, {148, 208, 0}} ,{{244, 128}, {149, 208, 0}} ,{{247, 128}, {152, 208, 0}} ,{{235, 128}, {140, 208, 0}} ,{{252, 128}, {157, 208, 0}} ,{{237, 128}, {142, 208, 0}} ,{{236, 128}, {141, 208, 0}} ,{{1, 129}, {162, 208, 0}} ,{{250, 128}, {155, 208, 0}} ,{{251, 128}, {156, 208, 0}} ,{{0, 129}, {161, 208, 0}} ,{{35, 128}, {196, 207, 0}} ,{{52, 128}, {213, 207, 0}} ,{{53, 128}, {214, 207, 0}} ,{{58, 128}, {219, 207, 0}} ,{{42, 128}, {203, 207, 0}} ,{{36, 128}, {197, 207, 0}} ,{{37, 128}, {198, 207, 0}} ,{{38, 128}, {199, 207, 0}} ,{{62, 128}, {223, 207, 0}} ,{{57, 128}, {218, 207, 0}} ,{{59, 128}, {220, 207, 0}} ,{{43, 128}, {204, 207, 0}} ,{{46, 128}, {207, 207, 0}} ,{{44, 128}, {205, 207, 0}} ,{{50, 128}, {211, 207, 0}} ,{{45, 128}, {206, 207, 0}} ,{{49, 128}, {210, 207, 0}} ,{{47, 128}, {208, 207, 0}} ,{{48, 128}, {209, 207, 0}} ,{{51, 128}, {212, 207, 0}} ,{{39, 128}, {200, 207, 0}} ,{{56, 128}, {217, 207, 0}} ,{{41, 128}, {202, 207, 0}} ,{{40, 128}, {201, 207, 0}} ,{{61, 128}, {222, 207, 0}} ,{{54, 128}, {215, 207, 0}} ,{{55, 128}, {216, 207, 0}} ,{{60, 128}, {221, 207, 0}} ,{{175, 128}, {80, 208, 0}} ,{{192, 128}, {97, 208, 0}} ,{{193, 128}, {98, 208, 0}} ,{{198, 128}, {103, 208, 0}} ,{{182, 128}, {87, 208, 0}} ,{{176, 128}, {81, 208, 0}} ,{{177, 128}, {82, 208, 0}} ,{{178, 128}, {83, 208, 0}} ,{{202, 128}, {107, 208, 0}} ,{{197, 128}, {102, 208, 0}} ,{{199, 128}, {104, 208, 0}} ,{{183, 128}, {88, 208, 0}} ,{{186, 128}, {91, 208, 0}} ,{{184, 128}, {89, 208, 0}} ,{{190, 128}, {95, 208, 0}} ,{{185, 128}, {90, 208, 0}} ,{{189, 128}, {94, 208, 0}} ,{{187, 128}, {92, 208, 0}} ,{{188, 128}, {93, 208, 0}} ,{{191, 128}, {96, 208, 0}} ,{{179, 128}, {84, 208, 0}} ,{{196, 128}, {101, 208, 0}} ,{{181, 128}, {86, 208, 0}} ,{{180, 128}, {85, 208, 0}} ,{{201, 128}, {106, 208, 0}} ,{{194, 128}, {99, 208, 0}} ,{{195, 128}, {100, 208, 0}} ,{{200, 128}, {105, 208, 0}} ,{{39, 106}, {200, 185, 0}} ,{{56, 106}, {217, 185, 0}} ,{{57, 106}, {218, 185, 0}} ,{{62, 106}, {223, 185, 0}} ,{{46, 106}, {207, 185, 0}} ,{{67, 106}, {228, 185, 0}} ,{{84, 106}, {245, 185, 0}} ,{{85, 106}, {246, 185, 0}} ,{{90, 106}, {251, 185, 0}} ,{{74, 106}, {235, 185, 0}} ,{{68, 106}, {229, 185, 0}} ,{{69, 106}, {230, 185, 0}} ,{{70, 106}, {231, 185, 0}} ,{{94, 106}, {255, 185, 0}} ,{{89, 106}, {250, 185, 0}} ,{{91, 106}, {252, 185, 0}} ,{{75, 106}, {236, 185, 0}} ,{{78, 106}, {239, 185, 0}} ,{{76, 106}, {237, 185, 0}} ,{{82, 106}, {243, 185, 0}} ,{{77, 106}, {238, 185, 0}} ,{{81, 106}, {242, 185, 0}} ,{{79, 106}, {240, 185, 0}} ,{{80, 106}, {241, 185, 0}} ,{{83, 106}, {244, 185, 0}} ,{{71, 106}, {232, 185, 0}} ,{{88, 106}, {249, 185, 0}} ,{{73, 106}, {234, 185, 0}} ,{{72, 106}, {233, 185, 0}} ,{{93, 106}, {254, 185, 0}} ,{{86, 106}, {247, 185, 0}} ,{{87, 106}, {248, 185, 0}} ,{{92, 106}, {253, 185, 0}} ,{{40, 106}, {201, 185, 0}} ,{{41, 106}, {202, 185, 0}} ,{{42, 106}, {203, 185, 0}} ,{{66, 106}, {227, 185, 0}} ,{{61, 106}, {222, 185, 0}} ,{{63, 106}, {224, 185, 0}} ,{{47, 106}, {208, 185, 0}} ,{{50, 106}, {211, 185, 0}} ,{{48, 106}, {209, 185, 0}} ,{{54, 106}, {215, 185, 0}} ,{{49, 106}, {210, 185, 0}} ,{{53, 106}, {214, 185, 0}} ,{{51, 106}, {212, 185, 0}} ,{{52, 106}, {213, 185, 0}} ,{{55, 106}, {216, 185, 0}} ,{{43, 106}, {204, 185, 0}} ,{{60, 106}, {221, 185, 0}} ,{{45, 106}, {206, 185, 0}} ,{{44, 106}, {205, 185, 0}} ,{{65, 106}, {226, 185, 0}} ,{{58, 106}, {219, 185, 0}} ,{{59, 106}, {220, 185, 0}} ,{{64, 106}, {225, 185, 0}} ,{{179, 106}, {84, 186, 0}} ,{{196, 106}, {101, 186, 0}} ,{{197, 106}, {102, 186, 0}} ,{{202, 106}, {107, 186, 0}} ,{{186, 106}, {91, 186, 0}} ,{{180, 106}, {85, 186, 0}} ,{{181, 106}, {86, 186, 0}} ,{{182, 106}, {87, 186, 0}} ,{{206, 106}, {111, 186, 0}} ,{{201, 106}, {106, 186, 0}} ,{{203, 106}, {108, 186, 0}} ,{{187, 106}, {92, 186, 0}} ,{{190, 106}, {95, 186, 0}} ,{{188, 106}, {93, 186, 0}} ,{{194, 106}, {99, 186, 0}} ,{{189, 106}, {94, 186, 0}} ,{{193, 106}, {98, 186, 0}} ,{{191, 106}, {96, 186, 0}} ,{{192, 106}, {97, 186, 0}} ,{{195, 106}, {100, 186, 0}} ,{{183, 106}, {88, 186, 0}} ,{{200, 106}, {105, 186, 0}} ,{{185, 106}, {90, 186, 0}} ,{{184, 106}, {89, 186, 0}} ,{{151, 106}, {56, 186, 0}} ,{{168, 106}, {73, 186, 0}} ,{{169, 106}, {74, 186, 0}} ,{{174, 106}, {79, 186, 0}} ,{{158, 106}, {63, 186, 0}} ,{{152, 106}, {57, 186, 0}} ,{{153, 106}, {58, 186, 0}} ,{{154, 106}, {59, 186, 0}} ,{{178, 106}, {83, 186, 0}} ,{{173, 106}, {78, 186, 0}} ,{{175, 106}, {80, 186, 0}} ,{{159, 106}, {64, 186, 0}} ,{{162, 106}, {67, 186, 0}} ,{{160, 106}, {65, 186, 0}} ,{{166, 106}, {71, 186, 0}} ,{{161, 106}, {66, 186, 0}} ,{{165, 106}, {70, 186, 0}} ,{{163, 106}, {68, 186, 0}} ,{{164, 106}, {69, 186, 0}} ,{{167, 106}, {72, 186, 0}} ,{{155, 106}, {60, 186, 0}} ,{{172, 106}, {77, 186, 0}} ,{{157, 106}, {62, 186, 0}} ,{{156, 106}, {61, 186, 0}} ,{{177, 106}, {82, 186, 0}} ,{{170, 106}, {75, 186, 0}} ,{{171, 106}, {76, 186, 0}} ,{{176, 106}, {81, 186, 0}} ,{{205, 106}, {110, 186, 0}} ,{{198, 106}, {103, 186, 0}} ,{{199, 106}, {104, 186, 0}} ,{{204, 106}, {109, 186, 0}} ,{{31, 108}, {192, 187, 0}} ,{{48, 108}, {209, 187, 0}} ,{{49, 108}, {210, 187, 0}} ,{{54, 108}, {215, 187, 0}} ,{{38, 108}, {199, 187, 0}} ,{{32, 108}, {193, 187, 0}} ,{{33, 108}, {194, 187, 0}} ,{{34, 108}, {195, 187, 0}} ,{{58, 108}, {219, 187, 0}} ,{{53, 108}, {214, 187, 0}} ,{{55, 108}, {216, 187, 0}} ,{{39, 108}, {200, 187, 0}} ,{{42, 108}, {203, 187, 0}} ,{{40, 108}, {201, 187, 0}} ,{{46, 108}, {207, 187, 0}} ,{{41, 108}, {202, 187, 0}} ,{{45, 108}, {206, 187, 0}} ,{{43, 108}, {204, 187, 0}} ,{{44, 108}, {205, 187, 0}} ,{{47, 108}, {208, 187, 0}} ,{{35, 108}, {196, 187, 0}} ,{{52, 108}, {213, 187, 0}} ,{{37, 108}, {198, 187, 0}} ,{{36, 108}, {197, 187, 0}} ,{{57, 108}, {218, 187, 0}} ,{{50, 108}, {211, 187, 0}} ,{{51, 108}, {212, 187, 0}} ,{{56, 108}, {217, 187, 0}} ,{{87, 108}, {248, 187, 0}} ,{{104, 108}, {9, 188, 0}} ,{{105, 108}, {10, 188, 0}} ,{{110, 108}, {15, 188, 0}} ,{{94, 108}, {255, 187, 0}} ,{{88, 108}, {249, 187, 0}} ,{{89, 108}, {250, 187, 0}} ,{{90, 108}, {251, 187, 0}} ,{{114, 108}, {19, 188, 0}} ,{{109, 108}, {14, 188, 0}} ,{{111, 108}, {16, 188, 0}} ,{{95, 108}, {0, 188, 0}} ,{{98, 108}, {3, 188, 0}} ,{{96, 108}, {1, 188, 0}} ,{{102, 108}, {7, 188, 0}} ,{{97, 108}, {2, 188, 0}} ,{{101, 108}, {6, 188, 0}} ,{{99, 108}, {4, 188, 0}} ,{{100, 108}, {5, 188, 0}} ,{{103, 108}, {8, 188, 0}} ,{{91, 108}, {252, 187, 0}} ,{{108, 108}, {13, 188, 0}} ,{{93, 108}, {254, 187, 0}} ,{{92, 108}, {253, 187, 0}} ,{{113, 108}, {18, 188, 0}} ,{{106, 108}, {11, 188, 0}} ,{{107, 108}, {12, 188, 0}} ,{{112, 108}, {17, 188, 0}} ,{{7, 107}, {168, 186, 0}} ,{{24, 107}, {185, 186, 0}} ,{{25, 107}, {186, 186, 0}} ,{{30, 107}, {191, 186, 0}} ,{{14, 107}, {175, 186, 0}} ,{{91, 107}, {252, 186, 0}} ,{{108, 107}, {13, 187, 0}} ,{{109, 107}, {14, 187, 0}} ,{{114, 107}, {19, 187, 0}} ,{{98, 107}, {3, 187, 0}} ,{{92, 107}, {253, 186, 0}} ,{{93, 107}, {254, 186, 0}} ,{{94, 107}, {255, 186, 0}} ,{{118, 107}, {23, 187, 0}} ,{{113, 107}, {18, 187, 0}} ,{{115, 107}, {20, 187, 0}} ,{{99, 107}, {4, 187, 0}} ,{{102, 107}, {7, 187, 0}} ,{{100, 107}, {5, 187, 0}} ,{{106, 107}, {11, 187, 0}} ,{{101, 107}, {6, 187, 0}} ,{{105, 107}, {10, 187, 0}} ,{{103, 107}, {8, 187, 0}} ,{{104, 107}, {9, 187, 0}} ,{{107, 107}, {12, 187, 0}} ,{{95, 107}, {0, 187, 0}} ,{{112, 107}, {17, 187, 0}} ,{{97, 107}, {2, 187, 0}} ,{{96, 107}, {1, 187, 0}} ,{{117, 107}, {22, 187, 0}} ,{{110, 107}, {15, 187, 0}} ,{{111, 107}, {16, 187, 0}} ,{{116, 107}, {21, 187, 0}} ,{{8, 107}, {169, 186, 0}} ,{{9, 107}, {170, 186, 0}} ,{{10, 107}, {171, 186, 0}} ,{{34, 107}, {195, 186, 0}} ,{{29, 107}, {190, 186, 0}} ,{{31, 107}, {192, 186, 0}} ,{{15, 107}, {176, 186, 0}} ,{{18, 107}, {179, 186, 0}} ,{{16, 107}, {177, 186, 0}} ,{{22, 107}, {183, 186, 0}} ,{{17, 107}, {178, 186, 0}} ,{{21, 107}, {182, 186, 0}} ,{{19, 107}, {180, 186, 0}} ,{{20, 107}, {181, 186, 0}} ,{{23, 107}, {184, 186, 0}} ,{{11, 107}, {172, 186, 0}} ,{{28, 107}, {189, 186, 0}} ,{{13, 107}, {174, 186, 0}} ,{{12, 107}, {173, 186, 0}} ,{{33, 107}, {194, 186, 0}} ,{{26, 107}, {187, 186, 0}} ,{{27, 107}, {188, 186, 0}} ,{{32, 107}, {193, 186, 0}} ,{{147, 107}, {52, 187, 0}} ,{{164, 107}, {69, 187, 0}} ,{{165, 107}, {70, 187, 0}} ,{{170, 107}, {75, 187, 0}} ,{{154, 107}, {59, 187, 0}} ,{{148, 107}, {53, 187, 0}} ,{{149, 107}, {54, 187, 0}} ,{{150, 107}, {55, 187, 0}} ,{{174, 107}, {79, 187, 0}} ,{{169, 107}, {74, 187, 0}} ,{{171, 107}, {76, 187, 0}} ,{{155, 107}, {60, 187, 0}} ,{{158, 107}, {63, 187, 0}} ,{{156, 107}, {61, 187, 0}} ,{{162, 107}, {67, 187, 0}} ,{{157, 107}, {62, 187, 0}} ,{{161, 107}, {66, 187, 0}} ,{{159, 107}, {64, 187, 0}} ,{{160, 107}, {65, 187, 0}} ,{{163, 107}, {68, 187, 0}} ,{{151, 107}, {56, 187, 0}} ,{{168, 107}, {73, 187, 0}} ,{{153, 107}, {58, 187, 0}} ,{{152, 107}, {57, 187, 0}} ,{{173, 107}, {78, 187, 0}} ,{{166, 107}, {71, 187, 0}} ,{{167, 107}, {72, 187, 0}} ,{{172, 107}, {77, 187, 0}} ,{{35, 107}, {196, 186, 0}} ,{{52, 107}, {213, 186, 0}} ,{{53, 107}, {214, 186, 0}} ,{{58, 107}, {219, 186, 0}} ,{{42, 107}, {203, 186, 0}} ,{{63, 107}, {224, 186, 0}} ,{{80, 107}, {241, 186, 0}} ,{{81, 107}, {242, 186, 0}} ,{{86, 107}, {247, 186, 0}} ,{{70, 107}, {231, 186, 0}} ,{{64, 107}, {225, 186, 0}} ,{{65, 107}, {226, 186, 0}} ,{{66, 107}, {227, 186, 0}} ,{{90, 107}, {251, 186, 0}} ,{{85, 107}, {246, 186, 0}} ,{{87, 107}, {248, 186, 0}} ,{{71, 107}, {232, 186, 0}} ,{{74, 107}, {235, 186, 0}} ,{{72, 107}, {233, 186, 0}} ,{{78, 107}, {239, 186, 0}} ,{{73, 107}, {234, 186, 0}} ,{{77, 107}, {238, 186, 0}} ,{{75, 107}, {236, 186, 0}} ,{{76, 107}, {237, 186, 0}} ,{{79, 107}, {240, 186, 0}} ,{{67, 107}, {228, 186, 0}} ,{{84, 107}, {245, 186, 0}} ,{{69, 107}, {230, 186, 0}} ,{{68, 107}, {229, 186, 0}} ,{{89, 107}, {250, 186, 0}} ,{{82, 107}, {243, 186, 0}} ,{{83, 107}, {244, 186, 0}} ,{{88, 107}, {249, 186, 0}} ,{{36, 107}, {197, 186, 0}} ,{{37, 107}, {198, 186, 0}} ,{{38, 107}, {199, 186, 0}} ,{{62, 107}, {223, 186, 0}} ,{{57, 107}, {218, 186, 0}} ,{{59, 107}, {220, 186, 0}} ,{{43, 107}, {204, 186, 0}} ,{{46, 107}, {207, 186, 0}} ,{{44, 107}, {205, 186, 0}} ,{{50, 107}, {211, 186, 0}} ,{{45, 107}, {206, 186, 0}} ,{{49, 107}, {210, 186, 0}} ,{{47, 107}, {208, 186, 0}} ,{{48, 107}, {209, 186, 0}} ,{{51, 107}, {212, 186, 0}} ,{{39, 107}, {200, 186, 0}} ,{{56, 107}, {217, 186, 0}} ,{{41, 107}, {202, 186, 0}} ,{{40, 107}, {201, 186, 0}} ,{{61, 107}, {222, 186, 0}} ,{{54, 107}, {215, 186, 0}} ,{{55, 107}, {216, 186, 0}} ,{{60, 107}, {221, 186, 0}} ,{{203, 107}, {108, 187, 0}} ,{{220, 107}, {125, 187, 0}} ,{{221, 107}, {126, 187, 0}} ,{{226, 107}, {131, 187, 0}} ,{{210, 107}, {115, 187, 0}} ,{{204, 107}, {109, 187, 0}} ,{{205, 107}, {110, 187, 0}} ,{{206, 107}, {111, 187, 0}} ,{{230, 107}, {135, 187, 0}} ,{{225, 107}, {130, 187, 0}} ,{{227, 107}, {132, 187, 0}} ,{{211, 107}, {116, 187, 0}} ,{{214, 107}, {119, 187, 0}} ,{{212, 107}, {117, 187, 0}} ,{{218, 107}, {123, 187, 0}} ,{{213, 107}, {118, 187, 0}} ,{{217, 107}, {122, 187, 0}} ,{{215, 107}, {120, 187, 0}} ,{{216, 107}, {121, 187, 0}} ,{{219, 107}, {124, 187, 0}} ,{{207, 107}, {112, 187, 0}} ,{{224, 107}, {129, 187, 0}} ,{{209, 107}, {114, 187, 0}} ,{{208, 107}, {113, 187, 0}} ,{{175, 107}, {80, 187, 0}} ,{{192, 107}, {97, 187, 0}} ,{{193, 107}, {98, 187, 0}} ,{{198, 107}, {103, 187, 0}} ,{{182, 107}, {87, 187, 0}} ,{{176, 107}, {81, 187, 0}} ,{{177, 107}, {82, 187, 0}} ,{{178, 107}, {83, 187, 0}} ,{{202, 107}, {107, 187, 0}} ,{{197, 107}, {102, 187, 0}} ,{{199, 107}, {104, 187, 0}} ,{{183, 107}, {88, 187, 0}} ,{{186, 107}, {91, 187, 0}} ,{{184, 107}, {89, 187, 0}} ,{{190, 107}, {95, 187, 0}} ,{{185, 107}, {90, 187, 0}} ,{{189, 107}, {94, 187, 0}} ,{{187, 107}, {92, 187, 0}} ,{{188, 107}, {93, 187, 0}} ,{{191, 107}, {96, 187, 0}} ,{{179, 107}, {84, 187, 0}} ,{{196, 107}, {101, 187, 0}} ,{{181, 107}, {86, 187, 0}} ,{{180, 107}, {85, 187, 0}} ,{{201, 107}, {106, 187, 0}} ,{{194, 107}, {99, 187, 0}} ,{{195, 107}, {100, 187, 0}} ,{{200, 107}, {105, 187, 0}} ,{{229, 107}, {134, 187, 0}} ,{{222, 107}, {127, 187, 0}} ,{{223, 107}, {128, 187, 0}} ,{{228, 107}, {133, 187, 0}} ,{{231, 107}, {136, 187, 0}} ,{{248, 107}, {153, 187, 0}} ,{{249, 107}, {154, 187, 0}} ,{{254, 107}, {159, 187, 0}} ,{{238, 107}, {143, 187, 0}} ,{{232, 107}, {137, 187, 0}} ,{{233, 107}, {138, 187, 0}} ,{{234, 107}, {139, 187, 0}} ,{{2, 108}, {163, 187, 0}} ,{{253, 107}, {158, 187, 0}} ,{{255, 107}, {160, 187, 0}} ,{{239, 107}, {144, 187, 0}} ,{{242, 107}, {147, 187, 0}} ,{{240, 107}, {145, 187, 0}} ,{{246, 107}, {151, 187, 0}} ,{{241, 107}, {146, 187, 0}} ,{{245, 107}, {150, 187, 0}} ,{{243, 107}, {148, 187, 0}} ,{{244, 107}, {149, 187, 0}} ,{{247, 107}, {152, 187, 0}} ,{{235, 107}, {140, 187, 0}} ,{{252, 107}, {157, 187, 0}} ,{{237, 107}, {142, 187, 0}} ,{{236, 107}, {141, 187, 0}} ,{{1, 108}, {162, 187, 0}} ,{{250, 107}, {155, 187, 0}} ,{{251, 107}, {156, 187, 0}} ,{{0, 108}, {161, 187, 0}} ,{{95, 106}, {0, 186, 0}} ,{{112, 106}, {17, 186, 0}} ,{{113, 106}, {18, 186, 0}} ,{{118, 106}, {23, 186, 0}} ,{{102, 106}, {7, 186, 0}} ,{{123, 106}, {28, 186, 0}} ,{{140, 106}, {45, 186, 0}} ,{{141, 106}, {46, 186, 0}} ,{{146, 106}, {51, 186, 0}} ,{{130, 106}, {35, 186, 0}} ,{{124, 106}, {29, 186, 0}} ,{{125, 106}, {30, 186, 0}} ,{{126, 106}, {31, 186, 0}} ,{{150, 106}, {55, 186, 0}} ,{{145, 106}, {50, 186, 0}} ,{{147, 106}, {52, 186, 0}} ,{{131, 106}, {36, 186, 0}} ,{{134, 106}, {39, 186, 0}} ,{{132, 106}, {37, 186, 0}} ,{{138, 106}, {43, 186, 0}} ,{{133, 106}, {38, 186, 0}} ,{{137, 106}, {42, 186, 0}} ,{{135, 106}, {40, 186, 0}} ,{{136, 106}, {41, 186, 0}} ,{{139, 106}, {44, 186, 0}} ,{{127, 106}, {32, 186, 0}} ,{{144, 106}, {49, 186, 0}} ,{{129, 106}, {34, 186, 0}} ,{{128, 106}, {33, 186, 0}} ,{{149, 106}, {54, 186, 0}} ,{{142, 106}, {47, 186, 0}} ,{{143, 106}, {48, 186, 0}} ,{{148, 106}, {53, 186, 0}} ,{{96, 106}, {1, 186, 0}} ,{{97, 106}, {2, 186, 0}} ,{{98, 106}, {3, 186, 0}} ,{{122, 106}, {27, 186, 0}} ,{{117, 106}, {22, 186, 0}} ,{{119, 106}, {24, 186, 0}} ,{{103, 106}, {8, 186, 0}} ,{{106, 106}, {11, 186, 0}} ,{{104, 106}, {9, 186, 0}} ,{{110, 106}, {15, 186, 0}} ,{{105, 106}, {10, 186, 0}} ,{{109, 106}, {14, 186, 0}} ,{{107, 106}, {12, 186, 0}} ,{{108, 106}, {13, 186, 0}} ,{{111, 106}, {16, 186, 0}} ,{{99, 106}, {4, 186, 0}} ,{{116, 106}, {21, 186, 0}} ,{{101, 106}, {6, 186, 0}} ,{{100, 106}, {5, 186, 0}} ,{{121, 106}, {26, 186, 0}} ,{{114, 106}, {19, 186, 0}} ,{{115, 106}, {20, 186, 0}} ,{{120, 106}, {25, 186, 0}} ,{{235, 106}, {140, 186, 0}} ,{{252, 106}, {157, 186, 0}} ,{{253, 106}, {158, 186, 0}} ,{{2, 107}, {163, 186, 0}} ,{{242, 106}, {147, 186, 0}} ,{{236, 106}, {141, 186, 0}} ,{{237, 106}, {142, 186, 0}} ,{{238, 106}, {143, 186, 0}} ,{{6, 107}, {167, 186, 0}} ,{{1, 107}, {162, 186, 0}} ,{{3, 107}, {164, 186, 0}} ,{{243, 106}, {148, 186, 0}} ,{{246, 106}, {151, 186, 0}} ,{{244, 106}, {149, 186, 0}} ,{{250, 106}, {155, 186, 0}} ,{{245, 106}, {150, 186, 0}} ,{{249, 106}, {154, 186, 0}} ,{{247, 106}, {152, 186, 0}} ,{{248, 106}, {153, 186, 0}} ,{{251, 106}, {156, 186, 0}} ,{{239, 106}, {144, 186, 0}} ,{{0, 107}, {161, 186, 0}} ,{{241, 106}, {146, 186, 0}} ,{{240, 106}, {145, 186, 0}} ,{{207, 106}, {112, 186, 0}} ,{{224, 106}, {129, 186, 0}} ,{{225, 106}, {130, 186, 0}} ,{{230, 106}, {135, 186, 0}} ,{{214, 106}, {119, 186, 0}} ,{{208, 106}, {113, 186, 0}} ,{{209, 106}, {114, 186, 0}} ,{{210, 106}, {115, 186, 0}} ,{{234, 106}, {139, 186, 0}} ,{{229, 106}, {134, 186, 0}} ,{{231, 106}, {136, 186, 0}} ,{{215, 106}, {120, 186, 0}} ,{{218, 106}, {123, 186, 0}} ,{{216, 106}, {121, 186, 0}} ,{{222, 106}, {127, 186, 0}} ,{{217, 106}, {122, 186, 0}} ,{{221, 106}, {126, 186, 0}} ,{{219, 106}, {124, 186, 0}} ,{{220, 106}, {125, 186, 0}} ,{{223, 106}, {128, 186, 0}} ,{{211, 106}, {116, 186, 0}} ,{{228, 106}, {133, 186, 0}} ,{{213, 106}, {118, 186, 0}} ,{{212, 106}, {117, 186, 0}} ,{{233, 106}, {138, 186, 0}} ,{{226, 106}, {131, 186, 0}} ,{{227, 106}, {132, 186, 0}} ,{{232, 106}, {137, 186, 0}} ,{{5, 107}, {166, 186, 0}} ,{{254, 106}, {159, 186, 0}} ,{{255, 106}, {160, 186, 0}} ,{{4, 107}, {165, 186, 0}} ,{{59, 108}, {220, 187, 0}} ,{{76, 108}, {237, 187, 0}} ,{{77, 108}, {238, 187, 0}} ,{{82, 108}, {243, 187, 0}} ,{{66, 108}, {227, 187, 0}} ,{{60, 108}, {221, 187, 0}} ,{{61, 108}, {222, 187, 0}} ,{{62, 108}, {223, 187, 0}} ,{{86, 108}, {247, 187, 0}} ,{{81, 108}, {242, 187, 0}} ,{{83, 108}, {244, 187, 0}} ,{{67, 108}, {228, 187, 0}} ,{{70, 108}, {231, 187, 0}} ,{{68, 108}, {229, 187, 0}} ,{{74, 108}, {235, 187, 0}} ,{{69, 108}, {230, 187, 0}} ,{{73, 108}, {234, 187, 0}} ,{{71, 108}, {232, 187, 0}} ,{{72, 108}, {233, 187, 0}} ,{{75, 108}, {236, 187, 0}} ,{{63, 108}, {224, 187, 0}} ,{{80, 108}, {241, 187, 0}} ,{{65, 108}, {226, 187, 0}} ,{{64, 108}, {225, 187, 0}} ,{{85, 108}, {246, 187, 0}} ,{{78, 108}, {239, 187, 0}} ,{{79, 108}, {240, 187, 0}} ,{{84, 108}, {245, 187, 0}} ,{{119, 107}, {24, 187, 0}} ,{{136, 107}, {41, 187, 0}} ,{{137, 107}, {42, 187, 0}} ,{{142, 107}, {47, 187, 0}} ,{{126, 107}, {31, 187, 0}} ,{{120, 107}, {25, 187, 0}} ,{{121, 107}, {26, 187, 0}} ,{{122, 107}, {27, 187, 0}} ,{{146, 107}, {51, 187, 0}} ,{{141, 107}, {46, 187, 0}} ,{{143, 107}, {48, 187, 0}} ,{{127, 107}, {32, 187, 0}} ,{{130, 107}, {35, 187, 0}} ,{{128, 107}, {33, 187, 0}} ,{{134, 107}, {39, 187, 0}} ,{{129, 107}, {34, 187, 0}} ,{{133, 107}, {38, 187, 0}} ,{{131, 107}, {36, 187, 0}} ,{{132, 107}, {37, 187, 0}} ,{{135, 107}, {40, 187, 0}} ,{{123, 107}, {28, 187, 0}} ,{{140, 107}, {45, 187, 0}} ,{{125, 107}, {30, 187, 0}} ,{{124, 107}, {29, 187, 0}} ,{{145, 107}, {50, 187, 0}} ,{{138, 107}, {43, 187, 0}} ,{{139, 107}, {44, 187, 0}} ,{{144, 107}, {49, 187, 0}} ,{{3, 108}, {164, 187, 0}} ,{{20, 108}, {181, 187, 0}} ,{{21, 108}, {182, 187, 0}} ,{{26, 108}, {187, 187, 0}} ,{{10, 108}, {171, 187, 0}} ,{{4, 108}, {165, 187, 0}} ,{{5, 108}, {166, 187, 0}} ,{{6, 108}, {167, 187, 0}} ,{{30, 108}, {191, 187, 0}} ,{{25, 108}, {186, 187, 0}} ,{{27, 108}, {188, 187, 0}} ,{{11, 108}, {172, 187, 0}} ,{{14, 108}, {175, 187, 0}} ,{{12, 108}, {173, 187, 0}} ,{{18, 108}, {179, 187, 0}} ,{{13, 108}, {174, 187, 0}} ,{{17, 108}, {178, 187, 0}} ,{{15, 108}, {176, 187, 0}} ,{{16, 108}, {177, 187, 0}} ,{{19, 108}, {180, 187, 0}} ,{{7, 108}, {168, 187, 0}} ,{{24, 108}, {185, 187, 0}} ,{{9, 108}, {170, 187, 0}} ,{{8, 108}, {169, 187, 0}} ,{{29, 108}, {190, 187, 0}} ,{{22, 108}, {183, 187, 0}} ,{{23, 108}, {184, 187, 0}} ,{{28, 108}, {189, 187, 0}} ,{{247, 96}, {152, 176, 0}} ,{{8, 97}, {169, 176, 0}} ,{{9, 97}, {170, 176, 0}} ,{{14, 97}, {175, 176, 0}} ,{{254, 96}, {159, 176, 0}} ,{{19, 97}, {180, 176, 0}} ,{{36, 97}, {197, 176, 0}} ,{{37, 97}, {198, 176, 0}} ,{{42, 97}, {203, 176, 0}} ,{{26, 97}, {187, 176, 0}} ,{{20, 97}, {181, 176, 0}} ,{{21, 97}, {182, 176, 0}} ,{{22, 97}, {183, 176, 0}} ,{{46, 97}, {207, 176, 0}} ,{{41, 97}, {202, 176, 0}} ,{{43, 97}, {204, 176, 0}} ,{{27, 97}, {188, 176, 0}} ,{{30, 97}, {191, 176, 0}} ,{{28, 97}, {189, 176, 0}} ,{{34, 97}, {195, 176, 0}} ,{{29, 97}, {190, 176, 0}} ,{{33, 97}, {194, 176, 0}} ,{{31, 97}, {192, 176, 0}} ,{{32, 97}, {193, 176, 0}} ,{{35, 97}, {196, 176, 0}} ,{{23, 97}, {184, 176, 0}} ,{{40, 97}, {201, 176, 0}} ,{{25, 97}, {186, 176, 0}} ,{{24, 97}, {185, 176, 0}} ,{{45, 97}, {206, 176, 0}} ,{{38, 97}, {199, 176, 0}} ,{{39, 97}, {200, 176, 0}} ,{{44, 97}, {205, 176, 0}} ,{{248, 96}, {153, 176, 0}} ,{{249, 96}, {154, 176, 0}} ,{{250, 96}, {155, 176, 0}} ,{{18, 97}, {179, 176, 0}} ,{{13, 97}, {174, 176, 0}} ,{{15, 97}, {176, 176, 0}} ,{{255, 96}, {160, 176, 0}} ,{{2, 97}, {163, 176, 0}} ,{{0, 97}, {161, 176, 0}} ,{{6, 97}, {167, 176, 0}} ,{{1, 97}, {162, 176, 0}} ,{{5, 97}, {166, 176, 0}} ,{{3, 97}, {164, 176, 0}} ,{{4, 97}, {165, 176, 0}} ,{{7, 97}, {168, 176, 0}} ,{{251, 96}, {156, 176, 0}} ,{{12, 97}, {173, 176, 0}} ,{{253, 96}, {158, 176, 0}} ,{{252, 96}, {157, 176, 0}} ,{{17, 97}, {178, 176, 0}} ,{{10, 97}, {171, 176, 0}} ,{{11, 97}, {172, 176, 0}} ,{{16, 97}, {177, 176, 0}} ,{{131, 97}, {36, 177, 0}} ,{{148, 97}, {53, 177, 0}} ,{{149, 97}, {54, 177, 0}} ,{{154, 97}, {59, 177, 0}} ,{{138, 97}, {43, 177, 0}} ,{{132, 97}, {37, 177, 0}} ,{{133, 97}, {38, 177, 0}} ,{{134, 97}, {39, 177, 0}} ,{{158, 97}, {63, 177, 0}} ,{{153, 97}, {58, 177, 0}} ,{{155, 97}, {60, 177, 0}} ,{{139, 97}, {44, 177, 0}} ,{{142, 97}, {47, 177, 0}} ,{{140, 97}, {45, 177, 0}} ,{{146, 97}, {51, 177, 0}} ,{{141, 97}, {46, 177, 0}} ,{{145, 97}, {50, 177, 0}} ,{{143, 97}, {48, 177, 0}} ,{{144, 97}, {49, 177, 0}} ,{{147, 97}, {52, 177, 0}} ,{{135, 97}, {40, 177, 0}} ,{{152, 97}, {57, 177, 0}} ,{{137, 97}, {42, 177, 0}} ,{{136, 97}, {41, 177, 0}} ,{{103, 97}, {8, 177, 0}} ,{{120, 97}, {25, 177, 0}} ,{{121, 97}, {26, 177, 0}} ,{{126, 97}, {31, 177, 0}} ,{{110, 97}, {15, 177, 0}} ,{{104, 97}, {9, 177, 0}} ,{{105, 97}, {10, 177, 0}} ,{{106, 97}, {11, 177, 0}} ,{{130, 97}, {35, 177, 0}} ,{{125, 97}, {30, 177, 0}} ,{{127, 97}, {32, 177, 0}} ,{{111, 97}, {16, 177, 0}} ,{{114, 97}, {19, 177, 0}} ,{{112, 97}, {17, 177, 0}} ,{{118, 97}, {23, 177, 0}} ,{{113, 97}, {18, 177, 0}} ,{{117, 97}, {22, 177, 0}} ,{{115, 97}, {20, 177, 0}} ,{{116, 97}, {21, 177, 0}} ,{{119, 97}, {24, 177, 0}} ,{{107, 97}, {12, 177, 0}} ,{{124, 97}, {29, 177, 0}} ,{{109, 97}, {14, 177, 0}} ,{{108, 97}, {13, 177, 0}} ,{{129, 97}, {34, 177, 0}} ,{{122, 97}, {27, 177, 0}} ,{{123, 97}, {28, 177, 0}} ,{{128, 97}, {33, 177, 0}} ,{{157, 97}, {62, 177, 0}} ,{{150, 97}, {55, 177, 0}} ,{{151, 97}, {56, 177, 0}} ,{{156, 97}, {61, 177, 0}} ,{{239, 98}, {144, 178, 0}} ,{{0, 99}, {161, 178, 0}} ,{{1, 99}, {162, 178, 0}} ,{{6, 99}, {167, 178, 0}} ,{{246, 98}, {151, 178, 0}} ,{{240, 98}, {145, 178, 0}} ,{{241, 98}, {146, 178, 0}} ,{{242, 98}, {147, 178, 0}} ,{{10, 99}, {171, 178, 0}} ,{{5, 99}, {166, 178, 0}} ,{{7, 99}, {168, 178, 0}} ,{{247, 98}, {152, 178, 0}} ,{{250, 98}, {155, 178, 0}} ,{{248, 98}, {153, 178, 0}} ,{{254, 98}, {159, 178, 0}} ,{{249, 98}, {154, 178, 0}} ,{{253, 98}, {158, 178, 0}} ,{{251, 98}, {156, 178, 0}} ,{{252, 98}, {157, 178, 0}} ,{{255, 98}, {160, 178, 0}} ,{{243, 98}, {148, 178, 0}} ,{{4, 99}, {165, 178, 0}} ,{{245, 98}, {150, 178, 0}} ,{{244, 98}, {149, 178, 0}} ,{{9, 99}, {170, 178, 0}} ,{{2, 99}, {163, 178, 0}} ,{{3, 99}, {164, 178, 0}} ,{{8, 99}, {169, 178, 0}} ,{{39, 99}, {200, 178, 0}} ,{{56, 99}, {217, 178, 0}} ,{{57, 99}, {218, 178, 0}} ,{{62, 99}, {223, 178, 0}} ,{{46, 99}, {207, 178, 0}} ,{{40, 99}, {201, 178, 0}} ,{{41, 99}, {202, 178, 0}} ,{{42, 99}, {203, 178, 0}} ,{{66, 99}, {227, 178, 0}} ,{{61, 99}, {222, 178, 0}} ,{{63, 99}, {224, 178, 0}} ,{{47, 99}, {208, 178, 0}} ,{{50, 99}, {211, 178, 0}} ,{{48, 99}, {209, 178, 0}} ,{{54, 99}, {215, 178, 0}} ,{{49, 99}, {210, 178, 0}} ,{{53, 99}, {214, 178, 0}} ,{{51, 99}, {212, 178, 0}} ,{{52, 99}, {213, 178, 0}} ,{{55, 99}, {216, 178, 0}} ,{{43, 99}, {204, 178, 0}} ,{{60, 99}, {221, 178, 0}} ,{{45, 99}, {206, 178, 0}} ,{{44, 99}, {205, 178, 0}} ,{{65, 99}, {226, 178, 0}} ,{{58, 99}, {219, 178, 0}} ,{{59, 99}, {220, 178, 0}} ,{{64, 99}, {225, 178, 0}} ,{{215, 97}, {120, 177, 0}} ,{{232, 97}, {137, 177, 0}} ,{{233, 97}, {138, 177, 0}} ,{{238, 97}, {143, 177, 0}} ,{{222, 97}, {127, 177, 0}} ,{{43, 98}, {204, 177, 0}} ,{{60, 98}, {221, 177, 0}} ,{{61, 98}, {222, 177, 0}} ,{{66, 98}, {227, 177, 0}} ,{{50, 98}, {211, 177, 0}} ,{{44, 98}, {205, 177, 0}} ,{{45, 98}, {206, 177, 0}} ,{{46, 98}, {207, 177, 0}} ,{{70, 98}, {231, 177, 0}} ,{{65, 98}, {226, 177, 0}} ,{{67, 98}, {228, 177, 0}} ,{{51, 98}, {212, 177, 0}} ,{{54, 98}, {215, 177, 0}} ,{{52, 98}, {213, 177, 0}} ,{{58, 98}, {219, 177, 0}} ,{{53, 98}, {214, 177, 0}} ,{{57, 98}, {218, 177, 0}} ,{{55, 98}, {216, 177, 0}} ,{{56, 98}, {217, 177, 0}} ,{{59, 98}, {220, 177, 0}} ,{{47, 98}, {208, 177, 0}} ,{{64, 98}, {225, 177, 0}} ,{{49, 98}, {210, 177, 0}} ,{{48, 98}, {209, 177, 0}} ,{{69, 98}, {230, 177, 0}} ,{{62, 98}, {223, 177, 0}} ,{{63, 98}, {224, 177, 0}} ,{{68, 98}, {229, 177, 0}} ,{{216, 97}, {121, 177, 0}} ,{{217, 97}, {122, 177, 0}} ,{{218, 97}, {123, 177, 0}} ,{{242, 97}, {147, 177, 0}} ,{{237, 97}, {142, 177, 0}} ,{{239, 97}, {144, 177, 0}} ,{{223, 97}, {128, 177, 0}} ,{{226, 97}, {131, 177, 0}} ,{{224, 97}, {129, 177, 0}} ,{{230, 97}, {135, 177, 0}} ,{{225, 97}, {130, 177, 0}} ,{{229, 97}, {134, 177, 0}} ,{{227, 97}, {132, 177, 0}} ,{{228, 97}, {133, 177, 0}} ,{{231, 97}, {136, 177, 0}} ,{{219, 97}, {124, 177, 0}} ,{{236, 97}, {141, 177, 0}} ,{{221, 97}, {126, 177, 0}} ,{{220, 97}, {125, 177, 0}} ,{{241, 97}, {146, 177, 0}} ,{{234, 97}, {139, 177, 0}} ,{{235, 97}, {140, 177, 0}} ,{{240, 97}, {145, 177, 0}} ,{{99, 98}, {4, 178, 0}} ,{{116, 98}, {21, 178, 0}} ,{{117, 98}, {22, 178, 0}} ,{{122, 98}, {27, 178, 0}} ,{{106, 98}, {11, 178, 0}} ,{{100, 98}, {5, 178, 0}} ,{{101, 98}, {6, 178, 0}} ,{{102, 98}, {7, 178, 0}} ,{{126, 98}, {31, 178, 0}} ,{{121, 98}, {26, 178, 0}} ,{{123, 98}, {28, 178, 0}} ,{{107, 98}, {12, 178, 0}} ,{{110, 98}, {15, 178, 0}} ,{{108, 98}, {13, 178, 0}} ,{{114, 98}, {19, 178, 0}} ,{{109, 98}, {14, 178, 0}} ,{{113, 98}, {18, 178, 0}} ,{{111, 98}, {16, 178, 0}} ,{{112, 98}, {17, 178, 0}} ,{{115, 98}, {20, 178, 0}} ,{{103, 98}, {8, 178, 0}} ,{{120, 98}, {25, 178, 0}} ,{{105, 98}, {10, 178, 0}} ,{{104, 98}, {9, 178, 0}} ,{{125, 98}, {30, 178, 0}} ,{{118, 98}, {23, 178, 0}} ,{{119, 98}, {24, 178, 0}} ,{{124, 98}, {29, 178, 0}} ,{{243, 97}, {148, 177, 0}} ,{{4, 98}, {165, 177, 0}} ,{{5, 98}, {166, 177, 0}} ,{{10, 98}, {171, 177, 0}} ,{{250, 97}, {155, 177, 0}} ,{{15, 98}, {176, 177, 0}} ,{{32, 98}, {193, 177, 0}} ,{{33, 98}, {194, 177, 0}} ,{{38, 98}, {199, 177, 0}} ,{{22, 98}, {183, 177, 0}} ,{{16, 98}, {177, 177, 0}} ,{{17, 98}, {178, 177, 0}} ,{{18, 98}, {179, 177, 0}} ,{{42, 98}, {203, 177, 0}} ,{{37, 98}, {198, 177, 0}} ,{{39, 98}, {200, 177, 0}} ,{{23, 98}, {184, 177, 0}} ,{{26, 98}, {187, 177, 0}} ,{{24, 98}, {185, 177, 0}} ,{{30, 98}, {191, 177, 0}} ,{{25, 98}, {186, 177, 0}} ,{{29, 98}, {190, 177, 0}} ,{{27, 98}, {188, 177, 0}} ,{{28, 98}, {189, 177, 0}} ,{{31, 98}, {192, 177, 0}} ,{{19, 98}, {180, 177, 0}} ,{{36, 98}, {197, 177, 0}} ,{{21, 98}, {182, 177, 0}} ,{{20, 98}, {181, 177, 0}} ,{{41, 98}, {202, 177, 0}} ,{{34, 98}, {195, 177, 0}} ,{{35, 98}, {196, 177, 0}} ,{{40, 98}, {201, 177, 0}} ,{{244, 97}, {149, 177, 0}} ,{{245, 97}, {150, 177, 0}} ,{{246, 97}, {151, 177, 0}} ,{{14, 98}, {175, 177, 0}} ,{{9, 98}, {170, 177, 0}} ,{{11, 98}, {172, 177, 0}} ,{{251, 97}, {156, 177, 0}} ,{{254, 97}, {159, 177, 0}} ,{{252, 97}, {157, 177, 0}} ,{{2, 98}, {163, 177, 0}} ,{{253, 97}, {158, 177, 0}} ,{{1, 98}, {162, 177, 0}} ,{{255, 97}, {160, 177, 0}} ,{{0, 98}, {161, 177, 0}} ,{{3, 98}, {164, 177, 0}} ,{{247, 97}, {152, 177, 0}} ,{{8, 98}, {169, 177, 0}} ,{{249, 97}, {154, 177, 0}} ,{{248, 97}, {153, 177, 0}} ,{{13, 98}, {174, 177, 0}} ,{{6, 98}, {167, 177, 0}} ,{{7, 98}, {168, 177, 0}} ,{{12, 98}, {173, 177, 0}} ,{{155, 98}, {60, 178, 0}} ,{{172, 98}, {77, 178, 0}} ,{{173, 98}, {78, 178, 0}} ,{{178, 98}, {83, 178, 0}} ,{{162, 98}, {67, 178, 0}} ,{{156, 98}, {61, 178, 0}} ,{{157, 98}, {62, 178, 0}} ,{{158, 98}, {63, 178, 0}} ,{{182, 98}, {87, 178, 0}} ,{{177, 98}, {82, 178, 0}} ,{{179, 98}, {84, 178, 0}} ,{{163, 98}, {68, 178, 0}} ,{{166, 98}, {71, 178, 0}} ,{{164, 98}, {69, 178, 0}} ,{{170, 98}, {75, 178, 0}} ,{{165, 98}, {70, 178, 0}} ,{{169, 98}, {74, 178, 0}} ,{{167, 98}, {72, 178, 0}} ,{{168, 98}, {73, 178, 0}} ,{{171, 98}, {76, 178, 0}} ,{{159, 98}, {64, 178, 0}} ,{{176, 98}, {81, 178, 0}} ,{{161, 98}, {66, 178, 0}} ,{{160, 98}, {65, 178, 0}} ,{{127, 98}, {32, 178, 0}} ,{{144, 98}, {49, 178, 0}} ,{{145, 98}, {50, 178, 0}} ,{{150, 98}, {55, 178, 0}} ,{{134, 98}, {39, 178, 0}} ,{{128, 98}, {33, 178, 0}} ,{{129, 98}, {34, 178, 0}} ,{{130, 98}, {35, 178, 0}} ,{{154, 98}, {59, 178, 0}} ,{{149, 98}, {54, 178, 0}} ,{{151, 98}, {56, 178, 0}} ,{{135, 98}, {40, 178, 0}} ,{{138, 98}, {43, 178, 0}} ,{{136, 98}, {41, 178, 0}} ,{{142, 98}, {47, 178, 0}} ,{{137, 98}, {42, 178, 0}} ,{{141, 98}, {46, 178, 0}} ,{{139, 98}, {44, 178, 0}} ,{{140, 98}, {45, 178, 0}} ,{{143, 98}, {48, 178, 0}} ,{{131, 98}, {36, 178, 0}} ,{{148, 98}, {53, 178, 0}} ,{{133, 98}, {38, 178, 0}} ,{{132, 98}, {37, 178, 0}} ,{{153, 98}, {58, 178, 0}} ,{{146, 98}, {51, 178, 0}} ,{{147, 98}, {52, 178, 0}} ,{{152, 98}, {57, 178, 0}} ,{{181, 98}, {86, 178, 0}} ,{{174, 98}, {79, 178, 0}} ,{{175, 98}, {80, 178, 0}} ,{{180, 98}, {85, 178, 0}} ,{{183, 98}, {88, 178, 0}} ,{{200, 98}, {105, 178, 0}} ,{{201, 98}, {106, 178, 0}} ,{{206, 98}, {111, 178, 0}} ,{{190, 98}, {95, 178, 0}} ,{{184, 98}, {89, 178, 0}} ,{{185, 98}, {90, 178, 0}} ,{{186, 98}, {91, 178, 0}} ,{{210, 98}, {115, 178, 0}} ,{{205, 98}, {110, 178, 0}} ,{{207, 98}, {112, 178, 0}} ,{{191, 98}, {96, 178, 0}} ,{{194, 98}, {99, 178, 0}} ,{{192, 98}, {97, 178, 0}} ,{{198, 98}, {103, 178, 0}} ,{{193, 98}, {98, 178, 0}} ,{{197, 98}, {102, 178, 0}} ,{{195, 98}, {100, 178, 0}} ,{{196, 98}, {101, 178, 0}} ,{{199, 98}, {104, 178, 0}} ,{{187, 98}, {92, 178, 0}} ,{{204, 98}, {109, 178, 0}} ,{{189, 98}, {94, 178, 0}} ,{{188, 98}, {93, 178, 0}} ,{{209, 98}, {114, 178, 0}} ,{{202, 98}, {107, 178, 0}} ,{{203, 98}, {108, 178, 0}} ,{{208, 98}, {113, 178, 0}} ,{{47, 97}, {208, 176, 0}} ,{{64, 97}, {225, 176, 0}} ,{{65, 97}, {226, 176, 0}} ,{{70, 97}, {231, 176, 0}} ,{{54, 97}, {215, 176, 0}} ,{{75, 97}, {236, 176, 0}} ,{{92, 97}, {253, 176, 0}} ,{{93, 97}, {254, 176, 0}} ,{{98, 97}, {3, 177, 0}} ,{{82, 97}, {243, 176, 0}} ,{{76, 97}, {237, 176, 0}} ,{{77, 97}, {238, 176, 0}} ,{{78, 97}, {239, 176, 0}} ,{{102, 97}, {7, 177, 0}} ,{{97, 97}, {2, 177, 0}} ,{{99, 97}, {4, 177, 0}} ,{{83, 97}, {244, 176, 0}} ,{{86, 97}, {247, 176, 0}} ,{{84, 97}, {245, 176, 0}} ,{{90, 97}, {251, 176, 0}} ,{{85, 97}, {246, 176, 0}} ,{{89, 97}, {250, 176, 0}} ,{{87, 97}, {248, 176, 0}} ,{{88, 97}, {249, 176, 0}} ,{{91, 97}, {252, 176, 0}} ,{{79, 97}, {240, 176, 0}} ,{{96, 97}, {1, 177, 0}} ,{{81, 97}, {242, 176, 0}} ,{{80, 97}, {241, 176, 0}} ,{{101, 97}, {6, 177, 0}} ,{{94, 97}, {255, 176, 0}} ,{{95, 97}, {0, 177, 0}} ,{{100, 97}, {5, 177, 0}} ,{{48, 97}, {209, 176, 0}} ,{{49, 97}, {210, 176, 0}} ,{{50, 97}, {211, 176, 0}} ,{{74, 97}, {235, 176, 0}} ,{{69, 97}, {230, 176, 0}} ,{{71, 97}, {232, 176, 0}} ,{{55, 97}, {216, 176, 0}} ,{{58, 97}, {219, 176, 0}} ,{{56, 97}, {217, 176, 0}} ,{{62, 97}, {223, 176, 0}} ,{{57, 97}, {218, 176, 0}} ,{{61, 97}, {222, 176, 0}} ,{{59, 97}, {220, 176, 0}} ,{{60, 97}, {221, 176, 0}} ,{{63, 97}, {224, 176, 0}} ,{{51, 97}, {212, 176, 0}} ,{{68, 97}, {229, 176, 0}} ,{{53, 97}, {214, 176, 0}} ,{{52, 97}, {213, 176, 0}} ,{{73, 97}, {234, 176, 0}} ,{{66, 97}, {227, 176, 0}} ,{{67, 97}, {228, 176, 0}} ,{{72, 97}, {233, 176, 0}} ,{{187, 97}, {92, 177, 0}} ,{{204, 97}, {109, 177, 0}} ,{{205, 97}, {110, 177, 0}} ,{{210, 97}, {115, 177, 0}} ,{{194, 97}, {99, 177, 0}} ,{{188, 97}, {93, 177, 0}} ,{{189, 97}, {94, 177, 0}} ,{{190, 97}, {95, 177, 0}} ,{{214, 97}, {119, 177, 0}} ,{{209, 97}, {114, 177, 0}} ,{{211, 97}, {116, 177, 0}} ,{{195, 97}, {100, 177, 0}} ,{{198, 97}, {103, 177, 0}} ,{{196, 97}, {101, 177, 0}} ,{{202, 97}, {107, 177, 0}} ,{{197, 97}, {102, 177, 0}} ,{{201, 97}, {106, 177, 0}} ,{{199, 97}, {104, 177, 0}} ,{{200, 97}, {105, 177, 0}} ,{{203, 97}, {108, 177, 0}} ,{{191, 97}, {96, 177, 0}} ,{{208, 97}, {113, 177, 0}} ,{{193, 97}, {98, 177, 0}} ,{{192, 97}, {97, 177, 0}} ,{{159, 97}, {64, 177, 0}} ,{{176, 97}, {81, 177, 0}} ,{{177, 97}, {82, 177, 0}} ,{{182, 97}, {87, 177, 0}} ,{{166, 97}, {71, 177, 0}} ,{{160, 97}, {65, 177, 0}} ,{{161, 97}, {66, 177, 0}} ,{{162, 97}, {67, 177, 0}} ,{{186, 97}, {91, 177, 0}} ,{{181, 97}, {86, 177, 0}} ,{{183, 97}, {88, 177, 0}} ,{{167, 97}, {72, 177, 0}} ,{{170, 97}, {75, 177, 0}} ,{{168, 97}, {73, 177, 0}} ,{{174, 97}, {79, 177, 0}} ,{{169, 97}, {74, 177, 0}} ,{{173, 97}, {78, 177, 0}} ,{{171, 97}, {76, 177, 0}} ,{{172, 97}, {77, 177, 0}} ,{{175, 97}, {80, 177, 0}} ,{{163, 97}, {68, 177, 0}} ,{{180, 97}, {85, 177, 0}} ,{{165, 97}, {70, 177, 0}} ,{{164, 97}, {69, 177, 0}} ,{{185, 97}, {90, 177, 0}} ,{{178, 97}, {83, 177, 0}} ,{{179, 97}, {84, 177, 0}} ,{{184, 97}, {89, 177, 0}} ,{{213, 97}, {118, 177, 0}} ,{{206, 97}, {111, 177, 0}} ,{{207, 97}, {112, 177, 0}} ,{{212, 97}, {117, 177, 0}} ,{{11, 99}, {172, 178, 0}} ,{{28, 99}, {189, 178, 0}} ,{{29, 99}, {190, 178, 0}} ,{{34, 99}, {195, 178, 0}} ,{{18, 99}, {179, 178, 0}} ,{{12, 99}, {173, 178, 0}} ,{{13, 99}, {174, 178, 0}} ,{{14, 99}, {175, 178, 0}} ,{{38, 99}, {199, 178, 0}} ,{{33, 99}, {194, 178, 0}} ,{{35, 99}, {196, 178, 0}} ,{{19, 99}, {180, 178, 0}} ,{{22, 99}, {183, 178, 0}} ,{{20, 99}, {181, 178, 0}} ,{{26, 99}, {187, 178, 0}} ,{{21, 99}, {182, 178, 0}} ,{{25, 99}, {186, 178, 0}} ,{{23, 99}, {184, 178, 0}} ,{{24, 99}, {185, 178, 0}} ,{{27, 99}, {188, 178, 0}} ,{{15, 99}, {176, 178, 0}} ,{{32, 99}, {193, 178, 0}} ,{{17, 99}, {178, 178, 0}} ,{{16, 99}, {177, 178, 0}} ,{{37, 99}, {198, 178, 0}} ,{{30, 99}, {191, 178, 0}} ,{{31, 99}, {192, 178, 0}} ,{{36, 99}, {197, 178, 0}} ,{{71, 98}, {232, 177, 0}} ,{{88, 98}, {249, 177, 0}} ,{{89, 98}, {250, 177, 0}} ,{{94, 98}, {255, 177, 0}} ,{{78, 98}, {239, 177, 0}} ,{{72, 98}, {233, 177, 0}} ,{{73, 98}, {234, 177, 0}} ,{{74, 98}, {235, 177, 0}} ,{{98, 98}, {3, 178, 0}} ,{{93, 98}, {254, 177, 0}} ,{{95, 98}, {0, 178, 0}} ,{{79, 98}, {240, 177, 0}} ,{{82, 98}, {243, 177, 0}} ,{{80, 98}, {241, 177, 0}} ,{{86, 98}, {247, 177, 0}} ,{{81, 98}, {242, 177, 0}} ,{{85, 98}, {246, 177, 0}} ,{{83, 98}, {244, 177, 0}} ,{{84, 98}, {245, 177, 0}} ,{{87, 98}, {248, 177, 0}} ,{{75, 98}, {236, 177, 0}} ,{{92, 98}, {253, 177, 0}} ,{{77, 98}, {238, 177, 0}} ,{{76, 98}, {237, 177, 0}} ,{{97, 98}, {2, 178, 0}} ,{{90, 98}, {251, 177, 0}} ,{{91, 98}, {252, 177, 0}} ,{{96, 98}, {1, 178, 0}} ,{{211, 98}, {116, 178, 0}} ,{{228, 98}, {133, 178, 0}} ,{{229, 98}, {134, 178, 0}} ,{{234, 98}, {139, 178, 0}} ,{{218, 98}, {123, 178, 0}} ,{{212, 98}, {117, 178, 0}} ,{{213, 98}, {118, 178, 0}} ,{{214, 98}, {119, 178, 0}} ,{{238, 98}, {143, 178, 0}} ,{{233, 98}, {138, 178, 0}} ,{{235, 98}, {140, 178, 0}} ,{{219, 98}, {124, 178, 0}} ,{{222, 98}, {127, 178, 0}} ,{{220, 98}, {125, 178, 0}} ,{{226, 98}, {131, 178, 0}} ,{{221, 98}, {126, 178, 0}} ,{{225, 98}, {130, 178, 0}} ,{{223, 98}, {128, 178, 0}} ,{{224, 98}, {129, 178, 0}} ,{{227, 98}, {132, 178, 0}} ,{{215, 98}, {120, 178, 0}} ,{{232, 98}, {137, 178, 0}} ,{{217, 98}, {122, 178, 0}} ,{{216, 98}, {121, 178, 0}} ,{{237, 98}, {142, 178, 0}} ,{{230, 98}, {135, 178, 0}} ,{{231, 98}, {136, 178, 0}} ,{{236, 98}, {141, 178, 0}} ,{{131, 118}, {36, 198, 0}} ,{{148, 118}, {53, 198, 0}} ,{{149, 118}, {54, 198, 0}} ,{{154, 118}, {59, 198, 0}} ,{{138, 118}, {43, 198, 0}} ,{{215, 118}, {120, 198, 0}} ,{{232, 118}, {137, 198, 0}} ,{{233, 118}, {138, 198, 0}} ,{{238, 118}, {143, 198, 0}} ,{{222, 118}, {127, 198, 0}} ,{{216, 118}, {121, 198, 0}} ,{{217, 118}, {122, 198, 0}} ,{{218, 118}, {123, 198, 0}} ,{{242, 118}, {147, 198, 0}} ,{{237, 118}, {142, 198, 0}} ,{{239, 118}, {144, 198, 0}} ,{{223, 118}, {128, 198, 0}} ,{{226, 118}, {131, 198, 0}} ,{{224, 118}, {129, 198, 0}} ,{{230, 118}, {135, 198, 0}} ,{{225, 118}, {130, 198, 0}} ,{{229, 118}, {134, 198, 0}} ,{{227, 118}, {132, 198, 0}} ,{{228, 118}, {133, 198, 0}} ,{{231, 118}, {136, 198, 0}} ,{{219, 118}, {124, 198, 0}} ,{{236, 118}, {141, 198, 0}} ,{{221, 118}, {126, 198, 0}} ,{{220, 118}, {125, 198, 0}} ,{{241, 118}, {146, 198, 0}} ,{{234, 118}, {139, 198, 0}} ,{{235, 118}, {140, 198, 0}} ,{{240, 118}, {145, 198, 0}} ,{{132, 118}, {37, 198, 0}} ,{{133, 118}, {38, 198, 0}} ,{{134, 118}, {39, 198, 0}} ,{{158, 118}, {63, 198, 0}} ,{{153, 118}, {58, 198, 0}} ,{{155, 118}, {60, 198, 0}} ,{{139, 118}, {44, 198, 0}} ,{{142, 118}, {47, 198, 0}} ,{{140, 118}, {45, 198, 0}} ,{{146, 118}, {51, 198, 0}} ,{{141, 118}, {46, 198, 0}} ,{{145, 118}, {50, 198, 0}} ,{{143, 118}, {48, 198, 0}} ,{{144, 118}, {49, 198, 0}} ,{{147, 118}, {52, 198, 0}} ,{{135, 118}, {40, 198, 0}} ,{{152, 118}, {57, 198, 0}} ,{{137, 118}, {42, 198, 0}} ,{{136, 118}, {41, 198, 0}} ,{{157, 118}, {62, 198, 0}} ,{{150, 118}, {55, 198, 0}} ,{{151, 118}, {56, 198, 0}} ,{{156, 118}, {61, 198, 0}} ,{{107, 131}, {12, 211, 0}} ,{{124, 131}, {29, 211, 0}} ,{{125, 131}, {30, 211, 0}} ,{{130, 131}, {35, 211, 0}} ,{{114, 131}, {19, 211, 0}} ,{{135, 131}, {40, 211, 0}} ,{{152, 131}, {57, 211, 0}} ,{{153, 131}, {58, 211, 0}} ,{{158, 131}, {63, 211, 0}} ,{{142, 131}, {47, 211, 0}} ,{{136, 131}, {41, 211, 0}} ,{{137, 131}, {42, 211, 0}} ,{{138, 131}, {43, 211, 0}} ,{{162, 131}, {67, 211, 0}} ,{{157, 131}, {62, 211, 0}} ,{{159, 131}, {64, 211, 0}} ,{{143, 131}, {48, 211, 0}} ,{{146, 131}, {51, 211, 0}} ,{{144, 131}, {49, 211, 0}} ,{{150, 131}, {55, 211, 0}} ,{{145, 131}, {50, 211, 0}} ,{{149, 131}, {54, 211, 0}} ,{{147, 131}, {52, 211, 0}} ,{{148, 131}, {53, 211, 0}} ,{{151, 131}, {56, 211, 0}} ,{{139, 131}, {44, 211, 0}} ,{{156, 131}, {61, 211, 0}} ,{{141, 131}, {46, 211, 0}} ,{{140, 131}, {45, 211, 0}} ,{{161, 131}, {66, 211, 0}} ,{{154, 131}, {59, 211, 0}} ,{{155, 131}, {60, 211, 0}} ,{{160, 131}, {65, 211, 0}} ,{{108, 131}, {13, 211, 0}} ,{{109, 131}, {14, 211, 0}} ,{{110, 131}, {15, 211, 0}} ,{{134, 131}, {39, 211, 0}} ,{{129, 131}, {34, 211, 0}} ,{{131, 131}, {36, 211, 0}} ,{{115, 131}, {20, 211, 0}} ,{{118, 131}, {23, 211, 0}} ,{{116, 131}, {21, 211, 0}} ,{{122, 131}, {27, 211, 0}} ,{{117, 131}, {22, 211, 0}} ,{{121, 131}, {26, 211, 0}} ,{{119, 131}, {24, 211, 0}} ,{{120, 131}, {25, 211, 0}} ,{{123, 131}, {28, 211, 0}} ,{{111, 131}, {16, 211, 0}} ,{{128, 131}, {33, 211, 0}} ,{{113, 131}, {18, 211, 0}} ,{{112, 131}, {17, 211, 0}} ,{{133, 131}, {38, 211, 0}} ,{{126, 131}, {31, 211, 0}} ,{{127, 131}, {32, 211, 0}} ,{{132, 131}, {37, 211, 0}} ,{{247, 131}, {152, 211, 0}} ,{{8, 132}, {169, 211, 0}} ,{{9, 132}, {170, 211, 0}} ,{{14, 132}, {175, 211, 0}} ,{{254, 131}, {159, 211, 0}} ,{{248, 131}, {153, 211, 0}} ,{{249, 131}, {154, 211, 0}} ,{{250, 131}, {155, 211, 0}} ,{{18, 132}, {179, 211, 0}} ,{{13, 132}, {174, 211, 0}} ,{{15, 132}, {176, 211, 0}} ,{{255, 131}, {160, 211, 0}} ,{{2, 132}, {163, 211, 0}} ,{{0, 132}, {161, 211, 0}} ,{{6, 132}, {167, 211, 0}} ,{{1, 132}, {162, 211, 0}} ,{{5, 132}, {166, 211, 0}} ,{{3, 132}, {164, 211, 0}} ,{{4, 132}, {165, 211, 0}} ,{{7, 132}, {168, 211, 0}} ,{{251, 131}, {156, 211, 0}} ,{{12, 132}, {173, 211, 0}} ,{{253, 131}, {158, 211, 0}} ,{{252, 131}, {157, 211, 0}} ,{{219, 131}, {124, 211, 0}} ,{{236, 131}, {141, 211, 0}} ,{{237, 131}, {142, 211, 0}} ,{{242, 131}, {147, 211, 0}} ,{{226, 131}, {131, 211, 0}} ,{{220, 131}, {125, 211, 0}} ,{{221, 131}, {126, 211, 0}} ,{{222, 131}, {127, 211, 0}} ,{{246, 131}, {151, 211, 0}} ,{{241, 131}, {146, 211, 0}} ,{{243, 131}, {148, 211, 0}} ,{{227, 131}, {132, 211, 0}} ,{{230, 131}, {135, 211, 0}} ,{{228, 131}, {133, 211, 0}} ,{{234, 131}, {139, 211, 0}} ,{{229, 131}, {134, 211, 0}} ,{{233, 131}, {138, 211, 0}} ,{{231, 131}, {136, 211, 0}} ,{{232, 131}, {137, 211, 0}} ,{{235, 131}, {140, 211, 0}} ,{{223, 131}, {128, 211, 0}} ,{{240, 131}, {145, 211, 0}} ,{{225, 131}, {130, 211, 0}} ,{{224, 131}, {129, 211, 0}} ,{{245, 131}, {150, 211, 0}} ,{{238, 131}, {143, 211, 0}} ,{{239, 131}, {144, 211, 0}} ,{{244, 131}, {149, 211, 0}} ,{{17, 132}, {178, 211, 0}} ,{{10, 132}, {171, 211, 0}} ,{{11, 132}, {172, 211, 0}} ,{{16, 132}, {177, 211, 0}} ,{{99, 133}, {4, 213, 0}} ,{{116, 133}, {21, 213, 0}} ,{{117, 133}, {22, 213, 0}} ,{{122, 133}, {27, 213, 0}} ,{{106, 133}, {11, 213, 0}} ,{{100, 133}, {5, 213, 0}} ,{{101, 133}, {6, 213, 0}} ,{{102, 133}, {7, 213, 0}} ,{{126, 133}, {31, 213, 0}} ,{{121, 133}, {26, 213, 0}} ,{{123, 133}, {28, 213, 0}} ,{{107, 133}, {12, 213, 0}} ,{{110, 133}, {15, 213, 0}} ,{{108, 133}, {13, 213, 0}} ,{{114, 133}, {19, 213, 0}} ,{{109, 133}, {14, 213, 0}} ,{{113, 133}, {18, 213, 0}} ,{{111, 133}, {16, 213, 0}} ,{{112, 133}, {17, 213, 0}} ,{{115, 133}, {20, 213, 0}} ,{{103, 133}, {8, 213, 0}} ,{{120, 133}, {25, 213, 0}} ,{{105, 133}, {10, 213, 0}} ,{{104, 133}, {9, 213, 0}} ,{{125, 133}, {30, 213, 0}} ,{{118, 133}, {23, 213, 0}} ,{{119, 133}, {24, 213, 0}} ,{{124, 133}, {29, 213, 0}} ,{{155, 133}, {60, 213, 0}} ,{{172, 133}, {77, 213, 0}} ,{{173, 133}, {78, 213, 0}} ,{{178, 133}, {83, 213, 0}} ,{{162, 133}, {67, 213, 0}} ,{{156, 133}, {61, 213, 0}} ,{{157, 133}, {62, 213, 0}} ,{{158, 133}, {63, 213, 0}} ,{{182, 133}, {87, 213, 0}} ,{{177, 133}, {82, 213, 0}} ,{{179, 133}, {84, 213, 0}} ,{{163, 133}, {68, 213, 0}} ,{{166, 133}, {71, 213, 0}} ,{{164, 133}, {69, 213, 0}} ,{{170, 133}, {75, 213, 0}} ,{{165, 133}, {70, 213, 0}} ,{{169, 133}, {74, 213, 0}} ,{{167, 133}, {72, 213, 0}} ,{{168, 133}, {73, 213, 0}} ,{{171, 133}, {76, 213, 0}} ,{{159, 133}, {64, 213, 0}} ,{{176, 133}, {81, 213, 0}} ,{{161, 133}, {66, 213, 0}} ,{{160, 133}, {65, 213, 0}} ,{{181, 133}, {86, 213, 0}} ,{{174, 133}, {79, 213, 0}} ,{{175, 133}, {80, 213, 0}} ,{{180, 133}, {85, 213, 0}} ,{{75, 132}, {236, 211, 0}} ,{{92, 132}, {253, 211, 0}} ,{{93, 132}, {254, 211, 0}} ,{{98, 132}, {3, 212, 0}} ,{{82, 132}, {243, 211, 0}} ,{{159, 132}, {64, 212, 0}} ,{{176, 132}, {81, 212, 0}} ,{{177, 132}, {82, 212, 0}} ,{{182, 132}, {87, 212, 0}} ,{{166, 132}, {71, 212, 0}} ,{{160, 132}, {65, 212, 0}} ,{{161, 132}, {66, 212, 0}} ,{{162, 132}, {67, 212, 0}} ,{{186, 132}, {91, 212, 0}} ,{{181, 132}, {86, 212, 0}} ,{{183, 132}, {88, 212, 0}} ,{{167, 132}, {72, 212, 0}} ,{{170, 132}, {75, 212, 0}} ,{{168, 132}, {73, 212, 0}} ,{{174, 132}, {79, 212, 0}} ,{{169, 132}, {74, 212, 0}} ,{{173, 132}, {78, 212, 0}} ,{{171, 132}, {76, 212, 0}} ,{{172, 132}, {77, 212, 0}} ,{{175, 132}, {80, 212, 0}} ,{{163, 132}, {68, 212, 0}} ,{{180, 132}, {85, 212, 0}} ,{{165, 132}, {70, 212, 0}} ,{{164, 132}, {69, 212, 0}} ,{{185, 132}, {90, 212, 0}} ,{{178, 132}, {83, 212, 0}} ,{{179, 132}, {84, 212, 0}} ,{{184, 132}, {89, 212, 0}} ,{{76, 132}, {237, 211, 0}} ,{{77, 132}, {238, 211, 0}} ,{{78, 132}, {239, 211, 0}} ,{{102, 132}, {7, 212, 0}} ,{{97, 132}, {2, 212, 0}} ,{{99, 132}, {4, 212, 0}} ,{{83, 132}, {244, 211, 0}} ,{{86, 132}, {247, 211, 0}} ,{{84, 132}, {245, 211, 0}} ,{{90, 132}, {251, 211, 0}} ,{{85, 132}, {246, 211, 0}} ,{{89, 132}, {250, 211, 0}} ,{{87, 132}, {248, 211, 0}} ,{{88, 132}, {249, 211, 0}} ,{{91, 132}, {252, 211, 0}} ,{{79, 132}, {240, 211, 0}} ,{{96, 132}, {1, 212, 0}} ,{{81, 132}, {242, 211, 0}} ,{{80, 132}, {241, 211, 0}} ,{{101, 132}, {6, 212, 0}} ,{{94, 132}, {255, 211, 0}} ,{{95, 132}, {0, 212, 0}} ,{{100, 132}, {5, 212, 0}} ,{{215, 132}, {120, 212, 0}} ,{{232, 132}, {137, 212, 0}} ,{{233, 132}, {138, 212, 0}} ,{{238, 132}, {143, 212, 0}} ,{{222, 132}, {127, 212, 0}} ,{{216, 132}, {121, 212, 0}} ,{{217, 132}, {122, 212, 0}} ,{{218, 132}, {123, 212, 0}} ,{{242, 132}, {147, 212, 0}} ,{{237, 132}, {142, 212, 0}} ,{{239, 132}, {144, 212, 0}} ,{{223, 132}, {128, 212, 0}} ,{{226, 132}, {131, 212, 0}} ,{{224, 132}, {129, 212, 0}} ,{{230, 132}, {135, 212, 0}} ,{{225, 132}, {130, 212, 0}} ,{{229, 132}, {134, 212, 0}} ,{{227, 132}, {132, 212, 0}} ,{{228, 132}, {133, 212, 0}} ,{{231, 132}, {136, 212, 0}} ,{{219, 132}, {124, 212, 0}} ,{{236, 132}, {141, 212, 0}} ,{{221, 132}, {126, 212, 0}} ,{{220, 132}, {125, 212, 0}} ,{{241, 132}, {146, 212, 0}} ,{{234, 132}, {139, 212, 0}} ,{{235, 132}, {140, 212, 0}} ,{{240, 132}, {145, 212, 0}} ,{{103, 132}, {8, 212, 0}} ,{{120, 132}, {25, 212, 0}} ,{{121, 132}, {26, 212, 0}} ,{{126, 132}, {31, 212, 0}} ,{{110, 132}, {15, 212, 0}} ,{{131, 132}, {36, 212, 0}} ,{{148, 132}, {53, 212, 0}} ,{{149, 132}, {54, 212, 0}} ,{{154, 132}, {59, 212, 0}} ,{{138, 132}, {43, 212, 0}} ,{{132, 132}, {37, 212, 0}} ,{{133, 132}, {38, 212, 0}} ,{{134, 132}, {39, 212, 0}} ,{{158, 132}, {63, 212, 0}} ,{{153, 132}, {58, 212, 0}} ,{{155, 132}, {60, 212, 0}} ,{{139, 132}, {44, 212, 0}} ,{{142, 132}, {47, 212, 0}} ,{{140, 132}, {45, 212, 0}} ,{{146, 132}, {51, 212, 0}} ,{{141, 132}, {46, 212, 0}} ,{{145, 132}, {50, 212, 0}} ,{{143, 132}, {48, 212, 0}} ,{{144, 132}, {49, 212, 0}} ,{{147, 132}, {52, 212, 0}} ,{{135, 132}, {40, 212, 0}} ,{{152, 132}, {57, 212, 0}} ,{{137, 132}, {42, 212, 0}} ,{{136, 132}, {41, 212, 0}} ,{{157, 132}, {62, 212, 0}} ,{{150, 132}, {55, 212, 0}} ,{{151, 132}, {56, 212, 0}} ,{{156, 132}, {61, 212, 0}} ,{{104, 132}, {9, 212, 0}} ,{{105, 132}, {10, 212, 0}} ,{{106, 132}, {11, 212, 0}} ,{{130, 132}, {35, 212, 0}} ,{{125, 132}, {30, 212, 0}} ,{{127, 132}, {32, 212, 0}} ,{{111, 132}, {16, 212, 0}} ,{{114, 132}, {19, 212, 0}} ,{{112, 132}, {17, 212, 0}} ,{{118, 132}, {23, 212, 0}} ,{{113, 132}, {18, 212, 0}} ,{{117, 132}, {22, 212, 0}} ,{{115, 132}, {20, 212, 0}} ,{{116, 132}, {21, 212, 0}} ,{{119, 132}, {24, 212, 0}} ,{{107, 132}, {12, 212, 0}} ,{{124, 132}, {29, 212, 0}} ,{{109, 132}, {14, 212, 0}} ,{{108, 132}, {13, 212, 0}} ,{{129, 132}, {34, 212, 0}} ,{{122, 132}, {27, 212, 0}} ,{{123, 132}, {28, 212, 0}} ,{{128, 132}, {33, 212, 0}} ,{{15, 133}, {176, 212, 0}} ,{{32, 133}, {193, 212, 0}} ,{{33, 133}, {194, 212, 0}} ,{{38, 133}, {199, 212, 0}} ,{{22, 133}, {183, 212, 0}} ,{{16, 133}, {177, 212, 0}} ,{{17, 133}, {178, 212, 0}} ,{{18, 133}, {179, 212, 0}} ,{{42, 133}, {203, 212, 0}} ,{{37, 133}, {198, 212, 0}} ,{{39, 133}, {200, 212, 0}} ,{{23, 133}, {184, 212, 0}} ,{{26, 133}, {187, 212, 0}} ,{{24, 133}, {185, 212, 0}} ,{{30, 133}, {191, 212, 0}} ,{{25, 133}, {186, 212, 0}} ,{{29, 133}, {190, 212, 0}} ,{{27, 133}, {188, 212, 0}} ,{{28, 133}, {189, 212, 0}} ,{{31, 133}, {192, 212, 0}} ,{{19, 133}, {180, 212, 0}} ,{{36, 133}, {197, 212, 0}} ,{{21, 133}, {182, 212, 0}} ,{{20, 133}, {181, 212, 0}} ,{{243, 132}, {148, 212, 0}} ,{{4, 133}, {165, 212, 0}} ,{{5, 133}, {166, 212, 0}} ,{{10, 133}, {171, 212, 0}} ,{{250, 132}, {155, 212, 0}} ,{{244, 132}, {149, 212, 0}} ,{{245, 132}, {150, 212, 0}} ,{{246, 132}, {151, 212, 0}} ,{{14, 133}, {175, 212, 0}} ,{{9, 133}, {170, 212, 0}} ,{{11, 133}, {172, 212, 0}} ,{{251, 132}, {156, 212, 0}} ,{{254, 132}, {159, 212, 0}} ,{{252, 132}, {157, 212, 0}} ,{{2, 133}, {163, 212, 0}} ,{{253, 132}, {158, 212, 0}} ,{{1, 133}, {162, 212, 0}} ,{{255, 132}, {160, 212, 0}} ,{{0, 133}, {161, 212, 0}} ,{{3, 133}, {164, 212, 0}} ,{{247, 132}, {152, 212, 0}} ,{{8, 133}, {169, 212, 0}} ,{{249, 132}, {154, 212, 0}} ,{{248, 132}, {153, 212, 0}} ,{{13, 133}, {174, 212, 0}} ,{{6, 133}, {167, 212, 0}} ,{{7, 133}, {168, 212, 0}} ,{{12, 133}, {173, 212, 0}} ,{{41, 133}, {202, 212, 0}} ,{{34, 133}, {195, 212, 0}} ,{{35, 133}, {196, 212, 0}} ,{{40, 133}, {201, 212, 0}} ,{{43, 133}, {204, 212, 0}} ,{{60, 133}, {221, 212, 0}} ,{{61, 133}, {222, 212, 0}} ,{{66, 133}, {227, 212, 0}} ,{{50, 133}, {211, 212, 0}} ,{{44, 133}, {205, 212, 0}} ,{{45, 133}, {206, 212, 0}} ,{{46, 133}, {207, 212, 0}} ,{{70, 133}, {231, 212, 0}} ,{{65, 133}, {226, 212, 0}} ,{{67, 133}, {228, 212, 0}} ,{{51, 133}, {212, 212, 0}} ,{{54, 133}, {215, 212, 0}} ,{{52, 133}, {213, 212, 0}} ,{{58, 133}, {219, 212, 0}} ,{{53, 133}, {214, 212, 0}} ,{{57, 133}, {218, 212, 0}} ,{{55, 133}, {216, 212, 0}} ,{{56, 133}, {217, 212, 0}} ,{{59, 133}, {220, 212, 0}} ,{{47, 133}, {208, 212, 0}} ,{{64, 133}, {225, 212, 0}} ,{{49, 133}, {210, 212, 0}} ,{{48, 133}, {209, 212, 0}} ,{{69, 133}, {230, 212, 0}} ,{{62, 133}, {223, 212, 0}} ,{{63, 133}, {224, 212, 0}} ,{{68, 133}, {229, 212, 0}} ,{{163, 131}, {68, 211, 0}} ,{{180, 131}, {85, 211, 0}} ,{{181, 131}, {86, 211, 0}} ,{{186, 131}, {91, 211, 0}} ,{{170, 131}, {75, 211, 0}} ,{{191, 131}, {96, 211, 0}} ,{{208, 131}, {113, 211, 0}} ,{{209, 131}, {114, 211, 0}} ,{{214, 131}, {119, 211, 0}} ,{{198, 131}, {103, 211, 0}} ,{{192, 131}, {97, 211, 0}} ,{{193, 131}, {98, 211, 0}} ,{{194, 131}, {99, 211, 0}} ,{{218, 131}, {123, 211, 0}} ,{{213, 131}, {118, 211, 0}} ,{{215, 131}, {120, 211, 0}} ,{{199, 131}, {104, 211, 0}} ,{{202, 131}, {107, 211, 0}} ,{{200, 131}, {105, 211, 0}} ,{{206, 131}, {111, 211, 0}} ,{{201, 131}, {106, 211, 0}} ,{{205, 131}, {110, 211, 0}} ,{{203, 131}, {108, 211, 0}} ,{{204, 131}, {109, 211, 0}} ,{{207, 131}, {112, 211, 0}} ,{{195, 131}, {100, 211, 0}} ,{{212, 131}, {117, 211, 0}} ,{{197, 131}, {102, 211, 0}} ,{{196, 131}, {101, 211, 0}} ,{{217, 131}, {122, 211, 0}} ,{{210, 131}, {115, 211, 0}} ,{{211, 131}, {116, 211, 0}} ,{{216, 131}, {121, 211, 0}} ,{{164, 131}, {69, 211, 0}} ,{{165, 131}, {70, 211, 0}} ,{{166, 131}, {71, 211, 0}} ,{{190, 131}, {95, 211, 0}} ,{{185, 131}, {90, 211, 0}} ,{{187, 131}, {92, 211, 0}} ,{{171, 131}, {76, 211, 0}} ,{{174, 131}, {79, 211, 0}} ,{{172, 131}, {77, 211, 0}} ,{{178, 131}, {83, 211, 0}} ,{{173, 131}, {78, 211, 0}} ,{{177, 131}, {82, 211, 0}} ,{{175, 131}, {80, 211, 0}} ,{{176, 131}, {81, 211, 0}} ,{{179, 131}, {84, 211, 0}} ,{{167, 131}, {72, 211, 0}} ,{{184, 131}, {89, 211, 0}} ,{{169, 131}, {74, 211, 0}} ,{{168, 131}, {73, 211, 0}} ,{{189, 131}, {94, 211, 0}} ,{{182, 131}, {87, 211, 0}} ,{{183, 131}, {88, 211, 0}} ,{{188, 131}, {93, 211, 0}} ,{{47, 132}, {208, 211, 0}} ,{{64, 132}, {225, 211, 0}} ,{{65, 132}, {226, 211, 0}} ,{{70, 132}, {231, 211, 0}} ,{{54, 132}, {215, 211, 0}} ,{{48, 132}, {209, 211, 0}} ,{{49, 132}, {210, 211, 0}} ,{{50, 132}, {211, 211, 0}} ,{{74, 132}, {235, 211, 0}} ,{{69, 132}, {230, 211, 0}} ,{{71, 132}, {232, 211, 0}} ,{{55, 132}, {216, 211, 0}} ,{{58, 132}, {219, 211, 0}} ,{{56, 132}, {217, 211, 0}} ,{{62, 132}, {223, 211, 0}} ,{{57, 132}, {218, 211, 0}} ,{{61, 132}, {222, 211, 0}} ,{{59, 132}, {220, 211, 0}} ,{{60, 132}, {221, 211, 0}} ,{{63, 132}, {224, 211, 0}} ,{{51, 132}, {212, 211, 0}} ,{{68, 132}, {229, 211, 0}} ,{{53, 132}, {214, 211, 0}} ,{{52, 132}, {213, 211, 0}} ,{{19, 132}, {180, 211, 0}} ,{{36, 132}, {197, 211, 0}} ,{{37, 132}, {198, 211, 0}} ,{{42, 132}, {203, 211, 0}} ,{{26, 132}, {187, 211, 0}} ,{{20, 132}, {181, 211, 0}} ,{{21, 132}, {182, 211, 0}} ,{{22, 132}, {183, 211, 0}} ,{{46, 132}, {207, 211, 0}} ,{{41, 132}, {202, 211, 0}} ,{{43, 132}, {204, 211, 0}} ,{{27, 132}, {188, 211, 0}} ,{{30, 132}, {191, 211, 0}} ,{{28, 132}, {189, 211, 0}} ,{{34, 132}, {195, 211, 0}} ,{{29, 132}, {190, 211, 0}} ,{{33, 132}, {194, 211, 0}} ,{{31, 132}, {192, 211, 0}} ,{{32, 132}, {193, 211, 0}} ,{{35, 132}, {196, 211, 0}} ,{{23, 132}, {184, 211, 0}} ,{{40, 132}, {201, 211, 0}} ,{{25, 132}, {186, 211, 0}} ,{{24, 132}, {185, 211, 0}} ,{{45, 132}, {206, 211, 0}} ,{{38, 132}, {199, 211, 0}} ,{{39, 132}, {200, 211, 0}} ,{{44, 132}, {205, 211, 0}} ,{{73, 132}, {234, 211, 0}} ,{{66, 132}, {227, 211, 0}} ,{{67, 132}, {228, 211, 0}} ,{{72, 132}, {233, 211, 0}} ,{{127, 133}, {32, 213, 0}} ,{{144, 133}, {49, 213, 0}} ,{{145, 133}, {50, 213, 0}} ,{{150, 133}, {55, 213, 0}} ,{{134, 133}, {39, 213, 0}} ,{{128, 133}, {33, 213, 0}} ,{{129, 133}, {34, 213, 0}} ,{{130, 133}, {35, 213, 0}} ,{{154, 133}, {59, 213, 0}} ,{{149, 133}, {54, 213, 0}} ,{{151, 133}, {56, 213, 0}} ,{{135, 133}, {40, 213, 0}} ,{{138, 133}, {43, 213, 0}} ,{{136, 133}, {41, 213, 0}} ,{{142, 133}, {47, 213, 0}} ,{{137, 133}, {42, 213, 0}} ,{{141, 133}, {46, 213, 0}} ,{{139, 133}, {44, 213, 0}} ,{{140, 133}, {45, 213, 0}} ,{{143, 133}, {48, 213, 0}} ,{{131, 133}, {36, 213, 0}} ,{{148, 133}, {53, 213, 0}} ,{{133, 133}, {38, 213, 0}} ,{{132, 133}, {37, 213, 0}} ,{{153, 133}, {58, 213, 0}} ,{{146, 133}, {51, 213, 0}} ,{{147, 133}, {52, 213, 0}} ,{{152, 133}, {57, 213, 0}} ,{{187, 132}, {92, 212, 0}} ,{{204, 132}, {109, 212, 0}} ,{{205, 132}, {110, 212, 0}} ,{{210, 132}, {115, 212, 0}} ,{{194, 132}, {99, 212, 0}} ,{{188, 132}, {93, 212, 0}} ,{{189, 132}, {94, 212, 0}} ,{{190, 132}, {95, 212, 0}} ,{{214, 132}, {119, 212, 0}} ,{{209, 132}, {114, 212, 0}} ,{{211, 132}, {116, 212, 0}} ,{{195, 132}, {100, 212, 0}} ,{{198, 132}, {103, 212, 0}} ,{{196, 132}, {101, 212, 0}} ,{{202, 132}, {107, 212, 0}} ,{{197, 132}, {102, 212, 0}} ,{{201, 132}, {106, 212, 0}} ,{{199, 132}, {104, 212, 0}} ,{{200, 132}, {105, 212, 0}} ,{{203, 132}, {108, 212, 0}} ,{{191, 132}, {96, 212, 0}} ,{{208, 132}, {113, 212, 0}} ,{{193, 132}, {98, 212, 0}} ,{{192, 132}, {97, 212, 0}} ,{{213, 132}, {118, 212, 0}} ,{{206, 132}, {111, 212, 0}} ,{{207, 132}, {112, 212, 0}} ,{{212, 132}, {117, 212, 0}} ,{{71, 133}, {232, 212, 0}} ,{{88, 133}, {249, 212, 0}} ,{{89, 133}, {250, 212, 0}} ,{{94, 133}, {255, 212, 0}} ,{{78, 133}, {239, 212, 0}} ,{{72, 133}, {233, 212, 0}} ,{{73, 133}, {234, 212, 0}} ,{{74, 133}, {235, 212, 0}} ,{{98, 133}, {3, 213, 0}} ,{{93, 133}, {254, 212, 0}} ,{{95, 133}, {0, 213, 0}} ,{{79, 133}, {240, 212, 0}} ,{{82, 133}, {243, 212, 0}} ,{{80, 133}, {241, 212, 0}} ,{{86, 133}, {247, 212, 0}} ,{{81, 133}, {242, 212, 0}} ,{{85, 133}, {246, 212, 0}} ,{{83, 133}, {244, 212, 0}} ,{{84, 133}, {245, 212, 0}} ,{{87, 133}, {248, 212, 0}} ,{{75, 133}, {236, 212, 0}} ,{{92, 133}, {253, 212, 0}} ,{{77, 133}, {238, 212, 0}} ,{{76, 133}, {237, 212, 0}} ,{{97, 133}, {2, 213, 0}} ,{{90, 133}, {251, 212, 0}} ,{{91, 133}, {252, 212, 0}} ,{{96, 133}, {1, 213, 0}} ,{{219, 103}, {124, 183, 0}} ,{{236, 103}, {141, 183, 0}} ,{{237, 103}, {142, 183, 0}} ,{{242, 103}, {147, 183, 0}} ,{{226, 103}, {131, 183, 0}} ,{{247, 103}, {152, 183, 0}} ,{{8, 104}, {169, 183, 0}} ,{{9, 104}, {170, 183, 0}} ,{{14, 104}, {175, 183, 0}} ,{{254, 103}, {159, 183, 0}} ,{{248, 103}, {153, 183, 0}} ,{{249, 103}, {154, 183, 0}} ,{{250, 103}, {155, 183, 0}} ,{{18, 104}, {179, 183, 0}} ,{{13, 104}, {174, 183, 0}} ,{{15, 104}, {176, 183, 0}} ,{{255, 103}, {160, 183, 0}} ,{{2, 104}, {163, 183, 0}} ,{{0, 104}, {161, 183, 0}} ,{{6, 104}, {167, 183, 0}} ,{{1, 104}, {162, 183, 0}} ,{{5, 104}, {166, 183, 0}} ,{{3, 104}, {164, 183, 0}} ,{{4, 104}, {165, 183, 0}} ,{{7, 104}, {168, 183, 0}} ,{{251, 103}, {156, 183, 0}} ,{{12, 104}, {173, 183, 0}} ,{{253, 103}, {158, 183, 0}} ,{{252, 103}, {157, 183, 0}} ,{{17, 104}, {178, 183, 0}} ,{{10, 104}, {171, 183, 0}} ,{{11, 104}, {172, 183, 0}} ,{{16, 104}, {177, 183, 0}} ,{{220, 103}, {125, 183, 0}} ,{{221, 103}, {126, 183, 0}} ,{{222, 103}, {127, 183, 0}} ,{{246, 103}, {151, 183, 0}} ,{{241, 103}, {146, 183, 0}} ,{{243, 103}, {148, 183, 0}} ,{{227, 103}, {132, 183, 0}} ,{{230, 103}, {135, 183, 0}} ,{{228, 103}, {133, 183, 0}} ,{{234, 103}, {139, 183, 0}} ,{{229, 103}, {134, 183, 0}} ,{{233, 103}, {138, 183, 0}} ,{{231, 103}, {136, 183, 0}} ,{{232, 103}, {137, 183, 0}} ,{{235, 103}, {140, 183, 0}} ,{{223, 103}, {128, 183, 0}} ,{{240, 103}, {145, 183, 0}} ,{{225, 103}, {130, 183, 0}} ,{{224, 103}, {129, 183, 0}} ,{{245, 103}, {150, 183, 0}} ,{{238, 103}, {143, 183, 0}} ,{{239, 103}, {144, 183, 0}} ,{{244, 103}, {149, 183, 0}} ,{{103, 104}, {8, 184, 0}} ,{{120, 104}, {25, 184, 0}} ,{{121, 104}, {26, 184, 0}} ,{{126, 104}, {31, 184, 0}} ,{{110, 104}, {15, 184, 0}} ,{{104, 104}, {9, 184, 0}} ,{{105, 104}, {10, 184, 0}} ,{{106, 104}, {11, 184, 0}} ,{{130, 104}, {35, 184, 0}} ,{{125, 104}, {30, 184, 0}} ,{{127, 104}, {32, 184, 0}} ,{{111, 104}, {16, 184, 0}} ,{{114, 104}, {19, 184, 0}} ,{{112, 104}, {17, 184, 0}} ,{{118, 104}, {23, 184, 0}} ,{{113, 104}, {18, 184, 0}} ,{{117, 104}, {22, 184, 0}} ,{{115, 104}, {20, 184, 0}} ,{{116, 104}, {21, 184, 0}} ,{{119, 104}, {24, 184, 0}} ,{{107, 104}, {12, 184, 0}} ,{{124, 104}, {29, 184, 0}} ,{{109, 104}, {14, 184, 0}} ,{{108, 104}, {13, 184, 0}} ,{{75, 104}, {236, 183, 0}} ,{{92, 104}, {253, 183, 0}} ,{{93, 104}, {254, 183, 0}} ,{{98, 104}, {3, 184, 0}} ,{{82, 104}, {243, 183, 0}} ,{{76, 104}, {237, 183, 0}} ,{{77, 104}, {238, 183, 0}} ,{{78, 104}, {239, 183, 0}} ,{{102, 104}, {7, 184, 0}} ,{{97, 104}, {2, 184, 0}} ,{{99, 104}, {4, 184, 0}} ,{{83, 104}, {244, 183, 0}} ,{{86, 104}, {247, 183, 0}} ,{{84, 104}, {245, 183, 0}} ,{{90, 104}, {251, 183, 0}} ,{{85, 104}, {246, 183, 0}} ,{{89, 104}, {250, 183, 0}} ,{{87, 104}, {248, 183, 0}} ,{{88, 104}, {249, 183, 0}} ,{{91, 104}, {252, 183, 0}} ,{{79, 104}, {240, 183, 0}} ,{{96, 104}, {1, 184, 0}} ,{{81, 104}, {242, 183, 0}} ,{{80, 104}, {241, 183, 0}} ,{{101, 104}, {6, 184, 0}} ,{{94, 104}, {255, 183, 0}} ,{{95, 104}, {0, 184, 0}} ,{{100, 104}, {5, 184, 0}} ,{{129, 104}, {34, 184, 0}} ,{{122, 104}, {27, 184, 0}} ,{{123, 104}, {28, 184, 0}} ,{{128, 104}, {33, 184, 0}} ,{{211, 105}, {116, 185, 0}} ,{{228, 105}, {133, 185, 0}} ,{{229, 105}, {134, 185, 0}} ,{{234, 105}, {139, 185, 0}} ,{{218, 105}, {123, 185, 0}} ,{{212, 105}, {117, 185, 0}} ,{{213, 105}, {118, 185, 0}} ,{{214, 105}, {119, 185, 0}} ,{{238, 105}, {143, 185, 0}} ,{{233, 105}, {138, 185, 0}} ,{{235, 105}, {140, 185, 0}} ,{{219, 105}, {124, 185, 0}} ,{{222, 105}, {127, 185, 0}} ,{{220, 105}, {125, 185, 0}} ,{{226, 105}, {131, 185, 0}} ,{{221, 105}, {126, 185, 0}} ,{{225, 105}, {130, 185, 0}} ,{{223, 105}, {128, 185, 0}} ,{{224, 105}, {129, 185, 0}} ,{{227, 105}, {132, 185, 0}} ,{{215, 105}, {120, 185, 0}} ,{{232, 105}, {137, 185, 0}} ,{{217, 105}, {122, 185, 0}} ,{{216, 105}, {121, 185, 0}} ,{{237, 105}, {142, 185, 0}} ,{{230, 105}, {135, 185, 0}} ,{{231, 105}, {136, 185, 0}} ,{{236, 105}, {141, 185, 0}} ,{{11, 106}, {172, 185, 0}} ,{{28, 106}, {189, 185, 0}} ,{{29, 106}, {190, 185, 0}} ,{{34, 106}, {195, 185, 0}} ,{{18, 106}, {179, 185, 0}} ,{{12, 106}, {173, 185, 0}} ,{{13, 106}, {174, 185, 0}} ,{{14, 106}, {175, 185, 0}} ,{{38, 106}, {199, 185, 0}} ,{{33, 106}, {194, 185, 0}} ,{{35, 106}, {196, 185, 0}} ,{{19, 106}, {180, 185, 0}} ,{{22, 106}, {183, 185, 0}} ,{{20, 106}, {181, 185, 0}} ,{{26, 106}, {187, 185, 0}} ,{{21, 106}, {182, 185, 0}} ,{{25, 106}, {186, 185, 0}} ,{{23, 106}, {184, 185, 0}} ,{{24, 106}, {185, 185, 0}} ,{{27, 106}, {188, 185, 0}} ,{{15, 106}, {176, 185, 0}} ,{{32, 106}, {193, 185, 0}} ,{{17, 106}, {178, 185, 0}} ,{{16, 106}, {177, 185, 0}} ,{{37, 106}, {198, 185, 0}} ,{{30, 106}, {191, 185, 0}} ,{{31, 106}, {192, 185, 0}} ,{{36, 106}, {197, 185, 0}} ,{{187, 104}, {92, 184, 0}} ,{{204, 104}, {109, 184, 0}} ,{{205, 104}, {110, 184, 0}} ,{{210, 104}, {115, 184, 0}} ,{{194, 104}, {99, 184, 0}} ,{{15, 105}, {176, 184, 0}} ,{{32, 105}, {193, 184, 0}} ,{{33, 105}, {194, 184, 0}} ,{{38, 105}, {199, 184, 0}} ,{{22, 105}, {183, 184, 0}} ,{{16, 105}, {177, 184, 0}} ,{{17, 105}, {178, 184, 0}} ,{{18, 105}, {179, 184, 0}} ,{{42, 105}, {203, 184, 0}} ,{{37, 105}, {198, 184, 0}} ,{{39, 105}, {200, 184, 0}} ,{{23, 105}, {184, 184, 0}} ,{{26, 105}, {187, 184, 0}} ,{{24, 105}, {185, 184, 0}} ,{{30, 105}, {191, 184, 0}} ,{{25, 105}, {186, 184, 0}} ,{{29, 105}, {190, 184, 0}} ,{{27, 105}, {188, 184, 0}} ,{{28, 105}, {189, 184, 0}} ,{{31, 105}, {192, 184, 0}} ,{{19, 105}, {180, 184, 0}} ,{{36, 105}, {197, 184, 0}} ,{{21, 105}, {182, 184, 0}} ,{{20, 105}, {181, 184, 0}} ,{{41, 105}, {202, 184, 0}} ,{{34, 105}, {195, 184, 0}} ,{{35, 105}, {196, 184, 0}} ,{{40, 105}, {201, 184, 0}} ,{{188, 104}, {93, 184, 0}} ,{{189, 104}, {94, 184, 0}} ,{{190, 104}, {95, 184, 0}} ,{{214, 104}, {119, 184, 0}} ,{{209, 104}, {114, 184, 0}} ,{{211, 104}, {116, 184, 0}} ,{{195, 104}, {100, 184, 0}} ,{{198, 104}, {103, 184, 0}} ,{{196, 104}, {101, 184, 0}} ,{{202, 104}, {107, 184, 0}} ,{{197, 104}, {102, 184, 0}} ,{{201, 104}, {106, 184, 0}} ,{{199, 104}, {104, 184, 0}} ,{{200, 104}, {105, 184, 0}} ,{{203, 104}, {108, 184, 0}} ,{{191, 104}, {96, 184, 0}} ,{{208, 104}, {113, 184, 0}} ,{{193, 104}, {98, 184, 0}} ,{{192, 104}, {97, 184, 0}} ,{{213, 104}, {118, 184, 0}} ,{{206, 104}, {111, 184, 0}} ,{{207, 104}, {112, 184, 0}} ,{{212, 104}, {117, 184, 0}} ,{{71, 105}, {232, 184, 0}} ,{{88, 105}, {249, 184, 0}} ,{{89, 105}, {250, 184, 0}} ,{{94, 105}, {255, 184, 0}} ,{{78, 105}, {239, 184, 0}} ,{{72, 105}, {233, 184, 0}} ,{{73, 105}, {234, 184, 0}} ,{{74, 105}, {235, 184, 0}} ,{{98, 105}, {3, 185, 0}} ,{{93, 105}, {254, 184, 0}} ,{{95, 105}, {0, 185, 0}} ,{{79, 105}, {240, 184, 0}} ,{{82, 105}, {243, 184, 0}} ,{{80, 105}, {241, 184, 0}} ,{{86, 105}, {247, 184, 0}} ,{{81, 105}, {242, 184, 0}} ,{{85, 105}, {246, 184, 0}} ,{{83, 105}, {244, 184, 0}} ,{{84, 105}, {245, 184, 0}} ,{{87, 105}, {248, 184, 0}} ,{{75, 105}, {236, 184, 0}} ,{{92, 105}, {253, 184, 0}} ,{{77, 105}, {238, 184, 0}} ,{{76, 105}, {237, 184, 0}} ,{{97, 105}, {2, 185, 0}} ,{{90, 105}, {251, 184, 0}} ,{{91, 105}, {252, 184, 0}} ,{{96, 105}, {1, 185, 0}} ,{{215, 104}, {120, 184, 0}} ,{{232, 104}, {137, 184, 0}} ,{{233, 104}, {138, 184, 0}} ,{{238, 104}, {143, 184, 0}} ,{{222, 104}, {127, 184, 0}} ,{{243, 104}, {148, 184, 0}} ,{{4, 105}, {165, 184, 0}} ,{{5, 105}, {166, 184, 0}} ,{{10, 105}, {171, 184, 0}} ,{{250, 104}, {155, 184, 0}} ,{{244, 104}, {149, 184, 0}} ,{{245, 104}, {150, 184, 0}} ,{{246, 104}, {151, 184, 0}} ,{{14, 105}, {175, 184, 0}} ,{{9, 105}, {170, 184, 0}} ,{{11, 105}, {172, 184, 0}} ,{{251, 104}, {156, 184, 0}} ,{{254, 104}, {159, 184, 0}} ,{{252, 104}, {157, 184, 0}} ,{{2, 105}, {163, 184, 0}} ,{{253, 104}, {158, 184, 0}} ,{{1, 105}, {162, 184, 0}} ,{{255, 104}, {160, 184, 0}} ,{{0, 105}, {161, 184, 0}} ,{{3, 105}, {164, 184, 0}} ,{{247, 104}, {152, 184, 0}} ,{{8, 105}, {169, 184, 0}} ,{{249, 104}, {154, 184, 0}} ,{{248, 104}, {153, 184, 0}} ,{{13, 105}, {174, 184, 0}} ,{{6, 105}, {167, 184, 0}} ,{{7, 105}, {168, 184, 0}} ,{{12, 105}, {173, 184, 0}} ,{{216, 104}, {121, 184, 0}} ,{{217, 104}, {122, 184, 0}} ,{{218, 104}, {123, 184, 0}} ,{{242, 104}, {147, 184, 0}} ,{{237, 104}, {142, 184, 0}} ,{{239, 104}, {144, 184, 0}} ,{{223, 104}, {128, 184, 0}} ,{{226, 104}, {131, 184, 0}} ,{{224, 104}, {129, 184, 0}} ,{{230, 104}, {135, 184, 0}} ,{{225, 104}, {130, 184, 0}} ,{{229, 104}, {134, 184, 0}} ,{{227, 104}, {132, 184, 0}} ,{{228, 104}, {133, 184, 0}} ,{{231, 104}, {136, 184, 0}} ,{{219, 104}, {124, 184, 0}} ,{{236, 104}, {141, 184, 0}} ,{{221, 104}, {126, 184, 0}} ,{{220, 104}, {125, 184, 0}} ,{{241, 104}, {146, 184, 0}} ,{{234, 104}, {139, 184, 0}} ,{{235, 104}, {140, 184, 0}} ,{{240, 104}, {145, 184, 0}} ,{{127, 105}, {32, 185, 0}} ,{{144, 105}, {49, 185, 0}} ,{{145, 105}, {50, 185, 0}} ,{{150, 105}, {55, 185, 0}} ,{{134, 105}, {39, 185, 0}} ,{{128, 105}, {33, 185, 0}} ,{{129, 105}, {34, 185, 0}} ,{{130, 105}, {35, 185, 0}} ,{{154, 105}, {59, 185, 0}} ,{{149, 105}, {54, 185, 0}} ,{{151, 105}, {56, 185, 0}} ,{{135, 105}, {40, 185, 0}} ,{{138, 105}, {43, 185, 0}} ,{{136, 105}, {41, 185, 0}} ,{{142, 105}, {47, 185, 0}} ,{{137, 105}, {42, 185, 0}} ,{{141, 105}, {46, 185, 0}} ,{{139, 105}, {44, 185, 0}} ,{{140, 105}, {45, 185, 0}} ,{{143, 105}, {48, 185, 0}} ,{{131, 105}, {36, 185, 0}} ,{{148, 105}, {53, 185, 0}} ,{{133, 105}, {38, 185, 0}} ,{{132, 105}, {37, 185, 0}} ,{{99, 105}, {4, 185, 0}} ,{{116, 105}, {21, 185, 0}} ,{{117, 105}, {22, 185, 0}} ,{{122, 105}, {27, 185, 0}} ,{{106, 105}, {11, 185, 0}} ,{{100, 105}, {5, 185, 0}} ,{{101, 105}, {6, 185, 0}} ,{{102, 105}, {7, 185, 0}} ,{{126, 105}, {31, 185, 0}} ,{{121, 105}, {26, 185, 0}} ,{{123, 105}, {28, 185, 0}} ,{{107, 105}, {12, 185, 0}} ,{{110, 105}, {15, 185, 0}} ,{{108, 105}, {13, 185, 0}} ,{{114, 105}, {19, 185, 0}} ,{{109, 105}, {14, 185, 0}} ,{{113, 105}, {18, 185, 0}} ,{{111, 105}, {16, 185, 0}} ,{{112, 105}, {17, 185, 0}} ,{{115, 105}, {20, 185, 0}} ,{{103, 105}, {8, 185, 0}} ,{{120, 105}, {25, 185, 0}} ,{{105, 105}, {10, 185, 0}} ,{{104, 105}, {9, 185, 0}} ,{{125, 105}, {30, 185, 0}} ,{{118, 105}, {23, 185, 0}} ,{{119, 105}, {24, 185, 0}} ,{{124, 105}, {29, 185, 0}} ,{{153, 105}, {58, 185, 0}} ,{{146, 105}, {51, 185, 0}} ,{{147, 105}, {52, 185, 0}} ,{{152, 105}, {57, 185, 0}} ,{{155, 105}, {60, 185, 0}} ,{{172, 105}, {77, 185, 0}} ,{{173, 105}, {78, 185, 0}} ,{{178, 105}, {83, 185, 0}} ,{{162, 105}, {67, 185, 0}} ,{{156, 105}, {61, 185, 0}} ,{{157, 105}, {62, 185, 0}} ,{{158, 105}, {63, 185, 0}} ,{{182, 105}, {87, 185, 0}} ,{{177, 105}, {82, 185, 0}} ,{{179, 105}, {84, 185, 0}} ,{{163, 105}, {68, 185, 0}} ,{{166, 105}, {71, 185, 0}} ,{{164, 105}, {69, 185, 0}} ,{{170, 105}, {75, 185, 0}} ,{{165, 105}, {70, 185, 0}} ,{{169, 105}, {74, 185, 0}} ,{{167, 105}, {72, 185, 0}} ,{{168, 105}, {73, 185, 0}} ,{{171, 105}, {76, 185, 0}} ,{{159, 105}, {64, 185, 0}} ,{{176, 105}, {81, 185, 0}} ,{{161, 105}, {66, 185, 0}} ,{{160, 105}, {65, 185, 0}} ,{{181, 105}, {86, 185, 0}} ,{{174, 105}, {79, 185, 0}} ,{{175, 105}, {80, 185, 0}} ,{{180, 105}, {85, 185, 0}} ,{{19, 104}, {180, 183, 0}} ,{{36, 104}, {197, 183, 0}} ,{{37, 104}, {198, 183, 0}} ,{{42, 104}, {203, 183, 0}} ,{{26, 104}, {187, 183, 0}} ,{{47, 104}, {208, 183, 0}} ,{{64, 104}, {225, 183, 0}} ,{{65, 104}, {226, 183, 0}} ,{{70, 104}, {231, 183, 0}} ,{{54, 104}, {215, 183, 0}} ,{{48, 104}, {209, 183, 0}} ,{{49, 104}, {210, 183, 0}} ,{{50, 104}, {211, 183, 0}} ,{{74, 104}, {235, 183, 0}} ,{{69, 104}, {230, 183, 0}} ,{{71, 104}, {232, 183, 0}} ,{{55, 104}, {216, 183, 0}} ,{{58, 104}, {219, 183, 0}} ,{{56, 104}, {217, 183, 0}} ,{{62, 104}, {223, 183, 0}} ,{{57, 104}, {218, 183, 0}} ,{{61, 104}, {222, 183, 0}} ,{{59, 104}, {220, 183, 0}} ,{{60, 104}, {221, 183, 0}} ,{{63, 104}, {224, 183, 0}} ,{{51, 104}, {212, 183, 0}} ,{{68, 104}, {229, 183, 0}} ,{{53, 104}, {214, 183, 0}} ,{{52, 104}, {213, 183, 0}} ,{{73, 104}, {234, 183, 0}} ,{{66, 104}, {227, 183, 0}} ,{{67, 104}, {228, 183, 0}} ,{{72, 104}, {233, 183, 0}} ,{{20, 104}, {181, 183, 0}} ,{{21, 104}, {182, 183, 0}} ,{{22, 104}, {183, 183, 0}} ,{{46, 104}, {207, 183, 0}} ,{{41, 104}, {202, 183, 0}} ,{{43, 104}, {204, 183, 0}} ,{{27, 104}, {188, 183, 0}} ,{{30, 104}, {191, 183, 0}} ,{{28, 104}, {189, 183, 0}} ,{{34, 104}, {195, 183, 0}} ,{{29, 104}, {190, 183, 0}} ,{{33, 104}, {194, 183, 0}} ,{{31, 104}, {192, 183, 0}} ,{{32, 104}, {193, 183, 0}} ,{{35, 104}, {196, 183, 0}} ,{{23, 104}, {184, 183, 0}} ,{{40, 104}, {201, 183, 0}} ,{{25, 104}, {186, 183, 0}} ,{{24, 104}, {185, 183, 0}} ,{{45, 104}, {206, 183, 0}} ,{{38, 104}, {199, 183, 0}} ,{{39, 104}, {200, 183, 0}} ,{{44, 104}, {205, 183, 0}} ,{{159, 104}, {64, 184, 0}} ,{{176, 104}, {81, 184, 0}} ,{{177, 104}, {82, 184, 0}} ,{{182, 104}, {87, 184, 0}} ,{{166, 104}, {71, 184, 0}} ,{{160, 104}, {65, 184, 0}} ,{{161, 104}, {66, 184, 0}} ,{{162, 104}, {67, 184, 0}} ,{{186, 104}, {91, 184, 0}} ,{{181, 104}, {86, 184, 0}} ,{{183, 104}, {88, 184, 0}} ,{{167, 104}, {72, 184, 0}} ,{{170, 104}, {75, 184, 0}} ,{{168, 104}, {73, 184, 0}} ,{{174, 104}, {79, 184, 0}} ,{{169, 104}, {74, 184, 0}} ,{{173, 104}, {78, 184, 0}} ,{{171, 104}, {76, 184, 0}} ,{{172, 104}, {77, 184, 0}} ,{{175, 104}, {80, 184, 0}} ,{{163, 104}, {68, 184, 0}} ,{{180, 104}, {85, 184, 0}} ,{{165, 104}, {70, 184, 0}} ,{{164, 104}, {69, 184, 0}} ,{{131, 104}, {36, 184, 0}} ,{{148, 104}, {53, 184, 0}} ,{{149, 104}, {54, 184, 0}} ,{{154, 104}, {59, 184, 0}} ,{{138, 104}, {43, 184, 0}} ,{{132, 104}, {37, 184, 0}} ,{{133, 104}, {38, 184, 0}} ,{{134, 104}, {39, 184, 0}} ,{{158, 104}, {63, 184, 0}} ,{{153, 104}, {58, 184, 0}} ,{{155, 104}, {60, 184, 0}} ,{{139, 104}, {44, 184, 0}} ,{{142, 104}, {47, 184, 0}} ,{{140, 104}, {45, 184, 0}} ,{{146, 104}, {51, 184, 0}} ,{{141, 104}, {46, 184, 0}} ,{{145, 104}, {50, 184, 0}} ,{{143, 104}, {48, 184, 0}} ,{{144, 104}, {49, 184, 0}} ,{{147, 104}, {52, 184, 0}} ,{{135, 104}, {40, 184, 0}} ,{{152, 104}, {57, 184, 0}} ,{{137, 104}, {42, 184, 0}} ,{{136, 104}, {41, 184, 0}} ,{{157, 104}, {62, 184, 0}} ,{{150, 104}, {55, 184, 0}} ,{{151, 104}, {56, 184, 0}} ,{{156, 104}, {61, 184, 0}} ,{{185, 104}, {90, 184, 0}} ,{{178, 104}, {83, 184, 0}} ,{{179, 104}, {84, 184, 0}} ,{{184, 104}, {89, 184, 0}} ,{{239, 105}, {144, 185, 0}} ,{{0, 106}, {161, 185, 0}} ,{{1, 106}, {162, 185, 0}} ,{{6, 106}, {167, 185, 0}} ,{{246, 105}, {151, 185, 0}} ,{{240, 105}, {145, 185, 0}} ,{{241, 105}, {146, 185, 0}} ,{{242, 105}, {147, 185, 0}} ,{{10, 106}, {171, 185, 0}} ,{{5, 106}, {166, 185, 0}} ,{{7, 106}, {168, 185, 0}} ,{{247, 105}, {152, 185, 0}} ,{{250, 105}, {155, 185, 0}} ,{{248, 105}, {153, 185, 0}} ,{{254, 105}, {159, 185, 0}} ,{{249, 105}, {154, 185, 0}} ,{{253, 105}, {158, 185, 0}} ,{{251, 105}, {156, 185, 0}} ,{{252, 105}, {157, 185, 0}} ,{{255, 105}, {160, 185, 0}} ,{{243, 105}, {148, 185, 0}} ,{{4, 106}, {165, 185, 0}} ,{{245, 105}, {150, 185, 0}} ,{{244, 105}, {149, 185, 0}} ,{{9, 106}, {170, 185, 0}} ,{{2, 106}, {163, 185, 0}} ,{{3, 106}, {164, 185, 0}} ,{{8, 106}, {169, 185, 0}} ,{{43, 105}, {204, 184, 0}} ,{{60, 105}, {221, 184, 0}} ,{{61, 105}, {222, 184, 0}} ,{{66, 105}, {227, 184, 0}} ,{{50, 105}, {211, 184, 0}} ,{{44, 105}, {205, 184, 0}} ,{{45, 105}, {206, 184, 0}} ,{{46, 105}, {207, 184, 0}} ,{{70, 105}, {231, 184, 0}} ,{{65, 105}, {226, 184, 0}} ,{{67, 105}, {228, 184, 0}} ,{{51, 105}, {212, 184, 0}} ,{{54, 105}, {215, 184, 0}} ,{{52, 105}, {213, 184, 0}} ,{{58, 105}, {219, 184, 0}} ,{{53, 105}, {214, 184, 0}} ,{{57, 105}, {218, 184, 0}} ,{{55, 105}, {216, 184, 0}} ,{{56, 105}, {217, 184, 0}} ,{{59, 105}, {220, 184, 0}} ,{{47, 105}, {208, 184, 0}} ,{{64, 105}, {225, 184, 0}} ,{{49, 105}, {210, 184, 0}} ,{{48, 105}, {209, 184, 0}} ,{{69, 105}, {230, 184, 0}} ,{{62, 105}, {223, 184, 0}} ,{{63, 105}, {224, 184, 0}} ,{{68, 105}, {229, 184, 0}} ,{{183, 105}, {88, 185, 0}} ,{{200, 105}, {105, 185, 0}} ,{{201, 105}, {106, 185, 0}} ,{{206, 105}, {111, 185, 0}} ,{{190, 105}, {95, 185, 0}} ,{{184, 105}, {89, 185, 0}} ,{{185, 105}, {90, 185, 0}} ,{{186, 105}, {91, 185, 0}} ,{{210, 105}, {115, 185, 0}} ,{{205, 105}, {110, 185, 0}} ,{{207, 105}, {112, 185, 0}} ,{{191, 105}, {96, 185, 0}} ,{{194, 105}, {99, 185, 0}} ,{{192, 105}, {97, 185, 0}} ,{{198, 105}, {103, 185, 0}} ,{{193, 105}, {98, 185, 0}} ,{{197, 105}, {102, 185, 0}} ,{{195, 105}, {100, 185, 0}} ,{{196, 105}, {101, 185, 0}} ,{{199, 105}, {104, 185, 0}} ,{{187, 105}, {92, 185, 0}} ,{{204, 105}, {109, 185, 0}} ,{{189, 105}, {94, 185, 0}} ,{{188, 105}, {93, 185, 0}} ,{{209, 105}, {114, 185, 0}} ,{{202, 105}, {107, 185, 0}} ,{{203, 105}, {108, 185, 0}} ,{{208, 105}, {113, 185, 0}} ,{{11, 113}, {172, 192, 0}} ,{{28, 113}, {189, 192, 0}} ,{{29, 113}, {190, 192, 0}} ,{{34, 113}, {195, 192, 0}} ,{{18, 113}, {179, 192, 0}} ,{{39, 113}, {200, 192, 0}} ,{{56, 113}, {217, 192, 0}} ,{{57, 113}, {218, 192, 0}} ,{{62, 113}, {223, 192, 0}} ,{{46, 113}, {207, 192, 0}} ,{{40, 113}, {201, 192, 0}} ,{{41, 113}, {202, 192, 0}} ,{{42, 113}, {203, 192, 0}} ,{{66, 113}, {227, 192, 0}} ,{{61, 113}, {222, 192, 0}} ,{{63, 113}, {224, 192, 0}} ,{{47, 113}, {208, 192, 0}} ,{{50, 113}, {211, 192, 0}} ,{{48, 113}, {209, 192, 0}} ,{{54, 113}, {215, 192, 0}} ,{{49, 113}, {210, 192, 0}} ,{{53, 113}, {214, 192, 0}} ,{{51, 113}, {212, 192, 0}} ,{{52, 113}, {213, 192, 0}} ,{{55, 113}, {216, 192, 0}} ,{{43, 113}, {204, 192, 0}} ,{{60, 113}, {221, 192, 0}} ,{{45, 113}, {206, 192, 0}} ,{{44, 113}, {205, 192, 0}} ,{{65, 113}, {226, 192, 0}} ,{{58, 113}, {219, 192, 0}} ,{{59, 113}, {220, 192, 0}} ,{{64, 113}, {225, 192, 0}} ,{{12, 113}, {173, 192, 0}} ,{{13, 113}, {174, 192, 0}} ,{{14, 113}, {175, 192, 0}} ,{{38, 113}, {199, 192, 0}} ,{{33, 113}, {194, 192, 0}} ,{{35, 113}, {196, 192, 0}} ,{{19, 113}, {180, 192, 0}} ,{{22, 113}, {183, 192, 0}} ,{{20, 113}, {181, 192, 0}} ,{{26, 113}, {187, 192, 0}} ,{{21, 113}, {182, 192, 0}} ,{{25, 113}, {186, 192, 0}} ,{{23, 113}, {184, 192, 0}} ,{{24, 113}, {185, 192, 0}} ,{{27, 113}, {188, 192, 0}} ,{{15, 113}, {176, 192, 0}} ,{{32, 113}, {193, 192, 0}} ,{{17, 113}, {178, 192, 0}} ,{{16, 113}, {177, 192, 0}} ,{{37, 113}, {198, 192, 0}} ,{{30, 113}, {191, 192, 0}} ,{{31, 113}, {192, 192, 0}} ,{{36, 113}, {197, 192, 0}} ,{{151, 113}, {56, 193, 0}} ,{{168, 113}, {73, 193, 0}} ,{{169, 113}, {74, 193, 0}} ,{{174, 113}, {79, 193, 0}} ,{{158, 113}, {63, 193, 0}} ,{{152, 113}, {57, 193, 0}} ,{{153, 113}, {58, 193, 0}} ,{{154, 113}, {59, 193, 0}} ,{{178, 113}, {83, 193, 0}} ,{{173, 113}, {78, 193, 0}} ,{{175, 113}, {80, 193, 0}} ,{{159, 113}, {64, 193, 0}} ,{{162, 113}, {67, 193, 0}} ,{{160, 113}, {65, 193, 0}} ,{{166, 113}, {71, 193, 0}} ,{{161, 113}, {66, 193, 0}} ,{{165, 113}, {70, 193, 0}} ,{{163, 113}, {68, 193, 0}} ,{{164, 113}, {69, 193, 0}} ,{{167, 113}, {72, 193, 0}} ,{{155, 113}, {60, 193, 0}} ,{{172, 113}, {77, 193, 0}} ,{{157, 113}, {62, 193, 0}} ,{{156, 113}, {61, 193, 0}} ,{{123, 113}, {28, 193, 0}} ,{{140, 113}, {45, 193, 0}} ,{{141, 113}, {46, 193, 0}} ,{{146, 113}, {51, 193, 0}} ,{{130, 113}, {35, 193, 0}} ,{{124, 113}, {29, 193, 0}} ,{{125, 113}, {30, 193, 0}} ,{{126, 113}, {31, 193, 0}} ,{{150, 113}, {55, 193, 0}} ,{{145, 113}, {50, 193, 0}} ,{{147, 113}, {52, 193, 0}} ,{{131, 113}, {36, 193, 0}} ,{{134, 113}, {39, 193, 0}} ,{{132, 113}, {37, 193, 0}} ,{{138, 113}, {43, 193, 0}} ,{{133, 113}, {38, 193, 0}} ,{{137, 113}, {42, 193, 0}} ,{{135, 113}, {40, 193, 0}} ,{{136, 113}, {41, 193, 0}} ,{{139, 113}, {44, 193, 0}} ,{{127, 113}, {32, 193, 0}} ,{{144, 113}, {49, 193, 0}} ,{{129, 113}, {34, 193, 0}} ,{{128, 113}, {33, 193, 0}} ,{{149, 113}, {54, 193, 0}} ,{{142, 113}, {47, 193, 0}} ,{{143, 113}, {48, 193, 0}} ,{{148, 113}, {53, 193, 0}} ,{{177, 113}, {82, 193, 0}} ,{{170, 113}, {75, 193, 0}} ,{{171, 113}, {76, 193, 0}} ,{{176, 113}, {81, 193, 0}} ,{{3, 115}, {164, 194, 0}} ,{{20, 115}, {181, 194, 0}} ,{{21, 115}, {182, 194, 0}} ,{{26, 115}, {187, 194, 0}} ,{{10, 115}, {171, 194, 0}} ,{{4, 115}, {165, 194, 0}} ,{{5, 115}, {166, 194, 0}} ,{{6, 115}, {167, 194, 0}} ,{{30, 115}, {191, 194, 0}} ,{{25, 115}, {186, 194, 0}} ,{{27, 115}, {188, 194, 0}} ,{{11, 115}, {172, 194, 0}} ,{{14, 115}, {175, 194, 0}} ,{{12, 115}, {173, 194, 0}} ,{{18, 115}, {179, 194, 0}} ,{{13, 115}, {174, 194, 0}} ,{{17, 115}, {178, 194, 0}} ,{{15, 115}, {176, 194, 0}} ,{{16, 115}, {177, 194, 0}} ,{{19, 115}, {180, 194, 0}} ,{{7, 115}, {168, 194, 0}} ,{{24, 115}, {185, 194, 0}} ,{{9, 115}, {170, 194, 0}} ,{{8, 115}, {169, 194, 0}} ,{{29, 115}, {190, 194, 0}} ,{{22, 115}, {183, 194, 0}} ,{{23, 115}, {184, 194, 0}} ,{{28, 115}, {189, 194, 0}} ,{{59, 115}, {220, 194, 0}} ,{{76, 115}, {237, 194, 0}} ,{{77, 115}, {238, 194, 0}} ,{{82, 115}, {243, 194, 0}} ,{{66, 115}, {227, 194, 0}} ,{{60, 115}, {221, 194, 0}} ,{{61, 115}, {222, 194, 0}} ,{{62, 115}, {223, 194, 0}} ,{{86, 115}, {247, 194, 0}} ,{{81, 115}, {242, 194, 0}} ,{{83, 115}, {244, 194, 0}} ,{{67, 115}, {228, 194, 0}} ,{{70, 115}, {231, 194, 0}} ,{{68, 115}, {229, 194, 0}} ,{{74, 115}, {235, 194, 0}} ,{{69, 115}, {230, 194, 0}} ,{{73, 115}, {234, 194, 0}} ,{{71, 115}, {232, 194, 0}} ,{{72, 115}, {233, 194, 0}} ,{{75, 115}, {236, 194, 0}} ,{{63, 115}, {224, 194, 0}} ,{{80, 115}, {241, 194, 0}} ,{{65, 115}, {226, 194, 0}} ,{{64, 115}, {225, 194, 0}} ,{{85, 115}, {246, 194, 0}} ,{{78, 115}, {239, 194, 0}} ,{{79, 115}, {240, 194, 0}} ,{{84, 115}, {245, 194, 0}} ,{{235, 113}, {140, 193, 0}} ,{{252, 113}, {157, 193, 0}} ,{{253, 113}, {158, 193, 0}} ,{{2, 114}, {163, 193, 0}} ,{{242, 113}, {147, 193, 0}} ,{{63, 114}, {224, 193, 0}} ,{{80, 114}, {241, 193, 0}} ,{{81, 114}, {242, 193, 0}} ,{{86, 114}, {247, 193, 0}} ,{{70, 114}, {231, 193, 0}} ,{{64, 114}, {225, 193, 0}} ,{{65, 114}, {226, 193, 0}} ,{{66, 114}, {227, 193, 0}} ,{{90, 114}, {251, 193, 0}} ,{{85, 114}, {246, 193, 0}} ,{{87, 114}, {248, 193, 0}} ,{{71, 114}, {232, 193, 0}} ,{{74, 114}, {235, 193, 0}} ,{{72, 114}, {233, 193, 0}} ,{{78, 114}, {239, 193, 0}} ,{{73, 114}, {234, 193, 0}} ,{{77, 114}, {238, 193, 0}} ,{{75, 114}, {236, 193, 0}} ,{{76, 114}, {237, 193, 0}} ,{{79, 114}, {240, 193, 0}} ,{{67, 114}, {228, 193, 0}} ,{{84, 114}, {245, 193, 0}} ,{{69, 114}, {230, 193, 0}} ,{{68, 114}, {229, 193, 0}} ,{{89, 114}, {250, 193, 0}} ,{{82, 114}, {243, 193, 0}} ,{{83, 114}, {244, 193, 0}} ,{{88, 114}, {249, 193, 0}} ,{{236, 113}, {141, 193, 0}} ,{{237, 113}, {142, 193, 0}} ,{{238, 113}, {143, 193, 0}} ,{{6, 114}, {167, 193, 0}} ,{{1, 114}, {162, 193, 0}} ,{{3, 114}, {164, 193, 0}} ,{{243, 113}, {148, 193, 0}} ,{{246, 113}, {151, 193, 0}} ,{{244, 113}, {149, 193, 0}} ,{{250, 113}, {155, 193, 0}} ,{{245, 113}, {150, 193, 0}} ,{{249, 113}, {154, 193, 0}} ,{{247, 113}, {152, 193, 0}} ,{{248, 113}, {153, 193, 0}} ,{{251, 113}, {156, 193, 0}} ,{{239, 113}, {144, 193, 0}} ,{{0, 114}, {161, 193, 0}} ,{{241, 113}, {146, 193, 0}} ,{{240, 113}, {145, 193, 0}} ,{{5, 114}, {166, 193, 0}} ,{{254, 113}, {159, 193, 0}} ,{{255, 113}, {160, 193, 0}} ,{{4, 114}, {165, 193, 0}} ,{{87, 115}, {248, 194, 0}} ,{{104, 115}, {9, 195, 0}} ,{{105, 115}, {10, 195, 0}} ,{{110, 115}, {15, 195, 0}} ,{{94, 115}, {255, 194, 0}} ,{{115, 115}, {20, 195, 0}} ,{{132, 115}, {37, 195, 0}} ,{{133, 115}, {38, 195, 0}} ,{{138, 115}, {43, 195, 0}} ,{{122, 115}, {27, 195, 0}} ,{{116, 115}, {21, 195, 0}} ,{{117, 115}, {22, 195, 0}} ,{{118, 115}, {23, 195, 0}} ,{{142, 115}, {47, 195, 0}} ,{{137, 115}, {42, 195, 0}} ,{{139, 115}, {44, 195, 0}} ,{{123, 115}, {28, 195, 0}} ,{{126, 115}, {31, 195, 0}} ,{{124, 115}, {29, 195, 0}} ,{{130, 115}, {35, 195, 0}} ,{{125, 115}, {30, 195, 0}} ,{{129, 115}, {34, 195, 0}} ,{{127, 115}, {32, 195, 0}} ,{{128, 115}, {33, 195, 0}} ,{{131, 115}, {36, 195, 0}} ,{{119, 115}, {24, 195, 0}} ,{{136, 115}, {41, 195, 0}} ,{{121, 115}, {26, 195, 0}} ,{{120, 115}, {25, 195, 0}} ,{{141, 115}, {46, 195, 0}} ,{{134, 115}, {39, 195, 0}} ,{{135, 115}, {40, 195, 0}} ,{{140, 115}, {45, 195, 0}} ,{{88, 115}, {249, 194, 0}} ,{{89, 115}, {250, 194, 0}} ,{{90, 115}, {251, 194, 0}} ,{{114, 115}, {19, 195, 0}} ,{{109, 115}, {14, 195, 0}} ,{{111, 115}, {16, 195, 0}} ,{{95, 115}, {0, 195, 0}} ,{{98, 115}, {3, 195, 0}} ,{{96, 115}, {1, 195, 0}} ,{{102, 115}, {7, 195, 0}} ,{{97, 115}, {2, 195, 0}} ,{{101, 115}, {6, 195, 0}} ,{{99, 115}, {4, 195, 0}} ,{{100, 115}, {5, 195, 0}} ,{{103, 115}, {8, 195, 0}} ,{{91, 115}, {252, 194, 0}} ,{{108, 115}, {13, 195, 0}} ,{{93, 115}, {254, 194, 0}} ,{{92, 115}, {253, 194, 0}} ,{{113, 115}, {18, 195, 0}} ,{{106, 115}, {11, 195, 0}} ,{{107, 115}, {12, 195, 0}} ,{{112, 115}, {17, 195, 0}} ,{{227, 115}, {132, 195, 0}} ,{{244, 115}, {149, 195, 0}} ,{{245, 115}, {150, 195, 0}} ,{{250, 115}, {155, 195, 0}} ,{{234, 115}, {139, 195, 0}} ,{{228, 115}, {133, 195, 0}} ,{{229, 115}, {134, 195, 0}} ,{{230, 115}, {135, 195, 0}} ,{{254, 115}, {159, 195, 0}} ,{{249, 115}, {154, 195, 0}} ,{{251, 115}, {156, 195, 0}} ,{{235, 115}, {140, 195, 0}} ,{{238, 115}, {143, 195, 0}} ,{{236, 115}, {141, 195, 0}} ,{{242, 115}, {147, 195, 0}} ,{{237, 115}, {142, 195, 0}} ,{{241, 115}, {146, 195, 0}} ,{{239, 115}, {144, 195, 0}} ,{{240, 115}, {145, 195, 0}} ,{{243, 115}, {148, 195, 0}} ,{{231, 115}, {136, 195, 0}} ,{{248, 115}, {153, 195, 0}} ,{{233, 115}, {138, 195, 0}} ,{{232, 115}, {137, 195, 0}} ,{{199, 115}, {104, 195, 0}} ,{{216, 115}, {121, 195, 0}} ,{{217, 115}, {122, 195, 0}} ,{{222, 115}, {127, 195, 0}} ,{{206, 115}, {111, 195, 0}} ,{{200, 115}, {105, 195, 0}} ,{{201, 115}, {106, 195, 0}} ,{{202, 115}, {107, 195, 0}} ,{{226, 115}, {131, 195, 0}} ,{{221, 115}, {126, 195, 0}} ,{{223, 115}, {128, 195, 0}} ,{{207, 115}, {112, 195, 0}} ,{{210, 115}, {115, 195, 0}} ,{{208, 115}, {113, 195, 0}} ,{{214, 115}, {119, 195, 0}} ,{{209, 115}, {114, 195, 0}} ,{{213, 115}, {118, 195, 0}} ,{{211, 115}, {116, 195, 0}} ,{{212, 115}, {117, 195, 0}} ,{{215, 115}, {120, 195, 0}} ,{{203, 115}, {108, 195, 0}} ,{{220, 115}, {125, 195, 0}} ,{{205, 115}, {110, 195, 0}} ,{{204, 115}, {109, 195, 0}} ,{{225, 115}, {130, 195, 0}} ,{{218, 115}, {123, 195, 0}} ,{{219, 115}, {124, 195, 0}} ,{{224, 115}, {129, 195, 0}} ,{{253, 115}, {158, 195, 0}} ,{{246, 115}, {151, 195, 0}} ,{{247, 115}, {152, 195, 0}} ,{{252, 115}, {157, 195, 0}} ,{{79, 117}, {240, 196, 0}} ,{{96, 117}, {1, 197, 0}} ,{{97, 117}, {2, 197, 0}} ,{{102, 117}, {7, 197, 0}} ,{{86, 117}, {247, 196, 0}} ,{{80, 117}, {241, 196, 0}} ,{{81, 117}, {242, 196, 0}} ,{{82, 117}, {243, 196, 0}} ,{{106, 117}, {11, 197, 0}} ,{{101, 117}, {6, 197, 0}} ,{{103, 117}, {8, 197, 0}} ,{{87, 117}, {248, 196, 0}} ,{{90, 117}, {251, 196, 0}} ,{{88, 117}, {249, 196, 0}} ,{{94, 117}, {255, 196, 0}} ,{{89, 117}, {250, 196, 0}} ,{{93, 117}, {254, 196, 0}} ,{{91, 117}, {252, 196, 0}} ,{{92, 117}, {253, 196, 0}} ,{{95, 117}, {0, 197, 0}} ,{{83, 117}, {244, 196, 0}} ,{{100, 117}, {5, 197, 0}} ,{{85, 117}, {246, 196, 0}} ,{{84, 117}, {245, 196, 0}} ,{{105, 117}, {10, 197, 0}} ,{{98, 117}, {3, 197, 0}} ,{{99, 117}, {4, 197, 0}} ,{{104, 117}, {9, 197, 0}} ,{{135, 117}, {40, 197, 0}} ,{{152, 117}, {57, 197, 0}} ,{{153, 117}, {58, 197, 0}} ,{{158, 117}, {63, 197, 0}} ,{{142, 117}, {47, 197, 0}} ,{{136, 117}, {41, 197, 0}} ,{{137, 117}, {42, 197, 0}} ,{{138, 117}, {43, 197, 0}} ,{{162, 117}, {67, 197, 0}} ,{{157, 117}, {62, 197, 0}} ,{{159, 117}, {64, 197, 0}} ,{{143, 117}, {48, 197, 0}} ,{{146, 117}, {51, 197, 0}} ,{{144, 117}, {49, 197, 0}} ,{{150, 117}, {55, 197, 0}} ,{{145, 117}, {50, 197, 0}} ,{{149, 117}, {54, 197, 0}} ,{{147, 117}, {52, 197, 0}} ,{{148, 117}, {53, 197, 0}} ,{{151, 117}, {56, 197, 0}} ,{{139, 117}, {44, 197, 0}} ,{{156, 117}, {61, 197, 0}} ,{{141, 117}, {46, 197, 0}} ,{{140, 117}, {45, 197, 0}} ,{{161, 117}, {66, 197, 0}} ,{{154, 117}, {59, 197, 0}} ,{{155, 117}, {60, 197, 0}} ,{{160, 117}, {65, 197, 0}} ,{{55, 116}, {216, 195, 0}} ,{{72, 116}, {233, 195, 0}} ,{{73, 116}, {234, 195, 0}} ,{{78, 116}, {239, 195, 0}} ,{{62, 116}, {223, 195, 0}} ,{{139, 116}, {44, 196, 0}} ,{{156, 116}, {61, 196, 0}} ,{{157, 116}, {62, 196, 0}} ,{{162, 116}, {67, 196, 0}} ,{{146, 116}, {51, 196, 0}} ,{{140, 116}, {45, 196, 0}} ,{{141, 116}, {46, 196, 0}} ,{{142, 116}, {47, 196, 0}} ,{{166, 116}, {71, 196, 0}} ,{{161, 116}, {66, 196, 0}} ,{{163, 116}, {68, 196, 0}} ,{{147, 116}, {52, 196, 0}} ,{{150, 116}, {55, 196, 0}} ,{{148, 116}, {53, 196, 0}} ,{{154, 116}, {59, 196, 0}} ,{{149, 116}, {54, 196, 0}} ,{{153, 116}, {58, 196, 0}} ,{{151, 116}, {56, 196, 0}} ,{{152, 116}, {57, 196, 0}} ,{{155, 116}, {60, 196, 0}} ,{{143, 116}, {48, 196, 0}} ,{{160, 116}, {65, 196, 0}} ,{{145, 116}, {50, 196, 0}} ,{{144, 116}, {49, 196, 0}} ,{{165, 116}, {70, 196, 0}} ,{{158, 116}, {63, 196, 0}} ,{{159, 116}, {64, 196, 0}} ,{{164, 116}, {69, 196, 0}} ,{{56, 116}, {217, 195, 0}} ,{{57, 116}, {218, 195, 0}} ,{{58, 116}, {219, 195, 0}} ,{{82, 116}, {243, 195, 0}} ,{{77, 116}, {238, 195, 0}} ,{{79, 116}, {240, 195, 0}} ,{{63, 116}, {224, 195, 0}} ,{{66, 116}, {227, 195, 0}} ,{{64, 116}, {225, 195, 0}} ,{{70, 116}, {231, 195, 0}} ,{{65, 116}, {226, 195, 0}} ,{{69, 116}, {230, 195, 0}} ,{{67, 116}, {228, 195, 0}} ,{{68, 116}, {229, 195, 0}} ,{{71, 116}, {232, 195, 0}} ,{{59, 116}, {220, 195, 0}} ,{{76, 116}, {237, 195, 0}} ,{{61, 116}, {222, 195, 0}} ,{{60, 116}, {221, 195, 0}} ,{{81, 116}, {242, 195, 0}} ,{{74, 116}, {235, 195, 0}} ,{{75, 116}, {236, 195, 0}} ,{{80, 116}, {241, 195, 0}} ,{{195, 116}, {100, 196, 0}} ,{{212, 116}, {117, 196, 0}} ,{{213, 116}, {118, 196, 0}} ,{{218, 116}, {123, 196, 0}} ,{{202, 116}, {107, 196, 0}} ,{{196, 116}, {101, 196, 0}} ,{{197, 116}, {102, 196, 0}} ,{{198, 116}, {103, 196, 0}} ,{{222, 116}, {127, 196, 0}} ,{{217, 116}, {122, 196, 0}} ,{{219, 116}, {124, 196, 0}} ,{{203, 116}, {108, 196, 0}} ,{{206, 116}, {111, 196, 0}} ,{{204, 116}, {109, 196, 0}} ,{{210, 116}, {115, 196, 0}} ,{{205, 116}, {110, 196, 0}} ,{{209, 116}, {114, 196, 0}} ,{{207, 116}, {112, 196, 0}} ,{{208, 116}, {113, 196, 0}} ,{{211, 116}, {116, 196, 0}} ,{{199, 116}, {104, 196, 0}} ,{{216, 116}, {121, 196, 0}} ,{{201, 116}, {106, 196, 0}} ,{{200, 116}, {105, 196, 0}} ,{{221, 116}, {126, 196, 0}} ,{{214, 116}, {119, 196, 0}} ,{{215, 116}, {120, 196, 0}} ,{{220, 116}, {125, 196, 0}} ,{{83, 116}, {244, 195, 0}} ,{{100, 116}, {5, 196, 0}} ,{{101, 116}, {6, 196, 0}} ,{{106, 116}, {11, 196, 0}} ,{{90, 116}, {251, 195, 0}} ,{{111, 116}, {16, 196, 0}} ,{{128, 116}, {33, 196, 0}} ,{{129, 116}, {34, 196, 0}} ,{{134, 116}, {39, 196, 0}} ,{{118, 116}, {23, 196, 0}} ,{{112, 116}, {17, 196, 0}} ,{{113, 116}, {18, 196, 0}} ,{{114, 116}, {19, 196, 0}} ,{{138, 116}, {43, 196, 0}} ,{{133, 116}, {38, 196, 0}} ,{{135, 116}, {40, 196, 0}} ,{{119, 116}, {24, 196, 0}} ,{{122, 116}, {27, 196, 0}} ,{{120, 116}, {25, 196, 0}} ,{{126, 116}, {31, 196, 0}} ,{{121, 116}, {26, 196, 0}} ,{{125, 116}, {30, 196, 0}} ,{{123, 116}, {28, 196, 0}} ,{{124, 116}, {29, 196, 0}} ,{{127, 116}, {32, 196, 0}} ,{{115, 116}, {20, 196, 0}} ,{{132, 116}, {37, 196, 0}} ,{{117, 116}, {22, 196, 0}} ,{{116, 116}, {21, 196, 0}} ,{{137, 116}, {42, 196, 0}} ,{{130, 116}, {35, 196, 0}} ,{{131, 116}, {36, 196, 0}} ,{{136, 116}, {41, 196, 0}} ,{{84, 116}, {245, 195, 0}} ,{{85, 116}, {246, 195, 0}} ,{{86, 116}, {247, 195, 0}} ,{{110, 116}, {15, 196, 0}} ,{{105, 116}, {10, 196, 0}} ,{{107, 116}, {12, 196, 0}} ,{{91, 116}, {252, 195, 0}} ,{{94, 116}, {255, 195, 0}} ,{{92, 116}, {253, 195, 0}} ,{{98, 116}, {3, 196, 0}} ,{{93, 116}, {254, 195, 0}} ,{{97, 116}, {2, 196, 0}} ,{{95, 116}, {0, 196, 0}} ,{{96, 116}, {1, 196, 0}} ,{{99, 116}, {4, 196, 0}} ,{{87, 116}, {248, 195, 0}} ,{{104, 116}, {9, 196, 0}} ,{{89, 116}, {250, 195, 0}} ,{{88, 116}, {249, 195, 0}} ,{{109, 116}, {14, 196, 0}} ,{{102, 116}, {7, 196, 0}} ,{{103, 116}, {8, 196, 0}} ,{{108, 116}, {13, 196, 0}} ,{{251, 116}, {156, 196, 0}} ,{{12, 117}, {173, 196, 0}} ,{{13, 117}, {174, 196, 0}} ,{{18, 117}, {179, 196, 0}} ,{{2, 117}, {163, 196, 0}} ,{{252, 116}, {157, 196, 0}} ,{{253, 116}, {158, 196, 0}} ,{{254, 116}, {159, 196, 0}} ,{{22, 117}, {183, 196, 0}} ,{{17, 117}, {178, 196, 0}} ,{{19, 117}, {180, 196, 0}} ,{{3, 117}, {164, 196, 0}} ,{{6, 117}, {167, 196, 0}} ,{{4, 117}, {165, 196, 0}} ,{{10, 117}, {171, 196, 0}} ,{{5, 117}, {166, 196, 0}} ,{{9, 117}, {170, 196, 0}} ,{{7, 117}, {168, 196, 0}} ,{{8, 117}, {169, 196, 0}} ,{{11, 117}, {172, 196, 0}} ,{{255, 116}, {160, 196, 0}} ,{{16, 117}, {177, 196, 0}} ,{{1, 117}, {162, 196, 0}} ,{{0, 117}, {161, 196, 0}} ,{{223, 116}, {128, 196, 0}} ,{{240, 116}, {145, 196, 0}} ,{{241, 116}, {146, 196, 0}} ,{{246, 116}, {151, 196, 0}} ,{{230, 116}, {135, 196, 0}} ,{{224, 116}, {129, 196, 0}} ,{{225, 116}, {130, 196, 0}} ,{{226, 116}, {131, 196, 0}} ,{{250, 116}, {155, 196, 0}} ,{{245, 116}, {150, 196, 0}} ,{{247, 116}, {152, 196, 0}} ,{{231, 116}, {136, 196, 0}} ,{{234, 116}, {139, 196, 0}} ,{{232, 116}, {137, 196, 0}} ,{{238, 116}, {143, 196, 0}} ,{{233, 116}, {138, 196, 0}} ,{{237, 116}, {142, 196, 0}} ,{{235, 116}, {140, 196, 0}} ,{{236, 116}, {141, 196, 0}} ,{{239, 116}, {144, 196, 0}} ,{{227, 116}, {132, 196, 0}} ,{{244, 116}, {149, 196, 0}} ,{{229, 116}, {134, 196, 0}} ,{{228, 116}, {133, 196, 0}} ,{{249, 116}, {154, 196, 0}} ,{{242, 116}, {147, 196, 0}} ,{{243, 116}, {148, 196, 0}} ,{{248, 116}, {153, 196, 0}} ,{{21, 117}, {182, 196, 0}} ,{{14, 117}, {175, 196, 0}} ,{{15, 117}, {176, 196, 0}} ,{{20, 117}, {181, 196, 0}} ,{{23, 117}, {184, 196, 0}} ,{{40, 117}, {201, 196, 0}} ,{{41, 117}, {202, 196, 0}} ,{{46, 117}, {207, 196, 0}} ,{{30, 117}, {191, 196, 0}} ,{{24, 117}, {185, 196, 0}} ,{{25, 117}, {186, 196, 0}} ,{{26, 117}, {187, 196, 0}} ,{{50, 117}, {211, 196, 0}} ,{{45, 117}, {206, 196, 0}} ,{{47, 117}, {208, 196, 0}} ,{{31, 117}, {192, 196, 0}} ,{{34, 117}, {195, 196, 0}} ,{{32, 117}, {193, 196, 0}} ,{{38, 117}, {199, 196, 0}} ,{{33, 117}, {194, 196, 0}} ,{{37, 117}, {198, 196, 0}} ,{{35, 117}, {196, 196, 0}} ,{{36, 117}, {197, 196, 0}} ,{{39, 117}, {200, 196, 0}} ,{{27, 117}, {188, 196, 0}} ,{{44, 117}, {205, 196, 0}} ,{{29, 117}, {190, 196, 0}} ,{{28, 117}, {189, 196, 0}} ,{{49, 117}, {210, 196, 0}} ,{{42, 117}, {203, 196, 0}} ,{{43, 117}, {204, 196, 0}} ,{{48, 117}, {209, 196, 0}} ,{{143, 115}, {48, 195, 0}} ,{{160, 115}, {65, 195, 0}} ,{{161, 115}, {66, 195, 0}} ,{{166, 115}, {71, 195, 0}} ,{{150, 115}, {55, 195, 0}} ,{{171, 115}, {76, 195, 0}} ,{{188, 115}, {93, 195, 0}} ,{{189, 115}, {94, 195, 0}} ,{{194, 115}, {99, 195, 0}} ,{{178, 115}, {83, 195, 0}} ,{{172, 115}, {77, 195, 0}} ,{{173, 115}, {78, 195, 0}} ,{{174, 115}, {79, 195, 0}} ,{{198, 115}, {103, 195, 0}} ,{{193, 115}, {98, 195, 0}} ,{{195, 115}, {100, 195, 0}} ,{{179, 115}, {84, 195, 0}} ,{{182, 115}, {87, 195, 0}} ,{{180, 115}, {85, 195, 0}} ,{{186, 115}, {91, 195, 0}} ,{{181, 115}, {86, 195, 0}} ,{{185, 115}, {90, 195, 0}} ,{{183, 115}, {88, 195, 0}} ,{{184, 115}, {89, 195, 0}} ,{{187, 115}, {92, 195, 0}} ,{{175, 115}, {80, 195, 0}} ,{{192, 115}, {97, 195, 0}} ,{{177, 115}, {82, 195, 0}} ,{{176, 115}, {81, 195, 0}} ,{{197, 115}, {102, 195, 0}} ,{{190, 115}, {95, 195, 0}} ,{{191, 115}, {96, 195, 0}} ,{{196, 115}, {101, 195, 0}} ,{{144, 115}, {49, 195, 0}} ,{{145, 115}, {50, 195, 0}} ,{{146, 115}, {51, 195, 0}} ,{{170, 115}, {75, 195, 0}} ,{{165, 115}, {70, 195, 0}} ,{{167, 115}, {72, 195, 0}} ,{{151, 115}, {56, 195, 0}} ,{{154, 115}, {59, 195, 0}} ,{{152, 115}, {57, 195, 0}} ,{{158, 115}, {63, 195, 0}} ,{{153, 115}, {58, 195, 0}} ,{{157, 115}, {62, 195, 0}} ,{{155, 115}, {60, 195, 0}} ,{{156, 115}, {61, 195, 0}} ,{{159, 115}, {64, 195, 0}} ,{{147, 115}, {52, 195, 0}} ,{{164, 115}, {69, 195, 0}} ,{{149, 115}, {54, 195, 0}} ,{{148, 115}, {53, 195, 0}} ,{{169, 115}, {74, 195, 0}} ,{{162, 115}, {67, 195, 0}} ,{{163, 115}, {68, 195, 0}} ,{{168, 115}, {73, 195, 0}} ,{{27, 116}, {188, 195, 0}} ,{{44, 116}, {205, 195, 0}} ,{{45, 116}, {206, 195, 0}} ,{{50, 116}, {211, 195, 0}} ,{{34, 116}, {195, 195, 0}} ,{{28, 116}, {189, 195, 0}} ,{{29, 116}, {190, 195, 0}} ,{{30, 116}, {191, 195, 0}} ,{{54, 116}, {215, 195, 0}} ,{{49, 116}, {210, 195, 0}} ,{{51, 116}, {212, 195, 0}} ,{{35, 116}, {196, 195, 0}} ,{{38, 116}, {199, 195, 0}} ,{{36, 116}, {197, 195, 0}} ,{{42, 116}, {203, 195, 0}} ,{{37, 116}, {198, 195, 0}} ,{{41, 116}, {202, 195, 0}} ,{{39, 116}, {200, 195, 0}} ,{{40, 116}, {201, 195, 0}} ,{{43, 116}, {204, 195, 0}} ,{{31, 116}, {192, 195, 0}} ,{{48, 116}, {209, 195, 0}} ,{{33, 116}, {194, 195, 0}} ,{{32, 116}, {193, 195, 0}} ,{{255, 115}, {160, 195, 0}} ,{{16, 116}, {177, 195, 0}} ,{{17, 116}, {178, 195, 0}} ,{{22, 116}, {183, 195, 0}} ,{{6, 116}, {167, 195, 0}} ,{{0, 116}, {161, 195, 0}} ,{{1, 116}, {162, 195, 0}} ,{{2, 116}, {163, 195, 0}} ,{{26, 116}, {187, 195, 0}} ,{{21, 116}, {182, 195, 0}} ,{{23, 116}, {184, 195, 0}} ,{{7, 116}, {168, 195, 0}} ,{{10, 116}, {171, 195, 0}} ,{{8, 116}, {169, 195, 0}} ,{{14, 116}, {175, 195, 0}} ,{{9, 116}, {170, 195, 0}} ,{{13, 116}, {174, 195, 0}} ,{{11, 116}, {172, 195, 0}} ,{{12, 116}, {173, 195, 0}} ,{{15, 116}, {176, 195, 0}} ,{{3, 116}, {164, 195, 0}} ,{{20, 116}, {181, 195, 0}} ,{{5, 116}, {166, 195, 0}} ,{{4, 116}, {165, 195, 0}} ,{{25, 116}, {186, 195, 0}} ,{{18, 116}, {179, 195, 0}} ,{{19, 116}, {180, 195, 0}} ,{{24, 116}, {185, 195, 0}} ,{{53, 116}, {214, 195, 0}} ,{{46, 116}, {207, 195, 0}} ,{{47, 116}, {208, 195, 0}} ,{{52, 116}, {213, 195, 0}} ,{{107, 117}, {12, 197, 0}} ,{{124, 117}, {29, 197, 0}} ,{{125, 117}, {30, 197, 0}} ,{{130, 117}, {35, 197, 0}} ,{{114, 117}, {19, 197, 0}} ,{{108, 117}, {13, 197, 0}} ,{{109, 117}, {14, 197, 0}} ,{{110, 117}, {15, 197, 0}} ,{{134, 117}, {39, 197, 0}} ,{{129, 117}, {34, 197, 0}} ,{{131, 117}, {36, 197, 0}} ,{{115, 117}, {20, 197, 0}} ,{{118, 117}, {23, 197, 0}} ,{{116, 117}, {21, 197, 0}} ,{{122, 117}, {27, 197, 0}} ,{{117, 117}, {22, 197, 0}} ,{{121, 117}, {26, 197, 0}} ,{{119, 117}, {24, 197, 0}} ,{{120, 117}, {25, 197, 0}} ,{{123, 117}, {28, 197, 0}} ,{{111, 117}, {16, 197, 0}} ,{{128, 117}, {33, 197, 0}} ,{{113, 117}, {18, 197, 0}} ,{{112, 117}, {17, 197, 0}} ,{{133, 117}, {38, 197, 0}} ,{{126, 117}, {31, 197, 0}} ,{{127, 117}, {32, 197, 0}} ,{{132, 117}, {37, 197, 0}} ,{{167, 116}, {72, 196, 0}} ,{{184, 116}, {89, 196, 0}} ,{{185, 116}, {90, 196, 0}} ,{{190, 116}, {95, 196, 0}} ,{{174, 116}, {79, 196, 0}} ,{{168, 116}, {73, 196, 0}} ,{{169, 116}, {74, 196, 0}} ,{{170, 116}, {75, 196, 0}} ,{{194, 116}, {99, 196, 0}} ,{{189, 116}, {94, 196, 0}} ,{{191, 116}, {96, 196, 0}} ,{{175, 116}, {80, 196, 0}} ,{{178, 116}, {83, 196, 0}} ,{{176, 116}, {81, 196, 0}} ,{{182, 116}, {87, 196, 0}} ,{{177, 116}, {82, 196, 0}} ,{{181, 116}, {86, 196, 0}} ,{{179, 116}, {84, 196, 0}} ,{{180, 116}, {85, 196, 0}} ,{{183, 116}, {88, 196, 0}} ,{{171, 116}, {76, 196, 0}} ,{{188, 116}, {93, 196, 0}} ,{{173, 116}, {78, 196, 0}} ,{{172, 116}, {77, 196, 0}} ,{{193, 116}, {98, 196, 0}} ,{{186, 116}, {91, 196, 0}} ,{{187, 116}, {92, 196, 0}} ,{{192, 116}, {97, 196, 0}} ,{{51, 117}, {212, 196, 0}} ,{{68, 117}, {229, 196, 0}} ,{{69, 117}, {230, 196, 0}} ,{{74, 117}, {235, 196, 0}} ,{{58, 117}, {219, 196, 0}} ,{{52, 117}, {213, 196, 0}} ,{{53, 117}, {214, 196, 0}} ,{{54, 117}, {215, 196, 0}} ,{{78, 117}, {239, 196, 0}} ,{{73, 117}, {234, 196, 0}} ,{{75, 117}, {236, 196, 0}} ,{{59, 117}, {220, 196, 0}} ,{{62, 117}, {223, 196, 0}} ,{{60, 117}, {221, 196, 0}} ,{{66, 117}, {227, 196, 0}} ,{{61, 117}, {222, 196, 0}} ,{{65, 117}, {226, 196, 0}} ,{{63, 117}, {224, 196, 0}} ,{{64, 117}, {225, 196, 0}} ,{{67, 117}, {228, 196, 0}} ,{{55, 117}, {216, 196, 0}} ,{{72, 117}, {233, 196, 0}} ,{{57, 117}, {218, 196, 0}} ,{{56, 117}, {217, 196, 0}} ,{{77, 117}, {238, 196, 0}} ,{{70, 117}, {231, 196, 0}} ,{{71, 117}, {232, 196, 0}} ,{{76, 117}, {237, 196, 0}} ,{{119, 114}, {24, 194, 0}} ,{{136, 114}, {41, 194, 0}} ,{{137, 114}, {42, 194, 0}} ,{{142, 114}, {47, 194, 0}} ,{{126, 114}, {31, 194, 0}} ,{{120, 114}, {25, 194, 0}} ,{{121, 114}, {26, 194, 0}} ,{{122, 114}, {27, 194, 0}} ,{{146, 114}, {51, 194, 0}} ,{{141, 114}, {46, 194, 0}} ,{{143, 114}, {48, 194, 0}} ,{{127, 114}, {32, 194, 0}} ,{{130, 114}, {35, 194, 0}} ,{{128, 114}, {33, 194, 0}} ,{{134, 114}, {39, 194, 0}} ,{{129, 114}, {34, 194, 0}} ,{{133, 114}, {38, 194, 0}} ,{{131, 114}, {36, 194, 0}} ,{{132, 114}, {37, 194, 0}} ,{{135, 114}, {40, 194, 0}} ,{{123, 114}, {28, 194, 0}} ,{{140, 114}, {45, 194, 0}} ,{{125, 114}, {30, 194, 0}} ,{{124, 114}, {29, 194, 0}} ,{{145, 114}, {50, 194, 0}} ,{{138, 114}, {43, 194, 0}} ,{{139, 114}, {44, 194, 0}} ,{{144, 114}, {49, 194, 0}} ,{{7, 114}, {168, 193, 0}} ,{{24, 114}, {185, 193, 0}} ,{{25, 114}, {186, 193, 0}} ,{{30, 114}, {191, 193, 0}} ,{{14, 114}, {175, 193, 0}} ,{{35, 114}, {196, 193, 0}} ,{{52, 114}, {213, 193, 0}} ,{{53, 114}, {214, 193, 0}} ,{{58, 114}, {219, 193, 0}} ,{{42, 114}, {203, 193, 0}} ,{{36, 114}, {197, 193, 0}} ,{{37, 114}, {198, 193, 0}} ,{{38, 114}, {199, 193, 0}} ,{{62, 114}, {223, 193, 0}} ,{{57, 114}, {218, 193, 0}} ,{{59, 114}, {220, 193, 0}} ,{{43, 114}, {204, 193, 0}} ,{{46, 114}, {207, 193, 0}} ,{{44, 114}, {205, 193, 0}} ,{{50, 114}, {211, 193, 0}} ,{{45, 114}, {206, 193, 0}} ,{{49, 114}, {210, 193, 0}} ,{{47, 114}, {208, 193, 0}} ,{{48, 114}, {209, 193, 0}} ,{{51, 114}, {212, 193, 0}} ,{{39, 114}, {200, 193, 0}} ,{{56, 114}, {217, 193, 0}} ,{{41, 114}, {202, 193, 0}} ,{{40, 114}, {201, 193, 0}} ,{{61, 114}, {222, 193, 0}} ,{{54, 114}, {215, 193, 0}} ,{{55, 114}, {216, 193, 0}} ,{{60, 114}, {221, 193, 0}} ,{{8, 114}, {169, 193, 0}} ,{{9, 114}, {170, 193, 0}} ,{{10, 114}, {171, 193, 0}} ,{{34, 114}, {195, 193, 0}} ,{{29, 114}, {190, 193, 0}} ,{{31, 114}, {192, 193, 0}} ,{{15, 114}, {176, 193, 0}} ,{{18, 114}, {179, 193, 0}} ,{{16, 114}, {177, 193, 0}} ,{{22, 114}, {183, 193, 0}} ,{{17, 114}, {178, 193, 0}} ,{{21, 114}, {182, 193, 0}} ,{{19, 114}, {180, 193, 0}} ,{{20, 114}, {181, 193, 0}} ,{{23, 114}, {184, 193, 0}} ,{{11, 114}, {172, 193, 0}} ,{{28, 114}, {189, 193, 0}} ,{{13, 114}, {174, 193, 0}} ,{{12, 114}, {173, 193, 0}} ,{{33, 114}, {194, 193, 0}} ,{{26, 114}, {187, 193, 0}} ,{{27, 114}, {188, 193, 0}} ,{{32, 114}, {193, 193, 0}} ,{{175, 114}, {80, 194, 0}} ,{{192, 114}, {97, 194, 0}} ,{{193, 114}, {98, 194, 0}} ,{{198, 114}, {103, 194, 0}} ,{{182, 114}, {87, 194, 0}} ,{{176, 114}, {81, 194, 0}} ,{{177, 114}, {82, 194, 0}} ,{{178, 114}, {83, 194, 0}} ,{{202, 114}, {107, 194, 0}} ,{{197, 114}, {102, 194, 0}} ,{{199, 114}, {104, 194, 0}} ,{{183, 114}, {88, 194, 0}} ,{{186, 114}, {91, 194, 0}} ,{{184, 114}, {89, 194, 0}} ,{{190, 114}, {95, 194, 0}} ,{{185, 114}, {90, 194, 0}} ,{{189, 114}, {94, 194, 0}} ,{{187, 114}, {92, 194, 0}} ,{{188, 114}, {93, 194, 0}} ,{{191, 114}, {96, 194, 0}} ,{{179, 114}, {84, 194, 0}} ,{{196, 114}, {101, 194, 0}} ,{{181, 114}, {86, 194, 0}} ,{{180, 114}, {85, 194, 0}} ,{{147, 114}, {52, 194, 0}} ,{{164, 114}, {69, 194, 0}} ,{{165, 114}, {70, 194, 0}} ,{{170, 114}, {75, 194, 0}} ,{{154, 114}, {59, 194, 0}} ,{{148, 114}, {53, 194, 0}} ,{{149, 114}, {54, 194, 0}} ,{{150, 114}, {55, 194, 0}} ,{{174, 114}, {79, 194, 0}} ,{{169, 114}, {74, 194, 0}} ,{{171, 114}, {76, 194, 0}} ,{{155, 114}, {60, 194, 0}} ,{{158, 114}, {63, 194, 0}} ,{{156, 114}, {61, 194, 0}} ,{{162, 114}, {67, 194, 0}} ,{{157, 114}, {62, 194, 0}} ,{{161, 114}, {66, 194, 0}} ,{{159, 114}, {64, 194, 0}} ,{{160, 114}, {65, 194, 0}} ,{{163, 114}, {68, 194, 0}} ,{{151, 114}, {56, 194, 0}} ,{{168, 114}, {73, 194, 0}} ,{{153, 114}, {58, 194, 0}} ,{{152, 114}, {57, 194, 0}} ,{{173, 114}, {78, 194, 0}} ,{{166, 114}, {71, 194, 0}} ,{{167, 114}, {72, 194, 0}} ,{{172, 114}, {77, 194, 0}} ,{{201, 114}, {106, 194, 0}} ,{{194, 114}, {99, 194, 0}} ,{{195, 114}, {100, 194, 0}} ,{{200, 114}, {105, 194, 0}} ,{{203, 114}, {108, 194, 0}} ,{{220, 114}, {125, 194, 0}} ,{{221, 114}, {126, 194, 0}} ,{{226, 114}, {131, 194, 0}} ,{{210, 114}, {115, 194, 0}} ,{{204, 114}, {109, 194, 0}} ,{{205, 114}, {110, 194, 0}} ,{{206, 114}, {111, 194, 0}} ,{{230, 114}, {135, 194, 0}} ,{{225, 114}, {130, 194, 0}} ,{{227, 114}, {132, 194, 0}} ,{{211, 114}, {116, 194, 0}} ,{{214, 114}, {119, 194, 0}} ,{{212, 114}, {117, 194, 0}} ,{{218, 114}, {123, 194, 0}} ,{{213, 114}, {118, 194, 0}} ,{{217, 114}, {122, 194, 0}} ,{{215, 114}, {120, 194, 0}} ,{{216, 114}, {121, 194, 0}} ,{{219, 114}, {124, 194, 0}} ,{{207, 114}, {112, 194, 0}} ,{{224, 114}, {129, 194, 0}} ,{{209, 114}, {114, 194, 0}} ,{{208, 114}, {113, 194, 0}} ,{{229, 114}, {134, 194, 0}} ,{{222, 114}, {127, 194, 0}} ,{{223, 114}, {128, 194, 0}} ,{{228, 114}, {133, 194, 0}} ,{{67, 113}, {228, 192, 0}} ,{{84, 113}, {245, 192, 0}} ,{{85, 113}, {246, 192, 0}} ,{{90, 113}, {251, 192, 0}} ,{{74, 113}, {235, 192, 0}} ,{{95, 113}, {0, 193, 0}} ,{{112, 113}, {17, 193, 0}} ,{{113, 113}, {18, 193, 0}} ,{{118, 113}, {23, 193, 0}} ,{{102, 113}, {7, 193, 0}} ,{{96, 113}, {1, 193, 0}} ,{{97, 113}, {2, 193, 0}} ,{{98, 113}, {3, 193, 0}} ,{{122, 113}, {27, 193, 0}} ,{{117, 113}, {22, 193, 0}} ,{{119, 113}, {24, 193, 0}} ,{{103, 113}, {8, 193, 0}} ,{{106, 113}, {11, 193, 0}} ,{{104, 113}, {9, 193, 0}} ,{{110, 113}, {15, 193, 0}} ,{{105, 113}, {10, 193, 0}} ,{{109, 113}, {14, 193, 0}} ,{{107, 113}, {12, 193, 0}} ,{{108, 113}, {13, 193, 0}} ,{{111, 113}, {16, 193, 0}} ,{{99, 113}, {4, 193, 0}} ,{{116, 113}, {21, 193, 0}} ,{{101, 113}, {6, 193, 0}} ,{{100, 113}, {5, 193, 0}} ,{{121, 113}, {26, 193, 0}} ,{{114, 113}, {19, 193, 0}} ,{{115, 113}, {20, 193, 0}} ,{{120, 113}, {25, 193, 0}} ,{{68, 113}, {229, 192, 0}} ,{{69, 113}, {230, 192, 0}} ,{{70, 113}, {231, 192, 0}} ,{{94, 113}, {255, 192, 0}} ,{{89, 113}, {250, 192, 0}} ,{{91, 113}, {252, 192, 0}} ,{{75, 113}, {236, 192, 0}} ,{{78, 113}, {239, 192, 0}} ,{{76, 113}, {237, 192, 0}} ,{{82, 113}, {243, 192, 0}} ,{{77, 113}, {238, 192, 0}} ,{{81, 113}, {242, 192, 0}} ,{{79, 113}, {240, 192, 0}} ,{{80, 113}, {241, 192, 0}} ,{{83, 113}, {244, 192, 0}} ,{{71, 113}, {232, 192, 0}} ,{{88, 113}, {249, 192, 0}} ,{{73, 113}, {234, 192, 0}} ,{{72, 113}, {233, 192, 0}} ,{{93, 113}, {254, 192, 0}} ,{{86, 113}, {247, 192, 0}} ,{{87, 113}, {248, 192, 0}} ,{{92, 113}, {253, 192, 0}} ,{{207, 113}, {112, 193, 0}} ,{{224, 113}, {129, 193, 0}} ,{{225, 113}, {130, 193, 0}} ,{{230, 113}, {135, 193, 0}} ,{{214, 113}, {119, 193, 0}} ,{{208, 113}, {113, 193, 0}} ,{{209, 113}, {114, 193, 0}} ,{{210, 113}, {115, 193, 0}} ,{{234, 113}, {139, 193, 0}} ,{{229, 113}, {134, 193, 0}} ,{{231, 113}, {136, 193, 0}} ,{{215, 113}, {120, 193, 0}} ,{{218, 113}, {123, 193, 0}} ,{{216, 113}, {121, 193, 0}} ,{{222, 113}, {127, 193, 0}} ,{{217, 113}, {122, 193, 0}} ,{{221, 113}, {126, 193, 0}} ,{{219, 113}, {124, 193, 0}} ,{{220, 113}, {125, 193, 0}} ,{{223, 113}, {128, 193, 0}} ,{{211, 113}, {116, 193, 0}} ,{{228, 113}, {133, 193, 0}} ,{{213, 113}, {118, 193, 0}} ,{{212, 113}, {117, 193, 0}} ,{{179, 113}, {84, 193, 0}} ,{{196, 113}, {101, 193, 0}} ,{{197, 113}, {102, 193, 0}} ,{{202, 113}, {107, 193, 0}} ,{{186, 113}, {91, 193, 0}} ,{{180, 113}, {85, 193, 0}} ,{{181, 113}, {86, 193, 0}} ,{{182, 113}, {87, 193, 0}} ,{{206, 113}, {111, 193, 0}} ,{{201, 113}, {106, 193, 0}} ,{{203, 113}, {108, 193, 0}} ,{{187, 113}, {92, 193, 0}} ,{{190, 113}, {95, 193, 0}} ,{{188, 113}, {93, 193, 0}} ,{{194, 113}, {99, 193, 0}} ,{{189, 113}, {94, 193, 0}} ,{{193, 113}, {98, 193, 0}} ,{{191, 113}, {96, 193, 0}} ,{{192, 113}, {97, 193, 0}} ,{{195, 113}, {100, 193, 0}} ,{{183, 113}, {88, 193, 0}} ,{{200, 113}, {105, 193, 0}} ,{{185, 113}, {90, 193, 0}} ,{{184, 113}, {89, 193, 0}} ,{{205, 113}, {110, 193, 0}} ,{{198, 113}, {103, 193, 0}} ,{{199, 113}, {104, 193, 0}} ,{{204, 113}, {109, 193, 0}} ,{{233, 113}, {138, 193, 0}} ,{{226, 113}, {131, 193, 0}} ,{{227, 113}, {132, 193, 0}} ,{{232, 113}, {137, 193, 0}} ,{{31, 115}, {192, 194, 0}} ,{{48, 115}, {209, 194, 0}} ,{{49, 115}, {210, 194, 0}} ,{{54, 115}, {215, 194, 0}} ,{{38, 115}, {199, 194, 0}} ,{{32, 115}, {193, 194, 0}} ,{{33, 115}, {194, 194, 0}} ,{{34, 115}, {195, 194, 0}} ,{{58, 115}, {219, 194, 0}} ,{{53, 115}, {214, 194, 0}} ,{{55, 115}, {216, 194, 0}} ,{{39, 115}, {200, 194, 0}} ,{{42, 115}, {203, 194, 0}} ,{{40, 115}, {201, 194, 0}} ,{{46, 115}, {207, 194, 0}} ,{{41, 115}, {202, 194, 0}} ,{{45, 115}, {206, 194, 0}} ,{{43, 115}, {204, 194, 0}} ,{{44, 115}, {205, 194, 0}} ,{{47, 115}, {208, 194, 0}} ,{{35, 115}, {196, 194, 0}} ,{{52, 115}, {213, 194, 0}} ,{{37, 115}, {198, 194, 0}} ,{{36, 115}, {197, 194, 0}} ,{{57, 115}, {218, 194, 0}} ,{{50, 115}, {211, 194, 0}} ,{{51, 115}, {212, 194, 0}} ,{{56, 115}, {217, 194, 0}} ,{{91, 114}, {252, 193, 0}} ,{{108, 114}, {13, 194, 0}} ,{{109, 114}, {14, 194, 0}} ,{{114, 114}, {19, 194, 0}} ,{{98, 114}, {3, 194, 0}} ,{{92, 114}, {253, 193, 0}} ,{{93, 114}, {254, 193, 0}} ,{{94, 114}, {255, 193, 0}} ,{{118, 114}, {23, 194, 0}} ,{{113, 114}, {18, 194, 0}} ,{{115, 114}, {20, 194, 0}} ,{{99, 114}, {4, 194, 0}} ,{{102, 114}, {7, 194, 0}} ,{{100, 114}, {5, 194, 0}} ,{{106, 114}, {11, 194, 0}} ,{{101, 114}, {6, 194, 0}} ,{{105, 114}, {10, 194, 0}} ,{{103, 114}, {8, 194, 0}} ,{{104, 114}, {9, 194, 0}} ,{{107, 114}, {12, 194, 0}} ,{{95, 114}, {0, 194, 0}} ,{{112, 114}, {17, 194, 0}} ,{{97, 114}, {2, 194, 0}} ,{{96, 114}, {1, 194, 0}} ,{{117, 114}, {22, 194, 0}} ,{{110, 114}, {15, 194, 0}} ,{{111, 114}, {16, 194, 0}} ,{{116, 114}, {21, 194, 0}} ,{{231, 114}, {136, 194, 0}} ,{{248, 114}, {153, 194, 0}} ,{{249, 114}, {154, 194, 0}} ,{{254, 114}, {159, 194, 0}} ,{{238, 114}, {143, 194, 0}} ,{{232, 114}, {137, 194, 0}} ,{{233, 114}, {138, 194, 0}} ,{{234, 114}, {139, 194, 0}} ,{{2, 115}, {163, 194, 0}} ,{{253, 114}, {158, 194, 0}} ,{{255, 114}, {160, 194, 0}} ,{{239, 114}, {144, 194, 0}} ,{{242, 114}, {147, 194, 0}} ,{{240, 114}, {145, 194, 0}} ,{{246, 114}, {151, 194, 0}} ,{{241, 114}, {146, 194, 0}} ,{{245, 114}, {150, 194, 0}} ,{{243, 114}, {148, 194, 0}} ,{{244, 114}, {149, 194, 0}} ,{{247, 114}, {152, 194, 0}} ,{{235, 114}, {140, 194, 0}} ,{{252, 114}, {157, 194, 0}} ,{{237, 114}, {142, 194, 0}} ,{{236, 114}, {141, 194, 0}} ,{{1, 115}, {162, 194, 0}} ,{{250, 114}, {155, 194, 0}} ,{{251, 114}, {156, 194, 0}} ,{{0, 115}, {161, 194, 0}} ,{{31, 129}, {192, 208, 0}} ,{{48, 129}, {209, 208, 0}} ,{{49, 129}, {210, 208, 0}} ,{{54, 129}, {215, 208, 0}} ,{{38, 129}, {199, 208, 0}} ,{{59, 129}, {220, 208, 0}} ,{{76, 129}, {237, 208, 0}} ,{{77, 129}, {238, 208, 0}} ,{{82, 129}, {243, 208, 0}} ,{{66, 129}, {227, 208, 0}} ,{{60, 129}, {221, 208, 0}} ,{{61, 129}, {222, 208, 0}} ,{{62, 129}, {223, 208, 0}} ,{{86, 129}, {247, 208, 0}} ,{{81, 129}, {242, 208, 0}} ,{{83, 129}, {244, 208, 0}} ,{{67, 129}, {228, 208, 0}} ,{{70, 129}, {231, 208, 0}} ,{{68, 129}, {229, 208, 0}} ,{{74, 129}, {235, 208, 0}} ,{{69, 129}, {230, 208, 0}} ,{{73, 129}, {234, 208, 0}} ,{{71, 129}, {232, 208, 0}} ,{{72, 129}, {233, 208, 0}} ,{{75, 129}, {236, 208, 0}} ,{{63, 129}, {224, 208, 0}} ,{{80, 129}, {241, 208, 0}} ,{{65, 129}, {226, 208, 0}} ,{{64, 129}, {225, 208, 0}} ,{{85, 129}, {246, 208, 0}} ,{{78, 129}, {239, 208, 0}} ,{{79, 129}, {240, 208, 0}} ,{{84, 129}, {245, 208, 0}} ,{{32, 129}, {193, 208, 0}} ,{{33, 129}, {194, 208, 0}} ,{{34, 129}, {195, 208, 0}} ,{{58, 129}, {219, 208, 0}} ,{{53, 129}, {214, 208, 0}} ,{{55, 129}, {216, 208, 0}} ,{{39, 129}, {200, 208, 0}} ,{{42, 129}, {203, 208, 0}} ,{{40, 129}, {201, 208, 0}} ,{{46, 129}, {207, 208, 0}} ,{{41, 129}, {202, 208, 0}} ,{{45, 129}, {206, 208, 0}} ,{{43, 129}, {204, 208, 0}} ,{{44, 129}, {205, 208, 0}} ,{{47, 129}, {208, 208, 0}} ,{{35, 129}, {196, 208, 0}} ,{{52, 129}, {213, 208, 0}} ,{{37, 129}, {198, 208, 0}} ,{{36, 129}, {197, 208, 0}} ,{{57, 129}, {218, 208, 0}} ,{{50, 129}, {211, 208, 0}} ,{{51, 129}, {212, 208, 0}} ,{{56, 129}, {217, 208, 0}} ,{{171, 129}, {76, 209, 0}} ,{{188, 129}, {93, 209, 0}} ,{{189, 129}, {94, 209, 0}} ,{{194, 129}, {99, 209, 0}} ,{{178, 129}, {83, 209, 0}} ,{{172, 129}, {77, 209, 0}} ,{{173, 129}, {78, 209, 0}} ,{{174, 129}, {79, 209, 0}} ,{{198, 129}, {103, 209, 0}} ,{{193, 129}, {98, 209, 0}} ,{{195, 129}, {100, 209, 0}} ,{{179, 129}, {84, 209, 0}} ,{{182, 129}, {87, 209, 0}} ,{{180, 129}, {85, 209, 0}} ,{{186, 129}, {91, 209, 0}} ,{{181, 129}, {86, 209, 0}} ,{{185, 129}, {90, 209, 0}} ,{{183, 129}, {88, 209, 0}} ,{{184, 129}, {89, 209, 0}} ,{{187, 129}, {92, 209, 0}} ,{{175, 129}, {80, 209, 0}} ,{{192, 129}, {97, 209, 0}} ,{{177, 129}, {82, 209, 0}} ,{{176, 129}, {81, 209, 0}} ,{{143, 129}, {48, 209, 0}} ,{{160, 129}, {65, 209, 0}} ,{{161, 129}, {66, 209, 0}} ,{{166, 129}, {71, 209, 0}} ,{{150, 129}, {55, 209, 0}} ,{{144, 129}, {49, 209, 0}} ,{{145, 129}, {50, 209, 0}} ,{{146, 129}, {51, 209, 0}} ,{{170, 129}, {75, 209, 0}} ,{{165, 129}, {70, 209, 0}} ,{{167, 129}, {72, 209, 0}} ,{{151, 129}, {56, 209, 0}} ,{{154, 129}, {59, 209, 0}} ,{{152, 129}, {57, 209, 0}} ,{{158, 129}, {63, 209, 0}} ,{{153, 129}, {58, 209, 0}} ,{{157, 129}, {62, 209, 0}} ,{{155, 129}, {60, 209, 0}} ,{{156, 129}, {61, 209, 0}} ,{{159, 129}, {64, 209, 0}} ,{{147, 129}, {52, 209, 0}} ,{{164, 129}, {69, 209, 0}} ,{{149, 129}, {54, 209, 0}} ,{{148, 129}, {53, 209, 0}} ,{{169, 129}, {74, 209, 0}} ,{{162, 129}, {67, 209, 0}} ,{{163, 129}, {68, 209, 0}} ,{{168, 129}, {73, 209, 0}} ,{{197, 129}, {102, 209, 0}} ,{{190, 129}, {95, 209, 0}} ,{{191, 129}, {96, 209, 0}} ,{{196, 129}, {101, 209, 0}} ,{{23, 131}, {184, 210, 0}} ,{{40, 131}, {201, 210, 0}} ,{{41, 131}, {202, 210, 0}} ,{{46, 131}, {207, 210, 0}} ,{{30, 131}, {191, 210, 0}} ,{{24, 131}, {185, 210, 0}} ,{{25, 131}, {186, 210, 0}} ,{{26, 131}, {187, 210, 0}} ,{{50, 131}, {211, 210, 0}} ,{{45, 131}, {206, 210, 0}} ,{{47, 131}, {208, 210, 0}} ,{{31, 131}, {192, 210, 0}} ,{{34, 131}, {195, 210, 0}} ,{{32, 131}, {193, 210, 0}} ,{{38, 131}, {199, 210, 0}} ,{{33, 131}, {194, 210, 0}} ,{{37, 131}, {198, 210, 0}} ,{{35, 131}, {196, 210, 0}} ,{{36, 131}, {197, 210, 0}} ,{{39, 131}, {200, 210, 0}} ,{{27, 131}, {188, 210, 0}} ,{{44, 131}, {205, 210, 0}} ,{{29, 131}, {190, 210, 0}} ,{{28, 131}, {189, 210, 0}} ,{{49, 131}, {210, 210, 0}} ,{{42, 131}, {203, 210, 0}} ,{{43, 131}, {204, 210, 0}} ,{{48, 131}, {209, 210, 0}} ,{{79, 131}, {240, 210, 0}} ,{{96, 131}, {1, 211, 0}} ,{{97, 131}, {2, 211, 0}} ,{{102, 131}, {7, 211, 0}} ,{{86, 131}, {247, 210, 0}} ,{{80, 131}, {241, 210, 0}} ,{{81, 131}, {242, 210, 0}} ,{{82, 131}, {243, 210, 0}} ,{{106, 131}, {11, 211, 0}} ,{{101, 131}, {6, 211, 0}} ,{{103, 131}, {8, 211, 0}} ,{{87, 131}, {248, 210, 0}} ,{{90, 131}, {251, 210, 0}} ,{{88, 131}, {249, 210, 0}} ,{{94, 131}, {255, 210, 0}} ,{{89, 131}, {250, 210, 0}} ,{{93, 131}, {254, 210, 0}} ,{{91, 131}, {252, 210, 0}} ,{{92, 131}, {253, 210, 0}} ,{{95, 131}, {0, 211, 0}} ,{{83, 131}, {244, 210, 0}} ,{{100, 131}, {5, 211, 0}} ,{{85, 131}, {246, 210, 0}} ,{{84, 131}, {245, 210, 0}} ,{{105, 131}, {10, 211, 0}} ,{{98, 131}, {3, 211, 0}} ,{{99, 131}, {4, 211, 0}} ,{{104, 131}, {9, 211, 0}} ,{{255, 129}, {160, 209, 0}} ,{{16, 130}, {177, 209, 0}} ,{{17, 130}, {178, 209, 0}} ,{{22, 130}, {183, 209, 0}} ,{{6, 130}, {167, 209, 0}} ,{{83, 130}, {244, 209, 0}} ,{{100, 130}, {5, 210, 0}} ,{{101, 130}, {6, 210, 0}} ,{{106, 130}, {11, 210, 0}} ,{{90, 130}, {251, 209, 0}} ,{{84, 130}, {245, 209, 0}} ,{{85, 130}, {246, 209, 0}} ,{{86, 130}, {247, 209, 0}} ,{{110, 130}, {15, 210, 0}} ,{{105, 130}, {10, 210, 0}} ,{{107, 130}, {12, 210, 0}} ,{{91, 130}, {252, 209, 0}} ,{{94, 130}, {255, 209, 0}} ,{{92, 130}, {253, 209, 0}} ,{{98, 130}, {3, 210, 0}} ,{{93, 130}, {254, 209, 0}} ,{{97, 130}, {2, 210, 0}} ,{{95, 130}, {0, 210, 0}} ,{{96, 130}, {1, 210, 0}} ,{{99, 130}, {4, 210, 0}} ,{{87, 130}, {248, 209, 0}} ,{{104, 130}, {9, 210, 0}} ,{{89, 130}, {250, 209, 0}} ,{{88, 130}, {249, 209, 0}} ,{{109, 130}, {14, 210, 0}} ,{{102, 130}, {7, 210, 0}} ,{{103, 130}, {8, 210, 0}} ,{{108, 130}, {13, 210, 0}} ,{{0, 130}, {161, 209, 0}} ,{{1, 130}, {162, 209, 0}} ,{{2, 130}, {163, 209, 0}} ,{{26, 130}, {187, 209, 0}} ,{{21, 130}, {182, 209, 0}} ,{{23, 130}, {184, 209, 0}} ,{{7, 130}, {168, 209, 0}} ,{{10, 130}, {171, 209, 0}} ,{{8, 130}, {169, 209, 0}} ,{{14, 130}, {175, 209, 0}} ,{{9, 130}, {170, 209, 0}} ,{{13, 130}, {174, 209, 0}} ,{{11, 130}, {172, 209, 0}} ,{{12, 130}, {173, 209, 0}} ,{{15, 130}, {176, 209, 0}} ,{{3, 130}, {164, 209, 0}} ,{{20, 130}, {181, 209, 0}} ,{{5, 130}, {166, 209, 0}} ,{{4, 130}, {165, 209, 0}} ,{{25, 130}, {186, 209, 0}} ,{{18, 130}, {179, 209, 0}} ,{{19, 130}, {180, 209, 0}} ,{{24, 130}, {185, 209, 0}} ,{{139, 130}, {44, 210, 0}} ,{{156, 130}, {61, 210, 0}} ,{{157, 130}, {62, 210, 0}} ,{{162, 130}, {67, 210, 0}} ,{{146, 130}, {51, 210, 0}} ,{{140, 130}, {45, 210, 0}} ,{{141, 130}, {46, 210, 0}} ,{{142, 130}, {47, 210, 0}} ,{{166, 130}, {71, 210, 0}} ,{{161, 130}, {66, 210, 0}} ,{{163, 130}, {68, 210, 0}} ,{{147, 130}, {52, 210, 0}} ,{{150, 130}, {55, 210, 0}} ,{{148, 130}, {53, 210, 0}} ,{{154, 130}, {59, 210, 0}} ,{{149, 130}, {54, 210, 0}} ,{{153, 130}, {58, 210, 0}} ,{{151, 130}, {56, 210, 0}} ,{{152, 130}, {57, 210, 0}} ,{{155, 130}, {60, 210, 0}} ,{{143, 130}, {48, 210, 0}} ,{{160, 130}, {65, 210, 0}} ,{{145, 130}, {50, 210, 0}} ,{{144, 130}, {49, 210, 0}} ,{{165, 130}, {70, 210, 0}} ,{{158, 130}, {63, 210, 0}} ,{{159, 130}, {64, 210, 0}} ,{{164, 130}, {69, 210, 0}} ,{{27, 130}, {188, 209, 0}} ,{{44, 130}, {205, 209, 0}} ,{{45, 130}, {206, 209, 0}} ,{{50, 130}, {211, 209, 0}} ,{{34, 130}, {195, 209, 0}} ,{{55, 130}, {216, 209, 0}} ,{{72, 130}, {233, 209, 0}} ,{{73, 130}, {234, 209, 0}} ,{{78, 130}, {239, 209, 0}} ,{{62, 130}, {223, 209, 0}} ,{{56, 130}, {217, 209, 0}} ,{{57, 130}, {218, 209, 0}} ,{{58, 130}, {219, 209, 0}} ,{{82, 130}, {243, 209, 0}} ,{{77, 130}, {238, 209, 0}} ,{{79, 130}, {240, 209, 0}} ,{{63, 130}, {224, 209, 0}} ,{{66, 130}, {227, 209, 0}} ,{{64, 130}, {225, 209, 0}} ,{{70, 130}, {231, 209, 0}} ,{{65, 130}, {226, 209, 0}} ,{{69, 130}, {230, 209, 0}} ,{{67, 130}, {228, 209, 0}} ,{{68, 130}, {229, 209, 0}} ,{{71, 130}, {232, 209, 0}} ,{{59, 130}, {220, 209, 0}} ,{{76, 130}, {237, 209, 0}} ,{{61, 130}, {222, 209, 0}} ,{{60, 130}, {221, 209, 0}} ,{{81, 130}, {242, 209, 0}} ,{{74, 130}, {235, 209, 0}} ,{{75, 130}, {236, 209, 0}} ,{{80, 130}, {241, 209, 0}} ,{{28, 130}, {189, 209, 0}} ,{{29, 130}, {190, 209, 0}} ,{{30, 130}, {191, 209, 0}} ,{{54, 130}, {215, 209, 0}} ,{{49, 130}, {210, 209, 0}} ,{{51, 130}, {212, 209, 0}} ,{{35, 130}, {196, 209, 0}} ,{{38, 130}, {199, 209, 0}} ,{{36, 130}, {197, 209, 0}} ,{{42, 130}, {203, 209, 0}} ,{{37, 130}, {198, 209, 0}} ,{{41, 130}, {202, 209, 0}} ,{{39, 130}, {200, 209, 0}} ,{{40, 130}, {201, 209, 0}} ,{{43, 130}, {204, 209, 0}} ,{{31, 130}, {192, 209, 0}} ,{{48, 130}, {209, 209, 0}} ,{{33, 130}, {194, 209, 0}} ,{{32, 130}, {193, 209, 0}} ,{{53, 130}, {214, 209, 0}} ,{{46, 130}, {207, 209, 0}} ,{{47, 130}, {208, 209, 0}} ,{{52, 130}, {213, 209, 0}} ,{{195, 130}, {100, 210, 0}} ,{{212, 130}, {117, 210, 0}} ,{{213, 130}, {118, 210, 0}} ,{{218, 130}, {123, 210, 0}} ,{{202, 130}, {107, 210, 0}} ,{{196, 130}, {101, 210, 0}} ,{{197, 130}, {102, 210, 0}} ,{{198, 130}, {103, 210, 0}} ,{{222, 130}, {127, 210, 0}} ,{{217, 130}, {122, 210, 0}} ,{{219, 130}, {124, 210, 0}} ,{{203, 130}, {108, 210, 0}} ,{{206, 130}, {111, 210, 0}} ,{{204, 130}, {109, 210, 0}} ,{{210, 130}, {115, 210, 0}} ,{{205, 130}, {110, 210, 0}} ,{{209, 130}, {114, 210, 0}} ,{{207, 130}, {112, 210, 0}} ,{{208, 130}, {113, 210, 0}} ,{{211, 130}, {116, 210, 0}} ,{{199, 130}, {104, 210, 0}} ,{{216, 130}, {121, 210, 0}} ,{{201, 130}, {106, 210, 0}} ,{{200, 130}, {105, 210, 0}} ,{{167, 130}, {72, 210, 0}} ,{{184, 130}, {89, 210, 0}} ,{{185, 130}, {90, 210, 0}} ,{{190, 130}, {95, 210, 0}} ,{{174, 130}, {79, 210, 0}} ,{{168, 130}, {73, 210, 0}} ,{{169, 130}, {74, 210, 0}} ,{{170, 130}, {75, 210, 0}} ,{{194, 130}, {99, 210, 0}} ,{{189, 130}, {94, 210, 0}} ,{{191, 130}, {96, 210, 0}} ,{{175, 130}, {80, 210, 0}} ,{{178, 130}, {83, 210, 0}} ,{{176, 130}, {81, 210, 0}} ,{{182, 130}, {87, 210, 0}} ,{{177, 130}, {82, 210, 0}} ,{{181, 130}, {86, 210, 0}} ,{{179, 130}, {84, 210, 0}} ,{{180, 130}, {85, 210, 0}} ,{{183, 130}, {88, 210, 0}} ,{{171, 130}, {76, 210, 0}} ,{{188, 130}, {93, 210, 0}} ,{{173, 130}, {78, 210, 0}} ,{{172, 130}, {77, 210, 0}} ,{{193, 130}, {98, 210, 0}} ,{{186, 130}, {91, 210, 0}} ,{{187, 130}, {92, 210, 0}} ,{{192, 130}, {97, 210, 0}} ,{{221, 130}, {126, 210, 0}} ,{{214, 130}, {119, 210, 0}} ,{{215, 130}, {120, 210, 0}} ,{{220, 130}, {125, 210, 0}} ,{{223, 130}, {128, 210, 0}} ,{{240, 130}, {145, 210, 0}} ,{{241, 130}, {146, 210, 0}} ,{{246, 130}, {151, 210, 0}} ,{{230, 130}, {135, 210, 0}} ,{{224, 130}, {129, 210, 0}} ,{{225, 130}, {130, 210, 0}} ,{{226, 130}, {131, 210, 0}} ,{{250, 130}, {155, 210, 0}} ,{{245, 130}, {150, 210, 0}} ,{{247, 130}, {152, 210, 0}} ,{{231, 130}, {136, 210, 0}} ,{{234, 130}, {139, 210, 0}} ,{{232, 130}, {137, 210, 0}} ,{{238, 130}, {143, 210, 0}} ,{{233, 130}, {138, 210, 0}} ,{{237, 130}, {142, 210, 0}} ,{{235, 130}, {140, 210, 0}} ,{{236, 130}, {141, 210, 0}} ,{{239, 130}, {144, 210, 0}} ,{{227, 130}, {132, 210, 0}} ,{{244, 130}, {149, 210, 0}} ,{{229, 130}, {134, 210, 0}} ,{{228, 130}, {133, 210, 0}} ,{{249, 130}, {154, 210, 0}} ,{{242, 130}, {147, 210, 0}} ,{{243, 130}, {148, 210, 0}} ,{{248, 130}, {153, 210, 0}} ,{{87, 129}, {248, 208, 0}} ,{{104, 129}, {9, 209, 0}} ,{{105, 129}, {10, 209, 0}} ,{{110, 129}, {15, 209, 0}} ,{{94, 129}, {255, 208, 0}} ,{{115, 129}, {20, 209, 0}} ,{{132, 129}, {37, 209, 0}} ,{{133, 129}, {38, 209, 0}} ,{{138, 129}, {43, 209, 0}} ,{{122, 129}, {27, 209, 0}} ,{{116, 129}, {21, 209, 0}} ,{{117, 129}, {22, 209, 0}} ,{{118, 129}, {23, 209, 0}} ,{{142, 129}, {47, 209, 0}} ,{{137, 129}, {42, 209, 0}} ,{{139, 129}, {44, 209, 0}} ,{{123, 129}, {28, 209, 0}} ,{{126, 129}, {31, 209, 0}} ,{{124, 129}, {29, 209, 0}} ,{{130, 129}, {35, 209, 0}} ,{{125, 129}, {30, 209, 0}} ,{{129, 129}, {34, 209, 0}} ,{{127, 129}, {32, 209, 0}} ,{{128, 129}, {33, 209, 0}} ,{{131, 129}, {36, 209, 0}} ,{{119, 129}, {24, 209, 0}} ,{{136, 129}, {41, 209, 0}} ,{{121, 129}, {26, 209, 0}} ,{{120, 129}, {25, 209, 0}} ,{{141, 129}, {46, 209, 0}} ,{{134, 129}, {39, 209, 0}} ,{{135, 129}, {40, 209, 0}} ,{{140, 129}, {45, 209, 0}} ,{{88, 129}, {249, 208, 0}} ,{{89, 129}, {250, 208, 0}} ,{{90, 129}, {251, 208, 0}} ,{{114, 129}, {19, 209, 0}} ,{{109, 129}, {14, 209, 0}} ,{{111, 129}, {16, 209, 0}} ,{{95, 129}, {0, 209, 0}} ,{{98, 129}, {3, 209, 0}} ,{{96, 129}, {1, 209, 0}} ,{{102, 129}, {7, 209, 0}} ,{{97, 129}, {2, 209, 0}} ,{{101, 129}, {6, 209, 0}} ,{{99, 129}, {4, 209, 0}} ,{{100, 129}, {5, 209, 0}} ,{{103, 129}, {8, 209, 0}} ,{{91, 129}, {252, 208, 0}} ,{{108, 129}, {13, 209, 0}} ,{{93, 129}, {254, 208, 0}} ,{{92, 129}, {253, 208, 0}} ,{{113, 129}, {18, 209, 0}} ,{{106, 129}, {11, 209, 0}} ,{{107, 129}, {12, 209, 0}} ,{{112, 129}, {17, 209, 0}} ,{{227, 129}, {132, 209, 0}} ,{{244, 129}, {149, 209, 0}} ,{{245, 129}, {150, 209, 0}} ,{{250, 129}, {155, 209, 0}} ,{{234, 129}, {139, 209, 0}} ,{{228, 129}, {133, 209, 0}} ,{{229, 129}, {134, 209, 0}} ,{{230, 129}, {135, 209, 0}} ,{{254, 129}, {159, 209, 0}} ,{{249, 129}, {154, 209, 0}} ,{{251, 129}, {156, 209, 0}} ,{{235, 129}, {140, 209, 0}} ,{{238, 129}, {143, 209, 0}} ,{{236, 129}, {141, 209, 0}} ,{{242, 129}, {147, 209, 0}} ,{{237, 129}, {142, 209, 0}} ,{{241, 129}, {146, 209, 0}} ,{{239, 129}, {144, 209, 0}} ,{{240, 129}, {145, 209, 0}} ,{{243, 129}, {148, 209, 0}} ,{{231, 129}, {136, 209, 0}} ,{{248, 129}, {153, 209, 0}} ,{{233, 129}, {138, 209, 0}} ,{{232, 129}, {137, 209, 0}} ,{{199, 129}, {104, 209, 0}} ,{{216, 129}, {121, 209, 0}} ,{{217, 129}, {122, 209, 0}} ,{{222, 129}, {127, 209, 0}} ,{{206, 129}, {111, 209, 0}} ,{{200, 129}, {105, 209, 0}} ,{{201, 129}, {106, 209, 0}} ,{{202, 129}, {107, 209, 0}} ,{{226, 129}, {131, 209, 0}} ,{{221, 129}, {126, 209, 0}} ,{{223, 129}, {128, 209, 0}} ,{{207, 129}, {112, 209, 0}} ,{{210, 129}, {115, 209, 0}} ,{{208, 129}, {113, 209, 0}} ,{{214, 129}, {119, 209, 0}} ,{{209, 129}, {114, 209, 0}} ,{{213, 129}, {118, 209, 0}} ,{{211, 129}, {116, 209, 0}} ,{{212, 129}, {117, 209, 0}} ,{{215, 129}, {120, 209, 0}} ,{{203, 129}, {108, 209, 0}} ,{{220, 129}, {125, 209, 0}} ,{{205, 129}, {110, 209, 0}} ,{{204, 129}, {109, 209, 0}} ,{{225, 129}, {130, 209, 0}} ,{{218, 129}, {123, 209, 0}} ,{{219, 129}, {124, 209, 0}} ,{{224, 129}, {129, 209, 0}} ,{{253, 129}, {158, 209, 0}} ,{{246, 129}, {151, 209, 0}} ,{{247, 129}, {152, 209, 0}} ,{{252, 129}, {157, 209, 0}} ,{{51, 131}, {212, 210, 0}} ,{{68, 131}, {229, 210, 0}} ,{{69, 131}, {230, 210, 0}} ,{{74, 131}, {235, 210, 0}} ,{{58, 131}, {219, 210, 0}} ,{{52, 131}, {213, 210, 0}} ,{{53, 131}, {214, 210, 0}} ,{{54, 131}, {215, 210, 0}} ,{{78, 131}, {239, 210, 0}} ,{{73, 131}, {234, 210, 0}} ,{{75, 131}, {236, 210, 0}} ,{{59, 131}, {220, 210, 0}} ,{{62, 131}, {223, 210, 0}} ,{{60, 131}, {221, 210, 0}} ,{{66, 131}, {227, 210, 0}} ,{{61, 131}, {222, 210, 0}} ,{{65, 131}, {226, 210, 0}} ,{{63, 131}, {224, 210, 0}} ,{{64, 131}, {225, 210, 0}} ,{{67, 131}, {228, 210, 0}} ,{{55, 131}, {216, 210, 0}} ,{{72, 131}, {233, 210, 0}} ,{{57, 131}, {218, 210, 0}} ,{{56, 131}, {217, 210, 0}} ,{{77, 131}, {238, 210, 0}} ,{{70, 131}, {231, 210, 0}} ,{{71, 131}, {232, 210, 0}} ,{{76, 131}, {237, 210, 0}} ,{{111, 130}, {16, 210, 0}} ,{{128, 130}, {33, 210, 0}} ,{{129, 130}, {34, 210, 0}} ,{{134, 130}, {39, 210, 0}} ,{{118, 130}, {23, 210, 0}} ,{{112, 130}, {17, 210, 0}} ,{{113, 130}, {18, 210, 0}} ,{{114, 130}, {19, 210, 0}} ,{{138, 130}, {43, 210, 0}} ,{{133, 130}, {38, 210, 0}} ,{{135, 130}, {40, 210, 0}} ,{{119, 130}, {24, 210, 0}} ,{{122, 130}, {27, 210, 0}} ,{{120, 130}, {25, 210, 0}} ,{{126, 130}, {31, 210, 0}} ,{{121, 130}, {26, 210, 0}} ,{{125, 130}, {30, 210, 0}} ,{{123, 130}, {28, 210, 0}} ,{{124, 130}, {29, 210, 0}} ,{{127, 130}, {32, 210, 0}} ,{{115, 130}, {20, 210, 0}} ,{{132, 130}, {37, 210, 0}} ,{{117, 130}, {22, 210, 0}} ,{{116, 130}, {21, 210, 0}} ,{{137, 130}, {42, 210, 0}} ,{{130, 130}, {35, 210, 0}} ,{{131, 130}, {36, 210, 0}} ,{{136, 130}, {41, 210, 0}} ,{{251, 130}, {156, 210, 0}} ,{{12, 131}, {173, 210, 0}} ,{{13, 131}, {174, 210, 0}} ,{{18, 131}, {179, 210, 0}} ,{{2, 131}, {163, 210, 0}} ,{{252, 130}, {157, 210, 0}} ,{{253, 130}, {158, 210, 0}} ,{{254, 130}, {159, 210, 0}} ,{{22, 131}, {183, 210, 0}} ,{{17, 131}, {178, 210, 0}} ,{{19, 131}, {180, 210, 0}} ,{{3, 131}, {164, 210, 0}} ,{{6, 131}, {167, 210, 0}} ,{{4, 131}, {165, 210, 0}} ,{{10, 131}, {171, 210, 0}} ,{{5, 131}, {166, 210, 0}} ,{{9, 131}, {170, 210, 0}} ,{{7, 131}, {168, 210, 0}} ,{{8, 131}, {169, 210, 0}} ,{{11, 131}, {172, 210, 0}} ,{{255, 130}, {160, 210, 0}} ,{{16, 131}, {177, 210, 0}} ,{{1, 131}, {162, 210, 0}} ,{{0, 131}, {161, 210, 0}} ,{{21, 131}, {182, 210, 0}} ,{{14, 131}, {175, 210, 0}} ,{{15, 131}, {176, 210, 0}} ,{{20, 131}, {181, 210, 0}} ,{{15, 119}, {176, 198, 0}} ,{{32, 119}, {193, 198, 0}} ,{{33, 119}, {194, 198, 0}} ,{{38, 119}, {199, 198, 0}} ,{{22, 119}, {183, 198, 0}} ,{{16, 119}, {177, 198, 0}} ,{{17, 119}, {178, 198, 0}} ,{{18, 119}, {179, 198, 0}} ,{{42, 119}, {203, 198, 0}} ,{{37, 119}, {198, 198, 0}} ,{{39, 119}, {200, 198, 0}} ,{{23, 119}, {184, 198, 0}} ,{{26, 119}, {187, 198, 0}} ,{{24, 119}, {185, 198, 0}} ,{{30, 119}, {191, 198, 0}} ,{{25, 119}, {186, 198, 0}} ,{{29, 119}, {190, 198, 0}} ,{{27, 119}, {188, 198, 0}} ,{{28, 119}, {189, 198, 0}} ,{{31, 119}, {192, 198, 0}} ,{{19, 119}, {180, 198, 0}} ,{{36, 119}, {197, 198, 0}} ,{{21, 119}, {182, 198, 0}} ,{{20, 119}, {181, 198, 0}} ,{{41, 119}, {202, 198, 0}} ,{{34, 119}, {195, 198, 0}} ,{{35, 119}, {196, 198, 0}} ,{{40, 119}, {201, 198, 0}} ,{{159, 118}, {64, 198, 0}} ,{{176, 118}, {81, 198, 0}} ,{{177, 118}, {82, 198, 0}} ,{{182, 118}, {87, 198, 0}} ,{{166, 118}, {71, 198, 0}} ,{{187, 118}, {92, 198, 0}} ,{{204, 118}, {109, 198, 0}} ,{{205, 118}, {110, 198, 0}} ,{{210, 118}, {115, 198, 0}} ,{{194, 118}, {99, 198, 0}} ,{{188, 118}, {93, 198, 0}} ,{{189, 118}, {94, 198, 0}} ,{{190, 118}, {95, 198, 0}} ,{{214, 118}, {119, 198, 0}} ,{{209, 118}, {114, 198, 0}} ,{{211, 118}, {116, 198, 0}} ,{{195, 118}, {100, 198, 0}} ,{{198, 118}, {103, 198, 0}} ,{{196, 118}, {101, 198, 0}} ,{{202, 118}, {107, 198, 0}} ,{{197, 118}, {102, 198, 0}} ,{{201, 118}, {106, 198, 0}} ,{{199, 118}, {104, 198, 0}} ,{{200, 118}, {105, 198, 0}} ,{{203, 118}, {108, 198, 0}} ,{{191, 118}, {96, 198, 0}} ,{{208, 118}, {113, 198, 0}} ,{{193, 118}, {98, 198, 0}} ,{{192, 118}, {97, 198, 0}} ,{{213, 118}, {118, 198, 0}} ,{{206, 118}, {111, 198, 0}} ,{{207, 118}, {112, 198, 0}} ,{{212, 118}, {117, 198, 0}} ,{{160, 118}, {65, 198, 0}} ,{{161, 118}, {66, 198, 0}} ,{{162, 118}, {67, 198, 0}} ,{{186, 118}, {91, 198, 0}} ,{{181, 118}, {86, 198, 0}} ,{{183, 118}, {88, 198, 0}} ,{{167, 118}, {72, 198, 0}} ,{{170, 118}, {75, 198, 0}} ,{{168, 118}, {73, 198, 0}} ,{{174, 118}, {79, 198, 0}} ,{{169, 118}, {74, 198, 0}} ,{{173, 118}, {78, 198, 0}} ,{{171, 118}, {76, 198, 0}} ,{{172, 118}, {77, 198, 0}} ,{{175, 118}, {80, 198, 0}} ,{{163, 118}, {68, 198, 0}} ,{{180, 118}, {85, 198, 0}} ,{{165, 118}, {70, 198, 0}} ,{{164, 118}, {69, 198, 0}} ,{{185, 118}, {90, 198, 0}} ,{{178, 118}, {83, 198, 0}} ,{{179, 118}, {84, 198, 0}} ,{{184, 118}, {89, 198, 0}} ,{{71, 119}, {232, 198, 0}} ,{{88, 119}, {249, 198, 0}} ,{{89, 119}, {250, 198, 0}} ,{{94, 119}, {255, 198, 0}} ,{{78, 119}, {239, 198, 0}} ,{{72, 119}, {233, 198, 0}} ,{{73, 119}, {234, 198, 0}} ,{{74, 119}, {235, 198, 0}} ,{{98, 119}, {3, 199, 0}} ,{{93, 119}, {254, 198, 0}} ,{{95, 119}, {0, 199, 0}} ,{{79, 119}, {240, 198, 0}} ,{{82, 119}, {243, 198, 0}} ,{{80, 119}, {241, 198, 0}} ,{{86, 119}, {247, 198, 0}} ,{{81, 119}, {242, 198, 0}} ,{{85, 119}, {246, 198, 0}} ,{{83, 119}, {244, 198, 0}} ,{{84, 119}, {245, 198, 0}} ,{{87, 119}, {248, 198, 0}} ,{{75, 119}, {236, 198, 0}} ,{{92, 119}, {253, 198, 0}} ,{{77, 119}, {238, 198, 0}} ,{{76, 119}, {237, 198, 0}} ,{{43, 119}, {204, 198, 0}} ,{{60, 119}, {221, 198, 0}} ,{{61, 119}, {222, 198, 0}} ,{{66, 119}, {227, 198, 0}} ,{{50, 119}, {211, 198, 0}} ,{{44, 119}, {205, 198, 0}} ,{{45, 119}, {206, 198, 0}} ,{{46, 119}, {207, 198, 0}} ,{{70, 119}, {231, 198, 0}} ,{{65, 119}, {226, 198, 0}} ,{{67, 119}, {228, 198, 0}} ,{{51, 119}, {212, 198, 0}} ,{{54, 119}, {215, 198, 0}} ,{{52, 119}, {213, 198, 0}} ,{{58, 119}, {219, 198, 0}} ,{{53, 119}, {214, 198, 0}} ,{{57, 119}, {218, 198, 0}} ,{{55, 119}, {216, 198, 0}} ,{{56, 119}, {217, 198, 0}} ,{{59, 119}, {220, 198, 0}} ,{{47, 119}, {208, 198, 0}} ,{{64, 119}, {225, 198, 0}} ,{{49, 119}, {210, 198, 0}} ,{{48, 119}, {209, 198, 0}} ,{{69, 119}, {230, 198, 0}} ,{{62, 119}, {223, 198, 0}} ,{{63, 119}, {224, 198, 0}} ,{{68, 119}, {229, 198, 0}} ,{{97, 119}, {2, 199, 0}} ,{{90, 119}, {251, 198, 0}} ,{{91, 119}, {252, 198, 0}} ,{{96, 119}, {1, 199, 0}} ,{{99, 119}, {4, 199, 0}} ,{{116, 119}, {21, 199, 0}} ,{{117, 119}, {22, 199, 0}} ,{{122, 119}, {27, 199, 0}} ,{{106, 119}, {11, 199, 0}} ,{{100, 119}, {5, 199, 0}} ,{{101, 119}, {6, 199, 0}} ,{{102, 119}, {7, 199, 0}} ,{{126, 119}, {31, 199, 0}} ,{{121, 119}, {26, 199, 0}} ,{{123, 119}, {28, 199, 0}} ,{{107, 119}, {12, 199, 0}} ,{{110, 119}, {15, 199, 0}} ,{{108, 119}, {13, 199, 0}} ,{{114, 119}, {19, 199, 0}} ,{{109, 119}, {14, 199, 0}} ,{{113, 119}, {18, 199, 0}} ,{{111, 119}, {16, 199, 0}} ,{{112, 119}, {17, 199, 0}} ,{{115, 119}, {20, 199, 0}} ,{{103, 119}, {8, 199, 0}} ,{{120, 119}, {25, 199, 0}} ,{{105, 119}, {10, 199, 0}} ,{{104, 119}, {9, 199, 0}} ,{{125, 119}, {30, 199, 0}} ,{{118, 119}, {23, 199, 0}} ,{{119, 119}, {24, 199, 0}} ,{{124, 119}, {29, 199, 0}} ,{{219, 117}, {124, 197, 0}} ,{{236, 117}, {141, 197, 0}} ,{{237, 117}, {142, 197, 0}} ,{{242, 117}, {147, 197, 0}} ,{{226, 117}, {131, 197, 0}} ,{{247, 117}, {152, 197, 0}} ,{{8, 118}, {169, 197, 0}} ,{{9, 118}, {170, 197, 0}} ,{{14, 118}, {175, 197, 0}} ,{{254, 117}, {159, 197, 0}} ,{{248, 117}, {153, 197, 0}} ,{{249, 117}, {154, 197, 0}} ,{{250, 117}, {155, 197, 0}} ,{{18, 118}, {179, 197, 0}} ,{{13, 118}, {174, 197, 0}} ,{{15, 118}, {176, 197, 0}} ,{{255, 117}, {160, 197, 0}} ,{{2, 118}, {163, 197, 0}} ,{{0, 118}, {161, 197, 0}} ,{{6, 118}, {167, 197, 0}} ,{{1, 118}, {162, 197, 0}} ,{{5, 118}, {166, 197, 0}} ,{{3, 118}, {164, 197, 0}} ,{{4, 118}, {165, 197, 0}} ,{{7, 118}, {168, 197, 0}} ,{{251, 117}, {156, 197, 0}} ,{{12, 118}, {173, 197, 0}} ,{{253, 117}, {158, 197, 0}} ,{{252, 117}, {157, 197, 0}} ,{{17, 118}, {178, 197, 0}} ,{{10, 118}, {171, 197, 0}} ,{{11, 118}, {172, 197, 0}} ,{{16, 118}, {177, 197, 0}} ,{{220, 117}, {125, 197, 0}} ,{{221, 117}, {126, 197, 0}} ,{{222, 117}, {127, 197, 0}} ,{{246, 117}, {151, 197, 0}} ,{{241, 117}, {146, 197, 0}} ,{{243, 117}, {148, 197, 0}} ,{{227, 117}, {132, 197, 0}} ,{{230, 117}, {135, 197, 0}} ,{{228, 117}, {133, 197, 0}} ,{{234, 117}, {139, 197, 0}} ,{{229, 117}, {134, 197, 0}} ,{{233, 117}, {138, 197, 0}} ,{{231, 117}, {136, 197, 0}} ,{{232, 117}, {137, 197, 0}} ,{{235, 117}, {140, 197, 0}} ,{{223, 117}, {128, 197, 0}} ,{{240, 117}, {145, 197, 0}} ,{{225, 117}, {130, 197, 0}} ,{{224, 117}, {129, 197, 0}} ,{{245, 117}, {150, 197, 0}} ,{{238, 117}, {143, 197, 0}} ,{{239, 117}, {144, 197, 0}} ,{{244, 117}, {149, 197, 0}} ,{{103, 118}, {8, 198, 0}} ,{{120, 118}, {25, 198, 0}} ,{{121, 118}, {26, 198, 0}} ,{{126, 118}, {31, 198, 0}} ,{{110, 118}, {15, 198, 0}} ,{{104, 118}, {9, 198, 0}} ,{{105, 118}, {10, 198, 0}} ,{{106, 118}, {11, 198, 0}} ,{{130, 118}, {35, 198, 0}} ,{{125, 118}, {30, 198, 0}} ,{{127, 118}, {32, 198, 0}} ,{{111, 118}, {16, 198, 0}} ,{{114, 118}, {19, 198, 0}} ,{{112, 118}, {17, 198, 0}} ,{{118, 118}, {23, 198, 0}} ,{{113, 118}, {18, 198, 0}} ,{{117, 118}, {22, 198, 0}} ,{{115, 118}, {20, 198, 0}} ,{{116, 118}, {21, 198, 0}} ,{{119, 118}, {24, 198, 0}} ,{{107, 118}, {12, 198, 0}} ,{{124, 118}, {29, 198, 0}} ,{{109, 118}, {14, 198, 0}} ,{{108, 118}, {13, 198, 0}} ,{{75, 118}, {236, 197, 0}} ,{{92, 118}, {253, 197, 0}} ,{{93, 118}, {254, 197, 0}} ,{{98, 118}, {3, 198, 0}} ,{{82, 118}, {243, 197, 0}} ,{{76, 118}, {237, 197, 0}} ,{{77, 118}, {238, 197, 0}} ,{{78, 118}, {239, 197, 0}} ,{{102, 118}, {7, 198, 0}} ,{{97, 118}, {2, 198, 0}} ,{{99, 118}, {4, 198, 0}} ,{{83, 118}, {244, 197, 0}} ,{{86, 118}, {247, 197, 0}} ,{{84, 118}, {245, 197, 0}} ,{{90, 118}, {251, 197, 0}} ,{{85, 118}, {246, 197, 0}} ,{{89, 118}, {250, 197, 0}} ,{{87, 118}, {248, 197, 0}} ,{{88, 118}, {249, 197, 0}} ,{{91, 118}, {252, 197, 0}} ,{{79, 118}, {240, 197, 0}} ,{{96, 118}, {1, 198, 0}} ,{{81, 118}, {242, 197, 0}} ,{{80, 118}, {241, 197, 0}} ,{{101, 118}, {6, 198, 0}} ,{{94, 118}, {255, 197, 0}} ,{{95, 118}, {0, 198, 0}} ,{{100, 118}, {5, 198, 0}} ,{{129, 118}, {34, 198, 0}} ,{{122, 118}, {27, 198, 0}} ,{{123, 118}, {28, 198, 0}} ,{{128, 118}, {33, 198, 0}} ,{{183, 119}, {88, 199, 0}} ,{{200, 119}, {105, 199, 0}} ,{{201, 119}, {106, 199, 0}} ,{{206, 119}, {111, 199, 0}} ,{{190, 119}, {95, 199, 0}} ,{{184, 119}, {89, 199, 0}} ,{{185, 119}, {90, 199, 0}} ,{{186, 119}, {91, 199, 0}} ,{{210, 119}, {115, 199, 0}} ,{{205, 119}, {110, 199, 0}} ,{{207, 119}, {112, 199, 0}} ,{{191, 119}, {96, 199, 0}} ,{{194, 119}, {99, 199, 0}} ,{{192, 119}, {97, 199, 0}} ,{{198, 119}, {103, 199, 0}} ,{{193, 119}, {98, 199, 0}} ,{{197, 119}, {102, 199, 0}} ,{{195, 119}, {100, 199, 0}} ,{{196, 119}, {101, 199, 0}} ,{{199, 119}, {104, 199, 0}} ,{{187, 119}, {92, 199, 0}} ,{{204, 119}, {109, 199, 0}} ,{{189, 119}, {94, 199, 0}} ,{{188, 119}, {93, 199, 0}} ,{{209, 119}, {114, 199, 0}} ,{{202, 119}, {107, 199, 0}} ,{{203, 119}, {108, 199, 0}} ,{{208, 119}, {113, 199, 0}} ,{{243, 118}, {148, 198, 0}} ,{{4, 119}, {165, 198, 0}} ,{{5, 119}, {166, 198, 0}} ,{{10, 119}, {171, 198, 0}} ,{{250, 118}, {155, 198, 0}} ,{{244, 118}, {149, 198, 0}} ,{{245, 118}, {150, 198, 0}} ,{{246, 118}, {151, 198, 0}} ,{{14, 119}, {175, 198, 0}} ,{{9, 119}, {170, 198, 0}} ,{{11, 119}, {172, 198, 0}} ,{{251, 118}, {156, 198, 0}} ,{{254, 118}, {159, 198, 0}} ,{{252, 118}, {157, 198, 0}} ,{{2, 119}, {163, 198, 0}} ,{{253, 118}, {158, 198, 0}} ,{{1, 119}, {162, 198, 0}} ,{{255, 118}, {160, 198, 0}} ,{{0, 119}, {161, 198, 0}} ,{{3, 119}, {164, 198, 0}} ,{{247, 118}, {152, 198, 0}} ,{{8, 119}, {169, 198, 0}} ,{{249, 118}, {154, 198, 0}} ,{{248, 118}, {153, 198, 0}} ,{{13, 119}, {174, 198, 0}} ,{{6, 119}, {167, 198, 0}} ,{{7, 119}, {168, 198, 0}} ,{{12, 119}, {173, 198, 0}} ,{{127, 119}, {32, 199, 0}} ,{{144, 119}, {49, 199, 0}} ,{{145, 119}, {50, 199, 0}} ,{{150, 119}, {55, 199, 0}} ,{{134, 119}, {39, 199, 0}} ,{{128, 119}, {33, 199, 0}} ,{{129, 119}, {34, 199, 0}} ,{{130, 119}, {35, 199, 0}} ,{{154, 119}, {59, 199, 0}} ,{{149, 119}, {54, 199, 0}} ,{{151, 119}, {56, 199, 0}} ,{{135, 119}, {40, 199, 0}} ,{{138, 119}, {43, 199, 0}} ,{{136, 119}, {41, 199, 0}} ,{{142, 119}, {47, 199, 0}} ,{{137, 119}, {42, 199, 0}} ,{{141, 119}, {46, 199, 0}} ,{{139, 119}, {44, 199, 0}} ,{{140, 119}, {45, 199, 0}} ,{{143, 119}, {48, 199, 0}} ,{{131, 119}, {36, 199, 0}} ,{{148, 119}, {53, 199, 0}} ,{{133, 119}, {38, 199, 0}} ,{{132, 119}, {37, 199, 0}} ,{{153, 119}, {58, 199, 0}} ,{{146, 119}, {51, 199, 0}} ,{{147, 119}, {52, 199, 0}} ,{{152, 119}, {57, 199, 0}} ,{{122, 78}, {40, 48, 0}} ,{{119, 78}, {37, 48, 0}} ,{{118, 78}, {36, 48, 0}} ,{{123, 78}, {41, 48, 0}} ,{{115, 78}, {33, 48, 0}} ,{{121, 78}, {39, 48, 0}} ,{{120, 78}, {38, 48, 0}} ,{{138, 78}, {56, 48, 0}} ,{{140, 78}, {58, 48, 0}} ,{{117, 78}, {35, 48, 0}} ,{{139, 78}, {57, 48, 0}} ,{{116, 78}, {34, 48, 0}} ,{{42, 57}, {32, 23, 0}} ,{{52, 57}, {42, 23, 0}} ,{{49, 57}, {39, 23, 0}} ,{{46, 57}, {36, 23, 0}} ,{{59, 57}, {49, 23, 0}} ,{{43, 57}, {33, 23, 0}} ,{{45, 57}, {35, 23, 0}} ,{{56, 57}, {46, 23, 0}} ,{{53, 57}, {43, 23, 0}} ,{{50, 57}, {40, 23, 0}} ,{{47, 57}, {37, 23, 0}} ,{{51, 57}, {41, 23, 0}} ,{{55, 57}, {45, 23, 0}} ,{{58, 57}, {48, 23, 0}} ,{{48, 57}, {38, 23, 0}} ,{{44, 57}, {34, 23, 0}} ,{{57, 57}, {47, 23, 0}} ,{{54, 57}, {44, 23, 0}} ,{{62, 57}, {52, 23, 0}} ,{{60, 57}, {50, 23, 0}} ,{{61, 57}, {51, 23, 0}} ,{{194, 70}, {252, 38, 0}} ,{{242, 70}, {49, 39, 0}} ,{{218, 70}, {24, 39, 0}} ,{{111, 71}, {185, 39, 0}} ,{{110, 71}, {184, 39, 0}} ,{{109, 71}, {183, 39, 0}} ,{{92, 71}, {165, 39, 0}} ,{{93, 71}, {166, 39, 0}} ,{{30, 71}, {100, 39, 0}} ,{{214, 70}, {20, 39, 0}} ,{{7, 71}, {70, 39, 0}} ,{{6, 75}, {88, 43, 0}} ,{{7, 75}, {89, 43, 0}} ,{{5, 75}, {87, 43, 0}} ,{{173, 70}, {227, 38, 0}} ,{{95, 71}, {168, 39, 0}} ,{{87, 71}, {160, 39, 0}} ,{{26, 71}, {94, 39, 0}} ,{{25, 71}, {93, 39, 0}} ,{{249, 70}, {56, 39, 0}} ,{{12, 71}, {75, 39, 0}} ,{{28, 71}, {98, 39, 0}} ,{{19, 71}, {87, 39, 0}} ,{{230, 70}, {36, 39, 0}} ,{{220, 70}, {26, 39, 0}} ,{{29, 71}, {99, 39, 0}} ,{{3, 75}, {85, 43, 0}} ,{{42, 71}, {112, 39, 0}} ,{{40, 71}, {110, 39, 0}} ,{{100, 71}, {173, 39, 0}} ,{{216, 70}, {22, 39, 0}} ,{{81, 71}, {154, 39, 0}} ,{{222, 70}, {28, 39, 0}} ,{{239, 70}, {46, 39, 0}} ,{{4, 75}, {86, 43, 0}} ,{{43, 71}, {113, 39, 0}} ,{{41, 71}, {111, 39, 0}} ,{{80, 71}, {153, 39, 0}} ,{{83, 71}, {156, 39, 0}} ,{{24, 71}, {92, 39, 0}} ,{{23, 71}, {91, 39, 0}} ,{{79, 71}, {152, 39, 0}} ,{{9, 71}, {72, 39, 0}} ,{{113, 71}, {187, 39, 0}} ,{{254, 70}, {61, 39, 0}} ,{{4, 71}, {67, 39, 0}} ,{{85, 71}, {158, 39, 0}} ,{{101, 71}, {174, 39, 0}} ,{{22, 71}, {90, 39, 0}} ,{{115, 71}, {189, 39, 0}} ,{{166, 70}, {219, 38, 0}} ,{{78, 71}, {148, 39, 0}} ,{{37, 43}, {162, 5, 0}} ,{{42, 43}, {167, 5, 0}} ,{{48, 43}, {173, 5, 0}} ,{{20, 43}, {145, 5, 0}} ,{{31, 43}, {156, 5, 0}} ,{{32, 43}, {157, 5, 0}} ,{{33, 43}, {158, 5, 0}} ,{{47, 43}, {172, 5, 0}} ,{{39, 43}, {164, 5, 0}} ,{{40, 43}, {165, 5, 0}} ,{{41, 43}, {166, 5, 0}} ,{{38, 43}, {163, 5, 0}} ,{{46, 43}, {171, 5, 0}} ,{{28, 43}, {153, 5, 0}} ,{{36, 43}, {161, 5, 0}} ,{{43, 43}, {168, 5, 0}} ,{{34, 43}, {159, 5, 0}} ,{{26, 43}, {151, 5, 0}} ,{{21, 43}, {146, 5, 0}} ,{{22, 43}, {147, 5, 0}} ,{{35, 43}, {160, 5, 0}} ,{{44, 43}, {169, 5, 0}} ,{{30, 43}, {155, 5, 0}} ,{{25, 43}, {150, 5, 0}} ,{{45, 43}, {170, 5, 0}} ,{{29, 43}, {154, 5, 0}} ,{{24, 43}, {149, 5, 0}} ,{{23, 43}, {148, 5, 0}} ,{{27, 43}, {152, 5, 0}} ,{{49, 43}, {174, 5, 0}} ,{{75, 43}, {208, 5, 0}} ,{{64, 138}, {48, 251, 0}} ,{{62, 138}, {46, 251, 0}} ,{{63, 138}, {47, 251, 0}} ,{{48, 138}, {32, 251, 0}} ,{{57, 138}, {41, 251, 0}} ,{{93, 43}, {226, 5, 0}} ,{{76, 43}, {209, 5, 0}} ,{{65, 138}, {49, 251, 0}} ,{{87, 138}, {76, 251, 0}} ,{{78, 43}, {211, 5, 0}} ,{{67, 138}, {51, 251, 0}} ,{{85, 43}, {218, 5, 0}} ,{{73, 138}, {58, 251, 0}} ,{{88, 43}, {221, 5, 0}} ,{{90, 43}, {223, 5, 0}} ,{{94, 43}, {227, 5, 0}} ,{{79, 138}, {67, 251, 0}} ,{{96, 43}, {229, 5, 0}} ,{{77, 43}, {210, 5, 0}} ,{{66, 138}, {50, 251, 0}} ,{{79, 43}, {212, 5, 0}} ,{{82, 43}, {215, 5, 0}} ,{{68, 138}, {52, 251, 0}} ,{{86, 43}, {219, 5, 0}} ,{{74, 138}, {59, 251, 0}} ,{{88, 138}, {77, 251, 0}} ,{{87, 43}, {220, 5, 0}} ,{{75, 138}, {60, 251, 0}} ,{{89, 43}, {222, 5, 0}} ,{{76, 138}, {62, 251, 0}} ,{{91, 43}, {224, 5, 0}} ,{{77, 138}, {64, 251, 0}} ,{{95, 43}, {228, 5, 0}} ,{{80, 138}, {68, 251, 0}} ,{{89, 138}, {78, 251, 0}} ,{{98, 43}, {231, 5, 0}} ,{{82, 138}, {71, 251, 0}} ,{{99, 43}, {232, 5, 0}} ,{{83, 138}, {72, 251, 0}} ,{{92, 43}, {225, 5, 0}} ,{{78, 138}, {65, 251, 0}} ,{{100, 43}, {233, 5, 0}} ,{{84, 138}, {73, 251, 0}} ,{{60, 138}, {44, 251, 0}} ,{{61, 138}, {45, 251, 0}} ,{{58, 138}, {42, 251, 0}} ,{{59, 138}, {43, 251, 0}} ,{{101, 43}, {234, 5, 0}} ,{{85, 138}, {74, 251, 0}} ,{{83, 43}, {216, 5, 0}} ,{{71, 138}, {56, 251, 0}} ,{{97, 43}, {230, 5, 0}} ,{{81, 138}, {70, 251, 0}} ,{{80, 43}, {213, 5, 0}} ,{{69, 138}, {53, 251, 0}} ,{{86, 138}, {75, 251, 0}} ,{{49, 138}, {33, 251, 0}} ,{{50, 138}, {34, 251, 0}} ,{{54, 138}, {38, 251, 0}} ,{{51, 138}, {35, 251, 0}} ,{{52, 138}, {36, 251, 0}} ,{{53, 138}, {37, 251, 0}} ,{{55, 138}, {39, 251, 0}} ,{{56, 138}, {40, 251, 0}} ,{{84, 43}, {217, 5, 0}} ,{{72, 138}, {57, 251, 0}} ,{{45, 138}, {29, 251, 0}} ,{{81, 43}, {214, 5, 0}} ,{{70, 138}, {54, 251, 0}} ,{{90, 138}, {79, 251, 0}} ,{{102, 43}, {240, 5, 0}} ,{{104, 43}, {242, 5, 0}} ,{{103, 43}, {241, 5, 0}} ,{{47, 138}, {31, 251, 0}} ,{{72, 43}, {197, 5, 0}} ,{{50, 43}, {175, 5, 0}} ,{{71, 43}, {196, 5, 0}} ,{{63, 43}, {188, 5, 0}} ,{{53, 43}, {178, 5, 0}} ,{{54, 43}, {179, 5, 0}} ,{{52, 43}, {177, 5, 0}} ,{{55, 43}, {180, 5, 0}} ,{{60, 43}, {185, 5, 0}} ,{{61, 43}, {186, 5, 0}} ,{{46, 138}, {30, 251, 0}} ,{{64, 43}, {189, 5, 0}} ,{{58, 43}, {183, 5, 0}} ,{{59, 43}, {184, 5, 0}} ,{{74, 43}, {199, 5, 0}} ,{{62, 43}, {187, 5, 0}} ,{{66, 43}, {191, 5, 0}} ,{{57, 43}, {182, 5, 0}} ,{{51, 43}, {176, 5, 0}} ,{{68, 43}, {193, 5, 0}} ,{{69, 43}, {194, 5, 0}} ,{{56, 43}, {181, 5, 0}} ,{{105, 43}, {243, 5, 0}} ,{{106, 43}, {244, 5, 0}} ,{{65, 43}, {190, 5, 0}} ,{{73, 43}, {198, 5, 0}} ,{{67, 43}, {192, 5, 0}} ,{{70, 43}, {195, 5, 0}} ,{{156, 70}, {209, 38, 0}} ,{{153, 67}, {136, 35, 0}} ,{{202, 66}, {185, 34, 0}} ,{{102, 82}, {246, 77, 0}} ,{{110, 82}, {254, 77, 0}} ,{{66, 82}, {210, 77, 0}} ,{{111, 82}, {255, 77, 0}} ,{{68, 82}, {212, 77, 0}} ,{{90, 82}, {234, 77, 0}} ,{{91, 82}, {235, 77, 0}} ,{{53, 82}, {197, 77, 0}} ,{{67, 82}, {211, 77, 0}} ,{{83, 82}, {227, 77, 0}} ,{{88, 82}, {232, 77, 0}} ,{{87, 82}, {231, 77, 0}} ,{{100, 82}, {244, 77, 0}} ,{{50, 82}, {194, 77, 0}} ,{{106, 82}, {250, 77, 0}} ,{{79, 82}, {223, 77, 0}} ,{{63, 82}, {207, 77, 0}} ,{{60, 82}, {204, 77, 0}} ,{{64, 82}, {208, 77, 0}} ,{{92, 82}, {236, 77, 0}} ,{{69, 82}, {213, 77, 0}} ,{{61, 82}, {205, 77, 0}} ,{{81, 82}, {225, 77, 0}} ,{{75, 82}, {219, 77, 0}} ,{{73, 82}, {217, 77, 0}} ,{{55, 82}, {199, 77, 0}} ,{{89, 82}, {233, 77, 0}} ,{{78, 82}, {222, 77, 0}} ,{{108, 82}, {252, 77, 0}} ,{{72, 82}, {216, 77, 0}} ,{{107, 82}, {251, 77, 0}} ,{{62, 82}, {206, 77, 0}} ,{{74, 82}, {218, 77, 0}} ,{{86, 82}, {230, 77, 0}} ,{{85, 82}, {229, 77, 0}} ,{{94, 82}, {238, 77, 0}} ,{{58, 82}, {202, 77, 0}} ,{{82, 82}, {226, 77, 0}} ,{{93, 82}, {237, 77, 0}} ,{{80, 82}, {224, 77, 0}} ,{{71, 82}, {215, 77, 0}} ,{{96, 82}, {240, 77, 0}} ,{{109, 82}, {253, 77, 0}} ,{{56, 82}, {200, 77, 0}} ,{{70, 82}, {214, 77, 0}} ,{{59, 82}, {203, 77, 0}} ,{{76, 82}, {220, 77, 0}} ,{{54, 82}, {198, 77, 0}} ,{{98, 82}, {242, 77, 0}} ,{{97, 82}, {241, 77, 0}} ,{{77, 82}, {221, 77, 0}} ,{{48, 82}, {192, 77, 0}} ,{{84, 82}, {228, 77, 0}} ,{{104, 82}, {248, 77, 0}} ,{{105, 82}, {249, 77, 0}} ,{{99, 82}, {243, 77, 0}} ,{{101, 82}, {245, 77, 0}} ,{{49, 82}, {193, 77, 0}} ,{{103, 82}, {247, 77, 0}} ,{{95, 82}, {239, 77, 0}} ,{{57, 82}, {201, 77, 0}} ,{{52, 82}, {196, 77, 0}} ,{{65, 82}, {209, 77, 0}} ,{{51, 82}, {195, 77, 0}} ,{{109, 70}, {161, 38, 0}} ,{{238, 78}, {159, 48, 0}} ,{{236, 78}, {157, 48, 0}} ,{{147, 78}, {66, 48, 0}} ,{{193, 78}, {112, 48, 0}} ,{{202, 78}, {121, 48, 0}} ,{{196, 78}, {115, 48, 0}} ,{{205, 78}, {124, 48, 0}} ,{{199, 78}, {118, 48, 0}} ,{{177, 78}, {96, 48, 0}} ,{{184, 78}, {103, 48, 0}} ,{{179, 78}, {98, 48, 0}} ,{{186, 78}, {105, 48, 0}} ,{{182, 78}, {101, 48, 0}} ,{{153, 78}, {72, 48, 0}} ,{{157, 78}, {76, 48, 0}} ,{{163, 78}, {82, 48, 0}} ,{{159, 78}, {78, 48, 0}} ,{{165, 78}, {84, 48, 0}} ,{{161, 78}, {80, 48, 0}} ,{{192, 78}, {111, 48, 0}} ,{{201, 78}, {120, 48, 0}} ,{{195, 78}, {114, 48, 0}} ,{{204, 78}, {123, 48, 0}} ,{{198, 78}, {117, 48, 0}} ,{{149, 78}, {68, 48, 0}} ,{{156, 78}, {75, 48, 0}} ,{{162, 78}, {81, 48, 0}} ,{{158, 78}, {77, 48, 0}} ,{{164, 78}, {83, 48, 0}} ,{{160, 78}, {79, 48, 0}} ,{{207, 78}, {126, 48, 0}} ,{{210, 78}, {129, 48, 0}} ,{{208, 78}, {127, 48, 0}} ,{{211, 78}, {130, 48, 0}} ,{{209, 78}, {128, 48, 0}} ,{{228, 78}, {147, 48, 0}} ,{{187, 78}, {106, 48, 0}} ,{{190, 78}, {109, 48, 0}} ,{{188, 78}, {107, 48, 0}} ,{{191, 78}, {110, 48, 0}} ,{{189, 78}, {108, 48, 0}} ,{{155, 78}, {74, 48, 0}} ,{{194, 78}, {113, 48, 0}} ,{{203, 78}, {122, 48, 0}} ,{{197, 78}, {116, 48, 0}} ,{{206, 78}, {125, 48, 0}} ,{{200, 78}, {119, 48, 0}} ,{{218, 78}, {137, 48, 0}} ,{{221, 78}, {140, 48, 0}} ,{{219, 78}, {138, 48, 0}} ,{{222, 78}, {141, 48, 0}} ,{{220, 78}, {139, 48, 0}} ,{{166, 78}, {85, 48, 0}} ,{{172, 78}, {91, 48, 0}} ,{{168, 78}, {87, 48, 0}} ,{{146, 78}, {65, 48, 0}} ,{{152, 78}, {71, 48, 0}} ,{{148, 78}, {67, 48, 0}} ,{{230, 78}, {149, 48, 0}} ,{{231, 78}, {150, 48, 0}} ,{{154, 78}, {73, 48, 0}} ,{{180, 78}, {99, 48, 0}} ,{{150, 78}, {69, 48, 0}} ,{{223, 78}, {142, 48, 0}} ,{{212, 78}, {131, 48, 0}} ,{{216, 78}, {135, 48, 0}} ,{{214, 78}, {133, 48, 0}} ,{{174, 78}, {93, 48, 0}} ,{{170, 78}, {89, 48, 0}} ,{{176, 78}, {95, 48, 0}} ,{{183, 78}, {102, 48, 0}} ,{{178, 78}, {97, 48, 0}} ,{{185, 78}, {104, 48, 0}} ,{{181, 78}, {100, 48, 0}} ,{{151, 78}, {70, 48, 0}} ,{{229, 78}, {148, 48, 0}} ,{{224, 78}, {143, 48, 0}} ,{{226, 78}, {145, 48, 0}} ,{{225, 78}, {144, 48, 0}} ,{{227, 78}, {146, 48, 0}} ,{{213, 78}, {132, 48, 0}} ,{{217, 78}, {136, 48, 0}} ,{{215, 78}, {134, 48, 0}} ,{{167, 78}, {86, 48, 0}} ,{{173, 78}, {92, 48, 0}} ,{{169, 78}, {88, 48, 0}} ,{{175, 78}, {94, 48, 0}} ,{{171, 78}, {90, 48, 0}} ,{{237, 78}, {158, 48, 0}} ,{{178, 70}, {236, 38, 0}} ,{{76, 66}, {59, 34, 0}} ,{{101, 64}, {21, 32, 0}} ,{{212, 74}, {35, 43, 0}} ,{{118, 64}, {38, 32, 0}} ,{{192, 67}, {175, 35, 0}} ,{{117, 70}, {169, 38, 0}} ,{{203, 67}, {186, 35, 0}} ,{{204, 67}, {187, 35, 0}} ,{{205, 67}, {188, 35, 0}} ,{{206, 67}, {189, 35, 0}} ,{{225, 69}, {21, 38, 0}} ,{{52, 70}, {104, 38, 0}} ,{{44, 67}, {27, 35, 0}} ,{{19, 67}, {2, 35, 0}} ,{{241, 64}, {180, 32, 0}} ,{{96, 64}, {16, 32, 0}} ,{{240, 37}, {45, 0, 0}} ,{{119, 64}, {39, 32, 0}} ,{{147, 64}, {67, 32, 0}} ,{{229, 76}, {26, 46, 0}} ,{{221, 76}, {18, 46, 0}} ,{{159, 67}, {142, 35, 0}} ,{{190, 70}, {248, 38, 0}} ,{{114, 66}, {97, 34, 0}} ,{{150, 73}, {229, 41, 0}} ,{{24, 74}, {103, 42, 0}} ,{{222, 79}, {152, 49, 0}} ,{{228, 79}, {158, 49, 0}} ,{{223, 79}, {153, 49, 0}} ,{{226, 79}, {156, 49, 0}} ,{{219, 79}, {149, 49, 0}} ,{{227, 79}, {157, 49, 0}} ,{{214, 79}, {144, 49, 0}} ,{{229, 79}, {159, 49, 0}} ,{{221, 79}, {151, 49, 0}} ,{{216, 79}, {146, 49, 0}} ,{{215, 79}, {145, 49, 0}} ,{{224, 79}, {154, 49, 0}} ,{{225, 79}, {155, 49, 0}} ,{{218, 79}, {148, 49, 0}} ,{{220, 79}, {150, 49, 0}} ,{{217, 79}, {147, 49, 0}} ,{{88, 78}, {6, 48, 0}} ,{{83, 78}, {1, 48, 0}} ,{{126, 78}, {44, 48, 0}} ,{{71, 78}, {241, 47, 0}} ,{{73, 78}, {243, 47, 0}} ,{{74, 78}, {244, 47, 0}} ,{{72, 78}, {242, 47, 0}} ,{{70, 78}, {240, 47, 0}} ,{{81, 78}, {251, 47, 0}} ,{{75, 78}, {245, 47, 0}} ,{{76, 78}, {246, 47, 0}} ,{{77, 78}, {247, 47, 0}} ,{{80, 78}, {250, 47, 0}} ,{{78, 78}, {248, 47, 0}} ,{{79, 78}, {249, 47, 0}} ,{{127, 78}, {45, 48, 0}} ,{{84, 78}, {2, 48, 0}} ,{{145, 78}, {63, 48, 0}} ,{{87, 78}, {5, 48, 0}} ,{{124, 78}, {42, 48, 0}} ,{{89, 78}, {7, 48, 0}} ,{{125, 78}, {43, 48, 0}} ,{{82, 78}, {0, 48, 0}} ,{{137, 78}, {55, 48, 0}} ,{{244, 80}, {195, 50, 0}} ,{{248, 80}, {199, 50, 0}} ,{{23, 82}, {231, 51, 0}} ,{{33, 82}, {241, 51, 0}} ,{{26, 82}, {234, 51, 0}} ,{{30, 82}, {238, 51, 0}} ,{{20, 82}, {228, 51, 0}} ,{{19, 82}, {227, 51, 0}} ,{{29, 82}, {237, 51, 0}} ,{{24, 82}, {232, 51, 0}} ,{{34, 82}, {242, 51, 0}} ,{{16, 82}, {224, 51, 0}} ,{{22, 82}, {230, 51, 0}} ,{{32, 82}, {240, 51, 0}} ,{{21, 82}, {229, 51, 0}} ,{{31, 82}, {239, 51, 0}} ,{{25, 82}, {233, 51, 0}} ,{{28, 82}, {236, 51, 0}} ,{{45, 82}, {253, 51, 0}} ,{{46, 82}, {254, 51, 0}} ,{{18, 82}, {226, 51, 0}} ,{{27, 82}, {235, 51, 0}} ,{{35, 82}, {243, 51, 0}} ,{{43, 82}, {251, 51, 0}} ,{{40, 82}, {248, 51, 0}} ,{{39, 82}, {247, 51, 0}} ,{{44, 82}, {252, 51, 0}} ,{{36, 82}, {244, 51, 0}} ,{{42, 82}, {250, 51, 0}} ,{{41, 82}, {249, 51, 0}} ,{{38, 82}, {246, 51, 0}} ,{{37, 82}, {245, 51, 0}} ,{{17, 82}, {225, 51, 0}} ,{{252, 80}, {203, 50, 0}} ,{{242, 80}, {193, 50, 0}} ,{{144, 81}, {96, 51, 0}} ,{{154, 81}, {106, 51, 0}} ,{{147, 81}, {99, 51, 0}} ,{{151, 81}, {103, 51, 0}} ,{{141, 81}, {93, 51, 0}} ,{{140, 81}, {92, 51, 0}} ,{{150, 81}, {102, 51, 0}} ,{{145, 81}, {97, 51, 0}} ,{{155, 81}, {107, 51, 0}} ,{{137, 81}, {89, 51, 0}} ,{{143, 81}, {95, 51, 0}} ,{{153, 81}, {105, 51, 0}} ,{{142, 81}, {94, 51, 0}} ,{{152, 81}, {104, 51, 0}} ,{{146, 81}, {98, 51, 0}} ,{{149, 81}, {101, 51, 0}} ,{{139, 81}, {91, 51, 0}} ,{{148, 81}, {100, 51, 0}} ,{{156, 81}, {108, 51, 0}} ,{{160, 81}, {112, 51, 0}} ,{{157, 81}, {109, 51, 0}} ,{{159, 81}, {111, 51, 0}} ,{{158, 81}, {110, 51, 0}} ,{{138, 81}, {90, 51, 0}} ,{{136, 81}, {88, 51, 0}} ,{{241, 80}, {192, 50, 0}} ,{{247, 80}, {198, 50, 0}} ,{{246, 80}, {197, 50, 0}} ,{{243, 80}, {194, 50, 0}} ,{{245, 80}, {196, 50, 0}} ,{{251, 80}, {202, 50, 0}} ,{{250, 80}, {201, 50, 0}} ,{{249, 80}, {200, 50, 0}} ,{{144, 78}, {62, 48, 0}} ,{{200, 66}, {183, 34, 0}} ,{{100, 66}, {83, 34, 0}} ,{{201, 145}, {64, 8, 1}} ,{{216, 145}, {79, 8, 1}} ,{{202, 145}, {65, 8, 1}} ,{{204, 145}, {67, 8, 1}} ,{{203, 145}, {66, 8, 1}} ,{{205, 145}, {68, 8, 1}} ,{{208, 145}, {71, 8, 1}} ,{{211, 145}, {74, 8, 1}} ,{{212, 145}, {75, 8, 1}} ,{{213, 145}, {76, 8, 1}} ,{{214, 145}, {77, 8, 1}} ,{{217, 145}, {80, 8, 1}} ,{{219, 145}, {82, 8, 1}} ,{{220, 145}, {83, 8, 1}} ,{{218, 145}, {81, 8, 1}} ,{{215, 145}, {78, 8, 1}} ,{{221, 145}, {84, 8, 1}} ,{{222, 145}, {85, 8, 1}} ,{{209, 145}, {72, 8, 1}} ,{{206, 145}, {69, 8, 1}} ,{{210, 145}, {73, 8, 1}} ,{{207, 145}, {70, 8, 1}} ,{{224, 145}, {88, 8, 1}} ,{{229, 145}, {93, 8, 1}} ,{{230, 145}, {94, 8, 1}} ,{{227, 145}, {91, 8, 1}} ,{{231, 145}, {95, 8, 1}} ,{{226, 145}, {90, 8, 1}} ,{{228, 145}, {92, 8, 1}} ,{{225, 145}, {89, 8, 1}} ,{{223, 145}, {87, 8, 1}} ,{{141, 73}, {220, 41, 0}} ,{{146, 73}, {225, 41, 0}} ,{{23, 66}, {6, 34, 0}} ,{{47, 66}, {30, 34, 0}} ,{{143, 73}, {222, 41, 0}} ,{{80, 65}, {57, 33, 0}} ,{{183, 64}, {108, 32, 0}} ,{{181, 64}, {106, 32, 0}} ,{{220, 146}, {96, 11, 1}} ,{{221, 146}, {97, 11, 1}} ,{{223, 146}, {99, 11, 1}} ,{{222, 146}, {98, 11, 1}} ,{{224, 146}, {100, 11, 1}} ,{{227, 146}, {103, 11, 1}} ,{{230, 146}, {106, 11, 1}} ,{{231, 146}, {107, 11, 1}} ,{{232, 146}, {108, 11, 1}} ,{{233, 146}, {109, 11, 1}} ,{{235, 146}, {111, 11, 1}} ,{{236, 146}, {112, 11, 1}} ,{{234, 146}, {110, 11, 1}} ,{{237, 146}, {113, 11, 1}} ,{{238, 146}, {114, 11, 1}} ,{{228, 146}, {104, 11, 1}} ,{{225, 146}, {101, 11, 1}} ,{{229, 146}, {105, 11, 1}} ,{{226, 146}, {102, 11, 1}} ,{{242, 146}, {123, 11, 1}} ,{{239, 146}, {120, 11, 1}} ,{{245, 146}, {126, 11, 1}} ,{{246, 146}, {127, 11, 1}} ,{{243, 146}, {124, 11, 1}} ,{{241, 146}, {122, 11, 1}} ,{{244, 146}, {125, 11, 1}} ,{{240, 146}, {121, 11, 1}} ,{{190, 146}, {64, 11, 1}} ,{{205, 146}, {79, 11, 1}} ,{{191, 146}, {65, 11, 1}} ,{{193, 146}, {67, 11, 1}} ,{{192, 146}, {66, 11, 1}} ,{{194, 146}, {68, 11, 1}} ,{{197, 146}, {71, 11, 1}} ,{{200, 146}, {74, 11, 1}} ,{{201, 146}, {75, 11, 1}} ,{{202, 146}, {76, 11, 1}} ,{{203, 146}, {77, 11, 1}} ,{{206, 146}, {80, 11, 1}} ,{{208, 146}, {82, 11, 1}} ,{{209, 146}, {83, 11, 1}} ,{{207, 146}, {81, 11, 1}} ,{{204, 146}, {78, 11, 1}} ,{{210, 146}, {84, 11, 1}} ,{{211, 146}, {85, 11, 1}} ,{{198, 146}, {72, 11, 1}} ,{{195, 146}, {69, 11, 1}} ,{{199, 146}, {73, 11, 1}} ,{{196, 146}, {70, 11, 1}} ,{{215, 146}, {91, 11, 1}} ,{{212, 146}, {88, 11, 1}} ,{{218, 146}, {94, 11, 1}} ,{{219, 146}, {95, 11, 1}} ,{{216, 146}, {92, 11, 1}} ,{{214, 146}, {90, 11, 1}} ,{{217, 146}, {93, 11, 1}} ,{{213, 146}, {89, 11, 1}} ,{{145, 67}, {128, 35, 0}} ,{{60, 66}, {43, 34, 0}} ,{{198, 73}, {21, 42, 0}} ,{{192, 73}, {15, 42, 0}} ,{{191, 67}, {174, 35, 0}} ,{{191, 73}, {14, 42, 0}} ,{{202, 73}, {25, 42, 0}} ,{{200, 73}, {23, 42, 0}} ,{{204, 73}, {27, 42, 0}} ,{{201, 73}, {24, 42, 0}} ,{{205, 73}, {28, 42, 0}} ,{{203, 73}, {26, 42, 0}} ,{{203, 66}, {186, 34, 0}} ,{{237, 73}, {60, 42, 0}} ,{{119, 142}, {249, 255, 0}} ,{{120, 142}, {250, 255, 0}} ,{{121, 142}, {251, 255, 0}} ,{{112, 70}, {164, 38, 0}} ,{{141, 64}, {61, 32, 0}} ,{{58, 66}, {41, 34, 0}} ,{{250, 73}, {73, 42, 0}} ,{{248, 73}, {71, 42, 0}} ,{{252, 73}, {75, 42, 0}} ,{{241, 73}, {64, 42, 0}} ,{{245, 73}, {68, 42, 0}} ,{{244, 73}, {67, 42, 0}} ,{{164, 69}, {216, 37, 0}} ,{{165, 69}, {217, 37, 0}} ,{{67, 38}, {161, 0, 0}} ,{{227, 76}, {24, 46, 0}} ,{{79, 66}, {62, 34, 0}} ,{{62, 65}, {39, 33, 0}} ,{{97, 38}, {191, 0, 0}} ,{{164, 64}, {84, 32, 0}} ,{{180, 64}, {100, 32, 0}} ,{{179, 64}, {99, 32, 0}} ,{{178, 64}, {98, 32, 0}} ,{{193, 70}, {251, 38, 0}} ,{{86, 78}, {4, 48, 0}} ,{{84, 91}, {191, 169, 0}} ,{{82, 91}, {189, 169, 0}} ,{{83, 91}, {190, 169, 0}} ,{{108, 91}, {216, 169, 0}} ,{{105, 91}, {213, 169, 0}} ,{{104, 91}, {212, 169, 0}} ,{{109, 91}, {217, 169, 0}} ,{{101, 91}, {209, 169, 0}} ,{{107, 91}, {215, 169, 0}} ,{{106, 91}, {214, 169, 0}} ,{{103, 91}, {211, 169, 0}} ,{{102, 91}, {210, 169, 0}} ,{{100, 91}, {208, 169, 0}} ,{{86, 91}, {193, 169, 0}} ,{{25, 91}, {132, 169, 0}} ,{{34, 91}, {141, 169, 0}} ,{{60, 91}, {167, 169, 0}} ,{{61, 91}, {168, 169, 0}} ,{{42, 91}, {149, 169, 0}} ,{{43, 91}, {150, 169, 0}} ,{{55, 91}, {162, 169, 0}} ,{{56, 91}, {163, 169, 0}} ,{{50, 91}, {157, 169, 0}} ,{{51, 91}, {158, 169, 0}} ,{{33, 91}, {140, 169, 0}} ,{{39, 91}, {146, 169, 0}} ,{{40, 91}, {147, 169, 0}} ,{{71, 91}, {178, 169, 0}} ,{{27, 91}, {134, 169, 0}} ,{{28, 91}, {135, 169, 0}} ,{{26, 91}, {133, 169, 0}} ,{{44, 91}, {151, 169, 0}} ,{{46, 91}, {153, 169, 0}} ,{{36, 91}, {143, 169, 0}} ,{{38, 91}, {145, 169, 0}} ,{{37, 91}, {144, 169, 0}} ,{{66, 91}, {173, 169, 0}} ,{{62, 91}, {169, 169, 0}} ,{{57, 91}, {164, 169, 0}} ,{{52, 91}, {159, 169, 0}} ,{{41, 91}, {148, 169, 0}} ,{{31, 91}, {138, 169, 0}} ,{{32, 91}, {139, 169, 0}} ,{{47, 91}, {154, 169, 0}} ,{{45, 91}, {152, 169, 0}} ,{{35, 91}, {142, 169, 0}} ,{{58, 91}, {165, 169, 0}} ,{{30, 91}, {137, 169, 0}} ,{{59, 91}, {166, 169, 0}} ,{{64, 91}, {171, 169, 0}} ,{{65, 91}, {172, 169, 0}} ,{{70, 91}, {177, 169, 0}} ,{{69, 91}, {176, 169, 0}} ,{{68, 91}, {175, 169, 0}} ,{{53, 91}, {160, 169, 0}} ,{{54, 91}, {161, 169, 0}} ,{{48, 91}, {155, 169, 0}} ,{{49, 91}, {156, 169, 0}} ,{{29, 91}, {136, 169, 0}} ,{{67, 91}, {174, 169, 0}} ,{{63, 91}, {170, 169, 0}} ,{{95, 91}, {202, 169, 0}} ,{{96, 91}, {203, 169, 0}} ,{{88, 91}, {195, 169, 0}} ,{{111, 91}, {223, 169, 0}} ,{{93, 91}, {200, 169, 0}} ,{{90, 91}, {197, 169, 0}} ,{{94, 91}, {201, 169, 0}} ,{{89, 91}, {196, 169, 0}} ,{{92, 91}, {199, 169, 0}} ,{{97, 91}, {204, 169, 0}} ,{{110, 91}, {222, 169, 0}} ,{{91, 91}, {198, 169, 0}} ,{{85, 91}, {192, 169, 0}} ,{{99, 91}, {207, 169, 0}} ,{{87, 91}, {194, 169, 0}} ,{{22, 91}, {129, 169, 0}} ,{{72, 91}, {179, 169, 0}} ,{{23, 91}, {130, 169, 0}} ,{{21, 91}, {128, 169, 0}} ,{{24, 91}, {131, 169, 0}} ,{{98, 91}, {205, 169, 0}} ,{{80, 91}, {187, 169, 0}} ,{{81, 91}, {188, 169, 0}} ,{{77, 91}, {184, 169, 0}} ,{{78, 91}, {185, 169, 0}} ,{{79, 91}, {186, 169, 0}} ,{{73, 91}, {180, 169, 0}} ,{{74, 91}, {181, 169, 0}} ,{{75, 91}, {182, 169, 0}} ,{{76, 91}, {183, 169, 0}} ,{{206, 73}, {29, 42, 0}} ,{{129, 70}, {181, 38, 0}} ,{{15, 70}, {67, 38, 0}} ,{{154, 147}, {187, 16, 1}} ,{{159, 147}, {192, 16, 1}} ,{{160, 147}, {193, 16, 1}} ,{{158, 147}, {191, 16, 1}} ,{{155, 147}, {188, 16, 1}} ,{{98, 147}, {131, 16, 1}} ,{{99, 147}, {132, 16, 1}} ,{{105, 147}, {138, 16, 1}} ,{{107, 147}, {140, 16, 1}} ,{{132, 147}, {165, 16, 1}} ,{{133, 147}, {166, 16, 1}} ,{{113, 147}, {146, 16, 1}} ,{{114, 147}, {147, 16, 1}} ,{{127, 147}, {160, 16, 1}} ,{{120, 147}, {153, 16, 1}} ,{{121, 147}, {154, 16, 1}} ,{{122, 147}, {155, 16, 1}} ,{{128, 147}, {161, 16, 1}} ,{{104, 147}, {137, 16, 1}} ,{{110, 147}, {143, 16, 1}} ,{{111, 147}, {144, 16, 1}} ,{{142, 147}, {175, 16, 1}} ,{{100, 147}, {133, 16, 1}} ,{{101, 147}, {134, 16, 1}} ,{{115, 147}, {148, 16, 1}} ,{{116, 147}, {149, 16, 1}} ,{{108, 147}, {141, 16, 1}} ,{{109, 147}, {142, 16, 1}} ,{{137, 147}, {170, 16, 1}} ,{{134, 147}, {167, 16, 1}} ,{{129, 147}, {162, 16, 1}} ,{{112, 147}, {145, 16, 1}} ,{{124, 147}, {157, 16, 1}} ,{{117, 147}, {150, 16, 1}} ,{{106, 147}, {139, 16, 1}} ,{{130, 147}, {163, 16, 1}} ,{{131, 147}, {164, 16, 1}} ,{{136, 147}, {169, 16, 1}} ,{{123, 147}, {156, 16, 1}} ,{{141, 147}, {174, 16, 1}} ,{{139, 147}, {172, 16, 1}} ,{{140, 147}, {173, 16, 1}} ,{{125, 147}, {158, 16, 1}} ,{{126, 147}, {159, 16, 1}} ,{{118, 147}, {151, 16, 1}} ,{{119, 147}, {152, 16, 1}} ,{{102, 147}, {135, 16, 1}} ,{{103, 147}, {136, 16, 1}} ,{{138, 147}, {171, 16, 1}} ,{{135, 147}, {168, 16, 1}} ,{{156, 147}, {189, 16, 1}} ,{{157, 147}, {190, 16, 1}} ,{{96, 147}, {129, 16, 1}} ,{{95, 147}, {128, 16, 1}} ,{{153, 147}, {186, 16, 1}} ,{{152, 147}, {185, 16, 1}} ,{{97, 147}, {130, 16, 1}} ,{{143, 147}, {176, 16, 1}} ,{{149, 147}, {182, 16, 1}} ,{{151, 147}, {184, 16, 1}} ,{{148, 147}, {181, 16, 1}} ,{{144, 147}, {177, 16, 1}} ,{{145, 147}, {178, 16, 1}} ,{{150, 147}, {183, 16, 1}} ,{{146, 147}, {179, 16, 1}} ,{{147, 147}, {180, 16, 1}} ,{{140, 77}, {28, 47, 0}} ,{{237, 77}, {125, 47, 0}} ,{{244, 77}, {132, 47, 0}} ,{{222, 77}, {110, 47, 0}} ,{{180, 77}, {68, 47, 0}} ,{{8, 78}, {152, 47, 0}} ,{{229, 77}, {117, 47, 0}} ,{{6, 78}, {150, 47, 0}} ,{{148, 77}, {36, 47, 0}} ,{{51, 78}, {195, 47, 0}} ,{{15, 78}, {159, 47, 0}} ,{{58, 78}, {202, 47, 0}} ,{{254, 77}, {142, 47, 0}} ,{{29, 78}, {173, 47, 0}} ,{{248, 77}, {136, 47, 0}} ,{{13, 78}, {157, 47, 0}} ,{{214, 77}, {102, 47, 0}} ,{{43, 78}, {187, 47, 0}} ,{{168, 77}, {56, 47, 0}} ,{{176, 77}, {64, 47, 0}} ,{{170, 77}, {58, 47, 0}} ,{{240, 77}, {128, 47, 0}} ,{{14, 78}, {158, 47, 0}} ,{{48, 78}, {192, 47, 0}} ,{{227, 77}, {115, 47, 0}} ,{{150, 77}, {38, 47, 0}} ,{{18, 78}, {162, 47, 0}} ,{{194, 77}, {82, 47, 0}} ,{{198, 77}, {86, 47, 0}} ,{{138, 77}, {26, 47, 0}} ,{{0, 78}, {144, 47, 0}} ,{{250, 77}, {138, 47, 0}} ,{{192, 77}, {80, 47, 0}} ,{{155, 77}, {43, 47, 0}} ,{{125, 77}, {13, 47, 0}} ,{{204, 77}, {92, 47, 0}} ,{{189, 77}, {77, 47, 0}} ,{{53, 78}, {197, 47, 0}} ,{{179, 77}, {67, 47, 0}} ,{{219, 77}, {107, 47, 0}} ,{{20, 78}, {164, 47, 0}} ,{{136, 77}, {24, 47, 0}} ,{{205, 77}, {93, 47, 0}} ,{{174, 77}, {62, 47, 0}} ,{{114, 77}, {2, 47, 0}} ,{{164, 77}, {52, 47, 0}} ,{{216, 77}, {104, 47, 0}} ,{{200, 77}, {88, 47, 0}} ,{{124, 77}, {12, 47, 0}} ,{{191, 77}, {79, 47, 0}} ,{{67, 78}, {211, 47, 0}} ,{{62, 78}, {206, 47, 0}} ,{{162, 77}, {50, 47, 0}} ,{{239, 77}, {127, 47, 0}} ,{{143, 77}, {31, 47, 0}} ,{{39, 78}, {183, 47, 0}} ,{{123, 77}, {11, 47, 0}} ,{{59, 78}, {203, 47, 0}} ,{{142, 77}, {30, 47, 0}} ,{{122, 77}, {10, 47, 0}} ,{{65, 78}, {209, 47, 0}} ,{{147, 77}, {35, 47, 0}} ,{{220, 77}, {108, 47, 0}} ,{{31, 78}, {175, 47, 0}} ,{{203, 77}, {91, 47, 0}} ,{{199, 77}, {87, 47, 0}} ,{{235, 77}, {123, 47, 0}} ,{{213, 77}, {101, 47, 0}} ,{{46, 78}, {190, 47, 0}} ,{{197, 77}, {85, 47, 0}} ,{{50, 78}, {194, 47, 0}} ,{{69, 78}, {213, 47, 0}} ,{{38, 78}, {182, 47, 0}} ,{{12, 78}, {156, 47, 0}} ,{{41, 78}, {185, 47, 0}} ,{{60, 78}, {204, 47, 0}} ,{{193, 77}, {81, 47, 0}} ,{{24, 78}, {168, 47, 0}} ,{{49, 78}, {193, 47, 0}} ,{{145, 77}, {33, 47, 0}} ,{{22, 78}, {166, 47, 0}} ,{{146, 77}, {34, 47, 0}} ,{{226, 77}, {114, 47, 0}} ,{{251, 77}, {139, 47, 0}} ,{{45, 78}, {189, 47, 0}} ,{{173, 77}, {61, 47, 0}} ,{{201, 77}, {89, 47, 0}} ,{{175, 77}, {63, 47, 0}} ,{{40, 78}, {184, 47, 0}} ,{{172, 77}, {60, 47, 0}} ,{{55, 78}, {199, 47, 0}} ,{{134, 77}, {22, 47, 0}} ,{{117, 77}, {5, 47, 0}} ,{{3, 78}, {147, 47, 0}} ,{{42, 78}, {186, 47, 0}} ,{{126, 77}, {14, 47, 0}} ,{{152, 77}, {40, 47, 0}} ,{{253, 77}, {141, 47, 0}} ,{{207, 77}, {95, 47, 0}} ,{{232, 77}, {120, 47, 0}} ,{{129, 77}, {17, 47, 0}} ,{{187, 77}, {75, 47, 0}} ,{{154, 77}, {42, 47, 0}} ,{{36, 78}, {180, 47, 0}} ,{{32, 78}, {176, 47, 0}} ,{{34, 78}, {178, 47, 0}} ,{{121, 77}, {9, 47, 0}} ,{{119, 77}, {7, 47, 0}} ,{{211, 77}, {99, 47, 0}} ,{{113, 77}, {1, 47, 0}} ,{{23, 78}, {167, 47, 0}} ,{{165, 77}, {53, 47, 0}} ,{{120, 77}, {8, 47, 0}} ,{{241, 77}, {129, 47, 0}} ,{{208, 77}, {96, 47, 0}} ,{{57, 78}, {201, 47, 0}} ,{{242, 77}, {130, 47, 0}} ,{{185, 77}, {73, 47, 0}} ,{{16, 78}, {160, 47, 0}} ,{{245, 77}, {133, 47, 0}} ,{{25, 78}, {169, 47, 0}} ,{{157, 77}, {45, 47, 0}} ,{{141, 77}, {29, 47, 0}} ,{{233, 77}, {121, 47, 0}} ,{{64, 78}, {208, 47, 0}} ,{{182, 77}, {70, 47, 0}} ,{{236, 77}, {124, 47, 0}} ,{{112, 77}, {0, 47, 0}} ,{{160, 77}, {48, 47, 0}} ,{{128, 77}, {16, 47, 0}} ,{{247, 77}, {135, 47, 0}} ,{{7, 78}, {151, 47, 0}} ,{{238, 77}, {126, 47, 0}} ,{{130, 77}, {18, 47, 0}} ,{{139, 77}, {27, 47, 0}} ,{{206, 77}, {94, 47, 0}} ,{{28, 78}, {172, 47, 0}} ,{{177, 77}, {65, 47, 0}} ,{{63, 78}, {207, 47, 0}} ,{{10, 78}, {154, 47, 0}} ,{{230, 77}, {118, 47, 0}} ,{{133, 77}, {21, 47, 0}} ,{{158, 77}, {46, 47, 0}} ,{{151, 77}, {39, 47, 0}} ,{{11, 78}, {155, 47, 0}} ,{{47, 78}, {191, 47, 0}} ,{{52, 78}, {196, 47, 0}} ,{{184, 77}, {72, 47, 0}} ,{{144, 77}, {32, 47, 0}} ,{{178, 77}, {66, 47, 0}} ,{{137, 77}, {25, 47, 0}} ,{{116, 77}, {4, 47, 0}} ,{{2, 78}, {146, 47, 0}} ,{{243, 77}, {131, 47, 0}} ,{{234, 77}, {122, 47, 0}} ,{{9, 78}, {153, 47, 0}} ,{{167, 77}, {55, 47, 0}} ,{{27, 78}, {171, 47, 0}} ,{{163, 77}, {51, 47, 0}} ,{{215, 77}, {103, 47, 0}} ,{{231, 77}, {119, 47, 0}} ,{{218, 77}, {106, 47, 0}} ,{{115, 77}, {3, 47, 0}} ,{{26, 78}, {170, 47, 0}} ,{{202, 77}, {90, 47, 0}} ,{{153, 77}, {41, 47, 0}} ,{{169, 77}, {57, 47, 0}} ,{{35, 78}, {179, 47, 0}} ,{{221, 77}, {109, 47, 0}} ,{{4, 78}, {148, 47, 0}} ,{{224, 77}, {112, 47, 0}} ,{{132, 77}, {20, 47, 0}} ,{{156, 77}, {44, 47, 0}} ,{{181, 77}, {69, 47, 0}} ,{{228, 77}, {116, 47, 0}} ,{{195, 77}, {83, 47, 0}} ,{{171, 77}, {59, 47, 0}} ,{{223, 77}, {111, 47, 0}} ,{{188, 77}, {76, 47, 0}} ,{{249, 77}, {137, 47, 0}} ,{{183, 77}, {71, 47, 0}} ,{{210, 77}, {98, 47, 0}} ,{{127, 77}, {15, 47, 0}} ,{{44, 78}, {188, 47, 0}} ,{{33, 78}, {177, 47, 0}} ,{{135, 77}, {23, 47, 0}} ,{{252, 77}, {140, 47, 0}} ,{{209, 77}, {97, 47, 0}} ,{{246, 77}, {134, 47, 0}} ,{{66, 78}, {210, 47, 0}} ,{{225, 77}, {113, 47, 0}} ,{{186, 77}, {74, 47, 0}} ,{{61, 78}, {205, 47, 0}} ,{{161, 77}, {49, 47, 0}} ,{{68, 78}, {212, 47, 0}} ,{{118, 77}, {6, 47, 0}} ,{{166, 77}, {54, 47, 0}} ,{{212, 77}, {100, 47, 0}} ,{{5, 78}, {149, 47, 0}} ,{{21, 78}, {165, 47, 0}} ,{{17, 78}, {161, 47, 0}} ,{{255, 77}, {143, 47, 0}} ,{{196, 77}, {84, 47, 0}} ,{{190, 77}, {78, 47, 0}} ,{{1, 78}, {145, 47, 0}} ,{{54, 78}, {198, 47, 0}} ,{{217, 77}, {105, 47, 0}} ,{{37, 78}, {181, 47, 0}} ,{{19, 78}, {163, 47, 0}} ,{{149, 77}, {37, 47, 0}} ,{{159, 77}, {47, 47, 0}} ,{{131, 77}, {19, 47, 0}} ,{{30, 78}, {174, 47, 0}} ,{{56, 78}, {200, 47, 0}} ,{{60, 48}, {214, 12, 0}} ,{{74, 48}, {238, 12, 0}} ,{{71, 48}, {235, 12, 0}} ,{{70, 48}, {234, 12, 0}} ,{{75, 48}, {239, 12, 0}} ,{{67, 48}, {231, 12, 0}} ,{{73, 48}, {237, 12, 0}} ,{{72, 48}, {236, 12, 0}} ,{{69, 48}, {233, 12, 0}} ,{{68, 48}, {232, 12, 0}} ,{{66, 48}, {230, 12, 0}} ,{{59, 48}, {213, 12, 0}} ,{{250, 47}, {133, 12, 0}} ,{{251, 47}, {134, 12, 0}} ,{{4, 48}, {144, 12, 0}} ,{{7, 48}, {148, 12, 0}} ,{{30, 48}, {172, 12, 0}} ,{{31, 48}, {173, 12, 0}} ,{{13, 48}, {154, 12, 0}} ,{{14, 48}, {155, 12, 0}} ,{{25, 48}, {166, 12, 0}} ,{{20, 48}, {161, 12, 0}} ,{{21, 48}, {162, 12, 0}} ,{{26, 48}, {167, 12, 0}} ,{{2, 48}, {142, 12, 0}} ,{{3, 48}, {143, 12, 0}} ,{{61, 48}, {222, 12, 0}} ,{{10, 48}, {151, 12, 0}} ,{{11, 48}, {152, 12, 0}} ,{{42, 48}, {185, 12, 0}} ,{{252, 47}, {135, 12, 0}} ,{{253, 47}, {136, 12, 0}} ,{{15, 48}, {156, 12, 0}} ,{{16, 48}, {157, 12, 0}} ,{{8, 48}, {149, 12, 0}} ,{{9, 48}, {150, 12, 0}} ,{{36, 48}, {178, 12, 0}} ,{{37, 48}, {179, 12, 0}} ,{{32, 48}, {174, 12, 0}} ,{{27, 48}, {168, 12, 0}} ,{{12, 48}, {153, 12, 0}} ,{{22, 48}, {163, 12, 0}} ,{{17, 48}, {158, 12, 0}} ,{{5, 48}, {146, 12, 0}} ,{{6, 48}, {147, 12, 0}} ,{{28, 48}, {170, 12, 0}} ,{{29, 48}, {171, 12, 0}} ,{{34, 48}, {176, 12, 0}} ,{{35, 48}, {177, 12, 0}} ,{{41, 48}, {184, 12, 0}} ,{{39, 48}, {182, 12, 0}} ,{{40, 48}, {183, 12, 0}} ,{{23, 48}, {164, 12, 0}} ,{{24, 48}, {165, 12, 0}} ,{{18, 48}, {159, 12, 0}} ,{{19, 48}, {160, 12, 0}} ,{{254, 47}, {137, 12, 0}} ,{{255, 47}, {138, 12, 0}} ,{{38, 48}, {181, 12, 0}} ,{{1, 48}, {140, 12, 0}} ,{{63, 48}, {225, 12, 0}} ,{{0, 48}, {139, 12, 0}} ,{{62, 48}, {224, 12, 0}} ,{{33, 48}, {175, 12, 0}} ,{{248, 47}, {130, 12, 0}} ,{{44, 48}, {189, 12, 0}} ,{{76, 48}, {241, 12, 0}} ,{{43, 48}, {188, 12, 0}} ,{{77, 48}, {242, 12, 0}} ,{{58, 48}, {205, 12, 0}} ,{{249, 47}, {131, 12, 0}} ,{{45, 48}, {190, 12, 0}} ,{{54, 48}, {200, 12, 0}} ,{{57, 48}, {204, 12, 0}} ,{{52, 48}, {198, 12, 0}} ,{{53, 48}, {199, 12, 0}} ,{{46, 48}, {191, 12, 0}} ,{{47, 48}, {192, 12, 0}} ,{{55, 48}, {202, 12, 0}} ,{{56, 48}, {203, 12, 0}} ,{{48, 48}, {193, 12, 0}} ,{{49, 48}, {194, 12, 0}} ,{{64, 48}, {226, 12, 0}} ,{{65, 48}, {227, 12, 0}} ,{{50, 48}, {195, 12, 0}} ,{{51, 48}, {196, 12, 0}} ,{{239, 78}, {160, 48, 0}} ,{{75, 79}, {252, 48, 0}} ,{{235, 78}, {156, 48, 0}} ,{{234, 78}, {155, 48, 0}} ,{{78, 79}, {255, 48, 0}} ,{{76, 79}, {253, 48, 0}} ,{{241, 78}, {162, 48, 0}} ,{{31, 79}, {208, 48, 0}} ,{{40, 79}, {217, 48, 0}} ,{{34, 79}, {211, 48, 0}} ,{{43, 79}, {220, 48, 0}} ,{{37, 79}, {214, 48, 0}} ,{{15, 79}, {192, 48, 0}} ,{{22, 79}, {199, 48, 0}} ,{{17, 79}, {194, 48, 0}} ,{{24, 79}, {201, 48, 0}} ,{{20, 79}, {197, 48, 0}} ,{{247, 78}, {168, 48, 0}} ,{{251, 78}, {172, 48, 0}} ,{{1, 79}, {178, 48, 0}} ,{{253, 78}, {174, 48, 0}} ,{{3, 79}, {180, 48, 0}} ,{{255, 78}, {176, 48, 0}} ,{{30, 79}, {207, 48, 0}} ,{{39, 79}, {216, 48, 0}} ,{{33, 79}, {210, 48, 0}} ,{{42, 79}, {219, 48, 0}} ,{{36, 79}, {213, 48, 0}} ,{{243, 78}, {164, 48, 0}} ,{{250, 78}, {171, 48, 0}} ,{{0, 79}, {177, 48, 0}} ,{{252, 78}, {173, 48, 0}} ,{{2, 79}, {179, 48, 0}} ,{{254, 78}, {175, 48, 0}} ,{{45, 79}, {222, 48, 0}} ,{{48, 79}, {225, 48, 0}} ,{{46, 79}, {223, 48, 0}} ,{{49, 79}, {226, 48, 0}} ,{{47, 79}, {224, 48, 0}} ,{{66, 79}, {243, 48, 0}} ,{{25, 79}, {202, 48, 0}} ,{{28, 79}, {205, 48, 0}} ,{{26, 79}, {203, 48, 0}} ,{{29, 79}, {206, 48, 0}} ,{{27, 79}, {204, 48, 0}} ,{{249, 78}, {170, 48, 0}} ,{{32, 79}, {209, 48, 0}} ,{{41, 79}, {218, 48, 0}} ,{{35, 79}, {212, 48, 0}} ,{{44, 79}, {221, 48, 0}} ,{{38, 79}, {215, 48, 0}} ,{{56, 79}, {233, 48, 0}} ,{{59, 79}, {236, 48, 0}} ,{{57, 79}, {234, 48, 0}} ,{{60, 79}, {237, 48, 0}} ,{{58, 79}, {235, 48, 0}} ,{{4, 79}, {181, 48, 0}} ,{{10, 79}, {187, 48, 0}} ,{{6, 79}, {183, 48, 0}} ,{{240, 78}, {161, 48, 0}} ,{{246, 78}, {167, 48, 0}} ,{{39, 80}, {245, 49, 0}} ,{{42, 80}, {248, 49, 0}} ,{{40, 80}, {246, 49, 0}} ,{{43, 80}, {249, 49, 0}} ,{{41, 80}, {247, 49, 0}} ,{{242, 78}, {163, 48, 0}} ,{{68, 79}, {245, 48, 0}} ,{{69, 79}, {246, 48, 0}} ,{{34, 80}, {240, 49, 0}} ,{{44, 80}, {250, 49, 0}} ,{{38, 80}, {244, 49, 0}} ,{{248, 78}, {169, 48, 0}} ,{{45, 80}, {251, 49, 0}} ,{{48, 80}, {254, 49, 0}} ,{{46, 80}, {252, 49, 0}} ,{{49, 80}, {255, 49, 0}} ,{{47, 80}, {253, 49, 0}} ,{{35, 80}, {241, 49, 0}} ,{{36, 80}, {242, 49, 0}} ,{{37, 80}, {243, 49, 0}} ,{{18, 79}, {195, 48, 0}} ,{{244, 78}, {165, 48, 0}} ,{{61, 79}, {238, 48, 0}} ,{{50, 79}, {227, 48, 0}} ,{{54, 79}, {231, 48, 0}} ,{{52, 79}, {229, 48, 0}} ,{{12, 79}, {189, 48, 0}} ,{{8, 79}, {185, 48, 0}} ,{{14, 79}, {191, 48, 0}} ,{{21, 79}, {198, 48, 0}} ,{{16, 79}, {193, 48, 0}} ,{{23, 79}, {200, 48, 0}} ,{{19, 79}, {196, 48, 0}} ,{{245, 78}, {166, 48, 0}} ,{{70, 79}, {247, 48, 0}} ,{{72, 79}, {249, 48, 0}} ,{{71, 79}, {248, 48, 0}} ,{{73, 79}, {250, 48, 0}} ,{{67, 79}, {244, 48, 0}} ,{{62, 79}, {239, 48, 0}} ,{{64, 79}, {241, 48, 0}} ,{{63, 79}, {240, 48, 0}} ,{{65, 79}, {242, 48, 0}} ,{{51, 79}, {228, 48, 0}} ,{{55, 79}, {232, 48, 0}} ,{{53, 79}, {230, 48, 0}} ,{{5, 79}, {182, 48, 0}} ,{{11, 79}, {188, 48, 0}} ,{{7, 79}, {184, 48, 0}} ,{{13, 79}, {190, 48, 0}} ,{{9, 79}, {186, 48, 0}} ,{{74, 79}, {251, 48, 0}} ,{{77, 79}, {254, 48, 0}} ,{{171, 90}, {8, 169, 0}} ,{{168, 90}, {5, 169, 0}} ,{{167, 90}, {4, 169, 0}} ,{{172, 90}, {9, 169, 0}} ,{{164, 90}, {1, 169, 0}} ,{{170, 90}, {7, 169, 0}} ,{{169, 90}, {6, 169, 0}} ,{{166, 90}, {3, 169, 0}} ,{{165, 90}, {2, 169, 0}} ,{{163, 90}, {0, 169, 0}} ,{{197, 90}, {34, 169, 0}} ,{{188, 90}, {25, 169, 0}} ,{{196, 90}, {33, 169, 0}} ,{{187, 90}, {24, 169, 0}} ,{{175, 90}, {12, 169, 0}} ,{{194, 90}, {31, 169, 0}} ,{{182, 90}, {19, 169, 0}} ,{{199, 90}, {36, 169, 0}} ,{{173, 90}, {10, 169, 0}} ,{{174, 90}, {11, 169, 0}} ,{{191, 90}, {28, 169, 0}} ,{{186, 90}, {23, 169, 0}} ,{{183, 90}, {20, 169, 0}} ,{{176, 90}, {13, 169, 0}} ,{{180, 90}, {17, 169, 0}} ,{{198, 90}, {35, 169, 0}} ,{{200, 90}, {37, 169, 0}} ,{{184, 90}, {21, 169, 0}} ,{{185, 90}, {22, 169, 0}} ,{{189, 90}, {26, 169, 0}} ,{{177, 90}, {14, 169, 0}} ,{{178, 90}, {15, 169, 0}} ,{{181, 90}, {18, 169, 0}} ,{{193, 90}, {30, 169, 0}} ,{{195, 90}, {32, 169, 0}} ,{{192, 90}, {29, 169, 0}} ,{{190, 90}, {27, 169, 0}} ,{{179, 90}, {16, 169, 0}} ,{{209, 90}, {46, 169, 0}} ,{{210, 90}, {47, 169, 0}} ,{{207, 90}, {44, 169, 0}} ,{{208, 90}, {45, 169, 0}} ,{{206, 90}, {43, 169, 0}} ,{{202, 90}, {39, 169, 0}} ,{{204, 90}, {41, 169, 0}} ,{{205, 90}, {42, 169, 0}} ,{{203, 90}, {40, 169, 0}} ,{{201, 90}, {38, 169, 0}} ,{{65, 65}, {42, 33, 0}} ,{{57, 67}, {40, 35, 0}} ,{{83, 146}, {67, 10, 1}} ,{{80, 146}, {64, 10, 1}} ,{{82, 146}, {66, 10, 1}} ,{{81, 146}, {65, 10, 1}} ,{{32, 146}, {0, 10, 1}} ,{{62, 146}, {38, 10, 1}} ,{{63, 146}, {39, 10, 1}} ,{{46, 146}, {21, 10, 1}} ,{{47, 146}, {22, 10, 1}} ,{{57, 146}, {33, 10, 1}} ,{{52, 146}, {28, 10, 1}} ,{{53, 146}, {29, 10, 1}} ,{{58, 146}, {34, 10, 1}} ,{{44, 146}, {18, 10, 1}} ,{{45, 146}, {19, 10, 1}} ,{{73, 146}, {49, 10, 1}} ,{{48, 146}, {23, 10, 1}} ,{{42, 146}, {16, 10, 1}} ,{{43, 146}, {17, 10, 1}} ,{{74, 146}, {50, 10, 1}} ,{{67, 146}, {43, 10, 1}} ,{{64, 146}, {40, 10, 1}} ,{{59, 146}, {35, 10, 1}} ,{{54, 146}, {30, 10, 1}} ,{{49, 146}, {25, 10, 1}} ,{{60, 146}, {36, 10, 1}} ,{{61, 146}, {37, 10, 1}} ,{{66, 146}, {42, 10, 1}} ,{{71, 146}, {47, 10, 1}} ,{{69, 146}, {45, 10, 1}} ,{{70, 146}, {46, 10, 1}} ,{{55, 146}, {31, 10, 1}} ,{{56, 146}, {32, 10, 1}} ,{{50, 146}, {26, 10, 1}} ,{{51, 146}, {27, 10, 1}} ,{{75, 146}, {51, 10, 1}} ,{{68, 146}, {44, 10, 1}} ,{{65, 146}, {41, 10, 1}} ,{{72, 146}, {48, 10, 1}} ,{{86, 146}, {70, 10, 1}} ,{{87, 146}, {71, 10, 1}} ,{{84, 146}, {68, 10, 1}} ,{{85, 146}, {69, 10, 1}} ,{{90, 146}, {82, 10, 1}} ,{{91, 146}, {83, 10, 1}} ,{{94, 146}, {86, 10, 1}} ,{{88, 146}, {80, 10, 1}} ,{{95, 146}, {87, 10, 1}} ,{{96, 146}, {88, 10, 1}} ,{{93, 146}, {85, 10, 1}} ,{{92, 146}, {84, 10, 1}} ,{{89, 146}, {81, 10, 1}} ,{{40, 146}, {14, 10, 1}} ,{{76, 146}, {56, 10, 1}} ,{{77, 146}, {57, 10, 1}} ,{{78, 146}, {58, 10, 1}} ,{{39, 146}, {13, 10, 1}} ,{{41, 146}, {15, 10, 1}} ,{{79, 146}, {63, 10, 1}} ,{{38, 146}, {12, 10, 1}} ,{{36, 146}, {5, 10, 1}} ,{{33, 146}, {1, 10, 1}} ,{{37, 146}, {6, 10, 1}} ,{{34, 146}, {2, 10, 1}} ,{{35, 146}, {3, 10, 1}} ,{{194, 57}, {219, 23, 0}} ,{{205, 57}, {232, 23, 0}} ,{{202, 57}, {229, 23, 0}} ,{{201, 57}, {228, 23, 0}} ,{{206, 57}, {233, 23, 0}} ,{{198, 57}, {225, 23, 0}} ,{{204, 57}, {231, 23, 0}} ,{{203, 57}, {230, 23, 0}} ,{{200, 57}, {227, 23, 0}} ,{{199, 57}, {226, 23, 0}} ,{{197, 57}, {224, 23, 0}} ,{{148, 57}, {173, 23, 0}} ,{{149, 57}, {174, 23, 0}} ,{{139, 57}, {164, 23, 0}} ,{{151, 57}, {176, 23, 0}} ,{{138, 57}, {163, 23, 0}} ,{{154, 57}, {179, 23, 0}} ,{{150, 57}, {175, 23, 0}} ,{{140, 57}, {165, 23, 0}} ,{{141, 57}, {166, 23, 0}} ,{{152, 57}, {177, 23, 0}} ,{{153, 57}, {178, 23, 0}} ,{{142, 57}, {167, 23, 0}} ,{{143, 57}, {168, 23, 0}} ,{{144, 57}, {169, 23, 0}} ,{{145, 57}, {170, 23, 0}} ,{{146, 57}, {171, 23, 0}} ,{{147, 57}, {172, 23, 0}} ,{{123, 57}, {148, 23, 0}} ,{{108, 57}, {133, 23, 0}} ,{{109, 57}, {134, 23, 0}} ,{{111, 57}, {136, 23, 0}} ,{{110, 57}, {135, 23, 0}} ,{{113, 57}, {138, 23, 0}} ,{{115, 57}, {140, 23, 0}} ,{{135, 57}, {160, 23, 0}} ,{{103, 57}, {128, 23, 0}} ,{{104, 57}, {129, 23, 0}} ,{{106, 57}, {131, 23, 0}} ,{{105, 57}, {130, 23, 0}} ,{{136, 57}, {161, 23, 0}} ,{{130, 57}, {155, 23, 0}} ,{{127, 57}, {152, 23, 0}} ,{{107, 57}, {132, 23, 0}} ,{{117, 57}, {142, 23, 0}} ,{{122, 57}, {147, 23, 0}} ,{{112, 57}, {137, 23, 0}} ,{{124, 57}, {149, 23, 0}} ,{{126, 57}, {151, 23, 0}} ,{{125, 57}, {150, 23, 0}} ,{{137, 57}, {162, 23, 0}} ,{{129, 57}, {154, 23, 0}} ,{{134, 57}, {159, 23, 0}} ,{{132, 57}, {157, 23, 0}} ,{{133, 57}, {158, 23, 0}} ,{{118, 57}, {143, 23, 0}} ,{{119, 57}, {144, 23, 0}} ,{{121, 57}, {146, 23, 0}} ,{{120, 57}, {145, 23, 0}} ,{{114, 57}, {139, 23, 0}} ,{{116, 57}, {141, 23, 0}} ,{{131, 57}, {156, 23, 0}} ,{{128, 57}, {153, 23, 0}} ,{{182, 57}, {207, 23, 0}} ,{{196, 57}, {221, 23, 0}} ,{{195, 57}, {220, 23, 0}} ,{{178, 57}, {203, 23, 0}} ,{{188, 57}, {213, 23, 0}} ,{{186, 57}, {211, 23, 0}} ,{{191, 57}, {216, 23, 0}} ,{{189, 57}, {214, 23, 0}} ,{{185, 57}, {210, 23, 0}} ,{{181, 57}, {206, 23, 0}} ,{{187, 57}, {212, 23, 0}} ,{{193, 57}, {218, 23, 0}} ,{{190, 57}, {215, 23, 0}} ,{{176, 57}, {201, 23, 0}} ,{{173, 57}, {198, 23, 0}} ,{{192, 57}, {217, 23, 0}} ,{{174, 57}, {199, 23, 0}} ,{{179, 57}, {204, 23, 0}} ,{{183, 57}, {208, 23, 0}} ,{{180, 57}, {205, 23, 0}} ,{{177, 57}, {202, 23, 0}} ,{{184, 57}, {209, 23, 0}} ,{{175, 57}, {200, 23, 0}} ,{{118, 59}, {227, 25, 0}} ,{{134, 59}, {243, 25, 0}} ,{{119, 59}, {228, 25, 0}} ,{{135, 59}, {244, 25, 0}} ,{{128, 59}, {237, 25, 0}} ,{{144, 59}, {253, 25, 0}} ,{{129, 59}, {238, 25, 0}} ,{{145, 59}, {254, 25, 0}} ,{{126, 59}, {235, 25, 0}} ,{{142, 59}, {251, 25, 0}} ,{{127, 59}, {236, 25, 0}} ,{{143, 59}, {252, 25, 0}} ,{{130, 59}, {239, 25, 0}} ,{{146, 59}, {255, 25, 0}} ,{{125, 59}, {234, 25, 0}} ,{{141, 59}, {250, 25, 0}} ,{{210, 57}, {243, 23, 0}} ,{{211, 57}, {244, 23, 0}} ,{{208, 57}, {241, 23, 0}} ,{{209, 57}, {242, 23, 0}} ,{{212, 57}, {245, 23, 0}} ,{{215, 57}, {248, 23, 0}} ,{{216, 57}, {249, 23, 0}} ,{{213, 57}, {246, 23, 0}} ,{{214, 57}, {247, 23, 0}} ,{{207, 57}, {240, 23, 0}} ,{{116, 59}, {225, 25, 0}} ,{{132, 59}, {241, 25, 0}} ,{{115, 59}, {224, 25, 0}} ,{{117, 59}, {226, 25, 0}} ,{{133, 59}, {242, 25, 0}} ,{{123, 59}, {232, 25, 0}} ,{{139, 59}, {248, 25, 0}} ,{{124, 59}, {233, 25, 0}} ,{{140, 59}, {249, 25, 0}} ,{{121, 59}, {230, 25, 0}} ,{{137, 59}, {246, 25, 0}} ,{{122, 59}, {231, 25, 0}} ,{{138, 59}, {247, 25, 0}} ,{{120, 59}, {229, 25, 0}} ,{{136, 59}, {245, 25, 0}} ,{{131, 59}, {240, 25, 0}} ,{{156, 57}, {181, 23, 0}} ,{{155, 57}, {180, 23, 0}} ,{{157, 57}, {182, 23, 0}} ,{{169, 57}, {194, 23, 0}} ,{{170, 57}, {195, 23, 0}} ,{{172, 57}, {197, 23, 0}} ,{{168, 57}, {193, 23, 0}} ,{{158, 57}, {183, 23, 0}} ,{{167, 57}, {192, 23, 0}} ,{{159, 57}, {184, 23, 0}} ,{{165, 57}, {190, 23, 0}} ,{{171, 57}, {196, 23, 0}} ,{{162, 57}, {187, 23, 0}} ,{{164, 57}, {189, 23, 0}} ,{{163, 57}, {188, 23, 0}} ,{{160, 57}, {185, 23, 0}} ,{{166, 57}, {191, 23, 0}} ,{{161, 57}, {186, 23, 0}} ,{{234, 64}, {173, 32, 0}} ,{{176, 80}, {127, 50, 0}} ,{{36, 165}, {1, 0, 14}} ,{{135, 49}, {204, 14, 0}} ,{{145, 49}, {216, 14, 0}} ,{{142, 49}, {213, 14, 0}} ,{{141, 49}, {212, 14, 0}} ,{{146, 49}, {217, 14, 0}} ,{{138, 49}, {209, 14, 0}} ,{{144, 49}, {215, 14, 0}} ,{{143, 49}, {214, 14, 0}} ,{{140, 49}, {211, 14, 0}} ,{{139, 49}, {210, 14, 0}} ,{{137, 49}, {208, 14, 0}} ,{{111, 49}, {175, 14, 0}} ,{{148, 49}, {221, 14, 0}} ,{{147, 49}, {220, 14, 0}} ,{{130, 49}, {198, 14, 0}} ,{{96, 49}, {154, 14, 0}} ,{{88, 49}, {136, 14, 0}} ,{{91, 49}, {148, 14, 0}} ,{{101, 49}, {159, 14, 0}} ,{{99, 49}, {157, 14, 0}} ,{{108, 49}, {171, 14, 0}} ,{{110, 49}, {174, 14, 0}} ,{{85, 49}, {130, 14, 0}} ,{{86, 49}, {132, 14, 0}} ,{{84, 49}, {129, 14, 0}} ,{{104, 49}, {163, 14, 0}} ,{{105, 49}, {165, 14, 0}} ,{{102, 49}, {161, 14, 0}} ,{{87, 49}, {135, 14, 0}} ,{{95, 49}, {153, 14, 0}} ,{{90, 49}, {141, 14, 0}} ,{{109, 49}, {173, 14, 0}} ,{{98, 49}, {156, 14, 0}} ,{{100, 49}, {158, 14, 0}} ,{{97, 49}, {155, 14, 0}} ,{{107, 49}, {170, 14, 0}} ,{{89, 49}, {138, 14, 0}} ,{{93, 49}, {150, 14, 0}} ,{{94, 49}, {151, 14, 0}} ,{{92, 49}, {149, 14, 0}} ,{{106, 49}, {167, 14, 0}} ,{{103, 49}, {162, 14, 0}} ,{{136, 49}, {205, 14, 0}} ,{{123, 49}, {188, 14, 0}} ,{{124, 49}, {189, 14, 0}} ,{{134, 49}, {203, 14, 0}} ,{{131, 49}, {200, 14, 0}} ,{{132, 49}, {201, 14, 0}} ,{{133, 49}, {202, 14, 0}} ,{{112, 49}, {176, 14, 0}} ,{{114, 49}, {178, 14, 0}} ,{{129, 49}, {196, 14, 0}} ,{{115, 49}, {179, 14, 0}} ,{{128, 49}, {195, 14, 0}} ,{{125, 49}, {192, 14, 0}} ,{{126, 49}, {193, 14, 0}} ,{{116, 49}, {180, 14, 0}} ,{{117, 49}, {181, 14, 0}} ,{{113, 49}, {177, 14, 0}} ,{{122, 49}, {187, 14, 0}} ,{{127, 49}, {194, 14, 0}} ,{{120, 49}, {184, 14, 0}} ,{{121, 49}, {185, 14, 0}} ,{{118, 49}, {182, 14, 0}} ,{{119, 49}, {183, 14, 0}} ,{{92, 74}, {171, 42, 0}} ,{{94, 74}, {173, 42, 0}} ,{{187, 69}, {239, 37, 0}} ,{{138, 71}, {217, 39, 0}} ,{{207, 73}, {30, 42, 0}} ,{{187, 146}, {61, 11, 1}} ,{{189, 146}, {63, 11, 1}} ,{{173, 74}, {252, 42, 0}} ,{{186, 146}, {60, 11, 1}} ,{{188, 146}, {62, 11, 1}} ,{{137, 71}, {216, 39, 0}} ,{{10, 70}, {62, 38, 0}} ,{{4, 38}, {65, 0, 0}} ,{{104, 89}, {50, 167, 0}} ,{{104, 38}, {198, 0, 0}} ,{{158, 39}, {252, 1, 0}} ,{{132, 39}, {226, 1, 0}} ,{{43, 39}, {137, 1, 0}} ,{{115, 75}, {109, 44, 0}} ,{{106, 89}, {52, 167, 0}} ,{{108, 89}, {54, 167, 0}} ,{{110, 89}, {56, 167, 0}} ,{{112, 89}, {58, 167, 0}} ,{{114, 89}, {60, 167, 0}} ,{{99, 38}, {193, 0, 0}} ,{{164, 38}, {2, 1, 0}} ,{{21, 63}, {174, 30, 0}} ,{{29, 63}, {182, 30, 0}} ,{{23, 63}, {176, 30, 0}} ,{{25, 63}, {178, 30, 0}} ,{{27, 63}, {180, 30, 0}} ,{{111, 39}, {205, 1, 0}} ,{{100, 38}, {194, 0, 0}} ,{{11, 63}, {164, 30, 0}} ,{{19, 63}, {172, 30, 0}} ,{{13, 63}, {166, 30, 0}} ,{{15, 63}, {168, 30, 0}} ,{{17, 63}, {170, 30, 0}} ,{{102, 38}, {196, 0, 0}} ,{{128, 39}, {222, 1, 0}} ,{{200, 39}, {38, 2, 0}} ,{{130, 39}, {224, 1, 0}} ,{{7, 63}, {160, 30, 0}} ,{{162, 39}, {0, 2, 0}} ,{{98, 38}, {192, 0, 0}} ,{{9, 63}, {162, 30, 0}} ,{{164, 39}, {2, 2, 0}} ,{{162, 38}, {0, 1, 0}} ,{{166, 38}, {4, 1, 0}} ,{{103, 38}, {197, 0, 0}} ,{{156, 39}, {250, 1, 0}} ,{{103, 62}, {0, 30, 0}} ,{{220, 39}, {58, 2, 0}} ,{{101, 38}, {195, 0, 0}} ,{{5, 38}, {66, 0, 0}} ,{{124, 89}, {70, 167, 0}} ,{{105, 62}, {2, 30, 0}} ,{{107, 62}, {4, 30, 0}} ,{{35, 39}, {129, 1, 0}} ,{{109, 62}, {6, 30, 0}} ,{{229, 39}, {67, 2, 0}} ,{{36, 39}, {130, 1, 0}} ,{{6, 38}, {67, 0, 0}} ,{{164, 89}, {110, 167, 0}} ,{{98, 89}, {44, 167, 0}} ,{{100, 89}, {46, 167, 0}} ,{{168, 38}, {6, 1, 0}} ,{{174, 38}, {12, 1, 0}} ,{{105, 38}, {199, 0, 0}} ,{{111, 62}, {8, 30, 0}} ,{{170, 38}, {8, 1, 0}} ,{{172, 38}, {10, 1, 0}} ,{{41, 39}, {135, 1, 0}} ,{{221, 39}, {59, 2, 0}} ,{{7, 38}, {68, 0, 0}} ,{{147, 39}, {241, 1, 0}} ,{{102, 39}, {196, 1, 0}} ,{{176, 38}, {14, 1, 0}} ,{{119, 62}, {16, 30, 0}} ,{{121, 62}, {18, 30, 0}} ,{{113, 62}, {10, 30, 0}} ,{{115, 62}, {12, 30, 0}} ,{{44, 39}, {138, 1, 0}} ,{{117, 62}, {14, 30, 0}} ,{{148, 39}, {242, 1, 0}} ,{{103, 39}, {197, 1, 0}} ,{{178, 38}, {16, 1, 0}} ,{{45, 39}, {139, 1, 0}} ,{{8, 38}, {69, 0, 0}} ,{{90, 89}, {36, 167, 0}} ,{{88, 89}, {34, 167, 0}} ,{{236, 38}, {74, 1, 0}} ,{{75, 39}, {169, 1, 0}} ,{{160, 89}, {106, 167, 0}} ,{{114, 38}, {208, 0, 0}} ,{{89, 39}, {183, 1, 0}} ,{{90, 39}, {184, 1, 0}} ,{{144, 39}, {238, 1, 0}} ,{{107, 38}, {201, 0, 0}} ,{{182, 38}, {20, 1, 0}} ,{{188, 38}, {26, 1, 0}} ,{{202, 39}, {40, 2, 0}} ,{{131, 62}, {28, 30, 0}} ,{{108, 38}, {202, 0, 0}} ,{{37, 63}, {190, 30, 0}} ,{{45, 63}, {198, 30, 0}} ,{{39, 63}, {192, 30, 0}} ,{{41, 63}, {194, 30, 0}} ,{{43, 63}, {196, 30, 0}} ,{{127, 62}, {24, 30, 0}} ,{{109, 38}, {203, 0, 0}} ,{{184, 38}, {22, 1, 0}} ,{{31, 63}, {184, 30, 0}} ,{{166, 39}, {4, 2, 0}} ,{{106, 38}, {200, 0, 0}} ,{{33, 63}, {186, 30, 0}} ,{{168, 39}, {6, 2, 0}} ,{{180, 38}, {18, 1, 0}} ,{{125, 62}, {22, 30, 0}} ,{{123, 62}, {20, 30, 0}} ,{{186, 38}, {24, 1, 0}} ,{{232, 39}, {70, 2, 0}} ,{{35, 63}, {188, 30, 0}} ,{{129, 62}, {26, 30, 0}} ,{{9, 38}, {70, 0, 0}} ,{{133, 62}, {30, 30, 0}} ,{{51, 39}, {145, 1, 0}} ,{{10, 38}, {71, 0, 0}} ,{{54, 39}, {148, 1, 0}} ,{{227, 39}, {65, 2, 0}} ,{{150, 39}, {244, 1, 0}} ,{{192, 38}, {30, 1, 0}} ,{{136, 39}, {230, 1, 0}} ,{{196, 38}, {34, 1, 0}} ,{{190, 38}, {28, 1, 0}} ,{{194, 38}, {32, 1, 0}} ,{{53, 39}, {147, 1, 0}} ,{{135, 62}, {32, 30, 0}} ,{{134, 39}, {228, 1, 0}} ,{{11, 38}, {72, 0, 0}} ,{{123, 75}, {117, 44, 0}} ,{{92, 89}, {38, 167, 0}} ,{{152, 39}, {246, 1, 0}} ,{{145, 62}, {42, 30, 0}} ,{{192, 39}, {30, 2, 0}} ,{{143, 62}, {40, 30, 0}} ,{{198, 38}, {36, 1, 0}} ,{{109, 75}, {103, 44, 0}} ,{{141, 62}, {38, 30, 0}} ,{{137, 62}, {34, 30, 0}} ,{{139, 62}, {36, 30, 0}} ,{{200, 38}, {38, 1, 0}} ,{{12, 38}, {73, 0, 0}} ,{{175, 89}, {121, 167, 0}} ,{{177, 89}, {123, 167, 0}} ,{{179, 89}, {125, 167, 0}} ,{{184, 89}, {130, 167, 0}} ,{{186, 89}, {132, 167, 0}} ,{{188, 89}, {134, 167, 0}} ,{{56, 39}, {150, 1, 0}} ,{{162, 89}, {108, 167, 0}} ,{{111, 38}, {205, 0, 0}} ,{{206, 38}, {44, 1, 0}} ,{{113, 39}, {207, 1, 0}} ,{{112, 38}, {206, 0, 0}} ,{{113, 38}, {207, 0, 0}} ,{{149, 62}, {46, 30, 0}} ,{{210, 38}, {48, 1, 0}} ,{{49, 63}, {202, 30, 0}} ,{{170, 39}, {8, 2, 0}} ,{{110, 38}, {204, 0, 0}} ,{{47, 63}, {200, 30, 0}} ,{{172, 39}, {10, 2, 0}} ,{{204, 38}, {42, 1, 0}} ,{{208, 38}, {46, 1, 0}} ,{{57, 39}, {151, 1, 0}} ,{{202, 38}, {40, 1, 0}} ,{{147, 62}, {44, 30, 0}} ,{{13, 38}, {74, 0, 0}} ,{{214, 38}, {52, 1, 0}} ,{{234, 39}, {72, 2, 0}} ,{{14, 38}, {75, 0, 0}} ,{{151, 62}, {48, 30, 0}} ,{{138, 39}, {232, 1, 0}} ,{{216, 38}, {54, 1, 0}} ,{{111, 75}, {105, 44, 0}} ,{{120, 89}, {66, 167, 0}} ,{{153, 62}, {50, 30, 0}} ,{{58, 39}, {152, 1, 0}} ,{{155, 62}, {52, 30, 0}} ,{{118, 89}, {64, 167, 0}} ,{{122, 89}, {68, 167, 0}} ,{{15, 38}, {76, 0, 0}} ,{{105, 39}, {199, 1, 0}} ,{{219, 38}, {57, 1, 0}} ,{{223, 39}, {61, 2, 0}} ,{{223, 38}, {61, 1, 0}} ,{{221, 38}, {59, 1, 0}} ,{{163, 62}, {60, 30, 0}} ,{{157, 62}, {54, 30, 0}} ,{{159, 62}, {56, 30, 0}} ,{{102, 75}, {96, 44, 0}} ,{{126, 89}, {72, 167, 0}} ,{{161, 62}, {58, 30, 0}} ,{{225, 38}, {63, 1, 0}} ,{{104, 75}, {98, 44, 0}} ,{{106, 39}, {200, 1, 0}} ,{{227, 38}, {65, 1, 0}} ,{{16, 38}, {77, 0, 0}} ,{{97, 63}, {250, 30, 0}} ,{{99, 63}, {252, 30, 0}} ,{{165, 62}, {62, 30, 0}} ,{{167, 62}, {64, 30, 0}} ,{{169, 62}, {66, 30, 0}} ,{{116, 75}, {110, 44, 0}} ,{{17, 38}, {78, 0, 0}} ,{{108, 39}, {202, 1, 0}} ,{{229, 38}, {67, 1, 0}} ,{{233, 38}, {71, 1, 0}} ,{{231, 38}, {69, 1, 0}} ,{{177, 62}, {74, 30, 0}} ,{{171, 62}, {68, 30, 0}} ,{{173, 62}, {70, 30, 0}} ,{{154, 39}, {248, 1, 0}} ,{{63, 39}, {157, 1, 0}} ,{{175, 62}, {72, 30, 0}} ,{{194, 39}, {32, 2, 0}} ,{{109, 39}, {203, 1, 0}} ,{{115, 38}, {209, 0, 0}} ,{{18, 38}, {79, 0, 0}} ,{{68, 39}, {162, 1, 0}} ,{{132, 89}, {78, 167, 0}} ,{{50, 39}, {144, 1, 0}} ,{{40, 39}, {134, 1, 0}} ,{{196, 39}, {34, 2, 0}} ,{{117, 38}, {211, 0, 0}} ,{{240, 38}, {78, 1, 0}} ,{{115, 39}, {209, 1, 0}} ,{{118, 38}, {212, 0, 0}} ,{{55, 63}, {208, 30, 0}} ,{{63, 63}, {216, 30, 0}} ,{{57, 63}, {210, 30, 0}} ,{{59, 63}, {212, 30, 0}} ,{{61, 63}, {214, 30, 0}} ,{{120, 38}, {214, 0, 0}} ,{{204, 39}, {42, 2, 0}} ,{{208, 39}, {46, 2, 0}} ,{{210, 39}, {48, 2, 0}} ,{{51, 63}, {204, 30, 0}} ,{{242, 38}, {80, 1, 0}} ,{{174, 39}, {12, 2, 0}} ,{{116, 38}, {210, 0, 0}} ,{{53, 63}, {206, 30, 0}} ,{{66, 39}, {160, 1, 0}} ,{{65, 63}, {218, 30, 0}} ,{{73, 63}, {226, 30, 0}} ,{{67, 63}, {220, 30, 0}} ,{{69, 63}, {222, 30, 0}} ,{{71, 63}, {224, 30, 0}} ,{{176, 39}, {14, 2, 0}} ,{{128, 89}, {74, 167, 0}} ,{{130, 89}, {76, 167, 0}} ,{{238, 38}, {76, 1, 0}} ,{{185, 62}, {82, 30, 0}} ,{{183, 62}, {80, 30, 0}} ,{{65, 39}, {159, 1, 0}} ,{{140, 39}, {234, 1, 0}} ,{{142, 39}, {236, 1, 0}} ,{{122, 38}, {216, 0, 0}} ,{{160, 39}, {254, 1, 0}} ,{{119, 38}, {213, 0, 0}} ,{{179, 62}, {76, 30, 0}} ,{{181, 62}, {78, 30, 0}} ,{{206, 39}, {44, 2, 0}} ,{{19, 38}, {80, 0, 0}} ,{{187, 62}, {84, 30, 0}} ,{{189, 62}, {86, 30, 0}} ,{{136, 89}, {82, 167, 0}} ,{{70, 39}, {164, 1, 0}} ,{{138, 89}, {84, 167, 0}} ,{{105, 75}, {99, 44, 0}} ,{{134, 89}, {80, 167, 0}} ,{{20, 38}, {81, 0, 0}} ,{{142, 89}, {88, 167, 0}} ,{{140, 89}, {86, 167, 0}} ,{{21, 38}, {82, 0, 0}} ,{{116, 89}, {62, 167, 0}} ,{{48, 39}, {142, 1, 0}} ,{{146, 89}, {92, 167, 0}} ,{{144, 89}, {90, 167, 0}} ,{{246, 38}, {84, 1, 0}} ,{{250, 38}, {88, 1, 0}} ,{{248, 38}, {86, 1, 0}} ,{{191, 62}, {88, 30, 0}} ,{{193, 62}, {90, 30, 0}} ,{{195, 62}, {92, 30, 0}} ,{{178, 39}, {16, 2, 0}} ,{{180, 39}, {18, 2, 0}} ,{{197, 62}, {94, 30, 0}} ,{{238, 39}, {76, 2, 0}} ,{{106, 75}, {100, 44, 0}} ,{{22, 38}, {83, 0, 0}} ,{{193, 89}, {139, 167, 0}} ,{{49, 39}, {143, 1, 0}} ,{{5, 63}, {158, 30, 0}} ,{{236, 39}, {74, 2, 0}} ,{{252, 38}, {90, 1, 0}} ,{{203, 62}, {100, 30, 0}} ,{{2, 39}, {96, 1, 0}} ,{{205, 62}, {102, 30, 0}} ,{{0, 39}, {94, 1, 0}} ,{{254, 38}, {92, 1, 0}} ,{{186, 39}, {24, 2, 0}} ,{{199, 62}, {96, 30, 0}} ,{{201, 62}, {98, 30, 0}} ,{{207, 62}, {104, 30, 0}} ,{{132, 75}, {126, 44, 0}} ,{{23, 38}, {84, 0, 0}} ,{{128, 38}, {222, 0, 0}} ,{{154, 89}, {100, 167, 0}} ,{{156, 89}, {102, 167, 0}} ,{{94, 39}, {188, 1, 0}} ,{{38, 39}, {132, 1, 0}} ,{{73, 39}, {167, 1, 0}} ,{{96, 89}, {42, 167, 0}} ,{{117, 75}, {111, 44, 0}} ,{{118, 75}, {112, 44, 0}} ,{{180, 89}, {126, 167, 0}} ,{{182, 89}, {128, 167, 0}} ,{{62, 39}, {156, 1, 0}} ,{{231, 39}, {69, 2, 0}} ,{{94, 89}, {40, 167, 0}} ,{{6, 39}, {100, 1, 0}} ,{{4, 39}, {98, 1, 0}} ,{{215, 62}, {112, 30, 0}} ,{{188, 39}, {26, 2, 0}} ,{{224, 39}, {62, 2, 0}} ,{{209, 62}, {106, 30, 0}} ,{{211, 62}, {108, 30, 0}} ,{{78, 39}, {172, 1, 0}} ,{{213, 62}, {110, 30, 0}} ,{{80, 39}, {174, 1, 0}} ,{{8, 39}, {102, 1, 0}} ,{{24, 38}, {85, 0, 0}} ,{{83, 39}, {177, 1, 0}} ,{{230, 39}, {68, 2, 0}} ,{{124, 38}, {218, 0, 0}} ,{{14, 39}, {108, 1, 0}} ,{{117, 39}, {211, 1, 0}} ,{{125, 38}, {219, 0, 0}} ,{{221, 62}, {118, 30, 0}} ,{{126, 38}, {220, 0, 0}} ,{{121, 39}, {215, 1, 0}} ,{{123, 39}, {217, 1, 0}} ,{{125, 39}, {219, 1, 0}} ,{{119, 39}, {213, 1, 0}} ,{{217, 62}, {114, 30, 0}} ,{{75, 63}, {228, 30, 0}} ,{{18, 39}, {112, 1, 0}} ,{{182, 39}, {20, 2, 0}} ,{{123, 38}, {217, 0, 0}} ,{{77, 63}, {230, 30, 0}} ,{{81, 39}, {175, 1, 0}} ,{{79, 63}, {232, 30, 0}} ,{{87, 63}, {240, 30, 0}} ,{{81, 63}, {234, 30, 0}} ,{{83, 63}, {236, 30, 0}} ,{{85, 63}, {238, 30, 0}} ,{{184, 39}, {22, 2, 0}} ,{{12, 39}, {106, 1, 0}} ,{{225, 62}, {122, 30, 0}} ,{{20, 39}, {114, 1, 0}} ,{{16, 39}, {110, 1, 0}} ,{{10, 39}, {104, 1, 0}} ,{{223, 62}, {120, 30, 0}} ,{{219, 62}, {116, 30, 0}} ,{{25, 38}, {86, 0, 0}} ,{{158, 89}, {104, 167, 0}} ,{{152, 89}, {98, 167, 0}} ,{{150, 89}, {96, 167, 0}} ,{{148, 89}, {94, 167, 0}} ,{{229, 62}, {126, 30, 0}} ,{{84, 39}, {178, 1, 0}} ,{{227, 62}, {124, 30, 0}} ,{{26, 38}, {87, 0, 0}} ,{{153, 39}, {247, 1, 0}} ,{{233, 62}, {130, 30, 0}} ,{{22, 39}, {116, 1, 0}} ,{{235, 62}, {132, 30, 0}} ,{{237, 62}, {134, 30, 0}} ,{{239, 62}, {136, 30, 0}} ,{{231, 62}, {128, 30, 0}} ,{{120, 75}, {114, 44, 0}} ,{{27, 38}, {88, 0, 0}} ,{{243, 62}, {140, 30, 0}} ,{{241, 62}, {138, 30, 0}} ,{{28, 38}, {89, 0, 0}} ,{{190, 39}, {28, 2, 0}} ,{{127, 38}, {221, 0, 0}} ,{{24, 39}, {118, 1, 0}} ,{{26, 39}, {120, 1, 0}} ,{{245, 62}, {142, 30, 0}} ,{{91, 63}, {244, 30, 0}} ,{{89, 63}, {242, 30, 0}} ,{{85, 39}, {179, 1, 0}} ,{{93, 63}, {246, 30, 0}} ,{{101, 63}, {254, 30, 0}} ,{{212, 39}, {50, 2, 0}} ,{{240, 39}, {78, 2, 0}} ,{{95, 63}, {248, 30, 0}} ,{{29, 38}, {90, 0, 0}} ,{{27, 39}, {121, 1, 0}} ,{{31, 39}, {125, 1, 0}} ,{{247, 62}, {144, 30, 0}} ,{{113, 75}, {107, 44, 0}} ,{{29, 39}, {123, 1, 0}} ,{{249, 62}, {146, 30, 0}} ,{{198, 39}, {36, 2, 0}} ,{{251, 62}, {148, 30, 0}} ,{{87, 39}, {181, 1, 0}} ,{{133, 75}, {127, 44, 0}} ,{{212, 38}, {50, 1, 0}} ,{{244, 38}, {82, 1, 0}} ,{{223, 70}, {29, 39, 0}} ,{{199, 89}, {255, 167, 0}} ,{{197, 89}, {253, 167, 0}} ,{{198, 89}, {254, 167, 0}} ,{{195, 89}, {251, 167, 0}} ,{{196, 89}, {252, 167, 0}} ,{{162, 61}, {37, 29, 0}} ,{{100, 39}, {194, 1, 0}} ,{{79, 40}, {173, 2, 0}} ,{{58, 40}, {152, 2, 0}} ,{{78, 40}, {172, 2, 0}} ,{{98, 39}, {192, 1, 0}} ,{{54, 40}, {148, 2, 0}} ,{{67, 40}, {161, 2, 0}} ,{{56, 40}, {150, 2, 0}} ,{{96, 39}, {190, 1, 0}} ,{{99, 39}, {193, 1, 0}} ,{{55, 40}, {149, 2, 0}} ,{{101, 39}, {195, 1, 0}} ,{{76, 39}, {170, 1, 0}} ,{{68, 40}, {162, 2, 0}} ,{{125, 61}, {0, 29, 0}} ,{{126, 61}, {1, 29, 0}} ,{{59, 40}, {153, 2, 0}} ,{{128, 61}, {3, 29, 0}} ,{{129, 61}, {4, 29, 0}} ,{{130, 61}, {5, 29, 0}} ,{{132, 61}, {7, 29, 0}} ,{{131, 61}, {6, 29, 0}} ,{{160, 61}, {35, 29, 0}} ,{{102, 89}, {48, 167, 0}} ,{{4, 40}, {98, 2, 0}} ,{{61, 40}, {155, 2, 0}} ,{{62, 40}, {156, 2, 0}} ,{{12, 40}, {106, 2, 0}} ,{{35, 40}, {129, 2, 0}} ,{{135, 61}, {10, 29, 0}} ,{{136, 61}, {11, 29, 0}} ,{{65, 40}, {159, 2, 0}} ,{{137, 61}, {12, 29, 0}} ,{{138, 61}, {13, 29, 0}} ,{{22, 40}, {116, 2, 0}} ,{{140, 61}, {15, 29, 0}} ,{{24, 40}, {118, 2, 0}} ,{{141, 61}, {16, 29, 0}} ,{{146, 61}, {21, 29, 0}} ,{{149, 61}, {24, 29, 0}} ,{{34, 40}, {128, 2, 0}} ,{{139, 61}, {14, 29, 0}} ,{{150, 61}, {25, 29, 0}} ,{{172, 89}, {118, 167, 0}} ,{{103, 89}, {49, 167, 0}} ,{{152, 61}, {27, 29, 0}} ,{{129, 75}, {123, 44, 0}} ,{{151, 61}, {26, 29, 0}} ,{{153, 61}, {28, 29, 0}} ,{{157, 61}, {32, 29, 0}} ,{{158, 61}, {33, 29, 0}} ,{{49, 40}, {143, 2, 0}} ,{{159, 61}, {34, 29, 0}} ,{{57, 40}, {151, 2, 0}} ,{{93, 39}, {187, 1, 0}} ,{{161, 61}, {36, 29, 0}} ,{{97, 39}, {191, 1, 0}} ,{{72, 39}, {166, 1, 0}} ,{{248, 61}, {123, 29, 0}} ,{{251, 61}, {126, 29, 0}} ,{{36, 38}, {97, 0, 0}} ,{{105, 89}, {51, 167, 0}} ,{{136, 38}, {230, 0, 0}} ,{{159, 39}, {253, 1, 0}} ,{{133, 39}, {227, 1, 0}} ,{{243, 39}, {81, 2, 0}} ,{{13, 62}, {144, 29, 0}} ,{{107, 89}, {53, 167, 0}} ,{{109, 89}, {55, 167, 0}} ,{{111, 89}, {57, 167, 0}} ,{{113, 89}, {59, 167, 0}} ,{{115, 89}, {61, 167, 0}} ,{{131, 38}, {225, 0, 0}} ,{{165, 38}, {3, 1, 0}} ,{{22, 63}, {175, 30, 0}} ,{{30, 63}, {183, 30, 0}} ,{{24, 63}, {177, 30, 0}} ,{{26, 63}, {179, 30, 0}} ,{{28, 63}, {181, 30, 0}} ,{{112, 39}, {206, 1, 0}} ,{{132, 38}, {226, 0, 0}} ,{{12, 63}, {165, 30, 0}} ,{{20, 63}, {173, 30, 0}} ,{{14, 63}, {167, 30, 0}} ,{{16, 63}, {169, 30, 0}} ,{{18, 63}, {171, 30, 0}} ,{{134, 38}, {228, 0, 0}} ,{{129, 39}, {223, 1, 0}} ,{{201, 39}, {39, 2, 0}} ,{{131, 39}, {225, 1, 0}} ,{{8, 63}, {161, 30, 0}} ,{{163, 39}, {1, 2, 0}} ,{{130, 38}, {224, 0, 0}} ,{{10, 63}, {163, 30, 0}} ,{{165, 39}, {3, 2, 0}} ,{{163, 38}, {1, 1, 0}} ,{{167, 38}, {5, 1, 0}} ,{{12, 62}, {143, 29, 0}} ,{{1, 63}, {154, 30, 0}} ,{{135, 38}, {229, 0, 0}} ,{{157, 39}, {251, 1, 0}} ,{{104, 62}, {1, 30, 0}} ,{{107, 75}, {101, 44, 0}} ,{{133, 38}, {227, 0, 0}} ,{{37, 38}, {98, 0, 0}} ,{{23, 40}, {117, 2, 0}} ,{{148, 61}, {23, 29, 0}} ,{{125, 89}, {71, 167, 0}} ,{{106, 62}, {3, 30, 0}} ,{{108, 62}, {5, 30, 0}} ,{{245, 39}, {83, 2, 0}} ,{{110, 62}, {7, 30, 0}} ,{{233, 61}, {108, 29, 0}} ,{{253, 61}, {128, 29, 0}} ,{{34, 39}, {128, 1, 0}} ,{{37, 39}, {131, 1, 0}} ,{{38, 38}, {99, 0, 0}} ,{{25, 40}, {119, 2, 0}} ,{{60, 40}, {154, 2, 0}} ,{{0, 40}, {94, 2, 0}} ,{{165, 89}, {111, 167, 0}} ,{{99, 89}, {45, 167, 0}} ,{{101, 89}, {47, 167, 0}} ,{{169, 38}, {7, 1, 0}} ,{{175, 38}, {13, 1, 0}} ,{{137, 38}, {231, 0, 0}} ,{{112, 62}, {9, 30, 0}} ,{{171, 38}, {9, 1, 0}} ,{{247, 39}, {85, 2, 0}} ,{{173, 38}, {11, 1, 0}} ,{{42, 39}, {136, 1, 0}} ,{{222, 39}, {60, 2, 0}} ,{{39, 38}, {100, 0, 0}} ,{{218, 39}, {56, 2, 0}} ,{{6, 63}, {159, 30, 0}} ,{{70, 40}, {164, 2, 0}} ,{{211, 38}, {49, 1, 0}} ,{{217, 39}, {55, 2, 0}} ,{{1, 40}, {95, 2, 0}} ,{{38, 40}, {132, 2, 0}} ,{{167, 89}, {113, 167, 0}} ,{{149, 39}, {243, 1, 0}} ,{{69, 40}, {163, 2, 0}} ,{{71, 40}, {165, 2, 0}} ,{{104, 39}, {198, 1, 0}} ,{{177, 38}, {15, 1, 0}} ,{{120, 62}, {17, 30, 0}} ,{{122, 62}, {19, 30, 0}} ,{{195, 39}, {33, 2, 0}} ,{{114, 62}, {11, 30, 0}} ,{{116, 62}, {13, 30, 0}} ,{{249, 39}, {87, 2, 0}} ,{{14, 62}, {145, 29, 0}} ,{{118, 62}, {15, 30, 0}} ,{{234, 61}, {109, 29, 0}} ,{{254, 61}, {129, 29, 0}} ,{{179, 38}, {17, 1, 0}} ,{{248, 39}, {86, 2, 0}} ,{{46, 39}, {140, 1, 0}} ,{{40, 38}, {101, 0, 0}} ,{{91, 89}, {37, 167, 0}} ,{{89, 89}, {35, 167, 0}} ,{{237, 38}, {75, 1, 0}} ,{{37, 40}, {131, 2, 0}} ,{{40, 40}, {134, 2, 0}} ,{{8, 62}, {139, 29, 0}} ,{{21, 62}, {152, 29, 0}} ,{{161, 89}, {107, 167, 0}} ,{{146, 38}, {240, 0, 0}} ,{{52, 40}, {146, 2, 0}} ,{{91, 39}, {185, 1, 0}} ,{{145, 39}, {239, 1, 0}} ,{{53, 40}, {147, 2, 0}} ,{{23, 62}, {154, 29, 0}} ,{{92, 39}, {186, 1, 0}} ,{{139, 38}, {233, 0, 0}} ,{{183, 38}, {21, 1, 0}} ,{{189, 38}, {27, 1, 0}} ,{{203, 39}, {41, 2, 0}} ,{{132, 62}, {29, 30, 0}} ,{{140, 38}, {234, 0, 0}} ,{{38, 63}, {191, 30, 0}} ,{{46, 63}, {199, 30, 0}} ,{{40, 63}, {193, 30, 0}} ,{{42, 63}, {195, 30, 0}} ,{{44, 63}, {197, 30, 0}} ,{{128, 62}, {25, 30, 0}} ,{{141, 38}, {235, 0, 0}} ,{{185, 38}, {23, 1, 0}} ,{{32, 63}, {185, 30, 0}} ,{{167, 39}, {5, 2, 0}} ,{{138, 38}, {232, 0, 0}} ,{{34, 63}, {187, 30, 0}} ,{{169, 39}, {7, 2, 0}} ,{{181, 38}, {19, 1, 0}} ,{{126, 62}, {23, 30, 0}} ,{{124, 62}, {21, 30, 0}} ,{{126, 75}, {120, 44, 0}} ,{{187, 38}, {25, 1, 0}} ,{{15, 62}, {146, 29, 0}} ,{{233, 39}, {71, 2, 0}} ,{{36, 63}, {189, 30, 0}} ,{{130, 62}, {27, 30, 0}} ,{{41, 38}, {102, 0, 0}} ,{{75, 40}, {169, 2, 0}} ,{{134, 62}, {31, 30, 0}} ,{{52, 39}, {146, 1, 0}} ,{{235, 61}, {110, 29, 0}} ,{{255, 61}, {130, 29, 0}} ,{{42, 38}, {103, 0, 0}} ,{{5, 40}, {99, 2, 0}} ,{{228, 39}, {66, 2, 0}} ,{{151, 39}, {245, 1, 0}} ,{{193, 38}, {31, 1, 0}} ,{{137, 39}, {231, 1, 0}} ,{{197, 38}, {35, 1, 0}} ,{{191, 38}, {29, 1, 0}} ,{{195, 38}, {33, 1, 0}} ,{{2, 40}, {96, 2, 0}} ,{{136, 62}, {33, 30, 0}} ,{{0, 62}, {131, 29, 0}} ,{{135, 39}, {229, 1, 0}} ,{{43, 38}, {104, 0, 0}} ,{{124, 75}, {118, 44, 0}} ,{{93, 89}, {39, 167, 0}} ,{{9, 40}, {103, 2, 0}} ,{{55, 39}, {149, 1, 0}} ,{{146, 62}, {43, 30, 0}} ,{{193, 39}, {31, 2, 0}} ,{{144, 62}, {41, 30, 0}} ,{{199, 38}, {37, 1, 0}} ,{{110, 75}, {104, 44, 0}} ,{{142, 62}, {39, 30, 0}} ,{{138, 62}, {35, 30, 0}} ,{{140, 62}, {37, 30, 0}} ,{{8, 40}, {102, 2, 0}} ,{{253, 62}, {150, 30, 0}} ,{{201, 38}, {39, 1, 0}} ,{{44, 38}, {105, 0, 0}} ,{{176, 89}, {122, 167, 0}} ,{{178, 89}, {124, 167, 0}} ,{{246, 61}, {121, 29, 0}} ,{{185, 89}, {131, 167, 0}} ,{{187, 89}, {133, 167, 0}} ,{{189, 89}, {135, 167, 0}} ,{{11, 40}, {105, 2, 0}} ,{{249, 61}, {124, 29, 0}} ,{{163, 89}, {109, 167, 0}} ,{{143, 38}, {237, 0, 0}} ,{{207, 38}, {45, 1, 0}} ,{{114, 39}, {208, 1, 0}} ,{{144, 38}, {238, 0, 0}} ,{{145, 38}, {239, 0, 0}} ,{{150, 62}, {47, 30, 0}} ,{{50, 63}, {203, 30, 0}} ,{{171, 39}, {9, 2, 0}} ,{{142, 38}, {236, 0, 0}} ,{{48, 63}, {201, 30, 0}} ,{{173, 39}, {11, 2, 0}} ,{{205, 38}, {43, 1, 0}} ,{{209, 38}, {47, 1, 0}} ,{{19, 62}, {150, 29, 0}} ,{{10, 40}, {104, 2, 0}} ,{{203, 38}, {41, 1, 0}} ,{{148, 62}, {45, 30, 0}} ,{{45, 38}, {106, 0, 0}} ,{{146, 39}, {240, 1, 0}} ,{{215, 38}, {53, 1, 0}} ,{{63, 40}, {157, 2, 0}} ,{{235, 39}, {73, 2, 0}} ,{{46, 38}, {107, 0, 0}} ,{{218, 38}, {56, 1, 0}} ,{{152, 62}, {49, 30, 0}} ,{{139, 39}, {233, 1, 0}} ,{{217, 38}, {55, 1, 0}} ,{{112, 75}, {106, 44, 0}} ,{{121, 89}, {67, 167, 0}} ,{{154, 62}, {51, 30, 0}} ,{{59, 39}, {153, 1, 0}} ,{{156, 62}, {53, 30, 0}} ,{{1, 62}, {132, 29, 0}} ,{{119, 89}, {65, 167, 0}} ,{{123, 89}, {69, 167, 0}} ,{{47, 38}, {108, 0, 0}} ,{{61, 39}, {155, 1, 0}} ,{{16, 40}, {110, 2, 0}} ,{{107, 39}, {201, 1, 0}} ,{{33, 39}, {127, 1, 0}} ,{{3, 63}, {156, 30, 0}} ,{{2, 63}, {155, 30, 0}} ,{{4, 63}, {157, 30, 0}} ,{{76, 40}, {170, 2, 0}} ,{{168, 89}, {114, 167, 0}} ,{{77, 40}, {171, 2, 0}} ,{{220, 38}, {58, 1, 0}} ,{{60, 39}, {154, 1, 0}} ,{{14, 40}, {108, 2, 0}} ,{{224, 38}, {62, 1, 0}} ,{{222, 38}, {60, 1, 0}} ,{{164, 62}, {61, 30, 0}} ,{{214, 39}, {52, 2, 0}} ,{{158, 62}, {55, 30, 0}} ,{{160, 62}, {57, 30, 0}} ,{{103, 75}, {97, 44, 0}} ,{{127, 89}, {73, 167, 0}} ,{{162, 62}, {59, 30, 0}} ,{{226, 38}, {64, 1, 0}} ,{{13, 40}, {107, 2, 0}} ,{{2, 62}, {133, 29, 0}} ,{{15, 40}, {109, 2, 0}} ,{{228, 38}, {66, 1, 0}} ,{{48, 38}, {109, 0, 0}} ,{{98, 63}, {251, 30, 0}} ,{{100, 63}, {253, 30, 0}} ,{{169, 89}, {115, 167, 0}} ,{{166, 62}, {63, 30, 0}} ,{{168, 62}, {65, 30, 0}} ,{{170, 62}, {67, 30, 0}} ,{{19, 40}, {113, 2, 0}} ,{{236, 61}, {111, 29, 0}} ,{{3, 62}, {134, 29, 0}} ,{{49, 38}, {110, 0, 0}} ,{{110, 39}, {204, 1, 0}} ,{{170, 89}, {116, 167, 0}} ,{{235, 38}, {73, 1, 0}} ,{{230, 38}, {68, 1, 0}} ,{{234, 38}, {72, 1, 0}} ,{{232, 38}, {70, 1, 0}} ,{{178, 62}, {75, 30, 0}} ,{{215, 39}, {53, 2, 0}} ,{{172, 62}, {69, 30, 0}} ,{{174, 62}, {71, 30, 0}} ,{{155, 39}, {249, 1, 0}} ,{{20, 40}, {114, 2, 0}} ,{{176, 62}, {73, 30, 0}} ,{{64, 39}, {158, 1, 0}} ,{{237, 61}, {112, 29, 0}} ,{{4, 62}, {135, 29, 0}} ,{{21, 40}, {115, 2, 0}} ,{{147, 38}, {241, 0, 0}} ,{{50, 38}, {111, 0, 0}} ,{{69, 39}, {163, 1, 0}} ,{{133, 89}, {79, 167, 0}} ,{{253, 39}, {91, 2, 0}} ,{{16, 62}, {147, 29, 0}} ,{{246, 39}, {84, 2, 0}} ,{{20, 62}, {151, 29, 0}} ,{{197, 39}, {35, 2, 0}} ,{{149, 38}, {243, 0, 0}} ,{{241, 38}, {79, 1, 0}} ,{{116, 39}, {210, 1, 0}} ,{{150, 38}, {244, 0, 0}} ,{{56, 63}, {209, 30, 0}} ,{{64, 63}, {217, 30, 0}} ,{{58, 63}, {211, 30, 0}} ,{{60, 63}, {213, 30, 0}} ,{{62, 63}, {215, 30, 0}} ,{{152, 38}, {246, 0, 0}} ,{{205, 39}, {43, 2, 0}} ,{{209, 39}, {47, 2, 0}} ,{{211, 39}, {49, 2, 0}} ,{{52, 63}, {205, 30, 0}} ,{{243, 38}, {81, 1, 0}} ,{{175, 39}, {13, 2, 0}} ,{{148, 38}, {242, 0, 0}} ,{{54, 63}, {207, 30, 0}} ,{{67, 39}, {161, 1, 0}} ,{{66, 63}, {219, 30, 0}} ,{{74, 63}, {227, 30, 0}} ,{{68, 63}, {221, 30, 0}} ,{{70, 63}, {223, 30, 0}} ,{{72, 63}, {225, 30, 0}} ,{{177, 39}, {15, 2, 0}} ,{{129, 89}, {75, 167, 0}} ,{{131, 89}, {77, 167, 0}} ,{{128, 75}, {122, 44, 0}} ,{{239, 38}, {77, 1, 0}} ,{{186, 62}, {83, 30, 0}} ,{{184, 62}, {81, 30, 0}} ,{{141, 39}, {235, 1, 0}} ,{{143, 39}, {237, 1, 0}} ,{{154, 38}, {248, 0, 0}} ,{{161, 39}, {255, 1, 0}} ,{{151, 38}, {245, 0, 0}} ,{{180, 62}, {77, 30, 0}} ,{{182, 62}, {79, 30, 0}} ,{{207, 39}, {45, 2, 0}} ,{{51, 38}, {112, 0, 0}} ,{{26, 40}, {120, 2, 0}} ,{{188, 62}, {85, 30, 0}} ,{{190, 62}, {87, 30, 0}} ,{{137, 89}, {83, 167, 0}} ,{{71, 39}, {165, 1, 0}} ,{{238, 61}, {113, 29, 0}} ,{{5, 62}, {136, 29, 0}} ,{{139, 89}, {85, 167, 0}} ,{{250, 61}, {125, 29, 0}} ,{{135, 89}, {81, 167, 0}} ,{{52, 38}, {113, 0, 0}} ,{{219, 39}, {57, 2, 0}} ,{{143, 89}, {89, 167, 0}} ,{{66, 40}, {160, 2, 0}} ,{{237, 39}, {75, 2, 0}} ,{{141, 89}, {87, 167, 0}} ,{{53, 38}, {114, 0, 0}} ,{{6, 40}, {100, 2, 0}} ,{{155, 65}, {132, 33, 0}} ,{{117, 89}, {63, 167, 0}} ,{{250, 39}, {88, 2, 0}} ,{{254, 39}, {92, 2, 0}} ,{{255, 39}, {93, 2, 0}} ,{{17, 62}, {148, 29, 0}} ,{{33, 40}, {127, 2, 0}} ,{{171, 89}, {117, 167, 0}} ,{{147, 89}, {93, 167, 0}} ,{{145, 89}, {91, 167, 0}} ,{{247, 38}, {85, 1, 0}} ,{{251, 38}, {89, 1, 0}} ,{{249, 38}, {87, 1, 0}} ,{{192, 62}, {89, 30, 0}} ,{{194, 62}, {91, 30, 0}} ,{{196, 62}, {93, 30, 0}} ,{{179, 39}, {17, 2, 0}} ,{{32, 40}, {126, 2, 0}} ,{{240, 61}, {115, 29, 0}} ,{{181, 39}, {19, 2, 0}} ,{{198, 62}, {95, 30, 0}} ,{{30, 40}, {124, 2, 0}} ,{{239, 61}, {114, 29, 0}} ,{{6, 62}, {137, 29, 0}} ,{{239, 39}, {77, 2, 0}} ,{{31, 40}, {125, 2, 0}} ,{{54, 38}, {115, 0, 0}} ,{{194, 89}, {140, 167, 0}} ,{{251, 39}, {89, 2, 0}} ,{{252, 39}, {90, 2, 0}} ,{{18, 62}, {149, 29, 0}} ,{{3, 40}, {97, 2, 0}} ,{{129, 38}, {223, 0, 0}} ,{{155, 61}, {30, 29, 0}} ,{{142, 61}, {17, 29, 0}} ,{{143, 61}, {18, 29, 0}} ,{{144, 61}, {19, 29, 0}} ,{{156, 61}, {31, 29, 0}} ,{{154, 61}, {29, 29, 0}} ,{{39, 40}, {133, 2, 0}} ,{{253, 38}, {91, 1, 0}} ,{{204, 62}, {101, 30, 0}} ,{{3, 39}, {97, 1, 0}} ,{{206, 62}, {103, 30, 0}} ,{{1, 39}, {95, 1, 0}} ,{{255, 38}, {93, 1, 0}} ,{{187, 39}, {25, 2, 0}} ,{{200, 62}, {97, 30, 0}} ,{{202, 62}, {99, 30, 0}} ,{{208, 62}, {105, 30, 0}} ,{{36, 40}, {130, 2, 0}} ,{{241, 61}, {116, 29, 0}} ,{{7, 62}, {138, 29, 0}} ,{{225, 39}, {63, 2, 0}} ,{{55, 38}, {116, 0, 0}} ,{{125, 75}, {119, 44, 0}} ,{{74, 40}, {168, 2, 0}} ,{{73, 40}, {167, 2, 0}} ,{{160, 38}, {254, 0, 0}} ,{{155, 89}, {101, 167, 0}} ,{{157, 89}, {103, 167, 0}} ,{{247, 61}, {122, 29, 0}} ,{{95, 39}, {189, 1, 0}} ,{{39, 39}, {133, 1, 0}} ,{{74, 39}, {168, 1, 0}} ,{{147, 61}, {22, 29, 0}} ,{{97, 89}, {43, 167, 0}} ,{{72, 40}, {166, 2, 0}} ,{{173, 89}, {119, 167, 0}} ,{{242, 39}, {80, 2, 0}} ,{{127, 61}, {2, 29, 0}} ,{{244, 39}, {82, 2, 0}} ,{{47, 39}, {141, 1, 0}} ,{{127, 39}, {221, 1, 0}} ,{{244, 61}, {119, 29, 0}} ,{{7, 40}, {101, 2, 0}} ,{{80, 40}, {174, 2, 0}} ,{{81, 40}, {175, 2, 0}} ,{{134, 61}, {9, 29, 0}} ,{{181, 89}, {127, 167, 0}} ,{{64, 40}, {158, 2, 0}} ,{{183, 89}, {129, 167, 0}} ,{{17, 40}, {111, 2, 0}} ,{{18, 40}, {112, 2, 0}} ,{{145, 61}, {20, 29, 0}} ,{{133, 61}, {8, 29, 0}} ,{{27, 40}, {121, 2, 0}} ,{{29, 40}, {123, 2, 0}} ,{{28, 40}, {122, 2, 0}} ,{{127, 75}, {121, 44, 0}} ,{{41, 40}, {135, 2, 0}} ,{{46, 40}, {140, 2, 0}} ,{{47, 40}, {141, 2, 0}} ,{{48, 40}, {142, 2, 0}} ,{{95, 89}, {41, 167, 0}} ,{{7, 39}, {101, 1, 0}} ,{{5, 39}, {99, 1, 0}} ,{{216, 62}, {113, 30, 0}} ,{{189, 39}, {27, 2, 0}} ,{{216, 39}, {54, 2, 0}} ,{{254, 62}, {151, 30, 0}} ,{{108, 75}, {102, 44, 0}} ,{{210, 62}, {107, 30, 0}} ,{{212, 62}, {109, 30, 0}} ,{{79, 39}, {173, 1, 0}} ,{{214, 62}, {111, 30, 0}} ,{{242, 61}, {117, 29, 0}} ,{{77, 39}, {171, 1, 0}} ,{{42, 40}, {136, 2, 0}} ,{{9, 39}, {103, 1, 0}} ,{{56, 38}, {117, 0, 0}} ,{{232, 61}, {107, 29, 0}} ,{{174, 89}, {120, 167, 0}} ,{{44, 40}, {138, 2, 0}} ,{{252, 61}, {127, 29, 0}} ,{{43, 40}, {137, 2, 0}} ,{{156, 38}, {250, 0, 0}} ,{{15, 39}, {109, 1, 0}} ,{{118, 39}, {212, 1, 0}} ,{{157, 38}, {251, 0, 0}} ,{{222, 62}, {119, 30, 0}} ,{{158, 38}, {252, 0, 0}} ,{{122, 39}, {216, 1, 0}} ,{{124, 39}, {218, 1, 0}} ,{{126, 39}, {220, 1, 0}} ,{{120, 39}, {214, 1, 0}} ,{{218, 62}, {115, 30, 0}} ,{{76, 63}, {229, 30, 0}} ,{{19, 39}, {113, 1, 0}} ,{{183, 39}, {21, 2, 0}} ,{{155, 38}, {249, 0, 0}} ,{{78, 63}, {231, 30, 0}} ,{{82, 39}, {176, 1, 0}} ,{{80, 63}, {233, 30, 0}} ,{{88, 63}, {241, 30, 0}} ,{{82, 63}, {235, 30, 0}} ,{{84, 63}, {237, 30, 0}} ,{{86, 63}, {239, 30, 0}} ,{{185, 39}, {23, 2, 0}} ,{{13, 39}, {107, 1, 0}} ,{{226, 62}, {123, 30, 0}} ,{{21, 39}, {115, 1, 0}} ,{{22, 62}, {153, 29, 0}} ,{{17, 39}, {111, 1, 0}} ,{{11, 39}, {105, 1, 0}} ,{{224, 62}, {121, 30, 0}} ,{{220, 62}, {117, 30, 0}} ,{{57, 38}, {118, 0, 0}} ,{{159, 89}, {105, 167, 0}} ,{{153, 89}, {99, 167, 0}} ,{{151, 89}, {97, 167, 0}} ,{{122, 75}, {116, 44, 0}} ,{{149, 89}, {95, 167, 0}} ,{{230, 62}, {127, 30, 0}} ,{{45, 40}, {139, 2, 0}} ,{{9, 62}, {140, 29, 0}} ,{{119, 75}, {113, 44, 0}} ,{{228, 62}, {125, 30, 0}} ,{{58, 38}, {119, 0, 0}} ,{{234, 62}, {131, 30, 0}} ,{{23, 39}, {117, 1, 0}} ,{{236, 62}, {133, 30, 0}} ,{{238, 62}, {135, 30, 0}} ,{{240, 62}, {137, 30, 0}} ,{{232, 62}, {129, 30, 0}} ,{{121, 75}, {115, 44, 0}} ,{{255, 62}, {152, 30, 0}} ,{{59, 38}, {120, 0, 0}} ,{{244, 62}, {141, 30, 0}} ,{{242, 62}, {139, 30, 0}} ,{{10, 62}, {141, 29, 0}} ,{{60, 38}, {121, 0, 0}} ,{{191, 39}, {29, 2, 0}} ,{{159, 38}, {253, 0, 0}} ,{{25, 39}, {119, 1, 0}} ,{{161, 38}, {255, 0, 0}} ,{{246, 62}, {143, 30, 0}} ,{{92, 63}, {245, 30, 0}} ,{{90, 63}, {243, 30, 0}} ,{{86, 39}, {180, 1, 0}} ,{{94, 63}, {247, 30, 0}} ,{{102, 63}, {255, 30, 0}} ,{{213, 39}, {51, 2, 0}} ,{{0, 63}, {153, 30, 0}} ,{{241, 39}, {79, 2, 0}} ,{{96, 63}, {249, 30, 0}} ,{{61, 38}, {122, 0, 0}} ,{{28, 39}, {122, 1, 0}} ,{{32, 39}, {126, 1, 0}} ,{{248, 62}, {145, 30, 0}} ,{{51, 40}, {145, 2, 0}} ,{{114, 75}, {108, 44, 0}} ,{{30, 39}, {124, 1, 0}} ,{{250, 62}, {147, 30, 0}} ,{{199, 39}, {37, 2, 0}} ,{{252, 62}, {149, 30, 0}} ,{{243, 61}, {118, 29, 0}} ,{{11, 62}, {142, 29, 0}} ,{{50, 40}, {144, 2, 0}} ,{{88, 39}, {182, 1, 0}} ,{{226, 39}, {64, 2, 0}} ,{{33, 138}, {0, 251, 0}} ,{{36, 138}, {3, 251, 0}} ,{{37, 138}, {4, 251, 0}} ,{{34, 138}, {1, 251, 0}} ,{{35, 138}, {2, 251, 0}} ,{{213, 38}, {51, 1, 0}} ,{{38, 138}, {5, 251, 0}} ,{{245, 38}, {83, 1, 0}} ,{{39, 138}, {6, 251, 0}} ,{{216, 64}, {144, 32, 0}} ,{{217, 64}, {145, 32, 0}} ,{{223, 61}, {98, 29, 0}} ,{{130, 75}, {124, 44, 0}} ,{{218, 64}, {146, 32, 0}} ,{{224, 61}, {99, 29, 0}} ,{{220, 64}, {148, 32, 0}} ,{{225, 61}, {100, 29, 0}} ,{{226, 61}, {101, 29, 0}} ,{{219, 64}, {147, 32, 0}} ,{{95, 50}, {214, 15, 0}} ,{{97, 50}, {216, 15, 0}} ,{{58, 67}, {41, 35, 0}} ,{{173, 73}, {252, 41, 0}} ,{{77, 38}, {171, 0, 0}} ,{{97, 71}, {170, 39, 0}} ,{{234, 72}, {57, 41, 0}} ,{{122, 64}, {42, 32, 0}} ,{{94, 64}, {14, 32, 0}} ,{{125, 64}, {45, 32, 0}} ,{{161, 65}, {144, 33, 0}} ,{{202, 72}, {25, 41, 0}} ,{{251, 74}, {74, 43, 0}} ,{{243, 74}, {66, 43, 0}} ,{{252, 74}, {75, 43, 0}} ,{{244, 72}, {67, 41, 0}} ,{{36, 73}, {115, 41, 0}} ,{{181, 65}, {164, 33, 0}} ,{{208, 72}, {31, 41, 0}} ,{{215, 65}, {198, 33, 0}} ,{{40, 73}, {119, 41, 0}} ,{{43, 73}, {122, 41, 0}} ,{{239, 74}, {62, 43, 0}} ,{{245, 65}, {228, 33, 0}} ,{{202, 65}, {185, 33, 0}} ,{{206, 72}, {29, 41, 0}} ,{{233, 74}, {56, 43, 0}} ,{{11, 66}, {250, 33, 0}} ,{{186, 65}, {169, 33, 0}} ,{{188, 65}, {171, 33, 0}} ,{{247, 72}, {70, 41, 0}} ,{{171, 65}, {154, 33, 0}} ,{{179, 65}, {162, 33, 0}} ,{{235, 74}, {58, 43, 0}} ,{{234, 74}, {57, 43, 0}} ,{{193, 74}, {16, 43, 0}} ,{{194, 74}, {17, 43, 0}} ,{{8, 66}, {247, 33, 0}} ,{{182, 74}, {5, 43, 0}} ,{{241, 65}, {224, 33, 0}} ,{{225, 65}, {208, 33, 0}} ,{{204, 72}, {27, 41, 0}} ,{{183, 72}, {6, 41, 0}} ,{{222, 65}, {205, 33, 0}} ,{{179, 72}, {2, 41, 0}} ,{{189, 72}, {12, 41, 0}} ,{{220, 65}, {203, 33, 0}} ,{{206, 65}, {189, 33, 0}} ,{{24, 73}, {103, 41, 0}} ,{{28, 73}, {107, 41, 0}} ,{{15, 73}, {94, 41, 0}} ,{{7, 73}, {86, 41, 0}} ,{{205, 65}, {188, 33, 0}} ,{{19, 73}, {98, 41, 0}} ,{{27, 73}, {106, 41, 0}} ,{{23, 73}, {102, 41, 0}} ,{{11, 73}, {90, 41, 0}} ,{{3, 73}, {82, 41, 0}} ,{{14, 66}, {253, 33, 0}} ,{{216, 65}, {199, 33, 0}} ,{{246, 74}, {69, 43, 0}} ,{{237, 65}, {220, 33, 0}} ,{{235, 65}, {218, 33, 0}} ,{{191, 72}, {14, 41, 0}} ,{{231, 74}, {54, 43, 0}} ,{{230, 74}, {53, 43, 0}} ,{{236, 74}, {59, 43, 0}} ,{{238, 74}, {61, 43, 0}} ,{{237, 74}, {60, 43, 0}} ,{{229, 74}, {52, 43, 0}} ,{{232, 74}, {55, 43, 0}} ,{{175, 65}, {158, 33, 0}} ,{{173, 65}, {156, 33, 0}} ,{{247, 65}, {230, 33, 0}} ,{{139, 71}, {218, 39, 0}} ,{{140, 71}, {219, 39, 0}} ,{{90, 78}, {8, 48, 0}} ,{{66, 73}, {145, 41, 0}} ,{{68, 73}, {147, 41, 0}} ,{{227, 74}, {50, 43, 0}} ,{{225, 74}, {48, 43, 0}} ,{{1, 73}, {80, 41, 0}} ,{{252, 72}, {75, 41, 0}} ,{{251, 72}, {74, 41, 0}} ,{{255, 72}, {78, 41, 0}} ,{{98, 78}, {16, 48, 0}} ,{{72, 73}, {151, 41, 0}} ,{{25, 67}, {8, 35, 0}} ,{{167, 70}, {220, 38, 0}} ,{{94, 78}, {12, 48, 0}} ,{{62, 38}, {123, 0, 0}} ,{{186, 67}, {169, 35, 0}} ,{{185, 67}, {168, 35, 0}} ,{{184, 67}, {167, 35, 0}} ,{{207, 76}, {4, 46, 0}} ,{{92, 78}, {10, 48, 0}} ,{{243, 76}, {40, 46, 0}} ,{{108, 64}, {28, 32, 0}} ,{{139, 73}, {218, 41, 0}} ,{{45, 73}, {124, 41, 0}} ,{{87, 69}, {139, 37, 0}} ,{{27, 67}, {10, 35, 0}} ,{{162, 69}, {214, 37, 0}} ,{{88, 69}, {140, 37, 0}} ,{{231, 76}, {28, 46, 0}} ,{{141, 71}, {220, 39, 0}} ,{{218, 66}, {201, 34, 0}} ,{{91, 69}, {143, 37, 0}} ,{{90, 69}, {142, 37, 0}} ,{{134, 71}, {213, 39, 0}} ,{{235, 37}, {40, 0, 0}} ,{{173, 67}, {156, 35, 0}} ,{{174, 67}, {157, 35, 0}} ,{{172, 67}, {155, 35, 0}} ,{{215, 76}, {12, 46, 0}} ,{{165, 65}, {148, 33, 0}} ,{{249, 72}, {72, 41, 0}} ,{{13, 66}, {252, 33, 0}} ,{{191, 65}, {174, 33, 0}} ,{{10, 66}, {249, 33, 0}} ,{{189, 74}, {12, 43, 0}} ,{{229, 65}, {212, 33, 0}} ,{{223, 65}, {206, 33, 0}} ,{{181, 72}, {4, 41, 0}} ,{{16, 66}, {255, 33, 0}} ,{{190, 65}, {173, 33, 0}} ,{{181, 74}, {4, 43, 0}} ,{{122, 71}, {197, 39, 0}} ,{{220, 66}, {203, 34, 0}} ,{{85, 69}, {137, 37, 0}} ,{{241, 76}, {38, 46, 0}} ,{{104, 64}, {24, 32, 0}} ,{{30, 38}, {91, 0, 0}} ,{{179, 67}, {162, 35, 0}} ,{{180, 67}, {163, 35, 0}} ,{{178, 67}, {161, 35, 0}} ,{{149, 64}, {69, 32, 0}} ,{{64, 73}, {143, 41, 0}} ,{{62, 73}, {141, 41, 0}} ,{{60, 73}, {139, 41, 0}} ,{{205, 76}, {2, 46, 0}} ,{{180, 66}, {163, 34, 0}} ,{{89, 69}, {141, 37, 0}} ,{{86, 69}, {138, 37, 0}} ,{{102, 78}, {20, 48, 0}} ,{{212, 76}, {9, 46, 0}} ,{{128, 73}, {207, 41, 0}} ,{{235, 76}, {32, 46, 0}} ,{{201, 67}, {184, 35, 0}} ,{{96, 78}, {14, 48, 0}} ,{{52, 73}, {131, 41, 0}} ,{{104, 78}, {22, 48, 0}} ,{{54, 73}, {133, 41, 0}} ,{{108, 78}, {26, 48, 0}} ,{{106, 78}, {24, 48, 0}} ,{{137, 73}, {216, 41, 0}} ,{{24, 70}, {76, 38, 0}} ,{{13, 61}, {45, 28, 0}} ,{{21, 61}, {53, 28, 0}} ,{{15, 61}, {47, 28, 0}} ,{{14, 61}, {46, 28, 0}} ,{{16, 61}, {48, 28, 0}} ,{{20, 61}, {52, 28, 0}} ,{{17, 61}, {49, 28, 0}} ,{{18, 61}, {50, 28, 0}} ,{{19, 61}, {51, 28, 0}} ,{{37, 61}, {72, 28, 0}} ,{{34, 61}, {69, 28, 0}} ,{{33, 61}, {68, 28, 0}} ,{{38, 61}, {73, 28, 0}} ,{{30, 61}, {65, 28, 0}} ,{{36, 61}, {71, 28, 0}} ,{{35, 61}, {70, 28, 0}} ,{{32, 61}, {67, 28, 0}} ,{{31, 61}, {66, 28, 0}} ,{{29, 61}, {64, 28, 0}} ,{{3, 61}, {35, 28, 0}} ,{{243, 60}, {19, 28, 0}} ,{{244, 60}, {20, 28, 0}} ,{{230, 60}, {6, 28, 0}} ,{{231, 60}, {7, 28, 0}} ,{{236, 60}, {12, 28, 0}} ,{{41, 61}, {79, 28, 0}} ,{{249, 60}, {25, 28, 0}} ,{{241, 60}, {17, 28, 0}} ,{{242, 60}, {18, 28, 0}} ,{{227, 60}, {3, 28, 0}} ,{{228, 60}, {4, 28, 0}} ,{{253, 60}, {29, 28, 0}} ,{{254, 60}, {30, 28, 0}} ,{{232, 60}, {8, 28, 0}} ,{{224, 60}, {0, 28, 0}} ,{{226, 60}, {2, 28, 0}} ,{{225, 60}, {1, 28, 0}} ,{{252, 60}, {28, 28, 0}} ,{{245, 60}, {21, 28, 0}} ,{{246, 60}, {22, 28, 0}} ,{{237, 60}, {13, 28, 0}} ,{{229, 60}, {5, 28, 0}} ,{{233, 60}, {9, 28, 0}} ,{{238, 60}, {14, 28, 0}} ,{{240, 60}, {16, 28, 0}} ,{{239, 60}, {15, 28, 0}} ,{{251, 60}, {27, 28, 0}} ,{{0, 61}, {32, 28, 0}} ,{{1, 61}, {33, 28, 0}} ,{{234, 60}, {10, 28, 0}} ,{{235, 60}, {11, 28, 0}} ,{{247, 60}, {23, 28, 0}} ,{{248, 60}, {24, 28, 0}} ,{{39, 61}, {77, 28, 0}} ,{{40, 61}, {78, 28, 0}} ,{{255, 60}, {31, 28, 0}} ,{{2, 61}, {34, 28, 0}} ,{{250, 60}, {26, 28, 0}} ,{{26, 61}, {61, 28, 0}} ,{{25, 61}, {60, 28, 0}} ,{{24, 61}, {59, 28, 0}} ,{{28, 61}, {63, 28, 0}} ,{{27, 61}, {62, 28, 0}} ,{{23, 61}, {55, 28, 0}} ,{{22, 61}, {54, 28, 0}} ,{{5, 61}, {37, 28, 0}} ,{{4, 61}, {36, 28, 0}} ,{{6, 61}, {38, 28, 0}} ,{{12, 61}, {44, 28, 0}} ,{{7, 61}, {39, 28, 0}} ,{{8, 61}, {40, 28, 0}} ,{{9, 61}, {41, 28, 0}} ,{{10, 61}, {42, 28, 0}} ,{{11, 61}, {43, 28, 0}} ,{{60, 74}, {139, 42, 0}} ,{{66, 74}, {145, 42, 0}} ,{{39, 73}, {118, 41, 0}} ,{{64, 74}, {143, 42, 0}} ,{{62, 74}, {141, 42, 0}} ,{{68, 74}, {147, 42, 0}} ,{{58, 74}, {137, 42, 0}} ,{{56, 74}, {135, 42, 0}} ,{{121, 66}, {104, 34, 0}} ,{{247, 66}, {230, 34, 0}} ,{{87, 74}, {166, 42, 0}} ,{{89, 74}, {168, 42, 0}} ,{{235, 66}, {218, 34, 0}} ,{{54, 74}, {133, 42, 0}} ,{{117, 66}, {100, 34, 0}} ,{{131, 66}, {114, 34, 0}} ,{{135, 66}, {118, 34, 0}} ,{{46, 74}, {125, 42, 0}} ,{{50, 74}, {129, 42, 0}} ,{{52, 74}, {131, 42, 0}} ,{{48, 74}, {127, 42, 0}} ,{{119, 66}, {102, 34, 0}} ,{{255, 37}, {60, 0, 0}} ,{{42, 74}, {121, 42, 0}} ,{{231, 66}, {214, 34, 0}} ,{{44, 74}, {123, 42, 0}} ,{{26, 70}, {78, 38, 0}} ,{{211, 69}, {7, 38, 0}} ,{{44, 71}, {114, 39, 0}} ,{{45, 71}, {115, 39, 0}} ,{{93, 69}, {145, 37, 0}} ,{{20, 71}, {88, 39, 0}} ,{{251, 58}, {78, 25, 0}} ,{{248, 58}, {75, 25, 0}} ,{{247, 58}, {74, 25, 0}} ,{{252, 58}, {79, 25, 0}} ,{{244, 58}, {71, 25, 0}} ,{{250, 58}, {77, 25, 0}} ,{{249, 58}, {76, 25, 0}} ,{{246, 58}, {73, 25, 0}} ,{{245, 58}, {72, 25, 0}} ,{{243, 58}, {70, 25, 0}} ,{{241, 58}, {68, 25, 0}} ,{{205, 58}, {18, 25, 0}} ,{{206, 58}, {19, 25, 0}} ,{{193, 58}, {6, 25, 0}} ,{{194, 58}, {7, 25, 0}} ,{{200, 58}, {13, 25, 0}} ,{{201, 58}, {14, 25, 0}} ,{{190, 58}, {3, 25, 0}} ,{{191, 58}, {4, 25, 0}} ,{{215, 58}, {28, 25, 0}} ,{{195, 58}, {8, 25, 0}} ,{{196, 58}, {9, 25, 0}} ,{{188, 58}, {1, 25, 0}} ,{{189, 58}, {2, 25, 0}} ,{{210, 58}, {23, 25, 0}} ,{{207, 58}, {20, 25, 0}} ,{{202, 58}, {15, 25, 0}} ,{{192, 58}, {5, 25, 0}} ,{{203, 58}, {16, 25, 0}} ,{{204, 58}, {17, 25, 0}} ,{{209, 58}, {22, 25, 0}} ,{{214, 58}, {27, 25, 0}} ,{{212, 58}, {25, 25, 0}} ,{{213, 58}, {26, 25, 0}} ,{{198, 58}, {11, 25, 0}} ,{{199, 58}, {12, 25, 0}} ,{{211, 58}, {24, 25, 0}} ,{{208, 58}, {21, 25, 0}} ,{{197, 58}, {10, 25, 0}} ,{{242, 58}, {69, 25, 0}} ,{{238, 58}, {58, 25, 0}} ,{{240, 58}, {64, 25, 0}} ,{{237, 58}, {57, 25, 0}} ,{{239, 58}, {59, 25, 0}} ,{{230, 58}, {50, 25, 0}} ,{{228, 58}, {48, 25, 0}} ,{{236, 58}, {56, 25, 0}} ,{{234, 58}, {54, 25, 0}} ,{{232, 58}, {52, 25, 0}} ,{{229, 58}, {49, 25, 0}} ,{{233, 58}, {53, 25, 0}} ,{{235, 58}, {55, 25, 0}} ,{{231, 58}, {51, 25, 0}} ,{{226, 58}, {42, 25, 0}} ,{{227, 58}, {43, 25, 0}} ,{{225, 58}, {41, 25, 0}} ,{{187, 58}, {0, 25, 0}} ,{{216, 58}, {32, 25, 0}} ,{{220, 58}, {36, 25, 0}} ,{{222, 58}, {38, 25, 0}} ,{{223, 58}, {39, 25, 0}} ,{{219, 58}, {35, 25, 0}} ,{{217, 58}, {33, 25, 0}} ,{{224, 58}, {40, 25, 0}} ,{{221, 58}, {37, 25, 0}} ,{{218, 58}, {34, 25, 0}} ,{{0, 81}, {207, 50, 0}} ,{{212, 142}, {128, 0, 1}} ,{{213, 142}, {129, 0, 1}} ,{{214, 142}, {130, 0, 1}} ,{{216, 142}, {132, 0, 1}} ,{{217, 142}, {133, 0, 1}} ,{{215, 142}, {131, 0, 1}} ,{{218, 142}, {134, 0, 1}} ,{{219, 142}, {135, 0, 1}} ,{{220, 142}, {136, 0, 1}} ,{{221, 142}, {137, 0, 1}} ,{{222, 142}, {138, 0, 1}} ,{{223, 142}, {139, 0, 1}} ,{{224, 142}, {140, 0, 1}} ,{{225, 142}, {141, 0, 1}} ,{{226, 142}, {142, 0, 1}} ,{{227, 142}, {143, 0, 1}} ,{{228, 142}, {144, 0, 1}} ,{{229, 142}, {145, 0, 1}} ,{{230, 142}, {146, 0, 1}} ,{{233, 142}, {149, 0, 1}} ,{{234, 142}, {150, 0, 1}} ,{{235, 142}, {151, 0, 1}} ,{{238, 142}, {154, 0, 1}} ,{{239, 142}, {155, 0, 1}} ,{{240, 142}, {156, 0, 1}} ,{{241, 142}, {157, 0, 1}} ,{{242, 142}, {158, 0, 1}} ,{{243, 142}, {159, 0, 1}} ,{{244, 142}, {160, 0, 1}} ,{{245, 142}, {161, 0, 1}} ,{{246, 142}, {162, 0, 1}} ,{{247, 142}, {163, 0, 1}} ,{{249, 142}, {165, 0, 1}} ,{{250, 142}, {166, 0, 1}} ,{{251, 142}, {167, 0, 1}} ,{{252, 142}, {168, 0, 1}} ,{{253, 142}, {169, 0, 1}} ,{{254, 142}, {170, 0, 1}} ,{{255, 142}, {171, 0, 1}} ,{{0, 143}, {172, 0, 1}} ,{{1, 143}, {173, 0, 1}} ,{{2, 143}, {174, 0, 1}} ,{{3, 143}, {175, 0, 1}} ,{{4, 143}, {176, 0, 1}} ,{{5, 143}, {177, 0, 1}} ,{{6, 143}, {178, 0, 1}} ,{{7, 143}, {179, 0, 1}} ,{{8, 143}, {180, 0, 1}} ,{{9, 143}, {181, 0, 1}} ,{{10, 143}, {182, 0, 1}} ,{{11, 143}, {183, 0, 1}} ,{{12, 143}, {184, 0, 1}} ,{{13, 143}, {185, 0, 1}} ,{{14, 143}, {186, 0, 1}} ,{{15, 143}, {187, 0, 1}} ,{{16, 143}, {188, 0, 1}} ,{{17, 143}, {189, 0, 1}} ,{{18, 143}, {190, 0, 1}} ,{{19, 143}, {191, 0, 1}} ,{{20, 143}, {192, 0, 1}} ,{{21, 143}, {193, 0, 1}} ,{{22, 143}, {194, 0, 1}} ,{{23, 143}, {195, 0, 1}} ,{{24, 143}, {196, 0, 1}} ,{{25, 143}, {197, 0, 1}} ,{{26, 143}, {198, 0, 1}} ,{{27, 143}, {199, 0, 1}} ,{{28, 143}, {200, 0, 1}} ,{{29, 143}, {201, 0, 1}} ,{{30, 143}, {202, 0, 1}} ,{{31, 143}, {203, 0, 1}} ,{{32, 143}, {204, 0, 1}} ,{{33, 143}, {205, 0, 1}} ,{{34, 143}, {206, 0, 1}} ,{{35, 143}, {207, 0, 1}} ,{{36, 143}, {208, 0, 1}} ,{{37, 143}, {209, 0, 1}} ,{{39, 143}, {211, 0, 1}} ,{{40, 143}, {212, 0, 1}} ,{{41, 143}, {213, 0, 1}} ,{{42, 143}, {214, 0, 1}} ,{{43, 143}, {215, 0, 1}} ,{{44, 143}, {216, 0, 1}} ,{{45, 143}, {217, 0, 1}} ,{{46, 143}, {218, 0, 1}} ,{{47, 143}, {219, 0, 1}} ,{{48, 143}, {220, 0, 1}} ,{{49, 143}, {221, 0, 1}} ,{{50, 143}, {222, 0, 1}} ,{{51, 143}, {223, 0, 1}} ,{{52, 143}, {224, 0, 1}} ,{{53, 143}, {225, 0, 1}} ,{{54, 143}, {226, 0, 1}} ,{{55, 143}, {227, 0, 1}} ,{{56, 143}, {228, 0, 1}} ,{{57, 143}, {229, 0, 1}} ,{{58, 143}, {230, 0, 1}} ,{{59, 143}, {231, 0, 1}} ,{{60, 143}, {232, 0, 1}} ,{{61, 143}, {233, 0, 1}} ,{{62, 143}, {234, 0, 1}} ,{{63, 143}, {235, 0, 1}} ,{{64, 143}, {236, 0, 1}} ,{{65, 143}, {237, 0, 1}} ,{{66, 143}, {238, 0, 1}} ,{{67, 143}, {239, 0, 1}} ,{{68, 143}, {240, 0, 1}} ,{{69, 143}, {241, 0, 1}} ,{{70, 143}, {242, 0, 1}} ,{{71, 143}, {243, 0, 1}} ,{{72, 143}, {244, 0, 1}} ,{{73, 143}, {245, 0, 1}} ,{{74, 143}, {246, 0, 1}} ,{{75, 143}, {247, 0, 1}} ,{{76, 143}, {248, 0, 1}} ,{{77, 143}, {249, 0, 1}} ,{{78, 143}, {250, 0, 1}} ,{{231, 142}, {147, 0, 1}} ,{{232, 142}, {148, 0, 1}} ,{{236, 142}, {152, 0, 1}} ,{{237, 142}, {153, 0, 1}} ,{{248, 142}, {164, 0, 1}} ,{{38, 143}, {210, 0, 1}} ,{{129, 142}, {5, 0, 1}} ,{{165, 142}, {43, 0, 1}} ,{{153, 142}, {30, 0, 1}} ,{{173, 142}, {51, 0, 1}} ,{{175, 142}, {53, 0, 1}} ,{{148, 142}, {25, 0, 1}} ,{{131, 142}, {7, 0, 1}} ,{{124, 142}, {0, 0, 1}} ,{{168, 142}, {46, 0, 1}} ,{{128, 142}, {4, 0, 1}} ,{{156, 142}, {33, 0, 1}} ,{{170, 142}, {48, 0, 1}} ,{{144, 142}, {21, 0, 1}} ,{{132, 142}, {8, 0, 1}} ,{{146, 142}, {23, 0, 1}} ,{{158, 142}, {35, 0, 1}} ,{{181, 142}, {60, 0, 1}} ,{{183, 142}, {63, 0, 1}} ,{{160, 142}, {37, 0, 1}} ,{{147, 142}, {24, 0, 1}} ,{{149, 142}, {26, 0, 1}} ,{{184, 142}, {64, 0, 1}} ,{{166, 142}, {44, 0, 1}} ,{{163, 142}, {41, 0, 1}} ,{{126, 142}, {2, 0, 1}} ,{{190, 142}, {70, 0, 1}} ,{{150, 142}, {27, 0, 1}} ,{{167, 142}, {45, 0, 1}} ,{{161, 142}, {38, 0, 1}} ,{{193, 142}, {73, 0, 1}} ,{{136, 142}, {13, 0, 1}} ,{{174, 142}, {52, 0, 1}} ,{{125, 142}, {1, 0, 1}} ,{{155, 142}, {32, 0, 1}} ,{{179, 142}, {57, 0, 1}} ,{{169, 142}, {47, 0, 1}} ,{{180, 142}, {58, 0, 1}} ,{{185, 142}, {65, 0, 1}} ,{{139, 142}, {16, 0, 1}} ,{{130, 142}, {6, 0, 1}} ,{{135, 142}, {11, 0, 1}} ,{{189, 142}, {69, 0, 1}} ,{{157, 142}, {34, 0, 1}} ,{{133, 142}, {9, 0, 1}} ,{{151, 142}, {28, 0, 1}} ,{{164, 142}, {42, 0, 1}} ,{{177, 142}, {55, 0, 1}} ,{{152, 142}, {29, 0, 1}} ,{{134, 142}, {10, 0, 1}} ,{{171, 142}, {49, 0, 1}} ,{{172, 142}, {50, 0, 1}} ,{{162, 142}, {40, 0, 1}} ,{{127, 142}, {3, 0, 1}} ,{{191, 142}, {71, 0, 1}} ,{{137, 142}, {14, 0, 1}} ,{{195, 142}, {75, 0, 1}} ,{{140, 142}, {17, 0, 1}} ,{{194, 142}, {74, 0, 1}} ,{{176, 142}, {54, 0, 1}} ,{{141, 142}, {18, 0, 1}} ,{{187, 142}, {67, 0, 1}} ,{{154, 142}, {31, 0, 1}} ,{{145, 142}, {22, 0, 1}} ,{{182, 142}, {61, 0, 1}} ,{{178, 142}, {56, 0, 1}} ,{{192, 142}, {72, 0, 1}} ,{{138, 142}, {15, 0, 1}} ,{{159, 142}, {36, 0, 1}} ,{{143, 142}, {20, 0, 1}} ,{{142, 142}, {19, 0, 1}} ,{{186, 142}, {66, 0, 1}} ,{{196, 142}, {76, 0, 1}} ,{{188, 142}, {68, 0, 1}} ,{{197, 142}, {77, 0, 1}} ,{{198, 142}, {80, 0, 1}} ,{{199, 142}, {81, 0, 1}} ,{{200, 142}, {82, 0, 1}} ,{{201, 142}, {83, 0, 1}} ,{{202, 142}, {84, 0, 1}} ,{{203, 142}, {85, 0, 1}} ,{{204, 142}, {86, 0, 1}} ,{{205, 142}, {87, 0, 1}} ,{{206, 142}, {88, 0, 1}} ,{{207, 142}, {89, 0, 1}} ,{{208, 142}, {90, 0, 1}} ,{{209, 142}, {91, 0, 1}} ,{{210, 142}, {92, 0, 1}} ,{{211, 142}, {93, 0, 1}} ,{{197, 73}, {20, 42, 0}} ,{{195, 73}, {18, 42, 0}} ,{{196, 73}, {19, 42, 0}} ,{{120, 64}, {40, 32, 0}} ,{{225, 64}, {164, 32, 0}} ,{{82, 87}, {238, 164, 0}} ,{{83, 87}, {239, 164, 0}} ,{{52, 87}, {208, 164, 0}} ,{{62, 87}, {218, 164, 0}} ,{{63, 87}, {219, 164, 0}} ,{{55, 87}, {211, 164, 0}} ,{{64, 87}, {220, 164, 0}} ,{{84, 87}, {240, 164, 0}} ,{{85, 87}, {241, 164, 0}} ,{{77, 87}, {233, 164, 0}} ,{{58, 87}, {214, 164, 0}} ,{{81, 87}, {237, 164, 0}} ,{{74, 87}, {230, 164, 0}} ,{{76, 87}, {232, 164, 0}} ,{{86, 87}, {242, 164, 0}} ,{{61, 87}, {217, 164, 0}} ,{{59, 87}, {215, 164, 0}} ,{{60, 87}, {216, 164, 0}} ,{{69, 87}, {225, 164, 0}} ,{{67, 87}, {223, 164, 0}} ,{{68, 87}, {224, 164, 0}} ,{{73, 87}, {229, 164, 0}} ,{{87, 87}, {243, 164, 0}} ,{{91, 87}, {247, 164, 0}} ,{{53, 87}, {209, 164, 0}} ,{{54, 87}, {210, 164, 0}} ,{{70, 87}, {226, 164, 0}} ,{{79, 87}, {235, 164, 0}} ,{{56, 87}, {212, 164, 0}} ,{{57, 87}, {213, 164, 0}} ,{{95, 87}, {251, 164, 0}} ,{{94, 87}, {250, 164, 0}} ,{{97, 87}, {253, 164, 0}} ,{{96, 87}, {252, 164, 0}} ,{{92, 87}, {248, 164, 0}} ,{{93, 87}, {249, 164, 0}} ,{{65, 87}, {221, 164, 0}} ,{{66, 87}, {222, 164, 0}} ,{{88, 87}, {244, 164, 0}} ,{{89, 87}, {245, 164, 0}} ,{{90, 87}, {246, 164, 0}} ,{{78, 87}, {234, 164, 0}} ,{{75, 87}, {231, 164, 0}} ,{{80, 87}, {236, 164, 0}} ,{{72, 87}, {228, 164, 0}} ,{{71, 87}, {227, 164, 0}} ,{{98, 87}, {254, 164, 0}} ,{{99, 87}, {255, 164, 0}} ,{{243, 64}, {182, 32, 0}} ,{{56, 66}, {39, 34, 0}} ,{{2, 74}, {81, 42, 0}} ,{{15, 74}, {94, 42, 0}} ,{{17, 74}, {96, 42, 0}} ,{{13, 74}, {92, 42, 0}} ,{{11, 74}, {90, 42, 0}} ,{{16, 74}, {95, 42, 0}} ,{{57, 66}, {40, 34, 0}} ,{{10, 74}, {89, 42, 0}} ,{{3, 74}, {82, 42, 0}} ,{{19, 74}, {98, 42, 0}} ,{{20, 74}, {99, 42, 0}} ,{{14, 74}, {93, 42, 0}} ,{{12, 74}, {91, 42, 0}} ,{{151, 74}, {230, 42, 0}} ,{{128, 71}, {204, 39, 0}} ,{{166, 71}, {245, 39, 0}} ,{{172, 71}, {251, 39, 0}} ,{{169, 71}, {248, 39, 0}} ,{{174, 71}, {253, 39, 0}} ,{{228, 74}, {51, 43, 0}} ,{{168, 71}, {247, 39, 0}} ,{{171, 71}, {250, 39, 0}} ,{{143, 71}, {222, 39, 0}} ,{{167, 71}, {246, 39, 0}} ,{{173, 71}, {252, 39, 0}} ,{{170, 71}, {249, 39, 0}} ,{{175, 71}, {254, 39, 0}} ,{{176, 71}, {255, 39, 0}} ,{{142, 71}, {221, 39, 0}} ,{{200, 70}, {3, 39, 0}} ,{{81, 69}, {133, 37, 0}} ,{{80, 69}, {132, 37, 0}} ,{{173, 69}, {225, 37, 0}} ,{{167, 69}, {219, 37, 0}} ,{{171, 69}, {223, 37, 0}} ,{{240, 72}, {63, 41, 0}} ,{{198, 69}, {250, 37, 0}} ,{{77, 69}, {129, 37, 0}} ,{{78, 69}, {130, 37, 0}} ,{{132, 71}, {211, 39, 0}} ,{{14, 71}, {79, 39, 0}} ,{{208, 70}, {14, 39, 0}} ,{{170, 69}, {222, 37, 0}} ,{{239, 72}, {62, 41, 0}} ,{{16, 71}, {81, 39, 0}} ,{{203, 69}, {255, 37, 0}} ,{{83, 69}, {135, 37, 0}} ,{{79, 69}, {131, 37, 0}} ,{{82, 69}, {134, 37, 0}} ,{{158, 64}, {78, 32, 0}} ,{{113, 78}, {31, 48, 0}} ,{{34, 38}, {95, 0, 0}} ,{{150, 69}, {202, 37, 0}} ,{{145, 71}, {224, 39, 0}} ,{{13, 144}, {128, 2, 1}} ,{{38, 144}, {153, 2, 1}} ,{{15, 144}, {130, 2, 1}} ,{{16, 144}, {131, 2, 1}} ,{{18, 144}, {133, 2, 1}} ,{{14, 144}, {129, 2, 1}} ,{{39, 144}, {154, 2, 1}} ,{{17, 144}, {132, 2, 1}} ,{{40, 144}, {155, 2, 1}} ,{{19, 144}, {134, 2, 1}} ,{{23, 144}, {138, 2, 1}} ,{{24, 144}, {139, 2, 1}} ,{{33, 144}, {148, 2, 1}} ,{{26, 144}, {141, 2, 1}} ,{{27, 144}, {142, 2, 1}} ,{{29, 144}, {144, 2, 1}} ,{{28, 144}, {143, 2, 1}} ,{{30, 144}, {145, 2, 1}} ,{{32, 144}, {147, 2, 1}} ,{{25, 144}, {140, 2, 1}} ,{{34, 144}, {149, 2, 1}} ,{{35, 144}, {150, 2, 1}} ,{{36, 144}, {151, 2, 1}} ,{{22, 144}, {137, 2, 1}} ,{{37, 144}, {152, 2, 1}} ,{{31, 144}, {146, 2, 1}} ,{{20, 144}, {135, 2, 1}} ,{{41, 144}, {156, 2, 1}} ,{{21, 144}, {136, 2, 1}} ,{{5, 146}, {32, 9, 1}} ,{{26, 146}, {53, 9, 1}} ,{{6, 146}, {33, 9, 1}} ,{{30, 146}, {57, 9, 1}} ,{{8, 146}, {35, 9, 1}} ,{{9, 146}, {36, 9, 1}} ,{{27, 146}, {54, 9, 1}} ,{{22, 146}, {49, 9, 1}} ,{{7, 146}, {34, 9, 1}} ,{{11, 146}, {38, 9, 1}} ,{{13, 146}, {40, 9, 1}} ,{{14, 146}, {41, 9, 1}} ,{{28, 146}, {55, 9, 1}} ,{{15, 146}, {42, 9, 1}} ,{{16, 146}, {43, 9, 1}} ,{{29, 146}, {56, 9, 1}} ,{{17, 146}, {44, 9, 1}} ,{{23, 146}, {50, 9, 1}} ,{{18, 146}, {45, 9, 1}} ,{{24, 146}, {51, 9, 1}} ,{{19, 146}, {46, 9, 1}} ,{{20, 146}, {47, 9, 1}} ,{{25, 146}, {52, 9, 1}} ,{{21, 146}, {48, 9, 1}} ,{{10, 146}, {37, 9, 1}} ,{{12, 146}, {39, 9, 1}} ,{{31, 146}, {63, 9, 1}} ,{{43, 65}, {20, 33, 0}} ,{{81, 38}, {175, 0, 0}} ,{{51, 162}, {40, 240, 1}} ,{{54, 162}, {43, 240, 1}} ,{{47, 162}, {36, 240, 1}} ,{{48, 162}, {37, 240, 1}} ,{{11, 162}, {0, 240, 1}} ,{{34, 162}, {23, 240, 1}} ,{{25, 162}, {14, 240, 1}} ,{{43, 162}, {32, 240, 1}} ,{{31, 162}, {20, 240, 1}} ,{{22, 162}, {11, 240, 1}} ,{{40, 162}, {29, 240, 1}} ,{{30, 162}, {19, 240, 1}} ,{{21, 162}, {10, 240, 1}} ,{{39, 162}, {28, 240, 1}} ,{{16, 162}, {5, 240, 1}} ,{{53, 162}, {42, 240, 1}} ,{{35, 162}, {24, 240, 1}} ,{{26, 162}, {15, 240, 1}} ,{{44, 162}, {33, 240, 1}} ,{{14, 162}, {3, 240, 1}} ,{{27, 162}, {16, 240, 1}} ,{{18, 162}, {7, 240, 1}} ,{{36, 162}, {25, 240, 1}} ,{{46, 162}, {35, 240, 1}} ,{{45, 162}, {34, 240, 1}} ,{{15, 162}, {4, 240, 1}} ,{{33, 162}, {22, 240, 1}} ,{{24, 162}, {13, 240, 1}} ,{{42, 162}, {31, 240, 1}} ,{{32, 162}, {21, 240, 1}} ,{{23, 162}, {12, 240, 1}} ,{{41, 162}, {30, 240, 1}} ,{{12, 162}, {1, 240, 1}} ,{{49, 162}, {38, 240, 1}} ,{{50, 162}, {39, 240, 1}} ,{{29, 162}, {18, 240, 1}} ,{{20, 162}, {9, 240, 1}} ,{{38, 162}, {27, 240, 1}} ,{{28, 162}, {17, 240, 1}} ,{{19, 162}, {8, 240, 1}} ,{{37, 162}, {26, 240, 1}} ,{{13, 162}, {2, 240, 1}} ,{{17, 162}, {6, 240, 1}} ,{{52, 162}, {41, 240, 1}} ,{{145, 48}, {87, 13, 0}} ,{{166, 48}, {121, 13, 0}} ,{{158, 48}, {110, 13, 0}} ,{{155, 48}, {107, 13, 0}} ,{{154, 48}, {106, 13, 0}} ,{{159, 48}, {111, 13, 0}} ,{{151, 48}, {103, 13, 0}} ,{{157, 48}, {109, 13, 0}} ,{{156, 48}, {108, 13, 0}} ,{{153, 48}, {105, 13, 0}} ,{{152, 48}, {104, 13, 0}} ,{{150, 48}, {102, 13, 0}} ,{{164, 48}, {116, 13, 0}} ,{{163, 48}, {115, 13, 0}} ,{{165, 48}, {117, 13, 0}} ,{{80, 48}, {5, 13, 0}} ,{{81, 48}, {6, 13, 0}} ,{{90, 48}, {16, 13, 0}} ,{{93, 48}, {20, 13, 0}} ,{{116, 48}, {44, 13, 0}} ,{{117, 48}, {45, 13, 0}} ,{{99, 48}, {26, 13, 0}} ,{{100, 48}, {27, 13, 0}} ,{{172, 48}, {127, 13, 0}} ,{{170, 48}, {125, 13, 0}} ,{{171, 48}, {126, 13, 0}} ,{{168, 48}, {123, 13, 0}} ,{{167, 48}, {122, 13, 0}} ,{{169, 48}, {124, 13, 0}} ,{{111, 48}, {38, 13, 0}} ,{{106, 48}, {33, 13, 0}} ,{{107, 48}, {34, 13, 0}} ,{{112, 48}, {39, 13, 0}} ,{{88, 48}, {14, 13, 0}} ,{{89, 48}, {15, 13, 0}} ,{{96, 48}, {23, 13, 0}} ,{{97, 48}, {24, 13, 0}} ,{{129, 48}, {57, 13, 0}} ,{{82, 48}, {7, 13, 0}} ,{{83, 48}, {8, 13, 0}} ,{{101, 48}, {28, 13, 0}} ,{{102, 48}, {29, 13, 0}} ,{{94, 48}, {21, 13, 0}} ,{{95, 48}, {22, 13, 0}} ,{{122, 48}, {50, 13, 0}} ,{{123, 48}, {51, 13, 0}} ,{{124, 48}, {52, 13, 0}} ,{{118, 48}, {46, 13, 0}} ,{{113, 48}, {40, 13, 0}} ,{{98, 48}, {25, 13, 0}} ,{{108, 48}, {35, 13, 0}} ,{{103, 48}, {30, 13, 0}} ,{{91, 48}, {18, 13, 0}} ,{{92, 48}, {19, 13, 0}} ,{{114, 48}, {42, 13, 0}} ,{{115, 48}, {43, 13, 0}} ,{{120, 48}, {48, 13, 0}} ,{{121, 48}, {49, 13, 0}} ,{{128, 48}, {56, 13, 0}} ,{{126, 48}, {54, 13, 0}} ,{{127, 48}, {55, 13, 0}} ,{{109, 48}, {36, 13, 0}} ,{{110, 48}, {37, 13, 0}} ,{{104, 48}, {31, 13, 0}} ,{{105, 48}, {32, 13, 0}} ,{{84, 48}, {9, 13, 0}} ,{{85, 48}, {10, 13, 0}} ,{{125, 48}, {53, 13, 0}} ,{{87, 48}, {12, 13, 0}} ,{{147, 48}, {97, 13, 0}} ,{{86, 48}, {11, 13, 0}} ,{{146, 48}, {96, 13, 0}} ,{{119, 48}, {47, 13, 0}} ,{{161, 48}, {113, 13, 0}} ,{{162, 48}, {114, 13, 0}} ,{{160, 48}, {112, 13, 0}} ,{{78, 48}, {2, 13, 0}} ,{{130, 48}, {61, 13, 0}} ,{{144, 48}, {77, 13, 0}} ,{{79, 48}, {3, 13, 0}} ,{{131, 48}, {62, 13, 0}} ,{{140, 48}, {72, 13, 0}} ,{{143, 48}, {76, 13, 0}} ,{{138, 48}, {70, 13, 0}} ,{{139, 48}, {71, 13, 0}} ,{{132, 48}, {63, 13, 0}} ,{{133, 48}, {64, 13, 0}} ,{{141, 48}, {74, 13, 0}} ,{{142, 48}, {75, 13, 0}} ,{{134, 48}, {65, 13, 0}} ,{{135, 48}, {66, 13, 0}} ,{{148, 48}, {98, 13, 0}} ,{{149, 48}, {99, 13, 0}} ,{{136, 48}, {67, 13, 0}} ,{{137, 48}, {68, 13, 0}} ,{{113, 70}, {165, 38, 0}} ,{{14, 70}, {66, 38, 0}} ,{{115, 70}, {167, 38, 0}} ,{{114, 70}, {166, 38, 0}} ,{{226, 70}, {32, 39, 0}} ,{{181, 70}, {239, 38, 0}} ,{{121, 70}, {173, 38, 0}} ,{{92, 38}, {186, 0, 0}} ,{{142, 78}, {60, 48, 0}} ,{{39, 158}, {0, 212, 1}} ,{{181, 160}, {168, 214, 1}} ,{{40, 158}, {1, 212, 1}} ,{{182, 160}, {169, 214, 1}} ,{{41, 158}, {2, 212, 1}} ,{{203, 160}, {190, 214, 1}} ,{{42, 158}, {3, 212, 1}} ,{{184, 160}, {171, 214, 1}} ,{{215, 161}, {202, 215, 1}} ,{{43, 158}, {4, 212, 1}} ,{{185, 160}, {172, 214, 1}} ,{{187, 160}, {174, 214, 1}} ,{{44, 158}, {5, 212, 1}} ,{{45, 158}, {6, 212, 1}} ,{{183, 160}, {170, 214, 1}} ,{{46, 158}, {7, 212, 1}} ,{{47, 158}, {8, 212, 1}} ,{{189, 160}, {176, 214, 1}} ,{{48, 158}, {9, 212, 1}} ,{{49, 158}, {10, 212, 1}} ,{{190, 160}, {177, 214, 1}} ,{{50, 158}, {11, 212, 1}} ,{{191, 160}, {178, 214, 1}} ,{{51, 158}, {12, 212, 1}} ,{{192, 160}, {179, 214, 1}} ,{{52, 158}, {13, 212, 1}} ,{{193, 160}, {180, 214, 1}} ,{{53, 158}, {14, 212, 1}} ,{{205, 160}, {192, 214, 1}} ,{{195, 160}, {182, 214, 1}} ,{{54, 158}, {15, 212, 1}} ,{{202, 160}, {189, 214, 1}} ,{{196, 160}, {183, 214, 1}} ,{{204, 160}, {191, 214, 1}} ,{{55, 158}, {16, 212, 1}} ,{{56, 158}, {17, 212, 1}} ,{{197, 160}, {184, 214, 1}} ,{{57, 158}, {18, 212, 1}} ,{{199, 160}, {186, 214, 1}} ,{{58, 158}, {19, 212, 1}} ,{{200, 160}, {187, 214, 1}} ,{{188, 160}, {175, 214, 1}} ,{{198, 160}, {185, 214, 1}} ,{{59, 158}, {20, 212, 1}} ,{{201, 160}, {188, 214, 1}} ,{{60, 158}, {21, 212, 1}} ,{{61, 158}, {22, 212, 1}} ,{{62, 158}, {23, 212, 1}} ,{{194, 160}, {181, 214, 1}} ,{{63, 158}, {24, 212, 1}} ,{{64, 158}, {25, 212, 1}} ,{{186, 160}, {173, 214, 1}} ,{{225, 161}, {214, 215, 1}} ,{{222, 161}, {211, 215, 1}} ,{{221, 161}, {210, 215, 1}} ,{{226, 161}, {215, 215, 1}} ,{{218, 161}, {207, 215, 1}} ,{{224, 161}, {213, 215, 1}} ,{{223, 161}, {212, 215, 1}} ,{{220, 161}, {209, 215, 1}} ,{{219, 161}, {208, 215, 1}} ,{{217, 161}, {206, 215, 1}} ,{{233, 160}, {220, 214, 1}} ,{{123, 159}, {108, 213, 1}} ,{{124, 159}, {109, 213, 1}} ,{{125, 159}, {110, 213, 1}} ,{{126, 159}, {111, 213, 1}} ,{{127, 159}, {112, 213, 1}} ,{{128, 159}, {113, 213, 1}} ,{{129, 159}, {114, 213, 1}} ,{{130, 159}, {115, 213, 1}} ,{{131, 159}, {116, 213, 1}} ,{{132, 159}, {117, 213, 1}} ,{{133, 159}, {118, 213, 1}} ,{{134, 159}, {119, 213, 1}} ,{{135, 159}, {120, 213, 1}} ,{{136, 159}, {121, 213, 1}} ,{{137, 159}, {122, 213, 1}} ,{{138, 159}, {123, 213, 1}} ,{{139, 159}, {124, 213, 1}} ,{{140, 159}, {125, 213, 1}} ,{{141, 159}, {126, 213, 1}} ,{{142, 159}, {127, 213, 1}} ,{{143, 159}, {128, 213, 1}} ,{{144, 159}, {129, 213, 1}} ,{{145, 159}, {130, 213, 1}} ,{{146, 159}, {131, 213, 1}} ,{{147, 159}, {132, 213, 1}} ,{{148, 159}, {133, 213, 1}} ,{{149, 159}, {134, 213, 1}} ,{{150, 159}, {135, 213, 1}} ,{{151, 159}, {136, 213, 1}} ,{{152, 159}, {137, 213, 1}} ,{{153, 159}, {138, 213, 1}} ,{{154, 159}, {139, 213, 1}} ,{{155, 159}, {140, 213, 1}} ,{{156, 159}, {141, 213, 1}} ,{{157, 159}, {142, 213, 1}} ,{{158, 159}, {143, 213, 1}} ,{{159, 159}, {144, 213, 1}} ,{{160, 159}, {145, 213, 1}} ,{{161, 159}, {146, 213, 1}} ,{{162, 159}, {147, 213, 1}} ,{{163, 159}, {148, 213, 1}} ,{{164, 159}, {149, 213, 1}} ,{{165, 159}, {150, 213, 1}} ,{{166, 159}, {151, 213, 1}} ,{{167, 159}, {152, 213, 1}} ,{{168, 159}, {153, 213, 1}} ,{{169, 159}, {154, 213, 1}} ,{{170, 159}, {155, 213, 1}} ,{{171, 159}, {156, 213, 1}} ,{{172, 159}, {157, 213, 1}} ,{{173, 159}, {158, 213, 1}} ,{{174, 159}, {159, 213, 1}} ,{{142, 158}, {104, 212, 1}} ,{{41, 161}, {28, 215, 1}} ,{{143, 158}, {105, 212, 1}} ,{{42, 161}, {29, 215, 1}} ,{{144, 158}, {106, 212, 1}} ,{{63, 161}, {50, 215, 1}} ,{{145, 158}, {107, 212, 1}} ,{{44, 161}, {31, 215, 1}} ,{{146, 158}, {108, 212, 1}} ,{{45, 161}, {32, 215, 1}} ,{{47, 161}, {34, 215, 1}} ,{{147, 158}, {109, 212, 1}} ,{{148, 158}, {110, 212, 1}} ,{{43, 161}, {30, 215, 1}} ,{{149, 158}, {111, 212, 1}} ,{{150, 158}, {112, 212, 1}} ,{{49, 161}, {36, 215, 1}} ,{{151, 158}, {113, 212, 1}} ,{{152, 158}, {114, 212, 1}} ,{{50, 161}, {37, 215, 1}} ,{{153, 158}, {115, 212, 1}} ,{{51, 161}, {38, 215, 1}} ,{{154, 158}, {116, 212, 1}} ,{{52, 161}, {39, 215, 1}} ,{{155, 158}, {117, 212, 1}} ,{{53, 161}, {40, 215, 1}} ,{{156, 158}, {118, 212, 1}} ,{{65, 161}, {52, 215, 1}} ,{{55, 161}, {42, 215, 1}} ,{{157, 158}, {119, 212, 1}} ,{{62, 161}, {49, 215, 1}} ,{{56, 161}, {43, 215, 1}} ,{{64, 161}, {51, 215, 1}} ,{{158, 158}, {120, 212, 1}} ,{{159, 158}, {121, 212, 1}} ,{{57, 161}, {44, 215, 1}} ,{{160, 158}, {122, 212, 1}} ,{{59, 161}, {46, 215, 1}} ,{{161, 158}, {123, 212, 1}} ,{{60, 161}, {47, 215, 1}} ,{{48, 161}, {35, 215, 1}} ,{{58, 161}, {45, 215, 1}} ,{{162, 158}, {124, 212, 1}} ,{{61, 161}, {48, 215, 1}} ,{{163, 158}, {125, 212, 1}} ,{{164, 158}, {126, 212, 1}} ,{{165, 158}, {127, 212, 1}} ,{{54, 161}, {41, 215, 1}} ,{{166, 158}, {128, 212, 1}} ,{{167, 158}, {129, 212, 1}} ,{{46, 161}, {33, 215, 1}} ,{{93, 161}, {80, 215, 1}} ,{{95, 161}, {82, 215, 1}} ,{{66, 161}, {53, 215, 1}} ,{{92, 161}, {79, 215, 1}} ,{{96, 161}, {83, 215, 1}} ,{{98, 161}, {85, 215, 1}} ,{{97, 161}, {84, 215, 1}} ,{{168, 158}, {130, 212, 1}} ,{{67, 161}, {54, 215, 1}} ,{{169, 158}, {131, 212, 1}} ,{{68, 161}, {55, 215, 1}} ,{{170, 158}, {132, 212, 1}} ,{{89, 161}, {76, 215, 1}} ,{{171, 158}, {133, 212, 1}} ,{{70, 161}, {57, 215, 1}} ,{{172, 158}, {134, 212, 1}} ,{{71, 161}, {58, 215, 1}} ,{{73, 161}, {60, 215, 1}} ,{{173, 158}, {135, 212, 1}} ,{{84, 161}, {71, 215, 1}} ,{{174, 158}, {136, 212, 1}} ,{{69, 161}, {56, 215, 1}} ,{{175, 158}, {137, 212, 1}} ,{{176, 158}, {138, 212, 1}} ,{{75, 161}, {62, 215, 1}} ,{{177, 158}, {139, 212, 1}} ,{{178, 158}, {140, 212, 1}} ,{{76, 161}, {63, 215, 1}} ,{{179, 158}, {141, 212, 1}} ,{{77, 161}, {64, 215, 1}} ,{{180, 158}, {142, 212, 1}} ,{{78, 161}, {65, 215, 1}} ,{{181, 158}, {143, 212, 1}} ,{{79, 161}, {66, 215, 1}} ,{{182, 158}, {144, 212, 1}} ,{{91, 161}, {78, 215, 1}} ,{{81, 161}, {68, 215, 1}} ,{{183, 158}, {145, 212, 1}} ,{{88, 161}, {75, 215, 1}} ,{{82, 161}, {69, 215, 1}} ,{{90, 161}, {77, 215, 1}} ,{{184, 158}, {146, 212, 1}} ,{{185, 158}, {147, 212, 1}} ,{{83, 161}, {70, 215, 1}} ,{{186, 158}, {148, 212, 1}} ,{{85, 161}, {72, 215, 1}} ,{{187, 158}, {149, 212, 1}} ,{{86, 161}, {73, 215, 1}} ,{{74, 161}, {61, 215, 1}} ,{{188, 158}, {150, 212, 1}} ,{{87, 161}, {74, 215, 1}} ,{{189, 158}, {151, 212, 1}} ,{{190, 158}, {152, 212, 1}} ,{{191, 158}, {153, 212, 1}} ,{{80, 161}, {67, 215, 1}} ,{{192, 158}, {154, 212, 1}} ,{{193, 158}, {155, 212, 1}} ,{{72, 161}, {59, 215, 1}} ,{{94, 161}, {81, 215, 1}} ,{{235, 160}, {222, 214, 1}} ,{{206, 160}, {193, 214, 1}} ,{{232, 160}, {219, 214, 1}} ,{{236, 160}, {223, 214, 1}} ,{{238, 160}, {225, 214, 1}} ,{{237, 160}, {224, 214, 1}} ,{{235, 158}, {208, 212, 1}} ,{{236, 158}, {209, 212, 1}} ,{{237, 158}, {210, 212, 1}} ,{{238, 158}, {211, 212, 1}} ,{{239, 158}, {212, 212, 1}} ,{{240, 158}, {213, 212, 1}} ,{{241, 158}, {214, 212, 1}} ,{{242, 158}, {215, 212, 1}} ,{{243, 158}, {216, 212, 1}} ,{{244, 158}, {217, 212, 1}} ,{{245, 158}, {218, 212, 1}} ,{{246, 158}, {219, 212, 1}} ,{{247, 158}, {220, 212, 1}} ,{{248, 158}, {221, 212, 1}} ,{{249, 158}, {222, 212, 1}} ,{{250, 158}, {223, 212, 1}} ,{{251, 158}, {224, 212, 1}} ,{{252, 158}, {225, 212, 1}} ,{{253, 158}, {226, 212, 1}} ,{{254, 158}, {227, 212, 1}} ,{{255, 158}, {228, 212, 1}} ,{{0, 159}, {229, 212, 1}} ,{{1, 159}, {230, 212, 1}} ,{{2, 159}, {231, 212, 1}} ,{{3, 159}, {232, 212, 1}} ,{{4, 159}, {233, 212, 1}} ,{{5, 159}, {234, 212, 1}} ,{{6, 159}, {235, 212, 1}} ,{{7, 159}, {236, 212, 1}} ,{{8, 159}, {237, 212, 1}} ,{{9, 159}, {238, 212, 1}} ,{{10, 159}, {239, 212, 1}} ,{{11, 159}, {240, 212, 1}} ,{{12, 159}, {241, 212, 1}} ,{{13, 159}, {242, 212, 1}} ,{{14, 159}, {243, 212, 1}} ,{{15, 159}, {244, 212, 1}} ,{{16, 159}, {245, 212, 1}} ,{{17, 159}, {246, 212, 1}} ,{{18, 159}, {247, 212, 1}} ,{{19, 159}, {248, 212, 1}} ,{{20, 159}, {249, 212, 1}} ,{{21, 159}, {250, 212, 1}} ,{{22, 159}, {251, 212, 1}} ,{{23, 159}, {252, 212, 1}} ,{{24, 159}, {253, 212, 1}} ,{{25, 159}, {254, 212, 1}} ,{{26, 159}, {255, 212, 1}} ,{{27, 159}, {0, 213, 1}} ,{{28, 159}, {1, 213, 1}} ,{{29, 159}, {2, 213, 1}} ,{{30, 159}, {3, 213, 1}} ,{{65, 158}, {26, 212, 1}} ,{{207, 160}, {194, 214, 1}} ,{{66, 158}, {27, 212, 1}} ,{{208, 160}, {195, 214, 1}} ,{{67, 158}, {28, 212, 1}} ,{{229, 160}, {216, 214, 1}} ,{{68, 158}, {29, 212, 1}} ,{{210, 160}, {197, 214, 1}} ,{{216, 161}, {203, 215, 1}} ,{{69, 158}, {30, 212, 1}} ,{{211, 160}, {198, 214, 1}} ,{{213, 160}, {200, 214, 1}} ,{{70, 158}, {31, 212, 1}} ,{{224, 160}, {211, 214, 1}} ,{{71, 158}, {32, 212, 1}} ,{{209, 160}, {196, 214, 1}} ,{{72, 158}, {33, 212, 1}} ,{{73, 158}, {34, 212, 1}} ,{{215, 160}, {202, 214, 1}} ,{{74, 158}, {35, 212, 1}} ,{{75, 158}, {36, 212, 1}} ,{{216, 160}, {203, 214, 1}} ,{{76, 158}, {37, 212, 1}} ,{{217, 160}, {204, 214, 1}} ,{{77, 158}, {38, 212, 1}} ,{{218, 160}, {205, 214, 1}} ,{{78, 158}, {39, 212, 1}} ,{{219, 160}, {206, 214, 1}} ,{{79, 158}, {40, 212, 1}} ,{{231, 160}, {218, 214, 1}} ,{{221, 160}, {208, 214, 1}} ,{{80, 158}, {41, 212, 1}} ,{{228, 160}, {215, 214, 1}} ,{{222, 160}, {209, 214, 1}} ,{{230, 160}, {217, 214, 1}} ,{{81, 158}, {42, 212, 1}} ,{{82, 158}, {43, 212, 1}} ,{{223, 160}, {210, 214, 1}} ,{{83, 158}, {44, 212, 1}} ,{{225, 160}, {212, 214, 1}} ,{{84, 158}, {45, 212, 1}} ,{{226, 160}, {213, 214, 1}} ,{{214, 160}, {201, 214, 1}} ,{{85, 158}, {46, 212, 1}} ,{{227, 160}, {214, 214, 1}} ,{{86, 158}, {47, 212, 1}} ,{{87, 158}, {48, 212, 1}} ,{{88, 158}, {49, 212, 1}} ,{{220, 160}, {207, 214, 1}} ,{{89, 158}, {50, 212, 1}} ,{{90, 158}, {51, 212, 1}} ,{{212, 160}, {199, 214, 1}} ,{{234, 160}, {221, 214, 1}} ,{{78, 159}, {56, 213, 1}} ,{{79, 159}, {57, 213, 1}} ,{{80, 159}, {59, 213, 1}} ,{{81, 159}, {60, 213, 1}} ,{{82, 159}, {61, 213, 1}} ,{{83, 159}, {62, 213, 1}} ,{{84, 159}, {64, 213, 1}} ,{{85, 159}, {65, 213, 1}} ,{{86, 159}, {66, 213, 1}} ,{{87, 159}, {67, 213, 1}} ,{{88, 159}, {68, 213, 1}} ,{{89, 159}, {70, 213, 1}} ,{{90, 159}, {74, 213, 1}} ,{{91, 159}, {75, 213, 1}} ,{{92, 159}, {76, 213, 1}} ,{{93, 159}, {77, 213, 1}} ,{{94, 159}, {78, 213, 1}} ,{{95, 159}, {79, 213, 1}} ,{{96, 159}, {80, 213, 1}} ,{{235, 161}, {224, 215, 1}} ,{{232, 161}, {221, 215, 1}} ,{{231, 161}, {220, 215, 1}} ,{{236, 161}, {225, 215, 1}} ,{{228, 161}, {217, 215, 1}} ,{{234, 161}, {223, 215, 1}} ,{{233, 161}, {222, 215, 1}} ,{{230, 161}, {219, 215, 1}} ,{{229, 161}, {218, 215, 1}} ,{{227, 161}, {216, 215, 1}} ,{{97, 159}, {82, 213, 1}} ,{{98, 159}, {83, 213, 1}} ,{{99, 159}, {84, 213, 1}} ,{{100, 159}, {85, 213, 1}} ,{{101, 159}, {86, 213, 1}} ,{{102, 159}, {87, 213, 1}} ,{{103, 159}, {88, 213, 1}} ,{{104, 159}, {89, 213, 1}} ,{{105, 159}, {90, 213, 1}} ,{{106, 159}, {91, 213, 1}} ,{{107, 159}, {92, 213, 1}} ,{{108, 159}, {93, 213, 1}} ,{{109, 159}, {94, 213, 1}} ,{{110, 159}, {95, 213, 1}} ,{{111, 159}, {96, 213, 1}} ,{{112, 159}, {97, 213, 1}} ,{{113, 159}, {98, 213, 1}} ,{{114, 159}, {99, 213, 1}} ,{{115, 159}, {100, 213, 1}} ,{{116, 159}, {101, 213, 1}} ,{{117, 159}, {102, 213, 1}} ,{{118, 159}, {103, 213, 1}} ,{{119, 159}, {104, 213, 1}} ,{{120, 159}, {105, 213, 1}} ,{{121, 159}, {106, 213, 1}} ,{{122, 159}, {107, 213, 1}} ,{{31, 159}, {4, 213, 1}} ,{{32, 159}, {5, 213, 1}} ,{{33, 159}, {7, 213, 1}} ,{{34, 159}, {8, 213, 1}} ,{{35, 159}, {9, 213, 1}} ,{{36, 159}, {10, 213, 1}} ,{{37, 159}, {13, 213, 1}} ,{{38, 159}, {14, 213, 1}} ,{{39, 159}, {15, 213, 1}} ,{{40, 159}, {16, 213, 1}} ,{{41, 159}, {17, 213, 1}} ,{{42, 159}, {18, 213, 1}} ,{{43, 159}, {19, 213, 1}} ,{{44, 159}, {20, 213, 1}} ,{{45, 159}, {22, 213, 1}} ,{{46, 159}, {23, 213, 1}} ,{{47, 159}, {24, 213, 1}} ,{{48, 159}, {25, 213, 1}} ,{{49, 159}, {26, 213, 1}} ,{{50, 159}, {27, 213, 1}} ,{{51, 159}, {28, 213, 1}} ,{{52, 159}, {30, 213, 1}} ,{{53, 159}, {31, 213, 1}} ,{{54, 159}, {32, 213, 1}} ,{{55, 159}, {33, 213, 1}} ,{{56, 159}, {34, 213, 1}} ,{{57, 159}, {35, 213, 1}} ,{{58, 159}, {36, 213, 1}} ,{{59, 159}, {37, 213, 1}} ,{{60, 159}, {38, 213, 1}} ,{{61, 159}, {39, 213, 1}} ,{{62, 159}, {40, 213, 1}} ,{{63, 159}, {41, 213, 1}} ,{{64, 159}, {42, 213, 1}} ,{{65, 159}, {43, 213, 1}} ,{{66, 159}, {44, 213, 1}} ,{{67, 159}, {45, 213, 1}} ,{{68, 159}, {46, 213, 1}} ,{{69, 159}, {47, 213, 1}} ,{{70, 159}, {48, 213, 1}} ,{{71, 159}, {49, 213, 1}} ,{{72, 159}, {50, 213, 1}} ,{{73, 159}, {51, 213, 1}} ,{{74, 159}, {52, 213, 1}} ,{{75, 159}, {53, 213, 1}} ,{{76, 159}, {54, 213, 1}} ,{{77, 159}, {55, 213, 1}} ,{{91, 158}, {52, 212, 1}} ,{{239, 160}, {226, 214, 1}} ,{{92, 158}, {53, 212, 1}} ,{{240, 160}, {227, 214, 1}} ,{{93, 158}, {54, 212, 1}} ,{{5, 161}, {248, 214, 1}} ,{{94, 158}, {55, 212, 1}} ,{{242, 160}, {229, 214, 1}} ,{{95, 158}, {56, 212, 1}} ,{{243, 160}, {230, 214, 1}} ,{{245, 160}, {232, 214, 1}} ,{{96, 158}, {57, 212, 1}} ,{{97, 158}, {58, 212, 1}} ,{{241, 160}, {228, 214, 1}} ,{{98, 158}, {59, 212, 1}} ,{{99, 158}, {60, 212, 1}} ,{{247, 160}, {234, 214, 1}} ,{{100, 158}, {61, 212, 1}} ,{{101, 158}, {62, 212, 1}} ,{{248, 160}, {235, 214, 1}} ,{{102, 158}, {63, 212, 1}} ,{{249, 160}, {236, 214, 1}} ,{{103, 158}, {64, 212, 1}} ,{{250, 160}, {237, 214, 1}} ,{{104, 158}, {65, 212, 1}} ,{{251, 160}, {238, 214, 1}} ,{{105, 158}, {66, 212, 1}} ,{{7, 161}, {250, 214, 1}} ,{{253, 160}, {240, 214, 1}} ,{{106, 158}, {67, 212, 1}} ,{{4, 161}, {247, 214, 1}} ,{{254, 160}, {241, 214, 1}} ,{{6, 161}, {249, 214, 1}} ,{{107, 158}, {68, 212, 1}} ,{{108, 158}, {69, 212, 1}} ,{{255, 160}, {242, 214, 1}} ,{{109, 158}, {70, 212, 1}} ,{{1, 161}, {244, 214, 1}} ,{{110, 158}, {71, 212, 1}} ,{{2, 161}, {245, 214, 1}} ,{{246, 160}, {233, 214, 1}} ,{{0, 161}, {243, 214, 1}} ,{{111, 158}, {72, 212, 1}} ,{{3, 161}, {246, 214, 1}} ,{{112, 158}, {73, 212, 1}} ,{{113, 158}, {74, 212, 1}} ,{{114, 158}, {75, 212, 1}} ,{{252, 160}, {239, 214, 1}} ,{{115, 158}, {76, 212, 1}} ,{{116, 158}, {77, 212, 1}} ,{{244, 160}, {231, 214, 1}} ,{{35, 161}, {22, 215, 1}} ,{{37, 161}, {24, 215, 1}} ,{{8, 161}, {251, 214, 1}} ,{{34, 161}, {21, 215, 1}} ,{{38, 161}, {25, 215, 1}} ,{{40, 161}, {27, 215, 1}} ,{{39, 161}, {26, 215, 1}} ,{{117, 158}, {78, 212, 1}} ,{{9, 161}, {252, 214, 1}} ,{{118, 158}, {79, 212, 1}} ,{{10, 161}, {253, 214, 1}} ,{{119, 158}, {80, 212, 1}} ,{{31, 161}, {18, 215, 1}} ,{{120, 158}, {81, 212, 1}} ,{{12, 161}, {255, 214, 1}} ,{{179, 160}, {164, 214, 1}} ,{{180, 160}, {165, 214, 1}} ,{{121, 158}, {82, 212, 1}} ,{{13, 161}, {0, 215, 1}} ,{{15, 161}, {2, 215, 1}} ,{{122, 158}, {83, 212, 1}} ,{{26, 161}, {13, 215, 1}} ,{{123, 158}, {84, 212, 1}} ,{{11, 161}, {254, 214, 1}} ,{{124, 158}, {86, 212, 1}} ,{{17, 161}, {4, 215, 1}} ,{{125, 158}, {87, 212, 1}} ,{{126, 158}, {88, 212, 1}} ,{{18, 161}, {5, 215, 1}} ,{{127, 158}, {89, 212, 1}} ,{{19, 161}, {6, 215, 1}} ,{{128, 158}, {90, 212, 1}} ,{{20, 161}, {7, 215, 1}} ,{{129, 158}, {91, 212, 1}} ,{{21, 161}, {8, 215, 1}} ,{{130, 158}, {92, 212, 1}} ,{{33, 161}, {20, 215, 1}} ,{{23, 161}, {10, 215, 1}} ,{{131, 158}, {93, 212, 1}} ,{{30, 161}, {17, 215, 1}} ,{{24, 161}, {11, 215, 1}} ,{{32, 161}, {19, 215, 1}} ,{{132, 158}, {94, 212, 1}} ,{{133, 158}, {95, 212, 1}} ,{{25, 161}, {12, 215, 1}} ,{{134, 158}, {96, 212, 1}} ,{{27, 161}, {14, 215, 1}} ,{{135, 158}, {97, 212, 1}} ,{{28, 161}, {15, 215, 1}} ,{{16, 161}, {3, 215, 1}} ,{{136, 158}, {98, 212, 1}} ,{{29, 161}, {16, 215, 1}} ,{{137, 158}, {99, 212, 1}} ,{{138, 158}, {100, 212, 1}} ,{{139, 158}, {101, 212, 1}} ,{{22, 161}, {9, 215, 1}} ,{{140, 158}, {102, 212, 1}} ,{{141, 158}, {103, 212, 1}} ,{{14, 161}, {1, 215, 1}} ,{{36, 161}, {23, 215, 1}} ,{{153, 71}, {232, 39, 0}} ,{{155, 71}, {234, 39, 0}} ,{{159, 71}, {238, 39, 0}} ,{{151, 71}, {230, 39, 0}} ,{{157, 71}, {236, 39, 0}} ,{{127, 160}, {112, 214, 1}} ,{{128, 160}, {113, 214, 1}} ,{{129, 160}, {114, 214, 1}} ,{{130, 160}, {115, 214, 1}} ,{{131, 160}, {116, 214, 1}} ,{{132, 160}, {117, 214, 1}} ,{{133, 160}, {118, 214, 1}} ,{{134, 160}, {119, 214, 1}} ,{{135, 160}, {120, 214, 1}} ,{{136, 160}, {121, 214, 1}} ,{{137, 160}, {122, 214, 1}} ,{{138, 160}, {123, 214, 1}} ,{{139, 160}, {124, 214, 1}} ,{{140, 160}, {125, 214, 1}} ,{{141, 160}, {126, 214, 1}} ,{{142, 160}, {127, 214, 1}} ,{{143, 160}, {128, 214, 1}} ,{{144, 160}, {129, 214, 1}} ,{{145, 160}, {130, 214, 1}} ,{{146, 160}, {131, 214, 1}} ,{{147, 160}, {132, 214, 1}} ,{{148, 160}, {133, 214, 1}} ,{{149, 160}, {134, 214, 1}} ,{{150, 160}, {135, 214, 1}} ,{{151, 160}, {136, 214, 1}} ,{{152, 160}, {137, 214, 1}} ,{{9, 162}, {254, 215, 1}} ,{{6, 162}, {251, 215, 1}} ,{{5, 162}, {250, 215, 1}} ,{{10, 162}, {255, 215, 1}} ,{{2, 162}, {247, 215, 1}} ,{{8, 162}, {253, 215, 1}} ,{{7, 162}, {252, 215, 1}} ,{{4, 162}, {249, 215, 1}} ,{{3, 162}, {248, 215, 1}} ,{{1, 162}, {246, 215, 1}} ,{{153, 160}, {138, 214, 1}} ,{{154, 160}, {139, 214, 1}} ,{{155, 160}, {140, 214, 1}} ,{{156, 160}, {141, 214, 1}} ,{{157, 160}, {142, 214, 1}} ,{{158, 160}, {143, 214, 1}} ,{{159, 160}, {144, 214, 1}} ,{{160, 160}, {145, 214, 1}} ,{{161, 160}, {146, 214, 1}} ,{{162, 160}, {147, 214, 1}} ,{{163, 160}, {148, 214, 1}} ,{{164, 160}, {149, 214, 1}} ,{{165, 160}, {150, 214, 1}} ,{{166, 160}, {151, 214, 1}} ,{{167, 160}, {152, 214, 1}} ,{{168, 160}, {153, 214, 1}} ,{{169, 160}, {154, 214, 1}} ,{{170, 160}, {155, 214, 1}} ,{{171, 160}, {156, 214, 1}} ,{{172, 160}, {157, 214, 1}} ,{{173, 160}, {158, 214, 1}} ,{{174, 160}, {159, 214, 1}} ,{{175, 160}, {160, 214, 1}} ,{{176, 160}, {161, 214, 1}} ,{{177, 160}, {162, 214, 1}} ,{{178, 160}, {163, 214, 1}} ,{{154, 71}, {233, 39, 0}} ,{{156, 71}, {235, 39, 0}} ,{{160, 71}, {239, 39, 0}} ,{{152, 71}, {231, 39, 0}} ,{{158, 71}, {237, 39, 0}} ,{{227, 159}, {212, 213, 1}} ,{{99, 161}, {86, 215, 1}} ,{{228, 159}, {213, 213, 1}} ,{{100, 161}, {87, 215, 1}} ,{{229, 159}, {214, 213, 1}} ,{{121, 161}, {108, 215, 1}} ,{{230, 159}, {215, 213, 1}} ,{{102, 161}, {89, 215, 1}} ,{{231, 159}, {216, 213, 1}} ,{{103, 161}, {90, 215, 1}} ,{{105, 161}, {92, 215, 1}} ,{{232, 159}, {217, 213, 1}} ,{{233, 159}, {218, 213, 1}} ,{{101, 161}, {88, 215, 1}} ,{{234, 159}, {219, 213, 1}} ,{{235, 159}, {220, 213, 1}} ,{{107, 161}, {94, 215, 1}} ,{{236, 159}, {221, 213, 1}} ,{{237, 159}, {222, 213, 1}} ,{{108, 161}, {95, 215, 1}} ,{{238, 159}, {223, 213, 1}} ,{{109, 161}, {96, 215, 1}} ,{{239, 159}, {224, 213, 1}} ,{{110, 161}, {97, 215, 1}} ,{{240, 159}, {225, 213, 1}} ,{{111, 161}, {98, 215, 1}} ,{{241, 159}, {226, 213, 1}} ,{{123, 161}, {110, 215, 1}} ,{{113, 161}, {100, 215, 1}} ,{{242, 159}, {227, 213, 1}} ,{{120, 161}, {107, 215, 1}} ,{{114, 161}, {101, 215, 1}} ,{{122, 161}, {109, 215, 1}} ,{{243, 159}, {228, 213, 1}} ,{{244, 159}, {229, 213, 1}} ,{{115, 161}, {102, 215, 1}} ,{{245, 159}, {230, 213, 1}} ,{{117, 161}, {104, 215, 1}} ,{{246, 159}, {231, 213, 1}} ,{{118, 161}, {105, 215, 1}} ,{{106, 161}, {93, 215, 1}} ,{{116, 161}, {103, 215, 1}} ,{{247, 159}, {232, 213, 1}} ,{{119, 161}, {106, 215, 1}} ,{{248, 159}, {233, 213, 1}} ,{{249, 159}, {234, 213, 1}} ,{{250, 159}, {235, 213, 1}} ,{{112, 161}, {99, 215, 1}} ,{{251, 159}, {236, 213, 1}} ,{{252, 159}, {237, 213, 1}} ,{{104, 161}, {91, 215, 1}} ,{{255, 161}, {244, 215, 1}} ,{{252, 161}, {241, 215, 1}} ,{{251, 161}, {240, 215, 1}} ,{{0, 162}, {245, 215, 1}} ,{{248, 161}, {237, 215, 1}} ,{{254, 161}, {243, 215, 1}} ,{{253, 161}, {242, 215, 1}} ,{{250, 161}, {239, 215, 1}} ,{{249, 161}, {238, 215, 1}} ,{{247, 161}, {236, 215, 1}} ,{{151, 161}, {138, 215, 1}} ,{{75, 160}, {60, 214, 1}} ,{{157, 161}, {144, 215, 1}} ,{{76, 160}, {61, 214, 1}} ,{{158, 161}, {145, 215, 1}} ,{{77, 160}, {62, 214, 1}} ,{{179, 161}, {166, 215, 1}} ,{{78, 160}, {63, 214, 1}} ,{{160, 161}, {147, 215, 1}} ,{{79, 160}, {64, 214, 1}} ,{{161, 161}, {148, 215, 1}} ,{{163, 161}, {150, 215, 1}} ,{{80, 160}, {65, 214, 1}} ,{{81, 160}, {66, 214, 1}} ,{{159, 161}, {146, 215, 1}} ,{{82, 160}, {67, 214, 1}} ,{{83, 160}, {68, 214, 1}} ,{{165, 161}, {152, 215, 1}} ,{{84, 160}, {69, 214, 1}} ,{{85, 160}, {70, 214, 1}} ,{{166, 161}, {153, 215, 1}} ,{{86, 160}, {71, 214, 1}} ,{{167, 161}, {154, 215, 1}} ,{{87, 160}, {72, 214, 1}} ,{{168, 161}, {155, 215, 1}} ,{{88, 160}, {73, 214, 1}} ,{{169, 161}, {156, 215, 1}} ,{{89, 160}, {74, 214, 1}} ,{{181, 161}, {168, 215, 1}} ,{{171, 161}, {158, 215, 1}} ,{{90, 160}, {75, 214, 1}} ,{{178, 161}, {165, 215, 1}} ,{{172, 161}, {159, 215, 1}} ,{{180, 161}, {167, 215, 1}} ,{{91, 160}, {76, 214, 1}} ,{{92, 160}, {77, 214, 1}} ,{{173, 161}, {160, 215, 1}} ,{{93, 160}, {78, 214, 1}} ,{{175, 161}, {162, 215, 1}} ,{{94, 160}, {79, 214, 1}} ,{{176, 161}, {163, 215, 1}} ,{{164, 161}, {151, 215, 1}} ,{{174, 161}, {161, 215, 1}} ,{{95, 160}, {80, 214, 1}} ,{{177, 161}, {164, 215, 1}} ,{{96, 160}, {81, 214, 1}} ,{{97, 160}, {82, 214, 1}} ,{{98, 160}, {83, 214, 1}} ,{{170, 161}, {157, 215, 1}} ,{{99, 160}, {84, 214, 1}} ,{{100, 160}, {85, 214, 1}} ,{{162, 161}, {149, 215, 1}} ,{{209, 161}, {196, 215, 1}} ,{{211, 161}, {198, 215, 1}} ,{{182, 161}, {169, 215, 1}} ,{{208, 161}, {195, 215, 1}} ,{{212, 161}, {199, 215, 1}} ,{{214, 161}, {201, 215, 1}} ,{{213, 161}, {200, 215, 1}} ,{{101, 160}, {86, 214, 1}} ,{{183, 161}, {170, 215, 1}} ,{{102, 160}, {87, 214, 1}} ,{{184, 161}, {171, 215, 1}} ,{{103, 160}, {88, 214, 1}} ,{{205, 161}, {192, 215, 1}} ,{{104, 160}, {89, 214, 1}} ,{{186, 161}, {173, 215, 1}} ,{{105, 160}, {90, 214, 1}} ,{{187, 161}, {174, 215, 1}} ,{{189, 161}, {176, 215, 1}} ,{{106, 160}, {91, 214, 1}} ,{{200, 161}, {187, 215, 1}} ,{{107, 160}, {92, 214, 1}} ,{{185, 161}, {172, 215, 1}} ,{{108, 160}, {93, 214, 1}} ,{{109, 160}, {94, 214, 1}} ,{{191, 161}, {178, 215, 1}} ,{{110, 160}, {95, 214, 1}} ,{{111, 160}, {96, 214, 1}} ,{{192, 161}, {179, 215, 1}} ,{{112, 160}, {97, 214, 1}} ,{{193, 161}, {180, 215, 1}} ,{{113, 160}, {98, 214, 1}} ,{{194, 161}, {181, 215, 1}} ,{{114, 160}, {99, 214, 1}} ,{{195, 161}, {182, 215, 1}} ,{{115, 160}, {100, 214, 1}} ,{{207, 161}, {194, 215, 1}} ,{{197, 161}, {184, 215, 1}} ,{{116, 160}, {101, 214, 1}} ,{{204, 161}, {191, 215, 1}} ,{{198, 161}, {185, 215, 1}} ,{{206, 161}, {193, 215, 1}} ,{{117, 160}, {102, 214, 1}} ,{{118, 160}, {103, 214, 1}} ,{{199, 161}, {186, 215, 1}} ,{{119, 160}, {104, 214, 1}} ,{{201, 161}, {188, 215, 1}} ,{{120, 160}, {105, 214, 1}} ,{{202, 161}, {189, 215, 1}} ,{{190, 161}, {177, 215, 1}} ,{{121, 160}, {106, 214, 1}} ,{{203, 161}, {190, 215, 1}} ,{{122, 160}, {107, 214, 1}} ,{{123, 160}, {108, 214, 1}} ,{{124, 160}, {109, 214, 1}} ,{{196, 161}, {183, 215, 1}} ,{{125, 160}, {110, 214, 1}} ,{{126, 160}, {111, 214, 1}} ,{{188, 161}, {175, 215, 1}} ,{{210, 161}, {197, 215, 1}} ,{{153, 161}, {140, 215, 1}} ,{{124, 161}, {111, 215, 1}} ,{{150, 161}, {137, 215, 1}} ,{{154, 161}, {141, 215, 1}} ,{{156, 161}, {143, 215, 1}} ,{{155, 161}, {142, 215, 1}} ,{{253, 159}, {238, 213, 1}} ,{{125, 161}, {112, 215, 1}} ,{{254, 159}, {239, 213, 1}} ,{{126, 161}, {113, 215, 1}} ,{{255, 159}, {240, 213, 1}} ,{{147, 161}, {134, 215, 1}} ,{{0, 160}, {241, 213, 1}} ,{{128, 161}, {115, 215, 1}} ,{{1, 160}, {242, 213, 1}} ,{{129, 161}, {116, 215, 1}} ,{{131, 161}, {118, 215, 1}} ,{{2, 160}, {243, 213, 1}} ,{{142, 161}, {129, 215, 1}} ,{{3, 160}, {244, 213, 1}} ,{{127, 161}, {114, 215, 1}} ,{{4, 160}, {245, 213, 1}} ,{{5, 160}, {246, 213, 1}} ,{{133, 161}, {120, 215, 1}} ,{{6, 160}, {247, 213, 1}} ,{{7, 160}, {248, 213, 1}} ,{{134, 161}, {121, 215, 1}} ,{{8, 160}, {249, 213, 1}} ,{{135, 161}, {122, 215, 1}} ,{{9, 160}, {250, 213, 1}} ,{{136, 161}, {123, 215, 1}} ,{{10, 160}, {251, 213, 1}} ,{{137, 161}, {124, 215, 1}} ,{{11, 160}, {252, 213, 1}} ,{{149, 161}, {136, 215, 1}} ,{{139, 161}, {126, 215, 1}} ,{{12, 160}, {253, 213, 1}} ,{{146, 161}, {133, 215, 1}} ,{{140, 161}, {127, 215, 1}} ,{{148, 161}, {135, 215, 1}} ,{{13, 160}, {254, 213, 1}} ,{{14, 160}, {255, 213, 1}} ,{{141, 161}, {128, 215, 1}} ,{{15, 160}, {0, 214, 1}} ,{{143, 161}, {130, 215, 1}} ,{{16, 160}, {1, 214, 1}} ,{{144, 161}, {131, 215, 1}} ,{{132, 161}, {119, 215, 1}} ,{{17, 160}, {2, 214, 1}} ,{{145, 161}, {132, 215, 1}} ,{{18, 160}, {3, 214, 1}} ,{{19, 160}, {4, 214, 1}} ,{{20, 160}, {5, 214, 1}} ,{{138, 161}, {125, 215, 1}} ,{{21, 160}, {6, 214, 1}} ,{{22, 160}, {7, 214, 1}} ,{{130, 161}, {117, 215, 1}} ,{{152, 161}, {139, 215, 1}} ,{{175, 159}, {160, 213, 1}} ,{{176, 159}, {161, 213, 1}} ,{{177, 159}, {162, 213, 1}} ,{{178, 159}, {163, 213, 1}} ,{{179, 159}, {164, 213, 1}} ,{{180, 159}, {165, 213, 1}} ,{{181, 159}, {166, 213, 1}} ,{{182, 159}, {167, 213, 1}} ,{{183, 159}, {168, 213, 1}} ,{{184, 159}, {169, 213, 1}} ,{{185, 159}, {170, 213, 1}} ,{{186, 159}, {171, 213, 1}} ,{{187, 159}, {172, 213, 1}} ,{{188, 159}, {173, 213, 1}} ,{{189, 159}, {174, 213, 1}} ,{{190, 159}, {175, 213, 1}} ,{{191, 159}, {176, 213, 1}} ,{{192, 159}, {177, 213, 1}} ,{{193, 159}, {178, 213, 1}} ,{{194, 159}, {179, 213, 1}} ,{{195, 159}, {180, 213, 1}} ,{{196, 159}, {181, 213, 1}} ,{{197, 159}, {182, 213, 1}} ,{{198, 159}, {183, 213, 1}} ,{{199, 159}, {184, 213, 1}} ,{{200, 159}, {185, 213, 1}} ,{{245, 161}, {234, 215, 1}} ,{{242, 161}, {231, 215, 1}} ,{{241, 161}, {230, 215, 1}} ,{{246, 161}, {235, 215, 1}} ,{{238, 161}, {227, 215, 1}} ,{{244, 161}, {233, 215, 1}} ,{{243, 161}, {232, 215, 1}} ,{{240, 161}, {229, 215, 1}} ,{{239, 161}, {228, 215, 1}} ,{{237, 161}, {226, 215, 1}} ,{{23, 160}, {8, 214, 1}} ,{{24, 160}, {9, 214, 1}} ,{{25, 160}, {10, 214, 1}} ,{{26, 160}, {11, 214, 1}} ,{{27, 160}, {12, 214, 1}} ,{{28, 160}, {13, 214, 1}} ,{{29, 160}, {14, 214, 1}} ,{{30, 160}, {15, 214, 1}} ,{{31, 160}, {16, 214, 1}} ,{{32, 160}, {17, 214, 1}} ,{{33, 160}, {18, 214, 1}} ,{{34, 160}, {19, 214, 1}} ,{{35, 160}, {20, 214, 1}} ,{{36, 160}, {21, 214, 1}} ,{{37, 160}, {22, 214, 1}} ,{{38, 160}, {23, 214, 1}} ,{{39, 160}, {24, 214, 1}} ,{{40, 160}, {25, 214, 1}} ,{{41, 160}, {26, 214, 1}} ,{{42, 160}, {27, 214, 1}} ,{{43, 160}, {28, 214, 1}} ,{{44, 160}, {29, 214, 1}} ,{{45, 160}, {30, 214, 1}} ,{{46, 160}, {31, 214, 1}} ,{{47, 160}, {32, 214, 1}} ,{{48, 160}, {33, 214, 1}} ,{{49, 160}, {34, 214, 1}} ,{{50, 160}, {35, 214, 1}} ,{{51, 160}, {36, 214, 1}} ,{{52, 160}, {37, 214, 1}} ,{{53, 160}, {38, 214, 1}} ,{{54, 160}, {39, 214, 1}} ,{{55, 160}, {40, 214, 1}} ,{{56, 160}, {41, 214, 1}} ,{{57, 160}, {42, 214, 1}} ,{{58, 160}, {43, 214, 1}} ,{{59, 160}, {44, 214, 1}} ,{{60, 160}, {45, 214, 1}} ,{{61, 160}, {46, 214, 1}} ,{{62, 160}, {47, 214, 1}} ,{{63, 160}, {48, 214, 1}} ,{{64, 160}, {49, 214, 1}} ,{{65, 160}, {50, 214, 1}} ,{{66, 160}, {51, 214, 1}} ,{{67, 160}, {52, 214, 1}} ,{{68, 160}, {53, 214, 1}} ,{{69, 160}, {54, 214, 1}} ,{{70, 160}, {55, 214, 1}} ,{{71, 160}, {56, 214, 1}} ,{{72, 160}, {57, 214, 1}} ,{{73, 160}, {58, 214, 1}} ,{{74, 160}, {59, 214, 1}} ,{{201, 159}, {186, 213, 1}} ,{{202, 159}, {187, 213, 1}} ,{{203, 159}, {188, 213, 1}} ,{{204, 159}, {189, 213, 1}} ,{{205, 159}, {190, 213, 1}} ,{{206, 159}, {191, 213, 1}} ,{{207, 159}, {192, 213, 1}} ,{{208, 159}, {193, 213, 1}} ,{{209, 159}, {194, 213, 1}} ,{{210, 159}, {195, 213, 1}} ,{{211, 159}, {196, 213, 1}} ,{{212, 159}, {197, 213, 1}} ,{{213, 159}, {198, 213, 1}} ,{{214, 159}, {199, 213, 1}} ,{{215, 159}, {200, 213, 1}} ,{{216, 159}, {201, 213, 1}} ,{{217, 159}, {202, 213, 1}} ,{{218, 159}, {203, 213, 1}} ,{{219, 159}, {204, 213, 1}} ,{{220, 159}, {205, 213, 1}} ,{{221, 159}, {206, 213, 1}} ,{{222, 159}, {207, 213, 1}} ,{{223, 159}, {208, 213, 1}} ,{{224, 159}, {209, 213, 1}} ,{{225, 159}, {210, 213, 1}} ,{{226, 159}, {211, 213, 1}} ,{{194, 158}, {156, 212, 1}} ,{{195, 158}, {158, 212, 1}} ,{{196, 158}, {159, 212, 1}} ,{{197, 158}, {162, 212, 1}} ,{{198, 158}, {165, 212, 1}} ,{{199, 158}, {166, 212, 1}} ,{{200, 158}, {169, 212, 1}} ,{{201, 158}, {170, 212, 1}} ,{{202, 158}, {171, 212, 1}} ,{{203, 158}, {172, 212, 1}} ,{{204, 158}, {174, 212, 1}} ,{{205, 158}, {175, 212, 1}} ,{{206, 158}, {176, 212, 1}} ,{{207, 158}, {177, 212, 1}} ,{{208, 158}, {178, 212, 1}} ,{{209, 158}, {179, 212, 1}} ,{{210, 158}, {180, 212, 1}} ,{{211, 158}, {181, 212, 1}} ,{{212, 158}, {182, 212, 1}} ,{{213, 158}, {183, 212, 1}} ,{{214, 158}, {184, 212, 1}} ,{{215, 158}, {185, 212, 1}} ,{{216, 158}, {187, 212, 1}} ,{{217, 158}, {189, 212, 1}} ,{{218, 158}, {190, 212, 1}} ,{{219, 158}, {191, 212, 1}} ,{{220, 158}, {192, 212, 1}} ,{{221, 158}, {193, 212, 1}} ,{{222, 158}, {194, 212, 1}} ,{{223, 158}, {195, 212, 1}} ,{{224, 158}, {197, 212, 1}} ,{{225, 158}, {198, 212, 1}} ,{{226, 158}, {199, 212, 1}} ,{{227, 158}, {200, 212, 1}} ,{{228, 158}, {201, 212, 1}} ,{{229, 158}, {202, 212, 1}} ,{{230, 158}, {203, 212, 1}} ,{{231, 158}, {204, 212, 1}} ,{{232, 158}, {205, 212, 1}} ,{{233, 158}, {206, 212, 1}} ,{{234, 158}, {207, 212, 1}} ,{{50, 66}, {33, 34, 0}} ,{{76, 73}, {155, 41, 0}} ,{{92, 73}, {171, 41, 0}} ,{{91, 73}, {170, 41, 0}} ,{{96, 73}, {175, 41, 0}} ,{{94, 73}, {173, 41, 0}} ,{{95, 73}, {174, 41, 0}} ,{{93, 73}, {172, 41, 0}} ,{{90, 73}, {169, 41, 0}} ,{{89, 73}, {168, 41, 0}} ,{{111, 66}, {94, 34, 0}} ,{{78, 73}, {157, 41, 0}} ,{{119, 70}, {171, 38, 0}} ,{{36, 71}, {106, 39, 0}} ,{{37, 71}, {107, 39, 0}} ,{{38, 71}, {108, 39, 0}} ,{{46, 71}, {116, 39, 0}} ,{{34, 71}, {104, 39, 0}} ,{{175, 64}, {95, 32, 0}} ,{{39, 71}, {109, 39, 0}} ,{{47, 71}, {117, 39, 0}} ,{{35, 71}, {105, 39, 0}} ,{{94, 69}, {146, 37, 0}} ,{{120, 70}, {172, 38, 0}} ,{{21, 71}, {89, 39, 0}} ,{{118, 70}, {170, 38, 0}} ,{{84, 92}, {237, 171, 0}} ,{{82, 92}, {235, 171, 0}} ,{{93, 92}, {248, 171, 0}} ,{{90, 92}, {245, 171, 0}} ,{{89, 92}, {244, 171, 0}} ,{{94, 92}, {249, 171, 0}} ,{{86, 92}, {241, 171, 0}} ,{{92, 92}, {247, 171, 0}} ,{{91, 92}, {246, 171, 0}} ,{{88, 92}, {243, 171, 0}} ,{{87, 92}, {242, 171, 0}} ,{{85, 92}, {240, 171, 0}} ,{{56, 92}, {209, 171, 0}} ,{{60, 92}, {213, 171, 0}} ,{{65, 92}, {218, 171, 0}} ,{{45, 92}, {198, 171, 0}} ,{{64, 92}, {217, 171, 0}} ,{{62, 92}, {215, 171, 0}} ,{{63, 92}, {216, 171, 0}} ,{{57, 92}, {210, 171, 0}} ,{{52, 92}, {205, 171, 0}} ,{{54, 92}, {207, 171, 0}} ,{{73, 92}, {226, 171, 0}} ,{{58, 92}, {211, 171, 0}} ,{{61, 92}, {214, 171, 0}} ,{{47, 92}, {200, 171, 0}} ,{{39, 92}, {192, 171, 0}} ,{{66, 92}, {219, 171, 0}} ,{{41, 92}, {194, 171, 0}} ,{{67, 92}, {220, 171, 0}} ,{{42, 92}, {195, 171, 0}} ,{{68, 92}, {221, 171, 0}} ,{{44, 92}, {197, 171, 0}} ,{{70, 92}, {223, 171, 0}} ,{{48, 92}, {201, 171, 0}} ,{{72, 92}, {225, 171, 0}} ,{{43, 92}, {196, 171, 0}} ,{{69, 92}, {222, 171, 0}} ,{{55, 92}, {208, 171, 0}} ,{{59, 92}, {212, 171, 0}} ,{{40, 92}, {193, 171, 0}} ,{{49, 92}, {202, 171, 0}} ,{{46, 92}, {199, 171, 0}} ,{{71, 92}, {224, 171, 0}} ,{{53, 92}, {206, 171, 0}} ,{{50, 92}, {203, 171, 0}} ,{{51, 92}, {204, 171, 0}} ,{{83, 92}, {236, 171, 0}} ,{{76, 92}, {229, 171, 0}} ,{{80, 92}, {233, 171, 0}} ,{{75, 92}, {228, 171, 0}} ,{{81, 92}, {234, 171, 0}} ,{{74, 92}, {227, 171, 0}} ,{{78, 92}, {231, 171, 0}} ,{{79, 92}, {232, 171, 0}} ,{{77, 92}, {230, 171, 0}} ,{{11, 70}, {63, 38, 0}} ,{{226, 67}, {209, 35, 0}} ,{{227, 67}, {210, 35, 0}} ,{{229, 67}, {212, 35, 0}} ,{{234, 67}, {217, 35, 0}} ,{{228, 67}, {211, 35, 0}} ,{{233, 67}, {216, 35, 0}} ,{{232, 67}, {215, 35, 0}} ,{{231, 67}, {214, 35, 0}} ,{{230, 67}, {213, 35, 0}} ,{{87, 38}, {181, 0, 0}} ,{{89, 38}, {183, 0, 0}} ,{{0, 67}, {239, 34, 0}} ,{{226, 64}, {165, 32, 0}} ,{{36, 66}, {19, 34, 0}} ,{{35, 66}, {18, 34, 0}} ,{{235, 73}, {58, 42, 0}} ,{{218, 73}, {41, 42, 0}} ,{{219, 73}, {42, 42, 0}} ,{{220, 73}, {43, 42, 0}} ,{{221, 73}, {44, 42, 0}} ,{{83, 66}, {66, 34, 0}} ,{{176, 73}, {255, 41, 0}} ,{{184, 66}, {167, 34, 0}} ,{{108, 40}, {202, 2, 0}} ,{{94, 40}, {188, 2, 0}} ,{{155, 40}, {249, 2, 0}} ,{{157, 40}, {251, 2, 0}} ,{{169, 61}, {44, 29, 0}} ,{{170, 61}, {45, 29, 0}} ,{{171, 61}, {46, 29, 0}} ,{{172, 61}, {47, 29, 0}} ,{{173, 61}, {48, 29, 0}} ,{{174, 61}, {49, 29, 0}} ,{{176, 61}, {51, 29, 0}} ,{{177, 61}, {52, 29, 0}} ,{{178, 61}, {53, 29, 0}} ,{{179, 61}, {54, 29, 0}} ,{{180, 61}, {55, 29, 0}} ,{{181, 61}, {56, 29, 0}} ,{{182, 61}, {57, 29, 0}} ,{{183, 61}, {58, 29, 0}} ,{{185, 61}, {60, 29, 0}} ,{{186, 61}, {61, 29, 0}} ,{{187, 61}, {62, 29, 0}} ,{{188, 61}, {63, 29, 0}} ,{{175, 61}, {50, 29, 0}} ,{{184, 61}, {59, 29, 0}} ,{{189, 61}, {64, 29, 0}} ,{{190, 61}, {65, 29, 0}} ,{{131, 75}, {125, 44, 0}} ,{{191, 61}, {66, 29, 0}} ,{{117, 40}, {211, 2, 0}} ,{{116, 40}, {210, 2, 0}} ,{{55, 89}, {1, 167, 0}} ,{{59, 89}, {5, 167, 0}} ,{{61, 89}, {7, 167, 0}} ,{{57, 89}, {3, 167, 0}} ,{{54, 89}, {0, 167, 0}} ,{{58, 89}, {4, 167, 0}} ,{{60, 89}, {6, 167, 0}} ,{{56, 89}, {2, 167, 0}} ,{{104, 40}, {198, 2, 0}} ,{{191, 89}, {137, 167, 0}} ,{{129, 40}, {223, 2, 0}} ,{{245, 61}, {120, 29, 0}} ,{{79, 89}, {25, 167, 0}} ,{{78, 89}, {24, 167, 0}} ,{{77, 89}, {23, 167, 0}} ,{{144, 40}, {238, 2, 0}} ,{{92, 40}, {186, 2, 0}} ,{{103, 40}, {197, 2, 0}} ,{{119, 40}, {213, 2, 0}} ,{{156, 40}, {250, 2, 0}} ,{{158, 40}, {252, 2, 0}} ,{{67, 89}, {13, 167, 0}} ,{{62, 89}, {8, 167, 0}} ,{{72, 89}, {18, 167, 0}} ,{{135, 40}, {229, 2, 0}} ,{{71, 89}, {17, 167, 0}} ,{{66, 89}, {12, 167, 0}} ,{{76, 89}, {22, 167, 0}} ,{{139, 40}, {233, 2, 0}} ,{{84, 51}, {252, 16, 0}} ,{{98, 40}, {192, 2, 0}} ,{{109, 40}, {203, 2, 0}} ,{{115, 40}, {209, 2, 0}} ,{{68, 89}, {14, 167, 0}} ,{{63, 89}, {9, 167, 0}} ,{{73, 89}, {19, 167, 0}} ,{{136, 40}, {230, 2, 0}} ,{{100, 40}, {194, 2, 0}} ,{{97, 40}, {191, 2, 0}} ,{{80, 89}, {26, 167, 0}} ,{{113, 40}, {207, 2, 0}} ,{{190, 89}, {136, 167, 0}} ,{{70, 89}, {16, 167, 0}} ,{{65, 89}, {11, 167, 0}} ,{{145, 40}, {239, 2, 0}} ,{{112, 40}, {206, 2, 0}} ,{{85, 89}, {31, 167, 0}} ,{{75, 89}, {21, 167, 0}} ,{{161, 40}, {255, 2, 0}} ,{{147, 40}, {241, 2, 0}} ,{{111, 40}, {205, 2, 0}} ,{{148, 40}, {242, 2, 0}} ,{{149, 40}, {243, 2, 0}} ,{{153, 40}, {247, 2, 0}} ,{{138, 40}, {232, 2, 0}} ,{{146, 40}, {240, 2, 0}} ,{{110, 40}, {204, 2, 0}} ,{{107, 40}, {201, 2, 0}} ,{{152, 40}, {246, 2, 0}} ,{{151, 40}, {245, 2, 0}} ,{{150, 40}, {244, 2, 0}} ,{{69, 89}, {15, 167, 0}} ,{{64, 89}, {10, 167, 0}} ,{{74, 89}, {20, 167, 0}} ,{{137, 40}, {231, 2, 0}} ,{{121, 40}, {215, 2, 0}} ,{{160, 40}, {254, 2, 0}} ,{{120, 40}, {214, 2, 0}} ,{{91, 40}, {185, 2, 0}} ,{{154, 40}, {248, 2, 0}} ,{{82, 89}, {28, 167, 0}} ,{{83, 89}, {29, 167, 0}} ,{{84, 89}, {30, 167, 0}} ,{{81, 89}, {27, 167, 0}} ,{{95, 40}, {189, 2, 0}} ,{{99, 40}, {193, 2, 0}} ,{{128, 40}, {222, 2, 0}} ,{{101, 40}, {195, 2, 0}} ,{{96, 40}, {190, 2, 0}} ,{{159, 40}, {253, 2, 0}} ,{{192, 89}, {138, 167, 0}} ,{{192, 61}, {67, 29, 0}} ,{{217, 61}, {92, 29, 0}} ,{{194, 61}, {69, 29, 0}} ,{{196, 61}, {71, 29, 0}} ,{{46, 62}, {177, 29, 0}} ,{{218, 61}, {93, 29, 0}} ,{{210, 61}, {85, 29, 0}} ,{{25, 62}, {156, 29, 0}} ,{{35, 62}, {166, 29, 0}} ,{{88, 40}, {182, 2, 0}} ,{{36, 62}, {167, 29, 0}} ,{{40, 62}, {171, 29, 0}} ,{{45, 62}, {176, 29, 0}} ,{{53, 62}, {184, 29, 0}} ,{{222, 61}, {97, 29, 0}} ,{{26, 62}, {157, 29, 0}} ,{{197, 61}, {72, 29, 0}} ,{{220, 61}, {95, 29, 0}} ,{{30, 62}, {161, 29, 0}} ,{{198, 61}, {73, 29, 0}} ,{{206, 61}, {81, 29, 0}} ,{{49, 62}, {180, 29, 0}} ,{{27, 62}, {158, 29, 0}} ,{{59, 62}, {190, 29, 0}} ,{{29, 62}, {160, 29, 0}} ,{{202, 61}, {77, 29, 0}} ,{{130, 40}, {224, 2, 0}} ,{{219, 61}, {94, 29, 0}} ,{{221, 61}, {96, 29, 0}} ,{{82, 40}, {176, 2, 0}} ,{{83, 40}, {177, 2, 0}} ,{{34, 62}, {165, 29, 0}} ,{{33, 62}, {164, 29, 0}} ,{{84, 40}, {178, 2, 0}} ,{{37, 62}, {168, 29, 0}} ,{{204, 61}, {79, 29, 0}} ,{{131, 40}, {225, 2, 0}} ,{{39, 62}, {170, 29, 0}} ,{{38, 62}, {169, 29, 0}} ,{{205, 61}, {80, 29, 0}} ,{{41, 62}, {172, 29, 0}} ,{{43, 62}, {174, 29, 0}} ,{{44, 62}, {175, 29, 0}} ,{{207, 61}, {82, 29, 0}} ,{{200, 61}, {75, 29, 0}} ,{{208, 61}, {83, 29, 0}} ,{{211, 61}, {86, 29, 0}} ,{{47, 62}, {178, 29, 0}} ,{{85, 40}, {179, 2, 0}} ,{{134, 40}, {228, 2, 0}} ,{{28, 62}, {159, 29, 0}} ,{{132, 40}, {226, 2, 0}} ,{{199, 61}, {74, 29, 0}} ,{{31, 62}, {162, 29, 0}} ,{{214, 61}, {89, 29, 0}} ,{{48, 62}, {179, 29, 0}} ,{{212, 61}, {87, 29, 0}} ,{{60, 62}, {191, 29, 0}} ,{{209, 61}, {84, 29, 0}} ,{{193, 61}, {68, 29, 0}} ,{{195, 61}, {70, 29, 0}} ,{{24, 62}, {155, 29, 0}} ,{{32, 62}, {163, 29, 0}} ,{{203, 61}, {78, 29, 0}} ,{{215, 61}, {90, 29, 0}} ,{{42, 62}, {173, 29, 0}} ,{{201, 61}, {76, 29, 0}} ,{{86, 40}, {180, 2, 0}} ,{{87, 40}, {181, 2, 0}} ,{{55, 62}, {186, 29, 0}} ,{{50, 62}, {181, 29, 0}} ,{{213, 61}, {88, 29, 0}} ,{{52, 62}, {183, 29, 0}} ,{{51, 62}, {182, 29, 0}} ,{{216, 61}, {91, 29, 0}} ,{{54, 62}, {185, 29, 0}} ,{{89, 40}, {183, 2, 0}} ,{{133, 40}, {227, 2, 0}} ,{{90, 40}, {184, 2, 0}} ,{{56, 62}, {187, 29, 0}} ,{{58, 62}, {189, 29, 0}} ,{{57, 62}, {188, 29, 0}} ,{{86, 89}, {32, 167, 0}} ,{{87, 89}, {33, 167, 0}} ,{{114, 40}, {208, 2, 0}} ,{{93, 40}, {187, 2, 0}} ,{{143, 40}, {237, 2, 0}} ,{{102, 40}, {196, 2, 0}} ,{{118, 40}, {212, 2, 0}} ,{{166, 89}, {112, 167, 0}} ,{{106, 40}, {200, 2, 0}} ,{{142, 40}, {236, 2, 0}} ,{{141, 40}, {235, 2, 0}} ,{{140, 40}, {234, 2, 0}} ,{{187, 73}, {10, 42, 0}} ,{{217, 57}, {0, 24, 0}} ,{{221, 57}, {4, 24, 0}} ,{{219, 57}, {2, 24, 0}} ,{{240, 57}, {24, 24, 0}} ,{{237, 57}, {21, 24, 0}} ,{{236, 57}, {20, 24, 0}} ,{{241, 57}, {25, 24, 0}} ,{{233, 57}, {17, 24, 0}} ,{{239, 57}, {23, 24, 0}} ,{{238, 57}, {22, 24, 0}} ,{{235, 57}, {19, 24, 0}} ,{{234, 57}, {18, 24, 0}} ,{{232, 57}, {16, 24, 0}} ,{{218, 57}, {1, 24, 0}} ,{{222, 57}, {5, 24, 0}} ,{{228, 57}, {11, 24, 0}} ,{{230, 57}, {13, 24, 0}} ,{{229, 57}, {12, 24, 0}} ,{{220, 57}, {3, 24, 0}} ,{{242, 57}, {32, 24, 0}} ,{{81, 58}, {135, 24, 0}} ,{{97, 58}, {151, 24, 0}} ,{{74, 58}, {128, 24, 0}} ,{{79, 58}, {133, 24, 0}} ,{{85, 58}, {139, 24, 0}} ,{{91, 58}, {145, 24, 0}} ,{{115, 58}, {169, 24, 0}} ,{{76, 58}, {130, 24, 0}} ,{{88, 58}, {142, 24, 0}} ,{{112, 58}, {166, 24, 0}} ,{{113, 58}, {167, 24, 0}} ,{{82, 58}, {136, 24, 0}} ,{{78, 58}, {132, 24, 0}} ,{{83, 58}, {137, 24, 0}} ,{{84, 58}, {138, 24, 0}} ,{{89, 58}, {143, 24, 0}} ,{{92, 58}, {146, 24, 0}} ,{{93, 58}, {147, 24, 0}} ,{{94, 58}, {148, 24, 0}} ,{{90, 58}, {144, 24, 0}} ,{{80, 58}, {134, 24, 0}} ,{{86, 58}, {140, 24, 0}} ,{{87, 58}, {141, 24, 0}} ,{{77, 58}, {131, 24, 0}} ,{{75, 58}, {129, 24, 0}} ,{{96, 58}, {150, 24, 0}} ,{{95, 58}, {149, 24, 0}} ,{{251, 57}, {41, 24, 0}} ,{{252, 57}, {42, 24, 0}} ,{{6, 58}, {52, 24, 0}} ,{{20, 58}, {66, 24, 0}} ,{{5, 58}, {51, 24, 0}} ,{{243, 57}, {33, 24, 0}} ,{{249, 57}, {39, 24, 0}} ,{{11, 58}, {57, 24, 0}} ,{{255, 57}, {45, 24, 0}} ,{{16, 58}, {62, 24, 0}} ,{{244, 57}, {34, 24, 0}} ,{{7, 58}, {53, 24, 0}} ,{{12, 58}, {58, 24, 0}} ,{{13, 58}, {59, 24, 0}} ,{{1, 58}, {47, 24, 0}} ,{{18, 58}, {64, 24, 0}} ,{{0, 58}, {46, 24, 0}} ,{{114, 58}, {168, 24, 0}} ,{{102, 58}, {156, 24, 0}} ,{{109, 58}, {163, 24, 0}} ,{{105, 58}, {159, 24, 0}} ,{{107, 58}, {161, 24, 0}} ,{{100, 58}, {154, 24, 0}} ,{{103, 58}, {157, 24, 0}} ,{{116, 58}, {170, 24, 0}} ,{{101, 58}, {155, 24, 0}} ,{{108, 58}, {162, 24, 0}} ,{{106, 58}, {160, 24, 0}} ,{{104, 58}, {158, 24, 0}} ,{{111, 58}, {165, 24, 0}} ,{{110, 58}, {164, 24, 0}} ,{{72, 58}, {118, 24, 0}} ,{{69, 58}, {115, 24, 0}} ,{{70, 58}, {116, 24, 0}} ,{{71, 58}, {117, 24, 0}} ,{{73, 58}, {119, 24, 0}} ,{{250, 57}, {40, 24, 0}} ,{{245, 57}, {35, 24, 0}} ,{{247, 57}, {37, 24, 0}} ,{{253, 57}, {43, 24, 0}} ,{{254, 57}, {44, 24, 0}} ,{{9, 58}, {55, 24, 0}} ,{{2, 58}, {48, 24, 0}} ,{{3, 58}, {49, 24, 0}} ,{{52, 58}, {98, 24, 0}} ,{{67, 58}, {113, 24, 0}} ,{{59, 58}, {105, 24, 0}} ,{{47, 58}, {93, 24, 0}} ,{{61, 58}, {107, 24, 0}} ,{{54, 58}, {100, 24, 0}} ,{{62, 58}, {108, 24, 0}} ,{{55, 58}, {101, 24, 0}} ,{{63, 58}, {109, 24, 0}} ,{{48, 58}, {94, 24, 0}} ,{{49, 58}, {95, 24, 0}} ,{{60, 58}, {106, 24, 0}} ,{{53, 58}, {99, 24, 0}} ,{{56, 58}, {102, 24, 0}} ,{{66, 58}, {112, 24, 0}} ,{{57, 58}, {103, 24, 0}} ,{{58, 58}, {104, 24, 0}} ,{{64, 58}, {110, 24, 0}} ,{{51, 58}, {97, 24, 0}} ,{{50, 58}, {96, 24, 0}} ,{{65, 58}, {111, 24, 0}} ,{{68, 58}, {114, 24, 0}} ,{{4, 58}, {50, 24, 0}} ,{{98, 58}, {152, 24, 0}} ,{{99, 58}, {153, 24, 0}} ,{{28, 58}, {74, 24, 0}} ,{{29, 58}, {75, 24, 0}} ,{{36, 58}, {82, 24, 0}} ,{{35, 58}, {81, 24, 0}} ,{{46, 58}, {92, 24, 0}} ,{{22, 58}, {68, 24, 0}} ,{{32, 58}, {78, 24, 0}} ,{{42, 58}, {88, 24, 0}} ,{{43, 58}, {89, 24, 0}} ,{{23, 58}, {69, 24, 0}} ,{{37, 58}, {83, 24, 0}} ,{{44, 58}, {90, 24, 0}} ,{{41, 58}, {87, 24, 0}} ,{{21, 58}, {67, 24, 0}} ,{{33, 58}, {79, 24, 0}} ,{{45, 58}, {91, 24, 0}} ,{{24, 58}, {70, 24, 0}} ,{{26, 58}, {72, 24, 0}} ,{{30, 58}, {76, 24, 0}} ,{{31, 58}, {77, 24, 0}} ,{{34, 58}, {80, 24, 0}} ,{{38, 58}, {84, 24, 0}} ,{{25, 58}, {71, 24, 0}} ,{{27, 58}, {73, 24, 0}} ,{{40, 58}, {86, 24, 0}} ,{{39, 58}, {85, 24, 0}} ,{{14, 58}, {60, 24, 0}} ,{{246, 57}, {36, 24, 0}} ,{{248, 57}, {38, 24, 0}} ,{{10, 58}, {56, 24, 0}} ,{{8, 58}, {54, 24, 0}} ,{{15, 58}, {61, 24, 0}} ,{{19, 58}, {65, 24, 0}} ,{{17, 58}, {63, 24, 0}} ,{{225, 57}, {8, 24, 0}} ,{{226, 57}, {9, 24, 0}} ,{{227, 57}, {10, 24, 0}} ,{{224, 57}, {7, 24, 0}} ,{{223, 57}, {6, 24, 0}} ,{{231, 57}, {14, 24, 0}} ,{{190, 157}, {0, 211, 1}} ,{{86, 70}, {138, 38, 0}} ,{{87, 70}, {139, 38, 0}} ,{{158, 67}, {141, 35, 0}} ,{{182, 70}, {240, 38, 0}} ,{{124, 66}, {107, 34, 0}} ,{{123, 66}, {106, 34, 0}} ,{{201, 66}, {184, 34, 0}} ,{{121, 38}, {215, 0, 0}} ,{{232, 73}, {55, 42, 0}} ,{{229, 73}, {52, 42, 0}} ,{{230, 73}, {53, 42, 0}} ,{{236, 73}, {59, 42, 0}} ,{{225, 73}, {48, 42, 0}} ,{{226, 73}, {49, 42, 0}} ,{{215, 70}, {21, 39, 0}} ,{{157, 66}, {140, 34, 0}} ,{{158, 66}, {141, 34, 0}} ,{{159, 66}, {142, 34, 0}} ,{{30, 157}, {132, 209, 1}} ,{{29, 157}, {131, 209, 1}} ,{{13, 157}, {115, 209, 1}} ,{{19, 157}, {121, 209, 1}} ,{{17, 157}, {119, 209, 1}} ,{{15, 157}, {117, 209, 1}} ,{{176, 156}, {20, 209, 1}} ,{{177, 156}, {21, 209, 1}} ,{{174, 156}, {18, 209, 1}} ,{{246, 156}, {92, 209, 1}} ,{{82, 157}, {184, 209, 1}} ,{{93, 157}, {195, 209, 1}} ,{{175, 156}, {19, 209, 1}} ,{{223, 156}, {69, 209, 1}} ,{{113, 157}, {215, 209, 1}} ,{{111, 157}, {213, 209, 1}} ,{{245, 156}, {91, 209, 1}} ,{{244, 156}, {90, 209, 1}} ,{{168, 156}, {12, 209, 1}} ,{{21, 157}, {123, 209, 1}} ,{{27, 157}, {129, 209, 1}} ,{{7, 157}, {109, 209, 1}} ,{{35, 157}, {137, 209, 1}} ,{{31, 157}, {133, 209, 1}} ,{{36, 157}, {138, 209, 1}} ,{{68, 157}, {170, 209, 1}} ,{{8, 157}, {110, 209, 1}} ,{{9, 157}, {111, 209, 1}} ,{{10, 157}, {112, 209, 1}} ,{{11, 157}, {113, 209, 1}} ,{{12, 157}, {114, 209, 1}} ,{{33, 157}, {135, 209, 1}} ,{{70, 157}, {172, 209, 1}} ,{{28, 157}, {130, 209, 1}} ,{{25, 157}, {127, 209, 1}} ,{{26, 157}, {128, 209, 1}} ,{{32, 157}, {134, 209, 1}} ,{{34, 157}, {136, 209, 1}} ,{{71, 157}, {173, 209, 1}} ,{{0, 157}, {102, 209, 1}} ,{{24, 157}, {126, 209, 1}} ,{{22, 157}, {124, 209, 1}} ,{{255, 156}, {101, 209, 1}} ,{{23, 157}, {125, 209, 1}} ,{{1, 157}, {103, 209, 1}} ,{{2, 157}, {104, 209, 1}} ,{{3, 157}, {105, 209, 1}} ,{{37, 157}, {139, 209, 1}} ,{{69, 157}, {171, 209, 1}} ,{{206, 156}, {52, 209, 1}} ,{{44, 157}, {146, 209, 1}} ,{{105, 157}, {207, 209, 1}} ,{{207, 156}, {53, 209, 1}} ,{{189, 156}, {33, 209, 1}} ,{{165, 156}, {9, 209, 1}} ,{{78, 157}, {180, 209, 1}} ,{{79, 157}, {181, 209, 1}} ,{{160, 156}, {4, 209, 1}} ,{{166, 156}, {10, 209, 1}} ,{{45, 157}, {147, 209, 1}} ,{{67, 157}, {169, 209, 1}} ,{{157, 156}, {1, 209, 1}} ,{{197, 156}, {43, 209, 1}} ,{{196, 156}, {42, 209, 1}} ,{{193, 156}, {37, 209, 1}} ,{{194, 156}, {38, 209, 1}} ,{{250, 156}, {96, 209, 1}} ,{{216, 156}, {62, 209, 1}} ,{{14, 157}, {116, 209, 1}} ,{{66, 157}, {168, 209, 1}} ,{{20, 157}, {122, 209, 1}} ,{{18, 157}, {120, 209, 1}} ,{{16, 157}, {118, 209, 1}} ,{{172, 156}, {16, 209, 1}} ,{{173, 156}, {17, 209, 1}} ,{{158, 156}, {2, 209, 1}} ,{{4, 157}, {106, 209, 1}} ,{{5, 157}, {107, 209, 1}} ,{{6, 157}, {108, 209, 1}} ,{{182, 156}, {26, 209, 1}} ,{{199, 156}, {45, 209, 1}} ,{{198, 156}, {44, 209, 1}} ,{{43, 157}, {145, 209, 1}} ,{{181, 156}, {25, 209, 1}} ,{{185, 156}, {29, 209, 1}} ,{{90, 157}, {192, 209, 1}} ,{{89, 157}, {191, 209, 1}} ,{{190, 156}, {34, 209, 1}} ,{{191, 156}, {35, 209, 1}} ,{{192, 156}, {36, 209, 1}} ,{{76, 157}, {178, 209, 1}} ,{{75, 157}, {177, 209, 1}} ,{{47, 157}, {149, 209, 1}} ,{{46, 157}, {148, 209, 1}} ,{{106, 157}, {208, 209, 1}} ,{{107, 157}, {209, 209, 1}} ,{{186, 156}, {30, 209, 1}} ,{{187, 156}, {31, 209, 1}} ,{{188, 156}, {32, 209, 1}} ,{{248, 156}, {94, 209, 1}} ,{{74, 157}, {176, 209, 1}} ,{{214, 156}, {60, 209, 1}} ,{{64, 157}, {166, 209, 1}} ,{{50, 157}, {152, 209, 1}} ,{{162, 156}, {6, 209, 1}} ,{{81, 157}, {183, 209, 1}} ,{{92, 157}, {194, 209, 1}} ,{{91, 157}, {193, 209, 1}} ,{{80, 157}, {182, 209, 1}} ,{{42, 157}, {144, 209, 1}} ,{{85, 157}, {187, 209, 1}} ,{{86, 157}, {188, 209, 1}} ,{{95, 157}, {197, 209, 1}} ,{{237, 156}, {83, 209, 1}} ,{{236, 156}, {82, 209, 1}} ,{{195, 156}, {41, 209, 1}} ,{{212, 156}, {58, 209, 1}} ,{{201, 156}, {47, 209, 1}} ,{{200, 156}, {46, 209, 1}} ,{{65, 157}, {167, 209, 1}} ,{{242, 156}, {88, 209, 1}} ,{{243, 156}, {89, 209, 1}} ,{{178, 156}, {22, 209, 1}} ,{{254, 156}, {100, 209, 1}} ,{{220, 156}, {66, 209, 1}} ,{{53, 157}, {155, 209, 1}} ,{{62, 157}, {164, 209, 1}} ,{{63, 157}, {165, 209, 1}} ,{{54, 157}, {156, 209, 1}} ,{{55, 157}, {157, 209, 1}} ,{{56, 157}, {158, 209, 1}} ,{{57, 157}, {159, 209, 1}} ,{{58, 157}, {160, 209, 1}} ,{{59, 157}, {161, 209, 1}} ,{{60, 157}, {162, 209, 1}} ,{{61, 157}, {163, 209, 1}} ,{{208, 156}, {54, 209, 1}} ,{{209, 156}, {55, 209, 1}} ,{{240, 156}, {86, 209, 1}} ,{{72, 157}, {174, 209, 1}} ,{{73, 157}, {175, 209, 1}} ,{{119, 157}, {221, 209, 1}} ,{{41, 157}, {143, 209, 1}} ,{{222, 156}, {68, 209, 1}} ,{{110, 157}, {212, 209, 1}} ,{{115, 157}, {217, 209, 1}} ,{{116, 157}, {218, 209, 1}} ,{{249, 156}, {95, 209, 1}} ,{{215, 156}, {61, 209, 1}} ,{{205, 156}, {51, 209, 1}} ,{{204, 156}, {50, 209, 1}} ,{{210, 156}, {56, 209, 1}} ,{{211, 156}, {57, 209, 1}} ,{{169, 156}, {13, 209, 1}} ,{{170, 156}, {14, 209, 1}} ,{{171, 156}, {15, 209, 1}} ,{{164, 156}, {8, 209, 1}} ,{{159, 156}, {3, 209, 1}} ,{{163, 156}, {7, 209, 1}} ,{{38, 157}, {140, 209, 1}} ,{{112, 157}, {214, 209, 1}} ,{{117, 157}, {219, 209, 1}} ,{{167, 156}, {11, 209, 1}} ,{{84, 157}, {186, 209, 1}} ,{{94, 157}, {196, 209, 1}} ,{{83, 157}, {185, 209, 1}} ,{{88, 157}, {190, 209, 1}} ,{{96, 157}, {198, 209, 1}} ,{{87, 157}, {189, 209, 1}} ,{{203, 156}, {49, 209, 1}} ,{{202, 156}, {48, 209, 1}} ,{{161, 156}, {5, 209, 1}} ,{{156, 156}, {0, 209, 1}} ,{{183, 156}, {27, 209, 1}} ,{{184, 156}, {28, 209, 1}} ,{{251, 156}, {97, 209, 1}} ,{{217, 156}, {63, 209, 1}} ,{{253, 156}, {99, 209, 1}} ,{{219, 156}, {65, 209, 1}} ,{{108, 157}, {210, 209, 1}} ,{{225, 156}, {71, 209, 1}} ,{{224, 156}, {70, 209, 1}} ,{{39, 157}, {141, 209, 1}} ,{{101, 157}, {203, 209, 1}} ,{{102, 157}, {204, 209, 1}} ,{{103, 157}, {205, 209, 1}} ,{{104, 157}, {206, 209, 1}} ,{{100, 157}, {202, 209, 1}} ,{{98, 157}, {200, 209, 1}} ,{{97, 157}, {199, 209, 1}} ,{{99, 157}, {201, 209, 1}} ,{{252, 156}, {98, 209, 1}} ,{{218, 156}, {64, 209, 1}} ,{{180, 156}, {24, 209, 1}} ,{{114, 157}, {216, 209, 1}} ,{{118, 157}, {220, 209, 1}} ,{{48, 157}, {150, 209, 1}} ,{{239, 156}, {85, 209, 1}} ,{{238, 156}, {84, 209, 1}} ,{{233, 156}, {79, 209, 1}} ,{{232, 156}, {78, 209, 1}} ,{{229, 156}, {75, 209, 1}} ,{{228, 156}, {74, 209, 1}} ,{{231, 156}, {77, 209, 1}} ,{{230, 156}, {76, 209, 1}} ,{{227, 156}, {73, 209, 1}} ,{{235, 156}, {81, 209, 1}} ,{{234, 156}, {80, 209, 1}} ,{{226, 156}, {72, 209, 1}} ,{{49, 157}, {151, 209, 1}} ,{{51, 157}, {153, 209, 1}} ,{{52, 157}, {154, 209, 1}} ,{{179, 156}, {23, 209, 1}} ,{{109, 157}, {211, 209, 1}} ,{{241, 156}, {87, 209, 1}} ,{{247, 156}, {93, 209, 1}} ,{{213, 156}, {59, 209, 1}} ,{{77, 157}, {179, 209, 1}} ,{{221, 156}, {67, 209, 1}} ,{{40, 157}, {142, 209, 1}} ,{{57, 70}, {109, 38, 0}} ,{{58, 70}, {110, 38, 0}} ,{{59, 70}, {111, 38, 0}} ,{{160, 50}, {62, 16, 0}} ,{{158, 50}, {60, 16, 0}} ,{{159, 50}, {61, 16, 0}} ,{{157, 50}, {59, 16, 0}} ,{{194, 50}, {96, 16, 0}} ,{{193, 50}, {95, 16, 0}} ,{{192, 50}, {94, 16, 0}} ,{{228, 50}, {130, 16, 0}} ,{{170, 50}, {72, 16, 0}} ,{{167, 50}, {69, 16, 0}} ,{{166, 50}, {68, 16, 0}} ,{{171, 50}, {73, 16, 0}} ,{{163, 50}, {65, 16, 0}} ,{{169, 50}, {71, 16, 0}} ,{{168, 50}, {70, 16, 0}} ,{{165, 50}, {67, 16, 0}} ,{{164, 50}, {66, 16, 0}} ,{{162, 50}, {64, 16, 0}} ,{{131, 50}, {33, 16, 0}} ,{{221, 91}, {122, 170, 0}} ,{{140, 50}, {42, 16, 0}} ,{{121, 50}, {23, 16, 0}} ,{{122, 50}, {24, 16, 0}} ,{{103, 50}, {5, 16, 0}} ,{{104, 50}, {6, 16, 0}} ,{{116, 50}, {18, 16, 0}} ,{{111, 50}, {13, 16, 0}} ,{{112, 50}, {14, 16, 0}} ,{{117, 50}, {19, 16, 0}} ,{{137, 50}, {39, 16, 0}} ,{{210, 50}, {112, 16, 0}} ,{{208, 50}, {110, 16, 0}} ,{{209, 50}, {111, 16, 0}} ,{{100, 50}, {2, 16, 0}} ,{{101, 50}, {3, 16, 0}} ,{{161, 50}, {63, 16, 0}} ,{{129, 50}, {31, 16, 0}} ,{{133, 50}, {35, 16, 0}} ,{{134, 50}, {36, 16, 0}} ,{{105, 50}, {7, 16, 0}} ,{{106, 50}, {8, 16, 0}} ,{{98, 50}, {0, 16, 0}} ,{{99, 50}, {1, 16, 0}} ,{{196, 91}, {97, 170, 0}} ,{{197, 91}, {98, 170, 0}} ,{{203, 91}, {104, 170, 0}} ,{{204, 91}, {105, 170, 0}} ,{{205, 91}, {106, 170, 0}} ,{{210, 91}, {111, 170, 0}} ,{{195, 91}, {96, 170, 0}} ,{{208, 91}, {109, 170, 0}} ,{{209, 91}, {110, 170, 0}} ,{{198, 91}, {99, 170, 0}} ,{{199, 91}, {100, 170, 0}} ,{{206, 91}, {107, 170, 0}} ,{{200, 91}, {101, 170, 0}} ,{{214, 91}, {115, 170, 0}} ,{{207, 91}, {108, 170, 0}} ,{{201, 91}, {102, 170, 0}} ,{{202, 91}, {103, 170, 0}} ,{{212, 91}, {113, 170, 0}} ,{{213, 91}, {114, 170, 0}} ,{{126, 50}, {28, 16, 0}} ,{{130, 50}, {32, 16, 0}} ,{{123, 50}, {25, 16, 0}} ,{{190, 50}, {92, 16, 0}} ,{{191, 50}, {93, 16, 0}} ,{{138, 50}, {40, 16, 0}} ,{{189, 50}, {91, 16, 0}} ,{{188, 50}, {90, 16, 0}} ,{{118, 50}, {20, 16, 0}} ,{{102, 50}, {4, 16, 0}} ,{{113, 50}, {15, 16, 0}} ,{{108, 50}, {10, 16, 0}} ,{{107, 50}, {9, 16, 0}} ,{{139, 50}, {41, 16, 0}} ,{{119, 50}, {21, 16, 0}} ,{{120, 50}, {22, 16, 0}} ,{{125, 50}, {27, 16, 0}} ,{{240, 50}, {142, 16, 0}} ,{{128, 50}, {30, 16, 0}} ,{{195, 50}, {97, 16, 0}} ,{{178, 50}, {80, 16, 0}} ,{{132, 50}, {34, 16, 0}} ,{{225, 50}, {127, 16, 0}} ,{{218, 50}, {120, 16, 0}} ,{{221, 50}, {123, 16, 0}} ,{{224, 50}, {126, 16, 0}} ,{{217, 50}, {119, 16, 0}} ,{{227, 50}, {129, 16, 0}} ,{{215, 50}, {117, 16, 0}} ,{{216, 50}, {118, 16, 0}} ,{{222, 50}, {124, 16, 0}} ,{{220, 50}, {122, 16, 0}} ,{{223, 50}, {125, 16, 0}} ,{{226, 50}, {128, 16, 0}} ,{{219, 50}, {121, 16, 0}} ,{{179, 50}, {81, 16, 0}} ,{{114, 50}, {16, 16, 0}} ,{{115, 50}, {17, 16, 0}} ,{{109, 50}, {11, 16, 0}} ,{{110, 50}, {12, 16, 0}} ,{{135, 50}, {37, 16, 0}} ,{{136, 50}, {38, 16, 0}} ,{{182, 50}, {84, 16, 0}} ,{{183, 50}, {85, 16, 0}} ,{{180, 50}, {82, 16, 0}} ,{{181, 50}, {83, 16, 0}} ,{{127, 50}, {29, 16, 0}} ,{{200, 50}, {102, 16, 0}} ,{{199, 50}, {101, 16, 0}} ,{{124, 50}, {26, 16, 0}} ,{{217, 91}, {118, 170, 0}} ,{{215, 91}, {116, 170, 0}} ,{{216, 91}, {117, 170, 0}} ,{{211, 91}, {112, 170, 0}} ,{{250, 50}, {152, 16, 0}} ,{{247, 50}, {149, 16, 0}} ,{{246, 50}, {148, 16, 0}} ,{{251, 50}, {153, 16, 0}} ,{{243, 50}, {145, 16, 0}} ,{{249, 50}, {151, 16, 0}} ,{{248, 50}, {150, 16, 0}} ,{{245, 50}, {147, 16, 0}} ,{{244, 50}, {146, 16, 0}} ,{{242, 50}, {144, 16, 0}} ,{{152, 50}, {54, 16, 0}} ,{{156, 50}, {58, 16, 0}} ,{{153, 50}, {55, 16, 0}} ,{{252, 50}, {154, 16, 0}} ,{{253, 50}, {155, 16, 0}} ,{{172, 50}, {74, 16, 0}} ,{{222, 91}, {123, 170, 0}} ,{{241, 50}, {143, 16, 0}} ,{{173, 50}, {75, 16, 0}} ,{{239, 50}, {141, 16, 0}} ,{{237, 50}, {139, 16, 0}} ,{{238, 50}, {140, 16, 0}} ,{{233, 50}, {135, 16, 0}} ,{{234, 50}, {136, 16, 0}} ,{{235, 50}, {137, 16, 0}} ,{{236, 50}, {138, 16, 0}} ,{{155, 50}, {57, 16, 0}} ,{{154, 50}, {56, 16, 0}} ,{{203, 50}, {105, 16, 0}} ,{{204, 50}, {106, 16, 0}} ,{{205, 50}, {107, 16, 0}} ,{{206, 50}, {108, 16, 0}} ,{{207, 50}, {109, 16, 0}} ,{{176, 50}, {78, 16, 0}} ,{{218, 91}, {119, 170, 0}} ,{{219, 91}, {120, 170, 0}} ,{{220, 91}, {121, 170, 0}} ,{{175, 50}, {77, 16, 0}} ,{{177, 50}, {79, 16, 0}} ,{{174, 50}, {76, 16, 0}} ,{{1, 51}, {159, 16, 0}} ,{{0, 51}, {158, 16, 0}} ,{{197, 50}, {99, 16, 0}} ,{{198, 50}, {100, 16, 0}} ,{{142, 50}, {44, 16, 0}} ,{{148, 50}, {50, 16, 0}} ,{{254, 50}, {156, 16, 0}} ,{{255, 50}, {157, 16, 0}} ,{{147, 50}, {49, 16, 0}} ,{{151, 50}, {53, 16, 0}} ,{{211, 50}, {113, 16, 0}} ,{{143, 50}, {45, 16, 0}} ,{{144, 50}, {46, 16, 0}} ,{{214, 50}, {116, 16, 0}} ,{{212, 50}, {114, 16, 0}} ,{{213, 50}, {115, 16, 0}} ,{{149, 50}, {51, 16, 0}} ,{{150, 50}, {52, 16, 0}} ,{{196, 50}, {98, 16, 0}} ,{{229, 50}, {131, 16, 0}} ,{{230, 50}, {132, 16, 0}} ,{{231, 50}, {133, 16, 0}} ,{{232, 50}, {134, 16, 0}} ,{{141, 50}, {43, 16, 0}} ,{{145, 50}, {47, 16, 0}} ,{{146, 50}, {48, 16, 0}} ,{{186, 50}, {88, 16, 0}} ,{{187, 50}, {89, 16, 0}} ,{{184, 50}, {86, 16, 0}} ,{{185, 50}, {87, 16, 0}} ,{{201, 50}, {103, 16, 0}} ,{{202, 50}, {104, 16, 0}} ,{{177, 73}, {0, 42, 0}} ,{{178, 73}, {1, 42, 0}} ,{{179, 73}, {2, 42, 0}} ,{{33, 66}, {16, 34, 0}} ,{{211, 66}, {194, 34, 0}} ,{{209, 66}, {192, 34, 0}} ,{{210, 66}, {193, 34, 0}} ,{{32, 66}, {15, 34, 0}} ,{{182, 73}, {5, 42, 0}} ,{{183, 73}, {6, 42, 0}} ,{{34, 66}, {17, 34, 0}} ,{{186, 73}, {9, 42, 0}} ,{{212, 66}, {195, 34, 0}} ,{{180, 73}, {3, 42, 0}} ,{{181, 73}, {4, 42, 0}} ,{{176, 74}, {255, 42, 0}} ,{{24, 66}, {7, 34, 0}} ,{{227, 64}, {166, 32, 0}} ,{{205, 66}, {188, 34, 0}} ,{{127, 64}, {47, 32, 0}} ,{{185, 64}, {110, 32, 0}} ,{{192, 66}, {175, 34, 0}} ,{{203, 68}, {255, 36, 0}} ,{{207, 162}, {87, 241, 1}} ,{{208, 162}, {95, 241, 1}} ,{{190, 68}, {242, 36, 0}} ,{{183, 68}, {235, 36, 0}} ,{{187, 68}, {239, 36, 0}} ,{{186, 68}, {238, 36, 0}} ,{{191, 68}, {243, 36, 0}} ,{{189, 68}, {241, 36, 0}} ,{{188, 68}, {240, 36, 0}} ,{{185, 68}, {237, 36, 0}} ,{{184, 68}, {236, 36, 0}} ,{{192, 68}, {244, 36, 0}} ,{{214, 162}, {139, 241, 1}} ,{{209, 162}, {121, 241, 1}} ,{{210, 162}, {123, 241, 1}} ,{{211, 162}, {124, 241, 1}} ,{{212, 162}, {127, 241, 1}} ,{{215, 162}, {140, 241, 1}} ,{{216, 162}, {141, 241, 1}} ,{{88, 66}, {71, 34, 0}} ,{{153, 66}, {136, 34, 0}} ,{{154, 66}, {137, 34, 0}} ,{{130, 66}, {113, 34, 0}} ,{{134, 66}, {117, 34, 0}} ,{{138, 66}, {121, 34, 0}} ,{{129, 66}, {112, 34, 0}} ,{{133, 66}, {116, 34, 0}} ,{{137, 66}, {120, 34, 0}} ,{{18, 70}, {70, 38, 0}} ,{{126, 70}, {178, 38, 0}} ,{{231, 64}, {170, 32, 0}} ,{{110, 59}, {216, 25, 0}} ,{{107, 59}, {213, 25, 0}} ,{{106, 59}, {212, 25, 0}} ,{{111, 59}, {217, 25, 0}} ,{{103, 59}, {209, 25, 0}} ,{{109, 59}, {215, 25, 0}} ,{{108, 59}, {214, 25, 0}} ,{{105, 59}, {211, 25, 0}} ,{{104, 59}, {210, 25, 0}} ,{{102, 59}, {208, 25, 0}} ,{{99, 59}, {199, 25, 0}} ,{{98, 59}, {198, 25, 0}} ,{{97, 59}, {197, 25, 0}} ,{{96, 59}, {196, 25, 0}} ,{{95, 59}, {195, 25, 0}} ,{{94, 59}, {194, 25, 0}} ,{{93, 59}, {193, 25, 0}} ,{{66, 59}, {162, 25, 0}} ,{{65, 59}, {161, 25, 0}} ,{{58, 59}, {154, 25, 0}} ,{{64, 59}, {160, 25, 0}} ,{{34, 59}, {130, 25, 0}} ,{{70, 59}, {166, 25, 0}} ,{{60, 59}, {156, 25, 0}} ,{{54, 59}, {150, 25, 0}} ,{{48, 59}, {144, 25, 0}} ,{{36, 59}, {132, 25, 0}} ,{{52, 59}, {148, 25, 0}} ,{{53, 59}, {149, 25, 0}} ,{{32, 59}, {128, 25, 0}} ,{{41, 59}, {137, 25, 0}} ,{{74, 59}, {170, 25, 0}} ,{{46, 59}, {142, 25, 0}} ,{{47, 59}, {143, 25, 0}} ,{{40, 59}, {136, 25, 0}} ,{{59, 59}, {155, 25, 0}} ,{{35, 59}, {131, 25, 0}} ,{{71, 59}, {167, 25, 0}} ,{{42, 59}, {138, 25, 0}} ,{{69, 59}, {165, 25, 0}} ,{{68, 59}, {164, 25, 0}} ,{{61, 59}, {157, 25, 0}} ,{{67, 59}, {163, 25, 0}} ,{{37, 59}, {133, 25, 0}} ,{{72, 59}, {168, 25, 0}} ,{{63, 59}, {159, 25, 0}} ,{{57, 59}, {153, 25, 0}} ,{{51, 59}, {147, 25, 0}} ,{{39, 59}, {135, 25, 0}} ,{{55, 59}, {151, 25, 0}} ,{{56, 59}, {152, 25, 0}} ,{{33, 59}, {129, 25, 0}} ,{{44, 59}, {140, 25, 0}} ,{{75, 59}, {171, 25, 0}} ,{{49, 59}, {145, 25, 0}} ,{{50, 59}, {146, 25, 0}} ,{{43, 59}, {139, 25, 0}} ,{{62, 59}, {158, 25, 0}} ,{{38, 59}, {134, 25, 0}} ,{{73, 59}, {169, 25, 0}} ,{{45, 59}, {141, 25, 0}} ,{{113, 59}, {222, 25, 0}} ,{{114, 59}, {223, 25, 0}} ,{{112, 59}, {218, 25, 0}} ,{{100, 59}, {200, 25, 0}} ,{{101, 59}, {201, 25, 0}} ,{{77, 59}, {177, 25, 0}} ,{{87, 59}, {187, 25, 0}} ,{{82, 59}, {182, 25, 0}} ,{{86, 59}, {186, 25, 0}} ,{{81, 59}, {181, 25, 0}} ,{{78, 59}, {178, 25, 0}} ,{{92, 59}, {192, 25, 0}} ,{{83, 59}, {183, 25, 0}} ,{{84, 59}, {184, 25, 0}} ,{{90, 59}, {190, 25, 0}} ,{{89, 59}, {189, 25, 0}} ,{{79, 59}, {179, 25, 0}} ,{{85, 59}, {185, 25, 0}} ,{{91, 59}, {191, 25, 0}} ,{{80, 59}, {180, 25, 0}} ,{{88, 59}, {188, 25, 0}} ,{{76, 59}, {176, 25, 0}} ,{{169, 67}, {152, 35, 0}} ,{{71, 45}, {243, 7, 0}} ,{{66, 45}, {238, 7, 0}} ,{{67, 45}, {239, 7, 0}} ,{{68, 45}, {240, 7, 0}} ,{{69, 45}, {241, 7, 0}} ,{{70, 45}, {242, 7, 0}} ,{{63, 45}, {235, 7, 0}} ,{{64, 45}, {236, 7, 0}} ,{{65, 45}, {237, 7, 0}} ,{{76, 45}, {248, 7, 0}} ,{{28, 45}, {200, 7, 0}} ,{{25, 45}, {197, 7, 0}} ,{{24, 45}, {196, 7, 0}} ,{{29, 45}, {201, 7, 0}} ,{{21, 45}, {193, 7, 0}} ,{{27, 45}, {199, 7, 0}} ,{{26, 45}, {198, 7, 0}} ,{{23, 45}, {195, 7, 0}} ,{{22, 45}, {194, 7, 0}} ,{{20, 45}, {192, 7, 0}} ,{{77, 45}, {249, 7, 0}} ,{{72, 45}, {244, 7, 0}} ,{{78, 45}, {250, 7, 0}} ,{{30, 45}, {202, 7, 0}} ,{{39, 45}, {211, 7, 0}} ,{{43, 45}, {215, 7, 0}} ,{{44, 45}, {216, 7, 0}} ,{{37, 45}, {209, 7, 0}} ,{{33, 45}, {205, 7, 0}} ,{{31, 45}, {203, 7, 0}} ,{{49, 45}, {221, 7, 0}} ,{{48, 45}, {220, 7, 0}} ,{{56, 45}, {228, 7, 0}} ,{{32, 45}, {204, 7, 0}} ,{{42, 45}, {214, 7, 0}} ,{{61, 45}, {233, 7, 0}} ,{{60, 45}, {232, 7, 0}} ,{{62, 45}, {234, 7, 0}} ,{{50, 45}, {222, 7, 0}} ,{{51, 45}, {223, 7, 0}} ,{{53, 45}, {225, 7, 0}} ,{{38, 45}, {210, 7, 0}} ,{{55, 45}, {227, 7, 0}} ,{{52, 45}, {224, 7, 0}} ,{{54, 45}, {226, 7, 0}} ,{{59, 45}, {231, 7, 0}} ,{{36, 45}, {208, 7, 0}} ,{{35, 45}, {207, 7, 0}} ,{{40, 45}, {212, 7, 0}} ,{{45, 45}, {217, 7, 0}} ,{{46, 45}, {218, 7, 0}} ,{{47, 45}, {219, 7, 0}} ,{{41, 45}, {213, 7, 0}} ,{{34, 45}, {206, 7, 0}} ,{{57, 45}, {229, 7, 0}} ,{{58, 45}, {230, 7, 0}} ,{{73, 45}, {245, 7, 0}} ,{{75, 45}, {247, 7, 0}} ,{{74, 45}, {246, 7, 0}} ,{{66, 38}, {160, 0, 0}} ,{{186, 64}, {111, 32, 0}} ,{{97, 64}, {17, 32, 0}} ,{{142, 74}, {221, 42, 0}} ,{{206, 66}, {189, 34, 0}} ,{{195, 66}, {178, 34, 0}} ,{{197, 66}, {180, 34, 0}} ,{{211, 72}, {34, 41, 0}} ,{{168, 65}, {151, 33, 0}} ,{{217, 72}, {40, 41, 0}} ,{{226, 72}, {49, 41, 0}} ,{{223, 72}, {46, 41, 0}} ,{{213, 72}, {36, 41, 0}} ,{{185, 74}, {8, 43, 0}} ,{{232, 65}, {215, 33, 0}} ,{{177, 74}, {0, 43, 0}} ,{{248, 89}, {52, 168, 0}} ,{{245, 89}, {49, 168, 0}} ,{{244, 89}, {48, 168, 0}} ,{{247, 89}, {51, 168, 0}} ,{{246, 89}, {50, 168, 0}} ,{{249, 89}, {53, 168, 0}} ,{{251, 89}, {55, 168, 0}} ,{{253, 89}, {57, 168, 0}} ,{{250, 89}, {54, 168, 0}} ,{{252, 89}, {56, 168, 0}} ,{{210, 72}, {33, 41, 0}} ,{{167, 65}, {150, 33, 0}} ,{{216, 72}, {39, 41, 0}} ,{{227, 72}, {50, 41, 0}} ,{{2, 66}, {241, 33, 0}} ,{{201, 65}, {184, 33, 0}} ,{{212, 72}, {35, 41, 0}} ,{{186, 74}, {9, 43, 0}} ,{{231, 65}, {214, 33, 0}} ,{{178, 74}, {1, 43, 0}} ,{{102, 71}, {175, 39, 0}} ,{{103, 71}, {177, 39, 0}} ,{{90, 66}, {73, 34, 0}} ,{{26, 66}, {9, 34, 0}} ,{{85, 66}, {68, 34, 0}} ,{{149, 66}, {132, 34, 0}} ,{{150, 66}, {133, 34, 0}} ,{{140, 67}, {123, 35, 0}} ,{{113, 66}, {96, 34, 0}} ,{{126, 66}, {109, 34, 0}} ,{{128, 66}, {111, 34, 0}} ,{{115, 66}, {98, 34, 0}} ,{{127, 66}, {110, 34, 0}} ,{{251, 66}, {234, 34, 0}} ,{{253, 66}, {236, 34, 0}} ,{{55, 66}, {38, 34, 0}} ,{{78, 38}, {172, 0, 0}} ,{{243, 66}, {226, 34, 0}} ,{{244, 66}, {227, 34, 0}} ,{{82, 66}, {65, 34, 0}} ,{{190, 66}, {173, 34, 0}} ,{{159, 70}, {212, 38, 0}} ,{{101, 68}, {153, 36, 0}} ,{{94, 68}, {146, 36, 0}} ,{{98, 68}, {150, 36, 0}} ,{{97, 68}, {149, 36, 0}} ,{{102, 68}, {154, 36, 0}} ,{{100, 68}, {152, 36, 0}} ,{{230, 37}, {35, 0, 0}} ,{{99, 68}, {151, 36, 0}} ,{{93, 68}, {145, 36, 0}} ,{{96, 68}, {148, 36, 0}} ,{{95, 68}, {147, 36, 0}} ,{{103, 68}, {155, 36, 0}} ,{{45, 65}, {22, 33, 0}} ,{{122, 142}, {252, 255, 0}} ,{{88, 73}, {167, 41, 0}} ,{{87, 73}, {166, 41, 0}} ,{{40, 68}, {71, 36, 0}} ,{{37, 68}, {68, 36, 0}} ,{{38, 68}, {69, 36, 0}} ,{{39, 68}, {70, 36, 0}} ,{{34, 68}, {65, 36, 0}} ,{{42, 68}, {73, 36, 0}} ,{{41, 68}, {72, 36, 0}} ,{{43, 68}, {74, 36, 0}} ,{{35, 68}, {66, 36, 0}} ,{{33, 68}, {64, 36, 0}} ,{{36, 68}, {67, 36, 0}} ,{{195, 56}, {155, 22, 0}} ,{{184, 56}, {144, 22, 0}} ,{{169, 56}, {129, 22, 0}} ,{{178, 56}, {138, 22, 0}} ,{{177, 56}, {137, 22, 0}} ,{{175, 56}, {135, 22, 0}} ,{{189, 56}, {149, 22, 0}} ,{{187, 56}, {147, 22, 0}} ,{{193, 56}, {153, 22, 0}} ,{{171, 56}, {131, 22, 0}} ,{{180, 56}, {140, 22, 0}} ,{{192, 56}, {152, 22, 0}} ,{{188, 56}, {148, 22, 0}} ,{{170, 56}, {130, 22, 0}} ,{{179, 56}, {139, 22, 0}} ,{{181, 56}, {141, 22, 0}} ,{{173, 56}, {133, 22, 0}} ,{{185, 56}, {145, 22, 0}} ,{{190, 56}, {150, 22, 0}} ,{{194, 56}, {154, 22, 0}} ,{{183, 56}, {143, 22, 0}} ,{{172, 56}, {132, 22, 0}} ,{{182, 56}, {142, 22, 0}} ,{{176, 56}, {136, 22, 0}} ,{{174, 56}, {134, 22, 0}} ,{{191, 56}, {151, 22, 0}} ,{{186, 56}, {146, 22, 0}} ,{{196, 56}, {156, 22, 0}} ,{{168, 56}, {128, 22, 0}} ,{{125, 40}, {219, 2, 0}} ,{{61, 65}, {38, 33, 0}} ,{{91, 144}, {0, 3, 1}} ,{{92, 144}, {1, 3, 1}} ,{{119, 144}, {28, 3, 1}} ,{{94, 144}, {3, 3, 1}} ,{{95, 144}, {4, 3, 1}} ,{{117, 144}, {26, 3, 1}} ,{{114, 144}, {23, 3, 1}} ,{{102, 144}, {11, 3, 1}} ,{{103, 144}, {12, 3, 1}} ,{{104, 144}, {13, 3, 1}} ,{{110, 144}, {19, 3, 1}} ,{{118, 144}, {27, 3, 1}} ,{{111, 144}, {20, 3, 1}} ,{{105, 144}, {14, 3, 1}} ,{{98, 144}, {7, 3, 1}} ,{{100, 144}, {9, 3, 1}} ,{{120, 144}, {29, 3, 1}} ,{{101, 144}, {10, 3, 1}} ,{{93, 144}, {2, 3, 1}} ,{{116, 144}, {25, 3, 1}} ,{{109, 144}, {18, 3, 1}} ,{{106, 144}, {15, 3, 1}} ,{{107, 144}, {16, 3, 1}} ,{{115, 144}, {24, 3, 1}} ,{{108, 144}, {17, 3, 1}} ,{{112, 144}, {21, 3, 1}} ,{{99, 144}, {8, 3, 1}} ,{{113, 144}, {22, 3, 1}} ,{{121, 144}, {30, 3, 1}} ,{{96, 144}, {5, 3, 1}} ,{{97, 144}, {6, 3, 1}} ,{{125, 144}, {35, 3, 1}} ,{{123, 144}, {33, 3, 1}} ,{{122, 144}, {32, 3, 1}} ,{{124, 144}, {34, 3, 1}} ,{{233, 144}, {213, 3, 1}} ,{{229, 144}, {209, 3, 1}} ,{{231, 144}, {211, 3, 1}} ,{{232, 144}, {212, 3, 1}} ,{{230, 144}, {210, 3, 1}} ,{{184, 144}, {160, 3, 1}} ,{{220, 144}, {200, 3, 1}} ,{{221, 144}, {201, 3, 1}} ,{{222, 144}, {202, 3, 1}} ,{{202, 144}, {178, 3, 1}} ,{{226, 144}, {206, 3, 1}} ,{{227, 144}, {207, 3, 1}} ,{{192, 144}, {168, 3, 1}} ,{{197, 144}, {173, 3, 1}} ,{{224, 144}, {204, 3, 1}} ,{{225, 144}, {205, 3, 1}} ,{{198, 144}, {174, 3, 1}} ,{{199, 144}, {175, 3, 1}} ,{{203, 144}, {179, 3, 1}} ,{{189, 144}, {165, 3, 1}} ,{{190, 144}, {166, 3, 1}} ,{{219, 144}, {195, 3, 1}} ,{{185, 144}, {161, 3, 1}} ,{{193, 144}, {169, 3, 1}} ,{{194, 144}, {170, 3, 1}} ,{{187, 144}, {163, 3, 1}} ,{{188, 144}, {164, 3, 1}} ,{{214, 144}, {190, 3, 1}} ,{{206, 144}, {182, 3, 1}} ,{{207, 144}, {183, 3, 1}} ,{{208, 144}, {184, 3, 1}} ,{{204, 144}, {180, 3, 1}} ,{{205, 144}, {181, 3, 1}} ,{{201, 144}, {177, 3, 1}} ,{{212, 144}, {188, 3, 1}} ,{{213, 144}, {189, 3, 1}} ,{{215, 144}, {191, 3, 1}} ,{{217, 144}, {193, 3, 1}} ,{{218, 144}, {194, 3, 1}} ,{{195, 144}, {171, 3, 1}} ,{{200, 144}, {176, 3, 1}} ,{{196, 144}, {172, 3, 1}} ,{{186, 144}, {162, 3, 1}} ,{{210, 144}, {186, 3, 1}} ,{{211, 144}, {187, 3, 1}} ,{{191, 144}, {167, 3, 1}} ,{{223, 144}, {203, 3, 1}} ,{{209, 144}, {185, 3, 1}} ,{{216, 144}, {192, 3, 1}} ,{{228, 144}, {208, 3, 1}} ,{{114, 146}, {113, 10, 1}} ,{{115, 146}, {114, 10, 1}} ,{{105, 146}, {104, 10, 1}} ,{{118, 146}, {117, 10, 1}} ,{{116, 146}, {115, 10, 1}} ,{{122, 146}, {121, 10, 1}} ,{{113, 146}, {112, 10, 1}} ,{{119, 146}, {118, 10, 1}} ,{{117, 146}, {116, 10, 1}} ,{{97, 146}, {96, 10, 1}} ,{{99, 146}, {98, 10, 1}} ,{{108, 146}, {107, 10, 1}} ,{{110, 146}, {109, 10, 1}} ,{{98, 146}, {97, 10, 1}} ,{{100, 146}, {99, 10, 1}} ,{{109, 146}, {108, 10, 1}} ,{{101, 146}, {100, 10, 1}} ,{{104, 146}, {103, 10, 1}} ,{{111, 146}, {110, 10, 1}} ,{{112, 146}, {111, 10, 1}} ,{{107, 146}, {106, 10, 1}} ,{{103, 146}, {102, 10, 1}} ,{{106, 146}, {105, 10, 1}} ,{{120, 146}, {119, 10, 1}} ,{{124, 146}, {123, 10, 1}} ,{{125, 146}, {124, 10, 1}} ,{{102, 146}, {101, 10, 1}} ,{{123, 146}, {122, 10, 1}} ,{{121, 146}, {120, 10, 1}} ,{{127, 146}, {126, 10, 1}} ,{{126, 146}, {125, 10, 1}} ,{{128, 146}, {127, 10, 1}} ,{{247, 146}, {0, 12, 1}} ,{{0, 147}, {9, 12, 1}} ,{{8, 147}, {17, 12, 1}} ,{{2, 147}, {11, 12, 1}} ,{{10, 147}, {19, 12, 1}} ,{{6, 147}, {15, 12, 1}} ,{{17, 147}, {26, 12, 1}} ,{{23, 147}, {32, 12, 1}} ,{{27, 147}, {36, 12, 1}} ,{{51, 147}, {60, 12, 1}} ,{{53, 147}, {62, 12, 1}} ,{{60, 147}, {69, 12, 1}} ,{{15, 147}, {24, 12, 1}} ,{{4, 147}, {13, 12, 1}} ,{{21, 147}, {30, 12, 1}} ,{{26, 147}, {35, 12, 1}} ,{{43, 147}, {52, 12, 1}} ,{{49, 147}, {58, 12, 1}} ,{{52, 147}, {61, 12, 1}} ,{{54, 147}, {63, 12, 1}} ,{{58, 147}, {67, 12, 1}} ,{{13, 147}, {22, 12, 1}} ,{{63, 147}, {72, 12, 1}} ,{{41, 147}, {50, 12, 1}} ,{{24, 147}, {33, 12, 1}} ,{{25, 147}, {34, 12, 1}} ,{{31, 147}, {40, 12, 1}} ,{{36, 147}, {45, 12, 1}} ,{{29, 147}, {38, 12, 1}} ,{{33, 147}, {42, 12, 1}} ,{{38, 147}, {47, 12, 1}} ,{{56, 147}, {65, 12, 1}} ,{{11, 147}, {20, 12, 1}} ,{{250, 146}, {3, 12, 1}} ,{{40, 147}, {49, 12, 1}} ,{{45, 147}, {54, 12, 1}} ,{{253, 146}, {6, 12, 1}} ,{{254, 146}, {7, 12, 1}} ,{{19, 147}, {28, 12, 1}} ,{{39, 147}, {48, 12, 1}} ,{{47, 147}, {56, 12, 1}} ,{{62, 147}, {71, 12, 1}} ,{{248, 146}, {1, 12, 1}} ,{{1, 147}, {10, 12, 1}} ,{{9, 147}, {18, 12, 1}} ,{{249, 146}, {2, 12, 1}} ,{{3, 147}, {12, 12, 1}} ,{{7, 147}, {16, 12, 1}} ,{{18, 147}, {27, 12, 1}} ,{{28, 147}, {37, 12, 1}} ,{{37, 147}, {46, 12, 1}} ,{{61, 147}, {70, 12, 1}} ,{{16, 147}, {25, 12, 1}} ,{{5, 147}, {14, 12, 1}} ,{{22, 147}, {31, 12, 1}} ,{{35, 147}, {44, 12, 1}} ,{{44, 147}, {53, 12, 1}} ,{{50, 147}, {59, 12, 1}} ,{{55, 147}, {64, 12, 1}} ,{{59, 147}, {68, 12, 1}} ,{{14, 147}, {23, 12, 1}} ,{{252, 146}, {5, 12, 1}} ,{{42, 147}, {51, 12, 1}} ,{{32, 147}, {41, 12, 1}} ,{{30, 147}, {39, 12, 1}} ,{{34, 147}, {43, 12, 1}} ,{{57, 147}, {66, 12, 1}} ,{{12, 147}, {21, 12, 1}} ,{{251, 146}, {4, 12, 1}} ,{{46, 147}, {55, 12, 1}} ,{{255, 146}, {8, 12, 1}} ,{{20, 147}, {29, 12, 1}} ,{{48, 147}, {57, 12, 1}} ,{{87, 61}, {125, 28, 0}} ,{{50, 61}, {88, 28, 0}} ,{{47, 61}, {85, 28, 0}} ,{{46, 61}, {84, 28, 0}} ,{{51, 61}, {89, 28, 0}} ,{{43, 61}, {81, 28, 0}} ,{{49, 61}, {87, 28, 0}} ,{{48, 61}, {86, 28, 0}} ,{{45, 61}, {83, 28, 0}} ,{{44, 61}, {82, 28, 0}} ,{{42, 61}, {80, 28, 0}} ,{{83, 61}, {121, 28, 0}} ,{{59, 61}, {97, 28, 0}} ,{{58, 61}, {96, 28, 0}} ,{{60, 61}, {98, 28, 0}} ,{{61, 61}, {99, 28, 0}} ,{{54, 61}, {92, 28, 0}} ,{{56, 61}, {94, 28, 0}} ,{{55, 61}, {93, 28, 0}} ,{{53, 61}, {91, 28, 0}} ,{{74, 61}, {112, 28, 0}} ,{{75, 61}, {113, 28, 0}} ,{{73, 61}, {111, 28, 0}} ,{{76, 61}, {114, 28, 0}} ,{{64, 61}, {102, 28, 0}} ,{{65, 61}, {103, 28, 0}} ,{{66, 61}, {104, 28, 0}} ,{{63, 61}, {101, 28, 0}} ,{{52, 61}, {90, 28, 0}} ,{{57, 61}, {95, 28, 0}} ,{{72, 61}, {110, 28, 0}} ,{{62, 61}, {100, 28, 0}} ,{{77, 61}, {115, 28, 0}} ,{{67, 61}, {105, 28, 0}} ,{{79, 61}, {117, 28, 0}} ,{{81, 61}, {119, 28, 0}} ,{{78, 61}, {116, 28, 0}} ,{{80, 61}, {118, 28, 0}} ,{{68, 61}, {106, 28, 0}} ,{{69, 61}, {107, 28, 0}} ,{{70, 61}, {108, 28, 0}} ,{{71, 61}, {109, 28, 0}} ,{{84, 61}, {122, 28, 0}} ,{{82, 61}, {120, 28, 0}} ,{{86, 61}, {124, 28, 0}} ,{{89, 61}, {127, 28, 0}} ,{{88, 61}, {126, 28, 0}} ,{{85, 61}, {123, 28, 0}} ,{{116, 64}, {36, 32, 0}} ,{{246, 76}, {43, 46, 0}} ,{{160, 67}, {143, 35, 0}} ,{{161, 67}, {144, 35, 0}} ,{{116, 71}, {190, 39, 0}} ,{{29, 68}, {35, 36, 0}} ,{{243, 70}, {50, 39, 0}} ,{{236, 70}, {43, 39, 0}} ,{{221, 70}, {27, 39, 0}} ,{{253, 70}, {60, 39, 0}} ,{{120, 71}, {195, 39, 0}} ,{{121, 71}, {196, 39, 0}} ,{{217, 69}, {13, 38, 0}} ,{{54, 67}, {37, 35, 0}} ,{{199, 66}, {182, 34, 0}} ,{{62, 47}, {86, 11, 0}} ,{{63, 47}, {87, 11, 0}} ,{{79, 47}, {110, 11, 0}} ,{{76, 47}, {107, 11, 0}} ,{{75, 47}, {106, 11, 0}} ,{{80, 47}, {111, 11, 0}} ,{{72, 47}, {103, 11, 0}} ,{{78, 47}, {109, 11, 0}} ,{{77, 47}, {108, 11, 0}} ,{{74, 47}, {105, 11, 0}} ,{{73, 47}, {104, 11, 0}} ,{{71, 47}, {102, 11, 0}} ,{{81, 47}, {112, 11, 0}} ,{{2, 47}, {5, 11, 0}} ,{{3, 47}, {6, 11, 0}} ,{{11, 47}, {16, 11, 0}} ,{{13, 47}, {20, 11, 0}} ,{{36, 47}, {44, 11, 0}} ,{{37, 47}, {45, 11, 0}} ,{{19, 47}, {26, 11, 0}} ,{{20, 47}, {27, 11, 0}} ,{{31, 47}, {38, 11, 0}} ,{{26, 47}, {33, 11, 0}} ,{{27, 47}, {34, 11, 0}} ,{{32, 47}, {39, 11, 0}} ,{{10, 47}, {15, 11, 0}} ,{{16, 47}, {23, 11, 0}} ,{{17, 47}, {24, 11, 0}} ,{{47, 47}, {57, 11, 0}} ,{{4, 47}, {7, 11, 0}} ,{{5, 47}, {8, 11, 0}} ,{{21, 47}, {28, 11, 0}} ,{{22, 47}, {29, 11, 0}} ,{{14, 47}, {21, 11, 0}} ,{{15, 47}, {22, 11, 0}} ,{{41, 47}, {50, 11, 0}} ,{{42, 47}, {51, 11, 0}} ,{{38, 47}, {46, 11, 0}} ,{{33, 47}, {40, 11, 0}} ,{{18, 47}, {25, 11, 0}} ,{{28, 47}, {35, 11, 0}} ,{{23, 47}, {30, 11, 0}} ,{{12, 47}, {19, 11, 0}} ,{{34, 47}, {42, 11, 0}} ,{{35, 47}, {43, 11, 0}} ,{{40, 47}, {48, 11, 0}} ,{{65, 47}, {93, 11, 0}} ,{{64, 47}, {92, 11, 0}} ,{{46, 47}, {56, 11, 0}} ,{{44, 47}, {54, 11, 0}} ,{{45, 47}, {55, 11, 0}} ,{{29, 47}, {36, 11, 0}} ,{{30, 47}, {37, 11, 0}} ,{{24, 47}, {31, 11, 0}} ,{{25, 47}, {32, 11, 0}} ,{{6, 47}, {9, 11, 0}} ,{{7, 47}, {10, 11, 0}} ,{{43, 47}, {53, 11, 0}} ,{{9, 47}, {12, 11, 0}} ,{{68, 47}, {97, 11, 0}} ,{{8, 47}, {11, 11, 0}} ,{{67, 47}, {96, 11, 0}} ,{{82, 47}, {113, 11, 0}} ,{{39, 47}, {47, 11, 0}} ,{{66, 47}, {95, 11, 0}} ,{{0, 47}, {2, 11, 0}} ,{{49, 47}, {61, 11, 0}} ,{{255, 46}, {1, 11, 0}} ,{{48, 47}, {60, 11, 0}} ,{{61, 47}, {77, 11, 0}} ,{{1, 47}, {3, 11, 0}} ,{{50, 47}, {62, 11, 0}} ,{{58, 47}, {72, 11, 0}} ,{{60, 47}, {76, 11, 0}} ,{{57, 47}, {71, 11, 0}} ,{{51, 47}, {63, 11, 0}} ,{{52, 47}, {64, 11, 0}} ,{{59, 47}, {75, 11, 0}} ,{{53, 47}, {65, 11, 0}} ,{{54, 47}, {66, 11, 0}} ,{{69, 47}, {98, 11, 0}} ,{{70, 47}, {99, 11, 0}} ,{{55, 47}, {67, 11, 0}} ,{{56, 47}, {68, 11, 0}} ,{{40, 140}, {62, 253, 0}} ,{{41, 140}, {63, 253, 0}} ,{{242, 69}, {38, 38, 0}} ,{{124, 71}, {199, 39, 0}} ,{{144, 145}, {168, 4, 1}} ,{{141, 145}, {165, 4, 1}} ,{{140, 145}, {164, 4, 1}} ,{{145, 145}, {169, 4, 1}} ,{{137, 145}, {161, 4, 1}} ,{{143, 145}, {167, 4, 1}} ,{{142, 145}, {166, 4, 1}} ,{{139, 145}, {163, 4, 1}} ,{{138, 145}, {162, 4, 1}} ,{{136, 145}, {160, 4, 1}} ,{{128, 145}, {150, 4, 1}} ,{{133, 145}, {155, 4, 1}} ,{{106, 145}, {128, 4, 1}} ,{{107, 145}, {129, 4, 1}} ,{{117, 145}, {139, 4, 1}} ,{{112, 145}, {134, 4, 1}} ,{{116, 145}, {138, 4, 1}} ,{{129, 145}, {151, 4, 1}} ,{{134, 145}, {156, 4, 1}} ,{{119, 145}, {141, 4, 1}} ,{{118, 145}, {140, 4, 1}} ,{{126, 145}, {148, 4, 1}} ,{{130, 145}, {152, 4, 1}} ,{{109, 145}, {131, 4, 1}} ,{{121, 145}, {143, 4, 1}} ,{{111, 145}, {133, 4, 1}} ,{{122, 145}, {144, 4, 1}} ,{{123, 145}, {145, 4, 1}} ,{{124, 145}, {146, 4, 1}} ,{{131, 145}, {153, 4, 1}} ,{{135, 145}, {157, 4, 1}} ,{{120, 145}, {142, 4, 1}} ,{{113, 145}, {135, 4, 1}} ,{{114, 145}, {136, 4, 1}} ,{{115, 145}, {137, 4, 1}} ,{{108, 145}, {130, 4, 1}} ,{{132, 145}, {154, 4, 1}} ,{{125, 145}, {147, 4, 1}} ,{{110, 145}, {132, 4, 1}} ,{{127, 145}, {149, 4, 1}} ,{{60, 65}, {37, 33, 0}} ,{{238, 70}, {45, 39, 0}} ,{{219, 70}, {25, 39, 0}} ,{{225, 70}, {31, 39, 0}} ,{{105, 70}, {157, 38, 0}} ,{{142, 64}, {62, 32, 0}} ,{{128, 70}, {180, 38, 0}} ,{{228, 76}, {25, 46, 0}} ,{{218, 76}, {15, 46, 0}} ,{{121, 64}, {41, 32, 0}} ,{{54, 66}, {37, 34, 0}} ,{{163, 74}, {242, 42, 0}} ,{{164, 74}, {243, 42, 0}} ,{{71, 68}, {123, 36, 0}} ,{{68, 68}, {120, 36, 0}} ,{{67, 68}, {119, 36, 0}} ,{{72, 68}, {124, 36, 0}} ,{{64, 68}, {116, 36, 0}} ,{{70, 68}, {122, 36, 0}} ,{{69, 68}, {121, 36, 0}} ,{{66, 68}, {118, 36, 0}} ,{{65, 68}, {117, 36, 0}} ,{{59, 80}, {9, 50, 0}} ,{{73, 80}, {23, 50, 0}} ,{{58, 80}, {8, 50, 0}} ,{{72, 80}, {22, 50, 0}} ,{{78, 80}, {28, 50, 0}} ,{{63, 80}, {13, 50, 0}} ,{{77, 80}, {27, 50, 0}} ,{{57, 80}, {7, 50, 0}} ,{{71, 80}, {21, 50, 0}} ,{{60, 80}, {10, 50, 0}} ,{{74, 80}, {24, 50, 0}} ,{{50, 80}, {0, 50, 0}} ,{{64, 80}, {14, 50, 0}} ,{{54, 80}, {4, 50, 0}} ,{{68, 80}, {18, 50, 0}} ,{{51, 80}, {1, 50, 0}} ,{{65, 80}, {15, 50, 0}} ,{{62, 80}, {12, 50, 0}} ,{{76, 80}, {26, 50, 0}} ,{{55, 80}, {5, 50, 0}} ,{{69, 80}, {19, 50, 0}} ,{{53, 80}, {3, 50, 0}} ,{{67, 80}, {17, 50, 0}} ,{{56, 80}, {6, 50, 0}} ,{{70, 80}, {20, 50, 0}} ,{{61, 80}, {11, 50, 0}} ,{{75, 80}, {25, 50, 0}} ,{{52, 80}, {2, 50, 0}} ,{{66, 80}, {16, 50, 0}} ,{{112, 80}, {63, 50, 0}} ,{{107, 80}, {58, 50, 0}} ,{{104, 80}, {55, 50, 0}} ,{{96, 80}, {47, 50, 0}} ,{{88, 80}, {39, 50, 0}} ,{{110, 80}, {61, 50, 0}} ,{{113, 80}, {64, 50, 0}} ,{{103, 80}, {54, 50, 0}} ,{{92, 80}, {43, 50, 0}} ,{{85, 80}, {36, 50, 0}} ,{{84, 80}, {35, 50, 0}} ,{{99, 80}, {50, 50, 0}} ,{{105, 80}, {56, 50, 0}} ,{{95, 80}, {46, 50, 0}} ,{{91, 80}, {42, 50, 0}} ,{{101, 80}, {52, 50, 0}} ,{{89, 80}, {40, 50, 0}} ,{{81, 80}, {32, 50, 0}} ,{{116, 80}, {67, 50, 0}} ,{{106, 80}, {57, 50, 0}} ,{{111, 80}, {62, 50, 0}} ,{{114, 80}, {65, 50, 0}} ,{{115, 80}, {66, 50, 0}} ,{{87, 80}, {38, 50, 0}} ,{{86, 80}, {37, 50, 0}} ,{{100, 80}, {51, 50, 0}} ,{{102, 80}, {53, 50, 0}} ,{{98, 80}, {49, 50, 0}} ,{{108, 80}, {59, 50, 0}} ,{{97, 80}, {48, 50, 0}} ,{{109, 80}, {60, 50, 0}} ,{{90, 80}, {41, 50, 0}} ,{{83, 80}, {34, 50, 0}} ,{{82, 80}, {33, 50, 0}} ,{{93, 80}, {44, 50, 0}} ,{{94, 80}, {45, 50, 0}} ,{{79, 80}, {29, 50, 0}} ,{{80, 80}, {30, 50, 0}} ,{{166, 162}, {16, 241, 1}} ,{{167, 162}, {17, 241, 1}} ,{{168, 162}, {18, 241, 1}} ,{{169, 162}, {19, 241, 1}} ,{{170, 162}, {20, 241, 1}} ,{{171, 162}, {21, 241, 1}} ,{{172, 162}, {22, 241, 1}} ,{{173, 162}, {23, 241, 1}} ,{{174, 162}, {24, 241, 1}} ,{{175, 162}, {25, 241, 1}} ,{{176, 162}, {26, 241, 1}} ,{{177, 162}, {27, 241, 1}} ,{{178, 162}, {28, 241, 1}} ,{{179, 162}, {29, 241, 1}} ,{{180, 162}, {30, 241, 1}} ,{{181, 162}, {31, 241, 1}} ,{{182, 162}, {32, 241, 1}} ,{{183, 162}, {33, 241, 1}} ,{{184, 162}, {34, 241, 1}} ,{{185, 162}, {35, 241, 1}} ,{{186, 162}, {36, 241, 1}} ,{{187, 162}, {37, 241, 1}} ,{{188, 162}, {38, 241, 1}} ,{{189, 162}, {39, 241, 1}} ,{{190, 162}, {40, 241, 1}} ,{{191, 162}, {41, 241, 1}} ,{{104, 68}, {156, 36, 0}} ,{{105, 68}, {157, 36, 0}} ,{{106, 68}, {158, 36, 0}} ,{{107, 68}, {159, 36, 0}} ,{{108, 68}, {160, 36, 0}} ,{{109, 68}, {161, 36, 0}} ,{{110, 68}, {162, 36, 0}} ,{{111, 68}, {163, 36, 0}} ,{{112, 68}, {164, 36, 0}} ,{{113, 68}, {165, 36, 0}} ,{{114, 68}, {166, 36, 0}} ,{{115, 68}, {167, 36, 0}} ,{{116, 68}, {168, 36, 0}} ,{{117, 68}, {169, 36, 0}} ,{{118, 68}, {170, 36, 0}} ,{{119, 68}, {171, 36, 0}} ,{{120, 68}, {172, 36, 0}} ,{{121, 68}, {173, 36, 0}} ,{{122, 68}, {174, 36, 0}} ,{{123, 68}, {175, 36, 0}} ,{{124, 68}, {176, 36, 0}} ,{{125, 68}, {177, 36, 0}} ,{{126, 68}, {178, 36, 0}} ,{{127, 68}, {179, 36, 0}} ,{{128, 68}, {180, 36, 0}} ,{{129, 68}, {181, 36, 0}} ,{{81, 68}, {133, 36, 0}} ,{{74, 68}, {126, 36, 0}} ,{{78, 68}, {130, 36, 0}} ,{{77, 68}, {129, 36, 0}} ,{{82, 68}, {134, 36, 0}} ,{{80, 68}, {132, 36, 0}} ,{{79, 68}, {131, 36, 0}} ,{{73, 68}, {125, 36, 0}} ,{{76, 68}, {128, 36, 0}} ,{{75, 68}, {127, 36, 0}} ,{{83, 68}, {135, 36, 0}} ,{{73, 70}, {125, 38, 0}} ,{{19, 66}, {2, 34, 0}} ,{{129, 80}, {80, 50, 0}} ,{{143, 78}, {61, 48, 0}} ,{{162, 67}, {145, 35, 0}} ,{{163, 67}, {146, 35, 0}} ,{{250, 69}, {46, 38, 0}} ,{{209, 70}, {15, 39, 0}} ,{{232, 37}, {37, 0, 0}} ,{{74, 70}, {126, 38, 0}} ,{{119, 71}, {194, 39, 0}} ,{{146, 74}, {225, 42, 0}} ,{{191, 70}, {249, 38, 0}} ,{{23, 67}, {6, 35, 0}} ,{{128, 64}, {48, 32, 0}} ,{{99, 65}, {76, 33, 0}} ,{{129, 64}, {49, 32, 0}} ,{{228, 64}, {167, 32, 0}} ,{{238, 64}, {177, 32, 0}} ,{{51, 90}, {117, 168, 0}} ,{{27, 90}, {93, 168, 0}} ,{{43, 90}, {109, 168, 0}} ,{{46, 90}, {112, 168, 0}} ,{{12, 90}, {78, 168, 0}} ,{{2, 90}, {68, 168, 0}} ,{{49, 90}, {115, 168, 0}} ,{{3, 90}, {69, 168, 0}} ,{{8, 90}, {74, 168, 0}} ,{{41, 90}, {107, 168, 0}} ,{{16, 90}, {82, 168, 0}} ,{{30, 90}, {96, 168, 0}} ,{{36, 90}, {102, 168, 0}} ,{{34, 90}, {100, 168, 0}} ,{{0, 90}, {66, 168, 0}} ,{{35, 90}, {101, 168, 0}} ,{{26, 90}, {92, 168, 0}} ,{{28, 90}, {94, 168, 0}} ,{{4, 90}, {70, 168, 0}} ,{{254, 89}, {64, 168, 0}} ,{{255, 89}, {65, 168, 0}} ,{{23, 90}, {89, 168, 0}} ,{{13, 90}, {79, 168, 0}} ,{{9, 90}, {75, 168, 0}} ,{{1, 90}, {67, 168, 0}} ,{{42, 90}, {108, 168, 0}} ,{{5, 90}, {71, 168, 0}} ,{{31, 90}, {97, 168, 0}} ,{{10, 90}, {76, 168, 0}} ,{{11, 90}, {77, 168, 0}} ,{{32, 90}, {98, 168, 0}} ,{{22, 90}, {88, 168, 0}} ,{{25, 90}, {91, 168, 0}} ,{{24, 90}, {90, 168, 0}} ,{{20, 90}, {86, 168, 0}} ,{{6, 90}, {72, 168, 0}} ,{{7, 90}, {73, 168, 0}} ,{{14, 90}, {80, 168, 0}} ,{{15, 90}, {81, 168, 0}} ,{{39, 90}, {105, 168, 0}} ,{{40, 90}, {106, 168, 0}} ,{{29, 90}, {95, 168, 0}} ,{{45, 90}, {111, 168, 0}} ,{{44, 90}, {110, 168, 0}} ,{{17, 90}, {83, 168, 0}} ,{{33, 90}, {99, 168, 0}} ,{{21, 90}, {87, 168, 0}} ,{{19, 90}, {85, 168, 0}} ,{{18, 90}, {84, 168, 0}} ,{{53, 90}, {119, 168, 0}} ,{{52, 90}, {118, 168, 0}} ,{{50, 90}, {116, 168, 0}} ,{{47, 90}, {113, 168, 0}} ,{{37, 90}, {103, 168, 0}} ,{{38, 90}, {104, 168, 0}} ,{{48, 90}, {114, 168, 0}} ,{{232, 143}, {217, 1, 1}} ,{{0, 144}, {241, 1, 1}} ,{{246, 143}, {231, 1, 1}} ,{{240, 143}, {225, 1, 1}} ,{{233, 143}, {218, 1, 1}} ,{{250, 143}, {235, 1, 1}} ,{{226, 143}, {211, 1, 1}} ,{{241, 143}, {226, 1, 1}} ,{{251, 143}, {236, 1, 1}} ,{{227, 143}, {212, 1, 1}} ,{{235, 143}, {220, 1, 1}} ,{{245, 143}, {230, 1, 1}} ,{{243, 143}, {228, 1, 1}} ,{{12, 144}, {253, 1, 1}} ,{{242, 143}, {227, 1, 1}} ,{{254, 143}, {239, 1, 1}} ,{{253, 143}, {238, 1, 1}} ,{{7, 144}, {248, 1, 1}} ,{{230, 143}, {215, 1, 1}} ,{{8, 144}, {249, 1, 1}} ,{{229, 143}, {214, 1, 1}} ,{{249, 143}, {234, 1, 1}} ,{{248, 143}, {233, 1, 1}} ,{{239, 143}, {224, 1, 1}} ,{{5, 144}, {246, 1, 1}} ,{{236, 143}, {221, 1, 1}} ,{{237, 143}, {222, 1, 1}} ,{{6, 144}, {247, 1, 1}} ,{{3, 144}, {244, 1, 1}} ,{{223, 143}, {208, 1, 1}} ,{{1, 144}, {242, 1, 1}} ,{{224, 143}, {209, 1, 1}} ,{{252, 143}, {237, 1, 1}} ,{{4, 144}, {245, 1, 1}} ,{{238, 143}, {223, 1, 1}} ,{{234, 143}, {219, 1, 1}} ,{{247, 143}, {232, 1, 1}} ,{{244, 143}, {229, 1, 1}} ,{{10, 144}, {251, 1, 1}} ,{{9, 144}, {250, 1, 1}} ,{{225, 143}, {210, 1, 1}} ,{{231, 143}, {216, 1, 1}} ,{{255, 143}, {240, 1, 1}} ,{{2, 144}, {243, 1, 1}} ,{{11, 144}, {252, 1, 1}} ,{{228, 143}, {213, 1, 1}} ,{{64, 57}, {54, 23, 0}} ,{{63, 57}, {53, 23, 0}} ,{{247, 145}, {15, 9, 1}} ,{{232, 145}, {0, 9, 1}} ,{{233, 145}, {1, 9, 1}} ,{{235, 145}, {3, 9, 1}} ,{{234, 145}, {2, 9, 1}} ,{{236, 145}, {4, 9, 1}} ,{{239, 145}, {7, 9, 1}} ,{{242, 145}, {10, 9, 1}} ,{{243, 145}, {11, 9, 1}} ,{{244, 145}, {12, 9, 1}} ,{{245, 145}, {13, 9, 1}} ,{{248, 145}, {16, 9, 1}} ,{{250, 145}, {18, 9, 1}} ,{{251, 145}, {19, 9, 1}} ,{{249, 145}, {17, 9, 1}} ,{{246, 145}, {14, 9, 1}} ,{{252, 145}, {20, 9, 1}} ,{{253, 145}, {21, 9, 1}} ,{{240, 145}, {8, 9, 1}} ,{{237, 145}, {5, 9, 1}} ,{{241, 145}, {9, 9, 1}} ,{{238, 145}, {6, 9, 1}} ,{{254, 145}, {22, 9, 1}} ,{{1, 146}, {25, 9, 1}} ,{{255, 145}, {23, 9, 1}} ,{{3, 146}, {27, 9, 1}} ,{{0, 146}, {24, 9, 1}} ,{{2, 146}, {26, 9, 1}} ,{{4, 146}, {31, 9, 1}} ,{{154, 70}, {207, 38, 0}} ,{{88, 38}, {182, 0, 0}} ,{{240, 70}, {47, 39, 0}} ,{{31, 70}, {83, 38, 0}} ,{{229, 66}, {212, 34, 0}} ,{{139, 74}, {218, 42, 0}} ,{{41, 67}, {24, 35, 0}} ,{{37, 65}, {14, 33, 0}} ,{{38, 65}, {15, 33, 0}} ,{{83, 38}, {177, 0, 0}} ,{{238, 37}, {43, 0, 0}} ,{{35, 74}, {114, 42, 0}} ,{{222, 73}, {45, 42, 0}} ,{{223, 73}, {46, 42, 0}} ,{{234, 73}, {57, 42, 0}} ,{{217, 73}, {40, 42, 0}} ,{{212, 73}, {35, 42, 0}} ,{{214, 73}, {37, 42, 0}} ,{{211, 73}, {34, 42, 0}} ,{{216, 73}, {39, 42, 0}} ,{{213, 73}, {36, 42, 0}} ,{{215, 73}, {38, 42, 0}} ,{{19, 70}, {71, 38, 0}} ,{{124, 64}, {44, 32, 0}} ,{{39, 67}, {22, 35, 0}} ,{{100, 78}, {18, 48, 0}} ,{{114, 78}, {32, 48, 0}} ,{{69, 38}, {163, 0, 0}} ,{{139, 66}, {122, 34, 0}} ,{{104, 74}, {183, 42, 0}} ,{{100, 74}, {179, 42, 0}} ,{{106, 74}, {185, 42, 0}} ,{{102, 74}, {181, 42, 0}} ,{{96, 74}, {175, 42, 0}} ,{{98, 74}, {177, 42, 0}} ,{{249, 66}, {232, 34, 0}} ,{{141, 66}, {124, 34, 0}} ,{{143, 66}, {126, 34, 0}} ,{{193, 66}, {176, 34, 0}} ,{{53, 65}, {30, 33, 0}} ,{{193, 140}, {19, 254, 0}} ,{{190, 140}, {16, 254, 0}} ,{{208, 140}, {49, 254, 0}} ,{{209, 140}, {50, 254, 0}} ,{{195, 140}, {21, 254, 0}} ,{{199, 140}, {25, 254, 0}} ,{{191, 140}, {17, 254, 0}} ,{{192, 140}, {18, 254, 0}} ,{{222, 140}, {63, 254, 0}} ,{{218, 140}, {59, 254, 0}} ,{{224, 140}, {65, 254, 0}} ,{{214, 140}, {55, 254, 0}} ,{{220, 140}, {61, 254, 0}} ,{{212, 140}, {53, 254, 0}} ,{{230, 140}, {71, 254, 0}} ,{{216, 140}, {57, 254, 0}} ,{{226, 140}, {67, 254, 0}} ,{{197, 140}, {23, 254, 0}} ,{{210, 140}, {51, 254, 0}} ,{{196, 140}, {22, 254, 0}} ,{{223, 140}, {64, 254, 0}} ,{{219, 140}, {60, 254, 0}} ,{{225, 140}, {66, 254, 0}} ,{{215, 140}, {56, 254, 0}} ,{{221, 140}, {62, 254, 0}} ,{{213, 140}, {54, 254, 0}} ,{{231, 140}, {72, 254, 0}} ,{{217, 140}, {58, 254, 0}} ,{{227, 140}, {68, 254, 0}} ,{{198, 140}, {24, 254, 0}} ,{{194, 140}, {20, 254, 0}} ,{{207, 140}, {48, 254, 0}} ,{{211, 140}, {52, 254, 0}} ,{{168, 67}, {151, 35, 0}} ,{{130, 64}, {50, 32, 0}} ,{{170, 67}, {153, 35, 0}} ,{{22, 67}, {5, 35, 0}} ,{{97, 65}, {74, 33, 0}} ,{{72, 66}, {55, 34, 0}} ,{{46, 66}, {29, 34, 0}} ,{{88, 64}, {8, 32, 0}} ,{{98, 69}, {150, 37, 0}} ,{{99, 69}, {151, 37, 0}} ,{{100, 69}, {152, 37, 0}} ,{{101, 69}, {153, 37, 0}} ,{{102, 69}, {154, 37, 0}} ,{{103, 69}, {155, 37, 0}} ,{{104, 69}, {156, 37, 0}} ,{{105, 69}, {157, 37, 0}} ,{{106, 69}, {158, 37, 0}} ,{{107, 69}, {159, 37, 0}} ,{{189, 73}, {12, 42, 0}} ,{{167, 64}, {87, 32, 0}} ,{{53, 70}, {105, 38, 0}} ,{{199, 73}, {22, 42, 0}} ,{{112, 66}, {95, 34, 0}} ,{{152, 64}, {72, 32, 0}} ,{{2, 38}, {63, 0, 0}} ,{{135, 70}, {187, 38, 0}} ,{{229, 37}, {34, 0, 0}} ,{{200, 67}, {183, 35, 0}} ,{{238, 69}, {34, 38, 0}} ,{{146, 70}, {198, 38, 0}} ,{{210, 76}, {7, 46, 0}} ,{{209, 76}, {6, 46, 0}} ,{{214, 76}, {11, 46, 0}} ,{{71, 66}, {54, 34, 0}} ,{{72, 70}, {124, 38, 0}} ,{{70, 70}, {122, 38, 0}} ,{{63, 70}, {115, 38, 0}} ,{{64, 70}, {116, 38, 0}} ,{{65, 70}, {117, 38, 0}} ,{{66, 70}, {118, 38, 0}} ,{{67, 70}, {119, 38, 0}} ,{{68, 70}, {120, 38, 0}} ,{{69, 70}, {121, 38, 0}} ,{{139, 64}, {59, 32, 0}} ,{{80, 38}, {174, 0, 0}} ,{{245, 90}, {82, 169, 0}} ,{{243, 90}, {80, 169, 0}} ,{{242, 90}, {79, 169, 0}} ,{{244, 90}, {81, 169, 0}} ,{{233, 90}, {70, 169, 0}} ,{{218, 90}, {55, 169, 0}} ,{{220, 90}, {57, 169, 0}} ,{{215, 90}, {52, 169, 0}} ,{{212, 90}, {49, 169, 0}} ,{{228, 90}, {65, 169, 0}} ,{{221, 90}, {58, 169, 0}} ,{{211, 90}, {48, 169, 0}} ,{{225, 90}, {62, 169, 0}} ,{{219, 90}, {56, 169, 0}} ,{{229, 90}, {66, 169, 0}} ,{{216, 90}, {53, 169, 0}} ,{{231, 90}, {68, 169, 0}} ,{{213, 90}, {50, 169, 0}} ,{{230, 90}, {67, 169, 0}} ,{{222, 90}, {59, 169, 0}} ,{{232, 90}, {69, 169, 0}} ,{{217, 90}, {54, 169, 0}} ,{{224, 90}, {61, 169, 0}} ,{{223, 90}, {60, 169, 0}} ,{{214, 90}, {51, 169, 0}} ,{{227, 90}, {64, 169, 0}} ,{{226, 90}, {63, 169, 0}} ,{{247, 90}, {95, 169, 0}} ,{{246, 90}, {83, 169, 0}} ,{{237, 90}, {74, 169, 0}} ,{{239, 90}, {76, 169, 0}} ,{{236, 90}, {73, 169, 0}} ,{{241, 90}, {78, 169, 0}} ,{{240, 90}, {77, 169, 0}} ,{{234, 90}, {71, 169, 0}} ,{{238, 90}, {75, 169, 0}} ,{{235, 90}, {72, 169, 0}} ,{{123, 142}, {253, 255, 0}} ,{{54, 65}, {31, 33, 0}} ,{{171, 70}, {224, 38, 0}} ,{{172, 70}, {225, 38, 0}} ,{{223, 67}, {206, 35, 0}} ,{{84, 73}, {163, 41, 0}} ,{{86, 73}, {165, 41, 0}} ,{{134, 64}, {54, 32, 0}} ,{{111, 78}, {29, 48, 0}} ,{{158, 74}, {237, 42, 0}} ,{{97, 73}, {176, 41, 0}} ,{{220, 76}, {17, 46, 0}} ,{{33, 67}, {16, 35, 0}} ,{{155, 64}, {75, 32, 0}} ,{{133, 64}, {53, 32, 0}} ,{{249, 76}, {46, 46, 0}} ,{{229, 69}, {25, 38, 0}} ,{{90, 65}, {67, 33, 0}} ,{{159, 64}, {79, 32, 0}} ,{{78, 66}, {61, 34, 0}} ,{{222, 66}, {205, 34, 0}} ,{{135, 64}, {55, 32, 0}} ,{{31, 38}, {92, 0, 0}} ,{{166, 73}, {245, 41, 0}} ,{{125, 71}, {200, 39, 0}} ,{{168, 73}, {247, 41, 0}} ,{{242, 74}, {65, 43, 0}} ,{{248, 74}, {71, 43, 0}} ,{{172, 140}, {252, 253, 0}} ,{{94, 50}, {213, 15, 0}} ,{{96, 50}, {215, 15, 0}} ,{{59, 67}, {42, 35, 0}} ,{{174, 73}, {253, 41, 0}} ,{{93, 38}, {187, 0, 0}} ,{{96, 71}, {169, 39, 0}} ,{{233, 72}, {56, 41, 0}} ,{{123, 64}, {43, 32, 0}} ,{{95, 64}, {15, 32, 0}} ,{{126, 64}, {46, 32, 0}} ,{{238, 73}, {61, 42, 0}} ,{{163, 65}, {146, 33, 0}} ,{{203, 72}, {26, 41, 0}} ,{{38, 73}, {117, 41, 0}} ,{{249, 74}, {72, 43, 0}} ,{{253, 74}, {76, 43, 0}} ,{{243, 72}, {66, 41, 0}} ,{{37, 73}, {116, 41, 0}} ,{{183, 65}, {166, 33, 0}} ,{{209, 72}, {32, 41, 0}} ,{{213, 65}, {196, 33, 0}} ,{{244, 74}, {67, 43, 0}} ,{{245, 74}, {68, 43, 0}} ,{{248, 72}, {71, 41, 0}} ,{{246, 65}, {229, 33, 0}} ,{{207, 72}, {30, 41, 0}} ,{{197, 65}, {180, 33, 0}} ,{{194, 72}, {17, 41, 0}} ,{{12, 66}, {251, 33, 0}} ,{{187, 65}, {170, 33, 0}} ,{{189, 65}, {172, 33, 0}} ,{{246, 72}, {69, 41, 0}} ,{{172, 65}, {155, 33, 0}} ,{{180, 65}, {163, 33, 0}} ,{{198, 72}, {21, 41, 0}} ,{{197, 72}, {20, 41, 0}} ,{{191, 74}, {14, 43, 0}} ,{{192, 74}, {15, 43, 0}} ,{{9, 66}, {248, 33, 0}} ,{{243, 65}, {226, 33, 0}} ,{{227, 65}, {210, 33, 0}} ,{{205, 72}, {28, 41, 0}} ,{{184, 72}, {7, 41, 0}} ,{{224, 65}, {207, 33, 0}} ,{{180, 72}, {3, 41, 0}} ,{{190, 72}, {13, 41, 0}} ,{{221, 65}, {204, 33, 0}} ,{{210, 65}, {193, 33, 0}} ,{{26, 73}, {105, 41, 0}} ,{{30, 73}, {109, 41, 0}} ,{{16, 73}, {95, 41, 0}} ,{{8, 73}, {87, 41, 0}} ,{{209, 65}, {192, 33, 0}} ,{{25, 73}, {104, 41, 0}} ,{{29, 73}, {108, 41, 0}} ,{{21, 73}, {100, 41, 0}} ,{{12, 73}, {91, 41, 0}} ,{{4, 73}, {83, 41, 0}} ,{{15, 66}, {254, 33, 0}} ,{{218, 65}, {201, 33, 0}} ,{{247, 74}, {70, 43, 0}} ,{{238, 65}, {221, 33, 0}} ,{{236, 65}, {219, 33, 0}} ,{{192, 72}, {15, 41, 0}} ,{{182, 72}, {5, 41, 0}} ,{{178, 72}, {1, 41, 0}} ,{{199, 72}, {22, 41, 0}} ,{{201, 72}, {24, 41, 0}} ,{{200, 72}, {23, 41, 0}} ,{{177, 72}, {0, 41, 0}} ,{{193, 72}, {16, 41, 0}} ,{{177, 65}, {160, 33, 0}} ,{{174, 65}, {157, 33, 0}} ,{{249, 65}, {232, 33, 0}} ,{{1, 66}, {240, 33, 0}} ,{{48, 66}, {31, 34, 0}} ,{{91, 78}, {9, 48, 0}} ,{{67, 73}, {146, 41, 0}} ,{{204, 76}, {1, 46, 0}} ,{{203, 76}, {0, 46, 0}} ,{{77, 73}, {156, 41, 0}} ,{{207, 66}, {190, 34, 0}} ,{{141, 67}, {124, 35, 0}} ,{{69, 73}, {148, 41, 0}} ,{{165, 71}, {244, 39, 0}} ,{{5, 66}, {244, 33, 0}} ,{{99, 78}, {17, 48, 0}} ,{{73, 73}, {152, 41, 0}} ,{{26, 67}, {9, 35, 0}} ,{{95, 78}, {13, 48, 0}} ,{{64, 38}, {125, 0, 0}} ,{{190, 67}, {173, 35, 0}} ,{{189, 67}, {172, 35, 0}} ,{{188, 67}, {171, 35, 0}} ,{{208, 76}, {5, 46, 0}} ,{{93, 78}, {11, 48, 0}} ,{{33, 73}, {112, 41, 0}} ,{{244, 76}, {41, 46, 0}} ,{{109, 64}, {29, 32, 0}} ,{{140, 73}, {219, 41, 0}} ,{{46, 73}, {125, 41, 0}} ,{{28, 67}, {11, 35, 0}} ,{{163, 69}, {215, 37, 0}} ,{{92, 69}, {144, 37, 0}} ,{{232, 76}, {29, 46, 0}} ,{{219, 66}, {202, 34, 0}} ,{{97, 69}, {149, 37, 0}} ,{{135, 71}, {214, 39, 0}} ,{{236, 37}, {41, 0, 0}} ,{{176, 67}, {159, 35, 0}} ,{{177, 67}, {160, 35, 0}} ,{{175, 67}, {158, 35, 0}} ,{{216, 76}, {13, 46, 0}} ,{{123, 71}, {198, 39, 0}} ,{{221, 66}, {204, 34, 0}} ,{{242, 76}, {39, 46, 0}} ,{{105, 64}, {25, 32, 0}} ,{{32, 38}, {93, 0, 0}} ,{{182, 67}, {165, 35, 0}} ,{{183, 67}, {166, 35, 0}} ,{{181, 67}, {164, 35, 0}} ,{{150, 64}, {70, 32, 0}} ,{{63, 73}, {142, 41, 0}} ,{{65, 73}, {144, 41, 0}} ,{{61, 73}, {140, 41, 0}} ,{{206, 76}, {3, 46, 0}} ,{{179, 66}, {162, 34, 0}} ,{{103, 78}, {21, 48, 0}} ,{{213, 76}, {10, 46, 0}} ,{{208, 66}, {191, 34, 0}} ,{{127, 73}, {206, 41, 0}} ,{{236, 76}, {33, 46, 0}} ,{{202, 67}, {185, 35, 0}} ,{{97, 78}, {15, 48, 0}} ,{{53, 73}, {132, 41, 0}} ,{{105, 78}, {23, 48, 0}} ,{{55, 73}, {134, 41, 0}} ,{{109, 78}, {27, 48, 0}} ,{{107, 78}, {25, 48, 0}} ,{{138, 73}, {217, 41, 0}} ,{{124, 40}, {218, 2, 0}} ,{{104, 66}, {87, 34, 0}} ,{{103, 66}, {86, 34, 0}} ,{{41, 66}, {24, 34, 0}} ,{{251, 76}, {48, 46, 0}} ,{{220, 72}, {43, 41, 0}} ,{{225, 72}, {48, 41, 0}} ,{{221, 143}, {154, 1, 1}} ,{{222, 143}, {155, 1, 1}} ,{{217, 143}, {150, 1, 1}} ,{{215, 143}, {148, 1, 1}} ,{{220, 143}, {153, 1, 1}} ,{{126, 65}, {103, 33, 0}} ,{{129, 65}, {106, 33, 0}} ,{{131, 65}, {108, 33, 0}} ,{{157, 65}, {134, 33, 0}} ,{{158, 65}, {135, 33, 0}} ,{{123, 65}, {100, 33, 0}} ,{{133, 65}, {110, 33, 0}} ,{{152, 65}, {129, 33, 0}} ,{{122, 65}, {99, 33, 0}} ,{{127, 65}, {104, 33, 0}} ,{{119, 65}, {96, 33, 0}} ,{{132, 65}, {109, 33, 0}} ,{{159, 65}, {136, 33, 0}} ,{{134, 65}, {111, 33, 0}} ,{{151, 65}, {128, 33, 0}} ,{{154, 65}, {131, 33, 0}} ,{{125, 65}, {102, 33, 0}} ,{{124, 65}, {101, 33, 0}} ,{{156, 65}, {133, 33, 0}} ,{{128, 65}, {105, 33, 0}} ,{{153, 65}, {130, 33, 0}} ,{{121, 65}, {98, 33, 0}} ,{{130, 65}, {107, 33, 0}} ,{{120, 65}, {97, 33, 0}} ,{{218, 143}, {151, 1, 1}} ,{{213, 143}, {146, 1, 1}} ,{{219, 143}, {152, 1, 1}} ,{{211, 143}, {144, 1, 1}} ,{{214, 143}, {147, 1, 1}} ,{{216, 143}, {149, 1, 1}} ,{{212, 143}, {145, 1, 1}} ,{{81, 65}, {58, 33, 0}} ,{{33, 71}, {103, 39, 0}} ,{{31, 71}, {101, 39, 0}} ,{{165, 73}, {244, 41, 0}} ,{{71, 147}, {103, 14, 1}} ,{{68, 147}, {100, 14, 1}} ,{{67, 147}, {99, 14, 1}} ,{{72, 147}, {104, 14, 1}} ,{{64, 147}, {96, 14, 1}} ,{{70, 147}, {102, 14, 1}} ,{{69, 147}, {101, 14, 1}} ,{{66, 147}, {98, 14, 1}} ,{{65, 147}, {97, 14, 1}} ,{{91, 147}, {123, 14, 1}} ,{{92, 147}, {124, 14, 1}} ,{{93, 147}, {125, 14, 1}} ,{{94, 147}, {126, 14, 1}} ,{{80, 147}, {112, 14, 1}} ,{{89, 147}, {121, 14, 1}} ,{{77, 147}, {109, 14, 1}} ,{{86, 147}, {118, 14, 1}} ,{{76, 147}, {108, 14, 1}} ,{{85, 147}, {117, 14, 1}} ,{{81, 147}, {113, 14, 1}} ,{{90, 147}, {122, 14, 1}} ,{{82, 147}, {114, 14, 1}} ,{{79, 147}, {111, 14, 1}} ,{{88, 147}, {120, 14, 1}} ,{{78, 147}, {110, 14, 1}} ,{{87, 147}, {119, 14, 1}} ,{{73, 147}, {105, 14, 1}} ,{{75, 147}, {107, 14, 1}} ,{{84, 147}, {116, 14, 1}} ,{{74, 147}, {106, 14, 1}} ,{{83, 147}, {115, 14, 1}} ,{{19, 57}, {238, 22, 0}} ,{{21, 57}, {240, 22, 0}} ,{{18, 57}, {237, 22, 0}} ,{{207, 56}, {170, 22, 0}} ,{{208, 56}, {171, 22, 0}} ,{{238, 56}, {201, 22, 0}} ,{{205, 56}, {168, 22, 0}} ,{{247, 56}, {210, 22, 0}} ,{{242, 56}, {205, 22, 0}} ,{{8, 57}, {227, 22, 0}} ,{{9, 57}, {228, 22, 0}} ,{{216, 56}, {179, 22, 0}} ,{{7, 57}, {226, 22, 0}} ,{{246, 56}, {209, 22, 0}} ,{{3, 57}, {222, 22, 0}} ,{{0, 57}, {219, 22, 0}} ,{{229, 56}, {192, 22, 0}} ,{{249, 56}, {212, 22, 0}} ,{{231, 56}, {194, 22, 0}} ,{{5, 57}, {224, 22, 0}} ,{{251, 56}, {214, 22, 0}} ,{{219, 56}, {182, 22, 0}} ,{{204, 56}, {167, 22, 0}} ,{{197, 56}, {160, 22, 0}} ,{{218, 56}, {181, 22, 0}} ,{{221, 56}, {184, 22, 0}} ,{{220, 56}, {183, 22, 0}} ,{{233, 56}, {196, 22, 0}} ,{{224, 56}, {187, 22, 0}} ,{{223, 56}, {186, 22, 0}} ,{{13, 57}, {232, 22, 0}} ,{{2, 57}, {221, 22, 0}} ,{{1, 57}, {220, 22, 0}} ,{{6, 57}, {225, 22, 0}} ,{{230, 56}, {193, 22, 0}} ,{{236, 56}, {199, 22, 0}} ,{{232, 56}, {195, 22, 0}} ,{{215, 56}, {178, 22, 0}} ,{{217, 56}, {180, 22, 0}} ,{{255, 56}, {218, 22, 0}} ,{{234, 56}, {197, 22, 0}} ,{{225, 56}, {188, 22, 0}} ,{{253, 56}, {216, 22, 0}} ,{{209, 56}, {172, 22, 0}} ,{{11, 57}, {230, 22, 0}} ,{{252, 56}, {215, 22, 0}} ,{{227, 56}, {190, 22, 0}} ,{{211, 56}, {174, 22, 0}} ,{{212, 56}, {175, 22, 0}} ,{{213, 56}, {176, 22, 0}} ,{{250, 56}, {213, 22, 0}} ,{{206, 56}, {169, 22, 0}} ,{{4, 57}, {223, 22, 0}} ,{{237, 56}, {200, 22, 0}} ,{{14, 57}, {233, 22, 0}} ,{{214, 56}, {177, 22, 0}} ,{{235, 56}, {198, 22, 0}} ,{{248, 56}, {211, 22, 0}} ,{{226, 56}, {189, 22, 0}} ,{{254, 56}, {217, 22, 0}} ,{{228, 56}, {191, 22, 0}} ,{{210, 56}, {173, 22, 0}} ,{{241, 56}, {204, 22, 0}} ,{{245, 56}, {208, 22, 0}} ,{{12, 57}, {231, 22, 0}} ,{{240, 56}, {203, 22, 0}} ,{{239, 56}, {202, 22, 0}} ,{{10, 57}, {229, 22, 0}} ,{{203, 56}, {166, 22, 0}} ,{{244, 56}, {207, 22, 0}} ,{{199, 56}, {162, 22, 0}} ,{{198, 56}, {161, 22, 0}} ,{{202, 56}, {165, 22, 0}} ,{{222, 56}, {185, 22, 0}} ,{{15, 57}, {234, 22, 0}} ,{{201, 56}, {164, 22, 0}} ,{{200, 56}, {163, 22, 0}} ,{{243, 56}, {206, 22, 0}} ,{{17, 57}, {236, 22, 0}} ,{{16, 57}, {235, 22, 0}} ,{{20, 57}, {239, 22, 0}} ,{{229, 64}, {168, 32, 0}} ,{{28, 70}, {80, 38, 0}} ,{{187, 70}, {245, 38, 0}} ,{{223, 69}, {19, 38, 0}} ,{{131, 45}, {54, 8, 0}} ,{{79, 45}, {0, 8, 0}} ,{{84, 45}, {5, 8, 0}} ,{{80, 45}, {1, 8, 0}} ,{{82, 45}, {3, 8, 0}} ,{{95, 45}, {16, 8, 0}} ,{{81, 45}, {2, 8, 0}} ,{{94, 45}, {15, 8, 0}} ,{{86, 45}, {7, 8, 0}} ,{{83, 45}, {4, 8, 0}} ,{{89, 45}, {10, 8, 0}} ,{{90, 45}, {11, 8, 0}} ,{{91, 45}, {12, 8, 0}} ,{{92, 45}, {13, 8, 0}} ,{{97, 45}, {18, 8, 0}} ,{{98, 45}, {19, 8, 0}} ,{{99, 45}, {20, 8, 0}} ,{{93, 45}, {14, 8, 0}} ,{{100, 45}, {21, 8, 0}} ,{{87, 45}, {8, 8, 0}} ,{{96, 45}, {17, 8, 0}} ,{{88, 45}, {9, 8, 0}} ,{{85, 45}, {6, 8, 0}} ,{{104, 45}, {25, 8, 0}} ,{{106, 45}, {27, 8, 0}} ,{{101, 45}, {22, 8, 0}} ,{{102, 45}, {23, 8, 0}} ,{{124, 45}, {45, 8, 0}} ,{{103, 45}, {24, 8, 0}} ,{{105, 45}, {26, 8, 0}} ,{{119, 45}, {40, 8, 0}} ,{{115, 45}, {36, 8, 0}} ,{{126, 45}, {49, 8, 0}} ,{{127, 45}, {50, 8, 0}} ,{{139, 45}, {62, 8, 0}} ,{{137, 45}, {60, 8, 0}} ,{{129, 45}, {52, 8, 0}} ,{{128, 45}, {51, 8, 0}} ,{{132, 45}, {55, 8, 0}} ,{{125, 45}, {48, 8, 0}} ,{{134, 45}, {57, 8, 0}} ,{{130, 45}, {53, 8, 0}} ,{{138, 45}, {61, 8, 0}} ,{{136, 45}, {59, 8, 0}} ,{{135, 45}, {58, 8, 0}} ,{{133, 45}, {56, 8, 0}} ,{{114, 45}, {35, 8, 0}} ,{{111, 45}, {32, 8, 0}} ,{{108, 45}, {29, 8, 0}} ,{{121, 45}, {42, 8, 0}} ,{{113, 45}, {34, 8, 0}} ,{{110, 45}, {31, 8, 0}} ,{{107, 45}, {28, 8, 0}} ,{{120, 45}, {41, 8, 0}} ,{{117, 45}, {38, 8, 0}} ,{{122, 45}, {43, 8, 0}} ,{{112, 45}, {33, 8, 0}} ,{{109, 45}, {30, 8, 0}} ,{{116, 45}, {37, 8, 0}} ,{{123, 45}, {44, 8, 0}} ,{{118, 45}, {39, 8, 0}} ,{{16, 70}, {68, 38, 0}} ,{{106, 90}, {180, 168, 0}} ,{{123, 90}, {206, 168, 0}} ,{{133, 90}, {216, 168, 0}} ,{{130, 90}, {213, 168, 0}} ,{{129, 90}, {212, 168, 0}} ,{{134, 90}, {217, 168, 0}} ,{{126, 90}, {209, 168, 0}} ,{{132, 90}, {215, 168, 0}} ,{{131, 90}, {214, 168, 0}} ,{{128, 90}, {211, 168, 0}} ,{{127, 90}, {210, 168, 0}} ,{{125, 90}, {208, 168, 0}} ,{{124, 90}, {207, 168, 0}} ,{{56, 90}, {130, 168, 0}} ,{{57, 90}, {131, 168, 0}} ,{{68, 90}, {142, 168, 0}} ,{{71, 90}, {145, 168, 0}} ,{{94, 90}, {168, 168, 0}} ,{{95, 90}, {169, 168, 0}} ,{{77, 90}, {151, 168, 0}} ,{{78, 90}, {152, 168, 0}} ,{{89, 90}, {163, 168, 0}} ,{{84, 90}, {158, 168, 0}} ,{{85, 90}, {159, 168, 0}} ,{{90, 90}, {164, 168, 0}} ,{{66, 90}, {140, 168, 0}} ,{{67, 90}, {141, 168, 0}} ,{{74, 90}, {148, 168, 0}} ,{{75, 90}, {149, 168, 0}} ,{{104, 90}, {178, 168, 0}} ,{{58, 90}, {132, 168, 0}} ,{{59, 90}, {133, 168, 0}} ,{{79, 90}, {153, 168, 0}} ,{{80, 90}, {154, 168, 0}} ,{{72, 90}, {146, 168, 0}} ,{{73, 90}, {147, 168, 0}} ,{{99, 90}, {173, 168, 0}} ,{{105, 90}, {179, 168, 0}} ,{{96, 90}, {170, 168, 0}} ,{{91, 90}, {165, 168, 0}} ,{{76, 90}, {150, 168, 0}} ,{{86, 90}, {160, 168, 0}} ,{{81, 90}, {155, 168, 0}} ,{{69, 90}, {143, 168, 0}} ,{{70, 90}, {144, 168, 0}} ,{{92, 90}, {166, 168, 0}} ,{{93, 90}, {167, 168, 0}} ,{{98, 90}, {172, 168, 0}} ,{{103, 90}, {177, 168, 0}} ,{{101, 90}, {175, 168, 0}} ,{{102, 90}, {176, 168, 0}} ,{{87, 90}, {161, 168, 0}} ,{{88, 90}, {162, 168, 0}} ,{{82, 90}, {156, 168, 0}} ,{{83, 90}, {157, 168, 0}} ,{{60, 90}, {134, 168, 0}} ,{{61, 90}, {135, 168, 0}} ,{{100, 90}, {174, 168, 0}} ,{{64, 90}, {138, 168, 0}} ,{{65, 90}, {139, 168, 0}} ,{{62, 90}, {136, 168, 0}} ,{{63, 90}, {137, 168, 0}} ,{{97, 90}, {171, 168, 0}} ,{{54, 90}, {128, 168, 0}} ,{{122, 90}, {196, 168, 0}} ,{{55, 90}, {129, 168, 0}} ,{{107, 90}, {181, 168, 0}} ,{{118, 90}, {192, 168, 0}} ,{{121, 90}, {195, 168, 0}} ,{{116, 90}, {190, 168, 0}} ,{{117, 90}, {191, 168, 0}} ,{{108, 90}, {182, 168, 0}} ,{{109, 90}, {183, 168, 0}} ,{{119, 90}, {193, 168, 0}} ,{{120, 90}, {194, 168, 0}} ,{{110, 90}, {184, 168, 0}} ,{{111, 90}, {185, 168, 0}} ,{{114, 90}, {188, 168, 0}} ,{{115, 90}, {189, 168, 0}} ,{{112, 90}, {186, 168, 0}} ,{{113, 90}, {187, 168, 0}} ,{{98, 70}, {150, 38, 0}} ,{{27, 70}, {79, 38, 0}} ,{{67, 65}, {44, 33, 0}} ,{{71, 65}, {48, 33, 0}} ,{{72, 65}, {49, 33, 0}} ,{{34, 65}, {11, 33, 0}} ,{{39, 65}, {16, 33, 0}} ,{{41, 65}, {18, 33, 0}} ,{{74, 65}, {51, 33, 0}} ,{{47, 65}, {24, 33, 0}} ,{{50, 65}, {27, 33, 0}} ,{{70, 65}, {47, 33, 0}} ,{{33, 65}, {10, 33, 0}} ,{{42, 65}, {19, 33, 0}} ,{{75, 65}, {52, 33, 0}} ,{{31, 65}, {8, 33, 0}} ,{{73, 38}, {167, 0, 0}} ,{{37, 67}, {20, 35, 0}} ,{{36, 67}, {19, 35, 0}} ,{{254, 37}, {59, 0, 0}} ,{{227, 73}, {50, 42, 0}} ,{{134, 70}, {186, 38, 0}} ,{{55, 65}, {32, 33, 0}} ,{{228, 140}, {69, 254, 0}} ,{{136, 70}, {188, 38, 0}} ,{{39, 66}, {22, 34, 0}} ,{{133, 70}, {185, 38, 0}} ,{{13, 71}, {77, 39, 0}} ,{{224, 70}, {30, 39, 0}} ,{{241, 70}, {48, 39, 0}} ,{{228, 69}, {24, 38, 0}} ,{{83, 145}, {105, 4, 1}} ,{{91, 145}, {113, 4, 1}} ,{{87, 145}, {109, 4, 1}} ,{{100, 145}, {122, 4, 1}} ,{{98, 145}, {120, 4, 1}} ,{{102, 145}, {124, 4, 1}} ,{{82, 145}, {104, 4, 1}} ,{{97, 145}, {119, 4, 1}} ,{{68, 145}, {90, 4, 1}} ,{{65, 145}, {87, 4, 1}} ,{{69, 145}, {91, 4, 1}} ,{{103, 145}, {125, 4, 1}} ,{{90, 145}, {112, 4, 1}} ,{{81, 145}, {103, 4, 1}} ,{{101, 145}, {123, 4, 1}} ,{{61, 145}, {83, 4, 1}} ,{{70, 145}, {92, 4, 1}} ,{{77, 145}, {99, 4, 1}} ,{{67, 145}, {89, 4, 1}} ,{{104, 145}, {126, 4, 1}} ,{{92, 145}, {114, 4, 1}} ,{{80, 145}, {102, 4, 1}} ,{{75, 145}, {97, 4, 1}} ,{{60, 145}, {82, 4, 1}} ,{{78, 145}, {100, 4, 1}} ,{{74, 145}, {96, 4, 1}} ,{{79, 145}, {101, 4, 1}} ,{{89, 145}, {111, 4, 1}} ,{{94, 145}, {116, 4, 1}} ,{{96, 145}, {118, 4, 1}} ,{{84, 145}, {106, 4, 1}} ,{{95, 145}, {117, 4, 1}} ,{{99, 145}, {121, 4, 1}} ,{{86, 145}, {108, 4, 1}} ,{{58, 145}, {80, 4, 1}} ,{{88, 145}, {110, 4, 1}} ,{{63, 145}, {85, 4, 1}} ,{{64, 145}, {86, 4, 1}} ,{{72, 145}, {94, 4, 1}} ,{{62, 145}, {84, 4, 1}} ,{{59, 145}, {81, 4, 1}} ,{{93, 145}, {115, 4, 1}} ,{{71, 145}, {93, 4, 1}} ,{{76, 145}, {98, 4, 1}} ,{{85, 145}, {107, 4, 1}} ,{{66, 145}, {88, 4, 1}} ,{{105, 145}, {127, 4, 1}} ,{{73, 145}, {95, 4, 1}} ,{{175, 70}, {233, 38, 0}} ,{{144, 74}, {223, 42, 0}} ,{{152, 74}, {231, 42, 0}} ,{{143, 74}, {222, 42, 0}} ,{{245, 72}, {68, 41, 0}} ,{{145, 74}, {224, 42, 0}} ,{{154, 74}, {233, 42, 0}} ,{{153, 74}, {232, 42, 0}} ,{{142, 67}, {125, 35, 0}} ,{{147, 73}, {226, 41, 0}} ,{{81, 74}, {160, 42, 0}} ,{{80, 74}, {159, 42, 0}} ,{{29, 74}, {108, 42, 0}} ,{{79, 74}, {158, 42, 0}} ,{{78, 74}, {157, 42, 0}} ,{{80, 66}, {63, 34, 0}} ,{{107, 64}, {27, 32, 0}} ,{{137, 64}, {57, 32, 0}} ,{{106, 64}, {26, 32, 0}} ,{{138, 64}, {58, 32, 0}} ,{{176, 48}, {134, 13, 0}} ,{{178, 48}, {136, 13, 0}} ,{{177, 48}, {135, 13, 0}} ,{{189, 48}, {147, 13, 0}} ,{{220, 48}, {182, 13, 0}} ,{{199, 48}, {160, 13, 0}} ,{{214, 48}, {175, 13, 0}} ,{{208, 48}, {169, 13, 0}} ,{{195, 48}, {156, 13, 0}} ,{{201, 48}, {162, 13, 0}} ,{{193, 48}, {154, 13, 0}} ,{{218, 48}, {180, 13, 0}} ,{{212, 48}, {173, 13, 0}} ,{{206, 48}, {167, 13, 0}} ,{{223, 48}, {185, 13, 0}} ,{{192, 48}, {150, 13, 0}} ,{{175, 48}, {133, 13, 0}} ,{{226, 48}, {189, 13, 0}} ,{{216, 48}, {177, 13, 0}} ,{{230, 48}, {195, 13, 0}} ,{{188, 48}, {146, 13, 0}} ,{{187, 48}, {145, 13, 0}} ,{{233, 48}, {198, 13, 0}} ,{{231, 48}, {196, 13, 0}} ,{{180, 48}, {138, 13, 0}} ,{{186, 48}, {144, 13, 0}} ,{{185, 48}, {143, 13, 0}} ,{{184, 48}, {142, 13, 0}} ,{{183, 48}, {141, 13, 0}} ,{{179, 48}, {137, 13, 0}} ,{{197, 48}, {158, 13, 0}} ,{{221, 48}, {183, 13, 0}} ,{{200, 48}, {161, 13, 0}} ,{{215, 48}, {176, 13, 0}} ,{{209, 48}, {170, 13, 0}} ,{{196, 48}, {157, 13, 0}} ,{{202, 48}, {163, 13, 0}} ,{{194, 48}, {155, 13, 0}} ,{{219, 48}, {181, 13, 0}} ,{{213, 48}, {174, 13, 0}} ,{{207, 48}, {168, 13, 0}} ,{{222, 48}, {184, 13, 0}} ,{{232, 48}, {197, 13, 0}} ,{{210, 48}, {171, 13, 0}} ,{{229, 48}, {194, 13, 0}} ,{{191, 48}, {149, 13, 0}} ,{{190, 48}, {148, 13, 0}} ,{{225, 48}, {187, 13, 0}} ,{{217, 48}, {179, 13, 0}} ,{{211, 48}, {172, 13, 0}} ,{{198, 48}, {159, 13, 0}} ,{{205, 48}, {166, 13, 0}} ,{{203, 48}, {164, 13, 0}} ,{{204, 48}, {165, 13, 0}} ,{{228, 48}, {193, 13, 0}} ,{{182, 48}, {140, 13, 0}} ,{{181, 48}, {139, 13, 0}} ,{{227, 48}, {192, 13, 0}} ,{{224, 48}, {186, 13, 0}} ,{{252, 48}, {244, 13, 0}} ,{{234, 48}, {202, 13, 0}} ,{{173, 48}, {130, 13, 0}} ,{{174, 48}, {131, 13, 0}} ,{{235, 48}, {207, 13, 0}} ,{{237, 48}, {209, 13, 0}} ,{{250, 48}, {242, 13, 0}} ,{{251, 48}, {243, 13, 0}} ,{{239, 48}, {211, 13, 0}} ,{{244, 48}, {218, 13, 0}} ,{{241, 48}, {214, 13, 0}} ,{{242, 48}, {216, 13, 0}} ,{{249, 48}, {223, 13, 0}} ,{{236, 48}, {208, 13, 0}} ,{{238, 48}, {210, 13, 0}} ,{{240, 48}, {212, 13, 0}} ,{{243, 48}, {217, 13, 0}} ,{{246, 48}, {220, 13, 0}} ,{{247, 48}, {221, 13, 0}} ,{{248, 48}, {222, 13, 0}} ,{{245, 48}, {219, 13, 0}} ,{{86, 64}, {6, 32, 0}} ,{{251, 70}, {58, 39, 0}} ,{{255, 70}, {62, 39, 0}} ,{{247, 70}, {54, 39, 0}} ,{{189, 70}, {247, 38, 0}} ,{{236, 69}, {32, 38, 0}} ,{{71, 74}, {150, 42, 0}} ,{{73, 74}, {152, 42, 0}} ,{{70, 74}, {149, 42, 0}} ,{{72, 74}, {151, 42, 0}} ,{{193, 88}, {115, 166, 0}} ,{{68, 67}, {51, 35, 0}} ,{{9, 74}, {88, 42, 0}} ,{{8, 74}, {87, 42, 0}} ,{{91, 74}, {170, 42, 0}} ,{{93, 74}, {172, 42, 0}} ,{{254, 140}, {96, 254, 0}} ,{{255, 140}, {97, 254, 0}} ,{{243, 140}, {85, 254, 0}} ,{{239, 140}, {80, 254, 0}} ,{{8, 141}, {107, 254, 0}} ,{{30, 66}, {13, 34, 0}} ,{{15, 67}, {254, 34, 0}} ,{{13, 67}, {252, 34, 0}} ,{{6, 141}, {105, 254, 0}} ,{{27, 66}, {10, 34, 0}} ,{{8, 67}, {247, 34, 0}} ,{{5, 67}, {244, 34, 0}} ,{{246, 140}, {88, 254, 0}} ,{{4, 141}, {102, 254, 0}} ,{{245, 140}, {87, 254, 0}} ,{{241, 140}, {82, 254, 0}} ,{{3, 141}, {101, 254, 0}} ,{{1, 141}, {99, 254, 0}} ,{{240, 140}, {81, 254, 0}} ,{{249, 140}, {91, 254, 0}} ,{{247, 140}, {89, 254, 0}} ,{{251, 140}, {93, 254, 0}} ,{{2, 141}, {100, 254, 0}} ,{{253, 140}, {95, 254, 0}} ,{{7, 141}, {106, 254, 0}} ,{{0, 141}, {98, 254, 0}} ,{{244, 140}, {86, 254, 0}} ,{{5, 141}, {104, 254, 0}} ,{{250, 140}, {92, 254, 0}} ,{{248, 140}, {90, 254, 0}} ,{{252, 140}, {94, 254, 0}} ,{{142, 65}, {119, 33, 0}} ,{{145, 65}, {122, 33, 0}} ,{{147, 65}, {124, 33, 0}} ,{{139, 65}, {116, 33, 0}} ,{{149, 65}, {126, 33, 0}} ,{{138, 65}, {115, 33, 0}} ,{{143, 65}, {120, 33, 0}} ,{{135, 65}, {112, 33, 0}} ,{{148, 65}, {125, 33, 0}} ,{{150, 65}, {127, 33, 0}} ,{{141, 65}, {118, 33, 0}} ,{{140, 65}, {117, 33, 0}} ,{{144, 65}, {121, 33, 0}} ,{{137, 65}, {114, 33, 0}} ,{{146, 65}, {123, 33, 0}} ,{{136, 65}, {113, 33, 0}} ,{{242, 140}, {84, 254, 0}} ,{{126, 40}, {220, 2, 0}} ,{{185, 146}, {59, 11, 1}} ,{{18, 74}, {97, 42, 0}} ,{{228, 73}, {51, 42, 0}} ,{{52, 67}, {35, 35, 0}} ,{{5, 71}, {68, 39, 0}} ,{{207, 69}, {3, 38, 0}} ,{{144, 70}, {196, 38, 0}} ,{{137, 70}, {189, 38, 0}} ,{{165, 67}, {148, 35, 0}} ,{{79, 38}, {173, 0, 0}} ,{{242, 37}, {47, 0, 0}} ,{{167, 73}, {246, 41, 0}} ,{{46, 65}, {23, 33, 0}} ,{{169, 65}, {152, 33, 0}} ,{{218, 72}, {41, 41, 0}} ,{{222, 72}, {45, 41, 0}} ,{{3, 66}, {242, 33, 0}} ,{{214, 72}, {37, 41, 0}} ,{{187, 74}, {10, 43, 0}} ,{{233, 65}, {216, 33, 0}} ,{{179, 74}, {2, 43, 0}} ,{{170, 65}, {153, 33, 0}} ,{{219, 72}, {42, 41, 0}} ,{{215, 72}, {38, 41, 0}} ,{{188, 74}, {11, 43, 0}} ,{{234, 65}, {217, 33, 0}} ,{{180, 74}, {3, 43, 0}} ,{{227, 37}, {32, 0, 0}} ,{{8, 71}, {71, 39, 0}} ,{{244, 64}, {183, 32, 0}} ,{{51, 66}, {34, 34, 0}} ,{{81, 73}, {160, 41, 0}} ,{{82, 73}, {161, 41, 0}} ,{{119, 73}, {198, 41, 0}} ,{{244, 162}, {41, 242, 1}} ,{{245, 162}, {42, 242, 1}} ,{{248, 162}, {45, 242, 1}} ,{{223, 162}, {20, 242, 1}} ,{{227, 162}, {24, 242, 1}} ,{{233, 162}, {30, 242, 1}} ,{{235, 162}, {32, 242, 1}} ,{{231, 162}, {28, 242, 1}} ,{{221, 162}, {18, 242, 1}} ,{{249, 162}, {46, 242, 1}} ,{{240, 162}, {37, 242, 1}} ,{{239, 162}, {36, 242, 1}} ,{{224, 162}, {21, 242, 1}} ,{{226, 162}, {23, 242, 1}} ,{{220, 162}, {17, 242, 1}} ,{{247, 162}, {44, 242, 1}} ,{{232, 162}, {29, 242, 1}} ,{{219, 162}, {16, 242, 1}} ,{{252, 162}, {49, 242, 1}} ,{{242, 162}, {39, 242, 1}} ,{{250, 162}, {47, 242, 1}} ,{{243, 162}, {40, 242, 1}} ,{{230, 162}, {27, 242, 1}} ,{{234, 162}, {31, 242, 1}} ,{{228, 162}, {25, 242, 1}} ,{{241, 162}, {38, 242, 1}} ,{{229, 162}, {26, 242, 1}} ,{{237, 162}, {34, 242, 1}} ,{{236, 162}, {33, 242, 1}} ,{{225, 162}, {22, 242, 1}} ,{{238, 162}, {35, 242, 1}} ,{{251, 162}, {48, 242, 1}} ,{{246, 162}, {43, 242, 1}} ,{{178, 66}, {161, 34, 0}} ,{{118, 73}, {197, 41, 0}} ,{{247, 76}, {44, 46, 0}} ,{{202, 162}, {74, 241, 1}} ,{{222, 162}, {19, 242, 1}} ,{{139, 70}, {191, 38, 0}} ,{{197, 162}, {49, 241, 1}} ,{{198, 162}, {61, 241, 1}} ,{{199, 162}, {63, 241, 1}} ,{{200, 162}, {66, 241, 1}} ,{{201, 162}, {70, 241, 1}} ,{{176, 66}, {159, 34, 0}} ,{{203, 162}, {75, 241, 1}} ,{{175, 66}, {158, 34, 0}} ,{{206, 162}, {78, 241, 1}} ,{{117, 73}, {196, 41, 0}} ,{{168, 70}, {221, 38, 0}} ,{{204, 162}, {76, 241, 1}} ,{{120, 73}, {199, 41, 0}} ,{{121, 73}, {200, 41, 0}} ,{{205, 162}, {77, 241, 1}} ,{{177, 66}, {160, 34, 0}} ,{{51, 81}, {3, 51, 0}} ,{{242, 81}, {194, 51, 0}} ,{{50, 81}, {2, 51, 0}} ,{{48, 81}, {0, 51, 0}} ,{{49, 81}, {1, 51, 0}} ,{{163, 81}, {115, 51, 0}} ,{{15, 82}, {223, 51, 0}} ,{{93, 81}, {45, 51, 0}} ,{{164, 81}, {116, 51, 0}} ,{{108, 81}, {60, 51, 0}} ,{{97, 81}, {49, 51, 0}} ,{{110, 81}, {62, 51, 0}} ,{{243, 81}, {195, 51, 0}} ,{{100, 81}, {52, 51, 0}} ,{{184, 81}, {136, 51, 0}} ,{{164, 66}, {147, 34, 0}} ,{{244, 81}, {196, 51, 0}} ,{{245, 81}, {197, 51, 0}} ,{{205, 81}, {157, 51, 0}} ,{{212, 81}, {164, 51, 0}} ,{{208, 81}, {160, 51, 0}} ,{{247, 81}, {199, 51, 0}} ,{{175, 81}, {127, 51, 0}} ,{{165, 66}, {148, 34, 0}} ,{{246, 81}, {198, 51, 0}} ,{{162, 81}, {114, 51, 0}} ,{{84, 81}, {36, 51, 0}} ,{{248, 81}, {200, 51, 0}} ,{{85, 81}, {37, 51, 0}} ,{{217, 162}, {144, 241, 1}} ,{{199, 81}, {151, 51, 0}} ,{{167, 81}, {119, 51, 0}} ,{{169, 81}, {121, 51, 0}} ,{{168, 81}, {120, 51, 0}} ,{{86, 81}, {38, 51, 0}} ,{{56, 81}, {8, 51, 0}} ,{{171, 81}, {123, 51, 0}} ,{{174, 81}, {126, 51, 0}} ,{{172, 81}, {124, 51, 0}} ,{{173, 81}, {125, 51, 0}} ,{{254, 80}, {205, 50, 0}} ,{{55, 81}, {7, 51, 0}} ,{{255, 80}, {206, 50, 0}} ,{{201, 81}, {153, 51, 0}} ,{{222, 67}, {205, 35, 0}} ,{{188, 70}, {246, 38, 0}} ,{{47, 82}, {255, 51, 0}} ,{{63, 81}, {15, 51, 0}} ,{{62, 81}, {14, 51, 0}} ,{{183, 81}, {135, 51, 0}} ,{{195, 81}, {147, 51, 0}} ,{{64, 81}, {16, 51, 0}} ,{{65, 81}, {17, 51, 0}} ,{{67, 81}, {19, 51, 0}} ,{{220, 81}, {172, 51, 0}} ,{{72, 81}, {24, 51, 0}} ,{{73, 81}, {25, 51, 0}} ,{{249, 81}, {201, 51, 0}} ,{{250, 81}, {202, 51, 0}} ,{{90, 81}, {42, 51, 0}} ,{{102, 81}, {54, 51, 0}} ,{{105, 81}, {57, 51, 0}} ,{{253, 80}, {204, 50, 0}} ,{{218, 162}, {0, 242, 1}} ,{{111, 81}, {63, 51, 0}} ,{{114, 81}, {66, 51, 0}} ,{{113, 81}, {65, 51, 0}} ,{{251, 81}, {203, 51, 0}} ,{{161, 81}, {113, 51, 0}} ,{{98, 81}, {50, 51, 0}} ,{{99, 81}, {51, 51, 0}} ,{{101, 81}, {53, 51, 0}} ,{{192, 81}, {144, 51, 0}} ,{{160, 66}, {143, 34, 0}} ,{{162, 66}, {145, 34, 0}} ,{{245, 66}, {228, 34, 0}} ,{{252, 81}, {204, 51, 0}} ,{{52, 81}, {4, 51, 0}} ,{{53, 81}, {5, 51, 0}} ,{{170, 81}, {122, 51, 0}} ,{{180, 81}, {132, 51, 0}} ,{{59, 81}, {11, 51, 0}} ,{{60, 81}, {12, 51, 0}} ,{{61, 81}, {13, 51, 0}} ,{{181, 81}, {133, 51, 0}} ,{{185, 81}, {137, 51, 0}} ,{{76, 81}, {28, 51, 0}} ,{{191, 81}, {143, 51, 0}} ,{{193, 81}, {145, 51, 0}} ,{{68, 81}, {20, 51, 0}} ,{{69, 81}, {21, 51, 0}} ,{{70, 81}, {22, 51, 0}} ,{{71, 81}, {23, 51, 0}} ,{{253, 81}, {205, 51, 0}} ,{{200, 81}, {152, 51, 0}} ,{{206, 81}, {158, 51, 0}} ,{{254, 81}, {206, 51, 0}} ,{{214, 81}, {166, 51, 0}} ,{{210, 81}, {162, 51, 0}} ,{{78, 81}, {30, 51, 0}} ,{{77, 81}, {29, 51, 0}} ,{{218, 81}, {170, 51, 0}} ,{{255, 81}, {207, 51, 0}} ,{{75, 81}, {27, 51, 0}} ,{{74, 81}, {26, 51, 0}} ,{{232, 81}, {184, 51, 0}} ,{{238, 81}, {190, 51, 0}} ,{{66, 81}, {18, 51, 0}} ,{{240, 81}, {192, 51, 0}} ,{{126, 74}, {205, 42, 0}} ,{{0, 82}, {208, 51, 0}} ,{{1, 82}, {209, 51, 0}} ,{{2, 82}, {210, 51, 0}} ,{{34, 67}, {17, 35, 0}} ,{{3, 82}, {211, 51, 0}} ,{{179, 81}, {131, 51, 0}} ,{{117, 81}, {69, 51, 0}} ,{{115, 81}, {67, 51, 0}} ,{{116, 81}, {68, 51, 0}} ,{{119, 81}, {71, 51, 0}} ,{{118, 81}, {70, 51, 0}} ,{{182, 81}, {134, 51, 0}} ,{{4, 82}, {212, 51, 0}} ,{{125, 81}, {77, 51, 0}} ,{{123, 81}, {75, 51, 0}} ,{{124, 81}, {76, 51, 0}} ,{{190, 81}, {142, 51, 0}} ,{{194, 81}, {146, 51, 0}} ,{{120, 81}, {72, 51, 0}} ,{{5, 82}, {213, 51, 0}} ,{{121, 81}, {73, 51, 0}} ,{{122, 81}, {74, 51, 0}} ,{{198, 81}, {150, 51, 0}} ,{{204, 81}, {156, 51, 0}} ,{{211, 81}, {163, 51, 0}} ,{{207, 81}, {159, 51, 0}} ,{{6, 82}, {214, 51, 0}} ,{{219, 81}, {171, 51, 0}} ,{{227, 81}, {179, 51, 0}} ,{{178, 81}, {130, 51, 0}} ,{{188, 81}, {140, 51, 0}} ,{{189, 81}, {141, 51, 0}} ,{{197, 81}, {149, 51, 0}} ,{{203, 81}, {155, 51, 0}} ,{{226, 81}, {178, 51, 0}} ,{{230, 81}, {182, 51, 0}} ,{{236, 81}, {188, 51, 0}} ,{{231, 81}, {183, 51, 0}} ,{{233, 81}, {185, 51, 0}} ,{{237, 81}, {189, 51, 0}} ,{{239, 81}, {191, 51, 0}} ,{{213, 81}, {165, 51, 0}} ,{{241, 81}, {193, 51, 0}} ,{{215, 81}, {167, 51, 0}} ,{{216, 81}, {168, 51, 0}} ,{{209, 81}, {161, 51, 0}} ,{{177, 81}, {129, 51, 0}} ,{{88, 81}, {40, 51, 0}} ,{{187, 81}, {139, 51, 0}} ,{{202, 81}, {154, 51, 0}} ,{{89, 81}, {41, 51, 0}} ,{{225, 81}, {177, 51, 0}} ,{{229, 81}, {181, 51, 0}} ,{{235, 81}, {187, 51, 0}} ,{{57, 81}, {9, 51, 0}} ,{{58, 81}, {10, 51, 0}} ,{{161, 66}, {144, 34, 0}} ,{{163, 66}, {146, 34, 0}} ,{{246, 66}, {229, 34, 0}} ,{{165, 81}, {117, 51, 0}} ,{{217, 81}, {169, 51, 0}} ,{{91, 81}, {43, 51, 0}} ,{{92, 81}, {44, 51, 0}} ,{{176, 81}, {128, 51, 0}} ,{{166, 81}, {118, 51, 0}} ,{{107, 81}, {59, 51, 0}} ,{{104, 81}, {56, 51, 0}} ,{{106, 81}, {58, 51, 0}} ,{{103, 81}, {55, 51, 0}} ,{{186, 81}, {138, 51, 0}} ,{{7, 82}, {215, 51, 0}} ,{{94, 81}, {46, 51, 0}} ,{{96, 81}, {48, 51, 0}} ,{{95, 81}, {47, 51, 0}} ,{{8, 82}, {216, 51, 0}} ,{{109, 81}, {61, 51, 0}} ,{{112, 81}, {64, 51, 0}} ,{{9, 82}, {217, 51, 0}} ,{{10, 82}, {218, 51, 0}} ,{{224, 81}, {176, 51, 0}} ,{{228, 81}, {180, 51, 0}} ,{{234, 81}, {186, 51, 0}} ,{{221, 81}, {173, 51, 0}} ,{{222, 81}, {174, 51, 0}} ,{{223, 81}, {175, 51, 0}} ,{{133, 81}, {85, 51, 0}} ,{{134, 81}, {86, 51, 0}} ,{{127, 74}, {206, 42, 0}} ,{{130, 81}, {82, 51, 0}} ,{{129, 81}, {81, 51, 0}} ,{{43, 66}, {26, 34, 0}} ,{{131, 81}, {83, 51, 0}} ,{{132, 81}, {84, 51, 0}} ,{{79, 81}, {31, 51, 0}} ,{{80, 81}, {32, 51, 0}} ,{{82, 81}, {34, 51, 0}} ,{{83, 81}, {35, 51, 0}} ,{{81, 81}, {33, 51, 0}} ,{{11, 82}, {219, 51, 0}} ,{{12, 82}, {220, 51, 0}} ,{{196, 81}, {148, 51, 0}} ,{{87, 81}, {39, 51, 0}} ,{{54, 81}, {6, 51, 0}} ,{{14, 82}, {222, 51, 0}} ,{{135, 81}, {87, 51, 0}} ,{{13, 82}, {221, 51, 0}} ,{{196, 74}, {19, 43, 0}} ,{{145, 73}, {224, 41, 0}} ,{{117, 69}, {169, 37, 0}} ,{{112, 69}, {164, 37, 0}} ,{{179, 69}, {231, 37, 0}} ,{{198, 74}, {21, 43, 0}} ,{{182, 69}, {234, 37, 0}} ,{{114, 69}, {166, 37, 0}} ,{{180, 69}, {232, 37, 0}} ,{{195, 74}, {18, 43, 0}} ,{{181, 69}, {233, 37, 0}} ,{{115, 69}, {167, 37, 0}} ,{{197, 74}, {20, 43, 0}} ,{{116, 69}, {168, 37, 0}} ,{{113, 69}, {165, 37, 0}} ,{{126, 81}, {78, 51, 0}} ,{{127, 81}, {79, 51, 0}} ,{{128, 81}, {80, 51, 0}} ,{{94, 71}, {167, 39, 0}} ,{{97, 70}, {149, 38, 0}} ,{{102, 70}, {154, 38, 0}} ,{{246, 69}, {42, 38, 0}} ,{{108, 66}, {91, 34, 0}} ,{{227, 70}, {33, 39, 0}} ,{{215, 66}, {198, 34, 0}} ,{{245, 67}, {228, 35, 0}} ,{{234, 70}, {41, 39, 0}} ,{{116, 66}, {99, 34, 0}} ,{{209, 64}, {136, 32, 0}} ,{{213, 64}, {140, 32, 0}} ,{{206, 64}, {133, 32, 0}} ,{{205, 64}, {132, 32, 0}} ,{{214, 64}, {141, 32, 0}} ,{{212, 64}, {139, 32, 0}} ,{{210, 64}, {137, 32, 0}} ,{{202, 64}, {129, 32, 0}} ,{{211, 64}, {138, 32, 0}} ,{{215, 64}, {142, 32, 0}} ,{{208, 64}, {135, 32, 0}} ,{{207, 64}, {134, 32, 0}} ,{{204, 64}, {131, 32, 0}} ,{{203, 64}, {130, 32, 0}} ,{{201, 64}, {128, 32, 0}} ,{{42, 73}, {121, 41, 0}} ,{{134, 74}, {213, 42, 0}} ,{{132, 74}, {211, 42, 0}} ,{{147, 66}, {130, 34, 0}} ,{{122, 74}, {201, 42, 0}} ,{{118, 74}, {197, 42, 0}} ,{{124, 74}, {203, 42, 0}} ,{{120, 74}, {199, 42, 0}} ,{{151, 66}, {134, 34, 0}} ,{{116, 74}, {195, 42, 0}} ,{{155, 66}, {138, 34, 0}} ,{{110, 74}, {189, 42, 0}} ,{{114, 74}, {193, 42, 0}} ,{{112, 74}, {191, 42, 0}} ,{{140, 66}, {123, 34, 0}} ,{{105, 74}, {184, 42, 0}} ,{{101, 74}, {180, 42, 0}} ,{{107, 74}, {186, 42, 0}} ,{{103, 74}, {182, 42, 0}} ,{{97, 74}, {176, 42, 0}} ,{{99, 74}, {178, 42, 0}} ,{{250, 66}, {233, 34, 0}} ,{{142, 66}, {125, 34, 0}} ,{{144, 66}, {127, 34, 0}} ,{{194, 66}, {177, 34, 0}} ,{{196, 67}, {179, 35, 0}} ,{{195, 67}, {178, 35, 0}} ,{{188, 73}, {11, 42, 0}} ,{{213, 69}, {9, 38, 0}} ,{{202, 60}, {161, 27, 0}} ,{{203, 60}, {162, 27, 0}} ,{{204, 60}, {163, 27, 0}} ,{{222, 60}, {184, 27, 0}} ,{{219, 60}, {181, 27, 0}} ,{{218, 60}, {180, 27, 0}} ,{{223, 60}, {185, 27, 0}} ,{{215, 60}, {177, 27, 0}} ,{{221, 60}, {183, 27, 0}} ,{{220, 60}, {182, 27, 0}} ,{{217, 60}, {179, 27, 0}} ,{{216, 60}, {178, 27, 0}} ,{{214, 60}, {176, 27, 0}} ,{{172, 60}, {131, 27, 0}} ,{{175, 60}, {134, 27, 0}} ,{{193, 60}, {152, 27, 0}} ,{{183, 60}, {142, 27, 0}} ,{{188, 60}, {147, 27, 0}} ,{{177, 60}, {136, 27, 0}} ,{{178, 60}, {137, 27, 0}} ,{{191, 60}, {150, 27, 0}} ,{{181, 60}, {140, 27, 0}} ,{{201, 60}, {160, 27, 0}} ,{{173, 60}, {132, 27, 0}} ,{{184, 60}, {143, 27, 0}} ,{{179, 60}, {138, 27, 0}} ,{{212, 60}, {174, 27, 0}} ,{{197, 60}, {156, 27, 0}} ,{{194, 60}, {153, 27, 0}} ,{{189, 60}, {148, 27, 0}} ,{{182, 60}, {141, 27, 0}} ,{{186, 60}, {145, 27, 0}} ,{{176, 60}, {135, 27, 0}} ,{{190, 60}, {149, 27, 0}} ,{{180, 60}, {139, 27, 0}} ,{{196, 60}, {155, 27, 0}} ,{{199, 60}, {158, 27, 0}} ,{{213, 60}, {175, 27, 0}} ,{{187, 60}, {146, 27, 0}} ,{{174, 60}, {133, 27, 0}} ,{{192, 60}, {151, 27, 0}} ,{{198, 60}, {157, 27, 0}} ,{{200, 60}, {159, 27, 0}} ,{{195, 60}, {154, 27, 0}} ,{{185, 60}, {144, 27, 0}} ,{{211, 60}, {170, 27, 0}} ,{{170, 60}, {129, 27, 0}} ,{{171, 60}, {130, 27, 0}} ,{{169, 60}, {128, 27, 0}} ,{{209, 60}, {168, 27, 0}} ,{{207, 60}, {166, 27, 0}} ,{{210, 60}, {169, 27, 0}} ,{{205, 60}, {164, 27, 0}} ,{{208, 60}, {167, 27, 0}} ,{{206, 60}, {165, 27, 0}} ,{{145, 70}, {197, 38, 0}} ,{{193, 64}, {120, 32, 0}} ,{{197, 64}, {124, 32, 0}} ,{{190, 64}, {117, 32, 0}} ,{{189, 64}, {116, 32, 0}} ,{{188, 64}, {113, 32, 0}} ,{{200, 64}, {127, 32, 0}} ,{{198, 64}, {125, 32, 0}} ,{{196, 64}, {123, 32, 0}} ,{{194, 64}, {121, 32, 0}} ,{{91, 38}, {185, 0, 0}} ,{{195, 64}, {122, 32, 0}} ,{{199, 64}, {126, 32, 0}} ,{{192, 64}, {119, 32, 0}} ,{{191, 64}, {118, 32, 0}} ,{{85, 38}, {179, 0, 0}} ,{{84, 38}, {178, 0, 0}} ,{{187, 64}, {112, 32, 0}} ,{{44, 73}, {123, 41, 0}} ,{{133, 74}, {212, 42, 0}} ,{{135, 74}, {214, 42, 0}} ,{{137, 74}, {216, 42, 0}} ,{{136, 74}, {215, 42, 0}} ,{{148, 66}, {131, 34, 0}} ,{{123, 74}, {202, 42, 0}} ,{{119, 74}, {198, 42, 0}} ,{{125, 74}, {204, 42, 0}} ,{{121, 74}, {200, 42, 0}} ,{{152, 66}, {135, 34, 0}} ,{{117, 74}, {196, 42, 0}} ,{{156, 66}, {139, 34, 0}} ,{{126, 71}, {201, 39, 0}} ,{{111, 74}, {190, 42, 0}} ,{{115, 74}, {194, 42, 0}} ,{{113, 74}, {192, 42, 0}} ,{{64, 66}, {47, 34, 0}} ,{{163, 64}, {83, 32, 0}} ,{{200, 89}, {0, 168, 0}} ,{{228, 89}, {28, 168, 0}} ,{{227, 89}, {27, 168, 0}} ,{{213, 89}, {13, 168, 0}} ,{{212, 89}, {12, 168, 0}} ,{{219, 89}, {19, 168, 0}} ,{{218, 89}, {18, 168, 0}} ,{{223, 89}, {23, 168, 0}} ,{{222, 89}, {22, 168, 0}} ,{{204, 89}, {4, 168, 0}} ,{{210, 89}, {10, 168, 0}} ,{{209, 89}, {9, 168, 0}} ,{{234, 89}, {34, 168, 0}} ,{{201, 89}, {1, 168, 0}} ,{{215, 89}, {15, 168, 0}} ,{{214, 89}, {14, 168, 0}} ,{{208, 89}, {8, 168, 0}} ,{{207, 89}, {7, 168, 0}} ,{{231, 89}, {31, 168, 0}} ,{{229, 89}, {29, 168, 0}} ,{{224, 89}, {24, 168, 0}} ,{{205, 89}, {5, 168, 0}} ,{{226, 89}, {26, 168, 0}} ,{{225, 89}, {25, 168, 0}} ,{{230, 89}, {30, 168, 0}} ,{{232, 89}, {32, 168, 0}} ,{{233, 89}, {33, 168, 0}} ,{{221, 89}, {21, 168, 0}} ,{{220, 89}, {20, 168, 0}} ,{{217, 89}, {17, 168, 0}} ,{{216, 89}, {16, 168, 0}} ,{{203, 89}, {3, 168, 0}} ,{{240, 89}, {40, 168, 0}} ,{{241, 89}, {41, 168, 0}} ,{{242, 89}, {42, 168, 0}} ,{{243, 89}, {43, 168, 0}} ,{{211, 89}, {11, 168, 0}} ,{{202, 89}, {2, 168, 0}} ,{{206, 89}, {6, 168, 0}} ,{{235, 89}, {35, 168, 0}} ,{{238, 89}, {38, 168, 0}} ,{{236, 89}, {36, 168, 0}} ,{{239, 89}, {39, 168, 0}} ,{{237, 89}, {37, 168, 0}} ,{{0, 68}, {6, 36, 0}} ,{{2, 68}, {8, 36, 0}} ,{{1, 68}, {7, 36, 0}} ,{{18, 68}, {24, 36, 0}} ,{{7, 68}, {13, 36, 0}} ,{{10, 68}, {16, 36, 0}} ,{{27, 68}, {33, 36, 0}} ,{{31, 68}, {37, 36, 0}} ,{{14, 68}, {20, 36, 0}} ,{{11, 68}, {17, 36, 0}} ,{{13, 68}, {19, 36, 0}} ,{{12, 68}, {18, 36, 0}} ,{{19, 68}, {25, 36, 0}} ,{{253, 67}, {3, 36, 0}} ,{{254, 67}, {4, 36, 0}} ,{{17, 68}, {23, 36, 0}} ,{{255, 67}, {5, 36, 0}} ,{{21, 68}, {27, 36, 0}} ,{{22, 68}, {28, 36, 0}} ,{{6, 68}, {12, 36, 0}} ,{{23, 68}, {29, 36, 0}} ,{{3, 68}, {9, 36, 0}} ,{{4, 68}, {10, 36, 0}} ,{{15, 68}, {21, 36, 0}} ,{{30, 68}, {36, 36, 0}} ,{{250, 67}, {0, 36, 0}} ,{{24, 68}, {30, 36, 0}} ,{{102, 65}, {79, 33, 0}} ,{{9, 68}, {15, 36, 0}} ,{{8, 68}, {14, 36, 0}} ,{{26, 68}, {32, 36, 0}} ,{{251, 67}, {1, 36, 0}} ,{{252, 67}, {2, 36, 0}} ,{{20, 68}, {26, 36, 0}} ,{{32, 68}, {38, 36, 0}} ,{{16, 68}, {22, 36, 0}} ,{{25, 68}, {31, 36, 0}} ,{{5, 68}, {11, 36, 0}} ,{{64, 67}, {47, 35, 0}} ,{{115, 44}, {15, 7, 0}} ,{{174, 44}, {74, 7, 0}} ,{{107, 44}, {6, 7, 0}} ,{{108, 44}, {7, 7, 0}} ,{{111, 44}, {10, 7, 0}} ,{{157, 44}, {57, 7, 0}} ,{{156, 44}, {56, 7, 0}} ,{{101, 44}, {0, 7, 0}} ,{{161, 44}, {61, 7, 0}} ,{{162, 44}, {62, 7, 0}} ,{{164, 44}, {64, 7, 0}} ,{{114, 44}, {13, 7, 0}} ,{{113, 44}, {12, 7, 0}} ,{{112, 44}, {11, 7, 0}} ,{{160, 44}, {60, 7, 0}} ,{{158, 44}, {58, 7, 0}} ,{{159, 44}, {59, 7, 0}} ,{{106, 44}, {5, 7, 0}} ,{{116, 44}, {16, 7, 0}} ,{{118, 44}, {18, 7, 0}} ,{{121, 44}, {21, 7, 0}} ,{{122, 44}, {22, 7, 0}} ,{{137, 44}, {37, 7, 0}} ,{{136, 44}, {36, 7, 0}} ,{{119, 44}, {19, 7, 0}} ,{{120, 44}, {20, 7, 0}} ,{{123, 44}, {23, 7, 0}} ,{{126, 44}, {26, 7, 0}} ,{{131, 44}, {31, 7, 0}} ,{{132, 44}, {32, 7, 0}} ,{{133, 44}, {33, 7, 0}} ,{{134, 44}, {34, 7, 0}} ,{{138, 44}, {38, 7, 0}} ,{{145, 44}, {45, 7, 0}} ,{{147, 44}, {47, 7, 0}} ,{{146, 44}, {46, 7, 0}} ,{{141, 44}, {41, 7, 0}} ,{{139, 44}, {39, 7, 0}} ,{{142, 44}, {42, 7, 0}} ,{{140, 44}, {40, 7, 0}} ,{{135, 44}, {35, 7, 0}} ,{{143, 44}, {43, 7, 0}} ,{{177, 44}, {79, 7, 0}} ,{{176, 44}, {78, 7, 0}} ,{{175, 44}, {77, 7, 0}} ,{{117, 44}, {17, 7, 0}} ,{{144, 44}, {44, 7, 0}} ,{{127, 44}, {27, 7, 0}} ,{{128, 44}, {28, 7, 0}} ,{{124, 44}, {24, 7, 0}} ,{{129, 44}, {29, 7, 0}} ,{{130, 44}, {30, 7, 0}} ,{{125, 44}, {25, 7, 0}} ,{{173, 44}, {73, 7, 0}} ,{{171, 44}, {71, 7, 0}} ,{{172, 44}, {72, 7, 0}} ,{{148, 44}, {48, 7, 0}} ,{{149, 44}, {49, 7, 0}} ,{{150, 44}, {50, 7, 0}} ,{{165, 44}, {65, 7, 0}} ,{{154, 44}, {54, 7, 0}} ,{{155, 44}, {55, 7, 0}} ,{{166, 44}, {66, 7, 0}} ,{{163, 44}, {63, 7, 0}} ,{{105, 44}, {4, 7, 0}} ,{{110, 44}, {9, 7, 0}} ,{{103, 44}, {2, 7, 0}} ,{{104, 44}, {3, 7, 0}} ,{{109, 44}, {8, 7, 0}} ,{{102, 44}, {1, 7, 0}} ,{{169, 44}, {69, 7, 0}} ,{{170, 44}, {70, 7, 0}} ,{{167, 44}, {67, 7, 0}} ,{{168, 44}, {68, 7, 0}} ,{{151, 44}, {51, 7, 0}} ,{{152, 44}, {52, 7, 0}} ,{{153, 44}, {53, 7, 0}} ,{{125, 73}, {204, 41, 0}} ,{{22, 57}, {0, 23, 0}} ,{{32, 57}, {10, 23, 0}} ,{{29, 57}, {7, 23, 0}} ,{{26, 57}, {4, 23, 0}} ,{{38, 57}, {17, 23, 0}} ,{{23, 57}, {1, 23, 0}} ,{{25, 57}, {3, 23, 0}} ,{{35, 57}, {14, 23, 0}} ,{{33, 57}, {11, 23, 0}} ,{{30, 57}, {8, 23, 0}} ,{{27, 57}, {5, 23, 0}} ,{{31, 57}, {9, 23, 0}} ,{{37, 57}, {16, 23, 0}} ,{{28, 57}, {6, 23, 0}} ,{{24, 57}, {2, 23, 0}} ,{{36, 57}, {15, 23, 0}} ,{{34, 57}, {12, 23, 0}} ,{{41, 57}, {20, 23, 0}} ,{{39, 57}, {18, 23, 0}} ,{{40, 57}, {19, 23, 0}} ,{{85, 57}, {96, 23, 0}} ,{{95, 57}, {106, 23, 0}} ,{{92, 57}, {103, 23, 0}} ,{{89, 57}, {100, 23, 0}} ,{{86, 57}, {97, 23, 0}} ,{{88, 57}, {99, 23, 0}} ,{{98, 57}, {110, 23, 0}} ,{{96, 57}, {107, 23, 0}} ,{{93, 57}, {104, 23, 0}} ,{{90, 57}, {101, 23, 0}} ,{{94, 57}, {105, 23, 0}} ,{{100, 57}, {112, 23, 0}} ,{{91, 57}, {102, 23, 0}} ,{{87, 57}, {98, 23, 0}} ,{{99, 57}, {111, 23, 0}} ,{{97, 57}, {108, 23, 0}} ,{{101, 57}, {114, 23, 0}} ,{{102, 57}, {115, 23, 0}} ,{{43, 165}, {38, 0, 14}} ,{{44, 165}, {39, 0, 14}} ,{{47, 165}, {42, 0, 14}} ,{{99, 165}, {94, 0, 14}} ,{{63, 165}, {58, 0, 14}} ,{{49, 165}, {44, 0, 14}} ,{{69, 165}, {64, 0, 14}} ,{{61, 165}, {56, 0, 14}} ,{{58, 165}, {53, 0, 14}} ,{{57, 165}, {52, 0, 14}} ,{{62, 165}, {57, 0, 14}} ,{{54, 165}, {49, 0, 14}} ,{{60, 165}, {55, 0, 14}} ,{{59, 165}, {54, 0, 14}} ,{{56, 165}, {51, 0, 14}} ,{{55, 165}, {50, 0, 14}} ,{{53, 165}, {48, 0, 14}} ,{{41, 165}, {36, 0, 14}} ,{{66, 165}, {61, 0, 14}} ,{{38, 165}, {33, 0, 14}} ,{{51, 165}, {46, 0, 14}} ,{{101, 165}, {96, 0, 14}} ,{{67, 165}, {62, 0, 14}} ,{{50, 165}, {45, 0, 14}} ,{{70, 165}, {65, 0, 14}} ,{{71, 165}, {66, 0, 14}} ,{{72, 165}, {67, 0, 14}} ,{{73, 165}, {68, 0, 14}} ,{{74, 165}, {69, 0, 14}} ,{{75, 165}, {70, 0, 14}} ,{{76, 165}, {71, 0, 14}} ,{{77, 165}, {72, 0, 14}} ,{{78, 165}, {73, 0, 14}} ,{{79, 165}, {74, 0, 14}} ,{{80, 165}, {75, 0, 14}} ,{{81, 165}, {76, 0, 14}} ,{{82, 165}, {77, 0, 14}} ,{{83, 165}, {78, 0, 14}} ,{{84, 165}, {79, 0, 14}} ,{{85, 165}, {80, 0, 14}} ,{{86, 165}, {81, 0, 14}} ,{{87, 165}, {82, 0, 14}} ,{{88, 165}, {83, 0, 14}} ,{{89, 165}, {84, 0, 14}} ,{{90, 165}, {85, 0, 14}} ,{{91, 165}, {86, 0, 14}} ,{{92, 165}, {87, 0, 14}} ,{{93, 165}, {88, 0, 14}} ,{{94, 165}, {89, 0, 14}} ,{{95, 165}, {90, 0, 14}} ,{{102, 165}, {97, 0, 14}} ,{{103, 165}, {98, 0, 14}} ,{{104, 165}, {99, 0, 14}} ,{{105, 165}, {100, 0, 14}} ,{{106, 165}, {101, 0, 14}} ,{{107, 165}, {102, 0, 14}} ,{{108, 165}, {103, 0, 14}} ,{{109, 165}, {104, 0, 14}} ,{{110, 165}, {105, 0, 14}} ,{{111, 165}, {106, 0, 14}} ,{{112, 165}, {107, 0, 14}} ,{{113, 165}, {108, 0, 14}} ,{{114, 165}, {109, 0, 14}} ,{{115, 165}, {110, 0, 14}} ,{{116, 165}, {111, 0, 14}} ,{{117, 165}, {112, 0, 14}} ,{{118, 165}, {113, 0, 14}} ,{{119, 165}, {114, 0, 14}} ,{{120, 165}, {115, 0, 14}} ,{{121, 165}, {116, 0, 14}} ,{{122, 165}, {117, 0, 14}} ,{{123, 165}, {118, 0, 14}} ,{{124, 165}, {119, 0, 14}} ,{{125, 165}, {120, 0, 14}} ,{{126, 165}, {121, 0, 14}} ,{{127, 165}, {122, 0, 14}} ,{{128, 165}, {123, 0, 14}} ,{{45, 165}, {40, 0, 14}} ,{{96, 165}, {91, 0, 14}} ,{{65, 165}, {60, 0, 14}} ,{{100, 165}, {95, 0, 14}} ,{{40, 165}, {35, 0, 14}} ,{{42, 165}, {37, 0, 14}} ,{{48, 165}, {43, 0, 14}} ,{{68, 165}, {63, 0, 14}} ,{{39, 165}, {34, 0, 14}} ,{{97, 165}, {92, 0, 14}} ,{{130, 165}, {125, 0, 14}} ,{{46, 165}, {41, 0, 14}} ,{{98, 165}, {93, 0, 14}} ,{{64, 165}, {59, 0, 14}} ,{{52, 165}, {47, 0, 14}} ,{{37, 165}, {32, 0, 14}} ,{{131, 165}, {126, 0, 14}} ,{{129, 165}, {124, 0, 14}} ,{{16, 59}, {99, 25, 0}} ,{{26, 59}, {109, 25, 0}} ,{{25, 59}, {108, 25, 0}} ,{{24, 59}, {107, 25, 0}} ,{{18, 59}, {101, 25, 0}} ,{{19, 59}, {102, 25, 0}} ,{{9, 59}, {92, 25, 0}} ,{{11, 59}, {94, 25, 0}} ,{{17, 59}, {100, 25, 0}} ,{{253, 58}, {80, 25, 0}} ,{{13, 59}, {96, 25, 0}} ,{{5, 59}, {88, 25, 0}} ,{{8, 59}, {91, 25, 0}} ,{{15, 59}, {98, 25, 0}} ,{{255, 58}, {82, 25, 0}} ,{{22, 59}, {105, 25, 0}} ,{{21, 59}, {104, 25, 0}} ,{{6, 59}, {89, 25, 0}} ,{{7, 59}, {90, 25, 0}} ,{{12, 59}, {95, 25, 0}} ,{{1, 59}, {84, 25, 0}} ,{{3, 59}, {86, 25, 0}} ,{{4, 59}, {87, 25, 0}} ,{{27, 59}, {112, 25, 0}} ,{{28, 59}, {113, 25, 0}} ,{{29, 59}, {114, 25, 0}} ,{{30, 59}, {115, 25, 0}} ,{{31, 59}, {116, 25, 0}} ,{{0, 59}, {83, 25, 0}} ,{{14, 59}, {97, 25, 0}} ,{{20, 59}, {103, 25, 0}} ,{{23, 59}, {106, 25, 0}} ,{{10, 59}, {93, 25, 0}} ,{{254, 58}, {81, 25, 0}} ,{{2, 59}, {85, 25, 0}} ,{{13, 60}, {127, 26, 0}} ,{{238, 59}, {93, 26, 0}} ,{{234, 59}, {89, 26, 0}} ,{{236, 59}, {91, 26, 0}} ,{{232, 59}, {87, 26, 0}} ,{{235, 59}, {90, 26, 0}} ,{{237, 59}, {92, 26, 0}} ,{{231, 59}, {86, 26, 0}} ,{{230, 59}, {85, 26, 0}} ,{{239, 59}, {94, 26, 0}} ,{{22, 60}, {136, 26, 0}} ,{{19, 60}, {133, 26, 0}} ,{{18, 60}, {132, 26, 0}} ,{{23, 60}, {137, 26, 0}} ,{{15, 60}, {129, 26, 0}} ,{{21, 60}, {135, 26, 0}} ,{{20, 60}, {134, 26, 0}} ,{{17, 60}, {131, 26, 0}} ,{{16, 60}, {130, 26, 0}} ,{{14, 60}, {128, 26, 0}} ,{{220, 59}, {75, 26, 0}} ,{{200, 59}, {55, 26, 0}} ,{{192, 59}, {47, 26, 0}} ,{{226, 59}, {81, 26, 0}} ,{{229, 59}, {84, 26, 0}} ,{{184, 59}, {39, 26, 0}} ,{{185, 59}, {40, 26, 0}} ,{{203, 59}, {58, 26, 0}} ,{{218, 59}, {73, 26, 0}} ,{{177, 59}, {32, 26, 0}} ,{{178, 59}, {33, 26, 0}} ,{{179, 59}, {34, 26, 0}} ,{{201, 59}, {56, 26, 0}} ,{{202, 59}, {57, 26, 0}} ,{{191, 59}, {46, 26, 0}} ,{{217, 59}, {72, 26, 0}} ,{{215, 59}, {70, 26, 0}} ,{{216, 59}, {71, 26, 0}} ,{{195, 59}, {50, 26, 0}} ,{{196, 59}, {51, 26, 0}} ,{{209, 59}, {64, 26, 0}} ,{{222, 59}, {77, 26, 0}} ,{{223, 59}, {78, 26, 0}} ,{{212, 59}, {67, 26, 0}} ,{{228, 59}, {83, 26, 0}} ,{{219, 59}, {74, 26, 0}} ,{{186, 59}, {41, 26, 0}} ,{{188, 59}, {43, 26, 0}} ,{{205, 59}, {60, 26, 0}} ,{{221, 59}, {76, 26, 0}} ,{{180, 59}, {35, 26, 0}} ,{{182, 59}, {37, 26, 0}} ,{{181, 59}, {36, 26, 0}} ,{{204, 59}, {59, 26, 0}} ,{{206, 59}, {61, 26, 0}} ,{{193, 59}, {48, 26, 0}} ,{{187, 59}, {42, 26, 0}} ,{{197, 59}, {52, 26, 0}} ,{{198, 59}, {53, 26, 0}} ,{{208, 59}, {63, 26, 0}} ,{{213, 59}, {68, 26, 0}} ,{{207, 59}, {62, 26, 0}} ,{{199, 59}, {54, 26, 0}} ,{{183, 59}, {38, 26, 0}} ,{{189, 59}, {44, 26, 0}} ,{{227, 59}, {82, 26, 0}} ,{{210, 59}, {65, 26, 0}} ,{{194, 59}, {49, 26, 0}} ,{{190, 59}, {45, 26, 0}} ,{{211, 59}, {66, 26, 0}} ,{{224, 59}, {79, 26, 0}} ,{{225, 59}, {80, 26, 0}} ,{{214, 59}, {69, 26, 0}} ,{{47, 60}, {173, 26, 0}} ,{{39, 60}, {165, 26, 0}} ,{{46, 60}, {172, 26, 0}} ,{{38, 60}, {164, 26, 0}} ,{{42, 60}, {168, 26, 0}} ,{{43, 60}, {169, 26, 0}} ,{{37, 60}, {163, 26, 0}} ,{{12, 60}, {124, 26, 0}} ,{{7, 60}, {119, 26, 0}} ,{{8, 60}, {120, 26, 0}} ,{{9, 60}, {121, 26, 0}} ,{{4, 60}, {116, 26, 0}} ,{{233, 59}, {88, 26, 0}} ,{{11, 60}, {123, 26, 0}} ,{{41, 60}, {167, 26, 0}} ,{{10, 60}, {122, 26, 0}} ,{{40, 60}, {166, 26, 0}} ,{{240, 59}, {96, 26, 0}} ,{{44, 60}, {170, 26, 0}} ,{{45, 60}, {171, 26, 0}} ,{{36, 60}, {162, 26, 0}} ,{{5, 60}, {117, 26, 0}} ,{{6, 60}, {118, 26, 0}} ,{{34, 60}, {160, 26, 0}} ,{{35, 60}, {161, 26, 0}} ,{{32, 60}, {152, 26, 0}} ,{{29, 60}, {149, 26, 0}} ,{{28, 60}, {148, 26, 0}} ,{{33, 60}, {153, 26, 0}} ,{{25, 60}, {145, 26, 0}} ,{{31, 60}, {151, 26, 0}} ,{{30, 60}, {150, 26, 0}} ,{{27, 60}, {147, 26, 0}} ,{{26, 60}, {146, 26, 0}} ,{{24, 60}, {144, 26, 0}} ,{{241, 59}, {97, 26, 0}} ,{{243, 59}, {99, 26, 0}} ,{{255, 59}, {111, 26, 0}} ,{{1, 60}, {113, 26, 0}} ,{{254, 59}, {110, 26, 0}} ,{{245, 59}, {101, 26, 0}} ,{{246, 59}, {102, 26, 0}} ,{{242, 59}, {98, 26, 0}} ,{{251, 59}, {107, 26, 0}} ,{{3, 60}, {115, 26, 0}} ,{{252, 59}, {108, 26, 0}} ,{{0, 60}, {112, 26, 0}} ,{{253, 59}, {109, 26, 0}} ,{{244, 59}, {100, 26, 0}} ,{{2, 60}, {114, 26, 0}} ,{{249, 59}, {105, 26, 0}} ,{{247, 59}, {103, 26, 0}} ,{{250, 59}, {106, 26, 0}} ,{{248, 59}, {104, 26, 0}} ,{{250, 91}, {155, 170, 0}} ,{{236, 91}, {141, 170, 0}} ,{{234, 91}, {139, 170, 0}} ,{{242, 91}, {147, 170, 0}} ,{{0, 92}, {161, 170, 0}} ,{{230, 91}, {135, 170, 0}} ,{{12, 92}, {173, 170, 0}} ,{{228, 91}, {133, 170, 0}} ,{{226, 91}, {131, 170, 0}} ,{{224, 91}, {129, 170, 0}} ,{{8, 92}, {169, 170, 0}} ,{{2, 92}, {163, 170, 0}} ,{{232, 91}, {137, 170, 0}} ,{{248, 91}, {153, 170, 0}} ,{{240, 91}, {145, 170, 0}} ,{{14, 92}, {175, 170, 0}} ,{{254, 91}, {159, 170, 0}} ,{{252, 91}, {157, 170, 0}} ,{{6, 92}, {167, 170, 0}} ,{{238, 91}, {143, 170, 0}} ,{{246, 91}, {151, 170, 0}} ,{{244, 91}, {149, 170, 0}} ,{{10, 92}, {171, 170, 0}} ,{{4, 92}, {165, 170, 0}} ,{{249, 91}, {154, 170, 0}} ,{{235, 91}, {140, 170, 0}} ,{{233, 91}, {138, 170, 0}} ,{{241, 91}, {146, 170, 0}} ,{{255, 91}, {160, 170, 0}} ,{{229, 91}, {134, 170, 0}} ,{{11, 92}, {172, 170, 0}} ,{{227, 91}, {132, 170, 0}} ,{{225, 91}, {130, 170, 0}} ,{{223, 91}, {128, 170, 0}} ,{{7, 92}, {168, 170, 0}} ,{{1, 92}, {162, 170, 0}} ,{{231, 91}, {136, 170, 0}} ,{{247, 91}, {152, 170, 0}} ,{{239, 91}, {144, 170, 0}} ,{{13, 92}, {174, 170, 0}} ,{{253, 91}, {158, 170, 0}} ,{{251, 91}, {156, 170, 0}} ,{{5, 92}, {166, 170, 0}} ,{{237, 91}, {142, 170, 0}} ,{{245, 91}, {150, 170, 0}} ,{{243, 91}, {148, 170, 0}} ,{{9, 92}, {170, 170, 0}} ,{{3, 92}, {164, 170, 0}} ,{{15, 92}, {176, 170, 0}} ,{{22, 92}, {183, 170, 0}} ,{{37, 92}, {222, 170, 0}} ,{{38, 92}, {223, 170, 0}} ,{{34, 92}, {219, 170, 0}} ,{{35, 92}, {220, 170, 0}} ,{{36, 92}, {221, 170, 0}} ,{{30, 92}, {191, 170, 0}} ,{{31, 92}, {192, 170, 0}} ,{{33, 92}, {194, 170, 0}} ,{{32, 92}, {193, 170, 0}} ,{{16, 92}, {177, 170, 0}} ,{{29, 92}, {190, 170, 0}} ,{{28, 92}, {189, 170, 0}} ,{{26, 92}, {187, 170, 0}} ,{{27, 92}, {188, 170, 0}} ,{{20, 92}, {181, 170, 0}} ,{{17, 92}, {178, 170, 0}} ,{{23, 92}, {184, 170, 0}} ,{{21, 92}, {182, 170, 0}} ,{{19, 92}, {180, 170, 0}} ,{{25, 92}, {186, 170, 0}} ,{{18, 92}, {179, 170, 0}} ,{{24, 92}, {185, 170, 0}} ,{{152, 47}, {248, 11, 0}} ,{{133, 47}, {215, 11, 0}} ,{{151, 47}, {247, 11, 0}} ,{{147, 47}, {243, 11, 0}} ,{{150, 47}, {246, 11, 0}} ,{{142, 47}, {238, 11, 0}} ,{{139, 47}, {235, 11, 0}} ,{{138, 47}, {234, 11, 0}} ,{{143, 47}, {239, 11, 0}} ,{{135, 47}, {231, 11, 0}} ,{{141, 47}, {237, 11, 0}} ,{{140, 47}, {236, 11, 0}} ,{{137, 47}, {233, 11, 0}} ,{{136, 47}, {232, 11, 0}} ,{{134, 47}, {230, 11, 0}} ,{{85, 47}, {133, 11, 0}} ,{{86, 47}, {134, 11, 0}} ,{{93, 47}, {144, 11, 0}} ,{{96, 47}, {148, 11, 0}} ,{{99, 47}, {154, 11, 0}} ,{{91, 47}, {142, 11, 0}} ,{{92, 47}, {143, 11, 0}} ,{{119, 47}, {185, 11, 0}} ,{{87, 47}, {135, 11, 0}} ,{{88, 47}, {136, 11, 0}} ,{{100, 47}, {156, 11, 0}} ,{{97, 47}, {149, 11, 0}} ,{{112, 47}, {178, 11, 0}} ,{{113, 47}, {179, 11, 0}} ,{{114, 47}, {180, 11, 0}} ,{{108, 47}, {174, 11, 0}} ,{{105, 47}, {168, 11, 0}} ,{{98, 47}, {153, 11, 0}} ,{{103, 47}, {163, 11, 0}} ,{{106, 47}, {169, 11, 0}} ,{{101, 47}, {158, 11, 0}} ,{{94, 47}, {146, 11, 0}} ,{{95, 47}, {147, 11, 0}} ,{{107, 47}, {170, 11, 0}} ,{{110, 47}, {176, 11, 0}} ,{{111, 47}, {177, 11, 0}} ,{{118, 47}, {184, 11, 0}} ,{{116, 47}, {182, 11, 0}} ,{{117, 47}, {183, 11, 0}} ,{{104, 47}, {164, 11, 0}} ,{{102, 47}, {159, 11, 0}} ,{{89, 47}, {137, 11, 0}} ,{{90, 47}, {138, 11, 0}} ,{{115, 47}, {181, 11, 0}} ,{{109, 47}, {175, 11, 0}} ,{{148, 47}, {244, 11, 0}} ,{{145, 47}, {241, 11, 0}} ,{{146, 47}, {242, 11, 0}} ,{{154, 47}, {250, 11, 0}} ,{{144, 47}, {240, 11, 0}} ,{{132, 47}, {208, 11, 0}} ,{{153, 47}, {249, 11, 0}} ,{{83, 47}, {130, 11, 0}} ,{{131, 47}, {205, 11, 0}} ,{{84, 47}, {131, 11, 0}} ,{{120, 47}, {190, 11, 0}} ,{{127, 47}, {200, 11, 0}} ,{{130, 47}, {204, 11, 0}} ,{{125, 47}, {198, 11, 0}} ,{{126, 47}, {199, 11, 0}} ,{{121, 47}, {191, 11, 0}} ,{{122, 47}, {192, 11, 0}} ,{{128, 47}, {202, 11, 0}} ,{{129, 47}, {203, 11, 0}} ,{{123, 47}, {193, 11, 0}} ,{{124, 47}, {194, 11, 0}} ,{{149, 47}, {245, 11, 0}} ,{{203, 70}, {7, 39, 0}} ,{{21, 70}, {73, 38, 0}} ,{{112, 71}, {186, 39, 0}} ,{{252, 70}, {59, 39, 0}} ,{{202, 70}, {6, 39, 0}} ,{{38, 67}, {21, 35, 0}} ,{{56, 65}, {33, 33, 0}} ,{{223, 47}, {86, 12, 0}} ,{{238, 47}, {110, 12, 0}} ,{{235, 47}, {107, 12, 0}} ,{{234, 47}, {106, 12, 0}} ,{{239, 47}, {111, 12, 0}} ,{{231, 47}, {103, 12, 0}} ,{{237, 47}, {109, 12, 0}} ,{{236, 47}, {108, 12, 0}} ,{{233, 47}, {105, 12, 0}} ,{{232, 47}, {104, 12, 0}} ,{{230, 47}, {102, 12, 0}} ,{{244, 47}, {124, 12, 0}} ,{{241, 47}, {121, 12, 0}} ,{{246, 47}, {126, 12, 0}} ,{{243, 47}, {123, 12, 0}} ,{{245, 47}, {125, 12, 0}} ,{{242, 47}, {122, 12, 0}} ,{{240, 47}, {120, 12, 0}} ,{{222, 47}, {85, 12, 0}} ,{{158, 47}, {5, 12, 0}} ,{{159, 47}, {6, 12, 0}} ,{{168, 47}, {16, 12, 0}} ,{{171, 47}, {20, 12, 0}} ,{{194, 47}, {44, 12, 0}} ,{{195, 47}, {45, 12, 0}} ,{{177, 47}, {26, 12, 0}} ,{{178, 47}, {27, 12, 0}} ,{{189, 47}, {38, 12, 0}} ,{{184, 47}, {33, 12, 0}} ,{{185, 47}, {34, 12, 0}} ,{{190, 47}, {39, 12, 0}} ,{{225, 47}, {89, 12, 0}} ,{{166, 47}, {14, 12, 0}} ,{{167, 47}, {15, 12, 0}} ,{{174, 47}, {23, 12, 0}} ,{{175, 47}, {24, 12, 0}} ,{{206, 47}, {57, 12, 0}} ,{{160, 47}, {7, 12, 0}} ,{{161, 47}, {8, 12, 0}} ,{{179, 47}, {28, 12, 0}} ,{{180, 47}, {29, 12, 0}} ,{{172, 47}, {21, 12, 0}} ,{{173, 47}, {22, 12, 0}} ,{{200, 47}, {50, 12, 0}} ,{{201, 47}, {51, 12, 0}} ,{{196, 47}, {46, 12, 0}} ,{{191, 47}, {40, 12, 0}} ,{{176, 47}, {25, 12, 0}} ,{{186, 47}, {35, 12, 0}} ,{{181, 47}, {30, 12, 0}} ,{{169, 47}, {18, 12, 0}} ,{{170, 47}, {19, 12, 0}} ,{{192, 47}, {42, 12, 0}} ,{{193, 47}, {43, 12, 0}} ,{{198, 47}, {48, 12, 0}} ,{{199, 47}, {49, 12, 0}} ,{{205, 47}, {56, 12, 0}} ,{{203, 47}, {54, 12, 0}} ,{{204, 47}, {55, 12, 0}} ,{{187, 47}, {36, 12, 0}} ,{{188, 47}, {37, 12, 0}} ,{{224, 47}, {88, 12, 0}} ,{{182, 47}, {31, 12, 0}} ,{{183, 47}, {32, 12, 0}} ,{{162, 47}, {9, 12, 0}} ,{{163, 47}, {10, 12, 0}} ,{{202, 47}, {53, 12, 0}} ,{{165, 47}, {12, 12, 0}} ,{{227, 47}, {97, 12, 0}} ,{{164, 47}, {11, 12, 0}} ,{{226, 47}, {96, 12, 0}} ,{{197, 47}, {47, 12, 0}} ,{{156, 47}, {2, 12, 0}} ,{{207, 47}, {61, 12, 0}} ,{{155, 47}, {1, 12, 0}} ,{{247, 47}, {127, 12, 0}} ,{{221, 47}, {77, 12, 0}} ,{{157, 47}, {3, 12, 0}} ,{{208, 47}, {62, 12, 0}} ,{{217, 47}, {72, 12, 0}} ,{{220, 47}, {76, 12, 0}} ,{{215, 47}, {70, 12, 0}} ,{{216, 47}, {71, 12, 0}} ,{{209, 47}, {63, 12, 0}} ,{{210, 47}, {64, 12, 0}} ,{{218, 47}, {74, 12, 0}} ,{{219, 47}, {75, 12, 0}} ,{{211, 47}, {65, 12, 0}} ,{{212, 47}, {66, 12, 0}} ,{{228, 47}, {98, 12, 0}} ,{{229, 47}, {99, 12, 0}} ,{{213, 47}, {67, 12, 0}} ,{{214, 47}, {68, 12, 0}} ,{{245, 64}, {184, 32, 0}} ,{{192, 70}, {250, 38, 0}} ,{{255, 157}, {65, 211, 1}} ,{{215, 157}, {25, 211, 1}} ,{{15, 158}, {81, 211, 1}} ,{{202, 157}, {12, 211, 1}} ,{{199, 157}, {9, 211, 1}} ,{{225, 157}, {35, 211, 1}} ,{{204, 157}, {14, 211, 1}} ,{{196, 157}, {6, 211, 1}} ,{{223, 157}, {33, 211, 1}} ,{{251, 157}, {61, 211, 1}} ,{{228, 157}, {38, 211, 1}} ,{{13, 158}, {79, 211, 1}} ,{{12, 158}, {78, 211, 1}} ,{{16, 158}, {82, 211, 1}} ,{{246, 157}, {56, 211, 1}} ,{{211, 157}, {21, 211, 1}} ,{{220, 157}, {30, 211, 1}} ,{{201, 157}, {11, 211, 1}} ,{{6, 158}, {72, 211, 1}} ,{{224, 157}, {34, 211, 1}} ,{{205, 157}, {15, 211, 1}} ,{{5, 158}, {71, 211, 1}} ,{{18, 158}, {84, 211, 1}} ,{{250, 157}, {60, 211, 1}} ,{{7, 158}, {73, 211, 1}} ,{{206, 157}, {16, 211, 1}} ,{{1, 158}, {67, 211, 1}} ,{{222, 157}, {32, 211, 1}} ,{{218, 157}, {28, 211, 1}} ,{{0, 158}, {66, 211, 1}} ,{{238, 157}, {48, 211, 1}} ,{{221, 157}, {31, 211, 1}} ,{{241, 157}, {51, 211, 1}} ,{{248, 157}, {58, 211, 1}} ,{{8, 158}, {74, 211, 1}} ,{{14, 158}, {80, 211, 1}} ,{{244, 157}, {54, 211, 1}} ,{{214, 157}, {24, 211, 1}} ,{{20, 158}, {86, 211, 1}} ,{{233, 157}, {43, 211, 1}} ,{{197, 157}, {7, 211, 1}} ,{{230, 157}, {40, 211, 1}} ,{{253, 157}, {63, 211, 1}} ,{{237, 157}, {47, 211, 1}} ,{{240, 157}, {50, 211, 1}} ,{{252, 157}, {62, 211, 1}} ,{{11, 158}, {77, 211, 1}} ,{{212, 157}, {22, 211, 1}} ,{{208, 157}, {18, 211, 1}} ,{{4, 158}, {70, 211, 1}} ,{{219, 157}, {29, 211, 1}} ,{{200, 157}, {10, 211, 1}} ,{{229, 157}, {39, 211, 1}} ,{{19, 158}, {85, 211, 1}} ,{{235, 157}, {45, 211, 1}} ,{{227, 157}, {37, 211, 1}} ,{{254, 157}, {64, 211, 1}} ,{{247, 157}, {57, 211, 1}} ,{{198, 157}, {8, 211, 1}} ,{{17, 158}, {83, 211, 1}} ,{{203, 157}, {13, 211, 1}} ,{{226, 157}, {36, 211, 1}} ,{{242, 157}, {52, 211, 1}} ,{{209, 157}, {19, 211, 1}} ,{{232, 157}, {42, 211, 1}} ,{{210, 157}, {20, 211, 1}} ,{{216, 157}, {26, 211, 1}} ,{{234, 157}, {44, 211, 1}} ,{{217, 157}, {27, 211, 1}} ,{{236, 157}, {46, 211, 1}} ,{{243, 157}, {53, 211, 1}} ,{{9, 158}, {75, 211, 1}} ,{{3, 158}, {69, 211, 1}} ,{{10, 158}, {76, 211, 1}} ,{{239, 157}, {49, 211, 1}} ,{{231, 157}, {41, 211, 1}} ,{{249, 157}, {59, 211, 1}} ,{{245, 157}, {55, 211, 1}} ,{{213, 157}, {23, 211, 1}} ,{{2, 158}, {68, 211, 1}} ,{{207, 157}, {17, 211, 1}} ,{{9, 45}, {167, 7, 0}} ,{{8, 45}, {166, 7, 0}} ,{{14, 45}, {172, 7, 0}} ,{{11, 45}, {169, 7, 0}} ,{{15, 45}, {173, 7, 0}} ,{{10, 45}, {168, 7, 0}} ,{{4, 45}, {162, 7, 0}} ,{{233, 44}, {135, 7, 0}} ,{{230, 44}, {132, 7, 0}} ,{{249, 44}, {151, 7, 0}} ,{{1, 45}, {159, 7, 0}} ,{{243, 44}, {145, 7, 0}} ,{{237, 44}, {139, 7, 0}} ,{{236, 44}, {138, 7, 0}} ,{{240, 44}, {142, 7, 0}} ,{{5, 45}, {163, 7, 0}} ,{{241, 44}, {143, 7, 0}} ,{{226, 44}, {128, 7, 0}} ,{{251, 44}, {153, 7, 0}} ,{{248, 44}, {150, 7, 0}} ,{{232, 44}, {134, 7, 0}} ,{{252, 44}, {154, 7, 0}} ,{{239, 44}, {141, 7, 0}} ,{{231, 44}, {133, 7, 0}} ,{{235, 44}, {137, 7, 0}} ,{{19, 45}, {177, 7, 0}} ,{{228, 44}, {130, 7, 0}} ,{{247, 44}, {149, 7, 0}} ,{{6, 45}, {164, 7, 0}} ,{{229, 44}, {131, 7, 0}} ,{{0, 45}, {158, 7, 0}} ,{{242, 44}, {144, 7, 0}} ,{{227, 44}, {129, 7, 0}} ,{{255, 44}, {157, 7, 0}} ,{{245, 44}, {147, 7, 0}} ,{{238, 44}, {140, 7, 0}} ,{{253, 44}, {155, 7, 0}} ,{{2, 45}, {160, 7, 0}} ,{{250, 44}, {152, 7, 0}} ,{{234, 44}, {136, 7, 0}} ,{{7, 45}, {165, 7, 0}} ,{{246, 44}, {148, 7, 0}} ,{{254, 44}, {156, 7, 0}} ,{{244, 44}, {146, 7, 0}} ,{{3, 45}, {161, 7, 0}} ,{{17, 45}, {175, 7, 0}} ,{{16, 45}, {174, 7, 0}} ,{{13, 45}, {171, 7, 0}} ,{{18, 45}, {176, 7, 0}} ,{{12, 45}, {170, 7, 0}} ,{{82, 49}, {90, 14, 0}} ,{{22, 49}, {26, 14, 0}} ,{{4, 49}, {8, 14, 0}} ,{{6, 49}, {10, 14, 0}} ,{{5, 49}, {9, 14, 0}} ,{{8, 49}, {12, 14, 0}} ,{{10, 49}, {14, 14, 0}} ,{{16, 49}, {20, 14, 0}} ,{{71, 49}, {79, 14, 0}} ,{{25, 49}, {29, 14, 0}} ,{{27, 49}, {31, 14, 0}} ,{{39, 49}, {43, 14, 0}} ,{{42, 49}, {46, 14, 0}} ,{{83, 49}, {91, 14, 0}} ,{{254, 48}, {2, 14, 0}} ,{{1, 49}, {5, 14, 0}} ,{{255, 48}, {3, 14, 0}} ,{{0, 49}, {4, 14, 0}} ,{{2, 49}, {6, 14, 0}} ,{{253, 48}, {1, 14, 0}} ,{{61, 49}, {69, 14, 0}} ,{{40, 49}, {44, 14, 0}} ,{{33, 49}, {37, 14, 0}} ,{{34, 49}, {38, 14, 0}} ,{{63, 49}, {71, 14, 0}} ,{{62, 49}, {70, 14, 0}} ,{{67, 49}, {75, 14, 0}} ,{{64, 49}, {72, 14, 0}} ,{{45, 49}, {49, 14, 0}} ,{{65, 49}, {73, 14, 0}} ,{{66, 49}, {74, 14, 0}} ,{{29, 49}, {33, 14, 0}} ,{{3, 49}, {7, 14, 0}} ,{{69, 49}, {77, 14, 0}} ,{{15, 49}, {19, 14, 0}} ,{{21, 49}, {25, 14, 0}} ,{{41, 49}, {45, 14, 0}} ,{{43, 49}, {47, 14, 0}} ,{{54, 49}, {58, 14, 0}} ,{{26, 49}, {30, 14, 0}} ,{{24, 49}, {28, 14, 0}} ,{{28, 49}, {32, 14, 0}} ,{{23, 49}, {27, 14, 0}} ,{{31, 49}, {35, 14, 0}} ,{{32, 49}, {36, 14, 0}} ,{{44, 49}, {48, 14, 0}} ,{{46, 49}, {50, 14, 0}} ,{{57, 49}, {65, 14, 0}} ,{{60, 49}, {68, 14, 0}} ,{{59, 49}, {67, 14, 0}} ,{{47, 49}, {51, 14, 0}} ,{{56, 49}, {64, 14, 0}} ,{{48, 49}, {52, 14, 0}} ,{{49, 49}, {53, 14, 0}} ,{{58, 49}, {66, 14, 0}} ,{{52, 49}, {56, 14, 0}} ,{{50, 49}, {54, 14, 0}} ,{{51, 49}, {55, 14, 0}} ,{{53, 49}, {57, 14, 0}} ,{{37, 49}, {41, 14, 0}} ,{{36, 49}, {40, 14, 0}} ,{{7, 49}, {11, 14, 0}} ,{{38, 49}, {42, 14, 0}} ,{{68, 49}, {76, 14, 0}} ,{{13, 49}, {17, 14, 0}} ,{{14, 49}, {18, 14, 0}} ,{{19, 49}, {23, 14, 0}} ,{{12, 49}, {16, 14, 0}} ,{{20, 49}, {24, 14, 0}} ,{{18, 49}, {22, 14, 0}} ,{{11, 49}, {15, 14, 0}} ,{{17, 49}, {21, 14, 0}} ,{{35, 49}, {39, 14, 0}} ,{{70, 49}, {78, 14, 0}} ,{{30, 49}, {34, 14, 0}} ,{{9, 49}, {13, 14, 0}} ,{{55, 49}, {63, 14, 0}} ,{{80, 49}, {88, 14, 0}} ,{{77, 49}, {85, 14, 0}} ,{{76, 49}, {84, 14, 0}} ,{{81, 49}, {89, 14, 0}} ,{{73, 49}, {81, 14, 0}} ,{{79, 49}, {87, 14, 0}} ,{{78, 49}, {86, 14, 0}} ,{{75, 49}, {83, 14, 0}} ,{{74, 49}, {82, 14, 0}} ,{{72, 49}, {80, 14, 0}} ,{{69, 66}, {52, 34, 0}} ,{{21, 66}, {4, 34, 0}} ,{{20, 66}, {3, 34, 0}} ,{{152, 73}, {231, 41, 0}} ,{{89, 64}, {9, 32, 0}} ,{{90, 71}, {163, 39, 0}} ,{{89, 71}, {162, 39, 0}} ,{{84, 64}, {4, 32, 0}} ,{{39, 74}, {118, 42, 0}} ,{{117, 71}, {192, 39, 0}} ,{{166, 64}, {86, 32, 0}} ,{{226, 74}, {49, 43, 0}} ,{{107, 70}, {159, 38, 0}} ,{{106, 70}, {158, 38, 0}} ,{{7, 66}, {246, 33, 0}} ,{{212, 69}, {8, 38, 0}} ,{{148, 70}, {200, 38, 0}} ,{{173, 49}, {24, 15, 0}} ,{{174, 49}, {25, 15, 0}} ,{{172, 49}, {23, 15, 0}} ,{{76, 50}, {194, 15, 0}} ,{{74, 50}, {192, 15, 0}} ,{{75, 50}, {193, 15, 0}} ,{{77, 50}, {195, 15, 0}} ,{{189, 49}, {40, 15, 0}} ,{{186, 49}, {37, 15, 0}} ,{{185, 49}, {36, 15, 0}} ,{{198, 49}, {49, 15, 0}} ,{{195, 49}, {46, 15, 0}} ,{{194, 49}, {45, 15, 0}} ,{{199, 49}, {50, 15, 0}} ,{{191, 49}, {42, 15, 0}} ,{{197, 49}, {48, 15, 0}} ,{{196, 49}, {47, 15, 0}} ,{{193, 49}, {44, 15, 0}} ,{{192, 49}, {43, 15, 0}} ,{{200, 49}, {51, 15, 0}} ,{{190, 49}, {41, 15, 0}} ,{{182, 49}, {33, 15, 0}} ,{{188, 49}, {39, 15, 0}} ,{{187, 49}, {38, 15, 0}} ,{{184, 49}, {35, 15, 0}} ,{{183, 49}, {34, 15, 0}} ,{{181, 49}, {32, 15, 0}} ,{{72, 50}, {190, 15, 0}} ,{{73, 50}, {191, 15, 0}} ,{{244, 49}, {96, 15, 0}} ,{{252, 49}, {104, 15, 0}} ,{{234, 49}, {86, 15, 0}} ,{{235, 49}, {87, 15, 0}} ,{{218, 49}, {69, 15, 0}} ,{{219, 49}, {70, 15, 0}} ,{{229, 49}, {81, 15, 0}} ,{{224, 49}, {76, 15, 0}} ,{{225, 49}, {77, 15, 0}} ,{{230, 49}, {82, 15, 0}} ,{{239, 49}, {91, 15, 0}} ,{{240, 49}, {92, 15, 0}} ,{{254, 49}, {106, 15, 0}} ,{{215, 49}, {66, 15, 0}} ,{{216, 49}, {67, 15, 0}} ,{{251, 49}, {103, 15, 0}} ,{{220, 49}, {71, 15, 0}} ,{{213, 49}, {64, 15, 0}} ,{{214, 49}, {65, 15, 0}} ,{{255, 49}, {107, 15, 0}} ,{{253, 49}, {105, 15, 0}} ,{{247, 49}, {99, 15, 0}} ,{{236, 49}, {88, 15, 0}} ,{{231, 49}, {83, 15, 0}} ,{{217, 49}, {68, 15, 0}} ,{{226, 49}, {78, 15, 0}} ,{{221, 49}, {73, 15, 0}} ,{{232, 49}, {84, 15, 0}} ,{{233, 49}, {85, 15, 0}} ,{{246, 49}, {98, 15, 0}} ,{{0, 50}, {108, 15, 0}} ,{{250, 49}, {102, 15, 0}} ,{{248, 49}, {100, 15, 0}} ,{{249, 49}, {101, 15, 0}} ,{{227, 49}, {79, 15, 0}} ,{{228, 49}, {80, 15, 0}} ,{{237, 49}, {89, 15, 0}} ,{{238, 49}, {90, 15, 0}} ,{{222, 49}, {74, 15, 0}} ,{{223, 49}, {75, 15, 0}} ,{{241, 49}, {93, 15, 0}} ,{{245, 49}, {97, 15, 0}} ,{{243, 49}, {95, 15, 0}} ,{{242, 49}, {94, 15, 0}} ,{{170, 49}, {21, 15, 0}} ,{{171, 49}, {22, 15, 0}} ,{{210, 49}, {61, 15, 0}} ,{{209, 49}, {60, 15, 0}} ,{{159, 49}, {10, 15, 0}} ,{{201, 49}, {52, 15, 0}} ,{{89, 50}, {208, 15, 0}} ,{{158, 49}, {9, 15, 0}} ,{{203, 49}, {54, 15, 0}} ,{{168, 49}, {19, 15, 0}} ,{{155, 49}, {6, 15, 0}} ,{{205, 49}, {56, 15, 0}} ,{{93, 50}, {212, 15, 0}} ,{{154, 49}, {5, 15, 0}} ,{{161, 49}, {12, 15, 0}} ,{{169, 49}, {20, 15, 0}} ,{{152, 49}, {3, 15, 0}} ,{{151, 49}, {2, 15, 0}} ,{{150, 49}, {1, 15, 0}} ,{{208, 49}, {59, 15, 0}} ,{{207, 49}, {58, 15, 0}} ,{{20, 50}, {132, 15, 0}} ,{{92, 50}, {211, 15, 0}} ,{{153, 49}, {4, 15, 0}} ,{{160, 49}, {11, 15, 0}} ,{{90, 50}, {209, 15, 0}} ,{{202, 49}, {53, 15, 0}} ,{{204, 49}, {55, 15, 0}} ,{{163, 49}, {14, 15, 0}} ,{{91, 50}, {210, 15, 0}} ,{{165, 49}, {16, 15, 0}} ,{{21, 50}, {133, 15, 0}} ,{{167, 49}, {18, 15, 0}} ,{{166, 49}, {17, 15, 0}} ,{{157, 49}, {8, 15, 0}} ,{{162, 49}, {13, 15, 0}} ,{{206, 49}, {57, 15, 0}} ,{{164, 49}, {15, 15, 0}} ,{{156, 49}, {7, 15, 0}} ,{{26, 50}, {138, 15, 0}} ,{{27, 50}, {139, 15, 0}} ,{{24, 50}, {136, 15, 0}} ,{{22, 50}, {134, 15, 0}} ,{{212, 49}, {63, 15, 0}} ,{{25, 50}, {137, 15, 0}} ,{{18, 50}, {130, 15, 0}} ,{{175, 49}, {26, 15, 0}} ,{{176, 49}, {27, 15, 0}} ,{{177, 49}, {28, 15, 0}} ,{{180, 49}, {31, 15, 0}} ,{{178, 49}, {29, 15, 0}} ,{{179, 49}, {30, 15, 0}} ,{{88, 50}, {207, 15, 0}} ,{{87, 50}, {206, 15, 0}} ,{{14, 50}, {126, 15, 0}} ,{{15, 50}, {127, 15, 0}} ,{{19, 50}, {131, 15, 0}} ,{{23, 50}, {135, 15, 0}} ,{{211, 49}, {62, 15, 0}} ,{{59, 50}, {176, 15, 0}} ,{{67, 50}, {184, 15, 0}} ,{{49, 50}, {166, 15, 0}} ,{{50, 50}, {167, 15, 0}} ,{{33, 50}, {149, 15, 0}} ,{{34, 50}, {150, 15, 0}} ,{{44, 50}, {161, 15, 0}} ,{{39, 50}, {156, 15, 0}} ,{{40, 50}, {157, 15, 0}} ,{{45, 50}, {162, 15, 0}} ,{{54, 50}, {171, 15, 0}} ,{{55, 50}, {172, 15, 0}} ,{{71, 50}, {188, 15, 0}} ,{{69, 50}, {186, 15, 0}} ,{{70, 50}, {187, 15, 0}} ,{{30, 50}, {146, 15, 0}} ,{{31, 50}, {147, 15, 0}} ,{{66, 50}, {183, 15, 0}} ,{{35, 50}, {151, 15, 0}} ,{{28, 50}, {144, 15, 0}} ,{{29, 50}, {145, 15, 0}} ,{{68, 50}, {185, 15, 0}} ,{{62, 50}, {179, 15, 0}} ,{{51, 50}, {168, 15, 0}} ,{{46, 50}, {163, 15, 0}} ,{{32, 50}, {148, 15, 0}} ,{{41, 50}, {158, 15, 0}} ,{{36, 50}, {153, 15, 0}} ,{{47, 50}, {164, 15, 0}} ,{{48, 50}, {165, 15, 0}} ,{{61, 50}, {178, 15, 0}} ,{{65, 50}, {182, 15, 0}} ,{{63, 50}, {180, 15, 0}} ,{{64, 50}, {181, 15, 0}} ,{{42, 50}, {159, 15, 0}} ,{{43, 50}, {160, 15, 0}} ,{{52, 50}, {169, 15, 0}} ,{{53, 50}, {170, 15, 0}} ,{{37, 50}, {154, 15, 0}} ,{{38, 50}, {155, 15, 0}} ,{{56, 50}, {173, 15, 0}} ,{{60, 50}, {177, 15, 0}} ,{{58, 50}, {175, 15, 0}} ,{{57, 50}, {174, 15, 0}} ,{{149, 49}, {0, 15, 0}} ,{{78, 50}, {196, 15, 0}} ,{{83, 50}, {201, 15, 0}} ,{{86, 50}, {204, 15, 0}} ,{{85, 50}, {203, 15, 0}} ,{{84, 50}, {202, 15, 0}} ,{{80, 50}, {198, 15, 0}} ,{{82, 50}, {200, 15, 0}} ,{{79, 50}, {197, 15, 0}} ,{{81, 50}, {199, 15, 0}} ,{{1, 50}, {113, 15, 0}} ,{{10, 50}, {122, 15, 0}} ,{{11, 50}, {123, 15, 0}} ,{{2, 50}, {114, 15, 0}} ,{{3, 50}, {115, 15, 0}} ,{{12, 50}, {124, 15, 0}} ,{{13, 50}, {125, 15, 0}} ,{{16, 50}, {128, 15, 0}} ,{{17, 50}, {129, 15, 0}} ,{{4, 50}, {116, 15, 0}} ,{{5, 50}, {117, 15, 0}} ,{{8, 50}, {120, 15, 0}} ,{{9, 50}, {121, 15, 0}} ,{{6, 50}, {118, 15, 0}} ,{{7, 50}, {119, 15, 0}} ,{{142, 73}, {221, 41, 0}} ,{{64, 76}, {75, 45, 0}} ,{{77, 76}, {88, 45, 0}} ,{{54, 76}, {65, 45, 0}} ,{{42, 76}, {53, 45, 0}} ,{{89, 76}, {100, 45, 0}} ,{{76, 76}, {87, 45, 0}} ,{{69, 76}, {80, 45, 0}} ,{{55, 76}, {66, 45, 0}} ,{{51, 76}, {62, 45, 0}} ,{{59, 76}, {70, 45, 0}} ,{{70, 76}, {81, 45, 0}} ,{{61, 76}, {72, 45, 0}} ,{{65, 76}, {76, 45, 0}} ,{{37, 76}, {48, 45, 0}} ,{{57, 76}, {68, 45, 0}} ,{{38, 76}, {49, 45, 0}} ,{{39, 76}, {50, 45, 0}} ,{{83, 76}, {94, 45, 0}} ,{{44, 76}, {55, 45, 0}} ,{{46, 76}, {57, 45, 0}} ,{{47, 76}, {58, 45, 0}} ,{{45, 76}, {56, 45, 0}} ,{{49, 76}, {60, 45, 0}} ,{{40, 76}, {51, 45, 0}} ,{{75, 76}, {86, 45, 0}} ,{{41, 76}, {52, 45, 0}} ,{{53, 76}, {64, 45, 0}} ,{{56, 76}, {67, 45, 0}} ,{{43, 76}, {54, 45, 0}} ,{{50, 76}, {61, 45, 0}} ,{{58, 76}, {69, 45, 0}} ,{{52, 76}, {63, 45, 0}} ,{{66, 76}, {77, 45, 0}} ,{{67, 76}, {78, 45, 0}} ,{{68, 76}, {79, 45, 0}} ,{{71, 76}, {82, 45, 0}} ,{{60, 76}, {71, 45, 0}} ,{{73, 76}, {84, 45, 0}} ,{{74, 76}, {85, 45, 0}} ,{{78, 76}, {89, 45, 0}} ,{{80, 76}, {91, 45, 0}} ,{{79, 76}, {90, 45, 0}} ,{{81, 76}, {92, 45, 0}} ,{{82, 76}, {93, 45, 0}} ,{{84, 76}, {95, 45, 0}} ,{{85, 76}, {96, 45, 0}} ,{{86, 76}, {97, 45, 0}} ,{{87, 76}, {98, 45, 0}} ,{{88, 76}, {99, 45, 0}} ,{{63, 76}, {74, 45, 0}} ,{{90, 76}, {101, 45, 0}} ,{{48, 76}, {59, 45, 0}} ,{{62, 76}, {73, 45, 0}} ,{{72, 76}, {83, 45, 0}} ,{{91, 76}, {111, 45, 0}} ,{{6, 71}, {69, 39, 0}} ,{{65, 38}, {126, 0, 0}} ,{{77, 66}, {60, 34, 0}} ,{{250, 74}, {73, 43, 0}} ,{{35, 73}, {114, 41, 0}} ,{{27, 74}, {106, 42, 0}} ,{{28, 74}, {107, 42, 0}} ,{{233, 76}, {30, 46, 0}} ,{{234, 76}, {31, 46, 0}} ,{{230, 76}, {27, 46, 0}} ,{{133, 73}, {212, 41, 0}} ,{{134, 73}, {213, 41, 0}} ,{{175, 73}, {254, 41, 0}} ,{{184, 146}, {58, 11, 1}} ,{{154, 64}, {74, 32, 0}} ,{{235, 72}, {58, 41, 0}} ,{{238, 72}, {61, 41, 0}} ,{{237, 72}, {60, 41, 0}} ,{{239, 67}, {222, 35, 0}} ,{{49, 67}, {32, 35, 0}} ,{{45, 67}, {28, 35, 0}} ,{{32, 67}, {15, 35, 0}} ,{{237, 76}, {34, 46, 0}} ,{{237, 67}, {220, 35, 0}} ,{{46, 67}, {29, 35, 0}} ,{{31, 67}, {14, 35, 0}} ,{{238, 76}, {35, 46, 0}} ,{{197, 67}, {180, 35, 0}} ,{{241, 67}, {224, 35, 0}} ,{{254, 162}, {65, 242, 1}} ,{{255, 162}, {66, 242, 1}} ,{{4, 163}, {71, 242, 1}} ,{{0, 163}, {67, 242, 1}} ,{{2, 163}, {69, 242, 1}} ,{{5, 163}, {72, 242, 1}} ,{{253, 162}, {64, 242, 1}} ,{{1, 163}, {68, 242, 1}} ,{{3, 163}, {70, 242, 1}} ,{{192, 162}, {42, 241, 1}} ,{{65, 67}, {48, 35, 0}} ,{{57, 65}, {34, 33, 0}} ,{{140, 74}, {219, 42, 0}} ,{{84, 71}, {157, 39, 0}} ,{{123, 73}, {202, 41, 0}} ,{{126, 73}, {205, 41, 0}} ,{{124, 73}, {203, 41, 0}} ,{{115, 64}, {35, 32, 0}} ,{{173, 64}, {93, 32, 0}} ,{{3, 70}, {55, 38, 0}} ,{{254, 69}, {50, 38, 0}} ,{{252, 69}, {48, 38, 0}} ,{{253, 69}, {49, 38, 0}} ,{{2, 70}, {54, 38, 0}} ,{{255, 69}, {51, 38, 0}} ,{{1, 70}, {53, 38, 0}} ,{{0, 70}, {52, 38, 0}} ,{{167, 74}, {246, 42, 0}} ,{{25, 74}, {104, 42, 0}} ,{{26, 74}, {105, 42, 0}} ,{{62, 66}, {45, 34, 0}} ,{{169, 74}, {248, 42, 0}} ,{{168, 74}, {247, 42, 0}} ,{{172, 73}, {251, 41, 0}} ,{{132, 64}, {52, 32, 0}} ,{{172, 74}, {251, 42, 0}} ,{{92, 66}, {75, 34, 0}} ,{{165, 74}, {244, 42, 0}} ,{{49, 73}, {128, 41, 0}} ,{{187, 66}, {170, 34, 0}} ,{{166, 74}, {245, 42, 0}} ,{{185, 66}, {168, 34, 0}} ,{{235, 64}, {174, 32, 0}} ,{{98, 65}, {75, 33, 0}} ,{{83, 73}, {162, 41, 0}} ,{{150, 70}, {202, 38, 0}} ,{{73, 65}, {50, 33, 0}} ,{{64, 65}, {41, 33, 0}} ,{{42, 67}, {25, 35, 0}} ,{{88, 65}, {65, 33, 0}} ,{{89, 65}, {66, 33, 0}} ,{{91, 65}, {68, 33, 0}} ,{{101, 65}, {78, 33, 0}} ,{{149, 70}, {201, 38, 0}} ,{{250, 70}, {57, 39, 0}} ,{{161, 64}, {81, 32, 0}} ,{{38, 74}, {117, 42, 0}} ,{{245, 76}, {42, 46, 0}} ,{{117, 64}, {37, 32, 0}} ,{{170, 64}, {90, 32, 0}} ,{{6, 74}, {85, 42, 0}} ,{{7, 74}, {86, 42, 0}} ,{{122, 73}, {201, 41, 0}} ,{{184, 73}, {7, 42, 0}} ,{{185, 73}, {8, 42, 0}} ,{{172, 144}, {147, 3, 1}} ,{{153, 144}, {128, 3, 1}} ,{{154, 144}, {129, 3, 1}} ,{{157, 144}, {132, 3, 1}} ,{{168, 144}, {143, 3, 1}} ,{{155, 144}, {130, 3, 1}} ,{{178, 144}, {153, 3, 1}} ,{{158, 144}, {133, 3, 1}} ,{{161, 144}, {136, 3, 1}} ,{{180, 144}, {155, 3, 1}} ,{{164, 144}, {139, 3, 1}} ,{{156, 144}, {131, 3, 1}} ,{{166, 144}, {141, 3, 1}} ,{{167, 144}, {142, 3, 1}} ,{{169, 144}, {144, 3, 1}} ,{{173, 144}, {148, 3, 1}} ,{{175, 144}, {150, 3, 1}} ,{{176, 144}, {151, 3, 1}} ,{{174, 144}, {149, 3, 1}} ,{{171, 144}, {146, 3, 1}} ,{{165, 144}, {140, 3, 1}} ,{{182, 144}, {157, 3, 1}} ,{{162, 144}, {137, 3, 1}} ,{{177, 144}, {152, 3, 1}} ,{{179, 144}, {154, 3, 1}} ,{{181, 144}, {156, 3, 1}} ,{{159, 144}, {134, 3, 1}} ,{{163, 144}, {138, 3, 1}} ,{{160, 144}, {135, 3, 1}} ,{{170, 144}, {145, 3, 1}} ,{{183, 144}, {159, 3, 1}} ,{{206, 69}, {2, 38, 0}} ,{{183, 70}, {241, 38, 0}} ,{{224, 69}, {20, 38, 0}} ,{{143, 64}, {63, 32, 0}} ,{{157, 67}, {140, 35, 0}} ,{{59, 66}, {42, 34, 0}} ,{{249, 73}, {72, 42, 0}} ,{{247, 73}, {70, 42, 0}} ,{{251, 73}, {74, 42, 0}} ,{{246, 73}, {69, 42, 0}} ,{{242, 73}, {65, 42, 0}} ,{{243, 73}, {66, 42, 0}} ,{{62, 70}, {114, 38, 0}} ,{{123, 70}, {175, 38, 0}} ,{{185, 69}, {237, 37, 0}} ,{{186, 69}, {238, 37, 0}} ,{{198, 70}, {1, 39, 0}} ,{{76, 69}, {128, 37, 0}} ,{{172, 69}, {224, 37, 0}} ,{{166, 69}, {218, 37, 0}} ,{{133, 71}, {212, 39, 0}} ,{{193, 67}, {176, 35, 0}} ,{{168, 69}, {220, 37, 0}} ,{{196, 69}, {248, 37, 0}} ,{{96, 69}, {148, 37, 0}} ,{{15, 71}, {80, 39, 0}} ,{{194, 67}, {177, 35, 0}} ,{{210, 70}, {16, 39, 0}} ,{{169, 69}, {221, 37, 0}} ,{{17, 71}, {82, 39, 0}} ,{{197, 69}, {249, 37, 0}} ,{{224, 76}, {21, 46, 0}} ,{{162, 65}, {145, 33, 0}} ,{{182, 65}, {165, 33, 0}} ,{{214, 65}, {197, 33, 0}} ,{{195, 72}, {18, 41, 0}} ,{{239, 65}, {222, 33, 0}} ,{{186, 72}, {9, 41, 0}} ,{{193, 65}, {176, 33, 0}} ,{{194, 65}, {177, 33, 0}} ,{{183, 74}, {6, 43, 0}} ,{{242, 65}, {225, 33, 0}} ,{{226, 65}, {209, 33, 0}} ,{{208, 65}, {191, 33, 0}} ,{{31, 73}, {110, 41, 0}} ,{{20, 73}, {99, 41, 0}} ,{{17, 73}, {96, 41, 0}} ,{{9, 73}, {88, 41, 0}} ,{{207, 65}, {190, 33, 0}} ,{{13, 73}, {92, 41, 0}} ,{{5, 73}, {84, 41, 0}} ,{{217, 65}, {200, 33, 0}} ,{{161, 71}, {240, 39, 0}} ,{{187, 72}, {10, 41, 0}} ,{{250, 72}, {73, 41, 0}} ,{{176, 65}, {159, 33, 0}} ,{{248, 65}, {231, 33, 0}} ,{{251, 65}, {234, 33, 0}} ,{{252, 65}, {235, 33, 0}} ,{{253, 65}, {236, 33, 0}} ,{{254, 65}, {237, 33, 0}} ,{{255, 65}, {238, 33, 0}} ,{{0, 66}, {239, 33, 0}} ,{{20, 67}, {3, 35, 0}} ,{{53, 67}, {36, 35, 0}} ,{{110, 73}, {189, 41, 0}} ,{{2, 73}, {81, 41, 0}} ,{{254, 72}, {77, 41, 0}} ,{{253, 72}, {76, 41, 0}} ,{{0, 73}, {79, 41, 0}} ,{{166, 65}, {149, 33, 0}} ,{{185, 65}, {168, 33, 0}} ,{{190, 74}, {13, 43, 0}} ,{{230, 65}, {213, 33, 0}} ,{{4, 66}, {243, 33, 0}} ,{{47, 73}, {126, 41, 0}} ,{{1, 67}, {240, 34, 0}} ,{{182, 66}, {165, 34, 0}} ,{{144, 71}, {223, 39, 0}} ,{{17, 70}, {69, 38, 0}} ,{{113, 88}, {13, 166, 0}} ,{{140, 88}, {40, 166, 0}} ,{{137, 88}, {37, 166, 0}} ,{{136, 88}, {36, 166, 0}} ,{{141, 88}, {41, 166, 0}} ,{{133, 88}, {33, 166, 0}} ,{{139, 88}, {39, 166, 0}} ,{{138, 88}, {38, 166, 0}} ,{{135, 88}, {35, 166, 0}} ,{{134, 88}, {34, 166, 0}} ,{{132, 88}, {32, 166, 0}} ,{{114, 88}, {14, 166, 0}} ,{{115, 88}, {15, 166, 0}} ,{{173, 87}, {73, 165, 0}} ,{{174, 87}, {74, 165, 0}} ,{{182, 87}, {82, 165, 0}} ,{{78, 88}, {234, 165, 0}} ,{{107, 87}, {7, 165, 0}} ,{{181, 87}, {81, 165, 0}} ,{{77, 88}, {233, 165, 0}} ,{{106, 87}, {6, 165, 0}} ,{{143, 87}, {43, 165, 0}} ,{{38, 88}, {194, 165, 0}} ,{{219, 87}, {119, 165, 0}} ,{{0, 88}, {156, 165, 0}} ,{{144, 87}, {44, 165, 0}} ,{{39, 88}, {195, 165, 0}} ,{{220, 87}, {120, 165, 0}} ,{{1, 88}, {157, 165, 0}} ,{{202, 87}, {102, 165, 0}} ,{{99, 88}, {255, 165, 0}} ,{{126, 87}, {26, 165, 0}} ,{{163, 87}, {63, 165, 0}} ,{{59, 88}, {215, 165, 0}} ,{{239, 87}, {139, 165, 0}} ,{{20, 88}, {176, 165, 0}} ,{{196, 87}, {96, 165, 0}} ,{{93, 88}, {249, 165, 0}} ,{{120, 87}, {20, 165, 0}} ,{{192, 87}, {92, 165, 0}} ,{{89, 88}, {245, 165, 0}} ,{{116, 87}, {16, 165, 0}} ,{{193, 87}, {93, 165, 0}} ,{{90, 88}, {246, 165, 0}} ,{{117, 87}, {17, 165, 0}} ,{{154, 87}, {54, 165, 0}} ,{{50, 88}, {206, 165, 0}} ,{{230, 87}, {130, 165, 0}} ,{{11, 88}, {167, 165, 0}} ,{{153, 87}, {53, 165, 0}} ,{{49, 88}, {205, 165, 0}} ,{{229, 87}, {129, 165, 0}} ,{{10, 88}, {166, 165, 0}} ,{{157, 87}, {57, 165, 0}} ,{{53, 88}, {209, 165, 0}} ,{{233, 87}, {133, 165, 0}} ,{{14, 88}, {170, 165, 0}} ,{{69, 88}, {225, 165, 0}} ,{{100, 87}, {0, 165, 0}} ,{{101, 87}, {1, 165, 0}} ,{{70, 88}, {226, 165, 0}} ,{{188, 87}, {88, 165, 0}} ,{{85, 88}, {241, 165, 0}} ,{{112, 87}, {12, 165, 0}} ,{{149, 87}, {49, 165, 0}} ,{{45, 88}, {201, 165, 0}} ,{{225, 87}, {125, 165, 0}} ,{{6, 88}, {162, 165, 0}} ,{{209, 87}, {109, 165, 0}} ,{{187, 87}, {87, 165, 0}} ,{{83, 88}, {239, 165, 0}} ,{{111, 87}, {11, 165, 0}} ,{{84, 88}, {240, 165, 0}} ,{{148, 87}, {48, 165, 0}} ,{{43, 88}, {199, 165, 0}} ,{{44, 88}, {200, 165, 0}} ,{{224, 87}, {124, 165, 0}} ,{{5, 88}, {161, 165, 0}} ,{{106, 88}, {6, 166, 0}} ,{{132, 87}, {32, 165, 0}} ,{{107, 88}, {7, 166, 0}} ,{{169, 87}, {69, 165, 0}} ,{{65, 88}, {221, 165, 0}} ,{{245, 87}, {145, 165, 0}} ,{{26, 88}, {182, 165, 0}} ,{{176, 87}, {76, 165, 0}} ,{{177, 87}, {77, 165, 0}} ,{{72, 88}, {228, 165, 0}} ,{{102, 87}, {2, 165, 0}} ,{{73, 88}, {229, 165, 0}} ,{{138, 87}, {38, 165, 0}} ,{{139, 87}, {39, 165, 0}} ,{{33, 88}, {189, 165, 0}} ,{{34, 88}, {190, 165, 0}} ,{{215, 87}, {115, 165, 0}} ,{{251, 87}, {151, 165, 0}} ,{{252, 87}, {152, 165, 0}} ,{{136, 87}, {36, 165, 0}} ,{{137, 87}, {37, 165, 0}} ,{{203, 87}, {103, 165, 0}} ,{{100, 88}, {0, 166, 0}} ,{{127, 87}, {27, 165, 0}} ,{{164, 87}, {64, 165, 0}} ,{{60, 88}, {216, 165, 0}} ,{{240, 87}, {140, 165, 0}} ,{{21, 88}, {177, 165, 0}} ,{{206, 87}, {106, 165, 0}} ,{{207, 87}, {107, 165, 0}} ,{{103, 88}, {3, 166, 0}} ,{{130, 87}, {30, 165, 0}} ,{{167, 87}, {67, 165, 0}} ,{{63, 88}, {219, 165, 0}} ,{{243, 87}, {143, 165, 0}} ,{{184, 87}, {84, 165, 0}} ,{{185, 87}, {85, 165, 0}} ,{{80, 88}, {236, 165, 0}} ,{{109, 87}, {9, 165, 0}} ,{{81, 88}, {237, 165, 0}} ,{{146, 87}, {46, 165, 0}} ,{{41, 88}, {197, 165, 0}} ,{{222, 87}, {122, 165, 0}} ,{{3, 88}, {159, 165, 0}} ,{{24, 88}, {180, 165, 0}} ,{{194, 87}, {94, 165, 0}} ,{{91, 88}, {247, 165, 0}} ,{{118, 87}, {18, 165, 0}} ,{{112, 88}, {12, 166, 0}} ,{{155, 87}, {55, 165, 0}} ,{{51, 88}, {207, 165, 0}} ,{{231, 87}, {131, 165, 0}} ,{{12, 88}, {168, 165, 0}} ,{{210, 87}, {110, 165, 0}} ,{{183, 87}, {83, 165, 0}} ,{{79, 88}, {235, 165, 0}} ,{{108, 87}, {8, 165, 0}} ,{{145, 87}, {45, 165, 0}} ,{{40, 88}, {196, 165, 0}} ,{{221, 87}, {121, 165, 0}} ,{{2, 88}, {158, 165, 0}} ,{{108, 88}, {8, 166, 0}} ,{{133, 87}, {33, 165, 0}} ,{{186, 87}, {86, 165, 0}} ,{{82, 88}, {238, 165, 0}} ,{{110, 87}, {10, 165, 0}} ,{{147, 87}, {47, 165, 0}} ,{{42, 88}, {198, 165, 0}} ,{{223, 87}, {123, 165, 0}} ,{{4, 88}, {160, 165, 0}} ,{{170, 87}, {70, 165, 0}} ,{{66, 88}, {222, 165, 0}} ,{{246, 87}, {146, 165, 0}} ,{{27, 88}, {183, 165, 0}} ,{{211, 87}, {111, 165, 0}} ,{{197, 87}, {97, 165, 0}} ,{{94, 88}, {250, 165, 0}} ,{{121, 87}, {21, 165, 0}} ,{{158, 87}, {58, 165, 0}} ,{{54, 88}, {210, 165, 0}} ,{{143, 88}, {43, 166, 0}} ,{{116, 88}, {16, 166, 0}} ,{{117, 88}, {17, 166, 0}} ,{{142, 88}, {42, 166, 0}} ,{{118, 88}, {18, 166, 0}} ,{{234, 87}, {134, 165, 0}} ,{{15, 88}, {171, 165, 0}} ,{{109, 88}, {9, 166, 0}} ,{{134, 87}, {34, 165, 0}} ,{{111, 88}, {11, 166, 0}} ,{{175, 87}, {75, 165, 0}} ,{{71, 88}, {227, 165, 0}} ,{{208, 87}, {108, 165, 0}} ,{{104, 88}, {4, 166, 0}} ,{{131, 87}, {31, 165, 0}} ,{{105, 88}, {5, 166, 0}} ,{{168, 87}, {68, 165, 0}} ,{{64, 88}, {220, 165, 0}} ,{{244, 87}, {144, 165, 0}} ,{{25, 88}, {181, 165, 0}} ,{{32, 88}, {188, 165, 0}} ,{{171, 87}, {71, 165, 0}} ,{{204, 87}, {104, 165, 0}} ,{{101, 88}, {1, 166, 0}} ,{{128, 87}, {28, 165, 0}} ,{{165, 87}, {65, 165, 0}} ,{{61, 88}, {217, 165, 0}} ,{{241, 87}, {141, 165, 0}} ,{{22, 88}, {178, 165, 0}} ,{{67, 88}, {223, 165, 0}} ,{{247, 87}, {147, 165, 0}} ,{{28, 88}, {184, 165, 0}} ,{{212, 87}, {112, 165, 0}} ,{{110, 88}, {10, 166, 0}} ,{{135, 87}, {35, 165, 0}} ,{{172, 87}, {72, 165, 0}} ,{{68, 88}, {224, 165, 0}} ,{{248, 87}, {148, 165, 0}} ,{{29, 88}, {185, 165, 0}} ,{{30, 88}, {186, 165, 0}} ,{{31, 88}, {187, 165, 0}} ,{{213, 87}, {113, 165, 0}} ,{{214, 87}, {114, 165, 0}} ,{{180, 87}, {80, 165, 0}} ,{{76, 88}, {232, 165, 0}} ,{{105, 87}, {5, 165, 0}} ,{{142, 87}, {42, 165, 0}} ,{{37, 88}, {193, 165, 0}} ,{{218, 87}, {118, 165, 0}} ,{{255, 87}, {155, 165, 0}} ,{{195, 87}, {95, 165, 0}} ,{{92, 88}, {248, 165, 0}} ,{{119, 87}, {19, 165, 0}} ,{{156, 87}, {56, 165, 0}} ,{{52, 88}, {208, 165, 0}} ,{{232, 87}, {132, 165, 0}} ,{{13, 88}, {169, 165, 0}} ,{{198, 87}, {98, 165, 0}} ,{{95, 88}, {251, 165, 0}} ,{{122, 87}, {22, 165, 0}} ,{{199, 87}, {99, 165, 0}} ,{{96, 88}, {252, 165, 0}} ,{{123, 87}, {23, 165, 0}} ,{{160, 87}, {60, 165, 0}} ,{{56, 88}, {212, 165, 0}} ,{{236, 87}, {136, 165, 0}} ,{{17, 88}, {173, 165, 0}} ,{{159, 87}, {59, 165, 0}} ,{{55, 88}, {211, 165, 0}} ,{{235, 87}, {135, 165, 0}} ,{{16, 88}, {172, 165, 0}} ,{{190, 87}, {90, 165, 0}} ,{{87, 88}, {243, 165, 0}} ,{{114, 87}, {14, 165, 0}} ,{{191, 87}, {91, 165, 0}} ,{{88, 88}, {244, 165, 0}} ,{{115, 87}, {15, 165, 0}} ,{{152, 87}, {52, 165, 0}} ,{{48, 88}, {204, 165, 0}} ,{{228, 87}, {128, 165, 0}} ,{{9, 88}, {165, 165, 0}} ,{{151, 87}, {51, 165, 0}} ,{{47, 88}, {203, 165, 0}} ,{{227, 87}, {127, 165, 0}} ,{{8, 88}, {164, 165, 0}} ,{{249, 87}, {149, 165, 0}} ,{{250, 87}, {150, 165, 0}} ,{{189, 87}, {89, 165, 0}} ,{{86, 88}, {242, 165, 0}} ,{{113, 87}, {13, 165, 0}} ,{{150, 87}, {50, 165, 0}} ,{{46, 88}, {202, 165, 0}} ,{{226, 87}, {126, 165, 0}} ,{{7, 88}, {163, 165, 0}} ,{{178, 87}, {78, 165, 0}} ,{{179, 87}, {79, 165, 0}} ,{{74, 88}, {230, 165, 0}} ,{{103, 87}, {3, 165, 0}} ,{{104, 87}, {4, 165, 0}} ,{{75, 88}, {231, 165, 0}} ,{{140, 87}, {40, 165, 0}} ,{{141, 87}, {41, 165, 0}} ,{{35, 88}, {191, 165, 0}} ,{{36, 88}, {192, 165, 0}} ,{{216, 87}, {116, 165, 0}} ,{{217, 87}, {117, 165, 0}} ,{{253, 87}, {153, 165, 0}} ,{{254, 87}, {154, 165, 0}} ,{{205, 87}, {105, 165, 0}} ,{{102, 88}, {2, 166, 0}} ,{{129, 87}, {29, 165, 0}} ,{{166, 87}, {66, 165, 0}} ,{{62, 88}, {218, 165, 0}} ,{{242, 87}, {142, 165, 0}} ,{{23, 88}, {179, 165, 0}} ,{{200, 87}, {100, 165, 0}} ,{{97, 88}, {253, 165, 0}} ,{{124, 87}, {24, 165, 0}} ,{{201, 87}, {101, 165, 0}} ,{{98, 88}, {254, 165, 0}} ,{{125, 87}, {25, 165, 0}} ,{{162, 87}, {62, 165, 0}} ,{{58, 88}, {214, 165, 0}} ,{{238, 87}, {138, 165, 0}} ,{{19, 88}, {175, 165, 0}} ,{{161, 87}, {61, 165, 0}} ,{{57, 88}, {213, 165, 0}} ,{{237, 87}, {137, 165, 0}} ,{{18, 88}, {174, 165, 0}} ,{{123, 88}, {23, 166, 0}} ,{{126, 88}, {26, 166, 0}} ,{{130, 88}, {30, 166, 0}} ,{{127, 88}, {27, 166, 0}} ,{{124, 88}, {24, 166, 0}} ,{{119, 88}, {19, 166, 0}} ,{{131, 88}, {31, 166, 0}} ,{{120, 88}, {20, 166, 0}} ,{{128, 88}, {28, 166, 0}} ,{{122, 88}, {22, 166, 0}} ,{{125, 88}, {25, 166, 0}} ,{{121, 88}, {21, 166, 0}} ,{{129, 88}, {29, 166, 0}} ,{{174, 140}, {0, 254, 0}} ,{{183, 140}, {9, 254, 0}} ,{{216, 165}, {83, 1, 14}} ,{{217, 165}, {84, 1, 14}} ,{{218, 165}, {85, 1, 14}} ,{{219, 165}, {86, 1, 14}} ,{{220, 165}, {87, 1, 14}} ,{{221, 165}, {88, 1, 14}} ,{{222, 165}, {89, 1, 14}} ,{{223, 165}, {90, 1, 14}} ,{{224, 165}, {91, 1, 14}} ,{{225, 165}, {92, 1, 14}} ,{{184, 140}, {10, 254, 0}} ,{{226, 165}, {93, 1, 14}} ,{{227, 165}, {94, 1, 14}} ,{{228, 165}, {95, 1, 14}} ,{{229, 165}, {96, 1, 14}} ,{{230, 165}, {97, 1, 14}} ,{{231, 165}, {98, 1, 14}} ,{{232, 165}, {99, 1, 14}} ,{{233, 165}, {100, 1, 14}} ,{{234, 165}, {101, 1, 14}} ,{{235, 165}, {102, 1, 14}} ,{{185, 140}, {11, 254, 0}} ,{{236, 165}, {103, 1, 14}} ,{{237, 165}, {104, 1, 14}} ,{{238, 165}, {105, 1, 14}} ,{{239, 165}, {106, 1, 14}} ,{{240, 165}, {107, 1, 14}} ,{{241, 165}, {108, 1, 14}} ,{{242, 165}, {109, 1, 14}} ,{{243, 165}, {110, 1, 14}} ,{{244, 165}, {111, 1, 14}} ,{{245, 165}, {112, 1, 14}} ,{{186, 140}, {12, 254, 0}} ,{{246, 165}, {113, 1, 14}} ,{{247, 165}, {114, 1, 14}} ,{{248, 165}, {115, 1, 14}} ,{{249, 165}, {116, 1, 14}} ,{{250, 165}, {117, 1, 14}} ,{{251, 165}, {118, 1, 14}} ,{{252, 165}, {119, 1, 14}} ,{{253, 165}, {120, 1, 14}} ,{{254, 165}, {121, 1, 14}} ,{{255, 165}, {122, 1, 14}} ,{{187, 140}, {13, 254, 0}} ,{{0, 166}, {123, 1, 14}} ,{{1, 166}, {124, 1, 14}} ,{{2, 166}, {125, 1, 14}} ,{{3, 166}, {126, 1, 14}} ,{{4, 166}, {127, 1, 14}} ,{{5, 166}, {128, 1, 14}} ,{{6, 166}, {129, 1, 14}} ,{{7, 166}, {130, 1, 14}} ,{{8, 166}, {131, 1, 14}} ,{{9, 166}, {132, 1, 14}} ,{{188, 140}, {14, 254, 0}} ,{{10, 166}, {133, 1, 14}} ,{{11, 166}, {134, 1, 14}} ,{{12, 166}, {135, 1, 14}} ,{{13, 166}, {136, 1, 14}} ,{{14, 166}, {137, 1, 14}} ,{{15, 166}, {138, 1, 14}} ,{{16, 166}, {139, 1, 14}} ,{{17, 166}, {140, 1, 14}} ,{{18, 166}, {141, 1, 14}} ,{{19, 166}, {142, 1, 14}} ,{{189, 140}, {15, 254, 0}} ,{{20, 166}, {143, 1, 14}} ,{{21, 166}, {144, 1, 14}} ,{{22, 166}, {145, 1, 14}} ,{{23, 166}, {146, 1, 14}} ,{{24, 166}, {147, 1, 14}} ,{{25, 166}, {148, 1, 14}} ,{{26, 166}, {149, 1, 14}} ,{{27, 166}, {150, 1, 14}} ,{{28, 166}, {151, 1, 14}} ,{{29, 166}, {152, 1, 14}} ,{{133, 165}, {0, 1, 14}} ,{{30, 166}, {153, 1, 14}} ,{{31, 166}, {154, 1, 14}} ,{{32, 166}, {155, 1, 14}} ,{{33, 166}, {156, 1, 14}} ,{{34, 166}, {157, 1, 14}} ,{{35, 166}, {158, 1, 14}} ,{{36, 166}, {159, 1, 14}} ,{{37, 166}, {160, 1, 14}} ,{{38, 166}, {161, 1, 14}} ,{{39, 166}, {162, 1, 14}} ,{{134, 165}, {1, 1, 14}} ,{{40, 166}, {163, 1, 14}} ,{{41, 166}, {164, 1, 14}} ,{{42, 166}, {165, 1, 14}} ,{{43, 166}, {166, 1, 14}} ,{{44, 166}, {167, 1, 14}} ,{{45, 166}, {168, 1, 14}} ,{{46, 166}, {169, 1, 14}} ,{{47, 166}, {170, 1, 14}} ,{{48, 166}, {171, 1, 14}} ,{{49, 166}, {172, 1, 14}} ,{{135, 165}, {2, 1, 14}} ,{{50, 166}, {173, 1, 14}} ,{{51, 166}, {174, 1, 14}} ,{{52, 166}, {175, 1, 14}} ,{{53, 166}, {176, 1, 14}} ,{{54, 166}, {177, 1, 14}} ,{{55, 166}, {178, 1, 14}} ,{{56, 166}, {179, 1, 14}} ,{{57, 166}, {180, 1, 14}} ,{{58, 166}, {181, 1, 14}} ,{{59, 166}, {182, 1, 14}} ,{{175, 140}, {1, 254, 0}} ,{{136, 165}, {3, 1, 14}} ,{{60, 166}, {183, 1, 14}} ,{{61, 166}, {184, 1, 14}} ,{{62, 166}, {185, 1, 14}} ,{{63, 166}, {186, 1, 14}} ,{{64, 166}, {187, 1, 14}} ,{{65, 166}, {188, 1, 14}} ,{{66, 166}, {189, 1, 14}} ,{{67, 166}, {190, 1, 14}} ,{{68, 166}, {191, 1, 14}} ,{{69, 166}, {192, 1, 14}} ,{{137, 165}, {4, 1, 14}} ,{{70, 166}, {193, 1, 14}} ,{{71, 166}, {194, 1, 14}} ,{{72, 166}, {195, 1, 14}} ,{{73, 166}, {196, 1, 14}} ,{{74, 166}, {197, 1, 14}} ,{{75, 166}, {198, 1, 14}} ,{{76, 166}, {199, 1, 14}} ,{{77, 166}, {200, 1, 14}} ,{{78, 166}, {201, 1, 14}} ,{{79, 166}, {202, 1, 14}} ,{{138, 165}, {5, 1, 14}} ,{{80, 166}, {203, 1, 14}} ,{{81, 166}, {204, 1, 14}} ,{{82, 166}, {205, 1, 14}} ,{{83, 166}, {206, 1, 14}} ,{{84, 166}, {207, 1, 14}} ,{{85, 166}, {208, 1, 14}} ,{{86, 166}, {209, 1, 14}} ,{{87, 166}, {210, 1, 14}} ,{{88, 166}, {211, 1, 14}} ,{{89, 166}, {212, 1, 14}} ,{{139, 165}, {6, 1, 14}} ,{{90, 166}, {213, 1, 14}} ,{{91, 166}, {214, 1, 14}} ,{{92, 166}, {215, 1, 14}} ,{{93, 166}, {216, 1, 14}} ,{{94, 166}, {217, 1, 14}} ,{{95, 166}, {218, 1, 14}} ,{{96, 166}, {219, 1, 14}} ,{{97, 166}, {220, 1, 14}} ,{{98, 166}, {221, 1, 14}} ,{{99, 166}, {222, 1, 14}} ,{{140, 165}, {7, 1, 14}} ,{{100, 166}, {223, 1, 14}} ,{{101, 166}, {224, 1, 14}} ,{{102, 166}, {225, 1, 14}} ,{{103, 166}, {226, 1, 14}} ,{{104, 166}, {227, 1, 14}} ,{{105, 166}, {228, 1, 14}} ,{{106, 166}, {229, 1, 14}} ,{{107, 166}, {230, 1, 14}} ,{{108, 166}, {231, 1, 14}} ,{{109, 166}, {232, 1, 14}} ,{{141, 165}, {8, 1, 14}} ,{{110, 166}, {233, 1, 14}} ,{{111, 166}, {234, 1, 14}} ,{{112, 166}, {235, 1, 14}} ,{{113, 166}, {236, 1, 14}} ,{{114, 166}, {237, 1, 14}} ,{{115, 166}, {238, 1, 14}} ,{{116, 166}, {239, 1, 14}} ,{{142, 165}, {9, 1, 14}} ,{{143, 165}, {10, 1, 14}} ,{{144, 165}, {11, 1, 14}} ,{{145, 165}, {12, 1, 14}} ,{{176, 140}, {2, 254, 0}} ,{{146, 165}, {13, 1, 14}} ,{{147, 165}, {14, 1, 14}} ,{{148, 165}, {15, 1, 14}} ,{{149, 165}, {16, 1, 14}} ,{{150, 165}, {17, 1, 14}} ,{{151, 165}, {18, 1, 14}} ,{{152, 165}, {19, 1, 14}} ,{{153, 165}, {20, 1, 14}} ,{{154, 165}, {21, 1, 14}} ,{{155, 165}, {22, 1, 14}} ,{{177, 140}, {3, 254, 0}} ,{{156, 165}, {23, 1, 14}} ,{{157, 165}, {24, 1, 14}} ,{{158, 165}, {25, 1, 14}} ,{{159, 165}, {26, 1, 14}} ,{{160, 165}, {27, 1, 14}} ,{{161, 165}, {28, 1, 14}} ,{{162, 165}, {29, 1, 14}} ,{{163, 165}, {30, 1, 14}} ,{{164, 165}, {31, 1, 14}} ,{{165, 165}, {32, 1, 14}} ,{{178, 140}, {4, 254, 0}} ,{{166, 165}, {33, 1, 14}} ,{{167, 165}, {34, 1, 14}} ,{{168, 165}, {35, 1, 14}} ,{{169, 165}, {36, 1, 14}} ,{{170, 165}, {37, 1, 14}} ,{{171, 165}, {38, 1, 14}} ,{{172, 165}, {39, 1, 14}} ,{{173, 165}, {40, 1, 14}} ,{{174, 165}, {41, 1, 14}} ,{{175, 165}, {42, 1, 14}} ,{{179, 140}, {5, 254, 0}} ,{{176, 165}, {43, 1, 14}} ,{{177, 165}, {44, 1, 14}} ,{{178, 165}, {45, 1, 14}} ,{{179, 165}, {46, 1, 14}} ,{{180, 165}, {47, 1, 14}} ,{{181, 165}, {48, 1, 14}} ,{{182, 165}, {49, 1, 14}} ,{{183, 165}, {50, 1, 14}} ,{{184, 165}, {51, 1, 14}} ,{{185, 165}, {52, 1, 14}} ,{{180, 140}, {6, 254, 0}} ,{{186, 165}, {53, 1, 14}} ,{{187, 165}, {54, 1, 14}} ,{{188, 165}, {55, 1, 14}} ,{{189, 165}, {56, 1, 14}} ,{{190, 165}, {57, 1, 14}} ,{{191, 165}, {58, 1, 14}} ,{{192, 165}, {59, 1, 14}} ,{{193, 165}, {60, 1, 14}} ,{{194, 165}, {61, 1, 14}} ,{{195, 165}, {62, 1, 14}} ,{{181, 140}, {7, 254, 0}} ,{{196, 165}, {63, 1, 14}} ,{{197, 165}, {64, 1, 14}} ,{{198, 165}, {65, 1, 14}} ,{{199, 165}, {66, 1, 14}} ,{{200, 165}, {67, 1, 14}} ,{{201, 165}, {68, 1, 14}} ,{{202, 165}, {69, 1, 14}} ,{{203, 165}, {70, 1, 14}} ,{{204, 165}, {71, 1, 14}} ,{{205, 165}, {72, 1, 14}} ,{{182, 140}, {8, 254, 0}} ,{{206, 165}, {73, 1, 14}} ,{{207, 165}, {74, 1, 14}} ,{{208, 165}, {75, 1, 14}} ,{{209, 165}, {76, 1, 14}} ,{{210, 165}, {77, 1, 14}} ,{{211, 165}, {78, 1, 14}} ,{{212, 165}, {79, 1, 14}} ,{{213, 165}, {80, 1, 14}} ,{{214, 165}, {81, 1, 14}} ,{{215, 165}, {82, 1, 14}} ,{{224, 73}, {47, 42, 0}} ,{{115, 61}, {233, 28, 0}} ,{{116, 61}, {234, 28, 0}} ,{{123, 61}, {241, 28, 0}} ,{{117, 61}, {235, 28, 0}} ,{{118, 61}, {236, 28, 0}} ,{{124, 61}, {242, 28, 0}} ,{{120, 61}, {238, 28, 0}} ,{{121, 61}, {239, 28, 0}} ,{{93, 61}, {211, 28, 0}} ,{{112, 61}, {230, 28, 0}} ,{{110, 61}, {228, 28, 0}} ,{{122, 61}, {240, 28, 0}} ,{{119, 61}, {237, 28, 0}} ,{{111, 61}, {229, 28, 0}} ,{{114, 61}, {232, 28, 0}} ,{{108, 61}, {226, 28, 0}} ,{{109, 61}, {227, 28, 0}} ,{{113, 61}, {231, 28, 0}} ,{{94, 61}, {212, 28, 0}} ,{{107, 61}, {225, 28, 0}} ,{{98, 61}, {216, 28, 0}} ,{{103, 61}, {221, 28, 0}} ,{{100, 61}, {218, 28, 0}} ,{{90, 61}, {208, 28, 0}} ,{{102, 61}, {220, 28, 0}} ,{{92, 61}, {210, 28, 0}} ,{{106, 61}, {224, 28, 0}} ,{{91, 61}, {209, 28, 0}} ,{{105, 61}, {223, 28, 0}} ,{{101, 61}, {219, 28, 0}} ,{{104, 61}, {222, 28, 0}} ,{{95, 61}, {213, 28, 0}} ,{{96, 61}, {214, 28, 0}} ,{{97, 61}, {215, 28, 0}} ,{{99, 61}, {217, 28, 0}} ,{{58, 65}, {35, 33, 0}} ,{{129, 73}, {208, 41, 0}} ,{{149, 74}, {228, 42, 0}} ,{{147, 74}, {226, 42, 0}} ,{{127, 71}, {202, 39, 0}} ,{{255, 66}, {238, 34, 0}} ,{{174, 64}, {94, 32, 0}} ,{{141, 78}, {59, 48, 0}} ,{{131, 78}, {49, 48, 0}} ,{{135, 78}, {53, 48, 0}} ,{{133, 78}, {51, 48, 0}} ,{{132, 78}, {50, 48, 0}} ,{{134, 78}, {52, 48, 0}} ,{{63, 38}, {124, 0, 0}} ,{{225, 67}, {208, 35, 0}} ,{{160, 74}, {239, 42, 0}} ,{{161, 74}, {240, 42, 0}} ,{{144, 67}, {127, 35, 0}} ,{{116, 70}, {168, 38, 0}} ,{{250, 76}, {47, 46, 0}} ,{{75, 73}, {154, 41, 0}} ,{{234, 66}, {217, 34, 0}} ,{{233, 66}, {216, 34, 0}} ,{{130, 70}, {182, 38, 0}} ,{{206, 70}, {12, 39, 0}} ,{{40, 67}, {23, 35, 0}} ,{{25, 70}, {77, 38, 0}} ,{{65, 66}, {48, 34, 0}} ,{{116, 65}, {93, 33, 0}} ,{{113, 65}, {90, 33, 0}} ,{{111, 65}, {88, 33, 0}} ,{{114, 65}, {91, 33, 0}} ,{{108, 65}, {85, 33, 0}} ,{{95, 38}, {189, 0, 0}} ,{{104, 65}, {81, 33, 0}} ,{{94, 38}, {188, 0, 0}} ,{{103, 65}, {80, 33, 0}} ,{{112, 65}, {89, 33, 0}} ,{{105, 65}, {82, 33, 0}} ,{{106, 65}, {83, 33, 0}} ,{{117, 65}, {94, 33, 0}} ,{{115, 65}, {92, 33, 0}} ,{{110, 65}, {87, 33, 0}} ,{{96, 38}, {190, 0, 0}} ,{{109, 65}, {86, 33, 0}} ,{{107, 65}, {84, 33, 0}} ,{{160, 65}, {137, 33, 0}} ,{{108, 70}, {160, 38, 0}} ,{{43, 67}, {26, 35, 0}} ,{{240, 74}, {63, 43, 0}} ,{{228, 72}, {51, 41, 0}} ,{{110, 78}, {28, 48, 0}} ,{{130, 78}, {48, 48, 0}} ,{{24, 67}, {7, 35, 0}} ,{{238, 140}, {79, 254, 0}} ,{{234, 140}, {75, 254, 0}} ,{{114, 71}, {188, 39, 0}} ,{{60, 70}, {112, 38, 0}} ,{{75, 70}, {127, 38, 0}} ,{{4, 70}, {56, 38, 0}} ,{{105, 71}, {179, 39, 0}} ,{{178, 69}, {230, 37, 0}} ,{{35, 70}, {87, 38, 0}} ,{{32, 70}, {84, 38, 0}} ,{{36, 70}, {88, 38, 0}} ,{{37, 70}, {89, 38, 0}} ,{{33, 70}, {85, 38, 0}} ,{{34, 70}, {86, 38, 0}} ,{{151, 69}, {203, 37, 0}} ,{{82, 70}, {134, 38, 0}} ,{{157, 73}, {236, 41, 0}} ,{{193, 69}, {245, 37, 0}} ,{{194, 69}, {246, 37, 0}} ,{{83, 70}, {135, 38, 0}} ,{{192, 69}, {244, 37, 0}} ,{{195, 69}, {247, 37, 0}} ,{{51, 70}, {103, 38, 0}} ,{{146, 71}, {225, 39, 0}} ,{{147, 71}, {226, 39, 0}} ,{{148, 71}, {227, 39, 0}} ,{{147, 69}, {199, 37, 0}} ,{{148, 69}, {200, 37, 0}} ,{{151, 70}, {203, 38, 0}} ,{{46, 70}, {98, 38, 0}} ,{{129, 71}, {208, 39, 0}} ,{{139, 69}, {191, 37, 0}} ,{{137, 69}, {189, 37, 0}} ,{{235, 69}, {31, 38, 0}} ,{{141, 70}, {193, 38, 0}} ,{{140, 70}, {192, 38, 0}} ,{{92, 70}, {144, 38, 0}} ,{{197, 70}, {255, 38, 0}} ,{{1, 71}, {64, 39, 0}} ,{{233, 70}, {39, 39, 0}} ,{{5, 70}, {57, 38, 0}} ,{{45, 70}, {97, 38, 0}} ,{{210, 74}, {33, 43, 0}} ,{{222, 74}, {45, 43, 0}} ,{{135, 73}, {214, 41, 0}} ,{{205, 74}, {28, 43, 0}} ,{{145, 69}, {197, 37, 0}} ,{{143, 69}, {195, 37, 0}} ,{{141, 69}, {193, 37, 0}} ,{{164, 70}, {217, 38, 0}} ,{{232, 69}, {28, 38, 0}} ,{{215, 74}, {38, 43, 0}} ,{{217, 74}, {40, 43, 0}} ,{{201, 69}, {253, 37, 0}} ,{{199, 69}, {251, 37, 0}} ,{{254, 74}, {80, 43, 0}} ,{{211, 70}, {17, 39, 0}} ,{{125, 69}, {177, 37, 0}} ,{{209, 74}, {32, 43, 0}} ,{{121, 69}, {173, 37, 0}} ,{{2, 75}, {84, 43, 0}} ,{{135, 69}, {187, 37, 0}} ,{{133, 69}, {185, 37, 0}} ,{{131, 69}, {183, 37, 0}} ,{{234, 69}, {30, 38, 0}} ,{{201, 70}, {4, 39, 0}} ,{{229, 140}, {70, 254, 0}} ,{{226, 69}, {22, 38, 0}} ,{{220, 74}, {43, 43, 0}} ,{{119, 69}, {171, 37, 0}} ,{{0, 75}, {82, 43, 0}} ,{{6, 70}, {58, 38, 0}} ,{{48, 70}, {100, 38, 0}} ,{{109, 69}, {161, 37, 0}} ,{{111, 69}, {163, 37, 0}} ,{{150, 67}, {133, 35, 0}} ,{{149, 71}, {228, 39, 0}} ,{{189, 69}, {241, 37, 0}} ,{{190, 69}, {242, 37, 0}} ,{{150, 71}, {229, 39, 0}} ,{{110, 69}, {162, 37, 0}} ,{{188, 69}, {240, 37, 0}} ,{{191, 69}, {243, 37, 0}} ,{{183, 69}, {235, 37, 0}} ,{{210, 69}, {6, 38, 0}} ,{{8, 70}, {60, 38, 0}} ,{{219, 69}, {15, 38, 0}} ,{{243, 67}, {226, 35, 0}} ,{{118, 71}, {193, 39, 0}} ,{{162, 70}, {215, 38, 0}} ,{{129, 69}, {181, 37, 0}} ,{{127, 69}, {179, 37, 0}} ,{{184, 69}, {236, 37, 0}} ,{{233, 69}, {29, 38, 0}} ,{{175, 74}, {254, 42, 0}} ,{{224, 74}, {47, 43, 0}} ,{{123, 69}, {175, 37, 0}} ,{{207, 74}, {30, 43, 0}} ,{{230, 64}, {169, 32, 0}} ,{{176, 64}, {96, 32, 0}} ,{{252, 76}, {49, 46, 0}} ,{{81, 66}, {64, 34, 0}} ,{{207, 70}, {13, 39, 0}} ,{{204, 66}, {187, 34, 0}} ,{{56, 67}, {39, 35, 0}} ,{{71, 38}, {165, 0, 0}} ,{{251, 69}, {47, 38, 0}} ,{{8, 87}, {155, 164, 0}} ,{{18, 87}, {165, 164, 0}} ,{{48, 87}, {195, 164, 0}} ,{{43, 87}, {190, 164, 0}} ,{{42, 87}, {189, 164, 0}} ,{{41, 87}, {188, 164, 0}} ,{{1, 87}, {148, 164, 0}} ,{{16, 87}, {163, 164, 0}} ,{{17, 87}, {164, 164, 0}} ,{{38, 87}, {185, 164, 0}} ,{{14, 87}, {161, 164, 0}} ,{{4, 87}, {151, 164, 0}} ,{{3, 87}, {150, 164, 0}} ,{{19, 87}, {166, 164, 0}} ,{{35, 87}, {182, 164, 0}} ,{{26, 87}, {173, 164, 0}} ,{{6, 87}, {153, 164, 0}} ,{{44, 87}, {191, 164, 0}} ,{{12, 87}, {159, 164, 0}} ,{{36, 87}, {183, 164, 0}} ,{{23, 87}, {170, 164, 0}} ,{{34, 87}, {181, 164, 0}} ,{{32, 87}, {179, 164, 0}} ,{{51, 87}, {198, 164, 0}} ,{{255, 86}, {146, 164, 0}} ,{{254, 86}, {145, 164, 0}} ,{{40, 87}, {187, 164, 0}} ,{{7, 87}, {154, 164, 0}} ,{{5, 87}, {152, 164, 0}} ,{{9, 87}, {156, 164, 0}} ,{{50, 87}, {197, 164, 0}} ,{{0, 87}, {147, 164, 0}} ,{{20, 87}, {167, 164, 0}} ,{{33, 87}, {180, 164, 0}} ,{{22, 87}, {169, 164, 0}} ,{{11, 87}, {158, 164, 0}} ,{{25, 87}, {172, 164, 0}} ,{{253, 86}, {144, 164, 0}} ,{{45, 87}, {192, 164, 0}} ,{{47, 87}, {194, 164, 0}} ,{{39, 87}, {186, 164, 0}} ,{{29, 87}, {176, 164, 0}} ,{{2, 87}, {149, 164, 0}} ,{{13, 87}, {160, 164, 0}} ,{{21, 87}, {168, 164, 0}} ,{{30, 87}, {177, 164, 0}} ,{{28, 87}, {175, 164, 0}} ,{{37, 87}, {184, 164, 0}} ,{{27, 87}, {174, 164, 0}} ,{{10, 87}, {157, 164, 0}} ,{{31, 87}, {178, 164, 0}} ,{{24, 87}, {171, 164, 0}} ,{{15, 87}, {162, 164, 0}} ,{{46, 87}, {193, 164, 0}} ,{{49, 87}, {196, 164, 0}} ,{{122, 82}, {10, 160, 0}} ,{{123, 82}, {11, 160, 0}} ,{{120, 82}, {8, 160, 0}} ,{{121, 82}, {9, 160, 0}} ,{{144, 82}, {32, 160, 0}} ,{{145, 82}, {33, 160, 0}} ,{{142, 82}, {30, 160, 0}} ,{{143, 82}, {31, 160, 0}} ,{{208, 82}, {96, 160, 0}} ,{{209, 82}, {97, 160, 0}} ,{{206, 82}, {94, 160, 0}} ,{{207, 82}, {95, 160, 0}} ,{{218, 82}, {106, 160, 0}} ,{{219, 82}, {107, 160, 0}} ,{{217, 82}, {105, 160, 0}} ,{{200, 82}, {88, 160, 0}} ,{{204, 82}, {92, 160, 0}} ,{{205, 82}, {93, 160, 0}} ,{{202, 82}, {90, 160, 0}} ,{{203, 82}, {91, 160, 0}} ,{{201, 82}, {89, 160, 0}} ,{{198, 82}, {86, 160, 0}} ,{{199, 82}, {87, 160, 0}} ,{{215, 82}, {103, 160, 0}} ,{{216, 82}, {104, 160, 0}} ,{{213, 82}, {101, 160, 0}} ,{{214, 82}, {102, 160, 0}} ,{{222, 82}, {110, 160, 0}} ,{{211, 82}, {99, 160, 0}} ,{{212, 82}, {100, 160, 0}} ,{{210, 82}, {98, 160, 0}} ,{{223, 82}, {111, 160, 0}} ,{{225, 82}, {113, 160, 0}} ,{{224, 82}, {112, 160, 0}} ,{{220, 82}, {108, 160, 0}} ,{{221, 82}, {109, 160, 0}} ,{{228, 82}, {116, 160, 0}} ,{{229, 82}, {117, 160, 0}} ,{{226, 82}, {114, 160, 0}} ,{{227, 82}, {115, 160, 0}} ,{{154, 82}, {42, 160, 0}} ,{{155, 82}, {43, 160, 0}} ,{{153, 82}, {41, 160, 0}} ,{{136, 82}, {24, 160, 0}} ,{{140, 82}, {28, 160, 0}} ,{{141, 82}, {29, 160, 0}} ,{{138, 82}, {26, 160, 0}} ,{{139, 82}, {27, 160, 0}} ,{{137, 82}, {25, 160, 0}} ,{{134, 82}, {22, 160, 0}} ,{{135, 82}, {23, 160, 0}} ,{{151, 82}, {39, 160, 0}} ,{{152, 82}, {40, 160, 0}} ,{{149, 82}, {37, 160, 0}} ,{{150, 82}, {38, 160, 0}} ,{{158, 82}, {46, 160, 0}} ,{{147, 82}, {35, 160, 0}} ,{{148, 82}, {36, 160, 0}} ,{{146, 82}, {34, 160, 0}} ,{{159, 82}, {47, 160, 0}} ,{{161, 82}, {49, 160, 0}} ,{{160, 82}, {48, 160, 0}} ,{{156, 82}, {44, 160, 0}} ,{{157, 82}, {45, 160, 0}} ,{{164, 82}, {52, 160, 0}} ,{{165, 82}, {53, 160, 0}} ,{{167, 82}, {55, 160, 0}} ,{{166, 82}, {54, 160, 0}} ,{{162, 82}, {50, 160, 0}} ,{{163, 82}, {51, 160, 0}} ,{{40, 85}, {184, 162, 0}} ,{{41, 85}, {185, 162, 0}} ,{{38, 85}, {182, 162, 0}} ,{{39, 85}, {183, 162, 0}} ,{{50, 85}, {194, 162, 0}} ,{{51, 85}, {195, 162, 0}} ,{{49, 85}, {193, 162, 0}} ,{{211, 85}, {99, 163, 0}} ,{{212, 85}, {100, 163, 0}} ,{{209, 85}, {97, 163, 0}} ,{{210, 85}, {98, 163, 0}} ,{{223, 85}, {111, 163, 0}} ,{{224, 85}, {112, 163, 0}} ,{{221, 85}, {109, 163, 0}} ,{{222, 85}, {110, 163, 0}} ,{{219, 85}, {107, 163, 0}} ,{{220, 85}, {108, 163, 0}} ,{{217, 85}, {105, 163, 0}} ,{{218, 85}, {106, 163, 0}} ,{{226, 85}, {114, 163, 0}} ,{{215, 85}, {103, 163, 0}} ,{{216, 85}, {104, 163, 0}} ,{{213, 85}, {101, 163, 0}} ,{{214, 85}, {102, 163, 0}} ,{{227, 85}, {115, 163, 0}} ,{{229, 85}, {117, 163, 0}} ,{{228, 85}, {116, 163, 0}} ,{{225, 85}, {113, 163, 0}} ,{{232, 85}, {120, 163, 0}} ,{{233, 85}, {121, 163, 0}} ,{{235, 85}, {123, 163, 0}} ,{{234, 85}, {122, 163, 0}} ,{{230, 85}, {118, 163, 0}} ,{{231, 85}, {119, 163, 0}} ,{{32, 85}, {176, 162, 0}} ,{{36, 85}, {180, 162, 0}} ,{{37, 85}, {181, 162, 0}} ,{{34, 85}, {178, 162, 0}} ,{{35, 85}, {179, 162, 0}} ,{{33, 85}, {177, 162, 0}} ,{{30, 85}, {174, 162, 0}} ,{{31, 85}, {175, 162, 0}} ,{{47, 85}, {191, 162, 0}} ,{{48, 85}, {192, 162, 0}} ,{{45, 85}, {189, 162, 0}} ,{{46, 85}, {190, 162, 0}} ,{{54, 85}, {198, 162, 0}} ,{{43, 85}, {187, 162, 0}} ,{{44, 85}, {188, 162, 0}} ,{{42, 85}, {186, 162, 0}} ,{{55, 85}, {199, 162, 0}} ,{{57, 85}, {201, 162, 0}} ,{{56, 85}, {200, 162, 0}} ,{{52, 85}, {196, 162, 0}} ,{{53, 85}, {197, 162, 0}} ,{{60, 85}, {204, 162, 0}} ,{{61, 85}, {205, 162, 0}} ,{{63, 85}, {207, 162, 0}} ,{{62, 85}, {206, 162, 0}} ,{{58, 85}, {202, 162, 0}} ,{{59, 85}, {203, 162, 0}} ,{{121, 83}, {9, 161, 0}} ,{{122, 83}, {10, 161, 0}} ,{{119, 83}, {7, 161, 0}} ,{{120, 83}, {8, 161, 0}} ,{{175, 83}, {63, 161, 0}} ,{{176, 83}, {64, 161, 0}} ,{{173, 83}, {61, 161, 0}} ,{{174, 83}, {62, 161, 0}} ,{{185, 83}, {73, 161, 0}} ,{{186, 83}, {74, 161, 0}} ,{{184, 83}, {72, 161, 0}} ,{{168, 83}, {56, 161, 0}} ,{{171, 83}, {59, 161, 0}} ,{{172, 83}, {60, 161, 0}} ,{{170, 83}, {58, 161, 0}} ,{{169, 83}, {57, 161, 0}} ,{{166, 83}, {54, 161, 0}} ,{{167, 83}, {55, 161, 0}} ,{{182, 83}, {70, 161, 0}} ,{{183, 83}, {71, 161, 0}} ,{{180, 83}, {68, 161, 0}} ,{{181, 83}, {69, 161, 0}} ,{{189, 83}, {77, 161, 0}} ,{{178, 83}, {66, 161, 0}} ,{{179, 83}, {67, 161, 0}} ,{{177, 83}, {65, 161, 0}} ,{{190, 83}, {78, 161, 0}} ,{{192, 83}, {80, 161, 0}} ,{{191, 83}, {79, 161, 0}} ,{{187, 83}, {75, 161, 0}} ,{{188, 83}, {76, 161, 0}} ,{{130, 83}, {18, 161, 0}} ,{{131, 83}, {19, 161, 0}} ,{{129, 83}, {17, 161, 0}} ,{{114, 83}, {2, 161, 0}} ,{{117, 83}, {5, 161, 0}} ,{{118, 83}, {6, 161, 0}} ,{{116, 83}, {4, 161, 0}} ,{{115, 83}, {3, 161, 0}} ,{{112, 83}, {0, 161, 0}} ,{{113, 83}, {1, 161, 0}} ,{{127, 83}, {15, 161, 0}} ,{{128, 83}, {16, 161, 0}} ,{{125, 83}, {13, 161, 0}} ,{{126, 83}, {14, 161, 0}} ,{{134, 83}, {22, 161, 0}} ,{{124, 83}, {12, 161, 0}} ,{{123, 83}, {11, 161, 0}} ,{{135, 83}, {23, 161, 0}} ,{{137, 83}, {25, 161, 0}} ,{{136, 83}, {24, 161, 0}} ,{{132, 83}, {20, 161, 0}} ,{{133, 83}, {21, 161, 0}} ,{{132, 82}, {20, 160, 0}} ,{{131, 82}, {19, 160, 0}} ,{{67, 83}, {211, 160, 0}} ,{{68, 83}, {212, 160, 0}} ,{{65, 83}, {209, 160, 0}} ,{{66, 83}, {210, 160, 0}} ,{{63, 83}, {207, 160, 0}} ,{{64, 83}, {208, 160, 0}} ,{{61, 83}, {205, 160, 0}} ,{{62, 83}, {206, 160, 0}} ,{{70, 83}, {214, 160, 0}} ,{{71, 83}, {215, 160, 0}} ,{{69, 83}, {213, 160, 0}} ,{{74, 83}, {218, 160, 0}} ,{{75, 83}, {219, 160, 0}} ,{{77, 83}, {221, 160, 0}} ,{{76, 83}, {220, 160, 0}} ,{{72, 83}, {216, 160, 0}} ,{{73, 83}, {217, 160, 0}} ,{{80, 83}, {224, 160, 0}} ,{{81, 83}, {225, 160, 0}} ,{{78, 83}, {222, 160, 0}} ,{{79, 83}, {223, 160, 0}} ,{{84, 84}, {228, 161, 0}} ,{{85, 84}, {229, 161, 0}} ,{{82, 84}, {226, 161, 0}} ,{{83, 84}, {227, 161, 0}} ,{{96, 84}, {240, 161, 0}} ,{{97, 84}, {241, 161, 0}} ,{{94, 84}, {238, 161, 0}} ,{{95, 84}, {239, 161, 0}} ,{{140, 84}, {28, 162, 0}} ,{{141, 84}, {29, 162, 0}} ,{{138, 84}, {26, 162, 0}} ,{{139, 84}, {27, 162, 0}} ,{{152, 84}, {40, 162, 0}} ,{{153, 84}, {41, 162, 0}} ,{{150, 84}, {38, 162, 0}} ,{{151, 84}, {39, 162, 0}} ,{{134, 84}, {22, 162, 0}} ,{{136, 84}, {24, 162, 0}} ,{{137, 84}, {25, 162, 0}} ,{{135, 84}, {23, 162, 0}} ,{{132, 84}, {20, 162, 0}} ,{{133, 84}, {21, 162, 0}} ,{{148, 84}, {36, 162, 0}} ,{{149, 84}, {37, 162, 0}} ,{{146, 84}, {34, 162, 0}} ,{{147, 84}, {35, 162, 0}} ,{{156, 84}, {44, 162, 0}} ,{{144, 84}, {32, 162, 0}} ,{{145, 84}, {33, 162, 0}} ,{{142, 84}, {30, 162, 0}} ,{{143, 84}, {31, 162, 0}} ,{{157, 84}, {45, 162, 0}} ,{{159, 84}, {47, 162, 0}} ,{{158, 84}, {46, 162, 0}} ,{{154, 84}, {42, 162, 0}} ,{{155, 84}, {43, 162, 0}} ,{{76, 84}, {220, 161, 0}} ,{{80, 84}, {224, 161, 0}} ,{{81, 84}, {225, 161, 0}} ,{{78, 84}, {222, 161, 0}} ,{{79, 84}, {223, 161, 0}} ,{{77, 84}, {221, 161, 0}} ,{{74, 84}, {218, 161, 0}} ,{{75, 84}, {219, 161, 0}} ,{{92, 84}, {236, 161, 0}} ,{{93, 84}, {237, 161, 0}} ,{{90, 84}, {234, 161, 0}} ,{{91, 84}, {235, 161, 0}} ,{{100, 84}, {244, 161, 0}} ,{{88, 84}, {232, 161, 0}} ,{{89, 84}, {233, 161, 0}} ,{{86, 84}, {230, 161, 0}} ,{{87, 84}, {231, 161, 0}} ,{{101, 84}, {245, 161, 0}} ,{{103, 84}, {247, 161, 0}} ,{{102, 84}, {246, 161, 0}} ,{{98, 84}, {242, 161, 0}} ,{{99, 84}, {243, 161, 0}} ,{{227, 84}, {115, 162, 0}} ,{{228, 84}, {116, 162, 0}} ,{{225, 84}, {113, 162, 0}} ,{{226, 84}, {114, 162, 0}} ,{{238, 84}, {126, 162, 0}} ,{{239, 84}, {127, 162, 0}} ,{{237, 84}, {125, 162, 0}} ,{{224, 84}, {112, 162, 0}} ,{{223, 84}, {111, 162, 0}} ,{{222, 84}, {110, 162, 0}} ,{{16, 84}, {160, 161, 0}} ,{{17, 84}, {161, 161, 0}} ,{{14, 84}, {158, 161, 0}} ,{{15, 84}, {159, 161, 0}} ,{{25, 84}, {169, 161, 0}} ,{{26, 84}, {170, 161, 0}} ,{{24, 84}, {168, 161, 0}} ,{{9, 84}, {153, 161, 0}} ,{{12, 84}, {156, 161, 0}} ,{{13, 84}, {157, 161, 0}} ,{{11, 84}, {155, 161, 0}} ,{{10, 84}, {154, 161, 0}} ,{{7, 84}, {151, 161, 0}} ,{{8, 84}, {152, 161, 0}} ,{{22, 84}, {166, 161, 0}} ,{{23, 84}, {167, 161, 0}} ,{{21, 84}, {165, 161, 0}} ,{{29, 84}, {173, 161, 0}} ,{{19, 84}, {163, 161, 0}} ,{{20, 84}, {164, 161, 0}} ,{{18, 84}, {162, 161, 0}} ,{{30, 84}, {174, 161, 0}} ,{{32, 84}, {176, 161, 0}} ,{{31, 84}, {175, 161, 0}} ,{{27, 84}, {171, 161, 0}} ,{{28, 84}, {172, 161, 0}} ,{{35, 84}, {179, 161, 0}} ,{{36, 84}, {180, 161, 0}} ,{{38, 84}, {182, 161, 0}} ,{{37, 84}, {181, 161, 0}} ,{{33, 84}, {177, 161, 0}} ,{{34, 84}, {178, 161, 0}} ,{{10, 83}, {154, 160, 0}} ,{{11, 83}, {155, 160, 0}} ,{{8, 83}, {152, 160, 0}} ,{{9, 83}, {153, 160, 0}} ,{{3, 83}, {147, 160, 0}} ,{{6, 83}, {150, 160, 0}} ,{{7, 83}, {151, 160, 0}} ,{{5, 83}, {149, 160, 0}} ,{{4, 83}, {148, 160, 0}} ,{{1, 83}, {145, 160, 0}} ,{{2, 83}, {146, 160, 0}} ,{{17, 83}, {161, 160, 0}} ,{{18, 83}, {162, 160, 0}} ,{{15, 83}, {159, 160, 0}} ,{{16, 83}, {160, 160, 0}} ,{{21, 83}, {165, 160, 0}} ,{{13, 83}, {157, 160, 0}} ,{{14, 83}, {158, 160, 0}} ,{{12, 83}, {156, 160, 0}} ,{{22, 83}, {166, 160, 0}} ,{{24, 83}, {168, 160, 0}} ,{{23, 83}, {167, 160, 0}} ,{{19, 83}, {163, 160, 0}} ,{{20, 83}, {164, 160, 0}} ,{{26, 83}, {170, 160, 0}} ,{{27, 83}, {171, 160, 0}} ,{{29, 83}, {173, 160, 0}} ,{{28, 83}, {172, 160, 0}} ,{{25, 83}, {169, 160, 0}} ,{{226, 83}, {114, 161, 0}} ,{{227, 83}, {115, 161, 0}} ,{{224, 83}, {112, 161, 0}} ,{{225, 83}, {113, 161, 0}} ,{{234, 83}, {122, 161, 0}} ,{{235, 83}, {123, 161, 0}} ,{{233, 83}, {121, 161, 0}} ,{{218, 83}, {106, 161, 0}} ,{{222, 83}, {110, 161, 0}} ,{{223, 83}, {111, 161, 0}} ,{{220, 83}, {108, 161, 0}} ,{{221, 83}, {109, 161, 0}} ,{{219, 83}, {107, 161, 0}} ,{{216, 83}, {104, 161, 0}} ,{{217, 83}, {105, 161, 0}} ,{{232, 83}, {120, 161, 0}} ,{{230, 83}, {118, 161, 0}} ,{{231, 83}, {119, 161, 0}} ,{{229, 83}, {117, 161, 0}} ,{{228, 83}, {116, 161, 0}} ,{{236, 83}, {124, 161, 0}} ,{{235, 84}, {123, 162, 0}} ,{{236, 84}, {124, 162, 0}} ,{{233, 84}, {121, 162, 0}} ,{{234, 84}, {122, 162, 0}} ,{{231, 84}, {119, 162, 0}} ,{{232, 84}, {120, 162, 0}} ,{{229, 84}, {117, 162, 0}} ,{{230, 84}, {118, 162, 0}} ,{{192, 84}, {80, 162, 0}} ,{{193, 84}, {81, 162, 0}} ,{{190, 84}, {78, 162, 0}} ,{{191, 84}, {79, 162, 0}} ,{{203, 84}, {91, 162, 0}} ,{{204, 84}, {92, 162, 0}} ,{{202, 84}, {90, 162, 0}} ,{{184, 84}, {72, 162, 0}} ,{{188, 84}, {76, 162, 0}} ,{{189, 84}, {77, 162, 0}} ,{{186, 84}, {74, 162, 0}} ,{{187, 84}, {75, 162, 0}} ,{{185, 84}, {73, 162, 0}} ,{{182, 84}, {70, 162, 0}} ,{{183, 84}, {71, 162, 0}} ,{{200, 84}, {88, 162, 0}} ,{{201, 84}, {89, 162, 0}} ,{{198, 84}, {86, 162, 0}} ,{{199, 84}, {87, 162, 0}} ,{{196, 84}, {84, 162, 0}} ,{{197, 84}, {85, 162, 0}} ,{{194, 84}, {82, 162, 0}} ,{{195, 84}, {83, 162, 0}} ,{{114, 82}, {2, 160, 0}} ,{{118, 82}, {6, 160, 0}} ,{{119, 82}, {7, 160, 0}} ,{{116, 82}, {4, 160, 0}} ,{{117, 82}, {5, 160, 0}} ,{{115, 82}, {3, 160, 0}} ,{{112, 82}, {0, 160, 0}} ,{{113, 82}, {1, 160, 0}} ,{{82, 86}, {226, 163, 0}} ,{{86, 86}, {230, 163, 0}} ,{{87, 86}, {231, 163, 0}} ,{{84, 86}, {228, 163, 0}} ,{{85, 86}, {229, 163, 0}} ,{{83, 86}, {227, 163, 0}} ,{{80, 86}, {224, 163, 0}} ,{{81, 86}, {225, 163, 0}} ,{{138, 86}, {26, 164, 0}} ,{{142, 86}, {30, 164, 0}} ,{{143, 86}, {31, 164, 0}} ,{{140, 86}, {28, 164, 0}} ,{{141, 86}, {29, 164, 0}} ,{{139, 86}, {27, 164, 0}} ,{{136, 86}, {24, 164, 0}} ,{{137, 86}, {25, 164, 0}} ,{{149, 86}, {37, 164, 0}} ,{{150, 86}, {38, 164, 0}} ,{{147, 86}, {35, 164, 0}} ,{{148, 86}, {36, 164, 0}} ,{{153, 86}, {41, 164, 0}} ,{{145, 86}, {33, 164, 0}} ,{{146, 86}, {34, 164, 0}} ,{{144, 86}, {32, 164, 0}} ,{{154, 86}, {42, 164, 0}} ,{{156, 86}, {44, 164, 0}} ,{{155, 86}, {43, 164, 0}} ,{{151, 86}, {39, 164, 0}} ,{{152, 86}, {40, 164, 0}} ,{{159, 86}, {47, 164, 0}} ,{{160, 86}, {48, 164, 0}} ,{{157, 86}, {45, 164, 0}} ,{{158, 86}, {46, 164, 0}} ,{{94, 86}, {238, 163, 0}} ,{{95, 86}, {239, 163, 0}} ,{{92, 86}, {236, 163, 0}} ,{{93, 86}, {237, 163, 0}} ,{{98, 86}, {242, 163, 0}} ,{{90, 86}, {234, 163, 0}} ,{{91, 86}, {235, 163, 0}} ,{{88, 86}, {232, 163, 0}} ,{{89, 86}, {233, 163, 0}} ,{{99, 86}, {243, 163, 0}} ,{{101, 86}, {245, 163, 0}} ,{{100, 86}, {244, 163, 0}} ,{{96, 86}, {240, 163, 0}} ,{{97, 86}, {241, 163, 0}} ,{{104, 86}, {248, 163, 0}} ,{{105, 86}, {249, 163, 0}} ,{{107, 86}, {251, 163, 0}} ,{{106, 86}, {250, 163, 0}} ,{{102, 86}, {246, 163, 0}} ,{{103, 86}, {247, 163, 0}} ,{{113, 84}, {1, 162, 0}} ,{{114, 84}, {2, 162, 0}} ,{{111, 84}, {255, 161, 0}} ,{{112, 84}, {0, 162, 0}} ,{{124, 84}, {12, 162, 0}} ,{{125, 84}, {13, 162, 0}} ,{{122, 84}, {10, 162, 0}} ,{{123, 84}, {11, 162, 0}} ,{{106, 84}, {250, 161, 0}} ,{{109, 84}, {253, 161, 0}} ,{{110, 84}, {254, 161, 0}} ,{{108, 84}, {252, 161, 0}} ,{{107, 84}, {251, 161, 0}} ,{{104, 84}, {248, 161, 0}} ,{{105, 84}, {249, 161, 0}} ,{{120, 84}, {8, 162, 0}} ,{{121, 84}, {9, 162, 0}} ,{{118, 84}, {6, 162, 0}} ,{{119, 84}, {7, 162, 0}} ,{{128, 84}, {16, 162, 0}} ,{{116, 84}, {4, 162, 0}} ,{{117, 84}, {5, 162, 0}} ,{{115, 84}, {3, 162, 0}} ,{{129, 84}, {17, 162, 0}} ,{{131, 84}, {19, 162, 0}} ,{{130, 84}, {18, 162, 0}} ,{{126, 84}, {14, 162, 0}} ,{{127, 84}, {15, 162, 0}} ,{{49, 84}, {193, 161, 0}} ,{{50, 84}, {194, 161, 0}} ,{{47, 84}, {191, 161, 0}} ,{{48, 84}, {192, 161, 0}} ,{{60, 84}, {204, 161, 0}} ,{{61, 84}, {205, 161, 0}} ,{{59, 84}, {203, 161, 0}} ,{{41, 84}, {185, 161, 0}} ,{{45, 84}, {189, 161, 0}} ,{{46, 84}, {190, 161, 0}} ,{{43, 84}, {187, 161, 0}} ,{{44, 84}, {188, 161, 0}} ,{{42, 84}, {186, 161, 0}} ,{{39, 84}, {183, 161, 0}} ,{{40, 84}, {184, 161, 0}} ,{{57, 84}, {201, 161, 0}} ,{{58, 84}, {202, 161, 0}} ,{{55, 84}, {199, 161, 0}} ,{{56, 84}, {200, 161, 0}} ,{{64, 84}, {208, 161, 0}} ,{{53, 84}, {197, 161, 0}} ,{{54, 84}, {198, 161, 0}} ,{{51, 84}, {195, 161, 0}} ,{{52, 84}, {196, 161, 0}} ,{{65, 84}, {209, 161, 0}} ,{{67, 84}, {211, 161, 0}} ,{{66, 84}, {210, 161, 0}} ,{{62, 84}, {206, 161, 0}} ,{{63, 84}, {207, 161, 0}} ,{{70, 84}, {214, 161, 0}} ,{{71, 84}, {215, 161, 0}} ,{{73, 84}, {217, 161, 0}} ,{{72, 84}, {216, 161, 0}} ,{{68, 84}, {212, 161, 0}} ,{{69, 84}, {213, 161, 0}} ,{{39, 83}, {183, 160, 0}} ,{{40, 83}, {184, 160, 0}} ,{{37, 83}, {181, 160, 0}} ,{{38, 83}, {182, 160, 0}} ,{{50, 83}, {194, 160, 0}} ,{{49, 83}, {193, 160, 0}} ,{{164, 84}, {52, 162, 0}} ,{{165, 84}, {53, 162, 0}} ,{{162, 84}, {50, 162, 0}} ,{{163, 84}, {51, 162, 0}} ,{{174, 84}, {62, 162, 0}} ,{{175, 84}, {63, 162, 0}} ,{{173, 84}, {61, 162, 0}} ,{{161, 84}, {49, 162, 0}} ,{{160, 84}, {48, 162, 0}} ,{{171, 84}, {59, 162, 0}} ,{{172, 84}, {60, 162, 0}} ,{{169, 84}, {57, 162, 0}} ,{{170, 84}, {58, 162, 0}} ,{{178, 84}, {66, 162, 0}} ,{{167, 84}, {55, 162, 0}} ,{{168, 84}, {56, 162, 0}} ,{{166, 84}, {54, 162, 0}} ,{{179, 84}, {67, 162, 0}} ,{{181, 84}, {69, 162, 0}} ,{{180, 84}, {68, 162, 0}} ,{{176, 84}, {64, 162, 0}} ,{{177, 84}, {65, 162, 0}} ,{{32, 83}, {176, 160, 0}} ,{{35, 83}, {179, 160, 0}} ,{{36, 83}, {180, 160, 0}} ,{{34, 83}, {178, 160, 0}} ,{{33, 83}, {177, 160, 0}} ,{{30, 83}, {174, 160, 0}} ,{{31, 83}, {175, 160, 0}} ,{{47, 83}, {191, 160, 0}} ,{{48, 83}, {192, 160, 0}} ,{{45, 83}, {189, 160, 0}} ,{{46, 83}, {190, 160, 0}} ,{{53, 83}, {197, 160, 0}} ,{{43, 83}, {187, 160, 0}} ,{{44, 83}, {188, 160, 0}} ,{{41, 83}, {185, 160, 0}} ,{{42, 83}, {186, 160, 0}} ,{{54, 83}, {198, 160, 0}} ,{{56, 83}, {200, 160, 0}} ,{{55, 83}, {199, 160, 0}} ,{{51, 83}, {195, 160, 0}} ,{{52, 83}, {196, 160, 0}} ,{{59, 83}, {203, 160, 0}} ,{{60, 83}, {204, 160, 0}} ,{{57, 83}, {201, 160, 0}} ,{{58, 83}, {202, 160, 0}} ,{{245, 83}, {133, 161, 0}} ,{{246, 83}, {134, 161, 0}} ,{{244, 83}, {132, 161, 0}} ,{{239, 82}, {127, 160, 0}} ,{{240, 82}, {128, 160, 0}} ,{{237, 82}, {125, 160, 0}} ,{{238, 82}, {126, 160, 0}} ,{{232, 82}, {120, 160, 0}} ,{{235, 82}, {123, 160, 0}} ,{{236, 82}, {124, 160, 0}} ,{{234, 82}, {122, 160, 0}} ,{{233, 82}, {121, 160, 0}} ,{{230, 82}, {118, 160, 0}} ,{{231, 82}, {119, 160, 0}} ,{{243, 82}, {131, 160, 0}} ,{{244, 82}, {132, 160, 0}} ,{{241, 82}, {129, 160, 0}} ,{{242, 82}, {130, 160, 0}} ,{{247, 82}, {135, 160, 0}} ,{{248, 82}, {136, 160, 0}} ,{{250, 82}, {138, 160, 0}} ,{{249, 82}, {137, 160, 0}} ,{{245, 82}, {133, 160, 0}} ,{{246, 82}, {134, 160, 0}} ,{{253, 82}, {141, 160, 0}} ,{{254, 82}, {142, 160, 0}} ,{{0, 83}, {144, 160, 0}} ,{{255, 82}, {143, 160, 0}} ,{{251, 82}, {139, 160, 0}} ,{{252, 82}, {140, 160, 0}} ,{{201, 83}, {89, 161, 0}} ,{{202, 83}, {90, 161, 0}} ,{{199, 83}, {87, 161, 0}} ,{{200, 83}, {88, 161, 0}} ,{{208, 83}, {96, 161, 0}} ,{{209, 83}, {97, 161, 0}} ,{{207, 83}, {95, 161, 0}} ,{{195, 83}, {83, 161, 0}} ,{{198, 83}, {86, 161, 0}} ,{{197, 83}, {85, 161, 0}} ,{{196, 83}, {84, 161, 0}} ,{{193, 83}, {81, 161, 0}} ,{{194, 83}, {82, 161, 0}} ,{{205, 83}, {93, 161, 0}} ,{{206, 83}, {94, 161, 0}} ,{{203, 83}, {91, 161, 0}} ,{{204, 83}, {92, 161, 0}} ,{{212, 83}, {100, 161, 0}} ,{{213, 83}, {101, 161, 0}} ,{{215, 83}, {103, 161, 0}} ,{{214, 83}, {102, 161, 0}} ,{{210, 83}, {98, 161, 0}} ,{{211, 83}, {99, 161, 0}} ,{{255, 83}, {143, 161, 0}} ,{{0, 84}, {144, 161, 0}} ,{{254, 83}, {142, 161, 0}} ,{{210, 84}, {98, 162, 0}} ,{{211, 84}, {99, 162, 0}} ,{{208, 84}, {96, 162, 0}} ,{{209, 84}, {97, 162, 0}} ,{{220, 84}, {108, 162, 0}} ,{{221, 84}, {109, 162, 0}} ,{{219, 84}, {107, 162, 0}} ,{{206, 84}, {94, 162, 0}} ,{{207, 84}, {95, 162, 0}} ,{{205, 84}, {93, 162, 0}} ,{{217, 84}, {105, 162, 0}} ,{{218, 84}, {106, 162, 0}} ,{{215, 84}, {103, 162, 0}} ,{{216, 84}, {104, 162, 0}} ,{{214, 84}, {102, 162, 0}} ,{{212, 84}, {100, 162, 0}} ,{{213, 84}, {101, 162, 0}} ,{{239, 83}, {127, 161, 0}} ,{{242, 83}, {130, 161, 0}} ,{{243, 83}, {131, 161, 0}} ,{{241, 83}, {129, 161, 0}} ,{{240, 83}, {128, 161, 0}} ,{{237, 83}, {125, 161, 0}} ,{{238, 83}, {126, 161, 0}} ,{{163, 86}, {51, 164, 0}} ,{{167, 86}, {55, 164, 0}} ,{{168, 86}, {56, 164, 0}} ,{{165, 86}, {53, 164, 0}} ,{{166, 86}, {54, 164, 0}} ,{{164, 86}, {52, 164, 0}} ,{{161, 86}, {49, 164, 0}} ,{{162, 86}, {50, 164, 0}} ,{{173, 86}, {61, 164, 0}} ,{{174, 86}, {62, 164, 0}} ,{{171, 86}, {59, 164, 0}} ,{{172, 86}, {60, 164, 0}} ,{{176, 86}, {64, 164, 0}} ,{{170, 86}, {58, 164, 0}} ,{{169, 86}, {57, 164, 0}} ,{{177, 86}, {65, 164, 0}} ,{{179, 86}, {67, 164, 0}} ,{{178, 86}, {66, 164, 0}} ,{{175, 86}, {63, 164, 0}} ,{{182, 86}, {70, 164, 0}} ,{{183, 86}, {71, 164, 0}} ,{{185, 86}, {73, 164, 0}} ,{{184, 86}, {72, 164, 0}} ,{{180, 86}, {68, 164, 0}} ,{{181, 86}, {69, 164, 0}} ,{{252, 83}, {140, 161, 0}} ,{{253, 83}, {141, 161, 0}} ,{{250, 83}, {138, 161, 0}} ,{{251, 83}, {139, 161, 0}} ,{{6, 86}, {150, 163, 0}} ,{{7, 86}, {151, 163, 0}} ,{{4, 86}, {148, 163, 0}} ,{{5, 86}, {149, 163, 0}} ,{{13, 86}, {157, 163, 0}} ,{{14, 86}, {158, 163, 0}} ,{{11, 86}, {155, 163, 0}} ,{{12, 86}, {156, 163, 0}} ,{{9, 86}, {153, 163, 0}} ,{{10, 86}, {154, 163, 0}} ,{{8, 86}, {152, 163, 0}} ,{{17, 86}, {161, 163, 0}} ,{{18, 86}, {162, 163, 0}} ,{{20, 86}, {164, 163, 0}} ,{{19, 86}, {163, 163, 0}} ,{{15, 86}, {159, 163, 0}} ,{{16, 86}, {160, 163, 0}} ,{{23, 86}, {167, 163, 0}} ,{{24, 86}, {168, 163, 0}} ,{{26, 86}, {170, 163, 0}} ,{{25, 86}, {169, 163, 0}} ,{{21, 86}, {165, 163, 0}} ,{{22, 86}, {166, 163, 0}} ,{{3, 84}, {147, 161, 0}} ,{{248, 83}, {136, 161, 0}} ,{{249, 83}, {137, 161, 0}} ,{{247, 83}, {135, 161, 0}} ,{{4, 84}, {148, 161, 0}} ,{{6, 84}, {150, 161, 0}} ,{{5, 84}, {149, 161, 0}} ,{{1, 84}, {145, 161, 0}} ,{{2, 84}, {146, 161, 0}} ,{{188, 86}, {76, 164, 0}} ,{{192, 86}, {80, 164, 0}} ,{{193, 86}, {81, 164, 0}} ,{{190, 86}, {78, 164, 0}} ,{{191, 86}, {79, 164, 0}} ,{{189, 86}, {77, 164, 0}} ,{{186, 86}, {74, 164, 0}} ,{{187, 86}, {75, 164, 0}} ,{{199, 86}, {87, 164, 0}} ,{{200, 86}, {88, 164, 0}} ,{{197, 86}, {85, 164, 0}} ,{{198, 86}, {86, 164, 0}} ,{{203, 86}, {91, 164, 0}} ,{{195, 86}, {83, 164, 0}} ,{{196, 86}, {84, 164, 0}} ,{{194, 86}, {82, 164, 0}} ,{{204, 86}, {92, 164, 0}} ,{{201, 86}, {89, 164, 0}} ,{{202, 86}, {90, 164, 0}} ,{{102, 85}, {246, 162, 0}} ,{{103, 85}, {247, 162, 0}} ,{{100, 85}, {244, 162, 0}} ,{{101, 85}, {245, 162, 0}} ,{{109, 85}, {253, 162, 0}} ,{{108, 85}, {252, 162, 0}} ,{{95, 85}, {239, 162, 0}} ,{{98, 85}, {242, 162, 0}} ,{{99, 85}, {243, 162, 0}} ,{{97, 85}, {241, 162, 0}} ,{{96, 85}, {240, 162, 0}} ,{{93, 85}, {237, 162, 0}} ,{{94, 85}, {238, 162, 0}} ,{{107, 85}, {251, 162, 0}} ,{{106, 85}, {250, 162, 0}} ,{{111, 85}, {255, 162, 0}} ,{{105, 85}, {249, 162, 0}} ,{{104, 85}, {248, 162, 0}} ,{{112, 85}, {0, 163, 0}} ,{{114, 85}, {2, 163, 0}} ,{{113, 85}, {1, 163, 0}} ,{{110, 85}, {254, 162, 0}} ,{{117, 85}, {5, 163, 0}} ,{{118, 85}, {6, 163, 0}} ,{{120, 85}, {8, 163, 0}} ,{{119, 85}, {7, 163, 0}} ,{{115, 85}, {3, 163, 0}} ,{{116, 85}, {4, 163, 0}} ,{{129, 82}, {17, 160, 0}} ,{{130, 82}, {18, 160, 0}} ,{{127, 82}, {15, 160, 0}} ,{{128, 82}, {16, 160, 0}} ,{{177, 82}, {65, 160, 0}} ,{{178, 82}, {66, 160, 0}} ,{{175, 82}, {63, 160, 0}} ,{{176, 82}, {64, 160, 0}} ,{{170, 82}, {58, 160, 0}} ,{{173, 82}, {61, 160, 0}} ,{{174, 82}, {62, 160, 0}} ,{{172, 82}, {60, 160, 0}} ,{{171, 82}, {59, 160, 0}} ,{{168, 82}, {56, 160, 0}} ,{{169, 82}, {57, 160, 0}} ,{{184, 82}, {72, 160, 0}} ,{{185, 82}, {73, 160, 0}} ,{{182, 82}, {70, 160, 0}} ,{{183, 82}, {71, 160, 0}} ,{{188, 82}, {76, 160, 0}} ,{{180, 82}, {68, 160, 0}} ,{{181, 82}, {69, 160, 0}} ,{{179, 82}, {67, 160, 0}} ,{{189, 82}, {77, 160, 0}} ,{{191, 82}, {79, 160, 0}} ,{{190, 82}, {78, 160, 0}} ,{{186, 82}, {74, 160, 0}} ,{{187, 82}, {75, 160, 0}} ,{{194, 82}, {82, 160, 0}} ,{{195, 82}, {83, 160, 0}} ,{{197, 82}, {85, 160, 0}} ,{{196, 82}, {84, 160, 0}} ,{{192, 82}, {80, 160, 0}} ,{{193, 82}, {81, 160, 0}} ,{{110, 86}, {254, 163, 0}} ,{{114, 86}, {2, 164, 0}} ,{{115, 86}, {3, 164, 0}} ,{{112, 86}, {0, 164, 0}} ,{{113, 86}, {1, 164, 0}} ,{{111, 86}, {255, 163, 0}} ,{{108, 86}, {252, 163, 0}} ,{{109, 86}, {253, 163, 0}} ,{{122, 86}, {10, 164, 0}} ,{{123, 86}, {11, 164, 0}} ,{{120, 86}, {8, 164, 0}} ,{{121, 86}, {9, 164, 0}} ,{{126, 86}, {14, 164, 0}} ,{{118, 86}, {6, 164, 0}} ,{{119, 86}, {7, 164, 0}} ,{{116, 86}, {4, 164, 0}} ,{{117, 86}, {5, 164, 0}} ,{{127, 86}, {15, 164, 0}} ,{{129, 86}, {17, 164, 0}} ,{{128, 86}, {16, 164, 0}} ,{{124, 86}, {12, 164, 0}} ,{{125, 86}, {13, 164, 0}} ,{{132, 86}, {20, 164, 0}} ,{{133, 86}, {21, 164, 0}} ,{{135, 86}, {23, 164, 0}} ,{{134, 86}, {22, 164, 0}} ,{{130, 86}, {18, 164, 0}} ,{{131, 86}, {19, 164, 0}} ,{{56, 86}, {200, 163, 0}} ,{{57, 86}, {201, 163, 0}} ,{{54, 86}, {198, 163, 0}} ,{{55, 86}, {199, 163, 0}} ,{{66, 86}, {210, 163, 0}} ,{{67, 86}, {211, 163, 0}} ,{{65, 86}, {209, 163, 0}} ,{{63, 86}, {207, 163, 0}} ,{{64, 86}, {208, 163, 0}} ,{{61, 86}, {205, 163, 0}} ,{{62, 86}, {206, 163, 0}} ,{{237, 85}, {125, 163, 0}} ,{{236, 85}, {124, 163, 0}} ,{{246, 85}, {134, 163, 0}} ,{{247, 85}, {135, 163, 0}} ,{{244, 85}, {132, 163, 0}} ,{{245, 85}, {133, 163, 0}} ,{{242, 85}, {130, 163, 0}} ,{{243, 85}, {131, 163, 0}} ,{{240, 85}, {128, 163, 0}} ,{{241, 85}, {129, 163, 0}} ,{{250, 85}, {138, 163, 0}} ,{{239, 85}, {127, 163, 0}} ,{{238, 85}, {126, 163, 0}} ,{{251, 85}, {139, 163, 0}} ,{{253, 85}, {141, 163, 0}} ,{{252, 85}, {140, 163, 0}} ,{{248, 85}, {136, 163, 0}} ,{{249, 85}, {137, 163, 0}} ,{{0, 86}, {144, 163, 0}} ,{{1, 86}, {145, 163, 0}} ,{{3, 86}, {147, 163, 0}} ,{{2, 86}, {146, 163, 0}} ,{{254, 85}, {142, 163, 0}} ,{{255, 85}, {143, 163, 0}} ,{{70, 86}, {214, 163, 0}} ,{{59, 86}, {203, 163, 0}} ,{{60, 86}, {204, 163, 0}} ,{{58, 86}, {202, 163, 0}} ,{{71, 86}, {215, 163, 0}} ,{{73, 86}, {217, 163, 0}} ,{{72, 86}, {216, 163, 0}} ,{{68, 86}, {212, 163, 0}} ,{{69, 86}, {213, 163, 0}} ,{{76, 86}, {220, 163, 0}} ,{{77, 86}, {221, 163, 0}} ,{{79, 86}, {223, 163, 0}} ,{{78, 86}, {222, 163, 0}} ,{{74, 86}, {218, 163, 0}} ,{{75, 86}, {219, 163, 0}} ,{{130, 85}, {18, 163, 0}} ,{{131, 85}, {19, 163, 0}} ,{{128, 85}, {16, 163, 0}} ,{{129, 85}, {17, 163, 0}} ,{{140, 85}, {28, 163, 0}} ,{{141, 85}, {29, 163, 0}} ,{{139, 85}, {27, 163, 0}} ,{{29, 86}, {173, 163, 0}} ,{{30, 86}, {174, 163, 0}} ,{{27, 86}, {171, 163, 0}} ,{{28, 86}, {172, 163, 0}} ,{{40, 86}, {184, 163, 0}} ,{{41, 86}, {185, 163, 0}} ,{{38, 86}, {182, 163, 0}} ,{{39, 86}, {183, 163, 0}} ,{{36, 86}, {180, 163, 0}} ,{{37, 86}, {181, 163, 0}} ,{{34, 86}, {178, 163, 0}} ,{{35, 86}, {179, 163, 0}} ,{{44, 86}, {188, 163, 0}} ,{{32, 86}, {176, 163, 0}} ,{{33, 86}, {177, 163, 0}} ,{{31, 86}, {175, 163, 0}} ,{{45, 86}, {189, 163, 0}} ,{{47, 86}, {191, 163, 0}} ,{{46, 86}, {190, 163, 0}} ,{{42, 86}, {186, 163, 0}} ,{{43, 86}, {187, 163, 0}} ,{{50, 86}, {194, 163, 0}} ,{{51, 86}, {195, 163, 0}} ,{{53, 86}, {197, 163, 0}} ,{{52, 86}, {196, 163, 0}} ,{{48, 86}, {192, 163, 0}} ,{{49, 86}, {193, 163, 0}} ,{{123, 85}, {11, 163, 0}} ,{{126, 85}, {14, 163, 0}} ,{{127, 85}, {15, 163, 0}} ,{{125, 85}, {13, 163, 0}} ,{{124, 85}, {12, 163, 0}} ,{{121, 85}, {9, 163, 0}} ,{{122, 85}, {10, 163, 0}} ,{{137, 85}, {25, 163, 0}} ,{{138, 85}, {26, 163, 0}} ,{{135, 85}, {23, 163, 0}} ,{{136, 85}, {24, 163, 0}} ,{{163, 85}, {51, 163, 0}} ,{{164, 85}, {52, 163, 0}} ,{{161, 85}, {49, 163, 0}} ,{{162, 85}, {50, 163, 0}} ,{{170, 85}, {58, 163, 0}} ,{{171, 85}, {59, 163, 0}} ,{{169, 85}, {57, 163, 0}} ,{{156, 85}, {44, 163, 0}} ,{{159, 85}, {47, 163, 0}} ,{{160, 85}, {48, 163, 0}} ,{{158, 85}, {46, 163, 0}} ,{{157, 85}, {45, 163, 0}} ,{{154, 85}, {42, 163, 0}} ,{{155, 85}, {43, 163, 0}} ,{{167, 85}, {55, 163, 0}} ,{{168, 85}, {56, 163, 0}} ,{{165, 85}, {53, 163, 0}} ,{{166, 85}, {54, 163, 0}} ,{{174, 85}, {62, 163, 0}} ,{{175, 85}, {63, 163, 0}} ,{{172, 85}, {60, 163, 0}} ,{{173, 85}, {61, 163, 0}} ,{{178, 85}, {66, 163, 0}} ,{{179, 85}, {67, 163, 0}} ,{{181, 85}, {69, 163, 0}} ,{{180, 85}, {68, 163, 0}} ,{{176, 85}, {64, 163, 0}} ,{{177, 85}, {65, 163, 0}} ,{{144, 85}, {32, 163, 0}} ,{{133, 85}, {21, 163, 0}} ,{{134, 85}, {22, 163, 0}} ,{{132, 85}, {20, 163, 0}} ,{{145, 85}, {33, 163, 0}} ,{{147, 85}, {35, 163, 0}} ,{{146, 85}, {34, 163, 0}} ,{{142, 85}, {30, 163, 0}} ,{{143, 85}, {31, 163, 0}} ,{{150, 85}, {38, 163, 0}} ,{{151, 85}, {39, 163, 0}} ,{{153, 85}, {41, 163, 0}} ,{{152, 85}, {40, 163, 0}} ,{{148, 85}, {36, 163, 0}} ,{{149, 85}, {37, 163, 0}} ,{{147, 83}, {35, 161, 0}} ,{{148, 83}, {36, 161, 0}} ,{{145, 83}, {33, 161, 0}} ,{{146, 83}, {34, 161, 0}} ,{{158, 83}, {46, 161, 0}} ,{{159, 83}, {47, 161, 0}} ,{{157, 83}, {45, 161, 0}} ,{{140, 83}, {28, 161, 0}} ,{{143, 83}, {31, 161, 0}} ,{{144, 83}, {32, 161, 0}} ,{{142, 83}, {30, 161, 0}} ,{{141, 83}, {29, 161, 0}} ,{{138, 83}, {26, 161, 0}} ,{{139, 83}, {27, 161, 0}} ,{{155, 83}, {43, 161, 0}} ,{{156, 83}, {44, 161, 0}} ,{{153, 83}, {41, 161, 0}} ,{{154, 83}, {42, 161, 0}} ,{{162, 83}, {50, 161, 0}} ,{{151, 83}, {39, 161, 0}} ,{{152, 83}, {40, 161, 0}} ,{{149, 83}, {37, 161, 0}} ,{{150, 83}, {38, 161, 0}} ,{{163, 83}, {51, 161, 0}} ,{{165, 83}, {53, 161, 0}} ,{{164, 83}, {52, 161, 0}} ,{{160, 83}, {48, 161, 0}} ,{{161, 83}, {49, 161, 0}} ,{{125, 82}, {13, 160, 0}} ,{{126, 82}, {14, 160, 0}} ,{{124, 82}, {12, 160, 0}} ,{{92, 83}, {236, 160, 0}} ,{{93, 83}, {237, 160, 0}} ,{{90, 83}, {234, 160, 0}} ,{{91, 83}, {235, 160, 0}} ,{{99, 83}, {243, 160, 0}} ,{{98, 83}, {242, 160, 0}} ,{{84, 83}, {228, 160, 0}} ,{{88, 83}, {232, 160, 0}} ,{{89, 83}, {233, 160, 0}} ,{{86, 83}, {230, 160, 0}} ,{{87, 83}, {231, 160, 0}} ,{{85, 83}, {229, 160, 0}} ,{{82, 83}, {226, 160, 0}} ,{{83, 83}, {227, 160, 0}} ,{{96, 83}, {240, 160, 0}} ,{{97, 83}, {241, 160, 0}} ,{{94, 83}, {238, 160, 0}} ,{{95, 83}, {239, 160, 0}} ,{{102, 83}, {246, 160, 0}} ,{{103, 83}, {247, 160, 0}} ,{{105, 83}, {249, 160, 0}} ,{{104, 83}, {248, 160, 0}} ,{{100, 83}, {244, 160, 0}} ,{{101, 83}, {245, 160, 0}} ,{{108, 83}, {252, 160, 0}} ,{{109, 83}, {253, 160, 0}} ,{{111, 83}, {255, 160, 0}} ,{{110, 83}, {254, 160, 0}} ,{{106, 83}, {250, 160, 0}} ,{{107, 83}, {251, 160, 0}} ,{{242, 84}, {130, 162, 0}} ,{{243, 84}, {131, 162, 0}} ,{{240, 84}, {128, 162, 0}} ,{{241, 84}, {129, 162, 0}} ,{{251, 84}, {139, 162, 0}} ,{{252, 84}, {140, 162, 0}} ,{{250, 84}, {138, 162, 0}} ,{{248, 84}, {136, 162, 0}} ,{{249, 84}, {137, 162, 0}} ,{{247, 84}, {135, 162, 0}} ,{{133, 82}, {21, 160, 0}} ,{{245, 84}, {133, 162, 0}} ,{{246, 84}, {134, 162, 0}} ,{{244, 84}, {132, 162, 0}} ,{{207, 86}, {95, 164, 0}} ,{{211, 86}, {99, 164, 0}} ,{{212, 86}, {100, 164, 0}} ,{{209, 86}, {97, 164, 0}} ,{{210, 86}, {98, 164, 0}} ,{{208, 86}, {96, 164, 0}} ,{{205, 86}, {93, 164, 0}} ,{{206, 86}, {94, 164, 0}} ,{{217, 86}, {105, 164, 0}} ,{{218, 86}, {106, 164, 0}} ,{{215, 86}, {103, 164, 0}} ,{{216, 86}, {104, 164, 0}} ,{{214, 86}, {102, 164, 0}} ,{{213, 86}, {101, 164, 0}} ,{{221, 86}, {109, 164, 0}} ,{{222, 86}, {110, 164, 0}} ,{{224, 86}, {112, 164, 0}} ,{{223, 86}, {111, 164, 0}} ,{{219, 86}, {107, 164, 0}} ,{{220, 86}, {108, 164, 0}} ,{{227, 86}, {115, 164, 0}} ,{{231, 86}, {119, 164, 0}} ,{{232, 86}, {120, 164, 0}} ,{{229, 86}, {117, 164, 0}} ,{{230, 86}, {118, 164, 0}} ,{{228, 86}, {116, 164, 0}} ,{{225, 86}, {113, 164, 0}} ,{{226, 86}, {114, 164, 0}} ,{{239, 86}, {127, 164, 0}} ,{{240, 86}, {128, 164, 0}} ,{{237, 86}, {125, 164, 0}} ,{{238, 86}, {126, 164, 0}} ,{{243, 86}, {131, 164, 0}} ,{{235, 86}, {123, 164, 0}} ,{{236, 86}, {124, 164, 0}} ,{{233, 86}, {121, 164, 0}} ,{{234, 86}, {122, 164, 0}} ,{{244, 86}, {132, 164, 0}} ,{{246, 86}, {134, 164, 0}} ,{{245, 86}, {133, 164, 0}} ,{{241, 86}, {129, 164, 0}} ,{{242, 86}, {130, 164, 0}} ,{{249, 86}, {137, 164, 0}} ,{{250, 86}, {138, 164, 0}} ,{{252, 86}, {140, 164, 0}} ,{{251, 86}, {139, 164, 0}} ,{{247, 86}, {135, 164, 0}} ,{{248, 86}, {136, 164, 0}} ,{{6, 85}, {150, 162, 0}} ,{{7, 85}, {151, 162, 0}} ,{{4, 85}, {148, 162, 0}} ,{{5, 85}, {149, 162, 0}} ,{{16, 85}, {160, 162, 0}} ,{{17, 85}, {161, 162, 0}} ,{{15, 85}, {159, 162, 0}} ,{{184, 85}, {72, 163, 0}} ,{{185, 85}, {73, 163, 0}} ,{{182, 85}, {70, 163, 0}} ,{{183, 85}, {71, 163, 0}} ,{{195, 85}, {83, 163, 0}} ,{{196, 85}, {84, 163, 0}} ,{{193, 85}, {81, 163, 0}} ,{{194, 85}, {82, 163, 0}} ,{{191, 85}, {79, 163, 0}} ,{{192, 85}, {80, 163, 0}} ,{{189, 85}, {77, 163, 0}} ,{{190, 85}, {78, 163, 0}} ,{{199, 85}, {87, 163, 0}} ,{{187, 85}, {75, 163, 0}} ,{{188, 85}, {76, 163, 0}} ,{{186, 85}, {74, 163, 0}} ,{{200, 85}, {88, 163, 0}} ,{{202, 85}, {90, 163, 0}} ,{{201, 85}, {89, 163, 0}} ,{{197, 85}, {85, 163, 0}} ,{{198, 85}, {86, 163, 0}} ,{{205, 85}, {93, 163, 0}} ,{{206, 85}, {94, 163, 0}} ,{{208, 85}, {96, 163, 0}} ,{{207, 85}, {95, 163, 0}} ,{{203, 85}, {91, 163, 0}} ,{{204, 85}, {92, 163, 0}} ,{{255, 84}, {143, 162, 0}} ,{{2, 85}, {146, 162, 0}} ,{{3, 85}, {147, 162, 0}} ,{{1, 85}, {145, 162, 0}} ,{{0, 85}, {144, 162, 0}} ,{{253, 84}, {141, 162, 0}} ,{{254, 84}, {142, 162, 0}} ,{{13, 85}, {157, 162, 0}} ,{{14, 85}, {158, 162, 0}} ,{{11, 85}, {155, 162, 0}} ,{{12, 85}, {156, 162, 0}} ,{{20, 85}, {164, 162, 0}} ,{{9, 85}, {153, 162, 0}} ,{{10, 85}, {154, 162, 0}} ,{{8, 85}, {152, 162, 0}} ,{{21, 85}, {165, 162, 0}} ,{{23, 85}, {167, 162, 0}} ,{{22, 85}, {166, 162, 0}} ,{{18, 85}, {162, 162, 0}} ,{{19, 85}, {163, 162, 0}} ,{{26, 85}, {170, 162, 0}} ,{{27, 85}, {171, 162, 0}} ,{{29, 85}, {173, 162, 0}} ,{{28, 85}, {172, 162, 0}} ,{{24, 85}, {168, 162, 0}} ,{{25, 85}, {169, 162, 0}} ,{{74, 85}, {218, 162, 0}} ,{{75, 85}, {219, 162, 0}} ,{{72, 85}, {216, 162, 0}} ,{{73, 85}, {217, 162, 0}} ,{{80, 85}, {224, 162, 0}} ,{{81, 85}, {225, 162, 0}} ,{{79, 85}, {223, 162, 0}} ,{{66, 85}, {210, 162, 0}} ,{{70, 85}, {214, 162, 0}} ,{{71, 85}, {215, 162, 0}} ,{{68, 85}, {212, 162, 0}} ,{{69, 85}, {213, 162, 0}} ,{{67, 85}, {211, 162, 0}} ,{{64, 85}, {208, 162, 0}} ,{{65, 85}, {209, 162, 0}} ,{{77, 85}, {221, 162, 0}} ,{{78, 85}, {222, 162, 0}} ,{{76, 85}, {220, 162, 0}} ,{{83, 85}, {227, 162, 0}} ,{{84, 85}, {228, 162, 0}} ,{{86, 85}, {230, 162, 0}} ,{{85, 85}, {229, 162, 0}} ,{{82, 85}, {226, 162, 0}} ,{{89, 85}, {233, 162, 0}} ,{{90, 85}, {234, 162, 0}} ,{{92, 85}, {236, 162, 0}} ,{{91, 85}, {235, 162, 0}} ,{{87, 85}, {231, 162, 0}} ,{{88, 85}, {232, 162, 0}} ,{{93, 64}, {13, 32, 0}} ,{{149, 141}, {255, 254, 0}} ,{{92, 64}, {12, 32, 0}} ,{{91, 64}, {11, 32, 0}} ,{{16, 67}, {255, 34, 0}} ,{{21, 74}, {100, 42, 0}} ,{{58, 73}, {137, 41, 0}} ,{{56, 73}, {135, 41, 0}} ,{{22, 74}, {101, 42, 0}} ,{{239, 73}, {62, 42, 0}} ,{{59, 73}, {138, 41, 0}} ,{{57, 73}, {136, 41, 0}} ,{{208, 73}, {31, 42, 0}} ,{{209, 73}, {32, 42, 0}} ,{{210, 73}, {33, 42, 0}} ,{{50, 73}, {129, 41, 0}} ,{{51, 73}, {130, 41, 0}} }; ecl-16.1.2/src/c/unicode/ucd_names_pair.c000066400000000000000000026550071266352375300201530ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* * Pairs of symbols. */ #include #include "ucd_names.h" const ecl_ucd_names_pair_type ecl_ucd_names_pair[ECL_UCD_TOTAL_PAIRS] = { {1, 0, 0, 0} ,{2, 0, 3, 0} ,{4, 0, 3, 0} ,{5, 0, 6, 0} ,{7, 0, 6, 0} ,{8, 0, 6, 0} ,{9, 0, 0, 0} ,{10, 0, 0, 0} ,{11, 0, 12, 0} ,{13, 0, 12, 0} ,{14, 0, 0, 0} ,{15, 0, 6, 0} ,{16, 0, 0, 0} ,{17, 0, 18, 0} ,{19, 0, 20, 0} ,{21, 0, 0, 0} ,{22, 0, 23, 0} ,{22, 0, 24, 0} ,{22, 0, 25, 0} ,{22, 0, 26, 0} ,{22, 0, 27, 0} ,{22, 0, 28, 0} ,{22, 0, 29, 0} ,{22, 0, 30, 0} ,{22, 0, 31, 0} ,{22, 0, 32, 0} ,{33, 0, 0, 0} ,{34, 0, 0, 0} ,{75, 167, 6, 0} ,{37, 0, 6, 0} ,{70, 167, 6, 0} ,{39, 0, 3, 0} ,{40, 0, 41, 0} ,{146, 166, 45, 0} ,{146, 166, 46, 0} ,{146, 166, 47, 0} ,{146, 166, 48, 0} ,{146, 166, 49, 0} ,{146, 166, 50, 0} ,{146, 166, 51, 0} ,{146, 166, 52, 0} ,{146, 166, 53, 0} ,{146, 166, 54, 0} ,{146, 166, 55, 0} ,{146, 166, 56, 0} ,{146, 166, 57, 0} ,{146, 166, 58, 0} ,{146, 166, 59, 0} ,{146, 166, 60, 0} ,{146, 166, 61, 0} ,{146, 166, 62, 0} ,{146, 166, 63, 0} ,{146, 166, 64, 0} ,{146, 166, 65, 0} ,{146, 166, 66, 0} ,{146, 166, 67, 0} ,{146, 166, 68, 0} ,{146, 166, 69, 0} ,{146, 166, 70, 0} ,{11, 0, 103, 168} ,{73, 0, 21, 0} ,{13, 0, 103, 168} ,{74, 0, 75, 0} ,{76, 0, 77, 0} ,{78, 0, 75, 0} ,{126, 166, 45, 0} ,{126, 166, 46, 0} ,{126, 166, 47, 0} ,{126, 166, 48, 0} ,{126, 166, 49, 0} ,{126, 166, 50, 0} ,{126, 166, 51, 0} ,{126, 166, 52, 0} ,{126, 166, 53, 0} ,{126, 166, 54, 0} ,{126, 166, 55, 0} ,{126, 166, 56, 0} ,{126, 166, 57, 0} ,{126, 166, 58, 0} ,{126, 166, 59, 0} ,{126, 166, 60, 0} ,{126, 166, 61, 0} ,{126, 166, 62, 0} ,{126, 166, 63, 0} ,{126, 166, 64, 0} ,{126, 166, 65, 0} ,{126, 166, 66, 0} ,{126, 166, 67, 0} ,{126, 166, 68, 0} ,{126, 166, 69, 0} ,{126, 166, 70, 0} ,{11, 0, 133, 168} ,{81, 0, 77, 0} ,{13, 0, 133, 168} ,{82, 0, 0, 0} ,{161, 173, 1, 0} ,{85, 0, 228, 37} ,{86, 0, 6, 0} ,{87, 0, 6, 0} ,{88, 0, 6, 0} ,{89, 0, 6, 0} ,{90, 0, 91, 0} ,{92, 0, 6, 0} ,{93, 0, 0, 0} ,{94, 0, 6, 0} ,{95, 0, 1, 174} ,{144, 168, 2, 174} ,{102, 0, 6, 0} ,{103, 0, 104, 0} ,{105, 0, 6, 0} ,{106, 0, 0, 0} ,{107, 0, 6, 0} ,{108, 0, 35, 66} ,{110, 0, 25, 0} ,{110, 0, 26, 0} ,{111, 0, 75, 0} ,{112, 0, 6, 0} ,{113, 0, 6, 0} ,{114, 0, 115, 0} ,{116, 0, 0, 0} ,{110, 0, 24, 0} ,{117, 0, 1, 174} ,{74, 168, 2, 174} ,{82, 169, 122, 0} ,{82, 169, 123, 0} ,{246, 172, 125, 0} ,{85, 0, 2, 38} ,{153, 167, 128, 0} ,{153, 167, 129, 0} ,{153, 167, 130, 0} ,{153, 167, 82, 0} ,{153, 167, 93, 0} ,{153, 167, 124, 40} ,{146, 166, 133, 0} ,{147, 169, 248, 167} ,{196, 167, 128, 0} ,{196, 167, 129, 0} ,{196, 167, 130, 0} ,{196, 167, 93, 0} ,{113, 168, 128, 0} ,{113, 168, 129, 0} ,{113, 168, 130, 0} ,{113, 168, 93, 0} ,{146, 166, 137, 0} ,{231, 169, 82, 0} ,{90, 167, 128, 0} ,{90, 167, 129, 0} ,{90, 167, 130, 0} ,{90, 167, 82, 0} ,{90, 167, 93, 0} ,{140, 0, 6, 0} ,{90, 167, 141, 0} ,{131, 167, 128, 0} ,{131, 167, 129, 0} ,{131, 167, 130, 0} ,{131, 167, 93, 0} ,{169, 168, 162, 167} ,{146, 166, 144, 0} ,{126, 166, 57, 175} ,{132, 167, 128, 0} ,{132, 167, 129, 0} ,{132, 167, 130, 0} ,{132, 167, 82, 0} ,{132, 167, 93, 0} ,{132, 167, 124, 40} ,{126, 166, 133, 0} ,{68, 169, 248, 167} ,{167, 167, 128, 0} ,{167, 167, 129, 0} ,{167, 167, 130, 0} ,{167, 167, 93, 0} ,{86, 168, 128, 0} ,{86, 168, 129, 0} ,{86, 168, 130, 0} ,{86, 168, 93, 0} ,{126, 166, 137, 0} ,{149, 169, 82, 0} ,{91, 167, 128, 0} ,{91, 167, 129, 0} ,{91, 167, 130, 0} ,{91, 167, 82, 0} ,{91, 167, 93, 0} ,{146, 0, 6, 0} ,{91, 167, 141, 0} ,{123, 167, 128, 0} ,{123, 167, 129, 0} ,{123, 167, 130, 0} ,{123, 167, 93, 0} ,{136, 168, 162, 167} ,{126, 166, 144, 0} ,{136, 168, 0, 168} ,{153, 167, 106, 0} ,{132, 167, 106, 0} ,{153, 167, 147, 0} ,{132, 167, 147, 0} ,{153, 167, 148, 0} ,{132, 167, 148, 0} ,{147, 169, 162, 167} ,{68, 169, 162, 167} ,{147, 169, 67, 168} ,{68, 169, 67, 168} ,{147, 169, 233, 166} ,{68, 169, 233, 166} ,{147, 169, 141, 167} ,{68, 169, 141, 167} ,{201, 168, 141, 167} ,{111, 168, 141, 167} ,{201, 168, 28, 167} ,{111, 168, 28, 167} ,{196, 167, 106, 0} ,{167, 167, 106, 0} ,{196, 167, 147, 0} ,{167, 167, 147, 0} ,{146, 166, 3, 174} ,{126, 166, 3, 174} ,{196, 167, 148, 0} ,{167, 167, 148, 0} ,{196, 167, 150, 0} ,{167, 167, 150, 0} ,{69, 169, 67, 168} ,{255, 168, 67, 168} ,{69, 169, 45, 170} ,{255, 168, 45, 170} ,{69, 169, 233, 166} ,{255, 168, 233, 166} ,{69, 169, 248, 167} ,{255, 168, 248, 167} ,{92, 169, 67, 168} ,{208, 168, 67, 168} ,{92, 169, 28, 167} ,{208, 168, 28, 167} ,{113, 168, 82, 0} ,{86, 168, 82, 0} ,{113, 168, 106, 0} ,{86, 168, 106, 0} ,{113, 168, 147, 0} ,{86, 168, 147, 0} ,{113, 168, 148, 0} ,{86, 168, 148, 0} ,{61, 175, 233, 166} ,{42, 171, 53, 0} ,{4, 174, 156, 0} ,{108, 169, 156, 0} ,{97, 178, 67, 168} ,{43, 171, 67, 168} ,{28, 169, 248, 167} ,{214, 168, 248, 167} ,{126, 166, 159, 0} ,{124, 168, 162, 167} ,{53, 168, 162, 167} ,{124, 168, 248, 167} ,{53, 168, 248, 167} ,{124, 168, 141, 167} ,{53, 168, 141, 167} ,{124, 168, 3, 173} ,{53, 168, 3, 173} ,{124, 168, 28, 167} ,{53, 168, 28, 167} ,{196, 170, 162, 167} ,{148, 169, 162, 167} ,{196, 170, 248, 167} ,{148, 169, 248, 167} ,{196, 170, 141, 167} ,{148, 169, 141, 167} ,{99, 178, 10, 0} ,{146, 166, 163, 0} ,{126, 166, 163, 0} ,{90, 167, 106, 0} ,{91, 167, 106, 0} ,{90, 167, 147, 0} ,{91, 167, 147, 0} ,{90, 167, 227, 169} ,{91, 167, 227, 169} ,{4, 174, 164, 0} ,{108, 169, 164, 0} ,{184, 168, 162, 167} ,{54, 168, 162, 167} ,{184, 168, 248, 167} ,{54, 168, 248, 167} ,{184, 168, 141, 167} ,{54, 168, 141, 167} ,{209, 168, 162, 167} ,{112, 168, 162, 167} ,{209, 168, 67, 168} ,{112, 168, 67, 168} ,{209, 168, 248, 167} ,{112, 168, 248, 167} ,{209, 168, 141, 167} ,{112, 168, 141, 167} ,{202, 168, 248, 167} ,{95, 168, 248, 167} ,{202, 168, 141, 167} ,{95, 168, 141, 167} ,{202, 168, 28, 167} ,{95, 168, 28, 167} ,{131, 167, 82, 0} ,{123, 167, 82, 0} ,{131, 167, 106, 0} ,{123, 167, 106, 0} ,{131, 167, 147, 0} ,{123, 167, 147, 0} ,{131, 167, 124, 40} ,{123, 167, 124, 40} ,{131, 167, 227, 169} ,{123, 167, 227, 169} ,{131, 167, 148, 0} ,{123, 167, 148, 0} ,{250, 169, 67, 168} ,{178, 169, 67, 168} ,{169, 168, 67, 168} ,{136, 168, 67, 168} ,{169, 168, 0, 168} ,{19, 169, 162, 167} ,{121, 168, 162, 167} ,{19, 169, 233, 166} ,{121, 168, 233, 166} ,{19, 169, 141, 167} ,{121, 168, 141, 167} ,{108, 171, 63, 0} ,{146, 169, 28, 167} ,{63, 170, 48, 167} ,{63, 170, 39, 171} ,{146, 169, 39, 171} ,{102, 172, 29, 0} ,{103, 172, 29, 0} ,{146, 166, 190, 170} ,{147, 169, 48, 167} ,{68, 169, 48, 167} ,{100, 178, 48, 0} ,{201, 168, 48, 167} ,{201, 168, 39, 171} ,{111, 168, 39, 171} ,{192, 167, 178, 0} ,{146, 166, 19, 175} ,{146, 166, 180, 0} ,{146, 166, 67, 169} ,{48, 175, 48, 167} ,{99, 171, 48, 167} ,{69, 169, 48, 167} ,{146, 166, 182, 0} ,{126, 166, 183, 0} ,{146, 166, 184, 0} ,{146, 166, 193, 170} ,{28, 169, 48, 167} ,{214, 168, 48, 167} ,{53, 168, 148, 172} ,{101, 178, 28, 167} ,{123, 170, 57, 0} ,{231, 169, 219, 172} ,{149, 169, 17, 174} ,{90, 167, 25, 175} ,{90, 167, 187, 0} ,{91, 167, 187, 0} ,{146, 166, 188, 0} ,{126, 166, 188, 0} ,{254, 169, 48, 167} ,{97, 169, 48, 167} ,{225, 166, 190, 0} ,{102, 172, 25, 0} ,{103, 172, 25, 0} ,{146, 166, 191, 0} ,{102, 178, 193, 0} ,{95, 168, 26, 168} ,{202, 168, 48, 167} ,{95, 168, 48, 167} ,{202, 168, 254, 168} ,{131, 167, 187, 0} ,{123, 167, 187, 0} ,{146, 166, 196, 0} ,{15, 172, 48, 167} ,{169, 168, 48, 167} ,{136, 168, 48, 167} ,{19, 169, 28, 167} ,{121, 168, 28, 167} ,{146, 166, 198, 0} ,{9, 174, 200, 0} ,{192, 170, 200, 0} ,{192, 170, 52, 168} ,{103, 178, 28, 167} ,{102, 172, 28, 0} ,{103, 172, 28, 0} ,{20, 174, 107, 172} ,{225, 166, 205, 0} ,{104, 178, 207, 0} ,{105, 178, 207, 0} ,{106, 178, 207, 0} ,{107, 178, 207, 0} ,{108, 178, 141, 167} ,{109, 178, 141, 167} ,{108, 172, 141, 167} ,{146, 166, 211, 0} ,{110, 178, 54, 0} ,{126, 166, 211, 0} ,{146, 166, 212, 0} ,{111, 178, 54, 0} ,{126, 166, 212, 0} ,{153, 167, 150, 0} ,{132, 167, 150, 0} ,{113, 168, 150, 0} ,{86, 168, 150, 0} ,{90, 167, 150, 0} ,{91, 167, 150, 0} ,{131, 167, 150, 0} ,{123, 167, 150, 0} ,{131, 167, 43, 170} ,{123, 167, 43, 170} ,{131, 167, 100, 171} ,{123, 167, 100, 171} ,{131, 167, 5, 174} ,{123, 167, 5, 174} ,{131, 167, 6, 174} ,{123, 167, 6, 174} ,{192, 167, 49, 0} ,{153, 167, 43, 170} ,{132, 167, 43, 170} ,{226, 172, 41, 171} ,{227, 172, 41, 171} ,{146, 166, 7, 174} ,{126, 166, 7, 174} ,{69, 169, 28, 167} ,{255, 168, 28, 167} ,{69, 169, 141, 167} ,{255, 168, 141, 167} ,{28, 169, 141, 167} ,{214, 168, 141, 167} ,{90, 167, 148, 0} ,{91, 167, 148, 0} ,{90, 167, 8, 174} ,{91, 167, 8, 174} ,{9, 174, 141, 167} ,{192, 170, 141, 167} ,{43, 171, 141, 167} ,{146, 166, 218, 0} ,{10, 174, 70, 0} ,{126, 166, 218, 0} ,{69, 169, 162, 167} ,{255, 168, 162, 167} ,{146, 166, 219, 0} ,{146, 166, 205, 0} ,{231, 169, 128, 0} ,{149, 169, 128, 0} ,{153, 167, 12, 174} ,{132, 167, 12, 174} ,{146, 166, 13, 174} ,{126, 166, 13, 174} ,{90, 167, 14, 174} ,{91, 167, 14, 174} ,{153, 167, 236, 168} ,{132, 167, 236, 168} ,{153, 167, 104, 168} ,{132, 167, 104, 168} ,{196, 167, 236, 168} ,{167, 167, 236, 168} ,{196, 167, 104, 168} ,{167, 167, 104, 168} ,{113, 168, 236, 168} ,{86, 168, 236, 168} ,{113, 168, 104, 168} ,{86, 168, 104, 168} ,{90, 167, 236, 168} ,{91, 167, 236, 168} ,{90, 167, 104, 168} ,{91, 167, 104, 168} ,{184, 168, 15, 174} ,{54, 168, 15, 174} ,{184, 168, 16, 174} ,{54, 168, 16, 174} ,{131, 167, 236, 168} ,{123, 167, 236, 168} ,{131, 167, 104, 168} ,{123, 167, 104, 168} ,{209, 168, 40, 171} ,{112, 168, 40, 171} ,{202, 168, 40, 171} ,{95, 168, 40, 171} ,{146, 166, 223, 0} ,{126, 166, 223, 0} ,{92, 169, 141, 167} ,{208, 168, 141, 167} ,{231, 169, 17, 174} ,{111, 168, 176, 168} ,{146, 166, 225, 0} ,{126, 166, 225, 0} ,{19, 169, 48, 167} ,{121, 168, 48, 167} ,{226, 172, 233, 166} ,{227, 172, 233, 166} ,{196, 167, 116, 0} ,{167, 167, 116, 0} ,{90, 167, 43, 170} ,{91, 167, 43, 170} ,{90, 167, 18, 174} ,{91, 167, 18, 174} ,{230, 172, 233, 166} ,{231, 172, 233, 166} ,{230, 172, 41, 171} ,{231, 172, 41, 171} ,{169, 168, 232, 169} ,{136, 168, 232, 169} ,{53, 168, 176, 168} ,{149, 169, 224, 0} ,{95, 168, 176, 168} ,{42, 171, 54, 0} ,{112, 178, 228, 0} ,{113, 178, 228, 0} ,{153, 167, 141, 0} ,{147, 169, 28, 167} ,{68, 169, 28, 167} ,{124, 168, 148, 172} ,{202, 168, 98, 169} ,{112, 168, 237, 171} ,{121, 168, 237, 171} ,{146, 166, 60, 169} ,{126, 166, 60, 169} ,{63, 170, 28, 167} ,{146, 166, 220, 172} ,{123, 170, 66, 0} ,{196, 167, 141, 0} ,{167, 167, 141, 0} ,{146, 166, 218, 172} ,{43, 171, 28, 167} ,{115, 178, 19, 174} ,{14, 172, 19, 174} ,{184, 168, 28, 167} ,{54, 168, 28, 167} ,{169, 168, 28, 167} ,{136, 168, 28, 167} ,{192, 167, 45, 0} ,{126, 166, 234, 0} ,{192, 167, 234, 0} ,{146, 169, 48, 167} ,{126, 166, 190, 170} ,{68, 169, 176, 168} ,{111, 168, 52, 168} ,{111, 168, 48, 167} ,{253, 169, 49, 0} ,{126, 166, 180, 0} ,{29, 175, 48, 167} ,{126, 166, 67, 169} ,{253, 169, 67, 169} ,{28, 175, 172, 0} ,{116, 178, 67, 169} ,{42, 171, 218, 172} ,{255, 168, 48, 167} ,{126, 166, 31, 175} ,{59, 167, 51, 0} ,{126, 166, 182, 0} ,{117, 178, 187, 0} ,{192, 167, 52, 0} ,{208, 168, 48, 167} ,{118, 178, 48, 167} ,{126, 166, 193, 170} ,{126, 166, 184, 0} ,{59, 167, 53, 0} ,{53, 168, 175, 168} ,{119, 178, 240, 0} ,{53, 168, 254, 168} ,{126, 166, 241, 0} ,{192, 167, 57, 0} ,{192, 167, 35, 175} ,{64, 170, 48, 167} ,{149, 169, 219, 172} ,{149, 169, 8, 168} ,{59, 167, 58, 0} ,{126, 166, 97, 171} ,{59, 167, 164, 0} ,{105, 172, 244, 0} ,{126, 166, 245, 0} ,{192, 167, 62, 0} ,{96, 173, 96, 171} ,{96, 173, 48, 167} ,{54, 168, 96, 171} ,{54, 168, 52, 168} ,{54, 168, 109, 172} ,{120, 178, 109, 172} ,{59, 167, 62, 0} ,{59, 167, 25, 174} ,{112, 168, 48, 167} ,{126, 166, 191, 0} ,{121, 178, 127, 172} ,{123, 178, 191, 0} ,{217, 172, 176, 168} ,{192, 167, 64, 0} ,{95, 168, 254, 168} ,{126, 166, 220, 172} ,{126, 166, 196, 0} ,{255, 169, 48, 167} ,{192, 167, 66, 0} ,{192, 167, 67, 0} ,{192, 167, 69, 0} ,{59, 167, 69, 0} ,{121, 168, 254, 168} ,{121, 168, 176, 168} ,{126, 166, 198, 0} ,{192, 170, 176, 168} ,{225, 166, 60, 169} ,{125, 178, 250, 0} ,{20, 174, 60, 169} ,{126, 178, 47, 0} ,{23, 174, 207, 0} ,{59, 167, 46, 0} ,{105, 172, 67, 169} ,{127, 178, 48, 167} ,{59, 167, 52, 0} ,{43, 171, 33, 175} ,{192, 167, 55, 0} ,{59, 167, 56, 0} ,{14, 172, 48, 167} ,{225, 166, 107, 172} ,{21, 174, 107, 172} ,{108, 172, 228, 0} ,{128, 178, 228, 0} ,{108, 172, 22, 174} ,{129, 178, 228, 0} ,{130, 178, 228, 0} ,{131, 178, 22, 174} ,{132, 178, 228, 0} ,{133, 178, 228, 0} ,{134, 178, 228, 0} ,{23, 174, 6, 1} ,{135, 178, 6, 1} ,{24, 174, 109, 172} ,{136, 178, 201, 0} ,{197, 166, 52, 0} ,{137, 178, 48, 167} ,{197, 166, 54, 0} ,{197, 166, 62, 0} ,{200, 168, 62, 0} ,{138, 178, 48, 167} ,{62, 170, 25, 174} ,{197, 166, 67, 0} ,{197, 166, 69, 0} ,{164, 166, 10, 1} ,{164, 166, 131, 64} ,{139, 178, 16, 0} ,{164, 166, 10, 0} ,{26, 174, 16, 0} ,{164, 166, 107, 171} ,{164, 166, 132, 172} ,{164, 166, 60, 169} ,{26, 174, 60, 169} ,{164, 166, 29, 174} ,{164, 166, 30, 174} ,{164, 166, 20, 67} ,{164, 166, 21, 67} ,{164, 166, 33, 38} ,{150, 0, 0, 0} ,{164, 166, 63, 38} ,{164, 166, 106, 0} ,{164, 166, 86, 38} ,{164, 166, 35, 38} ,{55, 168, 63, 38} ,{55, 168, 106, 0} ,{55, 168, 35, 38} ,{55, 168, 86, 38} ,{164, 166, 27, 174} ,{140, 178, 27, 174} ,{28, 174, 107, 171} ,{28, 174, 132, 172} ,{164, 166, 182, 66} ,{164, 166, 181, 66} ,{164, 166, 238, 37} ,{164, 166, 35, 66} ,{147, 0, 0, 0} ,{149, 0, 132, 0} ,{131, 0, 132, 0} ,{148, 0, 0, 0} ,{79, 0, 82, 0} ,{100, 0, 86, 38} ,{141, 178, 172, 0} ,{142, 178, 75, 0} ,{197, 166, 182, 0} ,{197, 166, 56, 0} ,{197, 166, 63, 0} ,{197, 166, 68, 0} ,{30, 175, 60, 169} ,{9, 172, 1, 168} ,{10, 172, 1, 168} ,{11, 172, 1, 168} ,{55, 168, 1, 168} ,{12, 172, 1, 168} ,{143, 178, 105, 173} ,{144, 178, 105, 173} ,{164, 166, 27, 1} ,{164, 166, 28, 1} ,{145, 178, 10, 0} ,{55, 168, 21, 67} ,{55, 168, 20, 67} ,{55, 168, 29, 174} ,{55, 168, 30, 174} ,{55, 168, 12, 1} ,{110, 172, 35, 38} ,{31, 174, 35, 38} ,{31, 174, 86, 38} ,{55, 168, 82, 0} ,{242, 170, 33, 0} ,{32, 174, 243, 170} ,{33, 174, 243, 170} ,{32, 174, 244, 170} ,{33, 174, 244, 170} ,{164, 166, 33, 1} ,{146, 178, 33, 1} ,{147, 178, 34, 1} ,{35, 1, 35, 38} ,{35, 1, 86, 38} ,{35, 1, 33, 38} ,{35, 1, 82, 0} ,{35, 1, 106, 0} ,{35, 1, 36, 1} ,{35, 1, 147, 0} ,{35, 1, 123, 40} ,{35, 1, 93, 0} ,{35, 1, 190, 167} ,{35, 1, 124, 40} ,{14, 168, 86, 38} ,{35, 1, 150, 0} ,{35, 1, 34, 174} ,{14, 168, 34, 174} ,{14, 168, 35, 38} ,{35, 1, 38, 1} ,{35, 1, 104, 168} ,{148, 178, 207, 171} ,{35, 1, 207, 171} ,{149, 178, 207, 171} ,{150, 178, 45, 174} ,{39, 174, 111, 172} ,{40, 174, 111, 172} ,{152, 169, 35, 174} ,{153, 169, 35, 174} ,{41, 174, 132, 0} ,{35, 1, 187, 0} ,{42, 174, 16, 170} ,{151, 178, 222, 0} ,{152, 178, 222, 0} ,{35, 1, 86, 173} ,{153, 178, 222, 0} ,{154, 178, 36, 174} ,{155, 178, 36, 174} ,{35, 1, 57, 168} ,{35, 1, 223, 172} ,{35, 1, 16, 170} ,{35, 1, 166, 170} ,{35, 1, 116, 0} ,{35, 1, 148, 0} ,{38, 174, 249, 167} ,{35, 1, 37, 174} ,{157, 178, 222, 0} ,{158, 178, 222, 0} ,{159, 178, 111, 172} ,{35, 1, 195, 170} ,{112, 172, 195, 170} ,{35, 1, 169, 169} ,{154, 173, 222, 0} ,{35, 1, 34, 38} ,{14, 168, 34, 38} ,{160, 178, 49, 1} ,{243, 172, 245, 170} ,{133, 171, 245, 170} ,{243, 172, 134, 171} ,{133, 171, 134, 171} ,{44, 174, 16, 170} ,{112, 172, 37, 174} ,{161, 178, 222, 0} ,{162, 178, 222, 0} ,{43, 174, 132, 0} ,{38, 174, 82, 0} ,{14, 168, 36, 1} ,{39, 174, 21, 169} ,{40, 174, 21, 169} ,{27, 170, 55, 1} ,{27, 170, 56, 1} ,{27, 170, 50, 174} ,{27, 170, 59, 1} ,{35, 1, 86, 175} ,{163, 178, 222, 0} ,{85, 175, 249, 167} ,{41, 174, 222, 0} ,{164, 178, 79, 173} ,{165, 178, 132, 0} ,{43, 175, 132, 0} ,{84, 175, 135, 171} ,{166, 178, 135, 171} ,{167, 178, 67, 1} ,{98, 171, 132, 0} ,{42, 174, 124, 40} ,{35, 1, 69, 1} ,{43, 174, 222, 0} ,{152, 169, 222, 172} ,{98, 171, 222, 0} ,{168, 178, 222, 172} ,{44, 174, 124, 40} ,{169, 178, 45, 174} ,{87, 175, 222, 0} ,{14, 168, 16, 170} ,{41, 175, 132, 0} ,{14, 168, 195, 170} ,{14, 168, 147, 0} ,{14, 168, 106, 0} ,{170, 178, 222, 0} ,{14, 168, 82, 0} ,{14, 168, 104, 168} ,{171, 178, 222, 0} ,{130, 167, 45, 0} ,{130, 167, 49, 0} ,{130, 167, 53, 0} ,{130, 167, 59, 0} ,{130, 167, 65, 0} ,{130, 167, 47, 0} ,{130, 167, 48, 0} ,{130, 167, 52, 0} ,{130, 167, 57, 0} ,{130, 167, 62, 0} ,{130, 167, 64, 0} ,{130, 167, 66, 0} ,{130, 167, 68, 0} ,{177, 166, 73, 1} ,{172, 166, 73, 1} ,{177, 166, 46, 174} ,{172, 166, 46, 174} ,{54, 1, 47, 174} ,{172, 178, 47, 174} ,{177, 166, 48, 174} ,{172, 166, 48, 174} ,{54, 1, 59, 1} ,{49, 174, 134, 169} ,{113, 172, 44, 171} ,{49, 174, 44, 171} ,{54, 1, 2, 38} ,{54, 1, 58, 1} ,{54, 1, 50, 174} ,{230, 167, 56, 169} ,{173, 178, 86, 1} ,{74, 169, 56, 169} ,{250, 167, 56, 169} ,{151, 169, 58, 1} ,{78, 169, 56, 169} ,{233, 169, 58, 1} ,{251, 167, 56, 169} ,{128, 171, 58, 1} ,{177, 166, 234, 0} ,{177, 166, 93, 1} ,{177, 166, 182, 0} ,{177, 166, 178, 0} ,{177, 166, 94, 1} ,{177, 166, 95, 1} ,{177, 166, 96, 1} ,{177, 166, 97, 1} ,{177, 166, 184, 0} ,{177, 166, 98, 1} ,{177, 166, 99, 1} ,{177, 166, 100, 1} ,{177, 166, 101, 1} ,{177, 166, 102, 1} ,{177, 166, 103, 1} ,{177, 166, 104, 1} ,{177, 166, 105, 1} ,{177, 166, 106, 1} ,{177, 166, 107, 1} ,{177, 166, 196, 0} ,{177, 166, 245, 0} ,{177, 166, 108, 1} ,{177, 166, 109, 1} ,{177, 166, 244, 0} ,{151, 169, 110, 1} ,{233, 169, 110, 1} ,{170, 168, 58, 1} ,{72, 169, 56, 169} ,{198, 167, 56, 169} ,{139, 168, 58, 1} ,{129, 171, 58, 1} ,{172, 166, 234, 0} ,{172, 166, 93, 1} ,{172, 166, 182, 0} ,{172, 166, 178, 0} ,{172, 166, 94, 1} ,{172, 166, 95, 1} ,{172, 166, 96, 1} ,{172, 166, 97, 1} ,{172, 166, 184, 0} ,{172, 166, 98, 1} ,{172, 166, 99, 1} ,{172, 166, 100, 1} ,{172, 166, 101, 1} ,{172, 166, 102, 1} ,{172, 166, 103, 1} ,{172, 166, 104, 1} ,{172, 166, 105, 1} ,{172, 166, 161, 170} ,{172, 166, 106, 1} ,{172, 166, 107, 1} ,{172, 166, 196, 0} ,{172, 166, 245, 0} ,{172, 166, 108, 1} ,{172, 166, 109, 1} ,{172, 166, 244, 0} ,{139, 168, 110, 1} ,{140, 168, 110, 1} ,{73, 169, 56, 169} ,{140, 168, 58, 1} ,{199, 167, 56, 169} ,{44, 170, 51, 174} ,{174, 178, 82, 1} ,{54, 1, 195, 168} ,{114, 172, 116, 172} ,{176, 178, 116, 172} ,{177, 178, 116, 172} ,{54, 1, 163, 170} ,{54, 1, 165, 170} ,{54, 1, 51, 174} ,{199, 168, 52, 174} ,{172, 166, 52, 174} ,{199, 168, 118, 1} ,{172, 166, 118, 1} ,{199, 168, 79, 1} ,{172, 166, 79, 1} ,{199, 168, 117, 1} ,{172, 166, 117, 1} ,{199, 168, 75, 1} ,{172, 166, 75, 1} ,{239, 166, 120, 1} ,{240, 166, 120, 1} ,{239, 166, 121, 1} ,{240, 166, 121, 1} ,{239, 166, 122, 1} ,{240, 166, 122, 1} ,{239, 166, 123, 1} ,{240, 166, 123, 1} ,{239, 166, 124, 1} ,{240, 166, 124, 1} ,{239, 166, 125, 1} ,{240, 166, 125, 1} ,{239, 166, 126, 1} ,{240, 166, 126, 1} ,{54, 1, 162, 170} ,{54, 1, 164, 170} ,{54, 1, 134, 169} ,{199, 168, 129, 1} ,{44, 170, 195, 168} ,{54, 1, 53, 174} ,{178, 178, 53, 174} ,{177, 166, 130, 1} ,{172, 166, 130, 1} ,{44, 170, 134, 169} ,{177, 166, 131, 1} ,{172, 166, 131, 1} ,{180, 178, 82, 1} ,{54, 174, 134, 169} ,{44, 170, 44, 171} ,{54, 174, 44, 171} ,{170, 166, 56, 174} ,{170, 166, 134, 1} ,{170, 166, 135, 1} ,{170, 166, 136, 1} ,{170, 166, 57, 174} ,{170, 166, 139, 1} ,{170, 166, 59, 174} ,{170, 166, 141, 1} ,{170, 166, 142, 1} ,{170, 166, 143, 1} ,{170, 166, 144, 1} ,{170, 166, 145, 1} ,{170, 166, 146, 1} ,{123, 172, 128, 0} ,{117, 172, 65, 0} ,{170, 166, 147, 1} ,{170, 166, 45, 0} ,{170, 166, 148, 1} ,{170, 166, 149, 1} ,{170, 166, 150, 1} ,{170, 166, 151, 1} ,{170, 166, 138, 1} ,{170, 166, 152, 1} ,{170, 166, 153, 1} ,{170, 166, 53, 0} ,{117, 172, 53, 0} ,{170, 166, 154, 1} ,{170, 166, 155, 1} ,{170, 166, 156, 1} ,{170, 166, 157, 1} ,{170, 166, 59, 0} ,{170, 166, 158, 1} ,{170, 166, 159, 1} ,{170, 166, 160, 1} ,{170, 166, 161, 1} ,{170, 166, 65, 0} ,{170, 166, 162, 1} ,{170, 166, 163, 1} ,{170, 166, 164, 1} ,{170, 166, 165, 1} ,{170, 166, 166, 1} ,{170, 166, 167, 1} ,{170, 166, 55, 174} ,{170, 166, 169, 1} ,{3, 172, 6, 0} ,{170, 166, 49, 0} ,{170, 166, 170, 1} ,{170, 166, 171, 1} ,{169, 166, 45, 0} ,{169, 166, 148, 1} ,{169, 166, 149, 1} ,{169, 166, 150, 1} ,{169, 166, 151, 1} ,{169, 166, 138, 1} ,{169, 166, 152, 1} ,{169, 166, 153, 1} ,{169, 166, 53, 0} ,{118, 172, 53, 0} ,{169, 166, 154, 1} ,{169, 166, 155, 1} ,{169, 166, 156, 1} ,{169, 166, 157, 1} ,{169, 166, 59, 0} ,{169, 166, 158, 1} ,{169, 166, 159, 1} ,{169, 166, 160, 1} ,{169, 166, 161, 1} ,{169, 166, 65, 0} ,{169, 166, 162, 1} ,{169, 166, 163, 1} ,{169, 166, 164, 1} ,{169, 166, 165, 1} ,{169, 166, 166, 1} ,{169, 166, 167, 1} ,{169, 166, 55, 174} ,{169, 166, 169, 1} ,{4, 172, 6, 0} ,{169, 166, 49, 0} ,{169, 166, 170, 1} ,{169, 166, 171, 1} ,{169, 166, 56, 174} ,{169, 166, 134, 1} ,{169, 166, 135, 1} ,{169, 166, 136, 1} ,{169, 166, 57, 174} ,{169, 166, 139, 1} ,{169, 166, 59, 174} ,{169, 166, 141, 1} ,{169, 166, 142, 1} ,{169, 166, 143, 1} ,{169, 166, 144, 1} ,{169, 166, 145, 1} ,{169, 166, 146, 1} ,{124, 172, 128, 0} ,{118, 172, 65, 0} ,{169, 166, 147, 1} ,{170, 166, 244, 0} ,{169, 166, 244, 0} ,{170, 166, 172, 1} ,{169, 166, 172, 1} ,{117, 170, 49, 0} ,{118, 170, 49, 0} ,{170, 166, 96, 169} ,{169, 166, 96, 169} ,{117, 170, 96, 169} ,{118, 170, 96, 169} ,{170, 166, 20, 169} ,{169, 166, 20, 169} ,{117, 170, 20, 169} ,{118, 170, 20, 169} ,{170, 166, 177, 1} ,{169, 166, 177, 1} ,{170, 166, 109, 1} ,{169, 166, 109, 1} ,{170, 166, 178, 1} ,{169, 166, 178, 1} ,{170, 166, 179, 1} ,{169, 166, 179, 1} ,{170, 166, 61, 174} ,{169, 166, 61, 174} ,{170, 166, 181, 1} ,{169, 166, 181, 1} ,{170, 166, 62, 174} ,{169, 166, 62, 174} ,{170, 166, 64, 174} ,{169, 166, 64, 174} ,{170, 166, 184, 1} ,{169, 166, 184, 1} ,{170, 166, 117, 1} ,{169, 166, 117, 1} ,{132, 1, 65, 174} ,{54, 167, 183, 1} ,{54, 167, 186, 1} ,{181, 178, 188, 1} ,{182, 178, 188, 1} ,{54, 167, 190, 1} ,{19, 177, 65, 174} ,{54, 167, 6, 172} ,{117, 172, 66, 174} ,{118, 172, 66, 174} ,{170, 166, 67, 174} ,{169, 166, 67, 174} ,{170, 166, 69, 174} ,{169, 166, 69, 174} ,{168, 170, 70, 174} ,{169, 170, 70, 174} ,{168, 170, 28, 167} ,{169, 170, 28, 167} ,{168, 170, 25, 169} ,{169, 170, 25, 169} ,{121, 172, 144, 167} ,{122, 172, 144, 167} ,{170, 166, 71, 174} ,{169, 166, 71, 174} ,{46, 171, 144, 167} ,{47, 171, 144, 167} ,{46, 171, 177, 169} ,{47, 171, 177, 169} ,{46, 171, 28, 167} ,{47, 171, 28, 167} ,{170, 166, 72, 174} ,{169, 166, 72, 174} ,{51, 171, 144, 167} ,{52, 171, 144, 167} ,{119, 172, 73, 174} ,{120, 172, 73, 174} ,{170, 166, 74, 174} ,{169, 166, 74, 174} ,{48, 171, 163, 1} ,{49, 171, 163, 1} ,{170, 166, 75, 174} ,{169, 166, 75, 174} ,{170, 166, 76, 174} ,{169, 166, 76, 174} ,{170, 166, 77, 174} ,{169, 166, 77, 174} ,{170, 166, 78, 174} ,{169, 166, 78, 174} ,{128, 172, 144, 167} ,{129, 172, 144, 167} ,{119, 172, 79, 174} ,{120, 172, 79, 174} ,{170, 166, 45, 171} ,{169, 166, 45, 171} ,{170, 166, 80, 174} ,{169, 166, 80, 174} ,{170, 166, 211, 1} ,{169, 166, 211, 1} ,{48, 171, 165, 1} ,{49, 171, 165, 1} ,{48, 171, 45, 171} ,{49, 171, 45, 171} ,{113, 173, 212, 1} ,{121, 172, 45, 170} ,{122, 172, 45, 170} ,{46, 171, 48, 167} ,{47, 171, 48, 167} ,{130, 172, 52, 168} ,{131, 172, 52, 168} ,{51, 171, 48, 167} ,{52, 171, 48, 167} ,{51, 171, 52, 168} ,{52, 171, 52, 168} ,{170, 166, 81, 174} ,{169, 166, 81, 174} ,{170, 166, 82, 174} ,{169, 166, 82, 174} ,{169, 166, 212, 1} ,{170, 166, 83, 174} ,{169, 166, 83, 174} ,{170, 166, 84, 174} ,{169, 166, 84, 174} ,{119, 172, 85, 174} ,{120, 172, 85, 174} ,{170, 166, 86, 174} ,{169, 166, 86, 174} ,{170, 166, 180, 0} ,{169, 166, 180, 0} ,{170, 166, 87, 174} ,{169, 166, 87, 174} ,{121, 172, 0, 168} ,{122, 172, 0, 168} ,{170, 166, 88, 174} ,{169, 166, 88, 174} ,{48, 171, 139, 1} ,{49, 171, 139, 1} ,{123, 172, 106, 0} ,{124, 172, 106, 0} ,{123, 172, 93, 0} ,{124, 172, 93, 0} ,{170, 166, 50, 171} ,{169, 166, 50, 171} ,{170, 166, 97, 171} ,{169, 166, 97, 171} ,{170, 166, 89, 174} ,{169, 166, 89, 174} ,{170, 166, 90, 174} ,{169, 166, 90, 174} ,{125, 172, 106, 0} ,{126, 172, 106, 0} ,{125, 172, 93, 0} ,{126, 172, 93, 0} ,{125, 172, 227, 169} ,{126, 172, 227, 169} ,{170, 166, 91, 174} ,{169, 166, 91, 174} ,{168, 170, 144, 167} ,{169, 170, 144, 167} ,{170, 166, 92, 174} ,{169, 166, 92, 174} ,{168, 170, 127, 172} ,{169, 170, 127, 172} ,{128, 172, 48, 167} ,{129, 172, 48, 167} ,{128, 172, 28, 167} ,{129, 172, 28, 167} ,{135, 169, 151, 1} ,{136, 169, 151, 1} ,{135, 169, 135, 1} ,{136, 169, 135, 1} ,{135, 169, 218, 1} ,{136, 169, 218, 1} ,{135, 169, 219, 1} ,{136, 169, 219, 1} ,{135, 169, 143, 1} ,{136, 169, 143, 1} ,{135, 169, 144, 1} ,{136, 169, 144, 1} ,{135, 169, 220, 1} ,{136, 169, 220, 1} ,{135, 169, 221, 1} ,{136, 169, 221, 1} ,{111, 173, 153, 1} ,{112, 173, 153, 1} ,{130, 172, 48, 167} ,{131, 172, 48, 167} ,{170, 166, 222, 1} ,{169, 166, 222, 1} ,{170, 166, 223, 1} ,{169, 166, 223, 1} ,{170, 166, 224, 1} ,{169, 166, 224, 1} ,{170, 166, 225, 1} ,{169, 166, 225, 1} ,{170, 166, 226, 1} ,{169, 166, 226, 1} ,{170, 166, 93, 174} ,{169, 166, 93, 174} ,{130, 172, 25, 169} ,{131, 172, 25, 169} ,{51, 171, 25, 169} ,{52, 171, 25, 169} ,{170, 166, 94, 174} ,{169, 166, 94, 174} ,{79, 167, 229, 1} ,{79, 167, 230, 1} ,{79, 167, 231, 1} ,{79, 167, 232, 1} ,{79, 167, 233, 1} ,{79, 167, 234, 1} ,{79, 167, 235, 1} ,{79, 167, 236, 1} ,{79, 167, 237, 1} ,{79, 167, 152, 1} ,{79, 167, 238, 1} ,{79, 167, 239, 1} ,{79, 167, 240, 1} ,{79, 167, 241, 1} ,{79, 167, 242, 1} ,{79, 167, 243, 1} ,{79, 167, 244, 1} ,{79, 167, 245, 1} ,{79, 167, 246, 1} ,{79, 167, 247, 1} ,{79, 167, 141, 1} ,{79, 167, 248, 1} ,{79, 167, 166, 1} ,{79, 167, 249, 1} ,{79, 167, 250, 1} ,{79, 167, 251, 1} ,{79, 167, 252, 1} ,{79, 167, 253, 1} ,{79, 167, 254, 1} ,{79, 167, 255, 1} ,{79, 167, 0, 2} ,{79, 167, 1, 2} ,{79, 167, 2, 2} ,{79, 167, 3, 2} ,{79, 167, 4, 2} ,{79, 167, 5, 2} ,{79, 167, 6, 2} ,{79, 167, 7, 2} ,{228, 1, 97, 40} ,{228, 1, 10, 0} ,{183, 178, 3, 0} ,{228, 1, 228, 37} ,{228, 1, 16, 0} ,{228, 1, 2, 38} ,{228, 1, 68, 172} ,{80, 167, 229, 1} ,{80, 167, 230, 1} ,{80, 167, 231, 1} ,{80, 167, 232, 1} ,{80, 167, 233, 1} ,{80, 167, 234, 1} ,{80, 167, 235, 1} ,{80, 167, 236, 1} ,{80, 167, 237, 1} ,{80, 167, 152, 1} ,{80, 167, 238, 1} ,{80, 167, 239, 1} ,{80, 167, 240, 1} ,{80, 167, 241, 1} ,{80, 167, 242, 1} ,{80, 167, 243, 1} ,{80, 167, 244, 1} ,{80, 167, 245, 1} ,{80, 167, 246, 1} ,{80, 167, 247, 1} ,{80, 167, 141, 1} ,{80, 167, 248, 1} ,{80, 167, 166, 1} ,{80, 167, 249, 1} ,{80, 167, 250, 1} ,{80, 167, 251, 1} ,{80, 167, 252, 1} ,{80, 167, 253, 1} ,{80, 167, 254, 1} ,{80, 167, 255, 1} ,{80, 167, 0, 2} ,{80, 167, 1, 2} ,{80, 167, 2, 2} ,{80, 167, 3, 2} ,{80, 167, 4, 2} ,{80, 167, 5, 2} ,{80, 167, 6, 2} ,{80, 167, 7, 2} ,{184, 178, 3, 2} ,{228, 1, 241, 37} ,{228, 1, 104, 0} ,{120, 167, 12, 2} ,{120, 167, 13, 2} ,{120, 167, 14, 2} ,{95, 174, 16, 2} ,{95, 174, 17, 2} ,{120, 167, 18, 2} ,{120, 167, 19, 2} ,{120, 167, 20, 2} ,{120, 167, 21, 2} ,{120, 167, 22, 2} ,{120, 167, 23, 2} ,{120, 167, 24, 2} ,{185, 178, 26, 2} ,{120, 167, 27, 2} ,{186, 178, 29, 2} ,{96, 174, 31, 2} ,{120, 167, 32, 2} ,{187, 178, 34, 2} ,{120, 167, 35, 2} ,{120, 167, 36, 2} ,{120, 167, 37, 2} ,{188, 178, 39, 2} ,{120, 167, 40, 2} ,{120, 167, 41, 2} ,{96, 174, 42, 2} ,{190, 178, 45, 2} ,{120, 167, 46, 2} ,{120, 167, 47, 2} ,{120, 167, 48, 2} ,{120, 167, 49, 2} ,{191, 178, 52, 2} ,{13, 168, 54, 2} ,{133, 172, 13, 2} ,{133, 172, 56, 2} ,{133, 172, 57, 2} ,{13, 168, 58, 2} ,{13, 168, 59, 2} ,{13, 168, 13, 2} ,{13, 168, 56, 2} ,{13, 168, 57, 2} ,{13, 168, 60, 2} ,{194, 178, 64, 2} ,{13, 168, 65, 2} ,{196, 178, 68, 2} ,{13, 168, 69, 2} ,{46, 170, 71, 2} ,{13, 168, 72, 2} ,{46, 170, 73, 2} ,{13, 168, 130, 173} ,{13, 168, 131, 173} ,{197, 178, 77, 2} ,{198, 178, 115, 0} ,{199, 178, 115, 0} ,{200, 178, 80, 2} ,{201, 178, 16, 2} ,{216, 166, 82, 2} ,{216, 166, 83, 2} ,{216, 166, 84, 2} ,{216, 166, 85, 2} ,{216, 166, 86, 2} ,{216, 166, 64, 2} ,{216, 166, 87, 2} ,{216, 166, 88, 2} ,{216, 166, 89, 2} ,{216, 166, 90, 2} ,{3, 170, 91, 2} ,{216, 166, 91, 2} ,{216, 166, 92, 2} ,{3, 170, 93, 2} ,{216, 166, 93, 2} ,{3, 170, 94, 2} ,{216, 166, 94, 2} ,{216, 166, 95, 2} ,{216, 166, 96, 2} ,{3, 170, 158, 1} ,{216, 166, 158, 1} ,{3, 170, 97, 2} ,{216, 166, 97, 2} ,{216, 166, 98, 2} ,{216, 166, 99, 2} ,{216, 166, 100, 2} ,{216, 166, 101, 2} ,{97, 174, 64, 2} ,{202, 178, 90, 2} ,{97, 174, 90, 2} ,{46, 170, 24, 2} ,{46, 170, 27, 2} ,{104, 2, 230, 37} ,{237, 168, 105, 2} ,{203, 178, 107, 2} ,{237, 168, 108, 2} ,{94, 167, 44, 66} ,{94, 167, 45, 66} ,{104, 2, 114, 2} ,{98, 174, 71, 175} ,{98, 174, 73, 175} ,{119, 2, 6, 0} ,{104, 2, 16, 0} ,{204, 178, 121, 2} ,{206, 178, 6, 0} ,{237, 168, 124, 2} ,{207, 178, 127, 2} ,{208, 178, 128, 2} ,{209, 178, 130, 2} ,{211, 178, 133, 2} ,{237, 168, 134, 2} ,{41, 168, 135, 2} ,{214, 178, 138, 2} ,{41, 168, 139, 2} ,{195, 167, 140, 2} ,{195, 167, 141, 2} ,{195, 167, 142, 2} ,{104, 2, 34, 0} ,{216, 178, 74, 175} ,{104, 2, 2, 38} ,{149, 166, 144, 2} ,{158, 173, 132, 0} ,{244, 167, 218, 169} ,{39, 169, 218, 169} ,{217, 178, 222, 0} ,{3, 168, 218, 169} ,{149, 166, 82, 2} ,{149, 166, 149, 2} ,{36, 169, 151, 2} ,{149, 166, 152, 2} ,{149, 166, 153, 2} ,{149, 166, 154, 2} ,{149, 166, 155, 2} ,{149, 166, 156, 2} ,{149, 166, 157, 2} ,{149, 166, 158, 2} ,{149, 166, 1, 2} ,{149, 166, 139, 2} ,{149, 166, 159, 2} ,{149, 166, 160, 2} ,{149, 166, 161, 2} ,{149, 166, 162, 2} ,{149, 166, 135, 2} ,{149, 166, 163, 2} ,{149, 166, 164, 2} ,{149, 166, 165, 2} ,{109, 169, 220, 169} ,{109, 169, 47, 170} ,{35, 169, 173, 170} ,{35, 169, 220, 169} ,{35, 169, 238, 168} ,{104, 2, 169, 2} ,{149, 166, 7, 2} ,{149, 166, 170, 2} ,{149, 166, 91, 2} ,{149, 166, 171, 2} ,{149, 166, 172, 2} ,{149, 166, 173, 2} ,{149, 166, 174, 2} ,{149, 166, 175, 2} ,{244, 167, 176, 2} ,{149, 166, 138, 2} ,{104, 2, 177, 2} ,{104, 2, 178, 2} ,{104, 2, 179, 2} ,{104, 2, 140, 2} ,{104, 2, 141, 2} ,{104, 2, 142, 2} ,{104, 2, 180, 2} ,{104, 2, 181, 2} ,{218, 178, 132, 0} ,{104, 2, 136, 172} ,{104, 2, 101, 174} ,{219, 178, 82, 2} ,{220, 178, 141, 2} ,{222, 178, 185, 2} ,{104, 2, 186, 2} ,{135, 172, 99, 174} ,{223, 178, 99, 174} ,{135, 172, 57, 168} ,{224, 178, 141, 2} ,{225, 178, 203, 170} ,{94, 167, 243, 37} ,{94, 167, 244, 37} ,{94, 167, 245, 37} ,{94, 167, 246, 37} ,{94, 167, 247, 37} ,{94, 167, 248, 37} ,{94, 167, 249, 37} ,{94, 167, 250, 37} ,{94, 167, 251, 37} ,{94, 167, 252, 37} ,{104, 2, 232, 37} ,{226, 178, 121, 2} ,{227, 178, 121, 2} ,{228, 178, 52, 173} ,{138, 172, 149, 2} ,{138, 172, 170, 2} ,{229, 178, 82, 2} ,{244, 167, 194, 2} ,{100, 174, 136, 172} ,{100, 174, 101, 174} ,{53, 171, 144, 2} ,{137, 172, 82, 2} ,{137, 172, 175, 2} ,{81, 177, 136, 172} ,{137, 172, 138, 2} ,{149, 166, 196, 2} ,{149, 166, 197, 2} ,{149, 166, 198, 2} ,{36, 169, 217, 169} ,{36, 169, 103, 174} ,{149, 166, 251, 1} ,{149, 166, 200, 2} ,{149, 166, 201, 2} ,{156, 168, 218, 169} ,{231, 178, 132, 0} ,{149, 166, 203, 2} ,{149, 166, 204, 2} ,{156, 168, 238, 168} ,{149, 166, 205, 2} ,{149, 166, 206, 2} ,{149, 166, 207, 2} ,{37, 169, 217, 169} ,{37, 169, 27, 167} ,{232, 178, 121, 174} ,{149, 166, 210, 2} ,{149, 166, 211, 2} ,{149, 166, 212, 2} ,{37, 169, 103, 174} ,{37, 169, 211, 171} ,{149, 166, 214, 2} ,{130, 168, 171, 170} ,{130, 168, 217, 169} ,{130, 168, 27, 167} ,{234, 178, 222, 0} ,{130, 168, 104, 171} ,{130, 168, 220, 169} ,{149, 166, 216, 2} ,{130, 168, 211, 171} ,{191, 168, 104, 171} ,{191, 168, 47, 170} ,{236, 178, 132, 171} ,{135, 170, 57, 171} ,{135, 170, 238, 168} ,{38, 169, 238, 168} ,{196, 169, 238, 168} ,{138, 172, 7, 2} ,{238, 178, 222, 0} ,{116, 169, 27, 167} ,{149, 166, 223, 2} ,{116, 169, 47, 170} ,{149, 166, 224, 2} ,{136, 170, 233, 166} ,{136, 170, 238, 168} ,{149, 166, 226, 2} ,{239, 178, 91, 2} ,{197, 169, 217, 169} ,{197, 169, 233, 166} ,{149, 166, 228, 2} ,{197, 169, 47, 170} ,{149, 166, 229, 2} ,{4, 170, 217, 169} ,{149, 166, 231, 2} ,{4, 170, 57, 171} ,{149, 166, 232, 2} ,{4, 170, 238, 168} ,{117, 169, 171, 170} ,{117, 169, 233, 166} ,{117, 169, 238, 168} ,{117, 169, 47, 170} ,{157, 168, 27, 167} ,{157, 168, 185, 2} ,{149, 166, 233, 2} ,{157, 168, 217, 169} ,{157, 168, 238, 168} ,{15, 168, 235, 2} ,{255, 170, 233, 166} ,{134, 173, 132, 0} ,{15, 168, 237, 2} ,{0, 171, 218, 169} ,{159, 173, 237, 2} ,{39, 169, 217, 169} ,{129, 170, 164, 0} ,{149, 166, 164, 0} ,{149, 166, 65, 0} ,{149, 166, 170, 1} ,{129, 170, 170, 1} ,{39, 169, 220, 169} ,{149, 166, 149, 1} ,{218, 168, 138, 2} ,{3, 168, 52, 168} ,{3, 168, 171, 170} ,{39, 169, 233, 166} ,{149, 166, 49, 0} ,{3, 168, 47, 170} ,{3, 168, 241, 2} ,{5, 170, 218, 169} ,{104, 2, 241, 37} ,{149, 166, 133, 0} ,{240, 178, 105, 174} ,{241, 178, 105, 174} ,{106, 174, 171, 166} ,{242, 178, 82, 2} ,{41, 168, 154, 2} ,{243, 178, 189, 2} ,{41, 168, 159, 2} ,{244, 178, 247, 2} ,{247, 178, 250, 2} ,{248, 178, 23, 0} ,{250, 178, 23, 0} ,{253, 178, 156, 2} ,{106, 174, 161, 166} ,{109, 174, 159, 2} ,{41, 168, 0, 3} ,{195, 167, 175, 2} ,{195, 167, 138, 2} ,{41, 168, 138, 2} ,{41, 168, 173, 2} ,{254, 178, 2, 3} ,{255, 178, 20, 0} ,{0, 179, 20, 0} ,{5, 179, 6, 3} ,{109, 174, 172, 2} ,{37, 169, 173, 170} ,{130, 168, 173, 170} ,{238, 167, 243, 37} ,{238, 167, 244, 37} ,{238, 167, 245, 37} ,{238, 167, 246, 37} ,{238, 167, 247, 37} ,{238, 167, 248, 37} ,{238, 167, 249, 37} ,{238, 167, 250, 37} ,{238, 167, 251, 37} ,{238, 167, 252, 37} ,{10, 171, 27, 167} ,{11, 171, 27, 167} ,{12, 171, 27, 167} ,{110, 174, 9, 0} ,{6, 179, 247, 1} ,{15, 168, 173, 170} ,{7, 179, 14, 3} ,{140, 172, 241, 37} ,{141, 172, 241, 37} ,{140, 172, 33, 0} ,{141, 172, 33, 0} ,{8, 179, 33, 0} ,{111, 174, 20, 3} ,{111, 174, 39, 1} ,{9, 179, 20, 3} ,{10, 179, 39, 1} ,{13, 3, 21, 3} ,{142, 172, 23, 3} ,{142, 172, 24, 3} ,{142, 172, 25, 3} ,{13, 3, 68, 172} ,{93, 167, 26, 3} ,{11, 179, 26, 3} ,{93, 167, 27, 3} ,{93, 167, 28, 3} ,{12, 179, 30, 3} ,{93, 167, 31, 3} ,{14, 179, 33, 3} ,{93, 167, 86, 2} ,{93, 167, 175, 2} ,{93, 167, 139, 2} ,{93, 167, 34, 3} ,{93, 167, 35, 3} ,{15, 179, 30, 3} ,{93, 167, 37, 3} ,{16, 179, 86, 2} ,{93, 167, 39, 3} ,{93, 167, 40, 3} ,{93, 167, 41, 3} ,{93, 167, 94, 2} ,{93, 167, 42, 3} ,{17, 179, 42, 3} ,{93, 167, 49, 0} ,{93, 167, 158, 1} ,{18, 179, 158, 1} ,{93, 167, 43, 3} ,{93, 167, 44, 3} ,{93, 167, 33, 3} ,{93, 167, 100, 2} ,{93, 167, 45, 3} ,{143, 172, 47, 3} ,{143, 172, 48, 3} ,{143, 172, 49, 3} ,{144, 172, 132, 0} ,{144, 172, 222, 0} ,{144, 172, 51, 3} ,{145, 172, 132, 0} ,{145, 172, 222, 0} ,{145, 172, 51, 3} ,{112, 174, 132, 0} ,{112, 174, 222, 0} ,{114, 174, 55, 3} ,{114, 174, 56, 3} ,{115, 174, 132, 0} ,{115, 174, 222, 0} ,{20, 179, 51, 3} ,{116, 174, 132, 0} ,{116, 174, 222, 0} ,{13, 3, 60, 3} ,{21, 179, 115, 0} ,{13, 3, 61, 3} ,{13, 3, 62, 3} ,{118, 174, 103, 170} ,{22, 179, 222, 0} ,{13, 3, 132, 171} ,{13, 3, 14, 175} ,{23, 179, 132, 0} ,{119, 174, 249, 167} ,{13, 3, 64, 3} ,{13, 3, 65, 3} ,{146, 172, 67, 3} ,{146, 172, 68, 3} ,{146, 172, 69, 3} ,{25, 179, 222, 0} ,{26, 179, 132, 171} ,{222, 168, 56, 171} ,{28, 179, 228, 175} ,{30, 179, 70, 169} ,{222, 168, 123, 174} ,{222, 168, 171, 170} ,{156, 168, 220, 169} ,{156, 168, 56, 171} ,{32, 179, 121, 174} ,{37, 169, 123, 174} ,{130, 168, 28, 167} ,{191, 168, 211, 171} ,{196, 169, 220, 169} ,{34, 179, 132, 0} ,{196, 169, 149, 172} ,{116, 169, 57, 171} ,{116, 169, 56, 171} ,{109, 169, 233, 166} ,{109, 169, 238, 168} ,{109, 169, 56, 171} ,{137, 170, 233, 166} ,{137, 170, 27, 167} ,{157, 168, 57, 171} ,{35, 179, 135, 2} ,{157, 168, 171, 170} ,{117, 169, 148, 172} ,{130, 168, 149, 172} ,{130, 168, 218, 169} ,{191, 168, 149, 172} ,{124, 174, 222, 0} ,{156, 168, 151, 172} ,{191, 168, 151, 172} ,{130, 168, 151, 172} ,{124, 174, 132, 0} ,{244, 167, 60, 171} ,{244, 167, 62, 171} ,{35, 169, 60, 171} ,{35, 169, 62, 171} ,{35, 169, 125, 174} ,{39, 169, 60, 171} ,{39, 169, 62, 171} ,{5, 170, 60, 171} ,{5, 170, 62, 171} ,{156, 168, 125, 174} ,{36, 179, 132, 0} ,{191, 168, 173, 170} ,{197, 169, 220, 169} ,{76, 167, 75, 3} ,{76, 167, 76, 3} ,{76, 167, 77, 3} ,{76, 167, 78, 3} ,{76, 167, 79, 3} ,{76, 167, 80, 3} ,{76, 167, 81, 3} ,{76, 167, 82, 3} ,{76, 167, 83, 3} ,{76, 167, 84, 3} ,{76, 167, 85, 3} ,{76, 167, 86, 3} ,{76, 167, 87, 3} ,{76, 167, 88, 3} ,{76, 167, 89, 3} ,{76, 167, 90, 3} ,{76, 167, 91, 3} ,{76, 167, 92, 3} ,{76, 167, 93, 3} ,{76, 167, 94, 3} ,{76, 167, 95, 3} ,{76, 167, 96, 3} ,{76, 167, 97, 3} ,{76, 167, 98, 3} ,{76, 167, 99, 3} ,{76, 167, 100, 3} ,{76, 167, 101, 3} ,{76, 167, 102, 3} ,{76, 167, 103, 3} ,{76, 167, 104, 3} ,{76, 167, 105, 3} ,{76, 167, 106, 3} ,{76, 167, 237, 1} ,{76, 167, 107, 3} ,{76, 167, 108, 3} ,{76, 167, 109, 3} ,{76, 167, 110, 3} ,{76, 167, 111, 3} ,{74, 3, 112, 3} ,{74, 3, 113, 3} ,{74, 3, 114, 3} ,{74, 3, 115, 3} ,{74, 3, 116, 3} ,{74, 3, 117, 3} ,{74, 3, 118, 3} ,{74, 3, 119, 3} ,{74, 3, 120, 3} ,{74, 3, 121, 3} ,{74, 3, 181, 2} ,{76, 167, 122, 3} ,{123, 3, 243, 37} ,{123, 3, 244, 37} ,{123, 3, 245, 37} ,{123, 3, 246, 37} ,{123, 3, 247, 37} ,{123, 3, 248, 37} ,{123, 3, 249, 37} ,{123, 3, 250, 37} ,{123, 3, 251, 37} ,{123, 3, 252, 37} ,{102, 167, 45, 0} ,{102, 167, 124, 3} ,{102, 167, 53, 0} ,{102, 167, 49, 0} ,{102, 167, 65, 0} ,{102, 167, 125, 3} ,{102, 167, 59, 0} ,{102, 167, 126, 3} ,{102, 167, 58, 0} ,{102, 167, 127, 3} ,{102, 167, 128, 3} ,{102, 167, 129, 3} ,{102, 167, 244, 1} ,{102, 167, 250, 1} ,{102, 167, 232, 1} ,{102, 167, 253, 1} ,{102, 167, 130, 3} ,{102, 167, 131, 3} ,{102, 167, 132, 3} ,{102, 167, 133, 3} ,{102, 167, 154, 1} ,{102, 167, 134, 3} ,{37, 179, 136, 3} ,{102, 167, 137, 3} ,{102, 167, 138, 3} ,{102, 167, 139, 3} ,{102, 167, 163, 1} ,{102, 167, 140, 3} ,{102, 167, 171, 1} ,{38, 179, 136, 3} ,{153, 172, 244, 1} ,{153, 172, 250, 1} ,{153, 172, 253, 1} ,{154, 172, 243, 170} ,{154, 172, 244, 170} ,{154, 172, 126, 174} ,{39, 179, 31, 1} ,{63, 171, 243, 170} ,{63, 171, 244, 170} ,{63, 171, 126, 174} ,{40, 179, 3, 0} ,{41, 179, 123, 40} ,{42, 179, 127, 174} ,{43, 179, 127, 174} ,{44, 179, 148, 3} ,{128, 174, 149, 3} ,{123, 3, 16, 0} ,{123, 3, 228, 37} ,{123, 3, 150, 3} ,{226, 167, 152, 3} ,{226, 167, 153, 3} ,{226, 167, 154, 3} ,{226, 167, 155, 3} ,{226, 167, 156, 3} ,{226, 167, 79, 3} ,{226, 167, 157, 3} ,{226, 167, 158, 3} ,{226, 167, 159, 3} ,{226, 167, 160, 3} ,{226, 167, 161, 3} ,{226, 167, 162, 3} ,{226, 167, 41, 3} ,{226, 167, 94, 2} ,{226, 167, 163, 3} ,{226, 167, 164, 3} ,{226, 167, 165, 3} ,{226, 167, 166, 3} ,{226, 167, 167, 3} ,{226, 167, 33, 3} ,{226, 167, 168, 3} ,{226, 167, 169, 3} ,{49, 170, 164, 3} ,{45, 179, 152, 3} ,{49, 170, 171, 3} ,{49, 170, 172, 3} ,{155, 172, 129, 174} ,{49, 170, 129, 174} ,{174, 170, 49, 0} ,{151, 3, 220, 167} ,{130, 174, 175, 3} ,{174, 170, 175, 3} ,{151, 3, 17, 168} ,{130, 174, 45, 0} ,{174, 170, 45, 0} ,{239, 168, 45, 0} ,{155, 172, 156, 172} ,{239, 168, 156, 172} ,{174, 170, 65, 0} ,{151, 3, 138, 167} ,{155, 172, 53, 0} ,{174, 170, 53, 0} ,{151, 3, 149, 167} ,{151, 3, 245, 167} ,{239, 168, 181, 2} ,{49, 170, 176, 3} ,{105, 168, 176, 3} ,{105, 168, 177, 3} ,{105, 168, 178, 3} ,{105, 168, 179, 3} ,{105, 168, 180, 3} ,{105, 168, 181, 3} ,{151, 3, 68, 172} ,{46, 179, 183, 3} ,{105, 168, 184, 3} ,{105, 168, 183, 3} ,{105, 168, 185, 3} ,{105, 168, 186, 3} ,{105, 168, 187, 3} ,{47, 179, 188, 3} ,{105, 168, 189, 3} ,{48, 179, 38, 1} ,{77, 168, 38, 1} ,{77, 168, 191, 3} ,{77, 168, 192, 3} ,{201, 166, 156, 172} ,{201, 166, 45, 0} ,{201, 166, 175, 3} ,{201, 166, 53, 0} ,{201, 166, 193, 3} ,{201, 166, 65, 0} ,{201, 166, 194, 3} ,{201, 166, 99, 169} ,{201, 166, 101, 169} ,{201, 166, 65, 171} ,{131, 174, 49, 0} ,{201, 166, 49, 0} ,{201, 166, 197, 3} ,{201, 166, 66, 171} ,{131, 174, 59, 0} ,{201, 166, 59, 0} ,{201, 166, 198, 3} ,{201, 166, 154, 1} ,{201, 166, 199, 3} ,{201, 166, 200, 3} ,{201, 166, 201, 3} ,{201, 166, 202, 3} ,{201, 166, 241, 1} ,{201, 166, 250, 1} ,{201, 166, 244, 1} ,{201, 166, 203, 3} ,{201, 166, 138, 3} ,{201, 166, 204, 3} ,{201, 166, 205, 3} ,{201, 166, 206, 3} ,{201, 166, 207, 3} ,{201, 166, 208, 3} ,{201, 166, 129, 3} ,{201, 166, 209, 3} ,{201, 166, 232, 1} ,{201, 166, 210, 3} ,{201, 166, 139, 3} ,{201, 166, 211, 3} ,{201, 166, 128, 3} ,{201, 166, 212, 3} ,{201, 166, 127, 3} ,{201, 166, 213, 3} ,{201, 166, 137, 3} ,{201, 166, 171, 1} ,{201, 166, 253, 1} ,{201, 166, 130, 3} ,{201, 166, 134, 3} ,{201, 166, 214, 3} ,{201, 166, 215, 3} ,{201, 166, 216, 3} ,{201, 166, 166, 1} ,{201, 166, 217, 3} ,{201, 166, 131, 3} ,{201, 166, 163, 1} ,{77, 168, 218, 3} ,{77, 168, 219, 3} ,{190, 3, 17, 168} ,{190, 3, 149, 167} ,{190, 3, 58, 168} ,{190, 3, 138, 167} ,{190, 3, 59, 168} ,{190, 3, 225, 168} ,{190, 3, 30, 169} ,{50, 170, 65, 171} ,{132, 174, 49, 0} ,{190, 3, 220, 167} ,{190, 3, 60, 168} ,{50, 170, 66, 171} ,{132, 174, 59, 0} ,{190, 3, 245, 167} ,{190, 3, 99, 168} ,{77, 168, 221, 3} ,{49, 179, 49, 0} ,{190, 3, 223, 3} ,{134, 174, 225, 3} ,{134, 174, 226, 3} ,{190, 3, 35, 38} ,{190, 3, 86, 38} ,{51, 179, 49, 0} ,{201, 166, 225, 1} ,{201, 166, 227, 3} ,{201, 166, 228, 3} ,{201, 166, 234, 1} ,{201, 166, 229, 3} ,{201, 166, 223, 1} ,{201, 166, 133, 3} ,{201, 166, 230, 3} ,{201, 166, 100, 169} ,{201, 166, 102, 169} ,{190, 3, 31, 169} ,{190, 3, 32, 169} ,{190, 3, 232, 3} ,{190, 3, 19, 171} ,{190, 3, 243, 37} ,{190, 3, 244, 37} ,{190, 3, 245, 37} ,{190, 3, 246, 37} ,{190, 3, 247, 37} ,{190, 3, 248, 37} ,{190, 3, 249, 37} ,{190, 3, 250, 37} ,{190, 3, 251, 37} ,{190, 3, 252, 37} ,{190, 3, 157, 177} ,{53, 179, 115, 0} ,{54, 179, 45, 0} ,{201, 166, 234, 3} ,{55, 179, 171, 1} ,{201, 166, 236, 3} ,{201, 166, 237, 3} ,{201, 166, 60, 169} ,{201, 166, 238, 3} ,{201, 166, 239, 3} ,{240, 3, 18, 171} ,{240, 3, 226, 168} ,{240, 3, 227, 168} ,{8, 167, 45, 0} ,{8, 167, 175, 3} ,{8, 167, 53, 0} ,{8, 167, 193, 3} ,{8, 167, 65, 0} ,{8, 167, 194, 3} ,{8, 167, 99, 169} ,{8, 167, 101, 169} ,{8, 167, 49, 0} ,{8, 167, 197, 3} ,{8, 167, 59, 0} ,{8, 167, 198, 3} ,{8, 167, 154, 1} ,{8, 167, 199, 3} ,{8, 167, 200, 3} ,{8, 167, 201, 3} ,{8, 167, 202, 3} ,{8, 167, 241, 1} ,{8, 167, 250, 1} ,{8, 167, 244, 1} ,{8, 167, 203, 3} ,{8, 167, 138, 3} ,{8, 167, 204, 3} ,{8, 167, 205, 3} ,{8, 167, 206, 3} ,{8, 167, 207, 3} ,{8, 167, 208, 3} ,{8, 167, 129, 3} ,{8, 167, 209, 3} ,{8, 167, 232, 1} ,{8, 167, 210, 3} ,{8, 167, 139, 3} ,{8, 167, 128, 3} ,{8, 167, 212, 3} ,{8, 167, 127, 3} ,{8, 167, 213, 3} ,{8, 167, 137, 3} ,{8, 167, 171, 1} ,{8, 167, 253, 1} ,{8, 167, 134, 3} ,{8, 167, 166, 1} ,{8, 167, 217, 3} ,{8, 167, 131, 3} ,{8, 167, 163, 1} ,{240, 3, 18, 170} ,{240, 3, 52, 170} ,{240, 3, 17, 168} ,{240, 3, 149, 167} ,{240, 3, 58, 168} ,{240, 3, 138, 167} ,{240, 3, 59, 168} ,{240, 3, 225, 168} ,{240, 3, 30, 169} ,{240, 3, 220, 167} ,{240, 3, 60, 168} ,{240, 3, 245, 167} ,{240, 3, 99, 168} ,{240, 3, 228, 168} ,{56, 179, 129, 3} ,{240, 3, 69, 171} ,{8, 167, 130, 3} ,{8, 167, 223, 1} ,{8, 167, 230, 3} ,{8, 167, 100, 169} ,{8, 167, 102, 169} ,{240, 3, 31, 169} ,{240, 3, 32, 169} ,{240, 3, 243, 37} ,{240, 3, 244, 37} ,{240, 3, 245, 37} ,{240, 3, 246, 37} ,{240, 3, 247, 37} ,{240, 3, 248, 37} ,{240, 3, 249, 37} ,{240, 3, 250, 37} ,{240, 3, 251, 37} ,{240, 3, 252, 37} ,{57, 179, 245, 3} ,{59, 179, 245, 3} ,{240, 3, 47, 177} ,{240, 3, 229, 64} ,{175, 170, 24, 0} ,{175, 170, 25, 0} ,{175, 170, 26, 0} ,{175, 170, 27, 0} ,{63, 179, 250, 3} ,{64, 179, 252, 3} ,{240, 3, 253, 3} ,{65, 179, 3, 0} ,{66, 179, 1, 4} ,{64, 171, 1, 4} ,{255, 3, 227, 168} ,{36, 167, 45, 0} ,{36, 167, 175, 3} ,{36, 167, 53, 0} ,{36, 167, 193, 3} ,{36, 167, 65, 0} ,{36, 167, 194, 3} ,{36, 167, 124, 3} ,{36, 167, 197, 3} ,{36, 167, 125, 3} ,{36, 167, 198, 3} ,{36, 167, 154, 1} ,{36, 167, 199, 3} ,{36, 167, 200, 3} ,{36, 167, 201, 3} ,{36, 167, 202, 3} ,{36, 167, 241, 1} ,{36, 167, 250, 1} ,{36, 167, 244, 1} ,{36, 167, 203, 3} ,{36, 167, 138, 3} ,{36, 167, 204, 3} ,{36, 167, 205, 3} ,{36, 167, 206, 3} ,{36, 167, 207, 3} ,{36, 167, 208, 3} ,{36, 167, 129, 3} ,{36, 167, 209, 3} ,{36, 167, 232, 1} ,{36, 167, 210, 3} ,{36, 167, 139, 3} ,{36, 167, 128, 3} ,{36, 167, 212, 3} ,{36, 167, 127, 3} ,{36, 167, 213, 3} ,{36, 167, 137, 3} ,{36, 167, 171, 1} ,{36, 167, 253, 1} ,{36, 167, 134, 3} ,{36, 167, 214, 3} ,{36, 167, 216, 3} ,{36, 167, 166, 1} ,{36, 167, 131, 3} ,{36, 167, 163, 1} ,{255, 3, 18, 170} ,{255, 3, 17, 168} ,{255, 3, 149, 167} ,{255, 3, 58, 168} ,{255, 3, 138, 167} ,{255, 3, 59, 168} ,{255, 3, 185, 169} ,{255, 3, 60, 168} ,{255, 3, 185, 168} ,{255, 3, 99, 168} ,{255, 3, 228, 168} ,{64, 171, 2, 4} ,{36, 167, 227, 3} ,{36, 167, 228, 3} ,{36, 167, 234, 1} ,{36, 167, 130, 3} ,{36, 167, 133, 3} ,{255, 3, 243, 37} ,{255, 3, 244, 37} ,{255, 3, 245, 37} ,{255, 3, 246, 37} ,{255, 3, 247, 37} ,{255, 3, 248, 37} ,{255, 3, 249, 37} ,{255, 3, 250, 37} ,{255, 3, 251, 37} ,{255, 3, 252, 37} ,{255, 3, 3, 4} ,{255, 3, 4, 4} ,{255, 3, 5, 4} ,{255, 3, 6, 4} ,{67, 179, 8, 4} ,{64, 171, 9, 4} ,{10, 4, 18, 171} ,{10, 4, 226, 168} ,{10, 4, 227, 168} ,{37, 167, 45, 0} ,{37, 167, 175, 3} ,{37, 167, 53, 0} ,{37, 167, 193, 3} ,{37, 167, 65, 0} ,{37, 167, 194, 3} ,{37, 167, 99, 169} ,{37, 167, 101, 169} ,{136, 174, 65, 171} ,{37, 167, 49, 0} ,{37, 167, 197, 3} ,{136, 174, 66, 171} ,{37, 167, 59, 0} ,{37, 167, 198, 3} ,{37, 167, 154, 1} ,{37, 167, 199, 3} ,{37, 167, 200, 3} ,{37, 167, 201, 3} ,{37, 167, 202, 3} ,{37, 167, 241, 1} ,{37, 167, 250, 1} ,{37, 167, 244, 1} ,{37, 167, 203, 3} ,{37, 167, 138, 3} ,{37, 167, 204, 3} ,{37, 167, 205, 3} ,{37, 167, 206, 3} ,{37, 167, 207, 3} ,{37, 167, 208, 3} ,{37, 167, 129, 3} ,{37, 167, 209, 3} ,{37, 167, 232, 1} ,{37, 167, 210, 3} ,{37, 167, 139, 3} ,{37, 167, 128, 3} ,{37, 167, 212, 3} ,{37, 167, 127, 3} ,{37, 167, 213, 3} ,{37, 167, 137, 3} ,{37, 167, 171, 1} ,{37, 167, 253, 1} ,{37, 167, 134, 3} ,{37, 167, 214, 3} ,{37, 167, 216, 3} ,{37, 167, 166, 1} ,{37, 167, 217, 3} ,{37, 167, 131, 3} ,{37, 167, 163, 1} ,{10, 4, 18, 170} ,{10, 4, 52, 170} ,{10, 4, 17, 168} ,{10, 4, 149, 167} ,{10, 4, 58, 168} ,{10, 4, 138, 167} ,{10, 4, 59, 168} ,{10, 4, 225, 168} ,{10, 4, 30, 169} ,{137, 174, 65, 171} ,{10, 4, 220, 167} ,{10, 4, 60, 168} ,{137, 174, 66, 171} ,{10, 4, 245, 167} ,{10, 4, 99, 168} ,{10, 4, 228, 168} ,{10, 4, 223, 3} ,{37, 167, 100, 169} ,{37, 167, 102, 169} ,{10, 4, 31, 169} ,{10, 4, 32, 169} ,{10, 4, 243, 37} ,{10, 4, 244, 37} ,{10, 4, 245, 37} ,{10, 4, 246, 37} ,{10, 4, 247, 37} ,{10, 4, 248, 37} ,{10, 4, 249, 37} ,{10, 4, 250, 37} ,{10, 4, 251, 37} ,{10, 4, 252, 37} ,{10, 4, 229, 64} ,{11, 4, 18, 171} ,{11, 4, 226, 168} ,{11, 4, 227, 168} ,{9, 167, 45, 0} ,{9, 167, 175, 3} ,{9, 167, 53, 0} ,{9, 167, 193, 3} ,{9, 167, 65, 0} ,{9, 167, 194, 3} ,{9, 167, 99, 169} ,{9, 167, 101, 169} ,{9, 167, 49, 0} ,{9, 167, 197, 3} ,{9, 167, 59, 0} ,{9, 167, 198, 3} ,{9, 167, 154, 1} ,{9, 167, 199, 3} ,{9, 167, 200, 3} ,{9, 167, 201, 3} ,{9, 167, 202, 3} ,{9, 167, 241, 1} ,{9, 167, 250, 1} ,{9, 167, 244, 1} ,{9, 167, 203, 3} ,{9, 167, 138, 3} ,{9, 167, 204, 3} ,{9, 167, 205, 3} ,{9, 167, 206, 3} ,{9, 167, 207, 3} ,{9, 167, 208, 3} ,{9, 167, 129, 3} ,{9, 167, 209, 3} ,{9, 167, 232, 1} ,{9, 167, 210, 3} ,{9, 167, 139, 3} ,{9, 167, 128, 3} ,{9, 167, 212, 3} ,{9, 167, 127, 3} ,{9, 167, 213, 3} ,{9, 167, 137, 3} ,{9, 167, 171, 1} ,{9, 167, 253, 1} ,{9, 167, 134, 3} ,{9, 167, 214, 3} ,{9, 167, 216, 3} ,{9, 167, 166, 1} ,{9, 167, 217, 3} ,{9, 167, 131, 3} ,{9, 167, 163, 1} ,{11, 4, 18, 170} ,{11, 4, 52, 170} ,{11, 4, 17, 168} ,{11, 4, 149, 167} ,{11, 4, 58, 168} ,{11, 4, 138, 167} ,{11, 4, 59, 168} ,{11, 4, 225, 168} ,{11, 4, 30, 169} ,{11, 4, 220, 167} ,{11, 4, 60, 168} ,{11, 4, 245, 167} ,{11, 4, 99, 168} ,{11, 4, 228, 168} ,{11, 4, 159, 172} ,{11, 4, 69, 171} ,{9, 167, 130, 3} ,{9, 167, 223, 1} ,{9, 167, 230, 3} ,{9, 167, 100, 169} ,{9, 167, 102, 169} ,{11, 4, 31, 169} ,{11, 4, 32, 169} ,{11, 4, 243, 37} ,{11, 4, 244, 37} ,{11, 4, 245, 37} ,{11, 4, 246, 37} ,{11, 4, 247, 37} ,{11, 4, 248, 37} ,{11, 4, 249, 37} ,{11, 4, 250, 37} ,{11, 4, 251, 37} ,{11, 4, 252, 37} ,{11, 4, 253, 3} ,{9, 167, 140, 3} ,{13, 4, 226, 168} ,{13, 4, 227, 168} ,{95, 167, 45, 0} ,{95, 167, 175, 3} ,{95, 167, 53, 0} ,{95, 167, 193, 3} ,{95, 167, 65, 0} ,{95, 167, 194, 3} ,{95, 167, 49, 0} ,{95, 167, 124, 3} ,{95, 167, 197, 3} ,{95, 167, 59, 0} ,{95, 167, 125, 3} ,{95, 167, 198, 3} ,{95, 167, 154, 1} ,{95, 167, 202, 3} ,{95, 167, 241, 1} ,{95, 167, 244, 1} ,{95, 167, 138, 3} ,{95, 167, 204, 3} ,{95, 167, 208, 3} ,{95, 167, 129, 3} ,{95, 167, 139, 3} ,{95, 167, 211, 3} ,{95, 167, 128, 3} ,{95, 167, 137, 3} ,{95, 167, 171, 1} ,{95, 167, 253, 1} ,{95, 167, 130, 3} ,{95, 167, 134, 3} ,{95, 167, 214, 3} ,{95, 167, 215, 3} ,{95, 167, 216, 3} ,{95, 167, 166, 1} ,{95, 167, 217, 3} ,{95, 167, 131, 3} ,{95, 167, 163, 1} ,{13, 4, 17, 168} ,{13, 4, 149, 167} ,{13, 4, 58, 168} ,{13, 4, 138, 167} ,{13, 4, 59, 168} ,{13, 4, 220, 167} ,{13, 4, 185, 169} ,{13, 4, 60, 168} ,{13, 4, 245, 167} ,{13, 4, 185, 168} ,{13, 4, 99, 168} ,{13, 4, 228, 168} ,{13, 4, 223, 3} ,{13, 4, 69, 171} ,{13, 4, 243, 37} ,{13, 4, 244, 37} ,{13, 4, 245, 37} ,{13, 4, 246, 37} ,{13, 4, 247, 37} ,{13, 4, 248, 37} ,{13, 4, 249, 37} ,{13, 4, 250, 37} ,{13, 4, 251, 37} ,{13, 4, 252, 37} ,{13, 4, 192, 168} ,{13, 4, 17, 170} ,{13, 4, 148, 170} ,{68, 179, 6, 0} ,{69, 179, 6, 0} ,{13, 4, 147, 177} ,{70, 179, 6, 0} ,{71, 179, 6, 0} ,{73, 179, 6, 0} ,{13, 4, 229, 64} ,{13, 4, 230, 37} ,{23, 4, 18, 171} ,{23, 4, 226, 168} ,{23, 4, 227, 168} ,{255, 166, 45, 0} ,{255, 166, 175, 3} ,{255, 166, 53, 0} ,{255, 166, 193, 3} ,{255, 166, 65, 0} ,{255, 166, 194, 3} ,{255, 166, 99, 169} ,{255, 166, 101, 169} ,{255, 166, 49, 0} ,{255, 166, 124, 3} ,{255, 166, 197, 3} ,{255, 166, 59, 0} ,{255, 166, 125, 3} ,{255, 166, 198, 3} ,{255, 166, 154, 1} ,{255, 166, 199, 3} ,{255, 166, 200, 3} ,{255, 166, 201, 3} ,{255, 166, 202, 3} ,{255, 166, 241, 1} ,{255, 166, 250, 1} ,{255, 166, 244, 1} ,{255, 166, 203, 3} ,{255, 166, 138, 3} ,{255, 166, 204, 3} ,{255, 166, 205, 3} ,{255, 166, 206, 3} ,{255, 166, 207, 3} ,{255, 166, 208, 3} ,{255, 166, 129, 3} ,{255, 166, 209, 3} ,{255, 166, 232, 1} ,{255, 166, 210, 3} ,{255, 166, 139, 3} ,{255, 166, 128, 3} ,{255, 166, 212, 3} ,{255, 166, 127, 3} ,{255, 166, 213, 3} ,{255, 166, 137, 3} ,{255, 166, 171, 1} ,{255, 166, 253, 1} ,{255, 166, 130, 3} ,{255, 166, 134, 3} ,{255, 166, 214, 3} ,{255, 166, 216, 3} ,{255, 166, 166, 1} ,{255, 166, 217, 3} ,{255, 166, 131, 3} ,{255, 166, 163, 1} ,{23, 4, 52, 170} ,{23, 4, 17, 168} ,{23, 4, 149, 167} ,{23, 4, 58, 168} ,{23, 4, 138, 167} ,{23, 4, 59, 168} ,{23, 4, 225, 168} ,{23, 4, 30, 169} ,{23, 4, 220, 167} ,{23, 4, 185, 169} ,{23, 4, 60, 168} ,{23, 4, 245, 167} ,{23, 4, 185, 168} ,{23, 4, 99, 168} ,{23, 4, 228, 168} ,{23, 4, 42, 169} ,{23, 4, 159, 172} ,{255, 166, 24, 4} ,{255, 166, 25, 4} ,{255, 166, 100, 169} ,{255, 166, 102, 169} ,{23, 4, 31, 169} ,{23, 4, 32, 169} ,{23, 4, 243, 37} ,{23, 4, 244, 37} ,{23, 4, 245, 37} ,{23, 4, 246, 37} ,{23, 4, 247, 37} ,{23, 4, 248, 37} ,{23, 4, 249, 37} ,{23, 4, 250, 37} ,{23, 4, 251, 37} ,{23, 4, 252, 37} ,{74, 179, 68, 171} ,{138, 174, 68, 171} ,{139, 174, 68, 171} ,{140, 174, 68, 171} ,{138, 174, 158, 172} ,{139, 174, 158, 172} ,{140, 174, 158, 172} ,{75, 179, 30, 4} ,{31, 4, 226, 168} ,{31, 4, 227, 168} ,{10, 167, 45, 0} ,{10, 167, 175, 3} ,{10, 167, 53, 0} ,{10, 167, 193, 3} ,{10, 167, 65, 0} ,{10, 167, 194, 3} ,{10, 167, 99, 169} ,{10, 167, 101, 169} ,{10, 167, 49, 0} ,{10, 167, 124, 3} ,{10, 167, 197, 3} ,{10, 167, 59, 0} ,{10, 167, 125, 3} ,{10, 167, 198, 3} ,{10, 167, 154, 1} ,{10, 167, 199, 3} ,{10, 167, 200, 3} ,{10, 167, 201, 3} ,{10, 167, 202, 3} ,{10, 167, 241, 1} ,{10, 167, 250, 1} ,{10, 167, 244, 1} ,{10, 167, 203, 3} ,{10, 167, 138, 3} ,{10, 167, 204, 3} ,{10, 167, 205, 3} ,{10, 167, 206, 3} ,{10, 167, 207, 3} ,{10, 167, 208, 3} ,{10, 167, 129, 3} ,{10, 167, 209, 3} ,{10, 167, 232, 1} ,{10, 167, 210, 3} ,{10, 167, 139, 3} ,{10, 167, 128, 3} ,{10, 167, 212, 3} ,{10, 167, 127, 3} ,{10, 167, 213, 3} ,{10, 167, 137, 3} ,{10, 167, 171, 1} ,{10, 167, 253, 1} ,{10, 167, 130, 3} ,{10, 167, 134, 3} ,{10, 167, 214, 3} ,{10, 167, 216, 3} ,{10, 167, 166, 1} ,{10, 167, 217, 3} ,{10, 167, 131, 3} ,{10, 167, 163, 1} ,{31, 4, 18, 170} ,{31, 4, 52, 170} ,{31, 4, 17, 168} ,{31, 4, 149, 167} ,{31, 4, 58, 168} ,{31, 4, 138, 167} ,{31, 4, 59, 168} ,{31, 4, 225, 168} ,{31, 4, 30, 169} ,{31, 4, 220, 167} ,{31, 4, 185, 169} ,{31, 4, 60, 168} ,{31, 4, 245, 167} ,{31, 4, 185, 168} ,{31, 4, 99, 168} ,{31, 4, 228, 168} ,{31, 4, 42, 169} ,{31, 4, 159, 172} ,{10, 167, 133, 3} ,{10, 167, 100, 169} ,{10, 167, 102, 169} ,{31, 4, 31, 169} ,{31, 4, 32, 169} ,{31, 4, 243, 37} ,{31, 4, 244, 37} ,{31, 4, 245, 37} ,{31, 4, 246, 37} ,{31, 4, 247, 37} ,{31, 4, 248, 37} ,{31, 4, 249, 37} ,{31, 4, 250, 37} ,{31, 4, 251, 37} ,{31, 4, 252, 37} ,{141, 174, 32, 4} ,{141, 174, 33, 4} ,{34, 4, 226, 168} ,{34, 4, 227, 168} ,{241, 166, 45, 0} ,{241, 166, 175, 3} ,{241, 166, 53, 0} ,{241, 166, 193, 3} ,{241, 166, 65, 0} ,{241, 166, 194, 3} ,{241, 166, 99, 169} ,{241, 166, 101, 169} ,{241, 166, 49, 0} ,{241, 166, 124, 3} ,{241, 166, 197, 3} ,{241, 166, 59, 0} ,{241, 166, 125, 3} ,{241, 166, 198, 3} ,{241, 166, 154, 1} ,{241, 166, 199, 3} ,{241, 166, 200, 3} ,{241, 166, 201, 3} ,{241, 166, 202, 3} ,{241, 166, 241, 1} ,{241, 166, 250, 1} ,{241, 166, 244, 1} ,{241, 166, 203, 3} ,{241, 166, 138, 3} ,{241, 166, 204, 3} ,{241, 166, 205, 3} ,{241, 166, 206, 3} ,{241, 166, 207, 3} ,{241, 166, 208, 3} ,{241, 166, 129, 3} ,{241, 166, 209, 3} ,{241, 166, 232, 1} ,{241, 166, 210, 3} ,{241, 166, 139, 3} ,{241, 166, 128, 3} ,{241, 166, 212, 3} ,{241, 166, 127, 3} ,{241, 166, 213, 3} ,{241, 166, 137, 3} ,{241, 166, 171, 1} ,{241, 166, 253, 1} ,{241, 166, 130, 3} ,{241, 166, 134, 3} ,{241, 166, 214, 3} ,{241, 166, 215, 3} ,{241, 166, 216, 3} ,{241, 166, 166, 1} ,{241, 166, 217, 3} ,{241, 166, 131, 3} ,{241, 166, 163, 1} ,{34, 4, 52, 170} ,{34, 4, 17, 168} ,{34, 4, 149, 167} ,{34, 4, 58, 168} ,{34, 4, 138, 167} ,{34, 4, 59, 168} ,{34, 4, 225, 168} ,{34, 4, 30, 169} ,{34, 4, 220, 167} ,{34, 4, 185, 169} ,{34, 4, 60, 168} ,{34, 4, 245, 167} ,{34, 4, 185, 168} ,{34, 4, 99, 168} ,{34, 4, 228, 168} ,{34, 4, 69, 171} ,{241, 166, 100, 169} ,{241, 166, 102, 169} ,{34, 4, 31, 169} ,{34, 4, 32, 169} ,{34, 4, 243, 37} ,{34, 4, 244, 37} ,{34, 4, 245, 37} ,{34, 4, 246, 37} ,{34, 4, 247, 37} ,{34, 4, 248, 37} ,{34, 4, 249, 37} ,{34, 4, 250, 37} ,{34, 4, 251, 37} ,{34, 4, 252, 37} ,{34, 4, 192, 168} ,{34, 4, 17, 170} ,{34, 4, 148, 170} ,{34, 4, 156, 177} ,{34, 4, 177, 173} ,{34, 4, 46, 177} ,{76, 179, 3, 0} ,{53, 170, 36, 4} ,{53, 170, 58, 0} ,{53, 170, 220, 3} ,{53, 170, 56, 0} ,{53, 170, 231, 3} ,{53, 170, 55, 0} ,{163, 172, 38, 4} ,{163, 172, 39, 4} ,{237, 166, 40, 4} ,{237, 166, 41, 4} ,{237, 166, 42, 4} ,{237, 166, 43, 4} ,{237, 166, 44, 4} ,{237, 166, 45, 4} ,{237, 166, 46, 4} ,{237, 166, 47, 4} ,{237, 166, 48, 4} ,{237, 166, 49, 4} ,{237, 166, 50, 4} ,{237, 166, 51, 4} ,{237, 166, 52, 4} ,{237, 166, 53, 4} ,{237, 166, 54, 4} ,{237, 166, 55, 4} ,{237, 166, 56, 4} ,{237, 166, 57, 4} ,{240, 168, 59, 4} ,{241, 168, 59, 4} ,{240, 168, 61, 4} ,{241, 168, 61, 4} ,{77, 179, 63, 4} ,{70, 171, 61, 4} ,{240, 168, 65, 4} ,{241, 168, 65, 4} ,{240, 168, 66, 4} ,{241, 168, 66, 4} ,{160, 172, 63, 4} ,{78, 179, 69, 4} ,{70, 171, 66, 4} ,{240, 168, 70, 4} ,{241, 168, 70, 4} ,{240, 168, 71, 4} ,{241, 168, 71, 4} ,{162, 172, 73, 4} ,{70, 171, 71, 4} ,{240, 168, 74, 4} ,{241, 168, 74, 4} ,{240, 168, 75, 4} ,{241, 168, 75, 4} ,{161, 172, 73, 4} ,{70, 171, 75, 4} ,{240, 168, 77, 4} ,{241, 168, 77, 4} ,{240, 168, 78, 4} ,{241, 168, 78, 4} ,{237, 166, 79, 4} ,{79, 179, 78, 4} ,{237, 166, 81, 4} ,{237, 166, 82, 4} ,{161, 172, 83, 4} ,{237, 166, 84, 4} ,{160, 172, 85, 4} ,{162, 172, 85, 4} ,{161, 172, 85, 4} ,{237, 166, 86, 4} ,{162, 172, 83, 4} ,{237, 166, 87, 4} ,{80, 179, 89, 4} ,{42, 168, 165, 172} ,{164, 172, 142, 174} ,{54, 170, 142, 174} ,{164, 172, 143, 174} ,{54, 170, 143, 174} ,{164, 172, 144, 174} ,{54, 170, 144, 174} ,{42, 168, 145, 174} ,{42, 168, 98, 4} ,{54, 170, 98, 4} ,{81, 179, 100, 4} ,{167, 172, 165, 172} ,{82, 179, 165, 172} ,{167, 172, 103, 4} ,{42, 168, 103, 4} ,{54, 170, 145, 174} ,{54, 170, 103, 4} ,{83, 179, 104, 4} ,{84, 179, 108, 4} ,{176, 170, 110, 4} ,{176, 170, 111, 4} ,{176, 170, 112, 4} ,{176, 170, 113, 4} ,{176, 170, 114, 4} ,{85, 179, 116, 4} ,{71, 171, 118, 4} ,{71, 171, 119, 4} ,{71, 171, 120, 4} ,{72, 171, 122, 4} ,{71, 171, 123, 4} ,{150, 174, 125, 4} ,{146, 174, 127, 4} ,{147, 174, 128, 4} ,{55, 170, 130, 4} ,{55, 170, 131, 4} ,{55, 170, 132, 4} ,{148, 174, 134, 4} ,{146, 174, 135, 4} ,{147, 174, 136, 4} ,{55, 170, 137, 4} ,{55, 170, 138, 4} ,{55, 170, 139, 4} ,{148, 174, 101, 1} ,{86, 179, 141, 4} ,{87, 179, 143, 4} ,{168, 172, 145, 4} ,{149, 174, 133, 3} ,{168, 172, 147, 4} ,{149, 174, 148, 4} ,{168, 172, 149, 4} ,{88, 179, 137, 3} ,{150, 174, 151, 4} ,{89, 179, 153, 4} ,{205, 166, 154, 4} ,{151, 174, 156, 4} ,{205, 166, 157, 4} ,{90, 179, 159, 4} ,{72, 171, 160, 4} ,{72, 171, 161, 4} ,{72, 171, 162, 4} ,{152, 174, 164, 4} ,{151, 174, 165, 4} ,{91, 179, 166, 4} ,{152, 174, 167, 4} ,{205, 166, 168, 4} ,{106, 168, 45, 0} ,{92, 179, 172, 4} ,{106, 168, 175, 3} ,{106, 168, 173, 4} ,{106, 168, 53, 0} ,{106, 168, 193, 3} ,{106, 168, 174, 4} ,{106, 168, 175, 4} ,{106, 168, 65, 0} ,{106, 168, 194, 3} ,{205, 166, 176, 4} ,{93, 179, 177, 4} ,{106, 168, 49, 0} ,{106, 168, 133, 0} ,{106, 168, 59, 0} ,{153, 174, 178, 4} ,{153, 174, 179, 4} ,{205, 166, 180, 4} ,{205, 166, 181, 4} ,{205, 166, 182, 4} ,{177, 170, 183, 4} ,{177, 170, 184, 4} ,{177, 170, 185, 4} ,{177, 170, 186, 4} ,{205, 166, 187, 4} ,{205, 166, 188, 4} ,{205, 166, 189, 4} ,{205, 166, 190, 4} ,{105, 4, 243, 37} ,{105, 4, 244, 37} ,{105, 4, 245, 37} ,{105, 4, 246, 37} ,{105, 4, 247, 37} ,{105, 4, 248, 37} ,{105, 4, 249, 37} ,{105, 4, 250, 37} ,{105, 4, 251, 37} ,{105, 4, 252, 37} ,{205, 166, 191, 4} ,{205, 166, 192, 4} ,{151, 167, 194, 4} ,{154, 174, 195, 4} ,{154, 174, 196, 4} ,{151, 167, 197, 4} ,{151, 167, 2, 2} ,{159, 174, 196, 4} ,{151, 167, 198, 4} ,{151, 167, 199, 4} ,{151, 167, 237, 1} ,{155, 174, 195, 4} ,{155, 174, 196, 4} ,{151, 167, 200, 4} ,{151, 167, 201, 4} ,{151, 167, 202, 4} ,{156, 174, 195, 4} ,{157, 174, 196, 4} ,{156, 174, 196, 4} ,{157, 174, 195, 4} ,{151, 167, 203, 4} ,{151, 167, 204, 4} ,{158, 174, 156, 4} ,{158, 174, 205, 4} ,{151, 167, 206, 4} ,{159, 174, 195, 4} ,{160, 174, 195, 4} ,{151, 167, 59, 0} ,{160, 174, 196, 4} ,{193, 4, 207, 4} ,{138, 169, 45, 0} ,{161, 174, 208, 4} ,{193, 4, 17, 168} ,{138, 169, 173, 4} ,{193, 4, 149, 167} ,{193, 4, 58, 168} ,{138, 169, 69, 0} ,{138, 169, 209, 4} ,{193, 4, 138, 167} ,{193, 4, 59, 168} ,{161, 174, 210, 4} ,{163, 174, 212, 4} ,{163, 174, 198, 4} ,{193, 4, 220, 167} ,{138, 169, 213, 4} ,{193, 4, 245, 167} ,{138, 169, 214, 4} ,{193, 4, 60, 168} ,{94, 179, 134, 3} ,{73, 171, 183, 4} ,{73, 171, 184, 4} ,{73, 171, 215, 4} ,{73, 171, 216, 4} ,{95, 179, 3, 0} ,{193, 4, 218, 4} ,{193, 4, 243, 37} ,{193, 4, 244, 37} ,{193, 4, 245, 37} ,{193, 4, 246, 37} ,{193, 4, 247, 37} ,{193, 4, 248, 37} ,{193, 4, 249, 37} ,{193, 4, 250, 37} ,{193, 4, 251, 37} ,{193, 4, 252, 37} ,{164, 174, 200, 4} ,{164, 174, 203, 4} ,{96, 179, 223, 3} ,{97, 179, 45, 0} ,{99, 179, 137, 3} ,{101, 179, 137, 3} ,{193, 174, 195, 174} ,{196, 174, 199, 174} ,{103, 179, 167, 174} ,{105, 179, 167, 174} ,{106, 179, 237, 4} ,{107, 179, 168, 174} ,{109, 179, 168, 174} ,{110, 179, 244, 4} ,{112, 179, 246, 4} ,{83, 167, 237, 4} ,{176, 172, 237, 4} ,{83, 167, 169, 174} ,{176, 172, 169, 174} ,{115, 179, 237, 4} ,{117, 179, 237, 4} ,{119, 179, 0, 5} ,{74, 171, 244, 4} ,{120, 179, 3, 5} ,{121, 179, 3, 5} ,{125, 179, 3, 5} ,{127, 179, 128, 3} ,{128, 179, 11, 5} ,{75, 171, 14, 5} ,{75, 171, 15, 5} ,{75, 171, 16, 5} ,{80, 171, 14, 5} ,{80, 171, 15, 5} ,{129, 179, 18, 5} ,{219, 4, 243, 37} ,{219, 4, 244, 37} ,{219, 4, 245, 37} ,{219, 4, 246, 37} ,{219, 4, 247, 37} ,{219, 4, 248, 37} ,{219, 4, 249, 37} ,{219, 4, 250, 37} ,{219, 4, 251, 37} ,{219, 4, 252, 37} ,{243, 168, 24, 0} ,{243, 168, 25, 0} ,{243, 168, 26, 0} ,{243, 168, 27, 0} ,{243, 168, 28, 0} ,{243, 168, 29, 0} ,{243, 168, 30, 0} ,{243, 168, 31, 0} ,{243, 168, 32, 0} ,{243, 168, 23, 0} ,{130, 179, 3, 5} ,{131, 179, 23, 5} ,{174, 174, 188, 174} ,{132, 179, 3, 5} ,{133, 179, 239, 4} ,{135, 179, 28, 5} ,{178, 174, 30, 5} ,{178, 174, 31, 5} ,{180, 174, 30, 5} ,{180, 174, 31, 5} ,{136, 179, 35, 5} ,{137, 179, 35, 5} ,{57, 167, 154, 1} ,{57, 167, 199, 3} ,{57, 167, 200, 3} ,{57, 167, 201, 3} ,{57, 167, 202, 3} ,{57, 167, 241, 1} ,{57, 167, 250, 1} ,{57, 167, 244, 1} ,{57, 167, 138, 3} ,{57, 167, 204, 3} ,{57, 167, 205, 3} ,{57, 167, 206, 3} ,{57, 167, 207, 3} ,{57, 167, 208, 3} ,{57, 167, 129, 3} ,{57, 167, 209, 3} ,{57, 167, 232, 1} ,{57, 167, 210, 3} ,{57, 167, 139, 3} ,{57, 167, 128, 3} ,{57, 167, 212, 3} ,{57, 167, 127, 3} ,{57, 167, 213, 3} ,{57, 167, 137, 3} ,{57, 167, 24, 4} ,{57, 167, 37, 5} ,{57, 167, 25, 4} ,{57, 167, 38, 5} ,{57, 167, 140, 3} ,{57, 167, 234, 3} ,{57, 167, 234, 1} ,{57, 167, 184, 174} ,{57, 167, 171, 1} ,{57, 167, 253, 1} ,{57, 167, 134, 3} ,{57, 167, 166, 1} ,{57, 167, 217, 3} ,{57, 167, 131, 3} ,{57, 167, 163, 1} ,{57, 167, 45, 0} ,{57, 167, 39, 5} ,{138, 179, 253, 1} ,{57, 167, 42, 5} ,{57, 167, 130, 3} ,{219, 4, 17, 168} ,{219, 4, 149, 167} ,{219, 4, 58, 168} ,{219, 4, 138, 167} ,{219, 4, 59, 168} ,{219, 4, 225, 168} ,{219, 4, 30, 169} ,{219, 4, 31, 169} ,{219, 4, 32, 169} ,{219, 4, 220, 167} ,{219, 4, 185, 169} ,{219, 4, 245, 167} ,{219, 4, 185, 168} ,{141, 179, 46, 5} ,{142, 179, 47, 5} ,{182, 174, 53, 0} ,{182, 174, 193, 3} ,{145, 179, 232, 1} ,{146, 179, 51, 5} ,{83, 167, 52, 5} ,{83, 167, 53, 5} ,{147, 179, 3, 5} ,{148, 179, 3, 5} ,{150, 179, 0, 5} ,{151, 179, 0, 5} ,{152, 179, 59, 5} ,{153, 179, 59, 5} ,{58, 167, 154, 1} ,{58, 167, 199, 3} ,{58, 167, 200, 3} ,{58, 167, 201, 3} ,{58, 167, 202, 3} ,{58, 167, 241, 1} ,{58, 167, 250, 1} ,{58, 167, 244, 1} ,{58, 167, 138, 3} ,{58, 167, 204, 3} ,{58, 167, 205, 3} ,{58, 167, 206, 3} ,{58, 167, 207, 3} ,{58, 167, 208, 3} ,{58, 167, 129, 3} ,{58, 167, 209, 3} ,{58, 167, 232, 1} ,{58, 167, 210, 3} ,{58, 167, 139, 3} ,{58, 167, 128, 3} ,{58, 167, 212, 3} ,{58, 167, 127, 3} ,{58, 167, 213, 3} ,{58, 167, 137, 3} ,{58, 167, 24, 4} ,{58, 167, 37, 5} ,{58, 167, 25, 4} ,{58, 167, 38, 5} ,{58, 167, 140, 3} ,{58, 167, 234, 3} ,{58, 167, 234, 1} ,{58, 167, 184, 174} ,{58, 167, 171, 1} ,{58, 167, 253, 1} ,{58, 167, 134, 3} ,{58, 167, 166, 1} ,{58, 167, 217, 3} ,{58, 167, 131, 3} ,{58, 167, 163, 1} ,{58, 167, 45, 0} ,{58, 167, 39, 5} ,{173, 172, 140, 3} ,{173, 172, 171, 1} ,{173, 172, 253, 1} ,{186, 174, 199, 3} ,{154, 179, 188, 174} ,{155, 179, 66, 5} ,{156, 179, 66, 5} ,{158, 179, 65, 0} ,{160, 179, 71, 5} ,{161, 179, 73, 5} ,{189, 174, 75, 5} ,{162, 179, 77, 5} ,{164, 179, 79, 5} ,{165, 179, 128, 3} ,{79, 171, 73, 5} ,{166, 179, 175, 172} ,{167, 179, 175, 172} ,{168, 179, 175, 172} ,{169, 179, 84, 5} ,{80, 171, 16, 5} ,{171, 179, 192, 174} ,{173, 179, 192, 174} ,{176, 172, 244, 4} ,{174, 179, 195, 174} ,{175, 179, 199, 174} ,{118, 0, 200, 174} ,{98, 0, 200, 174} ,{118, 0, 203, 174} ,{98, 0, 203, 174} ,{190, 166, 154, 1} ,{190, 166, 199, 3} ,{190, 166, 200, 3} ,{190, 166, 201, 3} ,{190, 166, 202, 3} ,{190, 166, 241, 1} ,{190, 166, 250, 1} ,{190, 166, 244, 1} ,{190, 166, 203, 3} ,{190, 166, 138, 3} ,{190, 166, 94, 5} ,{190, 166, 204, 3} ,{190, 166, 205, 3} ,{190, 166, 206, 3} ,{190, 166, 207, 3} ,{190, 166, 208, 3} ,{190, 166, 129, 3} ,{190, 166, 209, 3} ,{190, 166, 232, 1} ,{190, 166, 210, 3} ,{190, 166, 139, 3} ,{190, 166, 128, 3} ,{190, 166, 212, 3} ,{190, 166, 127, 3} ,{190, 166, 213, 3} ,{190, 166, 137, 3} ,{190, 166, 171, 1} ,{190, 166, 253, 1} ,{190, 166, 134, 3} ,{190, 166, 140, 3} ,{190, 166, 131, 3} ,{190, 166, 163, 1} ,{190, 166, 214, 3} ,{190, 166, 45, 0} ,{107, 168, 45, 0} ,{190, 166, 53, 0} ,{190, 166, 193, 3} ,{190, 166, 65, 0} ,{190, 166, 194, 3} ,{190, 166, 49, 0} ,{178, 170, 49, 0} ,{190, 166, 59, 0} ,{190, 166, 198, 3} ,{239, 167, 249, 174} ,{239, 167, 175, 3} ,{93, 5, 149, 167} ,{239, 167, 193, 3} ,{93, 5, 138, 167} ,{239, 167, 194, 3} ,{93, 5, 220, 167} ,{239, 167, 197, 3} ,{204, 174, 193, 3} ,{204, 174, 59, 0} ,{239, 167, 210, 174} ,{215, 167, 191, 3} ,{215, 167, 57, 168} ,{215, 167, 192, 3} ,{215, 167, 221, 3} ,{215, 167, 98, 5} ,{82, 171, 171, 1} ,{82, 171, 253, 1} ,{82, 171, 140, 3} ,{82, 171, 163, 1} ,{190, 166, 246, 174} ,{93, 5, 243, 37} ,{93, 5, 244, 37} ,{93, 5, 245, 37} ,{93, 5, 246, 37} ,{93, 5, 247, 37} ,{93, 5, 248, 37} ,{93, 5, 249, 37} ,{93, 5, 250, 37} ,{93, 5, 251, 37} ,{93, 5, 252, 37} ,{176, 179, 102, 5} ,{215, 167, 102, 5} ,{104, 169, 103, 5} ,{104, 169, 104, 5} ,{104, 169, 105, 5} ,{104, 169, 106, 5} ,{190, 166, 166, 1} ,{190, 166, 217, 3} ,{190, 166, 99, 169} ,{190, 166, 100, 169} ,{190, 166, 101, 169} ,{190, 166, 102, 169} ,{93, 5, 225, 168} ,{93, 5, 30, 169} ,{93, 5, 31, 169} ,{93, 5, 32, 169} ,{178, 170, 202, 3} ,{178, 170, 203, 3} ,{178, 170, 239, 3} ,{178, 170, 107, 5} ,{178, 172, 139, 3} ,{178, 172, 137, 3} ,{178, 172, 134, 3} ,{177, 179, 166, 1} ,{178, 179, 110, 5} ,{207, 174, 111, 5} ,{179, 179, 113, 5} ,{208, 174, 209, 3} ,{208, 174, 116, 5} ,{209, 174, 110, 5} ,{209, 174, 174, 4} ,{179, 170, 203, 172} ,{179, 170, 181, 170} ,{179, 170, 58, 170} ,{179, 170, 204, 172} ,{179, 170, 182, 170} ,{180, 172, 208, 3} ,{180, 172, 124, 5} ,{180, 172, 125, 5} ,{181, 179, 53, 0} ,{181, 172, 164, 0} ,{181, 172, 65, 0} ,{181, 172, 124, 3} ,{107, 168, 154, 1} ,{107, 168, 199, 3} ,{107, 168, 200, 3} ,{107, 168, 241, 1} ,{107, 168, 234, 1} ,{107, 168, 138, 3} ,{107, 168, 232, 1} ,{107, 168, 139, 3} ,{107, 168, 212, 3} ,{107, 168, 133, 3} ,{107, 168, 127, 3} ,{107, 168, 209, 3} ,{107, 168, 163, 1} ,{183, 179, 140, 3} ,{84, 171, 175, 3} ,{84, 171, 49, 0} ,{84, 171, 210, 174} ,{184, 179, 69, 0} ,{225, 169, 181, 170} ,{225, 169, 58, 170} ,{225, 169, 182, 170} ,{225, 169, 239, 174} ,{182, 172, 181, 170} ,{182, 172, 58, 170} ,{185, 179, 31, 1} ,{186, 179, 133, 3} ,{187, 179, 182, 170} ,{244, 168, 243, 37} ,{244, 168, 244, 37} ,{244, 168, 245, 37} ,{244, 168, 246, 37} ,{244, 168, 247, 37} ,{244, 168, 248, 37} ,{244, 168, 249, 37} ,{244, 168, 250, 37} ,{244, 168, 251, 37} ,{244, 168, 252, 37} ,{212, 174, 203, 172} ,{212, 174, 58, 170} ,{213, 174, 45, 0} ,{213, 174, 197, 3} ,{214, 174, 24, 0} ,{214, 174, 135, 5} ,{81, 167, 137, 5} ,{81, 167, 138, 5} ,{81, 167, 139, 5} ,{81, 167, 140, 5} ,{81, 167, 157, 1} ,{81, 167, 141, 5} ,{81, 167, 157, 3} ,{81, 167, 142, 5} ,{81, 167, 164, 3} ,{81, 167, 208, 4} ,{81, 167, 143, 5} ,{81, 167, 144, 5} ,{81, 167, 145, 5} ,{81, 167, 146, 5} ,{81, 167, 147, 5} ,{81, 167, 148, 5} ,{81, 167, 149, 5} ,{81, 167, 131, 1} ,{81, 167, 150, 5} ,{81, 167, 151, 5} ,{81, 167, 152, 5} ,{81, 167, 153, 5} ,{81, 167, 154, 5} ,{81, 167, 155, 5} ,{81, 167, 100, 2} ,{81, 167, 156, 5} ,{81, 167, 0, 5} ,{81, 167, 157, 5} ,{81, 167, 158, 5} ,{81, 167, 159, 5} ,{81, 167, 160, 5} ,{81, 167, 161, 5} ,{81, 167, 162, 5} ,{81, 167, 86, 2} ,{81, 167, 163, 5} ,{81, 167, 226, 1} ,{81, 167, 164, 5} ,{81, 167, 165, 5} ,{64, 167, 137, 5} ,{64, 167, 138, 5} ,{64, 167, 139, 5} ,{64, 167, 140, 5} ,{64, 167, 157, 1} ,{64, 167, 141, 5} ,{64, 167, 157, 3} ,{64, 167, 142, 5} ,{64, 167, 164, 3} ,{64, 167, 208, 4} ,{64, 167, 143, 5} ,{64, 167, 144, 5} ,{64, 167, 145, 5} ,{64, 167, 146, 5} ,{64, 167, 147, 5} ,{64, 167, 148, 5} ,{64, 167, 149, 5} ,{64, 167, 131, 1} ,{64, 167, 150, 5} ,{64, 167, 151, 5} ,{64, 167, 152, 5} ,{64, 167, 153, 5} ,{64, 167, 154, 5} ,{64, 167, 155, 5} ,{64, 167, 100, 2} ,{64, 167, 156, 5} ,{64, 167, 0, 5} ,{64, 167, 157, 5} ,{64, 167, 158, 5} ,{64, 167, 159, 5} ,{64, 167, 160, 5} ,{64, 167, 161, 5} ,{64, 167, 162, 5} ,{64, 167, 86, 2} ,{64, 167, 163, 5} ,{64, 167, 226, 1} ,{64, 167, 164, 5} ,{64, 167, 165, 5} ,{64, 167, 165, 3} ,{64, 167, 166, 5} ,{64, 167, 167, 5} ,{188, 179, 139, 5} ,{64, 167, 164, 2} ,{136, 5, 121, 64} ,{189, 179, 145, 5} ,{182, 166, 171, 5} ,{182, 166, 172, 5} ,{182, 166, 173, 5} ,{182, 166, 174, 5} ,{182, 166, 175, 5} ,{182, 166, 176, 5} ,{182, 166, 177, 5} ,{182, 166, 178, 5} ,{182, 166, 179, 5} ,{182, 166, 180, 5} ,{182, 166, 181, 5} ,{182, 166, 182, 5} ,{182, 166, 183, 5} ,{182, 166, 184, 5} ,{182, 166, 185, 5} ,{182, 166, 186, 5} ,{182, 166, 187, 5} ,{182, 166, 188, 5} ,{182, 166, 189, 5} ,{56, 170, 171, 5} ,{182, 166, 191, 5} ,{56, 170, 174, 5} ,{56, 170, 178, 5} ,{126, 170, 171, 5} ,{150, 168, 173, 5} ,{182, 166, 194, 5} ,{150, 168, 189, 5} ,{182, 166, 195, 5} ,{21, 172, 178, 5} ,{182, 166, 197, 5} ,{78, 168, 171, 5} ,{78, 168, 173, 5} ,{78, 168, 174, 5} ,{78, 168, 180, 5} ,{249, 170, 171, 5} ,{249, 170, 174, 5} ,{249, 170, 178, 5} ,{78, 168, 181, 5} ,{249, 170, 183, 5} ,{78, 168, 183, 5} ,{78, 168, 185, 5} ,{78, 168, 187, 5} ,{78, 168, 188, 5} ,{182, 166, 200, 5} ,{182, 166, 201, 5} ,{82, 168, 171, 5} ,{82, 168, 173, 5} ,{82, 168, 174, 5} ,{82, 168, 176, 5} ,{82, 168, 177, 5} ,{82, 168, 178, 5} ,{190, 179, 171, 5} ,{82, 168, 181, 5} ,{82, 168, 182, 5} ,{82, 168, 183, 5} ,{82, 168, 185, 5} ,{82, 168, 186, 5} ,{82, 168, 187, 5} ,{82, 168, 188, 5} ,{82, 168, 189, 5} ,{182, 166, 202, 5} ,{182, 166, 203, 5} ,{182, 166, 204, 5} ,{182, 166, 205, 5} ,{182, 166, 206, 5} ,{186, 168, 171, 5} ,{186, 168, 174, 5} ,{186, 168, 177, 5} ,{186, 168, 178, 5} ,{186, 168, 180, 5} ,{186, 168, 206, 5} ,{182, 166, 208, 5} ,{186, 168, 183, 5} ,{186, 168, 185, 5} ,{186, 168, 187, 5} ,{186, 168, 188, 5} ,{182, 166, 209, 5} ,{191, 179, 182, 5} ,{182, 166, 211, 5} ,{182, 166, 212, 5} ,{182, 166, 213, 5} ,{182, 166, 214, 5} ,{215, 174, 186, 5} ,{215, 174, 189, 5} ,{182, 166, 216, 5} ,{182, 166, 217, 5} ,{52, 177, 178, 5} ,{182, 166, 219, 5} ,{182, 166, 220, 5} ,{182, 166, 221, 5} ,{192, 179, 174, 5} ,{56, 170, 180, 5} ,{56, 170, 183, 5} ,{56, 170, 189, 5} ,{126, 170, 176, 5} ,{182, 166, 223, 5} ,{189, 166, 223, 5} ,{189, 166, 45, 0} ,{189, 166, 133, 0} ,{189, 166, 171, 1} ,{189, 166, 224, 1} ,{189, 166, 225, 5} ,{189, 166, 49, 0} ,{189, 166, 226, 5} ,{189, 166, 227, 5} ,{189, 166, 59, 0} ,{189, 166, 140, 3} ,{189, 166, 228, 5} ,{189, 166, 164, 0} ,{189, 166, 204, 4} ,{189, 166, 65, 0} ,{189, 166, 229, 5} ,{189, 166, 226, 1} ,{189, 166, 230, 5} ,{189, 166, 170, 1} ,{189, 166, 110, 5} ,{189, 166, 141, 1} ,{189, 166, 53, 0} ,{184, 172, 59, 0} ,{184, 172, 65, 0} ,{185, 172, 59, 0} ,{185, 172, 204, 4} ,{183, 172, 59, 0} ,{183, 172, 65, 0} ,{183, 172, 110, 5} ,{186, 172, 59, 0} ,{186, 172, 65, 0} ,{105, 169, 225, 5} ,{105, 169, 49, 0} ,{105, 169, 227, 5} ,{105, 169, 59, 0} ,{105, 169, 65, 0} ,{188, 169, 171, 1} ,{188, 169, 224, 1} ,{188, 169, 226, 5} ,{188, 169, 59, 0} ,{188, 169, 53, 0} ,{2, 170, 45, 0} ,{2, 170, 133, 0} ,{193, 179, 110, 5} ,{2, 170, 227, 5} ,{2, 170, 65, 0} ,{106, 169, 45, 0} ,{106, 169, 225, 5} ,{106, 169, 49, 0} ,{106, 169, 226, 5} ,{106, 169, 227, 5} ,{106, 169, 65, 0} ,{106, 169, 53, 0} ,{127, 170, 65, 0} ,{127, 170, 110, 5} ,{194, 179, 65, 0} ,{125, 168, 45, 0} ,{125, 168, 171, 1} ,{125, 168, 59, 0} ,{125, 168, 65, 0} ,{125, 168, 110, 5} ,{125, 168, 242, 5} ,{189, 166, 242, 5} ,{252, 170, 225, 5} ,{252, 170, 65, 0} ,{252, 170, 53, 0} ,{189, 166, 244, 5} ,{184, 172, 110, 5} ,{185, 172, 65, 0} ,{186, 172, 171, 1} ,{105, 169, 171, 1} ,{105, 169, 224, 1} ,{176, 166, 171, 5} ,{176, 166, 172, 5} ,{141, 169, 180, 5} ,{176, 166, 173, 5} ,{107, 169, 183, 5} ,{107, 169, 189, 5} ,{176, 166, 174, 5} ,{176, 166, 176, 5} ,{157, 167, 171, 5} ,{157, 167, 177, 5} ,{157, 167, 178, 5} ,{157, 167, 180, 5} ,{157, 167, 187, 5} ,{157, 167, 188, 5} ,{157, 167, 189, 5} ,{176, 166, 177, 5} ,{176, 166, 178, 5} ,{34, 169, 180, 5} ,{176, 166, 180, 5} ,{176, 166, 181, 5} ,{176, 166, 182, 5} ,{176, 166, 183, 5} ,{176, 166, 185, 5} ,{176, 166, 186, 5} ,{176, 166, 187, 5} ,{176, 166, 188, 5} ,{176, 166, 189, 5} ,{141, 169, 176, 5} ,{141, 169, 127, 173} ,{107, 169, 171, 5} ,{107, 169, 174, 5} ,{107, 169, 180, 5} ,{107, 169, 206, 5} ,{107, 169, 187, 5} ,{189, 169, 171, 5} ,{189, 169, 176, 5} ,{157, 167, 60, 172} ,{157, 167, 173, 5} ,{157, 167, 174, 5} ,{195, 179, 189, 5} ,{176, 166, 194, 5} ,{128, 173, 171, 5} ,{128, 173, 180, 5} ,{24, 172, 180, 5} ,{24, 172, 189, 5} ,{157, 167, 200, 5} ,{157, 167, 181, 5} ,{157, 167, 206, 5} ,{157, 167, 186, 5} ,{157, 167, 221, 5} ,{188, 168, 171, 5} ,{188, 168, 176, 5} ,{188, 168, 178, 5} ,{188, 168, 180, 5} ,{188, 168, 181, 5} ,{188, 168, 206, 5} ,{188, 168, 185, 5} ,{188, 168, 189, 5} ,{176, 166, 197, 5} ,{34, 169, 176, 5} ,{34, 169, 188, 5} ,{34, 169, 189, 5} ,{176, 166, 200, 5} ,{217, 168, 171, 5} ,{217, 168, 174, 5} ,{217, 168, 176, 5} ,{217, 168, 178, 5} ,{176, 166, 206, 5} ,{187, 172, 171, 5} ,{187, 172, 172, 5} ,{176, 166, 208, 5} ,{187, 172, 186, 5} ,{176, 166, 209, 5} ,{25, 172, 180, 5} ,{25, 172, 206, 5} ,{129, 173, 178, 5} ,{176, 166, 219, 5} ,{85, 171, 173, 5} ,{85, 171, 176, 5} ,{85, 171, 177, 5} ,{85, 171, 178, 5} ,{176, 166, 221, 5} ,{141, 169, 173, 5} ,{141, 169, 178, 5} ,{141, 169, 185, 5} ,{141, 169, 186, 5} ,{141, 169, 189, 5} ,{176, 166, 191, 5} ,{150, 166, 163, 1} ,{150, 166, 249, 5} ,{150, 166, 250, 5} ,{150, 166, 75, 3} ,{150, 166, 251, 5} ,{150, 166, 86, 2} ,{150, 166, 243, 1} ,{150, 166, 252, 5} ,{150, 166, 134, 3} ,{150, 166, 157, 4} ,{150, 166, 253, 5} ,{150, 166, 254, 5} ,{150, 166, 255, 5} ,{150, 166, 0, 6} ,{150, 166, 212, 4} ,{150, 166, 1, 6} ,{150, 166, 2, 6} ,{150, 166, 3, 6} ,{150, 166, 4, 6} ,{150, 166, 100, 3} ,{150, 166, 5, 6} ,{150, 166, 6, 6} ,{150, 166, 7, 6} ,{150, 166, 8, 6} ,{150, 166, 137, 3} ,{150, 166, 100, 1} ,{150, 166, 9, 6} ,{150, 166, 10, 6} ,{150, 166, 11, 6} ,{150, 166, 12, 6} ,{150, 166, 203, 4} ,{150, 166, 13, 6} ,{150, 166, 14, 6} ,{150, 166, 15, 6} ,{150, 166, 16, 6} ,{150, 166, 17, 6} ,{150, 166, 18, 6} ,{150, 166, 19, 6} ,{150, 166, 20, 6} ,{150, 166, 21, 6} ,{150, 166, 253, 1} ,{150, 166, 154, 4} ,{150, 166, 22, 6} ,{150, 166, 78, 3} ,{150, 166, 23, 6} ,{150, 166, 24, 6} ,{150, 166, 46, 5} ,{150, 166, 25, 6} ,{150, 166, 131, 3} ,{150, 166, 26, 6} ,{150, 166, 27, 6} ,{150, 166, 28, 6} ,{150, 166, 29, 6} ,{150, 166, 30, 6} ,{150, 166, 122, 4} ,{150, 166, 31, 6} ,{150, 166, 166, 1} ,{150, 166, 32, 6} ,{150, 166, 33, 6} ,{150, 166, 34, 6} ,{150, 166, 35, 6} ,{150, 166, 36, 6} ,{150, 166, 130, 1} ,{150, 166, 37, 6} ,{150, 166, 225, 1} ,{150, 166, 38, 6} ,{150, 166, 39, 6} ,{150, 166, 40, 6} ,{150, 166, 41, 6} ,{150, 166, 42, 6} ,{150, 166, 43, 6} ,{150, 166, 44, 6} ,{150, 166, 45, 6} ,{150, 166, 46, 6} ,{150, 166, 47, 6} ,{150, 166, 48, 6} ,{150, 166, 49, 6} ,{150, 166, 50, 6} ,{150, 166, 51, 6} ,{150, 166, 52, 6} ,{150, 166, 53, 6} ,{150, 166, 54, 6} ,{150, 166, 55, 6} ,{150, 166, 56, 6} ,{150, 166, 57, 6} ,{150, 166, 58, 6} ,{150, 166, 59, 6} ,{150, 166, 60, 6} ,{150, 166, 61, 6} ,{150, 166, 127, 3} ,{150, 166, 73, 5} ,{150, 166, 62, 6} ,{150, 166, 79, 3} ,{150, 166, 63, 6} ,{150, 166, 148, 1} ,{150, 166, 201, 4} ,{150, 166, 64, 6} ,{150, 166, 216, 3} ,{150, 166, 65, 6} ,{150, 166, 66, 6} ,{150, 166, 67, 6} ,{150, 166, 68, 6} ,{150, 166, 149, 1} ,{150, 166, 249, 1} ,{150, 166, 69, 6} ,{150, 166, 129, 3} ,{150, 166, 70, 6} ,{150, 166, 215, 4} ,{150, 166, 71, 6} ,{150, 166, 72, 6} ,{150, 166, 161, 1} ,{150, 166, 237, 1} ,{150, 166, 73, 6} ,{150, 166, 241, 1} ,{150, 166, 74, 6} ,{150, 166, 75, 6} ,{150, 166, 76, 6} ,{150, 166, 77, 6} ,{150, 166, 78, 6} ,{150, 166, 2, 2} ,{150, 166, 79, 6} ,{150, 166, 80, 6} ,{150, 166, 81, 6} ,{150, 166, 102, 1} ,{150, 166, 82, 6} ,{150, 166, 83, 6} ,{150, 166, 84, 6} ,{150, 166, 85, 6} ,{150, 166, 86, 6} ,{150, 166, 87, 6} ,{150, 166, 88, 6} ,{150, 166, 89, 6} ,{150, 166, 90, 6} ,{150, 166, 91, 6} ,{150, 166, 139, 3} ,{150, 166, 101, 1} ,{150, 166, 92, 6} ,{150, 166, 122, 3} ,{150, 166, 93, 6} ,{150, 166, 94, 6} ,{150, 166, 200, 4} ,{150, 166, 95, 6} ,{150, 166, 138, 3} ,{150, 166, 96, 6} ,{150, 166, 97, 6} ,{150, 166, 98, 6} ,{150, 166, 99, 6} ,{150, 166, 100, 6} ,{150, 166, 198, 4} ,{150, 166, 101, 6} ,{93, 169, 45, 0} ,{93, 169, 65, 0} ,{93, 169, 53, 0} ,{93, 169, 175, 3} ,{93, 169, 124, 3} ,{93, 169, 49, 0} ,{93, 169, 59, 0} ,{93, 169, 140, 3} ,{150, 166, 154, 1} ,{150, 166, 102, 6} ,{150, 166, 103, 6} ,{150, 166, 104, 6} ,{150, 166, 105, 6} ,{150, 166, 106, 6} ,{150, 166, 194, 4} ,{150, 166, 107, 6} ,{150, 166, 108, 6} ,{150, 166, 109, 6} ,{150, 166, 110, 6} ,{150, 166, 111, 6} ,{150, 166, 112, 6} ,{150, 166, 113, 6} ,{150, 166, 114, 6} ,{150, 166, 115, 6} ,{150, 166, 116, 6} ,{150, 166, 117, 6} ,{150, 166, 118, 6} ,{150, 166, 119, 6} ,{150, 166, 120, 6} ,{150, 166, 121, 6} ,{150, 166, 122, 6} ,{150, 166, 123, 6} ,{150, 166, 124, 6} ,{150, 166, 140, 3} ,{150, 166, 125, 6} ,{150, 166, 230, 5} ,{150, 166, 126, 6} ,{150, 166, 127, 6} ,{150, 166, 226, 1} ,{150, 166, 206, 4} ,{150, 166, 128, 6} ,{226, 169, 45, 0} ,{226, 169, 65, 0} ,{226, 169, 53, 0} ,{226, 169, 175, 3} ,{226, 169, 124, 3} ,{226, 169, 49, 0} ,{226, 169, 59, 0} ,{150, 166, 234, 1} ,{150, 166, 129, 6} ,{150, 166, 130, 6} ,{150, 166, 103, 3} ,{150, 166, 131, 6} ,{150, 166, 153, 1} ,{150, 166, 107, 3} ,{150, 166, 132, 6} ,{150, 166, 234, 3} ,{150, 166, 133, 6} ,{150, 166, 134, 6} ,{150, 166, 135, 6} ,{150, 166, 136, 6} ,{150, 166, 152, 1} ,{150, 166, 137, 6} ,{150, 166, 138, 6} ,{150, 166, 171, 1} ,{150, 166, 170, 1} ,{150, 166, 141, 1} ,{150, 166, 95, 3} ,{150, 166, 139, 6} ,{150, 166, 227, 5} ,{150, 166, 204, 4} ,{150, 166, 140, 6} ,{150, 166, 232, 1} ,{150, 166, 141, 6} ,{150, 166, 142, 6} ,{150, 166, 143, 6} ,{150, 166, 144, 6} ,{150, 166, 151, 1} ,{150, 166, 199, 4} ,{150, 166, 145, 6} ,{150, 166, 206, 3} ,{150, 166, 146, 6} ,{150, 166, 147, 6} ,{150, 166, 148, 6} ,{150, 166, 149, 6} ,{150, 166, 150, 6} ,{150, 166, 151, 6} ,{150, 166, 152, 6} ,{150, 166, 244, 1} ,{150, 166, 153, 6} ,{150, 166, 154, 6} ,{150, 166, 155, 6} ,{150, 166, 156, 6} ,{150, 166, 142, 1} ,{150, 166, 157, 6} ,{150, 166, 158, 6} ,{150, 166, 200, 3} ,{150, 166, 159, 6} ,{150, 166, 160, 6} ,{150, 166, 161, 6} ,{150, 166, 162, 6} ,{150, 166, 163, 6} ,{150, 166, 164, 6} ,{150, 166, 165, 6} ,{150, 166, 166, 6} ,{150, 166, 167, 6} ,{150, 166, 168, 6} ,{150, 166, 169, 6} ,{150, 166, 170, 6} ,{150, 166, 236, 3} ,{150, 166, 171, 6} ,{150, 166, 172, 6} ,{150, 166, 173, 6} ,{150, 166, 174, 6} ,{150, 166, 175, 6} ,{150, 166, 176, 6} ,{150, 166, 177, 6} ,{150, 166, 209, 3} ,{150, 166, 178, 6} ,{150, 166, 179, 6} ,{150, 166, 87, 3} ,{150, 166, 180, 6} ,{150, 166, 181, 6} ,{150, 166, 184, 4} ,{150, 166, 182, 6} ,{150, 166, 250, 1} ,{150, 166, 183, 6} ,{150, 166, 108, 1} ,{150, 166, 184, 6} ,{150, 166, 185, 6} ,{150, 166, 165, 1} ,{150, 166, 186, 6} ,{150, 166, 187, 6} ,{150, 166, 212, 3} ,{150, 166, 188, 6} ,{150, 166, 245, 0} ,{150, 166, 189, 6} ,{150, 166, 190, 6} ,{150, 166, 191, 6} ,{150, 166, 113, 5} ,{150, 166, 192, 6} ,{150, 166, 24, 4} ,{150, 166, 193, 6} ,{150, 166, 194, 6} ,{150, 166, 195, 6} ,{150, 166, 196, 6} ,{150, 166, 164, 1} ,{150, 166, 197, 6} ,{150, 166, 198, 6} ,{150, 166, 199, 6} ,{150, 166, 200, 6} ,{150, 166, 201, 6} ,{150, 166, 202, 6} ,{150, 166, 203, 6} ,{150, 166, 204, 6} ,{150, 166, 205, 6} ,{150, 166, 206, 6} ,{150, 166, 133, 3} ,{150, 166, 207, 6} ,{150, 166, 165, 3} ,{150, 166, 208, 6} ,{150, 166, 209, 6} ,{150, 166, 69, 3} ,{150, 166, 210, 6} ,{150, 166, 211, 6} ,{150, 166, 128, 3} ,{150, 166, 212, 6} ,{150, 166, 104, 1} ,{150, 166, 213, 6} ,{150, 166, 214, 6} ,{150, 166, 158, 1} ,{150, 166, 202, 4} ,{150, 166, 116, 5} ,{150, 166, 215, 6} ,{150, 166, 216, 6} ,{150, 166, 217, 6} ,{197, 179, 3, 0} ,{248, 5, 71, 172} ,{248, 5, 219, 6} ,{248, 5, 241, 37} ,{248, 5, 16, 0} ,{248, 5, 34, 0} ,{248, 5, 33, 0} ,{198, 179, 33, 0} ,{248, 5, 2, 38} ,{248, 5, 121, 64} ,{248, 5, 244, 37} ,{248, 5, 245, 37} ,{248, 5, 246, 37} ,{248, 5, 247, 37} ,{248, 5, 248, 37} ,{248, 5, 249, 37} ,{248, 5, 250, 37} ,{248, 5, 251, 37} ,{248, 5, 252, 37} ,{248, 5, 192, 168} ,{245, 168, 221, 6} ,{245, 168, 222, 6} ,{245, 168, 223, 6} ,{245, 168, 224, 6} ,{245, 168, 225, 6} ,{245, 168, 226, 6} ,{245, 168, 227, 6} ,{245, 168, 228, 6} ,{245, 168, 15, 4} ,{245, 168, 66, 172} ,{86, 171, 13, 6} ,{150, 166, 230, 6} ,{150, 166, 231, 6} ,{150, 166, 232, 6} ,{86, 171, 64, 6} ,{150, 166, 233, 6} ,{150, 166, 234, 6} ,{150, 166, 235, 6} ,{86, 171, 211, 6} ,{150, 166, 236, 6} ,{150, 166, 237, 6} ,{150, 166, 238, 6} ,{86, 171, 116, 5} ,{150, 166, 239, 6} ,{150, 166, 240, 6} ,{150, 166, 241, 6} ,{247, 168, 243, 6} ,{247, 168, 244, 6} ,{247, 168, 245, 6} ,{199, 179, 245, 6} ,{247, 168, 246, 6} ,{247, 168, 247, 6} ,{247, 168, 248, 6} ,{247, 168, 249, 6} ,{200, 179, 249, 6} ,{247, 168, 251, 6} ,{194, 166, 45, 0} ,{194, 166, 49, 0} ,{194, 166, 53, 0} ,{194, 166, 59, 0} ,{194, 166, 65, 0} ,{194, 166, 66, 0} ,{194, 166, 200, 3} ,{194, 166, 154, 1} ,{194, 166, 163, 6} ,{194, 166, 160, 6} ,{194, 166, 164, 6} ,{194, 166, 159, 6} ,{194, 166, 253, 6} ,{194, 166, 163, 1} ,{194, 166, 86, 2} ,{194, 166, 250, 5} ,{194, 166, 243, 1} ,{194, 166, 249, 5} ,{194, 166, 183, 0} ,{194, 166, 134, 3} ,{194, 166, 0, 6} ,{194, 166, 253, 5} ,{194, 166, 212, 4} ,{194, 166, 157, 4} ,{194, 166, 254, 6} ,{194, 166, 137, 3} ,{194, 166, 12, 6} ,{194, 166, 9, 6} ,{194, 166, 203, 4} ,{194, 166, 100, 1} ,{194, 166, 139, 3} ,{194, 166, 255, 6} ,{194, 166, 0, 7} ,{194, 166, 94, 6} ,{194, 166, 92, 6} ,{194, 166, 200, 4} ,{194, 166, 101, 1} ,{194, 166, 1, 7} ,{194, 166, 2, 7} ,{194, 166, 3, 7} ,{194, 166, 4, 7} ,{194, 166, 5, 7} ,{194, 166, 6, 7} ,{194, 166, 7, 7} ,{194, 166, 131, 3} ,{194, 166, 63, 0} ,{194, 166, 30, 6} ,{194, 166, 27, 6} ,{194, 166, 122, 4} ,{194, 166, 26, 6} ,{194, 166, 8, 7} ,{194, 166, 232, 1} ,{194, 166, 129, 3} ,{194, 166, 151, 1} ,{194, 166, 161, 1} ,{194, 166, 142, 6} ,{194, 166, 215, 4} ,{194, 166, 199, 4} ,{194, 166, 141, 6} ,{194, 166, 9, 7} ,{194, 166, 10, 7} ,{194, 166, 11, 7} ,{194, 166, 12, 7} ,{194, 166, 13, 7} ,{194, 166, 14, 7} ,{194, 166, 15, 7} ,{194, 166, 16, 7} ,{194, 166, 24, 4} ,{194, 166, 164, 1} ,{194, 166, 194, 6} ,{194, 166, 197, 6} ,{194, 166, 193, 6} ,{194, 166, 17, 7} ,{194, 166, 140, 3} ,{194, 166, 226, 1} ,{194, 166, 230, 5} ,{194, 166, 206, 4} ,{194, 166, 125, 6} ,{194, 166, 18, 7} ,{194, 166, 171, 1} ,{194, 166, 227, 5} ,{194, 166, 141, 1} ,{194, 166, 204, 4} ,{194, 166, 170, 1} ,{194, 166, 19, 7} ,{125, 166, 104, 0} ,{125, 166, 49, 0} ,{125, 166, 22, 7} ,{125, 166, 53, 0} ,{125, 166, 193, 3} ,{125, 166, 59, 0} ,{125, 166, 125, 3} ,{166, 168, 125, 3} ,{167, 166, 124, 3} ,{167, 166, 53, 0} ,{125, 166, 45, 0} ,{125, 166, 175, 3} ,{125, 166, 226, 1} ,{192, 166, 226, 1} ,{125, 166, 230, 5} ,{192, 166, 230, 5} ,{125, 166, 27, 7} ,{192, 166, 27, 7} ,{125, 166, 206, 4} ,{192, 166, 206, 4} ,{125, 166, 28, 7} ,{192, 166, 28, 7} ,{83, 168, 28, 7} ,{125, 166, 140, 3} ,{192, 166, 140, 3} ,{125, 166, 126, 6} ,{192, 166, 126, 6} ,{83, 168, 126, 6} ,{125, 166, 197, 3} ,{166, 168, 67, 0} ,{125, 166, 60, 169} ,{109, 168, 129, 0} ,{109, 168, 128, 0} ,{201, 179, 12, 1} ,{202, 179, 12, 1} ,{109, 168, 107, 171} ,{109, 168, 12, 1} ,{109, 168, 227, 169} ,{205, 179, 32, 7} ,{109, 168, 89, 38} ,{206, 179, 146, 168} ,{109, 168, 33, 7} ,{109, 168, 181, 66} ,{125, 166, 157, 1} ,{125, 166, 164, 3} ,{125, 166, 146, 5} ,{125, 166, 137, 5} ,{125, 166, 158, 1} ,{125, 166, 34, 7} ,{125, 166, 104, 1} ,{125, 166, 35, 7} ,{125, 166, 202, 4} ,{125, 166, 36, 7} ,{166, 168, 36, 7} ,{167, 166, 251, 5} ,{167, 166, 250, 5} ,{125, 166, 128, 3} ,{125, 166, 213, 6} ,{125, 166, 241, 6} ,{192, 166, 241, 6} ,{125, 166, 239, 6} ,{192, 166, 239, 6} ,{125, 166, 37, 7} ,{192, 166, 37, 7} ,{125, 166, 38, 7} ,{192, 166, 38, 7} ,{125, 166, 39, 7} ,{192, 166, 39, 7} ,{125, 166, 116, 5} ,{192, 166, 116, 5} ,{125, 166, 40, 7} ,{192, 166, 40, 7} ,{166, 168, 40, 7} ,{125, 166, 60, 0} ,{192, 166, 60, 0} ,{167, 166, 52, 0} ,{125, 166, 161, 1} ,{125, 166, 41, 7} ,{125, 166, 215, 4} ,{125, 166, 42, 7} ,{125, 166, 237, 1} ,{125, 166, 43, 7} ,{166, 168, 43, 7} ,{167, 166, 144, 6} ,{167, 166, 142, 6} ,{125, 166, 129, 3} ,{125, 166, 71, 6} ,{125, 166, 44, 7} ,{192, 166, 44, 7} ,{125, 166, 45, 7} ,{192, 166, 45, 7} ,{125, 166, 46, 7} ,{192, 166, 46, 7} ,{125, 166, 25, 0} ,{192, 166, 25, 0} ,{125, 166, 47, 7} ,{192, 166, 47, 7} ,{125, 166, 73, 6} ,{192, 166, 73, 6} ,{125, 166, 48, 7} ,{192, 166, 48, 7} ,{83, 168, 48, 7} ,{125, 166, 64, 0} ,{125, 166, 49, 7} ,{125, 166, 50, 7} ,{125, 166, 51, 7} ,{125, 166, 204, 3} ,{125, 166, 106, 6} ,{125, 166, 52, 7} ,{125, 166, 103, 6} ,{125, 166, 53, 7} ,{125, 166, 194, 4} ,{125, 166, 54, 7} ,{166, 168, 54, 7} ,{125, 166, 154, 1} ,{125, 166, 104, 6} ,{125, 166, 112, 6} ,{192, 166, 112, 6} ,{125, 166, 109, 6} ,{192, 166, 109, 6} ,{125, 166, 55, 7} ,{192, 166, 55, 7} ,{125, 166, 56, 7} ,{192, 166, 56, 7} ,{125, 166, 57, 7} ,{192, 166, 57, 7} ,{125, 166, 108, 6} ,{192, 166, 108, 6} ,{125, 166, 110, 6} ,{192, 166, 110, 6} ,{83, 168, 110, 6} ,{125, 166, 55, 0} ,{125, 166, 58, 7} ,{88, 171, 5, 2} ,{88, 171, 61, 7} ,{88, 171, 62, 7} ,{88, 171, 63, 7} ,{125, 166, 78, 6} ,{125, 166, 64, 7} ,{125, 166, 75, 6} ,{125, 166, 65, 7} ,{125, 166, 2, 2} ,{125, 166, 66, 7} ,{166, 168, 66, 7} ,{125, 166, 241, 1} ,{125, 166, 76, 6} ,{125, 166, 67, 7} ,{192, 166, 67, 7} ,{125, 166, 68, 7} ,{192, 166, 68, 7} ,{125, 166, 69, 7} ,{192, 166, 69, 7} ,{125, 166, 70, 7} ,{192, 166, 70, 7} ,{125, 166, 71, 7} ,{192, 166, 71, 7} ,{125, 166, 79, 6} ,{192, 166, 79, 6} ,{125, 166, 72, 7} ,{192, 166, 72, 7} ,{83, 168, 72, 7} ,{125, 166, 47, 0} ,{46, 168, 74, 7} ,{125, 166, 12, 6} ,{125, 166, 75, 7} ,{125, 166, 9, 6} ,{125, 166, 76, 7} ,{125, 166, 203, 4} ,{125, 166, 77, 7} ,{166, 168, 77, 7} ,{125, 166, 137, 3} ,{125, 166, 10, 6} ,{125, 166, 232, 6} ,{192, 166, 232, 6} ,{125, 166, 230, 6} ,{192, 166, 230, 6} ,{125, 166, 78, 7} ,{192, 166, 78, 7} ,{125, 166, 79, 7} ,{192, 166, 79, 7} ,{125, 166, 80, 7} ,{192, 166, 80, 7} ,{125, 166, 13, 6} ,{192, 166, 13, 6} ,{125, 166, 81, 7} ,{192, 166, 81, 7} ,{83, 168, 81, 7} ,{125, 166, 57, 0} ,{192, 166, 57, 0} ,{125, 166, 82, 7} ,{216, 174, 57, 0} ,{46, 168, 57, 0} ,{125, 166, 94, 6} ,{125, 166, 84, 7} ,{125, 166, 92, 6} ,{125, 166, 85, 7} ,{125, 166, 200, 4} ,{125, 166, 86, 7} ,{166, 168, 86, 7} ,{125, 166, 139, 3} ,{125, 166, 122, 3} ,{125, 166, 87, 7} ,{192, 166, 87, 7} ,{125, 166, 95, 6} ,{192, 166, 95, 6} ,{125, 166, 88, 7} ,{192, 166, 88, 7} ,{83, 168, 88, 7} ,{125, 166, 58, 0} ,{167, 166, 228, 2} ,{125, 166, 89, 7} ,{125, 166, 0, 6} ,{125, 166, 90, 7} ,{125, 166, 253, 5} ,{125, 166, 91, 7} ,{125, 166, 212, 4} ,{125, 166, 92, 7} ,{166, 168, 92, 7} ,{125, 166, 134, 3} ,{125, 166, 254, 5} ,{125, 166, 93, 7} ,{192, 166, 93, 7} ,{125, 166, 94, 7} ,{192, 166, 94, 7} ,{125, 166, 95, 7} ,{192, 166, 95, 7} ,{125, 166, 96, 7} ,{192, 166, 96, 7} ,{125, 166, 97, 7} ,{192, 166, 97, 7} ,{125, 166, 1, 6} ,{192, 166, 1, 6} ,{125, 166, 98, 7} ,{192, 166, 98, 7} ,{125, 166, 56, 0} ,{192, 166, 56, 0} ,{217, 174, 56, 0} ,{125, 166, 30, 6} ,{125, 166, 99, 7} ,{125, 166, 27, 6} ,{125, 166, 100, 7} ,{125, 166, 122, 4} ,{125, 166, 101, 7} ,{166, 168, 101, 7} ,{125, 166, 131, 3} ,{125, 166, 28, 6} ,{125, 166, 102, 7} ,{192, 166, 102, 7} ,{125, 166, 103, 7} ,{192, 166, 103, 7} ,{125, 166, 104, 7} ,{192, 166, 104, 7} ,{125, 166, 105, 7} ,{192, 166, 105, 7} ,{125, 166, 106, 7} ,{192, 166, 106, 7} ,{125, 166, 31, 6} ,{192, 166, 31, 6} ,{125, 166, 107, 7} ,{192, 166, 107, 7} ,{83, 168, 107, 7} ,{125, 166, 63, 0} ,{216, 174, 63, 0} ,{125, 166, 108, 7} ,{22, 168, 63, 0} ,{208, 179, 111, 7} ,{83, 168, 112, 7} ,{209, 179, 67, 0} ,{83, 168, 114, 7} ,{83, 168, 115, 7} ,{83, 168, 116, 7} ,{83, 168, 117, 7} ,{125, 166, 36, 6} ,{125, 166, 33, 6} ,{125, 166, 118, 7} ,{125, 166, 130, 1} ,{125, 166, 119, 7} ,{125, 166, 166, 1} ,{125, 166, 34, 6} ,{125, 166, 120, 7} ,{192, 166, 120, 7} ,{125, 166, 121, 7} ,{192, 166, 121, 7} ,{125, 166, 122, 7} ,{192, 166, 122, 7} ,{125, 166, 123, 7} ,{192, 166, 123, 7} ,{125, 166, 124, 7} ,{192, 166, 124, 7} ,{125, 166, 37, 6} ,{192, 166, 37, 6} ,{125, 166, 125, 7} ,{192, 166, 125, 7} ,{125, 166, 126, 7} ,{125, 166, 227, 5} ,{125, 166, 127, 7} ,{125, 166, 141, 1} ,{125, 166, 128, 7} ,{125, 166, 204, 4} ,{125, 166, 129, 7} ,{166, 168, 129, 7} ,{125, 166, 171, 1} ,{125, 166, 95, 3} ,{125, 166, 130, 7} ,{192, 166, 130, 7} ,{125, 166, 131, 7} ,{192, 166, 131, 7} ,{125, 166, 132, 7} ,{192, 166, 132, 7} ,{125, 166, 133, 7} ,{192, 166, 133, 7} ,{125, 166, 134, 7} ,{192, 166, 134, 7} ,{125, 166, 124, 5} ,{192, 166, 124, 5} ,{125, 166, 135, 7} ,{192, 166, 135, 7} ,{83, 168, 135, 7} ,{125, 166, 69, 0} ,{211, 179, 69, 0} ,{192, 166, 69, 0} ,{46, 168, 141, 1} ,{125, 166, 24, 6} ,{236, 174, 24, 6} ,{192, 166, 0, 6} ,{125, 166, 138, 7} ,{125, 166, 22, 6} ,{125, 166, 139, 7} ,{125, 166, 46, 5} ,{125, 166, 140, 7} ,{192, 166, 212, 4} ,{125, 166, 253, 1} ,{125, 166, 78, 3} ,{192, 166, 134, 3} ,{125, 166, 141, 7} ,{192, 166, 141, 7} ,{125, 166, 62, 0} ,{192, 166, 62, 0} ,{217, 174, 62, 0} ,{125, 166, 69, 3} ,{125, 166, 142, 7} ,{125, 166, 165, 3} ,{125, 166, 143, 7} ,{125, 166, 210, 6} ,{125, 166, 144, 7} ,{125, 166, 133, 3} ,{125, 166, 208, 6} ,{125, 166, 145, 7} ,{192, 166, 145, 7} ,{125, 166, 50, 0} ,{125, 166, 181, 6} ,{189, 172, 181, 6} ,{125, 166, 179, 6} ,{189, 172, 179, 6} ,{125, 166, 147, 7} ,{189, 172, 147, 7} ,{125, 166, 184, 4} ,{125, 166, 148, 7} ,{125, 166, 209, 3} ,{125, 166, 87, 3} ,{125, 166, 149, 7} ,{192, 166, 149, 7} ,{125, 166, 74, 7} ,{125, 166, 150, 7} ,{125, 166, 151, 7} ,{125, 166, 152, 7} ,{125, 166, 205, 3} ,{125, 166, 153, 7} ,{125, 166, 154, 7} ,{125, 166, 155, 7} ,{125, 166, 156, 7} ,{125, 166, 157, 7} ,{142, 169, 86, 2} ,{142, 169, 250, 5} ,{142, 169, 159, 7} ,{142, 169, 243, 1} ,{142, 169, 160, 7} ,{142, 169, 163, 1} ,{142, 169, 75, 3} ,{142, 169, 52, 0} ,{212, 179, 52, 0} ,{125, 166, 162, 7} ,{125, 166, 163, 7} ,{125, 166, 39, 6} ,{125, 166, 164, 7} ,{125, 166, 43, 6} ,{125, 166, 165, 7} ,{125, 166, 225, 1} ,{125, 166, 40, 6} ,{125, 166, 61, 0} ,{125, 166, 166, 7} ,{125, 166, 167, 7} ,{125, 166, 168, 7} ,{125, 166, 169, 7} ,{192, 166, 24, 6} ,{192, 166, 22, 6} ,{192, 166, 46, 5} ,{192, 166, 253, 1} ,{125, 166, 170, 7} ,{125, 166, 171, 7} ,{125, 166, 172, 7} ,{125, 166, 197, 4} ,{125, 166, 173, 7} ,{125, 166, 202, 3} ,{125, 166, 174, 7} ,{125, 166, 228, 2} ,{125, 166, 175, 7} ,{46, 168, 36, 6} ,{46, 168, 33, 6} ,{46, 168, 130, 1} ,{46, 168, 166, 1} ,{135, 168, 181, 6} ,{135, 168, 179, 6} ,{135, 168, 184, 4} ,{135, 168, 209, 3} ,{135, 168, 74, 7} ,{125, 166, 177, 7} ,{125, 166, 178, 7} ,{125, 166, 179, 7} ,{125, 166, 180, 7} ,{125, 166, 222, 1} ,{125, 166, 181, 7} ,{125, 166, 182, 7} ,{144, 169, 181, 6} ,{144, 169, 179, 6} ,{144, 169, 147, 7} ,{144, 169, 184, 4} ,{144, 169, 148, 7} ,{144, 169, 209, 3} ,{144, 169, 87, 3} ,{144, 169, 74, 7} ,{213, 179, 46, 0} ,{22, 168, 49, 0} ,{22, 168, 53, 0} ,{22, 168, 59, 0} ,{22, 168, 45, 0} ,{22, 168, 226, 1} ,{22, 168, 230, 5} ,{22, 168, 206, 4} ,{22, 168, 140, 3} ,{22, 168, 94, 6} ,{22, 168, 92, 6} ,{22, 168, 200, 4} ,{22, 168, 139, 3} ,{22, 168, 106, 6} ,{22, 168, 103, 6} ,{22, 168, 194, 4} ,{22, 168, 154, 1} ,{46, 168, 86, 2} ,{46, 168, 250, 5} ,{46, 168, 243, 1} ,{46, 168, 163, 1} ,{167, 166, 185, 7} ,{167, 166, 186, 7} ,{167, 166, 150, 1} ,{167, 166, 187, 7} ,{167, 166, 188, 7} ,{167, 166, 201, 3} ,{167, 166, 154, 4} ,{167, 166, 46, 5} ,{167, 166, 24, 6} ,{167, 166, 23, 6} ,{167, 166, 22, 6} ,{167, 166, 253, 1} ,{167, 166, 125, 6} ,{167, 166, 206, 4} ,{167, 166, 226, 1} ,{167, 166, 127, 6} ,{167, 166, 230, 5} ,{167, 166, 140, 3} ,{167, 166, 189, 7} ,{167, 166, 190, 7} ,{167, 166, 191, 7} ,{167, 166, 192, 7} ,{167, 166, 193, 7} ,{167, 166, 194, 7} ,{167, 166, 178, 6} ,{167, 166, 184, 4} ,{167, 166, 181, 6} ,{167, 166, 180, 6} ,{167, 166, 179, 6} ,{167, 166, 209, 3} ,{167, 166, 195, 7} ,{167, 166, 51, 7} ,{167, 166, 49, 7} ,{167, 166, 196, 7} ,{167, 166, 50, 7} ,{167, 166, 204, 3} ,{167, 166, 212, 6} ,{167, 166, 202, 4} ,{167, 166, 158, 1} ,{167, 166, 214, 6} ,{167, 166, 104, 1} ,{167, 166, 128, 3} ,{167, 166, 60, 0} ,{167, 166, 159, 6} ,{167, 166, 164, 6} ,{167, 166, 163, 6} ,{167, 166, 162, 6} ,{167, 166, 160, 6} ,{167, 166, 200, 3} ,{167, 166, 197, 7} ,{167, 166, 198, 7} ,{167, 166, 199, 7} ,{167, 166, 200, 7} ,{167, 166, 201, 7} ,{167, 166, 199, 3} ,{167, 166, 202, 7} ,{167, 166, 203, 7} ,{167, 166, 204, 7} ,{167, 166, 205, 7} ,{167, 166, 206, 7} ,{167, 166, 42, 5} ,{167, 166, 207, 7} ,{167, 166, 101, 1} ,{167, 166, 200, 4} ,{167, 166, 94, 6} ,{167, 166, 93, 6} ,{167, 166, 92, 6} ,{167, 166, 139, 3} ,{167, 166, 100, 1} ,{167, 166, 203, 4} ,{167, 166, 12, 6} ,{167, 166, 11, 6} ,{167, 166, 9, 6} ,{167, 166, 137, 3} ,{167, 166, 170, 1} ,{167, 166, 204, 4} ,{167, 166, 227, 5} ,{167, 166, 139, 6} ,{167, 166, 141, 1} ,{167, 166, 171, 1} ,{167, 166, 153, 6} ,{46, 168, 153, 6} ,{167, 166, 157, 6} ,{167, 166, 142, 1} ,{167, 166, 156, 6} ,{167, 166, 154, 6} ,{46, 168, 154, 6} ,{167, 166, 244, 1} ,{167, 166, 208, 7} ,{167, 166, 209, 7} ,{167, 166, 210, 7} ,{167, 166, 211, 7} ,{167, 166, 212, 7} ,{167, 166, 237, 3} ,{167, 166, 157, 4} ,{167, 166, 212, 4} ,{167, 166, 0, 6} ,{167, 166, 255, 5} ,{167, 166, 253, 5} ,{167, 166, 134, 3} ,{167, 166, 213, 7} ,{167, 166, 214, 7} ,{167, 166, 215, 7} ,{167, 166, 216, 7} ,{167, 166, 217, 7} ,{167, 166, 10, 7} ,{167, 166, 218, 7} ,{167, 166, 179, 7} ,{167, 166, 219, 7} ,{167, 166, 220, 7} ,{167, 166, 177, 7} ,{167, 166, 222, 1} ,{167, 166, 221, 7} ,{167, 166, 168, 7} ,{167, 166, 166, 7} ,{167, 166, 222, 7} ,{167, 166, 167, 7} ,{167, 166, 169, 7} ,{167, 166, 15, 7} ,{167, 166, 14, 7} ,{167, 166, 12, 7} ,{167, 166, 223, 7} ,{167, 166, 13, 7} ,{167, 166, 11, 7} ,{167, 166, 129, 6} ,{167, 166, 107, 3} ,{167, 166, 153, 1} ,{167, 166, 131, 6} ,{167, 166, 130, 6} ,{167, 166, 234, 1} ,{167, 166, 70, 0} ,{214, 179, 70, 0} ,{167, 166, 224, 7} ,{167, 166, 225, 7} ,{167, 166, 139, 1} ,{167, 166, 226, 7} ,{167, 166, 227, 7} ,{167, 166, 25, 4} ,{167, 166, 26, 6} ,{167, 166, 122, 4} ,{167, 166, 30, 6} ,{167, 166, 29, 6} ,{167, 166, 27, 6} ,{167, 166, 131, 3} ,{167, 166, 32, 6} ,{167, 166, 130, 1} ,{167, 166, 36, 6} ,{167, 166, 35, 6} ,{167, 166, 33, 6} ,{167, 166, 166, 1} ,{167, 166, 126, 7} ,{167, 166, 193, 6} ,{167, 166, 197, 6} ,{167, 166, 164, 1} ,{167, 166, 196, 6} ,{167, 166, 194, 6} ,{167, 166, 24, 4} ,{167, 166, 183, 6} ,{167, 166, 186, 6} ,{167, 166, 165, 1} ,{167, 166, 185, 6} ,{167, 166, 108, 1} ,{167, 166, 250, 1} ,{167, 166, 228, 7} ,{167, 166, 229, 7} ,{167, 166, 230, 7} ,{167, 166, 231, 7} ,{167, 166, 232, 7} ,{167, 166, 233, 7} ,{215, 179, 6, 0} ,{125, 166, 241, 37} ,{125, 166, 235, 7} ,{125, 166, 236, 7} ,{125, 166, 237, 7} ,{125, 166, 238, 7} ,{125, 166, 239, 7} ,{125, 166, 240, 7} ,{125, 166, 241, 7} ,{125, 166, 242, 7} ,{135, 168, 243, 7} ,{135, 168, 244, 7} ,{135, 168, 245, 7} ,{135, 168, 246, 7} ,{135, 168, 247, 7} ,{135, 168, 182, 6} ,{135, 168, 149, 7} ,{216, 179, 74, 7} ,{22, 168, 67, 0} ,{217, 179, 3, 0} ,{161, 167, 250, 7} ,{161, 167, 251, 7} ,{161, 167, 252, 7} ,{161, 167, 253, 7} ,{161, 167, 254, 7} ,{161, 167, 255, 7} ,{161, 167, 0, 8} ,{161, 167, 1, 8} ,{161, 167, 2, 8} ,{161, 167, 3, 8} ,{161, 167, 4, 8} ,{161, 167, 5, 8} ,{161, 167, 6, 8} ,{161, 167, 7, 8} ,{161, 167, 8, 8} ,{161, 167, 9, 8} ,{161, 167, 10, 8} ,{161, 167, 11, 8} ,{161, 167, 12, 8} ,{161, 167, 13, 8} ,{161, 167, 14, 8} ,{161, 167, 15, 8} ,{161, 167, 16, 8} ,{161, 167, 17, 8} ,{161, 167, 18, 8} ,{161, 167, 19, 8} ,{248, 7, 218, 174} ,{218, 179, 218, 174} ,{221, 179, 50, 0} ,{206, 166, 66, 0} ,{223, 179, 65, 0} ,{206, 166, 190, 0} ,{206, 166, 69, 0} ,{206, 166, 67, 0} ,{225, 179, 144, 0} ,{206, 166, 137, 0} ,{226, 179, 45, 0} ,{227, 179, 59, 0} ,{228, 179, 45, 0} ,{206, 166, 32, 8} ,{180, 170, 219, 174} ,{62, 169, 219, 174} ,{206, 166, 59, 0} ,{206, 166, 164, 0} ,{206, 166, 146, 5} ,{231, 179, 62, 0} ,{206, 166, 41, 8} ,{206, 166, 42, 8} ,{232, 179, 55, 0} ,{206, 166, 51, 0} ,{206, 166, 163, 0} ,{234, 179, 51, 0} ,{206, 166, 46, 8} ,{236, 179, 67, 0} ,{237, 179, 52, 0} ,{238, 179, 52, 0} ,{180, 170, 220, 174} ,{62, 169, 220, 174} ,{240, 179, 221, 174} ,{62, 169, 221, 174} ,{190, 172, 58, 0} ,{243, 179, 53, 0} ,{206, 166, 49, 0} ,{244, 179, 54, 0} ,{206, 166, 60, 8} ,{245, 179, 133, 0} ,{246, 179, 45, 0} ,{247, 179, 63, 8} ,{249, 179, 60, 0} ,{250, 179, 67, 8} ,{251, 179, 63, 0} ,{253, 179, 222, 174} ,{62, 169, 222, 174} ,{206, 166, 47, 0} ,{206, 166, 70, 0} ,{255, 179, 223, 174} ,{62, 169, 223, 174} ,{206, 166, 48, 0} ,{1, 180, 224, 174} ,{62, 169, 224, 174} ,{190, 172, 60, 0} ,{2, 180, 60, 0} ,{4, 180, 49, 0} ,{6, 180, 57, 0} ,{180, 170, 225, 174} ,{62, 169, 225, 174} ,{9, 180, 56, 0} ,{190, 172, 56, 0} ,{206, 166, 86, 8} ,{206, 166, 87, 8} ,{11, 180, 48, 0} ,{13, 180, 59, 0} ,{206, 166, 92, 8} ,{206, 166, 93, 8} ,{206, 166, 94, 8} ,{206, 166, 95, 8} ,{206, 166, 96, 8} ,{206, 166, 97, 8} ,{180, 170, 190, 0} ,{62, 169, 190, 0} ,{14, 180, 190, 0} ,{206, 166, 61, 0} ,{206, 166, 68, 0} ,{21, 8, 226, 174} ,{15, 180, 100, 8} ,{16, 180, 100, 8} ,{17, 180, 82, 1} ,{18, 180, 82, 1} ,{19, 180, 82, 1} ,{43, 168, 45, 0} ,{43, 168, 53, 0} ,{43, 168, 65, 0} ,{43, 168, 154, 1} ,{43, 168, 200, 3} ,{43, 168, 202, 3} ,{43, 168, 129, 3} ,{43, 168, 232, 1} ,{43, 168, 139, 3} ,{43, 168, 128, 3} ,{43, 168, 127, 3} ,{43, 168, 137, 3} ,{43, 168, 171, 1} ,{43, 168, 134, 3} ,{43, 168, 140, 3} ,{43, 168, 131, 3} ,{43, 168, 163, 1} ,{105, 8, 149, 167} ,{105, 8, 138, 167} ,{105, 8, 228, 168} ,{23, 168, 45, 0} ,{23, 168, 53, 0} ,{23, 168, 65, 0} ,{23, 168, 154, 1} ,{23, 168, 200, 3} ,{23, 168, 202, 3} ,{23, 168, 129, 3} ,{23, 168, 232, 1} ,{23, 168, 139, 3} ,{23, 168, 128, 3} ,{23, 168, 127, 3} ,{23, 168, 137, 3} ,{23, 168, 171, 1} ,{23, 168, 253, 1} ,{23, 168, 134, 3} ,{23, 168, 140, 3} ,{23, 168, 131, 3} ,{23, 168, 163, 1} ,{106, 8, 149, 167} ,{106, 8, 138, 167} ,{20, 180, 107, 8} ,{108, 8, 226, 174} ,{21, 180, 100, 8} ,{24, 168, 45, 0} ,{24, 168, 53, 0} ,{24, 168, 65, 0} ,{24, 168, 154, 1} ,{24, 168, 200, 3} ,{24, 168, 202, 3} ,{24, 168, 129, 3} ,{24, 168, 232, 1} ,{24, 168, 139, 3} ,{24, 168, 128, 3} ,{24, 168, 127, 3} ,{24, 168, 137, 3} ,{24, 168, 171, 1} ,{24, 168, 253, 1} ,{24, 168, 134, 3} ,{24, 168, 140, 3} ,{24, 168, 131, 3} ,{24, 168, 163, 1} ,{109, 8, 149, 167} ,{109, 8, 138, 167} ,{64, 168, 45, 0} ,{64, 168, 53, 0} ,{64, 168, 65, 0} ,{64, 168, 154, 1} ,{64, 168, 200, 3} ,{64, 168, 202, 3} ,{64, 168, 129, 3} ,{64, 168, 232, 1} ,{64, 168, 139, 3} ,{64, 168, 128, 3} ,{64, 168, 127, 3} ,{64, 168, 137, 3} ,{64, 168, 171, 1} ,{64, 168, 134, 3} ,{64, 168, 140, 3} ,{64, 168, 131, 3} ,{110, 8, 149, 167} ,{110, 8, 138, 167} ,{96, 167, 154, 1} ,{96, 167, 199, 3} ,{96, 167, 194, 4} ,{96, 167, 198, 7} ,{96, 167, 197, 4} ,{96, 167, 241, 1} ,{96, 167, 250, 1} ,{96, 167, 2, 2} ,{96, 167, 186, 6} ,{96, 167, 198, 4} ,{96, 167, 232, 1} ,{96, 167, 205, 3} ,{96, 167, 199, 4} ,{96, 167, 152, 7} ,{96, 167, 112, 8} ,{96, 167, 129, 3} ,{96, 167, 209, 3} ,{96, 167, 237, 1} ,{96, 167, 184, 4} ,{96, 167, 200, 4} ,{96, 167, 127, 3} ,{96, 167, 212, 3} ,{96, 167, 202, 4} ,{96, 167, 113, 5} ,{96, 167, 203, 4} ,{96, 167, 204, 4} ,{96, 167, 46, 5} ,{96, 167, 212, 4} ,{96, 167, 249, 1} ,{96, 167, 166, 1} ,{96, 167, 113, 8} ,{96, 167, 131, 3} ,{96, 167, 163, 1} ,{96, 167, 134, 3} ,{96, 167, 225, 1} ,{45, 168, 115, 8} ,{45, 168, 40, 6} ,{45, 168, 39, 6} ,{45, 168, 164, 7} ,{45, 168, 38, 6} ,{45, 168, 116, 8} ,{45, 168, 6, 7} ,{45, 168, 117, 8} ,{45, 168, 118, 8} ,{45, 168, 119, 8} ,{45, 168, 120, 8} ,{45, 168, 121, 8} ,{45, 168, 42, 6} ,{45, 168, 235, 7} ,{228, 174, 24, 0} ,{228, 174, 25, 0} ,{45, 168, 124, 8} ,{230, 174, 126, 8} ,{230, 174, 175, 3} ,{111, 8, 17, 168} ,{111, 8, 149, 167} ,{111, 8, 58, 168} ,{228, 169, 69, 0} ,{228, 169, 209, 4} ,{111, 8, 138, 167} ,{111, 8, 59, 168} ,{228, 169, 127, 8} ,{228, 169, 164, 0} ,{228, 169, 171, 1} ,{228, 169, 138, 1} ,{111, 8, 220, 167} ,{228, 169, 133, 0} ,{111, 8, 60, 168} ,{111, 8, 185, 168} ,{111, 8, 99, 168} ,{208, 167, 128, 8} ,{208, 167, 129, 8} ,{208, 167, 130, 8} ,{208, 167, 131, 8} ,{208, 167, 132, 8} ,{208, 167, 133, 8} ,{208, 167, 134, 8} ,{208, 167, 135, 8} ,{208, 167, 136, 8} ,{208, 167, 137, 8} ,{22, 180, 139, 8} ,{208, 167, 140, 8} ,{208, 167, 141, 8} ,{208, 167, 142, 8} ,{208, 167, 143, 8} ,{208, 167, 144, 8} ,{24, 180, 147, 8} ,{25, 180, 43, 7} ,{208, 167, 149, 8} ,{26, 180, 151, 8} ,{208, 167, 152, 8} ,{27, 180, 153, 8} ,{208, 167, 154, 8} ,{208, 167, 155, 8} ,{111, 8, 243, 37} ,{111, 8, 244, 37} ,{111, 8, 245, 37} ,{111, 8, 246, 37} ,{111, 8, 247, 37} ,{111, 8, 248, 37} ,{111, 8, 249, 37} ,{111, 8, 250, 37} ,{111, 8, 251, 37} ,{111, 8, 252, 37} ,{249, 168, 157, 8} ,{249, 168, 158, 8} ,{249, 168, 35, 7} ,{249, 168, 159, 8} ,{249, 168, 160, 8} ,{249, 168, 161, 8} ,{89, 171, 158, 8} ,{89, 171, 35, 7} ,{89, 171, 159, 8} ,{89, 171, 160, 8} ,{163, 8, 164, 8} ,{163, 8, 207, 4} ,{163, 8, 16, 0} ,{163, 8, 241, 37} ,{163, 8, 33, 0} ,{163, 8, 75, 175} ,{28, 180, 79, 38} ,{31, 180, 107, 2} ,{232, 174, 16, 0} ,{232, 174, 241, 37} ,{163, 8, 169, 8} ,{193, 172, 24, 0} ,{193, 172, 25, 0} ,{193, 172, 26, 0} ,{32, 180, 121, 2} ,{163, 8, 243, 37} ,{163, 8, 244, 37} ,{163, 8, 245, 37} ,{163, 8, 246, 37} ,{163, 8, 247, 37} ,{163, 8, 248, 37} ,{163, 8, 249, 37} ,{163, 8, 250, 37} ,{163, 8, 251, 37} ,{163, 8, 252, 37} ,{179, 166, 45, 0} ,{179, 166, 49, 0} ,{179, 166, 53, 0} ,{179, 166, 59, 0} ,{179, 166, 65, 0} ,{179, 166, 164, 0} ,{179, 166, 174, 4} ,{179, 166, 124, 3} ,{179, 166, 139, 3} ,{179, 166, 166, 4} ,{179, 166, 127, 3} ,{179, 166, 128, 3} ,{179, 166, 225, 1} ,{179, 166, 200, 3} ,{179, 166, 137, 3} ,{179, 166, 134, 3} ,{179, 166, 131, 3} ,{179, 166, 166, 1} ,{179, 166, 129, 3} ,{179, 166, 232, 1} ,{179, 166, 250, 1} ,{179, 166, 244, 1} ,{179, 166, 171, 1} ,{179, 166, 253, 1} ,{179, 166, 140, 3} ,{179, 166, 133, 3} ,{179, 166, 154, 1} ,{179, 166, 199, 3} ,{179, 166, 24, 4} ,{179, 166, 234, 1} ,{179, 166, 75, 3} ,{179, 166, 173, 8} ,{179, 166, 222, 1} ,{179, 166, 134, 6} ,{179, 166, 108, 1} ,{34, 180, 6, 0} ,{142, 167, 49, 0} ,{142, 167, 53, 0} ,{142, 167, 59, 0} ,{142, 167, 65, 0} ,{142, 167, 164, 0} ,{142, 167, 174, 4} ,{142, 167, 166, 4} ,{142, 167, 127, 3} ,{142, 167, 128, 3} ,{142, 167, 225, 1} ,{142, 167, 200, 3} ,{142, 167, 137, 3} ,{142, 167, 129, 3} ,{142, 167, 232, 1} ,{142, 167, 250, 1} ,{142, 167, 244, 1} ,{142, 167, 24, 4} ,{142, 167, 171, 1} ,{142, 167, 140, 3} ,{142, 167, 154, 1} ,{142, 167, 161, 6} ,{142, 167, 75, 3} ,{142, 167, 174, 8} ,{142, 167, 175, 8} ,{142, 167, 25, 4} ,{227, 167, 49, 0} ,{227, 167, 53, 0} ,{227, 167, 156, 3} ,{227, 167, 174, 4} ,{227, 167, 65, 0} ,{227, 167, 166, 4} ,{227, 167, 154, 1} ,{227, 167, 200, 3} ,{227, 167, 163, 1} ,{227, 167, 128, 3} ,{227, 167, 166, 1} ,{227, 167, 129, 3} ,{227, 167, 232, 1} ,{227, 167, 244, 1} ,{227, 167, 133, 3} ,{227, 167, 161, 6} ,{227, 167, 75, 3} ,{227, 167, 24, 4} ,{227, 167, 234, 1} ,{227, 167, 78, 3} ,{227, 167, 250, 1} ,{227, 167, 234, 3} ,{5, 168, 53, 0} ,{5, 168, 154, 1} ,{5, 168, 253, 1} ,{5, 168, 133, 3} ,{5, 168, 234, 3} ,{35, 180, 24, 0} ,{36, 180, 24, 0} ,{152, 167, 180, 8} ,{152, 167, 181, 8} ,{37, 180, 181, 8} ,{152, 167, 182, 8} ,{38, 180, 182, 8} ,{152, 167, 45, 0} ,{152, 167, 53, 0} ,{152, 167, 154, 1} ,{152, 167, 202, 3} ,{152, 167, 241, 1} ,{152, 167, 204, 3} ,{152, 167, 205, 3} ,{152, 167, 206, 3} ,{152, 167, 208, 3} ,{152, 167, 129, 3} ,{152, 167, 232, 1} ,{152, 167, 128, 3} ,{152, 167, 212, 3} ,{152, 167, 217, 3} ,{152, 167, 234, 3} ,{152, 167, 234, 1} ,{152, 167, 183, 8} ,{233, 174, 129, 3} ,{233, 174, 234, 3} ,{108, 168, 201, 3} ,{108, 168, 202, 3} ,{108, 168, 241, 1} ,{108, 168, 203, 3} ,{108, 168, 204, 3} ,{108, 168, 207, 3} ,{108, 168, 129, 3} ,{108, 168, 210, 3} ,{108, 168, 217, 3} ,{108, 168, 184, 8} ,{108, 168, 234, 3} ,{108, 168, 234, 1} ,{234, 174, 65, 0} ,{234, 174, 171, 1} ,{108, 168, 213, 3} ,{152, 167, 185, 8} ,{108, 168, 222, 1} ,{125, 166, 186, 8} ,{125, 166, 214, 4} ,{125, 166, 187, 8} ,{125, 166, 188, 8} ,{125, 166, 189, 8} ,{125, 166, 190, 8} ,{125, 166, 191, 8} ,{125, 166, 192, 8} ,{125, 166, 193, 8} ,{125, 166, 194, 8} ,{125, 166, 195, 8} ,{125, 166, 196, 8} ,{125, 166, 197, 8} ,{125, 166, 198, 8} ,{125, 166, 199, 8} ,{125, 166, 200, 8} ,{125, 166, 201, 8} ,{125, 166, 202, 8} ,{125, 166, 203, 8} ,{125, 166, 204, 8} ,{125, 166, 205, 8} ,{125, 166, 114, 2} ,{125, 166, 206, 8} ,{167, 168, 206, 8} ,{125, 166, 208, 8} ,{167, 168, 208, 8} ,{125, 166, 209, 8} ,{167, 168, 209, 8} ,{125, 166, 210, 8} ,{167, 168, 210, 8} ,{125, 166, 211, 8} ,{125, 166, 212, 8} ,{125, 166, 213, 8} ,{125, 166, 214, 8} ,{125, 166, 215, 8} ,{125, 166, 25, 6} ,{167, 168, 60, 0} ,{167, 168, 64, 0} ,{167, 168, 55, 0} ,{167, 168, 47, 0} ,{167, 168, 57, 0} ,{167, 168, 58, 0} ,{167, 168, 63, 0} ,{167, 168, 126, 7} ,{39, 180, 67, 0} ,{40, 180, 67, 0} ,{41, 180, 12, 1} ,{42, 180, 115, 0} ,{236, 174, 216, 8} ,{192, 166, 92, 7} ,{192, 166, 254, 5} ,{125, 166, 217, 8} ,{125, 166, 182, 6} ,{125, 166, 218, 8} ,{125, 166, 219, 8} ,{125, 166, 220, 8} ,{125, 166, 221, 8} ,{125, 166, 222, 8} ,{46, 168, 120, 7} ,{46, 168, 119, 7} ,{46, 168, 160, 7} ,{167, 166, 223, 8} ,{43, 180, 162, 6} ,{167, 166, 161, 6} ,{167, 166, 166, 6} ,{46, 168, 225, 8} ,{167, 166, 158, 6} ,{238, 174, 56, 0} ,{238, 174, 62, 0} ,{44, 180, 63, 0} ,{46, 180, 229, 8} ,{143, 167, 154, 1} ,{143, 167, 199, 3} ,{143, 167, 200, 3} ,{143, 167, 201, 3} ,{143, 167, 202, 3} ,{143, 167, 241, 1} ,{143, 167, 250, 1} ,{143, 167, 244, 1} ,{143, 167, 203, 3} ,{143, 167, 230, 8} ,{143, 167, 129, 3} ,{143, 167, 209, 3} ,{143, 167, 232, 1} ,{143, 167, 210, 3} ,{143, 167, 139, 3} ,{143, 167, 128, 3} ,{143, 167, 212, 3} ,{143, 167, 127, 3} ,{143, 167, 213, 3} ,{143, 167, 137, 3} ,{143, 167, 171, 1} ,{143, 167, 253, 1} ,{143, 167, 134, 3} ,{143, 167, 140, 3} ,{143, 167, 166, 1} ,{143, 167, 217, 3} ,{143, 167, 131, 3} ,{143, 167, 163, 1} ,{227, 8, 45, 177} ,{227, 8, 149, 167} ,{227, 8, 138, 167} ,{227, 8, 185, 169} ,{227, 8, 60, 168} ,{227, 8, 185, 168} ,{227, 8, 99, 168} ,{227, 8, 220, 167} ,{227, 8, 245, 167} ,{194, 172, 171, 1} ,{194, 172, 253, 1} ,{194, 172, 140, 3} ,{63, 169, 154, 1} ,{63, 169, 202, 3} ,{63, 169, 191, 3} ,{63, 169, 129, 3} ,{63, 169, 139, 3} ,{63, 169, 128, 3} ,{63, 169, 137, 3} ,{63, 169, 253, 1} ,{63, 169, 134, 3} ,{90, 171, 231, 8} ,{90, 171, 232, 8} ,{47, 180, 53, 0} ,{90, 171, 92, 7} ,{227, 8, 228, 37} ,{227, 8, 2, 38} ,{227, 8, 243, 37} ,{227, 8, 244, 37} ,{227, 8, 245, 37} ,{227, 8, 246, 37} ,{227, 8, 247, 37} ,{227, 8, 248, 37} ,{227, 8, 249, 37} ,{227, 8, 250, 37} ,{227, 8, 251, 37} ,{227, 8, 252, 37} ,{98, 167, 154, 1} ,{98, 167, 80, 6} ,{98, 167, 202, 3} ,{98, 167, 24, 4} ,{98, 167, 131, 3} ,{98, 167, 171, 1} ,{98, 167, 129, 3} ,{98, 167, 209, 3} ,{98, 167, 134, 3} ,{98, 167, 128, 3} ,{98, 167, 212, 3} ,{98, 167, 137, 3} ,{98, 167, 133, 3} ,{98, 167, 216, 3} ,{98, 167, 163, 1} ,{98, 167, 225, 1} ,{98, 167, 199, 3} ,{98, 167, 37, 5} ,{98, 167, 139, 3} ,{98, 167, 45, 0} ,{98, 167, 53, 0} ,{98, 167, 124, 3} ,{98, 167, 235, 1} ,{98, 167, 65, 0} ,{98, 167, 125, 3} ,{98, 167, 59, 0} ,{98, 167, 174, 4} ,{98, 167, 49, 0} ,{98, 167, 236, 8} ,{98, 167, 197, 3} ,{98, 167, 181, 170} ,{98, 167, 58, 170} ,{98, 167, 204, 172} ,{98, 167, 182, 170} ,{98, 167, 239, 174} ,{228, 167, 225, 1} ,{229, 167, 225, 1} ,{228, 167, 154, 1} ,{228, 167, 80, 6} ,{228, 167, 202, 3} ,{229, 167, 154, 1} ,{229, 167, 80, 6} ,{229, 167, 202, 3} ,{228, 167, 24, 4} ,{228, 167, 131, 3} ,{228, 167, 171, 1} ,{229, 167, 24, 4} ,{229, 167, 131, 3} ,{229, 167, 171, 1} ,{228, 167, 129, 3} ,{228, 167, 209, 3} ,{228, 167, 139, 3} ,{229, 167, 129, 3} ,{229, 167, 209, 3} ,{229, 167, 139, 3} ,{228, 167, 128, 3} ,{228, 167, 212, 3} ,{228, 167, 137, 3} ,{229, 167, 128, 3} ,{229, 167, 212, 3} ,{229, 167, 137, 3} ,{228, 167, 133, 3} ,{228, 167, 216, 3} ,{228, 167, 134, 3} ,{229, 167, 133, 3} ,{229, 167, 216, 3} ,{229, 167, 134, 3} ,{228, 167, 163, 1} ,{228, 167, 232, 1} ,{228, 167, 127, 3} ,{229, 167, 163, 1} ,{229, 167, 232, 1} ,{229, 167, 127, 3} ,{228, 167, 239, 8} ,{228, 167, 240, 8} ,{229, 167, 239, 8} ,{229, 167, 240, 8} ,{228, 167, 162, 4} ,{229, 167, 162, 4} ,{48, 180, 241, 8} ,{196, 166, 17, 168} ,{196, 166, 58, 168} ,{196, 166, 138, 167} ,{196, 166, 59, 168} ,{196, 166, 220, 167} ,{198, 168, 133, 0} ,{196, 166, 245, 167} ,{198, 168, 242, 8} ,{198, 168, 174, 4} ,{198, 168, 214, 4} ,{198, 168, 187, 8} ,{198, 168, 243, 8} ,{198, 168, 186, 8} ,{198, 168, 244, 8} ,{198, 168, 245, 8} ,{198, 168, 156, 3} ,{230, 169, 66, 0} ,{230, 169, 228, 2} ,{230, 169, 58, 0} ,{230, 169, 57, 0} ,{230, 169, 55, 0} ,{230, 169, 48, 0} ,{230, 169, 46, 0} ,{241, 174, 118, 5} ,{241, 174, 119, 5} ,{196, 166, 243, 37} ,{196, 166, 244, 37} ,{196, 166, 245, 37} ,{196, 166, 246, 37} ,{196, 166, 247, 37} ,{196, 166, 248, 37} ,{196, 166, 249, 37} ,{196, 166, 250, 37} ,{196, 166, 251, 37} ,{196, 166, 252, 37} ,{49, 180, 244, 37} ,{242, 174, 248, 8} ,{242, 174, 249, 8} ,{66, 167, 250, 8} ,{66, 167, 195, 172} ,{66, 167, 196, 172} ,{66, 167, 197, 172} ,{66, 167, 198, 172} ,{66, 167, 243, 174} ,{145, 169, 195, 172} ,{145, 169, 196, 172} ,{145, 169, 197, 172} ,{145, 169, 198, 172} ,{244, 174, 252, 8} ,{250, 168, 195, 172} ,{250, 168, 196, 172} ,{250, 168, 197, 172} ,{250, 168, 198, 172} ,{250, 168, 243, 174} ,{66, 167, 2, 9} ,{66, 167, 199, 172} ,{66, 167, 200, 172} ,{66, 167, 201, 172} ,{66, 167, 202, 172} ,{66, 167, 245, 174} ,{145, 169, 199, 172} ,{145, 169, 200, 172} ,{145, 169, 201, 172} ,{145, 169, 202, 172} ,{244, 174, 3, 9} ,{250, 168, 199, 172} ,{250, 168, 200, 172} ,{250, 168, 201, 172} ,{250, 168, 202, 172} ,{250, 168, 245, 174} ,{209, 167, 154, 1} ,{209, 167, 200, 3} ,{209, 167, 202, 3} ,{209, 167, 5, 9} ,{209, 167, 128, 3} ,{209, 167, 127, 3} ,{209, 167, 137, 3} ,{209, 167, 6, 9} ,{209, 167, 129, 3} ,{209, 167, 232, 1} ,{209, 167, 139, 3} ,{209, 167, 7, 9} ,{209, 167, 241, 1} ,{209, 167, 244, 1} ,{209, 167, 138, 3} ,{209, 167, 8, 9} ,{209, 167, 171, 1} ,{209, 167, 253, 1} ,{209, 167, 134, 3} ,{209, 167, 216, 3} ,{209, 167, 131, 3} ,{209, 167, 45, 0} ,{209, 167, 163, 1} ,{4, 9, 149, 167} ,{4, 9, 138, 167} ,{4, 9, 220, 167} ,{4, 9, 245, 167} ,{50, 180, 133, 0} ,{4, 9, 9, 9} ,{51, 180, 102, 5} ,{65, 168, 154, 1} ,{65, 168, 199, 3} ,{65, 168, 113, 6} ,{110, 168, 154, 1} ,{110, 168, 113, 6} ,{110, 168, 199, 3} ,{210, 167, 202, 3} ,{65, 168, 241, 1} ,{65, 168, 250, 1} ,{110, 168, 241, 1} ,{110, 168, 131, 3} ,{110, 168, 250, 1} ,{210, 167, 138, 3} ,{210, 167, 10, 9} ,{65, 168, 11, 9} ,{210, 167, 232, 1} ,{110, 168, 11, 9} ,{210, 167, 12, 9} ,{65, 168, 129, 3} ,{65, 168, 209, 3} ,{110, 168, 129, 3} ,{110, 168, 209, 3} ,{210, 167, 139, 3} ,{210, 167, 127, 3} ,{65, 168, 128, 3} ,{65, 168, 212, 3} ,{65, 168, 133, 3} ,{110, 168, 128, 3} ,{110, 168, 133, 3} ,{110, 168, 212, 3} ,{210, 167, 137, 3} ,{110, 168, 171, 1} ,{65, 168, 171, 1} ,{210, 167, 253, 1} ,{210, 167, 13, 9} ,{210, 167, 134, 3} ,{210, 167, 14, 9} ,{210, 167, 140, 3} ,{65, 168, 166, 1} ,{65, 168, 217, 3} ,{65, 168, 131, 3} ,{65, 168, 163, 1} ,{210, 167, 214, 3} ,{210, 167, 45, 0} ,{110, 168, 163, 1} ,{210, 167, 53, 0} ,{210, 167, 193, 3} ,{210, 167, 65, 0} ,{210, 167, 194, 3} ,{210, 167, 124, 3} ,{210, 167, 125, 3} ,{210, 167, 248, 8} ,{210, 167, 246, 174} ,{247, 174, 253, 1} ,{247, 174, 134, 3} ,{53, 180, 17, 9} ,{54, 180, 17, 9} ,{55, 180, 202, 3} ,{64, 169, 248, 174} ,{58, 180, 248, 174} ,{64, 169, 137, 3} ,{64, 169, 127, 3} ,{64, 169, 131, 3} ,{189, 167, 20, 9} ,{251, 168, 45, 0} ,{59, 180, 21, 9} ,{181, 166, 17, 168} ,{251, 168, 249, 174} ,{181, 166, 149, 167} ,{181, 166, 58, 168} ,{251, 168, 174, 4} ,{251, 168, 22, 9} ,{181, 166, 138, 167} ,{181, 166, 59, 168} ,{181, 166, 245, 167} ,{250, 174, 222, 0} ,{251, 168, 186, 8} ,{181, 166, 220, 167} ,{251, 168, 133, 0} ,{181, 166, 185, 168} ,{181, 166, 60, 168} ,{60, 180, 197, 3} ,{250, 174, 132, 0} ,{91, 171, 24, 9} ,{189, 167, 203, 172} ,{189, 167, 181, 170} ,{205, 172, 58, 170} ,{205, 172, 204, 172} ,{205, 172, 182, 170} ,{61, 180, 26, 9} ,{91, 171, 27, 9} ,{63, 180, 29, 9} ,{65, 180, 115, 0} ,{252, 168, 243, 37} ,{252, 168, 244, 37} ,{252, 168, 245, 37} ,{252, 168, 246, 37} ,{252, 168, 247, 37} ,{252, 168, 248, 37} ,{252, 168, 249, 37} ,{252, 168, 250, 37} ,{252, 168, 251, 37} ,{252, 168, 252, 37} ,{253, 168, 243, 37} ,{253, 168, 244, 37} ,{253, 168, 245, 37} ,{253, 168, 246, 37} ,{253, 168, 247, 37} ,{253, 168, 248, 37} ,{253, 168, 249, 37} ,{253, 168, 250, 37} ,{253, 168, 251, 37} ,{253, 168, 252, 37} ,{189, 167, 32, 9} ,{189, 167, 33, 9} ,{189, 167, 34, 9} ,{189, 167, 35, 9} ,{189, 167, 36, 9} ,{189, 167, 37, 9} ,{66, 180, 12, 9} ,{91, 171, 39, 9} ,{189, 167, 40, 9} ,{189, 167, 41, 9} ,{189, 167, 42, 9} ,{189, 167, 43, 9} ,{189, 167, 44, 9} ,{189, 167, 45, 9} ,{251, 174, 48, 9} ,{251, 174, 49, 9} ,{59, 170, 50, 9} ,{59, 170, 51, 9} ,{59, 170, 52, 9} ,{251, 166, 53, 9} ,{67, 180, 55, 9} ,{251, 166, 56, 9} ,{68, 180, 55, 9} ,{251, 166, 58, 9} ,{69, 180, 55, 9} ,{252, 174, 60, 9} ,{252, 174, 209, 172} ,{253, 174, 62, 9} ,{253, 174, 2, 175} ,{251, 166, 64, 9} ,{251, 166, 65, 9} ,{251, 166, 66, 9} ,{70, 180, 55, 9} ,{251, 166, 154, 1} ,{71, 180, 68, 9} ,{251, 166, 200, 3} ,{72, 180, 70, 9} ,{251, 166, 202, 3} ,{251, 166, 241, 1} ,{73, 180, 72, 9} ,{251, 166, 244, 1} ,{74, 180, 74, 9} ,{251, 166, 138, 3} ,{206, 172, 76, 9} ,{75, 180, 68, 9} ,{254, 174, 79, 9} ,{254, 174, 68, 9} ,{76, 180, 80, 9} ,{251, 166, 129, 3} ,{206, 172, 81, 9} ,{251, 166, 232, 1} ,{207, 172, 82, 9} ,{251, 166, 139, 3} ,{251, 166, 128, 3} ,{77, 180, 84, 9} ,{251, 166, 127, 3} ,{78, 180, 86, 9} ,{251, 166, 137, 3} ,{251, 166, 171, 1} ,{251, 166, 253, 1} ,{251, 166, 134, 3} ,{251, 166, 140, 3} ,{255, 174, 88, 9} ,{255, 174, 89, 9} ,{251, 166, 131, 3} ,{251, 166, 163, 1} ,{59, 170, 90, 9} ,{84, 168, 55, 9} ,{84, 168, 91, 9} ,{79, 180, 92, 9} ,{84, 168, 93, 9} ,{80, 180, 95, 9} ,{0, 175, 60, 9} ,{0, 175, 209, 172} ,{1, 175, 62, 9} ,{1, 175, 2, 175} ,{84, 168, 96, 9} ,{208, 172, 60, 9} ,{208, 172, 55, 9} ,{208, 172, 209, 172} ,{84, 168, 98, 9} ,{81, 180, 55, 9} ,{46, 9, 57, 177} ,{82, 180, 102, 9} ,{83, 180, 102, 9} ,{84, 180, 102, 9} ,{85, 180, 102, 9} ,{86, 180, 102, 9} ,{87, 180, 102, 9} ,{88, 180, 102, 9} ,{46, 9, 243, 37} ,{46, 9, 244, 37} ,{46, 9, 245, 37} ,{46, 9, 246, 37} ,{46, 9, 247, 37} ,{46, 9, 248, 37} ,{46, 9, 249, 37} ,{46, 9, 250, 37} ,{46, 9, 251, 37} ,{46, 9, 252, 37} ,{46, 9, 109, 9} ,{46, 9, 110, 9} ,{46, 9, 111, 9} ,{210, 172, 113, 9} ,{210, 172, 114, 9} ,{210, 172, 115, 9} ,{46, 9, 116, 9} ,{6, 168, 118, 9} ,{6, 168, 119, 9} ,{6, 168, 120, 9} ,{6, 168, 121, 9} ,{3, 175, 51, 9} ,{6, 168, 123, 9} ,{6, 168, 124, 9} ,{6, 168, 125, 9} ,{6, 168, 126, 9} ,{3, 175, 127, 9} ,{65, 169, 128, 9} ,{65, 169, 129, 9} ,{65, 169, 130, 9} ,{65, 169, 131, 9} ,{65, 169, 132, 9} ,{89, 180, 4, 175} ,{90, 180, 4, 175} ,{65, 169, 135, 9} ,{65, 169, 136, 9} ,{5, 175, 138, 9} ,{5, 175, 139, 9} ,{6, 175, 140, 9} ,{6, 175, 141, 9} ,{211, 172, 142, 9} ,{211, 172, 143, 9} ,{7, 175, 144, 9} ,{7, 175, 145, 9} ,{211, 172, 146, 9} ,{94, 171, 148, 9} ,{94, 171, 149, 9} ,{94, 171, 150, 9} ,{109, 167, 45, 0} ,{109, 167, 53, 0} ,{109, 167, 65, 0} ,{109, 167, 133, 0} ,{109, 167, 59, 0} ,{109, 167, 49, 0} ,{109, 167, 110, 5} ,{109, 167, 154, 1} ,{109, 167, 225, 1} ,{109, 167, 200, 3} ,{109, 167, 202, 3} ,{109, 167, 241, 1} ,{109, 167, 244, 1} ,{109, 167, 234, 1} ,{109, 167, 138, 3} ,{109, 167, 129, 3} ,{109, 167, 232, 1} ,{109, 167, 139, 3} ,{109, 167, 128, 3} ,{109, 167, 133, 3} ,{109, 167, 216, 3} ,{109, 167, 127, 3} ,{109, 167, 137, 3} ,{109, 167, 171, 1} ,{109, 167, 253, 1} ,{109, 167, 134, 3} ,{109, 167, 140, 3} ,{109, 167, 131, 3} ,{109, 167, 80, 6} ,{109, 167, 163, 1} ,{212, 172, 151, 9} ,{212, 172, 152, 9} ,{212, 172, 153, 9} ,{60, 170, 154, 9} ,{60, 170, 155, 9} ,{60, 170, 156, 9} ,{60, 170, 157, 9} ,{60, 170, 158, 9} ,{60, 170, 159, 9} ,{94, 171, 160, 9} ,{109, 167, 199, 3} ,{109, 167, 161, 9} ,{147, 9, 243, 37} ,{147, 9, 244, 37} ,{147, 9, 245, 37} ,{147, 9, 246, 37} ,{147, 9, 247, 37} ,{147, 9, 248, 37} ,{147, 9, 249, 37} ,{147, 9, 250, 37} ,{147, 9, 251, 37} ,{147, 9, 252, 37} ,{77, 167, 154, 1} ,{77, 167, 163, 9} ,{77, 167, 199, 3} ,{77, 167, 200, 3} ,{77, 167, 164, 9} ,{77, 167, 202, 3} ,{77, 167, 241, 1} ,{77, 167, 250, 1} ,{77, 167, 244, 1} ,{77, 167, 138, 3} ,{77, 167, 129, 3} ,{77, 167, 209, 3} ,{77, 167, 232, 1} ,{77, 167, 139, 3} ,{77, 167, 128, 3} ,{77, 167, 143, 4} ,{77, 167, 212, 3} ,{77, 167, 133, 3} ,{77, 167, 165, 9} ,{77, 167, 127, 3} ,{77, 167, 166, 9} ,{77, 167, 137, 3} ,{77, 167, 167, 9} ,{77, 167, 24, 4} ,{77, 167, 37, 5} ,{77, 167, 25, 4} ,{77, 167, 171, 1} ,{77, 167, 253, 1} ,{77, 167, 134, 3} ,{77, 167, 163, 1} ,{77, 167, 168, 9} ,{77, 167, 216, 3} ,{77, 167, 131, 3} ,{77, 167, 166, 1} ,{77, 167, 140, 3} ,{77, 167, 45, 0} ,{8, 175, 171, 1} ,{8, 175, 253, 1} ,{162, 9, 17, 168} ,{162, 9, 149, 167} ,{162, 9, 245, 167} ,{162, 9, 185, 168} ,{162, 9, 138, 167} ,{162, 9, 59, 168} ,{162, 9, 220, 167} ,{66, 169, 55, 0} ,{66, 169, 57, 0} ,{66, 169, 56, 0} ,{66, 169, 58, 0} ,{66, 169, 60, 0} ,{66, 169, 62, 0} ,{66, 169, 64, 0} ,{91, 180, 199, 4} ,{66, 169, 24, 9} ,{92, 180, 170, 9} ,{162, 9, 18, 170} ,{185, 170, 9, 175} ,{94, 180, 9, 175} ,{185, 170, 10, 175} ,{95, 180, 10, 175} ,{185, 170, 177, 9} ,{162, 9, 243, 37} ,{162, 9, 244, 37} ,{162, 9, 245, 37} ,{162, 9, 246, 37} ,{162, 9, 247, 37} ,{162, 9, 248, 37} ,{162, 9, 249, 37} ,{162, 9, 250, 37} ,{162, 9, 251, 37} ,{162, 9, 252, 37} ,{77, 167, 204, 3} ,{77, 167, 205, 3} ,{77, 167, 206, 3} ,{38, 167, 243, 37} ,{38, 167, 244, 37} ,{38, 167, 245, 37} ,{38, 167, 246, 37} ,{38, 167, 247, 37} ,{38, 167, 248, 37} ,{38, 167, 249, 37} ,{38, 167, 250, 37} ,{38, 167, 251, 37} ,{38, 167, 252, 37} ,{121, 167, 134, 3} ,{121, 167, 41, 0} ,{121, 167, 180, 9} ,{121, 167, 166, 4} ,{121, 167, 181, 9} ,{121, 167, 254, 5} ,{121, 167, 182, 9} ,{121, 167, 183, 9} ,{121, 167, 184, 9} ,{121, 167, 185, 9} ,{121, 167, 253, 5} ,{121, 167, 186, 9} ,{121, 167, 187, 9} ,{121, 167, 188, 9} ,{121, 167, 189, 9} ,{121, 167, 157, 4} ,{121, 167, 190, 9} ,{121, 167, 191, 9} ,{121, 167, 192, 9} ,{121, 167, 243, 8} ,{121, 167, 0, 6} ,{121, 167, 193, 9} ,{121, 167, 194, 9} ,{121, 167, 157, 1} ,{121, 167, 195, 9} ,{121, 167, 212, 4} ,{121, 167, 196, 9} ,{121, 167, 197, 9} ,{121, 167, 198, 9} ,{121, 167, 6, 2} ,{96, 180, 200, 9} ,{38, 167, 11, 175} ,{97, 180, 11, 175} ,{38, 167, 204, 9} ,{38, 167, 205, 9} ,{38, 167, 206, 9} ,{12, 175, 207, 9} ,{98, 180, 207, 9} ,{66, 168, 209, 9} ,{66, 168, 210, 9} ,{66, 168, 211, 9} ,{7, 168, 212, 9} ,{100, 180, 215, 9} ,{101, 180, 186, 170} ,{95, 171, 186, 170} ,{13, 175, 186, 170} ,{102, 180, 222, 0} ,{104, 180, 219, 9} ,{105, 180, 215, 9} ,{106, 180, 215, 9} ,{107, 180, 226, 3} ,{66, 168, 57, 168} ,{66, 168, 118, 176} ,{66, 168, 14, 175} ,{109, 180, 186, 170} ,{110, 180, 186, 170} ,{187, 170, 215, 9} ,{187, 170, 225, 3} ,{16, 175, 225, 3} ,{187, 170, 226, 3} ,{16, 175, 226, 3} ,{111, 180, 52, 168} ,{112, 180, 52, 168} ,{188, 170, 225, 9} ,{188, 170, 226, 9} ,{188, 170, 227, 9} ,{113, 180, 52, 168} ,{7, 168, 229, 9} ,{114, 180, 213, 172} ,{7, 168, 213, 172} ,{115, 180, 213, 172} ,{116, 180, 233, 9} ,{7, 168, 234, 9} ,{59, 167, 45, 0} ,{59, 167, 133, 0} ,{192, 167, 133, 0} ,{59, 167, 18, 175} ,{59, 167, 47, 0} ,{59, 167, 48, 0} ,{59, 167, 137, 0} ,{59, 167, 49, 0} ,{192, 167, 67, 169} ,{192, 167, 53, 0} ,{59, 167, 54, 0} ,{59, 167, 55, 0} ,{117, 180, 28, 167} ,{59, 167, 57, 0} ,{17, 175, 58, 0} ,{59, 167, 59, 0} ,{59, 167, 190, 170} ,{61, 170, 59, 0} ,{61, 170, 190, 170} ,{118, 180, 141, 0} ,{192, 167, 164, 0} ,{59, 167, 225, 0} ,{126, 166, 20, 175} ,{126, 166, 21, 175} ,{59, 167, 60, 0} ,{17, 175, 62, 0} ,{184, 176, 62, 0} ,{59, 167, 64, 0} ,{59, 167, 65, 0} ,{61, 170, 65, 0} ,{119, 180, 65, 0} ,{120, 180, 57, 0} ,{59, 167, 66, 0} ,{59, 167, 67, 0} ,{59, 167, 70, 0} ,{59, 167, 198, 0} ,{122, 180, 238, 9} ,{225, 166, 164, 2} ,{189, 170, 182, 0} ,{189, 170, 99, 1} ,{189, 170, 104, 1} ,{189, 170, 105, 1} ,{189, 170, 109, 1} ,{123, 180, 155, 1} ,{203, 167, 45, 0} ,{203, 167, 133, 0} ,{203, 167, 46, 0} ,{203, 167, 18, 175} ,{203, 167, 48, 0} ,{203, 167, 49, 0} ,{203, 167, 19, 175} ,{203, 167, 51, 0} ,{203, 167, 52, 0} ,{203, 167, 53, 0} ,{203, 167, 54, 0} ,{203, 167, 55, 0} ,{203, 167, 56, 0} ,{203, 167, 57, 0} ,{203, 167, 58, 0} ,{124, 180, 58, 0} ,{203, 167, 59, 0} ,{203, 167, 225, 0} ,{203, 167, 60, 0} ,{203, 167, 62, 0} ,{203, 167, 64, 0} ,{203, 167, 65, 0} ,{203, 167, 67, 0} ,{197, 166, 45, 0} ,{200, 168, 45, 0} ,{197, 166, 234, 0} ,{200, 168, 133, 0} ,{197, 166, 46, 0} ,{197, 166, 48, 0} ,{197, 166, 49, 0} ,{197, 166, 180, 0} ,{197, 166, 67, 169} ,{200, 168, 67, 169} ,{197, 166, 51, 0} ,{200, 168, 53, 0} ,{197, 166, 55, 0} ,{197, 166, 57, 0} ,{197, 166, 163, 0} ,{197, 166, 59, 0} ,{197, 166, 190, 170} ,{197, 166, 20, 175} ,{197, 166, 21, 175} ,{197, 166, 60, 0} ,{197, 166, 64, 0} ,{197, 166, 65, 0} ,{125, 180, 65, 0} ,{200, 168, 57, 0} ,{197, 166, 66, 0} ,{197, 166, 164, 2} ,{197, 166, 93, 1} ,{22, 175, 182, 0} ,{197, 166, 178, 0} ,{22, 175, 245, 0} ,{197, 166, 108, 1} ,{18, 169, 53, 0} ,{18, 169, 62, 0} ,{18, 169, 65, 0} ,{18, 169, 66, 0} ,{191, 170, 93, 1} ,{191, 170, 182, 0} ,{191, 170, 105, 1} ,{191, 170, 245, 0} ,{191, 170, 108, 1} ,{126, 166, 174, 4} ,{146, 169, 175, 168} ,{111, 168, 175, 168} ,{99, 171, 175, 168} ,{64, 170, 175, 168} ,{148, 169, 175, 168} ,{97, 169, 175, 168} ,{54, 168, 175, 168} ,{126, 180, 25, 175} ,{112, 168, 175, 168} ,{95, 168, 175, 168} ,{121, 168, 175, 168} ,{192, 167, 51, 0} ,{127, 180, 157, 1} ,{125, 170, 51, 0} ,{129, 180, 241, 9} ,{27, 175, 193, 170} ,{130, 180, 28, 167} ,{97, 169, 28, 167} ,{27, 175, 214, 172} ,{131, 180, 28, 167} ,{146, 169, 26, 168} ,{111, 168, 26, 168} ,{99, 171, 26, 168} ,{255, 168, 26, 168} ,{214, 168, 26, 168} ,{53, 168, 26, 168} ,{64, 170, 26, 168} ,{148, 169, 26, 168} ,{97, 169, 26, 168} ,{54, 168, 26, 168} ,{112, 168, 26, 168} ,{217, 172, 26, 168} ,{255, 169, 26, 168} ,{224, 172, 26, 168} ,{121, 168, 26, 168} ,{132, 167, 8, 168} ,{132, 180, 254, 168} ,{134, 180, 201, 0} ,{167, 167, 8, 168} ,{135, 180, 8, 168} ,{28, 175, 8, 168} ,{29, 175, 254, 168} ,{86, 168, 8, 168} ,{137, 180, 8, 168} ,{217, 172, 254, 168} ,{123, 167, 8, 168} ,{192, 170, 254, 168} ,{200, 168, 234, 0} ,{197, 166, 47, 0} ,{138, 180, 176, 168} ,{197, 166, 137, 0} ,{30, 175, 67, 169} ,{197, 166, 50, 0} ,{139, 180, 218, 172} ,{197, 166, 31, 175} ,{200, 168, 52, 0} ,{197, 166, 193, 170} ,{197, 166, 184, 0} ,{62, 170, 53, 0} ,{62, 170, 193, 170} ,{140, 180, 33, 175} ,{34, 175, 254, 168} ,{34, 175, 26, 168} ,{62, 170, 56, 0} ,{141, 180, 48, 167} ,{200, 168, 35, 175} ,{36, 175, 219, 172} ,{36, 175, 8, 168} ,{62, 170, 58, 0} ,{197, 166, 97, 171} ,{197, 166, 245, 0} ,{142, 180, 48, 167} ,{197, 166, 191, 0} ,{143, 180, 26, 168} ,{197, 166, 220, 172} ,{197, 166, 196, 0} ,{62, 170, 65, 0} ,{144, 180, 48, 167} ,{200, 168, 66, 0} ,{197, 166, 70, 0} ,{37, 175, 254, 168} ,{37, 175, 176, 168} ,{197, 166, 198, 0} ,{197, 166, 97, 1} ,{38, 175, 35, 38} ,{38, 175, 86, 38} ,{145, 180, 222, 0} ,{146, 180, 3, 0} ,{221, 172, 129, 0} ,{39, 175, 106, 0} ,{221, 172, 128, 0} ,{40, 175, 106, 0} ,{147, 180, 128, 0} ,{148, 180, 129, 0} ,{42, 175, 222, 0} ,{149, 180, 106, 0} ,{221, 172, 147, 0} ,{150, 180, 132, 0} ,{151, 180, 132, 0} ,{41, 175, 222, 0} ,{152, 180, 222, 0} ,{153, 180, 132, 0} ,{154, 180, 132, 0} ,{157, 180, 132, 0} ,{130, 167, 133, 0} ,{130, 167, 250, 9} ,{130, 167, 251, 9} ,{158, 180, 116, 0} ,{159, 180, 48, 0} ,{130, 167, 137, 0} ,{130, 167, 51, 0} ,{194, 170, 51, 0} ,{130, 167, 55, 0} ,{130, 167, 56, 0} ,{194, 170, 56, 0} ,{194, 170, 57, 0} ,{130, 167, 58, 0} ,{194, 170, 58, 0} ,{194, 170, 62, 0} ,{42, 175, 252, 9} ,{130, 167, 63, 0} ,{160, 180, 63, 0} ,{130, 167, 70, 0} ,{43, 175, 222, 0} ,{161, 180, 132, 0} ,{162, 180, 222, 172} ,{153, 167, 16, 170} ,{132, 167, 16, 170} ,{63, 170, 233, 166} ,{146, 169, 233, 166} ,{63, 170, 27, 167} ,{146, 169, 27, 167} ,{63, 170, 85, 168} ,{146, 169, 85, 168} ,{147, 169, 45, 175} ,{68, 169, 45, 175} ,{201, 168, 233, 166} ,{111, 168, 233, 166} ,{201, 168, 27, 167} ,{111, 168, 27, 167} ,{201, 168, 85, 168} ,{111, 168, 85, 168} ,{201, 168, 248, 167} ,{111, 168, 248, 167} ,{201, 168, 65, 170} ,{111, 168, 65, 170} ,{196, 167, 101, 171} ,{167, 167, 101, 171} ,{196, 167, 102, 171} ,{167, 167, 102, 171} ,{196, 167, 168, 168} ,{167, 167, 168, 168} ,{196, 167, 169, 169} ,{167, 167, 169, 169} ,{196, 167, 47, 175} ,{167, 167, 47, 175} ,{48, 175, 233, 166} ,{99, 171, 233, 166} ,{69, 169, 232, 169} ,{255, 168, 232, 169} ,{92, 169, 233, 166} ,{208, 168, 233, 166} ,{92, 169, 27, 167} ,{208, 168, 27, 167} ,{92, 169, 0, 168} ,{208, 168, 0, 168} ,{92, 169, 248, 167} ,{208, 168, 248, 167} ,{92, 169, 49, 175} ,{208, 168, 49, 175} ,{113, 168, 169, 169} ,{86, 168, 169, 169} ,{113, 168, 100, 171} ,{86, 168, 100, 171} ,{28, 169, 162, 167} ,{214, 168, 162, 167} ,{28, 169, 27, 167} ,{214, 168, 27, 167} ,{28, 169, 85, 168} ,{214, 168, 85, 168} ,{124, 168, 27, 167} ,{53, 168, 27, 167} ,{124, 168, 103, 171} ,{53, 168, 103, 171} ,{124, 168, 85, 168} ,{53, 168, 85, 168} ,{124, 168, 65, 170} ,{53, 168, 65, 170} ,{235, 171, 162, 167} ,{64, 170, 162, 167} ,{235, 171, 233, 166} ,{64, 170, 233, 166} ,{235, 171, 27, 167} ,{64, 170, 27, 167} ,{196, 170, 233, 166} ,{148, 169, 233, 166} ,{196, 170, 27, 167} ,{148, 169, 27, 167} ,{231, 169, 249, 167} ,{149, 169, 249, 167} ,{231, 169, 168, 168} ,{149, 169, 168, 168} ,{90, 167, 105, 171} ,{91, 167, 105, 171} ,{90, 167, 50, 175} ,{91, 167, 50, 175} ,{90, 167, 101, 171} ,{91, 167, 101, 171} ,{90, 167, 102, 171} ,{91, 167, 102, 171} ,{254, 169, 162, 167} ,{97, 169, 162, 167} ,{254, 169, 233, 166} ,{97, 169, 233, 166} ,{184, 168, 233, 166} ,{54, 168, 233, 166} ,{184, 168, 27, 167} ,{54, 168, 27, 167} ,{184, 168, 103, 171} ,{54, 168, 103, 171} ,{184, 168, 85, 168} ,{54, 168, 85, 168} ,{209, 168, 233, 166} ,{112, 168, 233, 166} ,{209, 168, 27, 167} ,{112, 168, 27, 167} ,{209, 168, 52, 175} ,{112, 168, 52, 175} ,{209, 168, 54, 175} ,{112, 168, 54, 175} ,{209, 168, 104, 171} ,{112, 168, 104, 171} ,{202, 168, 233, 166} ,{95, 168, 233, 166} ,{202, 168, 27, 167} ,{95, 168, 27, 167} ,{202, 168, 85, 168} ,{95, 168, 85, 168} ,{202, 168, 65, 170} ,{95, 168, 65, 170} ,{131, 167, 223, 172} ,{123, 167, 223, 172} ,{131, 167, 169, 169} ,{123, 167, 169, 169} ,{131, 167, 168, 168} ,{123, 167, 168, 168} ,{131, 167, 105, 171} ,{123, 167, 105, 171} ,{131, 167, 55, 175} ,{123, 167, 55, 175} ,{15, 172, 114, 171} ,{255, 169, 114, 171} ,{15, 172, 27, 167} ,{255, 169, 27, 167} ,{250, 169, 72, 170} ,{178, 169, 72, 170} ,{250, 169, 162, 167} ,{178, 169, 162, 167} ,{250, 169, 0, 168} ,{178, 169, 0, 168} ,{250, 169, 233, 166} ,{178, 169, 233, 166} ,{250, 169, 27, 167} ,{178, 169, 27, 167} ,{56, 175, 233, 166} ,{224, 172, 233, 166} ,{56, 175, 0, 168} ,{224, 172, 0, 168} ,{169, 168, 233, 166} ,{136, 168, 233, 166} ,{19, 169, 67, 168} ,{121, 168, 67, 168} ,{19, 169, 27, 167} ,{121, 168, 27, 167} ,{19, 169, 85, 168} ,{121, 168, 85, 168} ,{208, 168, 85, 168} ,{95, 168, 0, 168} ,{178, 169, 199, 176} ,{232, 172, 124, 40} ,{132, 167, 107, 171} ,{225, 172, 233, 166} ,{225, 172, 98, 169} ,{225, 172, 117, 173} ,{146, 166, 57, 175} ,{126, 166, 178, 0} ,{226, 172, 27, 167} ,{227, 172, 27, 167} ,{153, 167, 190, 167} ,{132, 167, 190, 167} ,{153, 167, 67, 170} ,{132, 167, 67, 170} ,{153, 167, 68, 170} ,{132, 167, 68, 170} ,{153, 167, 69, 170} ,{132, 167, 69, 170} ,{153, 167, 70, 170} ,{132, 167, 70, 170} ,{153, 167, 71, 170} ,{132, 167, 71, 170} ,{153, 167, 58, 175} ,{132, 167, 58, 175} ,{153, 167, 59, 175} ,{132, 167, 59, 175} ,{228, 172, 190, 167} ,{229, 172, 190, 167} ,{228, 172, 82, 0} ,{229, 172, 82, 0} ,{228, 172, 57, 168} ,{229, 172, 57, 168} ,{146, 166, 60, 175} ,{126, 166, 60, 175} ,{196, 167, 190, 167} ,{167, 167, 190, 167} ,{196, 167, 82, 0} ,{167, 167, 82, 0} ,{196, 167, 67, 170} ,{167, 167, 67, 170} ,{196, 167, 68, 170} ,{167, 167, 68, 170} ,{196, 167, 69, 170} ,{167, 167, 69, 170} ,{196, 167, 70, 170} ,{167, 167, 70, 170} ,{196, 167, 71, 170} ,{167, 167, 71, 170} ,{113, 168, 190, 167} ,{86, 168, 190, 167} ,{61, 175, 27, 167} ,{163, 180, 27, 167} ,{230, 172, 27, 167} ,{231, 172, 27, 167} ,{90, 167, 190, 167} ,{91, 167, 190, 167} ,{90, 167, 67, 170} ,{91, 167, 67, 170} ,{90, 167, 68, 170} ,{91, 167, 68, 170} ,{90, 167, 69, 170} ,{91, 167, 69, 170} ,{90, 167, 70, 170} ,{91, 167, 70, 170} ,{90, 167, 71, 170} ,{91, 167, 71, 170} ,{90, 167, 111, 171} ,{91, 167, 111, 171} ,{109, 171, 128, 0} ,{110, 171, 128, 0} ,{109, 171, 190, 167} ,{110, 171, 190, 167} ,{109, 171, 82, 0} ,{110, 171, 82, 0} ,{109, 171, 57, 168} ,{110, 171, 57, 168} ,{146, 166, 62, 175} ,{126, 166, 62, 175} ,{131, 167, 190, 167} ,{123, 167, 190, 167} ,{131, 167, 111, 171} ,{123, 167, 111, 171} ,{112, 171, 128, 0} ,{113, 171, 128, 0} ,{112, 171, 190, 167} ,{113, 171, 190, 167} ,{112, 171, 82, 0} ,{113, 171, 82, 0} ,{112, 171, 57, 168} ,{113, 171, 57, 168} ,{169, 168, 72, 170} ,{136, 168, 72, 170} ,{169, 168, 27, 167} ,{136, 168, 27, 167} ,{65, 175, 190, 167} ,{232, 172, 190, 167} ,{169, 168, 114, 171} ,{136, 168, 114, 171} ,{146, 166, 63, 175} ,{126, 166, 63, 175} ,{146, 166, 64, 175} ,{126, 166, 64, 175} ,{65, 175, 193, 0} ,{232, 172, 193, 0} ,{170, 168, 1, 10} ,{170, 168, 2, 10} ,{163, 167, 137, 168} ,{163, 167, 114, 168} ,{163, 167, 138, 168} ,{163, 167, 115, 168} ,{163, 167, 71, 169} ,{163, 167, 1, 169} ,{230, 167, 2, 169} ,{230, 167, 203, 168} ,{230, 167, 137, 168} ,{230, 167, 114, 168} ,{230, 167, 138, 168} ,{230, 167, 115, 168} ,{230, 167, 71, 169} ,{230, 167, 1, 169} ,{72, 169, 2, 169} ,{72, 169, 203, 168} ,{72, 169, 137, 168} ,{72, 169, 114, 168} ,{72, 169, 138, 168} ,{72, 169, 115, 168} ,{74, 169, 2, 169} ,{74, 169, 203, 168} ,{74, 169, 137, 168} ,{74, 169, 114, 168} ,{74, 169, 138, 168} ,{74, 169, 115, 168} ,{198, 167, 2, 169} ,{198, 167, 203, 168} ,{198, 167, 137, 168} ,{198, 167, 114, 168} ,{198, 167, 138, 168} ,{198, 167, 115, 168} ,{198, 167, 71, 169} ,{198, 167, 1, 169} ,{250, 167, 2, 169} ,{250, 167, 203, 168} ,{250, 167, 137, 168} ,{250, 167, 114, 168} ,{250, 167, 138, 168} ,{250, 167, 115, 168} ,{250, 167, 71, 169} ,{250, 167, 1, 169} ,{139, 168, 1, 10} ,{139, 168, 2, 10} ,{73, 170, 137, 168} ,{73, 170, 114, 168} ,{73, 170, 138, 168} ,{73, 170, 115, 168} ,{73, 170, 71, 169} ,{73, 170, 1, 169} ,{151, 169, 1, 10} ,{151, 169, 2, 10} ,{74, 170, 137, 168} ,{74, 170, 114, 168} ,{74, 170, 138, 168} ,{74, 170, 115, 168} ,{74, 170, 71, 169} ,{74, 170, 1, 169} ,{73, 169, 2, 169} ,{73, 169, 203, 168} ,{73, 169, 137, 168} ,{73, 169, 114, 168} ,{73, 169, 138, 168} ,{73, 169, 115, 168} ,{78, 169, 2, 169} ,{78, 169, 203, 168} ,{78, 169, 137, 168} ,{78, 169, 114, 168} ,{78, 169, 138, 168} ,{78, 169, 115, 168} ,{140, 168, 1, 10} ,{140, 168, 2, 10} ,{75, 170, 137, 168} ,{75, 170, 114, 168} ,{75, 170, 138, 168} ,{75, 170, 115, 168} ,{75, 170, 71, 169} ,{75, 170, 1, 169} ,{233, 169, 2, 10} ,{233, 172, 114, 168} ,{233, 172, 115, 168} ,{233, 172, 1, 169} ,{199, 167, 2, 169} ,{199, 167, 203, 168} ,{199, 167, 137, 168} ,{199, 167, 114, 168} ,{199, 167, 138, 168} ,{199, 167, 115, 168} ,{199, 167, 71, 169} ,{199, 167, 1, 169} ,{251, 167, 2, 169} ,{251, 167, 203, 168} ,{251, 167, 137, 168} ,{251, 167, 114, 168} ,{251, 167, 138, 168} ,{251, 167, 115, 168} ,{251, 167, 71, 169} ,{251, 167, 1, 169} ,{170, 168, 3, 10} ,{170, 168, 4, 10} ,{72, 169, 79, 169} ,{72, 169, 80, 169} ,{198, 167, 79, 169} ,{198, 167, 80, 169} ,{139, 168, 3, 10} ,{139, 168, 4, 10} ,{73, 169, 79, 169} ,{73, 169, 80, 169} ,{140, 168, 3, 10} ,{140, 168, 4, 10} ,{199, 167, 79, 169} ,{199, 167, 80, 169} ,{116, 171, 59, 1} ,{117, 171, 59, 1} ,{116, 171, 75, 169} ,{117, 171, 75, 169} ,{116, 171, 76, 169} ,{117, 171, 76, 169} ,{116, 171, 77, 169} ,{117, 171, 77, 169} ,{118, 171, 8, 10} ,{119, 171, 8, 10} ,{118, 171, 76, 170} ,{119, 171, 76, 170} ,{118, 171, 77, 170} ,{119, 171, 77, 170} ,{118, 171, 78, 170} ,{119, 171, 78, 170} ,{120, 171, 59, 1} ,{121, 171, 59, 1} ,{120, 171, 75, 169} ,{121, 171, 75, 169} ,{120, 171, 76, 169} ,{121, 171, 76, 169} ,{120, 171, 77, 169} ,{121, 171, 77, 169} ,{122, 171, 8, 10} ,{123, 171, 8, 10} ,{122, 171, 76, 170} ,{123, 171, 76, 170} ,{122, 171, 77, 170} ,{123, 171, 77, 170} ,{122, 171, 78, 170} ,{123, 171, 78, 170} ,{124, 171, 59, 1} ,{125, 171, 59, 1} ,{124, 171, 75, 169} ,{125, 171, 75, 169} ,{124, 171, 76, 169} ,{125, 171, 76, 169} ,{124, 171, 77, 169} ,{125, 171, 77, 169} ,{126, 171, 8, 10} ,{127, 171, 8, 10} ,{126, 171, 76, 170} ,{127, 171, 76, 170} ,{126, 171, 77, 170} ,{127, 171, 77, 170} ,{126, 171, 78, 170} ,{127, 171, 78, 170} ,{170, 168, 9, 10} ,{170, 168, 106, 0} ,{170, 168, 75, 169} ,{170, 168, 59, 1} ,{170, 168, 76, 169} ,{170, 168, 55, 1} ,{170, 168, 77, 169} ,{164, 180, 9, 10} ,{230, 167, 232, 169} ,{230, 167, 79, 169} ,{230, 167, 80, 169} ,{230, 167, 237, 172} ,{54, 1, 56, 1} ,{54, 1, 8, 10} ,{54, 1, 1, 10} ,{54, 1, 55, 1} ,{236, 172, 55, 1} ,{197, 170, 75, 169} ,{197, 170, 59, 1} ,{197, 170, 76, 169} ,{197, 170, 55, 1} ,{197, 170, 77, 169} ,{74, 169, 79, 169} ,{74, 169, 80, 169} ,{250, 167, 79, 169} ,{250, 167, 80, 169} ,{250, 167, 237, 172} ,{234, 172, 3, 10} ,{234, 172, 4, 10} ,{234, 172, 55, 1} ,{139, 168, 9, 10} ,{139, 168, 106, 0} ,{128, 171, 3, 10} ,{128, 171, 4, 10} ,{139, 168, 55, 1} ,{128, 171, 55, 1} ,{151, 169, 9, 10} ,{151, 169, 106, 0} ,{151, 169, 3, 10} ,{151, 169, 4, 10} ,{235, 172, 3, 10} ,{235, 172, 4, 10} ,{235, 172, 55, 1} ,{140, 168, 9, 10} ,{140, 168, 106, 0} ,{129, 171, 3, 10} ,{129, 171, 4, 10} ,{66, 175, 2, 169} ,{66, 175, 203, 168} ,{140, 168, 55, 1} ,{129, 171, 55, 1} ,{233, 169, 9, 10} ,{233, 169, 106, 0} ,{233, 169, 3, 10} ,{233, 169, 4, 10} ,{165, 180, 203, 168} ,{236, 172, 3, 10} ,{236, 172, 4, 10} ,{54, 1, 3, 10} ,{198, 170, 75, 169} ,{198, 170, 59, 1} ,{198, 170, 76, 169} ,{198, 170, 55, 1} ,{198, 170, 77, 169} ,{78, 169, 79, 169} ,{78, 169, 80, 169} ,{251, 167, 79, 169} ,{251, 167, 80, 169} ,{251, 167, 237, 172} ,{54, 1, 4, 10} ,{54, 1, 2, 10} ,{203, 1, 10, 10} ,{215, 1, 10, 10} ,{203, 1, 1, 0} ,{215, 1, 1, 0} ,{11, 10, 238, 172} ,{13, 10, 238, 172} ,{14, 10, 238, 172} ,{15, 10, 1, 0} ,{70, 2, 1, 0} ,{16, 10, 1, 0} ,{17, 10, 1, 0} ,{59, 172, 1, 0} ,{166, 180, 67, 1} ,{59, 172, 67, 1} ,{240, 172, 3, 0} ,{242, 172, 3, 0} ,{104, 0, 0, 0} ,{167, 180, 104, 0} ,{15, 10, 22, 10} ,{203, 1, 22, 10} ,{215, 1, 22, 10} ,{17, 3, 91, 0} ,{100, 0, 63, 38} ,{100, 0, 34, 38} ,{11, 0, 67, 175} ,{13, 0, 67, 175} ,{99, 8, 68, 175} ,{99, 8, 70, 175} ,{98, 173, 229, 37} ,{99, 173, 229, 37} ,{100, 0, 68, 175} ,{100, 0, 70, 175} ,{27, 10, 0, 0} ,{100, 0, 27, 10} ,{28, 10, 0, 0} ,{16, 1, 28, 10} ,{121, 0, 156, 173} ,{202, 0, 156, 173} ,{17, 3, 207, 4} ,{30, 10, 31, 10} ,{37, 1, 121, 2} ,{168, 5, 121, 2} ,{240, 172, 32, 10} ,{242, 172, 32, 10} ,{168, 180, 35, 10} ,{240, 172, 36, 10} ,{242, 172, 36, 10} ,{37, 10, 66, 38} ,{115, 2, 71, 175} ,{115, 2, 73, 175} ,{10, 1, 0, 0} ,{100, 0, 10, 1} ,{143, 2, 10, 1} ,{179, 0, 10, 1} ,{179, 0, 131, 64} ,{179, 0, 132, 64} ,{38, 10, 0, 0} ,{169, 180, 131, 171} ,{170, 180, 131, 171} ,{39, 10, 3, 0} ,{100, 0, 228, 37} ,{40, 10, 0, 0} ,{36, 1, 0, 0} ,{41, 10, 0, 0} ,{106, 4, 42, 10} ,{171, 180, 31, 10} ,{44, 10, 0, 0} ,{45, 10, 28, 10} ,{120, 0, 46, 10} ,{239, 169, 246, 171} ,{240, 169, 246, 171} ,{100, 0, 2, 38} ,{39, 0, 228, 37} ,{2, 0, 2, 38} ,{172, 180, 236, 1} ,{179, 0, 88, 38} ,{173, 180, 28, 10} ,{174, 180, 28, 10} ,{76, 0, 14, 0} ,{179, 0, 34, 0} ,{52, 10, 53, 10} ,{176, 180, 56, 10} ,{40, 0, 35, 66} ,{57, 10, 22, 10} ,{85, 0, 41, 10} ,{58, 10, 74, 175} ,{124, 0, 121, 169} ,{59, 10, 10, 1} ,{213, 2, 121, 169} ,{191, 2, 121, 169} ,{202, 0, 121, 169} ,{213, 2, 207, 176} ,{83, 1, 60, 10} ,{61, 10, 0, 0} ,{81, 0, 75, 175} ,{177, 180, 1, 0} ,{64, 10, 67, 1} ,{65, 10, 66, 10} ,{67, 10, 68, 10} ,{67, 10, 121, 2} ,{67, 10, 33, 7} ,{69, 10, 76, 175} ,{72, 10, 76, 175} ,{69, 10, 78, 175} ,{72, 10, 78, 175} ,{74, 10, 79, 175} ,{76, 10, 79, 175} ,{110, 0, 23, 0} ,{110, 0, 44, 38} ,{110, 0, 27, 0} ,{110, 0, 28, 0} ,{110, 0, 29, 0} ,{110, 0, 30, 0} ,{110, 0, 31, 0} ,{110, 0, 32, 0} ,{110, 0, 238, 37} ,{110, 0, 18, 0} ,{110, 0, 0, 38} ,{110, 0, 235, 37} ,{110, 0, 236, 37} ,{110, 0, 49, 38} ,{183, 2, 23, 0} ,{183, 2, 24, 0} ,{183, 2, 25, 0} ,{183, 2, 26, 0} ,{183, 2, 27, 0} ,{183, 2, 28, 0} ,{183, 2, 29, 0} ,{183, 2, 30, 0} ,{183, 2, 31, 0} ,{183, 2, 32, 0} ,{183, 2, 238, 37} ,{183, 2, 18, 0} ,{183, 2, 0, 38} ,{183, 2, 235, 37} ,{183, 2, 236, 37} ,{18, 169, 45, 0} ,{18, 169, 49, 0} ,{18, 169, 59, 0} ,{18, 169, 68, 0} ,{18, 169, 180, 0} ,{77, 10, 70, 38} ,{18, 3, 6, 0} ,{78, 10, 6, 0} ,{178, 180, 6, 0} ,{81, 10, 6, 0} ,{82, 10, 6, 0} ,{83, 10, 6, 0} ,{84, 10, 6, 0} ,{246, 3, 6, 0} ,{85, 10, 6, 0} ,{179, 180, 6, 0} ,{87, 10, 6, 0} ,{88, 10, 6, 0} ,{89, 10, 6, 0} ,{90, 10, 6, 0} ,{91, 10, 6, 0} ,{180, 180, 6, 0} ,{94, 10, 6, 0} ,{95, 10, 6, 0} ,{96, 10, 6, 0} ,{97, 10, 6, 0} ,{98, 10, 6, 0} ,{181, 180, 6, 0} ,{101, 10, 6, 0} ,{102, 10, 6, 0} ,{152, 169, 80, 175} ,{153, 169, 80, 175} ,{133, 171, 81, 175} ,{243, 172, 81, 175} ,{83, 175, 241, 169} ,{82, 175, 241, 169} ,{152, 169, 241, 169} ,{153, 169, 241, 169} ,{35, 1, 244, 172} ,{82, 175, 244, 172} ,{83, 175, 244, 172} ,{35, 1, 132, 171} ,{35, 1, 219, 170} ,{234, 169, 52, 2} ,{234, 169, 107, 10} ,{234, 169, 108, 10} ,{182, 180, 110, 10} ,{84, 175, 241, 169} ,{234, 169, 111, 10} ,{234, 169, 112, 10} ,{184, 180, 114, 10} ,{185, 180, 134, 171} ,{85, 175, 245, 170} ,{186, 180, 82, 1} ,{187, 180, 116, 10} ,{188, 180, 86, 175} ,{189, 180, 49, 1} ,{190, 180, 134, 171} ,{35, 1, 210, 65} ,{35, 1, 206, 65} ,{152, 169, 135, 171} ,{153, 169, 135, 171} ,{87, 175, 132, 0} ,{119, 10, 120, 10} ,{191, 180, 122, 10} ,{81, 169, 47, 0} ,{107, 0, 125, 10} ,{192, 180, 82, 1} ,{126, 10, 120, 10} ,{127, 10, 128, 10} ,{129, 10, 130, 10} ,{131, 10, 0, 0} ,{107, 0, 132, 10} ,{7, 167, 51, 0} ,{6, 167, 52, 0} ,{200, 170, 52, 0} ,{81, 169, 52, 0} ,{134, 10, 130, 10} ,{194, 180, 104, 1} ,{6, 167, 53, 0} ,{200, 170, 53, 0} ,{6, 167, 56, 0} ,{7, 167, 56, 0} ,{196, 180, 82, 1} ,{81, 169, 58, 0} ,{138, 10, 6, 0} ,{197, 180, 141, 10} ,{6, 167, 60, 0} ,{81, 169, 60, 0} ,{81, 169, 61, 0} ,{6, 167, 62, 0} ,{200, 170, 62, 0} ,{81, 169, 62, 0} ,{142, 10, 143, 10} ,{144, 10, 0, 0} ,{145, 10, 3, 0} ,{146, 10, 6, 0} ,{198, 180, 6, 0} ,{148, 10, 0, 0} ,{81, 169, 70, 0} ,{149, 10, 6, 0} ,{150, 10, 6, 0} ,{85, 0, 61, 65} ,{200, 170, 70, 0} ,{177, 0, 81, 41} ,{151, 10, 6, 0} ,{152, 10, 6, 0} ,{6, 167, 46, 0} ,{200, 170, 47, 0} ,{153, 10, 82, 1} ,{7, 167, 49, 0} ,{6, 167, 49, 0} ,{6, 167, 50, 0} ,{199, 180, 50, 0} ,{6, 167, 57, 0} ,{7, 167, 59, 0} ,{136, 2, 82, 1} ,{154, 10, 82, 1} ,{155, 10, 82, 1} ,{156, 10, 82, 1} ,{157, 10, 158, 10} ,{200, 180, 61, 0} ,{159, 10, 6, 0} ,{88, 175, 104, 1} ,{88, 175, 182, 0} ,{81, 169, 182, 0} ,{81, 169, 104, 1} ,{213, 166, 34, 66} ,{245, 172, 51, 0} ,{245, 172, 56, 0} ,{201, 180, 56, 0} ,{245, 172, 69, 0} ,{202, 180, 48, 0} ,{137, 171, 48, 0} ,{137, 171, 49, 0} ,{137, 171, 53, 0} ,{137, 171, 54, 0} ,{165, 10, 77, 0} ,{177, 0, 9, 0} ,{115, 2, 6, 0} ,{166, 10, 0, 0} ,{203, 180, 50, 0} ,{204, 180, 158, 10} ,{82, 169, 167, 10} ,{82, 169, 168, 10} ,{82, 169, 169, 10} ,{82, 169, 170, 10} ,{89, 175, 171, 10} ,{82, 169, 172, 10} ,{89, 175, 173, 10} ,{246, 172, 173, 10} ,{205, 180, 173, 10} ,{82, 169, 174, 10} ,{90, 175, 175, 10} ,{82, 169, 176, 10} ,{246, 172, 177, 10} ,{90, 175, 177, 10} ,{206, 180, 177, 10} ,{207, 180, 24, 0} ,{72, 167, 24, 0} ,{72, 167, 25, 0} ,{72, 167, 26, 0} ,{72, 167, 27, 0} ,{72, 167, 28, 0} ,{72, 167, 29, 0} ,{72, 167, 30, 0} ,{72, 167, 31, 0} ,{72, 167, 32, 0} ,{72, 167, 14, 4} ,{72, 167, 180, 10} ,{72, 167, 181, 10} ,{72, 167, 224, 6} ,{72, 167, 149, 170} ,{72, 167, 43, 169} ,{72, 167, 63, 172} ,{69, 168, 24, 0} ,{69, 168, 25, 0} ,{69, 168, 26, 0} ,{69, 168, 27, 0} ,{69, 168, 28, 0} ,{69, 168, 29, 0} ,{69, 168, 30, 0} ,{69, 168, 31, 0} ,{69, 168, 32, 0} ,{69, 168, 14, 4} ,{69, 168, 180, 10} ,{69, 168, 181, 10} ,{69, 168, 224, 6} ,{69, 168, 149, 170} ,{69, 168, 43, 169} ,{69, 168, 63, 172} ,{210, 180, 48, 0} ,{72, 167, 171, 173} ,{72, 167, 66, 172} ,{211, 180, 149, 170} ,{253, 169, 47, 0} ,{213, 180, 245, 2} ,{214, 180, 245, 2} ,{91, 175, 16, 4} ,{215, 180, 16, 4} ,{216, 180, 171, 10} ,{51, 10, 34, 1} ,{65, 1, 34, 1} ,{72, 1, 34, 1} ,{73, 3, 34, 1} ,{71, 168, 34, 1} ,{225, 170, 34, 1} ,{174, 168, 34, 1} ,{186, 10, 70, 168} ,{189, 10, 70, 168} ,{174, 169, 34, 1} ,{148, 168, 141, 0} ,{147, 168, 141, 0} ,{51, 10, 247, 172} ,{72, 1, 247, 172} ,{51, 10, 138, 171} ,{65, 1, 138, 171} ,{72, 1, 138, 171} ,{73, 3, 138, 171} ,{148, 168, 201, 0} ,{147, 168, 201, 0} ,{72, 168, 242, 167} ,{65, 1, 91, 169} ,{51, 168, 242, 167} ,{73, 3, 91, 169} ,{217, 180, 193, 10} ,{148, 168, 172, 0} ,{147, 168, 172, 0} ,{148, 168, 193, 0} ,{147, 168, 193, 0} ,{71, 168, 247, 172} ,{251, 172, 141, 0} ,{133, 175, 34, 1} ,{92, 175, 195, 10} ,{92, 175, 196, 10} ,{93, 175, 195, 10} ,{93, 175, 196, 10} ,{218, 180, 199, 2} ,{219, 180, 195, 10} ,{104, 10, 95, 175} ,{105, 10, 95, 175} ,{220, 180, 91, 0} ,{223, 180, 246, 65} ,{104, 10, 96, 175} ,{105, 10, 96, 175} ,{90, 168, 199, 10} ,{90, 168, 199, 2} ,{10, 169, 196, 10} ,{10, 169, 195, 10} ,{91, 168, 199, 10} ,{91, 168, 199, 2} ,{9, 169, 196, 10} ,{9, 169, 195, 10} ,{224, 180, 161, 65} ,{225, 180, 164, 65} ,{226, 180, 163, 65} ,{51, 10, 139, 171} ,{65, 1, 139, 171} ,{72, 1, 139, 171} ,{73, 3, 139, 171} ,{228, 180, 202, 10} ,{230, 180, 202, 10} ,{51, 10, 248, 172} ,{71, 168, 248, 172} ,{72, 1, 248, 172} ,{51, 10, 117, 168} ,{65, 1, 117, 168} ,{72, 1, 117, 168} ,{73, 3, 117, 168} ,{71, 168, 117, 168} ,{225, 170, 117, 168} ,{174, 168, 117, 168} ,{173, 169, 117, 168} ,{246, 169, 117, 168} ,{174, 169, 117, 168} ,{51, 10, 183, 171} ,{72, 1, 183, 171} ,{51, 10, 224, 171} ,{72, 1, 224, 171} ,{182, 171, 98, 175} ,{208, 170, 98, 175} ,{51, 10, 140, 171} ,{65, 1, 140, 171} ,{72, 1, 140, 171} ,{73, 3, 140, 171} ,{72, 168, 142, 168} ,{51, 168, 142, 168} ,{51, 10, 15, 169} ,{65, 1, 15, 169} ,{72, 1, 15, 169} ,{73, 3, 15, 169} ,{79, 170, 91, 169} ,{249, 172, 207, 10} ,{99, 175, 115, 173} ,{99, 175, 81, 176} ,{79, 170, 117, 168} ,{232, 180, 207, 10} ,{234, 180, 209, 10} ,{100, 175, 210, 10} ,{235, 180, 210, 10} ,{225, 170, 15, 169} ,{15, 176, 145, 170} ,{236, 180, 162, 65} ,{237, 180, 201, 10} ,{148, 168, 156, 167} ,{147, 168, 156, 167} ,{251, 172, 156, 167} ,{148, 168, 226, 170} ,{147, 168, 226, 170} ,{251, 172, 226, 170} ,{51, 10, 252, 172} ,{72, 1, 252, 172} ,{71, 168, 252, 172} ,{63, 2, 211, 10} ,{212, 10, 0, 0} ,{213, 10, 214, 10} ,{215, 10, 216, 10} ,{238, 180, 218, 10} ,{3, 3, 219, 10} ,{220, 10, 0, 0} ,{221, 10, 0, 0} ,{222, 10, 120, 10} ,{239, 180, 25, 66} ,{79, 0, 25, 66} ,{144, 171, 225, 10} ,{0, 173, 225, 10} ,{79, 0, 28, 66} ,{163, 168, 227, 10} ,{49, 168, 228, 10} ,{49, 168, 229, 10} ,{49, 168, 161, 10} ,{109, 0, 6, 0} ,{240, 180, 238, 37} ,{149, 0, 33, 7} ,{146, 0, 46, 10} ,{232, 10, 18, 0} ,{70, 1, 233, 10} ,{131, 0, 233, 10} ,{234, 10, 233, 10} ,{71, 0, 112, 2} ,{111, 2, 112, 2} ,{113, 2, 112, 2} ,{235, 10, 237, 1} ,{236, 10, 0, 0} ,{13, 0, 237, 10} ,{237, 10, 0, 0} ,{238, 10, 237, 10} ,{239, 10, 237, 10} ,{240, 10, 0, 0} ,{173, 168, 241, 10} ,{242, 10, 237, 1} ,{102, 0, 54, 66} ,{243, 10, 244, 10} ,{243, 10, 15, 8} ,{245, 10, 0, 0} ,{246, 10, 0, 0} ,{247, 10, 0, 0} ,{100, 0, 247, 10} ,{143, 2, 247, 10} ,{248, 10, 247, 10} ,{249, 10, 247, 10} ,{250, 10, 247, 10} ,{105, 10, 247, 10} ,{105, 10, 63, 66} ,{104, 10, 63, 66} ,{251, 10, 0, 0} ,{252, 10, 0, 0} ,{253, 10, 0, 0} ,{254, 10, 0, 0} ,{149, 0, 18, 0} ,{255, 10, 0, 0} ,{0, 11, 254, 10} ,{1, 11, 0, 0} ,{226, 0, 233, 10} ,{179, 0, 82, 0} ,{241, 180, 63, 0} ,{3, 11, 4, 11} ,{5, 11, 228, 10} ,{102, 0, 82, 0} ,{109, 0, 82, 0} ,{6, 11, 219, 166} ,{102, 0, 84, 66} ,{7, 11, 219, 166} ,{242, 180, 103, 175} ,{244, 180, 103, 175} ,{61, 1, 219, 166} ,{102, 0, 89, 66} ,{61, 1, 115, 176} ,{143, 2, 82, 0} ,{11, 11, 219, 166} ,{12, 11, 237, 1} ,{13, 11, 94, 66} ,{14, 11, 15, 11} ,{245, 180, 17, 11} ,{13, 11, 219, 166} ,{247, 180, 200, 66} ,{248, 180, 86, 66} ,{18, 3, 19, 11} ,{37, 0, 33, 0} ,{249, 180, 219, 166} ,{131, 0, 219, 166} ,{21, 11, 237, 1} ,{22, 11, 0, 0} ,{23, 11, 237, 1} ,{24, 11, 19, 11} ,{25, 11, 219, 166} ,{250, 180, 26, 11} ,{238, 10, 27, 11} ,{28, 11, 219, 166} ,{102, 0, 219, 166} ,{29, 11, 237, 1} ,{102, 0, 114, 66} ,{30, 11, 94, 66} ,{75, 167, 241, 167} ,{70, 167, 241, 167} ,{75, 167, 104, 175} ,{70, 167, 104, 175} ,{75, 167, 105, 175} ,{70, 167, 105, 175} ,{31, 11, 255, 167} ,{31, 11, 32, 168} ,{15, 11, 0, 0} ,{102, 0, 94, 66} ,{102, 0, 255, 167} ,{102, 0, 32, 168} ,{253, 172, 143, 171} ,{254, 172, 143, 171} ,{75, 167, 142, 171} ,{70, 167, 142, 171} ,{253, 172, 106, 175} ,{254, 172, 106, 175} ,{124, 176, 32, 168} ,{125, 176, 255, 167} ,{251, 180, 32, 168} ,{252, 180, 255, 167} ,{32, 11, 0, 0} ,{33, 11, 0, 0} ,{34, 11, 241, 167} ,{35, 11, 241, 167} ,{34, 11, 142, 171} ,{35, 11, 142, 171} ,{173, 168, 36, 11} ,{173, 168, 37, 11} ,{38, 11, 120, 10} ,{39, 11, 120, 10} ,{107, 175, 147, 66} ,{107, 175, 148, 66} ,{38, 11, 154, 169} ,{39, 11, 154, 169} ,{253, 180, 109, 175} ,{254, 180, 109, 175} ,{38, 11, 111, 175} ,{39, 11, 111, 175} ,{40, 11, 0, 0} ,{41, 11, 42, 11} ,{41, 11, 246, 10} ,{146, 171, 120, 10} ,{147, 171, 120, 10} ,{146, 171, 154, 169} ,{147, 171, 154, 169} ,{71, 0, 44, 11} ,{71, 0, 45, 11} ,{46, 11, 33, 7} ,{46, 11, 18, 0} ,{46, 11, 68, 10} ,{46, 11, 38, 66} ,{46, 11, 214, 66} ,{46, 11, 41, 66} ,{46, 11, 40, 66} ,{46, 11, 19, 11} ,{46, 11, 22, 10} ,{47, 11, 33, 7} ,{47, 11, 18, 0} ,{47, 11, 68, 10} ,{47, 11, 214, 66} ,{13, 0, 18, 1} ,{11, 0, 18, 1} ,{15, 1, 18, 1} ,{14, 1, 18, 1} ,{48, 11, 0, 0} ,{49, 11, 0, 0} ,{50, 11, 0, 0} ,{51, 11, 0, 0} ,{224, 170, 219, 171} ,{91, 173, 219, 171} ,{173, 168, 53, 11} ,{102, 0, 50, 11} ,{173, 168, 54, 11} ,{55, 11, 188, 66} ,{34, 11, 112, 175} ,{35, 11, 112, 175} ,{80, 170, 120, 10} ,{144, 171, 116, 175} ,{80, 170, 154, 169} ,{255, 180, 241, 167} ,{43, 11, 120, 10} ,{18, 11, 120, 10} ,{61, 11, 0, 0} ,{0, 181, 64, 11} ,{65, 11, 0, 0} ,{66, 11, 0, 0} ,{67, 11, 0, 0} ,{68, 11, 0, 0} ,{132, 175, 69, 11} ,{13, 0, 114, 10} ,{49, 168, 56, 66} ,{49, 168, 57, 66} ,{49, 168, 245, 10} ,{49, 168, 246, 10} ,{70, 11, 233, 10} ,{149, 0, 233, 10} ,{24, 11, 233, 10} ,{146, 0, 68, 10} ,{71, 11, 0, 0} ,{11, 0, 114, 175} ,{13, 0, 114, 175} ,{11, 0, 145, 171} ,{13, 0, 145, 171} ,{1, 181, 19, 11} ,{80, 0, 57, 66} ,{80, 0, 56, 66} ,{100, 0, 74, 11} ,{100, 0, 75, 11} ,{100, 0, 245, 10} ,{100, 0, 246, 10} ,{76, 11, 0, 0} ,{2, 181, 54, 66} ,{75, 167, 97, 168} ,{70, 167, 97, 168} ,{77, 11, 123, 66} ,{77, 11, 124, 66} ,{75, 167, 238, 66} ,{70, 167, 237, 66} ,{93, 168, 255, 167} ,{93, 168, 32, 168} ,{93, 168, 32, 11} ,{93, 168, 33, 11} ,{3, 181, 220, 170} ,{4, 181, 220, 170} ,{102, 0, 162, 66} ,{102, 0, 163, 66} ,{146, 171, 115, 175} ,{147, 171, 115, 175} ,{75, 167, 148, 171} ,{70, 167, 148, 171} ,{34, 11, 148, 171} ,{35, 11, 148, 171} ,{102, 0, 195, 66} ,{0, 173, 116, 175} ,{102, 0, 197, 66} ,{5, 181, 220, 170} ,{81, 0, 207, 4} ,{214, 9, 118, 64} ,{34, 171, 117, 175} ,{67, 173, 117, 175} ,{11, 169, 118, 175} ,{11, 169, 152, 171} ,{79, 0, 4, 67} ,{11, 169, 233, 166} ,{11, 169, 12, 169} ,{79, 0, 7, 67} ,{11, 169, 13, 169} ,{7, 181, 32, 7} ,{224, 10, 118, 175} ,{224, 10, 152, 171} ,{79, 0, 12, 67} ,{224, 10, 12, 169} ,{79, 0, 14, 67} ,{8, 181, 86, 11} ,{87, 11, 6, 0} ,{88, 11, 34, 1} ,{89, 11, 0, 0} ,{14, 1, 13, 1} ,{15, 1, 13, 1} ,{90, 11, 0, 0} ,{91, 11, 0, 0} ,{195, 2, 77, 0} ,{11, 0, 92, 11} ,{13, 0, 92, 11} ,{11, 0, 93, 11} ,{13, 0, 93, 11} ,{30, 7, 119, 175} ,{30, 7, 120, 175} ,{31, 7, 119, 175} ,{31, 7, 120, 175} ,{179, 0, 78, 38} ,{71, 0, 95, 11} ,{69, 11, 0, 0} ,{96, 11, 0, 0} ,{97, 11, 0, 0} ,{146, 10, 98, 11} ,{99, 11, 97, 0} ,{100, 11, 107, 10} ,{9, 181, 6, 0} ,{177, 0, 78, 38} ,{102, 11, 0, 0} ,{103, 11, 0, 0} ,{31, 7, 122, 175} ,{31, 7, 123, 175} ,{30, 7, 122, 175} ,{30, 7, 123, 175} ,{215, 170, 247, 10} ,{153, 171, 247, 10} ,{104, 11, 0, 0} ,{105, 11, 0, 0} ,{12, 181, 107, 11} ,{108, 11, 109, 11} ,{110, 11, 72, 173} ,{15, 181, 112, 11} ,{113, 11, 0, 0} ,{144, 168, 81, 168} ,{74, 168, 81, 168} ,{16, 181, 20, 3} ,{114, 11, 12, 1} ,{115, 11, 0, 0} ,{17, 181, 117, 11} ,{118, 11, 0, 0} ,{119, 11, 120, 11} ,{121, 11, 122, 11} ,{123, 11, 124, 11} ,{125, 11, 0, 0} ,{126, 11, 0, 0} ,{127, 11, 0, 0} ,{18, 181, 130, 11} ,{19, 181, 10, 10} ,{252, 167, 79, 11} ,{252, 167, 241, 10} ,{252, 167, 108, 10} ,{252, 167, 133, 11} ,{252, 167, 52, 2} ,{82, 170, 134, 11} ,{82, 170, 133, 11} ,{20, 181, 91, 0} ,{21, 181, 91, 0} ,{252, 167, 46, 10} ,{252, 167, 110, 10} ,{252, 167, 255, 167} ,{252, 167, 32, 168} ,{22, 181, 137, 11} ,{23, 181, 137, 11} ,{252, 167, 161, 65} ,{252, 167, 163, 65} ,{82, 170, 110, 10} ,{124, 175, 83, 11} ,{125, 175, 134, 11} ,{24, 181, 38, 10} ,{252, 167, 178, 0} ,{124, 175, 133, 11} ,{25, 181, 137, 11} ,{252, 167, 162, 65} ,{1, 173, 82, 11} ,{2, 173, 134, 11} ,{26, 181, 38, 10} ,{252, 167, 139, 11} ,{1, 173, 133, 11} ,{27, 181, 137, 11} ,{252, 167, 164, 65} ,{126, 175, 83, 11} ,{125, 175, 83, 11} ,{28, 181, 83, 11} ,{127, 175, 83, 11} ,{82, 170, 83, 11} ,{29, 181, 133, 11} ,{126, 175, 10, 10} ,{82, 170, 193, 2} ,{252, 167, 33, 0} ,{1, 173, 93, 0} ,{2, 173, 93, 0} ,{30, 181, 93, 0} ,{127, 175, 93, 0} ,{82, 170, 93, 0} ,{129, 175, 128, 175} ,{31, 181, 128, 175} ,{32, 181, 93, 0} ,{33, 181, 93, 0} ,{34, 181, 91, 0} ,{2, 173, 82, 0} ,{215, 166, 143, 11} ,{35, 181, 82, 0} ,{36, 181, 83, 11} ,{37, 181, 79, 11} ,{252, 167, 146, 11} ,{129, 175, 131, 175} ,{130, 175, 131, 175} ,{215, 166, 184, 0} ,{215, 166, 105, 1} ,{215, 166, 244, 0} ,{38, 181, 83, 11} ,{39, 181, 83, 11} ,{40, 181, 83, 11} ,{41, 181, 83, 11} ,{215, 166, 234, 0} ,{102, 0, 213, 70} ,{132, 175, 192, 65} ,{148, 11, 29, 68} ,{149, 11, 82, 1} ,{172, 169, 3, 173} ,{43, 10, 82, 1} ,{150, 11, 134, 175} ,{152, 11, 134, 175} ,{8, 2, 82, 1} ,{153, 11, 82, 1} ,{42, 181, 63, 38} ,{154, 11, 82, 1} ,{155, 11, 140, 175} ,{157, 11, 82, 1} ,{44, 181, 158, 11} ,{45, 181, 160, 11} ,{47, 181, 34, 1} ,{162, 11, 82, 1} ,{163, 11, 82, 1} ,{164, 11, 82, 1} ,{48, 181, 137, 175} ,{49, 181, 137, 175} ,{50, 181, 139, 175} ,{51, 181, 139, 175} ,{53, 181, 7, 173} ,{54, 181, 82, 1} ,{215, 166, 10, 10} ,{55, 181, 140, 175} ,{177, 11, 178, 11} ,{179, 11, 178, 11} ,{180, 11, 141, 175} ,{182, 11, 141, 175} ,{205, 170, 154, 171} ,{205, 170, 184, 11} ,{205, 170, 155, 171} ,{206, 170, 154, 171} ,{206, 170, 184, 11} ,{206, 170, 155, 171} ,{239, 169, 142, 175} ,{239, 169, 184, 11} ,{239, 169, 143, 175} ,{240, 169, 142, 175} ,{240, 169, 184, 11} ,{240, 169, 143, 175} ,{177, 171, 154, 171} ,{177, 171, 144, 175} ,{177, 171, 155, 171} ,{206, 168, 184, 11} ,{178, 171, 154, 171} ,{178, 171, 144, 175} ,{178, 171, 155, 171} ,{186, 11, 184, 11} ,{56, 181, 184, 11} ,{58, 181, 145, 175} ,{60, 181, 145, 175} ,{187, 11, 188, 11} ,{187, 11, 189, 11} ,{31, 7, 103, 168} ,{30, 7, 103, 168} ,{62, 181, 197, 67} ,{63, 181, 189, 11} ,{11, 0, 147, 175} ,{13, 0, 147, 175} ,{157, 171, 118, 5} ,{157, 171, 120, 5} ,{157, 171, 194, 11} ,{157, 171, 195, 11} ,{150, 175, 39, 1} ,{151, 175, 39, 1} ,{149, 175, 52, 2} ,{4, 173, 52, 2} ,{5, 173, 52, 2} ,{149, 175, 114, 10} ,{4, 173, 114, 10} ,{5, 173, 114, 10} ,{202, 170, 4, 11} ,{4, 173, 4, 11} ,{5, 173, 4, 11} ,{158, 171, 55, 3} ,{159, 171, 55, 3} ,{150, 175, 20, 3} ,{151, 175, 20, 3} ,{71, 0, 197, 11} ,{198, 11, 82, 1} ,{199, 11, 82, 1} ,{172, 169, 184, 11} ,{200, 11, 147, 0} ,{64, 181, 201, 11} ,{65, 181, 153, 175} ,{66, 181, 203, 11} ,{155, 175, 153, 175} ,{155, 175, 205, 11} ,{200, 11, 206, 11} ,{200, 11, 207, 11} ,{200, 11, 208, 11} ,{209, 11, 210, 11} ,{211, 11, 0, 0} ,{31, 7, 12, 0} ,{30, 7, 12, 0} ,{31, 7, 133, 168} ,{30, 7, 133, 168} ,{31, 7, 129, 168} ,{30, 7, 129, 168} ,{205, 10, 214, 11} ,{68, 181, 52, 2} ,{215, 11, 0, 0} ,{216, 11, 0, 0} ,{31, 8, 217, 11} ,{218, 11, 245, 10} ,{69, 181, 82, 1} ,{185, 166, 220, 11} ,{156, 175, 221, 11} ,{156, 175, 222, 11} ,{162, 171, 222, 11} ,{162, 171, 223, 11} ,{185, 166, 224, 11} ,{185, 166, 225, 11} ,{185, 166, 226, 11} ,{185, 166, 227, 11} ,{70, 181, 228, 11} ,{71, 181, 229, 11} ,{72, 181, 228, 11} ,{73, 181, 229, 11} ,{74, 181, 231, 11} ,{157, 175, 233, 11} ,{157, 175, 164, 3} ,{76, 181, 236, 11} ,{161, 171, 24, 0} ,{161, 171, 25, 0} ,{161, 171, 26, 0} ,{161, 171, 27, 0} ,{77, 181, 225, 11} ,{78, 181, 241, 11} ,{79, 181, 243, 11} ,{185, 166, 244, 11} ,{162, 171, 245, 11} ,{185, 166, 246, 11} ,{185, 166, 236, 11} ,{80, 181, 121, 2} ,{81, 181, 121, 2} ,{82, 181, 121, 2} ,{83, 181, 121, 2} ,{185, 166, 1, 0} ,{185, 166, 251, 11} ,{252, 11, 82, 1} ,{175, 0, 112, 11} ,{185, 166, 253, 11} ,{84, 181, 7, 173} ,{85, 181, 7, 173} ,{0, 12, 172, 0} ,{0, 12, 1, 12} ,{0, 12, 2, 12} ,{86, 181, 2, 12} ,{87, 181, 4, 12} ,{88, 181, 42, 10} ,{90, 181, 8, 12} ,{92, 181, 10, 12} ,{0, 12, 22, 10} ,{94, 181, 12, 12} ,{95, 181, 110, 10} ,{46, 11, 244, 37} ,{46, 11, 245, 37} ,{46, 11, 246, 37} ,{46, 11, 247, 37} ,{46, 11, 248, 37} ,{46, 11, 249, 37} ,{46, 11, 250, 37} ,{46, 11, 251, 37} ,{46, 11, 252, 37} ,{231, 166, 14, 4} ,{231, 166, 180, 10} ,{231, 166, 181, 10} ,{231, 166, 13, 12} ,{231, 166, 14, 12} ,{231, 166, 15, 12} ,{231, 166, 252, 3} ,{231, 166, 16, 12} ,{231, 166, 17, 12} ,{231, 166, 18, 12} ,{231, 166, 221, 6} ,{19, 12, 244, 37} ,{19, 12, 245, 37} ,{19, 12, 246, 37} ,{19, 12, 247, 37} ,{19, 12, 248, 37} ,{19, 12, 249, 37} ,{19, 12, 250, 37} ,{19, 12, 251, 37} ,{19, 12, 252, 37} ,{19, 12, 192, 168} ,{3, 169, 180, 10} ,{3, 169, 181, 10} ,{3, 169, 13, 12} ,{3, 169, 14, 12} ,{3, 169, 15, 12} ,{3, 169, 252, 3} ,{3, 169, 16, 12} ,{3, 169, 17, 12} ,{3, 169, 18, 12} ,{3, 169, 221, 6} ,{87, 178, 241, 37} ,{88, 178, 241, 37} ,{89, 178, 241, 37} ,{90, 178, 241, 37} ,{91, 178, 241, 37} ,{92, 178, 241, 37} ,{93, 178, 241, 37} ,{94, 178, 241, 37} ,{95, 178, 241, 37} ,{96, 181, 241, 37} ,{97, 181, 241, 37} ,{98, 181, 241, 37} ,{99, 181, 241, 37} ,{100, 181, 241, 37} ,{101, 181, 241, 37} ,{102, 181, 241, 37} ,{103, 181, 241, 37} ,{104, 181, 241, 37} ,{105, 181, 241, 37} ,{106, 181, 241, 37} ,{164, 167, 45, 0} ,{164, 167, 46, 0} ,{164, 167, 47, 0} ,{164, 167, 48, 0} ,{164, 167, 49, 0} ,{164, 167, 50, 0} ,{164, 167, 51, 0} ,{164, 167, 52, 0} ,{164, 167, 53, 0} ,{164, 167, 54, 0} ,{164, 167, 55, 0} ,{164, 167, 56, 0} ,{164, 167, 57, 0} ,{164, 167, 58, 0} ,{164, 167, 59, 0} ,{164, 167, 60, 0} ,{164, 167, 61, 0} ,{164, 167, 62, 0} ,{164, 167, 63, 0} ,{164, 167, 64, 0} ,{164, 167, 65, 0} ,{164, 167, 66, 0} ,{164, 167, 67, 0} ,{164, 167, 68, 0} ,{164, 167, 69, 0} ,{164, 167, 70, 0} ,{150, 167, 45, 0} ,{150, 167, 46, 0} ,{150, 167, 47, 0} ,{150, 167, 48, 0} ,{150, 167, 49, 0} ,{150, 167, 50, 0} ,{150, 167, 51, 0} ,{150, 167, 52, 0} ,{150, 167, 53, 0} ,{150, 167, 54, 0} ,{150, 167, 55, 0} ,{150, 167, 56, 0} ,{150, 167, 57, 0} ,{150, 167, 58, 0} ,{150, 167, 59, 0} ,{150, 167, 60, 0} ,{150, 167, 61, 0} ,{150, 167, 62, 0} ,{150, 167, 63, 0} ,{150, 167, 64, 0} ,{150, 167, 65, 0} ,{150, 167, 66, 0} ,{150, 167, 67, 0} ,{150, 167, 68, 0} ,{150, 167, 69, 0} ,{150, 167, 70, 0} ,{165, 167, 45, 0} ,{165, 167, 46, 0} ,{165, 167, 47, 0} ,{165, 167, 48, 0} ,{165, 167, 49, 0} ,{165, 167, 50, 0} ,{165, 167, 51, 0} ,{165, 167, 52, 0} ,{165, 167, 53, 0} ,{165, 167, 54, 0} ,{165, 167, 55, 0} ,{165, 167, 56, 0} ,{165, 167, 57, 0} ,{165, 167, 58, 0} ,{165, 167, 59, 0} ,{165, 167, 60, 0} ,{165, 167, 61, 0} ,{165, 167, 62, 0} ,{165, 167, 63, 0} ,{165, 167, 64, 0} ,{165, 167, 65, 0} ,{165, 167, 66, 0} ,{165, 167, 67, 0} ,{165, 167, 68, 0} ,{165, 167, 69, 0} ,{165, 167, 70, 0} ,{46, 11, 243, 37} ,{4, 169, 180, 10} ,{4, 169, 181, 10} ,{4, 169, 13, 12} ,{4, 169, 14, 12} ,{4, 169, 15, 12} ,{4, 169, 252, 3} ,{4, 169, 16, 12} ,{4, 169, 17, 12} ,{4, 169, 18, 12} ,{4, 169, 221, 6} ,{83, 169, 244, 37} ,{83, 169, 245, 37} ,{83, 169, 246, 37} ,{83, 169, 247, 37} ,{83, 169, 248, 37} ,{83, 169, 249, 37} ,{83, 169, 250, 37} ,{83, 169, 251, 37} ,{83, 169, 252, 37} ,{100, 0, 53, 68} ,{239, 11, 182, 68} ,{124, 167, 55, 3} ,{212, 167, 55, 3} ,{124, 167, 33, 12} ,{212, 167, 33, 12} ,{124, 167, 158, 175} ,{212, 167, 158, 175} ,{124, 167, 159, 175} ,{212, 167, 159, 175} ,{124, 167, 160, 175} ,{212, 167, 160, 175} ,{124, 167, 161, 175} ,{212, 167, 161, 175} ,{124, 167, 213, 170} ,{29, 168, 8, 173} ,{29, 168, 9, 173} ,{212, 167, 213, 170} ,{124, 167, 214, 170} ,{29, 168, 10, 173} ,{29, 168, 11, 173} ,{212, 167, 214, 170} ,{124, 167, 211, 170} ,{30, 168, 8, 173} ,{30, 168, 9, 173} ,{212, 167, 211, 170} ,{124, 167, 212, 170} ,{30, 168, 10, 173} ,{30, 168, 11, 173} ,{212, 167, 212, 170} ,{12, 173, 39, 1} ,{171, 168, 8, 173} ,{30, 168, 164, 175} ,{29, 168, 166, 175} ,{171, 168, 9, 173} ,{107, 181, 165, 171} ,{108, 181, 164, 171} ,{23, 173, 39, 1} ,{12, 173, 20, 3} ,{171, 168, 10, 173} ,{30, 168, 165, 175} ,{29, 168, 167, 175} ,{171, 168, 11, 173} ,{109, 181, 165, 171} ,{110, 181, 164, 171} ,{23, 173, 20, 3} ,{124, 167, 32, 173} ,{13, 173, 84, 170} ,{14, 173, 84, 170} ,{29, 168, 16, 173} ,{29, 168, 18, 173} ,{21, 173, 164, 171} ,{22, 173, 164, 171} ,{212, 167, 32, 173} ,{124, 167, 33, 173} ,{13, 173, 85, 170} ,{14, 173, 85, 170} ,{30, 168, 16, 173} ,{30, 168, 18, 173} ,{21, 173, 165, 171} ,{22, 173, 165, 171} ,{212, 167, 33, 173} ,{12, 173, 55, 3} ,{13, 173, 162, 175} ,{14, 173, 162, 175} ,{171, 168, 16, 173} ,{112, 181, 163, 175} ,{114, 181, 163, 175} ,{171, 168, 18, 173} ,{115, 181, 164, 175} ,{116, 181, 165, 175} ,{117, 181, 166, 175} ,{118, 181, 167, 175} ,{120, 181, 168, 175} ,{122, 181, 168, 175} ,{21, 173, 169, 175} ,{22, 173, 169, 175} ,{23, 173, 55, 3} ,{124, 167, 170, 175} ,{212, 167, 170, 175} ,{124, 167, 171, 175} ,{212, 167, 171, 175} ,{205, 168, 55, 3} ,{205, 168, 33, 12} ,{29, 168, 25, 173} ,{29, 168, 27, 173} ,{205, 168, 213, 170} ,{29, 168, 29, 173} ,{29, 168, 31, 173} ,{205, 168, 214, 170} ,{30, 168, 25, 173} ,{30, 168, 27, 173} ,{205, 168, 211, 170} ,{30, 168, 29, 173} ,{30, 168, 31, 173} ,{205, 168, 212, 170} ,{171, 168, 25, 173} ,{171, 168, 27, 173} ,{38, 173, 39, 1} ,{171, 168, 29, 173} ,{171, 168, 31, 173} ,{38, 173, 20, 3} ,{29, 168, 35, 173} ,{29, 168, 37, 173} ,{205, 168, 32, 173} ,{30, 168, 35, 173} ,{30, 168, 37, 173} ,{205, 168, 33, 173} ,{171, 168, 35, 173} ,{171, 168, 37, 173} ,{38, 173, 55, 3} ,{166, 171, 213, 170} ,{166, 171, 214, 170} ,{166, 171, 212, 170} ,{166, 171, 211, 170} ,{123, 181, 103, 173} ,{124, 181, 178, 175} ,{39, 173, 60, 10} ,{124, 167, 20, 3} ,{124, 167, 53, 10} ,{124, 167, 39, 1} ,{124, 167, 160, 11} ,{212, 167, 20, 3} ,{212, 167, 53, 10} ,{212, 167, 39, 1} ,{212, 167, 160, 11} ,{126, 181, 39, 1} ,{128, 181, 160, 11} ,{130, 181, 39, 1} ,{132, 181, 160, 11} ,{43, 173, 243, 11} ,{77, 1, 168, 171} ,{77, 1, 177, 175} ,{77, 1, 175, 175} ,{44, 173, 243, 11} ,{77, 1, 174, 175} ,{77, 1, 173, 175} ,{77, 1, 172, 175} ,{19, 0, 243, 11} ,{11, 0, 172, 175} ,{11, 0, 173, 175} ,{11, 0, 174, 175} ,{212, 168, 243, 11} ,{11, 0, 175, 175} ,{11, 0, 177, 175} ,{11, 0, 168, 171} ,{178, 168, 243, 11} ,{67, 5, 44, 12} ,{62, 10, 44, 12} ,{45, 12, 44, 12} ,{78, 2, 168, 171} ,{13, 0, 168, 171} ,{46, 12, 103, 173} ,{46, 12, 178, 175} ,{180, 175, 20, 3} ,{40, 173, 183, 175} ,{169, 171, 170, 171} ,{179, 175, 181, 175} ,{179, 175, 170, 171} ,{180, 175, 39, 1} ,{182, 175, 181, 175} ,{133, 181, 183, 175} ,{50, 10, 107, 10} ,{205, 10, 107, 10} ,{134, 181, 47, 12} ,{136, 181, 118, 69} ,{137, 181, 49, 12} ,{201, 167, 190, 175} ,{138, 181, 186, 175} ,{140, 181, 49, 12} ,{142, 181, 49, 12} ,{143, 181, 186, 175} ,{50, 10, 249, 169} ,{205, 10, 249, 169} ,{50, 10, 52, 12} ,{205, 10, 52, 12} ,{50, 10, 187, 175} ,{205, 10, 187, 175} ,{50, 10, 53, 12} ,{205, 10, 53, 12} ,{188, 175, 114, 10} ,{45, 173, 114, 10} ,{188, 175, 159, 169} ,{45, 173, 159, 169} ,{232, 171, 114, 10} ,{233, 171, 114, 10} ,{232, 171, 159, 169} ,{233, 171, 159, 169} ,{232, 171, 54, 12} ,{233, 171, 54, 12} ,{189, 175, 114, 10} ,{51, 173, 114, 10} ,{189, 175, 159, 169} ,{51, 173, 159, 169} ,{41, 173, 114, 10} ,{42, 173, 114, 10} ,{41, 173, 159, 169} ,{42, 173, 159, 169} ,{41, 173, 54, 12} ,{42, 173, 54, 12} ,{50, 10, 108, 10} ,{205, 10, 108, 10} ,{144, 181, 218, 74} ,{55, 12, 0, 0} ,{95, 11, 0, 0} ,{205, 10, 52, 2} ,{83, 1, 52, 2} ,{213, 167, 190, 175} ,{56, 12, 0, 0} ,{50, 10, 52, 2} ,{213, 167, 247, 169} ,{213, 167, 248, 169} ,{145, 181, 202, 167} ,{146, 181, 202, 167} ,{147, 181, 191, 175} ,{150, 181, 191, 175} ,{212, 168, 155, 69} ,{178, 168, 155, 69} ,{58, 12, 28, 10} ,{58, 12, 151, 69} ,{43, 173, 165, 69} ,{44, 173, 165, 69} ,{89, 168, 172, 171} ,{50, 168, 172, 171} ,{123, 168, 172, 171} ,{207, 168, 172, 171} ,{43, 173, 52, 2} ,{44, 173, 52, 2} ,{50, 10, 203, 69} ,{50, 10, 198, 69} ,{50, 10, 196, 69} ,{50, 10, 197, 69} ,{205, 10, 28, 10} ,{201, 167, 247, 169} ,{201, 167, 248, 169} ,{151, 181, 222, 171} ,{152, 181, 222, 171} ,{154, 181, 77, 0} ,{155, 181, 97, 168} ,{192, 175, 247, 169} ,{192, 175, 248, 169} ,{61, 12, 52, 2} ,{86, 169, 193, 175} ,{86, 169, 194, 175} ,{86, 169, 195, 175} ,{86, 169, 196, 175} ,{100, 170, 193, 175} ,{100, 170, 194, 175} ,{100, 170, 195, 175} ,{100, 170, 196, 175} ,{89, 168, 114, 10} ,{50, 168, 114, 10} ,{207, 168, 114, 10} ,{230, 170, 107, 10} ,{223, 171, 107, 10} ,{230, 170, 249, 169} ,{223, 171, 249, 169} ,{123, 168, 114, 10} ,{50, 10, 205, 175} ,{65, 12, 0, 0} ,{66, 12, 0, 0} ,{67, 12, 0, 0} ,{68, 12, 0, 0} ,{50, 10, 193, 2} ,{205, 10, 193, 2} ,{69, 12, 0, 0} ,{70, 12, 0, 0} ,{71, 12, 0, 0} ,{72, 12, 73, 12} ,{144, 3, 73, 12} ,{74, 12, 0, 0} ,{75, 12, 0, 0} ,{50, 10, 76, 12} ,{205, 10, 76, 12} ,{77, 12, 112, 11} ,{198, 175, 10, 12} ,{198, 175, 68, 0} ,{78, 12, 0, 0} ,{157, 181, 81, 12} ,{82, 12, 83, 12} ,{205, 10, 173, 171} ,{50, 10, 173, 171} ,{85, 12, 0, 0} ,{199, 175, 242, 175} ,{50, 10, 200, 175} ,{50, 10, 201, 175} ,{205, 10, 200, 175} ,{158, 181, 88, 170} ,{205, 10, 201, 175} ,{159, 181, 88, 170} ,{160, 181, 90, 12} ,{91, 12, 6, 0} ,{92, 12, 6, 0} ,{93, 12, 6, 0} ,{94, 12, 0, 0} ,{95, 12, 0, 0} ,{96, 12, 60, 10} ,{234, 7, 105, 1} ,{202, 175, 97, 12} ,{202, 175, 98, 12} ,{161, 181, 99, 12} ,{168, 2, 82, 1} ,{100, 12, 101, 12} ,{215, 175, 103, 12} ,{104, 12, 82, 1} ,{24, 1, 105, 12} ,{160, 169, 107, 12} ,{160, 169, 108, 12} ,{160, 169, 109, 12} ,{160, 169, 110, 12} ,{160, 169, 111, 12} ,{160, 169, 112, 12} ,{160, 169, 113, 12} ,{160, 169, 114, 12} ,{162, 181, 116, 12} ,{163, 181, 118, 12} ,{205, 10, 203, 175} ,{50, 10, 203, 175} ,{205, 10, 205, 175} ,{120, 12, 206, 175} ,{122, 12, 206, 175} ,{123, 12, 0, 0} ,{124, 12, 6, 0} ,{114, 12, 0, 0} ,{125, 12, 6, 0} ,{126, 12, 0, 0} ,{127, 12, 0, 0} ,{128, 12, 0, 0} ,{129, 12, 0, 0} ,{130, 12, 0, 0} ,{131, 12, 0, 0} ,{132, 12, 0, 0} ,{133, 12, 0, 0} ,{134, 12, 0, 0} ,{135, 12, 0, 0} ,{136, 12, 0, 0} ,{137, 12, 0, 0} ,{138, 12, 0, 0} ,{139, 12, 0, 0} ,{140, 12, 0, 0} ,{141, 12, 0, 0} ,{142, 12, 0, 0} ,{89, 170, 144, 12} ,{89, 170, 145, 12} ,{89, 170, 146, 12} ,{89, 170, 147, 12} ,{89, 170, 148, 12} ,{89, 170, 149, 12} ,{90, 170, 144, 12} ,{90, 170, 145, 12} ,{90, 170, 146, 12} ,{90, 170, 147, 12} ,{90, 170, 148, 12} ,{90, 170, 149, 12} ,{50, 10, 207, 175} ,{205, 10, 208, 175} ,{47, 173, 151, 12} ,{50, 10, 209, 175} ,{205, 10, 207, 175} ,{50, 10, 208, 175} ,{237, 175, 151, 12} ,{205, 10, 209, 175} ,{82, 12, 153, 12} ,{41, 12, 154, 12} ,{40, 12, 154, 12} ,{164, 181, 156, 12} ,{165, 181, 156, 12} ,{166, 181, 6, 0} ,{167, 181, 6, 0} ,{168, 181, 6, 0} ,{187, 10, 210, 175} ,{188, 10, 210, 175} ,{211, 175, 82, 1} ,{169, 181, 165, 12} ,{170, 181, 165, 12} ,{171, 181, 165, 12} ,{172, 181, 165, 12} ,{173, 181, 165, 12} ,{174, 181, 165, 12} ,{175, 181, 165, 12} ,{176, 181, 173, 12} ,{50, 10, 62, 70} ,{212, 175, 82, 1} ,{176, 12, 72, 70} ,{177, 181, 6, 0} ,{178, 12, 82, 1} ,{91, 170, 118, 5} ,{91, 170, 119, 5} ,{91, 170, 120, 5} ,{91, 170, 121, 5} ,{91, 170, 122, 5} ,{91, 170, 128, 5} ,{178, 181, 39, 1} ,{100, 170, 203, 170} ,{180, 181, 39, 1} ,{182, 181, 189, 2} ,{246, 173, 105, 12} ,{246, 173, 182, 12} ,{214, 175, 105, 12} ,{213, 175, 182, 12} ,{213, 175, 105, 12} ,{214, 175, 182, 12} ,{205, 10, 186, 12} ,{50, 10, 186, 12} ,{215, 175, 187, 12} ,{188, 12, 0, 0} ,{189, 12, 190, 12} ,{216, 175, 192, 12} ,{193, 12, 0, 0} ,{194, 12, 0, 0} ,{195, 12, 0, 0} ,{196, 12, 0, 0} ,{216, 175, 197, 12} ,{198, 12, 82, 1} ,{183, 181, 201, 12} ,{202, 12, 210, 69} ,{218, 175, 39, 1} ,{218, 175, 20, 3} ,{205, 12, 6, 0} ,{184, 181, 6, 0} ,{207, 12, 12, 70} ,{207, 12, 14, 70} ,{186, 181, 14, 70} ,{219, 175, 12, 70} ,{46, 173, 6, 0} ,{187, 181, 113, 70} ,{81, 0, 114, 70} ,{17, 3, 114, 70} ,{62, 10, 151, 69} ,{62, 10, 155, 69} ,{188, 181, 151, 69} ,{209, 12, 82, 1} ,{210, 12, 82, 1} ,{189, 181, 82, 1} ,{213, 12, 0, 0} ,{214, 12, 215, 12} ,{216, 12, 0, 0} ,{217, 12, 0, 0} ,{218, 12, 0, 0} ,{219, 12, 0, 0} ,{220, 12, 0, 0} ,{221, 12, 0, 0} ,{190, 181, 223, 12} ,{224, 12, 0, 0} ,{225, 12, 0, 0} ,{226, 12, 0, 0} ,{227, 12, 0, 0} ,{228, 12, 229, 12} ,{230, 12, 0, 0} ,{47, 11, 109, 11} ,{220, 175, 144, 5} ,{220, 175, 144, 12} ,{221, 175, 144, 5} ,{221, 175, 144, 12} ,{191, 181, 234, 12} ,{192, 181, 65, 12} ,{236, 12, 0, 0} ,{50, 10, 67, 12} ,{194, 181, 236, 12} ,{177, 0, 226, 69} ,{177, 0, 227, 69} ,{195, 181, 107, 10} ,{239, 12, 240, 12} ,{241, 12, 242, 12} ,{187, 12, 0, 0} ,{243, 12, 244, 12} ,{197, 181, 60, 10} ,{46, 11, 152, 70} ,{246, 12, 0, 0} ,{133, 4, 247, 12} ,{198, 181, 50, 173} ,{50, 10, 222, 175} ,{205, 10, 222, 175} ,{50, 10, 224, 175} ,{205, 10, 224, 175} ,{199, 181, 6, 0} ,{235, 3, 137, 69} ,{200, 181, 247, 12} ,{47, 11, 78, 12} ,{203, 181, 108, 69} ,{50, 10, 2, 13} ,{227, 175, 118, 5} ,{227, 175, 119, 5} ,{205, 181, 228, 175} ,{207, 181, 5, 13} ,{6, 13, 7, 13} ,{8, 13, 0, 0} ,{9, 13, 0, 0} ,{10, 13, 11, 13} ,{208, 181, 13, 13} ,{209, 181, 14, 13} ,{210, 181, 16, 13} ,{113, 12, 0, 0} ,{211, 181, 210, 11} ,{17, 13, 0, 0} ,{212, 181, 19, 13} ,{20, 13, 0, 0} ,{21, 13, 0, 0} ,{213, 181, 47, 12} ,{22, 13, 0, 0} ,{23, 13, 24, 13} ,{214, 181, 229, 12} ,{26, 13, 0, 0} ,{215, 181, 82, 1} ,{216, 181, 82, 1} ,{30, 13, 31, 13} ,{32, 13, 94, 169} ,{220, 181, 33, 13} ,{78, 2, 229, 175} ,{50, 10, 35, 13} ,{77, 1, 229, 175} ,{205, 10, 35, 13} ,{221, 181, 6, 0} ,{37, 13, 38, 13} ,{39, 13, 0, 0} ,{40, 13, 0, 0} ,{41, 13, 42, 13} ,{43, 13, 42, 13} ,{123, 168, 44, 13} ,{44, 13, 0, 0} ,{50, 168, 44, 13} ,{205, 10, 45, 13} ,{50, 10, 45, 13} ,{147, 11, 3, 0} ,{235, 3, 213, 70} ,{140, 0, 68, 0} ,{235, 3, 215, 70} ,{77, 12, 68, 0} ,{235, 3, 217, 70} ,{202, 12, 230, 175} ,{235, 3, 230, 175} ,{92, 170, 60, 10} ,{235, 3, 221, 70} ,{42, 0, 60, 10} ,{141, 168, 223, 70} ,{202, 12, 223, 70} ,{47, 13, 60, 10} ,{222, 181, 48, 13} ,{213, 2, 252, 70} ,{213, 2, 10, 71} ,{235, 3, 229, 70} ,{223, 181, 84, 169} ,{50, 10, 231, 175} ,{205, 10, 231, 175} ,{224, 3, 105, 70} ,{46, 11, 210, 69} ,{92, 170, 209, 69} ,{224, 181, 210, 69} ,{202, 12, 209, 69} ,{235, 3, 238, 70} ,{53, 13, 193, 2} ,{141, 168, 193, 2} ,{235, 3, 14, 0} ,{92, 170, 14, 0} ,{20, 12, 84, 169} ,{204, 170, 209, 69} ,{204, 170, 240, 70} ,{182, 10, 233, 175} ,{232, 175, 209, 69} ,{235, 3, 248, 70} ,{23, 12, 233, 175} ,{225, 181, 14, 0} ,{49, 13, 84, 169} ,{92, 170, 252, 70} ,{235, 3, 252, 70} ,{228, 181, 1, 71} ,{50, 10, 56, 13} ,{205, 10, 56, 13} ,{230, 181, 0, 71} ,{232, 181, 193, 2} ,{234, 181, 14, 0} ,{57, 13, 0, 0} ,{235, 181, 57, 13} ,{236, 181, 57, 13} ,{61, 13, 0, 0} ,{235, 3, 61, 13} ,{51, 13, 84, 169} ,{235, 175, 14, 0} ,{235, 3, 11, 71} ,{141, 168, 52, 2} ,{123, 168, 236, 175} ,{50, 168, 236, 175} ,{123, 168, 174, 171} ,{50, 168, 174, 171} ,{238, 181, 68, 0} ,{239, 181, 82, 1} ,{67, 5, 213, 168} ,{62, 10, 213, 168} ,{235, 3, 213, 168} ,{238, 175, 239, 175} ,{238, 175, 175, 171} ,{240, 175, 239, 175} ,{240, 175, 175, 171} ,{242, 181, 64, 13} ,{241, 175, 162, 169} ,{244, 181, 162, 169} ,{179, 171, 67, 13} ,{245, 181, 54, 173} ,{86, 12, 67, 13} ,{38, 9, 242, 175} ,{62, 10, 243, 175} ,{62, 10, 245, 175} ,{244, 175, 243, 175} ,{244, 175, 245, 175} ,{246, 181, 176, 171} ,{247, 181, 176, 171} ,{247, 175, 246, 175} ,{248, 175, 246, 175} ,{247, 175, 176, 171} ,{248, 175, 176, 171} ,{248, 181, 249, 175} ,{249, 181, 249, 175} ,{250, 181, 64, 13} ,{251, 181, 64, 13} ,{85, 169, 244, 37} ,{85, 169, 245, 37} ,{85, 169, 246, 37} ,{85, 169, 247, 37} ,{85, 169, 248, 37} ,{85, 169, 249, 37} ,{85, 169, 250, 37} ,{85, 169, 251, 37} ,{85, 169, 252, 37} ,{253, 167, 53, 68} ,{7, 169, 244, 37} ,{7, 169, 245, 37} ,{7, 169, 246, 37} ,{7, 169, 247, 37} ,{7, 169, 248, 37} ,{7, 169, 249, 37} ,{7, 169, 250, 37} ,{7, 169, 251, 37} ,{7, 169, 252, 37} ,{7, 169, 192, 168} ,{8, 169, 244, 37} ,{8, 169, 245, 37} ,{8, 169, 246, 37} ,{8, 169, 247, 37} ,{8, 169, 248, 37} ,{8, 169, 249, 37} ,{8, 169, 250, 37} ,{8, 169, 251, 37} ,{8, 169, 252, 37} ,{8, 169, 192, 168} ,{252, 181, 207, 170} ,{235, 3, 169, 65} ,{235, 3, 163, 65} ,{235, 3, 168, 65} ,{253, 181, 163, 65} ,{255, 181, 163, 65} ,{73, 13, 207, 170} ,{235, 3, 84, 71} ,{204, 10, 84, 71} ,{235, 3, 86, 71} ,{50, 10, 163, 65} ,{0, 182, 251, 175} ,{1, 182, 251, 175} ,{50, 10, 55, 173} ,{2, 182, 253, 175} ,{3, 182, 253, 175} ,{247, 0, 88, 71} ,{5, 182, 88, 71} ,{118, 0, 254, 175} ,{98, 0, 254, 175} ,{79, 13, 255, 175} ,{81, 13, 255, 175} ,{235, 3, 0, 176} ,{235, 3, 1, 176} ,{82, 13, 0, 176} ,{82, 13, 1, 176} ,{6, 182, 56, 173} ,{7, 182, 163, 65} ,{96, 170, 169, 65} ,{96, 170, 163, 65} ,{96, 170, 168, 65} ,{57, 173, 169, 65} ,{57, 173, 163, 65} ,{57, 173, 168, 65} ,{8, 182, 163, 65} ,{10, 182, 163, 65} ,{2, 176, 163, 65} ,{235, 3, 114, 71} ,{11, 182, 163, 65} ,{12, 182, 237, 10} ,{16, 182, 114, 10} ,{90, 13, 0, 0} ,{175, 0, 74, 11} ,{175, 0, 75, 11} ,{11, 0, 5, 176} ,{13, 0, 5, 176} ,{67, 2, 221, 170} ,{17, 182, 74, 11} ,{18, 182, 21, 0} ,{11, 168, 221, 171} ,{170, 0, 95, 13} ,{20, 182, 115, 0} ,{214, 0, 97, 168} ,{147, 176, 199, 10} ,{123, 168, 6, 176} ,{89, 168, 6, 176} ,{11, 0, 58, 173} ,{13, 0, 58, 173} ,{19, 0, 58, 173} ,{61, 12, 182, 66} ,{61, 12, 181, 66} ,{21, 182, 52, 11} ,{7, 176, 18, 1} ,{11, 0, 61, 11} ,{59, 173, 18, 1} ,{170, 0, 180, 66} ,{245, 169, 150, 176} ,{23, 182, 101, 13} ,{61, 173, 108, 10} ,{8, 176, 9, 176} ,{8, 176, 10, 176} ,{86, 169, 9, 176} ,{86, 169, 10, 176} ,{11, 176, 103, 168} ,{12, 176, 103, 168} ,{62, 173, 81, 168} ,{63, 173, 81, 168} ,{62, 173, 134, 170} ,{63, 173, 134, 170} ,{11, 176, 129, 168} ,{12, 176, 129, 168} ,{62, 173, 13, 176} ,{63, 173, 13, 176} ,{65, 1, 229, 171} ,{73, 3, 229, 171} ,{104, 10, 14, 176} ,{105, 10, 14, 176} ,{15, 176, 166, 66} ,{170, 0, 161, 65} ,{170, 0, 163, 65} ,{170, 0, 165, 65} ,{93, 173, 117, 168} ,{64, 173, 117, 168} ,{170, 0, 229, 65} ,{170, 0, 181, 65} ,{170, 0, 183, 65} ,{93, 173, 181, 171} ,{64, 173, 181, 171} ,{64, 173, 224, 171} ,{156, 166, 106, 13} ,{158, 166, 118, 5} ,{158, 166, 119, 5} ,{158, 166, 108, 13} ,{158, 166, 120, 5} ,{158, 166, 109, 13} ,{158, 166, 110, 13} ,{158, 166, 111, 13} ,{158, 166, 121, 5} ,{158, 166, 112, 13} ,{158, 166, 113, 13} ,{158, 166, 114, 13} ,{158, 166, 115, 13} ,{158, 166, 116, 13} ,{158, 166, 117, 13} ,{158, 166, 118, 13} ,{158, 166, 122, 5} ,{158, 166, 119, 13} ,{158, 166, 120, 13} ,{158, 166, 121, 13} ,{158, 166, 122, 13} ,{158, 166, 123, 13} ,{158, 166, 124, 13} ,{158, 166, 125, 13} ,{158, 166, 126, 13} ,{158, 166, 127, 13} ,{158, 166, 128, 13} ,{158, 166, 129, 13} ,{158, 166, 130, 13} ,{158, 166, 131, 13} ,{158, 166, 132, 13} ,{158, 166, 133, 13} ,{158, 166, 128, 5} ,{158, 166, 134, 13} ,{158, 166, 135, 13} ,{158, 166, 136, 13} ,{158, 166, 137, 13} ,{158, 166, 138, 13} ,{158, 166, 139, 13} ,{158, 166, 140, 13} ,{158, 166, 141, 13} ,{158, 166, 142, 13} ,{158, 166, 143, 13} ,{158, 166, 144, 13} ,{158, 166, 145, 13} ,{158, 166, 146, 13} ,{158, 166, 147, 13} ,{158, 166, 148, 13} ,{158, 166, 149, 13} ,{158, 166, 150, 13} ,{158, 166, 151, 13} ,{158, 166, 152, 13} ,{158, 166, 153, 13} ,{158, 166, 154, 13} ,{158, 166, 155, 13} ,{158, 166, 156, 13} ,{158, 166, 157, 13} ,{158, 166, 158, 13} ,{158, 166, 159, 13} ,{158, 166, 160, 13} ,{158, 166, 161, 13} ,{158, 166, 162, 13} ,{158, 166, 163, 13} ,{158, 166, 164, 13} ,{158, 166, 194, 11} ,{158, 166, 165, 13} ,{158, 166, 166, 13} ,{158, 166, 167, 13} ,{158, 166, 168, 13} ,{158, 166, 169, 13} ,{158, 166, 170, 13} ,{158, 166, 171, 13} ,{158, 166, 172, 13} ,{158, 166, 173, 13} ,{158, 166, 174, 13} ,{158, 166, 175, 13} ,{158, 166, 176, 13} ,{158, 166, 177, 13} ,{158, 166, 178, 13} ,{158, 166, 179, 13} ,{158, 166, 180, 13} ,{158, 166, 181, 13} ,{158, 166, 182, 13} ,{158, 166, 183, 13} ,{158, 166, 184, 13} ,{158, 166, 185, 13} ,{158, 166, 186, 13} ,{158, 166, 187, 13} ,{158, 166, 188, 13} ,{158, 166, 189, 13} ,{158, 166, 190, 13} ,{158, 166, 191, 13} ,{158, 166, 192, 13} ,{158, 166, 193, 13} ,{158, 166, 194, 13} ,{158, 166, 195, 13} ,{158, 166, 196, 13} ,{158, 166, 197, 13} ,{158, 166, 198, 13} ,{158, 166, 199, 13} ,{158, 166, 200, 13} ,{158, 166, 201, 13} ,{158, 166, 202, 13} ,{158, 166, 203, 13} ,{158, 166, 204, 13} ,{158, 166, 205, 13} ,{158, 166, 206, 13} ,{158, 166, 207, 13} ,{158, 166, 208, 13} ,{158, 166, 209, 13} ,{158, 166, 210, 13} ,{158, 166, 211, 13} ,{158, 166, 212, 13} ,{158, 166, 213, 13} ,{158, 166, 214, 13} ,{158, 166, 215, 13} ,{158, 166, 216, 13} ,{158, 166, 217, 13} ,{158, 166, 218, 13} ,{158, 166, 219, 13} ,{158, 166, 220, 13} ,{158, 166, 221, 13} ,{158, 166, 222, 13} ,{158, 166, 223, 13} ,{158, 166, 224, 13} ,{158, 166, 225, 13} ,{158, 166, 226, 13} ,{158, 166, 227, 13} ,{158, 166, 228, 13} ,{158, 166, 229, 13} ,{158, 166, 230, 13} ,{158, 166, 231, 13} ,{158, 166, 232, 13} ,{158, 166, 233, 13} ,{158, 166, 234, 13} ,{158, 166, 235, 13} ,{158, 166, 236, 13} ,{158, 166, 237, 13} ,{158, 166, 238, 13} ,{158, 166, 239, 13} ,{158, 166, 240, 13} ,{158, 166, 241, 13} ,{158, 166, 242, 13} ,{158, 166, 243, 13} ,{158, 166, 244, 13} ,{158, 166, 245, 13} ,{158, 166, 246, 13} ,{158, 166, 247, 13} ,{158, 166, 248, 13} ,{158, 166, 249, 13} ,{158, 166, 250, 13} ,{158, 166, 251, 13} ,{158, 166, 252, 13} ,{158, 166, 253, 13} ,{158, 166, 254, 13} ,{158, 166, 255, 13} ,{158, 166, 0, 14} ,{158, 166, 1, 14} ,{158, 166, 2, 14} ,{158, 166, 3, 14} ,{158, 166, 4, 14} ,{158, 166, 5, 14} ,{158, 166, 6, 14} ,{158, 166, 7, 14} ,{158, 166, 8, 14} ,{158, 166, 9, 14} ,{158, 166, 10, 14} ,{158, 166, 11, 14} ,{158, 166, 12, 14} ,{158, 166, 13, 14} ,{158, 166, 14, 14} ,{158, 166, 15, 14} ,{158, 166, 16, 14} ,{158, 166, 17, 14} ,{158, 166, 18, 14} ,{158, 166, 19, 14} ,{158, 166, 20, 14} ,{158, 166, 21, 14} ,{158, 166, 22, 14} ,{158, 166, 23, 14} ,{158, 166, 24, 14} ,{158, 166, 25, 14} ,{158, 166, 26, 14} ,{158, 166, 27, 14} ,{158, 166, 28, 14} ,{158, 166, 29, 14} ,{158, 166, 30, 14} ,{158, 166, 31, 14} ,{158, 166, 32, 14} ,{158, 166, 33, 14} ,{158, 166, 34, 14} ,{158, 166, 35, 14} ,{158, 166, 36, 14} ,{158, 166, 37, 14} ,{158, 166, 38, 14} ,{158, 166, 39, 14} ,{158, 166, 40, 14} ,{158, 166, 41, 14} ,{158, 166, 42, 14} ,{158, 166, 43, 14} ,{158, 166, 44, 14} ,{158, 166, 45, 14} ,{158, 166, 46, 14} ,{158, 166, 47, 14} ,{158, 166, 48, 14} ,{158, 166, 49, 14} ,{158, 166, 50, 14} ,{158, 166, 51, 14} ,{158, 166, 52, 14} ,{158, 166, 53, 14} ,{158, 166, 54, 14} ,{158, 166, 55, 14} ,{158, 166, 56, 14} ,{158, 166, 57, 14} ,{158, 166, 58, 14} ,{158, 166, 59, 14} ,{158, 166, 60, 14} ,{158, 166, 61, 14} ,{158, 166, 62, 14} ,{158, 166, 63, 14} ,{158, 166, 64, 14} ,{158, 166, 65, 14} ,{158, 166, 66, 14} ,{158, 166, 67, 14} ,{158, 166, 68, 14} ,{158, 166, 69, 14} ,{158, 166, 70, 14} ,{158, 166, 71, 14} ,{158, 166, 72, 14} ,{158, 166, 73, 14} ,{158, 166, 74, 14} ,{158, 166, 75, 14} ,{158, 166, 76, 14} ,{158, 166, 77, 14} ,{158, 166, 78, 14} ,{158, 166, 79, 14} ,{158, 166, 80, 14} ,{158, 166, 81, 14} ,{158, 166, 82, 14} ,{158, 166, 83, 14} ,{158, 166, 84, 14} ,{158, 166, 85, 14} ,{158, 166, 86, 14} ,{158, 166, 87, 14} ,{158, 166, 88, 14} ,{158, 166, 89, 14} ,{158, 166, 90, 14} ,{158, 166, 91, 14} ,{158, 166, 92, 14} ,{158, 166, 93, 14} ,{158, 166, 94, 14} ,{158, 166, 95, 14} ,{158, 166, 96, 14} ,{158, 166, 97, 14} ,{158, 166, 98, 14} ,{158, 166, 99, 14} ,{209, 170, 156, 167} ,{209, 170, 226, 170} ,{51, 10, 65, 173} ,{72, 1, 65, 173} ,{71, 168, 65, 173} ,{17, 176, 91, 169} ,{51, 10, 181, 171} ,{72, 1, 181, 171} ,{208, 170, 146, 168} ,{182, 171, 146, 168} ,{65, 1, 183, 171} ,{73, 3, 183, 171} ,{51, 10, 16, 176} ,{72, 1, 16, 176} ,{51, 10, 225, 171} ,{72, 1, 225, 171} ,{17, 176, 225, 171} ,{147, 168, 166, 176} ,{65, 1, 18, 176} ,{73, 3, 18, 176} ,{147, 168, 226, 171} ,{147, 168, 227, 171} ,{209, 170, 201, 0} ,{209, 170, 226, 171} ,{209, 170, 227, 171} ,{51, 10, 184, 171} ,{72, 1, 184, 171} ,{51, 10, 19, 176} ,{72, 1, 19, 176} ,{72, 168, 185, 171} ,{51, 168, 185, 171} ,{72, 168, 21, 176} ,{51, 168, 21, 176} ,{24, 182, 169, 65} ,{25, 182, 170, 65} ,{174, 168, 186, 171} ,{173, 169, 186, 171} ,{246, 169, 186, 171} ,{174, 169, 186, 171} ,{26, 182, 168, 65} ,{27, 182, 169, 65} ,{28, 182, 170, 65} ,{29, 182, 167, 65} ,{30, 182, 245, 3} ,{31, 182, 245, 3} ,{246, 169, 25, 176} ,{24, 176, 169, 65} ,{22, 176, 168, 65} ,{23, 176, 169, 65} ,{24, 176, 167, 65} ,{174, 168, 25, 176} ,{168, 176, 39, 1} ,{27, 176, 199, 10} ,{27, 176, 199, 2} ,{29, 176, 195, 10} ,{29, 176, 196, 10} ,{33, 182, 34, 1} ,{34, 182, 66, 173} ,{31, 7, 66, 173} ,{30, 7, 66, 173} ,{36, 182, 18, 0} ,{38, 182, 33, 7} ,{40, 182, 34, 1} ,{42, 182, 34, 1} ,{104, 10, 31, 176} ,{105, 10, 31, 176} ,{43, 182, 161, 65} ,{44, 182, 163, 65} ,{45, 182, 161, 65} ,{147, 168, 32, 176} ,{148, 168, 32, 176} ,{95, 173, 68, 0} ,{46, 182, 145, 170} ,{48, 182, 145, 170} ,{35, 176, 42, 176} ,{41, 176, 36, 176} ,{38, 176, 45, 176} ,{44, 176, 39, 176} ,{35, 176, 36, 176} ,{38, 176, 39, 176} ,{41, 176, 42, 176} ,{44, 176, 45, 176} ,{90, 168, 46, 176} ,{91, 168, 46, 176} ,{10, 169, 47, 176} ,{9, 169, 47, 176} ,{195, 171, 142, 168} ,{196, 171, 142, 168} ,{198, 171, 142, 168} ,{199, 171, 142, 168} ,{90, 168, 48, 176} ,{91, 168, 48, 176} ,{10, 169, 49, 176} ,{9, 169, 49, 176} ,{195, 171, 242, 167} ,{196, 171, 242, 167} ,{198, 171, 242, 167} ,{199, 171, 242, 167} ,{68, 173, 51, 176} ,{53, 176, 56, 176} ,{69, 173, 50, 176} ,{55, 176, 54, 176} ,{49, 182, 53, 10} ,{50, 182, 50, 176} ,{51, 182, 53, 10} ,{52, 182, 51, 176} ,{68, 173, 197, 171} ,{195, 171, 52, 176} ,{69, 173, 197, 171} ,{196, 171, 52, 176} ,{53, 176, 54, 176} ,{55, 176, 56, 176} ,{54, 182, 110, 14} ,{228, 171, 163, 65} ,{230, 171, 163, 65} ,{229, 170, 77, 66} ,{112, 170, 77, 66} ,{112, 170, 89, 66} ,{87, 169, 161, 65} ,{94, 173, 255, 167} ,{88, 169, 163, 65} ,{87, 173, 163, 65} ,{94, 173, 74, 11} ,{88, 173, 161, 65} ,{11, 0, 200, 171} ,{13, 0, 200, 171} ,{14, 1, 200, 171} ,{15, 1, 200, 171} ,{224, 170, 92, 13} ,{145, 168, 113, 14} ,{55, 182, 33, 0} ,{223, 168, 133, 168} ,{224, 168, 133, 168} ,{223, 168, 12, 0} ,{224, 168, 12, 0} ,{58, 176, 57, 176} ,{59, 176, 57, 176} ,{58, 176, 60, 176} ,{59, 176, 60, 176} ,{239, 169, 13, 169} ,{240, 169, 13, 169} ,{61, 176, 64, 176} ,{63, 176, 62, 176} ,{61, 176, 62, 176} ,{63, 176, 64, 176} ,{56, 182, 65, 176} ,{231, 170, 65, 176} ,{66, 176, 69, 176} ,{68, 176, 67, 176} ,{57, 182, 67, 176} ,{58, 182, 69, 176} ,{11, 0, 70, 176} ,{13, 0, 70, 176} ,{83, 1, 116, 14} ,{59, 182, 77, 0} ,{238, 10, 71, 176} ,{61, 182, 107, 10} ,{62, 182, 97, 168} ,{63, 182, 93, 13} ,{111, 0, 237, 10} ,{239, 10, 71, 176} ,{239, 10, 72, 176} ,{177, 0, 237, 10} ,{179, 0, 237, 10} ,{143, 168, 83, 11} ,{179, 0, 85, 73} ,{63, 3, 72, 176} ,{64, 182, 160, 11} ,{168, 169, 211, 170} ,{168, 169, 212, 170} ,{168, 169, 213, 170} ,{168, 169, 214, 170} ,{74, 176, 53, 10} ,{75, 176, 53, 10} ,{74, 176, 160, 11} ,{75, 176, 160, 11} ,{179, 0, 22, 66} ,{204, 171, 12, 169} ,{204, 171, 95, 176} ,{65, 182, 241, 169} ,{66, 182, 241, 169} ,{213, 167, 101, 64} ,{46, 11, 213, 168} ,{46, 11, 120, 14} ,{46, 11, 31, 38} ,{46, 11, 90, 13} ,{71, 182, 213, 168} ,{72, 182, 68, 0} ,{74, 182, 153, 38} ,{75, 182, 52, 2} ,{46, 11, 178, 69} ,{46, 11, 28, 10} ,{46, 11, 255, 167} ,{46, 11, 32, 168} ,{77, 182, 72, 173} ,{79, 182, 72, 173} ,{81, 182, 46, 10} ,{82, 182, 46, 10} ,{47, 11, 14, 0} ,{47, 11, 145, 170} ,{47, 11, 107, 10} ,{83, 182, 125, 14} ,{159, 11, 233, 166} ,{159, 11, 13, 169} ,{166, 0, 98, 176} ,{85, 182, 189, 11} ,{88, 182, 114, 10} ,{89, 182, 213, 168} ,{90, 182, 208, 66} ,{79, 176, 247, 169} ,{79, 176, 248, 169} ,{50, 10, 71, 11} ,{80, 176, 247, 169} ,{80, 176, 248, 169} ,{205, 10, 103, 11} ,{50, 10, 103, 11} ,{11, 0, 205, 171} ,{13, 0, 205, 171} ,{98, 173, 205, 171} ,{99, 173, 205, 171} ,{130, 14, 236, 10} ,{91, 182, 236, 10} ,{92, 182, 81, 176} ,{93, 182, 61, 11} ,{94, 182, 135, 14} ,{136, 14, 137, 14} ,{138, 14, 228, 10} ,{82, 176, 120, 14} ,{95, 182, 79, 173} ,{97, 182, 120, 14} ,{140, 14, 141, 14} ,{142, 14, 0, 0} ,{83, 176, 247, 169} ,{83, 176, 248, 169} ,{98, 182, 13, 172} ,{50, 10, 95, 11} ,{100, 170, 13, 172} ,{74, 173, 13, 172} ,{101, 170, 109, 69} ,{101, 170, 108, 69} ,{101, 170, 147, 69} ,{101, 170, 146, 69} ,{101, 170, 151, 69} ,{101, 170, 155, 69} ,{144, 14, 145, 14} ,{75, 173, 233, 10} ,{51, 1, 12, 169} ,{75, 173, 221, 171} ,{176, 1, 21, 0} ,{176, 1, 31, 38} ,{100, 0, 33, 7} ,{143, 2, 33, 7} ,{144, 168, 84, 176} ,{74, 168, 84, 176} ,{146, 14, 0, 0} ,{147, 14, 0, 0} ,{76, 173, 214, 66} ,{99, 182, 233, 10} ,{76, 173, 88, 176} ,{86, 176, 97, 168} ,{100, 182, 33, 7} ,{101, 182, 233, 10} ,{102, 182, 233, 10} ,{103, 182, 233, 10} ,{104, 182, 233, 10} ,{49, 168, 88, 176} ,{105, 182, 151, 14} ,{106, 182, 247, 10} ,{59, 10, 92, 176} ,{107, 182, 247, 10} ,{108, 182, 141, 0} ,{110, 182, 46, 10} ,{155, 14, 156, 14} ,{104, 10, 157, 14} ,{111, 182, 91, 176} ,{112, 182, 91, 176} ,{115, 182, 161, 14} ,{118, 182, 233, 10} ,{163, 14, 92, 176} ,{206, 171, 186, 65} ,{119, 182, 6, 0} ,{206, 171, 245, 10} ,{206, 171, 246, 10} ,{186, 11, 12, 169} ,{186, 11, 13, 169} ,{98, 13, 0, 0} ,{120, 182, 233, 10} ,{78, 173, 165, 14} ,{78, 173, 166, 14} ,{78, 173, 167, 14} ,{119, 168, 95, 176} ,{122, 182, 132, 0} ,{218, 170, 79, 173} ,{119, 168, 27, 167} ,{218, 170, 169, 169} ,{218, 170, 203, 64} ,{123, 182, 114, 10} ,{80, 173, 207, 171} ,{102, 170, 27, 167} ,{124, 182, 189, 2} ,{80, 173, 113, 176} ,{81, 173, 96, 176} ,{81, 173, 97, 176} ,{126, 182, 228, 10} ,{89, 169, 233, 166} ,{89, 169, 13, 169} ,{129, 182, 170, 14} ,{171, 14, 228, 10} ,{208, 171, 96, 176} ,{208, 171, 97, 176} ,{130, 182, 114, 176} ,{131, 182, 52, 2} ,{46, 11, 153, 38} ,{81, 173, 114, 10} ,{102, 170, 98, 176} ,{208, 171, 114, 10} ,{172, 14, 228, 10} ,{173, 14, 237, 73} ,{132, 182, 165, 14} ,{133, 182, 229, 10} ,{149, 14, 97, 168} ,{209, 171, 35, 66} ,{148, 14, 12, 169} ,{149, 14, 12, 169} ,{103, 176, 56, 66} ,{209, 171, 57, 66} ,{99, 176, 245, 10} ,{100, 176, 246, 10} ,{134, 182, 245, 10} ,{135, 182, 246, 10} ,{136, 182, 246, 10} ,{137, 182, 245, 10} ,{105, 176, 176, 14} ,{138, 182, 176, 14} ,{104, 176, 245, 10} ,{104, 176, 246, 10} ,{140, 182, 228, 73} ,{243, 169, 233, 166} ,{244, 169, 233, 166} ,{100, 0, 56, 66} ,{100, 0, 57, 66} ,{106, 176, 56, 66} ,{106, 176, 57, 66} ,{107, 176, 15, 8} ,{107, 176, 244, 10} ,{141, 182, 56, 66} ,{243, 169, 108, 176} ,{244, 169, 108, 176} ,{243, 169, 109, 176} ,{244, 169, 109, 176} ,{110, 176, 82, 11} ,{243, 169, 13, 169} ,{110, 176, 83, 11} ,{142, 182, 13, 169} ,{111, 176, 82, 11} ,{111, 176, 83, 11} ,{143, 182, 182, 14} ,{144, 182, 182, 14} ,{17, 169, 27, 167} ,{29, 11, 233, 166} ,{112, 176, 228, 170} ,{146, 182, 156, 167} ,{111, 170, 233, 166} ,{147, 182, 113, 176} ,{148, 182, 185, 14} ,{186, 14, 233, 166} ,{149, 182, 14, 0} ,{82, 173, 114, 176} ,{7, 11, 115, 176} ,{228, 171, 238, 37} ,{150, 182, 0, 38} ,{228, 171, 77, 66} ,{151, 182, 79, 11} ,{202, 0, 117, 176} ,{124, 0, 117, 176} ,{154, 182, 118, 176} ,{12, 11, 211, 171} ,{75, 167, 119, 176} ,{70, 167, 119, 176} ,{75, 167, 122, 176} ,{70, 167, 122, 176} ,{75, 167, 123, 176} ,{70, 167, 123, 176} ,{83, 173, 221, 170} ,{84, 173, 221, 170} ,{83, 173, 233, 166} ,{84, 173, 233, 166} ,{155, 182, 39, 1} ,{156, 182, 20, 3} ,{124, 176, 189, 14} ,{125, 176, 189, 14} ,{75, 167, 126, 176} ,{70, 167, 126, 176} ,{75, 167, 128, 176} ,{70, 167, 128, 176} ,{157, 182, 32, 168} ,{158, 182, 255, 167} ,{87, 169, 130, 176} ,{88, 169, 130, 176} ,{159, 182, 32, 168} ,{160, 182, 255, 167} ,{161, 182, 131, 176} ,{162, 182, 131, 176} ,{164, 182, 215, 171} ,{166, 182, 215, 171} ,{106, 170, 255, 167} ,{106, 170, 32, 168} ,{167, 182, 221, 170} ,{168, 182, 221, 170} ,{14, 169, 237, 66} ,{14, 169, 238, 66} ,{14, 169, 70, 74} ,{14, 169, 71, 74} ,{133, 176, 255, 167} ,{133, 176, 32, 168} ,{169, 182, 0, 38} ,{170, 182, 0, 38} ,{85, 173, 255, 167} ,{85, 173, 32, 168} ,{171, 182, 13, 169} ,{172, 182, 255, 167} ,{173, 182, 255, 167} ,{75, 167, 134, 176} ,{70, 167, 134, 176} ,{75, 167, 137, 176} ,{70, 167, 137, 176} ,{194, 14, 130, 4} ,{195, 14, 130, 4} ,{194, 14, 138, 176} ,{195, 14, 138, 176} ,{175, 182, 132, 0} ,{108, 170, 139, 176} ,{109, 170, 139, 176} ,{108, 170, 216, 171} ,{109, 170, 216, 171} ,{108, 170, 0, 38} ,{109, 170, 0, 38} ,{108, 170, 113, 66} ,{109, 170, 113, 66} ,{108, 170, 89, 66} ,{109, 170, 89, 66} ,{108, 170, 90, 66} ,{109, 170, 90, 66} ,{100, 0, 32, 11} ,{100, 0, 33, 11} ,{38, 11, 97, 168} ,{39, 11, 97, 168} ,{38, 11, 140, 176} ,{39, 11, 140, 176} ,{38, 11, 142, 176} ,{39, 11, 142, 176} ,{38, 11, 144, 176} ,{39, 11, 144, 176} ,{217, 171, 0, 38} ,{218, 171, 0, 38} ,{217, 171, 77, 66} ,{218, 171, 77, 66} ,{217, 171, 89, 66} ,{218, 171, 89, 66} ,{217, 171, 113, 66} ,{218, 171, 113, 66} ,{176, 182, 146, 176} ,{177, 182, 146, 176} ,{236, 0, 74, 11} ,{236, 0, 75, 11} ,{178, 182, 241, 167} ,{179, 182, 241, 167} ,{87, 173, 75, 11} ,{88, 173, 74, 11} ,{87, 173, 74, 11} ,{88, 173, 75, 11} ,{180, 182, 74, 11} ,{184, 182, 74, 11} ,{147, 176, 199, 2} ,{186, 182, 188, 11} ,{199, 14, 245, 10} ,{200, 14, 0, 0} ,{201, 14, 0, 0} ,{50, 1, 180, 66} ,{50, 1, 181, 66} ,{50, 1, 182, 66} ,{187, 182, 63, 0} ,{188, 182, 219, 171} ,{220, 171, 92, 173} ,{189, 182, 92, 173} ,{91, 173, 92, 173} ,{195, 182, 33, 12} ,{196, 182, 12, 169} ,{148, 176, 13, 169} ,{197, 182, 144, 74} ,{100, 0, 181, 66} ,{100, 0, 182, 66} ,{149, 176, 78, 38} ,{179, 0, 157, 74} ,{201, 182, 46, 10} ,{172, 169, 150, 176} ,{172, 169, 151, 176} ,{223, 170, 151, 176} ,{242, 10, 221, 171} ,{152, 176, 77, 66} ,{224, 170, 155, 176} ,{224, 170, 221, 171} ,{202, 182, 233, 10} ,{153, 176, 255, 167} ,{153, 176, 32, 168} ,{154, 176, 117, 66} ,{154, 176, 118, 66} ,{203, 182, 155, 176} ,{204, 182, 233, 10} ,{205, 182, 233, 10} ,{205, 10, 213, 168} ,{49, 168, 175, 74} ,{173, 169, 15, 169} ,{174, 168, 15, 169} ,{246, 169, 15, 169} ,{174, 169, 15, 169} ,{71, 168, 15, 169} ,{51, 10, 90, 169} ,{65, 1, 90, 169} ,{73, 3, 90, 169} ,{173, 169, 90, 169} ,{174, 168, 90, 169} ,{246, 169, 90, 169} ,{174, 169, 90, 169} ,{71, 168, 90, 169} ,{225, 170, 90, 169} ,{156, 176, 199, 2} ,{156, 176, 199, 10} ,{157, 176, 199, 2} ,{157, 176, 199, 10} ,{201, 167, 158, 176} ,{201, 167, 159, 176} ,{206, 182, 222, 171} ,{207, 182, 222, 171} ,{175, 169, 247, 169} ,{175, 169, 248, 169} ,{175, 169, 158, 176} ,{175, 169, 159, 176} ,{83, 1, 107, 10} ,{50, 10, 160, 176} ,{205, 10, 160, 176} ,{50, 10, 161, 176} ,{205, 10, 161, 176} ,{50, 10, 207, 14} ,{205, 10, 207, 14} ,{205, 10, 208, 14} ,{50, 10, 208, 14} ,{17, 3, 211, 74} ,{50, 10, 187, 69} ,{223, 171, 108, 10} ,{230, 170, 108, 10} ,{223, 171, 95, 11} ,{230, 170, 95, 11} ,{231, 171, 108, 10} ,{231, 171, 95, 11} ,{172, 176, 95, 11} ,{50, 10, 162, 176} ,{205, 10, 162, 176} ,{50, 10, 163, 176} ,{205, 10, 163, 176} ,{164, 176, 145, 170} ,{208, 182, 201, 10} ,{164, 176, 166, 66} ,{93, 173, 224, 171} ,{227, 170, 156, 167} ,{227, 170, 226, 170} ,{165, 176, 91, 169} ,{165, 176, 225, 171} ,{148, 168, 166, 176} ,{148, 168, 226, 171} ,{148, 168, 227, 171} ,{227, 170, 201, 0} ,{227, 170, 226, 171} ,{227, 170, 227, 171} ,{94, 173, 68, 0} ,{168, 176, 20, 3} ,{228, 171, 161, 65} ,{169, 176, 161, 65} ,{229, 170, 170, 176} ,{95, 173, 32, 168} ,{95, 173, 75, 11} ,{51, 10, 229, 171} ,{72, 1, 229, 171} ,{169, 176, 163, 65} ,{112, 170, 170, 176} ,{230, 171, 161, 65} ,{229, 170, 89, 66} ,{229, 170, 171, 176} ,{112, 170, 171, 176} ,{230, 170, 193, 2} ,{231, 171, 193, 2} ,{172, 176, 193, 2} ,{232, 171, 207, 14} ,{233, 171, 207, 14} ,{235, 3, 187, 69} ,{211, 182, 93, 13} ,{212, 182, 93, 13} ,{235, 3, 52, 2} ,{213, 182, 78, 12} ,{43, 167, 212, 14} ,{43, 167, 213, 14} ,{43, 167, 214, 14} ,{43, 167, 215, 14} ,{43, 167, 216, 14} ,{43, 167, 217, 14} ,{43, 167, 218, 14} ,{43, 167, 219, 14} ,{43, 167, 220, 14} ,{43, 167, 221, 14} ,{43, 167, 175, 176} ,{43, 167, 53, 0} ,{43, 167, 222, 14} ,{43, 167, 223, 14} ,{43, 167, 224, 14} ,{43, 167, 225, 14} ,{43, 167, 226, 14} ,{43, 167, 227, 14} ,{43, 167, 228, 14} ,{43, 167, 229, 14} ,{43, 167, 230, 14} ,{43, 167, 231, 14} ,{43, 167, 232, 14} ,{43, 167, 233, 14} ,{43, 167, 234, 14} ,{43, 167, 235, 14} ,{43, 167, 158, 1} ,{43, 167, 236, 14} ,{43, 167, 194, 6} ,{43, 167, 237, 14} ,{43, 167, 166, 1} ,{43, 167, 169, 1} ,{43, 167, 238, 14} ,{43, 167, 239, 14} ,{43, 167, 176, 176} ,{43, 167, 170, 1} ,{43, 167, 234, 171} ,{43, 167, 178, 176} ,{43, 167, 204, 4} ,{174, 176, 234, 171} ,{43, 167, 20, 169} ,{174, 176, 20, 169} ,{43, 167, 178, 1} ,{43, 167, 179, 1} ,{43, 167, 243, 14} ,{43, 167, 180, 176} ,{43, 167, 181, 176} ,{44, 167, 212, 14} ,{44, 167, 213, 14} ,{44, 167, 214, 14} ,{44, 167, 215, 14} ,{44, 167, 216, 14} ,{44, 167, 217, 14} ,{44, 167, 218, 14} ,{44, 167, 219, 14} ,{44, 167, 220, 14} ,{44, 167, 221, 14} ,{44, 167, 175, 176} ,{44, 167, 53, 0} ,{44, 167, 222, 14} ,{44, 167, 223, 14} ,{44, 167, 224, 14} ,{44, 167, 225, 14} ,{44, 167, 226, 14} ,{44, 167, 227, 14} ,{44, 167, 228, 14} ,{44, 167, 229, 14} ,{44, 167, 230, 14} ,{44, 167, 231, 14} ,{44, 167, 232, 14} ,{44, 167, 233, 14} ,{44, 167, 234, 14} ,{44, 167, 235, 14} ,{44, 167, 158, 1} ,{44, 167, 236, 14} ,{44, 167, 194, 6} ,{44, 167, 237, 14} ,{44, 167, 166, 1} ,{44, 167, 169, 1} ,{44, 167, 238, 14} ,{44, 167, 239, 14} ,{44, 167, 176, 176} ,{44, 167, 170, 1} ,{44, 167, 234, 171} ,{44, 167, 178, 176} ,{44, 167, 204, 4} ,{179, 176, 234, 171} ,{44, 167, 20, 169} ,{179, 176, 20, 169} ,{44, 167, 178, 1} ,{44, 167, 179, 1} ,{44, 167, 243, 14} ,{44, 167, 180, 176} ,{44, 167, 181, 176} ,{124, 168, 182, 176} ,{53, 168, 182, 176} ,{124, 168, 175, 168} ,{254, 169, 28, 167} ,{184, 168, 52, 168} ,{132, 167, 141, 0} ,{95, 168, 98, 169} ,{92, 169, 144, 167} ,{208, 168, 144, 167} ,{28, 169, 144, 167} ,{214, 168, 144, 167} ,{19, 169, 144, 167} ,{121, 168, 144, 167} ,{146, 166, 234, 0} ,{235, 171, 48, 167} ,{123, 170, 45, 0} ,{123, 170, 234, 0} ,{215, 182, 172, 0} ,{250, 169, 48, 167} ,{178, 169, 48, 167} ,{255, 169, 176, 168} ,{146, 166, 183, 176} ,{126, 166, 183, 176} ,{216, 182, 245, 0} ,{167, 167, 158, 11} ,{96, 173, 52, 168} ,{218, 182, 93, 13} ,{184, 176, 49, 0} ,{18, 169, 54, 0} ,{203, 167, 66, 0} ,{209, 168, 237, 171} ,{19, 169, 237, 171} ,{239, 166, 247, 14} ,{240, 166, 247, 14} ,{239, 166, 248, 14} ,{240, 166, 248, 14} ,{239, 166, 182, 0} ,{240, 166, 182, 0} ,{239, 166, 249, 14} ,{240, 166, 249, 14} ,{239, 166, 250, 14} ,{240, 166, 250, 14} ,{239, 166, 251, 14} ,{240, 166, 251, 14} ,{239, 166, 252, 14} ,{240, 166, 252, 14} ,{239, 166, 253, 14} ,{240, 166, 253, 14} ,{239, 166, 254, 14} ,{240, 166, 254, 14} ,{239, 166, 255, 14} ,{240, 166, 255, 14} ,{239, 166, 0, 15} ,{240, 166, 0, 15} ,{239, 166, 1, 15} ,{240, 166, 1, 15} ,{239, 166, 9, 6} ,{240, 166, 9, 6} ,{239, 166, 92, 6} ,{240, 166, 92, 6} ,{239, 166, 177, 1} ,{240, 166, 177, 1} ,{239, 166, 59, 0} ,{240, 166, 59, 0} ,{239, 166, 104, 1} ,{240, 166, 104, 1} ,{239, 166, 46, 5} ,{240, 166, 46, 5} ,{239, 166, 2, 15} ,{240, 166, 2, 15} ,{239, 166, 107, 1} ,{240, 166, 107, 1} ,{239, 166, 127, 8} ,{240, 166, 127, 8} ,{239, 166, 165, 3} ,{240, 166, 165, 3} ,{239, 166, 201, 7} ,{240, 166, 201, 7} ,{239, 166, 109, 1} ,{240, 166, 109, 1} ,{239, 166, 3, 15} ,{240, 166, 3, 15} ,{238, 171, 82, 2} ,{239, 171, 82, 2} ,{210, 168, 164, 2} ,{211, 168, 164, 2} ,{242, 171, 250, 14} ,{243, 171, 250, 14} ,{238, 171, 0, 15} ,{239, 171, 0, 15} ,{238, 171, 92, 6} ,{239, 171, 92, 6} ,{242, 171, 92, 6} ,{243, 171, 92, 6} ,{210, 168, 3, 15} ,{211, 168, 3, 15} ,{239, 166, 75, 1} ,{240, 166, 75, 1} ,{239, 166, 185, 176} ,{240, 166, 185, 176} ,{210, 168, 120, 1} ,{211, 168, 120, 1} ,{210, 168, 191, 0} ,{211, 168, 191, 0} ,{239, 166, 186, 176} ,{240, 166, 186, 176} ,{238, 171, 123, 1} ,{239, 171, 123, 1} ,{210, 168, 123, 1} ,{211, 168, 123, 1} ,{210, 168, 163, 1} ,{211, 168, 163, 1} ,{239, 166, 188, 176} ,{240, 166, 188, 176} ,{210, 168, 7, 15} ,{211, 168, 7, 15} ,{210, 168, 8, 15} ,{211, 168, 8, 15} ,{210, 168, 124, 1} ,{211, 168, 124, 1} ,{210, 168, 9, 15} ,{211, 168, 9, 15} ,{210, 168, 125, 1} ,{211, 168, 125, 1} ,{240, 171, 125, 1} ,{241, 171, 125, 1} ,{240, 171, 171, 7} ,{241, 171, 171, 7} ,{240, 171, 97, 6} ,{241, 171, 97, 6} ,{240, 171, 11, 15} ,{241, 171, 11, 15} ,{251, 169, 108, 4} ,{219, 182, 46, 5} ,{220, 182, 46, 5} ,{251, 169, 13, 15} ,{221, 182, 46, 5} ,{222, 182, 46, 5} ,{223, 182, 2, 15} ,{242, 171, 120, 1} ,{243, 171, 120, 1} ,{242, 171, 124, 1} ,{243, 171, 124, 1} ,{224, 182, 132, 0} ,{189, 176, 19, 15} ,{189, 176, 20, 15} ,{244, 171, 241, 37} ,{225, 182, 2, 38} ,{226, 182, 2, 38} ,{227, 182, 22, 15} ,{119, 1, 177, 173} ,{119, 1, 241, 37} ,{228, 182, 22, 15} ,{82, 167, 137, 5} ,{82, 167, 138, 5} ,{82, 167, 139, 5} ,{82, 167, 140, 5} ,{82, 167, 157, 1} ,{82, 167, 141, 5} ,{82, 167, 157, 3} ,{82, 167, 142, 5} ,{82, 167, 164, 3} ,{82, 167, 208, 4} ,{82, 167, 143, 5} ,{82, 167, 144, 5} ,{82, 167, 145, 5} ,{82, 167, 146, 5} ,{82, 167, 147, 5} ,{82, 167, 148, 5} ,{82, 167, 149, 5} ,{82, 167, 131, 1} ,{82, 167, 150, 5} ,{82, 167, 151, 5} ,{82, 167, 152, 5} ,{82, 167, 153, 5} ,{82, 167, 154, 5} ,{82, 167, 155, 5} ,{82, 167, 100, 2} ,{82, 167, 156, 5} ,{82, 167, 0, 5} ,{82, 167, 157, 5} ,{82, 167, 158, 5} ,{82, 167, 159, 5} ,{82, 167, 160, 5} ,{82, 167, 161, 5} ,{82, 167, 162, 5} ,{82, 167, 86, 2} ,{82, 167, 163, 5} ,{82, 167, 226, 1} ,{82, 167, 164, 5} ,{82, 167, 165, 5} ,{252, 166, 171, 1} ,{252, 166, 25, 15} ,{252, 166, 26, 15} ,{252, 166, 27, 15} ,{252, 166, 28, 15} ,{191, 176, 31, 15} ,{252, 166, 31, 15} ,{252, 166, 32, 15} ,{252, 166, 33, 15} ,{252, 166, 34, 15} ,{252, 166, 35, 15} ,{252, 166, 36, 15} ,{252, 166, 37, 15} ,{252, 166, 151, 4} ,{180, 169, 151, 4} ,{252, 166, 39, 15} ,{252, 166, 40, 15} ,{191, 176, 40, 15} ,{180, 169, 40, 15} ,{252, 166, 41, 15} ,{252, 166, 95, 3} ,{252, 166, 42, 15} ,{180, 169, 42, 15} ,{252, 166, 43, 15} ,{180, 169, 43, 15} ,{252, 166, 141, 1} ,{252, 166, 44, 15} ,{229, 182, 44, 15} ,{180, 169, 44, 15} ,{252, 166, 46, 15} ,{252, 166, 47, 15} ,{252, 166, 230, 8} ,{180, 169, 48, 15} ,{180, 169, 105, 12} ,{252, 166, 49, 15} ,{252, 166, 170, 1} ,{252, 166, 50, 15} ,{252, 166, 51, 15} ,{252, 166, 52, 15} ,{180, 169, 52, 15} ,{230, 182, 52, 15} ,{252, 166, 54, 15} ,{252, 166, 55, 15} ,{252, 166, 56, 15} ,{252, 166, 172, 1} ,{252, 166, 57, 15} ,{252, 166, 58, 15} ,{252, 166, 59, 15} ,{252, 166, 60, 15} ,{252, 166, 61, 15} ,{252, 166, 205, 8} ,{252, 166, 62, 15} ,{231, 182, 62, 15} ,{252, 166, 64, 15} ,{233, 182, 3, 0} ,{150, 166, 66, 15} ,{150, 166, 67, 15} ,{150, 166, 68, 15} ,{150, 166, 69, 15} ,{150, 166, 70, 15} ,{150, 166, 71, 15} ,{150, 166, 72, 15} ,{150, 166, 73, 15} ,{150, 166, 74, 15} ,{150, 166, 75, 15} ,{93, 169, 242, 8} ,{150, 166, 76, 15} ,{150, 166, 77, 15} ,{150, 166, 78, 15} ,{150, 166, 79, 15} ,{150, 166, 80, 15} ,{150, 166, 81, 15} ,{150, 166, 82, 15} ,{150, 166, 83, 15} ,{150, 166, 84, 15} ,{150, 166, 85, 15} ,{150, 166, 86, 15} ,{150, 166, 87, 15} ,{150, 166, 217, 3} ,{150, 166, 88, 15} ,{150, 166, 89, 15} ,{150, 166, 90, 15} ,{150, 166, 91, 15} ,{150, 166, 92, 15} ,{150, 166, 113, 8} ,{150, 166, 93, 15} ,{150, 166, 94, 15} ,{150, 166, 95, 15} ,{150, 166, 96, 15} ,{150, 166, 97, 15} ,{150, 166, 98, 15} ,{150, 166, 99, 15} ,{150, 166, 100, 15} ,{150, 166, 101, 15} ,{150, 166, 102, 15} ,{150, 166, 103, 15} ,{150, 166, 104, 15} ,{150, 166, 105, 15} ,{150, 166, 106, 15} ,{150, 166, 107, 15} ,{150, 166, 108, 15} ,{150, 166, 109, 15} ,{150, 166, 110, 15} ,{150, 166, 111, 15} ,{150, 166, 112, 15} ,{150, 166, 113, 15} ,{150, 166, 114, 15} ,{150, 166, 115, 15} ,{150, 166, 116, 15} ,{150, 166, 117, 15} ,{150, 166, 118, 15} ,{150, 166, 119, 15} ,{150, 166, 120, 15} ,{150, 166, 121, 15} ,{150, 166, 122, 15} ,{150, 166, 123, 15} ,{150, 166, 124, 15} ,{150, 166, 125, 15} ,{150, 166, 126, 15} ,{150, 166, 127, 15} ,{150, 166, 128, 15} ,{150, 166, 129, 15} ,{150, 166, 130, 15} ,{150, 166, 131, 15} ,{150, 166, 132, 15} ,{150, 166, 133, 15} ,{150, 166, 134, 15} ,{150, 166, 135, 15} ,{150, 166, 136, 15} ,{150, 166, 137, 15} ,{150, 166, 138, 15} ,{150, 166, 139, 15} ,{150, 166, 140, 15} ,{150, 166, 141, 15} ,{111, 167, 148, 1} ,{111, 167, 149, 1} ,{111, 167, 150, 1} ,{111, 167, 151, 1} ,{111, 167, 152, 1} ,{111, 167, 153, 1} ,{111, 167, 154, 1} ,{111, 167, 155, 1} ,{111, 167, 156, 1} ,{111, 167, 157, 1} ,{111, 167, 59, 0} ,{111, 167, 158, 1} ,{111, 167, 159, 1} ,{111, 167, 160, 1} ,{111, 167, 161, 1} ,{111, 167, 163, 1} ,{111, 167, 164, 1} ,{111, 167, 165, 1} ,{111, 167, 166, 1} ,{111, 167, 167, 1} ,{111, 167, 178, 1} ,{234, 182, 161, 1} ,{111, 167, 45, 0} ,{111, 167, 138, 1} ,{111, 167, 143, 15} ,{111, 167, 110, 173} ,{111, 167, 172, 1} ,{111, 167, 170, 1} ,{192, 176, 45, 0} ,{111, 167, 96, 169} ,{111, 167, 20, 169} ,{192, 176, 20, 169} ,{231, 170, 193, 176} ,{235, 182, 193, 176} ,{11, 0, 245, 171} ,{13, 0, 245, 171} ,{11, 0, 194, 176} ,{13, 0, 194, 176} ,{29, 1, 195, 176} ,{236, 182, 195, 176} ,{237, 182, 107, 2} ,{11, 0, 196, 176} ,{13, 0, 196, 176} ,{29, 1, 107, 10} ,{11, 0, 198, 176} ,{13, 0, 198, 176} ,{149, 15, 150, 15} ,{151, 15, 0, 0} ,{152, 15, 151, 15} ,{179, 0, 219, 76} ,{153, 15, 0, 0} ,{83, 1, 154, 15} ,{73, 3, 155, 15} ,{65, 1, 155, 15} ,{238, 182, 237, 10} ,{239, 182, 104, 0} ,{85, 0, 40, 10} ,{156, 15, 157, 15} ,{45, 10, 0, 168} ,{226, 0, 199, 176} ,{11, 0, 201, 176} ,{13, 0, 201, 176} ,{226, 0, 233, 166} ,{226, 0, 27, 167} ,{11, 0, 202, 176} ,{13, 0, 202, 176} ,{31, 7, 203, 176} ,{31, 7, 204, 176} ,{30, 7, 203, 176} ,{30, 7, 204, 176} ,{11, 0, 206, 176} ,{13, 0, 206, 176} ,{98, 173, 12, 0} ,{99, 173, 12, 0} ,{69, 172, 121, 169} ,{154, 177, 100, 8} ,{47, 11, 168, 64} ,{191, 2, 207, 176} ,{179, 0, 2, 38} ,{81, 0, 82, 0} ,{131, 0, 31, 10} ,{166, 173, 89, 38} ,{184, 166, 160, 15} ,{184, 166, 161, 15} ,{100, 173, 24, 0} ,{100, 173, 25, 0} ,{100, 173, 26, 0} ,{184, 166, 163, 15} ,{184, 166, 112, 11} ,{184, 166, 164, 15} ,{208, 176, 24, 0} ,{208, 176, 25, 0} ,{184, 166, 166, 15} ,{184, 166, 167, 15} ,{209, 176, 24, 0} ,{209, 176, 25, 0} ,{247, 171, 24, 0} ,{247, 171, 25, 0} ,{247, 171, 26, 0} ,{247, 171, 27, 0} ,{184, 166, 169, 15} ,{184, 166, 170, 15} ,{210, 176, 24, 0} ,{210, 176, 25, 0} ,{211, 176, 24, 0} ,{211, 176, 25, 0} ,{184, 166, 42, 13} ,{184, 166, 172, 15} ,{184, 166, 173, 15} ,{184, 166, 71, 12} ,{184, 166, 121, 12} ,{184, 166, 174, 15} ,{184, 166, 175, 15} ,{184, 166, 176, 15} ,{212, 176, 24, 0} ,{212, 176, 25, 0} ,{184, 166, 109, 12} ,{213, 176, 24, 0} ,{213, 176, 25, 0} ,{232, 170, 221, 176} ,{184, 166, 182, 15} ,{184, 166, 183, 15} ,{184, 166, 184, 15} ,{184, 166, 223, 176} ,{184, 166, 187, 15} ,{214, 176, 24, 0} ,{214, 176, 25, 0} ,{184, 166, 189, 15} ,{184, 166, 190, 15} ,{233, 167, 190, 15} ,{248, 171, 24, 0} ,{248, 171, 25, 0} ,{248, 171, 26, 0} ,{248, 171, 27, 0} ,{184, 166, 193, 15} ,{184, 166, 194, 15} ,{184, 166, 195, 15} ,{184, 166, 196, 15} ,{184, 166, 197, 15} ,{215, 176, 24, 0} ,{215, 176, 25, 0} ,{184, 166, 199, 15} ,{184, 166, 200, 15} ,{101, 173, 24, 0} ,{101, 173, 25, 0} ,{101, 173, 26, 0} ,{184, 166, 202, 15} ,{184, 166, 203, 15} ,{216, 176, 24, 0} ,{216, 176, 25, 0} ,{233, 167, 29, 6} ,{232, 170, 187, 0} ,{184, 166, 187, 0} ,{233, 167, 204, 15} ,{233, 167, 205, 15} ,{184, 166, 197, 11} ,{233, 167, 206, 15} ,{232, 170, 207, 15} ,{217, 176, 24, 0} ,{217, 176, 25, 0} ,{184, 166, 209, 15} ,{233, 167, 210, 15} ,{218, 176, 24, 0} ,{218, 176, 25, 0} ,{233, 167, 202, 11} ,{233, 167, 211, 15} ,{219, 176, 24, 0} ,{219, 176, 25, 0} ,{184, 166, 236, 12} ,{184, 166, 213, 15} ,{233, 167, 226, 176} ,{233, 167, 216, 15} ,{233, 167, 111, 12} ,{233, 167, 217, 15} ,{102, 173, 24, 0} ,{102, 173, 25, 0} ,{102, 173, 26, 0} ,{233, 167, 219, 15} ,{184, 166, 110, 14} ,{233, 167, 220, 15} ,{184, 166, 221, 15} ,{184, 166, 222, 15} ,{233, 167, 223, 15} ,{233, 167, 224, 15} ,{233, 167, 225, 15} ,{232, 170, 226, 15} ,{232, 170, 227, 15} ,{233, 167, 228, 15} ,{250, 171, 230, 15} ,{233, 167, 230, 15} ,{250, 171, 231, 15} ,{233, 167, 231, 15} ,{250, 171, 232, 15} ,{233, 167, 232, 15} ,{184, 166, 233, 15} ,{250, 171, 233, 15} ,{233, 167, 233, 15} ,{163, 166, 24, 0} ,{163, 166, 77, 0} ,{163, 166, 115, 0} ,{163, 166, 46, 10} ,{163, 166, 235, 15} ,{163, 166, 172, 0} ,{163, 166, 25, 0} ,{163, 166, 236, 15} ,{163, 166, 144, 5} ,{163, 166, 237, 15} ,{163, 166, 238, 15} ,{163, 166, 31, 0} ,{240, 182, 112, 11} ,{163, 166, 239, 15} ,{163, 166, 240, 15} ,{163, 166, 164, 15} ,{163, 166, 29, 68} ,{163, 166, 241, 15} ,{163, 166, 242, 15} ,{163, 166, 243, 15} ,{163, 166, 244, 15} ,{241, 182, 29, 68} ,{242, 182, 246, 15} ,{163, 166, 14, 4} ,{163, 166, 166, 15} ,{163, 166, 167, 15} ,{163, 166, 161, 15} ,{163, 166, 247, 15} ,{163, 166, 248, 15} ,{163, 166, 249, 15} ,{163, 166, 246, 15} ,{163, 166, 114, 12} ,{163, 166, 250, 15} ,{163, 166, 164, 6} ,{243, 182, 252, 15} ,{163, 166, 253, 15} ,{163, 166, 254, 15} ,{163, 166, 255, 15} ,{163, 166, 0, 16} ,{163, 166, 1, 16} ,{163, 166, 2, 16} ,{163, 166, 3, 16} ,{163, 166, 4, 16} ,{163, 166, 5, 16} ,{163, 166, 6, 16} ,{163, 166, 113, 12} ,{163, 166, 7, 16} ,{163, 166, 8, 16} ,{163, 166, 9, 16} ,{163, 166, 10, 16} ,{163, 166, 11, 16} ,{225, 176, 170, 15} ,{224, 176, 161, 15} ,{244, 182, 12, 16} ,{245, 182, 13, 16} ,{163, 166, 14, 16} ,{163, 166, 15, 16} ,{163, 166, 16, 16} ,{163, 166, 17, 16} ,{163, 166, 18, 16} ,{163, 166, 67, 13} ,{163, 166, 19, 16} ,{163, 166, 20, 16} ,{163, 166, 42, 13} ,{163, 166, 157, 15} ,{163, 166, 172, 15} ,{163, 166, 21, 16} ,{163, 166, 22, 16} ,{163, 166, 23, 16} ,{163, 166, 107, 10} ,{163, 166, 24, 16} ,{163, 166, 71, 12} ,{163, 166, 200, 8} ,{163, 166, 121, 12} ,{163, 166, 25, 16} ,{163, 166, 26, 16} ,{163, 166, 20, 0} ,{163, 166, 174, 15} ,{163, 166, 27, 16} ,{246, 182, 24, 16} ,{163, 166, 28, 16} ,{163, 166, 29, 16} ,{163, 166, 30, 16} ,{163, 166, 31, 16} ,{163, 166, 112, 12} ,{163, 166, 109, 12} ,{163, 166, 32, 16} ,{163, 166, 33, 16} ,{247, 182, 68, 0} ,{163, 166, 221, 176} ,{163, 166, 34, 16} ,{163, 166, 35, 16} ,{163, 166, 182, 15} ,{163, 166, 183, 15} ,{163, 166, 36, 16} ,{163, 166, 184, 15} ,{163, 166, 37, 16} ,{163, 166, 38, 16} ,{163, 166, 39, 16} ,{163, 166, 40, 16} ,{163, 166, 41, 16} ,{163, 166, 42, 16} ,{163, 166, 223, 176} ,{163, 166, 43, 16} ,{224, 176, 26, 13} ,{163, 166, 44, 16} ,{163, 166, 45, 16} ,{163, 166, 46, 16} ,{163, 166, 187, 15} ,{163, 166, 47, 16} ,{163, 166, 34, 1} ,{163, 166, 48, 16} ,{163, 166, 49, 16} ,{163, 166, 50, 16} ,{163, 166, 51, 16} ,{163, 166, 52, 16} ,{163, 166, 53, 16} ,{163, 166, 189, 15} ,{163, 166, 54, 16} ,{163, 166, 190, 15} ,{163, 166, 55, 16} ,{163, 166, 56, 16} ,{163, 166, 194, 15} ,{163, 166, 57, 16} ,{163, 166, 197, 15} ,{163, 166, 244, 10} ,{163, 166, 58, 16} ,{163, 166, 92, 8} ,{163, 166, 59, 16} ,{163, 166, 199, 15} ,{163, 166, 60, 16} ,{163, 166, 61, 16} ,{163, 166, 62, 16} ,{163, 166, 200, 15} ,{163, 166, 63, 16} ,{163, 166, 64, 16} ,{163, 166, 65, 16} ,{163, 166, 66, 16} ,{163, 166, 67, 16} ,{163, 166, 68, 16} ,{163, 166, 202, 15} ,{163, 166, 69, 16} ,{163, 166, 70, 16} ,{248, 182, 246, 15} ,{163, 166, 203, 15} ,{163, 166, 71, 16} ,{163, 166, 29, 6} ,{163, 166, 187, 0} ,{163, 166, 204, 15} ,{163, 166, 72, 16} ,{163, 166, 73, 16} ,{163, 166, 74, 16} ,{163, 166, 75, 16} ,{163, 166, 205, 15} ,{163, 166, 76, 16} ,{163, 166, 77, 16} ,{163, 166, 197, 11} ,{163, 166, 78, 16} ,{163, 166, 206, 15} ,{163, 166, 79, 16} ,{163, 166, 80, 16} ,{163, 166, 207, 15} ,{163, 166, 209, 15} ,{163, 166, 81, 16} ,{163, 166, 82, 16} ,{163, 166, 83, 16} ,{163, 166, 210, 15} ,{163, 166, 202, 11} ,{163, 166, 211, 15} ,{163, 166, 84, 16} ,{163, 166, 85, 16} ,{249, 182, 224, 15} ,{163, 166, 236, 12} ,{163, 166, 213, 15} ,{163, 166, 86, 16} ,{163, 166, 118, 12} ,{163, 166, 215, 15} ,{163, 166, 226, 176} ,{163, 166, 87, 16} ,{163, 166, 88, 16} ,{163, 166, 216, 15} ,{163, 166, 111, 12} ,{163, 166, 217, 15} ,{163, 166, 219, 15} ,{163, 166, 110, 14} ,{163, 166, 89, 16} ,{163, 166, 220, 15} ,{163, 166, 221, 15} ,{163, 166, 90, 16} ,{163, 166, 91, 16} ,{163, 166, 92, 16} ,{250, 182, 81, 16} ,{163, 166, 94, 16} ,{163, 166, 222, 15} ,{163, 166, 223, 15} ,{163, 166, 224, 15} ,{163, 166, 225, 15} ,{163, 166, 95, 16} ,{163, 166, 226, 15} ,{163, 166, 96, 16} ,{163, 166, 227, 15} ,{163, 166, 97, 16} ,{163, 166, 57, 12} ,{163, 166, 98, 16} ,{163, 166, 228, 15} ,{163, 166, 99, 16} ,{163, 166, 100, 16} ,{163, 166, 101, 16} ,{163, 166, 102, 16} ,{163, 166, 230, 15} ,{163, 166, 231, 15} ,{163, 166, 232, 15} ,{163, 166, 233, 15} ,{163, 166, 103, 16} ,{228, 176, 39, 1} ,{230, 176, 222, 0} ,{251, 182, 39, 1} ,{252, 182, 222, 0} ,{253, 182, 106, 16} ,{114, 170, 132, 0} ,{114, 170, 222, 0} ,{114, 170, 20, 3} ,{232, 176, 20, 3} ,{232, 176, 39, 1} ,{114, 170, 103, 173} ,{180, 168, 108, 16} ,{104, 16, 1, 0} ,{104, 16, 16, 0} ,{104, 16, 241, 37} ,{109, 16, 3, 0} ,{254, 182, 0, 177} ,{104, 16, 115, 170} ,{255, 182, 3, 0} ,{0, 183, 23, 0} ,{11, 0, 81, 168} ,{13, 0, 81, 168} ,{11, 0, 134, 170} ,{13, 0, 134, 170} ,{11, 0, 40, 169} ,{13, 0, 40, 169} ,{223, 168, 40, 169} ,{224, 168, 40, 169} ,{11, 0, 52, 172} ,{13, 0, 52, 172} ,{114, 16, 3, 0} ,{115, 16, 3, 0} ,{11, 0, 129, 168} ,{13, 0, 129, 168} ,{223, 168, 10, 170} ,{224, 168, 10, 170} ,{223, 168, 129, 168} ,{224, 168, 129, 168} ,{223, 168, 103, 168} ,{224, 168, 103, 168} ,{190, 10, 22, 10} ,{179, 0, 112, 78} ,{104, 173, 229, 37} ,{76, 0, 112, 78} ,{1, 183, 118, 12} ,{181, 168, 24, 0} ,{181, 168, 25, 0} ,{181, 168, 26, 0} ,{181, 168, 27, 0} ,{181, 168, 28, 0} ,{181, 168, 29, 0} ,{181, 168, 30, 0} ,{181, 168, 31, 0} ,{181, 168, 32, 0} ,{2, 183, 21, 169} ,{3, 183, 21, 169} ,{104, 16, 105, 173} ,{4, 183, 21, 169} ,{5, 183, 233, 176} ,{6, 183, 233, 176} ,{195, 2, 22, 10} ,{234, 170, 3, 0} ,{234, 176, 13, 170} ,{234, 170, 236, 176} ,{8, 183, 236, 176} ,{10, 183, 123, 0} ,{46, 11, 100, 78} ,{13, 183, 82, 1} ,{181, 168, 14, 4} ,{181, 168, 221, 6} ,{181, 168, 222, 6} ,{81, 0, 87, 78} ,{124, 16, 3, 0} ,{14, 183, 3, 0} ,{15, 183, 97, 0} ,{17, 183, 1, 0} ,{182, 168, 45, 0} ,{193, 166, 45, 0} ,{182, 168, 53, 0} ,{193, 166, 53, 0} ,{182, 168, 65, 0} ,{193, 166, 65, 0} ,{182, 168, 49, 0} ,{193, 166, 49, 0} ,{182, 168, 59, 0} ,{193, 166, 59, 0} ,{193, 166, 154, 1} ,{193, 166, 200, 3} ,{193, 166, 103, 6} ,{193, 166, 160, 6} ,{193, 166, 102, 6} ,{193, 166, 159, 6} ,{193, 166, 106, 6} ,{193, 166, 163, 6} ,{193, 166, 194, 4} ,{193, 166, 164, 6} ,{193, 166, 131, 3} ,{193, 166, 234, 1} ,{193, 166, 27, 6} ,{193, 166, 130, 6} ,{193, 166, 26, 6} ,{193, 166, 129, 6} ,{193, 166, 30, 6} ,{193, 166, 153, 1} ,{193, 166, 122, 4} ,{193, 166, 107, 3} ,{193, 166, 129, 3} ,{193, 166, 232, 1} ,{193, 166, 215, 4} ,{193, 166, 142, 6} ,{182, 168, 70, 6} ,{193, 166, 70, 6} ,{193, 166, 141, 6} ,{193, 166, 161, 1} ,{193, 166, 151, 1} ,{193, 166, 237, 1} ,{193, 166, 199, 4} ,{193, 166, 139, 3} ,{193, 166, 92, 6} ,{193, 166, 101, 1} ,{193, 166, 94, 6} ,{193, 166, 200, 4} ,{193, 166, 163, 1} ,{193, 166, 127, 3} ,{193, 166, 128, 3} ,{193, 166, 250, 5} ,{193, 166, 62, 6} ,{193, 166, 104, 1} ,{193, 166, 249, 5} ,{193, 166, 73, 5} ,{193, 166, 212, 6} ,{193, 166, 86, 2} ,{193, 166, 148, 1} ,{193, 166, 158, 1} ,{193, 166, 243, 1} ,{193, 166, 201, 4} ,{193, 166, 202, 4} ,{193, 166, 137, 3} ,{193, 166, 9, 6} ,{193, 166, 100, 1} ,{193, 166, 12, 6} ,{193, 166, 203, 4} ,{182, 168, 171, 1} ,{193, 166, 171, 1} ,{182, 168, 170, 1} ,{193, 166, 170, 1} ,{182, 168, 204, 4} ,{193, 166, 204, 4} ,{193, 166, 253, 1} ,{193, 166, 22, 6} ,{193, 166, 154, 4} ,{193, 166, 24, 6} ,{193, 166, 46, 5} ,{182, 168, 140, 3} ,{193, 166, 140, 3} ,{193, 166, 230, 5} ,{193, 166, 226, 1} ,{193, 166, 206, 4} ,{193, 166, 58, 0} ,{193, 166, 65, 6} ,{182, 168, 154, 1} ,{182, 168, 106, 6} ,{237, 176, 13, 170} ,{237, 176, 163, 173} ,{12, 170, 13, 170} ,{12, 170, 163, 173} ,{127, 16, 115, 170} ,{127, 16, 238, 176} ,{18, 183, 130, 16} ,{19, 183, 104, 0} ,{145, 167, 45, 0} ,{173, 166, 45, 0} ,{145, 167, 53, 0} ,{173, 166, 53, 0} ,{145, 167, 65, 0} ,{173, 166, 65, 0} ,{145, 167, 49, 0} ,{173, 166, 49, 0} ,{145, 167, 59, 0} ,{173, 166, 59, 0} ,{173, 166, 154, 1} ,{173, 166, 200, 3} ,{173, 166, 103, 6} ,{173, 166, 160, 6} ,{173, 166, 102, 6} ,{173, 166, 159, 6} ,{173, 166, 106, 6} ,{173, 166, 163, 6} ,{173, 166, 194, 4} ,{173, 166, 164, 6} ,{173, 166, 131, 3} ,{173, 166, 234, 1} ,{173, 166, 27, 6} ,{173, 166, 130, 6} ,{173, 166, 26, 6} ,{173, 166, 129, 6} ,{173, 166, 30, 6} ,{173, 166, 153, 1} ,{173, 166, 122, 4} ,{173, 166, 107, 3} ,{173, 166, 129, 3} ,{173, 166, 232, 1} ,{173, 166, 215, 4} ,{173, 166, 142, 6} ,{145, 167, 70, 6} ,{173, 166, 70, 6} ,{173, 166, 141, 6} ,{173, 166, 161, 1} ,{173, 166, 151, 1} ,{173, 166, 237, 1} ,{173, 166, 199, 4} ,{173, 166, 139, 3} ,{173, 166, 92, 6} ,{173, 166, 101, 1} ,{173, 166, 94, 6} ,{173, 166, 200, 4} ,{173, 166, 163, 1} ,{173, 166, 127, 3} ,{173, 166, 128, 3} ,{173, 166, 250, 5} ,{173, 166, 62, 6} ,{173, 166, 104, 1} ,{173, 166, 249, 5} ,{173, 166, 73, 5} ,{173, 166, 212, 6} ,{173, 166, 86, 2} ,{173, 166, 148, 1} ,{173, 166, 158, 1} ,{173, 166, 243, 1} ,{173, 166, 201, 4} ,{173, 166, 202, 4} ,{173, 166, 137, 3} ,{173, 166, 9, 6} ,{173, 166, 100, 1} ,{173, 166, 12, 6} ,{173, 166, 203, 4} ,{145, 167, 171, 1} ,{173, 166, 171, 1} ,{145, 167, 170, 1} ,{173, 166, 170, 1} ,{145, 167, 204, 4} ,{173, 166, 204, 4} ,{173, 166, 253, 1} ,{173, 166, 22, 6} ,{173, 166, 154, 4} ,{173, 166, 24, 6} ,{173, 166, 46, 5} ,{145, 167, 140, 3} ,{173, 166, 140, 3} ,{173, 166, 230, 5} ,{173, 166, 226, 1} ,{173, 166, 206, 4} ,{173, 166, 58, 0} ,{173, 166, 65, 6} ,{145, 167, 154, 1} ,{145, 167, 106, 6} ,{173, 166, 216, 3} ,{173, 166, 66, 6} ,{173, 166, 149, 1} ,{173, 166, 249, 1} ,{131, 16, 89, 38} ,{129, 177, 119, 169} ,{131, 16, 115, 170} ,{131, 16, 238, 176} ,{20, 183, 133, 16} ,{230, 166, 46, 0} ,{230, 166, 60, 0} ,{230, 166, 57, 0} ,{230, 166, 50, 0} ,{230, 166, 48, 0} ,{230, 166, 64, 0} ,{230, 166, 58, 0} ,{230, 166, 56, 0} ,{230, 166, 51, 0} ,{230, 166, 55, 0} ,{230, 166, 52, 0} ,{230, 166, 54, 0} ,{230, 166, 61, 0} ,{230, 166, 68, 0} ,{230, 166, 135, 16} ,{230, 166, 136, 16} ,{230, 166, 126, 7} ,{230, 166, 62, 0} ,{230, 166, 70, 0} ,{230, 166, 47, 0} ,{230, 166, 63, 0} ,{230, 166, 45, 0} ,{230, 166, 59, 0} ,{230, 166, 49, 0} ,{230, 166, 235, 1} ,{230, 166, 197, 3} ,{230, 166, 213, 4} ,{230, 166, 198, 3} ,{230, 166, 225, 0} ,{230, 166, 137, 5} ,{230, 166, 157, 1} ,{230, 166, 166, 4} ,{230, 166, 163, 0} ,{230, 166, 159, 1} ,{230, 166, 53, 0} ,{230, 166, 65, 0} ,{230, 166, 137, 16} ,{230, 166, 66, 0} ,{230, 166, 228, 2} ,{230, 166, 138, 16} ,{230, 166, 187, 9} ,{175, 166, 171, 5} ,{175, 166, 172, 5} ,{175, 166, 60, 172} ,{175, 166, 173, 5} ,{235, 170, 183, 5} ,{235, 170, 189, 5} ,{175, 166, 174, 5} ,{175, 166, 175, 5} ,{175, 166, 176, 5} ,{183, 168, 171, 5} ,{183, 168, 177, 5} ,{183, 168, 178, 5} ,{183, 168, 180, 5} ,{183, 168, 187, 5} ,{183, 168, 188, 5} ,{183, 168, 189, 5} ,{175, 166, 177, 5} ,{175, 166, 178, 5} ,{175, 166, 179, 5} ,{252, 169, 180, 5} ,{175, 166, 180, 5} ,{175, 166, 181, 5} ,{175, 166, 182, 5} ,{175, 166, 183, 5} ,{175, 166, 184, 5} ,{175, 166, 185, 5} ,{175, 166, 186, 5} ,{175, 166, 187, 5} ,{175, 166, 188, 5} ,{175, 166, 189, 5} ,{175, 166, 45, 0} ,{175, 166, 133, 0} ,{175, 166, 171, 1} ,{175, 166, 224, 1} ,{175, 166, 225, 5} ,{175, 166, 49, 0} ,{175, 166, 226, 5} ,{175, 166, 227, 5} ,{175, 166, 59, 0} ,{175, 166, 140, 3} ,{175, 166, 228, 5} ,{175, 166, 164, 0} ,{175, 166, 204, 4} ,{175, 166, 65, 0} ,{175, 166, 229, 5} ,{175, 166, 226, 1} ,{175, 166, 230, 5} ,{175, 166, 170, 1} ,{175, 166, 110, 5} ,{175, 166, 141, 1} ,{175, 166, 53, 0} ,{169, 5, 223, 5} ,{175, 166, 191, 5} ,{235, 170, 174, 5} ,{235, 170, 180, 5} ,{235, 170, 206, 5} ,{183, 168, 60, 172} ,{183, 168, 174, 5} ,{183, 168, 164, 173} ,{183, 168, 206, 5} ,{183, 168, 221, 5} ,{106, 173, 178, 5} ,{106, 173, 180, 5} ,{106, 173, 206, 5} ,{175, 166, 197, 5} ,{252, 169, 171, 5} ,{252, 169, 174, 5} ,{252, 169, 127, 173} ,{252, 169, 60, 177} ,{252, 169, 183, 5} ,{252, 169, 187, 5} ,{175, 166, 200, 5} ,{175, 166, 201, 5} ,{236, 170, 171, 5} ,{236, 170, 173, 5} ,{236, 170, 174, 5} ,{236, 170, 178, 5} ,{236, 170, 183, 5} ,{175, 166, 206, 5} ,{175, 166, 208, 5} ,{175, 166, 209, 5} ,{239, 176, 180, 5} ,{239, 176, 206, 5} ,{175, 166, 219, 5} ,{175, 166, 220, 5} ,{175, 166, 221, 5} ,{107, 173, 171, 1} ,{107, 173, 224, 1} ,{107, 173, 53, 0} ,{108, 173, 226, 5} ,{108, 173, 227, 5} ,{108, 173, 53, 0} ,{175, 166, 242, 5} ,{175, 166, 139, 16} ,{21, 183, 3, 0} ,{22, 183, 3, 0} ,{23, 183, 3, 0} ,{24, 183, 3, 0} ,{25, 183, 3, 0} ,{26, 183, 3, 0} ,{27, 183, 3, 0} ,{28, 183, 3, 0} ,{29, 183, 3, 0} ,{30, 183, 3, 0} ,{31, 183, 3, 0} ,{32, 183, 3, 0} ,{33, 183, 3, 0} ,{34, 183, 3, 0} ,{35, 183, 3, 0} ,{36, 183, 3, 0} ,{230, 166, 73, 5} ,{230, 166, 130, 6} ,{230, 166, 154, 6} ,{230, 166, 159, 6} ,{230, 166, 124, 3} ,{230, 166, 144, 16} ,{230, 166, 125, 3} ,{230, 166, 10, 8} ,{230, 166, 189, 9} ,{230, 166, 145, 16} ,{230, 166, 146, 16} ,{230, 166, 192, 9} ,{230, 166, 147, 16} ,{230, 166, 148, 16} ,{230, 166, 149, 16} ,{230, 166, 150, 16} ,{230, 166, 173, 4} ,{230, 166, 223, 3} ,{230, 166, 151, 16} ,{230, 166, 152, 16} ,{252, 171, 60, 0} ,{252, 171, 64, 0} ,{252, 171, 55, 0} ,{252, 171, 52, 0} ,{88, 167, 64, 0} ,{88, 167, 153, 16} ,{88, 167, 154, 16} ,{88, 167, 155, 16} ,{88, 167, 108, 7} ,{88, 167, 156, 16} ,{88, 167, 157, 16} ,{88, 167, 158, 16} ,{88, 167, 159, 16} ,{88, 167, 160, 16} ,{88, 167, 161, 16} ,{88, 167, 162, 16} ,{88, 167, 163, 16} ,{88, 167, 164, 16} ,{88, 167, 165, 16} ,{88, 167, 58, 0} ,{88, 167, 52, 0} ,{88, 167, 63, 0} ,{88, 167, 60, 0} ,{88, 167, 166, 16} ,{88, 167, 48, 0} ,{88, 167, 167, 16} ,{88, 167, 168, 16} ,{88, 167, 169, 16} ,{88, 167, 170, 16} ,{88, 167, 171, 16} ,{88, 167, 172, 16} ,{88, 167, 173, 16} ,{88, 167, 174, 16} ,{88, 167, 175, 16} ,{88, 167, 176, 16} ,{88, 167, 177, 16} ,{88, 167, 178, 16} ,{88, 167, 179, 16} ,{88, 167, 180, 16} ,{88, 167, 61, 0} ,{145, 167, 102, 6} ,{145, 167, 27, 6} ,{145, 167, 26, 6} ,{145, 167, 237, 1} ,{145, 167, 101, 1} ,{145, 167, 163, 1} ,{145, 167, 250, 5} ,{145, 167, 249, 5} ,{145, 167, 86, 2} ,{145, 167, 243, 1} ,{145, 167, 100, 1} ,{145, 167, 253, 1} ,{145, 167, 22, 6} ,{145, 167, 154, 4} ,{145, 167, 24, 6} ,{145, 167, 46, 5} ,{133, 167, 171, 5} ,{133, 167, 173, 5} ,{133, 167, 174, 5} ,{133, 167, 176, 5} ,{133, 167, 177, 5} ,{133, 167, 178, 5} ,{133, 167, 180, 5} ,{133, 167, 182, 5} ,{133, 167, 183, 5} ,{133, 167, 185, 5} ,{133, 167, 186, 5} ,{133, 167, 187, 5} ,{133, 167, 188, 5} ,{133, 167, 189, 5} ,{133, 167, 242, 176} ,{133, 167, 243, 176} ,{133, 167, 244, 176} ,{133, 167, 245, 176} ,{133, 167, 246, 176} ,{133, 167, 247, 176} ,{133, 167, 248, 176} ,{133, 167, 249, 176} ,{240, 176, 45, 0} ,{133, 167, 250, 176} ,{133, 167, 251, 176} ,{133, 167, 252, 176} ,{133, 167, 253, 176} ,{133, 167, 254, 176} ,{240, 176, 65, 0} ,{241, 176, 196, 16} ,{37, 183, 249, 5} ,{89, 167, 24, 0} ,{89, 167, 25, 0} ,{89, 167, 26, 0} ,{89, 167, 27, 0} ,{89, 167, 28, 0} ,{89, 167, 29, 0} ,{89, 167, 30, 0} ,{89, 167, 31, 0} ,{89, 167, 32, 0} ,{89, 167, 14, 4} ,{89, 167, 121, 12} ,{89, 167, 109, 12} ,{89, 167, 112, 12} ,{89, 167, 198, 16} ,{89, 167, 199, 16} ,{89, 167, 114, 12} ,{89, 167, 71, 12} ,{89, 167, 200, 16} ,{89, 167, 201, 16} ,{89, 167, 202, 16} ,{89, 167, 203, 16} ,{89, 167, 204, 16} ,{89, 167, 205, 16} ,{89, 167, 206, 16} ,{89, 167, 207, 16} ,{89, 167, 208, 16} ,{89, 167, 209, 16} ,{89, 167, 210, 16} ,{89, 167, 211, 16} ,{89, 167, 212, 16} ,{89, 167, 213, 16} ,{89, 167, 214, 16} ,{89, 167, 215, 16} ,{89, 167, 216, 16} ,{89, 167, 61, 16} ,{89, 167, 217, 16} ,{0, 167, 146, 11} ,{0, 167, 218, 16} ,{0, 167, 219, 16} ,{0, 167, 133, 16} ,{38, 183, 94, 169} ,{22, 169, 94, 169} ,{23, 169, 94, 169} ,{24, 169, 94, 169} ,{39, 183, 94, 169} ,{40, 183, 94, 169} ,{41, 183, 94, 169} ,{42, 183, 94, 169} ,{212, 12, 6, 0} ,{22, 169, 24, 0} ,{22, 169, 25, 0} ,{22, 169, 26, 0} ,{22, 169, 27, 0} ,{22, 169, 28, 0} ,{22, 169, 29, 0} ,{22, 169, 30, 0} ,{22, 169, 31, 0} ,{22, 169, 32, 0} ,{231, 166, 222, 6} ,{23, 169, 24, 0} ,{23, 169, 25, 0} ,{23, 169, 26, 0} ,{23, 169, 27, 0} ,{23, 169, 28, 0} ,{134, 167, 171, 5} ,{134, 167, 173, 5} ,{134, 167, 174, 5} ,{134, 167, 176, 5} ,{134, 167, 177, 5} ,{134, 167, 178, 5} ,{134, 167, 180, 5} ,{134, 167, 182, 5} ,{134, 167, 183, 5} ,{134, 167, 185, 5} ,{134, 167, 186, 5} ,{134, 167, 187, 5} ,{134, 167, 188, 5} ,{134, 167, 189, 5} ,{134, 167, 242, 176} ,{134, 167, 243, 176} ,{134, 167, 244, 176} ,{134, 167, 245, 176} ,{134, 167, 246, 176} ,{134, 167, 247, 176} ,{134, 167, 248, 176} ,{134, 167, 249, 176} ,{43, 183, 45, 0} ,{134, 167, 250, 176} ,{134, 167, 251, 176} ,{134, 167, 252, 176} ,{134, 167, 253, 176} ,{134, 167, 254, 176} ,{255, 176, 225, 16} ,{255, 176, 226, 16} ,{44, 183, 65, 0} ,{195, 16, 0, 177} ,{0, 167, 24, 0} ,{0, 167, 25, 0} ,{0, 167, 26, 0} ,{0, 167, 27, 0} ,{0, 167, 28, 0} ,{0, 167, 29, 0} ,{0, 167, 30, 0} ,{0, 167, 31, 0} ,{0, 167, 32, 0} ,{0, 167, 14, 4} ,{0, 167, 121, 12} ,{0, 167, 109, 12} ,{0, 167, 112, 12} ,{0, 167, 198, 16} ,{0, 167, 199, 16} ,{0, 167, 114, 12} ,{0, 167, 71, 12} ,{0, 167, 200, 16} ,{0, 167, 201, 16} ,{0, 167, 202, 16} ,{0, 167, 203, 16} ,{0, 167, 204, 16} ,{0, 167, 205, 16} ,{0, 167, 206, 16} ,{0, 167, 207, 16} ,{0, 167, 227, 16} ,{0, 167, 228, 16} ,{0, 167, 229, 16} ,{0, 167, 230, 16} ,{0, 167, 231, 16} ,{0, 167, 232, 16} ,{0, 167, 233, 16} ,{0, 167, 234, 16} ,{0, 167, 216, 16} ,{0, 167, 235, 16} ,{0, 167, 236, 16} ,{0, 167, 237, 16} ,{0, 167, 6, 3} ,{0, 167, 238, 16} ,{0, 167, 20, 3} ,{0, 167, 39, 1} ,{0, 167, 239, 16} ,{0, 167, 240, 16} ,{0, 167, 210, 16} ,{0, 167, 211, 16} ,{0, 167, 212, 16} ,{0, 167, 213, 16} ,{0, 167, 214, 16} ,{0, 167, 241, 16} ,{23, 169, 29, 0} ,{23, 169, 30, 0} ,{23, 169, 31, 0} ,{23, 169, 32, 0} ,{231, 166, 223, 6} ,{24, 169, 24, 0} ,{24, 169, 25, 0} ,{24, 169, 26, 0} ,{24, 169, 27, 0} ,{24, 169, 28, 0} ,{24, 169, 29, 0} ,{24, 169, 30, 0} ,{24, 169, 31, 0} ,{24, 169, 32, 0} ,{231, 166, 224, 6} ,{220, 166, 242, 16} ,{220, 166, 243, 16} ,{220, 166, 244, 16} ,{220, 166, 245, 16} ,{220, 166, 195, 8} ,{220, 166, 246, 16} ,{220, 166, 247, 16} ,{220, 166, 248, 16} ,{220, 166, 249, 16} ,{220, 166, 250, 16} ,{220, 166, 251, 16} ,{220, 166, 252, 16} ,{71, 0, 168, 16} ,{71, 0, 253, 16} ,{71, 0, 254, 16} ,{45, 183, 6, 0} ,{45, 167, 45, 0} ,{45, 167, 53, 0} ,{45, 167, 65, 0} ,{45, 167, 49, 0} ,{45, 167, 59, 0} ,{45, 167, 154, 1} ,{45, 167, 103, 6} ,{45, 167, 102, 6} ,{45, 167, 106, 6} ,{45, 167, 194, 4} ,{45, 167, 131, 3} ,{45, 167, 27, 6} ,{45, 167, 26, 6} ,{45, 167, 30, 6} ,{45, 167, 122, 4} ,{45, 167, 129, 3} ,{45, 167, 215, 4} ,{45, 167, 70, 6} ,{45, 167, 161, 1} ,{45, 167, 237, 1} ,{45, 167, 139, 3} ,{45, 167, 92, 6} ,{45, 167, 101, 1} ,{45, 167, 94, 6} ,{45, 167, 200, 4} ,{45, 167, 163, 1} ,{45, 167, 250, 5} ,{45, 167, 249, 5} ,{45, 167, 86, 2} ,{45, 167, 243, 1} ,{45, 167, 137, 3} ,{45, 167, 9, 6} ,{45, 167, 100, 1} ,{45, 167, 12, 6} ,{45, 167, 203, 4} ,{45, 167, 171, 1} ,{45, 167, 170, 1} ,{45, 167, 204, 4} ,{45, 167, 253, 1} ,{45, 167, 22, 6} ,{45, 167, 154, 4} ,{45, 167, 24, 6} ,{45, 167, 46, 5} ,{45, 167, 140, 3} ,{45, 167, 230, 5} ,{45, 167, 226, 1} ,{45, 167, 206, 4} ,{71, 0, 1, 17} ,{71, 0, 2, 17} ,{71, 0, 3, 17} ,{71, 0, 4, 17} ,{71, 0, 5, 17} ,{71, 0, 6, 17} ,{71, 0, 7, 17} ,{71, 0, 8, 17} ,{71, 0, 9, 17} ,{71, 0, 10, 17} ,{71, 0, 11, 17} ,{71, 0, 12, 17} ,{71, 0, 13, 17} ,{71, 0, 14, 17} ,{71, 0, 15, 17} ,{71, 0, 16, 17} ,{71, 0, 17, 17} ,{71, 0, 18, 17} ,{71, 0, 19, 17} ,{71, 0, 20, 17} ,{71, 0, 21, 17} ,{71, 0, 22, 17} ,{71, 0, 23, 17} ,{71, 0, 24, 17} ,{71, 0, 25, 17} ,{71, 0, 26, 17} ,{71, 0, 27, 17} ,{71, 0, 28, 17} ,{71, 0, 29, 17} ,{71, 0, 30, 17} ,{71, 0, 31, 17} ,{71, 0, 32, 17} ,{71, 0, 33, 17} ,{71, 0, 34, 17} ,{71, 0, 35, 17} ,{71, 0, 36, 17} ,{71, 0, 37, 17} ,{71, 0, 38, 17} ,{71, 0, 39, 17} ,{71, 0, 40, 17} ,{71, 0, 41, 17} ,{71, 0, 42, 17} ,{71, 0, 43, 17} ,{71, 0, 44, 17} ,{71, 0, 45, 17} ,{71, 0, 46, 17} ,{71, 0, 47, 17} ,{71, 0, 48, 17} ,{71, 0, 49, 17} ,{71, 0, 50, 17} ,{71, 0, 51, 17} ,{71, 0, 52, 17} ,{71, 0, 53, 17} ,{71, 0, 54, 17} ,{71, 0, 55, 17} ,{71, 0, 56, 17} ,{71, 0, 57, 17} ,{71, 0, 58, 17} ,{71, 0, 59, 17} ,{71, 0, 60, 17} ,{71, 0, 61, 17} ,{71, 0, 62, 17} ,{71, 0, 63, 17} ,{71, 0, 64, 17} ,{71, 0, 65, 17} ,{71, 0, 66, 17} ,{71, 0, 67, 17} ,{71, 0, 68, 17} ,{71, 0, 69, 17} ,{71, 0, 70, 17} ,{71, 0, 71, 17} ,{71, 0, 72, 17} ,{71, 0, 73, 17} ,{71, 0, 74, 17} ,{71, 0, 75, 17} ,{71, 0, 76, 17} ,{71, 0, 77, 17} ,{71, 0, 78, 17} ,{71, 0, 79, 17} ,{71, 0, 80, 17} ,{71, 0, 81, 17} ,{71, 0, 82, 17} ,{71, 0, 83, 17} ,{71, 0, 84, 17} ,{71, 0, 85, 17} ,{71, 0, 86, 17} ,{71, 0, 87, 17} ,{71, 0, 88, 17} ,{191, 167, 23, 0} ,{191, 167, 24, 0} ,{191, 167, 25, 0} ,{191, 167, 26, 0} ,{191, 167, 27, 0} ,{191, 167, 28, 0} ,{191, 167, 29, 0} ,{191, 167, 30, 0} ,{191, 167, 31, 0} ,{191, 167, 32, 0} ,{191, 167, 14, 4} ,{191, 167, 180, 10} ,{191, 167, 181, 10} ,{191, 167, 13, 12} ,{191, 167, 14, 12} ,{191, 167, 15, 12} ,{191, 167, 252, 3} ,{191, 167, 16, 12} ,{191, 167, 17, 12} ,{191, 167, 18, 12} ,{191, 167, 221, 6} ,{254, 171, 24, 0} ,{254, 171, 25, 0} ,{254, 171, 26, 0} ,{254, 171, 27, 0} ,{71, 0, 91, 17} ,{71, 0, 232, 1} ,{71, 0, 198, 3} ,{71, 0, 91, 0} ,{71, 0, 198, 9} ,{71, 0, 92, 17} ,{71, 0, 93, 17} ,{1, 177, 95, 17} ,{1, 177, 96, 17} ,{71, 0, 137, 16} ,{0, 172, 99, 17} ,{0, 172, 100, 17} ,{0, 172, 101, 17} ,{0, 172, 102, 17} ,{71, 0, 103, 17} ,{46, 183, 104, 17} ,{71, 0, 139, 3} ,{181, 169, 45, 0} ,{71, 0, 137, 3} ,{71, 0, 154, 1} ,{71, 0, 105, 17} ,{71, 0, 106, 17} ,{71, 0, 107, 17} ,{71, 0, 108, 17} ,{71, 0, 109, 17} ,{71, 0, 110, 17} ,{71, 0, 111, 17} ,{181, 169, 50, 0} ,{181, 169, 51, 0} ,{71, 0, 112, 17} ,{71, 0, 113, 17} ,{71, 0, 167, 16} ,{71, 0, 114, 17} ,{71, 0, 115, 17} ,{71, 0, 116, 17} ,{71, 0, 117, 17} ,{181, 169, 56, 0} ,{71, 0, 118, 17} ,{71, 0, 119, 17} ,{71, 0, 120, 17} ,{71, 0, 121, 17} ,{71, 0, 122, 17} ,{181, 169, 57, 0} ,{71, 0, 123, 17} ,{71, 0, 124, 17} ,{71, 0, 125, 17} ,{2, 177, 95, 17} ,{3, 177, 95, 17} ,{237, 170, 95, 17} ,{109, 173, 95, 17} ,{2, 177, 96, 17} ,{3, 177, 96, 17} ,{237, 170, 96, 17} ,{109, 173, 96, 17} ,{4, 177, 63, 0} ,{4, 177, 7, 177} ,{71, 0, 128, 3} ,{71, 0, 129, 17} ,{71, 0, 6, 9} ,{71, 0, 130, 17} ,{71, 0, 131, 17} ,{6, 177, 63, 0} ,{6, 177, 7, 177} ,{71, 0, 132, 17} ,{71, 0, 133, 17} ,{181, 169, 63, 0} ,{71, 0, 134, 17} ,{71, 0, 135, 17} ,{71, 0, 1, 7} ,{181, 169, 66, 0} ,{71, 0, 136, 17} ,{71, 0, 137, 17} ,{47, 183, 76, 17} ,{71, 0, 139, 17} ,{71, 0, 140, 17} ,{181, 169, 67, 0} ,{71, 0, 141, 17} ,{71, 0, 58, 7} ,{48, 183, 76, 17} ,{49, 183, 143, 17} ,{237, 170, 143, 17} ,{71, 0, 173, 4} ,{71, 0, 144, 17} ,{71, 0, 145, 17} ,{71, 0, 146, 17} ,{51, 183, 113, 17} ,{71, 0, 2, 2} ,{71, 0, 147, 17} ,{71, 0, 148, 17} ,{71, 0, 163, 1} ,{71, 0, 158, 16} ,{71, 0, 164, 3} ,{71, 0, 207, 7} ,{109, 173, 149, 17} ,{71, 0, 150, 17} ,{71, 0, 151, 17} ,{71, 0, 152, 17} ,{71, 0, 153, 17} ,{71, 0, 154, 17} ,{52, 183, 3, 16} ,{71, 0, 156, 17} ,{71, 0, 157, 17} ,{71, 0, 158, 17} ,{71, 0, 159, 17} ,{71, 0, 160, 17} ,{71, 0, 161, 17} ,{71, 0, 162, 17} ,{71, 0, 8, 7} ,{71, 0, 163, 17} ,{53, 183, 8, 177} ,{54, 183, 8, 177} ,{116, 167, 24, 0} ,{116, 167, 25, 0} ,{116, 167, 26, 0} ,{116, 167, 27, 0} ,{116, 167, 28, 0} ,{116, 167, 29, 0} ,{116, 167, 30, 0} ,{116, 167, 31, 0} ,{116, 167, 32, 0} ,{116, 167, 14, 4} ,{116, 167, 180, 10} ,{116, 167, 181, 10} ,{116, 167, 13, 12} ,{116, 167, 14, 12} ,{116, 167, 15, 12} ,{116, 167, 252, 3} ,{116, 167, 16, 12} ,{116, 167, 17, 12} ,{116, 167, 18, 12} ,{116, 167, 221, 6} ,{95, 169, 24, 0} ,{95, 169, 25, 0} ,{95, 169, 26, 0} ,{95, 169, 27, 0} ,{95, 169, 28, 0} ,{95, 169, 29, 0} ,{95, 169, 30, 0} ,{95, 169, 31, 0} ,{95, 169, 32, 0} ,{116, 167, 222, 6} ,{55, 183, 24, 0} ,{71, 0, 165, 17} ,{56, 183, 107, 12} ,{57, 183, 114, 12} ,{60, 183, 170, 17} ,{61, 183, 172, 17} ,{224, 166, 173, 17} ,{224, 166, 174, 17} ,{122, 168, 175, 17} ,{62, 183, 177, 17} ,{9, 177, 178, 17} ,{224, 166, 179, 17} ,{224, 166, 180, 17} ,{224, 166, 181, 17} ,{224, 166, 182, 17} ,{1, 172, 183, 17} ,{224, 166, 184, 17} ,{224, 166, 185, 17} ,{224, 166, 186, 17} ,{64, 183, 188, 17} ,{224, 166, 189, 17} ,{224, 166, 190, 17} ,{65, 183, 192, 17} ,{224, 166, 193, 17} ,{66, 183, 195, 17} ,{224, 166, 231, 11} ,{224, 166, 196, 17} ,{1, 172, 178, 17} ,{67, 183, 47, 12} ,{1, 172, 198, 17} ,{68, 183, 112, 12} ,{69, 183, 109, 12} ,{224, 166, 201, 17} ,{224, 166, 202, 17} ,{224, 166, 203, 17} ,{1, 172, 242, 15} ,{224, 166, 204, 17} ,{72, 183, 36, 12} ,{122, 168, 206, 17} ,{224, 166, 75, 12} ,{224, 166, 207, 17} ,{224, 166, 208, 17} ,{224, 166, 209, 17} ,{224, 166, 210, 17} ,{224, 166, 211, 17} ,{73, 183, 83, 178} ,{74, 183, 177, 17} ,{75, 183, 216, 17} ,{224, 166, 217, 17} ,{122, 168, 218, 17} ,{224, 166, 219, 17} ,{122, 168, 94, 16} ,{76, 183, 110, 12} ,{78, 183, 113, 12} ,{224, 166, 223, 17} ,{79, 183, 225, 17} ,{224, 166, 226, 17} ,{122, 168, 227, 17} ,{80, 183, 111, 12} ,{81, 183, 108, 12} ,{224, 166, 230, 17} ,{224, 166, 231, 17} ,{82, 183, 233, 17} ,{9, 177, 198, 17} ,{83, 183, 235, 17} ,{84, 183, 235, 17} ,{119, 166, 158, 3} ,{119, 166, 238, 17} ,{119, 166, 53, 0} ,{119, 166, 239, 17} ,{119, 166, 240, 17} ,{119, 166, 241, 17} ,{119, 166, 138, 1} ,{119, 166, 242, 17} ,{119, 166, 41, 0} ,{119, 166, 243, 17} ,{119, 166, 45, 0} ,{119, 166, 244, 17} ,{119, 166, 245, 17} ,{119, 166, 246, 17} ,{119, 166, 247, 17} ,{119, 166, 184, 1} ,{119, 166, 248, 17} ,{119, 166, 59, 0} ,{119, 166, 249, 17} ,{119, 166, 250, 17} ,{119, 166, 49, 0} ,{119, 166, 125, 6} ,{119, 166, 153, 3} ,{119, 166, 251, 17} ,{119, 166, 62, 6} ,{119, 166, 252, 17} ,{119, 166, 253, 17} ,{119, 166, 254, 17} ,{119, 166, 255, 17} ,{119, 166, 0, 18} ,{119, 166, 1, 18} ,{119, 166, 2, 18} ,{119, 166, 127, 3} ,{119, 166, 3, 18} ,{119, 166, 4, 18} ,{119, 166, 5, 18} ,{119, 166, 6, 18} ,{119, 166, 7, 18} ,{119, 166, 112, 11} ,{119, 166, 201, 4} ,{119, 166, 8, 18} ,{119, 166, 9, 18} ,{119, 166, 148, 1} ,{119, 166, 10, 18} ,{119, 166, 11, 18} ,{119, 166, 12, 18} ,{119, 166, 73, 5} ,{119, 166, 13, 18} ,{119, 166, 14, 18} ,{119, 166, 15, 18} ,{119, 166, 16, 18} ,{119, 166, 17, 18} ,{119, 166, 27, 11} ,{119, 166, 18, 18} ,{119, 166, 19, 18} ,{119, 166, 20, 18} ,{119, 166, 21, 18} ,{119, 166, 22, 18} ,{119, 166, 104, 1} ,{119, 166, 23, 18} ,{119, 166, 24, 18} ,{119, 166, 25, 18} ,{119, 166, 26, 18} ,{119, 166, 27, 18} ,{119, 166, 28, 18} ,{119, 166, 128, 3} ,{119, 166, 29, 18} ,{119, 166, 30, 18} ,{119, 166, 31, 18} ,{119, 166, 32, 18} ,{119, 166, 33, 18} ,{119, 166, 34, 18} ,{119, 166, 202, 4} ,{119, 166, 35, 18} ,{119, 166, 36, 18} ,{119, 166, 37, 18} ,{119, 166, 212, 6} ,{119, 166, 38, 18} ,{119, 166, 39, 18} ,{119, 166, 40, 18} ,{119, 166, 41, 18} ,{119, 166, 42, 18} ,{119, 166, 43, 18} ,{119, 166, 44, 18} ,{119, 166, 45, 18} ,{119, 166, 46, 18} ,{119, 166, 47, 18} ,{119, 166, 48, 18} ,{119, 166, 49, 18} ,{119, 166, 50, 18} ,{119, 166, 51, 18} ,{119, 166, 52, 18} ,{119, 166, 53, 18} ,{119, 166, 54, 18} ,{119, 166, 55, 18} ,{119, 166, 56, 18} ,{119, 166, 239, 3} ,{119, 166, 57, 18} ,{119, 166, 58, 18} ,{119, 166, 59, 18} ,{119, 166, 60, 18} ,{119, 166, 61, 18} ,{119, 166, 62, 18} ,{119, 166, 63, 18} ,{119, 166, 64, 18} ,{119, 166, 65, 18} ,{119, 166, 107, 5} ,{119, 166, 66, 18} ,{119, 166, 67, 18} ,{119, 166, 68, 18} ,{119, 166, 69, 18} ,{119, 166, 70, 18} ,{119, 166, 71, 18} ,{119, 166, 72, 18} ,{119, 166, 73, 18} ,{119, 166, 74, 18} ,{119, 166, 75, 18} ,{119, 166, 76, 18} ,{119, 166, 77, 18} ,{119, 166, 78, 18} ,{119, 166, 79, 18} ,{119, 166, 80, 18} ,{119, 166, 81, 18} ,{119, 166, 82, 18} ,{119, 166, 83, 18} ,{119, 166, 84, 18} ,{119, 166, 85, 18} ,{119, 166, 86, 18} ,{119, 166, 87, 18} ,{119, 166, 88, 18} ,{119, 166, 89, 18} ,{119, 166, 90, 18} ,{119, 166, 91, 18} ,{119, 166, 92, 18} ,{119, 166, 93, 18} ,{119, 166, 94, 18} ,{119, 166, 95, 18} ,{119, 166, 96, 18} ,{119, 166, 97, 18} ,{119, 166, 98, 18} ,{119, 166, 99, 18} ,{119, 166, 100, 18} ,{119, 166, 101, 18} ,{119, 166, 102, 18} ,{119, 166, 103, 18} ,{119, 166, 104, 18} ,{119, 166, 105, 18} ,{119, 166, 106, 18} ,{119, 166, 107, 18} ,{119, 166, 108, 18} ,{119, 166, 109, 18} ,{119, 166, 110, 18} ,{119, 166, 111, 18} ,{119, 166, 112, 18} ,{119, 166, 113, 18} ,{119, 166, 114, 18} ,{119, 166, 115, 18} ,{119, 166, 116, 18} ,{119, 166, 117, 18} ,{119, 166, 118, 18} ,{119, 166, 119, 18} ,{119, 166, 120, 18} ,{119, 166, 121, 18} ,{119, 166, 122, 18} ,{119, 166, 123, 18} ,{119, 166, 124, 18} ,{119, 166, 125, 18} ,{119, 166, 126, 18} ,{119, 166, 127, 18} ,{119, 166, 128, 18} ,{119, 166, 129, 18} ,{119, 166, 130, 18} ,{119, 166, 131, 18} ,{119, 166, 132, 18} ,{119, 166, 133, 18} ,{119, 166, 134, 18} ,{119, 166, 9, 6} ,{119, 166, 135, 18} ,{119, 166, 136, 18} ,{119, 166, 137, 18} ,{119, 166, 138, 18} ,{119, 166, 139, 18} ,{119, 166, 140, 18} ,{119, 166, 137, 3} ,{119, 166, 141, 18} ,{119, 166, 142, 18} ,{119, 166, 143, 18} ,{119, 166, 144, 18} ,{119, 166, 145, 18} ,{119, 166, 146, 18} ,{119, 166, 147, 18} ,{119, 166, 203, 4} ,{119, 166, 148, 18} ,{119, 166, 149, 18} ,{119, 166, 12, 6} ,{119, 166, 150, 18} ,{119, 166, 151, 18} ,{119, 166, 100, 1} ,{119, 166, 152, 18} ,{119, 166, 153, 18} ,{119, 166, 154, 18} ,{119, 166, 155, 18} ,{119, 166, 156, 18} ,{119, 166, 157, 18} ,{119, 166, 158, 18} ,{119, 166, 159, 18} ,{119, 166, 160, 18} ,{119, 166, 165, 3} ,{119, 166, 161, 18} ,{119, 166, 162, 18} ,{119, 166, 163, 18} ,{119, 166, 133, 3} ,{119, 166, 164, 18} ,{119, 166, 165, 18} ,{119, 166, 210, 6} ,{119, 166, 166, 18} ,{119, 166, 167, 18} ,{119, 166, 168, 18} ,{119, 166, 207, 6} ,{119, 166, 169, 18} ,{119, 166, 170, 18} ,{119, 166, 29, 16} ,{119, 166, 171, 18} ,{119, 166, 172, 18} ,{119, 166, 173, 18} ,{119, 166, 174, 18} ,{119, 166, 175, 18} ,{119, 166, 176, 18} ,{119, 166, 66, 6} ,{119, 166, 177, 18} ,{119, 166, 178, 18} ,{119, 166, 179, 18} ,{119, 166, 180, 18} ,{119, 166, 181, 18} ,{119, 166, 182, 18} ,{119, 166, 183, 18} ,{119, 166, 216, 3} ,{119, 166, 184, 18} ,{119, 166, 185, 18} ,{119, 166, 186, 18} ,{119, 166, 249, 1} ,{119, 166, 187, 18} ,{119, 166, 188, 18} ,{119, 166, 189, 18} ,{119, 166, 190, 18} ,{119, 166, 191, 18} ,{119, 166, 65, 6} ,{119, 166, 192, 18} ,{119, 166, 193, 18} ,{119, 166, 194, 18} ,{119, 166, 195, 18} ,{119, 166, 196, 18} ,{119, 166, 197, 18} ,{119, 166, 198, 18} ,{119, 166, 199, 18} ,{119, 166, 200, 18} ,{119, 166, 201, 18} ,{119, 166, 202, 18} ,{119, 166, 142, 6} ,{119, 166, 203, 18} ,{119, 166, 204, 18} ,{119, 166, 205, 18} ,{119, 166, 206, 18} ,{119, 166, 207, 18} ,{119, 166, 208, 18} ,{119, 166, 232, 1} ,{119, 166, 209, 18} ,{119, 166, 210, 18} ,{119, 166, 211, 18} ,{119, 166, 115, 0} ,{119, 166, 212, 18} ,{119, 166, 199, 4} ,{119, 166, 213, 18} ,{119, 166, 214, 18} ,{119, 166, 151, 1} ,{119, 166, 215, 18} ,{119, 166, 216, 18} ,{119, 166, 217, 18} ,{119, 166, 141, 6} ,{119, 166, 218, 18} ,{119, 166, 219, 18} ,{119, 166, 220, 18} ,{119, 166, 159, 3} ,{119, 166, 221, 18} ,{119, 166, 215, 4} ,{119, 166, 222, 18} ,{119, 166, 223, 18} ,{119, 166, 42, 10} ,{119, 166, 224, 18} ,{119, 166, 225, 18} ,{119, 166, 226, 18} ,{119, 166, 129, 3} ,{119, 166, 227, 18} ,{119, 166, 228, 18} ,{119, 166, 229, 18} ,{119, 166, 230, 18} ,{119, 166, 231, 18} ,{119, 166, 232, 18} ,{119, 166, 233, 18} ,{119, 166, 237, 1} ,{119, 166, 188, 11} ,{119, 166, 234, 18} ,{119, 166, 161, 1} ,{119, 166, 235, 18} ,{119, 166, 236, 18} ,{119, 166, 237, 18} ,{119, 166, 70, 6} ,{119, 166, 238, 18} ,{119, 166, 239, 18} ,{119, 166, 240, 18} ,{119, 166, 241, 18} ,{119, 166, 242, 18} ,{119, 166, 147, 6} ,{119, 166, 243, 18} ,{119, 166, 244, 18} ,{119, 166, 245, 18} ,{119, 166, 246, 18} ,{119, 166, 247, 18} ,{119, 166, 248, 18} ,{119, 166, 206, 3} ,{119, 166, 249, 18} ,{119, 166, 250, 18} ,{119, 166, 251, 18} ,{119, 166, 252, 18} ,{119, 166, 253, 18} ,{119, 166, 254, 18} ,{119, 166, 151, 6} ,{119, 166, 255, 18} ,{119, 166, 0, 19} ,{119, 166, 150, 6} ,{119, 166, 1, 19} ,{119, 166, 2, 19} ,{119, 166, 3, 19} ,{119, 166, 146, 6} ,{119, 166, 4, 19} ,{119, 166, 5, 19} ,{119, 166, 6, 19} ,{119, 166, 7, 19} ,{119, 166, 8, 19} ,{119, 166, 9, 19} ,{119, 166, 10, 19} ,{119, 166, 11, 19} ,{119, 166, 12, 19} ,{119, 166, 13, 19} ,{119, 166, 14, 19} ,{119, 166, 15, 19} ,{119, 166, 16, 19} ,{119, 166, 17, 19} ,{119, 166, 18, 19} ,{119, 166, 19, 19} ,{119, 166, 20, 19} ,{119, 166, 21, 19} ,{119, 166, 22, 19} ,{119, 166, 23, 19} ,{119, 166, 24, 19} ,{119, 166, 25, 19} ,{119, 166, 26, 19} ,{119, 166, 27, 19} ,{119, 166, 28, 19} ,{119, 166, 29, 19} ,{119, 166, 30, 19} ,{119, 166, 31, 19} ,{119, 166, 32, 19} ,{119, 166, 33, 19} ,{119, 166, 34, 19} ,{119, 166, 35, 19} ,{119, 166, 36, 19} ,{119, 166, 37, 19} ,{119, 166, 38, 19} ,{119, 166, 39, 19} ,{119, 166, 255, 6} ,{119, 166, 40, 19} ,{119, 166, 41, 19} ,{119, 166, 42, 19} ,{119, 166, 43, 19} ,{119, 166, 44, 19} ,{119, 166, 45, 19} ,{119, 166, 46, 19} ,{119, 166, 47, 19} ,{119, 166, 48, 19} ,{119, 166, 49, 19} ,{119, 166, 50, 19} ,{119, 166, 51, 19} ,{119, 166, 92, 6} ,{119, 166, 52, 19} ,{119, 166, 53, 19} ,{119, 166, 54, 19} ,{119, 166, 55, 19} ,{119, 166, 56, 19} ,{119, 166, 139, 3} ,{119, 166, 57, 19} ,{119, 166, 58, 19} ,{119, 166, 59, 19} ,{119, 166, 60, 19} ,{119, 166, 24, 16} ,{119, 166, 61, 19} ,{119, 166, 200, 4} ,{119, 166, 62, 19} ,{119, 166, 63, 19} ,{119, 166, 94, 6} ,{119, 166, 64, 19} ,{119, 166, 65, 19} ,{119, 166, 66, 19} ,{119, 166, 101, 1} ,{119, 166, 67, 19} ,{119, 166, 68, 19} ,{119, 166, 69, 19} ,{119, 166, 70, 19} ,{119, 166, 71, 19} ,{119, 166, 72, 19} ,{119, 166, 73, 19} ,{119, 166, 74, 19} ,{119, 166, 75, 19} ,{119, 166, 76, 19} ,{119, 166, 77, 19} ,{119, 166, 78, 19} ,{119, 166, 168, 9} ,{119, 166, 79, 19} ,{119, 166, 80, 19} ,{119, 166, 81, 19} ,{119, 166, 82, 19} ,{119, 166, 83, 19} ,{119, 166, 84, 19} ,{119, 166, 85, 19} ,{119, 166, 86, 19} ,{119, 166, 87, 19} ,{119, 166, 88, 19} ,{119, 166, 89, 19} ,{119, 166, 90, 19} ,{119, 166, 91, 19} ,{119, 166, 92, 19} ,{119, 166, 93, 19} ,{119, 166, 94, 19} ,{119, 166, 95, 19} ,{119, 166, 96, 19} ,{119, 166, 97, 19} ,{119, 166, 98, 19} ,{119, 166, 99, 19} ,{119, 166, 100, 19} ,{119, 166, 101, 19} ,{119, 166, 102, 19} ,{119, 166, 253, 5} ,{119, 166, 103, 19} ,{119, 166, 104, 19} ,{119, 166, 105, 19} ,{119, 166, 106, 19} ,{119, 166, 107, 19} ,{119, 166, 108, 19} ,{119, 166, 109, 19} ,{119, 166, 134, 3} ,{119, 166, 110, 19} ,{119, 166, 111, 19} ,{119, 166, 112, 19} ,{119, 166, 113, 19} ,{119, 166, 114, 19} ,{119, 166, 115, 19} ,{119, 166, 116, 19} ,{119, 166, 212, 4} ,{119, 166, 117, 19} ,{119, 166, 118, 19} ,{119, 166, 0, 6} ,{119, 166, 119, 19} ,{119, 166, 120, 19} ,{119, 166, 121, 19} ,{119, 166, 157, 4} ,{119, 166, 122, 19} ,{119, 166, 123, 19} ,{119, 166, 124, 19} ,{119, 166, 125, 19} ,{119, 166, 126, 19} ,{119, 166, 120, 8} ,{119, 166, 127, 19} ,{119, 166, 128, 19} ,{119, 166, 129, 19} ,{119, 166, 130, 19} ,{119, 166, 131, 19} ,{119, 166, 160, 6} ,{119, 166, 132, 19} ,{119, 166, 133, 19} ,{119, 166, 134, 19} ,{119, 166, 135, 19} ,{119, 166, 136, 19} ,{119, 166, 137, 19} ,{119, 166, 138, 19} ,{119, 166, 200, 3} ,{119, 166, 139, 19} ,{119, 166, 140, 19} ,{119, 166, 141, 19} ,{119, 166, 142, 19} ,{119, 166, 143, 19} ,{119, 166, 144, 19} ,{119, 166, 145, 19} ,{119, 166, 164, 6} ,{119, 166, 146, 19} ,{119, 166, 147, 19} ,{119, 166, 148, 19} ,{119, 166, 163, 6} ,{119, 166, 149, 19} ,{119, 166, 150, 19} ,{119, 166, 151, 19} ,{119, 166, 159, 6} ,{119, 166, 152, 19} ,{119, 166, 153, 19} ,{119, 166, 154, 19} ,{119, 166, 155, 19} ,{119, 166, 156, 19} ,{119, 166, 103, 6} ,{119, 166, 157, 19} ,{119, 166, 158, 19} ,{119, 166, 159, 19} ,{119, 166, 160, 19} ,{119, 166, 161, 19} ,{119, 166, 162, 19} ,{119, 166, 154, 1} ,{119, 166, 163, 19} ,{119, 166, 164, 19} ,{119, 166, 165, 19} ,{119, 166, 166, 19} ,{119, 166, 167, 19} ,{119, 166, 168, 19} ,{119, 166, 194, 4} ,{119, 166, 169, 19} ,{119, 166, 170, 19} ,{119, 166, 171, 19} ,{119, 166, 106, 6} ,{119, 166, 172, 19} ,{119, 166, 173, 19} ,{119, 166, 174, 19} ,{119, 166, 102, 6} ,{119, 166, 175, 19} ,{119, 166, 176, 19} ,{119, 166, 177, 19} ,{119, 166, 178, 19} ,{119, 166, 179, 19} ,{119, 166, 172, 6} ,{119, 166, 180, 19} ,{119, 166, 181, 19} ,{119, 166, 182, 19} ,{119, 166, 183, 19} ,{119, 166, 184, 19} ,{119, 166, 236, 3} ,{119, 166, 185, 19} ,{119, 166, 186, 19} ,{119, 166, 187, 19} ,{119, 166, 188, 19} ,{119, 166, 189, 19} ,{119, 166, 190, 19} ,{119, 166, 191, 19} ,{119, 166, 176, 6} ,{119, 166, 192, 19} ,{119, 166, 193, 19} ,{119, 166, 194, 19} ,{119, 166, 175, 6} ,{119, 166, 195, 19} ,{119, 166, 196, 19} ,{119, 166, 197, 19} ,{119, 166, 171, 6} ,{119, 166, 198, 19} ,{119, 166, 199, 19} ,{119, 166, 200, 19} ,{119, 166, 201, 19} ,{119, 166, 202, 19} ,{119, 166, 203, 19} ,{119, 166, 204, 19} ,{119, 166, 205, 19} ,{119, 166, 206, 19} ,{119, 166, 207, 19} ,{119, 166, 208, 19} ,{119, 166, 209, 19} ,{119, 166, 210, 19} ,{119, 166, 211, 19} ,{119, 166, 239, 4} ,{119, 166, 212, 19} ,{119, 166, 213, 19} ,{119, 166, 214, 19} ,{119, 166, 215, 19} ,{119, 166, 216, 19} ,{119, 166, 217, 19} ,{119, 166, 218, 19} ,{119, 166, 219, 19} ,{119, 166, 220, 19} ,{119, 166, 221, 19} ,{119, 166, 222, 19} ,{119, 166, 223, 19} ,{119, 166, 224, 19} ,{119, 166, 225, 19} ,{119, 166, 226, 19} ,{119, 166, 227, 19} ,{119, 166, 228, 19} ,{119, 166, 229, 19} ,{119, 166, 230, 19} ,{119, 166, 231, 19} ,{119, 166, 232, 19} ,{119, 166, 233, 19} ,{119, 166, 234, 19} ,{119, 166, 235, 19} ,{119, 166, 236, 19} ,{119, 166, 237, 19} ,{119, 166, 238, 19} ,{119, 166, 239, 19} ,{119, 166, 240, 19} ,{119, 166, 241, 19} ,{119, 166, 242, 19} ,{119, 166, 243, 19} ,{119, 166, 244, 19} ,{119, 166, 245, 19} ,{119, 166, 246, 19} ,{119, 166, 247, 19} ,{119, 166, 248, 19} ,{119, 166, 249, 19} ,{119, 166, 202, 3} ,{119, 166, 250, 19} ,{119, 166, 251, 19} ,{119, 166, 252, 19} ,{119, 166, 253, 19} ,{119, 166, 254, 19} ,{119, 166, 255, 19} ,{119, 166, 197, 4} ,{119, 166, 0, 20} ,{119, 166, 1, 20} ,{119, 166, 2, 20} ,{119, 166, 3, 20} ,{119, 166, 4, 20} ,{119, 166, 5, 20} ,{119, 166, 163, 5} ,{119, 166, 8, 15} ,{119, 166, 6, 20} ,{119, 166, 163, 1} ,{119, 166, 7, 20} ,{119, 166, 8, 20} ,{119, 166, 9, 20} ,{119, 166, 10, 20} ,{119, 166, 11, 20} ,{119, 166, 12, 20} ,{119, 166, 13, 20} ,{119, 166, 243, 1} ,{119, 166, 14, 20} ,{119, 166, 15, 20} ,{119, 166, 86, 2} ,{119, 166, 16, 20} ,{119, 166, 17, 20} ,{119, 166, 18, 20} ,{119, 166, 140, 3} ,{119, 166, 19, 20} ,{119, 166, 20, 20} ,{119, 166, 21, 20} ,{119, 166, 22, 20} ,{119, 166, 23, 20} ,{119, 166, 206, 4} ,{119, 166, 24, 20} ,{119, 166, 25, 20} ,{119, 166, 226, 1} ,{119, 166, 26, 20} ,{119, 166, 27, 20} ,{119, 166, 28, 20} ,{119, 166, 130, 6} ,{119, 166, 29, 20} ,{119, 166, 30, 20} ,{119, 166, 31, 20} ,{119, 166, 32, 20} ,{119, 166, 33, 20} ,{119, 166, 34, 20} ,{119, 166, 234, 1} ,{119, 166, 35, 20} ,{119, 166, 36, 20} ,{119, 166, 37, 20} ,{119, 166, 38, 20} ,{119, 166, 39, 20} ,{119, 166, 40, 20} ,{119, 166, 107, 3} ,{119, 166, 41, 20} ,{119, 166, 42, 20} ,{119, 166, 153, 1} ,{119, 166, 43, 20} ,{119, 166, 44, 20} ,{119, 166, 45, 20} ,{119, 166, 129, 6} ,{119, 166, 46, 20} ,{119, 166, 47, 20} ,{119, 166, 48, 20} ,{119, 166, 49, 20} ,{119, 166, 50, 20} ,{119, 166, 51, 20} ,{119, 166, 52, 20} ,{119, 166, 53, 20} ,{119, 166, 54, 20} ,{119, 166, 55, 20} ,{119, 166, 56, 20} ,{119, 166, 75, 6} ,{119, 166, 57, 20} ,{119, 166, 58, 20} ,{119, 166, 59, 20} ,{119, 166, 60, 20} ,{119, 166, 61, 20} ,{119, 166, 62, 20} ,{119, 166, 63, 20} ,{119, 166, 241, 1} ,{119, 166, 44, 11} ,{119, 166, 64, 20} ,{119, 166, 65, 20} ,{119, 166, 66, 20} ,{119, 166, 67, 20} ,{119, 166, 68, 20} ,{119, 166, 2, 2} ,{119, 166, 69, 20} ,{119, 166, 70, 20} ,{119, 166, 78, 6} ,{119, 166, 71, 20} ,{119, 166, 72, 20} ,{119, 166, 73, 20} ,{119, 166, 74, 6} ,{119, 166, 45, 11} ,{119, 166, 74, 20} ,{119, 166, 75, 20} ,{119, 166, 76, 20} ,{119, 166, 77, 20} ,{119, 166, 78, 20} ,{119, 166, 79, 20} ,{119, 166, 80, 20} ,{119, 166, 81, 20} ,{119, 166, 82, 20} ,{119, 166, 83, 20} ,{119, 166, 102, 15} ,{119, 166, 84, 20} ,{119, 166, 85, 20} ,{119, 166, 86, 20} ,{119, 166, 87, 20} ,{119, 166, 88, 20} ,{119, 166, 89, 20} ,{119, 166, 90, 20} ,{119, 166, 100, 15} ,{119, 166, 91, 20} ,{119, 166, 92, 20} ,{119, 166, 106, 15} ,{119, 166, 93, 20} ,{119, 166, 94, 20} ,{119, 166, 105, 15} ,{119, 166, 95, 20} ,{119, 166, 96, 20} ,{119, 166, 101, 15} ,{119, 166, 97, 20} ,{119, 166, 98, 20} ,{119, 166, 99, 20} ,{119, 166, 100, 20} ,{119, 166, 101, 20} ,{119, 166, 102, 20} ,{119, 166, 103, 20} ,{119, 166, 104, 20} ,{119, 166, 105, 20} ,{119, 166, 106, 20} ,{119, 166, 107, 20} ,{119, 166, 108, 20} ,{119, 166, 109, 20} ,{119, 166, 110, 20} ,{119, 166, 111, 20} ,{119, 166, 112, 20} ,{119, 166, 113, 20} ,{119, 166, 114, 20} ,{119, 166, 115, 20} ,{119, 166, 116, 20} ,{119, 166, 117, 20} ,{119, 166, 118, 20} ,{119, 166, 119, 20} ,{119, 166, 120, 20} ,{119, 166, 121, 20} ,{119, 166, 122, 20} ,{119, 166, 123, 20} ,{119, 166, 124, 20} ,{119, 166, 125, 20} ,{119, 166, 126, 20} ,{119, 166, 127, 20} ,{119, 166, 128, 20} ,{119, 166, 129, 20} ,{119, 166, 130, 20} ,{119, 166, 131, 20} ,{119, 166, 132, 20} ,{119, 166, 133, 20} ,{119, 166, 134, 20} ,{119, 166, 29, 0} ,{119, 166, 27, 6} ,{119, 166, 135, 20} ,{119, 166, 136, 20} ,{119, 166, 137, 20} ,{119, 166, 138, 20} ,{119, 166, 21, 9} ,{119, 166, 139, 20} ,{119, 166, 131, 3} ,{119, 166, 140, 20} ,{119, 166, 141, 20} ,{119, 166, 142, 20} ,{119, 166, 143, 20} ,{119, 166, 144, 20} ,{119, 166, 145, 20} ,{119, 166, 122, 4} ,{119, 166, 146, 20} ,{119, 166, 147, 20} ,{119, 166, 30, 6} ,{119, 166, 148, 20} ,{119, 166, 149, 20} ,{119, 166, 150, 20} ,{119, 166, 26, 6} ,{119, 166, 151, 20} ,{119, 166, 152, 20} ,{119, 166, 153, 20} ,{119, 166, 154, 20} ,{119, 166, 155, 20} ,{119, 166, 156, 20} ,{119, 166, 157, 20} ,{119, 166, 158, 20} ,{119, 166, 159, 20} ,{119, 166, 160, 20} ,{119, 166, 161, 20} ,{119, 166, 89, 15} ,{119, 166, 162, 20} ,{119, 166, 163, 20} ,{119, 166, 164, 20} ,{119, 166, 165, 20} ,{119, 166, 166, 20} ,{119, 166, 167, 20} ,{119, 166, 217, 3} ,{119, 166, 168, 20} ,{119, 166, 169, 20} ,{119, 166, 170, 20} ,{119, 166, 113, 8} ,{119, 166, 171, 20} ,{119, 166, 172, 20} ,{119, 166, 92, 15} ,{119, 166, 173, 20} ,{119, 166, 174, 20} ,{119, 166, 175, 20} ,{119, 166, 88, 15} ,{119, 166, 176, 20} ,{119, 166, 177, 20} ,{119, 166, 178, 20} ,{119, 166, 179, 20} ,{119, 166, 180, 20} ,{119, 166, 181, 20} ,{119, 166, 182, 20} ,{119, 166, 183, 20} ,{119, 166, 184, 20} ,{119, 166, 234, 3} ,{119, 166, 185, 20} ,{119, 166, 186, 20} ,{119, 166, 187, 20} ,{119, 166, 188, 20} ,{119, 166, 189, 20} ,{119, 166, 190, 20} ,{119, 166, 137, 6} ,{119, 166, 191, 20} ,{119, 166, 192, 20} ,{119, 166, 193, 20} ,{119, 166, 152, 1} ,{119, 166, 194, 20} ,{119, 166, 195, 20} ,{119, 166, 196, 20} ,{119, 166, 133, 6} ,{119, 166, 197, 20} ,{119, 166, 198, 20} ,{119, 166, 199, 20} ,{119, 166, 200, 20} ,{119, 166, 201, 20} ,{119, 166, 202, 20} ,{119, 166, 203, 20} ,{119, 166, 204, 20} ,{119, 166, 205, 20} ,{119, 166, 206, 20} ,{119, 166, 207, 20} ,{119, 166, 250, 1} ,{119, 166, 208, 20} ,{119, 166, 209, 20} ,{119, 166, 210, 20} ,{119, 166, 211, 20} ,{119, 166, 212, 20} ,{119, 166, 213, 20} ,{119, 166, 214, 20} ,{119, 166, 186, 6} ,{119, 166, 215, 20} ,{119, 166, 216, 20} ,{119, 166, 217, 20} ,{119, 166, 165, 1} ,{119, 166, 218, 20} ,{119, 166, 219, 20} ,{119, 166, 183, 6} ,{119, 166, 220, 20} ,{119, 166, 221, 20} ,{119, 166, 222, 20} ,{119, 166, 223, 20} ,{119, 166, 224, 20} ,{119, 166, 225, 20} ,{119, 166, 226, 20} ,{119, 166, 227, 20} ,{119, 166, 228, 20} ,{119, 166, 229, 20} ,{119, 166, 130, 3} ,{119, 166, 230, 20} ,{119, 166, 231, 20} ,{119, 166, 232, 20} ,{119, 166, 233, 20} ,{119, 166, 234, 20} ,{119, 166, 235, 20} ,{119, 166, 236, 20} ,{119, 166, 237, 20} ,{119, 166, 238, 20} ,{119, 166, 239, 20} ,{119, 166, 240, 20} ,{119, 166, 241, 20} ,{119, 166, 242, 20} ,{119, 166, 243, 20} ,{119, 166, 244, 20} ,{119, 166, 245, 20} ,{119, 166, 246, 20} ,{119, 166, 247, 20} ,{119, 166, 248, 20} ,{119, 166, 249, 20} ,{119, 166, 250, 20} ,{119, 166, 251, 20} ,{119, 166, 252, 20} ,{119, 166, 253, 20} ,{119, 166, 7, 9} ,{119, 166, 254, 20} ,{119, 166, 255, 20} ,{119, 166, 0, 21} ,{119, 166, 1, 21} ,{119, 166, 2, 21} ,{119, 166, 3, 21} ,{119, 166, 4, 21} ,{119, 166, 5, 21} ,{119, 166, 6, 21} ,{119, 166, 7, 21} ,{119, 166, 8, 21} ,{119, 166, 9, 21} ,{119, 166, 10, 21} ,{119, 166, 11, 21} ,{119, 166, 12, 21} ,{119, 166, 13, 21} ,{119, 166, 14, 21} ,{119, 166, 15, 21} ,{119, 166, 16, 21} ,{119, 166, 17, 21} ,{119, 166, 18, 21} ,{119, 166, 19, 21} ,{119, 166, 166, 1} ,{119, 166, 20, 21} ,{119, 166, 21, 21} ,{119, 166, 22, 21} ,{119, 166, 23, 21} ,{119, 166, 24, 21} ,{119, 166, 25, 21} ,{119, 166, 130, 1} ,{119, 166, 26, 21} ,{119, 166, 27, 21} ,{119, 166, 28, 21} ,{119, 166, 36, 6} ,{119, 166, 29, 21} ,{119, 166, 30, 21} ,{119, 166, 31, 21} ,{119, 166, 32, 6} ,{119, 166, 32, 21} ,{119, 166, 33, 21} ,{119, 166, 34, 21} ,{119, 166, 35, 21} ,{119, 166, 36, 21} ,{119, 166, 37, 21} ,{119, 166, 38, 21} ,{119, 166, 39, 21} ,{119, 166, 40, 21} ,{119, 166, 101, 16} ,{119, 166, 41, 21} ,{119, 166, 253, 1} ,{119, 166, 172, 15} ,{119, 166, 42, 21} ,{119, 166, 43, 21} ,{119, 166, 44, 21} ,{119, 166, 45, 21} ,{119, 166, 46, 21} ,{119, 166, 46, 5} ,{119, 166, 47, 21} ,{119, 166, 48, 21} ,{119, 166, 24, 6} ,{119, 166, 49, 21} ,{119, 166, 50, 21} ,{119, 166, 51, 21} ,{119, 166, 154, 4} ,{119, 166, 52, 21} ,{119, 166, 53, 21} ,{119, 166, 54, 21} ,{119, 166, 55, 21} ,{119, 166, 56, 21} ,{119, 166, 118, 8} ,{119, 166, 57, 21} ,{119, 166, 58, 21} ,{119, 166, 59, 21} ,{119, 166, 60, 21} ,{119, 166, 61, 21} ,{119, 166, 154, 6} ,{119, 166, 62, 21} ,{119, 166, 63, 21} ,{119, 166, 64, 21} ,{119, 166, 65, 21} ,{119, 166, 66, 21} ,{119, 166, 67, 21} ,{119, 166, 68, 21} ,{119, 166, 69, 21} ,{119, 166, 70, 21} ,{119, 166, 133, 11} ,{119, 166, 71, 21} ,{119, 166, 157, 6} ,{119, 166, 72, 21} ,{119, 166, 73, 21} ,{119, 166, 74, 21} ,{119, 166, 153, 6} ,{119, 166, 75, 21} ,{119, 166, 76, 21} ,{119, 166, 77, 21} ,{119, 166, 78, 21} ,{119, 166, 79, 21} ,{119, 166, 80, 21} ,{119, 166, 81, 21} ,{119, 166, 82, 21} ,{119, 166, 83, 21} ,{119, 166, 84, 21} ,{119, 166, 85, 21} ,{119, 166, 39, 6} ,{119, 166, 86, 21} ,{119, 166, 87, 21} ,{119, 166, 88, 21} ,{119, 166, 89, 21} ,{119, 166, 90, 21} ,{119, 166, 91, 21} ,{119, 166, 92, 21} ,{119, 166, 5, 7} ,{119, 166, 93, 21} ,{119, 166, 94, 21} ,{119, 166, 95, 21} ,{119, 166, 43, 6} ,{119, 166, 96, 21} ,{119, 166, 97, 21} ,{119, 166, 98, 21} ,{119, 166, 38, 6} ,{119, 166, 99, 21} ,{119, 166, 100, 21} ,{119, 166, 101, 21} ,{119, 166, 102, 21} ,{119, 166, 103, 21} ,{119, 166, 104, 21} ,{119, 166, 105, 21} ,{119, 166, 106, 21} ,{119, 166, 107, 21} ,{119, 166, 108, 21} ,{119, 166, 109, 21} ,{119, 166, 212, 7} ,{119, 166, 110, 21} ,{119, 166, 111, 21} ,{119, 166, 112, 21} ,{119, 166, 113, 21} ,{119, 166, 114, 21} ,{119, 166, 115, 21} ,{119, 166, 116, 21} ,{119, 166, 117, 21} ,{119, 166, 118, 21} ,{119, 166, 119, 21} ,{119, 166, 209, 7} ,{119, 166, 120, 21} ,{119, 166, 121, 21} ,{119, 166, 122, 21} ,{119, 166, 208, 7} ,{119, 166, 123, 21} ,{119, 166, 124, 21} ,{119, 166, 125, 21} ,{119, 166, 126, 21} ,{119, 166, 127, 21} ,{119, 166, 128, 21} ,{119, 166, 129, 21} ,{119, 166, 130, 21} ,{119, 166, 131, 21} ,{119, 166, 132, 21} ,{119, 166, 133, 21} ,{119, 166, 134, 21} ,{119, 166, 135, 21} ,{119, 166, 136, 21} ,{119, 166, 137, 21} ,{119, 166, 138, 21} ,{119, 166, 139, 21} ,{119, 166, 140, 21} ,{119, 166, 141, 21} ,{119, 166, 142, 21} ,{119, 166, 143, 21} ,{119, 166, 144, 21} ,{119, 166, 145, 21} ,{119, 166, 146, 21} ,{119, 166, 147, 21} ,{119, 166, 148, 21} ,{119, 166, 149, 21} ,{119, 166, 150, 21} ,{119, 166, 151, 21} ,{119, 166, 152, 21} ,{119, 166, 153, 21} ,{119, 166, 154, 21} ,{119, 166, 155, 21} ,{119, 166, 156, 21} ,{119, 166, 97, 6} ,{119, 166, 157, 21} ,{119, 166, 158, 21} ,{119, 166, 159, 21} ,{119, 166, 160, 21} ,{119, 166, 161, 21} ,{119, 166, 162, 21} ,{119, 166, 163, 21} ,{119, 166, 164, 21} ,{119, 166, 165, 21} ,{119, 166, 166, 21} ,{119, 166, 198, 4} ,{119, 166, 167, 21} ,{119, 166, 168, 21} ,{119, 166, 169, 21} ,{119, 166, 96, 6} ,{119, 166, 170, 21} ,{119, 166, 171, 21} ,{119, 166, 172, 21} ,{119, 166, 102, 1} ,{119, 166, 173, 21} ,{119, 166, 174, 21} ,{119, 166, 175, 21} ,{119, 166, 176, 21} ,{119, 166, 177, 21} ,{119, 166, 178, 21} ,{119, 166, 179, 21} ,{119, 166, 180, 21} ,{119, 166, 181, 21} ,{119, 166, 85, 6} ,{119, 166, 182, 21} ,{119, 166, 183, 21} ,{119, 166, 184, 21} ,{119, 166, 185, 21} ,{119, 166, 186, 21} ,{119, 166, 187, 21} ,{119, 166, 188, 21} ,{119, 166, 189, 21} ,{119, 166, 190, 21} ,{119, 166, 141, 1} ,{119, 166, 191, 21} ,{119, 166, 192, 21} ,{119, 166, 193, 21} ,{119, 166, 194, 21} ,{119, 166, 195, 21} ,{119, 166, 196, 21} ,{119, 166, 197, 21} ,{119, 166, 198, 21} ,{119, 166, 199, 21} ,{119, 166, 129, 1} ,{119, 166, 200, 21} ,{119, 166, 204, 4} ,{119, 166, 201, 21} ,{119, 166, 160, 3} ,{119, 166, 202, 21} ,{119, 166, 170, 1} ,{119, 166, 203, 21} ,{119, 166, 204, 21} ,{119, 166, 205, 21} ,{119, 166, 206, 21} ,{119, 166, 207, 21} ,{119, 166, 209, 4} ,{119, 166, 208, 21} ,{119, 166, 209, 21} ,{119, 166, 210, 21} ,{246, 166, 94, 21} ,{246, 166, 253, 5} ,{246, 166, 155, 19} ,{246, 166, 157, 21} ,{246, 166, 79, 20} ,{246, 166, 89, 15} ,{246, 166, 192, 19} ,{246, 166, 149, 19} ,{246, 166, 9, 6} ,{246, 166, 222, 19} ,{246, 166, 129, 19} ,{246, 166, 67, 18} ,{246, 166, 148, 18} ,{246, 166, 204, 4} ,{246, 166, 36, 18} ,{246, 166, 236, 19} ,{246, 166, 225, 18} ,{246, 166, 200, 3} ,{246, 166, 46, 20} ,{246, 166, 76, 20} ,{246, 166, 6, 19} ,{246, 166, 15, 18} ,{246, 166, 188, 19} ,{246, 166, 167, 21} ,{246, 166, 70, 6} ,{246, 166, 249, 17} ,{246, 166, 121, 21} ,{246, 166, 39, 20} ,{246, 166, 41, 18} ,{246, 166, 120, 18} ,{246, 166, 189, 21} ,{246, 166, 194, 18} ,{246, 166, 37, 21} ,{246, 166, 189, 18} ,{246, 166, 234, 1} ,{246, 166, 157, 6} ,{246, 166, 125, 20} ,{246, 166, 128, 21} ,{246, 166, 144, 19} ,{246, 166, 113, 21} ,{246, 166, 206, 4} ,{246, 166, 141, 6} ,{246, 166, 34, 21} ,{246, 166, 106, 19} ,{246, 166, 78, 20} ,{246, 166, 66, 20} ,{246, 166, 57, 20} ,{246, 166, 241, 19} ,{246, 166, 18, 21} ,{246, 166, 48, 20} ,{246, 166, 26, 21} ,{246, 166, 165, 1} ,{246, 166, 85, 20} ,{246, 166, 82, 18} ,{246, 166, 106, 6} ,{49, 167, 127, 3} ,{49, 167, 128, 3} ,{49, 167, 212, 3} ,{49, 167, 232, 1} ,{49, 167, 129, 3} ,{49, 167, 209, 3} ,{49, 167, 200, 3} ,{49, 167, 154, 1} ,{49, 167, 199, 3} ,{49, 167, 244, 1} ,{49, 167, 241, 1} ,{49, 167, 250, 1} ,{49, 167, 25, 4} ,{49, 167, 24, 4} ,{49, 167, 37, 5} ,{49, 167, 137, 3} ,{49, 167, 139, 3} ,{49, 167, 134, 3} ,{49, 167, 131, 3} ,{49, 167, 234, 3} ,{49, 167, 234, 1} ,{49, 167, 202, 3} ,{49, 167, 163, 1} ,{49, 167, 80, 6} ,{49, 167, 2, 6} ,{49, 167, 133, 3} ,{49, 167, 140, 3} ,{49, 167, 166, 1} ,{49, 167, 171, 1} ,{49, 167, 201, 3} ,{49, 167, 45, 0} ,{49, 167, 133, 0} ,{49, 167, 49, 0} ,{49, 167, 110, 5} ,{49, 167, 53, 0} ,{49, 167, 59, 0} ,{49, 167, 65, 0} ,{49, 167, 174, 4} ,{49, 167, 212, 21} ,{49, 167, 164, 0} ,{238, 170, 215, 4} ,{85, 183, 202, 4} ,{238, 170, 184, 8} ,{238, 170, 201, 4} ,{238, 170, 139, 3} ,{238, 170, 214, 21} ,{10, 177, 16, 0} ,{10, 177, 241, 37} ,{155, 166, 124, 3} ,{155, 166, 216, 21} ,{155, 166, 251, 5} ,{155, 166, 127, 6} ,{155, 166, 217, 21} ,{155, 166, 214, 6} ,{155, 166, 218, 21} ,{155, 166, 63, 6} ,{155, 166, 219, 21} ,{155, 166, 220, 21} ,{155, 166, 221, 21} ,{155, 166, 222, 21} ,{155, 166, 209, 6} ,{155, 166, 68, 6} ,{155, 166, 72, 6} ,{155, 166, 180, 6} ,{155, 166, 223, 21} ,{155, 166, 224, 21} ,{155, 166, 255, 5} ,{155, 166, 23, 6} ,{155, 166, 144, 6} ,{155, 166, 225, 21} ,{155, 166, 29, 6} ,{155, 166, 35, 6} ,{155, 166, 131, 6} ,{155, 166, 136, 6} ,{155, 166, 77, 6} ,{155, 166, 156, 6} ,{155, 166, 226, 21} ,{155, 166, 139, 6} ,{155, 166, 105, 6} ,{155, 166, 227, 21} ,{155, 166, 162, 6} ,{155, 166, 11, 6} ,{155, 166, 93, 6} ,{155, 166, 99, 6} ,{155, 166, 53, 0} ,{155, 166, 164, 3} ,{155, 166, 250, 5} ,{155, 166, 228, 21} ,{155, 166, 230, 5} ,{155, 166, 229, 21} ,{155, 166, 104, 1} ,{155, 166, 230, 21} ,{155, 166, 62, 6} ,{155, 166, 231, 21} ,{155, 166, 232, 21} ,{155, 166, 233, 21} ,{155, 166, 234, 21} ,{155, 166, 165, 3} ,{155, 166, 66, 6} ,{155, 166, 215, 4} ,{155, 166, 179, 6} ,{155, 166, 235, 21} ,{155, 166, 236, 21} ,{155, 166, 253, 5} ,{155, 166, 22, 6} ,{155, 166, 142, 6} ,{155, 166, 9, 19} ,{155, 166, 27, 6} ,{155, 166, 33, 6} ,{155, 166, 130, 6} ,{155, 166, 134, 6} ,{155, 166, 75, 6} ,{155, 166, 154, 6} ,{155, 166, 132, 21} ,{155, 166, 141, 1} ,{155, 166, 103, 6} ,{155, 166, 237, 21} ,{155, 166, 160, 6} ,{155, 166, 9, 6} ,{155, 166, 92, 6} ,{155, 166, 97, 6} ,{155, 166, 45, 0} ,{155, 166, 137, 5} ,{155, 166, 238, 21} ,{155, 166, 163, 1} ,{155, 166, 239, 21} ,{155, 166, 140, 3} ,{155, 166, 240, 21} ,{155, 166, 128, 3} ,{155, 166, 213, 3} ,{155, 166, 127, 3} ,{155, 166, 241, 21} ,{155, 166, 129, 17} ,{155, 166, 242, 21} ,{155, 166, 243, 21} ,{155, 166, 132, 3} ,{155, 166, 133, 3} ,{155, 166, 216, 3} ,{155, 166, 129, 3} ,{155, 166, 209, 3} ,{155, 166, 210, 3} ,{155, 166, 244, 21} ,{155, 166, 134, 3} ,{155, 166, 253, 1} ,{155, 166, 232, 1} ,{155, 166, 15, 19} ,{155, 166, 131, 3} ,{155, 166, 166, 1} ,{155, 166, 234, 1} ,{155, 166, 234, 3} ,{155, 166, 241, 1} ,{155, 166, 244, 1} ,{155, 166, 245, 21} ,{155, 166, 171, 1} ,{155, 166, 154, 1} ,{155, 166, 208, 4} ,{155, 166, 246, 21} ,{155, 166, 200, 3} ,{155, 166, 137, 3} ,{155, 166, 139, 3} ,{155, 166, 138, 3} ,{155, 166, 125, 3} ,{155, 166, 247, 21} ,{155, 166, 160, 7} ,{155, 166, 28, 7} ,{155, 166, 248, 21} ,{155, 166, 36, 7} ,{155, 166, 249, 21} ,{155, 166, 250, 21} ,{155, 166, 251, 21} ,{155, 166, 252, 21} ,{155, 166, 253, 21} ,{155, 166, 254, 21} ,{155, 166, 144, 7} ,{155, 166, 255, 21} ,{155, 166, 43, 7} ,{155, 166, 148, 7} ,{155, 166, 0, 22} ,{155, 166, 1, 22} ,{155, 166, 92, 7} ,{155, 166, 140, 7} ,{155, 166, 2, 22} ,{155, 166, 3, 22} ,{155, 166, 101, 7} ,{155, 166, 119, 7} ,{155, 166, 4, 22} ,{155, 166, 5, 22} ,{155, 166, 66, 7} ,{155, 166, 6, 22} ,{155, 166, 7, 22} ,{155, 166, 129, 7} ,{155, 166, 54, 7} ,{155, 166, 8, 22} ,{155, 166, 9, 22} ,{155, 166, 77, 7} ,{155, 166, 86, 7} ,{155, 166, 10, 22} ,{155, 166, 65, 0} ,{155, 166, 151, 5} ,{155, 166, 249, 5} ,{155, 166, 11, 22} ,{155, 166, 125, 6} ,{155, 166, 12, 22} ,{155, 166, 212, 6} ,{155, 166, 13, 22} ,{155, 166, 73, 5} ,{155, 166, 14, 22} ,{155, 166, 15, 22} ,{155, 166, 16, 22} ,{155, 166, 17, 22} ,{155, 166, 207, 6} ,{155, 166, 65, 6} ,{155, 166, 70, 6} ,{155, 166, 178, 6} ,{155, 166, 18, 22} ,{155, 166, 19, 22} ,{155, 166, 157, 4} ,{155, 166, 154, 4} ,{155, 166, 141, 6} ,{155, 166, 26, 19} ,{155, 166, 26, 6} ,{155, 166, 32, 6} ,{155, 166, 129, 6} ,{155, 166, 133, 6} ,{155, 166, 74, 6} ,{155, 166, 153, 6} ,{155, 166, 145, 21} ,{155, 166, 170, 1} ,{155, 166, 102, 6} ,{155, 166, 20, 22} ,{155, 166, 159, 6} ,{155, 166, 100, 1} ,{155, 166, 101, 1} ,{155, 166, 96, 6} ,{155, 166, 59, 0} ,{155, 166, 146, 5} ,{155, 166, 21, 22} ,{155, 166, 243, 1} ,{155, 166, 64, 17} ,{155, 166, 206, 4} ,{155, 166, 22, 22} ,{155, 166, 202, 4} ,{155, 166, 23, 22} ,{155, 166, 201, 4} ,{155, 166, 24, 22} ,{155, 166, 25, 22} ,{155, 166, 26, 22} ,{155, 166, 27, 22} ,{155, 166, 28, 22} ,{155, 166, 210, 6} ,{155, 166, 249, 1} ,{155, 166, 237, 1} ,{155, 166, 184, 4} ,{155, 166, 29, 22} ,{155, 166, 30, 22} ,{155, 166, 212, 4} ,{155, 166, 46, 5} ,{155, 166, 199, 4} ,{155, 166, 19, 19} ,{155, 166, 122, 4} ,{155, 166, 130, 1} ,{155, 166, 107, 3} ,{155, 166, 137, 6} ,{155, 166, 2, 2} ,{155, 166, 157, 6} ,{155, 166, 142, 21} ,{155, 166, 204, 4} ,{155, 166, 194, 4} ,{155, 166, 31, 22} ,{155, 166, 164, 6} ,{155, 166, 203, 4} ,{155, 166, 200, 4} ,{155, 166, 198, 4} ,{155, 166, 49, 0} ,{155, 166, 157, 1} ,{155, 166, 32, 22} ,{155, 166, 86, 2} ,{155, 166, 33, 22} ,{155, 166, 226, 1} ,{155, 166, 34, 22} ,{155, 166, 158, 1} ,{155, 166, 35, 22} ,{155, 166, 148, 1} ,{155, 166, 36, 22} ,{155, 166, 37, 22} ,{155, 166, 38, 22} ,{155, 166, 39, 22} ,{155, 166, 40, 22} ,{155, 166, 41, 22} ,{155, 166, 69, 3} ,{155, 166, 149, 1} ,{155, 166, 161, 1} ,{155, 166, 181, 6} ,{155, 166, 42, 22} ,{155, 166, 43, 22} ,{155, 166, 0, 6} ,{155, 166, 24, 6} ,{155, 166, 151, 1} ,{155, 166, 22, 19} ,{155, 166, 30, 6} ,{155, 166, 36, 6} ,{155, 166, 153, 1} ,{155, 166, 152, 1} ,{155, 166, 78, 6} ,{155, 166, 142, 1} ,{155, 166, 144, 1} ,{155, 166, 227, 5} ,{155, 166, 106, 6} ,{155, 166, 44, 22} ,{155, 166, 45, 22} ,{155, 166, 163, 6} ,{155, 166, 46, 22} ,{155, 166, 12, 6} ,{155, 166, 94, 6} ,{155, 166, 100, 6} ,{155, 166, 228, 2} ,{155, 166, 47, 22} ,{215, 21, 16, 0} ,{215, 21, 241, 37} ,{215, 21, 2, 38} ,{239, 170, 133, 3} ,{239, 170, 154, 1} ,{239, 170, 101, 7} ,{149, 168, 49, 22} ,{149, 168, 50, 22} ,{149, 168, 51, 22} ,{149, 168, 85, 7} ,{149, 168, 52, 22} ,{149, 168, 208, 6} ,{149, 168, 71, 6} ,{149, 168, 121, 9} ,{149, 168, 53, 22} ,{149, 168, 54, 22} ,{149, 168, 55, 22} ,{86, 183, 59, 0} ,{149, 168, 57, 22} ,{215, 21, 243, 37} ,{215, 21, 244, 37} ,{215, 21, 245, 37} ,{215, 21, 246, 37} ,{215, 21, 247, 37} ,{215, 21, 248, 37} ,{215, 21, 249, 37} ,{215, 21, 250, 37} ,{215, 21, 251, 37} ,{215, 21, 252, 37} ,{239, 170, 137, 3} ,{239, 170, 199, 4} ,{170, 166, 58, 22} ,{169, 166, 58, 22} ,{170, 166, 219, 14} ,{169, 166, 219, 14} ,{111, 173, 139, 1} ,{112, 173, 139, 1} ,{170, 166, 184, 0} ,{169, 166, 184, 0} ,{170, 166, 143, 15} ,{169, 166, 143, 15} ,{170, 166, 110, 173} ,{169, 166, 110, 173} ,{170, 166, 11, 177} ,{169, 166, 11, 177} ,{170, 166, 12, 177} ,{169, 166, 12, 177} ,{170, 166, 15, 177} ,{169, 166, 15, 177} ,{117, 170, 172, 1} ,{118, 170, 172, 1} ,{111, 173, 170, 1} ,{112, 173, 170, 1} ,{117, 170, 45, 0} ,{118, 170, 45, 0} ,{170, 166, 2, 172} ,{169, 166, 2, 172} ,{170, 166, 16, 177} ,{169, 166, 16, 177} ,{117, 170, 2, 172} ,{118, 170, 2, 172} ,{170, 166, 166, 5} ,{169, 166, 166, 5} ,{3, 172, 151, 1} ,{4, 172, 151, 1} ,{3, 172, 155, 1} ,{4, 172, 155, 1} ,{3, 172, 156, 1} ,{4, 172, 156, 1} ,{170, 166, 5, 172} ,{169, 166, 5, 172} ,{170, 166, 17, 177} ,{169, 166, 17, 177} ,{170, 166, 18, 177} ,{169, 166, 18, 177} ,{87, 183, 59, 0} ,{54, 167, 67, 22} ,{88, 183, 6, 172} ,{19, 177, 6, 172} ,{89, 183, 6, 172} ,{68, 22, 14, 0} ,{54, 167, 69, 22} ,{54, 167, 70, 22} ,{132, 1, 69, 22} ,{132, 1, 70, 22} ,{170, 166, 71, 22} ,{169, 166, 71, 22} ,{170, 166, 72, 22} ,{169, 166, 72, 22} ,{170, 166, 73, 22} ,{169, 166, 73, 22} ,{170, 166, 112, 15} ,{169, 166, 112, 15} ,{170, 166, 74, 22} ,{169, 166, 74, 22} ,{170, 166, 20, 177} ,{169, 166, 20, 177} ,{170, 166, 44, 7} ,{169, 166, 44, 7} ,{170, 166, 75, 22} ,{169, 166, 75, 22} ,{170, 166, 76, 22} ,{169, 166, 76, 22} ,{170, 166, 77, 22} ,{169, 166, 77, 22} ,{170, 166, 191, 7} ,{169, 166, 191, 7} ,{170, 166, 120, 7} ,{169, 166, 120, 7} ,{200, 166, 45, 0} ,{200, 166, 154, 1} ,{200, 166, 65, 0} ,{200, 166, 102, 6} ,{200, 166, 124, 3} ,{200, 166, 23, 6} ,{200, 166, 79, 22} ,{200, 166, 59, 0} ,{200, 166, 97, 6} ,{200, 166, 53, 0} ,{200, 166, 134, 3} ,{200, 166, 128, 3} ,{200, 166, 139, 7} ,{200, 166, 80, 22} ,{200, 166, 81, 22} ,{200, 166, 82, 22} ,{200, 166, 71, 6} ,{200, 166, 83, 22} ,{200, 166, 84, 22} ,{200, 166, 57, 0} ,{200, 166, 85, 22} ,{200, 166, 100, 1} ,{200, 166, 118, 7} ,{200, 166, 27, 6} ,{200, 166, 86, 22} ,{200, 166, 87, 22} ,{200, 166, 125, 15} ,{200, 166, 170, 19} ,{200, 166, 88, 22} ,{200, 166, 101, 1} ,{200, 166, 89, 22} ,{200, 166, 90, 22} ,{200, 166, 32, 6} ,{200, 166, 91, 22} ,{200, 166, 171, 1} ,{200, 166, 92, 22} ,{200, 166, 93, 22} ,{200, 166, 94, 22} ,{200, 166, 226, 21} ,{200, 166, 95, 22} ,{200, 166, 96, 22} ,{200, 166, 97, 22} ,{200, 166, 214, 6} ,{200, 166, 209, 6} ,{200, 166, 154, 4} ,{200, 166, 157, 4} ,{200, 166, 9, 6} ,{200, 166, 92, 6} ,{200, 166, 98, 22} ,{200, 166, 149, 5} ,{200, 166, 242, 1} ,{200, 166, 99, 22} ,{200, 166, 246, 21} ,{200, 166, 202, 3} ,{200, 166, 130, 1} ,{200, 166, 100, 22} ,{200, 166, 207, 6} ,{200, 166, 101, 22} ,{200, 166, 140, 3} ,{200, 166, 139, 3} ,{200, 166, 253, 5} ,{200, 166, 104, 1} ,{200, 166, 102, 22} ,{200, 166, 194, 4} ,{200, 166, 103, 22} ,{200, 166, 104, 22} ,{200, 166, 247, 1} ,{200, 166, 137, 3} ,{200, 166, 215, 4} ,{200, 166, 103, 6} ,{200, 166, 203, 4} ,{200, 166, 105, 22} ,{200, 166, 89, 2} ,{200, 166, 129, 17} ,{200, 166, 14, 4} ,{200, 166, 106, 22} ,{200, 166, 107, 22} ,{200, 166, 108, 22} ,{200, 166, 109, 22} ,{200, 166, 110, 22} ,{22, 177, 111, 22} ,{22, 177, 112, 22} ,{78, 22, 113, 22} ,{78, 22, 241, 37} ,{78, 22, 33, 0} ,{78, 22, 16, 0} ,{78, 22, 34, 0} ,{78, 22, 2, 38} ,{7, 172, 146, 9} ,{8, 172, 146, 9} ,{7, 172, 115, 22} ,{8, 172, 115, 22} ,{7, 172, 38, 6} ,{8, 172, 38, 6} ,{7, 172, 154, 4} ,{8, 172, 154, 4} ,{9, 172, 240, 170} ,{10, 172, 240, 170} ,{11, 172, 240, 170} ,{55, 168, 240, 170} ,{12, 172, 240, 170} ,{9, 172, 241, 170} ,{10, 172, 241, 170} ,{11, 172, 241, 170} ,{55, 168, 241, 170} ,{12, 172, 241, 170} ,{9, 172, 27, 169} ,{10, 172, 27, 169} ,{11, 172, 27, 169} ,{55, 168, 27, 169} ,{12, 172, 27, 169} ,{114, 173, 213, 168} ,{114, 173, 46, 10} ,{114, 173, 101, 64} ,{91, 183, 237, 10} ,{92, 183, 34, 1} ,{242, 170, 13, 172} ,{242, 170, 228, 37} ,{242, 170, 67, 38} ,{55, 168, 67, 38} ,{24, 177, 243, 170} ,{24, 177, 244, 170} ,{146, 166, 25, 177} ,{126, 166, 25, 177} ,{146, 166, 26, 177} ,{126, 166, 26, 177} ,{146, 166, 117, 22} ,{126, 166, 117, 22} ,{146, 166, 118, 22} ,{126, 166, 118, 22} ,{146, 166, 119, 22} ,{126, 166, 119, 22} ,{146, 166, 120, 22} ,{126, 166, 120, 22} ,{146, 166, 28, 177} ,{126, 166, 28, 177} ,{59, 167, 50, 0} ,{59, 167, 63, 0} ,{146, 166, 175, 3} ,{126, 166, 175, 3} ,{146, 166, 250, 9} ,{126, 166, 250, 9} ,{146, 166, 198, 3} ,{126, 166, 198, 3} ,{146, 166, 251, 9} ,{126, 166, 251, 9} ,{146, 166, 29, 177} ,{126, 166, 29, 177} ,{146, 166, 214, 4} ,{126, 166, 214, 4} ,{93, 183, 30, 177} ,{253, 169, 30, 177} ,{28, 169, 28, 167} ,{214, 168, 28, 167} ,{28, 169, 98, 169} ,{214, 168, 98, 169} ,{28, 169, 31, 177} ,{214, 168, 31, 177} ,{146, 166, 32, 177} ,{126, 166, 32, 177} ,{124, 168, 117, 173} ,{53, 168, 117, 173} ,{90, 167, 33, 177} ,{91, 167, 33, 177} ,{90, 167, 193, 0} ,{91, 167, 193, 0} ,{146, 166, 125, 3} ,{126, 166, 125, 3} ,{254, 169, 122, 170} ,{97, 169, 122, 170} ,{254, 169, 34, 177} ,{97, 169, 34, 177} ,{254, 169, 36, 177} ,{97, 169, 36, 177} ,{37, 177, 122, 170} ,{14, 172, 122, 170} ,{37, 177, 98, 169} ,{14, 172, 98, 169} ,{184, 168, 252, 9} ,{54, 168, 252, 9} ,{146, 166, 38, 177} ,{126, 166, 38, 177} ,{15, 172, 98, 169} ,{255, 169, 98, 169} ,{146, 166, 197, 18} ,{126, 166, 197, 18} ,{146, 166, 39, 177} ,{126, 166, 39, 177} ,{146, 166, 40, 177} ,{126, 166, 40, 177} ,{146, 166, 41, 177} ,{126, 166, 41, 177} ,{146, 166, 128, 22} ,{126, 166, 128, 22} ,{146, 166, 236, 1} ,{126, 166, 236, 1} ,{146, 166, 186, 9} ,{126, 166, 186, 9} ,{146, 166, 129, 22} ,{126, 166, 129, 22} ,{164, 166, 130, 22} ,{126, 166, 131, 22} ,{126, 166, 132, 22} ,{126, 166, 133, 22} ,{126, 166, 134, 22} ,{126, 166, 135, 22} ,{59, 167, 135, 22} ,{126, 166, 136, 22} ,{126, 166, 137, 22} ,{124, 170, 48, 0} ,{125, 170, 48, 0} ,{124, 170, 50, 0} ,{125, 170, 50, 0} ,{124, 170, 51, 0} ,{123, 170, 42, 177} ,{192, 167, 42, 177} ,{123, 170, 56, 0} ,{192, 167, 56, 0} ,{124, 170, 62, 0} ,{125, 170, 62, 0} ,{124, 170, 63, 0} ,{125, 170, 63, 0} ,{124, 170, 64, 0} ,{125, 170, 64, 0} ,{55, 168, 33, 38} ,{164, 166, 33, 0} ,{94, 183, 0, 38} ,{146, 166, 138, 22} ,{126, 166, 138, 22} ,{43, 177, 50, 0} ,{43, 177, 60, 0} ,{95, 183, 57, 0} ,{96, 183, 140, 22} ,{97, 183, 57, 0} ,{112, 167, 45, 0} ,{112, 167, 53, 0} ,{44, 177, 143, 22} ,{112, 167, 65, 0} ,{112, 167, 49, 0} ,{112, 167, 59, 0} ,{44, 177, 144, 22} ,{112, 167, 194, 4} ,{112, 167, 198, 7} ,{112, 167, 164, 6} ,{112, 167, 186, 7} ,{60, 167, 226, 168} ,{112, 167, 2, 2} ,{112, 167, 186, 6} ,{112, 167, 157, 6} ,{112, 167, 145, 22} ,{112, 167, 51, 7} ,{112, 167, 152, 7} ,{112, 167, 151, 6} ,{112, 167, 146, 22} ,{112, 167, 237, 1} ,{112, 167, 184, 4} ,{112, 167, 199, 4} ,{112, 167, 29, 22} ,{112, 167, 200, 4} ,{112, 167, 202, 4} ,{112, 167, 113, 5} ,{112, 167, 201, 4} ,{112, 167, 23, 22} ,{112, 167, 203, 4} ,{112, 167, 46, 5} ,{112, 167, 212, 4} ,{112, 167, 234, 20} ,{112, 167, 122, 4} ,{112, 167, 243, 1} ,{60, 167, 45, 177} ,{60, 167, 149, 167} ,{60, 167, 138, 167} ,{60, 167, 220, 167} ,{60, 167, 185, 168} ,{17, 172, 118, 5} ,{17, 172, 119, 5} ,{17, 172, 120, 5} ,{17, 172, 121, 5} ,{18, 172, 122, 0} ,{18, 172, 123, 0} ,{29, 169, 46, 177} ,{18, 172, 148, 22} ,{18, 172, 176, 10} ,{98, 183, 149, 22} ,{99, 183, 3, 0} ,{100, 183, 3, 0} ,{29, 169, 47, 177} ,{101, 183, 3, 0} ,{39, 167, 154, 1} ,{39, 167, 199, 3} ,{39, 167, 200, 3} ,{39, 167, 202, 3} ,{39, 167, 241, 1} ,{39, 167, 250, 1} ,{39, 167, 244, 1} ,{39, 167, 138, 3} ,{39, 167, 129, 3} ,{39, 167, 209, 3} ,{39, 167, 232, 1} ,{39, 167, 139, 3} ,{39, 167, 128, 3} ,{39, 167, 212, 3} ,{39, 167, 127, 3} ,{39, 167, 137, 3} ,{39, 167, 24, 4} ,{39, 167, 37, 5} ,{39, 167, 25, 4} ,{39, 167, 140, 3} ,{39, 167, 234, 3} ,{39, 167, 234, 1} ,{102, 183, 45, 0} ,{39, 167, 171, 1} ,{39, 167, 253, 1} ,{39, 167, 134, 3} ,{39, 167, 166, 1} ,{39, 167, 131, 3} ,{39, 167, 163, 1} ,{39, 167, 45, 0} ,{39, 167, 53, 0} ,{39, 167, 65, 0} ,{39, 167, 49, 0} ,{39, 167, 59, 0} ,{39, 167, 225, 1} ,{39, 167, 80, 6} ,{39, 167, 133, 3} ,{39, 167, 236, 3} ,{39, 167, 124, 3} ,{119, 173, 140, 3} ,{119, 173, 171, 1} ,{39, 167, 204, 3} ,{39, 167, 205, 3} ,{39, 167, 206, 3} ,{39, 167, 208, 3} ,{103, 183, 171, 1} ,{104, 183, 166, 1} ,{105, 183, 163, 1} ,{106, 183, 133, 3} ,{119, 173, 253, 1} ,{108, 183, 253, 1} ,{39, 167, 38, 1} ,{109, 183, 48, 177} ,{110, 183, 48, 177} ,{49, 177, 237, 4} ,{111, 183, 237, 4} ,{156, 22, 226, 168} ,{156, 22, 227, 168} ,{30, 167, 45, 0} ,{30, 167, 175, 3} ,{30, 167, 53, 0} ,{30, 167, 193, 3} ,{30, 167, 65, 0} ,{30, 167, 194, 3} ,{30, 167, 99, 169} ,{30, 167, 100, 169} ,{30, 167, 101, 169} ,{30, 167, 102, 169} ,{30, 167, 49, 0} ,{30, 167, 124, 3} ,{30, 167, 197, 3} ,{30, 167, 59, 0} ,{30, 167, 125, 3} ,{30, 167, 198, 3} ,{30, 167, 154, 1} ,{30, 167, 199, 3} ,{30, 167, 200, 3} ,{30, 167, 201, 3} ,{30, 167, 202, 3} ,{30, 167, 241, 1} ,{30, 167, 250, 1} ,{30, 167, 244, 1} ,{30, 167, 203, 3} ,{30, 167, 138, 3} ,{30, 167, 204, 3} ,{30, 167, 205, 3} ,{30, 167, 206, 3} ,{30, 167, 207, 3} ,{30, 167, 208, 3} ,{30, 167, 129, 3} ,{30, 167, 209, 3} ,{30, 167, 232, 1} ,{30, 167, 210, 3} ,{30, 167, 139, 3} ,{30, 167, 128, 3} ,{30, 167, 212, 3} ,{30, 167, 127, 3} ,{30, 167, 213, 3} ,{30, 167, 137, 3} ,{30, 167, 171, 1} ,{30, 167, 253, 1} ,{30, 167, 134, 3} ,{30, 167, 216, 3} ,{30, 167, 166, 1} ,{30, 167, 217, 3} ,{30, 167, 131, 3} ,{30, 167, 163, 1} ,{30, 167, 214, 3} ,{112, 183, 157, 22} ,{156, 22, 17, 168} ,{156, 22, 149, 167} ,{156, 22, 58, 168} ,{156, 22, 138, 167} ,{156, 22, 59, 168} ,{156, 22, 225, 168} ,{156, 22, 30, 169} ,{156, 22, 31, 169} ,{156, 22, 32, 169} ,{156, 22, 220, 167} ,{156, 22, 185, 169} ,{156, 22, 60, 168} ,{156, 22, 245, 167} ,{156, 22, 185, 168} ,{156, 22, 99, 168} ,{156, 22, 228, 168} ,{156, 22, 232, 3} ,{156, 22, 19, 171} ,{156, 22, 243, 37} ,{156, 22, 244, 37} ,{156, 22, 245, 37} ,{156, 22, 246, 37} ,{156, 22, 247, 37} ,{156, 22, 248, 37} ,{156, 22, 249, 37} ,{156, 22, 250, 37} ,{156, 22, 251, 37} ,{156, 22, 252, 37} ,{33, 169, 243, 37} ,{33, 169, 244, 37} ,{33, 169, 245, 37} ,{33, 169, 246, 37} ,{33, 169, 247, 37} ,{33, 169, 248, 37} ,{33, 169, 249, 37} ,{33, 169, 250, 37} ,{33, 169, 251, 37} ,{33, 169, 252, 37} ,{0, 170, 45, 0} ,{0, 170, 65, 0} ,{0, 170, 154, 1} ,{0, 170, 139, 3} ,{0, 170, 128, 3} ,{0, 170, 253, 1} ,{0, 170, 66, 6} ,{35, 1, 199, 45} ,{113, 183, 38, 1} ,{19, 172, 221, 3} ,{115, 183, 221, 3} ,{19, 172, 25, 0} ,{19, 172, 26, 0} ,{19, 172, 219, 3} ,{77, 168, 159, 22} ,{116, 183, 223, 5} ,{190, 3, 38, 10} ,{190, 3, 161, 22} ,{40, 167, 243, 37} ,{40, 167, 244, 37} ,{40, 167, 245, 37} ,{40, 167, 246, 37} ,{40, 167, 247, 37} ,{40, 167, 248, 37} ,{40, 167, 249, 37} ,{40, 167, 250, 37} ,{40, 167, 251, 37} ,{40, 167, 252, 37} ,{147, 167, 154, 1} ,{147, 167, 199, 3} ,{147, 167, 200, 3} ,{147, 167, 202, 3} ,{147, 167, 131, 3} ,{147, 167, 166, 1} ,{147, 167, 234, 1} ,{147, 167, 138, 3} ,{147, 167, 129, 3} ,{147, 167, 163, 22} ,{147, 167, 139, 3} ,{147, 167, 128, 3} ,{147, 167, 212, 3} ,{147, 167, 137, 3} ,{147, 167, 232, 1} ,{147, 167, 127, 3} ,{147, 167, 253, 1} ,{147, 167, 171, 1} ,{147, 167, 134, 3} ,{147, 167, 140, 3} ,{147, 167, 209, 3} ,{147, 167, 163, 1} ,{147, 167, 216, 3} ,{147, 167, 241, 1} ,{147, 167, 45, 0} ,{147, 167, 164, 0} ,{147, 167, 53, 0} ,{147, 167, 125, 3} ,{248, 170, 174, 4} ,{248, 170, 49, 0} ,{248, 170, 65, 0} ,{248, 170, 124, 3} ,{248, 170, 59, 0} ,{120, 173, 164, 22} ,{120, 173, 165, 22} ,{117, 183, 164, 22} ,{50, 177, 68, 7} ,{50, 177, 167, 22} ,{214, 167, 154, 1} ,{214, 167, 200, 3} ,{214, 167, 202, 3} ,{214, 167, 129, 3} ,{214, 167, 232, 1} ,{214, 167, 139, 3} ,{214, 167, 128, 3} ,{214, 167, 127, 3} ,{214, 167, 137, 3} ,{214, 167, 241, 1} ,{214, 167, 244, 1} ,{214, 167, 138, 3} ,{214, 167, 131, 3} ,{214, 167, 253, 1} ,{214, 167, 134, 3} ,{214, 167, 171, 1} ,{214, 167, 140, 3} ,{214, 167, 163, 1} ,{214, 167, 241, 21} ,{214, 167, 246, 21} ,{214, 167, 15, 19} ,{214, 167, 169, 22} ,{214, 167, 45, 0} ,{168, 22, 149, 167} ,{168, 22, 138, 167} ,{168, 22, 220, 167} ,{168, 22, 60, 168} ,{168, 22, 245, 167} ,{168, 22, 99, 168} ,{51, 177, 110, 5} ,{51, 177, 170, 22} ,{20, 172, 228, 2} ,{20, 172, 58, 0} ,{20, 172, 62, 0} ,{20, 172, 52, 0} ,{168, 22, 221, 3} ,{168, 22, 71, 172} ,{126, 170, 177, 5} ,{126, 170, 178, 5} ,{126, 170, 180, 5} ,{126, 170, 183, 5} ,{150, 168, 171, 5} ,{150, 168, 172, 5} ,{150, 168, 174, 5} ,{150, 168, 175, 5} ,{150, 168, 177, 5} ,{150, 168, 178, 5} ,{150, 168, 179, 5} ,{150, 168, 200, 5} ,{150, 168, 180, 5} ,{150, 168, 183, 5} ,{150, 168, 186, 5} ,{21, 172, 171, 5} ,{21, 172, 174, 5} ,{21, 172, 180, 5} ,{249, 170, 187, 5} ,{78, 168, 186, 5} ,{78, 168, 189, 5} ,{118, 183, 178, 5} ,{186, 168, 176, 5} ,{186, 168, 189, 5} ,{119, 183, 189, 5} ,{182, 166, 173, 22} ,{52, 177, 189, 5} ,{120, 183, 180, 5} ,{182, 166, 174, 22} ,{250, 170, 176, 22} ,{250, 170, 177, 22} ,{250, 170, 178, 22} ,{250, 170, 179, 22} ,{46, 167, 45, 0} ,{121, 183, 180, 22} ,{46, 167, 53, 0} ,{46, 167, 193, 3} ,{46, 167, 65, 0} ,{55, 177, 181, 22} ,{53, 177, 182, 22} ,{122, 183, 184, 22} ,{46, 167, 49, 0} ,{46, 167, 197, 3} ,{46, 167, 59, 0} ,{46, 167, 154, 1} ,{54, 177, 102, 9} ,{54, 177, 185, 22} ,{46, 167, 200, 3} ,{123, 183, 185, 22} ,{46, 167, 202, 3} ,{46, 167, 241, 1} ,{124, 183, 185, 22} ,{46, 167, 244, 1} ,{125, 183, 185, 22} ,{126, 183, 68, 9} ,{46, 167, 138, 3} ,{46, 167, 204, 3} ,{127, 183, 68, 9} ,{46, 167, 206, 3} ,{128, 183, 68, 9} ,{129, 183, 185, 22} ,{46, 167, 129, 3} ,{130, 183, 185, 22} ,{46, 167, 232, 1} ,{131, 183, 68, 9} ,{46, 167, 139, 3} ,{46, 167, 128, 3} ,{55, 177, 185, 22} ,{46, 167, 127, 3} ,{132, 183, 185, 22} ,{46, 167, 137, 3} ,{46, 167, 171, 1} ,{46, 167, 253, 1} ,{133, 183, 188, 22} ,{46, 167, 134, 3} ,{46, 167, 140, 3} ,{56, 177, 185, 22} ,{56, 177, 68, 9} ,{46, 167, 131, 3} ,{46, 167, 163, 1} ,{134, 183, 190, 22} ,{103, 169, 191, 22} ,{103, 169, 192, 22} ,{103, 169, 193, 22} ,{135, 183, 195, 22} ,{103, 169, 93, 9} ,{136, 183, 196, 22} ,{103, 169, 96, 9} ,{137, 183, 198, 22} ,{103, 169, 98, 9} ,{121, 173, 199, 22} ,{121, 173, 200, 22} ,{121, 173, 201, 22} ,{175, 22, 202, 22} ,{138, 183, 203, 22} ,{139, 183, 203, 22} ,{187, 168, 205, 22} ,{187, 168, 206, 22} ,{187, 168, 207, 22} ,{187, 168, 111, 9} ,{187, 168, 208, 22} ,{187, 168, 209, 22} ,{187, 168, 210, 22} ,{187, 168, 101, 9} ,{187, 168, 57, 177} ,{187, 168, 211, 22} ,{141, 183, 211, 22} ,{175, 22, 212, 22} ,{175, 22, 243, 37} ,{175, 22, 244, 37} ,{175, 22, 245, 37} ,{175, 22, 246, 37} ,{175, 22, 247, 37} ,{175, 22, 248, 37} ,{175, 22, 249, 37} ,{175, 22, 250, 37} ,{175, 22, 251, 37} ,{175, 22, 252, 37} ,{142, 183, 214, 22} ,{143, 183, 216, 22} ,{12, 167, 45, 0} ,{12, 167, 53, 0} ,{12, 167, 65, 0} ,{12, 167, 49, 0} ,{12, 167, 197, 3} ,{12, 167, 59, 0} ,{12, 167, 154, 1} ,{12, 167, 199, 3} ,{12, 167, 200, 3} ,{12, 167, 201, 3} ,{12, 167, 218, 22} ,{12, 167, 202, 3} ,{12, 167, 250, 1} ,{12, 167, 219, 22} ,{12, 167, 244, 1} ,{12, 167, 203, 3} ,{12, 167, 220, 22} ,{12, 167, 221, 22} ,{12, 167, 222, 22} ,{12, 167, 129, 3} ,{12, 167, 209, 3} ,{12, 167, 232, 1} ,{12, 167, 210, 3} ,{12, 167, 223, 22} ,{12, 167, 139, 3} ,{12, 167, 206, 3} ,{12, 167, 128, 3} ,{12, 167, 224, 22} ,{12, 167, 212, 3} ,{12, 167, 127, 3} ,{12, 167, 213, 3} ,{12, 167, 225, 22} ,{12, 167, 137, 3} ,{12, 167, 239, 3} ,{12, 167, 171, 1} ,{12, 167, 253, 1} ,{12, 167, 134, 3} ,{12, 167, 216, 3} ,{12, 167, 217, 3} ,{12, 167, 131, 3} ,{12, 167, 163, 1} ,{217, 22, 17, 168} ,{217, 22, 149, 167} ,{217, 22, 58, 168} ,{122, 173, 213, 4} ,{217, 22, 138, 167} ,{122, 173, 164, 0} ,{217, 22, 245, 167} ,{217, 22, 60, 168} ,{217, 22, 99, 168} ,{122, 173, 174, 4} ,{1, 170, 171, 1} ,{1, 170, 253, 1} ,{1, 170, 134, 3} ,{1, 170, 140, 3} ,{216, 168, 55, 0} ,{216, 168, 51, 0} ,{216, 168, 228, 2} ,{123, 173, 228, 2} ,{216, 168, 136, 16} ,{216, 168, 64, 0} ,{216, 168, 58, 0} ,{216, 168, 60, 0} ,{216, 168, 69, 0} ,{216, 168, 62, 0} ,{216, 168, 56, 0} ,{216, 168, 226, 22} ,{123, 173, 57, 0} ,{123, 173, 52, 0} ,{217, 22, 243, 37} ,{217, 22, 244, 37} ,{217, 22, 245, 37} ,{217, 22, 246, 37} ,{217, 22, 247, 37} ,{217, 22, 248, 37} ,{217, 22, 249, 37} ,{217, 22, 250, 37} ,{217, 22, 251, 37} ,{217, 22, 252, 37} ,{22, 172, 227, 22} ,{22, 172, 232, 3} ,{22, 172, 19, 171} ,{144, 183, 232, 3} ,{12, 168, 200, 3} ,{12, 168, 241, 1} ,{12, 168, 250, 1} ,{12, 168, 244, 1} ,{12, 168, 203, 3} ,{12, 168, 138, 3} ,{12, 168, 204, 3} ,{12, 168, 205, 3} ,{12, 168, 206, 3} ,{12, 168, 207, 3} ,{12, 168, 210, 3} ,{12, 168, 139, 3} ,{12, 168, 131, 3} ,{12, 168, 163, 1} ,{12, 168, 2, 6} ,{12, 168, 133, 3} ,{146, 183, 228, 22} ,{12, 168, 80, 6} ,{12, 168, 234, 1} ,{12, 168, 253, 1} ,{125, 173, 244, 8} ,{125, 173, 230, 22} ,{125, 173, 231, 22} ,{126, 173, 135, 5} ,{126, 173, 24, 0} ,{126, 173, 25, 0} ,{147, 183, 253, 1} ,{149, 183, 31, 1} ,{204, 167, 194, 4} ,{205, 167, 194, 4} ,{204, 167, 198, 7} ,{205, 167, 198, 7} ,{204, 167, 234, 22} ,{205, 167, 234, 22} ,{204, 167, 164, 6} ,{205, 167, 164, 6} ,{204, 167, 197, 4} ,{205, 167, 197, 4} ,{204, 167, 2, 2} ,{205, 167, 2, 2} ,{204, 167, 186, 6} ,{205, 167, 186, 6} ,{204, 167, 122, 4} ,{205, 167, 122, 4} ,{204, 167, 198, 4} ,{205, 167, 198, 4} ,{204, 167, 199, 4} ,{205, 167, 199, 4} ,{204, 167, 237, 1} ,{205, 167, 237, 1} ,{204, 167, 184, 4} ,{205, 167, 184, 4} ,{204, 167, 200, 4} ,{205, 167, 200, 4} ,{204, 167, 201, 4} ,{205, 167, 201, 4} ,{204, 167, 202, 4} ,{205, 167, 202, 4} ,{204, 167, 113, 5} ,{205, 167, 113, 5} ,{204, 167, 210, 6} ,{205, 167, 210, 6} ,{204, 167, 203, 4} ,{205, 167, 203, 4} ,{204, 167, 204, 4} ,{205, 167, 204, 4} ,{204, 167, 46, 5} ,{205, 167, 46, 5} ,{204, 167, 212, 4} ,{205, 167, 212, 4} ,{204, 167, 249, 1} ,{205, 167, 249, 1} ,{204, 167, 243, 1} ,{205, 167, 243, 1} ,{204, 167, 59, 0} ,{205, 167, 59, 0} ,{58, 177, 24, 9} ,{151, 168, 175, 3} ,{151, 168, 53, 0} ,{151, 168, 174, 4} ,{151, 168, 65, 0} ,{151, 168, 49, 0} ,{151, 168, 59, 0} ,{58, 177, 235, 22} ,{151, 168, 236, 22} ,{151, 168, 237, 22} ,{151, 168, 127, 8} ,{151, 168, 236, 8} ,{151, 168, 214, 4} ,{151, 168, 137, 5} ,{151, 168, 173, 4} ,{23, 172, 183, 4} ,{23, 172, 238, 22} ,{23, 172, 184, 4} ,{23, 172, 239, 22} ,{251, 170, 210, 4} ,{251, 170, 238, 22} ,{251, 170, 27, 9} ,{150, 183, 240, 22} ,{151, 183, 242, 22} ,{99, 167, 245, 22} ,{99, 167, 27, 9} ,{99, 167, 17, 9} ,{99, 167, 133, 18} ,{99, 167, 128, 3} ,{99, 167, 139, 3} ,{99, 167, 246, 22} ,{99, 167, 247, 22} ,{99, 167, 248, 22} ,{99, 167, 249, 22} ,{99, 167, 250, 22} ,{99, 167, 251, 22} ,{99, 167, 105, 12} ,{99, 167, 252, 22} ,{99, 167, 151, 5} ,{99, 167, 53, 0} ,{99, 167, 253, 22} ,{99, 167, 254, 22} ,{99, 167, 255, 22} ,{99, 167, 0, 23} ,{99, 167, 1, 23} ,{99, 167, 127, 3} ,{99, 167, 157, 5} ,{99, 167, 2, 23} ,{99, 167, 3, 23} ,{99, 167, 4, 23} ,{99, 167, 5, 23} ,{152, 183, 7, 23} ,{153, 183, 7, 23} ,{154, 183, 7, 23} ,{155, 183, 7, 23} ,{156, 183, 7, 23} ,{157, 183, 7, 23} ,{158, 183, 7, 23} ,{159, 183, 7, 23} ,{187, 169, 12, 23} ,{187, 169, 13, 23} ,{187, 169, 14, 23} ,{187, 169, 15, 23} ,{187, 169, 16, 23} ,{187, 169, 17, 23} ,{187, 169, 18, 23} ,{187, 169, 19, 23} ,{244, 166, 20, 23} ,{160, 183, 22, 23} ,{161, 183, 22, 23} ,{244, 166, 243, 37} ,{244, 166, 244, 37} ,{244, 166, 245, 37} ,{244, 166, 246, 37} ,{244, 166, 247, 37} ,{244, 166, 248, 37} ,{244, 166, 249, 37} ,{244, 166, 250, 37} ,{244, 166, 251, 37} ,{244, 166, 252, 37} ,{127, 166, 45, 0} ,{95, 92, 51, 0} ,{95, 92, 230, 33} ,{95, 92, 216, 37} ,{95, 92, 58, 0} ,{95, 92, 212, 0} ,{95, 92, 89, 7} ,{95, 92, 48, 0} ,{95, 92, 56, 0} ,{95, 92, 217, 37} ,{95, 92, 151, 17} ,{95, 92, 218, 37} ,{95, 92, 219, 37} ,{95, 92, 220, 37} ,{95, 92, 221, 37} ,{95, 92, 182, 7} ,{95, 92, 57, 0} ,{95, 92, 46, 0} ,{95, 92, 222, 37} ,{95, 92, 63, 0} ,{95, 92, 226, 22} ,{95, 92, 228, 2} ,{95, 92, 54, 0} ,{95, 92, 47, 0} ,{95, 92, 55, 0} ,{95, 92, 64, 0} ,{95, 92, 60, 0} ,{95, 92, 52, 0} ,{127, 166, 133, 0} ,{123, 92, 51, 0} ,{123, 92, 230, 33} ,{123, 92, 216, 37} ,{123, 92, 58, 0} ,{123, 92, 212, 0} ,{123, 92, 89, 7} ,{123, 92, 48, 0} ,{123, 92, 56, 0} ,{123, 92, 217, 37} ,{123, 92, 151, 17} ,{123, 92, 218, 37} ,{123, 92, 219, 37} ,{123, 92, 220, 37} ,{123, 92, 221, 37} ,{123, 92, 182, 7} ,{123, 92, 57, 0} ,{123, 92, 46, 0} ,{123, 92, 222, 37} ,{123, 92, 63, 0} ,{123, 92, 226, 22} ,{123, 92, 228, 2} ,{123, 92, 54, 0} ,{123, 92, 47, 0} ,{123, 92, 55, 0} ,{123, 92, 64, 0} ,{123, 92, 60, 0} ,{123, 92, 52, 0} ,{127, 166, 171, 1} ,{151, 92, 51, 0} ,{151, 92, 230, 33} ,{151, 92, 216, 37} ,{151, 92, 58, 0} ,{151, 92, 212, 0} ,{151, 92, 89, 7} ,{151, 92, 48, 0} ,{151, 92, 56, 0} ,{151, 92, 217, 37} ,{151, 92, 151, 17} ,{151, 92, 218, 37} ,{151, 92, 219, 37} ,{151, 92, 220, 37} ,{151, 92, 221, 37} ,{151, 92, 182, 7} ,{151, 92, 57, 0} ,{151, 92, 46, 0} ,{151, 92, 222, 37} ,{151, 92, 63, 0} ,{151, 92, 226, 22} ,{151, 92, 228, 2} ,{151, 92, 54, 0} ,{151, 92, 47, 0} ,{151, 92, 55, 0} ,{151, 92, 64, 0} ,{151, 92, 60, 0} ,{151, 92, 52, 0} ,{127, 166, 224, 1} ,{179, 92, 51, 0} ,{179, 92, 230, 33} ,{179, 92, 216, 37} ,{179, 92, 58, 0} ,{179, 92, 212, 0} ,{179, 92, 89, 7} ,{179, 92, 48, 0} ,{179, 92, 56, 0} ,{179, 92, 217, 37} ,{179, 92, 151, 17} ,{179, 92, 218, 37} ,{179, 92, 219, 37} ,{179, 92, 220, 37} ,{179, 92, 221, 37} ,{179, 92, 182, 7} ,{179, 92, 57, 0} ,{179, 92, 46, 0} ,{179, 92, 222, 37} ,{179, 92, 63, 0} ,{179, 92, 226, 22} ,{179, 92, 228, 2} ,{179, 92, 54, 0} ,{179, 92, 47, 0} ,{179, 92, 55, 0} ,{179, 92, 64, 0} ,{179, 92, 60, 0} ,{179, 92, 52, 0} ,{127, 166, 225, 5} ,{207, 92, 51, 0} ,{207, 92, 230, 33} ,{207, 92, 216, 37} ,{207, 92, 58, 0} ,{207, 92, 212, 0} ,{207, 92, 89, 7} ,{207, 92, 48, 0} ,{207, 92, 56, 0} ,{207, 92, 217, 37} ,{207, 92, 151, 17} ,{207, 92, 218, 37} ,{207, 92, 219, 37} ,{207, 92, 220, 37} ,{207, 92, 221, 37} ,{207, 92, 182, 7} ,{207, 92, 57, 0} ,{207, 92, 46, 0} ,{207, 92, 222, 37} ,{207, 92, 63, 0} ,{207, 92, 226, 22} ,{207, 92, 228, 2} ,{207, 92, 54, 0} ,{207, 92, 47, 0} ,{207, 92, 55, 0} ,{207, 92, 64, 0} ,{207, 92, 60, 0} ,{207, 92, 52, 0} ,{127, 166, 49, 0} ,{235, 92, 51, 0} ,{235, 92, 230, 33} ,{235, 92, 216, 37} ,{235, 92, 58, 0} ,{235, 92, 212, 0} ,{235, 92, 89, 7} ,{235, 92, 48, 0} ,{235, 92, 56, 0} ,{235, 92, 217, 37} ,{235, 92, 151, 17} ,{235, 92, 218, 37} ,{235, 92, 219, 37} ,{235, 92, 220, 37} ,{235, 92, 221, 37} ,{235, 92, 182, 7} ,{235, 92, 57, 0} ,{235, 92, 46, 0} ,{235, 92, 222, 37} ,{235, 92, 63, 0} ,{235, 92, 226, 22} ,{235, 92, 228, 2} ,{235, 92, 54, 0} ,{235, 92, 47, 0} ,{235, 92, 55, 0} ,{235, 92, 64, 0} ,{235, 92, 60, 0} ,{235, 92, 52, 0} ,{127, 166, 226, 5} ,{7, 93, 51, 0} ,{7, 93, 230, 33} ,{7, 93, 216, 37} ,{7, 93, 58, 0} ,{7, 93, 212, 0} ,{7, 93, 89, 7} ,{7, 93, 48, 0} ,{7, 93, 56, 0} ,{7, 93, 217, 37} ,{7, 93, 151, 17} ,{7, 93, 218, 37} ,{7, 93, 219, 37} ,{7, 93, 220, 37} ,{7, 93, 221, 37} ,{7, 93, 182, 7} ,{7, 93, 57, 0} ,{7, 93, 46, 0} ,{7, 93, 222, 37} ,{7, 93, 63, 0} ,{7, 93, 226, 22} ,{7, 93, 228, 2} ,{7, 93, 54, 0} ,{7, 93, 47, 0} ,{7, 93, 55, 0} ,{7, 93, 64, 0} ,{7, 93, 60, 0} ,{7, 93, 52, 0} ,{127, 166, 227, 5} ,{35, 93, 51, 0} ,{35, 93, 230, 33} ,{35, 93, 216, 37} ,{35, 93, 58, 0} ,{35, 93, 212, 0} ,{35, 93, 89, 7} ,{35, 93, 48, 0} ,{35, 93, 56, 0} ,{35, 93, 217, 37} ,{35, 93, 151, 17} ,{35, 93, 218, 37} ,{35, 93, 219, 37} ,{35, 93, 220, 37} ,{35, 93, 221, 37} ,{35, 93, 182, 7} ,{35, 93, 57, 0} ,{35, 93, 46, 0} ,{35, 93, 222, 37} ,{35, 93, 63, 0} ,{35, 93, 226, 22} ,{35, 93, 228, 2} ,{35, 93, 54, 0} ,{35, 93, 47, 0} ,{35, 93, 55, 0} ,{35, 93, 64, 0} ,{35, 93, 60, 0} ,{35, 93, 52, 0} ,{127, 166, 59, 0} ,{63, 93, 51, 0} ,{63, 93, 230, 33} ,{63, 93, 216, 37} ,{63, 93, 58, 0} ,{63, 93, 212, 0} ,{63, 93, 89, 7} ,{63, 93, 48, 0} ,{63, 93, 56, 0} ,{63, 93, 217, 37} ,{63, 93, 151, 17} ,{63, 93, 218, 37} ,{63, 93, 219, 37} ,{63, 93, 220, 37} ,{63, 93, 221, 37} ,{63, 93, 182, 7} ,{63, 93, 57, 0} ,{63, 93, 46, 0} ,{63, 93, 222, 37} ,{63, 93, 63, 0} ,{63, 93, 226, 22} ,{63, 93, 228, 2} ,{63, 93, 54, 0} ,{63, 93, 47, 0} ,{63, 93, 55, 0} ,{63, 93, 64, 0} ,{63, 93, 60, 0} ,{63, 93, 52, 0} ,{127, 166, 140, 3} ,{91, 93, 51, 0} ,{91, 93, 230, 33} ,{91, 93, 216, 37} ,{91, 93, 58, 0} ,{91, 93, 212, 0} ,{91, 93, 89, 7} ,{91, 93, 48, 0} ,{91, 93, 56, 0} ,{91, 93, 217, 37} ,{91, 93, 151, 17} ,{91, 93, 218, 37} ,{91, 93, 219, 37} ,{91, 93, 220, 37} ,{91, 93, 221, 37} ,{91, 93, 182, 7} ,{91, 93, 57, 0} ,{91, 93, 46, 0} ,{91, 93, 222, 37} ,{91, 93, 63, 0} ,{91, 93, 226, 22} ,{91, 93, 228, 2} ,{91, 93, 54, 0} ,{91, 93, 47, 0} ,{91, 93, 55, 0} ,{91, 93, 64, 0} ,{91, 93, 60, 0} ,{91, 93, 52, 0} ,{127, 166, 228, 5} ,{119, 93, 51, 0} ,{119, 93, 230, 33} ,{119, 93, 216, 37} ,{119, 93, 58, 0} ,{119, 93, 212, 0} ,{119, 93, 89, 7} ,{119, 93, 48, 0} ,{119, 93, 56, 0} ,{119, 93, 217, 37} ,{119, 93, 151, 17} ,{119, 93, 218, 37} ,{119, 93, 219, 37} ,{119, 93, 220, 37} ,{119, 93, 221, 37} ,{119, 93, 182, 7} ,{119, 93, 57, 0} ,{119, 93, 46, 0} ,{119, 93, 222, 37} ,{119, 93, 63, 0} ,{119, 93, 226, 22} ,{119, 93, 228, 2} ,{119, 93, 54, 0} ,{119, 93, 47, 0} ,{119, 93, 55, 0} ,{119, 93, 64, 0} ,{119, 93, 60, 0} ,{119, 93, 52, 0} ,{127, 166, 164, 0} ,{147, 93, 51, 0} ,{147, 93, 230, 33} ,{147, 93, 216, 37} ,{147, 93, 58, 0} ,{147, 93, 212, 0} ,{147, 93, 89, 7} ,{147, 93, 48, 0} ,{147, 93, 56, 0} ,{147, 93, 217, 37} ,{147, 93, 151, 17} ,{147, 93, 218, 37} ,{147, 93, 219, 37} ,{147, 93, 220, 37} ,{147, 93, 221, 37} ,{147, 93, 182, 7} ,{147, 93, 57, 0} ,{147, 93, 46, 0} ,{147, 93, 222, 37} ,{147, 93, 63, 0} ,{147, 93, 226, 22} ,{147, 93, 228, 2} ,{147, 93, 54, 0} ,{147, 93, 47, 0} ,{147, 93, 55, 0} ,{147, 93, 64, 0} ,{147, 93, 60, 0} ,{147, 93, 52, 0} ,{127, 166, 204, 4} ,{175, 93, 51, 0} ,{175, 93, 230, 33} ,{175, 93, 216, 37} ,{175, 93, 58, 0} ,{175, 93, 212, 0} ,{175, 93, 89, 7} ,{175, 93, 48, 0} ,{175, 93, 56, 0} ,{175, 93, 217, 37} ,{175, 93, 151, 17} ,{175, 93, 218, 37} ,{175, 93, 219, 37} ,{175, 93, 220, 37} ,{175, 93, 221, 37} ,{175, 93, 182, 7} ,{175, 93, 57, 0} ,{175, 93, 46, 0} ,{175, 93, 222, 37} ,{175, 93, 63, 0} ,{175, 93, 226, 22} ,{175, 93, 228, 2} ,{175, 93, 54, 0} ,{175, 93, 47, 0} ,{175, 93, 55, 0} ,{175, 93, 64, 0} ,{175, 93, 60, 0} ,{175, 93, 52, 0} ,{127, 166, 65, 0} ,{203, 93, 51, 0} ,{203, 93, 230, 33} ,{203, 93, 216, 37} ,{203, 93, 58, 0} ,{203, 93, 212, 0} ,{203, 93, 89, 7} ,{203, 93, 48, 0} ,{203, 93, 56, 0} ,{203, 93, 217, 37} ,{203, 93, 151, 17} ,{203, 93, 218, 37} ,{203, 93, 219, 37} ,{203, 93, 220, 37} ,{203, 93, 221, 37} ,{203, 93, 182, 7} ,{203, 93, 57, 0} ,{203, 93, 46, 0} ,{203, 93, 222, 37} ,{203, 93, 63, 0} ,{203, 93, 226, 22} ,{203, 93, 228, 2} ,{203, 93, 54, 0} ,{203, 93, 47, 0} ,{203, 93, 55, 0} ,{203, 93, 64, 0} ,{203, 93, 60, 0} ,{203, 93, 52, 0} ,{127, 166, 229, 5} ,{231, 93, 51, 0} ,{231, 93, 230, 33} ,{231, 93, 216, 37} ,{231, 93, 58, 0} ,{231, 93, 212, 0} ,{231, 93, 89, 7} ,{231, 93, 48, 0} ,{231, 93, 56, 0} ,{231, 93, 217, 37} ,{231, 93, 151, 17} ,{231, 93, 218, 37} ,{231, 93, 219, 37} ,{231, 93, 220, 37} ,{231, 93, 221, 37} ,{231, 93, 182, 7} ,{231, 93, 57, 0} ,{231, 93, 46, 0} ,{231, 93, 222, 37} ,{231, 93, 63, 0} ,{231, 93, 226, 22} ,{231, 93, 228, 2} ,{231, 93, 54, 0} ,{231, 93, 47, 0} ,{231, 93, 55, 0} ,{231, 93, 64, 0} ,{231, 93, 60, 0} ,{231, 93, 52, 0} ,{127, 166, 226, 1} ,{3, 94, 51, 0} ,{3, 94, 230, 33} ,{3, 94, 216, 37} ,{3, 94, 58, 0} ,{3, 94, 212, 0} ,{3, 94, 89, 7} ,{3, 94, 48, 0} ,{3, 94, 56, 0} ,{3, 94, 217, 37} ,{3, 94, 151, 17} ,{3, 94, 218, 37} ,{3, 94, 219, 37} ,{3, 94, 220, 37} ,{3, 94, 221, 37} ,{3, 94, 182, 7} ,{3, 94, 57, 0} ,{3, 94, 46, 0} ,{3, 94, 222, 37} ,{3, 94, 63, 0} ,{3, 94, 226, 22} ,{3, 94, 228, 2} ,{3, 94, 54, 0} ,{3, 94, 47, 0} ,{3, 94, 55, 0} ,{3, 94, 64, 0} ,{3, 94, 60, 0} ,{3, 94, 52, 0} ,{127, 166, 230, 5} ,{31, 94, 51, 0} ,{31, 94, 230, 33} ,{31, 94, 216, 37} ,{31, 94, 58, 0} ,{31, 94, 212, 0} ,{31, 94, 89, 7} ,{31, 94, 48, 0} ,{31, 94, 56, 0} ,{31, 94, 217, 37} ,{31, 94, 151, 17} ,{31, 94, 218, 37} ,{31, 94, 219, 37} ,{31, 94, 220, 37} ,{31, 94, 221, 37} ,{31, 94, 182, 7} ,{31, 94, 57, 0} ,{31, 94, 46, 0} ,{31, 94, 222, 37} ,{31, 94, 63, 0} ,{31, 94, 226, 22} ,{31, 94, 228, 2} ,{31, 94, 54, 0} ,{31, 94, 47, 0} ,{31, 94, 55, 0} ,{31, 94, 64, 0} ,{31, 94, 60, 0} ,{31, 94, 52, 0} ,{127, 166, 170, 1} ,{59, 94, 51, 0} ,{59, 94, 230, 33} ,{59, 94, 216, 37} ,{59, 94, 58, 0} ,{59, 94, 212, 0} ,{59, 94, 89, 7} ,{59, 94, 48, 0} ,{59, 94, 56, 0} ,{59, 94, 217, 37} ,{59, 94, 151, 17} ,{59, 94, 218, 37} ,{59, 94, 219, 37} ,{59, 94, 220, 37} ,{59, 94, 221, 37} ,{59, 94, 182, 7} ,{59, 94, 57, 0} ,{59, 94, 46, 0} ,{59, 94, 222, 37} ,{59, 94, 63, 0} ,{59, 94, 226, 22} ,{59, 94, 228, 2} ,{59, 94, 54, 0} ,{59, 94, 47, 0} ,{59, 94, 55, 0} ,{59, 94, 64, 0} ,{59, 94, 60, 0} ,{59, 94, 52, 0} ,{127, 166, 110, 5} ,{87, 94, 51, 0} ,{87, 94, 230, 33} ,{87, 94, 216, 37} ,{87, 94, 58, 0} ,{87, 94, 212, 0} ,{87, 94, 89, 7} ,{87, 94, 48, 0} ,{87, 94, 56, 0} ,{87, 94, 217, 37} ,{87, 94, 151, 17} ,{87, 94, 218, 37} ,{87, 94, 219, 37} ,{87, 94, 220, 37} ,{87, 94, 221, 37} ,{87, 94, 182, 7} ,{87, 94, 57, 0} ,{87, 94, 46, 0} ,{87, 94, 222, 37} ,{87, 94, 63, 0} ,{87, 94, 226, 22} ,{87, 94, 228, 2} ,{87, 94, 54, 0} ,{87, 94, 47, 0} ,{87, 94, 55, 0} ,{87, 94, 64, 0} ,{87, 94, 60, 0} ,{87, 94, 52, 0} ,{127, 166, 141, 1} ,{115, 94, 51, 0} ,{115, 94, 230, 33} ,{115, 94, 216, 37} ,{115, 94, 58, 0} ,{115, 94, 212, 0} ,{115, 94, 89, 7} ,{115, 94, 48, 0} ,{115, 94, 56, 0} ,{115, 94, 217, 37} ,{115, 94, 151, 17} ,{115, 94, 218, 37} ,{115, 94, 219, 37} ,{115, 94, 220, 37} ,{115, 94, 221, 37} ,{115, 94, 182, 7} ,{115, 94, 57, 0} ,{115, 94, 46, 0} ,{115, 94, 222, 37} ,{115, 94, 63, 0} ,{115, 94, 226, 22} ,{115, 94, 228, 2} ,{115, 94, 54, 0} ,{115, 94, 47, 0} ,{115, 94, 55, 0} ,{115, 94, 64, 0} ,{115, 94, 60, 0} ,{115, 94, 52, 0} ,{127, 166, 53, 0} ,{143, 94, 51, 0} ,{143, 94, 230, 33} ,{143, 94, 216, 37} ,{143, 94, 58, 0} ,{143, 94, 212, 0} ,{143, 94, 89, 7} ,{143, 94, 48, 0} ,{143, 94, 56, 0} ,{143, 94, 217, 37} ,{143, 94, 151, 17} ,{143, 94, 218, 37} ,{143, 94, 219, 37} ,{143, 94, 220, 37} ,{143, 94, 221, 37} ,{143, 94, 182, 7} ,{143, 94, 57, 0} ,{143, 94, 46, 0} ,{143, 94, 222, 37} ,{143, 94, 63, 0} ,{143, 94, 226, 22} ,{143, 94, 228, 2} ,{143, 94, 54, 0} ,{143, 94, 47, 0} ,{143, 94, 55, 0} ,{143, 94, 64, 0} ,{143, 94, 60, 0} ,{143, 94, 52, 0} ,{128, 166, 45, 0} ,{171, 94, 51, 0} ,{171, 94, 230, 33} ,{171, 94, 216, 37} ,{171, 94, 58, 0} ,{171, 94, 212, 0} ,{171, 94, 89, 7} ,{171, 94, 48, 0} ,{171, 94, 56, 0} ,{171, 94, 217, 37} ,{171, 94, 151, 17} ,{171, 94, 218, 37} ,{171, 94, 219, 37} ,{171, 94, 220, 37} ,{171, 94, 221, 37} ,{171, 94, 182, 7} ,{171, 94, 57, 0} ,{171, 94, 46, 0} ,{171, 94, 222, 37} ,{171, 94, 63, 0} ,{171, 94, 226, 22} ,{171, 94, 228, 2} ,{171, 94, 54, 0} ,{171, 94, 47, 0} ,{171, 94, 55, 0} ,{171, 94, 64, 0} ,{171, 94, 60, 0} ,{171, 94, 52, 0} ,{128, 166, 133, 0} ,{199, 94, 51, 0} ,{199, 94, 230, 33} ,{199, 94, 216, 37} ,{199, 94, 58, 0} ,{199, 94, 212, 0} ,{199, 94, 89, 7} ,{199, 94, 48, 0} ,{199, 94, 56, 0} ,{199, 94, 217, 37} ,{199, 94, 151, 17} ,{199, 94, 218, 37} ,{199, 94, 219, 37} ,{199, 94, 220, 37} ,{199, 94, 221, 37} ,{199, 94, 182, 7} ,{199, 94, 57, 0} ,{199, 94, 46, 0} ,{199, 94, 222, 37} ,{199, 94, 63, 0} ,{199, 94, 226, 22} ,{199, 94, 228, 2} ,{199, 94, 54, 0} ,{199, 94, 47, 0} ,{199, 94, 55, 0} ,{199, 94, 64, 0} ,{199, 94, 60, 0} ,{199, 94, 52, 0} ,{128, 166, 171, 1} ,{227, 94, 51, 0} ,{227, 94, 230, 33} ,{227, 94, 216, 37} ,{227, 94, 58, 0} ,{227, 94, 212, 0} ,{227, 94, 89, 7} ,{227, 94, 48, 0} ,{227, 94, 56, 0} ,{227, 94, 217, 37} ,{227, 94, 151, 17} ,{227, 94, 218, 37} ,{227, 94, 219, 37} ,{227, 94, 220, 37} ,{227, 94, 221, 37} ,{227, 94, 182, 7} ,{227, 94, 57, 0} ,{227, 94, 46, 0} ,{227, 94, 222, 37} ,{227, 94, 63, 0} ,{227, 94, 226, 22} ,{227, 94, 228, 2} ,{227, 94, 54, 0} ,{227, 94, 47, 0} ,{227, 94, 55, 0} ,{227, 94, 64, 0} ,{227, 94, 60, 0} ,{227, 94, 52, 0} ,{128, 166, 224, 1} ,{255, 94, 51, 0} ,{255, 94, 230, 33} ,{255, 94, 216, 37} ,{255, 94, 58, 0} ,{255, 94, 212, 0} ,{255, 94, 89, 7} ,{255, 94, 48, 0} ,{255, 94, 56, 0} ,{255, 94, 217, 37} ,{255, 94, 151, 17} ,{255, 94, 218, 37} ,{255, 94, 219, 37} ,{255, 94, 220, 37} ,{255, 94, 221, 37} ,{255, 94, 182, 7} ,{255, 94, 57, 0} ,{255, 94, 46, 0} ,{255, 94, 222, 37} ,{255, 94, 63, 0} ,{255, 94, 226, 22} ,{255, 94, 228, 2} ,{255, 94, 54, 0} ,{255, 94, 47, 0} ,{255, 94, 55, 0} ,{255, 94, 64, 0} ,{255, 94, 60, 0} ,{255, 94, 52, 0} ,{128, 166, 225, 5} ,{27, 95, 51, 0} ,{27, 95, 230, 33} ,{27, 95, 216, 37} ,{27, 95, 58, 0} ,{27, 95, 212, 0} ,{27, 95, 89, 7} ,{27, 95, 48, 0} ,{27, 95, 56, 0} ,{27, 95, 217, 37} ,{27, 95, 151, 17} ,{27, 95, 218, 37} ,{27, 95, 219, 37} ,{27, 95, 220, 37} ,{27, 95, 221, 37} ,{27, 95, 182, 7} ,{27, 95, 57, 0} ,{27, 95, 46, 0} ,{27, 95, 222, 37} ,{27, 95, 63, 0} ,{27, 95, 226, 22} ,{27, 95, 228, 2} ,{27, 95, 54, 0} ,{27, 95, 47, 0} ,{27, 95, 55, 0} ,{27, 95, 64, 0} ,{27, 95, 60, 0} ,{27, 95, 52, 0} ,{128, 166, 49, 0} ,{55, 95, 51, 0} ,{55, 95, 230, 33} ,{55, 95, 216, 37} ,{55, 95, 58, 0} ,{55, 95, 212, 0} ,{55, 95, 89, 7} ,{55, 95, 48, 0} ,{55, 95, 56, 0} ,{55, 95, 217, 37} ,{55, 95, 151, 17} ,{55, 95, 218, 37} ,{55, 95, 219, 37} ,{55, 95, 220, 37} ,{55, 95, 221, 37} ,{55, 95, 182, 7} ,{55, 95, 57, 0} ,{55, 95, 46, 0} ,{55, 95, 222, 37} ,{55, 95, 63, 0} ,{55, 95, 226, 22} ,{55, 95, 228, 2} ,{55, 95, 54, 0} ,{55, 95, 47, 0} ,{55, 95, 55, 0} ,{55, 95, 64, 0} ,{55, 95, 60, 0} ,{55, 95, 52, 0} ,{128, 166, 226, 5} ,{83, 95, 51, 0} ,{83, 95, 230, 33} ,{83, 95, 216, 37} ,{83, 95, 58, 0} ,{83, 95, 212, 0} ,{83, 95, 89, 7} ,{83, 95, 48, 0} ,{83, 95, 56, 0} ,{83, 95, 217, 37} ,{83, 95, 151, 17} ,{83, 95, 218, 37} ,{83, 95, 219, 37} ,{83, 95, 220, 37} ,{83, 95, 221, 37} ,{83, 95, 182, 7} ,{83, 95, 57, 0} ,{83, 95, 46, 0} ,{83, 95, 222, 37} ,{83, 95, 63, 0} ,{83, 95, 226, 22} ,{83, 95, 228, 2} ,{83, 95, 54, 0} ,{83, 95, 47, 0} ,{83, 95, 55, 0} ,{83, 95, 64, 0} ,{83, 95, 60, 0} ,{83, 95, 52, 0} ,{128, 166, 227, 5} ,{111, 95, 51, 0} ,{111, 95, 230, 33} ,{111, 95, 216, 37} ,{111, 95, 58, 0} ,{111, 95, 212, 0} ,{111, 95, 89, 7} ,{111, 95, 48, 0} ,{111, 95, 56, 0} ,{111, 95, 217, 37} ,{111, 95, 151, 17} ,{111, 95, 218, 37} ,{111, 95, 219, 37} ,{111, 95, 220, 37} ,{111, 95, 221, 37} ,{111, 95, 182, 7} ,{111, 95, 57, 0} ,{111, 95, 46, 0} ,{111, 95, 222, 37} ,{111, 95, 63, 0} ,{111, 95, 226, 22} ,{111, 95, 228, 2} ,{111, 95, 54, 0} ,{111, 95, 47, 0} ,{111, 95, 55, 0} ,{111, 95, 64, 0} ,{111, 95, 60, 0} ,{111, 95, 52, 0} ,{128, 166, 59, 0} ,{139, 95, 51, 0} ,{139, 95, 230, 33} ,{139, 95, 216, 37} ,{139, 95, 58, 0} ,{139, 95, 212, 0} ,{139, 95, 89, 7} ,{139, 95, 48, 0} ,{139, 95, 56, 0} ,{139, 95, 217, 37} ,{139, 95, 151, 17} ,{139, 95, 218, 37} ,{139, 95, 219, 37} ,{139, 95, 220, 37} ,{139, 95, 221, 37} ,{139, 95, 182, 7} ,{139, 95, 57, 0} ,{139, 95, 46, 0} ,{139, 95, 222, 37} ,{139, 95, 63, 0} ,{139, 95, 226, 22} ,{139, 95, 228, 2} ,{139, 95, 54, 0} ,{139, 95, 47, 0} ,{139, 95, 55, 0} ,{139, 95, 64, 0} ,{139, 95, 60, 0} ,{139, 95, 52, 0} ,{128, 166, 140, 3} ,{167, 95, 51, 0} ,{167, 95, 230, 33} ,{167, 95, 216, 37} ,{167, 95, 58, 0} ,{167, 95, 212, 0} ,{167, 95, 89, 7} ,{167, 95, 48, 0} ,{167, 95, 56, 0} ,{167, 95, 217, 37} ,{167, 95, 151, 17} ,{167, 95, 218, 37} ,{167, 95, 219, 37} ,{167, 95, 220, 37} ,{167, 95, 221, 37} ,{167, 95, 182, 7} ,{167, 95, 57, 0} ,{167, 95, 46, 0} ,{167, 95, 222, 37} ,{167, 95, 63, 0} ,{167, 95, 226, 22} ,{167, 95, 228, 2} ,{167, 95, 54, 0} ,{167, 95, 47, 0} ,{167, 95, 55, 0} ,{167, 95, 64, 0} ,{167, 95, 60, 0} ,{167, 95, 52, 0} ,{128, 166, 228, 5} ,{195, 95, 51, 0} ,{195, 95, 230, 33} ,{195, 95, 216, 37} ,{195, 95, 58, 0} ,{195, 95, 212, 0} ,{195, 95, 89, 7} ,{195, 95, 48, 0} ,{195, 95, 56, 0} ,{195, 95, 217, 37} ,{195, 95, 151, 17} ,{195, 95, 218, 37} ,{195, 95, 219, 37} ,{195, 95, 220, 37} ,{195, 95, 221, 37} ,{195, 95, 182, 7} ,{195, 95, 57, 0} ,{195, 95, 46, 0} ,{195, 95, 222, 37} ,{195, 95, 63, 0} ,{195, 95, 226, 22} ,{195, 95, 228, 2} ,{195, 95, 54, 0} ,{195, 95, 47, 0} ,{195, 95, 55, 0} ,{195, 95, 64, 0} ,{195, 95, 60, 0} ,{195, 95, 52, 0} ,{128, 166, 164, 0} ,{223, 95, 51, 0} ,{223, 95, 230, 33} ,{223, 95, 216, 37} ,{223, 95, 58, 0} ,{223, 95, 212, 0} ,{223, 95, 89, 7} ,{223, 95, 48, 0} ,{223, 95, 56, 0} ,{223, 95, 217, 37} ,{223, 95, 151, 17} ,{223, 95, 218, 37} ,{223, 95, 219, 37} ,{223, 95, 220, 37} ,{223, 95, 221, 37} ,{223, 95, 182, 7} ,{223, 95, 57, 0} ,{223, 95, 46, 0} ,{223, 95, 222, 37} ,{223, 95, 63, 0} ,{223, 95, 226, 22} ,{223, 95, 228, 2} ,{223, 95, 54, 0} ,{223, 95, 47, 0} ,{223, 95, 55, 0} ,{223, 95, 64, 0} ,{223, 95, 60, 0} ,{223, 95, 52, 0} ,{128, 166, 204, 4} ,{251, 95, 51, 0} ,{251, 95, 230, 33} ,{251, 95, 216, 37} ,{251, 95, 58, 0} ,{251, 95, 212, 0} ,{251, 95, 89, 7} ,{251, 95, 48, 0} ,{251, 95, 56, 0} ,{251, 95, 217, 37} ,{251, 95, 151, 17} ,{251, 95, 218, 37} ,{251, 95, 219, 37} ,{251, 95, 220, 37} ,{251, 95, 221, 37} ,{251, 95, 182, 7} ,{251, 95, 57, 0} ,{251, 95, 46, 0} ,{251, 95, 222, 37} ,{251, 95, 63, 0} ,{251, 95, 226, 22} ,{251, 95, 228, 2} ,{251, 95, 54, 0} ,{251, 95, 47, 0} ,{251, 95, 55, 0} ,{251, 95, 64, 0} ,{251, 95, 60, 0} ,{251, 95, 52, 0} ,{128, 166, 65, 0} ,{23, 96, 51, 0} ,{23, 96, 230, 33} ,{23, 96, 216, 37} ,{23, 96, 58, 0} ,{23, 96, 212, 0} ,{23, 96, 89, 7} ,{23, 96, 48, 0} ,{23, 96, 56, 0} ,{23, 96, 217, 37} ,{23, 96, 151, 17} ,{23, 96, 218, 37} ,{23, 96, 219, 37} ,{23, 96, 220, 37} ,{23, 96, 221, 37} ,{23, 96, 182, 7} ,{23, 96, 57, 0} ,{23, 96, 46, 0} ,{23, 96, 222, 37} ,{23, 96, 63, 0} ,{23, 96, 226, 22} ,{23, 96, 228, 2} ,{23, 96, 54, 0} ,{23, 96, 47, 0} ,{23, 96, 55, 0} ,{23, 96, 64, 0} ,{23, 96, 60, 0} ,{23, 96, 52, 0} ,{128, 166, 229, 5} ,{51, 96, 51, 0} ,{51, 96, 230, 33} ,{51, 96, 216, 37} ,{51, 96, 58, 0} ,{51, 96, 212, 0} ,{51, 96, 89, 7} ,{51, 96, 48, 0} ,{51, 96, 56, 0} ,{51, 96, 217, 37} ,{51, 96, 151, 17} ,{51, 96, 218, 37} ,{51, 96, 219, 37} ,{51, 96, 220, 37} ,{51, 96, 221, 37} ,{51, 96, 182, 7} ,{51, 96, 57, 0} ,{51, 96, 46, 0} ,{51, 96, 222, 37} ,{51, 96, 63, 0} ,{51, 96, 226, 22} ,{51, 96, 228, 2} ,{51, 96, 54, 0} ,{51, 96, 47, 0} ,{51, 96, 55, 0} ,{51, 96, 64, 0} ,{51, 96, 60, 0} ,{51, 96, 52, 0} ,{128, 166, 226, 1} ,{79, 96, 51, 0} ,{79, 96, 230, 33} ,{79, 96, 216, 37} ,{79, 96, 58, 0} ,{79, 96, 212, 0} ,{79, 96, 89, 7} ,{79, 96, 48, 0} ,{79, 96, 56, 0} ,{79, 96, 217, 37} ,{79, 96, 151, 17} ,{79, 96, 218, 37} ,{79, 96, 219, 37} ,{79, 96, 220, 37} ,{79, 96, 221, 37} ,{79, 96, 182, 7} ,{79, 96, 57, 0} ,{79, 96, 46, 0} ,{79, 96, 222, 37} ,{79, 96, 63, 0} ,{79, 96, 226, 22} ,{79, 96, 228, 2} ,{79, 96, 54, 0} ,{79, 96, 47, 0} ,{79, 96, 55, 0} ,{79, 96, 64, 0} ,{79, 96, 60, 0} ,{79, 96, 52, 0} ,{128, 166, 230, 5} ,{107, 96, 51, 0} ,{107, 96, 230, 33} ,{107, 96, 216, 37} ,{107, 96, 58, 0} ,{107, 96, 212, 0} ,{107, 96, 89, 7} ,{107, 96, 48, 0} ,{107, 96, 56, 0} ,{107, 96, 217, 37} ,{107, 96, 151, 17} ,{107, 96, 218, 37} ,{107, 96, 219, 37} ,{107, 96, 220, 37} ,{107, 96, 221, 37} ,{107, 96, 182, 7} ,{107, 96, 57, 0} ,{107, 96, 46, 0} ,{107, 96, 222, 37} ,{107, 96, 63, 0} ,{107, 96, 226, 22} ,{107, 96, 228, 2} ,{107, 96, 54, 0} ,{107, 96, 47, 0} ,{107, 96, 55, 0} ,{107, 96, 64, 0} ,{107, 96, 60, 0} ,{107, 96, 52, 0} ,{128, 166, 170, 1} ,{135, 96, 51, 0} ,{135, 96, 230, 33} ,{135, 96, 216, 37} ,{135, 96, 58, 0} ,{135, 96, 212, 0} ,{135, 96, 89, 7} ,{135, 96, 48, 0} ,{135, 96, 56, 0} ,{135, 96, 217, 37} ,{135, 96, 151, 17} ,{135, 96, 218, 37} ,{135, 96, 219, 37} ,{135, 96, 220, 37} ,{135, 96, 221, 37} ,{135, 96, 182, 7} ,{135, 96, 57, 0} ,{135, 96, 46, 0} ,{135, 96, 222, 37} ,{135, 96, 63, 0} ,{135, 96, 226, 22} ,{135, 96, 228, 2} ,{135, 96, 54, 0} ,{135, 96, 47, 0} ,{135, 96, 55, 0} ,{135, 96, 64, 0} ,{135, 96, 60, 0} ,{135, 96, 52, 0} ,{128, 166, 110, 5} ,{163, 96, 51, 0} ,{163, 96, 230, 33} ,{163, 96, 216, 37} ,{163, 96, 58, 0} ,{163, 96, 212, 0} ,{163, 96, 89, 7} ,{163, 96, 48, 0} ,{163, 96, 56, 0} ,{163, 96, 217, 37} ,{163, 96, 151, 17} ,{163, 96, 218, 37} ,{163, 96, 219, 37} ,{163, 96, 220, 37} ,{163, 96, 221, 37} ,{163, 96, 182, 7} ,{163, 96, 57, 0} ,{163, 96, 46, 0} ,{163, 96, 222, 37} ,{163, 96, 63, 0} ,{163, 96, 226, 22} ,{163, 96, 228, 2} ,{163, 96, 54, 0} ,{163, 96, 47, 0} ,{163, 96, 55, 0} ,{163, 96, 64, 0} ,{163, 96, 60, 0} ,{163, 96, 52, 0} ,{128, 166, 141, 1} ,{191, 96, 51, 0} ,{191, 96, 230, 33} ,{191, 96, 216, 37} ,{191, 96, 58, 0} ,{191, 96, 212, 0} ,{191, 96, 89, 7} ,{191, 96, 48, 0} ,{191, 96, 56, 0} ,{191, 96, 217, 37} ,{191, 96, 151, 17} ,{191, 96, 218, 37} ,{191, 96, 219, 37} ,{191, 96, 220, 37} ,{191, 96, 221, 37} ,{191, 96, 182, 7} ,{191, 96, 57, 0} ,{191, 96, 46, 0} ,{191, 96, 222, 37} ,{191, 96, 63, 0} ,{191, 96, 226, 22} ,{191, 96, 228, 2} ,{191, 96, 54, 0} ,{191, 96, 47, 0} ,{191, 96, 55, 0} ,{191, 96, 64, 0} ,{191, 96, 60, 0} ,{191, 96, 52, 0} ,{128, 166, 53, 0} ,{219, 96, 51, 0} ,{219, 96, 230, 33} ,{219, 96, 216, 37} ,{219, 96, 58, 0} ,{219, 96, 212, 0} ,{219, 96, 89, 7} ,{219, 96, 48, 0} ,{219, 96, 56, 0} ,{219, 96, 217, 37} ,{219, 96, 151, 17} ,{219, 96, 218, 37} ,{219, 96, 219, 37} ,{219, 96, 220, 37} ,{219, 96, 221, 37} ,{219, 96, 182, 7} ,{219, 96, 57, 0} ,{219, 96, 46, 0} ,{219, 96, 222, 37} ,{219, 96, 63, 0} ,{219, 96, 226, 22} ,{219, 96, 228, 2} ,{219, 96, 54, 0} ,{219, 96, 47, 0} ,{219, 96, 55, 0} ,{219, 96, 64, 0} ,{219, 96, 60, 0} ,{219, 96, 52, 0} ,{129, 166, 45, 0} ,{247, 96, 51, 0} ,{247, 96, 230, 33} ,{247, 96, 216, 37} ,{247, 96, 58, 0} ,{247, 96, 212, 0} ,{247, 96, 89, 7} ,{247, 96, 48, 0} ,{247, 96, 56, 0} ,{247, 96, 217, 37} ,{247, 96, 151, 17} ,{247, 96, 218, 37} ,{247, 96, 219, 37} ,{247, 96, 220, 37} ,{247, 96, 221, 37} ,{247, 96, 182, 7} ,{247, 96, 57, 0} ,{247, 96, 46, 0} ,{247, 96, 222, 37} ,{247, 96, 63, 0} ,{247, 96, 226, 22} ,{247, 96, 228, 2} ,{247, 96, 54, 0} ,{247, 96, 47, 0} ,{247, 96, 55, 0} ,{247, 96, 64, 0} ,{247, 96, 60, 0} ,{247, 96, 52, 0} ,{129, 166, 133, 0} ,{19, 97, 51, 0} ,{19, 97, 230, 33} ,{19, 97, 216, 37} ,{19, 97, 58, 0} ,{19, 97, 212, 0} ,{19, 97, 89, 7} ,{19, 97, 48, 0} ,{19, 97, 56, 0} ,{19, 97, 217, 37} ,{19, 97, 151, 17} ,{19, 97, 218, 37} ,{19, 97, 219, 37} ,{19, 97, 220, 37} ,{19, 97, 221, 37} ,{19, 97, 182, 7} ,{19, 97, 57, 0} ,{19, 97, 46, 0} ,{19, 97, 222, 37} ,{19, 97, 63, 0} ,{19, 97, 226, 22} ,{19, 97, 228, 2} ,{19, 97, 54, 0} ,{19, 97, 47, 0} ,{19, 97, 55, 0} ,{19, 97, 64, 0} ,{19, 97, 60, 0} ,{19, 97, 52, 0} ,{129, 166, 171, 1} ,{47, 97, 51, 0} ,{47, 97, 230, 33} ,{47, 97, 216, 37} ,{47, 97, 58, 0} ,{47, 97, 212, 0} ,{47, 97, 89, 7} ,{47, 97, 48, 0} ,{47, 97, 56, 0} ,{47, 97, 217, 37} ,{47, 97, 151, 17} ,{47, 97, 218, 37} ,{47, 97, 219, 37} ,{47, 97, 220, 37} ,{47, 97, 221, 37} ,{47, 97, 182, 7} ,{47, 97, 57, 0} ,{47, 97, 46, 0} ,{47, 97, 222, 37} ,{47, 97, 63, 0} ,{47, 97, 226, 22} ,{47, 97, 228, 2} ,{47, 97, 54, 0} ,{47, 97, 47, 0} ,{47, 97, 55, 0} ,{47, 97, 64, 0} ,{47, 97, 60, 0} ,{47, 97, 52, 0} ,{129, 166, 224, 1} ,{75, 97, 51, 0} ,{75, 97, 230, 33} ,{75, 97, 216, 37} ,{75, 97, 58, 0} ,{75, 97, 212, 0} ,{75, 97, 89, 7} ,{75, 97, 48, 0} ,{75, 97, 56, 0} ,{75, 97, 217, 37} ,{75, 97, 151, 17} ,{75, 97, 218, 37} ,{75, 97, 219, 37} ,{75, 97, 220, 37} ,{75, 97, 221, 37} ,{75, 97, 182, 7} ,{75, 97, 57, 0} ,{75, 97, 46, 0} ,{75, 97, 222, 37} ,{75, 97, 63, 0} ,{75, 97, 226, 22} ,{75, 97, 228, 2} ,{75, 97, 54, 0} ,{75, 97, 47, 0} ,{75, 97, 55, 0} ,{75, 97, 64, 0} ,{75, 97, 60, 0} ,{75, 97, 52, 0} ,{129, 166, 225, 5} ,{103, 97, 51, 0} ,{103, 97, 230, 33} ,{103, 97, 216, 37} ,{103, 97, 58, 0} ,{103, 97, 212, 0} ,{103, 97, 89, 7} ,{103, 97, 48, 0} ,{103, 97, 56, 0} ,{103, 97, 217, 37} ,{103, 97, 151, 17} ,{103, 97, 218, 37} ,{103, 97, 219, 37} ,{103, 97, 220, 37} ,{103, 97, 221, 37} ,{103, 97, 182, 7} ,{103, 97, 57, 0} ,{103, 97, 46, 0} ,{103, 97, 222, 37} ,{103, 97, 63, 0} ,{103, 97, 226, 22} ,{103, 97, 228, 2} ,{103, 97, 54, 0} ,{103, 97, 47, 0} ,{103, 97, 55, 0} ,{103, 97, 64, 0} ,{103, 97, 60, 0} ,{103, 97, 52, 0} ,{129, 166, 49, 0} ,{131, 97, 51, 0} ,{131, 97, 230, 33} ,{131, 97, 216, 37} ,{131, 97, 58, 0} ,{131, 97, 212, 0} ,{131, 97, 89, 7} ,{131, 97, 48, 0} ,{131, 97, 56, 0} ,{131, 97, 217, 37} ,{131, 97, 151, 17} ,{131, 97, 218, 37} ,{131, 97, 219, 37} ,{131, 97, 220, 37} ,{131, 97, 221, 37} ,{131, 97, 182, 7} ,{131, 97, 57, 0} ,{131, 97, 46, 0} ,{131, 97, 222, 37} ,{131, 97, 63, 0} ,{131, 97, 226, 22} ,{131, 97, 228, 2} ,{131, 97, 54, 0} ,{131, 97, 47, 0} ,{131, 97, 55, 0} ,{131, 97, 64, 0} ,{131, 97, 60, 0} ,{131, 97, 52, 0} ,{129, 166, 226, 5} ,{159, 97, 51, 0} ,{159, 97, 230, 33} ,{159, 97, 216, 37} ,{159, 97, 58, 0} ,{159, 97, 212, 0} ,{159, 97, 89, 7} ,{159, 97, 48, 0} ,{159, 97, 56, 0} ,{159, 97, 217, 37} ,{159, 97, 151, 17} ,{159, 97, 218, 37} ,{159, 97, 219, 37} ,{159, 97, 220, 37} ,{159, 97, 221, 37} ,{159, 97, 182, 7} ,{159, 97, 57, 0} ,{159, 97, 46, 0} ,{159, 97, 222, 37} ,{159, 97, 63, 0} ,{159, 97, 226, 22} ,{159, 97, 228, 2} ,{159, 97, 54, 0} ,{159, 97, 47, 0} ,{159, 97, 55, 0} ,{159, 97, 64, 0} ,{159, 97, 60, 0} ,{159, 97, 52, 0} ,{129, 166, 227, 5} ,{187, 97, 51, 0} ,{187, 97, 230, 33} ,{187, 97, 216, 37} ,{187, 97, 58, 0} ,{187, 97, 212, 0} ,{187, 97, 89, 7} ,{187, 97, 48, 0} ,{187, 97, 56, 0} ,{187, 97, 217, 37} ,{187, 97, 151, 17} ,{187, 97, 218, 37} ,{187, 97, 219, 37} ,{187, 97, 220, 37} ,{187, 97, 221, 37} ,{187, 97, 182, 7} ,{187, 97, 57, 0} ,{187, 97, 46, 0} ,{187, 97, 222, 37} ,{187, 97, 63, 0} ,{187, 97, 226, 22} ,{187, 97, 228, 2} ,{187, 97, 54, 0} ,{187, 97, 47, 0} ,{187, 97, 55, 0} ,{187, 97, 64, 0} ,{187, 97, 60, 0} ,{187, 97, 52, 0} ,{129, 166, 59, 0} ,{215, 97, 51, 0} ,{215, 97, 230, 33} ,{215, 97, 216, 37} ,{215, 97, 58, 0} ,{215, 97, 212, 0} ,{215, 97, 89, 7} ,{215, 97, 48, 0} ,{215, 97, 56, 0} ,{215, 97, 217, 37} ,{215, 97, 151, 17} ,{215, 97, 218, 37} ,{215, 97, 219, 37} ,{215, 97, 220, 37} ,{215, 97, 221, 37} ,{215, 97, 182, 7} ,{215, 97, 57, 0} ,{215, 97, 46, 0} ,{215, 97, 222, 37} ,{215, 97, 63, 0} ,{215, 97, 226, 22} ,{215, 97, 228, 2} ,{215, 97, 54, 0} ,{215, 97, 47, 0} ,{215, 97, 55, 0} ,{215, 97, 64, 0} ,{215, 97, 60, 0} ,{215, 97, 52, 0} ,{129, 166, 140, 3} ,{243, 97, 51, 0} ,{243, 97, 230, 33} ,{243, 97, 216, 37} ,{243, 97, 58, 0} ,{243, 97, 212, 0} ,{243, 97, 89, 7} ,{243, 97, 48, 0} ,{243, 97, 56, 0} ,{243, 97, 217, 37} ,{243, 97, 151, 17} ,{243, 97, 218, 37} ,{243, 97, 219, 37} ,{243, 97, 220, 37} ,{243, 97, 221, 37} ,{243, 97, 182, 7} ,{243, 97, 57, 0} ,{243, 97, 46, 0} ,{243, 97, 222, 37} ,{243, 97, 63, 0} ,{243, 97, 226, 22} ,{243, 97, 228, 2} ,{243, 97, 54, 0} ,{243, 97, 47, 0} ,{243, 97, 55, 0} ,{243, 97, 64, 0} ,{243, 97, 60, 0} ,{243, 97, 52, 0} ,{129, 166, 228, 5} ,{15, 98, 51, 0} ,{15, 98, 230, 33} ,{15, 98, 216, 37} ,{15, 98, 58, 0} ,{15, 98, 212, 0} ,{15, 98, 89, 7} ,{15, 98, 48, 0} ,{15, 98, 56, 0} ,{15, 98, 217, 37} ,{15, 98, 151, 17} ,{15, 98, 218, 37} ,{15, 98, 219, 37} ,{15, 98, 220, 37} ,{15, 98, 221, 37} ,{15, 98, 182, 7} ,{15, 98, 57, 0} ,{15, 98, 46, 0} ,{15, 98, 222, 37} ,{15, 98, 63, 0} ,{15, 98, 226, 22} ,{15, 98, 228, 2} ,{15, 98, 54, 0} ,{15, 98, 47, 0} ,{15, 98, 55, 0} ,{15, 98, 64, 0} ,{15, 98, 60, 0} ,{15, 98, 52, 0} ,{129, 166, 164, 0} ,{43, 98, 51, 0} ,{43, 98, 230, 33} ,{43, 98, 216, 37} ,{43, 98, 58, 0} ,{43, 98, 212, 0} ,{43, 98, 89, 7} ,{43, 98, 48, 0} ,{43, 98, 56, 0} ,{43, 98, 217, 37} ,{43, 98, 151, 17} ,{43, 98, 218, 37} ,{43, 98, 219, 37} ,{43, 98, 220, 37} ,{43, 98, 221, 37} ,{43, 98, 182, 7} ,{43, 98, 57, 0} ,{43, 98, 46, 0} ,{43, 98, 222, 37} ,{43, 98, 63, 0} ,{43, 98, 226, 22} ,{43, 98, 228, 2} ,{43, 98, 54, 0} ,{43, 98, 47, 0} ,{43, 98, 55, 0} ,{43, 98, 64, 0} ,{43, 98, 60, 0} ,{43, 98, 52, 0} ,{129, 166, 204, 4} ,{71, 98, 51, 0} ,{71, 98, 230, 33} ,{71, 98, 216, 37} ,{71, 98, 58, 0} ,{71, 98, 212, 0} ,{71, 98, 89, 7} ,{71, 98, 48, 0} ,{71, 98, 56, 0} ,{71, 98, 217, 37} ,{71, 98, 151, 17} ,{71, 98, 218, 37} ,{71, 98, 219, 37} ,{71, 98, 220, 37} ,{71, 98, 221, 37} ,{71, 98, 182, 7} ,{71, 98, 57, 0} ,{71, 98, 46, 0} ,{71, 98, 222, 37} ,{71, 98, 63, 0} ,{71, 98, 226, 22} ,{71, 98, 228, 2} ,{71, 98, 54, 0} ,{71, 98, 47, 0} ,{71, 98, 55, 0} ,{71, 98, 64, 0} ,{71, 98, 60, 0} ,{71, 98, 52, 0} ,{129, 166, 65, 0} ,{99, 98, 51, 0} ,{99, 98, 230, 33} ,{99, 98, 216, 37} ,{99, 98, 58, 0} ,{99, 98, 212, 0} ,{99, 98, 89, 7} ,{99, 98, 48, 0} ,{99, 98, 56, 0} ,{99, 98, 217, 37} ,{99, 98, 151, 17} ,{99, 98, 218, 37} ,{99, 98, 219, 37} ,{99, 98, 220, 37} ,{99, 98, 221, 37} ,{99, 98, 182, 7} ,{99, 98, 57, 0} ,{99, 98, 46, 0} ,{99, 98, 222, 37} ,{99, 98, 63, 0} ,{99, 98, 226, 22} ,{99, 98, 228, 2} ,{99, 98, 54, 0} ,{99, 98, 47, 0} ,{99, 98, 55, 0} ,{99, 98, 64, 0} ,{99, 98, 60, 0} ,{99, 98, 52, 0} ,{129, 166, 229, 5} ,{127, 98, 51, 0} ,{127, 98, 230, 33} ,{127, 98, 216, 37} ,{127, 98, 58, 0} ,{127, 98, 212, 0} ,{127, 98, 89, 7} ,{127, 98, 48, 0} ,{127, 98, 56, 0} ,{127, 98, 217, 37} ,{127, 98, 151, 17} ,{127, 98, 218, 37} ,{127, 98, 219, 37} ,{127, 98, 220, 37} ,{127, 98, 221, 37} ,{127, 98, 182, 7} ,{127, 98, 57, 0} ,{127, 98, 46, 0} ,{127, 98, 222, 37} ,{127, 98, 63, 0} ,{127, 98, 226, 22} ,{127, 98, 228, 2} ,{127, 98, 54, 0} ,{127, 98, 47, 0} ,{127, 98, 55, 0} ,{127, 98, 64, 0} ,{127, 98, 60, 0} ,{127, 98, 52, 0} ,{129, 166, 226, 1} ,{155, 98, 51, 0} ,{155, 98, 230, 33} ,{155, 98, 216, 37} ,{155, 98, 58, 0} ,{155, 98, 212, 0} ,{155, 98, 89, 7} ,{155, 98, 48, 0} ,{155, 98, 56, 0} ,{155, 98, 217, 37} ,{155, 98, 151, 17} ,{155, 98, 218, 37} ,{155, 98, 219, 37} ,{155, 98, 220, 37} ,{155, 98, 221, 37} ,{155, 98, 182, 7} ,{155, 98, 57, 0} ,{155, 98, 46, 0} ,{155, 98, 222, 37} ,{155, 98, 63, 0} ,{155, 98, 226, 22} ,{155, 98, 228, 2} ,{155, 98, 54, 0} ,{155, 98, 47, 0} ,{155, 98, 55, 0} ,{155, 98, 64, 0} ,{155, 98, 60, 0} ,{155, 98, 52, 0} ,{129, 166, 230, 5} ,{183, 98, 51, 0} ,{183, 98, 230, 33} ,{183, 98, 216, 37} ,{183, 98, 58, 0} ,{183, 98, 212, 0} ,{183, 98, 89, 7} ,{183, 98, 48, 0} ,{183, 98, 56, 0} ,{183, 98, 217, 37} ,{183, 98, 151, 17} ,{183, 98, 218, 37} ,{183, 98, 219, 37} ,{183, 98, 220, 37} ,{183, 98, 221, 37} ,{183, 98, 182, 7} ,{183, 98, 57, 0} ,{183, 98, 46, 0} ,{183, 98, 222, 37} ,{183, 98, 63, 0} ,{183, 98, 226, 22} ,{183, 98, 228, 2} ,{183, 98, 54, 0} ,{183, 98, 47, 0} ,{183, 98, 55, 0} ,{183, 98, 64, 0} ,{183, 98, 60, 0} ,{183, 98, 52, 0} ,{129, 166, 170, 1} ,{211, 98, 51, 0} ,{211, 98, 230, 33} ,{211, 98, 216, 37} ,{211, 98, 58, 0} ,{211, 98, 212, 0} ,{211, 98, 89, 7} ,{211, 98, 48, 0} ,{211, 98, 56, 0} ,{211, 98, 217, 37} ,{211, 98, 151, 17} ,{211, 98, 218, 37} ,{211, 98, 219, 37} ,{211, 98, 220, 37} ,{211, 98, 221, 37} ,{211, 98, 182, 7} ,{211, 98, 57, 0} ,{211, 98, 46, 0} ,{211, 98, 222, 37} ,{211, 98, 63, 0} ,{211, 98, 226, 22} ,{211, 98, 228, 2} ,{211, 98, 54, 0} ,{211, 98, 47, 0} ,{211, 98, 55, 0} ,{211, 98, 64, 0} ,{211, 98, 60, 0} ,{211, 98, 52, 0} ,{129, 166, 110, 5} ,{239, 98, 51, 0} ,{239, 98, 230, 33} ,{239, 98, 216, 37} ,{239, 98, 58, 0} ,{239, 98, 212, 0} ,{239, 98, 89, 7} ,{239, 98, 48, 0} ,{239, 98, 56, 0} ,{239, 98, 217, 37} ,{239, 98, 151, 17} ,{239, 98, 218, 37} ,{239, 98, 219, 37} ,{239, 98, 220, 37} ,{239, 98, 221, 37} ,{239, 98, 182, 7} ,{239, 98, 57, 0} ,{239, 98, 46, 0} ,{239, 98, 222, 37} ,{239, 98, 63, 0} ,{239, 98, 226, 22} ,{239, 98, 228, 2} ,{239, 98, 54, 0} ,{239, 98, 47, 0} ,{239, 98, 55, 0} ,{239, 98, 64, 0} ,{239, 98, 60, 0} ,{239, 98, 52, 0} ,{129, 166, 141, 1} ,{11, 99, 51, 0} ,{11, 99, 230, 33} ,{11, 99, 216, 37} ,{11, 99, 58, 0} ,{11, 99, 212, 0} ,{11, 99, 89, 7} ,{11, 99, 48, 0} ,{11, 99, 56, 0} ,{11, 99, 217, 37} ,{11, 99, 151, 17} ,{11, 99, 218, 37} ,{11, 99, 219, 37} ,{11, 99, 220, 37} ,{11, 99, 221, 37} ,{11, 99, 182, 7} ,{11, 99, 57, 0} ,{11, 99, 46, 0} ,{11, 99, 222, 37} ,{11, 99, 63, 0} ,{11, 99, 226, 22} ,{11, 99, 228, 2} ,{11, 99, 54, 0} ,{11, 99, 47, 0} ,{11, 99, 55, 0} ,{11, 99, 64, 0} ,{11, 99, 60, 0} ,{11, 99, 52, 0} ,{129, 166, 53, 0} ,{39, 99, 51, 0} ,{39, 99, 230, 33} ,{39, 99, 216, 37} ,{39, 99, 58, 0} ,{39, 99, 212, 0} ,{39, 99, 89, 7} ,{39, 99, 48, 0} ,{39, 99, 56, 0} ,{39, 99, 217, 37} ,{39, 99, 151, 17} ,{39, 99, 218, 37} ,{39, 99, 219, 37} ,{39, 99, 220, 37} ,{39, 99, 221, 37} ,{39, 99, 182, 7} ,{39, 99, 57, 0} ,{39, 99, 46, 0} ,{39, 99, 222, 37} ,{39, 99, 63, 0} ,{39, 99, 226, 22} ,{39, 99, 228, 2} ,{39, 99, 54, 0} ,{39, 99, 47, 0} ,{39, 99, 55, 0} ,{39, 99, 64, 0} ,{39, 99, 60, 0} ,{39, 99, 52, 0} ,{130, 166, 45, 0} ,{67, 99, 51, 0} ,{67, 99, 230, 33} ,{67, 99, 216, 37} ,{67, 99, 58, 0} ,{67, 99, 212, 0} ,{67, 99, 89, 7} ,{67, 99, 48, 0} ,{67, 99, 56, 0} ,{67, 99, 217, 37} ,{67, 99, 151, 17} ,{67, 99, 218, 37} ,{67, 99, 219, 37} ,{67, 99, 220, 37} ,{67, 99, 221, 37} ,{67, 99, 182, 7} ,{67, 99, 57, 0} ,{67, 99, 46, 0} ,{67, 99, 222, 37} ,{67, 99, 63, 0} ,{67, 99, 226, 22} ,{67, 99, 228, 2} ,{67, 99, 54, 0} ,{67, 99, 47, 0} ,{67, 99, 55, 0} ,{67, 99, 64, 0} ,{67, 99, 60, 0} ,{67, 99, 52, 0} ,{130, 166, 133, 0} ,{95, 99, 51, 0} ,{95, 99, 230, 33} ,{95, 99, 216, 37} ,{95, 99, 58, 0} ,{95, 99, 212, 0} ,{95, 99, 89, 7} ,{95, 99, 48, 0} ,{95, 99, 56, 0} ,{95, 99, 217, 37} ,{95, 99, 151, 17} ,{95, 99, 218, 37} ,{95, 99, 219, 37} ,{95, 99, 220, 37} ,{95, 99, 221, 37} ,{95, 99, 182, 7} ,{95, 99, 57, 0} ,{95, 99, 46, 0} ,{95, 99, 222, 37} ,{95, 99, 63, 0} ,{95, 99, 226, 22} ,{95, 99, 228, 2} ,{95, 99, 54, 0} ,{95, 99, 47, 0} ,{95, 99, 55, 0} ,{95, 99, 64, 0} ,{95, 99, 60, 0} ,{95, 99, 52, 0} ,{130, 166, 171, 1} ,{123, 99, 51, 0} ,{123, 99, 230, 33} ,{123, 99, 216, 37} ,{123, 99, 58, 0} ,{123, 99, 212, 0} ,{123, 99, 89, 7} ,{123, 99, 48, 0} ,{123, 99, 56, 0} ,{123, 99, 217, 37} ,{123, 99, 151, 17} ,{123, 99, 218, 37} ,{123, 99, 219, 37} ,{123, 99, 220, 37} ,{123, 99, 221, 37} ,{123, 99, 182, 7} ,{123, 99, 57, 0} ,{123, 99, 46, 0} ,{123, 99, 222, 37} ,{123, 99, 63, 0} ,{123, 99, 226, 22} ,{123, 99, 228, 2} ,{123, 99, 54, 0} ,{123, 99, 47, 0} ,{123, 99, 55, 0} ,{123, 99, 64, 0} ,{123, 99, 60, 0} ,{123, 99, 52, 0} ,{130, 166, 224, 1} ,{151, 99, 51, 0} ,{151, 99, 230, 33} ,{151, 99, 216, 37} ,{151, 99, 58, 0} ,{151, 99, 212, 0} ,{151, 99, 89, 7} ,{151, 99, 48, 0} ,{151, 99, 56, 0} ,{151, 99, 217, 37} ,{151, 99, 151, 17} ,{151, 99, 218, 37} ,{151, 99, 219, 37} ,{151, 99, 220, 37} ,{151, 99, 221, 37} ,{151, 99, 182, 7} ,{151, 99, 57, 0} ,{151, 99, 46, 0} ,{151, 99, 222, 37} ,{151, 99, 63, 0} ,{151, 99, 226, 22} ,{151, 99, 228, 2} ,{151, 99, 54, 0} ,{151, 99, 47, 0} ,{151, 99, 55, 0} ,{151, 99, 64, 0} ,{151, 99, 60, 0} ,{151, 99, 52, 0} ,{130, 166, 225, 5} ,{179, 99, 51, 0} ,{179, 99, 230, 33} ,{179, 99, 216, 37} ,{179, 99, 58, 0} ,{179, 99, 212, 0} ,{179, 99, 89, 7} ,{179, 99, 48, 0} ,{179, 99, 56, 0} ,{179, 99, 217, 37} ,{179, 99, 151, 17} ,{179, 99, 218, 37} ,{179, 99, 219, 37} ,{179, 99, 220, 37} ,{179, 99, 221, 37} ,{179, 99, 182, 7} ,{179, 99, 57, 0} ,{179, 99, 46, 0} ,{179, 99, 222, 37} ,{179, 99, 63, 0} ,{179, 99, 226, 22} ,{179, 99, 228, 2} ,{179, 99, 54, 0} ,{179, 99, 47, 0} ,{179, 99, 55, 0} ,{179, 99, 64, 0} ,{179, 99, 60, 0} ,{179, 99, 52, 0} ,{130, 166, 49, 0} ,{207, 99, 51, 0} ,{207, 99, 230, 33} ,{207, 99, 216, 37} ,{207, 99, 58, 0} ,{207, 99, 212, 0} ,{207, 99, 89, 7} ,{207, 99, 48, 0} ,{207, 99, 56, 0} ,{207, 99, 217, 37} ,{207, 99, 151, 17} ,{207, 99, 218, 37} ,{207, 99, 219, 37} ,{207, 99, 220, 37} ,{207, 99, 221, 37} ,{207, 99, 182, 7} ,{207, 99, 57, 0} ,{207, 99, 46, 0} ,{207, 99, 222, 37} ,{207, 99, 63, 0} ,{207, 99, 226, 22} ,{207, 99, 228, 2} ,{207, 99, 54, 0} ,{207, 99, 47, 0} ,{207, 99, 55, 0} ,{207, 99, 64, 0} ,{207, 99, 60, 0} ,{207, 99, 52, 0} ,{130, 166, 226, 5} ,{235, 99, 51, 0} ,{235, 99, 230, 33} ,{235, 99, 216, 37} ,{235, 99, 58, 0} ,{235, 99, 212, 0} ,{235, 99, 89, 7} ,{235, 99, 48, 0} ,{235, 99, 56, 0} ,{235, 99, 217, 37} ,{235, 99, 151, 17} ,{235, 99, 218, 37} ,{235, 99, 219, 37} ,{235, 99, 220, 37} ,{235, 99, 221, 37} ,{235, 99, 182, 7} ,{235, 99, 57, 0} ,{235, 99, 46, 0} ,{235, 99, 222, 37} ,{235, 99, 63, 0} ,{235, 99, 226, 22} ,{235, 99, 228, 2} ,{235, 99, 54, 0} ,{235, 99, 47, 0} ,{235, 99, 55, 0} ,{235, 99, 64, 0} ,{235, 99, 60, 0} ,{235, 99, 52, 0} ,{130, 166, 227, 5} ,{7, 100, 51, 0} ,{7, 100, 230, 33} ,{7, 100, 216, 37} ,{7, 100, 58, 0} ,{7, 100, 212, 0} ,{7, 100, 89, 7} ,{7, 100, 48, 0} ,{7, 100, 56, 0} ,{7, 100, 217, 37} ,{7, 100, 151, 17} ,{7, 100, 218, 37} ,{7, 100, 219, 37} ,{7, 100, 220, 37} ,{7, 100, 221, 37} ,{7, 100, 182, 7} ,{7, 100, 57, 0} ,{7, 100, 46, 0} ,{7, 100, 222, 37} ,{7, 100, 63, 0} ,{7, 100, 226, 22} ,{7, 100, 228, 2} ,{7, 100, 54, 0} ,{7, 100, 47, 0} ,{7, 100, 55, 0} ,{7, 100, 64, 0} ,{7, 100, 60, 0} ,{7, 100, 52, 0} ,{130, 166, 59, 0} ,{35, 100, 51, 0} ,{35, 100, 230, 33} ,{35, 100, 216, 37} ,{35, 100, 58, 0} ,{35, 100, 212, 0} ,{35, 100, 89, 7} ,{35, 100, 48, 0} ,{35, 100, 56, 0} ,{35, 100, 217, 37} ,{35, 100, 151, 17} ,{35, 100, 218, 37} ,{35, 100, 219, 37} ,{35, 100, 220, 37} ,{35, 100, 221, 37} ,{35, 100, 182, 7} ,{35, 100, 57, 0} ,{35, 100, 46, 0} ,{35, 100, 222, 37} ,{35, 100, 63, 0} ,{35, 100, 226, 22} ,{35, 100, 228, 2} ,{35, 100, 54, 0} ,{35, 100, 47, 0} ,{35, 100, 55, 0} ,{35, 100, 64, 0} ,{35, 100, 60, 0} ,{35, 100, 52, 0} ,{130, 166, 140, 3} ,{63, 100, 51, 0} ,{63, 100, 230, 33} ,{63, 100, 216, 37} ,{63, 100, 58, 0} ,{63, 100, 212, 0} ,{63, 100, 89, 7} ,{63, 100, 48, 0} ,{63, 100, 56, 0} ,{63, 100, 217, 37} ,{63, 100, 151, 17} ,{63, 100, 218, 37} ,{63, 100, 219, 37} ,{63, 100, 220, 37} ,{63, 100, 221, 37} ,{63, 100, 182, 7} ,{63, 100, 57, 0} ,{63, 100, 46, 0} ,{63, 100, 222, 37} ,{63, 100, 63, 0} ,{63, 100, 226, 22} ,{63, 100, 228, 2} ,{63, 100, 54, 0} ,{63, 100, 47, 0} ,{63, 100, 55, 0} ,{63, 100, 64, 0} ,{63, 100, 60, 0} ,{63, 100, 52, 0} ,{130, 166, 228, 5} ,{91, 100, 51, 0} ,{91, 100, 230, 33} ,{91, 100, 216, 37} ,{91, 100, 58, 0} ,{91, 100, 212, 0} ,{91, 100, 89, 7} ,{91, 100, 48, 0} ,{91, 100, 56, 0} ,{91, 100, 217, 37} ,{91, 100, 151, 17} ,{91, 100, 218, 37} ,{91, 100, 219, 37} ,{91, 100, 220, 37} ,{91, 100, 221, 37} ,{91, 100, 182, 7} ,{91, 100, 57, 0} ,{91, 100, 46, 0} ,{91, 100, 222, 37} ,{91, 100, 63, 0} ,{91, 100, 226, 22} ,{91, 100, 228, 2} ,{91, 100, 54, 0} ,{91, 100, 47, 0} ,{91, 100, 55, 0} ,{91, 100, 64, 0} ,{91, 100, 60, 0} ,{91, 100, 52, 0} ,{130, 166, 164, 0} ,{119, 100, 51, 0} ,{119, 100, 230, 33} ,{119, 100, 216, 37} ,{119, 100, 58, 0} ,{119, 100, 212, 0} ,{119, 100, 89, 7} ,{119, 100, 48, 0} ,{119, 100, 56, 0} ,{119, 100, 217, 37} ,{119, 100, 151, 17} ,{119, 100, 218, 37} ,{119, 100, 219, 37} ,{119, 100, 220, 37} ,{119, 100, 221, 37} ,{119, 100, 182, 7} ,{119, 100, 57, 0} ,{119, 100, 46, 0} ,{119, 100, 222, 37} ,{119, 100, 63, 0} ,{119, 100, 226, 22} ,{119, 100, 228, 2} ,{119, 100, 54, 0} ,{119, 100, 47, 0} ,{119, 100, 55, 0} ,{119, 100, 64, 0} ,{119, 100, 60, 0} ,{119, 100, 52, 0} ,{130, 166, 204, 4} ,{147, 100, 51, 0} ,{147, 100, 230, 33} ,{147, 100, 216, 37} ,{147, 100, 58, 0} ,{147, 100, 212, 0} ,{147, 100, 89, 7} ,{147, 100, 48, 0} ,{147, 100, 56, 0} ,{147, 100, 217, 37} ,{147, 100, 151, 17} ,{147, 100, 218, 37} ,{147, 100, 219, 37} ,{147, 100, 220, 37} ,{147, 100, 221, 37} ,{147, 100, 182, 7} ,{147, 100, 57, 0} ,{147, 100, 46, 0} ,{147, 100, 222, 37} ,{147, 100, 63, 0} ,{147, 100, 226, 22} ,{147, 100, 228, 2} ,{147, 100, 54, 0} ,{147, 100, 47, 0} ,{147, 100, 55, 0} ,{147, 100, 64, 0} ,{147, 100, 60, 0} ,{147, 100, 52, 0} ,{130, 166, 65, 0} ,{175, 100, 51, 0} ,{175, 100, 230, 33} ,{175, 100, 216, 37} ,{175, 100, 58, 0} ,{175, 100, 212, 0} ,{175, 100, 89, 7} ,{175, 100, 48, 0} ,{175, 100, 56, 0} ,{175, 100, 217, 37} ,{175, 100, 151, 17} ,{175, 100, 218, 37} ,{175, 100, 219, 37} ,{175, 100, 220, 37} ,{175, 100, 221, 37} ,{175, 100, 182, 7} ,{175, 100, 57, 0} ,{175, 100, 46, 0} ,{175, 100, 222, 37} ,{175, 100, 63, 0} ,{175, 100, 226, 22} ,{175, 100, 228, 2} ,{175, 100, 54, 0} ,{175, 100, 47, 0} ,{175, 100, 55, 0} ,{175, 100, 64, 0} ,{175, 100, 60, 0} ,{175, 100, 52, 0} ,{130, 166, 229, 5} ,{203, 100, 51, 0} ,{203, 100, 230, 33} ,{203, 100, 216, 37} ,{203, 100, 58, 0} ,{203, 100, 212, 0} ,{203, 100, 89, 7} ,{203, 100, 48, 0} ,{203, 100, 56, 0} ,{203, 100, 217, 37} ,{203, 100, 151, 17} ,{203, 100, 218, 37} ,{203, 100, 219, 37} ,{203, 100, 220, 37} ,{203, 100, 221, 37} ,{203, 100, 182, 7} ,{203, 100, 57, 0} ,{203, 100, 46, 0} ,{203, 100, 222, 37} ,{203, 100, 63, 0} ,{203, 100, 226, 22} ,{203, 100, 228, 2} ,{203, 100, 54, 0} ,{203, 100, 47, 0} ,{203, 100, 55, 0} ,{203, 100, 64, 0} ,{203, 100, 60, 0} ,{203, 100, 52, 0} ,{130, 166, 226, 1} ,{231, 100, 51, 0} ,{231, 100, 230, 33} ,{231, 100, 216, 37} ,{231, 100, 58, 0} ,{231, 100, 212, 0} ,{231, 100, 89, 7} ,{231, 100, 48, 0} ,{231, 100, 56, 0} ,{231, 100, 217, 37} ,{231, 100, 151, 17} ,{231, 100, 218, 37} ,{231, 100, 219, 37} ,{231, 100, 220, 37} ,{231, 100, 221, 37} ,{231, 100, 182, 7} ,{231, 100, 57, 0} ,{231, 100, 46, 0} ,{231, 100, 222, 37} ,{231, 100, 63, 0} ,{231, 100, 226, 22} ,{231, 100, 228, 2} ,{231, 100, 54, 0} ,{231, 100, 47, 0} ,{231, 100, 55, 0} ,{231, 100, 64, 0} ,{231, 100, 60, 0} ,{231, 100, 52, 0} ,{130, 166, 230, 5} ,{3, 101, 51, 0} ,{3, 101, 230, 33} ,{3, 101, 216, 37} ,{3, 101, 58, 0} ,{3, 101, 212, 0} ,{3, 101, 89, 7} ,{3, 101, 48, 0} ,{3, 101, 56, 0} ,{3, 101, 217, 37} ,{3, 101, 151, 17} ,{3, 101, 218, 37} ,{3, 101, 219, 37} ,{3, 101, 220, 37} ,{3, 101, 221, 37} ,{3, 101, 182, 7} ,{3, 101, 57, 0} ,{3, 101, 46, 0} ,{3, 101, 222, 37} ,{3, 101, 63, 0} ,{3, 101, 226, 22} ,{3, 101, 228, 2} ,{3, 101, 54, 0} ,{3, 101, 47, 0} ,{3, 101, 55, 0} ,{3, 101, 64, 0} ,{3, 101, 60, 0} ,{3, 101, 52, 0} ,{130, 166, 170, 1} ,{31, 101, 51, 0} ,{31, 101, 230, 33} ,{31, 101, 216, 37} ,{31, 101, 58, 0} ,{31, 101, 212, 0} ,{31, 101, 89, 7} ,{31, 101, 48, 0} ,{31, 101, 56, 0} ,{31, 101, 217, 37} ,{31, 101, 151, 17} ,{31, 101, 218, 37} ,{31, 101, 219, 37} ,{31, 101, 220, 37} ,{31, 101, 221, 37} ,{31, 101, 182, 7} ,{31, 101, 57, 0} ,{31, 101, 46, 0} ,{31, 101, 222, 37} ,{31, 101, 63, 0} ,{31, 101, 226, 22} ,{31, 101, 228, 2} ,{31, 101, 54, 0} ,{31, 101, 47, 0} ,{31, 101, 55, 0} ,{31, 101, 64, 0} ,{31, 101, 60, 0} ,{31, 101, 52, 0} ,{130, 166, 110, 5} ,{59, 101, 51, 0} ,{59, 101, 230, 33} ,{59, 101, 216, 37} ,{59, 101, 58, 0} ,{59, 101, 212, 0} ,{59, 101, 89, 7} ,{59, 101, 48, 0} ,{59, 101, 56, 0} ,{59, 101, 217, 37} ,{59, 101, 151, 17} ,{59, 101, 218, 37} ,{59, 101, 219, 37} ,{59, 101, 220, 37} ,{59, 101, 221, 37} ,{59, 101, 182, 7} ,{59, 101, 57, 0} ,{59, 101, 46, 0} ,{59, 101, 222, 37} ,{59, 101, 63, 0} ,{59, 101, 226, 22} ,{59, 101, 228, 2} ,{59, 101, 54, 0} ,{59, 101, 47, 0} ,{59, 101, 55, 0} ,{59, 101, 64, 0} ,{59, 101, 60, 0} ,{59, 101, 52, 0} ,{130, 166, 141, 1} ,{87, 101, 51, 0} ,{87, 101, 230, 33} ,{87, 101, 216, 37} ,{87, 101, 58, 0} ,{87, 101, 212, 0} ,{87, 101, 89, 7} ,{87, 101, 48, 0} ,{87, 101, 56, 0} ,{87, 101, 217, 37} ,{87, 101, 151, 17} ,{87, 101, 218, 37} ,{87, 101, 219, 37} ,{87, 101, 220, 37} ,{87, 101, 221, 37} ,{87, 101, 182, 7} ,{87, 101, 57, 0} ,{87, 101, 46, 0} ,{87, 101, 222, 37} ,{87, 101, 63, 0} ,{87, 101, 226, 22} ,{87, 101, 228, 2} ,{87, 101, 54, 0} ,{87, 101, 47, 0} ,{87, 101, 55, 0} ,{87, 101, 64, 0} ,{87, 101, 60, 0} ,{87, 101, 52, 0} ,{130, 166, 53, 0} ,{115, 101, 51, 0} ,{115, 101, 230, 33} ,{115, 101, 216, 37} ,{115, 101, 58, 0} ,{115, 101, 212, 0} ,{115, 101, 89, 7} ,{115, 101, 48, 0} ,{115, 101, 56, 0} ,{115, 101, 217, 37} ,{115, 101, 151, 17} ,{115, 101, 218, 37} ,{115, 101, 219, 37} ,{115, 101, 220, 37} ,{115, 101, 221, 37} ,{115, 101, 182, 7} ,{115, 101, 57, 0} ,{115, 101, 46, 0} ,{115, 101, 222, 37} ,{115, 101, 63, 0} ,{115, 101, 226, 22} ,{115, 101, 228, 2} ,{115, 101, 54, 0} ,{115, 101, 47, 0} ,{115, 101, 55, 0} ,{115, 101, 64, 0} ,{115, 101, 60, 0} ,{115, 101, 52, 0} ,{131, 166, 45, 0} ,{143, 101, 51, 0} ,{143, 101, 230, 33} ,{143, 101, 216, 37} ,{143, 101, 58, 0} ,{143, 101, 212, 0} ,{143, 101, 89, 7} ,{143, 101, 48, 0} ,{143, 101, 56, 0} ,{143, 101, 217, 37} ,{143, 101, 151, 17} ,{143, 101, 218, 37} ,{143, 101, 219, 37} ,{143, 101, 220, 37} ,{143, 101, 221, 37} ,{143, 101, 182, 7} ,{143, 101, 57, 0} ,{143, 101, 46, 0} ,{143, 101, 222, 37} ,{143, 101, 63, 0} ,{143, 101, 226, 22} ,{143, 101, 228, 2} ,{143, 101, 54, 0} ,{143, 101, 47, 0} ,{143, 101, 55, 0} ,{143, 101, 64, 0} ,{143, 101, 60, 0} ,{143, 101, 52, 0} ,{131, 166, 133, 0} ,{171, 101, 51, 0} ,{171, 101, 230, 33} ,{171, 101, 216, 37} ,{171, 101, 58, 0} ,{171, 101, 212, 0} ,{171, 101, 89, 7} ,{171, 101, 48, 0} ,{171, 101, 56, 0} ,{171, 101, 217, 37} ,{171, 101, 151, 17} ,{171, 101, 218, 37} ,{171, 101, 219, 37} ,{171, 101, 220, 37} ,{171, 101, 221, 37} ,{171, 101, 182, 7} ,{171, 101, 57, 0} ,{171, 101, 46, 0} ,{171, 101, 222, 37} ,{171, 101, 63, 0} ,{171, 101, 226, 22} ,{171, 101, 228, 2} ,{171, 101, 54, 0} ,{171, 101, 47, 0} ,{171, 101, 55, 0} ,{171, 101, 64, 0} ,{171, 101, 60, 0} ,{171, 101, 52, 0} ,{131, 166, 171, 1} ,{199, 101, 51, 0} ,{199, 101, 230, 33} ,{199, 101, 216, 37} ,{199, 101, 58, 0} ,{199, 101, 212, 0} ,{199, 101, 89, 7} ,{199, 101, 48, 0} ,{199, 101, 56, 0} ,{199, 101, 217, 37} ,{199, 101, 151, 17} ,{199, 101, 218, 37} ,{199, 101, 219, 37} ,{199, 101, 220, 37} ,{199, 101, 221, 37} ,{199, 101, 182, 7} ,{199, 101, 57, 0} ,{199, 101, 46, 0} ,{199, 101, 222, 37} ,{199, 101, 63, 0} ,{199, 101, 226, 22} ,{199, 101, 228, 2} ,{199, 101, 54, 0} ,{199, 101, 47, 0} ,{199, 101, 55, 0} ,{199, 101, 64, 0} ,{199, 101, 60, 0} ,{199, 101, 52, 0} ,{131, 166, 224, 1} ,{227, 101, 51, 0} ,{227, 101, 230, 33} ,{227, 101, 216, 37} ,{227, 101, 58, 0} ,{227, 101, 212, 0} ,{227, 101, 89, 7} ,{227, 101, 48, 0} ,{227, 101, 56, 0} ,{227, 101, 217, 37} ,{227, 101, 151, 17} ,{227, 101, 218, 37} ,{227, 101, 219, 37} ,{227, 101, 220, 37} ,{227, 101, 221, 37} ,{227, 101, 182, 7} ,{227, 101, 57, 0} ,{227, 101, 46, 0} ,{227, 101, 222, 37} ,{227, 101, 63, 0} ,{227, 101, 226, 22} ,{227, 101, 228, 2} ,{227, 101, 54, 0} ,{227, 101, 47, 0} ,{227, 101, 55, 0} ,{227, 101, 64, 0} ,{227, 101, 60, 0} ,{227, 101, 52, 0} ,{131, 166, 225, 5} ,{255, 101, 51, 0} ,{255, 101, 230, 33} ,{255, 101, 216, 37} ,{255, 101, 58, 0} ,{255, 101, 212, 0} ,{255, 101, 89, 7} ,{255, 101, 48, 0} ,{255, 101, 56, 0} ,{255, 101, 217, 37} ,{255, 101, 151, 17} ,{255, 101, 218, 37} ,{255, 101, 219, 37} ,{255, 101, 220, 37} ,{255, 101, 221, 37} ,{255, 101, 182, 7} ,{255, 101, 57, 0} ,{255, 101, 46, 0} ,{255, 101, 222, 37} ,{255, 101, 63, 0} ,{255, 101, 226, 22} ,{255, 101, 228, 2} ,{255, 101, 54, 0} ,{255, 101, 47, 0} ,{255, 101, 55, 0} ,{255, 101, 64, 0} ,{255, 101, 60, 0} ,{255, 101, 52, 0} ,{131, 166, 49, 0} ,{27, 102, 51, 0} ,{27, 102, 230, 33} ,{27, 102, 216, 37} ,{27, 102, 58, 0} ,{27, 102, 212, 0} ,{27, 102, 89, 7} ,{27, 102, 48, 0} ,{27, 102, 56, 0} ,{27, 102, 217, 37} ,{27, 102, 151, 17} ,{27, 102, 218, 37} ,{27, 102, 219, 37} ,{27, 102, 220, 37} ,{27, 102, 221, 37} ,{27, 102, 182, 7} ,{27, 102, 57, 0} ,{27, 102, 46, 0} ,{27, 102, 222, 37} ,{27, 102, 63, 0} ,{27, 102, 226, 22} ,{27, 102, 228, 2} ,{27, 102, 54, 0} ,{27, 102, 47, 0} ,{27, 102, 55, 0} ,{27, 102, 64, 0} ,{27, 102, 60, 0} ,{27, 102, 52, 0} ,{131, 166, 226, 5} ,{55, 102, 51, 0} ,{55, 102, 230, 33} ,{55, 102, 216, 37} ,{55, 102, 58, 0} ,{55, 102, 212, 0} ,{55, 102, 89, 7} ,{55, 102, 48, 0} ,{55, 102, 56, 0} ,{55, 102, 217, 37} ,{55, 102, 151, 17} ,{55, 102, 218, 37} ,{55, 102, 219, 37} ,{55, 102, 220, 37} ,{55, 102, 221, 37} ,{55, 102, 182, 7} ,{55, 102, 57, 0} ,{55, 102, 46, 0} ,{55, 102, 222, 37} ,{55, 102, 63, 0} ,{55, 102, 226, 22} ,{55, 102, 228, 2} ,{55, 102, 54, 0} ,{55, 102, 47, 0} ,{55, 102, 55, 0} ,{55, 102, 64, 0} ,{55, 102, 60, 0} ,{55, 102, 52, 0} ,{131, 166, 227, 5} ,{83, 102, 51, 0} ,{83, 102, 230, 33} ,{83, 102, 216, 37} ,{83, 102, 58, 0} ,{83, 102, 212, 0} ,{83, 102, 89, 7} ,{83, 102, 48, 0} ,{83, 102, 56, 0} ,{83, 102, 217, 37} ,{83, 102, 151, 17} ,{83, 102, 218, 37} ,{83, 102, 219, 37} ,{83, 102, 220, 37} ,{83, 102, 221, 37} ,{83, 102, 182, 7} ,{83, 102, 57, 0} ,{83, 102, 46, 0} ,{83, 102, 222, 37} ,{83, 102, 63, 0} ,{83, 102, 226, 22} ,{83, 102, 228, 2} ,{83, 102, 54, 0} ,{83, 102, 47, 0} ,{83, 102, 55, 0} ,{83, 102, 64, 0} ,{83, 102, 60, 0} ,{83, 102, 52, 0} ,{131, 166, 59, 0} ,{111, 102, 51, 0} ,{111, 102, 230, 33} ,{111, 102, 216, 37} ,{111, 102, 58, 0} ,{111, 102, 212, 0} ,{111, 102, 89, 7} ,{111, 102, 48, 0} ,{111, 102, 56, 0} ,{111, 102, 217, 37} ,{111, 102, 151, 17} ,{111, 102, 218, 37} ,{111, 102, 219, 37} ,{111, 102, 220, 37} ,{111, 102, 221, 37} ,{111, 102, 182, 7} ,{111, 102, 57, 0} ,{111, 102, 46, 0} ,{111, 102, 222, 37} ,{111, 102, 63, 0} ,{111, 102, 226, 22} ,{111, 102, 228, 2} ,{111, 102, 54, 0} ,{111, 102, 47, 0} ,{111, 102, 55, 0} ,{111, 102, 64, 0} ,{111, 102, 60, 0} ,{111, 102, 52, 0} ,{131, 166, 140, 3} ,{139, 102, 51, 0} ,{139, 102, 230, 33} ,{139, 102, 216, 37} ,{139, 102, 58, 0} ,{139, 102, 212, 0} ,{139, 102, 89, 7} ,{139, 102, 48, 0} ,{139, 102, 56, 0} ,{139, 102, 217, 37} ,{139, 102, 151, 17} ,{139, 102, 218, 37} ,{139, 102, 219, 37} ,{139, 102, 220, 37} ,{139, 102, 221, 37} ,{139, 102, 182, 7} ,{139, 102, 57, 0} ,{139, 102, 46, 0} ,{139, 102, 222, 37} ,{139, 102, 63, 0} ,{139, 102, 226, 22} ,{139, 102, 228, 2} ,{139, 102, 54, 0} ,{139, 102, 47, 0} ,{139, 102, 55, 0} ,{139, 102, 64, 0} ,{139, 102, 60, 0} ,{139, 102, 52, 0} ,{131, 166, 228, 5} ,{167, 102, 51, 0} ,{167, 102, 230, 33} ,{167, 102, 216, 37} ,{167, 102, 58, 0} ,{167, 102, 212, 0} ,{167, 102, 89, 7} ,{167, 102, 48, 0} ,{167, 102, 56, 0} ,{167, 102, 217, 37} ,{167, 102, 151, 17} ,{167, 102, 218, 37} ,{167, 102, 219, 37} ,{167, 102, 220, 37} ,{167, 102, 221, 37} ,{167, 102, 182, 7} ,{167, 102, 57, 0} ,{167, 102, 46, 0} ,{167, 102, 222, 37} ,{167, 102, 63, 0} ,{167, 102, 226, 22} ,{167, 102, 228, 2} ,{167, 102, 54, 0} ,{167, 102, 47, 0} ,{167, 102, 55, 0} ,{167, 102, 64, 0} ,{167, 102, 60, 0} ,{167, 102, 52, 0} ,{131, 166, 164, 0} ,{195, 102, 51, 0} ,{195, 102, 230, 33} ,{195, 102, 216, 37} ,{195, 102, 58, 0} ,{195, 102, 212, 0} ,{195, 102, 89, 7} ,{195, 102, 48, 0} ,{195, 102, 56, 0} ,{195, 102, 217, 37} ,{195, 102, 151, 17} ,{195, 102, 218, 37} ,{195, 102, 219, 37} ,{195, 102, 220, 37} ,{195, 102, 221, 37} ,{195, 102, 182, 7} ,{195, 102, 57, 0} ,{195, 102, 46, 0} ,{195, 102, 222, 37} ,{195, 102, 63, 0} ,{195, 102, 226, 22} ,{195, 102, 228, 2} ,{195, 102, 54, 0} ,{195, 102, 47, 0} ,{195, 102, 55, 0} ,{195, 102, 64, 0} ,{195, 102, 60, 0} ,{195, 102, 52, 0} ,{131, 166, 204, 4} ,{223, 102, 51, 0} ,{223, 102, 230, 33} ,{223, 102, 216, 37} ,{223, 102, 58, 0} ,{223, 102, 212, 0} ,{223, 102, 89, 7} ,{223, 102, 48, 0} ,{223, 102, 56, 0} ,{223, 102, 217, 37} ,{223, 102, 151, 17} ,{223, 102, 218, 37} ,{223, 102, 219, 37} ,{223, 102, 220, 37} ,{223, 102, 221, 37} ,{223, 102, 182, 7} ,{223, 102, 57, 0} ,{223, 102, 46, 0} ,{223, 102, 222, 37} ,{223, 102, 63, 0} ,{223, 102, 226, 22} ,{223, 102, 228, 2} ,{223, 102, 54, 0} ,{223, 102, 47, 0} ,{223, 102, 55, 0} ,{223, 102, 64, 0} ,{223, 102, 60, 0} ,{223, 102, 52, 0} ,{131, 166, 65, 0} ,{251, 102, 51, 0} ,{251, 102, 230, 33} ,{251, 102, 216, 37} ,{251, 102, 58, 0} ,{251, 102, 212, 0} ,{251, 102, 89, 7} ,{251, 102, 48, 0} ,{251, 102, 56, 0} ,{251, 102, 217, 37} ,{251, 102, 151, 17} ,{251, 102, 218, 37} ,{251, 102, 219, 37} ,{251, 102, 220, 37} ,{251, 102, 221, 37} ,{251, 102, 182, 7} ,{251, 102, 57, 0} ,{251, 102, 46, 0} ,{251, 102, 222, 37} ,{251, 102, 63, 0} ,{251, 102, 226, 22} ,{251, 102, 228, 2} ,{251, 102, 54, 0} ,{251, 102, 47, 0} ,{251, 102, 55, 0} ,{251, 102, 64, 0} ,{251, 102, 60, 0} ,{251, 102, 52, 0} ,{131, 166, 229, 5} ,{23, 103, 51, 0} ,{23, 103, 230, 33} ,{23, 103, 216, 37} ,{23, 103, 58, 0} ,{23, 103, 212, 0} ,{23, 103, 89, 7} ,{23, 103, 48, 0} ,{23, 103, 56, 0} ,{23, 103, 217, 37} ,{23, 103, 151, 17} ,{23, 103, 218, 37} ,{23, 103, 219, 37} ,{23, 103, 220, 37} ,{23, 103, 221, 37} ,{23, 103, 182, 7} ,{23, 103, 57, 0} ,{23, 103, 46, 0} ,{23, 103, 222, 37} ,{23, 103, 63, 0} ,{23, 103, 226, 22} ,{23, 103, 228, 2} ,{23, 103, 54, 0} ,{23, 103, 47, 0} ,{23, 103, 55, 0} ,{23, 103, 64, 0} ,{23, 103, 60, 0} ,{23, 103, 52, 0} ,{131, 166, 226, 1} ,{51, 103, 51, 0} ,{51, 103, 230, 33} ,{51, 103, 216, 37} ,{51, 103, 58, 0} ,{51, 103, 212, 0} ,{51, 103, 89, 7} ,{51, 103, 48, 0} ,{51, 103, 56, 0} ,{51, 103, 217, 37} ,{51, 103, 151, 17} ,{51, 103, 218, 37} ,{51, 103, 219, 37} ,{51, 103, 220, 37} ,{51, 103, 221, 37} ,{51, 103, 182, 7} ,{51, 103, 57, 0} ,{51, 103, 46, 0} ,{51, 103, 222, 37} ,{51, 103, 63, 0} ,{51, 103, 226, 22} ,{51, 103, 228, 2} ,{51, 103, 54, 0} ,{51, 103, 47, 0} ,{51, 103, 55, 0} ,{51, 103, 64, 0} ,{51, 103, 60, 0} ,{51, 103, 52, 0} ,{131, 166, 230, 5} ,{79, 103, 51, 0} ,{79, 103, 230, 33} ,{79, 103, 216, 37} ,{79, 103, 58, 0} ,{79, 103, 212, 0} ,{79, 103, 89, 7} ,{79, 103, 48, 0} ,{79, 103, 56, 0} ,{79, 103, 217, 37} ,{79, 103, 151, 17} ,{79, 103, 218, 37} ,{79, 103, 219, 37} ,{79, 103, 220, 37} ,{79, 103, 221, 37} ,{79, 103, 182, 7} ,{79, 103, 57, 0} ,{79, 103, 46, 0} ,{79, 103, 222, 37} ,{79, 103, 63, 0} ,{79, 103, 226, 22} ,{79, 103, 228, 2} ,{79, 103, 54, 0} ,{79, 103, 47, 0} ,{79, 103, 55, 0} ,{79, 103, 64, 0} ,{79, 103, 60, 0} ,{79, 103, 52, 0} ,{131, 166, 170, 1} ,{107, 103, 51, 0} ,{107, 103, 230, 33} ,{107, 103, 216, 37} ,{107, 103, 58, 0} ,{107, 103, 212, 0} ,{107, 103, 89, 7} ,{107, 103, 48, 0} ,{107, 103, 56, 0} ,{107, 103, 217, 37} ,{107, 103, 151, 17} ,{107, 103, 218, 37} ,{107, 103, 219, 37} ,{107, 103, 220, 37} ,{107, 103, 221, 37} ,{107, 103, 182, 7} ,{107, 103, 57, 0} ,{107, 103, 46, 0} ,{107, 103, 222, 37} ,{107, 103, 63, 0} ,{107, 103, 226, 22} ,{107, 103, 228, 2} ,{107, 103, 54, 0} ,{107, 103, 47, 0} ,{107, 103, 55, 0} ,{107, 103, 64, 0} ,{107, 103, 60, 0} ,{107, 103, 52, 0} ,{131, 166, 110, 5} ,{135, 103, 51, 0} ,{135, 103, 230, 33} ,{135, 103, 216, 37} ,{135, 103, 58, 0} ,{135, 103, 212, 0} ,{135, 103, 89, 7} ,{135, 103, 48, 0} ,{135, 103, 56, 0} ,{135, 103, 217, 37} ,{135, 103, 151, 17} ,{135, 103, 218, 37} ,{135, 103, 219, 37} ,{135, 103, 220, 37} ,{135, 103, 221, 37} ,{135, 103, 182, 7} ,{135, 103, 57, 0} ,{135, 103, 46, 0} ,{135, 103, 222, 37} ,{135, 103, 63, 0} ,{135, 103, 226, 22} ,{135, 103, 228, 2} ,{135, 103, 54, 0} ,{135, 103, 47, 0} ,{135, 103, 55, 0} ,{135, 103, 64, 0} ,{135, 103, 60, 0} ,{135, 103, 52, 0} ,{131, 166, 141, 1} ,{163, 103, 51, 0} ,{163, 103, 230, 33} ,{163, 103, 216, 37} ,{163, 103, 58, 0} ,{163, 103, 212, 0} ,{163, 103, 89, 7} ,{163, 103, 48, 0} ,{163, 103, 56, 0} ,{163, 103, 217, 37} ,{163, 103, 151, 17} ,{163, 103, 218, 37} ,{163, 103, 219, 37} ,{163, 103, 220, 37} ,{163, 103, 221, 37} ,{163, 103, 182, 7} ,{163, 103, 57, 0} ,{163, 103, 46, 0} ,{163, 103, 222, 37} ,{163, 103, 63, 0} ,{163, 103, 226, 22} ,{163, 103, 228, 2} ,{163, 103, 54, 0} ,{163, 103, 47, 0} ,{163, 103, 55, 0} ,{163, 103, 64, 0} ,{163, 103, 60, 0} ,{163, 103, 52, 0} ,{131, 166, 53, 0} ,{191, 103, 51, 0} ,{191, 103, 230, 33} ,{191, 103, 216, 37} ,{191, 103, 58, 0} ,{191, 103, 212, 0} ,{191, 103, 89, 7} ,{191, 103, 48, 0} ,{191, 103, 56, 0} ,{191, 103, 217, 37} ,{191, 103, 151, 17} ,{191, 103, 218, 37} ,{191, 103, 219, 37} ,{191, 103, 220, 37} ,{191, 103, 221, 37} ,{191, 103, 182, 7} ,{191, 103, 57, 0} ,{191, 103, 46, 0} ,{191, 103, 222, 37} ,{191, 103, 63, 0} ,{191, 103, 226, 22} ,{191, 103, 228, 2} ,{191, 103, 54, 0} ,{191, 103, 47, 0} ,{191, 103, 55, 0} ,{191, 103, 64, 0} ,{191, 103, 60, 0} ,{191, 103, 52, 0} ,{132, 166, 45, 0} ,{219, 103, 51, 0} ,{219, 103, 230, 33} ,{219, 103, 216, 37} ,{219, 103, 58, 0} ,{219, 103, 212, 0} ,{219, 103, 89, 7} ,{219, 103, 48, 0} ,{219, 103, 56, 0} ,{219, 103, 217, 37} ,{219, 103, 151, 17} ,{219, 103, 218, 37} ,{219, 103, 219, 37} ,{219, 103, 220, 37} ,{219, 103, 221, 37} ,{219, 103, 182, 7} ,{219, 103, 57, 0} ,{219, 103, 46, 0} ,{219, 103, 222, 37} ,{219, 103, 63, 0} ,{219, 103, 226, 22} ,{219, 103, 228, 2} ,{219, 103, 54, 0} ,{219, 103, 47, 0} ,{219, 103, 55, 0} ,{219, 103, 64, 0} ,{219, 103, 60, 0} ,{219, 103, 52, 0} ,{132, 166, 133, 0} ,{247, 103, 51, 0} ,{247, 103, 230, 33} ,{247, 103, 216, 37} ,{247, 103, 58, 0} ,{247, 103, 212, 0} ,{247, 103, 89, 7} ,{247, 103, 48, 0} ,{247, 103, 56, 0} ,{247, 103, 217, 37} ,{247, 103, 151, 17} ,{247, 103, 218, 37} ,{247, 103, 219, 37} ,{247, 103, 220, 37} ,{247, 103, 221, 37} ,{247, 103, 182, 7} ,{247, 103, 57, 0} ,{247, 103, 46, 0} ,{247, 103, 222, 37} ,{247, 103, 63, 0} ,{247, 103, 226, 22} ,{247, 103, 228, 2} ,{247, 103, 54, 0} ,{247, 103, 47, 0} ,{247, 103, 55, 0} ,{247, 103, 64, 0} ,{247, 103, 60, 0} ,{247, 103, 52, 0} ,{132, 166, 171, 1} ,{19, 104, 51, 0} ,{19, 104, 230, 33} ,{19, 104, 216, 37} ,{19, 104, 58, 0} ,{19, 104, 212, 0} ,{19, 104, 89, 7} ,{19, 104, 48, 0} ,{19, 104, 56, 0} ,{19, 104, 217, 37} ,{19, 104, 151, 17} ,{19, 104, 218, 37} ,{19, 104, 219, 37} ,{19, 104, 220, 37} ,{19, 104, 221, 37} ,{19, 104, 182, 7} ,{19, 104, 57, 0} ,{19, 104, 46, 0} ,{19, 104, 222, 37} ,{19, 104, 63, 0} ,{19, 104, 226, 22} ,{19, 104, 228, 2} ,{19, 104, 54, 0} ,{19, 104, 47, 0} ,{19, 104, 55, 0} ,{19, 104, 64, 0} ,{19, 104, 60, 0} ,{19, 104, 52, 0} ,{132, 166, 224, 1} ,{47, 104, 51, 0} ,{47, 104, 230, 33} ,{47, 104, 216, 37} ,{47, 104, 58, 0} ,{47, 104, 212, 0} ,{47, 104, 89, 7} ,{47, 104, 48, 0} ,{47, 104, 56, 0} ,{47, 104, 217, 37} ,{47, 104, 151, 17} ,{47, 104, 218, 37} ,{47, 104, 219, 37} ,{47, 104, 220, 37} ,{47, 104, 221, 37} ,{47, 104, 182, 7} ,{47, 104, 57, 0} ,{47, 104, 46, 0} ,{47, 104, 222, 37} ,{47, 104, 63, 0} ,{47, 104, 226, 22} ,{47, 104, 228, 2} ,{47, 104, 54, 0} ,{47, 104, 47, 0} ,{47, 104, 55, 0} ,{47, 104, 64, 0} ,{47, 104, 60, 0} ,{47, 104, 52, 0} ,{132, 166, 225, 5} ,{75, 104, 51, 0} ,{75, 104, 230, 33} ,{75, 104, 216, 37} ,{75, 104, 58, 0} ,{75, 104, 212, 0} ,{75, 104, 89, 7} ,{75, 104, 48, 0} ,{75, 104, 56, 0} ,{75, 104, 217, 37} ,{75, 104, 151, 17} ,{75, 104, 218, 37} ,{75, 104, 219, 37} ,{75, 104, 220, 37} ,{75, 104, 221, 37} ,{75, 104, 182, 7} ,{75, 104, 57, 0} ,{75, 104, 46, 0} ,{75, 104, 222, 37} ,{75, 104, 63, 0} ,{75, 104, 226, 22} ,{75, 104, 228, 2} ,{75, 104, 54, 0} ,{75, 104, 47, 0} ,{75, 104, 55, 0} ,{75, 104, 64, 0} ,{75, 104, 60, 0} ,{75, 104, 52, 0} ,{132, 166, 49, 0} ,{103, 104, 51, 0} ,{103, 104, 230, 33} ,{103, 104, 216, 37} ,{103, 104, 58, 0} ,{103, 104, 212, 0} ,{103, 104, 89, 7} ,{103, 104, 48, 0} ,{103, 104, 56, 0} ,{103, 104, 217, 37} ,{103, 104, 151, 17} ,{103, 104, 218, 37} ,{103, 104, 219, 37} ,{103, 104, 220, 37} ,{103, 104, 221, 37} ,{103, 104, 182, 7} ,{103, 104, 57, 0} ,{103, 104, 46, 0} ,{103, 104, 222, 37} ,{103, 104, 63, 0} ,{103, 104, 226, 22} ,{103, 104, 228, 2} ,{103, 104, 54, 0} ,{103, 104, 47, 0} ,{103, 104, 55, 0} ,{103, 104, 64, 0} ,{103, 104, 60, 0} ,{103, 104, 52, 0} ,{132, 166, 226, 5} ,{131, 104, 51, 0} ,{131, 104, 230, 33} ,{131, 104, 216, 37} ,{131, 104, 58, 0} ,{131, 104, 212, 0} ,{131, 104, 89, 7} ,{131, 104, 48, 0} ,{131, 104, 56, 0} ,{131, 104, 217, 37} ,{131, 104, 151, 17} ,{131, 104, 218, 37} ,{131, 104, 219, 37} ,{131, 104, 220, 37} ,{131, 104, 221, 37} ,{131, 104, 182, 7} ,{131, 104, 57, 0} ,{131, 104, 46, 0} ,{131, 104, 222, 37} ,{131, 104, 63, 0} ,{131, 104, 226, 22} ,{131, 104, 228, 2} ,{131, 104, 54, 0} ,{131, 104, 47, 0} ,{131, 104, 55, 0} ,{131, 104, 64, 0} ,{131, 104, 60, 0} ,{131, 104, 52, 0} ,{132, 166, 227, 5} ,{159, 104, 51, 0} ,{159, 104, 230, 33} ,{159, 104, 216, 37} ,{159, 104, 58, 0} ,{159, 104, 212, 0} ,{159, 104, 89, 7} ,{159, 104, 48, 0} ,{159, 104, 56, 0} ,{159, 104, 217, 37} ,{159, 104, 151, 17} ,{159, 104, 218, 37} ,{159, 104, 219, 37} ,{159, 104, 220, 37} ,{159, 104, 221, 37} ,{159, 104, 182, 7} ,{159, 104, 57, 0} ,{159, 104, 46, 0} ,{159, 104, 222, 37} ,{159, 104, 63, 0} ,{159, 104, 226, 22} ,{159, 104, 228, 2} ,{159, 104, 54, 0} ,{159, 104, 47, 0} ,{159, 104, 55, 0} ,{159, 104, 64, 0} ,{159, 104, 60, 0} ,{159, 104, 52, 0} ,{132, 166, 59, 0} ,{187, 104, 51, 0} ,{187, 104, 230, 33} ,{187, 104, 216, 37} ,{187, 104, 58, 0} ,{187, 104, 212, 0} ,{187, 104, 89, 7} ,{187, 104, 48, 0} ,{187, 104, 56, 0} ,{187, 104, 217, 37} ,{187, 104, 151, 17} ,{187, 104, 218, 37} ,{187, 104, 219, 37} ,{187, 104, 220, 37} ,{187, 104, 221, 37} ,{187, 104, 182, 7} ,{187, 104, 57, 0} ,{187, 104, 46, 0} ,{187, 104, 222, 37} ,{187, 104, 63, 0} ,{187, 104, 226, 22} ,{187, 104, 228, 2} ,{187, 104, 54, 0} ,{187, 104, 47, 0} ,{187, 104, 55, 0} ,{187, 104, 64, 0} ,{187, 104, 60, 0} ,{187, 104, 52, 0} ,{132, 166, 140, 3} ,{215, 104, 51, 0} ,{215, 104, 230, 33} ,{215, 104, 216, 37} ,{215, 104, 58, 0} ,{215, 104, 212, 0} ,{215, 104, 89, 7} ,{215, 104, 48, 0} ,{215, 104, 56, 0} ,{215, 104, 217, 37} ,{215, 104, 151, 17} ,{215, 104, 218, 37} ,{215, 104, 219, 37} ,{215, 104, 220, 37} ,{215, 104, 221, 37} ,{215, 104, 182, 7} ,{215, 104, 57, 0} ,{215, 104, 46, 0} ,{215, 104, 222, 37} ,{215, 104, 63, 0} ,{215, 104, 226, 22} ,{215, 104, 228, 2} ,{215, 104, 54, 0} ,{215, 104, 47, 0} ,{215, 104, 55, 0} ,{215, 104, 64, 0} ,{215, 104, 60, 0} ,{215, 104, 52, 0} ,{132, 166, 228, 5} ,{243, 104, 51, 0} ,{243, 104, 230, 33} ,{243, 104, 216, 37} ,{243, 104, 58, 0} ,{243, 104, 212, 0} ,{243, 104, 89, 7} ,{243, 104, 48, 0} ,{243, 104, 56, 0} ,{243, 104, 217, 37} ,{243, 104, 151, 17} ,{243, 104, 218, 37} ,{243, 104, 219, 37} ,{243, 104, 220, 37} ,{243, 104, 221, 37} ,{243, 104, 182, 7} ,{243, 104, 57, 0} ,{243, 104, 46, 0} ,{243, 104, 222, 37} ,{243, 104, 63, 0} ,{243, 104, 226, 22} ,{243, 104, 228, 2} ,{243, 104, 54, 0} ,{243, 104, 47, 0} ,{243, 104, 55, 0} ,{243, 104, 64, 0} ,{243, 104, 60, 0} ,{243, 104, 52, 0} ,{132, 166, 164, 0} ,{15, 105, 51, 0} ,{15, 105, 230, 33} ,{15, 105, 216, 37} ,{15, 105, 58, 0} ,{15, 105, 212, 0} ,{15, 105, 89, 7} ,{15, 105, 48, 0} ,{15, 105, 56, 0} ,{15, 105, 217, 37} ,{15, 105, 151, 17} ,{15, 105, 218, 37} ,{15, 105, 219, 37} ,{15, 105, 220, 37} ,{15, 105, 221, 37} ,{15, 105, 182, 7} ,{15, 105, 57, 0} ,{15, 105, 46, 0} ,{15, 105, 222, 37} ,{15, 105, 63, 0} ,{15, 105, 226, 22} ,{15, 105, 228, 2} ,{15, 105, 54, 0} ,{15, 105, 47, 0} ,{15, 105, 55, 0} ,{15, 105, 64, 0} ,{15, 105, 60, 0} ,{15, 105, 52, 0} ,{132, 166, 204, 4} ,{43, 105, 51, 0} ,{43, 105, 230, 33} ,{43, 105, 216, 37} ,{43, 105, 58, 0} ,{43, 105, 212, 0} ,{43, 105, 89, 7} ,{43, 105, 48, 0} ,{43, 105, 56, 0} ,{43, 105, 217, 37} ,{43, 105, 151, 17} ,{43, 105, 218, 37} ,{43, 105, 219, 37} ,{43, 105, 220, 37} ,{43, 105, 221, 37} ,{43, 105, 182, 7} ,{43, 105, 57, 0} ,{43, 105, 46, 0} ,{43, 105, 222, 37} ,{43, 105, 63, 0} ,{43, 105, 226, 22} ,{43, 105, 228, 2} ,{43, 105, 54, 0} ,{43, 105, 47, 0} ,{43, 105, 55, 0} ,{43, 105, 64, 0} ,{43, 105, 60, 0} ,{43, 105, 52, 0} ,{132, 166, 65, 0} ,{71, 105, 51, 0} ,{71, 105, 230, 33} ,{71, 105, 216, 37} ,{71, 105, 58, 0} ,{71, 105, 212, 0} ,{71, 105, 89, 7} ,{71, 105, 48, 0} ,{71, 105, 56, 0} ,{71, 105, 217, 37} ,{71, 105, 151, 17} ,{71, 105, 218, 37} ,{71, 105, 219, 37} ,{71, 105, 220, 37} ,{71, 105, 221, 37} ,{71, 105, 182, 7} ,{71, 105, 57, 0} ,{71, 105, 46, 0} ,{71, 105, 222, 37} ,{71, 105, 63, 0} ,{71, 105, 226, 22} ,{71, 105, 228, 2} ,{71, 105, 54, 0} ,{71, 105, 47, 0} ,{71, 105, 55, 0} ,{71, 105, 64, 0} ,{71, 105, 60, 0} ,{71, 105, 52, 0} ,{132, 166, 229, 5} ,{99, 105, 51, 0} ,{99, 105, 230, 33} ,{99, 105, 216, 37} ,{99, 105, 58, 0} ,{99, 105, 212, 0} ,{99, 105, 89, 7} ,{99, 105, 48, 0} ,{99, 105, 56, 0} ,{99, 105, 217, 37} ,{99, 105, 151, 17} ,{99, 105, 218, 37} ,{99, 105, 219, 37} ,{99, 105, 220, 37} ,{99, 105, 221, 37} ,{99, 105, 182, 7} ,{99, 105, 57, 0} ,{99, 105, 46, 0} ,{99, 105, 222, 37} ,{99, 105, 63, 0} ,{99, 105, 226, 22} ,{99, 105, 228, 2} ,{99, 105, 54, 0} ,{99, 105, 47, 0} ,{99, 105, 55, 0} ,{99, 105, 64, 0} ,{99, 105, 60, 0} ,{99, 105, 52, 0} ,{132, 166, 226, 1} ,{127, 105, 51, 0} ,{127, 105, 230, 33} ,{127, 105, 216, 37} ,{127, 105, 58, 0} ,{127, 105, 212, 0} ,{127, 105, 89, 7} ,{127, 105, 48, 0} ,{127, 105, 56, 0} ,{127, 105, 217, 37} ,{127, 105, 151, 17} ,{127, 105, 218, 37} ,{127, 105, 219, 37} ,{127, 105, 220, 37} ,{127, 105, 221, 37} ,{127, 105, 182, 7} ,{127, 105, 57, 0} ,{127, 105, 46, 0} ,{127, 105, 222, 37} ,{127, 105, 63, 0} ,{127, 105, 226, 22} ,{127, 105, 228, 2} ,{127, 105, 54, 0} ,{127, 105, 47, 0} ,{127, 105, 55, 0} ,{127, 105, 64, 0} ,{127, 105, 60, 0} ,{127, 105, 52, 0} ,{132, 166, 230, 5} ,{155, 105, 51, 0} ,{155, 105, 230, 33} ,{155, 105, 216, 37} ,{155, 105, 58, 0} ,{155, 105, 212, 0} ,{155, 105, 89, 7} ,{155, 105, 48, 0} ,{155, 105, 56, 0} ,{155, 105, 217, 37} ,{155, 105, 151, 17} ,{155, 105, 218, 37} ,{155, 105, 219, 37} ,{155, 105, 220, 37} ,{155, 105, 221, 37} ,{155, 105, 182, 7} ,{155, 105, 57, 0} ,{155, 105, 46, 0} ,{155, 105, 222, 37} ,{155, 105, 63, 0} ,{155, 105, 226, 22} ,{155, 105, 228, 2} ,{155, 105, 54, 0} ,{155, 105, 47, 0} ,{155, 105, 55, 0} ,{155, 105, 64, 0} ,{155, 105, 60, 0} ,{155, 105, 52, 0} ,{132, 166, 170, 1} ,{183, 105, 51, 0} ,{183, 105, 230, 33} ,{183, 105, 216, 37} ,{183, 105, 58, 0} ,{183, 105, 212, 0} ,{183, 105, 89, 7} ,{183, 105, 48, 0} ,{183, 105, 56, 0} ,{183, 105, 217, 37} ,{183, 105, 151, 17} ,{183, 105, 218, 37} ,{183, 105, 219, 37} ,{183, 105, 220, 37} ,{183, 105, 221, 37} ,{183, 105, 182, 7} ,{183, 105, 57, 0} ,{183, 105, 46, 0} ,{183, 105, 222, 37} ,{183, 105, 63, 0} ,{183, 105, 226, 22} ,{183, 105, 228, 2} ,{183, 105, 54, 0} ,{183, 105, 47, 0} ,{183, 105, 55, 0} ,{183, 105, 64, 0} ,{183, 105, 60, 0} ,{183, 105, 52, 0} ,{132, 166, 110, 5} ,{211, 105, 51, 0} ,{211, 105, 230, 33} ,{211, 105, 216, 37} ,{211, 105, 58, 0} ,{211, 105, 212, 0} ,{211, 105, 89, 7} ,{211, 105, 48, 0} ,{211, 105, 56, 0} ,{211, 105, 217, 37} ,{211, 105, 151, 17} ,{211, 105, 218, 37} ,{211, 105, 219, 37} ,{211, 105, 220, 37} ,{211, 105, 221, 37} ,{211, 105, 182, 7} ,{211, 105, 57, 0} ,{211, 105, 46, 0} ,{211, 105, 222, 37} ,{211, 105, 63, 0} ,{211, 105, 226, 22} ,{211, 105, 228, 2} ,{211, 105, 54, 0} ,{211, 105, 47, 0} ,{211, 105, 55, 0} ,{211, 105, 64, 0} ,{211, 105, 60, 0} ,{211, 105, 52, 0} ,{132, 166, 141, 1} ,{239, 105, 51, 0} ,{239, 105, 230, 33} ,{239, 105, 216, 37} ,{239, 105, 58, 0} ,{239, 105, 212, 0} ,{239, 105, 89, 7} ,{239, 105, 48, 0} ,{239, 105, 56, 0} ,{239, 105, 217, 37} ,{239, 105, 151, 17} ,{239, 105, 218, 37} ,{239, 105, 219, 37} ,{239, 105, 220, 37} ,{239, 105, 221, 37} ,{239, 105, 182, 7} ,{239, 105, 57, 0} ,{239, 105, 46, 0} ,{239, 105, 222, 37} ,{239, 105, 63, 0} ,{239, 105, 226, 22} ,{239, 105, 228, 2} ,{239, 105, 54, 0} ,{239, 105, 47, 0} ,{239, 105, 55, 0} ,{239, 105, 64, 0} ,{239, 105, 60, 0} ,{239, 105, 52, 0} ,{132, 166, 53, 0} ,{11, 106, 51, 0} ,{11, 106, 230, 33} ,{11, 106, 216, 37} ,{11, 106, 58, 0} ,{11, 106, 212, 0} ,{11, 106, 89, 7} ,{11, 106, 48, 0} ,{11, 106, 56, 0} ,{11, 106, 217, 37} ,{11, 106, 151, 17} ,{11, 106, 218, 37} ,{11, 106, 219, 37} ,{11, 106, 220, 37} ,{11, 106, 221, 37} ,{11, 106, 182, 7} ,{11, 106, 57, 0} ,{11, 106, 46, 0} ,{11, 106, 222, 37} ,{11, 106, 63, 0} ,{11, 106, 226, 22} ,{11, 106, 228, 2} ,{11, 106, 54, 0} ,{11, 106, 47, 0} ,{11, 106, 55, 0} ,{11, 106, 64, 0} ,{11, 106, 60, 0} ,{11, 106, 52, 0} ,{133, 166, 45, 0} ,{39, 106, 51, 0} ,{39, 106, 230, 33} ,{39, 106, 216, 37} ,{39, 106, 58, 0} ,{39, 106, 212, 0} ,{39, 106, 89, 7} ,{39, 106, 48, 0} ,{39, 106, 56, 0} ,{39, 106, 217, 37} ,{39, 106, 151, 17} ,{39, 106, 218, 37} ,{39, 106, 219, 37} ,{39, 106, 220, 37} ,{39, 106, 221, 37} ,{39, 106, 182, 7} ,{39, 106, 57, 0} ,{39, 106, 46, 0} ,{39, 106, 222, 37} ,{39, 106, 63, 0} ,{39, 106, 226, 22} ,{39, 106, 228, 2} ,{39, 106, 54, 0} ,{39, 106, 47, 0} ,{39, 106, 55, 0} ,{39, 106, 64, 0} ,{39, 106, 60, 0} ,{39, 106, 52, 0} ,{133, 166, 133, 0} ,{67, 106, 51, 0} ,{67, 106, 230, 33} ,{67, 106, 216, 37} ,{67, 106, 58, 0} ,{67, 106, 212, 0} ,{67, 106, 89, 7} ,{67, 106, 48, 0} ,{67, 106, 56, 0} ,{67, 106, 217, 37} ,{67, 106, 151, 17} ,{67, 106, 218, 37} ,{67, 106, 219, 37} ,{67, 106, 220, 37} ,{67, 106, 221, 37} ,{67, 106, 182, 7} ,{67, 106, 57, 0} ,{67, 106, 46, 0} ,{67, 106, 222, 37} ,{67, 106, 63, 0} ,{67, 106, 226, 22} ,{67, 106, 228, 2} ,{67, 106, 54, 0} ,{67, 106, 47, 0} ,{67, 106, 55, 0} ,{67, 106, 64, 0} ,{67, 106, 60, 0} ,{67, 106, 52, 0} ,{133, 166, 171, 1} ,{95, 106, 51, 0} ,{95, 106, 230, 33} ,{95, 106, 216, 37} ,{95, 106, 58, 0} ,{95, 106, 212, 0} ,{95, 106, 89, 7} ,{95, 106, 48, 0} ,{95, 106, 56, 0} ,{95, 106, 217, 37} ,{95, 106, 151, 17} ,{95, 106, 218, 37} ,{95, 106, 219, 37} ,{95, 106, 220, 37} ,{95, 106, 221, 37} ,{95, 106, 182, 7} ,{95, 106, 57, 0} ,{95, 106, 46, 0} ,{95, 106, 222, 37} ,{95, 106, 63, 0} ,{95, 106, 226, 22} ,{95, 106, 228, 2} ,{95, 106, 54, 0} ,{95, 106, 47, 0} ,{95, 106, 55, 0} ,{95, 106, 64, 0} ,{95, 106, 60, 0} ,{95, 106, 52, 0} ,{133, 166, 224, 1} ,{123, 106, 51, 0} ,{123, 106, 230, 33} ,{123, 106, 216, 37} ,{123, 106, 58, 0} ,{123, 106, 212, 0} ,{123, 106, 89, 7} ,{123, 106, 48, 0} ,{123, 106, 56, 0} ,{123, 106, 217, 37} ,{123, 106, 151, 17} ,{123, 106, 218, 37} ,{123, 106, 219, 37} ,{123, 106, 220, 37} ,{123, 106, 221, 37} ,{123, 106, 182, 7} ,{123, 106, 57, 0} ,{123, 106, 46, 0} ,{123, 106, 222, 37} ,{123, 106, 63, 0} ,{123, 106, 226, 22} ,{123, 106, 228, 2} ,{123, 106, 54, 0} ,{123, 106, 47, 0} ,{123, 106, 55, 0} ,{123, 106, 64, 0} ,{123, 106, 60, 0} ,{123, 106, 52, 0} ,{133, 166, 225, 5} ,{151, 106, 51, 0} ,{151, 106, 230, 33} ,{151, 106, 216, 37} ,{151, 106, 58, 0} ,{151, 106, 212, 0} ,{151, 106, 89, 7} ,{151, 106, 48, 0} ,{151, 106, 56, 0} ,{151, 106, 217, 37} ,{151, 106, 151, 17} ,{151, 106, 218, 37} ,{151, 106, 219, 37} ,{151, 106, 220, 37} ,{151, 106, 221, 37} ,{151, 106, 182, 7} ,{151, 106, 57, 0} ,{151, 106, 46, 0} ,{151, 106, 222, 37} ,{151, 106, 63, 0} ,{151, 106, 226, 22} ,{151, 106, 228, 2} ,{151, 106, 54, 0} ,{151, 106, 47, 0} ,{151, 106, 55, 0} ,{151, 106, 64, 0} ,{151, 106, 60, 0} ,{151, 106, 52, 0} ,{133, 166, 49, 0} ,{179, 106, 51, 0} ,{179, 106, 230, 33} ,{179, 106, 216, 37} ,{179, 106, 58, 0} ,{179, 106, 212, 0} ,{179, 106, 89, 7} ,{179, 106, 48, 0} ,{179, 106, 56, 0} ,{179, 106, 217, 37} ,{179, 106, 151, 17} ,{179, 106, 218, 37} ,{179, 106, 219, 37} ,{179, 106, 220, 37} ,{179, 106, 221, 37} ,{179, 106, 182, 7} ,{179, 106, 57, 0} ,{179, 106, 46, 0} ,{179, 106, 222, 37} ,{179, 106, 63, 0} ,{179, 106, 226, 22} ,{179, 106, 228, 2} ,{179, 106, 54, 0} ,{179, 106, 47, 0} ,{179, 106, 55, 0} ,{179, 106, 64, 0} ,{179, 106, 60, 0} ,{179, 106, 52, 0} ,{133, 166, 226, 5} ,{207, 106, 51, 0} ,{207, 106, 230, 33} ,{207, 106, 216, 37} ,{207, 106, 58, 0} ,{207, 106, 212, 0} ,{207, 106, 89, 7} ,{207, 106, 48, 0} ,{207, 106, 56, 0} ,{207, 106, 217, 37} ,{207, 106, 151, 17} ,{207, 106, 218, 37} ,{207, 106, 219, 37} ,{207, 106, 220, 37} ,{207, 106, 221, 37} ,{207, 106, 182, 7} ,{207, 106, 57, 0} ,{207, 106, 46, 0} ,{207, 106, 222, 37} ,{207, 106, 63, 0} ,{207, 106, 226, 22} ,{207, 106, 228, 2} ,{207, 106, 54, 0} ,{207, 106, 47, 0} ,{207, 106, 55, 0} ,{207, 106, 64, 0} ,{207, 106, 60, 0} ,{207, 106, 52, 0} ,{133, 166, 227, 5} ,{235, 106, 51, 0} ,{235, 106, 230, 33} ,{235, 106, 216, 37} ,{235, 106, 58, 0} ,{235, 106, 212, 0} ,{235, 106, 89, 7} ,{235, 106, 48, 0} ,{235, 106, 56, 0} ,{235, 106, 217, 37} ,{235, 106, 151, 17} ,{235, 106, 218, 37} ,{235, 106, 219, 37} ,{235, 106, 220, 37} ,{235, 106, 221, 37} ,{235, 106, 182, 7} ,{235, 106, 57, 0} ,{235, 106, 46, 0} ,{235, 106, 222, 37} ,{235, 106, 63, 0} ,{235, 106, 226, 22} ,{235, 106, 228, 2} ,{235, 106, 54, 0} ,{235, 106, 47, 0} ,{235, 106, 55, 0} ,{235, 106, 64, 0} ,{235, 106, 60, 0} ,{235, 106, 52, 0} ,{133, 166, 59, 0} ,{7, 107, 51, 0} ,{7, 107, 230, 33} ,{7, 107, 216, 37} ,{7, 107, 58, 0} ,{7, 107, 212, 0} ,{7, 107, 89, 7} ,{7, 107, 48, 0} ,{7, 107, 56, 0} ,{7, 107, 217, 37} ,{7, 107, 151, 17} ,{7, 107, 218, 37} ,{7, 107, 219, 37} ,{7, 107, 220, 37} ,{7, 107, 221, 37} ,{7, 107, 182, 7} ,{7, 107, 57, 0} ,{7, 107, 46, 0} ,{7, 107, 222, 37} ,{7, 107, 63, 0} ,{7, 107, 226, 22} ,{7, 107, 228, 2} ,{7, 107, 54, 0} ,{7, 107, 47, 0} ,{7, 107, 55, 0} ,{7, 107, 64, 0} ,{7, 107, 60, 0} ,{7, 107, 52, 0} ,{133, 166, 140, 3} ,{35, 107, 51, 0} ,{35, 107, 230, 33} ,{35, 107, 216, 37} ,{35, 107, 58, 0} ,{35, 107, 212, 0} ,{35, 107, 89, 7} ,{35, 107, 48, 0} ,{35, 107, 56, 0} ,{35, 107, 217, 37} ,{35, 107, 151, 17} ,{35, 107, 218, 37} ,{35, 107, 219, 37} ,{35, 107, 220, 37} ,{35, 107, 221, 37} ,{35, 107, 182, 7} ,{35, 107, 57, 0} ,{35, 107, 46, 0} ,{35, 107, 222, 37} ,{35, 107, 63, 0} ,{35, 107, 226, 22} ,{35, 107, 228, 2} ,{35, 107, 54, 0} ,{35, 107, 47, 0} ,{35, 107, 55, 0} ,{35, 107, 64, 0} ,{35, 107, 60, 0} ,{35, 107, 52, 0} ,{133, 166, 228, 5} ,{63, 107, 51, 0} ,{63, 107, 230, 33} ,{63, 107, 216, 37} ,{63, 107, 58, 0} ,{63, 107, 212, 0} ,{63, 107, 89, 7} ,{63, 107, 48, 0} ,{63, 107, 56, 0} ,{63, 107, 217, 37} ,{63, 107, 151, 17} ,{63, 107, 218, 37} ,{63, 107, 219, 37} ,{63, 107, 220, 37} ,{63, 107, 221, 37} ,{63, 107, 182, 7} ,{63, 107, 57, 0} ,{63, 107, 46, 0} ,{63, 107, 222, 37} ,{63, 107, 63, 0} ,{63, 107, 226, 22} ,{63, 107, 228, 2} ,{63, 107, 54, 0} ,{63, 107, 47, 0} ,{63, 107, 55, 0} ,{63, 107, 64, 0} ,{63, 107, 60, 0} ,{63, 107, 52, 0} ,{133, 166, 164, 0} ,{91, 107, 51, 0} ,{91, 107, 230, 33} ,{91, 107, 216, 37} ,{91, 107, 58, 0} ,{91, 107, 212, 0} ,{91, 107, 89, 7} ,{91, 107, 48, 0} ,{91, 107, 56, 0} ,{91, 107, 217, 37} ,{91, 107, 151, 17} ,{91, 107, 218, 37} ,{91, 107, 219, 37} ,{91, 107, 220, 37} ,{91, 107, 221, 37} ,{91, 107, 182, 7} ,{91, 107, 57, 0} ,{91, 107, 46, 0} ,{91, 107, 222, 37} ,{91, 107, 63, 0} ,{91, 107, 226, 22} ,{91, 107, 228, 2} ,{91, 107, 54, 0} ,{91, 107, 47, 0} ,{91, 107, 55, 0} ,{91, 107, 64, 0} ,{91, 107, 60, 0} ,{91, 107, 52, 0} ,{133, 166, 204, 4} ,{119, 107, 51, 0} ,{119, 107, 230, 33} ,{119, 107, 216, 37} ,{119, 107, 58, 0} ,{119, 107, 212, 0} ,{119, 107, 89, 7} ,{119, 107, 48, 0} ,{119, 107, 56, 0} ,{119, 107, 217, 37} ,{119, 107, 151, 17} ,{119, 107, 218, 37} ,{119, 107, 219, 37} ,{119, 107, 220, 37} ,{119, 107, 221, 37} ,{119, 107, 182, 7} ,{119, 107, 57, 0} ,{119, 107, 46, 0} ,{119, 107, 222, 37} ,{119, 107, 63, 0} ,{119, 107, 226, 22} ,{119, 107, 228, 2} ,{119, 107, 54, 0} ,{119, 107, 47, 0} ,{119, 107, 55, 0} ,{119, 107, 64, 0} ,{119, 107, 60, 0} ,{119, 107, 52, 0} ,{133, 166, 65, 0} ,{147, 107, 51, 0} ,{147, 107, 230, 33} ,{147, 107, 216, 37} ,{147, 107, 58, 0} ,{147, 107, 212, 0} ,{147, 107, 89, 7} ,{147, 107, 48, 0} ,{147, 107, 56, 0} ,{147, 107, 217, 37} ,{147, 107, 151, 17} ,{147, 107, 218, 37} ,{147, 107, 219, 37} ,{147, 107, 220, 37} ,{147, 107, 221, 37} ,{147, 107, 182, 7} ,{147, 107, 57, 0} ,{147, 107, 46, 0} ,{147, 107, 222, 37} ,{147, 107, 63, 0} ,{147, 107, 226, 22} ,{147, 107, 228, 2} ,{147, 107, 54, 0} ,{147, 107, 47, 0} ,{147, 107, 55, 0} ,{147, 107, 64, 0} ,{147, 107, 60, 0} ,{147, 107, 52, 0} ,{133, 166, 229, 5} ,{175, 107, 51, 0} ,{175, 107, 230, 33} ,{175, 107, 216, 37} ,{175, 107, 58, 0} ,{175, 107, 212, 0} ,{175, 107, 89, 7} ,{175, 107, 48, 0} ,{175, 107, 56, 0} ,{175, 107, 217, 37} ,{175, 107, 151, 17} ,{175, 107, 218, 37} ,{175, 107, 219, 37} ,{175, 107, 220, 37} ,{175, 107, 221, 37} ,{175, 107, 182, 7} ,{175, 107, 57, 0} ,{175, 107, 46, 0} ,{175, 107, 222, 37} ,{175, 107, 63, 0} ,{175, 107, 226, 22} ,{175, 107, 228, 2} ,{175, 107, 54, 0} ,{175, 107, 47, 0} ,{175, 107, 55, 0} ,{175, 107, 64, 0} ,{175, 107, 60, 0} ,{175, 107, 52, 0} ,{133, 166, 226, 1} ,{203, 107, 51, 0} ,{203, 107, 230, 33} ,{203, 107, 216, 37} ,{203, 107, 58, 0} ,{203, 107, 212, 0} ,{203, 107, 89, 7} ,{203, 107, 48, 0} ,{203, 107, 56, 0} ,{203, 107, 217, 37} ,{203, 107, 151, 17} ,{203, 107, 218, 37} ,{203, 107, 219, 37} ,{203, 107, 220, 37} ,{203, 107, 221, 37} ,{203, 107, 182, 7} ,{203, 107, 57, 0} ,{203, 107, 46, 0} ,{203, 107, 222, 37} ,{203, 107, 63, 0} ,{203, 107, 226, 22} ,{203, 107, 228, 2} ,{203, 107, 54, 0} ,{203, 107, 47, 0} ,{203, 107, 55, 0} ,{203, 107, 64, 0} ,{203, 107, 60, 0} ,{203, 107, 52, 0} ,{133, 166, 230, 5} ,{231, 107, 51, 0} ,{231, 107, 230, 33} ,{231, 107, 216, 37} ,{231, 107, 58, 0} ,{231, 107, 212, 0} ,{231, 107, 89, 7} ,{231, 107, 48, 0} ,{231, 107, 56, 0} ,{231, 107, 217, 37} ,{231, 107, 151, 17} ,{231, 107, 218, 37} ,{231, 107, 219, 37} ,{231, 107, 220, 37} ,{231, 107, 221, 37} ,{231, 107, 182, 7} ,{231, 107, 57, 0} ,{231, 107, 46, 0} ,{231, 107, 222, 37} ,{231, 107, 63, 0} ,{231, 107, 226, 22} ,{231, 107, 228, 2} ,{231, 107, 54, 0} ,{231, 107, 47, 0} ,{231, 107, 55, 0} ,{231, 107, 64, 0} ,{231, 107, 60, 0} ,{231, 107, 52, 0} ,{133, 166, 170, 1} ,{3, 108, 51, 0} ,{3, 108, 230, 33} ,{3, 108, 216, 37} ,{3, 108, 58, 0} ,{3, 108, 212, 0} ,{3, 108, 89, 7} ,{3, 108, 48, 0} ,{3, 108, 56, 0} ,{3, 108, 217, 37} ,{3, 108, 151, 17} ,{3, 108, 218, 37} ,{3, 108, 219, 37} ,{3, 108, 220, 37} ,{3, 108, 221, 37} ,{3, 108, 182, 7} ,{3, 108, 57, 0} ,{3, 108, 46, 0} ,{3, 108, 222, 37} ,{3, 108, 63, 0} ,{3, 108, 226, 22} ,{3, 108, 228, 2} ,{3, 108, 54, 0} ,{3, 108, 47, 0} ,{3, 108, 55, 0} ,{3, 108, 64, 0} ,{3, 108, 60, 0} ,{3, 108, 52, 0} ,{133, 166, 110, 5} ,{31, 108, 51, 0} ,{31, 108, 230, 33} ,{31, 108, 216, 37} ,{31, 108, 58, 0} ,{31, 108, 212, 0} ,{31, 108, 89, 7} ,{31, 108, 48, 0} ,{31, 108, 56, 0} ,{31, 108, 217, 37} ,{31, 108, 151, 17} ,{31, 108, 218, 37} ,{31, 108, 219, 37} ,{31, 108, 220, 37} ,{31, 108, 221, 37} ,{31, 108, 182, 7} ,{31, 108, 57, 0} ,{31, 108, 46, 0} ,{31, 108, 222, 37} ,{31, 108, 63, 0} ,{31, 108, 226, 22} ,{31, 108, 228, 2} ,{31, 108, 54, 0} ,{31, 108, 47, 0} ,{31, 108, 55, 0} ,{31, 108, 64, 0} ,{31, 108, 60, 0} ,{31, 108, 52, 0} ,{133, 166, 141, 1} ,{59, 108, 51, 0} ,{59, 108, 230, 33} ,{59, 108, 216, 37} ,{59, 108, 58, 0} ,{59, 108, 212, 0} ,{59, 108, 89, 7} ,{59, 108, 48, 0} ,{59, 108, 56, 0} ,{59, 108, 217, 37} ,{59, 108, 151, 17} ,{59, 108, 218, 37} ,{59, 108, 219, 37} ,{59, 108, 220, 37} ,{59, 108, 221, 37} ,{59, 108, 182, 7} ,{59, 108, 57, 0} ,{59, 108, 46, 0} ,{59, 108, 222, 37} ,{59, 108, 63, 0} ,{59, 108, 226, 22} ,{59, 108, 228, 2} ,{59, 108, 54, 0} ,{59, 108, 47, 0} ,{59, 108, 55, 0} ,{59, 108, 64, 0} ,{59, 108, 60, 0} ,{59, 108, 52, 0} ,{133, 166, 53, 0} ,{87, 108, 51, 0} ,{87, 108, 230, 33} ,{87, 108, 216, 37} ,{87, 108, 58, 0} ,{87, 108, 212, 0} ,{87, 108, 89, 7} ,{87, 108, 48, 0} ,{87, 108, 56, 0} ,{87, 108, 217, 37} ,{87, 108, 151, 17} ,{87, 108, 218, 37} ,{87, 108, 219, 37} ,{87, 108, 220, 37} ,{87, 108, 221, 37} ,{87, 108, 182, 7} ,{87, 108, 57, 0} ,{87, 108, 46, 0} ,{87, 108, 222, 37} ,{87, 108, 63, 0} ,{87, 108, 226, 22} ,{87, 108, 228, 2} ,{87, 108, 54, 0} ,{87, 108, 47, 0} ,{87, 108, 55, 0} ,{87, 108, 64, 0} ,{87, 108, 60, 0} ,{87, 108, 52, 0} ,{134, 166, 45, 0} ,{115, 108, 51, 0} ,{115, 108, 230, 33} ,{115, 108, 216, 37} ,{115, 108, 58, 0} ,{115, 108, 212, 0} ,{115, 108, 89, 7} ,{115, 108, 48, 0} ,{115, 108, 56, 0} ,{115, 108, 217, 37} ,{115, 108, 151, 17} ,{115, 108, 218, 37} ,{115, 108, 219, 37} ,{115, 108, 220, 37} ,{115, 108, 221, 37} ,{115, 108, 182, 7} ,{115, 108, 57, 0} ,{115, 108, 46, 0} ,{115, 108, 222, 37} ,{115, 108, 63, 0} ,{115, 108, 226, 22} ,{115, 108, 228, 2} ,{115, 108, 54, 0} ,{115, 108, 47, 0} ,{115, 108, 55, 0} ,{115, 108, 64, 0} ,{115, 108, 60, 0} ,{115, 108, 52, 0} ,{134, 166, 133, 0} ,{143, 108, 51, 0} ,{143, 108, 230, 33} ,{143, 108, 216, 37} ,{143, 108, 58, 0} ,{143, 108, 212, 0} ,{143, 108, 89, 7} ,{143, 108, 48, 0} ,{143, 108, 56, 0} ,{143, 108, 217, 37} ,{143, 108, 151, 17} ,{143, 108, 218, 37} ,{143, 108, 219, 37} ,{143, 108, 220, 37} ,{143, 108, 221, 37} ,{143, 108, 182, 7} ,{143, 108, 57, 0} ,{143, 108, 46, 0} ,{143, 108, 222, 37} ,{143, 108, 63, 0} ,{143, 108, 226, 22} ,{143, 108, 228, 2} ,{143, 108, 54, 0} ,{143, 108, 47, 0} ,{143, 108, 55, 0} ,{143, 108, 64, 0} ,{143, 108, 60, 0} ,{143, 108, 52, 0} ,{134, 166, 171, 1} ,{171, 108, 51, 0} ,{171, 108, 230, 33} ,{171, 108, 216, 37} ,{171, 108, 58, 0} ,{171, 108, 212, 0} ,{171, 108, 89, 7} ,{171, 108, 48, 0} ,{171, 108, 56, 0} ,{171, 108, 217, 37} ,{171, 108, 151, 17} ,{171, 108, 218, 37} ,{171, 108, 219, 37} ,{171, 108, 220, 37} ,{171, 108, 221, 37} ,{171, 108, 182, 7} ,{171, 108, 57, 0} ,{171, 108, 46, 0} ,{171, 108, 222, 37} ,{171, 108, 63, 0} ,{171, 108, 226, 22} ,{171, 108, 228, 2} ,{171, 108, 54, 0} ,{171, 108, 47, 0} ,{171, 108, 55, 0} ,{171, 108, 64, 0} ,{171, 108, 60, 0} ,{171, 108, 52, 0} ,{134, 166, 224, 1} ,{199, 108, 51, 0} ,{199, 108, 230, 33} ,{199, 108, 216, 37} ,{199, 108, 58, 0} ,{199, 108, 212, 0} ,{199, 108, 89, 7} ,{199, 108, 48, 0} ,{199, 108, 56, 0} ,{199, 108, 217, 37} ,{199, 108, 151, 17} ,{199, 108, 218, 37} ,{199, 108, 219, 37} ,{199, 108, 220, 37} ,{199, 108, 221, 37} ,{199, 108, 182, 7} ,{199, 108, 57, 0} ,{199, 108, 46, 0} ,{199, 108, 222, 37} ,{199, 108, 63, 0} ,{199, 108, 226, 22} ,{199, 108, 228, 2} ,{199, 108, 54, 0} ,{199, 108, 47, 0} ,{199, 108, 55, 0} ,{199, 108, 64, 0} ,{199, 108, 60, 0} ,{199, 108, 52, 0} ,{134, 166, 225, 5} ,{227, 108, 51, 0} ,{227, 108, 230, 33} ,{227, 108, 216, 37} ,{227, 108, 58, 0} ,{227, 108, 212, 0} ,{227, 108, 89, 7} ,{227, 108, 48, 0} ,{227, 108, 56, 0} ,{227, 108, 217, 37} ,{227, 108, 151, 17} ,{227, 108, 218, 37} ,{227, 108, 219, 37} ,{227, 108, 220, 37} ,{227, 108, 221, 37} ,{227, 108, 182, 7} ,{227, 108, 57, 0} ,{227, 108, 46, 0} ,{227, 108, 222, 37} ,{227, 108, 63, 0} ,{227, 108, 226, 22} ,{227, 108, 228, 2} ,{227, 108, 54, 0} ,{227, 108, 47, 0} ,{227, 108, 55, 0} ,{227, 108, 64, 0} ,{227, 108, 60, 0} ,{227, 108, 52, 0} ,{134, 166, 49, 0} ,{255, 108, 51, 0} ,{255, 108, 230, 33} ,{255, 108, 216, 37} ,{255, 108, 58, 0} ,{255, 108, 212, 0} ,{255, 108, 89, 7} ,{255, 108, 48, 0} ,{255, 108, 56, 0} ,{255, 108, 217, 37} ,{255, 108, 151, 17} ,{255, 108, 218, 37} ,{255, 108, 219, 37} ,{255, 108, 220, 37} ,{255, 108, 221, 37} ,{255, 108, 182, 7} ,{255, 108, 57, 0} ,{255, 108, 46, 0} ,{255, 108, 222, 37} ,{255, 108, 63, 0} ,{255, 108, 226, 22} ,{255, 108, 228, 2} ,{255, 108, 54, 0} ,{255, 108, 47, 0} ,{255, 108, 55, 0} ,{255, 108, 64, 0} ,{255, 108, 60, 0} ,{255, 108, 52, 0} ,{134, 166, 226, 5} ,{27, 109, 51, 0} ,{27, 109, 230, 33} ,{27, 109, 216, 37} ,{27, 109, 58, 0} ,{27, 109, 212, 0} ,{27, 109, 89, 7} ,{27, 109, 48, 0} ,{27, 109, 56, 0} ,{27, 109, 217, 37} ,{27, 109, 151, 17} ,{27, 109, 218, 37} ,{27, 109, 219, 37} ,{27, 109, 220, 37} ,{27, 109, 221, 37} ,{27, 109, 182, 7} ,{27, 109, 57, 0} ,{27, 109, 46, 0} ,{27, 109, 222, 37} ,{27, 109, 63, 0} ,{27, 109, 226, 22} ,{27, 109, 228, 2} ,{27, 109, 54, 0} ,{27, 109, 47, 0} ,{27, 109, 55, 0} ,{27, 109, 64, 0} ,{27, 109, 60, 0} ,{27, 109, 52, 0} ,{134, 166, 227, 5} ,{55, 109, 51, 0} ,{55, 109, 230, 33} ,{55, 109, 216, 37} ,{55, 109, 58, 0} ,{55, 109, 212, 0} ,{55, 109, 89, 7} ,{55, 109, 48, 0} ,{55, 109, 56, 0} ,{55, 109, 217, 37} ,{55, 109, 151, 17} ,{55, 109, 218, 37} ,{55, 109, 219, 37} ,{55, 109, 220, 37} ,{55, 109, 221, 37} ,{55, 109, 182, 7} ,{55, 109, 57, 0} ,{55, 109, 46, 0} ,{55, 109, 222, 37} ,{55, 109, 63, 0} ,{55, 109, 226, 22} ,{55, 109, 228, 2} ,{55, 109, 54, 0} ,{55, 109, 47, 0} ,{55, 109, 55, 0} ,{55, 109, 64, 0} ,{55, 109, 60, 0} ,{55, 109, 52, 0} ,{134, 166, 59, 0} ,{83, 109, 51, 0} ,{83, 109, 230, 33} ,{83, 109, 216, 37} ,{83, 109, 58, 0} ,{83, 109, 212, 0} ,{83, 109, 89, 7} ,{83, 109, 48, 0} ,{83, 109, 56, 0} ,{83, 109, 217, 37} ,{83, 109, 151, 17} ,{83, 109, 218, 37} ,{83, 109, 219, 37} ,{83, 109, 220, 37} ,{83, 109, 221, 37} ,{83, 109, 182, 7} ,{83, 109, 57, 0} ,{83, 109, 46, 0} ,{83, 109, 222, 37} ,{83, 109, 63, 0} ,{83, 109, 226, 22} ,{83, 109, 228, 2} ,{83, 109, 54, 0} ,{83, 109, 47, 0} ,{83, 109, 55, 0} ,{83, 109, 64, 0} ,{83, 109, 60, 0} ,{83, 109, 52, 0} ,{134, 166, 140, 3} ,{111, 109, 51, 0} ,{111, 109, 230, 33} ,{111, 109, 216, 37} ,{111, 109, 58, 0} ,{111, 109, 212, 0} ,{111, 109, 89, 7} ,{111, 109, 48, 0} ,{111, 109, 56, 0} ,{111, 109, 217, 37} ,{111, 109, 151, 17} ,{111, 109, 218, 37} ,{111, 109, 219, 37} ,{111, 109, 220, 37} ,{111, 109, 221, 37} ,{111, 109, 182, 7} ,{111, 109, 57, 0} ,{111, 109, 46, 0} ,{111, 109, 222, 37} ,{111, 109, 63, 0} ,{111, 109, 226, 22} ,{111, 109, 228, 2} ,{111, 109, 54, 0} ,{111, 109, 47, 0} ,{111, 109, 55, 0} ,{111, 109, 64, 0} ,{111, 109, 60, 0} ,{111, 109, 52, 0} ,{134, 166, 228, 5} ,{139, 109, 51, 0} ,{139, 109, 230, 33} ,{139, 109, 216, 37} ,{139, 109, 58, 0} ,{139, 109, 212, 0} ,{139, 109, 89, 7} ,{139, 109, 48, 0} ,{139, 109, 56, 0} ,{139, 109, 217, 37} ,{139, 109, 151, 17} ,{139, 109, 218, 37} ,{139, 109, 219, 37} ,{139, 109, 220, 37} ,{139, 109, 221, 37} ,{139, 109, 182, 7} ,{139, 109, 57, 0} ,{139, 109, 46, 0} ,{139, 109, 222, 37} ,{139, 109, 63, 0} ,{139, 109, 226, 22} ,{139, 109, 228, 2} ,{139, 109, 54, 0} ,{139, 109, 47, 0} ,{139, 109, 55, 0} ,{139, 109, 64, 0} ,{139, 109, 60, 0} ,{139, 109, 52, 0} ,{134, 166, 164, 0} ,{167, 109, 51, 0} ,{167, 109, 230, 33} ,{167, 109, 216, 37} ,{167, 109, 58, 0} ,{167, 109, 212, 0} ,{167, 109, 89, 7} ,{167, 109, 48, 0} ,{167, 109, 56, 0} ,{167, 109, 217, 37} ,{167, 109, 151, 17} ,{167, 109, 218, 37} ,{167, 109, 219, 37} ,{167, 109, 220, 37} ,{167, 109, 221, 37} ,{167, 109, 182, 7} ,{167, 109, 57, 0} ,{167, 109, 46, 0} ,{167, 109, 222, 37} ,{167, 109, 63, 0} ,{167, 109, 226, 22} ,{167, 109, 228, 2} ,{167, 109, 54, 0} ,{167, 109, 47, 0} ,{167, 109, 55, 0} ,{167, 109, 64, 0} ,{167, 109, 60, 0} ,{167, 109, 52, 0} ,{134, 166, 204, 4} ,{195, 109, 51, 0} ,{195, 109, 230, 33} ,{195, 109, 216, 37} ,{195, 109, 58, 0} ,{195, 109, 212, 0} ,{195, 109, 89, 7} ,{195, 109, 48, 0} ,{195, 109, 56, 0} ,{195, 109, 217, 37} ,{195, 109, 151, 17} ,{195, 109, 218, 37} ,{195, 109, 219, 37} ,{195, 109, 220, 37} ,{195, 109, 221, 37} ,{195, 109, 182, 7} ,{195, 109, 57, 0} ,{195, 109, 46, 0} ,{195, 109, 222, 37} ,{195, 109, 63, 0} ,{195, 109, 226, 22} ,{195, 109, 228, 2} ,{195, 109, 54, 0} ,{195, 109, 47, 0} ,{195, 109, 55, 0} ,{195, 109, 64, 0} ,{195, 109, 60, 0} ,{195, 109, 52, 0} ,{134, 166, 65, 0} ,{223, 109, 51, 0} ,{223, 109, 230, 33} ,{223, 109, 216, 37} ,{223, 109, 58, 0} ,{223, 109, 212, 0} ,{223, 109, 89, 7} ,{223, 109, 48, 0} ,{223, 109, 56, 0} ,{223, 109, 217, 37} ,{223, 109, 151, 17} ,{223, 109, 218, 37} ,{223, 109, 219, 37} ,{223, 109, 220, 37} ,{223, 109, 221, 37} ,{223, 109, 182, 7} ,{223, 109, 57, 0} ,{223, 109, 46, 0} ,{223, 109, 222, 37} ,{223, 109, 63, 0} ,{223, 109, 226, 22} ,{223, 109, 228, 2} ,{223, 109, 54, 0} ,{223, 109, 47, 0} ,{223, 109, 55, 0} ,{223, 109, 64, 0} ,{223, 109, 60, 0} ,{223, 109, 52, 0} ,{134, 166, 229, 5} ,{251, 109, 51, 0} ,{251, 109, 230, 33} ,{251, 109, 216, 37} ,{251, 109, 58, 0} ,{251, 109, 212, 0} ,{251, 109, 89, 7} ,{251, 109, 48, 0} ,{251, 109, 56, 0} ,{251, 109, 217, 37} ,{251, 109, 151, 17} ,{251, 109, 218, 37} ,{251, 109, 219, 37} ,{251, 109, 220, 37} ,{251, 109, 221, 37} ,{251, 109, 182, 7} ,{251, 109, 57, 0} ,{251, 109, 46, 0} ,{251, 109, 222, 37} ,{251, 109, 63, 0} ,{251, 109, 226, 22} ,{251, 109, 228, 2} ,{251, 109, 54, 0} ,{251, 109, 47, 0} ,{251, 109, 55, 0} ,{251, 109, 64, 0} ,{251, 109, 60, 0} ,{251, 109, 52, 0} ,{134, 166, 226, 1} ,{23, 110, 51, 0} ,{23, 110, 230, 33} ,{23, 110, 216, 37} ,{23, 110, 58, 0} ,{23, 110, 212, 0} ,{23, 110, 89, 7} ,{23, 110, 48, 0} ,{23, 110, 56, 0} ,{23, 110, 217, 37} ,{23, 110, 151, 17} ,{23, 110, 218, 37} ,{23, 110, 219, 37} ,{23, 110, 220, 37} ,{23, 110, 221, 37} ,{23, 110, 182, 7} ,{23, 110, 57, 0} ,{23, 110, 46, 0} ,{23, 110, 222, 37} ,{23, 110, 63, 0} ,{23, 110, 226, 22} ,{23, 110, 228, 2} ,{23, 110, 54, 0} ,{23, 110, 47, 0} ,{23, 110, 55, 0} ,{23, 110, 64, 0} ,{23, 110, 60, 0} ,{23, 110, 52, 0} ,{134, 166, 230, 5} ,{51, 110, 51, 0} ,{51, 110, 230, 33} ,{51, 110, 216, 37} ,{51, 110, 58, 0} ,{51, 110, 212, 0} ,{51, 110, 89, 7} ,{51, 110, 48, 0} ,{51, 110, 56, 0} ,{51, 110, 217, 37} ,{51, 110, 151, 17} ,{51, 110, 218, 37} ,{51, 110, 219, 37} ,{51, 110, 220, 37} ,{51, 110, 221, 37} ,{51, 110, 182, 7} ,{51, 110, 57, 0} ,{51, 110, 46, 0} ,{51, 110, 222, 37} ,{51, 110, 63, 0} ,{51, 110, 226, 22} ,{51, 110, 228, 2} ,{51, 110, 54, 0} ,{51, 110, 47, 0} ,{51, 110, 55, 0} ,{51, 110, 64, 0} ,{51, 110, 60, 0} ,{51, 110, 52, 0} ,{134, 166, 170, 1} ,{79, 110, 51, 0} ,{79, 110, 230, 33} ,{79, 110, 216, 37} ,{79, 110, 58, 0} ,{79, 110, 212, 0} ,{79, 110, 89, 7} ,{79, 110, 48, 0} ,{79, 110, 56, 0} ,{79, 110, 217, 37} ,{79, 110, 151, 17} ,{79, 110, 218, 37} ,{79, 110, 219, 37} ,{79, 110, 220, 37} ,{79, 110, 221, 37} ,{79, 110, 182, 7} ,{79, 110, 57, 0} ,{79, 110, 46, 0} ,{79, 110, 222, 37} ,{79, 110, 63, 0} ,{79, 110, 226, 22} ,{79, 110, 228, 2} ,{79, 110, 54, 0} ,{79, 110, 47, 0} ,{79, 110, 55, 0} ,{79, 110, 64, 0} ,{79, 110, 60, 0} ,{79, 110, 52, 0} ,{134, 166, 110, 5} ,{107, 110, 51, 0} ,{107, 110, 230, 33} ,{107, 110, 216, 37} ,{107, 110, 58, 0} ,{107, 110, 212, 0} ,{107, 110, 89, 7} ,{107, 110, 48, 0} ,{107, 110, 56, 0} ,{107, 110, 217, 37} ,{107, 110, 151, 17} ,{107, 110, 218, 37} ,{107, 110, 219, 37} ,{107, 110, 220, 37} ,{107, 110, 221, 37} ,{107, 110, 182, 7} ,{107, 110, 57, 0} ,{107, 110, 46, 0} ,{107, 110, 222, 37} ,{107, 110, 63, 0} ,{107, 110, 226, 22} ,{107, 110, 228, 2} ,{107, 110, 54, 0} ,{107, 110, 47, 0} ,{107, 110, 55, 0} ,{107, 110, 64, 0} ,{107, 110, 60, 0} ,{107, 110, 52, 0} ,{134, 166, 141, 1} ,{135, 110, 51, 0} ,{135, 110, 230, 33} ,{135, 110, 216, 37} ,{135, 110, 58, 0} ,{135, 110, 212, 0} ,{135, 110, 89, 7} ,{135, 110, 48, 0} ,{135, 110, 56, 0} ,{135, 110, 217, 37} ,{135, 110, 151, 17} ,{135, 110, 218, 37} ,{135, 110, 219, 37} ,{135, 110, 220, 37} ,{135, 110, 221, 37} ,{135, 110, 182, 7} ,{135, 110, 57, 0} ,{135, 110, 46, 0} ,{135, 110, 222, 37} ,{135, 110, 63, 0} ,{135, 110, 226, 22} ,{135, 110, 228, 2} ,{135, 110, 54, 0} ,{135, 110, 47, 0} ,{135, 110, 55, 0} ,{135, 110, 64, 0} ,{135, 110, 60, 0} ,{135, 110, 52, 0} ,{134, 166, 53, 0} ,{163, 110, 51, 0} ,{163, 110, 230, 33} ,{163, 110, 216, 37} ,{163, 110, 58, 0} ,{163, 110, 212, 0} ,{163, 110, 89, 7} ,{163, 110, 48, 0} ,{163, 110, 56, 0} ,{163, 110, 217, 37} ,{163, 110, 151, 17} ,{163, 110, 218, 37} ,{163, 110, 219, 37} ,{163, 110, 220, 37} ,{163, 110, 221, 37} ,{163, 110, 182, 7} ,{163, 110, 57, 0} ,{163, 110, 46, 0} ,{163, 110, 222, 37} ,{163, 110, 63, 0} ,{163, 110, 226, 22} ,{163, 110, 228, 2} ,{163, 110, 54, 0} ,{163, 110, 47, 0} ,{163, 110, 55, 0} ,{163, 110, 64, 0} ,{163, 110, 60, 0} ,{163, 110, 52, 0} ,{135, 166, 45, 0} ,{191, 110, 51, 0} ,{191, 110, 230, 33} ,{191, 110, 216, 37} ,{191, 110, 58, 0} ,{191, 110, 212, 0} ,{191, 110, 89, 7} ,{191, 110, 48, 0} ,{191, 110, 56, 0} ,{191, 110, 217, 37} ,{191, 110, 151, 17} ,{191, 110, 218, 37} ,{191, 110, 219, 37} ,{191, 110, 220, 37} ,{191, 110, 221, 37} ,{191, 110, 182, 7} ,{191, 110, 57, 0} ,{191, 110, 46, 0} ,{191, 110, 222, 37} ,{191, 110, 63, 0} ,{191, 110, 226, 22} ,{191, 110, 228, 2} ,{191, 110, 54, 0} ,{191, 110, 47, 0} ,{191, 110, 55, 0} ,{191, 110, 64, 0} ,{191, 110, 60, 0} ,{191, 110, 52, 0} ,{135, 166, 133, 0} ,{219, 110, 51, 0} ,{219, 110, 230, 33} ,{219, 110, 216, 37} ,{219, 110, 58, 0} ,{219, 110, 212, 0} ,{219, 110, 89, 7} ,{219, 110, 48, 0} ,{219, 110, 56, 0} ,{219, 110, 217, 37} ,{219, 110, 151, 17} ,{219, 110, 218, 37} ,{219, 110, 219, 37} ,{219, 110, 220, 37} ,{219, 110, 221, 37} ,{219, 110, 182, 7} ,{219, 110, 57, 0} ,{219, 110, 46, 0} ,{219, 110, 222, 37} ,{219, 110, 63, 0} ,{219, 110, 226, 22} ,{219, 110, 228, 2} ,{219, 110, 54, 0} ,{219, 110, 47, 0} ,{219, 110, 55, 0} ,{219, 110, 64, 0} ,{219, 110, 60, 0} ,{219, 110, 52, 0} ,{135, 166, 171, 1} ,{247, 110, 51, 0} ,{247, 110, 230, 33} ,{247, 110, 216, 37} ,{247, 110, 58, 0} ,{247, 110, 212, 0} ,{247, 110, 89, 7} ,{247, 110, 48, 0} ,{247, 110, 56, 0} ,{247, 110, 217, 37} ,{247, 110, 151, 17} ,{247, 110, 218, 37} ,{247, 110, 219, 37} ,{247, 110, 220, 37} ,{247, 110, 221, 37} ,{247, 110, 182, 7} ,{247, 110, 57, 0} ,{247, 110, 46, 0} ,{247, 110, 222, 37} ,{247, 110, 63, 0} ,{247, 110, 226, 22} ,{247, 110, 228, 2} ,{247, 110, 54, 0} ,{247, 110, 47, 0} ,{247, 110, 55, 0} ,{247, 110, 64, 0} ,{247, 110, 60, 0} ,{247, 110, 52, 0} ,{135, 166, 224, 1} ,{19, 111, 51, 0} ,{19, 111, 230, 33} ,{19, 111, 216, 37} ,{19, 111, 58, 0} ,{19, 111, 212, 0} ,{19, 111, 89, 7} ,{19, 111, 48, 0} ,{19, 111, 56, 0} ,{19, 111, 217, 37} ,{19, 111, 151, 17} ,{19, 111, 218, 37} ,{19, 111, 219, 37} ,{19, 111, 220, 37} ,{19, 111, 221, 37} ,{19, 111, 182, 7} ,{19, 111, 57, 0} ,{19, 111, 46, 0} ,{19, 111, 222, 37} ,{19, 111, 63, 0} ,{19, 111, 226, 22} ,{19, 111, 228, 2} ,{19, 111, 54, 0} ,{19, 111, 47, 0} ,{19, 111, 55, 0} ,{19, 111, 64, 0} ,{19, 111, 60, 0} ,{19, 111, 52, 0} ,{135, 166, 225, 5} ,{47, 111, 51, 0} ,{47, 111, 230, 33} ,{47, 111, 216, 37} ,{47, 111, 58, 0} ,{47, 111, 212, 0} ,{47, 111, 89, 7} ,{47, 111, 48, 0} ,{47, 111, 56, 0} ,{47, 111, 217, 37} ,{47, 111, 151, 17} ,{47, 111, 218, 37} ,{47, 111, 219, 37} ,{47, 111, 220, 37} ,{47, 111, 221, 37} ,{47, 111, 182, 7} ,{47, 111, 57, 0} ,{47, 111, 46, 0} ,{47, 111, 222, 37} ,{47, 111, 63, 0} ,{47, 111, 226, 22} ,{47, 111, 228, 2} ,{47, 111, 54, 0} ,{47, 111, 47, 0} ,{47, 111, 55, 0} ,{47, 111, 64, 0} ,{47, 111, 60, 0} ,{47, 111, 52, 0} ,{135, 166, 49, 0} ,{75, 111, 51, 0} ,{75, 111, 230, 33} ,{75, 111, 216, 37} ,{75, 111, 58, 0} ,{75, 111, 212, 0} ,{75, 111, 89, 7} ,{75, 111, 48, 0} ,{75, 111, 56, 0} ,{75, 111, 217, 37} ,{75, 111, 151, 17} ,{75, 111, 218, 37} ,{75, 111, 219, 37} ,{75, 111, 220, 37} ,{75, 111, 221, 37} ,{75, 111, 182, 7} ,{75, 111, 57, 0} ,{75, 111, 46, 0} ,{75, 111, 222, 37} ,{75, 111, 63, 0} ,{75, 111, 226, 22} ,{75, 111, 228, 2} ,{75, 111, 54, 0} ,{75, 111, 47, 0} ,{75, 111, 55, 0} ,{75, 111, 64, 0} ,{75, 111, 60, 0} ,{75, 111, 52, 0} ,{135, 166, 226, 5} ,{103, 111, 51, 0} ,{103, 111, 230, 33} ,{103, 111, 216, 37} ,{103, 111, 58, 0} ,{103, 111, 212, 0} ,{103, 111, 89, 7} ,{103, 111, 48, 0} ,{103, 111, 56, 0} ,{103, 111, 217, 37} ,{103, 111, 151, 17} ,{103, 111, 218, 37} ,{103, 111, 219, 37} ,{103, 111, 220, 37} ,{103, 111, 221, 37} ,{103, 111, 182, 7} ,{103, 111, 57, 0} ,{103, 111, 46, 0} ,{103, 111, 222, 37} ,{103, 111, 63, 0} ,{103, 111, 226, 22} ,{103, 111, 228, 2} ,{103, 111, 54, 0} ,{103, 111, 47, 0} ,{103, 111, 55, 0} ,{103, 111, 64, 0} ,{103, 111, 60, 0} ,{103, 111, 52, 0} ,{135, 166, 227, 5} ,{131, 111, 51, 0} ,{131, 111, 230, 33} ,{131, 111, 216, 37} ,{131, 111, 58, 0} ,{131, 111, 212, 0} ,{131, 111, 89, 7} ,{131, 111, 48, 0} ,{131, 111, 56, 0} ,{131, 111, 217, 37} ,{131, 111, 151, 17} ,{131, 111, 218, 37} ,{131, 111, 219, 37} ,{131, 111, 220, 37} ,{131, 111, 221, 37} ,{131, 111, 182, 7} ,{131, 111, 57, 0} ,{131, 111, 46, 0} ,{131, 111, 222, 37} ,{131, 111, 63, 0} ,{131, 111, 226, 22} ,{131, 111, 228, 2} ,{131, 111, 54, 0} ,{131, 111, 47, 0} ,{131, 111, 55, 0} ,{131, 111, 64, 0} ,{131, 111, 60, 0} ,{131, 111, 52, 0} ,{135, 166, 59, 0} ,{159, 111, 51, 0} ,{159, 111, 230, 33} ,{159, 111, 216, 37} ,{159, 111, 58, 0} ,{159, 111, 212, 0} ,{159, 111, 89, 7} ,{159, 111, 48, 0} ,{159, 111, 56, 0} ,{159, 111, 217, 37} ,{159, 111, 151, 17} ,{159, 111, 218, 37} ,{159, 111, 219, 37} ,{159, 111, 220, 37} ,{159, 111, 221, 37} ,{159, 111, 182, 7} ,{159, 111, 57, 0} ,{159, 111, 46, 0} ,{159, 111, 222, 37} ,{159, 111, 63, 0} ,{159, 111, 226, 22} ,{159, 111, 228, 2} ,{159, 111, 54, 0} ,{159, 111, 47, 0} ,{159, 111, 55, 0} ,{159, 111, 64, 0} ,{159, 111, 60, 0} ,{159, 111, 52, 0} ,{135, 166, 140, 3} ,{187, 111, 51, 0} ,{187, 111, 230, 33} ,{187, 111, 216, 37} ,{187, 111, 58, 0} ,{187, 111, 212, 0} ,{187, 111, 89, 7} ,{187, 111, 48, 0} ,{187, 111, 56, 0} ,{187, 111, 217, 37} ,{187, 111, 151, 17} ,{187, 111, 218, 37} ,{187, 111, 219, 37} ,{187, 111, 220, 37} ,{187, 111, 221, 37} ,{187, 111, 182, 7} ,{187, 111, 57, 0} ,{187, 111, 46, 0} ,{187, 111, 222, 37} ,{187, 111, 63, 0} ,{187, 111, 226, 22} ,{187, 111, 228, 2} ,{187, 111, 54, 0} ,{187, 111, 47, 0} ,{187, 111, 55, 0} ,{187, 111, 64, 0} ,{187, 111, 60, 0} ,{187, 111, 52, 0} ,{135, 166, 228, 5} ,{215, 111, 51, 0} ,{215, 111, 230, 33} ,{215, 111, 216, 37} ,{215, 111, 58, 0} ,{215, 111, 212, 0} ,{215, 111, 89, 7} ,{215, 111, 48, 0} ,{215, 111, 56, 0} ,{215, 111, 217, 37} ,{215, 111, 151, 17} ,{215, 111, 218, 37} ,{215, 111, 219, 37} ,{215, 111, 220, 37} ,{215, 111, 221, 37} ,{215, 111, 182, 7} ,{215, 111, 57, 0} ,{215, 111, 46, 0} ,{215, 111, 222, 37} ,{215, 111, 63, 0} ,{215, 111, 226, 22} ,{215, 111, 228, 2} ,{215, 111, 54, 0} ,{215, 111, 47, 0} ,{215, 111, 55, 0} ,{215, 111, 64, 0} ,{215, 111, 60, 0} ,{215, 111, 52, 0} ,{135, 166, 164, 0} ,{243, 111, 51, 0} ,{243, 111, 230, 33} ,{243, 111, 216, 37} ,{243, 111, 58, 0} ,{243, 111, 212, 0} ,{243, 111, 89, 7} ,{243, 111, 48, 0} ,{243, 111, 56, 0} ,{243, 111, 217, 37} ,{243, 111, 151, 17} ,{243, 111, 218, 37} ,{243, 111, 219, 37} ,{243, 111, 220, 37} ,{243, 111, 221, 37} ,{243, 111, 182, 7} ,{243, 111, 57, 0} ,{243, 111, 46, 0} ,{243, 111, 222, 37} ,{243, 111, 63, 0} ,{243, 111, 226, 22} ,{243, 111, 228, 2} ,{243, 111, 54, 0} ,{243, 111, 47, 0} ,{243, 111, 55, 0} ,{243, 111, 64, 0} ,{243, 111, 60, 0} ,{243, 111, 52, 0} ,{135, 166, 204, 4} ,{15, 112, 51, 0} ,{15, 112, 230, 33} ,{15, 112, 216, 37} ,{15, 112, 58, 0} ,{15, 112, 212, 0} ,{15, 112, 89, 7} ,{15, 112, 48, 0} ,{15, 112, 56, 0} ,{15, 112, 217, 37} ,{15, 112, 151, 17} ,{15, 112, 218, 37} ,{15, 112, 219, 37} ,{15, 112, 220, 37} ,{15, 112, 221, 37} ,{15, 112, 182, 7} ,{15, 112, 57, 0} ,{15, 112, 46, 0} ,{15, 112, 222, 37} ,{15, 112, 63, 0} ,{15, 112, 226, 22} ,{15, 112, 228, 2} ,{15, 112, 54, 0} ,{15, 112, 47, 0} ,{15, 112, 55, 0} ,{15, 112, 64, 0} ,{15, 112, 60, 0} ,{15, 112, 52, 0} ,{135, 166, 65, 0} ,{43, 112, 51, 0} ,{43, 112, 230, 33} ,{43, 112, 216, 37} ,{43, 112, 58, 0} ,{43, 112, 212, 0} ,{43, 112, 89, 7} ,{43, 112, 48, 0} ,{43, 112, 56, 0} ,{43, 112, 217, 37} ,{43, 112, 151, 17} ,{43, 112, 218, 37} ,{43, 112, 219, 37} ,{43, 112, 220, 37} ,{43, 112, 221, 37} ,{43, 112, 182, 7} ,{43, 112, 57, 0} ,{43, 112, 46, 0} ,{43, 112, 222, 37} ,{43, 112, 63, 0} ,{43, 112, 226, 22} ,{43, 112, 228, 2} ,{43, 112, 54, 0} ,{43, 112, 47, 0} ,{43, 112, 55, 0} ,{43, 112, 64, 0} ,{43, 112, 60, 0} ,{43, 112, 52, 0} ,{135, 166, 229, 5} ,{71, 112, 51, 0} ,{71, 112, 230, 33} ,{71, 112, 216, 37} ,{71, 112, 58, 0} ,{71, 112, 212, 0} ,{71, 112, 89, 7} ,{71, 112, 48, 0} ,{71, 112, 56, 0} ,{71, 112, 217, 37} ,{71, 112, 151, 17} ,{71, 112, 218, 37} ,{71, 112, 219, 37} ,{71, 112, 220, 37} ,{71, 112, 221, 37} ,{71, 112, 182, 7} ,{71, 112, 57, 0} ,{71, 112, 46, 0} ,{71, 112, 222, 37} ,{71, 112, 63, 0} ,{71, 112, 226, 22} ,{71, 112, 228, 2} ,{71, 112, 54, 0} ,{71, 112, 47, 0} ,{71, 112, 55, 0} ,{71, 112, 64, 0} ,{71, 112, 60, 0} ,{71, 112, 52, 0} ,{135, 166, 226, 1} ,{99, 112, 51, 0} ,{99, 112, 230, 33} ,{99, 112, 216, 37} ,{99, 112, 58, 0} ,{99, 112, 212, 0} ,{99, 112, 89, 7} ,{99, 112, 48, 0} ,{99, 112, 56, 0} ,{99, 112, 217, 37} ,{99, 112, 151, 17} ,{99, 112, 218, 37} ,{99, 112, 219, 37} ,{99, 112, 220, 37} ,{99, 112, 221, 37} ,{99, 112, 182, 7} ,{99, 112, 57, 0} ,{99, 112, 46, 0} ,{99, 112, 222, 37} ,{99, 112, 63, 0} ,{99, 112, 226, 22} ,{99, 112, 228, 2} ,{99, 112, 54, 0} ,{99, 112, 47, 0} ,{99, 112, 55, 0} ,{99, 112, 64, 0} ,{99, 112, 60, 0} ,{99, 112, 52, 0} ,{135, 166, 230, 5} ,{127, 112, 51, 0} ,{127, 112, 230, 33} ,{127, 112, 216, 37} ,{127, 112, 58, 0} ,{127, 112, 212, 0} ,{127, 112, 89, 7} ,{127, 112, 48, 0} ,{127, 112, 56, 0} ,{127, 112, 217, 37} ,{127, 112, 151, 17} ,{127, 112, 218, 37} ,{127, 112, 219, 37} ,{127, 112, 220, 37} ,{127, 112, 221, 37} ,{127, 112, 182, 7} ,{127, 112, 57, 0} ,{127, 112, 46, 0} ,{127, 112, 222, 37} ,{127, 112, 63, 0} ,{127, 112, 226, 22} ,{127, 112, 228, 2} ,{127, 112, 54, 0} ,{127, 112, 47, 0} ,{127, 112, 55, 0} ,{127, 112, 64, 0} ,{127, 112, 60, 0} ,{127, 112, 52, 0} ,{135, 166, 170, 1} ,{155, 112, 51, 0} ,{155, 112, 230, 33} ,{155, 112, 216, 37} ,{155, 112, 58, 0} ,{155, 112, 212, 0} ,{155, 112, 89, 7} ,{155, 112, 48, 0} ,{155, 112, 56, 0} ,{155, 112, 217, 37} ,{155, 112, 151, 17} ,{155, 112, 218, 37} ,{155, 112, 219, 37} ,{155, 112, 220, 37} ,{155, 112, 221, 37} ,{155, 112, 182, 7} ,{155, 112, 57, 0} ,{155, 112, 46, 0} ,{155, 112, 222, 37} ,{155, 112, 63, 0} ,{155, 112, 226, 22} ,{155, 112, 228, 2} ,{155, 112, 54, 0} ,{155, 112, 47, 0} ,{155, 112, 55, 0} ,{155, 112, 64, 0} ,{155, 112, 60, 0} ,{155, 112, 52, 0} ,{135, 166, 110, 5} ,{183, 112, 51, 0} ,{183, 112, 230, 33} ,{183, 112, 216, 37} ,{183, 112, 58, 0} ,{183, 112, 212, 0} ,{183, 112, 89, 7} ,{183, 112, 48, 0} ,{183, 112, 56, 0} ,{183, 112, 217, 37} ,{183, 112, 151, 17} ,{183, 112, 218, 37} ,{183, 112, 219, 37} ,{183, 112, 220, 37} ,{183, 112, 221, 37} ,{183, 112, 182, 7} ,{183, 112, 57, 0} ,{183, 112, 46, 0} ,{183, 112, 222, 37} ,{183, 112, 63, 0} ,{183, 112, 226, 22} ,{183, 112, 228, 2} ,{183, 112, 54, 0} ,{183, 112, 47, 0} ,{183, 112, 55, 0} ,{183, 112, 64, 0} ,{183, 112, 60, 0} ,{183, 112, 52, 0} ,{135, 166, 141, 1} ,{211, 112, 51, 0} ,{211, 112, 230, 33} ,{211, 112, 216, 37} ,{211, 112, 58, 0} ,{211, 112, 212, 0} ,{211, 112, 89, 7} ,{211, 112, 48, 0} ,{211, 112, 56, 0} ,{211, 112, 217, 37} ,{211, 112, 151, 17} ,{211, 112, 218, 37} ,{211, 112, 219, 37} ,{211, 112, 220, 37} ,{211, 112, 221, 37} ,{211, 112, 182, 7} ,{211, 112, 57, 0} ,{211, 112, 46, 0} ,{211, 112, 222, 37} ,{211, 112, 63, 0} ,{211, 112, 226, 22} ,{211, 112, 228, 2} ,{211, 112, 54, 0} ,{211, 112, 47, 0} ,{211, 112, 55, 0} ,{211, 112, 64, 0} ,{211, 112, 60, 0} ,{211, 112, 52, 0} ,{135, 166, 53, 0} ,{239, 112, 51, 0} ,{239, 112, 230, 33} ,{239, 112, 216, 37} ,{239, 112, 58, 0} ,{239, 112, 212, 0} ,{239, 112, 89, 7} ,{239, 112, 48, 0} ,{239, 112, 56, 0} ,{239, 112, 217, 37} ,{239, 112, 151, 17} ,{239, 112, 218, 37} ,{239, 112, 219, 37} ,{239, 112, 220, 37} ,{239, 112, 221, 37} ,{239, 112, 182, 7} ,{239, 112, 57, 0} ,{239, 112, 46, 0} ,{239, 112, 222, 37} ,{239, 112, 63, 0} ,{239, 112, 226, 22} ,{239, 112, 228, 2} ,{239, 112, 54, 0} ,{239, 112, 47, 0} ,{239, 112, 55, 0} ,{239, 112, 64, 0} ,{239, 112, 60, 0} ,{239, 112, 52, 0} ,{136, 166, 45, 0} ,{11, 113, 51, 0} ,{11, 113, 230, 33} ,{11, 113, 216, 37} ,{11, 113, 58, 0} ,{11, 113, 212, 0} ,{11, 113, 89, 7} ,{11, 113, 48, 0} ,{11, 113, 56, 0} ,{11, 113, 217, 37} ,{11, 113, 151, 17} ,{11, 113, 218, 37} ,{11, 113, 219, 37} ,{11, 113, 220, 37} ,{11, 113, 221, 37} ,{11, 113, 182, 7} ,{11, 113, 57, 0} ,{11, 113, 46, 0} ,{11, 113, 222, 37} ,{11, 113, 63, 0} ,{11, 113, 226, 22} ,{11, 113, 228, 2} ,{11, 113, 54, 0} ,{11, 113, 47, 0} ,{11, 113, 55, 0} ,{11, 113, 64, 0} ,{11, 113, 60, 0} ,{11, 113, 52, 0} ,{136, 166, 133, 0} ,{39, 113, 51, 0} ,{39, 113, 230, 33} ,{39, 113, 216, 37} ,{39, 113, 58, 0} ,{39, 113, 212, 0} ,{39, 113, 89, 7} ,{39, 113, 48, 0} ,{39, 113, 56, 0} ,{39, 113, 217, 37} ,{39, 113, 151, 17} ,{39, 113, 218, 37} ,{39, 113, 219, 37} ,{39, 113, 220, 37} ,{39, 113, 221, 37} ,{39, 113, 182, 7} ,{39, 113, 57, 0} ,{39, 113, 46, 0} ,{39, 113, 222, 37} ,{39, 113, 63, 0} ,{39, 113, 226, 22} ,{39, 113, 228, 2} ,{39, 113, 54, 0} ,{39, 113, 47, 0} ,{39, 113, 55, 0} ,{39, 113, 64, 0} ,{39, 113, 60, 0} ,{39, 113, 52, 0} ,{136, 166, 171, 1} ,{67, 113, 51, 0} ,{67, 113, 230, 33} ,{67, 113, 216, 37} ,{67, 113, 58, 0} ,{67, 113, 212, 0} ,{67, 113, 89, 7} ,{67, 113, 48, 0} ,{67, 113, 56, 0} ,{67, 113, 217, 37} ,{67, 113, 151, 17} ,{67, 113, 218, 37} ,{67, 113, 219, 37} ,{67, 113, 220, 37} ,{67, 113, 221, 37} ,{67, 113, 182, 7} ,{67, 113, 57, 0} ,{67, 113, 46, 0} ,{67, 113, 222, 37} ,{67, 113, 63, 0} ,{67, 113, 226, 22} ,{67, 113, 228, 2} ,{67, 113, 54, 0} ,{67, 113, 47, 0} ,{67, 113, 55, 0} ,{67, 113, 64, 0} ,{67, 113, 60, 0} ,{67, 113, 52, 0} ,{136, 166, 224, 1} ,{95, 113, 51, 0} ,{95, 113, 230, 33} ,{95, 113, 216, 37} ,{95, 113, 58, 0} ,{95, 113, 212, 0} ,{95, 113, 89, 7} ,{95, 113, 48, 0} ,{95, 113, 56, 0} ,{95, 113, 217, 37} ,{95, 113, 151, 17} ,{95, 113, 218, 37} ,{95, 113, 219, 37} ,{95, 113, 220, 37} ,{95, 113, 221, 37} ,{95, 113, 182, 7} ,{95, 113, 57, 0} ,{95, 113, 46, 0} ,{95, 113, 222, 37} ,{95, 113, 63, 0} ,{95, 113, 226, 22} ,{95, 113, 228, 2} ,{95, 113, 54, 0} ,{95, 113, 47, 0} ,{95, 113, 55, 0} ,{95, 113, 64, 0} ,{95, 113, 60, 0} ,{95, 113, 52, 0} ,{136, 166, 225, 5} ,{123, 113, 51, 0} ,{123, 113, 230, 33} ,{123, 113, 216, 37} ,{123, 113, 58, 0} ,{123, 113, 212, 0} ,{123, 113, 89, 7} ,{123, 113, 48, 0} ,{123, 113, 56, 0} ,{123, 113, 217, 37} ,{123, 113, 151, 17} ,{123, 113, 218, 37} ,{123, 113, 219, 37} ,{123, 113, 220, 37} ,{123, 113, 221, 37} ,{123, 113, 182, 7} ,{123, 113, 57, 0} ,{123, 113, 46, 0} ,{123, 113, 222, 37} ,{123, 113, 63, 0} ,{123, 113, 226, 22} ,{123, 113, 228, 2} ,{123, 113, 54, 0} ,{123, 113, 47, 0} ,{123, 113, 55, 0} ,{123, 113, 64, 0} ,{123, 113, 60, 0} ,{123, 113, 52, 0} ,{136, 166, 49, 0} ,{151, 113, 51, 0} ,{151, 113, 230, 33} ,{151, 113, 216, 37} ,{151, 113, 58, 0} ,{151, 113, 212, 0} ,{151, 113, 89, 7} ,{151, 113, 48, 0} ,{151, 113, 56, 0} ,{151, 113, 217, 37} ,{151, 113, 151, 17} ,{151, 113, 218, 37} ,{151, 113, 219, 37} ,{151, 113, 220, 37} ,{151, 113, 221, 37} ,{151, 113, 182, 7} ,{151, 113, 57, 0} ,{151, 113, 46, 0} ,{151, 113, 222, 37} ,{151, 113, 63, 0} ,{151, 113, 226, 22} ,{151, 113, 228, 2} ,{151, 113, 54, 0} ,{151, 113, 47, 0} ,{151, 113, 55, 0} ,{151, 113, 64, 0} ,{151, 113, 60, 0} ,{151, 113, 52, 0} ,{136, 166, 226, 5} ,{179, 113, 51, 0} ,{179, 113, 230, 33} ,{179, 113, 216, 37} ,{179, 113, 58, 0} ,{179, 113, 212, 0} ,{179, 113, 89, 7} ,{179, 113, 48, 0} ,{179, 113, 56, 0} ,{179, 113, 217, 37} ,{179, 113, 151, 17} ,{179, 113, 218, 37} ,{179, 113, 219, 37} ,{179, 113, 220, 37} ,{179, 113, 221, 37} ,{179, 113, 182, 7} ,{179, 113, 57, 0} ,{179, 113, 46, 0} ,{179, 113, 222, 37} ,{179, 113, 63, 0} ,{179, 113, 226, 22} ,{179, 113, 228, 2} ,{179, 113, 54, 0} ,{179, 113, 47, 0} ,{179, 113, 55, 0} ,{179, 113, 64, 0} ,{179, 113, 60, 0} ,{179, 113, 52, 0} ,{136, 166, 227, 5} ,{207, 113, 51, 0} ,{207, 113, 230, 33} ,{207, 113, 216, 37} ,{207, 113, 58, 0} ,{207, 113, 212, 0} ,{207, 113, 89, 7} ,{207, 113, 48, 0} ,{207, 113, 56, 0} ,{207, 113, 217, 37} ,{207, 113, 151, 17} ,{207, 113, 218, 37} ,{207, 113, 219, 37} ,{207, 113, 220, 37} ,{207, 113, 221, 37} ,{207, 113, 182, 7} ,{207, 113, 57, 0} ,{207, 113, 46, 0} ,{207, 113, 222, 37} ,{207, 113, 63, 0} ,{207, 113, 226, 22} ,{207, 113, 228, 2} ,{207, 113, 54, 0} ,{207, 113, 47, 0} ,{207, 113, 55, 0} ,{207, 113, 64, 0} ,{207, 113, 60, 0} ,{207, 113, 52, 0} ,{136, 166, 59, 0} ,{235, 113, 51, 0} ,{235, 113, 230, 33} ,{235, 113, 216, 37} ,{235, 113, 58, 0} ,{235, 113, 212, 0} ,{235, 113, 89, 7} ,{235, 113, 48, 0} ,{235, 113, 56, 0} ,{235, 113, 217, 37} ,{235, 113, 151, 17} ,{235, 113, 218, 37} ,{235, 113, 219, 37} ,{235, 113, 220, 37} ,{235, 113, 221, 37} ,{235, 113, 182, 7} ,{235, 113, 57, 0} ,{235, 113, 46, 0} ,{235, 113, 222, 37} ,{235, 113, 63, 0} ,{235, 113, 226, 22} ,{235, 113, 228, 2} ,{235, 113, 54, 0} ,{235, 113, 47, 0} ,{235, 113, 55, 0} ,{235, 113, 64, 0} ,{235, 113, 60, 0} ,{235, 113, 52, 0} ,{136, 166, 140, 3} ,{7, 114, 51, 0} ,{7, 114, 230, 33} ,{7, 114, 216, 37} ,{7, 114, 58, 0} ,{7, 114, 212, 0} ,{7, 114, 89, 7} ,{7, 114, 48, 0} ,{7, 114, 56, 0} ,{7, 114, 217, 37} ,{7, 114, 151, 17} ,{7, 114, 218, 37} ,{7, 114, 219, 37} ,{7, 114, 220, 37} ,{7, 114, 221, 37} ,{7, 114, 182, 7} ,{7, 114, 57, 0} ,{7, 114, 46, 0} ,{7, 114, 222, 37} ,{7, 114, 63, 0} ,{7, 114, 226, 22} ,{7, 114, 228, 2} ,{7, 114, 54, 0} ,{7, 114, 47, 0} ,{7, 114, 55, 0} ,{7, 114, 64, 0} ,{7, 114, 60, 0} ,{7, 114, 52, 0} ,{136, 166, 228, 5} ,{35, 114, 51, 0} ,{35, 114, 230, 33} ,{35, 114, 216, 37} ,{35, 114, 58, 0} ,{35, 114, 212, 0} ,{35, 114, 89, 7} ,{35, 114, 48, 0} ,{35, 114, 56, 0} ,{35, 114, 217, 37} ,{35, 114, 151, 17} ,{35, 114, 218, 37} ,{35, 114, 219, 37} ,{35, 114, 220, 37} ,{35, 114, 221, 37} ,{35, 114, 182, 7} ,{35, 114, 57, 0} ,{35, 114, 46, 0} ,{35, 114, 222, 37} ,{35, 114, 63, 0} ,{35, 114, 226, 22} ,{35, 114, 228, 2} ,{35, 114, 54, 0} ,{35, 114, 47, 0} ,{35, 114, 55, 0} ,{35, 114, 64, 0} ,{35, 114, 60, 0} ,{35, 114, 52, 0} ,{136, 166, 164, 0} ,{63, 114, 51, 0} ,{63, 114, 230, 33} ,{63, 114, 216, 37} ,{63, 114, 58, 0} ,{63, 114, 212, 0} ,{63, 114, 89, 7} ,{63, 114, 48, 0} ,{63, 114, 56, 0} ,{63, 114, 217, 37} ,{63, 114, 151, 17} ,{63, 114, 218, 37} ,{63, 114, 219, 37} ,{63, 114, 220, 37} ,{63, 114, 221, 37} ,{63, 114, 182, 7} ,{63, 114, 57, 0} ,{63, 114, 46, 0} ,{63, 114, 222, 37} ,{63, 114, 63, 0} ,{63, 114, 226, 22} ,{63, 114, 228, 2} ,{63, 114, 54, 0} ,{63, 114, 47, 0} ,{63, 114, 55, 0} ,{63, 114, 64, 0} ,{63, 114, 60, 0} ,{63, 114, 52, 0} ,{136, 166, 204, 4} ,{91, 114, 51, 0} ,{91, 114, 230, 33} ,{91, 114, 216, 37} ,{91, 114, 58, 0} ,{91, 114, 212, 0} ,{91, 114, 89, 7} ,{91, 114, 48, 0} ,{91, 114, 56, 0} ,{91, 114, 217, 37} ,{91, 114, 151, 17} ,{91, 114, 218, 37} ,{91, 114, 219, 37} ,{91, 114, 220, 37} ,{91, 114, 221, 37} ,{91, 114, 182, 7} ,{91, 114, 57, 0} ,{91, 114, 46, 0} ,{91, 114, 222, 37} ,{91, 114, 63, 0} ,{91, 114, 226, 22} ,{91, 114, 228, 2} ,{91, 114, 54, 0} ,{91, 114, 47, 0} ,{91, 114, 55, 0} ,{91, 114, 64, 0} ,{91, 114, 60, 0} ,{91, 114, 52, 0} ,{136, 166, 65, 0} ,{119, 114, 51, 0} ,{119, 114, 230, 33} ,{119, 114, 216, 37} ,{119, 114, 58, 0} ,{119, 114, 212, 0} ,{119, 114, 89, 7} ,{119, 114, 48, 0} ,{119, 114, 56, 0} ,{119, 114, 217, 37} ,{119, 114, 151, 17} ,{119, 114, 218, 37} ,{119, 114, 219, 37} ,{119, 114, 220, 37} ,{119, 114, 221, 37} ,{119, 114, 182, 7} ,{119, 114, 57, 0} ,{119, 114, 46, 0} ,{119, 114, 222, 37} ,{119, 114, 63, 0} ,{119, 114, 226, 22} ,{119, 114, 228, 2} ,{119, 114, 54, 0} ,{119, 114, 47, 0} ,{119, 114, 55, 0} ,{119, 114, 64, 0} ,{119, 114, 60, 0} ,{119, 114, 52, 0} ,{136, 166, 229, 5} ,{147, 114, 51, 0} ,{147, 114, 230, 33} ,{147, 114, 216, 37} ,{147, 114, 58, 0} ,{147, 114, 212, 0} ,{147, 114, 89, 7} ,{147, 114, 48, 0} ,{147, 114, 56, 0} ,{147, 114, 217, 37} ,{147, 114, 151, 17} ,{147, 114, 218, 37} ,{147, 114, 219, 37} ,{147, 114, 220, 37} ,{147, 114, 221, 37} ,{147, 114, 182, 7} ,{147, 114, 57, 0} ,{147, 114, 46, 0} ,{147, 114, 222, 37} ,{147, 114, 63, 0} ,{147, 114, 226, 22} ,{147, 114, 228, 2} ,{147, 114, 54, 0} ,{147, 114, 47, 0} ,{147, 114, 55, 0} ,{147, 114, 64, 0} ,{147, 114, 60, 0} ,{147, 114, 52, 0} ,{136, 166, 226, 1} ,{175, 114, 51, 0} ,{175, 114, 230, 33} ,{175, 114, 216, 37} ,{175, 114, 58, 0} ,{175, 114, 212, 0} ,{175, 114, 89, 7} ,{175, 114, 48, 0} ,{175, 114, 56, 0} ,{175, 114, 217, 37} ,{175, 114, 151, 17} ,{175, 114, 218, 37} ,{175, 114, 219, 37} ,{175, 114, 220, 37} ,{175, 114, 221, 37} ,{175, 114, 182, 7} ,{175, 114, 57, 0} ,{175, 114, 46, 0} ,{175, 114, 222, 37} ,{175, 114, 63, 0} ,{175, 114, 226, 22} ,{175, 114, 228, 2} ,{175, 114, 54, 0} ,{175, 114, 47, 0} ,{175, 114, 55, 0} ,{175, 114, 64, 0} ,{175, 114, 60, 0} ,{175, 114, 52, 0} ,{136, 166, 230, 5} ,{203, 114, 51, 0} ,{203, 114, 230, 33} ,{203, 114, 216, 37} ,{203, 114, 58, 0} ,{203, 114, 212, 0} ,{203, 114, 89, 7} ,{203, 114, 48, 0} ,{203, 114, 56, 0} ,{203, 114, 217, 37} ,{203, 114, 151, 17} ,{203, 114, 218, 37} ,{203, 114, 219, 37} ,{203, 114, 220, 37} ,{203, 114, 221, 37} ,{203, 114, 182, 7} ,{203, 114, 57, 0} ,{203, 114, 46, 0} ,{203, 114, 222, 37} ,{203, 114, 63, 0} ,{203, 114, 226, 22} ,{203, 114, 228, 2} ,{203, 114, 54, 0} ,{203, 114, 47, 0} ,{203, 114, 55, 0} ,{203, 114, 64, 0} ,{203, 114, 60, 0} ,{203, 114, 52, 0} ,{136, 166, 170, 1} ,{231, 114, 51, 0} ,{231, 114, 230, 33} ,{231, 114, 216, 37} ,{231, 114, 58, 0} ,{231, 114, 212, 0} ,{231, 114, 89, 7} ,{231, 114, 48, 0} ,{231, 114, 56, 0} ,{231, 114, 217, 37} ,{231, 114, 151, 17} ,{231, 114, 218, 37} ,{231, 114, 219, 37} ,{231, 114, 220, 37} ,{231, 114, 221, 37} ,{231, 114, 182, 7} ,{231, 114, 57, 0} ,{231, 114, 46, 0} ,{231, 114, 222, 37} ,{231, 114, 63, 0} ,{231, 114, 226, 22} ,{231, 114, 228, 2} ,{231, 114, 54, 0} ,{231, 114, 47, 0} ,{231, 114, 55, 0} ,{231, 114, 64, 0} ,{231, 114, 60, 0} ,{231, 114, 52, 0} ,{136, 166, 110, 5} ,{3, 115, 51, 0} ,{3, 115, 230, 33} ,{3, 115, 216, 37} ,{3, 115, 58, 0} ,{3, 115, 212, 0} ,{3, 115, 89, 7} ,{3, 115, 48, 0} ,{3, 115, 56, 0} ,{3, 115, 217, 37} ,{3, 115, 151, 17} ,{3, 115, 218, 37} ,{3, 115, 219, 37} ,{3, 115, 220, 37} ,{3, 115, 221, 37} ,{3, 115, 182, 7} ,{3, 115, 57, 0} ,{3, 115, 46, 0} ,{3, 115, 222, 37} ,{3, 115, 63, 0} ,{3, 115, 226, 22} ,{3, 115, 228, 2} ,{3, 115, 54, 0} ,{3, 115, 47, 0} ,{3, 115, 55, 0} ,{3, 115, 64, 0} ,{3, 115, 60, 0} ,{3, 115, 52, 0} ,{136, 166, 141, 1} ,{31, 115, 51, 0} ,{31, 115, 230, 33} ,{31, 115, 216, 37} ,{31, 115, 58, 0} ,{31, 115, 212, 0} ,{31, 115, 89, 7} ,{31, 115, 48, 0} ,{31, 115, 56, 0} ,{31, 115, 217, 37} ,{31, 115, 151, 17} ,{31, 115, 218, 37} ,{31, 115, 219, 37} ,{31, 115, 220, 37} ,{31, 115, 221, 37} ,{31, 115, 182, 7} ,{31, 115, 57, 0} ,{31, 115, 46, 0} ,{31, 115, 222, 37} ,{31, 115, 63, 0} ,{31, 115, 226, 22} ,{31, 115, 228, 2} ,{31, 115, 54, 0} ,{31, 115, 47, 0} ,{31, 115, 55, 0} ,{31, 115, 64, 0} ,{31, 115, 60, 0} ,{31, 115, 52, 0} ,{136, 166, 53, 0} ,{59, 115, 51, 0} ,{59, 115, 230, 33} ,{59, 115, 216, 37} ,{59, 115, 58, 0} ,{59, 115, 212, 0} ,{59, 115, 89, 7} ,{59, 115, 48, 0} ,{59, 115, 56, 0} ,{59, 115, 217, 37} ,{59, 115, 151, 17} ,{59, 115, 218, 37} ,{59, 115, 219, 37} ,{59, 115, 220, 37} ,{59, 115, 221, 37} ,{59, 115, 182, 7} ,{59, 115, 57, 0} ,{59, 115, 46, 0} ,{59, 115, 222, 37} ,{59, 115, 63, 0} ,{59, 115, 226, 22} ,{59, 115, 228, 2} ,{59, 115, 54, 0} ,{59, 115, 47, 0} ,{59, 115, 55, 0} ,{59, 115, 64, 0} ,{59, 115, 60, 0} ,{59, 115, 52, 0} ,{137, 166, 45, 0} ,{87, 115, 51, 0} ,{87, 115, 230, 33} ,{87, 115, 216, 37} ,{87, 115, 58, 0} ,{87, 115, 212, 0} ,{87, 115, 89, 7} ,{87, 115, 48, 0} ,{87, 115, 56, 0} ,{87, 115, 217, 37} ,{87, 115, 151, 17} ,{87, 115, 218, 37} ,{87, 115, 219, 37} ,{87, 115, 220, 37} ,{87, 115, 221, 37} ,{87, 115, 182, 7} ,{87, 115, 57, 0} ,{87, 115, 46, 0} ,{87, 115, 222, 37} ,{87, 115, 63, 0} ,{87, 115, 226, 22} ,{87, 115, 228, 2} ,{87, 115, 54, 0} ,{87, 115, 47, 0} ,{87, 115, 55, 0} ,{87, 115, 64, 0} ,{87, 115, 60, 0} ,{87, 115, 52, 0} ,{137, 166, 133, 0} ,{115, 115, 51, 0} ,{115, 115, 230, 33} ,{115, 115, 216, 37} ,{115, 115, 58, 0} ,{115, 115, 212, 0} ,{115, 115, 89, 7} ,{115, 115, 48, 0} ,{115, 115, 56, 0} ,{115, 115, 217, 37} ,{115, 115, 151, 17} ,{115, 115, 218, 37} ,{115, 115, 219, 37} ,{115, 115, 220, 37} ,{115, 115, 221, 37} ,{115, 115, 182, 7} ,{115, 115, 57, 0} ,{115, 115, 46, 0} ,{115, 115, 222, 37} ,{115, 115, 63, 0} ,{115, 115, 226, 22} ,{115, 115, 228, 2} ,{115, 115, 54, 0} ,{115, 115, 47, 0} ,{115, 115, 55, 0} ,{115, 115, 64, 0} ,{115, 115, 60, 0} ,{115, 115, 52, 0} ,{137, 166, 171, 1} ,{143, 115, 51, 0} ,{143, 115, 230, 33} ,{143, 115, 216, 37} ,{143, 115, 58, 0} ,{143, 115, 212, 0} ,{143, 115, 89, 7} ,{143, 115, 48, 0} ,{143, 115, 56, 0} ,{143, 115, 217, 37} ,{143, 115, 151, 17} ,{143, 115, 218, 37} ,{143, 115, 219, 37} ,{143, 115, 220, 37} ,{143, 115, 221, 37} ,{143, 115, 182, 7} ,{143, 115, 57, 0} ,{143, 115, 46, 0} ,{143, 115, 222, 37} ,{143, 115, 63, 0} ,{143, 115, 226, 22} ,{143, 115, 228, 2} ,{143, 115, 54, 0} ,{143, 115, 47, 0} ,{143, 115, 55, 0} ,{143, 115, 64, 0} ,{143, 115, 60, 0} ,{143, 115, 52, 0} ,{137, 166, 224, 1} ,{171, 115, 51, 0} ,{171, 115, 230, 33} ,{171, 115, 216, 37} ,{171, 115, 58, 0} ,{171, 115, 212, 0} ,{171, 115, 89, 7} ,{171, 115, 48, 0} ,{171, 115, 56, 0} ,{171, 115, 217, 37} ,{171, 115, 151, 17} ,{171, 115, 218, 37} ,{171, 115, 219, 37} ,{171, 115, 220, 37} ,{171, 115, 221, 37} ,{171, 115, 182, 7} ,{171, 115, 57, 0} ,{171, 115, 46, 0} ,{171, 115, 222, 37} ,{171, 115, 63, 0} ,{171, 115, 226, 22} ,{171, 115, 228, 2} ,{171, 115, 54, 0} ,{171, 115, 47, 0} ,{171, 115, 55, 0} ,{171, 115, 64, 0} ,{171, 115, 60, 0} ,{171, 115, 52, 0} ,{137, 166, 225, 5} ,{199, 115, 51, 0} ,{199, 115, 230, 33} ,{199, 115, 216, 37} ,{199, 115, 58, 0} ,{199, 115, 212, 0} ,{199, 115, 89, 7} ,{199, 115, 48, 0} ,{199, 115, 56, 0} ,{199, 115, 217, 37} ,{199, 115, 151, 17} ,{199, 115, 218, 37} ,{199, 115, 219, 37} ,{199, 115, 220, 37} ,{199, 115, 221, 37} ,{199, 115, 182, 7} ,{199, 115, 57, 0} ,{199, 115, 46, 0} ,{199, 115, 222, 37} ,{199, 115, 63, 0} ,{199, 115, 226, 22} ,{199, 115, 228, 2} ,{199, 115, 54, 0} ,{199, 115, 47, 0} ,{199, 115, 55, 0} ,{199, 115, 64, 0} ,{199, 115, 60, 0} ,{199, 115, 52, 0} ,{137, 166, 49, 0} ,{227, 115, 51, 0} ,{227, 115, 230, 33} ,{227, 115, 216, 37} ,{227, 115, 58, 0} ,{227, 115, 212, 0} ,{227, 115, 89, 7} ,{227, 115, 48, 0} ,{227, 115, 56, 0} ,{227, 115, 217, 37} ,{227, 115, 151, 17} ,{227, 115, 218, 37} ,{227, 115, 219, 37} ,{227, 115, 220, 37} ,{227, 115, 221, 37} ,{227, 115, 182, 7} ,{227, 115, 57, 0} ,{227, 115, 46, 0} ,{227, 115, 222, 37} ,{227, 115, 63, 0} ,{227, 115, 226, 22} ,{227, 115, 228, 2} ,{227, 115, 54, 0} ,{227, 115, 47, 0} ,{227, 115, 55, 0} ,{227, 115, 64, 0} ,{227, 115, 60, 0} ,{227, 115, 52, 0} ,{137, 166, 226, 5} ,{255, 115, 51, 0} ,{255, 115, 230, 33} ,{255, 115, 216, 37} ,{255, 115, 58, 0} ,{255, 115, 212, 0} ,{255, 115, 89, 7} ,{255, 115, 48, 0} ,{255, 115, 56, 0} ,{255, 115, 217, 37} ,{255, 115, 151, 17} ,{255, 115, 218, 37} ,{255, 115, 219, 37} ,{255, 115, 220, 37} ,{255, 115, 221, 37} ,{255, 115, 182, 7} ,{255, 115, 57, 0} ,{255, 115, 46, 0} ,{255, 115, 222, 37} ,{255, 115, 63, 0} ,{255, 115, 226, 22} ,{255, 115, 228, 2} ,{255, 115, 54, 0} ,{255, 115, 47, 0} ,{255, 115, 55, 0} ,{255, 115, 64, 0} ,{255, 115, 60, 0} ,{255, 115, 52, 0} ,{137, 166, 227, 5} ,{27, 116, 51, 0} ,{27, 116, 230, 33} ,{27, 116, 216, 37} ,{27, 116, 58, 0} ,{27, 116, 212, 0} ,{27, 116, 89, 7} ,{27, 116, 48, 0} ,{27, 116, 56, 0} ,{27, 116, 217, 37} ,{27, 116, 151, 17} ,{27, 116, 218, 37} ,{27, 116, 219, 37} ,{27, 116, 220, 37} ,{27, 116, 221, 37} ,{27, 116, 182, 7} ,{27, 116, 57, 0} ,{27, 116, 46, 0} ,{27, 116, 222, 37} ,{27, 116, 63, 0} ,{27, 116, 226, 22} ,{27, 116, 228, 2} ,{27, 116, 54, 0} ,{27, 116, 47, 0} ,{27, 116, 55, 0} ,{27, 116, 64, 0} ,{27, 116, 60, 0} ,{27, 116, 52, 0} ,{137, 166, 59, 0} ,{55, 116, 51, 0} ,{55, 116, 230, 33} ,{55, 116, 216, 37} ,{55, 116, 58, 0} ,{55, 116, 212, 0} ,{55, 116, 89, 7} ,{55, 116, 48, 0} ,{55, 116, 56, 0} ,{55, 116, 217, 37} ,{55, 116, 151, 17} ,{55, 116, 218, 37} ,{55, 116, 219, 37} ,{55, 116, 220, 37} ,{55, 116, 221, 37} ,{55, 116, 182, 7} ,{55, 116, 57, 0} ,{55, 116, 46, 0} ,{55, 116, 222, 37} ,{55, 116, 63, 0} ,{55, 116, 226, 22} ,{55, 116, 228, 2} ,{55, 116, 54, 0} ,{55, 116, 47, 0} ,{55, 116, 55, 0} ,{55, 116, 64, 0} ,{55, 116, 60, 0} ,{55, 116, 52, 0} ,{137, 166, 140, 3} ,{83, 116, 51, 0} ,{83, 116, 230, 33} ,{83, 116, 216, 37} ,{83, 116, 58, 0} ,{83, 116, 212, 0} ,{83, 116, 89, 7} ,{83, 116, 48, 0} ,{83, 116, 56, 0} ,{83, 116, 217, 37} ,{83, 116, 151, 17} ,{83, 116, 218, 37} ,{83, 116, 219, 37} ,{83, 116, 220, 37} ,{83, 116, 221, 37} ,{83, 116, 182, 7} ,{83, 116, 57, 0} ,{83, 116, 46, 0} ,{83, 116, 222, 37} ,{83, 116, 63, 0} ,{83, 116, 226, 22} ,{83, 116, 228, 2} ,{83, 116, 54, 0} ,{83, 116, 47, 0} ,{83, 116, 55, 0} ,{83, 116, 64, 0} ,{83, 116, 60, 0} ,{83, 116, 52, 0} ,{137, 166, 228, 5} ,{111, 116, 51, 0} ,{111, 116, 230, 33} ,{111, 116, 216, 37} ,{111, 116, 58, 0} ,{111, 116, 212, 0} ,{111, 116, 89, 7} ,{111, 116, 48, 0} ,{111, 116, 56, 0} ,{111, 116, 217, 37} ,{111, 116, 151, 17} ,{111, 116, 218, 37} ,{111, 116, 219, 37} ,{111, 116, 220, 37} ,{111, 116, 221, 37} ,{111, 116, 182, 7} ,{111, 116, 57, 0} ,{111, 116, 46, 0} ,{111, 116, 222, 37} ,{111, 116, 63, 0} ,{111, 116, 226, 22} ,{111, 116, 228, 2} ,{111, 116, 54, 0} ,{111, 116, 47, 0} ,{111, 116, 55, 0} ,{111, 116, 64, 0} ,{111, 116, 60, 0} ,{111, 116, 52, 0} ,{137, 166, 164, 0} ,{139, 116, 51, 0} ,{139, 116, 230, 33} ,{139, 116, 216, 37} ,{139, 116, 58, 0} ,{139, 116, 212, 0} ,{139, 116, 89, 7} ,{139, 116, 48, 0} ,{139, 116, 56, 0} ,{139, 116, 217, 37} ,{139, 116, 151, 17} ,{139, 116, 218, 37} ,{139, 116, 219, 37} ,{139, 116, 220, 37} ,{139, 116, 221, 37} ,{139, 116, 182, 7} ,{139, 116, 57, 0} ,{139, 116, 46, 0} ,{139, 116, 222, 37} ,{139, 116, 63, 0} ,{139, 116, 226, 22} ,{139, 116, 228, 2} ,{139, 116, 54, 0} ,{139, 116, 47, 0} ,{139, 116, 55, 0} ,{139, 116, 64, 0} ,{139, 116, 60, 0} ,{139, 116, 52, 0} ,{137, 166, 204, 4} ,{167, 116, 51, 0} ,{167, 116, 230, 33} ,{167, 116, 216, 37} ,{167, 116, 58, 0} ,{167, 116, 212, 0} ,{167, 116, 89, 7} ,{167, 116, 48, 0} ,{167, 116, 56, 0} ,{167, 116, 217, 37} ,{167, 116, 151, 17} ,{167, 116, 218, 37} ,{167, 116, 219, 37} ,{167, 116, 220, 37} ,{167, 116, 221, 37} ,{167, 116, 182, 7} ,{167, 116, 57, 0} ,{167, 116, 46, 0} ,{167, 116, 222, 37} ,{167, 116, 63, 0} ,{167, 116, 226, 22} ,{167, 116, 228, 2} ,{167, 116, 54, 0} ,{167, 116, 47, 0} ,{167, 116, 55, 0} ,{167, 116, 64, 0} ,{167, 116, 60, 0} ,{167, 116, 52, 0} ,{137, 166, 65, 0} ,{195, 116, 51, 0} ,{195, 116, 230, 33} ,{195, 116, 216, 37} ,{195, 116, 58, 0} ,{195, 116, 212, 0} ,{195, 116, 89, 7} ,{195, 116, 48, 0} ,{195, 116, 56, 0} ,{195, 116, 217, 37} ,{195, 116, 151, 17} ,{195, 116, 218, 37} ,{195, 116, 219, 37} ,{195, 116, 220, 37} ,{195, 116, 221, 37} ,{195, 116, 182, 7} ,{195, 116, 57, 0} ,{195, 116, 46, 0} ,{195, 116, 222, 37} ,{195, 116, 63, 0} ,{195, 116, 226, 22} ,{195, 116, 228, 2} ,{195, 116, 54, 0} ,{195, 116, 47, 0} ,{195, 116, 55, 0} ,{195, 116, 64, 0} ,{195, 116, 60, 0} ,{195, 116, 52, 0} ,{137, 166, 229, 5} ,{223, 116, 51, 0} ,{223, 116, 230, 33} ,{223, 116, 216, 37} ,{223, 116, 58, 0} ,{223, 116, 212, 0} ,{223, 116, 89, 7} ,{223, 116, 48, 0} ,{223, 116, 56, 0} ,{223, 116, 217, 37} ,{223, 116, 151, 17} ,{223, 116, 218, 37} ,{223, 116, 219, 37} ,{223, 116, 220, 37} ,{223, 116, 221, 37} ,{223, 116, 182, 7} ,{223, 116, 57, 0} ,{223, 116, 46, 0} ,{223, 116, 222, 37} ,{223, 116, 63, 0} ,{223, 116, 226, 22} ,{223, 116, 228, 2} ,{223, 116, 54, 0} ,{223, 116, 47, 0} ,{223, 116, 55, 0} ,{223, 116, 64, 0} ,{223, 116, 60, 0} ,{223, 116, 52, 0} ,{137, 166, 226, 1} ,{251, 116, 51, 0} ,{251, 116, 230, 33} ,{251, 116, 216, 37} ,{251, 116, 58, 0} ,{251, 116, 212, 0} ,{251, 116, 89, 7} ,{251, 116, 48, 0} ,{251, 116, 56, 0} ,{251, 116, 217, 37} ,{251, 116, 151, 17} ,{251, 116, 218, 37} ,{251, 116, 219, 37} ,{251, 116, 220, 37} ,{251, 116, 221, 37} ,{251, 116, 182, 7} ,{251, 116, 57, 0} ,{251, 116, 46, 0} ,{251, 116, 222, 37} ,{251, 116, 63, 0} ,{251, 116, 226, 22} ,{251, 116, 228, 2} ,{251, 116, 54, 0} ,{251, 116, 47, 0} ,{251, 116, 55, 0} ,{251, 116, 64, 0} ,{251, 116, 60, 0} ,{251, 116, 52, 0} ,{137, 166, 230, 5} ,{23, 117, 51, 0} ,{23, 117, 230, 33} ,{23, 117, 216, 37} ,{23, 117, 58, 0} ,{23, 117, 212, 0} ,{23, 117, 89, 7} ,{23, 117, 48, 0} ,{23, 117, 56, 0} ,{23, 117, 217, 37} ,{23, 117, 151, 17} ,{23, 117, 218, 37} ,{23, 117, 219, 37} ,{23, 117, 220, 37} ,{23, 117, 221, 37} ,{23, 117, 182, 7} ,{23, 117, 57, 0} ,{23, 117, 46, 0} ,{23, 117, 222, 37} ,{23, 117, 63, 0} ,{23, 117, 226, 22} ,{23, 117, 228, 2} ,{23, 117, 54, 0} ,{23, 117, 47, 0} ,{23, 117, 55, 0} ,{23, 117, 64, 0} ,{23, 117, 60, 0} ,{23, 117, 52, 0} ,{137, 166, 170, 1} ,{51, 117, 51, 0} ,{51, 117, 230, 33} ,{51, 117, 216, 37} ,{51, 117, 58, 0} ,{51, 117, 212, 0} ,{51, 117, 89, 7} ,{51, 117, 48, 0} ,{51, 117, 56, 0} ,{51, 117, 217, 37} ,{51, 117, 151, 17} ,{51, 117, 218, 37} ,{51, 117, 219, 37} ,{51, 117, 220, 37} ,{51, 117, 221, 37} ,{51, 117, 182, 7} ,{51, 117, 57, 0} ,{51, 117, 46, 0} ,{51, 117, 222, 37} ,{51, 117, 63, 0} ,{51, 117, 226, 22} ,{51, 117, 228, 2} ,{51, 117, 54, 0} ,{51, 117, 47, 0} ,{51, 117, 55, 0} ,{51, 117, 64, 0} ,{51, 117, 60, 0} ,{51, 117, 52, 0} ,{137, 166, 110, 5} ,{79, 117, 51, 0} ,{79, 117, 230, 33} ,{79, 117, 216, 37} ,{79, 117, 58, 0} ,{79, 117, 212, 0} ,{79, 117, 89, 7} ,{79, 117, 48, 0} ,{79, 117, 56, 0} ,{79, 117, 217, 37} ,{79, 117, 151, 17} ,{79, 117, 218, 37} ,{79, 117, 219, 37} ,{79, 117, 220, 37} ,{79, 117, 221, 37} ,{79, 117, 182, 7} ,{79, 117, 57, 0} ,{79, 117, 46, 0} ,{79, 117, 222, 37} ,{79, 117, 63, 0} ,{79, 117, 226, 22} ,{79, 117, 228, 2} ,{79, 117, 54, 0} ,{79, 117, 47, 0} ,{79, 117, 55, 0} ,{79, 117, 64, 0} ,{79, 117, 60, 0} ,{79, 117, 52, 0} ,{137, 166, 141, 1} ,{107, 117, 51, 0} ,{107, 117, 230, 33} ,{107, 117, 216, 37} ,{107, 117, 58, 0} ,{107, 117, 212, 0} ,{107, 117, 89, 7} ,{107, 117, 48, 0} ,{107, 117, 56, 0} ,{107, 117, 217, 37} ,{107, 117, 151, 17} ,{107, 117, 218, 37} ,{107, 117, 219, 37} ,{107, 117, 220, 37} ,{107, 117, 221, 37} ,{107, 117, 182, 7} ,{107, 117, 57, 0} ,{107, 117, 46, 0} ,{107, 117, 222, 37} ,{107, 117, 63, 0} ,{107, 117, 226, 22} ,{107, 117, 228, 2} ,{107, 117, 54, 0} ,{107, 117, 47, 0} ,{107, 117, 55, 0} ,{107, 117, 64, 0} ,{107, 117, 60, 0} ,{107, 117, 52, 0} ,{137, 166, 53, 0} ,{135, 117, 51, 0} ,{135, 117, 230, 33} ,{135, 117, 216, 37} ,{135, 117, 58, 0} ,{135, 117, 212, 0} ,{135, 117, 89, 7} ,{135, 117, 48, 0} ,{135, 117, 56, 0} ,{135, 117, 217, 37} ,{135, 117, 151, 17} ,{135, 117, 218, 37} ,{135, 117, 219, 37} ,{135, 117, 220, 37} ,{135, 117, 221, 37} ,{135, 117, 182, 7} ,{135, 117, 57, 0} ,{135, 117, 46, 0} ,{135, 117, 222, 37} ,{135, 117, 63, 0} ,{135, 117, 226, 22} ,{135, 117, 228, 2} ,{135, 117, 54, 0} ,{135, 117, 47, 0} ,{135, 117, 55, 0} ,{135, 117, 64, 0} ,{135, 117, 60, 0} ,{135, 117, 52, 0} ,{138, 166, 45, 0} ,{163, 117, 51, 0} ,{163, 117, 230, 33} ,{163, 117, 216, 37} ,{163, 117, 58, 0} ,{163, 117, 212, 0} ,{163, 117, 89, 7} ,{163, 117, 48, 0} ,{163, 117, 56, 0} ,{163, 117, 217, 37} ,{163, 117, 151, 17} ,{163, 117, 218, 37} ,{163, 117, 219, 37} ,{163, 117, 220, 37} ,{163, 117, 221, 37} ,{163, 117, 182, 7} ,{163, 117, 57, 0} ,{163, 117, 46, 0} ,{163, 117, 222, 37} ,{163, 117, 63, 0} ,{163, 117, 226, 22} ,{163, 117, 228, 2} ,{163, 117, 54, 0} ,{163, 117, 47, 0} ,{163, 117, 55, 0} ,{163, 117, 64, 0} ,{163, 117, 60, 0} ,{163, 117, 52, 0} ,{138, 166, 133, 0} ,{191, 117, 51, 0} ,{191, 117, 230, 33} ,{191, 117, 216, 37} ,{191, 117, 58, 0} ,{191, 117, 212, 0} ,{191, 117, 89, 7} ,{191, 117, 48, 0} ,{191, 117, 56, 0} ,{191, 117, 217, 37} ,{191, 117, 151, 17} ,{191, 117, 218, 37} ,{191, 117, 219, 37} ,{191, 117, 220, 37} ,{191, 117, 221, 37} ,{191, 117, 182, 7} ,{191, 117, 57, 0} ,{191, 117, 46, 0} ,{191, 117, 222, 37} ,{191, 117, 63, 0} ,{191, 117, 226, 22} ,{191, 117, 228, 2} ,{191, 117, 54, 0} ,{191, 117, 47, 0} ,{191, 117, 55, 0} ,{191, 117, 64, 0} ,{191, 117, 60, 0} ,{191, 117, 52, 0} ,{138, 166, 171, 1} ,{219, 117, 51, 0} ,{219, 117, 230, 33} ,{219, 117, 216, 37} ,{219, 117, 58, 0} ,{219, 117, 212, 0} ,{219, 117, 89, 7} ,{219, 117, 48, 0} ,{219, 117, 56, 0} ,{219, 117, 217, 37} ,{219, 117, 151, 17} ,{219, 117, 218, 37} ,{219, 117, 219, 37} ,{219, 117, 220, 37} ,{219, 117, 221, 37} ,{219, 117, 182, 7} ,{219, 117, 57, 0} ,{219, 117, 46, 0} ,{219, 117, 222, 37} ,{219, 117, 63, 0} ,{219, 117, 226, 22} ,{219, 117, 228, 2} ,{219, 117, 54, 0} ,{219, 117, 47, 0} ,{219, 117, 55, 0} ,{219, 117, 64, 0} ,{219, 117, 60, 0} ,{219, 117, 52, 0} ,{138, 166, 224, 1} ,{247, 117, 51, 0} ,{247, 117, 230, 33} ,{247, 117, 216, 37} ,{247, 117, 58, 0} ,{247, 117, 212, 0} ,{247, 117, 89, 7} ,{247, 117, 48, 0} ,{247, 117, 56, 0} ,{247, 117, 217, 37} ,{247, 117, 151, 17} ,{247, 117, 218, 37} ,{247, 117, 219, 37} ,{247, 117, 220, 37} ,{247, 117, 221, 37} ,{247, 117, 182, 7} ,{247, 117, 57, 0} ,{247, 117, 46, 0} ,{247, 117, 222, 37} ,{247, 117, 63, 0} ,{247, 117, 226, 22} ,{247, 117, 228, 2} ,{247, 117, 54, 0} ,{247, 117, 47, 0} ,{247, 117, 55, 0} ,{247, 117, 64, 0} ,{247, 117, 60, 0} ,{247, 117, 52, 0} ,{138, 166, 225, 5} ,{19, 118, 51, 0} ,{19, 118, 230, 33} ,{19, 118, 216, 37} ,{19, 118, 58, 0} ,{19, 118, 212, 0} ,{19, 118, 89, 7} ,{19, 118, 48, 0} ,{19, 118, 56, 0} ,{19, 118, 217, 37} ,{19, 118, 151, 17} ,{19, 118, 218, 37} ,{19, 118, 219, 37} ,{19, 118, 220, 37} ,{19, 118, 221, 37} ,{19, 118, 182, 7} ,{19, 118, 57, 0} ,{19, 118, 46, 0} ,{19, 118, 222, 37} ,{19, 118, 63, 0} ,{19, 118, 226, 22} ,{19, 118, 228, 2} ,{19, 118, 54, 0} ,{19, 118, 47, 0} ,{19, 118, 55, 0} ,{19, 118, 64, 0} ,{19, 118, 60, 0} ,{19, 118, 52, 0} ,{138, 166, 49, 0} ,{47, 118, 51, 0} ,{47, 118, 230, 33} ,{47, 118, 216, 37} ,{47, 118, 58, 0} ,{47, 118, 212, 0} ,{47, 118, 89, 7} ,{47, 118, 48, 0} ,{47, 118, 56, 0} ,{47, 118, 217, 37} ,{47, 118, 151, 17} ,{47, 118, 218, 37} ,{47, 118, 219, 37} ,{47, 118, 220, 37} ,{47, 118, 221, 37} ,{47, 118, 182, 7} ,{47, 118, 57, 0} ,{47, 118, 46, 0} ,{47, 118, 222, 37} ,{47, 118, 63, 0} ,{47, 118, 226, 22} ,{47, 118, 228, 2} ,{47, 118, 54, 0} ,{47, 118, 47, 0} ,{47, 118, 55, 0} ,{47, 118, 64, 0} ,{47, 118, 60, 0} ,{47, 118, 52, 0} ,{138, 166, 226, 5} ,{75, 118, 51, 0} ,{75, 118, 230, 33} ,{75, 118, 216, 37} ,{75, 118, 58, 0} ,{75, 118, 212, 0} ,{75, 118, 89, 7} ,{75, 118, 48, 0} ,{75, 118, 56, 0} ,{75, 118, 217, 37} ,{75, 118, 151, 17} ,{75, 118, 218, 37} ,{75, 118, 219, 37} ,{75, 118, 220, 37} ,{75, 118, 221, 37} ,{75, 118, 182, 7} ,{75, 118, 57, 0} ,{75, 118, 46, 0} ,{75, 118, 222, 37} ,{75, 118, 63, 0} ,{75, 118, 226, 22} ,{75, 118, 228, 2} ,{75, 118, 54, 0} ,{75, 118, 47, 0} ,{75, 118, 55, 0} ,{75, 118, 64, 0} ,{75, 118, 60, 0} ,{75, 118, 52, 0} ,{138, 166, 227, 5} ,{103, 118, 51, 0} ,{103, 118, 230, 33} ,{103, 118, 216, 37} ,{103, 118, 58, 0} ,{103, 118, 212, 0} ,{103, 118, 89, 7} ,{103, 118, 48, 0} ,{103, 118, 56, 0} ,{103, 118, 217, 37} ,{103, 118, 151, 17} ,{103, 118, 218, 37} ,{103, 118, 219, 37} ,{103, 118, 220, 37} ,{103, 118, 221, 37} ,{103, 118, 182, 7} ,{103, 118, 57, 0} ,{103, 118, 46, 0} ,{103, 118, 222, 37} ,{103, 118, 63, 0} ,{103, 118, 226, 22} ,{103, 118, 228, 2} ,{103, 118, 54, 0} ,{103, 118, 47, 0} ,{103, 118, 55, 0} ,{103, 118, 64, 0} ,{103, 118, 60, 0} ,{103, 118, 52, 0} ,{138, 166, 59, 0} ,{131, 118, 51, 0} ,{131, 118, 230, 33} ,{131, 118, 216, 37} ,{131, 118, 58, 0} ,{131, 118, 212, 0} ,{131, 118, 89, 7} ,{131, 118, 48, 0} ,{131, 118, 56, 0} ,{131, 118, 217, 37} ,{131, 118, 151, 17} ,{131, 118, 218, 37} ,{131, 118, 219, 37} ,{131, 118, 220, 37} ,{131, 118, 221, 37} ,{131, 118, 182, 7} ,{131, 118, 57, 0} ,{131, 118, 46, 0} ,{131, 118, 222, 37} ,{131, 118, 63, 0} ,{131, 118, 226, 22} ,{131, 118, 228, 2} ,{131, 118, 54, 0} ,{131, 118, 47, 0} ,{131, 118, 55, 0} ,{131, 118, 64, 0} ,{131, 118, 60, 0} ,{131, 118, 52, 0} ,{138, 166, 140, 3} ,{159, 118, 51, 0} ,{159, 118, 230, 33} ,{159, 118, 216, 37} ,{159, 118, 58, 0} ,{159, 118, 212, 0} ,{159, 118, 89, 7} ,{159, 118, 48, 0} ,{159, 118, 56, 0} ,{159, 118, 217, 37} ,{159, 118, 151, 17} ,{159, 118, 218, 37} ,{159, 118, 219, 37} ,{159, 118, 220, 37} ,{159, 118, 221, 37} ,{159, 118, 182, 7} ,{159, 118, 57, 0} ,{159, 118, 46, 0} ,{159, 118, 222, 37} ,{159, 118, 63, 0} ,{159, 118, 226, 22} ,{159, 118, 228, 2} ,{159, 118, 54, 0} ,{159, 118, 47, 0} ,{159, 118, 55, 0} ,{159, 118, 64, 0} ,{159, 118, 60, 0} ,{159, 118, 52, 0} ,{138, 166, 228, 5} ,{187, 118, 51, 0} ,{187, 118, 230, 33} ,{187, 118, 216, 37} ,{187, 118, 58, 0} ,{187, 118, 212, 0} ,{187, 118, 89, 7} ,{187, 118, 48, 0} ,{187, 118, 56, 0} ,{187, 118, 217, 37} ,{187, 118, 151, 17} ,{187, 118, 218, 37} ,{187, 118, 219, 37} ,{187, 118, 220, 37} ,{187, 118, 221, 37} ,{187, 118, 182, 7} ,{187, 118, 57, 0} ,{187, 118, 46, 0} ,{187, 118, 222, 37} ,{187, 118, 63, 0} ,{187, 118, 226, 22} ,{187, 118, 228, 2} ,{187, 118, 54, 0} ,{187, 118, 47, 0} ,{187, 118, 55, 0} ,{187, 118, 64, 0} ,{187, 118, 60, 0} ,{187, 118, 52, 0} ,{138, 166, 164, 0} ,{215, 118, 51, 0} ,{215, 118, 230, 33} ,{215, 118, 216, 37} ,{215, 118, 58, 0} ,{215, 118, 212, 0} ,{215, 118, 89, 7} ,{215, 118, 48, 0} ,{215, 118, 56, 0} ,{215, 118, 217, 37} ,{215, 118, 151, 17} ,{215, 118, 218, 37} ,{215, 118, 219, 37} ,{215, 118, 220, 37} ,{215, 118, 221, 37} ,{215, 118, 182, 7} ,{215, 118, 57, 0} ,{215, 118, 46, 0} ,{215, 118, 222, 37} ,{215, 118, 63, 0} ,{215, 118, 226, 22} ,{215, 118, 228, 2} ,{215, 118, 54, 0} ,{215, 118, 47, 0} ,{215, 118, 55, 0} ,{215, 118, 64, 0} ,{215, 118, 60, 0} ,{215, 118, 52, 0} ,{138, 166, 204, 4} ,{243, 118, 51, 0} ,{243, 118, 230, 33} ,{243, 118, 216, 37} ,{243, 118, 58, 0} ,{243, 118, 212, 0} ,{243, 118, 89, 7} ,{243, 118, 48, 0} ,{243, 118, 56, 0} ,{243, 118, 217, 37} ,{243, 118, 151, 17} ,{243, 118, 218, 37} ,{243, 118, 219, 37} ,{243, 118, 220, 37} ,{243, 118, 221, 37} ,{243, 118, 182, 7} ,{243, 118, 57, 0} ,{243, 118, 46, 0} ,{243, 118, 222, 37} ,{243, 118, 63, 0} ,{243, 118, 226, 22} ,{243, 118, 228, 2} ,{243, 118, 54, 0} ,{243, 118, 47, 0} ,{243, 118, 55, 0} ,{243, 118, 64, 0} ,{243, 118, 60, 0} ,{243, 118, 52, 0} ,{138, 166, 65, 0} ,{15, 119, 51, 0} ,{15, 119, 230, 33} ,{15, 119, 216, 37} ,{15, 119, 58, 0} ,{15, 119, 212, 0} ,{15, 119, 89, 7} ,{15, 119, 48, 0} ,{15, 119, 56, 0} ,{15, 119, 217, 37} ,{15, 119, 151, 17} ,{15, 119, 218, 37} ,{15, 119, 219, 37} ,{15, 119, 220, 37} ,{15, 119, 221, 37} ,{15, 119, 182, 7} ,{15, 119, 57, 0} ,{15, 119, 46, 0} ,{15, 119, 222, 37} ,{15, 119, 63, 0} ,{15, 119, 226, 22} ,{15, 119, 228, 2} ,{15, 119, 54, 0} ,{15, 119, 47, 0} ,{15, 119, 55, 0} ,{15, 119, 64, 0} ,{15, 119, 60, 0} ,{15, 119, 52, 0} ,{138, 166, 229, 5} ,{43, 119, 51, 0} ,{43, 119, 230, 33} ,{43, 119, 216, 37} ,{43, 119, 58, 0} ,{43, 119, 212, 0} ,{43, 119, 89, 7} ,{43, 119, 48, 0} ,{43, 119, 56, 0} ,{43, 119, 217, 37} ,{43, 119, 151, 17} ,{43, 119, 218, 37} ,{43, 119, 219, 37} ,{43, 119, 220, 37} ,{43, 119, 221, 37} ,{43, 119, 182, 7} ,{43, 119, 57, 0} ,{43, 119, 46, 0} ,{43, 119, 222, 37} ,{43, 119, 63, 0} ,{43, 119, 226, 22} ,{43, 119, 228, 2} ,{43, 119, 54, 0} ,{43, 119, 47, 0} ,{43, 119, 55, 0} ,{43, 119, 64, 0} ,{43, 119, 60, 0} ,{43, 119, 52, 0} ,{138, 166, 226, 1} ,{71, 119, 51, 0} ,{71, 119, 230, 33} ,{71, 119, 216, 37} ,{71, 119, 58, 0} ,{71, 119, 212, 0} ,{71, 119, 89, 7} ,{71, 119, 48, 0} ,{71, 119, 56, 0} ,{71, 119, 217, 37} ,{71, 119, 151, 17} ,{71, 119, 218, 37} ,{71, 119, 219, 37} ,{71, 119, 220, 37} ,{71, 119, 221, 37} ,{71, 119, 182, 7} ,{71, 119, 57, 0} ,{71, 119, 46, 0} ,{71, 119, 222, 37} ,{71, 119, 63, 0} ,{71, 119, 226, 22} ,{71, 119, 228, 2} ,{71, 119, 54, 0} ,{71, 119, 47, 0} ,{71, 119, 55, 0} ,{71, 119, 64, 0} ,{71, 119, 60, 0} ,{71, 119, 52, 0} ,{138, 166, 230, 5} ,{99, 119, 51, 0} ,{99, 119, 230, 33} ,{99, 119, 216, 37} ,{99, 119, 58, 0} ,{99, 119, 212, 0} ,{99, 119, 89, 7} ,{99, 119, 48, 0} ,{99, 119, 56, 0} ,{99, 119, 217, 37} ,{99, 119, 151, 17} ,{99, 119, 218, 37} ,{99, 119, 219, 37} ,{99, 119, 220, 37} ,{99, 119, 221, 37} ,{99, 119, 182, 7} ,{99, 119, 57, 0} ,{99, 119, 46, 0} ,{99, 119, 222, 37} ,{99, 119, 63, 0} ,{99, 119, 226, 22} ,{99, 119, 228, 2} ,{99, 119, 54, 0} ,{99, 119, 47, 0} ,{99, 119, 55, 0} ,{99, 119, 64, 0} ,{99, 119, 60, 0} ,{99, 119, 52, 0} ,{138, 166, 170, 1} ,{127, 119, 51, 0} ,{127, 119, 230, 33} ,{127, 119, 216, 37} ,{127, 119, 58, 0} ,{127, 119, 212, 0} ,{127, 119, 89, 7} ,{127, 119, 48, 0} ,{127, 119, 56, 0} ,{127, 119, 217, 37} ,{127, 119, 151, 17} ,{127, 119, 218, 37} ,{127, 119, 219, 37} ,{127, 119, 220, 37} ,{127, 119, 221, 37} ,{127, 119, 182, 7} ,{127, 119, 57, 0} ,{127, 119, 46, 0} ,{127, 119, 222, 37} ,{127, 119, 63, 0} ,{127, 119, 226, 22} ,{127, 119, 228, 2} ,{127, 119, 54, 0} ,{127, 119, 47, 0} ,{127, 119, 55, 0} ,{127, 119, 64, 0} ,{127, 119, 60, 0} ,{127, 119, 52, 0} ,{138, 166, 110, 5} ,{155, 119, 51, 0} ,{155, 119, 230, 33} ,{155, 119, 216, 37} ,{155, 119, 58, 0} ,{155, 119, 212, 0} ,{155, 119, 89, 7} ,{155, 119, 48, 0} ,{155, 119, 56, 0} ,{155, 119, 217, 37} ,{155, 119, 151, 17} ,{155, 119, 218, 37} ,{155, 119, 219, 37} ,{155, 119, 220, 37} ,{155, 119, 221, 37} ,{155, 119, 182, 7} ,{155, 119, 57, 0} ,{155, 119, 46, 0} ,{155, 119, 222, 37} ,{155, 119, 63, 0} ,{155, 119, 226, 22} ,{155, 119, 228, 2} ,{155, 119, 54, 0} ,{155, 119, 47, 0} ,{155, 119, 55, 0} ,{155, 119, 64, 0} ,{155, 119, 60, 0} ,{155, 119, 52, 0} ,{138, 166, 141, 1} ,{183, 119, 51, 0} ,{183, 119, 230, 33} ,{183, 119, 216, 37} ,{183, 119, 58, 0} ,{183, 119, 212, 0} ,{183, 119, 89, 7} ,{183, 119, 48, 0} ,{183, 119, 56, 0} ,{183, 119, 217, 37} ,{183, 119, 151, 17} ,{183, 119, 218, 37} ,{183, 119, 219, 37} ,{183, 119, 220, 37} ,{183, 119, 221, 37} ,{183, 119, 182, 7} ,{183, 119, 57, 0} ,{183, 119, 46, 0} ,{183, 119, 222, 37} ,{183, 119, 63, 0} ,{183, 119, 226, 22} ,{183, 119, 228, 2} ,{183, 119, 54, 0} ,{183, 119, 47, 0} ,{183, 119, 55, 0} ,{183, 119, 64, 0} ,{183, 119, 60, 0} ,{183, 119, 52, 0} ,{138, 166, 53, 0} ,{211, 119, 51, 0} ,{211, 119, 230, 33} ,{211, 119, 216, 37} ,{211, 119, 58, 0} ,{211, 119, 212, 0} ,{211, 119, 89, 7} ,{211, 119, 48, 0} ,{211, 119, 56, 0} ,{211, 119, 217, 37} ,{211, 119, 151, 17} ,{211, 119, 218, 37} ,{211, 119, 219, 37} ,{211, 119, 220, 37} ,{211, 119, 221, 37} ,{211, 119, 182, 7} ,{211, 119, 57, 0} ,{211, 119, 46, 0} ,{211, 119, 222, 37} ,{211, 119, 63, 0} ,{211, 119, 226, 22} ,{211, 119, 228, 2} ,{211, 119, 54, 0} ,{211, 119, 47, 0} ,{211, 119, 55, 0} ,{211, 119, 64, 0} ,{211, 119, 60, 0} ,{211, 119, 52, 0} ,{139, 166, 45, 0} ,{239, 119, 51, 0} ,{239, 119, 230, 33} ,{239, 119, 216, 37} ,{239, 119, 58, 0} ,{239, 119, 212, 0} ,{239, 119, 89, 7} ,{239, 119, 48, 0} ,{239, 119, 56, 0} ,{239, 119, 217, 37} ,{239, 119, 151, 17} ,{239, 119, 218, 37} ,{239, 119, 219, 37} ,{239, 119, 220, 37} ,{239, 119, 221, 37} ,{239, 119, 182, 7} ,{239, 119, 57, 0} ,{239, 119, 46, 0} ,{239, 119, 222, 37} ,{239, 119, 63, 0} ,{239, 119, 226, 22} ,{239, 119, 228, 2} ,{239, 119, 54, 0} ,{239, 119, 47, 0} ,{239, 119, 55, 0} ,{239, 119, 64, 0} ,{239, 119, 60, 0} ,{239, 119, 52, 0} ,{139, 166, 133, 0} ,{11, 120, 51, 0} ,{11, 120, 230, 33} ,{11, 120, 216, 37} ,{11, 120, 58, 0} ,{11, 120, 212, 0} ,{11, 120, 89, 7} ,{11, 120, 48, 0} ,{11, 120, 56, 0} ,{11, 120, 217, 37} ,{11, 120, 151, 17} ,{11, 120, 218, 37} ,{11, 120, 219, 37} ,{11, 120, 220, 37} ,{11, 120, 221, 37} ,{11, 120, 182, 7} ,{11, 120, 57, 0} ,{11, 120, 46, 0} ,{11, 120, 222, 37} ,{11, 120, 63, 0} ,{11, 120, 226, 22} ,{11, 120, 228, 2} ,{11, 120, 54, 0} ,{11, 120, 47, 0} ,{11, 120, 55, 0} ,{11, 120, 64, 0} ,{11, 120, 60, 0} ,{11, 120, 52, 0} ,{139, 166, 171, 1} ,{39, 120, 51, 0} ,{39, 120, 230, 33} ,{39, 120, 216, 37} ,{39, 120, 58, 0} ,{39, 120, 212, 0} ,{39, 120, 89, 7} ,{39, 120, 48, 0} ,{39, 120, 56, 0} ,{39, 120, 217, 37} ,{39, 120, 151, 17} ,{39, 120, 218, 37} ,{39, 120, 219, 37} ,{39, 120, 220, 37} ,{39, 120, 221, 37} ,{39, 120, 182, 7} ,{39, 120, 57, 0} ,{39, 120, 46, 0} ,{39, 120, 222, 37} ,{39, 120, 63, 0} ,{39, 120, 226, 22} ,{39, 120, 228, 2} ,{39, 120, 54, 0} ,{39, 120, 47, 0} ,{39, 120, 55, 0} ,{39, 120, 64, 0} ,{39, 120, 60, 0} ,{39, 120, 52, 0} ,{139, 166, 224, 1} ,{67, 120, 51, 0} ,{67, 120, 230, 33} ,{67, 120, 216, 37} ,{67, 120, 58, 0} ,{67, 120, 212, 0} ,{67, 120, 89, 7} ,{67, 120, 48, 0} ,{67, 120, 56, 0} ,{67, 120, 217, 37} ,{67, 120, 151, 17} ,{67, 120, 218, 37} ,{67, 120, 219, 37} ,{67, 120, 220, 37} ,{67, 120, 221, 37} ,{67, 120, 182, 7} ,{67, 120, 57, 0} ,{67, 120, 46, 0} ,{67, 120, 222, 37} ,{67, 120, 63, 0} ,{67, 120, 226, 22} ,{67, 120, 228, 2} ,{67, 120, 54, 0} ,{67, 120, 47, 0} ,{67, 120, 55, 0} ,{67, 120, 64, 0} ,{67, 120, 60, 0} ,{67, 120, 52, 0} ,{139, 166, 225, 5} ,{95, 120, 51, 0} ,{95, 120, 230, 33} ,{95, 120, 216, 37} ,{95, 120, 58, 0} ,{95, 120, 212, 0} ,{95, 120, 89, 7} ,{95, 120, 48, 0} ,{95, 120, 56, 0} ,{95, 120, 217, 37} ,{95, 120, 151, 17} ,{95, 120, 218, 37} ,{95, 120, 219, 37} ,{95, 120, 220, 37} ,{95, 120, 221, 37} ,{95, 120, 182, 7} ,{95, 120, 57, 0} ,{95, 120, 46, 0} ,{95, 120, 222, 37} ,{95, 120, 63, 0} ,{95, 120, 226, 22} ,{95, 120, 228, 2} ,{95, 120, 54, 0} ,{95, 120, 47, 0} ,{95, 120, 55, 0} ,{95, 120, 64, 0} ,{95, 120, 60, 0} ,{95, 120, 52, 0} ,{139, 166, 49, 0} ,{123, 120, 51, 0} ,{123, 120, 230, 33} ,{123, 120, 216, 37} ,{123, 120, 58, 0} ,{123, 120, 212, 0} ,{123, 120, 89, 7} ,{123, 120, 48, 0} ,{123, 120, 56, 0} ,{123, 120, 217, 37} ,{123, 120, 151, 17} ,{123, 120, 218, 37} ,{123, 120, 219, 37} ,{123, 120, 220, 37} ,{123, 120, 221, 37} ,{123, 120, 182, 7} ,{123, 120, 57, 0} ,{123, 120, 46, 0} ,{123, 120, 222, 37} ,{123, 120, 63, 0} ,{123, 120, 226, 22} ,{123, 120, 228, 2} ,{123, 120, 54, 0} ,{123, 120, 47, 0} ,{123, 120, 55, 0} ,{123, 120, 64, 0} ,{123, 120, 60, 0} ,{123, 120, 52, 0} ,{139, 166, 226, 5} ,{151, 120, 51, 0} ,{151, 120, 230, 33} ,{151, 120, 216, 37} ,{151, 120, 58, 0} ,{151, 120, 212, 0} ,{151, 120, 89, 7} ,{151, 120, 48, 0} ,{151, 120, 56, 0} ,{151, 120, 217, 37} ,{151, 120, 151, 17} ,{151, 120, 218, 37} ,{151, 120, 219, 37} ,{151, 120, 220, 37} ,{151, 120, 221, 37} ,{151, 120, 182, 7} ,{151, 120, 57, 0} ,{151, 120, 46, 0} ,{151, 120, 222, 37} ,{151, 120, 63, 0} ,{151, 120, 226, 22} ,{151, 120, 228, 2} ,{151, 120, 54, 0} ,{151, 120, 47, 0} ,{151, 120, 55, 0} ,{151, 120, 64, 0} ,{151, 120, 60, 0} ,{151, 120, 52, 0} ,{139, 166, 227, 5} ,{179, 120, 51, 0} ,{179, 120, 230, 33} ,{179, 120, 216, 37} ,{179, 120, 58, 0} ,{179, 120, 212, 0} ,{179, 120, 89, 7} ,{179, 120, 48, 0} ,{179, 120, 56, 0} ,{179, 120, 217, 37} ,{179, 120, 151, 17} ,{179, 120, 218, 37} ,{179, 120, 219, 37} ,{179, 120, 220, 37} ,{179, 120, 221, 37} ,{179, 120, 182, 7} ,{179, 120, 57, 0} ,{179, 120, 46, 0} ,{179, 120, 222, 37} ,{179, 120, 63, 0} ,{179, 120, 226, 22} ,{179, 120, 228, 2} ,{179, 120, 54, 0} ,{179, 120, 47, 0} ,{179, 120, 55, 0} ,{179, 120, 64, 0} ,{179, 120, 60, 0} ,{179, 120, 52, 0} ,{139, 166, 59, 0} ,{207, 120, 51, 0} ,{207, 120, 230, 33} ,{207, 120, 216, 37} ,{207, 120, 58, 0} ,{207, 120, 212, 0} ,{207, 120, 89, 7} ,{207, 120, 48, 0} ,{207, 120, 56, 0} ,{207, 120, 217, 37} ,{207, 120, 151, 17} ,{207, 120, 218, 37} ,{207, 120, 219, 37} ,{207, 120, 220, 37} ,{207, 120, 221, 37} ,{207, 120, 182, 7} ,{207, 120, 57, 0} ,{207, 120, 46, 0} ,{207, 120, 222, 37} ,{207, 120, 63, 0} ,{207, 120, 226, 22} ,{207, 120, 228, 2} ,{207, 120, 54, 0} ,{207, 120, 47, 0} ,{207, 120, 55, 0} ,{207, 120, 64, 0} ,{207, 120, 60, 0} ,{207, 120, 52, 0} ,{139, 166, 140, 3} ,{235, 120, 51, 0} ,{235, 120, 230, 33} ,{235, 120, 216, 37} ,{235, 120, 58, 0} ,{235, 120, 212, 0} ,{235, 120, 89, 7} ,{235, 120, 48, 0} ,{235, 120, 56, 0} ,{235, 120, 217, 37} ,{235, 120, 151, 17} ,{235, 120, 218, 37} ,{235, 120, 219, 37} ,{235, 120, 220, 37} ,{235, 120, 221, 37} ,{235, 120, 182, 7} ,{235, 120, 57, 0} ,{235, 120, 46, 0} ,{235, 120, 222, 37} ,{235, 120, 63, 0} ,{235, 120, 226, 22} ,{235, 120, 228, 2} ,{235, 120, 54, 0} ,{235, 120, 47, 0} ,{235, 120, 55, 0} ,{235, 120, 64, 0} ,{235, 120, 60, 0} ,{235, 120, 52, 0} ,{139, 166, 228, 5} ,{7, 121, 51, 0} ,{7, 121, 230, 33} ,{7, 121, 216, 37} ,{7, 121, 58, 0} ,{7, 121, 212, 0} ,{7, 121, 89, 7} ,{7, 121, 48, 0} ,{7, 121, 56, 0} ,{7, 121, 217, 37} ,{7, 121, 151, 17} ,{7, 121, 218, 37} ,{7, 121, 219, 37} ,{7, 121, 220, 37} ,{7, 121, 221, 37} ,{7, 121, 182, 7} ,{7, 121, 57, 0} ,{7, 121, 46, 0} ,{7, 121, 222, 37} ,{7, 121, 63, 0} ,{7, 121, 226, 22} ,{7, 121, 228, 2} ,{7, 121, 54, 0} ,{7, 121, 47, 0} ,{7, 121, 55, 0} ,{7, 121, 64, 0} ,{7, 121, 60, 0} ,{7, 121, 52, 0} ,{139, 166, 164, 0} ,{35, 121, 51, 0} ,{35, 121, 230, 33} ,{35, 121, 216, 37} ,{35, 121, 58, 0} ,{35, 121, 212, 0} ,{35, 121, 89, 7} ,{35, 121, 48, 0} ,{35, 121, 56, 0} ,{35, 121, 217, 37} ,{35, 121, 151, 17} ,{35, 121, 218, 37} ,{35, 121, 219, 37} ,{35, 121, 220, 37} ,{35, 121, 221, 37} ,{35, 121, 182, 7} ,{35, 121, 57, 0} ,{35, 121, 46, 0} ,{35, 121, 222, 37} ,{35, 121, 63, 0} ,{35, 121, 226, 22} ,{35, 121, 228, 2} ,{35, 121, 54, 0} ,{35, 121, 47, 0} ,{35, 121, 55, 0} ,{35, 121, 64, 0} ,{35, 121, 60, 0} ,{35, 121, 52, 0} ,{139, 166, 204, 4} ,{63, 121, 51, 0} ,{63, 121, 230, 33} ,{63, 121, 216, 37} ,{63, 121, 58, 0} ,{63, 121, 212, 0} ,{63, 121, 89, 7} ,{63, 121, 48, 0} ,{63, 121, 56, 0} ,{63, 121, 217, 37} ,{63, 121, 151, 17} ,{63, 121, 218, 37} ,{63, 121, 219, 37} ,{63, 121, 220, 37} ,{63, 121, 221, 37} ,{63, 121, 182, 7} ,{63, 121, 57, 0} ,{63, 121, 46, 0} ,{63, 121, 222, 37} ,{63, 121, 63, 0} ,{63, 121, 226, 22} ,{63, 121, 228, 2} ,{63, 121, 54, 0} ,{63, 121, 47, 0} ,{63, 121, 55, 0} ,{63, 121, 64, 0} ,{63, 121, 60, 0} ,{63, 121, 52, 0} ,{139, 166, 65, 0} ,{91, 121, 51, 0} ,{91, 121, 230, 33} ,{91, 121, 216, 37} ,{91, 121, 58, 0} ,{91, 121, 212, 0} ,{91, 121, 89, 7} ,{91, 121, 48, 0} ,{91, 121, 56, 0} ,{91, 121, 217, 37} ,{91, 121, 151, 17} ,{91, 121, 218, 37} ,{91, 121, 219, 37} ,{91, 121, 220, 37} ,{91, 121, 221, 37} ,{91, 121, 182, 7} ,{91, 121, 57, 0} ,{91, 121, 46, 0} ,{91, 121, 222, 37} ,{91, 121, 63, 0} ,{91, 121, 226, 22} ,{91, 121, 228, 2} ,{91, 121, 54, 0} ,{91, 121, 47, 0} ,{91, 121, 55, 0} ,{91, 121, 64, 0} ,{91, 121, 60, 0} ,{91, 121, 52, 0} ,{139, 166, 229, 5} ,{119, 121, 51, 0} ,{119, 121, 230, 33} ,{119, 121, 216, 37} ,{119, 121, 58, 0} ,{119, 121, 212, 0} ,{119, 121, 89, 7} ,{119, 121, 48, 0} ,{119, 121, 56, 0} ,{119, 121, 217, 37} ,{119, 121, 151, 17} ,{119, 121, 218, 37} ,{119, 121, 219, 37} ,{119, 121, 220, 37} ,{119, 121, 221, 37} ,{119, 121, 182, 7} ,{119, 121, 57, 0} ,{119, 121, 46, 0} ,{119, 121, 222, 37} ,{119, 121, 63, 0} ,{119, 121, 226, 22} ,{119, 121, 228, 2} ,{119, 121, 54, 0} ,{119, 121, 47, 0} ,{119, 121, 55, 0} ,{119, 121, 64, 0} ,{119, 121, 60, 0} ,{119, 121, 52, 0} ,{139, 166, 226, 1} ,{147, 121, 51, 0} ,{147, 121, 230, 33} ,{147, 121, 216, 37} ,{147, 121, 58, 0} ,{147, 121, 212, 0} ,{147, 121, 89, 7} ,{147, 121, 48, 0} ,{147, 121, 56, 0} ,{147, 121, 217, 37} ,{147, 121, 151, 17} ,{147, 121, 218, 37} ,{147, 121, 219, 37} ,{147, 121, 220, 37} ,{147, 121, 221, 37} ,{147, 121, 182, 7} ,{147, 121, 57, 0} ,{147, 121, 46, 0} ,{147, 121, 222, 37} ,{147, 121, 63, 0} ,{147, 121, 226, 22} ,{147, 121, 228, 2} ,{147, 121, 54, 0} ,{147, 121, 47, 0} ,{147, 121, 55, 0} ,{147, 121, 64, 0} ,{147, 121, 60, 0} ,{147, 121, 52, 0} ,{139, 166, 230, 5} ,{175, 121, 51, 0} ,{175, 121, 230, 33} ,{175, 121, 216, 37} ,{175, 121, 58, 0} ,{175, 121, 212, 0} ,{175, 121, 89, 7} ,{175, 121, 48, 0} ,{175, 121, 56, 0} ,{175, 121, 217, 37} ,{175, 121, 151, 17} ,{175, 121, 218, 37} ,{175, 121, 219, 37} ,{175, 121, 220, 37} ,{175, 121, 221, 37} ,{175, 121, 182, 7} ,{175, 121, 57, 0} ,{175, 121, 46, 0} ,{175, 121, 222, 37} ,{175, 121, 63, 0} ,{175, 121, 226, 22} ,{175, 121, 228, 2} ,{175, 121, 54, 0} ,{175, 121, 47, 0} ,{175, 121, 55, 0} ,{175, 121, 64, 0} ,{175, 121, 60, 0} ,{175, 121, 52, 0} ,{139, 166, 170, 1} ,{203, 121, 51, 0} ,{203, 121, 230, 33} ,{203, 121, 216, 37} ,{203, 121, 58, 0} ,{203, 121, 212, 0} ,{203, 121, 89, 7} ,{203, 121, 48, 0} ,{203, 121, 56, 0} ,{203, 121, 217, 37} ,{203, 121, 151, 17} ,{203, 121, 218, 37} ,{203, 121, 219, 37} ,{203, 121, 220, 37} ,{203, 121, 221, 37} ,{203, 121, 182, 7} ,{203, 121, 57, 0} ,{203, 121, 46, 0} ,{203, 121, 222, 37} ,{203, 121, 63, 0} ,{203, 121, 226, 22} ,{203, 121, 228, 2} ,{203, 121, 54, 0} ,{203, 121, 47, 0} ,{203, 121, 55, 0} ,{203, 121, 64, 0} ,{203, 121, 60, 0} ,{203, 121, 52, 0} ,{139, 166, 110, 5} ,{231, 121, 51, 0} ,{231, 121, 230, 33} ,{231, 121, 216, 37} ,{231, 121, 58, 0} ,{231, 121, 212, 0} ,{231, 121, 89, 7} ,{231, 121, 48, 0} ,{231, 121, 56, 0} ,{231, 121, 217, 37} ,{231, 121, 151, 17} ,{231, 121, 218, 37} ,{231, 121, 219, 37} ,{231, 121, 220, 37} ,{231, 121, 221, 37} ,{231, 121, 182, 7} ,{231, 121, 57, 0} ,{231, 121, 46, 0} ,{231, 121, 222, 37} ,{231, 121, 63, 0} ,{231, 121, 226, 22} ,{231, 121, 228, 2} ,{231, 121, 54, 0} ,{231, 121, 47, 0} ,{231, 121, 55, 0} ,{231, 121, 64, 0} ,{231, 121, 60, 0} ,{231, 121, 52, 0} ,{139, 166, 141, 1} ,{3, 122, 51, 0} ,{3, 122, 230, 33} ,{3, 122, 216, 37} ,{3, 122, 58, 0} ,{3, 122, 212, 0} ,{3, 122, 89, 7} ,{3, 122, 48, 0} ,{3, 122, 56, 0} ,{3, 122, 217, 37} ,{3, 122, 151, 17} ,{3, 122, 218, 37} ,{3, 122, 219, 37} ,{3, 122, 220, 37} ,{3, 122, 221, 37} ,{3, 122, 182, 7} ,{3, 122, 57, 0} ,{3, 122, 46, 0} ,{3, 122, 222, 37} ,{3, 122, 63, 0} ,{3, 122, 226, 22} ,{3, 122, 228, 2} ,{3, 122, 54, 0} ,{3, 122, 47, 0} ,{3, 122, 55, 0} ,{3, 122, 64, 0} ,{3, 122, 60, 0} ,{3, 122, 52, 0} ,{139, 166, 53, 0} ,{31, 122, 51, 0} ,{31, 122, 230, 33} ,{31, 122, 216, 37} ,{31, 122, 58, 0} ,{31, 122, 212, 0} ,{31, 122, 89, 7} ,{31, 122, 48, 0} ,{31, 122, 56, 0} ,{31, 122, 217, 37} ,{31, 122, 151, 17} ,{31, 122, 218, 37} ,{31, 122, 219, 37} ,{31, 122, 220, 37} ,{31, 122, 221, 37} ,{31, 122, 182, 7} ,{31, 122, 57, 0} ,{31, 122, 46, 0} ,{31, 122, 222, 37} ,{31, 122, 63, 0} ,{31, 122, 226, 22} ,{31, 122, 228, 2} ,{31, 122, 54, 0} ,{31, 122, 47, 0} ,{31, 122, 55, 0} ,{31, 122, 64, 0} ,{31, 122, 60, 0} ,{31, 122, 52, 0} ,{140, 166, 45, 0} ,{59, 122, 51, 0} ,{59, 122, 230, 33} ,{59, 122, 216, 37} ,{59, 122, 58, 0} ,{59, 122, 212, 0} ,{59, 122, 89, 7} ,{59, 122, 48, 0} ,{59, 122, 56, 0} ,{59, 122, 217, 37} ,{59, 122, 151, 17} ,{59, 122, 218, 37} ,{59, 122, 219, 37} ,{59, 122, 220, 37} ,{59, 122, 221, 37} ,{59, 122, 182, 7} ,{59, 122, 57, 0} ,{59, 122, 46, 0} ,{59, 122, 222, 37} ,{59, 122, 63, 0} ,{59, 122, 226, 22} ,{59, 122, 228, 2} ,{59, 122, 54, 0} ,{59, 122, 47, 0} ,{59, 122, 55, 0} ,{59, 122, 64, 0} ,{59, 122, 60, 0} ,{59, 122, 52, 0} ,{140, 166, 133, 0} ,{87, 122, 51, 0} ,{87, 122, 230, 33} ,{87, 122, 216, 37} ,{87, 122, 58, 0} ,{87, 122, 212, 0} ,{87, 122, 89, 7} ,{87, 122, 48, 0} ,{87, 122, 56, 0} ,{87, 122, 217, 37} ,{87, 122, 151, 17} ,{87, 122, 218, 37} ,{87, 122, 219, 37} ,{87, 122, 220, 37} ,{87, 122, 221, 37} ,{87, 122, 182, 7} ,{87, 122, 57, 0} ,{87, 122, 46, 0} ,{87, 122, 222, 37} ,{87, 122, 63, 0} ,{87, 122, 226, 22} ,{87, 122, 228, 2} ,{87, 122, 54, 0} ,{87, 122, 47, 0} ,{87, 122, 55, 0} ,{87, 122, 64, 0} ,{87, 122, 60, 0} ,{87, 122, 52, 0} ,{140, 166, 171, 1} ,{115, 122, 51, 0} ,{115, 122, 230, 33} ,{115, 122, 216, 37} ,{115, 122, 58, 0} ,{115, 122, 212, 0} ,{115, 122, 89, 7} ,{115, 122, 48, 0} ,{115, 122, 56, 0} ,{115, 122, 217, 37} ,{115, 122, 151, 17} ,{115, 122, 218, 37} ,{115, 122, 219, 37} ,{115, 122, 220, 37} ,{115, 122, 221, 37} ,{115, 122, 182, 7} ,{115, 122, 57, 0} ,{115, 122, 46, 0} ,{115, 122, 222, 37} ,{115, 122, 63, 0} ,{115, 122, 226, 22} ,{115, 122, 228, 2} ,{115, 122, 54, 0} ,{115, 122, 47, 0} ,{115, 122, 55, 0} ,{115, 122, 64, 0} ,{115, 122, 60, 0} ,{115, 122, 52, 0} ,{140, 166, 224, 1} ,{143, 122, 51, 0} ,{143, 122, 230, 33} ,{143, 122, 216, 37} ,{143, 122, 58, 0} ,{143, 122, 212, 0} ,{143, 122, 89, 7} ,{143, 122, 48, 0} ,{143, 122, 56, 0} ,{143, 122, 217, 37} ,{143, 122, 151, 17} ,{143, 122, 218, 37} ,{143, 122, 219, 37} ,{143, 122, 220, 37} ,{143, 122, 221, 37} ,{143, 122, 182, 7} ,{143, 122, 57, 0} ,{143, 122, 46, 0} ,{143, 122, 222, 37} ,{143, 122, 63, 0} ,{143, 122, 226, 22} ,{143, 122, 228, 2} ,{143, 122, 54, 0} ,{143, 122, 47, 0} ,{143, 122, 55, 0} ,{143, 122, 64, 0} ,{143, 122, 60, 0} ,{143, 122, 52, 0} ,{140, 166, 225, 5} ,{171, 122, 51, 0} ,{171, 122, 230, 33} ,{171, 122, 216, 37} ,{171, 122, 58, 0} ,{171, 122, 212, 0} ,{171, 122, 89, 7} ,{171, 122, 48, 0} ,{171, 122, 56, 0} ,{171, 122, 217, 37} ,{171, 122, 151, 17} ,{171, 122, 218, 37} ,{171, 122, 219, 37} ,{171, 122, 220, 37} ,{171, 122, 221, 37} ,{171, 122, 182, 7} ,{171, 122, 57, 0} ,{171, 122, 46, 0} ,{171, 122, 222, 37} ,{171, 122, 63, 0} ,{171, 122, 226, 22} ,{171, 122, 228, 2} ,{171, 122, 54, 0} ,{171, 122, 47, 0} ,{171, 122, 55, 0} ,{171, 122, 64, 0} ,{171, 122, 60, 0} ,{171, 122, 52, 0} ,{140, 166, 49, 0} ,{199, 122, 51, 0} ,{199, 122, 230, 33} ,{199, 122, 216, 37} ,{199, 122, 58, 0} ,{199, 122, 212, 0} ,{199, 122, 89, 7} ,{199, 122, 48, 0} ,{199, 122, 56, 0} ,{199, 122, 217, 37} ,{199, 122, 151, 17} ,{199, 122, 218, 37} ,{199, 122, 219, 37} ,{199, 122, 220, 37} ,{199, 122, 221, 37} ,{199, 122, 182, 7} ,{199, 122, 57, 0} ,{199, 122, 46, 0} ,{199, 122, 222, 37} ,{199, 122, 63, 0} ,{199, 122, 226, 22} ,{199, 122, 228, 2} ,{199, 122, 54, 0} ,{199, 122, 47, 0} ,{199, 122, 55, 0} ,{199, 122, 64, 0} ,{199, 122, 60, 0} ,{199, 122, 52, 0} ,{140, 166, 226, 5} ,{227, 122, 51, 0} ,{227, 122, 230, 33} ,{227, 122, 216, 37} ,{227, 122, 58, 0} ,{227, 122, 212, 0} ,{227, 122, 89, 7} ,{227, 122, 48, 0} ,{227, 122, 56, 0} ,{227, 122, 217, 37} ,{227, 122, 151, 17} ,{227, 122, 218, 37} ,{227, 122, 219, 37} ,{227, 122, 220, 37} ,{227, 122, 221, 37} ,{227, 122, 182, 7} ,{227, 122, 57, 0} ,{227, 122, 46, 0} ,{227, 122, 222, 37} ,{227, 122, 63, 0} ,{227, 122, 226, 22} ,{227, 122, 228, 2} ,{227, 122, 54, 0} ,{227, 122, 47, 0} ,{227, 122, 55, 0} ,{227, 122, 64, 0} ,{227, 122, 60, 0} ,{227, 122, 52, 0} ,{140, 166, 227, 5} ,{255, 122, 51, 0} ,{255, 122, 230, 33} ,{255, 122, 216, 37} ,{255, 122, 58, 0} ,{255, 122, 212, 0} ,{255, 122, 89, 7} ,{255, 122, 48, 0} ,{255, 122, 56, 0} ,{255, 122, 217, 37} ,{255, 122, 151, 17} ,{255, 122, 218, 37} ,{255, 122, 219, 37} ,{255, 122, 220, 37} ,{255, 122, 221, 37} ,{255, 122, 182, 7} ,{255, 122, 57, 0} ,{255, 122, 46, 0} ,{255, 122, 222, 37} ,{255, 122, 63, 0} ,{255, 122, 226, 22} ,{255, 122, 228, 2} ,{255, 122, 54, 0} ,{255, 122, 47, 0} ,{255, 122, 55, 0} ,{255, 122, 64, 0} ,{255, 122, 60, 0} ,{255, 122, 52, 0} ,{140, 166, 59, 0} ,{27, 123, 51, 0} ,{27, 123, 230, 33} ,{27, 123, 216, 37} ,{27, 123, 58, 0} ,{27, 123, 212, 0} ,{27, 123, 89, 7} ,{27, 123, 48, 0} ,{27, 123, 56, 0} ,{27, 123, 217, 37} ,{27, 123, 151, 17} ,{27, 123, 218, 37} ,{27, 123, 219, 37} ,{27, 123, 220, 37} ,{27, 123, 221, 37} ,{27, 123, 182, 7} ,{27, 123, 57, 0} ,{27, 123, 46, 0} ,{27, 123, 222, 37} ,{27, 123, 63, 0} ,{27, 123, 226, 22} ,{27, 123, 228, 2} ,{27, 123, 54, 0} ,{27, 123, 47, 0} ,{27, 123, 55, 0} ,{27, 123, 64, 0} ,{27, 123, 60, 0} ,{27, 123, 52, 0} ,{140, 166, 140, 3} ,{55, 123, 51, 0} ,{55, 123, 230, 33} ,{55, 123, 216, 37} ,{55, 123, 58, 0} ,{55, 123, 212, 0} ,{55, 123, 89, 7} ,{55, 123, 48, 0} ,{55, 123, 56, 0} ,{55, 123, 217, 37} ,{55, 123, 151, 17} ,{55, 123, 218, 37} ,{55, 123, 219, 37} ,{55, 123, 220, 37} ,{55, 123, 221, 37} ,{55, 123, 182, 7} ,{55, 123, 57, 0} ,{55, 123, 46, 0} ,{55, 123, 222, 37} ,{55, 123, 63, 0} ,{55, 123, 226, 22} ,{55, 123, 228, 2} ,{55, 123, 54, 0} ,{55, 123, 47, 0} ,{55, 123, 55, 0} ,{55, 123, 64, 0} ,{55, 123, 60, 0} ,{55, 123, 52, 0} ,{140, 166, 228, 5} ,{83, 123, 51, 0} ,{83, 123, 230, 33} ,{83, 123, 216, 37} ,{83, 123, 58, 0} ,{83, 123, 212, 0} ,{83, 123, 89, 7} ,{83, 123, 48, 0} ,{83, 123, 56, 0} ,{83, 123, 217, 37} ,{83, 123, 151, 17} ,{83, 123, 218, 37} ,{83, 123, 219, 37} ,{83, 123, 220, 37} ,{83, 123, 221, 37} ,{83, 123, 182, 7} ,{83, 123, 57, 0} ,{83, 123, 46, 0} ,{83, 123, 222, 37} ,{83, 123, 63, 0} ,{83, 123, 226, 22} ,{83, 123, 228, 2} ,{83, 123, 54, 0} ,{83, 123, 47, 0} ,{83, 123, 55, 0} ,{83, 123, 64, 0} ,{83, 123, 60, 0} ,{83, 123, 52, 0} ,{140, 166, 164, 0} ,{111, 123, 51, 0} ,{111, 123, 230, 33} ,{111, 123, 216, 37} ,{111, 123, 58, 0} ,{111, 123, 212, 0} ,{111, 123, 89, 7} ,{111, 123, 48, 0} ,{111, 123, 56, 0} ,{111, 123, 217, 37} ,{111, 123, 151, 17} ,{111, 123, 218, 37} ,{111, 123, 219, 37} ,{111, 123, 220, 37} ,{111, 123, 221, 37} ,{111, 123, 182, 7} ,{111, 123, 57, 0} ,{111, 123, 46, 0} ,{111, 123, 222, 37} ,{111, 123, 63, 0} ,{111, 123, 226, 22} ,{111, 123, 228, 2} ,{111, 123, 54, 0} ,{111, 123, 47, 0} ,{111, 123, 55, 0} ,{111, 123, 64, 0} ,{111, 123, 60, 0} ,{111, 123, 52, 0} ,{140, 166, 204, 4} ,{139, 123, 51, 0} ,{139, 123, 230, 33} ,{139, 123, 216, 37} ,{139, 123, 58, 0} ,{139, 123, 212, 0} ,{139, 123, 89, 7} ,{139, 123, 48, 0} ,{139, 123, 56, 0} ,{139, 123, 217, 37} ,{139, 123, 151, 17} ,{139, 123, 218, 37} ,{139, 123, 219, 37} ,{139, 123, 220, 37} ,{139, 123, 221, 37} ,{139, 123, 182, 7} ,{139, 123, 57, 0} ,{139, 123, 46, 0} ,{139, 123, 222, 37} ,{139, 123, 63, 0} ,{139, 123, 226, 22} ,{139, 123, 228, 2} ,{139, 123, 54, 0} ,{139, 123, 47, 0} ,{139, 123, 55, 0} ,{139, 123, 64, 0} ,{139, 123, 60, 0} ,{139, 123, 52, 0} ,{140, 166, 65, 0} ,{167, 123, 51, 0} ,{167, 123, 230, 33} ,{167, 123, 216, 37} ,{167, 123, 58, 0} ,{167, 123, 212, 0} ,{167, 123, 89, 7} ,{167, 123, 48, 0} ,{167, 123, 56, 0} ,{167, 123, 217, 37} ,{167, 123, 151, 17} ,{167, 123, 218, 37} ,{167, 123, 219, 37} ,{167, 123, 220, 37} ,{167, 123, 221, 37} ,{167, 123, 182, 7} ,{167, 123, 57, 0} ,{167, 123, 46, 0} ,{167, 123, 222, 37} ,{167, 123, 63, 0} ,{167, 123, 226, 22} ,{167, 123, 228, 2} ,{167, 123, 54, 0} ,{167, 123, 47, 0} ,{167, 123, 55, 0} ,{167, 123, 64, 0} ,{167, 123, 60, 0} ,{167, 123, 52, 0} ,{140, 166, 229, 5} ,{195, 123, 51, 0} ,{195, 123, 230, 33} ,{195, 123, 216, 37} ,{195, 123, 58, 0} ,{195, 123, 212, 0} ,{195, 123, 89, 7} ,{195, 123, 48, 0} ,{195, 123, 56, 0} ,{195, 123, 217, 37} ,{195, 123, 151, 17} ,{195, 123, 218, 37} ,{195, 123, 219, 37} ,{195, 123, 220, 37} ,{195, 123, 221, 37} ,{195, 123, 182, 7} ,{195, 123, 57, 0} ,{195, 123, 46, 0} ,{195, 123, 222, 37} ,{195, 123, 63, 0} ,{195, 123, 226, 22} ,{195, 123, 228, 2} ,{195, 123, 54, 0} ,{195, 123, 47, 0} ,{195, 123, 55, 0} ,{195, 123, 64, 0} ,{195, 123, 60, 0} ,{195, 123, 52, 0} ,{140, 166, 226, 1} ,{223, 123, 51, 0} ,{223, 123, 230, 33} ,{223, 123, 216, 37} ,{223, 123, 58, 0} ,{223, 123, 212, 0} ,{223, 123, 89, 7} ,{223, 123, 48, 0} ,{223, 123, 56, 0} ,{223, 123, 217, 37} ,{223, 123, 151, 17} ,{223, 123, 218, 37} ,{223, 123, 219, 37} ,{223, 123, 220, 37} ,{223, 123, 221, 37} ,{223, 123, 182, 7} ,{223, 123, 57, 0} ,{223, 123, 46, 0} ,{223, 123, 222, 37} ,{223, 123, 63, 0} ,{223, 123, 226, 22} ,{223, 123, 228, 2} ,{223, 123, 54, 0} ,{223, 123, 47, 0} ,{223, 123, 55, 0} ,{223, 123, 64, 0} ,{223, 123, 60, 0} ,{223, 123, 52, 0} ,{140, 166, 230, 5} ,{251, 123, 51, 0} ,{251, 123, 230, 33} ,{251, 123, 216, 37} ,{251, 123, 58, 0} ,{251, 123, 212, 0} ,{251, 123, 89, 7} ,{251, 123, 48, 0} ,{251, 123, 56, 0} ,{251, 123, 217, 37} ,{251, 123, 151, 17} ,{251, 123, 218, 37} ,{251, 123, 219, 37} ,{251, 123, 220, 37} ,{251, 123, 221, 37} ,{251, 123, 182, 7} ,{251, 123, 57, 0} ,{251, 123, 46, 0} ,{251, 123, 222, 37} ,{251, 123, 63, 0} ,{251, 123, 226, 22} ,{251, 123, 228, 2} ,{251, 123, 54, 0} ,{251, 123, 47, 0} ,{251, 123, 55, 0} ,{251, 123, 64, 0} ,{251, 123, 60, 0} ,{251, 123, 52, 0} ,{140, 166, 170, 1} ,{23, 124, 51, 0} ,{23, 124, 230, 33} ,{23, 124, 216, 37} ,{23, 124, 58, 0} ,{23, 124, 212, 0} ,{23, 124, 89, 7} ,{23, 124, 48, 0} ,{23, 124, 56, 0} ,{23, 124, 217, 37} ,{23, 124, 151, 17} ,{23, 124, 218, 37} ,{23, 124, 219, 37} ,{23, 124, 220, 37} ,{23, 124, 221, 37} ,{23, 124, 182, 7} ,{23, 124, 57, 0} ,{23, 124, 46, 0} ,{23, 124, 222, 37} ,{23, 124, 63, 0} ,{23, 124, 226, 22} ,{23, 124, 228, 2} ,{23, 124, 54, 0} ,{23, 124, 47, 0} ,{23, 124, 55, 0} ,{23, 124, 64, 0} ,{23, 124, 60, 0} ,{23, 124, 52, 0} ,{140, 166, 110, 5} ,{51, 124, 51, 0} ,{51, 124, 230, 33} ,{51, 124, 216, 37} ,{51, 124, 58, 0} ,{51, 124, 212, 0} ,{51, 124, 89, 7} ,{51, 124, 48, 0} ,{51, 124, 56, 0} ,{51, 124, 217, 37} ,{51, 124, 151, 17} ,{51, 124, 218, 37} ,{51, 124, 219, 37} ,{51, 124, 220, 37} ,{51, 124, 221, 37} ,{51, 124, 182, 7} ,{51, 124, 57, 0} ,{51, 124, 46, 0} ,{51, 124, 222, 37} ,{51, 124, 63, 0} ,{51, 124, 226, 22} ,{51, 124, 228, 2} ,{51, 124, 54, 0} ,{51, 124, 47, 0} ,{51, 124, 55, 0} ,{51, 124, 64, 0} ,{51, 124, 60, 0} ,{51, 124, 52, 0} ,{140, 166, 141, 1} ,{79, 124, 51, 0} ,{79, 124, 230, 33} ,{79, 124, 216, 37} ,{79, 124, 58, 0} ,{79, 124, 212, 0} ,{79, 124, 89, 7} ,{79, 124, 48, 0} ,{79, 124, 56, 0} ,{79, 124, 217, 37} ,{79, 124, 151, 17} ,{79, 124, 218, 37} ,{79, 124, 219, 37} ,{79, 124, 220, 37} ,{79, 124, 221, 37} ,{79, 124, 182, 7} ,{79, 124, 57, 0} ,{79, 124, 46, 0} ,{79, 124, 222, 37} ,{79, 124, 63, 0} ,{79, 124, 226, 22} ,{79, 124, 228, 2} ,{79, 124, 54, 0} ,{79, 124, 47, 0} ,{79, 124, 55, 0} ,{79, 124, 64, 0} ,{79, 124, 60, 0} ,{79, 124, 52, 0} ,{140, 166, 53, 0} ,{107, 124, 51, 0} ,{107, 124, 230, 33} ,{107, 124, 216, 37} ,{107, 124, 58, 0} ,{107, 124, 212, 0} ,{107, 124, 89, 7} ,{107, 124, 48, 0} ,{107, 124, 56, 0} ,{107, 124, 217, 37} ,{107, 124, 151, 17} ,{107, 124, 218, 37} ,{107, 124, 219, 37} ,{107, 124, 220, 37} ,{107, 124, 221, 37} ,{107, 124, 182, 7} ,{107, 124, 57, 0} ,{107, 124, 46, 0} ,{107, 124, 222, 37} ,{107, 124, 63, 0} ,{107, 124, 226, 22} ,{107, 124, 228, 2} ,{107, 124, 54, 0} ,{107, 124, 47, 0} ,{107, 124, 55, 0} ,{107, 124, 64, 0} ,{107, 124, 60, 0} ,{107, 124, 52, 0} ,{141, 166, 45, 0} ,{135, 124, 51, 0} ,{135, 124, 230, 33} ,{135, 124, 216, 37} ,{135, 124, 58, 0} ,{135, 124, 212, 0} ,{135, 124, 89, 7} ,{135, 124, 48, 0} ,{135, 124, 56, 0} ,{135, 124, 217, 37} ,{135, 124, 151, 17} ,{135, 124, 218, 37} ,{135, 124, 219, 37} ,{135, 124, 220, 37} ,{135, 124, 221, 37} ,{135, 124, 182, 7} ,{135, 124, 57, 0} ,{135, 124, 46, 0} ,{135, 124, 222, 37} ,{135, 124, 63, 0} ,{135, 124, 226, 22} ,{135, 124, 228, 2} ,{135, 124, 54, 0} ,{135, 124, 47, 0} ,{135, 124, 55, 0} ,{135, 124, 64, 0} ,{135, 124, 60, 0} ,{135, 124, 52, 0} ,{141, 166, 133, 0} ,{163, 124, 51, 0} ,{163, 124, 230, 33} ,{163, 124, 216, 37} ,{163, 124, 58, 0} ,{163, 124, 212, 0} ,{163, 124, 89, 7} ,{163, 124, 48, 0} ,{163, 124, 56, 0} ,{163, 124, 217, 37} ,{163, 124, 151, 17} ,{163, 124, 218, 37} ,{163, 124, 219, 37} ,{163, 124, 220, 37} ,{163, 124, 221, 37} ,{163, 124, 182, 7} ,{163, 124, 57, 0} ,{163, 124, 46, 0} ,{163, 124, 222, 37} ,{163, 124, 63, 0} ,{163, 124, 226, 22} ,{163, 124, 228, 2} ,{163, 124, 54, 0} ,{163, 124, 47, 0} ,{163, 124, 55, 0} ,{163, 124, 64, 0} ,{163, 124, 60, 0} ,{163, 124, 52, 0} ,{141, 166, 171, 1} ,{191, 124, 51, 0} ,{191, 124, 230, 33} ,{191, 124, 216, 37} ,{191, 124, 58, 0} ,{191, 124, 212, 0} ,{191, 124, 89, 7} ,{191, 124, 48, 0} ,{191, 124, 56, 0} ,{191, 124, 217, 37} ,{191, 124, 151, 17} ,{191, 124, 218, 37} ,{191, 124, 219, 37} ,{191, 124, 220, 37} ,{191, 124, 221, 37} ,{191, 124, 182, 7} ,{191, 124, 57, 0} ,{191, 124, 46, 0} ,{191, 124, 222, 37} ,{191, 124, 63, 0} ,{191, 124, 226, 22} ,{191, 124, 228, 2} ,{191, 124, 54, 0} ,{191, 124, 47, 0} ,{191, 124, 55, 0} ,{191, 124, 64, 0} ,{191, 124, 60, 0} ,{191, 124, 52, 0} ,{141, 166, 224, 1} ,{219, 124, 51, 0} ,{219, 124, 230, 33} ,{219, 124, 216, 37} ,{219, 124, 58, 0} ,{219, 124, 212, 0} ,{219, 124, 89, 7} ,{219, 124, 48, 0} ,{219, 124, 56, 0} ,{219, 124, 217, 37} ,{219, 124, 151, 17} ,{219, 124, 218, 37} ,{219, 124, 219, 37} ,{219, 124, 220, 37} ,{219, 124, 221, 37} ,{219, 124, 182, 7} ,{219, 124, 57, 0} ,{219, 124, 46, 0} ,{219, 124, 222, 37} ,{219, 124, 63, 0} ,{219, 124, 226, 22} ,{219, 124, 228, 2} ,{219, 124, 54, 0} ,{219, 124, 47, 0} ,{219, 124, 55, 0} ,{219, 124, 64, 0} ,{219, 124, 60, 0} ,{219, 124, 52, 0} ,{141, 166, 225, 5} ,{247, 124, 51, 0} ,{247, 124, 230, 33} ,{247, 124, 216, 37} ,{247, 124, 58, 0} ,{247, 124, 212, 0} ,{247, 124, 89, 7} ,{247, 124, 48, 0} ,{247, 124, 56, 0} ,{247, 124, 217, 37} ,{247, 124, 151, 17} ,{247, 124, 218, 37} ,{247, 124, 219, 37} ,{247, 124, 220, 37} ,{247, 124, 221, 37} ,{247, 124, 182, 7} ,{247, 124, 57, 0} ,{247, 124, 46, 0} ,{247, 124, 222, 37} ,{247, 124, 63, 0} ,{247, 124, 226, 22} ,{247, 124, 228, 2} ,{247, 124, 54, 0} ,{247, 124, 47, 0} ,{247, 124, 55, 0} ,{247, 124, 64, 0} ,{247, 124, 60, 0} ,{247, 124, 52, 0} ,{141, 166, 49, 0} ,{19, 125, 51, 0} ,{19, 125, 230, 33} ,{19, 125, 216, 37} ,{19, 125, 58, 0} ,{19, 125, 212, 0} ,{19, 125, 89, 7} ,{19, 125, 48, 0} ,{19, 125, 56, 0} ,{19, 125, 217, 37} ,{19, 125, 151, 17} ,{19, 125, 218, 37} ,{19, 125, 219, 37} ,{19, 125, 220, 37} ,{19, 125, 221, 37} ,{19, 125, 182, 7} ,{19, 125, 57, 0} ,{19, 125, 46, 0} ,{19, 125, 222, 37} ,{19, 125, 63, 0} ,{19, 125, 226, 22} ,{19, 125, 228, 2} ,{19, 125, 54, 0} ,{19, 125, 47, 0} ,{19, 125, 55, 0} ,{19, 125, 64, 0} ,{19, 125, 60, 0} ,{19, 125, 52, 0} ,{141, 166, 226, 5} ,{47, 125, 51, 0} ,{47, 125, 230, 33} ,{47, 125, 216, 37} ,{47, 125, 58, 0} ,{47, 125, 212, 0} ,{47, 125, 89, 7} ,{47, 125, 48, 0} ,{47, 125, 56, 0} ,{47, 125, 217, 37} ,{47, 125, 151, 17} ,{47, 125, 218, 37} ,{47, 125, 219, 37} ,{47, 125, 220, 37} ,{47, 125, 221, 37} ,{47, 125, 182, 7} ,{47, 125, 57, 0} ,{47, 125, 46, 0} ,{47, 125, 222, 37} ,{47, 125, 63, 0} ,{47, 125, 226, 22} ,{47, 125, 228, 2} ,{47, 125, 54, 0} ,{47, 125, 47, 0} ,{47, 125, 55, 0} ,{47, 125, 64, 0} ,{47, 125, 60, 0} ,{47, 125, 52, 0} ,{141, 166, 227, 5} ,{75, 125, 51, 0} ,{75, 125, 230, 33} ,{75, 125, 216, 37} ,{75, 125, 58, 0} ,{75, 125, 212, 0} ,{75, 125, 89, 7} ,{75, 125, 48, 0} ,{75, 125, 56, 0} ,{75, 125, 217, 37} ,{75, 125, 151, 17} ,{75, 125, 218, 37} ,{75, 125, 219, 37} ,{75, 125, 220, 37} ,{75, 125, 221, 37} ,{75, 125, 182, 7} ,{75, 125, 57, 0} ,{75, 125, 46, 0} ,{75, 125, 222, 37} ,{75, 125, 63, 0} ,{75, 125, 226, 22} ,{75, 125, 228, 2} ,{75, 125, 54, 0} ,{75, 125, 47, 0} ,{75, 125, 55, 0} ,{75, 125, 64, 0} ,{75, 125, 60, 0} ,{75, 125, 52, 0} ,{141, 166, 59, 0} ,{103, 125, 51, 0} ,{103, 125, 230, 33} ,{103, 125, 216, 37} ,{103, 125, 58, 0} ,{103, 125, 212, 0} ,{103, 125, 89, 7} ,{103, 125, 48, 0} ,{103, 125, 56, 0} ,{103, 125, 217, 37} ,{103, 125, 151, 17} ,{103, 125, 218, 37} ,{103, 125, 219, 37} ,{103, 125, 220, 37} ,{103, 125, 221, 37} ,{103, 125, 182, 7} ,{103, 125, 57, 0} ,{103, 125, 46, 0} ,{103, 125, 222, 37} ,{103, 125, 63, 0} ,{103, 125, 226, 22} ,{103, 125, 228, 2} ,{103, 125, 54, 0} ,{103, 125, 47, 0} ,{103, 125, 55, 0} ,{103, 125, 64, 0} ,{103, 125, 60, 0} ,{103, 125, 52, 0} ,{141, 166, 140, 3} ,{131, 125, 51, 0} ,{131, 125, 230, 33} ,{131, 125, 216, 37} ,{131, 125, 58, 0} ,{131, 125, 212, 0} ,{131, 125, 89, 7} ,{131, 125, 48, 0} ,{131, 125, 56, 0} ,{131, 125, 217, 37} ,{131, 125, 151, 17} ,{131, 125, 218, 37} ,{131, 125, 219, 37} ,{131, 125, 220, 37} ,{131, 125, 221, 37} ,{131, 125, 182, 7} ,{131, 125, 57, 0} ,{131, 125, 46, 0} ,{131, 125, 222, 37} ,{131, 125, 63, 0} ,{131, 125, 226, 22} ,{131, 125, 228, 2} ,{131, 125, 54, 0} ,{131, 125, 47, 0} ,{131, 125, 55, 0} ,{131, 125, 64, 0} ,{131, 125, 60, 0} ,{131, 125, 52, 0} ,{141, 166, 228, 5} ,{159, 125, 51, 0} ,{159, 125, 230, 33} ,{159, 125, 216, 37} ,{159, 125, 58, 0} ,{159, 125, 212, 0} ,{159, 125, 89, 7} ,{159, 125, 48, 0} ,{159, 125, 56, 0} ,{159, 125, 217, 37} ,{159, 125, 151, 17} ,{159, 125, 218, 37} ,{159, 125, 219, 37} ,{159, 125, 220, 37} ,{159, 125, 221, 37} ,{159, 125, 182, 7} ,{159, 125, 57, 0} ,{159, 125, 46, 0} ,{159, 125, 222, 37} ,{159, 125, 63, 0} ,{159, 125, 226, 22} ,{159, 125, 228, 2} ,{159, 125, 54, 0} ,{159, 125, 47, 0} ,{159, 125, 55, 0} ,{159, 125, 64, 0} ,{159, 125, 60, 0} ,{159, 125, 52, 0} ,{141, 166, 164, 0} ,{187, 125, 51, 0} ,{187, 125, 230, 33} ,{187, 125, 216, 37} ,{187, 125, 58, 0} ,{187, 125, 212, 0} ,{187, 125, 89, 7} ,{187, 125, 48, 0} ,{187, 125, 56, 0} ,{187, 125, 217, 37} ,{187, 125, 151, 17} ,{187, 125, 218, 37} ,{187, 125, 219, 37} ,{187, 125, 220, 37} ,{187, 125, 221, 37} ,{187, 125, 182, 7} ,{187, 125, 57, 0} ,{187, 125, 46, 0} ,{187, 125, 222, 37} ,{187, 125, 63, 0} ,{187, 125, 226, 22} ,{187, 125, 228, 2} ,{187, 125, 54, 0} ,{187, 125, 47, 0} ,{187, 125, 55, 0} ,{187, 125, 64, 0} ,{187, 125, 60, 0} ,{187, 125, 52, 0} ,{141, 166, 204, 4} ,{215, 125, 51, 0} ,{215, 125, 230, 33} ,{215, 125, 216, 37} ,{215, 125, 58, 0} ,{215, 125, 212, 0} ,{215, 125, 89, 7} ,{215, 125, 48, 0} ,{215, 125, 56, 0} ,{215, 125, 217, 37} ,{215, 125, 151, 17} ,{215, 125, 218, 37} ,{215, 125, 219, 37} ,{215, 125, 220, 37} ,{215, 125, 221, 37} ,{215, 125, 182, 7} ,{215, 125, 57, 0} ,{215, 125, 46, 0} ,{215, 125, 222, 37} ,{215, 125, 63, 0} ,{215, 125, 226, 22} ,{215, 125, 228, 2} ,{215, 125, 54, 0} ,{215, 125, 47, 0} ,{215, 125, 55, 0} ,{215, 125, 64, 0} ,{215, 125, 60, 0} ,{215, 125, 52, 0} ,{141, 166, 65, 0} ,{243, 125, 51, 0} ,{243, 125, 230, 33} ,{243, 125, 216, 37} ,{243, 125, 58, 0} ,{243, 125, 212, 0} ,{243, 125, 89, 7} ,{243, 125, 48, 0} ,{243, 125, 56, 0} ,{243, 125, 217, 37} ,{243, 125, 151, 17} ,{243, 125, 218, 37} ,{243, 125, 219, 37} ,{243, 125, 220, 37} ,{243, 125, 221, 37} ,{243, 125, 182, 7} ,{243, 125, 57, 0} ,{243, 125, 46, 0} ,{243, 125, 222, 37} ,{243, 125, 63, 0} ,{243, 125, 226, 22} ,{243, 125, 228, 2} ,{243, 125, 54, 0} ,{243, 125, 47, 0} ,{243, 125, 55, 0} ,{243, 125, 64, 0} ,{243, 125, 60, 0} ,{243, 125, 52, 0} ,{141, 166, 229, 5} ,{15, 126, 51, 0} ,{15, 126, 230, 33} ,{15, 126, 216, 37} ,{15, 126, 58, 0} ,{15, 126, 212, 0} ,{15, 126, 89, 7} ,{15, 126, 48, 0} ,{15, 126, 56, 0} ,{15, 126, 217, 37} ,{15, 126, 151, 17} ,{15, 126, 218, 37} ,{15, 126, 219, 37} ,{15, 126, 220, 37} ,{15, 126, 221, 37} ,{15, 126, 182, 7} ,{15, 126, 57, 0} ,{15, 126, 46, 0} ,{15, 126, 222, 37} ,{15, 126, 63, 0} ,{15, 126, 226, 22} ,{15, 126, 228, 2} ,{15, 126, 54, 0} ,{15, 126, 47, 0} ,{15, 126, 55, 0} ,{15, 126, 64, 0} ,{15, 126, 60, 0} ,{15, 126, 52, 0} ,{141, 166, 226, 1} ,{43, 126, 51, 0} ,{43, 126, 230, 33} ,{43, 126, 216, 37} ,{43, 126, 58, 0} ,{43, 126, 212, 0} ,{43, 126, 89, 7} ,{43, 126, 48, 0} ,{43, 126, 56, 0} ,{43, 126, 217, 37} ,{43, 126, 151, 17} ,{43, 126, 218, 37} ,{43, 126, 219, 37} ,{43, 126, 220, 37} ,{43, 126, 221, 37} ,{43, 126, 182, 7} ,{43, 126, 57, 0} ,{43, 126, 46, 0} ,{43, 126, 222, 37} ,{43, 126, 63, 0} ,{43, 126, 226, 22} ,{43, 126, 228, 2} ,{43, 126, 54, 0} ,{43, 126, 47, 0} ,{43, 126, 55, 0} ,{43, 126, 64, 0} ,{43, 126, 60, 0} ,{43, 126, 52, 0} ,{141, 166, 230, 5} ,{71, 126, 51, 0} ,{71, 126, 230, 33} ,{71, 126, 216, 37} ,{71, 126, 58, 0} ,{71, 126, 212, 0} ,{71, 126, 89, 7} ,{71, 126, 48, 0} ,{71, 126, 56, 0} ,{71, 126, 217, 37} ,{71, 126, 151, 17} ,{71, 126, 218, 37} ,{71, 126, 219, 37} ,{71, 126, 220, 37} ,{71, 126, 221, 37} ,{71, 126, 182, 7} ,{71, 126, 57, 0} ,{71, 126, 46, 0} ,{71, 126, 222, 37} ,{71, 126, 63, 0} ,{71, 126, 226, 22} ,{71, 126, 228, 2} ,{71, 126, 54, 0} ,{71, 126, 47, 0} ,{71, 126, 55, 0} ,{71, 126, 64, 0} ,{71, 126, 60, 0} ,{71, 126, 52, 0} ,{141, 166, 170, 1} ,{99, 126, 51, 0} ,{99, 126, 230, 33} ,{99, 126, 216, 37} ,{99, 126, 58, 0} ,{99, 126, 212, 0} ,{99, 126, 89, 7} ,{99, 126, 48, 0} ,{99, 126, 56, 0} ,{99, 126, 217, 37} ,{99, 126, 151, 17} ,{99, 126, 218, 37} ,{99, 126, 219, 37} ,{99, 126, 220, 37} ,{99, 126, 221, 37} ,{99, 126, 182, 7} ,{99, 126, 57, 0} ,{99, 126, 46, 0} ,{99, 126, 222, 37} ,{99, 126, 63, 0} ,{99, 126, 226, 22} ,{99, 126, 228, 2} ,{99, 126, 54, 0} ,{99, 126, 47, 0} ,{99, 126, 55, 0} ,{99, 126, 64, 0} ,{99, 126, 60, 0} ,{99, 126, 52, 0} ,{141, 166, 110, 5} ,{127, 126, 51, 0} ,{127, 126, 230, 33} ,{127, 126, 216, 37} ,{127, 126, 58, 0} ,{127, 126, 212, 0} ,{127, 126, 89, 7} ,{127, 126, 48, 0} ,{127, 126, 56, 0} ,{127, 126, 217, 37} ,{127, 126, 151, 17} ,{127, 126, 218, 37} ,{127, 126, 219, 37} ,{127, 126, 220, 37} ,{127, 126, 221, 37} ,{127, 126, 182, 7} ,{127, 126, 57, 0} ,{127, 126, 46, 0} ,{127, 126, 222, 37} ,{127, 126, 63, 0} ,{127, 126, 226, 22} ,{127, 126, 228, 2} ,{127, 126, 54, 0} ,{127, 126, 47, 0} ,{127, 126, 55, 0} ,{127, 126, 64, 0} ,{127, 126, 60, 0} ,{127, 126, 52, 0} ,{141, 166, 141, 1} ,{155, 126, 51, 0} ,{155, 126, 230, 33} ,{155, 126, 216, 37} ,{155, 126, 58, 0} ,{155, 126, 212, 0} ,{155, 126, 89, 7} ,{155, 126, 48, 0} ,{155, 126, 56, 0} ,{155, 126, 217, 37} ,{155, 126, 151, 17} ,{155, 126, 218, 37} ,{155, 126, 219, 37} ,{155, 126, 220, 37} ,{155, 126, 221, 37} ,{155, 126, 182, 7} ,{155, 126, 57, 0} ,{155, 126, 46, 0} ,{155, 126, 222, 37} ,{155, 126, 63, 0} ,{155, 126, 226, 22} ,{155, 126, 228, 2} ,{155, 126, 54, 0} ,{155, 126, 47, 0} ,{155, 126, 55, 0} ,{155, 126, 64, 0} ,{155, 126, 60, 0} ,{155, 126, 52, 0} ,{141, 166, 53, 0} ,{183, 126, 51, 0} ,{183, 126, 230, 33} ,{183, 126, 216, 37} ,{183, 126, 58, 0} ,{183, 126, 212, 0} ,{183, 126, 89, 7} ,{183, 126, 48, 0} ,{183, 126, 56, 0} ,{183, 126, 217, 37} ,{183, 126, 151, 17} ,{183, 126, 218, 37} ,{183, 126, 219, 37} ,{183, 126, 220, 37} ,{183, 126, 221, 37} ,{183, 126, 182, 7} ,{183, 126, 57, 0} ,{183, 126, 46, 0} ,{183, 126, 222, 37} ,{183, 126, 63, 0} ,{183, 126, 226, 22} ,{183, 126, 228, 2} ,{183, 126, 54, 0} ,{183, 126, 47, 0} ,{183, 126, 55, 0} ,{183, 126, 64, 0} ,{183, 126, 60, 0} ,{183, 126, 52, 0} ,{142, 166, 45, 0} ,{211, 126, 51, 0} ,{211, 126, 230, 33} ,{211, 126, 216, 37} ,{211, 126, 58, 0} ,{211, 126, 212, 0} ,{211, 126, 89, 7} ,{211, 126, 48, 0} ,{211, 126, 56, 0} ,{211, 126, 217, 37} ,{211, 126, 151, 17} ,{211, 126, 218, 37} ,{211, 126, 219, 37} ,{211, 126, 220, 37} ,{211, 126, 221, 37} ,{211, 126, 182, 7} ,{211, 126, 57, 0} ,{211, 126, 46, 0} ,{211, 126, 222, 37} ,{211, 126, 63, 0} ,{211, 126, 226, 22} ,{211, 126, 228, 2} ,{211, 126, 54, 0} ,{211, 126, 47, 0} ,{211, 126, 55, 0} ,{211, 126, 64, 0} ,{211, 126, 60, 0} ,{211, 126, 52, 0} ,{142, 166, 133, 0} ,{239, 126, 51, 0} ,{239, 126, 230, 33} ,{239, 126, 216, 37} ,{239, 126, 58, 0} ,{239, 126, 212, 0} ,{239, 126, 89, 7} ,{239, 126, 48, 0} ,{239, 126, 56, 0} ,{239, 126, 217, 37} ,{239, 126, 151, 17} ,{239, 126, 218, 37} ,{239, 126, 219, 37} ,{239, 126, 220, 37} ,{239, 126, 221, 37} ,{239, 126, 182, 7} ,{239, 126, 57, 0} ,{239, 126, 46, 0} ,{239, 126, 222, 37} ,{239, 126, 63, 0} ,{239, 126, 226, 22} ,{239, 126, 228, 2} ,{239, 126, 54, 0} ,{239, 126, 47, 0} ,{239, 126, 55, 0} ,{239, 126, 64, 0} ,{239, 126, 60, 0} ,{239, 126, 52, 0} ,{142, 166, 171, 1} ,{11, 127, 51, 0} ,{11, 127, 230, 33} ,{11, 127, 216, 37} ,{11, 127, 58, 0} ,{11, 127, 212, 0} ,{11, 127, 89, 7} ,{11, 127, 48, 0} ,{11, 127, 56, 0} ,{11, 127, 217, 37} ,{11, 127, 151, 17} ,{11, 127, 218, 37} ,{11, 127, 219, 37} ,{11, 127, 220, 37} ,{11, 127, 221, 37} ,{11, 127, 182, 7} ,{11, 127, 57, 0} ,{11, 127, 46, 0} ,{11, 127, 222, 37} ,{11, 127, 63, 0} ,{11, 127, 226, 22} ,{11, 127, 228, 2} ,{11, 127, 54, 0} ,{11, 127, 47, 0} ,{11, 127, 55, 0} ,{11, 127, 64, 0} ,{11, 127, 60, 0} ,{11, 127, 52, 0} ,{142, 166, 224, 1} ,{39, 127, 51, 0} ,{39, 127, 230, 33} ,{39, 127, 216, 37} ,{39, 127, 58, 0} ,{39, 127, 212, 0} ,{39, 127, 89, 7} ,{39, 127, 48, 0} ,{39, 127, 56, 0} ,{39, 127, 217, 37} ,{39, 127, 151, 17} ,{39, 127, 218, 37} ,{39, 127, 219, 37} ,{39, 127, 220, 37} ,{39, 127, 221, 37} ,{39, 127, 182, 7} ,{39, 127, 57, 0} ,{39, 127, 46, 0} ,{39, 127, 222, 37} ,{39, 127, 63, 0} ,{39, 127, 226, 22} ,{39, 127, 228, 2} ,{39, 127, 54, 0} ,{39, 127, 47, 0} ,{39, 127, 55, 0} ,{39, 127, 64, 0} ,{39, 127, 60, 0} ,{39, 127, 52, 0} ,{142, 166, 225, 5} ,{67, 127, 51, 0} ,{67, 127, 230, 33} ,{67, 127, 216, 37} ,{67, 127, 58, 0} ,{67, 127, 212, 0} ,{67, 127, 89, 7} ,{67, 127, 48, 0} ,{67, 127, 56, 0} ,{67, 127, 217, 37} ,{67, 127, 151, 17} ,{67, 127, 218, 37} ,{67, 127, 219, 37} ,{67, 127, 220, 37} ,{67, 127, 221, 37} ,{67, 127, 182, 7} ,{67, 127, 57, 0} ,{67, 127, 46, 0} ,{67, 127, 222, 37} ,{67, 127, 63, 0} ,{67, 127, 226, 22} ,{67, 127, 228, 2} ,{67, 127, 54, 0} ,{67, 127, 47, 0} ,{67, 127, 55, 0} ,{67, 127, 64, 0} ,{67, 127, 60, 0} ,{67, 127, 52, 0} ,{142, 166, 49, 0} ,{95, 127, 51, 0} ,{95, 127, 230, 33} ,{95, 127, 216, 37} ,{95, 127, 58, 0} ,{95, 127, 212, 0} ,{95, 127, 89, 7} ,{95, 127, 48, 0} ,{95, 127, 56, 0} ,{95, 127, 217, 37} ,{95, 127, 151, 17} ,{95, 127, 218, 37} ,{95, 127, 219, 37} ,{95, 127, 220, 37} ,{95, 127, 221, 37} ,{95, 127, 182, 7} ,{95, 127, 57, 0} ,{95, 127, 46, 0} ,{95, 127, 222, 37} ,{95, 127, 63, 0} ,{95, 127, 226, 22} ,{95, 127, 228, 2} ,{95, 127, 54, 0} ,{95, 127, 47, 0} ,{95, 127, 55, 0} ,{95, 127, 64, 0} ,{95, 127, 60, 0} ,{95, 127, 52, 0} ,{142, 166, 226, 5} ,{123, 127, 51, 0} ,{123, 127, 230, 33} ,{123, 127, 216, 37} ,{123, 127, 58, 0} ,{123, 127, 212, 0} ,{123, 127, 89, 7} ,{123, 127, 48, 0} ,{123, 127, 56, 0} ,{123, 127, 217, 37} ,{123, 127, 151, 17} ,{123, 127, 218, 37} ,{123, 127, 219, 37} ,{123, 127, 220, 37} ,{123, 127, 221, 37} ,{123, 127, 182, 7} ,{123, 127, 57, 0} ,{123, 127, 46, 0} ,{123, 127, 222, 37} ,{123, 127, 63, 0} ,{123, 127, 226, 22} ,{123, 127, 228, 2} ,{123, 127, 54, 0} ,{123, 127, 47, 0} ,{123, 127, 55, 0} ,{123, 127, 64, 0} ,{123, 127, 60, 0} ,{123, 127, 52, 0} ,{142, 166, 227, 5} ,{151, 127, 51, 0} ,{151, 127, 230, 33} ,{151, 127, 216, 37} ,{151, 127, 58, 0} ,{151, 127, 212, 0} ,{151, 127, 89, 7} ,{151, 127, 48, 0} ,{151, 127, 56, 0} ,{151, 127, 217, 37} ,{151, 127, 151, 17} ,{151, 127, 218, 37} ,{151, 127, 219, 37} ,{151, 127, 220, 37} ,{151, 127, 221, 37} ,{151, 127, 182, 7} ,{151, 127, 57, 0} ,{151, 127, 46, 0} ,{151, 127, 222, 37} ,{151, 127, 63, 0} ,{151, 127, 226, 22} ,{151, 127, 228, 2} ,{151, 127, 54, 0} ,{151, 127, 47, 0} ,{151, 127, 55, 0} ,{151, 127, 64, 0} ,{151, 127, 60, 0} ,{151, 127, 52, 0} ,{142, 166, 59, 0} ,{179, 127, 51, 0} ,{179, 127, 230, 33} ,{179, 127, 216, 37} ,{179, 127, 58, 0} ,{179, 127, 212, 0} ,{179, 127, 89, 7} ,{179, 127, 48, 0} ,{179, 127, 56, 0} ,{179, 127, 217, 37} ,{179, 127, 151, 17} ,{179, 127, 218, 37} ,{179, 127, 219, 37} ,{179, 127, 220, 37} ,{179, 127, 221, 37} ,{179, 127, 182, 7} ,{179, 127, 57, 0} ,{179, 127, 46, 0} ,{179, 127, 222, 37} ,{179, 127, 63, 0} ,{179, 127, 226, 22} ,{179, 127, 228, 2} ,{179, 127, 54, 0} ,{179, 127, 47, 0} ,{179, 127, 55, 0} ,{179, 127, 64, 0} ,{179, 127, 60, 0} ,{179, 127, 52, 0} ,{142, 166, 140, 3} ,{207, 127, 51, 0} ,{207, 127, 230, 33} ,{207, 127, 216, 37} ,{207, 127, 58, 0} ,{207, 127, 212, 0} ,{207, 127, 89, 7} ,{207, 127, 48, 0} ,{207, 127, 56, 0} ,{207, 127, 217, 37} ,{207, 127, 151, 17} ,{207, 127, 218, 37} ,{207, 127, 219, 37} ,{207, 127, 220, 37} ,{207, 127, 221, 37} ,{207, 127, 182, 7} ,{207, 127, 57, 0} ,{207, 127, 46, 0} ,{207, 127, 222, 37} ,{207, 127, 63, 0} ,{207, 127, 226, 22} ,{207, 127, 228, 2} ,{207, 127, 54, 0} ,{207, 127, 47, 0} ,{207, 127, 55, 0} ,{207, 127, 64, 0} ,{207, 127, 60, 0} ,{207, 127, 52, 0} ,{142, 166, 228, 5} ,{235, 127, 51, 0} ,{235, 127, 230, 33} ,{235, 127, 216, 37} ,{235, 127, 58, 0} ,{235, 127, 212, 0} ,{235, 127, 89, 7} ,{235, 127, 48, 0} ,{235, 127, 56, 0} ,{235, 127, 217, 37} ,{235, 127, 151, 17} ,{235, 127, 218, 37} ,{235, 127, 219, 37} ,{235, 127, 220, 37} ,{235, 127, 221, 37} ,{235, 127, 182, 7} ,{235, 127, 57, 0} ,{235, 127, 46, 0} ,{235, 127, 222, 37} ,{235, 127, 63, 0} ,{235, 127, 226, 22} ,{235, 127, 228, 2} ,{235, 127, 54, 0} ,{235, 127, 47, 0} ,{235, 127, 55, 0} ,{235, 127, 64, 0} ,{235, 127, 60, 0} ,{235, 127, 52, 0} ,{142, 166, 164, 0} ,{7, 128, 51, 0} ,{7, 128, 230, 33} ,{7, 128, 216, 37} ,{7, 128, 58, 0} ,{7, 128, 212, 0} ,{7, 128, 89, 7} ,{7, 128, 48, 0} ,{7, 128, 56, 0} ,{7, 128, 217, 37} ,{7, 128, 151, 17} ,{7, 128, 218, 37} ,{7, 128, 219, 37} ,{7, 128, 220, 37} ,{7, 128, 221, 37} ,{7, 128, 182, 7} ,{7, 128, 57, 0} ,{7, 128, 46, 0} ,{7, 128, 222, 37} ,{7, 128, 63, 0} ,{7, 128, 226, 22} ,{7, 128, 228, 2} ,{7, 128, 54, 0} ,{7, 128, 47, 0} ,{7, 128, 55, 0} ,{7, 128, 64, 0} ,{7, 128, 60, 0} ,{7, 128, 52, 0} ,{142, 166, 204, 4} ,{35, 128, 51, 0} ,{35, 128, 230, 33} ,{35, 128, 216, 37} ,{35, 128, 58, 0} ,{35, 128, 212, 0} ,{35, 128, 89, 7} ,{35, 128, 48, 0} ,{35, 128, 56, 0} ,{35, 128, 217, 37} ,{35, 128, 151, 17} ,{35, 128, 218, 37} ,{35, 128, 219, 37} ,{35, 128, 220, 37} ,{35, 128, 221, 37} ,{35, 128, 182, 7} ,{35, 128, 57, 0} ,{35, 128, 46, 0} ,{35, 128, 222, 37} ,{35, 128, 63, 0} ,{35, 128, 226, 22} ,{35, 128, 228, 2} ,{35, 128, 54, 0} ,{35, 128, 47, 0} ,{35, 128, 55, 0} ,{35, 128, 64, 0} ,{35, 128, 60, 0} ,{35, 128, 52, 0} ,{142, 166, 65, 0} ,{63, 128, 51, 0} ,{63, 128, 230, 33} ,{63, 128, 216, 37} ,{63, 128, 58, 0} ,{63, 128, 212, 0} ,{63, 128, 89, 7} ,{63, 128, 48, 0} ,{63, 128, 56, 0} ,{63, 128, 217, 37} ,{63, 128, 151, 17} ,{63, 128, 218, 37} ,{63, 128, 219, 37} ,{63, 128, 220, 37} ,{63, 128, 221, 37} ,{63, 128, 182, 7} ,{63, 128, 57, 0} ,{63, 128, 46, 0} ,{63, 128, 222, 37} ,{63, 128, 63, 0} ,{63, 128, 226, 22} ,{63, 128, 228, 2} ,{63, 128, 54, 0} ,{63, 128, 47, 0} ,{63, 128, 55, 0} ,{63, 128, 64, 0} ,{63, 128, 60, 0} ,{63, 128, 52, 0} ,{142, 166, 229, 5} ,{91, 128, 51, 0} ,{91, 128, 230, 33} ,{91, 128, 216, 37} ,{91, 128, 58, 0} ,{91, 128, 212, 0} ,{91, 128, 89, 7} ,{91, 128, 48, 0} ,{91, 128, 56, 0} ,{91, 128, 217, 37} ,{91, 128, 151, 17} ,{91, 128, 218, 37} ,{91, 128, 219, 37} ,{91, 128, 220, 37} ,{91, 128, 221, 37} ,{91, 128, 182, 7} ,{91, 128, 57, 0} ,{91, 128, 46, 0} ,{91, 128, 222, 37} ,{91, 128, 63, 0} ,{91, 128, 226, 22} ,{91, 128, 228, 2} ,{91, 128, 54, 0} ,{91, 128, 47, 0} ,{91, 128, 55, 0} ,{91, 128, 64, 0} ,{91, 128, 60, 0} ,{91, 128, 52, 0} ,{142, 166, 226, 1} ,{119, 128, 51, 0} ,{119, 128, 230, 33} ,{119, 128, 216, 37} ,{119, 128, 58, 0} ,{119, 128, 212, 0} ,{119, 128, 89, 7} ,{119, 128, 48, 0} ,{119, 128, 56, 0} ,{119, 128, 217, 37} ,{119, 128, 151, 17} ,{119, 128, 218, 37} ,{119, 128, 219, 37} ,{119, 128, 220, 37} ,{119, 128, 221, 37} ,{119, 128, 182, 7} ,{119, 128, 57, 0} ,{119, 128, 46, 0} ,{119, 128, 222, 37} ,{119, 128, 63, 0} ,{119, 128, 226, 22} ,{119, 128, 228, 2} ,{119, 128, 54, 0} ,{119, 128, 47, 0} ,{119, 128, 55, 0} ,{119, 128, 64, 0} ,{119, 128, 60, 0} ,{119, 128, 52, 0} ,{142, 166, 230, 5} ,{147, 128, 51, 0} ,{147, 128, 230, 33} ,{147, 128, 216, 37} ,{147, 128, 58, 0} ,{147, 128, 212, 0} ,{147, 128, 89, 7} ,{147, 128, 48, 0} ,{147, 128, 56, 0} ,{147, 128, 217, 37} ,{147, 128, 151, 17} ,{147, 128, 218, 37} ,{147, 128, 219, 37} ,{147, 128, 220, 37} ,{147, 128, 221, 37} ,{147, 128, 182, 7} ,{147, 128, 57, 0} ,{147, 128, 46, 0} ,{147, 128, 222, 37} ,{147, 128, 63, 0} ,{147, 128, 226, 22} ,{147, 128, 228, 2} ,{147, 128, 54, 0} ,{147, 128, 47, 0} ,{147, 128, 55, 0} ,{147, 128, 64, 0} ,{147, 128, 60, 0} ,{147, 128, 52, 0} ,{142, 166, 170, 1} ,{175, 128, 51, 0} ,{175, 128, 230, 33} ,{175, 128, 216, 37} ,{175, 128, 58, 0} ,{175, 128, 212, 0} ,{175, 128, 89, 7} ,{175, 128, 48, 0} ,{175, 128, 56, 0} ,{175, 128, 217, 37} ,{175, 128, 151, 17} ,{175, 128, 218, 37} ,{175, 128, 219, 37} ,{175, 128, 220, 37} ,{175, 128, 221, 37} ,{175, 128, 182, 7} ,{175, 128, 57, 0} ,{175, 128, 46, 0} ,{175, 128, 222, 37} ,{175, 128, 63, 0} ,{175, 128, 226, 22} ,{175, 128, 228, 2} ,{175, 128, 54, 0} ,{175, 128, 47, 0} ,{175, 128, 55, 0} ,{175, 128, 64, 0} ,{175, 128, 60, 0} ,{175, 128, 52, 0} ,{142, 166, 110, 5} ,{203, 128, 51, 0} ,{203, 128, 230, 33} ,{203, 128, 216, 37} ,{203, 128, 58, 0} ,{203, 128, 212, 0} ,{203, 128, 89, 7} ,{203, 128, 48, 0} ,{203, 128, 56, 0} ,{203, 128, 217, 37} ,{203, 128, 151, 17} ,{203, 128, 218, 37} ,{203, 128, 219, 37} ,{203, 128, 220, 37} ,{203, 128, 221, 37} ,{203, 128, 182, 7} ,{203, 128, 57, 0} ,{203, 128, 46, 0} ,{203, 128, 222, 37} ,{203, 128, 63, 0} ,{203, 128, 226, 22} ,{203, 128, 228, 2} ,{203, 128, 54, 0} ,{203, 128, 47, 0} ,{203, 128, 55, 0} ,{203, 128, 64, 0} ,{203, 128, 60, 0} ,{203, 128, 52, 0} ,{142, 166, 141, 1} ,{231, 128, 51, 0} ,{231, 128, 230, 33} ,{231, 128, 216, 37} ,{231, 128, 58, 0} ,{231, 128, 212, 0} ,{231, 128, 89, 7} ,{231, 128, 48, 0} ,{231, 128, 56, 0} ,{231, 128, 217, 37} ,{231, 128, 151, 17} ,{231, 128, 218, 37} ,{231, 128, 219, 37} ,{231, 128, 220, 37} ,{231, 128, 221, 37} ,{231, 128, 182, 7} ,{231, 128, 57, 0} ,{231, 128, 46, 0} ,{231, 128, 222, 37} ,{231, 128, 63, 0} ,{231, 128, 226, 22} ,{231, 128, 228, 2} ,{231, 128, 54, 0} ,{231, 128, 47, 0} ,{231, 128, 55, 0} ,{231, 128, 64, 0} ,{231, 128, 60, 0} ,{231, 128, 52, 0} ,{142, 166, 53, 0} ,{3, 129, 51, 0} ,{3, 129, 230, 33} ,{3, 129, 216, 37} ,{3, 129, 58, 0} ,{3, 129, 212, 0} ,{3, 129, 89, 7} ,{3, 129, 48, 0} ,{3, 129, 56, 0} ,{3, 129, 217, 37} ,{3, 129, 151, 17} ,{3, 129, 218, 37} ,{3, 129, 219, 37} ,{3, 129, 220, 37} ,{3, 129, 221, 37} ,{3, 129, 182, 7} ,{3, 129, 57, 0} ,{3, 129, 46, 0} ,{3, 129, 222, 37} ,{3, 129, 63, 0} ,{3, 129, 226, 22} ,{3, 129, 228, 2} ,{3, 129, 54, 0} ,{3, 129, 47, 0} ,{3, 129, 55, 0} ,{3, 129, 64, 0} ,{3, 129, 60, 0} ,{3, 129, 52, 0} ,{143, 166, 45, 0} ,{31, 129, 51, 0} ,{31, 129, 230, 33} ,{31, 129, 216, 37} ,{31, 129, 58, 0} ,{31, 129, 212, 0} ,{31, 129, 89, 7} ,{31, 129, 48, 0} ,{31, 129, 56, 0} ,{31, 129, 217, 37} ,{31, 129, 151, 17} ,{31, 129, 218, 37} ,{31, 129, 219, 37} ,{31, 129, 220, 37} ,{31, 129, 221, 37} ,{31, 129, 182, 7} ,{31, 129, 57, 0} ,{31, 129, 46, 0} ,{31, 129, 222, 37} ,{31, 129, 63, 0} ,{31, 129, 226, 22} ,{31, 129, 228, 2} ,{31, 129, 54, 0} ,{31, 129, 47, 0} ,{31, 129, 55, 0} ,{31, 129, 64, 0} ,{31, 129, 60, 0} ,{31, 129, 52, 0} ,{143, 166, 133, 0} ,{59, 129, 51, 0} ,{59, 129, 230, 33} ,{59, 129, 216, 37} ,{59, 129, 58, 0} ,{59, 129, 212, 0} ,{59, 129, 89, 7} ,{59, 129, 48, 0} ,{59, 129, 56, 0} ,{59, 129, 217, 37} ,{59, 129, 151, 17} ,{59, 129, 218, 37} ,{59, 129, 219, 37} ,{59, 129, 220, 37} ,{59, 129, 221, 37} ,{59, 129, 182, 7} ,{59, 129, 57, 0} ,{59, 129, 46, 0} ,{59, 129, 222, 37} ,{59, 129, 63, 0} ,{59, 129, 226, 22} ,{59, 129, 228, 2} ,{59, 129, 54, 0} ,{59, 129, 47, 0} ,{59, 129, 55, 0} ,{59, 129, 64, 0} ,{59, 129, 60, 0} ,{59, 129, 52, 0} ,{143, 166, 171, 1} ,{87, 129, 51, 0} ,{87, 129, 230, 33} ,{87, 129, 216, 37} ,{87, 129, 58, 0} ,{87, 129, 212, 0} ,{87, 129, 89, 7} ,{87, 129, 48, 0} ,{87, 129, 56, 0} ,{87, 129, 217, 37} ,{87, 129, 151, 17} ,{87, 129, 218, 37} ,{87, 129, 219, 37} ,{87, 129, 220, 37} ,{87, 129, 221, 37} ,{87, 129, 182, 7} ,{87, 129, 57, 0} ,{87, 129, 46, 0} ,{87, 129, 222, 37} ,{87, 129, 63, 0} ,{87, 129, 226, 22} ,{87, 129, 228, 2} ,{87, 129, 54, 0} ,{87, 129, 47, 0} ,{87, 129, 55, 0} ,{87, 129, 64, 0} ,{87, 129, 60, 0} ,{87, 129, 52, 0} ,{143, 166, 224, 1} ,{115, 129, 51, 0} ,{115, 129, 230, 33} ,{115, 129, 216, 37} ,{115, 129, 58, 0} ,{115, 129, 212, 0} ,{115, 129, 89, 7} ,{115, 129, 48, 0} ,{115, 129, 56, 0} ,{115, 129, 217, 37} ,{115, 129, 151, 17} ,{115, 129, 218, 37} ,{115, 129, 219, 37} ,{115, 129, 220, 37} ,{115, 129, 221, 37} ,{115, 129, 182, 7} ,{115, 129, 57, 0} ,{115, 129, 46, 0} ,{115, 129, 222, 37} ,{115, 129, 63, 0} ,{115, 129, 226, 22} ,{115, 129, 228, 2} ,{115, 129, 54, 0} ,{115, 129, 47, 0} ,{115, 129, 55, 0} ,{115, 129, 64, 0} ,{115, 129, 60, 0} ,{115, 129, 52, 0} ,{143, 166, 225, 5} ,{143, 129, 51, 0} ,{143, 129, 230, 33} ,{143, 129, 216, 37} ,{143, 129, 58, 0} ,{143, 129, 212, 0} ,{143, 129, 89, 7} ,{143, 129, 48, 0} ,{143, 129, 56, 0} ,{143, 129, 217, 37} ,{143, 129, 151, 17} ,{143, 129, 218, 37} ,{143, 129, 219, 37} ,{143, 129, 220, 37} ,{143, 129, 221, 37} ,{143, 129, 182, 7} ,{143, 129, 57, 0} ,{143, 129, 46, 0} ,{143, 129, 222, 37} ,{143, 129, 63, 0} ,{143, 129, 226, 22} ,{143, 129, 228, 2} ,{143, 129, 54, 0} ,{143, 129, 47, 0} ,{143, 129, 55, 0} ,{143, 129, 64, 0} ,{143, 129, 60, 0} ,{143, 129, 52, 0} ,{143, 166, 49, 0} ,{171, 129, 51, 0} ,{171, 129, 230, 33} ,{171, 129, 216, 37} ,{171, 129, 58, 0} ,{171, 129, 212, 0} ,{171, 129, 89, 7} ,{171, 129, 48, 0} ,{171, 129, 56, 0} ,{171, 129, 217, 37} ,{171, 129, 151, 17} ,{171, 129, 218, 37} ,{171, 129, 219, 37} ,{171, 129, 220, 37} ,{171, 129, 221, 37} ,{171, 129, 182, 7} ,{171, 129, 57, 0} ,{171, 129, 46, 0} ,{171, 129, 222, 37} ,{171, 129, 63, 0} ,{171, 129, 226, 22} ,{171, 129, 228, 2} ,{171, 129, 54, 0} ,{171, 129, 47, 0} ,{171, 129, 55, 0} ,{171, 129, 64, 0} ,{171, 129, 60, 0} ,{171, 129, 52, 0} ,{143, 166, 226, 5} ,{199, 129, 51, 0} ,{199, 129, 230, 33} ,{199, 129, 216, 37} ,{199, 129, 58, 0} ,{199, 129, 212, 0} ,{199, 129, 89, 7} ,{199, 129, 48, 0} ,{199, 129, 56, 0} ,{199, 129, 217, 37} ,{199, 129, 151, 17} ,{199, 129, 218, 37} ,{199, 129, 219, 37} ,{199, 129, 220, 37} ,{199, 129, 221, 37} ,{199, 129, 182, 7} ,{199, 129, 57, 0} ,{199, 129, 46, 0} ,{199, 129, 222, 37} ,{199, 129, 63, 0} ,{199, 129, 226, 22} ,{199, 129, 228, 2} ,{199, 129, 54, 0} ,{199, 129, 47, 0} ,{199, 129, 55, 0} ,{199, 129, 64, 0} ,{199, 129, 60, 0} ,{199, 129, 52, 0} ,{143, 166, 227, 5} ,{227, 129, 51, 0} ,{227, 129, 230, 33} ,{227, 129, 216, 37} ,{227, 129, 58, 0} ,{227, 129, 212, 0} ,{227, 129, 89, 7} ,{227, 129, 48, 0} ,{227, 129, 56, 0} ,{227, 129, 217, 37} ,{227, 129, 151, 17} ,{227, 129, 218, 37} ,{227, 129, 219, 37} ,{227, 129, 220, 37} ,{227, 129, 221, 37} ,{227, 129, 182, 7} ,{227, 129, 57, 0} ,{227, 129, 46, 0} ,{227, 129, 222, 37} ,{227, 129, 63, 0} ,{227, 129, 226, 22} ,{227, 129, 228, 2} ,{227, 129, 54, 0} ,{227, 129, 47, 0} ,{227, 129, 55, 0} ,{227, 129, 64, 0} ,{227, 129, 60, 0} ,{227, 129, 52, 0} ,{143, 166, 59, 0} ,{255, 129, 51, 0} ,{255, 129, 230, 33} ,{255, 129, 216, 37} ,{255, 129, 58, 0} ,{255, 129, 212, 0} ,{255, 129, 89, 7} ,{255, 129, 48, 0} ,{255, 129, 56, 0} ,{255, 129, 217, 37} ,{255, 129, 151, 17} ,{255, 129, 218, 37} ,{255, 129, 219, 37} ,{255, 129, 220, 37} ,{255, 129, 221, 37} ,{255, 129, 182, 7} ,{255, 129, 57, 0} ,{255, 129, 46, 0} ,{255, 129, 222, 37} ,{255, 129, 63, 0} ,{255, 129, 226, 22} ,{255, 129, 228, 2} ,{255, 129, 54, 0} ,{255, 129, 47, 0} ,{255, 129, 55, 0} ,{255, 129, 64, 0} ,{255, 129, 60, 0} ,{255, 129, 52, 0} ,{143, 166, 140, 3} ,{27, 130, 51, 0} ,{27, 130, 230, 33} ,{27, 130, 216, 37} ,{27, 130, 58, 0} ,{27, 130, 212, 0} ,{27, 130, 89, 7} ,{27, 130, 48, 0} ,{27, 130, 56, 0} ,{27, 130, 217, 37} ,{27, 130, 151, 17} ,{27, 130, 218, 37} ,{27, 130, 219, 37} ,{27, 130, 220, 37} ,{27, 130, 221, 37} ,{27, 130, 182, 7} ,{27, 130, 57, 0} ,{27, 130, 46, 0} ,{27, 130, 222, 37} ,{27, 130, 63, 0} ,{27, 130, 226, 22} ,{27, 130, 228, 2} ,{27, 130, 54, 0} ,{27, 130, 47, 0} ,{27, 130, 55, 0} ,{27, 130, 64, 0} ,{27, 130, 60, 0} ,{27, 130, 52, 0} ,{143, 166, 228, 5} ,{55, 130, 51, 0} ,{55, 130, 230, 33} ,{55, 130, 216, 37} ,{55, 130, 58, 0} ,{55, 130, 212, 0} ,{55, 130, 89, 7} ,{55, 130, 48, 0} ,{55, 130, 56, 0} ,{55, 130, 217, 37} ,{55, 130, 151, 17} ,{55, 130, 218, 37} ,{55, 130, 219, 37} ,{55, 130, 220, 37} ,{55, 130, 221, 37} ,{55, 130, 182, 7} ,{55, 130, 57, 0} ,{55, 130, 46, 0} ,{55, 130, 222, 37} ,{55, 130, 63, 0} ,{55, 130, 226, 22} ,{55, 130, 228, 2} ,{55, 130, 54, 0} ,{55, 130, 47, 0} ,{55, 130, 55, 0} ,{55, 130, 64, 0} ,{55, 130, 60, 0} ,{55, 130, 52, 0} ,{143, 166, 164, 0} ,{83, 130, 51, 0} ,{83, 130, 230, 33} ,{83, 130, 216, 37} ,{83, 130, 58, 0} ,{83, 130, 212, 0} ,{83, 130, 89, 7} ,{83, 130, 48, 0} ,{83, 130, 56, 0} ,{83, 130, 217, 37} ,{83, 130, 151, 17} ,{83, 130, 218, 37} ,{83, 130, 219, 37} ,{83, 130, 220, 37} ,{83, 130, 221, 37} ,{83, 130, 182, 7} ,{83, 130, 57, 0} ,{83, 130, 46, 0} ,{83, 130, 222, 37} ,{83, 130, 63, 0} ,{83, 130, 226, 22} ,{83, 130, 228, 2} ,{83, 130, 54, 0} ,{83, 130, 47, 0} ,{83, 130, 55, 0} ,{83, 130, 64, 0} ,{83, 130, 60, 0} ,{83, 130, 52, 0} ,{143, 166, 204, 4} ,{111, 130, 51, 0} ,{111, 130, 230, 33} ,{111, 130, 216, 37} ,{111, 130, 58, 0} ,{111, 130, 212, 0} ,{111, 130, 89, 7} ,{111, 130, 48, 0} ,{111, 130, 56, 0} ,{111, 130, 217, 37} ,{111, 130, 151, 17} ,{111, 130, 218, 37} ,{111, 130, 219, 37} ,{111, 130, 220, 37} ,{111, 130, 221, 37} ,{111, 130, 182, 7} ,{111, 130, 57, 0} ,{111, 130, 46, 0} ,{111, 130, 222, 37} ,{111, 130, 63, 0} ,{111, 130, 226, 22} ,{111, 130, 228, 2} ,{111, 130, 54, 0} ,{111, 130, 47, 0} ,{111, 130, 55, 0} ,{111, 130, 64, 0} ,{111, 130, 60, 0} ,{111, 130, 52, 0} ,{143, 166, 65, 0} ,{139, 130, 51, 0} ,{139, 130, 230, 33} ,{139, 130, 216, 37} ,{139, 130, 58, 0} ,{139, 130, 212, 0} ,{139, 130, 89, 7} ,{139, 130, 48, 0} ,{139, 130, 56, 0} ,{139, 130, 217, 37} ,{139, 130, 151, 17} ,{139, 130, 218, 37} ,{139, 130, 219, 37} ,{139, 130, 220, 37} ,{139, 130, 221, 37} ,{139, 130, 182, 7} ,{139, 130, 57, 0} ,{139, 130, 46, 0} ,{139, 130, 222, 37} ,{139, 130, 63, 0} ,{139, 130, 226, 22} ,{139, 130, 228, 2} ,{139, 130, 54, 0} ,{139, 130, 47, 0} ,{139, 130, 55, 0} ,{139, 130, 64, 0} ,{139, 130, 60, 0} ,{139, 130, 52, 0} ,{143, 166, 229, 5} ,{167, 130, 51, 0} ,{167, 130, 230, 33} ,{167, 130, 216, 37} ,{167, 130, 58, 0} ,{167, 130, 212, 0} ,{167, 130, 89, 7} ,{167, 130, 48, 0} ,{167, 130, 56, 0} ,{167, 130, 217, 37} ,{167, 130, 151, 17} ,{167, 130, 218, 37} ,{167, 130, 219, 37} ,{167, 130, 220, 37} ,{167, 130, 221, 37} ,{167, 130, 182, 7} ,{167, 130, 57, 0} ,{167, 130, 46, 0} ,{167, 130, 222, 37} ,{167, 130, 63, 0} ,{167, 130, 226, 22} ,{167, 130, 228, 2} ,{167, 130, 54, 0} ,{167, 130, 47, 0} ,{167, 130, 55, 0} ,{167, 130, 64, 0} ,{167, 130, 60, 0} ,{167, 130, 52, 0} ,{143, 166, 226, 1} ,{195, 130, 51, 0} ,{195, 130, 230, 33} ,{195, 130, 216, 37} ,{195, 130, 58, 0} ,{195, 130, 212, 0} ,{195, 130, 89, 7} ,{195, 130, 48, 0} ,{195, 130, 56, 0} ,{195, 130, 217, 37} ,{195, 130, 151, 17} ,{195, 130, 218, 37} ,{195, 130, 219, 37} ,{195, 130, 220, 37} ,{195, 130, 221, 37} ,{195, 130, 182, 7} ,{195, 130, 57, 0} ,{195, 130, 46, 0} ,{195, 130, 222, 37} ,{195, 130, 63, 0} ,{195, 130, 226, 22} ,{195, 130, 228, 2} ,{195, 130, 54, 0} ,{195, 130, 47, 0} ,{195, 130, 55, 0} ,{195, 130, 64, 0} ,{195, 130, 60, 0} ,{195, 130, 52, 0} ,{143, 166, 230, 5} ,{223, 130, 51, 0} ,{223, 130, 230, 33} ,{223, 130, 216, 37} ,{223, 130, 58, 0} ,{223, 130, 212, 0} ,{223, 130, 89, 7} ,{223, 130, 48, 0} ,{223, 130, 56, 0} ,{223, 130, 217, 37} ,{223, 130, 151, 17} ,{223, 130, 218, 37} ,{223, 130, 219, 37} ,{223, 130, 220, 37} ,{223, 130, 221, 37} ,{223, 130, 182, 7} ,{223, 130, 57, 0} ,{223, 130, 46, 0} ,{223, 130, 222, 37} ,{223, 130, 63, 0} ,{223, 130, 226, 22} ,{223, 130, 228, 2} ,{223, 130, 54, 0} ,{223, 130, 47, 0} ,{223, 130, 55, 0} ,{223, 130, 64, 0} ,{223, 130, 60, 0} ,{223, 130, 52, 0} ,{143, 166, 170, 1} ,{251, 130, 51, 0} ,{251, 130, 230, 33} ,{251, 130, 216, 37} ,{251, 130, 58, 0} ,{251, 130, 212, 0} ,{251, 130, 89, 7} ,{251, 130, 48, 0} ,{251, 130, 56, 0} ,{251, 130, 217, 37} ,{251, 130, 151, 17} ,{251, 130, 218, 37} ,{251, 130, 219, 37} ,{251, 130, 220, 37} ,{251, 130, 221, 37} ,{251, 130, 182, 7} ,{251, 130, 57, 0} ,{251, 130, 46, 0} ,{251, 130, 222, 37} ,{251, 130, 63, 0} ,{251, 130, 226, 22} ,{251, 130, 228, 2} ,{251, 130, 54, 0} ,{251, 130, 47, 0} ,{251, 130, 55, 0} ,{251, 130, 64, 0} ,{251, 130, 60, 0} ,{251, 130, 52, 0} ,{143, 166, 110, 5} ,{23, 131, 51, 0} ,{23, 131, 230, 33} ,{23, 131, 216, 37} ,{23, 131, 58, 0} ,{23, 131, 212, 0} ,{23, 131, 89, 7} ,{23, 131, 48, 0} ,{23, 131, 56, 0} ,{23, 131, 217, 37} ,{23, 131, 151, 17} ,{23, 131, 218, 37} ,{23, 131, 219, 37} ,{23, 131, 220, 37} ,{23, 131, 221, 37} ,{23, 131, 182, 7} ,{23, 131, 57, 0} ,{23, 131, 46, 0} ,{23, 131, 222, 37} ,{23, 131, 63, 0} ,{23, 131, 226, 22} ,{23, 131, 228, 2} ,{23, 131, 54, 0} ,{23, 131, 47, 0} ,{23, 131, 55, 0} ,{23, 131, 64, 0} ,{23, 131, 60, 0} ,{23, 131, 52, 0} ,{143, 166, 141, 1} ,{51, 131, 51, 0} ,{51, 131, 230, 33} ,{51, 131, 216, 37} ,{51, 131, 58, 0} ,{51, 131, 212, 0} ,{51, 131, 89, 7} ,{51, 131, 48, 0} ,{51, 131, 56, 0} ,{51, 131, 217, 37} ,{51, 131, 151, 17} ,{51, 131, 218, 37} ,{51, 131, 219, 37} ,{51, 131, 220, 37} ,{51, 131, 221, 37} ,{51, 131, 182, 7} ,{51, 131, 57, 0} ,{51, 131, 46, 0} ,{51, 131, 222, 37} ,{51, 131, 63, 0} ,{51, 131, 226, 22} ,{51, 131, 228, 2} ,{51, 131, 54, 0} ,{51, 131, 47, 0} ,{51, 131, 55, 0} ,{51, 131, 64, 0} ,{51, 131, 60, 0} ,{51, 131, 52, 0} ,{143, 166, 53, 0} ,{79, 131, 51, 0} ,{79, 131, 230, 33} ,{79, 131, 216, 37} ,{79, 131, 58, 0} ,{79, 131, 212, 0} ,{79, 131, 89, 7} ,{79, 131, 48, 0} ,{79, 131, 56, 0} ,{79, 131, 217, 37} ,{79, 131, 151, 17} ,{79, 131, 218, 37} ,{79, 131, 219, 37} ,{79, 131, 220, 37} ,{79, 131, 221, 37} ,{79, 131, 182, 7} ,{79, 131, 57, 0} ,{79, 131, 46, 0} ,{79, 131, 222, 37} ,{79, 131, 63, 0} ,{79, 131, 226, 22} ,{79, 131, 228, 2} ,{79, 131, 54, 0} ,{79, 131, 47, 0} ,{79, 131, 55, 0} ,{79, 131, 64, 0} ,{79, 131, 60, 0} ,{79, 131, 52, 0} ,{144, 166, 45, 0} ,{107, 131, 51, 0} ,{107, 131, 230, 33} ,{107, 131, 216, 37} ,{107, 131, 58, 0} ,{107, 131, 212, 0} ,{107, 131, 89, 7} ,{107, 131, 48, 0} ,{107, 131, 56, 0} ,{107, 131, 217, 37} ,{107, 131, 151, 17} ,{107, 131, 218, 37} ,{107, 131, 219, 37} ,{107, 131, 220, 37} ,{107, 131, 221, 37} ,{107, 131, 182, 7} ,{107, 131, 57, 0} ,{107, 131, 46, 0} ,{107, 131, 222, 37} ,{107, 131, 63, 0} ,{107, 131, 226, 22} ,{107, 131, 228, 2} ,{107, 131, 54, 0} ,{107, 131, 47, 0} ,{107, 131, 55, 0} ,{107, 131, 64, 0} ,{107, 131, 60, 0} ,{107, 131, 52, 0} ,{144, 166, 133, 0} ,{135, 131, 51, 0} ,{135, 131, 230, 33} ,{135, 131, 216, 37} ,{135, 131, 58, 0} ,{135, 131, 212, 0} ,{135, 131, 89, 7} ,{135, 131, 48, 0} ,{135, 131, 56, 0} ,{135, 131, 217, 37} ,{135, 131, 151, 17} ,{135, 131, 218, 37} ,{135, 131, 219, 37} ,{135, 131, 220, 37} ,{135, 131, 221, 37} ,{135, 131, 182, 7} ,{135, 131, 57, 0} ,{135, 131, 46, 0} ,{135, 131, 222, 37} ,{135, 131, 63, 0} ,{135, 131, 226, 22} ,{135, 131, 228, 2} ,{135, 131, 54, 0} ,{135, 131, 47, 0} ,{135, 131, 55, 0} ,{135, 131, 64, 0} ,{135, 131, 60, 0} ,{135, 131, 52, 0} ,{144, 166, 171, 1} ,{163, 131, 51, 0} ,{163, 131, 230, 33} ,{163, 131, 216, 37} ,{163, 131, 58, 0} ,{163, 131, 212, 0} ,{163, 131, 89, 7} ,{163, 131, 48, 0} ,{163, 131, 56, 0} ,{163, 131, 217, 37} ,{163, 131, 151, 17} ,{163, 131, 218, 37} ,{163, 131, 219, 37} ,{163, 131, 220, 37} ,{163, 131, 221, 37} ,{163, 131, 182, 7} ,{163, 131, 57, 0} ,{163, 131, 46, 0} ,{163, 131, 222, 37} ,{163, 131, 63, 0} ,{163, 131, 226, 22} ,{163, 131, 228, 2} ,{163, 131, 54, 0} ,{163, 131, 47, 0} ,{163, 131, 55, 0} ,{163, 131, 64, 0} ,{163, 131, 60, 0} ,{163, 131, 52, 0} ,{144, 166, 224, 1} ,{191, 131, 51, 0} ,{191, 131, 230, 33} ,{191, 131, 216, 37} ,{191, 131, 58, 0} ,{191, 131, 212, 0} ,{191, 131, 89, 7} ,{191, 131, 48, 0} ,{191, 131, 56, 0} ,{191, 131, 217, 37} ,{191, 131, 151, 17} ,{191, 131, 218, 37} ,{191, 131, 219, 37} ,{191, 131, 220, 37} ,{191, 131, 221, 37} ,{191, 131, 182, 7} ,{191, 131, 57, 0} ,{191, 131, 46, 0} ,{191, 131, 222, 37} ,{191, 131, 63, 0} ,{191, 131, 226, 22} ,{191, 131, 228, 2} ,{191, 131, 54, 0} ,{191, 131, 47, 0} ,{191, 131, 55, 0} ,{191, 131, 64, 0} ,{191, 131, 60, 0} ,{191, 131, 52, 0} ,{144, 166, 225, 5} ,{219, 131, 51, 0} ,{219, 131, 230, 33} ,{219, 131, 216, 37} ,{219, 131, 58, 0} ,{219, 131, 212, 0} ,{219, 131, 89, 7} ,{219, 131, 48, 0} ,{219, 131, 56, 0} ,{219, 131, 217, 37} ,{219, 131, 151, 17} ,{219, 131, 218, 37} ,{219, 131, 219, 37} ,{219, 131, 220, 37} ,{219, 131, 221, 37} ,{219, 131, 182, 7} ,{219, 131, 57, 0} ,{219, 131, 46, 0} ,{219, 131, 222, 37} ,{219, 131, 63, 0} ,{219, 131, 226, 22} ,{219, 131, 228, 2} ,{219, 131, 54, 0} ,{219, 131, 47, 0} ,{219, 131, 55, 0} ,{219, 131, 64, 0} ,{219, 131, 60, 0} ,{219, 131, 52, 0} ,{144, 166, 49, 0} ,{247, 131, 51, 0} ,{247, 131, 230, 33} ,{247, 131, 216, 37} ,{247, 131, 58, 0} ,{247, 131, 212, 0} ,{247, 131, 89, 7} ,{247, 131, 48, 0} ,{247, 131, 56, 0} ,{247, 131, 217, 37} ,{247, 131, 151, 17} ,{247, 131, 218, 37} ,{247, 131, 219, 37} ,{247, 131, 220, 37} ,{247, 131, 221, 37} ,{247, 131, 182, 7} ,{247, 131, 57, 0} ,{247, 131, 46, 0} ,{247, 131, 222, 37} ,{247, 131, 63, 0} ,{247, 131, 226, 22} ,{247, 131, 228, 2} ,{247, 131, 54, 0} ,{247, 131, 47, 0} ,{247, 131, 55, 0} ,{247, 131, 64, 0} ,{247, 131, 60, 0} ,{247, 131, 52, 0} ,{144, 166, 226, 5} ,{19, 132, 51, 0} ,{19, 132, 230, 33} ,{19, 132, 216, 37} ,{19, 132, 58, 0} ,{19, 132, 212, 0} ,{19, 132, 89, 7} ,{19, 132, 48, 0} ,{19, 132, 56, 0} ,{19, 132, 217, 37} ,{19, 132, 151, 17} ,{19, 132, 218, 37} ,{19, 132, 219, 37} ,{19, 132, 220, 37} ,{19, 132, 221, 37} ,{19, 132, 182, 7} ,{19, 132, 57, 0} ,{19, 132, 46, 0} ,{19, 132, 222, 37} ,{19, 132, 63, 0} ,{19, 132, 226, 22} ,{19, 132, 228, 2} ,{19, 132, 54, 0} ,{19, 132, 47, 0} ,{19, 132, 55, 0} ,{19, 132, 64, 0} ,{19, 132, 60, 0} ,{19, 132, 52, 0} ,{144, 166, 227, 5} ,{47, 132, 51, 0} ,{47, 132, 230, 33} ,{47, 132, 216, 37} ,{47, 132, 58, 0} ,{47, 132, 212, 0} ,{47, 132, 89, 7} ,{47, 132, 48, 0} ,{47, 132, 56, 0} ,{47, 132, 217, 37} ,{47, 132, 151, 17} ,{47, 132, 218, 37} ,{47, 132, 219, 37} ,{47, 132, 220, 37} ,{47, 132, 221, 37} ,{47, 132, 182, 7} ,{47, 132, 57, 0} ,{47, 132, 46, 0} ,{47, 132, 222, 37} ,{47, 132, 63, 0} ,{47, 132, 226, 22} ,{47, 132, 228, 2} ,{47, 132, 54, 0} ,{47, 132, 47, 0} ,{47, 132, 55, 0} ,{47, 132, 64, 0} ,{47, 132, 60, 0} ,{47, 132, 52, 0} ,{144, 166, 59, 0} ,{75, 132, 51, 0} ,{75, 132, 230, 33} ,{75, 132, 216, 37} ,{75, 132, 58, 0} ,{75, 132, 212, 0} ,{75, 132, 89, 7} ,{75, 132, 48, 0} ,{75, 132, 56, 0} ,{75, 132, 217, 37} ,{75, 132, 151, 17} ,{75, 132, 218, 37} ,{75, 132, 219, 37} ,{75, 132, 220, 37} ,{75, 132, 221, 37} ,{75, 132, 182, 7} ,{75, 132, 57, 0} ,{75, 132, 46, 0} ,{75, 132, 222, 37} ,{75, 132, 63, 0} ,{75, 132, 226, 22} ,{75, 132, 228, 2} ,{75, 132, 54, 0} ,{75, 132, 47, 0} ,{75, 132, 55, 0} ,{75, 132, 64, 0} ,{75, 132, 60, 0} ,{75, 132, 52, 0} ,{144, 166, 140, 3} ,{103, 132, 51, 0} ,{103, 132, 230, 33} ,{103, 132, 216, 37} ,{103, 132, 58, 0} ,{103, 132, 212, 0} ,{103, 132, 89, 7} ,{103, 132, 48, 0} ,{103, 132, 56, 0} ,{103, 132, 217, 37} ,{103, 132, 151, 17} ,{103, 132, 218, 37} ,{103, 132, 219, 37} ,{103, 132, 220, 37} ,{103, 132, 221, 37} ,{103, 132, 182, 7} ,{103, 132, 57, 0} ,{103, 132, 46, 0} ,{103, 132, 222, 37} ,{103, 132, 63, 0} ,{103, 132, 226, 22} ,{103, 132, 228, 2} ,{103, 132, 54, 0} ,{103, 132, 47, 0} ,{103, 132, 55, 0} ,{103, 132, 64, 0} ,{103, 132, 60, 0} ,{103, 132, 52, 0} ,{144, 166, 228, 5} ,{131, 132, 51, 0} ,{131, 132, 230, 33} ,{131, 132, 216, 37} ,{131, 132, 58, 0} ,{131, 132, 212, 0} ,{131, 132, 89, 7} ,{131, 132, 48, 0} ,{131, 132, 56, 0} ,{131, 132, 217, 37} ,{131, 132, 151, 17} ,{131, 132, 218, 37} ,{131, 132, 219, 37} ,{131, 132, 220, 37} ,{131, 132, 221, 37} ,{131, 132, 182, 7} ,{131, 132, 57, 0} ,{131, 132, 46, 0} ,{131, 132, 222, 37} ,{131, 132, 63, 0} ,{131, 132, 226, 22} ,{131, 132, 228, 2} ,{131, 132, 54, 0} ,{131, 132, 47, 0} ,{131, 132, 55, 0} ,{131, 132, 64, 0} ,{131, 132, 60, 0} ,{131, 132, 52, 0} ,{144, 166, 164, 0} ,{159, 132, 51, 0} ,{159, 132, 230, 33} ,{159, 132, 216, 37} ,{159, 132, 58, 0} ,{159, 132, 212, 0} ,{159, 132, 89, 7} ,{159, 132, 48, 0} ,{159, 132, 56, 0} ,{159, 132, 217, 37} ,{159, 132, 151, 17} ,{159, 132, 218, 37} ,{159, 132, 219, 37} ,{159, 132, 220, 37} ,{159, 132, 221, 37} ,{159, 132, 182, 7} ,{159, 132, 57, 0} ,{159, 132, 46, 0} ,{159, 132, 222, 37} ,{159, 132, 63, 0} ,{159, 132, 226, 22} ,{159, 132, 228, 2} ,{159, 132, 54, 0} ,{159, 132, 47, 0} ,{159, 132, 55, 0} ,{159, 132, 64, 0} ,{159, 132, 60, 0} ,{159, 132, 52, 0} ,{144, 166, 204, 4} ,{187, 132, 51, 0} ,{187, 132, 230, 33} ,{187, 132, 216, 37} ,{187, 132, 58, 0} ,{187, 132, 212, 0} ,{187, 132, 89, 7} ,{187, 132, 48, 0} ,{187, 132, 56, 0} ,{187, 132, 217, 37} ,{187, 132, 151, 17} ,{187, 132, 218, 37} ,{187, 132, 219, 37} ,{187, 132, 220, 37} ,{187, 132, 221, 37} ,{187, 132, 182, 7} ,{187, 132, 57, 0} ,{187, 132, 46, 0} ,{187, 132, 222, 37} ,{187, 132, 63, 0} ,{187, 132, 226, 22} ,{187, 132, 228, 2} ,{187, 132, 54, 0} ,{187, 132, 47, 0} ,{187, 132, 55, 0} ,{187, 132, 64, 0} ,{187, 132, 60, 0} ,{187, 132, 52, 0} ,{144, 166, 65, 0} ,{215, 132, 51, 0} ,{215, 132, 230, 33} ,{215, 132, 216, 37} ,{215, 132, 58, 0} ,{215, 132, 212, 0} ,{215, 132, 89, 7} ,{215, 132, 48, 0} ,{215, 132, 56, 0} ,{215, 132, 217, 37} ,{215, 132, 151, 17} ,{215, 132, 218, 37} ,{215, 132, 219, 37} ,{215, 132, 220, 37} ,{215, 132, 221, 37} ,{215, 132, 182, 7} ,{215, 132, 57, 0} ,{215, 132, 46, 0} ,{215, 132, 222, 37} ,{215, 132, 63, 0} ,{215, 132, 226, 22} ,{215, 132, 228, 2} ,{215, 132, 54, 0} ,{215, 132, 47, 0} ,{215, 132, 55, 0} ,{215, 132, 64, 0} ,{215, 132, 60, 0} ,{215, 132, 52, 0} ,{144, 166, 229, 5} ,{243, 132, 51, 0} ,{243, 132, 230, 33} ,{243, 132, 216, 37} ,{243, 132, 58, 0} ,{243, 132, 212, 0} ,{243, 132, 89, 7} ,{243, 132, 48, 0} ,{243, 132, 56, 0} ,{243, 132, 217, 37} ,{243, 132, 151, 17} ,{243, 132, 218, 37} ,{243, 132, 219, 37} ,{243, 132, 220, 37} ,{243, 132, 221, 37} ,{243, 132, 182, 7} ,{243, 132, 57, 0} ,{243, 132, 46, 0} ,{243, 132, 222, 37} ,{243, 132, 63, 0} ,{243, 132, 226, 22} ,{243, 132, 228, 2} ,{243, 132, 54, 0} ,{243, 132, 47, 0} ,{243, 132, 55, 0} ,{243, 132, 64, 0} ,{243, 132, 60, 0} ,{243, 132, 52, 0} ,{144, 166, 226, 1} ,{15, 133, 51, 0} ,{15, 133, 230, 33} ,{15, 133, 216, 37} ,{15, 133, 58, 0} ,{15, 133, 212, 0} ,{15, 133, 89, 7} ,{15, 133, 48, 0} ,{15, 133, 56, 0} ,{15, 133, 217, 37} ,{15, 133, 151, 17} ,{15, 133, 218, 37} ,{15, 133, 219, 37} ,{15, 133, 220, 37} ,{15, 133, 221, 37} ,{15, 133, 182, 7} ,{15, 133, 57, 0} ,{15, 133, 46, 0} ,{15, 133, 222, 37} ,{15, 133, 63, 0} ,{15, 133, 226, 22} ,{15, 133, 228, 2} ,{15, 133, 54, 0} ,{15, 133, 47, 0} ,{15, 133, 55, 0} ,{15, 133, 64, 0} ,{15, 133, 60, 0} ,{15, 133, 52, 0} ,{144, 166, 230, 5} ,{43, 133, 51, 0} ,{43, 133, 230, 33} ,{43, 133, 216, 37} ,{43, 133, 58, 0} ,{43, 133, 212, 0} ,{43, 133, 89, 7} ,{43, 133, 48, 0} ,{43, 133, 56, 0} ,{43, 133, 217, 37} ,{43, 133, 151, 17} ,{43, 133, 218, 37} ,{43, 133, 219, 37} ,{43, 133, 220, 37} ,{43, 133, 221, 37} ,{43, 133, 182, 7} ,{43, 133, 57, 0} ,{43, 133, 46, 0} ,{43, 133, 222, 37} ,{43, 133, 63, 0} ,{43, 133, 226, 22} ,{43, 133, 228, 2} ,{43, 133, 54, 0} ,{43, 133, 47, 0} ,{43, 133, 55, 0} ,{43, 133, 64, 0} ,{43, 133, 60, 0} ,{43, 133, 52, 0} ,{144, 166, 170, 1} ,{71, 133, 51, 0} ,{71, 133, 230, 33} ,{71, 133, 216, 37} ,{71, 133, 58, 0} ,{71, 133, 212, 0} ,{71, 133, 89, 7} ,{71, 133, 48, 0} ,{71, 133, 56, 0} ,{71, 133, 217, 37} ,{71, 133, 151, 17} ,{71, 133, 218, 37} ,{71, 133, 219, 37} ,{71, 133, 220, 37} ,{71, 133, 221, 37} ,{71, 133, 182, 7} ,{71, 133, 57, 0} ,{71, 133, 46, 0} ,{71, 133, 222, 37} ,{71, 133, 63, 0} ,{71, 133, 226, 22} ,{71, 133, 228, 2} ,{71, 133, 54, 0} ,{71, 133, 47, 0} ,{71, 133, 55, 0} ,{71, 133, 64, 0} ,{71, 133, 60, 0} ,{71, 133, 52, 0} ,{144, 166, 110, 5} ,{99, 133, 51, 0} ,{99, 133, 230, 33} ,{99, 133, 216, 37} ,{99, 133, 58, 0} ,{99, 133, 212, 0} ,{99, 133, 89, 7} ,{99, 133, 48, 0} ,{99, 133, 56, 0} ,{99, 133, 217, 37} ,{99, 133, 151, 17} ,{99, 133, 218, 37} ,{99, 133, 219, 37} ,{99, 133, 220, 37} ,{99, 133, 221, 37} ,{99, 133, 182, 7} ,{99, 133, 57, 0} ,{99, 133, 46, 0} ,{99, 133, 222, 37} ,{99, 133, 63, 0} ,{99, 133, 226, 22} ,{99, 133, 228, 2} ,{99, 133, 54, 0} ,{99, 133, 47, 0} ,{99, 133, 55, 0} ,{99, 133, 64, 0} ,{99, 133, 60, 0} ,{99, 133, 52, 0} ,{144, 166, 141, 1} ,{127, 133, 51, 0} ,{127, 133, 230, 33} ,{127, 133, 216, 37} ,{127, 133, 58, 0} ,{127, 133, 212, 0} ,{127, 133, 89, 7} ,{127, 133, 48, 0} ,{127, 133, 56, 0} ,{127, 133, 217, 37} ,{127, 133, 151, 17} ,{127, 133, 218, 37} ,{127, 133, 219, 37} ,{127, 133, 220, 37} ,{127, 133, 221, 37} ,{127, 133, 182, 7} ,{127, 133, 57, 0} ,{127, 133, 46, 0} ,{127, 133, 222, 37} ,{127, 133, 63, 0} ,{127, 133, 226, 22} ,{127, 133, 228, 2} ,{127, 133, 54, 0} ,{127, 133, 47, 0} ,{127, 133, 55, 0} ,{127, 133, 64, 0} ,{127, 133, 60, 0} ,{127, 133, 52, 0} ,{144, 166, 53, 0} ,{155, 133, 51, 0} ,{155, 133, 230, 33} ,{155, 133, 216, 37} ,{155, 133, 58, 0} ,{155, 133, 212, 0} ,{155, 133, 89, 7} ,{155, 133, 48, 0} ,{155, 133, 56, 0} ,{155, 133, 217, 37} ,{155, 133, 151, 17} ,{155, 133, 218, 37} ,{155, 133, 219, 37} ,{155, 133, 220, 37} ,{155, 133, 221, 37} ,{155, 133, 182, 7} ,{155, 133, 57, 0} ,{155, 133, 46, 0} ,{155, 133, 222, 37} ,{155, 133, 63, 0} ,{155, 133, 226, 22} ,{155, 133, 228, 2} ,{155, 133, 54, 0} ,{155, 133, 47, 0} ,{155, 133, 55, 0} ,{155, 133, 64, 0} ,{155, 133, 60, 0} ,{155, 133, 52, 0} ,{145, 166, 45, 0} ,{183, 133, 51, 0} ,{183, 133, 230, 33} ,{183, 133, 216, 37} ,{183, 133, 58, 0} ,{183, 133, 212, 0} ,{183, 133, 89, 7} ,{183, 133, 48, 0} ,{183, 133, 56, 0} ,{183, 133, 217, 37} ,{183, 133, 151, 17} ,{183, 133, 218, 37} ,{183, 133, 219, 37} ,{183, 133, 220, 37} ,{183, 133, 221, 37} ,{183, 133, 182, 7} ,{183, 133, 57, 0} ,{183, 133, 46, 0} ,{183, 133, 222, 37} ,{183, 133, 63, 0} ,{183, 133, 226, 22} ,{183, 133, 228, 2} ,{183, 133, 54, 0} ,{183, 133, 47, 0} ,{183, 133, 55, 0} ,{183, 133, 64, 0} ,{183, 133, 60, 0} ,{183, 133, 52, 0} ,{145, 166, 133, 0} ,{211, 133, 51, 0} ,{211, 133, 230, 33} ,{211, 133, 216, 37} ,{211, 133, 58, 0} ,{211, 133, 212, 0} ,{211, 133, 89, 7} ,{211, 133, 48, 0} ,{211, 133, 56, 0} ,{211, 133, 217, 37} ,{211, 133, 151, 17} ,{211, 133, 218, 37} ,{211, 133, 219, 37} ,{211, 133, 220, 37} ,{211, 133, 221, 37} ,{211, 133, 182, 7} ,{211, 133, 57, 0} ,{211, 133, 46, 0} ,{211, 133, 222, 37} ,{211, 133, 63, 0} ,{211, 133, 226, 22} ,{211, 133, 228, 2} ,{211, 133, 54, 0} ,{211, 133, 47, 0} ,{211, 133, 55, 0} ,{211, 133, 64, 0} ,{211, 133, 60, 0} ,{211, 133, 52, 0} ,{145, 166, 171, 1} ,{239, 133, 51, 0} ,{239, 133, 230, 33} ,{239, 133, 216, 37} ,{239, 133, 58, 0} ,{239, 133, 212, 0} ,{239, 133, 89, 7} ,{239, 133, 48, 0} ,{239, 133, 56, 0} ,{239, 133, 217, 37} ,{239, 133, 151, 17} ,{239, 133, 218, 37} ,{239, 133, 219, 37} ,{239, 133, 220, 37} ,{239, 133, 221, 37} ,{239, 133, 182, 7} ,{239, 133, 57, 0} ,{239, 133, 46, 0} ,{239, 133, 222, 37} ,{239, 133, 63, 0} ,{239, 133, 226, 22} ,{239, 133, 228, 2} ,{239, 133, 54, 0} ,{239, 133, 47, 0} ,{239, 133, 55, 0} ,{239, 133, 64, 0} ,{239, 133, 60, 0} ,{239, 133, 52, 0} ,{145, 166, 224, 1} ,{11, 134, 51, 0} ,{11, 134, 230, 33} ,{11, 134, 216, 37} ,{11, 134, 58, 0} ,{11, 134, 212, 0} ,{11, 134, 89, 7} ,{11, 134, 48, 0} ,{11, 134, 56, 0} ,{11, 134, 217, 37} ,{11, 134, 151, 17} ,{11, 134, 218, 37} ,{11, 134, 219, 37} ,{11, 134, 220, 37} ,{11, 134, 221, 37} ,{11, 134, 182, 7} ,{11, 134, 57, 0} ,{11, 134, 46, 0} ,{11, 134, 222, 37} ,{11, 134, 63, 0} ,{11, 134, 226, 22} ,{11, 134, 228, 2} ,{11, 134, 54, 0} ,{11, 134, 47, 0} ,{11, 134, 55, 0} ,{11, 134, 64, 0} ,{11, 134, 60, 0} ,{11, 134, 52, 0} ,{145, 166, 225, 5} ,{39, 134, 51, 0} ,{39, 134, 230, 33} ,{39, 134, 216, 37} ,{39, 134, 58, 0} ,{39, 134, 212, 0} ,{39, 134, 89, 7} ,{39, 134, 48, 0} ,{39, 134, 56, 0} ,{39, 134, 217, 37} ,{39, 134, 151, 17} ,{39, 134, 218, 37} ,{39, 134, 219, 37} ,{39, 134, 220, 37} ,{39, 134, 221, 37} ,{39, 134, 182, 7} ,{39, 134, 57, 0} ,{39, 134, 46, 0} ,{39, 134, 222, 37} ,{39, 134, 63, 0} ,{39, 134, 226, 22} ,{39, 134, 228, 2} ,{39, 134, 54, 0} ,{39, 134, 47, 0} ,{39, 134, 55, 0} ,{39, 134, 64, 0} ,{39, 134, 60, 0} ,{39, 134, 52, 0} ,{145, 166, 49, 0} ,{67, 134, 51, 0} ,{67, 134, 230, 33} ,{67, 134, 216, 37} ,{67, 134, 58, 0} ,{67, 134, 212, 0} ,{67, 134, 89, 7} ,{67, 134, 48, 0} ,{67, 134, 56, 0} ,{67, 134, 217, 37} ,{67, 134, 151, 17} ,{67, 134, 218, 37} ,{67, 134, 219, 37} ,{67, 134, 220, 37} ,{67, 134, 221, 37} ,{67, 134, 182, 7} ,{67, 134, 57, 0} ,{67, 134, 46, 0} ,{67, 134, 222, 37} ,{67, 134, 63, 0} ,{67, 134, 226, 22} ,{67, 134, 228, 2} ,{67, 134, 54, 0} ,{67, 134, 47, 0} ,{67, 134, 55, 0} ,{67, 134, 64, 0} ,{67, 134, 60, 0} ,{67, 134, 52, 0} ,{145, 166, 226, 5} ,{95, 134, 51, 0} ,{95, 134, 230, 33} ,{95, 134, 216, 37} ,{95, 134, 58, 0} ,{95, 134, 212, 0} ,{95, 134, 89, 7} ,{95, 134, 48, 0} ,{95, 134, 56, 0} ,{95, 134, 217, 37} ,{95, 134, 151, 17} ,{95, 134, 218, 37} ,{95, 134, 219, 37} ,{95, 134, 220, 37} ,{95, 134, 221, 37} ,{95, 134, 182, 7} ,{95, 134, 57, 0} ,{95, 134, 46, 0} ,{95, 134, 222, 37} ,{95, 134, 63, 0} ,{95, 134, 226, 22} ,{95, 134, 228, 2} ,{95, 134, 54, 0} ,{95, 134, 47, 0} ,{95, 134, 55, 0} ,{95, 134, 64, 0} ,{95, 134, 60, 0} ,{95, 134, 52, 0} ,{145, 166, 227, 5} ,{123, 134, 51, 0} ,{123, 134, 230, 33} ,{123, 134, 216, 37} ,{123, 134, 58, 0} ,{123, 134, 212, 0} ,{123, 134, 89, 7} ,{123, 134, 48, 0} ,{123, 134, 56, 0} ,{123, 134, 217, 37} ,{123, 134, 151, 17} ,{123, 134, 218, 37} ,{123, 134, 219, 37} ,{123, 134, 220, 37} ,{123, 134, 221, 37} ,{123, 134, 182, 7} ,{123, 134, 57, 0} ,{123, 134, 46, 0} ,{123, 134, 222, 37} ,{123, 134, 63, 0} ,{123, 134, 226, 22} ,{123, 134, 228, 2} ,{123, 134, 54, 0} ,{123, 134, 47, 0} ,{123, 134, 55, 0} ,{123, 134, 64, 0} ,{123, 134, 60, 0} ,{123, 134, 52, 0} ,{145, 166, 59, 0} ,{151, 134, 51, 0} ,{151, 134, 230, 33} ,{151, 134, 216, 37} ,{151, 134, 58, 0} ,{151, 134, 212, 0} ,{151, 134, 89, 7} ,{151, 134, 48, 0} ,{151, 134, 56, 0} ,{151, 134, 217, 37} ,{151, 134, 151, 17} ,{151, 134, 218, 37} ,{151, 134, 219, 37} ,{151, 134, 220, 37} ,{151, 134, 221, 37} ,{151, 134, 182, 7} ,{151, 134, 57, 0} ,{151, 134, 46, 0} ,{151, 134, 222, 37} ,{151, 134, 63, 0} ,{151, 134, 226, 22} ,{151, 134, 228, 2} ,{151, 134, 54, 0} ,{151, 134, 47, 0} ,{151, 134, 55, 0} ,{151, 134, 64, 0} ,{151, 134, 60, 0} ,{151, 134, 52, 0} ,{145, 166, 140, 3} ,{179, 134, 51, 0} ,{179, 134, 230, 33} ,{179, 134, 216, 37} ,{179, 134, 58, 0} ,{179, 134, 212, 0} ,{179, 134, 89, 7} ,{179, 134, 48, 0} ,{179, 134, 56, 0} ,{179, 134, 217, 37} ,{179, 134, 151, 17} ,{179, 134, 218, 37} ,{179, 134, 219, 37} ,{179, 134, 220, 37} ,{179, 134, 221, 37} ,{179, 134, 182, 7} ,{179, 134, 57, 0} ,{179, 134, 46, 0} ,{179, 134, 222, 37} ,{179, 134, 63, 0} ,{179, 134, 226, 22} ,{179, 134, 228, 2} ,{179, 134, 54, 0} ,{179, 134, 47, 0} ,{179, 134, 55, 0} ,{179, 134, 64, 0} ,{179, 134, 60, 0} ,{179, 134, 52, 0} ,{145, 166, 228, 5} ,{207, 134, 51, 0} ,{207, 134, 230, 33} ,{207, 134, 216, 37} ,{207, 134, 58, 0} ,{207, 134, 212, 0} ,{207, 134, 89, 7} ,{207, 134, 48, 0} ,{207, 134, 56, 0} ,{207, 134, 217, 37} ,{207, 134, 151, 17} ,{207, 134, 218, 37} ,{207, 134, 219, 37} ,{207, 134, 220, 37} ,{207, 134, 221, 37} ,{207, 134, 182, 7} ,{207, 134, 57, 0} ,{207, 134, 46, 0} ,{207, 134, 222, 37} ,{207, 134, 63, 0} ,{207, 134, 226, 22} ,{207, 134, 228, 2} ,{207, 134, 54, 0} ,{207, 134, 47, 0} ,{207, 134, 55, 0} ,{207, 134, 64, 0} ,{207, 134, 60, 0} ,{207, 134, 52, 0} ,{145, 166, 164, 0} ,{235, 134, 51, 0} ,{235, 134, 230, 33} ,{235, 134, 216, 37} ,{235, 134, 58, 0} ,{235, 134, 212, 0} ,{235, 134, 89, 7} ,{235, 134, 48, 0} ,{235, 134, 56, 0} ,{235, 134, 217, 37} ,{235, 134, 151, 17} ,{235, 134, 218, 37} ,{235, 134, 219, 37} ,{235, 134, 220, 37} ,{235, 134, 221, 37} ,{235, 134, 182, 7} ,{235, 134, 57, 0} ,{235, 134, 46, 0} ,{235, 134, 222, 37} ,{235, 134, 63, 0} ,{235, 134, 226, 22} ,{235, 134, 228, 2} ,{235, 134, 54, 0} ,{235, 134, 47, 0} ,{235, 134, 55, 0} ,{235, 134, 64, 0} ,{235, 134, 60, 0} ,{235, 134, 52, 0} ,{145, 166, 204, 4} ,{7, 135, 51, 0} ,{7, 135, 230, 33} ,{7, 135, 216, 37} ,{7, 135, 58, 0} ,{7, 135, 212, 0} ,{7, 135, 89, 7} ,{7, 135, 48, 0} ,{7, 135, 56, 0} ,{7, 135, 217, 37} ,{7, 135, 151, 17} ,{7, 135, 218, 37} ,{7, 135, 219, 37} ,{7, 135, 220, 37} ,{7, 135, 221, 37} ,{7, 135, 182, 7} ,{7, 135, 57, 0} ,{7, 135, 46, 0} ,{7, 135, 222, 37} ,{7, 135, 63, 0} ,{7, 135, 226, 22} ,{7, 135, 228, 2} ,{7, 135, 54, 0} ,{7, 135, 47, 0} ,{7, 135, 55, 0} ,{7, 135, 64, 0} ,{7, 135, 60, 0} ,{7, 135, 52, 0} ,{145, 166, 65, 0} ,{35, 135, 51, 0} ,{35, 135, 230, 33} ,{35, 135, 216, 37} ,{35, 135, 58, 0} ,{35, 135, 212, 0} ,{35, 135, 89, 7} ,{35, 135, 48, 0} ,{35, 135, 56, 0} ,{35, 135, 217, 37} ,{35, 135, 151, 17} ,{35, 135, 218, 37} ,{35, 135, 219, 37} ,{35, 135, 220, 37} ,{35, 135, 221, 37} ,{35, 135, 182, 7} ,{35, 135, 57, 0} ,{35, 135, 46, 0} ,{35, 135, 222, 37} ,{35, 135, 63, 0} ,{35, 135, 226, 22} ,{35, 135, 228, 2} ,{35, 135, 54, 0} ,{35, 135, 47, 0} ,{35, 135, 55, 0} ,{35, 135, 64, 0} ,{35, 135, 60, 0} ,{35, 135, 52, 0} ,{145, 166, 229, 5} ,{63, 135, 51, 0} ,{63, 135, 230, 33} ,{63, 135, 216, 37} ,{63, 135, 58, 0} ,{63, 135, 212, 0} ,{63, 135, 89, 7} ,{63, 135, 48, 0} ,{63, 135, 56, 0} ,{63, 135, 217, 37} ,{63, 135, 151, 17} ,{63, 135, 218, 37} ,{63, 135, 219, 37} ,{63, 135, 220, 37} ,{63, 135, 221, 37} ,{63, 135, 182, 7} ,{63, 135, 57, 0} ,{63, 135, 46, 0} ,{63, 135, 222, 37} ,{63, 135, 63, 0} ,{63, 135, 226, 22} ,{63, 135, 228, 2} ,{63, 135, 54, 0} ,{63, 135, 47, 0} ,{63, 135, 55, 0} ,{63, 135, 64, 0} ,{63, 135, 60, 0} ,{63, 135, 52, 0} ,{145, 166, 226, 1} ,{91, 135, 51, 0} ,{91, 135, 230, 33} ,{91, 135, 216, 37} ,{91, 135, 58, 0} ,{91, 135, 212, 0} ,{91, 135, 89, 7} ,{91, 135, 48, 0} ,{91, 135, 56, 0} ,{91, 135, 217, 37} ,{91, 135, 151, 17} ,{91, 135, 218, 37} ,{91, 135, 219, 37} ,{91, 135, 220, 37} ,{91, 135, 221, 37} ,{91, 135, 182, 7} ,{91, 135, 57, 0} ,{91, 135, 46, 0} ,{91, 135, 222, 37} ,{91, 135, 63, 0} ,{91, 135, 226, 22} ,{91, 135, 228, 2} ,{91, 135, 54, 0} ,{91, 135, 47, 0} ,{91, 135, 55, 0} ,{91, 135, 64, 0} ,{91, 135, 60, 0} ,{91, 135, 52, 0} ,{145, 166, 230, 5} ,{119, 135, 51, 0} ,{119, 135, 230, 33} ,{119, 135, 216, 37} ,{119, 135, 58, 0} ,{119, 135, 212, 0} ,{119, 135, 89, 7} ,{119, 135, 48, 0} ,{119, 135, 56, 0} ,{119, 135, 217, 37} ,{119, 135, 151, 17} ,{119, 135, 218, 37} ,{119, 135, 219, 37} ,{119, 135, 220, 37} ,{119, 135, 221, 37} ,{119, 135, 182, 7} ,{119, 135, 57, 0} ,{119, 135, 46, 0} ,{119, 135, 222, 37} ,{119, 135, 63, 0} ,{119, 135, 226, 22} ,{119, 135, 228, 2} ,{119, 135, 54, 0} ,{119, 135, 47, 0} ,{119, 135, 55, 0} ,{119, 135, 64, 0} ,{119, 135, 60, 0} ,{119, 135, 52, 0} ,{145, 166, 170, 1} ,{147, 135, 51, 0} ,{147, 135, 230, 33} ,{147, 135, 216, 37} ,{147, 135, 58, 0} ,{147, 135, 212, 0} ,{147, 135, 89, 7} ,{147, 135, 48, 0} ,{147, 135, 56, 0} ,{147, 135, 217, 37} ,{147, 135, 151, 17} ,{147, 135, 218, 37} ,{147, 135, 219, 37} ,{147, 135, 220, 37} ,{147, 135, 221, 37} ,{147, 135, 182, 7} ,{147, 135, 57, 0} ,{147, 135, 46, 0} ,{147, 135, 222, 37} ,{147, 135, 63, 0} ,{147, 135, 226, 22} ,{147, 135, 228, 2} ,{147, 135, 54, 0} ,{147, 135, 47, 0} ,{147, 135, 55, 0} ,{147, 135, 64, 0} ,{147, 135, 60, 0} ,{147, 135, 52, 0} ,{145, 166, 110, 5} ,{175, 135, 51, 0} ,{175, 135, 230, 33} ,{175, 135, 216, 37} ,{175, 135, 58, 0} ,{175, 135, 212, 0} ,{175, 135, 89, 7} ,{175, 135, 48, 0} ,{175, 135, 56, 0} ,{175, 135, 217, 37} ,{175, 135, 151, 17} ,{175, 135, 218, 37} ,{175, 135, 219, 37} ,{175, 135, 220, 37} ,{175, 135, 221, 37} ,{175, 135, 182, 7} ,{175, 135, 57, 0} ,{175, 135, 46, 0} ,{175, 135, 222, 37} ,{175, 135, 63, 0} ,{175, 135, 226, 22} ,{175, 135, 228, 2} ,{175, 135, 54, 0} ,{175, 135, 47, 0} ,{175, 135, 55, 0} ,{175, 135, 64, 0} ,{175, 135, 60, 0} ,{175, 135, 52, 0} ,{145, 166, 141, 1} ,{203, 135, 51, 0} ,{203, 135, 230, 33} ,{203, 135, 216, 37} ,{203, 135, 58, 0} ,{203, 135, 212, 0} ,{203, 135, 89, 7} ,{203, 135, 48, 0} ,{203, 135, 56, 0} ,{203, 135, 217, 37} ,{203, 135, 151, 17} ,{203, 135, 218, 37} ,{203, 135, 219, 37} ,{203, 135, 220, 37} ,{203, 135, 221, 37} ,{203, 135, 182, 7} ,{203, 135, 57, 0} ,{203, 135, 46, 0} ,{203, 135, 222, 37} ,{203, 135, 63, 0} ,{203, 135, 226, 22} ,{203, 135, 228, 2} ,{203, 135, 54, 0} ,{203, 135, 47, 0} ,{203, 135, 55, 0} ,{203, 135, 64, 0} ,{203, 135, 60, 0} ,{203, 135, 52, 0} ,{145, 166, 53, 0} ,{231, 135, 51, 0} ,{231, 135, 230, 33} ,{231, 135, 216, 37} ,{231, 135, 58, 0} ,{231, 135, 212, 0} ,{231, 135, 89, 7} ,{231, 135, 48, 0} ,{231, 135, 56, 0} ,{231, 135, 217, 37} ,{231, 135, 151, 17} ,{231, 135, 218, 37} ,{231, 135, 219, 37} ,{231, 135, 220, 37} ,{231, 135, 221, 37} ,{231, 135, 182, 7} ,{231, 135, 57, 0} ,{231, 135, 46, 0} ,{231, 135, 222, 37} ,{231, 135, 63, 0} ,{231, 135, 226, 22} ,{231, 135, 228, 2} ,{231, 135, 54, 0} ,{231, 135, 47, 0} ,{231, 135, 55, 0} ,{231, 135, 64, 0} ,{231, 135, 60, 0} ,{231, 135, 52, 0} ,{105, 169, 226, 5} ,{105, 169, 59, 177} ,{188, 169, 45, 0} ,{188, 169, 133, 0} ,{188, 169, 225, 5} ,{2, 170, 226, 5} ,{162, 183, 53, 0} ,{106, 169, 133, 0} ,{106, 169, 59, 0} ,{127, 170, 45, 0} ,{127, 170, 225, 5} ,{127, 170, 49, 0} ,{127, 170, 59, 0} ,{163, 183, 59, 0} ,{125, 168, 224, 1} ,{125, 168, 226, 5} ,{125, 168, 227, 5} ,{125, 168, 59, 177} ,{125, 168, 204, 4} ,{125, 168, 170, 1} ,{125, 168, 53, 0} ,{252, 170, 45, 0} ,{252, 170, 49, 0} ,{107, 169, 176, 5} ,{107, 169, 185, 5} ,{176, 166, 175, 5} ,{164, 183, 178, 5} ,{189, 169, 178, 5} ,{189, 169, 180, 5} ,{189, 169, 127, 173} ,{189, 169, 183, 5} ,{189, 169, 185, 5} ,{189, 169, 187, 5} ,{157, 167, 172, 5} ,{165, 183, 189, 5} ,{166, 183, 186, 5} ,{128, 173, 189, 5} ,{24, 172, 174, 5} ,{24, 172, 188, 5} ,{157, 167, 209, 5} ,{167, 183, 189, 5} ,{176, 166, 195, 5} ,{188, 168, 173, 5} ,{188, 168, 191, 5} ,{176, 166, 27, 23} ,{188, 168, 164, 173} ,{188, 168, 183, 5} ,{34, 169, 174, 5} ,{168, 183, 188, 5} ,{34, 169, 177, 5} ,{176, 166, 179, 5} ,{34, 169, 60, 177} ,{34, 169, 183, 5} ,{34, 169, 185, 5} ,{217, 168, 177, 5} ,{217, 168, 200, 5} ,{61, 177, 171, 5} ,{61, 177, 174, 5} ,{217, 168, 206, 5} ,{217, 168, 183, 5} ,{217, 168, 185, 5} ,{217, 168, 187, 5} ,{217, 168, 189, 5} ,{62, 177, 178, 5} ,{62, 177, 200, 5} ,{25, 172, 177, 5} ,{25, 172, 189, 5} ,{63, 177, 178, 5} ,{63, 177, 179, 5} ,{176, 166, 184, 5} ,{129, 173, 180, 5} ,{129, 173, 187, 5} ,{123, 166, 31, 23} ,{123, 166, 32, 23} ,{123, 166, 33, 23} ,{123, 166, 34, 23} ,{123, 166, 35, 23} ,{123, 166, 36, 23} ,{123, 166, 37, 23} ,{123, 166, 38, 23} ,{123, 166, 39, 23} ,{123, 166, 40, 23} ,{123, 166, 41, 23} ,{123, 166, 42, 23} ,{123, 166, 43, 23} ,{123, 166, 44, 23} ,{123, 166, 45, 23} ,{123, 166, 46, 23} ,{123, 166, 47, 23} ,{123, 166, 48, 23} ,{123, 166, 49, 23} ,{123, 166, 50, 23} ,{123, 166, 51, 23} ,{123, 166, 52, 23} ,{123, 166, 53, 23} ,{123, 166, 54, 23} ,{123, 166, 55, 23} ,{123, 166, 56, 23} ,{123, 166, 57, 23} ,{123, 166, 58, 23} ,{123, 166, 59, 23} ,{123, 166, 60, 23} ,{123, 166, 61, 23} ,{123, 166, 62, 23} ,{123, 166, 63, 23} ,{123, 166, 64, 23} ,{123, 166, 65, 23} ,{123, 166, 66, 23} ,{123, 166, 67, 23} ,{123, 166, 68, 23} ,{123, 166, 69, 23} ,{123, 166, 70, 23} ,{123, 166, 71, 23} ,{123, 166, 72, 23} ,{123, 166, 73, 23} ,{123, 166, 74, 23} ,{123, 166, 75, 23} ,{123, 166, 76, 23} ,{123, 166, 77, 23} ,{123, 166, 78, 23} ,{123, 166, 79, 23} ,{123, 166, 80, 23} ,{123, 166, 81, 23} ,{123, 166, 82, 23} ,{123, 166, 83, 23} ,{123, 166, 84, 23} ,{123, 166, 85, 23} ,{123, 166, 86, 23} ,{123, 166, 87, 23} ,{123, 166, 88, 23} ,{123, 166, 89, 23} ,{123, 166, 90, 23} ,{123, 166, 91, 23} ,{123, 166, 92, 23} ,{123, 166, 93, 23} ,{123, 166, 94, 23} ,{123, 166, 95, 23} ,{123, 166, 96, 23} ,{123, 166, 97, 23} ,{123, 166, 98, 23} ,{123, 166, 99, 23} ,{123, 166, 100, 23} ,{123, 166, 101, 23} ,{123, 166, 102, 23} ,{123, 166, 103, 23} ,{123, 166, 104, 23} ,{123, 166, 105, 23} ,{123, 166, 106, 23} ,{123, 166, 107, 23} ,{123, 166, 108, 23} ,{123, 166, 109, 23} ,{123, 166, 110, 23} ,{123, 166, 111, 23} ,{123, 166, 112, 23} ,{123, 166, 113, 23} ,{123, 166, 114, 23} ,{123, 166, 115, 23} ,{123, 166, 116, 23} ,{123, 166, 117, 23} ,{123, 166, 118, 23} ,{123, 166, 119, 23} ,{123, 166, 120, 23} ,{123, 166, 121, 23} ,{123, 166, 122, 23} ,{123, 166, 123, 23} ,{123, 166, 124, 23} ,{123, 166, 125, 23} ,{123, 166, 126, 23} ,{123, 166, 127, 23} ,{123, 166, 128, 23} ,{123, 166, 129, 23} ,{123, 166, 130, 23} ,{123, 166, 131, 23} ,{123, 166, 132, 23} ,{123, 166, 133, 23} ,{123, 166, 134, 23} ,{123, 166, 135, 23} ,{123, 166, 136, 23} ,{123, 166, 137, 23} ,{123, 166, 138, 23} ,{123, 166, 139, 23} ,{123, 166, 140, 23} ,{123, 166, 141, 23} ,{123, 166, 142, 23} ,{123, 166, 143, 23} ,{123, 166, 144, 23} ,{123, 166, 145, 23} ,{123, 166, 146, 23} ,{123, 166, 147, 23} ,{123, 166, 148, 23} ,{123, 166, 149, 23} ,{123, 166, 150, 23} ,{123, 166, 151, 23} ,{123, 166, 152, 23} ,{123, 166, 153, 23} ,{123, 166, 154, 23} ,{123, 166, 155, 23} ,{123, 166, 156, 23} ,{123, 166, 157, 23} ,{123, 166, 158, 23} ,{123, 166, 159, 23} ,{123, 166, 160, 23} ,{123, 166, 161, 23} ,{123, 166, 162, 23} ,{123, 166, 163, 23} ,{123, 166, 164, 23} ,{123, 166, 165, 23} ,{123, 166, 166, 23} ,{123, 166, 167, 23} ,{123, 166, 168, 23} ,{123, 166, 169, 23} ,{123, 166, 170, 23} ,{123, 166, 171, 23} ,{123, 166, 172, 23} ,{123, 166, 173, 23} ,{123, 166, 174, 23} ,{123, 166, 175, 23} ,{123, 166, 176, 23} ,{123, 166, 177, 23} ,{123, 166, 178, 23} ,{123, 166, 179, 23} ,{123, 166, 180, 23} ,{123, 166, 181, 23} ,{123, 166, 182, 23} ,{123, 166, 183, 23} ,{123, 166, 184, 23} ,{123, 166, 185, 23} ,{123, 166, 186, 23} ,{123, 166, 187, 23} ,{123, 166, 188, 23} ,{123, 166, 189, 23} ,{123, 166, 190, 23} ,{123, 166, 191, 23} ,{123, 166, 192, 23} ,{123, 166, 193, 23} ,{123, 166, 194, 23} ,{123, 166, 195, 23} ,{123, 166, 196, 23} ,{123, 166, 197, 23} ,{123, 166, 198, 23} ,{123, 166, 199, 23} ,{123, 166, 200, 23} ,{123, 166, 201, 23} ,{123, 166, 202, 23} ,{123, 166, 203, 23} ,{123, 166, 204, 23} ,{123, 166, 205, 23} ,{123, 166, 206, 23} ,{123, 166, 207, 23} ,{123, 166, 208, 23} ,{123, 166, 209, 23} ,{123, 166, 210, 23} ,{123, 166, 211, 23} ,{123, 166, 212, 23} ,{123, 166, 213, 23} ,{123, 166, 214, 23} ,{123, 166, 215, 23} ,{123, 166, 216, 23} ,{123, 166, 217, 23} ,{123, 166, 218, 23} ,{123, 166, 219, 23} ,{123, 166, 220, 23} ,{123, 166, 221, 23} ,{123, 166, 222, 23} ,{123, 166, 223, 23} ,{123, 166, 224, 23} ,{123, 166, 225, 23} ,{123, 166, 226, 23} ,{123, 166, 227, 23} ,{123, 166, 228, 23} ,{123, 166, 229, 23} ,{123, 166, 230, 23} ,{123, 166, 231, 23} ,{123, 166, 232, 23} ,{123, 166, 233, 23} ,{123, 166, 234, 23} ,{123, 166, 235, 23} ,{123, 166, 236, 23} ,{123, 166, 237, 23} ,{123, 166, 238, 23} ,{123, 166, 239, 23} ,{123, 166, 240, 23} ,{123, 166, 241, 23} ,{123, 166, 242, 23} ,{123, 166, 243, 23} ,{123, 166, 244, 23} ,{123, 166, 245, 23} ,{123, 166, 246, 23} ,{123, 166, 247, 23} ,{123, 166, 248, 23} ,{123, 166, 249, 23} ,{123, 166, 250, 23} ,{123, 166, 251, 23} ,{123, 166, 252, 23} ,{123, 166, 253, 23} ,{123, 166, 254, 23} ,{123, 166, 255, 23} ,{123, 166, 0, 24} ,{123, 166, 1, 24} ,{123, 166, 2, 24} ,{123, 166, 3, 24} ,{123, 166, 4, 24} ,{123, 166, 5, 24} ,{123, 166, 6, 24} ,{123, 166, 7, 24} ,{123, 166, 8, 24} ,{123, 166, 9, 24} ,{123, 166, 10, 24} ,{123, 166, 11, 24} ,{123, 166, 12, 24} ,{123, 166, 13, 24} ,{123, 166, 14, 24} ,{123, 166, 15, 24} ,{123, 166, 16, 24} ,{123, 166, 17, 24} ,{123, 166, 18, 24} ,{123, 166, 19, 24} ,{123, 166, 20, 24} ,{123, 166, 21, 24} ,{123, 166, 22, 24} ,{123, 166, 23, 24} ,{123, 166, 24, 24} ,{123, 166, 25, 24} ,{123, 166, 26, 24} ,{123, 166, 27, 24} ,{123, 166, 28, 24} ,{123, 166, 29, 24} ,{123, 166, 30, 24} ,{123, 166, 31, 24} ,{123, 166, 32, 24} ,{123, 166, 33, 24} ,{123, 166, 34, 24} ,{123, 166, 35, 24} ,{123, 166, 36, 24} ,{123, 166, 37, 24} ,{123, 166, 38, 24} ,{123, 166, 39, 24} ,{123, 166, 40, 24} ,{123, 166, 41, 24} ,{123, 166, 42, 24} ,{123, 166, 43, 24} ,{123, 166, 44, 24} ,{123, 166, 45, 24} ,{123, 166, 46, 24} ,{123, 166, 47, 24} ,{123, 166, 48, 24} ,{123, 166, 49, 24} ,{123, 166, 50, 24} ,{123, 166, 51, 24} ,{123, 166, 52, 24} ,{123, 166, 53, 24} ,{123, 166, 54, 24} ,{123, 166, 55, 24} ,{123, 166, 56, 24} ,{123, 166, 57, 24} ,{123, 166, 58, 24} ,{123, 166, 59, 24} ,{123, 166, 60, 24} ,{123, 166, 61, 24} ,{123, 166, 62, 24} ,{123, 166, 63, 24} ,{123, 166, 64, 24} ,{123, 166, 65, 24} ,{123, 166, 66, 24} ,{123, 166, 67, 24} ,{123, 166, 68, 24} ,{123, 166, 69, 24} ,{123, 166, 70, 24} ,{123, 166, 71, 24} ,{123, 166, 72, 24} ,{123, 166, 73, 24} ,{123, 166, 74, 24} ,{123, 166, 75, 24} ,{123, 166, 76, 24} ,{123, 166, 77, 24} ,{123, 166, 78, 24} ,{123, 166, 79, 24} ,{123, 166, 80, 24} ,{123, 166, 81, 24} ,{123, 166, 82, 24} ,{123, 166, 83, 24} ,{123, 166, 84, 24} ,{123, 166, 85, 24} ,{123, 166, 86, 24} ,{123, 166, 87, 24} ,{123, 166, 88, 24} ,{123, 166, 89, 24} ,{123, 166, 90, 24} ,{123, 166, 91, 24} ,{123, 166, 92, 24} ,{123, 166, 93, 24} ,{123, 166, 94, 24} ,{123, 166, 95, 24} ,{123, 166, 96, 24} ,{123, 166, 97, 24} ,{123, 166, 98, 24} ,{123, 166, 99, 24} ,{123, 166, 100, 24} ,{123, 166, 101, 24} ,{123, 166, 102, 24} ,{123, 166, 103, 24} ,{123, 166, 104, 24} ,{123, 166, 105, 24} ,{123, 166, 106, 24} ,{123, 166, 107, 24} ,{123, 166, 108, 24} ,{123, 166, 109, 24} ,{123, 166, 110, 24} ,{123, 166, 111, 24} ,{123, 166, 112, 24} ,{123, 166, 113, 24} ,{123, 166, 114, 24} ,{123, 166, 115, 24} ,{123, 166, 116, 24} ,{123, 166, 117, 24} ,{123, 166, 118, 24} ,{123, 166, 119, 24} ,{123, 166, 120, 24} ,{123, 166, 121, 24} ,{123, 166, 122, 24} ,{123, 166, 123, 24} ,{123, 166, 124, 24} ,{123, 166, 125, 24} ,{123, 166, 126, 24} ,{123, 166, 127, 24} ,{123, 166, 128, 24} ,{123, 166, 129, 24} ,{123, 166, 130, 24} ,{123, 166, 131, 24} ,{123, 166, 132, 24} ,{123, 166, 133, 24} ,{123, 166, 134, 24} ,{123, 166, 135, 24} ,{123, 166, 136, 24} ,{123, 166, 137, 24} ,{123, 166, 138, 24} ,{123, 166, 139, 24} ,{123, 166, 140, 24} ,{123, 166, 141, 24} ,{123, 166, 142, 24} ,{123, 166, 143, 24} ,{123, 166, 144, 24} ,{123, 166, 145, 24} ,{123, 166, 146, 24} ,{123, 166, 147, 24} ,{123, 166, 148, 24} ,{123, 166, 149, 24} ,{123, 166, 150, 24} ,{123, 166, 151, 24} ,{123, 166, 152, 24} ,{123, 166, 153, 24} ,{123, 166, 154, 24} ,{123, 166, 155, 24} ,{123, 166, 156, 24} ,{123, 166, 157, 24} ,{123, 166, 158, 24} ,{123, 166, 159, 24} ,{123, 166, 160, 24} ,{123, 166, 161, 24} ,{123, 166, 162, 24} ,{123, 166, 163, 24} ,{123, 166, 164, 24} ,{123, 166, 165, 24} ,{123, 166, 166, 24} ,{123, 166, 167, 24} ,{123, 166, 168, 24} ,{123, 166, 169, 24} ,{123, 166, 170, 24} ,{123, 166, 171, 24} ,{123, 166, 172, 24} ,{123, 166, 173, 24} ,{123, 166, 174, 24} ,{123, 166, 175, 24} ,{123, 166, 176, 24} ,{123, 166, 177, 24} ,{123, 166, 178, 24} ,{123, 166, 179, 24} ,{123, 166, 180, 24} ,{123, 166, 181, 24} ,{123, 166, 182, 24} ,{123, 166, 183, 24} ,{123, 166, 184, 24} ,{123, 166, 185, 24} ,{123, 166, 186, 24} ,{123, 166, 187, 24} ,{123, 166, 188, 24} ,{123, 166, 189, 24} ,{123, 166, 190, 24} ,{123, 166, 191, 24} ,{123, 166, 192, 24} ,{123, 166, 193, 24} ,{123, 166, 194, 24} ,{123, 166, 195, 24} ,{123, 166, 196, 24} ,{123, 166, 197, 24} ,{123, 166, 198, 24} ,{123, 166, 199, 24} ,{123, 166, 200, 24} ,{123, 166, 201, 24} ,{123, 166, 202, 24} ,{123, 166, 203, 24} ,{123, 166, 204, 24} ,{123, 166, 205, 24} ,{123, 166, 206, 24} ,{123, 166, 207, 24} ,{123, 166, 208, 24} ,{123, 166, 209, 24} ,{123, 166, 210, 24} ,{123, 166, 211, 24} ,{123, 166, 212, 24} ,{123, 166, 213, 24} ,{123, 166, 214, 24} ,{123, 166, 215, 24} ,{123, 166, 216, 24} ,{123, 166, 217, 24} ,{123, 166, 218, 24} ,{123, 166, 219, 24} ,{123, 166, 220, 24} ,{123, 166, 221, 24} ,{123, 166, 222, 24} ,{123, 166, 223, 24} ,{123, 166, 224, 24} ,{123, 166, 225, 24} ,{123, 166, 226, 24} ,{123, 166, 227, 24} ,{123, 166, 228, 24} ,{123, 166, 229, 24} ,{123, 166, 230, 24} ,{123, 166, 231, 24} ,{123, 166, 232, 24} ,{123, 166, 118, 12} ,{123, 166, 233, 24} ,{123, 166, 234, 24} ,{123, 166, 235, 24} ,{123, 166, 236, 24} ,{123, 166, 237, 24} ,{123, 166, 238, 24} ,{123, 166, 239, 24} ,{123, 166, 240, 24} ,{123, 166, 241, 24} ,{123, 166, 242, 24} ,{123, 166, 243, 24} ,{108, 169, 244, 24} ,{108, 169, 165, 3} ,{108, 169, 245, 24} ,{108, 169, 246, 24} ,{108, 169, 247, 24} ,{170, 183, 64, 0} ,{108, 169, 171, 16} ,{26, 172, 248, 1} ,{26, 172, 233, 1} ,{26, 172, 238, 1} ,{171, 183, 248, 1} ,{26, 172, 240, 1} ,{172, 183, 58, 2} ,{174, 183, 253, 24} ,{176, 183, 56, 2} ,{64, 177, 96, 2} ,{190, 169, 82, 2} ,{190, 169, 85, 2} ,{190, 169, 86, 2} ,{190, 169, 91, 2} ,{190, 169, 92, 2} ,{177, 183, 93, 2} ,{190, 169, 99, 2} ,{190, 169, 101, 2} ,{64, 177, 238, 37} ,{28, 172, 130, 173} ,{28, 172, 131, 173} ,{66, 177, 130, 173} ,{66, 177, 131, 173} ,{132, 173, 56, 2} ,{132, 173, 57, 2} ,{132, 173, 68, 2} ,{71, 177, 2, 168} ,{178, 183, 2, 168} ,{179, 183, 2, 168} ,{181, 183, 68, 2} ,{70, 177, 2, 168} ,{182, 183, 2, 168} ,{183, 183, 2, 168} ,{67, 177, 2, 168} ,{3, 170, 68, 177} ,{216, 166, 68, 177} ,{184, 183, 2, 168} ,{185, 183, 2, 168} ,{186, 183, 2, 168} ,{187, 183, 2, 168} ,{3, 170, 69, 177} ,{216, 166, 69, 177} ,{188, 183, 2, 168} ,{189, 183, 2, 168} ,{190, 183, 2, 168} ,{253, 170, 2, 168} ,{191, 183, 2, 168} ,{192, 183, 60, 2} ,{71, 177, 133, 173} ,{193, 183, 133, 173} ,{194, 183, 133, 173} ,{195, 183, 92, 2} ,{72, 177, 161, 166} ,{72, 177, 160, 166} ,{29, 172, 161, 166} ,{29, 172, 160, 166} ,{29, 172, 171, 166} ,{29, 172, 198, 166} ,{30, 172, 161, 166} ,{30, 172, 160, 166} ,{30, 172, 171, 166} ,{30, 172, 198, 166} ,{31, 172, 161, 166} ,{31, 172, 160, 166} ,{31, 172, 171, 166} ,{31, 172, 198, 166} ,{32, 172, 161, 166} ,{32, 172, 160, 166} ,{32, 172, 171, 166} ,{32, 172, 198, 166} ,{33, 172, 161, 166} ,{33, 172, 160, 166} ,{33, 172, 171, 166} ,{33, 172, 198, 166} ,{34, 172, 161, 166} ,{34, 172, 160, 166} ,{34, 172, 171, 166} ,{34, 172, 198, 166} ,{35, 172, 161, 166} ,{35, 172, 160, 166} ,{35, 172, 171, 166} ,{35, 172, 198, 166} ,{36, 172, 161, 166} ,{36, 172, 160, 166} ,{36, 172, 171, 166} ,{36, 172, 198, 166} ,{37, 172, 161, 166} ,{37, 172, 160, 166} ,{37, 172, 171, 166} ,{37, 172, 198, 166} ,{38, 172, 161, 166} ,{38, 172, 160, 166} ,{38, 172, 171, 166} ,{38, 172, 198, 166} ,{255, 170, 161, 166} ,{255, 170, 160, 166} ,{255, 170, 171, 166} ,{255, 170, 198, 166} ,{39, 172, 161, 166} ,{39, 172, 160, 166} ,{39, 172, 171, 166} ,{39, 172, 198, 166} ,{73, 177, 161, 166} ,{73, 177, 160, 166} ,{74, 177, 161, 166} ,{74, 177, 160, 166} ,{75, 177, 161, 166} ,{75, 177, 160, 166} ,{76, 177, 161, 166} ,{76, 177, 160, 166} ,{77, 177, 161, 166} ,{77, 177, 160, 166} ,{78, 177, 161, 166} ,{78, 177, 160, 166} ,{109, 169, 161, 166} ,{109, 169, 160, 166} ,{109, 169, 171, 166} ,{109, 169, 198, 166} ,{4, 170, 161, 166} ,{4, 170, 160, 166} ,{4, 170, 171, 166} ,{4, 170, 198, 166} ,{40, 172, 161, 166} ,{40, 172, 160, 166} ,{40, 172, 171, 166} ,{40, 172, 198, 166} ,{41, 172, 161, 166} ,{41, 172, 160, 166} ,{41, 172, 171, 166} ,{41, 172, 198, 166} ,{79, 177, 161, 166} ,{79, 177, 160, 166} ,{42, 172, 161, 166} ,{42, 172, 160, 166} ,{42, 172, 171, 166} ,{42, 172, 198, 166} ,{134, 173, 57, 172} ,{134, 173, 160, 173} ,{0, 171, 161, 166} ,{0, 171, 160, 166} ,{0, 171, 171, 166} ,{0, 171, 198, 166} ,{43, 172, 161, 166} ,{43, 172, 160, 166} ,{43, 172, 171, 166} ,{43, 172, 198, 166} ,{5, 170, 161, 166} ,{5, 170, 160, 166} ,{5, 170, 13, 171} ,{5, 170, 14, 171} ,{44, 172, 161, 166} ,{44, 172, 160, 166} ,{44, 172, 171, 166} ,{44, 172, 198, 166} ,{80, 177, 161, 166} ,{80, 177, 160, 166} ,{149, 166, 135, 173} ,{149, 166, 136, 173} ,{149, 166, 137, 173} ,{149, 166, 138, 173} ,{196, 183, 57, 172} ,{82, 177, 161, 166} ,{82, 177, 160, 166} ,{129, 170, 135, 173} ,{129, 170, 136, 173} ,{129, 170, 137, 173} ,{129, 170, 138, 173} ,{45, 172, 161, 166} ,{45, 172, 160, 166} ,{45, 172, 171, 166} ,{45, 172, 198, 166} ,{86, 177, 171, 166} ,{86, 177, 198, 166} ,{103, 167, 90, 177} ,{103, 167, 145, 173} ,{87, 177, 161, 166} ,{87, 177, 160, 166} ,{88, 177, 161, 166} ,{88, 177, 160, 166} ,{89, 177, 161, 166} ,{89, 177, 160, 166} ,{34, 168, 135, 173} ,{34, 168, 136, 173} ,{34, 168, 137, 173} ,{34, 168, 138, 173} ,{139, 173, 161, 166} ,{139, 173, 160, 166} ,{139, 173, 171, 166} ,{143, 173, 216, 167} ,{143, 173, 92, 167} ,{197, 183, 171, 166} ,{35, 169, 161, 166} ,{35, 169, 160, 166} ,{35, 169, 171, 166} ,{35, 169, 198, 166} ,{103, 167, 35, 168} ,{103, 167, 56, 168} ,{103, 167, 217, 167} ,{103, 167, 216, 167} ,{103, 167, 234, 167} ,{243, 167, 35, 168} ,{243, 167, 56, 168} ,{243, 167, 219, 168} ,{243, 167, 217, 167} ,{243, 167, 216, 167} ,{243, 167, 234, 167} ,{104, 167, 35, 168} ,{104, 167, 56, 168} ,{104, 167, 219, 168} ,{104, 167, 217, 167} ,{104, 167, 216, 167} ,{104, 167, 234, 167} ,{152, 168, 35, 168} ,{152, 168, 217, 167} ,{152, 168, 216, 167} ,{152, 168, 234, 167} ,{127, 168, 56, 168} ,{127, 168, 217, 167} ,{221, 168, 35, 168} ,{221, 168, 217, 167} ,{112, 169, 35, 168} ,{112, 169, 56, 168} ,{112, 169, 217, 167} ,{125, 167, 35, 168} ,{125, 167, 56, 168} ,{125, 167, 219, 168} ,{125, 167, 217, 167} ,{80, 168, 56, 168} ,{80, 168, 217, 167} ,{36, 168, 35, 168} ,{36, 168, 56, 168} ,{36, 168, 219, 168} ,{36, 168, 217, 167} ,{154, 168, 56, 168} ,{154, 168, 217, 167} ,{146, 173, 217, 167} ,{128, 168, 35, 168} ,{128, 168, 217, 167} ,{220, 168, 35, 168} ,{220, 168, 217, 167} ,{98, 168, 35, 168} ,{98, 168, 56, 168} ,{98, 168, 219, 168} ,{98, 168, 217, 167} ,{98, 168, 216, 167} ,{98, 168, 234, 167} ,{190, 168, 56, 168} ,{190, 168, 217, 167} ,{190, 168, 216, 167} ,{190, 168, 234, 167} ,{219, 167, 90, 177} ,{219, 167, 35, 168} ,{219, 167, 56, 168} ,{219, 167, 219, 168} ,{47, 172, 161, 166} ,{219, 167, 217, 167} ,{219, 167, 216, 167} ,{219, 167, 234, 167} ,{85, 167, 35, 168} ,{85, 167, 56, 168} ,{85, 167, 219, 168} ,{85, 167, 217, 167} ,{85, 167, 216, 167} ,{85, 167, 234, 167} ,{218, 167, 35, 168} ,{218, 167, 56, 168} ,{218, 167, 219, 168} ,{218, 167, 217, 167} ,{218, 167, 216, 167} ,{218, 167, 234, 167} ,{126, 167, 35, 168} ,{126, 167, 56, 168} ,{126, 167, 219, 168} ,{126, 167, 217, 167} ,{126, 167, 216, 167} ,{126, 167, 234, 167} ,{114, 169, 35, 168} ,{114, 169, 217, 167} ,{114, 169, 216, 167} ,{114, 169, 234, 167} ,{242, 166, 35, 168} ,{242, 166, 56, 168} ,{242, 166, 219, 168} ,{242, 166, 217, 167} ,{242, 166, 216, 167} ,{242, 166, 234, 167} ,{198, 183, 144, 173} ,{199, 183, 144, 173} ,{91, 177, 144, 173} ,{111, 169, 116, 177} ,{111, 169, 117, 177} ,{93, 177, 161, 166} ,{94, 177, 161, 166} ,{95, 177, 161, 166} ,{200, 183, 161, 166} ,{201, 183, 160, 166} ,{34, 168, 11, 170} ,{103, 167, 169, 167} ,{34, 168, 130, 170} ,{103, 167, 92, 167} ,{103, 167, 1, 167} ,{243, 167, 113, 169} ,{243, 167, 1, 171} ,{243, 167, 169, 167} ,{243, 167, 2, 171} ,{243, 167, 92, 167} ,{243, 167, 1, 167} ,{104, 167, 113, 169} ,{104, 167, 1, 171} ,{104, 167, 169, 167} ,{104, 167, 2, 171} ,{104, 167, 92, 167} ,{104, 167, 1, 167} ,{152, 168, 113, 169} ,{152, 168, 1, 171} ,{152, 168, 169, 167} ,{152, 168, 2, 171} ,{152, 168, 92, 167} ,{152, 168, 1, 167} ,{98, 168, 92, 167} ,{98, 168, 1, 167} ,{190, 168, 92, 167} ,{190, 168, 1, 167} ,{219, 167, 145, 173} ,{47, 172, 160, 166} ,{219, 167, 169, 167} ,{219, 167, 92, 167} ,{219, 167, 1, 167} ,{85, 167, 169, 167} ,{85, 167, 92, 167} ,{85, 167, 1, 167} ,{218, 167, 145, 173} ,{218, 167, 169, 167} ,{126, 167, 113, 169} ,{126, 167, 1, 171} ,{126, 167, 169, 167} ,{126, 167, 2, 171} ,{126, 167, 92, 167} ,{126, 167, 1, 167} ,{202, 183, 160, 166} ,{242, 166, 113, 169} ,{242, 166, 1, 171} ,{242, 166, 169, 167} ,{242, 166, 2, 171} ,{242, 166, 92, 167} ,{242, 166, 1, 167} ,{103, 167, 193, 167} ,{103, 167, 168, 167} ,{103, 167, 79, 168} ,{103, 167, 50, 167} ,{92, 177, 171, 166} ,{243, 167, 193, 167} ,{243, 167, 168, 167} ,{243, 167, 79, 168} ,{243, 167, 50, 167} ,{243, 167, 8, 170} ,{104, 167, 193, 167} ,{104, 167, 168, 167} ,{104, 167, 79, 168} ,{104, 167, 50, 167} ,{104, 167, 8, 170} ,{152, 168, 50, 167} ,{127, 168, 168, 167} ,{127, 168, 50, 167} ,{221, 168, 193, 167} ,{221, 168, 50, 167} ,{112, 169, 193, 167} ,{112, 169, 50, 167} ,{125, 167, 193, 167} ,{125, 167, 168, 167} ,{125, 167, 79, 168} ,{125, 167, 50, 167} ,{80, 168, 168, 167} ,{80, 168, 79, 168} ,{80, 168, 50, 167} ,{36, 168, 193, 167} ,{36, 168, 168, 167} ,{36, 168, 79, 168} ,{36, 168, 50, 167} ,{154, 168, 168, 167} ,{146, 173, 50, 167} ,{128, 168, 193, 167} ,{128, 168, 50, 167} ,{220, 168, 193, 167} ,{220, 168, 50, 167} ,{98, 168, 193, 167} ,{98, 168, 168, 167} ,{98, 168, 79, 168} ,{98, 168, 50, 167} ,{190, 168, 168, 167} ,{190, 168, 50, 167} ,{219, 167, 193, 167} ,{219, 167, 168, 167} ,{219, 167, 79, 168} ,{47, 172, 171, 166} ,{219, 167, 50, 167} ,{85, 167, 193, 167} ,{85, 167, 168, 167} ,{85, 167, 79, 168} ,{85, 167, 50, 167} ,{85, 167, 8, 170} ,{218, 167, 193, 167} ,{218, 167, 168, 167} ,{218, 167, 79, 168} ,{218, 167, 50, 167} ,{126, 167, 193, 167} ,{126, 167, 168, 167} ,{126, 167, 79, 168} ,{126, 167, 50, 167} ,{126, 167, 8, 170} ,{114, 169, 193, 167} ,{114, 169, 50, 167} ,{203, 183, 171, 166} ,{242, 166, 193, 167} ,{242, 166, 168, 167} ,{242, 166, 79, 168} ,{242, 166, 50, 167} ,{242, 166, 8, 170} ,{103, 167, 189, 168} ,{92, 177, 198, 166} ,{243, 167, 189, 168} ,{243, 167, 7, 170} ,{104, 167, 189, 168} ,{104, 167, 7, 170} ,{152, 168, 189, 168} ,{152, 168, 7, 170} ,{125, 167, 189, 168} ,{125, 167, 7, 170} ,{113, 167, 189, 168} ,{113, 167, 7, 170} ,{47, 172, 198, 166} ,{219, 167, 189, 168} ,{85, 167, 189, 168} ,{126, 167, 189, 168} ,{126, 167, 7, 170} ,{242, 166, 189, 168} ,{242, 166, 7, 170} ,{93, 177, 198, 166} ,{94, 177, 198, 166} ,{95, 177, 198, 166} ,{154, 168, 216, 167} ,{154, 168, 234, 167} ,{128, 168, 216, 167} ,{128, 168, 234, 167} ,{220, 168, 216, 167} ,{220, 168, 234, 167} ,{125, 167, 216, 167} ,{125, 167, 234, 167} ,{113, 167, 216, 167} ,{113, 167, 234, 167} ,{221, 168, 216, 167} ,{221, 168, 234, 167} ,{127, 168, 216, 167} ,{127, 168, 234, 167} ,{112, 169, 216, 167} ,{112, 169, 234, 167} ,{80, 168, 216, 167} ,{80, 168, 234, 167} ,{36, 168, 216, 167} ,{36, 168, 234, 167} ,{113, 167, 35, 168} ,{113, 167, 56, 168} ,{113, 167, 219, 168} ,{113, 167, 217, 167} ,{113, 167, 48, 172} ,{125, 167, 48, 172} ,{80, 168, 48, 172} ,{36, 168, 48, 172} ,{154, 168, 92, 167} ,{154, 168, 1, 167} ,{128, 168, 92, 167} ,{128, 168, 1, 167} ,{220, 168, 92, 167} ,{220, 168, 1, 167} ,{125, 167, 92, 167} ,{125, 167, 1, 167} ,{113, 167, 92, 167} ,{113, 167, 1, 167} ,{221, 168, 92, 167} ,{221, 168, 1, 167} ,{127, 168, 92, 167} ,{127, 168, 1, 167} ,{112, 169, 92, 167} ,{112, 169, 1, 167} ,{80, 168, 92, 167} ,{80, 168, 1, 167} ,{36, 168, 92, 167} ,{36, 168, 1, 167} ,{113, 167, 148, 173} ,{113, 167, 192, 169} ,{97, 177, 160, 166} ,{113, 167, 169, 167} ,{113, 167, 113, 169} ,{125, 167, 113, 169} ,{80, 168, 113, 169} ,{36, 168, 113, 169} ,{113, 167, 193, 167} ,{113, 167, 168, 167} ,{113, 167, 79, 168} ,{113, 167, 50, 167} ,{125, 167, 8, 170} ,{113, 167, 8, 170} ,{154, 168, 50, 167} ,{147, 173, 198, 166} ,{125, 167, 96, 177} ,{104, 177, 198, 166} ,{204, 183, 198, 166} ,{113, 167, 96, 177} ,{97, 177, 198, 166} ,{154, 168, 189, 168} ,{146, 173, 189, 168} ,{99, 177, 160, 166} ,{99, 177, 161, 166} ,{49, 25, 235, 37} ,{49, 25, 236, 37} ,{103, 177, 50, 167} ,{205, 183, 148, 173} ,{104, 167, 150, 173} ,{104, 167, 7, 171} ,{104, 167, 6, 171} ,{104, 167, 152, 173} ,{104, 167, 133, 170} ,{206, 183, 79, 168} ,{127, 168, 5, 171} ,{127, 168, 133, 170} ,{221, 168, 155, 168} ,{221, 168, 132, 170} ,{125, 167, 150, 173} ,{147, 173, 168, 167} ,{147, 173, 92, 167} ,{125, 167, 5, 171} ,{125, 167, 133, 170} ,{125, 167, 152, 173} ,{125, 167, 191, 169} ,{125, 167, 193, 169} ,{100, 177, 192, 169} ,{100, 177, 168, 167} ,{80, 168, 191, 169} ,{113, 167, 102, 177} ,{113, 167, 7, 171} ,{113, 167, 9, 170} ,{207, 183, 160, 166} ,{101, 177, 79, 168} ,{113, 167, 191, 169} ,{113, 167, 193, 169} ,{36, 168, 49, 172} ,{36, 168, 149, 173} ,{36, 168, 6, 171} ,{154, 168, 5, 171} ,{154, 168, 133, 170} ,{154, 168, 193, 169} ,{154, 168, 155, 168} ,{105, 177, 169, 167} ,{128, 168, 191, 169} ,{128, 168, 193, 169} ,{128, 168, 132, 170} ,{220, 168, 191, 169} ,{220, 168, 155, 168} ,{220, 168, 132, 170} ,{98, 168, 149, 173} ,{98, 168, 6, 171} ,{190, 168, 5, 171} ,{190, 168, 191, 169} ,{85, 167, 102, 177} ,{85, 167, 115, 169} ,{85, 167, 49, 172} ,{50, 172, 193, 167} ,{50, 172, 148, 173} ,{85, 167, 149, 173} ,{85, 167, 6, 171} ,{85, 167, 5, 171} ,{85, 167, 133, 170} ,{218, 167, 150, 173} ,{218, 167, 7, 171} ,{218, 167, 115, 169} ,{151, 173, 168, 167} ,{151, 173, 50, 167} ,{208, 183, 193, 167} ,{218, 167, 6, 171} ,{151, 173, 79, 168} ,{114, 169, 152, 173} ,{114, 169, 193, 169} ,{126, 167, 7, 171} ,{126, 167, 49, 172} ,{8, 171, 169, 167} ,{8, 171, 50, 167} ,{8, 171, 92, 167} ,{126, 167, 155, 168} ,{126, 167, 132, 170} ,{242, 166, 191, 169} ,{242, 166, 193, 169} ,{243, 167, 51, 172} ,{104, 167, 9, 170} ,{103, 177, 92, 167} ,{104, 167, 51, 172} ,{209, 183, 92, 167} ,{104, 167, 155, 168} ,{104, 167, 132, 170} ,{127, 168, 155, 168} ,{127, 168, 49, 172} ,{127, 168, 132, 170} ,{104, 177, 92, 167} ,{80, 168, 115, 169} ,{113, 167, 115, 169} ,{36, 168, 115, 169} ,{85, 167, 9, 170} ,{85, 167, 155, 168} ,{242, 166, 115, 169} ,{242, 166, 9, 170} ,{242, 166, 155, 168} ,{218, 167, 155, 168} ,{190, 168, 155, 168} ,{126, 167, 115, 169} ,{190, 168, 133, 170} ,{85, 167, 7, 171} ,{128, 168, 155, 168} ,{219, 167, 155, 168} ,{8, 171, 168, 167} ,{218, 167, 51, 172} ,{50, 172, 50, 167} ,{219, 167, 191, 169} ,{50, 172, 169, 167} ,{8, 171, 192, 169} ,{127, 168, 115, 169} ,{221, 168, 9, 170} ,{218, 167, 9, 170} ,{98, 168, 155, 168} ,{243, 167, 115, 169} ,{219, 167, 193, 169} ,{105, 177, 50, 167} ,{80, 168, 193, 169} ,{125, 167, 51, 172} ,{126, 167, 9, 170} ,{111, 177, 110, 177} ,{210, 183, 110, 177} ,{211, 183, 161, 166} ,{212, 183, 161, 166} ,{213, 183, 161, 166} ,{214, 183, 161, 166} ,{215, 183, 161, 166} ,{216, 183, 161, 166} ,{217, 183, 161, 166} ,{111, 177, 161, 166} ,{218, 183, 60, 25} ,{148, 166, 61, 25} ,{62, 25, 6, 0} ,{222, 183, 66, 25} ,{157, 166, 118, 5} ,{157, 166, 119, 5} ,{157, 166, 120, 5} ,{157, 166, 121, 5} ,{157, 166, 122, 5} ,{157, 166, 128, 5} ,{157, 166, 194, 11} ,{157, 166, 228, 13} ,{157, 166, 195, 11} ,{157, 166, 68, 25} ,{157, 166, 69, 25} ,{157, 166, 108, 13} ,{157, 166, 109, 13} ,{157, 166, 112, 13} ,{157, 166, 119, 13} ,{157, 166, 134, 13} ,{107, 167, 16, 0} ,{107, 167, 83, 78} ,{107, 167, 84, 78} ,{107, 167, 33, 0} ,{107, 167, 34, 0} ,{107, 167, 228, 37} ,{107, 167, 2, 38} ,{107, 167, 104, 78} ,{223, 183, 71, 25} ,{107, 167, 118, 64} ,{113, 177, 153, 173} ,{113, 177, 155, 173} ,{114, 177, 153, 173} ,{114, 177, 155, 173} ,{154, 173, 153, 173} ,{154, 173, 155, 173} ,{224, 183, 106, 0} ,{107, 167, 117, 64} ,{107, 167, 100, 64} ,{107, 167, 99, 64} ,{107, 167, 34, 38} ,{107, 167, 238, 140} ,{194, 169, 12, 0} ,{195, 169, 12, 0} ,{194, 169, 133, 168} ,{195, 169, 133, 168} ,{194, 169, 129, 168} ,{195, 169, 129, 168} ,{194, 169, 52, 172} ,{195, 169, 52, 172} ,{194, 169, 134, 170} ,{195, 169, 134, 170} ,{194, 169, 81, 168} ,{195, 169, 81, 168} ,{194, 169, 40, 169} ,{195, 169, 40, 169} ,{107, 167, 96, 78} ,{115, 177, 40, 169} ,{73, 25, 115, 0} ,{205, 10, 228, 140} ,{194, 169, 103, 168} ,{195, 169, 103, 168} ,{204, 10, 36, 1} ,{74, 25, 36, 1} ,{195, 2, 36, 1} ,{100, 0, 234, 140} ,{204, 10, 34, 38} ,{74, 25, 34, 38} ,{195, 2, 34, 38} ,{79, 0, 16, 0} ,{79, 0, 83, 78} ,{79, 0, 241, 37} ,{79, 0, 34, 0} ,{79, 0, 33, 0} ,{79, 0, 2, 38} ,{79, 0, 228, 37} ,{79, 0, 100, 64} ,{79, 0, 235, 37} ,{79, 0, 236, 37} ,{79, 0, 62, 38} ,{79, 0, 64, 38} ,{79, 0, 102, 78} ,{79, 0, 103, 78} ,{79, 0, 230, 37} ,{79, 0, 9, 0} ,{79, 0, 14, 0} ,{79, 0, 238, 37} ,{79, 0, 240, 37} ,{79, 0, 255, 37} ,{79, 0, 1, 38} ,{79, 0, 0, 38} ,{79, 0, 31, 38} ,{79, 0, 231, 37} ,{79, 0, 232, 37} ,{79, 0, 3, 38} ,{225, 183, 161, 166} ,{228, 183, 132, 0} ,{104, 2, 116, 177} ,{229, 183, 76, 25} ,{104, 2, 117, 177} ,{157, 173, 161, 166} ,{157, 173, 198, 166} ,{118, 177, 161, 166} ,{118, 177, 198, 166} ,{119, 177, 161, 166} ,{119, 177, 198, 166} ,{120, 177, 161, 166} ,{120, 177, 198, 166} ,{121, 177, 161, 166} ,{121, 177, 198, 166} ,{230, 183, 161, 166} ,{158, 173, 57, 172} ,{158, 173, 160, 173} ,{244, 167, 13, 171} ,{244, 167, 14, 171} ,{39, 169, 13, 171} ,{39, 169, 14, 171} ,{122, 177, 161, 166} ,{122, 177, 160, 166} ,{3, 168, 13, 171} ,{3, 168, 14, 171} ,{123, 177, 171, 166} ,{123, 177, 198, 166} ,{244, 167, 161, 166} ,{244, 167, 160, 166} ,{222, 168, 161, 166} ,{222, 168, 160, 166} ,{222, 168, 171, 166} ,{222, 168, 198, 166} ,{159, 173, 161, 166} ,{159, 173, 160, 166} ,{36, 169, 161, 166} ,{36, 169, 160, 166} ,{36, 169, 171, 166} ,{36, 169, 198, 166} ,{53, 172, 161, 166} ,{53, 172, 160, 166} ,{53, 172, 171, 166} ,{53, 172, 198, 166} ,{54, 172, 161, 166} ,{54, 172, 160, 166} ,{54, 172, 171, 166} ,{54, 172, 198, 166} ,{156, 168, 161, 166} ,{156, 168, 160, 166} ,{156, 168, 171, 166} ,{156, 168, 198, 166} ,{55, 172, 161, 166} ,{55, 172, 160, 166} ,{55, 172, 171, 166} ,{55, 172, 198, 166} ,{37, 169, 161, 166} ,{37, 169, 160, 166} ,{124, 177, 161, 166} ,{124, 177, 160, 166} ,{130, 168, 161, 166} ,{130, 168, 160, 166} ,{231, 183, 161, 166} ,{149, 166, 11, 170} ,{191, 168, 161, 166} ,{191, 168, 160, 166} ,{191, 168, 171, 166} ,{191, 168, 198, 166} ,{10, 171, 161, 166} ,{10, 171, 160, 166} ,{10, 171, 171, 166} ,{10, 171, 198, 166} ,{135, 170, 161, 166} ,{135, 170, 160, 166} ,{135, 170, 171, 166} ,{135, 170, 198, 166} ,{11, 171, 161, 166} ,{11, 171, 160, 166} ,{11, 171, 171, 166} ,{11, 171, 198, 166} ,{38, 169, 161, 166} ,{38, 169, 160, 166} ,{38, 169, 171, 166} ,{38, 169, 198, 166} ,{56, 172, 161, 166} ,{56, 172, 160, 166} ,{56, 172, 171, 166} ,{56, 172, 198, 166} ,{196, 169, 161, 166} ,{196, 169, 160, 166} ,{196, 169, 171, 166} ,{196, 169, 198, 166} ,{12, 171, 161, 166} ,{12, 171, 160, 166} ,{12, 171, 171, 166} ,{12, 171, 198, 166} ,{116, 169, 161, 166} ,{116, 169, 160, 166} ,{116, 169, 171, 166} ,{116, 169, 198, 166} ,{136, 170, 161, 166} ,{136, 170, 160, 166} ,{136, 170, 171, 166} ,{136, 170, 198, 166} ,{197, 169, 161, 166} ,{197, 169, 160, 166} ,{197, 169, 171, 166} ,{197, 169, 198, 166} ,{117, 169, 161, 166} ,{117, 169, 160, 166} ,{117, 169, 171, 166} ,{117, 169, 198, 166} ,{137, 170, 161, 166} ,{137, 170, 160, 166} ,{137, 170, 171, 166} ,{137, 170, 198, 166} ,{157, 168, 161, 166} ,{157, 168, 160, 166} ,{157, 168, 171, 166} ,{157, 168, 198, 166} ,{15, 168, 161, 166} ,{15, 168, 160, 166} ,{15, 168, 171, 166} ,{15, 168, 198, 166} ,{39, 169, 161, 166} ,{39, 169, 160, 166} ,{125, 177, 161, 166} ,{125, 177, 160, 166} ,{3, 168, 161, 166} ,{3, 168, 160, 166} ,{3, 168, 171, 166} ,{3, 168, 198, 166} ,{127, 177, 57, 172} ,{127, 177, 160, 173} ,{198, 169, 13, 171} ,{198, 169, 14, 171} ,{128, 177, 161, 166} ,{128, 177, 160, 166} ,{198, 169, 161, 166} ,{198, 169, 160, 166} ,{59, 172, 66, 38} ,{78, 25, 228, 37} ,{78, 25, 229, 37} ,{78, 25, 230, 37} ,{78, 25, 231, 37} ,{78, 25, 232, 37} ,{78, 25, 9, 0} ,{78, 25, 10, 0} ,{78, 25, 235, 37} ,{78, 25, 236, 37} ,{78, 25, 14, 0} ,{78, 25, 238, 37} ,{78, 25, 16, 0} ,{78, 25, 240, 37} ,{78, 25, 241, 37} ,{78, 25, 21, 0} ,{78, 25, 243, 37} ,{78, 25, 244, 37} ,{78, 25, 245, 37} ,{78, 25, 246, 37} ,{78, 25, 247, 37} ,{78, 25, 248, 37} ,{78, 25, 249, 37} ,{78, 25, 250, 37} ,{78, 25, 251, 37} ,{78, 25, 252, 37} ,{78, 25, 33, 0} ,{78, 25, 34, 0} ,{78, 25, 255, 37} ,{78, 25, 0, 38} ,{78, 25, 1, 38} ,{78, 25, 2, 38} ,{78, 25, 3, 38} ,{170, 167, 45, 0} ,{170, 167, 46, 0} ,{170, 167, 47, 0} ,{170, 167, 48, 0} ,{170, 167, 49, 0} ,{170, 167, 50, 0} ,{170, 167, 51, 0} ,{170, 167, 52, 0} ,{170, 167, 53, 0} ,{170, 167, 54, 0} ,{170, 167, 55, 0} ,{170, 167, 56, 0} ,{170, 167, 57, 0} ,{170, 167, 58, 0} ,{170, 167, 59, 0} ,{170, 167, 60, 0} ,{170, 167, 61, 0} ,{170, 167, 62, 0} ,{170, 167, 63, 0} ,{170, 167, 64, 0} ,{170, 167, 65, 0} ,{170, 167, 66, 0} ,{170, 167, 67, 0} ,{170, 167, 68, 0} ,{170, 167, 69, 0} ,{170, 167, 70, 0} ,{78, 25, 30, 38} ,{78, 25, 31, 38} ,{78, 25, 32, 38} ,{78, 25, 33, 38} ,{78, 25, 34, 38} ,{78, 25, 35, 38} ,{171, 167, 45, 0} ,{171, 167, 46, 0} ,{171, 167, 47, 0} ,{171, 167, 48, 0} ,{171, 167, 49, 0} ,{171, 167, 50, 0} ,{171, 167, 51, 0} ,{171, 167, 52, 0} ,{171, 167, 53, 0} ,{171, 167, 54, 0} ,{171, 167, 55, 0} ,{171, 167, 56, 0} ,{171, 167, 57, 0} ,{171, 167, 58, 0} ,{171, 167, 59, 0} ,{171, 167, 60, 0} ,{171, 167, 61, 0} ,{171, 167, 62, 0} ,{171, 167, 63, 0} ,{171, 167, 64, 0} ,{171, 167, 65, 0} ,{171, 167, 66, 0} ,{171, 167, 67, 0} ,{171, 167, 68, 0} ,{171, 167, 69, 0} ,{171, 167, 70, 0} ,{78, 25, 62, 38} ,{78, 25, 63, 38} ,{78, 25, 64, 38} ,{78, 25, 82, 0} ,{78, 25, 54, 73} ,{78, 25, 55, 73} ,{79, 25, 84, 78} ,{79, 25, 94, 78} ,{79, 25, 95, 78} ,{79, 25, 83, 78} ,{162, 173, 89, 38} ,{247, 166, 206, 4} ,{118, 169, 45, 0} ,{118, 169, 53, 0} ,{118, 169, 65, 0} ,{118, 169, 49, 0} ,{118, 169, 59, 0} ,{118, 169, 171, 1} ,{118, 169, 170, 1} ,{118, 169, 204, 4} ,{118, 169, 70, 6} ,{79, 25, 75, 79} ,{247, 166, 45, 0} ,{247, 166, 53, 0} ,{247, 166, 65, 0} ,{247, 166, 49, 0} ,{247, 166, 59, 0} ,{247, 166, 154, 1} ,{247, 166, 103, 6} ,{247, 166, 102, 6} ,{247, 166, 106, 6} ,{247, 166, 194, 4} ,{247, 166, 131, 3} ,{247, 166, 27, 6} ,{247, 166, 26, 6} ,{247, 166, 30, 6} ,{247, 166, 122, 4} ,{247, 166, 129, 3} ,{247, 166, 215, 4} ,{247, 166, 70, 6} ,{247, 166, 161, 1} ,{247, 166, 237, 1} ,{247, 166, 139, 3} ,{247, 166, 92, 6} ,{247, 166, 101, 1} ,{247, 166, 94, 6} ,{247, 166, 200, 4} ,{247, 166, 163, 1} ,{247, 166, 250, 5} ,{247, 166, 249, 5} ,{247, 166, 86, 2} ,{247, 166, 243, 1} ,{247, 166, 137, 3} ,{247, 166, 9, 6} ,{247, 166, 100, 1} ,{247, 166, 12, 6} ,{247, 166, 203, 4} ,{247, 166, 171, 1} ,{247, 166, 170, 1} ,{247, 166, 204, 4} ,{247, 166, 253, 1} ,{247, 166, 22, 6} ,{247, 166, 154, 4} ,{247, 166, 24, 6} ,{247, 166, 46, 5} ,{247, 166, 140, 3} ,{247, 166, 58, 0} ,{162, 173, 13, 170} ,{162, 173, 163, 173} ,{79, 25, 171, 79} ,{17, 167, 171, 5} ,{17, 167, 172, 5} ,{17, 167, 60, 172} ,{17, 167, 173, 5} ,{130, 177, 183, 5} ,{130, 177, 189, 5} ,{17, 167, 174, 5} ,{17, 167, 175, 5} ,{17, 167, 176, 5} ,{14, 170, 171, 5} ,{14, 170, 177, 5} ,{14, 170, 178, 5} ,{14, 170, 180, 5} ,{14, 170, 187, 5} ,{14, 170, 188, 5} ,{14, 170, 189, 5} ,{17, 167, 177, 5} ,{17, 167, 178, 5} ,{17, 167, 179, 5} ,{17, 167, 164, 173} ,{17, 167, 180, 5} ,{17, 167, 181, 5} ,{17, 167, 182, 5} ,{17, 167, 183, 5} ,{17, 167, 184, 5} ,{17, 167, 185, 5} ,{17, 167, 186, 5} ,{17, 167, 187, 5} ,{17, 167, 188, 5} ,{17, 167, 189, 5} ,{17, 167, 45, 0} ,{17, 167, 133, 0} ,{17, 167, 171, 1} ,{17, 167, 224, 1} ,{17, 167, 225, 5} ,{17, 167, 49, 0} ,{17, 167, 226, 5} ,{17, 167, 227, 5} ,{17, 167, 59, 0} ,{17, 167, 140, 3} ,{17, 167, 228, 5} ,{17, 167, 164, 0} ,{17, 167, 204, 4} ,{17, 167, 65, 0} ,{17, 167, 229, 5} ,{17, 167, 226, 1} ,{17, 167, 230, 5} ,{17, 167, 170, 1} ,{17, 167, 110, 5} ,{17, 167, 141, 1} ,{17, 167, 53, 0} ,{78, 25, 68, 38} ,{78, 25, 69, 38} ,{78, 25, 78, 38} ,{78, 25, 106, 0} ,{78, 25, 72, 38} ,{78, 25, 71, 38} ,{78, 25, 230, 64} ,{233, 183, 33, 12} ,{79, 25, 161, 65} ,{79, 25, 162, 65} ,{79, 25, 163, 65} ,{79, 25, 164, 65} ,{79, 25, 108, 69} ,{79, 25, 151, 69} ,{165, 173, 188, 12} ,{165, 173, 121, 2} ,{165, 173, 82, 25} ,{83, 25, 123, 142} ,{84, 25, 85, 25} ,{234, 183, 45, 0} ,{235, 183, 49, 0} ,{236, 183, 53, 0} ,{237, 183, 59, 0} ,{238, 183, 65, 0} ,{239, 183, 232, 1} ,{240, 183, 151, 1} ,{241, 183, 142, 6} ,{242, 183, 199, 4} ,{243, 183, 141, 6} ,{244, 183, 244, 1} ,{245, 183, 142, 1} ,{246, 183, 157, 6} ,{247, 183, 153, 6} ,{248, 183, 154, 1} ,{249, 183, 106, 6} ,{250, 183, 103, 6} ,{251, 183, 194, 4} ,{252, 183, 102, 6} ,{253, 183, 137, 3} ,{254, 183, 12, 6} ,{255, 183, 9, 6} ,{0, 184, 203, 4} ,{1, 184, 100, 1} ,{2, 184, 139, 3} ,{3, 184, 94, 6} ,{4, 184, 92, 6} ,{5, 184, 200, 4} ,{6, 184, 101, 1} ,{7, 184, 128, 3} ,{8, 184, 158, 1} ,{9, 184, 104, 1} ,{10, 184, 202, 4} ,{11, 184, 212, 6} ,{12, 184, 225, 1} ,{13, 184, 42, 6} ,{14, 184, 39, 6} ,{15, 184, 43, 6} ,{16, 184, 253, 1} ,{17, 184, 24, 6} ,{18, 184, 22, 6} ,{19, 184, 46, 5} ,{20, 184, 154, 4} ,{21, 184, 131, 3} ,{22, 184, 30, 6} ,{23, 184, 27, 6} ,{24, 184, 122, 4} ,{25, 184, 26, 6} ,{26, 184, 129, 3} ,{27, 184, 161, 1} ,{28, 184, 215, 4} ,{29, 184, 237, 1} ,{30, 184, 70, 6} ,{31, 184, 140, 3} ,{32, 184, 226, 1} ,{33, 184, 230, 5} ,{34, 184, 206, 4} ,{35, 184, 234, 1} ,{36, 184, 153, 1} ,{37, 184, 107, 3} ,{38, 184, 148, 25} ,{39, 184, 150, 25} ,{40, 184, 198, 3} ,{41, 184, 71, 22} ,{42, 184, 154, 25} ,{43, 184, 95, 6} ,{44, 184, 157, 25} ,{45, 184, 159, 25} ,{46, 184, 161, 25} ,{47, 184, 163, 25} ,{48, 184, 165, 25} ,{49, 184, 167, 25} ,{50, 184, 44, 7} ,{51, 184, 25, 0} ,{131, 168, 170, 25} ,{131, 168, 171, 25} ,{131, 168, 172, 25} ,{131, 168, 173, 25} ,{131, 168, 174, 25} ,{131, 168, 175, 25} ,{131, 168, 176, 25} ,{131, 168, 177, 25} ,{131, 168, 178, 25} ,{131, 168, 179, 25} ,{131, 168, 180, 25} ,{131, 168, 181, 25} ,{131, 168, 182, 25} ,{131, 168, 183, 25} ,{52, 184, 144, 5} ,{53, 184, 255, 15} ,{54, 184, 95, 16} ,{55, 184, 189, 25} ,{56, 184, 191, 25} ,{57, 184, 193, 25} ,{58, 184, 196, 15} ,{59, 184, 195, 15} ,{61, 184, 198, 25} ,{63, 184, 198, 25} ,{64, 184, 202, 25} ,{65, 184, 204, 25} ,{66, 184, 182, 15} ,{67, 184, 207, 25} ,{68, 184, 226, 15} ,{69, 184, 210, 25} ,{70, 184, 212, 25} ,{71, 184, 214, 25} ,{72, 184, 216, 25} ,{73, 184, 218, 25} ,{74, 184, 220, 25} ,{75, 184, 222, 25} ,{76, 184, 81, 16} ,{183, 166, 224, 25} ,{77, 184, 226, 25} ,{78, 184, 228, 25} ,{79, 184, 230, 25} ,{80, 184, 210, 15} ,{183, 166, 232, 25} ,{81, 184, 234, 25} ,{183, 166, 235, 25} ,{183, 166, 236, 25} ,{82, 184, 187, 0} ,{183, 166, 238, 25} ,{183, 166, 239, 25} ,{183, 166, 240, 25} ,{83, 184, 242, 25} ,{183, 166, 243, 25} ,{183, 166, 244, 25} ,{84, 184, 186, 15} ,{183, 166, 246, 25} ,{183, 166, 247, 25} ,{85, 184, 249, 25} ,{86, 184, 251, 25} ,{183, 166, 252, 25} ,{183, 166, 253, 25} ,{183, 166, 254, 25} ,{183, 166, 255, 25} ,{183, 166, 0, 26} ,{183, 166, 1, 26} ,{183, 166, 2, 26} ,{183, 166, 3, 26} ,{183, 166, 4, 26} ,{87, 184, 6, 26} ,{183, 166, 7, 26} ,{88, 184, 25, 16} ,{183, 166, 9, 26} ,{183, 166, 10, 26} ,{183, 166, 11, 26} ,{183, 166, 12, 26} ,{183, 166, 13, 26} ,{183, 166, 14, 26} ,{183, 166, 15, 26} ,{183, 166, 16, 26} ,{183, 166, 17, 26} ,{183, 166, 18, 26} ,{183, 166, 19, 26} ,{89, 184, 21, 26} ,{90, 184, 23, 26} ,{91, 184, 25, 26} ,{92, 184, 47, 16} ,{93, 184, 34, 1} ,{183, 166, 28, 26} ,{94, 184, 30, 26} ,{183, 166, 31, 26} ,{183, 166, 32, 26} ,{96, 184, 35, 26} ,{97, 184, 35, 26} ,{99, 184, 39, 26} ,{100, 184, 41, 26} ,{183, 166, 42, 26} ,{183, 166, 43, 26} ,{101, 184, 45, 26} ,{183, 166, 46, 26} ,{183, 166, 47, 26} ,{183, 166, 48, 26} ,{183, 166, 49, 26} ,{183, 166, 50, 26} ,{102, 184, 52, 26} ,{183, 166, 53, 26} ,{183, 166, 54, 26} ,{183, 166, 55, 26} ,{183, 166, 56, 26} ,{183, 166, 57, 26} ,{135, 167, 59, 26} ,{135, 167, 60, 26} ,{135, 167, 61, 26} ,{135, 167, 62, 26} ,{135, 167, 63, 26} ,{135, 167, 64, 26} ,{135, 167, 65, 26} ,{135, 167, 66, 26} ,{135, 167, 67, 26} ,{135, 167, 68, 26} ,{135, 167, 69, 26} ,{135, 167, 70, 26} ,{135, 167, 71, 26} ,{135, 167, 72, 26} ,{135, 167, 73, 26} ,{135, 167, 74, 26} ,{135, 167, 75, 26} ,{135, 167, 76, 26} ,{135, 167, 77, 26} ,{135, 167, 78, 26} ,{135, 167, 79, 26} ,{135, 167, 80, 26} ,{135, 167, 81, 26} ,{135, 167, 82, 26} ,{135, 167, 83, 26} ,{135, 167, 84, 26} ,{135, 167, 85, 26} ,{135, 167, 86, 26} ,{135, 167, 87, 26} ,{131, 177, 77, 0} ,{131, 177, 115, 0} ,{88, 26, 213, 70} ,{55, 167, 24, 0} ,{55, 167, 25, 0} ,{55, 167, 26, 0} ,{55, 167, 27, 0} ,{55, 167, 28, 0} ,{55, 167, 29, 0} ,{55, 167, 30, 0} ,{55, 167, 31, 0} ,{55, 167, 32, 0} ,{55, 167, 14, 4} ,{55, 167, 221, 6} ,{55, 167, 222, 6} ,{55, 167, 223, 6} ,{55, 167, 224, 6} ,{55, 167, 225, 6} ,{55, 167, 226, 6} ,{55, 167, 227, 6} ,{55, 167, 228, 6} ,{55, 167, 149, 170} ,{132, 177, 15, 4} ,{55, 167, 175, 173} ,{133, 177, 15, 4} ,{55, 167, 43, 169} ,{134, 177, 15, 4} ,{135, 177, 15, 4} ,{136, 177, 15, 4} ,{55, 167, 176, 173} ,{55, 167, 63, 172} ,{132, 177, 16, 4} ,{103, 184, 16, 4} ,{133, 177, 16, 4} ,{55, 167, 171, 173} ,{134, 177, 16, 4} ,{135, 177, 16, 4} ,{136, 177, 16, 4} ,{104, 184, 16, 4} ,{55, 167, 66, 172} ,{105, 184, 16, 4} ,{106, 184, 16, 4} ,{107, 184, 16, 4} ,{108, 184, 16, 4} ,{109, 184, 16, 4} ,{110, 184, 16, 4} ,{111, 184, 16, 4} ,{112, 184, 16, 4} ,{113, 184, 92, 26} ,{15, 171, 167, 173} ,{15, 171, 138, 177} ,{15, 171, 140, 177} ,{114, 184, 93, 26} ,{115, 184, 137, 177} ,{116, 184, 137, 177} ,{139, 177, 138, 177} ,{139, 177, 140, 177} ,{15, 170, 122, 0} ,{15, 170, 123, 0} ,{15, 170, 99, 26} ,{206, 167, 28, 0} ,{206, 167, 224, 6} ,{206, 167, 43, 169} ,{139, 170, 16, 4} ,{61, 172, 16, 4} ,{139, 170, 100, 26} ,{62, 172, 100, 26} ,{61, 172, 100, 26} ,{15, 170, 141, 177} ,{139, 170, 141, 177} ,{15, 170, 142, 177} ,{139, 170, 142, 177} ,{139, 170, 101, 26} ,{62, 172, 101, 26} ,{61, 172, 101, 26} ,{15, 170, 143, 177} ,{139, 170, 143, 177} ,{15, 170, 168, 173} ,{62, 172, 168, 173} ,{61, 172, 168, 173} ,{62, 172, 102, 26} ,{118, 184, 104, 26} ,{41, 169, 24, 0} ,{169, 173, 24, 0} ,{170, 173, 25, 0} ,{41, 169, 25, 0} ,{119, 184, 144, 177} ,{170, 173, 144, 177} ,{140, 170, 28, 0} ,{140, 170, 14, 4} ,{120, 184, 172, 173} ,{169, 173, 14, 4} ,{121, 184, 14, 4} ,{41, 169, 14, 4} ,{41, 169, 222, 6} ,{140, 170, 224, 6} ,{122, 184, 172, 173} ,{169, 173, 224, 6} ,{41, 169, 224, 6} ,{41, 169, 149, 170} ,{41, 169, 175, 173} ,{170, 173, 43, 169} ,{140, 170, 43, 169} ,{41, 169, 43, 169} ,{123, 184, 43, 169} ,{124, 184, 43, 169} ,{41, 169, 63, 172} ,{41, 169, 171, 173} ,{126, 184, 102, 26} ,{128, 184, 102, 26} ,{146, 177, 6, 0} ,{129, 184, 172, 173} ,{130, 184, 6, 0} ,{131, 184, 6, 0} ,{54, 1, 147, 177} ,{132, 184, 6, 0} ,{54, 1, 236, 64} ,{133, 184, 6, 0} ,{148, 177, 64, 172} ,{134, 184, 64, 172} ,{135, 184, 64, 172} ,{136, 184, 64, 172} ,{137, 184, 6, 0} ,{138, 184, 149, 177} ,{139, 184, 6, 0} ,{140, 184, 6, 0} ,{141, 184, 6, 0} ,{142, 184, 6, 0} ,{143, 184, 6, 0} ,{144, 184, 6, 0} ,{145, 184, 149, 177} ,{146, 184, 6, 0} ,{147, 184, 6, 0} ,{148, 184, 6, 0} ,{149, 184, 6, 0} ,{179, 10, 150, 177} ,{150, 184, 150, 177} ,{151, 184, 6, 0} ,{152, 184, 6, 0} ,{153, 184, 6, 0} ,{154, 184, 6, 0} ,{155, 184, 6, 0} ,{156, 184, 6, 0} ,{157, 184, 6, 0} ,{53, 167, 142, 26} ,{158, 184, 110, 14} ,{159, 184, 110, 14} ,{53, 167, 145, 26} ,{53, 167, 0, 16} ,{53, 167, 255, 15} ,{53, 167, 21, 26} ,{53, 167, 146, 26} ,{53, 167, 147, 26} ,{53, 167, 34, 1} ,{53, 167, 15, 16} ,{53, 167, 5, 13} ,{53, 167, 148, 26} ,{53, 167, 149, 26} ,{53, 167, 150, 26} ,{53, 167, 151, 26} ,{53, 167, 236, 15} ,{53, 167, 152, 26} ,{160, 184, 154, 26} ,{53, 167, 155, 26} ,{53, 167, 156, 26} ,{53, 167, 157, 26} ,{53, 167, 158, 26} ,{53, 167, 159, 26} ,{53, 167, 160, 26} ,{53, 167, 187, 0} ,{53, 167, 161, 26} ,{161, 184, 186, 0} ,{53, 167, 62, 20} ,{53, 167, 195, 15} ,{53, 167, 163, 26} ,{53, 167, 164, 26} ,{53, 167, 165, 26} ,{53, 167, 63, 6} ,{162, 184, 25, 16} ,{53, 167, 167, 26} ,{53, 167, 168, 26} ,{53, 167, 169, 26} ,{53, 167, 170, 26} ,{163, 184, 172, 26} ,{53, 167, 103, 16} ,{53, 167, 173, 26} ,{53, 167, 174, 26} ,{164, 184, 23, 16} ,{165, 184, 175, 26} ,{167, 184, 141, 0} ,{136, 167, 45, 0} ,{136, 167, 49, 0} ,{136, 167, 46, 0} ,{136, 167, 177, 26} ,{136, 167, 51, 0} ,{136, 167, 48, 0} ,{136, 167, 53, 0} ,{136, 167, 67, 0} ,{136, 167, 70, 0} ,{136, 167, 74, 7} ,{136, 167, 54, 0} ,{136, 167, 55, 0} ,{136, 167, 61, 0} ,{136, 167, 56, 0} ,{136, 167, 57, 0} ,{136, 167, 58, 0} ,{136, 167, 123, 17} ,{136, 167, 36, 4} ,{136, 167, 65, 0} ,{136, 167, 60, 0} ,{136, 167, 207, 7} ,{136, 167, 62, 0} ,{136, 167, 63, 0} ,{136, 167, 64, 0} ,{136, 167, 178, 26} ,{136, 167, 137, 5} ,{136, 167, 157, 1} ,{136, 167, 52, 0} ,{136, 167, 68, 0} ,{33, 167, 45, 0} ,{33, 167, 180, 26} ,{33, 167, 48, 0} ,{33, 167, 56, 0} ,{33, 167, 181, 26} ,{33, 167, 62, 0} ,{33, 167, 182, 26} ,{33, 167, 148, 25} ,{33, 167, 61, 0} ,{33, 167, 46, 0} ,{33, 167, 57, 0} ,{33, 167, 59, 0} ,{33, 167, 183, 26} ,{33, 167, 64, 0} ,{33, 167, 126, 7} ,{33, 167, 184, 26} ,{33, 167, 63, 0} ,{151, 177, 229, 13} ,{33, 167, 65, 0} ,{33, 167, 36, 4} ,{33, 167, 68, 0} ,{33, 167, 58, 0} ,{33, 167, 185, 26} ,{33, 167, 60, 0} ,{33, 167, 226, 22} ,{33, 167, 53, 0} ,{33, 167, 49, 0} ,{33, 167, 186, 26} ,{33, 167, 55, 0} ,{33, 167, 187, 26} ,{33, 167, 188, 26} ,{33, 167, 194, 3} ,{33, 167, 51, 0} ,{33, 167, 189, 26} ,{33, 167, 171, 16} ,{33, 167, 190, 26} ,{33, 167, 228, 2} ,{33, 167, 193, 3} ,{151, 177, 191, 26} ,{33, 167, 178, 26} ,{33, 167, 192, 26} ,{33, 167, 220, 3} ,{33, 167, 106, 17} ,{33, 167, 193, 26} ,{33, 167, 194, 26} ,{33, 167, 195, 26} ,{33, 167, 196, 26} ,{33, 167, 197, 26} ,{33, 167, 198, 26} ,{117, 167, 45, 0} ,{117, 167, 148, 1} ,{117, 167, 106, 6} ,{117, 167, 151, 1} ,{117, 167, 49, 0} ,{117, 167, 149, 1} ,{117, 167, 153, 1} ,{117, 167, 86, 2} ,{117, 167, 181, 6} ,{117, 167, 53, 0} ,{117, 167, 154, 1} ,{117, 167, 155, 1} ,{117, 167, 156, 1} ,{117, 167, 157, 1} ,{117, 167, 191, 0} ,{117, 167, 59, 0} ,{117, 167, 158, 1} ,{117, 167, 36, 6} ,{117, 167, 102, 6} ,{117, 167, 159, 1} ,{117, 167, 160, 1} ,{117, 167, 161, 1} ,{117, 167, 65, 0} ,{117, 167, 199, 26} ,{117, 167, 191, 6} ,{117, 167, 199, 7} ,{117, 167, 162, 1} ,{117, 167, 200, 26} ,{117, 167, 165, 1} ,{117, 167, 193, 3} ,{117, 167, 194, 3} ,{65, 172, 24, 0} ,{65, 172, 28, 0} ,{65, 172, 14, 4} ,{65, 172, 224, 6} ,{158, 167, 202, 26} ,{158, 167, 203, 26} ,{158, 167, 204, 26} ,{158, 167, 205, 26} ,{158, 167, 206, 26} ,{158, 167, 207, 26} ,{158, 167, 208, 26} ,{158, 167, 209, 26} ,{158, 167, 210, 26} ,{158, 167, 211, 26} ,{158, 167, 212, 26} ,{158, 167, 213, 26} ,{158, 167, 214, 26} ,{158, 167, 215, 26} ,{158, 167, 216, 26} ,{158, 167, 217, 26} ,{158, 167, 218, 26} ,{158, 167, 228, 6} ,{158, 167, 219, 26} ,{158, 167, 220, 26} ,{158, 167, 221, 26} ,{158, 167, 222, 26} ,{158, 167, 223, 26} ,{158, 167, 224, 26} ,{158, 167, 219, 0} ,{158, 167, 225, 26} ,{158, 167, 176, 173} ,{127, 167, 227, 26} ,{127, 167, 93, 1} ,{127, 167, 228, 26} ,{127, 167, 199, 3} ,{127, 167, 178, 0} ,{127, 167, 243, 1} ,{127, 167, 206, 4} ,{127, 167, 95, 1} ,{127, 167, 229, 26} ,{127, 167, 89, 2} ,{127, 167, 90, 2} ,{127, 167, 91, 2} ,{127, 167, 100, 2} ,{127, 167, 99, 1} ,{127, 167, 93, 2} ,{127, 167, 230, 26} ,{127, 167, 94, 2} ,{127, 167, 129, 6} ,{127, 167, 231, 26} ,{127, 167, 164, 2} ,{127, 167, 212, 6} ,{127, 167, 232, 26} ,{127, 167, 233, 26} ,{127, 167, 234, 26} ,{127, 167, 235, 26} ,{127, 167, 165, 2} ,{127, 167, 237, 1} ,{127, 167, 53, 0} ,{127, 167, 65, 0} ,{127, 167, 88, 15} ,{226, 26, 213, 173} ,{62, 167, 45, 0} ,{62, 167, 53, 0} ,{62, 167, 65, 0} ,{62, 167, 154, 1} ,{62, 167, 102, 6} ,{62, 167, 200, 3} ,{62, 167, 159, 6} ,{62, 167, 80, 6} ,{62, 167, 241, 1} ,{62, 167, 244, 1} ,{62, 167, 154, 6} ,{62, 167, 129, 3} ,{62, 167, 70, 6} ,{62, 167, 232, 1} ,{62, 167, 142, 6} ,{62, 167, 141, 6} ,{62, 167, 209, 3} ,{62, 167, 128, 3} ,{62, 167, 127, 3} ,{62, 167, 133, 3} ,{62, 167, 139, 3} ,{62, 167, 101, 1} ,{62, 167, 137, 3} ,{62, 167, 9, 6} ,{62, 167, 100, 1} ,{62, 167, 171, 1} ,{62, 167, 216, 3} ,{62, 167, 66, 6} ,{62, 167, 253, 1} ,{62, 167, 154, 4} ,{62, 167, 134, 3} ,{62, 167, 131, 3} ,{62, 167, 234, 1} ,{62, 167, 166, 1} ,{62, 167, 217, 3} ,{62, 167, 163, 1} ,{62, 167, 236, 26} ,{168, 184, 119, 5} ,{62, 167, 238, 26} ,{62, 167, 239, 26} ,{62, 167, 240, 26} ,{169, 184, 119, 5} ,{62, 167, 242, 26} ,{62, 167, 243, 26} ,{31, 167, 213, 173} ,{31, 167, 146, 170} ,{31, 167, 17, 171} ,{31, 167, 192, 168} ,{31, 167, 147, 170} ,{170, 184, 15, 4} ,{141, 170, 53, 0} ,{141, 170, 49, 0} ,{141, 170, 45, 0} ,{141, 170, 183, 8} ,{141, 170, 59, 0} ,{141, 170, 125, 3} ,{142, 170, 53, 0} ,{142, 170, 49, 0} ,{142, 170, 45, 0} ,{142, 170, 183, 8} ,{142, 170, 59, 0} ,{142, 170, 125, 3} ,{73, 167, 214, 4} ,{73, 167, 245, 26} ,{73, 167, 125, 6} ,{73, 167, 139, 6} ,{73, 167, 52, 0} ,{73, 167, 214, 6} ,{73, 167, 63, 6} ,{73, 167, 72, 6} ,{73, 167, 144, 6} ,{73, 167, 185, 6} ,{73, 167, 156, 6} ,{73, 167, 193, 8} ,{73, 167, 246, 26} ,{73, 167, 162, 1} ,{73, 167, 68, 6} ,{73, 167, 137, 0} ,{73, 167, 180, 6} ,{73, 167, 160, 1} ,{73, 167, 131, 6} ,{73, 167, 191, 0} ,{73, 167, 136, 6} ,{73, 167, 159, 1} ,{73, 167, 155, 1} ,{73, 167, 156, 1} ,{73, 167, 157, 1} ,{73, 167, 163, 0} ,{73, 167, 188, 0} ,{73, 167, 247, 26} ,{143, 170, 53, 0} ,{143, 170, 49, 0} ,{143, 170, 45, 0} ,{143, 170, 183, 8} ,{143, 170, 59, 0} ,{143, 170, 125, 3} ,{144, 170, 53, 0} ,{144, 170, 49, 0} ,{144, 170, 45, 0} ,{144, 170, 183, 8} ,{144, 170, 59, 0} ,{144, 170, 125, 3} ,{74, 167, 214, 4} ,{74, 167, 245, 26} ,{74, 167, 125, 6} ,{74, 167, 139, 6} ,{74, 167, 52, 0} ,{74, 167, 214, 6} ,{74, 167, 63, 6} ,{74, 167, 72, 6} ,{74, 167, 144, 6} ,{74, 167, 185, 6} ,{74, 167, 156, 6} ,{74, 167, 193, 8} ,{74, 167, 246, 26} ,{74, 167, 162, 1} ,{74, 167, 68, 6} ,{74, 167, 137, 0} ,{74, 167, 180, 6} ,{74, 167, 160, 1} ,{74, 167, 131, 6} ,{74, 167, 191, 0} ,{74, 167, 136, 6} ,{74, 167, 159, 1} ,{74, 167, 155, 1} ,{74, 167, 156, 1} ,{74, 167, 157, 1} ,{74, 167, 163, 0} ,{74, 167, 188, 0} ,{74, 167, 247, 26} ,{42, 167, 249, 26} ,{42, 167, 232, 18} ,{42, 167, 250, 26} ,{42, 167, 209, 6} ,{42, 167, 251, 26} ,{42, 167, 122, 4} ,{42, 167, 252, 26} ,{42, 167, 8, 13} ,{42, 167, 253, 26} ,{42, 167, 254, 26} ,{42, 167, 255, 26} ,{42, 167, 0, 27} ,{42, 167, 1, 27} ,{42, 167, 2, 27} ,{42, 167, 3, 27} ,{42, 167, 4, 22} ,{42, 167, 4, 27} ,{42, 167, 5, 27} ,{42, 167, 6, 27} ,{171, 184, 163, 1} ,{42, 167, 8, 27} ,{42, 167, 9, 27} ,{42, 167, 10, 27} ,{42, 167, 11, 27} ,{42, 167, 12, 27} ,{42, 167, 13, 27} ,{42, 167, 146, 5} ,{42, 167, 234, 25} ,{42, 167, 233, 11} ,{42, 167, 183, 8} ,{42, 167, 14, 27} ,{42, 167, 94, 2} ,{42, 167, 219, 15} ,{42, 167, 15, 27} ,{42, 167, 240, 15} ,{42, 167, 53, 10} ,{42, 167, 16, 27} ,{42, 167, 17, 27} ,{42, 167, 222, 25} ,{42, 167, 18, 27} ,{42, 167, 19, 27} ,{42, 167, 15, 8} ,{42, 167, 20, 27} ,{42, 167, 195, 9} ,{42, 167, 21, 27} ,{42, 167, 92, 8} ,{42, 167, 22, 27} ,{42, 167, 23, 27} ,{128, 167, 82, 2} ,{128, 167, 127, 3} ,{128, 167, 129, 3} ,{128, 167, 244, 1} ,{128, 167, 80, 6} ,{128, 167, 199, 3} ,{128, 167, 25, 27} ,{128, 167, 253, 1} ,{128, 167, 131, 3} ,{128, 167, 26, 27} ,{128, 167, 210, 3} ,{128, 167, 27, 27} ,{128, 167, 200, 3} ,{128, 167, 133, 3} ,{128, 167, 28, 27} ,{128, 167, 161, 3} ,{128, 167, 29, 27} ,{128, 167, 30, 27} ,{128, 167, 31, 27} ,{128, 167, 175, 2} ,{128, 167, 163, 1} ,{128, 167, 171, 1} ,{128, 167, 45, 0} ,{128, 167, 49, 0} ,{128, 167, 53, 0} ,{128, 167, 59, 0} ,{128, 167, 65, 0} ,{128, 167, 175, 3} ,{128, 167, 124, 3} ,{128, 167, 125, 3} ,{24, 27, 243, 37} ,{24, 27, 244, 37} ,{24, 27, 245, 37} ,{24, 27, 246, 37} ,{24, 27, 247, 37} ,{24, 27, 248, 37} ,{24, 27, 249, 37} ,{24, 27, 250, 37} ,{24, 27, 251, 37} ,{24, 27, 252, 37} ,{248, 166, 45, 0} ,{248, 166, 49, 0} ,{248, 166, 53, 0} ,{248, 166, 59, 0} ,{248, 166, 65, 0} ,{248, 166, 244, 1} ,{248, 166, 157, 6} ,{248, 166, 154, 1} ,{248, 166, 106, 6} ,{248, 166, 103, 6} ,{248, 166, 194, 4} ,{248, 166, 102, 6} ,{248, 166, 134, 3} ,{248, 166, 0, 6} ,{248, 166, 253, 5} ,{248, 166, 212, 4} ,{248, 166, 157, 4} ,{248, 166, 137, 3} ,{248, 166, 12, 6} ,{248, 166, 9, 6} ,{248, 166, 203, 4} ,{248, 166, 100, 1} ,{248, 166, 139, 3} ,{248, 166, 94, 6} ,{248, 166, 92, 6} ,{248, 166, 200, 4} ,{248, 166, 101, 1} ,{248, 166, 128, 3} ,{248, 166, 158, 1} ,{248, 166, 104, 1} ,{248, 166, 202, 4} ,{248, 166, 212, 6} ,{248, 166, 253, 1} ,{248, 166, 24, 6} ,{248, 166, 22, 6} ,{248, 166, 46, 5} ,{248, 166, 154, 4} ,{248, 166, 131, 3} ,{248, 166, 30, 6} ,{248, 166, 27, 6} ,{248, 166, 122, 4} ,{248, 166, 26, 6} ,{248, 166, 129, 3} ,{248, 166, 161, 1} ,{248, 166, 215, 4} ,{248, 166, 237, 1} ,{248, 166, 70, 6} ,{248, 166, 140, 3} ,{248, 166, 226, 1} ,{248, 166, 230, 5} ,{248, 166, 206, 4} ,{248, 166, 80, 6} ,{248, 166, 84, 6} ,{248, 166, 234, 1} ,{248, 166, 107, 3} ,{235, 167, 35, 27} ,{235, 167, 27, 3} ,{235, 167, 84, 2} ,{235, 167, 36, 27} ,{235, 167, 86, 2} ,{235, 167, 175, 2} ,{235, 167, 87, 2} ,{235, 167, 34, 3} ,{235, 167, 35, 3} ,{235, 167, 37, 27} ,{235, 167, 39, 3} ,{235, 167, 38, 27} ,{235, 167, 93, 2} ,{235, 167, 94, 2} ,{235, 167, 95, 2} ,{235, 167, 96, 2} ,{235, 167, 158, 1} ,{235, 167, 43, 3} ,{235, 167, 39, 27} ,{235, 167, 99, 2} ,{235, 167, 100, 2} ,{235, 167, 45, 3} ,{118, 167, 73, 38} ,{118, 167, 146, 170} ,{118, 167, 17, 171} ,{118, 167, 70, 172} ,{118, 167, 192, 168} ,{118, 167, 147, 170} ,{118, 167, 17, 170} ,{118, 167, 148, 170} ,{172, 184, 66, 172} ,{236, 167, 41, 27} ,{236, 167, 83, 2} ,{236, 167, 42, 27} ,{236, 167, 43, 27} ,{236, 167, 86, 2} ,{236, 167, 11, 15} ,{236, 167, 44, 27} ,{236, 167, 88, 2} ,{236, 167, 89, 2} ,{236, 167, 90, 2} ,{236, 167, 91, 2} ,{236, 167, 45, 27} ,{236, 167, 93, 2} ,{236, 167, 94, 2} ,{236, 167, 46, 27} ,{236, 167, 164, 2} ,{236, 167, 158, 1} ,{236, 167, 232, 26} ,{236, 167, 98, 2} ,{236, 167, 47, 27} ,{236, 167, 100, 2} ,{236, 167, 107, 1} ,{40, 27, 146, 170} ,{40, 27, 192, 168} ,{40, 27, 147, 170} ,{40, 27, 17, 170} ,{40, 27, 17, 171} ,{40, 27, 70, 172} ,{173, 184, 121, 2} ,{172, 167, 45, 0} ,{172, 167, 46, 0} ,{172, 167, 51, 0} ,{172, 167, 48, 0} ,{172, 167, 49, 0} ,{172, 167, 66, 0} ,{172, 167, 53, 0} ,{172, 167, 69, 0} ,{172, 167, 55, 0} ,{172, 167, 56, 0} ,{172, 167, 57, 0} ,{172, 167, 58, 0} ,{172, 167, 59, 0} ,{172, 167, 62, 0} ,{172, 167, 226, 22} ,{172, 167, 64, 0} ,{172, 167, 65, 0} ,{172, 167, 50, 0} ,{172, 167, 61, 0} ,{172, 167, 63, 0} ,{172, 167, 178, 26} ,{172, 167, 137, 5} ,{172, 167, 157, 1} ,{172, 167, 120, 8} ,{172, 167, 36, 4} ,{172, 167, 47, 0} ,{174, 184, 3, 0} ,{101, 167, 45, 0} ,{49, 27, 149, 167} ,{49, 27, 138, 167} ,{49, 27, 225, 168} ,{49, 27, 220, 167} ,{49, 27, 245, 167} ,{175, 184, 42, 169} ,{176, 184, 16, 170} ,{49, 27, 226, 168} ,{49, 27, 227, 168} ,{101, 167, 154, 1} ,{101, 167, 199, 3} ,{101, 167, 200, 3} ,{101, 167, 201, 3} ,{101, 167, 241, 1} ,{101, 167, 250, 1} ,{101, 167, 244, 1} ,{101, 167, 138, 3} ,{101, 167, 204, 3} ,{101, 167, 205, 3} ,{101, 167, 206, 3} ,{101, 167, 207, 3} ,{101, 167, 208, 3} ,{101, 167, 129, 3} ,{101, 167, 209, 3} ,{101, 167, 232, 1} ,{101, 167, 210, 3} ,{101, 167, 139, 3} ,{101, 167, 128, 3} ,{101, 167, 212, 3} ,{101, 167, 127, 3} ,{101, 167, 213, 3} ,{101, 167, 137, 3} ,{101, 167, 171, 1} ,{101, 167, 253, 1} ,{101, 167, 134, 3} ,{101, 167, 216, 3} ,{101, 167, 166, 1} ,{101, 167, 217, 3} ,{101, 167, 131, 3} ,{101, 167, 234, 1} ,{101, 167, 163, 1} ,{101, 167, 42, 5} ,{101, 167, 50, 27} ,{177, 184, 132, 0} ,{67, 172, 51, 27} ,{67, 172, 57, 168} ,{49, 27, 221, 3} ,{49, 27, 244, 37} ,{49, 27, 245, 37} ,{49, 27, 246, 37} ,{49, 27, 247, 37} ,{49, 27, 192, 168} ,{49, 27, 147, 170} ,{49, 27, 17, 170} ,{49, 27, 148, 170} ,{120, 169, 115, 0} ,{120, 169, 145, 170} ,{120, 169, 52, 2} ,{178, 184, 91, 0} ,{120, 169, 53, 27} ,{120, 169, 54, 27} ,{120, 169, 232, 3} ,{120, 169, 19, 171} ,{120, 169, 55, 27} ,{137, 167, 86, 2} ,{137, 167, 38, 27} ,{137, 167, 34, 3} ,{137, 167, 93, 2} ,{137, 167, 39, 27} ,{137, 167, 175, 2} ,{137, 167, 100, 2} ,{137, 167, 99, 2} ,{137, 167, 27, 3} ,{137, 167, 45, 3} ,{137, 167, 21, 9} ,{137, 167, 39, 3} ,{137, 167, 94, 2} ,{137, 167, 57, 27} ,{137, 167, 43, 3} ,{137, 167, 95, 2} ,{137, 167, 69, 3} ,{137, 167, 82, 2} ,{137, 167, 58, 27} ,{137, 167, 59, 27} ,{137, 167, 84, 2} ,{137, 167, 36, 27} ,{137, 167, 60, 27} ,{137, 167, 35, 3} ,{137, 167, 61, 27} ,{137, 167, 62, 27} ,{137, 167, 37, 27} ,{137, 167, 63, 27} ,{137, 167, 64, 27} ,{115, 167, 146, 170} ,{179, 184, 224, 6} ,{180, 184, 97, 0} ,{253, 166, 45, 0} ,{253, 166, 175, 3} ,{253, 166, 250, 9} ,{253, 166, 67, 27} ,{253, 166, 137, 5} ,{253, 166, 68, 27} ,{253, 166, 133, 0} ,{253, 166, 69, 27} ,{253, 166, 49, 0} ,{253, 166, 124, 3} ,{253, 166, 59, 0} ,{253, 166, 125, 3} ,{253, 166, 53, 0} ,{253, 166, 193, 3} ,{253, 166, 65, 0} ,{253, 166, 194, 3} ,{253, 166, 106, 6} ,{253, 166, 84, 6} ,{253, 166, 133, 15} ,{253, 166, 70, 27} ,{253, 166, 163, 6} ,{253, 166, 175, 6} ,{253, 166, 150, 1} ,{253, 166, 78, 6} ,{253, 166, 142, 1} ,{253, 166, 161, 1} ,{253, 166, 181, 6} ,{253, 166, 151, 1} ,{253, 166, 42, 22} ,{253, 166, 49, 7} ,{253, 166, 158, 1} ,{253, 166, 69, 3} ,{253, 166, 148, 1} ,{253, 166, 35, 22} ,{253, 166, 2, 20} ,{253, 166, 71, 27} ,{253, 166, 72, 27} ,{253, 166, 94, 6} ,{253, 166, 100, 6} ,{253, 166, 73, 27} ,{253, 166, 12, 6} ,{253, 166, 74, 27} ,{253, 166, 75, 27} ,{253, 166, 227, 5} ,{253, 166, 149, 1} ,{253, 166, 24, 6} ,{253, 166, 0, 6} ,{253, 166, 30, 6} ,{253, 166, 153, 1} ,{253, 166, 36, 6} ,{253, 166, 152, 1} ,{253, 166, 76, 27} ,{253, 166, 77, 27} ,{253, 166, 86, 2} ,{66, 27, 68, 172} ,{78, 27, 245, 76} ,{79, 0, 245, 76} ,{61, 12, 245, 76} ,{61, 12, 246, 76} ,{184, 184, 100, 8} ,{188, 184, 100, 8} ,{237, 167, 35, 27} ,{237, 167, 27, 3} ,{237, 167, 84, 2} ,{237, 167, 36, 27} ,{237, 167, 86, 2} ,{237, 167, 175, 2} ,{237, 167, 87, 2} ,{237, 167, 34, 3} ,{237, 167, 35, 3} ,{237, 167, 37, 27} ,{237, 167, 39, 3} ,{237, 167, 38, 27} ,{237, 167, 93, 2} ,{237, 167, 94, 2} ,{237, 167, 95, 2} ,{237, 167, 96, 2} ,{237, 167, 158, 1} ,{237, 167, 43, 3} ,{237, 167, 39, 27} ,{237, 167, 99, 2} ,{237, 167, 100, 2} ,{237, 167, 45, 3} ,{129, 167, 146, 170} ,{129, 167, 17, 171} ,{129, 167, 70, 172} ,{129, 167, 155, 177} ,{129, 167, 192, 168} ,{129, 167, 147, 170} ,{129, 167, 17, 170} ,{129, 167, 148, 170} ,{16, 168, 35, 27} ,{16, 168, 27, 3} ,{16, 168, 84, 2} ,{16, 168, 36, 27} ,{16, 168, 86, 2} ,{190, 184, 99, 2} ,{16, 168, 87, 2} ,{16, 168, 34, 3} ,{16, 168, 35, 3} ,{16, 168, 37, 27} ,{16, 168, 39, 3} ,{16, 168, 38, 27} ,{191, 184, 39, 27} ,{16, 168, 94, 2} ,{16, 168, 95, 2} ,{16, 168, 158, 1} ,{16, 168, 43, 3} ,{16, 168, 100, 2} ,{16, 168, 45, 3} ,{159, 167, 146, 170} ,{159, 167, 17, 171} ,{159, 167, 70, 172} ,{159, 167, 155, 177} ,{159, 167, 192, 168} ,{159, 167, 147, 170} ,{159, 167, 17, 170} ,{159, 167, 148, 170} ,{67, 167, 45, 0} ,{119, 167, 45, 0} ,{119, 167, 133, 0} ,{67, 167, 53, 0} ,{119, 167, 53, 0} ,{119, 167, 49, 0} ,{67, 167, 59, 0} ,{67, 167, 164, 0} ,{119, 167, 164, 0} ,{67, 167, 89, 27} ,{119, 167, 89, 27} ,{67, 167, 90, 27} ,{119, 167, 90, 27} ,{67, 167, 180, 9} ,{119, 167, 180, 9} ,{67, 167, 91, 27} ,{119, 167, 91, 27} ,{67, 167, 92, 27} ,{119, 167, 92, 27} ,{67, 167, 93, 27} ,{67, 167, 94, 27} ,{119, 167, 94, 27} ,{67, 167, 214, 4} ,{119, 167, 214, 4} ,{67, 167, 95, 27} ,{119, 167, 95, 27} ,{67, 167, 96, 27} ,{119, 167, 96, 27} ,{67, 167, 97, 27} ,{119, 167, 97, 27} ,{67, 167, 181, 9} ,{119, 167, 181, 9} ,{67, 167, 98, 27} ,{67, 167, 99, 27} ,{67, 167, 156, 1} ,{67, 167, 137, 5} ,{67, 167, 100, 27} ,{119, 167, 100, 27} ,{67, 167, 101, 27} ,{119, 167, 101, 27} ,{67, 167, 102, 27} ,{119, 167, 102, 27} ,{67, 167, 103, 27} ,{119, 167, 103, 27} ,{119, 167, 166, 4} ,{67, 167, 163, 0} ,{119, 167, 104, 27} ,{67, 167, 193, 9} ,{67, 167, 249, 17} ,{67, 167, 105, 27} ,{67, 167, 106, 27} ,{119, 167, 106, 27} ,{67, 167, 126, 8} ,{119, 167, 126, 8} ,{67, 167, 107, 27} ,{119, 167, 107, 27} ,{67, 167, 108, 27} ,{119, 167, 108, 27} ,{67, 167, 109, 27} ,{119, 167, 109, 27} ,{67, 167, 110, 27} ,{67, 167, 137, 14} ,{67, 167, 111, 27} ,{67, 167, 12, 27} ,{119, 167, 12, 27} ,{67, 167, 191, 0} ,{119, 167, 191, 0} ,{67, 167, 41, 0} ,{119, 167, 41, 0} ,{67, 167, 112, 27} ,{119, 167, 112, 27} ,{67, 167, 184, 1} ,{67, 167, 113, 27} ,{114, 27, 244, 37} ,{114, 27, 245, 37} ,{114, 27, 246, 37} ,{114, 27, 247, 37} ,{114, 27, 248, 37} ,{114, 27, 249, 37} ,{114, 27, 250, 37} ,{114, 27, 251, 37} ,{114, 27, 252, 37} ,{37, 168, 14, 4} ,{37, 168, 221, 6} ,{37, 168, 222, 6} ,{37, 168, 223, 6} ,{37, 168, 224, 6} ,{37, 168, 225, 6} ,{37, 168, 226, 6} ,{37, 168, 227, 6} ,{37, 168, 228, 6} ,{37, 168, 149, 170} ,{192, 184, 15, 4} ,{37, 168, 175, 173} ,{193, 184, 15, 4} ,{37, 168, 43, 169} ,{194, 184, 15, 4} ,{195, 184, 15, 4} ,{196, 184, 15, 4} ,{37, 168, 176, 173} ,{114, 27, 177, 173} ,{114, 27, 156, 177} ,{197, 184, 170, 10} ,{199, 184, 171, 10} ,{115, 27, 18, 171} ,{115, 27, 226, 168} ,{115, 27, 227, 168} ,{56, 167, 45, 0} ,{56, 167, 175, 3} ,{56, 167, 53, 0} ,{56, 167, 193, 3} ,{56, 167, 65, 0} ,{56, 167, 194, 3} ,{56, 167, 49, 0} ,{56, 167, 197, 3} ,{56, 167, 59, 0} ,{56, 167, 198, 3} ,{56, 167, 154, 1} ,{56, 167, 199, 3} ,{56, 167, 200, 3} ,{56, 167, 201, 3} ,{56, 167, 202, 3} ,{56, 167, 241, 1} ,{56, 167, 250, 1} ,{56, 167, 244, 1} ,{56, 167, 203, 3} ,{56, 167, 138, 3} ,{56, 167, 204, 3} ,{56, 167, 205, 3} ,{56, 167, 206, 3} ,{56, 167, 229, 3} ,{56, 167, 207, 3} ,{56, 167, 223, 1} ,{56, 167, 208, 3} ,{56, 167, 129, 3} ,{56, 167, 209, 3} ,{56, 167, 232, 1} ,{56, 167, 210, 3} ,{56, 167, 139, 3} ,{56, 167, 128, 3} ,{56, 167, 212, 3} ,{56, 167, 127, 3} ,{56, 167, 213, 3} ,{56, 167, 137, 3} ,{56, 167, 171, 1} ,{56, 167, 253, 1} ,{56, 167, 134, 3} ,{56, 167, 216, 3} ,{56, 167, 166, 1} ,{56, 167, 217, 3} ,{56, 167, 131, 3} ,{56, 167, 163, 1} ,{115, 27, 17, 168} ,{115, 27, 149, 167} ,{115, 27, 58, 168} ,{115, 27, 138, 167} ,{115, 27, 59, 168} ,{115, 27, 220, 167} ,{115, 27, 60, 168} ,{115, 27, 245, 167} ,{115, 27, 99, 168} ,{115, 27, 228, 168} ,{115, 27, 18, 170} ,{115, 27, 157, 177} ,{200, 184, 6, 0} ,{115, 27, 230, 37} ,{115, 27, 71, 172} ,{201, 184, 71, 172} ,{115, 27, 232, 3} ,{115, 27, 19, 171} ,{124, 166, 45, 0} ,{199, 169, 50, 169} ,{199, 169, 206, 169} ,{150, 170, 101, 168} ,{150, 170, 163, 1} ,{150, 170, 121, 27} ,{150, 170, 203, 177} ,{150, 170, 124, 27} ,{150, 170, 125, 27} ,{124, 166, 148, 25} ,{124, 166, 89, 27} ,{45, 169, 127, 27} ,{45, 169, 182, 173} ,{45, 169, 165, 17} ,{45, 169, 101, 168} ,{45, 169, 163, 1} ,{45, 169, 48, 169} ,{45, 169, 130, 27} ,{45, 169, 131, 27} ,{45, 169, 132, 27} ,{45, 169, 206, 173} ,{229, 168, 123, 27} ,{124, 166, 133, 27} ,{20, 171, 135, 27} ,{20, 171, 101, 168} ,{20, 171, 77, 172} ,{20, 171, 136, 27} ,{20, 171, 137, 27} ,{124, 166, 92, 27} ,{124, 166, 138, 27} ,{159, 177, 140, 27} ,{202, 184, 142, 27} ,{124, 166, 181, 9} ,{201, 169, 181, 9} ,{201, 169, 144, 27} ,{201, 169, 142, 27} ,{201, 169, 163, 1} ,{201, 169, 145, 27} ,{201, 169, 103, 6} ,{201, 169, 36, 6} ,{201, 169, 146, 27} ,{124, 166, 147, 27} ,{124, 166, 35, 27} ,{124, 166, 148, 27} ,{203, 184, 75, 172} ,{124, 166, 137, 5} ,{204, 184, 137, 5} ,{205, 184, 68, 10} ,{208, 184, 152, 27} ,{161, 177, 95, 17} ,{124, 166, 153, 27} ,{124, 166, 154, 27} ,{124, 166, 155, 27} ,{209, 184, 22, 170} ,{124, 166, 157, 27} ,{124, 166, 158, 27} ,{124, 166, 12, 27} ,{162, 177, 196, 177} ,{162, 177, 233, 177} ,{212, 184, 29, 18} ,{165, 177, 12, 27} ,{216, 184, 12, 27} ,{124, 166, 127, 27} ,{124, 166, 163, 27} ,{124, 166, 127, 3} ,{124, 166, 118, 27} ,{124, 166, 164, 27} ,{124, 166, 165, 27} ,{124, 166, 166, 27} ,{218, 184, 166, 27} ,{124, 166, 135, 27} ,{124, 166, 91, 0} ,{124, 166, 168, 27} ,{124, 166, 62, 6} ,{179, 173, 50, 169} ,{219, 184, 46, 8} ,{179, 173, 189, 173} ,{124, 166, 73, 5} ,{167, 177, 89, 27} ,{167, 177, 151, 5} ,{220, 184, 73, 5} ,{124, 166, 170, 27} ,{222, 184, 170, 27} ,{124, 166, 15, 18} ,{124, 166, 172, 27} ,{124, 166, 232, 1} ,{124, 166, 139, 9} ,{223, 184, 175, 27} ,{222, 167, 148, 27} ,{222, 167, 135, 27} ,{222, 167, 62, 6} ,{222, 167, 200, 3} ,{225, 184, 175, 27} ,{222, 167, 160, 6} ,{222, 167, 176, 27} ,{222, 167, 177, 27} ,{222, 167, 163, 1} ,{222, 167, 189, 9} ,{226, 184, 198, 177} ,{222, 167, 179, 27} ,{222, 167, 134, 3} ,{222, 167, 157, 4} ,{227, 184, 181, 27} ,{222, 167, 132, 22} ,{222, 167, 94, 6} ,{229, 184, 29, 18} ,{222, 167, 27, 6} ,{222, 167, 137, 27} ,{230, 184, 176, 27} ,{222, 167, 146, 27} ,{124, 166, 184, 27} ,{124, 166, 185, 27} ,{124, 166, 186, 27} ,{124, 166, 187, 27} ,{124, 166, 142, 6} ,{124, 166, 188, 27} ,{124, 166, 189, 27} ,{124, 166, 174, 177} ,{124, 166, 144, 27} ,{124, 166, 191, 27} ,{234, 184, 46, 16} ,{124, 166, 46, 16} ,{124, 166, 141, 6} ,{235, 184, 141, 6} ,{181, 173, 123, 27} ,{181, 173, 196, 27} ,{124, 166, 197, 27} ,{237, 184, 199, 27} ,{124, 166, 200, 27} ,{124, 166, 138, 9} ,{124, 166, 201, 27} ,{124, 166, 202, 27} ,{124, 166, 203, 27} ,{124, 166, 204, 27} ,{124, 166, 182, 173} ,{124, 166, 172, 177} ,{124, 166, 205, 27} ,{124, 166, 206, 27} ,{124, 166, 49, 0} ,{238, 184, 29, 18} ,{240, 184, 177, 177} ,{124, 166, 197, 26} ,{242, 184, 232, 1} ,{152, 170, 46, 8} ,{152, 170, 9, 6} ,{152, 170, 208, 27} ,{152, 170, 36, 6} ,{152, 170, 65, 0} ,{124, 166, 209, 27} ,{124, 166, 210, 27} ,{124, 166, 155, 1} ,{124, 166, 157, 1} ,{169, 177, 211, 27} ,{153, 170, 79, 172} ,{169, 177, 12, 6} ,{243, 184, 157, 1} ,{244, 184, 157, 1} ,{153, 170, 95, 17} ,{124, 166, 212, 27} ,{124, 166, 140, 27} ,{124, 166, 199, 27} ,{124, 166, 213, 27} ,{19, 168, 45, 0} ,{170, 177, 215, 27} ,{170, 177, 196, 173} ,{19, 168, 137, 5} ,{19, 168, 118, 27} ,{19, 168, 182, 173} ,{19, 168, 172, 177} ,{19, 168, 163, 1} ,{245, 184, 123, 27} ,{19, 168, 48, 169} ,{19, 168, 217, 27} ,{246, 184, 95, 17} ,{19, 168, 218, 27} ,{19, 168, 134, 3} ,{19, 168, 196, 173} ,{19, 168, 253, 5} ,{19, 168, 157, 4} ,{19, 168, 219, 27} ,{19, 168, 191, 9} ,{124, 166, 200, 3} ,{247, 184, 123, 27} ,{124, 166, 220, 27} ,{183, 173, 195, 177} ,{183, 173, 163, 1} ,{183, 173, 121, 27} ,{250, 184, 223, 27} ,{3, 167, 137, 5} ,{3, 167, 12, 27} ,{252, 184, 165, 17} ,{3, 167, 118, 27} ,{253, 184, 173, 177} ,{3, 167, 15, 18} ,{254, 184, 173, 177} ,{3, 167, 232, 1} ,{3, 167, 142, 6} ,{3, 167, 174, 177} ,{3, 167, 197, 27} ,{3, 167, 155, 1} ,{255, 184, 176, 177} ,{3, 167, 157, 1} ,{0, 185, 79, 172} ,{3, 167, 101, 168} ,{3, 167, 46, 8} ,{3, 167, 160, 6} ,{3, 167, 226, 27} ,{1, 185, 193, 173} ,{3, 185, 26, 6} ,{5, 185, 199, 27} ,{3, 167, 229, 27} ,{6, 185, 176, 177} ,{8, 185, 253, 5} ,{3, 167, 232, 27} ,{3, 167, 48, 169} ,{11, 185, 49, 169} ,{3, 167, 179, 27} ,{3, 167, 217, 27} ,{3, 167, 235, 27} ,{13, 185, 215, 27} ,{15, 185, 137, 5} ,{3, 167, 134, 3} ,{3, 167, 77, 172} ,{3, 167, 9, 6} ,{3, 167, 94, 2} ,{3, 167, 177, 177} ,{3, 167, 128, 3} ,{3, 167, 208, 27} ,{3, 167, 238, 27} ,{3, 167, 36, 6} ,{16, 185, 240, 18} ,{3, 167, 240, 27} ,{3, 167, 151, 14} ,{3, 167, 137, 27} ,{3, 167, 65, 0} ,{3, 167, 191, 9} ,{18, 185, 141, 6} ,{19, 185, 220, 27} ,{124, 166, 242, 27} ,{21, 185, 242, 27} ,{124, 166, 244, 27} ,{124, 166, 84, 172} ,{124, 166, 165, 17} ,{22, 185, 84, 172} ,{124, 166, 248, 27} ,{124, 166, 249, 27} ,{124, 166, 139, 5} ,{124, 166, 211, 27} ,{124, 166, 101, 168} ,{23, 185, 211, 27} ,{24, 185, 211, 27} ,{124, 166, 46, 8} ,{124, 166, 250, 27} ,{124, 166, 251, 27} ,{124, 166, 252, 27} ,{25, 185, 22, 170} ,{124, 166, 160, 6} ,{184, 173, 210, 177} ,{184, 173, 210, 173} ,{26, 185, 160, 6} ,{124, 166, 226, 27} ,{27, 185, 226, 27} ,{28, 185, 226, 27} ,{124, 166, 254, 27} ,{124, 166, 176, 27} ,{29, 185, 123, 27} ,{124, 166, 255, 27} ,{30, 185, 121, 27} ,{22, 171, 101, 168} ,{22, 171, 121, 27} ,{31, 185, 121, 27} ,{22, 171, 128, 3} ,{124, 166, 1, 28} ,{124, 166, 142, 27} ,{73, 172, 185, 177} ,{73, 172, 206, 169} ,{73, 172, 29, 171} ,{73, 172, 120, 27} ,{124, 166, 159, 6} ,{33, 185, 159, 6} ,{124, 166, 4, 28} ,{74, 172, 179, 27} ,{74, 172, 186, 177} ,{74, 172, 94, 2} ,{35, 185, 8, 28} ,{23, 171, 123, 27} ,{124, 166, 177, 27} ,{36, 185, 177, 19} ,{186, 173, 22, 170} ,{38, 185, 10, 28} ,{124, 166, 11, 28} ,{124, 166, 12, 28} ,{39, 185, 75, 172} ,{124, 166, 154, 19} ,{124, 166, 14, 28} ,{124, 166, 15, 28} ,{124, 166, 16, 28} ,{124, 166, 163, 1} ,{180, 177, 120, 27} ,{180, 177, 123, 27} ,{124, 166, 229, 27} ,{124, 166, 250, 5} ,{122, 169, 12, 27} ,{122, 169, 127, 27} ,{122, 169, 118, 27} ,{122, 169, 46, 16} ,{122, 169, 244, 27} ,{122, 169, 17, 28} ,{122, 169, 94, 2} ,{122, 169, 36, 6} ,{122, 169, 65, 0} ,{124, 166, 249, 5} ,{124, 166, 232, 27} ,{25, 171, 137, 5} ,{25, 171, 229, 27} ,{25, 171, 217, 27} ,{25, 171, 19, 28} ,{25, 171, 191, 9} ,{124, 166, 20, 28} ,{124, 166, 53, 0} ,{40, 185, 45, 0} ,{124, 166, 21, 28} ,{124, 166, 22, 28} ,{183, 177, 15, 18} ,{183, 177, 95, 17} ,{124, 166, 24, 28} ,{124, 166, 121, 27} ,{187, 173, 188, 27} ,{187, 173, 22, 6} ,{46, 185, 191, 9} ,{124, 166, 48, 169} ,{124, 166, 26, 28} ,{47, 185, 79, 172} ,{124, 166, 28, 28} ,{124, 166, 147, 16} ,{76, 172, 29, 171} ,{48, 185, 147, 16} ,{49, 185, 147, 16} ,{76, 172, 95, 17} ,{124, 166, 130, 27} ,{124, 166, 164, 3} ,{124, 166, 189, 9} ,{124, 166, 30, 28} ,{124, 166, 154, 1} ,{5, 167, 45, 0} ,{5, 167, 92, 27} ,{51, 185, 218, 27} ,{5, 167, 127, 27} ,{5, 167, 118, 27} ,{5, 167, 135, 27} ,{5, 167, 91, 0} ,{5, 167, 62, 6} ,{5, 167, 140, 27} ,{5, 167, 199, 27} ,{5, 167, 200, 3} ,{5, 167, 165, 17} ,{5, 167, 101, 168} ,{5, 167, 46, 8} ,{53, 185, 193, 173} ,{5, 167, 160, 6} ,{5, 167, 176, 27} ,{54, 185, 238, 27} ,{184, 177, 185, 177} ,{5, 167, 159, 6} ,{5, 167, 14, 28} ,{5, 167, 121, 27} ,{5, 167, 147, 16} ,{5, 167, 179, 27} ,{5, 167, 103, 6} ,{5, 167, 235, 27} ,{5, 167, 253, 5} ,{5, 167, 157, 4} ,{5, 167, 12, 6} ,{188, 173, 141, 6} ,{188, 173, 160, 6} ,{188, 173, 161, 1} ,{5, 167, 9, 6} ,{56, 185, 33, 28} ,{5, 167, 94, 6} ,{5, 167, 94, 2} ,{5, 167, 104, 1} ,{5, 167, 154, 4} ,{5, 167, 131, 3} ,{5, 167, 238, 27} ,{5, 167, 166, 1} ,{5, 167, 36, 6} ,{5, 167, 240, 27} ,{5, 167, 32, 6} ,{5, 167, 34, 28} ,{5, 167, 35, 28} ,{5, 167, 150, 5} ,{5, 167, 65, 0} ,{5, 167, 219, 27} ,{5, 167, 191, 9} ,{57, 185, 128, 3} ,{5, 167, 146, 27} ,{5, 167, 130, 6} ,{124, 166, 37, 28} ,{59, 185, 37, 28} ,{124, 166, 39, 28} ,{124, 166, 40, 28} ,{124, 166, 145, 27} ,{124, 166, 41, 28} ,{124, 166, 42, 28} ,{61, 185, 42, 28} ,{124, 166, 179, 27} ,{124, 166, 186, 177} ,{124, 166, 44, 28} ,{187, 177, 206, 169} ,{62, 185, 44, 28} ,{124, 166, 46, 28} ,{124, 166, 47, 28} ,{124, 166, 217, 27} ,{188, 177, 192, 177} ,{64, 185, 192, 177} ,{124, 166, 49, 28} ,{124, 166, 103, 6} ,{190, 173, 206, 169} ,{190, 173, 210, 173} ,{190, 173, 202, 173} ,{124, 166, 235, 27} ,{124, 166, 17, 28} ,{124, 166, 51, 28} ,{124, 166, 52, 28} ,{124, 166, 53, 28} ,{66, 185, 53, 28} ,{124, 166, 102, 6} ,{69, 185, 127, 27} ,{124, 166, 218, 27} ,{124, 166, 54, 28} ,{70, 185, 158, 170} ,{124, 166, 56, 28} ,{124, 166, 57, 28} ,{71, 185, 123, 27} ,{124, 166, 59, 28} ,{124, 166, 177, 19} ,{73, 185, 177, 19} ,{124, 166, 61, 28} ,{124, 166, 62, 28} ,{124, 166, 134, 3} ,{124, 166, 131, 27} ,{32, 167, 45, 0} ,{191, 173, 195, 177} ,{191, 173, 46, 8} ,{191, 173, 215, 27} ,{32, 167, 181, 9} ,{32, 167, 137, 5} ,{74, 185, 196, 177} ,{32, 167, 118, 27} ,{32, 167, 62, 6} ,{32, 167, 185, 27} ,{32, 167, 157, 1} ,{32, 167, 200, 3} ,{32, 167, 46, 8} ,{32, 167, 177, 27} ,{76, 185, 177, 27} ,{32, 167, 163, 1} ,{32, 167, 229, 27} ,{77, 185, 94, 2} ,{32, 167, 48, 169} ,{32, 167, 147, 16} ,{197, 177, 192, 173} ,{197, 177, 198, 177} ,{32, 167, 103, 6} ,{32, 167, 17, 28} ,{32, 167, 218, 27} ,{32, 167, 57, 28} ,{80, 185, 193, 173} ,{32, 167, 131, 27} ,{32, 167, 19, 28} ,{32, 167, 157, 4} ,{32, 167, 63, 28} ,{32, 167, 12, 6} ,{32, 167, 77, 172} ,{32, 167, 124, 27} ,{32, 167, 94, 6} ,{32, 167, 202, 177} ,{81, 185, 140, 27} ,{200, 177, 120, 27} ,{32, 167, 64, 28} ,{83, 185, 64, 28} ,{32, 167, 151, 14} ,{32, 167, 66, 28} ,{32, 167, 137, 27} ,{88, 185, 139, 3} ,{32, 167, 65, 0} ,{32, 167, 218, 177} ,{32, 167, 206, 173} ,{32, 167, 209, 173} ,{32, 167, 191, 9} ,{32, 167, 146, 27} ,{89, 185, 95, 17} ,{124, 166, 67, 28} ,{201, 177, 36, 6} ,{201, 177, 202, 177} ,{124, 166, 203, 177} ,{92, 185, 36, 6} ,{124, 166, 68, 28} ,{124, 166, 215, 27} ,{124, 166, 196, 173} ,{124, 166, 171, 2} ,{205, 177, 22, 170} ,{95, 185, 154, 4} ,{124, 166, 253, 5} ,{124, 166, 69, 28} ,{124, 166, 70, 28} ,{124, 166, 19, 28} ,{124, 166, 157, 4} ,{96, 185, 206, 169} ,{124, 166, 71, 28} ,{20, 168, 181, 9} ,{20, 168, 118, 27} ,{20, 168, 199, 27} ,{97, 185, 120, 27} ,{20, 168, 101, 168} ,{98, 185, 118, 27} ,{20, 168, 147, 16} ,{20, 168, 40, 28} ,{20, 168, 145, 27} ,{99, 185, 49, 169} ,{20, 168, 103, 6} ,{100, 185, 49, 169} ,{20, 168, 131, 27} ,{20, 168, 77, 172} ,{20, 168, 94, 6} ,{20, 168, 101, 1} ,{101, 185, 49, 169} ,{103, 185, 73, 5} ,{20, 168, 8, 28} ,{207, 167, 120, 27} ,{104, 185, 71, 28} ,{105, 185, 71, 28} ,{207, 167, 95, 17} ,{207, 167, 196, 27} ,{124, 166, 77, 28} ,{124, 166, 10, 28} ,{106, 185, 10, 28} ,{107, 185, 10, 28} ,{197, 173, 196, 27} ,{124, 166, 79, 28} ,{124, 166, 63, 28} ,{124, 166, 132, 22} ,{207, 177, 132, 22} ,{108, 185, 21, 170} ,{124, 166, 137, 3} ,{208, 177, 29, 171} ,{208, 177, 123, 27} ,{124, 166, 81, 28} ,{124, 166, 82, 28} ,{124, 166, 83, 28} ,{124, 166, 175, 27} ,{124, 166, 181, 27} ,{124, 166, 12, 6} ,{124, 166, 84, 28} ,{124, 166, 9, 6} ,{124, 166, 85, 28} ,{124, 166, 100, 1} ,{110, 185, 100, 1} ,{124, 166, 86, 28} ,{111, 185, 123, 27} ,{124, 166, 88, 28} ,{124, 166, 89, 28} ,{124, 166, 124, 27} ,{154, 170, 50, 169} ,{154, 170, 22, 170} ,{112, 185, 234, 1} ,{209, 177, 124, 27} ,{114, 185, 139, 3} ,{115, 185, 124, 27} ,{124, 166, 91, 28} ,{78, 172, 50, 169} ,{116, 185, 142, 6} ,{117, 185, 142, 6} ,{78, 172, 123, 27} ,{124, 166, 139, 3} ,{124, 166, 93, 28} ,{124, 166, 152, 27} ,{199, 173, 94, 28} ,{119, 185, 120, 27} ,{120, 185, 152, 27} ,{124, 166, 96, 28} ,{121, 185, 98, 28} ,{124, 166, 99, 28} ,{124, 166, 100, 28} ,{124, 166, 94, 6} ,{200, 173, 50, 169} ,{200, 173, 202, 173} ,{200, 173, 196, 27} ,{124, 166, 92, 6} ,{122, 185, 210, 177} ,{124, 166, 102, 28} ,{124, 166, 103, 28} ,{211, 177, 79, 172} ,{124, 185, 101, 168} ,{124, 166, 105, 28} ,{161, 168, 137, 5} ,{161, 168, 12, 27} ,{161, 168, 214, 177} ,{161, 168, 177, 27} ,{125, 185, 101, 168} ,{161, 168, 94, 6} ,{161, 168, 94, 2} ,{161, 168, 36, 6} ,{126, 185, 137, 5} ,{127, 185, 49, 169} ,{213, 177, 214, 177} ,{161, 168, 209, 173} ,{161, 168, 146, 27} ,{124, 166, 107, 28} ,{124, 166, 101, 1} ,{124, 166, 108, 28} ,{124, 166, 94, 2} ,{27, 171, 46, 8} ,{27, 171, 175, 27} ,{27, 171, 208, 27} ,{131, 185, 208, 27} ,{27, 171, 146, 27} ,{123, 169, 120, 27} ,{123, 169, 201, 173} ,{215, 177, 94, 2} ,{134, 185, 67, 28} ,{124, 166, 33, 28} ,{46, 169, 163, 27} ,{46, 169, 62, 6} ,{46, 169, 138, 9} ,{46, 169, 177, 27} ,{46, 169, 48, 169} ,{46, 169, 145, 27} ,{46, 169, 134, 3} ,{46, 169, 94, 6} ,{46, 169, 110, 28} ,{46, 169, 219, 27} ,{216, 177, 62, 6} ,{135, 185, 65, 0} ,{124, 166, 128, 3} ,{124, 166, 111, 28} ,{124, 166, 112, 28} ,{124, 166, 29, 18} ,{124, 166, 113, 28} ,{124, 166, 104, 1} ,{47, 169, 50, 169} ,{203, 169, 89, 27} ,{203, 169, 62, 6} ,{203, 169, 73, 5} ,{203, 169, 49, 0} ,{203, 169, 53, 0} ,{203, 169, 21, 28} ,{203, 169, 65, 0} ,{203, 169, 219, 27} ,{136, 185, 104, 1} ,{124, 166, 114, 28} ,{217, 177, 44, 28} ,{80, 172, 202, 173} ,{217, 177, 234, 1} ,{137, 185, 114, 28} ,{124, 166, 253, 1} ,{124, 166, 116, 28} ,{124, 166, 22, 6} ,{124, 166, 154, 4} ,{124, 166, 131, 3} ,{4, 168, 98, 28} ,{124, 166, 125, 27} ,{61, 168, 45, 0} ,{61, 168, 141, 6} ,{61, 168, 197, 27} ,{61, 168, 163, 1} ,{61, 168, 179, 27} ,{61, 168, 177, 19} ,{61, 168, 132, 22} ,{61, 168, 9, 6} ,{61, 168, 94, 2} ,{61, 168, 208, 27} ,{61, 168, 240, 27} ,{61, 168, 223, 27} ,{61, 168, 219, 27} ,{61, 168, 118, 28} ,{61, 168, 137, 22} ,{61, 168, 11, 8} ,{61, 168, 146, 27} ,{138, 185, 125, 27} ,{4, 168, 123, 27} ,{124, 166, 208, 27} ,{140, 185, 127, 27} ,{124, 166, 119, 28} ,{124, 166, 238, 27} ,{124, 166, 166, 1} ,{124, 166, 136, 27} ,{204, 169, 50, 169} ,{204, 169, 206, 169} ,{155, 170, 142, 27} ,{155, 170, 94, 6} ,{155, 170, 64, 28} ,{155, 170, 240, 18} ,{155, 170, 65, 0} ,{155, 170, 218, 177} ,{124, 166, 120, 28} ,{124, 166, 121, 28} ,{124, 166, 122, 28} ,{124, 166, 36, 6} ,{203, 173, 249, 5} ,{220, 177, 84, 172} ,{141, 185, 21, 170} ,{124, 166, 124, 28} ,{124, 166, 125, 28} ,{124, 166, 132, 27} ,{124, 166, 126, 28} ,{124, 166, 127, 28} ,{124, 166, 240, 27} ,{221, 177, 50, 169} ,{142, 185, 147, 16} ,{124, 166, 129, 28} ,{231, 168, 45, 0} ,{231, 168, 166, 27} ,{231, 168, 170, 27} ,{231, 168, 191, 27} ,{231, 168, 46, 8} ,{231, 168, 121, 27} ,{231, 168, 48, 169} ,{231, 168, 61, 28} ,{231, 168, 63, 28} ,{231, 168, 86, 28} ,{231, 168, 208, 27} ,{124, 166, 131, 28} ,{124, 166, 132, 28} ,{222, 177, 120, 27} ,{145, 185, 15, 18} ,{124, 166, 133, 28} ,{124, 166, 32, 6} ,{148, 185, 32, 6} ,{124, 166, 64, 28} ,{124, 166, 134, 28} ,{124, 166, 27, 6} ,{149, 185, 123, 27} ,{124, 166, 34, 28} ,{124, 166, 135, 28} ,{152, 185, 64, 28} ,{124, 166, 137, 28} ,{124, 166, 110, 28} ,{124, 166, 26, 6} ,{154, 185, 26, 6} ,{124, 166, 138, 28} ,{124, 166, 139, 28} ,{124, 166, 35, 28} ,{124, 166, 151, 14} ,{124, 166, 140, 28} ,{124, 166, 153, 20} ,{124, 166, 141, 28} ,{124, 166, 129, 3} ,{81, 172, 14, 0} ,{224, 177, 250, 5} ,{224, 177, 9, 6} ,{81, 172, 123, 27} ,{124, 166, 223, 27} ,{160, 185, 46, 16} ,{161, 185, 95, 17} ,{124, 166, 66, 28} ,{157, 170, 62, 6} ,{157, 170, 177, 27} ,{157, 170, 36, 6} ,{157, 170, 32, 6} ,{157, 170, 8, 28} ,{157, 170, 191, 9} ,{124, 166, 137, 27} ,{124, 166, 150, 5} ,{124, 166, 161, 1} ,{162, 185, 123, 27} ,{124, 166, 215, 4} ,{163, 185, 120, 27} ,{124, 166, 247, 22} ,{124, 166, 145, 28} ,{204, 173, 29, 171} ,{227, 177, 145, 28} ,{164, 185, 84, 172} ,{124, 166, 70, 6} ,{124, 166, 8, 28} ,{124, 166, 140, 9} ,{124, 166, 136, 22} ,{124, 166, 240, 18} ,{169, 185, 234, 1} ,{124, 166, 65, 0} ,{28, 171, 177, 27} ,{170, 185, 65, 0} ,{173, 185, 21, 170} ,{175, 185, 153, 20} ,{178, 185, 200, 0} ,{124, 166, 219, 27} ,{124, 166, 118, 28} ,{124, 166, 191, 9} ,{205, 169, 61, 28} ,{205, 169, 206, 169} ,{207, 173, 9, 6} ,{207, 173, 206, 173} ,{180, 185, 123, 27} ,{205, 169, 123, 27} ,{205, 169, 196, 27} ,{181, 185, 206, 169} ,{124, 166, 150, 28} ,{124, 166, 137, 22} ,{88, 172, 131, 27} ,{182, 185, 232, 1} ,{88, 172, 136, 27} ,{88, 172, 65, 0} ,{124, 166, 151, 28} ,{124, 166, 152, 28} ,{228, 177, 217, 27} ,{228, 177, 128, 3} ,{124, 166, 151, 5} ,{183, 185, 123, 27} ,{124, 166, 11, 8} ,{184, 185, 11, 8} ,{229, 177, 196, 27} ,{124, 166, 154, 28} ,{230, 177, 163, 1} ,{230, 177, 139, 3} ,{208, 169, 181, 9} ,{208, 169, 163, 1} ,{208, 169, 94, 2} ,{208, 169, 219, 27} ,{208, 169, 209, 173} ,{185, 185, 62, 6} ,{124, 166, 156, 28} ,{124, 166, 157, 28} ,{124, 166, 158, 28} ,{124, 166, 159, 28} ,{224, 167, 45, 0} ,{224, 167, 163, 27} ,{224, 167, 91, 0} ,{224, 167, 203, 27} ,{224, 167, 200, 3} ,{224, 167, 165, 17} ,{224, 167, 101, 168} ,{224, 167, 46, 8} ,{224, 167, 159, 6} ,{224, 167, 163, 1} ,{224, 167, 121, 27} ,{224, 167, 147, 16} ,{224, 167, 30, 28} ,{224, 167, 103, 6} ,{224, 167, 132, 22} ,{224, 167, 85, 28} ,{224, 167, 128, 3} ,{224, 167, 36, 6} ,{224, 167, 135, 28} ,{224, 167, 70, 6} ,{186, 185, 177, 27} ,{224, 167, 191, 9} ,{224, 167, 161, 28} ,{124, 166, 161, 28} ,{187, 185, 210, 173} ,{124, 166, 146, 27} ,{89, 172, 50, 169} ,{188, 185, 102, 6} ,{89, 172, 22, 170} ,{89, 172, 29, 171} ,{124, 166, 164, 28} ,{124, 166, 165, 28} ,{124, 166, 166, 28} ,{124, 166, 167, 28} ,{124, 166, 168, 28} ,{190, 185, 217, 27} ,{124, 166, 170, 28} ,{124, 166, 234, 1} ,{232, 177, 120, 27} ,{191, 185, 22, 170} ,{124, 166, 171, 28} ,{124, 166, 172, 28} ,{124, 166, 173, 28} ,{124, 166, 130, 6} ,{193, 185, 130, 6} ,{124, 166, 175, 28} ,{124, 166, 176, 28} ,{194, 185, 233, 177} ,{124, 166, 178, 28} ,{124, 166, 179, 28} ,{124, 166, 129, 6} ,{124, 166, 180, 28} ,{195, 185, 50, 169} ,{124, 166, 182, 28} ,{124, 166, 183, 28} ,{233, 168, 12, 27} ,{132, 168, 12, 27} ,{102, 168, 12, 27} ,{194, 168, 12, 27} ,{24, 170, 12, 27} ,{209, 169, 12, 27} ,{23, 170, 12, 27} ,{125, 169, 12, 27} ,{132, 168, 46, 16} ,{102, 168, 46, 16} ,{194, 168, 46, 16} ,{24, 170, 46, 16} ,{209, 169, 46, 16} ,{23, 170, 46, 16} ,{125, 169, 46, 16} ,{102, 168, 65, 0} ,{194, 168, 65, 0} ,{24, 170, 65, 0} ,{209, 169, 65, 0} ,{23, 170, 65, 0} ,{125, 169, 65, 0} ,{51, 169, 184, 28} ,{233, 168, 184, 28} ,{132, 168, 184, 28} ,{102, 168, 184, 28} ,{194, 168, 184, 28} ,{24, 170, 184, 28} ,{209, 169, 184, 28} ,{23, 170, 184, 28} ,{125, 169, 184, 28} ,{51, 169, 185, 28} ,{233, 168, 185, 28} ,{132, 168, 185, 28} ,{102, 168, 185, 28} ,{194, 168, 185, 28} ,{233, 168, 122, 28} ,{132, 168, 122, 28} ,{196, 185, 158, 170} ,{102, 168, 122, 28} ,{194, 168, 122, 28} ,{24, 170, 122, 28} ,{209, 169, 122, 28} ,{23, 170, 122, 28} ,{125, 169, 122, 28} ,{51, 169, 187, 28} ,{233, 168, 187, 28} ,{132, 168, 187, 28} ,{197, 185, 158, 170} ,{102, 168, 187, 28} ,{194, 168, 187, 28} ,{237, 177, 46, 16} ,{237, 177, 85, 28} ,{51, 169, 189, 28} ,{233, 168, 189, 28} ,{132, 168, 189, 28} ,{198, 185, 158, 170} ,{102, 168, 189, 28} ,{194, 168, 189, 28} ,{238, 177, 191, 28} ,{238, 177, 192, 28} ,{90, 172, 193, 28} ,{90, 172, 194, 28} ,{239, 177, 45, 0} ,{239, 177, 46, 0} ,{199, 185, 196, 28} ,{211, 173, 197, 28} ,{240, 177, 45, 0} ,{240, 177, 46, 0} ,{241, 177, 199, 28} ,{241, 177, 200, 28} ,{91, 172, 201, 28} ,{91, 172, 202, 28} ,{91, 172, 203, 28} ,{200, 185, 45, 0} ,{233, 168, 30, 171} ,{132, 168, 30, 171} ,{102, 168, 30, 171} ,{194, 168, 30, 171} ,{24, 170, 30, 171} ,{51, 169, 205, 28} ,{233, 168, 205, 28} ,{132, 168, 205, 28} ,{102, 168, 205, 28} ,{102, 168, 242, 177} ,{194, 168, 205, 28} ,{194, 168, 242, 177} ,{188, 166, 207, 28} ,{188, 166, 208, 28} ,{51, 169, 209, 28} ,{233, 168, 209, 28} ,{243, 177, 46, 16} ,{244, 177, 46, 16} ,{201, 185, 46, 16} ,{243, 177, 245, 177} ,{244, 177, 245, 177} ,{202, 185, 12, 27} ,{203, 185, 12, 27} ,{247, 177, 174, 10} ,{247, 177, 122, 0} ,{204, 185, 213, 173} ,{205, 185, 33, 0} ,{248, 177, 33, 0} ,{248, 177, 61, 10} ,{120, 166, 214, 28} ,{120, 166, 215, 28} ,{120, 166, 216, 28} ,{120, 166, 217, 28} ,{120, 166, 218, 28} ,{120, 166, 219, 28} ,{120, 166, 220, 28} ,{120, 166, 221, 28} ,{120, 166, 222, 28} ,{120, 166, 223, 28} ,{120, 166, 224, 28} ,{120, 166, 225, 28} ,{120, 166, 226, 28} ,{120, 166, 227, 28} ,{120, 166, 228, 28} ,{120, 166, 229, 28} ,{120, 166, 230, 28} ,{120, 166, 231, 28} ,{120, 166, 232, 28} ,{120, 166, 233, 28} ,{120, 166, 234, 28} ,{120, 166, 235, 28} ,{120, 166, 236, 28} ,{120, 166, 237, 28} ,{120, 166, 238, 28} ,{120, 166, 239, 28} ,{120, 166, 240, 28} ,{120, 166, 241, 28} ,{120, 166, 242, 28} ,{120, 166, 243, 28} ,{120, 166, 244, 28} ,{120, 166, 245, 28} ,{120, 166, 246, 28} ,{120, 166, 247, 28} ,{120, 166, 248, 28} ,{120, 166, 249, 28} ,{120, 166, 250, 28} ,{120, 166, 251, 28} ,{120, 166, 252, 28} ,{120, 166, 253, 28} ,{120, 166, 254, 28} ,{120, 166, 255, 28} ,{120, 166, 0, 29} ,{120, 166, 1, 29} ,{120, 166, 2, 29} ,{120, 166, 3, 29} ,{120, 166, 4, 29} ,{120, 166, 5, 29} ,{120, 166, 6, 29} ,{120, 166, 7, 29} ,{120, 166, 8, 29} ,{120, 166, 9, 29} ,{120, 166, 10, 29} ,{120, 166, 11, 29} ,{120, 166, 12, 29} ,{120, 166, 13, 29} ,{120, 166, 14, 29} ,{120, 166, 15, 29} ,{120, 166, 16, 29} ,{120, 166, 17, 29} ,{120, 166, 18, 29} ,{120, 166, 19, 29} ,{120, 166, 20, 29} ,{120, 166, 21, 29} ,{120, 166, 22, 29} ,{120, 166, 23, 29} ,{120, 166, 24, 29} ,{120, 166, 25, 29} ,{120, 166, 26, 29} ,{120, 166, 27, 29} ,{120, 166, 28, 29} ,{120, 166, 29, 29} ,{120, 166, 30, 29} ,{120, 166, 31, 29} ,{120, 166, 32, 29} ,{120, 166, 33, 29} ,{120, 166, 34, 29} ,{120, 166, 35, 29} ,{120, 166, 36, 29} ,{120, 166, 37, 29} ,{120, 166, 38, 29} ,{120, 166, 39, 29} ,{120, 166, 40, 29} ,{120, 166, 41, 29} ,{120, 166, 42, 29} ,{120, 166, 43, 29} ,{120, 166, 44, 29} ,{120, 166, 45, 29} ,{120, 166, 46, 29} ,{120, 166, 47, 29} ,{120, 166, 48, 29} ,{120, 166, 49, 29} ,{120, 166, 50, 29} ,{120, 166, 51, 29} ,{120, 166, 52, 29} ,{120, 166, 53, 29} ,{120, 166, 54, 29} ,{120, 166, 55, 29} ,{120, 166, 56, 29} ,{120, 166, 57, 29} ,{120, 166, 58, 29} ,{120, 166, 59, 29} ,{120, 166, 60, 29} ,{120, 166, 61, 29} ,{120, 166, 62, 29} ,{120, 166, 63, 29} ,{120, 166, 64, 29} ,{120, 166, 65, 29} ,{120, 166, 66, 29} ,{120, 166, 67, 29} ,{120, 166, 68, 29} ,{120, 166, 69, 29} ,{120, 166, 70, 29} ,{120, 166, 71, 29} ,{120, 166, 72, 29} ,{120, 166, 73, 29} ,{120, 166, 74, 29} ,{120, 166, 75, 29} ,{120, 166, 76, 29} ,{120, 166, 77, 29} ,{120, 166, 78, 29} ,{120, 166, 79, 29} ,{120, 166, 80, 29} ,{120, 166, 81, 29} ,{120, 166, 82, 29} ,{120, 166, 83, 29} ,{120, 166, 84, 29} ,{120, 166, 85, 29} ,{120, 166, 86, 29} ,{120, 166, 87, 29} ,{120, 166, 88, 29} ,{120, 166, 89, 29} ,{120, 166, 90, 29} ,{120, 166, 91, 29} ,{120, 166, 92, 29} ,{120, 166, 93, 29} ,{120, 166, 94, 29} ,{120, 166, 95, 29} ,{120, 166, 96, 29} ,{120, 166, 97, 29} ,{120, 166, 98, 29} ,{120, 166, 99, 29} ,{120, 166, 100, 29} ,{120, 166, 101, 29} ,{120, 166, 102, 29} ,{120, 166, 103, 29} ,{120, 166, 104, 29} ,{120, 166, 105, 29} ,{120, 166, 106, 29} ,{120, 166, 107, 29} ,{120, 166, 108, 29} ,{120, 166, 109, 29} ,{120, 166, 110, 29} ,{120, 166, 111, 29} ,{120, 166, 112, 29} ,{120, 166, 113, 29} ,{120, 166, 114, 29} ,{120, 166, 115, 29} ,{120, 166, 116, 29} ,{120, 166, 117, 29} ,{120, 166, 118, 29} ,{120, 166, 119, 29} ,{120, 166, 120, 29} ,{120, 166, 121, 29} ,{120, 166, 122, 29} ,{120, 166, 123, 29} ,{120, 166, 124, 29} ,{120, 166, 125, 29} ,{120, 166, 126, 29} ,{120, 166, 127, 29} ,{120, 166, 128, 29} ,{120, 166, 129, 29} ,{120, 166, 130, 29} ,{120, 166, 131, 29} ,{120, 166, 132, 29} ,{120, 166, 133, 29} ,{120, 166, 134, 29} ,{120, 166, 135, 29} ,{120, 166, 136, 29} ,{120, 166, 137, 29} ,{120, 166, 138, 29} ,{120, 166, 139, 29} ,{120, 166, 140, 29} ,{120, 166, 141, 29} ,{120, 166, 142, 29} ,{120, 166, 143, 29} ,{120, 166, 144, 29} ,{120, 166, 145, 29} ,{120, 166, 146, 29} ,{120, 166, 147, 29} ,{120, 166, 148, 29} ,{120, 166, 149, 29} ,{120, 166, 150, 29} ,{120, 166, 151, 29} ,{120, 166, 152, 29} ,{120, 166, 153, 29} ,{120, 166, 154, 29} ,{120, 166, 155, 29} ,{120, 166, 156, 29} ,{120, 166, 157, 29} ,{120, 166, 158, 29} ,{120, 166, 159, 29} ,{120, 166, 160, 29} ,{120, 166, 161, 29} ,{120, 166, 162, 29} ,{120, 166, 163, 29} ,{120, 166, 164, 29} ,{120, 166, 165, 29} ,{120, 166, 166, 29} ,{120, 166, 167, 29} ,{120, 166, 168, 29} ,{120, 166, 169, 29} ,{120, 166, 170, 29} ,{120, 166, 171, 29} ,{120, 166, 172, 29} ,{120, 166, 173, 29} ,{120, 166, 174, 29} ,{120, 166, 175, 29} ,{120, 166, 176, 29} ,{120, 166, 177, 29} ,{120, 166, 178, 29} ,{120, 166, 179, 29} ,{120, 166, 180, 29} ,{120, 166, 181, 29} ,{120, 166, 182, 29} ,{120, 166, 183, 29} ,{120, 166, 184, 29} ,{120, 166, 185, 29} ,{120, 166, 186, 29} ,{120, 166, 187, 29} ,{120, 166, 188, 29} ,{120, 166, 189, 29} ,{120, 166, 190, 29} ,{120, 166, 191, 29} ,{120, 166, 192, 29} ,{120, 166, 193, 29} ,{120, 166, 194, 29} ,{120, 166, 195, 29} ,{120, 166, 196, 29} ,{120, 166, 197, 29} ,{120, 166, 198, 29} ,{120, 166, 199, 29} ,{120, 166, 200, 29} ,{120, 166, 201, 29} ,{120, 166, 202, 29} ,{120, 166, 203, 29} ,{120, 166, 204, 29} ,{120, 166, 205, 29} ,{120, 166, 206, 29} ,{120, 166, 207, 29} ,{120, 166, 208, 29} ,{120, 166, 209, 29} ,{120, 166, 210, 29} ,{120, 166, 211, 29} ,{120, 166, 212, 29} ,{120, 166, 213, 29} ,{120, 166, 214, 29} ,{120, 166, 215, 29} ,{120, 166, 216, 29} ,{120, 166, 217, 29} ,{120, 166, 218, 29} ,{120, 166, 219, 29} ,{120, 166, 220, 29} ,{120, 166, 221, 29} ,{120, 166, 222, 29} ,{120, 166, 223, 29} ,{120, 166, 224, 29} ,{120, 166, 225, 29} ,{120, 166, 226, 29} ,{120, 166, 227, 29} ,{120, 166, 228, 29} ,{120, 166, 229, 29} ,{120, 166, 230, 29} ,{120, 166, 231, 29} ,{120, 166, 232, 29} ,{120, 166, 233, 29} ,{120, 166, 234, 29} ,{120, 166, 235, 29} ,{120, 166, 236, 29} ,{120, 166, 237, 29} ,{120, 166, 238, 29} ,{120, 166, 239, 29} ,{120, 166, 240, 29} ,{120, 166, 241, 29} ,{120, 166, 242, 29} ,{120, 166, 243, 29} ,{120, 166, 244, 29} ,{120, 166, 245, 29} ,{120, 166, 246, 29} ,{120, 166, 247, 29} ,{120, 166, 248, 29} ,{120, 166, 249, 29} ,{120, 166, 250, 29} ,{120, 166, 251, 29} ,{120, 166, 252, 29} ,{120, 166, 253, 29} ,{120, 166, 254, 29} ,{120, 166, 255, 29} ,{120, 166, 0, 30} ,{120, 166, 1, 30} ,{120, 166, 2, 30} ,{120, 166, 3, 30} ,{120, 166, 4, 30} ,{120, 166, 5, 30} ,{120, 166, 6, 30} ,{120, 166, 7, 30} ,{120, 166, 8, 30} ,{120, 166, 9, 30} ,{120, 166, 10, 30} ,{120, 166, 11, 30} ,{120, 166, 12, 30} ,{120, 166, 13, 30} ,{120, 166, 14, 30} ,{120, 166, 15, 30} ,{120, 166, 16, 30} ,{120, 166, 17, 30} ,{120, 166, 18, 30} ,{120, 166, 19, 30} ,{120, 166, 20, 30} ,{120, 166, 21, 30} ,{120, 166, 22, 30} ,{120, 166, 23, 30} ,{120, 166, 24, 30} ,{120, 166, 25, 30} ,{120, 166, 26, 30} ,{120, 166, 27, 30} ,{120, 166, 28, 30} ,{120, 166, 29, 30} ,{120, 166, 30, 30} ,{120, 166, 31, 30} ,{120, 166, 32, 30} ,{120, 166, 33, 30} ,{120, 166, 34, 30} ,{120, 166, 35, 30} ,{120, 166, 36, 30} ,{120, 166, 37, 30} ,{120, 166, 38, 30} ,{120, 166, 39, 30} ,{120, 166, 40, 30} ,{120, 166, 41, 30} ,{120, 166, 42, 30} ,{120, 166, 43, 30} ,{120, 166, 44, 30} ,{120, 166, 45, 30} ,{120, 166, 46, 30} ,{120, 166, 47, 30} ,{120, 166, 48, 30} ,{120, 166, 49, 30} ,{120, 166, 50, 30} ,{120, 166, 51, 30} ,{120, 166, 52, 30} ,{120, 166, 53, 30} ,{120, 166, 54, 30} ,{120, 166, 55, 30} ,{120, 166, 56, 30} ,{120, 166, 57, 30} ,{120, 166, 58, 30} ,{120, 166, 59, 30} ,{120, 166, 60, 30} ,{120, 166, 61, 30} ,{120, 166, 62, 30} ,{120, 166, 63, 30} ,{120, 166, 64, 30} ,{120, 166, 65, 30} ,{120, 166, 66, 30} ,{120, 166, 67, 30} ,{120, 166, 68, 30} ,{120, 166, 69, 30} ,{120, 166, 70, 30} ,{120, 166, 71, 30} ,{120, 166, 72, 30} ,{120, 166, 73, 30} ,{120, 166, 74, 30} ,{120, 166, 75, 30} ,{120, 166, 76, 30} ,{120, 166, 77, 30} ,{120, 166, 78, 30} ,{120, 166, 79, 30} ,{120, 166, 80, 30} ,{120, 166, 81, 30} ,{120, 166, 82, 30} ,{120, 166, 83, 30} ,{120, 166, 84, 30} ,{120, 166, 85, 30} ,{120, 166, 86, 30} ,{120, 166, 87, 30} ,{120, 166, 88, 30} ,{120, 166, 89, 30} ,{120, 166, 90, 30} ,{120, 166, 91, 30} ,{120, 166, 92, 30} ,{120, 166, 93, 30} ,{120, 166, 94, 30} ,{120, 166, 95, 30} ,{120, 166, 96, 30} ,{120, 166, 97, 30} ,{120, 166, 98, 30} ,{120, 166, 99, 30} ,{120, 166, 100, 30} ,{120, 166, 101, 30} ,{120, 166, 102, 30} ,{120, 166, 103, 30} ,{120, 166, 104, 30} ,{120, 166, 105, 30} ,{120, 166, 106, 30} ,{120, 166, 107, 30} ,{120, 166, 108, 30} ,{120, 166, 109, 30} ,{120, 166, 110, 30} ,{120, 166, 111, 30} ,{120, 166, 112, 30} ,{120, 166, 113, 30} ,{120, 166, 114, 30} ,{120, 166, 115, 30} ,{120, 166, 116, 30} ,{120, 166, 117, 30} ,{120, 166, 118, 30} ,{120, 166, 119, 30} ,{120, 166, 120, 30} ,{120, 166, 121, 30} ,{120, 166, 122, 30} ,{120, 166, 123, 30} ,{120, 166, 124, 30} ,{120, 166, 125, 30} ,{120, 166, 126, 30} ,{120, 166, 127, 30} ,{120, 166, 128, 30} ,{120, 166, 129, 30} ,{120, 166, 130, 30} ,{120, 166, 131, 30} ,{120, 166, 132, 30} ,{120, 166, 133, 30} ,{120, 166, 134, 30} ,{120, 166, 135, 30} ,{120, 166, 136, 30} ,{120, 166, 137, 30} ,{120, 166, 138, 30} ,{120, 166, 139, 30} ,{120, 166, 140, 30} ,{120, 166, 141, 30} ,{120, 166, 142, 30} ,{120, 166, 143, 30} ,{120, 166, 144, 30} ,{120, 166, 145, 30} ,{120, 166, 146, 30} ,{120, 166, 147, 30} ,{120, 166, 148, 30} ,{120, 166, 149, 30} ,{120, 166, 150, 30} ,{120, 166, 151, 30} ,{120, 166, 152, 30} ,{120, 166, 153, 30} ,{120, 166, 154, 30} ,{120, 166, 155, 30} ,{120, 166, 156, 30} ,{120, 166, 157, 30} ,{120, 166, 158, 30} ,{120, 166, 159, 30} ,{120, 166, 160, 30} ,{120, 166, 161, 30} ,{120, 166, 162, 30} ,{120, 166, 163, 30} ,{120, 166, 164, 30} ,{120, 166, 165, 30} ,{120, 166, 166, 30} ,{120, 166, 167, 30} ,{120, 166, 168, 30} ,{120, 166, 169, 30} ,{120, 166, 170, 30} ,{120, 166, 171, 30} ,{120, 166, 172, 30} ,{120, 166, 173, 30} ,{120, 166, 174, 30} ,{120, 166, 175, 30} ,{120, 166, 176, 30} ,{120, 166, 177, 30} ,{120, 166, 178, 30} ,{120, 166, 179, 30} ,{120, 166, 180, 30} ,{120, 166, 181, 30} ,{120, 166, 182, 30} ,{120, 166, 183, 30} ,{120, 166, 184, 30} ,{120, 166, 185, 30} ,{120, 166, 186, 30} ,{120, 166, 187, 30} ,{120, 166, 188, 30} ,{120, 166, 189, 30} ,{120, 166, 190, 30} ,{120, 166, 191, 30} ,{120, 166, 192, 30} ,{120, 166, 193, 30} ,{120, 166, 194, 30} ,{120, 166, 195, 30} ,{120, 166, 196, 30} ,{120, 166, 197, 30} ,{120, 166, 198, 30} ,{120, 166, 199, 30} ,{120, 166, 200, 30} ,{120, 166, 201, 30} ,{120, 166, 202, 30} ,{120, 166, 203, 30} ,{120, 166, 204, 30} ,{120, 166, 205, 30} ,{120, 166, 206, 30} ,{120, 166, 207, 30} ,{120, 166, 208, 30} ,{120, 166, 209, 30} ,{120, 166, 210, 30} ,{120, 166, 211, 30} ,{120, 166, 212, 30} ,{120, 166, 213, 30} ,{120, 166, 214, 30} ,{120, 166, 215, 30} ,{120, 166, 216, 30} ,{120, 166, 217, 30} ,{120, 166, 218, 30} ,{120, 166, 219, 30} ,{120, 166, 220, 30} ,{120, 166, 221, 30} ,{120, 166, 222, 30} ,{120, 166, 223, 30} ,{120, 166, 224, 30} ,{120, 166, 225, 30} ,{120, 166, 226, 30} ,{120, 166, 227, 30} ,{120, 166, 228, 30} ,{120, 166, 229, 30} ,{120, 166, 230, 30} ,{120, 166, 231, 30} ,{120, 166, 232, 30} ,{120, 166, 233, 30} ,{120, 166, 234, 30} ,{120, 166, 235, 30} ,{120, 166, 236, 30} ,{120, 166, 237, 30} ,{120, 166, 238, 30} ,{120, 166, 239, 30} ,{120, 166, 240, 30} ,{120, 166, 241, 30} ,{120, 166, 242, 30} ,{120, 166, 243, 30} ,{120, 166, 244, 30} ,{120, 166, 245, 30} ,{120, 166, 246, 30} ,{120, 166, 247, 30} ,{120, 166, 248, 30} ,{120, 166, 249, 30} ,{120, 166, 250, 30} ,{120, 166, 251, 30} ,{120, 166, 252, 30} ,{120, 166, 253, 30} ,{120, 166, 254, 30} ,{120, 166, 255, 30} ,{120, 166, 0, 31} ,{120, 166, 1, 31} ,{120, 166, 2, 31} ,{120, 166, 3, 31} ,{120, 166, 4, 31} ,{120, 166, 5, 31} ,{120, 166, 6, 31} ,{120, 166, 7, 31} ,{120, 166, 8, 31} ,{120, 166, 9, 31} ,{120, 166, 10, 31} ,{120, 166, 11, 31} ,{120, 166, 12, 31} ,{120, 166, 13, 31} ,{120, 166, 14, 31} ,{120, 166, 15, 31} ,{120, 166, 16, 31} ,{120, 166, 17, 31} ,{120, 166, 18, 31} ,{120, 166, 19, 31} ,{120, 166, 20, 31} ,{120, 166, 21, 31} ,{120, 166, 22, 31} ,{120, 166, 23, 31} ,{120, 166, 24, 31} ,{120, 166, 25, 31} ,{120, 166, 26, 31} ,{120, 166, 27, 31} ,{120, 166, 28, 31} ,{120, 166, 29, 31} ,{120, 166, 30, 31} ,{120, 166, 31, 31} ,{120, 166, 32, 31} ,{120, 166, 33, 31} ,{120, 166, 34, 31} ,{120, 166, 35, 31} ,{120, 166, 36, 31} ,{120, 166, 37, 31} ,{120, 166, 38, 31} ,{120, 166, 39, 31} ,{120, 166, 40, 31} ,{120, 166, 41, 31} ,{120, 166, 42, 31} ,{120, 166, 43, 31} ,{120, 166, 44, 31} ,{120, 166, 45, 31} ,{120, 166, 46, 31} ,{120, 166, 47, 31} ,{120, 166, 48, 31} ,{120, 166, 49, 31} ,{120, 166, 50, 31} ,{120, 166, 51, 31} ,{120, 166, 52, 31} ,{120, 166, 53, 31} ,{120, 166, 54, 31} ,{120, 166, 55, 31} ,{120, 166, 56, 31} ,{120, 166, 57, 31} ,{120, 166, 58, 31} ,{120, 166, 59, 31} ,{120, 166, 60, 31} ,{120, 166, 61, 31} ,{120, 166, 62, 31} ,{120, 166, 63, 31} ,{120, 166, 64, 31} ,{120, 166, 65, 31} ,{120, 166, 66, 31} ,{120, 166, 67, 31} ,{120, 166, 68, 31} ,{120, 166, 69, 31} ,{120, 166, 70, 31} ,{120, 166, 71, 31} ,{120, 166, 72, 31} ,{120, 166, 73, 31} ,{120, 166, 74, 31} ,{120, 166, 75, 31} ,{120, 166, 76, 31} ,{120, 166, 77, 31} ,{120, 166, 78, 31} ,{120, 166, 79, 31} ,{120, 166, 80, 31} ,{120, 166, 81, 31} ,{120, 166, 82, 31} ,{120, 166, 83, 31} ,{120, 166, 84, 31} ,{120, 166, 85, 31} ,{120, 166, 86, 31} ,{120, 166, 87, 31} ,{120, 166, 88, 31} ,{120, 166, 89, 31} ,{120, 166, 90, 31} ,{120, 166, 91, 31} ,{120, 166, 92, 31} ,{120, 166, 93, 31} ,{120, 166, 94, 31} ,{120, 166, 95, 31} ,{120, 166, 96, 31} ,{120, 166, 97, 31} ,{120, 166, 98, 31} ,{120, 166, 99, 31} ,{120, 166, 100, 31} ,{120, 166, 101, 31} ,{120, 166, 102, 31} ,{120, 166, 103, 31} ,{120, 166, 104, 31} ,{120, 166, 105, 31} ,{120, 166, 106, 31} ,{120, 166, 107, 31} ,{120, 166, 108, 31} ,{120, 166, 109, 31} ,{120, 166, 110, 31} ,{120, 166, 111, 31} ,{120, 166, 112, 31} ,{120, 166, 113, 31} ,{120, 166, 114, 31} ,{120, 166, 115, 31} ,{120, 166, 116, 31} ,{120, 166, 117, 31} ,{120, 166, 118, 31} ,{120, 166, 119, 31} ,{120, 166, 120, 31} ,{120, 166, 121, 31} ,{120, 166, 122, 31} ,{120, 166, 123, 31} ,{120, 166, 124, 31} ,{120, 166, 125, 31} ,{120, 166, 126, 31} ,{120, 166, 127, 31} ,{120, 166, 128, 31} ,{120, 166, 129, 31} ,{120, 166, 130, 31} ,{120, 166, 131, 31} ,{120, 166, 132, 31} ,{120, 166, 133, 31} ,{120, 166, 134, 31} ,{120, 166, 135, 31} ,{120, 166, 136, 31} ,{120, 166, 137, 31} ,{120, 166, 138, 31} ,{120, 166, 139, 31} ,{120, 166, 140, 31} ,{120, 166, 141, 31} ,{120, 166, 142, 31} ,{120, 166, 143, 31} ,{120, 166, 144, 31} ,{120, 166, 145, 31} ,{120, 166, 146, 31} ,{120, 166, 147, 31} ,{120, 166, 148, 31} ,{120, 166, 149, 31} ,{120, 166, 150, 31} ,{120, 166, 151, 31} ,{120, 166, 152, 31} ,{120, 166, 153, 31} ,{120, 166, 154, 31} ,{120, 166, 155, 31} ,{120, 166, 156, 31} ,{120, 166, 157, 31} ,{120, 166, 158, 31} ,{120, 166, 159, 31} ,{120, 166, 160, 31} ,{120, 166, 161, 31} ,{120, 166, 162, 31} ,{120, 166, 163, 31} ,{120, 166, 164, 31} ,{120, 166, 165, 31} ,{120, 166, 166, 31} ,{120, 166, 167, 31} ,{120, 166, 168, 31} ,{120, 166, 169, 31} ,{120, 166, 170, 31} ,{120, 166, 171, 31} ,{120, 166, 172, 31} ,{120, 166, 173, 31} ,{120, 166, 174, 31} ,{120, 166, 175, 31} ,{120, 166, 176, 31} ,{120, 166, 177, 31} ,{120, 166, 178, 31} ,{120, 166, 179, 31} ,{120, 166, 180, 31} ,{120, 166, 181, 31} ,{120, 166, 182, 31} ,{120, 166, 183, 31} ,{120, 166, 184, 31} ,{120, 166, 185, 31} ,{120, 166, 186, 31} ,{120, 166, 187, 31} ,{120, 166, 188, 31} ,{120, 166, 189, 31} ,{120, 166, 190, 31} ,{120, 166, 191, 31} ,{120, 166, 192, 31} ,{120, 166, 193, 31} ,{120, 166, 194, 31} ,{120, 166, 195, 31} ,{120, 166, 196, 31} ,{120, 166, 197, 31} ,{120, 166, 198, 31} ,{120, 166, 199, 31} ,{120, 166, 200, 31} ,{120, 166, 201, 31} ,{120, 166, 202, 31} ,{120, 166, 203, 31} ,{120, 166, 204, 31} ,{120, 166, 205, 31} ,{120, 166, 206, 31} ,{120, 166, 207, 31} ,{120, 166, 208, 31} ,{120, 166, 209, 31} ,{120, 166, 210, 31} ,{120, 166, 211, 31} ,{120, 166, 212, 31} ,{120, 166, 213, 31} ,{120, 166, 214, 31} ,{120, 166, 215, 31} ,{120, 166, 216, 31} ,{120, 166, 217, 31} ,{120, 166, 218, 31} ,{120, 166, 219, 31} ,{120, 166, 220, 31} ,{120, 166, 221, 31} ,{120, 166, 222, 31} ,{120, 166, 223, 31} ,{120, 166, 224, 31} ,{120, 166, 225, 31} ,{120, 166, 226, 31} ,{120, 166, 227, 31} ,{120, 166, 228, 31} ,{120, 166, 229, 31} ,{120, 166, 230, 31} ,{120, 166, 231, 31} ,{120, 166, 232, 31} ,{120, 166, 233, 31} ,{120, 166, 234, 31} ,{120, 166, 235, 31} ,{120, 166, 236, 31} ,{120, 166, 237, 31} ,{120, 166, 238, 31} ,{120, 166, 239, 31} ,{120, 166, 240, 31} ,{120, 166, 241, 31} ,{120, 166, 242, 31} ,{120, 166, 243, 31} ,{120, 166, 244, 31} ,{120, 166, 245, 31} ,{120, 166, 246, 31} ,{120, 166, 247, 31} ,{120, 166, 248, 31} ,{120, 166, 249, 31} ,{120, 166, 250, 31} ,{120, 166, 251, 31} ,{120, 166, 252, 31} ,{120, 166, 253, 31} ,{120, 166, 254, 31} ,{120, 166, 255, 31} ,{120, 166, 0, 32} ,{120, 166, 1, 32} ,{120, 166, 2, 32} ,{120, 166, 3, 32} ,{120, 166, 4, 32} ,{120, 166, 5, 32} ,{120, 166, 6, 32} ,{120, 166, 7, 32} ,{120, 166, 8, 32} ,{120, 166, 9, 32} ,{120, 166, 10, 32} ,{120, 166, 11, 32} ,{120, 166, 12, 32} ,{120, 166, 13, 32} ,{120, 166, 14, 32} ,{120, 166, 15, 32} ,{120, 166, 16, 32} ,{120, 166, 17, 32} ,{120, 166, 18, 32} ,{120, 166, 19, 32} ,{120, 166, 20, 32} ,{120, 166, 21, 32} ,{120, 166, 22, 32} ,{120, 166, 23, 32} ,{120, 166, 24, 32} ,{120, 166, 25, 32} ,{120, 166, 26, 32} ,{120, 166, 27, 32} ,{120, 166, 28, 32} ,{120, 166, 29, 32} ,{120, 166, 30, 32} ,{120, 166, 31, 32} ,{120, 166, 32, 32} ,{120, 166, 33, 32} ,{120, 166, 34, 32} ,{120, 166, 35, 32} ,{120, 166, 36, 32} ,{120, 166, 37, 32} ,{120, 166, 38, 32} ,{120, 166, 39, 32} ,{120, 166, 40, 32} ,{120, 166, 41, 32} ,{120, 166, 42, 32} ,{120, 166, 43, 32} ,{120, 166, 44, 32} ,{120, 166, 45, 32} ,{120, 166, 46, 32} ,{120, 166, 47, 32} ,{120, 166, 48, 32} ,{120, 166, 49, 32} ,{120, 166, 50, 32} ,{120, 166, 51, 32} ,{120, 166, 52, 32} ,{120, 166, 53, 32} ,{120, 166, 54, 32} ,{120, 166, 55, 32} ,{120, 166, 56, 32} ,{120, 166, 57, 32} ,{120, 166, 58, 32} ,{120, 166, 59, 32} ,{120, 166, 60, 32} ,{120, 166, 61, 32} ,{120, 166, 62, 32} ,{120, 166, 63, 32} ,{120, 166, 64, 32} ,{120, 166, 65, 32} ,{120, 166, 66, 32} ,{120, 166, 67, 32} ,{120, 166, 68, 32} ,{120, 166, 69, 32} ,{120, 166, 70, 32} ,{120, 166, 71, 32} ,{120, 166, 72, 32} ,{120, 166, 73, 32} ,{120, 166, 74, 32} ,{120, 166, 75, 32} ,{120, 166, 76, 32} ,{120, 166, 77, 32} ,{120, 166, 78, 32} ,{120, 166, 79, 32} ,{120, 166, 80, 32} ,{120, 166, 81, 32} ,{120, 166, 82, 32} ,{120, 166, 83, 32} ,{120, 166, 84, 32} ,{120, 166, 85, 32} ,{120, 166, 86, 32} ,{120, 166, 87, 32} ,{120, 166, 88, 32} ,{120, 166, 89, 32} ,{120, 166, 90, 32} ,{120, 166, 91, 32} ,{120, 166, 92, 32} ,{120, 166, 93, 32} ,{120, 166, 94, 32} ,{120, 166, 95, 32} ,{120, 166, 96, 32} ,{120, 166, 97, 32} ,{120, 166, 98, 32} ,{120, 166, 99, 32} ,{120, 166, 100, 32} ,{120, 166, 101, 32} ,{120, 166, 102, 32} ,{120, 166, 103, 32} ,{120, 166, 104, 32} ,{120, 166, 105, 32} ,{120, 166, 106, 32} ,{120, 166, 107, 32} ,{120, 166, 108, 32} ,{120, 166, 109, 32} ,{120, 166, 110, 32} ,{120, 166, 111, 32} ,{120, 166, 112, 32} ,{120, 166, 113, 32} ,{120, 166, 114, 32} ,{120, 166, 115, 32} ,{120, 166, 116, 32} ,{120, 166, 117, 32} ,{120, 166, 118, 32} ,{120, 166, 119, 32} ,{120, 166, 120, 32} ,{120, 166, 121, 32} ,{120, 166, 122, 32} ,{120, 166, 123, 32} ,{120, 166, 124, 32} ,{120, 166, 125, 32} ,{120, 166, 126, 32} ,{120, 166, 127, 32} ,{120, 166, 128, 32} ,{120, 166, 129, 32} ,{120, 166, 130, 32} ,{120, 166, 131, 32} ,{120, 166, 132, 32} ,{120, 166, 133, 32} ,{120, 166, 134, 32} ,{120, 166, 135, 32} ,{120, 166, 136, 32} ,{120, 166, 137, 32} ,{120, 166, 138, 32} ,{120, 166, 139, 32} ,{120, 166, 140, 32} ,{120, 166, 141, 32} ,{120, 166, 142, 32} ,{120, 166, 143, 32} ,{120, 166, 144, 32} ,{120, 166, 145, 32} ,{120, 166, 146, 32} ,{120, 166, 147, 32} ,{120, 166, 148, 32} ,{120, 166, 149, 32} ,{120, 166, 150, 32} ,{120, 166, 151, 32} ,{120, 166, 152, 32} ,{120, 166, 153, 32} ,{120, 166, 154, 32} ,{120, 166, 155, 32} ,{120, 166, 156, 32} ,{120, 166, 157, 32} ,{120, 166, 158, 32} ,{120, 166, 159, 32} ,{120, 166, 160, 32} ,{120, 166, 161, 32} ,{120, 166, 162, 32} ,{120, 166, 163, 32} ,{120, 166, 164, 32} ,{120, 166, 165, 32} ,{120, 166, 166, 32} ,{120, 166, 167, 32} ,{120, 166, 168, 32} ,{120, 166, 169, 32} ,{120, 166, 170, 32} ,{120, 166, 171, 32} ,{120, 166, 172, 32} ,{120, 166, 173, 32} ,{120, 166, 174, 32} ,{120, 166, 175, 32} ,{120, 166, 176, 32} ,{120, 166, 177, 32} ,{120, 166, 178, 32} ,{120, 166, 179, 32} ,{120, 166, 180, 32} ,{120, 166, 181, 32} ,{120, 166, 182, 32} ,{120, 166, 183, 32} ,{120, 166, 184, 32} ,{120, 166, 185, 32} ,{120, 166, 186, 32} ,{120, 166, 187, 32} ,{120, 166, 188, 32} ,{120, 166, 189, 32} ,{120, 166, 190, 32} ,{120, 166, 191, 32} ,{120, 166, 192, 32} ,{120, 166, 193, 32} ,{120, 166, 194, 32} ,{120, 166, 195, 32} ,{120, 166, 196, 32} ,{120, 166, 197, 32} ,{120, 166, 198, 32} ,{120, 166, 199, 32} ,{120, 166, 200, 32} ,{120, 166, 201, 32} ,{120, 166, 202, 32} ,{120, 166, 203, 32} ,{120, 166, 204, 32} ,{120, 166, 205, 32} ,{120, 166, 206, 32} ,{120, 166, 207, 32} ,{120, 166, 208, 32} ,{120, 166, 209, 32} ,{120, 166, 210, 32} ,{120, 166, 211, 32} ,{120, 166, 212, 32} ,{120, 166, 213, 32} ,{120, 166, 214, 32} ,{120, 166, 215, 32} ,{120, 166, 216, 32} ,{120, 166, 217, 32} ,{120, 166, 218, 32} ,{120, 166, 219, 32} ,{120, 166, 220, 32} ,{120, 166, 221, 32} ,{120, 166, 222, 32} ,{120, 166, 223, 32} ,{120, 166, 224, 32} ,{120, 166, 225, 32} ,{120, 166, 226, 32} ,{120, 166, 227, 32} ,{120, 166, 228, 32} ,{120, 166, 229, 32} ,{120, 166, 230, 32} ,{120, 166, 231, 32} ,{120, 166, 232, 32} ,{120, 166, 233, 32} ,{120, 166, 234, 32} ,{120, 166, 235, 32} ,{120, 166, 236, 32} ,{120, 166, 237, 32} ,{120, 166, 238, 32} ,{120, 166, 239, 32} ,{120, 166, 240, 32} ,{120, 166, 241, 32} ,{120, 166, 242, 32} ,{120, 166, 243, 32} ,{120, 166, 244, 32} ,{120, 166, 245, 32} ,{120, 166, 246, 32} ,{120, 166, 247, 32} ,{120, 166, 248, 32} ,{120, 166, 249, 32} ,{120, 166, 250, 32} ,{120, 166, 251, 32} ,{120, 166, 252, 32} ,{120, 166, 253, 32} ,{120, 166, 254, 32} ,{120, 166, 255, 32} ,{120, 166, 0, 33} ,{120, 166, 1, 33} ,{120, 166, 2, 33} ,{120, 166, 3, 33} ,{120, 166, 4, 33} ,{159, 166, 1, 10} ,{159, 166, 6, 33} ,{159, 166, 55, 1} ,{214, 173, 8, 33} ,{214, 173, 9, 33} ,{215, 173, 8, 33} ,{215, 173, 9, 33} ,{159, 166, 11, 33} ,{159, 166, 12, 33} ,{159, 166, 13, 33} ,{159, 166, 14, 33} ,{206, 185, 9, 33} ,{159, 166, 16, 33} ,{249, 177, 8, 33} ,{207, 185, 8, 33} ,{159, 166, 86, 1} ,{159, 166, 19, 33} ,{159, 166, 20, 33} ,{252, 177, 9, 33} ,{159, 166, 22, 33} ,{159, 166, 23, 33} ,{251, 177, 25, 33} ,{33, 171, 25, 33} ,{159, 166, 27, 33} ,{159, 166, 28, 33} ,{159, 166, 29, 33} ,{250, 177, 25, 33} ,{96, 172, 25, 33} ,{95, 172, 25, 33} ,{159, 166, 33, 33} ,{159, 166, 34, 33} ,{208, 185, 36, 33} ,{209, 185, 25, 33} ,{210, 185, 25, 33} ,{5, 178, 25, 33} ,{159, 166, 40, 33} ,{159, 166, 41, 33} ,{159, 166, 42, 33} ,{253, 177, 25, 33} ,{159, 166, 44, 33} ,{159, 166, 45, 33} ,{159, 166, 46, 33} ,{217, 173, 25, 33} ,{211, 185, 49, 33} ,{2, 178, 25, 33} ,{159, 166, 51, 33} ,{159, 166, 52, 33} ,{159, 166, 53, 33} ,{159, 166, 54, 33} ,{159, 166, 55, 33} ,{159, 166, 56, 33} ,{212, 185, 57, 33} ,{63, 168, 25, 33} ,{159, 166, 59, 33} ,{216, 173, 25, 33} ,{213, 185, 62, 33} ,{159, 166, 63, 33} ,{159, 166, 64, 33} ,{159, 166, 65, 33} ,{0, 178, 25, 33} ,{159, 166, 67, 33} ,{255, 177, 25, 33} ,{254, 177, 25, 33} ,{159, 166, 70, 33} ,{159, 166, 71, 33} ,{159, 166, 72, 33} ,{214, 185, 74, 33} ,{216, 173, 74, 33} ,{159, 166, 75, 33} ,{159, 166, 76, 33} ,{250, 177, 57, 33} ,{251, 177, 57, 33} ,{214, 173, 57, 33} ,{159, 166, 77, 33} ,{159, 166, 78, 33} ,{159, 166, 79, 33} ,{159, 166, 80, 33} ,{215, 185, 57, 33} ,{95, 172, 219, 173} ,{96, 172, 219, 173} ,{159, 166, 84, 33} ,{252, 177, 57, 33} ,{216, 185, 57, 33} ,{159, 166, 87, 33} ,{159, 166, 88, 33} ,{159, 166, 89, 33} ,{159, 166, 90, 33} ,{217, 185, 92, 33} ,{215, 173, 57, 33} ,{253, 177, 57, 33} ,{218, 185, 57, 33} ,{159, 166, 94, 33} ,{159, 166, 95, 33} ,{159, 166, 96, 33} ,{254, 177, 57, 33} ,{255, 177, 57, 33} ,{1, 178, 98, 33} ,{159, 166, 99, 33} ,{159, 166, 100, 33} ,{216, 173, 57, 33} ,{159, 166, 101, 33} ,{217, 173, 57, 33} ,{159, 166, 102, 33} ,{0, 178, 57, 33} ,{159, 166, 103, 33} ,{219, 185, 57, 33} ,{220, 185, 41, 33} ,{159, 166, 106, 33} ,{159, 166, 107, 33} ,{159, 166, 108, 33} ,{159, 166, 109, 33} ,{159, 166, 110, 33} ,{159, 166, 111, 33} ,{159, 166, 112, 33} ,{159, 166, 113, 33} ,{159, 166, 114, 33} ,{1, 178, 114, 33} ,{2, 178, 57, 33} ,{3, 178, 116, 33} ,{3, 178, 117, 33} ,{221, 185, 119, 33} ,{223, 185, 121, 33} ,{159, 166, 122, 33} ,{159, 166, 123, 33} ,{4, 178, 125, 33} ,{4, 178, 83, 33} ,{159, 166, 126, 33} ,{34, 178, 83, 33} ,{224, 185, 25, 33} ,{218, 173, 25, 33} ,{218, 173, 74, 33} ,{218, 173, 57, 33} ,{5, 178, 57, 33} ,{159, 166, 130, 33} ,{159, 166, 9, 33} ,{159, 166, 131, 33} ,{159, 166, 132, 33} ,{159, 166, 56, 1} ,{225, 185, 135, 33} ,{226, 185, 137, 33} ,{227, 185, 137, 33} ,{228, 185, 137, 33} ,{229, 185, 135, 33} ,{33, 171, 219, 173} ,{6, 178, 142, 33} ,{6, 178, 143, 33} ,{159, 166, 144, 33} ,{7, 178, 125, 33} ,{7, 178, 83, 33} ,{221, 173, 143, 33} ,{159, 166, 147, 33} ,{159, 166, 148, 33} ,{159, 166, 149, 33} ,{159, 166, 150, 33} ,{8, 178, 153, 33} ,{210, 169, 154, 33} ,{210, 169, 153, 33} ,{210, 169, 155, 33} ,{210, 169, 156, 33} ,{210, 169, 157, 33} ,{210, 169, 158, 33} ,{8, 178, 157, 33} ,{162, 168, 9, 178} ,{10, 178, 9, 178} ,{162, 168, 11, 178} ,{10, 178, 11, 178} ,{230, 185, 161, 33} ,{162, 168, 165, 33} ,{12, 178, 161, 33} ,{12, 178, 13, 178} ,{162, 168, 13, 178} ,{16, 178, 161, 33} ,{231, 185, 15, 178} ,{14, 178, 15, 178} ,{222, 173, 173, 33} ,{222, 173, 174, 33} ,{222, 173, 175, 33} ,{232, 185, 161, 33} ,{233, 185, 161, 33} ,{234, 185, 161, 33} ,{18, 178, 119, 33} ,{18, 178, 179, 33} ,{237, 185, 181, 33} ,{159, 166, 182, 33} ,{159, 166, 183, 33} ,{239, 185, 186, 33} ,{25, 170, 128, 3} ,{25, 170, 71, 33} ,{240, 185, 161, 33} ,{25, 170, 142, 6} ,{241, 185, 142, 6} ,{25, 170, 106, 6} ,{25, 170, 107, 3} ,{19, 178, 125, 33} ,{19, 178, 83, 33} ,{21, 178, 175, 33} ,{21, 178, 174, 33} ,{244, 185, 194, 33} ,{245, 185, 195, 33} ,{63, 168, 196, 33} ,{223, 173, 198, 33} ,{223, 173, 199, 33} ,{223, 173, 200, 33} ,{247, 185, 202, 33} ,{248, 185, 204, 33} ,{32, 171, 205, 33} ,{159, 170, 205, 33} ,{159, 170, 202, 33} ,{159, 170, 24, 178} ,{159, 170, 26, 178} ,{159, 170, 28, 178} ,{159, 170, 30, 178} ,{32, 171, 24, 178} ,{32, 171, 26, 178} ,{32, 171, 28, 178} ,{32, 171, 30, 178} ,{31, 178, 216, 33} ,{31, 178, 217, 33} ,{32, 178, 219, 33} ,{32, 178, 220, 33} ,{94, 172, 9, 33} ,{94, 172, 221, 33} ,{211, 169, 221, 33} ,{224, 173, 224, 33} ,{224, 173, 225, 33} ,{224, 173, 226, 33} ,{211, 169, 227, 33} ,{225, 173, 224, 33} ,{225, 173, 225, 33} ,{225, 173, 226, 33} ,{249, 185, 230, 33} ,{250, 185, 225, 0} ,{159, 166, 118, 1} ,{26, 170, 128, 3} ,{26, 170, 181, 33} ,{26, 170, 200, 3} ,{26, 170, 142, 6} ,{26, 170, 106, 6} ,{26, 170, 107, 3} ,{26, 170, 92, 6} ,{95, 172, 33, 178} ,{96, 172, 33, 178} ,{95, 172, 226, 173} ,{96, 172, 226, 173} ,{34, 178, 125, 33} ,{33, 171, 226, 173} ,{251, 185, 234, 33} ,{231, 173, 234, 33} ,{147, 166, 35, 178} ,{252, 185, 35, 178} ,{253, 185, 234, 33} ,{254, 185, 234, 33} ,{255, 185, 36, 178} ,{0, 186, 36, 178} ,{1, 186, 189, 2} ,{2, 186, 235, 33} ,{3, 186, 236, 33} ,{147, 166, 235, 33} ,{147, 166, 237, 33} ,{228, 173, 118, 5} ,{228, 173, 119, 5} ,{228, 173, 120, 5} ,{147, 166, 69, 1} ,{4, 186, 222, 0} ,{5, 186, 3, 0} ,{147, 166, 242, 33} ,{147, 166, 243, 33} ,{147, 166, 72, 0} ,{6, 186, 160, 170} ,{7, 186, 160, 170} ,{8, 186, 160, 170} ,{38, 178, 160, 170} ,{9, 186, 160, 170} ,{37, 178, 160, 170} ,{37, 178, 39, 178} ,{38, 178, 39, 178} ,{229, 173, 248, 33} ,{40, 178, 251, 33} ,{40, 178, 252, 33} ,{147, 166, 80, 178} ,{230, 173, 248, 33} ,{41, 178, 251, 33} ,{41, 178, 252, 33} ,{43, 178, 118, 5} ,{43, 178, 119, 5} ,{11, 186, 216, 16} ,{231, 173, 255, 33} ,{231, 173, 0, 34} ,{44, 178, 53, 10} ,{44, 178, 160, 11} ,{45, 178, 53, 10} ,{45, 178, 160, 11} ,{46, 178, 53, 10} ,{46, 178, 160, 11} ,{47, 178, 255, 33} ,{47, 178, 0, 34} ,{12, 186, 2, 34} ,{13, 186, 2, 34} ,{48, 178, 251, 33} ,{48, 178, 252, 33} ,{49, 178, 251, 33} ,{49, 178, 252, 33} ,{14, 186, 216, 16} ,{63, 178, 216, 16} ,{237, 173, 216, 16} ,{99, 172, 216, 16} ,{147, 166, 50, 178} ,{64, 178, 216, 16} ,{66, 178, 216, 16} ,{68, 178, 216, 16} ,{70, 178, 50, 178} ,{147, 166, 51, 178} ,{15, 186, 8, 34} ,{16, 186, 51, 178} ,{244, 173, 232, 173} ,{244, 173, 98, 172} ,{52, 178, 44, 16} ,{52, 178, 57, 12} ,{53, 178, 44, 16} ,{53, 178, 57, 12} ,{54, 178, 44, 16} ,{54, 178, 57, 12} ,{55, 178, 44, 16} ,{55, 178, 57, 12} ,{56, 178, 44, 16} ,{56, 178, 57, 12} ,{57, 178, 232, 173} ,{57, 178, 98, 172} ,{61, 178, 44, 16} ,{61, 178, 57, 12} ,{17, 186, 8, 34} ,{18, 186, 8, 34} ,{147, 166, 98, 172} ,{19, 186, 8, 34} ,{62, 178, 232, 173} ,{62, 178, 98, 172} ,{147, 166, 147, 0} ,{63, 178, 154, 12} ,{237, 173, 154, 12} ,{99, 172, 154, 12} ,{147, 166, 54, 70} ,{64, 178, 154, 12} ,{66, 178, 154, 12} ,{68, 178, 154, 12} ,{70, 178, 54, 70} ,{78, 167, 100, 14} ,{20, 186, 100, 14} ,{234, 173, 118, 5} ,{234, 173, 119, 5} ,{234, 173, 120, 5} ,{236, 173, 118, 5} ,{236, 173, 119, 5} ,{236, 173, 120, 5} ,{21, 186, 115, 0} ,{35, 171, 118, 5} ,{35, 171, 119, 5} ,{35, 171, 120, 5} ,{35, 171, 121, 5} ,{35, 171, 122, 5} ,{100, 172, 130, 11} ,{101, 172, 130, 11} ,{100, 172, 42, 10} ,{101, 172, 42, 10} ,{100, 172, 18, 34} ,{101, 172, 18, 34} ,{100, 172, 19, 34} ,{101, 172, 19, 34} ,{78, 167, 75, 0} ,{78, 167, 20, 34} ,{78, 167, 21, 34} ,{78, 167, 22, 34} ,{78, 167, 23, 34} ,{22, 186, 20, 34} ,{23, 186, 20, 34} ,{78, 167, 26, 34} ,{71, 178, 53, 10} ,{71, 178, 160, 11} ,{78, 167, 28, 34} ,{78, 167, 29, 34} ,{78, 167, 30, 34} ,{78, 167, 31, 34} ,{78, 167, 32, 34} ,{24, 186, 63, 16} ,{25, 186, 63, 16} ,{147, 166, 33, 34} ,{147, 166, 34, 34} ,{147, 166, 70, 0} ,{147, 166, 35, 34} ,{147, 166, 36, 34} ,{147, 166, 37, 34} ,{147, 166, 38, 34} ,{147, 166, 39, 34} ,{73, 178, 46, 10} ,{26, 186, 46, 10} ,{147, 166, 42, 34} ,{147, 166, 43, 34} ,{27, 186, 43, 34} ,{74, 178, 46, 10} ,{74, 178, 53, 10} ,{235, 168, 118, 5} ,{235, 168, 119, 5} ,{235, 168, 120, 5} ,{235, 168, 121, 5} ,{235, 168, 122, 5} ,{235, 168, 128, 5} ,{235, 168, 194, 11} ,{235, 168, 228, 13} ,{235, 168, 195, 11} ,{235, 168, 68, 25} ,{235, 168, 69, 25} ,{147, 166, 47, 34} ,{147, 166, 48, 34} ,{28, 186, 49, 34} ,{29, 186, 46, 10} ,{30, 186, 15, 16} ,{31, 186, 15, 16} ,{78, 167, 50, 34} ,{32, 186, 52, 34} ,{75, 178, 3, 0} ,{33, 186, 3, 0} ,{34, 186, 3, 0} ,{76, 178, 53, 10} ,{76, 178, 160, 11} ,{35, 186, 55, 34} ,{147, 166, 56, 34} ,{36, 186, 211, 10} ,{147, 166, 58, 34} ,{147, 166, 140, 22} ,{147, 166, 59, 34} ,{238, 173, 44, 16} ,{238, 173, 57, 12} ,{147, 166, 61, 34} ,{79, 178, 57, 12} ,{239, 173, 44, 16} ,{239, 173, 57, 12} ,{77, 178, 44, 16} ,{77, 178, 57, 12} ,{37, 186, 216, 16} ,{38, 186, 216, 16} ,{39, 186, 216, 16} ,{238, 173, 216, 16} ,{79, 178, 216, 16} ,{239, 173, 216, 16} ,{241, 173, 73, 34} ,{241, 173, 74, 34} ,{41, 186, 118, 5} ,{37, 171, 73, 34} ,{37, 171, 74, 34} ,{243, 173, 118, 5} ,{243, 173, 119, 5} ,{243, 173, 120, 5} ,{147, 166, 77, 34} ,{81, 178, 80, 178} ,{42, 186, 248, 33} ,{244, 173, 46, 0} ,{147, 166, 79, 34} ,{147, 166, 80, 34} ,{147, 166, 81, 34} ,{147, 166, 82, 34} ,{147, 166, 83, 34} ,{147, 166, 84, 34} ,{147, 166, 85, 34} ,{43, 186, 87, 34} ,{44, 186, 87, 34} ,{45, 186, 90, 34} ,{46, 186, 92, 34} ,{140, 167, 118, 5} ,{140, 167, 119, 5} ,{140, 167, 120, 5} ,{140, 167, 121, 5} ,{140, 167, 122, 5} ,{140, 167, 128, 5} ,{140, 167, 194, 11} ,{140, 167, 228, 13} ,{140, 167, 195, 11} ,{140, 167, 68, 25} ,{140, 167, 69, 25} ,{140, 167, 108, 13} ,{140, 167, 109, 13} ,{140, 167, 112, 13} ,{140, 167, 119, 13} ,{140, 167, 134, 13} ,{140, 167, 165, 13} ,{140, 167, 229, 13} ,{140, 167, 95, 34} ,{140, 167, 96, 34} ,{140, 167, 97, 34} ,{140, 167, 98, 34} ,{140, 167, 110, 13} ,{140, 167, 113, 13} ,{140, 167, 99, 34} ,{140, 167, 100, 34} ,{140, 167, 101, 34} ,{140, 167, 102, 34} ,{140, 167, 103, 34} ,{87, 167, 118, 5} ,{87, 167, 119, 5} ,{87, 167, 121, 5} ,{87, 167, 122, 5} ,{87, 167, 194, 11} ,{87, 167, 228, 13} ,{87, 167, 69, 25} ,{87, 167, 108, 13} ,{87, 167, 109, 13} ,{87, 167, 112, 13} ,{87, 167, 165, 13} ,{87, 167, 229, 13} ,{87, 167, 95, 34} ,{87, 167, 110, 13} ,{87, 167, 113, 13} ,{87, 167, 120, 13} ,{87, 167, 135, 13} ,{87, 167, 166, 13} ,{87, 167, 105, 34} ,{87, 167, 106, 34} ,{87, 167, 107, 34} ,{87, 167, 137, 13} ,{87, 167, 168, 13} ,{87, 167, 232, 13} ,{87, 167, 191, 26} ,{87, 167, 108, 34} ,{87, 167, 109, 34} ,{87, 167, 110, 34} ,{87, 167, 126, 13} ,{87, 167, 172, 13} ,{87, 167, 236, 13} ,{87, 167, 111, 34} ,{87, 167, 99, 34} ,{87, 167, 100, 34} ,{87, 167, 101, 34} ,{87, 167, 102, 34} ,{87, 167, 103, 34} ,{245, 173, 206, 11} ,{245, 173, 207, 11} ,{245, 173, 208, 11} ,{47, 186, 112, 34} ,{246, 173, 114, 12} ,{48, 186, 114, 12} ,{49, 186, 114, 12} ,{82, 178, 107, 12} ,{82, 178, 116, 34} ,{126, 169, 114, 12} ,{199, 166, 6, 3} ,{50, 186, 52, 2} ,{199, 166, 118, 34} ,{199, 166, 119, 34} ,{51, 186, 3, 16} ,{199, 166, 120, 34} ,{199, 166, 121, 34} ,{199, 166, 75, 12} ,{52, 186, 233, 11} ,{54, 186, 124, 34} ,{199, 166, 125, 34} ,{199, 166, 126, 34} ,{199, 166, 210, 17} ,{199, 166, 127, 34} ,{199, 166, 217, 16} ,{199, 166, 128, 34} ,{55, 186, 172, 26} ,{199, 166, 173, 17} ,{199, 166, 186, 17} ,{199, 166, 129, 34} ,{199, 166, 130, 34} ,{199, 166, 131, 34} ,{199, 166, 132, 34} ,{199, 166, 133, 34} ,{199, 166, 134, 34} ,{199, 166, 135, 34} ,{199, 166, 136, 34} ,{199, 166, 137, 34} ,{199, 166, 138, 34} ,{56, 186, 140, 34} ,{199, 166, 141, 34} ,{199, 166, 142, 34} ,{199, 166, 143, 34} ,{199, 166, 144, 34} ,{199, 166, 145, 34} ,{199, 166, 146, 34} ,{199, 166, 147, 34} ,{199, 166, 148, 34} ,{199, 166, 149, 34} ,{58, 186, 151, 34} ,{199, 166, 144, 10} ,{59, 186, 83, 178} ,{199, 166, 153, 34} ,{199, 166, 154, 34} ,{199, 166, 155, 34} ,{199, 166, 156, 34} ,{199, 166, 157, 34} ,{199, 166, 158, 34} ,{199, 166, 159, 34} ,{61, 186, 161, 34} ,{199, 166, 162, 34} ,{199, 166, 4, 27} ,{199, 166, 163, 34} ,{199, 166, 164, 34} ,{199, 166, 165, 34} ,{62, 186, 249, 15} ,{199, 166, 166, 34} ,{63, 186, 164, 3} ,{199, 166, 167, 34} ,{199, 166, 168, 34} ,{199, 166, 169, 34} ,{199, 166, 170, 34} ,{199, 166, 102, 11} ,{199, 166, 171, 34} ,{199, 166, 172, 34} ,{199, 166, 173, 34} ,{199, 166, 174, 34} ,{199, 166, 175, 34} ,{199, 166, 176, 34} ,{199, 166, 177, 34} ,{199, 166, 178, 34} ,{199, 166, 179, 34} ,{199, 166, 235, 17} ,{199, 166, 180, 34} ,{199, 166, 181, 34} ,{199, 166, 182, 34} ,{199, 166, 183, 34} ,{64, 186, 184, 34} ,{199, 166, 185, 34} ,{199, 166, 186, 34} ,{199, 166, 187, 34} ,{127, 169, 244, 37} ,{127, 169, 245, 37} ,{127, 169, 246, 37} ,{127, 169, 247, 37} ,{127, 169, 248, 37} ,{127, 169, 249, 37} ,{127, 169, 250, 37} ,{127, 169, 251, 37} ,{127, 169, 252, 37} ,{128, 169, 244, 37} ,{128, 169, 245, 37} ,{128, 169, 246, 37} ,{128, 169, 247, 37} ,{128, 169, 248, 37} ,{128, 169, 249, 37} ,{128, 169, 250, 37} ,{128, 169, 251, 37} ,{128, 169, 252, 37} ,{15, 167, 45, 0} ,{15, 167, 46, 0} ,{15, 167, 47, 0} ,{15, 167, 48, 0} ,{15, 167, 49, 0} ,{15, 167, 50, 0} ,{15, 167, 51, 0} ,{15, 167, 52, 0} ,{15, 167, 53, 0} ,{15, 167, 54, 0} ,{15, 167, 55, 0} ,{15, 167, 56, 0} ,{15, 167, 57, 0} ,{15, 167, 58, 0} ,{15, 167, 59, 0} ,{15, 167, 60, 0} ,{15, 167, 61, 0} ,{15, 167, 62, 0} ,{15, 167, 63, 0} ,{15, 167, 64, 0} ,{15, 167, 65, 0} ,{15, 167, 66, 0} ,{15, 167, 67, 0} ,{15, 167, 68, 0} ,{15, 167, 69, 0} ,{15, 167, 70, 0} ,{16, 167, 45, 0} ,{16, 167, 46, 0} ,{16, 167, 47, 0} ,{16, 167, 48, 0} ,{16, 167, 49, 0} ,{16, 167, 50, 0} ,{16, 167, 51, 0} ,{16, 167, 52, 0} ,{16, 167, 53, 0} ,{16, 167, 54, 0} ,{16, 167, 55, 0} ,{16, 167, 56, 0} ,{16, 167, 57, 0} ,{16, 167, 58, 0} ,{16, 167, 59, 0} ,{16, 167, 60, 0} ,{16, 167, 61, 0} ,{16, 167, 62, 0} ,{16, 167, 63, 0} ,{16, 167, 64, 0} ,{16, 167, 65, 0} ,{16, 167, 66, 0} ,{16, 167, 67, 0} ,{16, 167, 68, 0} ,{16, 167, 69, 0} ,{16, 167, 70, 0} ,{18, 167, 45, 0} ,{18, 167, 46, 0} ,{18, 167, 47, 0} ,{18, 167, 48, 0} ,{18, 167, 49, 0} ,{18, 167, 50, 0} ,{18, 167, 51, 0} ,{18, 167, 52, 0} ,{18, 167, 53, 0} ,{18, 167, 54, 0} ,{18, 167, 55, 0} ,{18, 167, 56, 0} ,{18, 167, 57, 0} ,{18, 167, 58, 0} ,{18, 167, 59, 0} ,{18, 167, 60, 0} ,{18, 167, 61, 0} ,{18, 167, 62, 0} ,{18, 167, 63, 0} ,{18, 167, 64, 0} ,{18, 167, 65, 0} ,{18, 167, 66, 0} ,{18, 167, 67, 0} ,{18, 167, 68, 0} ,{18, 167, 69, 0} ,{18, 167, 70, 0} ,{14, 167, 45, 0} ,{14, 167, 46, 0} ,{14, 167, 47, 0} ,{14, 167, 48, 0} ,{14, 167, 49, 0} ,{14, 167, 50, 0} ,{14, 167, 51, 0} ,{14, 167, 53, 0} ,{14, 167, 54, 0} ,{14, 167, 55, 0} ,{14, 167, 56, 0} ,{14, 167, 57, 0} ,{14, 167, 58, 0} ,{14, 167, 59, 0} ,{14, 167, 60, 0} ,{14, 167, 61, 0} ,{14, 167, 62, 0} ,{14, 167, 63, 0} ,{14, 167, 64, 0} ,{14, 167, 65, 0} ,{14, 167, 66, 0} ,{14, 167, 67, 0} ,{14, 167, 68, 0} ,{14, 167, 69, 0} ,{14, 167, 70, 0} ,{19, 167, 45, 0} ,{19, 167, 46, 0} ,{19, 167, 47, 0} ,{19, 167, 48, 0} ,{19, 167, 49, 0} ,{19, 167, 50, 0} ,{19, 167, 51, 0} ,{19, 167, 52, 0} ,{19, 167, 53, 0} ,{19, 167, 54, 0} ,{19, 167, 55, 0} ,{19, 167, 56, 0} ,{19, 167, 57, 0} ,{19, 167, 58, 0} ,{19, 167, 59, 0} ,{19, 167, 60, 0} ,{19, 167, 61, 0} ,{19, 167, 62, 0} ,{19, 167, 63, 0} ,{19, 167, 64, 0} ,{19, 167, 65, 0} ,{19, 167, 66, 0} ,{19, 167, 67, 0} ,{19, 167, 68, 0} ,{19, 167, 69, 0} ,{19, 167, 70, 0} ,{20, 167, 45, 0} ,{20, 167, 46, 0} ,{20, 167, 47, 0} ,{20, 167, 48, 0} ,{20, 167, 49, 0} ,{20, 167, 50, 0} ,{20, 167, 51, 0} ,{20, 167, 52, 0} ,{20, 167, 53, 0} ,{20, 167, 54, 0} ,{20, 167, 55, 0} ,{20, 167, 56, 0} ,{20, 167, 57, 0} ,{20, 167, 58, 0} ,{20, 167, 59, 0} ,{20, 167, 60, 0} ,{20, 167, 61, 0} ,{20, 167, 62, 0} ,{20, 167, 63, 0} ,{20, 167, 64, 0} ,{20, 167, 65, 0} ,{20, 167, 66, 0} ,{20, 167, 67, 0} ,{20, 167, 68, 0} ,{20, 167, 69, 0} ,{20, 167, 70, 0} ,{40, 168, 45, 0} ,{40, 168, 47, 0} ,{40, 168, 48, 0} ,{40, 168, 51, 0} ,{40, 168, 54, 0} ,{40, 168, 55, 0} ,{40, 168, 58, 0} ,{40, 168, 59, 0} ,{40, 168, 60, 0} ,{40, 168, 61, 0} ,{40, 168, 63, 0} ,{40, 168, 64, 0} ,{40, 168, 65, 0} ,{40, 168, 66, 0} ,{40, 168, 67, 0} ,{40, 168, 68, 0} ,{40, 168, 69, 0} ,{40, 168, 70, 0} ,{225, 167, 45, 0} ,{225, 167, 46, 0} ,{225, 167, 47, 0} ,{225, 167, 48, 0} ,{225, 167, 50, 0} ,{225, 167, 52, 0} ,{225, 167, 53, 0} ,{225, 167, 54, 0} ,{225, 167, 55, 0} ,{225, 167, 56, 0} ,{225, 167, 57, 0} ,{225, 167, 58, 0} ,{225, 167, 60, 0} ,{225, 167, 61, 0} ,{225, 167, 62, 0} ,{225, 167, 63, 0} ,{225, 167, 64, 0} ,{225, 167, 65, 0} ,{225, 167, 66, 0} ,{225, 167, 67, 0} ,{225, 167, 68, 0} ,{225, 167, 69, 0} ,{225, 167, 70, 0} ,{173, 167, 45, 0} ,{173, 167, 46, 0} ,{173, 167, 47, 0} ,{173, 167, 48, 0} ,{173, 167, 49, 0} ,{173, 167, 50, 0} ,{173, 167, 51, 0} ,{173, 167, 52, 0} ,{173, 167, 53, 0} ,{173, 167, 54, 0} ,{173, 167, 55, 0} ,{173, 167, 56, 0} ,{173, 167, 57, 0} ,{173, 167, 58, 0} ,{173, 167, 59, 0} ,{173, 167, 60, 0} ,{173, 167, 61, 0} ,{173, 167, 62, 0} ,{173, 167, 63, 0} ,{173, 167, 64, 0} ,{173, 167, 65, 0} ,{173, 167, 66, 0} ,{173, 167, 67, 0} ,{173, 167, 68, 0} ,{173, 167, 69, 0} ,{173, 167, 70, 0} ,{174, 167, 45, 0} ,{174, 167, 46, 0} ,{174, 167, 47, 0} ,{174, 167, 48, 0} ,{174, 167, 49, 0} ,{174, 167, 50, 0} ,{174, 167, 51, 0} ,{174, 167, 52, 0} ,{174, 167, 53, 0} ,{174, 167, 54, 0} ,{174, 167, 55, 0} ,{174, 167, 56, 0} ,{174, 167, 57, 0} ,{174, 167, 58, 0} ,{174, 167, 59, 0} ,{174, 167, 60, 0} ,{174, 167, 61, 0} ,{174, 167, 62, 0} ,{174, 167, 63, 0} ,{174, 167, 64, 0} ,{174, 167, 65, 0} ,{174, 167, 66, 0} ,{174, 167, 67, 0} ,{174, 167, 68, 0} ,{174, 167, 69, 0} ,{174, 167, 70, 0} ,{246, 167, 45, 0} ,{246, 167, 46, 0} ,{246, 167, 48, 0} ,{246, 167, 49, 0} ,{246, 167, 50, 0} ,{246, 167, 51, 0} ,{246, 167, 54, 0} ,{246, 167, 55, 0} ,{246, 167, 56, 0} ,{246, 167, 57, 0} ,{246, 167, 58, 0} ,{246, 167, 59, 0} ,{246, 167, 60, 0} ,{246, 167, 61, 0} ,{246, 167, 63, 0} ,{246, 167, 64, 0} ,{246, 167, 65, 0} ,{246, 167, 66, 0} ,{246, 167, 67, 0} ,{246, 167, 68, 0} ,{246, 167, 69, 0} ,{175, 167, 45, 0} ,{175, 167, 46, 0} ,{175, 167, 47, 0} ,{175, 167, 48, 0} ,{175, 167, 49, 0} ,{175, 167, 50, 0} ,{175, 167, 51, 0} ,{175, 167, 52, 0} ,{175, 167, 53, 0} ,{175, 167, 54, 0} ,{175, 167, 55, 0} ,{175, 167, 56, 0} ,{175, 167, 57, 0} ,{175, 167, 58, 0} ,{175, 167, 59, 0} ,{175, 167, 60, 0} ,{175, 167, 61, 0} ,{175, 167, 62, 0} ,{175, 167, 63, 0} ,{175, 167, 64, 0} ,{175, 167, 65, 0} ,{175, 167, 66, 0} ,{175, 167, 67, 0} ,{175, 167, 68, 0} ,{175, 167, 69, 0} ,{175, 167, 70, 0} ,{21, 168, 45, 0} ,{21, 168, 46, 0} ,{21, 168, 48, 0} ,{21, 168, 49, 0} ,{21, 168, 50, 0} ,{21, 168, 51, 0} ,{21, 168, 53, 0} ,{21, 168, 54, 0} ,{21, 168, 55, 0} ,{21, 168, 56, 0} ,{21, 168, 57, 0} ,{21, 168, 59, 0} ,{21, 168, 63, 0} ,{21, 168, 64, 0} ,{21, 168, 65, 0} ,{21, 168, 66, 0} ,{21, 168, 67, 0} ,{21, 168, 68, 0} ,{21, 168, 69, 0} ,{176, 167, 45, 0} ,{176, 167, 46, 0} ,{176, 167, 47, 0} ,{176, 167, 48, 0} ,{176, 167, 49, 0} ,{176, 167, 50, 0} ,{176, 167, 51, 0} ,{176, 167, 52, 0} ,{176, 167, 53, 0} ,{176, 167, 54, 0} ,{176, 167, 55, 0} ,{176, 167, 56, 0} ,{176, 167, 57, 0} ,{176, 167, 58, 0} ,{176, 167, 59, 0} ,{176, 167, 60, 0} ,{176, 167, 61, 0} ,{176, 167, 62, 0} ,{176, 167, 63, 0} ,{176, 167, 64, 0} ,{176, 167, 65, 0} ,{176, 167, 66, 0} ,{176, 167, 67, 0} ,{176, 167, 68, 0} ,{176, 167, 69, 0} ,{176, 167, 70, 0} ,{177, 167, 45, 0} ,{177, 167, 46, 0} ,{177, 167, 47, 0} ,{177, 167, 48, 0} ,{177, 167, 49, 0} ,{177, 167, 50, 0} ,{177, 167, 51, 0} ,{177, 167, 52, 0} ,{177, 167, 53, 0} ,{177, 167, 54, 0} ,{177, 167, 55, 0} ,{177, 167, 56, 0} ,{177, 167, 57, 0} ,{177, 167, 58, 0} ,{177, 167, 59, 0} ,{177, 167, 60, 0} ,{177, 167, 61, 0} ,{177, 167, 62, 0} ,{177, 167, 63, 0} ,{177, 167, 64, 0} ,{177, 167, 65, 0} ,{177, 167, 66, 0} ,{177, 167, 67, 0} ,{177, 167, 68, 0} ,{177, 167, 69, 0} ,{177, 167, 70, 0} ,{178, 167, 45, 0} ,{178, 167, 46, 0} ,{178, 167, 47, 0} ,{178, 167, 48, 0} ,{178, 167, 49, 0} ,{178, 167, 50, 0} ,{178, 167, 51, 0} ,{178, 167, 52, 0} ,{178, 167, 53, 0} ,{178, 167, 54, 0} ,{178, 167, 55, 0} ,{178, 167, 56, 0} ,{178, 167, 57, 0} ,{178, 167, 58, 0} ,{178, 167, 59, 0} ,{178, 167, 60, 0} ,{178, 167, 61, 0} ,{178, 167, 62, 0} ,{178, 167, 63, 0} ,{178, 167, 64, 0} ,{178, 167, 65, 0} ,{178, 167, 66, 0} ,{178, 167, 67, 0} ,{178, 167, 68, 0} ,{178, 167, 69, 0} ,{178, 167, 70, 0} ,{179, 167, 45, 0} ,{179, 167, 46, 0} ,{179, 167, 47, 0} ,{179, 167, 48, 0} ,{179, 167, 49, 0} ,{179, 167, 50, 0} ,{179, 167, 51, 0} ,{179, 167, 52, 0} ,{179, 167, 53, 0} ,{179, 167, 54, 0} ,{179, 167, 55, 0} ,{179, 167, 56, 0} ,{179, 167, 57, 0} ,{179, 167, 58, 0} ,{179, 167, 59, 0} ,{179, 167, 60, 0} ,{179, 167, 61, 0} ,{179, 167, 62, 0} ,{179, 167, 63, 0} ,{179, 167, 64, 0} ,{179, 167, 65, 0} ,{179, 167, 66, 0} ,{179, 167, 67, 0} ,{179, 167, 68, 0} ,{179, 167, 69, 0} ,{179, 167, 70, 0} ,{180, 167, 45, 0} ,{180, 167, 46, 0} ,{180, 167, 47, 0} ,{180, 167, 48, 0} ,{180, 167, 49, 0} ,{180, 167, 50, 0} ,{180, 167, 51, 0} ,{180, 167, 52, 0} ,{180, 167, 53, 0} ,{180, 167, 54, 0} ,{180, 167, 55, 0} ,{180, 167, 56, 0} ,{180, 167, 57, 0} ,{180, 167, 58, 0} ,{180, 167, 59, 0} ,{180, 167, 60, 0} ,{180, 167, 61, 0} ,{180, 167, 62, 0} ,{180, 167, 63, 0} ,{180, 167, 64, 0} ,{180, 167, 65, 0} ,{180, 167, 66, 0} ,{180, 167, 67, 0} ,{180, 167, 68, 0} ,{180, 167, 69, 0} ,{180, 167, 70, 0} ,{21, 167, 45, 0} ,{21, 167, 46, 0} ,{21, 167, 47, 0} ,{21, 167, 48, 0} ,{21, 167, 49, 0} ,{21, 167, 50, 0} ,{21, 167, 51, 0} ,{21, 167, 52, 0} ,{21, 167, 53, 0} ,{21, 167, 54, 0} ,{21, 167, 55, 0} ,{21, 167, 56, 0} ,{21, 167, 57, 0} ,{21, 167, 58, 0} ,{21, 167, 59, 0} ,{21, 167, 60, 0} ,{21, 167, 61, 0} ,{21, 167, 62, 0} ,{21, 167, 63, 0} ,{21, 167, 64, 0} ,{21, 167, 65, 0} ,{21, 167, 66, 0} ,{21, 167, 67, 0} ,{21, 167, 68, 0} ,{21, 167, 69, 0} ,{21, 167, 70, 0} ,{22, 167, 45, 0} ,{22, 167, 46, 0} ,{22, 167, 47, 0} ,{22, 167, 48, 0} ,{22, 167, 49, 0} ,{22, 167, 50, 0} ,{22, 167, 51, 0} ,{22, 167, 52, 0} ,{22, 167, 53, 0} ,{22, 167, 54, 0} ,{22, 167, 55, 0} ,{22, 167, 56, 0} ,{22, 167, 57, 0} ,{22, 167, 58, 0} ,{22, 167, 59, 0} ,{22, 167, 60, 0} ,{22, 167, 61, 0} ,{22, 167, 62, 0} ,{22, 167, 63, 0} ,{22, 167, 64, 0} ,{22, 167, 65, 0} ,{22, 167, 66, 0} ,{22, 167, 67, 0} ,{22, 167, 68, 0} ,{22, 167, 69, 0} ,{22, 167, 70, 0} ,{181, 167, 45, 0} ,{181, 167, 46, 0} ,{181, 167, 47, 0} ,{181, 167, 48, 0} ,{181, 167, 49, 0} ,{181, 167, 50, 0} ,{181, 167, 51, 0} ,{181, 167, 52, 0} ,{181, 167, 53, 0} ,{181, 167, 54, 0} ,{181, 167, 55, 0} ,{181, 167, 56, 0} ,{181, 167, 57, 0} ,{181, 167, 58, 0} ,{181, 167, 59, 0} ,{181, 167, 60, 0} ,{181, 167, 61, 0} ,{181, 167, 62, 0} ,{181, 167, 63, 0} ,{181, 167, 64, 0} ,{181, 167, 65, 0} ,{181, 167, 66, 0} ,{181, 167, 67, 0} ,{181, 167, 68, 0} ,{181, 167, 69, 0} ,{181, 167, 70, 0} ,{182, 167, 45, 0} ,{182, 167, 46, 0} ,{182, 167, 47, 0} ,{182, 167, 48, 0} ,{182, 167, 49, 0} ,{182, 167, 50, 0} ,{182, 167, 51, 0} ,{182, 167, 52, 0} ,{182, 167, 53, 0} ,{182, 167, 54, 0} ,{182, 167, 55, 0} ,{182, 167, 56, 0} ,{182, 167, 57, 0} ,{182, 167, 58, 0} ,{182, 167, 59, 0} ,{182, 167, 60, 0} ,{182, 167, 61, 0} ,{182, 167, 62, 0} ,{182, 167, 63, 0} ,{182, 167, 64, 0} ,{182, 167, 65, 0} ,{182, 167, 66, 0} ,{182, 167, 67, 0} ,{182, 167, 68, 0} ,{182, 167, 69, 0} ,{182, 167, 70, 0} ,{23, 167, 45, 0} ,{23, 167, 46, 0} ,{23, 167, 47, 0} ,{23, 167, 48, 0} ,{23, 167, 49, 0} ,{23, 167, 50, 0} ,{23, 167, 51, 0} ,{23, 167, 52, 0} ,{23, 167, 53, 0} ,{23, 167, 54, 0} ,{23, 167, 55, 0} ,{23, 167, 56, 0} ,{23, 167, 57, 0} ,{23, 167, 58, 0} ,{23, 167, 59, 0} ,{23, 167, 60, 0} ,{23, 167, 61, 0} ,{23, 167, 62, 0} ,{23, 167, 63, 0} ,{23, 167, 64, 0} ,{23, 167, 65, 0} ,{23, 167, 66, 0} ,{23, 167, 67, 0} ,{23, 167, 68, 0} ,{23, 167, 69, 0} ,{23, 167, 70, 0} ,{24, 167, 45, 0} ,{24, 167, 46, 0} ,{24, 167, 47, 0} ,{24, 167, 48, 0} ,{24, 167, 49, 0} ,{24, 167, 50, 0} ,{24, 167, 51, 0} ,{24, 167, 52, 0} ,{24, 167, 53, 0} ,{24, 167, 54, 0} ,{24, 167, 55, 0} ,{24, 167, 56, 0} ,{24, 167, 57, 0} ,{24, 167, 58, 0} ,{24, 167, 59, 0} ,{24, 167, 60, 0} ,{24, 167, 61, 0} ,{24, 167, 62, 0} ,{24, 167, 63, 0} ,{24, 167, 64, 0} ,{24, 167, 65, 0} ,{24, 167, 66, 0} ,{24, 167, 67, 0} ,{24, 167, 68, 0} ,{24, 167, 69, 0} ,{24, 167, 70, 0} ,{183, 167, 45, 0} ,{183, 167, 46, 0} ,{183, 167, 47, 0} ,{183, 167, 48, 0} ,{183, 167, 49, 0} ,{183, 167, 50, 0} ,{183, 167, 51, 0} ,{183, 167, 52, 0} ,{183, 167, 53, 0} ,{183, 167, 54, 0} ,{183, 167, 55, 0} ,{183, 167, 56, 0} ,{183, 167, 57, 0} ,{183, 167, 58, 0} ,{183, 167, 59, 0} ,{183, 167, 60, 0} ,{183, 167, 61, 0} ,{183, 167, 62, 0} ,{183, 167, 63, 0} ,{183, 167, 64, 0} ,{183, 167, 65, 0} ,{183, 167, 66, 0} ,{183, 167, 67, 0} ,{183, 167, 68, 0} ,{183, 167, 69, 0} ,{183, 167, 70, 0} ,{184, 167, 45, 0} ,{184, 167, 46, 0} ,{184, 167, 47, 0} ,{184, 167, 48, 0} ,{184, 167, 49, 0} ,{184, 167, 50, 0} ,{184, 167, 51, 0} ,{184, 167, 52, 0} ,{184, 167, 53, 0} ,{184, 167, 54, 0} ,{184, 167, 55, 0} ,{184, 167, 56, 0} ,{184, 167, 57, 0} ,{184, 167, 58, 0} ,{184, 167, 59, 0} ,{184, 167, 60, 0} ,{184, 167, 61, 0} ,{184, 167, 62, 0} ,{184, 167, 63, 0} ,{184, 167, 64, 0} ,{184, 167, 65, 0} ,{184, 167, 66, 0} ,{184, 167, 67, 0} ,{184, 167, 68, 0} ,{184, 167, 69, 0} ,{184, 167, 70, 0} ,{85, 178, 53, 0} ,{85, 178, 54, 0} ,{15, 167, 234, 0} ,{15, 167, 93, 1} ,{15, 167, 182, 0} ,{15, 167, 178, 0} ,{15, 167, 94, 1} ,{15, 167, 95, 1} ,{15, 167, 96, 1} ,{15, 167, 97, 1} ,{15, 167, 184, 0} ,{15, 167, 98, 1} ,{15, 167, 99, 1} ,{15, 167, 100, 1} ,{15, 167, 101, 1} ,{15, 167, 102, 1} ,{15, 167, 103, 1} ,{15, 167, 104, 1} ,{15, 167, 105, 1} ,{15, 167, 195, 168} ,{15, 167, 106, 1} ,{15, 167, 107, 1} ,{15, 167, 196, 0} ,{15, 167, 245, 0} ,{15, 167, 108, 1} ,{15, 167, 109, 1} ,{15, 167, 244, 0} ,{154, 166, 221, 10} ,{16, 167, 234, 0} ,{16, 167, 93, 1} ,{16, 167, 182, 0} ,{16, 167, 178, 0} ,{16, 167, 94, 1} ,{16, 167, 95, 1} ,{16, 167, 96, 1} ,{16, 167, 97, 1} ,{16, 167, 184, 0} ,{16, 167, 98, 1} ,{16, 167, 99, 1} ,{16, 167, 100, 1} ,{16, 167, 101, 1} ,{16, 167, 102, 1} ,{16, 167, 103, 1} ,{16, 167, 104, 1} ,{16, 167, 105, 1} ,{16, 167, 161, 170} ,{16, 167, 106, 1} ,{16, 167, 107, 1} ,{16, 167, 196, 0} ,{16, 167, 245, 0} ,{16, 167, 108, 1} ,{16, 167, 109, 1} ,{16, 167, 244, 0} ,{154, 166, 19, 66} ,{154, 166, 28, 170} ,{154, 166, 195, 168} ,{154, 166, 162, 170} ,{154, 166, 163, 170} ,{154, 166, 164, 170} ,{154, 166, 165, 170} ,{18, 167, 234, 0} ,{18, 167, 93, 1} ,{18, 167, 182, 0} ,{18, 167, 178, 0} ,{18, 167, 94, 1} ,{18, 167, 95, 1} ,{18, 167, 96, 1} ,{18, 167, 97, 1} ,{18, 167, 184, 0} ,{18, 167, 98, 1} ,{18, 167, 99, 1} ,{18, 167, 100, 1} ,{18, 167, 101, 1} ,{18, 167, 102, 1} ,{18, 167, 103, 1} ,{18, 167, 104, 1} ,{18, 167, 105, 1} ,{18, 167, 195, 168} ,{18, 167, 106, 1} ,{18, 167, 107, 1} ,{18, 167, 196, 0} ,{18, 167, 245, 0} ,{18, 167, 108, 1} ,{18, 167, 109, 1} ,{18, 167, 244, 0} ,{214, 169, 221, 10} ,{14, 167, 234, 0} ,{14, 167, 93, 1} ,{14, 167, 182, 0} ,{14, 167, 178, 0} ,{14, 167, 94, 1} ,{14, 167, 95, 1} ,{14, 167, 96, 1} ,{14, 167, 97, 1} ,{14, 167, 184, 0} ,{14, 167, 98, 1} ,{14, 167, 99, 1} ,{14, 167, 100, 1} ,{14, 167, 101, 1} ,{14, 167, 102, 1} ,{14, 167, 103, 1} ,{14, 167, 104, 1} ,{14, 167, 105, 1} ,{14, 167, 161, 170} ,{14, 167, 106, 1} ,{14, 167, 107, 1} ,{14, 167, 196, 0} ,{14, 167, 245, 0} ,{14, 167, 108, 1} ,{14, 167, 109, 1} ,{14, 167, 244, 0} ,{214, 169, 19, 66} ,{214, 169, 28, 170} ,{214, 169, 195, 168} ,{214, 169, 162, 170} ,{214, 169, 163, 170} ,{214, 169, 164, 170} ,{214, 169, 165, 170} ,{19, 167, 234, 0} ,{19, 167, 93, 1} ,{19, 167, 182, 0} ,{19, 167, 178, 0} ,{19, 167, 94, 1} ,{19, 167, 95, 1} ,{19, 167, 96, 1} ,{19, 167, 97, 1} ,{19, 167, 184, 0} ,{19, 167, 98, 1} ,{19, 167, 99, 1} ,{19, 167, 100, 1} ,{19, 167, 101, 1} ,{19, 167, 102, 1} ,{19, 167, 103, 1} ,{19, 167, 104, 1} ,{19, 167, 105, 1} ,{19, 167, 195, 168} ,{19, 167, 106, 1} ,{19, 167, 107, 1} ,{19, 167, 196, 0} ,{19, 167, 245, 0} ,{19, 167, 108, 1} ,{19, 167, 109, 1} ,{19, 167, 244, 0} ,{215, 169, 221, 10} ,{20, 167, 234, 0} ,{20, 167, 93, 1} ,{20, 167, 182, 0} ,{20, 167, 178, 0} ,{20, 167, 94, 1} ,{20, 167, 95, 1} ,{20, 167, 96, 1} ,{20, 167, 97, 1} ,{20, 167, 184, 0} ,{20, 167, 98, 1} ,{20, 167, 99, 1} ,{20, 167, 100, 1} ,{20, 167, 101, 1} ,{20, 167, 102, 1} ,{20, 167, 103, 1} ,{20, 167, 104, 1} ,{20, 167, 105, 1} ,{20, 167, 161, 170} ,{20, 167, 106, 1} ,{20, 167, 107, 1} ,{20, 167, 196, 0} ,{20, 167, 245, 0} ,{20, 167, 108, 1} ,{20, 167, 109, 1} ,{20, 167, 244, 0} ,{215, 169, 19, 66} ,{215, 169, 28, 170} ,{215, 169, 195, 168} ,{215, 169, 162, 170} ,{215, 169, 163, 170} ,{215, 169, 164, 170} ,{215, 169, 165, 170} ,{21, 167, 234, 0} ,{21, 167, 93, 1} ,{21, 167, 182, 0} ,{21, 167, 178, 0} ,{21, 167, 94, 1} ,{21, 167, 95, 1} ,{21, 167, 96, 1} ,{21, 167, 97, 1} ,{21, 167, 184, 0} ,{21, 167, 98, 1} ,{21, 167, 99, 1} ,{21, 167, 100, 1} ,{21, 167, 101, 1} ,{21, 167, 102, 1} ,{21, 167, 103, 1} ,{21, 167, 104, 1} ,{21, 167, 105, 1} ,{21, 167, 195, 168} ,{21, 167, 106, 1} ,{21, 167, 107, 1} ,{21, 167, 196, 0} ,{21, 167, 245, 0} ,{21, 167, 108, 1} ,{21, 167, 109, 1} ,{21, 167, 244, 0} ,{162, 166, 221, 10} ,{22, 167, 234, 0} ,{22, 167, 93, 1} ,{22, 167, 182, 0} ,{22, 167, 178, 0} ,{22, 167, 94, 1} ,{22, 167, 95, 1} ,{22, 167, 96, 1} ,{22, 167, 97, 1} ,{22, 167, 184, 0} ,{22, 167, 98, 1} ,{22, 167, 99, 1} ,{22, 167, 100, 1} ,{22, 167, 101, 1} ,{22, 167, 102, 1} ,{22, 167, 103, 1} ,{22, 167, 104, 1} ,{22, 167, 105, 1} ,{22, 167, 161, 170} ,{22, 167, 106, 1} ,{22, 167, 107, 1} ,{22, 167, 196, 0} ,{22, 167, 245, 0} ,{22, 167, 108, 1} ,{22, 167, 109, 1} ,{22, 167, 244, 0} ,{162, 166, 19, 66} ,{162, 166, 28, 170} ,{162, 166, 195, 168} ,{162, 166, 162, 170} ,{162, 166, 163, 170} ,{162, 166, 164, 170} ,{162, 166, 165, 170} ,{23, 167, 234, 0} ,{23, 167, 93, 1} ,{23, 167, 182, 0} ,{23, 167, 178, 0} ,{23, 167, 94, 1} ,{23, 167, 95, 1} ,{23, 167, 96, 1} ,{23, 167, 97, 1} ,{23, 167, 184, 0} ,{23, 167, 98, 1} ,{23, 167, 99, 1} ,{23, 167, 100, 1} ,{23, 167, 101, 1} ,{23, 167, 102, 1} ,{23, 167, 103, 1} ,{23, 167, 104, 1} ,{23, 167, 105, 1} ,{23, 167, 195, 168} ,{23, 167, 106, 1} ,{23, 167, 107, 1} ,{23, 167, 196, 0} ,{23, 167, 245, 0} ,{23, 167, 108, 1} ,{23, 167, 109, 1} ,{23, 167, 244, 0} ,{216, 169, 221, 10} ,{24, 167, 234, 0} ,{24, 167, 93, 1} ,{24, 167, 182, 0} ,{24, 167, 178, 0} ,{24, 167, 94, 1} ,{24, 167, 95, 1} ,{24, 167, 96, 1} ,{24, 167, 97, 1} ,{24, 167, 184, 0} ,{24, 167, 98, 1} ,{24, 167, 99, 1} ,{24, 167, 100, 1} ,{24, 167, 101, 1} ,{24, 167, 102, 1} ,{24, 167, 103, 1} ,{24, 167, 104, 1} ,{24, 167, 105, 1} ,{24, 167, 161, 170} ,{24, 167, 106, 1} ,{24, 167, 107, 1} ,{24, 167, 196, 0} ,{24, 167, 245, 0} ,{24, 167, 108, 1} ,{24, 167, 109, 1} ,{24, 167, 244, 0} ,{216, 169, 19, 66} ,{216, 169, 28, 170} ,{216, 169, 195, 168} ,{216, 169, 162, 170} ,{216, 169, 163, 170} ,{216, 169, 164, 170} ,{216, 169, 165, 170} ,{15, 167, 79, 1} ,{16, 167, 79, 1} ,{154, 166, 243, 37} ,{154, 166, 244, 37} ,{154, 166, 245, 37} ,{154, 166, 246, 37} ,{154, 166, 247, 37} ,{154, 166, 248, 37} ,{154, 166, 249, 37} ,{154, 166, 250, 37} ,{154, 166, 251, 37} ,{154, 166, 252, 37} ,{250, 166, 243, 37} ,{250, 166, 244, 37} ,{250, 166, 245, 37} ,{250, 166, 246, 37} ,{250, 166, 247, 37} ,{250, 166, 248, 37} ,{250, 166, 249, 37} ,{250, 166, 250, 37} ,{250, 166, 251, 37} ,{250, 166, 252, 37} ,{153, 166, 243, 37} ,{153, 166, 244, 37} ,{153, 166, 245, 37} ,{153, 166, 246, 37} ,{153, 166, 247, 37} ,{153, 166, 248, 37} ,{153, 166, 249, 37} ,{153, 166, 250, 37} ,{153, 166, 251, 37} ,{153, 166, 252, 37} ,{162, 166, 243, 37} ,{162, 166, 244, 37} ,{162, 166, 245, 37} ,{162, 166, 246, 37} ,{162, 166, 247, 37} ,{162, 166, 248, 37} ,{162, 166, 249, 37} ,{162, 166, 250, 37} ,{162, 166, 251, 37} ,{162, 166, 252, 37} ,{229, 166, 243, 37} ,{229, 166, 244, 37} ,{229, 166, 245, 37} ,{229, 166, 246, 37} ,{229, 166, 247, 37} ,{229, 166, 248, 37} ,{229, 166, 249, 37} ,{229, 166, 250, 37} ,{229, 166, 251, 37} ,{229, 166, 252, 37} ,{65, 186, 111, 12} ,{66, 186, 111, 12} ,{67, 186, 111, 12} ,{68, 186, 111, 12} ,{69, 186, 232, 15} ,{70, 186, 232, 15} ,{71, 186, 232, 15} ,{247, 173, 129, 169} ,{248, 173, 129, 169} ,{249, 173, 129, 169} ,{250, 173, 129, 169} ,{251, 173, 129, 169} ,{252, 173, 129, 169} ,{253, 173, 129, 169} ,{254, 173, 129, 169} ,{255, 173, 129, 169} ,{247, 173, 130, 169} ,{248, 173, 130, 169} ,{249, 173, 130, 169} ,{250, 173, 130, 169} ,{251, 173, 130, 169} ,{252, 173, 130, 169} ,{253, 173, 130, 169} ,{254, 173, 130, 169} ,{255, 173, 130, 169} ,{247, 173, 131, 169} ,{248, 173, 131, 169} ,{249, 173, 131, 169} ,{250, 173, 131, 169} ,{251, 173, 131, 169} ,{252, 173, 131, 169} ,{253, 173, 131, 169} ,{254, 173, 131, 169} ,{255, 173, 131, 169} ,{63, 167, 200, 34} ,{63, 167, 201, 34} ,{63, 167, 189, 15} ,{63, 167, 202, 34} ,{63, 167, 203, 34} ,{63, 167, 204, 34} ,{63, 167, 205, 34} ,{63, 167, 206, 34} ,{63, 167, 207, 34} ,{63, 167, 172, 26} ,{72, 186, 172, 26} ,{29, 170, 211, 34} ,{29, 170, 212, 34} ,{29, 170, 213, 34} ,{29, 170, 214, 34} ,{29, 170, 215, 34} ,{29, 170, 216, 34} ,{29, 170, 217, 34} ,{30, 170, 211, 34} ,{30, 170, 212, 34} ,{30, 170, 213, 34} ,{30, 170, 214, 34} ,{30, 170, 215, 34} ,{30, 170, 216, 34} ,{30, 170, 217, 34} ,{31, 170, 211, 34} ,{31, 170, 212, 34} ,{31, 170, 213, 34} ,{31, 170, 214, 34} ,{31, 170, 215, 34} ,{31, 170, 216, 34} ,{31, 170, 217, 34} ,{32, 170, 211, 34} ,{32, 170, 212, 34} ,{32, 170, 213, 34} ,{32, 170, 214, 34} ,{32, 170, 215, 34} ,{32, 170, 216, 34} ,{32, 170, 217, 34} ,{33, 170, 211, 34} ,{33, 170, 212, 34} ,{33, 170, 213, 34} ,{33, 170, 214, 34} ,{33, 170, 215, 34} ,{33, 170, 216, 34} ,{33, 170, 217, 34} ,{34, 170, 211, 34} ,{34, 170, 212, 34} ,{34, 170, 213, 34} ,{34, 170, 214, 34} ,{34, 170, 215, 34} ,{34, 170, 216, 34} ,{34, 170, 217, 34} ,{35, 170, 211, 34} ,{35, 170, 212, 34} ,{35, 170, 213, 34} ,{35, 170, 214, 34} ,{35, 170, 215, 34} ,{35, 170, 216, 34} ,{35, 170, 217, 34} ,{73, 186, 172, 26} ,{36, 170, 211, 34} ,{36, 170, 212, 34} ,{36, 170, 213, 34} ,{36, 170, 214, 34} ,{36, 170, 215, 34} ,{36, 170, 216, 34} ,{36, 170, 217, 34} ,{37, 170, 211, 34} ,{37, 170, 212, 34} ,{37, 170, 213, 34} ,{37, 170, 214, 34} ,{37, 170, 215, 34} ,{37, 170, 216, 34} ,{37, 170, 217, 34} ,{38, 170, 211, 34} ,{38, 170, 212, 34} ,{38, 170, 213, 34} ,{38, 170, 214, 34} ,{38, 170, 215, 34} ,{38, 170, 216, 34} ,{38, 170, 217, 34} ,{39, 170, 211, 34} ,{39, 170, 212, 34} ,{39, 170, 213, 34} ,{39, 170, 214, 34} ,{39, 170, 215, 34} ,{39, 170, 216, 34} ,{39, 170, 217, 34} ,{40, 170, 211, 34} ,{40, 170, 212, 34} ,{40, 170, 213, 34} ,{40, 170, 214, 34} ,{40, 170, 215, 34} ,{40, 170, 216, 34} ,{40, 170, 217, 34} ,{41, 170, 211, 34} ,{41, 170, 212, 34} ,{41, 170, 213, 34} ,{41, 170, 214, 34} ,{41, 170, 215, 34} ,{41, 170, 216, 34} ,{41, 170, 217, 34} ,{42, 170, 211, 34} ,{42, 170, 212, 34} ,{42, 170, 213, 34} ,{42, 170, 214, 34} ,{42, 170, 215, 34} ,{42, 170, 216, 34} ,{42, 170, 217, 34} ,{86, 178, 241, 37} ,{86, 178, 16, 0} ,{87, 178, 16, 0} ,{88, 178, 16, 0} ,{89, 178, 16, 0} ,{90, 178, 16, 0} ,{91, 178, 16, 0} ,{92, 178, 16, 0} ,{93, 178, 16, 0} ,{94, 178, 16, 0} ,{95, 178, 16, 0} ,{185, 167, 45, 0} ,{185, 167, 46, 0} ,{185, 167, 47, 0} ,{185, 167, 48, 0} ,{185, 167, 49, 0} ,{185, 167, 50, 0} ,{185, 167, 51, 0} ,{185, 167, 52, 0} ,{185, 167, 53, 0} ,{185, 167, 54, 0} ,{185, 167, 55, 0} ,{185, 167, 56, 0} ,{185, 167, 57, 0} ,{185, 167, 58, 0} ,{185, 167, 59, 0} ,{185, 167, 60, 0} ,{185, 167, 61, 0} ,{185, 167, 62, 0} ,{185, 167, 63, 0} ,{185, 167, 64, 0} ,{185, 167, 65, 0} ,{185, 167, 66, 0} ,{185, 167, 67, 0} ,{185, 167, 68, 0} ,{185, 167, 69, 0} ,{185, 167, 70, 0} ,{55, 169, 22, 38} ,{96, 178, 6, 38} ,{96, 178, 21, 38} ,{46, 11, 146, 17} ,{46, 11, 226, 34} ,{54, 169, 46, 0} ,{54, 169, 58, 0} ,{54, 169, 60, 0} ,{54, 169, 63, 0} ,{54, 169, 67, 0} ,{47, 11, 183, 0} ,{47, 11, 136, 17} ,{47, 11, 227, 34} ,{47, 11, 226, 22} ,{47, 11, 228, 34} ,{239, 11, 137, 68} ,{239, 11, 145, 68} ,{38, 171, 54, 0} ,{38, 171, 56, 0} ,{38, 171, 57, 0} ,{38, 171, 60, 0} ,{189, 12, 212, 162} ,{0, 174, 105, 27} ,{0, 174, 128, 3} ,{0, 174, 131, 3} ,{71, 0, 229, 34} ,{74, 186, 230, 34} ,{108, 167, 232, 34} ,{108, 167, 233, 34} ,{108, 167, 234, 34} ,{75, 186, 151, 1} ,{108, 167, 235, 34} ,{108, 167, 236, 34} ,{108, 167, 237, 34} ,{108, 167, 238, 34} ,{108, 167, 239, 34} ,{108, 167, 240, 34} ,{108, 167, 241, 34} ,{108, 167, 242, 34} ,{108, 167, 243, 34} ,{108, 167, 244, 34} ,{108, 167, 245, 34} ,{108, 167, 246, 34} ,{108, 167, 247, 34} ,{108, 167, 248, 34} ,{108, 167, 249, 34} ,{108, 167, 250, 34} ,{108, 167, 251, 34} ,{108, 167, 252, 34} ,{108, 167, 253, 34} ,{108, 167, 254, 34} ,{108, 167, 255, 34} ,{108, 167, 0, 35} ,{108, 167, 1, 35} ,{108, 167, 2, 35} ,{108, 167, 3, 35} ,{108, 167, 4, 35} ,{108, 167, 5, 35} ,{108, 167, 6, 35} ,{108, 167, 7, 35} ,{108, 167, 8, 35} ,{132, 169, 9, 35} ,{132, 169, 1, 35} ,{132, 169, 235, 34} ,{132, 169, 10, 35} ,{132, 169, 11, 35} ,{132, 169, 8, 35} ,{132, 169, 12, 35} ,{132, 169, 13, 35} ,{132, 169, 14, 35} ,{123, 166, 15, 35} ,{123, 166, 16, 35} ,{123, 166, 17, 35} ,{123, 166, 18, 35} ,{123, 166, 19, 35} ,{123, 166, 20, 35} ,{123, 166, 21, 35} ,{123, 166, 22, 35} ,{123, 166, 23, 35} ,{123, 166, 24, 35} ,{123, 166, 25, 35} ,{123, 166, 26, 35} ,{123, 166, 27, 35} ,{123, 166, 28, 35} ,{123, 166, 29, 35} ,{123, 166, 30, 35} ,{123, 166, 31, 35} ,{123, 166, 32, 35} ,{123, 166, 33, 35} ,{123, 166, 34, 35} ,{123, 166, 35, 35} ,{123, 166, 36, 35} ,{123, 166, 37, 35} ,{123, 166, 38, 35} ,{123, 166, 39, 35} ,{123, 166, 40, 35} ,{123, 166, 41, 35} ,{123, 166, 42, 35} ,{123, 166, 43, 35} ,{123, 166, 44, 35} ,{123, 166, 45, 35} ,{123, 166, 46, 35} ,{123, 166, 47, 35} ,{123, 166, 48, 35} ,{123, 166, 49, 35} ,{123, 166, 50, 35} ,{123, 166, 51, 35} ,{123, 166, 52, 35} ,{123, 166, 53, 35} ,{123, 166, 54, 35} ,{123, 166, 55, 35} ,{123, 166, 56, 35} ,{123, 166, 57, 35} ,{123, 166, 58, 35} ,{123, 166, 59, 35} ,{123, 166, 60, 35} ,{123, 166, 61, 35} ,{123, 166, 62, 35} ,{123, 166, 63, 35} ,{123, 166, 64, 35} ,{123, 166, 65, 35} ,{123, 166, 66, 35} ,{123, 166, 67, 35} ,{123, 166, 68, 35} ,{123, 166, 69, 35} ,{123, 166, 70, 35} ,{123, 166, 71, 35} ,{123, 166, 72, 35} ,{123, 166, 73, 35} ,{123, 166, 74, 35} ,{123, 166, 75, 35} ,{123, 166, 76, 35} ,{123, 166, 77, 35} ,{123, 166, 78, 35} ,{123, 166, 79, 35} ,{123, 166, 80, 35} ,{123, 166, 81, 35} ,{123, 166, 82, 35} ,{123, 166, 83, 35} ,{123, 166, 84, 35} ,{123, 166, 85, 35} ,{123, 166, 86, 35} ,{123, 166, 87, 35} ,{123, 166, 88, 35} ,{123, 166, 89, 35} ,{123, 166, 90, 35} ,{123, 166, 91, 35} ,{123, 166, 92, 35} ,{123, 166, 93, 35} ,{123, 166, 94, 35} ,{123, 166, 95, 35} ,{123, 166, 96, 35} ,{123, 166, 97, 35} ,{123, 166, 98, 35} ,{123, 166, 99, 35} ,{123, 166, 100, 35} ,{123, 166, 101, 35} ,{123, 166, 102, 35} ,{123, 166, 103, 35} ,{123, 166, 104, 35} ,{123, 166, 105, 35} ,{123, 166, 106, 35} ,{123, 166, 107, 35} ,{123, 166, 108, 35} ,{123, 166, 109, 35} ,{123, 166, 110, 35} ,{123, 166, 111, 35} ,{123, 166, 112, 35} ,{123, 166, 113, 35} ,{123, 166, 114, 35} ,{123, 166, 115, 35} ,{123, 166, 116, 35} ,{123, 166, 117, 35} ,{123, 166, 118, 35} ,{123, 166, 119, 35} ,{123, 166, 120, 35} ,{123, 166, 121, 35} ,{123, 166, 122, 35} ,{123, 166, 123, 35} ,{123, 166, 124, 35} ,{123, 166, 125, 35} ,{123, 166, 126, 35} ,{123, 166, 127, 35} ,{123, 166, 128, 35} ,{123, 166, 129, 35} ,{123, 166, 130, 35} ,{123, 166, 131, 35} ,{123, 166, 132, 35} ,{123, 166, 133, 35} ,{123, 166, 134, 35} ,{123, 166, 135, 35} ,{123, 166, 136, 35} ,{123, 166, 137, 35} ,{123, 166, 138, 35} ,{123, 166, 139, 35} ,{123, 166, 140, 35} ,{123, 166, 141, 35} ,{123, 166, 142, 35} ,{123, 166, 143, 35} ,{123, 166, 144, 35} ,{123, 166, 145, 35} ,{123, 166, 146, 35} ,{123, 166, 147, 35} ,{123, 166, 148, 35} ,{123, 166, 149, 35} ,{123, 166, 150, 35} ,{123, 166, 151, 35} ,{123, 166, 152, 35} ,{123, 166, 153, 35} ,{123, 166, 154, 35} ,{123, 166, 155, 35} ,{123, 166, 156, 35} ,{123, 166, 157, 35} ,{123, 166, 158, 35} ,{123, 166, 159, 35} ,{123, 166, 160, 35} ,{123, 166, 161, 35} ,{123, 166, 162, 35} ,{123, 166, 163, 35} ,{123, 166, 164, 35} ,{123, 166, 165, 35} ,{123, 166, 166, 35} ,{123, 166, 167, 35} ,{123, 166, 168, 35} ,{123, 166, 169, 35} ,{123, 166, 170, 35} ,{123, 166, 171, 35} ,{123, 166, 172, 35} ,{123, 166, 173, 35} ,{123, 166, 174, 35} ,{123, 166, 175, 35} ,{123, 166, 176, 35} ,{123, 166, 177, 35} ,{123, 166, 178, 35} ,{123, 166, 179, 35} ,{123, 166, 180, 35} ,{123, 166, 181, 35} ,{123, 166, 182, 35} ,{123, 166, 183, 35} ,{123, 166, 184, 35} ,{123, 166, 185, 35} ,{123, 166, 186, 35} ,{123, 166, 187, 35} ,{123, 166, 188, 35} ,{123, 166, 189, 35} ,{123, 166, 190, 35} ,{123, 166, 191, 35} ,{123, 166, 192, 35} ,{123, 166, 193, 35} ,{123, 166, 194, 35} ,{123, 166, 195, 35} ,{123, 166, 196, 35} ,{123, 166, 197, 35} ,{123, 166, 198, 35} ,{123, 166, 199, 35} ,{123, 166, 200, 35} ,{123, 166, 201, 35} ,{123, 166, 202, 35} ,{123, 166, 203, 35} ,{123, 166, 204, 35} ,{123, 166, 205, 35} ,{123, 166, 206, 35} ,{123, 166, 207, 35} ,{123, 166, 208, 35} ,{123, 166, 209, 35} ,{123, 166, 210, 35} ,{123, 166, 211, 35} ,{123, 166, 212, 35} ,{123, 166, 213, 35} ,{123, 166, 214, 35} ,{123, 166, 215, 35} ,{123, 166, 216, 35} ,{123, 166, 217, 35} ,{123, 166, 218, 35} ,{123, 166, 219, 35} ,{123, 166, 220, 35} ,{123, 166, 221, 35} ,{123, 166, 222, 35} ,{123, 166, 223, 35} ,{123, 166, 224, 35} ,{123, 166, 225, 35} ,{123, 166, 226, 35} ,{123, 166, 227, 35} ,{123, 166, 228, 35} ,{123, 166, 229, 35} ,{123, 166, 230, 35} ,{123, 166, 231, 35} ,{123, 166, 232, 35} ,{123, 166, 233, 35} ,{123, 166, 234, 35} ,{123, 166, 235, 35} ,{123, 166, 236, 35} ,{123, 166, 237, 35} ,{123, 166, 238, 35} ,{123, 166, 239, 35} ,{123, 166, 240, 35} ,{123, 166, 241, 35} ,{123, 166, 242, 35} ,{123, 166, 243, 35} ,{123, 166, 244, 35} ,{123, 166, 245, 35} ,{123, 166, 246, 35} ,{123, 166, 247, 35} ,{123, 166, 248, 35} ,{123, 166, 249, 35} ,{123, 166, 250, 35} ,{123, 166, 251, 35} ,{123, 166, 252, 35} ,{123, 166, 253, 35} ,{123, 166, 254, 35} ,{123, 166, 255, 35} ,{123, 166, 0, 36} ,{123, 166, 1, 36} ,{123, 166, 2, 36} ,{123, 166, 3, 36} ,{123, 166, 4, 36} ,{123, 166, 5, 36} ,{123, 166, 6, 36} ,{123, 166, 7, 36} ,{123, 166, 8, 36} ,{123, 166, 9, 36} ,{123, 166, 10, 36} ,{123, 166, 11, 36} ,{123, 166, 12, 36} ,{123, 166, 13, 36} ,{123, 166, 14, 36} ,{123, 166, 15, 36} ,{123, 166, 16, 36} ,{123, 166, 17, 36} ,{123, 166, 18, 36} ,{123, 166, 19, 36} ,{123, 166, 20, 36} ,{123, 166, 21, 36} ,{123, 166, 22, 36} ,{123, 166, 23, 36} ,{123, 166, 24, 36} ,{123, 166, 25, 36} ,{123, 166, 26, 36} ,{123, 166, 27, 36} ,{123, 166, 28, 36} ,{123, 166, 29, 36} ,{123, 166, 30, 36} ,{123, 166, 31, 36} ,{123, 166, 32, 36} ,{123, 166, 33, 36} ,{123, 166, 34, 36} ,{123, 166, 35, 36} ,{123, 166, 36, 36} ,{123, 166, 37, 36} ,{123, 166, 38, 36} ,{123, 166, 39, 36} ,{123, 166, 40, 36} ,{123, 166, 41, 36} ,{123, 166, 42, 36} ,{123, 166, 43, 36} ,{123, 166, 44, 36} ,{123, 166, 45, 36} ,{123, 166, 46, 36} ,{123, 166, 47, 36} ,{123, 166, 48, 36} ,{123, 166, 49, 36} ,{123, 166, 50, 36} ,{123, 166, 51, 36} ,{123, 166, 52, 36} ,{123, 166, 53, 36} ,{123, 166, 54, 36} ,{123, 166, 55, 36} ,{123, 166, 56, 36} ,{123, 166, 57, 36} ,{123, 166, 58, 36} ,{123, 166, 59, 36} ,{123, 166, 60, 36} ,{123, 166, 61, 36} ,{123, 166, 62, 36} ,{123, 166, 63, 36} ,{123, 166, 64, 36} ,{123, 166, 65, 36} ,{123, 166, 66, 36} ,{123, 166, 67, 36} ,{123, 166, 68, 36} ,{123, 166, 69, 36} ,{123, 166, 70, 36} ,{123, 166, 71, 36} ,{123, 166, 72, 36} ,{123, 166, 73, 36} ,{123, 166, 74, 36} ,{123, 166, 75, 36} ,{123, 166, 76, 36} ,{123, 166, 77, 36} ,{123, 166, 78, 36} ,{123, 166, 79, 36} ,{123, 166, 80, 36} ,{123, 166, 81, 36} ,{123, 166, 82, 36} ,{123, 166, 83, 36} ,{123, 166, 84, 36} ,{123, 166, 85, 36} ,{123, 166, 86, 36} ,{123, 166, 87, 36} ,{123, 166, 88, 36} ,{123, 166, 89, 36} ,{123, 166, 90, 36} ,{123, 166, 91, 36} ,{123, 166, 92, 36} ,{123, 166, 93, 36} ,{123, 166, 94, 36} ,{123, 166, 95, 36} ,{123, 166, 96, 36} ,{123, 166, 97, 36} ,{123, 166, 98, 36} ,{123, 166, 99, 36} ,{123, 166, 100, 36} ,{123, 166, 101, 36} ,{123, 166, 102, 36} ,{123, 166, 103, 36} ,{123, 166, 104, 36} ,{123, 166, 105, 36} ,{123, 166, 106, 36} ,{123, 166, 107, 36} ,{123, 166, 108, 36} ,{123, 166, 109, 36} ,{123, 166, 110, 36} ,{123, 166, 111, 36} ,{123, 166, 112, 36} ,{123, 166, 113, 36} ,{123, 166, 114, 36} ,{123, 166, 115, 36} ,{123, 166, 116, 36} ,{123, 166, 117, 36} ,{123, 166, 118, 36} ,{123, 166, 119, 36} ,{123, 166, 120, 36} ,{123, 166, 121, 36} ,{123, 166, 122, 36} ,{123, 166, 123, 36} ,{123, 166, 124, 36} ,{123, 166, 125, 36} ,{123, 166, 126, 36} ,{123, 166, 127, 36} ,{123, 166, 128, 36} ,{123, 166, 129, 36} ,{123, 166, 130, 36} ,{123, 166, 131, 36} ,{123, 166, 132, 36} ,{123, 166, 133, 36} ,{123, 166, 134, 36} ,{123, 166, 135, 36} ,{123, 166, 136, 36} ,{123, 166, 137, 36} ,{123, 166, 138, 36} ,{123, 166, 139, 36} ,{123, 166, 140, 36} ,{123, 166, 141, 36} ,{123, 166, 142, 36} ,{123, 166, 143, 36} ,{123, 166, 144, 36} ,{123, 166, 145, 36} ,{123, 166, 146, 36} ,{123, 166, 147, 36} ,{123, 166, 148, 36} ,{123, 166, 149, 36} ,{123, 166, 150, 36} ,{123, 166, 151, 36} ,{123, 166, 152, 36} ,{123, 166, 153, 36} ,{123, 166, 154, 36} ,{123, 166, 155, 36} ,{123, 166, 156, 36} ,{123, 166, 157, 36} ,{123, 166, 158, 36} ,{123, 166, 159, 36} ,{123, 166, 160, 36} ,{123, 166, 161, 36} ,{123, 166, 162, 36} ,{123, 166, 163, 36} ,{123, 166, 164, 36} ,{123, 166, 165, 36} ,{123, 166, 166, 36} ,{123, 166, 167, 36} ,{123, 166, 168, 36} ,{123, 166, 169, 36} ,{123, 166, 170, 36} ,{123, 166, 171, 36} ,{123, 166, 172, 36} ,{123, 166, 173, 36} ,{123, 166, 174, 36} ,{123, 166, 175, 36} ,{123, 166, 176, 36} ,{123, 166, 177, 36} ,{123, 166, 178, 36} ,{123, 166, 179, 36} ,{123, 166, 180, 36} ,{123, 166, 181, 36} ,{123, 166, 182, 36} ,{123, 166, 183, 36} ,{123, 166, 184, 36} ,{123, 166, 185, 36} ,{123, 166, 186, 36} ,{123, 166, 187, 36} ,{123, 166, 188, 36} ,{123, 166, 189, 36} ,{123, 166, 190, 36} ,{123, 166, 191, 36} ,{123, 166, 192, 36} ,{123, 166, 193, 36} ,{123, 166, 194, 36} ,{123, 166, 195, 36} ,{123, 166, 196, 36} ,{123, 166, 197, 36} ,{123, 166, 198, 36} ,{123, 166, 199, 36} ,{123, 166, 200, 36} ,{123, 166, 201, 36} ,{123, 166, 202, 36} ,{123, 166, 203, 36} ,{123, 166, 204, 36} ,{123, 166, 205, 36} ,{123, 166, 206, 36} ,{123, 166, 207, 36} ,{123, 166, 208, 36} ,{123, 166, 209, 36} ,{123, 166, 210, 36} ,{123, 166, 211, 36} ,{123, 166, 212, 36} ,{123, 166, 213, 36} ,{123, 166, 214, 36} ,{123, 166, 215, 36} ,{123, 166, 216, 36} ,{123, 166, 217, 36} ,{123, 166, 218, 36} ,{123, 166, 219, 36} ,{123, 166, 220, 36} ,{123, 166, 221, 36} ,{123, 166, 222, 36} ,{123, 166, 223, 36} ,{123, 166, 224, 36} ,{123, 166, 225, 36} ,{123, 166, 226, 36} ,{123, 166, 227, 36} ,{123, 166, 228, 36} ,{123, 166, 229, 36} ,{123, 166, 230, 36} ,{123, 166, 231, 36} ,{123, 166, 232, 36} ,{123, 166, 233, 36} ,{123, 166, 234, 36} ,{123, 166, 235, 36} ,{123, 166, 236, 36} ,{123, 166, 237, 36} ,{123, 166, 238, 36} ,{123, 166, 239, 36} ,{123, 166, 240, 36} ,{123, 166, 241, 36} ,{123, 166, 242, 36} ,{123, 166, 243, 36} ,{123, 166, 244, 36} ,{123, 166, 245, 36} ,{123, 166, 246, 36} ,{123, 166, 247, 36} ,{123, 166, 248, 36} ,{123, 166, 249, 36} ,{123, 166, 250, 36} ,{123, 166, 251, 36} ,{123, 166, 252, 36} ,{123, 166, 253, 36} ,{123, 166, 254, 36} ,{123, 166, 255, 36} ,{123, 166, 0, 37} ,{123, 166, 1, 37} ,{123, 166, 2, 37} ,{123, 166, 3, 37} ,{123, 166, 4, 37} ,{123, 166, 5, 37} ,{123, 166, 6, 37} ,{123, 166, 7, 37} ,{123, 166, 8, 37} ,{123, 166, 9, 37} ,{123, 166, 10, 37} ,{123, 166, 11, 37} ,{123, 166, 12, 37} ,{123, 166, 13, 37} ,{123, 166, 14, 37} ,{123, 166, 15, 37} ,{123, 166, 16, 37} ,{123, 166, 17, 37} ,{123, 166, 18, 37} ,{123, 166, 19, 37} ,{123, 166, 20, 37} ,{123, 166, 21, 37} ,{123, 166, 22, 37} ,{123, 166, 23, 37} ,{123, 166, 24, 37} ,{123, 166, 25, 37} ,{123, 166, 26, 37} ,{123, 166, 27, 37} ,{123, 166, 28, 37} ,{123, 166, 29, 37} ,{123, 166, 30, 37} ,{123, 166, 31, 37} ,{123, 166, 32, 37} ,{123, 166, 33, 37} ,{123, 166, 34, 37} ,{123, 166, 35, 37} ,{123, 166, 36, 37} ,{123, 166, 37, 37} ,{123, 166, 38, 37} ,{123, 166, 39, 37} ,{123, 166, 40, 37} ,{123, 166, 41, 37} ,{123, 166, 42, 37} ,{123, 166, 43, 37} ,{123, 166, 44, 37} ,{45, 37, 66, 28} ,{143, 28, 1, 0} ,{143, 28, 228, 37} ,{143, 28, 229, 37} ,{143, 28, 230, 37} ,{143, 28, 231, 37} ,{143, 28, 232, 37} ,{143, 28, 9, 0} ,{143, 28, 10, 0} ,{143, 28, 235, 37} ,{143, 28, 236, 37} ,{143, 28, 14, 0} ,{143, 28, 238, 37} ,{143, 28, 16, 0} ,{143, 28, 240, 37} ,{143, 28, 241, 37} ,{143, 28, 21, 0} ,{143, 28, 243, 37} ,{143, 28, 244, 37} ,{143, 28, 245, 37} ,{143, 28, 246, 37} ,{143, 28, 247, 37} ,{143, 28, 248, 37} ,{143, 28, 249, 37} ,{143, 28, 250, 37} ,{143, 28, 251, 37} ,{143, 28, 252, 37} ,{143, 28, 33, 0} ,{143, 28, 34, 0} ,{143, 28, 255, 37} ,{143, 28, 0, 38} ,{143, 28, 1, 38} ,{143, 28, 2, 38} ,{143, 28, 3, 38} ,{187, 167, 45, 0} ,{187, 167, 46, 0} ,{187, 167, 47, 0} ,{187, 167, 48, 0} ,{187, 167, 49, 0} ,{187, 167, 50, 0} ,{187, 167, 51, 0} ,{187, 167, 52, 0} ,{187, 167, 53, 0} ,{187, 167, 54, 0} ,{187, 167, 55, 0} ,{187, 167, 56, 0} ,{187, 167, 57, 0} ,{187, 167, 58, 0} ,{187, 167, 59, 0} ,{187, 167, 60, 0} ,{187, 167, 61, 0} ,{187, 167, 62, 0} ,{187, 167, 63, 0} ,{187, 167, 64, 0} ,{187, 167, 65, 0} ,{187, 167, 66, 0} ,{187, 167, 67, 0} ,{187, 167, 68, 0} ,{187, 167, 69, 0} ,{187, 167, 70, 0} ,{143, 28, 30, 38} ,{143, 28, 31, 38} ,{143, 28, 32, 38} ,{143, 28, 33, 38} ,{143, 28, 34, 38} ,{143, 28, 35, 38} ,{188, 167, 45, 0} ,{188, 167, 46, 0} ,{188, 167, 47, 0} ,{188, 167, 48, 0} ,{188, 167, 49, 0} ,{188, 167, 50, 0} ,{188, 167, 51, 0} ,{188, 167, 52, 0} ,{188, 167, 53, 0} ,{188, 167, 54, 0} ,{188, 167, 55, 0} ,{188, 167, 56, 0} ,{188, 167, 57, 0} ,{188, 167, 58, 0} ,{188, 167, 59, 0} ,{188, 167, 60, 0} ,{188, 167, 61, 0} ,{188, 167, 62, 0} ,{188, 167, 63, 0} ,{188, 167, 64, 0} ,{188, 167, 65, 0} ,{188, 167, 66, 0} ,{188, 167, 67, 0} ,{188, 167, 68, 0} ,{188, 167, 69, 0} ,{188, 167, 70, 0} ,{143, 28, 62, 38} ,{143, 28, 63, 38} ,{143, 28, 64, 38} ,{143, 28, 82, 0} ,{46, 37, 66, 28} ,{157, 166, 165, 13} ,{157, 166, 229, 13} ,{157, 166, 95, 34} ,{157, 166, 96, 34} ,{157, 166, 97, 34} ,{157, 166, 98, 34} ,{157, 166, 110, 13} ,{157, 166, 113, 13} ,{157, 166, 120, 13} ,{157, 166, 135, 13} ,{157, 166, 166, 13} ,{157, 166, 230, 13} ,{157, 166, 105, 34} ,{157, 166, 106, 34} ,{157, 166, 47, 37} ,{157, 166, 107, 34} ,{157, 166, 48, 37} ,{157, 166, 115, 13} ,{157, 166, 122, 13} ,{157, 166, 137, 13} ,{157, 166, 168, 13} ,{157, 166, 232, 13} ,{157, 166, 191, 26} ,{157, 166, 108, 34} ,{157, 166, 49, 37} ,{157, 166, 109, 34} ,{157, 166, 110, 34} ,{157, 166, 50, 37} ,{157, 166, 126, 13} ,{157, 166, 141, 13} ,{157, 166, 172, 13} ,{157, 166, 236, 13} ,{157, 166, 111, 34} ,{157, 166, 99, 34} ,{157, 166, 100, 34} ,{157, 166, 101, 34} ,{157, 166, 102, 34} ,{157, 166, 103, 34} ,{157, 166, 51, 37} ,{157, 166, 149, 13} ,{157, 166, 180, 13} ,{157, 166, 244, 13} ,{157, 166, 52, 37} ,{157, 166, 53, 37} ,{157, 166, 54, 37} ,{157, 166, 55, 37} ,{157, 166, 56, 37} ,{157, 166, 57, 37} ,{157, 166, 58, 37} ,{157, 166, 59, 37} ,{157, 166, 196, 13} ,{157, 166, 4, 14} ,{157, 166, 60, 37} ,{157, 166, 61, 37} ,{157, 166, 62, 37} ,{157, 166, 63, 37} ,{157, 166, 64, 37} ,{157, 166, 65, 37} ,{157, 166, 66, 37} ,{157, 166, 67, 37} ,{157, 166, 68, 37} ,{157, 166, 36, 14} ,{157, 166, 69, 37} ,{157, 166, 70, 37} ,{157, 166, 71, 37} ,{157, 166, 72, 37} ,{157, 166, 73, 37} ,{157, 166, 74, 37} ,{157, 166, 75, 37} ,{157, 166, 76, 37} ,{157, 166, 77, 37} ,{157, 166, 78, 37} ,{157, 166, 79, 37} ,{157, 166, 80, 37} ,{157, 166, 81, 37} ,{157, 166, 82, 37} ,{157, 166, 83, 37} ,{157, 166, 84, 37} ,{157, 166, 85, 37} ,{157, 166, 86, 37} ,{157, 166, 87, 37} ,{157, 166, 88, 37} ,{157, 166, 89, 37} ,{157, 166, 90, 37} ,{157, 166, 91, 37} ,{157, 166, 92, 37} ,{157, 166, 93, 37} ,{157, 166, 94, 37} ,{157, 166, 95, 37} ,{157, 166, 96, 37} ,{157, 166, 97, 37} ,{157, 166, 98, 37} ,{157, 166, 99, 37} ,{157, 166, 100, 37} ,{157, 166, 101, 37} ,{157, 166, 102, 37} ,{157, 166, 103, 37} ,{157, 166, 104, 37} ,{157, 166, 105, 37} ,{157, 166, 106, 37} ,{157, 166, 107, 37} ,{157, 166, 108, 37} ,{157, 166, 109, 37} ,{157, 166, 110, 37} ,{157, 166, 111, 37} ,{157, 166, 112, 37} ,{157, 166, 111, 13} ,{157, 166, 114, 13} ,{157, 166, 121, 13} ,{157, 166, 136, 13} ,{157, 166, 167, 13} ,{157, 166, 231, 13} ,{157, 166, 113, 37} ,{157, 166, 114, 37} ,{157, 166, 115, 37} ,{157, 166, 116, 37} ,{157, 166, 117, 37} ,{157, 166, 116, 13} ,{157, 166, 123, 13} ,{157, 166, 138, 13} ,{157, 166, 169, 13} ,{157, 166, 233, 13} ,{157, 166, 118, 37} ,{157, 166, 119, 37} ,{157, 166, 120, 37} ,{157, 166, 121, 37} ,{157, 166, 122, 37} ,{157, 166, 123, 37} ,{157, 166, 127, 13} ,{157, 166, 142, 13} ,{157, 166, 173, 13} ,{157, 166, 237, 13} ,{157, 166, 124, 37} ,{157, 166, 125, 37} ,{157, 166, 126, 37} ,{157, 166, 127, 37} ,{157, 166, 128, 37} ,{157, 166, 129, 37} ,{157, 166, 130, 37} ,{157, 166, 150, 13} ,{157, 166, 181, 13} ,{157, 166, 245, 13} ,{157, 166, 131, 37} ,{157, 166, 132, 37} ,{157, 166, 133, 37} ,{157, 166, 134, 37} ,{157, 166, 135, 37} ,{157, 166, 136, 37} ,{157, 166, 137, 37} ,{157, 166, 138, 37} ,{157, 166, 197, 13} ,{157, 166, 5, 14} ,{157, 166, 139, 37} ,{157, 166, 140, 37} ,{157, 166, 141, 37} ,{157, 166, 142, 37} ,{157, 166, 143, 37} ,{157, 166, 144, 37} ,{157, 166, 145, 37} ,{157, 166, 146, 37} ,{157, 166, 147, 37} ,{157, 166, 37, 14} ,{157, 166, 148, 37} ,{157, 166, 149, 37} ,{157, 166, 150, 37} ,{157, 166, 151, 37} ,{157, 166, 152, 37} ,{157, 166, 153, 37} ,{157, 166, 154, 37} ,{157, 166, 155, 37} ,{157, 166, 156, 37} ,{157, 166, 157, 37} ,{157, 166, 158, 37} ,{157, 166, 159, 37} ,{157, 166, 160, 37} ,{157, 166, 161, 37} ,{157, 166, 162, 37} ,{157, 166, 163, 37} ,{157, 166, 164, 37} ,{157, 166, 165, 37} ,{157, 166, 166, 37} ,{157, 166, 167, 37} ,{157, 166, 168, 37} ,{157, 166, 169, 37} ,{157, 166, 170, 37} ,{157, 166, 171, 37} ,{157, 166, 172, 37} ,{157, 166, 173, 37} ,{157, 166, 174, 37} ,{157, 166, 175, 37} ,{157, 166, 176, 37} ,{157, 166, 177, 37} ,{157, 166, 178, 37} ,{157, 166, 179, 37} ,{157, 166, 180, 37} ,{157, 166, 181, 37} ,{157, 166, 182, 37} ,{157, 166, 183, 37} ,{157, 166, 184, 37} ,{157, 166, 185, 37} ,{157, 166, 186, 37} ,{157, 166, 187, 37} ,{157, 166, 188, 37} ,{157, 166, 189, 37} ,{157, 166, 190, 37} ,{157, 166, 191, 37} ,{157, 166, 192, 37} ,{157, 166, 193, 37} ,{157, 166, 194, 37} ,{157, 166, 195, 37} ,{157, 166, 196, 37} ,{157, 166, 197, 37} ,{157, 166, 198, 37} ,{157, 166, 199, 37} ,{157, 166, 200, 37} ,{157, 166, 201, 37} ,{157, 166, 202, 37} ,{157, 166, 117, 13} ,{157, 166, 124, 13} ,{157, 166, 139, 13} ,{157, 166, 170, 13} ,{157, 166, 234, 13} ,{157, 166, 203, 37} ,{157, 166, 204, 37} ,{157, 166, 205, 37} ,{157, 166, 206, 37} ,{157, 166, 207, 37} ,{157, 166, 208, 37} ,{157, 166, 128, 13} ,{157, 166, 143, 13} ,{157, 166, 174, 13} ,{157, 166, 238, 13} ,{157, 166, 209, 37} ,{157, 166, 210, 37} ,{157, 166, 211, 37} ,{157, 166, 212, 37} ,{157, 166, 213, 37} ,{157, 166, 214, 37} ,{157, 166, 215, 37} ,{157, 166, 151, 13} ,{169, 5, 220, 4} ,{79, 0, 44, 0} ,{237, 17, 220, 4} ,{212, 28, 213, 28} ,{43, 0, 44, 0} ,{159, 15, 29, 23} ,{122, 166, 30, 23} ,{117, 27, 42, 1} ,{20, 7, 21, 7} ,{42, 0, 118, 166} ,{117, 166, 51, 0} ,{117, 166, 230, 33} ,{117, 166, 58, 0} ,{117, 166, 48, 0} ,{117, 166, 223, 37} ,{117, 166, 62, 0} ,{117, 166, 57, 0} ,{117, 166, 46, 0} ,{117, 166, 224, 37} ,{117, 166, 63, 0} ,{117, 166, 226, 22} ,{117, 166, 225, 37} ,{117, 166, 54, 0} ,{117, 166, 226, 37} ,{117, 166, 47, 0} ,{117, 166, 55, 0} ,{117, 166, 64, 0} ,{117, 166, 60, 0} ,{117, 166, 52, 0} ,{42, 0, 121, 166} ,{117, 9, 146, 3} ,{104, 2, 155, 0} ,{104, 2, 44, 0} ,{248, 5, 220, 4} ,{187, 2, 42, 1} ,{162, 10, 163, 10} ,{63, 10, 152, 166} ,{63, 10, 139, 34} ,{215, 21, 220, 4} ,{104, 13, 105, 13} ,{171, 8, 67, 25} ,{156, 166, 107, 13} ,{5, 33, 147, 166} ,{111, 1, 245, 2} ,{255, 2, 245, 2} ,{153, 166, 139, 34} ,{234, 15, 190, 11} ,{9, 1, 44, 0} ,{86, 25, 171, 0} ,{164, 10, 79, 0} ,{125, 166, 25, 7} ,{164, 10, 43, 0} ,{132, 1, 118, 166} ,{132, 1, 121, 166} ,{244, 2, 245, 2} ,{54, 1, 118, 166} ,{131, 16, 44, 0} ,{127, 0, 243, 2} ,{169, 5, 44, 0} ,{169, 5, 245, 5} ,{54, 1, 121, 166} ,{127, 0, 149, 0} ,{163, 8, 44, 0} ,{191, 11, 32, 12} ,{234, 8, 247, 8} ,{169, 5, 170, 5} ,{165, 166, 184, 25} ,{159, 15, 190, 11} ,{146, 3, 63, 2} ,{208, 34, 194, 34} ,{117, 27, 65, 27} ,{187, 166, 42, 1} ,{169, 5, 224, 5} ,{93, 5, 44, 0} ,{125, 166, 26, 7} ,{191, 166, 24, 7} ,{127, 16, 44, 0} ,{252, 6, 44, 0} ,{237, 8, 234, 8} ,{195, 166, 238, 8} ,{164, 166, 79, 0} ,{100, 5, 245, 2} ,{117, 34, 63, 2} ,{78, 22, 44, 0} ,{190, 3, 44, 0} ,{127, 0, 202, 2} ,{139, 0, 127, 0} ,{127, 0, 148, 2} ,{105, 4, 106, 4} ,{21, 8, 44, 0} ,{127, 0, 136, 2} ,{165, 166, 220, 4} ,{127, 0, 37, 25} ,{5, 15, 86, 27} ,{210, 166, 44, 0} ,{234, 8, 233, 22} ,{123, 10, 124, 10} ,{128, 11, 129, 11} ,{214, 166, 146, 3} ,{11, 2, 44, 0} ,{142, 0, 127, 0} ,{104, 16, 122, 16} ,{62, 1, 237, 1} ,{218, 166, 185, 166} ,{64, 1, 127, 0} ,{84, 11, 94, 34} ,{187, 1, 214, 0} ,{166, 17, 63, 2} ,{42, 0, 44, 0} ,{127, 0, 223, 166} ,{189, 1, 214, 0} ,{44, 0, 22, 1} ,{63, 10, 192, 34} ,{134, 16, 44, 0} ,{46, 11, 5, 0} ,{126, 0, 127, 0} ,{178, 166, 132, 0} ,{44, 0, 76, 0} ,{207, 166, 36, 25} ,{127, 0, 146, 2} ,{37, 4, 44, 0} ,{127, 0, 227, 166} ,{119, 1, 121, 166} ,{119, 1, 118, 166} ,{34, 4, 44, 0} ,{148, 166, 148, 2} ,{152, 22, 83, 9} ,{243, 22, 244, 22} ,{135, 0, 127, 0} ,{237, 17, 190, 11} ,{79, 25, 173, 166} ,{32, 27, 220, 4} ,{48, 28, 128, 14} ,{63, 10, 213, 166} ,{46, 9, 44, 0} ,{24, 15, 44, 0} ,{66, 27, 44, 0} ,{124, 166, 221, 27} ,{23, 4, 44, 0} ,{46, 11, 197, 16} ,{204, 166, 160, 166} ,{54, 1, 97, 26} ,{254, 166, 128, 14} ,{124, 166, 201, 1} ,{4, 167, 128, 14} ,{237, 0, 43, 0} ,{237, 0, 79, 0} ,{240, 3, 44, 0} ,{11, 4, 44, 0} ,{31, 4, 44, 0} ,{61, 5, 44, 0} ,{217, 22, 44, 0} ,{154, 166, 191, 34} ,{63, 10, 166, 166} ,{154, 166, 43, 0} ,{154, 166, 79, 0} ,{79, 25, 175, 166} ,{63, 10, 168, 166} ,{154, 166, 168, 166} ,{154, 166, 166, 166} ,{162, 166, 43, 0} ,{162, 166, 79, 0} ,{162, 166, 168, 166} ,{162, 166, 166, 166} ,{103, 10, 127, 0} ,{25, 167, 118, 10} ,{178, 166, 222, 0} ,{127, 0, 141, 0} ,{79, 0, 43, 0} ,{156, 22, 44, 0} ,{5, 15, 46, 3} ,{124, 166, 249, 166} ,{179, 26, 44, 0} ,{186, 166, 209, 34} ,{186, 166, 224, 34} ,{255, 3, 44, 0} ,{10, 4, 44, 0} ,{178, 9, 179, 9} ,{243, 166, 44, 0} ,{127, 5, 162, 22} ,{236, 166, 215, 0} ,{248, 26, 44, 0} ,{211, 14, 121, 166} ,{211, 14, 118, 166} ,{46, 11, 131, 16} ,{175, 22, 44, 0} ,{63, 10, 191, 34} ,{127, 0, 172, 0} ,{211, 21, 44, 0} ,{174, 166, 171, 166} ,{127, 0, 38, 25} ,{140, 26, 141, 26} ,{52, 167, 42, 1} ,{35, 1, 132, 1} ,{88, 26, 5, 0} ,{115, 27, 44, 0} ,{219, 4, 44, 0} ,{219, 4, 11, 167} ,{225, 166, 29, 167} ,{141, 22, 142, 22} ,{99, 5, 42, 1} ,{31, 167, 42, 1} ,{193, 34, 194, 34} ,{136, 5, 44, 0} ,{176, 8, 177, 8} ,{111, 8, 146, 3} ,{211, 166, 87, 27} ,{159, 15, 231, 34} ,{68, 167, 30, 23} ,{38, 0, 36, 0} ,{151, 166, 195, 3} ,{179, 10, 76, 1} ,{244, 26, 121, 166} ,{244, 26, 118, 166} ,{35, 0, 36, 0} ,{74, 3, 44, 0} ,{162, 9, 44, 0} ,{147, 166, 35, 1} ,{228, 1, 121, 166} ,{228, 1, 118, 166} ,{136, 5, 121, 166} ,{136, 5, 118, 166} ,{219, 4, 50, 2} ,{136, 0, 127, 0} ,{148, 166, 137, 2} ,{54, 1, 104, 34} ,{86, 167, 222, 166} ,{159, 15, 220, 0} ,{19, 12, 197, 16} ,{146, 166, 203, 166} ,{126, 166, 203, 166} ,{235, 166, 160, 166} ,{13, 3, 44, 0} ,{109, 2, 110, 2} ,{13, 4, 44, 0} ,{111, 8, 44, 0} ,{234, 8, 235, 8} ,{97, 167, 44, 0} ,{244, 166, 44, 0} ,{5, 15, 164, 10} ,{49, 27, 44, 0} ,{123, 3, 44, 0} ,{242, 166, 41, 167} ,{148, 166, 150, 2} ,{70, 25, 41, 5} ,{105, 167, 63, 2} ,{106, 167, 81, 0} ,{47, 11, 69, 167} ,{147, 9, 44, 0} ,{124, 0, 167, 2} ,{54, 167, 44, 0} ,{60, 167, 44, 0} ,{148, 166, 8, 3} ,{5, 15, 189, 10} ,{114, 167, 56, 27} ,{220, 166, 17, 4} ,{100, 167, 44, 0} ,{33, 27, 34, 27} ,{211, 166, 88, 27} ,{11, 2, 40, 1} ,{38, 167, 44, 0} ,{74, 0, 214, 0} ,{126, 166, 217, 166} ,{180, 166, 67, 5} ,{148, 166, 217, 2} ,{148, 166, 184, 2} ,{226, 26, 44, 0} ,{24, 27, 44, 0} ,{80, 27, 81, 27} ,{35, 1, 126, 166} ,{146, 166, 217, 166} ,{126, 166, 232, 166} ,{19, 12, 169, 5} ,{46, 11, 169, 5} ,{183, 166, 58, 26} ,{176, 26, 44, 0} ,{115, 167, 44, 0} ,{151, 166, 65, 0} ,{54, 1, 93, 34} ,{139, 167, 222, 166} ,{127, 0, 150, 0} ,{179, 166, 165, 8} ,{227, 8, 44, 0} ,{127, 0, 199, 1} ,{173, 166, 79, 0} ,{127, 0, 114, 0} ,{40, 167, 44, 0} ,{202, 0, 167, 2} ,{151, 166, 53, 0} ,{46, 11, 146, 166} ,{193, 4, 44, 0} ,{179, 166, 65, 167} ,{146, 166, 232, 166} ,{214, 0, 59, 1} ,{62, 1, 63, 1} ,{81, 0, 141, 0} ,{176, 166, 193, 5} ,{201, 26, 44, 0} ,{80, 27, 82, 27} ,{127, 0, 110, 167} ,{248, 7, 44, 0} ,{127, 0, 129, 0} ,{172, 166, 84, 1} ,{19, 12, 126, 166} ,{46, 11, 126, 166} ,{214, 0, 13, 0} ,{126, 166, 245, 166} ,{202, 166, 171, 166} ,{174, 166, 160, 166} ,{78, 25, 146, 166} ,{78, 25, 126, 166} ,{48, 27, 44, 0} ,{154, 166, 6, 167} ,{154, 166, 7, 167} ,{47, 167, 79, 0} ,{250, 166, 79, 0} ,{13, 167, 43, 0} ,{13, 167, 79, 0} ,{153, 166, 43, 0} ,{153, 166, 79, 0} ,{153, 166, 168, 166} ,{153, 166, 166, 166} ,{229, 166, 43, 0} ,{229, 166, 79, 0} ,{19, 12, 146, 166} ,{212, 11, 213, 11} ,{143, 28, 146, 166} ,{143, 28, 126, 166} ,{181, 166, 42, 1} ,{233, 0, 132, 0} ,{220, 166, 89, 17} ,{126, 166, 177, 0} ,{209, 166, 171, 166} ,{174, 27, 128, 14} ,{104, 2, 79, 0} ,{146, 166, 245, 166} ,{214, 0, 129, 0} ,{172, 166, 88, 1} ,{172, 166, 92, 1} ,{214, 0, 11, 0} ,{71, 0, 127, 0} ,{11, 1, 57, 12} ,{164, 166, 43, 0} ,{212, 166, 234, 166} ,{212, 166, 228, 166} ,{2, 167, 98, 26} ,{124, 166, 72, 28} ,{111, 8, 42, 1} ,{4, 9, 44, 0} ,{181, 166, 44, 0} ,{91, 1, 127, 0} ,{180, 166, 235, 3} ,{109, 10, 127, 0} ,{168, 22, 44, 0} ,{93, 5, 42, 1} ,{235, 166, 161, 166} ,{174, 166, 161, 166} ,{148, 166, 243, 2} ,{148, 166, 227, 2} ,{151, 166, 49, 0} ,{124, 166, 173, 27} ,{221, 167, 194, 167} ,{124, 166, 160, 28} ,{223, 167, 128, 14} ,{63, 10, 7, 167} ,{151, 3, 44, 0} ,{179, 166, 166, 8} ,{196, 166, 228, 166} ,{196, 166, 234, 166} ,{177, 166, 84, 1} ,{5, 15, 119, 1} ,{184, 166, 191, 15} ,{232, 167, 179, 15} ,{204, 166, 161, 166} ,{118, 167, 44, 0} ,{40, 27, 44, 0} ,{129, 167, 44, 0} ,{7, 3, 94, 167} ,{93, 5, 151, 166} ,{89, 1, 127, 0} ,{67, 2, 219, 166} ,{192, 10, 91, 0} ,{148, 166, 70, 3} ,{149, 166, 136, 2} ,{151, 166, 59, 0} ,{47, 167, 43, 0} ,{219, 4, 42, 1} ,{127, 0, 116, 0} ,{37, 1, 222, 0} ,{177, 166, 88, 1} ,{177, 166, 92, 1} ,{215, 166, 132, 11} ,{68, 13, 239, 11} ,{46, 11, 152, 166} ,{35, 0, 130, 4} ,{127, 0, 93, 0} ,{174, 0, 91, 0} ,{127, 0, 172, 3} ,{149, 166, 148, 2} ,{124, 166, 117, 28} ,{179, 166, 168, 8} ,{46, 9, 147, 166} ,{208, 9, 42, 1} ,{195, 0, 172, 0} ,{119, 0, 120, 0} ,{14, 1, 214, 0} ,{81, 0, 137, 10} ,{190, 166, 133, 5} ,{11, 2, 53, 2} ,{35, 1, 100, 0} ,{149, 166, 234, 2} ,{159, 167, 44, 0} ,{151, 166, 175, 3} ,{124, 166, 214, 27} ,{18, 168, 128, 14} ,{207, 167, 128, 14} ,{250, 166, 43, 0} ,{125, 166, 109, 7} ,{106, 8, 44, 0} ,{109, 8, 44, 0} ,{127, 0, 194, 0} ,{25, 168, 172, 0} ,{214, 0, 106, 0} ,{214, 0, 8, 10} ,{180, 166, 15, 1} ,{180, 166, 14, 1} ,{127, 0, 148, 167} ,{38, 0, 130, 4} ,{79, 0, 155, 0} ,{103, 167, 127, 0} ,{209, 166, 161, 166} ,{148, 166, 9, 3} ,{114, 27, 5, 0} ,{117, 14, 41, 5} ,{188, 34, 189, 34} ,{63, 10, 6, 167} ,{195, 167, 22, 1} ,{37, 4, 151, 166} ,{105, 8, 44, 0} ,{111, 8, 114, 8} ,{44, 168, 187, 2} ,{125, 166, 73, 7} ,{138, 0, 127, 0} ,{15, 1, 214, 0} ,{146, 7, 160, 10} ,{78, 2, 13, 0} ,{72, 1, 64, 1} ,{127, 0, 201, 0} ,{126, 166, 160, 0} ,{126, 166, 165, 0} ,{164, 166, 76, 0} ,{202, 166, 161, 166} ,{149, 0, 222, 0} ,{151, 166, 193, 3} ,{151, 166, 194, 3} ,{151, 166, 197, 3} ,{4, 168, 128, 14} ,{126, 0, 15, 0} ,{159, 166, 58, 33} ,{110, 8, 44, 0} ,{181, 166, 228, 166} ,{208, 9, 174, 0} ,{127, 0, 130, 0} ,{254, 9, 214, 0} ,{79, 0, 72, 167} ,{188, 10, 34, 1} ,{11, 0, 13, 0} ,{51, 10, 64, 1} ,{127, 0, 100, 0} ,{118, 0, 99, 0} ,{104, 16, 140, 16} ,{127, 0, 220, 0} ,{190, 3, 42, 1} ,{182, 166, 198, 5} ,{51, 167, 171, 166} ,{148, 166, 218, 2} ,{101, 0, 72, 0} ,{182, 166, 199, 5} ,{125, 166, 29, 7} ,{46, 9, 151, 166} ,{127, 0, 249, 167} ,{126, 166, 84, 167} ,{196, 11, 146, 3} ,{87, 168, 67, 5} ,{78, 2, 11, 0} ,{51, 10, 26, 167} ,{72, 1, 26, 167} ,{71, 0, 47, 10} ,{155, 167, 67, 2} ,{252, 12, 191, 10} ,{126, 166, 167, 0} ,{183, 2, 118, 166} ,{127, 0, 115, 0} ,{148, 166, 221, 2} ,{151, 166, 198, 3} ,{134, 27, 128, 14} ,{119, 27, 120, 27} ,{188, 166, 213, 2} ,{71, 0, 72, 0} ,{85, 0, 147, 0} ,{151, 3, 70, 2} ,{205, 166, 169, 4} ,{190, 166, 95, 5} ,{5, 168, 65, 167} ,{125, 166, 111, 1} ,{181, 166, 234, 166} ,{126, 166, 151, 0} ,{126, 166, 166, 0} ,{146, 166, 84, 167} ,{226, 166, 3, 10} ,{226, 166, 4, 10} ,{81, 0, 214, 0} ,{100, 0, 34, 1} ,{127, 0, 79, 0} ,{15, 0, 42, 1} ,{64, 1, 99, 0} ,{126, 166, 169, 0} ,{224, 166, 249, 3} ,{77, 1, 13, 0} ,{146, 166, 160, 0} ,{189, 166, 241, 5} ,{127, 0, 234, 2} ,{148, 166, 37, 25} ,{148, 166, 220, 2} ,{186, 167, 72, 0} ,{149, 166, 215, 2} ,{165, 166, 146, 3} ,{188, 166, 124, 0} ,{80, 0, 72, 0} ,{125, 166, 176, 7} ,{134, 168, 24, 7} ,{126, 166, 143, 0} ,{238, 166, 3, 10} ,{238, 166, 4, 10} ,{172, 166, 240, 167} ,{172, 166, 211, 167} ,{46, 13, 205, 10} ,{63, 1, 91, 0} ,{101, 0, 127, 0} ,{98, 0, 99, 0} ,{169, 0, 84, 11} ,{17, 3, 141, 0} ,{72, 1, 221, 166} ,{51, 10, 221, 166} ,{215, 21, 146, 3} ,{182, 166, 193, 5} ,{212, 166, 187, 2} ,{148, 166, 39, 25} ,{127, 0, 215, 2} ,{148, 166, 219, 2} ,{174, 166, 1, 167} ,{149, 166, 202, 2} ,{149, 166, 184, 2} ,{5, 0, 121, 0} ,{231, 27, 128, 14} ,{124, 166, 106, 28} ,{160, 168, 128, 14} ,{159, 166, 159, 33} ,{32, 1, 246, 2} ,{115, 5, 109, 5} ,{125, 166, 23, 7} ,{165, 168, 24, 7} ,{125, 166, 207, 8} ,{74, 0, 222, 0} ,{146, 166, 143, 0} ,{163, 167, 127, 0} ,{180, 166, 81, 0} ,{214, 0, 17, 3} ,{217, 10, 102, 0} ,{186, 10, 187, 10} ,{146, 167, 82, 0} ,{127, 0, 224, 0} ,{5, 15, 10, 15} ,{13, 0, 11, 1} ,{104, 16, 105, 16} ,{179, 168, 106, 4} ,{117, 16, 76, 1} ,{193, 166, 79, 0} ,{175, 166, 193, 5} ,{146, 166, 165, 0} ,{151, 166, 125, 3} ,{182, 166, 207, 5} ,{175, 22, 204, 22} ,{176, 166, 196, 5} ,{174, 166, 198, 166} ,{148, 166, 225, 2} ,{149, 166, 217, 2} ,{5, 0, 14, 4} ,{124, 166, 109, 28} ,{188, 166, 191, 2} ,{114, 1, 82, 1} ,{127, 0, 238, 167} ,{196, 168, 22, 0} ,{196, 166, 151, 166} ,{54, 1, 44, 0} ,{197, 166, 177, 0} ,{146, 166, 151, 0} ,{146, 166, 167, 0} ,{127, 0, 2, 10} ,{57, 1, 214, 0} ,{180, 166, 100, 0} ,{80, 0, 47, 10} ,{77, 1, 11, 0} ,{126, 166, 153, 0} ,{146, 166, 166, 0} ,{239, 166, 231, 167} ,{240, 166, 231, 167} ,{11, 0, 11, 1} ,{81, 0, 91, 0} ,{126, 166, 158, 0} ,{230, 0, 141, 0} ,{12, 167, 111, 1} ,{176, 166, 199, 5} ,{149, 166, 168, 2} ,{51, 167, 161, 166} ,{148, 166, 10, 3} ,{148, 166, 202, 2} ,{149, 166, 70, 3} ,{11, 0, 205, 10} ,{13, 0, 205, 10} ,{71, 167, 62, 0} ,{42, 1, 191, 3} ,{42, 1, 192, 3} ,{42, 1, 221, 3} ,{124, 166, 126, 27} ,{124, 166, 130, 28} ,{230, 168, 128, 14} ,{142, 0, 15, 0} ,{188, 166, 202, 0} ,{147, 166, 45, 34} ,{234, 168, 46, 34} ,{100, 0, 128, 0} ,{104, 2, 42, 1} ,{160, 167, 132, 0} ,{151, 3, 151, 166} ,{237, 166, 58, 4} ,{237, 166, 60, 4} ,{219, 4, 22, 0} ,{242, 168, 11, 1} ,{93, 5, 95, 5} ,{248, 5, 5, 0} ,{248, 5, 242, 6} ,{246, 168, 50, 2} ,{66, 167, 148, 8} ,{248, 168, 156, 8} ,{66, 167, 1, 9} ,{181, 166, 151, 166} ,{181, 166, 31, 9} ,{181, 166, 247, 8} ,{127, 0, 8, 168} ,{126, 166, 152, 0} ,{178, 166, 209, 2} ,{226, 166, 55, 1} ,{127, 0, 1, 10} ,{19, 12, 5, 0} ,{239, 11, 231, 166} ,{235, 3, 166, 167} ,{235, 3, 200, 167} ,{68, 13, 254, 167} ,{253, 167, 254, 167} ,{73, 3, 26, 167} ,{65, 1, 26, 167} ,{222, 10, 246, 2} ,{127, 0, 82, 11} ,{127, 0, 83, 11} ,{123, 10, 37, 1} ,{205, 10, 34, 1} ,{94, 168, 221, 166} ,{37, 0, 42, 1} ,{42, 0, 96, 168} ,{146, 166, 169, 0} ,{176, 1, 175, 1} ,{174, 0, 3, 0} ,{231, 166, 31, 12} ,{231, 166, 220, 16} ,{231, 166, 221, 16} ,{146, 167, 172, 0} ,{98, 0, 66, 13} ,{26, 169, 1, 168} ,{146, 166, 158, 0} ,{186, 10, 110, 2} ,{71, 167, 220, 3} ,{71, 167, 56, 0} ,{71, 167, 231, 3} ,{35, 1, 190, 3} ,{176, 166, 198, 5} ,{218, 168, 148, 2} ,{149, 166, 150, 2} ,{149, 166, 208, 2} ,{149, 166, 219, 2} ,{149, 166, 147, 2} ,{197, 10, 72, 0} ,{2, 167, 105, 26} ,{243, 3, 3, 0} ,{191, 2, 15, 4} ,{120, 0, 121, 0} ,{229, 168, 128, 14} ,{193, 168, 100, 168} ,{124, 166, 116, 1} ,{129, 27, 123, 27} ,{15, 0, 12, 27} ,{128, 14, 45, 0} ,{188, 166, 121, 0} ,{147, 166, 159, 11} ,{52, 169, 9, 34} ,{47, 11, 146, 166} ,{186, 167, 225, 34} ,{127, 0, 58, 1} ,{219, 4, 146, 3} ,{222, 4, 223, 4} ,{114, 5, 164, 168} ,{203, 0, 20, 0} ,{206, 166, 36, 8} ,{61, 169, 37, 8} ,{227, 8, 118, 166} ,{181, 166, 61, 167} ,{46, 9, 78, 167} ,{162, 9, 61, 167} ,{175, 0, 49, 0} ,{126, 166, 134, 0} ,{146, 166, 152, 0} ,{214, 0, 123, 40} ,{238, 166, 55, 1} ,{172, 166, 87, 1} ,{172, 166, 90, 1} ,{177, 166, 87, 1} ,{5, 10, 154, 167} ,{6, 10, 154, 167} ,{7, 10, 154, 167} ,{177, 166, 90, 1} ,{127, 0, 3, 10} ,{127, 0, 4, 10} ,{213, 166, 43, 0} ,{9, 168, 121, 0} ,{100, 0, 46, 11} ,{50, 13, 14, 0} ,{253, 167, 46, 11} ,{205, 10, 201, 167} ,{75, 167, 215, 0} ,{70, 167, 215, 0} ,{140, 0, 42, 1} ,{50, 10, 34, 1} ,{64, 1, 242, 167} ,{146, 166, 153, 0} ,{150, 166, 203, 0} ,{206, 10, 108, 69} ,{116, 167, 90, 17} ,{174, 1, 175, 1} ,{126, 166, 189, 0} ,{127, 0, 215, 168} ,{195, 3, 62, 0} ,{195, 3, 220, 3} ,{195, 3, 56, 0} ,{195, 3, 231, 3} ,{175, 22, 151, 166} ,{93, 5, 146, 3} ,{189, 166, 235, 5} ,{189, 166, 238, 5} ,{176, 166, 190, 5} ,{42, 0, 33, 168} ,{149, 166, 166, 2} ,{148, 166, 42, 25} ,{110, 169, 127, 0} ,{148, 166, 38, 25} ,{153, 168, 160, 166} ,{148, 166, 234, 2} ,{202, 166, 1, 167} ,{149, 166, 221, 2} ,{149, 166, 137, 2} ,{247, 166, 79, 0} ,{139, 10, 3, 0} ,{49, 27, 70, 2} ,{149, 0, 100, 8} ,{124, 166, 159, 168} ,{124, 166, 79, 2} ,{255, 4, 15, 0} ,{188, 166, 21, 12} ,{183, 12, 63, 2} ,{39, 168, 250, 11} ,{39, 168, 190, 34} ,{246, 2, 197, 34} ,{246, 2, 198, 34} ,{246, 2, 199, 34} ,{55, 169, 69, 167} ,{80, 1, 81, 1} ,{133, 169, 82, 1} ,{170, 166, 217, 1} ,{169, 166, 217, 1} ,{123, 3, 35, 1} ,{193, 4, 151, 166} ,{247, 167, 12, 5} ,{93, 5, 61, 167} ,{176, 166, 222, 5} ,{125, 166, 158, 7} ,{125, 166, 183, 7} ,{143, 169, 24, 7} ,{66, 167, 162, 8} ,{126, 166, 171, 0} ,{146, 166, 134, 0} ,{126, 166, 138, 0} ,{126, 166, 47, 168} ,{214, 0, 128, 0} ,{177, 166, 240, 167} ,{35, 1, 11, 0} ,{35, 1, 13, 0} ,{246, 2, 241, 167} ,{180, 166, 13, 0} ,{67, 5, 200, 167} ,{180, 166, 11, 0} ,{67, 5, 166, 167} ,{79, 0, 114, 10} ,{106, 12, 63, 2} ,{162, 12, 185, 166} ,{50, 2, 64, 13} ,{238, 10, 143, 168} ,{163, 169, 175, 0} ,{164, 169, 118, 14} ,{165, 169, 119, 14} ,{166, 169, 20, 11} ,{167, 169, 120, 168} ,{226, 0, 222, 0} ,{67, 2, 139, 14} ,{246, 2, 215, 0} ,{81, 0, 37, 1} ,{186, 10, 188, 10} ,{189, 10, 187, 10} ,{70, 11, 127, 0} ,{143, 2, 34, 12} ,{127, 0, 156, 167} ,{126, 166, 168, 0} ,{4, 15, 189, 0} ,{252, 166, 38, 15} ,{71, 0, 199, 9} ,{164, 166, 114, 22} ,{182, 169, 174, 0} ,{164, 166, 21, 1} ,{151, 166, 124, 3} ,{174, 0, 170, 4} ,{244, 166, 151, 166} ,{189, 166, 236, 5} ,{176, 166, 192, 5} ,{216, 166, 117, 10} ,{174, 166, 169, 167} ,{202, 166, 160, 166} ,{174, 166, 50, 167} ,{107, 167, 11, 0} ,{107, 167, 13, 0} ,{149, 166, 220, 2} ,{149, 166, 227, 2} ,{85, 167, 207, 166} ,{124, 166, 126, 0} ,{124, 166, 143, 27} ,{200, 169, 128, 14} ,{122, 27, 128, 14} ,{47, 169, 128, 14} ,{124, 166, 32, 28} ,{124, 166, 241, 27} ,{128, 14, 118, 27} ,{124, 166, 155, 28} ,{207, 169, 128, 14} ,{188, 166, 178, 10} ,{159, 166, 151, 33} ,{159, 166, 222, 33} ,{147, 166, 69, 34} ,{71, 34, 72, 34} ,{63, 10, 164, 10} ,{154, 166, 164, 10} ,{162, 166, 164, 10} ,{127, 0, 12, 1} ,{236, 166, 132, 0} ,{127, 0, 85, 0} ,{31, 168, 132, 0} ,{23, 4, 120, 0} ,{221, 169, 22, 0} ,{28, 4, 246, 2} ,{223, 169, 27, 0} ,{215, 167, 95, 5} ,{150, 166, 248, 0} ,{100, 0, 129, 0} ,{111, 8, 151, 166} ,{196, 166, 44, 0} ,{229, 169, 111, 1} ,{146, 166, 47, 168} ,{127, 0, 106, 0} ,{177, 166, 211, 167} ,{35, 1, 106, 10} ,{191, 10, 34, 1} ,{172, 11, 99, 0} ,{161, 169, 163, 12} ,{100, 0, 221, 166} ,{11, 0, 92, 168} ,{13, 0, 92, 168} ,{64, 1, 132, 0} ,{171, 11, 99, 0} ,{243, 10, 214, 0} ,{243, 10, 67, 2} ,{14, 1, 41, 1} ,{189, 10, 188, 10} ,{11, 0, 202, 167} ,{13, 0, 202, 167} ,{79, 0, 107, 10} ,{146, 166, 168, 0} ,{119, 1, 146, 3} ,{175, 166, 198, 5} ,{126, 166, 179, 0} ,{146, 166, 189, 0} ,{126, 166, 197, 0} ,{35, 1, 201, 166} ,{217, 22, 61, 167} ,{189, 166, 237, 5} ,{216, 166, 111, 1} ,{149, 166, 230, 2} ,{3, 168, 242, 2} ,{127, 0, 137, 2} ,{126, 168, 198, 166} ,{126, 168, 171, 166} ,{209, 166, 1, 167} ,{113, 16, 72, 0} ,{47, 25, 160, 166} ,{128, 16, 127, 16} ,{249, 0, 119, 169} ,{17, 167, 193, 5} ,{206, 167, 121, 0} ,{131, 0, 222, 0} ,{158, 168, 15, 4} ,{42, 1, 218, 3} ,{159, 27, 136, 10} ,{246, 27, 136, 10} ,{20, 170, 46, 8} ,{128, 14, 177, 19} ,{188, 166, 20, 12} ,{188, 166, 182, 10} ,{63, 168, 187, 33} ,{159, 166, 232, 33} ,{35, 1, 54, 1} ,{87, 1, 82, 1} ,{34, 167, 210, 34} ,{34, 167, 218, 34} ,{34, 167, 219, 34} ,{34, 167, 220, 34} ,{34, 167, 221, 34} ,{34, 167, 222, 34} ,{34, 167, 223, 34} ,{35, 167, 210, 34} ,{35, 167, 218, 34} ,{35, 167, 219, 34} ,{35, 167, 220, 34} ,{35, 167, 221, 34} ,{35, 167, 222, 34} ,{35, 167, 223, 34} ,{213, 0, 27, 168} ,{54, 1, 43, 0} ,{127, 0, 147, 0} ,{11, 2, 70, 2} ,{160, 167, 222, 0} ,{160, 167, 99, 0} ,{151, 3, 50, 2} ,{190, 3, 151, 166} ,{240, 3, 88, 0} ,{42, 1, 219, 3} ,{241, 166, 35, 4} ,{42, 168, 94, 4} ,{205, 166, 129, 4} ,{182, 166, 190, 5} ,{33, 8, 34, 8} ,{117, 5, 120, 5} ,{46, 9, 42, 1} ,{147, 9, 151, 166} ,{126, 166, 235, 9} ,{197, 166, 43, 0} ,{146, 166, 171, 0} ,{126, 166, 242, 0} ,{127, 0, 168, 168} ,{47, 1, 214, 0} ,{122, 167, 129, 0} ,{122, 167, 128, 0} ,{122, 167, 190, 167} ,{122, 167, 82, 0} ,{122, 167, 57, 168} ,{127, 0, 128, 0} ,{172, 166, 89, 1} ,{177, 166, 89, 1} ,{172, 166, 91, 1} ,{5, 10, 28, 168} ,{6, 10, 28, 168} ,{7, 10, 28, 168} ,{65, 1, 205, 10} ,{58, 11, 59, 11} ,{127, 0, 170, 0} ,{215, 166, 109, 10} ,{17, 3, 127, 0} ,{15, 1, 36, 12} ,{14, 1, 36, 12} ,{42, 12, 243, 11} ,{214, 0, 77, 1} ,{99, 0, 88, 12} ,{205, 10, 143, 12} ,{50, 10, 143, 12} ,{179, 12, 180, 12} ,{175, 0, 4, 3} ,{4, 0, 162, 169} ,{47, 10, 64, 13} ,{141, 168, 163, 65} ,{133, 10, 84, 13} ,{100, 0, 34, 12} ,{109, 10, 34, 1} ,{14, 1, 215, 0} ,{205, 10, 213, 167} ,{143, 14, 243, 0} ,{109, 0, 42, 1} ,{167, 2, 132, 0} ,{170, 169, 155, 167} ,{178, 166, 215, 0} ,{139, 14, 93, 168} ,{190, 14, 37, 1} ,{34, 11, 215, 0} ,{35, 11, 215, 0} ,{127, 0, 109, 10} ,{226, 0, 111, 14} ,{51, 168, 215, 0} ,{180, 168, 107, 16} ,{113, 170, 192, 10} ,{112, 16, 3, 0} ,{49, 167, 174, 0} ,{170, 166, 173, 1} ,{169, 166, 173, 1} ,{127, 0, 17, 3} ,{76, 168, 214, 0} ,{76, 168, 108, 14} ,{121, 170, 199, 1} ,{146, 166, 177, 0} ,{146, 166, 239, 9} ,{126, 166, 239, 9} ,{182, 166, 192, 5} ,{189, 166, 239, 5} ,{228, 1, 33, 168} ,{149, 166, 240, 2} ,{184, 2, 160, 166} ,{110, 0, 136, 2} ,{174, 166, 92, 167} ,{174, 166, 168, 167} ,{100, 0, 81, 168} ,{149, 166, 218, 2} ,{149, 166, 225, 2} ,{149, 166, 243, 2} ,{165, 166, 181, 12} ,{206, 167, 191, 2} ,{2, 167, 110, 26} ,{73, 167, 170, 0} ,{73, 167, 50, 1} ,{74, 167, 170, 0} ,{74, 167, 50, 1} ,{79, 0, 52, 2} ,{5, 0, 24, 0} ,{5, 0, 221, 6} ,{158, 168, 16, 4} ,{121, 0, 15, 4} ,{199, 169, 128, 14} ,{124, 166, 207, 27} ,{151, 170, 128, 14} ,{124, 166, 203, 1} ,{124, 166, 90, 28} ,{204, 169, 128, 14} ,{124, 166, 143, 28} ,{156, 170, 128, 14} ,{117, 14, 245, 2} ,{159, 166, 206, 33} ,{37, 1, 244, 33} ,{111, 1, 106, 1} ,{127, 1, 82, 1} ,{115, 1, 82, 1} ,{128, 1, 82, 1} ,{116, 1, 82, 1} ,{221, 0, 222, 0} ,{43, 0, 155, 0} ,{170, 166, 196, 1} ,{169, 166, 196, 1} ,{48, 170, 65, 1} ,{118, 168, 66, 0} ,{118, 168, 38, 169} ,{219, 169, 66, 0} ,{239, 168, 170, 0} ,{51, 170, 247, 3} ,{205, 166, 109, 4} ,{205, 166, 170, 4} ,{190, 166, 96, 5} ,{215, 167, 59, 169} ,{206, 166, 57, 170} ,{117, 5, 119, 5} ,{117, 5, 122, 5} ,{6, 168, 98, 0} ,{183, 170, 137, 9} ,{162, 9, 70, 2} ,{114, 8, 215, 9} ,{7, 168, 179, 8} ,{7, 168, 178, 8} ,{199, 168, 29, 167} ,{175, 0, 59, 0} ,{54, 1, 96, 168} ,{126, 166, 199, 0} ,{136, 0, 28, 167} ,{35, 1, 59, 167} ,{47, 1, 222, 0} ,{146, 166, 138, 0} ,{198, 167, 127, 0} ,{199, 167, 127, 0} ,{133, 10, 44, 0} ,{199, 170, 43, 0} ,{8, 11, 102, 0} ,{88, 168, 116, 168} ,{202, 0, 189, 2} ,{20, 12, 192, 2} ,{11, 0, 183, 11} ,{13, 0, 183, 11} ,{191, 10, 163, 65} ,{73, 3, 221, 166} ,{72, 1, 16, 169} ,{101, 0, 96, 13} ,{10, 168, 39, 1} ,{10, 168, 20, 3} ,{48, 168, 39, 1} ,{48, 168, 20, 3} ,{31, 7, 11, 1} ,{63, 1, 249, 3} ,{159, 11, 127, 0} ,{119, 168, 127, 0} ,{213, 2, 103, 170} ,{67, 2, 79, 11} ,{178, 166, 93, 13} ,{246, 2, 67, 2} ,{15, 1, 41, 1} ,{143, 2, 11, 168} ,{14, 1, 15, 1} ,{100, 0, 156, 167} ,{51, 10, 16, 169} ,{73, 168, 156, 167} ,{72, 168, 215, 0} ,{205, 10, 62, 10} ,{13, 0, 101, 0} ,{184, 166, 179, 15} ,{81, 0, 120, 16} ,{233, 170, 121, 16} ,{175, 166, 190, 5} ,{175, 166, 199, 5} ,{71, 0, 242, 0} ,{116, 170, 213, 21} ,{155, 166, 48, 22} ,{83, 1, 1, 168} ,{83, 1, 27, 169} ,{164, 166, 29, 1} ,{22, 1, 31, 1} ,{76, 0, 31, 1} ,{220, 0, 49, 1} ,{42, 0, 139, 22} ,{246, 170, 44, 0} ,{40, 167, 187, 2} ,{78, 168, 199, 5} ,{175, 22, 42, 1} ,{212, 166, 146, 3} ,{189, 166, 243, 5} ,{216, 166, 74, 2} ,{11, 2, 155, 0} ,{149, 166, 236, 2} ,{15, 168, 238, 2} ,{127, 0, 11, 170} ,{127, 0, 130, 170} ,{127, 0, 131, 170} ,{136, 2, 127, 0} ,{174, 166, 192, 169} ,{51, 167, 50, 167} ,{202, 166, 50, 167} ,{126, 167, 209, 166} ,{244, 167, 127, 0} ,{149, 166, 8, 3} ,{149, 166, 9, 3} ,{149, 166, 10, 3} ,{41, 167, 161, 166} ,{41, 167, 160, 166} ,{88, 26, 90, 26} ,{136, 10, 121, 0} ,{5, 0, 25, 0} ,{42, 1, 38, 1} ,{100, 0, 232, 3} ,{124, 166, 100, 168} ,{124, 166, 0, 28} ,{21, 171, 128, 14} ,{124, 166, 5, 28} ,{124, 166, 18, 28} ,{24, 171, 128, 14} ,{239, 27, 15, 0} ,{123, 169, 202, 169} ,{124, 166, 142, 0} ,{128, 14, 137, 27} ,{159, 27, 120, 27} ,{159, 166, 133, 33} ,{159, 166, 201, 33} ,{159, 166, 26, 33} ,{14, 1, 13, 0} ,{78, 167, 17, 34} ,{212, 169, 76, 34} ,{36, 171, 213, 169} ,{239, 11, 54, 169} ,{127, 0, 173, 0} ,{127, 0, 166, 170} ,{105, 170, 27, 168} ,{126, 166, 154, 0} ,{126, 166, 157, 0} ,{83, 1, 134, 169} ,{210, 1, 144, 167} ,{170, 166, 201, 1} ,{169, 166, 201, 1} ,{170, 166, 205, 1} ,{169, 166, 205, 1} ,{203, 166, 93, 0} ,{170, 166, 203, 1} ,{169, 166, 203, 1} ,{149, 166, 22, 1} ,{18, 3, 19, 3} ,{79, 0, 197, 0} ,{170, 170, 222, 0} ,{31, 168, 222, 0} ,{31, 168, 72, 3} ,{197, 168, 202, 0} ,{59, 171, 132, 0} ,{197, 168, 124, 0} ,{61, 171, 132, 0} ,{137, 169, 170, 0} ,{255, 3, 42, 1} ,{196, 3, 49, 0} ,{196, 3, 59, 0} ,{63, 2, 27, 4} ,{67, 171, 224, 169} ,{242, 3, 42, 169} ,{237, 166, 64, 4} ,{205, 166, 117, 4} ,{205, 166, 121, 4} ,{193, 4, 186, 169} ,{83, 167, 221, 4} ,{139, 169, 13, 5} ,{40, 5, 41, 5} ,{219, 4, 65, 5} ,{77, 171, 42, 1} ,{57, 169, 80, 5} ,{139, 169, 17, 5} ,{91, 5, 92, 5} ,{140, 169, 100, 5} ,{108, 5, 109, 5} ,{239, 167, 95, 5} ,{176, 166, 247, 5} ,{150, 166, 229, 6} ,{125, 166, 59, 7} ,{87, 171, 60, 7} ,{249, 168, 162, 8} ,{227, 8, 42, 1} ,{189, 167, 170, 4} ,{6, 168, 118, 0} ,{92, 171, 137, 9} ,{147, 9, 42, 1} ,{66, 168, 213, 9} ,{81, 170, 186, 0} ,{243, 0, 59, 0} ,{153, 169, 68, 1} ,{126, 166, 181, 0} ,{213, 0, 197, 167} ,{48, 1, 150, 169} ,{48, 1, 197, 167} ,{0, 169, 27, 168} ,{0, 169, 70, 169} ,{226, 0, 197, 167} ,{214, 0, 93, 0} ,{178, 168, 12, 1} ,{126, 166, 170, 0} ,{90, 167, 68, 168} ,{91, 167, 68, 168} ,{254, 9, 197, 167} ,{131, 167, 68, 168} ,{123, 167, 68, 168} ,{127, 0, 82, 0} ,{255, 9, 0, 10} ,{163, 167, 238, 166} ,{163, 167, 226, 166} ,{230, 167, 238, 166} ,{230, 167, 226, 166} ,{198, 167, 238, 166} ,{198, 167, 226, 166} ,{250, 167, 238, 166} ,{250, 167, 226, 166} ,{199, 167, 238, 166} ,{199, 167, 226, 166} ,{251, 167, 238, 166} ,{251, 167, 226, 166} ,{139, 168, 204, 168} ,{140, 168, 204, 168} ,{24, 10, 229, 37} ,{101, 0, 229, 37} ,{110, 167, 132, 0} ,{35, 1, 170, 0} ,{51, 1, 49, 1} ,{64, 1, 222, 0} ,{152, 166, 43, 0} ,{213, 166, 166, 166} ,{202, 0, 235, 169} ,{200, 10, 201, 10} ,{204, 10, 34, 1} ,{64, 1, 206, 10} ,{67, 2, 94, 66} ,{80, 5, 219, 166} ,{224, 10, 22, 4} ,{73, 11, 228, 10} ,{71, 0, 18, 11} ,{71, 0, 43, 11} ,{201, 170, 94, 66} ,{127, 0, 11, 168} ,{149, 171, 81, 11} ,{150, 171, 163, 168} ,{151, 171, 146, 168} ,{30, 7, 11, 1} ,{78, 2, 172, 0} ,{77, 1, 172, 0} ,{17, 3, 192, 11} ,{156, 171, 193, 11} ,{88, 168, 48, 168} ,{88, 168, 10, 168} ,{185, 166, 237, 11} ,{160, 171, 238, 11} ,{185, 166, 163, 168} ,{59, 10, 34, 12} ,{15, 1, 35, 12} ,{14, 1, 35, 12} ,{124, 167, 39, 12} ,{121, 0, 40, 12} ,{167, 171, 243, 11} ,{46, 12, 89, 168} ,{87, 170, 39, 1} ,{46, 12, 59, 12} ,{171, 171, 69, 11} ,{84, 12, 185, 11} ,{141, 168, 107, 10} ,{221, 0, 93, 170} ,{101, 0, 94, 170} ,{11, 0, 206, 168} ,{13, 0, 206, 168} ,{235, 3, 50, 10} ,{118, 0, 95, 170} ,{100, 0, 91, 169} ,{65, 1, 221, 166} ,{143, 2, 34, 1} ,{102, 14, 201, 0} ,{63, 1, 146, 69} ,{221, 166, 172, 0} ,{64, 1, 214, 0} ,{230, 0, 239, 12} ,{64, 1, 239, 12} ,{104, 14, 105, 14} ,{39, 12, 104, 10} ,{118, 10, 13, 0} ,{11, 0, 118, 10} ,{118, 10, 11, 0} ,{90, 168, 15, 1} ,{91, 168, 15, 1} ,{170, 0, 22, 10} ,{10, 169, 11, 0} ,{9, 169, 11, 0} ,{112, 14, 201, 0} ,{127, 0, 115, 14} ,{201, 171, 20, 11} ,{11, 0, 214, 0} ,{3, 3, 232, 10} ,{129, 14, 116, 14} ,{186, 11, 127, 0} ,{221, 0, 132, 0} ,{89, 169, 20, 11} ,{148, 14, 127, 0} ,{17, 3, 137, 10} ,{127, 0, 219, 170} ,{62, 1, 215, 0} ,{184, 14, 215, 0} ,{236, 0, 162, 0} ,{139, 14, 79, 11} ,{107, 170, 113, 66} ,{38, 11, 171, 169} ,{39, 11, 171, 169} ,{13, 0, 52, 11} ,{100, 0, 11, 168} ,{127, 0, 146, 168} ,{230, 0, 202, 167} ,{50, 10, 62, 10} ,{203, 10, 34, 1} ,{176, 169, 34, 1} ,{101, 14, 177, 169} ,{101, 14, 228, 170} ,{17, 169, 215, 0} ,{59, 10, 34, 1} ,{111, 170, 215, 0} ,{50, 10, 79, 0} ,{50, 10, 74, 168} ,{205, 10, 74, 168} ,{79, 0, 175, 1} ,{146, 166, 242, 0} ,{127, 0, 231, 0} ,{236, 171, 201, 0} ,{239, 166, 179, 169} ,{240, 166, 179, 169} ,{239, 166, 177, 168} ,{240, 166, 177, 168} ,{239, 166, 30, 9} ,{240, 166, 30, 9} ,{119, 1, 177, 168} ,{145, 15, 72, 0} ,{127, 0, 48, 10} ,{184, 166, 168, 15} ,{184, 166, 192, 15} ,{184, 166, 229, 15} ,{249, 171, 179, 15} ,{134, 16, 111, 1} ,{251, 171, 44, 0} ,{195, 16, 106, 4} ,{191, 167, 90, 17} ,{71, 0, 97, 17} ,{255, 171, 98, 17} ,{224, 166, 101, 5} ,{236, 0, 96, 169} ,{170, 166, 103, 0} ,{169, 166, 103, 0} ,{64, 22, 59, 0} ,{192, 1, 6, 0} ,{183, 169, 24, 1} ,{183, 169, 26, 1} ,{184, 169, 22, 1} ,{164, 166, 22, 1} ,{164, 166, 23, 1} ,{184, 169, 76, 0} ,{15, 1, 34, 1} ,{126, 166, 232, 0} ,{146, 166, 197, 0} ,{60, 167, 147, 22} ,{16, 172, 246, 8} ,{29, 169, 44, 169} ,{77, 168, 158, 22} ,{168, 22, 61, 167} ,{182, 166, 196, 5} ,{217, 22, 70, 2} ,{212, 166, 186, 169} ,{157, 167, 198, 5} ,{176, 166, 246, 5} ,{128, 170, 248, 24} ,{254, 170, 102, 2} ,{253, 170, 127, 0} ,{149, 166, 9, 25} ,{149, 166, 10, 25} ,{149, 166, 11, 25} ,{149, 166, 12, 25} ,{149, 166, 13, 25} ,{149, 166, 14, 25} ,{149, 166, 15, 25} ,{149, 166, 16, 25} ,{149, 166, 17, 25} ,{149, 166, 18, 25} ,{149, 166, 19, 25} ,{149, 166, 26, 25} ,{149, 166, 27, 25} ,{149, 166, 29, 25} ,{15, 168, 30, 25} ,{149, 166, 31, 25} ,{149, 166, 135, 0} ,{136, 2, 36, 25} ,{219, 167, 6, 170} ,{153, 168, 161, 166} ,{202, 166, 92, 167} ,{85, 167, 209, 166} ,{51, 167, 1, 167} ,{50, 10, 10, 170} ,{149, 166, 39, 25} ,{149, 166, 37, 25} ,{149, 166, 38, 25} ,{149, 166, 40, 25} ,{215, 0, 161, 166} ,{236, 166, 209, 2} ,{26, 4, 18, 10} ,{222, 5, 180, 5} ,{206, 167, 184, 10} ,{206, 167, 117, 2} ,{121, 0, 16, 4} ,{119, 26, 6, 0} ,{100, 167, 76, 1} ,{117, 2, 16, 4} ,{49, 27, 42, 1} ,{9, 2, 3, 0} ,{148, 167, 16, 171} ,{5, 0, 26, 0} ,{92, 0, 3, 0} ,{124, 166, 223, 10} ,{124, 166, 2, 28} ,{23, 171, 128, 14} ,{128, 14, 36, 6} ,{124, 166, 29, 28} ,{124, 169, 157, 1} ,{124, 166, 92, 28} ,{128, 14, 101, 168} ,{124, 166, 115, 28} ,{124, 166, 75, 9} ,{245, 27, 136, 10} ,{82, 172, 245, 27} ,{83, 172, 21, 170} ,{136, 10, 142, 0} ,{232, 168, 232, 168} ,{124, 166, 226, 4} ,{87, 172, 128, 14} ,{124, 166, 163, 28} ,{102, 168, 38, 168} ,{125, 169, 38, 168} ,{117, 27, 70, 2} ,{92, 172, 42, 1} ,{159, 166, 218, 33} ,{159, 166, 32, 33} ,{159, 166, 31, 33} ,{249, 33, 250, 33} ,{9, 34, 57, 12} ,{147, 166, 41, 12} ,{147, 166, 30, 1} ,{147, 166, 32, 1} ,{146, 166, 174, 0} ,{126, 166, 174, 0} ,{127, 0, 118, 166} ,{126, 166, 236, 0} ,{203, 0, 204, 0} ,{106, 172, 28, 167} ,{126, 166, 210, 0} ,{127, 0, 246, 0} ,{164, 166, 114, 0} ,{40, 1, 222, 0} ,{35, 1, 85, 0} ,{54, 1, 79, 0} ,{54, 1, 211, 167} ,{213, 0, 214, 0} ,{233, 0, 82, 1} ,{170, 166, 50, 1} ,{169, 166, 50, 1} ,{132, 1, 167, 170} ,{132, 1, 33, 168} ,{170, 166, 198, 1} ,{169, 166, 198, 1} ,{170, 166, 84, 167} ,{169, 166, 84, 167} ,{170, 166, 217, 166} ,{169, 166, 217, 166} ,{120, 170, 172, 0} ,{170, 166, 209, 1} ,{169, 166, 209, 1} ,{170, 166, 213, 1} ,{169, 166, 213, 1} ,{212, 168, 12, 1} ,{13, 168, 55, 2} ,{11, 2, 50, 2} ,{104, 2, 151, 166} ,{146, 2, 132, 0} ,{53, 171, 146, 2} ,{149, 166, 154, 0} ,{41, 168, 155, 0} ,{13, 3, 15, 3} ,{13, 3, 16, 3} ,{13, 3, 22, 3} ,{93, 167, 46, 3} ,{13, 3, 50, 3} ,{13, 3, 52, 3} ,{93, 167, 66, 3} ,{209, 2, 214, 0} ,{127, 0, 91, 0} ,{58, 171, 132, 0} ,{172, 170, 214, 0} ,{150, 172, 203, 170} ,{197, 168, 213, 2} ,{102, 167, 142, 3} ,{137, 169, 50, 1} ,{151, 3, 164, 166} ,{50, 1, 45, 0} ,{63, 2, 29, 4} ,{157, 172, 224, 169} ,{12, 4, 42, 169} ,{237, 166, 67, 4} ,{237, 166, 76, 4} ,{237, 166, 72, 4} ,{37, 4, 42, 1} ,{42, 168, 92, 4} ,{90, 4, 91, 4} ,{42, 168, 101, 4} ,{166, 172, 102, 4} ,{205, 166, 144, 4} ,{74, 171, 58, 169} ,{219, 4, 5, 5} ,{170, 172, 42, 1} ,{83, 167, 233, 4} ,{58, 167, 76, 171} ,{79, 171, 81, 5} ,{225, 4, 82, 5} ,{83, 167, 247, 4} ,{140, 169, 96, 5} ,{177, 172, 100, 5} ,{190, 166, 123, 5} ,{179, 172, 164, 168} ,{239, 167, 127, 5} ,{225, 169, 129, 5} ,{189, 166, 233, 5} ,{189, 166, 231, 5} ,{189, 166, 232, 5} ,{189, 166, 234, 5} ,{176, 166, 207, 5} ,{125, 166, 146, 7} ,{188, 172, 24, 7} ,{206, 166, 55, 8} ,{163, 8, 170, 8} ,{191, 172, 171, 8} ,{192, 172, 172, 8} ,{227, 8, 11, 167} ,{251, 8, 252, 8} ,{146, 8, 252, 8} ,{253, 8, 252, 8} ,{254, 8, 252, 8} ,{251, 8, 3, 9} ,{146, 8, 3, 9} ,{253, 8, 3, 9} ,{254, 8, 3, 9} ,{117, 5, 118, 5} ,{117, 5, 121, 5} ,{189, 167, 25, 9} ,{251, 166, 75, 9} ,{251, 166, 78, 9} ,{84, 168, 97, 9} ,{61, 9, 55, 9} ,{46, 9, 112, 9} ,{184, 170, 175, 0} ,{147, 9, 61, 167} ,{170, 0, 191, 3} ,{217, 166, 141, 0} ,{127, 0, 233, 0} ,{175, 0, 245, 166} ,{126, 166, 192, 0} ,{157, 0, 28, 167} ,{11, 0, 172, 0} ,{142, 0, 91, 0} ,{35, 1, 244, 9} ,{68, 1, 222, 0} ,{213, 0, 222, 0} ,{126, 166, 53, 1} ,{108, 171, 166, 0} ,{146, 166, 126, 0} ,{126, 166, 126, 0} ,{153, 167, 66, 170} ,{132, 167, 66, 170} ,{146, 166, 139, 0} ,{126, 166, 139, 0} ,{136, 168, 127, 0} ,{177, 166, 91, 1} ,{54, 1, 227, 166} ,{54, 1, 223, 166} ,{54, 1, 204, 168} ,{127, 0, 8, 10} ,{12, 10, 83, 64} ,{98, 0, 20, 10} ,{239, 172, 13, 0} ,{118, 0, 20, 10} ,{241, 172, 11, 0} ,{35, 1, 50, 1} ,{131, 0, 49, 1} ,{177, 0, 136, 171} ,{9, 168, 124, 0} ,{190, 10, 34, 1} ,{238, 169, 141, 0} ,{79, 170, 141, 171} ,{64, 1, 63, 1} ,{71, 168, 221, 166} ,{77, 8, 235, 169} ,{10, 11, 75, 167} ,{10, 11, 70, 167} ,{173, 168, 226, 10} ,{255, 172, 22, 4} ,{215, 166, 245, 169} ,{215, 166, 138, 11} ,{146, 167, 115, 0} ,{158, 171, 83, 170} ,{159, 171, 83, 170} ,{248, 2, 246, 2} ,{41, 5, 25, 0} ,{158, 169, 35, 12} ,{5, 169, 36, 12} ,{156, 169, 35, 12} ,{6, 169, 36, 12} ,{124, 167, 116, 168} ,{157, 169, 5, 169} ,{155, 169, 6, 169} ,{67, 5, 172, 168} ,{15, 173, 35, 12} ,{235, 3, 172, 168} ,{17, 173, 36, 12} ,{214, 0, 14, 1} ,{214, 0, 15, 1} ,{155, 169, 156, 169} ,{157, 169, 158, 169} ,{212, 167, 116, 168} ,{99, 8, 166, 167} ,{24, 173, 37, 12} ,{100, 0, 166, 167} ,{26, 173, 38, 12} ,{99, 8, 200, 167} ,{28, 173, 37, 12} ,{100, 0, 200, 167} ,{30, 173, 38, 12} ,{48, 168, 55, 3} ,{10, 168, 55, 3} ,{99, 8, 172, 168} ,{34, 173, 37, 12} ,{100, 0, 172, 168} ,{36, 173, 38, 12} ,{205, 168, 116, 168} ,{124, 167, 230, 0} ,{169, 171, 214, 0} ,{50, 10, 144, 168} ,{205, 10, 144, 168} ,{78, 2, 11, 1} ,{77, 1, 11, 1} ,{205, 10, 236, 169} ,{125, 12, 76, 168} ,{205, 10, 70, 11} ,{250, 12, 11, 0} ,{48, 173, 250, 12} ,{49, 173, 251, 12} ,{205, 10, 242, 169} ,{192, 2, 193, 2} ,{49, 13, 50, 13} ,{87, 12, 28, 10} ,{72, 1, 13, 1} ,{205, 10, 163, 65} ,{235, 3, 96, 170} ,{97, 13, 98, 13} ,{170, 0, 13, 0} ,{205, 10, 77, 13} ,{60, 173, 102, 13} ,{63, 10, 11, 0} ,{63, 10, 13, 0} ,{170, 0, 72, 1} ,{238, 169, 156, 167} ,{191, 171, 34, 1} ,{15, 1, 13, 0} ,{90, 168, 99, 170} ,{91, 168, 99, 170} ,{100, 13, 162, 0} ,{202, 0, 17, 3} ,{216, 170, 39, 1} ,{214, 0, 139, 14} ,{50, 10, 213, 167} ,{73, 0, 51, 1} ,{49, 168, 46, 11} ,{37, 1, 158, 14} ,{145, 168, 164, 14} ,{226, 0, 132, 0} ,{102, 170, 127, 0} ,{119, 168, 20, 11} ,{61, 1, 155, 167} ,{75, 167, 104, 170} ,{70, 167, 104, 170} ,{100, 0, 191, 14} ,{119, 168, 222, 0} ,{38, 11, 215, 0} ,{39, 11, 215, 0} ,{109, 14, 214, 0} ,{89, 173, 124, 14} ,{220, 171, 100, 0} ,{11, 0, 52, 11} ,{170, 0, 51, 10} ,{72, 168, 108, 14} ,{51, 168, 108, 14} ,{192, 167, 165, 0} ,{119, 1, 35, 1} ,{11, 0, 100, 0} ,{13, 0, 100, 0} ,{184, 166, 162, 15} ,{184, 166, 201, 15} ,{184, 166, 218, 15} ,{77, 1, 20, 3} ,{100, 0, 116, 16} ,{25, 1, 21, 169} ,{175, 166, 196, 5} ,{175, 166, 236, 5} ,{175, 166, 238, 5} ,{71, 0, 128, 17} ,{144, 15, 181, 1} ,{170, 166, 179, 0} ,{169, 166, 179, 0} ,{132, 1, 44, 0} ,{164, 166, 149, 0} ,{119, 170, 91, 0} ,{127, 0, 22, 1} ,{116, 173, 141, 0} ,{120, 0, 124, 0} ,{243, 166, 11, 167} ,{40, 167, 174, 0} ,{175, 22, 61, 167} ,{217, 22, 151, 166} ,{1, 170, 111, 1} ,{93, 5, 229, 22} ,{124, 173, 133, 5} ,{104, 169, 134, 5} ,{199, 5, 171, 5} ,{157, 167, 196, 5} ,{176, 166, 218, 5} ,{74, 2, 115, 0} ,{75, 2, 115, 0} ,{216, 166, 4, 171} ,{127, 0, 72, 2} ,{15, 168, 204, 166} ,{32, 25, 161, 166} ,{32, 25, 160, 166} ,{33, 25, 161, 166} ,{33, 25, 160, 166} ,{34, 168, 135, 0} ,{148, 166, 34, 25} ,{140, 173, 240, 2} ,{141, 173, 148, 2} ,{142, 173, 41, 167} ,{3, 171, 161, 166} ,{207, 166, 160, 166} ,{148, 166, 40, 25} ,{125, 167, 209, 166} ,{209, 166, 160, 166} ,{51, 167, 169, 167} ,{202, 166, 193, 167} ,{218, 167, 209, 166} ,{174, 166, 193, 167} ,{11, 0, 123, 0} ,{35, 1, 48, 1} ,{13, 0, 123, 0} ,{149, 0, 29, 10} ,{104, 2, 188, 2} ,{9, 171, 145, 2} ,{36, 169, 239, 2} ,{215, 0, 160, 166} ,{83, 0, 84, 0} ,{79, 25, 131, 16} ,{129, 16, 13, 170} ,{198, 5, 180, 5} ,{81, 25, 140, 16} ,{64, 10, 176, 11} ,{120, 12, 93, 26} ,{118, 2, 101, 26} ,{2, 167, 106, 26} ,{2, 167, 107, 26} ,{191, 2, 16, 4} ,{248, 12, 245, 2} ,{124, 0, 43, 12} ,{136, 10, 202, 0} ,{124, 0, 15, 4} ,{21, 12, 15, 4} ,{44, 169, 123, 0} ,{124, 166, 19, 170} ,{124, 166, 169, 27} ,{124, 166, 81, 5} ,{124, 166, 195, 27} ,{128, 27, 123, 27} ,{3, 167, 62, 168} ,{124, 166, 86, 5} ,{180, 27, 15, 0} ,{124, 166, 9, 28} ,{124, 166, 129, 27} ,{5, 167, 124, 169} ,{128, 14, 48, 169} ,{124, 166, 50, 28} ,{32, 167, 62, 168} ,{15, 0, 163, 1} ,{15, 0, 45, 0} ,{141, 27, 15, 0} ,{216, 27, 128, 14} ,{195, 173, 215, 27} ,{124, 166, 78, 28} ,{128, 14, 62, 168} ,{124, 166, 150, 27} ,{124, 166, 101, 28} ,{136, 10, 94, 2} ,{128, 14, 191, 9} ,{124, 166, 239, 27} ,{124, 166, 72, 8} ,{28, 171, 85, 172} ,{86, 172, 65, 0} ,{205, 169, 128, 14} ,{36, 28, 128, 14} ,{183, 27, 49, 169} ,{128, 14, 65, 0} ,{209, 169, 38, 168} ,{5, 15, 211, 28} ,{64, 10, 22, 15} ,{159, 166, 7, 33} ,{159, 166, 10, 33} ,{159, 166, 60, 33} ,{159, 166, 47, 33} ,{159, 166, 129, 33} ,{82, 33, 83, 33} ,{159, 166, 145, 33} ,{220, 173, 141, 33} ,{159, 166, 172, 33} ,{159, 166, 197, 33} ,{211, 169, 223, 33} ,{211, 169, 228, 33} ,{82, 33, 125, 33} ,{147, 166, 238, 33} ,{227, 173, 239, 33} ,{147, 166, 152, 0} ,{147, 166, 181, 0} ,{147, 166, 100, 0} ,{9, 34, 44, 16} ,{121, 0, 191, 1} ,{78, 167, 14, 34} ,{147, 166, 15, 34} ,{235, 173, 14, 34} ,{147, 166, 11, 1} ,{147, 166, 60, 34} ,{147, 166, 63, 34} ,{212, 169, 70, 34} ,{240, 173, 213, 169} ,{37, 171, 67, 34} ,{242, 173, 75, 34} ,{147, 166, 71, 0} ,{27, 170, 117, 9} ,{181, 12, 63, 2} ,{63, 167, 121, 0} ,{63, 167, 202, 0} ,{63, 167, 124, 0} ,{63, 167, 213, 2} ,{63, 167, 191, 2} ,{63, 167, 182, 10} ,{63, 167, 178, 10} ,{63, 167, 20, 12} ,{63, 167, 21, 12} ,{239, 11, 47, 11} ,{96, 0, 97, 0} ,{100, 0, 131, 171} ,{135, 0, 233, 166} ,{42, 0, 167, 170} ,{115, 172, 150, 0} ,{213, 0, 150, 169} ,{216, 0, 232, 169} ,{217, 0, 27, 168} ,{146, 166, 199, 0} ,{201, 168, 104, 172} ,{131, 0, 215, 0} ,{11, 174, 197, 167} ,{216, 0, 162, 167} ,{220, 0, 197, 167} ,{73, 168, 128, 0} ,{127, 0, 104, 168} ,{59, 173, 186, 0} ,{226, 0, 27, 168} ,{215, 172, 201, 0} ,{225, 166, 85, 0} ,{225, 166, 179, 0} ,{255, 0, 176, 168} ,{225, 166, 252, 0} ,{192, 167, 153, 0} ,{85, 0, 62, 0} ,{164, 166, 179, 0} ,{16, 1, 33, 0} ,{164, 166, 17, 1} ,{11, 0, 13, 1} ,{13, 0, 13, 1} ,{110, 172, 100, 0} ,{164, 166, 30, 1} ,{164, 166, 32, 1} ,{172, 169, 132, 0} ,{41, 1, 222, 0} ,{233, 0, 222, 0} ,{44, 1, 222, 0} ,{35, 1, 81, 0} ,{35, 1, 78, 0} ,{35, 1, 111, 0} ,{152, 169, 101, 0} ,{35, 1, 212, 168} ,{35, 1, 53, 1} ,{35, 1, 178, 168} ,{215, 0, 39, 1} ,{74, 1, 75, 1} ,{76, 1, 6, 0} ,{78, 1, 79, 1} ,{113, 172, 179, 0} ,{57, 1, 58, 1} ,{112, 1, 82, 1} ,{74, 1, 117, 1} ,{80, 1, 28, 170} ,{44, 170, 179, 0} ,{168, 1, 6, 0} ,{133, 1, 72, 170} ,{137, 1, 138, 1} ,{140, 1, 137, 1} ,{58, 174, 53, 0} ,{180, 1, 73, 168} ,{60, 174, 35, 38} ,{182, 1, 244, 0} ,{92, 1, 127, 0} ,{63, 174, 183, 1} ,{185, 1, 6, 0} ,{84, 167, 201, 0} ,{193, 1, 6, 0} ,{194, 1, 127, 0} ,{68, 174, 195, 1} ,{127, 0, 197, 1} ,{200, 1, 144, 167} ,{202, 1, 154, 1} ,{203, 1, 150, 1} ,{204, 1, 25, 169} ,{206, 1, 144, 167} ,{207, 1, 144, 167} ,{208, 1, 65, 0} ,{208, 1, 214, 172} ,{207, 1, 164, 1} ,{210, 1, 177, 169} ,{214, 1, 165, 1} ,{215, 1, 52, 168} ,{232, 166, 147, 0} ,{232, 166, 93, 0} ,{126, 0, 138, 1} ,{133, 1, 45, 170} ,{235, 0, 0, 168} ,{200, 1, 0, 168} ,{243, 0, 50, 171} ,{245, 166, 93, 0} ,{210, 1, 0, 168} ,{216, 1, 0, 168} ,{227, 1, 154, 1} ,{204, 1, 144, 167} ,{120, 167, 15, 2} ,{120, 167, 30, 2} ,{27, 172, 100, 0} ,{94, 167, 115, 2} ,{55, 171, 132, 0} ,{9, 171, 195, 2} ,{146, 2, 222, 0} ,{160, 167, 215, 0} ,{102, 174, 199, 2} ,{6, 170, 207, 166} ,{104, 174, 176, 2} ,{41, 168, 243, 2} ,{104, 2, 3, 3} ,{107, 174, 4, 3} ,{195, 167, 76, 0} ,{237, 168, 11, 3} ,{13, 3, 54, 171} ,{13, 3, 53, 3} ,{13, 3, 83, 1} ,{113, 174, 54, 3} ,{13, 3, 57, 3} ,{13, 3, 59, 3} ,{13, 3, 202, 0} ,{117, 174, 81, 0} ,{13, 3, 63, 3} ,{0, 169, 214, 0} ,{79, 0, 135, 2} ,{219, 169, 55, 171} ,{122, 174, 222, 0} ,{156, 168, 172, 170} ,{152, 172, 222, 0} ,{143, 3, 31, 1} ,{174, 0, 10, 0} ,{123, 3, 146, 3} ,{173, 3, 160, 3} ,{239, 168, 174, 3} ,{201, 166, 50, 1} ,{50, 170, 50, 1} ,{190, 3, 224, 3} ,{133, 174, 42, 1} ,{8, 167, 244, 3} ,{10, 4, 187, 2} ,{10, 4, 151, 166} ,{222, 169, 121, 0} ,{222, 169, 202, 0} ,{222, 169, 124, 0} ,{31, 4, 42, 1} ,{93, 4, 91, 4} ,{95, 4, 91, 4} ,{96, 4, 91, 4} ,{97, 4, 91, 4} ,{205, 166, 126, 4} ,{205, 166, 63, 1} ,{205, 166, 133, 4} ,{205, 166, 146, 4} ,{205, 166, 124, 4} ,{205, 166, 155, 4} ,{205, 166, 163, 4} ,{106, 168, 12, 4} ,{151, 167, 109, 4} ,{151, 167, 129, 4} ,{151, 167, 144, 4} ,{151, 167, 146, 4} ,{151, 167, 155, 4} ,{151, 167, 121, 4} ,{151, 167, 163, 4} ,{138, 169, 170, 4} ,{193, 4, 211, 4} ,{162, 174, 42, 1} ,{193, 4, 163, 4} ,{169, 172, 225, 4} ,{165, 174, 226, 4} ,{235, 4, 137, 3} ,{222, 4, 239, 4} ,{229, 4, 237, 4} ,{219, 4, 1, 5} ,{170, 174, 42, 1} ,{172, 172, 225, 4} ,{172, 174, 253, 4} ,{173, 174, 254, 4} ,{83, 167, 20, 5} ,{175, 174, 21, 5} ,{83, 167, 29, 5} ,{177, 174, 254, 4} ,{83, 167, 32, 5} ,{179, 174, 33, 5} ,{219, 4, 151, 166} ,{181, 174, 179, 0} ,{247, 167, 57, 5} ,{225, 4, 45, 0} ,{219, 4, 62, 5} ,{185, 174, 63, 5} ,{24, 5, 25, 5} ,{187, 174, 0, 5} ,{57, 169, 74, 5} ,{241, 4, 242, 4} ,{86, 5, 223, 4} ,{191, 174, 87, 5} ,{83, 167, 244, 2} ,{58, 169, 230, 4} ,{194, 174, 137, 3} ,{83, 167, 231, 4} ,{89, 5, 90, 5} ,{58, 169, 232, 4} ,{198, 174, 137, 3} ,{81, 171, 6, 0} ,{81, 171, 42, 1} ,{201, 174, 127, 0} ,{202, 174, 189, 2} ,{239, 167, 96, 5} ,{93, 5, 174, 0} ,{205, 174, 50, 2} ,{206, 174, 83, 171} ,{190, 166, 59, 169} ,{239, 167, 59, 169} ,{135, 0, 132, 0} ,{131, 5, 132, 5} ,{215, 167, 133, 5} ,{239, 167, 134, 5} ,{104, 169, 95, 5} ,{182, 166, 215, 5} ,{125, 166, 83, 7} ,{125, 166, 100, 5} ,{20, 8, 3, 0} ,{35, 8, 59, 0} ,{51, 8, 52, 0} ,{54, 8, 58, 0} ,{70, 8, 63, 0} ,{73, 8, 64, 0} ,{76, 8, 46, 0} ,{82, 8, 57, 0} ,{99, 8, 100, 8} ,{45, 168, 122, 8} ,{227, 174, 123, 8} ,{111, 8, 187, 2} ,{229, 174, 125, 8} ,{88, 0, 146, 3} ,{163, 8, 168, 8} ,{142, 167, 65, 167} ,{152, 167, 11, 1} ,{125, 166, 137, 7} ,{235, 174, 24, 7} ,{125, 166, 226, 8} ,{237, 174, 224, 8} ,{117, 5, 128, 5} ,{196, 166, 174, 0} ,{240, 174, 246, 8} ,{196, 166, 42, 1} ,{255, 8, 252, 8} ,{66, 167, 0, 9} ,{255, 8, 3, 9} ,{101, 5, 131, 3} ,{64, 169, 100, 5} ,{76, 0, 128, 3} ,{97, 5, 175, 3} ,{251, 168, 23, 9} ,{59, 170, 47, 9} ,{251, 166, 244, 3} ,{251, 166, 15, 9} ,{207, 172, 77, 9} ,{251, 166, 87, 9} ,{84, 168, 244, 3} ,{84, 168, 15, 9} ,{63, 9, 55, 9} ,{6, 168, 122, 9} ,{127, 0, 132, 9} ,{93, 171, 175, 0} ,{93, 171, 236, 0} ,{184, 170, 236, 0} ,{162, 9, 11, 167} ,{171, 9, 172, 9} ,{175, 9, 140, 3} ,{201, 9, 202, 9} ,{38, 167, 70, 2} ,{95, 171, 217, 9} ,{110, 167, 222, 0} ,{7, 168, 179, 0} ,{15, 175, 179, 8} ,{59, 167, 179, 0} ,{243, 0, 46, 0} ,{179, 0, 49, 0} ,{215, 170, 59, 0} ,{153, 171, 59, 0} ,{197, 166, 54, 1} ,{127, 0, 8, 1} ,{23, 175, 214, 0} ,{114, 0, 82, 0} ,{42, 0, 79, 0} ,{26, 175, 121, 166} ,{253, 169, 216, 172} ,{126, 166, 235, 0} ,{197, 166, 179, 0} ,{237, 0, 51, 0} ,{127, 0, 253, 0} ,{32, 175, 201, 0} ,{197, 166, 160, 0} ,{242, 0, 96, 171} ,{197, 166, 47, 168} ,{197, 166, 169, 0} ,{35, 1, 83, 1} ,{35, 1, 245, 9} ,{35, 1, 246, 9} ,{35, 1, 71, 1} ,{130, 167, 165, 0} ,{35, 1, 82, 173} ,{127, 0, 253, 9} ,{44, 175, 197, 167} ,{253, 9, 214, 0} ,{46, 175, 147, 0} ,{146, 166, 181, 0} ,{127, 0, 195, 170} ,{226, 0, 106, 171} ,{127, 0, 111, 0} ,{51, 175, 70, 169} ,{127, 0, 46, 1} ,{53, 175, 70, 169} ,{48, 1, 106, 171} ,{146, 166, 53, 1} ,{145, 0, 63, 0} ,{47, 1, 197, 167} ,{47, 1, 150, 169} ,{135, 0, 27, 167} ,{146, 166, 136, 0} ,{142, 0, 27, 167} ,{115, 171, 231, 3} ,{115, 171, 66, 0} ,{169, 168, 127, 0} ,{172, 166, 128, 1} ,{99, 8, 229, 37} ,{23, 10, 130, 171} ,{25, 10, 26, 10} ,{69, 175, 130, 171} ,{116, 2, 6, 0} ,{117, 2, 118, 2} ,{72, 175, 6, 0} ,{70, 2, 3, 0} ,{213, 2, 189, 2} ,{70, 10, 71, 10} ,{104, 2, 41, 5} ,{77, 175, 73, 10} ,{22, 0, 75, 10} ,{103, 10, 132, 0} ,{172, 169, 49, 1} ,{35, 1, 105, 10} ,{35, 1, 104, 10} ,{35, 1, 71, 168} ,{14, 168, 81, 0} ,{44, 1, 132, 0} ,{35, 1, 70, 1} ,{213, 166, 79, 0} ,{9, 168, 202, 0} ,{9, 168, 191, 2} ,{72, 167, 184, 10} ,{182, 171, 194, 10} ,{208, 170, 194, 10} ,{31, 7, 198, 10} ,{94, 175, 34, 1} ,{175, 0, 98, 170} ,{103, 10, 136, 10} ,{100, 0, 141, 0} ,{249, 172, 208, 10} ,{174, 168, 250, 172} ,{64, 1, 51, 10} ,{101, 175, 246, 2} ,{9, 11, 219, 166} ,{136, 10, 219, 166} ,{8, 11, 113, 66} ,{80, 5, 94, 66} ,{102, 0, 126, 0} ,{10, 11, 126, 0} ,{246, 2, 143, 171} ,{246, 2, 127, 0} ,{110, 175, 113, 66} ,{56, 11, 57, 11} ,{58, 11, 72, 11} ,{113, 175, 145, 171} ,{222, 170, 113, 66} ,{58, 11, 60, 11} ,{230, 0, 207, 4} ,{81, 170, 146, 168} ,{13, 0, 94, 11} ,{11, 0, 94, 11} ,{1, 3, 246, 2} ,{11, 0, 210, 10} ,{13, 0, 210, 10} ,{215, 166, 223, 170} ,{215, 166, 25, 11} ,{215, 166, 140, 11} ,{215, 166, 141, 11} ,{142, 11, 134, 11} ,{215, 166, 15, 1} ,{215, 166, 14, 1} ,{233, 4, 82, 0} ,{13, 0, 143, 168} ,{73, 3, 71, 1} ,{151, 11, 82, 1} ,{77, 8, 165, 11} ,{135, 175, 166, 11} ,{123, 8, 82, 1} ,{169, 11, 170, 11} ,{166, 11, 82, 1} ,{156, 11, 82, 1} ,{181, 11, 82, 1} ,{78, 2, 210, 10} ,{77, 1, 210, 10} ,{114, 0, 185, 11} ,{206, 168, 102, 5} ,{81, 0, 191, 11} ,{146, 175, 77, 0} ,{88, 168, 81, 0} ,{148, 175, 127, 0} ,{202, 170, 31, 7} ,{202, 170, 30, 7} ,{200, 11, 170, 0} ,{136, 10, 202, 11} ,{200, 11, 202, 0} ,{154, 175, 204, 11} ,{185, 166, 6, 173} ,{185, 166, 232, 11} ,{176, 169, 55, 3} ,{176, 169, 33, 12} ,{163, 171, 55, 3} ,{163, 171, 33, 12} ,{81, 0, 36, 12} ,{17, 3, 36, 12} ,{5, 169, 84, 170} ,{6, 169, 84, 170} ,{5, 169, 85, 170} ,{6, 169, 85, 170} ,{17, 3, 35, 12} ,{81, 0, 35, 12} ,{97, 170, 55, 3} ,{97, 170, 33, 12} ,{178, 10, 86, 170} ,{173, 173, 243, 11} ,{191, 2, 86, 170} ,{124, 0, 86, 170} ,{121, 0, 41, 12} ,{176, 175, 243, 11} ,{77, 1, 39, 1} ,{40, 173, 50, 168} ,{46, 12, 78, 2} ,{87, 170, 20, 3} ,{46, 12, 50, 168} ,{207, 168, 170, 171} ,{89, 168, 63, 1} ,{50, 168, 63, 1} ,{51, 12, 49, 12} ,{81, 0, 52, 12} ,{50, 10, 236, 169} ,{50, 10, 242, 169} ,{81, 0, 49, 12} ,{46, 12, 57, 12} ,{236, 169, 217, 170} ,{89, 168, 62, 12} ,{207, 168, 62, 12} ,{123, 168, 62, 12} ,{50, 168, 62, 12} ,{77, 12, 191, 11} ,{197, 175, 127, 0} ,{179, 0, 38, 9} ,{11, 0, 88, 170} ,{13, 0, 88, 170} ,{20, 1, 246, 2} ,{119, 12, 118, 12} ,{63, 12, 127, 0} ,{204, 175, 64, 12} ,{41, 12, 121, 12} ,{150, 12, 151, 12} ,{87, 12, 151, 12} ,{152, 12, 151, 12} ,{13, 3, 60, 10} ,{161, 12, 162, 12} ,{174, 12, 175, 12} ,{126, 169, 185, 12} ,{126, 169, 184, 12} ,{102, 12, 214, 0} ,{191, 12, 246, 2} ,{124, 0, 203, 12} ,{217, 175, 204, 12} ,{125, 12, 214, 0} ,{205, 10, 231, 12} ,{50, 10, 231, 12} ,{252, 12, 50, 173} ,{11, 0, 253, 12} ,{223, 175, 254, 12} ,{205, 10, 109, 10} ,{3, 13, 11, 0} ,{226, 175, 4, 13} ,{148, 167, 132, 0} ,{34, 13, 35, 13} ,{54, 1, 60, 10} ,{213, 2, 52, 173} ,{204, 170, 54, 13} ,{192, 2, 209, 69} ,{20, 12, 53, 173} ,{234, 175, 62, 13} ,{63, 13, 174, 171} ,{50, 10, 70, 11} ,{235, 3, 99, 8} ,{177, 0, 175, 171} ,{235, 3, 100, 0} ,{235, 3, 2, 0} ,{86, 12, 54, 173} ,{205, 170, 64, 13} ,{62, 10, 249, 9} ,{206, 170, 64, 13} ,{101, 0, 93, 170} ,{235, 3, 144, 168} ,{235, 3, 74, 168} ,{186, 167, 94, 170} ,{11, 10, 151, 0} ,{75, 13, 55, 173} ,{179, 171, 65, 13} ,{214, 0, 163, 65} ,{78, 13, 56, 173} ,{80, 13, 95, 170} ,{77, 1, 180, 171} ,{78, 2, 180, 171} ,{87, 13, 88, 13} ,{113, 7, 91, 13} ,{3, 176, 85, 11} ,{4, 176, 92, 13} ,{197, 10, 97, 168} ,{11, 0, 166, 167} ,{61, 173, 175, 169} ,{51, 10, 195, 1} ,{72, 1, 195, 1} ,{63, 10, 223, 168} ,{63, 10, 224, 168} ,{249, 9, 12, 0} ,{103, 13, 98, 170} ,{13, 0, 221, 166} ,{97, 170, 34, 1} ,{72, 1, 94, 168} ,{64, 1, 142, 168} ,{100, 0, 184, 171} ,{192, 10, 137, 10} ,{20, 176, 185, 171} ,{1, 13, 188, 171} ,{143, 3, 188, 171} ,{173, 169, 189, 171} ,{189, 171, 168, 65} ,{120, 168, 72, 1} ,{26, 176, 190, 171} ,{120, 168, 73, 3} ,{28, 176, 190, 171} ,{39, 12, 105, 10} ,{236, 0, 98, 170} ,{15, 0, 222, 0} ,{64, 1, 192, 10} ,{193, 171, 34, 171} ,{34, 176, 118, 10} ,{14, 1, 202, 10} ,{14, 1, 192, 171} ,{37, 176, 15, 1} ,{192, 171, 202, 10} ,{193, 171, 67, 173} ,{40, 176, 118, 10} ,{15, 1, 202, 10} ,{14, 1, 194, 171} ,{43, 176, 15, 1} ,{194, 171, 202, 10} ,{14, 1, 142, 168} ,{13, 0, 142, 168} ,{14, 1, 242, 167} ,{13, 0, 242, 167} ,{91, 168, 160, 11} ,{90, 168, 160, 11} ,{209, 2, 197, 171} ,{198, 171, 109, 14} ,{9, 169, 39, 1} ,{199, 171, 109, 14} ,{10, 169, 39, 1} ,{18, 11, 72, 0} ,{145, 168, 11, 0} ,{145, 168, 13, 0} ,{114, 14, 72, 0} ,{239, 169, 202, 171} ,{30, 7, 210, 10} ,{240, 169, 202, 171} ,{31, 7, 210, 10} ,{47, 10, 97, 168} ,{11, 0, 39, 12} ,{70, 167, 72, 0} ,{13, 0, 39, 12} ,{75, 167, 72, 0} ,{50, 10, 129, 168} ,{210, 170, 20, 3} ,{210, 170, 53, 10} ,{168, 169, 13, 0} ,{73, 176, 214, 0} ,{168, 169, 203, 171} ,{204, 171, 127, 0} ,{64, 1, 108, 14} ,{1, 13, 230, 0} ,{127, 14, 127, 0} ,{128, 14, 127, 0} ,{127, 0, 213, 168} ,{17, 169, 73, 173} ,{242, 169, 217, 170} ,{65, 13, 81, 168} ,{49, 168, 148, 14} ,{85, 176, 111, 14} ,{49, 168, 71, 0} ,{128, 14, 233, 10} ,{77, 173, 127, 0} ,{159, 14, 160, 14} ,{90, 176, 161, 14} ,{186, 11, 233, 10} ,{11, 0, 159, 11} ,{118, 168, 109, 10} ,{94, 176, 132, 0} ,{212, 168, 52, 2} ,{178, 168, 52, 2} ,{20, 11, 114, 10} ,{148, 14, 215, 0} ,{149, 14, 215, 0} ,{137, 10, 215, 0} ,{90, 173, 127, 0} ,{149, 14, 127, 0} ,{100, 0, 71, 0} ,{236, 0, 209, 171} ,{202, 0, 177, 14} ,{178, 14, 61, 12} ,{146, 167, 100, 14} ,{119, 170, 22, 10} ,{243, 169, 73, 168} ,{244, 169, 73, 168} ,{143, 2, 210, 171} ,{143, 3, 189, 2} ,{127, 0, 33, 38} ,{62, 1, 241, 167} ,{187, 14, 37, 0} ,{116, 176, 188, 14} ,{148, 167, 222, 0} ,{110, 170, 93, 13} ,{127, 0, 39, 0} ,{120, 176, 50, 2} ,{121, 176, 132, 0} ,{170, 169, 219, 166} ,{75, 167, 67, 2} ,{70, 167, 67, 2} ,{214, 0, 216, 171} ,{214, 0, 102, 0} ,{127, 176, 189, 14} ,{14, 169, 212, 171} ,{184, 14, 220, 170} ,{14, 169, 79, 11} ,{139, 14, 212, 171} ,{184, 14, 67, 2} ,{214, 171, 192, 14} ,{214, 171, 193, 14} ,{135, 176, 215, 0} ,{136, 176, 215, 171} ,{36, 0, 241, 167} ,{107, 170, 0, 38} ,{127, 0, 86, 173} ,{127, 0, 89, 169} ,{141, 176, 222, 0} ,{222, 170, 155, 167} ,{143, 176, 233, 166} ,{175, 0, 191, 11} ,{145, 176, 233, 10} ,{11, 169, 96, 13} ,{50, 1, 245, 169} ,{100, 0, 220, 0} ,{110, 170, 132, 0} ,{110, 170, 222, 0} ,{242, 10, 127, 0} ,{143, 2, 191, 14} ,{14, 169, 139, 14} ,{206, 14, 57, 11} ,{147, 168, 194, 10} ,{148, 168, 194, 10} ,{31, 7, 202, 167} ,{30, 7, 202, 167} ,{61, 12, 107, 10} ,{77, 11, 249, 169} ,{17, 3, 209, 14} ,{81, 0, 209, 14} ,{11, 0, 221, 166} ,{51, 10, 94, 168} ,{83, 1, 100, 14} ,{190, 10, 120, 168} ,{167, 176, 103, 14} ,{73, 0, 230, 171} ,{73, 0, 89, 66} ,{73, 0, 77, 66} ,{205, 10, 79, 0} ,{235, 3, 213, 167} ,{43, 167, 242, 14} ,{244, 2, 221, 14} ,{240, 14, 163, 1} ,{79, 0, 241, 14} ,{177, 176, 52, 168} ,{44, 167, 242, 14} ,{244, 14, 45, 0} ,{245, 14, 225, 14} ,{73, 168, 91, 0} ,{11, 1, 52, 0} ,{59, 167, 177, 0} ,{189, 12, 120, 1} ,{6, 15, 122, 1} ,{168, 11, 91, 13} ,{187, 176, 163, 1} ,{97, 173, 18, 15} ,{252, 166, 29, 15} ,{190, 176, 30, 15} ,{111, 167, 173, 1} ,{145, 15, 107, 2} ,{83, 1, 245, 171} ,{146, 15, 107, 2} ,{147, 15, 72, 0} ,{29, 1, 148, 15} ,{197, 176, 72, 0} ,{127, 0, 124, 40} ,{76, 0, 158, 15} ,{200, 176, 72, 0} ,{11, 168, 246, 171} ,{212, 168, 72, 0} ,{178, 168, 72, 0} ,{235, 9, 142, 0} ,{205, 176, 72, 0} ,{149, 0, 3, 0} ,{184, 166, 165, 15} ,{184, 166, 79, 0} ,{184, 166, 171, 15} ,{184, 166, 87, 12} ,{184, 166, 177, 15} ,{184, 166, 178, 15} ,{184, 166, 188, 15} ,{184, 166, 198, 15} ,{184, 166, 187, 10} ,{184, 166, 208, 15} ,{184, 166, 170, 0} ,{184, 166, 212, 15} ,{11, 1, 180, 15} ,{220, 176, 181, 15} ,{185, 15, 246, 2} ,{222, 176, 186, 15} ,{163, 166, 83, 1} ,{163, 166, 50, 1} ,{214, 15, 215, 15} ,{180, 168, 11, 0} ,{227, 176, 63, 1} ,{180, 168, 215, 0} ,{229, 176, 63, 1} ,{114, 0, 214, 0} ,{114, 170, 78, 2} ,{149, 0, 21, 169} ,{234, 170, 127, 0} ,{50, 2, 78, 2} ,{235, 176, 123, 0} ,{35, 1, 12, 170} ,{249, 0, 115, 170} ,{175, 166, 246, 5} ,{133, 167, 189, 16} ,{19, 12, 253, 171} ,{181, 16, 45, 0} ,{182, 16, 45, 0} ,{183, 16, 45, 0} ,{184, 16, 45, 0} ,{185, 16, 45, 0} ,{186, 16, 45, 0} ,{187, 16, 45, 0} ,{188, 16, 45, 0} ,{190, 16, 45, 0} ,{191, 16, 45, 0} ,{192, 16, 45, 0} ,{193, 16, 45, 0} ,{194, 16, 45, 0} ,{46, 11, 253, 171} ,{111, 16, 82, 1} ,{71, 0, 94, 17} ,{71, 0, 126, 17} ,{71, 0, 127, 17} ,{237, 170, 136, 10} ,{71, 0, 39, 8} ,{5, 177, 136, 10} ,{166, 0, 95, 17} ,{136, 10, 57, 0} ,{224, 166, 79, 0} ,{211, 21, 70, 2} ,{59, 22, 244, 0} ,{60, 22, 61, 22} ,{216, 1, 127, 0} ,{13, 177, 62, 22} ,{14, 177, 61, 22} ,{63, 22, 175, 1} ,{65, 22, 59, 0} ,{100, 0, 5, 172} ,{54, 167, 191, 1} ,{207, 1, 25, 169} ,{78, 22, 35, 1} ,{21, 177, 50, 2} ,{164, 166, 224, 3} ,{23, 177, 214, 0} ,{116, 22, 82, 2} ,{116, 22, 164, 2} ,{121, 22, 127, 0} ,{27, 177, 16, 0} ,{122, 22, 115, 173} ,{134, 0, 97, 168} ,{120, 170, 215, 168} ,{90, 0, 56, 0} ,{170, 0, 245, 170} ,{127, 0, 123, 22} ,{127, 0, 124, 22} ,{35, 177, 201, 0} ,{146, 166, 232, 0} ,{125, 22, 252, 9} ,{126, 22, 70, 0} ,{127, 22, 28, 167} ,{127, 22, 122, 170} ,{239, 9, 51, 0} ,{247, 170, 179, 0} ,{60, 167, 42, 1} ,{151, 166, 45, 0} ,{118, 173, 125, 0} ,{246, 3, 3, 0} ,{254, 2, 3, 0} ,{243, 166, 50, 2} ,{40, 167, 42, 1} ,{168, 22, 151, 166} ,{182, 166, 218, 5} ,{46, 167, 45, 5} ,{46, 167, 201, 1} ,{46, 167, 83, 9} ,{46, 167, 87, 9} ,{100, 9, 101, 9} ,{212, 166, 170, 4} ,{235, 5, 53, 0} ,{199, 5, 174, 5} ,{176, 166, 171, 22} ,{176, 166, 28, 23} ,{176, 166, 210, 5} ,{216, 166, 155, 11} ,{28, 172, 66, 2} ,{65, 177, 214, 0} ,{216, 166, 250, 24} ,{227, 2, 2, 168} ,{204, 1, 2, 168} ,{216, 166, 103, 2} ,{216, 166, 154, 10} ,{244, 167, 8, 25} ,{149, 166, 20, 25} ,{149, 166, 21, 25} ,{149, 166, 22, 25} ,{149, 166, 23, 25} ,{149, 166, 24, 25} ,{149, 166, 25, 25} ,{157, 168, 28, 25} ,{149, 166, 142, 0} ,{149, 166, 217, 166} ,{149, 166, 106, 9} ,{149, 166, 34, 25} ,{83, 177, 35, 25} ,{84, 177, 240, 2} ,{85, 177, 46, 172} ,{34, 168, 216, 0} ,{34, 168, 147, 2} ,{34, 168, 142, 0} ,{207, 166, 161, 166} ,{148, 166, 46, 172} ,{34, 168, 234, 2} ,{111, 169, 188, 2} ,{111, 169, 45, 25} ,{111, 169, 46, 25} ,{202, 166, 198, 166} ,{113, 167, 51, 167} ,{148, 166, 4, 171} ,{98, 177, 48, 25} ,{80, 168, 202, 166} ,{113, 167, 174, 166} ,{202, 166, 169, 167} ,{104, 167, 209, 166} ,{125, 167, 51, 167} ,{128, 168, 209, 166} ,{51, 25, 22, 4} ,{106, 177, 52, 25} ,{107, 177, 204, 0} ,{108, 177, 42, 1} ,{109, 177, 161, 166} ,{148, 166, 50, 25} ,{125, 2, 126, 2} ,{35, 1, 155, 0} ,{14, 168, 226, 0} ,{107, 167, 224, 168} ,{43, 25, 161, 166} ,{44, 25, 161, 166} ,{104, 2, 45, 25} ,{104, 2, 46, 25} ,{104, 2, 42, 25} ,{104, 2, 77, 25} ,{244, 167, 58, 172} ,{3, 168, 41, 167} ,{149, 166, 41, 25} ,{244, 167, 36, 25} ,{198, 169, 127, 0} ,{126, 177, 145, 2} ,{198, 169, 58, 172} ,{12, 170, 132, 16} ,{17, 167, 190, 5} ,{88, 26, 166, 173} ,{55, 167, 202, 0} ,{55, 167, 213, 2} ,{55, 167, 182, 10} ,{55, 167, 178, 10} ,{55, 167, 20, 12} ,{95, 26, 167, 173} ,{162, 15, 93, 26} ,{88, 26, 95, 26} ,{142, 16, 93, 26} ,{191, 1, 100, 26} ,{118, 2, 100, 26} ,{191, 1, 101, 26} ,{202, 0, 109, 26} ,{54, 1, 121, 0} ,{145, 177, 11, 1} ,{19, 4, 6, 0} ,{54, 1, 202, 0} ,{91, 26, 6, 0} ,{132, 26, 6, 0} ,{33, 167, 191, 15} ,{121, 0, 149, 0} ,{152, 177, 136, 10} ,{153, 177, 148, 167} ,{5, 0, 27, 0} ,{44, 169, 122, 0} ,{9, 2, 6, 0} ,{124, 166, 139, 27} ,{158, 177, 128, 14} ,{72, 172, 15, 0} ,{160, 177, 150, 27} ,{124, 166, 159, 27} ,{162, 27, 136, 10} ,{163, 177, 162, 27} ,{178, 173, 19, 170} ,{180, 173, 136, 10} ,{166, 177, 81, 5} ,{124, 166, 135, 0} ,{153, 170, 128, 14} ,{19, 168, 62, 168} ,{128, 27, 194, 27} ,{171, 177, 123, 27} ,{15, 0, 253, 1} ,{190, 27, 75, 172} ,{209, 1, 15, 0} ,{15, 0, 134, 3} ,{79, 2, 201, 173} ,{124, 166, 119, 27} ,{124, 166, 227, 27} ,{124, 166, 209, 1} ,{124, 166, 23, 28} ,{181, 177, 136, 10} ,{182, 177, 23, 28} ,{5, 167, 2, 28} ,{239, 12, 142, 27} ,{6, 28, 189, 173} ,{124, 166, 45, 28} ,{124, 166, 193, 27} ,{249, 166, 142, 0} ,{189, 177, 136, 10} ,{190, 177, 249, 166} ,{191, 177, 65, 0} ,{62, 5, 136, 10} ,{193, 177, 159, 168} ,{78, 9, 192, 173} ,{160, 27, 120, 27} ,{32, 167, 29, 28} ,{15, 0, 157, 4} ,{32, 167, 194, 173} ,{199, 177, 2, 28} ,{124, 166, 202, 169} ,{26, 171, 151, 14} ,{122, 27, 123, 27} ,{122, 27, 194, 27} ,{124, 166, 137, 2} ,{124, 166, 21, 23} ,{206, 177, 136, 10} ,{124, 166, 80, 28} ,{154, 170, 136, 10} ,{128, 14, 49, 0} ,{124, 166, 104, 28} ,{246, 27, 15, 0} ,{161, 168, 26, 171} ,{159, 27, 49, 169} ,{123, 169, 239, 12} ,{193, 168, 194, 167} ,{80, 172, 128, 14} ,{232, 168, 45, 0} ,{203, 173, 136, 10} ,{219, 177, 239, 27} ,{124, 166, 128, 28} ,{124, 166, 25, 28} ,{136, 10, 25, 28} ,{81, 172, 128, 14} ,{123, 28, 136, 10} ,{225, 177, 123, 28} ,{204, 173, 136, 10} ,{124, 166, 208, 173} ,{124, 166, 26, 8} ,{208, 169, 62, 168} ,{183, 27, 15, 0} ,{124, 166, 147, 28} ,{161, 27, 120, 27} ,{188, 166, 186, 28} ,{234, 177, 128, 14} ,{235, 177, 247, 27} ,{236, 177, 15, 0} ,{132, 168, 38, 168} ,{90, 172, 195, 28} ,{211, 173, 198, 28} ,{23, 170, 38, 168} ,{206, 28, 158, 170} ,{51, 169, 142, 16} ,{233, 168, 116, 26} ,{38, 168, 45, 0} ,{188, 166, 212, 173} ,{246, 177, 121, 0} ,{93, 172, 230, 0} ,{159, 166, 17, 33} ,{159, 166, 30, 33} ,{159, 166, 24, 33} ,{159, 166, 21, 33} ,{159, 166, 43, 33} ,{159, 166, 69, 33} ,{159, 166, 68, 33} ,{159, 166, 66, 33} ,{159, 166, 97, 33} ,{159, 166, 50, 33} ,{159, 166, 115, 33} ,{159, 166, 124, 33} ,{159, 166, 39, 33} ,{33, 171, 141, 33} ,{221, 173, 146, 33} ,{210, 169, 152, 33} ,{160, 33, 161, 33} ,{162, 168, 162, 33} ,{163, 33, 161, 33} ,{162, 168, 166, 33} ,{167, 33, 161, 33} ,{159, 166, 85, 33} ,{170, 33, 171, 33} ,{162, 168, 168, 33} ,{159, 166, 178, 33} ,{17, 178, 138, 0} ,{25, 170, 17, 15} ,{63, 168, 191, 33} ,{20, 178, 192, 33} ,{63, 168, 189, 33} ,{207, 33, 136, 33} ,{23, 178, 208, 33} ,{209, 33, 210, 33} ,{25, 178, 208, 33} ,{211, 33, 212, 33} ,{27, 178, 208, 33} ,{213, 33, 214, 33} ,{29, 178, 208, 33} ,{159, 166, 215, 33} ,{94, 172, 207, 33} ,{82, 33, 233, 33} ,{159, 166, 127, 33} ,{111, 1, 234, 33} ,{121, 16, 6, 0} ,{147, 166, 14, 10} ,{147, 166, 13, 10} ,{246, 33, 247, 33} ,{229, 173, 97, 172} ,{230, 173, 97, 172} ,{147, 166, 253, 33} ,{42, 178, 254, 33} ,{147, 166, 159, 12} ,{147, 166, 160, 12} ,{147, 166, 145, 0} ,{99, 172, 174, 0} ,{147, 166, 250, 33} ,{147, 166, 4, 34} ,{40, 12, 216, 16} ,{53, 1, 8, 34} ,{53, 169, 14, 1} ,{53, 169, 11, 0} ,{53, 169, 13, 0} ,{53, 169, 15, 1} ,{53, 169, 34, 171} ,{147, 166, 222, 12} ,{147, 166, 73, 13} ,{58, 178, 182, 1} ,{59, 178, 9, 34} ,{60, 178, 15, 1} ,{147, 166, 12, 34} ,{147, 166, 6, 34} ,{147, 166, 157, 12} ,{147, 166, 164, 17} ,{65, 178, 162, 15} ,{147, 166, 7, 34} ,{67, 178, 113, 2} ,{147, 166, 233, 173} ,{69, 178, 90, 17} ,{147, 166, 27, 34} ,{147, 166, 40, 34} ,{72, 178, 41, 34} ,{147, 166, 44, 34} ,{147, 166, 53, 34} ,{147, 166, 54, 34} ,{147, 166, 64, 34} ,{147, 166, 65, 34} ,{147, 166, 62, 34} ,{134, 0, 248, 33} ,{147, 166, 78, 34} ,{126, 169, 115, 34} ,{63, 1, 213, 17} ,{206, 10, 249, 3} ,{14, 167, 154, 0} ,{22, 0, 26, 4} ,{22, 0, 121, 0} ,{22, 0, 202, 0} ,{22, 0, 124, 0} ,{22, 0, 213, 2} ,{22, 0, 191, 2} ,{22, 0, 182, 10} ,{22, 0, 178, 10} ,{22, 0, 20, 12} ,{22, 0, 21, 12} ,{46, 11, 164, 10} ,{146, 166, 157, 0} ,{148, 169, 161, 0} ,{98, 178, 162, 0} ,{146, 166, 176, 0} ,{126, 166, 185, 0} ,{21, 174, 192, 0} ,{225, 166, 202, 0} ,{225, 166, 206, 0} ,{225, 166, 208, 0} ,{225, 166, 209, 0} ,{225, 166, 195, 0} ,{146, 166, 210, 0} ,{10, 174, 169, 0} ,{124, 168, 104, 172} ,{231, 169, 118, 166} ,{126, 166, 227, 0} ,{126, 166, 229, 0} ,{146, 166, 79, 0} ,{114, 178, 232, 0} ,{105, 172, 179, 0} ,{126, 166, 238, 0} ,{126, 166, 239, 0} ,{53, 168, 127, 0} ,{253, 169, 165, 0} ,{42, 171, 157, 0} ,{126, 166, 247, 0} ,{122, 178, 179, 0} ,{225, 166, 248, 0} ,{124, 178, 249, 0} ,{225, 166, 251, 0} ,{59, 167, 152, 0} ,{126, 166, 254, 0} ,{126, 166, 0, 1} ,{126, 166, 1, 1} ,{126, 166, 2, 1} ,{126, 166, 3, 1} ,{126, 166, 4, 1} ,{126, 166, 5, 1} ,{225, 166, 7, 1} ,{24, 174, 24, 175} ,{197, 166, 153, 0} ,{200, 168, 165, 0} ,{164, 166, 177, 0} ,{164, 166, 11, 1} ,{164, 166, 19, 1} ,{164, 166, 20, 1} ,{164, 166, 24, 1} ,{164, 166, 26, 1} ,{164, 166, 100, 0} ,{164, 166, 175, 0} ,{55, 168, 11, 0} ,{35, 1, 177, 0} ,{35, 1, 179, 0} ,{35, 1, 221, 0} ,{35, 1, 245, 169} ,{35, 1, 223, 170} ,{35, 1, 102, 170} ,{35, 1, 43, 1} ,{35, 1, 195, 0} ,{112, 172, 100, 0} ,{156, 178, 45, 1} ,{35, 1, 46, 1} ,{35, 1, 74, 0} ,{35, 1, 226, 0} ,{35, 1, 71, 0} ,{35, 1, 52, 1} ,{35, 1, 17, 169} ,{35, 1, 102, 0} ,{35, 1, 60, 1} ,{35, 1, 65, 1} ,{35, 1, 66, 1} ,{98, 171, 19, 173} ,{35, 1, 149, 0} ,{14, 168, 48, 1} ,{14, 168, 51, 168} ,{54, 1, 77, 1} ,{54, 1, 85, 1} ,{54, 1, 113, 1} ,{114, 172, 111, 0} ,{175, 178, 214, 0} ,{114, 172, 115, 172} ,{54, 1, 179, 0} ,{54, 1, 128, 1} ,{179, 178, 76, 168} ,{54, 167, 187, 1} ,{54, 167, 189, 1} ,{228, 1, 8, 2} ,{128, 170, 10, 2} ,{120, 167, 25, 2} ,{120, 167, 28, 2} ,{120, 167, 33, 2} ,{120, 167, 38, 2} ,{120, 167, 43, 2} ,{189, 178, 44, 2} ,{134, 172, 51, 2} ,{13, 168, 61, 2} ,{192, 178, 62, 2} ,{193, 178, 63, 2} ,{13, 168, 66, 2} ,{195, 178, 67, 2} ,{46, 170, 76, 2} ,{134, 172, 78, 2} ,{134, 172, 77, 1} ,{46, 170, 79, 2} ,{13, 168, 81, 2} ,{27, 172, 103, 2} ,{104, 2, 106, 2} ,{104, 2, 120, 2} ,{104, 2, 122, 2} ,{205, 178, 123, 2} ,{237, 168, 112, 177} ,{237, 168, 126, 2} ,{237, 168, 129, 2} ,{237, 168, 131, 2} ,{210, 178, 132, 2} ,{139, 172, 136, 2} ,{212, 178, 6, 170} ,{213, 178, 127, 0} ,{104, 2, 143, 2} ,{215, 178, 149, 0} ,{244, 167, 236, 166} ,{104, 2, 182, 2} ,{104, 2, 183, 2} ,{104, 2, 85, 0} ,{104, 2, 50, 2} ,{221, 178, 184, 2} ,{135, 172, 85, 0} ,{104, 2, 179, 0} ,{157, 173, 127, 0} ,{104, 2, 190, 2} ,{104, 2, 185, 1} ,{104, 2, 191, 2} ,{149, 166, 110, 0} ,{156, 168, 31, 168} ,{230, 178, 81, 0} ,{37, 169, 120, 174} ,{130, 168, 118, 168} ,{233, 178, 197, 0} ,{191, 168, 160, 167} ,{235, 178, 147, 172} ,{116, 169, 178, 166} ,{237, 178, 222, 2} ,{149, 166, 231, 0} ,{139, 172, 218, 2} ,{139, 172, 225, 2} ,{41, 168, 137, 2} ,{41, 168, 124, 0} ,{104, 2, 163, 168} ,{104, 2, 6, 173} ,{245, 178, 249, 2} ,{246, 178, 213, 1} ,{41, 168, 251, 2} ,{41, 168, 252, 2} ,{249, 178, 253, 2} ,{41, 168, 154, 0} ,{251, 178, 254, 2} ,{252, 178, 246, 2} ,{104, 2, 121, 175} ,{108, 174, 76, 0} ,{108, 174, 22, 1} ,{104, 2, 251, 2} ,{1, 179, 22, 1} ,{2, 179, 204, 0} ,{3, 179, 127, 0} ,{4, 179, 5, 3} ,{110, 174, 12, 3} ,{13, 3, 163, 168} ,{13, 3, 17, 3} ,{140, 172, 54, 171} ,{141, 172, 54, 171} ,{93, 167, 110, 0} ,{93, 167, 29, 3} ,{93, 167, 154, 0} ,{13, 179, 32, 3} ,{93, 167, 36, 3} ,{93, 167, 38, 3} ,{93, 167, 111, 1} ,{93, 167, 179, 0} ,{13, 3, 58, 3} ,{19, 179, 59, 3} ,{13, 3, 95, 0} ,{118, 174, 167, 2} ,{119, 174, 37, 1} ,{222, 168, 160, 167} ,{24, 179, 71, 3} ,{222, 168, 120, 174} ,{222, 168, 170, 170} ,{27, 179, 147, 172} ,{222, 168, 31, 168} ,{29, 179, 209, 2} ,{37, 169, 58, 171} ,{31, 179, 147, 172} ,{196, 169, 48, 170} ,{33, 179, 73, 3} ,{157, 168, 118, 168} ,{191, 168, 152, 172} ,{102, 167, 135, 3} ,{102, 167, 141, 3} ,{63, 171, 144, 3} ,{137, 169, 145, 3} ,{123, 3, 14, 168} ,{123, 3, 22, 1} ,{123, 3, 76, 0} ,{128, 174, 147, 3} ,{49, 170, 170, 3} ,{105, 168, 182, 3} ,{105, 168, 76, 2} ,{77, 168, 85, 0} ,{50, 170, 222, 3} ,{50, 170, 196, 3} ,{50, 179, 170, 0} ,{77, 168, 22, 1} ,{52, 179, 233, 3} ,{201, 166, 196, 3} ,{201, 166, 235, 3} ,{8, 167, 241, 3} ,{135, 174, 146, 167} ,{135, 174, 127, 0} ,{58, 179, 77, 1} ,{175, 170, 121, 0} ,{60, 179, 248, 3} ,{61, 179, 36, 0} ,{62, 179, 249, 3} ,{51, 170, 251, 3} ,{240, 3, 254, 3} ,{64, 171, 0, 4} ,{255, 3, 7, 4} ,{13, 4, 17, 4} ,{13, 4, 18, 4} ,{13, 4, 20, 4} ,{13, 4, 21, 4} ,{13, 4, 22, 4} ,{72, 179, 215, 0} ,{222, 169, 26, 4} ,{23, 4, 42, 1} ,{34, 4, 120, 2} ,{237, 166, 62, 4} ,{160, 172, 68, 4} ,{237, 166, 80, 4} ,{163, 172, 88, 4} ,{42, 168, 99, 4} ,{167, 172, 94, 4} ,{37, 4, 70, 2} ,{205, 166, 107, 4} ,{205, 166, 115, 4} ,{205, 166, 140, 4} ,{205, 166, 142, 4} ,{205, 166, 150, 4} ,{205, 166, 152, 4} ,{205, 166, 158, 4} ,{205, 166, 139, 0} ,{177, 170, 171, 4} ,{105, 4, 231, 174} ,{193, 4, 107, 4} ,{193, 4, 217, 4} ,{219, 4, 220, 4} ,{169, 172, 224, 4} ,{166, 174, 227, 4} ,{98, 179, 228, 4} ,{166, 174, 221, 4} ,{100, 179, 229, 4} ,{172, 172, 58, 169} ,{102, 179, 234, 4} ,{83, 167, 58, 169} ,{104, 179, 229, 4} ,{83, 167, 236, 4} ,{83, 167, 238, 4} ,{83, 167, 240, 4} ,{108, 179, 190, 174} ,{83, 167, 243, 4} ,{83, 167, 245, 4} ,{111, 179, 229, 4} ,{83, 167, 248, 4} ,{113, 179, 249, 4} ,{114, 179, 250, 4} ,{83, 167, 251, 4} ,{116, 179, 252, 4} ,{174, 174, 255, 4} ,{118, 179, 170, 0} ,{171, 174, 2, 5} ,{171, 174, 4, 5} ,{171, 172, 6, 5} ,{122, 179, 7, 5} ,{123, 179, 225, 4} ,{124, 179, 8, 5} ,{171, 172, 225, 4} ,{126, 179, 9, 5} ,{171, 172, 10, 5} ,{75, 171, 12, 5} ,{83, 167, 19, 5} ,{176, 174, 22, 5} ,{176, 174, 26, 5} ,{83, 167, 210, 1} ,{83, 167, 27, 5} ,{134, 179, 225, 4} ,{247, 167, 34, 5} ,{247, 167, 36, 5} ,{57, 167, 76, 171} ,{247, 167, 43, 5} ,{139, 179, 44, 5} ,{140, 179, 45, 5} ,{247, 167, 227, 4} ,{247, 167, 22, 5} ,{143, 179, 48, 5} ,{144, 179, 49, 5} ,{247, 167, 50, 5} ,{247, 167, 54, 5} ,{247, 167, 26, 1} ,{247, 167, 55, 5} ,{149, 179, 27, 5} ,{247, 167, 56, 5} ,{183, 174, 58, 5} ,{183, 174, 60, 5} ,{186, 174, 64, 5} ,{78, 171, 235, 3} ,{78, 171, 67, 5} ,{78, 171, 68, 5} ,{157, 179, 69, 5} ,{78, 171, 70, 5} ,{159, 179, 225, 4} ,{57, 169, 72, 5} ,{57, 169, 76, 5} ,{189, 174, 78, 5} ,{163, 179, 251, 4} ,{57, 169, 234, 4} ,{174, 172, 247, 4} ,{174, 172, 83, 5} ,{174, 172, 24, 5} ,{80, 171, 12, 5} ,{83, 167, 85, 5} ,{170, 179, 190, 174} ,{83, 167, 88, 5} ,{172, 179, 222, 4} ,{193, 174, 197, 174} ,{196, 174, 197, 174} ,{215, 167, 174, 1} ,{190, 166, 83, 171} ,{239, 167, 83, 171} ,{207, 174, 112, 5} ,{239, 167, 126, 5} ,{180, 179, 109, 5} ,{140, 169, 95, 5} ,{182, 179, 100, 5} ,{84, 171, 111, 1} ,{182, 172, 130, 5} ,{190, 166, 211, 174} ,{215, 167, 211, 174} ,{64, 167, 177, 0} ,{164, 166, 136, 5} ,{82, 168, 198, 5} ,{182, 166, 210, 5} ,{182, 166, 222, 5} ,{2, 170, 233, 5} ,{189, 166, 240, 5} ,{157, 167, 192, 5} ,{248, 5, 35, 1} ,{196, 179, 218, 6} ,{248, 5, 220, 6} ,{247, 168, 50, 1} ,{247, 168, 250, 6} ,{109, 168, 153, 171} ,{109, 168, 215, 170} ,{109, 168, 100, 0} ,{203, 179, 50, 1} ,{204, 179, 81, 0} ,{109, 168, 50, 1} ,{125, 166, 110, 7} ,{207, 179, 24, 7} ,{83, 168, 113, 7} ,{125, 166, 136, 7} ,{210, 179, 24, 7} ,{125, 166, 161, 7} ,{125, 166, 184, 7} ,{167, 166, 244, 2} ,{125, 166, 234, 7} ,{135, 168, 111, 1} ,{248, 7, 249, 7} ,{248, 7, 179, 0} ,{206, 166, 22, 8} ,{219, 179, 23, 8} ,{220, 179, 24, 8} ,{206, 166, 25, 8} ,{222, 179, 26, 8} ,{206, 166, 27, 8} ,{224, 179, 28, 8} ,{206, 166, 29, 8} ,{206, 166, 30, 8} ,{206, 166, 31, 8} ,{206, 166, 38, 8} ,{229, 179, 39, 8} ,{230, 179, 40, 8} ,{206, 166, 43, 8} ,{206, 166, 44, 8} ,{233, 179, 45, 8} ,{206, 166, 47, 8} ,{235, 179, 48, 8} ,{206, 166, 49, 8} ,{206, 166, 50, 8} ,{206, 166, 52, 8} ,{239, 179, 53, 8} ,{206, 166, 56, 8} ,{241, 179, 57, 8} ,{242, 179, 58, 8} ,{206, 166, 59, 8} ,{180, 170, 61, 8} ,{62, 169, 61, 8} ,{206, 166, 62, 8} ,{206, 166, 64, 8} ,{248, 179, 65, 8} ,{206, 166, 66, 8} ,{206, 166, 68, 8} ,{206, 166, 69, 8} ,{252, 179, 57, 170} ,{206, 166, 71, 8} ,{254, 179, 72, 8} ,{206, 166, 74, 8} ,{0, 180, 75, 8} ,{206, 166, 77, 8} ,{206, 166, 78, 8} ,{3, 180, 79, 8} ,{206, 166, 80, 8} ,{5, 180, 81, 8} ,{206, 166, 83, 8} ,{7, 180, 84, 8} ,{8, 180, 85, 8} ,{206, 166, 88, 8} ,{10, 180, 89, 8} ,{206, 166, 90, 8} ,{12, 180, 91, 8} ,{206, 166, 98, 8} ,{21, 8, 101, 8} ,{21, 8, 20, 1} ,{21, 8, 102, 8} ,{21, 8, 103, 8} ,{21, 8, 104, 8} ,{106, 8, 42, 1} ,{108, 8, 100, 0} ,{208, 167, 138, 8} ,{208, 167, 145, 8} ,{23, 180, 146, 8} ,{208, 167, 148, 8} ,{208, 167, 150, 8} ,{111, 8, 231, 174} ,{163, 8, 165, 8} ,{163, 8, 166, 8} ,{29, 180, 220, 4} ,{30, 180, 167, 8} ,{163, 8, 187, 2} ,{142, 167, 170, 0} ,{33, 180, 187, 2} ,{152, 167, 178, 8} ,{152, 167, 179, 8} ,{152, 167, 85, 0} ,{152, 167, 124, 0} ,{125, 166, 123, 5} ,{125, 166, 114, 5} ,{109, 168, 79, 0} ,{109, 168, 29, 1} ,{167, 166, 224, 8} ,{167, 166, 206, 0} ,{227, 8, 228, 8} ,{45, 180, 25, 7} ,{90, 171, 233, 8} ,{198, 168, 187, 2} ,{196, 166, 247, 8} ,{4, 9, 151, 166} ,{4, 9, 163, 168} ,{64, 169, 15, 9} ,{52, 180, 16, 9} ,{91, 171, 18, 9} ,{64, 169, 111, 1} ,{64, 169, 22, 1} ,{56, 180, 19, 9} ,{57, 180, 67, 2} ,{251, 168, 170, 4} ,{251, 168, 247, 8} ,{189, 167, 244, 3} ,{189, 167, 28, 9} ,{62, 180, 238, 8} ,{181, 166, 35, 1} ,{64, 180, 30, 9} ,{189, 167, 199, 175} ,{251, 166, 54, 9} ,{251, 166, 57, 9} ,{251, 166, 59, 9} ,{251, 166, 67, 9} ,{251, 166, 201, 1} ,{251, 166, 69, 9} ,{251, 166, 71, 9} ,{251, 166, 73, 9} ,{206, 172, 77, 9} ,{251, 166, 135, 3} ,{251, 166, 83, 9} ,{251, 166, 85, 9} ,{84, 168, 47, 9} ,{84, 168, 94, 9} ,{84, 168, 99, 9} ,{251, 166, 227, 2} ,{251, 166, 103, 9} ,{251, 166, 104, 9} ,{251, 166, 105, 9} ,{251, 166, 106, 9} ,{251, 166, 107, 9} ,{251, 166, 108, 9} ,{65, 169, 133, 9} ,{65, 169, 134, 9} ,{66, 169, 169, 9} ,{162, 9, 42, 1} ,{185, 170, 173, 9} ,{93, 180, 174, 9} ,{185, 170, 176, 9} ,{38, 167, 199, 9} ,{38, 167, 203, 9} ,{12, 175, 100, 0} ,{7, 168, 213, 9} ,{99, 180, 214, 9} ,{95, 171, 216, 9} ,{66, 168, 196, 3} ,{13, 175, 114, 8} ,{103, 180, 218, 9} ,{66, 168, 100, 0} ,{66, 168, 143, 2} ,{66, 168, 217, 9} ,{66, 168, 220, 9} ,{108, 180, 221, 9} ,{66, 168, 222, 9} ,{187, 170, 223, 9} ,{187, 170, 224, 9} ,{188, 170, 228, 9} ,{7, 168, 230, 9} ,{7, 168, 231, 9} ,{188, 170, 232, 9} ,{59, 167, 160, 0} ,{61, 170, 203, 166} ,{61, 170, 236, 9} ,{61, 170, 177, 0} ,{225, 166, 249, 0} ,{121, 180, 237, 9} ,{113, 173, 29, 167} ,{203, 167, 179, 0} ,{197, 166, 235, 9} ,{54, 168, 24, 175} ,{164, 166, 132, 1} ,{126, 166, 240, 9} ,{128, 180, 127, 0} ,{126, 166, 89, 1} ,{126, 166, 91, 1} ,{126, 166, 84, 1} ,{111, 168, 215, 172} ,{133, 180, 214, 0} ,{126, 166, 216, 172} ,{126, 166, 175, 0} ,{136, 180, 203, 166} ,{197, 166, 134, 0} ,{197, 166, 154, 0} ,{197, 166, 157, 0} ,{197, 166, 242, 0} ,{197, 166, 166, 0} ,{197, 166, 167, 0} ,{197, 166, 197, 0} ,{35, 1, 242, 9} ,{35, 1, 243, 9} ,{39, 175, 246, 9} ,{40, 175, 245, 9} ,{35, 1, 247, 9} ,{14, 168, 74, 0} ,{35, 1, 217, 0} ,{35, 1, 57, 8} ,{35, 1, 26, 8} ,{35, 1, 248, 9} ,{130, 167, 249, 9} ,{155, 180, 175, 0} ,{156, 180, 126, 0} ,{130, 167, 134, 0} ,{130, 167, 239, 9} ,{130, 167, 170, 0} ,{152, 169, 68, 1} ,{98, 171, 20, 173} ,{126, 166, 136, 0} ,{230, 167, 127, 0} ,{177, 166, 128, 1} ,{59, 172, 19, 10} ,{19, 10, 21, 10} ,{33, 10, 34, 10} ,{99, 8, 144, 168} ,{99, 8, 74, 168} ,{233, 4, 43, 10} ,{49, 10, 42, 1} ,{50, 10, 51, 10} ,{50, 10, 72, 1} ,{202, 0, 54, 10} ,{175, 180, 55, 10} ,{62, 10, 63, 10} ,{79, 10, 80, 10} ,{237, 8, 86, 10} ,{92, 10, 93, 10} ,{99, 10, 100, 10} ,{234, 169, 109, 10} ,{234, 169, 113, 10} ,{183, 180, 99, 0} ,{35, 1, 73, 0} ,{35, 1, 115, 10} ,{35, 1, 143, 2} ,{35, 1, 117, 10} ,{35, 1, 72, 168} ,{133, 171, 100, 0} ,{121, 10, 216, 170} ,{4, 3, 37, 1} ,{134, 10, 135, 10} ,{193, 180, 174, 173} ,{160, 0, 171, 0} ,{195, 180, 137, 10} ,{139, 10, 140, 10} ,{147, 10, 50, 2} ,{177, 0, 43, 0} ,{38, 9, 43, 0} ,{179, 0, 136, 171} ,{213, 166, 168, 166} ,{177, 0, 79, 0} ,{185, 166, 151, 3} ,{9, 168, 213, 2} ,{9, 168, 178, 10} ,{120, 0, 247, 3} ,{72, 167, 121, 0} ,{208, 180, 118, 2} ,{209, 180, 134, 0} ,{72, 167, 179, 0} ,{72, 167, 182, 10} ,{212, 180, 183, 10} ,{91, 175, 185, 10} ,{72, 167, 233, 173} ,{9, 168, 26, 4} ,{225, 170, 221, 166} ,{147, 168, 197, 10} ,{208, 170, 197, 10} ,{100, 175, 170, 0} ,{72, 168, 63, 1} ,{221, 180, 137, 10} ,{222, 180, 136, 10} ,{51, 168, 136, 10} ,{65, 1, 102, 175} ,{72, 168, 136, 10} ,{51, 10, 97, 175} ,{227, 180, 72, 1} ,{72, 1, 97, 175} ,{229, 180, 51, 10} ,{79, 170, 100, 0} ,{231, 180, 141, 171} ,{72, 1, 205, 10} ,{233, 180, 33, 176} ,{246, 169, 250, 172} ,{73, 3, 102, 175} ,{124, 0, 72, 1} ,{215, 10, 173, 168} ,{102, 0, 223, 10} ,{230, 10, 231, 10} ,{85, 0, 2, 11} ,{7, 11, 201, 170} ,{10, 11, 7, 11} ,{243, 180, 80, 5} ,{16, 11, 249, 3} ,{7, 11, 93, 168} ,{246, 180, 249, 3} ,{18, 11, 222, 170} ,{131, 0, 20, 11} ,{155, 167, 162, 0} ,{253, 172, 80, 5} ,{254, 172, 80, 5} ,{108, 175, 38, 11} ,{108, 175, 39, 11} ,{144, 171, 80, 170} ,{62, 11, 63, 11} ,{179, 0, 226, 0} ,{62, 1, 214, 0} ,{173, 168, 78, 11} ,{173, 168, 80, 11} ,{0, 173, 80, 170} ,{11, 169, 127, 0} ,{6, 181, 71, 173} ,{145, 168, 85, 11} ,{121, 175, 101, 11} ,{14, 1, 68, 1} ,{10, 181, 106, 11} ,{11, 181, 71, 173} ,{53, 1, 20, 11} ,{13, 181, 126, 0} ,{14, 181, 111, 11} ,{110, 11, 216, 170} ,{11, 11, 116, 11} ,{215, 166, 241, 5} ,{215, 166, 131, 11} ,{215, 166, 135, 11} ,{215, 166, 136, 11} ,{215, 166, 51, 10} ,{215, 166, 72, 1} ,{252, 167, 15, 1} ,{215, 166, 65, 1} ,{252, 167, 14, 1} ,{215, 166, 73, 3} ,{215, 166, 70, 11} ,{130, 175, 142, 11} ,{215, 166, 24, 11} ,{215, 166, 11, 0} ,{215, 166, 226, 0} ,{215, 166, 70, 167} ,{215, 166, 221, 0} ,{215, 166, 144, 11} ,{215, 166, 145, 11} ,{252, 167, 102, 0} ,{215, 166, 84, 1} ,{215, 166, 87, 1} ,{215, 166, 89, 1} ,{215, 166, 92, 1} ,{86, 169, 4, 3} ,{46, 11, 210, 171} ,{43, 181, 127, 0} ,{46, 11, 159, 11} ,{90, 0, 213, 167} ,{46, 181, 161, 11} ,{136, 175, 167, 11} ,{136, 175, 168, 11} ,{138, 175, 171, 11} ,{138, 175, 172, 11} ,{173, 11, 174, 11} ,{52, 181, 146, 3} ,{175, 11, 65, 10} ,{190, 2, 176, 11} ,{17, 3, 37, 1} ,{89, 168, 67, 2} ,{57, 181, 123, 168} ,{50, 168, 67, 2} ,{59, 181, 207, 168} ,{30, 7, 92, 168} ,{61, 181, 136, 10} ,{190, 11, 146, 3} ,{152, 175, 136, 10} ,{200, 11, 50, 1} ,{152, 175, 174, 173} ,{114, 11, 131, 0} ,{67, 181, 127, 0} ,{190, 2, 219, 11} ,{185, 166, 17, 3} ,{185, 166, 37, 1} ,{185, 166, 81, 0} ,{185, 166, 41, 5} ,{185, 166, 230, 11} ,{185, 166, 234, 11} ,{75, 181, 235, 11} ,{185, 166, 239, 11} ,{185, 166, 240, 11} ,{162, 171, 242, 11} ,{185, 166, 247, 11} ,{185, 166, 248, 11} ,{185, 166, 249, 11} ,{185, 166, 250, 11} ,{185, 166, 254, 11} ,{185, 166, 255, 11} ,{0, 12, 85, 0} ,{0, 12, 3, 12} ,{0, 12, 5, 12} ,{0, 12, 6, 12} ,{89, 181, 7, 12} ,{0, 12, 9, 12} ,{91, 181, 246, 2} ,{0, 12, 11, 12} ,{93, 181, 119, 10} ,{0, 12, 100, 0} ,{5, 0, 117, 2} ,{5, 0, 22, 12} ,{5, 0, 23, 12} ,{5, 0, 24, 12} ,{5, 0, 25, 12} ,{5, 0, 26, 12} ,{5, 0, 27, 12} ,{5, 0, 28, 12} ,{5, 0, 29, 12} ,{5, 0, 30, 12} ,{5, 0, 31, 12} ,{29, 168, 158, 169} ,{30, 168, 158, 169} ,{29, 168, 156, 169} ,{30, 168, 156, 169} ,{30, 168, 235, 3} ,{111, 181, 20, 173} ,{29, 168, 235, 3} ,{113, 181, 19, 173} ,{157, 169, 14, 1} ,{155, 169, 14, 1} ,{157, 169, 15, 1} ,{155, 169, 15, 1} ,{29, 168, 67, 5} ,{119, 181, 19, 173} ,{30, 168, 67, 5} ,{121, 181, 20, 173} ,{39, 173, 185, 175} ,{39, 173, 184, 175} ,{124, 167, 203, 171} ,{125, 181, 235, 3} ,{124, 167, 10, 168} ,{127, 181, 235, 3} ,{212, 167, 203, 171} ,{129, 181, 67, 5} ,{212, 167, 10, 168} ,{131, 181, 67, 5} ,{182, 175, 214, 0} ,{86, 169, 251, 2} ,{205, 10, 71, 0} ,{135, 181, 48, 12} ,{201, 167, 17, 3} ,{201, 167, 50, 12} ,{201, 167, 184, 175} ,{139, 181, 123, 168} ,{201, 167, 185, 175} ,{141, 181, 207, 168} ,{201, 167, 230, 0} ,{47, 173, 48, 12} ,{213, 167, 77, 1} ,{213, 167, 78, 2} ,{213, 167, 50, 168} ,{213, 167, 11, 11} ,{148, 181, 8, 11} ,{149, 181, 89, 168} ,{201, 167, 89, 168} ,{201, 167, 123, 168} ,{86, 169, 81, 0} ,{153, 181, 60, 12} ,{45, 173, 159, 11} ,{79, 12, 127, 0} ,{156, 181, 80, 12} ,{205, 10, 14, 1} ,{205, 10, 15, 1} ,{89, 12, 214, 0} ,{24, 11, 214, 0} ,{115, 12, 246, 2} ,{205, 10, 117, 12} ,{155, 12, 40, 12} ,{155, 12, 157, 12} ,{158, 12, 159, 12} ,{158, 12, 160, 12} ,{158, 12, 145, 0} ,{237, 169, 164, 12} ,{237, 169, 166, 12} ,{237, 169, 167, 12} ,{237, 169, 168, 12} ,{237, 169, 169, 12} ,{237, 169, 170, 12} ,{237, 169, 171, 12} ,{161, 169, 172, 12} ,{177, 12, 175, 12} ,{225, 175, 178, 166} ,{74, 173, 205, 10} ,{179, 181, 149, 0} ,{74, 173, 202, 0} ,{181, 181, 205, 10} ,{199, 12, 200, 12} ,{22, 1, 206, 12} ,{208, 12, 124, 12} ,{185, 181, 214, 0} ,{125, 12, 120, 170} ,{62, 10, 79, 0} ,{211, 12, 212, 12} ,{50, 10, 222, 12} ,{232, 12, 233, 12} ,{63, 12, 235, 12} ,{237, 12, 238, 12} ,{193, 181, 214, 0} ,{47, 173, 20, 11} ,{245, 12, 127, 0} ,{196, 181, 205, 10} ,{248, 12, 249, 12} ,{255, 12, 0, 13} ,{11, 0, 236, 0} ,{78, 176, 20, 11} ,{201, 181, 225, 175} ,{202, 181, 20, 11} ,{173, 176, 220, 0} ,{204, 181, 214, 0} ,{50, 10, 20, 1} ,{206, 181, 206, 10} ,{12, 13, 233, 12} ,{12, 13, 127, 0} ,{15, 13, 185, 166} ,{79, 12, 206, 10} ,{18, 13, 20, 11} ,{71, 0, 213, 2} ,{25, 13, 127, 0} ,{27, 13, 7, 12} ,{28, 13, 29, 13} ,{205, 10, 18, 13} ,{217, 181, 119, 170} ,{218, 181, 114, 0} ,{219, 181, 50, 10} ,{146, 10, 36, 13} ,{24, 11, 246, 2} ,{213, 2, 52, 13} ,{50, 10, 4, 3} ,{27, 12, 192, 2} ,{182, 10, 55, 13} ,{226, 181, 50, 10} ,{227, 181, 214, 0} ,{20, 12, 55, 13} ,{229, 181, 202, 12} ,{46, 11, 92, 170} ,{231, 181, 204, 170} ,{235, 3, 53, 173} ,{233, 181, 53, 13} ,{58, 13, 59, 13} ,{235, 3, 60, 13} ,{237, 175, 109, 0} ,{237, 181, 205, 10} ,{241, 175, 50, 2} ,{65, 13, 66, 13} ,{240, 181, 168, 5} ,{241, 181, 42, 1} ,{235, 3, 87, 12} ,{243, 181, 2, 0} ,{38, 9, 179, 171} ,{62, 10, 144, 168} ,{62, 10, 74, 168} ,{67, 5, 11, 0} ,{67, 5, 13, 0} ,{62, 10, 177, 171} ,{62, 10, 178, 171} ,{235, 3, 69, 13} ,{70, 13, 53, 2} ,{235, 3, 71, 13} ,{254, 181, 72, 13} ,{250, 175, 74, 13} ,{250, 175, 76, 13} ,{252, 175, 73, 3} ,{252, 175, 65, 1} ,{235, 3, 77, 13} ,{4, 182, 192, 2} ,{46, 11, 235, 3} ,{83, 13, 84, 13} ,{49, 13, 85, 13} ,{235, 3, 49, 13} ,{9, 182, 86, 13} ,{77, 8, 202, 12} ,{124, 0, 89, 13} ,{205, 10, 159, 11} ,{13, 182, 48, 12} ,{14, 182, 79, 0} ,{15, 182, 205, 10} ,{75, 173, 94, 13} ,{39, 11, 94, 13} ,{205, 10, 175, 169} ,{19, 182, 17, 1} ,{7, 176, 100, 0} ,{99, 13, 70, 173} ,{22, 182, 17, 3} ,{174, 168, 214, 0} ,{173, 169, 214, 0} ,{174, 168, 187, 171} ,{173, 169, 187, 171} ,{246, 169, 187, 171} ,{174, 169, 187, 171} ,{23, 176, 1, 13} ,{22, 176, 143, 3} ,{118, 0, 106, 14} ,{32, 182, 30, 176} ,{98, 0, 106, 14} ,{31, 7, 30, 176} ,{35, 182, 221, 166} ,{31, 7, 191, 171} ,{37, 182, 221, 166} ,{123, 168, 107, 14} ,{39, 182, 105, 10} ,{207, 168, 107, 14} ,{41, 182, 104, 10} ,{112, 170, 50, 1} ,{229, 170, 50, 1} ,{50, 1, 112, 170} ,{71, 168, 77, 176} ,{65, 1, 94, 168} ,{47, 182, 33, 176} ,{68, 173, 91, 168} ,{195, 171, 215, 0} ,{69, 173, 90, 168} ,{196, 171, 215, 0} ,{13, 0, 238, 169} ,{53, 182, 251, 2} ,{145, 168, 123, 8} ,{11, 0, 101, 0} ,{100, 0, 66, 176} ,{100, 0, 68, 176} ,{81, 0, 71, 1} ,{231, 170, 117, 14} ,{60, 182, 127, 0} ,{238, 10, 231, 170} ,{143, 168, 166, 0} ,{63, 3, 210, 170} ,{76, 176, 13, 0} ,{76, 176, 11, 0} ,{109, 10, 70, 173} ,{67, 182, 210, 171} ,{68, 182, 214, 0} ,{69, 182, 215, 170} ,{70, 182, 70, 173} ,{213, 167, 121, 14} ,{46, 11, 122, 14} ,{73, 182, 38, 9} ,{14, 1, 77, 176} ,{213, 167, 79, 0} ,{76, 182, 109, 10} ,{213, 167, 71, 173} ,{78, 182, 123, 14} ,{47, 11, 143, 3} ,{80, 182, 230, 0} ,{47, 11, 78, 176} ,{202, 0, 124, 14} ,{217, 170, 126, 14} ,{84, 182, 81, 11} ,{13, 0, 159, 11} ,{86, 182, 215, 0} ,{87, 182, 11, 0} ,{93, 176, 109, 14} ,{11, 168, 109, 14} ,{131, 14, 136, 10} ,{132, 14, 55, 11} ,{123, 10, 133, 14} ,{201, 167, 134, 14} ,{82, 176, 152, 176} ,{29, 11, 63, 1} ,{96, 182, 73, 173} ,{50, 10, 175, 169} ,{76, 173, 15, 0} ,{86, 176, 127, 0} ,{87, 176, 149, 14} ,{87, 176, 148, 14} ,{202, 0, 243, 169} ,{202, 0, 244, 169} ,{150, 14, 202, 0} ,{187, 11, 127, 0} ,{152, 14, 153, 14} ,{186, 11, 73, 168} ,{186, 11, 154, 14} ,{109, 182, 127, 0} ,{89, 176, 253, 2} ,{89, 176, 107, 14} ,{77, 173, 102, 0} ,{113, 182, 162, 14} ,{114, 182, 249, 3} ,{186, 11, 160, 14} ,{116, 182, 126, 0} ,{117, 182, 53, 2} ,{206, 171, 128, 14} ,{61, 12, 93, 176} ,{218, 170, 74, 0} ,{121, 182, 40, 1} ,{218, 170, 50, 10} ,{80, 173, 1, 13} ,{168, 14, 67, 2} ,{125, 182, 20, 1} ,{73, 11, 169, 14} ,{127, 182, 127, 0} ,{128, 182, 30, 7} ,{46, 11, 89, 169} ,{208, 171, 100, 0} ,{145, 168, 174, 14} ,{175, 14, 67, 2} ,{99, 176, 101, 176} ,{100, 176, 101, 176} ,{148, 14, 102, 176} ,{149, 14, 102, 176} ,{236, 0, 103, 176} ,{105, 176, 126, 14} ,{139, 182, 214, 0} ,{244, 169, 179, 14} ,{79, 0, 180, 14} ,{145, 168, 181, 14} ,{145, 168, 183, 14} ,{112, 176, 127, 0} ,{145, 182, 143, 2} ,{111, 170, 127, 0} ,{184, 14, 109, 0} ,{37, 0, 127, 0} ,{119, 168, 215, 0} ,{100, 0, 18, 3} ,{17, 169, 31, 168} ,{152, 182, 215, 0} ,{153, 182, 214, 0} ,{83, 173, 105, 170} ,{84, 173, 105, 170} ,{87, 169, 129, 176} ,{88, 169, 129, 176} ,{87, 169, 213, 171} ,{88, 169, 213, 171} ,{87, 169, 88, 169} ,{88, 169, 87, 169} ,{87, 169, 132, 176} ,{163, 182, 88, 169} ,{88, 169, 132, 176} ,{165, 182, 87, 169} ,{106, 170, 75, 167} ,{106, 170, 70, 167} ,{213, 171, 87, 169} ,{213, 171, 88, 169} ,{85, 173, 75, 167} ,{70, 167, 179, 14} ,{70, 167, 109, 14} ,{17, 169, 127, 0} ,{174, 182, 196, 14} ,{71, 0, 11, 0} ,{71, 0, 13, 0} ,{236, 0, 38, 11} ,{236, 0, 39, 11} ,{39, 11, 109, 14} ,{39, 11, 90, 173} ,{181, 182, 162, 0} ,{182, 182, 34, 12} ,{183, 182, 127, 0} ,{197, 14, 127, 0} ,{185, 182, 198, 14} ,{202, 14, 127, 0} ,{11, 168, 143, 2} ,{11, 168, 100, 0} ,{170, 0, 34, 12} ,{190, 182, 192, 10} ,{191, 182, 11, 0} ,{192, 182, 203, 14} ,{193, 182, 246, 2} ,{194, 182, 100, 0} ,{50, 1, 223, 170} ,{148, 176, 215, 0} ,{173, 168, 204, 14} ,{198, 182, 127, 0} ,{199, 182, 179, 0} ,{200, 182, 205, 14} ,{143, 2, 18, 3} ,{143, 2, 51, 1} ,{61, 12, 224, 170} ,{100, 0, 51, 1} ,{201, 167, 50, 168} ,{201, 167, 207, 168} ,{124, 0, 51, 10} ,{235, 3, 210, 14} ,{209, 182, 127, 0} ,{210, 182, 210, 14} ,{173, 176, 109, 10} ,{235, 3, 46, 11} ,{255, 169, 127, 0} ,{214, 182, 13, 0} ,{126, 166, 246, 14} ,{91, 167, 76, 0} ,{217, 182, 131, 0} ,{251, 169, 12, 15} ,{251, 169, 116, 1} ,{251, 169, 14, 15} ,{251, 169, 15, 15} ,{251, 169, 16, 15} ,{97, 173, 17, 15} ,{244, 171, 173, 11} ,{244, 171, 21, 15} ,{244, 171, 123, 2} ,{119, 1, 23, 15} ,{252, 166, 45, 15} ,{252, 166, 53, 15} ,{252, 166, 63, 15} ,{24, 15, 164, 166} ,{232, 182, 65, 15} ,{111, 167, 142, 15} ,{231, 170, 83, 1} ,{29, 1, 83, 1} ,{83, 1, 147, 15} ,{83, 1, 74, 168} ,{100, 0, 63, 3} ,{163, 166, 15, 1} ,{163, 166, 13, 0} ,{163, 166, 245, 15} ,{163, 166, 251, 15} ,{163, 166, 170, 0} ,{163, 166, 202, 0} ,{163, 166, 126, 4} ,{163, 166, 100, 0} ,{163, 166, 208, 15} ,{225, 176, 88, 13} ,{163, 166, 93, 16} ,{228, 176, 231, 176} ,{230, 176, 231, 176} ,{180, 168, 19, 0} ,{27, 13, 110, 16} ,{104, 16, 231, 4} ,{104, 16, 5, 0} ,{114, 16, 50, 2} ,{104, 16, 118, 16} ,{104, 16, 143, 3} ,{104, 16, 119, 16} ,{169, 5, 99, 8} ,{169, 5, 100, 0} ,{234, 176, 249, 0} ,{7, 183, 139, 10} ,{234, 170, 50, 2} ,{9, 183, 77, 1} ,{218, 166, 37, 1} ,{11, 183, 123, 16} ,{12, 183, 176, 11} ,{153, 14, 125, 16} ,{104, 16, 171, 8} ,{104, 16, 11, 1} ,{16, 183, 126, 16} ,{127, 16, 255, 0} ,{12, 170, 100, 0} ,{131, 16, 255, 0} ,{75, 168, 141, 16} ,{75, 168, 73, 0} ,{75, 168, 121, 0} ,{75, 168, 202, 0} ,{75, 168, 124, 0} ,{75, 168, 213, 2} ,{75, 168, 31, 7} ,{75, 168, 114, 0} ,{75, 168, 30, 7} ,{75, 168, 120, 12} ,{75, 168, 162, 15} ,{75, 168, 142, 16} ,{75, 168, 113, 2} ,{75, 168, 143, 16} ,{75, 168, 209, 11} ,{75, 168, 81, 8} ,{241, 176, 139, 0} ,{231, 166, 117, 2} ,{231, 166, 184, 10} ,{231, 166, 222, 16} ,{231, 166, 223, 16} ,{231, 166, 224, 16} ,{134, 167, 189, 16} ,{134, 167, 188, 16} ,{255, 16, 0, 17} ,{71, 0, 83, 9} ,{71, 0, 138, 17} ,{71, 0, 142, 17} ,{71, 0, 158, 0} ,{71, 0, 134, 0} ,{50, 183, 136, 10} ,{71, 0, 155, 17} ,{71, 0, 197, 0} ,{71, 0, 126, 0} ,{116, 167, 164, 17} ,{122, 168, 167, 17} ,{122, 168, 168, 17} ,{224, 166, 169, 17} ,{58, 183, 81, 11} ,{59, 183, 249, 3} ,{224, 166, 171, 17} ,{224, 166, 176, 17} ,{224, 166, 187, 17} ,{63, 183, 84, 178} ,{224, 166, 191, 17} ,{224, 166, 194, 17} ,{224, 166, 197, 17} ,{122, 168, 199, 17} ,{122, 168, 200, 17} ,{224, 166, 205, 17} ,{70, 183, 246, 2} ,{71, 183, 249, 3} ,{224, 166, 212, 17} ,{224, 166, 214, 17} ,{224, 166, 215, 17} ,{122, 168, 220, 17} ,{122, 168, 221, 17} ,{77, 183, 222, 17} ,{122, 168, 224, 17} ,{122, 168, 228, 17} ,{122, 168, 229, 17} ,{224, 166, 232, 17} ,{224, 166, 234, 17} ,{224, 166, 236, 17} ,{116, 170, 135, 3} ,{149, 168, 56, 22} ,{113, 173, 66, 22} ,{54, 167, 117, 2} ,{54, 167, 118, 2} ,{164, 166, 123, 168} ,{90, 183, 197, 10} ,{242, 170, 14, 1} ,{146, 166, 179, 0} ,{164, 166, 50, 1} ,{247, 170, 85, 0} ,{247, 170, 136, 0} ,{247, 170, 74, 1} ,{29, 169, 118, 173} ,{29, 169, 41, 12} ,{29, 169, 150, 22} ,{29, 169, 151, 22} ,{39, 167, 79, 0} ,{39, 167, 248, 12} ,{39, 167, 153, 22} ,{39, 167, 249, 0} ,{39, 167, 154, 22} ,{243, 166, 155, 22} ,{107, 183, 44, 0} ,{243, 166, 99, 8} ,{243, 166, 100, 0} ,{49, 177, 100, 0} ,{156, 22, 61, 167} ,{77, 168, 233, 3} ,{77, 168, 100, 0} ,{114, 183, 158, 22} ,{190, 3, 160, 22} ,{120, 173, 166, 22} ,{182, 166, 171, 22} ,{182, 166, 172, 22} ,{182, 166, 247, 5} ,{46, 167, 136, 0} ,{53, 177, 183, 22} ,{46, 167, 69, 9} ,{46, 167, 71, 9} ,{46, 167, 141, 3} ,{46, 167, 73, 9} ,{46, 167, 186, 22} ,{46, 167, 187, 22} ,{46, 167, 135, 3} ,{46, 167, 75, 9} ,{46, 167, 78, 9} ,{46, 167, 85, 9} ,{46, 167, 244, 3} ,{250, 170, 189, 22} ,{103, 169, 194, 22} ,{103, 169, 94, 9} ,{103, 169, 197, 22} ,{175, 22, 11, 0} ,{175, 22, 13, 0} ,{175, 22, 177, 0} ,{140, 183, 204, 22} ,{187, 168, 213, 22} ,{187, 168, 215, 22} ,{22, 172, 143, 2} ,{93, 5, 164, 166} ,{145, 183, 133, 5} ,{190, 166, 134, 5} ,{215, 167, 232, 22} ,{148, 183, 109, 5} ,{251, 170, 163, 4} ,{251, 170, 241, 22} ,{99, 167, 6, 23} ,{99, 167, 8, 23} ,{99, 167, 9, 23} ,{99, 167, 83, 9} ,{99, 167, 135, 3} ,{99, 167, 10, 23} ,{99, 167, 11, 23} ,{99, 167, 136, 0} ,{244, 166, 21, 23} ,{244, 166, 23, 23} ,{2, 170, 241, 5} ,{125, 168, 232, 5} ,{176, 166, 24, 23} ,{157, 167, 222, 5} ,{176, 166, 25, 23} ,{157, 167, 26, 23} ,{34, 169, 193, 5} ,{108, 169, 170, 0} ,{169, 183, 166, 0} ,{128, 170, 249, 24} ,{67, 177, 127, 0} ,{13, 168, 251, 24} ,{173, 183, 252, 24} ,{27, 172, 250, 24} ,{175, 183, 250, 24} ,{190, 169, 111, 1} ,{216, 166, 155, 10} ,{216, 166, 156, 10} ,{216, 166, 254, 24} ,{180, 183, 127, 0} ,{216, 166, 255, 24} ,{216, 166, 0, 25} ,{216, 166, 1, 25} ,{216, 166, 2, 25} ,{216, 166, 79, 2} ,{216, 166, 3, 25} ,{216, 166, 4, 25} ,{216, 166, 5, 25} ,{216, 166, 6, 25} ,{216, 166, 7, 25} ,{70, 177, 127, 0} ,{216, 166, 227, 2} ,{216, 166, 204, 1} ,{254, 170, 136, 2} ,{81, 177, 146, 2} ,{143, 173, 235, 166} ,{148, 166, 41, 25} ,{148, 166, 215, 2} ,{111, 169, 131, 170} ,{34, 168, 215, 2} ,{91, 177, 3, 171} ,{114, 169, 3, 171} ,{113, 167, 209, 166} ,{104, 167, 202, 166} ,{104, 167, 174, 166} ,{101, 177, 51, 167} ,{218, 167, 51, 167} ,{104, 167, 51, 167} ,{148, 166, 53, 25} ,{148, 166, 54, 25} ,{148, 166, 55, 25} ,{148, 166, 56, 25} ,{148, 166, 57, 25} ,{148, 166, 58, 25} ,{148, 166, 126, 2} ,{148, 166, 59, 25} ,{148, 166, 112, 177} ,{148, 166, 63, 25} ,{219, 183, 64, 25} ,{220, 183, 65, 25} ,{221, 183, 64, 25} ,{115, 177, 113, 16} ,{35, 1, 72, 25} ,{104, 2, 48, 25} ,{104, 2, 75, 25} ,{226, 183, 127, 0} ,{227, 183, 48, 25} ,{104, 2, 101, 14} ,{149, 166, 146, 2} ,{149, 166, 47, 25} ,{79, 25, 80, 25} ,{232, 183, 67, 5} ,{208, 166, 87, 25} ,{208, 166, 88, 25} ,{208, 166, 89, 25} ,{208, 166, 90, 25} ,{208, 166, 91, 25} ,{208, 166, 92, 25} ,{208, 166, 93, 25} ,{208, 166, 94, 25} ,{208, 166, 95, 25} ,{208, 166, 96, 25} ,{208, 166, 97, 25} ,{208, 166, 98, 25} ,{208, 166, 99, 25} ,{208, 166, 100, 25} ,{208, 166, 101, 25} ,{208, 166, 102, 25} ,{208, 166, 103, 25} ,{208, 166, 104, 25} ,{208, 166, 105, 25} ,{208, 166, 106, 25} ,{208, 166, 107, 25} ,{208, 166, 108, 25} ,{208, 166, 109, 25} ,{208, 166, 110, 25} ,{208, 166, 111, 25} ,{208, 166, 112, 25} ,{208, 166, 113, 25} ,{208, 166, 114, 25} ,{208, 166, 115, 25} ,{208, 166, 116, 25} ,{208, 166, 117, 25} ,{208, 166, 118, 25} ,{208, 166, 119, 25} ,{208, 166, 120, 25} ,{208, 166, 121, 25} ,{208, 166, 122, 25} ,{208, 166, 123, 25} ,{208, 166, 124, 25} ,{208, 166, 125, 25} ,{208, 166, 126, 25} ,{208, 166, 127, 25} ,{208, 166, 128, 25} ,{208, 166, 129, 25} ,{208, 166, 130, 25} ,{208, 166, 131, 25} ,{208, 166, 132, 25} ,{208, 166, 133, 25} ,{208, 166, 134, 25} ,{208, 166, 135, 25} ,{208, 166, 136, 25} ,{208, 166, 137, 25} ,{208, 166, 138, 25} ,{208, 166, 139, 25} ,{208, 166, 140, 25} ,{208, 166, 141, 25} ,{208, 166, 142, 25} ,{208, 166, 143, 25} ,{208, 166, 144, 25} ,{208, 166, 145, 25} ,{208, 166, 146, 25} ,{208, 166, 147, 25} ,{208, 166, 149, 25} ,{208, 166, 151, 25} ,{208, 166, 152, 25} ,{208, 166, 153, 25} ,{208, 166, 155, 25} ,{208, 166, 156, 25} ,{208, 166, 158, 25} ,{208, 166, 160, 25} ,{208, 166, 162, 25} ,{208, 166, 164, 25} ,{208, 166, 166, 25} ,{208, 166, 168, 25} ,{208, 166, 169, 25} ,{183, 166, 185, 25} ,{183, 166, 186, 25} ,{183, 166, 187, 25} ,{183, 166, 188, 25} ,{183, 166, 190, 25} ,{183, 166, 192, 25} ,{183, 166, 194, 25} ,{183, 166, 195, 25} ,{183, 166, 196, 25} ,{60, 184, 197, 25} ,{183, 166, 199, 25} ,{62, 184, 200, 25} ,{183, 166, 201, 25} ,{183, 166, 203, 25} ,{183, 166, 205, 25} ,{183, 166, 206, 25} ,{183, 166, 208, 25} ,{183, 166, 209, 25} ,{183, 166, 211, 25} ,{183, 166, 213, 25} ,{183, 166, 215, 25} ,{138, 170, 217, 25} ,{138, 170, 219, 25} ,{183, 166, 221, 25} ,{183, 166, 223, 25} ,{138, 170, 225, 25} ,{138, 170, 227, 25} ,{183, 166, 229, 25} ,{183, 166, 231, 25} ,{183, 166, 233, 25} ,{183, 166, 237, 25} ,{138, 170, 241, 25} ,{183, 166, 245, 25} ,{183, 166, 248, 25} ,{183, 166, 250, 25} ,{183, 166, 5, 26} ,{183, 166, 8, 26} ,{183, 166, 20, 26} ,{183, 166, 22, 26} ,{183, 166, 24, 26} ,{183, 166, 26, 26} ,{183, 166, 27, 26} ,{183, 166, 29, 26} ,{183, 166, 33, 26} ,{95, 184, 34, 26} ,{183, 166, 36, 26} ,{183, 166, 37, 26} ,{98, 184, 38, 26} ,{183, 166, 40, 26} ,{138, 170, 44, 26} ,{183, 166, 51, 26} ,{55, 167, 124, 0} ,{55, 167, 21, 12} ,{55, 167, 31, 12} ,{55, 167, 220, 16} ,{55, 167, 221, 16} ,{55, 167, 184, 10} ,{55, 167, 222, 16} ,{55, 167, 223, 16} ,{55, 167, 224, 16} ,{55, 167, 89, 26} ,{15, 171, 91, 26} ,{15, 171, 113, 2} ,{88, 26, 94, 26} ,{88, 26, 96, 26} ,{2, 167, 103, 26} ,{117, 184, 121, 0} ,{2, 167, 108, 26} ,{140, 170, 117, 2} ,{2, 167, 111, 26} ,{140, 170, 184, 10} ,{2, 167, 112, 26} ,{2, 167, 113, 26} ,{2, 167, 114, 26} ,{125, 184, 191, 2} ,{2, 167, 115, 26} ,{127, 184, 184, 10} ,{146, 177, 42, 1} ,{148, 177, 116, 26} ,{54, 1, 173, 173} ,{54, 1, 117, 26} ,{54, 1, 118, 26} ,{54, 1, 124, 0} ,{54, 1, 213, 2} ,{54, 1, 191, 2} ,{54, 1, 120, 26} ,{54, 1, 121, 26} ,{54, 1, 122, 26} ,{54, 1, 123, 26} ,{54, 1, 124, 26} ,{54, 1, 125, 26} ,{54, 1, 126, 26} ,{54, 1, 127, 26} ,{54, 1, 128, 26} ,{54, 1, 26, 4} ,{179, 10, 129, 26} ,{179, 10, 130, 26} ,{179, 10, 131, 26} ,{179, 10, 133, 26} ,{179, 10, 134, 26} ,{179, 10, 135, 26} ,{179, 10, 136, 26} ,{179, 10, 137, 26} ,{179, 10, 138, 26} ,{179, 10, 22, 4} ,{179, 10, 139, 26} ,{53, 167, 143, 26} ,{53, 167, 144, 26} ,{53, 167, 153, 26} ,{53, 167, 162, 26} ,{53, 167, 166, 26} ,{53, 167, 171, 26} ,{53, 167, 79, 0} ,{53, 167, 195, 2} ,{53, 167, 35, 1} ,{166, 184, 63, 3} ,{62, 167, 237, 26} ,{62, 167, 241, 26} ,{31, 167, 5, 0} ,{42, 167, 7, 27} ,{118, 167, 5, 0} ,{40, 27, 64, 10} ,{48, 27, 16, 1} ,{49, 27, 187, 2} ,{67, 172, 100, 0} ,{67, 172, 137, 10} ,{120, 169, 52, 27} ,{115, 167, 5, 0} ,{115, 167, 65, 27} ,{61, 12, 202, 0} ,{181, 184, 79, 27} ,{182, 184, 16, 171} ,{183, 184, 131, 0} ,{61, 12, 121, 0} ,{185, 184, 131, 0} ,{186, 184, 174, 173} ,{187, 184, 79, 27} ,{16, 168, 83, 27} ,{189, 184, 84, 27} ,{16, 168, 85, 27} ,{37, 168, 202, 0} ,{37, 168, 213, 2} ,{37, 168, 182, 10} ,{37, 168, 178, 10} ,{37, 168, 20, 12} ,{114, 27, 44, 169} ,{114, 27, 120, 0} ,{198, 184, 202, 0} ,{115, 27, 116, 27} ,{115, 27, 100, 0} ,{159, 177, 194, 173} ,{124, 166, 149, 27} ,{72, 172, 136, 10} ,{72, 172, 124, 0} ,{161, 177, 151, 27} ,{206, 184, 223, 10} ,{207, 184, 15, 0} ,{124, 166, 156, 27} ,{178, 173, 159, 27} ,{210, 184, 164, 177} ,{211, 184, 164, 177} ,{165, 177, 159, 27} ,{213, 184, 239, 12} ,{214, 184, 19, 170} ,{215, 184, 19, 170} ,{124, 166, 167, 27} ,{217, 184, 136, 10} ,{179, 173, 128, 14} ,{180, 173, 239, 12} ,{124, 166, 171, 27} ,{221, 184, 136, 10} ,{222, 167, 62, 168} ,{222, 167, 69, 9} ,{224, 184, 15, 0} ,{222, 167, 178, 27} ,{222, 167, 185, 173} ,{222, 167, 182, 27} ,{228, 184, 15, 0} ,{222, 167, 231, 177} ,{124, 166, 192, 27} ,{231, 184, 193, 27} ,{232, 184, 142, 0} ,{233, 184, 194, 27} ,{181, 173, 136, 10} ,{124, 166, 198, 27} ,{236, 184, 128, 14} ,{168, 177, 128, 14} ,{168, 177, 136, 10} ,{239, 184, 135, 0} ,{152, 170, 62, 168} ,{241, 184, 175, 177} ,{153, 170, 239, 12} ,{153, 170, 151, 27} ,{19, 168, 209, 1} ,{19, 168, 193, 27} ,{124, 166, 69, 9} ,{3, 167, 134, 27} ,{248, 184, 222, 27} ,{249, 184, 15, 0} ,{3, 167, 224, 27} ,{251, 184, 15, 0} ,{3, 167, 137, 10} ,{3, 167, 225, 27} ,{3, 167, 213, 1} ,{3, 167, 203, 1} ,{3, 167, 227, 27} ,{3, 167, 228, 27} ,{2, 185, 15, 0} ,{3, 167, 175, 177} ,{4, 185, 185, 173} ,{3, 167, 230, 27} ,{3, 167, 231, 27} ,{7, 185, 15, 0} ,{3, 167, 233, 27} ,{9, 185, 15, 0} ,{10, 185, 234, 27} ,{3, 167, 236, 27} ,{12, 185, 15, 0} ,{3, 167, 237, 27} ,{14, 185, 15, 0} ,{3, 167, 26, 171} ,{3, 167, 241, 27} ,{17, 185, 15, 0} ,{254, 166, 136, 10} ,{124, 166, 243, 27} ,{20, 185, 239, 12} ,{124, 166, 247, 27} ,{178, 177, 136, 10} ,{178, 177, 239, 12} ,{124, 166, 253, 27} ,{184, 173, 239, 12} ,{179, 177, 136, 10} ,{179, 177, 239, 12} ,{124, 166, 228, 27} ,{22, 171, 62, 168} ,{22, 171, 185, 173} ,{124, 166, 3, 28} ,{32, 185, 239, 12} ,{74, 172, 7, 28} ,{34, 185, 15, 0} ,{186, 173, 198, 173} ,{186, 173, 136, 10} ,{37, 185, 9, 28} ,{124, 166, 13, 28} ,{124, 166, 136, 0} ,{187, 173, 136, 10} ,{41, 185, 129, 27} ,{42, 185, 25, 28} ,{43, 185, 223, 177} ,{44, 185, 241, 27} ,{45, 185, 136, 10} ,{124, 166, 27, 28} ,{76, 172, 239, 12} ,{76, 172, 151, 27} ,{5, 167, 31, 28} ,{50, 185, 15, 0} ,{5, 167, 212, 177} ,{52, 185, 32, 28} ,{184, 177, 15, 0} ,{5, 167, 12, 15} ,{55, 185, 15, 0} ,{5, 167, 208, 173} ,{124, 166, 38, 28} ,{58, 185, 239, 12} ,{124, 166, 43, 28} ,{60, 185, 136, 10} ,{187, 177, 239, 12} ,{188, 177, 136, 10} ,{63, 185, 193, 27} ,{124, 166, 174, 27} ,{65, 185, 136, 10} ,{124, 166, 194, 177} ,{67, 185, 224, 27} ,{68, 185, 194, 177} ,{124, 166, 55, 28} ,{124, 166, 58, 28} ,{124, 166, 60, 28} ,{72, 185, 151, 27} ,{32, 167, 159, 27} ,{32, 167, 9, 28} ,{75, 185, 15, 0} ,{32, 167, 159, 168} ,{32, 167, 58, 28} ,{78, 185, 15, 0} ,{79, 185, 231, 27} ,{200, 177, 15, 0} ,{32, 167, 65, 28} ,{82, 185, 15, 0} ,{32, 167, 207, 1} ,{84, 185, 15, 0} ,{85, 185, 62, 168} ,{86, 185, 44, 5} ,{87, 185, 15, 0} ,{124, 166, 48, 28} ,{124, 166, 204, 177} ,{90, 185, 136, 10} ,{91, 185, 204, 177} ,{205, 177, 128, 14} ,{93, 185, 60, 28} ,{94, 185, 15, 0} ,{124, 166, 180, 27} ,{20, 168, 73, 28} ,{20, 168, 159, 168} ,{20, 168, 74, 28} ,{20, 168, 15, 9} ,{20, 168, 75, 28} ,{20, 168, 76, 28} ,{102, 185, 15, 0} ,{207, 167, 239, 12} ,{207, 167, 151, 27} ,{197, 173, 136, 10} ,{197, 173, 151, 27} ,{207, 177, 21, 23} ,{124, 166, 199, 9} ,{109, 185, 136, 10} ,{124, 166, 87, 28} ,{154, 170, 128, 14} ,{209, 177, 90, 28} ,{113, 185, 198, 173} ,{154, 170, 239, 12} ,{78, 172, 198, 173} ,{78, 172, 128, 14} ,{199, 173, 128, 14} ,{118, 185, 95, 28} ,{199, 173, 151, 27} ,{124, 166, 97, 28} ,{124, 166, 17, 15} ,{211, 177, 128, 14} ,{123, 185, 212, 177} ,{161, 168, 124, 169} ,{213, 177, 126, 0} ,{161, 168, 239, 27} ,{27, 171, 7, 28} ,{128, 185, 136, 10} ,{129, 185, 79, 2} ,{130, 185, 202, 169} ,{215, 177, 79, 2} ,{132, 185, 122, 27} ,{133, 185, 136, 10} ,{216, 177, 169, 27} ,{47, 169, 239, 12} ,{80, 172, 151, 27} ,{4, 168, 136, 10} ,{124, 166, 7, 28} ,{139, 185, 249, 166} ,{220, 177, 226, 177} ,{221, 177, 128, 14} ,{222, 177, 223, 177} ,{143, 185, 225, 27} ,{144, 185, 136, 10} ,{124, 166, 95, 28} ,{146, 185, 136, 10} ,{147, 185, 85, 0} ,{124, 166, 75, 28} ,{124, 166, 136, 28} ,{150, 185, 136, 10} ,{151, 185, 136, 28} ,{124, 166, 44, 5} ,{153, 185, 136, 10} ,{124, 166, 226, 177} ,{155, 185, 17, 15} ,{156, 185, 136, 10} ,{157, 185, 17, 15} ,{158, 185, 142, 28} ,{159, 185, 136, 10} ,{124, 166, 123, 28} ,{124, 166, 207, 1} ,{124, 166, 144, 28} ,{227, 177, 72, 8} ,{124, 166, 146, 28} ,{165, 185, 136, 10} ,{166, 185, 146, 28} ,{167, 185, 147, 28} ,{168, 185, 136, 10} ,{28, 171, 142, 0} ,{205, 173, 83, 9} ,{171, 185, 136, 10} ,{172, 185, 83, 9} ,{205, 173, 148, 28} ,{174, 185, 136, 10} ,{205, 173, 142, 0} ,{176, 185, 179, 0} ,{177, 185, 85, 172} ,{207, 173, 86, 172} ,{179, 185, 142, 0} ,{205, 169, 149, 28} ,{88, 172, 124, 169} ,{124, 166, 153, 28} ,{229, 177, 239, 12} ,{208, 169, 231, 177} ,{224, 167, 232, 168} ,{124, 166, 162, 28} ,{89, 172, 128, 14} ,{124, 166, 169, 28} ,{189, 185, 128, 14} ,{232, 177, 47, 11} ,{124, 166, 174, 28} ,{192, 185, 136, 10} ,{124, 166, 177, 28} ,{124, 166, 181, 28} ,{132, 168, 186, 28} ,{132, 168, 188, 28} ,{132, 168, 190, 28} ,{24, 170, 38, 168} ,{91, 172, 204, 28} ,{194, 168, 210, 28} ,{51, 169, 40, 12} ,{51, 169, 41, 12} ,{93, 172, 212, 173} ,{93, 172, 81, 0} ,{159, 166, 15, 33} ,{159, 166, 18, 33} ,{159, 166, 35, 33} ,{159, 166, 37, 33} ,{159, 166, 38, 33} ,{217, 173, 48, 33} ,{249, 177, 18, 33} ,{159, 166, 61, 33} ,{159, 166, 73, 33} ,{159, 166, 81, 33} ,{14, 178, 86, 33} ,{159, 166, 91, 33} ,{159, 166, 93, 33} ,{159, 166, 104, 33} ,{159, 166, 105, 33} ,{159, 166, 118, 33} ,{159, 166, 120, 33} ,{222, 185, 112, 1} ,{159, 166, 128, 33} ,{31, 171, 134, 33} ,{31, 171, 136, 33} ,{31, 171, 138, 33} ,{31, 171, 139, 33} ,{31, 171, 140, 33} ,{162, 168, 164, 33} ,{159, 166, 169, 33} ,{162, 168, 176, 33} ,{162, 168, 177, 33} ,{16, 178, 166, 33} ,{159, 166, 180, 33} ,{235, 185, 112, 1} ,{236, 185, 58, 33} ,{63, 168, 184, 33} ,{238, 185, 185, 33} ,{63, 168, 188, 33} ,{22, 178, 190, 33} ,{159, 166, 193, 33} ,{242, 185, 189, 33} ,{243, 185, 192, 33} ,{22, 178, 192, 33} ,{63, 168, 136, 0} ,{246, 185, 201, 33} ,{63, 168, 203, 33} ,{159, 166, 229, 33} ,{159, 166, 231, 33} ,{147, 166, 99, 8} ,{147, 166, 73, 0} ,{147, 166, 204, 10} ,{147, 166, 50, 1} ,{147, 166, 11, 0} ,{147, 166, 13, 0} ,{147, 166, 121, 16} ,{147, 166, 208, 2} ,{147, 166, 78, 9} ,{147, 166, 240, 33} ,{147, 166, 241, 33} ,{147, 166, 249, 12} ,{147, 166, 252, 12} ,{147, 166, 11, 10} ,{147, 166, 245, 33} ,{147, 166, 101, 8} ,{10, 186, 95, 26} ,{147, 166, 1, 34} ,{147, 166, 3, 34} ,{147, 166, 5, 34} ,{147, 166, 15, 0} ,{147, 166, 109, 10} ,{147, 166, 183, 11} ,{147, 166, 10, 34} ,{147, 166, 11, 34} ,{78, 167, 13, 34} ,{78, 167, 16, 34} ,{78, 167, 24, 34} ,{78, 167, 25, 34} ,{78, 167, 100, 0} ,{78, 167, 143, 2} ,{73, 178, 133, 4} ,{147, 166, 85, 0} ,{147, 166, 163, 168} ,{147, 166, 107, 0} ,{78, 167, 15, 1} ,{78, 167, 14, 1} ,{78, 167, 51, 34} ,{75, 178, 14, 1} ,{237, 173, 53, 34} ,{147, 166, 127, 0} ,{147, 166, 57, 34} ,{78, 178, 66, 34} ,{78, 178, 67, 34} ,{147, 166, 68, 34} ,{241, 173, 66, 34} ,{40, 186, 75, 34} ,{81, 178, 181, 0} ,{147, 166, 86, 34} ,{147, 166, 88, 34} ,{147, 166, 89, 34} ,{147, 166, 91, 34} ,{54, 1, 117, 9} ,{126, 169, 113, 34} ,{126, 169, 114, 34} ,{199, 166, 19, 0} ,{199, 166, 221, 17} ,{199, 166, 122, 34} ,{199, 166, 123, 34} ,{53, 186, 67, 2} ,{199, 166, 176, 17} ,{199, 166, 139, 34} ,{199, 166, 150, 34} ,{57, 186, 67, 2} ,{199, 166, 152, 34} ,{199, 166, 160, 34} ,{60, 186, 67, 2} ,{199, 166, 236, 0} ,{199, 166, 214, 17} ,{199, 166, 84, 178} ,{63, 167, 188, 10} ,{63, 167, 189, 10} ,{63, 167, 187, 10} ,{63, 167, 186, 10} ,{63, 167, 195, 34} ,{63, 167, 196, 34} ,{63, 167, 205, 10} ,{186, 166, 17, 3} ,{186, 166, 81, 0} ,{71, 0, 127, 16} ,{47, 11, 131, 16} }; ecl-16.1.2/src/c/unicode/ucd_names_str.c000066400000000000000000002531321266352375300200170ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* * Dictionary words. */ #include #include "ucd_names.h" const char *ecl_ucd_names_word[ECL_UCD_FIRST_PAIR] = { "" ,"SPACE" ,"EXCLAMATION_" ,"MARK" ,"QUOTATION_" ,"NUMBER_" ,"SIGN" ,"DOLLAR_" ,"PERCENT_" ,"AMPERSAND" ,"APOSTROPHE" ,"LEFT_" ,"PARENTHESIS" ,"RIGHT_" ,"ASTERISK" ,"PLUS_" ,"COMMA" ,"HYPHEN-" ,"MINUS" ,"FULL_" ,"STOP" ,"SOLIDUS" ,"DIGIT_" ,"ZERO" ,"ONE" ,"TWO" ,"THREE" ,"FOUR" ,"FIVE" ,"SIX" ,"SEVEN" ,"EIGHT" ,"NINE" ,"COLON" ,"SEMICOLON" ,"LESS-" ,"THAN_" ,"EQUALS_" ,"GREATER-" ,"QUESTION_" ,"COMMERCIAL_" ,"AT" ,"LATIN_" ,"CAPITAL_" ,"LETTER_" ,"A" ,"B" ,"C" ,"D" ,"E" ,"F" ,"G" ,"H" ,"I" ,"J" ,"K" ,"L" ,"M" ,"N" ,"O" ,"P" ,"Q" ,"R" ,"S" ,"T" ,"U" ,"V" ,"W" ,"X" ,"Y" ,"Z" ,"SQUARE_" ,"BRACKET" ,"REVERSE_" ,"CIRCUMFLEX_" ,"ACCENT" ,"LOW_" ,"LINE" ,"GRAVE_" ,"SMALL_" ,"CURLY_" ,"VERTICAL_" ,"TILDE" ,"NO-" ,"BREAK_" ,"INVERTED_" ,"CENT_" ,"POUND_" ,"CURRENCY_" ,"YEN_" ,"BROKEN_" ,"BAR" ,"SECTION_" ,"DIAERESIS" ,"COPYRIGHT_" ,"FEMININE_" ,"ORDINAL_" ,"INDICATOR" ,"LEFT-" ,"POINTING_" ,"DOUBLE_" ,"ANGLE_" ,"NOT_" ,"SOFT_" ,"HYPHEN" ,"REGISTERED_" ,"MACRON" ,"DEGREE_" ,"PLUS-" ,"MINUS_" ,"SUPERSCRIPT_" ,"ACUTE_" ,"MICRO_" ,"PILCROW_" ,"MIDDLE_" ,"DOT" ,"CEDILLA" ,"MASCULINE_" ,"RIGHT-" ,"VULGAR_" ,"FRACTION_" ,"ONE_" ,"QUARTER" ,"HALF" ,"THREE_" ,"QUARTERS" ,"A_" ,"WITH_" ,"GRAVE" ,"ACUTE" ,"CIRCUMFLEX" ,"RING_" ,"ABOVE" ,"AE" ,"C_" ,"E_" ,"I_" ,"ETH" ,"N_" ,"O_" ,"MULTIPLICATION_" ,"STROKE" ,"U_" ,"Y_" ,"THORN" ,"SHARP_" ,"DIVISION_" ,"BREVE" ,"OGONEK" ,"DOT_" ,"CARON" ,"D_" ,"G_" ,"H_" ,"DOTLESS_" ,"LIGATURE_" ,"IJ" ,"J_" ,"K_" ,"KRA" ,"L_" ,"PRECEDED_" ,"BY_" ,"ENG" ,"OE" ,"R_" ,"S_" ,"T_" ,"W_" ,"Z_" ,"LONG_" ,"B_" ,"HOOK" ,"TOPBAR" ,"TONE_" ,"OPEN_" ,"AFRICAN_" ,"TURNED_" ,"DELTA" ,"REVERSED_" ,"SCHWA" ,"F_" ,"GAMMA" ,"HV" ,"IOTA" ,"LAMBDA_" ,"LEG" ,"HORN" ,"OI" ,"P_" ,"YR" ,"ESH" ,"ESH_" ,"LOOP" ,"PALATAL_" ,"RETROFLEX_" ,"UPSILON" ,"V_" ,"EZH" ,"EZH_" ,"REVERSED" ,"TAIL" ,"TWO_" ,"GLOTTAL_" ,"STOP_" ,"WYNN" ,"DENTAL_" ,"CLICK" ,"LATERAL_" ,"ALVEOLAR_" ,"DZ_" ,"LJ" ,"NJ" ,"DIAERESIS_" ,"AND_" ,"ABOVE_" ,"AE_" ,"OGONEK_" ,"DZ" ,"HWAIR" ,"STROKE_" ,"COMMA_" ,"BELOW" ,"YOGH" ,"CURL" ,"OU" ,"TILDE_" ,"DB_" ,"DIGRAPH" ,"QP_" ,"DIAGONAL_" ,"SWASH_" ,"Q_" ,"HOOK_" ,"ALPHA" ,"SCHWA_" ,"CLOSED_" ,"SCRIPT_" ,"RAMS_" ,"HENG_" ,"BELT" ,"LEZH" ,"M_" ,"BARRED_" ,"OMEGA" ,"PHI" ,"FISHHOOK" ,"SQUAT_" ,"PHARYNGEAL_" ,"VOICED_" ,"FRICATIVE" ,"STRETCHED_" ,"BILABIAL_" ,"CROSSED-" ,"DEZH_" ,"DIGRAPH_" ,"TS_" ,"TESH_" ,"TC_" ,"FENG_" ,"LS_" ,"LZ_" ,"PERCUSSIVE" ,"BIDENTAL_" ,"FISHHOOK_" ,"MODIFIER_" ,"PRIME" ,"HALF_" ,"RING" ,"ARROWHEAD" ,"UP_" ,"DOWN_" ,"TRIANGULAR_" ,"CENTRED_" ,"TACK" ,"RHOTIC_" ,"CROSS_" ,"EXTRA-" ,"HIGH_" ,"MID_" ,"YIN_" ,"DEPARTING_" ,"YANG_" ,"VOICING" ,"UNASPIRATED" ,"RAISED_" ,"BEGIN_" ,"TONE" ,"END_" ,"SHELF" ,"ARROW" ,"COMBINING_" ,"OVERLINE" ,"LINE_" ,"CANDRABINDU" ,"RIGHT" ,"ACCENT_" ,"TACK_" ,"SIGN_" ,"PALATALIZED_" ,"BRIDGE_" ,"ARCH_" ,"CARON_" ,"BREVE_" ,"MACRON_" ,"OVERLAY" ,"SHORT_" ,"SOLIDUS_" ,"SEAGULL_" ,"X_" ,"GREEK_" ,"PERISPOMENI" ,"KORONIS" ,"DIALYTIKA_" ,"TONOS" ,"YPOGEGRAMMENI" ,"HOMOTHETIC_" ,"ALMOST_" ,"EQUAL_" ,"TO_" ,"ARROW_" ,"UPWARDS_" ,"GRAPHEME_" ,"JOINER" ,"ARROWHEAD_" ,"FERMATA" ,"ASTERISK_" ,"ZIGZAG_" ,"RIGHTWARDS_" ,"HETA" ,"ARCHAIC_" ,"SAMPI" ,"NUMERAL_" ,"LOWER_" ,"PAMPHYLIAN_" ,"DIGAMMA" ,"LUNATE_" ,"SIGMA_" ,"SYMBOL" ,"DOTTED_" ,"ALPHA_" ,"ANO_" ,"TELEIA" ,"EPSILON_" ,"ETA_" ,"IOTA_" ,"OMICRON_" ,"UPSILON_" ,"OMEGA_" ,"BETA" ,"EPSILON" ,"ZETA" ,"ETA" ,"THETA" ,"KAPPA" ,"LAMDA" ,"MU" ,"NU" ,"XI" ,"OMICRON" ,"PI" ,"RHO" ,"SIGMA" ,"TAU" ,"CHI" ,"PSI" ,"DIALYTIKA" ,"FINAL_" ,"KAI_" ,"BETA_" ,"THETA_" ,"PHI_" ,"PI_" ,"KOPPA" ,"STIGMA" ,"COPTIC_" ,"SHEI" ,"FEI" ,"KHEI" ,"HORI" ,"GANGIA" ,"SHIMA" ,"DEI" ,"KAPPA_" ,"RHO_" ,"YOT" ,"SHO" ,"SAN" ,"CYRILLIC_" ,"IE_" ,"IO" ,"DJE" ,"GJE" ,"UKRAINIAN_" ,"IE" ,"DZE" ,"BYELORUSSIAN-" ,"YI" ,"JE" ,"LJE" ,"NJE" ,"TSHE" ,"KJE" ,"DZHE" ,"BE" ,"VE" ,"GHE" ,"DE" ,"ZHE" ,"ZE" ,"KA" ,"EL" ,"EM" ,"EN" ,"PE" ,"ER" ,"ES" ,"TE" ,"EF" ,"HA" ,"TSE" ,"CHE" ,"SHA" ,"SHCHA" ,"HARD_" ,"YERU" ,"YU" ,"YA" ,"YAT" ,"IOTIFIED_" ,"LITTLE_" ,"YUS" ,"BIG_" ,"KSI" ,"FITA" ,"IZHITSA" ,"IZHITSA_" ,"UK" ,"ROUND_" ,"TITLO" ,"OT" ,"THOUSANDS_" ,"PALATALIZATION" ,"DASIA_" ,"PNEUMATA" ,"PSILI_" ,"POKRYTIE" ,"HUNDRED_" ,"MILLIONS_" ,"SEMISOFT_" ,"ER_" ,"TICK" ,"GHE_" ,"UPTURN" ,"ZHE_" ,"DESCENDER" ,"ZE_" ,"KA_" ,"BASHKIR_" ,"EN_" ,"PE_" ,"ABKHASIAN_" ,"ES_" ,"TE_" ,"STRAIGHT_" ,"HA_" ,"CHE_" ,"SHHA" ,"PALOCHKA" ,"EL_" ,"KHAKASSIAN_" ,"EM_" ,"YERU_" ,"KOMI_" ,"ZJE" ,"DZJE" ,"SJE" ,"TJE" ,"LHA" ,"RHA" ,"YAE" ,"QA" ,"WE" ,"ALEUT_" ,"ARMENIAN_" ,"AYB" ,"BEN" ,"GIM" ,"DA" ,"ECH" ,"ZA" ,"EH" ,"ET" ,"TO" ,"INI" ,"LIWN" ,"XEH" ,"CA" ,"KEN" ,"HO" ,"JA" ,"GHAD" ,"CHEH" ,"MEN" ,"NOW" ,"VO" ,"CHA" ,"PEH" ,"JHEH" ,"RA" ,"SEH" ,"VEW" ,"TIWN" ,"REH" ,"CO" ,"YIWN" ,"PIWR" ,"KEH" ,"OH" ,"FEH" ,"EMPHASIS_" ,"ABBREVIATION_" ,"ECH_" ,"HEBREW_" ,"ETNAHTA" ,"SEGOL" ,"SHALSHELET" ,"ZAQEF_" ,"QATAN" ,"GADOL" ,"TIPEHA" ,"REVIA" ,"ZARQA" ,"PASHTA" ,"YETIV" ,"TEVIR" ,"GERESH" ,"GERESH_" ,"MUQDAM" ,"GERSHAYIM" ,"QARNEY_" ,"PARA" ,"TELISHA_" ,"GEDOLA" ,"PAZER" ,"ATNAH_" ,"HAFUKH" ,"MUNAH" ,"MAHAPAKH" ,"MERKHA" ,"MERKHA_" ,"KEFULA" ,"DARGA" ,"QADMA" ,"QETANA" ,"YERAH_" ,"BEN_" ,"YOMO" ,"OLE" ,"ILUY" ,"DEHI" ,"ZINOR" ,"MARK_" ,"MASORA_" ,"CIRCLE" ,"POINT_" ,"SHEVA" ,"HATAF_" ,"PATAH" ,"QAMATS" ,"HIRIQ" ,"TSERE" ,"HOLAM" ,"HOLAM_" ,"HASER_" ,"FOR_" ,"VAV" ,"QUBUTS" ,"DAGESH_" ,"OR_" ,"MAPIQ" ,"METEG" ,"PUNCTUATION_" ,"MAQAF" ,"RAFE" ,"PASEQ" ,"SHIN_" ,"SIN_" ,"SOF_" ,"PASUQ" ,"UPPER_" ,"NUN_" ,"HAFUKHA" ,"QAMATS_" ,"ALEF" ,"BET" ,"GIMEL" ,"DALET" ,"HE" ,"ZAYIN" ,"HET" ,"TET" ,"YOD" ,"KAF" ,"LAMED" ,"MEM" ,"NUN" ,"SAMEKH" ,"AYIN" ,"TSADI" ,"QOF" ,"RESH" ,"SHIN" ,"TAV" ,"YIDDISH_" ,"VAV_" ,"ARABIC_" ,"SANAH" ,"FOOTNOTE_" ,"MARKER" ,"SAFHA" ,"ARABIC-" ,"INDIC_" ,"CUBE_" ,"ROOT" ,"FOURTH_" ,"RAY" ,"PER_" ,"MILLE_" ,"TEN_" ,"THOUSAND_" ,"AFGHANI_" ,"DATE_" ,"SEPARATOR" ,"POETIC_" ,"VERSE_" ,"MISRA" ,"SALLALLAHOU_" ,"ALAYHE_" ,"WASSALLAM" ,"ASSALLAM" ,"RAHMATULLAH_" ,"ALAYHE" ,"RADI_" ,"ALLAHOU_" ,"ANHU" ,"TAKHALLUS" ,"TAH" ,"ALEF_" ,"LAM_" ,"YEH" ,"ZAIN" ,"FATHA" ,"DAMMA" ,"KASRA" ,"TRIPLE_" ,"HAMZA" ,"MADDA_" ,"HAMZA_" ,"WAW_" ,"YEH_" ,"BEH" ,"TEH_" ,"MARBUTA" ,"TEH" ,"THEH" ,"JEEM" ,"HAH" ,"KHAH" ,"DAL" ,"THAL" ,"SEEN" ,"SHEEN" ,"SAD" ,"DAD" ,"ZAH" ,"AIN" ,"GHAIN" ,"KEHEH_" ,"DOTS_" ,"FARSI_" ,"TATWEEL" ,"QAF" ,"LAM" ,"MEEM" ,"NOON" ,"HEH" ,"WAW" ,"MAKSURA" ,"FATHATAN" ,"DAMMATAN" ,"KASRATAN" ,"SHADDA" ,"SUKUN" ,"MADDAH_" ,"SUBSCRIPT_" ,"NOON_" ,"GHUNNA" ,"ZWARAKAY" ,"VOWEL_" ,"FATHA_" ,"DOTS" ,"DECIMAL_" ,"FIVE_" ,"POINTED_" ,"STAR" ,"WASLA" ,"WAVY_" ,"TTEH" ,"TTEHEH" ,"BEEH" ,"DOWNWARDS" ,"TEHEH" ,"BEHEH" ,"HAH_" ,"NYEH" ,"DYEH" ,"TCHEH" ,"TCHEHEH" ,"DDAL" ,"DAL_" ,"BELOW_" ,"DAHAL" ,"DDAHAL" ,"DUL" ,"FOUR_" ,"RREH" ,"REH_" ,"JEH" ,"SEEN_" ,"SAD_" ,"TAH_" ,"AIN_" ,"FEH_" ,"MOVED_" ,"VEH" ,"PEHEH" ,"QAF_" ,"KEHEH" ,"KAF_" ,"NG" ,"GAF" ,"GAF_" ,"NGOEH" ,"GUEH" ,"RNOON" ,"HEH_" ,"DOACHASHMEE" ,"TCHEH_" ,"GOAL" ,"GOAL_" ,"MARBUTA_" ,"KIRGHIZ_" ,"BARREE" ,"BARREE_" ,"MEEM_" ,"INITIAL_" ,"FORM" ,"OF_" ,"AYAH" ,"START_" ,"RUB_" ,"HIZB" ,"ROUNDED_" ,"UPRIGHT_" ,"RECTANGULAR_" ,"HEAD_" ,"ISOLATED_" ,"MADDA" ,"PLACE_" ,"SAJDAH" ,"EMPTY_" ,"CENTRE_" ,"FILLED_" ,"CENTRE" ,"EXTENDED_" ,"SHEEN_" ,"DAD_" ,"GHAIN_" ,"SINDHI_" ,"POSTPOSITION_" ,"SYRIAC_" ,"PARAGRAPH" ,"SUPRALINEAR_" ,"SUBLINEAR_" ,"HORIZONTAL_" ,"COLON_" ,"SKEWED_" ,"LEFT" ,"CONTRACTION" ,"HARKLEAN_" ,"OBELUS" ,"METOBELUS" ,"ASTERISCUS" ,"ALAPH" ,"BETH" ,"GAMAL" ,"GAMAL_" ,"GARSHUNI" ,"DALATH" ,"DALATH_" ,"RISH" ,"HETH" ,"TETH" ,"TETH_" ,"YUDH" ,"YUDH_" ,"KAPH" ,"LAMADH" ,"MIM" ,"SEMKATH" ,"SADHE" ,"QAPH" ,"TAW" ,"PERSIAN_" ,"BHETH" ,"GHAMAL" ,"DHALATH" ,"PTHAHA_" ,"DOTTED" ,"ZQAPHA_" ,"RBASA_" ,"ZLAMA_" ,"HORIZONTAL" ,"ANGULAR" ,"HBASA_" ,"HBASA-" ,"ESASA_" ,"RWAHA" ,"QUSHSHAYA" ,"RUKKAKHA" ,"OBLIQUE_" ,"MUSIC" ,"BARREKH" ,"SOGDIAN_" ,"ZHAIN" ,"KHAPH" ,"FE" ,"BEH_" ,"HORIZONTALLY_" ,"VERTICALLY_" ,"DOWNWARDS_" ,"THAANA_" ,"HAA" ,"SHAVIYANI" ,"NOONU" ,"RAA" ,"BAA" ,"LHAVIYANI" ,"KAAFU" ,"ALIFU" ,"VAAVU" ,"MEEMU" ,"FAAFU" ,"DHAALU" ,"THAA" ,"LAAMU" ,"GAAFU" ,"GNAVIYANI" ,"SEENU" ,"DAVIYANI" ,"ZAVIYANI" ,"TAVIYANI" ,"YAA" ,"PAVIYANI" ,"JAVIYANI" ,"CHAVIYANI" ,"TTAA" ,"HHAA" ,"KHAA" ,"THAALU" ,"ZAA" ,"SHEENU" ,"SAADHU" ,"DAADHU" ,"ZO" ,"AINU" ,"GHAINU" ,"QAAFU" ,"WAAVU" ,"ABAFILI" ,"AABAAFILI" ,"IBIFILI" ,"EEBEEFILI" ,"UBUFILI" ,"OOBOOFILI" ,"EBEFILI" ,"EYBEYFILI" ,"OBOFILI" ,"OABOAFILI" ,"NAA" ,"NKO_" ,"EE" ,"OO" ,"DAGBASINNA" ,"BA" ,"PA" ,"TA" ,"RRA" ,"SA" ,"GBA" ,"FA" ,"LA" ,"NA_" ,"WOLOSO" ,"MA" ,"NYA" ,"NA" ,"WA" ,"NYA_" ,"JONA_" ,"RISING_" ,"DESCENDING_" ,"NASALIZATION_" ,"SYMBOL_" ,"OO_" ,"DENNEN" ,"GBAKURUNEN" ,"LAJANYALAN" ,"SAMARITAN_" ,"ALAF" ,"BIT" ,"GAMAN" ,"DALAT" ,"IY" ,"ZEN" ,"IT" ,"TIT" ,"YUT" ,"KAAF" ,"LABAT" ,"SINGAAT" ,"IN" ,"FI" ,"TSAADIY" ,"QUF" ,"SHAN" ,"TAAF" ,"IN-" ,"OCCLUSION" ,"DAGESH" ,"EPENTHETIC_" ,"OVERLONG_" ,"AA" ,"NEQUDAA" ,"AFSAAQ" ,"ANGED" ,"BAU" ,"ATMAAU" ,"SHIYYAALAA" ,"MELODIC_" ,"QITSA" ,"ZIQAA" ,"ZAEF" ,"TURU" ,"ARKAANU" ,"MASHFAAT" ,"ANNAAU" ,"DEVANAGARI_" ,"ANUSVARA" ,"VISARGA" ,"II" ,"UU" ,"VOCALIC_" ,"CANDRA_" ,"AI" ,"AU" ,"KHA" ,"GA" ,"GHA" ,"NGA" ,"JHA" ,"TTA" ,"TTHA" ,"DDA" ,"DDHA" ,"NNA" ,"THA" ,"DHA" ,"NNNA" ,"PHA" ,"BHA" ,"LLA" ,"LLLA" ,"VA" ,"SSA" ,"NUKTA" ,"AVAGRAHA" ,"RR" ,"VIRAMA" ,"PRISHTHAMATRA_" ,"OM" ,"STRESS_" ,"UDATTA" ,"ANUDATTA" ,"KHHA" ,"GHHA" ,"DDDHA" ,"YYA" ,"LL" ,"DANDA" ,"SPACING_" ,"ZHA" ,"HEAVY_" ,"GGA" ,"JJA" ,"DDDA" ,"BBA" ,"BENGALI_" ,"KHANDA_" ,"AU_" ,"LENGTH_" ,"RA_" ,"DIAGONAL" ,"RUPEE_" ,"NUMERATOR_" ,"LESS_" ,"THE_" ,"DENOMINATOR" ,"DENOMINATOR_" ,"SIXTEEN" ,"ISSHAR" ,"GANDA_" ,"GURMUKHI_" ,"ADAK_" ,"BINDI" ,"UDAAT" ,"TIPPI" ,"ADDAK" ,"IRI" ,"URA" ,"EK_" ,"ONKAR" ,"YAKASH" ,"GUJARATI_" ,"ORIYA_" ,"AI_" ,"TAMIL_" ,"TEN" ,"HUNDRED" ,"THOUSAND" ,"DAY_" ,"MONTH_" ,"YEAR_" ,"DEBIT_" ,"CREDIT_" ,"AS_" ,"TELUGU_" ,"TSA" ,"DZA" ,"ZERO_" ,"ODD_" ,"POWERS_" ,"EVEN_" ,"TUUMU" ,"KANNADA_" ,"JIHVAMULIYA" ,"UPADHMANIYA" ,"MALAYALAM_" ,"CHILLU_" ,"NN" ,"SINHALA_" ,"ANUSVARAYA" ,"VISARGAYA" ,"AYANNA" ,"AAYANNA" ,"AEYANNA" ,"AEEYANNA" ,"IYANNA" ,"IIYANNA" ,"UYANNA" ,"UUYANNA" ,"IRUYANNA" ,"IRUUYANNA" ,"ILUYANNA" ,"ILUUYANNA" ,"EYANNA" ,"EEYANNA" ,"AIYANNA" ,"OYANNA" ,"OOYANNA" ,"AUYANNA" ,"ALPAPRAANA_" ,"KAYANNA" ,"MAHAAPRAANA_" ,"GAYANNA" ,"KANTAJA_" ,"NAASIKYAYA" ,"SANYAKA_" ,"CAYANNA" ,"JAYANNA" ,"TAALUJA_" ,"SANYOOGA_" ,"NAAKSIKYAYA" ,"TTAYANNA" ,"DDAYANNA" ,"MUURDHAJA_" ,"NAYANNA" ,"TAYANNA" ,"DAYANNA" ,"DANTAJA_" ,"PAYANNA" ,"BAYANNA" ,"MAYANNA" ,"AMBA_" ,"YAYANNA" ,"RAYANNA" ,"LAYANNA" ,"VAYANNA" ,"SAYANNA" ,"HAYANNA" ,"FAYANNA" ,"AL-" ,"LAKUNA" ,"AELA-" ,"PILLA" ,"KETTI_" ,"AEDA-" ,"DIGA_" ,"IS-" ,"PAA-" ,"GAETTA-" ,"KOMBUVA" ,"KOMBU_" ,"DEKA" ,"KOMBUVA_" ,"HAA_" ,"GAYANUKITTA" ,"KUNDDALIYA" ,"THAI_" ,"CHARACTER_" ,"KO_" ,"KAI" ,"KHO_" ,"KHAI" ,"KHUAT" ,"KHWAI" ,"KHON" ,"RAKHANG" ,"NGO_" ,"NGU" ,"CHO_" ,"CHAN" ,"CHING" ,"CHANG" ,"SO_" ,"SO" ,"CHOE" ,"YO_" ,"YING" ,"DO_" ,"CHADA" ,"PATAK" ,"THO_" ,"THAN" ,"NANGMONTHO" ,"PHUTHAO" ,"NO_" ,"NEN" ,"DEK" ,"TAO" ,"THUNG" ,"THAHAN" ,"THONG" ,"BO_" ,"BAIMAI" ,"PO_" ,"PLA" ,"PHO_" ,"PHUNG" ,"FO_" ,"PHAN" ,"FAN" ,"SAMPHAO" ,"MO_" ,"YAK" ,"RO_" ,"RUA" ,"RU" ,"LO_" ,"LING" ,"LU" ,"WO_" ,"WAEN" ,"SALA" ,"RUSI" ,"SUA" ,"HO_" ,"HIP" ,"CHULA" ,"ANG" ,"NOKHUK" ,"PAIYANNOI" ,"SARA_" ,"MAI_" ,"HAN-" ,"AKAT" ,"AM" ,"UE" ,"UEE" ,"PHINTHU" ,"BAHT" ,"MAIMUAN" ,"MAIMALAI" ,"LAKKHANGYAO" ,"MAIYAMOK" ,"MAITAIKHU" ,"EK" ,"THO" ,"TRI" ,"CHATTAWA" ,"THANTHAKHAT" ,"NIKHAHIT" ,"YAMAKKAN" ,"FONGMAN" ,"ANGKHANKHU" ,"KHOMUT" ,"LAO_" ,"KO" ,"SUNG" ,"TAM" ,"NGO" ,"NYO" ,"DO" ,"NO" ,"BO" ,"PO" ,"MO" ,"YO" ,"LOOT" ,"WO" ,"ELLIPSIS" ,"KAN" ,"YY" ,"KON" ,"SEMIVOWEL_" ,"LO" ,"EI" ,"AY" ,"TI" ,"CATAWA" ,"CANCELLATION_" ,"NIGGAHITA" ,"TIBETAN_" ,"SYLLABLE_" ,"GTER_" ,"YIG_" ,"MGO_" ,"TRUNCATED_" ,"-" ,"UM_" ,"RNAM_" ,"BCAD_" ,"TSHEG_" ,"MDUN_" ,"CLOSING_" ,"SGAB_" ,"CARET_" ,"PHUR_" ,"SHAD_" ,"SBRUL_" ,"SHAD" ,"BSKUR_" ,"MGO" ,"BKA-" ,"_" ,"SHOG_" ,"INTERSYLLABIC_" ,"TSHEG" ,"DELIMITER_" ,"BSTAR" ,"NYIS_" ,"RIN_" ,"CHEN_" ,"SPUNGS_" ,"RGYA_" ,"GRAM_" ,"DZUD_" ,"RTAGS_" ,"ME_" ,"CAN" ,"LOGOTYPE_" ,"CHAD_" ,"RTAGS" ,"LHAG_" ,"ASTROLOGICAL_" ,"SGRA_" ,"GCAN_" ,"CHAR_" ,"KHYUD_" ,"SDONG_" ,"TSHUGS" ,"RDEL_" ,"DKAR_" ,"GCIG" ,"GNYIS" ,"GSUM" ,"NAG_" ,"NAG" ,"BSDUS_" ,"NGAS_" ,"BZUNG_" ,"NYI_" ,"ZLA" ,"BZHI_" ,"MIG_" ,"SGOR_" ,"TSA_" ,"PHRU" ,"GUG_" ,"GYON" ,"GYAS" ,"ANG_" ,"KHANG_" ,"YAR_" ,"TSHES" ,"MAR_" ,"TSHA" ,"DZHA" ,"KSSA" ,"FIXED-" ,"FORM_" ,"KKA" ,"RJES_" ,"SU_" ,"NGA_" ,"RO" ,"BCAD" ,"ZLA_" ,"NAA_" ,"SNA_" ,"LDAN" ,"HALANTA" ,"PALUTA" ,"LCI_" ,"LCE_" ,"MCHU_" ,"GRU_" ,"CAN_" ,"RGYINGS" ,"MED_" ,"SUBJOINED_" ,"KU_" ,"RU_" ,"KHA_" ,"CANTILLATION_" ,"BEAT" ,"LIGHT_" ,"CANG_" ,"TE-" ,"SBUB_" ,"CHAL" ,"DRIL_" ,"BU" ,"RDO_" ,"RJE" ,"PADMA_" ,"GDAN" ,"RJE_" ,"GRAM" ,"NOR_" ,"BU_" ,"KHYIL" ,"GSUM_" ,"DKAR" ,"BSKA-" ,"GI_" ,"RGYAN" ,"MNYAM_" ,"BRDA_" ,"RNYING_" ,"FACING_" ,"SVASTI_" ,"MYANMAR_" ,"NNYA" ,"SHAN_" ,"MON_" ,"TALL_" ,"ASAT" ,"CONSONANT_" ,"MEDIAL_" ,"GREAT_" ,"SECTION" ,"LOCATIVE" ,"COMPLETED" ,"AFOREMENTIONED" ,"GENITIVE" ,"BBE" ,"SGAW_" ,"KAREN_" ,"EU" ,"HATHI" ,"KE_" ,"PHO" ,"WESTERN_" ,"PWO_" ,"PWA" ,"TONE-" ,"1" ,"2" ,"3" ,"4" ,"5" ,"EASTERN_" ,"YWA" ,"GHWA" ,"GEBA_" ,"KAYAH_" ,"6" ,"COUNCIL_" ,"EMPHATIC_" ,"RUMAI_" ,"PALAUNG_" ,"KHAMTI_" ,"AITON_" ,"EXCLAMATION" ,"GEORGIAN_" ,"AN" ,"BAN" ,"GAN" ,"DON" ,"VIN" ,"TAN" ,"LAS" ,"MAN" ,"NAR" ,"ON" ,"PAR" ,"ZHAR" ,"RAE" ,"TAR" ,"UN" ,"PHAR" ,"KHAR" ,"GHAN" ,"QAR" ,"CHIN" ,"JIL" ,"CIL" ,"CHAR" ,"XAN" ,"JHAN" ,"HAE" ,"HIE" ,"HAR" ,"HOE" ,"YN" ,"ELIFI" ,"PARAGRAPH_" ,"HANGUL_" ,"CHOSEONG_" ,"KIYEOK" ,"SSANGKIYEOK" ,"NIEUN" ,"TIKEUT" ,"SSANGTIKEUT" ,"RIEUL" ,"MIEUM" ,"PIEUP" ,"SSANGPIEUP" ,"SIOS" ,"SSANGSIOS" ,"IEUNG" ,"CIEUC" ,"SSANGCIEUC" ,"CHIEUCH" ,"KHIEUKH" ,"THIEUTH" ,"PHIEUPH" ,"HIEUH" ,"NIEUN-" ,"SSANGNIEUN" ,"TIKEUT-" ,"RIEUL-" ,"SSANGRIEUL" ,"KAPYEOUNRIEUL" ,"MIEUM-" ,"KAPYEOUNMIEUM" ,"PIEUP-" ,"SIOS-" ,"KAPYEOUNPIEUP" ,"KAPYEOUNSSANGPIEUP" ,"CHITUEUMSIOS" ,"CHITUEUMSSANGSIOS" ,"CEONGCHIEUMSIOS" ,"CEONGCHIEUMSSANGSIOS" ,"PANSIOS" ,"IEUNG-" ,"SSANGIEUNG" ,"YESIEUNG" ,"CIEUC-" ,"CHITUEUMCIEUC" ,"CHITUEUMSSANGCIEUC" ,"CEONGCHIEUMCIEUC" ,"CEONGCHIEUMSSANGCIEUC" ,"CHIEUCH-" ,"CHITUEUMCHIEUCH" ,"CEONGCHIEUMCHIEUCH" ,"PHIEUPH-" ,"KAPYEOUNPHIEUPH" ,"SSANGHIEUH" ,"YEORINHIEUH" ,"KIYEOK-" ,"FILLER" ,"JUNGSEONG_" ,"EO" ,"YEO" ,"YE" ,"WAE" ,"WEO" ,"WI" ,"A-" ,"YA-" ,"EO-" ,"YEO-" ,"O-" ,"YO-" ,"U-" ,"YU-" ,"EU-" ,"YI-" ,"I-" ,"ARAEA" ,"ARAEA-" ,"SSANGARAEA" ,"JONGSEONG_" ,"YESIEUNG-" ,"HIEUH-" ,"ETHIOPIC_" ,"HU" ,"HI" ,"HEE" ,"HOA" ,"LI" ,"LAA" ,"LEE" ,"LE" ,"LWA" ,"HHA" ,"HHU" ,"HHI" ,"HHEE" ,"HHE" ,"HHO" ,"HHWA" ,"MI" ,"MAA" ,"MEE" ,"ME" ,"MWA" ,"SZA" ,"SZU" ,"SZI" ,"SZAA" ,"SZEE" ,"SZE" ,"SZO" ,"SZWA" ,"RI" ,"REE" ,"RE" ,"RWA" ,"SU" ,"SI" ,"SAA" ,"SEE" ,"SE" ,"SWA" ,"SHU" ,"SHI" ,"SHAA" ,"SHEE" ,"SHE" ,"SHWA" ,"QU" ,"QI" ,"QAA" ,"QEE" ,"QE" ,"QO" ,"QOA" ,"QWA" ,"QWI" ,"QWAA" ,"QWEE" ,"QWE" ,"QHA" ,"QHU" ,"QHI" ,"QHAA" ,"QHEE" ,"QHE" ,"QHO" ,"QHWA" ,"QHWI" ,"QHWAA" ,"QHWEE" ,"QHWE" ,"BI" ,"BEE" ,"BWA" ,"VU" ,"VI" ,"VAA" ,"VEE" ,"VWA" ,"TU" ,"TAA" ,"TEE" ,"TWA" ,"CU" ,"CI" ,"CAA" ,"CEE" ,"CE" ,"CWA" ,"XA" ,"XU" ,"XAA" ,"XEE" ,"XE" ,"XO" ,"XOA" ,"XWA" ,"XWI" ,"XWAA" ,"XWEE" ,"XWE" ,"NI" ,"NEE" ,"NE" ,"NWA" ,"NYU" ,"NYI" ,"NYAA" ,"NYEE" ,"NYE" ,"NYWA" ,"KU" ,"KI" ,"KAA" ,"KEE" ,"KE" ,"KOA" ,"KWA" ,"KWI" ,"KWAA" ,"KWEE" ,"KWE" ,"KXA" ,"KXU" ,"KXI" ,"KXAA" ,"KXEE" ,"KXE" ,"KXO" ,"KXWA" ,"KXWI" ,"KXWAA" ,"KXWEE" ,"KXWE" ,"WU" ,"WAA" ,"WEE" ,"WOA" ,"ZU" ,"ZI" ,"ZEE" ,"ZWA" ,"ZHU" ,"ZHI" ,"ZHAA" ,"ZHEE" ,"ZHO" ,"ZHWA" ,"YEE" ,"YOA" ,"DU" ,"DI" ,"DAA" ,"DEE" ,"DWA" ,"DDU" ,"DDI" ,"DDAA" ,"DDEE" ,"DDE" ,"DDO" ,"DDWA" ,"JU" ,"JI" ,"JAA" ,"JEE" ,"JO" ,"JWA" ,"GU" ,"GI" ,"GAA" ,"GEE" ,"GE" ,"GO" ,"GOA" ,"GWA" ,"GWI" ,"GWAA" ,"GWEE" ,"GWE" ,"GGU" ,"GGI" ,"GGAA" ,"GGEE" ,"GGE" ,"GGO" ,"GGWAA" ,"THU" ,"THI" ,"THEE" ,"THE" ,"THWA" ,"CHU" ,"CHAA" ,"CHEE" ,"CHO" ,"CHWA" ,"PHU" ,"PHAA" ,"PHEE" ,"PHE" ,"PHWA" ,"TSU" ,"TSI" ,"TSAA" ,"TSEE" ,"TSO" ,"TSWA" ,"TZA" ,"TZU" ,"TZI" ,"TZAA" ,"TZEE" ,"TZE" ,"TZO" ,"TZOA" ,"FU" ,"FAA" ,"FEE" ,"FO" ,"FWA" ,"PU" ,"PAA" ,"PEE" ,"RYA" ,"MYA" ,"FYA" ,"GEMINATION_" ,"WORDSPACE" ,"PREFACE_" ,"TWENTY" ,"THIRTY" ,"FORTY" ,"FIFTY" ,"SIXTY" ,"SEVENTY" ,"EIGHTY" ,"NINETY" ,"SEBATBEIT_" ,"MWI" ,"MWEE" ,"MWE" ,"BWI" ,"BWEE" ,"BWE" ,"FWI" ,"FWEE" ,"FWE" ,"PWI" ,"PWEE" ,"PWE" ,"TONAL_" ,"YIZET" ,"DERET" ,"RIKRIK" ,"DIFAT" ,"KENAT" ,"CHIRET" ,"HIDET" ,"DERET-" ,"KURT" ,"CHEROKEE_" ,"GV" ,"LV" ,"HNA" ,"NAH" ,"NV" ,"QUA" ,"QUE" ,"QUI" ,"QUO" ,"QUU" ,"QUV" ,"SV" ,"DV" ,"DLA" ,"TLA" ,"TLE" ,"TLI" ,"TLO" ,"TLU" ,"TLV" ,"TSV" ,"WV" ,"YV" ,"CANADIAN_" ,"SYLLABICS_" ,"AAI" ,"Y-" ,"CREE_" ,"CARRIER_" ,"WEST-" ,"WII" ,"WOO" ,"NASKAPI_" ,"BOTTOM_" ,"TOP_" ,"STROKES" ,"PLUS" ,"PAAI" ,"PII" ,"POO" ,"PWII" ,"PWO" ,"PWOO" ,"PWAA" ,"TAAI" ,"TII" ,"TOO" ,"TWE" ,"TWI" ,"TWII" ,"TWOO" ,"TWAA" ,"TTE" ,"TTI" ,"TTO" ,"KAAI" ,"KII" ,"KOO" ,"KWII" ,"KWO" ,"KWOO" ,"KW" ,"SOUTH-" ,"SLAVEY_" ,"KIH" ,"KOH" ,"KAH" ,"CAAI" ,"CII" ,"COO" ,"CWE" ,"CWI" ,"CWII" ,"CWO" ,"CWOO" ,"CWAA" ,"SAYISI_" ,"TH" ,"MAAI" ,"MII" ,"MOO" ,"MWII" ,"MWO" ,"MWOO" ,"MWAA" ,"MH" ,"ATHAPASCAN_" ,"NAAI" ,"NII" ,"NOO" ,"NWE" ,"NWAA" ,"NH" ,"LAAI" ,"LII" ,"LOO" ,"LWE" ,"LWI" ,"LWII" ,"LWO" ,"LWOO" ,"LWAA" ,"SAAI" ,"SII" ,"SOO" ,"SWE" ,"SWI" ,"SWII" ,"SWO" ,"SWOO" ,"SWAA" ,"SW" ,"BLACKFOOT_" ,"MOOSE-" ,"SK" ,"SKW" ,"S-" ,"SPWA" ,"STWA" ,"SKWA" ,"SCWA" ,"SHII" ,"SHOO" ,"SHWE" ,"SHWI" ,"SHWII" ,"SHWO" ,"SHWOO" ,"SHWAA" ,"SH" ,"YAAI" ,"YII" ,"YOO" ,"YWE" ,"YWI" ,"YWII" ,"YWO" ,"YWOO" ,"YWAA" ,"BIBLE-" ,"R-" ,"RAAI" ,"RII" ,"ROO" ,"RWAA" ,"FAAI" ,"FII" ,"FOO" ,"FWAA" ,"N-" ,"THII" ,"THOO" ,"THWAA" ,"TTHE" ,"TTHI" ,"TTHO" ,"TTH" ,"TYE" ,"TYI" ,"TYO" ,"TYA" ,"NUNAVIK_" ,"HII" ,"HOO" ,"NUNAVUT_" ,"HK" ,"QAAI" ,"QII" ,"QOO" ,"TLHE" ,"TLHI" ,"TLHO" ,"TLHA" ,"NGAAI" ,"NGI" ,"NGII" ,"NGOO" ,"NGAA" ,"NNG" ,"WOODS-" ,"LHI" ,"LHII" ,"LHO" ,"LHOO" ,"LHAA" ,"LH" ,"TH-" ,"AIVILIK_" ,"GHU" ,"GHO" ,"GHEE" ,"GHI" ,"HWU" ,"HWO" ,"HWE" ,"HWEE" ,"HWI" ,"HWA" ,"TTU" ,"TTEE" ,"KHU" ,"KHO" ,"KHE" ,"KHEE" ,"KHI" ,"KKU" ,"KKO" ,"KKE" ,"KKEE" ,"KKI" ,"KK" ,"JJU" ,"JJO" ,"JJE" ,"JJEE" ,"JJI" ,"DLU" ,"DLO" ,"DLE" ,"DLEE" ,"DLI" ,"LHU" ,"LHE" ,"LHEE" ,"TLHU" ,"TLHEE" ,"TLEE" ,"DZU" ,"DZO" ,"DZEE" ,"DZI" ,"TTSU" ,"TTSO" ,"TTSE" ,"TTSEE" ,"TTSI" ,"TTSA" ,"CHI_" ,"QAI" ,"NGAI" ,"NNGI" ,"NNGII" ,"NNGO" ,"NNGOO" ,"NNGA" ,"NNGAA" ,"THWEE" ,"THWI" ,"THWII" ,"THWO" ,"THWOO" ,"OGHAM_" ,"SPACE_" ,"BEITH" ,"LUIS" ,"FEARN" ,"SAIL" ,"NION" ,"UATH" ,"DAIR" ,"TINNE" ,"COLL" ,"CEIRT" ,"MUIN" ,"GORT" ,"NGEADAL" ,"STRAIF" ,"RUIS" ,"AILM" ,"ONN" ,"UR" ,"EADHADH" ,"IODHADH" ,"EABHADH" ,"OR" ,"UILLEANN" ,"IFIN" ,"EAMHANCHOLL" ,"PEITH" ,"FEATHER_" ,"RUNIC_" ,"FEHU_" ,"FEOH_" ,"FE_" ,"URUZ_" ,"UR_" ,"THURISAZ_" ,"THURS_" ,"ANSUZ_" ,"OS_" ,"AC_" ,"AESC" ,"LONG-" ,"BRANCH-" ,"OSS_" ,"SHORT-" ,"TWIG-" ,"RAIDO_" ,"RAD_" ,"REID_" ,"KAUNA" ,"CEN" ,"KAUN_" ,"GEBO_" ,"GYFU_" ,"GAR" ,"WUNJO_" ,"WYNN_" ,"HAGLAZ_" ,"HAEGL_" ,"HAGALL_" ,"NAUDIZ_" ,"NYD_" ,"NAUD_" ,"DOTTED-" ,"ISAZ_" ,"IS_" ,"ISS_" ,"JERAN_" ,"GER" ,"AR_" ,"IWAZ_" ,"EOH" ,"PERTHO_" ,"PEORTH_" ,"ALGIZ_" ,"EOLHX" ,"SOWILO_" ,"SIGEL_" ,"SOL_" ,"TIWAZ_" ,"TIR_" ,"TYR_" ,"BERKANAN_" ,"BEORC_" ,"BJARKAN_" ,"OPEN-" ,"EHWAZ_" ,"EH_" ,"MANNAZ_" ,"MAN_" ,"MADR_" ,"LAUKAZ_" ,"LAGU_" ,"LOGR_" ,"INGWAZ" ,"ING" ,"DAGAZ_" ,"DAEG_" ,"OTHALAN_" ,"ETHEL_" ,"EAR" ,"IOR" ,"CWEORTH" ,"CALC" ,"CEALC" ,"STAN" ,"ICELANDIC-" ,"SINGLE_" ,"PUNCTUATION" ,"MULTIPLE_" ,"ARLAUG_" ,"TVIMADUR_" ,"BELGTHOR_" ,"TAGALOG_" ,"HANUNOO_" ,"PAMUDPOD" ,"PHILIPPINE_" ,"BUHID_" ,"TAGBANWA_" ,"KHMER_" ,"NNO" ,"SSO" ,"INDEPENDENT_" ,"QAQ" ,"QUK" ,"QUUV" ,"RY" ,"RYY" ,"LY" ,"LYY" ,"QOO_" ,"TYPE_" ,"QAU" ,"INHERENT_" ,"AQ" ,"UA" ,"NIKAHIT" ,"REAHMUK" ,"YUUKALEAPINTU" ,"MUUSIKATOAN" ,"TRIISAP" ,"BANTOC" ,"ROBAT" ,"TOANDAKHIAT" ,"KAKABAT" ,"AHSDA" ,"SAMYOK_" ,"SANNYA" ,"VIRIAM" ,"COENG" ,"BATHAMASAT" ,"KHAN" ,"BARIYOOSAN" ,"CAMNUC_" ,"PII_" ,"KUUH" ,"LEK_" ,"BEYYAL" ,"PHNAEK_" ,"MUAN" ,"KOOMUUT" ,"RIEL" ,"AVAKRAHASANYA" ,"ATTHACAN" ,"ATTAK_" ,"SON" ,"MUOY" ,"BEI" ,"BUON" ,"PRAM" ,"PRAM-" ,"MONGOLIAN_" ,"BIRGA" ,"TODO_" ,"SIBE_" ,"BOUNDARY_" ,"MANCHU_" ,"NIRUGU" ,"FREE_" ,"VARIATION_" ,"SELECTOR_" ,"ZRA" ,"JIA" ,"NIA" ,"ALI_" ,"GALI_" ,"ANUSVARA_" ,"VISARGA_" ,"DAMARU" ,"UBADAMA" ,"BALUDA" ,"AH" ,"CYA" ,"DAGALGA" ,"OY" ,"AAY" ,"WAY" ,"POY" ,"PAY" ,"PWOY" ,"TAY" ,"KAY" ,"KWAY" ,"MAY" ,"NOY" ,"NAY" ,"LAY" ,"SOY" ,"SAY" ,"SHOY" ,"SHAY" ,"SHWOY" ,"YOY" ,"YAY" ,"NWI" ,"OJIBWAY_" ,"NWII" ,"NWO" ,"NWOO" ,"RWEE" ,"RWI" ,"RWII" ,"RWO" ,"RWOO" ,"RWE" ,"THWE" ,"TTHWE" ,"TTHOO" ,"TTHAA" ,"TLHWE" ,"TLHOO" ,"GWU" ,"DENE_" ,"JUU" ,"BEAVER_" ,"LIMBU_" ,"VOWEL-" ,"LETTER" ,"YAN" ,"MUKPHRENG" ,"KEMPHRENG" ,"SA-" ,"TAI_" ,"LE_" ,"AUE" ,"NEW_" ,"LUE_" ,"KVA" ,"XVA" ,"SHORTENER" ,"OA" ,"UY" ,"OAY" ,"UEY" ,"MARK-" ,"THAM_" ,"LAE" ,"LAEV" ,"PATHAMASAT" ,"MUOY_" ,"KOET" ,"BEI_" ,"BUON_" ,"PRAM_" ,"DAP_" ,"DAP-" ,"TUTEYASAT" ,"ROC" ,"BUGINESE_" ,"NGKA" ,"MPA" ,"NRA" ,"NYCA" ,"PALLAWA" ,"RATA" ,"RATHA" ,"RANA" ,"RUE" ,"LUE" ,"LA_" ,"TANG_" ,"LAI" ,"KANG_" ,"RATHA_" ,"SAKOT" ,"SAT" ,"UUE" ,"OA_" ,"KANG" ,"KHUEN_" ,"HAAM" ,"SAM" ,"KHUEN-" ,"KARAN" ,"CRYPTOGRAMMIC_" ,"HORA_" ,"WIANG" ,"WIANGWAAK" ,"SAWAN" ,"KEOW" ,"HOY" ,"DOKMAI" ,"ROTATED_" ,"YAMOK" ,"KAAN" ,"KAANKUU" ,"SATKAAN" ,"SATKAANKUU" ,"HANG" ,"CAANG" ,"BALINESE_" ,"ULU_" ,"RICEM" ,"CANDRA" ,"CECEK" ,"SURANG" ,"BISAH" ,"AKARA" ,"AKARA_" ,"TEDUNG" ,"IKARA" ,"IKARA_" ,"UKARA" ,"UKARA_" ,"REPA" ,"REPA_" ,"LENGA" ,"LENGA_" ,"EKARA" ,"AIKARA" ,"OKARA" ,"OKARA_" ,"MAHAPRANA" ,"GA_" ,"GORA" ,"CA_" ,"LACA" ,"JA_" ,"JERA" ,"TA_" ,"LATIK" ,"MURDA_" ,"DA_" ,"ALPAPRANA" ,"RAMBAT" ,"TAWA" ,"MADU" ,"PA_" ,"KAPAL" ,"BA_" ,"KEMBANG" ,"SA_" ,"SAGA" ,"SAPA" ,"REREKAN" ,"ULU" ,"SARI" ,"SUKU" ,"SUKU_" ,"ILUT" ,"TALING" ,"TALING_" ,"PEPET" ,"PEPET_" ,"ADEG_" ,"ADEG" ,"SASAK" ,"KHOT_" ,"TZIR_" ,"EF_" ,"VE_" ,"ZAL_" ,"ASYURA_" ,"PANTI" ,"PAMADA" ,"WINDU" ,"CARIK_" ,"PAMUNGKAH" ,"SIKI" ,"PAREREN" ,"PAMENENG" ,"MUSICAL_" ,"DONG" ,"DENG" ,"DUNG" ,"DANG" ,"DANG_" ,"DING" ,"DAENG" ,"DEUNG" ,"DAING" ,"GEDE" ,"TEGEH" ,"ENDEP" ,"KEMPUL" ,"KEMPLI" ,"JEGOGAN" ,"KEMPUL_" ,"KEMPLI_" ,"BENDE" ,"GONG" ,"HAND_" ,"DUG" ,"DAG" ,"TUK" ,"TAK" ,"PANG" ,"PUNG" ,"PLAK" ,"PLUK" ,"PING" ,"SUNDANESE_" ,"PANYECEK" ,"PANGLAYAR" ,"PANGWISAD" ,"PAMINGKAL" ,"PANYAKRA" ,"PANYIKU" ,"PANGHULU" ,"PANYUKU" ,"PANAELAENG" ,"PANOLONG" ,"PAMEPET" ,"PANEULEUNG" ,"PAMAAEH" ,"SYA" ,"LEPCHA_" ,"KLA" ,"GLA" ,"FLA" ,"BLA" ,"MLA" ,"HLA" ,"NYIN-" ,"RAN" ,"TA-" ,"ROL" ,"NYET_" ,"THYOOM_" ,"CER-" ,"TSHOOK_" ,"TSHOOK" ,"OL_" ,"CHIKI_" ,"AG" ,"AL" ,"AAK" ,"AAJ" ,"AAM" ,"AAW" ,"IS" ,"IH" ,"INY" ,"IR" ,"UC" ,"UD" ,"UNN" ,"EP" ,"EDD" ,"ERR" ,"OTT" ,"OB" ,"OV" ,"MU_" ,"TTUDDAG" ,"GAAHLAA_" ,"TTUDDAAG" ,"MU-" ,"RELAA" ,"PHAARKAA" ,"AHAD" ,"MUCAAD" ,"VEDIC_" ,"KARSHANA" ,"SHARA" ,"PRENKHA" ,"NIHSHVASA" ,"YAJURVEDIC_" ,"MIDLINE_" ,"SVARITA" ,"AGGRAVATED_" ,"KATHAKA_" ,"SVARITA_" ,"SCHROEDER" ,"RIGVEDIC_" ,"KASHMIRI_" ,"ATHARVAVEDIC_" ,"UDATTA_" ,"ANUDATTA_" ,"ANTARGOMUKHA" ,"BAHIRGOMUKHA" ,"VAMAGOMUKHA" ,"VAMAGOMUKHA_" ,"TIRYAK" ,"HEXIFORM_" ,"RTHANG_" ,"UBHAYATO_" ,"MUKHA" ,"ARDHAVISARGA" ,"SIDEWAYS_" ,"DIAERESIZED_" ,"LARYNGEAL_" ,"SPIRANT" ,"INSULAR_" ,"TH_" ,"STRIKETHROUGH" ,"SNAKE_" ,"SUSPENSION_" ,"MACRON-" ,"GRAVE-" ,"ACUTE-" ,"BREVE-" ,"US_" ,"FLATTENED_" ,"AO" ,"AV" ,"ROTUNDA" ,"CEDILLA_" ,"HORN_" ,"MIDDLE-" ,"WELSH_" ,"PSILI" ,"DASIA" ,"VARIA" ,"OXIA" ,"VARIA_" ,"OXIA_" ,"PERISPOMENI_" ,"PROSGEGRAMMENI" ,"VRACHY" ,"QUAD" ,"THREE-" ,"PER-" ,"FOUR-" ,"SIX-" ,"FIGURE_" ,"THIN_" ,"HAIR_" ,"WIDTH_" ,"NON-" ,"TO-" ,"BREAKING_" ,"DASH" ,"LOW-" ,"9_" ,"HIGH-" ,"REVERSED-" ,"DAGGER" ,"BULLET" ,"LEADER" ,"HYPHENATION_" ,"POINT" ,"EMBEDDING" ,"POP_" ,"DIRECTIONAL_" ,"FORMATTING" ,"OVERRIDE" ,"NARROW_" ,"CARET" ,"REFERENCE_" ,"INTERROBANG" ,"UNDERTIE" ,"TIE" ,"INSERTION_" ,"ASTERISM" ,"HYPHEN_" ,"SLASH" ,"BRACKET_" ,"QUILL" ,"TIRONIAN_" ,"BLACK_" ,"LEFTWARDS_" ,"CLOSE_" ,"UP" ,"ASTERISKS_" ,"ALIGNED_" ,"VERTICALLY" ,"SWUNG_" ,"FLOWER_" ,"QUADRUPLE_" ,"CROSS" ,"TRICOLON" ,"MEDIUM_" ,"MATHEMATICAL_" ,"WORD_" ,"FUNCTION_" ,"APPLICATION" ,"INVISIBLE_" ,"TIMES" ,"INHIBIT_" ,"SYMMETRIC_" ,"SWAPPING" ,"ACTIVATE_" ,"SHAPING" ,"NATIONAL_" ,"SHAPES" ,"NOMINAL_" ,"EURO-" ,"CRUZEIRO_" ,"FRENCH_" ,"FRANC_" ,"LIRA_" ,"MILL_" ,"NAIRA_" ,"PESETA_" ,"WON_" ,"SHEQEL_" ,"DONG_" ,"EURO_" ,"KIP_" ,"TUGRIK_" ,"DRACHMA_" ,"GERMAN_" ,"PENNY_" ,"PESO_" ,"GUARANI_" ,"AUSTRAL_" ,"HRYVNIA_" ,"CEDI_" ,"LIVRE_" ,"TOURNOIS_" ,"SPESMILO_" ,"TENGE_" ,"HARPOON_" ,"ANTICLOCKWISE_" ,"CLOCKWISE_" ,"ENCLOSING_" ,"SQUARE" ,"DIAMOND" ,"CIRCLE_" ,"BACKSLASH" ,"SCREEN" ,"KEYCAP" ,"UPWARD_" ,"TRIANGLE" ,"ANNUITY_" ,"UNDERDOT" ,"WIDE_" ,"BARB_" ,"ACCOUNT_" ,"OF" ,"ADDRESSED_" ,"SUBJECT" ,"DOUBLE-" ,"STRUCK_" ,"CELSIUS" ,"CARE_" ,"CADA_" ,"UNA" ,"EULER_" ,"CONSTANT" ,"SCRUPLE" ,"FAHRENHEIT" ,"BLACK-" ,"PLANCK_" ,"CONSTANT_" ,"OVER_" ,"BAR_" ,"NUMERO_" ,"SOUND_" ,"RECORDING_" ,"COPYRIGHT" ,"PRESCRIPTION_" ,"TAKE" ,"RESPONSE" ,"SERVICE_" ,"TELEPHONE_" ,"TRADE_" ,"VERSICLE" ,"OUNCE_" ,"OHM_" ,"KELVIN_" ,"ANGSTROM_" ,"ESTIMATED_" ,"BET_" ,"GIMEL_" ,"DALET_" ,"INFORMATION_" ,"SOURCE" ,"FACSIMILE_" ,"ARY_" ,"SUMMATION" ,"SANS-" ,"SERIF_" ,"ITALIC_" ,"PROPERTY_" ,"AKTIESELSKAB" ,"SEVENTH" ,"NINTH" ,"TENTH" ,"THIRD" ,"THIRDS" ,"FIFTH" ,"FIFTHS" ,"SIXTH" ,"SIXTHS" ,"EIGHTH" ,"EIGHTHS" ,"SEVEN_" ,"ROMAN_" ,"ELEVEN" ,"TWELVE" ,"SIX_" ,"LATE_" ,"FIFTY_" ,"EARLY_" ,"NORTH_" ,"WEST_" ,"EAST_" ,"SOUTH_" ,"WAVE_" ,"HEADED_" ,"FROM_" ,"BASE" ,"TIP_" ,"LEFTWARDS" ,"RIGHTWARDS" ,"CORNER_" ,"SEMICIRCLE_" ,"UPWARDS" ,"PAIRED_" ,"ARROWS" ,"HARPOON" ,"SQUIGGLE_" ,"DASHED_" ,"WHITE_" ,"ON_" ,"PEDESTAL" ,"PEDESTAL_" ,"WALL" ,"CORNER" ,"ALL" ,"COMPLEMENT" ,"PARTIAL_" ,"DIFFERENTIAL" ,"THERE_" ,"EXISTS" ,"DOES_" ,"EXIST" ,"SET" ,"INCREMENT" ,"NABLA" ,"ELEMENT_" ,"AN_" ,"CONTAINS_" ,"MEMBER" ,"CONTAIN_" ,"PROOF" ,"PRODUCT" ,"COPRODUCT" ,"MINUS-" ,"OR-" ,"SET_" ,"OPERATOR" ,"BULLET_" ,"PROPORTIONAL_" ,"INFINITY" ,"ANGLE" ,"MEASURED_" ,"SPHERICAL_" ,"DIVIDES" ,"DIVIDE" ,"PARALLEL_" ,"LOGICAL_" ,"AND" ,"INTERSECTION" ,"UNION" ,"INTEGRAL" ,"CONTOUR_" ,"SURFACE_" ,"VOLUME_" ,"THEREFORE" ,"BECAUSE" ,"RATIO" ,"PROPORTION" ,"EXCESS" ,"GEOMETRIC_" ,"HOMOTHETIC" ,"LAZY_" ,"SINE_" ,"WAVE" ,"WREATH_" ,"ASYMPTOTICALLY_" ,"APPROXIMATELY_" ,"BUT_" ,"ACTUALLY_" ,"NEITHER_" ,"ALL_" ,"EQUIVALENT_" ,"GEOMETRICALLY_" ,"DIFFERENCE_" ,"BETWEEN" ,"APPROACHES_" ,"LIMIT" ,"IMAGE_" ,"EQUALS" ,"IN_" ,"CORRESPONDS_" ,"ESTIMATES" ,"EQUIANGULAR_" ,"STAR_" ,"DELTA_" ,"DEFINITION" ,"BY" ,"QUESTIONED_" ,"IDENTICAL_" ,"STRICTLY_" ,"MUCH_" ,"PRECEDES" ,"SUCCEEDS" ,"PRECEDES_" ,"SUCCEEDS_" ,"PRECEDE" ,"SUCCEED" ,"SUBSET_" ,"SUPERSET_" ,"MULTISET" ,"MULTISET_" ,"MULTIPLICATION" ,"ORIGINAL_" ,"CAP" ,"CUP" ,"CIRCLED_" ,"SQUARED_" ,"ASSERTION" ,"MODELS" ,"TRUE" ,"FORCES" ,"TURNSTILE" ,"PROVE" ,"FORCE" ,"NEGATED_" ,"UNDER_" ,"RELATION" ,"NORMAL_" ,"SUBGROUP_" ,"SUBGROUP" ,"MULTIMAP" ,"HERMITIAN_" ,"CONJUGATE_" ,"MATRIX" ,"INTERCALATE" ,"XOR" ,"NAND" ,"NOR" ,"ARC" ,"DIAMOND_" ,"BOWTIE" ,"FACTOR_" ,"SEMIDIRECT_" ,"SUBSET" ,"SUPERSET" ,"PITCHFORK" ,"VERY_" ,"PRECEDE_" ,"EQUAL" ,"SUCCEED_" ,"AT_" ,"OVERBAR" ,"UNDERBAR" ,"NOTATION_" ,"BAG_" ,"MEMBERSHIP" ,"DIAMETER_" ,"ELECTRIC_" ,"HOUSE" ,"PROJECTIVE" ,"PERSPECTIVE" ,"CEILING" ,"FLOOR" ,"CROP" ,"LOZENGE" ,"SEGMENT" ,"SECTOR" ,"RECORDER" ,"POSITION_" ,"VIEWDATA_" ,"INTEREST_" ,"WATCH" ,"HOURGLASS" ,"FROWN" ,"SMILE" ,"BETWEEN_" ,"BARS" ,"OPTION_" ,"KEY" ,"ERASE_" ,"RECTANGLE_" ,"BOX" ,"KEYBOARD" ,"BENZENE_" ,"CYLINDRICITY" ,"AROUND-" ,"PROFILE" ,"SYMMETRY" ,"TOTAL_" ,"RUNOUT" ,"DIMENSION_" ,"ORIGIN" ,"CONICAL_" ,"TAPER" ,"SLOPE" ,"COUNTERBORE" ,"COUNTERSINK" ,"APL_" ,"FUNCTIONAL_" ,"BEAM" ,"SQUISH_" ,"QUAD_" ,"JOT" ,"STILE" ,"SLASH_" ,"BACKSLASH_" ,"VANE" ,"DEL_" ,"DEL" ,"QUOTE_" ,"JOT_" ,"SHOE_" ,"ZILDE" ,"STILE_" ,"SEMICOLON_" ,"QUESTION" ,"CHECK_" ,"SHOULDERED_" ,"BELL_" ,"CONTINUOUS_" ,"UNDERLINE_" ,"DISCONTINUOUS_" ,"COMPOSITION_" ,"ENTER_" ,"ALTERNATIVE_" ,"KEY_" ,"HELM_" ,"NOTCH" ,"TRIANGLE_" ,"DOWN" ,"NORTHWEST_" ,"UNDO_" ,"MONOSTABLE_" ,"HYSTERESIS_" ,"CIRCUIT-" ,"OUTPUT_" ,"H-" ,"L-" ,"PASSIVE-" ,"PULL-" ,"DOWN-" ,"UP-" ,"DIRECT_" ,"CURRENT_" ,"SOFTWARE-" ,"SEPARATOR_" ,"PREVIOUS_" ,"PAGE" ,"NEXT_" ,"PRINT_" ,"SCREEN_" ,"CLEAR_" ,"PARENTHESIS_" ,"EXTENSION" ,"PIECE" ,"INTEGRAL_" ,"SUMMATION_" ,"TOP" ,"BOTTOM" ,"RADICAL_" ,"BOX_" ,"SCAN_" ,"LINE-" ,"7" ,"9" ,"DENTISTRY_" ,"FOOT" ,"RETURN_" ,"EJECT_" ,"METRICAL_" ,"SHORT" ,"LONG" ,"SHORTS" ,"SHORTS_" ,"JOINED" ,"TRISEME" ,"TETRASEME" ,"PENTASEME" ,"EARTH_" ,"GROUND" ,"FUSE" ,"TORTOISE_" ,"SHELL_" ,"TRAPEZIUM" ,"STRAIGHTNESS" ,"FLATNESS" ,"CURRENT" ,"ELECTRICAL_" ,"EXPONENT_" ,"NULL" ,"HEADING" ,"TEXT" ,"TRANSMISSION" ,"ENQUIRY" ,"ACKNOWLEDGE" ,"BELL" ,"BACKSPACE" ,"TABULATION" ,"FEED" ,"CARRIAGE_" ,"RETURN" ,"SHIFT_" ,"OUT" ,"DATA_" ,"LINK_" ,"ESCAPE" ,"DEVICE_" ,"CONTROL_" ,"NEGATIVE_" ,"SYNCHRONOUS_" ,"IDLE" ,"TRANSMISSION_" ,"BLOCK" ,"CANCEL" ,"MEDIUM" ,"SUBSTITUTE" ,"FILE_" ,"GROUP_" ,"RECORD_" ,"UNIT_" ,"DELETE" ,"BLANK_" ,"NEWLINE" ,"DELETE_" ,"SUBSTITUTE_" ,"OCR_" ,"CHAIR" ,"FORK" ,"BELT_" ,"BUCKLE" ,"BOW_" ,"BRANCH_" ,"BANK_" ,"IDENTIFICATION" ,"AMOUNT_" ,"CHECK" ,"CUSTOMER_" ,"NUMBER" ,"THIRTEEN" ,"FOURTEEN" ,"FIFTEEN" ,"SEVENTEEN" ,"EIGHTEEN" ,"NINETEEN" ,"PARENTHESIZED_" ,"EIGHT_" ,"NINE_" ,"ELEVEN_" ,"TWELVE_" ,"THIRTEEN_" ,"FOURTEEN_" ,"FIFTEEN_" ,"SIXTEEN_" ,"SEVENTEEN_" ,"EIGHTEEN_" ,"NINETEEN_" ,"TWENTY_" ,"DRAWINGS_" ,"VERTICAL" ,"DASH_" ,"HEAVY" ,"LIGHT" ,"DOUBLE" ,"SINGLE" ,"ARC_" ,"EIGHTH_" ,"QUARTER_" ,"EIGHTHS_" ,"QUARTERS_" ,"SHADE" ,"DARK_" ,"QUADRANT_" ,"CORNERS" ,"CONTAINING_" ,"FILL" ,"ORTHOGONAL_" ,"CROSSHATCH_" ,"RECTANGLE" ,"PARALLELOGRAM" ,"POINTER" ,"FISHEYE" ,"BULLSEYE" ,"BLACK" ,"INVERSE_" ,"CIRCULAR_" ,"BISECTING_" ,"LARGE_" ,"QUADRANT" ,"SUN_" ,"RAYS" ,"CLOUD" ,"UMBRELLA" ,"SNOWMAN" ,"COMET" ,"LIGHTNING" ,"THUNDERSTORM" ,"SUN" ,"ASCENDING_" ,"NODE" ,"CONJUNCTION" ,"OPPOSITION" ,"TELEPHONE" ,"BALLOT_" ,"SALTIRE" ,"UMBRELLA_" ,"RAIN_" ,"DROPS" ,"HOT_" ,"BEVERAGE" ,"SHOGI_" ,"SHAMROCK" ,"FLORAL_" ,"HEART_" ,"INDEX" ,"SKULL_" ,"CROSSBONES" ,"CAUTION_" ,"RADIOACTIVE_" ,"BIOHAZARD_" ,"CADUCEUS" ,"ANKH" ,"ORTHODOX_" ,"LORRAINE" ,"JERUSALEM" ,"CRESCENT" ,"ADI_" ,"SHAKTI" ,"HAMMER_" ,"SICKLE" ,"PEACE_" ,"YANG" ,"TRIGRAM_" ,"HEAVEN" ,"LAKE" ,"FIRE" ,"THUNDER" ,"WIND" ,"WATER" ,"MOUNTAIN" ,"EARTH" ,"WHEEL_" ,"DHARMA" ,"FROWNING_" ,"FACE" ,"SMILING_" ,"FIRST_" ,"MOON" ,"LAST_" ,"MERCURY" ,"FEMALE_" ,"MALE_" ,"JUPITER" ,"SATURN" ,"URANUS" ,"NEPTUNE" ,"PLUTO" ,"ARIES" ,"TAURUS" ,"GEMINI" ,"CANCER" ,"LEO" ,"VIRGO" ,"LIBRA" ,"SCORPIUS" ,"SAGITTARIUS" ,"CAPRICORN" ,"AQUARIUS" ,"PISCES" ,"CHESS_" ,"KING" ,"QUEEN" ,"ROOK" ,"BISHOP" ,"KNIGHT" ,"PAWN" ,"SPADE_" ,"SUIT" ,"CLUB_" ,"SPRINGS" ,"NOTE" ,"BEAMED_" ,"NOTES" ,"SIXTEENTH_" ,"MUSIC_" ,"FLAT_" ,"NATURAL_" ,"UNIVERSAL_" ,"RECYCLING_" ,"TYPE-" ,"1_" ,"PLASTICS" ,"2_" ,"3_" ,"4_" ,"5_" ,"6_" ,"7_" ,"GENERIC_" ,"MATERIALS" ,"RECYCLED_" ,"PAPER_" ,"PARTIALLY-" ,"PERMANENT_" ,"WHEELCHAIR_" ,"DIE_" ,"FACE-" ,"MONOGRAM_" ,"YIN" ,"DIGRAM_" ,"GREATER_" ,"LESSER_" ,"FLAG" ,"PICK" ,"ANCHOR" ,"CROSSED_" ,"SWORDS" ,"STAFF_" ,"AESCULAPIUS" ,"SCALES" ,"ALEMBIC" ,"FLOWER" ,"GEAR" ,"HERMES" ,"ATOM_" ,"FLEUR-" ,"DE-" ,"LIS" ,"OUTLINED_" ,"LINES_" ,"CONVERGING_" ,"WARNING_" ,"VOLTAGE_" ,"DOUBLED_" ,"INTERLOCKED_" ,"MARRIAGE_" ,"DIVORCE_" ,"UNMARRIED_" ,"PARTNERSHIP_" ,"COFFIN" ,"FUNERAL_" ,"URN" ,"NEUTER" ,"CERES" ,"PALLAS" ,"JUNO" ,"VESTA" ,"CHIRON" ,"MOON_" ,"LILITH" ,"SEXTILE" ,"SEMISEXTILE" ,"QUINCUNX" ,"SESQUIQUADRATE" ,"SOCCER_" ,"BALL" ,"BASEBALL" ,"DRAUGHTS_" ,"SNOWMAN_" ,"WITHOUT_" ,"SNOW" ,"BEHIND_" ,"RAIN" ,"THUNDER_" ,"CLOUD_" ,"CROSSING_" ,"LANES" ,"DISABLED_" ,"CAR" ,"CAR_" ,"SLIDING" ,"HELMET_" ,"CHAINS" ,"ENTRY" ,"ALTERNATE_" ,"ONE-" ,"WAY_" ,"TRAFFIC" ,"TWO-" ,"LANE_" ,"MERGE" ,"DRIVE_" ,"SLOW_" ,"FALLING_" ,"TRUCK" ,"RESTRICTED_" ,"ENTRY-" ,"SHIELD" ,"SHINTO_" ,"SHRINE" ,"CHURCH" ,"CASTLE" ,"HISTORIC_" ,"SITE" ,"GEAR_" ,"HUB" ,"HANDLES" ,"MAP_" ,"LIGHTHOUSE" ,"FOUNTAIN" ,"FLAG_" ,"HOLE" ,"FERRY" ,"SAILBOAT" ,"SKIER" ,"ICE_" ,"SKATE" ,"PERSON_" ,"TENT" ,"JAPANESE_" ,"HEADSTONE_" ,"GRAVEYARD_" ,"FUEL_" ,"PUMP" ,"CUP_" ,"STRIPE" ,"BLADE_" ,"SCISSORS" ,"LOCATION_" ,"TAPE_" ,"DRIVE" ,"AIRPLANE" ,"ENVELOPE" ,"VICTORY_" ,"HAND" ,"WRITING_" ,"PENCIL" ,"NIB" ,"SHADOWED_" ,"MALTESE_" ,"DAVID" ,"TEARDROP-" ,"SPOKED_" ,"BALLOON-" ,"CLUB-" ,"PINWHEEL_" ,"RECTILINEAR_" ,"PETALLED_" ,"FLORETTE" ,"SNOWFLAKE" ,"TIGHT_" ,"TRIFOLIATE_" ,"CHEVRON_" ,"SPARKLE" ,"PROPELLER_" ,"DROP-" ,"ORNAMENT" ,"CURVED_" ,"STEM_" ,"HEART" ,"DINGBAT_" ,"WIDE-" ,"DRAFTING_" ,"ROUND-" ,"TIPPED_" ,"TRIANGLE-" ,"TOP-" ,"LIGHTED_" ,"BOTTOM-" ,"CONCAVE-" ,"SHADED_" ,"BACK-" ,"TILTED_" ,"FRONT-" ,"NOTCHED_" ,"WHITE-" ,"FEATHERED_" ,"BARBED_" ,"SHANKED_" ,"WEDGE-" ,"TAILED_" ,"DIMENSIONAL_" ,"PERPENDICULAR" ,"SHAPED_" ,"DELIMITER" ,"INSIDE" ,"PRECEDING_" ,"DIVISION" ,"OPENING_" ,"OUTER_" ,"JOIN" ,"LOZENGE_" ,"DIVIDED_" ,"RULE" ,"SIDED_" ,"GAPPED_" ,"BRAILLE_" ,"PATTERN_" ,"BLANK" ,"DOTS-" ,"12" ,"13" ,"23" ,"123" ,"14" ,"24" ,"124" ,"34" ,"134" ,"234" ,"1234" ,"15" ,"25" ,"125" ,"35" ,"135" ,"235" ,"1235" ,"45" ,"145" ,"245" ,"1245" ,"345" ,"1345" ,"2345" ,"12345" ,"16" ,"26" ,"126" ,"36" ,"136" ,"236" ,"1236" ,"46" ,"146" ,"246" ,"1246" ,"346" ,"1346" ,"2346" ,"12346" ,"56" ,"156" ,"256" ,"1256" ,"356" ,"1356" ,"2356" ,"12356" ,"456" ,"1456" ,"2456" ,"12456" ,"3456" ,"13456" ,"23456" ,"123456" ,"17" ,"27" ,"127" ,"37" ,"137" ,"237" ,"1237" ,"47" ,"147" ,"247" ,"1247" ,"347" ,"1347" ,"2347" ,"12347" ,"57" ,"157" ,"257" ,"1257" ,"357" ,"1357" ,"2357" ,"12357" ,"457" ,"1457" ,"2457" ,"12457" ,"3457" ,"13457" ,"23457" ,"123457" ,"67" ,"167" ,"267" ,"1267" ,"367" ,"1367" ,"2367" ,"12367" ,"467" ,"1467" ,"2467" ,"12467" ,"3467" ,"13467" ,"23467" ,"123467" ,"567" ,"1567" ,"2567" ,"12567" ,"3567" ,"13567" ,"23567" ,"123567" ,"4567" ,"14567" ,"24567" ,"124567" ,"34567" ,"134567" ,"234567" ,"1234567" ,"8" ,"18" ,"28" ,"128" ,"38" ,"138" ,"238" ,"1238" ,"48" ,"148" ,"248" ,"1248" ,"348" ,"1348" ,"2348" ,"12348" ,"58" ,"158" ,"258" ,"1258" ,"358" ,"1358" ,"2358" ,"12358" ,"458" ,"1458" ,"2458" ,"12458" ,"3458" ,"13458" ,"23458" ,"123458" ,"68" ,"168" ,"268" ,"1268" ,"368" ,"1368" ,"2368" ,"12368" ,"468" ,"1468" ,"2468" ,"12468" ,"3468" ,"13468" ,"23468" ,"123468" ,"568" ,"1568" ,"2568" ,"12568" ,"3568" ,"13568" ,"23568" ,"123568" ,"4568" ,"14568" ,"24568" ,"124568" ,"34568" ,"134568" ,"234568" ,"1234568" ,"78" ,"178" ,"278" ,"1278" ,"378" ,"1378" ,"2378" ,"12378" ,"478" ,"1478" ,"2478" ,"12478" ,"3478" ,"13478" ,"23478" ,"123478" ,"578" ,"1578" ,"2578" ,"12578" ,"3578" ,"13578" ,"23578" ,"123578" ,"4578" ,"14578" ,"24578" ,"124578" ,"34578" ,"134578" ,"234578" ,"1234578" ,"678" ,"1678" ,"2678" ,"12678" ,"3678" ,"13678" ,"23678" ,"123678" ,"4678" ,"14678" ,"24678" ,"124678" ,"34678" ,"134678" ,"234678" ,"1234678" ,"5678" ,"15678" ,"25678" ,"125678" ,"35678" ,"135678" ,"235678" ,"1235678" ,"45678" ,"145678" ,"245678" ,"1245678" ,"345678" ,"1345678" ,"2345678" ,"12345678" ,"STEM" ,"TAIL_" ,"ARROW-" ,"DIRECTLY_" ,"THEN_" ,"CURVING_" ,"SIDE_" ,"SEMICIRCULAR_" ,"THROUGH_" ,"BESIDE_" ,"HEAD" ,"OPERATOR_" ,"FISH_" ,"SPOT" ,"BINDING_" ,"TICK_" ,"FENCE" ,"VARIANT_" ,"ARM_" ,"ENDING_" ,"PARALLEL" ,"SUPERIMPOSED_" ,"ANTICLOCKWISE-" ,"STROKES_" ,"JOINED_" ,"SQUARES" ,"SERIFS_" ,"BOWTIE_" ,"TIMES_" ,"WIGGLY_" ,"INCOMPLETE_" ,"TIE_" ,"INFINITY_" ,"ENDED_" ,"CONTOURED_" ,"OUTLINE" ,"INCREASES_" ,"AS" ,"SHUFFLE_" ,"SLANTED_" ,"GLEICH_" ,"STARK" ,"THERMODYNAMIC" ,"ERROR-" ,"RULE-" ,"DELAYED" ,"TINY" ,"MINY" ,"UNION_" ,"INTERSECTION_" ,"MODULO_" ,"SUM" ,"FINITE_" ,"PART_" ,"AVERAGE_" ,"CIRCULATION_" ,"FUNCTION" ,"INTEGRATION" ,"INTEGRATION_" ,"PATH_" ,"AROUND_" ,"POLE" ,"INCLUDING_" ,"QUATERNION_" ,"SCHEMA_" ,"COMPOSITION" ,"PIPING" ,"PROJECTION" ,"VECTOR_" ,"PRODUCT_" ,"CLOSED" ,"SMASH_" ,"INTERIOR_" ,"RIGHTHAND_" ,"RELATIONAL_" ,"AMALGAMATION_" ,"SERIFS" ,"INTERSECTING_" ,"SLOPING_" ,"OVERLAPPING_" ,"VEE_" ,"DOMAIN_" ,"ANTIRESTRICTION" ,"RANGE_" ,"SIMILAR_" ,"SIMILAR" ,"CONGRUENT_" ,"CONSECUTIVE_" ,"SIGNS" ,"APPROXIMATE" ,"SINGLE-" ,"NESTED_" ,"CURVE" ,"CURVE_" ,"SMALLER_" ,"LARGER_" ,"BUMPY_" ,"PITCHFORK_" ,"TEE_" ,"TRANSVERSAL_" ,"FORKING" ,"NONFORKING" ,"PERPENDICULAR_" ,"MEMBER_" ,"DIVIDE_" ,"NEGATION_" ,"BINARY_" ,"PENTAGON" ,"HEXAGON" ,"ELLIPSE" ,"OVAL_" ,"GLAGOLITIC_" ,"AZU" ,"BUKY" ,"VEDE" ,"GLAGOLI" ,"DOBRO" ,"YESTU" ,"ZHIVETE" ,"DZELO" ,"ZEMLJA" ,"IZHE" ,"DJERVI" ,"KAKO" ,"LJUDIJE" ,"MYSLITE" ,"NASHI" ,"ONU" ,"POKOJI" ,"RITSI" ,"SLOVO" ,"TVRIDO" ,"UKU" ,"FRITU" ,"HERU" ,"OTU" ,"SHTA" ,"CHRIVI" ,"YERI" ,"YATI" ,"SPIDERY_" ,"YUS_" ,"IOTATED_" ,"SHTAPIC" ,"TROKUTASTI_" ,"LATINATE_" ,"TAILLESS_" ,"ALFA" ,"VIDA" ,"DALDA" ,"EIE" ,"SOU" ,"ZATA" ,"HATE" ,"THETHE" ,"IAUDA" ,"KAPA" ,"LAULA" ,"SIMA" ,"OOU" ,"DIALECT-" ,"OLD_" ,"AKHMIMIC_" ,"HEI" ,"HAT" ,"DJA" ,"NUBIAN_" ,"WAU" ,"MI_" ,"STAUROS" ,"TAU_" ,"KHI_" ,"SHIMA_" ,"NI_" ,"SPIRITUS_" ,"ASPER" ,"LENIS" ,"INDIRECT_" ,"DIVIDER" ,"MORPHOLOGICAL_" ,"TIFINAGH_" ,"YAB" ,"YABH" ,"YAG" ,"YAGHH" ,"BERBER_" ,"ACADEMY_" ,"YAJ" ,"YAD" ,"YADH" ,"YADD" ,"YADDH" ,"YEY" ,"YAF" ,"TUAREG_" ,"YAKHH" ,"YAH" ,"YAHH" ,"YAKH" ,"YAQ" ,"YAZH" ,"AHAGGAR_" ,"YAL" ,"YAM" ,"YAGN" ,"YAP" ,"YAR" ,"YARR" ,"YAGH" ,"AYER_" ,"YAS" ,"YASS" ,"YASH" ,"YATH" ,"YACH" ,"YATT" ,"YAV" ,"YAW" ,"YAZ" ,"TAWELLEMET_" ,"YAZZ" ,"LABIALIZATION_" ,"LOA" ,"MOA" ,"ROA" ,"SOA" ,"SHOA" ,"BOA" ,"TOA" ,"COA" ,"NOA" ,"NYOA" ,"ZOA" ,"DOA" ,"DDOA" ,"JOA" ,"THOA" ,"CHOA" ,"PHOA" ,"POA" ,"GGWA" ,"GGWI" ,"GGWEE" ,"GGWE" ,"SSU" ,"SSI" ,"SSAA" ,"SSEE" ,"SSE" ,"CCA" ,"CCU" ,"CCI" ,"CCAA" ,"CCEE" ,"CCE" ,"CCO" ,"ZZA" ,"ZZU" ,"ZZI" ,"ZZAA" ,"ZZEE" ,"ZZE" ,"ZZO" ,"CCHA" ,"CCHU" ,"CCHI" ,"CCHAA" ,"CCHEE" ,"CCHE" ,"CCHO" ,"QYA" ,"QYU" ,"QYI" ,"QYAA" ,"QYEE" ,"QYE" ,"QYO" ,"KYA" ,"KYU" ,"KYI" ,"KYAA" ,"KYEE" ,"KYE" ,"KYO" ,"XYA" ,"XYU" ,"XYI" ,"XYAA" ,"XYEE" ,"XYE" ,"XYO" ,"GYA" ,"GYU" ,"GYI" ,"GYAA" ,"GYEE" ,"GYE" ,"GYO" ,"ES-" ,"DJERV" ,"MONOGRAPH_" ,"SUBSTITUTION_" ,"INTERPOLATION_" ,"TRANSPOSITION_" ,"OMISSION_" ,"EDITORIAL_" ,"CORONIS" ,"PARAGRAPHOS" ,"FORKED_" ,"HYPODIASTOLE" ,"OBELOS" ,"ANCORA" ,"PALM_" ,"BRANCH" ,"PARAPHRASE_" ,"CJK_" ,"REPEAT" ,"CLIFF" ,"SECOND_" ,"PERSON" ,"TABLE" ,"KNIFE_" ,"DIVINATION" ,"SEAL" ,"LAME_" ,"SNAKE" ,"THREAD" ,"SNOUT_" ,"RAP" ,"CHOKE" ,"DEATH" ,"MOTHER" ,"CIVILIAN" ,"WATER_" ,"PAW_" ,"SIMPLIFIED_" ,"TREE_" ,"TRUNK" ,"COW" ,"DOG" ,"JADE" ,"BOLT_" ,"CLOTH" ,"EYE" ,"SPIRIT_" ,"BAMBOO" ,"SILK" ,"C-" ,"NET_" ,"MESH" ,"SHEEP" ,"RAM" ,"EWE" ,"OLD" ,"BRUSH_" ,"MEAT" ,"MORTAR" ,"GRASS_" ,"TIGER" ,"CLOTHES" ,"SPEECH" ,"SHELL" ,"CART" ,"WALK" ,"WALK_" ,"CITY" ,"GOLD" ,"GATE" ,"MOUND_" ,"BLUE" ,"TANNED_" ,"LEATHER" ,"LEAF" ,"FLY" ,"EAT_" ,"EAT" ,"HORSE" ,"BONE" ,"GHOST" ,"FISH" ,"BIRD" ,"SALT" ,"WHEAT" ,"YELLOW" ,"FROG" ,"J-" ,"EVEN" ,"TOOTH" ,"DRAGON" ,"TURTLE" ,"KANGXI_" ,"SECOND" ,"LID" ,"LEGS" ,"ENTER" ,"COVER" ,"ICE" ,"KNIFE" ,"POWER" ,"WRAP" ,"SPOON" ,"HIDING_" ,"ENCLOSURE" ,"PRIVATE" ,"AGAIN" ,"MOUTH" ,"SCHOLAR" ,"GO_" ,"SLOWLY" ,"EVENING" ,"BIG" ,"WOMAN" ,"CHILD" ,"ROOF" ,"INCH" ,"SMALL" ,"LAME" ,"CORPSE" ,"SPROUT" ,"RIVER" ,"WORK" ,"ONESELF" ,"TURBAN" ,"DRY" ,"STRIDE" ,"HANDS" ,"SHOOT" ,"BOW" ,"SNOUT" ,"BRISTLE" ,"STEP" ,"HALBERD" ,"DOOR" ,"SCRIPT" ,"DIPPER" ,"AXE" ,"NOT" ,"TREE" ,"LACK" ,"WEAPON" ,"COMPARE" ,"FUR" ,"CLAN" ,"STEAM" ,"CLAW" ,"FATHER" ,"SLICE" ,"FANG" ,"PROFOUND" ,"MELON" ,"TILE" ,"SWEET" ,"LIFE" ,"USE" ,"FIELD" ,"SICKNESS" ,"WHITE" ,"SKIN" ,"DISH" ,"SPEAR" ,"STONE" ,"SPIRIT" ,"TRACK" ,"GRAIN" ,"CAVE" ,"STAND" ,"RICE" ,"JAR" ,"NET" ,"FEATHER" ,"PLOW" ,"BRUSH" ,"MINISTER" ,"SELF" ,"ARRIVE" ,"TONGUE" ,"OPPOSE" ,"BOAT" ,"STOPPING" ,"COLOR" ,"GRASS" ,"INSECT" ,"BLOOD" ,"WEST" ,"VALLEY" ,"BEAN" ,"PIG" ,"BADGER" ,"RED" ,"RUN" ,"BODY" ,"BITTER" ,"MORNING" ,"WINE" ,"DISTINGUISH" ,"VILLAGE" ,"MOUND" ,"SLAVE" ,"WRONG" ,"LEEK" ,"SOUND" ,"FRAGRANT" ,"TALL" ,"HAIR" ,"FIGHT" ,"SACRIFICIAL_" ,"CAULDRON" ,"DEER" ,"HEMP" ,"MILLET" ,"EMBROIDERY" ,"TRIPOD" ,"DRUM" ,"RAT" ,"NOSE" ,"FLUTE" ,"IDEOGRAPHIC_" ,"DESCRIPTION_" ,"SURROUND" ,"SURROUND_" ,"OVERLAID" ,"DITTO_" ,"INDUSTRIAL_" ,"STANDARD_" ,"ITERATION_" ,"LENTICULAR_" ,"POSTAL_" ,"GETA_" ,"PRIME_" ,"HANGZHOU_" ,"LEVEL_" ,"ENTERING_" ,"KANA_" ,"REPEAT_" ,"TELEGRAPH_" ,"FEED_" ,"MASU_" ,"ALTERNATION_" ,"FILL_" ,"HIRAGANA_" ,"KATAKANA-" ,"SEMI-" ,"YORI" ,"KATAKANA_" ,"PROLONGED_" ,"KOTO" ,"BOPOMOFO_" ,"ZH" ,"CH" ,"IU" ,"GN" ,"ARAEAE" ,"ANNOTATION_" ,"LINKING_" ,"THIRD_" ,"HEAVEN_" ,"ENN" ,"ANN" ,"INN" ,"IM" ,"NGG" ,"AINN" ,"AUNN" ,"ONG" ,"INNN" ,"WG" ,"XG" ,"BXG" ,"HZZ" ,"HZG" ,"HP" ,"HZWG" ,"SZWG" ,"HZT" ,"HZZP" ,"HPWG" ,"HZW" ,"HZZZ" ,"SP" ,"HZ" ,"HG" ,"SZ" ,"SWZ" ,"ST" ,"SG" ,"PD" ,"PZ" ,"TN" ,"SZZ" ,"SWG" ,"HXWG" ,"HZZZG" ,"PG" ,"KIYEOK_" ,"NIEUN_" ,"TIKEUT_" ,"RIEUL_" ,"MIEUM_" ,"PIEUP_" ,"SIOS_" ,"IEUNG_" ,"CIEUC_" ,"CHIEUCH_" ,"KHIEUKH_" ,"THIEUTH_" ,"PHIEUPH_" ,"HIEUH_" ,"KOREAN_" ,"OJEON" ,"IDEOGRAPH_" ,"WOOD" ,"METAL" ,"STOCK" ,"HAVE" ,"SOCIETY" ,"NAME" ,"SPECIAL" ,"FINANCIAL" ,"CONGRATULATION" ,"LABOR" ,"REPRESENT" ,"CALL" ,"STUDY" ,"SUPERVISE" ,"ENTERPRISE" ,"RESOURCE" ,"ALLIANCE" ,"FESTIVAL" ,"REST" ,"REACH" ,"KINDERGARTEN" ,"SCHOOL" ,"THIRTY_" ,"FORTY_" ,"SIXTY_" ,"SEVENTY_" ,"EIGHTY_" ,"CHAMKO" ,"JUEUI" ,"SECRET" ,"MALE" ,"FEMALE" ,"SUITABLE" ,"EXCELLENT" ,"PRINT" ,"ATTENTION" ,"ITEM" ,"COPY" ,"CORRECT" ,"HIGH" ,"LOW" ,"MEDICINE" ,"RELIGION" ,"NIGHT" ,"JANUARY" ,"FEBRUARY" ,"MARCH" ,"APRIL" ,"JUNE" ,"JULY" ,"AUGUST" ,"SEPTEMBER" ,"OCTOBER" ,"NOVEMBER" ,"DECEMBER" ,"ERG" ,"EV" ,"LIMITED_" ,"LIABILITY_" ,"APAATO" ,"ARUHUA" ,"ANPEA" ,"AARU" ,"ININGU" ,"INTI" ,"UON" ,"ESUKUUDO" ,"EEKAA" ,"ONSU" ,"OOMU" ,"KAIRI" ,"KARATTO" ,"KARORII" ,"GARON" ,"GANMA" ,"GIGA" ,"GINII" ,"KYURII" ,"GIRUDAA" ,"KIRO" ,"KIROGURAMU" ,"KIROMEETORU" ,"KIROWATTO" ,"GURAMU" ,"GURAMUTON" ,"KURUZEIRO" ,"KUROONE" ,"KEESU" ,"KORUNA" ,"KOOPO" ,"SAIKURU" ,"SANTIIMU" ,"SIRINGU" ,"SENTI" ,"SENTO" ,"DAASU" ,"DESI" ,"DORU" ,"TON" ,"NANO" ,"NOTTO" ,"HAITU" ,"PAASENTO" ,"PAATU" ,"BAARERU" ,"PIASUTORU" ,"PIKURU" ,"PIKO" ,"BIRU" ,"HUARADDO" ,"HUIITO" ,"BUSSYERU" ,"HURAN" ,"HEKUTAARU" ,"PESO" ,"PENIHI" ,"HERUTU" ,"PENSU" ,"PEEZI" ,"BEETA" ,"POINTO" ,"BORUTO" ,"HON" ,"PONDO" ,"HOORU" ,"HOON" ,"MAIKURO" ,"MAIRU" ,"MAHHA" ,"MARUKU" ,"MANSYON" ,"MIKURON" ,"MIRI" ,"MIRIBAARU" ,"MEGA" ,"MEGATON" ,"MEETORU" ,"YAADO" ,"YAARU" ,"YUAN" ,"RITTORU" ,"RIRA" ,"RUPII" ,"RUUBURU" ,"REMU" ,"RENTOGEN" ,"WATTO" ,"HOUR_" ,"TWENTY-" ,"HPA" ,"PC" ,"DM" ,"DM_" ,"SQUARED" ,"CUBED" ,"ERA_" ,"NAME_" ,"HEISEI" ,"SYOUWA" ,"TAISYOU" ,"MEIZI" ,"CORPORATION" ,"AMPS" ,"KB" ,"MB" ,"GB" ,"CAL" ,"KCAL" ,"PF" ,"NF" ,"MG" ,"KG" ,"KHZ" ,"MHZ" ,"GHZ" ,"THZ" ,"ML" ,"DL" ,"KL" ,"FM" ,"NM" ,"MM" ,"CM" ,"KM" ,"MM_" ,"CM_" ,"KM_" ,"KPA" ,"GPA" ,"RAD" ,"PS" ,"NS" ,"MS" ,"PV" ,"MV" ,"KV" ,"MV_" ,"PW" ,"NW" ,"MW" ,"MW_" ,"OHM" ,"BQ" ,"CC" ,"CD" ,"DB" ,"GY" ,"CAPITAL" ,"KT" ,"LM" ,"LN" ,"LOG" ,"LX" ,"MB_" ,"MIL" ,"MOL" ,"PH" ,"PM" ,"PPM" ,"PR" ,"SR" ,"WB" ,"THIRTY-" ,"GAL" ,"HEXAGRAM_" ,"CREATIVE_" ,"RECEPTIVE_" ,"DIFFICULTY_" ,"BEGINNING" ,"YOUTHFUL_" ,"FOLLY" ,"WAITING" ,"CONFLICT" ,"ARMY" ,"HOLDING_" ,"TOGETHER" ,"TAMING" ,"TREADING" ,"PEACE" ,"STANDSTILL" ,"FELLOWSHIP" ,"POSSESSION" ,"MODESTY" ,"ENTHUSIASM" ,"FOLLOWING" ,"WORK_" ,"DECAYED" ,"APPROACH" ,"CONTEMPLATION" ,"BITING_" ,"THROUGH" ,"GRACE" ,"SPLITTING_" ,"APART" ,"INNOCENCE" ,"MOUTH_" ,"PREPONDERANCE" ,"ABYSMAL_" ,"CLINGING_" ,"INFLUENCE" ,"DURATION" ,"RETREAT" ,"PROGRESS" ,"DARKENING_" ,"FAMILY" ,"OBSTRUCTION" ,"DELIVERANCE" ,"DECREASE" ,"INCREASE" ,"BREAKTHROUGH" ,"COMING_" ,"MEET" ,"GATHERING_" ,"PUSHING_" ,"UPWARD" ,"OPPRESSION" ,"WELL" ,"REVOLUTION" ,"AROUSING_" ,"KEEPING_" ,"STILL_" ,"DEVELOPMENT" ,"MARRYING_" ,"MAIDEN" ,"ABUNDANCE" ,"WANDERER" ,"GENTLE_" ,"JOYOUS_" ,"DISPERSION" ,"LIMITATION" ,"INNER_" ,"TRUTH" ,"AFTER_" ,"COMPLETION" ,"BEFORE_" ,"YI_" ,"IX" ,"IP" ,"IET" ,"IEX" ,"IEP" ,"AX" ,"AP" ,"UOX" ,"UO" ,"UOP" ,"OX" ,"OP" ,"EX" ,"BIX" ,"BIP" ,"BIET" ,"BIEX" ,"BIE" ,"BIEP" ,"BAT" ,"BAX" ,"BAP" ,"BUOX" ,"BUO" ,"BUOP" ,"BOT" ,"BOP" ,"BEX" ,"BEP" ,"BUT" ,"BUX" ,"BUP" ,"BURX" ,"BUR" ,"BYT" ,"BYX" ,"BYP" ,"BYRX" ,"BYR" ,"PIT" ,"PIX" ,"PIP" ,"PIEX" ,"PIE" ,"PIEP" ,"PAT" ,"PAX" ,"PAP" ,"PUOX" ,"PUO" ,"PUOP" ,"POT" ,"POX" ,"POP" ,"PUT" ,"PUX" ,"PUP" ,"PURX" ,"PUR" ,"PYT" ,"PYX" ,"PY" ,"PYP" ,"PYRX" ,"PYR" ,"BBIT" ,"BBIX" ,"BBI" ,"BBIP" ,"BBIET" ,"BBIEX" ,"BBIE" ,"BBIEP" ,"BBAT" ,"BBAX" ,"BBAP" ,"BBUOX" ,"BBUO" ,"BBUOP" ,"BBOT" ,"BBOX" ,"BBO" ,"BBOP" ,"BBEX" ,"BBEP" ,"BBUT" ,"BBUX" ,"BBU" ,"BBUP" ,"BBURX" ,"BBUR" ,"BBYT" ,"BBYX" ,"BBY" ,"BBYP" ,"NBIT" ,"NBIX" ,"NBI" ,"NBIP" ,"NBIEX" ,"NBIE" ,"NBIEP" ,"NBAT" ,"NBAX" ,"NBA" ,"NBAP" ,"NBOT" ,"NBOX" ,"NBO" ,"NBOP" ,"NBUT" ,"NBUX" ,"NBU" ,"NBUP" ,"NBURX" ,"NBUR" ,"NBYT" ,"NBYX" ,"NBY" ,"NBYP" ,"NBYRX" ,"NBYR" ,"HMIT" ,"HMIX" ,"HMI" ,"HMIP" ,"HMIEX" ,"HMIE" ,"HMIEP" ,"HMAT" ,"HMAX" ,"HMA" ,"HMAP" ,"HMUOX" ,"HMUO" ,"HMUOP" ,"HMOT" ,"HMOX" ,"HMO" ,"HMOP" ,"HMUT" ,"HMUX" ,"HMU" ,"HMUP" ,"HMURX" ,"HMUR" ,"HMYX" ,"HMY" ,"HMYP" ,"HMYRX" ,"HMYR" ,"MIT" ,"MIX" ,"MIP" ,"MIEX" ,"MIE" ,"MIEP" ,"MAT" ,"MAX" ,"MAP" ,"MUOT" ,"MUOX" ,"MUO" ,"MUOP" ,"MOT" ,"MOX" ,"MOP" ,"MEX" ,"MUT" ,"MUX" ,"MUP" ,"MURX" ,"MUR" ,"MYT" ,"MYX" ,"MY" ,"MYP" ,"FIT" ,"FIX" ,"FIP" ,"FAT" ,"FAX" ,"FAP" ,"FOX" ,"FOP" ,"FUT" ,"FUX" ,"FUP" ,"FURX" ,"FYT" ,"FYX" ,"FY" ,"FYP" ,"VIT" ,"VIX" ,"VIP" ,"VIET" ,"VIEX" ,"VIE" ,"VIEP" ,"VAT" ,"VAX" ,"VAP" ,"VOT" ,"VOX" ,"VOP" ,"VEX" ,"VEP" ,"VUT" ,"VUX" ,"VUP" ,"VURX" ,"VUR" ,"VYT" ,"VYX" ,"VY" ,"VYP" ,"VYRX" ,"VYR" ,"DIT" ,"DIX" ,"DIP" ,"DIEX" ,"DIE" ,"DIEP" ,"DAT" ,"DAX" ,"DAP" ,"DUOX" ,"DUO" ,"DOX" ,"DOP" ,"DEX" ,"DEP" ,"DUT" ,"DUX" ,"DUP" ,"DURX" ,"DUR" ,"TIX" ,"TIP" ,"TIEX" ,"TIEP" ,"TAT" ,"TAX" ,"TAP" ,"TUOT" ,"TUOX" ,"TUO" ,"TUOP" ,"TOT" ,"TOX" ,"TEX" ,"TEP" ,"TUT" ,"TUX" ,"TUP" ,"TURX" ,"TUR" ,"DDIT" ,"DDIX" ,"DDIP" ,"DDIEX" ,"DDIE" ,"DDIEP" ,"DDAT" ,"DDAX" ,"DDAP" ,"DDUOX" ,"DDUO" ,"DDUOP" ,"DDOT" ,"DDOX" ,"DDOP" ,"DDEX" ,"DDEP" ,"DDUT" ,"DDUX" ,"DDUP" ,"DDURX" ,"DDUR" ,"NDIT" ,"NDIX" ,"NDI" ,"NDIP" ,"NDIEX" ,"NDIE" ,"NDAT" ,"NDAX" ,"NDA" ,"NDAP" ,"NDOT" ,"NDOX" ,"NDO" ,"NDOP" ,"NDEX" ,"NDE" ,"NDEP" ,"NDUT" ,"NDUX" ,"NDU" ,"NDUP" ,"NDURX" ,"NDUR" ,"HNIT" ,"HNIX" ,"HNI" ,"HNIP" ,"HNIET" ,"HNIEX" ,"HNIE" ,"HNIEP" ,"HNAT" ,"HNAX" ,"HNAP" ,"HNUOX" ,"HNUO" ,"HNOT" ,"HNOX" ,"HNOP" ,"HNEX" ,"HNE" ,"HNEP" ,"HNUT" ,"NIT" ,"NIX" ,"NIP" ,"NIEX" ,"NIE" ,"NIEP" ,"NAX" ,"NAP" ,"NUOX" ,"NUO" ,"NUOP" ,"NOX" ,"NOP" ,"NEX" ,"NEP" ,"NUT" ,"NUX" ,"NUP" ,"NURX" ,"NUR" ,"HLIT" ,"HLIX" ,"HLI" ,"HLIP" ,"HLIEX" ,"HLIE" ,"HLIEP" ,"HLAT" ,"HLAX" ,"HLAP" ,"HLUOX" ,"HLUO" ,"HLUOP" ,"HLOX" ,"HLO" ,"HLOP" ,"HLEX" ,"HLE" ,"HLEP" ,"HLUT" ,"HLUX" ,"HLU" ,"HLUP" ,"HLURX" ,"HLUR" ,"HLYT" ,"HLYX" ,"HLY" ,"HLYP" ,"HLYRX" ,"HLYR" ,"LIT" ,"LIX" ,"LIP" ,"LIET" ,"LIEX" ,"LIE" ,"LIEP" ,"LAT" ,"LAX" ,"LAP" ,"LUOT" ,"LUOX" ,"LUO" ,"LUOP" ,"LOT" ,"LOX" ,"LOP" ,"LEX" ,"LEP" ,"LUT" ,"LUX" ,"LUP" ,"LURX" ,"LUR" ,"LYT" ,"LYX" ,"LYP" ,"LYRX" ,"LYR" ,"GIT" ,"GIX" ,"GIP" ,"GIET" ,"GIEX" ,"GIE" ,"GIEP" ,"GAT" ,"GAX" ,"GAP" ,"GUOT" ,"GUOX" ,"GUO" ,"GUOP" ,"GOT" ,"GOX" ,"GOP" ,"GET" ,"GEX" ,"GEP" ,"GUT" ,"GUX" ,"GUP" ,"GURX" ,"GUR" ,"KIT" ,"KIX" ,"KIP" ,"KIEX" ,"KIE" ,"KIEP" ,"KAT" ,"KAX" ,"KAP" ,"KUOX" ,"KUO" ,"KUOP" ,"KOT" ,"KOX" ,"KOP" ,"KET" ,"KEX" ,"KEP" ,"KUT" ,"KUX" ,"KUP" ,"KURX" ,"KUR" ,"GGIT" ,"GGIX" ,"GGIEX" ,"GGIE" ,"GGIEP" ,"GGAT" ,"GGAX" ,"GGAP" ,"GGUOT" ,"GGUOX" ,"GGUO" ,"GGUOP" ,"GGOT" ,"GGOX" ,"GGOP" ,"GGET" ,"GGEX" ,"GGEP" ,"GGUT" ,"GGUX" ,"GGUP" ,"GGURX" ,"GGUR" ,"MGIEX" ,"MGIE" ,"MGAT" ,"MGAX" ,"MGA" ,"MGAP" ,"MGUOX" ,"MGUO" ,"MGUOP" ,"MGOT" ,"MGOX" ,"MGOP" ,"MGEX" ,"MGE" ,"MGEP" ,"MGUT" ,"MGUX" ,"MGU" ,"MGUP" ,"MGURX" ,"MGUR" ,"HXIT" ,"HXIX" ,"HXI" ,"HXIP" ,"HXIET" ,"HXIEX" ,"HXIE" ,"HXIEP" ,"HXAT" ,"HXAX" ,"HXA" ,"HXAP" ,"HXUOT" ,"HXUOX" ,"HXUO" ,"HXUOP" ,"HXOT" ,"HXOX" ,"HXO" ,"HXOP" ,"HXEX" ,"HXE" ,"HXEP" ,"NGIEX" ,"NGIE" ,"NGIEP" ,"NGAT" ,"NGAX" ,"NGAP" ,"NGUOT" ,"NGUOX" ,"NGUO" ,"NGOT" ,"NGOX" ,"NGOP" ,"NGEX" ,"NGE" ,"NGEP" ,"HIT" ,"HIEX" ,"HAX" ,"HAP" ,"HUOT" ,"HUOX" ,"HUO" ,"HUOP" ,"HOT" ,"HOX" ,"HOP" ,"HEX" ,"HEP" ,"WAT" ,"WAX" ,"WAP" ,"WUOX" ,"WUO" ,"WUOP" ,"WOX" ,"WOP" ,"WEX" ,"WEP" ,"ZIT" ,"ZIX" ,"ZIP" ,"ZIEX" ,"ZIE" ,"ZIEP" ,"ZAT" ,"ZAX" ,"ZAP" ,"ZUOX" ,"ZUO" ,"ZUOP" ,"ZOT" ,"ZOX" ,"ZOP" ,"ZEX" ,"ZEP" ,"ZUT" ,"ZUX" ,"ZUP" ,"ZURX" ,"ZUR" ,"ZYT" ,"ZYX" ,"ZY" ,"ZYP" ,"ZYRX" ,"ZYR" ,"CIT" ,"CIX" ,"CIP" ,"CIET" ,"CIEX" ,"CIE" ,"CIEP" ,"CAT" ,"CAX" ,"CUOX" ,"CUO" ,"CUOP" ,"COT" ,"COX" ,"COP" ,"CEX" ,"CEP" ,"CUT" ,"CUX" ,"CURX" ,"CUR" ,"CYT" ,"CYX" ,"CY" ,"CYP" ,"CYRX" ,"CYR" ,"ZZIT" ,"ZZIX" ,"ZZIP" ,"ZZIET" ,"ZZIEX" ,"ZZIE" ,"ZZIEP" ,"ZZAT" ,"ZZAX" ,"ZZAP" ,"ZZOX" ,"ZZOP" ,"ZZEX" ,"ZZEP" ,"ZZUX" ,"ZZUP" ,"ZZURX" ,"ZZUR" ,"ZZYT" ,"ZZYX" ,"ZZY" ,"ZZYP" ,"ZZYRX" ,"ZZYR" ,"NZIT" ,"NZIX" ,"NZI" ,"NZIP" ,"NZIEX" ,"NZIE" ,"NZIEP" ,"NZAT" ,"NZAX" ,"NZA" ,"NZAP" ,"NZUOX" ,"NZUO" ,"NZOX" ,"NZOP" ,"NZEX" ,"NZE" ,"NZUX" ,"NZU" ,"NZUP" ,"NZURX" ,"NZUR" ,"NZYT" ,"NZYX" ,"NZY" ,"NZYP" ,"NZYRX" ,"NZYR" ,"SIT" ,"SIP" ,"SIEX" ,"SIE" ,"SIEP" ,"SAX" ,"SAP" ,"SUOX" ,"SUO" ,"SUOP" ,"SOT" ,"SOX" ,"SOP" ,"SEX" ,"SEP" ,"SUT" ,"SUX" ,"SUP" ,"SURX" ,"SUR" ,"SYT" ,"SYX" ,"SY" ,"SYP" ,"SYRX" ,"SYR" ,"SSIT" ,"SSIX" ,"SSIP" ,"SSIEX" ,"SSIE" ,"SSIEP" ,"SSAT" ,"SSAX" ,"SSAP" ,"SSOT" ,"SSOX" ,"SSOP" ,"SSEX" ,"SSEP" ,"SSUT" ,"SSUX" ,"SSUP" ,"SSYT" ,"SSYX" ,"SSY" ,"SSYP" ,"SSYRX" ,"SSYR" ,"ZHAT" ,"ZHAX" ,"ZHAP" ,"ZHUOX" ,"ZHUO" ,"ZHUOP" ,"ZHOT" ,"ZHOX" ,"ZHOP" ,"ZHET" ,"ZHEX" ,"ZHEP" ,"ZHUT" ,"ZHUX" ,"ZHUP" ,"ZHURX" ,"ZHUR" ,"ZHYT" ,"ZHYX" ,"ZHY" ,"ZHYP" ,"ZHYRX" ,"ZHYR" ,"CHAT" ,"CHAX" ,"CHAP" ,"CHUOT" ,"CHUOX" ,"CHUO" ,"CHUOP" ,"CHOT" ,"CHOX" ,"CHOP" ,"CHET" ,"CHEX" ,"CHEP" ,"CHUX" ,"CHUP" ,"CHURX" ,"CHUR" ,"CHYT" ,"CHYX" ,"CHY" ,"CHYP" ,"CHYRX" ,"CHYR" ,"RRAX" ,"RRUOX" ,"RRUO" ,"RROT" ,"RROX" ,"RRO" ,"RROP" ,"RRET" ,"RREX" ,"RRE" ,"RREP" ,"RRUT" ,"RRUX" ,"RRU" ,"RRUP" ,"RRURX" ,"RRUR" ,"RRYT" ,"RRYX" ,"RRY" ,"RRYP" ,"RRYRX" ,"RRYR" ,"NRAT" ,"NRAX" ,"NRAP" ,"NROX" ,"NRO" ,"NROP" ,"NRET" ,"NREX" ,"NRE" ,"NREP" ,"NRUT" ,"NRUX" ,"NRU" ,"NRUP" ,"NRURX" ,"NRUR" ,"NRYT" ,"NRYX" ,"NRY" ,"NRYP" ,"NRYRX" ,"NRYR" ,"SHAT" ,"SHAX" ,"SHAP" ,"SHUOX" ,"SHUO" ,"SHUOP" ,"SHOT" ,"SHOX" ,"SHOP" ,"SHET" ,"SHEX" ,"SHEP" ,"SHUT" ,"SHUX" ,"SHUP" ,"SHURX" ,"SHUR" ,"SHYT" ,"SHYX" ,"SHY" ,"SHYP" ,"SHYRX" ,"SHYR" ,"RAX" ,"RUOX" ,"RUO" ,"RUOP" ,"ROT" ,"ROX" ,"ROP" ,"REX" ,"REP" ,"RUT" ,"RUX" ,"RUP" ,"RURX" ,"RUR" ,"RYT" ,"RYX" ,"RYP" ,"RYRX" ,"RYR" ,"JIT" ,"JIX" ,"JIP" ,"JIET" ,"JIEX" ,"JIE" ,"JIEP" ,"JUOT" ,"JUOX" ,"JUO" ,"JUOP" ,"JOX" ,"JOP" ,"JUT" ,"JUX" ,"JUP" ,"JURX" ,"JUR" ,"JYT" ,"JYX" ,"JY" ,"JYP" ,"JYRX" ,"JYR" ,"QIT" ,"QIX" ,"QIP" ,"QIET" ,"QIEX" ,"QIE" ,"QIEP" ,"QUOT" ,"QUOX" ,"QUOP" ,"QOT" ,"QOX" ,"QOP" ,"QUT" ,"QUX" ,"QUP" ,"QURX" ,"QUR" ,"QYT" ,"QYX" ,"QY" ,"QYP" ,"QYRX" ,"QYR" ,"JJIT" ,"JJIX" ,"JJIP" ,"JJIET" ,"JJIEX" ,"JJIE" ,"JJIEP" ,"JJUOX" ,"JJUO" ,"JJUOP" ,"JJOT" ,"JJOX" ,"JJOP" ,"JJUT" ,"JJUX" ,"JJUP" ,"JJURX" ,"JJUR" ,"JJYT" ,"JJYX" ,"JJY" ,"JJYP" ,"NJIT" ,"NJIX" ,"NJI" ,"NJIP" ,"NJIET" ,"NJIEX" ,"NJIE" ,"NJIEP" ,"NJUOX" ,"NJUO" ,"NJOT" ,"NJOX" ,"NJO" ,"NJOP" ,"NJUX" ,"NJU" ,"NJUP" ,"NJURX" ,"NJUR" ,"NJYT" ,"NJYX" ,"NJY" ,"NJYP" ,"NJYRX" ,"NJYR" ,"NYIT" ,"NYIX" ,"NYIP" ,"NYIET" ,"NYIEX" ,"NYIE" ,"NYIEP" ,"NYUOX" ,"NYUO" ,"NYUOP" ,"NYOT" ,"NYOX" ,"NYOP" ,"NYUT" ,"NYUX" ,"NYUP" ,"XIT" ,"XIX" ,"XIP" ,"XIET" ,"XIEX" ,"XIE" ,"XIEP" ,"XUOX" ,"XUO" ,"XOT" ,"XOX" ,"XOP" ,"XYT" ,"XYX" ,"XY" ,"XYP" ,"XYRX" ,"XYR" ,"YIT" ,"YIX" ,"YIP" ,"YIET" ,"YIEX" ,"YIE" ,"YIEP" ,"YUOT" ,"YUOX" ,"YUO" ,"YUOP" ,"YOX" ,"YOP" ,"YUX" ,"YUP" ,"YURX" ,"YUR" ,"YYT" ,"YYX" ,"YYP" ,"YYRX" ,"YYR" ,"LISU_" ,"UH" ,"MYA_" ,"JEU" ,"VAI_" ,"EEN" ,"WEEN" ,"BHEE" ,"MBEE" ,"KPEE" ,"MGBEE" ,"GBEE" ,"DHEE" ,"DHHEE" ,"NDEE" ,"NJEE" ,"NGGEE" ,"HIN" ,"WIN" ,"BHI" ,"MBI" ,"KPI" ,"MGBI" ,"GBI" ,"DHI" ,"DHHI" ,"NGGI" ,"NGAN" ,"HAN" ,"WAN" ,"MBA" ,"KPAN" ,"MGBA" ,"DHHA" ,"NJA" ,"NGGA" ,"OON" ,"WOON" ,"BHOO" ,"BOO" ,"MBOO" ,"KPOO" ,"MGBOO" ,"GBOO" ,"VOO" ,"DHOO" ,"DHHOO" ,"DOO" ,"NDOO" ,"ZOO" ,"ZHOO" ,"JOO" ,"NJOO" ,"NGGOO" ,"GOO" ,"NYOO" ,"HUN" ,"WUN" ,"BHU" ,"MBU" ,"KPU" ,"MGBU" ,"GBU" ,"DHU" ,"DHHU" ,"NGGU" ,"NGON" ,"WON" ,"BHO" ,"MBO" ,"KPO" ,"MGBO" ,"GBO" ,"GBON" ,"DHO" ,"DHHO" ,"NGGO" ,"NGEN" ,"HEN" ,"WEN" ,"BHE" ,"MBE" ,"KPE" ,"KPEN" ,"MGBE" ,"GBE" ,"GBEN" ,"DHE" ,"DHHE" ,"NGGE" ,"NGGEN" ,"GEN" ,"LENGTHENER" ,"NDOLE_" ,"FEENG" ,"KEENG" ,"TING" ,"BANG" ,"DOONG" ,"KUNG" ,"TONG" ,"DO-" ,"JONG" ,"ZEMLYA" ,"BROAD_" ,"NEUTRAL_" ,"YER" ,"BACK_" ,"BLENDED_" ,"MONOCULAR_" ,"BINOCULAR_" ,"MULTIOCULAR_" ,"VZMET" ,"SLAVONIC_" ,"KAVYKA" ,"PAYEROK" ,"DWE" ,"DZWE" ,"ZHWE" ,"DZZE" ,"TSWE" ,"TSSE" ,"TCHE" ,"BAMUM_" ,"TAE" ,"RIEE" ,"LEEEE" ,"MEEEE" ,"NDAA" ,"NJAEM" ,"SUU" ,"SHEUX" ,"SEUX" ,"NUAE" ,"NJUAE" ,"YOQ" ,"YUQ" ,"NSHA" ,"KEUX" ,"PEUX" ,"NTEE" ,"PUE" ,"WUE" ,"REUX" ,"NGKWAEN" ,"PUAE" ,"FOM" ,"LOQ" ,"MBEN" ,"REN" ,"MBAA" ,"NTUU" ,"SAMBA" ,"FAAMAE" ,"KOVUU" ,"KOGHOM" ,"KOQNDON" ,"TUKWENTIS" ,"NJAEMLI" ,"CHINESE_" ,"SHANG" ,"EGYPTOLOGICAL_" ,"HENG" ,"TZ" ,"TRESILLO" ,"CUATRILLO" ,"CUATRILLO_" ,"AV_" ,"FLOURISH" ,"SQUIRREL_" ,"RUM_" ,"VISIGOTHIC_" ,"THORN_" ,"VEND" ,"CON" ,"US" ,"DUM" ,"LUM" ,"MUM" ,"NUM" ,"RUM" ,"TUM" ,"UM" ,"SALTILLO" ,"EPIGRAPHIC_" ,"LONGA" ,"SYLOTI_" ,"NAGRI_" ,"DVISVARA" ,"HASANTA" ,"JHO" ,"DDHO" ,"POETRY_" ,"SIXTEENTH" ,"SIXTEENTHS" ,"PLACEHOLDER_" ,"QUANTITY_" ,"PHAGS-" ,"VOICELESS_" ,"ASPIRATED_" ,"SUPERFIXED_" ,"SAURASHTRA_" ,"HAARU" ,"CANDRABINDU_" ,"PUSHPIKA" ,"GAP_" ,"HEADSTROKE" ,"LI_" ,"HTA" ,"PLOPHU" ,"CALYA" ,"CALYA_" ,"SHYA" ,"REJANG_" ,"NYJA" ,"EA" ,"SSANGSIOS-" ,"SSANGCIEUC-" ,"SSANGTHIEUTH" ,"SSANGYEORINHIEUH" ,"JAVANESE_" ,"PANYANGGA" ,"CECAK" ,"LAYAR" ,"WIGNYAN" ,"KAWI" ,"CEREK" ,"LELET" ,"LELET_" ,"RASWADI" ,"MURDA" ,"TTA_" ,"DDA_" ,"AGUNG" ,"CECAK_" ,"TELU" ,"TARUNG" ,"TOLONG" ,"WULU" ,"WULU_" ,"MELIK" ,"MENDUT" ,"DIRGA_" ,"MURE" ,"KERET" ,"PENGKAL" ,"CAKRA" ,"PANGKON" ,"RERENGGAN" ,"PADA_" ,"ANDAP" ,"MADYA" ,"LUHUR" ,"PANGKAT" ,"LINGSA" ,"LUNGSI" ,"PISELEH" ,"PANGRANGKEP" ,"TIRTA_" ,"TUMETES" ,"ISEN-" ,"ISEN" ,"CHAM_" ,"NGUE" ,"CHHA" ,"NHUE" ,"NHA" ,"NHJA" ,"NUE" ,"PPA" ,"MUE" ,"SS" ,"SPIRAL" ,"REDUPLICATION" ,"LOGOGRAM_" ,"QN" ,"HM" ,"PAO_" ,"VIET_" ,"KHHO" ,"KHIT" ,"IA" ,"UEA" ,"NUENG" ,"SONG" ,"HOI" ,"KOI_" ,"KOI" ,"MEETEI_" ,"MAYEK_" ,"KOK" ,"CHIL" ,"TIL" ,"KHOU" ,"NGOU" ,"THOU" ,"WAI" ,"HUK" ,"PHAM" ,"ATIYA" ,"GOK" ,"JHAM" ,"RAI" ,"DIL" ,"GHOU" ,"DHOU" ,"BHAM" ,"KOK_" ,"LONSUM" ,"LAI_" ,"MIT_" ,"TIL_" ,"NGOU_" ,"ONAP" ,"INAP" ,"ANAP" ,"YENAP" ,"SOUNAP" ,"UNAP" ,"CHEINAP" ,"NUNG" ,"CHEIKHEI" ,"LUM_" ,"IYEK" ,"APUN_" ,"SSANGTIKEUT-" ,"SSANGRIEUL-" ,"YEORINHIEUH-" ,"SSANGMIEUM" ,"PANSIOS-" ,"COMPATIBILITY_" ,"IDEOGRAPH-" ,"F900" ,"F901" ,"F902" ,"F903" ,"F904" ,"F905" ,"F906" ,"F907" ,"F908" ,"F909" ,"F90A" ,"F90B" ,"F90C" ,"F90D" ,"F90E" ,"F90F" ,"F910" ,"F911" ,"F912" ,"F913" ,"F914" ,"F915" ,"F916" ,"F917" ,"F918" ,"F919" ,"F91A" ,"F91B" ,"F91C" ,"F91D" ,"F91E" ,"F91F" ,"F920" ,"F921" ,"F922" ,"F923" ,"F924" ,"F925" ,"F926" ,"F927" ,"F928" ,"F929" ,"F92A" ,"F92B" ,"F92C" ,"F92D" ,"F92E" ,"F92F" ,"F930" ,"F931" ,"F932" ,"F933" ,"F934" ,"F935" ,"F936" ,"F937" ,"F938" ,"F939" ,"F93A" ,"F93B" ,"F93C" ,"F93D" ,"F93E" ,"F93F" ,"F940" ,"F941" ,"F942" ,"F943" ,"F944" ,"F945" ,"F946" ,"F947" ,"F948" ,"F949" ,"F94A" ,"F94B" ,"F94C" ,"F94D" ,"F94E" ,"F94F" ,"F950" ,"F951" ,"F952" ,"F953" ,"F954" ,"F955" ,"F956" ,"F957" ,"F958" ,"F959" ,"F95A" ,"F95B" ,"F95C" ,"F95D" ,"F95E" ,"F95F" ,"F960" ,"F961" ,"F962" ,"F963" ,"F964" ,"F965" ,"F966" ,"F967" ,"F968" ,"F969" ,"F96A" ,"F96B" ,"F96C" ,"F96D" ,"F96E" ,"F96F" ,"F970" ,"F971" ,"F972" ,"F973" ,"F974" ,"F975" ,"F976" ,"F977" ,"F978" ,"F979" ,"F97A" ,"F97B" ,"F97C" ,"F97D" ,"F97E" ,"F97F" ,"F980" ,"F981" ,"F982" ,"F983" ,"F984" ,"F985" ,"F986" ,"F987" ,"F988" ,"F989" ,"F98A" ,"F98B" ,"F98C" ,"F98D" ,"F98E" ,"F98F" ,"F990" ,"F991" ,"F992" ,"F993" ,"F994" ,"F995" ,"F996" ,"F997" ,"F998" ,"F999" ,"F99A" ,"F99B" ,"F99C" ,"F99D" ,"F99E" ,"F99F" ,"F9A0" ,"F9A1" ,"F9A2" ,"F9A3" ,"F9A4" ,"F9A5" ,"F9A6" ,"F9A7" ,"F9A8" ,"F9A9" ,"F9AA" ,"F9AB" ,"F9AC" ,"F9AD" ,"F9AE" ,"F9AF" ,"F9B0" ,"F9B1" ,"F9B2" ,"F9B3" ,"F9B4" ,"F9B5" ,"F9B6" ,"F9B7" ,"F9B8" ,"F9B9" ,"F9BA" ,"F9BB" ,"F9BC" ,"F9BD" ,"F9BE" ,"F9BF" ,"F9C0" ,"F9C1" ,"F9C2" ,"F9C3" ,"F9C4" ,"F9C5" ,"F9C6" ,"F9C7" ,"F9C8" ,"F9C9" ,"F9CA" ,"F9CB" ,"F9CC" ,"F9CD" ,"F9CE" ,"F9CF" ,"F9D0" ,"F9D1" ,"F9D2" ,"F9D3" ,"F9D4" ,"F9D5" ,"F9D6" ,"F9D7" ,"F9D8" ,"F9D9" ,"F9DA" ,"F9DB" ,"F9DC" ,"F9DD" ,"F9DE" ,"F9DF" ,"F9E0" ,"F9E1" ,"F9E2" ,"F9E3" ,"F9E4" ,"F9E5" ,"F9E6" ,"F9E7" ,"F9E8" ,"F9E9" ,"F9EA" ,"F9EB" ,"F9EC" ,"F9ED" ,"F9EE" ,"F9EF" ,"F9F0" ,"F9F1" ,"F9F2" ,"F9F3" ,"F9F4" ,"F9F5" ,"F9F6" ,"F9F7" ,"F9F8" ,"F9F9" ,"F9FA" ,"F9FB" ,"F9FC" ,"F9FD" ,"F9FE" ,"F9FF" ,"FA00" ,"FA01" ,"FA02" ,"FA03" ,"FA04" ,"FA05" ,"FA06" ,"FA07" ,"FA08" ,"FA09" ,"FA0A" ,"FA0B" ,"FA0C" ,"FA0D" ,"FA0E" ,"FA0F" ,"FA10" ,"FA11" ,"FA12" ,"FA13" ,"FA14" ,"FA15" ,"FA16" ,"FA17" ,"FA18" ,"FA19" ,"FA1A" ,"FA1B" ,"FA1C" ,"FA1D" ,"FA1E" ,"FA1F" ,"FA20" ,"FA21" ,"FA22" ,"FA23" ,"FA24" ,"FA25" ,"FA26" ,"FA27" ,"FA28" ,"FA29" ,"FA2A" ,"FA2B" ,"FA2C" ,"FA2D" ,"FA30" ,"FA31" ,"FA32" ,"FA33" ,"FA34" ,"FA35" ,"FA36" ,"FA37" ,"FA38" ,"FA39" ,"FA3A" ,"FA3B" ,"FA3C" ,"FA3D" ,"FA3E" ,"FA3F" ,"FA40" ,"FA41" ,"FA42" ,"FA43" ,"FA44" ,"FA45" ,"FA46" ,"FA47" ,"FA48" ,"FA49" ,"FA4A" ,"FA4B" ,"FA4C" ,"FA4D" ,"FA4E" ,"FA4F" ,"FA50" ,"FA51" ,"FA52" ,"FA53" ,"FA54" ,"FA55" ,"FA56" ,"FA57" ,"FA58" ,"FA59" ,"FA5A" ,"FA5B" ,"FA5C" ,"FA5D" ,"FA5E" ,"FA5F" ,"FA60" ,"FA61" ,"FA62" ,"FA63" ,"FA64" ,"FA65" ,"FA66" ,"FA67" ,"FA68" ,"FA69" ,"FA6A" ,"FA6B" ,"FA6C" ,"FA6D" ,"FA70" ,"FA71" ,"FA72" ,"FA73" ,"FA74" ,"FA75" ,"FA76" ,"FA77" ,"FA78" ,"FA79" ,"FA7A" ,"FA7B" ,"FA7C" ,"FA7D" ,"FA7E" ,"FA7F" ,"FA80" ,"FA81" ,"FA82" ,"FA83" ,"FA84" ,"FA85" ,"FA86" ,"FA87" ,"FA88" ,"FA89" ,"FA8A" ,"FA8B" ,"FA8C" ,"FA8D" ,"FA8E" ,"FA8F" ,"FA90" ,"FA91" ,"FA92" ,"FA93" ,"FA94" ,"FA95" ,"FA96" ,"FA97" ,"FA98" ,"FA99" ,"FA9A" ,"FA9B" ,"FA9C" ,"FA9D" ,"FA9E" ,"FA9F" ,"FAA0" ,"FAA1" ,"FAA2" ,"FAA3" ,"FAA4" ,"FAA5" ,"FAA6" ,"FAA7" ,"FAA8" ,"FAA9" ,"FAAA" ,"FAAB" ,"FAAC" ,"FAAD" ,"FAAE" ,"FAAF" ,"FAB0" ,"FAB1" ,"FAB2" ,"FAB3" ,"FAB4" ,"FAB5" ,"FAB6" ,"FAB7" ,"FAB8" ,"FAB9" ,"FABA" ,"FABB" ,"FABC" ,"FABD" ,"FABE" ,"FABF" ,"FAC0" ,"FAC1" ,"FAC2" ,"FAC3" ,"FAC4" ,"FAC5" ,"FAC6" ,"FAC7" ,"FAC8" ,"FAC9" ,"FACA" ,"FACB" ,"FACC" ,"FACD" ,"FACF" ,"FAD0" ,"FAD1" ,"FAD2" ,"FAD3" ,"FAD4" ,"FAD5" ,"FAD6" ,"FAD7" ,"FAD8" ,"FAD9" ,"FF" ,"FL" ,"FFI" ,"FFL" ,"MEN_" ,"VEW_" ,"YOD_" ,"JUDEO-" ,"SPANISH_" ,"VARIKA" ,"HE_" ,"ZAYIN_" ,"TET_" ,"LAMED_" ,"MEM_" ,"SAMEKH_" ,"TSADI_" ,"QOF_" ,"RESH_" ,"TAV_" ,"WASLA_" ,"BEEH_" ,"PEH_" ,"BEHEH_" ,"TTEHEH_" ,"TEHEH_" ,"TTEH_" ,"VEH_" ,"PEHEH_" ,"DYEH_" ,"NYEH_" ,"TCHEHEH_" ,"DDAHAL_" ,"DAHAL_" ,"DUL_" ,"DDAL_" ,"JEH_" ,"RREH_" ,"GUEH_" ,"NGOEH_" ,"GHUNNA_" ,"RNOON_" ,"DOACHASHMEE_" ,"NG_" ,"OE_" ,"YU_" ,"UIGHUR_" ,"KAZAKH_" ,"MAKSURA_" ,"JEEM_" ,"KHAH_" ,"THEH_" ,"ZAH_" ,"THAL_" ,"SHADDA_" ,"DAMMATAN_" ,"KASRATAN_" ,"DAMMA_" ,"KASRA_" ,"ZAIN_" ,"FATHATAN_" ,"ORNATE_" ,"SALLA_" ,"USED_" ,"KORANIC_" ,"QALA_" ,"ALLAH_" ,"AKBAR_" ,"MOHAMMAD_" ,"SALAM_" ,"RASOUL_" ,"WASALLAM_" ,"WASALLAM" ,"JALLAJALALOUHOU" ,"RIAL_" ,"BISMILLAH_" ,"AR-" ,"RAHMAN_" ,"RAHEEM" ,"SELECTOR-" ,"10" ,"11" ,"PRESENTATION_" ,"BRAKCET" ,"CONJOINING_" ,"SESAME_" ,"CENTRELINE_" ,"TATWEEL_" ,"FRAGMENT" ,"SUKUN_" ,"FULLWIDTH_" ,"HALFWIDTH_" ,"FORMS_" ,"INTERLINEAR_" ,"TERMINATOR" ,"OBJECT_" ,"REPLACEMENT_" ,"CHARACTER" ,"LINEAR_" ,"B008_" ,"B038_" ,"B028_" ,"B061_" ,"B010_" ,"B001_" ,"B045_" ,"B007_" ,"B014_" ,"B051_" ,"B057_" ,"B046_" ,"B036_" ,"B065_" ,"B077_" ,"B044_" ,"B067_" ,"B070_" ,"B081_" ,"B080_" ,"B013_" ,"B073_" ,"B015_" ,"B023_" ,"B006_" ,"B024_" ,"B030_" ,"B052_" ,"B055_" ,"B003_" ,"B072_" ,"B039_" ,"B011_" ,"B050_" ,"B016_" ,"B078_" ,"B021_" ,"B032_" ,"B060_" ,"B027_" ,"B053_" ,"B002_" ,"B026_" ,"B031_" ,"B009_" ,"B041_" ,"B012_" ,"B058_" ,"B059_" ,"B004_" ,"B037_" ,"B005_" ,"B069_" ,"B054_" ,"B075_" ,"B040_" ,"B042_" ,"B017_" ,"B074_" ,"B020_" ,"B025_" ,"A2" ,"B043_" ,"A3" ,"B085_" ,"B071_" ,"B090_" ,"DWO" ,"B048_" ,"B029_" ,"PU2" ,"B062_" ,"PTE" ,"B076_" ,"RA2" ,"B033_" ,"RA3" ,"B068_" ,"RO2" ,"B066_" ,"TA2" ,"B087_" ,"B091_" ,"B018" ,"B019" ,"B022" ,"B034" ,"B047" ,"B049" ,"B056" ,"B063" ,"B064" ,"B079" ,"B082" ,"B083" ,"B086" ,"B089" ,"IDEOGRAM_" ,"B100_" ,"B102_" ,"B104_" ,"B105_" ,"EQUID" ,"B105F_" ,"MARE" ,"B105M_" ,"STALLION" ,"B106F_" ,"B106M_" ,"B107F_" ,"SHE-" ,"GOAT" ,"B107M_" ,"HE-" ,"B108F_" ,"SOW" ,"B108M_" ,"BOAR" ,"B109F_" ,"B109M_" ,"BULL" ,"B120_" ,"B121_" ,"BARLEY" ,"B122_" ,"OLIVE" ,"B123_" ,"SPICE" ,"B125_" ,"CYPERUS" ,"B127_" ,"KAPO" ,"B128_" ,"KANAKO" ,"B130_" ,"OIL" ,"B131_" ,"B132" ,"B133_" ,"AREPA" ,"B135_" ,"MERI" ,"B140_" ,"BRONZE" ,"B141_" ,"B142" ,"B145_" ,"WOOL" ,"B146" ,"B150" ,"B151_" ,"B152" ,"B153" ,"B154" ,"B156_" ,"TURO2" ,"B157" ,"B158" ,"B159_" ,"B160" ,"B161" ,"B162_" ,"GARMENT" ,"B163_" ,"ARMOUR" ,"B164" ,"B165" ,"B166" ,"B167" ,"B168" ,"B169" ,"B170" ,"B171" ,"B172" ,"B173_" ,"MONTH" ,"B174" ,"B176_" ,"B177" ,"B178" ,"B179" ,"B180" ,"B181" ,"B182" ,"B183" ,"B184" ,"B185" ,"B189" ,"B190" ,"B191_" ,"HELMET" ,"B220_" ,"FOOTSTOOL" ,"B225_" ,"BATHTUB" ,"B230_" ,"B231_" ,"B232" ,"B233_" ,"SWORD" ,"B234" ,"B236" ,"B240_" ,"WHEELED_" ,"CHARIOT" ,"B241_" ,"B242_" ,"CHARIOT_" ,"FRAME" ,"B243_" ,"WHEEL" ,"B245" ,"B246" ,"B247_" ,"DIPTE" ,"B248" ,"B249" ,"B251" ,"B252" ,"B253" ,"B254_" ,"DART" ,"B255" ,"B256" ,"B257" ,"B258" ,"B259" ,"VESSEL_" ,"B155" ,"B200" ,"B201" ,"B202" ,"B203" ,"B204" ,"B205" ,"B206" ,"B207" ,"B208" ,"B209" ,"B210" ,"B211" ,"B212" ,"B213" ,"B214" ,"B215" ,"B216" ,"B217" ,"B218" ,"B219" ,"B221" ,"B222" ,"B226" ,"B227" ,"B228" ,"B229" ,"B250" ,"B305" ,"AEGEAN_" ,"NINETY_" ,"WEIGHT_" ,"BASE_" ,"UNIT" ,"SUBUNIT" ,"DRY_" ,"MEASURE_" ,"LIQUID_" ,"ACROPHONIC_" ,"ATTIC_" ,"DRACHMA" ,"TALENTS" ,"STATERS" ,"MNAS" ,"HERAEUM_" ,"PLETHRON" ,"THESPIAN_" ,"HERMIONIAN_" ,"EPIDAUREAN_" ,"CYRENAIC_" ,"DRACHMAS" ,"TROEZENIAN_" ,"MESSENIAN_" ,"CARYSTIAN_" ,"NAXIAN_" ,"DELPHIC_" ,"STRATIAN_" ,"THIRDS_" ,"TALENT_" ,"OBOL_" ,"OBOLS_" ,"METRETES_" ,"KYATHOS_" ,"LITRA_" ,"OUNKIA_" ,"XESTES_" ,"ARTABE_" ,"AROURA_" ,"GRAMMA_" ,"TRYBLION_" ,"SEXTANS_" ,"UNCIA_" ,"SEMUNCIA_" ,"SEXTULA_" ,"DIMIDIA_" ,"SILIQUA_" ,"DENARIUS_" ,"QUINARIUS_" ,"SESTERTIUS_" ,"DUPONDIUS_" ,"CENTURIAL_" ,"PHAISTOS_" ,"DISC_" ,"PEDESTRIAN" ,"PLUMED_" ,"TATTOOED_" ,"CAPTIVE" ,"GAUNTLET" ,"TIARA" ,"CLUB" ,"MANACLES" ,"MATTOCK" ,"SAW" ,"BOOMERANG" ,"CARPENTRY_" ,"PLANE" ,"DOLIUM" ,"COMB" ,"SLING" ,"COLUMN" ,"BEEHIVE" ,"SHIP" ,"HIDE" ,"BULLS_" ,"EAGLE" ,"DOVE" ,"TUNNY" ,"PLANE_" ,"VINE" ,"PAPYRUS" ,"ROSETTE" ,"LILY" ,"OX_" ,"BACK" ,"GRATER" ,"STRAINER" ,"BAND" ,"LYCIAN_" ,"BH" ,"TT" ,"CARIAN_" ,"P2" ,"UUU" ,"LD" ,"D2" ,"SH2" ,"TT2" ,"UUUU" ,"K2" ,"ND" ,"G2" ,"ST2" ,"39" ,"UUU2" ,"MB2" ,"MB3" ,"MB4" ,"LD2" ,"E2" ,"UUU3" ,"EKS" ,"ERS" ,"GOTHIC_" ,"AHSA" ,"BAIRKAN" ,"GIBA" ,"DAGS" ,"AIHVUS" ,"QAIRTHRA" ,"IUJA" ,"HAGL" ,"THIUTH" ,"EIS" ,"KUSMA" ,"LAGUS" ,"MANNA" ,"NAUTHS" ,"JER" ,"URUS" ,"PAIRTHRA" ,"RAIDA" ,"SAUIL" ,"TEIWS" ,"WINJA" ,"FAIHU" ,"IGGWS" ,"OTHAL" ,"UGARITIC_" ,"ALPA" ,"GAMLA" ,"HOTA" ,"DHAL" ,"SAMKA" ,"SADE" ,"QOPA" ,"RASHA" ,"THANNA" ,"AURAMAZDAA" ,"AURAMAZDAA-" ,"AURAMAZDAAHA" ,"XSHAAYATHIYA" ,"DAHYAAUSH" ,"DAHYAAUSH-" ,"BAGA" ,"BUUMISH" ,"DESERET_" ,"OW" ,"GAY" ,"EW" ,"SHAVIAN_" ,"PEEP" ,"KICK" ,"THIGH" ,"SURE" ,"YEA" ,"HUNG" ,"BIB" ,"DEAD" ,"GAG" ,"VOW" ,"THEY" ,"MEASURE" ,"JUDGE" ,"WOE" ,"HA-" ,"LOLL" ,"MIME" ,"IF" ,"EGG" ,"ASH" ,"ADO" ,"ROAR" ,"AGE" ,"OAK" ,"OOZE" ,"AWE" ,"ARE" ,"AIR" ,"ARRAY" ,"IAN" ,"YEW" ,"OSMANYA_" ,"DEEL" ,"SHIIN" ,"CAYN" ,"QAAF" ,"LAAN" ,"MIIN" ,"NUUN" ,"CYPRIOT_" ,"IMPERIAL_" ,"ARAMAIC_" ,"ALEPH" ,"DALETH" ,"YODH" ,"LAMEDH" ,"QOPH" ,"PHOENICIAN_" ,"ALF" ,"GAML" ,"DELT" ,"ZAI" ,"LAMD" ,"SEMK" ,"ROSH" ,"LYDIAN_" ,"KHAROSHTHI_" ,"TTTHA" ,"CAUDA" ,"CRESCENT_" ,"MANGALAM" ,"LOTUS" ,"LINES" ,"ARABIAN_" ,"KHETH" ,"AYN" ,"DHADHE" ,"GHAYN" ,"ZAYN" ,"DHALETH" ,"THAW" ,"THETH" ,"NUMERIC_" ,"AVESTAN_" ,"AAO" ,"AAN" ,"AEE" ,"XVE" ,"NGYE" ,"NGVE" ,"NNE" ,"HME" ,"YYE" ,"SHYE" ,"SSHE" ,"TINY_" ,"RINGS_" ,"INSCRIPTIONAL_" ,"PARTHIAN_" ,"PAHLAVI_" ,"WAW-" ,"AYIN-" ,"MEM-" ,"TURKIC_" ,"ORKHON_" ,"YENISEI_" ,"AB" ,"AEB" ,"AEG" ,"AD" ,"AED" ,"EZ" ,"AEY" ,"AEK" ,"OEK" ,"AEL" ,"ELT" ,"AEN" ,"ENT" ,"ENC" ,"ENY" ,"AENG" ,"IC" ,"EC" ,"IQ" ,"OQ" ,"AR" ,"AER" ,"AES" ,"AET" ,"BASH" ,"RUMI_" ,"KAITHI_" ,"ENUMERATION_" ,"CUNEIFORM_" ,"BAD" ,"GAN2_" ,"TENU" ,"IGI" ,"LAGAR_" ,"GUNU" ,"MUSH" ,"SAG" ,"AB_" ,"ASH2" ,"DUN3_" ,"IGI_" ,"IMIN" ,"LAGAB" ,"SHESH" ,"AB2" ,"AB2_" ,"BALAG" ,"SHA3" ,"TAK4" ,"AK" ,"AK_" ,"ERIN2" ,"SHITA_" ,"GISH" ,"AL_" ,"DIM2" ,"KAD3" ,"USH" ,"ALAN" ,"AMAR" ,"AMAR_" ,"NAGA_" ,"OPPOSING_" ,"NAGA" ,"ANSHE" ,"APIN" ,"ARAD" ,"ARAD_" ,"ARKAB" ,"ASAL2" ,"ASH_" ,"ZIDA_" ,"KABA_" ,"TUG2_" ,"ASHGAB" ,"BAG3" ,"BAHAR2" ,"BAL" ,"BAL_" ,"BARA2" ,"BI_" ,"BULUG" ,"BULUG_" ,"BUR2" ,"DAG_" ,"KISIM5_" ,"MASH" ,"GIR2" ,"GUD" ,"IR_" ,"KAK" ,"LU_" ,"MASH2" ,"PAP_" ,"U2_" ,"DAM" ,"DAR" ,"DARA3" ,"DARA4" ,"DIB" ,"DIM" ,"DIM_" ,"DIN" ,"DIN_" ,"KASKAL_" ,"GUNU_" ,"DU_" ,"SHESHIG" ,"DUB" ,"DUB_" ,"ESH2" ,"DUB2" ,"DUGUD" ,"DUH" ,"DUN" ,"DUN3" ,"DUN4" ,"DUR2" ,"E2_" ,"SAL" ,"EDIN" ,"EGIR" ,"GAN2" ,"EREN" ,"EZEN" ,"EZEN_" ,"LAL" ,"LAL_" ,"KASKAL" ,"KU3" ,"U2" ,"GA2" ,"GA2_" ,"TENU_" ,"TAB" ,"ASH2_" ,"BUR_" ,"GI4" ,"GI4_" ,"GIR2_" ,"HAL" ,"HAL_" ,"HI_" ,"HUB2" ,"ISH_" ,"HU_" ,"KID" ,"KID_" ,"KU3_" ,"SAR" ,"SHE_" ,"SHID" ,"UD_" ,"GABA" ,"GABA_" ,"GAD" ,"GAD_" ,"GAR_" ,"GAL_" ,"GALAM" ,"GAM" ,"GAR3" ,"GASHAN" ,"GESHTIN" ,"GESHTIN_" ,"GIDIM" ,"GIR3" ,"GIR3_" ,"GISAL" ,"GISH_" ,"GU_" ,"GU2" ,"GU2_" ,"KAK_" ,"SAL_" ,"TUG2" ,"GUD_" ,"LUGAL" ,"GUL" ,"GUM" ,"GUM_" ,"GUR7" ,"GURUN" ,"GURUSH" ,"KIN" ,"HUB2_" ,"LISH" ,"HUL2" ,"IB" ,"IDIM" ,"IDIM_" ,"IG" ,"SHIR_" ,"IL" ,"IL_" ,"IL2" ,"IM_" ,"ISH" ,"AD_" ,"SHA3_" ,"NUNUZ" ,"SIG" ,"SUHUR" ,"UMUM_" ,"KA2" ,"KA2_" ,"KAB" ,"KAD2" ,"KAD4" ,"KAD5" ,"KAD5_" ,"KAL" ,"KAL_" ,"KAM2" ,"KAM4" ,"LAGAB_" ,"KESH2" ,"KI_" ,"KISAL" ,"KISH" ,"KISIM5" ,"KU4" ,"KU4_" ,"KU7" ,"KUL" ,"KUL_" ,"KUN" ,"KUR_" ,"KUSHU2" ,"KWU318" ,"LUL" ,"SHU2" ,"SHU2_" ,"TAG" ,"LAGAR" ,"LAHSHU" ,"LIL" ,"LIMMU2" ,"LU2" ,"LU2_" ,"ESH2_" ,"KAD3_" ,"SI_" ,"SIK2_" ,"LU3" ,"LUGAL_" ,"LUH" ,"MA_" ,"MA2" ,"MAH" ,"MAR" ,"MES" ,"MIN" ,"MUG" ,"MUG_" ,"MUNSUB" ,"MURGU2" ,"MUSH_" ,"MUSH3" ,"MUSH3_" ,"NA2" ,"INVERTED" ,"SHU_" ,"NAGAR" ,"NAM_" ,"NUTILLU" ,"NAM" ,"NAM2" ,"NE_" ,"NI2" ,"NIM" ,"NIM_" ,"NINDA2" ,"NINDA2_" ,"NISAG" ,"NU11" ,"NUNUZ_" ,"SILA3" ,"PAD" ,"PAN" ,"PESH2" ,"PIRIG" ,"PIRIG_" ,"RAB" ,"SAG_" ,"UB" ,"SANGA2" ,"SHA6" ,"SHAB6" ,"SHAR2" ,"TAB_" ,"SHEG9" ,"SHEN" ,"SHESH2" ,"SHESHLAM" ,"SHID_" ,"SHIM" ,"SHIM_" ,"SHINIG" ,"SHIR" ,"SHITA" ,"SHUBUR" ,"SIG4" ,"SIG4_" ,"SIK2" ,"SUD" ,"SUD2" ,"SUMASH" ,"SUR9" ,"DISH_" ,"TAG_" ,"TI_" ,"TIR" ,"TUR_" ,"ZA_" ,"SUR_" ,"SHESHIG_" ,"UDUG" ,"UMBIN" ,"UMUM" ,"UN_" ,"UR2" ,"UR2_" ,"UR4" ,"URI" ,"URI3" ,"URU" ,"URU_" ,"URUDA" ,"URUDA_" ,"USH_" ,"USHX" ,"USH2" ,"USHUMX" ,"UTUKI" ,"UZ3" ,"UZ3_" ,"UZU" ,"ZAG" ,"ZAMX" ,"ZE2" ,"ZI_" ,"ZI3" ,"ZIB" ,"ZIB_" ,"ZIG" ,"ZIZ2" ,"ZU5" ,"ZU5_" ,"ZUBUR" ,"ZUM" ,"GESH2" ,"GESHU" ,"SHAR2_" ,"SHARU" ,"SHARU_" ,"BURU" ,"BURU_" ,"ESH16" ,"ESH21" ,"LIMMU" ,"LIMMU4" ,"LIMMU_" ,"ASH9" ,"IMIN3" ,"IMIN_" ,"USSU" ,"USSU3" ,"ILIMMU" ,"ILIMMU3" ,"ILIMMU4" ,"ILIMMU_" ,"BAN2" ,"BAN2_" ,"NIGIDAMIN" ,"NIGIDAESH" ,"ESHE3" ,"SIXTHS_" ,"ASSYRIAN_" ,"EGYPTIAN_" ,"HIEROGLYPH_" ,"A001" ,"A002" ,"A003" ,"A004" ,"A005" ,"A005A" ,"A006" ,"A006A" ,"A006B" ,"A007" ,"A008" ,"A009" ,"A010" ,"A011" ,"A012" ,"A013" ,"A014" ,"A014A" ,"A015" ,"A016" ,"A017" ,"A017A" ,"A018" ,"A019" ,"A020" ,"A021" ,"A022" ,"A023" ,"A024" ,"A025" ,"A026" ,"A027" ,"A028" ,"A029" ,"A030" ,"A031" ,"A032" ,"A032A" ,"A033" ,"A034" ,"A035" ,"A036" ,"A037" ,"A038" ,"A039" ,"A040" ,"A040A" ,"A041" ,"A042" ,"A042A" ,"A043" ,"A043A" ,"A044" ,"A045" ,"A045A" ,"A046" ,"A047" ,"A048" ,"A049" ,"A050" ,"A051" ,"A052" ,"A053" ,"A054" ,"A055" ,"A056" ,"A057" ,"A058" ,"A059" ,"A060" ,"A061" ,"A062" ,"A063" ,"A064" ,"A065" ,"A066" ,"A067" ,"A068" ,"A069" ,"A070" ,"B001" ,"B002" ,"B003" ,"B004" ,"B005" ,"B005A" ,"B006" ,"B007" ,"B008" ,"B009" ,"C001" ,"C002" ,"C002A" ,"C002B" ,"C002C" ,"C003" ,"C004" ,"C005" ,"C006" ,"C007" ,"C008" ,"C009" ,"C010" ,"C010A" ,"C011" ,"C012" ,"C013" ,"C014" ,"C015" ,"C016" ,"C017" ,"C018" ,"C019" ,"C020" ,"C021" ,"C022" ,"C023" ,"C024" ,"D001" ,"D002" ,"D003" ,"D004" ,"D005" ,"D006" ,"D007" ,"D008" ,"D008A" ,"D009" ,"D010" ,"D011" ,"D012" ,"D013" ,"D014" ,"D015" ,"D016" ,"D017" ,"D018" ,"D019" ,"D020" ,"D021" ,"D022" ,"D023" ,"D024" ,"D025" ,"D026" ,"D027" ,"D027A" ,"D028" ,"D029" ,"D030" ,"D031" ,"D031A" ,"D032" ,"D033" ,"D034" ,"D034A" ,"D035" ,"D036" ,"D037" ,"D038" ,"D039" ,"D040" ,"D041" ,"D042" ,"D043" ,"D044" ,"D045" ,"D046" ,"D046A" ,"D047" ,"D048" ,"D048A" ,"D049" ,"D050" ,"D050A" ,"D050B" ,"D050C" ,"D050D" ,"D050E" ,"D050F" ,"D050G" ,"D050H" ,"D050I" ,"D051" ,"D052" ,"D052A" ,"D053" ,"D054" ,"D054A" ,"D055" ,"D056" ,"D057" ,"D058" ,"D059" ,"D060" ,"D061" ,"D062" ,"D063" ,"D064" ,"D065" ,"D066" ,"D067" ,"D067A" ,"D067B" ,"D067C" ,"D067D" ,"D067E" ,"D067F" ,"D067G" ,"D067H" ,"E001" ,"E002" ,"E003" ,"E004" ,"E005" ,"E006" ,"E007" ,"E008" ,"E008A" ,"E009" ,"E009A" ,"E010" ,"E011" ,"E012" ,"E013" ,"E014" ,"E015" ,"E016" ,"E016A" ,"E017" ,"E017A" ,"E018" ,"E019" ,"E020" ,"E020A" ,"E021" ,"E022" ,"E023" ,"E024" ,"E025" ,"E026" ,"E027" ,"E028" ,"E028A" ,"E029" ,"E030" ,"E031" ,"E032" ,"E033" ,"E034" ,"E034A" ,"E036" ,"E037" ,"E038" ,"F001" ,"F001A" ,"F002" ,"F003" ,"F004" ,"F005" ,"F006" ,"F007" ,"F008" ,"F009" ,"F010" ,"F011" ,"F012" ,"F013" ,"F013A" ,"F014" ,"F015" ,"F016" ,"F017" ,"F018" ,"F019" ,"F020" ,"F021" ,"F021A" ,"F022" ,"F023" ,"F024" ,"F025" ,"F026" ,"F027" ,"F028" ,"F029" ,"F030" ,"F031" ,"F031A" ,"F032" ,"F033" ,"F034" ,"F035" ,"F036" ,"F037" ,"F037A" ,"F038" ,"F038A" ,"F039" ,"F040" ,"F041" ,"F042" ,"F043" ,"F044" ,"F045" ,"F045A" ,"F046" ,"F046A" ,"F047" ,"F047A" ,"F048" ,"F049" ,"F050" ,"F051" ,"F051A" ,"F051B" ,"F051C" ,"F052" ,"F053" ,"G001" ,"G002" ,"G003" ,"G004" ,"G005" ,"G006" ,"G006A" ,"G007" ,"G007A" ,"G007B" ,"G008" ,"G009" ,"G010" ,"G011" ,"G011A" ,"G012" ,"G013" ,"G014" ,"G015" ,"G016" ,"G017" ,"G018" ,"G019" ,"G020" ,"G020A" ,"G021" ,"G022" ,"G023" ,"G024" ,"G025" ,"G026" ,"G026A" ,"G027" ,"G028" ,"G029" ,"G030" ,"G031" ,"G032" ,"G033" ,"G034" ,"G035" ,"G036" ,"G036A" ,"G037" ,"G037A" ,"G038" ,"G039" ,"G040" ,"G041" ,"G042" ,"G043" ,"G043A" ,"G044" ,"G045" ,"G045A" ,"G046" ,"G047" ,"G048" ,"G049" ,"G050" ,"G051" ,"G052" ,"G053" ,"G054" ,"H001" ,"H002" ,"H003" ,"H004" ,"H005" ,"H006" ,"H006A" ,"H007" ,"H008" ,"I001" ,"I002" ,"I003" ,"I004" ,"I005" ,"I005A" ,"I006" ,"I007" ,"I008" ,"I009" ,"I009A" ,"I010" ,"I010A" ,"I011" ,"I011A" ,"I012" ,"I013" ,"I014" ,"I015" ,"K001" ,"K002" ,"K003" ,"K004" ,"K005" ,"K006" ,"K007" ,"K008" ,"L001" ,"L002" ,"L002A" ,"L003" ,"L004" ,"L005" ,"L006" ,"L006A" ,"L007" ,"L008" ,"M001" ,"M001A" ,"M001B" ,"M002" ,"M003" ,"M003A" ,"M004" ,"M005" ,"M006" ,"M007" ,"M008" ,"M009" ,"M010" ,"M010A" ,"M011" ,"M012" ,"M012A" ,"M012B" ,"M012C" ,"M012D" ,"M012E" ,"M012F" ,"M012G" ,"M012H" ,"M013" ,"M014" ,"M015" ,"M015A" ,"M016" ,"M016A" ,"M017" ,"M017A" ,"M018" ,"M019" ,"M020" ,"M021" ,"M022" ,"M022A" ,"M023" ,"M024" ,"M024A" ,"M025" ,"M026" ,"M027" ,"M028" ,"M028A" ,"M029" ,"M030" ,"M031" ,"M031A" ,"M032" ,"M033" ,"M033A" ,"M033B" ,"M034" ,"M035" ,"M036" ,"M037" ,"M038" ,"M039" ,"M040" ,"M040A" ,"M041" ,"M042" ,"M043" ,"M044" ,"N001" ,"N002" ,"N003" ,"N004" ,"N005" ,"N006" ,"N007" ,"N008" ,"N009" ,"N010" ,"N011" ,"N012" ,"N013" ,"N014" ,"N015" ,"N016" ,"N017" ,"N018" ,"N018A" ,"N018B" ,"N019" ,"N020" ,"N021" ,"N022" ,"N023" ,"N024" ,"N025" ,"N025A" ,"N026" ,"N027" ,"N028" ,"N029" ,"N030" ,"N031" ,"N032" ,"N033" ,"N033A" ,"N034" ,"N034A" ,"N035" ,"N035A" ,"N036" ,"N037" ,"N037A" ,"N038" ,"N039" ,"N040" ,"N041" ,"N042" ,"NL001" ,"NL002" ,"NL003" ,"NL004" ,"NL005" ,"NL005A" ,"NL006" ,"NL007" ,"NL008" ,"NL009" ,"NL010" ,"NL011" ,"NL012" ,"NL013" ,"NL014" ,"NL015" ,"NL016" ,"NL017" ,"NL017A" ,"NL018" ,"NL019" ,"NL020" ,"NU001" ,"NU002" ,"NU003" ,"NU004" ,"NU005" ,"NU006" ,"NU007" ,"NU008" ,"NU009" ,"NU010" ,"NU010A" ,"NU011" ,"NU011A" ,"NU012" ,"NU013" ,"NU014" ,"NU015" ,"NU016" ,"NU017" ,"NU018" ,"NU018A" ,"NU019" ,"NU020" ,"NU021" ,"NU022" ,"NU022A" ,"O001" ,"O001A" ,"O002" ,"O003" ,"O004" ,"O005" ,"O005A" ,"O006" ,"O006A" ,"O006B" ,"O006C" ,"O006D" ,"O006E" ,"O006F" ,"O007" ,"O008" ,"O009" ,"O010" ,"O010A" ,"O010B" ,"O010C" ,"O011" ,"O012" ,"O013" ,"O014" ,"O015" ,"O016" ,"O017" ,"O018" ,"O019" ,"O019A" ,"O020" ,"O020A" ,"O021" ,"O022" ,"O023" ,"O024" ,"O024A" ,"O025" ,"O025A" ,"O026" ,"O027" ,"O028" ,"O029" ,"O029A" ,"O030" ,"O030A" ,"O031" ,"O032" ,"O033" ,"O033A" ,"O034" ,"O035" ,"O036" ,"O036A" ,"O036B" ,"O036C" ,"O036D" ,"O037" ,"O038" ,"O039" ,"O040" ,"O041" ,"O042" ,"O043" ,"O044" ,"O045" ,"O046" ,"O047" ,"O048" ,"O049" ,"O050" ,"O050A" ,"O050B" ,"O051" ,"P001" ,"P001A" ,"P002" ,"P003" ,"P003A" ,"P004" ,"P005" ,"P006" ,"P007" ,"P008" ,"P009" ,"P010" ,"P011" ,"Q001" ,"Q002" ,"Q003" ,"Q004" ,"Q005" ,"Q006" ,"Q007" ,"R001" ,"R002" ,"R002A" ,"R003" ,"R003A" ,"R003B" ,"R004" ,"R005" ,"R006" ,"R007" ,"R008" ,"R009" ,"R010" ,"R010A" ,"R011" ,"R012" ,"R013" ,"R014" ,"R015" ,"R016" ,"R016A" ,"R017" ,"R018" ,"R019" ,"R020" ,"R021" ,"R022" ,"R023" ,"R024" ,"R025" ,"R026" ,"R027" ,"R028" ,"R029" ,"S001" ,"S002" ,"S002A" ,"S003" ,"S004" ,"S005" ,"S006" ,"S006A" ,"S007" ,"S008" ,"S009" ,"S010" ,"S011" ,"S012" ,"S013" ,"S014" ,"S014A" ,"S014B" ,"S015" ,"S016" ,"S017" ,"S017A" ,"S018" ,"S019" ,"S020" ,"S021" ,"S022" ,"S023" ,"S024" ,"S025" ,"S026" ,"S026A" ,"S026B" ,"S027" ,"S028" ,"S029" ,"S030" ,"S031" ,"S032" ,"S033" ,"S034" ,"S035" ,"S035A" ,"S036" ,"S037" ,"S038" ,"S039" ,"S040" ,"S041" ,"S042" ,"S043" ,"S044" ,"S045" ,"S046" ,"T001" ,"T002" ,"T003" ,"T003A" ,"T004" ,"T005" ,"T006" ,"T007" ,"T007A" ,"T008" ,"T008A" ,"T009" ,"T009A" ,"T010" ,"T011" ,"T011A" ,"T012" ,"T013" ,"T014" ,"T015" ,"T016" ,"T016A" ,"T017" ,"T018" ,"T019" ,"T020" ,"T021" ,"T022" ,"T023" ,"T024" ,"T025" ,"T026" ,"T027" ,"T028" ,"T029" ,"T030" ,"T031" ,"T032" ,"T032A" ,"T033" ,"T033A" ,"T034" ,"T035" ,"T036" ,"U001" ,"U002" ,"U003" ,"U004" ,"U005" ,"U006" ,"U006A" ,"U006B" ,"U007" ,"U008" ,"U009" ,"U010" ,"U011" ,"U012" ,"U013" ,"U014" ,"U015" ,"U016" ,"U017" ,"U018" ,"U019" ,"U020" ,"U021" ,"U022" ,"U023" ,"U023A" ,"U024" ,"U025" ,"U026" ,"U027" ,"U028" ,"U029" ,"U029A" ,"U030" ,"U031" ,"U032" ,"U032A" ,"U033" ,"U034" ,"U035" ,"U036" ,"U037" ,"U038" ,"U039" ,"U040" ,"U041" ,"U042" ,"V001" ,"V001A" ,"V001B" ,"V001C" ,"V001D" ,"V001E" ,"V001F" ,"V001G" ,"V001H" ,"V001I" ,"V002" ,"V002A" ,"V003" ,"V004" ,"V005" ,"V006" ,"V007" ,"V007A" ,"V007B" ,"V008" ,"V009" ,"V010" ,"V011" ,"V011A" ,"V011B" ,"V011C" ,"V012" ,"V012A" ,"V012B" ,"V013" ,"V014" ,"V015" ,"V016" ,"V017" ,"V018" ,"V019" ,"V020" ,"V020A" ,"V020B" ,"V020C" ,"V020D" ,"V020E" ,"V020F" ,"V020G" ,"V020H" ,"V020I" ,"V020J" ,"V020K" ,"V020L" ,"V021" ,"V022" ,"V023" ,"V023A" ,"V024" ,"V025" ,"V026" ,"V027" ,"V028" ,"V028A" ,"V029" ,"V029A" ,"V030" ,"V030A" ,"V031" ,"V031A" ,"V032" ,"V033" ,"V033A" ,"V034" ,"V035" ,"V036" ,"V037" ,"V037A" ,"V038" ,"V039" ,"V040" ,"V040A" ,"W001" ,"W002" ,"W003" ,"W003A" ,"W004" ,"W005" ,"W006" ,"W007" ,"W008" ,"W009" ,"W009A" ,"W010" ,"W010A" ,"W011" ,"W012" ,"W013" ,"W014" ,"W014A" ,"W015" ,"W016" ,"W017" ,"W017A" ,"W018" ,"W018A" ,"W019" ,"W020" ,"W021" ,"W022" ,"W023" ,"W024" ,"W024A" ,"W025" ,"X001" ,"X002" ,"X003" ,"X004" ,"X004A" ,"X004B" ,"X005" ,"X006" ,"X006A" ,"X007" ,"X008" ,"X008A" ,"Y001" ,"Y001A" ,"Y002" ,"Y003" ,"Y004" ,"Y005" ,"Y006" ,"Y007" ,"Y008" ,"Z001" ,"Z002" ,"Z002A" ,"Z002B" ,"Z002C" ,"Z002D" ,"Z003" ,"Z003A" ,"Z003B" ,"Z004" ,"Z004A" ,"Z005" ,"Z005A" ,"Z006" ,"Z007" ,"Z008" ,"Z009" ,"Z010" ,"Z011" ,"Z012" ,"Z013" ,"Z014" ,"Z015" ,"Z015A" ,"Z015B" ,"Z015C" ,"Z015D" ,"Z015E" ,"Z015F" ,"Z015G" ,"Z015H" ,"Z015I" ,"Z016" ,"Z016A" ,"Z016B" ,"Z016C" ,"Z016D" ,"Z016E" ,"Z016F" ,"Z016G" ,"Z016H" ,"AA001" ,"AA002" ,"AA003" ,"AA004" ,"AA005" ,"AA006" ,"AA007" ,"AA007A" ,"AA007B" ,"AA008" ,"AA009" ,"AA010" ,"AA011" ,"AA012" ,"AA013" ,"AA014" ,"AA015" ,"AA016" ,"AA017" ,"AA018" ,"AA019" ,"AA020" ,"AA021" ,"AA022" ,"AA023" ,"AA024" ,"AA025" ,"AA026" ,"AA027" ,"AA028" ,"AA029" ,"AA030" ,"AA031" ,"AA032" ,"BYZANTINE_" ,"DASEIA" ,"OXEIA_" ,"EKFONITIKON" ,"DIPLI" ,"VAREIA_" ,"KATHISTI" ,"SYRMATIKI" ,"PARAKLITIKI" ,"YPOKRISIS" ,"YPOKRISIS_" ,"KREMASTI" ,"APESO_" ,"EXO_" ,"KENTIMATA" ,"APOSTROFOS" ,"APOSTROFOS_" ,"SYNEVMA" ,"THITA" ,"OLIGON_" ,"ARCHAION" ,"GORGON_" ,"PSILON" ,"CHAMILON" ,"VATHY" ,"ISON_" ,"KENTIMA_" ,"KENTIMATA_" ,"SAXIMATA" ,"PARICHON" ,"STAVROS_" ,"APODEXIA" ,"OXEIAI_" ,"VAREIAI_" ,"APODERMA_" ,"APOTHEMA" ,"KLASMA" ,"REVMA" ,"PIASMA_" ,"TINAGMA" ,"ANATRICHISMA" ,"SEISMA" ,"SYNAGMA_" ,"META_" ,"STAVROU" ,"OYRANISMA_" ,"THEMA" ,"LEMOI" ,"DYO" ,"TRIA" ,"TESSERA" ,"KRATIMATA" ,"NEO" ,"FTHORA_" ,"IMIFTHORA" ,"TROMIKON_" ,"KATAVA_" ,"TROMIKON" ,"PELASTON" ,"PSIFISTON" ,"KONTEVMA" ,"CHOREVMA_" ,"RAPISMA" ,"PARAKALESMA_" ,"PARAKLITIKI_" ,"ICHADIN" ,"NANA" ,"PETASMA" ,"KONTEVMA_" ,"ALLO" ,"STRAGGISMATA" ,"GRONTHISMATA" ,"PETASTI" ,"KOUFISMA" ,"PETASTOKOUFISMA" ,"KRATIMOKOUFISMA" ,"PELASTON_" ,"NEO_" ,"ANO" ,"YPSILI" ,"APOSTROFOI_" ,"SYNDESMOS_" ,"YPORROI" ,"KRATIMOYPORROON" ,"ELAFRON" ,"CHAMILI" ,"MIKRON_" ,"ISON" ,"PSIFISTON_" ,"OMALON" ,"ANTIKENOMA" ,"LYGISMA" ,"ETERON_" ,"PARAKALESMA" ,"KYLISMA" ,"ANTIKENOKYLISMA" ,"EKSTREPTON" ,"SYRMA" ,"EPEGERMA" ,"SEISMA_" ,"XIRON_" ,"TROMIKOPSIFISTON" ,"PSIFISTOLYGISMA" ,"TROMIKOLYGISMA" ,"TROMIKOPARAKALESMA" ,"PSIFISTOPARAKALESMA" ,"TROMIKOSYNAGMA" ,"PSIFISTOSYNAGMA" ,"GORGOSYNTHETON" ,"ARGOSYNTHETON" ,"THEMATISMOS_" ,"ESO" ,"EXO" ,"THEMA_" ,"APLOUN" ,"THES_" ,"APOTHES" ,"KATAVASMA" ,"ENDOFONON" ,"YFEN_" ,"KATO" ,"STAVROS" ,"KLASMA_" ,"DIPLI_" ,"KRATIMA_" ,"APLI" ,"TRIPLI" ,"TETRAPLI" ,"LEIMMA_" ,"ENOS_" ,"CHRONOU" ,"DYO_" ,"CHRONON" ,"TRION_" ,"TESSARON_" ,"IMISEOS_" ,"PARESTIGMENON_" ,"ARISTERA" ,"DEXIA" ,"DIGORGON" ,"DIGORGON_" ,"ARISTERA_" ,"TRIGORGON" ,"ARGON" ,"IMIDIARGON" ,"DIARGON" ,"AGOGI_" ,"POLI_" ,"ARGI" ,"ARGOTERI" ,"METRIA" ,"MESI" ,"GORGI" ,"GORGOTERI" ,"MARTYRIA_" ,"PROTOS_" ,"ICHOS" ,"ALLI_" ,"DEYTEROS_" ,"TRITOS_" ,"TRIFONIAS" ,"TETARTOS_" ,"LEGETOS_" ,"PLAGIOS_" ,"ISAKIA_" ,"TELOUS_" ,"ICHIMATOS" ,"FANEROSIS_" ,"TETRAFONIAS" ,"MONOFONIAS" ,"DIFONIAS" ,"VARYS_" ,"PROTOVARYS_" ,"GORTHMIKON_" ,"DIPLOUN" ,"ENARXIS_" ,"VOU" ,"IMIFONON" ,"IMIFTHORON" ,"ARCHAION_" ,"DEYTEROU_" ,"ICHOU" ,"DIATONIKI_" ,"NAOS_" ,"SKLIRON_" ,"DIATONON_" ,"MALAKON_" ,"CHROMA_" ,"FHTORA_" ,"VASIS" ,"SYNAFI" ,"NENANO" ,"CHROA_" ,"ZYGOS" ,"KLITON" ,"SPATHI" ,"YFESIS_" ,"TETARTIMORION" ,"ENARMONIOS_" ,"ANTIFONIA" ,"TRITIMORION" ,"DIESIS_" ,"APLI_" ,"DODEKATA" ,"MONOGRAMMOS_" ,"TESSERA_" ,"DIGRAMMOS_" ,"EX_" ,"TRIGRAMMOS_" ,"OKTO_" ,"GENIKI_" ,"DIESIS" ,"YFESIS" ,"DIASTOLI_" ,"MIKRI" ,"MEGALI" ,"THESEOS" ,"SIMANSIS_" ,"THESEOS_" ,"DISIMOU" ,"TRISIMOU" ,"TETRASIMOU" ,"ARSEOS" ,"ARSEOS_" ,"DIGRAMMA_" ,"GG" ,"DIFTOGGOS_" ,"ARKTIKO_" ,"MESO" ,"BARLINE" ,"SEGNO" ,"CAPO" ,"CODA" ,"REPEATED_" ,"FIGURE-" ,"FERMATA_" ,"BREATH_" ,"CAESURA" ,"BRACE" ,"STAFF" ,"FIVE-" ,"STRING_" ,"FRETBOARD" ,"CLEF" ,"CLEF_" ,"OTTAVA_" ,"ALTA" ,"BASSA" ,"DRUM_" ,"CLEF-" ,"SHARP" ,"FLAT" ,"COMMON_" ,"TIME" ,"CUT_" ,"QUINDICESIMA_" ,"MULTI_" ,"WHOLE_" ,"SIXTY-" ,"NOTEHEAD" ,"NOTEHEAD_" ,"VOID_" ,"NULL_" ,"CLUSTER_" ,"SPRECHGESANG_" ,"TREMOLO-" ,"FINGERED_" ,"AUGMENTATION_" ,"FLAG-" ,"SLUR" ,"PHRASE" ,"STACCATO" ,"TENUTO" ,"STACCATISSIMO" ,"MARCATO" ,"MARCATO-" ,"ACCENT-" ,"LOURE" ,"ARPEGGIATO_" ,"DOIT" ,"RIP" ,"FLIP" ,"SMEAR" ,"BEND" ,"RINFORZANDO" ,"SUBITO" ,"PIANO" ,"MEZZO" ,"FORTE" ,"CRESCENDO" ,"DECRESCENDO" ,"GRACE_" ,"NOTE_" ,"TR" ,"TURN" ,"TURN_" ,"ORNAMENT_" ,"STROKE-" ,"HAUPTSTIMME" ,"NEBENSTIMME" ,"STIMME" ,"HARMONIC" ,"SNAP_" ,"PIZZICATO" ,"PEDAL_" ,"GLISSANDO_" ,"FINGERNAILS" ,"DAMP" ,"DAMP_" ,"MAXIMA" ,"BREVIS" ,"SEMIBREVIS_" ,"MINIMA" ,"MINIMA_" ,"SEMIMINIMA_" ,"FUSA_" ,"LONGA_" ,"PERFECTA_" ,"IMPERFECTA_" ,"BREVIS_" ,"TEMPUS_" ,"PERFECTUM_" ,"CUM_" ,"PROLATIONE_" ,"PERFECTA" ,"IMPERFECTA" ,"DIMINUTION-" ,"IMPERFECTUM_" ,"CROIX" ,"GREGORIAN_" ,"VIRGA" ,"PODATUS" ,"CLIVIS" ,"SCANDICUS" ,"CLIMACUS" ,"TORCULUS" ,"PORRECTUS" ,"PORRECTUS_" ,"FLEXUS" ,"SCANDICUS_" ,"TORCULUS_" ,"RESUPINUS" ,"PES_" ,"SUBPUNCTIS" ,"VOCAL_" ,"SYMBOL-" ,"19" ,"20" ,"21" ,"22" ,"50" ,"51" ,"52" ,"53" ,"54" ,"INSTRUMENTAL_" ,"29" ,"30" ,"32" ,"40" ,"42" ,"43" ,"49" ,"LEIMMA" ,"HEAVENLY_" ,"HUMAN_" ,"EARTHLY_" ,"HUMAN" ,"TETRAGRAM_" ,"MIRED" ,"BARRIER" ,"CONTRARIETY" ,"ASCENT" ,"BRANCHING_" ,"DEFECTIVENESS_" ,"DISTORTION" ,"DIVERGENCE" ,"YOUTHFULNESS" ,"PENETRATION" ,"CONTACT" ,"ADVANCE" ,"RELEASE" ,"RESISTANCE" ,"EASE" ,"JOY" ,"CONTENTION" ,"ENDEAVOUR" ,"DUTIES" ,"CHANGE" ,"DECISIVENESS" ,"BOLD_" ,"RESOLUTION" ,"PACKING" ,"LEGION" ,"CLOSENESS" ,"KINSHIP" ,"GATHERING" ,"STRENGTH" ,"PURITY" ,"FULLNESS" ,"RESIDENCE" ,"LAW_" ,"MODEL" ,"GOING_" ,"ENCOUNTERS" ,"STOVE" ,"GREATNESS" ,"ENLARGEMENT" ,"PATTERN" ,"RITUAL" ,"FLIGHT" ,"VASTNESS_" ,"WASTING" ,"CONSTANCY" ,"ETERNITY" ,"UNITY" ,"DIMINISHMENT" ,"GUARDEDNESS" ,"MASSING" ,"ACCUMULATION" ,"EMBELLISHMENT" ,"DOUBT" ,"SINKING" ,"INNER" ,"DEPARTURE" ,"DARKENING" ,"DIMMING" ,"EXHAUSTION" ,"SEVERANCE" ,"STOPPAGE" ,"HARDNESS" ,"CLOSURE" ,"FAILURE" ,"AGGRAVATION" ,"COMPLIANCE" ,"VERGE" ,"DIFFICULTIES" ,"LABOURING" ,"FOSTERING" ,"COUNTING_" ,"ROD_" ,"TENS_" ,"FRAKTUR_" ,"MONOSPACE_" ,"MAHJONG_" ,"TILE_" ,"RED_" ,"GREEN_" ,"CHARACTERS" ,"BAMBOOS" ,"CIRCLES" ,"PLUM" ,"ORCHID" ,"CHRYSANTHEMUM" ,"SPRING" ,"SUMMER" ,"AUTUMN" ,"WINTER" ,"JOKER" ,"DOMINO_" ,"HORIZONTAL-" ,"00-" ,"00" ,"01" ,"02" ,"03" ,"04" ,"05" ,"06" ,"01-" ,"02-" ,"03-" ,"04-" ,"05-" ,"06-" ,"VERTICAL-" ,"BRACKETED_" ,"WZ" ,"SD" ,"PPV" ,"DJ" ,"HOKA" ,"UNIFIED_" ,"624B" ,"5B57" ,"53CC" ,"4E8C" ,"591A" ,"89E3" ,"5929" ,"4EA4" ,"6620" ,"7121" ,"6599" ,"524D" ,"5F8C" ,"518D" ,"65B0" ,"521D" ,"7D42" ,"751F" ,"8CA9" ,"58F0" ,"5439" ,"6F14" ,"6295" ,"6355" ,"4E00" ,"4E09" ,"904A" ,"5DE6" ,"4E2D" ,"53F3" ,"6307" ,"8D70" ,"6253" ,"672C" ,"5B89" ,"70B9" ,"76D7" ,"52DD" ,"6557" ,"2F800" ,"2F801" ,"2F802" ,"2F803" ,"2F804" ,"2F805" ,"2F806" ,"2F807" ,"2F808" ,"2F809" ,"2F80A" ,"2F80B" ,"2F80C" ,"2F80D" ,"2F80E" ,"2F80F" ,"2F810" ,"2F811" ,"2F812" ,"2F813" ,"2F814" ,"2F815" ,"2F816" ,"2F817" ,"2F818" ,"2F819" ,"2F81A" ,"2F81B" ,"2F81C" ,"2F81D" ,"2F81E" ,"2F81F" ,"2F820" ,"2F821" ,"2F822" ,"2F823" ,"2F824" ,"2F825" ,"2F826" ,"2F827" ,"2F828" ,"2F829" ,"2F82A" ,"2F82B" ,"2F82C" ,"2F82D" ,"2F82E" ,"2F82F" ,"2F830" ,"2F831" ,"2F832" ,"2F833" ,"2F834" ,"2F835" ,"2F836" ,"2F837" ,"2F838" ,"2F839" ,"2F83A" ,"2F83B" ,"2F83C" ,"2F83D" ,"2F83E" ,"2F83F" ,"2F840" ,"2F841" ,"2F842" ,"2F843" ,"2F844" ,"2F845" ,"2F846" ,"2F847" ,"2F848" ,"2F849" ,"2F84A" ,"2F84B" ,"2F84C" ,"2F84D" ,"2F84E" ,"2F84F" ,"2F850" ,"2F851" ,"2F852" ,"2F853" ,"2F854" ,"2F855" ,"2F856" ,"2F857" ,"2F858" ,"2F859" ,"2F85A" ,"2F85B" ,"2F85C" ,"2F85D" ,"2F85E" ,"2F85F" ,"2F860" ,"2F861" ,"2F862" ,"2F863" ,"2F864" ,"2F865" ,"2F866" ,"2F867" ,"2F868" ,"2F869" ,"2F86A" ,"2F86B" ,"2F86C" ,"2F86D" ,"2F86E" ,"2F86F" ,"2F870" ,"2F871" ,"2F872" ,"2F873" ,"2F874" ,"2F875" ,"2F876" ,"2F877" ,"2F878" ,"2F879" ,"2F87A" ,"2F87B" ,"2F87C" ,"2F87D" ,"2F87E" ,"2F87F" ,"2F880" ,"2F881" ,"2F882" ,"2F883" ,"2F884" ,"2F885" ,"2F886" ,"2F887" ,"2F888" ,"2F889" ,"2F88A" ,"2F88B" ,"2F88C" ,"2F88D" ,"2F88E" ,"2F88F" ,"2F890" ,"2F891" ,"2F892" ,"2F893" ,"2F894" ,"2F895" ,"2F896" ,"2F897" ,"2F898" ,"2F899" ,"2F89A" ,"2F89B" ,"2F89C" ,"2F89D" ,"2F89E" ,"2F89F" ,"2F8A0" ,"2F8A1" ,"2F8A2" ,"2F8A3" ,"2F8A4" ,"2F8A5" ,"2F8A6" ,"2F8A7" ,"2F8A8" ,"2F8A9" ,"2F8AA" ,"2F8AB" ,"2F8AC" ,"2F8AD" ,"2F8AE" ,"2F8AF" ,"2F8B0" ,"2F8B1" ,"2F8B2" ,"2F8B3" ,"2F8B4" ,"2F8B5" ,"2F8B6" ,"2F8B7" ,"2F8B8" ,"2F8B9" ,"2F8BA" ,"2F8BB" ,"2F8BC" ,"2F8BD" ,"2F8BE" ,"2F8BF" ,"2F8C0" ,"2F8C1" ,"2F8C2" ,"2F8C3" ,"2F8C4" ,"2F8C5" ,"2F8C6" ,"2F8C7" ,"2F8C8" ,"2F8C9" ,"2F8CA" ,"2F8CB" ,"2F8CC" ,"2F8CD" ,"2F8CE" ,"2F8CF" ,"2F8D0" ,"2F8D1" ,"2F8D2" ,"2F8D3" ,"2F8D4" ,"2F8D5" ,"2F8D6" ,"2F8D7" ,"2F8D8" ,"2F8D9" ,"2F8DA" ,"2F8DB" ,"2F8DC" ,"2F8DD" ,"2F8DE" ,"2F8DF" ,"2F8E0" ,"2F8E1" ,"2F8E2" ,"2F8E3" ,"2F8E4" ,"2F8E5" ,"2F8E6" ,"2F8E7" ,"2F8E8" ,"2F8E9" ,"2F8EA" ,"2F8EB" ,"2F8EC" ,"2F8ED" ,"2F8EE" ,"2F8EF" ,"2F8F0" ,"2F8F1" ,"2F8F2" ,"2F8F3" ,"2F8F4" ,"2F8F5" ,"2F8F6" ,"2F8F7" ,"2F8F8" ,"2F8F9" ,"2F8FA" ,"2F8FB" ,"2F8FC" ,"2F8FD" ,"2F8FE" ,"2F8FF" ,"2F900" ,"2F901" ,"2F902" ,"2F903" ,"2F904" ,"2F905" ,"2F906" ,"2F907" ,"2F908" ,"2F909" ,"2F90A" ,"2F90B" ,"2F90C" ,"2F90D" ,"2F90E" ,"2F90F" ,"2F910" ,"2F911" ,"2F912" ,"2F913" ,"2F914" ,"2F915" ,"2F916" ,"2F917" ,"2F918" ,"2F919" ,"2F91A" ,"2F91B" ,"2F91C" ,"2F91D" ,"2F91E" ,"2F91F" ,"2F920" ,"2F921" ,"2F922" ,"2F923" ,"2F924" ,"2F925" ,"2F926" ,"2F927" ,"2F928" ,"2F929" ,"2F92A" ,"2F92B" ,"2F92C" ,"2F92D" ,"2F92E" ,"2F92F" ,"2F930" ,"2F931" ,"2F932" ,"2F933" ,"2F934" ,"2F935" ,"2F936" ,"2F937" ,"2F938" ,"2F939" ,"2F93A" ,"2F93B" ,"2F93C" ,"2F93D" ,"2F93E" ,"2F93F" ,"2F940" ,"2F941" ,"2F942" ,"2F943" ,"2F944" ,"2F945" ,"2F946" ,"2F947" ,"2F948" ,"2F949" ,"2F94A" ,"2F94B" ,"2F94C" ,"2F94D" ,"2F94E" ,"2F94F" ,"2F950" ,"2F951" ,"2F952" ,"2F953" ,"2F954" ,"2F955" ,"2F956" ,"2F957" ,"2F958" ,"2F959" ,"2F95A" ,"2F95B" ,"2F95C" ,"2F95D" ,"2F95E" ,"2F95F" ,"2F960" ,"2F961" ,"2F962" ,"2F963" ,"2F964" ,"2F965" ,"2F966" ,"2F967" ,"2F968" ,"2F969" ,"2F96A" ,"2F96B" ,"2F96C" ,"2F96D" ,"2F96E" ,"2F96F" ,"2F970" ,"2F971" ,"2F972" ,"2F973" ,"2F974" ,"2F975" ,"2F976" ,"2F977" ,"2F978" ,"2F979" ,"2F97A" ,"2F97B" ,"2F97C" ,"2F97D" ,"2F97E" ,"2F97F" ,"2F980" ,"2F981" ,"2F982" ,"2F983" ,"2F984" ,"2F985" ,"2F986" ,"2F987" ,"2F988" ,"2F989" ,"2F98A" ,"2F98B" ,"2F98C" ,"2F98D" ,"2F98E" ,"2F98F" ,"2F990" ,"2F991" ,"2F992" ,"2F993" ,"2F994" ,"2F995" ,"2F996" ,"2F997" ,"2F998" ,"2F999" ,"2F99A" ,"2F99B" ,"2F99C" ,"2F99D" ,"2F99E" ,"2F99F" ,"2F9A0" ,"2F9A1" ,"2F9A2" ,"2F9A3" ,"2F9A4" ,"2F9A5" ,"2F9A6" ,"2F9A7" ,"2F9A8" ,"2F9A9" ,"2F9AA" ,"2F9AB" ,"2F9AC" ,"2F9AD" ,"2F9AE" ,"2F9AF" ,"2F9B0" ,"2F9B1" ,"2F9B2" ,"2F9B3" ,"2F9B4" ,"2F9B5" ,"2F9B6" ,"2F9B7" ,"2F9B8" ,"2F9B9" ,"2F9BA" ,"2F9BB" ,"2F9BC" ,"2F9BD" ,"2F9BE" ,"2F9BF" ,"2F9C0" ,"2F9C1" ,"2F9C2" ,"2F9C3" ,"2F9C4" ,"2F9C5" ,"2F9C6" ,"2F9C7" ,"2F9C8" ,"2F9C9" ,"2F9CA" ,"2F9CB" ,"2F9CC" ,"2F9CD" ,"2F9CE" ,"2F9CF" ,"2F9D0" ,"2F9D1" ,"2F9D2" ,"2F9D3" ,"2F9D4" ,"2F9D5" ,"2F9D6" ,"2F9D7" ,"2F9D8" ,"2F9D9" ,"2F9DA" ,"2F9DB" ,"2F9DC" ,"2F9DD" ,"2F9DE" ,"2F9DF" ,"2F9E0" ,"2F9E1" ,"2F9E2" ,"2F9E3" ,"2F9E4" ,"2F9E5" ,"2F9E6" ,"2F9E7" ,"2F9E8" ,"2F9E9" ,"2F9EA" ,"2F9EB" ,"2F9EC" ,"2F9ED" ,"2F9EE" ,"2F9EF" ,"2F9F0" ,"2F9F1" ,"2F9F2" ,"2F9F3" ,"2F9F4" ,"2F9F5" ,"2F9F6" ,"2F9F7" ,"2F9F8" ,"2F9F9" ,"2F9FA" ,"2F9FB" ,"2F9FC" ,"2F9FD" ,"2F9FE" ,"2F9FF" ,"2FA00" ,"2FA01" ,"2FA02" ,"2FA03" ,"2FA04" ,"2FA05" ,"2FA06" ,"2FA07" ,"2FA08" ,"2FA09" ,"2FA0A" ,"2FA0B" ,"2FA0C" ,"2FA0D" ,"2FA0E" ,"2FA0F" ,"2FA10" ,"2FA11" ,"2FA12" ,"2FA13" ,"2FA14" ,"2FA15" ,"2FA16" ,"2FA17" ,"2FA18" ,"2FA19" ,"2FA1A" ,"2FA1B" ,"2FA1C" ,"2FA1D" ,"LANGUAGE_" ,"CANCEL_" ,"31" ,"33" ,"41" ,"44" ,"55" ,"59" ,"60" ,"61" ,"62" ,"63" ,"64" ,"65" ,"66" ,"69" ,"70" ,"71" ,"72" ,"73" ,"74" ,"75" ,"76" ,"77" ,"79" ,"80" ,"81" ,"82" ,"83" ,"84" ,"85" ,"86" ,"87" ,"88" ,"89" ,"90" ,"91" ,"92" ,"93" ,"94" ,"95" ,"96" ,"97" ,"98" ,"99" ,"100" ,"101" ,"102" ,"103" ,"104" ,"105" ,"106" ,"107" ,"108" ,"109" ,"110" ,"111" ,"112" ,"113" ,"114" ,"115" ,"116" ,"117" ,"118" ,"119" ,"120" ,"121" ,"122" ,"129" ,"130" ,"131" ,"132" ,"133" ,"139" ,"140" ,"141" ,"142" ,"143" ,"144" ,"149" ,"150" ,"151" ,"152" ,"153" ,"154" ,"155" ,"159" ,"160" ,"161" ,"162" ,"163" ,"164" ,"165" ,"166" ,"169" ,"170" ,"171" ,"172" ,"173" ,"174" ,"175" ,"176" ,"177" ,"179" ,"180" ,"181" ,"182" ,"183" ,"184" ,"185" ,"186" ,"187" ,"188" ,"189" ,"190" ,"191" ,"192" ,"193" ,"194" ,"195" ,"196" ,"197" ,"198" ,"199" ,"200" ,"201" ,"202" ,"203" ,"204" ,"205" ,"206" ,"207" ,"208" ,"209" ,"210" ,"211" ,"212" ,"213" ,"214" ,"215" ,"216" ,"217" ,"218" ,"219" ,"220" ,"221" ,"222" ,"223" ,"224" ,"225" ,"226" ,"227" ,"228" ,"229" ,"230" ,"231" ,"232" ,"233" ,"239" ,"240" ,"241" ,"242" ,"243" ,"244" ,"249" ,"250" ,"251" ,"252" ,"253" ,"254" ,"255" ,"GS" ,"LG" ,"LB" ,"LS" ,"LT" ,"LP" ,"BS" ,"DD" ,"BB" ,"" ,"JJ" }; ecl-16.1.2/src/c/unify.d000066400000000000000000000150101266352375300146650ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* unify.d -- Support for unification. */ /* Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include "ecl.h" #include "unify.h" object *slot; /* scanning pointer within object */ int (*slotf)(); /* read/write mode accessor */ /* -------------------- Trail Instructions -------------------- */ object *trail[VSSIZE]; object **trail_top = trail; #define BIND(loc, val) {loc = val; trail_push(&loc);} @(defun trail_mark () @ trail_mark; @) @(defun trail_restore () @ trail_restore; @(return ECL_NIL) @) @(defun trail_unmark () @ trail_unmark; @(return ECL_NIL) @) /* -------------------- Mode Operators -------------------- */ bool get_slot(object x) /* read mode */ { if (x == *slot || unify(x, *slot)) if (*slot == OBJNULL) return((bool)MAKE_LOCATIVE(slot++)); else return((bool)*slot++); /* dereference */ else return(FALSE); } bool set_slot(object x) /* write mode */ { /* NOTE: slot contains OBJNULL */ *slot = x; return((bool)MAKE_LOCATIVE(slot++)); } /* -------------------- Get Instructions -------------------- */ /* get_variable is just setq */ @(defun get_value (v x) @ @(return (get_value(v, x)?ECL_T:ECL_NIL)) @) @(defun get_constant (c x) @ @(return (get_constant(c, x)?ECL_T:ECL_NIL)) @) @(defun get_nil (arg) @ @(return (get_nil(arg)?ECL_T:ECL_NIL)) @) bool get_cons(object x) { RETRY: switch (ecl_t_of(x)) { case t_cons: slot = &CDR(x); /* cdr slot is first in struct cons */ slotf = get_slot; return(TRUE); case t_locative: if (UNBOUNDP(x)) { object new = CONS(OBJNULL, OBJNULL); BIND(DEREF(x), new); slot = &CDR(new); slotf = set_slot; return(TRUE); } else { x = DEREF(x); goto RETRY; } default: return(FALSE); } } @(defun get_cons (arg) @ @(return (get_cons(arg)?ECL_T:ECL_NIL)) @) bool get_instance(object x, object class, int arity) { RETRY: switch (ecl_t_of(x)) { case t_instance: if (ECL_CLASS_OF(x) == class) { slot = x->instance.slots; slotf = get_slot; return(TRUE); } else return(FALSE); case t_locative: if (UNBOUNDP(x)) { object new = allocate_instance(class, arity); BIND(DEREF(x), new); slot = new->instance.slots; slotf = set_slot; return(TRUE); } else { x = DEREF(x); goto RETRY; } default: return(FALSE); } } @(defun get_instance (x class arity) @ @(return (get_instance(x, class, ecl_fixnum(arity))?ECL_T:ECL_NIL)) @) /* -------------------- Unify Instructions -------------------- */ #define UNIFY_LOCATIVE(x, y, L) {object *p = &DEREF(x); \ if (*p == OBJNULL) { \ BIND(*p, y); return(TRUE); } \ else { x = *p; goto L;}} /* #define UNIFY_LOCATIVE(x, y, L) {if (UNBOUNDP(x)) { \ BIND(DEREF(x), y); return(TRUE); } \ else { x = DEREF(x); goto L;}} */ bool unify(object x, object y) { /* NOTE: x <- y */ L: switch (ecl_t_of(x)) { case t_locative: UNIFY_LOCATIVE(x, y, L); case t_cons: L1: switch (ecl_t_of(y)) { case t_cons: return(unify(CAR(x), CAR(y)) && unify(CDR(x), CDR(y))); case t_locative: UNIFY_LOCATIVE(y, x, L1); default: return(FALSE); } case t_instance: L2: switch (ecl_t_of(y)) { case t_instance: if (ECL_CLASS_OF(x) == ECL_CLASS_OF(y)) { int l = x->instance.length; int i; object *slotx = x->instance.slots; object *sloty = y->instance.slots; for (i = 0; i < l; i++) { if (!unify(*slotx++, *sloty++)) return(FALSE); } return(TRUE); } else return(FALSE); case t_locative: UNIFY_LOCATIVE(y, x, L2); default: return(FALSE); } default: L3: if (LOCATIVEP(y)) UNIFY_LOCATIVE(y, x, L3) else if (equal(x,y)) return(TRUE); else return(FALSE); } } /* Internal function. One should use unify_variable, which always returns T */ @(defun unify_slot () @ @(return ((object)unify_slot)) @) @(defun unify_value (loc) object x; @ x = (object)unify_value(loc); @(return ((x == ECL_NIL || x)?ECL_T:ECL_NIL)) @) @(defun unify_constant (c) object x; @ x = (object)unify_constant(c); @(return ((x == ECL_NIL || x)?ECL_T:ECL_NIL)) @) @(defun unify_nil () object x; @ x = (object)unify_nil; @(return ((x == ECL_NIL || x)?ECL_T:ECL_NIL)) @) /* -------------------- Test Functions -------------------- */ @(defun make_locative (&optional (n 0)) @ @(return (MAKE_LOCATIVE(ecl_fixnum(n)))) @) @(defun locativep (obje) @ @(return (LOCATIVEP(obje)?ECL_T:ECL_NIL)) @) @(defun unboundp (loc) @ @(return (UNBOUNDP(loc)?ECL_T:ECL_NIL)) @) @(defun dereference (x) extern object Slocative; @ while (ecl_t_of(x) != t_locative) x = wrong_type_argument(Slocative, x); @(return (DEREF(x))) @) @(defun make_variable (name) @ @(return (CONS(name, OBJNULL))) @) /* (defmacro unify-variable (v) `(progn (setq ,v (si:unify-slot)) t) */ object Ssetq, Sunify_slot; @(defun unify_variable (object var) @ @(return list(3, Sprogn, list(3, Ssetq, CADR(var), CONS(Sunify_slot, ECL_NIL)), ECL_T)) @) #define make_si_macro(name, cfun) \ {object x = make_si_ordinary(name); \ ECL_SYM_FUN(x) = make_cfun(cfun, ECL_NIL, NULL); \ x->symbol.mflag = TRUE; \ } void init_unify(void) { make_si_macro("UNIFY-VARIABLE", Lunify_variable); } ecl-16.1.2/src/c/unixfsys.d000066400000000000000000001336061266352375300154370ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* unixfsys.c -- Unix file system interface. */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #include #include #ifndef _MSC_VER # include #else # include # include # define access _access # define F_OK 0 typedef int mode_t; #endif #include #include #ifdef HAVE_PWD_H # include #endif #include #include #include #include #ifdef HAVE_DIRENT_H # include #else # if !defined(_MSC_VER) # include # endif #endif #if defined(ECL_MS_WINDOWS_HOST) # include # undef ERROR #endif #include #include ecl_def_ct_base_string(str_slash,"/",1,static,const); static cl_object coerce_to_posix_filename(cl_object filename) { /* This converts a pathname designator into a namestring, with the * particularity that directories do not end with a slash '/', because * this is not supported on all POSIX platforms (most notably Windows) */ filename = si_coerce_to_filename(filename); return cl_string_right_trim(str_slash, filename); } static int safe_chdir(const char *path, cl_object prefix) { if (prefix != ECL_NIL) { cl_object aux = make_constant_base_string(path); aux = si_base_string_concatenate(2, prefix, aux); return safe_chdir((char *)aux->base_string.self, ECL_NIL); } else { int output; ecl_disable_interrupts(); output = chdir((char *)path); ecl_enable_interrupts(); return output; } } static int safe_stat(const char *path, struct stat *sb) { int output; ecl_disable_interrupts(); output = stat(path, sb); ecl_enable_interrupts(); return output; } #ifdef HAVE_LSTAT static int safe_lstat(const char *path, struct stat *sb) { int output; ecl_disable_interrupts(); output = lstat(path, sb); ecl_enable_interrupts(); return output; } #endif #if defined(ECL_MS_WINDOWS_HOST) static cl_object drive_host_prefix(cl_object pathname) { cl_object device = pathname->pathname.device; cl_object host = pathname->pathname.host; cl_object output = ECL_NIL; if (device != ECL_NIL) { output = make_base_string_copy("X:"); output->base_string.self[0] = device->base_string.self[0]; } if (host != ECL_NIL) { cl_object slash = cl_core.slash; if (output != ECL_NIL) output = si_base_string_concatenate(5, output, slash, slash, host, slash); else output = si_base_string_concatenate(4, slash, slash, host, slash); } return output; } #else #define drive_host_prefix(x) ECL_NIL #endif /* * string_to_pathanme, to be used when s is a real pathname */ cl_object ecl_cstring_to_pathname(char *s) { cl_object string = ecl_make_simple_base_string(s, -1); return cl_parse_namestring(1, string); } /* * Finds current directory by using getcwd() with an adjustable * string which grows until it can host the whole path. */ static cl_object current_dir(void) { cl_object output; const char *ok; #ifdef _MSC_VER unsigned char *c; #endif cl_index size = 128; do { output = ecl_alloc_adjustable_base_string(size); ecl_disable_interrupts(); ok = getcwd((char*)output->base_string.self, size); if (ok == NULL && errno != ENAMETOOLONG) { perror("ext::getcwd error"); ecl_internal_error("Can't work without CWD"); } ecl_enable_interrupts(); size += 256; } while (ok == NULL); size = strlen((char*)output->base_string.self); if ((size + 1 /* / */ + 1 /* 0 */) >= output->base_string.dim) { /* Too large to host the trailing '/' */ cl_object other = ecl_alloc_adjustable_base_string(size+2); strcpy((char*)other->base_string.self, (char*)output->base_string.self); output = other; } #ifdef _MSC_VER for (c = output->base_string.self; *c; c++) if (*c == '\\') *c = '/'; #endif if (output->base_string.self[size-1] != '/') { output->base_string.self[size++] = '/'; output->base_string.self[size] = 0; } output->base_string.fillp = size; return output; } /* * Using a certain path, guess the type of the object it points to. */ static cl_object file_kind(char *filename, bool follow_links) { cl_object output; #if defined(ECL_MS_WINDOWS_HOST) DWORD dw; ecl_disable_interrupts(); dw = GetFileAttributes( filename ); if (dw == -1) output = ECL_NIL; else if ( dw & FILE_ATTRIBUTE_DIRECTORY ) output = @':directory'; else output = @':file'; ecl_enable_interrupts(); #else struct stat buf; # ifdef HAVE_LSTAT if ((follow_links? safe_stat : safe_lstat)(filename, &buf) < 0) # else if (safe_stat(filename, &buf) < 0) # endif output = ECL_NIL; # ifdef HAVE_LSTAT else if (S_ISLNK(buf.st_mode)) output = @':link'; # endif else if (S_ISDIR(buf.st_mode)) output = @':directory'; else if (S_ISREG(buf.st_mode)) output = @':file'; else output = @':special'; #endif return output; } cl_object si_file_kind(cl_object filename, cl_object follow_links) { filename = coerce_to_posix_filename(filename); @(return file_kind((char*)filename->base_string.self, !Null(follow_links))) } #if defined(HAVE_LSTAT) && !defined(ECL_MS_WINDOWS_HOST) static cl_object si_readlink(cl_object filename) { /* Given a filename which is a symlink, this routine returns * the value of this link in the form of a pathname. */ cl_index size = 128, written; cl_object output, kind; do { output = ecl_alloc_adjustable_base_string(size); ecl_disable_interrupts(); written = readlink((char*)filename->base_string.self, (char*)output->base_string.self, size); ecl_enable_interrupts(); size += 256; } while (written == size); output->base_string.self[written] = '\0'; kind = file_kind((char*)output->base_string.self, FALSE); if (kind == @':directory') { output->base_string.self[written++] = '/'; output->base_string.self[written] = '\0'; } output->base_string.fillp = written; return output; } #endif /* HAVE_LSTAT */ static cl_object enter_directory(cl_object base_dir, cl_object subdir, bool ignore_if_failure) { /* Assuming we start in "base_dir", enter a subdirectory named by * "subdir", which may be a string, :UP, :ABSOLUTE or :RELATIVE. * If the operation succeeds, return the truename of the resulting * path -- resolving any links in the process. */ cl_object aux, output, kind; if (subdir == @':absolute') { return cl_make_pathname(4, @':directory', ecl_list1(subdir), @':defaults', base_dir); } else if (subdir == @':relative') { /* Nothing to do */ return base_dir; } else if (subdir == @':up') { aux = make_constant_base_string(".."); } else if (!ECL_BASE_STRING_P(subdir)) { unlikely_if (!ecl_fits_in_base_string(subdir)) FEerror("Directory component ~S found in pathname~& ~S" "~&is not allowed in TRUENAME or DIRECTORY", 1, subdir); aux = si_coerce_to_base_string(subdir); } else { aux = subdir; } /* We now compose a new path based on the base directory and * the new component. We have to verify that the new pathname is * a directory and if it is a link recover the true name. */ aux = ecl_append(base_dir->pathname.directory, ecl_list1(aux)); output = cl_make_pathname(4, @':directory', aux, @':defaults', base_dir); aux = ecl_namestring(output, ECL_NAMESTRING_FORCE_BASE_STRING); /* We remove the trailing '/' from the namestring because the * POSIX library does not like it. */ aux->base_string.self[--aux->base_string.fillp] = 0; kind = file_kind((char*)aux->base_string.self, FALSE); if (kind == ECL_NIL) { if (ignore_if_failure) return ECL_NIL; FEcannot_open(output); #ifdef HAVE_LSTAT } else if (kind == @':link') { output = cl_truename(ecl_merge_pathnames(si_readlink(aux), base_dir, @':default')); if (output->pathname.name != ECL_NIL || output->pathname.type != ECL_NIL) goto WRONG_DIR; return output; #endif } else if (kind != @':directory') { WRONG_DIR: if (ignore_if_failure) return ECL_NIL; FEerror("The directory~& ~S~&in pathname~& ~S~&" "actually points to a file or special device.", 2, subdir, base_dir); } if (subdir == @':up') { cl_object newdir= output->pathname.directory; newdir = ecl_nbutlast(newdir, 2); if (Null(newdir)) { if (ignore_if_failure) return ECL_NIL; FEerror("Pathname contained an :UP component " "that goes above the base directory:" "~& ~S", 1, output); } output->pathname.directory = newdir; } return output; } static cl_object make_absolute_pathname(cl_object orig_pathname) { cl_object base_dir = si_getcwd(0); cl_object pathname = coerce_to_file_pathname(orig_pathname); return ecl_merge_pathnames(pathname, base_dir, @':default'); } static cl_object make_base_pathname(cl_object pathname) { return ecl_make_pathname(pathname->pathname.host, pathname->pathname.device, ecl_list1(@':absolute'), ECL_NIL, ECL_NIL, ECL_NIL, @':local'); } #define FOLLOW_SYMLINKS 1 static cl_object file_truename(cl_object pathname, cl_object filename, int flags) { cl_object kind; if (Null(pathname)) { if (Null(filename)) { ecl_internal_error("file_truename:" " both FILENAME and PATHNAME are null!"); } pathname = cl_pathname(filename); } else if (Null(filename)) { filename = ecl_namestring(pathname, ECL_NAMESTRING_FORCE_BASE_STRING); if (Null(filename)) { FEerror("Unprintable pathname ~S found in TRUENAME", 1, pathname); } } kind = file_kind((char*)filename->base_string.self, FALSE); if (kind == ECL_NIL) { FEcannot_open(filename); #ifdef HAVE_LSTAT } else if (kind == @':link' && (flags & FOLLOW_SYMLINKS)) { /* The link might be a relative pathname. In that case * we have to merge with the original pathname. On * the other hand, if the link is broken т€“ return file * truename "as is". */ struct stat filestatus; if (safe_stat(filename->base_string.self, &filestatus) < 0) @(return pathname kind); filename = si_readlink(filename); pathname = ecl_make_pathname(pathname->pathname.host, pathname->pathname.device, pathname->pathname.directory, ECL_NIL, ECL_NIL, ECL_NIL, @':local'); pathname = ecl_merge_pathnames(filename, pathname, @':default'); return cl_truename(pathname); #endif } else if (kind == @':directory'){ /* If the pathname is a directory but we have supplied a file name, correct the type by appending a directory separator and re-parsing again the namestring */ if (pathname->pathname.name != ECL_NIL || pathname->pathname.type != ECL_NIL) { pathname = si_base_string_concatenate (2, filename, make_constant_base_string("/")); pathname = cl_truename(pathname); } } /* ECL does not contemplate version numbers in directory pathnames */ if (pathname->pathname.name == ECL_NIL && pathname->pathname.type == ECL_NIL) { /* We have to destructively change the * pathname version here. Otherwise * merge_pathnames will not do it. It is * safe because coerce_to_file_pathname * created a copy. */ pathname->pathname.version = ECL_NIL; } else { pathname->pathname.version = @':newest'; } @(return pathname kind) } /* * Search the actual name of the directory of a pathname, * going through links if they exist. Default is * current directory */ cl_object cl_truename(cl_object orig_pathname) { cl_object pathname = make_absolute_pathname(orig_pathname); cl_object base_dir = make_base_pathname(pathname); cl_object dir; /* We process the directory part of the filename, removing all * possible symlinks. To do so, we inspect recursively the * directory which contains our file, and come back. We also have to * ensure that the filename itself does not point to a symlink: if so, * then we resolve the value of the symlink and continue traversing * the filesystem. */ for (dir = pathname->pathname.directory; !Null(dir); dir = ECL_CONS_CDR(dir)) { base_dir = enter_directory(base_dir, ECL_CONS_CAR(dir), 0); } pathname = ecl_merge_pathnames(base_dir, pathname, @':default'); @(return file_truename(pathname, ECL_NIL, FOLLOW_SYMLINKS)) } int ecl_backup_open(const char *filename, int option, int mode) { char *backupfilename = ecl_alloc(strlen(filename) + 5); if (backupfilename == NULL) { FElibc_error("Cannot allocate memory for backup filename", 0); } strcat(strcpy(backupfilename, filename), ".BAK"); ecl_disable_interrupts(); #if defined(ECL_MS_WINDOWS_HOST) /* Windows' rename doesn't replace an existing file */ if (access(backupfilename, F_OK) == 0 && unlink(backupfilename)) { ecl_enable_interrupts(); FElibc_error("Cannot remove the file ~S", 1, ecl_make_constant_base_string(backupfilename,-1)); } #endif if (rename(filename, backupfilename)) { ecl_enable_interrupts(); FElibc_error("Cannot rename the file ~S to ~S.", 2, ecl_make_constant_base_string(filename,-1), ecl_make_constant_base_string(backupfilename,-1)); } ecl_enable_interrupts(); ecl_dealloc(backupfilename); return open(filename, option, mode); } cl_object ecl_file_len(int f) { struct stat filestatus; memset(&filestatus, 0, sizeof(filestatus)); ecl_disable_interrupts(); fstat(f, &filestatus); ecl_enable_interrupts(); return ecl_make_integer(filestatus.st_size); } @(defun rename-file (oldn newn &key (if_exists @':error')) cl_object old_filename, new_filename, old_truename, new_truename; int error; @ /* 1) Get the old filename, and complain if it has wild components, * or if it does not exist. Notice that the filename to be renamed * is not the truename, because we might be renaming a symbolic link. */ old_truename = cl_truename(oldn); old_filename = coerce_to_posix_filename(old_truename); /* 2) Create the new file name. */ newn = ecl_merge_pathnames(newn, oldn, @':newest'); new_filename = si_coerce_to_filename(newn); while (if_exists == @':error' || if_exists == ECL_NIL) { if (cl_probe_file(new_filename) == ECL_NIL) { if_exists = ECL_T; break; } /* if the file already exists */ if (if_exists == @':error') { const char *msg = "When trying to rename ~S, ~S already exists"; if_exists = si_signal_simple_error (6, @'file-error', /* condition */ @':supersede', /* continuable */ /* format */ ecl_make_constant_base_string(msg,strlen(msg)), cl_list(2, oldn, new_filename), /* format args */ @':pathname', /* file-error options */ new_filename); if (if_exists == ECL_T) if_exists= @':error'; } if (if_exists == ECL_NIL) { @(return ECL_NIL ECL_NIL ECL_NIL) } } if (ecl_unlikely(if_exists != @':supersede' && if_exists != ECL_T)) { /* invalid key */ FEerror("~S is an illegal IF-EXISTS option for RENAME-FILE.", 1, if_exists); } { ecl_disable_interrupts(); #if defined(ECL_MS_WINDOWS_HOST) error = SetErrorMode(0); if (MoveFile((char*)old_filename->base_string.self, (char*)new_filename->base_string.self)) { SetErrorMode(error); goto SUCCESS; } switch (GetLastError()) { case ERROR_ALREADY_EXISTS: case ERROR_FILE_EXISTS: break; default: goto FAILURE_CLOBBER; }; if (MoveFileEx((char*)old_filename->base_string.self, (char*)new_filename->base_string.self, MOVEFILE_REPLACE_EXISTING)) { SetErrorMode(error); goto SUCCESS; } /* hack for win95/novell */ chmod((char*)old_filename->base_string.self, 0777); chmod((char*)new_filename->base_string.self, 0777); SetFileAttributesA((char*)new_filename->base_string.self, FILE_ATTRIBUTE_NORMAL); SetFileAttributesA((char*)new_filename->base_string.self, FILE_ATTRIBUTE_TEMPORARY); if (MoveFile((char*)old_filename->base_string.self, (char*)new_filename->base_string.self)) { SetErrorMode(error); goto SUCCESS; } /* fallback on old behavior */ (void)DeleteFileA((char*)new_filename->base_string.self); if (MoveFile((char*)old_filename->base_string.self, (char*)new_filename->base_string.self)) { SetErrorMode(error); goto SUCCESS; } /* fall through */ #else if (rename((char*)old_filename->base_string.self, (char*)new_filename->base_string.self) == 0) { goto SUCCESS; } #endif } FAILURE_CLOBBER: ecl_enable_interrupts(); { cl_object c_error = _ecl_strerror(errno); const char *msg = "Unable to rename file ~S to ~S.~%C library error: ~S"; si_signal_simple_error (6, @'file-error', /* condition */ ECL_NIL, /* continuable */ ecl_make_constant_base_string(msg,strlen(msg)), /* format */ cl_list(3, oldn, newn, c_error), /* format args */ @':pathname', /* file-error options */ oldn); } SUCCESS: ecl_enable_interrupts(); new_truename = cl_truename(newn); @(return newn old_truename new_truename) @) static int directory_pathname_p(cl_object path) { return (path->pathname.name == ECL_NIL) && (path->pathname.type == ECL_NIL); } cl_object cl_delete_file(cl_object file) { cl_object path = cl_pathname(file); int isdir = directory_pathname_p(path); cl_object filename = coerce_to_posix_filename(path); int ok, code; ecl_disable_interrupts(); ok = (isdir? rmdir : unlink)((char*)filename->base_string.self); ecl_enable_interrupts(); if (ok < 0) { const char *msg = isdir? "Cannot delete the directory ~S.~%C library error: ~S" : "Cannot delete the file ~S.~%C library error: ~S"; cl_object c_error = _ecl_strerror(errno); si_signal_simple_error (6, @'file-error', /* condition */ ECL_T, /* continuable */ ecl_make_constant_base_string(msg,strlen(msg)), /* format */ cl_list(2, file, c_error), /* format args */ @':pathname', /* file-error options */ file); } @(return ECL_T) } cl_object cl_probe_file(cl_object file) { /* INV: Both SI:FILE-KIND and TRUENAME complain if "file" has wildcards */ @(return (si_file_kind(file, ECL_T) != ECL_NIL? cl_truename(file) : ECL_NIL)) } cl_object cl_file_write_date(cl_object file) { cl_object time, filename = coerce_to_posix_filename(file); struct stat filestatus; if (safe_stat((char*)filename->base_string.self, &filestatus) < 0) { time = ECL_NIL; } else { time = UTC_time_to_universal_time(filestatus.st_mtime); } @(return time) } cl_object cl_file_author(cl_object file) { cl_object output, filename = coerce_to_posix_filename(file); struct stat filestatus; if (safe_stat((char*)filename->base_string.self, &filestatus) < 0) { const char *msg = "Unable to read file author for ~S." "~%C library error: ~S"; cl_object c_error = _ecl_strerror(errno); si_signal_simple_error (6, @'file-error', /* condition */ ECL_T, /* continuable */ ecl_make_constant_base_string(msg,strlen(msg)), /* format */ cl_list(2, file, c_error), /* format args */ @':pathname', /* file-error options */ file); } #ifdef HAVE_PWD_H { struct passwd *pwent; ecl_disable_interrupts(); pwent = getpwuid(filestatus.st_uid); ecl_enable_interrupts(); output = make_base_string_copy(pwent->pw_name); } #else output = make_constant_base_string("UNKNOWN"); #endif @(return output) } cl_object ecl_homedir_pathname(cl_object user) { cl_index i; cl_object namestring; const char *h, *d; if (!Null(user)) { #ifdef HAVE_PWD_H struct passwd *pwent = NULL; #endif char *p; /* This ensures that our string has the right length and it is terminated with a '\0' */ user = si_copy_to_simple_base_string(user); p = (char*)user->base_string.self; i = user->base_string.fillp; if (i > 0 && *p == '~') { p++; i--; } if (i == 0) return ecl_homedir_pathname(ECL_NIL); #ifdef HAVE_PWD_H pwent = getpwnam(p); if (pwent == NULL) FEerror("Unknown user ~S.", 1, p); namestring = make_base_string_copy(pwent->pw_dir); #endif FEerror("Unknown user ~S.", 1, p); } else if ((h = getenv("HOME"))) { namestring = make_base_string_copy(h); #if defined(ECL_MS_WINDOWS_HOST) } else if ((h = getenv("HOMEPATH")) && (d = getenv("HOMEDRIVE"))) { namestring = si_base_string_concatenate(2, make_constant_base_string(d), make_constant_base_string(h)); #endif } else { namestring = make_constant_base_string("/"); } if (namestring->base_string.self[0] == '~') { FEerror("Not a valid home pathname ~S", 1, namestring); } i = namestring->base_string.fillp; if (!IS_DIR_SEPARATOR(namestring->base_string.self[i-1])) namestring = si_base_string_concatenate(2, namestring, ECL_CODE_CHAR(DIR_SEPARATOR)); return cl_parse_namestring(3, namestring, ECL_NIL, ECL_NIL); } @(defun user_homedir_pathname (&optional host) @ /* Ignore optional host argument. */ @(return ecl_homedir_pathname(ECL_NIL)); @) static bool string_match(const char *s, cl_object pattern) { if (pattern == ECL_NIL || pattern == @':wild') { return 1; } else { cl_index ls = strlen(s); ecl_def_ct_base_string(strng, s, ls, /*auto*/, const); return ecl_string_match(strng, 0, ls, pattern, 0, ecl_length(pattern)); } } /* * list_current_directory() lists the files and directories which are contained * in the current working directory (as given by current_dir()). If ONLY_DIR is * true, the list is made of only the directories -- a propert which is checked * by following the symlinks. */ static cl_object list_directory(cl_object base_dir, cl_object text_mask, cl_object pathname_mask, int flags) { const cl_env_ptr the_env = ecl_process_env(); cl_object out = ECL_NIL; cl_object prefix = ecl_namestring(base_dir, ECL_NAMESTRING_FORCE_BASE_STRING); cl_object component, component_path, kind; char *text; #if defined(HAVE_DIRENT_H) DIR *dir; struct dirent *entry; ecl_disable_interrupts(); dir = opendir((char*)prefix->base_string.self); if (dir == NULL) { out = ECL_NIL; goto OUTPUT; } while ((entry = readdir(dir))) { text = entry->d_name; #else # ifdef ECL_MS_WINDOWS_HOST WIN32_FIND_DATA fd; HANDLE hFind = NULL; BOOL found = FALSE; ecl_disable_interrupts(); for (;;) { if (hFind == NULL) { cl_object aux = make_constant_base_string(".\\*"); cl_object mask = si_base_string_concatenate(2, prefix, aux); hFind = FindFirstFile((char*)mask->base_string.self, &fd); if (hFind == INVALID_HANDLE_VALUE) { out = ECL_NIL; goto OUTPUT; } found = TRUE; } else { found = FindNextFile(hFind, &fd); } if (!found) break; text = fd.cFileName; # else /* sys/dir.h as in SYSV */ FILE *fp; char iobuffer[BUFSIZ]; DIRECTORY dir; ecl_disable_interrupts(); fp = fopen((char*)prefix->base_string.self, OPEN_R); if (fp == NULL) { out = ECL_NIL; goto OUTPUT; } setbuf(fp, iobuffer); for (;;) { if (fread(&dir, sizeof(DIRECTORY), 1, fp) <= 0) break; if (dir.d_ino == 0) continue; text = dir.d_name; # endif /* !ECL_MS_WINDOWS_HOST */ #endif /* !HAVE_DIRENT_H */ if (text[0] == '.' && (text[1] == '\0' || (text[1] == '.' && text[2] == '\0'))) continue; if (!string_match(text, text_mask)) continue; component = make_constant_base_string(text); component = si_base_string_concatenate(2, prefix, component); component_path = cl_pathname(component); if (!Null(pathname_mask)) { if (Null(cl_pathname_match_p(component, pathname_mask))) continue; } component_path = file_truename(component_path, component, flags); kind = ecl_nth_value(the_env, 1); out = CONS(CONS(component_path, kind), out); } #ifdef HAVE_DIRENT_H closedir(dir); #else # ifdef ECL_MS_WINDOWS_HOST FindClose(hFind); # else fclose(fp); # endif /* !ECL_MS_WINDOWS_HOST */ #endif /* !HAVE_DIRENT_H */ ecl_enable_interrupts(); OUTPUT: return cl_nreverse(out); } /* * dir_files() lists all files which are contained in the current directory and * which match the masks in PATHNAME. This routine is essentially a wrapper for * list_current_directory(), which transforms the list of strings into a list * of pathnames. BASEDIR is the truename of the current directory and it is * used to build these pathnames. */ static cl_object dir_files(cl_object base_dir, cl_object pathname, int flags) { cl_object all_files, output = ECL_NIL; cl_object mask; cl_object name = pathname->pathname.name; cl_object type = pathname->pathname.type; if (name == ECL_NIL && type == ECL_NIL) { return cl_list(1, base_dir); } mask = ecl_make_pathname(ECL_NIL, ECL_NIL, ECL_NIL, name, type, pathname->pathname.version, @':local'); for (all_files = list_directory(base_dir, ECL_NIL, mask, flags); !Null(all_files); all_files = ECL_CONS_CDR(all_files)) { cl_object record = ECL_CONS_CAR(all_files); cl_object new = ECL_CONS_CAR(record); cl_object kind = ECL_CONS_CDR(record); if (kind != @':directory') { output = CONS(new, output); } } return output; } /* * dir_recursive() performs the dirty job of DIRECTORY. The routine moves * through the filesystem looking for files and directories which match * the masks in the arguments PATHNAME and DIRECTORY, collecting them in a * list. */ static cl_object dir_recursive(cl_object base_dir, cl_object directory, cl_object filemask, int flags) { cl_object item, output = ECL_NIL; AGAIN: /* There are several possibilities here: * * 1) The list of subdirectories DIRECTORY is empty, and only PATHNAME * remains to be inspected. If there is no file name or type, then * we simply output the truename of the current directory. Otherwise * we have to find a file which corresponds to the description. */ if (directory == ECL_NIL) { return ecl_nconc(dir_files(base_dir, filemask, flags), output); } /* * 2) We have not yet exhausted the DIRECTORY component of the * pathname. We have to enter some subdirectory, determined by * CAR(DIRECTORY) and scan it. */ item = ECL_CONS_CAR(directory); if (item == @':wild' || ecl_wild_string_p(item)) { /* * 2.1) If CAR(DIRECTORY) is a string or :WILD, we have to * enter & scan all subdirectories in our curent directory. */ cl_object next_dir = list_directory(base_dir, item, ECL_NIL, flags); for (; !Null(next_dir); next_dir = ECL_CONS_CDR(next_dir)) { cl_object record = ECL_CONS_CAR(next_dir); cl_object component = ECL_CONS_CAR(record); cl_object kind = ECL_CONS_CDR(record); if (kind != @':directory') continue; item = dir_recursive(cl_pathname(component), ECL_CONS_CDR(directory), filemask, flags); output = ecl_nconc(item, output); } } else if (item == @':wild-inferiors') { /* * 2.2) If CAR(DIRECTORY) is :WILD-INFERIORS, we have to do * scan all subdirectories from _all_ levels, looking for a * tree that matches the remaining part of DIRECTORY. */ cl_object next_dir = list_directory(base_dir, ECL_NIL, ECL_NIL, flags); for (; !Null(next_dir); next_dir = ECL_CONS_CDR(next_dir)) { cl_object record = ECL_CONS_CAR(next_dir); cl_object component = ECL_CONS_CAR(record); cl_object kind = ECL_CONS_CDR(record); if (kind != @':directory') continue; item = dir_recursive(cl_pathname(component), directory, filemask, flags); output = ecl_nconc(item, output); } directory = ECL_CONS_CDR(directory); goto AGAIN; } else { /* :ABSOLUTE, :RELATIVE, :UP, component without wildcards */ /* * 2.2) If CAR(DIRECTORY) is :ABSOLUTE, :RELATIVE or :UP we update * the directory to reflect the root, the current or the parent one. */ base_dir = enter_directory(base_dir, item, 1); /* * If enter_directory() fails, we simply ignore this path. This is * what other implementations do and is consistent with the behavior * for the file part. */ if (Null(base_dir)) return ECL_NIL; directory = ECL_CONS_CDR(directory); goto AGAIN; } return output; } @(defun directory (mask &key (resolve_symlinks ECL_T) &allow_other_keys) cl_object base_dir; cl_object output; @ mask = coerce_to_file_pathname(mask); mask = make_absolute_pathname(mask); base_dir = make_base_pathname(mask); output = dir_recursive(base_dir, mask->pathname.directory, mask, Null(resolve_symlinks)? 0 : FOLLOW_SYMLINKS); @(return output) @) @(defun ext::getcwd (&optional (change_d_p_d ECL_NIL)) cl_object output; @ output = cl_parse_namestring(3, current_dir(), ECL_NIL, ECL_NIL); if (!Null(change_d_p_d)) { ECL_SETQ(the_env, @'*default-pathname-defaults*', output); } @(return output) @) cl_object si_get_library_pathname(void) { cl_object s = cl_core.library_pathname; if (!Null(s)) { goto OUTPUT_UNCHANGED; } else { const char *v = getenv("ECLDIR"); if (v) { s = make_constant_base_string(v); goto OUTPUT; } } #if defined(ECL_MS_WINDOWS_HOST) { char *buffer; HMODULE hnd; cl_index len, ep; s = ecl_alloc_adjustable_base_string(cl_core.path_max); buffer = (char*)s->base_string.self; ecl_disable_interrupts(); hnd = GetModuleHandle("ecl.dll"); len = GetModuleFileName(hnd, buffer, cl_core.path_max-1); ecl_enable_interrupts(); if (len == 0) { FEerror("GetModuleFileName failed (last error = ~S)", 1, ecl_make_fixnum(GetLastError())); } s->base_string.fillp = len; /* GetModuleFileName returns a file name. We have to strip * the directory component. */ s = cl_make_pathname(8, @':name', ECL_NIL, @':type', ECL_NIL, @':version', ECL_NIL, @':defaults', s); s = ecl_namestring(s, ECL_NAMESTRING_FORCE_BASE_STRING); } #else s = make_constant_base_string(ECLDIR "/"); #endif OUTPUT: { cl_object true_pathname = cl_probe_file(s); if (Null(true_pathname)) { s = current_dir(); } else { /* Produce a string */ s = ecl_namestring(s, ECL_NAMESTRING_FORCE_BASE_STRING); } } cl_core.library_pathname = s; OUTPUT_UNCHANGED: @(return s); } @(defun ext::chdir (directory &optional (change_d_p_d ECL_T)) cl_object previous = si_getcwd(0); cl_object namestring; @ /* This will fail if the new directory does not exist */ directory = cl_truename(directory); if (directory->pathname.name != ECL_NIL || directory->pathname.type != ECL_NIL) FEerror("~A is not a directory pathname.", 1, directory); namestring = ecl_namestring(directory, ECL_NAMESTRING_TRUNCATE_IF_ERROR | ECL_NAMESTRING_FORCE_BASE_STRING); if (safe_chdir((char*)namestring->base_string.self, ECL_NIL) < 0) { cl_object c_error = _ecl_strerror(errno); const char *msg = "Can't change the current directory to ~A." "~%C library error: ~S"; si_signal_simple_error (6, @'file-error', /* condition */ ECL_T, /* continuable */ /* format */ ecl_make_constant_base_string(msg,strlen(msg)), cl_list(2, directory, c_error), /* format args */ @':pathname', /* file-error options */ directory); } else if (change_d_p_d != ECL_NIL) { ECL_SETQ(the_env, @'*default-pathname-defaults*', directory); } @(return previous) @) cl_object si_mkdir(cl_object directory, cl_object mode) { int modeint, ok; cl_object filename = si_coerce_to_base_string(directory); if (ecl_unlikely(!ECL_FIXNUMP(mode) || ecl_fixnum_minusp(mode) || ecl_fixnum_greater(mode, ecl_make_fixnum(0777)))) { FEwrong_type_nth_arg(@[si::mkdir], 2, mode, ecl_make_integer_type(ecl_make_fixnum(0), ecl_make_fixnum(0777))); } modeint = ecl_fixnum(mode); { /* Ensure a clean string, without trailing slashes, * and null terminated. */ cl_index last = filename->base_string.fillp; if (last > 1) { ecl_character c = filename->base_string.self[last-1]; if (IS_DIR_SEPARATOR(c)) last--; } filename = ecl_subseq(filename, 0, last); } ecl_disable_interrupts(); #if defined(ECL_MS_WINDOWS_HOST) ok = mkdir((char*)filename->base_string.self); #else ok = mkdir((char*)filename->base_string.self, modeint); #endif ecl_enable_interrupts(); if (ecl_unlikely(ok < 0)) { cl_object c_error = _ecl_strerror(errno); const char *msg = "Could not create directory ~S" "~%C library error: ~S"; si_signal_simple_error (6, @'file-error', /* condition */ ECL_T, /* continuable */ /* format */ ecl_make_constant_base_string(msg,strlen(msg)), cl_list(2, filename, c_error), /* format args */ @':pathname', /* file-error options */ filename); } @(return filename) } cl_object si_mkstemp(cl_object template) { cl_object output; cl_index l; int fd; #if defined(ECL_MS_WINDOWS_HOST) cl_object phys, dir, file; char strTempDir[MAX_PATH]; char strTempFileName[MAX_PATH]; char *s; int ok; phys = cl_translate_logical_pathname(1, template); dir = cl_make_pathname(8, @':type', ECL_NIL, @':name', ECL_NIL, @':version', ECL_NIL, @':defaults', phys); dir = si_coerce_to_filename(dir); file = cl_file_namestring(phys); l = dir->base_string.fillp; memcpy(strTempDir, dir->base_string.self, l); strTempDir[l] = 0; for (s = strTempDir; *s; s++) if (*s == '/') *s = '\\'; ecl_disable_interrupts(); ok = GetTempFileName(strTempDir, (char*)file->base_string.self, 0, strTempFileName); ecl_enable_interrupts(); if (!ok) { output = ECL_NIL; } else { l = strlen(strTempFileName); output = ecl_alloc_simple_base_string(l); memcpy(output->base_string.self, strTempFileName, l); } #else template = si_coerce_to_filename(template); l = template->base_string.fillp; output = ecl_alloc_simple_base_string(l + 6); memcpy(output->base_string.self, template->base_string.self, l); memcpy(output->base_string.self + l, "XXXXXX", 6); ecl_disable_interrupts(); # ifdef HAVE_MKSTEMP fd = mkstemp((char*)output->base_string.self); # else if (mktemp((char*)output->base_string.self)) { fd = open((char*)output->base_string.self, O_CREAT|O_TRUNC, 0666); } else { fd = -1; } # endif ecl_enable_interrupts(); if (fd < 0) { output = ECL_NIL; } else { close(fd); } #endif @(return (Null(output)? output : cl_truename(output))) } cl_object si_rmdir(cl_object directory) { return cl_delete_file(cl_make_pathname(6, @':name', ECL_NIL, @':type', ECL_NIL, @':defaults', directory)); } cl_object si_copy_file(cl_object orig, cl_object dest) { FILE *in, *out; int ok = 0; orig = si_coerce_to_filename(orig); dest = si_coerce_to_filename(dest); ecl_disable_interrupts(); in = fopen((char*)orig->base_string.self, OPEN_R); if (in) { out = fopen((char*)dest->base_string.self, OPEN_W); if (out) { unsigned char *buffer = ecl_alloc_atomic(1024); cl_index size; do { size = fread(buffer, 1, 1024, in); fwrite(buffer, 1, size, out); } while (size == 1024); ok = 1; fclose(out); } fclose(in); } ecl_enable_interrupts(); @(return (ok? ECL_T : ECL_NIL)) } cl_object si_chmod(cl_object file, cl_object mode) { mode_t code = ecl_to_uint32_t(mode); cl_object filename = coerce_to_posix_filename(file); unlikely_if (chmod((char*)filename->base_string.self, code)) { cl_object c_error = _ecl_strerror(errno); const char *msg = "Unable to change mode of file ~S to value ~O" "~%C library error: ~S"; si_signal_simple_error (6, @'file-error', /* condition */ ECL_T, /* continuable */ /* format */ ecl_make_constant_base_string(msg,strlen(msg)), cl_list(3, file, mode, c_error), /* format args */ @':pathname', /* file-error options */ file); } @(return) } ecl-16.1.2/src/c/unixint.d000066400000000000000000001442471266352375300152500ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* unixint.c -- Unix interrupt interface. */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. Copyright (c) 2016, Daniel KochmaХ„ski. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ /********************************************************************** * HOW WE HANDLE SIGNALS AND EXCEPTIONS * * (the following should be correlated with the manual) * * POSIX contemplates the notion of "signals", which are events that * cause a process or a thread to be interrupted. Windows uses the * term "exception", which includes also a more general kind of * errors. * * In both cases the consequence is that a thread or process may be * interrupted at any time, either by causes which are intrinsic to * them (synchronous signals), such as floating point exceptions, or * extrinsic (asynchronous signals), such as the process being aborted * by the user. * * Of course, those interruptions are not always welcome. When the * interrupt is delivered and a handler is invoked, the thread or even * the whole program may be in an inconsistent state. For instance the * thread may have acquired a lock, or it may be in the process of * filling the fields of a structure. Understanding this POSIX * restricts severely what functions can be called from a signal * handler, thereby limiting its usefulness. * * There is a simple solution, which ECL uses, and which is to mark * sections of code which are interruptible, and in which it is safe * for the handler to run arbitrary code, protect anything else. In * principle this "marking" can be done using POSIX functions such as * pthread_sigmask() or sigprocmask(). * * However in practice this is slow, as it involves at least a * function call, resolving thread-local variables, etc, etc, and it * will not work in Windows. Furthermore, sometimes we want signals to * be detected but not to be immediately processed. For instance, when * reading from the terminal we want to be able to interrupt the * process, but we can not execute the code from the handler, since * read() may leave the input stream in an inconsistent, or even * locked state. * * Our approach is slightly different: we install our own signal * hander which reads a single, thread-local variable stored in the * ecl_process_env()->disable_interrupts. If the variable marks that * signals should be postponed, then the information about the signal * is queued. Otherwise the appropriate code is executed: for instance * invoking the debugger, jumping to a condition handler, quitting, * etc. */ #ifdef __sun__ /* For SA_SIGINFO in Solaris. We could have used _XOPEN_SOURCE=600, but * this requires C99 and the default GCC for Solaris (3.4.3) does not * support this C standard. */ # define __EXTENSIONS__ #endif #include #include #include /* To get APCProc calls */ #define _WIN32_WINNT 0x400 #include #if defined(_MSC_VER) || defined(__MINGW32__) # include #endif #if !defined(_MSC_VER) # include #endif #include #ifdef ECL_USE_MPROTECT # ifndef SA_SIGINFO # error "We cannot use the mmap code without siginfo" # endif # include #endif #include #include #include static struct { int code; char *name; cl_object handler; } known_signals[] = { #ifdef SIGHUP { SIGHUP, "+SIGHUP+", ECL_NIL}, #endif #ifdef SIGINT { SIGINT, "+SIGINT+", @'si::terminal-interrupt'}, #endif #ifdef SIGQUIT { SIGQUIT, "+SIGQUIT+", ECL_NIL}, #endif #ifdef SIGILL { SIGILL, "+SIGILL+", @'ext::illegal-instruction'}, #endif #ifdef SIGTRAP { SIGTRAP, "+SIGTRAP+", ECL_NIL}, #endif #ifdef SIGABRT { SIGABRT, "+SIGABRT+", ECL_NIL}, #endif #ifdef SIGEMT { SIGEMT, "+SIGEMT+", ECL_NIL}, #endif #ifdef SIGFPE { SIGFPE, "+SIGFPE+", ECL_NIL}, #endif #ifdef SIGKILL { SIGKILL, "+SIGKILL+", ECL_NIL}, #endif #ifdef SIGBUS { SIGBUS, "+SIGBUS+", @'ext::segmentation-violation'}, #endif #ifdef SIGSEGV { SIGSEGV, "+SIGSEGV+", @'ext::segmentation-violation'}, #endif #ifdef SIGSYS { SIGSYS, "+SIGSYS+", ECL_NIL}, #endif #ifdef SIGPIPE { SIGPIPE, "+SIGPIPE+", ECL_NIL}, #endif #ifdef SIGALRM { SIGALRM, "+SIGALRM+", ECL_NIL}, #endif #ifdef SIGTERM { SIGTERM, "+SIGTERM+", ECL_NIL}, #endif #ifdef SIGURG { SIGURG, "+SIGURG+", ECL_NIL}, #endif #ifdef SIGSTOP { SIGSTOP, "+SIGSTOP+", ECL_NIL}, #endif #ifdef SIGTSTP { SIGTSTP, "+SIGTSTP+", ECL_NIL}, #endif #ifdef SIGCONT { SIGCONT, "+SIGCONT+", ECL_NIL}, #endif #ifdef SIGCHLD { SIGCHLD, "+SIGCHLD+", @'si::wait-for-all-processes'}, #endif #ifdef SIGTTIN { SIGTTIN, "+SIGTTIN+", ECL_NIL}, #endif #ifdef SIGTTOU { SIGTTOU, "+SIGTTOU+", ECL_NIL}, #endif #ifdef SIGIO { SIGIO, "+SIGIO+", ECL_NIL}, #endif #ifdef SIGXCPU { SIGXCPU, "+SIGXCPU+", ECL_NIL}, #endif #ifdef SIGXFSZ { SIGXFSZ, "+SIGXFSZ+", ECL_NIL}, #endif #ifdef SIGVTALRM { SIGVTALRM, "+SIGVTALRM+", ECL_NIL}, #endif #ifdef SIGPROF { SIGPROF, "+SIGPROF+", ECL_NIL}, #endif #ifdef SIGWINCH { SIGWINCH, "+SIGWINCH+", ECL_NIL}, #endif #ifdef SIGINFO { SIGINFO, "+SIGINFO+", ECL_NIL}, #endif #ifdef SIGUSR1 { SIGUSR1, "+SIGUSR1+", ECL_NIL}, #endif #ifdef SIGUSR2 { SIGUSR2, "+SIGUSR2+", ECL_NIL}, #endif #ifdef SIGTHR { SIGTHR, "+SIGTHR+", ECL_NIL}, #endif { -1, "", ECL_NIL } }; #ifdef HAVE_SIGPROCMASK static sigset_t main_thread_sigmask; # define handler_fn_prototype(name, sig, info, aux) name(sig, info, aux) # define call_handler(name, sig, info, aux) name(sig, info, aux) # define reinstall_signal(x,y) # define copy_siginfo(x,y) memcpy(x, y, sizeof(struct sigaction)) static void mysignal(int code, void *handler) { struct sigaction action; sigaction(code, NULL, &action); if (handler == SIG_IGN || handler == SIG_DFL) { action.sa_handler = handler; } else { #ifdef SA_SIGINFO /* void (*handler)(int, siginfo_t *, void*) */ action.sa_sigaction = handler; action.sa_flags = SA_SIGINFO; #else /* void (*handler)(int) */ action.sa_handler = handler; action.sa_flags = 0; #endif sigfillset(&action.sa_mask); } sigaction(code, &action, NULL); } #else /* HAVE_SIGPROCMASK */ # define handler_fn_prototype(name, sig, info, aux) name(sig) # define call_handler(name, sig, info, aux) name(sig) # define mysignal(x,y) signal(x,y) # define reinstall_signal(x,y) signal(x,y) # define copy_siginfo(x,y) #endif static bool zombie_process(cl_env_ptr the_env) { #ifdef ECL_THREADS if (the_env == NULL) { return 1; } else { /* When we are exiting a thread, we simply ignore all signals. */ cl_object process = the_env->own_process; return (process->process.phase == ECL_PROCESS_INACTIVE); } #else return !the_env; #endif } static ECL_INLINE bool interrupts_disabled_by_C(cl_env_ptr the_env) { return the_env->disable_interrupts; } static ECL_INLINE bool interrupts_disabled_by_lisp(cl_env_ptr the_env) { return !ecl_option_values[ECL_OPT_BOOTED] || Null(ECL_SYM_VAL(the_env, @'ext::*interrupts-enabled*')); } static void early_signal_error() ecl_attr_noreturn; static void early_signal_error() { ecl_internal_error("Got signal before environment was installed" " on our thread"); } static void illegal_signal_code(cl_object code) ecl_attr_noreturn; static void illegal_signal_code(cl_object code) { FEerror("Unknown signal code: ~D", 1, code); } /* On platforms in which mprotect() works, we block all write access * to the environment for a cheap check of pending interrupts. On * other platforms we change the value of disable_interrupts to 3, so * that we detect changes. */ static ECL_INLINE void set_guard_page(cl_env_ptr the_env) { #if defined(ECL_USE_MPROTECT) if (mprotect(the_env, sizeof(*the_env), PROT_READ) < 0) { ecl_internal_error("Unable to mprotect environment."); } #elif defined(ECL_USE_GUARD_PAGE) if (!VirtualProtect(the_env, sizeof(*the_env), PAGE_GUARD, NULL)) { ecl_internal_error("Unable to mprotect environment."); } #endif } static cl_object pop_signal(cl_env_ptr env); #define unblock_signal(env, sig) #ifdef HAVE_SIGPROCMASK # undef unblock_signal static void unblock_signal(cl_env_ptr the_env, int signal) { /* * We do not really "unblock" the signal, but rather restore * ECL's default sigmask. */ # ifdef ECL_THREADS pthread_sigmask(SIG_SETMASK, the_env->default_sigmask, NULL); # else sigprocmask(SIG_SETMASK, the_env->default_sigmask, NULL); # endif } #endif ecl_def_ct_base_string(str_ignore_signal,"Ignore signal",13,static,const); static void handle_signal_now(cl_object signal_code, cl_object process) { switch (ecl_t_of(signal_code)) { case t_fixnum: cl_cerror(4, str_ignore_signal, @'ext::unix-signal-received', @':code', signal_code); break; case t_symbol: /* * When we bind a handler to a signal, it may either * be a function, a symbol denoting a function or * a symbol denoting a condition. */ if (cl_find_class(2, signal_code, ECL_NIL) != ECL_NIL) cl_cerror(2, str_ignore_signal, signal_code); #ifdef ECL_THREADS else if (!Null(process)) _ecl_funcall3(signal_code, @':process', process); #endif else _ecl_funcall1(signal_code); break; case t_cfun: case t_cfunfixed: case t_cclosure: case t_bytecodes: case t_bclosure: _ecl_funcall1(signal_code); default: break; } } cl_object si_handle_signal(cl_object signal_code, cl_object process) { handle_signal_now(signal_code, process); @(return) } static void handle_all_queued(cl_env_ptr env) { while (env->pending_interrupt != ECL_NIL) { handle_signal_now(pop_signal(env), env->own_process); } } static void queue_signal(cl_env_ptr env, cl_object code, int allocate) { ECL_WITH_SPINLOCK_BEGIN(env, &env->signal_queue_spinlock) { cl_object record; if (allocate) { record = ecl_list1(ECL_NIL); } else { record = env->signal_queue; if (record != ECL_NIL) { env->signal_queue = ECL_CONS_CDR(record); } } if (record != ECL_NIL) { ECL_RPLACA(record, code); env->pending_interrupt = ecl_nconc(env->pending_interrupt, record); } } ECL_WITH_SPINLOCK_END; } static cl_object pop_signal(cl_env_ptr env) { cl_object record, value; if (env->pending_interrupt == ECL_NIL) { return ECL_NIL; } ECL_WITH_SPINLOCK_BEGIN(env, &env->signal_queue_spinlock) { record = env->pending_interrupt; value = ECL_CONS_CAR(record); env->pending_interrupt = ECL_CONS_CDR(record); /* Save some conses for future use, to avoid allocating */ if (ECL_SYMBOLP(value) || ECL_FIXNUMP(value)) { ECL_RPLACD(record, env->signal_queue); env->signal_queue = record; } } ECL_WITH_SPINLOCK_END; return value; } static void handle_or_queue(cl_env_ptr the_env, cl_object signal_code, int code) { if (Null(signal_code) || signal_code == NULL) return; /* * If interrupts are disabled by lisp we are not so eager on * detecting when the interrupts become enabled again. We * queue the signal and are done with that. */ if (interrupts_disabled_by_lisp(the_env)) { queue_signal(the_env, signal_code, 0); } /* * If interrupts are disabled by C, and we have not pushed a * pending signal, save this signal and return. */ else if (interrupts_disabled_by_C(the_env)) { the_env->disable_interrupts = 3; queue_signal(the_env, signal_code, 0); set_guard_page(the_env); } /* * If interrupts are enabled, that means we are in a safe area * and may execute arbitrary lisp code. We can thus call the * appropriate handlers. */ else { if (code) unblock_signal(the_env, code); si_trap_fpe(@'last', ECL_T); /* Clear FPE exception flag */ handle_signal_now(signal_code, the_env->own_process); } } static void handler_fn_prototype(non_evil_signal_handler, int sig, siginfo_t *siginfo, void *data) { int old_errno = errno; cl_env_ptr the_env; cl_object signal_object; reinstall_signal(sig, non_evil_signal_handler); /* The lisp environment might not be installed. */ the_env = ecl_process_env(); unlikely_if (zombie_process(the_env)) return; signal_object = ecl_gethash_safe(ecl_make_fixnum(sig), cl_core.known_signals, ECL_NIL); handle_or_queue(the_env, signal_object, sig); errno = old_errno; } static void handler_fn_prototype(evil_signal_handler, int sig, siginfo_t *siginfo, void *data) { int old_errno = errno; cl_env_ptr the_env; cl_object signal_object; reinstall_signal(sig, evil_signal_handler); /* The lisp environment might not be installed. */ the_env = ecl_process_env(); unlikely_if (zombie_process(the_env)) return; signal_object = ecl_gethash_safe(ecl_make_fixnum(sig), cl_core.known_signals, ECL_NIL); handle_signal_now(signal_object, the_env->own_process); errno = old_errno; } #if defined(ECL_THREADS) && defined(HAVE_SIGPROCMASK) typedef struct { cl_object process; int signo; } signal_thread_message; static cl_object signal_thread_process = ECL_NIL; static signal_thread_message signal_thread_msg; static cl_object signal_thread_spinlock = ECL_NIL; static int signal_thread_pipe[2] = {-1,-1}; static void handler_fn_prototype(deferred_signal_handler, int sig, siginfo_t *siginfo, void *data) { int old_errno = errno; cl_env_ptr the_env; signal_thread_message msg; reinstall_signal(sig, deferred_signal_handler); /* The lisp environment might not be installed. */ the_env = ecl_process_env(); unlikely_if (zombie_process(the_env)) return; msg.signo = sig; msg.process = the_env->own_process; if (msg.process == signal_thread_process) { /* The signal handling thread may also receive signals. In * this case we do not use the pipe, but just copy the message * Note that read() will abort the thread will get notified. */ signal_thread_msg = msg; } else if (signal_thread_pipe[1] > 0) { ecl_get_spinlock(the_env, &signal_thread_spinlock); write(signal_thread_pipe[1], &msg, sizeof(msg)); ecl_giveup_spinlock(&signal_thread_spinlock); } else { /* Nothing to do. There is no way to handle this signal because * the responsible thread is not running */ } errno = old_errno; } static cl_object asynchronous_signal_servicing_thread() { const cl_env_ptr the_env = ecl_process_env(); int interrupt_signal = -1; /* * We block all signals except the usual interrupt thread and GC signals. */ { sigset_t handled_set; sigfillset(&handled_set); if (ecl_option_values[ECL_OPT_TRAP_INTERRUPT_SIGNAL]) { interrupt_signal = ecl_option_values[ECL_OPT_THREAD_INTERRUPT_SIGNAL]; sigdelset(&handled_set, interrupt_signal); sigdelset(&handled_set, GC_get_suspend_signal()); sigdelset(&handled_set, GC_get_thr_restart_signal()); } pthread_sigmask(SIG_BLOCK, &handled_set, NULL); } /* * We create the object for communication. We need a lock to prevent other * threads from writing before the pipe is created. */ ecl_get_spinlock(the_env, &signal_thread_spinlock); pipe(signal_thread_pipe); ecl_giveup_spinlock(&signal_thread_spinlock); signal_thread_msg.process = ECL_NIL; for (;;) { cl_object signal_code; signal_thread_msg.process = ECL_NIL; if (read(signal_thread_pipe[0], &signal_thread_msg, sizeof(signal_thread_msg)) < 0) { /* Either the pipe errs or we have received an interrupt * from a different thread */ if (errno != EINTR || signal_thread_msg.process != the_env->own_process) break; } /* We have queued ourselves an interrupt event */ if (signal_thread_msg.signo == interrupt_signal && signal_thread_msg.process == the_env->own_process) { break; } #ifdef SIGCHLD if (signal_thread_msg.signo == SIGCHLD) { si_wait_for_all_processes(0); continue; } #endif signal_code = ecl_gethash_safe(ecl_make_fixnum(signal_thread_msg.signo), cl_core.known_signals, ECL_NIL); if (!Null(signal_code)) { mp_process_run_function(4, @'si::handle-signal', @'si::handle-signal', signal_code, signal_thread_msg.process); } } # if defined(ECL_USE_MPROTECT) /* We might have protected our own environment */ mprotect(the_env, sizeof(*the_env), PROT_READ | PROT_WRITE); # endif /* ECL_USE_MPROTECT */ close(signal_thread_pipe[0]); close(signal_thread_pipe[1]); ecl_return0(the_env); } #endif /* ECL_THREADS && !ECL_MS_WINDOWS_HOST */ #if defined(ECL_THREADS) && !defined(ECL_MS_WINDOWS_HOST) static void handler_fn_prototype(process_interrupt_handler, int sig, siginfo_t *siginfo, void *data) { int old_errno = errno; cl_env_ptr the_env; reinstall_signal(sig, process_interrupt_handler); /* The lisp environment might not be installed. */ the_env = ecl_process_env(); if (zombie_process(the_env)) return; if (!Null(the_env->pending_interrupt)) { if (interrupts_disabled_by_C(the_env)) { set_guard_page(the_env); } else if (!interrupts_disabled_by_lisp(the_env)) { unblock_signal(the_env, sig); handle_all_queued(the_env); } } errno = old_errno; } #endif /* ECL_THREADS && !ECL_MS_WINDOWS_HOST */ static void handler_fn_prototype(fpe_signal_handler, int sig, siginfo_t *info, void *data) { int code; cl_object condition; cl_env_ptr the_env; reinstall_signal(sig, fpe_signal_handler); /* The lisp environment might not be installed. */ unlikely_if (!ecl_option_values[ECL_OPT_BOOTED]) { early_signal_error(); } the_env = ecl_process_env(); unlikely_if (zombie_process(the_env)) return; condition = @'arithmetic-error'; code = 0; #ifdef _MSC_VER switch (_fpecode) { case _FPE_INVALID: condition = @'floating-point-invalid-operation'; code = FE_INVALID; break; case _FPE_OVERFLOW: condition = @'floating-point-overflow'; code = FE_OVERFLOW; break; case _FPE_UNDERFLOW: condition = @'floating-point-underflow'; code = FE_UNDERFLOW; break; case _FPE_ZERODIVIDE: condition = @'division-by-zero'; code = FE_DIVBYZERO; break; } #else /* !_MSC_VER */ # if defined(HAVE_FENV_H) & !defined(ECL_AVOID_FENV_H) code = fetestexcept(FE_ALL_EXCEPT); if (code & FE_DIVBYZERO) { condition = @'division-by-zero'; code = FE_DIVBYZERO; } else if (code & FE_INVALID) { condition = @'floating-point-invalid-operation'; code = FE_INVALID; } else if (code & FE_OVERFLOW) { condition = @'floating-point-overflow'; code = FE_OVERFLOW; } else if (code & FE_UNDERFLOW) { condition = @'floating-point-underflow'; code = FE_UNDERFLOW; } else if (code & FE_INEXACT) { condition = @'floating-point-inexact'; code = FE_INEXACT; } feclearexcept(FE_ALL_EXCEPT); # endif #endif /* !_MSC_VER */ #if defined(SA_SIGINFO) && !defined(NACL) if (info) { if (info->si_code == FPE_INTDIV || info->si_code == FPE_FLTDIV) { condition = @'division-by-zero'; code = FE_DIVBYZERO; } else if (info->si_code == FPE_FLTOVF) { condition = @'floating-point-overflow'; code = FE_OVERFLOW; } else if (info->si_code == FPE_FLTUND) { condition = @'floating-point-underflow'; code = FE_UNDERFLOW; } else if (info->si_code == FPE_FLTRES) { condition = @'floating-point-inexact'; code = FE_INEXACT; } else if (info->si_code == FPE_FLTINV) { condition = @'floating-point-invalid-operation'; code = FE_INVALID; } } #endif /* SA_SIGINFO */ /* if (code && !(code & the_env->trap_fpe_bits)) condition = ECL_NIL; */ si_trap_fpe(@'last', ECL_T); /* Clear FPE exception flag */ unblock_signal(the_env, code); handle_signal_now(condition, the_env->own_process); /* We will not reach past this point. */ } static void handler_fn_prototype(sigsegv_handler, int sig, siginfo_t *info, void *aux) { int old_errno = errno; static const char *stack_overflow_msg = "\n;;;\n;;; Stack overflow.\n" ";;; Jumping to the outermost toplevel prompt\n" ";;;\n\n"; static const char *segv_msg = "\n;;;\n" ";;; Detected access to protected memory, " "also kwown as 'bus or segmentation fault'.\n" ";;; Jumping to the outermost toplevel prompt\n" ";;;\n\n"; cl_env_ptr the_env; reinstall_signal(sig, sigsegv_handler); /* The lisp environment might not be installed. */ unlikely_if (!ecl_option_values[ECL_OPT_BOOTED]) { early_signal_error(); } the_env = ecl_process_env(); unlikely_if (zombie_process(the_env)) return; #if defined(SA_SIGINFO) && !defined(NACL) # if defined(ECL_USE_MPROTECT) /* We access the environment when it was protected. That * means there was a pending signal. */ if (((char*)the_env <= (char*)info->si_addr) && ((char*)info->si_addr <= (char*)(the_env+1))) { mprotect(the_env, sizeof(*the_env), PROT_READ | PROT_WRITE); the_env->disable_interrupts = 0; unblock_signal(the_env, sig); handle_all_queued(the_env); return; } # endif /* ECL_USE_MPROTECT */ # ifdef ECL_DOWN_STACK if (sig == SIGSEGV && (char*)info->si_addr > the_env->cs_barrier && (char*)info->si_addr <= the_env->cs_org) { unblock_signal(the_env, sig); ecl_unrecoverable_error(the_env, stack_overflow_msg); return; } # else if (sig == SIGSEGV && (char*)info->si_addr < the_env->cs_barrier && (char*)info->si_addr >= the_env->cs_org) { unblock_signal(the_env, sig); ecl_unrecoverable_error(the_env, stack_overflow_msg); return; } # endif /* ECL_DOWN_STACK */ /* Do not attempt an error handler if we nest two serious * errors in the same thread */ if (the_env->fault_address == info->si_addr) { the_env->fault_address = info->si_addr; unblock_signal(the_env, sig); ecl_unrecoverable_error(the_env, segv_msg); } else { the_env->fault_address = info->si_addr; handle_or_queue(the_env, @'ext::segmentation-violation', sig); } #else /* * We cannot distinguish between a stack overflow and a simple * access violation. Thus we assume the worst case and jump to * the outermost handler. */ unblock_signal(the_env, sig); ecl_unrecoverable_error(the_env, segv_msg); #endif /* SA_SIGINFO */ errno = old_errno; } cl_object si_check_pending_interrupts(void) { handle_all_queued(ecl_process_env()); @(return) } void ecl_check_pending_interrupts(cl_env_ptr env) { handle_all_queued(env); } static cl_object do_catch_signal(int code, cl_object action, cl_object process) { if (action == ECL_NIL || action == @':ignore') { mysignal(code, SIG_IGN); return ECL_T; } else if (action == @':default') { mysignal(code, SIG_DFL); return ECL_T; } else if (action == @':mask' || action == @':unmask') { #ifdef HAVE_SIGPROCMASK # ifdef ECL_THREADS /* When a process object is supplied, the changes take care * on the process structure and will only take effect when * the process is enabled. */ if (ecl_t_of(process) == t_process) { cl_env_ptr env = process->process.env; sigset_t *handled_set = (sigset_t *)env->default_sigmask; if (action == @':mask') { sigaddset(handled_set, code); } else { sigdelset(handled_set, code); } return ECL_T; } else { sigset_t handled_set; pthread_sigmask(SIG_SETMASK, NULL, &handled_set); if (action == @':mask') { sigaddset(&handled_set, code); } else { sigdelset(&handled_set, code); } pthread_sigmask(SIG_SETMASK, &handled_set, NULL); return ECL_T; } # else { sigset_t handled_set; sigprocmask(SIG_SETMASK, NULL, &handled_set); if (action == @':mask') { sigaddset(&handled_set, code); } else { sigdelset(&handled_set, code); } sigprocmask(SIG_SETMASK, &handled_set, NULL); return ECL_T; } # endif /* !ECL_THREADS */ #else /* !HAVE_SIGPROCMASK */ return ECL_NIL; #endif /* !HAVE_SIGPROCMASK */ } else if (action == ECL_T || action == @':catch') { if (code == SIGSEGV) { mysignal(code, sigsegv_handler); } #ifdef SIGBUS else if (code == SIGBUS) { mysignal(code, sigsegv_handler); } #endif #ifdef SIGILL else if (code == SIGILL) { mysignal(SIGILL, evil_signal_handler); } #endif #if defined(SIGCHLD) && defined(ECL_THREADS) else if (code == SIGCHLD && ecl_option_values[ECL_OPT_SIGNAL_HANDLING_THREAD]) { /* Do nothing. This is taken care of in * the asynchronous signal handler. */ } #endif else { mysignal(code, non_evil_signal_handler); } return ECL_T; } else { FEerror("Unknown 2nd argument to EXT:CATCH-SIGNAL: ~A", 1, action); } } cl_object si_get_signal_handler(cl_object code) { cl_object handler = ecl_gethash_safe(code, cl_core.known_signals, OBJNULL); unlikely_if (handler == OBJNULL) { illegal_signal_code(code); } @(return handler) } cl_object si_set_signal_handler(cl_object code, cl_object handler) { cl_object action = ecl_gethash_safe(code, cl_core.known_signals, OBJNULL); unlikely_if (action == OBJNULL) { illegal_signal_code(code); } ecl_sethash(code, cl_core.known_signals, handler); si_catch_signal(2, code, ECL_T); @(return handler) } @(defun ext::catch-signal (code flag &key process) @ { int code_int; unlikely_if (ecl_gethash_safe(code, cl_core.known_signals, OBJNULL) == OBJNULL) { illegal_signal_code(code); } code_int = ecl_fixnum(code); #ifdef GBC_BOEHM # ifdef SIGSEGV unlikely_if ((code == ecl_make_fixnum(SIGSEGV)) && ecl_option_values[ECL_OPT_INCREMENTAL_GC]) FEerror("It is not allowed to change the behavior of SIGSEGV.", 0); # endif # ifdef SIGBUS unlikely_if (code_int == SIGBUS) FEerror("It is not allowed to change the behavior of SIGBUS.", 0); # endif #endif #if defined(ECL_THREADS) && !defined(ECL_MS_WINDOWS_HOST) unlikely_if (code_int == ecl_option_values[ECL_OPT_THREAD_INTERRUPT_SIGNAL]) { FEerror("It is not allowed to change the behavior of signal ~D", 1, code); } #endif #ifdef SIGFPE unlikely_if (code_int == SIGFPE) { FEerror("The signal handler for SIGPFE cannot be uninstalled. Use SI:TRAP-FPE instead.", 0); } #endif @(return do_catch_signal(code_int, flag, process)); } @) #ifdef ECL_THREADS # ifdef ECL_WINDOWS_THREADS static VOID CALLBACK wakeup_function(ULONG_PTR foo) { cl_env_ptr env = ecl_process_env(); volatile i = env->nvalues; env->nvalues = i; } static VOID CALLBACK wakeup_noop(ULONG_PTR foo) { } # endif static bool do_interrupt_thread(cl_object process) { # ifdef ECL_WINDOWS_THREADS # ifndef ECL_USE_GUARD_PAGE # error "Cannot implement ecl_interrupt_process without guard pages" # endif HANDLE thread = (HANDLE)process->process.thread; CONTEXT context; void *trap_address = process->process.env; DWORD guard = PAGE_GUARD | PAGE_READWRITE; int ok = 1; if (SuspendThread(thread) == (DWORD)-1) { FEwin32_error("Unable to suspend thread ~A", 1, process); ok = 0; goto EXIT; } process->process.interrupt = ECL_T; if (!VirtualProtect(process->process.env, sizeof(struct cl_env_struct), guard, &guard)) { FEwin32_error("Unable to protect memory from thread ~A", 1, process); ok = 0; } RESUME: if (!QueueUserAPC(wakeup_function, thread, 0)) { FEwin32_error("Unable to queue APC call to thread ~A", 1, process); ok = 0; } if (ResumeThread(thread) == (DWORD)-1) { FEwin32_error("Unable to resume thread ~A", 1, process); ok = 0; goto EXIT; } EXIT: return ok; # else int signal = ecl_option_values[ECL_OPT_THREAD_INTERRUPT_SIGNAL]; if (pthread_kill(process->process.thread, signal)) { FElibc_error("Unable to interrupt process ~A", 1, process); } return 1; # endif } void ecl_interrupt_process(cl_object process, cl_object function) { /* * We first ensure that the process is active and running * and past the initialization phase, where it has set up * the environment. Then: * - In Windows it sets up a trap in the stack, so that the * uncaught exception handler can catch it and process it. * - In POSIX systems it sends a user level interrupt to * the thread, which then decides how to act. * * If FUNCTION is NIL, we just intend to wake up the process * from some call to ecl_musleep() Queue the interrupt for any * process stage that can potentially receive a signal */ if (!Null(function) && (process->process.phase >= ECL_PROCESS_BOOTING)) { function = si_coerce_to_function(function); queue_signal(process->process.env, function, 1); } /* ... but only deliver if the process is still alive */ if (process->process.phase == ECL_PROCESS_ACTIVE) do_interrupt_thread(process); } void ecl_wakeup_process(cl_object process) { # ifdef ECL_WINDOWS_THREADS HANDLE thread = (HANDLE)process->process.thread; if (!QueueUserAPC(wakeup_noop, thread, 0)) { FEwin32_error("Unable to queue APC call to thread ~A", 1, process); } # else do_interrupt_thread(process); # endif } #endif /* ECL_THREADS */ #ifdef ECL_WINDOWS_THREADS static LPTOP_LEVEL_EXCEPTION_FILTER old_W32_exception_filter = NULL; LONG WINAPI _ecl_w32_exception_filter(struct _EXCEPTION_POINTERS* ep) { LONG excpt_result; cl_env_ptr the_env = ecl_process_env(); excpt_result = EXCEPTION_CONTINUE_EXECUTION; switch (ep->ExceptionRecord->ExceptionCode) { /* Access to guard page */ case STATUS_GUARD_PAGE_VIOLATION: { cl_object process = the_env->own_process; if (!Null(process->process.interrupt)) { cl_object signal = pop_signal(the_env); process->process.interrupt = ECL_NIL; while (signal != ECL_NIL && signal) { handle_signal_now(signal, the_env->own_process); signal = pop_signal(the_env); } return EXCEPTION_CONTINUE_EXECUTION; } } /* Catch all arithmetic exceptions */ case EXCEPTION_INT_DIVIDE_BY_ZERO: feclearexcept(FE_ALL_EXCEPT); handle_signal_now(@'division-by-zero', the_env->own_process); return EXCEPTION_CONTINUE_EXECUTION; case EXCEPTION_INT_OVERFLOW: feclearexcept(FE_ALL_EXCEPT); handle_signal_now(@'arithmetic-error', the_env->own_process); return EXCEPTION_CONTINUE_EXECUTION; case EXCEPTION_FLT_DIVIDE_BY_ZERO: feclearexcept(FE_ALL_EXCEPT); handle_signal_now(@'floating-point-overflow', the_env->own_process); return EXCEPTION_CONTINUE_EXECUTION; case EXCEPTION_FLT_OVERFLOW: feclearexcept(FE_ALL_EXCEPT); handle_signal_now(@'floating-point-overflow', the_env->own_process); return EXCEPTION_CONTINUE_EXECUTION; case EXCEPTION_FLT_UNDERFLOW: feclearexcept(FE_ALL_EXCEPT); handle_signal_now(@'floating-point-underflow', the_env->own_process); return EXCEPTION_CONTINUE_EXECUTION; case EXCEPTION_FLT_INEXACT_RESULT: feclearexcept(FE_ALL_EXCEPT); handle_signal_now(@'floating-point-inexact', the_env->own_process); return EXCEPTION_CONTINUE_EXECUTION; case EXCEPTION_FLT_DENORMAL_OPERAND: case EXCEPTION_FLT_INVALID_OPERATION: feclearexcept(FE_ALL_EXCEPT); handle_signal_now(@'floating-point-invalid-operation', the_env->own_process); return EXCEPTION_CONTINUE_EXECUTION; case EXCEPTION_FLT_STACK_CHECK: handle_signal_now(@'arithmetic-error', the_env->own_process); return EXCEPTION_CONTINUE_EXECUTION; /* Catch segmentation fault */ case EXCEPTION_ACCESS_VIOLATION: handle_signal_now(@'ext::segmentation-violation', the_env->own_process); return EXCEPTION_CONTINUE_EXECUTION; /* Catch illegal instruction */ case EXCEPTION_ILLEGAL_INSTRUCTION: handle_signal_now(@'ext::illegal-instruction', the_env->own_process); return EXCEPTION_CONTINUE_EXECUTION; /* Do not catch anything else */ default: excpt_result = EXCEPTION_CONTINUE_SEARCH; break; } if (old_W32_exception_filter) return old_W32_exception_filter(ep); return excpt_result; } static cl_object W32_handle_in_new_thread(cl_object signal_code) { /* XXX: there is some bug present only on windows platform with importing the current thread. Don't know how to track it though. */ #if 0 int outside_ecl = ecl_import_current_thread(@'si::handle-signal', ECL_NIL); mp_process_run_function(4, @'si::handle-signal', @'si::handle-signal', signal_code, ECL_NIL); if (outside_ecl) ecl_release_current_thread(); #endif /* 0 */ } BOOL WINAPI W32_console_ctrl_handler(DWORD type) { switch (type) { case CTRL_C_EVENT: case CTRL_BREAK_EVENT: { /* cl_object function = */ /* ECL_SYM_FUN(@'si::terminal-interrupt'); */ /* if (function) */ /* W32_handle_in_new_thread(function); */ return TRUE; } case CTRL_CLOSE_EVENT: case CTRL_LOGOFF_EVENT: case CTRL_SHUTDOWN_EVENT: /* Doing nothing is arguably the most reasonable. Calling (quit) causes process to exit and Windows has problems, because "process has unexpectably died.*/ return TRUE; default: return FALSE; } } #endif /* ECL_WINDOWS_THREADS */ cl_object si_trap_fpe(cl_object condition, cl_object flag) { cl_env_ptr the_env = ecl_process_env(); #ifndef FE_ALL_EXCEPT # define FE_ALL_EXCEPT FE_DIVBYZERO | FE_OVERFLOW | FE_UNDERFLOW | FE_INVALID #endif const int all = FE_ALL_EXCEPT; int bits = 0; if (condition == @'last') { bits = the_env->trap_fpe_bits; } else { if (condition == ECL_T) bits = FE_DIVBYZERO | FE_OVERFLOW | FE_UNDERFLOW | FE_INVALID; else if (condition == @'division-by-zero') bits = FE_DIVBYZERO; else if (condition == @'floating-point-overflow') bits = FE_OVERFLOW; else if (condition == @'floating-point-underflow') bits = FE_UNDERFLOW; else if (condition == @'floating-point-invalid-operation') bits = FE_INVALID; else if (condition == @'floating-point-inexact') bits = FE_INEXACT; else if (ECL_FIXNUMP(condition)) bits = ecl_fixnum(condition) & all; if (flag == ECL_NIL) { bits = the_env->trap_fpe_bits & ~bits; } else { bits = the_env->trap_fpe_bits | bits; } } #if !defined(ECL_AVOID_FPE_H) # ifdef HAVE_FENV_H feclearexcept(all); # endif # if defined(ECL_MS_WINDOWS_HOST) _fpreset(); # endif # ifdef HAVE_FEENABLEEXCEPT fedisableexcept(all & ~bits); feenableexcept(all & bits); # endif #endif the_env->trap_fpe_bits = bits; @(return ecl_make_fixnum(bits)) } /* * In this code we decide whether to install a process-wide signal * handler for each of the asynchronous signals (SIGINT, SIGTERM, * SIGCHLD...) or we block the signal and let the background thread * detect and process them. */ static void install_asynchronous_signal_handlers() { #if defined(ECL_MS_WINDOWS_HOST) # define async_handler(signal,handler,mask) #else # if defined(ECL_THREADS) && defined(HAVE_SIGPROCMASK) # define async_handler(signal,handler,mask) { \ if (ecl_option_values[ECL_OPT_SIGNAL_HANDLING_THREAD]) { \ mysignal(signal, deferred_signal_handler); \ } else { \ mysignal(signal,handler); \ }} # else # define async_handler(signal,handler,mask) \ mysignal(signal,handler) # endif #endif #ifdef HAVE_SIGPROCMASK sigset_t *sigmask = cl_core.default_sigmask = &main_thread_sigmask; cl_core.default_sigmask_bytes = sizeof(sigset_t); # ifdef ECL_THREADS pthread_sigmask(SIG_SETMASK, NULL, sigmask); # else sigprocmask(SIG_SETMASK, NULL, sigmask); # endif #endif #ifdef SIGINT if (ecl_option_values[ECL_OPT_TRAP_SIGINT]) { async_handler(SIGINT, non_evil_signal_handler, sigmask); } #endif #ifdef SIGCHLD if (ecl_option_values[ECL_OPT_TRAP_SIGCHLD]) { /* We have to set the process signal handler explicitly, * because on many platforms the default is SIG_IGN. */ mysignal(SIGCHLD, non_evil_signal_handler); async_handler(SIGCHLD, non_evil_signal_handler, sigmask); } #endif #ifdef HAVE_SIGPROCMASK # if defined(ECL_THREADS) pthread_sigmask(SIG_SETMASK, sigmask, NULL); # else sigprocmask(SIG_SETMASK, sigmask, NULL); # endif #endif #ifdef ECL_WINDOWS_THREADS old_W32_exception_filter = SetUnhandledExceptionFilter(_ecl_w32_exception_filter); if (ecl_option_values[ECL_OPT_TRAP_SIGINT]) { SetConsoleCtrlHandler(W32_console_ctrl_handler, TRUE); } #endif #undef async_handler } /* * In POSIX systems we may set up a background thread that detects * synchronous signals and spawns a new thread to handle each of them. */ static void install_signal_handling_thread() { #if defined(ECL_THREADS) && defined(HAVE_SIGPROCMASK) ecl_process_env()->default_sigmask = &main_thread_sigmask; if (ecl_option_values[ECL_OPT_SIGNAL_HANDLING_THREAD]) { cl_object fun = ecl_make_cfun((cl_objectfn_fixed) asynchronous_signal_servicing_thread, @'si::signal-servicing', ECL_NIL, 0); cl_object process = signal_thread_process = mp_process_run_function_wait(2, @'si::signal-servicing', fun); if (Null(process)) { ecl_internal_error("Unable to create signal " "servicing thread"); } } #endif } /* * This routine sets up handlers for all exceptions, such as access to * restricted regions of memory. They have to be set up before we call * init_GC(). */ static void install_synchronous_signal_handlers() { #ifdef SIGBUS if (ecl_option_values[ECL_OPT_TRAP_SIGBUS]) { do_catch_signal(SIGBUS, ECL_T, ECL_NIL); } #endif #ifdef SIGSEGV if (ecl_option_values[ECL_OPT_TRAP_SIGSEGV]) { do_catch_signal(SIGSEGV, ECL_T, ECL_NIL); } #endif #ifdef SIGPIPE if (ecl_option_values[ECL_OPT_TRAP_SIGPIPE]) { do_catch_signal(SIGPIPE, ECL_T, ECL_NIL); } #endif #ifdef SIGILL if (ecl_option_values[ECL_OPT_TRAP_SIGILL]) { do_catch_signal(SIGILL, ECL_T, ECL_NIL); } #endif /* In order to implement MP:INTERRUPT-PROCESS, MP:PROCESS-KILL * and the like, we use signals. This sets up a synchronous * signal handler for that particular signal. */ #ifdef SIGRTMIN # define DEFAULT_THREAD_INTERRUPT_SIGNAL SIGRTMIN + 2 #else # define DEFAULT_THREAD_INTERRUPT_SIGNAL SIGUSR1 #endif #if defined(ECL_THREADS) && !defined(ECL_MS_WINDOWS_HOST) if (ecl_option_values[ECL_OPT_TRAP_INTERRUPT_SIGNAL]) { int signal = ecl_option_values[ECL_OPT_THREAD_INTERRUPT_SIGNAL]; if (signal == 0) { signal = DEFAULT_THREAD_INTERRUPT_SIGNAL; ecl_set_option(ECL_OPT_THREAD_INTERRUPT_SIGNAL, signal); } mysignal(signal, process_interrupt_handler); #ifdef HAVE_SIGPROCMASK sigdelset(&main_thread_sigmask, signal); pthread_sigmask(SIG_SETMASK, &main_thread_sigmask, NULL); #endif } #endif } /* * This routine sets up handlers for floating point exceptions. We * cannot do it earlier because it requires the memory allocator to * be set up. */ static void install_fpe_signal_handlers() { #ifdef SIGFPE if (ecl_option_values[ECL_OPT_TRAP_SIGFPE]) { mysignal(SIGFPE, fpe_signal_handler); si_trap_fpe(ECL_T, ECL_T); # ifdef ECL_IEEE_FP /* By default deactivate errors and accept * denormals in floating point computations */ si_trap_fpe(@'floating-point-invalid-operation', ECL_NIL); si_trap_fpe(@'division-by-zero', ECL_NIL); si_trap_fpe(@'floating-point-overflow', ECL_NIL); # endif } #endif } /* * Create one Common Lisp constant for each signal that we know, * such as +SIGINT+ for SIGINT, etc. */ static void add_one_signal(cl_object hash_table, int signal, cl_object name, cl_object handler) { cl_object code = ecl_make_fixnum(signal); cl_export2(name, cl_core.ext_package); si_Xmake_constant(name, code); ecl_sethash(code, hash_table, handler); } static void create_signal_code_constants() { cl_object hash = cl_core.known_signals = cl__make_hash_table(@'eql', ecl_make_fixnum(128), cl_core.rehash_size, cl_core.rehash_threshold); int i; for (i = 0; known_signals[i].code >= 0; i++) { add_one_signal(hash, known_signals[i].code, _ecl_intern(known_signals[i].name, cl_core.ext_package), known_signals[i].handler); } #ifdef SIGRTMIN for (i = SIGRTMIN; i <= SIGRTMAX; i++) { int intern_flag[1]; char buffer[64]; cl_object name; sprintf(buffer, "+SIGRT%d+", i-SIGRTMIN); name = ecl_intern(make_base_string_copy(buffer), cl_core.ext_package, intern_flag); add_one_signal(hash, i, name, ECL_NIL); } add_one_signal(hash, SIGRTMIN, _ecl_intern("+SIGRTMIN+", cl_core.ext_package), ECL_NIL); add_one_signal(hash, SIGRTMAX, _ecl_intern("+SIGRTMAX+", cl_core.ext_package), ECL_NIL); #endif } void init_unixint(int pass) { if (pass == 0) { install_asynchronous_signal_handlers(); install_synchronous_signal_handlers(); } else { create_signal_code_constants(); install_fpe_signal_handlers(); install_signal_handling_thread(); ECL_SET(@'ext::*interrupts-enabled*', ECL_T); ecl_process_env()->disable_interrupts = 0; } } ecl-16.1.2/src/c/unixsys.d000066400000000000000000000723001266352375300152620ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* unixsys.s -- Unix shell interface. */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #include #include #include #include #include /* to see whether we have SIGCHLD */ #if !defined(_MSC_VER) # include #endif #include #include #ifdef cygwin # include /* For cygwin_attach_handle_to_fd() */ #endif #if defined(ECL_MS_WINDOWS_HOST) || defined(cygwin) # include #endif #ifdef HAVE_SYS_WAIT_H # include #endif #include /* Mingw defines 'environ' to be a macro instead of a global variable. */ #ifdef environ # undef environ #endif cl_object si_getpid(void) { #if defined(NACL) FElibc_error("si_getpid not implemented",1); @(return Cnil) #else @(return ecl_make_fixnum(getpid())) #endif } cl_object si_getuid(void) { #if defined(ECL_MS_WINDOWS_HOST) @(return ecl_make_fixnum(0)); #else @(return ecl_make_integer(getuid())); #endif } ecl_def_ct_base_string(fake_in_name, "PIPE-READ-ENDPOINT", 18, static, const); ecl_def_ct_base_string(fake_out_name, "PIPE-WRITE-ENDPOINT", 19, static, const); cl_object si_make_pipe() { #if defined(NACL) FElibc_error("si_make_pipe not implemented",1); @(return Cnil) #else cl_object output; int fds[2], ret; #if defined(ECL_MS_WINDOWS_HOST) ret = _pipe(fds, 4096, _O_BINARY); #else ret = pipe(fds); #endif if (ret < 0) { FElibc_error("Unable to create pipe", 0); output = ECL_NIL; } else { cl_object in = ecl_make_stream_from_fd(fake_in_name, fds[0], ecl_smm_input, 8, ECL_STREAM_DEFAULT_FORMAT, ECL_NIL); cl_object out = ecl_make_stream_from_fd(fake_out_name, fds[1], ecl_smm_output, 8, ECL_STREAM_DEFAULT_FORMAT, ECL_NIL); output = cl_make_two_way_stream(in, out); } @(return output) #endif } static cl_object from_list_to_execve_argument(cl_object l, char ***environp) { cl_object p; cl_index i, j, total_size = 0, nstrings = 0; cl_object buffer; char **environ; for (p = l; !Null(p); p = ECL_CONS_CDR(p)) { cl_object s; if (!CONSP(p)) { FEerror("In EXT:RUN-PROGRAM, environment " "is not a list of strings", 0); } s = ECL_CONS_CAR(p); if (!ECL_BASE_STRING_P(s)) { FEerror("In EXT:RUN-PROGRAM, environment " "is not a list of base strings", 0); } total_size += s->base_string.fillp + 1; nstrings++; } /* Extra place for ending null */ total_size++; buffer = ecl_alloc_simple_base_string(++total_size); environ = ecl_alloc_atomic((nstrings + 1) * sizeof(char*)); for (j = i = 0, p = l; !Null(p); p = ECL_CONS_CDR(p)) { cl_object s = ECL_CONS_CAR(p); cl_index l = s->base_string.fillp; if (i + l + 1 >= total_size) { FEerror("In EXT:RUN-PROGRAM, environment list" " changed during execution.", 0); break; } environ[j++] = (char*)(buffer->base_string.self + i); memcpy(buffer->base_string.self + i, s->base_string.self, l); i += l; buffer->base_string.self[i++] = 0; } buffer->base_string.self[i++] = 0; environ[j] = 0; if (environp) *environp = environ; return buffer; } static cl_object make_external_process() { return _ecl_funcall1(@'ext::make-external-process'); } static cl_object external_process_pid(cl_object p) { return ecl_structure_ref(p, @'ext::external-process', 0); } static cl_object external_process_status(cl_object p) { return ecl_structure_ref(p, @'ext::external-process', 4); } static cl_object external_process_code(cl_object p) { return ecl_structure_ref(p, @'ext::external-process', 5); } static void set_external_process_pid(cl_object process, cl_object pid) { ecl_structure_set(process, @'ext::external-process', 0, pid); } static void set_external_process_streams(cl_object process, cl_object input, cl_object output, cl_object error) { ecl_structure_set(process, @'ext::external-process', 1, input); ecl_structure_set(process, @'ext::external-process', 2, output); ecl_structure_set(process, @'ext::external-process', 3, error); } static void update_process_status(cl_object process, cl_object status, cl_object code) { ecl_structure_set(process, @'ext::external-process', 0, ECL_NIL); ecl_structure_set(process, @'ext::external-process', 4, status); ecl_structure_set(process, @'ext::external-process', 5, code); } #if defined(SIGCHLD) && !defined(ECL_MS_WINDOWS_HOST) static void add_external_process(cl_env_ptr env, cl_object process) { cl_object l = ecl_list1(process); ecl_disable_interrupts_env(env); ECL_WITH_SPINLOCK_BEGIN(env, &cl_core.external_processes_lock); { ECL_RPLACD(l, cl_core.external_processes); cl_core.external_processes = l; } ECL_WITH_SPINLOCK_END; ecl_enable_interrupts_env(env); } static void remove_external_process(cl_env_ptr env, cl_object process) { ecl_disable_interrupts_env(env); ECL_WITH_SPINLOCK_BEGIN(env, &cl_core.external_processes_lock); { cl_core.external_processes = ecl_delete_eq(process, cl_core.external_processes); } ECL_WITH_SPINLOCK_END; ecl_enable_interrupts_env(env); } static cl_object find_external_process(cl_env_ptr env, cl_object pid) { cl_object output = ECL_NIL; ecl_disable_interrupts_env(env); ECL_WITH_SPINLOCK_BEGIN(env, &cl_core.external_processes_lock); { cl_object p; for (p = cl_core.external_processes; p != ECL_NIL; p = ECL_CONS_CDR(p)) { cl_object process = ECL_CONS_CAR(p); if (external_process_pid(process) == pid) { output = process; break; } } } ECL_WITH_SPINLOCK_END(&cl_core.external_processes_lock); ecl_enable_interrupts_env(env); return output; } #else #define add_external_process(env,p) #define remove_external_process(env,p) #endif static cl_object ecl_waitpid(cl_object pid, cl_object wait) { cl_object status, code; #if defined(NACL) FElibc_error("ecl_waitpid not implemented",1); @(return Cnil) #elif defined(ECL_MS_WINDOWS_HOST) cl_env_ptr the_env = ecl_process_env(); HANDLE *hProcess = ecl_foreign_data_pointer_safe(pid); DWORD exitcode; int ok; WaitForSingleObject(*hProcess, Null(wait)? 0 : INFINITE); ecl_disable_interrupts_env(the_env); ok = GetExitCodeProcess(*hProcess, &exitcode); if (!ok) { status = @':error'; code = ECL_NIL; } else if (exitcode == STILL_ACTIVE) { status = @':running'; code = ECL_NIL; } else { status = @':exited'; code = ecl_make_fixnum(exitcode); pid->foreign.data = NULL; CloseHandle(*hProcess); } ecl_enable_interrupts_env(the_env); #else int code_int, error; error = waitpid(ecl_to_fix(pid), &code_int, Null(wait)? WNOHANG : 0); if (error < 0) { if (errno == EINTR) { status = @':abort'; } else { status = @':error'; } code = ECL_NIL; pid = ECL_NIL; } else if (error == 0) { status = ECL_NIL; code = ECL_NIL; pid = ECL_NIL; } else { pid = ecl_make_fixnum(error); if (WIFEXITED(code_int)) { status = @':exited'; code = ecl_make_fixnum(WEXITSTATUS(code_int)); } else if (WIFSIGNALED(code_int)) { status = @':signaled'; code = ecl_make_fixnum(WTERMSIG(code_int)); } else if (WIFSTOPPED(code_int)) { status = @':stopped'; code = ecl_make_fixnum(WSTOPSIG(code_int)); } else { status = @':running'; code = ECL_NIL; } } #endif @(return status code pid) } @(defun si::wait-for-all-processes (&key (process ECL_NIL)) @ { const cl_env_ptr env = ecl_process_env(); #if defined(SIGCHLD) && !defined(ECL_WINDOWS_HOST) do { cl_object status = ecl_waitpid(ecl_make_fixnum(-1), ECL_NIL); cl_object code = env->values[1]; cl_object pid = env->values[2]; if (Null(pid)) { if (status != @':abort') break; } else { cl_object p = find_external_process(env, pid); if (!Null(p)) { set_external_process_pid(p, ECL_NIL); update_process_status(p, status, code); } if (status != @':running') { remove_external_process(env, p); ecl_delete_eq(p, cl_core.external_processes); } } } while (1); #endif ecl_return0(env); } @) #if defined(ECL_MS_WINDOWS_HOST) || defined(cygwin) cl_object si_close_windows_handle(cl_object h) { if (ecl_t_of(h) == t_foreign) { HANDLE *ph = (HANDLE*)h->foreign.data; if (ph) CloseHandle(*ph); } } static cl_object make_windows_handle(HANDLE h) { cl_object foreign = ecl_allocate_foreign_data(@':pointer-void', sizeof(HANDLE*)); HANDLE *ph = (HANDLE*)foreign->foreign.data; *ph = h; si_set_finalizer(foreign, @'si::close-windows-handle'); return foreign; } #endif @(defun ext::external-process-wait (process &optional (wait ECL_NIL)) @ { cl_object status, code, pid; AGAIN: pid = external_process_pid(process); if (Null(pid)) { /* If PID is NIL, it may be because the process failed, * or because it is being updated by a separate thread, * which is why we have to spin here. Note also the order * here: status is updated _after_ code, and hence we * check it _before_ code. */ do { ecl_musleep(0.0, 1); status = external_process_status(process); } while (status == @':running'); code = external_process_code(process); } else { status = ecl_waitpid(pid, wait); code = ecl_nth_value(the_env, 1); pid = ecl_nth_value(the_env, 2); /* A SIGCHLD interrupt may abort waitpid. If this * is the case, the signal handler may have consumed * the process status and we have to start over again */ if (Null(pid)) { if (!Null(wait)) goto AGAIN; status = external_process_status(process); code = external_process_code(process); } else { update_process_status(process, status, code); remove_external_process(the_env, process); } } @(return status code) } @) #if defined(ECL_MS_WINDOWS_HOST) HANDLE ecl_stream_to_HANDLE(cl_object s, bool output) { if (ecl_unlikely(!ECL_ANSI_STREAM_P(s))) return INVALID_HANDLE_VALUE; switch ((enum ecl_smmode)s->stream.mode) { #if defined(ECL_WSOCK) case ecl_smm_input_wsock: case ecl_smm_output_wsock: case ecl_smm_io_wsock: #endif #if defined(ECL_MS_WINDOWS_HOST) case ecl_smm_io_wcon: #endif return (HANDLE)IO_FILE_DESCRIPTOR(s); default: { int stream_descriptor = ecl_stream_to_handle(s, output); return (stream_descriptor < 0)? INVALID_HANDLE_VALUE: (HANDLE)_get_osfhandle(stream_descriptor); } } } #endif #if defined(ECL_MS_WINDOWS_HOST) static void create_descriptor(cl_object stream, cl_object direction, HANDLE *child, int *parent) { SECURITY_ATTRIBUTES attr; HANDLE current = GetCurrentProcess(); attr.nLength = sizeof(SECURITY_ATTRIBUTES); attr.lpSecurityDescriptor = NULL; attr.bInheritHandle = TRUE; if (stream == @':stream') { /* Creates a pipe that we can write to and the child reads from. We duplicate one extreme of the pipe so that the child does not inherit it. */ HANDLE tmp; if (CreatePipe(&tmp, child, &attr, 0) == 0) return; if (DuplicateHandle(current, tmp, current, &tmp, 0, FALSE, DUPLICATE_CLOSE_SOURCE | DUPLICATE_SAME_ACCESS) == 0) return; if (direction == @':input') { #ifdef cygwin *parent = cygwin_attach_handle_to_fd (0, -1, tmp, S_IRWXU, GENERIC_WRITE); #else *parent = _open_osfhandle ((intptr_t)tmp, _O_WRONLY); #endif } else { #ifdef cygwin *parent = cygwin_attach_handle_to_fd (0, -1, tmp, S_IRWXU, GENERIC_READ); #else *parent = _open_osfhandle ((intptr_t)tmp, _O_RDONLY); #endif } if (*parent < 0) printf("open_osfhandle failed\n"); } else if (Null(stream)) { *child = NULL; } else if (!Null(cl_streamp(stream))) { HANDLE stream_handle = ecl_stream_to_HANDLE (stream, direction != @':input'); if (stream_handle == INVALID_HANDLE_VALUE) { FEerror("~S argument to RUN-PROGRAM does not " "have a file handle:~%~S", 2, direction, stream); } DuplicateHandle(current, stream_handle, current, child, 0, TRUE, DUPLICATE_SAME_ACCESS); } else { FEerror("Invalid ~S argument to EXT:RUN-PROGRAM", 1, stream); } } #else static void create_descriptor(cl_object stream, cl_object direction, int *child, int *parent) { if (stream == @':stream') { int fd[2]; pipe(fd); if (direction == @':input') { *parent = fd[1]; *child = fd[0]; } else { *parent = fd[0]; *child = fd[1]; } } else if (Null(stream)) { if (direction == @':input') *child = open("/dev/null", O_RDONLY); else *child = open("/dev/null", O_WRONLY); } else if (!Null(cl_streamp(stream))) { *child = ecl_stream_to_handle (stream, direction != @':input'); if (*child >= 0) { *child = dup(*child); } else { FEerror("~S argument to RUN-PROGRAM does not " "have a file handle:~%~S", 2, direction, stream); } } else { FEerror("Invalid ~S argument to EXT:RUN-PROGRAM", 1, stream); } } #endif @(defun ext::run-program (command argv &key (input @':stream') (output @':stream') (error @':output') (wait @'t') (environ ECL_NIL) (if_input_does_not_exist ECL_NIL) (if_output_exists @':error') (if_error_exists @':error') (external_format @':default')) int parent_write = 0, parent_read = 0, parent_error = 0; int child_pid; cl_object pid, process; cl_object stream_write; cl_object stream_read; cl_object stream_error; cl_object exit_status = ECL_NIL; @ command = si_copy_to_simple_base_string(command); argv = cl_mapcar(2, @'si::copy-to-simple-base-string', argv); process = make_external_process(); { if (input == @'t') input = ecl_symbol_value(@'*standard-input*'); if (ECL_STRINGP(input) || ECL_PATHNAMEP(input)) input = cl_open(5, input, @':direction', @':input', @':if-does-not-exist', if_input_does_not_exist, @':external-format', external_format); if (output == @'t') output = ecl_symbol_value(@'*standard-output*'); if (ECL_STRINGP(output) || ECL_PATHNAMEP(output)) output = cl_open(7, output, @':direction', @':output', @':if-exists', if_output_exists, @':if-does-not-exist', @':create', @':external-format', external_format); if (error == @'t') error = ecl_symbol_value(@'*error-output*'); if (ECL_STRINGP(error) || ECL_PATHNAMEP(error)) error = cl_open(7, error, @':direction', @':output', @':if-exists', if_error_exists, @':if-does-not-exist', @':create', @':external-format', external_format); } #if defined(ECL_MS_WINDOWS_HOST) { BOOL ok; STARTUPINFO st_info; PROCESS_INFORMATION pr_info; HANDLE child_stdout, child_stdin, child_stderr; HANDLE current = GetCurrentProcess(); HANDLE saved_stdout, saved_stdin, saved_stderr; cl_object env_buffer; char *env = NULL; /* Enclose each argument, as well as the file name in double quotes, to avoid problems when these arguments or file names have spaces */ command = cl_format(4, ECL_NIL, ecl_make_simple_base_string("~S~{ ~S~}", -1), command, argv); command = si_copy_to_simple_base_string(command); command = ecl_null_terminated_base_string(command); if (!Null(environ)) { env_buffer = from_list_to_execve_argument(environ, NULL); env = env_buffer->base_string.self; } create_descriptor(input, @':input', &child_stdin, &parent_write); create_descriptor(output, @':output', &child_stdout, &parent_read); if (error == @':output') /* The child inherits a duplicate of its own output handle.*/ DuplicateHandle(current, child_stdout, current, &child_stderr, 0, TRUE, DUPLICATE_SAME_ACCESS); else create_descriptor(error, @':error', &child_stderr, &parent_error); add_external_process(the_env, process); #if 1 ZeroMemory(&st_info, sizeof(STARTUPINFO)); st_info.cb = sizeof(STARTUPINFO); st_info.lpTitle = NULL; /* No window title, just exec name */ st_info.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW; /* Specify std{in,out,err} */ st_info.wShowWindow = SW_HIDE; st_info.hStdInput = child_stdin; st_info.hStdOutput = child_stdout; st_info.hStdError = child_stderr; ZeroMemory(&pr_info, sizeof(PROCESS_INFORMATION)); ok = CreateProcess(NULL, command->base_string.self, NULL, NULL, /* lpProcess/ThreadAttributes */ TRUE, /* Inherit handles (for files) */ /*CREATE_NEW_CONSOLE |*/ 0 /*(input == ECL_T || output == ECL_T || error == ECL_T ? 0 : CREATE_NO_WINDOW)*/, env, /* Inherit environment */ NULL, /* Current directory */ &st_info, /* Startup info */ &pr_info); /* Process info */ #else /* 1 */ saved_stdin = GetStdHandle(STD_INPUT_HANDLE); saved_stdout = GetStdHandle(STD_OUTPUT_HANDLE); saved_stderr = GetStdHandle(STD_ERROR_HANDLE); SetStdHandle(STD_INPUT_HANDLE, child_stdin); SetStdHandle(STD_OUTPUT_HANDLE, child_stdout); SetStdHandle(STD_ERROR_HANDLE, child_stderr); ZeroMemory(&st_info, sizeof(STARTUPINFO)); st_info.cb = sizeof(STARTUPINFO); ZeroMemory(&pr_info, sizeof(PROCESS_INFORMATION)); ok = CreateProcess(NULL, command->base_string.self, NULL, NULL, /* lpProcess/ThreadAttributes */ TRUE, /* Inherit handles (for files) */ /*CREATE_NEW_CONSOLE |*/ 0, NULL, /* Inherit environment */ NULL, /* Current directory */ &st_info, /* Startup info */ &pr_info); /* Process info */ SetStdHandle(STD_INPUT_HANDLE, saved_stdin); SetStdHandle(STD_OUTPUT_HANDLE, saved_stdout); SetStdHandle(STD_ERROR_HANDLE, saved_stderr); #endif /* 1 */ /* Child handles must be closed in the parent process */ /* otherwise the created pipes are never closed */ if (ok) { CloseHandle(pr_info.hThread); pid = make_windows_handle(pr_info.hProcess); } else { char *message; FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ALLOCATE_BUFFER, 0, GetLastError(), 0, (void*)&message, 0, NULL); printf("%s\n", message); LocalFree(message); pid = ECL_NIL; } set_external_process_pid(process, pid); if (child_stdin) CloseHandle(child_stdin); if (child_stdout) CloseHandle(child_stdout); if (child_stderr) CloseHandle(child_stderr); } #elif !defined(NACL) /* mingw */ { int child_stdin, child_stdout, child_stderr; int pipe_fd[2]; argv = CONS(command, ecl_nconc(argv, ecl_list1(ECL_NIL))); argv = _ecl_funcall3(@'coerce', argv, @'vector'); create_descriptor(input, @':input', &child_stdin, &parent_write); create_descriptor(output, @':output', &child_stdout, &parent_read); if (error == @':output') child_stderr = child_stdout; else create_descriptor(error, @':error', &child_stderr, &parent_error); add_external_process(the_env, process); pipe(pipe_fd); child_pid = fork(); if (child_pid == 0) { /* Child */ int j; void **argv_ptr = (void **)argv->vector.self.t; { /* Wait for the parent to set up its process structure */ char sync[1]; close(pipe_fd[1]); while (read(pipe_fd[0], sync, 1) < 1) { printf("\nError reading child pipe %d", errno); fflush(stdout); } close(pipe_fd[0]); } dup2(child_stdin, STDIN_FILENO); if (parent_write) close(parent_write); dup2(child_stdout, STDOUT_FILENO); if (parent_read) close(parent_read); dup2(child_stderr, STDERR_FILENO); if (parent_error) close(parent_error); for (j = 0; j < argv->vector.fillp; j++) { cl_object arg = argv->vector.self.t[j]; if (arg == ECL_NIL) { argv_ptr[j] = NULL; } else { argv_ptr[j] = arg->base_string.self; } } if (!Null(environ)) { char **pstrings; cl_object buffer = from_list_to_execve_argument(environ, &pstrings); execve((char*)command->base_string.self, argv_ptr, pstrings); } else { execvp((char*)command->base_string.self, argv_ptr); } /* at this point exec has failed */ perror("exec"); abort(); } if (child_pid < 0) { pid = ECL_NIL; } else { pid = ecl_make_fixnum(child_pid); } set_external_process_pid(process, pid); { /* This guarantees that the child process does not exit * before we have created the process structure. If we do not * do this, the SIGPIPE signal may arrive before * set_external_process_pid() and our call to external-process-wait * down there may block indefinitely. */ char sync[1]; close(pipe_fd[0]); while (write(pipe_fd[1], sync, 1) < 1) { printf("\nError writing child pipe %d", errno); fflush(stdout); } close(pipe_fd[1]); } close(child_stdin); close(child_stdout); close(child_stderr); } #else { FElibc_error("ext::run-program not implemented",1); @(return Cnil) } #endif /* mingw */ if (Null(pid)) { if (parent_write) close(parent_write); if (parent_read) close(parent_read); if (parent_error) close(parent_error); parent_write = 0; parent_read = 0; parent_error = 0; remove_external_process(the_env, process); FEerror("Could not spawn subprocess to run ~S.", 1, command); } if (parent_write > 0) { stream_write = ecl_make_stream_from_fd(command, parent_write, ecl_smm_output, 8, external_format, ECL_T); } else { parent_write = 0; stream_write = cl_core.null_stream; } if (parent_read > 0) { stream_read = ecl_make_stream_from_fd(command, parent_read, ecl_smm_input, 8, external_format, ECL_T); } else { parent_read = 0; stream_read = cl_core.null_stream; } if (parent_error > 0) { stream_error = ecl_make_stream_from_fd(command, parent_error, ecl_smm_input, 8, external_format, ECL_T); } else { parent_error = 0; stream_error = cl_core.null_stream; } set_external_process_streams(process, stream_write, stream_read, stream_error); if (!Null(wait)) { exit_status = si_external_process_wait(2, process, ECL_T); exit_status = ecl_nth_value(the_env, 1); } @(return ((parent_read || parent_write)? cl_make_two_way_stream(stream_read, stream_write) : ECL_NIL) exit_status process) @) ecl-16.1.2/src/c/vector_push.d000066400000000000000000000057431266352375300161100ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* string.d -- String routines. */ /* Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. Copyright (c) 1990, Giuseppe Attardi. Copyright (c) 2001, Juan Jose Garcia Ripoll. ECL is free software; you can redistribute it and/or modify it under thep terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See file '../Copyright' for full details. */ #include #include static cl_object extend_vector(cl_object v, cl_index amount) { cl_object other; cl_index new_length; unlikely_if (!ECL_VECTORP(v)) { FEwrong_type_nth_arg(@[vector-push-extend],1,v,@[vector]); } if (!ECL_ADJUSTABLE_ARRAY_P(v)) FEerror("vector-push-extend: the array ~S is not adjustable.", 1, v); if (v->vector.dim >= ECL_ARRAY_DIMENSION_LIMIT) FEerror("Can't extend the array.", 0); if (amount == 0) amount = v->vector.dim / 2 + 1; new_length = v->vector.dim + amount; if (new_length > ECL_ARRAY_DIMENSION_LIMIT) new_length = ECL_ARRAY_DIMENSION_LIMIT; other = si_make_vector(cl_array_element_type(v), ecl_make_fixnum(new_length), ECL_T, ecl_make_fixnum(v->vector.fillp), ECL_NIL, ecl_make_fixnum(0)); ecl_copy_subarray(other, 0, v, 0, v->vector.fillp); return si_replace_array(v, other); } ecl_character ecl_string_push_extend(cl_object s, ecl_character c) { switch(ecl_t_of(s)) { #ifdef ECL_UNICODE case t_string: #endif case t_base_string: /* We use the fact that both string types are byte-compatible except for the data. */ if (s->base_string.fillp >= s->base_string.dim) { s = extend_vector(s, 0); } ecl_char_set(s, s->base_string.fillp++, c); return c; default: FEwrong_type_nth_arg(@[vector-push-extend],1,s,@[string]); } } cl_object cl_vector_push(cl_object value, cl_object v) { cl_index f = ecl_fixnum(cl_fill_pointer(v)); if (f >= v->vector.dim) { @(return ECL_NIL); } else { ecl_aset1(v, v->vector.fillp, value); @(return ecl_make_fixnum(v->vector.fillp++)); } } @(defun vector-push-extend (value v &optional (extent ecl_make_fixnum(0))) @ { cl_index f = ecl_fixnum(cl_fill_pointer(v)); if (f >= v->vector.dim) { v = extend_vector(v, ecl_to_size(extent)); } ecl_aset1(v, v->vector.fillp, value); @(return ecl_make_fixnum(v->vector.fillp++)); } @) ecl-16.1.2/src/clos/000077500000000000000000000000001266352375300141075ustar00rootroot00000000000000ecl-16.1.2/src/clos/boot.lsp000066400000000000000000000136461266352375300156040ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: CLOS -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; Copyright (c) 1992, Giuseppe Attardi.o ;;;; Copyright (c) 2001, Juan Jose Garcia Ripoll. ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. (in-package "CLOS") (defconstant +builtin-classes-pre-array+ (make-array (1+ #.(length +builtin-classes-list+)))) ;;; ---------------------------------------------------------------------- ;;; Building the classes T, CLASS, STANDARD-OBJECT and STANDARD-CLASS. ;;; ;;; We cannot use the functions CREATE-STANDARD-CLASS and others because SLOTS, ;;; DIRECT-SLOTS, etc are empty and therefore SLOT-VALUE does not work. (defun make-empty-standard-class (name &key (metaclass 'standard-class) direct-superclasses direct-slots index) (declare (optimize speed (safety 0))) (let* ((the-metaclass (and metaclass (gethash metaclass si::*class-name-hash-table*))) (class (or (gethash name si::*class-name-hash-table*) (si:allocate-raw-instance nil the-metaclass #.(length +standard-class-slots+))))) (with-early-accessors (+standard-class-slots+) (when (eq name 'standard-class) (defconstant +the-standard-class+ class) (si:instance-class-set class class)) (setf (class-id class) name (class-direct-subclasses class) nil (class-direct-default-initargs class) nil (class-default-initargs class) nil (class-finalized-p class) t (eql-specializer-flag class) nil (specializer-direct-methods class) nil (specializer-direct-generic-functions class) nil (gethash name si::*class-name-hash-table*) class (class-sealedp class) nil (class-dependents class) nil (class-valid-initargs class) nil ) (add-slots class direct-slots) (let ((superclasses (loop for name in direct-superclasses for parent = (find-class name) do (push class (class-direct-subclasses parent)) collect parent))) (setf (class-direct-superclasses class) superclasses (class-precedence-list class) (compute-clos-class-precedence-list class superclasses))) (when index (setf (aref +builtin-classes-pre-array+ index) class)) class))) (defun remove-accessors (slotds) (declare (optimize speed (safety 0))) (loop for i in slotds for j = (copy-list i) do (remf (cdr j) :accessor) collect j)) (defun add-slots (class slots) (declare (si::c-local) (optimize speed (safety 0))) ;; It does not matter that we pass NIL instead of a class object, ;; because CANONICAL-SLOT-TO-DIRECT-SLOT will make simple slots. (with-early-accessors (+standard-class-slots+ +slot-definition-slots+) (let* ((table (make-hash-table :size (if slots 24 0))) (location-table (make-hash-table :size (if slots 24 0))) (slots (parse-slots slots)) (direct-slots (loop for slotd in slots collect (apply #'make-simple-slotd (find-class 'standard-direct-slot-definition) slotd))) (effective-slots (loop for i from 0 for slotd in slots for name = (getf slotd :name) for s = (apply #'make-simple-slotd (find-class 'standard-effective-slot-definition) slotd) do (setf (slot-definition-location s) i (gethash name location-table) i (gethash name table) s) collect s))) (setf (class-slots class) effective-slots (class-direct-slots class) direct-slots (class-size class) (length slots) (slot-table class) table (class-location-table class) location-table)))) ;; 1) Create the classes ;; ;; Notice that, due to circularity in the definition, STANDARD-CLASS has ;; itself as metaclass. MAKE-EMPTY-STANDARD-CLASS takes care of that. ;; (let* ((class-hierarchy '#.+class-hierarchy+)) (let ((all-classes (loop for c in class-hierarchy for class = (apply #'make-empty-standard-class c) collect class))) (defconstant +the-t-class+ (find-class 't nil)) (defconstant +the-class+ (find-class 'class nil)) (defconstant +the-std-class+ (find-class 'std-class nil)) (defconstant +the-funcallable-standard-class+ (find-class 'funcallable-standard-class nil)) ;; ;; 2) Class T had its metaclass wrong. Fix it. ;; (si:instance-class-set (find-class 't) (find-class 'built-in-class)) ;; ;; 3) Finalize ;; (mapc #'si::instance-sig-set all-classes) ;; ;; 4) This is needed for further optimization ;; (setf (slot-value (find-class 'method-combination) 'sealedp) t) ;; ;; 5) This is needed so that slot-definition objects are not marked ;; obsolete and need to be updated ;; (with-early-accessors (+standard-class-slots+) (loop for c in all-classes do (loop for s in (class-direct-slots c) do (si::instance-sig-set s)) do (loop for s in (class-slots c) do (si::instance-sig-set s)))) )) ecl-16.1.2/src/clos/builtin.lsp000066400000000000000000000107051266352375300163000ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: CLOS -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; Copyright (c) 1992, Giuseppe Attardi. ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. (in-package "CLOS") ;;; ---------------------------------------------------------------------- ;;; Methods ;;; ====================================================================== ;;; Built-in classes ;;; ---------------------------------------------------------------------- (defmethod make-instance ((class built-in-class) &rest initargs) (declare (ignore initargs)) (error "The built-in class (~A) cannot be instantiated" class)) ;;; ;;; At this point we can activate the vector of builtin classes, which ;;; is used by class-of and other functions. ;;; (si::*make-constant '+builtin-classes+ +builtin-classes-pre-array+) (defmethod ensure-class-using-class ((class null) name &rest rest) (declare (ignore class)) (multiple-value-bind (metaclass direct-superclasses options) (apply #'help-ensure-class rest) (declare (ignore direct-superclasses)) (setf class (apply #'make-instance metaclass :name name options)) (when name (si:create-type-name name) (setf (find-class name) class)))) (defmethod change-class ((instance t) (new-class symbol) &rest initargs) (apply #'change-class instance (find-class new-class) initargs)) (defmethod make-instances-obsolete ((class symbol)) (make-instances-obsolete (find-class class)) class) (defmethod make-instance ((class-name symbol) &rest initargs) (apply #'make-instance (find-class class-name) initargs)) (defmethod slot-makunbound-using-class ((class built-in-class) self slotd) (declare (ignore class self slotd)) (error "SLOT-MAKUNBOUND-USING-CLASS cannot be applied on built-in objects")) (defmethod slot-boundp-using-class ((class built-in-class) self slotd) (declare (ignore class self slotd)) (error "SLOT-BOUNDP-USING-CLASS cannot be applied on built-in objects")) (defmethod slot-value-using-class ((class built-in-class) self slotd) (declare (ignore class self slotd)) (error "SLOT-VALUE-USING-CLASS cannot be applied on built-in objects")) (defmethod (setf slot-value-using-class) (val (class built-in-class) self slotd) (declare (ignore class self slotd val)) (error "SLOT-VALUE-USING-CLASS cannot be applied on built-in objects")) (defmethod slot-exists-p-using-class ((class built-in-class) self slotd) (declare (ignore class self slotd)) nil) ;;; ====================================================================== ;;; STRUCTURES ;;; ;;; structure-classes cannot be instantiated (defmethod allocate-instance ((class structure-class) &rest initargs) (declare (ignore initargs)) (apply #'si::make-structure class (make-list (class-size class) :initial-element (si::unbound)))) (defmethod finalize-inheritance ((class structure-class)) (call-next-method) (dolist (slot (class-slots class)) (unless (eq :INSTANCE (slot-definition-allocation slot)) (error "The structure class ~S can't have shared slots" (class-name class))))) (defmethod make-load-form ((object structure-object) &optional environment) (make-load-form-saving-slots object :key environment)) (defmethod print-object ((obj structure-object) stream) (let* ((class (si:instance-class obj)) (slotds (class-slots class))) (declare (:read-only class)) (when (and slotds ;; *p-readably* effectively disables *p-level* (not *print-readably*) *print-level* (zerop *print-level*)) (write-string "#" stream) (return-from print-object obj)) (write-string "#S(" stream) (prin1 (class-name class) stream) (do ((scan slotds (cdr scan)) (i 0 (1+ i)) (limit (or *print-length* most-positive-fixnum)) (sv)) ((null scan)) (declare (fixnum i)) (when (>= i limit) (write-string " ..." stream) (return)) (setq sv (si:instance-ref obj i)) (write-string " :" stream) (prin1 (slot-definition-name (car scan)) stream) (write-string " " stream) (prin1 sv stream)) (write-string ")" stream) obj)) ecl-16.1.2/src/clos/change.lsp000066400000000000000000000270001266352375300160530ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: CLOS -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; Copyright (c) 1992, Giuseppe Attardi. ;;;; Copyright (c) 2001, Juan Jose Garcia Ripoll. ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. (in-package "CLOS") ;;; ---------------------------------------------------------------------- ;;; INSTANCE UPDATE PROTOCOL ;;; ;;; ;;; PART 1: CHANGING THE CLASS OF AN INSTANCE ;;; ;;; The method CHANGE-CLASS performs most of the work. ;;; ;;; a) The structure of the instance is changed to match the new ;;; number of local slots. ;;; b) The new local slots are filled with the value of the old ;;; slots. Only the name is used, so that a new local slot may ;;; get the value of old slots that were eithe local or shared. ;;; c) Finally, UPDATE-INSTANCE-FOR-DIFFERENT-CLASS is invoked ;;; with a copy of the instance as it looked before the change, ;;; the changed instance and enough information to perform any ;;; extra processing. ;;; (defmethod update-instance-for-different-class ((old-data standard-object) (new-data standard-object) &rest initargs) (let ((old-local-slotds (si::instance-sig old-data)) (new-local-slotds (remove :instance (si::instance-sig new-data) :test-not #'eq :key #'slot-definition-allocation)) added-slots) (setf added-slots (set-difference (mapcar #'slot-definition-name new-local-slotds) (mapcar #'slot-definition-name old-local-slotds))) (check-initargs (class-of new-data) initargs (valid-keywords-from-methods (compute-applicable-methods #'update-instance-for-different-class (list old-data new-data)) (compute-applicable-methods #'shared-initialize (list new-data added-slots)))) (apply #'shared-initialize new-data added-slots initargs))) (defmethod change-class ((instance standard-object) (new-class std-class) &rest initargs) (let* ((old-instance (si::copy-instance instance)) (new-size (class-size new-class)) (instance (si::allocate-raw-instance instance new-class new-size))) (si::instance-sig-set instance) ;; "The values of local slots specified by both the class Cto and ;; Cfrom are retained. If such a local slot was unbound, it remains ;; unbound." ;; "The values of slots specified as shared in the class Cfrom and ;; as local in the class Cto are retained." (let* ((new-local-slotds (class-slots (class-of instance)))) (dolist (new-slot new-local-slotds) ;; CHANGE-CLASS can only operate on the value of local slots. (when (eq (slot-definition-allocation new-slot) :INSTANCE) (let ((name (slot-definition-name new-slot))) (if (and (slot-exists-p old-instance name) (slot-boundp old-instance name)) (setf (slot-value instance name) (slot-value old-instance name)) (slot-makunbound instance name)))))) (apply #'update-instance-for-different-class old-instance instance initargs) instance)) (defmethod change-class ((instance class) new-class &rest initargs) (declare (ignore new-class initargs)) (if (forward-referenced-class-p instance) (call-next-method) (error "The metaclass of a class metaobject cannot be changed."))) ;;; ;;; PART 2: UPDATING AN INSTANCE THAT BECAME OBSOLETE ;;; ;;; Each instance has a hidden field (readable with SI::INSTANCE-SIG), which ;;; contains the list of slots of its class. This field is updated every time ;;; the class is initialized or reinitialized. Generally ;;; (EQ (SI::INSTANCE-SIG x) (CLASS-SLOTS (CLASS-OF x))) ;;; returns NIL whenever the class became obsolete. ;;; ;;; There are two circumstances under which a instance may become obsolete: ;;; either the class has been modified using REDEFINE-INSTANCE (and thus the ;;; list of slots changed), or MAKE-INSTANCES-OBSOLETE has been used. ;;; ;;; The function UPDATE-INSTANCE (hidden to the user) does the job of ;;; updating an instance that has become obsolete. ;;; ;;; a) A copy of the instance is saved to check the old values. ;;; b) The structure of the instance is changed to match the new ;;; number of local slots. ;;; c) The new local slots are filled with the value of the old ;;; local slots. ;;; d) Finally, UPDATE-INSTANCE-FOR-REDEFINED-CLASS is invoked ;;; with enough information to perform any extra initialization, ;;; for instance of new slots. ;;; ;;; It is not clear when the function UPDATE-INSTANCE is invoked. At least ;;; this will happen whenever the functions SLOT-VALUE, (SETF SLOT-VALUE), ;;; SLOT-BOUNDP or SLOT-EXISTS-P are used. ;;; (defmethod update-instance-for-redefined-class ((instance standard-object) added-slots discarded-slots property-list &rest initargs) (check-initargs (class-of instance) initargs (valid-keywords-from-methods (compute-applicable-methods #'update-instance-for-redefined-class (list instance added-slots discarded-slots property-list)) (compute-applicable-methods #'shared-initialize (list instance added-slots)))) (apply #'shared-initialize instance added-slots initargs)) (defmethod update-instance-for-redefined-class ((instance std-class) added-slots discarded-slots property-list &rest initargs) ;; If the metaclass of this class changed, so did probably that of its ;; subclasses. We need those subclasses to be up-to-date. This prevents ;; errors when loading twice the following ;; (defclass metaclas ...) ;; (defclass x () ... (:metaclas metaclas)) ;; (defclass y (y) ...) ;; because X might be redefined with Y not being up-to-date on the second ;; pass. (prog1 (call-next-method) (dolist (class (class-direct-subclasses instance)) (ensure-up-to-date-instance class)))) (defun update-instance (instance) (let* ((class (class-of instance)) (old-slotds (si::instance-sig instance)) (new-slotds (class-slots class)) (old-instance (si::copy-instance instance)) (discarded-slots '()) (added-slots '()) (property-list '())) (setf instance (si::allocate-raw-instance instance class (class-size class))) (si::instance-sig-set instance) (let* ((new-i 0) (old-local-slotds (remove :instance old-slotds :test-not #'eq :key #'slot-definition-allocation)) (new-local-slotds (remove :instance new-slotds :test-not #'eq :key #'slot-definition-allocation))) (declare (fixnum new-i)) (setq discarded-slots (set-difference (mapcar #'slot-definition-name old-local-slotds) (mapcar #'slot-definition-name new-local-slotds))) (dolist (slot-name discarded-slots) (let* ((ndx (position slot-name old-local-slotds :key #'slot-definition-name))) (setf property-list (list* slot-name (si::instance-ref old-instance ndx) property-list)))) (dolist (new-slot new-local-slotds) (let* ((name (slot-definition-name new-slot)) (old-i (position name old-local-slotds :key #'slot-definition-name))) (if old-i (si::instance-set instance new-i (si::instance-ref old-instance old-i)) (push name added-slots)) (incf new-i)))) (update-instance-for-redefined-class instance added-slots discarded-slots property-list))) ;;; ---------------------------------------------------------------------- ;;; CLASS REDEFINITION PROTOCOL (ensure-generic-function 'reinitialize-instance :lambda-list '(class &rest initargs)) (defmethod reinitialize-instance ((class class) &rest initargs &key (direct-superclasses () direct-superclasses-p) (direct-slots nil direct-slots-p)) (let ((name (class-name class))) (when (member name '(CLASS BUILT-IN-CLASS) :test #'eq) (error "The kernel CLOS class ~S cannot be changed." name))) ;; remove previous defined accessor methods (when (class-finalized-p class) (remove-optional-slot-accessors class)) (call-next-method) ;; the list of direct slots is converted to direct-slot-definitions (when direct-slots-p (setf (class-direct-slots class) (loop for s in direct-slots collect (canonical-slot-to-direct-slot class s)))) ;; set up inheritance checking that it makes sense (when direct-superclasses-p (setf direct-superclasses (check-direct-superclasses class direct-superclasses)) (dolist (l (class-direct-superclasses class)) (unless (member l direct-superclasses) (remove-direct-subclass l class))) (dolist (l (setf (class-direct-superclasses class) direct-superclasses)) (add-direct-subclass l class))) ;; if there are no forward references, we can just finalize the class here (setf (class-finalized-p class) nil) (finalize-unless-forward class) class) (defmethod make-instances-obsolete ((class class)) (setf (class-slots class) (copy-list (class-slots class))) class) (defun remove-optional-slot-accessors (class) (declare (class class) (optimize (safety 0)) (si::c-local)) (let ((class-name (class-name class))) (dolist (slotd (class-slots class)) ;; remove previous defined reader methods (dolist (reader (slot-definition-readers slotd)) (let* ((gf-object (fdefinition reader)) found) ;; primary method (when (setq found (find-method gf-object nil (list class-name) nil)) (remove-method gf-object found)) ;; before method (when (setq found (find-method gf-object ':before (list class-name) nil)) (remove-method gf-object found)) ;; after method (when (setq found (find-method gf-object ':after (list class-name) nil)) (remove-method gf-object found)) (when (null (generic-function-methods gf-object)) (fmakunbound reader)))) ;; remove previous defined writer methods (dolist (writer (slot-definition-writers slotd)) (let* ((gf-object (fdefinition writer)) found) ;; primary method (when (setq found (find-method gf-object nil (list 'T class-name) nil)) (remove-method gf-object found)) ;; before method (when (setq found (find-method gf-object ':before (list 'T class-name) nil)) (remove-method gf-object found)) ;; after method (when (setq found (find-method gf-object ':after (list 'T class-name) nil)) (remove-method gf-object found)) (when (null (generic-function-methods gf-object)) (fmakunbound writer))))))) ecl-16.1.2/src/clos/cmpinit.lsp000066400000000000000000000007451266352375300163000ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: CLOS -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; (defvar std-compile (symbol-function 'compile-file)) (defun compile-file (file &key (output-file (make-pathname :type "o" :defaults file))) (funcall std-compile file :c-file t :h-file t :data-file t :system-p t :output-file nil)) ;(setq compiler:*cc* (concatenate 'STRING compiler:*cc* " -I../h")) ecl-16.1.2/src/clos/combin.lsp000066400000000000000000000411241266352375300161000ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: CLOS -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; Copyright (c) 1992, Giuseppe Attardi. ;;;; Copyright (c) 2001, Juan Jose Garcia Ripoll. ;;;; ;;;; ECoLisp is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. (in-package "CLOS") ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; COMPILING EFFECTIVE METHODS ;;; ;;; The following functions take care of transforming the forms ;;; produced by the method combinations into effective methods. In ECL ;;; effective methods are nothing but directly callable functions. ;;; Ideally, this compilation should just produce new compiled ;;; functions. However, we do not want to cons a lot of functions, and ;;; therefore we use closures. ;;; ;;; Formerly we used to keep a list of precompiled effective methods ;;; and made a structural comparison between the current method and ;;; the precompiled ones, so as to save memory. This only causes ;;; improvements in declarative combinations. For standard combinations ;;; it should be enough with a couple of different closures and hence ;;; the structural comparison is a loss of time. ;;; ;;; This is the core routine. It produces effective methods (i.e. ;;; functions) out of the forms generated by the method combinators. ;;; We consider the following cases: ;;; 1) Ordinary methods. The function of the method is extracted. ;;; 2) Functions. They map to themselves. This only happens ;;; when these functions have been generated by previous calls ;;; to EFFECTIVE-METHOD-FUNCTION. ;;; 3) (CALL-METHOD method rest-methods) A closure is ;;; generated that invokes the current method while informing ;;; it about the remaining methods. ;;; 4) (MAKE-METHOD form) A function is created that takes the ;;; list of arguments of the generic function and evaluates ;;; the forms in a null environment. This is the only form ;;; that may lead to consing of new bytecodes objects. Nested ;;; CALL-METHOD are handled via the global macro CALL-METHOD. ;;; 5) Ordinary forms are turned into lambda forms, much like ;;; what happens with the content of MAKE-METHOD. ;;; (defun effective-method-function (form &optional top-level &aux first) (cond ((functionp form) form) ((method-p form) (method-function form)) ((atom form) (error "Malformed effective method form:~%~A" form)) ((eq (setf first (first form)) 'MAKE-METHOD) (coerce `(lambda (.combined-method-args. *next-methods*) (declare (special .combined-method-args. *next-methods*)) ,(second form)) 'function)) ((eq first 'CALL-METHOD) (combine-method-functions (effective-method-function (second form)) (mapcar #'effective-method-function (third form)))) (top-level (coerce `(lambda (.combined-method-args. no-next-methods) (declare (ignorable no-next-methods)) ,form) 'function)) (t (error "Malformed effective method form:~%~A" form)))) ;;; ;;; This function is a combinator of effective methods. It creates a ;;; closure that invokes the first method while passing the information ;;; of the remaining methods. The resulting closure (or effective method) ;;; is the equivalent of (CALL-METHOD method rest-methods) ;;; (defun combine-method-functions (method rest-methods) (declare (si::c-local)) #'(lambda (.combined-method-args. no-next-methods) (declare (ignorable no-next-methods)) (funcall method .combined-method-args. rest-methods))) (defmacro call-method (method &optional rest-methods) `(funcall ,(effective-method-function method) .combined-method-args. ',(and rest-methods (mapcar #'effective-method-function rest-methods)))) (defun call-next-method (&rest args) (declare (special .combined-method-args. *next-methods*)) (unless *next-methods* (error "No next method.")) (funcall (car *next-methods*) (or args .combined-method-args.) (rest *next-methods*))) (defun next-method-p () (declare (special *next-methods*)) *next-methods*) (define-compiler-macro call-next-method (&rest args) `(if *next-methods* (funcall (car *next-methods*) ,(if args `(list ,@args) '.combined-method-args.) (rest *next-methods*)) (error "No next method."))) (define-compiler-macro next-method-p () 'clos::*next-methods*) (defun error-qualifier (m qualifier) (declare (si::c-local)) (error "Standard method combination allows only one qualifier ~ per method, either :BEFORE, :AFTER, or :AROUND; while ~ a method with ~S was found." m qualifier)) (defun standard-main-effective-method (before primary after) (declare (si::c-local)) #'(lambda (.combined-method-args. no-next-method) (declare (ignorable no-next-method)) (dolist (i before) (funcall i .combined-method-args. nil)) (if after (multiple-value-prog1 (funcall (first primary) .combined-method-args. (rest primary)) (dolist (i after) (funcall i .combined-method-args. nil))) (funcall (first primary) .combined-method-args. (rest primary))))) (defun standard-compute-effective-method (gf methods) (with-early-accessors (+standard-method-slots+) (let* ((before ()) (primary ()) (after ()) (around ())) (dolist (m methods) (let* ((qualifiers (method-qualifiers m)) (f (method-function m))) (cond ((null qualifiers) (push f primary)) ((rest qualifiers) (error-qualifier m qualifiers)) ((eq (setq qualifiers (first qualifiers)) :BEFORE) (push f before)) ((eq qualifiers :AFTER) (push f after)) ((eq qualifiers :AROUND) (push f around)) (t (error-qualifier m qualifiers))))) ;; When there are no primary methods, an error is to be signaled, ;; and we need not care about :AROUND, :AFTER or :BEFORE methods. (when (null primary) (return-from standard-compute-effective-method #'(lambda (&rest args) (apply 'no-primary-method gf args)))) ;; PRIMARY, BEFORE and AROUND are reversed because they have to ;; be on most-specific-first order (ANSI 7.6.6.2), while AFTER ;; may remain as it is because it is least-specific-order. (setf primary (nreverse primary) before (nreverse before)) (if around (let ((main (if (or before after) (list (standard-main-effective-method before primary after)) primary))) (setf around (nreverse around)) (combine-method-functions (first around) (nconc (rest around) main))) (if (or before after) (standard-main-effective-method before primary after) (combine-method-functions (first primary) (rest primary)))) ))) ;; ---------------------------------------------------------------------- ;; DEFINE-METHOD-COMBINATION ;; ;; METHOD-COMBINATION objects are just a list ;; (name arg*) ;; where NAME is the name of the method combination type defined with ;; DEFINE-METHOD-COMBINATION, and ARG* is zero or more arguments. ;; ;; For each method combination type there is an associated function, ;; and the list of all known method combination types is kept in ;; *METHOD-COMBINATIONS* in the form of property list: ;; (mc-type-name1 function1 mc-type-name2 function2 ....) ;; ;; FUNCTIONn is the function associated to a method combination. It ;; is of type (FUNCTION (generic-function method-list) FUNCTION), ;; and it outputs an anonymous function which is the effective method. ;; #+threads (defparameter *method-combinations-lock* (mp:make-lock :name 'find-method-combination)) (defparameter *method-combinations* (make-hash-table :size 32 :test 'eq)) (defun search-method-combination (name) (mp:with-lock (*method-combinations-lock*) (or (gethash name *method-combinations*) (error "~A does not name a method combination" name)))) (defun install-method-combination (name function) (mp:with-lock (*method-combinations-lock*) (setf (gethash name *method-combinations*) function)) name) (defun make-method-combination (name compiler options) (with-early-make-instance +method-combination-slots+ (o (find-class 'method-combination) :name name :compiler compiler :options options) o)) (defun find-method-combination (gf method-combination-type-name method-combination-options) (make-method-combination method-combination-type-name (search-method-combination method-combination-type-name) method-combination-options )) (defun define-simple-method-combination (name &key documentation identity-with-one-argument (operator name)) `(define-method-combination ,name (&optional (order :MOST-SPECIFIC-FIRST)) ((around (:AROUND)) (principal (,name) :REQUIRED t)) ,documentation (let ((main-effective-method `(,',operator ,@(mapcar #'(lambda (x) `(CALL-METHOD ,x NIL)) (if (eql order :MOST-SPECIFIC-LAST) (reverse principal) principal))))) (cond (around `(call-method ,(first around) (,@(rest around) (make-method ,main-effective-method)))) (,(if identity-with-one-argument '(rest principal) t) main-effective-method) (t (second main-effective-method)))))) (defun define-complex-method-combination (form) (declare (si::c-local)) (flet ((syntax-error () (error "~S is not a valid DEFINE-METHOD-COMBINATION form" form))) (destructuring-bind (name lambda-list method-groups &rest body &aux (group-names '()) (group-checks '()) (group-after '()) (generic-function '.generic-function.) (method-arguments '())) form (unless (symbolp name) (syntax-error)) (let ((x (first body))) (when (and (consp x) (eql (first x) :ARGUMENTS)) (error "Option :ARGUMENTS is not supported in DEFINE-METHOD-COMBINATION."))) (let ((x (first body))) (when (and (consp x) (eql (first x) :GENERIC-FUNCTION)) (setf body (rest body)) (unless (symbolp (setf generic-function (second x))) (syntax-error)))) (dolist (group method-groups) (destructuring-bind (group-name predicate &key description (order :most-specific-first) (required nil)) group (if (symbolp group-name) (push group-name group-names) (syntax-error)) (let ((condition (cond ((eql predicate '*) 'T) ((and predicate (symbolp predicate)) `(,predicate .METHOD-QUALIFIERS.)) ((and (listp predicate) (let* ((q (last predicate 0)) (p (copy-list (butlast predicate 0)))) (when (every #'symbolp p) (if (eql q '*) `(every #'equal ',p .METHOD-QUALIFIERS.) `(equal ',p .METHOD-QUALIFIERS.)))))) (t (syntax-error))))) (push `(,condition (push .METHOD. ,group-name)) group-checks)) (when required (push `(unless ,group-name (error "Method combination: ~S. No methods ~ in required group ~S." ,name ,group-name)) group-after)) (case order (:most-specific-first (push `(setf ,group-name (nreverse ,group-name)) group-after)) (:most-specific-last) (otherwise (let ((order-var (gensym))) (setf group-names (append group-names (list (list order-var order))) group-after (list* `(when (eq ,order-var :most-specific-first) (setf ,group-name (nreverse ,group-name))) group-after))))))) `(install-method-combination ',name (ext::lambda-block ,name (,generic-function .methods-list. ,@lambda-list) (let (,@group-names) (dolist (.method. .methods-list.) (let ((.method-qualifiers. (method-qualifiers .method.))) (cond ,@(nreverse group-checks) (t (invalid-method-error .method. "Method qualifiers ~S are not allowed in the method~ combination ~S." .method-qualifiers. ,name))))) ,@group-after (effective-method-function (progn ,@body) t)))) ))) (defmacro define-method-combination (name &body body) (if (and body (listp (first body))) (define-complex-method-combination (list* name body)) (apply #'define-simple-method-combination name body))) (defun method-combination-error (format-control &rest args) ;; FIXME! We should emit a more detailed error! (error "Method-combination error:~%~S" (apply #'format nil format-control args))) (defun invalid-method-error (method format-control &rest args) (error "Invalid method error for ~A~%~S" method (apply #'format nil format-control args))) ;;; ---------------------------------------------------------------------- ;;; COMPUTE-EFFECTIVE-METHOD ;;; (eval-when (compile) (let* ((class (find-class 'method-combination))) (define-compiler-macro method-combination-compiler (o) `(si::instance-ref ,o ,(slot-definition-location (gethash 'compiler (slot-table class))))) (define-compiler-macro method-combination-options (o) `(si::instance-ref ,o ,(slot-definition-location (gethash 'options (slot-table class))))))) (defun std-compute-effective-method (gf method-combination applicable-methods) (declare (type method-combination method-combination) (type generic-function gf) (optimize speed (safety 0))) (with-early-accessors (+method-combination-slots+) (let* ((compiler (method-combination-compiler method-combination)) (options (method-combination-options method-combination))) (if options (apply compiler gf applicable-methods options) (funcall compiler gf applicable-methods))))) (defun compute-effective-method-function (gf method-combination applicable-methods) ;; Cannot be inlined because it will be a method (declare (notinline compute-effective-method)) (let ((form (compute-effective-method gf method-combination applicable-methods))) (let ((aux form) f) (if (and (listp aux) (eq (pop aux) 'funcall) (functionp (setf f (pop aux))) (eq (pop aux) '.combined-method-args.) (eq (pop aux) '*next-methods*)) f (effective-method-function form t))))) (defun compute-effective-method (gf method-combination applicable-methods) `(funcall ,(std-compute-effective-method gf method-combination applicable-methods) .combined-method-args. *next-methods*)) ;; ;; These method combinations are bytecompiled, for simplicity. ;; (install-method-combination 'standard 'standard-compute-effective-method) (eval '(progn (define-method-combination progn :identity-with-one-argument t) (define-method-combination and :identity-with-one-argument t) (define-method-combination max :identity-with-one-argument t) (define-method-combination + :identity-with-one-argument t) (define-method-combination nconc :identity-with-one-argument t) (define-method-combination append :identity-with-one-argument nil) (define-method-combination list :identity-with-one-argument nil) (define-method-combination min :identity-with-one-argument t) (define-method-combination or :identity-with-one-argument t))) ecl-16.1.2/src/clos/conditions.lsp000066400000000000000000001025121266352375300170010ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: CLOS -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; Copyright (c) 2001, Juan Jose Garcia-Ripoll ;;;; Copyright (c) 1992, Giuseppe Attardi. ;;;; Copyright (c) 2001, Juan Jose Garcia Ripoll. ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. ;;; ;;; conditions.lsp ;;; ;;; Originally written by Kent M. Pitman of Symbolics, Inc. and ;;; distributed without any copyright. ;;; This is Version 18. ;;; ;;; KMP's disclaimer: ;;; ;;; This is a sample implementation. It is not in any way intended as the ;;; definition of any aspect of the condition system. It is simply an existence ;;; proof that the condition system can be implemented. ;;; (in-package "SYSTEM") ;;; ---------------------------------------------------------------------- ;;; Unique Ids (defmacro unique-id (obj) "Generates a unique integer ID for its argument." `(sys:pointer ,obj)) ;;; Restarts (defparameter *restart-clusters* ()) (defparameter *condition-restarts* ()) ;;; do we need copy-list if *restart-clusters* has only one element? Beppe (defun compute-restarts (&optional condition) (let* ((assoc-restart ()) (other ()) (output ())) (when condition (dolist (i *condition-restarts*) (if (eq (first i) condition) (setq assoc-restart (append (rest i) assoc-restart)) (setq other (append (rest i) other))))) (dolist (restart-cluster *restart-clusters*) (dolist (restart restart-cluster) (when (and (or (not condition) (member restart assoc-restart) (not (member restart other))) (funcall (restart-test-function restart) condition)) (push restart output)))) (nreverse output))) (defun restart-print (restart stream depth) (declare (ignore depth)) (if *print-escape* (format stream "#<~s.~d>" (type-of restart) (unique-id restart)) (restart-report restart stream)) restart) (defstruct (restart (:PRINT-FUNCTION restart-print)) name function report-function interactive-function (test-function (constantly t))) (defun restart-report (restart stream) (declare (si::c-local)) (let ((fn (restart-report-function restart))) (if fn (funcall fn stream) (format stream "~s" (or (restart-name restart) restart))))) (defun bind-simple-restarts (tag names) (flet ((simple-restart-function (tag code) #'(lambda (&rest args) (throw tag (values code args))))) (cons (loop for i from 1 for n in (if (atom names) (list names) names) for f = (simple-restart-function tag i) collect (let ((v i)) (make-restart :name n :function f))) *restart-clusters*))) (defun bind-simple-handlers (tag names) (flet ((simple-handler-function (tag code) #'(lambda (c) (throw tag (values code c))))) (cons (loop for i from 1 for n in (if (atom names) (list names) names) for f = (simple-handler-function tag i) collect (cons n f)) *handler-clusters*))) (defmacro restart-bind (bindings &body forms) `(let ((*restart-clusters* (cons (list ,@(mapcar #'(lambda (binding) `(make-restart :NAME ',(car binding) :FUNCTION ,(cadr binding) ,@(cddr binding))) bindings)) *restart-clusters*))) ,@forms)) (defun find-restart (name &optional condition) (dolist (restart (compute-restarts condition)) (when (or (eq restart name) (eq (restart-name restart) name)) (return-from find-restart restart)))) (defun find-restart-never-fail (restart &optional condition) (declare (si::c-local)) (or (find-restart restart condition) (signal-simple-error 'control-error nil "Restart ~S is not active." (list restart)))) (defun invoke-restart (restart &rest values) (let ((real-restart (find-restart-never-fail restart))) (apply (restart-function real-restart) values))) (defun invoke-restart-interactively (restart) (let ((real-restart (find-restart-never-fail restart))) (apply (restart-function real-restart) (let ((interactive-function (restart-interactive-function real-restart))) (if interactive-function (funcall interactive-function) '()))))) (defmacro restart-case (expression &body clauses &environment env) (flet ((transform-keywords (&key report interactive test) (let ((keywords '())) (when test (setq keywords (list :TEST-FUNCTION `#',test))) (when interactive (setq keywords (list :INTERACTIVE-FUNCTION `#',interactive))) (when report (setq keywords (list* :REPORT-FUNCTION (if (stringp report) `#'(lambda (stream) (write-string ,report stream)) `#',report) keywords))) keywords))) (let*((block-tag (gensym)) (temp-var (gensym)) (data (mapcar #'(lambda (clause) (let (keywords (forms (cddr clause))) (do () ((null forms)) (if (keywordp (car forms)) (setq keywords (list* (car forms) (cadr forms) keywords) forms (cddr forms)) (return))) (list (car clause) ;Name=0 (gensym) ;Tag=1 (apply #'transform-keywords ;Keywords=2 keywords) (cadr clause) ;BVL=3 forms))) ;Body=4 clauses))) (let ((expression2 (macroexpand expression env))) (when (consp expression2) (let* ((condition-form nil) (condition-var (gensym)) (name (first expression2))) (case name (SIGNAL (setq condition-form (second expression2))) (ERROR (setq condition-form `(coerce-to-condition ,(second expression2) (list ,@(cddr expression2)) 'SIMPLE-ERROR 'ERROR))) (CERROR (setq condition-form `(coerce-to-condition ,(third expression2) (list ,@(cdddr expression2)) 'SIMPLE-ERROR 'CERROR))) (WARN (setq condition-form `(coerce-to-condition ,(second expression2) (list ,@(cddr expression2)) 'SIMPLE-WARNING 'WARN)))) (when condition-form (setq expression `(let ((,condition-var ,condition-form)) (with-condition-restarts ,condition-var (first *restart-clusters*) ,(if (eq name 'CERROR) `(cerror ,(second expression2) ,condition-var) (list name condition-var))))) )))) `(block ,block-tag (let ((,temp-var nil)) (tagbody (restart-bind ,(mapcar #'(lambda (datum) (let*((name (nth 0 datum)) (tag (nth 1 datum)) (keys (nth 2 datum))) `(,name #'(lambda (&rest temp) (setq ,temp-var temp) (go ,tag)) ,@keys))) data) (return-from ,block-tag ,expression)) ,@(mapcan #'(lambda (datum) (let*((tag (nth 1 datum)) (bvl (nth 3 datum)) (body (nth 4 datum))) (list tag `(return-from ,block-tag (apply #'(lambda ,bvl ,@body) ,temp-var))))) data))))))) (defmacro with-simple-restart ((restart-name format-control &rest format-arguments) &body forms) `(restart-case (progn ,@forms) (,restart-name () :REPORT (lambda (stream) (format stream ,format-control ,@format-arguments)) (values nil t)))) (defmacro with-condition-restarts (condition restarts &body forms) `(let ((*condition-restarts* (cons (cons ,condition ,restarts) *condition-restarts*))) ,@forms)) ;;; ---------------------------------------------------------------------- ;;; Condition Data Type (defclass condition () ((report-function :allocation :class :initform nil))) (defmethod print-object ((c condition) stream) (if *print-escape* (call-next-method) (let ((reporter (slot-value c 'report-function))) (cond ((stringp reporter) (write-string reporter stream)) ((null reporter) (call-next-method)) (t (funcall reporter c stream)))))) (defmacro define-condition (name parent-list slot-specs &rest options) ;; CAUTION: ANSI states the equivalence between :REPORT and a method. ;; Does this mean that CALL-NEXT-METHOD should be available? SBCL does ;; not do it this way, and so don't we. (let* ((class-options nil)) (dolist (option options) (case (car option) ((:DEFAULT-INITARGS :DOCUMENTATION) (push option class-options)) (:REPORT (let ((report-function (cadr option))) (push `(report-function :initform ,(if (symbolp report-function) (list 'quote report-function) report-function)) slot-specs))) (otherwise (cerror "Ignore this DEFINE-CONDITION option." "Invalid DEFINE-CONDITION option: ~S" option)))) `(PROGN (DEFCLASS ,name ,(or parent-list '(CONDITION)) ,slot-specs ,@class-options) ',NAME))) (defun find-subclasses-of-type (type class) ;; Find all subclasses of CLASS that are subtypes of the given TYPE. (declare (si::c-local)) (if (subtypep class type) (list class) (loop for c in (clos::class-direct-subclasses class) nconc (find-subclasses-of-type type c)))) (defun make-condition (type &rest slot-initializations) (let ((class (or (and (symbolp type) (find-class type nil)) (first (last (sort (find-subclasses-of-type type (find-class 'condition)) #'si::subclassp)))))) (unless class (error 'SIMPLE-TYPE-ERROR :DATUM type :EXPECTED-TYPE 'CONDITION :FORMAT-CONTROL "Not a condition type: ~S" :FORMAT-ARGUMENTS (list type))) (apply #'make-instance class slot-initializations))) #| For the moment, do not redefine these. Beppe. (eval-when (eval compile load) (defun accumulate-cases (macro-name cases list-is-atom-p) (do ((c cases (cdr c)) (l '())) ((null c) (nreverse l)) (let ((keys (caar c))) (cond ((atom keys) (cond ((null keys)) ((member keys '(OTHERWISE T)) (error "OTHERWISE is not allowed in ~S expressions." macro-name)) (t (push keys l)))) (list-is-atom-p (push keys l)) (t (setq l (append keys l))))))) );nehw-lave (defmacro ecase (keyform &rest cases) (let ((keys (accumulate-cases 'ECASE cases nil))) `(case ,keyform ,@cases (otherwise (error 'CASE-FAILURE :name 'ECASE :datum ,keyform :expected-type '(MEMBER ,@keys) :possibilities ',keys)))))) (defmacro ccase (keyplace &rest cases) (let ((keys (accumulate-cases 'CCASE cases nil)) (tag1 (gensym)) (tag2 (gensym))) `(block ,tag1 (tagbody ,tag2 (return-from ,tag1 (case ,keyplace ,@cases (otherwise (restart-case (error 'CASE-FAILURE :name 'CCASE :datum ,keyplace :expected-type '(MEMBER ,@keys) :possibilities ',keys) (store-value (value) :report (lambda (stream) (format stream "Supply a new value of ~S." ',keyplace)) :interactive read-evaluated-form (setf ,keyplace value) (go ,tag2)))))))))) (defmacro etypecase (keyform &rest cases) (let ((types (accumulate-cases 'ETYPECASE cases t))) `(typecase ,keyform ,@cases (otherwise (error 'CASE-FAILURE :name 'ETYPECASE :datum ,keyform :expected-type '(OR ,@types) :possibilities ',types))))) (defmacro ctypecase (keyplace &rest cases) (let ((types (accumulate-cases 'CTYPECASE cases t)) (tag1 (gensym)) (tag2 (gensym))) `(block ,tag1 (tagbody ,tag2 (return-from ,tag1 (typecase ,keyplace ,@cases (otherwise (restart-case (error 'CASE-FAILURE :name 'CTYPECASE :datum ,keyplace :expected-type '(OR ,@types) :possibilities ',types) (store-value (value) :REPORT (lambda (stream) (format stream "Supply a new value of ~S." ',keyplace)) :INTERACTIVE read-evaluated-form (setf ,keyplace value) (go ,tag2)))))))))) |# (defparameter *handler-clusters* nil) (defmacro handler-bind (bindings &body forms) (unless (every #'(lambda (x) (and (listp x) (= (length x) 2))) bindings) (error "Ill-formed handler bindings.")) `(let ((*handler-clusters* (cons (list ,@(mapcar #'(lambda (x) `(cons ',(car x) ,(cadr x))) bindings)) *handler-clusters*))) ,@forms)) (defun signal (datum &rest arguments) (let* ((condition (coerce-to-condition datum arguments 'SIMPLE-CONDITION 'SIGNAL)) (*handler-clusters* *handler-clusters*)) (if (typep condition *break-on-signals*) (break "~A~%Break entered because of *BREAK-ON-SIGNALS*." condition)) (loop (unless *handler-clusters* (return)) (let ((cluster (pop *handler-clusters*))) (dolist (handler cluster) < (when (typep condition (car handler)) (funcall (cdr handler) condition) )))) nil)) ;;; COERCE-TO-CONDITION ;;; Internal routine used in ERROR, CERROR, BREAK, and WARN for parsing the ;;; hairy argument conventions into a single argument that's directly usable ;;; by all the other routines. (defun coerce-to-condition (datum arguments default-type function-name) (cond ((typep datum 'CONDITION) (when arguments (cerror "Ignore the additional arguments." 'SIMPLE-TYPE-ERROR :DATUM arguments :EXPECTED-TYPE 'NULL :FORMAT-CONTROL "You may not supply additional arguments ~ when giving ~S to ~S." :FORMAT-ARGUMENTS (list datum function-name))) datum) ((symbolp datum) ;roughly, (subtypep datum 'CONDITION) (apply #'make-condition datum arguments)) ((or (stringp datum) (functionp datum)) (make-condition default-type :FORMAT-CONTROL datum :FORMAT-ARGUMENTS arguments)) (t (error 'SIMPLE-TYPE-ERROR :DATUM datum :EXPECTED-TYPE '(OR SYMBOL STRING) :FORMAT-CONTROL "Bad argument to ~S: ~S" :FORMAT-ARGUMENTS (list function-name datum))))) (defun break (&optional (format-control "Break") &rest format-arguments) "Enters a break loop. The execution of the program can be resumed by typing :CONTINUE at the break loop. Type :HELP to see the break-loop commands list. If FORMAT-STRING is non-NIL, it is used as the format string to be output to *ERROR-OUTPUT* before entering the break loop. ARGs are arguments to the format string." (let ((*debugger-hook* nil)) (with-simple-restart (continue "Return from BREAK.") (invoke-debugger (make-condition 'SIMPLE-CONDITION :FORMAT-CONTROL format-control :FORMAT-ARGUMENTS format-arguments)))) nil) (defun warn (datum &rest arguments) "Args: (format-string &rest args) Formats FORMAT-STRING and ARGs to *ERROR-OUTPUT* as a warning message. Enters a break level if the value of *BREAK-ON-WARNINGS* is non-NIL. Otherwise, returns with NIL." (let ((condition (coerce-to-condition datum arguments 'SIMPLE-WARNING 'WARN))) (check-type condition warning "a warning condition") (restart-case (signal condition) (muffle-warning () :REPORT "Skip warning." (return-from warn nil))) (format *error-output* "~&;;; Warning: ~A~%" condition) nil)) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; ALL CONDITIONS ;;; ;;; Instead of compiling each condition definition, we store them in a ;;; list and evaluate them at run time. Besides, there are multiple ;;; SIMPLE-* conditions which inherit from SIMPLE-ERROR and which are ;;; only created when the error is signaled. ;;; (define-condition warning () ()) (define-condition serious-condition () ()) (define-condition error (serious-condition) ()) (define-condition simple-condition () ((format-control :INITARG :FORMAT-CONTROL :INITFORM "" :ACCESSOR simple-condition-format-control) (format-arguments :INITARG :FORMAT-ARGUMENTS :INITFORM NIL :ACCESSOR simple-condition-format-arguments)) (:REPORT (lambda (condition stream) (format stream "~?" (simple-condition-format-control condition) (simple-condition-format-arguments condition))))) (define-condition simple-warning (simple-condition warning) ()) (define-condition style-warning (warning) ()) (define-condition simple-style-warning (style-warning simple-condition) ()) (define-condition simple-error (simple-condition error) ()) (define-condition storage-condition (serious-condition) ()) (define-condition ext:segmentation-violation (storage-condition) () (:REPORT "Detected access to an invalid or protected memory address.")) (define-condition ext:stack-overflow (storage-condition) ((size :initarg :size :initform 0 :reader ext:stack-overflow-size) (type :initarg :type :initform nil :reader ext:stack-overflow-type)) (:REPORT (lambda (condition stream) (let* ((type (ext::stack-overflow-type condition)) (size (ext::stack-overflow-size condition))) (if size (format stream "~A overflow at size ~D. Stack can probably be resized. Proceed with caution." type size) (format stream "~A stack overflow. Stack cannot grow any further. Either exit or return to an outer frame, undoing all the function calls so far." type)))))) (define-condition ext:storage-exhausted (storage-condition) () (:REPORT "Memory limit reached. Please jump to an outer pointer, quit program and enlarge the memory limits before executing the program again.")) (define-condition ext:illegal-instruction (serious-condition) () (:REPORT "Illegal instruction.")) (define-condition ext:unix-signal-received () ((code :type fixnum :initform 0 :initarg :code :accessor ext:unix-signal-received-code)) (:report (lambda (condition stream) (format stream "Serious signal ~D caught." (ext:unix-signal-received-code condition))))) (define-condition type-error (error) ((datum :INITARG :DATUM :READER type-error-datum) (expected-type :INITARG :EXPECTED-TYPE :READER type-error-expected-type)) (:REPORT (lambda (condition stream) (format stream "~S is not of type ~S." (type-error-datum condition) (type-error-expected-type condition))))) (define-condition simple-type-error (simple-condition type-error) ()) (define-condition case-failure (type-error) ((name :INITARG :NAME :READER case-failure-name) (possibilities :INITARG :POSSIBILITIES :READER case-failure-possibilities)) (:REPORT (lambda (condition stream) (format stream "~S fell through ~S expression.~%Wanted one of ~:S." (type-error-datum condition) (case-failure-name condition) (case-failure-possibilities condition))))) (define-condition program-error (error) ()) (define-condition control-error (error) ()) (define-condition stream-error (error) ((stream :initarg :stream :reader stream-error-stream))) (define-condition end-of-file (stream-error) () (:REPORT (lambda (condition stream) (format stream "Unexpected end of file on ~S." (stream-error-stream condition))))) (define-condition file-error (error) ((pathname :INITARG :PATHNAME :READER file-error-pathname)) (:REPORT (lambda (condition stream) (format stream "Filesystem error with pathname ~S.~%Either 1) the file does not exist, or 2) we are not allowed to access the file, or 3) the pathname points to a broken symbolic link." (file-error-pathname condition))))) (define-condition package-error (error) ((package :INITARG :PACKAGE :READER package-error-package))) (define-condition cell-error (error) ((name :INITARG :NAME :READER cell-error-name))) (define-condition unbound-variable (cell-error) () (:REPORT (lambda (condition stream) (format stream "The variable ~S is unbound." (cell-error-name condition))))) (define-condition unbound-slot (cell-error) ((instance :INITARG :INSTANCE :READER unbound-slot-instance)) (:REPORT (lambda (condition stream) (format stream "The slot ~S in the object ~S is unbound." (cell-error-name condition) (unbound-slot-instance condition))))) (define-condition undefined-function (cell-error) () (:REPORT (lambda (condition stream) (format stream "The function ~S is undefined." (cell-error-name condition))))) (define-condition arithmetic-error (error) ((operation :INITARG :OPERATION :READER arithmetic-error-operation) (operands :INITARG :OPERANDS :INITFORM '() :READER arithmetic-error-operands))) (define-condition division-by-zero (arithmetic-error) ()) (define-condition floating-point-overflow (arithmetic-error) ()) (define-condition floating-point-underflow (arithmetic-error) ()) (define-condition floating-point-inexact (arithmetic-error) ()) (define-condition floating-point-invalid-operation (arithmetic-error) ()) (define-condition abort-failure (control-error) () (:REPORT "Abort failed.")) (define-condition print-not-readable (error) ((object :INITARG :OBJECT :READER print-not-readable-object)) (:REPORT (lambda (condition stream) (format stream "Cannot print object ~A readably." (print-not-readable-object condition))))) (define-condition parse-error (error) ()) (define-condition reader-error (parse-error stream-error) ()) (define-condition format-error (simple-error) ((format-control :initarg :complaint) (format-arguments :initarg :arguments) (control-string :reader format-error-control-string :initarg :control-string #+cmu-format :initform #+cmu-format *default-format-error-control-string*) (offset :reader format-error-offset :initarg :offset #+cmu-format :initform #+cmu-format *default-format-error-offset*) (print-banner :reader format-error-print-banner :initarg :print-banner :initform t)) (:report (lambda (condition stream) (cl:format stream "~:[~;Error in format: ~]~ ~?~@[~% ~A~% ~V@T^~]" (format-error-print-banner condition) (simple-condition-format-control condition) (simple-condition-format-arguments condition) (format-error-control-string condition) (format-error-offset condition))))) (define-condition ext:interactive-interrupt (serious-condition) () (:report "Console interrupt.")) (defun signal-simple-error (base-condition continue-message format-control format-args &rest args) (let ((simple-error-name (intern (concatenate 'string "SIMPLE-" (string base-condition)) (find-package "SI")))) (unless (find-class simple-error-name nil) (eval `(defclass ,simple-error-name (simple-error ,base-condition) ()))) (if continue-message (apply #'cerror continue-message simple-error-name :format-control format-control :format-arguments format-args args) (apply #'error simple-error-name :format-control format-control :format-arguments format-args args)))) (defmacro handler-case (form &rest cases) (let ((no-error-clause (assoc ':NO-ERROR cases))) (if no-error-clause (let* ((normal-return (make-symbol "NORMAL-RETURN")) (error-return (make-symbol "ERROR-RETURN"))) `(block ,error-return (multiple-value-call #'(lambda ,@(cdr no-error-clause)) (block ,normal-return (return-from ,error-return (handler-case (return-from ,normal-return ,form) ,@(remove no-error-clause cases))))))) (let* ((tag (gensym)) (var (gensym)) (annotated-cases (mapcar #'(lambda (case) (cons (gensym) case)) cases))) `(block ,tag (let ((,var nil)) (declare (ignorable ,var)) (tagbody (handler-bind ,(mapcar #'(lambda (annotated-case) (list (cadr annotated-case) `#'(lambda (temp) (declare (ignorable temp)) ,@(if (caddr annotated-case) `((setq ,var temp))) (go ,(car annotated-case))))) annotated-cases) (return-from ,tag ,form)) ,@(mapcan #'(lambda (annotated-case) (list (car annotated-case) (let ((body (cdddr annotated-case))) `(return-from ,tag ,(if (caddr annotated-case) `(let ((,(caaddr annotated-case) ,var)) ,@body) ;; We must allow declarations! `(locally ,@body)))))) annotated-cases)))))))) (defmacro ignore-errors (&rest forms) `(handler-case (progn ,@forms) (error (condition) (values nil condition)))) (defun abort (&optional c) (invoke-restart (find-restart-never-fail 'ABORT c)) (error 'ABORT-FAILURE)) (defun continue (&optional c) (let ((restart (find-restart 'CONTINUE c))) (and restart (invoke-restart restart)))) (defun muffle-warning (&optional c) (invoke-restart (find-restart-never-fail 'MUFFLE-WARNING c))) (defun store-value (value &optional c) (let ((restart (find-restart 'STORE-VALUE c))) (and restart (invoke-restart restart value)))) (defun use-value (value &optional c) (let ((restart (find-restart 'USE-VALUE c))) (and restart (invoke-restart restart value)))) (defun assert-report (names stream) (declare (si::c-local)) (format stream "Retry assertion") (if names (format stream " with new value~P for ~{~S~^, ~}." (length names) names) (format stream "."))) (defun assert-prompt (name value) (declare (si::c-local)) (if (y-or-n-p "The old value of ~S is ~S.~ ~%Do you want to supply a new value? " name value) (flet ((read-it () (eval (read *query-io*)))) (format *query-io* "~&Type a form to be evaluated:~%") (if (symbolp name) ;Help user debug lexical variables (progv (list name) (list value) (read-it)) (read-it))) value)) (defun assert-failure (test-form &optional place-names values &rest arguments) (unless arguments (setf arguments (list 'SIMPLE-TYPE-ERROR :DATUM test-form :EXPECTED-TYPE nil ; This needs some work in revision :FORMAT-CONTROL "The assertion ~S failed" :FORMAT-ARGUMENTS (list test-form)))) (restart-case (error (si::coerce-to-condition (first arguments) (rest arguments) 'simple-error 'assert)) (continue () :REPORT (lambda (stream) (assert-report place-names stream)) (return-from assert-failure (values-list (loop for place-name in place-names for value in values collect (assert-prompt place-name value))))))) ;;; ---------------------------------------------------------------------- ;;; ECL's interface to the toplevel and debugger (defun sys::universal-error-handler (continue-string datum args) "Args: (error-name continuable-p function-name continue-format-string error-format-string &rest args) ECL specific. Starts the error handler of ECL. When an error is detected, ECL calls this function with the specified arguments. To change the error handler of ECL, redefine this function. ERROR-NAME is the name of the error. CONTINUABLE-P is T for a continuable error and NIL for a fatal error. FUNCTION-NAME is the name of the function that caused the error. CONTINUE-FORMAT-STRING and ERROR-FORMAT-STRING are the format strings of the error message. ARGS are the arguments to the format strings." (declare (inline apply) ;; So as not to get bogus frames in debugger #-ecl-min (c::policy-debug-ihs-frame)) (let ((condition (coerce-to-condition datum args 'simple-error 'error))) (cond ((eq t continue-string) ; from CEerror; mostly allocation errors (with-simple-restart (ignore "Ignore the error, and try the operation again") (signal condition) (invoke-debugger condition))) ((stringp continue-string) (with-simple-restart (continue "~A" (format nil "~?" continue-string args)) (signal condition) (invoke-debugger condition))) ((and continue-string (symbolp continue-string)) ; from CEerror (with-simple-restart (accept "Accept the error, returning NIL") (multiple-value-bind (rv used-restart) (with-simple-restart (ignore "Ignore the error, and try the operation again") (multiple-value-bind (rv used-restart) (with-simple-restart (continue "Continue, using ~S" continue-string) (signal condition) (invoke-debugger condition)) (if used-restart continue-string rv))) (if used-restart t rv)))) (t (progn (signal condition) (invoke-debugger condition)))))) (defun sys::stack-error-handler (continue-string datum args) (unwind-protect (universal-error-handler continue-string datum args) (si:reset-margin (getf args :type)))) (defun sys::tpl-continue-command (&rest any) (apply #'invoke-restart 'continue any)) ecl-16.1.2/src/clos/cpl.lsp000066400000000000000000000155631266352375300154170ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: CLOS -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; Copyright (c) 1992, Giuseppe Attardi. ;;;; Copyright (c) 2001, Juan Jose Garcia Ripoll. ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. (in-package "CLOS") ;;; ---------------------------------------------------------------------- ;;; ORDERING OF CLASSES ;;; ;;; We have two implementations of the algorithm described in Sect. 4.3.5 ;;; of the Common Lisp Hyperspec. The first implementation is a literal ;;; transcription of that algorithm. The second implementation does not ;;; create the list of pairs for describing the order, it is not recursive ;;; and conses less #+(or) (defun compute-clos-class-precedence-list (new-class superclasses) (labels ((pair-list (l) (if (or (null l) (endp (cdr l))) nil (cons (cons (first l) (second l)) (pair-list (rest l))))) (walk-supers (parent superclasses class-list precedence-alist) (let ((new-alist (pair-list (if parent (list* parent superclasses) superclasses)))) (setf precedence-alist (nconc new-alist precedence-alist) class-list (union superclasses class-list))) (dolist (c superclasses) (multiple-value-setq (class-list precedence-alist) (walk-supers c (class-direct-superclasses c) class-list precedence-alist))) (values class-list precedence-alist)) (cycle-error (new-class) (error "A cycle has been detected in the class precedence list for ~A." (class-name new-class))) (free-elements (class-list precedence-alist) (set-difference class-list (delete-duplicates (mapcar #'cdr precedence-alist)))) (next-element (free-list cpl) (if (or (null cpl) (endp free-list) (endp (rest free-list))) (first free-list) (dolist (i cpl nil) (dolist (j (class-direct-superclasses i)) (when (member j free-list) (return-from next-element j))))))) (if (endp (rest superclasses)) (let ((class (first superclasses))) (list* new-class (class-precedence-list class))) (multiple-value-bind (class-list precedence-alist) (walk-supers nil superclasses nil nil) (do ((cpl (list new-class))) ((null class-list) (if precedence-alist (cycle-error new-class) (nreverse cpl))) (let* ((candidates (free-elements class-list precedence-alist)) (next (next-element candidates cpl))) (unless next (cycle-error new-class)) (setf precedence-alist (delete next precedence-alist :key #'car) class-list (delete next class-list) cpl (cons next cpl)))))))) (defun compute-clos-class-precedence-list (new-class superclasses) (labels ((walk-supers (superclasses) ;; Creates two lists, one with all the superclasses of a class to be created, ;; and a second list with lists (c1 c2 c3 ... cn) that represent a partial ;; ordering of the classes (c1 > c2), (c2 > c3), etc." (let ((class-list '()) (precedence-lists (list superclasses))) (loop (unless superclasses (return (values class-list precedence-lists))) (let ((next-class (pop superclasses))) (unless (member next-class class-list :test 'eql) (let ((more-classes (slot-value next-class 'direct-superclasses))) (setf class-list (list* next-class class-list) precedence-lists (list* (list* next-class more-classes) precedence-lists) superclasses (append more-classes superclasses)))))))) (cycle-error (class) (error "A cycle has been detected in the class precedence list for ~A." (class-name class))) (has-no-precedent (class precedence-lists) ;; Check if CLASS is not preceded by any other class in the partial order. (dolist (partial-order precedence-lists t) (when (member class (rest partial-order) :test 'eql) (return nil)))) (free-elements (class-list precedence-lists) ;; Return classes that are not preceded by anyone (let ((output '())) (dolist (class class-list) (when (has-no-precedent class precedence-lists) (push class output))) output)) (next-element (free-list cpl) ;; Compute the next element that we will add to the class precedence list. (if (or (null cpl) (endp free-list) (endp (rest free-list))) (first free-list) (dolist (i cpl nil) (dolist (j (slot-value i 'direct-superclasses)) (when (member j free-list :test 'eql) (return-from next-element j)))))) (delete-class (class precedence-lists) (do ((l precedence-lists (rest l))) ((null l) (delete nil precedence-lists)) (let ((one-list (first l))) (when (eq class (first one-list)) (setf (first l) (rest one-list))))))) (cond ((null superclasses) (list new-class)) ((endp (rest superclasses)) (let ((class (first superclasses))) (list* new-class (slot-value class 'precedence-list)))) (t (multiple-value-bind (class-list precedence-lists) (walk-supers superclasses) (do ((cpl (list new-class))) ((null class-list) (if precedence-lists (cycle-error new-class) (nreverse cpl))) (let* ((candidates (free-elements class-list precedence-lists)) (next (next-element candidates cpl))) (unless next (cycle-error new-class)) (setf precedence-lists (delete-class next precedence-lists) class-list (delete next class-list) cpl (cons next cpl))))))))) ;;; ---------------------------------------------------------------------- ecl-16.1.2/src/clos/defclass.lsp000066400000000000000000000131331266352375300164140ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: CLOS -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; Copyright (c) 1992, Giuseppe Attardi. ;;;; Copyright (c) 2001, Juan Jose Garcia Ripoll. ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. (in-package "CLOS") ;;; ---------------------------------------------------------------------- ;;; DEFCLASS (defun parse-default-initargs (default-initargs) (declare (si::c-local)) (do* ((output-list nil) (scan default-initargs (cddr scan)) (already-supplied '())) ((endp scan) `(list ,@(nreverse output-list))) (when (endp (rest scan)) (si::simple-program-error "Wrong number of elements in :DEFAULT-INITARGS option.")) (let ((slot-name (first scan)) (initform (second scan))) (if (member slot-name already-supplied) (si::simple-program-error "~S is duplicated in :DEFAULT-INITARGS form ~S" slot-name default-initargs) (push slot-name already-supplied)) (push `(list ',slot-name ',initform ,(make-function-initform initform)) output-list)))) (defmacro defclass (&whole form &rest args) (unless (>= (length args) 3) (si::simple-program-error "Illegal defclass form: the class name, the superclasses and the slots should always be provided")) (let* ((name (pop args)) (superclasses (pop args)) (slots (pop args)) (options args)) (unless (and (listp superclasses) (listp slots)) (si::simple-program-error "Illegal defclass form: superclasses and slots should be lists")) (unless (and (symbolp name) (every #'symbolp superclasses)) (si::simple-program-error "Illegal defclass form: superclasses and class name are not valid")) `(eval-when (compile load eval) ,(ext:register-with-pde form `(load-defclass ',name ',superclasses ,(compress-slot-forms slots) ,(process-class-options options)))))) (defun compress-slot-forms (slot-definitions) (declare (si::c-local)) ;; Here we compose the final form. The slots list, and the default initargs ;; may contain object that need to be evaluated. Hence, it cannot be always ;; quoted. (let ((const '()) (output '()) (non-const nil)) (dolist (slotd (parse-slots slot-definitions)) (let* ((initfun (getf slotd :initfunction nil)) (copy (copy-list slotd))) (remf copy :initfunction) (cond ((atom initfun) (push copy const) (push (ext:maybe-quote copy) output)) ((eq (first initfun) 'constantly) (push copy const) (push (ext:maybe-quote copy) output)) (t (push `(list* :initfunction ,initfun ,(ext:maybe-quote copy)) output) (setf non-const t))))) (if non-const `(list ,@(nreverse output)) (ext:maybe-quote (nreverse const))))) (defun uncompress-slot-forms (slot-definitions) (loop for slotd in slot-definitions for initform = (getf slotd :initform slotd) collect (if (eq initform slotd) slotd (if (getf slotd :initfunction) slotd (list* :initfunction (constantly (eval initform)) slotd))))) (defun process-class-options (class-args) (let ((options '()) (processed-options '())) (dolist (option class-args) (let ((option-name (first option)) option-value) (if (member option-name processed-options) (si:simple-program-error "Option ~s for DEFCLASS specified more than once" option-name) (push option-name processed-options)) (setq option-value (case option-name ((:metaclass :documentation) (ext:maybe-quote (second option))) (:default-initargs (setf option-name :direct-default-initargs) (parse-default-initargs (rest option))) (otherwise (ext:maybe-quote (rest option)))) options (list* (ext:maybe-quote option-name) option-value options)))) (and options `(list ,@options)))) (defun load-defclass (name superclasses slot-definitions options) (apply #'ensure-class name :direct-superclasses superclasses :direct-slots (uncompress-slot-forms slot-definitions) options)) ;;; ---------------------------------------------------------------------- ;;; ENSURE-CLASS ;;; (defun ensure-class (name &rest initargs) (let* ((old-class nil) new-class) ;; Only classes which have a PROPER name are redefined. If a class ;; with the same name is register, but the name of the class does not ;; correspond to the registered name, a new class is returned. ;; [Hyperspec 7.7 for DEFCLASS] (when name (when (and (setf old-class (find-class name nil)) (not (eq (class-name old-class) name))) (setf old-class nil))) (setf new-class (apply #'ensure-class-using-class old-class name initargs)) new-class)) #+(or) ;#+cross (eval-when (compile) (defun ensure-class (name &rest initargs) (warn "Ignoring definition for class ~S" name))) ecl-16.1.2/src/clos/fixup.lsp000066400000000000000000000330341266352375300157650ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: CLOS -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; Copyright (c) 1992, Giuseppe Attardi. ;;;; Copyright (c) 2001, Juan Jose Garcia Ripoll. ;;;; Copyright (c) 2015, Daniel KochmaХ„ski ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. (in-package "CLOS") ;;; --------------------------------------------------------------------- ;;; slots #| (defclass effective-slot-definition (slot-definition)) (defclass direct-slot-definition (slot-definition)) (defclass standard-slot-definition (slot-definition)) (defclass standard-direct-slot-definition (standard-slot-definition direct-slot-definition)) (defclass standard-effective-slot-definition (standard-slot-definition direct-slot-definition)) |# (defmethod reader-method-class ((class std-class) (direct-slot direct-slot-definition) &rest initargs) (declare (ignore class direct-slot initargs)) (find-class (if (member (class-name (class-of class)) '(standard-class funcallable-standard-class structure-class)) 'standard-optimized-reader-method 'standard-reader-method))) (defmethod writer-method-class ((class std-class) (direct-slot direct-slot-definition) &rest initargs) (declare (ignore class direct-slot initargs)) (find-class (if (member (class-name (class-of class)) '(standard-class funcallable-standard-class structure-class)) 'standard-optimized-writer-method 'standard-reader-method))) ;;; --------------------------------------------------------------------- ;;; Fixup (defun register-method-with-specializers (method) (declare (si::c-local)) (loop for spec in (method-specializers method) do (add-direct-method spec method))) (dolist (method-info *early-methods* (makunbound '*EARLY-METHODS*)) (let* ((method-name (car method-info)) (gfun (fdefinition method-name)) (standard-method-class (find-class 'standard-method))) (when (eq 'T (class-id (si:instance-class gfun))) ;; complete the generic function object (si:instance-class-set gfun (find-class 'STANDARD-GENERIC-FUNCTION)) (si::instance-sig-set gfun) (setf (slot-value gfun 'method-class) standard-method-class) (setf (slot-value gfun 'docstring) nil) ) (dolist (method (cdr method-info)) ;; complete the method object (let ((old-class (si::instance-class method))) (si::instance-class-set method (cond ((null old-class) (find-class 'standard-method)) ((symbolp old-class) (find-class (truly-the symbol old-class))) (t old-class)))) (si::instance-sig-set gfun) (register-method-with-specializers method) ) )) ;;; --------------------------------------------------------------------- ;;; redefined (defun method-p (method) (typep method 'METHOD)) (defun make-method (method-class qualifiers specializers arglist function options) (apply #'make-instance method-class :generic-function nil :qualifiers qualifiers :lambda-list arglist :specializers specializers :function function :allow-other-keys t options)) (defun all-keywords (l) (declare (si::c-local)) (let ((all-keys '())) (do ((l (rest l) (cddddr l))) ((null l) all-keys) (push (first l) all-keys)))) (defun congruent-lambda-p (l1 l2) (multiple-value-bind (r1 opts1 rest1 key-flag1 keywords1 a-o-k1) (si::process-lambda-list l1 'FUNCTION) (declare (ignore a-o-k1)) (multiple-value-bind (r2 opts2 rest2 key-flag2 keywords2 a-o-k2) (si::process-lambda-list l2 'FUNCTION) (and (= (length r2) (length r1)) (= (length opts1) (length opts2)) (eq (and (null rest1) (null key-flag1)) (and (null rest2) (null key-flag2))) ;; All keywords mentioned in the genericf function ;; must be accepted by the method. (or (null key-flag1) (null key-flag2) a-o-k2 (null (set-difference (all-keywords keywords1) (all-keywords keywords2)))) t)))) (defun add-method (gf method) ;; during boot it's a structure accessor (declare (notinline method-qualifiers remove-method)) ;; ;; 1) The method must not be already installed in another generic ;; function. ;; (let ((other-gf (method-generic-function method))) (unless (or (null other-gf) (eq other-gf gf)) (error "The method ~A belongs to the generic function ~A ~ and cannot be added to ~A." method other-gf gf))) ;; ;; 2) The method and the generic function should have congruent ;; lambda lists. That is, it should accept the same number of ;; required and optional arguments, and only accept keyword ;; arguments when the generic function does. ;; (let ((new-lambda-list (method-lambda-list method))) (if (slot-boundp gf 'lambda-list) (let ((old-lambda-list (generic-function-lambda-list gf))) (unless (congruent-lambda-p old-lambda-list new-lambda-list) (error "Cannot add the method ~A to the generic function ~A because ~ their lambda lists ~A and ~A are not congruent." method gf old-lambda-list new-lambda-list))) (reinitialize-instance gf :lambda-list (implicit-generic-lambda new-lambda-list)))) ;; ;; 3) Finally, it is inserted in the list of methods, and the method is ;; marked as belonging to a generic function. ;; (when (generic-function-methods gf) (let* ((method-qualifiers (method-qualifiers method)) (specializers (method-specializers method)) (found (find-method gf method-qualifiers specializers nil))) (when found (remove-method gf found)))) ;; ;; We install the method by: ;; i) Adding it to the list of methods (push method (generic-function-methods gf)) (setf (method-generic-function method) gf) ;; ii) Updating the specializers list of the generic ;; function. Notice that we should call add-direct-method for each ;; specializer but specializer objects are not yet implemented #+(or) (dolist (spec (method-specializers method)) (add-direct-method spec method)) ;; iii) Computing a new discriminating function... Well, since the ;; core ECL does not need the discriminating function because we ;; always use the same one, we just update the spec-how list of the ;; generic function. (compute-g-f-spec-list gf) (set-generic-function-dispatch gf) ;; iv) Update dependents. (update-dependents gf (list 'add-method method)) ;; v) Register with specializers (register-method-with-specializers method) gf) (defun function-to-method (name signature) (let* ((aux-name 'temp-method) (method (eval `(defmethod ,aux-name ,signature))) (generic-function (fdefinition aux-name))) (setf (method-function method) (wrapped-method-function (fdefinition name))) (setf (fdefinition name) generic-function) (setf (generic-function-name generic-function) name) (fmakunbound aux-name))) (defun remove-method (gf method) (setf (generic-function-methods gf) (delete method (generic-function-methods gf)) (method-generic-function method) nil) (si:clear-gfun-hash gf) (loop for spec in (method-specializers method) do (remove-direct-method spec method)) (compute-g-f-spec-list gf) (set-generic-function-dispatch gf) (update-dependents gf (list 'remove-method method)) gf) (function-to-method 'add-method '((gf standard-generic-function) (method standard-method))) (function-to-method 'remove-method '((gf standard-generic-function) (method standard-method))) (function-to-method 'find-method '((gf standard-generic-function) qualifiers specializers &optional error)) ;;; COMPUTE-APPLICABLE-METHODS is used by the core in various places, ;;; including instance initialization. This means we cannot just ;;; redefine it. ;;; ;;; Instead, we create an auxiliary function and move definitions from ;;; one to the other. #+(or) (defgeneric aux-compute-applicable-methods (gf args) (:method ((gf standard-generic-function) args) (std-compute-applicable-methods gf args))) (defmethod aux-compute-applicable-methods ((gf standard-generic-function) args) (std-compute-applicable-methods gf args)) (let ((aux #'aux-compute-applicable-methods)) (setf (generic-function-name aux) 'compute-applicable-methods (fdefinition 'compute-applicable-methods) aux)) (defmethod compute-applicable-methods-using-classes ((gf standard-generic-function) classes) (std-compute-applicable-methods-using-classes gf classes)) (function-to-method 'compute-effective-method '((gf standard-generic-function) method-combination applicable-methods)) ;;; --------------------------------------------------------------------- ;;; Error messages (defmethod no-applicable-method (gf &rest args) (error "No applicable method for ~S with ~ ~:[no arguments~;arguments of types ~:*~{~& ~A~}~]." (generic-function-name gf) (mapcar #'type-of args))) (defmethod no-next-method (gf method &rest args) (declare (ignore gf)) (error "In method ~A~%No next method given arguments ~A" method args)) (defun no-primary-method (gf &rest args) (error "Generic function: ~A. No primary method given arguments: ~S" (generic-function-name gf) args)) ;;; Now we protect classes from redefinition: (eval-when (compile load) (defun setf-find-class (new-value name &optional errorp env) (declare (ignore errorp)) (let ((old-class (find-class name nil env))) (cond ((typep old-class 'built-in-class) (error "The class associated to the CL specifier ~S cannot be changed." name)) ((member name '(CLASS BUILT-IN-CLASS) :test #'eq) (error "The kernel CLOS class ~S cannot be changed." name)) ((classp new-value) (setf (gethash name si:*class-name-hash-table*) new-value)) ((null new-value) (remhash name si:*class-name-hash-table*)) (t (error "~A is not a class." new-value)))) new-value) ) ;;; --------------------------------------------------------------------- ;;; DEPENDENT MAINTENANCE PROTOCOL ;;; (defmethod add-dependent ((c class) dep) (pushnew dep (class-dependents c))) (defmethod add-dependent ((c generic-function) dependent) (pushnew dependent (generic-function-dependents c))) (defmethod remove-dependent ((c class) dep) (setf (class-dependents c) (remove dep (class-dependents c)))) (defmethod remove-dependent ((c standard-generic-function) dep) (setf (generic-function-dependents c) (remove dep (generic-function-dependents c)))) (defmethod map-dependents ((c class) function) (dolist (d (class-dependents c)) (funcall function d))) (defmethod map-dependents ((c standard-generic-function) function) (dolist (d (generic-function-dependents c)) (funcall function d))) (defgeneric update-dependent (object dependent &rest initargs)) ;; After this, update-dependents will work (setf *clos-booted* 'map-dependents) (defclass initargs-updater () ()) (defun recursively-update-classes (a-class) (slot-makunbound a-class 'valid-initargs) (mapc #'recursively-update-classes (class-direct-subclasses a-class))) (defmethod update-dependent ((object generic-function) (dep initargs-updater) &rest initargs) (declare (ignore dep initargs object)) (recursively-update-classes +the-class+)) (let ((x (make-instance 'initargs-updater))) (add-dependent #'shared-initialize x) (add-dependent #'initialize-instance x) (add-dependent #'allocate-instance x)) (function-to-method 'make-method-lambda '((gf standard-generic-function) (method standard-method) lambda-form environment)) (function-to-method 'compute-discriminating-function '((gf standard-generic-function))) (function-to-method 'generic-function-method-class '((gf standard-generic-function))) (function-to-method 'find-method-combination '((gf standard-generic-function) method-combination-type-name method-combination-options)) (function-to-method '(setf generic-function-name) '((name t) (gf generic-function))) ecl-16.1.2/src/clos/generic.lsp000066400000000000000000000271341266352375300162520ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: CLOS -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; Copyright (c) 1992, Giuseppe Attardi. ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. (in-package "CLOS") ;;; ---------------------------------------------------------------------- ;;; DEFGENERIC ;;; (defmacro defgeneric (&whole whole &rest args) (multiple-value-bind (function-specifier lambda-list options) (parse-defgeneric args) (parse-lambda-list lambda-list) ;; process options (multiple-value-bind (option-list method-list) (parse-generic-options options lambda-list) (let* ((output `(ensure-generic-function ',function-specifier :delete-methods t ,@option-list))) (ext:register-with-pde whole (if method-list `(progn ,output (associate-methods-to-gfun ',function-specifier ,@(loop for m in method-list collect `(defmethod ,function-specifier ,@m)))) output)))))) (defun parse-defgeneric (args) (declare (si::c-local)) ;; (values function-specifier lambda-list options) (let (function-specifier) (unless args (simple-program-error "Illegal defgeneric form: missing generic function name")) (setq function-specifier (pop args)) (unless args (simple-program-error "Illegal defgeneric form: missing lambda-list")) (values function-specifier (first args) (rest args)))) (defun parse-generic-options (options lambda-list) (declare (si::c-local)) (let* ((processed-options '()) (method-list '()) (declarations '()) arg-list) (dolist (option options) (let ((option-name (first option)) option-value) (cond ((eq option-name :method) ;; We do not need to check the validity of this ;; because DEFMETHOD will do it. (push (rest option) method-list)) ((eq option-name 'declare) (setf declarations (append (rest option) declarations))) ((member option-name processed-options) (simple-program-error "Option ~s specified more than once" option-name)) (t (push option-name processed-options) ;; We leave much of the type checking for SHARED-INITIALIZE (setq option-value (case option-name (:argument-precedence-order (rest option)) (:method-combination (rest option)) ((:documentation :generic-function-class :method-class) (unless (endp (cddr option)) (simple-program-error "Too many arguments for option ~A" option-name)) (second option)) (otherwise (simple-program-error "~S is not a legal defgeneric option" option-name)))) (setf arg-list `(',option-name ',option-value ,@arg-list)))))) (values `(:lambda-list ',lambda-list ,@arg-list ,@(when declarations `(:declarations ',declarations))) method-list))) (defun parse-lambda-list (lambda-list &optional post-keyword) (declare (si::c-local)) (let ((arg (car lambda-list))) (cond ((null lambda-list)) ((eq arg '&AUX) (simple-program-error "&aux is not allowed in a generic function lambda-list")) ((member arg lambda-list-keywords) (parse-lambda-list (cdr lambda-list) t)) (post-keyword ;; After a lambda-list-keyword there can be no specializers. (parse-lambda-list (cdr lambda-list) t)) (t (if (listp arg) (simple-program-error "the parameters cannot be specialized in generic function lambda-list") (parse-lambda-list (cdr lambda-list))))))) (defun valid-declaration-p (decl) ;(declare (si::c-local)) (and (eq (first decl) 'OPTIMIZE) (loop for item in decl always (or (atom item) (and (consp item) (member (first item) '(SPEED SPACE COMPILATION-SPEED DEBUG SAFETY))))))) ;;; ---------------------------------------------------------------------- ;;; GENERIC FUNCTION (RE)INITIALIZATION PROTOCOL ;; (defun lambda-list-required-arguments (lambda-list) (rest (si::process-lambda-list lambda-list t))) (defmethod shared-initialize ((gfun generic-function) slot-names &rest initargs &key (name nil) (lambda-list nil l-l-p) (argument-precedence-order nil a-o-p) (documentation nil) (declarations nil) (method-class (find-class 'method)) &aux (gfun-name (if (slot-boundp gfun 'name) (slot-value gfun 'name) (or name :anonymous))) ) (declare (ignore initargs slot-names)) ;; ;; Check the validity of several fields. ;; (when a-o-p (unless l-l-p (simple-program-error "When defining generic function ~A~%Supplied :argument-precedence-order, but :lambda-list is missing" gfun-name)) (dolist (l (lambda-list-required-arguments lambda-list)) (unless (= (count l argument-precedence-order) 1) (simple-program-error "When defining generic function ~A~%The required argument ~A does not appear exactly once in the ARGUMENT-PRECEDENCE-ORDER list ~A" gfun-name l argument-precedence-order)))) (unless (every #'valid-declaration-p declarations) (simple-program-error "When defining generic function ~A~%Not a valid declaration list: ~A" gfun-name declarations)) (unless (or (null documentation) (stringp documentation)) (error 'simple-type-error :format-control "When defining generic function~A~%Not a valid documentation object ~" :format-arguments (list gfun-name documentation) :datum documentation :expected-type '(or null string))) (unless (si::subclassp method-class (find-class 'method)) (error 'simple-type-error :format-control "When defining generic function~A~%Not a valid method class, ~A" :format-arguments (list gfun-name method-class) :datum method-class :expected-type 'method)) ;; ;; When supplying a new lambda-list, ensure that it is compatible with ;; the old list of methods. ;; (when (and l-l-p (slot-boundp gfun 'methods)) (unless (every #'(lambda (x) (congruent-lambda-p lambda-list x)) (mapcar #'method-lambda-list (generic-function-methods gfun))) (simple-program-error "Cannot replace the lambda list of ~A with ~A because it is incongruent with some of the methods" gfun lambda-list))) (call-next-method) (let ((combination (generic-function-method-combination gfun))) (unless (typep combination 'method-combination) (setf (generic-function-method-combination gfun) (find-method-combination gfun (first combination) (rest combination))))) (when (and l-l-p (not a-o-p)) (setf (generic-function-argument-precedence-order gfun) (lambda-list-required-arguments lambda-list))) (set-generic-function-dispatch gfun) gfun) (defmethod shared-initialize ((gfun standard-generic-function) slot-names &rest initargs) (declare (ignore initargs slot-names)) (call-next-method) (when (generic-function-methods gfun) (compute-g-f-spec-list gfun)) (update-dependents gfun initargs) gfun) (defun associate-methods-to-gfun (name &rest methods) (let ((gfun (fdefinition name))) (dolist (method methods) (setf (getf (method-plist method) :method-from-defgeneric-p) t)) gfun)) (defmethod ensure-generic-function-using-class ((gfun generic-function) name &rest args &key (method-class 'STANDARD-METHOD method-class-p) (generic-function-class (class-of gfun)) (delete-methods nil)) ;; modify the existing object (setf args (copy-list args)) (remf args :generic-function-class) (remf args :declare) (remf args :environment) (remf args :delete-methods) ;; FIXME! We should check that the class GENERIC-FUNCTION-CLASS is compatible ;; with the old one. In what sense "compatible" is ment, I do not know! ;; (See ANSI DEFGENERIC entry) (when (symbolp generic-function-class) (setf generic-function-class (find-class generic-function-class))) (unless (si::subclassp generic-function-class (find-class 'generic-function)) (error "~A is not a valid :GENERIC-FUNCTION-CLASS argument for ENSURE-GENERIC-FUNCTION." generic-function-class)) (when (and method-class-p (symbolp method-class)) (setf args (list* :method-class (find-class method-class) args))) (when delete-methods (dolist (m (copy-list (generic-function-methods gfun))) (when (getf (method-plist m) :method-from-defgeneric-p) (remove-method gfun m)))) (if (eq (class-of gfun) generic-function-class) (apply #'reinitialize-instance gfun args) (apply #'change-class gfun generic-function-class args))) (defmethod ensure-generic-function-using-class ((gfun null) name &rest args &key (method-class 'STANDARD-METHOD method-class-p) (generic-function-class 'STANDARD-GENERIC-FUNCTION) (delete-methods nil)) (declare (ignore delete-methods gfun)) ;; else create a new generic function object (setf args (copy-list args)) (remf args :generic-function-class) (remf args :declare) (remf args :environment) (remf args :delete-methods) (when (and method-class-p (symbolp generic-function-class)) (setf args (list* :method-class (find-class method-class) args))) (apply #'make-instance generic-function-class :name name args)) (defun ensure-generic-function (name &rest args &key &allow-other-keys) (let ((gfun (si::traced-old-definition name))) (cond ((not (legal-generic-function-name-p name)) (simple-program-error "~A is not a valid generic function name" name)) ((not (fboundp name)) (setf (fdefinition name) (apply #'ensure-generic-function-using-class gfun name args))) ((si::instancep (or gfun (setf gfun (fdefinition name)))) (apply #'ensure-generic-function-using-class gfun name args)) ((special-operator-p name) (simple-program-error "The special operator ~A is not a valid name for a generic function" name)) ((macro-function name) (simple-program-error "The symbol ~A is bound to a macro and is not a valid name for a generic function" name)) ((not *clos-booted*) (setf (fdefinition name) (apply #'ensure-generic-function-using-class nil name args)) (fdefinition name)) (t (simple-program-error "The symbol ~A is bound to an ordinary function and is not a valid name for a generic function" name))))) ecl-16.1.2/src/clos/hierarchy.lsp000066400000000000000000000354331266352375300166150ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: CLOS -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; Copyright (c) 1992, Giuseppe Attardi.o ;;;; Copyright (c) 2001, Juan Jose Garcia Ripoll. ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. ;;; ;;; COMMON LISP CLASSES HIERARCHY ;;; ;;; The following set of constants describe the slots, the names of ;;; the classes and their relation, including both standard Commmon Lisp ;;; and the MetaObject Protocol. This information is only loaded when ;;; bootstrapping and compiling ECL. ;;; (in-package "CLOS") ;;; ---------------------------------------------------------------------- ;;; Class SPECIALIZER (eval-when (:compile-toplevel :execute) (defparameter +specializer-slots+ '((flag :initform nil :accessor eql-specializer-flag) (direct-methods :initform nil :accessor specializer-direct-methods) (direct-generic-functions :initform nil :accessor specializer-direct-generic-functions)))) (eval-when (:compile-toplevel :execute) (defparameter +eql-specializer-slots+ '((flag :initform t :accessor eql-specializer-flag) (direct-methods :initform nil :accessor specializer-direct-methods) (direct-generic-functions :initform nil :accessor specializer-direct-generic-functions) (object :initarg :object :accessor eql-specializer-object)))) ;;; ---------------------------------------------------------------------- ;;; Class METHOD-COMBINATION (eval-when (:compile-toplevel :execute) (defparameter +method-combination-slots+ `((name :initarg :name :accessor method-combination-name) (compiler :initarg :compiler :accessor method-combination-compiler) (options :initarg :options :accessor method-combination-options)))) ;;; ---------------------------------------------------------------------- ;;; Class CLASS (eval-when (:compile-toplevel :execute) (defparameter +class-slots+ `(,@+specializer-slots+ (name :initarg :name :initform nil :accessor class-id) (direct-superclasses :initarg :direct-superclasses :accessor class-direct-superclasses) (direct-subclasses :initform nil :accessor class-direct-subclasses) (slots :accessor class-slots) (precedence-list :accessor class-precedence-list) (direct-slots :initarg :direct-slots :accessor class-direct-slots) (direct-default-initargs :initarg :direct-default-initargs :initform nil :accessor class-direct-default-initargs) (default-initargs :accessor class-default-initargs) (finalized :initform nil :accessor class-finalized-p) (docstring :initarg :documentation :initform nil) (size :accessor class-size) (sealedp :initarg :sealedp :initform nil :accessor class-sealedp) (prototype) (dependents :initform nil :accessor class-dependents) (valid-initargs :accessor class-valid-initargs) (slot-table :accessor slot-table) (location-table :initform nil :accessor class-location-table) )) (defconstant +class-name-ndx+ (position 'name +class-slots+ :key #'first)) (defconstant +class-precedence-list-ndx+ (position 'precedence-list +class-slots+ :key #'first))) ;;; ---------------------------------------------------------------------- ;;; STANDARD-CLASS (eval-when (:compile-toplevel :execute) (defparameter +standard-class-slots+ (append +class-slots+ '((optimize-slot-access) (forward))))) ;;; ---------------------------------------------------------------------- ;;; STRUCTURE-CLASS (eval-when (:compile-toplevel :execute) (defparameter +structure-class-slots+ (append +class-slots+ '((slot-descriptions) (initial-offset) (defstruct-form) (constructors) (documentation) (copier) (predicate) (print-function))))) ;;; ---------------------------------------------------------------------- ;;; STANDARD-GENERIC-FUNCTION (eval-when (:compile-toplevel :execute) (defparameter +standard-generic-function-slots+ '((name :initarg :name :initform nil :reader generic-function-name) (spec-list :initform nil :accessor generic-function-spec-list) (method-combination :initarg :method-combination :initform (find-method-combination (class-prototype (find-class 'standard-generic-function)) 'standard nil) :accessor generic-function-method-combination) (lambda-list :initarg :lambda-list :accessor generic-function-lambda-list) (argument-precedence-order :initarg :argument-precedence-order :initform nil :accessor generic-function-argument-precedence-order) (method-class :initarg :method-class :initform (find-class 'standard-method)) (docstring :initarg :documentation :initform nil) (methods :initform nil :accessor generic-function-methods) (a-p-o-function :initform nil :accessor generic-function-a-p-o-function) (declarations :initarg :declarations :initform nil :accessor generic-function-declarations) (dependents :initform nil :accessor generic-function-dependents)))) ;;; ---------------------------------------------------------------------- ;;; STANDARD-METHOD (eval-when (:compile-toplevel :execute) (defparameter +standard-method-slots+ '((the-generic-function :initarg :generic-function :initform nil :accessor method-generic-function) (lambda-list :initarg :lambda-list :accessor method-lambda-list) (specializers :initarg :specializers :accessor method-specializers) (qualifiers :initform nil :initarg :qualifiers :accessor method-qualifiers) (the-function :initarg :function :accessor method-function) (docstring :initarg :documentation :initform nil) (plist :initform nil :initarg :plist :accessor method-plist) (keywords :initform nil :accessor method-keywords))) (defparameter +standard-accessor-method-slots+ (append +standard-method-slots+ '((slot-definition :initarg :slot-definition :initform nil ;; FIXME! Should be a :reader :accessor accessor-method-slot-definition))))) ;;; ---------------------------------------------------------------------- ;;; SLOT-DEFINITION ;;; (eval-when (:compile-toplevel :load-toplevel :execute) (defconstant +slot-definition-slots+ '((name :initarg :name :initform nil :accessor slot-definition-name) (initform :initarg :initform :initform +initform-unsupplied+ :accessor slot-definition-initform) (initfunction :initarg :initfunction :initform nil :accessor slot-definition-initfunction) (declared-type :initarg :type :initform t :accessor slot-definition-type) (allocation :initarg :allocation :initform :instance :accessor slot-definition-allocation) (initargs :initarg :initargs :initform nil :accessor slot-definition-initargs) (readers :initarg :readers :initform nil :accessor slot-definition-readers) (writers :initarg :writers :initform nil :accessor slot-definition-writers) (docstring :initarg :documentation :initform nil :accessor slot-definition-documentation) (location :initarg :location :initform nil :accessor slot-definition-location) ))) ;;; ---------------------------------------------------------------------- (eval-when (:compile-toplevel :execute) ;; ;; All changes to this are connected to the changes in ;; the code of cl_class_of() in src/instance.d ;; (defconstant +builtin-classes-list+ '(;(t object) (sequence) (list sequence) (cons list) (array) (vector array sequence) (string vector) #+unicode (base-string string vector) (bit-vector vector) (stream) (ext:ansi-stream stream) (file-stream ext:ansi-stream) (echo-stream ext:ansi-stream) (string-stream ext:ansi-stream) (two-way-stream ext:ansi-stream) (synonym-stream ext:ansi-stream) (broadcast-stream ext:ansi-stream) (concatenated-stream ext:ansi-stream) (ext:sequence-stream ext:ansi-stream) (character) (number) (real number) (rational real) (integer rational) (fixnum integer) (bignum integer) (ratio rational) (float real) (single-float float) (double-float float) (complex number) (symbol) (null symbol list) (keyword symbol) (package) (function) (pathname) (logical-pathname pathname) (hash-table) (random-state) (readtable) (si::code-block) (si::foreign-data) (si::frame) (si::weak-pointer) #+threads (mp::process) #+threads (mp::lock) #+threads (mp::rwlock) #+threads (mp::condition-variable) #+threads (mp::semaphore) #+threads (mp::barrier) #+threads (mp::mailbox) #+sse2 (ext::sse-pack)))) ;;; FROM AMOP: ;;; ;;; Metaobject Class Direct Superclasses ;;; standard-object (t) ;;; funcallable-standard-object (standard-object function) ;;; * metaobject (standard-object) ;;; * generic-function (metaobject funcallable-standard-object) ;;; standard-generic-function (generic-function) ;;; * method (metaobject) ;;; standard-method (method) ;;; * standard-accessor-method (standard-method) ;;; standard-reader-method (standard-accessor-method) ;;; standard-writer-method (standard-accessor-method) ;;; * method-combination (metaobject) ;;; * slot-definition (metaobject) ;;; * direct-slot-definition (slot-definition) ;;; * effective-slot-definition (slot-definition) ;;; * standard-slot-definition (slot-definition) ;;; standard-direct-slot-definition (standard-slot-definition direct-slot-definition) ;;; standard-effective-slot-definition (standard-slot-definition effective-slot-definition) ;;; * specializer (metaobject) ;;; eql-specializer (specializer) ;;; * class (specializer) ;;; built-in-class (class) ;;; forward-referenced-class (class) ;;; standard-class (class) ;;; funcallable-standard-class (class) ;;; (eval-when (eval) (defconstant +class-hierarchy+ `((standard-class) (standard-effective-slot-definition) (standard-direct-slot-definition) (standard-class :metaclass nil ; Special-cased in boot.lsp :direct-slots #.+standard-class-slots+) (standard-direct-slot-definition :direct-slots #3=#.+slot-definition-slots+) (standard-effective-slot-definition :direct-slots #3#) (t :index 0) (standard-object :direct-superclasses (t)) (metaobject :direct-superclasses (standard-object)) (slot-definition :direct-superclasses (metaobject) :direct-slots #3#) (standard-slot-definition :direct-superclasses (slot-definition) :direct-slots #3#) (direct-slot-definition :direct-superclasses (slot-definition) :direct-slots #3#) (effective-slot-definition :direct-superclasses (slot-definition) :direct-slots #3#) (standard-direct-slot-definition :direct-superclasses (standard-slot-definition direct-slot-definition) :direct-slots #3#) (standard-effective-slot-definition :direct-superclasses (standard-slot-definition effective-slot-definition) :direct-slots #3#) (method-combination :direct-superclasses (metaobject) :direct-slots #.+method-combination-slots+) (specializer :direct-superclasses (metaobject) :direct-slots #.+specializer-slots+) (eql-specializer :direct-superclasses (specializer) :direct-slots #.+eql-specializer-slots+) (class :direct-superclasses (specializer) :direct-slots #.+class-slots+) (forward-referenced-class :direct-superclasses (class) :direct-slots #.+class-slots+) (built-in-class :direct-superclasses (class) :direct-slots #1=#.+standard-class-slots+) (std-class :direct-superclasses (class) :direct-slots #1#) (standard-class :direct-superclasses (std-class) :direct-slots #1# :metaclass standard-class) (funcallable-standard-class :direct-superclasses (std-class) :direct-slots #1#) ,@(loop for (name . rest) in +builtin-classes-list+ for index from 1 collect (list name :metaclass 'built-in-class :index index :direct-superclasses (or rest '(t)))) (funcallable-standard-object :direct-superclasses (standard-object function)) (generic-function :metaclass funcallable-standard-class :direct-superclasses (metaobject funcallable-standard-object)) (standard-generic-function :direct-superclasses (generic-function) :direct-slots #.+standard-generic-function-slots+ :metaclass funcallable-standard-class) (method :direct-superclasses (metaobject)) (standard-method :direct-superclasses (method) :direct-slots #.+standard-method-slots+) (standard-accessor-method :direct-superclasses (standard-method) :direct-slots #2=#.+standard-accessor-method-slots+) (standard-reader-method :direct-superclasses (standard-accessor-method) :direct-slots #2#) (standard-writer-method :direct-superclasses (standard-accessor-method) :direct-slots #2#) (standard-optimized-reader-method :direct-superclasses (standard-reader-method) :direct-slots #2#) (standard-optimized-writer-method :direct-superclasses (standard-writer-method) :direct-slots #2#) (structure-class :direct-superclasses (class) :direct-slots #.+structure-class-slots+) (structure-object :metaclass structure-class :direct-superclasses (t)) ))) ecl-16.1.2/src/clos/init.lsp000066400000000000000000000006771266352375300156040ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: CLOS -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; (load "../util/system") (load "defsys") (load "cmpinit") (setq compiler:*cc* (concatenate 'STRING compiler:*cc* " -I../h -I../../linux/h")) (rename-package 'clos 'old-clos) (setq si:*gc-verbose* nil) (sbt:build-system clos :compile :force) ;(setq *print-circle* t) ;(allocate 'cons 800 t) (quit) ecl-16.1.2/src/clos/inspect.lsp000066400000000000000000000427531266352375300163070ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: CLOS -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; Copyright (c) 1992, Giuseppe Attardi. ;;;; Copyright (c) 2001, Juan Jose Garcia Ripoll. ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. (in-package "CLOS") ;;; ---------------------------------------------------------------------- ;;; INTERACTIVE NAVIGATION THROUGH OBJECTS ;;; (defmethod select-clos-N ((instance standard-object)) (let* ((class (si:instance-class instance)) (local-slotds (class-local-slots class)) (class-slotds (class-class-slots class))) (if local-slotds (progn (si::inspect-indent) (format t "The local slots are:~%") (incf si::*inspect-level*) (dolist (slotd local-slotds) (si::inspect-indent-1) (format t "name : ~S" (clos::slot-definition-name slotd)) (if (slot-boundp instance (clos::slot-definition-name slotd)) (si::inspect-recursively "value:" (slot-value instance (clos::slot-definition-name slotd)) (slot-value instance (clos::slot-definition-name slotd))) (si::inspect-print "value: Unbound" nil (slot-value instance (clos::slot-definition-name slotd))))) (decf si::*inspect-level*)) (progn (si::inspect-indent) (format t "It has no local slots.~%"))) (if class-slotds (progn (si::inspect-indent) (format t "The class slots are:~%") (incf si::*inspect-level*) (dolist (slotd class-slotds) (si::inspect-indent-1) (format t "name : ~S" (clos::slot-definition-name slotd)) (if (slot-boundp instance (clos::slot-definition-name slotd)) (si::inspect-recursively "value:" (slot-value instance (clos::slot-definition-name slotd)) (slot-value instance (clos::slot-definition-name slotd))) (si::inspect-print "value: Unbound" nil (slot-value instance (clos::slot-definition-name slotd))))) (decf si::*inspect-level*)) (progn (si::inspect-indent) (format t "It has no class slots.~%"))))) (defun select-clos-N-inner-class (instance) (let* ((class (si:instance-class instance)) (local-slotds (class-local-slots class))) (if local-slotds (progn (si::inspect-indent) (format t "The (local) slots are:~%") (incf si::*inspect-level*) (dolist (slotd local-slotds) (si::inspect-indent-1) (format t "name : ~S" (clos::slot-definition-name slotd)) (if (slot-boundp instance (clos::slot-definition-name slotd)) (si::inspect-recursively "value:" (slot-value instance (clos::slot-definition-name slotd)) ; (slot-value instance (clos::slot-definition-name slotd)) ) (si::inspect-print "value: Unbound" nil ; (slot-value instance (clos::slot-definition-name slotd)) ))) (decf si::*inspect-level*)) (progn (si::inspect-indent) (format t "It has no (local) slots.~%"))))) (defmethod select-clos-N ((instance std-class)) (select-clos-N-inner-class instance)) (defmethod select-clos-N ((instance t)) (select-clos-N-inner-class instance)) (defmethod select-clos-L ((instance standard-object)) (let* ((class (si:instance-class instance)) (local-slotds (class-local-slots class)) (class-slotds (class-class-slots class))) (terpri) (if local-slotds (progn (format t "The names of the local slots are:~%") (dolist (slotd local-slotds) (format t " ~S~%" (clos::slot-definition-name slotd)))) (progn (format t "It has no local slots.~%"))) (terpri) (if class-slotds (progn (format t "The names of the class slots are:~%") (dolist (slotd class-slotds) (format t " ~S~%" (clos::slot-definition-name slotd)))) (progn (format t "It has no class slots.~%"))) (terpri))) (defun select-clos-L-inner-class (instance) (let* ((class (si:instance-class instance)) (local-slotds (class-local-slots class))) (terpri) (if local-slotds (progn (format t "The names of the (local) slots are:~%") (dolist (slotd local-slotds) (format t " ~S~%" (clos::slot-definition-name slotd)))) (progn (format t "It has no (local) slots.~%"))) (terpri))) (defmethod select-clos-L ((instance std-class)) (select-clos-L-inner-class instance)) (defmethod select-clos-L ((instance t)) (select-clos-L-inner-class instance)) (defmethod select-clos-J ((instance standard-object)) (let* ((class (si:instance-class instance)) (local-slotds (class-local-slots class)) (class-slotds (class-class-slots class)) (slotd (car (member (prog1 (read-preserving-whitespace *query-io*) (si::inspect-read-line)) (append local-slotds class-slotds) :key #'clos::slot-definition-name :test #'eq)))) (if slotd (progn (incf si::*inspect-level*) (si::inspect-indent-1) (format t "name : ~S" (clos::slot-definition-name slotd)) (if (slot-boundp instance (clos::slot-definition-name slotd)) (si::inspect-recursively "value:" (slot-value instance (clos::slot-definition-name slotd)) (slot-value instance (clos::slot-definition-name slotd))) (si::inspect-print "value: Unbound" nil (slot-value instance (clos::slot-definition-name slotd)))) (decf si::*inspect-level*)) (progn (terpri) (format t "~S is not a slot of the instance." (slot-definition-name slotd)) (terpri) (terpri))))) (defun select-clos-J-inner-class (instance) (let* ((class (si:instance-class instance)) (local-slotds (class-local-slots class)) (slotd (car (member (prog1 (read-preserving-whitespace *query-io*) (si::inspect-read-line)) local-slotds :key #'clos::slot-definition-name :test #'eq)))) (if slotd (progn (incf si::*inspect-level*) (si::inspect-indent-1) (format t "name : ~S" (clos::slot-definition-name slotd)) (if (slot-boundp instance (clos::slot-definition-name slotd)) (si::inspect-recursively "value:" (slot-value instance (clos::slot-definition-name slotd)) ; (slot-value instance (clos::slot-definition-name slotd)) ) (si::inspect-print "value: Unbound" nil ; (slot-value instance (clos::slot-definition-name slotd)) )) (decf si::*inspect-level*)) (progn (terpri) (format t "~S is not a slot of the instance." (slot-definition-name slotd)) (terpri) (terpri))))) (defmethod select-clos-J ((instance std-class)) (select-clos-J-inner-class instance)) (defmethod select-clos-J ((instance t)) (select-clos-J-inner-class instance)) (defun select-clos-? () (declare (si::c-local)) (terpri) (format t "Inspect commands for clos instances:~%~ n (or N or Newline): inspects all slots of the class (recursively).~%~ s (or S): skips the field.~%~ p (or P): pretty-prints the field.~%~ a (or A): aborts the inspection of the rest of the fields.~%~ e (or E) form: evaluates and prints the form.~%~ l (or L): show the names of all slots.~%~ j (or J) slot-name: inspect the slot with the name requested.~%~ q (or Q): quits the inspection.~%~ ?: prints this.~%~%" )) (defun class-local-slots (class) (remove :class (class-slots class) :key #'clos::slot-definition-allocation)) (defun class-class-slots (class) (remove :instance (class-slots class) :key #'clos::slot-definition-allocation)) (defmethod inspect-obj ((instance standard-object)) (unless (let ((metaclass (si:instance-class (si:instance-class instance)))) (or (eq metaclass (find-class 'STANDARD-CLASS)) (eq metaclass (find-class 'FUNCALLABLE-STANDARD-CLASS)))) (terpri) (format t "No applicable method CLOS::INSPECT-OBJ for an instance~%") (format t "of class ~S" (si:instance-class instance)) (throw 'SI::ABORT-INSPECT nil)) (decf si::*inspect-level*) (let* ((class (si:instance-class instance)) (local-slotds (class-local-slots class)) (class-slotds (class-class-slots class))) (declare (type class class)) (loop (format t "~S - clos object:" instance) (incf si::*inspect-level*) (si::inspect-indent) (format t "- it is an instance of class named ~S," (class-name class)) (si::inspect-indent) (format t "- it has ~A local slots and ~A class slots: " (length local-slotds) (length class-slotds)) (force-output) (case (do ((char (read-char *query-io*) (read-char *query-io*))) ((and (char/= char #\Space) (char/= #\Tab)) char)) ((#\Newline #\Return) (select-clos-N instance) (return nil)) ((#\n #\N) (si::inspect-read-line) (select-clos-N instance) (return nil)) ((#\s #\S) (si::inspect-read-line) (return nil)) ((#\p #\P) (si::inspect-read-line) (si::select-P instance)) ((#\a #\A) (si::inspect-read-line) (throw 'SI::ABORT-INSPECT nil)) ((#\e #\E) (si::select-E)) ((#\q #\Q) (si::inspect-read-line) (throw 'SI::QUIT-INSPECT nil)) ((#\l #\L) (si::inspect-read-line) (select-clos-L instance)) ((#\j #\J) (select-clos-J instance)) ((#\?) (si::inspect-read-line) (select-clos-?)) (t (si::inspect-read-line))) (decf si::*inspect-level*) (si::inspect-indent))) (incf si::*inspect-level*)) (defun inspect-obj-inner-class (instance) (decf si::*inspect-level*) (let* ((class (si:instance-class instance)) (local-slotds (class-local-slots class))) (declare (type class class)) (loop (format t "~S - clos object:" instance) (incf si::*inspect-level*) (si::inspect-indent) (format t "- it is an instance of class named ~S," (class-name class)) (si::inspect-indent) (format t "- it has ~A local slots: " (length local-slotds)) (force-output) (case (do ((char (read-char *query-io*) (read-char *query-io*))) ((and (char/= char #\Space) (char/= #\Tab)) char)) ((#\Newline #\Return) (select-clos-N instance) (return nil)) ((#\n #\N) (si::inspect-read-line) (select-clos-N instance) (return nil)) ((#\s #\S) (si::inspect-read-line) (return nil)) ((#\p #\P) (si::inspect-read-line) (si::select-P instance)) ((#\a #\A) (si::inspect-read-line) (throw 'SI::ABORT-INSPECT nil)) ((#\e #\E) (si::select-E)) ((#\q #\Q) (si::inspect-read-line) (throw 'SI::QUIT-INSPECT nil)) ((#\l #\L) (si::inspect-read-line) (select-clos-L instance)) ((#\j #\J) (select-clos-J instance)) ((#\?) (si::inspect-read-line) (select-clos-?)) (t (si::inspect-read-line))) (decf si::*inspect-level*) (si::inspect-indent))) (incf si::*inspect-level*)) (defmethod inspect-obj ((instance std-class)) (inspect-obj-inner-class instance)) (defmethod inspect-obj ((instance t)) (inspect-obj-inner-class instance)) ;;; ------------------------------------------------------------------------- ;;; ;;; Documentation ;;; (defconstant +valid-documentation-types+ '(compiler-macro function method-combination setf structure t type variable)) (defgeneric documentation (object doc-type)) (defgeneric (setf documentation) (new-value object doc-type)) (defmethod documentation ((object symbol) doc-type) (when (member doc-type +valid-documentation-types+) (case doc-type (type (let ((c (find-class object nil))) (if c (documentation c t) (si::get-documentation object doc-type)))) (function (or (si::get-documentation object doc-type) (and (fboundp object) (documentation (or (macro-function object) (fdefinition object)) doc-type)))) (otherwise (si::get-documentation object doc-type))))) (defmethod (setf documentation) (new-value (object symbol) doc-type) (when (member doc-type +valid-documentation-types+) (case doc-type (type (let ((c (find-class object nil))) (if c (progn (si::set-documentation object 'type nil) (si::set-documentation object 'structure nil) (setf (documentation c t) new-value)) (si::set-documentation object doc-type new-value)))) (function (if (fboundp object) (let ((c (or (macro-function object) (fdefinition object)))) (si::set-documentation c 'function nil) (setf (documentation c 'function) new-value)) (si::set-documentation object doc-type new-value))) (otherwise (si::set-documentation object doc-type new-value)))) new-value) (defmethod documentation ((object package) doc-type) (when (member doc-type '(t package)) (si::get-documentation object 'package))) (defmethod (setf documentation) (new-value (object package) doc-type) (when (member doc-type '(t package)) (si::set-documentation object 'package new-value))) (defmethod documentation ((object class) doc-type) (when (and (member doc-type '(t type)) (slot-boundp object 'docstring)) (slot-value object 'docstring))) (defmethod (setf documentation) (new-value (object class) doc-type) (when (member doc-type '(t type)) (setf (slot-value object 'docstring) new-value))) (defmethod documentation ((object structure-class) doc-type) (when (member doc-type '(t type)) (si::get-documentation (class-name object) 'structure))) (defmethod (setf documentation) (new-value (object structure-class) doc-type) (when (member doc-type '(t type)) (setf (documentation (class-name object) 'structure) new-value))) (defmethod documentation ((object list) doc-type) (when (member doc-type '(function compiler-macro)) (si::get-documentation object doc-type))) (defmethod (setf documentation) (new-value (object list) doc-type) (when (member doc-type '(function compiler-macro)) (si::set-documentation object doc-type new-value))) (defmethod documentation ((object standard-generic-function) doc-type) (when (member doc-type '(t function)) (slot-value object 'docstring))) (defmethod (setf documentation) (new-value (object standard-generic-function) doc-type) (when (member doc-type '(t function)) (setf (slot-value object 'docstring) new-value))) (defmethod documentation ((object standard-method) doc-type) (when (member doc-type '(t function)) (slot-value object 'docstring))) (defmethod (setf documentation) (new-value (object standard-method) doc-type) (when (member doc-type '(t function)) (setf (slot-value object 'docstring) new-value))) (defmethod documentation ((object function) doc-type) (when (member doc-type '(t function)) (si::get-documentation object doc-type))) (defmethod (setf documentation) (new-value (object function) doc-type) (when (member doc-type '(t function)) (si::set-documentation object doc-type new-value))) (defmethod documentation ((object slot-definition) doc-type) (when (member doc-type '(t function)) (slot-value object 'docstring))) (defmethod (setf documentation) (new-value (object slot-definition) doc-type) (when (member doc-type '(t function)) (setf (slot-value object 'docstring) new-value))) ecl-16.1.2/src/clos/kernel.lsp000066400000000000000000000431761266352375300161220ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: CLOS -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; Copyright (c) 1992, Giuseppe Attardi. ;;;; Copyright (c) 2001, Juan Jose Garcia Ripoll. ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. (in-package "CLOS") (defparameter *clos-booted* nil) ;;; ---------------------------------------------------------------------- ;;; ;;; FIND-CLASS naming classes. ;;; ;;; ;;; (FIND-CLASS ) returns the class named . setf can be used ;;; with find-class to set the class named . These are "extrinsic" ;;; names. Neither find-class nor setf of find-class do anything with the ;;; name slot of the class, they only lookup and change the association from ;;; name to class. ;;; ;;; This is only used during boot. The real one is in built-in. (eval-when (compile) (defun setf-find-class (new-value class &optional errorp env) (warn "Ignoring class definition for ~S" class))) (defun setf-find-class (new-value name &optional errorp env) (declare (ignore errorp env)) (let ((old-class (find-class name nil))) (cond ((and old-class (or (typep old-class 'built-in-class) (member name '(class built-in-class) :test #'eq))) (unless (eq new-value old-class) (error "The class associated to the CL specifier ~S cannot be changed." name))) ((classp new-value) (setf (gethash name si:*class-name-hash-table*) new-value)) ((null new-value) (remhash name si:*class-name-hash-table*)) (t (error "~A is not a class." new-value)))) new-value) (defsetf find-class (&rest x) (v) `(setf-find-class ,v ,@x)) (defun classp (obj) (and (si:instancep obj) (let ((topmost (find-class 'CLASS nil))) ;; All instances can be classes until the class CLASS has ;; been installed. Otherwise, we check the parents. ;(print (list (class-id (class-of obj))topmost (and topmost (class-precedence-list topmost)))) (or (null topmost) (si::subclassp (si::instance-class obj) topmost))) t)) ;;; ---------------------------------------------------------------------- ;;; Methods (defun install-method (name qualifiers specializers lambda-list fun wrap &rest options) (declare (notinline ensure-generic-function)) ; (record-definition 'method `(method ,name ,@qualifiers ,specializers)) (let* ((gf (ensure-generic-function name)) (fun (if wrap (wrapped-method-function fun) fun)) (specializers (mapcar #'(lambda (x) (cond ((consp x) (intern-eql-specializer (second x))) ((typep x 'specializer) x) ((find-class x nil)) (t (error "In method definition for ~A, found an invalid specializer ~A" name specializers)))) specializers)) (method (make-method (generic-function-method-class gf) qualifiers specializers lambda-list fun options))) (add-method gf method) method)) (defun wrapped-method-function (method-function) #'(lambda (.combined-method-args. *next-methods*) (declare (special .combined-method-args. *next-methods*)) (apply method-function .combined-method-args.))) ;;; ---------------------------------------------------------------------- ;;; early versions ;;; early version used during bootstrap (defun ensure-generic-function (name &key (lambda-list (si::unbound) l-l-p)) (if (and (fboundp name) (si::instancep (fdefinition name))) (fdefinition name) ;; create a fake standard-generic-function object: (with-early-make-instance +standard-generic-function-slots+ (gfun (find-class 'standard-generic-function) :name name :spec-list nil :method-combination (find-method-combination nil 'standard nil) :lambda-list lambda-list :argument-precedence-order (and l-l-p (rest (si::process-lambda-list lambda-list t))) :method-class (find-class 'standard-method) :docstring nil :methods nil :a-p-o-function nil :declarations nil :dependents nil) ;; create a new gfun (set-funcallable-instance-function gfun 'standard-generic-function) (setf (fdefinition name) gfun) gfun))) (defun (setf generic-function-name) (new-name gf) (if *clos-booted* (reinitialize-instance gf :name new-name) (setf (slot-value gf 'name) new-name))) (defun default-dispatch (generic-function) (cond ((null *clos-booted*) 'standard-generic-function) ((eq (class-id (class-of generic-function)) 'standard-generic-function) 'standard-generic-function) (t))) (defun compute-discriminating-function (generic-function) (values #'(lambda (&rest args) (multiple-value-bind (method-list ok) (compute-applicable-methods-using-classes generic-function (mapcar #'class-of args)) (unless ok (setf method-list (compute-applicable-methods generic-function args)) (unless method-list (apply #'no-applicable-method generic-function args))) (funcall (compute-effective-method-function generic-function (generic-function-method-combination generic-function) method-list) args nil))) t)) (defun set-generic-function-dispatch (gfun) ;; ;; We have to decide which discriminating function to install: ;; 1* One supplied by the user ;; 2* One coded in C that follows the MOP ;; 3* One in C specialized for slot accessors ;; 4* One in C that does not use generic versions of compute-applicable-... ;; Respectively ;; 1* The user supplies a discriminating function, or the number of arguments ;; is so large that they cannot be handled by the C dispatchers with ;; with memoization. ;; 2* The generic function is not a s-g-f but takes less than 64 arguments ;; 3* The generic function is a standard-generic-function and all its slots ;; are standard-{reader,writer}-slots ;; 4* The generic function is a standard-generic-function with less ;; than 64 arguments ;; ;; This chain of reasoning uses the fact that the user cannot override methods ;; such as COMPUTE-APPLICABLE-METHODS, or COMPUTE-EFFECTIVE-METHOD, or ;; COMPUTE-DISCRIMINATING-FUNCTION acting on STANDARD-GENERIC-FUNCTION. ;; (declare (notinline compute-discriminating-function)) (multiple-value-bind (default-function optimizable) ;; ;; If the class is not a standard-generic-function, we must honor whatever function ;; the user provides. However, we still recognize the case without user-computed ;; function, where we can replace the output of COMPUTE-DISCRIMINATING-FUNCTION with ;; a similar implementation in C (compute-discriminating-function gfun) (let ((methods (slot-value gfun 'methods))) (set-funcallable-instance-function gfun (cond ;; Case 1* ((or (not optimizable) (> (length (slot-value gfun 'spec-list)) si::c-arguments-limit)) default-function) ;; Case 2* ((and (not (eq (slot-value (class-of gfun) 'name) 'standard-generic-function)) *clos-booted*) t) ((null methods) 'standard-generic-function) ;; Cases 3* ((loop with class = (find-class 'standard-optimized-reader-method nil) for m in methods always (eq class (class-of m))) 'standard-optimized-reader-method) ((loop with class = (find-class 'standard-optimized-writer-method nil) for m in methods always (eq class (class-of m))) 'standard-optimized-writer-method) ;; Case 4* (t 'standard-generic-function)))))) ;;; ---------------------------------------------------------------------- ;;; COMPUTE-APPLICABLE-METHODS ;;; ;;; This part is a source of problems because we have to access slots of ;;; various objects, which could potentially lead to infinite recursion as ;;; those accessors require also some dispatch. The solution is to avoid ;;; calling then generic function that implement the accessors. ;;; This is possible because: ;;; 1. The user can only extend compute-applicable-methods if it ;;; defines a method with a subclass of standard-generic-function ;;; 2. The user cannot extend slot-value and friends on standard-classes ;;; due to the restriction "Any method defined by a portable program ;;; on a specified generic function must have at least one specializer ;;; that is neither a specified class nor an eql specializer whose ;;; associated value is an instance of a specified class." ;;; 3. Subclasses of specified classes preserve the slot order in ECL. ;;; (defun std-compute-applicable-methods (gf args) (sort-applicable-methods gf (applicable-method-list gf args) (mapcar #'class-of args))) (setf (fdefinition 'compute-applicable-methods) #'std-compute-applicable-methods) (defun applicable-method-list (gf args) (declare (optimize (speed 3)) (si::c-local)) (with-early-accessors (+standard-method-slots+ +standard-generic-function-slots+ +eql-specializer-slots+ +standard-class-slots+) (flet ((applicable-method-p (method args) (loop for spec in (method-specializers method) for arg in args always (if (eql-specializer-flag spec) (eql arg (eql-specializer-object spec)) (si::of-class-p arg spec))))) (loop for method in (generic-function-methods gf) when (applicable-method-p method args) collect method)))) (defun std-compute-applicable-methods-using-classes (gf classes) (declare (optimize (speed 3))) (with-early-accessors (+standard-method-slots+ +eql-specializer-slots+ +standard-generic-function-slots+) (flet ((applicable-method-p (method classes) (loop for spec in (method-specializers method) for class in classes always (cond ((eql-specializer-flag spec) ;; EQL specializer invalidate computation ;; we return NIL (when (si::of-class-p (eql-specializer-object spec) class) (return-from std-compute-applicable-methods-using-classes (values nil nil))) nil) ((si::subclassp class spec)))))) (values (sort-applicable-methods gf (loop for method in (generic-function-methods gf) when (applicable-method-p method classes) collect method) classes) t)))) (defun sort-applicable-methods (gf applicable-list args-specializers) (declare (optimize (safety 0) (speed 3))) (with-early-accessors (+standard-method-slots+ +standard-generic-function-slots+) (let ((f (generic-function-a-p-o-function gf))) ;; reorder args to match the precedence order (when f (setf args-specializers (funcall f (subseq args-specializers 0 (length (generic-function-argument-precedence-order gf)))))) ;; then order the list (do* ((scan applicable-list) (most-specific (first scan) (first scan)) (ordered-list)) ((null (cdr scan)) (when most-specific ;; at least one method (nreverse (push most-specific ordered-list)))) (dolist (meth (cdr scan)) (when (eq (compare-methods most-specific meth args-specializers f) 2) (setq most-specific meth))) (setq scan (delete most-specific scan)) (push most-specific ordered-list))))) (defun compare-methods (method-1 method-2 args-specializers f) (declare (si::c-local)) (with-early-accessors (+standard-method-slots+) (let* ((specializers-list-1 (method-specializers method-1)) (specializers-list-2 (method-specializers method-2))) (compare-specializers-lists (if f (funcall f specializers-list-1) specializers-list-1) (if f (funcall f specializers-list-2) specializers-list-2) args-specializers)))) (defun compare-specializers-lists (spec-list-1 spec-list-2 args-specializers) (declare (si::c-local)) (when (or spec-list-1 spec-list-2) (ecase (compare-specializers (first spec-list-1) (first spec-list-2) (first args-specializers)) (1 '1) (2 '2) (= (compare-specializers-lists (cdr spec-list-1) (cdr spec-list-2) (cdr args-specializers))) ((nil) (error "The type specifiers ~S and ~S can not be disambiguated~ with respect to the argument specializer: ~S" (or (car spec-list-1) t) (or (car spec-list-2) t) (car args-specializers))))) ) (defun fast-subtypep (spec1 spec2) (declare (si::c-local)) ;; Specialized version of subtypep which uses the fact that spec1 ;; and spec2 are either classes or of the form (EQL x) (with-early-accessors (+eql-specializer-slots+ +standard-class-slots+) (if (eql-specializer-flag spec1) (if (eql-specializer-flag spec2) (eql (eql-specializer-object spec1) (eql-specializer-object spec2)) (si::of-class-p (eql-specializer-object spec1) spec2)) (if (eql-specializer-flag spec2) ;; There is only one class with a single element, which ;; is NULL = (MEMBER NIL). (and (null (eql-specializer-object spec2)) (eq (class-name spec1) 'null)) (si::subclassp spec1 spec2))))) (defun compare-specializers (spec-1 spec-2 arg-class) (declare (si::c-local)) (with-early-accessors (+standard-class-slots+ +standard-class-slots+) (let* ((cpl (class-precedence-list arg-class))) (cond ((eq spec-1 spec-2) '=) ((fast-subtypep spec-1 spec-2) '1) ((fast-subtypep spec-2 spec-1) '2) ((eql-specializer-flag spec-1) '1) ; is this engough? ((eql-specializer-flag spec-2) '2) ; Beppe ((member spec-1 (member spec-2 cpl)) '2) ((member spec-2 (member spec-1 cpl)) '1) ;; This will force an error in the caller (t nil))))) (defun compute-g-f-spec-list (gf) (with-early-accessors (+standard-generic-function-slots+ +eql-specializer-slots+ +standard-method-slots+) (flet ((nupdate-spec-how-list (spec-how-list specializers gf) ;; update the spec-how of the gfun ;; computing the or of the previous value and the new one (setf spec-how-list (or spec-how-list (copy-list specializers))) (do* ((l specializers (cdr l)) (l2 spec-how-list (cdr l2)) (spec-how) (spec-how-old)) ((null l)) (setq spec-how (first l) spec-how-old (first l2)) (setf (first l2) (if (eql-specializer-flag spec-how) (list* (eql-specializer-object spec-how) (and (consp spec-how-old) spec-how-old)) (if (consp spec-how-old) spec-how-old spec-how)))) spec-how-list)) (let* ((spec-how-list nil) (function nil) (a-p-o (generic-function-argument-precedence-order gf))) (dolist (method (generic-function-methods gf)) (setf spec-how-list (nupdate-spec-how-list spec-how-list (method-specializers method) gf))) (setf (generic-function-spec-list gf) (loop for type in spec-how-list for i from 0 when type collect (cons type i))) (let* ((g-f-l-l (generic-function-lambda-list gf))) (when (consp g-f-l-l) (let ((required-arguments (rest (si::process-lambda-list g-f-l-l t)))) (unless (equal a-p-o required-arguments) (setf function (coerce `(lambda (%list) (destructuring-bind ,required-arguments %list (list ,@a-p-o))) 'function)))))) (setf (generic-function-a-p-o-function gf) function) (si:clear-gfun-hash gf))))) (defun print-object (object stream) (print-unreadable-object (object stream))) ecl-16.1.2/src/clos/load.lsp.in000066400000000000000000000025461266352375300161620ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;; @configure_input@ (defvar +clos-module-files+ '("src:clos;package.lsp" "src:clos;cpl.lsp" "src:clos;std-slot-value.lsp" "src:clos;slot.lsp" "src:clos;boot.lsp" "src:clos;kernel.lsp" "src:clos;method.lsp" "src:clos;combin.lsp" "src:clos;std-accessors.lsp" "src:clos;defclass.lsp" "src:clos;slotvalue.lsp" "src:clos;standard.lsp" "src:clos;builtin.lsp" "src:clos;change.lsp" "src:clos;stdmethod.lsp" "src:clos;generic.lsp" "src:clos;fixup.lsp" "src:clos;conditions.lsp" "src:clos;print.lsp" #+clos-streams "src:clos;streams.lsp" #+cmu-format "src:lsp;pprint.lsp" "src:lsp;describe.lsp" ; Depends on conditions.lsp "src:clos;inspect.lsp" ; Depends on describe.lsp "src:lsp;top.lsp" ; Depends on conditions.lsp "src:lsp;process.lsp" ; Depends on defclass #+unicode "src:lsp;unicode.lsp" ; Depends on conditions.lsp "ext:bytecmp;bytecmp.lsp" "ext:ecl-cdb;ecl-cdb.lisp" ; Needed for DOCUMENTATION "ext:ecl-cdb;ecl-help.lisp" "src:clos;walk.lsp" )) (mapc #'(lambda (x) (terpri) (princ ";;; Loading ") (princ x) (load x :verbose nil)) +clos-module-files+) (setf +clos-module-files+ (remove "src:clos;macros.lsp" +clos-module-files+ :test #'equalp)) ecl-16.1.2/src/clos/macros.lsp000066400000000000000000000023701266352375300161150ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: CLOS -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; Copyright (c) 1992, Giuseppe Attardi. ;;;; Copyright (c) 2001, Juan Jose Garcia Ripoll. ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. (in-package "CLOS") (defmacro mapappend (fun &rest args) `(reduce #'append (mapcar ,fun ,@args))) (defmacro ensure-up-to-date-instance (instance) ;; The up-to-date status of a class is determined by ;; instance.sig. This slot of the C structure contains a list of ;; slot definitions that was used to create the instance. When the ;; class is updated, the list is newly created. Structures are also ;; "instances" but keep ECL_UNBOUND instead of the list. `(let* ((i ,instance) (s (si::instance-sig i))) (declare (:read-only i s)) (when (si:sl-boundp s) (unless (eq s (class-slots (si::instance-class i))) (update-instance i))))) ecl-16.1.2/src/clos/method.lsp000066400000000000000000000502751266352375300161200ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: CLOS -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; Copyright (c) 1992, Giuseppe Attardi. ;;;; Copyright (c) 2001, Juan Jose Garcia Ripoll. ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. (in-package "CLOS") ;;; ---------------------------------------------------------------------- (defparameter *method-size* 32) ; Size of methods hash tables ;;; This holds fake methods created during bootstrap. ;;; It is an alist of: ;;; (method-name {method}+) (defparameter *early-methods* nil) ;;; ;;; This is used by combined methods to communicate the next methods to ;;; the methods they call. ;;; (defparameter *next-methods* nil) ;;; Add type declarations for the arguments of a METHOD. This implies ;;; copying the method arguments because the arguments may be modified. (defparameter *add-method-argument-declarations* nil) ;;; ---------------------------------------------------------------------- ;;; DEFMETHOD ;;; (defun generic-function-method-class (generic-function) (if *clos-booted* (slot-value generic-function 'method-class) (find-class 'standard-method))) (defmacro defmethod (&whole whole name &rest args &environment env) (declare (notinline make-method-lambda)) (let* ((*print-length* 3) (*print-depth* 2) (qualifiers (loop while (and args (not (listp (first args)))) collect (pop args))) (specialized-lambda-list (if args (pop args) (error "Illegal defmethod form: missing lambda list"))) (body args)) (multiple-value-bind (lambda-list required-parameters specializers) (parse-specialized-lambda-list specialized-lambda-list) (multiple-value-bind (lambda-form declarations documentation) (make-raw-lambda name lambda-list required-parameters specializers body env) (let* ((generic-function (ensure-generic-function name)) (method-class (generic-function-method-class generic-function)) method) (when *clos-booted* (when (symbolp method-class) (setf method-class (find-class method-class nil))) (if method-class (setf method (class-prototype method-class)) (error "Cannot determine the method class for generic functions of type ~A" (type-of generic-function)))) (multiple-value-bind (fn-form options) (make-method-lambda generic-function method lambda-form env) (when documentation (setf options (list* :documentation documentation options))) (multiple-value-bind (wrapped-lambda wrapped-p) (simplify-lambda name fn-form) (unless wrapped-p (error "Unable to unwrap function")) (ext:register-with-pde whole `(install-method ',name ',qualifiers ,(specializers-expression specializers) ',lambda-list ,(maybe-remove-block wrapped-lambda) ,wrapped-p ,@(mapcar #'si::maybe-quote options)))))))))) (defun specializers-expression (specializers) (declare (si::c-local)) ;; The list of specializers contains either types or (EQL value) ;; expressions. The 'value' has to be obtained by evaluating a lisp form ;; We save some space/time by including directly the value of those ;; forms which do not involve any evaluations, such as literals or QUOTE ;; expressions. Note that we cannot use CONSTANTP because this would extract ;; the value of constant symbols, which would not be EQL to the value of ;; those same constants when the code is reloaded. (list 'si::quasiquote (loop for spec in specializers collect (if (atom spec) spec `(eql ,(let ((value (second spec))) (if (if (atom value) (not (symbolp value)) (eq (car value) 'quote)) (ext:constant-form-value value) (list 'si::unquote value)))))))) (defun maybe-remove-block (method-lambda) (when (eq (first method-lambda) 'lambda) (multiple-value-bind (declarations body documentation) (si::find-declarations (cddr method-lambda)) (let (block) (when (and (null (rest body)) (listp (setf block (first body))) (eq (first block) 'block)) (setf method-lambda `(ext:lambda-block ,(second block) ,(second method-lambda) ,@declarations ,@(cddr block))) )))) method-lambda) (defun simplify-lambda (method-name fn-form) (let ((aux fn-form)) (if (and (eq (pop aux) 'lambda) (equalp (pop aux) '(.combined-method-args. *next-methods*)) (equalp (pop aux) '(declare (special .combined-method-args. *next-methods*))) (null (rest aux)) (= (length (setf aux (first aux))) 3) (eq (first aux) 'apply) (eq (third aux) '.combined-method-args.) (listp (setf aux (second aux))) (eq (first aux) 'lambda)) (values aux t) (values fn-form nil)))) (defun make-raw-lambda (name lambda-list required-parameters specializers body env) (declare (si::c-local) (ignore env)) (multiple-value-bind (declarations real-body documentation) (sys::find-declarations body) ;; FIXME!! This deactivates the checking of keyword arguments ;; inside methods. The reason is that this checking must be ;; supplemented the knowledge of the keyword arguments of all ;; applicable methods (X3J13 7.6.5). Therefore, we should insert ;; that check, either in the method itself so that it is done ;; incrementally, or in COMPUTE-EFFECTIVE-METHOD. (when (and (member '&key lambda-list) (not (member '&allow-other-keys lambda-list))) (let ((x (position '&aux lambda-list))) (setf lambda-list (append (subseq lambda-list 0 x) '(&allow-other-keys) (and x (subseq lambda-list x)) nil)))) (let* ((copied-variables '()) (ignorable `(declare (ignorable ,@required-parameters))) (class-declarations (nconc (when *add-method-argument-declarations* (loop for name in required-parameters for type in specializers when (and (not (eq type t)) (symbolp type)) do (push `(,name ,name) copied-variables) and nconc `((type ,type ,name) (si::no-check-type ,name)))) (list (list 'si::function-block-name name)) (cdar declarations))) (block `(block ,(si::function-block-name name) ,@real-body)) (method-lambda ;; Remove the documentation string and insert the ;; appropriate class declarations. The documentation ;; string is removed to make it easy for us to insert ;; new declarations later, they will just go after the ;; second of the method lambda. The class declarations ;; are inserted to communicate the class of the method's ;; arguments to the code walk. `(lambda ,lambda-list ,@(and class-declarations `((declare ,@class-declarations))) ,ignorable ,(if copied-variables `(let* ,copied-variables ,ignorable ,block) block)))) (values method-lambda declarations documentation)))) (defun make-method-lambda (gf method method-lambda env) (multiple-value-bind (call-next-method-p next-method-p-p in-closure-p) (walk-method-lambda method-lambda env) (values `(lambda (.combined-method-args. *next-methods*) (declare (special .combined-method-args. *next-methods*)) (apply ,(if in-closure-p (add-call-next-method-closure method-lambda) method-lambda) .combined-method-args.)) nil))) (defun add-call-next-method-closure (method-lambda) (multiple-value-bind (declarations real-body documentation) (si::find-declarations (cddr method-lambda)) `(lambda ,(second method-lambda) (let* ((.closed-combined-method-args. (if (listp .combined-method-args.) .combined-method-args. (apply #'list .combined-method-args.))) (.next-methods. *next-methods*)) (flet ((call-next-method (&rest args) (unless .next-methods. (error "No next method")) (funcall (car .next-methods.) (or args .closed-combined-method-args.) (rest .next-methods.))) (next-method-p () .next-methods.)) ,@real-body))))) (defun environment-contains-closure (env) ;; ;; As explained in compiler.d (make_lambda()), we use a symbol with ;; name "FUNCTION-BOUNDARY" to mark the beginning of a function. If ;; we find that symbol twice, it is quite likely that this form will ;; end up in a closure. ;; (let ((counter 0)) (declare (fixnum counter)) (dolist (item (car env)) (when (and (consp item) (eq (first (the cons item)) 'si::function-boundary) (> (incf counter) 1)) (return t))))) (defun walk-method-lambda (method-lambda env) (declare (si::c-local)) (let ((call-next-method-p nil) (next-method-p-p nil) (in-closure-p nil)) (flet ((code-walker (form env) (unless (atom form) (let ((name (first form))) (case name (CALL-NEXT-METHOD (setf call-next-method-p (or call-next-method-p T) in-closure-p (or in-closure-p (environment-contains-closure env)))) (NEXT-METHOD-P (setf next-method-p-p t in-closure-p (or in-closure-p (environment-contains-closure env)))) (FUNCTION (when (eq (second form) 'CALL-NEXT-METHOD) (setf in-closure-p t call-next-method-p 'FUNCTION)) (when (eq (second form) 'NEXT-METHOD-P) (setf next-method-p-p 'FUNCTION in-closure-p t)))))) form)) (let ((si::*code-walker* #'code-walker)) ;; Instead of (coerce method-lambda 'function) we use ;; explicitely the bytecodes compiler with an environment, no ;; stepping, compiler-env-p = t and execute = nil, so that the ;; form does not get executed. (si::eval-with-env method-lambda env nil t t))) (values call-next-method-p next-method-p-p in-closure-p))) ;;; ---------------------------------------------------------------------- ;;; parsing (defun legal-generic-function-name-p (name) (si::valid-function-name-p name)) (defun parse-defmethod (args) (declare (si::c-local)) ;; This function has to extract the name of the method, a list of ;; possible qualifiers (identified by not being lists), the lambda ;; list of the method (which might be empty!) and the body of the ;; function. (let* (name) (unless args (error "Illegal defmethod form: missing method name")) (setq name (pop args)) (unless (legal-generic-function-name-p name) (error "~A cannot be a generic function specifier.~%~ It must be either a non-nil symbol or ~%~ a list whose car is setf and whose second is a non-nil symbol." name)) (do ((qualifiers '())) ((progn (when (endp args) (error "Illegal defmethod form: missing lambda-list")) (listp (first args))) (values name (nreverse qualifiers) (first args) (rest args))) (push (pop args) qualifiers)))) (defun implicit-generic-lambda (lambda-list) "Implicit defgeneric declaration removes all &key arguments (preserving &key)" (when lambda-list (let (acc) (do* ((ll lambda-list (cdr ll)) (elt (car ll) (car ll))) ((or (endp (rest ll)) (eql elt '&key)) (nreverse (cons elt acc))) (push elt acc))))) (defun extract-lambda-list (specialized-lambda-list) (values (parse-specialized-lambda-list specialized-lambda-list))) (defun extract-specializer-names (specialized-lambda-list) (nth-value 2 (parse-specialized-lambda-list specialized-lambda-list))) (defun parse-specialized-lambda-list (specialized-lambda-list) "This function takes a method lambda list and outputs the list of required arguments, the list of specializers and a new lambda list where the specializer have disappeared." (declare (si::c-local)) ;; SI:PROCESS-LAMBDA-LIST will ensure that the lambda list is ;; syntactically correct and will output as a first argument the ;; list of required arguments. We use this list to extract the ;; specializers and build a lambda list without specializers. (do* ((arglist (rest (si::process-lambda-list specialized-lambda-list 'METHOD)) (rest arglist)) (lambda-list (copy-list specialized-lambda-list)) (ll lambda-list (rest ll)) (required-parameters '()) (specializers '()) arg variable specializer) ((null arglist) (values lambda-list (nreverse required-parameters) (nreverse specializers))) (setf arg (first arglist)) (cond ;; Just a variable ((atom arg) (setf variable arg specializer T)) ;; List contains more elements than variable and specializer ((not (endp (cddr arg))) (si::simple-program-error "Syntax error in method specializer ~A" arg)) ;; Specializer is NIL ((null (setf variable (first arg) specializer (second arg))) (si::simple-program-error "NIL is not a valid specializer in a method lambda list")) ;; Specializer is a class name ((atom specializer)) ;; Specializer is (EQL value) ((and (eql (first specializer) 'EQL) (cdr specializer) (endp (cddr specializer)))) ;; Otherwise, syntax error (t (si::simple-program-error "Syntax error in method specializer ~A" arg))) (setf (first ll) variable) (push variable required-parameters) (push specializer specializers))) (defun declaration-specializers (arglist declarations) (declare (si::c-local)) (do ((argscan arglist (cdr argscan)) (declist (when declarations (cdr declarations)))) ((or (null argscan) (member (first argscan) '(&OPTIONAL &REST &KEY &ALLOW-OTHER-KEYS &AUX))) `(DECLARE ,@declist)) (when (listp (first argscan)) (push `(TYPE ,(cadar argscan) ,(caar argscan)) declist)))) ;;; ---------------------------------------------------------------------- ;;; operations (defun compute-method-keywords (lambda-list) (multiple-value-bind (reqs opts rest key-flag keywords allow-other-keys) (si::process-lambda-list lambda-list t) (declare (ignore reqs opts rest key-flag)) (if allow-other-keys 't (loop for k in (rest keywords) by #'cddddr collect k)))) (defun make-method (method-class qualifiers specializers lambda-list fun options) (declare (ignore options)) (with-early-make-instance ;; We choose the largest list of slots +standard-accessor-method-slots+ (method (if (si::instancep method-class) method-class (find-class method-class)) :generic-function nil :lambda-list lambda-list :function fun :specializers specializers :qualifiers qualifiers :keywords (compute-method-keywords lambda-list)) method)) ;;; early version used during bootstrap (defun method-p (x) (si::instancep x)) ;;; early version used during bootstrap (defun add-method (gf method) (with-early-accessors (+standard-method-slots+ +standard-generic-function-slots+ +standard-class-slots+) (let* ((name (slot-value gf 'name)) (method-entry (assoc name *early-methods*))) (unless method-entry (setq method-entry (list name)) (push method-entry *early-methods*)) (push method (cdr method-entry)) (push method (generic-function-methods gf)) (setf (method-generic-function method) gf) (unless (si::sl-boundp (generic-function-lambda-list gf)) (setf (generic-function-lambda-list gf) (implicit-generic-lambda (method-lambda-list method))) (setf (generic-function-argument-precedence-order gf) (rest (si::process-lambda-list (method-lambda-list method) t)))) (compute-g-f-spec-list gf) (set-generic-function-dispatch gf) method))) (defun find-method (gf qualifiers specializers &optional (errorp t)) (declare (notinline method-qualifiers)) (flet ((filter-specializer (name) (cond ((typep name 'specializer) name) ((atom name) (let ((class (find-class name nil))) (unless class (error "~A is not a valid specializer name" name)) class)) ((and (eq (first name) 'EQL) (null (cddr name))) (cdr name)) (t (error "~A is not a valid specializer name" name)))) (specializer= (cons-or-class specializer) (if (consp cons-or-class) (and (eql-specializer-flag specializer) (eql (car cons-or-class) (eql-specializer-object specializer))) (eq cons-or-class specializer)))) (when (/= (length specializers) (length (generic-function-argument-precedence-order gf))) (error "The specializers list~%~A~%does not match the number of required arguments in ~A" specializers (generic-function-name gf))) (loop with specializers = (mapcar #'filter-specializer specializers) for method in (generic-function-methods gf) when (and (equal qualifiers (method-qualifiers method)) (every #'specializer= specializers (method-specializers method))) do (return-from find-method method)) ;; If we did not find any matching method, then the list of ;; specializers might have the wrong size and we must signal ;; an error. (when errorp (error "There is no method on the generic function ~S that agrees on qualifiers ~S and specializers ~S" (generic-function-name gf) qualifiers specializers))) nil) ;;; ---------------------------------------------------------------------- ;;; with-accessors (defmacro with-accessors (slot-accessor-pairs instance-form &body body) (let* ((temp (gensym)) (accessors (do ((scan slot-accessor-pairs (cdr scan)) (res)) ((null scan) (nreverse res)) (push `(,(caar scan) (,(cadar scan) ,temp)) res)))) `(let ((,temp ,instance-form)) (symbol-macrolet ,accessors ,@body)))) ;;; Force the compiler into optimizing use of gethash inside methods: (setf (symbol-function 'SLOT-INDEX) (symbol-function 'GETHASH)) ecl-16.1.2/src/clos/package.lsp000066400000000000000000000013451266352375300162250ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: CLOS -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; Copyright (c) 1992, Giuseppe Attardi. ;;;; Copyright (c) 2001, Juan Jose Garcia Ripoll. ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. (defpackage "CLOS" (:use "CL" "EXT") (:import-from "SI" "UNBOUND" "GET-SYSPROP" "PUT-SYSPROP" "REM-SYSPROP" "SIMPLE-PROGRAM-ERROR")) ecl-16.1.2/src/clos/print.lsp000066400000000000000000000302631266352375300157670ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: CLOS -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; Copyright (c) 1992, Giuseppe Attardi. ;;;; Copyright (c) 2001, Juan Jose Garcia Ripoll. ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. (in-package "CLOS") ;;; ---------------------------------------------------------------------- ;;; Load forms ;;; ;;; ECL extends the ANSI specification by allowing to use ;;; MAKE-LOAD-FORM on almost any kind of lisp object. ;;; (defun make-load-form-saving-slots (object &key slot-names environment) (declare (ignore environment)) (do* ((class (class-of object)) (initialization (list 'progn)) (slots (class-slots class) (cdr slots))) ((endp slots) (values `(allocate-instance ,class) (nreverse initialization))) (let* ((slot (first slots)) (slot-name (slot-definition-name slot))) (when (or (and (null slot-names) (eq (slot-definition-allocation slot) :instance)) (member slot-name slot-names)) (push (if (slot-boundp object slot-name) `(setf (slot-value ,object ',slot-name) ',(slot-value object slot-name)) `(slot-makunbound ,object ',slot-name)) initialization))))) (defun need-to-make-load-form-p (object env) "Return T if the object cannot be externalized using the lisp printer and we should rather use MAKE-LOAD-FORM." (declare (ignore env)) (let ((*load-form-cache* nil)) (declare (special *load-form-cache*)) (labels ((recursive-test (object) (loop ;; For simple, atomic objects we just return NIL. There is no need to ;; call MAKE-LOAD-FORM on them (when (typep object '(or character number symbol pathname string bit-vector)) (return nil)) ;; For complex objects we set up a cache and run through the ;; objects content looking for data that might require ;; MAKE-LOAD-FORM to be externalized. The cache is used to ;; solve the problem of circularity and of EQ references. (unless *load-form-cache* (setf *load-form-cache* (make-hash-table :size 128 :test #'eq))) (when (gethash object *load-form-cache*) (return nil)) (setf (gethash object *load-form-cache*) t) (cond ((arrayp object) (unless (subtypep (array-element-type object) '(or character number)) (dotimes (i (array-total-size object)) (recursive-test (row-major-aref object i)))) (return nil)) ((consp object) (recursive-test (car object)) (setf object (rest object))) ((compiled-function-p object) (multiple-value-bind (lex code data name) (si::bc-split object) (when (or (null data) (null code) (recursive-test lex) (recursive-test code) (recursive-test name)) (throw 'need-to-make-load-form t)) (setf object data))) (t (throw 'need-to-make-load-form t)))))) (catch 'need-to-make-load-form (recursive-test object) nil)))) (defmethod make-load-form ((object t) &optional env) (flet ((maybe-quote (object) (if (or (consp object) (symbolp object)) (list 'quote object) object))) (unless (need-to-make-load-form-p object env) (return-from make-load-form (maybe-quote object))) (typecase object (compiled-function (multiple-value-bind (lex code data name) (si::bc-split object) (unless code (error "Cannot externalize object ~a" object)) (values `(si::bc-join ,(make-load-form lex env) ',code ; An specialized array, no load form ,(make-load-form data env) ,(make-load-form name env))))) (array (let ((init-forms '())) (values `(make-array ',(array-dimensions object) :element-type ',(array-element-type object) :adjustable ',(adjustable-array-p object) :initial-contents ',(loop for i from 0 below (array-total-size object) collect (let ((x (row-major-aref object i))) (if (need-to-make-load-form-p x env) (progn (push `(setf (row-major-aref ,object ,i) ',x) init-forms) 0) x)))) (and init-forms `(progn ,@init-forms))))) (cons (values `(cons ,(maybe-quote (car object)) nil) (and (rest object) `(rplacd ,(maybe-quote object) ,(maybe-quote (cdr object)))))) (hash-table (let* ((content (ext:hash-table-content object)) (make-form `(make-hash-table :size ,(hash-table-size object) :rehash-size ,(hash-table-rehash-size object) :rehash-threshold ,(hash-table-rehash-threshold object) :test ',(hash-table-test object)))) (if (need-to-make-load-form-p content env) (values make-form `(dolist (i ',(loop for key being each hash-key in object using (hash-value obj) collect (cons key obj))) (setf (gethash (car i) ,object) (cdr i)))) (values `(ext:hash-table-fill ,make-form ',content) nil)))) (t (no-make-load-form object))))) (defmethod make-load-form ((object standard-object) &optional environment) (no-make-load-form object)) (defmethod make-load-form ((object structure-object) &optional environment) (no-make-load-form object)) (defmethod make-load-form ((object condition) &optional environment) (no-make-load-form object)) (defun no-make-load-form (object) (declare (si::c-local)) (error "No adequate specialization of MAKE-LOAD-FORM for an object of type" (type-of object))) (defmethod make-load-form ((class class) &optional environment) (declare (ignore environment)) (let ((name (class-name class))) (if (and name (eq (find-class name) class)) `(find-class ',name) (error "Cannot externalize anonymous class ~A" class)))) (defmethod make-load-form ((package package) &optional environment) (declare (ignore environment)) `(find-package ,(package-name package))) ;;; ---------------------------------------------------------------------- ;;; Printing ;;; ---------------------------------------------------------------------- (defmethod print-object ((instance t) stream) (if (typep instance 'standard-object) (let ((*package* (find-package "CL"))) (print-unreadable-object (instance stream) (format stream "~S" (class-name (si:instance-class instance))))) (write instance :stream stream)) instance) (defmethod print-object ((instance standard-object) stream) (print-unreadable-object (instance stream) (let ((*package* (find-package "CL"))) (format stream "a ~S" (class-name (si:instance-class instance))))) instance) (defmethod print-object ((class class) stream) (print-unreadable-object (class stream) (let ((*package* (find-package "CL"))) (format stream "The ~S ~S" (class-name (si:instance-class class)) (class-name class)))) class) (defmethod print-object ((gf standard-generic-function) stream) (print-unreadable-object (gf stream :type t) (prin1 (generic-function-name gf) stream)) gf) (defmethod print-object ((m standard-method) stream) (print-unreadable-object (m stream :type t) (format stream "~A ~A" (let ((gf (method-generic-function m))) (if gf (generic-function-name gf) 'UNNAMED)) (method-specializers m))) m) (defun ext::float-nan-string (x) (when *print-readably* (error 'print-not-readable :object x)) (cdr (assoc (type-of x) '((single-float . "#") (double-float . "#") (long-float . "#") (short-float . "#"))))) (defun ext::float-infinity-string (x) (when (and *print-readably* (null *read-eval*)) (error 'print-not-readable :object x)) (let* ((negative-infinities '((single-float . "#.ext::single-float-negative-infinity") (double-float . "#.ext::double-float-negative-infinity") (long-float . "#.ext::long-float-negative-infinity") (short-float . "#.ext::short-float-negative-infinity"))) (positive-infinities '((single-float . "#.ext::single-float-positive-infinity") (double-float . "#.ext::double-float-positive-infinity") (long-float . "#.ext::long-float-positive-infinity") (short-float . "#.ext::short-float-positive-infinity"))) (record (assoc (type-of x) (if (plusp x) positive-infinities negative-infinities)))) (unless record (error "Not an infinity")) (cdr record))) ;;; ---------------------------------------------------------------------- ;;; Describe ;;; ---------------------------------------------------------------------- (defmethod describe-object ((obj t) (stream t)) (let* ((class (class-of obj)) (slotds (class-slots class))) (format stream "~%~A is an instance of class ~A" obj (class-name class)) (do ((scan slotds (cdr scan)) (i 0 (1+ i)) (sv)) ((null scan)) (declare (fixnum i)) (setq sv (si:instance-ref obj i)) (print (slot-definition-name (car scan)) stream) (princ ": " stream) (if (si:sl-boundp sv) (prin1 sv stream) (prin1 "Unbound" stream)))) obj) (defmethod describe-object ((obj class) (stream t)) (let* ((class (si:instance-class obj)) (slotds (class-slots class))) (format stream "~%~A is an instance of class ~A" obj (class-name class)) (do ((scan slotds (cdr scan)) (i 0 (1+ i)) (sv)) ((null scan)) (declare (fixnum i)) (print (slot-definition-name (car scan)) stream) (princ ": " stream) (case (slot-definition-name (car scan)) ((superiors inferiors) (princ "(" stream) (do* ((scan (si:instance-ref obj i) (cdr scan)) (e (car scan) (car scan))) ((null scan)) (prin1 (class-name e) stream) (when (cdr scan) (princ " " stream))) (princ ")" stream)) (otherwise (setq sv (si:instance-ref obj i)) (if (si:sl-boundp sv) (prin1 sv stream) (prin1 "Unbound" stream)))))) obj) ;; ---------------------------------------------------------------------- ecl-16.1.2/src/clos/slot.lsp000066400000000000000000000132011266352375300156050ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: CLOS -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; Copyright (c) 1992, Giuseppe Attardi. ;;;; Copyright (c) 2001, Juan Jose Garcia Ripoll. ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. (in-package "CLOS") (defconstant +initform-unsupplied+ '+initform-unsupplied+) ;;; ---------------------------------------------------------------------- ;;; SLOT descriptors ;;; (defun make-simple-slotd (class &key name (initform +initform-unsupplied+) initfunction (type 'T) (allocation :instance) initargs readers writers documentation location) (when (and (eq allocation :class) (functionp initfunction)) (setf initfunction (constantly (funcall initfunction)))) (with-early-make-instance +slot-definition-slots+ (slotd class :name name :initform initform :initfunction (if (listp initfunction) (eval initfunction) initfunction) :type type :allocation allocation :initargs initargs :readers readers :writers writers :documentation documentation :location location) slotd)) (defun freeze-class-slot-initfunction (slotd) (when (eq (getf slotd :allocation) :class) (let ((initfunc (getf slotd :initfunction))) (when initfunc (setf (getf slotd :initfunction) (constantly (funcall initfunc)))))) slotd) (defun canonical-slot-to-direct-slot (class slotd) ;; Class slot init functions must be called right away (setf slotd (freeze-class-slot-initfunction slotd)) (if (find-class 'slot-definition nil) (apply #'make-instance (apply #'direct-slot-definition-class class (freeze-class-slot-initfunction slotd)) slotd) (apply #'make-simple-slotd class slotd))) (defun direct-slot-to-canonical-slot (slotd) (list . #.(loop for (name . rest) in +slot-definition-slots+ collect (getf rest :initarg) collect `(,(getf rest :accessor) slotd)))) ;;; ---------------------------------------------------------------------- ;;; ;;; (PARSE-SLOTS slot-definition-form) => slot-definition-object ;;; ;;; This routine is the one responsible for parsing the definition of ;;; a slot in DEFCLASS. ;;; (defun make-function-initform (form) ;; INITFORM is a form that is to be evaluated at runtime. If it is a ;; constant value, we output simply a quoted form. If it is not, ;; we output a function that can be invoked at runtime to retrieve ;; the value. ;; ;; Output => (FUNCTION (LAMBDA () form)) ;; => (QUOTE ...) ;; (if (constantp form) `(constantly ,form) `#'(lambda () ,form))) (defun parse-slot (slot &optional (full nil)) (declare (si::c-local)) (if (symbolp slot) (list* :name slot (when full (list :initform '+INITFORM-UNSUPPLIED+ :initfunction nil :initargs nil :readers nil :writers nil :allocation :instance :documentation nil :type 'T))) (do* ((output (parse-slot (first slot) full)) (options (rest slot)) (value nil) (extra nil)) ((null options) (nconc output extra)) (let ((option (pop options))) (when (endp options) (si::simple-program-error "In the slot description ~S,~%the option ~S is missing an argument" slot option)) (let ((value (pop options))) (when (and (member option '(:allocation :initform :type :documentation)) (getf options option)) (si::simple-program-error "In the slot description ~S,~%the option ~S is duplicated" slot option)) (case option (:initarg (push value (getf output :initargs))) (:initform (setf (getf output :initform) value (getf output :initfunction) (make-function-initform value))) (:accessor (push value (getf output :readers)) (push `(setf ,value) (getf output :writers))) (:reader (push value (getf output :readers))) (:writer (push value (getf output :writers))) (:allocation (setf (getf output :allocation) value)) (:type (setf (getf output :type) value)) (:documentation (setf (getf output :documentation) value)) (otherwise (if (or (getf extra option) (getf options option)) (push value (getf extra option)) (setf (getf extra option) value))))))))) (defun parse-slots (slots) (do ((scan slots (cdr scan)) (collect)) ((null scan) (nreverse collect)) (let* ((slotd (parse-slot (first scan))) (name (getf slotd :name))) (dolist (other-slotd collect) (when (eq name (getf other-slotd :name)) (si::simple-program-error "A definition for the slot ~S appeared twice in a DEFCLASS form" name))) (push slotd collect)))) ;;; ---------------------------------------------------------------------- ecl-16.1.2/src/clos/slotvalue.lsp000066400000000000000000000057311266352375300166530ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: CLOS -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; Copyright (c) 1992, Giuseppe Attardi.o ;;;; Copyright (c) 2001, Juan Jose Garcia Ripoll. ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. (in-package "CLOS") (defmethod class-prototype ((class class)) (unless (slot-boundp class 'prototype) (setf (slot-value class 'prototype) (allocate-instance class))) (slot-value class 'prototype)) (defun slot-makunbound (self slot-name) (let* ((class (class-of self)) (slotd (find-slot-definition class slot-name))) (if slotd (slot-makunbound-using-class class self slotd) (slot-missing class self slot-name 'SLOT-MAKUNBOUND)) self)) (defmethod slot-value-using-class ((class std-class) self slotd) (declare (ignore class)) (let* ((location (slot-definition-location slotd)) (value (standard-instance-access self location))) (if (si:sl-boundp value) value (values (slot-unbound class self (slot-definition-name slotd)))))) (defmethod slot-boundp-using-class ((class std-class) self slotd) (declare (ignore class)) (si:sl-boundp (standard-instance-access self (slot-definition-location slotd)))) (defmethod (setf slot-value-using-class) (val (class std-class) self slotd) (declare (ignore class)) (setf (standard-instance-access self (slot-definition-location slotd)) val)) (defmethod slot-makunbound-using-class ((class std-class) instance slotd) (declare (ignore class)) (setf (standard-instance-access instance (slot-definition-location slotd)) (si:unbound)) instance) ;;; ;;; 3) Error messages related to slot access ;;; (defmethod slot-missing ((class t) object slot-name operation &optional new-value) (declare (ignore operation new-value class)) (error "~A is not a slot of ~A" slot-name object)) (defmethod slot-unbound ((class t) object slot-name) (declare (ignore class)) (error 'unbound-slot :instance object :name slot-name)) ;;; This method is non-standard. It is used by clos:safe-instance-ref to ;;; signal an unbound slot error when only the index is known. (defmethod slot-unbound ((class null) object slot-index) (declare (ignore class)) (let* ((class (class-of object)) (slotd (find slot-index (slot-value class 'slots) :key #'slot-definition-location))) (values (slot-unbound class object (slot-definition-name slotd))))) ;;; ;;; For the next accessor we define a method. ;;; (defmethod class-name ((class class)) (class-id class)) (defmethod (setf class-name) (new-value (class class)) (reinitialize-instance class :name new-value) new-value) ecl-16.1.2/src/clos/standard.lsp000066400000000000000000000736061266352375300164430ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: CLOS -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; Copyright (c) 1992, Giuseppe Attardi. ;;;; Copyright (c) 2001, Juan Jose Garcia Ripoll. ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. (in-package "CLOS") ;;; ---------------------------------------------------------------------- ;;; INSTANCES INITIALIZATION AND REINITIALIZATION ;;; (defmethod initialize-instance ((instance T) &rest initargs) (apply #'shared-initialize instance 'T initargs)) (defmethod reinitialize-instance ((instance T) &rest initargs) (check-initargs (class-of instance) initargs (valid-keywords-from-methods (compute-applicable-methods #'reinitialize-instance (list instance)) (compute-applicable-methods #'shared-initialize (list instance t)))) (apply #'shared-initialize instance '() initargs)) (defmethod shared-initialize ((instance T) slot-names &rest initargs) ;; ;; initialize the instance's slots is a two step process ;; 1 A slot for which one of the initargs in initargs can set ;; the slot, should be set by that initarg. If more than ;; one initarg in initargs can set the slot, the leftmost ;; one should set it. ;; ;; 2 Any slot not set by step 1, may be set from its initform ;; by step 2. Only those slots specified by the slot-names ;; argument are set. If slot-names is: ;; T ;; any slot not set in step 1 is set from its ;; initform ;; ;; any slot in the list, and not set in step 1 ;; is set from its initform ;; ;; () ;; no slots are set from initforms ;; (let* ((class (class-of instance))) ;; initialize-instance slots (dolist (slotd (class-slots class)) (let* ((slot-initargs (slot-definition-initargs slotd)) (slot-name (slot-definition-name slotd))) (or ;; Try to initialize the slot from one of the initargs. (do ((l initargs) initarg val) ((null l) nil) (setf initarg (pop l)) (when (endp l) (simple-program-error "Wrong number of keyword arguments for SHARED-INITIALIZE, ~A" initargs)) (unless (symbolp initarg) (simple-program-error "Not a valid initarg: ~A" initarg)) (setf val (pop l)) (when (member initarg slot-initargs :test #'eq) (setf (slot-value instance slot-name) val) (return t))) ;; Try to initialize the slot from its initform. (when (and slot-names (or (eq slot-names 'T) (member slot-name slot-names)) (not (slot-boundp instance slot-name))) (let ((initfun (slot-definition-initfunction slotd))) (when initfun (setf (slot-value instance slot-name) (funcall initfun)))))) ))) instance) ;;; ---------------------------------------------------------------------- ;;; CLASSES INITIALIZATION AND REINITIALIZATION ;;; (defun compute-instance-size (slots) (loop for slotd in slots with last-location = 0 with num-slots = 0 when (eq (slot-definition-allocation slotd) :instance) do (let ((new-loc (safe-slot-definition-location slotd))) (incf num-slots) (when (and new-loc (> new-loc last-location)) (setf last-location new-loc))) finally (return (max num-slots (1+ last-location))))) (defmethod allocate-instance ((class class) &rest initargs) (declare (ignore initargs)) ;; FIXME! Inefficient! We should keep a list of dependent classes. (unless (class-finalized-p class) (finalize-inheritance class)) (let ((x (si::allocate-raw-instance nil class (class-size class)))) (si::instance-sig-set x) x)) (defmethod make-instance ((class class) &rest initargs) ;; Without finalization we can not find initargs. (unless (class-finalized-p class) (finalize-inheritance class)) ;; We add the default-initargs first, because one of these initargs might ;; be (:allow-other-keys t), which disables the checking of the arguments. ;; (Paul Dietz's ANSI test suite, test CLASS-24.4) (setf initargs (add-default-initargs class initargs)) (let ((keywords (if (slot-boundp class 'valid-initargs) (class-valid-initargs class) (precompute-valid-initarg-keywords class)))) (check-initargs class initargs nil (class-slots class) keywords)) (let ((instance (apply #'allocate-instance class initargs))) (apply #'initialize-instance instance initargs) instance)) (defun delete-keyword (keyword list) (loop until (eq (getf list keyword list) list) do (remf list keyword)) list) (defun add-default-initargs (class initargs) (declare (si::c-local)) ;; Here, for each slot which is not mentioned in the initialization ;; arguments, but which has a value associated with :DEFAULT-INITARGS, ;; we compute the value and add it to the list of initargs. (let ((output '())) (dolist (scan (class-default-initargs class)) (let* ((initarg (first scan)) (value (third scan)) (supplied-value (si::search-keyword initargs initarg))) (when (or (eq supplied-value '+initform-unsupplied+) (eq supplied-value 'si::missing-keyword)) (when (eq supplied-value '+initform-unsupplied+) (setf initargs (delete-keyword initarg initargs))) (setf output (list* (funcall value) initarg output))))) (if output (append initargs (nreverse output)) initargs))) (defmethod direct-slot-definition-class ((class T) &rest canonicalized-slot) (declare (ignore class canonicalized-slot)) (find-class 'standard-direct-slot-definition nil)) (defmethod effective-slot-definition-class ((class T) &rest canonicalized-slot) (declare (ignore class canonicalized-slot)) (find-class 'standard-effective-slot-definition nil)) (defun has-forward-referenced-parents (class) (or (forward-referenced-class-p class) (and (not (class-finalized-p class)) (some #'has-forward-referenced-parents (class-direct-superclasses class))))) (defun finalize-unless-forward (class) (unless (find-if #'has-forward-referenced-parents (class-direct-superclasses class)) (finalize-inheritance class))) (defmethod initialize-instance ((class class) &rest initargs &key direct-slots) (declare (ignore sealedp)) ;; convert the slots from lists to direct slots (apply #'call-next-method class :direct-slots (loop for s in direct-slots collect (canonical-slot-to-direct-slot class s)) initargs) (finalize-unless-forward class) class) (defmethod shared-initialize ((class class) slot-names &rest initargs &key direct-superclasses) ;; verify that the inheritance list makes sense (let* ((class (apply #'call-next-method class slot-names :direct-superclasses (if (slot-boundp class 'direct-superclasses) (slot-value class 'direct-superclasses) nil) initargs)) (direct-superclasses (check-direct-superclasses class direct-superclasses))) (loop for c in (class-direct-superclasses class) unless (member c direct-superclasses :test #'eq) do (remove-direct-subclass c class)) (setf (class-direct-superclasses class) direct-superclasses) (loop for c in direct-superclasses do (add-direct-subclass c class)) class)) (defun precompute-valid-initarg-keywords (class) (setf (class-valid-initargs class) (loop with methods = (nconc (compute-applicable-methods #'allocate-instance (list class)) (compute-applicable-methods #'initialize-instance (list (class-prototype class))) (compute-applicable-methods #'shared-initialize (list (class-prototype class) t))) for m in methods for k = (method-keywords m) when (eq k t) return t append k))) (defun update-dependents (object initargs) (when *clos-booted* (map-dependents object #'(lambda (dep) (apply #'update-dependent object dep initargs))))) (defmethod shared-initialize ((class std-class) slot-names &rest initargs &key (optimize-slot-access (list *optimize-slot-access*)) sealedp) (declare (ignore initargs slot-names)) (setf (slot-value class 'optimize-slot-access) (first optimize-slot-access) (slot-value class 'sealedp) (and sealedp t)) (setf class (call-next-method)) (update-dependents class initargs) class) (defmethod add-direct-subclass ((parent class) child) (pushnew child (class-direct-subclasses parent))) (defmethod remove-direct-subclass ((parent class) child) (setf (class-direct-subclasses parent) (remove child (class-direct-subclasses parent)))) (defun check-direct-superclasses (class supplied-superclasses) (if supplied-superclasses (loop for superclass in supplied-superclasses ;; Until we process streams.lsp there are some invalid combinations ;; using built-in-class, which here we simply ignore. unless (or (validate-superclass class superclass) (not (eq *clos-booted* T))) do (error "Class ~A is not a valid superclass for ~A" superclass class)) (setf supplied-superclasses (list (find-class (typecase class (STANDARD-CLASS 'STANDARD-OBJECT) (STRUCTURE-CLASS 'STRUCTURE-OBJECT) (FUNCALLABLE-STANDARD-CLASS 'FUNCALLABLE-STANDARD-OBJECT) (otherwise (error "No :DIRECT-SUPERCLASS ~ argument was supplied for metaclass ~S." (class-of class)))))))) ;; FIXME!!! Here should come the invocation of VALIDATE-SUPERCLASS! ;; FIXME!!! We should check that structures and standard objects are ;; not mixed, and that STANDARD-CLASS, or STANDARD-GENERIC-FUNCTION, ;; etc, are the first classes. supplied-superclasses) (defmethod validate-superclass ((class class) (superclass class)) (or (eq superclass +the-t-class+) (let ((c1 (class-of class)) (c2 (class-of superclass))) (or (eq c1 c2) (and (eq c1 +the-standard-class+) (eq c2 +the-funcallable-standard-class+)) (and (eq c2 +the-standard-class+) (eq c1 +the-funcallable-standard-class+)) )) (forward-referenced-class-p superclass) )) ;;; ---------------------------------------------------------------------- ;;; FINALIZATION OF CLASS INHERITANCE ;;; (defun forward-referenced-class-p (x) (let ((y (find-class 'FORWARD-REFERENCED-CLASS nil))) (and y (si::subclassp (class-of x) y)))) (defmethod finalize-inheritance ((class class)) ;; FINALIZE-INHERITANCE computes the guts of what defines a class: the ;; slots, the list of parent class, etc. It is called when either the ;; class was not finalized before, or when one of the parents has been ;; modified. ;; (let ((cpl (compute-class-precedence-list class))) ;; A class cannot be finalized if any of its parents is either ;; a not yet defined class or it has not yet been finalized. ;; In the first case we can just signal an error... ;; (let ((x (find-if #'forward-referenced-class-p (rest cpl)))) (when x (error "Cannot finish building the class~% ~A~%~ because it contains a reference to the undefined class~% ~A" (class-name class) (class-name x)))) ;; ;; ... and in the second case we just finalize the top-most class ;; which is not yet finalized and rely on the fact that this ;; class will also try to finalize all of its children. ;; (let ((x (find-if-not #'class-finalized-p cpl :from-end t))) (unless (or (null x) (eq x class)) (return-from finalize-inheritance (finalize-inheritance x)))) (setf (class-precedence-list class) cpl) (let ((slots (compute-slots class))) (setf (class-slots class) slots (class-size class) (compute-instance-size slots) (class-default-initargs class) (compute-default-initargs class) (class-finalized-p class) t)) ;; ;; When a class is sealed we rewrite the list of direct slots to fix ;; their locations. This may imply adding _new_ direct slots. ;; (when (class-sealedp class) (let* ((free-slots (delete-duplicates (mapcar #'slot-definition-name (class-slots class)))) (all-slots (class-slots class))) ;; ;; We first search all slots that belonged to unsealed classes and which ;; therefore have no fixed position. ;; (loop for c in cpl do (loop for slotd in (class-direct-slots c) when (safe-slot-definition-location slotd) do (setf free-slots (delete (slot-definition-name slotd) free-slots)))) ;; ;; We now copy the locations of the effective slots in this class to ;; the class direct slots. ;; (loop for slotd in (class-direct-slots class) do (let* ((name (slot-definition-name slotd)) (other-slotd (find name all-slots :key #'slot-definition-name))) (setf (slot-definition-location slotd) (slot-definition-location other-slotd) free-slots (delete name free-slots)))) ;; ;; And finally we add one direct slot for each inherited slot that did ;; not have a fixed location. ;; (loop for name in free-slots with direct-slots = (class-direct-slots class) do (let* ((effective-slotd (find name all-slots :key #'slot-definition-name)) (def (direct-slot-to-canonical-slot effective-slotd))) (push (apply #'make-instance (direct-slot-definition-class class def) def) direct-slots)) finally (setf (class-direct-slots class) direct-slots)))) ;; ;; This is not really needed, because when we modify the list of slots ;; all instances automatically become obsolete (See change.lsp) ;(make-instances-obsolete class) ;; ;; But this is really needed: we have to clear the different type caches ;; for type comparisons and so on. ;; (si::subtypep-clear-cache) ) ;; As mentioned above, when a parent is finalized, it is responsible for ;; invoking FINALIZE-INHERITANCE on all of its children. Obviously, ;; this only makes sense when the class has been defined. (dolist (subclass (reverse (class-direct-subclasses class))) (finalize-unless-forward subclass)) ;; ;; We create various caches to more rapidly find the slot locations and ;; slot definitions. (std-create-slots-table class) ) (defmethod finalize-inheritance ((class std-class)) (call-next-method) (std-class-generate-accessors class)) (defmethod compute-class-precedence-list ((class class)) (compute-clos-class-precedence-list class (class-direct-superclasses class))) (eval-when (:compile-toplevel :execute) (defmacro mapappend (fun &rest args) `(reduce #'append (mapcar ,fun ,@args)))) (defmethod compute-slots ((class class)) ;; INV: for some classes ECL expects that the order of the inherited slots is ;; preserved. The following code ensures that, if C1 is after C2 in the ;; class precedence list, and the slot S1 appears both in C1 and C2, ;; the slot S1 will appear the new class before the slots of C2; and ;; whenever possible, in the same position as in C1. ;; (do* ((all-slots (mapappend #'class-direct-slots (reverse (class-precedence-list class)))) (all-names (nreverse (mapcar #'slot-definition-name all-slots))) (output '()) (scan all-names (cdr scan))) ((endp scan) output) (let ((name (first scan))) (unless (find name (rest scan)) (push (compute-effective-slot-definition class name (delete name (reverse all-slots) :key #'slot-definition-name :test-not #'eq)) output))))) (defun slot-definition-to-plist (slotd) (list :name (slot-definition-name slotd) :initform (slot-definition-initform slotd) :initfunction (slot-definition-initfunction slotd) :type (slot-definition-type slotd) :allocation (slot-definition-allocation slotd) :initargs (slot-definition-initargs slotd) :readers (slot-definition-readers slotd) :writers (slot-definition-writers slotd) :documentation (slot-definition-documentation slotd) :location (slot-definition-location slotd))) (defun safe-slot-definition-location (slotd &optional default) (if (or (listp slotd) (slot-boundp slotd 'location)) (slot-definition-location slotd) default)) (defmethod compute-effective-slot-definition ((class class) name direct-slots) (flet ((direct-to-effective (old-slot) (if (consp old-slot) (copy-list old-slot) (let ((initargs (slot-definition-to-plist old-slot))) (apply #'make-instance (apply #'effective-slot-definition-class class initargs) initargs)))) (combine-slotds (new-slotd old-slotd) (let* ((new-type (slot-definition-type new-slotd)) (old-type (slot-definition-type old-slotd)) (loc1 (safe-slot-definition-location new-slotd)) (loc2 (safe-slot-definition-location old-slotd))) (when loc2 (if loc1 (unless (eql loc1 loc2) (error 'simple-error :format-control "You have specified two conflicting slot locations:~%~D and ~F~%for slot ~A" :format-arguments (list loc1 loc2 name))) (progn #+(or) (format t "~%Assigning a default location ~D for ~A in ~A." loc2 name (class-name class)) (setf (slot-definition-location new-slotd) loc2)))) (setf (slot-definition-initargs new-slotd) (union (slot-definition-initargs new-slotd) (slot-definition-initargs old-slotd))) (unless (slot-definition-initfunction new-slotd) (setf (slot-definition-initform new-slotd) (slot-definition-initform old-slotd) (slot-definition-initfunction new-slotd) (slot-definition-initfunction old-slotd))) (setf (slot-definition-readers new-slotd) (union (slot-definition-readers new-slotd) (slot-definition-readers old-slotd)) (slot-definition-writers new-slotd) (union (slot-definition-writers new-slotd) (slot-definition-writers old-slotd)) (slot-definition-type new-slotd) ;; FIXME! we should be more smart then this: (cond ((subtypep new-type old-type) new-type) ((subtypep old-type new-type) old-type) (T `(and ,new-type ,old-type)))) new-slotd))) (reduce #'combine-slotds (rest direct-slots) :initial-value (direct-to-effective (first direct-slots))))) (defmethod compute-default-initargs ((class class)) (let ((all-initargs (mapappend #'class-direct-default-initargs (class-precedence-list class)))) ;; We have to use this trick because REMOVE-DUPLICATES on ;; ((:foo x) (:faa y) (:foo z)) would produce ((:faa y) (:foo z)) ;; and we want ((:foo x) (:faa y)) (nreverse (remove-duplicates (reverse all-initargs) :key #'first)))) ;;; ====================================================================== ;;; STANDARD-CLASS specializations ;;; ;;; IMPORTANT: The following implementation of ENSURE-CLASS-USING-CLASS is ;;; shared by the metaclasses STANDARD-CLASS and STRUCTURE-CLASS. ;;; (defmethod ensure-class-using-class ((class class) name &rest rest &key direct-slots direct-default-initargs) (declare (ignore direct-default-initargs direct-slots)) (multiple-value-bind (metaclass direct-superclasses options) (apply #'help-ensure-class rest) (declare (ignore direct-superclasses)) (cond ((forward-referenced-class-p class) (change-class class metaclass)) ((not (eq (class-of class) metaclass)) (error "When redefining a class, the metaclass can not change."))) (setf class (apply #'reinitialize-instance class :name name options)) (when name (si:create-type-name name) (setf (find-class name) class)) class)) (defun coerce-to-class (class-or-symbol &optional (fail nil)) (cond ((si:instancep class-or-symbol) class-or-symbol) ((not (symbolp class-or-symbol)) (error "~a is not a valid class specifier." class-or-symbol)) ((find-class class-or-symbol fail)) (t (warn 'si::simple-style-warning :format-control "Class ~A has been forward referenced." :format-arguments (list class-or-symbol)) (ensure-class class-or-symbol :metaclass 'forward-referenced-class :direct-superclasses (list (find-class 'standard-object)) :direct-slots '())))) (defun help-ensure-class (&rest options &key (metaclass 'standard-class) direct-superclasses &allow-other-keys) (remf options :metaclass) (remf options :direct-superclasses) (setf metaclass (coerce-to-class metaclass t) direct-superclasses (mapcar #'coerce-to-class direct-superclasses)) (values metaclass direct-superclasses (list* :direct-superclasses direct-superclasses options))) ;;; ---------------------------------------------------------------------- ;;; Around methods for COMPUTE-SLOTS which assign locations to each slot. ;;; (defun class-compute-slots (class slots) ;; This an ECL extension. We are allowed to specify the location of ;; a direct slot. Consequently we have to first sort the ones which ;; have been predefined and then assign locations _after_ the last ;; assigned slot. Note the generalized comparison, which pushes all ;; slots without a defined location to the end of the list. (let* ((size (compute-instance-size slots)) (instance-slots (remove :instance slots :key #'slot-definition-allocation :test-not #'eq)) (numbered-slots (remove-if-not #'safe-slot-definition-location instance-slots)) (other-slots (remove-if #'safe-slot-definition-location instance-slots)) (aux (make-array size :element-type 't :adjustable nil :initial-element nil))) (loop for i in numbered-slots do (let ((loc (slot-definition-location i))) (when (aref aux loc) (error 'simple-error :format-control "Slots ~A and ~A are said to have the same location in class ~A." :format-ars (list (aref aux loc) i class))) (setf (aref aux loc) i))) (loop for i in other-slots with index = 0 do (loop while (aref aux index) do (incf index) finally (setf (aref aux index) i (slot-definition-location i) index))) slots)) (defmethod compute-slots :around ((class class)) (class-compute-slots class (call-next-method))) (defun std-class-compute-slots (class slots) (declare (si::c-local)) (let* ((direct-slots (class-direct-slots class))) (dolist (slotd slots) (let* ((name (slot-definition-name slotd)) (allocation (slot-definition-allocation slotd))) (cond ((not (eq (slot-definition-allocation slotd) :class))) ((find name direct-slots :key #'slot-definition-name) ; new shared slot (let* ((initfunc (slot-definition-initfunction slotd)) (value (if initfunc (funcall initfunc) (unbound)))) (setf (slot-definition-location slotd) (list value)))) (t ; inherited shared slot (dolist (c (class-precedence-list class)) (unless (eql c class) (let ((other (find (slot-definition-name slotd) (class-slots c) :key #'slot-definition-name))) (when (and other (eq (slot-definition-allocation other) allocation) (setf (slot-definition-location slotd) (slot-definition-location other))) (return))))))))) slots)) (defmethod compute-slots :around ((class std-class)) (std-class-compute-slots class (call-next-method))) ;;; ====================================================================== ;;; STANDARD-OBJECT ;;; ;;; Standard-object has no slots and inherits only from t: ;;; (defclass standard-object (t) ()) (defmethod describe-object ((obj standard-object) (stream t)) (let* ((class (si:instance-class obj)) (slotds (class-slots class)) slotname has-shared-slots) (format stream "~%~S is an instance of class ~A" obj (class-name class)) (when slotds ;; print instance slots (format stream "~%it has the following instance slots") (dolist (slot slotds) (setq slotname (slot-definition-name slot)) (case (slot-definition-allocation slot) (:INSTANCE (format stream "~%~A:~24,8T~A" slotname (if (slot-boundp obj slotname) (slot-value obj slotname) "Unbound"))) ;; :CLASS (T (setq has-shared-slots t)))) (when has-shared-slots ;; print class slots (format stream "~%it has the following class slots") (dolist (slot slotds) (setq slotname (slot-definition-name slot)) (unless (eq (slot-definition-allocation slot) :INSTANCE) (format stream "~%~A:~24,8T~A" slotname (if (slot-boundp obj slotname) (slot-value obj slotname) "Unbound"))))))) obj) ;;; ---------------------------------------------------------------------- ;;; CHECK INITARGS ;;; ;;; There are different sets of initialization arguments. First we have ;;; those coming from the :INITARG option in the slots. Then we have ;;; all declared initargs which are keyword arguments to methods defined ;;; on SHARED-INITIALIZE, REINITIALIZE-INSTANCE, etc. (See ANSI 7.1.2) ;;; (defun valid-keywords-from-methods (&rest method-lists) (loop for methods in method-lists when (member t methods :key #'method-keywords) return t nconc methods)) (defun check-initargs (class initargs &optional methods (slots (class-slots class)) cached-keywords) ;; First get all initargs which have been declared in the given ;; methods, then check the list of initargs declared in the slots ;; of the class. (unless (or (eq methods t) (eq cached-keywords t)) (do* ((name-loc initargs (cddr name-loc)) (allow-other-keys nil) (allow-other-keys-found nil) (unknown-key nil)) ((null name-loc) (when (and (not allow-other-keys) unknown-key) (simple-program-error "Unknown initialization option ~S for class ~A" unknown-key class))) (let ((name (first name-loc))) (cond ((null (cdr name-loc)) (simple-program-error "No value supplied for the init-name ~S." name)) ;; This check must be here, because :ALLOW-OTHER-KEYS is a valid ;; slot-initarg. ((and (eql name :ALLOW-OTHER-KEYS) (not allow-other-keys-found)) (setf allow-other-keys (second name-loc) allow-other-keys-found t)) ;; Check if the arguments is associated with a slot ((member name slots :test #'member :key #'slot-definition-initargs)) ;; The initialization argument has been declared in some method ((member name cached-keywords)) ((and methods (member name methods :test #'member :key #'method-keywords))) (t (setf unknown-key name))))))) ;;; ---------------------------------------------------------------------- ;;; Methods (defmethod describe-object ((obj std-class) (stream t)) (let ((slotds (class-slots (si:instance-class obj)))) (format stream "~%~A is an instance of class ~A" obj (class-name (si:instance-class obj))) (do ((scan slotds (cdr scan)) (i 0 (1+ i))) ((null scan)) (declare (fixnum i)) (print (slot-definition-name (car scan)) stream) (princ ": " stream) (case (slot-definition-name (car scan)) ((SUPERIORS INFERIORS PRECEDENCE-LIST) (princ "(" stream) (do* ((scan (si:instance-ref obj i) (cdr scan)) (e (car scan) (car scan))) ((null scan)) (prin1 (class-name e) stream) (when (cdr scan) (princ " " stream))) (princ ")")) (otherwise (prin1 (si:instance-ref obj i) stream))))) obj) ecl-16.1.2/src/clos/std-accessors.lsp000066400000000000000000000174041266352375300174120ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: CLOS -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; Copyright (c) 1992, Giuseppe Attardi.o ;;;; Copyright (c) 2001, Juan Jose Garcia Ripoll. ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. (in-package "CLOS") ;;; ---------------------------------------------------------------------- ;;; ACCESSOR / READER / WRITER METHOD CREATION ;;; ;;; The following code creates optimized and unoptimized versions of the ;;; slot accessors defined for a class. They are designed so that at least ;;; some varieties work at boot time. ;;; (defun safe-slot-definition-location (slotd &optional default) (cond ((listp slotd) (error "List instead of a slot definition object")) (t (slot-value slotd 'location)))) (defun std-class-sealed-accessors (index) (declare (si::c-local) (fixnum index)) (values #'(lambda (self) (declare (optimize (safety 0) (speed 3) (debug 0)) (standard-object self)) (ensure-up-to-date-instance self) (safe-instance-ref self index)) #'(lambda (value self) (declare (optimize (safety 0) (speed 3) (debug 0)) (standard-object self)) (ensure-up-to-date-instance self) (si:instance-set self index value)))) (defun std-class-accessors (slot-name) (declare (si::c-local)) ;; The following are very slow. We do not optimize for the slot position. (values #'(lambda (self) (slot-value self slot-name)) #'(lambda (value self) (setf (slot-value self slot-name) value)))) (defun safe-add-method (name method) ;; Adds a method to a function which might have been previously defined ;; as non-generic, without breaking the function (cond ((or *clos-booted* (not (fboundp name)) (si::instancep (fdefinition name))) (add-method (ensure-generic-function name) method)) (t (let* ((alt-name '#:foo) (gf (ensure-generic-function alt-name))) (add-method gf method) (setf (generic-function-name gf) name) (setf (fdefinition name) gf) (fmakunbound alt-name))))) (defun std-class-generate-accessors (standard-class &optional (optimizable t)) ;; ;; The accessors are closures, which are generated every time the ;; slots of the class change. The accessors are safe: they check that ;; the slot is bound after retreiving the value, and they may take ;; the liberty of using SI:INSTANCE-REF because they know the class of ;; the instance. ;; (dolist (slotd (slot-value standard-class 'direct-slots)) (with-slots ((name name) (allocation allocation) (location location) (readers readers) (writers writers)) slotd ;; When a class is of a specified class in the MOP (such as ;; STANDARD-CLASS), then the user may not write any method ;; around SLOT-VALUE-USING-CLASS. This allows us to write ;; optimized versions of the accessors. (unless (member (slot-value standard-class 'name) '(standard-class funcallable-standard-class structure-class)) (setf optimizable nil)) (multiple-value-bind (reader writer) (cond ((and optimizable (eq allocation :instance) ;; This is an extension by ECL in which a direct slot ;; definition specifies the location of a slot. It ;; only happens for sealed classes. (typep location 'fixnum)) (std-class-sealed-accessors location)) (t (std-class-accessors name))) (let* ((options (list :slot-definition slotd)) (reader-args (list* :function reader :generic-function nil :qualifiers nil :lambda-list '(object) :specializers `(,standard-class) options)) (reader-class (if (boundp '*early-methods*) 'standard-reader-method (apply #'reader-method-class standard-class slotd reader-args))) (writer-args (list* :function writer :generic-function nil :qualifiers nil :lambda-list '(value object) :specializers `(,(find-class t) ,standard-class) options)) (writer-class (if (boundp '*early-methods*) 'standard-writer-method (apply #'writer-method-class standard-class slotd writer-args)))) (dolist (fname readers) (let ((method (make-method reader-class nil `(,standard-class) '(self) (wrapped-method-function reader) options))) (safe-add-method fname method) ;; This is redundant, but we need it at boot time because ;; the early MAKE-METHOD does not use the options field. (unless *clos-booted* (setf (slot-value method 'slot-definition) slotd)))) (dolist (fname writers) (let ((method (make-method writer-class nil `(,(find-class t) ,standard-class) '(value self) (wrapped-method-function writer) options))) (safe-add-method fname method) ;; This is redundant, but we need it at boot time because ;; the early MAKE-METHOD does not use the options field. (unless *clos-booted* (setf (slot-value method 'slot-definition) slotd))))))))) (defun reader-closure (index) (declare (si::c-local)) (lambda (object) (si::instance-ref object index))) (defun writer-closure (index) (declare (si::c-local)) (lambda (value object) (si::instance-set object index value))) (labels ((generate-accessors (class) (declare (optimize speed (safety 0))) (if (and (typep class 'std-class) #+(or) (not (member (slot-value class 'name) '(slot-definition direct-slot-definition effective-slot-definition standard-slot-definition standard-direct-slot-definition standard-effective-slot-definition)))) (std-class-generate-accessors class t) (loop for slotd in (slot-value class 'slots) for index = (slot-value slotd 'location) do (loop for reader in (slot-value slotd 'readers) do (setf (fdefinition reader) (reader-closure index))) do (loop for writer in (slot-value slotd 'writers) do (setf (fdefinition writer) (writer-closure index))))) (mapc #'generate-accessors (slot-value class 'direct-subclasses)))) (generate-accessors +the-t-class+)) ecl-16.1.2/src/clos/std-slot-value.lsp000066400000000000000000000253261266352375300175220ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: CLOS -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; Copyright (c) 1992, Giuseppe Attardi.o ;;;; Copyright (c) 2001, Juan Jose Garcia Ripoll. ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. (in-package "CLOS") (eval-when (:compile-toplevel :execute) (load "src:clos;hierarchy.lsp")) ;;; ---------------------------------------------------------------------- ;;; SLOTS READING AND WRITING ;;; ;;; Functional and macro interface for accessing the slots of an instance. ;;; This interface is defined with specialization for classes that ECL ;;; knows of such as standard classes and funcallable standard class. ;;; This is needed to avoid circularity in compute-applicable-methods, ;;; which needs the slot values and thus cannot go through a dispatch ;;; itself. ;;; ;;; Note that using SLOT-VALUE or specialized versions of it is not ;;; wrong because the MOP enforces various restrictions on portable ;;; code: ;;; 1) Accessors must behave as SLOT-VALUE ;;; 2) In particular, any method defined by the user must be ;;; specialized on at least one non-specified class. This means ;;; that the user cannot change the behavoir of SLOT-VALUE for ;;; standard classes. ;;; ;;; First of all we define WITH-SLOTS because it is going to be useful ;;; for enforcing the use of SLOT-VALUE and not of accessors ;;; throughout the bootstrap code. ;;; (defmacro with-slots (slot-entries instance-form &body body) (let* ((temp (gensym)) (accessors (do ((scan slot-entries (cdr scan)) (res)) ((null scan) (nreverse res)) (if (symbolp (first scan)) (push `(,(first scan) (slot-value ,temp ',(first scan))) res) (push `(,(caar scan) (slot-value ,temp ',(cadar scan))) res))))) `(let ((,temp ,instance-form)) (symbol-macrolet ,accessors ,@body)))) ;;; ;;; The following macro is a convenience that can be used to directly ;;; access the slots of a class based on their s-form description. It ;;; is used internally by ECL during bootstrap. Unlike WITH-SLOTS, ;;; the macros directly access the slots by index. ;;; (eval-when (:compile-toplevel :execute) (defmacro with-early-accessors ((&rest slot-definitions) &rest body) `(macrolet ,(loop for slots in slot-definitions nconc (loop for (name . slotd) in (if (symbolp slots) (symbol-value slots) slots) for index from 0 for accessor = (getf slotd :accessor) when accessor collect `(,accessor (object) `(si::instance-ref ,object ,,index)))) ,@body))) ;;; ;;; The following macro is also used at bootstap for instantiating ;;; a class based only on the s-form description. ;;; (eval-when (:compile-toplevel :execute) (defmacro with-early-make-instance (slots (object class &rest key-value-pairs) &rest body) (when (symbolp slots) (setf slots (symbol-value slots))) `(let* ((%class ,class) (,object (si::allocate-raw-instance nil %class ,(length slots)))) (declare (type standard-object ,object)) ,@(flet ((initializerp (name list) (not (eq (getf list name 'wrong) 'wrong)))) (loop for (name . slotd) in slots for initarg = (getf slotd :initarg) for initform = (getf slotd :initform (si::unbound)) for initvalue = (getf key-value-pairs initarg) for index from 0 do (cond ((and initarg (initializerp initarg key-value-pairs)) (setf initform (getf key-value-pairs initarg))) ((initializerp name key-value-pairs) (setf initform (getf key-value-pairs name)))) when (si:sl-boundp initform) collect `(si::instance-set ,object ,index ,initform))) (when %class (si::instance-sig-set ,object)) (with-early-accessors (,slots) ,@body)))) ;;; ;;; ECL classes store slots in a hash table for faster access. The ;;; following functions create the cache and allow us to locate the ;;; slots rapidly. ;;; (defun std-create-slots-table (class) (with-slots ((all-slots slots) (slot-table slot-table) (location-table location-table)) class (let* ((size (max 32 (* 2 (length all-slots)))) (table (make-hash-table :size size))) (dolist (slotd all-slots) (setf (gethash (slot-definition-name slotd) table) slotd)) (let ((metaclass (si::instance-class class)) (locations nil)) (when (or (eq metaclass (find-class 'standard-class)) (eq metaclass (find-class 'funcallable-standard-class)) (eq metaclass (find-class 'structure-class))) (setf locations (make-hash-table :size size)) (dolist (slotd all-slots) (setf (gethash (slot-definition-name slotd) locations) (slot-definition-location slotd)))) (setf slot-table table location-table locations))))) (defun find-slot-definition (class slot-name) (with-slots ((slots slots) (slot-table slot-table)) class (if (or (eq (si:instance-class class) +the-standard-class+) (eq (si:instance-class class) +the-funcallable-standard-class+)) (gethash slot-name slot-table nil) (find slot-name slots :key #'slot-definition-name)))) ;;; ;;; INSTANCE UPDATE PREVIOUS ;;; (eval-when (:compile-toplevel :execute) (defmacro ensure-up-to-date-instance (instance) ;; The up-to-date status of a class is determined by ;; instance.sig. This slot of the C structure contains a list of ;; slot definitions that was used to create the instance. When the ;; class is updated, the list is newly created. Structures are also ;; "instances" but keep ECL_UNBOUND instead of the list. `(let* ((i ,instance) (s (si::instance-sig i))) (declare (:read-only i s)) (with-early-accessors (+standard-class-slots+) (when (si:sl-boundp s) (unless (eq s (class-slots (si::instance-class i))) (update-instance i))))))) (defun update-instance (x) (si::instance-sig-set x)) (declaim (notinline update-instance)) ;;; ;;; STANDARD-CLASS INTERFACE ;;; ;;; Specific functions for slot reading, writing, boundness checking, etc. ;;; (defun standard-instance-access (instance location) (with-early-accessors (+standard-class-slots+ +slot-definition-slots+) (ensure-up-to-date-instance instance) (cond ((ext:fixnump location) ;; local slot (si:instance-ref instance (truly-the fixnum location))) ((consp location) ;; shared slot (car location)) (t (invalid-slot-location instance location))))) (defun standard-instance-set (instance location val) (with-early-accessors (+standard-class-slots+ +slot-definition-slots+) (ensure-up-to-date-instance instance) (cond ((ext:fixnump location) ;; local slot (si:instance-set instance (truly-the fixnum location) val)) ((consp location) ;; shared slot (setf (car location) val)) (t (invalid-slot-location instance location))) val)) (defsetf standard-instance-access standard-instance-set) (defsetf funcallable-standard-instance-access standard-instance-set) (defun slot-value (self slot-name) (with-early-accessors (+standard-class-slots+ +slot-definition-slots+) (let* ((class (class-of self)) (location-table (class-location-table class))) (if location-table (let ((location (gethash slot-name location-table nil))) (if location (let ((value (standard-instance-access self location))) (if (si:sl-boundp value) value (values (slot-unbound class self slot-name)))) (slot-missing class self slot-name 'SLOT-VALUE))) (let ((slotd (find slot-name (class-slots class) :key #'slot-definition-name))) (if slotd (slot-value-using-class class self slotd) (values (slot-missing class self slot-name 'SLOT-VALUE)))))))) (defun slot-exists-p (self slot-name) (and (find-slot-definition (class-of self) slot-name) t)) (defun slot-boundp (self slot-name) (with-early-accessors (+standard-class-slots+ +slot-definition-slots+) (let* ((class (class-of self)) (location-table (class-location-table class))) (if location-table (let ((location (gethash slot-name location-table nil))) (if location (si:sl-boundp (standard-instance-access self location)) (values (slot-missing class self slot-name 'SLOT-BOUNDP)))) (let ((slotd (find slot-name (class-slots class) :key #'slot-definition-name))) (if slotd (slot-boundp-using-class class self slotd) (values (slot-missing class self slot-name 'SLOT-BOUNDP)))))))) (defun clos::slot-value-set (value self slot-name) (with-early-accessors (+standard-class-slots+ +slot-definition-slots+) (let* ((class (class-of self)) (location-table (class-location-table class))) (if location-table (let ((location (gethash slot-name location-table nil))) (if location (setf (standard-instance-access self location) value) (slot-missing class self slot-name 'SETF value))) (let ((slotd (find slot-name (class-slots class) :key #'slot-definition-name))) (if slotd (setf (slot-value-using-class class self slotd) value) (slot-missing class self slot-name 'SETF value)))))) value) (setf (fdefinition '(setf slot-value)) #'clos::slot-value-set) ;;; ;;; 2) Overloadable methods on which the previous functions are based ;;; (defun invalid-slot-location (instance location) (declare (si::c-local) (ignore instance)) (error "Invalid location ~A when accessing slot of class ~A" location (class-of location))) ecl-16.1.2/src/clos/stdmethod.lsp000066400000000000000000000067571266352375300166410ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: CLOS -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; Copyright (c) 1992, Giuseppe Attardi. ;;;; Copyright (c) 2001, Juan Jose Garcia Ripoll. ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. (in-package "CLOS") ;;;---------------------------------------------------------------------- ;;; Method ;;; ---------------------------------------------------------------------- (defun function-keywords (method) (multiple-value-bind (reqs opts rest-var key-flag keywords) (si::process-lambda-list (slot-value method 'lambda-list) 'function) (declare (ignore reqs opts rest-var)) (when key-flag (do* ((output '()) (l (cdr keywords) (cddddr l))) ((endp l) output) (push (first l) output))))) (defmethod shared-initialize ((method standard-method) slot-names &rest initargs &key (specializers nil spec-supplied-p) (lambda-list nil lambda-supplied-p) generic-function) (declare (ignore initargs method slot-names)) (when slot-names (unless spec-supplied-p (error "Specializer list not supplied in method initialization")) (unless lambda-supplied-p (error "Lambda list not supplied in method initialization")) (unless (= (first (si::process-lambda-list lambda-list 'method)) (length specializers)) (error "The list of specializers does not match the number of required arguments in the lambda list ~A" lambda-list))) (when spec-supplied-p (loop for s in specializers unless (typep s 'specializer) do (error "Object ~A is not a valid specializer" s))) (setf method (call-next-method) (method-keywords method) (compute-method-keywords (method-lambda-list method))) method) #+threads (defparameter *eql-specializer-lock* (mp:make-lock :name 'eql-specializer)) (defparameter *eql-specializer-hash* (make-hash-table :size 128 :test #'eql)) (defun intern-eql-specializer (object) (let ((table *eql-specializer-hash*)) (mp:with-lock (*eql-specializer-lock*) (or (gethash object table nil) (setf (gethash object table) (make-instance 'eql-specializer :object object)))))) (defmethod add-direct-method ((spec specializer) (method method)) (pushnew method (specializer-direct-methods spec)) (let ((gf (method-generic-function method))) (pushnew gf (specializer-direct-generic-functions spec))) (values)) (defmethod remove-direct-method ((spec specializer) (method method)) (let* ((gf (method-generic-function method)) (methods (delete method (specializer-direct-methods spec)))) (setf (specializer-direct-methods spec) methods) (unless (find gf methods :key #'method-generic-function) (setf (specializer-direct-generic-functions spec) (delete gf (specializer-direct-generic-functions spec)))) (values))) (defmethod remove-direct-method ((spec eql-specializer) (method method)) (mp:with-lock (*eql-specializer-lock*) (call-next-method) (unless (specializer-direct-methods spec) (remhash spec *eql-specializer-hash*))) (values)) ecl-16.1.2/src/clos/streams.lsp000066400000000000000000000617221266352375300163150ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: CLOS -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; Copyright (c) 2004, Juan Jose Garcia-Ripoll ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. ;;;; The CLOS IO library. (in-package "GRAY") (import 'ext:ansi-stream) ;;; ;;; This is the generic function interface for CLOS streams. ;;; ;;; The following is a port of SBCL's implementation of Gray ;;; Streams. Minor caveats with respect to the proposal are that we ;;; rather keep CLOSE, STREAM-ELEMENT-TYPE, INPUT-STREAM-P, ;;; OUTPUT-STREAM-P and OPEN-STREAM-P these as normal functions that ;;; call the user extensible EXT:STREAM-{CLOSE, ELT-TYPE, INPUT-P, ;;; OUTPUT-P, OPEN-P}. ;;; (defgeneric stream-advance-to-column (stream column) (:documentation "Write enough blank space so that the next character will be written at the specified column. Returns true if the operation is successful, or NIL if it is not supported for this stream. This is intended for use by by PPRINT and FORMAT ~T. The default method uses STREAM-LINE-COLUMN and repeated calls to STREAM-WRITE-CHAR with a #\SPACE character; it returns NIL if STREAM-LINE-COLUMN returns NIL.")) (defgeneric stream-clear-input (stream) (:documentation "This is like CL:CLEAR-INPUT, but for Gray streams, returning NIL. The default method does nothing.")) (defgeneric stream-clear-output (stream) (:documentation "This is like CL:CLEAR-OUTPUT, but for Gray streams: clear the given output STREAM. The default method does nothing.")) (defgeneric close (stream &key abort) (:documentation "Close the given STREAM. No more I/O may be performed, but inquiries may still be made. If :ABORT is true, an attempt is made to clean up the side effects of having created the stream.")) (defgeneric stream-element-type (stream) (:documentation "Return a type specifier for the kind of object returned by the STREAM. The class FUNDAMENTAL-CHARACTER-STREAM provides a default method which returns CHARACTER.")) (defgeneric stream-finish-output (stream) (:documentation "Attempts to ensure that all output sent to the Stream has reached its destination, and only then returns false. Implements FINISH-OUTPUT. The default method does nothing.")) (defgeneric stream-force-output (stream) (:documentation "Attempts to force any buffered output to be sent. Implements FORCE-OUTPUT. The default method does nothing.")) (defgeneric stream-fresh-line (stream) (:documentation "Outputs a new line to the Stream if it is not positioned at the beginning of a line. Returns T if it output a new line, nil otherwise. Used by FRESH-LINE. The default method uses STREAM-START-LINE-P and STREAM-TERPRI.")) (defgeneric input-stream-p (stream) (:documentation "Can STREAM perform input operations?")) (defgeneric stream-p (stream) (:documentation "Is this object a STREAM?")) (defgeneric stream-interactive-p (stream) (:documentation "Is stream interactive (For instance, a tty)?")) (defgeneric stream-line-column (stream) (:documentation "Return the column number where the next character will be written, or NIL if that is not meaningful for this stream. The first column on a line is numbered 0. This function is used in the implementation of PPRINT and the FORMAT ~T directive. For every character output stream class that is defined, a method must be defined for this function, although it is permissible for it to always return NIL.")) (defgeneric stream-listen (stream) #+sb-doc (:documentation "This is used by LISTEN. It returns true or false. The default method uses STREAM-READ-CHAR-NO-HANG and STREAM-UNREAD-CHAR. Most streams should define their own method since it will usually be trivial and will always be more efficient than the default method.")) (defgeneric open-stream-p (stream) (:documentation "Return true if STREAM is not closed. A default method is provided by class FUNDAMENTAL-STREAM which returns true if CLOSE has not been called on the stream.")) (defgeneric output-stream-p (stream) (:documentation "Can STREAM perform output operations?")) (defgeneric stream-peek-char (stream) (:documentation "This is used to implement PEEK-CHAR; this corresponds to PEEK-TYPE of NIL. It returns either a character or :EOF. The default method calls STREAM-READ-CHAR and STREAM-UNREAD-CHAR.")) (defgeneric stream-read-byte (stream) (:documentation "Used by READ-BYTE; returns either an integer, or the symbol :EOF if the stream is at end-of-file.")) (defgeneric stream-read-char (stream) (:documentation "Read one character from the stream. Return either a character object, or the symbol :EOF if the stream is at end-of-file. Every subclass of FUNDAMENTAL-CHARACTER-INPUT-STREAM must define a method for this function.")) (defgeneric stream-read-char-no-hang (stream) (:documentation "This is used to implement READ-CHAR-NO-HANG. It returns either a character, or NIL if no input is currently available, or :EOF if end-of-file is reached. The default method provided by FUNDAMENTAL-CHARACTER-INPUT-STREAM simply calls STREAM-READ-CHAR; this is sufficient for file streams, but interactive streams should define their own method.")) (defgeneric stream-read-line (stream) (:documentation "This is used by READ-LINE. A string is returned as the first value. The second value is true if the string was terminated by end-of-file instead of the end of a line. The default method uses repeated calls to STREAM-READ-CHAR.")) (defgeneric stream-read-sequence (stream sequence &optional start end) (:documentation "This is like CL:READ-SEQUENCE, but for Gray streams.")) (defgeneric stream-start-line-p (stream) (:documentation "Is STREAM known to be positioned at the beginning of a line? It is permissible for an implementation to always return NIL. This is used in the implementation of FRESH-LINE. Note that while a value of 0 from STREAM-LINE-COLUMN also indicates the beginning of a line, there are cases where STREAM-START-LINE-P can be meaningfully implemented although STREAM-LINE-COLUMN can't be. For example, for a window using variable-width characters, the column number isn't very meaningful, but the beginning of the line does have a clear meaning. The default method for STREAM-START-LINE-P on class FUNDAMENTAL-CHARACTER-OUTPUT-STREAM uses STREAM-LINE-COLUMN, so if that is defined to return NIL, then a method should be provided for either STREAM-START-LINE-P or STREAM-FRESH-LINE.")) (defgeneric stream-terpri (stream) (:documentation "Writes an end of line, as for TERPRI. Returns NIL. The default method does (STREAM-WRITE-CHAR stream #\NEWLINE).")) (defgeneric stream-unread-char (stream character) (:documentation "Un-do the last call to STREAM-READ-CHAR, as in UNREAD-CHAR. Return NIL. Every subclass of FUNDAMENTAL-CHARACTER-INPUT-STREAM must define a method for this function.")) (defgeneric stream-write-byte (stream integer) (:documentation "Implements WRITE-BYTE; writes the integer to the stream and returns the integer as the result.")) (defgeneric stream-write-char (stream character) (:documentation "Write CHARACTER to STREAM and return CHARACTER. Every subclass of FUNDAMENTAL-CHARACTER-OUTPUT-STREAM must have a method defined for this function.")) (defgeneric stream-write-string (stream string &optional start end) (:documentation "This is used by WRITE-STRING. It writes the string to the stream, optionally delimited by start and end, which default to 0 and NIL. The string argument is returned. The default method provided by FUNDAMENTAL-CHARACTER-OUTPUT-STREAM uses repeated calls to STREAM-WRITE-CHAR.")) (defgeneric stream-write-sequence (stream sequence &optional start end) (:documentation "This is like CL:WRITE-SEQUENCE, but for Gray streams.")) (defgeneric stream-file-position (stream &optional position) (:documentation "This is like CL:FILE-POSITION, but for Gray streams.")) (defgeneric stream-file-descriptor (stream &optional direction) (:documentation "Return the file-descriptor underlaying STREAM, or NIL if not available. DIRECTION must be either :INPUT, or :OUTPUT and is supposed to discriminate in case STREAM is a bidirectional stream. DIRECTION is supposed to default to :INPUT. An error is signaled if DIRECTION is :INPUT (:OUTPUT), and STREAM is not an input (output) stream. A system-provided :BEFORE method handles this case; user methods do not need to take care of it. In case STREAM-FILE-DESCRIPTOR is not implemented for STREAM, an error is signaled. That is, users must add methods to explicitly decline by returning NIL.")) ;;; ;;; Our class hierarchy looks like the one from Gray streams ;;; ;;; character output streams ;;; ;;; A character output stream can be created by defining a class that ;;; includes FUNDAMENTAL-CHARACTER-OUTPUT-STREAM and defining methods ;;; for the generic functions below. ;;; ;;; binary streams ;;; ;;; Binary streams can be created by defining a class that includes ;;; either FUNDAMENTAL-BINARY-INPUT-STREAM or ;;; FUNDAMENTAL-BINARY-OUTPUT-STREAM (or both) and defining a method ;;; for STREAM-ELEMENT-TYPE and for one or both of the following ;;; generic functions. ;;; (defclass fundamental-stream (standard-object stream) ((open-p :initform t :accessor open-stream-p)) (:documentation "the base class for all CLOS streams")) (defclass fundamental-input-stream (fundamental-stream) nil) (defclass fundamental-output-stream (fundamental-stream) nil) (defclass fundamental-character-stream (fundamental-stream) nil) (defclass fundamental-binary-stream (fundamental-stream) nil) (defclass fundamental-character-input-stream (fundamental-input-stream fundamental-character-stream) nil) (defclass fundamental-character-output-stream (fundamental-output-stream fundamental-character-stream) nil) (defclass fundamental-binary-input-stream (fundamental-input-stream fundamental-binary-stream) nil) (defclass fundamental-binary-output-stream (fundamental-output-stream fundamental-binary-stream) nil) ;;; ;;; The following methods constitute default implementations. ;;; (defun bug-or-error (stream fun) (declare (si::c-local)) (if (typep stream 'stream) (error "The stream ~S has no suitable method for ~S." stream fun) (error 'type-error :datum stream :expected-type 'stream))) ;; STREAM-ADVANCE-TO-COLUMN (defmethod stream-advance-to-column ((stream fundamental-character-output-stream) column) (let ((current-column (stream-line-column stream))) (when current-column (let ((fill (- column current-column))) (dotimes (i fill) (stream-write-char stream #\Space))) T))) ;; CLEAR-INPUT (defmethod stream-clear-input ((stream fundamental-character-input-stream)) (declare (ignore stream)) nil) (defmethod stream-clear-input ((stream ansi-stream)) (cl:clear-input stream)) (defmethod stream-clear-input ((stream t)) (bug-or-error stream 'stream-clear-input)) ;; CLEAR-OUTPUT (defmethod stream-clear-output ((stream fundamental-output-stream)) (declare (ignore stream)) nil) (defmethod stream-clear-output ((stream ansi-stream)) (cl:clear-output stream)) (defmethod stream-clear-output ((stream t)) (bug-or-error stream 'stream-clear-output)) ;; CLOSE (defmethod close ((stream fundamental-stream) &key abort) (declare (ignore abort)) (setf (open-stream-p stream) nil) t) (defmethod close ((stream ansi-stream) &key abort) (cl:close stream :abort abort)) (defmethod close ((stream stream) &key abort) (declare (ignore abort)) (bug-or-error stream 'close)) ;; STREAM-ELEMENT-TYPE (defmethod stream-element-type ((stream fundamental-character-stream)) (declare (ignore stream)) 'character) (defmethod stream-element-type ((stream ansi-stream)) (cl:stream-element-type stream)) (defmethod stream-element-type ((stream t)) (bug-or-error stream 'stream-element-type)) ;; FINISH-OUTPUT (defmethod stream-finish-output ((stream fundamental-output-stream)) (declare (ignore stream)) nil) (defmethod stream-finish-output ((stream ansi-stream)) (cl:finish-output stream)) (defmethod stream-finish-output ((stream t)) (bug-or-error stream 'stream-finish-output)) ;; FORCE-OUTPUT (defmethod stream-force-output ((stream fundamental-output-stream)) (declare (ignore stream)) nil) (defmethod stream-force-output ((stream ansi-stream)) (cl:force-output stream)) (defmethod stream-force-output ((stream t)) (bug-or-error stream 'stream-force-output)) ;; FRESH-LINE (defmethod stream-fresh-line ((stream fundamental-character-output-stream)) (unless (stream-start-line-p stream) (stream-terpri stream) t)) (defmethod stream-fresh-line ((stream ansi-stream)) (cl:fresh-line stream)) ;; INPUT-STREAM-P (defmethod input-stream-p ((stream fundamental-stream)) (declare (ignore stream)) nil) (defmethod input-stream-p ((stream fundamental-input-stream)) (declare (ignore stream)) t) (defmethod input-stream-p ((stream ansi-stream)) (cl:input-stream-p stream)) (defmethod input-stream-p ((stream t)) (bug-or-error stream 'input-stream-p)) ;; INTERACTIVE-STREAM-P (defmethod stream-interactive-p ((stream ansi-stream)) (cl:interactive-stream-p stream)) (defmethod stream-interactive-p ((stream t)) (bug-or-error stream 'stream-interactive-p)) ;; LINE-COLUMN (defmethod stream-line-column ((stream fundamental-character-output-stream)) (declare (ignore stream)) nil) ;; LISTEN (defmethod stream-listen ((stream fundamental-character-input-stream)) (let ((char (stream-read-char-no-hang stream))) (when (characterp char) (stream-unread-char stream char) t))) (defmethod stream-listen ((stream ansi-stream)) (cl:listen stream)) (defmethod stream-listen ((stream t)) (bug-or-error stream 'stream-listen)) ;; OPEN-STREAM-P (defmethod open-stream-p ((stream ansi-stream)) (cl:open-stream-p stream)) (defmethod open-stream-p ((stream t)) (bug-or-error stream 'open-stream-p)) ;; OUTPUT-STREAM-P (defmethod output-stream-p ((stream fundamental-stream)) (declare (ignore stream)) nil) (defmethod output-stream-p ((stream fundamental-output-stream)) (declare (ignore stream)) t) (defmethod output-stream-p ((stream ansi-stream)) (cl:output-stream-p stream)) (defmethod output-stream-p ((stream t)) (bug-or-error stream 'output-stream-p)) ;; PEEK-CHAR (defmethod stream-peek-char ((stream fundamental-character-input-stream)) (let ((char (stream-read-char stream))) (unless (eq char :eof) (stream-unread-char stream char)) char)) (defmethod stream-peek-char ((stream ansi-stream)) (cl:peek-char stream)) (defmethod stream-peek-char ((stream t)) (bug-or-error stream 'stream-peek-char)) ;; READ-BYTE (defmethod stream-read-byte ((stream ansi-stream)) (cl:read-byte stream)) (defmethod stream-read-byte ((stream t)) (bug-or-error stream 'stream-read-byte)) ;; READ-CHAR (defmethod stream-read-char ((stream ansi-stream)) (cl:read-char stream)) (defmethod stream-read-char ((stream t)) (bug-or-error stream 'stream-read-char)) ;; UNREAD-CHAR (defmethod stream-unread-char ((stream ansi-stream) character) (cl:unread-char character stream)) (defmethod stream-unread-char ((stream ansi-stream) character) (declare (ignore character)) (bug-or-error stream 'stream-unread-char)) ;; READ-CHAR-NO-HANG (defmethod stream-read-char-no-hang ((stream fundamental-character-input-stream)) (stream-read-char stream)) (defmethod stream-read-char-no-hang ((stream ansi-stream)) (cl:read-char-no-hang stream)) (defmethod stream-read-char-no-hang ((stream t)) (bug-or-error stream 'stream-read-char-no-hang)) ;; READ-LINE (defmethod stream-read-line ((stream fundamental-character-input-stream)) (let ((res (make-string 80)) (len 80) (index 0)) (loop (let ((ch (stream-read-char stream))) (cond ((eq ch :eof) (return (values (si::shrink-vector res index) t))) (t (when (char= ch #\newline) (return (values (si::shrink-vector res index) nil))) (when (= index len) (setq len (* len 2)) (let ((new (make-string len))) (replace new res) (setq res new))) (setf (schar res index) ch) (incf index))))))) (defmethod stream-read-line ((stream ansi-stream)) (cl:read-line stream)) (defmethod stream-read-line ((stream t)) (bug-or-error stream 'stream-read-line)) ;; READ-SEQUENCE (defmethod stream-read-sequence ((stream fundamental-character-input-stream) sequence &optional (start 0) (end nil)) (si::do-read-sequence sequence stream start end)) (defmethod stream-read-sequence ((stream fundamental-binary-input-stream) sequence &optional (start 0) (end nil)) (si::do-read-sequence sequence stream start end)) (defmethod stream-read-sequence ((stream ansi-stream) sequence &optional (start 0) (end nil)) (si:do-read-sequence stream sequence start end)) (defmethod stream-read-sequence ((stream t) sequence &optional start end) (declare (ignore sequence start end)) (bug-or-error stream 'stream-read-sequence)) ;; START-LINE-P (defmethod stream-start-line-p ((stream fundamental-character-output-stream)) (eql (stream-line-column stream) 0)) ;; FILE-POSITION (defmethod stream-file-position ((stream ansi-stream) &optional position) (file-position stream position)) (defmethod stream-file-position ((stream t) &optional position) (declare (ignore stream position)) nil) ;; STREAM-P (defmethod streamp ((stream stream)) (declare (ignore stream)) t) (defmethod streamp ((stream t)) (declare (ignore stream)) nil) ;; WRITE-BYTE (defmethod stream-write-byte ((stream ansi-stream) integer) (cl:write-byte integer stream)) (defmethod stream-write-byte ((stream t) integer) (declare (ignore integer)) (bug-or-error stream 'stream-write-byte)) ;; WRITE-CHAR (defmethod stream-write-char ((stream ansi-stream) character) (cl:write-char character stream)) (defmethod stream-write-char ((stream t) character) (declare (ignore character)) (bug-or-error stream 'stream-write-char)) ;; WRITE-SEQUENCE (defmethod stream-write-sequence ((stream fundamental-character-output-stream) sequence &optional (start 0) end) (si::do-write-sequence sequence stream start end)) (defmethod stream-write-sequence ((stream fundamental-binary-output-stream) sequence &optional (start 0) end) (si::do-write-sequence sequence stream start end)) (defmethod stream-write-sequence ((stream ansi-stream) sequence &optional (start 0) end) (si::do-write-sequence sequence stream start end)) (defmethod stream-write-sequence ((stream t) sequence &optional start end) (declare (ignore sequence start end)) (bug-or-error stream 'stream-write-sequence)) ;; WRITE-STRING (defmethod stream-write-string ((stream fundamental-character-output-stream) string &optional (start 0) end) (declare (type t stream) ; check for c::stream-designator ignored (string string) (fixnum start) (ext:check-arguments-type)) (let ((end (or end (length string)))) (declare (fixnum end)) (do ((pos start (1+ pos))) ((>= pos end)) (declare (type si::index pos)) (stream-write-char stream (aref string pos)))) string) (defmethod stream-write-string ((stream ansi-stream) string &optional (start 0) end) (cl:write-string string stream :start start :end end)) (defmethod stream-write-string ((stream t) string &optional start end) (declare (ignore string start end)) (bug-or-error stream 'stream-write-string)) ;; TERPRI (defmethod stream-terpri ((stream fundamental-character-output-stream)) (stream-write-char stream #\Newline)) (defmethod stream-terpri ((stream ansi-stream)) (cl:terpri stream)) (defmethod stream-terpri ((stream t)) (bug-or-error stream 'stream-terpri)) ;;; FILE-DESCRIPTOR (defmethod stream-file-descriptor :before (stream &optional (direction :input)) (multiple-value-bind (predicate kind) (case direction (:input (values 'input-stream-p "input")) (:output (values 'output-stream-p "output")) (t (error 'simple-type-error :format-control "Not a valid direction, ~S; must be one of ~ :INPUT or :OUTPUT." :format-arguments (list direction) :datum direction :expected-type '(member :input :output)))) (unless (funcall predicate stream) (error 'simple-type-error :format-control "Not an ~A stream, ~S, although ~S ~ was provided as DIRECTION." :format-arguments (list kind stream direction) :datum stream :expected-type `(satisfies ,predicate))))) (defmethod stream-file-descriptor (stream &optional direction) (declare (ignore direction)) (bug-or-error stream 'stream-file-descriptor)) (defmethod stream-file-descriptor ((stream two-way-stream) &optional (direction :input)) (stream-file-descriptor (case direction (:input (two-way-stream-input-stream stream)) (:output (two-way-stream-output-stream stream))) direction)) (defmethod stream-file-descriptor ((stream file-stream) &optional (direction :input)) (declare (ignore direction)) (si:file-stream-fd stream)) ;;; Setup (eval-when (:compile-toplevel :execute) (defconstant +conflicting-symbols+ '(cl:close cl:stream-element-type cl:input-stream-p cl:open-stream-p cl:output-stream-p cl:streamp))) (let ((p (find-package "GRAY"))) (export '(nil) p) (do-external-symbols (s (find-package "COMMON-LISP")) (unless (member s '#.+conflicting-symbols+) (export s p)))) ;;; Redefining the IO functions ;; ;; I guess that because of efficiency reasons most of the IO functions ;; in CL are normal functions (ie. not generic functions); but that ;; doesn't work with packages like FLEXI-STREAMS that want to define ;; new stream types that work with the same symbols from CL. ;; ;; TRIVIAL-GRAY-STREAMS tries to unify that mess across different ;; implementations, by importing most of (for ECL) GRAY into ;; IMPL-SPECIFIC-GRAY, importing from I-S-G into T-G-S, and ;; overloading/extending there where necessary. ;; ;; ;; REDEFINE-CL-FUNCTIONS should now make the functions that are bound ;; to CL symbols generic functions. ;; ;; ;; So... ;; ;; CL has a function ;; GRAY has a function ;; ;; TRIVIAL-GRAY-STREAMS imports from GRAY ;; ;; But calling eg. CL:FILE-POSITION should make use of all the methods ;; defined on T-G-S:STREAMS-FILE-POSITION ... ;; (defun %redefine-cl-functions (cl-symbol gray-symbol gray-package) (unless (typep (fdefinition cl-symbol) 'generic-function) (let ((gf (fdefinition gray-symbol))) ;; Given a symbol in CL, and one in GRAY, we want to keep the CL ;; symbol (in case there are references to it stored somewhere), ;; but it shall get the generic-function ... (setf (fdefinition cl-symbol) gf) ;; and become EQ to the GRAY symbol. ;; ;; But: unintern/import removes the package from the symbol used ;; as name by the GF, making it equivalent to a GENSYM - and ;; then no new methods can be registered for it ... ;; ;; For same symbol-names, we can unintern/import/export; ;; for different symbol-names, we can only copy the fdefinition. (when (string= (symbol-name cl-symbol) (symbol-name gray-symbol)) (unintern gray-symbol gray-package) (import cl-symbol gray-package) (export cl-symbol gray-package)) ;; so now make the GF accessible again (setf (slot-value gf 'clos::name) cl-symbol)))) (defun redefine-cl-functions () "Some functions in CL package are expected to be generic. We make them so." (let ((x (si::package-lock "COMMON-LISP" nil)) (gray-package (find-package "GRAY"))) (loop for cl-symbol in '#.+conflicting-symbols+ for gray-symbol = (find-symbol (symbol-name cl-symbol) gray-package) do (%redefine-cl-functions cl-symbol gray-symbol gray-package)) ;; things that are called differently (%redefine-cl-functions 'cl:file-position 'gray:stream-file-position gray-package) (si::package-lock "COMMON-LISP" x) nil)) (setf *clos-booted* t) ecl-16.1.2/src/clos/walk.lsp000066400000000000000000001631701266352375300155750ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: WALKER ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;; ;;; ************************************************************************* ;;; Copyright (c) 1985, 1986, 1987, 1988, 1989, 1990 Xerox Corporation. ;;; All rights reserved. ;;; ;;; Use and copying of this software and preparation of derivative works ;;; based upon this software are permitted. Any distribution of this ;;; software or derivative works must comply with all applicable United ;;; States export control laws. ;;; ;;; This software is made available AS IS, and Xerox Corporation makes no ;;; warranty about the software, its performance or its conformity to any ;;; specification. ;;; ;;; Any person obtaining a copy of this software is requested to send their ;;; name and post office or electronic mail address to: ;;; CommonLoops Coordinator ;;; Xerox PARC ;;; 3333 Coyote Hill Rd. ;;; Palo Alto, CA 94304 ;;; (or send Arpanet mail to CommonLoops-Coordinator.pa@Xerox.arpa) ;;; ;;; Suggestions, comments and requests for improvements are also welcome. ;;; ************************************************************************* ;;; ;;; A simple code walker, based IN PART on: (roll the credits) ;;; Larry Masinter's Masterscope ;;; Moon's Common Lisp code walker ;;; Gary Drescher's code walker ;;; Larry Masinter's simple code walker ;;; . ;;; . ;;; boy, thats fair (I hope). ;;; ;;; For now at least, this code walker really only does what PCL needs it to ;;; do. Maybe it will grow up someday. ;;; ;;; ;;; This code walker used to be completely portable. Now it is just "Real ;;; easy to port". This change had to happen because the hack that made it ;;; completely portable kept breaking in different releases of different ;;; Common Lisps, and in addition it never worked entirely anyways. So, ;;; its now easy to port. To port this walker, all you have to write is one ;;; simple macro and two simple functions. These macros and functions are ;;; used by the walker to manipluate the macroexpansion environments of ;;; the Common Lisp it is running in. ;;; ;;; The code which implements the macroexpansion environment manipulation ;;; mechanisms is in the first part of the file, the real walker follows it. ;;; ;;; ;;; The user entry points are walk-form and nested-walked-form. In addition, ;;; it is legal for user code to call the variable information functions: ;;; variable-lexical-p, variable-special-p and variable-class. Some users ;;; will need to call define-walker-template, they will have to figure that ;;; out for themselves. ;;; (defpackage "WALKER" (:export define-walker-template walk-form walk-form-expand-macros-p #-ecl nested-walk-form variable-lexical-p variable-special-p *variable-declarations* variable-declaration macroexpand-all ) (:import-from "SI" "GET-SYSPROP" "PUT-SYSPROP")) (in-package "WALKER") (declaim (notinline note-lexical-binding walk-bindings-1 walk-let/let* walk-form-internal)) (push :walker *features*) ;;; ;;; On the following pages are implementations of the implementation specific ;;; environment hacking functions. ;;; ;;; This code just hacks 'macroexpansion environments'. That is, it is only ;;; concerned with the function binding of symbols in the environment. The ;;; walker needs to be able to tell if the symbol names a lexical macro or ;;; function, and it needs to be able to build environments which contain ;;; lexical macro or function bindings. It must be able, when walking a ;;; macrolet, flet or labels form to construct an environment which reflects ;;; the bindings created by that form. Note that the environment created ;;; does NOT have to be sufficient to evaluate the body, merely to walk its ;;; body. This means that definitions do not have to be supplied for lexical ;;; functions, only the fact that that function is bound is important. For ;;; macros, the macroexpansion function must be supplied. ;;; ;;; This code is organized in a way that lets it work in implementations that ;;; stack cons their environments. That is reflected in the fact that the ;;; only operation that lets a user build a new environment is a with-body ;;; macro which executes its body with the specified symbol bound to the new ;;; environment. No code in this walker or in PCL will hold a pointer to ;;; these environments after the body returns. Other user code is free to do ;;; so in implementations where it works, but that code is not considered ;;; portable. ;;; ;;; There are 3 environment hacking tools. One macro which is used for ;;; creating new environments, and two functions which are used to access the ;;; bindings of existing environments. ;;; ;;; WITH-AUGMENTED-ENVIRONMENT ;;; ;;; ENVIRONMENT-FUNCTION ;;; ;;; ENVIRONMENT-MACRO ;;; (defun unbound-lexical-function (&rest args) (declare (ignore args)) (error "The evaluator was called to evaluate a form in a macroexpansion~%~ environment constructed by the PCL portable code walker. These~%~ environments are only useful for macroexpansion, they cannot be~%~ used for evaluation.~%~ This error should never occur when using PCL.~%~ This most likely source of this error is a program which tries to~%~ to use the PCL portable code walker to build its own evaluator.")) ;;; ;;; In Kyoto Common Lisp, the macroexpansion environment is a three element ;;; list. The second element describes lexical functions and macros. The ;;; function entries in this list have the form ;;; ( FUNCTION ) ;;; The macro entries have the form ;;; ( MACRO ). ;;; ;;; (defmacro with-augmented-environment ((new-env old-env &key functions macros) &body body) `(let ((,new-env (with-augmented-environment-internal ,old-env ,functions ,macros))) ,@body)) (defun with-augmented-environment-internal (env functions macros) (let* ((vars (car env)) (funs (cdr env))) (dolist (f functions) (push `(,(car f) function ,#'unbound-lexical-function) funs)) (dolist (m macros) (push `(,(car m) macro ,(second m)) funs)) (cons vars funs))) #+nil (defun environment-function (env fn) (when env (let ((entry (assoc fn (cdr env)))) (and entry (eq (second entry) 'FUNCTION) (third entry))))) (defun environment-macro (env macro) (declare (si::c-local)) (when env (let ((entry (assoc macro (cdr env)))) (and entry (eq (second entry) 'MACRO) (third entry))))) (defmacro with-new-definition-in-environment ((new-env old-env macrolet/flet/labels-form) &body body) (let* ((functions (make-symbol "Functions")) (macros (make-symbol "Macros"))) `(let ((,functions ()) (,macros ())) (ecase (car ,macrolet/flet/labels-form) ((FLET LABELS) (dolist (fn (second ,macrolet/flet/labels-form)) (push fn ,functions))) ((MACROLET) (dolist (mac (second ,macrolet/flet/labels-form)) (push (list (car mac) (convert-macro-to-lambda (second mac) (cddr mac) (string (car mac)))) ,macros)))) (with-augmented-environment (,new-env ,old-env :functions ,functions :macros ,macros) ,@body)))) (defun convert-macro-to-lambda (llist body &optional (name "Dummy Macro")) (declare (si::c-local)) (let ((gensym (make-symbol name))) (eval `(defmacro ,gensym ,llist ,@body)) (macro-function gensym))) ;;; ;;; Now comes the real walker. ;;; ;;; As the walker walks over the code, it communicates information to itself ;;; about the walk. This information includes the walk function, variable ;;; bindings, declarations in effect etc. This information is inherently ;;; lexical, so the walker passes it around in the actual environment the ;;; walker passes to macroexpansion functions. This is what makes the ;;; nested-walk-form facility work properly. ;;; (defmacro walker-environment-bind ((var env &rest key-args) &body body) `(with-augmented-environment (,var ,env :macros (walker-environment-bind-1 ,env ,.key-args)) .,body)) (defvar *key-to-walker-environment* (gensym)) (defun env-lock (env) (declare (si::c-local)) (environment-macro env *key-to-walker-environment*)) (defun walker-environment-bind-1 (env &key (walk-function nil wfnp) (walk-form nil wfop) (declarations nil decp) (lexical-variables nil lexp)) (declare (si::c-local)) (let ((lock (env-lock env))) (list (list *key-to-walker-environment* (list (if wfnp walk-function (car lock)) (if wfop walk-form (second lock)) (if decp declarations (third lock)) (if lexp lexical-variables (fourth lock))))))) (defun env-walk-function (env) (declare (si::c-local)) (first (env-lock env))) (defun env-walk-form (env) (declare (si::c-local)) (second (env-lock env))) (defun env-declarations (env) (declare (si::c-local)) (third (env-lock env))) (defun env-lexical-variables (env) (declare (si::c-local)) (fourth (env-lock env))) (defun note-declaration (declaration env) (declare (si::c-local)) (push declaration (third (env-lock env)))) (defun note-lexical-binding (thing env) (push (list thing :LEXICAL-VAR) (fourth (env-lock env)))) (defun VARIABLE-LEXICAL-P (var env) (declare (si::c-local)) (let ((entry (member var (env-lexical-variables env) :key #'car))) (when (eq (cadar entry) :LEXICAL-VAR) entry))) (defun variable-symbol-macro-p (var env) (declare (si::c-local)) (let ((entry (member var (env-lexical-variables env) :key #'car))) (when (eq (cadar entry) :macro) entry))) (defvar *VARIABLE-DECLARATIONS* '(SPECIAL TYPE)) ; Beppe (defun VARIABLE-DECLARATION (declaration var env) (if (not (member declaration *variable-declarations*)) (error "~S is not a recognized variable declaration." declaration) (let ((id (or (variable-lexical-p var env) var))) (dolist (decl (env-declarations env)) (when (and (eq (car decl) declaration) (or (eq (second decl) id) (and (eq 'TYPE (car decl)) (member var (cddr decl) :test #'eq)))) ; Beppe (return decl)))))) (defun VARIABLE-SPECIAL-P (var env) (or (not (null (variable-declaration 'SPECIAL var env))) (variable-globally-special-p var))) ;;; ;;; VARIABLE-GLOBALLY-SPECIAL-P is used to ask if a variable has been ;;; declared globally special. Any particular CommonLisp implementation ;;; should customize this function accordingly and send their customization ;;; back. ;;; ;;; The default version of variable-globally-special-p is probably pretty ;;; slow, so it uses *globally-special-variables* as a cache to remember ;;; variables that it has already figured out are globally special. ;;; ;;; This would need to be reworked if an unspecial declaration got added to ;;; Common Lisp. ;;; ;;; Common Lisp nit: ;;; variable-globally-special-p should be defined in Common Lisp. ;;; (defun variable-globally-special-p (symbol) (si:specialp symbol)) ;; ;;;;;; Handling of special forms (the infamous 24). ;; ;;; ;;; and I quote... ;;; ;;; The set of special forms is purposely kept very small because ;;; any program analyzing program (read code walker) must have ;;; special knowledge about every type of special form. Such a ;;; program needs no special knowledge about macros... ;;; ;;; So all we have to do here is a define a way to store and retrieve ;;; templates which describe how to walk the 24 special forms and we are all ;;; set... ;;; ;;; Well, its a nice concept, and I have to admit to being naive enough that ;;; I believed it for a while, but not everyone takes having only 24 special ;;; forms as seriously as might be nice. There are (at least) 3 ways to ;;; lose: ;; ;;; 1 - Implementation x implements a Common Lisp special form as a macro ;;; which expands into a special form which: ;;; - Is a common lisp special form (not likely) ;;; - Is not a common lisp special form (on the 3600 IF --> COND). ;;; ;;; * We can safe ourselves from this case (second subcase really) by ;;; checking to see if there is a template defined for something ;;; before we check to see if we we can macroexpand it. ;;; ;;; 2 - Implementation x implements a Common Lisp macro as a special form. ;;; ;;; * This is a screw, but not so bad, we save ourselves from it by ;;; defining extra templates for the macros which are *likely* to ;;; be implemented as special forms. (DO, DO* ...) ;;; ;;; 3 - Implementation x has a special form which is not on the list of ;;; Common Lisp special forms. ;;; ;;; * This is a bad sort of a screw and happens more than I would like ;;; to think, especially in the implementations which provide more ;;; than just Common Lisp (3600, Xerox etc.). ;;; The fix is not terribly staisfactory, but will have to do for ;;; now. There is a hook in get walker-template which can get a ;;; template from the implementation's own walker. That template ;;; has to be converted, and so it may be that the right way to do ;;; this would actually be for that implementation to provide an ;;; interface to its walker which looks like the interface to this ;;; walker. ;;; (eval-when (#-cross compile load eval) (defmacro get-walker-template-internal (x) ;Has to be inside eval-when because `(get-sysprop ,x 'WALKER-TEMPLATE)) ;Golden Common Lisp doesn't hack ;compile time definition of macros ;right for setf. (defmacro define-walker-template (name &optional (template '(NIL REPEAT (EVAL)))) `(eval-when (load eval) (put-sysprop ',name 'WALKER-TEMPLATE ',template))) ) (defun get-walker-template (x) (cond ((symbolp x) (or (get-walker-template-internal x) (get-implementation-dependent-walker-template x))) ((and (listp x) (eq (car x) 'LAMBDA)) '(LAMBDA REPEAT (EVAL))) (t (error "Can't get template for ~S" x)))) (defun get-implementation-dependent-walker-template (x) (declare (ignore x)) ()) ;; ;;;;;; The actual templates ;; (define-walker-template BLOCK (NIL NIL REPEAT (EVAL))) (define-walker-template CATCH (NIL EVAL REPEAT (EVAL))) (define-walker-template COMPILER-LET walk-compiler-let) (define-walker-template DECLARE walk-unexpected-declare) (define-walker-template EVAL-WHEN (NIL QUOTE REPEAT (EVAL))) (define-walker-template FLET walk-flet) (define-walker-template FUNCTION (NIL CALL)) (define-walker-template GO (NIL QUOTE)) (define-walker-template IF walk-if) (define-walker-template LABELS walk-labels) (define-walker-template LAMBDA walk-lambda) (define-walker-template LET walk-let) (define-walker-template LET* walk-let*) (define-walker-template LOCALLY walk-locally) (define-walker-template MACROLET walk-macrolet) (define-walker-template MULTIPLE-VALUE-CALL (NIL EVAL REPEAT (EVAL))) (define-walker-template MULTIPLE-VALUE-PROG1 (NIL RETURN REPEAT (EVAL))) (define-walker-template MULTIPLE-VALUE-SETQ walk-multiple-value-setq) (define-walker-template MULTIPLE-VALUE-BIND walk-multiple-value-bind) (define-walker-template PROGN (NIL REPEAT (EVAL))) (define-walker-template PROGV (NIL EVAL EVAL REPEAT (EVAL))) (define-walker-template QUOTE (NIL QUOTE)) (define-walker-template RETURN-FROM (NIL QUOTE REPEAT (RETURN))) (define-walker-template SETQ walk-setq) (define-walker-template SYMBOL-MACROLET walk-symbol-macrolet) (define-walker-template TAGBODY walk-tagbody) (define-walker-template THE (NIL QUOTE EVAL)) (define-walker-template THROW (NIL EVAL EVAL)) (define-walker-template UNWIND-PROTECT (NIL RETURN REPEAT (EVAL))) ;;; The new special form. ;(define-walker-template pcl::LOAD-TIME-EVAL (NIL EVAL)) ;;; ;;; And the extra templates... ;;; #+ecl (define-walker-template DOTIMES walk-dotimes/dolist) #+ecl (define-walker-template DOLIST walk-dotimes/dolist) #+ecl (define-walker-template WHEN walk-when/unless) #+ecl (define-walker-template UNLESS walk-when/unless) (define-walker-template DO walk-do) (define-walker-template DO* walk-do*) (define-walker-template PROG walk-prog) (define-walker-template PROG* walk-prog*) (define-walker-template COND (NIL REPEAT ((TEST REPEAT (EVAL))))) (define-walker-template ext::lambda-block walk-named-lambda) ;Not really right, but ;we don't hack block ;names anyways. #+ecl (define-walker-template ffi::c-inline walk-c-inline) ;;; Controls whether macros are expanded by walk-form (defvar WALK-FORM-EXPAND-MACROS-P nil) (defun macroexpand-all (form &optional environment) (let ((walk-form-expand-macros-p t)) (walk-form form environment))) (defun WALK-FORM (form &optional environment (walk-function #'(lambda (subform context env) (declare (ignore context env)) subform))) (walker-environment-bind (new-env environment :walk-function walk-function) (walk-form-internal form :eval new-env))) ;;; ;;; nested-walk-form provides an interface that allows nested macros, each ;;; of which must walk their body to just do one walk of the body of the ;;; inner macro. That inner walk is done with a walk function which is the ;;; composition of the two walk functions. ;;; ;;; This facility works by having the walker annotate the environment that ;;; it passes to macroexpand-1 to know which form is being macroexpanded. ;;; If then the &whole argument to the macroexpansion function is eq to ;;; the env-walk-form of the environment, nested-walk-form can be certain ;;; that there are no intervening layers and that a nested walk is alright. ;;; ;;; There are some semantic problems with this facility. In particular, if ;;; the outer walk function returns T as its walk-no-more-p value, this will ;;; prevent the inner walk function from getting a chance to walk the subforms ;;; of the form. This is almost never what you want, since it destroys the ;;; equivalence between this nested-walk-form function and two seperate ;;; walk-forms. ;;; #-ecl (defun NESTED-WALK-FORM (whole form &optional environment (walk-function #'(lambda (subform context env) (declare (ignore context env)) subform))) (if (eq whole (env-walk-form environment)) (let ((outer-walk-function (env-walk-function environment))) (throw whole (walk-form form environment #'(lambda (f c e) ;; First loop to make sure the inner walk function ;; has done all it wants to do with this form. ;; Basically, what we are doing here is providing ;; the same contract walk-form-internal normally ;; provides to the inner walk function. (let*((inner-result nil) (inner-no-more-p nil) (outer-result nil) (outer-no-more-p nil)) (loop (multiple-value-setq (inner-result inner-no-more-p) (funcall walk-function f c e)) (cond (inner-no-more-p (return)) ((not (eq inner-result f))) ((not (consp inner-result)) (return)) ((get-walker-template (car inner-result)) (return)) (t (multiple-value-bind (expansion macrop) (walker-environment-bind (new-env e :walk-form inner-result) (macroexpand-1 inner-result new-env)) (if macrop (setq inner-result expansion) (return))))) (setq f inner-result)) (multiple-value-setq (outer-result outer-no-more-p) (funcall outer-walk-function inner-result c e)) (values outer-result (and inner-no-more-p outer-no-more-p))))))) (walk-form form environment walk-function))) ;;; ;;; WALK-FORM-INTERNAL is the main driving function for the code walker. It ;;; takes a form and the current context and walks the form calling itself or ;;; the appropriate template recursively. ;;; ;;; "It is recommended that a program-analyzing-program process a form ;;; that is a list whose car is a symbol as follows: ;;; ;;; 1. If the program has particular knowledge about the symbol, ;;; process the form using special-purpose code. All of the ;;; standard special forms should fall into this category. ;;; 2. Otherwise, if macro-function is true of the symbol apply ;;; either macroexpand or macroexpand-1 and start over. ;;; 3. Otherwise, assume it is a function call. " ;;; (defun walk-form-internal (form context env &aux fn template) ;; First apply the walk-function to perform whatever translation ;; the user wants to this form. If the second value returned ;; by walk-function is T then we don't recurse... (catch form (multiple-value-bind (newform walk-no-more-p) (funcall (env-walk-function env) form context env) (catch newform (cond (walk-no-more-p newform) ((not (eq form newform)) (walk-form-internal newform context env)) ((not (consp newform)) (let ((symmac (car (variable-symbol-macro-p newform env)))) (if symmac (let ((newnewform (walk-form-internal (cddr symmac) context env))) (if (eq newnewform (cddr symmac)) (if walk-form-expand-macros-p newnewform newform) newnewform)) newform))) ((setq template (get-walker-template (setq fn (car newform)))) (if (symbolp template) (funcall template newform context env) (walk-template newform template context env))) (t (multiple-value-bind (newnewform macrop) (walker-environment-bind (new-env env :walk-form newform) (macroexpand-1 newform new-env)) (cond (macrop (let ((newnewnewform (walk-form-internal newnewform context env))) (if (eq newnewnewform newnewform) (if walk-form-expand-macros-p newnewform newform) newnewnewform))) ((and (symbolp fn) (not (fboundp fn)) (special-operator-p fn)) (error "~S is a special form, not defined in the CommonLisp.~%~ manual This code walker doesn't know how to walk it.~%~ Define a template for this special form and try again." fn)) (t ;; Otherwise, walk the form as if its just a standard ;; functioncall using a template for standard function ;; call. (walk-template newnewform '(CALL REPEAT (EVAL)) context env)))))))))) (defun walk-template (form template context env) (declare (si::c-local)) (if (atom template) (ecase template ((EVAL FUNCTION TEST EFFECT RETURN) (walk-form-internal form :EVAL env)) ((QUOTE NIL) form) (SET (walk-form-internal form :SET env)) ((LAMBDA CALL) (cond ((or (symbolp form) (and (listp form) (= (length form) 2) (eq (car form) 'SETF))) form) (t (walk-form-internal form context env))))) (case (car template) (REPEAT (walk-template-handle-repeat form (cdr template) ;; For the case where nothing happens ;; after the repeat optimize out the ;; call to length. (if (null (cddr template)) () (nthcdr (- (length form) (length (cddr template))) form)) context env)) (IF (walk-template form (if (if (listp (second template)) (eval (second template)) (funcall (second template) form)) (third template) (fourth template)) context env)) (REMOTE (walk-template form (second template) context env)) (otherwise (cond ((atom form) form) (t (recons form (walk-template (car form) (car template) context env) (walk-template (cdr form) (cdr template) context env)))))))) (defun walk-template-handle-repeat (form template stop-form context env) (declare (si::c-local)) (if (eq form stop-form) (walk-template form (cdr template) context env) (walk-template-handle-repeat-1 form template (car template) stop-form context env))) (defun walk-template-handle-repeat-1 (form template repeat-template stop-form context env) (declare (si::c-local)) (cond ((null form) ()) ((eq form stop-form) (if (null repeat-template) (walk-template stop-form (cdr template) context env) (error "While handling repeat:~%~ Ran into stop while still in repeat template."))) ((null repeat-template) (walk-template-handle-repeat-1 form template (car template) stop-form context env)) (t (recons form (walk-template (car form) (car repeat-template) context env) (walk-template-handle-repeat-1 (cdr form) template (cdr repeat-template) stop-form context env))))) (defun walk-repeat-eval (form env) (and form (recons form (walk-form-internal (car form) :eval env) (walk-repeat-eval (cdr form) env)))) (defun recons (x car cdr) (if (or (not (eq (car x) car)) (not (eq (cdr x) cdr))) (cons car cdr) x)) (defun relist (x &rest args) (declare (si::c-local)) (if (null args) nil (relist-internal x args nil))) (defun relist* (x &rest args) (declare (si::c-local)) (relist-internal x args 'T)) (defun relist-internal (x args *p) (declare (si::c-local)) (if (null (cdr args)) (if *p (car args) (recons x (car args) nil)) (recons x (car args) (relist-internal (cdr x) (cdr args) *p)))) ;; ;;;;;; Special walkers ;; (defun walk-declarations (body fn env &optional doc-string-p declarations old-body &aux (form (car body)) macrop new-form) (declare (si::c-local)) (cond ((and (stringp form) ;might be a doc string (cdr body) ;isn't the returned value (null doc-string-p) ;no doc string yet (null declarations)) ;no declarations yet (recons body form (walk-declarations (cdr body) fn env t))) ((and (listp form) (eq (car form) 'DECLARE)) ;; Got ourselves a real live declaration. Record it, look for more. (dolist (declaration (cdr form)) (let*((type (car declaration)) (name (second declaration)) (args (cddr declaration))) (if (member type *variable-declarations*) (note-declaration `(,type ,(or (variable-lexical-p name env) name) ,.args) env) (note-declaration declaration env)) (push declaration declarations))) (recons body form (walk-declarations (cdr body) fn env doc-string-p declarations))) ((and form (listp form) (null (get-walker-template (car form))) (progn (multiple-value-setq (new-form macrop) (macroexpand-1 form env)) macrop)) ;; This form was a call to a macro. Maybe it expanded ;; into a declare? Recurse to find out. (walk-declarations (recons body new-form (cdr body)) fn env doc-string-p declarations (or old-body body))) (t ;; Now that we have walked and recorded the declarations, ;; call the function our caller provided to expand the body. ;; We call that function rather than passing the real-body ;; back, because we are RECONSING up the new body. (funcall fn (or old-body body) env)))) (defun walk-unexpected-declare (form context env) (declare (ignore context env) (si::c-local)) (warn "Encountered declare ~S in a place where a declare was not expected." form) form) (defun walk-arglist (arglist context env &optional (destructuringp nil) &aux arg) (declare (si::c-local)) (cond ((null arglist) ()) ((symbolp (setq arg (car arglist))) (or (member arg lambda-list-keywords) (note-lexical-binding arg env)) (recons arglist arg (walk-arglist (cdr arglist) context env (and destructuringp (not (member arg lambda-list-keywords)))))) ((consp arg) (prog1 (recons arglist (if destructuringp (walk-arglist arg context env destructuringp) (relist* arg (car arg) (walk-form-internal (second arg) :eval env) (cddr arg))) (walk-arglist (cdr arglist) context env nil)) (if (symbolp (car arg)) (note-lexical-binding (car arg) env) (note-lexical-binding (cadar arg) env)) (or (null (cddr arg)) (not (symbolp (third arg))) (note-lexical-binding (third arg) env)))) (t (error "Can't understand something in the arglist ~S" arglist)))) (defun walk-let (form context env) (walk-let/let* form context env nil)) (defun walk-let* (form context env) (walk-let/let* form context env t)) (defun walk-prog (form context env) (walk-prog/prog* form context env nil)) (defun walk-prog* (form context env) (walk-prog/prog* form context env t)) (defun walk-do (form context env) (walk-do/do* form context env nil)) (defun walk-do* (form context env) (walk-do/do* form context env t)) (defun walk-let/let* (form context old-env sequentialp) (walker-environment-bind (new-env old-env) (let* ((let/let* (car form)) (bindings (second form)) (body (cddr form)) (walked-bindings (walk-bindings-1 bindings old-env new-env context sequentialp)) (walked-body (walk-declarations body #'walk-repeat-eval new-env))) (relist* form let/let* walked-bindings walked-body)))) (defun walk-locally (form context env) (declare (ignore context)) (let* ((locally (car form)) (body (cdr form)) (walked-body (walk-declarations body #'walk-repeat-eval env))) (relist* form locally walked-body))) (defun walk-prog/prog* (form context old-env sequentialp) (walker-environment-bind (new-env old-env) (let* ((possible-block-name (second form)) (blocked-prog (and (symbolp possible-block-name) (not (eq possible-block-name 'nil))))) (multiple-value-bind (let/let* block-name bindings body) (if blocked-prog (values (car form) (cadr form) (caddr form) (cdddr form)) (values (car form) nil (cadr form) (cddr form))) (let* ((walked-bindings (walk-bindings-1 bindings old-env new-env context sequentialp)) (walked-body (walk-declarations body #'(lambda (real-body real-env) (walk-tagbody-1 real-body context real-env)) new-env))) (if block-name (relist* form let/let* block-name walked-bindings walked-body) (relist* form let/let* walked-bindings walked-body))))))) (defun walk-do/do* (form context old-env sequentialp) (walker-environment-bind (new-env old-env) (let* ((do/do* (car form)) (bindings (second form)) (end-test (third form)) (body (cdddr form)) (walked-bindings (walk-bindings-1 bindings old-env new-env context sequentialp)) (walked-body (walk-declarations body #'walk-repeat-eval new-env))) (relist* form do/do* (walk-bindings-2 bindings walked-bindings context new-env) (walk-template end-test '(TEST REPEAT (EVAL)) context new-env) walked-body)))) #+ecl (defun walk-dotimes/dolist (form context old-env) (walker-environment-bind (new-env old-env) (let* ((dotimes/dolist (car form)) (bindings (second form)) (body (cddr form)) ; This is a hack. We tread BINDINGS as we ; would in a DO/DO* loop. (walked-bindings (walk-bindings-1 bindings old-env new-env context t)) (walked-body (walk-declarations body #'walk-repeat-eval new-env))) (relist* form dotimes/dolist (walk-bindings-2 bindings walked-bindings context new-env) walked-body)))) (defun walk-multiple-value-setq (form context env) (let ((vars (cadr form))) (if (some #'(lambda (var) (variable-symbol-macro-p var env)) vars) (let* ((temps (mapcar #'(lambda (var) (declare (ignore var)) (gensym)) vars)) (sets (mapcar #'(lambda (var temp) `(setq ,var ,temp)) vars temps)) (expanded `(multiple-value-bind ,temps ,(caddr form) ,@sets)) (walked (walk-form-internal expanded context env))) (if (eq walked expanded) form walked)) (walk-template form '(nil (repeat (set)) eval) context env)))) (defun walk-multiple-value-bind (form context old-env) (walker-environment-bind (new-env old-env) (let* ((mvb (car form)) (bindings (second form)) (mv-form (walk-template (third form) 'EVAL context old-env)) (body (cdddr form)) walked-bindings (walked-body (walk-declarations body #'(lambda (real-body real-env) (setq walked-bindings (walk-bindings-1 bindings old-env new-env context nil)) (walk-repeat-eval real-body real-env)) new-env))) (relist* form mvb walked-bindings mv-form walked-body)))) (defun walk-bindings-1 (bindings old-env new-env context sequentialp) (and bindings (let ((binding (car bindings))) (recons bindings (if (symbolp binding) (prog1 binding (note-lexical-binding binding new-env)) (prog1 (relist* binding (car binding) (walk-form-internal (second binding) context (if sequentialp new-env old-env)) (cddr binding)) ;save cddr for DO/DO* ;it is the next value ;form. Don't walk it ;now though. (note-lexical-binding (car binding) new-env))) (walk-bindings-1 (cdr bindings) old-env new-env context sequentialp))))) (defun walk-bindings-2 (bindings walked-bindings context env) (declare (si::c-local)) (and bindings (let ((binding (car bindings)) (walked-binding (car walked-bindings))) (recons bindings (if (symbolp binding) binding (relist* binding (car walked-binding) (second walked-binding) (walk-template (cddr binding) '(EVAL) context env))) (walk-bindings-2 (cdr bindings) (cdr walked-bindings) context env))))) (defun walk-lambda (form context old-env) (walker-environment-bind (new-env old-env) (let* ((arglist (second form)) (body (cddr form)) (walked-arglist (walk-arglist arglist context new-env)) (walked-body (walk-declarations body #'walk-repeat-eval new-env))) (relist* form (car form) walked-arglist walked-body)))) (defun walk-named-lambda (form context old-env) (walker-environment-bind (new-env old-env) (let* ((name (second form)) (arglist (third form)) (body (cdddr form)) (walked-arglist (walk-arglist arglist context new-env)) (walked-body (walk-declarations body #'walk-repeat-eval new-env))) (relist* form (car form) name walked-arglist walked-body)))) (defun walk-setq (form context env) (if (cdddr form) (let* ((expanded (let* ((rforms nil) (tail (cdr form))) (loop (when (null tail) (return (nreverse rforms))) (let ((var (pop tail)) (val (pop tail))) (push `(setq ,var ,val) rforms))))) (walked (walk-repeat-eval expanded env))) (if (eq expanded walked) form `(progn ,@walked))) (let* ((var (cadr form)) (val (caddr form)) (symmac (car (variable-symbol-macro-p var env)))) (if symmac (let* ((expanded `(setf ,(cddr symmac) ,val)) (walked (walk-form-internal expanded context env))) (if (eq expanded walked) form walked)) (relist form 'setq (walk-form-internal var :set env) (walk-form-internal val :eval env)))))) (defun walk-symbol-macrolet (form context old-env) (declare (ignore context)) (let* ((bindings (second form))) (walker-environment-bind (new-env old-env :lexical-variables (append (mapcar #'(lambda (binding) `(,(first binding) :macro . ,(second binding))) bindings) (env-lexical-variables old-env))) (relist* form 'SYMBOL-MACROLET bindings (walk-repeat-eval (cddr form) new-env))))) (defun walk-tagbody (form context env) (recons form (car form) (walk-tagbody-1 (cdr form) context env))) (defun walk-tagbody-1 (form context env) (declare (si::c-local)) (and form (recons form (walk-form-internal (car form) (if (symbolp (car form)) 'QUOTE context) env) (walk-tagbody-1 (cdr form) context env)))) (defun walk-compiler-let (form context old-env) (declare (ignore context)) (let* ((vars ()) (vals ())) (dolist (binding (second form)) (cond ((symbolp binding) (push binding vars) (push nil vals)) (t (push (car binding) vars) (push (eval (second binding)) vals)))) (relist* form (car form) (second form) (progv vars vals (walk-repeat-eval (cddr form) old-env))))) (defun walk-macrolet (form context old-env) (walker-environment-bind (macro-env nil :walk-function (env-walk-function old-env)) (labels ((walk-definitions (definitions) (and definitions (let ((definition (car definitions))) (recons definitions (relist* definition (car definition) (walk-arglist (second definition) context macro-env t) (walk-declarations (cddr definition) #'walk-repeat-eval macro-env)) (walk-definitions (cdr definitions))))))) (with-new-definition-in-environment (new-env old-env form) (relist* form (car form) (walk-definitions (second form)) (walk-declarations (cddr form) #'walk-repeat-eval new-env)))))) (defun walk-flet (form context old-env) (labels ((walk-definitions (definitions) (if (null definitions) () (recons definitions (walk-lambda (car definitions) context old-env) (walk-definitions (cdr definitions)))))) (recons form (car form) (recons (cdr form) (walk-definitions (second form)) (with-new-definition-in-environment (new-env old-env form) (walk-declarations (cddr form) #'walk-repeat-eval new-env)))))) (defun walk-labels (form context old-env) (with-new-definition-in-environment (new-env old-env form) (labels ((walk-definitions (definitions) (if (null definitions) () (recons definitions (walk-lambda (car definitions) context new-env) (walk-definitions (cdr definitions)))))) (recons form (car form) (recons (cdr form) (walk-definitions (second form)) (walk-declarations (cddr form) #'walk-repeat-eval new-env)))))) (defun walk-if (form context env) (let*((predicate (second form)) (arm1 (third form)) (arm2 (if (cddddr form) (progn (warn "In the form:~%~S~%~ IF only accepts three arguments, you are using ~D.~%~ It is true that some Common Lisps support this, but ~ it is not~%~ truly legal Common Lisp. For now, this code ~ walker is interpreting ~%~ the extra arguments as extra else clauses. ~ Even if this is what~%~ you intended, you should fix your source code." form (length (cdr form))) (cons 'PROGN (cdddr form))) (fourth form)))) (relist form 'IF (walk-form-internal predicate context env) (walk-form-internal arm1 context env) (walk-form-internal arm2 context env)))) #+ecl (defun walk-when/unless (form context env) (relist* form (first form) (walk-form-internal (second form) context env) ; predicate (walk-repeat-eval (cddr form) env))) #+ecl (defun walk-c-inline (form context env) (declare (ignore context)) (relist* form (first form) (walk-repeat-eval (second form) env) ; arguments (cddr form))) ; types and flags of the form ;;; ;;; Tests tests tests ;;; #| ;;; ;;; Here are some examples of the kinds of things you should be able to do ;;; with your implementation of the macroexpansion environment hacking ;;; mechanism. ;;; ;;; with-lexical-macros is kind of like macrolet, but it only takes names ;;; of the macros and actual macroexpansion functions to use to macroexpand ;;; them. The win about that is that for macros which want to wrap several ;;; macrolets around their body, they can do this but have the macroexpansion ;;; functions be compiled. See the WITH-RPUSH example. ;;; ;;; If the implementation had a special way of communicating the augmented ;;; environment back to the evaluator that would be totally great. It would ;;; mean that we could just augment the environment then pass control back ;;; to the implementations own compiler or interpreter. We wouldn't have ;;; to call the actual walker. That would make this much faster. Since the ;;; principal client of this is defmethod it would make compiling defmethods ;;; faster and that would certainly be a win. ;;; (defmacro with-lexical-macros (macros &body body &environment old-env) (with-augmented-environment (new-env old-env :macros macros) (walk-form (cons 'PROGN body) new-env))) (defun expand-rpush (form env) `(push ,(third form) ,(second form))) (defmacro with-rpush (&body body) `(with-lexical-macros ,(list (list 'RPUSH #'expand-rpush)) ,@body)) ;;; ;;; Unfortunately, I don't have an automatic tester for the walker. ;;; Instead there is this set of test cases with a description of ;;; how each one should go. ;;; (defmacro take-it-out-for-a-test-walk (form) `(progn (terpri) (terpri) (let ((copy-of-form (copy-tree ',form)) (result (walk-form ',form nil '(lambda (x y env) (format t "~&Form: ~S ~3T Context: ~A" x y) (when (symbolp x) (let ((lexical (variable-lexical-p x env)) (special (variable-special-p x env))) (when lexical (format t ";~3T") (format t "lexically bound")) (when special (format t ";~3T") (format t "declared special")) (when (boundp x) (format t ";~3T") (format t "bound: ~S " (eval x))))) x)))) (cond ((not (equal result copy-of-form)) (format t "~%Warning: Result not EQUAL to copy of start.")) ((not (eq result ',form)) (format t "~%Warning: Result not EQ to copy of start."))) (pprint result) result))) (defmacro foo (&rest ignore) ''GLOBAL-FOO) (defmacro bar (&rest ignore) ''GLOBAL-BAR) (take-it-out-for-a-test-walk (list arg1 arg2 arg3)) (take-it-out-for-a-test-walk (list (cons 1 2) (list 3 4 5))) (take-it-out-for-a-test-walk (progn (foo) (bar 1))) (take-it-out-for-a-test-walk (block block-name a b c)) (take-it-out-for-a-test-walk (block block-name (list a) b c)) (take-it-out-for-a-test-walk (catch catch-tag (list a) b c)) ;;; ;;; This is a fairly simple macrolet case. While walking the body of the ;;; macro, x should be lexically bound. In the body of the macrolet form ;;; itself, x should not be bound. ;;; (take-it-out-for-a-test-walk (macrolet ((foo (x) (list x) ''INNER)) x (foo 1))) ;;; ;;; A slightly more complex macrolet case. In the body of the macro x ;;; should not be lexically bound. In the body of the macrolet form itself ;;; x should be bound. Note that THIS CASE WILL CAUSE AN ERROR when it ;;; tries to macroexpand the call to foo. ;;; (take-it-out-for-a-test-walk (let ((x 1)) (macrolet ((foo () (list x) ''INNER)) x (foo)))) ;;; ;;; A truly hairy use of compiler-let and macrolet. In the body of the ;;; macro x should not be lexically bound. In the body of the macrolet ;;; itself x should not be lexically bound. But the macro should expand ;;; into 1. ;;; (take-it-out-for-a-test-walk (compiler-let ((x 1)) (let ((x 2)) (macrolet ((foo () x)) x (foo))))) (take-it-out-for-a-test-walk (flet ((foo (x) (list x y)) (bar (x) (list x y))) (foo 1))) (take-it-out-for-a-test-walk (let ((y 2)) (flet ((foo (x) (list x y)) (bar (x) (list x y))) (foo 1)))) (take-it-out-for-a-test-walk (labels ((foo (x) (bar x)) (bar (x) (foo x))) (foo 1))) (take-it-out-for-a-test-walk (flet ((foo (x) (foo x))) (foo 1))) (take-it-out-for-a-test-walk (flet ((foo (x) (foo x))) (flet ((bar (x) (foo x))) (bar 1)))) (take-it-out-for-a-test-walk (compiler-let ((a 1) (b 2)) (foo a) b)) (take-it-out-for-a-test-walk (prog () (declare (special a b)))) (take-it-out-for-a-test-walk (let (a b c) (declare (special a b)) (foo a) b c)) (take-it-out-for-a-test-walk (let (a b c) (declare (special a) (special b)) (foo a) b c)) (take-it-out-for-a-test-walk (let (a b c) (declare (special a)) (declare (special b)) (foo a) b c)) (take-it-out-for-a-test-walk (let (a b c) (declare (special a)) (declare (special b)) (let ((a 1)) (foo a) b c))) (take-it-out-for-a-test-walk (eval-when () a (foo a))) (take-it-out-for-a-test-walk (eval-when (eval when load) a (foo a))) (take-it-out-for-a-test-walk (multiple-value-bind (a b) (foo a b) (list a b))) (take-it-out-for-a-test-walk (multiple-value-bind (a b) (foo a b) (declare (special a)) (list a b))) (take-it-out-for-a-test-walk (progn (function foo))) (take-it-out-for-a-test-walk (progn a b (go a))) (take-it-out-for-a-test-walk (if a b c)) (take-it-out-for-a-test-walk (if a b)) (take-it-out-for-a-test-walk ((lambda (a b) (list a b)) 1 2)) (take-it-out-for-a-test-walk ((lambda (a b) (declare (special a)) (list a b)) 1 2)) (take-it-out-for-a-test-walk (let ((a a) (b a) (c b)) (list a b c))) (take-it-out-for-a-test-walk (let* ((a a) (b a) (c b)) (list a b c))) (take-it-out-for-a-test-walk (let ((a a) (b a) (c b)) (declare (special a b)) (list a b c))) (take-it-out-for-a-test-walk (let* ((a a) (b a) (c b)) (declare (special a b)) (list a b c))) (take-it-out-for-a-test-walk (let ((a 1) (b 2)) (foo bar) (declare (special a)) (foo a b))) (take-it-out-for-a-test-walk (multiple-value-call #'foo a b c)) (take-it-out-for-a-test-walk (multiple-value-prog1 a b c)) (take-it-out-for-a-test-walk (progn a b c)) (take-it-out-for-a-test-walk (progv vars vals a b c)) (take-it-out-for-a-test-walk (quote a)) (take-it-out-for-a-test-walk (return-from block-name a b c)) (take-it-out-for-a-test-walk (setq a 1)) (take-it-out-for-a-test-walk (setq a (foo 1) b (bar 2) c 3)) (take-it-out-for-a-test-walk (tagbody a b c (go a))) (take-it-out-for-a-test-walk (the foo (foo-form a b c))) (take-it-out-for-a-test-walk (throw tag-form a)) (take-it-out-for-a-test-walk (unwind-protect (foo a b) d e f)) (defmacro flet-1 (a b) ''OUTER) (defmacro labels-1 (a b) ''OUTER) (take-it-out-for-a-test-walk (flet ((flet-1 (a b) () (flet-1 a b) (list a b))) (flet-1 1 2) (foo 1 2))) (take-it-out-for-a-test-walk (labels ((label-1 (a b) () (label-1 a b)(list a b))) (label-1 1 2) (foo 1 2))) (take-it-out-for-a-test-walk (macrolet ((macrolet-1 (a b) (list a b))) (macrolet-1 a b) (foo 1 2))) (take-it-out-for-a-test-walk (macrolet ((foo (a) `(inner-foo-expanded ,a))) (foo 1))) (take-it-out-for-a-test-walk (progn (bar 1) (macrolet ((bar (a) `(inner-bar-expanded ,a))) (bar 2)))) (take-it-out-for-a-test-walk (progn (bar 1) (macrolet ((bar (s) (bar s) `(inner-bar-expanded ,s))) (bar 2)))) (take-it-out-for-a-test-walk (cond (a b) ((foo bar) a (foo a)))) (let ((the-lexical-variables ())) (walk-form '(let ((a 1) (b 2)) #'(lambda (x) (list a b x y))) () #'(lambda (form context env) (when (and (symbolp form) (variable-lexical-p form env)) (push form the-lexical-variables)) form)) (or (and (= (length the-lexical-variables) 3) (member 'a the-lexical-variables) (member 'b the-lexical-variables) (member 'x the-lexical-variables)) (error "Walker didn't do lexical variables of a closure properly."))) |# ecl-16.1.2/src/clx/000077500000000000000000000000001266352375300137355ustar00rootroot00000000000000ecl-16.1.2/src/clx/.cvsignore000066400000000000000000000000071266352375300157320ustar00rootroot00000000000000*.fasl ecl-16.1.2/src/clx/CHANGES000066400000000000000000000033251266352375300147330ustar00rootroot00000000000000Details of changes since R5: NOTE: this file is not updated any more. Changes since checking into version control can be found from darcs in some way shape or form. There may however be some Dark Ages between when this file was last updated and the version that was the initial version control checkin. Changes in CLX 5.02: Replace LCL:ENVIRONMENT-VALUE with LCL:ENVIRONMENT-VARIABLE. Fix a declaration in the DEFINE-ERROR macro. Quote type argument to TYPE-CHECK consistently. Changes in CLX 5.01: Support for MIT-MAGIC-COOKIE-1 authorization has been added. All VALUES declarations have been changed to CLX-VALUES declarations. VALUES is a CL type name and cannot be used as a declaration name. All ARRAY-REGISTER declarations have been removed as Genera no longer needs them. Many type declarations have been corrected or tightened up now that some Lisps look at them. Print functions have been defined for bitmap and pixmap formats. The DISPLAY-PLIST slot will be initialized to NIL. When debugging, don't optimize SPEED in the buffer macros. Make the CARD8<->CHAR and the window manager code work for sparse character sets (where some codes do not have corresponding characters). The default gcontext extension set and copy functions will take the correct number of arguments. PUT-IMAGE will now work for 24-bit images. The buffer accessors for MEMBER8, etc., will use the standard mechanisms for reporting type errors. Typographical errors in SET-WM-PROPERTIES, SET-STANDARD-COLORMAP, and POINTER-CONTROL have been fixed. Symbolics systems will do lazy macroexpansion in the buffer macros. A variety of changes for Symbolics Minima systems have been made. Some system-dependent code has been added for CMU Common Lisp. ecl-16.1.2/src/clx/NEWS000066400000000000000000000133471266352375300144440ustar00rootroot00000000000000-*- Text -*- -- Changes in telent CLX 0.7.3, Tue Mar 28 2006 --- Support for Allegro CL (6.2 and later) (Mikel Evins) Latin 1 keysyms (Christophe Rhodes) Some protocol fixes (Douglas Crosher) Define a RENDER-OP typ (Douglas Crosher) --- Changes in SBCL CLX 0.7.2, Tue Jan 10 2006 --- OpenMCL fixes DPMS extension support Xauthority ipv6 parsing fixes Thanks to Bryan O'Connor, Matthew Kennedy, Christophe Rhodes --- Changes in SBCL CLX 0.7.1, Wed Aug 24 2005 --- Works in SBCL 0.9.2 and newer. --- Changes in SBCL CLX 0.7.0, Sun May 1 2005 --- The SBCL support now depends on version 0.9.0 or greater. --- Changes in SBCL CLX 0.6.1, Mon Mar 28 2005 --- experimental GLX extension support (from Janis Dzerins) The ICCCM-compliant selection handling in demo/clipboard.lisp is now more ICCCM-compliant. The implementation of the RENDER client protocol has been enhanced. (Gilbert Baumann) Bug fix: CIRCULATE-NOTIFY, CIRCULATE-REQUEST and PROPERTY-NOTIFY input event descriptions have been fixed. --- Changes in SBCL CLX 0.6, Tue Nov 16 2004 --- A port to ECL has been merged (Juan Jose Garcia Ripoll) With the addition of an implementation of DYNAMIC-EXTENT &REST lists to SBCL, various functions (e.g. READ-INPUT, QUEUE-EVENT) in CLX should cons less. A Texinfo version of the CLX manual has been added (in manual/), thanks to the work of Gilbert Baumann and Shawn Betts. The portable-clx mailing list has been created for development discussion and bug reports. See http://lists.metacircles.com/cgi-bin/mailman/listinfo/portable-clx A demonstration of ICCCM-compliant selection handling for select and paste has been included in demo/clipboard.lisp Bug fix: change the sizes of certain fields in a WM-SIZE-HINT to be 32 bits wide, as per the ICCCM specifications. Fixes a problem seen with the MacOS X11 window manger, that uses very large hint values. (Patch from Eric Marsden) Bug fix: +POINTER-EVENT-MASK-VECTOR+ is supposed to be a vector of keywords. It wasn't, but it is now. (Milan Zamazal) Bug fix: xrender now compiles properly when *DEF-CLX-CLASS-USE-DEFCLASS* (Milan again) --- Changes in SBCL CLX 0.5.4, Tue Nov 11 00:02:43 2003 --- A change in the implementation of PROCESS-BLOCK and PROCESS-WAKEUP under multithreaded SBCL. Previous versions used queues and condition variables, but this seems to have undesireable performance characteristics; the newer version uses a polling loop calling sched_yield() inside, which greatly improves responsiveness, but is more CPU-hungry (as perceived by top(1), at least; in theory it only hogs the CPU when nobody else wants it). --- Changes in SBCL CLX 0.5.3, Sat Sep 6 12:14:39 UTC 2003 --- We allow a PIXMAP-DEPTH of 12 in clx.lisp, despite not having any image routines for it, to allow clx to load when running under eXceed. Image routines are unlikely to work in such circumstances. Bug fixes * ERROR idiom (xvidmode.lisp) * Add timestamp in NEWS file --- Changes in SBCL CLX 0.5.2, about twenty minutes before 0.5.3 --- OPEN-DEFAULT-DISPLAY now takes an optional argument for the display name, which has the same "protocol/host:display.screen" format as used by the C libX11 (XOpenDisplay). OPEN-DISPLAY is not actively deprecated, but is much less useful by comparison Inclusion of two new tests/demos (from Ingvar Mattson): * demo/clclock: a simple clock application; * demo/mandel: a Mandelbrot set viewer. Bug fixes * Fix bad type declarations in TEXT-EXTENTS-SERVER and TEXT-WIDTH-SERVER (text.lisp) * Fix FORMAT argument mismatch error in WRITE-BITMAP-FILE (image.lisp) --- Changes in SBCL CLX 0.5.1, Wed Jun 25 14:20:31 BST 2003 --- experimental RENDER extension support (from Gilbert Baumann) note: the API to this is as yet unfinalized, as indeed the protocol and specification appear to be in flux. Nevertheless, feedback is welcome to the portable-clx-devel mailing list. Bug fixes * fix bugs in the image test: always draw glyphs in white on black (not 1 on 0 -- i.e. dark red/blue on black in 24 bit truecolour); don't abuse the X-HOT and Y-HOT slots for communicating persistent information any more. * Disable the "optimized" pixarray read/write routines, on the basis that the newly fixed image test reveals that they are broken. * fix type bugs in DEFINE-GCONTEXT-ACCESSOR, which previously signalled a type error if :COPY-FUNCTION was not provided, and a different type error if it was. Other notes * we use the SBCL extensions to the condition system to customize compiler behaviour. As such, the system will only build without breaking into the debugger using the supplied .asd, as we inhibit error signalling from DEFCONSTANT; the benefits of this are easier code sharing, as we minimize divergence within the clx source proper from other implementations. * we also use an SBCL extension to maximize efficiency: we set SB-EXT:*DERIVE-FUNCTION-TYPES* to true for the duration of the compilation of the clx library. Should functions in CLX be redefined in a type-incompatible way, their callers in CLX (but not outside) will need to be recompiled. --- Changes in SBCL CLX 0.5, Fri May 30 01:16:34 BST 2003 --- XFree86-VidModeExtension extension support (courtesy of Iban Hatchondo) OPEN-DEFAULT-DISPLAY (opens display in $DISPLAY environment variable) exported Implement CLX MP dependencies for SBCL: HOLDING-LOCK, PROCESS-BLOCK, etc Many bug fixes * asking for text extents on unchached fonts could potentially deadlock http://article.gmane.org/gmane.lisp.clx.devel/16 * lots of compiler warnings, style-warnings, notes cleared up Style and ANSI cleanups * Much renaming of constants from *foo* to +foo+ * Change old-style COMPILE LOAD EVAL to new-style :COMPILE-TOPLEVEL :LOAD-TOPLEVEL :EXECUTE in EVAL-WHENs. ecl-16.1.2/src/clx/README000066400000000000000000000076311266352375300146240ustar00rootroot00000000000000This directory contains CLX, an X11 client library for Common Lisp. The code was originally taken from a CMUCL distribution, was modified somewhat in order to make it compile and run under SBCL, then a selection of patches were added from other CLXes around the net. = Features - SHAPE extension support (Gilbert Baumann) - XFREE86-VIDMODE extension support (Iban Hatchondo) - experimental RENDER extension support (Gilbert Baumann and Christian Sunesson) - X authority support that works with ssh forwarding (Eric Marsden via CMUCL) - OPEN-DEFAULT-DISPLAY function which, as the name suggests, does that (dan) - various bug fixes (Iban Hatchondo and a cast of several) - a manual in texinfo format (Shawn Betts, Gilbert Baumann) = Compatibility This CLX distribution is intended to work under the latest released version of SBCL - please report the bug if it doesn't. It should usually also work with earlier versions back to 0.9.0, and possibly earlier still, but may need manual adjustment to the clx.asd file (to remove use of newly-introduced features). It has also been used as a basis for CLX ports on other Lisp implementations, but these instructions are only good for SBCL. If you're running something else, you need to know (a) that it builds with asdf (and asdf-install, if the planets are in alignment) and (b) what asdf is anyway. http://www.weitz.de/asdf-install/ might help you there. If you've installed this using some non-SBCL Lisp, please send mail describing the process so that future versions can incorporate your instructions. If you are following SBCL CVS and this CLX does not run in it, please check the darcs repositor{y,ies} for this CLX distribution to see if your bug has been fixed already. darcs get http://verisons.telent.net/clx # version from which releases are made http://common-lisp.net/~crhodes/clx # patches merged by Christophe http://monday-monkey.com/repos/clx/ # OpenMCL tree by bryan o'connor? = Building using asdf-install * (require 'asdf) * (require 'asdf-install) * (asdf-install:install 'clx) ; download and install automatically, or * (asdf-install:install "clx-x.y.z.tar.gz") ; if you've downloaded already = Building by hand If you don't trust asdf-install, here's how to do it manually - 1. Untar this tree somewhere 2. Add a symlink to clx.asd from one of the directories listed in your asdf:*central-registry* If that makes no sense to you yet, choose one of - 2a. personal installation: $ cd $HOME/.sbcl/systems # you may have to create this directory $ ln -s /path/to/clx/source/clx.asd . 2b. systemwide installations: you need to ask SBCL where it lives $ sbcl --noinform --eval '(format t "~A~%" (posix-getenv "SBCL_HOME"))' ASDFized version and ongoing by Daniel Barlow and (mostly, these days) Christophe Rhodes ecl-16.1.2/src/clx/README-R5000066400000000000000000000035571266352375300151130ustar00rootroot00000000000000 Original CLX README, retained for historical information --- These files contain beta code, but they have been tested to some extent under Symbolics, TI, Lucid and Franz. The files have been given .l suffixes to keep them within 12 characters, to keep SysV sites happy. Please rename them with more appropriate suffixes for your system. For Franz systems, see exclREADME. For Symbolics systems, first rename all the .l files to .lisp. Then edit your sys.translations file so that sys:x11;clx; points to this directory and put a clx.system file in your sys:site;directory that has the form (si:set-system-source-file "clx" "sys:x11;clx;defsystem.lisp") in it. After that CLX can be compiled with the "Compile System CLX" command and loaded with the "Load System CLX" command. For TI systems, rename all the .l files to .lisp, and make a clx.translations file in your sys:site; directory pointing to this directory and a sys:site;clx.system file like the one described for symbolics systems above, but with the defsystem file being in the clx:clx; directory. Then CLX can be compiled with (make-system "CLX" :compile :noconfirm) and loaded with (make-system "CLX" :noconfirm). For Lucid systems, you should rename all the .l files to .lisp too (This might not be possible on SysV systems). After loading the defsystem.l file, CLX can be compiled with the (compile-clx) function and loaded with the (load-clx) form. The ms-patch.uu file is a patch to Lucid version 2 systems. You probably don't need it, as you are probably running Lucid version 3 or later, but if you are still using Lucid version 2, you need this patch. You'll need to uudecode it to produce the binary. For kcl systems, after loading the defsystem.l file, CLX can be compiled with the (compile-clx) function and loaded with the (load-clx) form. For more information, see defsystem.l and provide.l. ecl-16.1.2/src/clx/attributes.lisp000066400000000000000000000617721266352375300170310ustar00rootroot00000000000000;;; -*- Mode: LISP; Syntax: Common-lisp; Package: XLIB; Base: 10; Lowercase: Yes -*- ;;; Window Attributes ;;; ;;; TEXAS INSTRUMENTS INCORPORATED ;;; P.O. BOX 2909 ;;; AUSTIN, TEXAS 78769 ;;; ;;; Copyright (C) 1987 Texas Instruments Incorporated. ;;; ;;; Permission is granted to any individual or institution to use, copy, modify, ;;; and distribute this software, provided that this complete copyright and ;;; permission notice is maintained, intact, in all copies and supporting ;;; documentation. ;;; ;;; Texas Instruments Incorporated provides this software "as is" without ;;; express or implied warranty. ;;; ;;; The special variable *window-attributes* is an alist containg: ;;; (drawable attributes attribute-changes geometry geometry-changes) ;;; Where DRAWABLE is the associated window or pixmap ;;; ATTRIBUTES is NIL or a reply-buffer containing the drawable's ;;; attributes for use by the accessors. ;;; ATTRIBUTE-CHANGES is NIL or an array. The first element ;;; of the array is a "value-mask", indicating which ;;; attributes have changed. The other elements are ;;; integers associated with the changed values, ready ;;; for insertion into a server request. ;;; GEOMETRY is like ATTRIBUTES, but for window geometry ;;; GEOMETRY-CHANGES is like ATTRIBUTE-CHANGES, but for window geometry ;;; ;;; Attribute and Geometry accessors and SETF's look on the special variable ;;; *window-attributes* for the drawable. If its not there, the accessor is ;;; NOT within a WITH-STATE, and a server request is made to get or put a value. ;;; If an entry is found in *window-attributes*, the cache buffers are used ;;; for the access. ;;; ;;; All WITH-STATE has to do (re)bind *Window-attributes* to a list including ;;; the new drawable. The caches are initialized to NIL and allocated as needed. (in-package :xlib) (eval-when (:compile-toplevel :load-toplevel :execute) (defconstant +attribute-size+ 44) (defconstant +geometry-size+ 24) (defconstant +context-size+ (max +attribute-size+ +geometry-size+ (* 16 4)))) (defvar *window-attributes* nil) ;; Bound to an alist of (drawable . state) within WITH-STATE ;; Window Attribute reply buffer resource (defvar *context-free-list* nil) ;; resource of free reply buffers (defun allocate-context () (or (threaded-atomic-pop *context-free-list* reply-next reply-buffer) (make-reply-buffer +context-size+))) (defun deallocate-context (context) (declare (type reply-buffer context)) (threaded-atomic-push context *context-free-list* reply-next reply-buffer)) (defmacro state-attributes (state) `(second ,state)) (defmacro state-attribute-changes (state) `(third ,state)) (defmacro state-geometry (state) `(fourth ,state)) (defmacro state-geometry-changes (state) `(fifth ,state)) (defmacro drawable-equal-function () ;; Since drawables are not always cached, we must use drawable-equal ;; to determine equality. ''drawable-equal) (defmacro window-equal-function () ;; Since windows are not always cached, we must use window-equal ;; to determine equality. ''window-equal) (defmacro with-state ((drawable) &body body) ;; Allows a consistent view to be obtained of data returned by GetWindowAttributes ;; and GetGeometry, and allows a coherent update using ChangeWindowAttributes and ;; ConfigureWindow. The body is not surrounded by a with-display. Within the ;; indefinite scope of the body, on a per-process basis in a multi-process ;; environment, the first call within an Accessor Group on the specified drawable ;; (the object, not just the variable) causes the complete results of the protocol ;; request to be retained, and returned in any subsequent accessor calls. Calls ;; within a Setf Group are delayed, and executed in a single request on exit from ;; the body. In addition, if a call on a function within an Accessor Group follows ;; a call on a function in the corresponding Setf Group, then all delayed setfs for ;; that group are executed, any retained accessor information for that group is ;; discarded, the corresponding protocol request is (re)issued, and the results are ;; (again) retained, and returned in any subsequent accessor calls. ;; Accessor Group A (for GetWindowAttributes): ;; window-visual, window-visual-info, window-class, window-gravity, window-bit-gravity, ;; window-backing-store, window-backing-planes, window-backing-pixel, ;; window-save-under, window-colormap, window-colormap-installed-p, ;; window-map-state, window-all-event-masks, window-event-mask, ;; window-do-not-propagate-mask, window-override-redirect ;; Setf Group A (for ChangeWindowAttributes): ;; window-gravity, window-bit-gravity, window-backing-store, window-backing-planes, ;; window-backing-pixel, window-save-under, window-event-mask, ;; window-do-not-propagate-mask, window-override-redirect, window-colormap, ;; window-cursor ;; Accessor Group G (for GetGeometry): ;; drawable-root, drawable-depth, drawable-x, drawable-y, drawable-width, ;; drawable-height, drawable-border-width ;; Setf Group G (for ConfigureWindow): ;; drawable-x, drawable-y, drawable-width, drawable-height, drawable-border-width, ;; window-priority (let ((state-entry (gensym))) ;; alist of (drawable attributes attribute-changes geometry geometry-changes) `(with-stack-list (,state-entry ,drawable nil nil nil nil) (with-stack-list* (*window-attributes* ,state-entry *window-attributes*) (multiple-value-prog1 (progn ,@body) (cleanup-state-entry ,state-entry)))))) (defun cleanup-state-entry (state) ;; Return buffers to the free-list (let ((entry (state-attributes state))) (when entry (deallocate-context entry))) (let ((entry (state-attribute-changes state))) (when entry (put-window-attribute-changes (car state) entry) (deallocate-gcontext-state entry))) (let ((entry (state-geometry state))) (when entry (deallocate-context entry))) (let ((entry (state-geometry-changes state))) (when entry (put-drawable-geometry-changes (car state) entry) (deallocate-gcontext-state entry)))) (defun change-window-attribute (window number value) ;; Called from window attribute SETF's to alter an attribute value ;; number is the change-attributes request mask bit number (declare (type window window) (type card8 number) (type card32 value)) (let ((state-entry nil) (changes nil)) (if (and *window-attributes* (setq state-entry (assoc window (the list *window-attributes*) :test (window-equal-function)))) (progn ; Within a WITH-STATE - cache changes (setq changes (state-attribute-changes state-entry)) (unless changes (setq changes (allocate-gcontext-state)) (setf (state-attribute-changes state-entry) changes) (setf (aref changes 0) 0)) ;; Initialize mask to zero (setf (aref changes 0) (logior (aref changes 0) (ash 1 number))) ;; set mask bit (setf (aref changes (1+ number)) value)) ;; save value ; Send change to the server (with-buffer-request ((window-display window) +x-changewindowattributes+) (window window) (card32 (ash 1 number) value))))) ;; ;; These two are twins (change-window-attribute change-drawable-geometry) ;; If you change one, you probably need to change the other... ;; (defun change-drawable-geometry (drawable number value) ;; Called from drawable geometry SETF's to alter an attribute value ;; number is the change-attributes request mask bit number (declare (type drawable drawable) (type card8 number) (type card29 value)) (let ((state-entry nil) (changes nil)) (if (and *window-attributes* (setq state-entry (assoc drawable (the list *window-attributes*) :test (drawable-equal-function)))) (progn ; Within a WITH-STATE - cache changes (setq changes (state-geometry-changes state-entry)) (unless changes (setq changes (allocate-gcontext-state)) (setf (state-geometry-changes state-entry) changes) (setf (aref changes 0) 0)) ;; Initialize mask to zero (setf (aref changes 0) (logior (aref changes 0) (ash 1 number))) ;; set mask bit (setf (aref changes (1+ number)) value)) ;; save value ; Send change to the server (with-buffer-request ((drawable-display drawable) +x-configurewindow+) (drawable drawable) (card16 (ash 1 number)) (card29 value))))) (defun get-window-attributes-buffer (window) (declare (type window window)) (let ((state-entry nil) (changes nil)) (or (and *window-attributes* (setq state-entry (assoc window (the list *window-attributes*) :test (window-equal-function))) (null (setq changes (state-attribute-changes state-entry))) (state-attributes state-entry)) (let ((display (window-display window))) (with-display (display) ;; When SETF's have been done, flush changes to the server (when changes (put-window-attribute-changes window changes) (deallocate-gcontext-state (state-attribute-changes state-entry)) (setf (state-attribute-changes state-entry) nil)) ;; Get window attributes (with-buffer-request-and-reply (display +x-getwindowattributes+ size :sizes (8)) ((window window)) (let ((repbuf (or (state-attributes state-entry) (allocate-context)))) (declare (type reply-buffer repbuf)) ;; Copy into repbuf from reply buffer (buffer-replace (reply-ibuf8 repbuf) buffer-bbuf 0 size) (when state-entry (setf (state-attributes state-entry) repbuf)) repbuf))))))) ;; ;; These two are twins (get-window-attributes-buffer get-drawable-geometry-buffer) ;; If you change one, you probably need to change the other... ;; (defun get-drawable-geometry-buffer (drawable) (declare (type drawable drawable)) (let ((state-entry nil) (changes nil)) (or (and *window-attributes* (setq state-entry (assoc drawable (the list *window-attributes*) :test (drawable-equal-function))) (null (setq changes (state-geometry-changes state-entry))) (state-geometry state-entry)) (let ((display (drawable-display drawable))) (with-display (display) ;; When SETF's have been done, flush changes to the server (when changes (put-drawable-geometry-changes drawable changes) (deallocate-gcontext-state (state-geometry-changes state-entry)) (setf (state-geometry-changes state-entry) nil)) ;; Get drawable attributes (with-buffer-request-and-reply (display +x-getgeometry+ size :sizes (8)) ((drawable drawable)) (let ((repbuf (or (state-geometry state-entry) (allocate-context)))) (declare (type reply-buffer repbuf)) ;; Copy into repbuf from reply buffer (buffer-replace (reply-ibuf8 repbuf) buffer-bbuf 0 size) (when state-entry (setf (state-geometry state-entry) repbuf)) repbuf))))))) (defun put-window-attribute-changes (window changes) ;; change window attributes ;; Always from Called within a WITH-DISPLAY (declare (type window window) (type gcontext-state changes)) (let* ((display (window-display window)) (mask (aref changes 0))) (declare (type display display) (type mask32 mask)) (with-buffer-request (display +x-changewindowattributes+) (window window) (card32 mask) (progn ;; Insert a word in the request for each one bit in the mask (do ((bits mask (ash bits -1)) (request-size 2) ;Word count (i 1 (index+ i 1))) ;Entry count ((zerop bits) (card16-put 2 (index-incf request-size)) (index-incf (buffer-boffset display) (index* request-size 4))) (declare (type mask32 bits) (type array-index i request-size)) (when (oddp bits) (card32-put (index* (index-incf request-size) 4) (aref changes i)))))))) ;; ;; These two are twins (put-window-attribute-changes put-drawable-geometry-changes) ;; If you change one, you probably need to change the other... ;; (defun put-drawable-geometry-changes (window changes) ;; change window attributes or geometry (depending on request-number...) ;; Always from Called within a WITH-DISPLAY (declare (type window window) (type gcontext-state changes)) (let* ((display (window-display window)) (mask (aref changes 0))) (declare (type display display) (type mask16 mask)) (with-buffer-request (display +x-configurewindow+) (window window) (card16 mask) (progn ;; Insert a word in the request for each one bit in the mask (do ((bits mask (ash bits -1)) (request-size 2) ;Word count (i 1 (index+ i 1))) ;Entry count ((zerop bits) (card16-put 2 (incf request-size)) (index-incf (buffer-boffset display) (* request-size 4))) (declare (type mask16 bits) (type fixnum request-size) (type array-index i)) (when (oddp bits) (card29-put (* (incf request-size) 4) (aref changes i)))))))) (defmacro with-attributes ((window &rest options) &body body) `(let ((.with-attributes-reply-buffer. (get-window-attributes-buffer ,window))) (declare (type reply-buffer .with-attributes-reply-buffer.)) (prog1 (with-buffer-input (.with-attributes-reply-buffer. ,@options) ,@body) (unless *window-attributes* (deallocate-context .with-attributes-reply-buffer.))))) ;; ;; These two are twins (with-attributes with-geometry) ;; If you change one, you probably need to change the other... ;; (defmacro with-geometry ((window &rest options) &body body) `(let ((.with-geometry-reply-buffer. (get-drawable-geometry-buffer ,window))) (declare (type reply-buffer .with-geometry-reply-buffer.)) (prog1 (with-buffer-input (.with-geometry-reply-buffer. ,@options) ,@body) (unless *window-attributes* (deallocate-context .with-geometry-reply-buffer.))))) ;;;----------------------------------------------------------------------------- ;;; Group A: (for GetWindowAttributes) ;;;----------------------------------------------------------------------------- (defun window-visual (window) (declare (type window window)) (declare (clx-values resource-id)) (with-attributes (window :sizes 32) (resource-id-get 8))) (defun window-visual-info (window) (declare (type window window)) (declare (clx-values visual-info)) (with-attributes (window :sizes 32) (visual-info (window-display window) (resource-id-get 8)))) (defun window-class (window) (declare (type window window)) (declare (clx-values (member :input-output :input-only))) (with-attributes (window :sizes 16) (member16-get 12 :copy :input-output :input-only))) (defun set-window-background (window background) (declare (type window window) (type (or (member :none :parent-relative) pixel pixmap) background)) (cond ((eq background :none) (change-window-attribute window 0 0)) ((eq background :parent-relative) (change-window-attribute window 0 1)) ((integerp background) ;; Background pixel (change-window-attribute window 0 0) ;; pixmap :NONE (change-window-attribute window 1 background)) ((type? background 'pixmap) ;; Background pixmap (change-window-attribute window 0 (pixmap-id background))) (t (x-type-error background '(or (member :none :parent-relative) integer pixmap)))) background) #+Genera (eval-when (compile) (compiler:function-defined 'window-background)) (defsetf window-background set-window-background) (defun set-window-border (window border) (declare (type window window) (type (or (member :copy) pixel pixmap) border)) (cond ((eq border :copy) (change-window-attribute window 2 0)) ((type? border 'pixmap) ;; Border pixmap (change-window-attribute window 2 (pixmap-id border))) ((integerp border) ;; Border pixel (change-window-attribute window 3 border)) (t (x-type-error border '(or (member :copy) integer pixmap)))) border) #+Genera (eval-when (compile) (compiler:function-defined 'window-border)) (defsetf window-border set-window-border) (defun window-bit-gravity (window) ;; setf'able (declare (type window window)) (declare (clx-values bit-gravity)) (with-attributes (window :sizes 8) (member8-vector-get 14 +bit-gravity-vector+))) (defun set-window-bit-gravity (window gravity) (change-window-attribute window 4 (encode-type (member-vector +bit-gravity-vector+) gravity)) gravity) (defsetf window-bit-gravity set-window-bit-gravity) (defun window-gravity (window) ;; setf'able (declare (type window window)) (declare (clx-values win-gravity)) (with-attributes (window :sizes 8) (member8-vector-get 15 +win-gravity-vector+))) (defun set-window-gravity (window gravity) (change-window-attribute window 5 (encode-type (member-vector +win-gravity-vector+) gravity)) gravity) (defsetf window-gravity set-window-gravity) (defun window-backing-store (window) ;; setf'able (declare (type window window)) (declare (clx-values (member :not-useful :when-mapped :always))) (with-attributes (window :sizes 8) (member8-get 1 :not-useful :when-mapped :always))) (defun set-window-backing-store (window when) (change-window-attribute window 6 (encode-type (member :not-useful :when-mapped :always) when)) when) (defsetf window-backing-store set-window-backing-store) (defun window-backing-planes (window) ;; setf'able (declare (type window window)) (declare (clx-values pixel)) (with-attributes (window :sizes 32) (card32-get 16))) (defun set-window-backing-planes (window planes) (change-window-attribute window 7 (encode-type card32 planes)) planes) (defsetf window-backing-planes set-window-backing-planes) (defun window-backing-pixel (window) ;; setf'able (declare (type window window)) (declare (clx-values pixel)) (with-attributes (window :sizes 32) (card32-get 20))) (defun set-window-backing-pixel (window pixel) (change-window-attribute window 8 (encode-type card32 pixel)) pixel) (defsetf window-backing-pixel set-window-backing-pixel) (defun window-save-under (window) ;; setf'able (declare (type window window)) (declare (clx-values (member :off :on))) (with-attributes (window :sizes 8) (member8-get 24 :off :on))) (defun set-window-save-under (window when) (change-window-attribute window 10 (encode-type (member :off :on) when)) when) (defsetf window-save-under set-window-save-under) (defun window-override-redirect (window) ;; setf'able (declare (type window window)) (declare (clx-values (member :off :on))) (with-attributes (window :sizes 8) (member8-get 27 :off :on))) (defun set-window-override-redirect (window when) (change-window-attribute window 9 (encode-type (member :off :on) when)) when) (defsetf window-override-redirect set-window-override-redirect) (defun window-event-mask (window) ;; setf'able (declare (type window window)) (declare (clx-values mask32)) (with-attributes (window :sizes 32) (card32-get 36))) (defsetf window-event-mask (window) (event-mask) (let ((em (gensym))) `(let ((,em ,event-mask)) (declare (type event-mask ,em)) (change-window-attribute ,window 11 (encode-event-mask ,em)) ,em))) (defun window-do-not-propagate-mask (window) ;; setf'able (declare (type window window)) (declare (clx-values mask32)) (with-attributes (window :sizes 32) (card32-get 40))) (defsetf window-do-not-propagate-mask (window) (device-event-mask) (let ((em (gensym))) `(let ((,em ,device-event-mask)) (declare (type device-event-mask ,em)) (change-window-attribute ,window 12 (encode-device-event-mask ,em)) ,em))) (defun window-colormap (window) (declare (type window window)) (declare (clx-values (or null colormap))) (with-attributes (window :sizes 32) (let ((id (resource-id-get 28))) (if (zerop id) nil (let ((colormap (lookup-colormap (window-display window) id))) (unless (colormap-visual-info colormap) (setf (colormap-visual-info colormap) (visual-info (window-display window) (resource-id-get 8)))) colormap))))) (defun set-window-colormap (window colormap) (change-window-attribute window 13 (encode-type (or (member :copy) colormap) colormap)) colormap) (defsetf window-colormap set-window-colormap) (defun window-cursor (window) (declare (type window window)) (declare (clx-values cursor)) window (error "~S can only be set" 'window-cursor)) (defun set-window-cursor (window cursor) (change-window-attribute window 14 (encode-type (or (member :none) cursor) cursor)) cursor) (defsetf window-cursor set-window-cursor) (defun window-colormap-installed-p (window) (declare (type window window)) (declare (clx-values generalized-boolean)) (with-attributes (window :sizes 8) (boolean-get 25))) (defun window-all-event-masks (window) (declare (type window window)) (declare (clx-values mask32)) (with-attributes (window :sizes 32) (card32-get 32))) (defun window-map-state (window) (declare (type window window)) (declare (clx-values (member :unmapped :unviewable :viewable))) (with-attributes (window :sizes 8) (member8-get 26 :unmapped :unviewable :viewable))) ;;;----------------------------------------------------------------------------- ;;; Group G: (for GetGeometry) ;;;----------------------------------------------------------------------------- (defun drawable-root (drawable) (declare (type drawable drawable)) (declare (clx-values window)) (with-geometry (drawable :sizes 32) (window-get 8 (drawable-display drawable)))) (defun drawable-x (drawable) ;; setf'able (declare (type drawable drawable)) (declare (clx-values int16)) (with-geometry (drawable :sizes 16) (int16-get 12))) (defun set-drawable-x (drawable x) (change-drawable-geometry drawable 0 (encode-type int16 x)) x) (defsetf drawable-x set-drawable-x) (defun drawable-y (drawable) ;; setf'able (declare (type drawable drawable)) (declare (clx-values int16)) (with-geometry (drawable :sizes 16) (int16-get 14))) (defun set-drawable-y (drawable y) (change-drawable-geometry drawable 1 (encode-type int16 y)) y) (defsetf drawable-y set-drawable-y) (defun drawable-width (drawable) ;; setf'able ;; Inside width, excluding border. (declare (type drawable drawable)) (declare (clx-values card16)) (with-geometry (drawable :sizes 16) (card16-get 16))) (defun set-drawable-width (drawable width) (change-drawable-geometry drawable 2 (encode-type card16 width)) width) (defsetf drawable-width set-drawable-width) (defun drawable-height (drawable) ;; setf'able ;; Inside height, excluding border. (declare (type drawable drawable)) (declare (clx-values card16)) (with-geometry (drawable :sizes 16) (card16-get 18))) (defun set-drawable-height (drawable height) (change-drawable-geometry drawable 3 (encode-type card16 height)) height) (defsetf drawable-height set-drawable-height) (defun drawable-depth (drawable) (declare (type drawable drawable)) (declare (clx-values card8)) (with-geometry (drawable :sizes 8) (card8-get 1))) (defun drawable-border-width (drawable) ;; setf'able (declare (type drawable drawable)) (declare (clx-values integer)) (with-geometry (drawable :sizes 16) (card16-get 20))) (defun set-drawable-border-width (drawable width) (change-drawable-geometry drawable 4 (encode-type card16 width)) width) (defsetf drawable-border-width set-drawable-border-width) (defun set-window-priority (mode window sibling) (declare (type (member :above :below :top-if :bottom-if :opposite) mode) (type window window) (type (or null window) sibling)) (with-state (window) (change-drawable-geometry window 6 (encode-type (member :above :below :top-if :bottom-if :opposite) mode)) (when sibling (change-drawable-geometry window 5 (encode-type window sibling)))) mode) #+Genera (eval-when (compile) (compiler:function-defined 'window-priority)) (defsetf window-priority (window &optional sibling) (mode) ;; A bit strange, but retains setf form. `(set-window-priority ,mode ,window ,sibling)) ecl-16.1.2/src/clx/big-requests.lisp000066400000000000000000000022721266352375300172430ustar00rootroot00000000000000;;; -*- Mode: Lisp; Syntax: Common-Lisp; Package: XLIB; -*- ;;; ;;; (c) copyright 2006 Richard Kreuter ;;; (c) copyright 2007 by Christophe Rhodes ;;; ;;; Permission is granted to any individual or institution to use, ;;; copy, modify, and distribute this software, provided that this ;;; complete copyright and permission notice is maintained, intact, in ;;; all copies and supporting documentation. ;;; ;;; 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. (in-package "XLIB") ;;; No new events or errors are defined by this extension. (Big ;;; Requests Extension, section 3) ;;; ;;; The name of this extension is "BIG-REQUESTS" (Big Requests ;;; Extension, section 4) (define-extension "BIG-REQUESTS") (defun enable-big-requests (display) (declare (type display display)) (let ((opcode (extension-opcode display "BIG-REQUESTS"))) (with-buffer-request-and-reply (display opcode nil) ((data 0)) (let ((maximum-request-length (card32-get 8))) (setf (display-extended-max-request-length display) maximum-request-length))))) ecl-16.1.2/src/clx/buffer.lisp000066400000000000000000001607231266352375300161100ustar00rootroot00000000000000;;; -*- Mode: LISP; Syntax: Common-lisp; Package: XLIB; Base: 10; Lowercase: Yes -*- ;;; This file contains definitions for the BUFFER object for Common-Lisp X ;;; windows version 11 ;;; ;;; TEXAS INSTRUMENTS INCORPORATED ;;; P.O. BOX 2909 ;;; AUSTIN, TEXAS 78769 ;;; ;;; Copyright (C) 1987 Texas Instruments Incorporated. ;;; ;;; Permission is granted to any individual or institution to use, copy, modify, ;;; and distribute this software, provided that this complete copyright and ;;; permission notice is maintained, intact, in all copies and supporting ;;; documentation. ;;; ;;; Texas Instruments Incorporated provides this software "as is" without ;;; express or implied warranty. ;;; ;; A few notes: ;; ;; 1. The BUFFER implements a two-way buffered byte / half-word ;; / word stream. Hooks are left for implementing this with a ;; shared memory buffer, or with effenciency hooks to the network ;; code. ;; ;; 2. The BUFFER object uses overlapping displaced arrays for ;; inserting and removing bytes half-words and words. ;; ;; 3. The BYTE component of these arrays is written to a STREAM ;; associated with the BUFFER. The stream has its own buffer. ;; This may be made more efficient by using the Zetalisp ;; :Send-Output-Buffer operation. ;; ;; 4. The BUFFER object is INCLUDED in the DISPLAY object. ;; This was done to reduce access time when sending requests, ;; while maintaing some code modularity. ;; Several buffer functions are duplicated (with-buffer, ;; buffer-force-output, close-buffer) to keep the naming ;; conventions consistent. ;; ;; 5. A nother layer of software is built on top of this for generating ;; both client and server interface routines, given a specification ;; of the protocol. (see the INTERFACE file) ;; ;; 6. Care is taken to leave the buffer pointer (buffer-bbuf) set to ;; a point after a complete request. This is to ensure that a partial ;; request won't be left after aborts (e.g. control-abort on a lispm). (in-package :xlib) (defconstant +requestsize+ 160) ;; Max request size (excluding variable length requests) ;;; This is here instead of in bufmac so that with-display can be ;;; compiled without macros and bufmac being loaded. (defmacro with-buffer ((buffer &key timeout inline) &body body &environment env) ;; This macro is for use in a multi-process environment. It provides ;; exclusive access to the local buffer object for request generation and ;; reply processing. `(macrolet ((with-buffer ((buffer &key timeout) &body body) ;; Speedup hack for lexically nested with-buffers `(progn (progn ,buffer ,@(and timeout `(,timeout)) nil) ,@body))) ,(if (and (null inline) (macroexpand '(use-closures) env)) `(flet ((.with-buffer-body. () ,@body)) #+clx-ansi-common-lisp (declare (dynamic-extent #'.with-buffer-body.)) (with-buffer-function ,buffer ,timeout #'.with-buffer-body.)) (let ((buf (if (or (symbolp buffer) (constantp buffer)) buffer '.buffer.))) `(let (,@(unless (eq buf buffer) `((,buf ,buffer)))) ,@(unless (eq buf buffer) `((declare (type buffer ,buf)))) ,(declare-bufmac) (when (buffer-dead ,buf) (x-error 'closed-display :display ,buf)) (holding-lock ((buffer-lock ,buf) ,buf "CLX Display Lock" ,@(and timeout `(:timeout ,timeout))) ,@body)))))) (defun with-buffer-function (buffer timeout function) (declare (type display buffer) (type (or null number) timeout) (type function function) #+clx-ansi-common-lisp (dynamic-extent function) ;; FIXME: This is probably more a bug in SBCL (logged as ;; bug #243) (ignorable timeout) #+(and lispm (not clx-ansi-common-lisp)) (sys:downward-funarg function)) (with-buffer (buffer :timeout timeout :inline t) (funcall function))) ;;; The following are here instead of in bufmac so that event-case can ;;; be compiled without macros and bufmac being loaded. (defmacro read-card8 (byte-index) `(aref-card8 buffer-bbuf (index+ buffer-boffset ,byte-index))) (defmacro read-int8 (byte-index) `(aref-int8 buffer-bbuf (index+ buffer-boffset ,byte-index))) (defmacro read-card16 (byte-index) #+clx-overlapping-arrays `(aref-card16 buffer-wbuf (index+ buffer-woffset (index-ash ,byte-index -1))) #-clx-overlapping-arrays `(aref-card16 buffer-bbuf (index+ buffer-boffset ,byte-index))) (defmacro read-int16 (byte-index) #+clx-overlapping-arrays `(aref-int16 buffer-wbuf (index+ buffer-woffset (index-ash ,byte-index -1))) #-clx-overlapping-arrays `(aref-int16 buffer-bbuf (index+ buffer-boffset ,byte-index))) (defmacro read-card32 (byte-index) #+clx-overlapping-arrays `(aref-card32 buffer-lbuf (index+ buffer-loffset (index-ash ,byte-index -2))) #-clx-overlapping-arrays `(aref-card32 buffer-bbuf (index+ buffer-boffset ,byte-index))) (defmacro read-int32 (byte-index) #+clx-overlapping-arrays `(aref-int32 buffer-lbuf (index+ buffer-loffset (index-ash ,byte-index -2))) #-clx-overlapping-arrays `(aref-int32 buffer-bbuf (index+ buffer-boffset ,byte-index))) (defmacro read-card29 (byte-index) #+clx-overlapping-arrays `(aref-card29 buffer-lbuf (index+ buffer-loffset (index-ash ,byte-index -2))) #-clx-overlapping-arrays `(aref-card29 buffer-bbuf (index+ buffer-boffset ,byte-index))) (defmacro event-code (reply-buffer) ;; The reply-buffer structure is used for events. ;; The size slot is used for the event code. `(reply-size ,reply-buffer)) (defmacro reading-event ((event &rest options) &body body) (declare (arglist (buffer &key sizes) &body body)) ;; BODY may contain calls to (READ32 &optional index) etc. ;; These calls will read from the input buffer at byte ;; offset INDEX. If INDEX is not supplied, then the next ;; word, half-word or byte is returned. `(with-buffer-input (,event ,@options) ,@body)) (defmacro with-buffer-input ((reply-buffer &key display (sizes '(8 16 32)) index) &body body) (unless (listp sizes) (setq sizes (list sizes))) ;; 160 is a special hack for client-message-events (when (set-difference sizes '(0 8 16 32 160 256)) (error "Illegal sizes in ~a" sizes)) `(let ((%reply-buffer ,reply-buffer) ,@(and display `((%buffer ,display)))) (declare (type reply-buffer %reply-buffer) ,@(and display '((type display %buffer)))) ,(declare-bufmac) ,@(and display '(%buffer)) (let* ((buffer-boffset (the array-index ,(or index 0))) #-clx-overlapping-arrays (buffer-bbuf (reply-ibuf8 %reply-buffer)) #+clx-overlapping-arrays ,@(append (when (member 8 sizes) `((buffer-bbuf (reply-ibuf8 %reply-buffer)))) (when (or (member 16 sizes) (member 160 sizes)) `((buffer-woffset (index-ash buffer-boffset -1)) (buffer-wbuf (reply-ibuf16 %reply-buffer)))) (when (member 32 sizes) `((buffer-loffset (index-ash buffer-boffset -2)) (buffer-lbuf (reply-ibuf32 %reply-buffer)))))) (declare (type array-index buffer-boffset)) #-clx-overlapping-arrays (declare (type buffer-bytes buffer-bbuf)) #+clx-overlapping-arrays ,@(append (when (member 8 sizes) '((declare (type buffer-bytes buffer-bbuf)))) (when (member 16 sizes) '((declare (type array-index buffer-woffset)) (declare (type buffer-words buffer-wbuf)))) (when (member 32 sizes) '((declare (type array-index buffer-loffset)) (declare (type buffer-longs buffer-lbuf))))) buffer-boffset #-clx-overlapping-arrays buffer-bbuf #+clx-overlapping-arrays ,@(append (when (member 8 sizes) '(buffer-bbuf)) (when (member 16 sizes) '(buffer-woffset buffer-wbuf)) (when (member 32 sizes) '(buffer-loffset buffer-lbuf))) #+clx-overlapping-arrays (macrolet ((%buffer-sizes () ',sizes)) ,@body) #-clx-overlapping-arrays ,@body))) (defun make-buffer (output-size constructor &rest options) (declare (dynamic-extent options)) ;; Output-Size is the output-buffer size in bytes. (let ((byte-output (make-array output-size :element-type 'card8 :initial-element 0))) (apply constructor :size output-size :obuf8 byte-output #+clx-overlapping-arrays :obuf16 #+clx-overlapping-arrays (make-array (index-ash output-size -1) :element-type 'overlap16 :displaced-to byte-output) #+clx-overlapping-arrays :obuf32 #+clx-overlapping-arrays (make-array (index-ash output-size -2) :element-type 'overlap32 :displaced-to byte-output) options))) (defun make-reply-buffer (size) ;; Size is the buffer size in bytes (let ((byte-input (make-array size :element-type 'card8 :initial-element 0))) (make-reply-buffer-internal :size size :ibuf8 byte-input #+clx-overlapping-arrays :ibuf16 #+clx-overlapping-arrays (make-array (index-ash size -1) :element-type 'overlap16 :displaced-to byte-input) #+clx-overlapping-arrays :ibuf32 #+clx-overlapping-arrays (make-array (index-ash size -2) :element-type 'overlap32 :displaced-to byte-input)))) (defun buffer-ensure-size (buffer size) (declare (type buffer buffer) (type array-index size)) (when (index> size (buffer-size buffer)) (with-buffer (buffer) (buffer-flush buffer) (let* ((new-buffer-size (index-ash 1 (integer-length (index1- size)))) (new-buffer (make-array new-buffer-size :element-type 'card8 :initial-element 0))) (setf (buffer-obuf8 buffer) new-buffer) #+clx-overlapping-arrays (setf (buffer-obuf16 buffer) (make-array (index-ash new-buffer-size -1) :element-type 'overlap16 :displaced-to new-buffer) (buffer-obuf32 buffer) (make-array (index-ash new-buffer-size -2) :element-type 'overlap32 :displaced-to new-buffer)))))) (defun buffer-pad-request (buffer pad) (declare (type buffer buffer) (type array-index pad)) (unless (index-zerop pad) (when (index> (index+ (buffer-boffset buffer) pad) (buffer-size buffer)) (buffer-flush buffer)) (incf (buffer-boffset buffer) pad) (unless (index-zerop (index-mod (buffer-boffset buffer) 4)) (buffer-flush buffer)))) (declaim (inline buffer-new-request-number)) (defun buffer-new-request-number (buffer) (declare (type buffer buffer)) (setf (buffer-request-number buffer) (ldb (byte 16 0) (1+ (buffer-request-number buffer))))) (defun with-buffer-request-function (display gc-force request-function) (declare (type display display) (type (or null gcontext) gc-force)) (declare (type function request-function) #+clx-ansi-common-lisp (dynamic-extent request-function) #+(and lispm (not clx-ansi-common-lisp)) (sys:downward-funarg request-function)) (with-buffer (display :inline t) (multiple-value-prog1 (progn (when gc-force (force-gcontext-changes-internal gc-force)) (without-aborts (funcall request-function display))) (display-invoke-after-function display)))) (defun with-buffer-request-function-nolock (display gc-force request-function) (declare (type display display) (type (or null gcontext) gc-force)) (declare (type function request-function) #+clx-ansi-common-lisp (dynamic-extent request-function) #+(and lispm (not clx-ansi-common-lisp)) (sys:downward-funarg request-function)) (multiple-value-prog1 (progn (when gc-force (force-gcontext-changes-internal gc-force)) (without-aborts (funcall request-function display))) (display-invoke-after-function display))) (defstruct (pending-command (:copier nil) (:predicate nil)) (sequence 0 :type card16) (reply-buffer nil :type (or null reply-buffer)) (process nil) (next nil #-explorer :type #-explorer (or null pending-command))) (defun with-buffer-request-and-reply-function (display multiple-reply request-function reply-function) (declare (type display display) (type generalized-boolean multiple-reply)) (declare (type function request-function reply-function) #+clx-ansi-common-lisp (dynamic-extent request-function reply-function) #+(and lispm (not clx-ansi-common-lisp)) (sys:downward-funarg request-function reply-function)) (let ((pending-command nil) (reply-buffer nil)) (declare (type (or null pending-command) pending-command) (type (or null reply-buffer) reply-buffer)) (unwind-protect (progn (with-buffer (display :inline t) (setq pending-command (start-pending-command display)) (without-aborts (funcall request-function display)) (buffer-force-output display) (display-invoke-after-function display)) (cond (multiple-reply (loop (setq reply-buffer (read-reply display pending-command)) (when (funcall reply-function display reply-buffer) (return nil)) (deallocate-reply-buffer (shiftf reply-buffer nil)))) (t (setq reply-buffer (read-reply display pending-command)) (funcall reply-function display reply-buffer)))) (when reply-buffer (deallocate-reply-buffer reply-buffer)) (when pending-command (stop-pending-command display pending-command))))) ;; ;; Buffer stream operations ;; (defun buffer-write (vector buffer start end) ;; Write out VECTOR from START to END into BUFFER ;; Internal function, MUST BE CALLED FROM WITHIN WITH-BUFFER (declare (type buffer buffer) (type array-index start end)) (when (buffer-dead buffer) (x-error 'closed-display :display buffer)) (wrap-buf-output (buffer) (funcall (buffer-write-function buffer) vector buffer start end)) nil) (defun buffer-flush (buffer) ;; Write the buffer contents to the server stream - doesn't force-output the stream ;; Internal function, MUST BE CALLED FROM WITHIN WITH-BUFFER (declare (type buffer buffer)) (unless (buffer-flush-inhibit buffer) (let ((boffset (buffer-boffset buffer))) (declare (type array-index boffset)) (when (index-plusp boffset) (buffer-write (buffer-obuf8 buffer) buffer 0 boffset) (setf (buffer-boffset buffer) 0) (setf (buffer-last-request buffer) nil)))) nil) (defmacro with-buffer-flush-inhibited ((buffer) &body body) (let ((buf (if (or (symbolp buffer) (constantp buffer)) buffer '.buffer.))) `(let* (,@(and (not (eq buf buffer)) `((,buf ,buffer))) (.saved-buffer-flush-inhibit. (buffer-flush-inhibit ,buf))) (unwind-protect (progn (setf (buffer-flush-inhibit ,buf) t) ,@body) (setf (buffer-flush-inhibit ,buf) .saved-buffer-flush-inhibit.))))) (defun buffer-force-output (buffer) ;; Output is normally buffered, this forces any buffered output to the server. (declare (type buffer buffer)) (when (buffer-dead buffer) (x-error 'closed-display :display buffer)) (buffer-flush buffer) (wrap-buf-output (buffer) (without-aborts (funcall (buffer-force-output-function buffer) buffer))) nil) (defun close-buffer (buffer &key abort) ;; Close the host connection in BUFFER (declare (type buffer buffer)) (unless (null (buffer-output-stream buffer)) (wrap-buf-output (buffer) (funcall (buffer-close-function buffer) buffer :abort abort)) (setf (buffer-dead buffer) t) ;; Zap pointers to the streams, to ensure they're GC'd (setf (buffer-output-stream buffer) nil) (setf (buffer-input-stream buffer) nil) ) nil) (defun buffer-input (buffer vector start end &optional timeout) ;; Read into VECTOR from the buffer stream ;; Timeout, when non-nil, is in seconds ;; Returns non-nil if EOF encountered ;; Returns :TIMEOUT when timeout exceeded (declare (type buffer buffer) (type vector vector) (type array-index start end) (type (or null number) timeout)) (declare (clx-values eof-p)) (when (buffer-dead buffer) (x-error 'closed-display :display buffer)) (unless (= start end) (let ((result (wrap-buf-input (buffer) (funcall (buffer-input-function buffer) buffer vector start end timeout)))) (unless (or (null result) (eq result :timeout)) (close-buffer buffer)) result))) (defun buffer-input-wait (buffer timeout) ;; Timeout, when non-nil, is in seconds ;; Returns non-nil if EOF encountered ;; Returns :TIMEOUT when timeout exceeded (declare (type buffer buffer) (type (or null number) timeout)) (declare (clx-values timeout)) (when (buffer-dead buffer) (x-error 'closed-display :display buffer)) (let ((result (wrap-buf-input (buffer) (funcall (buffer-input-wait-function buffer) buffer timeout)))) (unless (or (null result) (eq result :timeout)) (close-buffer buffer)) result)) (defun buffer-listen (buffer) ;; Returns T if there is input available for the buffer. This should never ;; block, so it can be called from the scheduler. (declare (type buffer buffer)) (declare (clx-values input-available)) (or (not (null (buffer-dead buffer))) (wrap-buf-input (buffer) (funcall (buffer-listen-function buffer) buffer)))) ;;; Reading sequences of strings ;;; a list of pascal-strings with card8 lengths, no padding in between ;;; can't use read-sequence-char (defun read-sequence-string (buffer-bbuf length nitems result-type &optional (buffer-boffset 0)) (declare (type buffer-bytes buffer-bbuf) (type array-index length nitems buffer-boffset)) length (with-vector (buffer-bbuf buffer-bytes) (let ((result (make-sequence result-type nitems))) (do* ((index 0 (index+ index 1 string-length)) (count 0 (index1+ count)) (string-length 0) (string "")) ((index>= count nitems) result) (declare (type array-index index count string-length) (type string string)) (setq string-length (read-card8 index) string (make-sequence 'string string-length)) (do ((i (index1+ index) (index1+ i)) (j 0 (index1+ j))) ((index>= j string-length) (setf (elt result count) string)) (declare (type array-index i j)) (setf (aref string j) (card8->char (read-card8 i)))))))) ;;; Reading sequences of chars (defmacro define-transformed-sequence-reader (name totype transformer reader) (let ((ntrans (gensym))) `(defun ,name (reply-buffer result-type nitems &optional transform data (start 0) (index 0)) (declare (type reply-buffer reply-buffer) (type t result-type) (type array-index nitems start index) (type (or null sequence) data) (type (or null (function (,totype) t)) transform) #+clx-ansi-common-lisp (dynamic-extent transform) #+(and lispm (not clx-ansi-common-lisp)) (sys:downward-funarg transform)) (if transform (flet ((,ntrans (v) (funcall transform (,transformer v)))) #+clx-ansi-common-lisp (declare (dynamic-extent #',ntrans)) (,reader reply-buffer result-type nitems #',ntrans data start index)) (,reader reply-buffer result-type nitems #',transformer data start index))))) (define-transformed-sequence-reader read-sequence-char character card8->char read-sequence-card8) ;;; Reading sequences of card8's (defmacro define-list-readers ((name tname) type size step reader) `(progn (defun ,name (reply-buffer nitems data start index) (declare (type reply-buffer reply-buffer) (type array-index nitems start index) (type list data)) (with-buffer-input (reply-buffer :sizes (,size) :index index) (do* ((j nitems (index- j 1)) (list (nthcdr start data) (cdr list)) (index 0 (index+ index ,step))) ((index-zerop j)) (declare (type array-index index j) (type list list)) (setf (car list) (,reader index))))) (defun ,tname (reply-buffer nitems data transform start index) (declare (type reply-buffer reply-buffer) (type array-index nitems start index) (type list data) (type (function (,type) t) transform) #+clx-ansi-common-lisp (dynamic-extent transform) #+(and lispm (not clx-ansi-common-lisp)) (sys:downward-funarg transform)) (with-buffer-input (reply-buffer :sizes (,size) :index index) (do* ((j nitems (index- j 1)) (list (nthcdr start data) (cdr list)) (index 0 (index+ index ,step))) ((index-zerop j)) (declare (type array-index index j) (type list list)) (setf (car list) (funcall transform (,reader index)))))))) (define-list-readers (read-list-card8 read-list-card8-with-transform) card8 8 1 read-card8) #-lispm (defun read-simple-array-card8 (reply-buffer nitems data start index) (declare (type reply-buffer reply-buffer) (type array-index nitems start index) (type (simple-array card8 (*)) data)) (with-vector (data (simple-array card8 (*))) (with-buffer-input (reply-buffer :sizes (8)) (buffer-replace data buffer-bbuf start (index+ start nitems) index)))) #-lispm (defun read-simple-array-card8-with-transform (reply-buffer nitems data transform start index) (declare (type reply-buffer reply-buffer) (type array-index nitems start index) (type (simple-array card8 (*)) data)) (declare (type (function (card8) card8) transform) #+clx-ansi-common-lisp (dynamic-extent transform) #+(and lispm (not clx-ansi-common-lisp)) (sys:downward-funarg transform)) (with-vector (data (simple-array card8 (*))) (with-buffer-input (reply-buffer :sizes (8) :index index) (do* ((j start (index+ j 1)) (end (index+ start nitems)) (index 0 (index+ index 1))) ((index>= j end)) (declare (type array-index j end index)) (setf (aref data j) (the card8 (funcall transform (read-card8 index)))))))) (defun read-vector-card8 (reply-buffer nitems data start index) (declare (type reply-buffer reply-buffer) (type array-index nitems start index) (type vector data) (optimize #+cmu(ext:inhibit-warnings 3))) (with-vector (data vector) (with-buffer-input (reply-buffer :sizes (8) :index index) (do* ((j start (index+ j 1)) (end (index+ start nitems)) (index 0 (index+ index 1))) ((index>= j end)) (declare (type array-index j end index)) (setf (aref data j) (read-card8 index)))))) (defun read-vector-card8-with-transform (reply-buffer nitems data transform start index) (declare (type reply-buffer reply-buffer) (type array-index nitems start index) (type vector data) (optimize #+cmu(ext:inhibit-warnings 3))) (declare (type (function (card8) t) transform) #+clx-ansi-common-lisp (dynamic-extent transform) #+(and lispm (not clx-ansi-common-lisp)) (sys:downward-funarg transform)) (with-vector (data vector) (with-buffer-input (reply-buffer :sizes (8) :index index) (do* ((j start (index+ j 1)) (end (index+ start nitems)) (index 0 (index+ index 1))) ((index>= j end)) (declare (type array-index j end index)) (setf (aref data j) (funcall transform (read-card8 index))))))) (defmacro define-sequence-reader (name type (list tlist) (sa tsa) (vec tvec)) `(defun ,name (reply-buffer result-type nitems &optional transform data (start 0) (index 0)) (declare (type reply-buffer reply-buffer) (type t result-type) (type array-index nitems start index) (type (or null sequence) data) (type (or null (function (,type) t)) transform) #+clx-ansi-common-lisp (dynamic-extent transform) #+(and lispm (not clx-ansi-common-lisp)) (sys:downward-funarg transform)) (let ((result (or data (make-sequence result-type nitems)))) (typecase result (list (if transform (,tlist reply-buffer nitems result transform start index) (,list reply-buffer nitems result start index))) #-lispm ((simple-array ,type (*)) (if transform (,tsa reply-buffer nitems result transform start index) (,sa reply-buffer nitems result start index))) ;; FIXME: general sequences (t (if transform (,tvec reply-buffer nitems result transform start index) (,vec reply-buffer nitems result start index)))) result))) (define-sequence-reader read-sequence-card8 card8 (read-list-card8 read-list-card8-with-transform) (read-simple-array-card8 read-simple-array-card8-with-transform) (read-vector-card8 read-vector-card8-with-transform)) (define-transformed-sequence-reader read-sequence-int8 int8 card8->int8 read-sequence-card8) ;;; Reading sequences of card16's (define-list-readers (read-list-card16 read-list-card16-with-transform) card16 16 2 read-card16) #-lispm (defun read-simple-array-card16 (reply-buffer nitems data start index) (declare (type reply-buffer reply-buffer) (type array-index nitems start index) (type (simple-array card16 (*)) data)) (with-vector (data (simple-array card16 (*))) (with-buffer-input (reply-buffer :sizes (16) :index index) #-clx-overlapping-arrays (do* ((j start (index+ j 1)) (end (index+ start nitems)) (index 0 (index+ index 2))) ((index>= j end)) (declare (type array-index j end index)) (setf (aref data j) (the card16 (read-card16 index)))) #+clx-overlapping-arrays (buffer-replace data buffer-wbuf start (index+ start nitems) (index-floor index 2))))) #-lispm (defun read-simple-array-card16-with-transform (reply-buffer nitems data transform start index) (declare (type reply-buffer reply-buffer) (type array-index nitems start index) (type (simple-array card16 (*)) data)) (declare (type (function (card16) card16) transform) #+clx-ansi-common-lisp (dynamic-extent transform) #+(and lispm (not clx-ansi-common-lisp)) (sys:downward-funarg transform)) (with-vector (data (simple-array card16 (*))) (with-buffer-input (reply-buffer :sizes (16) :index index) (do* ((j start (index+ j 1)) (end (index+ start nitems)) (index 0 (index+ index 2))) ((index>= j end)) (declare (type array-index j end index)) (setf (aref data j) (the card16 (funcall transform (read-card16 index)))))))) (defun read-vector-card16 (reply-buffer nitems data start index) (declare (type reply-buffer reply-buffer) (type array-index nitems start index) (type vector data) (optimize #+cmu(ext:inhibit-warnings 3))) (with-vector (data vector) (with-buffer-input (reply-buffer :sizes (16) :index index) #-clx-overlapping-arrays (do* ((j start (index+ j 1)) (end (index+ start nitems)) (index 0 (index+ index 2))) ((index>= j end)) (declare (type array-index j end index)) (setf (aref data j) (read-card16 index))) #+clx-overlapping-arrays (buffer-replace data buffer-wbuf start (index+ start nitems) (index-floor index 2))))) (defun read-vector-card16-with-transform (reply-buffer nitems data transform start index) (declare (type reply-buffer reply-buffer) (type array-index nitems start index) (type vector data) (optimize #+cmu(ext:inhibit-warnings 3))) (declare (type (function (card16) t) transform) #+clx-ansi-common-lisp (dynamic-extent transform) #+(and lispm (not clx-ansi-common-lisp)) (sys:downward-funarg transform)) (with-vector (data vector) (with-buffer-input (reply-buffer :sizes (16) :index index) (do* ((j start (index+ j 1)) (end (index+ start nitems)) (index 0 (index+ index 2))) ((index>= j end)) (declare (type array-index j end index)) (setf (aref data j) (funcall transform (read-card16 index))))))) (define-sequence-reader read-sequence-card16 card16 (read-list-card16 read-list-card16-with-transform) (read-simple-array-card16 read-simple-array-card16-with-transform) (read-vector-card16 read-vector-card16-with-transform)) (define-transformed-sequence-reader read-sequence-int16 int16 card16->int16 read-sequence-card16) ;;; Reading sequences of card32's (define-list-readers (read-list-card32 read-list-card32-with-transform) card32 32 4 read-card32) #-lispm (defun read-simple-array-card32 (reply-buffer nitems data start index) (declare (type reply-buffer reply-buffer) (type array-index nitems start index) (type (simple-array card32 (*)) data)) (with-vector (data (simple-array card32 (*))) (with-buffer-input (reply-buffer :sizes (32) :index index) #-clx-overlapping-arrays (do* ((j start (index+ j 1)) (end (index+ start nitems)) (index 0 (index+ index 4))) ((index>= j end)) (declare (type array-index j end index)) (setf (aref data j) (the card32 (read-card32 index)))) #+clx-overlapping-arrays (buffer-replace data buffer-lbuf start (index+ start nitems) (index-floor index 4))))) #-lispm (defun read-simple-array-card32-with-transform (reply-buffer nitems data transform start index) (declare (type reply-buffer reply-buffer) (type array-index nitems start index) (type (simple-array card32 (*)) data)) (declare (type (function (card32) card32) transform) #+clx-ansi-common-lisp (dynamic-extent transform) #+(and lispm (not clx-ansi-common-lisp)) (sys:downward-funarg transform)) (with-vector (data (simple-array card32 (*))) (with-buffer-input (reply-buffer :sizes (32) :index index) (do* ((j start (index+ j 1)) (end (index+ start nitems)) (index 0 (index+ index 4))) ((index>= j end)) (declare (type array-index j end index)) (setf (aref data j) (the card32 (funcall transform (read-card32 index)))))))) (defun read-vector-card32 (reply-buffer nitems data start index) (declare (type reply-buffer reply-buffer) (type array-index nitems start index) (type vector data) (optimize #+cmu(ext:inhibit-warnings 3))) (with-vector (data vector) (with-buffer-input (reply-buffer :sizes (32) :index index) #-clx-overlapping-arrays (do* ((j start (index+ j 1)) (end (index+ start nitems)) (index 0 (index+ index 4))) ((index>= j end)) (declare (type array-index j end index)) (setf (aref data j) (read-card32 index))) #+clx-overlapping-arrays (buffer-replace data buffer-lbuf start (index+ start nitems) (index-floor index 4))))) (defun read-vector-card32-with-transform (reply-buffer nitems data transform start index) (declare (type reply-buffer reply-buffer) (type array-index nitems start index) (type vector data) (optimize #+cmu(ext:inhibit-warnings 3))) (declare (type (function (card32) t) transform) #+clx-ansi-common-lisp (dynamic-extent transform) #+(and lispm (not clx-ansi-common-lisp)) (sys:downward-funarg transform)) (with-vector (data vector) (with-buffer-input (reply-buffer :sizes (32) :index index) (do* ((j start (index+ j 1)) (end (index+ start nitems)) (index 0 (index+ index 4))) ((index>= j end)) (declare (type array-index j end index)) (setf (aref data j) (funcall transform (read-card32 index))))))) (define-sequence-reader read-sequence-card32 card32 (read-list-card32 read-list-card32-with-transform) (read-simple-array-card32 read-simple-array-card32-with-transform) (read-vector-card32 read-vector-card32-with-transform)) (define-transformed-sequence-reader read-sequence-int32 int32 card32->int32 read-sequence-card32) ;;; Writing sequences of chars (defmacro define-transformed-sequence-writer (name fromtype transformer writer) (let ((ntrans (gensym))) `(defun ,name (buffer boffset data &optional (start 0) (end (length data)) transform) (declare (type buffer buffer) (type sequence data) (type array-index boffset start end) (type (or null (function (t) ,fromtype)) transform) #+clx-ansi-common-lisp (dynamic-extent transform) #+(and lispm (not clx-ansi-common-lisp)) (sys:downward-funarg transform)) (if transform (flet ((,ntrans (x) (,transformer (the ,fromtype (funcall transform x))))) #+clx-ansi-common-lisp (declare (dynamic-extent #',ntrans)) (,writer buffer boffset data start end #',ntrans)) (,writer buffer boffset data start end #',transformer))))) (define-transformed-sequence-writer write-sequence-char character char->card8 write-sequence-card8) ;;; Writing sequences of card8's (defmacro define-list-writers ((name tname) type step writer) `(progn (defun ,name (buffer boffset data start end) (declare (type buffer buffer) (type list data) (type array-index boffset start end)) (writing-buffer-chunks ,type ((list (nthcdr start data))) ((type list list)) (do ((j 0 (index+ j ,step))) ((index>= j chunk)) (declare (type array-index j)) (,writer j (pop list))))) (defun ,tname (buffer boffset data start end transform) (declare (type buffer buffer) (type list data) (type array-index boffset start end) (type (function (t) ,type) transform) #+clx-ansi-common-lisp (dynamic-extent transform) #+(and lispm (not clx-ansi-common-lisp)) (sys:downward-funarg transform)) (writing-buffer-chunks ,type ((list (nthcdr start data))) ((type list list)) (do ((j 0 (index+ j ,step))) ((index>= j chunk)) (declare (type array-index j)) (,writer j (funcall transform (pop list)))))))) ;;; original CLX comment: "TI Compiler bug", in WRITE-LIST-CARD8 #+ti (progn (defun write-list-card8 (buffer boffset data start end) (writing-buffer-chunks card8 ((list (nthcdr start data))) ((type list list)) (dotimes (j chunk) (setf (aref buffer-bbuf (index+ buffer-boffset j)) (pop list))))) (defun write-list-card8-with-transform (buffer boffset data start end transform) (writing-buffer-chunks card8 ((list (nthcdr start data))) ((type list lst)) (dotimes (j chunk) (declare (type array-index j)) (write-card8 j (funcall transform (pop lst))))))) #-ti (define-list-writers (write-list-card8 write-list-card8-with-transform) card8 1 write-card8) ;;; Should really write directly from data, instead of into the buffer first #-lispm (defun write-simple-array-card8 (buffer boffset data start end) (declare (type buffer buffer) (type (simple-array card8 (*)) data) (type array-index boffset start end)) (with-vector (data (simple-array card8 (*))) (writing-buffer-chunks card8 ((index start (index+ index chunk))) ((type array-index index)) (buffer-replace buffer-bbuf data buffer-boffset (index+ buffer-boffset chunk) index))) nil) #-lispm (defun write-simple-array-card8-with-transform (buffer boffset data start end transform) (declare (type buffer buffer) (type (simple-array card8 (*)) data) (type array-index boffset start end)) (declare (type (function (card8) card8) transform) #+clx-ansi-common-lisp (dynamic-extent transform) #+(and lispm (not clx-ansi-common-lisp)) (sys:downward-funarg transform)) (with-vector (data (simple-array card8 (*))) (writing-buffer-chunks card8 ((index start)) ((type array-index index)) (dotimes (j chunk) (declare (type array-index j)) (write-card8 j (funcall transform (aref data index))) (setq index (index+ index 1))))) nil) (defun write-vector-card8 (buffer boffset data start end) (declare (type buffer buffer) (type vector data) (type array-index boffset start end) (optimize #+cmu(ext:inhibit-warnings 3))) (with-vector (data vector) (writing-buffer-chunks card8 ((index start)) ((type array-index index)) (dotimes (j chunk) (declare (type array-index j)) (write-card8 j (aref data index)) (setq index (index+ index 1))))) nil) (defun write-vector-card8-with-transform (buffer boffset data start end transform) (declare (type buffer buffer) (type vector data) (type array-index boffset start end)) (declare (type (function (t) card8) transform) #+clx-ansi-common-lisp (dynamic-extent transform) #+(and lispm (not clx-ansi-common-lisp)) (sys:downward-funarg transform)) (with-vector (data vector) (writing-buffer-chunks card8 ((index start)) ((type array-index index)) (dotimes (j chunk) (declare (type array-index j)) (write-card8 j (funcall transform (aref data index))) (setq index (index+ index 1))))) nil) (defmacro define-sequence-writer (name type (list tlist) (sa tsa) (vec tvec)) `(defun ,name (buffer boffset data &optional (start 0) (end (length data)) transform) (declare (type buffer buffer) (type sequence data) (type array-index boffset start end) (type (or null (function (t) ,type)) transform) #+clx-ansi-common-lisp (dynamic-extent transform) #+(and lispm (not clx-ansi-common-lisp)) (sys:downward-funarg transform)) (typecase data (list (if transform (,tlist buffer boffset data start end transform) (,list buffer boffset data start end))) #-lispm ((simple-array ,type (*)) (if transform (,tsa buffer boffset data start end transform) (,sa buffer boffset data start end))) (t ; FIXME: general sequences (if transform (,tvec buffer boffset data start end transform) (,vec buffer boffset data start end)))))) (define-sequence-writer write-sequence-card8 card8 (write-list-card8 write-list-card8-with-transform) (write-simple-array-card8 write-simple-array-card8-with-transform) (write-vector-card8 write-vector-card8-with-transform)) (define-transformed-sequence-writer write-sequence-int8 int8 int8->card8 write-sequence-card8) ;;; Writing sequences of card16's (define-list-writers (write-list-card16 write-list-card16-with-transform) card16 2 write-card16) #-lispm (defun write-simple-array-card16 (buffer boffset data start end) (declare (type buffer buffer) (type (simple-array card16 (*)) data) (type array-index boffset start end)) (with-vector (data (simple-array card16 (*))) (writing-buffer-chunks card16 ((index start)) ((type array-index index)) ;; Depends upon the chunks being an even multiple of card16's big (do ((j 0 (index+ j 2))) ((index>= j chunk)) (declare (type array-index j)) (write-card16 j (aref data index)) (setq index (index+ index 1))) ;; overlapping case (let ((length (floor chunk 2))) (buffer-replace buffer-wbuf data buffer-woffset (index+ buffer-woffset length) index) (setq index (index+ index length))))) nil) #-lispm (defun write-simple-array-card16-with-transform (buffer boffset data start end transform) (declare (type buffer buffer) (type (simple-array card16 (*)) data) (type array-index boffset start end)) (declare (type (function (card16) card16) transform) #+clx-ansi-common-lisp (dynamic-extent transform) #+(and lispm (not clx-ansi-common-lisp)) (sys:downward-funarg transform)) (with-vector (data (simple-array card16 (*))) (writing-buffer-chunks card16 ((index start)) ((type array-index index)) ;; Depends upon the chunks being an even multiple of card16's big (do ((j 0 (index+ j 2))) ((index>= j chunk)) (declare (type array-index j)) (write-card16 j (funcall transform (aref data index))) (setq index (index+ index 1))))) nil) (defun write-vector-card16 (buffer boffset data start end) (declare (type buffer buffer) (type vector data) (type array-index boffset start end) (optimize #+cmu(ext:inhibit-warnings 3))) (with-vector (data vector) (writing-buffer-chunks card16 ((index start)) ((type array-index index)) ;; Depends upon the chunks being an even multiple of card16's big (do ((j 0 (index+ j 2))) ((index>= j chunk)) (declare (type array-index j)) (write-card16 j (aref data index)) (setq index (index+ index 1))) ;; overlapping case (let ((length (floor chunk 2))) (buffer-replace buffer-wbuf data buffer-woffset (index+ buffer-woffset length) index) (setq index (index+ index length))))) nil) (defun write-vector-card16-with-transform (buffer boffset data start end transform) (declare (type buffer buffer) (type vector data) (type array-index boffset start end) (optimize #+cmu(ext:inhibit-warnings 3))) (declare (type (function (t) card16) transform) #+clx-ansi-common-lisp (dynamic-extent transform) #+(and lispm (not clx-ansi-common-lisp)) (sys:downward-funarg transform)) (with-vector (data vector) (writing-buffer-chunks card16 ((index start)) ((type array-index index)) ;; Depends upon the chunks being an even multiple of card16's big (do ((j 0 (index+ j 2))) ((index>= j chunk)) (declare (type array-index j)) (write-card16 j (funcall transform (aref data index))) (setq index (index+ index 1))))) nil) (define-sequence-writer write-sequence-card16 card16 (write-list-card16 write-list-card16-with-transform) (write-simple-array-card16 write-simple-array-card16-with-transform) (write-vector-card16 write-vector-card16-with-transform)) ;;; Writing sequences of int16's (define-list-writers (write-list-int16 write-list-int16-with-transform) int16 2 write-int16) #-lispm (defun write-simple-array-int16 (buffer boffset data start end) (declare (type buffer buffer) (type (simple-array int16 (*)) data) (type array-index boffset start end)) (with-vector (data (simple-array int16 (*))) (writing-buffer-chunks int16 ((index start)) ((type array-index index)) ;; Depends upon the chunks being an even multiple of int16's big (do ((j 0 (index+ j 2))) ((index>= j chunk)) (declare (type array-index j)) (write-int16 j (aref data index)) (setq index (index+ index 1))) ;; overlapping case (let ((length (floor chunk 2))) (buffer-replace buffer-wbuf data buffer-woffset (index+ buffer-woffset length) index) (setq index (index+ index length))))) nil) #-lispm (defun write-simple-array-int16-with-transform (buffer boffset data start end transform) (declare (type buffer buffer) (type (simple-array int16 (*)) data) (type array-index boffset start end)) (declare (type (function (int16) int16) transform) #+clx-ansi-common-lisp (dynamic-extent transform) #+(and lispm (not clx-ansi-common-lisp)) (sys:downward-funarg transform)) (with-vector (data (simple-array int16 (*))) (writing-buffer-chunks int16 ((index start)) ((type array-index index)) ;; Depends upon the chunks being an even multiple of int16's big (do ((j 0 (index+ j 2))) ((index>= j chunk)) (declare (type array-index j)) (write-int16 j (funcall transform (aref data index))) (setq index (index+ index 1))))) nil) (defun write-vector-int16 (buffer boffset data start end) (declare (type buffer buffer) (type vector data) (type array-index boffset start end) (optimize #+cmu(ext:inhibit-warnings 3))) (with-vector (data vector) (writing-buffer-chunks int16 ((index start)) ((type array-index index)) ;; Depends upon the chunks being an even multiple of int16's big (do ((j 0 (index+ j 2))) ((index>= j chunk)) (declare (type array-index j)) (write-int16 j (aref data index)) (setq index (index+ index 1))) ;; overlapping case (let ((length (floor chunk 2))) (buffer-replace buffer-wbuf data buffer-woffset (index+ buffer-woffset length) index) (setq index (index+ index length))))) nil) (defun write-vector-int16-with-transform (buffer boffset data start end transform) (declare (type buffer buffer) (type vector data) (type array-index boffset start end) (optimize #+cmu(ext:inhibit-warnings 3))) (declare (type (function (t) int16) transform) #+clx-ansi-common-lisp (dynamic-extent transform) #+(and lispm (not clx-ansi-common-lisp)) (sys:downward-funarg transform)) (with-vector (data vector) (writing-buffer-chunks int16 ((index start)) ((type array-index index)) ;; Depends upon the chunks being an even multiple of int16's big (do ((j 0 (index+ j 2))) ((index>= j chunk)) (declare (type array-index j)) (write-int16 j (funcall transform (aref data index))) (setq index (index+ index 1))))) nil) (define-sequence-writer write-sequence-int16 int16 (write-list-int16 write-list-int16-with-transform) (write-simple-array-int16 write-simple-array-int16-with-transform) (write-vector-int16 write-vector-int16-with-transform)) ;;; Writing sequences of card32's (define-list-writers (write-list-card32 write-list-card32-with-transform) card32 4 write-card32) #-lispm (defun write-simple-array-card32 (buffer boffset data start end) (declare (type buffer buffer) (type (simple-array card32 (*)) data) (type array-index boffset start end)) (with-vector (data (simple-array card32 (*))) (writing-buffer-chunks card32 ((index start)) ((type array-index index)) ;; Depends upon the chunks being an even multiple of card32's big (do ((j 0 (index+ j 4))) ((index>= j chunk)) (declare (type array-index j)) (write-card32 j (aref data index)) (setq index (index+ index 1))) ;; overlapping case (let ((length (floor chunk 4))) (buffer-replace buffer-lbuf data buffer-loffset (index+ buffer-loffset length) index) (setq index (index+ index length))))) nil) #-lispm (defun write-simple-array-card32-with-transform (buffer boffset data start end transform) (declare (type buffer buffer) (type (simple-array card32 (*)) data) (type array-index boffset start end)) (declare (type (function (card32) card32) transform) #+clx-ansi-common-lisp (dynamic-extent transform) #+(and lispm (not clx-ansi-common-lisp)) (sys:downward-funarg transform)) (with-vector (data (simple-array card32 (*))) (writing-buffer-chunks card32 ((index start)) ((type array-index index)) ;; Depends upon the chunks being an even multiple of card32's big (do ((j 0 (index+ j 4))) ((index>= j chunk)) (declare (type array-index j)) (write-card32 j (funcall transform (aref data index))) (setq index (index+ index 1))))) nil) (defun write-vector-card32 (buffer boffset data start end) (declare (type buffer buffer) (type vector data) (type array-index boffset start end) (optimize #+cmu(ext:inhibit-warnings 3))) (with-vector (data vector) (writing-buffer-chunks card32 ((index start)) ((type array-index index)) ;; Depends upon the chunks being an even multiple of card32's big (do ((j 0 (index+ j 4))) ((index>= j chunk)) (declare (type array-index j)) (write-card32 j (aref data index)) (setq index (index+ index 1))) ;; overlapping case (let ((length (floor chunk 4))) (buffer-replace buffer-lbuf data buffer-loffset (index+ buffer-loffset length) index) (setq index (index+ index length))))) nil) (defun write-vector-card32-with-transform (buffer boffset data start end transform) (declare (type buffer buffer) (type vector data) (type array-index boffset start end) (optimize #+cmu(ext:inhibit-warnings 3))) (declare (type (function (t) card32) transform) #+clx-ansi-common-lisp (dynamic-extent transform) #+(and lispm (not clx-ansi-common-lisp)) (sys:downward-funarg transform)) (with-vector (data vector) (writing-buffer-chunks card32 ((index start)) ((type array-index index)) ;; Depends upon the chunks being an even multiple of card32's big (do ((j 0 (index+ j 4))) ((index>= j chunk)) (declare (type array-index j)) (write-card32 j (funcall transform (aref data index))) (setq index (index+ index 1))))) nil) (define-sequence-writer write-sequence-card32 card32 (write-list-card32 write-list-card32-with-transform) (write-simple-array-card32 write-simple-array-card32-with-transform) (write-vector-card32 write-vector-card32-with-transform)) (define-transformed-sequence-writer write-sequence-int32 int32 int32->card32 write-sequence-card32) (defun read-bitvector256 (buffer-bbuf boffset data) (declare (type buffer-bytes buffer-bbuf) (type array-index boffset) (type (or null (simple-bit-vector 256)) data)) (let ((result (or data (make-array 256 :element-type 'bit :initial-element 0)))) (declare (type (simple-bit-vector 256) result)) (do ((i (index+ boffset 1) (index+ i 1)) ;; Skip first byte (j 8 (index+ j 8))) ((index>= j 256)) (declare (type array-index i j)) (do ((byte (aref-card8 buffer-bbuf i) (index-ash byte -1)) (k j (index+ k 1))) ((zerop byte) (when data ;; Clear uninitialized bits in data (do ((end (index+ j 8))) ((index= k end)) (declare (type array-index end)) (setf (aref result k) 0) (index-incf k)))) (declare (type array-index k) (type card8 byte)) (setf (aref result k) (the bit (logand byte 1))))) result)) (defun write-bitvector256 (buffer boffset map) (declare (type buffer buffer) (type array-index boffset) (type (simple-array bit (*)) map)) (with-buffer-output (buffer :index boffset :sizes 8) (do* ((i (index+ buffer-boffset 1) (index+ i 1)) ; Skip first byte (j 8 (index+ j 8))) ((index>= j 256)) (declare (type array-index i j)) (do ((byte 0) (bit (index+ j 7) (index- bit 1))) ((index< bit j) (aset-card8 byte buffer-bbuf i)) (declare (type array-index bit) (type card8 byte)) (setq byte (the card8 (logior (the card8 (ash byte 1)) (aref map bit)))))))) ;;; Writing sequences of char2b's (define-list-writers (write-list-char2b write-list-char2b-with-transform) card16 2 write-char2b) #-lispm (defun write-simple-array-char2b (buffer boffset data start end) (declare (type buffer buffer) (type (simple-array card16 (*)) data) (type array-index boffset start end)) (with-vector (data (simple-array card16 (*))) (writing-buffer-chunks card16 ((index start)) ((type array-index index)) (do ((j 0 (index+ j 2))) ((index>= j (1- chunk)) (setf chunk j)) (declare (type array-index j)) (write-char2b j (aref data index)) (setq index (index+ index 1))))) nil) #-lispm (defun write-simple-array-char2b-with-transform (buffer boffset data start end transform) (declare (type buffer buffer) (type (simple-array card16 (*)) data) (type array-index boffset start end)) (declare (type (function (card16) card16) transform) #+clx-ansi-common-lisp (dynamic-extent transform) #+(and lispm (not clx-ansi-common-lisp)) (sys:downward-funarg transform)) (with-vector (data (simple-array card16 (*))) (writing-buffer-chunks card16 ((index start)) ((type array-index index)) (do ((j 0 (index+ j 2))) ((index>= j (1- chunk)) (setf chunk j)) (declare (type array-index j)) (write-char2b j (funcall transform (aref data index))) (setq index (index+ index 1))))) nil) (defun write-vector-char2b (buffer boffset data start end) (declare (type buffer buffer) (type vector data) (type array-index boffset start end) (optimize #+cmu(ext:inhibit-warnings 3))) (with-vector (data vector) (writing-buffer-chunks card16 ((index start)) ((type array-index index)) (do ((j 0 (index+ j 2))) ((index>= j (1- chunk)) (setf chunk j)) (declare (type array-index j)) (write-char2b j (aref data index)) (setq index (index+ index 1))))) nil) (defun write-vector-char2b-with-transform (buffer boffset data start end transform) (declare (type buffer buffer) (type vector data) (type array-index boffset start end) (optimize #+cmu(ext:inhibit-warnings 3))) (declare (type (function (t) card16) transform) #+clx-ansi-common-lisp (dynamic-extent transform) #+(and lispm (not clx-ansi-common-lisp)) (sys:downward-funarg transform)) (with-vector (data vector) (writing-buffer-chunks card16 ((index start)) ((type array-index index)) (do ((j 0 (index+ j 2))) ((index>= j (1- chunk)) (setf chunk j)) (declare (type array-index j)) (write-char2b j (funcall transform (aref data index))) (setq index (index+ index 1))))) nil) (define-sequence-writer write-sequence-char2b card16 (write-list-char2b write-list-char2b-with-transform) (write-simple-array-char2b write-simple-array-char2b-with-transform) (write-vector-char2b write-vector-char2b-with-transform)) ecl-16.1.2/src/clx/bufmac.lisp000066400000000000000000000170551266352375300160730ustar00rootroot00000000000000;;; -*- Mode: LISP; Syntax: Common-lisp; Package: XLIB; Base: 10; Lowercase: Yes -*- ;;; This file contains macro definitions for the BUFFER object for Common-Lisp ;;; X windows version 11 ;;; ;;; TEXAS INSTRUMENTS INCORPORATED ;;; P.O. BOX 2909 ;;; AUSTIN, TEXAS 78769 ;;; ;;; Copyright (C) 1987 Texas Instruments Incorporated. ;;; ;;; Permission is granted to any individual or institution to use, copy, modify, ;;; and distribute this software, provided that this complete copyright and ;;; permission notice is maintained, intact, in all copies and supporting ;;; documentation. ;;; ;;; Texas Instruments Incorporated provides this software "as is" without ;;; express or implied warranty. ;;; (in-package :xlib) ;;; The read- macros are in buffer.lisp, because event-case depends on (most of) them. (defmacro write-card8 (byte-index item) `(aset-card8 (the card8 ,item) buffer-bbuf (index+ buffer-boffset ,byte-index))) (defmacro write-int8 (byte-index item) `(aset-int8 (the int8 ,item) buffer-bbuf (index+ buffer-boffset ,byte-index))) (defmacro write-card16 (byte-index item) #+clx-overlapping-arrays `(aset-card16 (the card16 ,item) buffer-wbuf (index+ buffer-woffset (index-ash ,byte-index -1))) #-clx-overlapping-arrays `(aset-card16 (the card16 ,item) buffer-bbuf (index+ buffer-boffset ,byte-index))) (defmacro write-int16 (byte-index item) #+clx-overlapping-arrays `(aset-int16 (the int16 ,item) buffer-wbuf (index+ buffer-woffset (index-ash ,byte-index -1))) #-clx-overlapping-arrays `(aset-int16 (the int16 ,item) buffer-bbuf (index+ buffer-boffset ,byte-index))) (defmacro write-card32 (byte-index item) #+clx-overlapping-arrays `(aset-card32 (the card32 ,item) buffer-lbuf (index+ buffer-loffset (index-ash ,byte-index -2))) #-clx-overlapping-arrays `(aset-card32 (the card32 ,item) buffer-bbuf (index+ buffer-boffset ,byte-index))) (defmacro write-int32 (byte-index item) #+clx-overlapping-arrays `(aset-int32 (the int32 ,item) buffer-lbuf (index+ buffer-loffset (index-ash ,byte-index -2))) #-clx-overlapping-arrays `(aset-int32 (the int32 ,item) buffer-bbuf (index+ buffer-boffset ,byte-index))) (defmacro write-card29 (byte-index item) #+clx-overlapping-arrays `(aset-card29 (the card29 ,item) buffer-lbuf (index+ buffer-loffset (index-ash ,byte-index -2))) #-clx-overlapping-arrays `(aset-card29 (the card29 ,item) buffer-bbuf (index+ buffer-boffset ,byte-index))) ;; This is used for 2-byte characters, which may not be aligned on 2-byte boundaries ;; and always are written high-order byte first. (defmacro write-char2b (byte-index item) ;; It is impossible to do an overlapping write, so only nonoverlapping here. `(let ((%item ,item) (%byte-index (index+ buffer-boffset ,byte-index))) (declare (type card16 %item) (type array-index %byte-index)) (aset-card8 (the card8 (ldb (byte 8 8) %item)) buffer-bbuf %byte-index) (aset-card8 (the card8 (ldb (byte 8 0) %item)) buffer-bbuf (index+ %byte-index 1)))) (defmacro set-buffer-offset (value &environment env) env `(let ((.boffset. ,value)) (declare (type array-index .boffset.)) (setq buffer-boffset .boffset.) #+clx-overlapping-arrays ,@(when (member 16 (macroexpand '(%buffer-sizes) env)) `((setq buffer-woffset (index-ash .boffset. -1)))) #+clx-overlapping-arrays ,@(when (member 32 (macroexpand '(%buffer-sizes) env)) `((setq buffer-loffset (index-ash .boffset. -2)))) #+clx-overlapping-arrays .boffset.)) (defmacro advance-buffer-offset (value) `(set-buffer-offset (index+ buffer-boffset ,value))) (defmacro with-buffer-output ((buffer &key (sizes '(8 16 32)) length index) &body body) (unless (listp sizes) (setq sizes (list sizes))) `(let ((%buffer ,buffer)) (declare (type display %buffer)) ,(declare-bufmac) ,(when length `(when (index>= (index+ (buffer-boffset %buffer) ,length) (buffer-size %buffer)) (buffer-flush %buffer))) (let* ((buffer-boffset (the array-index ,(or index `(buffer-boffset %buffer)))) #-clx-overlapping-arrays (buffer-bbuf (buffer-obuf8 %buffer)) #+clx-overlapping-arrays ,@(append (when (member 8 sizes) `((buffer-bbuf (buffer-obuf8 %buffer)))) (when (or (member 16 sizes) (member 160 sizes)) `((buffer-woffset (index-ash buffer-boffset -1)) (buffer-wbuf (buffer-obuf16 %buffer)))) (when (member 32 sizes) `((buffer-loffset (index-ash buffer-boffset -2)) (buffer-lbuf (buffer-obuf32 %buffer)))))) (declare (type array-index buffer-boffset)) #-clx-overlapping-arrays (declare (type buffer-bytes buffer-bbuf)) #+clx-overlapping-arrays ,@(append (when (member 8 sizes) '((declare (type buffer-bytes buffer-bbuf)))) (when (member 16 sizes) '((declare (type array-index buffer-woffset)) (declare (type buffer-words buffer-wbuf)))) (when (member 32 sizes) '((declare (type array-index buffer-loffset)) (declare (type buffer-longs buffer-lbuf))))) buffer-boffset #-clx-overlapping-arrays buffer-bbuf #+clx-overlapping-arrays ,@(append (when (member 8 sizes) '(buffer-bbuf)) (when (member 16 sizes) '(buffer-woffset buffer-wbuf)) (when (member 32 sizes) '(buffer-loffset buffer-lbuf))) #+clx-overlapping-arrays (macrolet ((%buffer-sizes () ',sizes)) ,@body) #-clx-overlapping-arrays ,@body))) ;;; This macro is just used internally in buffer (defmacro writing-buffer-chunks (type args decls &body body) (when (> (length body) 2) (error "writing-buffer-chunks called with too many forms")) (let* ((size (* 8 (index-increment type))) (form #-clx-overlapping-arrays (first body) #+clx-overlapping-arrays ; XXX type dependencies (or (second body) (first body)))) `(with-buffer-output (buffer :index boffset :sizes ,(reverse (adjoin size '(8)))) ;; Loop filling the buffer (do* (,@args ;; Number of bytes needed to output (len ,(if (= size 8) `(index- end start) `(index-ash (index- end start) ,(truncate size 16))) (index- len chunk)) ;; Number of bytes available in buffer (chunk (index-min len (index- (buffer-size buffer) buffer-boffset)) (index-min len (index- (buffer-size buffer) buffer-boffset)))) ((not (index-plusp len))) (declare ,@decls (type array-index len chunk)) ,form (index-incf buffer-boffset chunk) ;; Flush the buffer (when (and (index-plusp len) (index>= buffer-boffset (buffer-size buffer))) (setf (buffer-boffset buffer) buffer-boffset) (buffer-flush buffer) (setq buffer-boffset (buffer-boffset buffer)) #+clx-overlapping-arrays ,(case size (16 '(setq buffer-woffset (index-ash buffer-boffset -1))) (32 '(setq buffer-loffset (index-ash buffer-boffset -2)))))) (setf (buffer-boffset buffer) (lround buffer-boffset))))) ecl-16.1.2/src/clx/build-clx.lisp000066400000000000000000000016371266352375300165200ustar00rootroot00000000000000;;; -*- Mode: Lisp; Package: Xlib; Log: clx.log -*- ;;; Load this file if you want to compile CLX in its entirety. (proclaim '(optimize (speed 3) (safety 1) (space 1) (compilation-speed 0))) ;;; Hide CLOS from CLX, so objects stay implemented as structures. ;;; #|| (when (find-package "CLOS") (rename-package (find-package "CLOS") "NO-CLOS-HERE")) (when (find-package "PCL") (rename-package (find-package "PCL") "NO-PCL-HERE")) (when (find-package "SB-PCL") (rename-package (find-package "SB-PCL") "NO-SB-PCL-HERE")) ||# (when (find-package "XLIB") (delete-package "XLIB")) (unless (find-package "XLIB") (make-package "XLIB" :use '("COMMON-LISP"))) #-sbcl (compile-file "clx:defsystem.lisp" :error-file nil :load t) #+sbcl (progn (compile-file "clx:defsystem.lisp") (load "clx:defsystem")) (with-compilation-unit () (#+cmu xlib:compile-clx #-cmu compile-clx (pathname "CLX:"))) ecl-16.1.2/src/clx/clx-module.lisp000066400000000000000000000002401266352375300166730ustar00rootroot00000000000000;;;(in-package :xlib) ;;;(common-lisp:use-package (list :common-lisp)) (provide :clx) (load "clx:defsystem.lisp") (load-clx (translate-logical-pathname "CLX:"))ecl-16.1.2/src/clx/clx.asd000066400000000000000000000176201266352375300152220ustar00rootroot00000000000000;;; -*- Lisp -*- mode ;;; Original copyright message from defsystem.lisp: ;;; TEXAS INSTRUMENTS INCORPORATED ;;; P.O. BOX 2909 ;;; AUSTIN, TEXAS 78769 ;;; ;;; Portions Copyright (C) 1987 Texas Instruments Incorporated. ;;; Portions Copyright (C) 1988, 1989 Franz Inc, Berkeley, Ca. ;;; ;;; Permission is granted to any individual or institution to use, ;;; copy, modify, and distribute this software, provided that this ;;; complete copyright and permission notice is maintained, intact, in ;;; all copies and supporting documentation. ;;; ;;; Texas Instruments Incorporated provides this software "as is" ;;; without express or implied warranty. ;;; ;;; Franz Incorporated provides this software "as is" without express ;;; or implied warranty. (defpackage :clx-system (:use :cl :asdf)) (in-package :clx-system) (pushnew :clx-ansi-common-lisp *features*) (defclass clx-source-file (cl-source-file) ()) (defclass xrender-source-file (clx-source-file) ()) ;;; CL-SOURCE-FILE, not CLX-SOURCE-FILE, so that we're not accused of ;;; cheating by rebinding *DERIVE-FUNCTION-TYPES* :-) (defclass example-source-file (cl-source-file) ()) (defclass legacy-file (static-file) ()) (defsystem CLX :depends-on (#+sbcl sb-bsd-sockets) :version "0.7.2" :serial t :default-component-class clx-source-file :components ((:file "package") (:file "depdefs") (:file "clx") #-(or openmcl allegro) (:file "dependent") #+openmcl (:file "dep-openmcl") #+allegro (:file "dep-allegro") (:file "macros") (:file "bufmac") (:file "buffer") (:file "display") (:file "gcontext") (:file "input") (:file "requests") (:file "fonts") (:file "graphics") (:file "text") (:file "attributes") (:file "translate") (:file "keysyms") (:file "manager") (:file "image") (:file "resource") #+allegro (:file "excldep" :pathname "excldep.lisp") (:module extensions :pathname #.(make-pathname :directory '(:relative)) :components ((:file "shape") (:file "big-requests") (:file "xvidmode") (:xrender-source-file "xrender") (:file "glx") (:file "gl" :depends-on ("glx")) (:file "dpms") (:file "xtest") (:file "screensaver") (:file "xinerama"))) (:module demo :default-component-class example-source-file :components ((:file "bezier") ;; KLUDGE: this requires "bezier" for proper operation, ;; but we don't declare that dependency here, because ;; asdf doesn't load example files anyway. (:file "beziertest") (:file "clclock") (:file "clipboard") (:file "clx-demos") (:file "gl-test") ;; FIXME: compiling this generates 30-odd spurious code ;; deletion notes. Find out why, and either fix or ;; workaround the problem. (:file "mandel") (:file "menu") (:file "zoid"))) (:module test :default-component-class example-source-file :components ((:file "image") ;; KLUDGE: again, this depends on "zoid" (:file "trapezoid"))) (:static-file "NEWS") (:static-file "CHANGES") (:static-file "README") (:static-file "README-R5") (:legacy-file "exclMakefile") (:legacy-file "exclREADME") (:legacy-file "exclcmac" :pathname "exclcmac.lisp") (:legacy-file "excldepc" :pathname "excldep.c") (:legacy-file "sockcl" :pathname "sockcl.lisp") (:legacy-file "socket" :pathname "socket.c") (:legacy-file "defsystem" :pathname "defsystem.lisp") (:legacy-file "provide" :pathname "provide.lisp") (:legacy-file "cmudep" :pathname "cmudep.lisp") (:module manual ;; TODO: teach asdf how to process texinfo files :components ((:static-file "clx.texinfo"))) (:module debug :default-component-class legacy-file :components ((:file "debug" :pathname "debug.lisp") (:file "describe" :pathname "describe.lisp") (:file "event-test" :pathname "event-test.lisp") (:file "keytrans" :pathname "keytrans.lisp") (:file "trace" :pathname "trace.lisp") (:file "util" :pathname "util.lisp"))))) (defmethod perform ((o load-op) (f example-source-file)) ;; do nothing. We want to compile them when CLX is compiled, but ;; not load them when CLX is loaded. t) #+sbcl (defmethod perform :around ((o compile-op) (f xrender-source-file)) ;; RENDER would appear to be an inherently slow protocol; further, ;; it's not set in stone, and consequently we care less about speed ;; than we do about correctness. (handler-bind ((sb-ext:compiler-note #'muffle-warning)) (call-next-method))) #+sbcl (defmethod perform :around ((o compile-op) (f clx-source-file)) ;; our CLX library should compile without WARNINGs, and ideally ;; without STYLE-WARNINGs. Since it currently does, let's enforce ;; it here so that we can catch regressions easily. (let ((on-warnings (operation-on-warnings o)) (on-failure (operation-on-failure o))) (unwind-protect (progn (setf (operation-on-warnings o) :error (operation-on-failure o) :error) ;; a variety of accessors, such as AREF-CARD32, are not ;; declared INLINE. Without this (non-ANSI) ;; static-type-inference behaviour, SBCL emits an extra 100 ;; optimization notes (roughly one fifth of all of the ;; notes emitted). Since the internals are unlikely to ;; change much, and certainly the internals should stay in ;; sync, enabling this extension is a win. (Note that the ;; use of this does not imply that applications using CLX ;; calls that expand into calls to these accessors will be ;; optimized in the same way). (let ((sb-ext:*derive-function-types* t) (sadx (find-symbol "STACK-ALLOCATE-DYNAMIC-EXTENT" :sb-c)) (sadx-var (find-symbol "*STACK-ALLOCATE-DYNAMIC-EXTENT*" :sb-ext))) ;; deeply unportable stuff, this. I will be shot. We ;; want to enable the dynamic-extent declarations in CLX. (when (and sadx (sb-c::policy-quality-name-p sadx)) ;; no way of setting it back short of yet more yukky stuff (proclaim `(optimize (,sadx 3)))) (if sadx-var (progv (list sadx-var) (list t) (call-next-method)) (call-next-method)))) (setf (operation-on-warnings o) on-warnings (operation-on-failure o) on-failure)))) #+sbcl (defmethod perform :around (o (f clx-source-file)) ;; SBCL signals an error if DEFCONSTANT is asked to redefine a ;; constant unEQLly. For CLX's purposes, however, we are defining ;; structured constants (lists and arrays) not for EQLity, but for ;; the purposes of constant-folding operations such as (MEMBER FOO ;; +BAR+), so it is safe to abort the redefinition provided the ;; structured data is sufficiently equal. (handler-bind ((sb-ext:defconstant-uneql (lambda (c) ;; KLUDGE: this really means "don't warn me about ;; efficiency of generic array access, please" (declare (optimize (sb-ext:inhibit-warnings 3))) (let ((old (sb-ext:defconstant-uneql-old-value c)) (new (sb-ext:defconstant-uneql-new-value c))) (typecase old (list (when (equal old new) (abort c))) (string (when (and (typep new 'string) (string= old new)) (abort c))) (simple-vector (when (and (typep new 'simple-vector) (= (length old) (length new)) (every #'eql old new)) (abort c))) (array (when (and (typep new 'array) (equal (array-dimensions old) (array-dimensions new)) (equal (array-element-type old) (array-element-type new)) (dotimes (i (array-total-size old) t) (unless (eql (row-major-aref old i) (row-major-aref new i)) (return nil)))) (abort c)))))))) (call-next-method))) ecl-16.1.2/src/clx/clx.lisp000066400000000000000000001136041266352375300154210ustar00rootroot00000000000000;;; -*- Mode: LISP; Syntax: Common-lisp; Package: XLIB; Base: 10; Lowercase: Yes -*- ;;; ;;; TEXAS INSTRUMENTS INCORPORATED ;;; P.O. BOX 2909 ;;; AUSTIN, TEXAS 78769 ;;; ;;; Copyright (C) 1987 Texas Instruments Incorporated. ;;; ;;; Permission is granted to any individual or institution to use, copy, modify, ;;; and distribute this software, provided that this complete copyright and ;;; permission notice is maintained, intact, in all copies and supporting ;;; documentation. ;;; ;;; Texas Instruments Incorporated provides this software "as is" without ;;; express or implied warranty. ;;; ;; Primary Interface Author: ;; Robert W. Scheifler ;; MIT Laboratory for Computer Science ;; 545 Technology Square, Room 418 ;; Cambridge, MA 02139 ;; rws@zermatt.lcs.mit.edu ;; Design Contributors: ;; Dan Cerys, Texas Instruments ;; Scott Fahlman, CMU ;; Charles Hornig, Symbolics ;; John Irwin, Franz ;; Kerry Kimbrough, Texas Instruments ;; Chris Lindblad, MIT ;; Rob MacLachlan, CMU ;; Mike McMahon, Symbolics ;; David Moon, Symbolics ;; LaMott Oren, Texas Instruments ;; Daniel Weinreb, Symbolics ;; John Wroclawski, MIT ;; Richard Zippel, Symbolics ;; Primary Implementation Author: ;; LaMott Oren, Texas Instruments ;; Implementation Contributors: ;; Charles Hornig, Symbolics ;; John Irwin, Franz ;; Chris Lindblad, MIT ;; Robert Scheifler, MIT ;;; ;;; Change history: ;;; ;;; Date Author Description ;;; ------------------------------------------------------------------------------------- ;;; 04/07/87 R.Scheifler Created code stubs ;;; 04/08/87 L.Oren Started Implementation ;;; 05/11/87 L.Oren Included draft 3 revisions ;;; 07/07/87 L.Oren Untested alpha release to MIT ;;; 07/17/87 L.Oren Alpha release ;;; 08/**/87 C.Lindblad Rewrite of buffer code ;;; 08/**/87 et al Various random bug fixes ;;; 08/**/87 R.Scheifler General syntactic and portability cleanups ;;; 08/**/87 R.Scheifler Rewrite of gcontext caching and shadowing ;;; 09/02/87 L.Oren Change events from resource-ids to objects ;;; 12/24/87 R.Budzianowski KCL support ;;; 12/**/87 J.Irwin ExCL 2.0 support ;;; 01/20/88 L.Oren Add server extension mechanisms ;;; 01/20/88 L.Oren Only force output when blocking on input ;;; 01/20/88 L.Oren Uniform support for :event-window on events ;;; 01/28/88 L.Oren Add window manager property functions ;;; 01/28/88 L.Oren Add character translation facility ;;; 02/**/87 J.Irwin Allegro 2.2 support ;;; This is considered a somewhat changeable interface. Discussion of better ;;; integration with CLOS, support for user-specified subclassess of basic ;;; objects, and the additional functionality to match the C Xlib is still in ;;; progress. Bug reports should be addressed to bug-clx@expo.lcs.mit.edu. ;; Note: all of the following is in the package XLIB. (in-package :xlib) (pushnew :clx *features*) (pushnew :xlib *features*) (defparameter *version* "MIT R5.02") (pushnew :clx-mit-r4 *features*) (pushnew :clx-mit-r5 *features*) (defparameter *protocol-major-version* 11.) (defparameter *protocol-minor-version* 0) (defparameter *x-tcp-port* 6000) ;; add display number ;; Note: if you have read the Version 11 protocol document or C Xlib manual, most of ;; the relationships should be fairly obvious. We have no intention of writing yet ;; another moby document for this interface. ;; Types employed: display, window, pixmap, cursor, font, gcontext, colormap, color. ;; These types are defined solely by a functional interface; we do not specify ;; whether they are implemented as structures or flavors or ... Although functions ;; below are written using DEFUN, this is not an implementation requirement (although ;; it is a requirement that they be functions as opposed to macros or special forms). ;; It is unclear whether with-slots in the Common Lisp Object System must work on ;; them. ;; Windows, pixmaps, cursors, fonts, gcontexts, and colormaps are all represented as ;; compound objects, rather than as integer resource-ids. This allows applications ;; to deal with multiple displays without having an explicit display argument in the ;; most common functions. Every function uses the display object indicated by the ;; first argument that is or contains a display; it is an error if arguments contain ;; different displays, and predictable results are not guaranteed. ;; Each of window, pixmap, cursor, font, gcontext, and colormap have the following ;; five functions: ;(defun make- (display resource-id) ; ;; This function should almost never be called by applications, except in handling ; ;; events. To minimize consing in some implementations, this may use a cache in ; ;; the display. Make-gcontext creates with :cache-p nil. Make-font creates with ; ;; cache-p true. ; (declare (type display display) ; (type integer resource-id) ; (clx-values ))) ;(defun -display () ; (declare (type ) ; (clx-values display))) ;(defun -id () ; (declare (type ) ; (clx-values integer))) ;(defun -equal (-1 -2) ; (declare (type -1 -2))) ;(defun -p (-1 -2) ; (declare (type -1 -2) ; (clx-values boolean))) (deftype generalized-boolean () 't) ; (or null (not null)) (deftype card32 () '(unsigned-byte 32)) (deftype card29 () '(unsigned-byte 29)) (deftype card24 () '(unsigned-byte 24)) (deftype int32 () '(signed-byte 32)) (deftype card16 () '(unsigned-byte 16)) (deftype int16 () '(signed-byte 16)) (deftype card8 () '(unsigned-byte 8)) (deftype int8 () '(signed-byte 8)) (deftype card4 () '(unsigned-byte 4)) #-clx-ansi-common-lisp (deftype real (&optional (min '*) (max '*)) (labels ((convert (limit floatp) (typecase limit (number (if floatp (float limit 0s0) (rational limit))) (list (map 'list #'convert limit)) (otherwise limit)))) `(or (float ,(convert min t) ,(convert max t)) (rational ,(convert min nil) ,(convert max nil))))) #-clx-ansi-common-lisp (deftype base-char () 'string-char) ; Note that we are explicitly using a different rgb representation than what ; is actually transmitted in the protocol. (deftype rgb-val () '(real 0 1)) ; Note that we are explicitly using a different angle representation than what ; is actually transmitted in the protocol. (deftype angle () '(real #.(* -2 pi) #.(* 2 pi))) (deftype mask32 () 'card32) (deftype mask16 () 'card16) (deftype pixel () '(unsigned-byte 32)) (deftype image-depth () '(integer 0 32)) (deftype resource-id () 'card29) (deftype keysym () 'card32) ; The following functions are provided by color objects: ; The intention is that IHS and YIQ and CYM interfaces will also exist. ; Note that we are explicitly using a different spectrum representation ; than what is actually transmitted in the protocol. (def-clx-class (color (:constructor make-color-internal (red green blue)) (:copier nil) (:print-function print-color)) (red 0.0 :type rgb-val) (green 0.0 :type rgb-val) (blue 0.0 :type rgb-val)) (defun print-color (color stream depth) (declare (type color color) (ignore depth)) (print-unreadable-object (color stream :type t) (prin1 (color-red color) stream) (write-string " " stream) (prin1 (color-green color) stream) (write-string " " stream) (prin1 (color-blue color) stream))) (defun make-color (&key (red 1.0) (green 1.0) (blue 1.0) &allow-other-keys) (declare (type rgb-val red green blue)) (declare (clx-values color)) (make-color-internal red green blue)) (defun color-rgb (color) (declare (type color color)) (declare (clx-values red green blue)) (values (color-red color) (color-green color) (color-blue color))) (def-clx-class (bitmap-format (:copier nil) (:print-function print-bitmap-format)) (unit 8 :type (member 8 16 32)) (pad 8 :type (member 8 16 32)) (lsb-first-p nil :type generalized-boolean)) (defun print-bitmap-format (bitmap-format stream depth) (declare (type bitmap-format bitmap-format) (ignore depth)) (print-unreadable-object (bitmap-format stream :type t) (format stream "unit ~D pad ~D ~:[M~;L~]SB first" (bitmap-format-unit bitmap-format) (bitmap-format-pad bitmap-format) (bitmap-format-lsb-first-p bitmap-format)))) (def-clx-class (pixmap-format (:copier nil) (:print-function print-pixmap-format)) (depth 0 :type image-depth) (bits-per-pixel 8 :type (member 1 4 8 12 16 24 32)) (scanline-pad 8 :type (member 8 16 32))) (defun print-pixmap-format (pixmap-format stream depth) (declare (type pixmap-format pixmap-format) (ignore depth)) (print-unreadable-object (pixmap-format stream :type t) (format stream "depth ~D bits-per-pixel ~D scanline-pad ~D" (pixmap-format-depth pixmap-format) (pixmap-format-bits-per-pixel pixmap-format) (pixmap-format-scanline-pad pixmap-format)))) (defparameter *atom-cache-size* 200) (defparameter *resource-id-map-size* 500) (def-clx-class (display (:include buffer) (:constructor make-display-internal) (:print-function print-display) (:copier nil)) (host) ; Server Host (display 0 :type integer) ; Display number on host (after-function nil) ; Function to call after every request (event-lock (make-process-lock "CLX Event Lock")) ; with-event-queue lock (event-queue-lock (make-process-lock "CLX Event Queue Lock")) ; new-events/event-queue lock (event-queue-tail ; last event in the event queue nil :type (or null reply-buffer)) (event-queue-head ; Threaded queue of events nil :type (or null reply-buffer)) (atom-cache (make-hash-table :test (atom-cache-map-test) :size *atom-cache-size*) :type hash-table) ; Hash table relating atoms keywords ; to atom id's (font-cache nil) ; list of font (protocol-major-version 0 :type card16) ; Major version of server's X protocol (protocol-minor-version 0 :type card16) ; minor version of servers X protocol (vendor-name "" :type string) ; vendor of the server hardware (resource-id-base 0 :type resource-id) ; resouce ID base (resource-id-mask 0 :type resource-id) ; resource ID mask bits (resource-id-byte nil) ; resource ID mask field (used with DPB & LDB) (resource-id-count 0 :type resource-id) ; resource ID mask count ; (used for allocating ID's) (resource-id-map (make-hash-table :test (resource-id-map-test) :size *resource-id-map-size*) :type hash-table) ; hash table maps resource-id's to ; objects (used in lookup functions) (xid 'resourcealloc) ; allocator function (byte-order #+clx-little-endian :lsbfirst ; connection byte order #-clx-little-endian :msbfirst) (release-number 0 :type card32) ; release of the server (max-request-length 0 :type card16) ; maximum number 32 bit words in request (default-screen) ; default screen for operations (roots nil :type list) ; List of screens (motion-buffer-size 0 :type card32) ; size of motion buffer (xdefaults) ; contents of defaults from server (image-lsb-first-p nil :type generalized-boolean) (bitmap-format (make-bitmap-format) ; Screen image info :type bitmap-format) (pixmap-formats nil :type sequence) ; list of pixmap formats (min-keycode 0 :type card8) ; minimum key-code (max-keycode 0 :type card8) ; maximum key-code (error-handler 'default-error-handler) ; Error handler function (close-down-mode :destroy) ; Close down mode saved by Set-Close-Down-Mode (authorization-name "" :type string) (authorization-data "" :type (or (array (unsigned-byte 8)) string)) (last-width nil :type (or null card29)) ; Accumulated width of last string (keysym-mapping nil ; Keysym mapping cached from server :type (or null (array * (* *)))) (modifier-mapping nil :type list) ; ALIST of (keysym . state-mask) for all modifier keysyms (keysym-translation nil :type list) ; An alist of (keysym object function) ; for display-local keysyms (extension-alist nil :type list) ; extension alist, which has elements: ; (name major-opcode first-event first-error) (event-extensions '#() :type vector) ; Vector mapping X event-codes to event keys (performance-info) ; Hook for gathering performance info (trace-history) ; Hook for debug trace (plist nil :type list) ; hook for extension to hang data ;; These slots are used to manage multi-process input. (input-in-progress nil) ; Some process reading from the stream. ; Updated with CONDITIONAL-STORE. (pending-commands nil) ; Threaded list of PENDING-COMMAND objects ; for all commands awaiting replies. ; Protected by WITH-EVENT-QUEUE-INTERNAL. (asynchronous-errors nil) ; Threaded list of REPLY-BUFFER objects ; containing error messages for commands ; which did not expect replies. ; Protected by WITH-EVENT-QUEUE-INTERNAL. (report-asynchronous-errors ; When to report asynchronous errors '(:immediately) :type list) ; The keywords that can be on this list ; are :IMMEDIATELY, :BEFORE-EVENT-HANDLING, ; and :AFTER-FINISH-OUTPUT (event-process nil) ; Process ID of process awaiting events. ; Protected by WITH-EVENT-QUEUE. (new-events nil :type (or null reply-buffer)) ; Pointer to the first new event in the ; event queue. ; Protected by WITH-EVENT-QUEUE. (current-event-symbol ; Bound with PROGV by event handling macros (list (gensym) (gensym)) :type cons) (atom-id-map (make-hash-table :test (resource-id-map-test) :size *atom-cache-size*) :type hash-table) (extended-max-request-length 0 :type card32) ) (defun print-display-name (display stream) (declare (type (or null display) display)) (cond (display #-allegro (princ (display-host display) stream) #+allegro (write-string (string (display-host display)) stream) (write-string ":" stream) (princ (display-display display) stream)) (t (write-string "(no display)" stream))) display) (defun print-display (display stream depth) (declare (type display display) (ignore depth)) (print-unreadable-object (display stream :type t) (print-display-name display stream) (write-string " (" stream) (write-string (display-vendor-name display) stream) (write-string " R" stream) (prin1 (display-release-number display) stream) (write-string ")" stream))) ;;(deftype drawable () '(or window pixmap)) (def-clx-class (drawable (:copier nil) (:print-function print-drawable)) (id 0 :type resource-id) (display nil :type (or null display)) (plist nil :type list) ; Extension hook ) (defun print-drawable (drawable stream depth) (declare (type drawable drawable) (ignore depth)) (print-unreadable-object (drawable stream :type t) (print-display-name (drawable-display drawable) stream) (write-string " " stream) (let ((*print-base* 16)) (prin1 (drawable-id drawable) stream)))) (def-clx-class (window (:include drawable) (:copier nil) (:print-function print-drawable)) ) (def-clx-class (pixmap (:include drawable) (:copier nil) (:print-function print-drawable)) ) (def-clx-class (visual-info (:copier nil) (:print-function print-visual-info)) (id 0 :type resource-id) (display nil :type (or null display)) (class :static-gray :type (member :static-gray :static-color :true-color :gray-scale :pseudo-color :direct-color)) (red-mask 0 :type pixel) (green-mask 0 :type pixel) (blue-mask 0 :type pixel) (bits-per-rgb 1 :type card8) (colormap-entries 0 :type card16) (plist nil :type list) ; Extension hook ) (defun print-visual-info (visual-info stream depth) (declare (type visual-info visual-info) (ignore depth)) (print-unreadable-object (visual-info stream :type t) (prin1 (visual-info-bits-per-rgb visual-info) stream) (write-string "-bit " stream) (princ (visual-info-class visual-info) stream) (write-string " " stream) (print-display-name (visual-info-display visual-info) stream) (write-string " " stream) (prin1 (visual-info-id visual-info) stream))) (def-clx-class (colormap (:copier nil) (:print-function print-colormap)) (id 0 :type resource-id) (display nil :type (or null display)) (visual-info nil :type (or null visual-info)) ) (defun print-colormap (colormap stream depth) (declare (type colormap colormap) (ignore depth)) (print-unreadable-object (colormap stream :type t) (when (colormap-visual-info colormap) (princ (visual-info-class (colormap-visual-info colormap)) stream) (write-string " " stream)) (print-display-name (colormap-display colormap) stream) (write-string " " stream) (prin1 (colormap-id colormap) stream))) (def-clx-class (cursor (:copier nil) (:print-function print-cursor)) (id 0 :type resource-id) (display nil :type (or null display)) ) (defun print-cursor (cursor stream depth) (declare (type cursor cursor) (ignore depth)) (print-unreadable-object (cursor stream :type t) (print-display-name (cursor-display cursor) stream) (write-string " " stream) (prin1 (cursor-id cursor) stream))) ; Atoms are accepted as strings or symbols, and are always returned as keywords. ; Protocol-level integer atom ids are hidden, using a cache in the display object. (deftype xatom () '(or string symbol)) (defconstant +predefined-atoms+ '#(nil :PRIMARY :SECONDARY :ARC :ATOM :BITMAP :CARDINAL :COLORMAP :CURSOR :CUT_BUFFER0 :CUT_BUFFER1 :CUT_BUFFER2 :CUT_BUFFER3 :CUT_BUFFER4 :CUT_BUFFER5 :CUT_BUFFER6 :CUT_BUFFER7 :DRAWABLE :FONT :INTEGER :PIXMAP :POINT :RECTANGLE :RESOURCE_MANAGER :RGB_COLOR_MAP :RGB_BEST_MAP :RGB_BLUE_MAP :RGB_DEFAULT_MAP :RGB_GRAY_MAP :RGB_GREEN_MAP :RGB_RED_MAP :STRING :VISUALID :WINDOW :WM_COMMAND :WM_HINTS :WM_CLIENT_MACHINE :WM_ICON_NAME :WM_ICON_SIZE :WM_NAME :WM_NORMAL_HINTS :WM_SIZE_HINTS :WM_ZOOM_HINTS :MIN_SPACE :NORM_SPACE :MAX_SPACE :END_SPACE :SUPERSCRIPT_X :SUPERSCRIPT_Y :SUBSCRIPT_X :SUBSCRIPT_Y :UNDERLINE_POSITION :UNDERLINE_THICKNESS :STRIKEOUT_ASCENT :STRIKEOUT_DESCENT :ITALIC_ANGLE :X_HEIGHT :QUAD_WIDTH :WEIGHT :POINT_SIZE :RESOLUTION :COPYRIGHT :NOTICE :FONT_NAME :FAMILY_NAME :FULL_NAME :CAP_HEIGHT :WM_CLASS :WM_TRANSIENT_FOR)) (deftype stringable () '(or string symbol)) (deftype fontable () '(or stringable font)) ; Nil stands for CurrentTime. (deftype timestamp () '(or null card32)) (defconstant +bit-gravity-vector+ '#(:forget :north-west :north :north-east :west :center :east :south-west :south :south-east :static)) (deftype bit-gravity () '(member :forget :north-west :north :north-east :west :center :east :south-west :south :south-east :static)) (defconstant +win-gravity-vector+ '#(:unmap :north-west :north :north-east :west :center :east :south-west :south :south-east :static)) (defparameter *protocol-families* '(;; X11/X.h, Family* (:internet . 0) (:decnet . 1) (:chaos . 2) ;; X11/Xauth.h "not part of X standard" (:Local . 256) (:Wild . 65535) (:Netname . 254) (:Krb5Principal . 253) (:LocalHost . 252))) (deftype win-gravity () '(member :unmap :north-west :north :north-east :west :center :east :south-west :south :south-east :static)) (deftype grab-status () '(member :success :already-grabbed :invalid-time :not-viewable)) ; An association list. (deftype alist (key-type-and-name datum-type-and-name) (declare (ignore key-type-and-name datum-type-and-name)) 'list) (deftype clx-list (&optional element-type) (declare (ignore element-type)) 'list) (deftype clx-sequence (&optional element-type) (declare (ignore element-type)) 'sequence) ; A sequence, containing zero or more repetitions of the given elements, ; with the elements expressed as (type name). (deftype repeat-seq (&rest elts) elts 'sequence) (deftype point-seq () '(repeat-seq (int16 x) (int16 y))) (deftype seg-seq () '(repeat-seq (int16 x1) (int16 y1) (int16 x2) (int16 y2))) (deftype rect-seq () '(repeat-seq (int16 x) (int16 y) (card16 width) (card16 height))) (deftype arc-seq () '(repeat-seq (int16 x) (int16 y) (card16 width) (card16 height) (angle angle1) (angle angle2))) (deftype gcontext-state () 'simple-vector) (def-clx-class (gcontext (:copier nil) (:print-function print-gcontext)) ;; The accessors convert to CLX data types. (id 0 :type resource-id) (display nil :type (or null display)) (drawable nil :type (or null drawable)) (cache-p t :type generalized-boolean) (server-state (allocate-gcontext-state) :type gcontext-state) (local-state (allocate-gcontext-state) :type gcontext-state) (plist nil :type list) ; Extension hook (next nil #-explorer :type #-explorer (or null gcontext)) ) (defun print-gcontext (gcontext stream depth) (declare (type gcontext gcontext) (ignore depth)) (print-unreadable-object (gcontext stream :type t) (print-display-name (gcontext-display gcontext) stream) (write-string " " stream) (prin1 (gcontext-id gcontext) stream))) (defconstant +event-mask-vector+ '#(:key-press :key-release :button-press :button-release :enter-window :leave-window :pointer-motion :pointer-motion-hint :button-1-motion :button-2-motion :button-3-motion :button-4-motion :button-5-motion :button-motion :keymap-state :exposure :visibility-change :structure-notify :resize-redirect :substructure-notify :substructure-redirect :focus-change :property-change :colormap-change :owner-grab-button)) (deftype event-mask-class () '(member :key-press :key-release :owner-grab-button :button-press :button-release :enter-window :leave-window :pointer-motion :pointer-motion-hint :button-1-motion :button-2-motion :button-3-motion :button-4-motion :button-5-motion :button-motion :exposure :visibility-change :structure-notify :resize-redirect :substructure-notify :substructure-redirect :focus-change :property-change :colormap-change :keymap-state)) (deftype event-mask () '(or mask32 (clx-list event-mask-class))) (defconstant +pointer-event-mask-vector+ ;; the first two elements used to be '%error '%error (i.e. symbols, ;; and not keywords) but the vector is supposed to contain ;; keywords, so I renamed them -dan 2004.11.13 '#(:%error :%error :button-press :button-release :enter-window :leave-window :pointer-motion :pointer-motion-hint :button-1-motion :button-2-motion :button-3-motion :button-4-motion :button-5-motion :button-motion :keymap-state)) (deftype pointer-event-mask-class () '(member :button-press :button-release :enter-window :leave-window :pointer-motion :pointer-motion-hint :button-1-motion :button-2-motion :button-3-motion :button-4-motion :button-5-motion :button-motion :keymap-state)) (deftype pointer-event-mask () '(or mask32 (clx-list pointer-event-mask-class))) (defconstant +device-event-mask-vector+ '#(:key-press :key-release :button-press :button-release :pointer-motion :button-1-motion :button-2-motion :button-3-motion :button-4-motion :button-5-motion :button-motion)) (deftype device-event-mask-class () '(member :key-press :key-release :button-press :button-release :pointer-motion :button-1-motion :button-2-motion :button-3-motion :button-4-motion :button-5-motion :button-motion)) (deftype device-event-mask () '(or mask32 (clx-list device-event-mask-class))) (defconstant +state-mask-vector+ '#(:shift :lock :control :mod-1 :mod-2 :mod-3 :mod-4 :mod-5 :button-1 :button-2 :button-3 :button-4 :button-5)) (deftype modifier-key () '(member :shift :lock :control :mod-1 :mod-2 :mod-3 :mod-4 :mod-5)) (deftype modifier-mask () '(or (member :any) mask16 (clx-list modifier-key))) (deftype state-mask-key () '(or modifier-key (member :button-1 :button-2 :button-3 :button-4 :button-5))) (defconstant +gcontext-components+ '(:function :plane-mask :foreground :background :line-width :line-style :cap-style :join-style :fill-style :fill-rule :tile :stipple :ts-x :ts-y :font :subwindow-mode :exposures :clip-x :clip-y :clip-mask :dash-offset :dashes :arc-mode)) (deftype gcontext-key () '(member :function :plane-mask :foreground :background :line-width :line-style :cap-style :join-style :fill-style :fill-rule :tile :stipple :ts-x :ts-y :font :subwindow-mode :exposures :clip-x :clip-y :clip-mask :dash-offset :dashes :arc-mode)) (deftype event-key () '(or (member :key-press :key-release :button-press :button-release :motion-notify :enter-notify :leave-notify :focus-in :focus-out :keymap-notify :exposure :graphics-exposure :no-exposure :visibility-notify :create-notify :destroy-notify :unmap-notify :map-notify :map-request :reparent-notify :configure-notify :gravity-notify :resize-request :configure-request :circulate-notify :circulate-request :property-notify :selection-clear :selection-request :selection-notify :colormap-notify :client-message :mapping-notify) (satisfies extension-event-key-p))) (deftype error-key () '(member :access :alloc :atom :colormap :cursor :drawable :font :gcontext :id-choice :illegal-request :implementation :length :match :name :pixmap :value :window)) (deftype draw-direction () '(member :left-to-right :right-to-left)) (defconstant +boole-vector+ '#(#.boole-clr #.boole-and #.boole-andc2 #.boole-1 #.boole-andc1 #.boole-2 #.boole-xor #.boole-ior #.boole-nor #.boole-eqv #.boole-c2 #.boole-orc2 #.boole-c1 #.boole-orc1 #.boole-nand #.boole-set)) (deftype boole-constant () `(member ,boole-clr ,boole-and ,boole-andc2 ,boole-1 ,boole-andc1 ,boole-2 ,boole-xor ,boole-ior ,boole-nor ,boole-eqv ,boole-c2 ,boole-orc2 ,boole-c1 ,boole-orc1 ,boole-nand ,boole-set)) (def-clx-class (screen (:copier nil) (:print-function print-screen)) (root nil :type (or null window)) (width 0 :type card16) (height 0 :type card16) (width-in-millimeters 0 :type card16) (height-in-millimeters 0 :type card16) (depths nil :type (alist (image-depth depth) ((clx-list visual-info) visuals))) (root-depth 1 :type image-depth) (root-visual-info nil :type (or null visual-info)) (default-colormap nil :type (or null colormap)) (white-pixel 0 :type pixel) (black-pixel 1 :type pixel) (min-installed-maps 1 :type card16) (max-installed-maps 1 :type card16) (backing-stores :never :type (member :never :when-mapped :always)) (save-unders-p nil :type generalized-boolean) (event-mask-at-open 0 :type mask32) (plist nil :type list) ; Extension hook ) (defun print-screen (screen stream depth) (declare (type screen screen) (ignore depth)) (print-unreadable-object (screen stream :type t) (let ((display (drawable-display (screen-root screen)))) (print-display-name display stream) (write-string "." stream) (princ (position screen (display-roots display)) stream)) (write-string " " stream) (prin1 (screen-width screen) stream) (write-string "x" stream) (prin1 (screen-height screen) stream) (write-string "x" stream) (prin1 (screen-root-depth screen) stream) (when (screen-root-visual-info screen) (write-string " " stream) (princ (visual-info-class (screen-root-visual-info screen)) stream)))) (defun screen-root-visual (screen) (declare (type screen screen) (clx-values resource-id)) (visual-info-id (screen-root-visual-info screen))) ;; The list contains alternating keywords and integers. (deftype font-props () 'list) (def-clx-class (font-info (:copier nil) (:predicate nil)) (direction :left-to-right :type draw-direction) (min-char 0 :type card16) ;; First character in font (max-char 0 :type card16) ;; Last character in font (min-byte1 0 :type card8) ;; The following are for 16 bit fonts (max-byte1 0 :type card8) ;; and specify min&max values for (min-byte2 0 :type card8) ;; the two character bytes (max-byte2 0 :type card8) (all-chars-exist-p nil :type generalized-boolean) (default-char 0 :type card16) (min-bounds nil :type (or null vector)) (max-bounds nil :type (or null vector)) (ascent 0 :type int16) (descent 0 :type int16) (properties nil :type font-props)) (def-clx-class (font (:constructor make-font-internal) (:copier nil) (:print-function print-font)) (id-internal nil :type (or null resource-id)) ;; NIL when not opened (display nil :type (or null display)) (reference-count 0 :type fixnum) (name "" :type (or null string)) ;; NIL when ID is for a GContext (font-info-internal nil :type (or null font-info)) (char-infos-internal nil :type (or null (simple-array int16 (*)))) (local-only-p t :type generalized-boolean) ;; When T, always calculate text extents locally (plist nil :type list) ; Extension hook ) (defun print-font (font stream depth) (declare (type font font) (ignore depth)) (print-unreadable-object (font stream :type t) (if (font-name font) (princ (font-name font) stream) (write-string "(gcontext)" stream)) (write-string " " stream) (print-display-name (font-display font) stream) (when (font-id-internal font) (write-string " " stream) (prin1 (font-id font) stream)))) (defun font-id (font) ;; Get font-id, opening font if needed (or (font-id-internal font) (open-font-internal font))) (defun font-font-info (font) (or (font-font-info-internal font) (query-font font))) (defun font-char-infos (font) (or (font-char-infos-internal font) (progn (query-font font) (font-char-infos-internal font)))) (defun make-font (&key id display (reference-count 0) (name "") (local-only-p t) font-info-internal) (make-font-internal :id-internal id :display display :reference-count reference-count :name name :local-only-p local-only-p :font-info-internal font-info-internal)) ; For each component ( :type ) of font-info, ; there is a corresponding function: ;(defun font- (font) ; (declare (type font font) ; (clx-values ))) (macrolet ((make-font-info-accessors (useless-name &body fields) `(within-definition (,useless-name make-font-info-accessors) ,@(mapcar #'(lambda (field) (let* ((type (second field)) (n (string (first field))) (name (xintern 'font- n)) (accessor (xintern 'font-info- n))) `(defun ,name (font) (declare (type font font)) (declare (clx-values ,type)) (,accessor (font-font-info font))))) fields)))) (make-font-info-accessors ignore (direction draw-direction) (min-char card16) (max-char card16) (min-byte1 card8) (max-byte1 card8) (min-byte2 card8) (max-byte2 card8) (all-chars-exist-p generalized-boolean) (default-char card16) (min-bounds vector) (max-bounds vector) (ascent int16) (descent int16) (properties font-props))) (defun font-property (font name) (declare (type font font) (type keyword name)) (declare (clx-values (or null int32))) (getf (font-properties font) name)) (macrolet ((make-mumble-equal (type) ;; Since caching is only done for objects created by the ;; client, we must always compare ID and display for ;; non-identical mumbles. (let ((predicate (xintern type '-equal)) (id (xintern type '-id)) (dpy (xintern type '-display))) `(within-definition (,type make-mumble-equal) (defun ,predicate (a b) (declare (type ,type a b)) (or (eql a b) (and (= (,id a) (,id b)) (eq (,dpy a) (,dpy b))))))))) (make-mumble-equal window) (make-mumble-equal pixmap) (make-mumble-equal cursor) (make-mumble-equal font) (make-mumble-equal gcontext) (make-mumble-equal colormap) (make-mumble-equal drawable)) ;;; ;;; Event-mask encode/decode functions ;;; Converts from keyword-lists to integer and back ;;; (defun encode-mask (key-vector key-list key-type) ;; KEY-VECTOR is a vector containg bit-position keywords. The ;; position of the keyword in the vector indicates its bit position ;; in the resulting mask. KEY-LIST is either a mask or a list of ;; KEY-TYPE Returns NIL when KEY-LIST is not a list or mask. (declare (type (simple-array keyword (*)) key-vector) (type (or mask32 list) key-list)) (declare (clx-values (or mask32 null))) (typecase key-list (mask32 key-list) (list (let ((mask 0)) (dolist (key key-list mask) (let ((bit (position key (the vector key-vector) :test #'eq))) (unless bit (x-type-error key key-type)) (setq mask (logior mask (ash 1 bit))))))))) (defun decode-mask (key-vector mask) (declare (type (simple-array keyword (*)) key-vector) (type mask32 mask)) (declare (clx-values list)) (do ((m mask (ash m -1)) (bit 0 (1+ bit)) (len (length key-vector)) (result nil)) ((or (zerop m) (>= bit len)) result) (declare (type mask32 m) (fixnum bit len) (list result)) (when (oddp m) (push (aref key-vector bit) result)))) (defun encode-event-mask (event-mask) (declare (type event-mask event-mask)) (declare (clx-values mask32)) (or (encode-mask +event-mask-vector+ event-mask 'event-mask-class) (x-type-error event-mask 'event-mask))) (defun make-event-mask (&rest keys) ;; This is only defined for core events. ;; Useful for constructing event-mask, pointer-event-mask, device-event-mask. (declare (type (clx-list event-mask-class) keys)) (declare (clx-values mask32)) (encode-mask +event-mask-vector+ keys 'event-mask-class)) (defun make-event-keys (event-mask) ;; This is only defined for core events. (declare (type mask32 event-mask)) (declare (clx-values (clx-list event-mask-class))) (decode-mask +event-mask-vector+ event-mask)) (defun encode-device-event-mask (device-event-mask) (declare (type device-event-mask device-event-mask)) (declare (clx-values mask32)) (or (encode-mask +device-event-mask-vector+ device-event-mask 'device-event-mask-class) (x-type-error device-event-mask 'device-event-mask))) (defun encode-modifier-mask (modifier-mask) (declare (type modifier-mask modifier-mask)) (declare (clx-values mask16)) (or (and (eq modifier-mask :any) #x8000) (encode-mask +state-mask-vector+ modifier-mask 'modifier-key) (x-type-error modifier-mask 'modifier-mask))) (defun encode-state-mask (state-mask) (declare (type (or mask16 (clx-list state-mask-key)) state-mask)) (declare (clx-values mask16)) (or (encode-mask +state-mask-vector+ state-mask 'state-mask-key) (x-type-error state-mask '(or mask16 (clx-list state-mask-key))))) (defun make-state-mask (&rest keys) ;; Useful for constructing modifier-mask, state-mask. (declare (type (clx-list state-mask-key) keys)) (declare (clx-values mask16)) (encode-mask +state-mask-vector+ keys 'state-mask-key)) (defun make-state-keys (state-mask) (declare (type mask16 state-mask)) (declare (clx-values (clx-list state-mask-key))) (decode-mask +state-mask-vector+ state-mask)) (defun encode-pointer-event-mask (pointer-event-mask) (declare (type pointer-event-mask pointer-event-mask)) (declare (clx-values mask32)) (or (encode-mask +pointer-event-mask-vector+ pointer-event-mask 'pointer-event-mask-class) (x-type-error pointer-event-mask 'pointer-event-mask))) ecl-16.1.2/src/clx/cmudep.lisp000066400000000000000000000013521266352375300161040ustar00rootroot00000000000000;;; -*- Package: XLIB -*- ;;; ;;; ********************************************************************** ;;; This code was written as part of the CMU Common Lisp project at ;;; Carnegie Mellon University, and has been placed in the public domain. ;;; If you want to use this code or any part of CMU Common Lisp, please contact ;;; Scott Fahlman or slisp-group@cs.cmu.edu. ;;; (ext:file-comment "$Header: /loaclhost/usr/local/src/cvs/clx/cmudep.lisp,v 1.1 2000/07/02 19:19:46 dan Exp $") ;;; ;;; ********************************************************************** ;;; (in-package "XLIB") (alien:def-alien-routine ("connect_to_server" xlib::connect-to-server) c-call:int (host c-call:c-string) (port c-call:int)) ecl-16.1.2/src/clx/debug/000077500000000000000000000000001266352375300150235ustar00rootroot00000000000000ecl-16.1.2/src/clx/debug/debug.lisp000066400000000000000000000044541266352375300170110ustar00rootroot00000000000000;;; -*- Mode:Lisp; Package:XLIB; Syntax:COMMON-LISP; Base:10; Lowercase:YES; Patch-file:T -*- ;;; CLX debugging code ;;; ;;; TEXAS INSTRUMENTS INCORPORATED ;;; P.O. BOX 2909 ;;; AUSTIN, TEXAS 78769 ;;; ;;; Copyright (C) 1987 Texas Instruments Incorporated. ;;; ;;; Permission is granted to any individual or institution to use, copy, modify, ;;; and distribute this software, provided that this complete copyright and ;;; permission notice is maintained, intact, in all copies and supporting ;;; documentation. ;;; ;;; Texas Instruments Incorporated provides this software "as is" without ;;; express or implied warranty. ;;; ;;; Created 04/09/87 14:30:41 by LaMott G. OREN (in-package :xlib) (export '(display-listen readflush check-buffer check-finish check-force clear-next)) (defun display-listen (display) (listen (display-input-stream display))) (defun readflush (display) ;; Flushes Display's input stream, returning what was there (let ((stream (display-input-stream display))) (loop while (listen stream) collect (read-byte stream)))) ;;----------------------------------------------------------------------------- ;; The following are useful display-after functions (defun check-buffer (display) ;; Ensure the output buffer in display is correct (with-buffer-output (display :length :none :sizes (8 16)) (do* ((i 0 (+ i length)) request length) ((>= i buffer-boffset) (unless (= i buffer-boffset) (warn "Buffer size ~d Requests end at ~d" buffer-boffset i))) (let ((buffer-boffset 0) #+clx-overlapping-arrays (buffer-woffset 0)) (setq request (card8-get i)) (setq length (* 4 (card16-get (+ i 2))))) (when (zerop request) (warn "Zero request in buffer") (return nil)) (when (zerop length) (warn "Zero length in buffer") (return nil))))) (defun check-finish (display) (check-buffer display) (display-finish-output display)) (defun check-force (display) (check-buffer display) (display-force-output display)) (defun clear-next (display) ;; Never append requests (setf (display-last-request display) nil)) ;; End of file ecl-16.1.2/src/clx/debug/describe.lisp000066400000000000000000001157631266352375300175110ustar00rootroot00000000000000;;; -*- Mode: Lisp; Package: XLIB; Syntax: COMMON-LISP; Base: 10; Lowercase: Yes; -*- ;;; Describe X11 protocol requests ;;; ;;; TEXAS INSTRUMENTS INCORPORATED ;;; P.O. BOX 2909 ;;; AUSTIN, TEXAS 78769 ;;; ;;; Copyright (C) 1987 Texas Instruments Incorporated. ;;; ;;; Permission is granted to any individual or institution to use, copy, modify, ;;; and distribute this software, provided that this complete copyright and ;;; permission notice is maintained, intact, in all copies and supporting ;;; documentation. ;;; ;;; Texas Instruments Incorporated provides this software "as is" without ;;; express or implied warranty. ;;; ;;; Created 07/15/87 by LaMott G. OREN (in-package :xlib) (defparameter *request-parameters* (make-array (length *request-names*))) (defmacro x-request (name &rest fields) (unless (zerop (mod (length fields) 3)) (format t "~%Field length not a multiple of 3 for ~a" name)) (let ((request (position name *request-names* :test #'string-equal))) (if request `(setf (aref *request-parameters* ,request) ',fields) `(format t "~%~s isn't an X11 request name" ',name)))) (defun print-history-description (buffer &optional (start 0)) ;; Display an output history (reading-event (buffer) (let ((request (card8-get start)) (length (* 4 (card16-get (+ start 2)))) (margin 5)) (format t "~a (~d) length ~d" (request-name request) request length) (when (>= request (length *request-parameters*)) (setq request 0)) (do ((parms (aref *request-parameters* request) (cdddr parms)) (j start)) ((or (endp parms) (>= j length))) (let ((len (first parms)) (type (second parms)) (doc (third parms)) value) (setq value (case len (1 (card8-get j)) (2 (card16-get j)) (4 (card32-get j)))) (format t "~%~v@t" margin) (if value (progn (print-value j value type doc) (incf j len)) (progn (format t "~2d ~10a ~a" j type doc) (case type ((listofvalue listofcard32 listofatom) (format t " Words:~%~v@t" margin) (dotimes (k (floor (- length (- j start)) 4)) (format t " ~d" (card32-get j)) (incf j 4))) (listofrectangle (format t " Half-Words:~%~v@t" margin) (dotimes (k (floor (- length (- j start)) 2)) (format t " ~d" (card16-get j)) (incf j 2))) (x (when (integerp len) (incf j len))) ; Unused (string8 (format t " Bytes:~%~v@t" margin) (dotimes (k (- length (- j start))) (format t "~a" (int-char (card8-get j))) (incf j))) (otherwise (format t " Bytes:~%~v@t" margin) (dotimes (k (- length (- j start))) (format t " ~d" (card8-get j)) (incf j))))))))))) (defun print-value (i value type doc &aux temp) (format t "~2d ~3d " i value) (if (consp type) (case (first type) (bitmask (format t "~a" (nreverse (decode-mask (symbol-value (second type)) value))) (setq type (car type))) (member (if (null (setq temp (nth value (cdr type)))) (format t "*****ERROR*****") (format t "~a" temp)) (setq type (car type)))) (case type ((window pixmap drawable cursor font gcontext colormap atom) (format t "[#x~x]" value) #+comment (let ((temp (lookup-resource-id display value))) (when (eq (first type) 'atom) (setq temp (lookup-xatom display value))) (when temp (format t " (~s)" (type-of temp))))) (int16 (setq temp (card16->int16 value)) (when (minusp temp) (format t "~d" temp))) (otherwise (when (and (numberp type) (not (= type value))) (format t "*****ERROR*****"))))) (format t "~30,10t ~10a ~a" type doc)) (x-request Error 1 1 opcode 1 CARD8 data 2 8+n request-length n LISTofBYTE data ) (x-request CreateWindow 1 1 opcode 1 CARD8 depth 2 8+n request-length 4 WINDOW wid 4 WINDOW parent 2 INT16 x 2 INT16 y 2 CARD16 width 2 CARD16 height 2 CARD16 border-width 2 (MEMBER CopyFromParent InputOutput InputOnly) class 4 (OR (MEMBER CopyFromParent) VISUALID) visual 4 (BITMASK *create-bitmask*) value-mask 4n LISTofVALUE value-list ) (defparameter *create-bitmask* #(background-pixmap background-pixel border-pixmap border-pixel bit-gravity win-gravity backing-store backing-planes backing-pixel override-redirect save-under event-mask do-not-propagate-mask colormap cursor)) (x-request ChangeWindowAttributes 1 2 opcode 1 x unused 2 3+n request-length 4 WINDOW window 4 (BITMASK *create-bitmask*) value-mask 4n LISTofVALUE value-list ) (x-request GetWindowAttributes 1 3 opcode 1 x unused 2 2 request-length 4 WINDOW window ) (x-request DestroyWindow 1 4 opcode 1 x unused 2 2 request-length 4 WINDOW window ) (x-request DestroySubwindows 1 5 opcode 1 x unused 2 2 request-length 4 WINDOW window ) (x-request ChangeSaveSet 1 6 opcode 1 (MEMBER insert delete) mode 2 2 request-length 4 WINDOW window ) (x-request ReparentWindow 1 7 opcode 1 x unused 2 4 request-length 4 WINDOW window 4 WINDOW parent 2 INT16 x 2 INT16 y ) (x-request MapWindow 1 8 opcode 1 x unused 2 2 request-length 4 WINDOW window ) (x-request MapSubwindows 1 9 opcode 1 x unused 2 2 request-length 4 WINDOW window ) (x-request UnmapWindow 1 10 opcode 1 x unused 2 2 request-length 4 WINDOW window ) (x-request UnmapSubwindows 1 11 opcode 1 x unused 2 2 request-length 4 WINDOW window ) (x-request ConfigureWindow 1 12 opcode 1 x unused 2 3+n request-length 4 WINDOW window 2 BITMASK value-mask 2 x unused 4n LISTofVALUE value-list ) (x-request CirculateWindow 1 13 opcode 1 (MEMBER RaiseLowest LowerHighest) direction 2 2 request-length 4 WINDOW window ) (x-request GetGeometry 1 14 opcode 1 x unused 2 2 request-length 4 DRAWABLE drawable ) (x-request QueryTree 1 15 opcode 1 x unused 2 2 request-length 4 WINDOW window ) (x-request InternAtom 1 16 opcode 1 BOOL only-if-exists 2 |2+(n+p)/4| request-length 2 n length-of-name 2 x unused n STRING8 name p x unused ) (x-request GetAtomName 1 17 opcode 1 x unused 2 2 request-length 4 ATOM atom ) (x-request ChangeProperty 1 18 opcode 1 (MEMBER replace prepend append) mode 2 |6+(n+p)/4| request-length 4 WINDOW window 4 ATOM property 4 ATOM type 1 CARD8 format 3 x unused 4 CARD32 length-of-data-in-format-units n LISTofBYTE data p x unused ) (x-request DeleteProperty 1 19 opcode 1 x unused 2 3 request-length 4 WINDOW window 4 ATOM property ) (x-request GetProperty 1 20 opcode 1 BOOL delete 2 6 request-length 4 WINDOW window 4 ATOM property 4 (OR (MEMBER anypropertytype) ATOM) type 4 CARD32 long-offset 4 CARD32 long-length ) (x-request ListProperties 1 21 opcode 1 x unused 2 2 request-length 4 WINDOW window ) (x-request SetSelectionOwner 1 22 opcode 1 x unused 2 4 request-length 4 (OR (MEMBER none) WINDOW) owner 4 ATOM selection 4 (OR (MEMBER currenttime) TIMESTAMP) time ) (x-request GetSelectionOwner 1 23 opcode 1 x unused 2 2 request-length 4 ATOM selection ) (x-request ConvertSelection 1 24 opcode 1 x unused 2 6 request-length 4 WINDOW requestor 4 ATOM selection 4 ATOM target 4 (OR (MEMBER none) ATOM) property 4 (OR (MEMBER currenttime) TIMESTAMP) time ) (x-request SendEvent 1 25 opcode 1 BOOL propagate 2 11 request-length 4 (OR (MEMBER pointerwindow inputfocus) WINDOW) destination 4 SETofEVENT event-mask 32 n event ) (x-request GrabPointer 1 26 opcode 1 BOOL owner-events 2 6 request-length 4 WINDOW grab-window 2 SETofPOINTEREVENT event-mask 1 (MEMBER Synchronous Asynchronous) pointer-mode 1 (MEMBER Synchronous Asynchronous) keyboard-mode 4 (OR (MEMBER none) WINDOW) confine-to 4 (OR (MEMBER none) CURSOR) cursor 4 (OR (MEMBER currenttime) TIMESTAMP) timestamp ) (x-request UngrabPointer 1 27 opcode 1 x unused 2 2 request-length 4 (OR (MEMBER currenttime) TIMESTAMP) time ) (x-request GrabButton 1 28 opcode 1 BOOL owner-events 2 6 request-length 4 WINDOW grab-window 2 SETofPOINTEREVENT event-mask 1 (MEMBER Synchronous Asynchronous) pointer-mode 1 (MEMBER Synchronous Asynchronous) keyboard-mode 4 (OR (MEMBER none) WINDOW) confine-to 4 (OR (MEMBER none) CURSOR) cursor 1 (OR (MEMBER anybutton) BUTTON)button 1 x unused 2 SETofKEYMASK modifiers ) (x-request UngrabButton 1 29 opcode 1 (OR (MEMBER anybutton) BUTTON) button 2 3 request-length 4 WINDOW grab-window 2 SETofKEYMASK modifiers 2 x unused ) (x-request ChangeActivePointerGrab 1 30 opcode 1 x unused 2 4 request-length 4 (OR (MEMBER none) CURSOR) cursor 4 (OR (MEMBER currenttime) TIMESTAMP) time 2 SETofPOINTEREVENT event-mask 2 x unused ) (x-request GrabKeyboard 1 31 opcode 1 BOOL owner-events 2 4 request-length 4 WINDOW grab-window 4 (OR (MEMBER currenttime) TIMESTAMP) time 1 (MEMBER Synchronous Asynchronous) pointer-mode 1 (MEMBER Synchronous Asynchronous) keyboard-mode 2 x unused ) (x-request UngrabKeyboard 1 32 opcode 1 x unused 2 2 request-length 4 (OR (MEMBER currenttime) TIMESTAMP) time ) (x-request GrabKey 1 33 opcode 1 BOOL owner-events 2 4 request-length 4 WINDOW grab-window 2 SETofKEYMASK modifiers 1 (OR (MEMBER anykey) KEYCODE) key 1 (MEMBER Synchronous Asynchronous) pointer-mode 1 (MEMBER Synchronous Asynchronous) keyboard-mode 3 x unused ) (x-request UngrabKey 1 34 opcode 1 (OR (MEMBER anykey) KEYCODE) key 2 3 request-length 4 WINDOW grab-window 2 SETofKEYMASK modifiers 2 x unused ) (x-request AllowEvents 1 35 opcode 1 (MEMBER AsyncPointer SyncPointer ReplayPointer AsyncKeyboard SyncKeyboard ReplayKeyboard) mode 2 2 request-length 4 (OR (MEMBER currenttime) TIMESTAMP) time ) (x-request GrabServer 1 36 opcode 1 x unused 2 1 request-length ) (x-request UngrabServer 1 37 opcode 1 x unused 2 1 request-length ) (x-request QueryPointer 1 38 opcode 1 x unused 2 2 request-length 4 WINDOW window ) (x-request GetMotionEvents 1 39 opcode 1 x unused 2 4 request-length 4 WINDOW window 4 (OR (MEMBER CURRENTTIME) TIMESTAMP) start 4 (OR (MEMBER CURRENTTIME) TIMESTAMP) stop ) (x-request TranslateCoords 1 40 opcode 1 x unused 2 4 request-length 4 WINDOW src-window 4 WINDOW dst-window 2 INT16 src-x 2 INT16 src-y ) (x-request WarpPointer 1 41 opcode 1 x unused 2 6 request-length 4 (OR (MEMBER none) WINDOW) src-window 4 WINDOW dst-window 2 INT16 src-x 2 INT16 src-y 2 CARD16 src-width 2 CARD16 src-height 2 INT16 dst-x 2 INT16 dst-y ) (x-request SetInputFocus 1 42 opcode 1 (MEMBER none pointerroot parent) revert-to 2 3 request-length 4 (OR (MEMBER none pointerroot) WINDOW) focus 4 (OR (MEMBER CURRENTTIME) TIMESTAMP) time ) (x-request GetInputFocus 1 43 opcode 1 x unused 2 1 request-length ) (x-request QueryKeymap 1 44 opcode 1 x unused 2 1 request-length ) (x-request OpenFont 1 45 opcode 1 x unused 2 |3+(n+p)/4| request-length 4 FONT fid 2 n length-of-name 2 x unused n STRING8 name p x unused ) (x-request CloseFont 1 46 opcode 1 x unused 2 2 request-length 4 FONT font ) (x-request QueryFont 1 47 opcode 1 x unused 2 2 request-length 4 FONTABLE font ) (x-request QueryTextExtents 1 48 opcode 1 BOOL odd-length-p 2 |2+(2n+p)/4| request-length 4 FONTABLE font 2n STRING16 string p x unused ) (x-request ListFonts 1 49 opcode 1 x unused 2 |2+(n+p)/4| request-length 2 CARD16 max-names 2 n length-of-pattern n STRING8 pattern p x unused ) (x-request ListFontsWithInfo 1 50 opcode 1 x unused 2 |2+(n+p)/4| request-length 2 CARD16 max-names 2 n length-of-pattern n STRING8 pattern p x unused ) (x-request SetFontPath 1 51 opcode 1 x unused 2 |2+(n+p)/4| request-length 2 CARD16 number-of-STRs-in-path 2 x unused n LISTofSTR path p x unused ) (x-request GetFontPath 1 52 opcode 1 x unused 2 1 request-list ) (x-request CreatePixmap 1 53 opcode 1 CARD8 depth 2 4 request-length 4 PIXMAP pid 4 DRAWABLE drawable 2 CARD16 width 2 CARD16 height ) (x-request FreePixmap 1 54 opcode 1 x unused 2 2 request-length 4 PIXMAP pixmap ) (x-request CreateGC 1 55 opcode 1 x unused 2 4+n request-length 4 GCONTEXT cid 4 DRAWABLE drawable 4 (BITMASK *gc-bitmask*) value-mask 4n LISTofVALUE value-list ) (defconstant *gc-bitmask* #(function plane-mask foreground background line-width line-style cap-style join-style fill-style fill-rule tile stipple tile-stipple-x-origin tile-stipple-y-origin font subwindow-mode graphics-exposures clip-x-origin clip-y-origin clip-mask dash-offset dashes arc-mode)) (x-request ChangeGC 1 56 opcode 1 x unused 2 3+n request-length 4 GCONTEXT gc 4 (BITMASK *gc-bitmask*) value-mask 4n LISTofVALUE value-list ) (x-request CopyGC 1 57 opcode 1 x unused 2 4 request-length 4 GCONTEXT src-gc 4 GCONTEXT dst-gc 4 (BITMASK *gc-bitmask*) value-mask ) (x-request SetDashes 1 58 opcode 1 x unused 2 |3+(n+p)/4| request-length 4 GCONTEXT gc 2 CARD16 dash-offset 2 n length-of-dashes n LISTofCARD8 dashes p x unused ) (x-request SetClipRectangles 1 59 opcode 1 (MEMBER UnSorted YSorted YXSorted YXBanded) ordering 2 3+2n request-length 4 GCONTEXT gc 2 INT16 clip-x-origin 2 INT16 clip-y-origin 8n LISTofRECTANGLE rectangles ) (x-request FreeGC 1 60 opcode 1 x unused 2 2 request-length 4 GCONTEXT gc ) (x-request ClearToBackground 1 61 opcode 1 BOOL exposures 2 4 request-length 4 WINDOW window 2 INT16 x 2 INT16 y 2 CARD16 width 2 CARD16 height ) (x-request CopyArea 1 62 opcode 1 x unused 2 7 request-length 4 DRAWABLE src-drawable 4 DRAWABLE dst-drawable 4 GCONTEXT gc 2 INT16 src-x 2 INT16 src-y 2 INT16 dst-x 2 INT16 dst-y 2 CARD16 width 2 CARD16 height ) (x-request CopyPlane 1 63 opcode 1 x unused 2 8 request-length 4 DRAWABLE src-drawable 4 DRAWABLE dst-drawable 4 GCONTEXT gc 2 INT16 src-x 2 INT16 src-y 2 INT16 dst-x 2 INT16 dst-y 2 CARD16 width 2 CARD16 height 4 CARD32 bit-plane ) (x-request PolyPoint 1 64 opcode 1 (MEMBER origin previous) coordinate-mode 2 3+n request-length 4 DRAWABLE drawable 4 GCONTEXT gc 4n LISTofPOINT points ) (x-request PolyLine 1 65 opcode 1 (MEMBER origin previous) coordinate-mode 2 3+n request-length 4 DRAWABLE drawable 4 GCONTEXT gc 4n LISTofPOINT points ) (x-request PolySegment 1 66 opcode 1 x unused 2 3+2n request-length 4 DRAWABLE drawable 4 GCONTEXT gc 8n LISTofSEGMENT segments ) (x-request PolyRectangle 1 67 opcode 1 x unused 2 3+2n request-length 4 DRAWABLE drawable 4 GCONTEXT gc 8n LISTofRECTANGLE rectangles ) (x-request PolyArc 1 68 opcode 1 x unused 2 3+3n request-length 4 DRAWABLE drawable 4 GCONTEXT gc 12n LISTofARC arcs ) (x-request FillPoly 1 69 opcode 1 x unused 2 4+n request-length 4 DRAWABLE drawable 4 GCONTEXT gc 1 (MEMBER complex nonconvex convex) shape 1 (MEMBER origin previous) coordinate-mode 2 x unused 4n LISTofPOINT points ) (x-request PolyFillRectangle 1 70 opcode 1 x unused 2 3+2n request-length 4 DRAWABLE drawable 4 GCONTEXT gc 8n LISTofRECTANGLE rectangles ) (x-request PolyFillArc 1 71 opcode 1 x unused 2 3+3n request-length 4 DRAWABLE drawable 4 GCONTEXT gc 12n LISTofARC arcs ) (x-request PutImage 1 72 opcode 1 (bitmap xypixmap zpixmap) format 2 |6+(n+p)/4| request-length 4 DRAWABLE drawable 4 GCONTEXT gc 2 CARD16 width 2 CARD16 height 2 INT16 dst-x 2 INT16 dst-y 1 CARD8 left-pad 1 CARD8 depth 2 x unused n LISTofBYTE data p x unused ) (x-request GetImage 1 73 opcode 1 (MEMBER error xypixmap zpixmap) format 2 5 request-length 4 DRAWABLE drawable 2 INT16 x 2 INT16 y 2 CARD16 width 2 CARD16 height 4 CARD32 plane-mask ) (x-request PolyText8 1 74 opcode 1 x unused 2 |4+(n+p)/4| request-length 4 DRAWABLE drawable 4 GCONTEXT gc 2 INT16 x 2 INT16 y n LISTofTEXTITEM8 items p x unused ) (x-request PolyText16 1 75 opcode 1 x unused 2 |4+(n+p)/4| request-length 4 DRAWABLE drawable 4 GCONTEXT gc 2 INT16 x 2 INT16 y n LISTofTEXTITEM16 items p x unused ) (x-request ImageText8 1 76 opcode 1 n length-of-string 2 |4+(n+p)/4| request-length 4 DRAWABLE drawable 4 GCONTEXT gc 2 INT16 x 2 INT16 y n STRING8 string p x unused ) (x-request ImageText16 1 77 opcode 1 n number-of-CHAR2Bs-in-string 2 |4+(2n+p)/4| request-length 4 DRAWABLE drawable 4 GCONTEXT gc 2 INT16 x 2 INT16 y 2n STRING16 string p x unused ) (x-request CreateColormap 1 78 opcode 1 (MEMBER none all) alloc 2 4 request-length 4 COLORMAP mid 4 WINDOW window 4 VISUALID visual ) (x-request FreeColormap 1 79 opcode 1 x unused 2 2 request-length 4 COLORMAP cmap ) (x-request CopyColormapAndFree 1 80 opcode 1 x unused 2 3 request-length 4 COLORMAP mid 4 COLORMAP src-cmap ) (x-request InstallColormap 1 81 opcode 1 x unused 2 2 request-length 4 COLORMAP cmap ) (x-request UninstallColormap 1 82 opcode 1 x unused 2 2 request-length 4 COLORMAP cmap ) (x-request ListInstalledColormaps 1 83 opcode 1 x unused 2 2 request-length 4 WINDOW window ) (x-request AllocColor 1 84 opcode 1 x unused 2 4 request-length 4 COLORMAP cmap 2 CARD16 red 2 CARD16 green 2 CARD16 blue 2 x unused ) (x-request AllocNamedColor 1 85 opcode 1 x unused 2 |3+(n+p)/4| request-length 4 COLORMAP cmap 2 n length-of-name 2 x unused n STRING8 name p x unused ) (x-request AllocColorCells 1 86 opcode 1 BOOL contiguous 2 3 request-length 4 COLORMAP cmap 2 CARD16 colors 2 CARD16 planes ) (x-request AllocColorPlanes 1 87 opcode 1 BOOL contiguous 2 4 request-length 4 COLORMAP cmap 2 CARD16 colors 2 CARD16 reds 2 CARD16 greens 2 CARD16 blues ) (x-request FreeColors 1 88 opcode 1 x unused 2 3+n request-length 4 COLORMAP cmap 4 CARD32 plane-mask 4n LISTofCARD32 pixels ) (x-request StoreColors 1 89 opcode 1 x unused 2 2+3n request-length 4 COLORMAP cmap 12n LISTofCOLORITEM items ) (x-request StoreNamedColor 1 90 opcode 1 color-mask do-red_do-green_do-blue 2 |4+(n+p)/4| request-length 4 COLORMAP cmap 4 CARD32 pixel 2 n length-of-name 2 x unused n STRING8 name p x unused ) (x-request QueryColors 1 91 opcode 1 x unused 2 2+n request-length 4 COLORMAP cmap 4n LISTofCARD32 pixels ) (x-request LookupColor 1 92 opcode 1 x unused 2 |3+(n+p)/4| request-length 4 COLORMAP cmap 2 n length-of-name 2 x unused n STRING8 name p x unused ) (x-request CreateCursor 1 93 opcode 1 x unused 2 8 request-length 4 CURSOR cid 4 PIXMAP source 4 (OR (MEMBER none) PIXMAP) mask 2 CARD16 fore-red 2 CARD16 fore-green 2 CARD16 fore-blue 2 CARD16 back-red 2 CARD16 back-green 2 CARD16 back-blue 2 CARD16 x 2 CARD16 y ) (x-request CreateGlyphCursor 1 94 CreateGlyphCursor 1 x unused 2 8 request-length 4 CURSOR cid 4 FONT source-font 4 (OR (MEMBER none) FONT) mask-font 2 CARD16 source-char 2 CARD16 mask-char 2 CARD16 fore-red 2 CARD16 fore-green 2 CARD16 fore-blue 2 CARD16 back-red 2 CARD16 back-green 2 CARD16 back-blue ) (x-request FreeCursor 1 95 opcode 1 x unused 2 2 request-length 4 CURSOR cursor ) (x-request RecolorCursor 1 96 opcode 1 x unused 2 5 request-length 4 CURSOR cursor 2 CARD16 fore-red 2 CARD16 fore-green 2 CARD16 fore-blue 2 CARD16 back-red 2 CARD16 back-green 2 CARD16 back-blue ) (x-request QueryBestSize 1 97 opcode 1 (MEMBER cursor tile stipple) class 2 3 request-length 4 DRAWABLE drawable 2 CARD16 width 2 CARD16 height ) (x-request QueryExtension 1 98 opcode 1 x unused 2 |2+(n+p)/4| request-length 2 n length-of-name 2 x unused n STRING8 name p x unused ) (x-request ListExtensions 1 99 opcode 1 x unused 2 1 request-length ) (x-request SetKeyboardMapping 1 100 opcode 1 n keycode-count 2 2+nm request-length 1 KEYCODE first-keycode 1 m keysyms-per-keycode 2 x unused 4nm LISTofKEYSYM keysyms ) (x-request GetKeyboardMapping 1 101 opcode 1 x unused 2 2 request-length 1 KEYCODE first-keycode 1 CARD8 count 2 x unused ) (x-request ChangeKeyboardControl 1 102 opcode 1 x unused 2 2+n request-length 4 BITMASK value-mask 4n LISTofVALUE value-list ) (x-request GetKeyboardControl 1 103 opcode 1 x unused 2 1 request-length ) (x-request Bell 1 104 opcode 1 INT8 percent 2 1 request-length ) (x-request ChangePointerControl 1 105 opcode 1 x unused 2 3 request-length 2 INT16 acceleration-numerator 2 INT16 acceleration-denominator 2 INT16 threshold 1 BOOL do-acceleration 1 BOOL do-threshold ) (x-request GetPointerControl 1 106 GetPointerControl 1 x unused 2 1 request-length ) (x-request SetScreenSaver 1 107 opcode 1 x unused 2 3 request-length 2 INT16 timeout 2 INT16 interval 1 (MEMBER no yes default) prefer-blanking 1 (MEMBER no yes default) allow-exposures 2 x unused ) (x-request GetScreenSaver 1 108 opcode 1 x unused 2 1 request-length ) (x-request ChangeHosts 1 109 opcode 1 (MEMBER insert delete) mode 2 |2+(n+p)/4| request-length 1 (MEMBER internet decnet chaos) family 1 x unused 2 CARD16 length-of-address n LISTofCARD8 address p x unused ) (x-request ListHosts 1 110 opcode 1 x unused 2 1 request-length ) (x-request ChangeAccessControl 1 111 opcode 1 (MEMBER disable enable) mode 2 1 request-length ) (x-request ChangeCloseDownMode 1 112 opcode 1 (MEMBER destroy retainpermanent retaintemporary) mode 2 1 request-length ) (x-request KillClient 1 113 opcode 1 x unused 2 2 request-length 4 (MEMBER alltemporary CARD32) resource ) (x-request RotateProperties 1 114 opcode 1 x unused 2 3+n request-length 4 WINDOW window 2 n number-of-properties 2 INT16 delta 4n LISTofATOM properties ) (x-request ForceScreenSaver 1 115 ForceScreenSaver 1 (MEMBER reset activate) mode 2 1 request-length ) (x-request SetPointerMapping 1 116 opcode 1 n length-of-map 2 |1+(n+p)/4| request-length n LISTofCARD8 map p x unused ) (x-request GetPointerMapping 1 117 opcode 1 x unused 2 1 request-length ) (x-request SetModifierMapping 1 118 opcode 1 KEYCODE Lock 2 5 request-length 1 KEYCODE Shift_A 1 KEYCODE Shift_B 1 KEYCODE Control_A 1 KEYCODE Control_B 1 KEYCODE Mod1_A 1 KEYCODE Mod1_B 1 KEYCODE Mod2_A 1 KEYCODE Mod2_B 1 KEYCODE Mod3_A 1 KEYCODE Mod3_B 1 KEYCODE Mod4_A 1 KEYCODE Mod4_B 1 KEYCODE Mod5_A 1 KEYCODE Mod5_B 2 x unused ) (x-request GetModifierMapping 1 119 opcode 1 x unused 2 1 request-length ) #+comment (x-request NoOperation 1 127 opcode 1 x unused 2 1 request-length ) ;; End of file ecl-16.1.2/src/clx/debug/event-test.lisp000066400000000000000000000226521266352375300200210ustar00rootroot00000000000000;;; -*- Mode: LISP; Syntax: Common-lisp; Package: (XTEST (XLIB LISP)); Base: 10; Lowercase: Yes -*- (in-package :xtest :use '(:xlib :lisp)) (defstruct event key ; Event key display ; Display event was reported to ;; The following are from the CLX event code state time event-window root drawable window child parent root-x root-y x y width height border-width override-redirect-p same-screen-p configure-p hint-p kind mode keymap focus-p count major minor above-sibling place atom selection requestor target property colormap new-p installed-p format type data send-event-p ) (defun process-input (display &optional timeout) "Process one event" (declare (type display display) ; The display (from initialize-clue) (type (or null number) timeout) ; optional timeout in seconds (values (or null character))) ; Returns NIL only if timeout exceeded (let ((event (make-event))) (setf (event-display event) display) (macrolet ((set-event (&rest parameters) `(progn ,@(mapcar #'(lambda (parm) `(setf (,(intern (concatenate 'string (string 'event-) (string parm))) event) ,parm)) parameters))) (dispatch (contact) `(dispatch-event event event-key send-event-p ,contact))) (let ((result (xlib:event-case (display :timeout timeout :force-output-p t) ((:key-press :key-release :button-press :button-release) (code time root window child root-x root-y x y state same-screen-p event-key send-event-p) (set-event code time root window child root-x root-y x y state same-screen-p) (dispatch window)) (:motion-notify (hint-p time root window child root-x root-y x y state same-screen-p event-key send-event-p) (set-event hint-p time root window child root-x root-y x y state same-screen-p) (dispatch window)) ((:enter-notify :leave-notify) (kind time root window child root-x root-y x y state mode focus-p same-screen-p event-key send-event-p) (set-event kind time root window child root-x root-y x y state mode focus-p same-screen-p) (dispatch window)) ((:focus-in :focus-out) (kind window mode event-key send-event-p) (set-event kind window mode) (dispatch window)) (:keymap-notify (window keymap event-key send-event-p) (set-event window keymap) (dispatch window)) (:exposure (window x y width height count event-key send-event-p) (set-event window x y width height count) (dispatch window)) (:graphics-exposure (drawable x y width height count major minor event-key send-event-p) (set-event drawable x y width height count major minor) (dispatch drawable)) (:no-exposure (drawable major minor event-key send-event-p) (set-event drawable major minor) (dispatch drawable)) (:visibility-notify (window state event-key send-event-p) (set-event window state) (dispatch window)) (:create-notify (parent window x y width height border-width override-redirect-p event-key send-event-p) (set-event parent window x y width height border-width override-redirect-p) (dispatch parent)) (:destroy-notify (event-window window event-key send-event-p) (set-event event-window window) (dispatch event-window)) (:unmap-notify (event-window window configure-p event-key send-event-p) (set-event event-window window configure-p) (dispatch event-window)) (:map-notify (event-window window override-redirect-p event-key send-event-p) (set-event event-window window override-redirect-p) (dispatch event-window)) (:map-request (parent window event-key send-event-p) (set-event parent window) (dispatch parent)) (:reparent-notify (event-window window parent x y override-redirect-p event-key send-event-p) (set-event event-window window parent x y override-redirect-p) (dispatch event-window)) (:configure-notify (event-window window above-sibling x y width height border-width override-redirect-p event-key send-event-p) (set-event event-window window above-sibling x y width height border-width override-redirect-p) (dispatch event-window)) (:configure-request (parent window above-sibling x y width height border-width event-key send-event-p) (set-event parent window above-sibling x y width height border-width) (dispatch parent)) (:gravity-notify (event-window window x y event-key send-event-p) (set-event event-window window x y) (dispatch event-window)) (:resize-request (window width height event-key send-event-p) (set-event window width height) (dispatch window)) (:circulate-notify (event-window window parent place event-key send-event-p) (set-event event-window window parent place) (dispatch event-window)) (:circulate-request (parent window place event-key send-event-p) (set-event parent window place) (dispatch parent)) (:property-notify (window atom time state event-key send-event-p) (set-event window atom time state) (dispatch window)) (:selection-clear (time window selection event-key send-event-p) (set-event time window selection) (dispatch window)) (:selection-request (time window requestor selection target property event-key send-event-p) (set-event time window requestor selection target property) (dispatch window)) (:selection-notify (time window selection target property event-key send-event-p) (set-event time window selection target property) (dispatch window)) (:colormap-notify (window colormap new-p installed-p event-key send-event-p) (set-event window colormap new-p installed-p) (dispatch window)) (:client-message (format window type data event-key send-event-p) (set-event format window type data) (dispatch window)) (:mapping-notify (request start count) (mapping-notify display request start count)) ;; Special case ))) (and result t))))) (defun event-case-test (display) ;; Tests universality of display, event-key, event-code, send-event-p and event-window (event-case (display) ((key-press key-release button-press button-release motion-notify enter-notify leave-notify focus-in focus-out keymap-notify exposure graphics-exposure no-exposure visibility-notify create-notify destroy-notify unmap-notify map-notify map-request reparent-notify configure-notify gravity-notify resize-request configure-request circulate-notify circulate-request property-notify selection-clear selection-request selection-notify colormap-notify client-message) (display event-key event-code send-event-p event-window) (print (list display event-key event-code send-event-p event-window))) (mapping-notify ;; mapping-notify doesn't have event-window (display event-key event-code send-event-p) (print (list display event-key event-code send-event-p))) )) ecl-16.1.2/src/clx/debug/keytrans.lisp000066400000000000000000000274041266352375300175630ustar00rootroot00000000000000;;; -*- Mode:Lisp; Package:XLIB; Syntax:COMMON-LISP; Base:10; Lowercase:T -*- ;;; CLX keysym-translation test programs ;;; ;;; TEXAS INSTRUMENTS INCORPORATED ;;; P.O. BOX 2909 ;;; AUSTIN, TEXAS 78769 ;;; ;;; Copyright (C) 1987 Texas Instruments Incorporated. ;;; ;;; Permission is granted to any individual or institution to use, copy, modify, ;;; and distribute this software, provided that this complete copyright and ;;; permission notice is maintained, intact, in all copies and supporting ;;; documentation. ;;; ;;; Texas Instruments Incorporated provides this software "as is" without ;;; express or implied warranty. ;;; (in-package :xlib) (defun list-missing-keysyms () ;; Lists explorer characters which have no keysyms (dotimes (i 256) (unless (character->keysyms (int-char i)) (format t "~%(define-keysym ~@c ~d)" (int-char i) i)))) (defun list-multiple-keysyms () ;; Lists characters with more than one keysym (dotimes (i 256) (when (cdr (character->keysyms (int-char i))) (format t "~%Character ~@c [~d] has keysyms" (int-char i) i) (dolist (keysym (character->keysyms (int-char i))) (format t " ~d ~d" (ldb (byte 8 8) keysym) (ldb (byte 8 0) keysym)))))) (defun check-lowercase-keysyms () ;; Checks for keysyms with incorrect :lowercase parameters (maphash #'(lambda (key mapping) (let* ((value (car mapping)) (char (keysym-mapping-object value))) (if (and (characterp char) (both-case-p char) (= (char-int char) (char-int (char-upcase char)))) ;; uppercase alphabetic character (unless (eq (keysym-mapping-lowercase value) (char-int (char-downcase char))) (let ((lowercase (keysym-mapping-lowercase value)) (should-be (char-downcase char))) (format t "~%Error keysym ~3d ~3d (~@c) has :Lowercase ~3d ~3d (~s) Should be ~3d ~3d (~@c)" (ldb (byte 8 8) key) (ldb (byte 8 0) key) char (and lowercase (ldb (byte 8 8) lowercase)) (and lowercase (ldb (byte 8 0) lowercase)) (int-char lowercase) (ldb (byte 8 8) (char-int should-be)) (ldb (byte 8 0) (char-int should-be)) should-be))) (when (keysym-mapping-lowercase value) (let ((lowercase (keysym-mapping-lowercase value))) (format t "~%Error keysym ~3d ~3d (~@c) has :lowercase ~3d ~3d (~@c) and shouldn't" (ldb (byte 8 8) key) (ldb (byte 8 0) key) char (and lowercase (ldb (byte 8 8) (char-int lowercase))) (and lowercase (ldb (byte 8 0) (char-int lowercase))) lowercase )))))) *keysym->character-map*)) (defun print-all-keysyms () (let ((all nil)) (maphash #'(lambda (key value) (push (cons key value) all)) *keysym->character-map*) (setq all (sort all #'< :key #'car)) (format t "~%~d keysyms:" (length all)) (dolist (keysym all) (format t "~%~3d ~3d~{ ~s~}" (ldb (byte 8 8) (car keysym)) (ldb (byte 8 0) (car keysym)) (cadr keysym)) (dolist (mapping (cddr keysym)) (format t "~%~7@t~{ ~s~}" mapping))))) (defun keysym-mappings (keysym &key display (mask-format #'identity)) ;; Return all the keysym mappings for keysym. ;; Returns a list of argument lists that are argument-lists to define-keysym. ;; The following will re-create the mappings for KEYSYM: ;; (dolist (mapping (keysym-mappings) keysym) ;; (apply #'define-keysym mapping)) (let ((mappings (append (and display (cdr (assoc keysym (display-keysym-translation display)))) (gethash keysym *keysym->character-map*))) (result nil)) (dolist (mapping mappings) (let ((object (keysym-mapping-object mapping)) (translate (keysym-mapping-translate mapping)) (lowercase (keysym-mapping-lowercase mapping)) (modifiers (keysym-mapping-modifiers mapping)) (mask (keysym-mapping-mask mapping))) (push (append (list object keysym) (when translate (list :translate translate)) (when lowercase (list :lowercase lowercase)) (when modifiers (list :modifiers (funcall mask-format modifiers))) (when mask (list :mask (funcall mask-format mask)))) result))) (nreverse result))) #+comment (defun print-keysym-mappings (keysym &optional display) (format t "~%(keysym ~d ~3d) " (ldb (byte 8 8) keysym) (ldb (byte 8 0) keysym)) (dolist (mapping (keysym-mappings keysym :display display)) (format t "~16t~{ ~s~}~%" mapping))) (defun print-keysym-mappings (keysym &optional display) (flet ((format-mask (mask) (cond ((numberp mask) `(make-state-mask ,@(make-state-keys mask))) ((atom mask) mask) (t `(list ,@(mapcar #'(lambda (item) (if (numberp item) `(keysym ,(keysym-mapping-object (car (gethash item *keysym->character-map*)))) item)) mask)))))) (dolist (mapping (keysym-mappings keysym :display display :mask-format #'format-mask)) (format t "~%(define-keysym ~s (keysym ~d ~3d)~{ ~s~})" (car mapping) (ldb (byte 8 8) keysym) (ldb (byte 8 0) keysym) (cdr mapping))))) (defun keysym-test (host) ;; Server key-press Loop-back test (let* ((display (open-display host)) (width 400) (height 400) (screen (display-default-screen display)) (black (screen-black-pixel screen)) (white (screen-white-pixel screen)) (win (create-window :parent (screen-root screen) :background black :border white :border-width 1 :colormap (screen-default-colormap screen) :bit-gravity :center :event-mask '(:exposure :key-press) :x 20 :y 20 :width width :height height)) #+comment (gc (create-gcontext :drawable win :background black :foreground white))) (initialize-extensions display) (map-window win) ; Map the window ;; Handle events (unwind-protect (dotimes (state 64) (do ((code (display-min-keycode display) (1+ code))) ((> code (display-max-keycode display))) (send-event win :key-press '(:key-press) :code code :state state :window win :root (screen-root screen) :time 0 :x 1 :y 2 :root-x 10 :root-y 20 :same-screen-p t) (event-case (display :force-output-p t :discard-p t) (exposure ;; Come here on exposure events (window count) (when (zerop count) ;; Ignore all but the last exposure event (clear-area window)) nil) (key-press (display code state) (princ (keycode->character display code state)) t)))) (close-display display)))) (defun keysym-echo (host &optional keymap-p) ;; Echo characters typed to a window (let* ((display (open-display host)) (width 400) (height 400) (screen (display-default-screen display)) (black (screen-black-pixel screen)) (white (screen-white-pixel screen)) (win (create-window :parent (screen-root screen) :background black :border white :border-width 1 :colormap (screen-default-colormap screen) :bit-gravity :center :event-mask '(:exposure :key-press :keymap-state :enter-window) :x 20 :y 20 :width width :height height)) (gc (create-gcontext :drawable win :background black :foreground white))) (initialize-extensions display) (map-window win) ; Map the window ;; Handle events (unwind-protect (event-case (display :force-output-p t :discard-p t) (exposure ;; Come here on exposure events (window count) (when (zerop count) ;; Ignore all but the last exposure event (clear-area window) (draw-glyphs window gc 10 10 "Press to exit")) nil) (key-press (display code state) (let ((char (keycode->character display code state))) (format t "~%Code: ~s State: ~s Char: ~s" code state char) ;; (PRINC char) (PRINC " ") (when keymap-p (let ((keymap (query-keymap display))) (unless (character-in-map-p display char keymap) (print "character-in-map-p failed") (print-keymap keymap)))) ;; (when (eql char #\0) (setq disp display) (break)) (eql char #\escape))) (keymap-notify (keymap) (print "Keymap-notify") ;; we never get here. Server bug? (when (keysym-in-map-p display 65 keymap) (print "Found A")) (when (character-in-map-p display #\b keymap) (print "Found B"))) (enter-notify (event-window) (format t "~%Enter ~s" event-window))) (close-display display)))) (defun print-keymap (keymap) (do ((j 32 (+ j 32))) ;; first 32 bits is for window ((>= j 256)) (format t "~% ~3d: " j) (do ((i j (1+ i))) ((>= i (+ j 32))) (when (zerop (logand i 7)) (princ " ")) (princ (aref keymap i))))) (defun define-keysym-test (&key display printp (modifiers (list (keysym :left-meta))) (mask :modifiers)) (let* ((keysym 067) (args `(baz ,keysym :modifiers ,modifiers ,@(and mask `(:mask ,mask)))) (original (copy-tree (keysym-mappings keysym :display display)))) (when printp (print-keysym-mappings 67) (terpri)) (apply #'define-keysym args) (when printp (print-keysym-mappings 67) (terpri)) (let ((is (keysym-mappings keysym :display display)) (should-be (append original (list args)))) (unless (equal is should-be) (cerror "Ignore" "define-keysym error. ~%is: ~s ~%Should be: ~s" is should-be))) (apply #'undefine-keysym args) (when printp (print-keysym-mappings 67) (terpri)) (let ((is (keysym-mappings keysym :display display))) (unless (equal is original) (cerror "Ignore" "undefine-keysym error. ~%is: ~s ~%Should be: ~s" is original))))) (define-keysym-test) (define-keysym-test :modifiers (make-state-mask :shift :lock)) (define-keysym-test :modifiers (list :shift (keysym :left-meta) :control)) (define-keysym-test :modifiers (make-state-mask :shift :lock) :mask nil) ecl-16.1.2/src/clx/debug/trace.lisp000066400000000000000000000444431266352375300170230ustar00rootroot00000000000000;;; -*- Mode: LISP; Syntax: Common-lisp; Package: XLIB; Base: 10; Lowercase: Yes -*- ;;; ;;; TEXAS INSTRUMENTS INCORPORATED ;;; P.O. BOX 2909 ;;; AUSTIN, TEXAS 78769 ;;; ;;; Copyright (C) 1987 Texas Instruments Incorporated. ;;; ;;; Permission is granted to any individual or institution to use, copy, modify, ;;; and distribute this software, provided that this complete copyright and ;;; permission notice is maintained, intact, in all copies and supporting ;;; documentation. ;;; ;;; Texas Instruments Incorporated provides this software "as is" without ;;; express or implied warranty. ;;; ;; Trace works by substituting trace functions for the display-write/input functions. ;; The trace functions maintain a database of requests sent to the server in the ;; trace-history display property. This is an alist of (id . byte-vector) where ;; id is the request number for writes, :reply for replies, :event for events and ;; :error for errors. The alist is kept in reverse order (most recent first) ;; In a multiprocessing system is it very helpful to know what process wrote or ;; read certain requests. Thus I have modified the format of the trace-history ;; list. It is now an alist of: ((id . more-info) . byte-vector). ;; (more-info is a list returned by the trace-more-info function). ;; Also added the ability to suspend and resume tracing without destroying the ;; trace history. Renamed 'display-trace' to 'show-trace' to avoid confusion. ;; 7feb91 -- jdi ;;; Created 09/14/87 by LaMott G. OREN (in-package :xlib) (eval-when (load eval) (export '(trace-display suspend-display-tracing resume-display-tracing untrace-display show-trace display-trace ; for backwards compatibility describe-request describe-event describe-reply describe-error describe-trace))) (defun trace-display (display) "Start a trace on DISPLAY. If display is already being traced, this discards previous history. See show-trace and describe-trace." (declare (type display display)) (unless (getf (display-plist display) 'write-function) (bind-io-hooks display)) (setf (display-trace-history display) nil) t) (defun suspend-display-tracing (display) "Tracing is suspended, but history is not cleared." (if (getf (display-plist display) 'suspend-display-tracing) (warn "Tracing is already suspend for ~s" display) (progn (unbind-io-hooks display) (setf (getf (display-plist display) 'suspend-display-tracing) t)))) (defun resume-display-tracing (display) "Used to resume tracing after suspending" (if (getf (display-plist display) 'suspend-display-tracing) (progn (bind-io-hooks display) (remf (display-plist display) 'suspend-display-tracing)) (warn "Tracing was not suspended for ~s" display))) (defun untrace-display (display) "Stop tracing DISPLAY." (declare (type display display)) (if (not (getf (display-plist display) 'suspend-display-tracing)) (unbind-io-hooks display) (remf (display-plist display) 'suspend-display-tracing)) (setf (display-trace-history display) nil)) ;; Assumes tracing is not already on. (defun bind-io-hooks (display) (let ((write-function (display-write-function display)) (input-function (display-input-function display))) ;; Save origional write/input functions so we can untrace (setf (getf (display-plist display) 'write-function) write-function) (setf (getf (display-plist display) 'input-function) input-function) ;; Set new write/input functions that will record what's sent to the server (setf (display-write-function display) #'(lambda (vector display start end) (trace-write-hook vector display start end) (funcall write-function vector display start end))) (setf (display-input-function display) #'(lambda (display vector start end timeout) (let ((result (funcall input-function display vector start end timeout))) (unless result (trace-read-hook display vector start end)) result))))) (defun unbind-io-hooks (display) (let ((write-function (getf (display-plist display) 'write-function)) (input-function (getf (display-plist display) 'input-function))) (when write-function (setf (display-write-function display) write-function)) (when input-function (setf (display-input-function display) input-function)) (remf (display-plist display) 'write-function) (remf (display-plist display) 'input-function))) (defun byte-ref16 (vector index) #+clx-little-endian (logior (the card16 (ash (the card8 (aref vector (index+ index 1))) 8)) (the card8 (aref vector index))) #-clx-little-endian (logior (the card16 (ash (the card8 (aref vector index)) 8)) (the card8 (aref vector (index+ index 1))))) (defun byte-ref32 (a i) (declare (type buffer-bytes a) (type array-index i)) (declare (values card32)) (declare-buffun) #+clx-little-endian (the card32 (logior (the card32 (ash (the card8 (aref a (index+ i 3))) 24)) (the card29 (ash (the card8 (aref a (index+ i 2))) 16)) (the card16 (ash (the card8 (aref a (index+ i 1))) 8)) (the card8 (aref a i)))) #-clx-little-endian (the card32 (logior (the card32 (ash (the card8 (aref a i)) 24)) (the card29 (ash (the card8 (aref a (index+ i 1))) 16)) (the card16 (ash (the card8 (aref a (index+ i 2))) 8)) (the card8 (aref a (index+ i 3)))))) (defun trace-write-hook (vector display start end) ;; Called only by buffer-flush. Start should always be 0 (unless (zerop start) (format *debug-io* "write-called with non-zero start: ~d" start)) (let* ((history (display-trace-history display)) (request-number (display-request-number display)) (last-history (car history))) ;; There may be several requests in the buffer, and the last one may be ;; incomplete. The first one may be the completion of a previous request. ;; We can detect incomplete requests by comparing the expected length of ;; the last request with the actual length. (when (and last-history (numberp (caar last-history))) (let* ((last-length (index* 4 (byte-ref16 (cdr last-history) 2))) (append-length (min (- last-length (length (cdr last-history))) (- end start)))) (when (plusp append-length) ;; Last history incomplete - append to last (setf (cdr last-history) (concatenate '(vector card8) (cdr last-history) (subseq vector start (+ start append-length)))) (index-incf start append-length)))) ;; Copy new requests into the history (do* ((new-history nil) (i start (+ i length)) request length) ((>= i end) ;; add in sequence numbers (dolist (entry new-history) (setf (caar entry) request-number) (decf request-number)) (setf (display-trace-history display) (nconc new-history history))) (setq request (aref vector i)) (setq length (index* 4 (byte-ref16 vector (+ i 2)))) (when (zerop length) (warn "Zero length in buffer") (return nil)) (push (cons (cons 0 (trace-more-info display request vector i (min (+ i length) end))) (subseq vector i (min (+ i length) end))) new-history) (when (zerop request) (warn "Zero length in buffer") (return nil))))) (defun trace-read-hook (display vector start end) ;; Reading is done with an initial length of 32 (with start = 0) ;; This may be followed by several other reads for long replies. (let* ((history (display-trace-history display)) (last-history (car history)) (length (- end start))) (when (and history (eq (caar last-history) :reply)) (let* ((last-length (index+ 32 (index* 4 (byte-ref32 (cdr last-history) 4)))) (append-length (min (- last-length (length (cdr last-history))) (- end start)))) (when (plusp append-length) (setf (cdr last-history) (concatenate '(vector card8) (cdr last-history) (subseq vector start (+ start append-length)))) (index-incf start append-length) (index-decf length append-length)))) ;; Copy new requests into the history (when (plusp length) (let ((reply-type (case (aref vector start) (0 :error) (1 :reply) (otherwise :event)))) (push (cons (cons reply-type (trace-more-info display reply-type vector start (+ start length))) (subseq vector start (+ start length))) (display-trace-history display)))))) (defun trace-more-info (display request-id vector start end) ;; Currently only returns current process. #+allegro (list mp::*current-process*)) (defun show-trace (display &key length show-process) "Display the trace history for DISPLAY. The default is to show ALL history entries. When the LENGTH parameter is used, only the last LENGTH entries are displayed." (declare (type display display)) (dolist (hist (reverse (subseq (display-trace-history display) 0 length))) (let* ((id (caar hist)) (more-info (cdar hist)) (vector (cdr hist)) (length (length vector)) (request (aref vector 0))) (format t "~%~5d " id) (case id (:error (trace-error-print display more-info vector)) (:event (format t "~a (~d) Sequence ~d" (if (< request (length *event-key-vector*)) (aref *event-key-vector* request) "Unknown") request (byte-ref16 vector 2)) (when show-process #+allegro (format t ", Proc ~a" (mp::process-name (car more-info))))) (:reply (format t "To ~d length ~d" (byte-ref16 vector 2) length) (let ((actual-length (index+ 32 (index* 4 (byte-ref32 vector 4))))) (unless (= length actual-length) (format t " Should be ~d **************" actual-length))) (when show-process #+allegro (format t ", Proc ~a" (mp::process-name (car more-info))))) (otherwise (format t "~a (~d) length ~d" (request-name request) request length) (when show-process #+allegro (format t ", Proc ~a" (mp::process-name (car more-info))))))))) ;; For backwards compatibility (defun display-trace (&rest args) (apply 'show-trace args)) (defun find-trace (display type sequence &optional (number 0)) (dolist (history (display-trace-history display)) (when (and (symbolp (caar history)) (= (logandc2 (aref (cdr history) 0) 128) type) (= (byte-ref16 (cdr history) 2) sequence) (minusp (decf number))) (return (cdr history))))) (defun describe-error (display sequence) "Describe the error associated with request SEQUENCE." (let ((vector (find-trace display 0 sequence))) (if vector (progn (terpri) (trace-error-print display nil vector)) (format t "Error with sequence ~d not found." sequence)))) (defun trace-error-print (display more-info vector &optional (stream *standard-output*)) (let ((event (allocate-event))) ;; Copy into event from reply buffer (buffer-replace (reply-ibuf8 event) vector 0 *replysize*) (reading-event (event) (let* ((type (read-card8 0)) (error-code (read-card8 1)) (sequence (read-card16 2)) (resource-id (read-card32 4)) (minor-code (read-card16 8)) (major-code (read-card8 10)) (current-sequence (ldb (byte 16 0) (buffer-request-number display))) (error-key (if (< error-code (length *xerror-vector*)) (aref *xerror-vector* error-code) 'unknown-error)) (params (case error-key ((colormap-error cursor-error drawable-error font-error gcontext-error id-choice-error pixmap-error window-error) (list :resource-id resource-id)) (atom-error (list :atom-id resource-id)) (value-error (list :value resource-id)) (unknown-error ;; Prevent errors when handler is a sequence (setq error-code 0) (list :error-code error-code))))) type (let ((condition (apply #+lispm #'si:make-condition #+allegro #'make-condition #-(or lispm allegro) #'make-condition error-key :error-key error-key :display display :major major-code :minor minor-code :sequence sequence :current-sequence current-sequence params))) (princ condition stream) (deallocate-event event) condition))))) (defun describe-request (display sequence) "Describe the request with sequence number SEQUENCE" #+ti (si:load-if "clx:debug;describe") (let ((request (assoc sequence (display-trace-history display) :test #'(lambda (item key) (eql item (car key)))))) (if (null request) (format t "~%Request number ~d not found in trace history" sequence) (let* ((vector (cdr request)) (len (length vector)) (hist (make-reply-buffer len))) (buffer-replace (reply-ibuf8 hist) vector 0 len) (print-history-description hist))))) (defun describe-reply (display sequence) "Print the reply to request SEQUENCE. (The current implementation doesn't print very pretty)" (let ((vector (find-trace display 1 sequence)) (*print-array* t)) (if vector (print vector) (format t "~%Reply not found")))) (defun event-number (name) (if (integerp name) (let ((name (logandc2 name 128))) (if (typep name '(integer 0 63)) (aref *event-key-vector* name)) name) (position (string name) *event-key-vector* :test #'equalp :key #'string))) (defun describe-event (display name sequence &optional (number 0)) "Describe the event with event-name NAME and sequence number SEQUENCE. If there is more than one event, return NUMBER in the sequence." (declare (type display display) (type (or stringable (integer 0 63)) name) (integer sequence)) (let* ((event (event-number name)) (vector (and event (find-trace display event sequence number)))) (if (not event) (format t "~%~s isn't an event name" name) (if (not vector) (if (and (plusp number) (setq vector (find-trace display event sequence 0))) (do ((i 1 (1+ i)) (last-vector)) (nil) (if (setq vector (find-trace display event sequence i)) (setq last-vector vector) (progn (format t "~%Event number ~d not found, last event was ~d" number (1- i)) (return (trace-event-print display last-vector))))) (format t "~%Event ~s not found" (aref *event-key-vector* event))) (trace-event-print display vector))))) (defun trace-event-print (display vector) (let* ((event (allocate-event)) (event-code (ldb (byte 7 0) (aref vector 0))) (event-decoder (aref *event-handler-vector* event-code))) ;; Copy into event from reply buffer (setf (event-code event) event-code) (buffer-replace (reply-ibuf8 event) vector 0 *replysize*) (prog1 (funcall event-decoder display event #'(lambda (&rest args &key send-event-p &allow-other-keys) (setq args (copy-list args)) (remf args :display) (remf args :event-code) (unless send-event-p (remf args :send-event-p)) args)) (deallocate-event event)))) (defun describe-trace (display &optional length) "Display the trace history for DISPLAY. The default is to show ALL history entries. When the LENGTH parameter is used, only the last LENGTH entries are displayed." (declare (type display display)) #+ti (si:load-if "clx:debug;describe") (dolist (hist (reverse (subseq (display-trace-history display) 0 length))) (let* ((id (car hist)) (vector (cdr hist)) (length (length vector))) (format t "~%~5d " id) (case id (:error (trace-error-print display nil vector)) (:event (let ((event (trace-event-print display vector))) (when event (format t "from ~d ~{ ~s~}" (byte-ref16 vector 2) event)))) (:reply (format t "To ~d length ~d" (byte-ref16 vector 2) length) (let ((actual-length (index+ 32 (index* 4 (byte-ref32 vector 4))))) (unless (= length actual-length) (format t " Should be ~d **************" actual-length))) (let ((*print-array* t) (*print-base* 16.)) (princ " ") (princ vector))) (otherwise (let* ((len (length vector)) (hist (make-reply-buffer len))) (buffer-replace (reply-ibuf8 hist) vector 0 len) (print-history-description hist))))))) ;; End of file ecl-16.1.2/src/clx/debug/util.lisp000066400000000000000000000133601266352375300166740ustar00rootroot00000000000000;;; -*- Mode:Lisp; Package:XLIB; Syntax:COMMON-LISP; Base:10; Lowercase:YES; -*- ;; CLX utilities ;;; ;;; TEXAS INSTRUMENTS INCORPORATED ;;; P.O. BOX 2909 ;;; AUSTIN, TEXAS 78769 ;;; ;;; Copyright (C) 1987 Texas Instruments Incorporated. ;;; ;;; Permission is granted to any individual or institution to use, copy, modify, ;;; and distribute this software, provided that this complete copyright and ;;; permission notice is maintained, intact, in all copies and supporting ;;; documentation. ;;; ;;; Texas Instruments Incorporated provides this software "as is" without ;;; express or implied warranty. ;;; ;;; Created 04/09/87 14:30:41 by LaMott G. OREN (in-package :xlib) (export '(display-root display-black display-white report-events describe-window describe-gc degree radian display-refresh root-tree window-tree)) (defun display-root (display) (screen-root (display-default-screen display))) (defun display-black (display) (screen-black-pixel (display-default-screen display))) (defun display-white (display) (screen-white-pixel (display-default-screen display))) (defun report-events (display) (loop (unless (process-event display :handler #'(lambda (&rest args) (print args)) :discard-p t :timeout 0.001) (return nil)))) (defun describe-window (window) (macrolet ((da (attribute &key (transform 'progn) (format "~s")) (let ((func (intern (concatenate 'string (string 'window-) (string attribute)) 'xlib))) `(format t "~%~22a ~?" ',attribute ,format (list (,transform (,func window)))))) (dg (attribute &key (transform 'progn) (format "~s")) (let ((func (intern (concatenate 'string (string 'drawable-) (string attribute)) 'xlib))) `(format t "~%~22a ~?" ',attribute ,format (list (,transform (,func window))))))) (with-state (window) (when (window-p window) (da visual :format "#x~x") (da class) (da gravity) (da bit-gravity) (da backing-store) (da backing-planes :format "#x~x") (da backing-pixel) (da save-under) (da colormap) (da colormap-installed-p) (da map-state) (da all-event-masks :transform make-event-keys :format "~{~<~%~1:;~s ~>~}") (da event-mask :transform make-event-keys :format "~{~<~%~1:;~s ~>~}") (da do-not-propagate-mask :transform make-event-keys :format "~{~<~%~1:;~s ~>~}") (da override-redirect) ) (dg root) (dg depth) (dg x) (dg y) (dg width) (dg height) (dg border-width) ))) (defun describe-gc (gc) (macrolet ((dgc (name &key (transform 'progn) (format "~s")) (let ((func (intern (concatenate 'string (string 'gcontext-) (string name)) 'xlib))) `(format t "~%~22a ~?" ',name ,format (list (,transform (,func gc))))))) (dgc function) (dgc plane-mask) (dgc foreground) (dgc background) (dgc line-width) (dgc line-style) (dgc cap-style) (dgc join-style) (dgc fill-style) (dgc fill-rule) (dgc tile) (dgc stipple) (dgc ts-x) (dgc ts-y) (dgc font) ;; See below (dgc subwindow-mode) (dgc exposures) (dgc clip-x) (dgc clip-y) ;; (dgc clip-ordering) (dgc clip-mask) (dgc dash-offset) (dgc dashes) (dgc arc-mode) )) (defun degree (degrees) (* degrees (/ pi 180))) (defun radian (radians) (round (* radians (/ 180 pi)))) (defun display-refresh (host) ;; Useful for when the system writes to the screen (sometimes scrolling!) (let ((display (open-display host))) (unwind-protect (let ((screen (display-default-screen display))) (let ((win (create-window :parent (screen-root screen) :x 0 :y 0 :override-redirect :on :width (screen-width screen) :height (screen-height screen) :background (screen-black-pixel screen)))) (map-window win) (display-finish-output display) (unmap-window win) (destroy-window win) (display-finish-output display))) (close-display display)))) (defun root-tree (host) (let ((display (open-display host))) (unwind-protect (window-tree (screen-root (display-default-screen display))) (close-display display))) (values)) (defun window-tree (window &optional (depth 0)) ;; Print the window tree and properties starting from WINDOW ;; Returns a list of windows in the order that they are printed. (declare (arglist window) (type window window) (values (list window))) (let ((props (mapcar #'(lambda (prop) (multiple-value-bind (data type format) (get-property window prop) (case type (:string (setq data (coerce data 'string)))) (list prop format type data))) (list-properties window))) (result (list window))) (with-state (window) (format t "~%~v@t#x~x~20,20t X~3d Y~3d W~4d H~3d ~s" depth (window-id window) (drawable-x window) (drawable-y window) (drawable-width window) (drawable-height window) (window-map-state window))) (dolist (prop props) (format t "~%~v@t~{~s ~}" (+ depth 2) prop)) (dolist (w (query-tree window)) (setq result (nconc result (window-tree w (+ depth 2))))) result)) ecl-16.1.2/src/clx/defsystem.lisp000066400000000000000000000516161266352375300166420ustar00rootroot00000000000000;;; -*- Mode: Lisp; Package: Xlib; Log: clx.log -*- ;;; ;;; TEXAS INSTRUMENTS INCORPORATED ;;; P.O. BOX 2909 ;;; AUSTIN, TEXAS 78769 ;;; ;;; Portions Copyright (C) 1987 Texas Instruments Incorporated. ;;; Portions Copyright (C) 1988, 1989 Franz Inc, Berkeley, Ca. ;;; ;;; Permission is granted to any individual or institution to use, copy, modify, ;;; and distribute this software, provided that this complete copyright and ;;; permission notice is maintained, intact, in all copies and supporting ;;; documentation. ;;; ;;; Texas Instruments Incorporated provides this software "as is" without ;;; express or implied warranty. ;;; ;;; Franz Incorporated provides this software "as is" without express or ;;; implied warranty. ;;; #+ features used in this file ;;; clx-ansi-common-lisp ;;; lispm ;;; genera ;;; minima ;;; lucid ;;; lcl3.0 ;;; apollo ;;; kcl ;;; ibcl ;;; excl ;;; CMU ;;; sbcl #+(or Genera Minima sbcl ecl) (eval-when (:compile-toplevel :load-toplevel :execute) (common-lisp:pushnew :clx-ansi-common-lisp common-lisp:*features*)) #+(and Genera clx-ansi-common-lisp) (eval-when (:compile-toplevel :load-toplevel :execute) (setf *readtable* si:*ansi-common-lisp-readtable*)) #-(or clx-ansi-common-lisp cmu) (lisp:in-package :user) #+cmu (lisp:in-package "XLIB") #+cmu (export 'load-clx) #+clx-ansi-common-lisp (common-lisp:in-package :common-lisp-user) ;;;; Lisp Machines #+(and lispm (not genera)) (global:defsystem CLX (:pathname-default "clx:clx;") (:patchable "clx:patch;" clx-ti) (:initial-status :experimental) (:module package "package") (:module depdefs "depdefs") (:module clx "clx") (:module dependent "dependent") (:module macros "macros") (:module bufmac "bufmac") (:module buffer "buffer") (:module display "display") (:module gcontext "gcontext") (:module requests "requests") (:module input "input") (:module fonts "fonts") (:module graphics "graphics") (:module text "text") (:module attributes "attributes") (:module translate "translate") (:module keysyms "keysyms") (:module manager "manager") (:module image "image") (:module resource "resource") (:module doc "doc") (:compile-load package) (:compile-load depdefs (:fasload package)) (:compile-load clx (:fasload package depdefs)) (:compile-load dependent (:fasload package depdefs clx)) ;; Macros only needed for compilation (:skip :compile-load macros (:fasload package depdefs clx dependent)) ;; Bufmac only needed for compilation (:skip :compile-load bufmac (:fasload package depdefs clx dependent macros)) (:compile-load buffer (:fasload package depdefs clx dependent macros bufmac)) (:compile-load display (:fasload package depdefs clx dependent macros bufmac buffer)) (:compile-load gcontext (:fasload package depdefs clx dependent macros bufmac buffer display)) (:compile-load input (:fasload package depdefs clx dependent macros bufmac buffer display)) (:compile-load requests (:fasload package depdefs clx dependent macros bufmac buffer display input)) (:compile-load fonts (:fasload package depdefs clx dependent macros bufmac buffer display)) (:compile-load graphics (:fasload package depdefs clx dependent macros fonts bufmac buffer display fonts)) (:compile-load text (:fasload package depdefs clx dependent macros fonts bufmac buffer display gcontext fonts)) (:compile-load-init attributes (dependent) (:fasload package depdefs clx dependent macros bufmac buffer display)) (:compile-load translate (:fasload package depdefs clx dependent macros bufmac buffer display)) (:compile-load keysyms (:fasload package depdefs clx dependent macros bufmac buffer display translate)) (:compile-load manager (:fasload package depdefs clx dependent macros bufmac buffer display)) (:compile-load image (:fasload package depdefs clx dependent macros bufmac buffer display)) (:compile-load resource (:fasload package depdefs clx dependent macros bufmac buffer display)) (:auxiliary doc) ) ;;; Symbolics Lisp Machines #+Genera (scl:defsystem CLX (:default-pathname "SYS:X11;CLX;" :pretty-name "CLX" :maintaining-sites (:scrc) :distribute-sources t :distribute-binaries t :source-category :basic) (:module doc ("doc") (:type :lisp-example)) (:serial "package" "depdefs" "generalock" "clx" "dependent" "macros" "bufmac" "buffer" "display" "gcontext" "input" "requests" "fonts" "graphics" "text" "attributes" "translate" "keysyms" "manager" "image" "resource")) #+Minima (zl:::scl:defsystem Minima-CLX (:default-pathname "SYS:X11;CLX;" :pretty-name "Minima CLX" :maintain-journals nil :maintaining-sites (:scrc) :distribute-sources t :distribute-binaries t :source-category :basic :default-module-type :minima-lisp) (:module doc ("doc") (:type :lisp-example)) (:serial "package" "depdefs" "clx" "dependent" "macros" "bufmac" "buffer" "display" "gcontext" "input" "requests" "fonts" "graphics" "text" "attributes" "translate" "keysyms" "manager" "image" "resource")) ;;; Franz ;; ;; The following is a suggestion. If you comment out this form be ;; prepared for possible deadlock, since no interrupts will be recognized ;; while reading from the X socket if the scheduler is not running. ;; #+excl (setq compiler::generate-interrupt-checks-switch (compile nil '(lambda (safety size speed &optional debug) (declare (ignore size debug)) (or (< speed 3) (> safety 0))))) ;;; Allegro #+allegro (excl:defsystem :clx () |package| (|excldep| :load-before-compile (|package|) :recompile-on (|package|)) (|depdefs| :load-before-compile (|package| |excldep|) :recompile-on (|excldep|)) (|clx| :load-before-compile (|package| |excldep| |depdefs|) :recompile-on (|package| |excldep| |depdefs|)) (|dependent| :load-before-compile (|package| |excldep| |depdefs| |clx|) :recompile-on (|clx|)) (|exclcmac| :load-before-compile (|package| |excldep| |depdefs| |clx| |dependent|) :recompile-on (|dependent|)) (|macros| :load-before-compile (|package| |excldep| |depdefs| |clx| |dependent| |exclcmac|) :recompile-on (|exclcmac|)) (|bufmac| :load-before-compile (|package| |excldep| |depdefs| |clx| |dependent| |exclcmac| |macros|) :recompile-on (|macros|)) (|buffer| :load-before-compile (|package| |excldep| |depdefs| |clx| |dependent| |exclcmac| |macros| |bufmac|) :recompile-on (|bufmac|)) (|display| :load-before-compile (|package| |excldep| |depdefs| |clx| |dependent| |exclcmac| |macros| |bufmac| |buffer|) :recompile-on (|buffer|)) (|gcontext| :load-before-compile (|package| |excldep| |depdefs| |clx| |dependent| |exclcmac| |macros| |bufmac| |buffer| |display|) :recompile-on (|display|)) (|input| :load-before-compile (|package| |excldep| |depdefs| |clx| |dependent| |exclcmac| |macros| |bufmac| |buffer| |display|) :recompile-on (|display|)) (|requests| :load-before-compile (|package| |excldep| |depdefs| |clx| |dependent| |exclcmac| |macros| |bufmac| |buffer| |display| |input|) :recompile-on (|display|)) (|fonts| :load-before-compile (|package| |excldep| |depdefs| |clx| |dependent| |exclcmac| |macros| |bufmac| |buffer| |display|) :recompile-on (|display|)) (|graphics| :load-before-compile (|package| |excldep| |depdefs| |clx| |dependent| |exclcmac| |macros| |bufmac| |buffer| |display| |fonts|) :recompile-on (|fonts|)) (|text| :load-before-compile (|package| |excldep| |depdefs| |clx| |dependent| |exclcmac| |macros| |bufmac| |buffer| |display| |gcontext| |fonts|) :recompile-on (|gcontext| |fonts|) :load-after (|translate|)) ;; The above line gets around a compiler macro expansion bug. (|attributes| :load-before-compile (|package| |excldep| |depdefs| |clx| |dependent| |exclcmac| |macros| |bufmac| |buffer| |display|) :recompile-on (|display|)) (|translate| :load-before-compile (|package| |excldep| |depdefs| |clx| |dependent| |exclcmac| |macros| |bufmac| |buffer| |display| |text|) :recompile-on (|display|)) (|keysyms| :load-before-compile (|package| |excldep| |depdefs| |clx| |dependent| |exclcmac| |macros| |bufmac| |buffer| |display| |translate|) :recompile-on (|translate|)) (|manager| :load-before-compile (|package| |excldep| |depdefs| |clx| |dependent| |exclcmac| |macros| |bufmac| |buffer| |display|) :recompile-on (|display|)) (|image| :load-before-compile (|package| |excldep| |depdefs| |clx| |dependent| |exclcmac| |macros| |bufmac| |buffer| |display|) :recompile-on (|display|)) ;; Don't know if l-b-c list is correct. XX (|resource| :load-before-compile (|package| |excldep| |depdefs| |clx| |dependent| |exclcmac| |macros| |bufmac| |buffer| |display|) :recompile-on (|display|)) ) #+allegro (excl:defsystem :clx-debug (:default-pathname "debug/" :needed-systems (:clx) :load-before-compile (:clx)) |describe| |keytrans| |trace| |util|) ;;;; Compile CLX ;;; COMPILE-CLX compiles the lisp source files and loads the binaries. ;;; It goes to some trouble to let the source files be in one directory ;;; and the binary files in another. Thus the same set of sources can ;;; be used for different machines and/or lisp systems. It also allows ;;; you to supply explicit extensions, so source files do not have to ;;; be renamed to fit into the naming conventions of an implementation. ;;; For example, ;;; (compile-clx "*.lisp" "machine/") ;;; compiles source files from the connected directory and puts them ;;; into the "machine" subdirectory. You can then load CLX out of the ;;; machine directory. ;;; The code has no knowledge of the source file types (eg, ".l" or ;;; ".lisp") or of the binary file types (eg, ".b" or ".sbin"). Calling ;;; compile-file and load with a file type of NIL usually sorts things ;;; out correctly, but you may have to explicitly give the source and ;;; binary file types. ;;; An attempt at compiling the C language sources is also made, ;;; but you may have to set different compiler switches ;;; should be. If it doesn't do the right thing, then do ;;; (compile-clx "" "" :compile-c NIL) ;;; to prevent the compilation. ;;; compilation notes ;;; lucid2.0/hp9000s300 ;;; must uudecode the file make-sequence-patch.uu #+(or lucid kcl ibcl cmu) (defun clx-foreign-files (binary-path) #+(and lucid (not lcl3.0) (or mc68000 mc68020)) (load (merge-pathnames "make-sequence-patch" binary-path)) #+(and lucid apollo) (lucid::load-foreign-file (namestring (merge-pathnames "socket" binary-path)) :preserve-pathname t) #+(and lucid (not apollo)) (lucid::load-foreign-files (list (namestring (merge-pathnames "socket.o" binary-path))) '("-lc")) #+cmu (declare (ignore binary-path)) #+(or cmu sbcl) (alien:def-alien-routine ("connect_to_server" xlib::connect-to-server) c-call:int (host c-call:c-string) (port c-call:int)) #+(or kcl ibcl) (progn (let ((pathname (merge-pathnames "sockcl.o" binary-path)) (options (concatenate 'string (namestring (merge-pathnames "socket.o" binary-path)) " -lc"))) (format t "~&Faslinking ~A with ~A.~%" pathname options) (si:faslink (namestring pathname) options) (format t "~&Finished faslinking ~A.~%" pathname))) ) #-(or lispm allegro Minima) (defun compile-clx (&optional (source-pathname-defaults "") (binary-pathname-defaults "") &key (compile-c t)) ;; The pathname-defaults above might only be strings, so coerce them ;; to pathnames. Build a default binary path with every component ;; of the source except the file type. This should prevent ;; (compile-clx "*.lisp") from destroying source files. (let* ((source-path (pathname source-pathname-defaults)) (path (make-pathname :host (pathname-host source-path) :device (pathname-device source-path) :directory (pathname-directory source-path) :name (pathname-name source-path) :type nil :version (pathname-version source-path))) (binary-path (merge-pathnames binary-pathname-defaults path)) #+clx-ansi-common-lisp (*compile-verbose* t) (*load-verbose* t)) ;; Make sure source-path and binary-path file types are distinct so ;; we don't accidently overwrite the source files. NIL should be an ;; ok type, but anything else spells trouble. (if (and (equal (pathname-type source-path) (pathname-type binary-path)) (not (null (pathname-type binary-path)))) (error "Source and binary pathname defaults have same type ~s ~s" source-path binary-path)) (format t "~&;;; Default paths: ~s ~s~%" source-path binary-path) ;; In lucid make sure we're using the compiler in production mode. #+lcl3.0 (progn (unless (member :pqc *features*) (cerror "Go ahead anyway." "Lucid's production mode compiler must be loaded to compile CLX.")) (proclaim '(optimize (speed 3) (safety 1) (space 0) (compilation-speed 0)))) (labels ((compile-lisp (filename) (let ((source (merge-pathnames filename source-path)) (binary (merge-pathnames filename binary-path))) ;; If the source and binary pathnames are the same, ;; then don't supply an output file just to be sure ;; compile-file defaults correctly. #+(or kcl ibcl) (load source) (if (equal source binary) (compile-file source) (compile-file source :output-file binary)) binary)) (compile-and-load (filename) (load (compile-lisp filename))) #+(or lucid kcl ibcl) (compile-c (filename) (let* ((c-filename (concatenate 'string filename ".c")) (o-filename (concatenate 'string filename ".o")) (src (merge-pathnames c-filename source-path)) (obj (merge-pathnames o-filename binary-path)) (args (list "-c" (namestring src) "-o" (namestring obj) #+mips "-G 0" #+(or hp sysv) "-DSYSV" #+(and mips (not dec)) "-I/usr/include/bsd" #-(and mips (not dec)) "-DUNIXCONN" #+(and lucid pa) "-DHPUX -DHPUX7.0" ))) (format t ";;; cc~{ ~A~}~%" args) (unless (zerop #+lucid (multiple-value-bind (iostream estream exitstatus pid) ;; in 2.0, run-program is exported from system: ;; in 3.0, run-program is exported from lcl: ;; system inheirits lcl (system::run-program "cc" :arguments args) (declare (ignore iostream estream pid)) exitstatus) #+(or kcl ibcl) (system (format nil "cc~{ ~A~}" args))) (error "Compile of ~A failed." src))))) ;; Now compile and load all the files. ;; Defer compiler warnings until everything's compiled, if possible. (#+(or clx-ansi-common-lisp CMU) with-compilation-unit #+lcl3.0 lucid::with-deferred-warnings #-(or lcl3.0 clx-ansi-common-lisp CMU) progn () (compile-and-load "package") #+(or lucid kcl ibcl) (when compile-c (compile-c "socket")) #+(or kcl ibcl) (compile-lisp "sockcl") #+(or lucid kcl ibcl) (clx-foreign-files binary-path) #+excl (compile-and-load "excldep") (compile-and-load "depdefs") (compile-and-load "clx") (compile-and-load "dependent") #+excl (compile-and-load "exclcmac") ; these are just macros (compile-and-load "macros") ; these are just macros (compile-and-load "bufmac") ; these are just macros (compile-and-load "buffer") (compile-and-load "display") (compile-and-load "gcontext") (compile-and-load "input") (compile-and-load "requests") (compile-and-load "fonts") (compile-and-load "graphics") (compile-and-load "text") (compile-and-load "attributes") (compile-and-load "translate") (compile-and-load "keysyms") (compile-and-load "manager") (compile-and-load "image") (compile-and-load "resource") )))) ;;;; Load CLX ;;; This procedure loads the binaries for CLX. All of the binaries ;;; should be in the same directory, so setting the default pathname ;;; should point load to the right place. ;;; You should have a module definition somewhere so the require/provide ;;; mechanism can avoid reloading CLX. In an ideal world, somebody would ;;; just put ;;; (REQUIRE 'CLX) ;;; in their file (some implementations don't have a central registry for ;;; modules, so a pathname needs to be supplied). ;;; The REQUIRE should find a file that does ;;; (IN-PACKAGE 'XLIB :USE '(LISP)) ;;; (PROVIDE 'CLX) ;;; (LOAD ) ;;; (LOAD-CLX ) #-(or lispm allegro Minima) (defun load-clx (&optional (binary-pathname-defaults "") &key (macrosp nil)) (let* ((source-path (pathname "")) (path (make-pathname :host (pathname-host source-path) :device (pathname-device source-path) :directory (pathname-directory source-path) :name (pathname-name source-path) :type nil :version (pathname-version source-path))) (binary-path (merge-pathnames binary-pathname-defaults path)) (*load-verbose* t)) (flet ((load-binary (filename) (let ((binary (merge-pathnames filename binary-path))) (load binary)))) (load-binary "package") #+(or lucid kcl ibcl cmu) (clx-foreign-files binary-path) #+excl (load-binary "excldep") (load-binary "depdefs") (load-binary "clx") (load-binary "dependent") (when macrosp #+excl (load-binary "exclcmac") (load-binary "macros") (load-binary "bufmac")) (load-binary "buffer") (load-binary "display") (load-binary "gcontext") (load-binary "input") (load-binary "requests") (load-binary "fonts") (load-binary "graphics") (load-binary "text") (load-binary "attributes") (load-binary "translate") (load-binary "keysyms") (load-binary "manager") (load-binary "image") (load-binary "resource") ))) ;;; ;;; ECL likes to combine several files into a single dynamically loadable ;;; library. ;;; #+ecl (defconstant +clx-modules+ '("package" "depdefs" "clx" "dependent" "macros" "bufmac" "buffer" "display" "gcontext" "input" "requests" "fonts" "graphics" "text" "attributes" "translate" "keysyms" "manager" "image" "resource")) #+(or) ;ecl (flet ((compile-if-old (destdir sources &rest options) (mapcar #'(lambda (source) (let ((object (merge-pathnames destdir (compile-file-pathname source :type :object)))) (unless (and (probe-file object) (>= (file-write-date object) (file-write-date source))) (apply #'compile-file source :output-file object options)) object)) sources))) (let ((clx-objects (compile-if-old "./" +clx-modules+ :system-p t))) (c::build-fasl "clx" :lisp-files clx-objects))) (mapcar #'load +clx-modules+) ecl-16.1.2/src/clx/demo/000077500000000000000000000000001266352375300146615ustar00rootroot00000000000000ecl-16.1.2/src/clx/demo/.cvsignore000066400000000000000000000000071266352375300166560ustar00rootroot00000000000000*.fasl ecl-16.1.2/src/clx/demo/bezier.lisp000066400000000000000000000025401266352375300170330ustar00rootroot00000000000000;;; -*- Mode:Lisp; Package:XLIB; Syntax:COMMON-LISP; Base:10; Lowercase:T -*- ;;; CLX interface for Bezier Spline Extension. ;;; ;;; TEXAS INSTRUMENTS INCORPORATED ;;; P.O. BOX 2909 ;;; AUSTIN, TEXAS 78769 ;;; ;;; Copyright (C) 1987 Texas Instruments Incorporated. ;;; ;;; Permission is granted to any individual or institution to use, copy, modify, ;;; and distribute this software, provided that this complete copyright and ;;; permission notice is maintained, intact, in all copies and supporting ;;; documentation. ;;; ;;; Texas Instruments Incorporated provides this software "as is" without ;;; express or implied warranty. ;;; (in-package :xlib) (export 'draw-curves) (define-extension "bezier") (defun draw-curves (drawable gcontext points) ;; Draw Bezier splines on drawable using gcontext. ;; Points are a list of (x0 y0 x1 y1 x2 y2 x3 y3) (declare (type drawable drawable) (type gcontext gcontext) (type sequence points)) (let* ((display (drawable-display drawable)) (opcode (extension-opcode display "bezier"))) (with-buffer-request (display opcode :gc-force gcontext) ((data card8) 1) ;; X_PolyBezier - The minor_opcode for PolyBezier (drawable drawable) (gcontext gcontext) ((sequence :format int16) points)))) ecl-16.1.2/src/clx/demo/beziertest.lisp000066400000000000000000000063111266352375300177330ustar00rootroot00000000000000;;; -*- Mode:Lisp; Package:XLIB; Syntax:COMMON-LISP; Base:10; Lowercase:T -*- ;;; CLX Bezier Spline Extension demo program ;;; ;;; TEXAS INSTRUMENTS INCORPORATED ;;; P.O. BOX 2909 ;;; AUSTIN, TEXAS 78769 ;;; ;;; Copyright (C) 1987 Texas Instruments Incorporated. ;;; ;;; Permission is granted to any individual or institution to use, copy, modify, ;;; and distribute this software, provided that this complete copyright and ;;; permission notice is maintained, intact, in all copies and supporting ;;; documentation. ;;; ;;; Texas Instruments Incorporated provides this software "as is" without ;;; express or implied warranty. ;;; (in-package :xlib) (defun bezier-test (host &optional (pathname "/usr/X.V11R1/extensions/test/datafile")) ;; Display the part picture in /extensions/test/datafile (let* ((display (open-display host)) (width 800) (height 800) (screen (display-default-screen display)) (black (screen-black-pixel screen)) (white (screen-white-pixel screen)) (win (create-window :parent (screen-root screen) :background black :border white :border-width 1 :colormap (screen-default-colormap screen) :bit-gravity :center :event-mask '(:exposure :key-press) :x 20 :y 20 :width width :height height)) (gc (create-gcontext :drawable win :background black :foreground white)) (lines (make-array (* 500 4) :fill-pointer 0 :element-type 'card16)) (curves (make-array (* 500 8) :fill-pointer 0 :element-type 'card16))) ;; Read the data (with-open-file (stream pathname) (loop (case (read-char stream nil :eof) (#\l (dotimes (i 4) (vector-push-extend (read stream) lines))) (#\b (dotimes (i 8) (vector-push-extend (read stream) curves))) ((#\space #\newline #\tab)) (otherwise (return))))) ;; The data points were created to fit in a 2048x2048 square, ;; this means scale_factor will always be small enough so that ;; we don't need to worry about overflows. (let ((factor (ash (min width height) 5))) (dotimes (i (length lines)) (setf (aref lines i) (ash (* (aref lines i) factor) -16))) (dotimes (i (length curves)) (setf (aref curves i) (ash (* (aref curves i) factor) -16)))) (map-window win) ; Map the window ;; Handle events (unwind-protect (loop (event-case (display :force-output-p t) (exposure ;; Come here on exposure events (window count) (when (zerop count) ;; Ignore all but the last exposure event (clear-area window) (draw-segments win gc lines) (draw-curves win gc curves) (draw-glyphs win gc 10 10 "Press any key to exit") ;; Returning non-nil causes event-case to exit t)) (key-press () (return-from bezier-test t)))) (close-display display)))) ecl-16.1.2/src/clx/demo/clclock.lisp000066400000000000000000000053121266352375300171650ustar00rootroot00000000000000(defpackage "XCLCLOCK" (:use "CL") (:export "CLOCK")) (in-package "XCLCLOCK") (defvar *display* (xlib:open-default-display)) (defvar *screen* (xlib:display-default-screen *display*)) (defvar *colormap* (xlib:screen-default-colormap *screen*)) (defvar *font* (xlib:open-font *display* "fixed")) (defvar *win*) (multiple-value-bind (width ascent) (xlib:text-extents *font* "XVIIII XXXVIIII XXXVIIII") (setq *win* (xlib:create-window :parent (xlib:screen-root *screen*) :x 512 :y 512 :width (+ 20 width) :height (+ 20 ascent) :background (xlib:alloc-color *colormap* (xlib:lookup-color *colormap* "midnightblue"))))) (defvar *gcontext* (xlib:create-gcontext :drawable *win* :fill-style :solid :background (xlib:screen-white-pixel *screen*) :foreground (xlib:alloc-color *colormap* (xlib:lookup-color *colormap* "yellow")) :font *font*)) (defvar *background* (xlib:create-gcontext :drawable *win* :fill-style :solid :background (xlib:screen-white-pixel *screen*) :foreground (xlib:alloc-color *colormap* (xlib:lookup-color *colormap* "midnightblue")) :font *font*)) (defvar *palette* nil) (defvar *black* (xlib:screen-black-pixel *screen*)) (defun romanize (arg) (if (zerop arg) "O" (format nil "~@R" arg))) (defun clock-string () (multiple-value-bind (s m h) (decode-universal-time (get-universal-time)) (format nil "~a ~a ~a" (romanize h) (romanize m) (romanize s)))) (defun update-clockface () (let ((string (clock-string))) (let ((string-width (xlib:text-width *gcontext* string))) (xlib:draw-rectangle *win* *background* 0 0 (xlib:drawable-width *win*) (xlib:drawable-height *win*) :fill-p) (xlib:draw-glyphs *win* *gcontext* (- (truncate (- (xlib:drawable-width *win*) string-width) 2) 10) (- (xlib:drawable-height *win*) 10) string))) (xlib:display-force-output *display*)) (defun clock () (xlib:map-window *win*) (loop (update-clockface) (sleep 1))) ecl-16.1.2/src/clx/demo/clipboard.lisp000066400000000000000000000215751266352375300175230ustar00rootroot00000000000000;;; This is a pretty direct translation of the Xlib selection test ;;; program by Tor Andersson found at ;;; , with ;;; minor enhancements: ;;; ;;; * gdk requestors apparently unconditionally request UTF8_STRING ;;; selections without checking the TARGETS list of the selection ;;; owner -- and apparently even never request anything else. This ;;; seems to be in contradiction with the freedesktop.org draft ;;; specification at ;;; ;;; (linked from ), but this is ;;; the real world and we have to live in it. It would be nice if ;;; someone in the freedesktop community could resolve this. ;;; ;;; * the original C code, in the XSendEvent call, has an event mask ;;; of SelectionNotify. SelectionNotify is not an event mask at ;;; all, however: but the code works "by accident" because ;;; SelectionNotify happens to have value 31, which has enough bits ;;; flipped on that most clients select on at least one of those ;;; events. This bug is fixed below. ;;; ;;; * [ Update 2004-11-29, superseding to some extent the above ] in ;;; fact, these two things are related. ICCCM says that the event ;;; disclaiming the ability to send in a given format should be sent ;;; with an empty event mask ("2.2 Responsibilities of the Selection ;;; Owner"). ;;; ;;; * implemented the ICCCM-required TIMESTAMP and MULTIPLE targets ;;; ;;; As ever with these things, the divisions in intellectual property ;;; between the writer of the original C program, Tor Andersson ;;; (contactable at tor [dot] andersson [at] gmail [dot] com) and the ;;; translator (Christophe Rhodes, csr21 [at] cam [dot] ac [dot] uk) ;;; are murky, probably depend on jurisdiction, and in addition for ;;; such a small work are essentially trivial. To set peoples' minds ;;; at ease, Tor wishes this information to be disseminated as widely ;;; as possible. ;;; Copyright (c) 2004, Christophe Rhodes ;;; ;;; Permission is hereby granted, free of charge, to any person ;;; obtaining a copy of this software and associated documentation ;;; files (the "Software"), to deal in the Software without ;;; restriction, including without limitation the rights to use, copy, ;;; modify, merge, publish, distribute, sublicense, and/or sell copies ;;; of the Software, and to permit persons to whom the Software is ;;; furnished to do so, subject to the following conditions: ;;; ;;; The above copyright notice and this permission notice shall be ;;; included in all copies or substantial portions of the Software. ;;; ;;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, ;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ;;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND ;;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT ;;; HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, ;;; WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, ;;; OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER ;;; DEALINGS IN THE SOFTWARE. (defpackage "CLIPBOARD" (:use "CL" "XLIB") (:export "MAIN")) (in-package "CLIPBOARD") ;;; This is "traditional" XLIB style; I don't really know if it's the ;;; best way -- in developing this program, style of XLIB programming ;;; was secondary to achieving First Paste. (defvar *window*) (defvar *time*) (defvar *display*) (defun ownselect () (format t "~&> set-selection-owner~%") (finish-output) (set-selection-owner *display* :primary *window* *time*) (unless (eq *window* (selection-owner *display* :primary)) (write-string "failed to own primary"))) (defun deselect () (format t "~&> unset-selection-owner~%") (finish-output) (set-selection-owner *display* :primary nil *time*) (unless (eq nil (selection-owner *display* :primary)) (write-string "failed to disown primary"))) (defun ask-paste () (format t "~&! deleting properties on window~%") (finish-output) (delete-property *window* :aeclip-target) (delete-property *window* :aeclip-string) (delete-property *window* :aeclip-utf8_string) (delete-property *window* :aeclip-text) (format t "~&> convert-selection TARGETS~%") (finish-output) (convert-selection :primary :targets *window* :aeclip-target) (format t "~&> convert-selection STRING~%") (finish-output) (convert-selection :primary :string *window* :aeclip-string) (format t "~&> convert-selection UTF8_STRING~%") (finish-output) (convert-selection :primary :utf8_string *window* :aeclip-utf8_string) (format t "~&> convert-selection TEXT~%") (finish-output) (convert-selection :primary :text *window* :aeclip-text) nil) (defun recv-paste (property) (multiple-value-bind (data name format) (get-property *window* property) (format t "~&< get-prop ~S " name) (case format (32 (format t "[~{~S~^,~}]" (mapcar (lambda (x) (atom-name *display* x)) data))) (8 (format t "~S" (map 'string 'code-char data))) (t (format t "format=~S data=~S" format data))) (format t "~%") (finish-output) (delete-property *window* property))) (defun send-copy (selection target property requestor time) (flet ((send (target property) (case target ((:string) (format t "~&> sending text data~%") (finish-output) (change-property requestor property "Hello, World (from the CLX clipboard)!" target 8 :transform #'char-code) property) (:targets (format t "~&> sending targets list~%") (finish-output) ;; ARGH. Can't use :TRANSFORM as we scribble over CLX's buffer. (let ((targets (mapcar (lambda (x) (intern-atom *display* x)) '(:targets :timestamp :multiple :string)))) (change-property requestor property targets target 32)) property) (:timestamp (format t "~&> sending timestamp~%") (finish-output) (change-property requestor property (list *time*) target 32) property) (t (format t "~&> sending none~%") (finish-output) nil)))) (case target ;; WARNING: this is untested. I don't know of any clients which ;; use the :MULTIPLE target. (:multiple (let* ((list (get-property requestor property)) (plist (mapcar (lambda (x) (atom-name *display* x)) list))) (loop for (ptarget pproperty) on plist by #'cddr with all-succeeded = t if (send ptarget pproperty) collect ptarget into result and collect pproperty into result else collect nil into result and collect pproperty into result and do (setf all-succeeded nil) finally (unless all-succeeded (let ((new-list (mapcar (lambda (x) (intern-atom *display* x)) result))) (change-property requestor property new-list target 32)))))) (t (setf property (send target property)))) (send-event requestor :selection-notify (make-event-mask) :selection selection :target target :property property :time time :event-window requestor :window requestor))) (defun main () (let* ((*display* (open-default-display)) (screen (display-default-screen *display*)) (*window* (create-window :parent (screen-root screen) :x 10 :y 10 :width 200 :height 200 :event-mask (make-event-mask :button-press :property-change)))) (map-window *window*) (display-finish-output *display*) (event-case (*display*) (:button-press (code time) (format t "~&ButtonPress~%") (finish-output) (case code (1 (setf *time* time) (ownselect)) (2 (ask-paste)) (3 (deselect)))) (:client-message () (format t "~&ClientMessage~%") (finish-output)) (:selection-clear (selection) (format t "~&SelectionClear ~S~%" selection) (finish-output)) (:selection-notify (selection target property) (format t "~&SelectionNotify ~S ~S ~S~%" selection target property) (finish-output) (unless (eq property nil) (recv-paste property)) (display-finish-output *display*)) (:selection-request (selection target property requestor time) (format t "~&SelectionRequest ~S ~S ~S~%" selection target property) (finish-output) (send-copy selection target property requestor time) (display-finish-output *display*)) (:property-notify (atom state) (format t "~&PropertyNotify ~S ~S~%" atom state) (finish-output))))) ecl-16.1.2/src/clx/demo/clx-demos.lisp000066400000000000000000001173101266352375300174500ustar00rootroot00000000000000;;; -*- Mode: Lisp; Package: Demos -*- ;;; ;;; This file contains various graphics hacks written and ported over the ;;; years by various and numerous persons. ;;; ;;; This file should be portable to any valid Common Lisp with CLX -- DEC 88. ;;; (defpackage :demos (:use :common-lisp) (:export do-all-demos demo)) (in-package :demos) ;;;; Graphic demos wrapper macro. ;;; This wrapper macro should be reconsidered with respect to its property ;;; list usage. Possibly a demo structure should be used with *demos* ;;; pointing to these instead of function names. Also, something should ;;; be done about a title window that displays the name of the demo while ;;; it is running. (defparameter *demos* nil) (defvar *display* nil) (defvar *screen* nil) (defvar *root* nil) (defvar *black-pixel* nil) (defvar *white-pixel* nil) (defvar *window* nil) (defmacro defdemo (fun-name demo-name args x y width height doc &rest forms) `(progn (defun ,fun-name ,args ,doc (unless *display* #+:cmu (multiple-value-setq (*display* *screen*) (ext:open-clx-display)) #+(or sbcl allegro clisp) (progn (setf *display* (xlib::open-default-display)) (setf *screen* (xlib:display-default-screen *display*))) #-(or cmu sbcl allegro clisp) (progn ;; Portable method (setf *display* (xlib:open-display (machine-instance))) (setf *screen* (xlib:display-default-screen *display*))) (setf *root* (xlib:screen-root *screen*)) (setf *black-pixel* (xlib:screen-black-pixel *screen*)) (setf *white-pixel* (xlib:screen-white-pixel *screen*))) (let ((*window* (xlib:create-window :parent *root* :x ,x :y ,y :event-mask nil :width ,width :height ,height :background *white-pixel* :border *black-pixel* :border-width 2 :override-redirect :on))) (xlib:map-window *window*) ;; ;; I hate to do this since this is not something any normal ;; program should do ... (setf (xlib:window-priority *window*) :above) (xlib:display-finish-output *display*) (unwind-protect (progn ,@forms) (xlib:unmap-window *window*) (xlib:display-finish-output *display*)))) (setf (get ',fun-name 'demo-name) ',demo-name) (setf (get ',fun-name 'demo-doc) ',doc) (export ',fun-name) (pushnew ',fun-name *demos*) ',fun-name)) ;;;; Main entry points. (defun do-all-demos () (loop (dolist (demo *demos*) (funcall demo) (sleep 3)))) ;;; DEMO is a hack to get by. It should be based on creating a menu. At ;;; that time, *name-to-function* should be deleted, since this mapping will ;;; be manifested in the menu slot name cross its action. Also the ;;; "Shove-bounce" demo should be renamed to "Shove bounce"; likewise for ;;; "Fast-towers-of-Hanoi" and "Slow-towers-of-hanoi". ;;; (defvar *name-to-function* (make-hash-table :test #'eq)) (defvar *keyword-package* (find-package "KEYWORD")) (defun demo () (macrolet ((read-demo () `(let ((*package* *keyword-package*)) (read)))) (dolist (d *demos*) (setf (gethash (intern (string-upcase (get d 'demo-name)) *keyword-package*) *name-to-function*) d)) (loop (fresh-line) (dolist (d *demos*) (write-string " ") (write-line (get d 'demo-name))) (write-string " ") (write-line "Help ") (write-string " ") (write-line "Quit") (write-string "Enter demo name: ") (let ((demo (read-demo))) (case demo (:help (let* ((demo (read-demo)) (fun (gethash demo *name-to-function*))) (fresh-line) (if fun (format t "~&~%~A~&~%" (get fun 'demo-doc)) (format t "Unknown demo name -- ~A." demo)))) (:quit (return t)) (t (let ((fun (gethash demo *name-to-function*))) (if fun #+mp (mp:make-process #'(lambda () (loop (funcall fun) (sleep 2))) :name (format nil "~S" demo)) #-mp (funcall fun) (format t "~&~%Unknown demo name -- ~A.~&~%" demo))))))))) ;;;; Shared demo utilities. (defun full-window-state (w) (xlib:with-state (w) (values (xlib:drawable-width w) (xlib:drawable-height w) (xlib:drawable-x w) (xlib:drawable-y w) (xlib:window-map-state w)))) ;;;; Greynetic. ;;; GREYNETIC displays random sized and shaded boxes in a window. This is ;;; real slow. It needs work. ;;; (defun greynetic (window duration) (let* ((pixmap (xlib:create-pixmap :width 32 :height 32 :depth 1 :drawable window)) (gcontext (xlib:create-gcontext :drawable window :background *white-pixel* :foreground *black-pixel* :tile pixmap :fill-style :tiled))) (multiple-value-bind (width height) (full-window-state window) (dotimes (i duration) (let* ((pixmap-data (greynetic-pixmapper)) (image (xlib:create-image :width 32 :height 32 :depth 1 :data pixmap-data))) (xlib:put-image pixmap gcontext image :x 0 :y 0 :width 32 :height 32) (xlib:draw-rectangle window gcontext (- (random width) 5) (- (random height) 5) (+ 4 (random (truncate width 3))) (+ 4 (random (truncate height 3))) t)) (xlib:display-force-output *display*))) (xlib:free-gcontext gcontext) (xlib:free-pixmap pixmap))) (defvar *greynetic-pixmap-array* (make-array '(32 32) :initial-element 0 :element-type 'xlib:pixel)) (defun greynetic-pixmapper () (let ((pixmap-data *greynetic-pixmap-array*)) (dotimes (i 4) (declare (fixnum i)) (let ((nibble (random 16))) (setf nibble (logior nibble (ash nibble 4)) nibble (logior nibble (ash nibble 8)) nibble (logior nibble (ash nibble 12)) nibble (logior nibble (ash nibble 16))) (dotimes (j 32) (let ((bit (if (logbitp j nibble) 1 0))) (setf (aref pixmap-data i j) bit (aref pixmap-data (+ 4 i) j) bit (aref pixmap-data (+ 8 i) j) bit (aref pixmap-data (+ 12 i) j) bit (aref pixmap-data (+ 16 i) j) bit (aref pixmap-data (+ 20 i) j) bit (aref pixmap-data (+ 24 i) j) bit (aref pixmap-data (+ 28 i) j) bit))))) pixmap-data)) #+nil (defdemo greynetic-demo "Greynetic" (&optional (duration 300)) 100 100 600 600 "Displays random grey rectangles." (greynetic *window* duration)) ;;;; Qix. (defstruct qix buffer (dx1 5) (dy1 10) (dx2 10) (dy2 5)) (defun construct-qix (length) (let ((qix (make-qix))) (setf (qix-buffer qix) (make-circular-list length)) qix)) (defun make-circular-list (length) (let ((l (make-list length))) (rplacd (last l) l))) (defun qix (window lengths duration) "Each length is the number of lines to put in a qix, and that many qix (of the correct size) are put up on the screen. Lets the qix wander around the screen for Duration steps." (let ((histories (mapcar #'construct-qix lengths))) (multiple-value-bind (width height) (full-window-state window) (declare (fixnum width height)) (xlib:clear-area window) (xlib:display-force-output *display*) (do ((h histories (cdr h)) (l lengths (cdr l))) ((null h)) (do ((x (qix-buffer (car h)) (cdr x)) (i 0 (1+ i))) ((= i (car l))) (rplaca x (make-array 4)))) ;; Start each qix at a random spot on the screen. (dolist (h histories) (let ((x (random width)) (y (random height))) (rplaca (qix-buffer h) (make-array 4 :initial-contents (list x y x y))))) (rplacd (last histories) histories) (let ((x1 0) (y1 0) (x2 0) (y2 0) (dx1 0) (dy1 0) (dx2 0) (dy2 0) tem line next-line qix (gc (xlib:create-gcontext :drawable window :foreground *white-pixel* :background *black-pixel* :line-width 0 :line-style :solid :function boole-c2))) (declare (fixnum x1 y1 x2 y2 dx1 dy1 dx2 dy2)) (dotimes (i duration) ;; Line is the next line in the next qix. Rotate this qix and ;; the qix ring. (setq qix (car histories)) (setq line (car (qix-buffer qix))) (setq next-line (cadr (qix-buffer qix))) (setf (qix-buffer qix) (cdr (qix-buffer qix))) (setq histories (cdr histories)) (setf x1 (svref line 0)) (setf y1 (svref line 1)) (setf x2 (svref line 2)) (setf y2 (svref line 3)) (xlib:draw-line window gc x1 y1 x2 y2) (setq dx1 (- (+ (qix-dx1 qix) (random 3)) 1)) (setq dy1 (- (+ (qix-dy1 qix) (random 3)) 1)) (setq dx2 (- (+ (qix-dx2 qix) (random 3)) 1)) (setq dy2 (- (+ (qix-dy2 qix) (random 3)) 1)) (cond ((> dx1 10) (setq dx1 10)) ((< dx1 -10) (setq dx1 -10))) (cond ((> dy1 10) (setq dy1 10)) ((< dy1 -10) (setq dy1 -10))) (cond ((> dx2 10) (setq dx2 10)) ((< dx2 -10) (setq dx2 -10))) (cond ((> dy2 10) (setq dy2 10)) ((< dy2 -10) (setq dy2 -10))) (cond ((or (>= (setq tem (+ x1 dx1)) width) (minusp tem)) (setq dx1 (- dx1)))) (cond ((or (>= (setq tem (+ x2 dx2)) width) (minusp tem)) (setq dx2 (- dx2)))) (cond ((or (>= (setq tem (+ y1 dy1)) height) (minusp tem)) (setq dy1 (- dy1)))) (cond ((or (>= (setq tem (+ y2 dy2)) height) (minusp tem)) (setq dy2 (- dy2)))) (setf (qix-dy2 qix) dy2) (setf (qix-dx2 qix) dx2) (setf (qix-dy1 qix) dy1) (setf (qix-dx1 qix) dx1) ` (when (svref next-line 0) (xlib:draw-line window gc (svref next-line 0) (svref next-line 1) (svref next-line 2) (svref next-line 3))) (setf (svref next-line 0) (+ x1 dx1)) (setf (svref next-line 1) (+ y1 dy1)) (setf (svref next-line 2) (+ x2 dx2)) (setf (svref next-line 3) (+ y2 dy2)) (xlib:display-force-output *display*)))))) (defdemo qix-demo "Qix" (&optional (lengths '(30 30)) (duration 2000)) 0 0 700 700 "Hypnotic wandering lines." (qix *window* lengths duration)) ;;;; Petal. ;;; Fast sine constants: (defconstant d360 #o5500) (defconstant d270 #o4160) (defconstant d180 #o2640) (defconstant d90 #o1320) (defconstant vecmax 2880) (defparameter sin-array '#(#o0 #o435 #o1073 #o1531 #o2166 #o2623 #o3260 #o3714 #o4350 #o5003 #o5435 #o6066 #o6516 #o7145 #o7573 #o10220 #o10644 #o11266 #o11706 #o12326 #o12743 #o13357 #o13771 #o14401 #o15007 #o15414 #o16016 #o16416 #o17013 #o17407 #o20000 #o20366 #o20752 #o21333 #o21711 #o22265 #o22636 #o23204 #o23546 #o24106 #o24443 #o24774 #o25323 #o25645 #o26165 #o26501 #o27011 #o27316 #o27617 #o30115 #o30406 #o30674 #o31156 #o31434 #o31706 #o32154 #o32416 #o32654 #o33106 #o33333 #o33554 #o33771 #o34202 #o34406 #o34605 #o35000 #o35167 #o35351 #o35526 #o35677 #o36043 #o36203 #o36336 #o36464 #o36605 #o36721 #o37031 #o37134 #o37231 #o37322 #o37407 #o37466 #o37540 #o37605 #o37646 #o37701 #o37730 #o37751 #o37766 #o37775 #o40000)) (defmacro psin (val) `(let* ((val ,val) neg frac sinlo) (if (>= val d180) (setq neg t val (- val d180))) (if (>= val d90) (setq val (- d180 val))) (setq frac (logand val 7)) (setq val (ash val -3)) ;; (setq sinlo (if (>= val 90) (svref sin-array 90) (svref sin-array val))) ;; (if (< val 90) (setq sinlo (+ sinlo (ash (* frac (- (svref sin-array (1+ val)) sinlo)) -3)))) ;; (if neg (- sinlo) sinlo))) (defmacro pcos (x) `(let ((tmp (- ,x d270))) (psin (if (minusp tmp) (+ tmp d360) tmp)))) ;;;; Miscellaneous petal hackery. (defmacro high-16bits-* (a b) `(let ((a-h (ash ,a -8)) (b-h (ash ,b -8))) (+ (* a-h b-h) (ash (* a-h (logand ,b 255)) -8) (ash (* b-h (logand ,a 255)) -8)))) (defun complete (style petal) (let ((repnum 1) factor cntval needed) (dotimes (i 3) (case i (0 (setq factor 2 cntval 6)) (1 (setq factor 3 cntval 2)) (2 (setq factor 5 cntval 1))) (do () ((or (minusp cntval) (not (zerop (rem style factor))))) (setq repnum (* repnum factor)) (setq cntval (1- cntval)) (setq style (floor style factor)))) (setq needed (floor vecmax repnum)) (if (and (not (oddp needed)) (oddp petal)) (floor needed 2) needed))) ;;;; Petal Parameters and Petal itself (defparameter continuous t) (defparameter styinc 2) (defparameter petinc 1) (defparameter scalfac-fac 8192) (defun petal (petal-window &optional (how-many 10) (style 0) (petal 0)) (let ((width 512) (height 512)) (xlib:clear-area petal-window) (xlib:display-force-output *display*) (let ((veccnt 0) (nustyle 722) (nupetal 3) (scalfac (1+ (floor scalfac-fac (min width height)))) (ctrx (floor width 2)) (ctry (floor height 2)) (tt 0) (s 0) (lststyle 0) (lstpetal 0) (petstyle 0) (vectors 0) (r 0) (x1 0) (y1 0) (x2 0) (y2 0) (i 0) (gc (xlib:create-gcontext :drawable petal-window :foreground *black-pixel* :background *white-pixel* :line-width 0 :line-style :solid))) (loop (when (zerop veccnt) (setq tt 0 s 0 lststyle style lstpetal petal petal nupetal style nustyle petstyle (rem (* petal style) d360) vectors (complete style petal)) (when continuous (setq nupetal (+ nupetal petinc) nustyle (+ nustyle styinc))) (when (or (/= lststyle style) (/= lstpetal petal)) (xlib:clear-area petal-window) (xlib:display-force-output *display*))) (when (or (/= lststyle style) (/= lstpetal petal)) (setq veccnt (1+ veccnt) i veccnt x1 x2 y1 y2 tt (rem (+ tt style) d360) s (rem (+ s petstyle) d360) r (pcos s)) (setq x2 (+ ctrx (floor (high-16bits-* (pcos tt) r) scalfac)) y2 (+ ctry (floor (high-16bits-* (psin tt) r) scalfac))) (when (/= i 1) (xlib:draw-line petal-window gc x1 y1 x2 y2) (xlib:display-force-output *display*))) (when (> veccnt vectors) (setq veccnt 0) (setq how-many (1- how-many)) (sleep 2) (when (zerop how-many) (return))))))) (defdemo petal-demo "Petal" (&optional (how-many 10) (style 0) (petal 0)) 100 100 512 512 "Flower-like display." (petal *window* how-many style petal)) ;;;; Hanoi. ;;; Random parameters: (defparameter disk-thickness 15 "The thickness of a disk in pixels.") (defparameter disk-spacing (+ disk-thickness 3) "The amount of vertical space used by a disk on a needle.") (defvar *horizontal-velocity* 20 "The speed at which disks slide sideways.") (defvar *vertical-velocity* 12 "The speed at which disks move up and down.") ;;; These variables are bound by the main function. (defvar *hanoi-window* () "The window that Hanoi is happening on.") (defvar *hanoi-window-height* () "The height of the viewport Hanoi is happening on.") (defvar *transfer-height* () "The height at which disks are transferred.") (defvar *hanoi-gcontext* () "The graphics context for Hanoi under X11.") ;;; Needle Functions (defstruct disk size) (defstruct needle position disk-stack) ;;; Needle-Top-Height returns the height of the top disk on NEEDLE. (defun needle-top-height (needle) (- *hanoi-window-height* (* disk-spacing (length (the list (needle-disk-stack needle)))))) (defvar available-disks (do ((i 10 (+ i 10)) (dlist () (cons (make-disk :size i) dlist))) ((> i 80) dlist))) (defvar needle-1 (make-needle :position 184)) (defvar needle-2 (make-needle :position 382)) (defvar needle-3 (make-needle :position 584)) ;;; Graphic interface abstraction: ;;; Invert-Rectangle calls the CLX function draw-rectangle with "fill-p" ;;; set to T. Update-Screen forces the display output. ;;; (defmacro invert-rectangle (x y height width) `(xlib:draw-rectangle *hanoi-window* *hanoi-gcontext* ,x ,y ,width ,height t)) (defmacro update-screen () `(xlib:display-force-output *display*)) ;;;; Moving disks up and down ;;; Slide-Up slides the image of a disk up from the coordinates X, ;;; START-Y to the point X, END-Y. DISK-SIZE is the size of the disk to ;;; move. START-Y must be greater than END-Y (defun slide-up (start-y end-y x disk-size) (multiple-value-bind (number-moves pixels-left) (truncate (- start-y end-y) *vertical-velocity*) (do ((x (- x disk-size)) (width (* disk-size 2)) (old-y start-y (- old-y *vertical-velocity*)) (new-y (- start-y *vertical-velocity*) (- new-y *vertical-velocity*)) (number-moves number-moves (1- number-moves))) ((zerop number-moves) (when (plusp pixels-left) (invert-rectangle x (- old-y pixels-left) disk-thickness width) (invert-rectangle x old-y disk-thickness width) (update-screen))) ;; Loop body writes disk at new height & erases at old height. (invert-rectangle x old-y disk-thickness width) (invert-rectangle x new-y disk-thickness width) (update-screen)))) ;;; Slide-Down slides the image of a disk down from the coordinates X, ;;; START-Y to the point X, END-Y. DISK-SIZE is the size of the disk to ;;; move. START-Y must be less than END-Y. (defun slide-down (start-y end-y x disk-size) (multiple-value-bind (number-moves pixels-left) (truncate (- end-y start-y) *vertical-velocity*) (do ((x (- x disk-size)) (width (* disk-size 2)) (old-y start-y (+ old-y *vertical-velocity*)) (new-y (+ start-y *vertical-velocity*) (+ new-y *vertical-velocity*)) (number-moves number-moves (1- number-moves))) ((zerop number-moves) (when (plusp pixels-left) (invert-rectangle x (+ old-y pixels-left) disk-thickness width) (invert-rectangle x old-y disk-thickness width) (update-screen))) ;; Loop body writes disk at new height & erases at old height. (invert-rectangle X old-y disk-thickness width) (invert-rectangle X new-y disk-thickness width) (update-screen)))) ;;;; Lifting and Droping Disks ;;; Lift-disk pops the top disk off of needle and raises it up to the ;;; transfer height. The disk is returned. (defun lift-disk (needle) "Pops the top disk off of NEEDLE, Lifts it above the needle, & returns it." (let* ((height (needle-top-height needle)) (disk (pop (needle-disk-stack needle)))) (slide-up height *transfer-height* (needle-position needle) (disk-size disk)) disk)) ;;; Drop-disk drops a disk positioned over needle at the transfer height ;;; onto needle. The disk is pushed onto needle. (defun drop-disk (disk needle) "DISK must be positioned above NEEDLE. It is dropped onto NEEDLE." (push disk (needle-disk-stack needle)) (slide-down *transfer-height* (needle-top-height needle) (needle-position needle) (disk-size disk)) t) ;;; Drop-initial-disk is the same as drop-disk except that the disk is ;;; drawn once before dropping. (defun drop-initial-disk (disk needle) "DISK must be positioned above NEEDLE. It is dropped onto NEEDLE." (let* ((size (disk-size disk)) (lx (- (needle-position needle) size))) (invert-rectangle lx *transfer-height* disk-thickness (* size 2)) (push disk (needle-disk-stack needle)) (slide-down *transfer-height* (needle-top-height needle) (needle-position needle) (disk-size disk)) t)) ;;;; Sliding Disks Right and Left ;;; Slide-Right slides the image of a disk located at START-X, Y to the ;;; position END-X, Y. DISK-SIZE is the size of the disk. START-X is ;;; less than END-X. (defun slide-right (start-x end-x Y disk-size) (multiple-value-bind (number-moves pixels-left) (truncate (- end-x start-x) *horizontal-velocity*) (do ((right-x (+ start-x disk-size) (+ right-x *horizontal-velocity*)) (left-x (- start-x disk-size) (+ left-x *horizontal-velocity*)) (number-moves number-moves (1- number-moves))) ((zerop number-moves) (when (plusp pixels-left) (invert-rectangle right-x Y disk-thickness pixels-left) (invert-rectangle left-x Y disk-thickness pixels-left) (update-screen))) ;; Loop body adds chunk *horizontal-velocity* pixels wide to right ;; side of disk, then chops off left side. (invert-rectangle right-x Y disk-thickness *horizontal-velocity*) (invert-rectangle left-x Y disk-thickness *horizontal-velocity*) (update-screen)))) ;;; Slide-Left is the same as Slide-Right except that START-X is greater ;;; than END-X. (defun slide-left (start-x end-x Y disk-size) (multiple-value-bind (number-moves pixels-left) (truncate (- start-x end-x) *horizontal-velocity*) (do ((right-x (- (+ start-x disk-size) *horizontal-velocity*) (- right-x *horizontal-velocity*)) (left-x (- (- start-x disk-size) *horizontal-velocity*) (- left-x *horizontal-velocity*)) (number-moves number-moves (1- number-moves))) ((zerop number-moves) (when (plusp pixels-left) (setq left-x (- (+ left-x *horizontal-velocity*) pixels-left)) (setq right-x (- (+ right-x *horizontal-velocity*) pixels-left)) (invert-rectangle left-x Y disk-thickness pixels-left) (invert-rectangle right-x Y disk-thickness pixels-left) (update-screen))) ;; Loop body adds chunk *horizontal-velocity* pixels wide to left ;; side of disk, then chops off right side. (invert-rectangle left-x Y disk-thickness *horizontal-velocity*) (invert-rectangle right-x Y disk-thickness *horizontal-velocity*) (update-screen)))) ;;;; Transferring Disks ;;; Transfer disk slides a disk at the transfer height from a position ;;; over START-NEEDLE to a position over END-NEEDLE. Modified disk is ;;; returned. (defun transfer-disk (disk start-needle end-needle) "Moves DISK from a position over START-NEEDLE to a position over END-NEEDLE." (let ((start (needle-position start-needle)) (end (needle-position end-needle))) (if (< start end) (slide-right start end *transfer-height* (disk-size disk)) (slide-left start end *transfer-height* (disk-size disk))) disk)) ;;; Move-One-Disk moves the top disk from START-NEEDLE to END-NEEDLE. (defun move-one-disk (start-needle end-needle) "Moves the disk on top of START-NEEDLE to the top of END-NEEDLE." (drop-disk (transfer-disk (lift-disk start-needle) start-needle end-needle) end-needle) t) ;;; Move-N-Disks moves the top N disks from START-NEEDLE to END-NEEDLE ;;; obeying the rules of the towers of hannoi problem. To move the ;;; disks, a third needle, TEMP-NEEDLE, is needed for temporary storage. (defun move-n-disks (n start-needle end-needle temp-needle) "Moves the top N disks from START-NEEDLE to END-NEEDLE. Uses TEMP-NEEDLE for temporary storage." (cond ((= n 1) (move-one-disk start-needle end-needle)) (t (move-n-disks (1- n) start-needle temp-needle end-needle) (move-one-disk start-needle end-needle) (move-n-disks (1- n) temp-needle end-needle start-needle))) t) ;;;; Hanoi itself. (defun hanoi (window n) (multiple-value-bind (width height) (full-window-state window) (declare (ignore width)) (let* ((*hanoi-window* window) (*hanoi-window-height* height) (*transfer-height* (- height (* disk-spacing n))) (*hanoi-gcontext* (xlib:create-gcontext :drawable *hanoi-window* :foreground *white-pixel* :background *black-pixel* :fill-style :solid :function boole-c2))) (xlib:clear-area *hanoi-window*) (xlib:display-force-output *display*) (let ((needle-1 (make-needle :position 184)) (needle-2 (make-needle :position 382)) (needle-3 (make-needle :position 584))) (setf (needle-disk-stack needle-1) ()) (setf (needle-disk-stack needle-2) ()) (setf (needle-disk-stack needle-3) ()) (do ((n n (1- n)) (available-disks available-disks (cdr available-disks))) ((zerop n)) (drop-initial-disk (car available-disks) needle-1)) (move-n-disks n needle-1 needle-3 needle-2) t)))) ;;; Change the names of these when the DEMO loop isn't so stupid. ;;; (defdemo slow-hanoi-demo "Slow-towers-of-Hanoi" (&optional (how-many 4)) 0 100 768 300 "Solves the Towers of Hanoi problem before your very eyes." (let ((*horizontal-velocity* 3) (*vertical-velocity* 1)) (hanoi *window* how-many))) ;;; (defdemo fast-hanoi-demo "Fast-towers-of-Hanoi" (&optional (how-many 7)) 0 100 768 300 "Solves the Towers of Hanoi problem before your very eyes." (hanoi *window* how-many)) ;;;; Bounce window. ;;; BOUNCE-WINDOW takes a window and seemingly drops it to the bottom of ;;; the screen. Optionally, the window can have an initial x velocity, ;;; screen border elasticity, and gravity value. The outer loop is ;;; entered the first time with the window at its initial height, but ;;; each iteration after this, the loop starts with the window at the ;;; bottom of the screen heading upward. The inner loop, except for the ;;; first execution, carries the window up until the negative velocity ;;; becomes positive, carrying the window down to bottom when the ;;; velocity is positive. Due to number lossage, ROUND'ing and ;;; TRUNC'ing when the velocity gets so small will cause the window to ;;; head upward with the same velocity over two iterations which will ;;; cause the window to bounce forever, so we have prev-neg-velocity and ;;; number-problems to check for this. This is not crucial with the x ;;; velocity since the loop terminates as a function of the y velocity. ;;; (defun bounce-window (window &optional (x-velocity 0) (elasticity 0.85) (gravity 2)) (unless (< 0 elasticity 1) (error "Elasticity must be between 0 and 1.")) (unless (plusp gravity) (error "Gravity must be positive.")) (multiple-value-bind (width height x y mapped) (full-window-state window) (when (eq mapped :viewable) (let ((top-of-window-at-bottom (- (xlib:drawable-height *root*) height)) (left-of-window-at-right (- (xlib:drawable-width *root*) width)) (y-velocity 0) (prev-neg-velocity most-negative-fixnum) (number-problems nil)) (declare (fixnum top-of-window-at-bottom left-of-window-at-right y-velocity)) (loop (when (= prev-neg-velocity 0) (return t)) (let ((negative-velocity (minusp y-velocity))) (loop (let ((next-y (+ y y-velocity)) (next-y-velocity (+ y-velocity gravity))) (declare (fixnum next-y next-y-velocity)) (when (> next-y top-of-window-at-bottom) (cond (number-problems (setf y-velocity (incf prev-neg-velocity))) (t (setq y-velocity (- (truncate (* elasticity y-velocity)))) (when (= y-velocity prev-neg-velocity) (incf y-velocity) (setf number-problems t)) (setf prev-neg-velocity y-velocity))) (setf y top-of-window-at-bottom) (setf (xlib:drawable-x window) x (xlib:drawable-y window) y) (xlib:display-force-output *display*) (return)) (setq y-velocity next-y-velocity) (setq y next-y)) (when (and negative-velocity (>= y-velocity 0)) (setf negative-velocity nil)) (let ((next-x (+ x x-velocity))) (declare (fixnum next-x)) (when (or (> next-x left-of-window-at-right) (< next-x 0)) (setq x-velocity (- (truncate (* elasticity x-velocity))))) (setq x next-x)) (setf (xlib:drawable-x window) x (xlib:drawable-y window) y) (xlib:display-force-output *display*)))))))) ;;; Change the name of this when DEMO is not so stupid. ;;; (defdemo shove-bounce-demo "Shove-bounce" () 100 100 300 300 "Drops the demo window with an inital X velocity which bounces off screen borders." (bounce-window *window* 30)) (defdemo bounce-demo "Bounce" () 100 100 300 300 "Drops the demo window which bounces off screen borders." (bounce-window *window*)) ;;;; Recurrence Demo ;;; Copyright (C) 1988 Michael O. Newton (newton@csvax.caltech.edu) ;;; Permission is granted to any individual or institution to use, copy, ;;; modify, and distribute this software, provided that this complete ;;; copyright and permission notice is maintained, intact, in all copies and ;;; supporting documentation. ;;; The author provides this software "as is" without express or ;;; implied warranty. ;;; This routine plots the recurrence ;;; x <- y(1+sin(0.7x)) - 1.2(|x|)^.5 ;;; y <- .21 - x ;;; As described in a ?? 1983 issue of the Mathematical Intelligencer (defun recurrence (display window &optional (point-count 10000)) (let ((gc (xlib:create-gcontext :drawable window :background *white-pixel* :foreground *black-pixel*))) (multiple-value-bind (width height) (full-window-state window) (xlib:clear-area window) (draw-ppict window gc point-count 0.0 0.0 (* width 0.5) (* height 0.5)) (xlib:display-force-output display) (sleep 4)) (xlib:free-gcontext gc))) ;;; Draw points. X assumes points are in the range of width x height, ;;; with 0,0 being upper left and 0,H being lower left. ;;; hw and hh are half-width and half-height of screen (defun draw-ppict (win gc count x y hw hh) "Recursively draw pretty picture" (unless (zerop count) (let ((xf (floor (* (+ 1.0 x) hw ))) ;These lines center the picture (yf (floor (* (+ 0.7 y) hh )))) (xlib:draw-point win gc xf yf) (draw-ppict win gc (1- count) (- (* y (1+ (sin (* 0.7 x)))) (* 1.2 (sqrt (abs x)))) (- 0.21 x) hw hh)))) (defdemo recurrence-demo "Recurrence" () 10 10 700 700 "Plots a cool recurrence relation." (recurrence *display* *window*)) ;;;; Plaid ;;; ;;; Translated from the X11 Plaid Demo written in C by Christopher Hoover. ;;; (defmacro rect-x (rects n) `(svref ,rects (ash ,n 2))) (defmacro rect-y (rects n) `(svref ,rects (+ (ash ,n 2) 1))) (defmacro rect-width (rects n) `(svref ,rects (+ (ash ,n 2) 2))) (defmacro rect-height (rects n) `(svref ,rects (+ (ash ,n 2) 3))) (defun plaid (display window &optional (num-iterations 10000) (num-rectangles 10)) (let ((gcontext (xlib:create-gcontext :drawable window :function boole-c2 :plane-mask (logxor *white-pixel* *black-pixel*) :background *white-pixel* :foreground *black-pixel* :fill-style :solid)) (rectangles (make-array (* 4 num-rectangles) :element-type 'number :initial-element 0))) (multiple-value-bind (width height) (full-window-state window) (let ((center-x (ash width -1)) (center-y (ash height -1)) (x-dir -2) (y-dir -2) (x-off 2) (y-off 2)) (dotimes (iter (truncate num-iterations num-rectangles)) (dotimes (i num-rectangles) (setf (rect-x rectangles i) (- center-x x-off)) (setf (rect-y rectangles i) (- center-y y-off)) (setf (rect-width rectangles i) (ash x-off 1)) (setf (rect-height rectangles i) (ash y-off 1)) (incf x-off x-dir) (incf y-off y-dir) (when (or (<= x-off 0) (>= x-off center-x)) (decf x-off (ash x-dir 1)) (setf x-dir (- x-dir))) (when (or (<= y-off 0) (>= y-off center-y)) (decf y-off (ash y-dir 1)) (setf y-dir (- y-dir)))) (xlib:draw-rectangles window gcontext rectangles t) (xlib:display-force-output display)))) (xlib:free-gcontext gcontext))) (defdemo plaid-demo "Plaid" (&optional (iterations 10000) (num-rectangles 10)) 10 10 101 201 "Plaid, man." (plaid *display* *window* iterations num-rectangles)) ;;;; Bball demo ;;; ;;; Ported to CLX by Blaine Burks ;;; (defvar *ball-size-x* 38) (defvar *ball-size-y* 34) (defmacro xor-ball (pixmap window gcontext x y) `(xlib:copy-area ,pixmap ,gcontext 0 0 *ball-size-x* *ball-size-y* ,window ,x ,y)) (defconstant bball-gravity 1) (defconstant maximum-x-drift 7) (defvar *max-bball-x*) (defvar *max-bball-y*) (defstruct ball (x (random (- *max-bball-x* *ball-size-x*))) (y (random (- *max-bball-y* *ball-size-y*))) (dx (if (zerop (random 2)) (random maximum-x-drift) (- (random maximum-x-drift)))) (dy 0)) (defun get-bounce-image () "Returns the pixmap to be bounced around the screen." (xlib::bitmap-image #*000000000000000000000000000000000000 #*000000000000000000000000000000000000 #*000000000000000000001000000010000000 #*000000000000000000000000000100000000 #*000000000000000000000100001000000000 #*000000000000000010000000010000000000 #*000000000000000000100010000000000000 #*000000000000000000001000000000000000 #*000000000001111100000000000101010000 #*000000000010000011000111000000000000 #*000000000100000000111000000000000000 #*000000000100000000000000000100000000 #*000000000100000000001000100010000000 #*000000111111100000010000000001000000 #*000000111111100000100000100000100000 #*000011111111111000000000000000000000 #*001111111111111110000000100000000000 #*001111111111111110000000000000000000 #*011111111111111111000000000000000000 #*011111111111111111000000000000000000 #*111111111111110111100000000000000000 #*111111111111111111100000000000000000 #*111111111111111101100000000000000000 #*111111111111111101100000000000000000 #*111111111111111101100000000000000000 #*111111111111111111100000000000000000 #*111111111111110111100000000000000000 #*011111111111111111000000000000000000 #*011111111111011111000000000000000000 #*001111111111111110000000000000000000 #*001111111111111110000000000000000000 #*000011111111111000000000000000000000 #*000000111111100000000000000000000000 #*000000000000000000000000000000000000)) (defun bounce-1-ball (pixmap window gcontext ball) (let ((x (ball-x ball)) (y (ball-y ball)) (dx (ball-dx ball)) (dy (ball-dy ball))) (xor-ball pixmap window gcontext x y) (setq x (+ x dx)) (setq y (+ y dy)) (if (or (< x 0) (> x (- *max-bball-x* *ball-size-x*))) (setq x (- x dx) dx (- dx))) (if (> y (- *max-bball-y* *ball-size-y*)) (setq y (- y dy) dy (- dy))) (setq dy (+ dy bball-gravity)) (setf (ball-x ball) x) (setf (ball-y ball) y) (setf (ball-dx ball) dx) (setf (ball-dy ball) dy) (xor-ball pixmap window gcontext x y))) (defun bounce-balls (display window how-many duration) (xlib:clear-area window) (xlib:display-force-output display) (multiple-value-bind (*max-bball-x* *max-bball-y*) (full-window-state window) (let* ((balls (do ((i 0 (1+ i)) (list () (cons (make-ball) list))) ((= i how-many) list))) (gcontext (xlib:create-gcontext :drawable window :foreground *white-pixel* :background *black-pixel* :function boole-xor :exposures :off)) (bounce-pixmap (xlib:create-pixmap :width 38 :height 34 :depth 1 :drawable window)) (pixmap-gc (xlib:create-gcontext :drawable bounce-pixmap :foreground *white-pixel* :background *black-pixel*))) (xlib:put-image bounce-pixmap pixmap-gc (get-bounce-image) :x 0 :y 0 :width 38 :height 34) (xlib:free-gcontext pixmap-gc) (dolist (ball balls) (xor-ball bounce-pixmap window gcontext (ball-x ball) (ball-y ball))) (xlib:display-force-output display) (dotimes (i duration) (dolist (ball balls) (bounce-1-ball bounce-pixmap window gcontext ball)) (xlib:display-force-output display)) (xlib:free-pixmap bounce-pixmap) (xlib:free-gcontext gcontext)))) #+nil (defdemo bouncing-ball-demo "Bouncing-Ball" (&optional (how-many 5) (duration 500)) 34 34 700 500 "Bouncing balls in space." (bounce-balls *display* *window* how-many duration)) ecl-16.1.2/src/clx/demo/gl-test.lisp000066400000000000000000000371731266352375300171440ustar00rootroot00000000000000(defpackage :gl-test (:use :common-lisp :xlib) (:export "TEST" "CLX-TEST")) (in-package :gl-test) (defun test (function &key (host "localhost") (display 1) (width 200) (height 200)) (let* ((display (open-display host :display display)) (screen (display-default-screen display)) (root (screen-root screen)) ctx) (unwind-protect (progn ;;; Inform the server about us. (glx::client-info display) (let* ((visual (glx:choose-visual screen '(:glx-rgba (:glx-red-size 1) (:glx-green-size 1) (:glx-blue-size 1) :glx-double-buffer))) (colormap (create-colormap (glx:visual-id visual) root)) (window (create-window :parent root :x 10 :y 10 :width width :height height :class :input-output :background (screen-black-pixel screen) :border (screen-black-pixel screen) :visual (glx:visual-id visual) :depth 24 :colormap colormap :event-mask '(:structure-notify :exposure))) (gc (create-gcontext :foreground (screen-white-pixel screen) :background (screen-black-pixel screen) :drawable window :font (open-font display "fixed")))) (set-wm-properties window :name "glx-test" :resource-class "glx-test" :command (list "glx-test") :x 10 :y 10 :width width :height height :min-width width :min-height height :initial-state :normal) (setf ctx (glx:create-context screen (glx:visual-id visual))) (map-window window) (glx:make-current window ctx) (funcall function display window) (unmap-window window) (free-gcontext gc))) (when ctx (glx:destroy-context ctx)) (close-display display)))) ;;; Tests (defun no-floats (display window) (declare (ignore display window)) (gl:color-3s #x7fff #x7fff 0) (gl:begin gl:+polygon+) (gl:vertex-2s 0 0) (gl:vertex-2s 1 0) (gl:vertex-2s 1 1) (gl:vertex-2s 0 1) (gl:end) (glx:swap-buffers) (sleep 5)) (defun anim (display window) (declare (ignore display window)) (gl:ortho 0.0d0 1.0d0 0.0d0 1.0d0 -1.0d0 1.0d0) (gl:clear-color 0.0s0 0.0s0 0.0s0 0.0s0) (gl:line-width 2.0s0) (loop repeat 361 for angle upfrom 0.0s0 by 1.0s0 do (progn (gl:clear gl:+color-buffer-bit+) (gl:push-matrix) (gl:translate-f 0.5s0 0.5s0 0.0s0) (gl:rotate-f angle 0.0s0 0.0s0 1.0s0) (gl:translate-f -0.5s0 -0.5s0 0.0s0) (gl:begin gl:+polygon+ #-(and) gl:+line-loop+) (gl:color-3ub 255 0 0) (gl:vertex-2f 0.25s0 0.25s0) (gl:color-3ub 0 255 0) (gl:vertex-2f 0.75s0 0.25s0) (gl:color-3ub 0 0 255) (gl:vertex-2f 0.75s0 0.75s0) (gl:color-3ub 255 255 255) (gl:vertex-2f 0.25s0 0.75s0) (gl:end) (gl:pop-matrix) (glx:swap-buffers) (sleep 0.02))) (sleep 3)) (defun anim/list (display window) (declare (ignore display window)) (gl:ortho 0.0d0 1.0d0 0.0d0 1.0d0 -1.0d0 1.0d0) (gl:clear-color 0.0s0 0.0s0 0.0s0 0.0s0) (let ((list (gl:gen-lists 1))) (gl:new-list list gl:+compile+) (gl:begin gl:+polygon+) (gl:color-3ub 255 0 0) (gl:vertex-2f 0.25s0 0.25s0) (gl:color-3ub 0 255 0) (gl:vertex-2f 0.75s0 0.25s0) (gl:color-3ub 0 0 255) (gl:vertex-2f 0.75s0 0.75s0) (gl:color-3ub 255 255 255) (gl:vertex-2f 0.25s0 0.75s0) (gl:end) (glx:render) (gl:end-list) (loop repeat 361 for angle upfrom 0.0s0 by 1.0s0 do (progn (gl:clear gl:+color-buffer-bit+) (gl:push-matrix) (gl:rotate-f angle 0.0s0 0.0s0 1.0s0) (gl:call-list list) (gl:pop-matrix) (glx:swap-buffers) (sleep 0.02)))) (sleep 3)) ;;; glxgears (defconstant +pi+ (coerce pi 'single-float)) (declaim (type single-float +pi+)) (defun gear (inner-radius outer-radius width teeth tooth-depth) (let ((r0 inner-radius) (r1 (/ (- outer-radius tooth-depth) 2.0s0)) (r2 (/ (+ outer-radius tooth-depth) 2.0s0)) (da (/ (* 2.0s0 +pi+) teeth 4.0s0))) (gl:shade-model gl:+flat+) (gl:normal-3f 0.0s0 0.0s0 1.0s0) ;; Front face. (gl:begin gl:+quad-strip+) (dotimes (i (1+ teeth)) (let ((angle (/ (* i 2.0 +pi+) teeth))) (declare (type single-float angle)) (gl:vertex-3f (* r0 (cos angle)) (* r0 (sin angle)) (* width 0.5s0)) (gl:vertex-3f (* r1 (cos angle)) (* r1 (sin angle)) (* width 0.5s0)) (when (< i teeth) (gl:vertex-3f (* r0 (cos angle)) (* r0 (sin angle)) (* width 0.5s0)) (gl:vertex-3f (* r1 (cos (+ angle (* 3 da)))) (* r1 (sin (+ angle (* 3 da)))) (* width 0.5s0))))) (gl:end) ;; Draw front sides of teeth. (gl:begin gl:+quads+) (setf da (/ (* 2.0s0 +pi+) teeth 4.0s0)) (dotimes (i teeth) (let ((angle (/ (* i 2.0s0 +pi+) teeth))) (declare (type single-float angle)) (gl:vertex-3f (* r1 (cos angle)) (* r1 (sin angle)) (* width 0.5s0)) (gl:vertex-3f (* r2 (cos (+ angle da))) (* r2 (sin (+ angle da))) (* width 0.5s0)) (gl:vertex-3f (* r2 (cos (+ angle (* 2 da)))) (* r2 (sin (+ angle (* 2 da)))) (* width 0.5s0)) (gl:vertex-3f (* r1 (cos (+ angle (* 3 da)))) (* r1 (sin (+ angle (* 3 da)))) (* width 0.5s0)))) (gl:end) (gl:normal-3f 0.0s0 0.0s0 -1.0s0) ;; Draw back face. (gl:begin gl:+quad-strip+) (dotimes (i (1+ teeth)) (let ((angle (/ (* i 2.0s0 +pi+) teeth))) (declare (type single-float angle)) (gl:vertex-3f (* r1 (cos angle)) (* r1 (sin angle)) (* width -0.5s0)) (gl:vertex-3f (* r0 (cos angle)) (* r0 (sin angle)) (* width -0.5s0)) (when (< i teeth) (gl:vertex-3f (* r1 (cos (+ angle (* 3 da)))) (* r1 (sin (+ angle (* 3 da)))) (* width -0.5s0)) (gl:vertex-3f (* r0 (cos angle)) (* r0 (sin angle)) (* width 0.5s0))))) (gl:end) ;; Draw back sides of teeth. (gl:begin gl:+quads+) (setf da (/ (* 2.0s0 +pi+) teeth 4.0s0)) (dotimes (i teeth) (let ((angle (/ (* i 2.0s0 +pi+) teeth))) (declare (type single-float angle)) (gl:vertex-3f (* r1 (cos (+ angle (* 3 da)))) (* r1 (sin (+ angle (* 3 da)))) (* width -0.5s0)) (gl:vertex-3f (* r2 (cos (+ angle (* 2 da)))) (* r2 (sin (+ angle (* 2 da)))) (* width -0.5s0)) (gl:vertex-3f (* r2 (cos (+ angle da))) (* r2 (sin (+ angle da))) (* width -0.5s0)) (gl:vertex-3f (* r1 (cos angle)) (* r1 (sin angle)) (* width -0.5s0)))) (gl:end) ;; Draw outward faces of teeth. (gl:begin gl:+quad-strip+) (dotimes (i teeth) (let ((angle (/ (* i 2.0s0 +pi+) teeth))) (declare (type single-float angle)) (gl:vertex-3f (* r1 (cos angle)) (* r1 (sin angle)) (* width 0.5s0)) (gl:vertex-3f (* r1 (cos angle)) (* r1 (sin angle)) (* width -0.5s0)) (let* ((u (- (* r2 (cos (+ angle da))) (* r1 (cos angle)))) (v (- (* r2 (sin (+ angle da))) (* r1 (sin angle)))) (len (sqrt (+ (* u u) (* v v))))) (setf u (/ u len) v (/ v len)) (gl:normal-3f v u 0.0s0) (gl:vertex-3f (* r2 (cos (+ angle da))) (* r2 (sin (+ angle da))) (* width 0.5s0)) (gl:vertex-3f (* r2 (cos (+ angle da))) (* r2 (sin (+ angle da))) (* width -0.5s0)) (gl:normal-3f (cos angle) (sin angle) 0.0s0) (gl:vertex-3f (* r2 (cos (+ angle (* 2 da)))) (* r2 (sin (+ angle (* 2 da)))) (* width 0.5s0)) (gl:vertex-3f (* r2 (cos (+ angle (* 2 da)))) (* r2 (sin (+ angle (* 2 da)))) (* width -0.5s0)) (setf u (- (* r1 (cos (+ angle (* 3 da)))) (* r2 (cos (+ angle (* 2 da))))) v (- (* r1 (sin (+ angle (* 3 da)))) (* r2 (sin (+ angle (* 2 da)))))) (gl:normal-3f v (- u) 0.0s0) (gl:vertex-3f (* r1 (cos (+ angle (* 3 da)))) (* r1 (sin (+ angle (* 3 da)))) (* width 0.5s0)) (gl:vertex-3f (* r1 (cos (+ angle (* 3 da)))) (* r1 (sin (+ angle (* 3 da)))) (* width -0.5s0)) (gl:normal-3f (cos angle) (sin angle) 0.0s0)))) (gl:vertex-3f (* r1 (cos 0)) (* r1 (sin 0)) (* width 0.5s0)) (gl:vertex-3f (* r1 (cos 0)) (* r1 (sin 0)) (* width -0.5s0)) (gl:end) (gl:shade-model gl:+smooth+) ;; Draw inside radius cylinder. (gl:begin gl:+quad-strip+) (dotimes (i (1+ teeth)) (let ((angle (/ (* i 2.0s0 +pi+) teeth))) (declare (type single-float angle)) (gl:normal-3f (- (cos angle)) (- (sin angle)) 0.0s0) (gl:vertex-3f (* r0 (cos angle)) (* r0 (sin angle)) (* width -0.5s0)) (gl:vertex-3f (* r0 (cos angle)) (* r0 (sin angle)) (* width 0.5s0)))) (gl:end))) (defun draw (gear-1 gear-2 gear-3 view-rotx view-roty view-rotz angle) (gl:clear (logior gl:+color-buffer-bit+ gl:+depth-buffer-bit+)) (gl:push-matrix) (gl:rotate-f view-rotx 1.0s0 0.0s0 0.0s0) (gl:rotate-f view-roty 0.0s0 1.0s0 0.0s0) (gl:rotate-f view-rotz 0.0s0 0.0s0 1.0s0) (gl:push-matrix) (gl:translate-f -3.0s0 -2.0s0 0.0s0) (gl:rotate-f angle 0.0s0 0.0s0 1.0s0) (gl:call-list gear-1) (gl:pop-matrix) (gl:push-matrix) (gl:translate-f 3.1s0 -2.0s0 0.0s0) (gl:rotate-f (- (* angle -2.0s0) 9.0s0) 0.0s0 0.0s0 1.0s0) (gl:call-list gear-2) (gl:pop-matrix) (gl:push-matrix) (gl:translate-f -3.1s0 4.2s0 0.0s0) (gl:rotate-f (- (* angle -2.s0) 25.0s0) 0.0s0 0.0s0 1.0s0) (gl:call-list gear-3) (gl:pop-matrix) (gl:pop-matrix)) (defun reshape (width height) (gl:viewport 0 0 width height) (let ((h (coerce (/ height width) 'double-float))) (gl:matrix-mode gl:+projection+) (gl:load-identity) (gl:frustum -1.0d0 1.0d0 (- h) h 5.0d0 60.0d0)) (gl:matrix-mode gl:+modelview+) (gl:load-identity) (gl:translate-f 0.0s0 0.0s0 -40.0s0)) (defun init () (let (gear-1 gear-2 gear-3) ;;(gl:light-fv gl:+light0+ gl:+position+ '(5.0s0 5.0s0 10.0s0 0.0s0)) ;;(gl:enable gl:+cull-face+) ;;(gl:enable gl:+lighting+) ;;(gl:enable gl:+light0+) ;;(gl:enable gl:+depth-test+) ;; Make the gears. (setf gear-1 (gl:gen-lists 1)) (gl:new-list gear-1 gl:+compile+) (gl:material-fv gl:+front+ gl:+ambient-and-diffuse+ '(0.8s0 0.1s0 0.0s0 1.0s0)) (gear 1.0s0 4.0s0 1.0s0 20 0.7s0) (gl:end-list) (setf gear-2 (gl:gen-lists 1)) (gl:new-list gear-2 gl:+compile+) (gl:material-fv gl:+front+ gl:+ambient-and-diffuse+ '(0.0s0 0.8s0 0.2s0 1.0s0)) (gear 0.5s0 2.0s0 2.0s0 10 0.7s0) (gl:end-list) (setf gear-3 (gl:gen-lists 1)) (gl:new-list gear-3 gl:+compile+) (gl:material-fv gl:+front+ gl:+ambient-and-diffuse+ '(0.2s0 0.2s0 1.0s0 1.0s0)) (gear 1.3s0 2.0s0 0.5s0 10 0.7s0) (gl:end-list) ;;(gl:enable gl:+normalize+) (values gear-1 gear-2 gear-3))) (defun gears* (display window) (declare (ignore display window)) (gl:enable gl:+cull-face+) (gl:enable gl:+lighting+) (gl:enable gl:+light0+) (gl:enable gl:+normalize+) (gl:enable gl:+depth-test+) (reshape 300 300) ;;(gl:light-fv gl:+light0+ gl:+position+ #(5.0s0 5.0s0 10.0s0 0.0s0)) (let (list) (declare (ignore list)) #-(and) (progn (setf list (gl:gen-lists 1)) (gl:new-list list gl:+compile+) ;;(gl:material-fv gl:+front+ gl:+ambient-and-diffuse+ '(0.8s0 0.1s0 0.0s0 1.0s0)) (gear 1.0s0 4.0s0 1.0s0 20 0.7s0) (glx:render) (gl:end-list)) (loop ;;for angle from 0.0s0 below 361.0s0 by 1.0s0 with angle single-float = 0.0s0 with dt = 0.004s0 repeat 2500 do (progn (incf angle (* 70.0s0 dt)) ; 70 degrees per second (when (< 3600.0s0 angle) (decf angle 3600.0s0)) (gl:clear (logior gl:+color-buffer-bit+ gl:+depth-buffer-bit+)) (gl:push-matrix) (gl:rotate-f 20.0s0 0.0s0 1.0s0 0.0s0) (gl:push-matrix) (gl:translate-f -3.0s0 -2.0s0 0.0s0) (gl:rotate-f angle 0.0s0 0.0s0 1.0s0) (gl:material-fv gl:+front+ gl:+ambient-and-diffuse+ '(0.8s0 0.1s0 0.0s0 1.0s0)) (gear 1.0s0 4.0s0 1.0s0 20 0.7s0) (gl:pop-matrix) (gl:push-matrix) (gl:translate-f 3.1s0 -2.0s0 0.0s0) (gl:rotate-f (- (* angle -2.0s0) 9.0s0) 0.0s0 0.0s0 1.0s0) (gl:material-fv gl:+front+ gl:+ambient-and-diffuse+ '(0.0s0 0.8s0 0.2s0 1.0s0)) (gear 0.5s0 2.0s0 2.0s0 10 0.7s0) (gl:pop-matrix) (gl:push-matrix) (gl:translate-f -3.1s0 4.2s0 0.0s0) (gl:rotate-f (- (* angle -2.s0) 25.0s0) 0.0s0 0.0s0 1.0s0) (gl:material-fv gl:+front+ gl:+ambient-and-diffuse+ '(0.2s0 0.2s0 1.0s0 1.0s0)) (gear 1.3s0 2.0s0 0.5s0 10 0.7s0) (gl:pop-matrix) (gl:pop-matrix) (glx:swap-buffers) ;;(sleep 0.025) ))) ;;(sleep 3) ) (defun gears (display window) (declare (ignore window)) (let ((view-rotx 20.0s0) (view-roty 30.0s0) (view-rotz 0.0s0) (angle 0.0s0) (frames 0) (dt 0.004s0) ; *** This is dynamically adjusted ;;(t-rot-0 -1.0d0) ;;(t-rate-0 -1.d0) gear-1 gear-2 gear-3) (multiple-value-setq (gear-1 gear-2 gear-3) (init)) (loop (event-case (display :timeout 0.01 :force-output-p t) (configure-notify (width height) (reshape width height) t) (key-press (code) (format t "Key pressed: ~S~%" code) (return-from gears t))) (incf angle (* 70.0s0 dt)) ; 70 degrees per second (when (< 3600.0s0 angle) (decf angle 3600.0s0)) (draw gear-1 gear-2 gear-3 view-rotx view-roty view-rotz angle) (glx:swap-buffers) (incf frames) ;; FPS calculation goes here ))) ecl-16.1.2/src/clx/demo/hello.lisp000066400000000000000000000070011266352375300166530ustar00rootroot00000000000000;;; -*- Mode:Lisp; Syntax: Common-lisp; Package:XLIB; Base:10; Lowercase: Yes -*- (in-package :xlib) (defun hello-world (host &rest args &key (string "Hello World") (font "fixed")) ;; CLX demo, says STRING using FONT in its own window on HOST (let ((display nil) (abort t)) (unwind-protect (progn (setq display (open-display host)) (multiple-value-prog1 (let* ((screen (display-default-screen display)) (black (screen-black-pixel screen)) (white (screen-white-pixel screen)) (font (open-font display font)) (border 1) ; Minimum margin around the text (width (+ (text-width font string) (* 2 border))) (height (+ (max-char-ascent font) (max-char-descent font) (* 2 border))) (x (truncate (- (screen-width screen) width) 2)) (y (truncate (- (screen-height screen) height) 2)) (window (create-window :parent (screen-root screen) :x x :y y :width width :height height :background black :border white :border-width 1 :colormap (screen-default-colormap screen) :bit-gravity :center :event-mask '(:exposure :button-press))) (gcontext (create-gcontext :drawable window :background black :foreground white :font font))) ;; Set window manager hints (set-wm-properties window :name 'hello-world :icon-name string :resource-name string :resource-class 'hello-world :command (list* 'hello-world host args) :x x :y y :width width :height height :min-width width :min-height height :input :off :initial-state :normal) (map-window window) ; Map the window ;; Handle events (event-case (display :discard-p t :force-output-p t) (exposure ;; Come here on exposure events (window count) (when (zerop count) ;; Ignore all but the last exposure event (with-state (window) (let ((x (truncate (- (drawable-width window) width) 2)) (y (truncate (- (+ (drawable-height window) (max-char-ascent font)) (max-char-descent font)) 2))) ;; Draw text centered in widnow (clear-area window) (draw-glyphs window gcontext x y string))) ;; Returning non-nil causes event-case to exit nil)) (button-press () t))) ;; Pressing any mouse-button exits (setq abort nil))) ;; Ensure display is closed when done (when display (close-display display :abort abort))))) ecl-16.1.2/src/clx/demo/mandel.lisp000066400000000000000000000527561266352375300170310ustar00rootroot00000000000000(defpackage "XMANDEL" (:use "CL") (:export "NEW-WINDOW" "EVENT-LOOP")) (in-package "XMANDEL") (defvar *display* (xlib:open-default-display)) (defvar *screen* (xlib:display-default-screen *display*)) (defvar *backing-store* (make-hash-table) "Backing store hashtable, keyed off window id") (defvar *colmap* nil) (defvar *helpwin* nil) (defvar *zoom-table* (make-hash-table)) (defvar *zoomcolmap* (xlib:create-gcontext :drawable (xlib:screen-root *screen*) :foreground (xlib:screen-white-pixel *screen*) :function boole-xor)) (defvar *white* (xlib:create-gcontext :drawable (xlib:screen-root *screen*) :foreground (xlib:screen-white-pixel *screen*) )) (defvar *winmap* (make-hash-table)) (defvar *textmap* (xlib:create-gcontext :drawable (xlib:screen-root *screen*) :foreground (xlib:screen-black-pixel *screen*) :background (xlib:screen-white-pixel *screen*))) ;;; OK, this is an ugly hack to make sure we can handle ;;; shift and modstate in a sane way, alas we can't 100% rely ;;; on "current state of keyboard", since we only process events ;;; with a noticeable delay, at eth best of times, so a fast keyboarder ;;; can fool us, we are, however, IIRC, guaranteed that all events are ;;; serialised, so... (defvar *modstate* nil) (declaim (list *modstate*)) (defun make-shift-foo () (let ((rv 0)) (if (member :shift *modstate*) (setf rv 1)) (if (member :character-set-switch *modstate*) (setf rv (+ rv 2))) rv)) (defstruct (mandel-square (:conc-name ms-)) (x 0 :type fixnum) (y 0 :type fixnum) (s 512 :type fixnum) (base-r 0.0d0 :type double-float) (base-i 0.0d0 :type double-float) (maxiter 1024 :type fixnum) (dr 0.0d0 :type double-float) (di 0.0d0 :type double-float) win ) (defun make-queue (&rest args) (apply #'make-instance 'queue args)) (defclass queue () ((head :initform nil :accessor q-head) (tail :initform nil :accessor q-tail))) (defclass out-queue () ((win-queues :accessor win-queues :initarg :xyzzy-1) (seen-windows :accessor windows :initform nil) (win-list :accessor win-list :initarg :xyzzy-2) (last-window :accessor last-window :initform nil)) (:default-initargs :xyzzy-1 (make-hash-table) :xyzzy-2 (make-instance 'queue))) (defvar *sysqueue* (make-instance 'out-queue)) (defgeneric empty-p (queue)) (defgeneric empty (queue)) (defgeneric empty-win (queue win)) (defgeneric enqueue (queue item)) (defgeneric queue-push (queue item)) (defgeneric dequeue (queue)) (defmethod empty-p ((q null)) t) (defmethod empty-p ((q queue)) (null (q-head q))) (defmethod empty-p ((q out-queue)) (let ((coll nil)) (maphash #'(lambda (key val) (declare (ignore key)) (push (empty-p val) coll)) (win-queues q)) (every #'identity coll))) (defmethod empty ((q null)) nil) (defmethod empty ((q queue)) (setf (q-head q) nil) (setf (q-tail q) nil)) (defmethod empty ((q out-queue)) (maphash #'(lambda (key val) (declare (ignore key)) (empty val)) (win-queues q))) (defmethod empty-win ((q out-queue) win) (let ((temp-queue (gethash win (win-queues q)))) (empty temp-queue))) (defmethod enqueue ((q queue) item) (cond ((empty-p q) (setf (q-head q) (cons item nil)) (setf (q-tail q) (q-head q))) (t (setf (cdr (q-tail q)) (cons item nil)) (setf (q-tail q) (cdr (q-tail q)))))) (defmethod enqueue ((q out-queue) item) (let ((windows (q-head (win-list q))) (win (ms-win item))) (declare (type xlib:window win)) (unless (member win windows) (enqueue (win-list q) win)) (unless (member win (windows q)) (push win (windows q))) (let ((temp-queue (gethash win (win-queues q)))) (if (null temp-queue) (let ((new (make-queue))) (setf (gethash win (win-queues q)) new) (enqueue new item)) (enqueue temp-queue item))))) (defmethod queue-push ((q queue) item) (cond ((empty-p q) (setf (q-head q) (cons item nil)) (setf (q-tail q) (q-head q))) (t (setf (q-head q) (cons item (q-head q)))))) (defmethod queue-push ((q out-queue) item) (let ((windows (q-head (win-list q))) (win (ms-win item))) (declare (type xlib:window win)) (unless (member win windows) (enqueue (win-list q) win)) (unless (member win (windows q)) (push win (windows q))) (let ((temp-queue (gethash win (win-queues q)))) (if (null temp-queue) (let ((new (make-queue))) (setf (gethash win (win-queues q)) new) (queue-push new item)) (queue-push temp-queue item))))) (defmethod dequeue ((q out-queue)) (if (empty-p q) nil (let ((windows (win-list q))) (do* ((next (dequeue windows)) (finished nil) (val nil) (temp-queue (gethash next (win-queues q)) (gethash next (win-queues q)))) (finished val) (cond ((empty-p temp-queue) (setf next (dequeue windows))) (t (setf val (dequeue temp-queue)) (unless (empty-p temp-queue) (enqueue windows next)) (setf finished t))))))) (defmethod dequeue ((q queue)) (prog1 (car (q-head q)) (if (not (empty-p q)) (setf (q-head q) (cdr (q-head q)))) (if (null (q-head q)) (progn (setf (q-head q) nil) (setf (q-tail q) nil))))) (defun iter (rc ic max) (declare (double-float rc ic) (fixnum max)) (do ((x 0.0d0 (the double-float (+ (- (* x x) (* y y)) rc))) (y 0.0d0 (the double-float (+ (* 2.0d0 x y) ic))) (n 1 (the fixnum (1+ n)))) ((or (>= n max) (>= (+ (* x x) (* y y)) 4.0d0)) n))) ;;; (a+bi)^2 --> ;;; (a+bi)(a+bi) --> ;;; a^2+2abi+(bi)^2 --> ;;; a^2+2abi-b^2 (defclass zoomer () ((zoom-type :initarg :type :reader zoom-type :type fixnum) (start-x :initarg :x :reader start-x :type fixnum) (start-y :initarg :y :reader start-y :type fixnum) (stop-x :accessor stop-x :initform -1 :type fixnum) (stop-y :accessor stop-y :initform -1 :type fixnum) (win :reader win :initarg :win))) ;;;(defmethod print-object ((object zoomer) stream) ;;; (format stream " [~a ~a]>~%" ;;; (zoom-type object) (start-x object) (start-y object) ;;; (stop-x object) (stop-y object))) (defun init-colours () (unless *colmap* (setf *colmap* (make-array 256 :element-type 'xlib:gcontext :initial-element *zoomcolmap*)) (setf (aref *colmap* 0) (xlib:create-gcontext :drawable (xlib:screen-root *screen*) :foreground (xlib:alloc-color (xlib:screen-default-colormap *screen*) (xlib:make-color :red 0 :green 0 :blue 0)))) (loop for index from 1 to 255 do (setf (aref *colmap* index) (xlib:create-gcontext :drawable (xlib:screen-root *screen*) :foreground (xlib:alloc-color (xlib:screen-default-colormap *screen*) (xlib:make-color :red (random 1.0) :green (random 1.0) :blue (random 1.0)))))))) (defmacro modcol (col max) `(if (= ,col ,max) 0 (1+ (mod ,col 255)))) (defun plot (win col x y max) (declare (fixnum col x y max)) (let ((col (modcol col max))) (xlib:draw-point win (aref *colmap* col) x y) (setf (aref (the (simple-array (integer 0 255) (512 512)) (gethash win *backing-store*)) x y) col))) (defun display-help () (unless *helpwin* (setf *helpwin* (xlib:create-window :parent (xlib:screen-root *screen*) :x 512 :y 512 :width 310 :height 180 :event-mask (xlib:make-event-mask :exposure) :backing-store :always :background (xlib:screen-white-pixel *screen*))) (xlib:map-window *helpwin*) (xlib:display-force-output *display*)) (unless (xlib:gcontext-font *textmap*) (let ((fixed (xlib:list-fonts *display* "fixed")) font) (if fixed (setf font (xlib:open-font *display* "fixed")) (error "Could not open suitable font")) (setf (xlib:gcontext-font *textmap*) (if (consp fixed) (car fixed) fixed)))) (xlib:draw-rectangle *helpwin* *white* 0 0 (xlib:drawable-width *helpwin*) (xlib:drawable-height *helpwin*) t) (xlib:draw-glyphs *helpwin* *textmap* 10 13 "Button 1: Zoom same") (xlib:draw-glyphs *helpwin* *textmap* 10 33 "Button 2: Zoom new") (xlib:draw-glyphs *helpwin* *textmap* 10 53 "Button 3: Zoom out, same") (xlib:draw-glyphs *helpwin* *textmap* 10 93 "In general, click to zoom centred on mouse,") (xlib:draw-glyphs *helpwin* *textmap* 10 113 "drag to zoom a region.") (xlib:draw-glyphs *helpwin* *textmap* 10 153 "Q: quit") (xlib:display-force-output *display*)) (defun repaint-window (win x-low y-low x-high y-high) (declare (fixnum x-low y-low x-high y-high)) (if (eq win *helpwin*) (display-help) (let ((bs (the (simple-array (integer 0 255) (512 512)) (gethash win *backing-store*)))) (loop for y of-type fixnum from y-low to y-high do (loop for x of-type fixnum from x-low to x-high do (xlib:draw-point win (aref *colmap* (aref bs x y)) x y)))))) (defun fill-square (win col x y s max) (declare (fixnum col x y s max)) (let ((col (modcol col max))) (xlib:draw-rectangle win (aref *colmap* col) x y s s t) (let ((bs (the (simple-array (integer 0 255) (512 512)) (gethash win *backing-store*)))) (loop for px of-type fixnum from x to (1- (+ x s)) do (loop for py of-type fixnum from y to (1- (+ y s)) do (setf (aref bs px py) col)))))) (defun make-square (win x y side bx by dx dy &optional (maxiter 1024)) (declare (xlib:window win) (fixnum x y side maxiter) (double-float bx by dx dy)) (let ((sq (make-mandel-square :x x :y y :s side :base-r bx :base-i by :dr dx :di dy :maxiter maxiter :win win))) (queue-push *sysqueue* sq))) (defun mandel-win (win lx ly hx hy &optional (maxiter 1024)) (declare (xlib:window win) (double-float lx ly hx hy) (fixnum maxiter)) (let ((dx (coerce (/ (- hx lx) 512.0d0) 'double-float)) (dy (coerce (/ (- hy ly) 512.0d0) 'double-float))) (setf (gethash win *winmap*) (make-mandel-square :x 0 :y 0 :s 512 :base-r lx :base-i ly :dr dx :di dy :maxiter maxiter)) (make-square win 0 256 256 lx ly dx dy maxiter) (make-square win 256 256 256 lx ly dx dy maxiter) (make-square win 256 0 256 lx ly dx dy maxiter) (make-square win 0 0 256 lx ly dx dy maxiter))) (defun new-window (lx ly hx hy &optional (maxiter 1024)) (let ((win (xlib:create-window :parent (xlib:screen-root *screen*) :x (+ 100 (random 50)) :y (+ 100 (random 50)) :width 512 :height 512 :bit-gravity :center :event-mask (xlib:make-event-mask :button-motion :button-press :button-release :key-press :exposure))) (ar (make-array '(512 512) :element-type '(integer 0 255) :initial-element 0)) ) (setf (gethash win *backing-store*) ar) (xlib:map-window win) (mandel-win win (coerce lx 'double-float) (coerce ly 'double-float) (coerce hx 'double-float) (coerce hy 'double-float) maxiter))) (defun fill-square-p (ix iy s bx by dx dy max win) (declare (fixnum ix iy s max) (double-float bx by dx dy)) (let ((norm (iter (+ bx (* ix dx)) (+ by (* iy dy)) max))) (and (loop for px from ix below (+ ix s) for x of-type double-float = (+ bx (* px dx)) with y = (+ by (* iy dy)) for i = (iter x y max) do (plot win i px iy max) while (= i norm) finally (return t)) (loop for py from iy below (+ s iy) for y of-type double-float = (+ by (* py dy)) with x = (+ bx (* ix dx)) for i = (iter x y max) do (plot win i ix py max) while (= i norm) finally (return t)) (loop for px from (1- (+ s ix)) downto ix for x of-type double-float = (+ bx (* px dx)) with y = (+ by (* dy (1- (+ s iy)))) for i = (iter x y max) do (plot win i px iy max) if (/= i norm) return nil finally (return t)) (loop for py from (1- (+ s iy)) downto iy for y of-type double-float = (+ by (* py dy)) with x = (+ bx (* dx (1- (+ s ix)))) for i = (iter x y max) do (plot win i ix py max) if (/= i norm) return nil finally (return t))))) (defmacro z (base delta int) `(+ ,base (* ,delta ,int))) (defun draw-square (square) (declare (mandel-square square)) (let ((dx (ms-dr square)) (dy (ms-di square)) (base-x (ms-base-r square)) (base-y (ms-base-i square)) (maxiter (ms-maxiter square)) (win (ms-win square)) (x (ms-x square)) (y (ms-y square)) (s (ms-s square)) ) (declare (double-float dx dy base-x base-y) (fixnum x y s maxiter)) (cond ((= s 2) (plot win (iter (z base-x dx (1+ x)) (z base-y dy (1+ y)) maxiter) (1+ x) (1+ y) maxiter) (plot win (iter (z base-x dx (1+ x)) (z base-y dy y) maxiter) (1+ x) y maxiter) (plot win (iter (z base-x dx x) (z base-y dy (1+ y)) maxiter) x (1+ y) maxiter) (plot win (iter (z base-x dx x) (z base-y dy y) maxiter) x y maxiter)) ((fill-square-p x y s base-x base-y dx dy maxiter win) (fill-square win (iter (z base-x dx x) (z base-y dy y) maxiter) x y s maxiter)) (t (let ((new-s (/ s 2))) (make-square win x y new-s base-x base-y dx dy maxiter) (make-square win x (+ y new-s) new-s base-x base-y dx dy maxiter) (make-square win (+ x new-s) y new-s base-x base-y dx dy maxiter) (make-square win (+ x new-s) (+ y new-s) new-s base-x base-y dx dy maxiter)))))) (defun create-zoom (win x y button) (setf (gethash win *zoom-table*) (make-instance 'zoomer :x x :y y :win win :type (case button (1 :zoom-same) (2 :zoom-new) (3 :zoom-out))))) (defun update-zoom (win x y code) (declare (ignore code) (fixnum x y)) (let ((zoomer (gethash win *zoom-table*))) (when zoomer (let ((new-side (max 0 (- (the fixnum x) (the fixnum (start-x zoomer))) (- (the fixnum y) (the fixnum (start-y zoomer)))))) (let ((old-side (max 0 (- (the fixnum (stop-x zoomer)) (the fixnum (start-x zoomer))) (- (the fixnum (stop-y zoomer)) (the fixnum (start-y zoomer)))))) (xlib:draw-rectangle win *zoomcolmap* (the fixnum (start-x zoomer)) (the fixnum (start-y zoomer)) old-side old-side)) (setf (stop-x zoomer) (max (the fixnum (start-x zoomer)) (the fixnum x) )) (setf (stop-y zoomer) (max (the fixnum (start-y zoomer)) (the fixnum y) )) (xlib:draw-rectangle win *zoomcolmap* (the fixnum (start-x zoomer)) (the fixnum (start-y zoomer)) new-side new-side) (xlib:display-force-output *display*))))) (defun finish-zoom (win x y code) (declare (ignore code)) (let ((zoomer (gethash win *zoom-table*))) (setf (stop-x zoomer) x) (setf (stop-y zoomer) y))) (defun do-zoom (win) (let ((zoomer (gethash win *zoom-table*))) (declare (zoomer zoomer)) (setf (gethash win *zoom-table*) nil) (let ((dx (- (the fixnum (stop-x zoomer)) (the fixnum (start-x zoomer)))) (dy (- (the fixnum (stop-y zoomer)) (the fixnum (start-y zoomer)))) (sq (gethash win *winmap*))) (let ((side (max dx dy)) (x (the fixnum (start-x zoomer))) (y (the fixnum (start-y zoomer))) lx hx ly hy ) (if (< side 5) (setf lx (+ (ms-base-r sq) (* (- x 128) (ms-dr sq))) ly (+ (ms-base-i sq) (* (- y 128) (ms-di sq))) hx (+ (ms-base-r sq) (* (+ x 128) (ms-dr sq))) hy (+ (ms-base-i sq) (* (+ y 128) (ms-di sq)))) (setf lx (+ (ms-base-r sq) (* x (ms-dr sq))) ly (+ (ms-base-i sq) (* y (ms-dr sq))) hx (+ (ms-base-r sq) (* (+ side x) (ms-dr sq))) hy (+ (ms-base-i sq) (* (+ side y) (ms-dr sq))))) ;;; (format t "DEBUG: zoomer is ~a~%~%" zoomer) (case (zoom-type zoomer) (:zoom-new (new-window lx ly hx hy (ms-maxiter sq))) (:zoom-same (empty-win *sysqueue* win) (mandel-win win lx ly hx hy (ms-maxiter sq))) (:zoom-out (empty-win *sysqueue* win) (let ((br (ms-base-r sq)) (bi (ms-base-i sq)) (dr (ms-dr sq)) (di (ms-di sq))) (mandel-win win (- br (* 512 dr)) (- bi (* 512 di)) (+ (* 1024 dr) br) (+ (* 1024 di) bi) (ms-maxiter sq)))) (t (format t "Unknown/unimplemented zoom type ~a~%~%" (zoom-type zoomer)))))))) (defun quit-window (window) (let ((temp (gethash window (win-queues *sysqueue*)))) (when temp (empty temp)))) (defun event-loop () (init-colours) (do ((quit nil) (redisplay nil t)) ((eq quit 'quit)) (xlib:event-case (*display* :timeout 0) (:button-press (window x y code) (create-zoom window x y code) t) (:button-release (window x y code) (finish-zoom window x y code) (do-zoom window) t) (:motion-notify (window x y code) (update-zoom window x y code) t) (:exposure (window x y width height count) (let ((count count)) (declare (ignore count) (fixnum x y width height)) (when redisplay (repaint-window window x y (1- (+ x width)) (1- (+ y height))))) t) (:key-press (window code) (case (xlib:keysym->character *display* (xlib:keycode->keysym *display* code (make-shift-foo))) (#\q (quit-window window)) (#\? (display-help)) ((:left-shift :right-shift) (push :shift *modstate*)) ((:left-control :right-control) (push :ctrl *modstate*)) (:character-set-switch (push :character-set-switch *modstate*))) t) (:key-release (window code) (let ((window window)) (declare (ignore window)) (case (xlib:keysym->character *display* (xlib:keycode->keysym *display* code 0)) (:character-set-switch (setf *modstate* (delete :character-set-switch *modstate*))) ((:left-control :right-control) (setf *modstate* (delete :ctrl *modstate*))) ((:left-shift :right-shift) (setf *modstate* (delete :shift *modstate*))))) t)) (cond ((empty-p *sysqueue*) nil) (t (let ((square (dequeue *sysqueue*))) (draw-square square)))))) ecl-16.1.2/src/clx/demo/menu.lisp000066400000000000000000000363041266352375300165240ustar00rootroot00000000000000;;; -*- Mode:Lisp; Syntax: Common-lisp; Package:XLIB; Base:10; Lowercase: Yes -*- ;;; ;;; TEXAS INSTRUMENTS INCORPORATED ;;; P.O. BOX 2909 ;;; AUSTIN, TEXAS 78769 ;;; ;;; Copyright (C) 1988 Texas Instruments Incorporated. ;;; ;;; Permission is granted to any individual or institution to use, copy, modify, ;;; and distribute this software, provided that this complete copyright and ;;; permission notice is maintained, intact, in all copies and supporting ;;; documentation. ;;; ;;; Texas Instruments Incorporated provides this software "as is" without ;;; express or implied warranty. ;;; (in-package :xlib) ;;;----------------------------------------------------------------------------------+ ;;; | ;;; These functions demonstrate a simple menu implementation described in | ;;; Kimbrough, Kerry, "Windows to the Future", Lisp Pointers, Oct-Nov, 1987. | ;;; See functions JUST-SAY-LISP and POP-UP for demonstrations. | ;;; | ;;;----------------------------------------------------------------------------------+ (defstruct (menu) "A simple menu of text strings." (title "choose an item:") item-alist ;((item-window item-string)) window gcontext width title-width item-width item-height (geometry-changed-p t)) ;nil iff unchanged since displayed (defun create-menu (parent-window text-color background-color text-font) (make-menu ;; Create menu graphics context :gcontext (CREATE-GCONTEXT :drawable parent-window :foreground text-color :background background-color :font text-font) ;; Create menu window :window (CREATE-WINDOW :parent parent-window :class :input-output :x 0 ;temporary value :y 0 ;temporary value :width 16 ;temporary value :height 16 ;temporary value :border-width 2 :border text-color :background background-color :save-under :on :override-redirect :on ;override window mgr when positioning :event-mask (MAKE-EVENT-MASK :leave-window :exposure)))) (defun menu-set-item-list (menu &rest item-strings) ;; Assume the new items will change the menu's width and height (setf (menu-geometry-changed-p menu) t) ;; Destroy any existing item windows (dolist (item (menu-item-alist menu)) (DESTROY-WINDOW (first item))) ;; Add (item-window item-string) elements to item-alist (setf (menu-item-alist menu) (let (alist) (dolist (item item-strings (nreverse alist)) (push (list (CREATE-WINDOW :parent (menu-window menu) :x 0 ;temporary value :y 0 ;temporary value :width 16 ;temporary value :height 16 ;temporary value :background (GCONTEXT-BACKGROUND (menu-gcontext menu)) :event-mask (MAKE-EVENT-MASK :enter-window :leave-window :button-press :button-release)) item) alist))))) (defparameter *menu-item-margin* 4 "Minimum number of pixels surrounding menu items.") (defun menu-recompute-geometry (menu) (when (menu-geometry-changed-p menu) (let* ((menu-font (GCONTEXT-FONT (menu-gcontext menu))) (title-width (TEXT-EXTENTS menu-font (menu-title menu))) (item-height (+ (FONT-ASCENT menu-font) (FONT-DESCENT menu-font))) (item-width 0) (items (menu-item-alist menu)) menu-width) ;; Find max item string width (dolist (next-item items) (setf item-width (max item-width (TEXT-EXTENTS menu-font (second next-item))))) ;; Compute final menu width, taking margins into account (setf menu-width (max title-width (+ item-width *menu-item-margin* *menu-item-margin*))) (let ((window (menu-window menu)) (delta-y (+ item-height *menu-item-margin*))) ;; Update width and height of menu window (WITH-STATE (window) (setf (DRAWABLE-WIDTH window) menu-width (DRAWABLE-HEIGHT window) (+ *menu-item-margin* (* (1+ (length items)) delta-y)))) ;; Update width, height, position of item windows (let ((item-left (round (- menu-width item-width) 2)) (next-item-top delta-y)) (dolist (next-item items) (let ((window (first next-item))) (WITH-STATE (window) (setf (DRAWABLE-HEIGHT window) item-height (DRAWABLE-WIDTH window) item-width (DRAWABLE-X window) item-left (DRAWABLE-Y window) next-item-top))) (incf next-item-top delta-y)))) ;; Map all item windows (MAP-SUBWINDOWS (menu-window menu)) ;; Save item geometry (setf (menu-item-width menu) item-width (menu-item-height menu) item-height (menu-width menu) menu-width (menu-title-width menu) title-width (menu-geometry-changed-p menu) nil)))) (defun menu-refresh (menu) (let* ((gcontext (menu-gcontext menu)) (baseline-y (FONT-ASCENT (GCONTEXT-FONT gcontext)))) ;; Show title centered in "reverse-video" (let ((fg (GCONTEXT-BACKGROUND gcontext)) (bg (GCONTEXT-FOREGROUND gcontext))) (WITH-GCONTEXT (gcontext :foreground fg :background bg) (DRAW-IMAGE-GLYPHS (menu-window menu) gcontext (round (- (menu-width menu) (menu-title-width menu)) 2) ;start x baseline-y ;start y (menu-title menu)))) ;; Show each menu item (position is relative to item window) (dolist (item (menu-item-alist menu)) (DRAW-IMAGE-GLYPHS (first item) gcontext 0 ;start x baseline-y ;start y (second item))))) (defun menu-choose (menu x y) ;; Display the menu so that first item is at x,y. (menu-present menu x y) (let ((items (menu-item-alist menu)) (mw (menu-window menu)) selected-item) ;; Event processing loop (do () (selected-item) (EVENT-CASE ((DRAWABLE-DISPLAY mw) :force-output-p t) (:exposure (count) ;; Discard all but final :exposure then display the menu (when (zerop count) (menu-refresh menu)) t) (:button-release (event-window) ;;Select an item (setf selected-item (second (assoc event-window items))) t) (:enter-notify (window) ;;Highlight an item (let ((position (position window items :key #'first))) (when position (menu-highlight-item menu position))) t) (:leave-notify (window kind) (if (eql mw window) ;; Quit if pointer moved out of main menu window (setf selected-item (when (eq kind :ancestor) :none)) ;; Otherwise, unhighlight the item window left (let ((position (position window items :key #'first))) (when position (menu-unhighlight-item menu position)))) t) (otherwise () ;;Ignore and discard any other event t))) ;; Erase the menu (UNMAP-WINDOW mw) ;; Return selected item string, if any (unless (eq selected-item :none) selected-item))) (defun menu-highlight-item (menu position) (let* ((box-margin (round *menu-item-margin* 2)) (left (- (round (- (menu-width menu) (menu-item-width menu)) 2) box-margin)) (top (- (* (+ *menu-item-margin* (menu-item-height menu)) (1+ position)) box-margin)) (width (+ (menu-item-width menu) box-margin box-margin)) (height (+ (menu-item-height menu) box-margin box-margin))) ;; Draw a box in menu window around the given item. (DRAW-RECTANGLE (menu-window menu) (menu-gcontext menu) left top width height))) (defun menu-unhighlight-item (menu position) ;; Draw a box in the menu background color (let ((gcontext (menu-gcontext menu))) (WITH-GCONTEXT (gcontext :foreground (gcontext-background gcontext)) (menu-highlight-item menu position)))) (defun menu-present (menu x y) ;; Make sure menu geometry is up-to-date (menu-recompute-geometry menu) ;; Try to center first item at the given location, but ;; make sure menu is completely visible in its parent (let ((menu-window (menu-window menu))) (multiple-value-bind (tree parent) (QUERY-TREE menu-window) (declare (ignore tree)) (WITH-STATE (parent) (let* ((parent-width (DRAWABLE-WIDTH parent)) (parent-height (DRAWABLE-HEIGHT parent)) (menu-height (+ *menu-item-margin* (* (1+ (length (menu-item-alist menu))) (+ (menu-item-height menu) *menu-item-margin*)))) (menu-x (max 0 (min (- parent-width (menu-width menu)) (- x (round (menu-width menu) 2))))) (menu-y (max 0 (min (- parent-height menu-height) (- y (round (menu-item-height menu) 2/3) *menu-item-margin*))))) (WITH-STATE (menu-window) (setf (DRAWABLE-X menu-window) menu-x (DRAWABLE-Y menu-window) menu-y))))) ;; Make menu visible (MAP-WINDOW menu-window))) (defun just-say-lisp (&optional (font-name "fixed")) (let* ((display (open-default-display)) (screen (first (DISPLAY-ROOTS display))) (fg-color (SCREEN-BLACK-PIXEL screen)) (bg-color (SCREEN-WHITE-PIXEL screen)) (nice-font (OPEN-FONT display font-name)) (a-menu (create-menu (screen-root screen) ;the menu's parent fg-color bg-color nice-font))) (setf (menu-title a-menu) "Please pick your favorite language:") (menu-set-item-list a-menu "Fortran" "APL" "Forth" "Lisp") ;; Bedevil the user until he picks a nice programming language (unwind-protect (do (choice) ((and (setf choice (menu-choose a-menu 100 100)) (string-equal "Lisp" choice)))) (CLOSE-DISPLAY display)))) (defun pop-up (host strings &key (title "Pick one:") (font "fixed")) (let* ((display (OPEN-DISPLAY host)) (screen (first (DISPLAY-ROOTS display))) (fg-color (SCREEN-BLACK-PIXEL screen)) (bg-color (SCREEN-WHITE-PIXEL screen)) (font (OPEN-FONT display font)) (parent-width 400) (parent-height 400) (parent (CREATE-WINDOW :parent (SCREEN-ROOT screen) :override-redirect :on :x 100 :y 100 :width parent-width :height parent-height :background bg-color :event-mask (MAKE-EVENT-MASK :button-press :exposure))) (a-menu (create-menu parent fg-color bg-color font)) (prompt "Press a button...") (prompt-gc (CREATE-GCONTEXT :drawable parent :foreground fg-color :background bg-color :font font)) (prompt-y (FONT-ASCENT font)) (ack-y (- parent-height (FONT-DESCENT font)))) (setf (menu-title a-menu) title) (apply #'menu-set-item-list a-menu strings) ;; Present main window (MAP-WINDOW parent) (flet ((display-centered-text (window string gcontext height width) (multiple-value-bind (w a d l r fa fd) (text-extents gcontext string) (declare (ignore a d l r)) (let ((box-height (+ fa fd))) ;; Clear previous text (CLEAR-AREA window :x 0 :y (- height fa) :width width :height box-height) ;; Draw new text (DRAW-IMAGE-GLYPHS window gcontext (round (- width w) 2) height string))))) (unwind-protect (loop (EVENT-CASE (display :force-output-p t) (:exposure (count) ;; Display prompt (when (zerop count) (display-centered-text parent prompt prompt-gc prompt-y parent-width)) t) (:button-press (x y) ;; Pop up the menu (let ((choice (menu-choose a-menu x y))) (if choice (display-centered-text parent (format nil "You have selected ~a." choice) prompt-gc ack-y parent-width) (display-centered-text parent "No selection...try again." prompt-gc ack-y parent-width))) t) (otherwise () ;;Ignore and discard any other event t))) (CLOSE-DISPLAY display))))) ecl-16.1.2/src/clx/demo/zoid.lisp000066400000000000000000000042041266352375300165170ustar00rootroot00000000000000;;; -*- Mode:Lisp; Package:XLIB; Syntax:COMMON-LISP; Base:10; Lowercase:T -*- ;;; CLX interface for Trapezoid Extension. ;;; ;;; TEXAS INSTRUMENTS INCORPORATED ;;; P.O. BOX 2909 ;;; AUSTIN, TEXAS 78769 ;;; ;;; Copyright (C) 1987 Texas Instruments Incorporated. ;;; ;;; Permission is granted to any individual or institution to use, copy, modify, ;;; and distribute this software, provided that this complete copyright and ;;; permission notice is maintained, intact, in all copies and supporting ;;; documentation. ;;; ;;; Texas Instruments Incorporated provides this software "as is" without ;;; express or implied warranty. ;;; (in-package :xlib) (export '(draw-filled-trapezoids gcontext-trapezoid-alignment ;; Setf'able )) (define-extension "ZoidExtension") (defun draw-filled-trapezoids (drawable gcontext points) ;; Draw trapezoids on drawable using gcontext. ;; Points are a list of either (y1 y2 y3 y4 x1 x2) ;; x-aligned ;; or (x1 x2 x3 x4 y1 y2) ;; y-aligned ;; Alignment is determined by the GCONTEXT [see gcontext-trapezoid-alignment] ;; Alignment is set with the ALIGNMENT keyword argument, which may be ;; :X, :Y, or NIL (use previous alignment) (declare (type drawable drawable) (type gcontext gcontext) (type sequence points)) (let* ((display (drawable-display drawable)) (opcode (extension-opcode display "ZoidExtension"))) (with-buffer-request (display opcode :gc-force gcontext) ((data card8) 1) ;; X_PolyFillZoid (drawable drawable) (gcontext gcontext) ((sequence :format int16) points)))) (define-gcontext-accessor trapezoid-alignment :default :x :set-function set-trapezoid-alignment) (defun set-trapezoid-alignment (gcontext alignment) (declare (type (member :x :y) alignment)) (let* ((display (gcontext-display gcontext)) (opcode (extension-opcode display "ZoidExtension"))) (with-buffer-request (display opcode) ((data card8) 2) ;; X_SetZoidAlignment (gcontext gcontext) ((member8 %error :x :y) alignment)))) ecl-16.1.2/src/clx/dep-allegro.lisp000066400000000000000000002622161266352375300170320ustar00rootroot00000000000000;;; -*- Mode: Lisp; Package: Xlib; Log: clx.log -*- ;; This file contains some of the system dependent code for CLX ;;; ;;; TEXAS INSTRUMENTS INCORPORATED ;;; P.O. BOX 2909 ;;; AUSTIN, TEXAS 78769 ;;; ;;; Copyright (C) 1987 Texas Instruments Incorporated. ;;; ;;; Permission is granted to any individual or institution to use, copy, modify, ;;; and distribute this software, provided that this complete copyright and ;;; permission notice is maintained, intact, in all copies and supporting ;;; documentation. ;;; ;;; Texas Instruments Incorporated provides this software "as is" without ;;; express or implied warranty. ;;; (in-package :xlib) (proclaim '(declaration array-register)) ;;; The size of the output buffer. Must be a multiple of 4. (defparameter *output-buffer-size* 8192) ;;; Number of seconds to wait for a reply to a server request (defparameter *reply-timeout* nil) #-(or clx-overlapping-arrays (not clx-little-endian)) (progn (defconstant +word-0+ 0) (defconstant +word-1+ 1) (defconstant +long-0+ 0) (defconstant +long-1+ 1) (defconstant +long-2+ 2) (defconstant +long-3+ 3)) #-(or clx-overlapping-arrays clx-little-endian) (progn (defconstant +word-0+ 1) (defconstant +word-1+ 0) (defconstant +long-0+ 3) (defconstant +long-1+ 2) (defconstant +long-2+ 1) (defconstant +long-3+ 0)) ;;; Set some compiler-options for often used code (eval-when (:compile-toplevel :load-toplevel :execute) (defconstant +buffer-speed+ #+clx-debugging 1 #-clx-debugging 3 "Speed compiler option for buffer code.") (defconstant +buffer-safety+ #+clx-debugging 3 #-clx-debugging 0 "Safety compiler option for buffer code.") (defconstant +buffer-debug+ #+clx-debugging 2 #-clx-debugging 1 "Debug compiler option for buffer code>") (defun declare-bufmac () `(declare (optimize (speed ,+buffer-speed+) (safety ,+buffer-safety+) (debug ,+buffer-debug+)))) ;; It's my impression that in lucid there's some way to make a ;; declaration called fast-entry or something that causes a function ;; to not do some checking on args. Sadly, we have no lucid manuals ;; here. If such a declaration is available, it would be a good ;; idea to make it here when +buffer-speed+ is 3 and +buffer-safety+ ;; is 0. (defun declare-buffun () `(declare (optimize (speed ,+buffer-speed+) (safety ,+buffer-safety+) (debug ,+buffer-debug+))))) (declaim (inline card8->int8 int8->card8 card16->int16 int16->card16 card32->int32 int32->card32)) #-Genera (progn (defun card8->int8 (x) (declare (type card8 x)) (declare (clx-values int8)) #.(declare-buffun) (the int8 (if (logbitp 7 x) (the int8 (- x #x100)) x))) (defun int8->card8 (x) (declare (type int8 x)) (declare (clx-values card8)) #.(declare-buffun) (the card8 (ldb (byte 8 0) x))) (defun card16->int16 (x) (declare (type card16 x)) (declare (clx-values int16)) #.(declare-buffun) (the int16 (if (logbitp 15 x) (the int16 (- x #x10000)) x))) (defun int16->card16 (x) (declare (type int16 x)) (declare (clx-values card16)) #.(declare-buffun) (the card16 (ldb (byte 16 0) x))) (defun card32->int32 (x) (declare (type card32 x)) (declare (clx-values int32)) #.(declare-buffun) (the int32 (if (logbitp 31 x) (the int32 (- x #x100000000)) x))) (defun int32->card32 (x) (declare (type int32 x)) (declare (clx-values card32)) #.(declare-buffun) (the card32 (ldb (byte 32 0) x))) ) (declaim (inline aref-card8 aset-card8 aref-int8 aset-int8)) #+(or excl lcl3.0 clx-overlapping-arrays) (declaim (inline aref-card16 aref-int16 aref-card32 aref-int32 aref-card29 aset-card16 aset-int16 aset-card32 aset-int32 aset-card29)) #+(and clx-overlapping-arrays (not Genera)) (progn (defun aref-card16 (a i) (aref a i)) (defun aset-card16 (v a i) (setf (aref a i) v)) (defun aref-int16 (a i) (card16->int16 (aref a i))) (defun aset-int16 (v a i) (setf (aref a i) (int16->card16 v)) v) (defun aref-card32 (a i) (aref a i)) (defun aset-card32 (v a i) (setf (aref a i) v)) (defun aref-int32 (a i) (card32->int32 (aref a i))) (defun aset-int32 (v a i) (setf (aref a i) (int32->card32 v)) v) (defun aref-card29 (a i) (aref a i)) (defun aset-card29 (v a i) (setf (aref a i) v)) ) #+excl (progn (defun aref-card8 (a i) (declare (type buffer-bytes a) (type array-index i)) (declare (clx-values card8)) #.(declare-buffun) (the card8 (sys:memref a #.(sys::mdparam 'comp::md-lvector-data0-norm) i :unsigned-byte))) (defun aset-card8 (v a i) (declare (type card8 v) (type buffer-bytes a) (type array-index i)) #.(declare-buffun) (setf (sys:memref a #.(sys::mdparam 'comp::md-lvector-data0-norm) i :unsigned-byte) v)) (defun aref-int8 (a i) (declare (type buffer-bytes a) (type array-index i)) (declare (clx-values int8)) #.(declare-buffun) (the int8 (sys:memref a #.(sys::mdparam 'comp::md-lvector-data0-norm) i :signed-byte))) (defun aset-int8 (v a i) (declare (type int8 v) (type buffer-bytes a) (type array-index i)) #.(declare-buffun) (setf (sys:memref a #.(sys::mdparam 'comp::md-lvector-data0-norm) i :signed-byte) v)) (defun aref-card16 (a i) (declare (type buffer-bytes a) (type array-index i)) (declare (clx-values card16)) #.(declare-buffun) (the card16 (sys:memref a #.(sys::mdparam 'comp::md-lvector-data0-norm) i :unsigned-word))) (defun aset-card16 (v a i) (declare (type card16 v) (type buffer-bytes a) (type array-index i)) #.(declare-buffun) (setf (sys:memref a #.(sys::mdparam 'comp::md-lvector-data0-norm) i :unsigned-word) v)) (defun aref-int16 (a i) (declare (type buffer-bytes a) (type array-index i)) (declare (clx-values int16)) #.(declare-buffun) (the int16 (sys:memref a #.(sys::mdparam 'comp::md-lvector-data0-norm) i :signed-word))) (defun aset-int16 (v a i) (declare (type int16 v) (type buffer-bytes a) (type array-index i)) #.(declare-buffun) (setf (sys:memref a #.(sys::mdparam 'comp::md-lvector-data0-norm) i :signed-word) v)) (defun aref-card32 (a i) (declare (type buffer-bytes a) (type array-index i)) (declare (clx-values card32)) #.(declare-buffun) (the card32 (sys:memref a #.(sys::mdparam 'comp::md-lvector-data0-norm) i :unsigned-long))) (defun aset-card32 (v a i) (declare (type card32 v) (type buffer-bytes a) (type array-index i)) #.(declare-buffun) (setf (sys:memref a #.(sys::mdparam 'comp::md-lvector-data0-norm) i :unsigned-long) v)) (defun aref-int32 (a i) (declare (type buffer-bytes a) (type array-index i)) (declare (clx-values int32)) #.(declare-buffun) (the int32 (sys:memref a #.(sys::mdparam 'comp::md-lvector-data0-norm) i :signed-long))) (defun aset-int32 (v a i) (declare (type int32 v) (type buffer-bytes a) (type array-index i)) #.(declare-buffun) (setf (sys:memref a #.(sys::mdparam 'comp::md-lvector-data0-norm) i :signed-long) v)) (defun aref-card29 (a i) (declare (type buffer-bytes a) (type array-index i)) (declare (clx-values card29)) #.(declare-buffun) (the card29 (sys:memref a #.(sys::mdparam 'comp::md-lvector-data0-norm) i :unsigned-long))) (defun aset-card29 (v a i) (declare (type card29 v) (type buffer-bytes a) (type array-index i)) #.(declare-buffun) (setf (sys:memref a #.(sys::mdparam 'comp::md-lvector-data0-norm) i :unsigned-long) v)) ) (defsetf aref-card8 (a i) (v) `(aset-card8 ,v ,a ,i)) (defsetf aref-int8 (a i) (v) `(aset-int8 ,v ,a ,i)) (defsetf aref-card16 (a i) (v) `(aset-card16 ,v ,a ,i)) (defsetf aref-int16 (a i) (v) `(aset-int16 ,v ,a ,i)) (defsetf aref-card32 (a i) (v) `(aset-card32 ,v ,a ,i)) (defsetf aref-int32 (a i) (v) `(aset-int32 ,v ,a ,i)) (defsetf aref-card29 (a i) (v) `(aset-card29 ,v ,a ,i)) ;;; Other random conversions (defun rgb-val->card16 (value) ;; Short floats are good enough (declare (type rgb-val value)) (declare (clx-values card16)) #.(declare-buffun) ;; Convert VALUE from float to card16 (the card16 (values (round (the rgb-val value) #.(/ 1.0s0 #xffff))))) (defun card16->rgb-val (value) ;; Short floats are good enough (declare (type card16 value)) (declare (clx-values short-float)) #.(declare-buffun) ;; Convert VALUE from card16 to float (the short-float (* (the card16 value) #.(/ 1.0s0 #xffff)))) (defun radians->int16 (value) ;; Short floats are good enough (declare (type angle value)) (declare (clx-values int16)) #.(declare-buffun) (the int16 (values (round (the angle value) #.(float (/ pi 180.0s0 64.0s0) 0.0s0))))) (defun int16->radians (value) ;; Short floats are good enough (declare (type int16 value)) (declare (clx-values short-float)) #.(declare-buffun) (the short-float (* (the int16 value) #.(coerce (/ pi 180.0 64.0) 'short-float)))) #+(or cmu sbcl) (progn ;;; This overrides the (probably incorrect) definition in clx.lisp. Since PI ;;; is irrational, there can't be a precise rational representation. In ;;; particular, the different float approximations will always be /=. This ;;; causes problems with type checking, because people might compute an ;;; argument in any precision. What we do is discard all the excess precision ;;; in the value, and see if the protocol encoding falls in the desired range ;;; (64'ths of a degree.) ;;; (deftype angle () '(satisfies anglep)) (defun anglep (x) (and (typep x 'real) (<= (* -360 64) (radians->int16 x) (* 360 64)))) ) ;;----------------------------------------------------------------------------- ;; Character transformation ;;----------------------------------------------------------------------------- ;;; This stuff transforms chars to ascii codes in card8's and back. ;;; You might have to hack it a little to get it to work for your machine. (declaim (inline char->card8 card8->char)) (macrolet ((char-translators () (let ((alist `(#-lispm ;; The normal ascii codes for the control characters. ,@`((#\Return . 13) (#\Linefeed . 10) (#\Rubout . 127) (#\Page . 12) (#\Tab . 9) (#\Backspace . 8) (#\Newline . 10) (#\Space . 32)) ;; One the lispm, #\Newline is #\Return, but we'd really like ;; #\Newline to translate to ascii code 10, so we swap the ;; Ascii codes for #\Return and #\Linefeed. We also provide ;; mappings from the counterparts of these control characters ;; so that the character mapping from the lisp machine ;; character set to ascii is invertible. #+lispm ,@`((#\Return . 10) (,(code-char 10) . ,(char-code #\Return)) (#\Linefeed . 13) (,(code-char 13) . ,(char-code #\Linefeed)) (#\Rubout . 127) (,(code-char 127) . ,(char-code #\Rubout)) (#\Page . 12) (,(code-char 12) . ,(char-code #\Page)) (#\Tab . 9) (,(code-char 9) . ,(char-code #\Tab)) (#\Backspace . 8) (,(code-char 8) . ,(char-code #\Backspace)) (#\Newline . 10) (,(code-char 10) . ,(char-code #\Newline)) (#\Space . 32) (,(code-char 32) . ,(char-code #\Space))) ;; The rest of the common lisp charater set with the normal ;; ascii codes for them. (#\! . 33) (#\" . 34) (#\# . 35) (#\$ . 36) (#\% . 37) (#\& . 38) (#\' . 39) (#\( . 40) (#\) . 41) (#\* . 42) (#\+ . 43) (#\, . 44) (#\- . 45) (#\. . 46) (#\/ . 47) (#\0 . 48) (#\1 . 49) (#\2 . 50) (#\3 . 51) (#\4 . 52) (#\5 . 53) (#\6 . 54) (#\7 . 55) (#\8 . 56) (#\9 . 57) (#\: . 58) (#\; . 59) (#\< . 60) (#\= . 61) (#\> . 62) (#\? . 63) (#\@ . 64) (#\A . 65) (#\B . 66) (#\C . 67) (#\D . 68) (#\E . 69) (#\F . 70) (#\G . 71) (#\H . 72) (#\I . 73) (#\J . 74) (#\K . 75) (#\L . 76) (#\M . 77) (#\N . 78) (#\O . 79) (#\P . 80) (#\Q . 81) (#\R . 82) (#\S . 83) (#\T . 84) (#\U . 85) (#\V . 86) (#\W . 87) (#\X . 88) (#\Y . 89) (#\Z . 90) (#\[ . 91) (#\\ . 92) (#\] . 93) (#\^ . 94) (#\_ . 95) (#\` . 96) (#\a . 97) (#\b . 98) (#\c . 99) (#\d . 100) (#\e . 101) (#\f . 102) (#\g . 103) (#\h . 104) (#\i . 105) (#\j . 106) (#\k . 107) (#\l . 108) (#\m . 109) (#\n . 110) (#\o . 111) (#\p . 112) (#\q . 113) (#\r . 114) (#\s . 115) (#\t . 116) (#\u . 117) (#\v . 118) (#\w . 119) (#\x . 120) (#\y . 121) (#\z . 122) (#\{ . 123) (#\| . 124) (#\} . 125) (#\~ . 126)))) (cond ((dolist (pair alist nil) (when (not (= (char-code (car pair)) (cdr pair))) (return t))) `(progn (defconstant *char-to-card8-translation-table* ',(let ((array (make-array (let ((max-char-code 255)) (dolist (pair alist) (setq max-char-code (max max-char-code (char-code (car pair))))) (1+ max-char-code)) :element-type 'card8))) (dotimes (i (length array)) (setf (aref array i) (mod i 256))) (dolist (pair alist) (setf (aref array (char-code (car pair))) (cdr pair))) array)) (defconstant *card8-to-char-translation-table* ',(let ((array (make-array 256))) (dotimes (i (length array)) (setf (aref array i) (code-char i))) (dolist (pair alist) (setf (aref array (cdr pair)) (car pair))) array)) #-Genera (progn (defun char->card8 (char) (declare (type base-char char)) #.(declare-buffun) (the card8 (aref (the (simple-array card8 (*)) *char-to-card8-translation-table*) (the array-index (char-code char))))) (defun card8->char (card8) (declare (type card8 card8)) #.(declare-buffun) (the base-char (or (aref (the simple-vector *card8-to-char-translation-table*) card8) (error "Invalid CHAR code ~D." card8)))) ) #+Genera (progn (defun char->card8 (char) (declare lt:(side-effects reader reducible)) (aref *char-to-card8-translation-table* (char-code char))) (defun card8->char (card8) (declare lt:(side-effects reader reducible)) (aref *card8-to-char-translation-table* card8)) ) #-Minima (dotimes (i 256) (unless (= i (char->card8 (card8->char i))) (warn "The card8->char mapping is not invertible through char->card8. Info:~%~S" (list i (card8->char i) (char->card8 (card8->char i)))) (return nil))) #-Minima (dotimes (i (length *char-to-card8-translation-table*)) (let ((char (code-char i))) (unless (eql char (card8->char (char->card8 char))) (warn "The char->card8 mapping is not invertible through card8->char. Info:~%~S" (list char (char->card8 char) (card8->char (char->card8 char)))) (return nil)))))) (t `(progn (defun char->card8 (char) (declare (type base-char char)) #.(declare-buffun) (the card8 (char-code char))) (defun card8->char (card8) (declare (type card8 card8)) #.(declare-buffun) (the base-char (code-char card8))) )))))) (char-translators)) ;;----------------------------------------------------------------------------- ;; Process Locking ;; ;; Common-Lisp doesn't provide process locking primitives, so we define ;; our own here, based on Zetalisp primitives. Holding-Lock is very ;; similar to with-lock on The TI Explorer, and a little more efficient ;; than with-process-lock on a Symbolics. ;;----------------------------------------------------------------------------- ;;; MAKE-PROCESS-LOCK: Creating a process lock. #+excl (defun make-process-lock (name) (mp:make-process-lock :name name)) ;;; HOLDING-LOCK: Execute a body of code with a lock held. ;;; The holding-lock macro takes a timeout keyword argument. EVENT-LISTEN ;;; passes its timeout to the holding-lock macro, so any timeout you want to ;;; work for event-listen you should do for holding-lock. ;; If you're not sharing DISPLAY objects within a multi-processing ;; shared-memory environment, this is sufficient ;;; HOLDING-LOCK for CMU Common Lisp. ;;; ;;; We are not multi-processing, but we use this macro to try to protect ;;; against re-entering request functions. This can happen if an interrupt ;;; occurs and the handler attempts to use X over the same display connection. ;;; This can happen if the GC hooks are used to notify the user over the same ;;; display connection. We inhibit GC notifications since display of them ;;; could cause recursive entry into CLX. ;;; ;;; HOLDING-LOCK for CMU Common Lisp with multi-processes. ;;; #+excl (defmacro holding-lock ((locator display &optional whostate &key timeout) &body body) (declare (ignore display)) `(let (.hl-lock. .hl-obtained-lock. .hl-curproc.) (unwind-protect (block .hl-doit. (when (sys:scheduler-running-p) ; fast test for scheduler running (setq .hl-lock. ,locator .hl-curproc. mp::*current-process*) (when (and .hl-curproc. ; nil if in process-wait fun (not (eq (mp::process-lock-locker .hl-lock.) .hl-curproc.))) ;; Then we need to grab the lock. ,(if timeout `(if (not (mp::process-lock .hl-lock. .hl-curproc. ,whostate ,timeout)) (return-from .hl-doit. nil)) `(mp::process-lock .hl-lock. .hl-curproc. ,@(when whostate `(,whostate)))) ;; There is an apparent race condition here. However, there is ;; no actual race condition -- our implementation of mp:process- ;; lock guarantees that the lock will still be held when it ;; returns, and no interrupt can happen between that and the ;; execution of the next form. -- jdi 2/27/91 (setq .hl-obtained-lock. t))) ,@body) (if (and .hl-obtained-lock. ;; Note -- next form added to allow error handler inside ;; body to unlock the lock prematurely if it knows that ;; the current process cannot possibly continue but will ;; throw out (or is it throw up?). (eq (mp::process-lock-locker .hl-lock.) .hl-curproc.)) (mp::process-unlock .hl-lock. .hl-curproc.))))) ;;; WITHOUT-ABORTS ;;; If you can inhibit asynchronous keyboard aborts inside the body of this ;;; macro, then it is a good idea to do this. This macro is wrapped around ;;; request writing and reply reading to ensure that requests are atomically ;;; written and replies are atomically read from the stream. #+excl (defmacro without-aborts (&body body) `(without-interrupts ,@body)) ;;; PROCESS-BLOCK: Wait until a given predicate returns a non-NIL value. ;;; Caller guarantees that PROCESS-WAKEUP will be called after the predicate's ;;; value changes. #+excl (defun process-block (whostate predicate &rest predicate-args) (if (sys:scheduler-running-p) (apply #'mp::process-wait whostate predicate predicate-args) (or (apply predicate predicate-args) (error "Program tried to wait with no scheduler.")))) ;;; PROCESS-WAKEUP: Check some other process' wait function. (declaim (inline process-wakeup)) #+excl (defun process-wakeup (process) (let ((curproc mp::*current-process*)) (when (and curproc process) (unless (mp::process-p curproc) (error "~s is not a process" curproc)) (unless (mp::process-p process) (error "~s is not a process" process)) (if (> (mp::process-priority process) (mp::process-priority curproc)) (mp::process-allow-schedule process))))) ;;; CURRENT-PROCESS: Return the current process object for input locking and ;;; for calling PROCESS-WAKEUP. (declaim (inline current-process)) ;;; Default return NIL, which is acceptable even if there is a scheduler. #+excl (defun current-process () (and (sys:scheduler-running-p) mp::*current-process*)) ;;; WITHOUT-INTERRUPTS -- provide for atomic operations. ;;; CONDITIONAL-STORE: ;; This should use GET-SETF-METHOD to avoid evaluating subforms multiple times. ;; It doesn't because CLtL doesn't pass the environment to GET-SETF-METHOD. #-sbcl (defmacro conditional-store (place old-value new-value) `(without-interrupts (cond ((eq ,place ,old-value) (setf ,place ,new-value) t)))) ;;;---------------------------------------------------------------------------- ;;; IO Error Recovery ;;; All I/O operations are done within a WRAP-BUF-OUTPUT macro. ;;; It prevents multiple mindless errors when the network craters. ;;; ;;;---------------------------------------------------------------------------- #-Genera (defmacro wrap-buf-output ((buffer) &body body) ;; Error recovery wrapper `(unless (buffer-dead ,buffer) ,@body)) #-Genera (defmacro wrap-buf-input ((buffer) &body body) (declare (ignore buffer)) ;; Error recovery wrapper `(progn ,@body)) ;;;---------------------------------------------------------------------------- ;;; System dependent IO primitives ;;; Functions for opening, reading writing forcing-output and closing ;;; the stream to the server. ;;;---------------------------------------------------------------------------- ;;; OPEN-X-STREAM - create a stream for communicating to the appropriate X ;;; server ;; ;; Note that since we don't use the CL i/o facilities to do i/o, the display ;; input and output "stream" is really a file descriptor (fixnum). ;; #+excl (defun open-x-stream (host display protocol) (declare (ignore protocol)) ;; assume TCP (let ((stream (socket:make-socket :remote-host (string host) :remote-port (+ *x-tcp-port* display) :format :binary))) (if (streamp stream) stream (error "Cannot connect to server: ~A:~D" host display)))) ;;; BUFFER-READ-DEFAULT - read data from the X stream ;; ;; Rewritten 10/89 to not use foreign function interface to do I/O. ;; #+excl (defun buffer-read-default (display vector start end timeout) (declare (type display display) (type buffer-bytes vector) (type array-index start end) (type (or null (real 0 *)) timeout)) #.(declare-buffun) (let* ((howmany (- end start)) (fd (display-input-stream display))) (declare (type array-index howmany)) (or (cond ((fd-char-avail-p fd) nil) ((and timeout (= timeout 0)) :timeout) ((buffer-input-wait-default display timeout))) (fd-read-bytes fd vector start howmany)))) ;;; WARNING: ;;; CLX performance will suffer if your lisp uses read-byte for ;;; receiving all data from the X Window System server. ;;; You are encouraged to write a specialized version of ;;; buffer-read-default that does block transfers. ;;; BUFFER-WRITE-DEFAULT - write data to the X stream #+excl (defun buffer-write-default (vector display start end) (declare (type buffer-bytes vector) (type display display) (type array-index start end)) #.(declare-buffun) (let ((stream (display-output-stream display))) (unless (null stream) (write-sequence vector stream :start start :end end))) ) ;;; WARNING: ;;; CLX performance will be severely degraded if your lisp uses ;;; write-byte to send all data to the X Window System server. ;;; You are STRONGLY encouraged to write a specialized version ;;; of buffer-write-default that does block transfers. ;;; buffer-force-output-default - force output to the X stream #+excl (defun buffer-force-output-default (display) ;; The default buffer force-output function for use with common-lisp streams (declare (type display display)) (let ((stream (display-output-stream display))) (declare (type (or null stream) stream)) (unless (null stream) (force-output stream)))) ;;; BUFFER-CLOSE-DEFAULT - close the X stream #+excl (defun buffer-close-default (display &key abort) ;; The default buffer close function for use with common-lisp streams (declare (type display display)) #.(declare-buffun) (let ((stream (display-output-stream display))) (declare (type (or null stream) stream)) (unless (null stream) (close stream :abort abort)))) ;;; BUFFER-INPUT-WAIT-DEFAULT - wait for for input to be available for the ;;; buffer. This is called in read-input between requests, so that a process ;;; waiting for input is abortable when between requests. Should return ;;; :TIMEOUT if it times out, NIL otherwise. ;;; The default implementation ;; ;; This is used so an 'eq' test may be used to find out whether or not we can ;; safely throw this process out of the CLX read loop. ;; #+excl (defparameter *read-whostate* "waiting for input from X server") ;; ;; Note that this function returns nil on error if the scheduler is running, ;; t on error if not. This is ok since buffer-read will detect the error. ;; #+excl (defun buffer-input-wait-default (display timeout) (declare (type display display) (type (or null (real 0 *)) timeout)) (declare (clx-values timeout)) (let ((fd (display-input-stream display))) (when (streamp fd) (cond ((fd-char-avail-p fd) nil) ;; Otherwise no bytes were available on the socket ((and timeout (= timeout 0)) ;; If there aren't enough and timeout == 0, timeout. :timeout) ;; If the scheduler is running let it do timeouts. ((sys:scheduler-running-p) (if (not (mp:wait-for-input-available fd :whostate *read-whostate* :wait-function #'fd-char-avail-p :timeout timeout)) (return-from buffer-input-wait-default :timeout)) ) ;; Otherwise we have to handle timeouts by hand, and call select() ;; to block until input is available. Note we don't really handle ;; the interaction of interrupts and (numberp timeout) here. XX (t #+mswindows (error "scheduler must be running to use CLX on MS Windows") #-mswindows (let ((res 0)) (declare (fixnum res)) (with-interrupt-checking-on (loop (setq res (fd-wait-for-input fd (if (null timeout) 0 (truncate timeout)))) (cond ((plusp res) ; success (return nil)) ((eq res 0) ; timeout (return :timeout)) ((eq res -1) ; error (return t)) ;; Otherwise we got an interrupt -- go around again. ))))))))) ;;; BUFFER-LISTEN-DEFAULT - returns T if there is input available for the ;;; buffer. This should never block, so it can be called from the scheduler. ;;; The default implementation is to just use listen. #+excl #+(and excl clx-use-allegro-streams) (defun buffer-listen-default (display) (declare (type display display)) (let ((stream (display-input-stream display))) (declare (type (or null stream) stream)) (if (null stream) t (listen stream)))) #+(and excl (not clx-use-allegro-streams)) (defun buffer-listen-default (display) (declare (type display display)) (let ((fd (display-input-stream display))) (declare (type fixnum fd)) (if (= fd -1) t (fd-char-avail-p fd)))) ;;;---------------------------------------------------------------------------- ;;; System dependent speed hacks ;;;---------------------------------------------------------------------------- ;; ;; WITH-STACK-LIST is used by WITH-STATE as a memory saving feature. ;; If your lisp doesn't have stack-lists, and you're worried about ;; consing garbage, you may want to re-write this to allocate and ;; initialize lists from a resource. ;; #-lispm (defmacro with-stack-list ((var &rest elements) &body body) ;; SYNTAX: (WITH-STACK-LIST (var exp1 ... expN) body) ;; Equivalent to (LET ((var (MAPCAR #'EVAL '(exp1 ... expN)))) body) ;; except that the list produced by MAPCAR resides on the stack and ;; therefore DISAPPEARS when WITH-STACK-LIST is exited. `(let ((,var (list ,@elements))) (declare (type cons ,var) #+clx-ansi-common-lisp (dynamic-extent ,var)) ,@body)) #-lispm (defmacro with-stack-list* ((var &rest elements) &body body) ;; SYNTAX: (WITH-STACK-LIST* (var exp1 ... expN) body) ;; Equivalent to (LET ((var (APPLY #'LIST* (MAPCAR #'EVAL '(exp1 ... expN))))) body) ;; except that the list produced by MAPCAR resides on the stack and ;; therefore DISAPPEARS when WITH-STACK-LIST is exited. `(let ((,var (list* ,@elements))) (declare (type cons ,var) #+clx-ansi-common-lisp (dynamic-extent ,var)) ,@body)) (declaim (inline buffer-replace)) #+excl (defun buffer-replace (target-sequence source-sequence target-start target-end &optional (source-start 0)) (declare (type buffer-bytes target-sequence source-sequence) (type array-index target-start target-end source-start) (optimize (speed 3) (safety 0))) (let ((source-end (length source-sequence))) (declare (type array-index source-end)) (excl:if* (and (eq target-sequence source-sequence) (> target-start source-start)) then (let ((nelts (min (- target-end target-start) (- source-end source-start)))) (do ((target-index (+ target-start nelts -1) (1- target-index)) (source-index (+ source-start nelts -1) (1- source-index))) ((= target-index (1- target-start)) target-sequence) (declare (type array-index target-index source-index)) (setf (aref target-sequence target-index) (aref source-sequence source-index)))) else (do ((target-index target-start (1+ target-index)) (source-index source-start (1+ source-index))) ((or (= target-index target-end) (= source-index source-end)) target-sequence) (declare (type array-index target-index source-index)) (setf (aref target-sequence target-index) (aref source-sequence source-index)))))) #-lispm (defmacro with-gcontext-bindings ((gc saved-state indexes ts-index temp-mask temp-gc) &body body) (let ((local-state (gensym)) (resets nil)) (dolist (index indexes) (push `(setf (svref ,local-state ,index) (svref ,saved-state ,index)) resets)) `(unwind-protect (progn ,@body) (let ((,local-state (gcontext-local-state ,gc))) (declare (type gcontext-state ,local-state)) ,@resets (setf (svref ,local-state ,ts-index) 0)) (when ,temp-gc (restore-gcontext-temp-state ,gc ,temp-mask ,temp-gc)) (deallocate-gcontext-state ,saved-state)))) ;;;---------------------------------------------------------------------------- ;;; How much error detection should CLX do? ;;; Several levels are possible: ;;; ;;; 1. Do the equivalent of check-type on every argument. ;;; ;;; 2. Simply report TYPE-ERROR. This eliminates overhead of all the format ;;; strings generated by check-type. ;;; ;;; 3. Do error checking only on arguments that are likely to have errors ;;; (like keyword names) ;;; ;;; 4. Do error checking only where not doing so may dammage the envirnment ;;; on a non-tagged machine (i.e. when storing into a structure that has ;;; been passed in) ;;; ;;; 5. No extra error detection code. On lispm's, ASET may barf trying to ;;; store a non-integer into a number array. ;;; ;;; How extensive should the error checking be? For example, if the server ;;; expects a CARD16, is is sufficient for CLX to check for integer, or ;;; should it also check for non-negative and less than 65536? ;;;---------------------------------------------------------------------------- ;; The +TYPE-CHECK?+ constant controls how much error checking is done. ;; Possible values are: ;; NIL - Don't do any error checking ;; t - Do the equivalent of checktype on every argument ;; :minimal - Do error checking only where errors are likely ;;; This controls macro expansion, and isn't changable at run-time You will ;;; probably want to set this to nil if you want good performance at ;;; production time. (defconstant +type-check?+ #+(or Genera Minima CMU sbcl) nil #-(or Genera Minima CMU sbcl) t) ;; TYPE? is used to allow the code to do error checking at a different level from ;; the declarations. It also does some optimizations for systems that don't have ;; good compiler support for TYPEP. The definitions for CARD32, CARD16, INT16, etc. ;; include range checks. You can modify TYPE? to do less extensive checking ;; for these types if you desire. ;; ;; ### This comment is a lie! TYPE? is really also used for run-time type ;; dispatching, not just type checking. -- Ram. (defmacro type? (object type) #+(or cmu sbcl) `(typep ,object ,type) #-(or cmu sbcl) (if (not (constantp type)) `(typep ,object ,type) (progn (setq type (eval type)) #+(or Genera explorer Minima) (if +type-check?+ `(locally (declare (optimize safety)) (typep ,object ',type)) `(typep ,object ',type)) #-(or Genera explorer Minima) (let ((predicate (assoc type '((drawable drawable-p) (window window-p) (pixmap pixmap-p) (cursor cursor-p) (font font-p) (gcontext gcontext-p) (colormap colormap-p) (null null) (integer integerp))))) (cond (predicate `(,(second predicate) ,object)) ((eq type 'generalized-boolean) 't) ; Everything is a generalized-boolean. (+type-check?+ `(locally (declare (optimize safety)) (typep ,object ',type))) (t `(typep ,object ',type))))))) ;; X-TYPE-ERROR is the function called for type errors. ;; If you want lots of checking, but are concerned about code size, ;; this can be made into a macro that ignores some parameters. (defun x-type-error (object type &optional error-string) (x-error 'x-type-error :datum object :expected-type type :type-string error-string)) ;;----------------------------------------------------------------------------- ;; Error handlers ;; Hack up KMP error signaling using zetalisp until the real thing comes ;; along ;;----------------------------------------------------------------------------- (defun default-error-handler (display error-key &rest key-vals &key asynchronous &allow-other-keys) (declare (type generalized-boolean asynchronous) (dynamic-extent key-vals)) ;; The default display-error-handler. ;; It signals the conditions listed in the DISPLAY file. (if asynchronous (apply #'x-cerror "Ignore" error-key :display display :error-key error-key key-vals) (apply #'x-error error-key :display display :error-key error-key key-vals))) #+(or clx-ansi-common-lisp excl lcl3.0 (and CMU mp)) (defun x-error (condition &rest keyargs) (declare (dynamic-extent keyargs)) (apply #'error condition keyargs)) #+(or clx-ansi-common-lisp excl lcl3.0 CMU) (defun x-cerror (proceed-format-string condition &rest keyargs) (declare (dynamic-extent keyargs)) (apply #'cerror proceed-format-string condition keyargs)) ;;; X-ERROR for CMU Common Lisp ;;; ;;; We detect a couple condition types for which we disable event handling in ;;; our system. This prevents going into the debugger or returning to a ;;; command prompt with CLX repeatedly seeing the same condition. This occurs ;;; because CMU Common Lisp provides for all events (that is, X, input on file ;;; descriptors, Mach messages, etc.) to come through one routine anyone can ;;; use to wait for input. ;;; #+(and CMU (not mp)) (defun x-error (condition &rest keyargs) (let ((condx (apply #'make-condition condition keyargs))) (when (eq condition 'closed-display) (let ((disp (closed-display-display condx))) (warn "Disabled event handling on ~S." disp) (ext::disable-clx-event-handling disp))) (error condx))) #-(or lispm ansi-common-lisp excl lcl3.0 CMU sbcl) (defun x-error (condition &rest keyargs) (error "X-Error: ~a" (princ-to-string (apply #'make-condition condition keyargs)))) #-(or lispm clx-ansi-common-lisp excl lcl3.0 CMU sbcl) (defun x-cerror (proceed-format-string condition &rest keyargs) (cerror proceed-format-string "X-Error: ~a" (princ-to-string (apply #'make-condition condition keyargs)))) ;; version 15 of Pitman error handling defines the syntax for define-condition to be: ;; DEFINE-CONDITION name (parent-type) [({slot}*) {option}*] ;; Where option is one of: (:documentation doc-string) (:conc-name symbol-or-string) ;; or (:report exp) #+(and excl (not clx-ansi-common-lisp)) (defmacro define-condition (name parent-types &optional slots &rest args) `(excl::define-condition ,name (,(first parent-types)) ,(mapcar #'(lambda (slot) (if (consp slot) (car slot) slot)) slots) ,@args)) #+(or clx-ansi-common-lisp excl lcl3.0 CMU sbcl) (define-condition x-error (error) ()) ;;----------------------------------------------------------------------------- ;; HOST hacking ;;----------------------------------------------------------------------------- #+(and allegro-version>= (version>= 5 0)) (eval-when (compile eval load) #+(version>= 6 0) (progn (require :sock) #-(version>= 7 0) (require :gray-compat)) #-(version>= 6 0) (require :sock)) #+(and allegro-version>= (version>= 5 0)) (defun host-address (host &optional (family :internet)) (ecase family (:internet (cons :internet (multiple-value-list (socket::ipaddr-to-dotted (socket::lookup-hostname host) :values t)))))) #+(and allegro-version>= (not (version>= 5 0))) (defun host-address (host &optional (family :internet)) ;; Return a list whose car is the family keyword (:internet :DECnet :Chaos) ;; and cdr is a list of network address bytes. (declare (type stringable host) (type (or null (member :internet :decnet :chaos) card8) family)) (declare (clx-values list)) (labels ((no-host-error () (error "Unknown host ~S" host)) (no-address-error () (error "Host ~S has no ~S address" host family))) (let ((hostent 0)) (unwind-protect (progn (setf hostent (ipc::gethostbyname (string host))) (when (zerop hostent) (no-host-error)) (ecase family ((:internet nil 0) (unless (= (ipc::hostent-addrtype hostent) 2) (no-address-error)) (assert (= (ipc::hostent-length hostent) 4)) (let ((addr (ipc::hostent-addr hostent))) (when (or (member comp::.target. '(:hp :sgi4d :sony :dec3100) :test #'eq) (probe-file "/lib/ld.so")) ;; BSD 4.3 based systems require an extra indirection (setq addr (si:memref-int addr 0 0 :unsigned-long))) (list :internet (si:memref-int addr 0 0 :unsigned-byte) (si:memref-int addr 1 0 :unsigned-byte) (si:memref-int addr 2 0 :unsigned-byte) (si:memref-int addr 3 0 :unsigned-byte)))))) (ff:free-cstruct hostent))))) ;;----------------------------------------------------------------------------- ;; Whether to use closures for requests or not. ;;----------------------------------------------------------------------------- ;;; If this macro expands to non-NIL, then request and locking code is ;;; compiled in a much more compact format, as the common code is shared, and ;;; the specific code is built into a closure that is funcalled by the shared ;;; code. If your compiler makes efficient use of closures then you probably ;;; want to make this expand to T, as it makes the code more compact. (defmacro use-closures () #+(or lispm Minima) t #-(or lispm Minima) nil) #-(or Genera Minima) (defun clx-macroexpand (form env) (macroexpand form env)) ;;----------------------------------------------------------------------------- ;; Resource stuff ;;----------------------------------------------------------------------------- ;;; Utilities (defun getenv (name) #+excl (sys:getenv name) ) (defun get-host-name () "Return the same hostname as gethostname(3) would" ;; resources-pathname was using short-site-name for this purpose #+excl (short-site-name) ) (defun homedir-file-pathname (name) (and #-(or unix mach) (search "Unix" (software-type) :test #'char-equal) (merge-pathnames (user-homedir-pathname) (pathname name)))) ;;; DEFAULT-RESOURCES-PATHNAME - The pathname of the resources file to load if ;;; a resource manager isn't running. (defun default-resources-pathname () (homedir-file-pathname ".Xdefaults")) ;;; RESOURCES-PATHNAME - The pathname of the resources file to load after the ;;; defaults have been loaded. (defun resources-pathname () (or (let ((string (getenv "XENVIRONMENT"))) (and string (pathname string))) (homedir-file-pathname (concatenate 'string ".Xdefaults-" (get-host-name))))) ;;; AUTHORITY-PATHNAME - The pathname of the authority file. (defun authority-pathname () (or (let ((xauthority (getenv "XAUTHORITY"))) (and xauthority (pathname xauthority))) (homedir-file-pathname ".Xauthority"))) ;;; this particular defaulting behaviour is typical to most Unices, I think #+unix (defun get-default-display (&optional display-name) "Parse the argument DISPLAY-NAME, or the environment variable $DISPLAY if it is NIL. Display names have the format [protocol/] [hostname] : [:] displaynumber [.screennumber] There are two special cases in parsing, to match that done in the Xlib C language bindings - If the hostname is ``unix'' or the empty string, any supplied protocol is ignored and a connection is made using the :local transport. - If a double colon separates hostname from displaynumber, the protocol is assumed to be decnet. Returns a list of (host display-number screen protocol)." (let* ((name (or display-name (getenv "DISPLAY") (error "DISPLAY environment variable is not set"))) (slash-i (or (position #\/ name) -1)) (colon-i (position #\: name :start (1+ slash-i))) (decnet-colon-p (eql (elt name (1+ colon-i)) #\:)) (host (subseq name (1+ slash-i) colon-i)) (dot-i (and colon-i (position #\. name :start colon-i))) (display (when colon-i (parse-integer name :start (if decnet-colon-p (+ colon-i 2) (1+ colon-i)) :end dot-i))) (screen (when dot-i (parse-integer name :start (1+ dot-i)))) (protocol (cond ((or (string= host "") (string-equal host "unix")) :local) (decnet-colon-p :decnet) ((> slash-i -1) (intern (string-upcase (subseq name 0 slash-i)) :keyword)) (t :internet)))) (list host (or display 0) (or screen 0) protocol))) ;;----------------------------------------------------------------------------- ;; GC stuff ;;----------------------------------------------------------------------------- (defun gc-cleanup () (declare (special *event-free-list* *pending-command-free-list* *reply-buffer-free-lists* *gcontext-local-state-cache* *temp-gcontext-cache*)) (setq *event-free-list* nil) (setq *pending-command-free-list* nil) (when (boundp '*reply-buffer-free-lists*) (fill *reply-buffer-free-lists* nil)) (setq *gcontext-local-state-cache* nil) (setq *temp-gcontext-cache* nil) nil) ;;----------------------------------------------------------------------------- ;; WITH-STANDARD-IO-SYNTAX equivalent, used in (SETF WM-COMMAND) ;;----------------------------------------------------------------------------- #-(or clx-ansi-common-lisp Genera CMU sbcl) (defun with-standard-io-syntax-function (function) (declare #+lispm (sys:downward-funarg function)) (let ((*package* (find-package :user)) (*print-array* t) (*print-base* 10) (*print-case* :upcase) (*print-circle* nil) (*print-escape* t) (*print-gensym* t) (*print-length* nil) (*print-level* nil) (*print-pretty* nil) (*print-radix* nil) (*read-base* 10) (*read-default-float-format* 'single-float) (*read-suppress* nil) ) (funcall function))) #-(or clx-ansi-common-lisp Genera CMU sbcl) (defmacro with-standard-io-syntax (&body body) `(flet ((.with-standard-io-syntax-body. () ,@body)) (with-standard-io-syntax-function #'.with-standard-io-syntax-body.))) ;;----------------------------------------------------------------------------- ;; DEFAULT-KEYSYM-TRANSLATE ;;----------------------------------------------------------------------------- ;;; If object is a character, char-bits are set from state. ;;; ;;; [the following isn't implemented (should it be?)] ;;; If object is a list, it is an alist with entries: ;;; (base-char [modifiers] [mask-modifiers]) ;;; When MODIFIERS are specified, this character translation ;;; will only take effect when the specified modifiers are pressed. ;;; MASK-MODIFIERS can be used to specify a set of modifiers to ignore. ;;; When MASK-MODIFIERS is missing, all other modifiers are ignored. ;;; In ambiguous cases, the most specific translation is used. #-(or (and clx-ansi-common-lisp (not lispm) (not allegro)) CMU sbcl) (defun default-keysym-translate (display state object) (declare (type display display) (type card16 state) (type t object) (clx-values t) (special left-meta-keysym right-meta-keysym left-super-keysym right-super-keysym left-hyper-keysym right-hyper-keysym)) (when (characterp object) (when (logbitp (position :control +state-mask-vector+) state) (setf (char-bit object :control) 1)) (when (or (state-keysymp display state left-meta-keysym) (state-keysymp display state right-meta-keysym)) (setf (char-bit object :meta) 1)) (when (or (state-keysymp display state left-super-keysym) (state-keysymp display state right-super-keysym)) (setf (char-bit object :super) 1)) (when (or (state-keysymp display state left-hyper-keysym) (state-keysymp display state right-hyper-keysym)) (setf (char-bit object :hyper) 1))) object) ;;----------------------------------------------------------------------------- ;; Image stuff ;;----------------------------------------------------------------------------- ;;; Types (deftype pixarray-1-element-type () 'bit) (deftype pixarray-4-element-type () '(unsigned-byte 4)) (deftype pixarray-8-element-type () '(unsigned-byte 8)) (deftype pixarray-16-element-type () '(unsigned-byte 16)) (deftype pixarray-24-element-type () '(unsigned-byte 24)) (deftype pixarray-32-element-type () #-(or Genera Minima) '(unsigned-byte 32) #+(or Genera Minima) 'fixnum) (deftype pixarray-1 () '(#+(or cmu sbcl) simple-array #-(or cmu sbcl) array pixarray-1-element-type (* *))) (deftype pixarray-4 () '(#+(or cmu sbcl) simple-array #-(or cmu sbcl) array pixarray-4-element-type (* *))) (deftype pixarray-8 () '(#+(or cmu sbcl) simple-array #-(or cmu sbcl) array pixarray-8-element-type (* *))) (deftype pixarray-16 () '(#+(or cmu sbcl) simple-array #-(or cmu sbcl) array pixarray-16-element-type (* *))) (deftype pixarray-24 () '(#+(or cmu sbcl) simple-array #-(or cmu sbcl) array pixarray-24-element-type (* *))) (deftype pixarray-32 () '(#+(or cmu sbcl) simple-array #-(or cmu sbcl) array pixarray-32-element-type (* *))) (deftype pixarray () '(or pixarray-1 pixarray-4 pixarray-8 pixarray-16 pixarray-24 pixarray-32)) (deftype bitmap () 'pixarray-1) ;;; WITH-UNDERLYING-SIMPLE-VECTOR #+excl (defmacro with-underlying-simple-vector ((variable element-type pixarray) &body body) `(let ((,variable (cdr (excl::ah_data ,pixarray)))) (declare (type (simple-array ,element-type (*)) ,variable)) ,@body)) ;;; These are used to read and write pixels from and to CARD8s. ;;; READ-IMAGE-LOAD-BYTE is used to extract 1 and 4 bit pixels from CARD8s. (defmacro read-image-load-byte (size position integer) (unless +image-bit-lsb-first-p+ (setq position (- 7 position))) `(the (unsigned-byte ,size) (#-Genera ldb #+Genera sys:%logldb (byte ,size ,position) (the card8 ,integer)))) ;;; READ-IMAGE-ASSEMBLE-BYTES is used to build 16, 24 and 32 bit pixels from ;;; the appropriate number of CARD8s. (defmacro read-image-assemble-bytes (&rest bytes) (unless +image-byte-lsb-first-p+ (setq bytes (reverse bytes))) (let ((it (first bytes)) (count 0)) (dolist (byte (rest bytes)) (setq it `(#-Genera dpb #+Genera sys:%logdpb (the card8 ,byte) (byte 8 ,(incf count 8)) (the (unsigned-byte ,count) ,it)))) #-Genera `(the (unsigned-byte ,(* (length bytes) 8)) ,it) #+Genera it)) ;;; WRITE-IMAGE-LOAD-BYTE is used to extract a CARD8 from a 16, 24 or 32 bit ;;; pixel. (defmacro write-image-load-byte (position integer integer-size) integer-size (unless +image-byte-lsb-first-p+ (setq position (- integer-size 8 position))) `(the card8 (#-Genera ldb #+Genera sys:%logldb (byte 8 ,position) #-Genera (the (unsigned-byte ,integer-size) ,integer) #+Genera ,integer ))) ;;; WRITE-IMAGE-ASSEMBLE-BYTES is used to build a CARD8 from 1 or 4 bit ;;; pixels. (defmacro write-image-assemble-bytes (&rest bytes) (unless +image-bit-lsb-first-p+ (setq bytes (reverse bytes))) (let ((size (floor 8 (length bytes))) (it (first bytes)) (count 0)) (dolist (byte (rest bytes)) (setq it `(#-Genera dpb #+Genera sys:%logdpb (the (unsigned-byte ,size) ,byte) (byte ,size ,(incf count size)) (the (unsigned-byte ,count) ,it)))) `(the card8 ,it))) #+(or Genera lcl3.0 excl) (defvar *computed-image-byte-lsb-first-p* +image-byte-lsb-first-p+) #+(or Genera lcl3.0 excl) (defvar *computed-image-bit-lsb-first-p* +image-bit-lsb-first-p+) ;;; The following table gives the bit ordering within bytes (when accessed ;;; sequentially) for a scanline containing 32 bits, with bits numbered 0 to ;;; 31, where bit 0 should be leftmost on the display. For a given byte ;;; labelled A-B, A is for the most significant bit of the byte, and B is ;;; for the least significant bit. ;;; ;;; legend: ;;; 1 scanline-unit = 8 ;;; 2 scanline-unit = 16 ;;; 4 scanline-unit = 32 ;;; M byte-order = MostSignificant ;;; L byte-order = LeastSignificant ;;; m bit-order = MostSignificant ;;; l bit-order = LeastSignificant ;;; ;;; ;;; format ordering ;;; ;;; 1Mm 00-07 08-15 16-23 24-31 ;;; 2Mm 00-07 08-15 16-23 24-31 ;;; 4Mm 00-07 08-15 16-23 24-31 ;;; 1Ml 07-00 15-08 23-16 31-24 ;;; 2Ml 15-08 07-00 31-24 23-16 ;;; 4Ml 31-24 23-16 15-08 07-00 ;;; 1Lm 00-07 08-15 16-23 24-31 ;;; 2Lm 08-15 00-07 24-31 16-23 ;;; 4Lm 24-31 16-23 08-15 00-07 ;;; 1Ll 07-00 15-08 23-16 31-24 ;;; 2Ll 07-00 15-08 23-16 31-24 ;;; 4Ll 07-00 15-08 23-16 31-24 #+(or Genera lcl3.0 excl) (defconstant *image-bit-ordering-table* '(((1 (00 07) (08 15) (16 23) (24 31)) (nil nil)) ((2 (00 07) (08 15) (16 23) (24 31)) (nil nil)) ((4 (00 07) (08 15) (16 23) (24 31)) (nil nil)) ((1 (07 00) (15 08) (23 16) (31 24)) (nil t)) ((2 (15 08) (07 00) (31 24) (23 16)) (nil t)) ((4 (31 24) (23 16) (15 08) (07 00)) (nil t)) ((1 (00 07) (08 15) (16 23) (24 31)) (t nil)) ((2 (08 15) (00 07) (24 31) (16 23)) (t nil)) ((4 (24 31) (16 23) (08 15) (00 07)) (t nil)) ((1 (07 00) (15 08) (23 16) (31 24)) (t t)) ((2 (07 00) (15 08) (23 16) (31 24)) (t t)) ((4 (07 00) (15 08) (23 16) (31 24)) (t t)))) #+(or Genera lcl3.0 excl) (defun compute-image-byte-and-bit-ordering () (declare (clx-values image-byte-lsb-first-p image-bit-lsb-first-p)) ;; First compute the ordering (let ((ordering nil) (a (make-array '(1 32) :element-type 'bit :initial-element 0))) (dotimes (i 4) (push (flet ((bitpos (a i n) (declare (optimize (speed 3) (safety 0) (space 0))) (declare (type (simple-array bit (* *)) a) (type fixnum i n)) (with-underlying-simple-vector (v (unsigned-byte 8) a) (prog2 (setf (aref v i) n) (dotimes (i 32) (unless (zerop (aref a 0 i)) (return i))) (setf (aref v i) 0))))) (list (bitpos a i #b10000000) (bitpos a i #b00000001))) ordering)) (setq ordering (cons (floor +image-unit+ 8) (nreverse ordering))) ;; Now from the ordering, compute byte-lsb-first-p and bit-lsb-first-p (let ((byte-and-bit-ordering (second (assoc ordering *image-bit-ordering-table* :test #'equal)))) (unless byte-and-bit-ordering (error "Couldn't determine image byte and bit ordering~@ measured image ordering = ~A" ordering)) (values-list byte-and-bit-ordering)))) #+(or Genera lcl3.0 excl) (multiple-value-setq (*computed-image-byte-lsb-first-p* *computed-image-bit-lsb-first-p*) (compute-image-byte-and-bit-ordering)) ;;; If you can write fast routines that can read and write pixarrays out of a ;;; buffer-bytes, do it! It makes the image code a lot faster. The ;;; FAST-READ-PIXARRAY, FAST-WRITE-PIXARRAY and FAST-COPY-PIXARRAY routines ;;; return T if they can do it, NIL if they can't. ;;; FIXME: though we have some #+sbcl -conditionalized routines in ;;; here, they would appear not to work, and so are commented out in ;;; the the FAST-xxx-PIXARRAY routines themseleves. Investigate ;;; whether the unoptimized routines are often used, and also whether ;;; speeding them up while maintaining correctness is possible. ;;; FAST-READ-PIXARRAY - fill part of a pixarray from a buffer of card8s #+(or lcl3.0 excl) (defun fast-read-pixarray-1 (buffer-bbuf index array x y width height padded-bytes-per-line bits-per-pixel) (declare (type buffer-bytes buffer-bbuf) (type pixarray-1 array) (type card16 x y width height) (type array-index index padded-bytes-per-line) (type (member 1 4 8 16 24 32) bits-per-pixel) (ignore bits-per-pixel)) #.(declare-buffun) (with-vector (buffer-bbuf buffer-bytes) (with-underlying-simple-vector (vector pixarray-1-element-type array) (do* ((start (index+ index (index* y padded-bytes-per-line) (index-ceiling x 8)) (index+ start padded-bytes-per-line)) (y 0 (index1+ y)) (left-bits (the array-index (mod (the fixnum (- x)) 8))) (right-bits (index-mod (index- width left-bits) 8)) (middle-bits (the fixnum (- (the fixnum (- width left-bits)) right-bits))) (middle-bytes (index-floor middle-bits 8))) ((index>= y height)) (declare (type array-index start y left-bits right-bits middle-bytes) (fixnum middle-bits)) (cond ((< middle-bits 0) (let ((byte (aref buffer-bbuf (index1- start))) (x (array-row-major-index array y left-bits))) (declare (type card8 byte) (type array-index x)) (when (index> right-bits 6) (setf (aref vector (index- x 1)) (read-image-load-byte 1 7 byte))) (when (and (index> left-bits 1) (index> right-bits 5)) (setf (aref vector (index- x 2)) (read-image-load-byte 1 6 byte))) (when (and (index> left-bits 2) (index> right-bits 4)) (setf (aref vector (index- x 3)) (read-image-load-byte 1 5 byte))) (when (and (index> left-bits 3) (index> right-bits 3)) (setf (aref vector (index- x 4)) (read-image-load-byte 1 4 byte))) (when (and (index> left-bits 4) (index> right-bits 2)) (setf (aref vector (index- x 5)) (read-image-load-byte 1 3 byte))) (when (and (index> left-bits 5) (index> right-bits 1)) (setf (aref vector (index- x 6)) (read-image-load-byte 1 2 byte))) (when (index> left-bits 6) (setf (aref vector (index- x 7)) (read-image-load-byte 1 1 byte))))) (t (unless (index-zerop left-bits) (let ((byte (aref buffer-bbuf (index1- start))) (x (array-row-major-index array y left-bits))) (declare (type card8 byte) (type array-index x)) (setf (aref vector (index- x 1)) (read-image-load-byte 1 7 byte)) (when (index> left-bits 1) (setf (aref vector (index- x 2)) (read-image-load-byte 1 6 byte)) (when (index> left-bits 2) (setf (aref vector (index- x 3)) (read-image-load-byte 1 5 byte)) (when (index> left-bits 3) (setf (aref vector (index- x 4)) (read-image-load-byte 1 4 byte)) (when (index> left-bits 4) (setf (aref vector (index- x 5)) (read-image-load-byte 1 3 byte)) (when (index> left-bits 5) (setf (aref vector (index- x 6)) (read-image-load-byte 1 2 byte)) (when (index> left-bits 6) (setf (aref vector (index- x 7)) (read-image-load-byte 1 1 byte)) )))))))) (do* ((end (index+ start middle-bytes)) (i start (index1+ i)) (x (array-row-major-index array y left-bits) (index+ x 8))) ((index>= i end) (unless (index-zerop right-bits) (let ((byte (aref buffer-bbuf end)) (x (array-row-major-index array y (index+ left-bits middle-bits)))) (declare (type card8 byte) (type array-index x)) (setf (aref vector (index+ x 0)) (read-image-load-byte 1 0 byte)) (when (index> right-bits 1) (setf (aref vector (index+ x 1)) (read-image-load-byte 1 1 byte)) (when (index> right-bits 2) (setf (aref vector (index+ x 2)) (read-image-load-byte 1 2 byte)) (when (index> right-bits 3) (setf (aref vector (index+ x 3)) (read-image-load-byte 1 3 byte)) (when (index> right-bits 4) (setf (aref vector (index+ x 4)) (read-image-load-byte 1 4 byte)) (when (index> right-bits 5) (setf (aref vector (index+ x 5)) (read-image-load-byte 1 5 byte)) (when (index> right-bits 6) (setf (aref vector (index+ x 6)) (read-image-load-byte 1 6 byte)) ))))))))) (declare (type array-index end i x)) (let ((byte (aref buffer-bbuf i))) (declare (type card8 byte)) (setf (aref vector (index+ x 0)) (read-image-load-byte 1 0 byte)) (setf (aref vector (index+ x 1)) (read-image-load-byte 1 1 byte)) (setf (aref vector (index+ x 2)) (read-image-load-byte 1 2 byte)) (setf (aref vector (index+ x 3)) (read-image-load-byte 1 3 byte)) (setf (aref vector (index+ x 4)) (read-image-load-byte 1 4 byte)) (setf (aref vector (index+ x 5)) (read-image-load-byte 1 5 byte)) (setf (aref vector (index+ x 6)) (read-image-load-byte 1 6 byte)) (setf (aref vector (index+ x 7)) (read-image-load-byte 1 7 byte)))) ))))) t) #+(or lcl3.0 excl) (defun fast-read-pixarray-4 (buffer-bbuf index array x y width height padded-bytes-per-line bits-per-pixel) (declare (type buffer-bytes buffer-bbuf) (type pixarray-4 array) (type card16 x y width height) (type array-index index padded-bytes-per-line) (type (member 1 4 8 16 24 32) bits-per-pixel) (ignore bits-per-pixel)) #.(declare-buffun) (with-vector (buffer-bbuf buffer-bytes) (with-underlying-simple-vector (vector pixarray-4-element-type array) (do* ((start (index+ index (index* y padded-bytes-per-line) (index-ceiling x 2)) (index+ start padded-bytes-per-line)) (y 0 (index1+ y)) (left-nibbles (the array-index (mod (the fixnum (- (the fixnum x))) 2))) (right-nibbles (index-mod (index- width left-nibbles) 2)) (middle-nibbles (index- width left-nibbles right-nibbles)) (middle-bytes (index-floor middle-nibbles 2))) ((index>= y height)) (declare (type array-index start y left-nibbles right-nibbles middle-nibbles middle-bytes)) (unless (index-zerop left-nibbles) (setf (aref array y 0) (read-image-load-byte 4 4 (aref buffer-bbuf (index1- start))))) (do* ((end (index+ start middle-bytes)) (i start (index1+ i)) (x (array-row-major-index array y left-nibbles) (index+ x 2))) ((index>= i end) (unless (index-zerop right-nibbles) (setf (aref array y (index+ left-nibbles middle-nibbles)) (read-image-load-byte 4 0 (aref buffer-bbuf end))))) (declare (type array-index end i x)) (let ((byte (aref buffer-bbuf i))) (declare (type card8 byte)) (setf (aref vector (index+ x 0)) (read-image-load-byte 4 0 byte)) (setf (aref vector (index+ x 1)) (read-image-load-byte 4 4 byte)))) ))) t) #+(or Genera lcl3.0 excl CMU sbcl) (defun fast-read-pixarray-24 (buffer-bbuf index array x y width height padded-bytes-per-line bits-per-pixel) (declare (type buffer-bytes buffer-bbuf) (type pixarray-24 array) (type card16 width height) (type array-index index padded-bytes-per-line) (type (member 1 4 8 16 24 32) bits-per-pixel) (ignore bits-per-pixel)) #.(declare-buffun) (with-vector (buffer-bbuf buffer-bytes) (with-underlying-simple-vector (vector pixarray-24-element-type array) (do* ((start (index+ index (index* y padded-bytes-per-line) (index* x 3)) (index+ start padded-bytes-per-line)) (y 0 (index1+ y))) ((index>= y height)) (declare (type array-index start y)) (do* ((end (index+ start (index* width 3))) (i start (index+ i 3)) (x (array-row-major-index array y 0) (index1+ x))) ((index>= i end)) (declare (type array-index end i x)) (setf (aref vector x) (read-image-assemble-bytes (aref buffer-bbuf (index+ i 0)) (aref buffer-bbuf (index+ i 1)) (aref buffer-bbuf (index+ i 2)))))))) t) ;;; COPY-BIT-RECT -- Internal ;;; ;;; This is the classic BITBLT operation, copying a rectangular subarray ;;; from one array to another (but source and destination must not overlap.) ;;; Widths are specified in bits. Neither array can have a non-zero ;;; displacement. We allow extra random bit-offset to be thrown into the X. ;;; #+(or Genera lcl3.0 excl) (defun fast-read-pixarray-with-swap (bbuf boffset pixarray x y width height padded-bytes-per-line bits-per-pixel unit byte-lsb-first-p bit-lsb-first-p) (declare (type buffer-bytes bbuf) (type array-index boffset padded-bytes-per-line) (type pixarray pixarray) (type card16 x y width height) (type (member 1 4 8 16 24 32) bits-per-pixel) (type (member 8 16 32) unit) (type generalized-boolean byte-lsb-first-p bit-lsb-first-p)) (unless (index= bits-per-pixel 24) (let ((pixarray-padded-bits-per-line (if (index= height 1) 0 (index* (index- (array-row-major-index pixarray 1 0) (array-row-major-index pixarray 0 0)) bits-per-pixel))) (x-bits (index* x bits-per-pixel))) (declare (type array-index pixarray-padded-bits-per-line x-bits)) (when (if (eq *computed-image-byte-lsb-first-p* *computed-image-bit-lsb-first-p*) (and (index-zerop (index-mod pixarray-padded-bits-per-line 8)) (index-zerop (index-mod x-bits 8))) (and (index-zerop (index-mod pixarray-padded-bits-per-line +image-unit+)) (index-zerop (index-mod x-bits +image-unit+)))) (multiple-value-bind (image-swap-function image-swap-lsb-first-p) (image-swap-function bits-per-pixel unit byte-lsb-first-p bit-lsb-first-p +image-unit+ *computed-image-byte-lsb-first-p* *computed-image-bit-lsb-first-p*) (declare (type symbol image-swap-function) (type generalized-boolean image-swap-lsb-first-p)) (with-underlying-simple-vector (dst card8 pixarray) (funcall (symbol-function image-swap-function) bbuf dst (index+ boffset (index* y padded-bytes-per-line) (index-floor x-bits 8)) 0 (index-ceiling (index* width bits-per-pixel) 8) padded-bytes-per-line (index-floor pixarray-padded-bits-per-line 8) height image-swap-lsb-first-p))) t)))) (defun fast-read-pixarray (bbuf boffset pixarray x y width height padded-bytes-per-line bits-per-pixel unit byte-lsb-first-p bit-lsb-first-p) (declare (type buffer-bytes bbuf) (type array-index boffset padded-bytes-per-line) (type pixarray pixarray) (type card16 x y width height) (type (member 1 4 8 16 24 32) bits-per-pixel) (type (member 8 16 32) unit) (type generalized-boolean byte-lsb-first-p bit-lsb-first-p)) (progn bbuf boffset pixarray x y width height padded-bytes-per-line bits-per-pixel unit byte-lsb-first-p bit-lsb-first-p) (or #+(or Genera lcl3.0 excl) (fast-read-pixarray-with-swap bbuf boffset pixarray x y width height padded-bytes-per-line bits-per-pixel unit byte-lsb-first-p bit-lsb-first-p) (let ((function (or #+lispm (and (= (sys:array-element-size pixarray) bits-per-pixel) (zerop (index-mod padded-bytes-per-line 4)) (zerop (index-mod (* #+Genera (sys:array-row-span pixarray) #-Genera (array-dimension pixarray 1) bits-per-pixel) 32)) #'fast-read-pixarray-using-bitblt) #+(or CMU) (and (index= (pixarray-element-size pixarray) bits-per-pixel) #'fast-read-pixarray-using-bitblt) #+(or lcl3.0 excl) (and (index= bits-per-pixel 1) #'fast-read-pixarray-1) #+(or lcl3.0 excl) (and (index= bits-per-pixel 4) #'fast-read-pixarray-4) #+(or Genera lcl3.0 excl CMU) (and (index= bits-per-pixel 24) #'fast-read-pixarray-24)))) (when function (read-pixarray-internal bbuf boffset pixarray x y width height padded-bytes-per-line bits-per-pixel function unit byte-lsb-first-p bit-lsb-first-p +image-unit+ +image-byte-lsb-first-p+ +image-bit-lsb-first-p+))))) ;;; FAST-WRITE-PIXARRAY - copy part of a pixarray into an array of CARD8s #+(or lcl3.0 excl) (defun fast-write-pixarray-1 (buffer-bbuf index array x y width height padded-bytes-per-line bits-per-pixel) (declare (type buffer-bytes buffer-bbuf) (type pixarray-1 array) (type card16 x y width height) (type array-index index padded-bytes-per-line) (type (member 1 4 8 16 24 32) bits-per-pixel) (ignore bits-per-pixel)) #.(declare-buffun) (with-vector (buffer-bbuf buffer-bytes) (with-underlying-simple-vector (vector pixarray-1-element-type array) (do* ((h 0 (index1+ h)) (y y (index1+ y)) (right-bits (index-mod width 8)) (middle-bits (index- width right-bits)) (middle-bytes (index-ceiling middle-bits 8)) (start index (index+ start padded-bytes-per-line))) ((index>= h height)) (declare (type array-index h y right-bits middle-bits middle-bytes start)) (do* ((end (index+ start middle-bytes)) (i start (index1+ i)) (start-x x) (x (array-row-major-index array y start-x) (index+ x 8))) ((index>= i end) (unless (index-zerop right-bits) (let ((x (array-row-major-index array y (index+ start-x middle-bits)))) (declare (type array-index x)) (setf (aref buffer-bbuf end) (write-image-assemble-bytes (aref vector (index+ x 0)) (if (index> right-bits 1) (aref vector (index+ x 1)) 0) (if (index> right-bits 2) (aref vector (index+ x 2)) 0) (if (index> right-bits 3) (aref vector (index+ x 3)) 0) (if (index> right-bits 4) (aref vector (index+ x 4)) 0) (if (index> right-bits 5) (aref vector (index+ x 5)) 0) (if (index> right-bits 6) (aref vector (index+ x 6)) 0) 0))))) (declare (type array-index end i start-x x)) (setf (aref buffer-bbuf i) (write-image-assemble-bytes (aref vector (index+ x 0)) (aref vector (index+ x 1)) (aref vector (index+ x 2)) (aref vector (index+ x 3)) (aref vector (index+ x 4)) (aref vector (index+ x 5)) (aref vector (index+ x 6)) (aref vector (index+ x 7)))))))) t) #+(or lcl3.0 excl) (defun fast-write-pixarray-4 (buffer-bbuf index array x y width height padded-bytes-per-line bits-per-pixel) (declare (type buffer-bytes buffer-bbuf) (type pixarray-4 array) (type int16 x y) (type card16 width height) (type array-index index padded-bytes-per-line) (type (member 1 4 8 16 24 32) bits-per-pixel) (ignore bits-per-pixel)) #.(declare-buffun) (with-vector (buffer-bbuf buffer-bytes) (with-underlying-simple-vector (vector pixarray-4-element-type array) (do* ((h 0 (index1+ h)) (y y (index1+ y)) (right-nibbles (index-mod width 2)) (middle-nibbles (index- width right-nibbles)) (middle-bytes (index-ceiling middle-nibbles 2)) (start index (index+ start padded-bytes-per-line))) ((index>= h height)) (declare (type array-index h y right-nibbles middle-nibbles middle-bytes start)) (do* ((end (index+ start middle-bytes)) (i start (index1+ i)) (start-x x) (x (array-row-major-index array y start-x) (index+ x 2))) ((index>= i end) (unless (index-zerop right-nibbles) (setf (aref buffer-bbuf end) (write-image-assemble-bytes (aref array y (index+ start-x middle-nibbles)) 0)))) (declare (type array-index end i start-x x)) (setf (aref buffer-bbuf i) (write-image-assemble-bytes (aref vector (index+ x 0)) (aref vector (index+ x 1)))))))) t) #+(or Genera lcl3.0 excl CMU sbcl) (defun fast-write-pixarray-24 (buffer-bbuf index array x y width height padded-bytes-per-line bits-per-pixel) (declare (type buffer-bytes buffer-bbuf) (type pixarray-24 array) (type int16 x y) (type card16 width height) (type array-index index padded-bytes-per-line) (type (member 1 4 8 16 24 32) bits-per-pixel) (ignore bits-per-pixel)) #.(declare-buffun) (with-vector (buffer-bbuf buffer-bytes) (with-underlying-simple-vector (vector pixarray-24-element-type array) (do* ((h 0 (index1+ h)) (y y (index1+ y)) (start index (index+ start padded-bytes-per-line))) ((index>= h height)) (declare (type array-index y start)) (do* ((end (index+ start (index* width 3))) (i start (index+ i 3)) (x (array-row-major-index array y x) (index1+ x))) ((index>= i end)) (declare (type array-index end i x)) (let ((pixel (aref vector x))) (declare (type pixarray-24-element-type pixel)) (setf (aref buffer-bbuf (index+ i 0)) (write-image-load-byte 0 pixel 24)) (setf (aref buffer-bbuf (index+ i 1)) (write-image-load-byte 8 pixel 24)) (setf (aref buffer-bbuf (index+ i 2)) (write-image-load-byte 16 pixel 24))))))) t) #+(or Genera lcl3.0 excl) (defun fast-write-pixarray-with-swap (bbuf boffset pixarray x y width height padded-bytes-per-line bits-per-pixel unit byte-lsb-first-p bit-lsb-first-p) (declare (type buffer-bytes bbuf) (type pixarray pixarray) (type card16 x y width height) (type array-index boffset padded-bytes-per-line) (type (member 1 4 8 16 24 32) bits-per-pixel) (type (member 8 16 32) unit) (type generalized-boolean byte-lsb-first-p bit-lsb-first-p)) (unless (index= bits-per-pixel 24) (let ((pixarray-padded-bits-per-line (if (index= height 1) 0 (index* (index- (array-row-major-index pixarray 1 0) (array-row-major-index pixarray 0 0)) bits-per-pixel))) (pixarray-start-bit-offset (index* (array-row-major-index pixarray y x) bits-per-pixel))) (declare (type array-index pixarray-padded-bits-per-line pixarray-start-bit-offset)) (when (if (eq *computed-image-byte-lsb-first-p* *computed-image-bit-lsb-first-p*) (and (index-zerop (index-mod pixarray-padded-bits-per-line 8)) (index-zerop (index-mod pixarray-start-bit-offset 8))) (and (index-zerop (index-mod pixarray-padded-bits-per-line +image-unit+)) (index-zerop (index-mod pixarray-start-bit-offset +image-unit+)))) (multiple-value-bind (image-swap-function image-swap-lsb-first-p) (image-swap-function bits-per-pixel +image-unit+ *computed-image-byte-lsb-first-p* *computed-image-bit-lsb-first-p* unit byte-lsb-first-p bit-lsb-first-p) (declare (type symbol image-swap-function) (type generalized-boolean image-swap-lsb-first-p)) (with-underlying-simple-vector (src card8 pixarray) (funcall (symbol-function image-swap-function) src bbuf (index-floor pixarray-start-bit-offset 8) boffset (index-ceiling (index* width bits-per-pixel) 8) (index-floor pixarray-padded-bits-per-line 8) padded-bytes-per-line height image-swap-lsb-first-p)) t))))) (defun fast-write-pixarray (bbuf boffset pixarray x y width height padded-bytes-per-line bits-per-pixel unit byte-lsb-first-p bit-lsb-first-p) (declare (type buffer-bytes bbuf) (type pixarray pixarray) (type card16 x y width height) (type array-index boffset padded-bytes-per-line) (type (member 1 4 8 16 24 32) bits-per-pixel) (type (member 8 16 32) unit) (type generalized-boolean byte-lsb-first-p bit-lsb-first-p)) (progn bbuf boffset pixarray x y width height padded-bytes-per-line bits-per-pixel unit byte-lsb-first-p bit-lsb-first-p) (or #+(or Genera lcl3.0 excl) (fast-write-pixarray-with-swap bbuf boffset pixarray x y width height padded-bytes-per-line bits-per-pixel unit byte-lsb-first-p bit-lsb-first-p) (let ((function (or #+lispm (and (= (sys:array-element-size pixarray) bits-per-pixel) (zerop (index-mod padded-bytes-per-line 4)) (zerop (index-mod (* #+Genera (sys:array-row-span pixarray) #-Genera (array-dimension pixarray 1) bits-per-pixel) 32)) #'fast-write-pixarray-using-bitblt) #+(or CMU) (and (index= (pixarray-element-size pixarray) bits-per-pixel) #'fast-write-pixarray-using-bitblt) #+(or lcl3.0 excl) (and (index= bits-per-pixel 1) #'fast-write-pixarray-1) #+(or lcl3.0 excl) (and (index= bits-per-pixel 4) #'fast-write-pixarray-4) #+(or Genera lcl3.0 excl CMU) (and (index= bits-per-pixel 24) #'fast-write-pixarray-24)))) (when function (write-pixarray-internal bbuf boffset pixarray x y width height padded-bytes-per-line bits-per-pixel function +image-unit+ +image-byte-lsb-first-p+ +image-bit-lsb-first-p+ unit byte-lsb-first-p bit-lsb-first-p))))) ;;; FAST-COPY-PIXARRAY - copy part of a pixarray into another (defun fast-copy-pixarray (pixarray copy x y width height bits-per-pixel) (declare (type pixarray pixarray copy) (type card16 x y width height) (type (member 1 4 8 16 24 32) bits-per-pixel)) (progn pixarray copy x y width height bits-per-pixel nil) (or #+(or lispm CMU) (let* ((pixarray-padded-pixels-per-line #+Genera (sys:array-row-span pixarray) #-Genera (array-dimension pixarray 1)) (pixarray-padded-bits-per-line (* pixarray-padded-pixels-per-line bits-per-pixel)) (copy-padded-pixels-per-line #+Genera (sys:array-row-span copy) #-Genera (array-dimension copy 1)) (copy-padded-bits-per-line (* copy-padded-pixels-per-line bits-per-pixel))) #-(or CMU) (when (and (= (sys:array-element-size pixarray) bits-per-pixel) (zerop (index-mod pixarray-padded-bits-per-line 32)) (zerop (index-mod copy-padded-bits-per-line 32))) (sys:bitblt boole-1 width height pixarray x y copy 0 0) t) #+(or CMU) (when (index= (pixarray-element-size pixarray) (pixarray-element-size copy) bits-per-pixel) (copy-bit-rect pixarray pixarray-padded-bits-per-line x y copy copy-padded-bits-per-line 0 0 height (index* width bits-per-pixel)) t)) #+(or lcl3.0 excl) (unless (index= bits-per-pixel 24) (let ((pixarray-padded-bits-per-line (if (index= height 1) 0 (index* (index- (array-row-major-index pixarray 1 0) (array-row-major-index pixarray 0 0)) bits-per-pixel))) (copy-padded-bits-per-line (if (index= height 1) 0 (index* (index- (array-row-major-index copy 1 0) (array-row-major-index copy 0 0)) bits-per-pixel))) (pixarray-start-bit-offset (index* (array-row-major-index pixarray y x) bits-per-pixel))) (declare (type array-index pixarray-padded-bits-per-line copy-padded-bits-per-line pixarray-start-bit-offset)) (when (if (eq *computed-image-byte-lsb-first-p* *computed-image-bit-lsb-first-p*) (and (index-zerop (index-mod pixarray-padded-bits-per-line 8)) (index-zerop (index-mod copy-padded-bits-per-line 8)) (index-zerop (index-mod pixarray-start-bit-offset 8))) (and (index-zerop (index-mod pixarray-padded-bits-per-line +image-unit+)) (index-zerop (index-mod copy-padded-bits-per-line +image-unit+)) (index-zerop (index-mod pixarray-start-bit-offset +image-unit+)))) (with-underlying-simple-vector (src card8 pixarray) (with-underlying-simple-vector (dst card8 copy) (image-noswap src dst (index-floor pixarray-start-bit-offset 8) 0 (index-ceiling (index* width bits-per-pixel) 8) (index-floor pixarray-padded-bits-per-line 8) (index-floor copy-padded-bits-per-line 8) height nil))) t))) #+(or lcl3.0 excl) (macrolet ((copy (type element-type) `(let ((pixarray pixarray) (copy copy)) (declare (type ,type pixarray copy)) #.(declare-buffun) (with-underlying-simple-vector (src ,element-type pixarray) (with-underlying-simple-vector (dst ,element-type copy) (do* ((dst-y 0 (index1+ dst-y)) (src-y y (index1+ src-y))) ((index>= dst-y height)) (declare (type card16 dst-y src-y)) (do* ((dst-idx (array-row-major-index copy dst-y 0) (index1+ dst-idx)) (dst-end (index+ dst-idx width)) (src-idx (array-row-major-index pixarray src-y x) (index1+ src-idx))) ((index>= dst-idx dst-end)) (declare (type array-index dst-idx src-idx dst-end)) (setf (aref dst dst-idx) (the ,element-type (aref src src-idx)))))))))) (ecase bits-per-pixel (1 (copy pixarray-1 pixarray-1-element-type)) (4 (copy pixarray-4 pixarray-4-element-type)) (8 (copy pixarray-8 pixarray-8-element-type)) (16 (copy pixarray-16 pixarray-16-element-type)) (24 (copy pixarray-24 pixarray-24-element-type)) (32 (copy pixarray-32 pixarray-32-element-type))) t))) ecl-16.1.2/src/clx/dep-openmcl.lisp000066400000000000000000001220701266352375300170330ustar00rootroot00000000000000;;; -*- Mode: Lisp; Package: Xlib; Log: clx.log -*- ;; This file contains some of the system dependent code for CLX ;;; ;;; TEXAS INSTRUMENTS INCORPORATED ;;; P.O. BOX 2909 ;;; AUSTIN, TEXAS 78769 ;;; ;;; Copyright (C) 1987 Texas Instruments Incorporated. ;;; ;;; Permission is granted to any individual or institution to use, copy, modify, ;;; and distribute this software, provided that this complete copyright and ;;; permission notice is maintained, intact, in all copies and supporting ;;; documentation. ;;; ;;; Texas Instruments Incorporated provides this software "as is" without ;;; express or implied warranty. ;;; (in-package :xlib) (proclaim '(declaration array-register)) ;;; The size of the output buffer. Must be a multiple of 4. (defparameter *output-buffer-size* 8192) ;;; Number of seconds to wait for a reply to a server request (defparameter *reply-timeout* nil) (progn (defconstant +word-0+ 1) (defconstant +word-1+ 0) (defconstant +long-0+ 3) (defconstant +long-1+ 2) (defconstant +long-2+ 1) (defconstant +long-3+ 0)) ;;; Set some compiler-options for often used code (eval-when (:compile-toplevel :load-toplevel :execute) (defconstant +buffer-speed+ #+clx-debugging 1 #-clx-debugging 3 "Speed compiler option for buffer code.") (defconstant +buffer-safety+ #+clx-debugging 3 #-clx-debugging 0 "Safety compiler option for buffer code.") (defconstant +buffer-debug+ #+clx-debugging 2 #-clx-debugging 1 "Debug compiler option for buffer code>") (defun declare-bufmac () `(declare (optimize (speed ,+buffer-speed+) (safety ,+buffer-safety+) (debug ,+buffer-debug+)))) ;; It's my impression that in lucid there's some way to make a ;; declaration called fast-entry or something that causes a function ;; to not do some checking on args. Sadly, we have no lucid manuals ;; here. If such a declaration is available, it would be a good ;; idea to make it here when +buffer-speed+ is 3 and +buffer-safety+ ;; is 0. (defun declare-buffun () `(declare (optimize (speed ,+buffer-speed+) (safety ,+buffer-safety+) (debug ,+buffer-debug+))))) (declaim (inline card8->int8 int8->card8 card16->int16 int16->card16 card32->int32 int32->card32)) (progn (defun card8->int8 (x) (declare (type card8 x)) (declare (clx-values int8)) #.(declare-buffun) (the int8 (if (logbitp 7 x) (the int8 (- x #x100)) x))) (defun int8->card8 (x) (declare (type int8 x)) (declare (clx-values card8)) #.(declare-buffun) (the card8 (ldb (byte 8 0) x))) (defun card16->int16 (x) (declare (type card16 x)) (declare (clx-values int16)) #.(declare-buffun) (the int16 (if (logbitp 15 x) (the int16 (- x #x10000)) x))) (defun int16->card16 (x) (declare (type int16 x)) (declare (clx-values card16)) #.(declare-buffun) (the card16 (ldb (byte 16 0) x))) (defun card32->int32 (x) (declare (type card32 x)) (declare (clx-values int32)) #.(declare-buffun) (the int32 (if (logbitp 31 x) (the int32 (- x #x100000000)) x))) (defun int32->card32 (x) (declare (type int32 x)) (declare (clx-values card32)) #.(declare-buffun) (the card32 (ldb (byte 32 0) x))) ) (declaim (inline aref-card8 aset-card8 aref-int8 aset-int8)) (progn (defun aref-card8 (a i) (declare (type buffer-bytes a) (type array-index i)) (declare (clx-values card8)) #.(declare-buffun) (the card8 (aref a i))) (defun aset-card8 (v a i) (declare (type card8 v) (type buffer-bytes a) (type array-index i)) #.(declare-buffun) (setf (aref a i) v)) (defun aref-int8 (a i) (declare (type buffer-bytes a) (type array-index i)) (declare (clx-values int8)) #.(declare-buffun) (card8->int8 (aref a i))) (defun aset-int8 (v a i) (declare (type int8 v) (type buffer-bytes a) (type array-index i)) #.(declare-buffun) (setf (aref a i) (int8->card8 v))) ) (progn (defun aref-card16 (a i) (declare (type buffer-bytes a) (type array-index i)) (declare (clx-values card16)) #.(declare-buffun) (the card16 (logior (the card16 (ash (the card8 (aref a (index+ i +word-1+))) 8)) (the card8 (aref a (index+ i +word-0+)))))) (defun aset-card16 (v a i) (declare (type card16 v) (type buffer-bytes a) (type array-index i)) #.(declare-buffun) (setf (aref a (index+ i +word-1+)) (the card8 (ldb (byte 8 8) v)) (aref a (index+ i +word-0+)) (the card8 (ldb (byte 8 0) v))) v) (defun aref-int16 (a i) (declare (type buffer-bytes a) (type array-index i)) (declare (clx-values int16)) #.(declare-buffun) (the int16 (logior (the int16 (ash (the int8 (aref-int8 a (index+ i +word-1+))) 8)) (the card8 (aref a (index+ i +word-0+)))))) (defun aset-int16 (v a i) (declare (type int16 v) (type buffer-bytes a) (type array-index i)) #.(declare-buffun) (setf (aref a (index+ i +word-1+)) (the card8 (ldb (byte 8 8) v)) (aref a (index+ i +word-0+)) (the card8 (ldb (byte 8 0) v))) v) (defun aref-card32 (a i) (declare (type buffer-bytes a) (type array-index i)) (declare (clx-values card32)) #.(declare-buffun) (the card32 (logior (the card32 (ash (the card8 (aref a (index+ i +long-3+))) 24)) (the card29 (ash (the card8 (aref a (index+ i +long-2+))) 16)) (the card16 (ash (the card8 (aref a (index+ i +long-1+))) 8)) (the card8 (aref a (index+ i +long-0+)))))) (defun aset-card32 (v a i) (declare (type card32 v) (type buffer-bytes a) (type array-index i)) #.(declare-buffun) (setf (aref a (index+ i +long-3+)) (the card8 (ldb (byte 8 24) v)) (aref a (index+ i +long-2+)) (the card8 (ldb (byte 8 16) v)) (aref a (index+ i +long-1+)) (the card8 (ldb (byte 8 8) v)) (aref a (index+ i +long-0+)) (the card8 (ldb (byte 8 0) v))) v) (defun aref-int32 (a i) (declare (type buffer-bytes a) (type array-index i)) (declare (clx-values int32)) #.(declare-buffun) (the int32 (logior (the int32 (ash (the int8 (aref-int8 a (index+ i +long-3+))) 24)) (the card29 (ash (the card8 (aref a (index+ i +long-2+))) 16)) (the card16 (ash (the card8 (aref a (index+ i +long-1+))) 8)) (the card8 (aref a (index+ i +long-0+)))))) (defun aset-int32 (v a i) (declare (type int32 v) (type buffer-bytes a) (type array-index i)) #.(declare-buffun) (setf (aref a (index+ i +long-3+)) (the card8 (ldb (byte 8 24) v)) (aref a (index+ i +long-2+)) (the card8 (ldb (byte 8 16) v)) (aref a (index+ i +long-1+)) (the card8 (ldb (byte 8 8) v)) (aref a (index+ i +long-0+)) (the card8 (ldb (byte 8 0) v))) v) (defun aref-card29 (a i) (declare (type buffer-bytes a) (type array-index i)) (declare (clx-values card29)) #.(declare-buffun) (the card29 (logior (the card29 (ash (the card8 (aref a (index+ i +long-3+))) 24)) (the card29 (ash (the card8 (aref a (index+ i +long-2+))) 16)) (the card16 (ash (the card8 (aref a (index+ i +long-1+))) 8)) (the card8 (aref a (index+ i +long-0+)))))) (defun aset-card29 (v a i) (declare (type card29 v) (type buffer-bytes a) (type array-index i)) #.(declare-buffun) (setf (aref a (index+ i +long-3+)) (the card8 (ldb (byte 8 24) v)) (aref a (index+ i +long-2+)) (the card8 (ldb (byte 8 16) v)) (aref a (index+ i +long-1+)) (the card8 (ldb (byte 8 8) v)) (aref a (index+ i +long-0+)) (the card8 (ldb (byte 8 0) v))) v) ) (defsetf aref-card8 (a i) (v) `(aset-card8 ,v ,a ,i)) (defsetf aref-int8 (a i) (v) `(aset-int8 ,v ,a ,i)) (defsetf aref-card16 (a i) (v) `(aset-card16 ,v ,a ,i)) (defsetf aref-int16 (a i) (v) `(aset-int16 ,v ,a ,i)) (defsetf aref-card32 (a i) (v) `(aset-card32 ,v ,a ,i)) (defsetf aref-int32 (a i) (v) `(aset-int32 ,v ,a ,i)) (defsetf aref-card29 (a i) (v) `(aset-card29 ,v ,a ,i)) ;;; Other random conversions (defun rgb-val->card16 (value) ;; Short floats are good enough (declare (type rgb-val value)) (declare (clx-values card16)) #.(declare-buffun) ;; Convert VALUE from float to card16 (the card16 (values (round (the rgb-val value) #.(/ 1.0s0 #xffff))))) (defun card16->rgb-val (value) ;; Short floats are good enough (declare (type card16 value)) (declare (clx-values short-float)) #.(declare-buffun) ;; Convert VALUE from card16 to float (the short-float (* (the card16 value) #.(/ 1.0s0 #xffff)))) (defun radians->int16 (value) ;; Short floats are good enough (declare (type angle value)) (declare (clx-values int16)) #.(declare-buffun) (the int16 (values (round (the angle value) #.(float (/ pi 180.0s0 64.0s0) 0.0s0))))) (defun int16->radians (value) ;; Short floats are good enough (declare (type int16 value)) (declare (clx-values short-float)) #.(declare-buffun) (the short-float (* (the int16 value) #.(coerce (/ pi 180.0 64.0) 'short-float)))) ;;----------------------------------------------------------------------------- ;; Character transformation ;;----------------------------------------------------------------------------- ;;; This stuff transforms chars to ascii codes in card8's and back. ;;; You might have to hack it a little to get it to work for your machine. (declaim (inline char->card8 card8->char)) (macrolet ((char-translators () (let ((alist `( ;; The normal ascii codes for the control characters. ,@`((#\Return . 13) (#\Linefeed . 10) (#\Rubout . 127) (#\Page . 12) (#\Tab . 9) (#\Backspace . 8) (#\Newline . 10) (#\Space . 32)) ;; The rest of the common lisp charater set with ;; the normal ascii codes for them. (#\! . 33) (#\" . 34) (#\# . 35) (#\$ . 36) (#\% . 37) (#\& . 38) (#\' . 39) (#\( . 40) (#\) . 41) (#\* . 42) (#\+ . 43) (#\, . 44) (#\- . 45) (#\. . 46) (#\/ . 47) (#\0 . 48) (#\1 . 49) (#\2 . 50) (#\3 . 51) (#\4 . 52) (#\5 . 53) (#\6 . 54) (#\7 . 55) (#\8 . 56) (#\9 . 57) (#\: . 58) (#\; . 59) (#\< . 60) (#\= . 61) (#\> . 62) (#\? . 63) (#\@ . 64) (#\A . 65) (#\B . 66) (#\C . 67) (#\D . 68) (#\E . 69) (#\F . 70) (#\G . 71) (#\H . 72) (#\I . 73) (#\J . 74) (#\K . 75) (#\L . 76) (#\M . 77) (#\N . 78) (#\O . 79) (#\P . 80) (#\Q . 81) (#\R . 82) (#\S . 83) (#\T . 84) (#\U . 85) (#\V . 86) (#\W . 87) (#\X . 88) (#\Y . 89) (#\Z . 90) (#\[ . 91) (#\\ . 92) (#\] . 93) (#\^ . 94) (#\_ . 95) (#\` . 96) (#\a . 97) (#\b . 98) (#\c . 99) (#\d . 100) (#\e . 101) (#\f . 102) (#\g . 103) (#\h . 104) (#\i . 105) (#\j . 106) (#\k . 107) (#\l . 108) (#\m . 109) (#\n . 110) (#\o . 111) (#\p . 112) (#\q . 113) (#\r . 114) (#\s . 115) (#\t . 116) (#\u . 117) (#\v . 118) (#\w . 119) (#\x . 120) (#\y . 121) (#\z . 122) (#\{ . 123) (#\| . 124) (#\} . 125) (#\~ . 126)))) (cond ((dolist (pair alist nil) (when (not (= (char-code (car pair)) (cdr pair))) (return t))) `(progn (defconstant *char-to-card8-translation-table* ',(let ((array (make-array (let ((max-char-code 255)) (dolist (pair alist) (setq max-char-code (max max-char-code (char-code (car pair))))) (1+ max-char-code)) :element-type 'card8))) (dotimes (i (length array)) (setf (aref array i) (mod i 256))) (dolist (pair alist) (setf (aref array (char-code (car pair))) (cdr pair))) array)) (defconstant *card8-to-char-translation-table* ',(let ((array (make-array 256))) (dotimes (i (length array)) (setf (aref array i) (code-char i))) (dolist (pair alist) (setf (aref array (cdr pair)) (car pair))) array)) (progn (defun char->card8 (char) (declare (type base-char char)) #.(declare-buffun) (the card8 (aref (the (simple-array card8 (*)) *char-to-card8-translation-table*) (the array-index (char-code char))))) (defun card8->char (card8) (declare (type card8 card8)) #.(declare-buffun) (the base-char (or (aref (the simple-vector *card8-to-char-translation-table*) card8) (error "Invalid CHAR code ~D." card8)))) ) #+Genera (progn (defun char->card8 (char) (declare lt:(side-effects reader reducible)) (aref *char-to-card8-translation-table* (char-code char))) (defun card8->char (card8) (declare lt:(side-effects reader reducible)) (aref *card8-to-char-translation-table* card8)) ) (dotimes (i 256) (unless (= i (char->card8 (card8->char i))) (warn "The card8->char mapping is not invertible through char->card8. Info:~%~S" (list i (card8->char i) (char->card8 (card8->char i)))) (return nil))) (dotimes (i (length *char-to-card8-translation-table*)) (let ((char (code-char i))) (unless (eql char (card8->char (char->card8 char))) (warn "The char->card8 mapping is not invertible through card8->char. Info:~%~S" (list char (char->card8 char) (card8->char (char->card8 char)))) (return nil)))))) (t `(progn (defun char->card8 (char) (declare (type base-char char)) #.(declare-buffun) (the card8 (char-code char))) (defun card8->char (card8) (declare (type card8 card8)) #.(declare-buffun) (the base-char (code-char card8))) )))))) (char-translators)) ;;----------------------------------------------------------------------------- ;; Process Locking ;; ;; Common-Lisp doesn't provide process locking primitives, so we define ;; our own here, based on Zetalisp primitives. Holding-Lock is very ;; similar to with-lock on The TI Explorer, and a little more efficient ;; than with-process-lock on a Symbolics. ;;----------------------------------------------------------------------------- ;;; MAKE-PROCESS-LOCK: Creating a process lock. (defun make-process-lock (name) (ccl:make-lock name)) ;;; HOLDING-LOCK: Execute a body of code with a lock held. ;;; The holding-lock macro takes a timeout keyword argument. EVENT-LISTEN ;;; passes its timeout to the holding-lock macro, so any timeout you want to ;;; work for event-listen you should do for holding-lock. (defmacro holding-lock ((locator display &optional whostate &key timeout) &body body) (declare (ignore timeout display)) `(ccl:with-lock-grabbed (,locator ,whostate) ,@body)) ;;; WITHOUT-ABORTS ;;; If you can inhibit asynchronous keyboard aborts inside the body of this ;;; macro, then it is a good idea to do this. This macro is wrapped around ;;; request writing and reply reading to ensure that requests are atomically ;;; written and replies are atomically read from the stream. (defmacro without-aborts (&body body) `(ccl:without-interrupts ,@body)) ;;; PROCESS-BLOCK: Wait until a given predicate returns a non-NIL value. ;;; Caller guarantees that PROCESS-WAKEUP will be called after the predicate's ;;; value changes. (defun process-block (whostate predicate &rest predicate-args) (declare (dynamic-extern predicate-args)) (apply #'ccl:process-wait whostate predicate predicate-args)) ;;; PROCESS-WAKEUP: Check some other process' wait function. (declaim (inline process-wakeup)) (defun process-wakeup (process) (declare (ignore process)) nil) ;;; CURRENT-PROCESS: Return the current process object for input locking and ;;; for calling PROCESS-WAKEUP. (declaim (inline current-process)) ;;; Default return NIL, which is acceptable even if there is a scheduler. (defun current-process () ccl::*current-process*) ;;; WITHOUT-INTERRUPTS -- provide for atomic operations. (defmacro without-interrupts (&body body) `(ccl:without-interrupts ,@body)) ;;; CONDITIONAL-STORE: ;; This should use GET-SETF-METHOD to avoid evaluating subforms multiple times. ;; It doesn't because CLtL doesn't pass the environment to GET-SETF-METHOD. (defmacro conditional-store (place old-value new-value) `(ccl::conditional-store ,place ,old-value ,new-value)) ;;;---------------------------------------------------------------------------- ;;; IO Error Recovery ;;; All I/O operations are done within a WRAP-BUF-OUTPUT macro. ;;; It prevents multiple mindless errors when the network craters. ;;; ;;;---------------------------------------------------------------------------- (defmacro wrap-buf-output ((buffer) &body body) ;; Error recovery wrapper `(unless (buffer-dead ,buffer) ,@body)) (defmacro wrap-buf-input ((buffer) &body body) (declare (ignore buffer)) ;; Error recovery wrapper `(progn ,@body)) ;;;---------------------------------------------------------------------------- ;;; System dependent IO primitives ;;; Functions for opening, reading writing forcing-output and closing ;;; the stream to the server. ;;;---------------------------------------------------------------------------- ;;; OPEN-X-STREAM - create a stream for communicating to the appropriate X ;;; server (defun open-x-stream (host display protocol) (declare (ignore protocol)) (let ((local-socket-path (unix-socket-path-from-host host display))) (if local-socket-path (ccl::make-socket :connect :active :address-family :file :remote-filename local-socket-path) (ccl::make-socket :connect :active :remote-host host :remote-port (+ 6000 display))))) ;;; BUFFER-READ-DEFAULT - read data from the X stream (defun buffer-read-default (display vector start end timeout) (declare (type display display) (type buffer-bytes vector) (type array-index start end) (type (or null (real 0 *)) timeout)) #.(declare-buffun) (let ((stream (display-input-stream display))) (declare (type (or null stream) stream)) (or (cond ((null stream)) ((listen stream) nil) ((and timeout (= timeout 0)) :timeout) ((buffer-input-wait-default display timeout))) (progn (ccl:stream-read-ivector stream vector start (- end start)) nil)))) ;;; BUFFER-WRITE-DEFAULT - write data to the X stream (defun buffer-write-default (vector display start end) (declare (type buffer-bytes vector) (type display display) (type array-index start end)) #.(declare-buffun) (let ((stream (display-output-stream display))) (declare (type (or null stream) stream)) (unless (null stream) (ccl:stream-write-ivector stream vector start (- end start))) nil)) ;;; buffer-force-output-default - force output to the X stream (defun buffer-force-output-default (display) ;; The default buffer force-output function for use with common-lisp streams (declare (type display display)) (let ((stream (display-output-stream display))) (declare (type (or null stream) stream)) (unless (null stream) (force-output stream)))) ;;; BUFFER-CLOSE-DEFAULT - close the X stream (defun buffer-close-default (display &key abort) ;; The default buffer close function for use with common-lisp streams (declare (type display display)) #.(declare-buffun) (let ((stream (display-output-stream display))) (declare (type (or null stream) stream)) (unless (null stream) (close stream :abort abort)))) ;;; BUFFER-INPUT-WAIT-DEFAULT - wait for for input to be available for the ;;; buffer. This is called in read-input between requests, so that a process ;;; waiting for input is abortable when between requests. Should return ;;; :TIMEOUT if it times out, NIL otherwise. (defun buffer-input-wait-default (display timeout) (declare (type display display) (type (or null number) timeout)) (let ((stream (display-input-stream display))) (declare (type (or null stream) stream)) (cond ((null stream)) ((listen stream) nil) ((eql timeout 0) :timeout) (t (let* ((fd (ccl::stream-device stream :input)) (ticks (and timeout (floor (* timeout ccl::*ticks-per-second*))))) (if (ccl::process-input-wait fd ticks) nil :timeout)))))) ;;; BUFFER-LISTEN-DEFAULT - returns T if there is input available for the ;;; buffer. This should never block, so it can be called from the scheduler. ;;; The default implementation is to just use listen. (defun buffer-listen-default (display) (declare (type display display)) (let ((stream (display-input-stream display))) (declare (type (or null stream) stream)) (if (null stream) t (listen stream)))) ;;;---------------------------------------------------------------------------- ;;; System dependent speed hacks ;;;---------------------------------------------------------------------------- ;; ;; WITH-STACK-LIST is used by WITH-STATE as a memory saving feature. ;; If your lisp doesn't have stack-lists, and you're worried about ;; consing garbage, you may want to re-write this to allocate and ;; initialize lists from a resource. ;; (defmacro with-stack-list ((var &rest elements) &body body) ;; SYNTAX: (WITH-STACK-LIST (var exp1 ... expN) body) ;; Equivalent to (LET ((var (MAPCAR #'EVAL '(exp1 ... expN)))) body) ;; except that the list produced by MAPCAR resides on the stack and ;; therefore DISAPPEARS when WITH-STACK-LIST is exited. `(let ((,var (list ,@elements))) (declare (type cons ,var) #+clx-ansi-common-lisp (dynamic-extent ,var)) ,@body)) (defmacro with-stack-list* ((var &rest elements) &body body) ;; SYNTAX: (WITH-STACK-LIST* (var exp1 ... expN) body) ;; Equivalent to (LET ((var (APPLY #'LIST* (MAPCAR #'EVAL '(exp1 ... expN))))) body) ;; except that the list produced by MAPCAR resides on the stack and ;; therefore DISAPPEARS when WITH-STACK-LIST is exited. `(let ((,var (list* ,@elements))) (declare (type cons ,var) (dynamic-extent ,var)) ,@body)) (declaim (inline buffer-replace)) (defun buffer-replace (buf1 buf2 start1 end1 &optional (start2 0)) (declare (type buffer-bytes buf1 buf2) (type array-index start1 end1 start2)) (replace buf1 buf2 :start1 start1 :end1 end1 :start2 start2)) (defmacro with-gcontext-bindings ((gc saved-state indexes ts-index temp-mask temp-gc) &body body) (let ((local-state (gensym)) (resets nil)) (dolist (index indexes) (push `(setf (svref ,local-state ,index) (svref ,saved-state ,index)) resets)) `(unwind-protect (progn ,@body) (let ((,local-state (gcontext-local-state ,gc))) (declare (type gcontext-state ,local-state)) ,@resets (setf (svref ,local-state ,ts-index) 0)) (when ,temp-gc (restore-gcontext-temp-state ,gc ,temp-mask ,temp-gc)) (deallocate-gcontext-state ,saved-state)))) ;;;---------------------------------------------------------------------------- ;;; How much error detection should CLX do? ;;; Several levels are possible: ;;; ;;; 1. Do the equivalent of check-type on every argument. ;;; ;;; 2. Simply report TYPE-ERROR. This eliminates overhead of all the format ;;; strings generated by check-type. ;;; ;;; 3. Do error checking only on arguments that are likely to have errors ;;; (like keyword names) ;;; ;;; 4. Do error checking only where not doing so may dammage the envirnment ;;; on a non-tagged machine (i.e. when storing into a structure that has ;;; been passed in) ;;; ;;; 5. No extra error detection code. On lispm's, ASET may barf trying to ;;; store a non-integer into a number array. ;;; ;;; How extensive should the error checking be? For example, if the server ;;; expects a CARD16, is is sufficient for CLX to check for integer, or ;;; should it also check for non-negative and less than 65536? ;;;---------------------------------------------------------------------------- ;; The +TYPE-CHECK?+ constant controls how much error checking is done. ;; Possible values are: ;; NIL - Don't do any error checking ;; t - Do the equivalent of checktype on every argument ;; :minimal - Do error checking only where errors are likely ;;; This controls macro expansion, and isn't changable at run-time You will ;;; probably want to set this to nil if you want good performance at ;;; production time. (defconstant +type-check?+ nil) ;; TYPE? is used to allow the code to do error checking at a different level from ;; the declarations. It also does some optimizations for systems that don't have ;; good compiler support for TYPEP. The definitions for CARD32, CARD16, INT16, etc. ;; include range checks. You can modify TYPE? to do less extensive checking ;; for these types if you desire. ;; ;; ### This comment is a lie! TYPE? is really also used for run-time type ;; dispatching, not just type checking. -- Ram. (defmacro type? (object type) (if (not (constantp type)) `(typep ,object ,type) (progn (setq type (eval type)) (let ((predicate (assoc type '((drawable drawable-p) (window window-p) (pixmap pixmap-p) (cursor cursor-p) (font font-p) (gcontext gcontext-p) (colormap colormap-p) (null null) (integer integerp))))) (cond (predicate `(,(second predicate) ,object)) ((eq type 'generalized-boolean) 't) ; Everything is a generalized-boolean. (+type-check?+ `(locally (declare (optimize safety)) (typep ,object ',type))) (t `(typep ,object ',type))))))) ;; X-TYPE-ERROR is the function called for type errors. ;; If you want lots of checking, but are concerned about code size, ;; this can be made into a macro that ignores some parameters. (defun x-type-error (object type &optional error-string) (x-error 'x-type-error :datum object :expected-type type :type-string error-string)) ;;----------------------------------------------------------------------------- ;; Error handlers ;; Hack up KMP error signaling using zetalisp until the real thing comes ;; along ;;----------------------------------------------------------------------------- (defun default-error-handler (display error-key &rest key-vals &key asynchronous &allow-other-keys) (declare (type generalized-boolean asynchronous) (dynamic-extent key-vals)) ;; The default display-error-handler. ;; It signals the conditions listed in the DISPLAY file. (if asynchronous (apply #'x-cerror "Ignore" error-key :display display :error-key error-key key-vals) (apply #'x-error error-key :display display :error-key error-key key-vals))) (defun x-error (condition &rest keyargs) (declare (dynamic-extent keyargs)) (apply #'error condition keyargs)) (defun x-cerror (proceed-format-string condition &rest keyargs) (declare (dynamic-extent keyargs)) (apply #'cerror proceed-format-string condition keyargs)) ;; version 15 of Pitman error handling defines the syntax for define-condition to be: ;; DEFINE-CONDITION name (parent-type) [({slot}*) {option}*] ;; Where option is one of: (:documentation doc-string) (:conc-name symbol-or-string) ;; or (:report exp) (define-condition x-error (error) ()) ;;----------------------------------------------------------------------------- ;; HOST hacking ;;----------------------------------------------------------------------------- (defun host-address (host &optional (family :internet)) ;; Return a list whose car is the family keyword (:internet :DECnet :Chaos) ;; and cdr is a list of network address bytes. (declare (type stringable host) (type (or null (member :internet :decnet :chaos) card8) family)) (declare (clx-values list)) (ecase family ((:internet nil 0) (let* ((addr (ccl::host-as-inet-host host))) (cons :internet (list (ldb (byte 8 24) addr) (ldb (byte 8 16) addr) (ldb (byte 8 8) addr) (ldb (byte 8 0) addr))))))) ;;----------------------------------------------------------------------------- ;; Whether to use closures for requests or not. ;;----------------------------------------------------------------------------- ;;; If this macro expands to non-NIL, then request and locking code is ;;; compiled in a much more compact format, as the common code is shared, and ;;; the specific code is built into a closure that is funcalled by the shared ;;; code. If your compiler makes efficient use of closures then you probably ;;; want to make this expand to T, as it makes the code more compact. (defmacro use-closures () nil) (defun clx-macroexpand (form env) (macroexpand form env)) ;;----------------------------------------------------------------------------- ;; Resource stuff ;;----------------------------------------------------------------------------- ;;; Utilities (defun getenv (name) (ccl::getenv name)) (defun get-host-name () "Return the same hostname as gethostname(3) would" (machine-instance)) (defun homedir-file-pathname (name) (merge-pathnames (user-homedir-pathname) (pathname name))) ;;; DEFAULT-RESOURCES-PATHNAME - The pathname of the resources file to load if ;;; a resource manager isn't running. (defun default-resources-pathname () (homedir-file-pathname ".Xdefaults")) ;;; RESOURCES-PATHNAME - The pathname of the resources file to load after the ;;; defaults have been loaded. (defun resources-pathname () (or (let ((string (getenv "XENVIRONMENT"))) (and string (pathname string))) (homedir-file-pathname (concatenate 'string ".Xdefaults-" (get-host-name))))) ;;; AUTHORITY-PATHNAME - The pathname of the authority file. (defun authority-pathname () (or (let ((xauthority (getenv "XAUTHORITY"))) (and xauthority (pathname xauthority))) (homedir-file-pathname ".Xauthority"))) ;;; this particular defaulting behaviour is typical to most Unices, I think (defun get-default-display (&optional display-name) "Parse the argument DISPLAY-NAME, or the environment variable $DISPLAY if it is NIL. Display names have the format [protocol/] [hostname] : [:] displaynumber [.screennumber] There are two special cases in parsing, to match that done in the Xlib C language bindings - If the hostname is ``unix'' or the empty string, any supplied protocol is ignored and a connection is made using the :local transport. - If a double colon separates hostname from displaynumber, the protocol is assumed to be decnet. Returns a list of (host display-number screen protocol)." (let* ((name (or display-name (getenv "DISPLAY") (error "DISPLAY environment variable is not set"))) (slash-i (or (position #\/ name) -1)) (colon-i (position #\: name :start (1+ slash-i))) (decnet-colon-p (eql (elt name (1+ colon-i)) #\:)) (host (subseq name (1+ slash-i) colon-i)) (dot-i (and colon-i (position #\. name :start colon-i))) (display (when colon-i (parse-integer name :start (if decnet-colon-p (+ colon-i 2) (1+ colon-i)) :end dot-i))) (screen (when dot-i (parse-integer name :start (1+ dot-i)))) (protocol (cond ((or (string= host "") (string-equal host "unix")) :local) (decnet-colon-p :decnet) ((> slash-i -1) (intern (string-upcase (subseq name 0 slash-i)) :keyword)) (t :internet)))) (list host (or display 0) (or screen 0) protocol))) ;;----------------------------------------------------------------------------- ;; GC stuff ;;----------------------------------------------------------------------------- (defun gc-cleanup () (declare (special *event-free-list* *pending-command-free-list* *reply-buffer-free-lists* *gcontext-local-state-cache* *temp-gcontext-cache*)) (setq *event-free-list* nil) (setq *pending-command-free-list* nil) (when (boundp '*reply-buffer-free-lists*) (fill *reply-buffer-free-lists* nil)) (setq *gcontext-local-state-cache* nil) (setq *temp-gcontext-cache* nil) nil) ;;----------------------------------------------------------------------------- ;; DEFAULT-KEYSYM-TRANSLATE ;;----------------------------------------------------------------------------- ;;; If object is a character, char-bits are set from state. ;;; ;;; [the following isn't implemented (should it be?)] ;;; If object is a list, it is an alist with entries: ;;; (base-char [modifiers] [mask-modifiers]) ;;; When MODIFIERS are specified, this character translation ;;; will only take effect when the specified modifiers are pressed. ;;; MASK-MODIFIERS can be used to specify a set of modifiers to ignore. ;;; When MASK-MODIFIERS is missing, all other modifiers are ignored. ;;; In ambiguous cases, the most specific translation is used. (defun default-keysym-translate (display state object) (declare (type display display) (type card16 state) (type t object) (ignore display state) (clx-values t)) object) ;;----------------------------------------------------------------------------- ;; Image stuff ;;----------------------------------------------------------------------------- ;;; Types (deftype pixarray-1-element-type () 'bit) (deftype pixarray-4-element-type () '(unsigned-byte 4)) (deftype pixarray-8-element-type () '(unsigned-byte 8)) (deftype pixarray-16-element-type () '(unsigned-byte 16)) (deftype pixarray-24-element-type () '(unsigned-byte 24)) (deftype pixarray-32-element-type () '(unsigned-byte 32)) (deftype pixarray-1 () '(array pixarray-1-element-type (* *))) (deftype pixarray-4 () '(array pixarray-4-element-type (* *))) (deftype pixarray-8 () '(array pixarray-8-element-type (* *))) (deftype pixarray-16 () '(array pixarray-16-element-type (* *))) (deftype pixarray-24 () '(array pixarray-24-element-type (* *))) (deftype pixarray-32 () '(array pixarray-32-element-type (* *))) (deftype pixarray () '(or pixarray-1 pixarray-4 pixarray-8 pixarray-16 pixarray-24 pixarray-32)) (deftype bitmap () 'pixarray-1) ;;; WITH-UNDERLYING-SIMPLE-VECTOR (defmacro with-underlying-simple-vector ((variable element-type pixarray) &body body) (declare (ignore element-type)) `(let* ((,variable (ccl::array-data-and-offset ,pixarray))) ,@body)) ;;; These are used to read and write pixels from and to CARD8s. ;;; READ-IMAGE-LOAD-BYTE is used to extract 1 and 4 bit pixels from CARD8s. (defmacro read-image-load-byte (size position integer) (unless +image-bit-lsb-first-p+ (setq position (- 7 position))) `(the (unsigned-byte ,size) (ldb (byte ,size ,position) (the card8 ,integer)))) ;;; READ-IMAGE-ASSEMBLE-BYTES is used to build 16, 24 and 32 bit pixels from ;;; the appropriate number of CARD8s. (defmacro read-image-assemble-bytes (&rest bytes) (unless +image-byte-lsb-first-p+ (setq bytes (reverse bytes))) (let ((it (first bytes)) (count 0)) (dolist (byte (rest bytes)) (setq it `(dpb (the card8 ,byte) (byte 8 ,(incf count 8)) (the (unsigned-byte ,count) ,it)))) `(the (unsigned-byte ,(* (length bytes) 8)) ,it))) ;;; WRITE-IMAGE-LOAD-BYTE is used to extract a CARD8 from a 16, 24 or 32 bit ;;; pixel. (defmacro write-image-load-byte (position integer integer-size) integer-size (unless +image-byte-lsb-first-p+ (setq position (- integer-size 8 position))) `(the card8 (ldb (byte 8 ,position) (the (unsigned-byte ,integer-size) ,integer)))) ;;; WRITE-IMAGE-ASSEMBLE-BYTES is used to build a CARD8 from 1 or 4 bit ;;; pixels. (defmacro write-image-assemble-bytes (&rest bytes) (unless +image-bit-lsb-first-p+ (setq bytes (reverse bytes))) (let ((size (floor 8 (length bytes))) (it (first bytes)) (count 0)) (dolist (byte (rest bytes)) (setq it `(dpb (the (unsigned-byte ,size) ,byte) (byte ,size ,(incf count size)) (the (unsigned-byte ,count) ,it)))) `(the card8 ,it))) ;;; If you can write fast routines that can read and write pixarrays out of a ;;; buffer-bytes, do it! It makes the image code a lot faster. The ;;; FAST-READ-PIXARRAY, FAST-WRITE-PIXARRAY and FAST-COPY-PIXARRAY routines ;;; return T if they can do it, NIL if they can't. ;;; FAST-READ-PIXARRAY - fill part of a pixarray from a buffer of card8s (defun fast-read-pixarray (bbuf boffset pixarray x y width height padded-bytes-per-line bits-per-pixel unit byte-lsb-first-p bit-lsb-first-p) (declare (ignore bbuf boffset pixarray x y width height padded-bytes-per-line bits-per-pixel unit byte-lsb-first-p bit-lsb-first-p)) nil) ;;; FAST-WRITE-PIXARRAY - copy part of a pixarray into an array of CARD8s (defun fast-write-pixarray (bbuf boffset pixarray x y width height padded-bytes-per-line bits-per-pixel unit byte-lsb-first-p bit-lsb-first-p) (declare (ignore bbuf boffset pixarray x y width height padded-bytes-per-line bits-per-pixel unit byte-lsb-first-p bit-lsp-first-p)) nil) ;;; FAST-COPY-PIXARRAY - copy part of a pixarray into another (defun fast-copy-pixarray (pixarray copy x y width height bits-per-pixel) (declare (ignore pixarray copy x y width height bits-per-pixel)) nil) ecl-16.1.2/src/clx/depdefs.lisp000066400000000000000000000625321266352375300162500ustar00rootroot00000000000000;;; -*- Mode: LISP; Syntax: Common-lisp; Package: XLIB; Base: 10; Lowercase: Yes -*- ;; This file contains some of the system dependent code for CLX ;;; ;;; TEXAS INSTRUMENTS INCORPORATED ;;; P.O. BOX 2909 ;;; AUSTIN, TEXAS 78769 ;;; ;;; Copyright (C) 1987 Texas Instruments Incorporated. ;;; ;;; Permission is granted to any individual or institution to use, copy, modify, ;;; and distribute this software, provided that this complete copyright and ;;; permission notice is maintained, intact, in all copies and supporting ;;; documentation. ;;; ;;; Texas Instruments Incorporated provides this software "as is" without ;;; express or implied warranty. ;;; (in-package :xlib) ;;;------------------------------------------------------------------------- ;;; Declarations ;;;------------------------------------------------------------------------- ;;; fix a bug in kcl's RATIONAL... ;;; redefine both the function and the type. #+(or kcl ibcl) (progn (defun rational (x) (if (rationalp x) x (lisp:rational x))) (deftype rational (&optional l u) `(lisp:rational ,l ,u))) ;;; DECLAIM #-clx-ansi-common-lisp (defmacro declaim (&rest decl-specs) (if (cdr decl-specs) `(progn ,@(mapcar #'(lambda (decl-spec) `(proclaim ',decl-spec)) decl-specs)) `(proclaim ',(car decl-specs)))) ;;; CLX-VALUES value1 value2 ... -- Documents the values returned by the function. #-Genera (declaim (declaration clx-values)) #+Genera (setf (get 'clx-values 'si:declaration-alias) 'scl:values) ;;; ARGLIST arg1 arg2 ... -- Documents the arglist of the function. Overrides ;;; the documentation that might get generated by the real arglist of the ;;; function. #-(or lispm lcl3.0) (declaim (declaration arglist)) ;;; DYNAMIC-EXTENT var -- Tells the compiler that the rest arg var has ;;; dynamic extent and therefore can be kept on the stack and not copied to ;;; the heap, even though the value is passed out of the function. #-(or clx-ansi-common-lisp lcl3.0) (declaim (declaration dynamic-extent)) ;;; IGNORABLE var -- Tells the compiler that the variable might or might not be used. #-clx-ansi-common-lisp (declaim (declaration ignorable)) ;;; INDENTATION argpos1 arginden1 argpos2 arginden2 --- Tells the lisp editor how to ;;; indent calls to the function or macro containing the declaration. #-genera (declaim (declaration indentation)) ;;;------------------------------------------------------------------------- ;;; Declaration macros ;;;------------------------------------------------------------------------- ;;; WITH-VECTOR (variable type) &body body --- ensures the variable is a local ;;; and then does a type declaration and array register declaration (defmacro with-vector ((var type) &body body) `(let ((,var ,var)) (declare (type ,type ,var)) ,@body)) ;;; WITHIN-DEFINITION (name type) &body body --- Includes definitions for ;;; Meta-. #+lispm (defmacro within-definition ((name type) &body body) `(zl:local-declare ((sys:function-parent ,name ,type)) (sys:record-source-file-name ',name ',type) ,@body)) #-lispm (defmacro within-definition ((name type) &body body) (declare (ignore name type)) `(progn ,@body)) ;;;------------------------------------------------------------------------- ;;; CLX can maintain a mapping from X server ID's to local data types. If ;;; one takes the view that CLX objects will be instance variables of ;;; objects at the next higher level, then PROCESS-EVENT will typically map ;;; from resource-id to higher-level object. In that case, the lower-level ;;; CLX mapping will almost never be used (except in rare cases like ;;; query-tree), and only serve to consume space (which is difficult to ;;; GC), in which case always-consing versions of the make-s will ;;; be better. Even when maps are maintained, it isn't clear they are ;;; useful for much beyond xatoms and windows (since almost nothing else ;;; ever comes back in events). ;;;-------------------------------------------------------------------------- (defconstant +clx-cached-types+ '(drawable window pixmap ;; gcontext cursor colormap font)) (defmacro resource-id-map-test () #+excl '#'equal #-excl '#'eql) ; (eq fixnum fixnum) is not guaranteed. (defmacro atom-cache-map-test () #+excl '#'equal #-excl '#'eq) (defmacro keysym->character-map-test () #+excl '#'equal #-excl '#'eql) ;;; You must define this to match the real byte order. It is used by ;;; overlapping array and image code. #+(or lispm vax little-endian Minima) (eval-when (eval compile load) (pushnew :clx-little-endian *features*)) #+lcl3.0 (eval-when (compile eval load) (ecase lucid::machine-endian (:big nil) (:little (pushnew :clx-little-endian *features*)))) #+cmu (eval-when (compile eval load) (ecase #.(c:backend-byte-order c:*backend*) (:big-endian) (:little-endian (pushnew :clx-little-endian *features*)))) #+sbcl (eval-when (:compile-toplevel :load-toplevel :execute) ;; FIXME: Ideally, we shouldn't end up with the internal ;; :CLX-LITTLE-ENDIAN decorating user-visible *FEATURES* lists. ;; This probably wants to be split up into :compile-toplevel ;; :execute and :load-toplevel clauses, so that loading the compiled ;; code doesn't push the feature. (ecase sb-c:*backend-byte-order* (:big-endian) (:little-endian (pushnew :clx-little-endian *features*)))) ;;; Steele's Common-Lisp states: "It is an error if the array specified ;;; as the :displaced-to argument does not have the same :element-type ;;; as the array being created" If this is the case on your lisp, then ;;; leave the overlapping-arrays feature turned off. Lisp machines ;;; (Symbolics TI and LMI) don't have this restriction, and allow arrays ;;; with different element types to overlap. CLX will take advantage of ;;; this to do fast array packing/unpacking when the overlapping-arrays ;;; feature is enabled. #+clisp (eval-when (:compile-toplevel :load-toplevel :execute) (unless system::*big-endian* (pushnew :clx-little-endian *features*))) #+(and clx-little-endian lispm) (eval-when (eval compile load) (pushnew :clx-overlapping-arrays *features*)) #+(and clx-overlapping-arrays genera) (progn (deftype overlap16 () '(unsigned-byte 16)) (deftype overlap32 () '(signed-byte 32)) ) #+(and clx-overlapping-arrays (or explorer lambda cadr)) (progn (deftype overlap16 () '(unsigned-byte 16)) (deftype overlap32 () '(unsigned-byte 32)) ) (deftype buffer-bytes () `(simple-array (unsigned-byte 8) (*))) #+clx-overlapping-arrays (progn (deftype buffer-words () `(vector overlap16)) (deftype buffer-longs () `(vector overlap32)) ) ;;; This defines a type which is a subtype of the integers. ;;; This type is used to describe all variables that can be array indices. ;;; It is here because it is used below. ;;; This is inclusive because start/end can be 1 past the end. (deftype array-index () `(integer 0 ,array-dimension-limit)) ;; this is the best place to define these? #-Genera (progn (defun make-index-typed (form) (if (constantp form) form `(the array-index ,form))) (defun make-index-op (operator args) `(the array-index (values ,(case (length args) (0 `(,operator)) (1 `(,operator ,(make-index-typed (first args)))) (2 `(,operator ,(make-index-typed (first args)) ,(make-index-typed (second args)))) (otherwise `(,operator ,(make-index-op operator (subseq args 0 (1- (length args)))) ,(make-index-typed (first (last args))))))))) (defmacro index+ (&rest numbers) (make-index-op '+ numbers)) (defmacro index-logand (&rest numbers) (make-index-op 'logand numbers)) (defmacro index-logior (&rest numbers) (make-index-op 'logior numbers)) (defmacro index- (&rest numbers) (make-index-op '- numbers)) (defmacro index* (&rest numbers) (make-index-op '* numbers)) (defmacro index1+ (number) (make-index-op '1+ (list number))) (defmacro index1- (number) (make-index-op '1- (list number))) (defmacro index-incf (place &optional (delta 1)) (make-index-op 'incf (list place delta))) (defmacro index-decf (place &optional (delta 1)) (make-index-op 'decf (list place delta))) (defmacro index-min (&rest numbers) (make-index-op 'min numbers)) (defmacro index-max (&rest numbers) (make-index-op 'max numbers)) (defmacro index-floor (number divisor) (make-index-op 'floor (list number divisor))) (defmacro index-ceiling (number divisor) (make-index-op 'ceiling (list number divisor))) (defmacro index-truncate (number divisor) (make-index-op 'truncate (list number divisor))) (defmacro index-mod (number divisor) (make-index-op 'mod (list number divisor))) (defmacro index-ash (number count) (make-index-op 'ash (list number count))) (defmacro index-plusp (number) `(plusp (the array-index ,number))) (defmacro index-zerop (number) `(zerop (the array-index ,number))) (defmacro index-evenp (number) `(evenp (the array-index ,number))) (defmacro index-oddp (number) `(oddp (the array-index ,number))) (defmacro index> (&rest numbers) `(> ,@(mapcar #'make-index-typed numbers))) (defmacro index= (&rest numbers) `(= ,@(mapcar #'make-index-typed numbers))) (defmacro index< (&rest numbers) `(< ,@(mapcar #'make-index-typed numbers))) (defmacro index>= (&rest numbers) `(>= ,@(mapcar #'make-index-typed numbers))) (defmacro index<= (&rest numbers) `(<= ,@(mapcar #'make-index-typed numbers))) ) #+Genera (progn (defmacro index+ (&rest numbers) `(+ ,@numbers)) (defmacro index-logand (&rest numbers) `(logand ,@numbers)) (defmacro index-logior (&rest numbers) `(logior ,@numbers)) (defmacro index- (&rest numbers) `(- ,@numbers)) (defmacro index* (&rest numbers) `(* ,@numbers)) (defmacro index1+ (number) `(1+ ,number)) (defmacro index1- (number) `(1- ,number)) (defmacro index-incf (place &optional (delta 1)) `(setf ,place (index+ ,place ,delta))) (defmacro index-decf (place &optional (delta 1)) `(setf ,place (index- ,place ,delta))) (defmacro index-min (&rest numbers) `(min ,@numbers)) (defmacro index-max (&rest numbers) `(max ,@numbers)) (defun positive-power-of-two-p (x) (when (symbolp x) (multiple-value-bind (constantp value) (lt:named-constant-p x) (when constantp (setq x value)))) (and (typep x 'fixnum) (plusp x) (zerop (logand x (1- x))))) (defmacro index-floor (number divisor) (cond ((eql divisor 1) number) ((and (positive-power-of-two-p divisor) (fboundp 'si:%fixnum-floor)) `(si:%fixnum-floor ,number ,divisor)) (t `(floor ,number ,divisor)))) (defmacro index-ceiling (number divisor) (cond ((eql divisor 1) number) ((and (positive-power-of-two-p divisor) (fboundp 'si:%fixnum-ceiling)) `(si:%fixnum-ceiling ,number ,divisor)) (t `(ceiling ,number ,divisor)))) (defmacro index-truncate (number divisor) (cond ((eql divisor 1) number) ((and (positive-power-of-two-p divisor) (fboundp 'si:%fixnum-floor)) `(si:%fixnum-floor ,number ,divisor)) (t `(truncate ,number ,divisor)))) (defmacro index-mod (number divisor) (cond ((and (positive-power-of-two-p divisor) (fboundp 'si:%fixnum-mod)) `(si:%fixnum-mod ,number ,divisor)) (t `(mod ,number ,divisor)))) (defmacro index-ash (number count) (cond ((eql count 0) number) ((and (typep count 'fixnum) (minusp count) (fboundp 'si:%fixnum-floor)) `(si:%fixnum-floor ,number ,(expt 2 (- count)))) ((and (typep count 'fixnum) (plusp count) (fboundp 'si:%fixnum-multiply)) `(si:%fixnum-multiply ,number ,(expt 2 count))) (t `(ash ,number ,count)))) (defmacro index-plusp (number) `(plusp ,number)) (defmacro index-zerop (number) `(zerop ,number)) (defmacro index-evenp (number) `(evenp ,number)) (defmacro index-oddp (number) `(oddp ,number)) (defmacro index> (&rest numbers) `(> ,@numbers)) (defmacro index= (&rest numbers) `(= ,@numbers)) (defmacro index< (&rest numbers) `(< ,@numbers)) (defmacro index>= (&rest numbers) `(>= ,@numbers)) (defmacro index<= (&rest numbers) `(<= ,@numbers)) ) ;;;; Stuff for BUFFER definition (defconstant +replysize+ 32.) ;; used in defstruct initializations to avoid compiler warnings (defvar *empty-bytes* (make-sequence 'buffer-bytes 0)) (declaim (type buffer-bytes *empty-bytes*)) #+clx-overlapping-arrays (progn (defvar *empty-words* (make-sequence 'buffer-words 0)) (declaim (type buffer-words *empty-words*)) ) #+clx-overlapping-arrays (progn (defvar *empty-longs* (make-sequence 'buffer-longs 0)) (declaim (type buffer-longs *empty-longs*)) ) (defstruct (reply-buffer (:conc-name reply-) (:constructor make-reply-buffer-internal) (:copier nil) (:predicate nil)) (size 0 :type array-index) ;Buffer size ;; Byte (8 bit) input buffer (ibuf8 *empty-bytes* :type buffer-bytes) ;; Word (16bit) input buffer #+clx-overlapping-arrays (ibuf16 *empty-words* :type buffer-words) ;; Long (32bit) input buffer #+clx-overlapping-arrays (ibuf32 *empty-longs* :type buffer-longs) (next nil #-explorer :type #-explorer (or null reply-buffer)) (data-size 0 :type array-index) ) (defconstant +buffer-text16-size+ 256) (deftype buffer-text16 () `(simple-array (unsigned-byte 16) (,+buffer-text16-size+))) ;; These are here because. (defparameter *xlib-package* (find-package :xlib)) (defun xintern (&rest parts) (intern (apply #'concatenate 'string (mapcar #'string parts)) *xlib-package*)) (defparameter *keyword-package* (find-package :keyword)) (defun kintern (name) (intern (string name) *keyword-package*)) ;;; Pseudo-class mechanism. (eval-when (:compile-toplevel :load-toplevel :execute) ;; FIXME: maybe we should reevaluate this? (defvar *def-clx-class-use-defclass* #+(or Genera allegro) t #+(and cmu pcl) '(XLIB:DRAWABLE XLIB:WINDOW XLIB:PIXMAP) #+(and cmu (not pcl)) nil #-(or Genera cmu allegro) nil "Controls whether DEF-CLX-CLASS uses DEFCLASS. If it is a list, it is interpreted by DEF-CLX-CLASS to be a list of type names for which DEFCLASS should be used. If it is not a list, then DEFCLASS is always used. If it is NIL, then DEFCLASS is never used, since NIL is the empty list.") ) (defmacro def-clx-class ((name &rest options) &body slots) (if (or (not (listp *def-clx-class-use-defclass*)) (member name *def-clx-class-use-defclass*)) (let ((clos-package #+clx-ansi-common-lisp (find-package :common-lisp) #-clx-ansi-common-lisp (or (find-package :clos) (find-package :pcl) (let ((lisp-pkg (find-package :lisp))) (and (find-symbol (string 'defclass) lisp-pkg) lisp-pkg)))) (constructor t) (constructor-args t) (include nil) (print-function nil) (copier t) (predicate t)) (dolist (option options) (ecase (pop option) (:constructor (setf constructor (pop option)) (setf constructor-args (if (null option) t (pop option)))) (:include (setf include (pop option))) (:print-function (setf print-function (pop option))) (:copier (setf copier (pop option))) (:predicate (setf predicate (pop option))))) (flet ((cintern (&rest symbols) (intern (apply #'concatenate 'simple-string (mapcar #'symbol-name symbols)) *package*)) (kintern (symbol) (intern (symbol-name symbol) (find-package :keyword))) (closintern (symbol) (intern (symbol-name symbol) clos-package))) (when (eq constructor t) (setf constructor (cintern 'make- name))) (when (eq copier t) (setf copier (cintern 'copy- name))) (when (eq predicate t) (setf predicate (cintern name '-p))) (when include (setf slots (append (get include 'def-clx-class) slots))) (let* ((n-slots (length slots)) (slot-names (make-list n-slots)) (slot-initforms (make-list n-slots)) (slot-types (make-list n-slots))) (dotimes (i n-slots) (let ((slot (elt slots i))) (setf (elt slot-names i) (pop slot)) (setf (elt slot-initforms i) (pop slot)) (setf (elt slot-types i) (getf slot :type t)))) `(progn (eval-when (:compile-toplevel :load-toplevel :execute) (setf (get ',name 'def-clx-class) ',slots)) ;; From here down are the system-specific expansions: (within-definition (,name def-clx-class) (,(closintern 'defclass) ,name ,(and include `(,include)) (,@(map 'list #'(lambda (slot-name slot-initform slot-type) `(,slot-name :initform ,slot-initform :type ,slot-type :accessor ,(cintern name '- slot-name) ,@(when (and constructor (or (eq constructor-args t) (member slot-name constructor-args))) `(:initarg ,(kintern slot-name))) )) slot-names slot-initforms slot-types))) ,(when constructor (if (eq constructor-args t) `(defun ,constructor (&rest args) (apply #',(closintern 'make-instance) ',name args)) `(defun ,constructor ,constructor-args (,(closintern 'make-instance) ',name ,@(mapcan #'(lambda (slot-name) (and (member slot-name slot-names) `(,(kintern slot-name) ,slot-name))) constructor-args))))) ,(when predicate #+allegro `(progn (,(closintern 'defmethod) ,predicate (object) (declare (ignore object)) nil) (,(closintern 'defmethod) ,predicate ((object ,name)) t)) #-allegro `(defun ,predicate (object) (typep object ',name))) ,(when copier `(,(closintern 'defmethod) ,copier ((.object. ,name)) (,(closintern 'with-slots) ,slot-names .object. (,(closintern 'make-instance) ',name ,@(mapcan #'(lambda (slot-name) `(,(kintern slot-name) ,slot-name)) slot-names))))) ,(when print-function `(,(closintern 'defmethod) ,(closintern 'print-object) ((object ,name) stream) (,print-function object stream 0)))))))) `(within-definition (,name def-clx-class) (defstruct (,name ,@options) ,@slots)))) #+Genera (progn (scl:defprop def-clx-class "CLX Class" si:definition-type-name) (scl:defprop def-clx-class zwei:defselect-function-spec-finder zwei:definition-function-spec-finder)) ;; We need this here so we can define DISPLAY for CLX. ;; ;; This structure is :INCLUDEd in the DISPLAY structure. ;; Overlapping (displaced) arrays are provided for byte ;; half-word and word access on both input and output. ;; (def-clx-class (buffer (:constructor nil) (:copier nil) (:predicate nil)) ;; Lock for multi-processing systems (lock (make-process-lock "CLX Buffer Lock")) #-excl (output-stream nil :type (or null stream)) #+excl (output-stream -1 :type fixnum) ;; Buffer size (size 0 :type array-index) (request-number 0 :type (unsigned-byte 16)) ;; Byte position of start of last request ;; used for appending requests and error recovery (last-request nil :type (or null array-index)) ;; Byte position of start of last flushed request (last-flushed-request nil :type (or null array-index)) ;; Current byte offset (boffset 0 :type array-index) ;; Byte (8 bit) output buffer (obuf8 *empty-bytes* :type buffer-bytes) ;; Word (16bit) output buffer #+clx-overlapping-arrays (obuf16 *empty-words* :type buffer-words) ;; Long (32bit) output buffer #+clx-overlapping-arrays (obuf32 *empty-longs* :type buffer-longs) ;; Holding buffer for 16-bit text (tbuf16 (make-sequence 'buffer-text16 +buffer-text16-size+ :initial-element 0)) ;; Probably EQ to Output-Stream #-excl (input-stream nil :type (or null stream)) #+excl (input-stream -1 :type fixnum) ;; T when the host connection has gotten errors (dead nil :type (or null (not null))) ;; T makes buffer-flush a noop. Manipulated with with-buffer-flush-inhibited. (flush-inhibit nil :type (or null (not null))) ;; Change these functions when using shared memory buffers to the server ;; Function to call when writing the buffer (write-function 'buffer-write-default) ;; Function to call when flushing the buffer (force-output-function 'buffer-force-output-default) ;; Function to call when closing a connection (close-function 'buffer-close-default) ;; Function to call when reading the buffer (input-function 'buffer-read-default) ;; Function to call to wait for data to be input (input-wait-function 'buffer-input-wait-default) ;; Function to call to listen for input data (listen-function 'buffer-listen-default) #+Genera (debug-io nil :type (or null stream)) ) ;;----------------------------------------------------------------------------- ;; Printing routines. ;;----------------------------------------------------------------------------- #-(or clx-ansi-common-lisp Genera) (defun print-unreadable-object-function (object stream type identity function) (declare #+lispm (sys:downward-funarg function)) (princ "#<" stream) (when type (let ((type (type-of object)) (pcl-package (find-package :pcl))) ;; Handle pcl type-of lossage (when (and pcl-package (symbolp type) (eq (symbol-package type) pcl-package) (string-equal (symbol-name type) "STD-INSTANCE")) (setq type (funcall (intern (symbol-name 'class-name) pcl-package) (funcall (intern (symbol-name 'class-of) pcl-package) object)))) (prin1 type stream))) (when (and type function) (princ " " stream)) (when function (funcall function)) (when (and (or type function) identity) (princ " " stream)) (when identity (princ "???" stream)) (princ ">" stream) nil) #-(or clx-ansi-common-lisp Genera) (defmacro print-unreadable-object ((object stream &key type identity) &body body) (if body `(flet ((.print-unreadable-object-body. () ,@body)) (print-unreadable-object-function ,object ,stream ,type ,identity #'.print-unreadable-object-body.)) `(print-unreadable-object-function ,object ,stream ,type ,identity nil))) ;;----------------------------------------------------------------------------- ;; Image stuff ;;----------------------------------------------------------------------------- (defconstant +image-bit-lsb-first-p+ #+clx-little-endian t #-clx-little-endian nil) (defconstant +image-byte-lsb-first-p+ #+clx-little-endian t #-clx-little-endian nil) (defconstant +image-unit+ 32) (defconstant +image-pad+ 32) ;;----------------------------------------------------------------------------- ;; Foreign Functions ;;----------------------------------------------------------------------------- #+(and lucid apollo (not lcl3.0)) (lucid::define-foreign-function '(connect-to-server "connect_to_server") '((:val host :string) (:val display :integer32)) :integer32) #+(and lucid (not apollo) (not lcl3.0)) (lucid::define-c-function connect-to-server (host display) :result-type :integer) #+lcl3.0 (lucid::def-foreign-function (connect-to-server (:language :c) (:return-type :signed-32bit)) (host :simple-string) (display :signed-32bit)) ;;----------------------------------------------------------------------------- ;; Finding the server socket ;;----------------------------------------------------------------------------- ;; These are here because dep-openmcl.lisp and dependent.lisp both need them (defconstant +X-unix-socket-path+ "/tmp/.X11-unix/X" "The location of the X socket") (defun unix-socket-path-from-host (host display) "Return the name of the unix domain socket for host and display, or nil if a network socket should be opened." (cond ((or (string= host "") (string= host "unix")) (format nil "~A~D" +X-unix-socket-path+ display)) #+darwin ((and (> (length host) 10) (string= host "tmp/launch" :end1 10)) (format nil "/~A:~D" host display)) (t nil))) ecl-16.1.2/src/clx/dependent.lisp000066400000000000000000004673511266352375300166140ustar00rootroot00000000000000;;; -*- Mode: Lisp; Package: Xlib; Log: clx.log -*- ;; This file contains some of the system dependent code for CLX ;;; ;;; TEXAS INSTRUMENTS INCORPORATED ;;; P.O. BOX 2909 ;;; AUSTIN, TEXAS 78769 ;;; ;;; Copyright (C) 1987 Texas Instruments Incorporated. ;;; ;;; Permission is granted to any individual or institution to use, copy, modify, ;;; and distribute this software, provided that this complete copyright and ;;; permission notice is maintained, intact, in all copies and supporting ;;; documentation. ;;; ;;; Texas Instruments Incorporated provides this software "as is" without ;;; express or implied warranty. ;;; (in-package :xlib) (proclaim '(declaration array-register)) #+cmu (setf (getf ext:*herald-items* :xlib) `(" CLX X Library " ,*version*)) ;;; The size of the output buffer. Must be a multiple of 4. (defparameter *output-buffer-size* 8192) #+explorer (zwei:define-indentation event-case (1 1)) ;;; Number of seconds to wait for a reply to a server request (defparameter *reply-timeout* nil) #-(or clx-overlapping-arrays (not clx-little-endian)) (progn (defconstant +word-0+ 0) (defconstant +word-1+ 1) (defconstant +long-0+ 0) (defconstant +long-1+ 1) (defconstant +long-2+ 2) (defconstant +long-3+ 3)) #-(or clx-overlapping-arrays clx-little-endian) (progn (defconstant +word-0+ 1) (defconstant +word-1+ 0) (defconstant +long-0+ 3) (defconstant +long-1+ 2) (defconstant +long-2+ 1) (defconstant +long-3+ 0)) ;;; Set some compiler-options for often used code (eval-when (:compile-toplevel :load-toplevel :execute) (defconstant +buffer-speed+ #+clx-debugging 1 #-clx-debugging 3 "Speed compiler option for buffer code.") (defconstant +buffer-safety+ #+clx-debugging 3 #-clx-debugging 0 "Safety compiler option for buffer code.") (defconstant +buffer-debug+ #+clx-debugging 2 #-clx-debugging 1 "Debug compiler option for buffer code>") (defun declare-bufmac () `(declare (optimize (speed ,+buffer-speed+) (safety ,+buffer-safety+) (debug ,+buffer-debug+)))) ;; It's my impression that in lucid there's some way to make a ;; declaration called fast-entry or something that causes a function ;; to not do some checking on args. Sadly, we have no lucid manuals ;; here. If such a declaration is available, it would be a good ;; idea to make it here when +buffer-speed+ is 3 and +buffer-safety+ ;; is 0. (defun declare-buffun () `(declare (optimize (speed ,+buffer-speed+) (safety ,+buffer-safety+) (debug ,+buffer-debug+))))) (declaim (inline card8->int8 int8->card8 card16->int16 int16->card16 card32->int32 int32->card32)) #-Genera (progn (defun card8->int8 (x) (declare (type card8 x)) (declare (clx-values int8)) #.(declare-buffun) (the int8 (if (logbitp 7 x) (the int8 (- x #x100)) x))) (defun int8->card8 (x) (declare (type int8 x)) (declare (clx-values card8)) #.(declare-buffun) (the card8 (ldb (byte 8 0) x))) (defun card16->int16 (x) (declare (type card16 x)) (declare (clx-values int16)) #.(declare-buffun) (the int16 (if (logbitp 15 x) (the int16 (- x #x10000)) x))) (defun int16->card16 (x) (declare (type int16 x)) (declare (clx-values card16)) #.(declare-buffun) (the card16 (ldb (byte 16 0) x))) (defun card32->int32 (x) (declare (type card32 x)) (declare (clx-values int32)) #.(declare-buffun) (the int32 (if (logbitp 31 x) (the int32 (- x #x100000000)) x))) (defun int32->card32 (x) (declare (type int32 x)) (declare (clx-values card32)) #.(declare-buffun) (the card32 (ldb (byte 32 0) x))) ) #+Genera (progn (defun card8->int8 (x) (declare lt:(side-effects simple reducible)) (if (logbitp 7 x) (- x #x100) x)) (defun int8->card8 (x) (declare lt:(side-effects simple reducible)) (ldb (byte 8 0) x)) (defun card16->int16 (x) (declare lt:(side-effects simple reducible)) (if (logbitp 15 x) (- x #x10000) x)) (defun int16->card16 (x) (declare lt:(side-effects simple reducible)) (ldb (byte 16 0) x)) (defun card32->int32 (x) (declare lt:(side-effects simple reducible)) (sys:%logldb (byte 32 0) x)) (defun int32->card32 (x) (declare lt:(side-effects simple reducible)) (ldb (byte 32 0) x)) ) (declaim (inline aref-card8 aset-card8 aref-int8 aset-int8)) #-(or Genera lcl3.0 excl) (progn (defun aref-card8 (a i) (declare (type buffer-bytes a) (type array-index i)) (declare (clx-values card8)) #.(declare-buffun) (the card8 (aref a i))) (defun aset-card8 (v a i) (declare (type card8 v) (type buffer-bytes a) (type array-index i)) #.(declare-buffun) (setf (aref a i) v)) (defun aref-int8 (a i) (declare (type buffer-bytes a) (type array-index i)) (declare (clx-values int8)) #.(declare-buffun) (card8->int8 (aref a i))) (defun aset-int8 (v a i) (declare (type int8 v) (type buffer-bytes a) (type array-index i)) #.(declare-buffun) (setf (aref a i) (int8->card8 v))) ) #+Genera (progn (defun aref-card8 (a i) (aref a i)) (defun aset-card8 (v a i) (zl:aset v a i)) (defun aref-int8 (a i) (card8->int8 (aref a i))) (defun aset-int8 (v a i) (zl:aset (int8->card8 v) a i)) ) #+(or excl lcl3.0 clx-overlapping-arrays) (declaim (inline aref-card16 aref-int16 aref-card32 aref-int32 aref-card29 aset-card16 aset-int16 aset-card32 aset-int32 aset-card29)) #+(and clx-overlapping-arrays Genera) (progn (defun aref-card16 (a i) (aref a i)) (defun aset-card16 (v a i) (zl:aset v a i)) (defun aref-int16 (a i) (card16->int16 (aref a i))) (defun aset-int16 (v a i) (zl:aset (int16->card16 v) a i) v) (defun aref-card32 (a i) (int32->card32 (aref a i))) (defun aset-card32 (v a i) (zl:aset (card32->int32 v) a i)) (defun aref-int32 (a i) (aref a i)) (defun aset-int32 (v a i) (zl:aset v a i)) (defun aref-card29 (a i) (aref a i)) (defun aset-card29 (v a i) (zl:aset v a i)) ) #+(and clx-overlapping-arrays (not Genera)) (progn (defun aref-card16 (a i) (aref a i)) (defun aset-card16 (v a i) (setf (aref a i) v)) (defun aref-int16 (a i) (card16->int16 (aref a i))) (defun aset-int16 (v a i) (setf (aref a i) (int16->card16 v)) v) (defun aref-card32 (a i) (aref a i)) (defun aset-card32 (v a i) (setf (aref a i) v)) (defun aref-int32 (a i) (card32->int32 (aref a i))) (defun aset-int32 (v a i) (setf (aref a i) (int32->card32 v)) v) (defun aref-card29 (a i) (aref a i)) (defun aset-card29 (v a i) (setf (aref a i) v)) ) #+excl (progn (defun aref-card8 (a i) (declare (type buffer-bytes a) (type array-index i)) (declare (clx-values card8)) #.(declare-buffun) (the card8 (sys:memref a #.(comp::mdparam 'comp::md-svector-data0-adj) i :unsigned-byte))) (defun aset-card8 (v a i) (declare (type card8 v) (type buffer-bytes a) (type array-index i)) #.(declare-buffun) (setf (sys:memref a #.(comp::mdparam 'comp::md-svector-data0-adj) i :unsigned-byte) v)) (defun aref-int8 (a i) (declare (type buffer-bytes a) (type array-index i)) (declare (clx-values int8)) #.(declare-buffun) (the int8 (sys:memref a #.(comp::mdparam 'comp::md-svector-data0-adj) i :signed-byte))) (defun aset-int8 (v a i) (declare (type int8 v) (type buffer-bytes a) (type array-index i)) #.(declare-buffun) (setf (sys:memref a #.(comp::mdparam 'comp::md-svector-data0-adj) i :signed-byte) v)) (defun aref-card16 (a i) (declare (type buffer-bytes a) (type array-index i)) (declare (clx-values card16)) #.(declare-buffun) (the card16 (sys:memref a #.(comp::mdparam 'comp::md-svector-data0-adj) i :unsigned-word))) (defun aset-card16 (v a i) (declare (type card16 v) (type buffer-bytes a) (type array-index i)) #.(declare-buffun) (setf (sys:memref a #.(comp::mdparam 'comp::md-svector-data0-adj) i :unsigned-word) v)) (defun aref-int16 (a i) (declare (type buffer-bytes a) (type array-index i)) (declare (clx-values int16)) #.(declare-buffun) (the int16 (sys:memref a #.(comp::mdparam 'comp::md-svector-data0-adj) i :signed-word))) (defun aset-int16 (v a i) (declare (type int16 v) (type buffer-bytes a) (type array-index i)) #.(declare-buffun) (setf (sys:memref a #.(comp::mdparam 'comp::md-svector-data0-adj) i :signed-word) v)) (defun aref-card32 (a i) (declare (type buffer-bytes a) (type array-index i)) (declare (clx-values card32)) #.(declare-buffun) (the card32 (sys:memref a #.(comp::mdparam 'comp::md-svector-data0-adj) i :unsigned-long))) (defun aset-card32 (v a i) (declare (type card32 v) (type buffer-bytes a) (type array-index i)) #.(declare-buffun) (setf (sys:memref a #.(comp::mdparam 'comp::md-svector-data0-adj) i :unsigned-long) v)) (defun aref-int32 (a i) (declare (type buffer-bytes a) (type array-index i)) (declare (clx-values int32)) #.(declare-buffun) (the int32 (sys:memref a #.(comp::mdparam 'comp::md-svector-data0-adj) i :signed-long))) (defun aset-int32 (v a i) (declare (type int32 v) (type buffer-bytes a) (type array-index i)) #.(declare-buffun) (setf (sys:memref a #.(comp::mdparam 'comp::md-svector-data0-adj) i :signed-long) v)) (defun aref-card29 (a i) (declare (type buffer-bytes a) (type array-index i)) (declare (clx-values card29)) #.(declare-buffun) (the card29 (sys:memref a #.(comp::mdparam 'comp::md-svector-data0-adj) i :unsigned-long))) (defun aset-card29 (v a i) (declare (type card29 v) (type buffer-bytes a) (type array-index i)) #.(declare-buffun) (setf (sys:memref a #.(comp::mdparam 'comp::md-svector-data0-adj) i :unsigned-long) v)) ) #+lcl3.0 (progn (defun aref-card8 (a i) (declare (type buffer-bytes a) (type array-index i) (clx-values card8)) #.(declare-buffun) (the card8 (lucid::%svref-8bit a i))) (defun aset-card8 (v a i) (declare (type card8 v) (type buffer-bytes a) (type array-index i)) #.(declare-buffun) (setf (lucid::%svref-8bit a i) v)) (defun aref-int8 (a i) (declare (type buffer-bytes a) (type array-index i) (clx-values int8)) #.(declare-buffun) (the int8 (lucid::%svref-signed-8bit a i))) (defun aset-int8 (v a i) (declare (type int8 v) (type buffer-bytes a) (type array-index i)) #.(declare-buffun) (setf (lucid::%svref-signed-8bit a i) v)) (defun aref-card16 (a i) (declare (type buffer-bytes a) (type array-index i) (clx-values card16)) #.(declare-buffun) (the card16 (lucid::%svref-16bit a (index-ash i -1)))) (defun aset-card16 (v a i) (declare (type card16 v) (type buffer-bytes a) (type array-index i)) #.(declare-buffun) (setf (lucid::%svref-16bit a (index-ash i -1)) v)) (defun aref-int16 (a i) (declare (type buffer-bytes a) (type array-index i) (clx-values int16)) #.(declare-buffun) (the int16 (lucid::%svref-signed-16bit a (index-ash i -1)))) (defun aset-int16 (v a i) (declare (type int16 v) (type buffer-bytes a) (type array-index i)) #.(declare-buffun) (setf (lucid::%svref-signed-16bit a (index-ash i -1)) v)) (defun aref-card32 (a i) (declare (type buffer-bytes a) (type array-index i) (clx-values card32)) #.(declare-buffun) (the card32 (lucid::%svref-32bit a (index-ash i -2)))) (defun aset-card32 (v a i) (declare (type card32 v) (type buffer-bytes a) (type array-index i)) #.(declare-buffun) (setf (lucid::%svref-32bit a (index-ash i -2)) v)) (defun aref-int32 (a i) (declare (type buffer-bytes a) (type array-index i) (clx-values int32)) #.(declare-buffun) (the int32 (lucid::%svref-signed-32bit a (index-ash i -2)))) (defun aset-int32 (v a i) (declare (type int32 v) (type buffer-bytes a) (type array-index i)) #.(declare-buffun) (setf (lucid::%svref-signed-32bit a (index-ash i -2)) v)) (defun aref-card29 (a i) (declare (type buffer-bytes a) (type array-index i) (clx-values card29)) #.(declare-buffun) (the card29 (lucid::%svref-32bit a (index-ash i -2)))) (defun aset-card29 (v a i) (declare (type card29 v) (type buffer-bytes a) (type array-index i)) #.(declare-buffun) (setf (lucid::%svref-32bit a (index-ash i -2)) v)) ) #-(or excl lcl3.0 clx-overlapping-arrays) (progn (defun aref-card16 (a i) (declare (type buffer-bytes a) (type array-index i)) (declare (clx-values card16)) #.(declare-buffun) (the card16 (logior (the card16 (ash (the card8 (aref a (index+ i +word-1+))) 8)) (the card8 (aref a (index+ i +word-0+)))))) (defun aset-card16 (v a i) (declare (type card16 v) (type buffer-bytes a) (type array-index i)) #.(declare-buffun) (setf (aref a (index+ i +word-1+)) (the card8 (ldb (byte 8 8) v)) (aref a (index+ i +word-0+)) (the card8 (ldb (byte 8 0) v))) v) (defun aref-int16 (a i) (declare (type buffer-bytes a) (type array-index i)) (declare (clx-values int16)) #.(declare-buffun) (the int16 (logior (the int16 (ash (the int8 (aref-int8 a (index+ i +word-1+))) 8)) (the card8 (aref a (index+ i +word-0+)))))) (defun aset-int16 (v a i) (declare (type int16 v) (type buffer-bytes a) (type array-index i)) #.(declare-buffun) (setf (aref a (index+ i +word-1+)) (the card8 (ldb (byte 8 8) v)) (aref a (index+ i +word-0+)) (the card8 (ldb (byte 8 0) v))) v) (defun aref-card32 (a i) (declare (type buffer-bytes a) (type array-index i)) (declare (clx-values card32)) #.(declare-buffun) (the card32 (logior (the card32 (ash (the card8 (aref a (index+ i +long-3+))) 24)) (the card29 (ash (the card8 (aref a (index+ i +long-2+))) 16)) (the card16 (ash (the card8 (aref a (index+ i +long-1+))) 8)) (the card8 (aref a (index+ i +long-0+)))))) (defun aset-card32 (v a i) (declare (type card32 v) (type buffer-bytes a) (type array-index i)) #.(declare-buffun) (setf (aref a (index+ i +long-3+)) (the card8 (ldb (byte 8 24) v)) (aref a (index+ i +long-2+)) (the card8 (ldb (byte 8 16) v)) (aref a (index+ i +long-1+)) (the card8 (ldb (byte 8 8) v)) (aref a (index+ i +long-0+)) (the card8 (ldb (byte 8 0) v))) v) (defun aref-int32 (a i) (declare (type buffer-bytes a) (type array-index i)) (declare (clx-values int32)) #.(declare-buffun) (the int32 (logior (the int32 (ash (the int8 (aref-int8 a (index+ i +long-3+))) 24)) (the card29 (ash (the card8 (aref a (index+ i +long-2+))) 16)) (the card16 (ash (the card8 (aref a (index+ i +long-1+))) 8)) (the card8 (aref a (index+ i +long-0+)))))) (defun aset-int32 (v a i) (declare (type int32 v) (type buffer-bytes a) (type array-index i)) #.(declare-buffun) (setf (aref a (index+ i +long-3+)) (the card8 (ldb (byte 8 24) v)) (aref a (index+ i +long-2+)) (the card8 (ldb (byte 8 16) v)) (aref a (index+ i +long-1+)) (the card8 (ldb (byte 8 8) v)) (aref a (index+ i +long-0+)) (the card8 (ldb (byte 8 0) v))) v) (defun aref-card29 (a i) (declare (type buffer-bytes a) (type array-index i)) (declare (clx-values card29)) #.(declare-buffun) (the card29 (logior (the card29 (ash (the card8 (aref a (index+ i +long-3+))) 24)) (the card29 (ash (the card8 (aref a (index+ i +long-2+))) 16)) (the card16 (ash (the card8 (aref a (index+ i +long-1+))) 8)) (the card8 (aref a (index+ i +long-0+)))))) (defun aset-card29 (v a i) (declare (type card29 v) (type buffer-bytes a) (type array-index i)) #.(declare-buffun) (setf (aref a (index+ i +long-3+)) (the card8 (ldb (byte 8 24) v)) (aref a (index+ i +long-2+)) (the card8 (ldb (byte 8 16) v)) (aref a (index+ i +long-1+)) (the card8 (ldb (byte 8 8) v)) (aref a (index+ i +long-0+)) (the card8 (ldb (byte 8 0) v))) v) ) (defsetf aref-card8 (a i) (v) `(aset-card8 ,v ,a ,i)) (defsetf aref-int8 (a i) (v) `(aset-int8 ,v ,a ,i)) (defsetf aref-card16 (a i) (v) `(aset-card16 ,v ,a ,i)) (defsetf aref-int16 (a i) (v) `(aset-int16 ,v ,a ,i)) (defsetf aref-card32 (a i) (v) `(aset-card32 ,v ,a ,i)) (defsetf aref-int32 (a i) (v) `(aset-int32 ,v ,a ,i)) (defsetf aref-card29 (a i) (v) `(aset-card29 ,v ,a ,i)) ;;; Other random conversions (defun rgb-val->card16 (value) ;; Short floats are good enough (declare (type rgb-val value)) (declare (clx-values card16)) #.(declare-buffun) ;; Convert VALUE from float to card16 (the card16 (values (round (the rgb-val value) #.(/ 1.0s0 #xffff))))) (defun card16->rgb-val (value) ;; Short floats are good enough (declare (type card16 value)) (declare (clx-values short-float)) #.(declare-buffun) ;; Convert VALUE from card16 to float (the short-float (* (the card16 value) #.(/ 1.0s0 #xffff)))) (defun radians->int16 (value) ;; Short floats are good enough (declare (type angle value)) (declare (clx-values int16)) #.(declare-buffun) (the int16 (values (round (the angle value) #.(float (/ pi 180.0s0 64.0s0) 0.0s0))))) (defun int16->radians (value) ;; Short floats are good enough (declare (type int16 value)) (declare (clx-values short-float)) #.(declare-buffun) (the short-float (* (the int16 value) #.(coerce (/ pi 180.0 64.0) 'short-float)))) #+(or cmu sbcl clisp ecl) (progn ;;; This overrides the (probably incorrect) definition in clx.lisp. Since PI ;;; is irrational, there can't be a precise rational representation. In ;;; particular, the different float approximations will always be /=. This ;;; causes problems with type checking, because people might compute an ;;; argument in any precision. What we do is discard all the excess precision ;;; in the value, and see if the protocol encoding falls in the desired range ;;; (64'ths of a degree.) ;;; (deftype angle () '(satisfies anglep)) (defun anglep (x) (and (typep x 'real) (<= (* -360 64) (radians->int16 x) (* 360 64)))) ) ;;----------------------------------------------------------------------------- ;; Character transformation ;;----------------------------------------------------------------------------- ;;; This stuff transforms chars to ascii codes in card8's and back. ;;; You might have to hack it a little to get it to work for your machine. (declaim (inline char->card8 card8->char)) (macrolet ((char-translators () (let ((alist `(#-lispm ;; The normal ascii codes for the control characters. ,@`((#\Return . 13) (#\Linefeed . 10) (#\Rubout . 127) (#\Page . 12) (#\Tab . 9) (#\Backspace . 8) (#\Newline . 10) (#\Space . 32)) ;; One the lispm, #\Newline is #\Return, but we'd really like ;; #\Newline to translate to ascii code 10, so we swap the ;; Ascii codes for #\Return and #\Linefeed. We also provide ;; mappings from the counterparts of these control characters ;; so that the character mapping from the lisp machine ;; character set to ascii is invertible. #+lispm ,@`((#\Return . 10) (,(code-char 10) . ,(char-code #\Return)) (#\Linefeed . 13) (,(code-char 13) . ,(char-code #\Linefeed)) (#\Rubout . 127) (,(code-char 127) . ,(char-code #\Rubout)) (#\Page . 12) (,(code-char 12) . ,(char-code #\Page)) (#\Tab . 9) (,(code-char 9) . ,(char-code #\Tab)) (#\Backspace . 8) (,(code-char 8) . ,(char-code #\Backspace)) (#\Newline . 10) (,(code-char 10) . ,(char-code #\Newline)) (#\Space . 32) (,(code-char 32) . ,(char-code #\Space))) ;; The rest of the common lisp charater set with the normal ;; ascii codes for them. (#\! . 33) (#\" . 34) (#\# . 35) (#\$ . 36) (#\% . 37) (#\& . 38) (#\' . 39) (#\( . 40) (#\) . 41) (#\* . 42) (#\+ . 43) (#\, . 44) (#\- . 45) (#\. . 46) (#\/ . 47) (#\0 . 48) (#\1 . 49) (#\2 . 50) (#\3 . 51) (#\4 . 52) (#\5 . 53) (#\6 . 54) (#\7 . 55) (#\8 . 56) (#\9 . 57) (#\: . 58) (#\; . 59) (#\< . 60) (#\= . 61) (#\> . 62) (#\? . 63) (#\@ . 64) (#\A . 65) (#\B . 66) (#\C . 67) (#\D . 68) (#\E . 69) (#\F . 70) (#\G . 71) (#\H . 72) (#\I . 73) (#\J . 74) (#\K . 75) (#\L . 76) (#\M . 77) (#\N . 78) (#\O . 79) (#\P . 80) (#\Q . 81) (#\R . 82) (#\S . 83) (#\T . 84) (#\U . 85) (#\V . 86) (#\W . 87) (#\X . 88) (#\Y . 89) (#\Z . 90) (#\[ . 91) (#\\ . 92) (#\] . 93) (#\^ . 94) (#\_ . 95) (#\` . 96) (#\a . 97) (#\b . 98) (#\c . 99) (#\d . 100) (#\e . 101) (#\f . 102) (#\g . 103) (#\h . 104) (#\i . 105) (#\j . 106) (#\k . 107) (#\l . 108) (#\m . 109) (#\n . 110) (#\o . 111) (#\p . 112) (#\q . 113) (#\r . 114) (#\s . 115) (#\t . 116) (#\u . 117) (#\v . 118) (#\w . 119) (#\x . 120) (#\y . 121) (#\z . 122) (#\{ . 123) (#\| . 124) (#\} . 125) (#\~ . 126)))) (cond ((dolist (pair alist nil) (when (not (= (char-code (car pair)) (cdr pair))) (return t))) `(progn (defconstant *char-to-card8-translation-table* ',(let ((array (make-array (let ((max-char-code 255)) (dolist (pair alist) (setq max-char-code (max max-char-code (char-code (car pair))))) (1+ max-char-code)) :element-type 'card8))) (dotimes (i (length array)) (setf (aref array i) (mod i 256))) (dolist (pair alist) (setf (aref array (char-code (car pair))) (cdr pair))) array)) (defconstant *card8-to-char-translation-table* ',(let ((array (make-array 256))) (dotimes (i (length array)) (setf (aref array i) (code-char i))) (dolist (pair alist) (setf (aref array (cdr pair)) (car pair))) array)) #-Genera (progn (defun char->card8 (char) (declare (type base-char char)) #.(declare-buffun) (the card8 (aref (the (simple-array card8 (*)) *char-to-card8-translation-table*) (the array-index (char-code char))))) (defun card8->char (card8) (declare (type card8 card8)) #.(declare-buffun) (the base-char (or (aref (the simple-vector *card8-to-char-translation-table*) card8) (error "Invalid CHAR code ~D." card8)))) ) #+Genera (progn (defun char->card8 (char) (declare lt:(side-effects reader reducible)) (aref *char-to-card8-translation-table* (char-code char))) (defun card8->char (card8) (declare lt:(side-effects reader reducible)) (aref *card8-to-char-translation-table* card8)) ) #-Minima (dotimes (i 256) (unless (= i (char->card8 (card8->char i))) (warn "The card8->char mapping is not invertible through char->card8. Info:~%~S" (list i (card8->char i) (char->card8 (card8->char i)))) (return nil))) #-Minima (dotimes (i (length *char-to-card8-translation-table*)) (let ((char (code-char i))) (unless (eql char (card8->char (char->card8 char))) (warn "The char->card8 mapping is not invertible through card8->char. Info:~%~S" (list char (char->card8 char) (card8->char (char->card8 char)))) (return nil)))))) (t `(progn (defun char->card8 (char) (declare (type base-char char)) #.(declare-buffun) (the card8 (char-code char))) (defun card8->char (card8) (declare (type card8 card8)) #.(declare-buffun) (the base-char (code-char card8))) )))))) (char-translators)) ;;----------------------------------------------------------------------------- ;; Process Locking ;; ;; Common-Lisp doesn't provide process locking primitives, so we define ;; our own here, based on Zetalisp primitives. Holding-Lock is very ;; similar to with-lock on The TI Explorer, and a little more efficient ;; than with-process-lock on a Symbolics. ;;----------------------------------------------------------------------------- ;;; MAKE-PROCESS-LOCK: Creating a process lock. #-(or LispM excl Minima sbcl (and cmu mp) (and ecl threads)) (defun make-process-lock (name) (declare (ignore name)) nil) #+excl (defun make-process-lock (name) (mp:make-process-lock :name name)) #+(and LispM (not Genera)) (defun make-process-lock (name) (vector nil name)) #+Genera (defun make-process-lock (name) (process:make-lock name :flavor 'clx-lock)) #+Minima (defun make-process-lock (name) (minima:make-lock name :recursive t)) #+(and cmu mp) (defun make-process-lock (name) (mp:make-lock name)) #+sbcl (defun make-process-lock (name) (sb-thread:make-mutex :name name)) #+(and ecl threads) (defun make-process-lock (name) (mp:make-lock :name name :recursive t)) ;;; HOLDING-LOCK: Execute a body of code with a lock held. ;;; The holding-lock macro takes a timeout keyword argument. EVENT-LISTEN ;;; passes its timeout to the holding-lock macro, so any timeout you want to ;;; work for event-listen you should do for holding-lock. ;; If you're not sharing DISPLAY objects within a multi-processing ;; shared-memory environment, this is sufficient #-(or lispm excl lcl3.0 Minima sbcl (and CMU mp) (and ecl threads)) (defmacro holding-lock ((locator display &optional whostate &key timeout) &body body) (declare (ignore locator display whostate timeout)) `(progn ,@body)) ;;; HOLDING-LOCK for CMU Common Lisp. ;;; ;;; We are not multi-processing, but we use this macro to try to protect ;;; against re-entering request functions. This can happen if an interrupt ;;; occurs and the handler attempts to use X over the same display connection. ;;; This can happen if the GC hooks are used to notify the user over the same ;;; display connection. We inhibit GC notifications since display of them ;;; could cause recursive entry into CLX. ;;; #+(and CMU (not mp)) (defmacro holding-lock ((locator display &optional whostate &key timeout) &body body) `(let #+cmu((ext:*gc-verbose* nil) (ext:*gc-inhibit-hook* nil) (ext:*before-gc-hooks* nil) (ext:*after-gc-hooks* nil)) #+sbcl() ,locator ,display ,whostate ,timeout (system:without-interrupts (progn ,@body)))) ;;; HOLDING-LOCK for CMU Common Lisp with multi-processes. ;;; #+(and cmu mp) (defmacro holding-lock ((lock display &optional (whostate "CLX wait") &key timeout) &body body) (declare (ignore display)) `(mp:with-lock-held (,lock ,whostate ,@(and timeout `(:timeout ,timeout))) ,@body)) #+clisp (defmacro holding-lock ((lock display &optional (whostate "CLX wait") &key timeout) &body body) (declare (ignore lock display whostate timeout)) `(progn ,@body)) #+(and ecl threads) (defmacro holding-lock ((lock display &optional (whostate "CLX wait") &key timeout) &body body) (declare (ignore display)) `(mp::with-lock (,lock) ,@body)) #+sbcl (defmacro holding-lock ((lock display &optional (whostate "CLX wait") &key timeout) &body body) ;; This macro is used by WITH-DISPLAY, which claims to be callable ;; recursively. So, had better use a recursive lock. ;; ;; FIXME: This is hideously ugly. If WITH-TIMEOUT handled NIL ;; timeouts... (declare (ignore display whostate)) (if timeout `(if ,timeout (handler-case (sb-ext:with-timeout ,timeout (sb-thread:with-recursive-lock (,lock) ,@body)) (sb-ext:timeout () nil)) (sb-thread:with-recursive-lock (,lock) ,@body)) `(sb-thread:with-recursive-lock (,lock) ,@body))) #+Genera (defmacro holding-lock ((locator display &optional whostate &key timeout) &body body) (declare (ignore whostate)) `(process:with-lock (,locator :timeout ,timeout) (let ((.debug-io. (buffer-debug-io ,display))) (scl:let-if .debug-io. ((*debug-io* .debug-io.)) ,@body)))) #+(and lispm (not Genera)) (defmacro holding-lock ((locator display &optional whostate &key timeout) &body body) (declare (ignore display)) ;; This macro is for use in a multi-process environment. (let ((lock (gensym)) (have-lock (gensym)) (timeo (gensym))) `(let* ((,lock (zl:locf (svref ,locator 0))) (,have-lock (eq (car ,lock) sys:current-process)) (,timeo ,timeout)) (unwind-protect (when (cond (,have-lock) ((#+explorer si:%store-conditional #-explorer sys:store-conditional ,lock nil sys:current-process)) ((null ,timeo) (sys:process-lock ,lock nil ,(or whostate "CLX Lock"))) ((sys:process-wait-with-timeout ,(or whostate "CLX Lock") (round (* ,timeo 60.)) #'(lambda (lock process) (#+explorer si:%store-conditional #-explorer sys:store-conditional lock nil process)) ,lock sys:current-process))) ,@body) (unless ,have-lock (#+explorer si:%store-conditional #-explorer sys:store-conditional ,lock sys:current-process nil)))))) ;; Lucid has a process locking mechanism as well under release 3.0 #+lcl3.0 (defmacro holding-lock ((locator display &optional whostate &key timeout) &body body) (declare (ignore display)) (if timeout ;; Hair to support timeout. `(let ((.have-lock. (eq ,locator lcl:*current-process*)) (.timeout. ,timeout)) (unwind-protect (when (cond (.have-lock.) ((conditional-store ,locator nil lcl:*current-process*)) ((null .timeout.) (lcl:process-lock ,locator) t) ((lcl:process-wait-with-timeout ,whostate .timeout. #'(lambda () (conditional-store ,locator nil lcl:*current-process*)))) ;; abort the PROCESS-UNLOCK if actually timing out (t (setf .have-lock. :abort) nil)) ,@body) (unless .have-lock. (lcl:process-unlock ,locator)))) `(lcl:with-process-lock (,locator) ,@body))) #+excl (defmacro holding-lock ((locator display &optional whostate &key timeout) &body body) (declare (ignore display)) `(let (.hl-lock. .hl-obtained-lock. .hl-curproc.) (unwind-protect (block .hl-doit. (when mp::*scheduler-stack-group* ; fast test for scheduler running (setq .hl-lock. ,locator .hl-curproc. mp::*current-process*) (when (and .hl-curproc. ; nil if in process-wait fun (not (eq (mp::process-lock-locker .hl-lock.) .hl-curproc.))) ;; Then we need to grab the lock. ,(if timeout `(if (not (mp::process-lock .hl-lock. .hl-curproc. ,whostate ,timeout)) (return-from .hl-doit. nil)) `(mp::process-lock .hl-lock. .hl-curproc. ,@(when whostate `(,whostate)))) ;; There is an apparent race condition here. However, there is ;; no actual race condition -- our implementation of mp:process- ;; lock guarantees that the lock will still be held when it ;; returns, and no interrupt can happen between that and the ;; execution of the next form. -- jdi 2/27/91 (setq .hl-obtained-lock. t))) ,@body) (if (and .hl-obtained-lock. ;; Note -- next form added to allow error handler inside ;; body to unlock the lock prematurely if it knows that ;; the current process cannot possibly continue but will ;; throw out (or is it throw up?). (eq (mp::process-lock-locker .hl-lock.) .hl-curproc.)) (mp::process-unlock .hl-lock. .hl-curproc.))))) #+Minima (defmacro holding-lock ((locator display &optional whostate &key timeout) &body body) `(holding-lock-1 #'(lambda () ,@body) ,locator ,display ,@(and whostate `(:whostate ,whostate)) ,@(and timeout `(:timeout ,timeout)))) #+Minima (defun holding-lock-1 (continuation lock display &key (whostate "Lock") timeout) (declare (dynamic-extent continuation)) (declare (ignore display whostate timeout)) (minima:with-lock (lock) (funcall continuation))) ;;; WITHOUT-ABORTS ;;; If you can inhibit asynchronous keyboard aborts inside the body of this ;;; macro, then it is a good idea to do this. This macro is wrapped around ;;; request writing and reply reading to ensure that requests are atomically ;;; written and replies are atomically read from the stream. #-(or Genera excl lcl3.0) (defmacro without-aborts (&body body) `(progn ,@body)) #+Genera (defmacro without-aborts (&body body) `(sys:without-aborts (clx "CLX is in the middle of an operation that should be atomic.") ,@body)) #+excl (defmacro without-aborts (&body body) `(without-interrupts ,@body)) #+lcl3.0 (defmacro without-aborts (&body body) `(lcl:with-interruptions-inhibited ,@body)) ;;; PROCESS-BLOCK: Wait until a given predicate returns a non-NIL value. ;;; Caller guarantees that PROCESS-WAKEUP will be called after the predicate's ;;; value changes. #-(or lispm excl lcl3.0 Minima (and sb-thread sbcl) (and cmu mp) (and ecl threads)) (defun process-block (whostate predicate &rest predicate-args) (declare (ignore whostate)) (or (apply predicate predicate-args) (error "Program tried to wait with no scheduler."))) #+Genera (defun process-block (whostate predicate &rest predicate-args) (declare (type function predicate) #+clx-ansi-common-lisp (dynamic-extent predicate) #-clx-ansi-common-lisp (sys:downward-funarg predicate)) (apply #'process:block-process whostate predicate predicate-args)) #+(and lispm (not Genera)) (defun process-block (whostate predicate &rest predicate-args) (declare (type function predicate) #+clx-ansi-common-lisp (dynamic-extent predicate) #-clx-ansi-common-lisp (sys:downward-funarg predicate)) (apply #'global:process-wait whostate predicate predicate-args)) #+excl (defun process-block (whostate predicate &rest predicate-args) (if mp::*scheduler-stack-group* (apply #'mp::process-wait whostate predicate predicate-args) (or (apply predicate predicate-args) (error "Program tried to wait with no scheduler.")))) #+lcl3.0 (defun process-block (whostate predicate &rest predicate-args) (declare (dynamic-extent predicate-args)) (apply #'lcl:process-wait whostate predicate predicate-args)) #+Minima (defun process-block (whostate predicate &rest predicate-args) (declare (type function predicate) (dynamic-extent predicate)) (apply #'minima:process-wait whostate predicate predicate-args)) #+(and cmu mp) (defun process-block (whostate predicate &rest predicate-args) (declare (type function predicate)) (mp:process-wait whostate #'(lambda () (apply predicate predicate-args)))) #+(and sbcl sb-thread) (progn (declaim (inline yield)) (defun yield () (declare (optimize speed (safety 0))) (sb-alien:alien-funcall (sb-alien:extern-alien "sched_yield" (function sb-alien:int))) (values))) #+(and sbcl sb-thread) (defun process-block (whostate predicate &rest predicate-args) (declare (ignore whostate)) (declare (type function predicate)) (loop (when (apply predicate predicate-args) (return)) (yield))) #+(and ecl threads) (defun process-block (whostate predicate &rest predicate-args) (declare (ignore whostate)) (declare (type function predicate)) (loop (when (apply predicate predicate-args) (return)) (mp:process-yield))) ;;; FIXME: the below implementation for threaded PROCESS-BLOCK using ;;; queues and condition variables might seem better, but in fact it ;;; turns out to make performance extremely suboptimal, at least as ;;; measured by McCLIM on linux 2.4 kernels. -- CSR, 2003-11-10 #+(or) (defvar *process-conditions* (make-hash-table)) #+(or) (defun process-block (whostate predicate &rest predicate-args) (declare (ignore whostate)) (declare (type function predicate)) (let* ((pid (sb-thread:current-thread-id)) (last (gethash pid *process-conditions*)) (lock (or (car last) (sb-thread:make-mutex :name (format nil "lock ~A" pid)))) (queue (or (cdr last) (sb-thread:make-waitqueue :name (format nil "queue ~A" pid))))) (unless last (setf (gethash pid *process-conditions*) (cons lock queue))) (sb-thread:with-mutex (lock) (loop (when (apply predicate predicate-args) (return)) (handler-case (sb-ext:with-timeout .5 (sb-thread:condition-wait queue lock)) (sb-ext:timeout () (format *trace-output* "thread ~A, process-block timed out~%" (sb-thread:current-thread-id) ))))))) ;;; PROCESS-WAKEUP: Check some other process' wait function. (declaim (inline process-wakeup)) #-(or excl Genera Minima (and sbcl sb-thread) (and cmu mp) (and ecl threads)) (defun process-wakeup (process) (declare (ignore process)) nil) #+excl (defun process-wakeup (process) (let ((curproc mp::*current-process*)) (when (and curproc process) (unless (mp::process-p curproc) (error "~s is not a process" curproc)) (unless (mp::process-p process) (error "~s is not a process" process)) (if (> (mp::process-priority process) (mp::process-priority curproc)) (mp::process-allow-schedule process))))) #+Genera (defun process-wakeup (process) (process:wakeup process)) #+Minima (defun process-wakeup (process) (when process (minima:process-wakeup process))) #+(and cmu mp) (defun process-wakeup (process) (declare (ignore process)) (mp:process-yield)) #+(and sb-thread sbcl) (defun process-wakeup (process) (declare (ignore process)) (yield)) #+(and ecl threads) (defun process-wakeup (process) (declare (ignore process)) (mp:process-yield)) #+(or) (defun process-wakeup (process) (declare (ignore process)) (destructuring-bind (lock . queue) (gethash (sb-thread:current-thread-id) *process-conditions* (cons nil nil)) (declare (ignore lock)) (when queue (sb-thread:condition-notify queue)))) ;;; CURRENT-PROCESS: Return the current process object for input locking and ;;; for calling PROCESS-WAKEUP. (declaim (inline current-process)) ;;; Default return NIL, which is acceptable even if there is a scheduler. #-(or lispm excl lcl3.0 sbcl Minima (and cmu mp) (and ecl threads)) (defun current-process () nil) #+lispm (defun current-process () sys:current-process) #+excl (defun current-process () (and mp::*scheduler-stack-group* mp::*current-process*)) #+lcl3.0 (defun current-process () lcl:*current-process*) #+Minima (defun current-process () (minima:current-process)) #+(or (and cmu mp) (and ecl threads)) (defun current-process () mp:*current-process*) #+sbcl (defun current-process () sb-thread:*current-thread*) ;;; WITHOUT-INTERRUPTS -- provide for atomic operations. #-(or lispm excl lcl3.0 Minima cmu) (defmacro without-interrupts (&body body) `(progn ,@body)) #+(and lispm (not Genera)) (defmacro without-interrupts (&body body) `(sys:without-interrupts ,@body)) #+Genera (defmacro without-interrupts (&body body) `(process:with-no-other-processes ,@body)) #+LCL3.0 (defmacro without-interrupts (&body body) `(lcl:with-scheduling-inhibited ,@body)) #+Minima (defmacro without-interrupts (&body body) `(minima:with-no-other-processes ,@body)) #+cmu (defmacro without-interrupts (&body body) `(system:without-interrupts ,@body)) #+ecl (defmacro without-interrupts (&body body) `(mp:without-interrupts ,@body)) #+sbcl (defvar *without-interrupts-sic-lock* (sb-thread:make-mutex :name "lock simulating *without-interrupts*")) #+sbcl (defmacro without-interrupts (&body body) `(sb-thread:with-recursive-lock (*without-interrupts-sic-lock*) ,@body)) ;;; CONDITIONAL-STORE: ;; This should use GET-SETF-METHOD to avoid evaluating subforms multiple times. ;; It doesn't because CLtL doesn't pass the environment to GET-SETF-METHOD. #-sbcl (defmacro conditional-store (place old-value new-value) `(without-interrupts (cond ((eq ,place ,old-value) (setf ,place ,new-value) t)))) #+sbcl (progn (defvar *conditional-store-lock* (sb-thread:make-mutex :name "conditional store")) (defmacro conditional-store (place old-value new-value) `(sb-thread:with-mutex (*conditional-store-lock*) (cond ((eq ,place ,old-value) (setf ,place ,new-value) t))))) ;;;---------------------------------------------------------------------------- ;;; IO Error Recovery ;;; All I/O operations are done within a WRAP-BUF-OUTPUT macro. ;;; It prevents multiple mindless errors when the network craters. ;;; ;;;---------------------------------------------------------------------------- #-Genera (defmacro wrap-buf-output ((buffer) &body body) ;; Error recovery wrapper `(unless (buffer-dead ,buffer) ,@body)) #+Genera (defmacro wrap-buf-output ((buffer) &body body) ;; Error recovery wrapper `(let ((.buffer. ,buffer)) (unless (buffer-dead .buffer.) (scl:condition-bind (((sys:network-error) #'(lambda (error) (scl:condition-case () (funcall (buffer-close-function .buffer.) .buffer. :abort t) (sys:network-error)) (setf (buffer-dead .buffer.) error) (setf (buffer-output-stream .buffer.) nil) (setf (buffer-input-stream .buffer.) nil) nil))) ,@body)))) #-Genera (defmacro wrap-buf-input ((buffer) &body body) (declare (ignore buffer)) ;; Error recovery wrapper `(progn ,@body)) #+Genera (defmacro wrap-buf-input ((buffer) &body body) ;; Error recovery wrapper `(let ((.buffer. ,buffer)) (scl:condition-bind (((sys:network-error) #'(lambda (error) (scl:condition-case () (funcall (buffer-close-function .buffer.) .buffer. :abort t) (sys:network-error)) (setf (buffer-dead .buffer.) error) (setf (buffer-output-stream .buffer.) nil) (setf (buffer-input-stream .buffer.) nil) nil))) ,@body))) ;;;---------------------------------------------------------------------------- ;;; System dependent IO primitives ;;; Functions for opening, reading writing forcing-output and closing ;;; the stream to the server. ;;;---------------------------------------------------------------------------- ;;; OPEN-X-STREAM - create a stream for communicating to the appropriate X ;;; server #-(or explorer Genera lucid kcl ibcl excl Minima CMU sbcl ecl clisp) (defun open-x-stream (host display protocol) host display protocol ;; unused (error "OPEN-X-STREAM not implemented yet.")) #+clisp (defun open-x-stream (host display protocol) (declare (ignore protocol) (type (integer 0) display)) (let ((socket ;; are we dealing with a localhost? (when (or (string= host "") (string= host "unix")) ;; ok, try to connect to a AF_UNIX domain socket (sys::make-socket-stream "" display)))) (if socket socket ;; try to connect by hand (let ((host (host-address host))) (when host ;; Fixme: get a descent ip standard in CLX: a vector! (let ((ip (format nil "~{~D~^.~}" (rest host)))) (socket:socket-connect (+ 6000 display) ip :element-type '(unsigned-byte 8)))))))) ;;; Genera: ;;; TCP and DNA are both layered products, so try to work with either one. #+Genera (when (fboundp 'tcp:add-tcp-port-for-protocol) (tcp:add-tcp-port-for-protocol :x-window-system 6000)) #+Genera (when (fboundp 'dna:add-dna-contact-id-for-protocol) (dna:add-dna-contact-id-for-protocol :x-window-system "X$X0")) #+Genera (net:define-protocol :x-window-system (:x-window-system :byte-stream) (:invoke-with-stream ((stream :characters nil :ascii-translation nil)) stream)) #+Genera (eval-when (compile) (compiler:function-defined 'tcp:open-tcp-stream) (compiler:function-defined 'dna:open-dna-bidirectional-stream)) #+Genera (defun open-x-stream (host display protocol) (let ((host (net:parse-host host))) (if (or protocol (plusp display)) ;; The protocol was specified or the display isn't 0, so we ;; can't use the Generic Network System. If the protocol was ;; specified, then use that protocol, otherwise, blindly use ;; TCP. (ccase protocol ((:tcp nil) (tcp:open-tcp-stream host (+ *x-tcp-port* display) nil :direction :io :characters nil :ascii-translation nil)) ((:dna) (dna:open-dna-bidirectional-stream host (format nil "X$X~D" display) :characters nil :ascii-translation nil))) (let ((neti:*invoke-service-automatic-retry* t)) (net:invoke-service-on-host :x-window-system host))))) #+explorer (defun open-x-stream (host display protocol) (declare (ignore protocol)) (net:open-connection-on-medium (net:parse-host host) ;Host :byte-stream ;Medium "X11" ;Logical contact name :stream-type :character-stream :direction :bidirectional :timeout-after-open nil :remote-port (+ *x-tcp-port* display))) #+explorer (net:define-logical-contact-name "X11" `((:local "X11") (:chaos "X11") (:nsp-stream "X11") (:tcp ,*x-tcp-port*))) #+lucid (defun open-x-stream (host display protocol) protocol ;; unused (let ((fd (connect-to-server host display))) (when (minusp fd) (error "Failed to connect to server: ~A ~D" host display)) (user::make-lisp-stream :input-handle fd :output-handle fd :element-type 'unsigned-byte #-lcl3.0 :stream-type #-lcl3.0 :ephemeral))) #+(or kcl ibcl) (defun open-x-stream (host display protocol) protocol ;; unused (let ((stream (open-socket-stream host display))) (if (streamp stream) stream (error "Cannot connect to server: ~A:~D" host display)))) #+excl ;; ;; Note that since we don't use the CL i/o facilities to do i/o, the display ;; input and output "stream" is really a file descriptor (fixnum). ;; (defun open-x-stream (host display protocol) (declare (ignore protocol));; unused (let ((fd (connect-to-server (string host) display))) (when (minusp fd) (error "Failed to connect to server: ~A ~D" host display)) fd)) #+Minima (defun open-x-stream (host display protocol) (declare (ignore protocol));; unused (minima:open-tcp-stream :foreign-address (apply #'minima:make-ip-address (cdr (host-address host))) :foreign-port (+ *x-tcp-port* display))) #+(or sbcl ecl) (defun open-x-stream (host display protocol) (declare (ignore protocol) (type (integer 0) display)) (let ((local-socket-path (unix-socket-path-from-host host display))) (socket-make-stream (if local-socket-path (let ((s (make-instance 'local-socket :type :stream))) (socket-connect s local-socket-path) s) (let ((host (car (host-ent-addresses (get-host-by-name host))))) (when host (let ((s (make-instance 'inet-socket :type :stream :protocol :tcp))) (socket-connect s host (+ 6000 display)) s)))) :element-type '(unsigned-byte 8) :input t :output t :buffering :none))) ;;; BUFFER-READ-DEFAULT - read data from the X stream #+(or Genera explorer) (defun buffer-read-default (display vector start end timeout) ;; returns non-NIL if EOF encountered ;; Returns :TIMEOUT when timeout exceeded (declare (type display display) (type buffer-bytes vector) (type array-index start end) (type (or null (real 0 *)) timeout)) #.(declare-buffun) (let ((stream (display-input-stream display))) (or (cond ((null stream)) ((funcall stream :listen) nil) ((and timeout (= timeout 0)) :timeout) ((buffer-input-wait-default display timeout))) (multiple-value-bind (ignore eofp) (funcall stream :string-in nil vector start end) eofp)))) #+excl ;; ;; Rewritten 10/89 to not use foreign function interface to do I/O. ;; (defun buffer-read-default (display vector start end timeout) (declare (type display display) (type buffer-bytes vector) (type array-index start end) (type (or null (real 0 *)) timeout)) #.(declare-buffun) (let* ((howmany (- end start)) (fd (display-input-stream display))) (declare (type array-index howmany) (fixnum fd)) (or (cond ((fd-char-avail-p fd) nil) ((and timeout (= timeout 0)) :timeout) ((buffer-input-wait-default display timeout))) (fd-read-bytes fd vector start howmany)))) #+lcl3.0 (defmacro with-underlying-stream ((variable stream display direction) &body body) `(let ((,variable (or (getf (display-plist ,display) ',direction) (setf (getf (display-plist ,display) ',direction) (lucid::underlying-stream ,stream ,(if (eq direction 'input) :input :output)))))) ,@body)) #+lcl3.0 (defun buffer-read-default (display vector start end timeout) ;;Note that LISTEN must still be done on "slow stream" or the I/O system ;;gets confused. But reading should be done from "fast stream" for speed. ;;We used to inhibit scheduling because there were races in Lucid's ;;multitasking system. Empirical evidence suggests they may be gone now. ;;Should you decide you need to inhibit scheduling, do it around the ;;lcl:read-array. (declare (type display display) (type buffer-bytes vector) (type array-index start end) (type (or null (real 0 *)) timeout)) #.(declare-buffun) (let ((stream (display-input-stream display))) (declare (type (or null stream) stream)) (or (cond ((null stream)) ((listen stream) nil) ((and timeout (= timeout 0)) :timeout) ((buffer-input-wait-default display timeout))) (with-underlying-stream (stream stream display input) (eq (lcl:read-array stream vector start end nil :eof) :eof))))) #+Minima (defun buffer-read-default (display vector start end timeout) ;; returns non-NIL if EOF encountered ;; Returns :TIMEOUT when timeout exceeded (declare (type display display) (type buffer-bytes vector) (type array-index start end) (type (or null (real 0 *)) timeout)) #.(declare-buffun) (let ((stream (display-input-stream display))) (or (cond ((null stream)) ((listen stream) nil) ((and timeout (= timeout 0)) :timeout) ((buffer-input-wait-default display timeout))) (eq :eof (minima:read-vector vector stream nil start end))))) ;;; BUFFER-READ-DEFAULT for CMU Common Lisp. ;;; ;;; If timeout is 0, then we call LISTEN to see if there is any input. ;;; Timeout 0 is the only case where READ-INPUT dives into BUFFER-READ without ;;; first calling BUFFER-INPUT-WAIT-DEFAULT. ;;; #+(or CMU sbcl) (defun buffer-read-default (display vector start end timeout) (declare (type display display) (type buffer-bytes vector) (type array-index start end) (type (or null fixnum) timeout)) #.(declare-buffun) (cond ((and (eql timeout 0) (not (listen (display-input-stream display)))) :timeout) (t (#+cmu system:read-n-bytes #+sbcl sb-sys:read-n-bytes (display-input-stream display) vector start (- end start)) nil))) #+(or ecl clisp) (defun buffer-read-default (display vector start end timeout) (declare (type display display) (type buffer-bytes vector) (type array-index start end) (type (or null fixnum) timeout)) #.(declare-buffun) (cond ((and (eql timeout 0) (not (listen (display-input-stream display)))) :timeout) (t (read-sequence vector (display-input-stream display) :start start :end end) nil))) ;;; WARNING: ;;; CLX performance will suffer if your lisp uses read-byte for ;;; receiving all data from the X Window System server. ;;; You are encouraged to write a specialized version of ;;; buffer-read-default that does block transfers. #-(or Genera explorer excl lcl3.0 Minima CMU sbcl ecl clisp) (defun buffer-read-default (display vector start end timeout) (declare (type display display) (type buffer-bytes vector) (type array-index start end) (type (or null (real 0 *)) timeout)) #.(declare-buffun) (let ((stream (display-input-stream display))) (declare (type (or null stream) stream)) (or (cond ((null stream)) ((listen stream) nil) ((and timeout (= timeout 0)) :timeout) ((buffer-input-wait-default display timeout))) (do* ((index start (index1+ index))) ((index>= index end) nil) (declare (type array-index index)) (let ((c (read-byte stream nil nil))) (declare (type (or null card8) c)) (if (null c) (return t) (setf (aref vector index) (the card8 c)))))))) ;;; BUFFER-WRITE-DEFAULT - write data to the X stream #+(or Genera explorer) (defun buffer-write-default (vector display start end) ;; The default buffer write function for use with common-lisp streams (declare (type buffer-bytes vector) (type display display) (type array-index start end)) #.(declare-buffun) (let ((stream (display-output-stream display))) (declare (type (or null stream) stream)) (unless (null stream) (write-string vector stream :start start :end end)))) #+excl (defun buffer-write-default (vector display start end) (declare (type buffer-bytes vector) (type display display) (type array-index start end)) #.(declare-buffun) (excl::filesys-write-bytes (display-output-stream display) vector start (- end start))) #+lcl3.0 (defun buffer-write-default (vector display start end) ;;We used to inhibit scheduling because there were races in Lucid's ;;multitasking system. Empirical evidence suggests they may be gone now. ;;Should you decide you need to inhibit scheduling, do it around the ;;lcl:write-array. (declare (type display display) (type buffer-bytes vector) (type array-index start end)) #.(declare-buffun) (let ((stream (display-output-stream display))) (declare (type (or null stream) stream)) (unless (null stream) (with-underlying-stream (stream stream display output) (lcl:write-array stream vector start end))))) #+Minima (defun buffer-write-default (vector display start end) ;; The default buffer write function for use with common-lisp streams (declare (type buffer-bytes vector) (type display display) (type array-index start end)) #.(declare-buffun) (let ((stream (display-output-stream display))) (declare (type (or null stream) stream)) (unless (null stream) (minima:write-vector vector stream start end)))) #+CMU (defun buffer-write-default (vector display start end) (declare (type buffer-bytes vector) (type display display) (type array-index start end)) #.(declare-buffun) (system:output-raw-bytes (display-output-stream display) vector start end) nil) #+(or sbcl ecl clisp) (defun buffer-write-default (vector display start end) (declare (type buffer-bytes vector) (type display display) (type array-index start end)) #.(declare-buffun) (write-sequence vector (display-output-stream display) :start start :end end) nil) ;;; WARNING: ;;; CLX performance will be severely degraded if your lisp uses ;;; write-byte to send all data to the X Window System server. ;;; You are STRONGLY encouraged to write a specialized version ;;; of buffer-write-default that does block transfers. #-(or Genera explorer excl lcl3.0 Minima CMU sbcl clisp ecl) (defun buffer-write-default (vector display start end) ;; The default buffer write function for use with common-lisp streams (declare (type buffer-bytes vector) (type display display) (type array-index start end)) #.(declare-buffun) (let ((stream (display-output-stream display))) (declare (type (or null stream) stream)) (unless (null stream) (with-vector (vector buffer-bytes) (do ((index start (index1+ index))) ((index>= index end)) (declare (type array-index index)) (write-byte (aref vector index) stream)))))) ;;; buffer-force-output-default - force output to the X stream #+excl (defun buffer-force-output-default (display) ;; buffer-write-default does the actual writing. (declare (ignore display))) #-(or excl) (defun buffer-force-output-default (display) ;; The default buffer force-output function for use with common-lisp streams (declare (type display display)) (let ((stream (display-output-stream display))) (declare (type (or null stream) stream)) (unless (null stream) (force-output stream)))) ;;; BUFFER-CLOSE-DEFAULT - close the X stream #+excl (defun buffer-close-default (display &key abort) ;; The default buffer close function for use with common-lisp streams (declare (type display display) (ignore abort)) #.(declare-buffun) (excl::filesys-checking-close (display-output-stream display))) #-(or excl) (defun buffer-close-default (display &key abort) ;; The default buffer close function for use with common-lisp streams (declare (type display display)) #.(declare-buffun) (let ((stream (display-output-stream display))) (declare (type (or null stream) stream)) (unless (null stream) (close stream :abort abort)))) ;;; BUFFER-INPUT-WAIT-DEFAULT - wait for for input to be available for the ;;; buffer. This is called in read-input between requests, so that a process ;;; waiting for input is abortable when between requests. Should return ;;; :TIMEOUT if it times out, NIL otherwise. ;;; The default implementation ;; Poll for input every *buffer-read-polling-time* SECONDS. #-(or Genera explorer excl lcl3.0 CMU sbcl) (defparameter *buffer-read-polling-time* 0.5) #-(or Genera explorer excl lcl3.0 CMU sbcl clisp) (defun buffer-input-wait-default (display timeout) (declare (type display display) (type (or null (real 0 *)) timeout)) (declare (clx-values timeout)) (let ((stream (display-input-stream display))) (declare (type (or null stream) stream)) (cond ((null stream)) ((listen stream) nil) ((and timeout (= timeout 0)) :timeout) ((not (null timeout)) (multiple-value-bind (npoll fraction) (truncate timeout *buffer-read-polling-time*) (dotimes (i npoll) ; Sleep for a time, then listen again (sleep *buffer-read-polling-time*) (when (listen stream) (return-from buffer-input-wait-default nil))) (when (plusp fraction) (sleep fraction) ; Sleep a fraction of a second (when (listen stream) ; and listen one last time (return-from buffer-input-wait-default nil))) :timeout))))) #+(or CMU sbcl clisp) (defun buffer-input-wait-default (display timeout) (declare (type display display) (type (or null number) timeout)) (let ((stream (display-input-stream display))) (declare (type (or null stream) stream)) (cond ((null stream)) ((listen stream) nil) ((eql timeout 0) :timeout) (t (if #+sbcl (sb-sys:wait-until-fd-usable (sb-sys:fd-stream-fd stream) :input timeout) #+mp (mp:process-wait-until-fd-usable (system:fd-stream-fd stream) :input timeout) #+clisp (multiple-value-bind (sec usec) (floor (or timeout 0)) (ext:socket-status stream (and timeout sec) (round usec 1d-6))) #-(or sbcl mp clisp) (system:wait-until-fd-usable (system:fd-stream-fd stream) :input timeout) nil :timeout))))) #+Genera (defun buffer-input-wait-default (display timeout) (declare (type display display) (type (or null (real 0 *)) timeout)) (declare (clx-values timeout)) (let ((stream (display-input-stream display))) (declare (type (or null stream) stream)) (cond ((null stream)) ((scl:send stream :listen) nil) ((and timeout (= timeout 0)) :timeout) ((null timeout) (si:stream-input-block stream "CLX Input")) (t (scl:condition-bind ((neti:protocol-timeout #'(lambda (error) (when (eq stream (scl:send error :stream)) (return-from buffer-input-wait-default :timeout))))) (neti:with-stream-timeout (stream :input timeout) (si:stream-input-block stream "CLX Input"))))) nil)) #+explorer (defun buffer-input-wait-default (display timeout) (declare (type display display) (type (or null (real 0 *)) timeout)) (declare (clx-values timeout)) (let ((stream (display-input-stream display))) (declare (type (or null stream) stream)) (cond ((null stream)) ((zl:send stream :listen) nil) ((and timeout (= timeout 0)) :timeout) ((null timeout) (si:process-wait "CLX Input" stream :listen)) (t (unless (si:process-wait-with-timeout "CLX Input" (round (* timeout 60.)) stream :listen) (return-from buffer-input-wait-default :timeout)))) nil)) #+excl ;; ;; This is used so an 'eq' test may be used to find out whether or not we can ;; safely throw this process out of the CLX read loop. ;; (defparameter *read-whostate* "waiting for input from X server") ;; ;; Note that this function returns nil on error if the scheduler is running, ;; t on error if not. This is ok since buffer-read will detect the error. ;; #+excl (defun buffer-input-wait-default (display timeout) (declare (type display display) (type (or null (real 0 *)) timeout)) (declare (clx-values timeout)) (let ((fd (display-input-stream display))) (declare (fixnum fd)) (when (>= fd 0) (cond ((fd-char-avail-p fd) nil) ;; Otherwise no bytes were available on the socket ((and timeout (= timeout 0)) ;; If there aren't enough and timeout == 0, timeout. :timeout) ;; If the scheduler is running let it do timeouts. (mp::*scheduler-stack-group* #+allegro (if (not (mp:wait-for-input-available fd :whostate *read-whostate* :wait-function #'fd-char-avail-p :timeout timeout)) (return-from buffer-input-wait-default :timeout)) #-allegro (mp::wait-for-input-available fd :whostate *read-whostate* :wait-function #'fd-char-avail-p)) ;; Otherwise we have to handle timeouts by hand, and call select() ;; to block until input is available. Note we don't really handle ;; the interaction of interrupts and (numberp timeout) here. XX (t (let ((res 0)) (declare (fixnum res)) (with-interrupt-checking-on (loop (setq res (fd-wait-for-input fd (if (null timeout) 0 (truncate timeout)))) (cond ((plusp res) ; success (return nil)) ((eq res 0) ; timeout (return :timeout)) ((eq res -1) ; error (return t)) ;; Otherwise we got an interrupt -- go around again. ))))))))) #+lcl3.0 (defun buffer-input-wait-default (display timeout) (declare (type display display) (type (or null (real 0 *)) timeout) (clx-values timeout)) #.(declare-buffun) (let ((stream (display-input-stream display))) (declare (type (or null stream) stream)) (cond ((null stream)) ((listen stream) nil) ((and timeout (= timeout 0)) :timeout) ((with-underlying-stream (stream stream display input) (lucid::waiting-for-input-from-stream stream (lucid::with-io-unlocked (if (null timeout) (lcl:process-wait "CLX Input" #'listen stream) (lcl:process-wait-with-timeout "CLX Input" timeout #'listen stream))))) nil) (:timeout)))) ;;; BUFFER-LISTEN-DEFAULT - returns T if there is input available for the ;;; buffer. This should never block, so it can be called from the scheduler. ;;; The default implementation is to just use listen. #-(or excl) (defun buffer-listen-default (display) (declare (type display display)) (let ((stream (display-input-stream display))) (declare (type (or null stream) stream)) (if (null stream) t (listen stream)))) #+excl (defun buffer-listen-default (display) (declare (type display display)) (let ((fd (display-input-stream display))) (declare (type fixnum fd)) (if (= fd -1) t (fd-char-avail-p fd)))) ;;;---------------------------------------------------------------------------- ;;; System dependent speed hacks ;;;---------------------------------------------------------------------------- ;; ;; WITH-STACK-LIST is used by WITH-STATE as a memory saving feature. ;; If your lisp doesn't have stack-lists, and you're worried about ;; consing garbage, you may want to re-write this to allocate and ;; initialize lists from a resource. ;; #-lispm (defmacro with-stack-list ((var &rest elements) &body body) ;; SYNTAX: (WITH-STACK-LIST (var exp1 ... expN) body) ;; Equivalent to (LET ((var (MAPCAR #'EVAL '(exp1 ... expN)))) body) ;; except that the list produced by MAPCAR resides on the stack and ;; therefore DISAPPEARS when WITH-STACK-LIST is exited. `(let ((,var (list ,@elements))) (declare (type cons ,var) #+clx-ansi-common-lisp (dynamic-extent ,var)) ,@body)) #-lispm (defmacro with-stack-list* ((var &rest elements) &body body) ;; SYNTAX: (WITH-STACK-LIST* (var exp1 ... expN) body) ;; Equivalent to (LET ((var (APPLY #'LIST* (MAPCAR #'EVAL '(exp1 ... expN))))) body) ;; except that the list produced by MAPCAR resides on the stack and ;; therefore DISAPPEARS when WITH-STACK-LIST is exited. `(let ((,var (list* ,@elements))) (declare (type cons ,var) #+clx-ansi-common-lisp (dynamic-extent ,var)) ,@body)) (declaim (inline buffer-replace)) #+lispm (defun buffer-replace (buf1 buf2 start1 end1 &optional (start2 0)) (declare (type vector buf1 buf2) (type array-index start1 end1 start2)) (sys:copy-array-portion buf2 start2 (length buf2) buf1 start1 end1)) #+excl (defun buffer-replace (target-sequence source-sequence target-start target-end &optional (source-start 0)) (declare (type buffer-bytes target-sequence source-sequence) (type array-index target-start target-end source-start) (optimize (speed 3) (safety 0))) (let ((source-end (length source-sequence))) (declare (type array-index source-end)) (excl:if* (and (eq target-sequence source-sequence) (> target-start source-start)) then (let ((nelts (min (- target-end target-start) (- source-end source-start)))) (do ((target-index (+ target-start nelts -1) (1- target-index)) (source-index (+ source-start nelts -1) (1- source-index))) ((= target-index (1- target-start)) target-sequence) (declare (type array-index target-index source-index)) (setf (aref target-sequence target-index) (aref source-sequence source-index)))) else (do ((target-index target-start (1+ target-index)) (source-index source-start (1+ source-index))) ((or (= target-index target-end) (= source-index source-end)) target-sequence) (declare (type array-index target-index source-index)) (setf (aref target-sequence target-index) (aref source-sequence source-index)))))) #+cmu (defun buffer-replace (buf1 buf2 start1 end1 &optional (start2 0)) (declare (type buffer-bytes buf1 buf2) (type array-index start1 end1 start2)) #.(declare-buffun) (kernel:bit-bash-copy buf2 (+ (* start2 #+cmu vm:byte-bits #+sbcl sb-vm:n-byte-bits) (* vm:vector-data-offset #+cmu vm:word-bits #+sbcl sb-vm:n-word-bits)) buf1 (+ (* start1 #+cmu vm:byte-bits #+sbcl sb-vm:n-byte-bits) (* vm:vector-data-offset #+cmu vm:word-bits #+sbcl sb-vm:n-word-bits)) (* (- end1 start1) #+cmu vm:byte-bits #+sbcl sb-vm:n-byte-bits))) #+lucid ;;;The compiler is *supposed* to optimize calls to replace, but in actual ;;;fact it does not. (defun buffer-replace (buf1 buf2 start1 end1 &optional (start2 0)) (declare (type buffer-bytes buf1 buf2) (type array-index start1 end1 start2)) #.(declare-buffun) (let ((end2 (lucid::%simple-8bit-vector-length buf2))) (declare (type array-index end2)) (lucid::simple-8bit-vector-replace-internal buf1 buf2 start1 end1 start2 end2))) #+(and clx-overlapping-arrays (not (or lispm excl))) (defun buffer-replace (buf1 buf2 start1 end1 &optional (start2 0)) (declare (type vector buf1 buf2) (type array-index start1 end1 start2)) (replace buf1 buf2 :start1 start1 :end1 end1 :start2 start2)) #-(or lispm lucid excl CMU clx-overlapping-arrays) (defun buffer-replace (buf1 buf2 start1 end1 &optional (start2 0)) (declare (type buffer-bytes buf1 buf2) (type array-index start1 end1 start2)) (replace buf1 buf2 :start1 start1 :end1 end1 :start2 start2)) #+ti (defun with-location-bindings (sys:"e bindings &rest body) (do ((bindings bindings (cdr bindings))) ((null bindings) (sys:eval-body-as-progn body)) (sys:bind (sys:*eval `(sys:locf ,(caar bindings))) (sys:*eval (cadar bindings))))) #+ti (compiler:defoptimizer with-location-bindings with-l-b-compiler nil (form) (let ((bindings (cadr form)) (body (cddr form))) `(let () ,@(loop for (accessor value) in bindings collect `(si:bind (si:locf ,accessor) ,value)) ,@body))) #+ti (defun (:property with-location-bindings compiler::cw-handler) (exp) (let* ((bindlist (mapcar #'compiler::cw-clause (second exp))) (body (compiler::cw-clause (cddr exp)))) (and compiler::cw-return-expansion-flag (list* (first exp) bindlist body)))) #+(and lispm (not ti)) (defmacro with-location-bindings (bindings &body body) `(sys:letf* ,bindings ,@body)) #+lispm (defmacro with-gcontext-bindings ((gc saved-state indexes ts-index temp-mask temp-gc) &body body) ;; don't use svref on LHS because Symbolics didn't define locf for it (let* ((local-state (gensym)) (bindings `(((aref ,local-state ,ts-index) 0)))) ; will become zero anyway (dolist (index indexes) (push `((aref ,local-state ,index) (svref ,saved-state ,index)) bindings)) `(let ((,local-state (gcontext-local-state ,gc))) (declare (type gcontext-state ,local-state)) (unwind-protect (with-location-bindings ,bindings ,@body) (setf (svref ,local-state ,ts-index) 0) (when ,temp-gc (restore-gcontext-temp-state ,gc ,temp-mask ,temp-gc)) (deallocate-gcontext-state ,saved-state))))) #-lispm (defmacro with-gcontext-bindings ((gc saved-state indexes ts-index temp-mask temp-gc) &body body) (let ((local-state (gensym)) (resets nil)) (dolist (index indexes) (push `(setf (svref ,local-state ,index) (svref ,saved-state ,index)) resets)) `(unwind-protect (progn ,@body) (let ((,local-state (gcontext-local-state ,gc))) (declare (type gcontext-state ,local-state)) ,@resets (setf (svref ,local-state ,ts-index) 0)) (when ,temp-gc (restore-gcontext-temp-state ,gc ,temp-mask ,temp-gc)) (deallocate-gcontext-state ,saved-state)))) ;;;---------------------------------------------------------------------------- ;;; How much error detection should CLX do? ;;; Several levels are possible: ;;; ;;; 1. Do the equivalent of check-type on every argument. ;;; ;;; 2. Simply report TYPE-ERROR. This eliminates overhead of all the format ;;; strings generated by check-type. ;;; ;;; 3. Do error checking only on arguments that are likely to have errors ;;; (like keyword names) ;;; ;;; 4. Do error checking only where not doing so may dammage the envirnment ;;; on a non-tagged machine (i.e. when storing into a structure that has ;;; been passed in) ;;; ;;; 5. No extra error detection code. On lispm's, ASET may barf trying to ;;; store a non-integer into a number array. ;;; ;;; How extensive should the error checking be? For example, if the server ;;; expects a CARD16, is is sufficient for CLX to check for integer, or ;;; should it also check for non-negative and less than 65536? ;;;---------------------------------------------------------------------------- ;; The +TYPE-CHECK?+ constant controls how much error checking is done. ;; Possible values are: ;; NIL - Don't do any error checking ;; t - Do the equivalent of checktype on every argument ;; :minimal - Do error checking only where errors are likely ;;; This controls macro expansion, and isn't changable at run-time You will ;;; probably want to set this to nil if you want good performance at ;;; production time. (defconstant +type-check?+ #+(or Genera Minima CMU sbcl) nil #-(or Genera Minima CMU sbcl) t) ;; TYPE? is used to allow the code to do error checking at a different level from ;; the declarations. It also does some optimizations for systems that don't have ;; good compiler support for TYPEP. The definitions for CARD32, CARD16, INT16, etc. ;; include range checks. You can modify TYPE? to do less extensive checking ;; for these types if you desire. ;; ;; ### This comment is a lie! TYPE? is really also used for run-time type ;; dispatching, not just type checking. -- Ram. (defmacro type? (object type) #+(or cmu sbcl clisp) `(typep ,object ,type) #-(or cmu sbcl clisp) (if (not (constantp type)) `(typep ,object ,type) (progn (setq type (eval type)) #+(or Genera explorer Minima) (if +type-check?+ `(locally (declare (optimize safety)) (typep ,object ',type)) `(typep ,object ',type)) #-(or Genera explorer Minima) (let ((predicate (assoc type '((drawable drawable-p) (window window-p) (pixmap pixmap-p) (cursor cursor-p) (font font-p) (gcontext gcontext-p) (colormap colormap-p) (null null) (integer integerp))))) (cond (predicate `(,(second predicate) ,object)) ((eq type 'generalized-boolean) 't) ; Everything is a generalized-boolean. (+type-check?+ `(locally (declare (optimize safety)) (typep ,object ',type))) (t `(typep ,object ',type))))))) ;; X-TYPE-ERROR is the function called for type errors. ;; If you want lots of checking, but are concerned about code size, ;; this can be made into a macro that ignores some parameters. (defun x-type-error (object type &optional error-string) (x-error 'x-type-error :datum object :expected-type type :type-string error-string)) ;;----------------------------------------------------------------------------- ;; Error handlers ;; Hack up KMP error signaling using zetalisp until the real thing comes ;; along ;;----------------------------------------------------------------------------- (defun default-error-handler (display error-key &rest key-vals &key asynchronous &allow-other-keys) (declare (type generalized-boolean asynchronous) (dynamic-extent key-vals)) ;; The default display-error-handler. ;; It signals the conditions listed in the DISPLAY file. (if asynchronous (apply #'x-cerror "Ignore" error-key :display display :error-key error-key key-vals) (apply #'x-error error-key :display display :error-key error-key key-vals))) #+(and lispm (not Genera) (not clx-ansi-common-lisp)) (defun x-error (condition &rest keyargs) (apply #'sys:signal condition keyargs)) #+(and lispm (not Genera) (not clx-ansi-common-lisp)) (defun x-cerror (proceed-format-string condition &rest keyargs) (sys:signal (apply #'zl:make-condition condition keyargs) :proceed-types proceed-format-string)) #+(and Genera (not clx-ansi-common-lisp)) (defun x-error (condition &rest keyargs) (declare (dbg:error-reporter)) (apply #'sys:signal condition keyargs)) #+(and Genera (not clx-ansi-common-lisp)) (defun x-cerror (proceed-format-string condition &rest keyargs) (declare (dbg:error-reporter)) (apply #'sys:signal condition :continue-format-string proceed-format-string keyargs)) #+(or clx-ansi-common-lisp excl lcl3.0 clisp (and CMU mp)) (defun x-error (condition &rest keyargs) (declare (dynamic-extent keyargs)) (apply #'error condition keyargs)) #+(or clx-ansi-common-lisp excl lcl3.0 CMU clisp) (defun x-cerror (proceed-format-string condition &rest keyargs) (declare (dynamic-extent keyargs)) (apply #'cerror proceed-format-string condition keyargs)) ;;; X-ERROR for CMU Common Lisp ;;; ;;; We detect a couple condition types for which we disable event handling in ;;; our system. This prevents going into the debugger or returning to a ;;; command prompt with CLX repeatedly seeing the same condition. This occurs ;;; because CMU Common Lisp provides for all events (that is, X, input on file ;;; descriptors, Mach messages, etc.) to come through one routine anyone can ;;; use to wait for input. ;;; #+(and CMU (not mp)) (defun x-error (condition &rest keyargs) (let ((condx (apply #'make-condition condition keyargs))) (when (eq condition 'closed-display) (let ((disp (closed-display-display condx))) (warn "Disabled event handling on ~S." disp) (ext::disable-clx-event-handling disp))) (error condx))) #-(or lispm ansi-common-lisp excl lcl3.0 CMU sbcl clisp) (defun x-error (condition &rest keyargs) (error "X-Error: ~a" (princ-to-string (apply #'make-condition condition keyargs)))) #-(or lispm clx-ansi-common-lisp excl lcl3.0 CMU sbcl clisp) (defun x-cerror (proceed-format-string condition &rest keyargs) (cerror proceed-format-string "X-Error: ~a" (princ-to-string (apply #'make-condition condition keyargs)))) ;; version 15 of Pitman error handling defines the syntax for define-condition to be: ;; DEFINE-CONDITION name (parent-type) [({slot}*) {option}*] ;; Where option is one of: (:documentation doc-string) (:conc-name symbol-or-string) ;; or (:report exp) #+lcl3.0 (defmacro define-condition (name parent-types &optional slots &rest args) `(lcl:define-condition ,name (,(first parent-types)) ,(mapcar #'(lambda (slot) (if (consp slot) (car slot) slot)) slots) ,@args)) #+(and excl (not clx-ansi-common-lisp)) (defmacro define-condition (name parent-types &optional slots &rest args) `(excl::define-condition ,name (,(first parent-types)) ,(mapcar #'(lambda (slot) (if (consp slot) (car slot) slot)) slots) ,@args)) #+(and CMU (not clx-ansi-common-lisp)) (defmacro define-condition (name parent-types &optional slots &rest args) `(common-lisp:define-condition ,name (,(first parent-types)) ,(mapcar #'(lambda (slot) (if (consp slot) (car slot) slot)) slots) ,@args)) #+(and lispm (not clx-ansi-common-lisp)) (defmacro define-condition (name parent-types &body options) (let ((slot-names (mapcar #'(lambda (slot) (if (consp slot) (car slot) slot)) (pop options))) (documentation nil) (conc-name (concatenate 'string (string name) "-")) (reporter nil)) (dolist (item options) (ecase (first item) (:documentation (setq documentation (second item))) (:conc-name (setq conc-name (string (second item)))) (:report (setq reporter (second item))))) `(within-definition (,name define-condition) (zl:defflavor ,name ,slot-names ,parent-types :initable-instance-variables #-Genera (:accessor-prefix ,conc-name) #+Genera (:conc-name ,conc-name) #-Genera (:outside-accessible-instance-variables ,@slot-names) #+Genera (:readable-instance-variables ,@slot-names)) ,(when reporter ;; when no reporter, parent's is inherited `(zl:defmethod #-Genera (,name :report) #+Genera (dbg:report ,name) (stream) ,(if (stringp reporter) `(write-string ,reporter stream) `(,reporter global:self stream)) global:self)) (zl:compile-flavor-methods ,name) ,(when documentation `(setf (documentation name 'type) ,documentation)) ',name))) #+(and lispm (not Genera) (not clx-ansi-common-lisp)) (zl:defflavor x-error () (global:error)) #+(and Genera (not clx-ansi-common-lisp)) (scl:defflavor x-error ((dbg:proceed-types '(:continue)) ; continue-format-string) (sys:error) (:initable-instance-variables continue-format-string)) #+(and Genera (not clx-ansi-common-lisp)) (scl:defmethod (scl:make-instance x-error) (&rest ignore) (when (not (sys:variable-boundp continue-format-string)) (setf dbg:proceed-types (remove :continue dbg:proceed-types)))) #+(and Genera (not clx-ansi-common-lisp)) (scl:defmethod (dbg:proceed x-error :continue) () :continue) #+(and Genera (not clx-ansi-common-lisp)) (sys:defmethod (dbg:document-proceed-type x-error :continue) (stream) (format stream continue-format-string)) #+(or clx-ansi-common-lisp excl lcl3.0 CMU sbcl clisp) (define-condition x-error (error) ()) #-(or lispm clx-ansi-common-lisp excl lcl3.0 CMU sbcl) (defstruct x-error report-function) #-(or lispm clx-ansi-common-lisp excl lcl3.0 CMU sbcl) (defmacro define-condition (name parent-types &body options) ;; Define a structure that when printed displays an error message (flet ((reporter-for-condition (name) (xintern "." name '-reporter.))) (let ((slot-names (mapcar #'(lambda (slot) (if (consp slot) (car slot) slot)) (pop options))) (documentation nil) (conc-name (concatenate 'string (string name) "-")) (reporter nil) (condition (gensym)) (stream (gensym)) (report-function (reporter-for-condition name))) (dolist (item options) (ecase (first item) (:documentation (setq documentation (second item))) (:conc-name (setq conc-name (string (second item)))) (:report (setq reporter (second item))))) (unless reporter (setq report-function (reporter-for-condition (first parent-types)))) `(within-definition (,name define-condition) (defstruct (,name (:conc-name ,(intern conc-name)) (:print-function condition-print) (:include ,(first parent-types) (report-function ',report-function))) ,@slot-names) ,(when documentation `(setf (documentation name 'type) ,documentation)) ,(when reporter `(defun ,report-function (,condition ,stream) ,(if (stringp reporter) `(write-string ,reporter ,stream) `(,reporter ,condition ,stream)) ,condition)) ',name)))) #-(or lispm clx-ansi-common-lisp excl lcl3.0 CMU sbcl clisp) (defun condition-print (condition stream depth) (declare (type x-error condition) (type stream stream) (ignore depth)) (if *print-escape* (print-unreadable-object (condition stream :type t)) (funcall (x-error-report-function condition) condition stream)) condition) #-(or lispm clx-ansi-common-lisp excl lcl3.0 CMU sbcl clisp) (defun make-condition (type &rest slot-initializations) (declare (dynamic-extent slot-initializations)) (let ((make-function (intern (concatenate 'string (string 'make-) (string type)) (symbol-package type)))) (apply make-function slot-initializations))) #-(or clx-ansi-common-lisp excl lcl3.0 CMU sbcl clisp) (define-condition type-error (x-error) ((datum :reader type-error-datum :initarg :datum) (expected-type :reader type-error-expected-type :initarg :expected-type)) (:report (lambda (condition stream) (format stream "~s isn't a ~a" (type-error-datum condition) (type-error-expected-type condition))))) ;;----------------------------------------------------------------------------- ;; HOST hacking ;;----------------------------------------------------------------------------- #-(or explorer Genera Minima Allegro CMU sbcl ecl clisp) (defun host-address (host &optional (family :internet)) ;; Return a list whose car is the family keyword (:internet :DECnet :Chaos) ;; and cdr is a list of network address bytes. (declare (type stringable host) (type (or null (member :internet :decnet :chaos) card8) family)) (declare (clx-values list)) host family (error "HOST-ADDRESS not implemented yet.")) #+clisp (defun host-address (host &optional (family :internet)) "Return a list whose car is the family keyword (:internet :DECnet :Chaos) and cdr is a list of network address bytes." (declare (type stringable host) (type (or null (member :internet :decnet :chaos) card8) family)) (declare (clx-values list)) (labels ((no-host-error () (error "Unknown host ~S" host)) (no-address-error () (error "Host ~S has no ~S address" host family))) (let ((hostent (posix::resolve-host-ipaddr (string host)))) (when (not (posix::hostent-addr-list hostent)) (no-host-error)) (ecase family ((:internet nil 0) (unless (= (posix::hostent-addrtype hostent) 2) (no-address-error)) (let ((addr (first (posix::hostent-addr-list hostent)))) (etypecase addr (integer (list :internet (ldb (byte 8 24) addr) (ldb (byte 8 16) addr) (ldb (byte 8 8) addr) (ldb (byte 8 0) addr))) (string (let ((parts (read-from-string (nsubstitute #\Space #\. (ext:string-concat "(" addr ")"))))) (check-type parts (cons (unsigned-byte 8) (cons (unsigned-byte 8) (cons (unsigned-byte 8) (cons (unsigned-byte 8) NULL))))) (cons :internet parts)))))))))) #+explorer (defun host-address (host &optional (family :internet)) ;; Return a list whose car is the family keyword (:internet :DECnet :Chaos) ;; and cdr is a list of network address bytes. (declare (type stringable host) (type (or null (member :internet :decnet :chaos) card8) family)) (declare (clx-values list)) (ecase family ((:internet nil 0) (let ((addr (ip:get-ip-address host))) (unless addr (error "~s isn't an internet host name" host)) (list :internet (ldb (byte 8 24) addr) (ldb (byte 8 16) addr) (ldb (byte 8 8) addr) (ldb (byte 8 0) addr)))) ((:chaos 2) (let ((addr (first (chaos:chaos-addresses host)))) (unless addr (error "~s isn't a chaos host name" host)) (list :chaos (ldb (byte 8 0) addr) (ldb (byte 8 8) addr)))))) #+Genera (defun host-address (host &optional (family :internet)) ;; Return a list whose car is the family keyword (:internet :DECnet :Chaos) ;; and cdr is a list of network address bytes. (declare (type stringable host) (type (or null (member :internet :decnet :chaos) card8) family)) (declare (clx-values list)) (setf host (string host)) (let ((net-type (ecase family ((:internet nil 0) :internet) ((:DECnet 1) :dna) ((:chaos 2) :chaos)))) (dolist (addr (sys:send (net:parse-host host) :network-addresses) (error "~S isn't a valid ~(~A~) host name" host family)) (let ((network (car addr)) (address (cadr addr))) (when (sys:send network :network-typep net-type) (return (ecase family ((:internet nil 0) (multiple-value-bind (a b c d) (tcp:explode-internet-address address) (list :internet a b c d))) ((:DECnet 1) (list :DECnet (ldb (byte 8 0) address) (ldb (byte 8 8) address))) ((:chaos 2) (list :chaos (ldb (byte 8 0) address) (ldb (byte 8 8) address)))))))))) #+Minima (defun host-address (host &optional (family :internet)) ;; Return a list whose car is the family keyword (:internet :DECnet :Chaos) ;; and cdr is a list of network address bytes. (declare (type stringable host) (type (or null (member :internet :decnet :chaos) card8) family)) (declare (clx-values list)) (etypecase family ((:internet nil 0) (list* :internet (multiple-value-list (minima:ip-address-components (minima:parse-ip-address (string host)))))))) #+Allegro (defun host-address (host &optional (family :internet)) ;; Return a list whose car is the family keyword (:internet :DECnet :Chaos) ;; and cdr is a list of network address bytes. (declare (type stringable host) (type (or null (member :internet :decnet :chaos) card8) family)) (declare (clx-values list)) (labels ((no-host-error () (error "Unknown host ~S" host)) (no-address-error () (error "Host ~S has no ~S address" host family))) (let ((hostent 0)) (unwind-protect (progn (setf hostent (ipc::gethostbyname (string host))) (when (zerop hostent) (no-host-error)) (ecase family ((:internet nil 0) (unless (= (ipc::hostent-addrtype hostent) 2) (no-address-error)) (assert (= (ipc::hostent-length hostent) 4)) (let ((addr (ipc::hostent-addr hostent))) (when (or (member comp::.target. '(:hp :sgi4d :sony :dec3100) :test #'eq) (probe-file "/lib/ld.so")) ;; BSD 4.3 based systems require an extra indirection (setq addr (si:memref-int addr 0 0 :unsigned-long))) (list :internet (si:memref-int addr 0 0 :unsigned-byte) (si:memref-int addr 1 0 :unsigned-byte) (si:memref-int addr 2 0 :unsigned-byte) (si:memref-int addr 3 0 :unsigned-byte)))))) (ff:free-cstruct hostent))))) ;#+sbcl ;(require :sockets) #+CMU (defun host-address (host &optional (family :internet)) ;; Return a list whose car is the family keyword (:internet :DECnet :Chaos) ;; and cdr is a list of network address bytes. (declare (type stringable host) (type (or null (member :internet :decnet :chaos) card8) family)) (declare (clx-values list)) (labels ((no-host-error () (error "Unknown host ~S" host)) (no-address-error () (error "Host ~S has no ~S address" host family))) (let ((hostent #+rwi-sockets(ext:lookup-host-entry (string host)) #+mna-sockets(net.sbcl.sockets:look-up-host-entry (string host)) #+db-sockets(sockets:get-host-by-name (string host)))) (when (not hostent) (no-host-error)) (ecase family ((:internet nil 0) #+rwi-sockets(unless (= (ext::host-entry-addr-type hostent) 2) (no-address-error)) #+mna-sockets(unless (= (net.sbcl.sockets::host-entry-addr-type hostent) 2) (no-address-error)) ;; the following form is for use with SBCL and Daniel ;; Barlow's socket package #+db-sockets(unless (sockets:host-ent-address hostent) (no-address-error)) (append (list :internet) #+rwi-sockets (let ((addr (first (ext::host-entry-addr-list hostent)))) (list (ldb (byte 8 24) addr) (ldb (byte 8 16) addr) (ldb (byte 8 8) addr) (ldb (byte 8 0) addr))) #+mna-sockets (let ((addr (first (net.sbcl.sockets::host-entry-addr-list hostent)))) (list (ldb (byte 8 24) addr) (ldb (byte 8 16) addr) (ldb (byte 8 8) addr) (ldb (byte 8 0) addr))) ;; the following form is for use with SBCL and Daniel ;; Barlow's socket package #+db-sockets(coerce (sockets:host-ent-address hostent) 'list))))))) #+sbcl (defun host-address (host &optional (family :internet)) ;; Return a list whose car is the family keyword (:internet :DECnet :Chaos) ;; and cdr is a list of network address bytes. (declare (type stringable host) (type (or null (member :internet :decnet :chaos) card8) family)) (declare (clx-values list)) (let ((hostent (get-host-by-name (string host)))) (ecase family ((:internet nil 0) (cons :internet (coerce (host-ent-address hostent) 'list)))))) #+ecl (defun host-address (host &optional (family :internet)) ;; Return a list whose car is the family keyword (:internet :DECnet :Chaos) ;; and cdr is a list of network address bytes. (declare (type stringable host) (type (or null (member :internet :decnet :chaos) card8) family)) (declare (clx-values list)) (labels ((no-host-error () (error "Unknown host ~S" host))) (let ((addr (first (nth-value 3 (si::lookup-host-entry (string host)))))) (unless addr (no-host-error)) (list :internet (ldb (byte 8 24) addr) (ldb (byte 8 16) addr) (ldb (byte 8 8) addr) (ldb (byte 8 0) addr))))) #+explorer ;; This isn't required, but it helps make sense of the results from access-hosts (defun get-host (host-object) ;; host-object is a list whose car is the family keyword (:internet :DECnet :Chaos) ;; and cdr is a list of network address bytes. (declare (type list host-object)) (declare (clx-values string family)) (let* ((family (first host-object)) (address (ecase family (:internet (dpb (second host-object) (byte 8 24) (dpb (third host-object) (byte 8 16) (dpb (fourth host-object) (byte 8 8) (fifth host-object))))) (:chaos (dpb (third host-object) (byte 8 8) (second host-object)))))) (when (eq family :internet) (setq family :ip)) (let ((host (si:get-host-from-address address family))) (values (and host (funcall host :name)) family)))) ;;; This isn't required, but it helps make sense of the results from access-hosts #+Genera (defun get-host (host-object) ;; host-object is a list whose car is the family keyword (:internet :DECnet :Chaos) ;; and cdr is a list of network address bytes. (declare (type list host-object)) (declare (clx-values string family)) (let ((family (first host-object))) (values (sys:send (net:get-host-from-address (ecase family (:internet (apply #'tcp:build-internet-address (rest host-object))) ((:chaos :DECnet) (dpb (third host-object) (byte 8 8) (second host-object)))) (net:local-network-of-type (if (eq family :DECnet) :DNA family))) :name) family))) ;;; This isn't required, but it helps make sense of the results from access-hosts #+Minima (defun get-host (host-object) ;; host-object is a list whose car is the family keyword (:internet :DECnet :Chaos) ;; and cdr is a list of network address bytes. (declare (type list host-object)) (declare (clx-values string family)) (let ((family (first host-object))) (values (ecase family (:internet (minima:ip-address-string (apply #'minima:make-ip-address (rest host-object))))) family))) ;;----------------------------------------------------------------------------- ;; Whether to use closures for requests or not. ;;----------------------------------------------------------------------------- ;;; If this macro expands to non-NIL, then request and locking code is ;;; compiled in a much more compact format, as the common code is shared, and ;;; the specific code is built into a closure that is funcalled by the shared ;;; code. If your compiler makes efficient use of closures then you probably ;;; want to make this expand to T, as it makes the code more compact. (defmacro use-closures () #+(or lispm Minima) t #-(or lispm Minima) nil) #+(or Genera Minima) (defun clx-macroexpand (form env) (declare (ignore env)) form) #-(or Genera Minima) (defun clx-macroexpand (form env) (macroexpand form env)) ;;----------------------------------------------------------------------------- ;; Resource stuff ;;----------------------------------------------------------------------------- ;;; Utilities (defun getenv (name) #+excl (sys:getenv name) #+lcl3.0 (lcl:environment-variable name) #+CMU (cdr (assoc name ext:*environment-list* :test #'string=)) #+sbcl (sb-ext:posix-getenv name) #+ecl (si:getenv name) #+clisp (ext:getenv name) #-(or sbcl excl lcl3.0 CMU ecl clisp) (progn name nil)) (defun get-host-name () "Return the same hostname as gethostname(3) would" ;; machine-instance probably works on a lot of lisps, but clisp is not ;; one of them #+(or cmu sbcl ecl) (machine-instance) ;; resources-pathname was using short-site-name for this purpose #+excl (short-site-name) #+clisp (let ((s (machine-instance))) (subseq s 0 (position #\Space s))) #-(or excl cmu sbcl ecl clisp) (error "get-host-name not implemented")) (defun homedir-file-pathname (name) (and #-(or unix mach) (search "Unix" (software-type) :test #'char-equal) (merge-pathnames (user-homedir-pathname) (pathname name)))) ;;; DEFAULT-RESOURCES-PATHNAME - The pathname of the resources file to load if ;;; a resource manager isn't running. (defun default-resources-pathname () (homedir-file-pathname ".Xdefaults")) ;;; RESOURCES-PATHNAME - The pathname of the resources file to load after the ;;; defaults have been loaded. (defun resources-pathname () (or (let ((string (getenv "XENVIRONMENT"))) (and string (pathname string))) (homedir-file-pathname (concatenate 'string ".Xdefaults-" (get-host-name))))) ;;; AUTHORITY-PATHNAME - The pathname of the authority file. (defun authority-pathname () (or (let ((xauthority (getenv "XAUTHORITY"))) (and xauthority (pathname xauthority))) (homedir-file-pathname ".Xauthority"))) #+ecl (eval-when (:load-toplevel :execute :compile-toplevel) (pushnew :unix *features*)) ;;; this particular defaulting behaviour is typical to most Unices, I think #+unix (defun get-default-display (&optional display-name) "Parse the argument DISPLAY-NAME, or the environment variable $DISPLAY if it is NIL. Display names have the format [protocol/] [hostname] : [:] displaynumber [.screennumber] There are two special cases in parsing, to match that done in the Xlib C language bindings - If the hostname is ``unix'' or the empty string, any supplied protocol is ignored and a connection is made using the :local transport. - If a double colon separates hostname from displaynumber, the protocol is assumed to be decnet. Returns a list of (host display-number screen protocol)." (let* ((name (or display-name (getenv "DISPLAY") (error "DISPLAY environment variable is not set"))) (slash-i (or (position #\/ name) -1)) (colon-i (position #\: name :start (1+ slash-i))) (decnet-colon-p (eql (elt name (1+ colon-i)) #\:)) (host (subseq name (1+ slash-i) colon-i)) (dot-i (and colon-i (position #\. name :start colon-i))) (display (when colon-i (parse-integer name :start (if decnet-colon-p (+ colon-i 2) (1+ colon-i)) :end dot-i))) (screen (when dot-i (parse-integer name :start (1+ dot-i)))) (protocol (cond ((or (string= host "") (string-equal host "unix")) :local) (decnet-colon-p :decnet) ((> slash-i -1) (intern (string-upcase (subseq name 0 slash-i)) :keyword)) (t :internet)))) (list host (or display 0) (or screen 0) protocol))) ;;----------------------------------------------------------------------------- ;; GC stuff ;;----------------------------------------------------------------------------- (defun gc-cleanup () (declare (special *event-free-list* *pending-command-free-list* *reply-buffer-free-lists* *gcontext-local-state-cache* *temp-gcontext-cache*)) (setq *event-free-list* nil) (setq *pending-command-free-list* nil) (when (boundp '*reply-buffer-free-lists*) (fill *reply-buffer-free-lists* nil)) (setq *gcontext-local-state-cache* nil) (setq *temp-gcontext-cache* nil) nil) #+Genera (si:define-gc-cleanup clx-cleanup ("CLX Cleanup") (gc-cleanup)) ;;----------------------------------------------------------------------------- ;; WITH-STANDARD-IO-SYNTAX equivalent, used in (SETF WM-COMMAND) ;;----------------------------------------------------------------------------- #-(or clx-ansi-common-lisp Genera CMU sbcl ecl) (defun with-standard-io-syntax-function (function) (declare #+lispm (sys:downward-funarg function)) (let ((*package* (find-package :user)) (*print-array* t) (*print-base* 10) (*print-case* :upcase) (*print-circle* nil) (*print-escape* t) (*print-gensym* t) (*print-length* nil) (*print-level* nil) (*print-pretty* nil) (*print-radix* nil) (*read-base* 10) (*read-default-float-format* 'single-float) (*read-suppress* nil) #+ticl (ticl:*print-structure* t) #+lucid (lucid::*print-structure* t)) (funcall function))) #-(or clx-ansi-common-lisp Genera CMU sbcl ecl) (defmacro with-standard-io-syntax (&body body) `(flet ((.with-standard-io-syntax-body. () ,@body)) (with-standard-io-syntax-function #'.with-standard-io-syntax-body.))) ;;----------------------------------------------------------------------------- ;; DEFAULT-KEYSYM-TRANSLATE ;;----------------------------------------------------------------------------- ;;; If object is a character, char-bits are set from state. ;;; ;;; [the following isn't implemented (should it be?)] ;;; If object is a list, it is an alist with entries: ;;; (base-char [modifiers] [mask-modifiers]) ;;; When MODIFIERS are specified, this character translation ;;; will only take effect when the specified modifiers are pressed. ;;; MASK-MODIFIERS can be used to specify a set of modifiers to ignore. ;;; When MASK-MODIFIERS is missing, all other modifiers are ignored. ;;; In ambiguous cases, the most specific translation is used. #-(or (and clx-ansi-common-lisp (not lispm) (not allegro)) CMU sbcl) (defun default-keysym-translate (display state object) (declare (type display display) (type card16 state) (type t object) (clx-values t) (special left-meta-keysym right-meta-keysym left-super-keysym right-super-keysym left-hyper-keysym right-hyper-keysym)) (when (characterp object) (when (logbitp (position :control +state-mask-vector+) state) (setf (char-bit object :control) 1)) (when (or (state-keysymp display state left-meta-keysym) (state-keysymp display state right-meta-keysym)) (setf (char-bit object :meta) 1)) (when (or (state-keysymp display state left-super-keysym) (state-keysymp display state right-super-keysym)) (setf (char-bit object :super) 1)) (when (or (state-keysymp display state left-hyper-keysym) (state-keysymp display state right-hyper-keysym)) (setf (char-bit object :hyper) 1))) object) #+(or (and clx-ansi-common-lisp (not lispm) (not allegro)) CMU sbcl clisp) (defun default-keysym-translate (display state object) (declare (type display display) (type card16 state) (type t object) (ignore display state) (clx-values t)) object) ;;----------------------------------------------------------------------------- ;; Image stuff ;;----------------------------------------------------------------------------- ;;; Types (deftype pixarray-1-element-type () 'bit) (deftype pixarray-4-element-type () '(unsigned-byte 4)) (deftype pixarray-8-element-type () '(unsigned-byte 8)) (deftype pixarray-16-element-type () '(unsigned-byte 16)) (deftype pixarray-24-element-type () '(unsigned-byte 24)) (deftype pixarray-32-element-type () #-(or Genera Minima) '(unsigned-byte 32) #+(or Genera Minima) 'fixnum) (deftype pixarray-1 () '(#+(or cmu sbcl) simple-array #-(or cmu sbcl) array pixarray-1-element-type (* *))) (deftype pixarray-4 () '(#+(or cmu sbcl) simple-array #-(or cmu sbcl) array pixarray-4-element-type (* *))) (deftype pixarray-8 () '(#+(or cmu sbcl) simple-array #-(or cmu sbcl) array pixarray-8-element-type (* *))) (deftype pixarray-16 () '(#+(or cmu sbcl) simple-array #-(or cmu sbcl) array pixarray-16-element-type (* *))) (deftype pixarray-24 () '(#+(or cmu sbcl) simple-array #-(or cmu sbcl) array pixarray-24-element-type (* *))) (deftype pixarray-32 () '(#+(or cmu sbcl) simple-array #-(or cmu sbcl) array pixarray-32-element-type (* *))) (deftype pixarray () '(or pixarray-1 pixarray-4 pixarray-8 pixarray-16 pixarray-24 pixarray-32)) (deftype bitmap () 'pixarray-1) ;;; WITH-UNDERLYING-SIMPLE-VECTOR #+Genera (defmacro with-underlying-simple-vector ((variable element-type pixarray) &body body) (let ((bits-per-element (sys:array-bits-per-element (symbol-value (sys:type-array-element-type element-type))))) `(scl:stack-let ((,variable (make-array (index-ceiling (index* (array-total-size ,pixarray) (sys:array-element-size ,pixarray)) ,bits-per-element) :element-type ',element-type :displaced-to ,pixarray))) (declare (type (vector ,element-type) ,variable)) ,@body))) #+lcl3.0 (defmacro with-underlying-simple-vector ((variable element-type pixarray) &body body) `(let ((,variable (sys:underlying-simple-vector ,pixarray))) (declare (type (simple-array ,element-type (*)) ,variable)) ,@body)) #+excl (defmacro with-underlying-simple-vector ((variable element-type pixarray) &body body) `(let ((,variable (cdr (excl::ah_data ,pixarray)))) (declare (type (simple-array ,element-type (*)) ,variable)) ,@body)) #+(or CMU sbcl) ;;; We do *NOT* support viewing an array as having a different element type. ;;; Element-type is ignored. ;;; (defmacro with-underlying-simple-vector ((variable element-type pixarray) &body body) (declare (ignore element-type)) `(#+cmu kernel::with-array-data #+sbcl sb-kernel:with-array-data ((,variable ,pixarray) (start) (end)) (declare (ignore start end)) ,@body)) ;;; These are used to read and write pixels from and to CARD8s. ;;; READ-IMAGE-LOAD-BYTE is used to extract 1 and 4 bit pixels from CARD8s. (defmacro read-image-load-byte (size position integer) (unless +image-bit-lsb-first-p+ (setq position (- 7 position))) `(the (unsigned-byte ,size) (#-Genera ldb #+Genera sys:%logldb (byte ,size ,position) (the card8 ,integer)))) ;;; READ-IMAGE-ASSEMBLE-BYTES is used to build 16, 24 and 32 bit pixels from ;;; the appropriate number of CARD8s. (defmacro read-image-assemble-bytes (&rest bytes) (unless +image-byte-lsb-first-p+ (setq bytes (reverse bytes))) (let ((it (first bytes)) (count 0)) (dolist (byte (rest bytes)) (setq it `(#-Genera dpb #+Genera sys:%logdpb (the card8 ,byte) (byte 8 ,(incf count 8)) (the (unsigned-byte ,count) ,it)))) #-Genera `(the (unsigned-byte ,(* (length bytes) 8)) ,it) #+Genera it)) ;;; WRITE-IMAGE-LOAD-BYTE is used to extract a CARD8 from a 16, 24 or 32 bit ;;; pixel. (defmacro write-image-load-byte (position integer integer-size) integer-size (unless +image-byte-lsb-first-p+ (setq position (- integer-size 8 position))) `(the card8 (#-Genera ldb #+Genera sys:%logldb (byte 8 ,position) #-Genera (the (unsigned-byte ,integer-size) ,integer) #+Genera ,integer ))) ;;; WRITE-IMAGE-ASSEMBLE-BYTES is used to build a CARD8 from 1 or 4 bit ;;; pixels. (defmacro write-image-assemble-bytes (&rest bytes) (unless +image-bit-lsb-first-p+ (setq bytes (reverse bytes))) (let ((size (floor 8 (length bytes))) (it (first bytes)) (count 0)) (dolist (byte (rest bytes)) (setq it `(#-Genera dpb #+Genera sys:%logdpb (the (unsigned-byte ,size) ,byte) (byte ,size ,(incf count size)) (the (unsigned-byte ,count) ,it)))) `(the card8 ,it))) #+(or Genera lcl3.0 excl) (defvar *computed-image-byte-lsb-first-p* +image-byte-lsb-first-p+) #+(or Genera lcl3.0 excl) (defvar *computed-image-bit-lsb-first-p* +image-bit-lsb-first-p+) ;;; The following table gives the bit ordering within bytes (when accessed ;;; sequentially) for a scanline containing 32 bits, with bits numbered 0 to ;;; 31, where bit 0 should be leftmost on the display. For a given byte ;;; labelled A-B, A is for the most significant bit of the byte, and B is ;;; for the least significant bit. ;;; ;;; legend: ;;; 1 scanline-unit = 8 ;;; 2 scanline-unit = 16 ;;; 4 scanline-unit = 32 ;;; M byte-order = MostSignificant ;;; L byte-order = LeastSignificant ;;; m bit-order = MostSignificant ;;; l bit-order = LeastSignificant ;;; ;;; ;;; format ordering ;;; ;;; 1Mm 00-07 08-15 16-23 24-31 ;;; 2Mm 00-07 08-15 16-23 24-31 ;;; 4Mm 00-07 08-15 16-23 24-31 ;;; 1Ml 07-00 15-08 23-16 31-24 ;;; 2Ml 15-08 07-00 31-24 23-16 ;;; 4Ml 31-24 23-16 15-08 07-00 ;;; 1Lm 00-07 08-15 16-23 24-31 ;;; 2Lm 08-15 00-07 24-31 16-23 ;;; 4Lm 24-31 16-23 08-15 00-07 ;;; 1Ll 07-00 15-08 23-16 31-24 ;;; 2Ll 07-00 15-08 23-16 31-24 ;;; 4Ll 07-00 15-08 23-16 31-24 #+(or Genera lcl3.0 excl) (defconstant *image-bit-ordering-table* '(((1 (00 07) (08 15) (16 23) (24 31)) (nil nil)) ((2 (00 07) (08 15) (16 23) (24 31)) (nil nil)) ((4 (00 07) (08 15) (16 23) (24 31)) (nil nil)) ((1 (07 00) (15 08) (23 16) (31 24)) (nil t)) ((2 (15 08) (07 00) (31 24) (23 16)) (nil t)) ((4 (31 24) (23 16) (15 08) (07 00)) (nil t)) ((1 (00 07) (08 15) (16 23) (24 31)) (t nil)) ((2 (08 15) (00 07) (24 31) (16 23)) (t nil)) ((4 (24 31) (16 23) (08 15) (00 07)) (t nil)) ((1 (07 00) (15 08) (23 16) (31 24)) (t t)) ((2 (07 00) (15 08) (23 16) (31 24)) (t t)) ((4 (07 00) (15 08) (23 16) (31 24)) (t t)))) #+(or Genera lcl3.0 excl) (defun compute-image-byte-and-bit-ordering () (declare (clx-values image-byte-lsb-first-p image-bit-lsb-first-p)) ;; First compute the ordering (let ((ordering nil) (a (make-array '(1 32) :element-type 'bit :initial-element 0))) (dotimes (i 4) (push (flet ((bitpos (a i n) (declare (optimize (speed 3) (safety 0) (space 0))) (declare (type (simple-array bit (* *)) a) (type fixnum i n)) (with-underlying-simple-vector (v (unsigned-byte 8) a) (prog2 (setf (aref v i) n) (dotimes (i 32) (unless (zerop (aref a 0 i)) (return i))) (setf (aref v i) 0))))) (list (bitpos a i #b10000000) (bitpos a i #b00000001))) ordering)) (setq ordering (cons (floor +image-unit+ 8) (nreverse ordering))) ;; Now from the ordering, compute byte-lsb-first-p and bit-lsb-first-p (let ((byte-and-bit-ordering (second (assoc ordering *image-bit-ordering-table* :test #'equal)))) (unless byte-and-bit-ordering (error "Couldn't determine image byte and bit ordering~@ measured image ordering = ~A" ordering)) (values-list byte-and-bit-ordering)))) #+(or Genera lcl3.0 excl) (multiple-value-setq (*computed-image-byte-lsb-first-p* *computed-image-bit-lsb-first-p*) (compute-image-byte-and-bit-ordering)) ;;; If you can write fast routines that can read and write pixarrays out of a ;;; buffer-bytes, do it! It makes the image code a lot faster. The ;;; FAST-READ-PIXARRAY, FAST-WRITE-PIXARRAY and FAST-COPY-PIXARRAY routines ;;; return T if they can do it, NIL if they can't. ;;; FIXME: though we have some #+sbcl -conditionalized routines in ;;; here, they would appear not to work, and so are commented out in ;;; the the FAST-xxx-PIXARRAY routines themseleves. Investigate ;;; whether the unoptimized routines are often used, and also whether ;;; speeding them up while maintaining correctness is possible. ;;; FAST-READ-PIXARRAY - fill part of a pixarray from a buffer of card8s #+(or lcl3.0 excl) (defun fast-read-pixarray-1 (buffer-bbuf index array x y width height padded-bytes-per-line bits-per-pixel) (declare (type buffer-bytes buffer-bbuf) (type pixarray-1 array) (type card16 x y width height) (type array-index index padded-bytes-per-line) (type (member 1 4 8 16 24 32) bits-per-pixel) (ignore bits-per-pixel)) #.(declare-buffun) (with-vector (buffer-bbuf buffer-bytes) (with-underlying-simple-vector (vector pixarray-1-element-type array) (do* ((start (index+ index (index* y padded-bytes-per-line) (index-ceiling x 8)) (index+ start padded-bytes-per-line)) (y 0 (index1+ y)) (left-bits (the array-index (mod (the fixnum (- x)) 8))) (right-bits (index-mod (index- width left-bits) 8)) (middle-bits (the fixnum (- (the fixnum (- width left-bits)) right-bits))) (middle-bytes (index-floor middle-bits 8))) ((index>= y height)) (declare (type array-index start y left-bits right-bits middle-bytes) (fixnum middle-bits)) (cond ((< middle-bits 0) (let ((byte (aref buffer-bbuf (index1- start))) (x (array-row-major-index array y left-bits))) (declare (type card8 byte) (type array-index x)) (when (index> right-bits 6) (setf (aref vector (index- x 1)) (read-image-load-byte 1 7 byte))) (when (and (index> left-bits 1) (index> right-bits 5)) (setf (aref vector (index- x 2)) (read-image-load-byte 1 6 byte))) (when (and (index> left-bits 2) (index> right-bits 4)) (setf (aref vector (index- x 3)) (read-image-load-byte 1 5 byte))) (when (and (index> left-bits 3) (index> right-bits 3)) (setf (aref vector (index- x 4)) (read-image-load-byte 1 4 byte))) (when (and (index> left-bits 4) (index> right-bits 2)) (setf (aref vector (index- x 5)) (read-image-load-byte 1 3 byte))) (when (and (index> left-bits 5) (index> right-bits 1)) (setf (aref vector (index- x 6)) (read-image-load-byte 1 2 byte))) (when (index> left-bits 6) (setf (aref vector (index- x 7)) (read-image-load-byte 1 1 byte))))) (t (unless (index-zerop left-bits) (let ((byte (aref buffer-bbuf (index1- start))) (x (array-row-major-index array y left-bits))) (declare (type card8 byte) (type array-index x)) (setf (aref vector (index- x 1)) (read-image-load-byte 1 7 byte)) (when (index> left-bits 1) (setf (aref vector (index- x 2)) (read-image-load-byte 1 6 byte)) (when (index> left-bits 2) (setf (aref vector (index- x 3)) (read-image-load-byte 1 5 byte)) (when (index> left-bits 3) (setf (aref vector (index- x 4)) (read-image-load-byte 1 4 byte)) (when (index> left-bits 4) (setf (aref vector (index- x 5)) (read-image-load-byte 1 3 byte)) (when (index> left-bits 5) (setf (aref vector (index- x 6)) (read-image-load-byte 1 2 byte)) (when (index> left-bits 6) (setf (aref vector (index- x 7)) (read-image-load-byte 1 1 byte)) )))))))) (do* ((end (index+ start middle-bytes)) (i start (index1+ i)) (x (array-row-major-index array y left-bits) (index+ x 8))) ((index>= i end) (unless (index-zerop right-bits) (let ((byte (aref buffer-bbuf end)) (x (array-row-major-index array y (index+ left-bits middle-bits)))) (declare (type card8 byte) (type array-index x)) (setf (aref vector (index+ x 0)) (read-image-load-byte 1 0 byte)) (when (index> right-bits 1) (setf (aref vector (index+ x 1)) (read-image-load-byte 1 1 byte)) (when (index> right-bits 2) (setf (aref vector (index+ x 2)) (read-image-load-byte 1 2 byte)) (when (index> right-bits 3) (setf (aref vector (index+ x 3)) (read-image-load-byte 1 3 byte)) (when (index> right-bits 4) (setf (aref vector (index+ x 4)) (read-image-load-byte 1 4 byte)) (when (index> right-bits 5) (setf (aref vector (index+ x 5)) (read-image-load-byte 1 5 byte)) (when (index> right-bits 6) (setf (aref vector (index+ x 6)) (read-image-load-byte 1 6 byte)) ))))))))) (declare (type array-index end i x)) (let ((byte (aref buffer-bbuf i))) (declare (type card8 byte)) (setf (aref vector (index+ x 0)) (read-image-load-byte 1 0 byte)) (setf (aref vector (index+ x 1)) (read-image-load-byte 1 1 byte)) (setf (aref vector (index+ x 2)) (read-image-load-byte 1 2 byte)) (setf (aref vector (index+ x 3)) (read-image-load-byte 1 3 byte)) (setf (aref vector (index+ x 4)) (read-image-load-byte 1 4 byte)) (setf (aref vector (index+ x 5)) (read-image-load-byte 1 5 byte)) (setf (aref vector (index+ x 6)) (read-image-load-byte 1 6 byte)) (setf (aref vector (index+ x 7)) (read-image-load-byte 1 7 byte)))) ))))) t) #+(or lcl3.0 excl) (defun fast-read-pixarray-4 (buffer-bbuf index array x y width height padded-bytes-per-line bits-per-pixel) (declare (type buffer-bytes buffer-bbuf) (type pixarray-4 array) (type card16 x y width height) (type array-index index padded-bytes-per-line) (type (member 1 4 8 16 24 32) bits-per-pixel) (ignore bits-per-pixel)) #.(declare-buffun) (with-vector (buffer-bbuf buffer-bytes) (with-underlying-simple-vector (vector pixarray-4-element-type array) (do* ((start (index+ index (index* y padded-bytes-per-line) (index-ceiling x 2)) (index+ start padded-bytes-per-line)) (y 0 (index1+ y)) (left-nibbles (the array-index (mod (the fixnum (- (the fixnum x))) 2))) (right-nibbles (index-mod (index- width left-nibbles) 2)) (middle-nibbles (index- width left-nibbles right-nibbles)) (middle-bytes (index-floor middle-nibbles 2))) ((index>= y height)) (declare (type array-index start y left-nibbles right-nibbles middle-nibbles middle-bytes)) (unless (index-zerop left-nibbles) (setf (aref array y 0) (read-image-load-byte 4 4 (aref buffer-bbuf (index1- start))))) (do* ((end (index+ start middle-bytes)) (i start (index1+ i)) (x (array-row-major-index array y left-nibbles) (index+ x 2))) ((index>= i end) (unless (index-zerop right-nibbles) (setf (aref array y (index+ left-nibbles middle-nibbles)) (read-image-load-byte 4 0 (aref buffer-bbuf end))))) (declare (type array-index end i x)) (let ((byte (aref buffer-bbuf i))) (declare (type card8 byte)) (setf (aref vector (index+ x 0)) (read-image-load-byte 4 0 byte)) (setf (aref vector (index+ x 1)) (read-image-load-byte 4 4 byte)))) ))) t) #+(or Genera lcl3.0 excl CMU sbcl) (defun fast-read-pixarray-24 (buffer-bbuf index array x y width height padded-bytes-per-line bits-per-pixel) (declare (type buffer-bytes buffer-bbuf) (type pixarray-24 array) (type card16 width height) (type array-index index padded-bytes-per-line) (type (member 1 4 8 16 24 32) bits-per-pixel) (ignore bits-per-pixel)) #.(declare-buffun) (with-vector (buffer-bbuf buffer-bytes) (with-underlying-simple-vector (vector pixarray-24-element-type array) (do* ((start (index+ index (index* y padded-bytes-per-line) (index* x 3)) (index+ start padded-bytes-per-line)) (y 0 (index1+ y))) ((index>= y height)) (declare (type array-index start y)) (do* ((end (index+ start (index* width 3))) (i start (index+ i 3)) (x (array-row-major-index array y 0) (index1+ x))) ((index>= i end)) (declare (type array-index end i x)) (setf (aref vector x) (read-image-assemble-bytes (aref buffer-bbuf (index+ i 0)) (aref buffer-bbuf (index+ i 1)) (aref buffer-bbuf (index+ i 2)))))))) t) #+lispm (defun fast-read-pixarray-using-bitblt (bbuf boffset pixarray x y width height padded-bytes-per-line bits-per-pixel) (#+Genera sys:stack-let* #-Genera let* ((dimensions (list (+ y height) (floor (* padded-bytes-per-line 8) bits-per-pixel))) (a (make-array dimensions :element-type (array-element-type pixarray) :displaced-to bbuf :displaced-index-offset (floor (* boffset 8) bits-per-pixel)))) (sys:bitblt boole-1 width height a x y pixarray 0 0)) t) #+(or CMU sbcl) (defun pixarray-element-size (pixarray) (let ((eltype (array-element-type pixarray))) (cond ((eq eltype 'bit) 1) ((and (consp eltype) (eq (first eltype) 'unsigned-byte)) (second eltype)) (t (error "Invalid pixarray: ~S." pixarray))))) #+CMU ;;; COPY-BIT-RECT -- Internal ;;; ;;; This is the classic BITBLT operation, copying a rectangular subarray ;;; from one array to another (but source and destination must not overlap.) ;;; Widths are specified in bits. Neither array can have a non-zero ;;; displacement. We allow extra random bit-offset to be thrown into the X. ;;; (defun copy-bit-rect (source source-width sx sy dest dest-width dx dy height width) (declare (type array-index source-width sx sy dest-width dx dy height width)) #.(declare-buffun) (kernel::with-array-data ((sdata source) (sstart) (send)) (declare (ignore send)) (kernel::with-array-data ((ddata dest) (dstart) (dend)) (declare (ignore dend)) (assert (and (zerop sstart) (zerop dstart))) (do ((src-idx (index+ (* vm:vector-data-offset #+cmu vm:word-bits #+sbcl sb-vm:n-word-bits) sx (index* sy source-width)) (index+ src-idx source-width)) (dest-idx (index+ (* vm:vector-data-offset #+cmu vm:word-bits #+sbcl sb-vm:n-word-bits) dx (index* dy dest-width)) (index+ dest-idx dest-width)) (count height (1- count))) ((zerop count)) (declare (type array-index src-idx dest-idx count)) (kernel:bit-bash-copy sdata src-idx ddata dest-idx width))))) #+sbcl (defun copy-bit-rect (source source-width sx sy dest dest-width dx dy height width) (declare (type array-index source-width sx sy dest-width dx dy height width)) #.(declare-buffun) (sb-kernel:with-array-data ((sdata source) (sstart) (send)) (declare (ignore send)) (sb-kernel:with-array-data ((ddata dest) (dstart) (dend)) (declare (ignore dend)) (assert (and (zerop sstart) (zerop dstart))) (do ((src-idx (index+ (* sb-vm:vector-data-offset sb-vm:n-word-bits) sx (index* sy source-width)) (index+ src-idx source-width)) (dest-idx (index+ (* sb-vm:vector-data-offset sb-vm:n-word-bits) dx (index* dy dest-width)) (index+ dest-idx dest-width)) (count height (1- count))) ((zerop count)) (declare (type array-index src-idx dest-idx count)) (sb-kernel:ub1-bash-copy sdata src-idx ddata dest-idx width))))) #+(or CMU sbcl) (defun fast-read-pixarray-using-bitblt (bbuf boffset pixarray x y width height padded-bytes-per-line bits-per-pixel) (declare (type (array * 2) pixarray)) #.(declare-buffun) (copy-bit-rect bbuf (index* padded-bytes-per-line #+cmu vm:byte-bits #+sbcl sb-vm:n-byte-bits) (index* boffset #+cmu vm:byte-bits #+sbcl sb-vm:n-byte-bits) 0 pixarray (index* (array-dimension pixarray 1) bits-per-pixel) x y height (index* width bits-per-pixel)) t) #+(or Genera lcl3.0 excl) (defun fast-read-pixarray-with-swap (bbuf boffset pixarray x y width height padded-bytes-per-line bits-per-pixel unit byte-lsb-first-p bit-lsb-first-p) (declare (type buffer-bytes bbuf) (type array-index boffset padded-bytes-per-line) (type pixarray pixarray) (type card16 x y width height) (type (member 1 4 8 16 24 32) bits-per-pixel) (type (member 8 16 32) unit) (type generalized-boolean byte-lsb-first-p bit-lsb-first-p)) (unless (index= bits-per-pixel 24) (let ((pixarray-padded-bits-per-line (if (index= height 1) 0 (index* (index- (array-row-major-index pixarray 1 0) (array-row-major-index pixarray 0 0)) bits-per-pixel))) (x-bits (index* x bits-per-pixel))) (declare (type array-index pixarray-padded-bits-per-line x-bits)) (when (if (eq *computed-image-byte-lsb-first-p* *computed-image-bit-lsb-first-p*) (and (index-zerop (index-mod pixarray-padded-bits-per-line 8)) (index-zerop (index-mod x-bits 8))) (and (index-zerop (index-mod pixarray-padded-bits-per-line +image-unit+)) (index-zerop (index-mod x-bits +image-unit+)))) (multiple-value-bind (image-swap-function image-swap-lsb-first-p) (image-swap-function bits-per-pixel unit byte-lsb-first-p bit-lsb-first-p +image-unit+ *computed-image-byte-lsb-first-p* *computed-image-bit-lsb-first-p*) (declare (type symbol image-swap-function) (type generalized-boolean image-swap-lsb-first-p)) (with-underlying-simple-vector (dst card8 pixarray) (funcall (symbol-function image-swap-function) bbuf dst (index+ boffset (index* y padded-bytes-per-line) (index-floor x-bits 8)) 0 (index-ceiling (index* width bits-per-pixel) 8) padded-bytes-per-line (index-floor pixarray-padded-bits-per-line 8) height image-swap-lsb-first-p))) t)))) (defun fast-read-pixarray (bbuf boffset pixarray x y width height padded-bytes-per-line bits-per-pixel unit byte-lsb-first-p bit-lsb-first-p) (declare (type buffer-bytes bbuf) (type array-index boffset padded-bytes-per-line) (type pixarray pixarray) (type card16 x y width height) (type (member 1 4 8 16 24 32) bits-per-pixel) (type (member 8 16 32) unit) (type generalized-boolean byte-lsb-first-p bit-lsb-first-p)) (progn bbuf boffset pixarray x y width height padded-bytes-per-line bits-per-pixel unit byte-lsb-first-p bit-lsb-first-p) (or #+(or Genera lcl3.0 excl) (fast-read-pixarray-with-swap bbuf boffset pixarray x y width height padded-bytes-per-line bits-per-pixel unit byte-lsb-first-p bit-lsb-first-p) (let ((function (or #+lispm (and (= (sys:array-element-size pixarray) bits-per-pixel) (zerop (index-mod padded-bytes-per-line 4)) (zerop (index-mod (* #+Genera (sys:array-row-span pixarray) #-Genera (array-dimension pixarray 1) bits-per-pixel) 32)) #'fast-read-pixarray-using-bitblt) #+(or CMU) (and (index= (pixarray-element-size pixarray) bits-per-pixel) #'fast-read-pixarray-using-bitblt) #+(or lcl3.0 excl) (and (index= bits-per-pixel 1) #'fast-read-pixarray-1) #+(or lcl3.0 excl) (and (index= bits-per-pixel 4) #'fast-read-pixarray-4) #+(or Genera lcl3.0 excl CMU) (and (index= bits-per-pixel 24) #'fast-read-pixarray-24)))) (when function (read-pixarray-internal bbuf boffset pixarray x y width height padded-bytes-per-line bits-per-pixel function unit byte-lsb-first-p bit-lsb-first-p +image-unit+ +image-byte-lsb-first-p+ +image-bit-lsb-first-p+))))) ;;; FAST-WRITE-PIXARRAY - copy part of a pixarray into an array of CARD8s #+(or lcl3.0 excl) (defun fast-write-pixarray-1 (buffer-bbuf index array x y width height padded-bytes-per-line bits-per-pixel) (declare (type buffer-bytes buffer-bbuf) (type pixarray-1 array) (type card16 x y width height) (type array-index index padded-bytes-per-line) (type (member 1 4 8 16 24 32) bits-per-pixel) (ignore bits-per-pixel)) #.(declare-buffun) (with-vector (buffer-bbuf buffer-bytes) (with-underlying-simple-vector (vector pixarray-1-element-type array) (do* ((h 0 (index1+ h)) (y y (index1+ y)) (right-bits (index-mod width 8)) (middle-bits (index- width right-bits)) (middle-bytes (index-ceiling middle-bits 8)) (start index (index+ start padded-bytes-per-line))) ((index>= h height)) (declare (type array-index h y right-bits middle-bits middle-bytes start)) (do* ((end (index+ start middle-bytes)) (i start (index1+ i)) (start-x x) (x (array-row-major-index array y start-x) (index+ x 8))) ((index>= i end) (unless (index-zerop right-bits) (let ((x (array-row-major-index array y (index+ start-x middle-bits)))) (declare (type array-index x)) (setf (aref buffer-bbuf end) (write-image-assemble-bytes (aref vector (index+ x 0)) (if (index> right-bits 1) (aref vector (index+ x 1)) 0) (if (index> right-bits 2) (aref vector (index+ x 2)) 0) (if (index> right-bits 3) (aref vector (index+ x 3)) 0) (if (index> right-bits 4) (aref vector (index+ x 4)) 0) (if (index> right-bits 5) (aref vector (index+ x 5)) 0) (if (index> right-bits 6) (aref vector (index+ x 6)) 0) 0))))) (declare (type array-index end i start-x x)) (setf (aref buffer-bbuf i) (write-image-assemble-bytes (aref vector (index+ x 0)) (aref vector (index+ x 1)) (aref vector (index+ x 2)) (aref vector (index+ x 3)) (aref vector (index+ x 4)) (aref vector (index+ x 5)) (aref vector (index+ x 6)) (aref vector (index+ x 7)))))))) t) #+(or lcl3.0 excl) (defun fast-write-pixarray-4 (buffer-bbuf index array x y width height padded-bytes-per-line bits-per-pixel) (declare (type buffer-bytes buffer-bbuf) (type pixarray-4 array) (type int16 x y) (type card16 width height) (type array-index index padded-bytes-per-line) (type (member 1 4 8 16 24 32) bits-per-pixel) (ignore bits-per-pixel)) #.(declare-buffun) (with-vector (buffer-bbuf buffer-bytes) (with-underlying-simple-vector (vector pixarray-4-element-type array) (do* ((h 0 (index1+ h)) (y y (index1+ y)) (right-nibbles (index-mod width 2)) (middle-nibbles (index- width right-nibbles)) (middle-bytes (index-ceiling middle-nibbles 2)) (start index (index+ start padded-bytes-per-line))) ((index>= h height)) (declare (type array-index h y right-nibbles middle-nibbles middle-bytes start)) (do* ((end (index+ start middle-bytes)) (i start (index1+ i)) (start-x x) (x (array-row-major-index array y start-x) (index+ x 2))) ((index>= i end) (unless (index-zerop right-nibbles) (setf (aref buffer-bbuf end) (write-image-assemble-bytes (aref array y (index+ start-x middle-nibbles)) 0)))) (declare (type array-index end i start-x x)) (setf (aref buffer-bbuf i) (write-image-assemble-bytes (aref vector (index+ x 0)) (aref vector (index+ x 1)))))))) t) #+(or Genera lcl3.0 excl CMU sbcl) (defun fast-write-pixarray-24 (buffer-bbuf index array x y width height padded-bytes-per-line bits-per-pixel) (declare (type buffer-bytes buffer-bbuf) (type pixarray-24 array) (type int16 x y) (type card16 width height) (type array-index index padded-bytes-per-line) (type (member 1 4 8 16 24 32) bits-per-pixel) (ignore bits-per-pixel)) #.(declare-buffun) (with-vector (buffer-bbuf buffer-bytes) (with-underlying-simple-vector (vector pixarray-24-element-type array) (do* ((h 0 (index1+ h)) (y y (index1+ y)) (start index (index+ start padded-bytes-per-line))) ((index>= h height)) (declare (type array-index y start)) (do* ((end (index+ start (index* width 3))) (i start (index+ i 3)) (x (array-row-major-index array y x) (index1+ x))) ((index>= i end)) (declare (type array-index end i x)) (let ((pixel (aref vector x))) (declare (type pixarray-24-element-type pixel)) (setf (aref buffer-bbuf (index+ i 0)) (write-image-load-byte 0 pixel 24)) (setf (aref buffer-bbuf (index+ i 1)) (write-image-load-byte 8 pixel 24)) (setf (aref buffer-bbuf (index+ i 2)) (write-image-load-byte 16 pixel 24))))))) t) #+lispm (defun fast-write-pixarray-using-bitblt (bbuf boffset pixarray x y width height padded-bytes-per-line bits-per-pixel) (#+Genera sys:stack-let* #-Genera let* ((dimensions (list (+ y height) (floor (* padded-bytes-per-line 8) bits-per-pixel))) (a (make-array dimensions :element-type (array-element-type pixarray) :displaced-to bbuf :displaced-index-offset (floor (* boffset 8) bits-per-pixel)))) (sys:bitblt boole-1 width height pixarray x y a 0 0)) t) #+(or CMU sbcl) (defun fast-write-pixarray-using-bitblt (bbuf boffset pixarray x y width height padded-bytes-per-line bits-per-pixel) #.(declare-buffun) (copy-bit-rect pixarray (index* (array-dimension pixarray 1) bits-per-pixel) x y bbuf (index* padded-bytes-per-line #+cmu vm:byte-bits #+sbcl sb-vm:n-byte-bits) (index* boffset #+cmu vm:byte-bits #+sbcl sb-vm:n-byte-bits) 0 height (index* width bits-per-pixel)) t) #+(or Genera lcl3.0 excl) (defun fast-write-pixarray-with-swap (bbuf boffset pixarray x y width height padded-bytes-per-line bits-per-pixel unit byte-lsb-first-p bit-lsb-first-p) (declare (type buffer-bytes bbuf) (type pixarray pixarray) (type card16 x y width height) (type array-index boffset padded-bytes-per-line) (type (member 1 4 8 16 24 32) bits-per-pixel) (type (member 8 16 32) unit) (type generalized-boolean byte-lsb-first-p bit-lsb-first-p)) (unless (index= bits-per-pixel 24) (let ((pixarray-padded-bits-per-line (if (index= height 1) 0 (index* (index- (array-row-major-index pixarray 1 0) (array-row-major-index pixarray 0 0)) bits-per-pixel))) (pixarray-start-bit-offset (index* (array-row-major-index pixarray y x) bits-per-pixel))) (declare (type array-index pixarray-padded-bits-per-line pixarray-start-bit-offset)) (when (if (eq *computed-image-byte-lsb-first-p* *computed-image-bit-lsb-first-p*) (and (index-zerop (index-mod pixarray-padded-bits-per-line 8)) (index-zerop (index-mod pixarray-start-bit-offset 8))) (and (index-zerop (index-mod pixarray-padded-bits-per-line +image-unit+)) (index-zerop (index-mod pixarray-start-bit-offset +image-unit+)))) (multiple-value-bind (image-swap-function image-swap-lsb-first-p) (image-swap-function bits-per-pixel +image-unit+ *computed-image-byte-lsb-first-p* *computed-image-bit-lsb-first-p* unit byte-lsb-first-p bit-lsb-first-p) (declare (type symbol image-swap-function) (type generalized-boolean image-swap-lsb-first-p)) (with-underlying-simple-vector (src card8 pixarray) (funcall (symbol-function image-swap-function) src bbuf (index-floor pixarray-start-bit-offset 8) boffset (index-ceiling (index* width bits-per-pixel) 8) (index-floor pixarray-padded-bits-per-line 8) padded-bytes-per-line height image-swap-lsb-first-p)) t))))) (defun fast-write-pixarray (bbuf boffset pixarray x y width height padded-bytes-per-line bits-per-pixel unit byte-lsb-first-p bit-lsb-first-p) (declare (type buffer-bytes bbuf) (type pixarray pixarray) (type card16 x y width height) (type array-index boffset padded-bytes-per-line) (type (member 1 4 8 16 24 32) bits-per-pixel) (type (member 8 16 32) unit) (type generalized-boolean byte-lsb-first-p bit-lsb-first-p)) (progn bbuf boffset pixarray x y width height padded-bytes-per-line bits-per-pixel unit byte-lsb-first-p bit-lsb-first-p) (or #+(or Genera lcl3.0 excl) (fast-write-pixarray-with-swap bbuf boffset pixarray x y width height padded-bytes-per-line bits-per-pixel unit byte-lsb-first-p bit-lsb-first-p) (let ((function (or #+lispm (and (= (sys:array-element-size pixarray) bits-per-pixel) (zerop (index-mod padded-bytes-per-line 4)) (zerop (index-mod (* #+Genera (sys:array-row-span pixarray) #-Genera (array-dimension pixarray 1) bits-per-pixel) 32)) #'fast-write-pixarray-using-bitblt) #+(or CMU) (and (index= (pixarray-element-size pixarray) bits-per-pixel) #'fast-write-pixarray-using-bitblt) #+(or lcl3.0 excl) (and (index= bits-per-pixel 1) #'fast-write-pixarray-1) #+(or lcl3.0 excl) (and (index= bits-per-pixel 4) #'fast-write-pixarray-4) #+(or Genera lcl3.0 excl CMU) (and (index= bits-per-pixel 24) #'fast-write-pixarray-24)))) (when function (write-pixarray-internal bbuf boffset pixarray x y width height padded-bytes-per-line bits-per-pixel function +image-unit+ +image-byte-lsb-first-p+ +image-bit-lsb-first-p+ unit byte-lsb-first-p bit-lsb-first-p))))) ;;; FAST-COPY-PIXARRAY - copy part of a pixarray into another (defun fast-copy-pixarray (pixarray copy x y width height bits-per-pixel) (declare (type pixarray pixarray copy) (type card16 x y width height) (type (member 1 4 8 16 24 32) bits-per-pixel)) (progn pixarray copy x y width height bits-per-pixel nil) (or #+(or lispm CMU) (let* ((pixarray-padded-pixels-per-line #+Genera (sys:array-row-span pixarray) #-Genera (array-dimension pixarray 1)) (pixarray-padded-bits-per-line (* pixarray-padded-pixels-per-line bits-per-pixel)) (copy-padded-pixels-per-line #+Genera (sys:array-row-span copy) #-Genera (array-dimension copy 1)) (copy-padded-bits-per-line (* copy-padded-pixels-per-line bits-per-pixel))) #-(or CMU) (when (and (= (sys:array-element-size pixarray) bits-per-pixel) (zerop (index-mod pixarray-padded-bits-per-line 32)) (zerop (index-mod copy-padded-bits-per-line 32))) (sys:bitblt boole-1 width height pixarray x y copy 0 0) t) #+(or CMU) (when (index= (pixarray-element-size pixarray) (pixarray-element-size copy) bits-per-pixel) (copy-bit-rect pixarray pixarray-padded-bits-per-line x y copy copy-padded-bits-per-line 0 0 height (index* width bits-per-pixel)) t)) #+(or lcl3.0 excl) (unless (index= bits-per-pixel 24) (let ((pixarray-padded-bits-per-line (if (index= height 1) 0 (index* (index- (array-row-major-index pixarray 1 0) (array-row-major-index pixarray 0 0)) bits-per-pixel))) (copy-padded-bits-per-line (if (index= height 1) 0 (index* (index- (array-row-major-index copy 1 0) (array-row-major-index copy 0 0)) bits-per-pixel))) (pixarray-start-bit-offset (index* (array-row-major-index pixarray y x) bits-per-pixel))) (declare (type array-index pixarray-padded-bits-per-line copy-padded-bits-per-line pixarray-start-bit-offset)) (when (if (eq *computed-image-byte-lsb-first-p* *computed-image-bit-lsb-first-p*) (and (index-zerop (index-mod pixarray-padded-bits-per-line 8)) (index-zerop (index-mod copy-padded-bits-per-line 8)) (index-zerop (index-mod pixarray-start-bit-offset 8))) (and (index-zerop (index-mod pixarray-padded-bits-per-line +image-unit+)) (index-zerop (index-mod copy-padded-bits-per-line +image-unit+)) (index-zerop (index-mod pixarray-start-bit-offset +image-unit+)))) (with-underlying-simple-vector (src card8 pixarray) (with-underlying-simple-vector (dst card8 copy) (image-noswap src dst (index-floor pixarray-start-bit-offset 8) 0 (index-ceiling (index* width bits-per-pixel) 8) (index-floor pixarray-padded-bits-per-line 8) (index-floor copy-padded-bits-per-line 8) height nil))) t))) #+(or lcl3.0 excl) (macrolet ((copy (type element-type) `(let ((pixarray pixarray) (copy copy)) (declare (type ,type pixarray copy)) #.(declare-buffun) (with-underlying-simple-vector (src ,element-type pixarray) (with-underlying-simple-vector (dst ,element-type copy) (do* ((dst-y 0 (index1+ dst-y)) (src-y y (index1+ src-y))) ((index>= dst-y height)) (declare (type card16 dst-y src-y)) (do* ((dst-idx (array-row-major-index copy dst-y 0) (index1+ dst-idx)) (dst-end (index+ dst-idx width)) (src-idx (array-row-major-index pixarray src-y x) (index1+ src-idx))) ((index>= dst-idx dst-end)) (declare (type array-index dst-idx src-idx dst-end)) (setf (aref dst dst-idx) (the ,element-type (aref src src-idx)))))))))) (ecase bits-per-pixel (1 (copy pixarray-1 pixarray-1-element-type)) (4 (copy pixarray-4 pixarray-4-element-type)) (8 (copy pixarray-8 pixarray-8-element-type)) (16 (copy pixarray-16 pixarray-16-element-type)) (24 (copy pixarray-24 pixarray-24-element-type)) (32 (copy pixarray-32 pixarray-32-element-type))) t))) ecl-16.1.2/src/clx/display.lisp000066400000000000000000001001771266352375300163010ustar00rootroot00000000000000;;; -*- Mode: LISP; Syntax: Common-lisp; Package: XLIB; Base: 10; Lowercase: Yes -*- ;;; This file contains definitions for the DISPLAY object for Common-Lisp X windows version 11 ;;; ;;; TEXAS INSTRUMENTS INCORPORATED ;;; P.O. BOX 2909 ;;; AUSTIN, TEXAS 78769 ;;; ;;; Copyright (C) 1987 Texas Instruments Incorporated. ;;; ;;; Permission is granted to any individual or institution to use, copy, modify, ;;; and distribute this software, provided that this complete copyright and ;;; permission notice is maintained, intact, in all copies and supporting ;;; documentation. ;;; ;;; Texas Instruments Incorporated provides this software "as is" without ;;; express or implied warranty. ;;; (in-package :xlib) ;;; Authorizaton (defparameter *known-authorizations* '("MIT-MAGIC-COOKIE-1")) ;;; X11 Authorization: to prevent malicious users from snooping on a ;;; display, X servers may require connection requests to be ;;; authorized. The X server (or display manager) will create a random ;;; key on startup, and store it as an entry in a file generally named ;;; $HOME/.Xauthority (see xauth(1) and the AUTHORITY-PATHNAME ;;; function). Clients must extract from this file the "magic cookie" ;;; that corresponds to the server they wish to connect to, and send ;;; it as authorization data when opening the display. ;;; The format of the .Xauthority file is documented in the XFree ;;; sources, in the file xc/lib/Xau/README. ;;; Stolen from the cmucl sources, with patches by Hannu Rummukainen and ;;; Scott Fahlman. (defun read-xauth-entry (stream) (labels ((read-short (stream &optional (eof-errorp t)) (let ((high-byte (read-byte stream eof-errorp))) (and high-byte (dpb high-byte (byte 8 8) (read-byte stream))))) (read-short-length-string (stream) (let ((length (read-short stream))) (let ((string (make-string length))) (dotimes (k length) (setf (schar string k) (card8->char (read-byte stream)))) string))) (read-short-length-vector (stream) (let ((length (read-short stream))) (let ((vector (make-array length :element-type '(unsigned-byte 8)))) (dotimes (k length) (setf (aref vector k) (read-byte stream))) vector)))) (let ((family-id (read-short stream nil))) (if (null family-id) (list nil nil nil nil nil) (let* ((address-data (read-short-length-vector stream)) (number (parse-integer (read-short-length-string stream))) (name (read-short-length-string stream)) (data (read-short-length-vector stream)) (family (car (rassoc family-id *protocol-families*)))) (unless family (return-from read-xauth-entry ;; we return FAMILY-ID to signal to ;; GET-BEST-AUTHORIZATION that we haven't finished ;; with the stream. (list family-id nil nil nil nil))) (let ((address (case family (:local (map 'string #'code-char address-data)) (:internet (coerce address-data 'list)) ;; FIXME: we can probably afford not to support ;; :DECNET or :CHAOSNET in this modern age, but ;; :INTERNET6 probably deserve support. -- CSR, ;; 2005-08-07 (t nil)))) ;; if ADDRESS is NIL by this time, we will never match ;; the address of DISPLAY. (list family address number name data))))))) (defun get-best-authorization (host display protocol) ;; parse .Xauthority, extract the cookie for DISPLAY on HOST. ;; PROTOCOL determines whether the server connection is using an ;; Internet protocol (value of :internet) or a non-network ;; protocol such as Unix domain sockets (value of :local). Returns ;; two strings: an authorization name (very likely the string ;; "MIT-MAGIC-COOKIE-1") and an authorization key, represented as ;; fixnums in a vector. If we fail to find an appropriate cookie, ;; return two empty strings. (let ((pathname (authority-pathname))) (when pathname (with-open-file (stream pathname :element-type '(unsigned-byte 8) :if-does-not-exist nil) (when stream (let* ((host-address (and (eql protocol :internet) (rest (host-address host protocol)))) (best-name nil) (best-pos nil) (best-data nil)) ;; Check for the localhost address, in which case we're ;; really FamilyLocal. (when (or (eql protocol :local) (and (eql protocol :internet) (equal host-address '(127 0 0 1)))) (setq host-address (get-host-name)) (setq protocol :local)) (loop (destructuring-bind (family address number name data) (read-xauth-entry stream) (unless family (return)) (when (and (eql family protocol) (equal host-address address) (= number display) (let ((pos1 (position name *known-authorizations* :test #'string=))) (and pos1 (or (null best-pos) (< pos1 best-pos))))) (setf best-name name best-pos (position name *known-authorizations* :test #'string=) best-data data)))) (when best-name (return-from get-best-authorization (values best-name best-data))))))) (values "" ""))) (defmacro with-display ((display &key timeout inline) &body body) ;; This macro is for use in a multi-process environment. It ;; provides exclusive access to the local display object for ;; multiple request generation. It need not provide immediate ;; exclusive access for replies; that is, if another process is ;; waiting for a reply (while not in a with-display), then ;; synchronization need not (but can) occur immediately. Except ;; where noted, all routines effectively contain an implicit ;; with-display where needed, so that correct synchronization is ;; always provided at the interface level on a per-call basis. ;; Nested uses of this macro will work correctly. This macro does ;; not prevent concurrent event processing; see with-event-queue. `(with-buffer (,display ,@(and timeout `(:timeout ,timeout)) ,@(and inline `(:inline ,inline))) ,@body)) ;; ;; Resource id management ;; (defun initialize-resource-allocator (display) ;; Find the resource-id-byte (appropriate for LDB & DPB) from the resource-id-mask (let ((id-mask (display-resource-id-mask display))) (unless (zerop id-mask) ;; zero mask is an error (do ((first 0 (index1+ first)) (mask id-mask (the mask32 (ash mask -1)))) ((oddp mask) (setf (display-resource-id-byte display) (byte (integer-length mask) first))) (declare (type array-index first) (type mask32 mask)))))) (defun resourcealloc (display) ;; Allocate a resource-id for use in DISPLAY (declare (type display display)) (declare (clx-values resource-id)) (loop for next-count upfrom (1+ (display-resource-id-count display)) repeat (1+ (display-resource-id-mask display)) as id = (dpb next-count (display-resource-id-byte display) (display-resource-id-base display)) unless (nth-value 1 (gethash id (display-resource-id-map display))) do (setf (display-resource-id-count display) next-count) (setf (gethash id (display-resource-id-map display)) t) (return-from resourcealloc id)) ;; internal consistency check (assert (= (hash-table-count (display-resource-id-map display)) (1+ (display-resource-id-mask display)))) ;; tell the user what's gone wrong (error 'resource-ids-exhausted)) (defmacro allocate-resource-id (display object type) ;; Allocate a resource-id for OBJECT in DISPLAY `(with-display (,display) ,(if (member (eval type) +clx-cached-types+) `(let ((id (funcall (display-xid ,display) ,display))) (save-id ,display id ,object) id) `(funcall (display-xid ,display) ,display)))) (defmacro deallocate-resource-id (display id type) (declare (ignore type)) ;; Deallocate a resource-id for OBJECT in DISPLAY `(deallocate-resource-id-internal ,display ,id)) (defun deallocate-resource-id-internal (display id) (with-display (display) (remhash id (display-resource-id-map display)))) (defun lookup-resource-id (display id) ;; Find the object associated with resource ID (gethash id (display-resource-id-map display))) (defun save-id (display id object) ;; cache the object associated with ID for this display. (declare (type display display) (type integer id) (type t object)) (declare (clx-values object)) ;; we can't cache objects from other clients, because they may ;; become invalid without us being told about that. (let ((base (display-resource-id-base display)) (mask (display-resource-id-mask display))) (when (= (logandc2 id mask) base) (setf (gethash id (display-resource-id-map display)) object)) object)) ;; Define functions to find the CLX data types given a display and resource-id ;; If the data type is being cached, look there first. (macrolet ((generate-lookup-functions (useless-name &body types) `(within-definition (,useless-name generate-lookup-functions) ,@(mapcar #'(lambda (type) `(defun ,(xintern 'lookup- type) (display id) (declare (type display display) (type resource-id id)) (declare (clx-values ,type)) ,(if (member type +clx-cached-types+) `(let ((,type (lookup-resource-id display id))) (cond ((null ,type) ;; Not found, create and save it. (setq ,type (,(xintern 'make- type) :display display :id id)) (save-id display id ,type)) ;; Found. Check the type ,(cond ((null +type-check?+) `(t ,type)) ((member type '(window pixmap)) `((type? ,type 'drawable) ,type)) (t `((type? ,type ',type) ,type))) ,@(when +type-check?+ `((t (x-error 'lookup-error :id id :display display :type ',type :object ,type)))))) ;; Not being cached. Create a new one each time. `(,(xintern 'make- type) :display display :id id)))) types)))) (generate-lookup-functions ignore drawable window pixmap gcontext cursor colormap font)) (defun id-atom (id display) ;; Return the cached atom for an atom ID (declare (type resource-id id) (type display display)) (declare (clx-values (or null keyword))) (gethash id (display-atom-id-map display))) (defun atom-id (atom display) ;; Return the ID for an atom in DISPLAY (declare (type xatom atom) (type display display)) (declare (clx-values (or null resource-id))) (gethash (if (or (null atom) (keywordp atom)) atom (kintern atom)) (display-atom-cache display))) (defun set-atom-id (atom display id) ;; Set the ID for an atom in DISPLAY (declare (type xatom atom) (type display display) (type resource-id id)) (declare (clx-values resource-id)) (let ((atom (if (or (null atom) (keywordp atom)) atom (kintern atom)))) (setf (gethash id (display-atom-id-map display)) atom) (setf (gethash atom (display-atom-cache display)) id) id)) (defsetf atom-id set-atom-id) (defun initialize-predefined-atoms (display) (dotimes (i (length +predefined-atoms+)) (declare (type resource-id i)) (setf (atom-id (svref +predefined-atoms+ i) display) i))) (defun visual-info (display visual-id) (declare (type display display) (type resource-id visual-id) (clx-values visual-info)) (when (zerop visual-id) (return-from visual-info nil)) (dolist (screen (display-roots display)) (declare (type screen screen)) (dolist (depth (screen-depths screen)) (declare (type cons depth)) (dolist (visual-info (rest depth)) (declare (type visual-info visual-info)) (when (funcall (resource-id-map-test) visual-id (visual-info-id visual-info)) (return-from visual-info visual-info))))) (error "Visual info not found for id #x~x in display ~s." visual-id display)) ;; ;; Display functions ;; (defmacro with-event-queue ((display &key timeout inline) &body body &environment env) ;; exclusive access to event queue `(macrolet ((with-event-queue ((display &key timeout) &body body) ;; Speedup hack for lexically nested with-event-queues `(progn (progn ,display ,@(and timeout `(,timeout)) nil) ,@body))) ,(if (and (null inline) (macroexpand '(use-closures) env)) `(flet ((.with-event-queue-body. () ,@body)) #+clx-ansi-common-lisp (declare (dynamic-extent #'.with-event-queue-body.)) (with-event-queue-function ,display ,timeout #'.with-event-queue-body.)) (let ((disp (if (or (symbolp display) (constantp display)) display '.display.))) `(let (,@(unless (eq disp display) `((,disp ,display)))) (holding-lock ((display-event-lock ,disp) ,disp "CLX Event Lock" ,@(and timeout `(:timeout ,timeout))) ,@body)))))) (defun with-event-queue-function (display timeout function) (declare (type display display) (type (or null number) timeout) (type function function) #+clx-ansi-common-lisp (dynamic-extent function) ;; FIXME: see SBCL bug #243 (ignorable display timeout) #+(and lispm (not clx-ansi-common-lisp)) (sys:downward-funarg function)) (with-event-queue (display :timeout timeout :inline t) (funcall function))) (defmacro with-event-queue-internal ((display &key timeout) &body body) ;; exclusive access to the internal event queues (let ((disp (if (or (symbolp display) (constantp display)) display '.display.))) `(let (,@(unless (eq disp display) `((,disp ,display)))) (holding-lock ((display-event-queue-lock ,disp) ,disp "CLX Event Queue Lock" ,@(and timeout `(:timeout ,timeout))) ,@body)))) (defun open-default-display (&optional display-name) "Open a connection to DISPLAY-NAME if supplied, or to the appropriate default display as given by GET-DEFAULT-DISPLAY otherwise. OPEN-DISPLAY-NAME always attempts to do display authorization. The hostname is resolved to an address, then authorization data for the (protocol, host-address, displaynumber) triple is looked up in the file given by AUTHORITY_PATHNAME (typically $HOME/.Xauthority). If the protocol is :local, or if the hostname resolves to the local host, authority data for the local machine's actual hostname - as returned by gethostname(3) - is used instead." (destructuring-bind (host display screen protocol) (get-default-display display-name) (let ((display (open-display host :display display :protocol protocol))) (setf (display-default-screen display) (nth screen (display-roots display))) display))) (defun open-display (host &key (display 0) protocol authorization-name authorization-data) ;; Implementation specific routine to setup the buffer for a ;; specific host and display. This must interface with the local ;; network facilities, and will probably do special things to ;; circumvent the nework when displaying on the local host. ;; ;; A string must be acceptable as a host, but otherwise the possible types ;; for host and protocol are not constrained, and will likely be very ;; system dependent. The default protocol is system specific. Authorization, ;; if any, is assumed to come from the environment somehow. (declare (type integer display)) (declare (clx-values display)) ;; Get the authorization mechanism from the environment. Handle the ;; special case of a host name of "" and "unix" which means the ;; protocol is :local (when (null authorization-name) (multiple-value-setq (authorization-name authorization-data) (get-best-authorization host display (if (member host '("" "unix") :test #'equal) :local protocol)))) ;; PROTOCOL is the network protocol (something like :TCP :DNA or :CHAOS). See OPEN-X-STREAM. (let* ((stream (open-x-stream host display protocol)) (disp (make-buffer *output-buffer-size* #'make-display-internal :host host :display display :output-stream stream :input-stream stream)) (ok-p nil)) (unwind-protect (progn (display-connect disp :authorization-name authorization-name :authorization-data authorization-data) (setf (display-authorization-name disp) authorization-name) (setf (display-authorization-data disp) authorization-data) (initialize-resource-allocator disp) (initialize-predefined-atoms disp) (initialize-extensions disp) (when (assoc "BIG-REQUESTS" (display-extension-alist disp) :test #'string=) (enable-big-requests disp)) (setq ok-p t)) (unless ok-p (close-display disp :abort t))) disp)) (defun display-force-output (display) ; Output is normally buffered, this forces any buffered output to the server. (declare (type display display)) (with-display (display) (buffer-force-output display))) (defun close-display (display &key abort) ;; Close the host connection in DISPLAY (declare (type display display)) (close-buffer display :abort abort)) (defun display-connect (display &key authorization-name authorization-data) (with-buffer-output (display :sizes (8 16)) (card8-put 0 (ecase (display-byte-order display) (:lsbfirst #x6c) ;; Ascii lowercase l - Least Significant Byte First (:msbfirst #x42))) ;; Ascii uppercase B - Most Significant Byte First (card16-put 2 *protocol-major-version*) (card16-put 4 *protocol-minor-version*) (card16-put 6 (length authorization-name)) (card16-put 8 (length authorization-data)) (write-sequence-char display 12 authorization-name) (if (stringp authorization-data) (write-sequence-char display (lround (+ 12 (length authorization-name))) authorization-data) (write-sequence-card8 display (lround (+ 12 (length authorization-name))) authorization-data))) (buffer-force-output display) (let ((reply-buffer nil)) (declare (type (or null reply-buffer) reply-buffer)) (unwind-protect (progn (setq reply-buffer (allocate-reply-buffer #x1000)) (with-buffer-input (reply-buffer :sizes (8 16 32)) (buffer-input display buffer-bbuf 0 8) (let ((success (boolean-get 0)) (reason-length (card8-get 1)) (major-version (card16-get 2)) (minor-version (card16-get 4)) (total-length (card16-get 6)) vendor-length num-roots num-formats) (declare (ignore total-length)) (unless success (x-error 'connection-failure :major-version major-version :minor-version minor-version :host (display-host display) :display (display-display display) :reason (progn (buffer-input display buffer-bbuf 0 reason-length) (string-get reason-length 0 :reply-buffer reply-buffer)))) (buffer-input display buffer-bbuf 0 32) (setf (display-protocol-major-version display) major-version) (setf (display-protocol-minor-version display) minor-version) (setf (display-release-number display) (card32-get 0)) (setf (display-resource-id-base display) (card32-get 4)) (setf (display-resource-id-mask display) (card32-get 8)) (setf (display-motion-buffer-size display) (card32-get 12)) (setq vendor-length (card16-get 16)) (setf (display-max-request-length display) (card16-get 18)) (setq num-roots (card8-get 20)) (setq num-formats (card8-get 21)) ;; Get the image-info (setf (display-image-lsb-first-p display) (zerop (card8-get 22))) (let ((format (display-bitmap-format display))) (declare (type bitmap-format format)) (setf (bitmap-format-lsb-first-p format) (zerop (card8-get 23))) (setf (bitmap-format-unit format) (card8-get 24)) (setf (bitmap-format-pad format) (card8-get 25))) (setf (display-min-keycode display) (card8-get 26)) (setf (display-max-keycode display) (card8-get 27)) ;; 4 bytes unused ;; Get the vendor string (buffer-input display buffer-bbuf 0 (lround vendor-length)) (setf (display-vendor-name display) (string-get vendor-length 0 :reply-buffer reply-buffer)) ;; Initialize the pixmap formats (dotimes (i num-formats) ;; loop gathering pixmap formats (declare (ignorable i)) (buffer-input display buffer-bbuf 0 8) (push (make-pixmap-format :depth (card8-get 0) :bits-per-pixel (card8-get 1) :scanline-pad (card8-get 2)) ; 5 unused bytes (display-pixmap-formats display))) (setf (display-pixmap-formats display) (nreverse (display-pixmap-formats display))) ;; Initialize the screens (dotimes (i num-roots) (declare (ignorable i)) (buffer-input display buffer-bbuf 0 40) (let* ((root-id (card32-get 0)) (root (make-window :id root-id :display display)) (root-visual (card32-get 32)) (default-colormap-id (card32-get 4)) (default-colormap (make-colormap :id default-colormap-id :display display)) (screen (make-screen :root root :default-colormap default-colormap :white-pixel (card32-get 8) :black-pixel (card32-get 12) :event-mask-at-open (card32-get 16) :width (card16-get 20) :height (card16-get 22) :width-in-millimeters (card16-get 24) :height-in-millimeters (card16-get 26) :min-installed-maps (card16-get 28) :max-installed-maps (card16-get 30) :backing-stores (member8-get 36 :never :when-mapped :always) :save-unders-p (boolean-get 37) :root-depth (card8-get 38))) (num-depths (card8-get 39)) (depths nil)) ;; Save root window for event reporting (save-id display root-id root) (save-id display default-colormap-id default-colormap) ;; Create the depth AList for a screen, (depth . visual-infos) (dotimes (j num-depths) (declare (ignorable j)) (buffer-input display buffer-bbuf 0 8) (let ((depth (card8-get 0)) (num-visuals (card16-get 2)) (visuals nil)) ;; 4 bytes unused (dotimes (k num-visuals) (declare (ignorable k)) (buffer-input display buffer-bbuf 0 24) (let* ((visual (card32-get 0)) (visual-info (make-visual-info :id visual :display display :class (member8-get 4 :static-gray :gray-scale :static-color :pseudo-color :true-color :direct-color) :bits-per-rgb (card8-get 5) :colormap-entries (card16-get 6) :red-mask (card32-get 8) :green-mask (card32-get 12) :blue-mask (card32-get 16) ;; 4 bytes unused ))) (push visual-info visuals) (when (funcall (resource-id-map-test) root-visual visual) (setf (screen-root-visual-info screen) (setf (colormap-visual-info default-colormap) visual-info))))) (push (cons depth (nreverse visuals)) depths))) (setf (screen-depths screen) (nreverse depths)) (push screen (display-roots display)))) (setf (display-roots display) (nreverse (display-roots display))) (setf (display-default-screen display) (first (display-roots display)))))) (when reply-buffer (deallocate-reply-buffer reply-buffer)))) display) (defun display-protocol-version (display) (declare (type display display)) (declare (clx-values major minor)) (values (display-protocol-major-version display) (display-protocol-minor-version display))) (defun display-vendor (display) (declare (type display display)) (declare (clx-values name release)) (values (display-vendor-name display) (display-release-number display))) (defun display-nscreens (display) (declare (type display display)) (length (display-roots display))) #+comment ;; defined by the DISPLAY defstruct (defsetf display-error-handler (display) (handler) ;; All errors (synchronous and asynchronous) are processed by ;; calling an error handler in the display. If handler is a ;; sequence it is expected to contain handler functions specific to ;; each error; the error code is used to index the sequence, ;; fetching the appropriate handler. Any results returned by the ;; handler are ignored; it is assumed the handler either takes care ;; of the error completely, or else signals. For all core errors, ;; the keyword/value argument pairs are: ;; :display display ;; :error-key error-key ;; :major integer ;; :minor integer ;; :sequence integer ;; :current-sequence integer ;; For :colormap, :cursor, :drawable, :font, :gcontext, :id-choice, :pixmap, and ;; :window errors another pair is: ;; :resource-id integer ;; For :atom errors, another pair is: ;; :atom-id integer ;; For :value errors, another pair is: ;; :value integer ) ;; setf'able ;; If defined, called after every protocol request is generated, ;; even those inside explicit with-display's, but never called from ;; inside the after-function itself. The function is called inside ;; the effective with-display for the associated request. Default ;; value is nil. Can be set, for example, to #'display-force-output ;; or #'display-finish-output. (defvar *inside-display-after-function* nil) (defun display-invoke-after-function (display) ; Called after every protocal request is generated (declare (type display display)) (when (and (display-after-function display) (not *inside-display-after-function*)) (let ((*inside-display-after-function* t)) ;; Ensure no recursive calls (funcall (display-after-function display) display)))) (defun display-finish-output (display) ;; Forces output, then causes a round-trip to ensure that all possible ;; errors and events have been received. (declare (type display display)) (with-buffer-request-and-reply (display +x-getinputfocus+ 16 :sizes (8 32)) () ) ;; Report asynchronous errors here if the user wants us to. (report-asynchronous-errors display :after-finish-output)) (defparameter *request-names* '#("error" "CreateWindow" "ChangeWindowAttributes" "GetWindowAttributes" "DestroyWindow" "DestroySubwindows" "ChangeSaveSet" "ReparentWindow" "MapWindow" "MapSubwindows" "UnmapWindow" "UnmapSubwindows" "ConfigureWindow" "CirculateWindow" "GetGeometry" "QueryTree" "InternAtom" "GetAtomName" "ChangeProperty" "DeleteProperty" "GetProperty" "ListProperties" "SetSelectionOwner" "GetSelectionOwner" "ConvertSelection" "SendEvent" "GrabPointer" "UngrabPointer" "GrabButton" "UngrabButton" "ChangeActivePointerGrab" "GrabKeyboard" "UngrabKeyboard" "GrabKey" "UngrabKey" "AllowEvents" "GrabServer" "UngrabServer" "QueryPointer" "GetMotionEvents" "TranslateCoords" "WarpPointer" "SetInputFocus" "GetInputFocus" "QueryKeymap" "OpenFont" "CloseFont" "QueryFont" "QueryTextExtents" "ListFonts" "ListFontsWithInfo" "SetFontPath" "GetFontPath" "CreatePixmap" "FreePixmap" "CreateGC" "ChangeGC" "CopyGC" "SetDashes" "SetClipRectangles" "FreeGC" "ClearToBackground" "CopyArea" "CopyPlane" "PolyPoint" "PolyLine" "PolySegment" "PolyRectangle" "PolyArc" "FillPoly" "PolyFillRectangle" "PolyFillArc" "PutImage" "GetImage" "PolyText8" "PolyText16" "ImageText8" "ImageText16" "CreateColormap" "FreeColormap" "CopyColormapAndFree" "InstallColormap" "UninstallColormap" "ListInstalledColormaps" "AllocColor" "AllocNamedColor" "AllocColorCells" "AllocColorPlanes" "FreeColors" "StoreColors" "StoreNamedColor" "QueryColors" "LookupColor" "CreateCursor" "CreateGlyphCursor" "FreeCursor" "RecolorCursor" "QueryBestSize" "QueryExtension" "ListExtensions" "SetKeyboardMapping" "GetKeyboardMapping" "ChangeKeyboardControl" "GetKeyboardControl" "Bell" "ChangePointerControl" "GetPointerControl" "SetScreenSaver" "GetScreenSaver" "ChangeHosts" "ListHosts" "ChangeAccessControl" "ChangeCloseDownMode" "KillClient" "RotateProperties" "ForceScreenSaver" "SetPointerMapping" "GetPointerMapping" "SetModifierMapping" "GetModifierMapping")) ecl-16.1.2/src/clx/dpms.lisp000066400000000000000000000135451266352375300156010ustar00rootroot00000000000000 ;;;; Original Author: Matthew Kennedy ;;;; ;;;; Documentation strings derived from DPMS.txt distributed with the Xorg X11 ;;;; server implementation. DPMS.txt contains the following copyright: ;;;; ;;;; Copyright (C) Digital Equipment Corporation, 1996 ;;;; ;;;; Permission to use, copy, modify, distribute, and sell this documentation ;;;; for any purpose is hereby granted without fee, provided that the above ;;;; copyright notice and this permission notice appear in all copies. Digital ;;;; Equipment Corporation makes no representations about the suitability for ;;;; any purpose of the information in this document. This documentation is ;;;; provided ``as is'' without express or implied warranty. (defpackage :dpms (:use :common-lisp) (:import-from :xlib "DEFINE-EXTENSION" "DISPLAY" "WITH-BUFFER-REQUEST-AND-REPLY" "WITH-BUFFER-REQUEST" "EXTENSION-OPCODE" "CARD8-GET" "CARD16-GET" "BOOLEAN-GET" "CARD8" "CARD16" "DATA") (:export "DPMS-GET-VERSION" "DPMS-CAPABLE" "DPMS-GET-TIMEOUTS" "DPMS-SET-TIMEOUTS" "DPMS-ENABLE" "DPMS-DISABLE" "DPMS-FORCE-LEVEL" "DPMS-INFO")) (in-package :dpms) (define-extension "DPMS") (defmacro dpms-opcode (display) `(extension-opcode ,display "DPMS")) (defconstant +get-version+ 0) (defconstant +capable+ 1) (defconstant +get-timeouts+ 2) (defconstant +set-timeouts+ 3) (defconstant +enable+ 4) (defconstant +disable+ 5) (defconstant +force-level+ 6) (defconstant +info+ 7) (defun dpms-get-version (display &optional (major-version 1) (minor-version 1)) "Return two values: the major and minor version of the DPMS implementation the server supports. If supplied, the MAJOR-VERSION and MINOR-VERSION indicate what version of the protocol the client wants the server to implement." (declare (type display display)) (with-buffer-request-and-reply (display (dpms-opcode display) nil) ((data +get-version+) (card16 major-version) (card16 minor-version)) (values (card16-get 8) (card16-get 10)))) (defun dpms-capable (display) "True if the currently running server's devices are capable of DPMS operations. The truth value of this request is implementation defined, but is generally based on the capabilities of the graphic card and monitor combination. Also, the return value in the case of heterogeneous multi-head servers is implementation defined." (declare (type display display)) (with-buffer-request-and-reply (display (dpms-opcode display) nil) ((data +capable+)) (boolean-get 8))) (defun dpms-get-timeouts (display) "Return three values: the current values of the DPMS timeout values. The timeout values are (in order returned): standby, suspend and off. All values are in units of seconds. A value of zero for any timeout value indicates that the mode is disabled." (declare (type display display)) (with-buffer-request-and-reply (display (dpms-opcode display) nil) ((data +get-timeouts+)) (values (card16-get 8) (card16-get 10) (card16-get 12)))) (defun dpms-set-timeouts (display standby suspend off) "Set the values of the DPMS timeouts. All values are in units of seconds. A value of zero for any timeout value disables that mode." (declare (type display display)) (with-buffer-request (display (dpms-opcode display)) (data +set-timeouts+) (card16 standby) (card16 suspend) (card16 off) (card16 0)) ;unused (values)) (defun dpms-enable (display) "Enable the DPMS characteristics of the server using the server's currently stored timeouts. If DPMS is already enabled, no change is affected." (declare (type display display)) (with-buffer-request (display (dpms-opcode display)) (data +enable+)) (values)) (defun dpms-disable (display) "Disable the DPMS characteristics of the server. It does not affect the core or extension screen savers. If DPMS is already disabled, no change is effected. This request is provided so that DPMS may be disabled without damaging the server's stored timeout values." (declare (type display display)) (with-buffer-request (display (dpms-opcode display)) ((data +disable+))) (values)) (defun dpms-force-level (display power-level) "Forces a specific DPMS level on the server. Valid keyword values for POWER-LEVEL are: DPMS-MODE-ON, DPMS-MODE-STANDBY, DPMS-MODE-SUSPEND and DPMS-MODE-OFF." (declare (type display display)) (with-buffer-request (display (dpms-opcode display)) (data +force-level+) (card16 (ecase power-level (:dpms-mode-on 0) (:dpms-mode-standby 1) (:dpms-mode-suspend 2) (:dpms-mode-off 3))) (card16 0)) ;unused (values)) (defun dpms-info (display) "Returns two valus: the DPMS power-level and state value for the display. State is one of the keywords DPMS-ENABLED or DPMS-DISABLED. If state is DPMS-ENABLED, then power level is returned as one of the keywords DPMS-MODE-ON, DPMS-MODE-STANDBY, DPMS-MODE-SUSPEND or DPMS-MODE-OFF. If state is DPMS-DISABLED, then power-level is undefined and returned as NIL." (declare (type display display)) (with-buffer-request-and-reply (display (dpms-opcode display) nil) ((data +info+)) (let ((state (if (boolean-get 10) :dpms-enabled :dpms-disabled))) (values (unless (eq state :dpms-disabled) (ecase (card16-get 8) (0 :dpms-mode-on) (1 :dpms-mode-standby) (2 :dpms-mode-suspend) (3 :dpms-mode-off))) state)))) ;;; Local Variables: ;;; indent-tabs-mode: nil ;;; End: ecl-16.1.2/src/clx/exclMakefile000066400000000000000000000121441266352375300162530ustar00rootroot00000000000000# # Makefile for CLX # (X11 R4.4 release, Franz Allegro Common Lisp version) # # ************************************************************************* # * Change the next line to point to where you have Common Lisp installed * # * (make sure the Lisp doesn't already have CLX loaded in) * # ************************************************************************* CL = /usr/local/bin/cl RM = /bin/rm SHELL = /bin/sh ECHO = /bin/echo TAGS = /usr/local/lib/emacs/etc/etags # Name of dumped lisp CLX = CLX CLOPTS = -qq # Use this one for Suns CFLAGS = -O -DUNIXCONN # Use this one for Silicon Graphics & Mips Inc MIPS based machines # CFLAGS = -O -G 0 -I/usr/include/bsd # Use this one for DEC MIPS based machines # CFLAGS = -O -G 0 -DUNIXCONN # Use this one for HP machines # CFLAGS = -O -DSYSV -DUNIXCONN # Lisp optimization for compiling SPEED = 3 SAFETY = 0 C_SRC = excldep.c socket.c C_OBJS = excldep.o socket.o L_OBJS = defsystem.fasl package.fasl excldep.fasl depdefs.fasl clx.fasl \ dependent.fasl exclcmac.fasl macros.fasl bufmac.fasl buffer.fasl \ display.fasl gcontext.fasl requests.fasl input.fasl fonts.fasl \ graphics.fasl text.fasl attributes.fasl translate.fasl keysyms.fasl \ manager.fasl image.fasl resource.fasl L_NOMACROS_OBJS = package.fasl excldep.fasl depdefs.fasl clx.fasl \ dependent.fasl buffer.fasl display.fasl gcontext.fasl \ requests.fasl input.fasl fonts.fasl graphics.fasl text.fasl \ attributes.fasl translate.fasl keysyms.fasl manager.fasl image.fasl \ resource.fasl L_SRC = defsystem.cl package.cl excldep.cl depdefs.cl clx.cl \ dependent.cl exclcmac.cl macros.cl bufmac.cl buffer.cl \ display.cl gcontext.cl requests.cl input.cl fonts.cl \ graphics.cl text.cl attributes.cl translate.cl keysyms.cl \ manager.cl image.cl resource.cl # default and aliases all: no-clos # all: partial-clos compile-CLX-for-CLUE: compile-partial-clos-CLX clue: partial-clos # # Three build rules are provided: no-clos, partial-clos, and full-clos. # The first is no-clos, which results in a CLX whose datastructures are # all defstructs. partial-clos results in xlib:window, xlib:pixmap, and # xlib:drawable being CLOS instances, all others defstructs. full-clos # makes all CLX complex datatypes into CLOS instances. # # (note that the :clos feature implies native CLOS *not* PCL). # no-clos: $(C_OBJS) compile-no-clos-CLX cat # # This rule is used to compile CLX to be used with XCW version 2, or CLUE. # partial-clos: $(C_OBJS) compile-partial-clos-CLX cat full-clos: $(C_OBJS) compile-full-clos-CLX cat c: $(C_OBJS) compile-no-clos-CLX: $(C_OBJS) $(ECHO) " \ (set-case-mode :case-sensitive-lower) \ (proclaim '(optimize (speed $(SPEED)) (safety $(SAFETY)))) \ #+(version>= 4 0) (pushnew :clx-ansi-common-lisp *features*) \ (load \"defsystem\") \ #+allegro (compile-system :clx) \ #-allegro (compile-clx) \ #+allegro (compile-system :clx-debug)" \ | $(CL) $(CLOPTS) -batch compile-partial-clos-CLX: $(C_OBJS) $(ECHO) " \ #+clos (set-case-mode :case-sensitive-lower) \ #-clos (setq excl::*print-nickname* t) \ (proclaim '(optimize (speed $(SPEED)) (safety $(SAFETY)))) \ (unless (or (find-package 'clos) (find-package 'pcl)) \ (let ((spread (sys:gsgc-parameter :generation-spread))) \ (setf (sys:gsgc-parameter :generation-spread) 1) \ (require :pcl) \ (provide :pcl) \ (gc) (gc) \ (setf (sys:gsgc-parameter :generation-spread) spread))) \ #+(version>= 4 0) (pushnew :clx-ansi-common-lisp *features*) \ (load \"defsystem\") \ (load \"package\") \ (setq xlib::*def-clx-class-use-defclass* '(xlib:window xlib:pixmap xlib:drawable)) \ #+allegro (compile-system :clx) \ #-allegro (compile-clx \"\" \"\" :for-clue t) \ #+allegro (compile-system :clx-debug)" \ | $(CL) $(CLOPTS) -batch compile-full-clos-CLX: $(C_OBJS) $(ECHO) " \ #+clos (set-case-mode :case-sensitive-lower) \ #-clos (setq excl::*print-nickname* t) \ (proclaim '(optimize (speed $(SPEED)) (safety $(SAFETY)))) \ (unless (or (find-package 'clos) (find-package 'pcl)) \ (let ((spread (sys:gsgc-parameter :generation-spread))) \ (setf (sys:gsgc-parameter :generation-spread) 1) \ (require :pcl) \ (provide :pcl) \ (gc) (gc) \ (setf (sys:gsgc-parameter :generation-spread) spread))) \ #+(version>= 4 0) (pushnew :clx-ansi-common-lisp *features*) \ (load \"defsystem\") \ (load \"package\") \ (setq xlib::*def-clx-class-use-defclass* t) \ #+allegro (compile-system :clx) \ #-allegro (compile-clx \"\" \"\" :for-clue t) \ #+allegro (compile-system :clx-debug)" \ | $(CL) $(CLOPTS) -batch cat: -cat $(L_NOMACROS_OBJS) > CLX.fasl load-CLX: $(ECHO) " \ (let ((spread (sys:gsgc-parameter :generation-spread))) \ (setf (sys:gsgc-parameter :generation-spread) 1) \ (load \"defsystem\") \ #+allegro (load-system :clx) \ #-allegro (load-clx) \ (gc :tenure) \ (setf (sys:gsgc-parameter :generation-spread) spread)) \ (gc t)" \ '(dumplisp :name "$(CLX)" #+allegro :checkpoint #+allegro nil)' \ "(exit)" | $(CL) $(CLOPTS) clean: $(RM) -f *.fasl debug/*.fasl $(CLX) core $(C_OBJS) make.out install: mv CLX.fasl $(DEST)/clx.fasl mv *.o $(DEST) tags: $(TAGS) $(L_SRC) $(C_SRC) ecl-16.1.2/src/clx/exclREADME000066400000000000000000000040771266352375300155010ustar00rootroot00000000000000 This file contains instructions on how to make CLX work with Franz Common Lisp. CLX should work on any machine that supports Allegro Common Lisp version 3.0.1 or greater. It also works under ExCL version 2.0.10. However it has been tested extensively with only Allegro CL versions 3.0, 3.1, and 4.0. There are three steps to compile and install CLX. The first is simply moving files around. In this directory, execute (assuming you using csh): % foreach i (*.l */*.l) ? mv $i $i:r.cl ? end % mv exclMakefile Makefile The second is compiling the source files into fasl files. The fasl files will be combined into one big fasl file, CLX.fasl. This file is then installed in your Common Lisp library directory in the next step. You may need to edit the Makefile to select the proper CFLAGS for your machine -- look in Makefile for examples. Then just: % make Now you must move the CLX.fasl file into the standard CL library. This is normally "/usr/local/lib/cl/code", but you can find out for sure by typing: (directory-namestring excl::*library-code-pathname*) to a running Lisp. If it prints something other than "/usr/local/lib/cl/code" substitute what it prints in the below instructions. % mv CLX.fasl /usr/local/lib/cl/code/clx.fasl % mv *.o /usr/local/lib/cl/code Now you can just start up Lisp and type: (load "clx") to load in CLX. You may want to dump a lisp at this point since CLX is a large package and can take some time to load into Lisp. You probably also want to set the :generation-spread to 1 while loading CLX. Please see your Allegro CL User Guide for more information on :generation-spread. Sophisticated users may wish to peruse the Makefile and defsystem.cl and note how things are set up. For example we hardwire the compiler interrupt check switch on, so that CL can still be interrupted while it is reading from the X11 socket. Please see chapter 7 of the CL User's guide for more information on compiler switches and their effects. Please report Franz specific CLX bugs to: ucbvax!franz!bugs or bugs@Franz.COM ecl-16.1.2/src/clx/exclcmac.lisp000066400000000000000000000205231266352375300164070ustar00rootroot00000000000000;;; -*- Mode: common-lisp; Package: xlib; Base: 10; Lowercase: Yes -*- ;;; ;;; CLX -- exclcmac.cl ;;; This file provides for inline expansion of some functions. ;;; ;;; Copyright (c) 1989 Franz Inc, Berkeley, Ca. ;;; ;;; Permission is granted to any individual or institution to use, copy, ;;; modify, and distribute this software, provided that this complete ;;; copyright and permission notice is maintained, intact, in all copies and ;;; supporting documentation. ;;; ;;; Franz Incorporated provides this software "as is" without ;;; express or implied warranty. ;;; (in-package :xlib) ;; ;; Type predicates ;; (excl:defcmacro card8p (x) (let ((xx (gensym))) `(let ((,xx ,x)) (declare (optimize (speed 3) (safety 0)) (fixnum ,xx)) (and (excl:fixnump ,xx) (> #.(expt 2 8) ,xx) (>= ,xx 0))))) (excl:defcmacro card16p (x) (let ((xx (gensym))) `(let ((,xx ,x)) (declare (optimize (speed 3) (safety 0)) (fixnum ,xx)) (and (excl:fixnump ,xx) (> #.(expt 2 16) ,xx) (>= ,xx 0))))) (excl:defcmacro int8p (x) (let ((xx (gensym))) `(let ((,xx ,x)) (declare (optimize (speed 3) (safety 0)) (fixnum ,xx)) (and (excl:fixnump ,xx) (> #.(expt 2 7) ,xx) (>= ,xx #.(expt -2 7)))))) (excl:defcmacro int16p (x) (let ((xx (gensym))) `(let ((,xx ,x)) (declare (optimize (speed 3) (safety 0)) (fixnum ,xx)) (and (excl:fixnump ,xx) (> #.(expt 2 15) ,xx) (>= ,xx #.(expt -2 15)))))) ;; Card29p, card32p, int32p are too large to expand inline ;; ;; Type transformers ;; (excl:defcmacro card8->int8 (x) (let ((xx (gensym))) `(let ((,xx ,x)) ,(declare-bufmac) (declare (type card8 ,xx)) (the int8 (if (logbitp 7 ,xx) (the int8 (- ,xx #x100)) ,xx))))) (excl:defcmacro int8->card8 (x) `(locally ,(declare-bufmac) (the card8 (ldb (byte 8 0) (the int8 ,x))))) (excl:defcmacro card16->int16 (x) (let ((xx (gensym))) `(let ((,xx ,x)) ,(declare-bufmac) (declare (type card16 ,xx)) (the int16 (if (logbitp 15 ,xx) (the int16 (- ,xx #x10000)) ,xx))))) (excl:defcmacro int16->card16 (x) `(locally ,(declare-bufmac) (the card16 (ldb (byte 16 0) (the int16 ,x))))) (excl:defcmacro card32->int32 (x) (let ((xx (gensym))) `(let ((,xx ,x)) ,(declare-bufmac) (declare (type card32 ,xx)) (the int32 (if (logbitp 31 ,xx) (the int32 (- ,xx #x100000000)) ,xx))))) (excl:defcmacro int32->card32 (x) `(locally ,(declare-bufmac) (the card32 (ldb (byte 32 0) (the int32 ,x))))) (excl:defcmacro char->card8 (char) `(locally ,(declare-bufmac) (the card8 (char-code (the string-char ,char))))) (excl:defcmacro card8->char (card8) `(locally ,(declare-bufmac) (the string-char (code-char (the card8 ,card8))))) ;; ;; Array accessors and setters ;; (excl:defcmacro aref-card8 (a i) `(locally ,(declare-bufmac) (the card8 (sys:memref (the buffer-bytes ,a) #.(comp::mdparam 'comp::md-svector-data0-adj) (the array-index ,i) :unsigned-byte)))) (excl:defcmacro aset-card8 (v a i) `(locally ,(declare-bufmac) (setf (sys:memref (the buffer-bytes ,a) #.(comp::mdparam 'comp::md-svector-data0-adj) (the array-index ,i) :unsigned-byte) (the card8 ,v)))) (excl:defcmacro aref-int8 (a i) `(locally ,(declare-bufmac) (the int8 (sys:memref (the buffer-bytes ,a) #.(comp::mdparam 'comp::md-svector-data0-adj) (the array-index ,i) :signed-byte)))) (excl:defcmacro aset-int8 (v a i) `(locally ,(declare-bufmac) (setf (sys:memref (the buffer-bytes ,a) #.(comp::mdparam 'comp::md-svector-data0-adj) (the array-index ,i) :signed-byte) (the int8 ,v)))) (excl:defcmacro aref-card16 (a i) `(locally ,(declare-bufmac) (the card16 (sys:memref (the buffer-bytes ,a) #.(comp::mdparam 'comp::md-svector-data0-adj) (the array-index ,i) :unsigned-word)))) (excl:defcmacro aset-card16 (v a i) `(locally ,(declare-bufmac) (setf (sys:memref (the buffer-bytes ,a) #.(comp::mdparam 'comp::md-svector-data0-adj) (the array-index ,i) :unsigned-word) (the card16 ,v)))) (excl:defcmacro aref-int16 (a i) `(locally ,(declare-bufmac) (the int16 (sys:memref (the buffer-bytes ,a) #.(comp::mdparam 'comp::md-svector-data0-adj) (the array-index ,i) :signed-word)))) (excl:defcmacro aset-int16 (v a i) `(locally ,(declare-bufmac) (setf (sys:memref (the buffer-bytes ,a) #.(comp::mdparam 'comp::md-svector-data0-adj) (the array-index ,i) :signed-word) (the int16 ,v)))) (excl:defcmacro aref-card32 (a i) `(locally ,(declare-bufmac) (the card32 (sys:memref (the buffer-bytes ,a) #.(comp::mdparam 'comp::md-svector-data0-adj) (the array-index ,i) :unsigned-long)))) (excl:defcmacro aset-card32 (v a i) `(locally ,(declare-bufmac) (setf (sys:memref (the buffer-bytes ,a) #.(comp::mdparam 'comp::md-svector-data0-adj) (the array-index ,i) :unsigned-long) (the card32 ,v)))) (excl:defcmacro aref-int32 (a i) `(locally ,(declare-bufmac) (the int32 (sys:memref (the buffer-bytes ,a) #.(comp::mdparam 'comp::md-svector-data0-adj) (the array-index ,i) :signed-long)))) (excl:defcmacro aset-int32 (v a i) `(locally ,(declare-bufmac) (setf (sys:memref (the buffer-bytes ,a) #.(comp::mdparam 'comp::md-svector-data0-adj) (the array-index ,i) :signed-long) (the int32 ,v)))) (excl:defcmacro aref-card29 (a i) ;; Don't need to mask bits here since X protocol guarantees top bits zero `(locally ,(declare-bufmac) (the card29 (sys:memref (the buffer-bytes ,a) #.(comp::mdparam 'comp::md-svector-data0-adj) (the array-index ,i) :unsigned-long)))) (excl:defcmacro aset-card29 (v a i) ;; I also assume here Lisp is passing a number that fits in 29 bits. `(locally ,(declare-bufmac) (setf (sys:memref (the buffer-bytes ,a) #.(comp::mdparam 'comp::md-svector-data0-adj) (the array-index ,i) :unsigned-long) (the card29 ,v)))) ;; ;; Font accessors ;; (excl:defcmacro font-id (font) ;; Get font-id, opening font if needed (let ((f (gensym))) `(let ((,f ,font)) (or (font-id-internal ,f) (open-font-internal ,f))))) (excl:defcmacro font-font-info (font) (let ((f (gensym))) `(let ((,f ,font)) (or (font-font-info-internal ,f) (query-font ,f))))) (excl:defcmacro font-char-infos (font) (let ((f (gensym))) `(let ((,f ,font)) (or (font-char-infos-internal ,f) (progn (query-font ,f) (font-char-infos-internal ,f)))))) ;; ;; Miscellaneous ;; (excl:defcmacro current-process () `(the (or mp::process null) (and mp::*scheduler-stack-group* mp::*current-process*))) (excl:defcmacro process-wakeup (process) (let ((proc (gensym))) `(let ((.pw-curproc. mp::*current-process*) (,proc ,process)) (when (and .pw-curproc. ,proc) (if (> (mp::process-priority ,proc) (mp::process-priority .pw-curproc.)) (mp::process-allow-schedule ,proc)))))) (excl:defcmacro buffer-new-request-number (buffer) (let ((buf (gensym))) `(let ((,buf ,buffer)) (declare (type buffer ,buf)) (setf (buffer-request-number ,buf) (ldb (byte 16 0) (1+ (buffer-request-number ,buf))))))) ecl-16.1.2/src/clx/excldefsys.lisp000066400000000000000000000157261266352375300170120ustar00rootroot00000000000000;;; -*- Mode: common-lisp; Package: xlib; Base: 10; Lowercase: Yes -*- ;;; ;;; Copyright (c) 1988, 1989 Franz Inc, Berkeley, Ca. ;;; ;;; Permission is granted to any individual or institution to use, copy, ;;; modify, and distribute this software, provided that this complete ;;; copyright and permission notice is maintained, intact, in all copies and ;;; supporting documentation. ;;; ;;; Franz Incorporated provides this software "as is" without express or ;;; implied warranty. ;;; (in-package :xlib :use '(:foreign-functions :lisp :excl)) #+allegro (require :defsystem "defsys") (eval-when (load) (require :clxexcldep "excldep")) ;; ;; The following is a suggestion. If you comment out this form be ;; prepared for possible deadlock, since no interrupts will be recognized ;; while reading from the X socket if the scheduler is not running. ;; (setq compiler::generate-interrupt-checks-switch (compile nil '(lambda (safety size speed) (declare (ignore size)) (or (< speed 3) (> safety 0))))) #+allegro (excl:defsystem :clx () |depdefs| (|clx| :load-before-compile (|depdefs|) :recompile-on (|depdefs|)) (|dependent| :load-before-compile (|depdefs| |clx|) :recompile-on (|clx|)) (|exclcmac| :load-before-compile (|depdefs| |clx| |dependent|) :recompile-on (|dependent|)) (|macros| :load-before-compile (|depdefs| |clx| |dependent| |exclcmac|) :recompile-on (|exclcmac|)) (|bufmac| :load-before-compile (|depdefs| |clx| |dependent| |exclcmac| |macros|) :recompile-on (|macros|)) (|buffer| :load-before-compile (|depdefs| |clx| |dependent| |exclcmac| |macros| |bufmac|) :recompile-on (|bufmac|)) (|display| :load-before-compile (|depdefs| |clx| |dependent| |exclcmac| |macros| |bufmac| |buffer|) :recompile-on (|buffer|)) (|gcontext| :load-before-compile (|depdefs| |clx| |dependent| |exclcmac| |macros| |bufmac| |buffer| |display|) :recompile-on (|display|)) (|input| :load-before-compile (|depdefs| |clx| |dependent| |exclcmac| |macros| |bufmac| |buffer| |display| ) :recompile-on (|display|)) (|requests| :load-before-compile (|depdefs| |clx| |dependent| |exclcmac| |macros| |bufmac| |buffer| |display| |input|) :recompile-on (|display|)) (|fonts| :load-before-compile (|depdefs| |clx| |dependent| |exclcmac| |macros| |bufmac| |buffer| |display| ) :recompile-on (|display|)) (|graphics| :load-before-compile (|depdefs| |clx| |dependent| |exclcmac| |macros| |bufmac| |buffer| |display| |fonts|) :recompile-on (|fonts|)) (|text| :load-before-compile (|depdefs| |clx| |dependent| |exclcmac| |macros| |bufmac| |buffer| |display| |gcontext| |fonts|) :recompile-on (|gcontext| |fonts|) :load-after (|translate|)) ;; The above line gets around a compiler macro expansion bug. (|attributes| :load-before-compile (|depdefs| |clx| |dependent| |exclcmac| |macros| |bufmac| |buffer| |display|) :recompile-on (|display|)) (|translate| :load-before-compile (|depdefs| |clx| |dependent| |exclcmac| |macros| |bufmac| |buffer| |display| |text|) :recompile-on (|display|)) (|keysyms| :load-before-compile (|depdefs| |clx| |dependent| |exclcmac| |macros| |bufmac| |buffer| |display| |translate|) :recompile-on (|translate|)) (|manager| :load-before-compile (|depdefs| |clx| |dependent| |exclcmac| |macros| |bufmac| |buffer| |display|) :recompile-on (|display|)) (|image| :load-before-compile (|depdefs| |clx| |dependent| |exclcmac| |macros| |bufmac| |buffer| |display| ) :recompile-on (|display|)) ;; Don't know if l-b-c list is correct. XX (|resource| :load-before-compile (|depdefs| |clx| |dependent| |exclcmac| |macros| |bufmac| |buffer| |display|) :recompile-on (|display|)) ) #+allegro (excl:defsystem :clx-debug (:default-pathname "debug/" :needed-systems (:clx) :load-before-compile (:clx)) |describe| |keytrans| |trace| |util|) (defun compile-clx (&optional pathname-defaults) (let ((*default-pathname-defaults* (or pathname-defaults *default-pathname-defaults*))) (declare (special *default-pathname-defaults*)) (compile-file "depdefs") (load "depdefs") (compile-file "clx") (load "clx") (compile-file "dependent") (load "dependent") (compile-file "macros") (load "macros") (compile-file "bufmac") (load "bufmac") (compile-file "buffer") (load "buffer") (compile-file "display") (load "display") (compile-file "gcontext") (load "gcontext") (compile-file "input") (load "input") (compile-file "requests") (load "requests") (compile-file "fonts") (load "fonts") (compile-file "graphics") (load "graphics") (compile-file "text") (load "text") (compile-file "attributes") (load "attributes") (load "translate") (compile-file "translate") ; work-around bug in 2.0 and 2.2 (load "translate") (compile-file "keysyms") (load "keysyms") (compile-file "manager") (load "manager") (compile-file "image") (load "image") (compile-file "resource") (load "resource") )) (defun load-clx (&optional pathname-defaults) (let ((*default-pathname-defaults* (or pathname-defaults *default-pathname-defaults*))) (declare (special *default-pathname-defaults*)) (load "depdefs") (load "clx") (load "dependent") (load "macros") (load "bufmac") (load "buffer") (load "display") (load "gcontext") (load "input") (load "requests") (load "fonts") (load "graphics") (load "text") (load "attributes") (load "translate") (load "keysyms") (load "manager") (load "image") (load "resource") )) ecl-16.1.2/src/clx/excldep.c000066400000000000000000000037531266352375300155350ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* * Allegro CL dependent C helper routines for CLX */ /* * This code requires select and interval timers. * This means you probably need BSD, or a version * of Unix with select and interval timers added. */ #include #include #include #include #define ERROR -1 #define INTERRUPT -2 #define TIMEOUT 0 #define SUCCESS 1 #ifdef FD_SETSIZE #define NUMBER_OF_FDS FD_SETSIZE /* Highest possible file descriptor */ #else #define NUMBER_OF_FDS 32 #endif /* Length of array needed to hold all file descriptor bits */ #define CHECKLEN ((NUMBER_OF_FDS+8*sizeof(int)-1) / (8 * sizeof(int))) extern int errno; /* * This function waits for input to become available on 'fd'. If timeout is * 0, wait forever. Otherwise wait 'timeout' seconds. If input becomes * available before the timer expires, return SUCCESS. If the timer expires * return TIMEOUT. If an error occurs, return ERROR. If an interrupt occurs * while waiting, return INTERRUPT. */ int fd_wait_for_input(fd, timeout) register int fd; register int timeout; { struct timeval timer; register int i; int checkfds[CHECKLEN]; if (fd < 0 || fd >= NUMBER_OF_FDS) { fprintf(stderr, "Bad file descriptor argument: %d to fd_wait_for_input\n", fd); fflush(stderr); } for (i = 0; i < CHECKLEN; i++) checkfds[i] = 0; checkfds[fd / (8 * sizeof(int))] |= 1 << (fd % (8 * sizeof(int))); if (timeout) { timer.tv_sec = timeout; timer.tv_usec = 0; i = select(32, checkfds, (int *)0, (int *)0, &timer); } else i = select(32, checkfds, (int *)0, (int *)0, (struct timeval *)0); if (i < 0) /* error condition */ if (errno == EINTR) return (INTERRUPT); else return (ERROR); else if (i == 0) return (TIMEOUT); else return (SUCCESS); } ecl-16.1.2/src/clx/excldep.lisp000066400000000000000000000357111266352375300162610ustar00rootroot00000000000000;;; -*- Mode: common-lisp; Package: xlib; Base: 10; Lowercase: Yes -*- ;;; ;;; CLX -- excldep.cl ;;; ;;; Copyright (c) 1987, 1988, 1989 Franz Inc, Berkeley, Ca. ;;; ;;; Permission is granted to any individual or institution to use, copy, ;;; modify, and distribute this software, provided that this complete ;;; copyright and permission notice is maintained, intact, in all copies and ;;; supporting documentation. ;;; ;;; Franz Incorporated provides this software "as is" without ;;; express or implied warranty. ;;; (in-package :xlib) (eval-when (compile load eval) (require :foreign) (require :process) ; Needed even if scheduler is not ; running. (Must be able to make ; a process-lock.) ) (eval-when (load) (provide :clx)) #-(or little-endian big-endian) (eval-when (eval compile load) (let ((x '#(1))) (if (not (eq 0 (sys::memref x #.(sys::mdparam 'comp::md-lvector-data0-norm) 0 :unsigned-byte))) (pushnew :little-endian *features*) (pushnew :big-endian *features*)))) (defmacro correct-case (string) ;; This macro converts the given string to the ;; current preferred case, or leaves it alone in a case-sensitive mode. (let ((str (gensym))) `(let ((,str ,string)) (case excl::*current-case-mode* (:case-insensitive-lower (string-downcase ,str)) (:case-insensitive-upper (string-upcase ,str)) ((:case-sensitive-lower :case-sensitive-upper) ,str))))) (defconstant type-pred-alist '(#-(version>= 4 1 devel 16) (card8 . card8p) #-(version>= 4 1 devel 16) (card16 . card16p) #-(version>= 4 1 devel 16) (card29 . card29p) #-(version>= 4 1 devel 16) (card32 . card32p) #-(version>= 4 1 devel 16) (int8 . int8p) #-(version>= 4 1 devel 16) (int16 . int16p) #-(version>= 4 1 devel 16) (int32 . int32p) #-(version>= 4 1 devel 16) (mask16 . card16p) #-(version>= 4 1 devel 16) (mask32 . card32p) #-(version>= 4 1 devel 16) (pixel . card32p) #-(version>= 4 1 devel 16) (resource-id . card29p) #-(version>= 4 1 devel 16) (keysym . card32p) (angle . anglep) (color . color-p) (bitmap-format . bitmap-format-p) (pixmap-format . pixmap-format-p) (display . display-p) (drawable . drawable-p) (window . window-p) (pixmap . pixmap-p) (visual-info . visual-info-p) (colormap . colormap-p) (cursor . cursor-p) (gcontext . gcontext-p) (screen . screen-p) (font . font-p) (image-x . image-x-p) (image-xy . image-xy-p) (image-z . image-z-p) (wm-hints . wm-hints-p) (wm-size-hints . wm-size-hints-p) )) ;; This (if (and ...) t nil) stuff has a purpose -- it lets the old ;; sun4 compiler opencode the `and'. #-(version>= 4 1 devel 16) (defun card8p (x) (declare (optimize (speed 3) (safety 0)) (fixnum x)) (if (and (excl:fixnump x) (> #.(expt 2 8) x) (>= x 0)) t nil)) #-(version>= 4 1 devel 16) (defun card16p (x) (declare (optimize (speed 3) (safety 0)) (fixnum x)) (if (and (excl:fixnump x) (> #.(expt 2 16) x) (>= x 0)) t nil)) #-(version>= 4 1 devel 16) (defun card29p (x) (declare (optimize (speed 3) (safety 0))) (if (or (and (excl:fixnump x) (>= (the fixnum x) 0)) (and (excl:bignump x) (> #.(expt 2 29) (the bignum x)) (>= (the bignum x) 0))) t nil)) #-(version>= 4 1 devel 16) (defun card32p (x) (declare (optimize (speed 3) (safety 0))) (if (or (and (excl:fixnump x) (>= (the fixnum x) 0)) (and (excl:bignump x) (> #.(expt 2 32) (the bignum x)) (>= (the bignum x) 0))) t nil)) #-(version>= 4 1 devel 16) (defun int8p (x) (declare (optimize (speed 3) (safety 0)) (fixnum x)) (if (and (excl:fixnump x) (> #.(expt 2 7) x) (>= x #.(expt -2 7))) t nil)) #-(version>= 4 1 devel 16) (defun int16p (x) (declare (optimize (speed 3) (safety 0)) (fixnum x)) (if (and (excl:fixnump x) (> #.(expt 2 15) x) (>= x #.(expt -2 15))) t nil)) #-(version>= 4 1 devel 16) (defun int32p (x) (declare (optimize (speed 3) (safety 0))) (if (or (excl:fixnump x) (and (excl:bignump x) (> #.(expt 2 31) (the bignum x)) (>= (the bignum x) #.(expt -2 31)))) t nil)) ;; This one can be handled better by knowing a little about what we're ;; testing for. Plus this version can handle (single-float pi), which ;; is otherwise larger than pi! (defun anglep (x) (declare (optimize (speed 3) (safety 0))) (if (or (and (excl::fixnump x) (>= (the fixnum x) #.(truncate (* -2 pi))) (<= (the fixnum x) #.(truncate (* 2 pi)))) (and (excl::single-float-p x) (>= (the single-float x) #.(float (* -2 pi) 0.0s0)) (<= (the single-float x) #.(float (* 2 pi) 0.0s0))) (and (excl::double-float-p x) (>= (the double-float x) #.(float (* -2 pi) 0.0d0)) (<= (the double-float x) #.(float (* 2 pi) 0.0d0)))) t nil)) (eval-when (load eval) #+(version>= 4 1 devel 16) (mapcar #'(lambda (elt) (excl:add-typep-transformer (car elt) (cdr elt))) type-pred-alist) #-(version>= 4 1 devel 16) (nconc excl::type-pred-alist type-pred-alist)) ;; Return t if there is a character available for reading or on error, ;; otherwise return nil. #-(version>= 6 0) (progn #-(or (version>= 4 2) mswindows) (defun fd-char-avail-p (fd) (multiple-value-bind (available-p errcode) (comp::.primcall-sargs 'sys::filesys excl::fs-char-avail fd) (excl:if* errcode then t else available-p))) #+(and (version>= 4 2) (not mswindows)) (defun fd-char-avail-p (fd) (excl::filesys-character-available-p fd)) #+mswindows (defun fd-char-avail-p (socket-stream) (listen socket-stream)) ) #+(version>= 6 0) (defun fd-char-avail-p (socket-stream) (excl::read-no-hang-p socket-stream)) (defmacro with-interrupt-checking-on (&body body) `(locally (declare (optimize (safety 1))) ,@body)) ;; Read from the given fd into 'vector', which has element type card8. ;; Start storing at index 'start-index' and read exactly 'length' bytes. ;; Return t if an error or eof occurred, nil otherwise. (defun fd-read-bytes (fd vector start-index length) ;; Read from the given stream fd into 'vector', which has element type card8. ;; Start storing at index 'start-index' and read exactly 'length' bytes. ;; Return t if an error or eof occurred, nil otherwise. (declare (fixnum next-index start-index length)) (with-interrupt-checking-on (let ((end-index (+ start-index length))) (loop (let ((next-index (excl:read-vector vector fd :start start-index :end end-index))) (excl:if* (eq next-index start-index) then ; end of file before was all filled up (return t) elseif (eq next-index end-index) then ; we're all done (return nil) else (setq start-index next-index))))))) ;; special patch for CLX (various process fixes) ;; patch1000.2 (eval-when (compile load eval) (unless (find-package :patch) (make-package :patch :use '(:lisp :excl)))) (in-package :patch) (defvar *patches* nil) #+allegro (eval-when (compile eval load) (when (and (= excl::cl-major-version-number 3) (or (= excl::cl-minor-version-number 0) (and (= excl::cl-minor-version-number 1) excl::cl-generation-number (< excl::cl-generation-number 9)))) (push :clx-r4-process-patches *features*))) #+clx-r4-process-patches (push (cons 1000.2 "special patch for CLX (various process fixes)") *patches*) (in-package :mp) #+clx-r4-process-patches (export 'wait-for-input-available) #+clx-r4-process-patches (defun with-timeout-event (seconds fnc args) (unless *scheduler-stack-group* (start-scheduler)) ;[spr670] (let ((clock-event (make-clock-event))) (when (<= seconds 0) (setq seconds 0)) (multiple-value-bind (secs msecs) (truncate seconds) ;; secs is now a nonegative integer, and msecs is either fixnum zero ;; or else something interesting. (unless (eq 0 msecs) (setq msecs (truncate (* 1000.0 msecs)))) ;; Now msecs is also a nonnegative fixnum. (multiple-value-bind (now mnow) (excl::cl-internal-real-time) (incf secs now) (incf msecs mnow) (when (>= msecs 1000) (decf msecs 1000) (incf secs)) (unless (excl:fixnump secs) (setq secs most-positive-fixnum)) (setf (clock-event-secs clock-event) secs (clock-event-msecs clock-event) msecs (clock-event-function clock-event) fnc (clock-event-args clock-event) args))) clock-event)) #+clx-r4-process-patches (defmacro with-timeout ((seconds &body timeout-body) &body body) `(let* ((clock-event (with-timeout-event ,seconds #'process-interrupt (cons *current-process* '(with-timeout-internal)))) (excl::*without-interrupts* t) ret) (unwind-protect ;; Warning: Branch tensioner better not reorder this code! (setq ret (catch 'with-timeout-internal (add-to-clock-queue clock-event) (let ((excl::*without-interrupts* nil)) (multiple-value-list (progn ,@body))))) (excl:if* (eq ret 'with-timeout-internal) then (let ((excl::*without-interrupts* nil)) (setq ret (multiple-value-list (progn ,@timeout-body)))) else (remove-from-clock-queue clock-event))) (values-list ret))) #+clx-r4-process-patches (defun process-lock (lock &optional (lock-value *current-process*) (whostate "Lock") timeout) (declare (optimize (speed 3))) (unless (process-lock-p lock) (error "First argument to PROCESS-LOCK must be a process-lock: ~s" lock)) (without-interrupts (excl:if* (null (process-lock-locker lock)) then (setf (process-lock-locker lock) lock-value) else (excl:if* timeout then (excl:if* (or (eq 0 timeout) ;for speed (zerop timeout)) then nil else (with-timeout (timeout) (process-lock-1 lock lock-value whostate))) else (process-lock-1 lock lock-value whostate))))) #+clx-r4-process-patches (defun process-lock-1 (lock lock-value whostate) (declare (type process-lock lock) (optimize (speed 3))) (let ((process *current-process*)) (declare (type process process)) (unless process (error "PROCESS-LOCK may not be called on the scheduler's stack group.")) (loop (unless (process-lock-locker lock) (return (setf (process-lock-locker lock) lock-value))) (push process (process-lock-waiting lock)) (let ((saved-whostate (process-whostate process))) (unwind-protect (progn (setf (process-whostate process) whostate) (process-add-arrest-reason process lock)) (setf (process-whostate process) saved-whostate)))))) #+clx-r4-process-patches (defun process-wait (whostate function &rest args) (declare (optimize (speed 3))) ;; Run the wait function once here both for efficiency and as a ;; first line check for errors in the function. (unless (apply function args) (process-wait-1 whostate function args))) #+clx-r4-process-patches (defun process-wait-1 (whostate function args) (declare (optimize (speed 3))) (let ((process *current-process*)) (declare (type process process)) (unless process (error "Process-wait may not be called within the scheduler's stack group.")) (let ((saved-whostate (process-whostate process))) (unwind-protect (without-scheduling-internal (without-interrupts (setf (process-whostate process) whostate (process-wait-function process) function (process-wait-args process) args) (chain-rem-q process) (chain-ins-q process *waiting-processes*)) (process-resume-scheduler nil)) (setf (process-whostate process) saved-whostate (process-wait-function process) nil (process-wait-args process) nil))))) #+clx-r4-process-patches (defun process-wait-with-timeout (whostate seconds function &rest args) ;; Now returns T upon completion, NIL upon timeout. -- 6Jun89 smh ;; [spr1135] [rfe939] Timeout won't throw out of interrupt level code. ;; -- 28Feb90 smh ;; Run the wait function once here both for efficiency and as a ;; first line check for errors in the function. (excl:if* (apply function args) then t else (let ((ret (list nil))) (without-interrupts (let ((clock-event (with-timeout-event seconds #'identity '(nil)))) (add-to-clock-queue clock-event) (process-wait-1 whostate #'(lambda (clock-event function args ret) (or (null (chain-next clock-event)) (and (apply function args) (setf (car ret) 't)))) (list clock-event function args ret)))) (car ret)))) ;; ;; Returns nil on timeout, otherwise t. ;; #+clx-r4-process-patches (defun wait-for-input-available (stream-or-fd &key (wait-function #'listen) (whostate "waiting for input") timeout) (let ((fd (excl:if* (excl:fixnump stream-or-fd) then stream-or-fd elseif (streamp stream-or-fd) then (excl::stream-input-fn stream-or-fd) else (error "wait-for-input-available expects a stream or file descriptor: ~s" stream-or-fd)))) ;; At this point fd could be nil, since stream-input-fn returns nil for ;; streams that are output only, or for certain special purpose streams. (if fd (unwind-protect (progn (mp::mpwatchfor fd) (excl:if* timeout then (mp::process-wait-with-timeout whostate timeout wait-function stream-or-fd) else (mp::process-wait whostate wait-function stream-or-fd) t)) (mp::mpunwatchfor fd)) (excl:if* timeout then (mp::process-wait-with-timeout whostate timeout wait-function stream-or-fd) else (mp::process-wait whostate wait-function stream-or-fd) t)))) ecl-16.1.2/src/clx/fonts.lisp000066400000000000000000000372131266352375300157650ustar00rootroot00000000000000;;; -*- Mode: LISP; Syntax: Common-lisp; Package: XLIB; Base: 10; Lowercase: Yes -*- ;;; ;;; TEXAS INSTRUMENTS INCORPORATED ;;; P.O. BOX 2909 ;;; AUSTIN, TEXAS 78769 ;;; ;;; Copyright (C) 1987 Texas Instruments Incorporated. ;;; ;;; Permission is granted to any individual or institution to use, copy, modify, ;;; and distribute this software, provided that this complete copyright and ;;; permission notice is maintained, intact, in all copies and supporting ;;; documentation. ;;; ;;; Texas Instruments Incorporated provides this software "as is" without ;;; express or implied warranty. ;;; (in-package :xlib) ;; The char-info stuff is here instead of CLX because of uses of int16->card16. ; To allow efficient storage representations, the type char-info is not ; required to be a structure. ;; For each of left-bearing, right-bearing, width, ascent, descent, attributes: ;(defun char- (font index) ; ;; Note: I have tentatively chosen to return nil for an out-of-bounds index ; ;; (or an in-bounds index on a pseudo font), although returning zero or ; ;; signalling might be better. ; (declare (type font font) ; (type integer index) ; (clx-values (or null integer)))) ;(defun max-char- (font) ; ;; Note: I have tentatively chosen separate accessors over allowing :min and ; ;; :max as an index above. ; (declare (type font font) ; (clx-values integer))) ;(defun min-char- (font) ; (declare (type font font) ; (clx-values integer))) ;; Note: char16- accessors could be defined to accept two-byte indexes. (deftype char-info-vec () '(simple-array int16 (*))) (macrolet ((def-char-info-accessors (useless-name &body fields) `(within-definition (,useless-name def-char-info-accessors) ,@(do ((field fields (cdr field)) (n 0 (1+ n)) (name) (type) (result nil)) ((endp field) result) (setq name (xintern 'char- (caar field))) (setq type (cadar field)) (flet ((from (form) (if (eq type 'int16) form `(,(xintern 'int16-> type) ,form)))) (push `(defun ,name (font index) (declare (type font font) (type array-index index)) (declare (clx-values (or null ,type))) (when (and (font-name font) (index>= (font-max-char font) index (font-min-char font))) (the ,type ,(from `(the int16 (let ((char-info-vector (font-char-infos font))) (declare (type char-info-vec char-info-vector)) (if (index-zerop (length char-info-vector)) ;; Fixed width font (aref (the char-info-vec (font-max-bounds font)) ,n) ;; Variable width font (aref char-info-vector (index+ (index* 6 (index- index (font-min-char font))) ,n))))))))) result) (setq name (xintern 'min-char- (caar field))) (push `(defun ,name (font) (declare (type font font)) (declare (clx-values (or null ,type))) (when (font-name font) (the ,type ,(from `(the int16 (aref (the char-info-vec (font-min-bounds font)) ,n)))))) result) (setq name (xintern 'max-char- (caar field))) (push `(defun ,name (font) (declare (type font font)) (declare (clx-values (or null ,type))) (when (font-name font) (the ,type ,(from `(the int16 (aref (the char-info-vec (font-max-bounds font)) ,n)))))) result))) (defun make-char-info (&key ,@(mapcar #'(lambda (field) `(,(car field) (required-arg ,(car field)))) fields)) (declare ,@(mapcar #'(lambda (field) `(type ,@(reverse field))) fields)) (let ((result (make-array ,(length fields) :element-type 'int16))) (declare (type char-info-vec result)) ,@(do* ((field fields (cdr field)) (var (caar field) (caar field)) (type (cadar field) (cadar field)) (n 0 (1+ n)) (result nil)) ((endp field) (nreverse result)) (push `(setf (aref result ,n) ,(if (eq type 'int16) var `(,(xintern type '->int16) ,var))) result)) result))))) (def-char-info-accessors ignore (left-bearing int16) (right-bearing int16) (width int16) (ascent int16) (descent int16) (attributes card16))) (defun open-font (display name) ;; Font objects may be cached and reference counted locally within the display ;; object. This function might not execute a with-display if the font is cached. ;; The protocol QueryFont request happens on-demand under the covers. (declare (type display display) (type stringable name)) (declare (clx-values font)) (let* ((name-string (string-downcase (string name))) (font (car (member name-string (display-font-cache display) :key 'font-name :test 'equal))) font-id) (unless font (setq font (make-font :display display :name name-string)) (setq font-id (allocate-resource-id display font 'font)) (setf (font-id-internal font) font-id) (with-buffer-request (display +x-openfont+) (resource-id font-id) (card16 (length name-string)) (pad16 nil) (string name-string)) (push font (display-font-cache display))) (incf (font-reference-count font)) (unless (font-font-info-internal font) (query-font font)) font)) (defun open-font-internal (font) ;; Called "under the covers" to open a font object (declare (type font font)) (declare (clx-values resource-id)) (let* ((name-string (font-name font)) (display (font-display font)) (id (allocate-resource-id display font 'font))) (setf (font-id-internal font) id) (with-buffer-request (display +x-openfont+) (resource-id id) (card16 (length name-string)) (pad16 nil) (string name-string)) (push font (display-font-cache display)) (incf (font-reference-count font)) id)) (defun discard-font-info (font) ;; Discards any state that can be re-obtained with QueryFont. This is ;; simply a performance hint for memory-limited systems. (declare (type font font)) (setf (font-font-info-internal font) nil (font-char-infos-internal font) nil)) (defun query-font (font) ;; Internal function called by font and char info accessors (declare (type font font)) (declare (clx-values font-info)) (let ((display (font-display font)) font-id font-info props) (setq font-id (font-id font)) ;; May issue an open-font request (with-buffer-request-and-reply (display +x-queryfont+ 60) ((resource-id font-id)) (let* ((min-byte2 (card16-get 40)) (max-byte2 (card16-get 42)) (min-byte1 (card8-get 49)) (max-byte1 (card8-get 50)) (min-char min-byte2) (max-char (index+ (index-ash max-byte1 8) max-byte2)) (nfont-props (card16-get 46)) (nchar-infos (index* (card32-get 56) 6)) (char-info (make-array nchar-infos :element-type 'int16))) (setq font-info (make-font-info :direction (member8-get 48 :left-to-right :right-to-left) :min-char min-char :max-char max-char :min-byte1 min-byte1 :max-byte1 max-byte1 :min-byte2 min-byte2 :max-byte2 max-byte2 :all-chars-exist-p (boolean-get 51) :default-char (card16-get 44) :ascent (int16-get 52) :descent (int16-get 54) :min-bounds (char-info-get 8) :max-bounds (char-info-get 24))) (setq props (sequence-get :length (index* 2 nfont-props) :format int32 :result-type 'list :index 60)) (sequence-get :length nchar-infos :format int16 :data char-info :index (index+ 60 (index* 2 nfont-props 4))) (setf (font-char-infos-internal font) char-info) (setf (font-font-info-internal font) font-info))) ;; Replace atom id's with keywords in the plist (do ((p props (cddr p))) ((endp p)) (setf (car p) (atom-name display (car p)))) (setf (font-info-properties font-info) props) font-info)) (defun close-font (font) ;; This might not generate a protocol request if the font is reference ;; counted locally. (declare (type font font)) (when (and (not (plusp (decf (font-reference-count font)))) (font-id-internal font)) (let ((display (font-display font)) (id (font-id-internal font))) (declare (type display display)) ;; Remove font from cache (setf (display-font-cache display) (delete font (display-font-cache display))) ;; Close the font (with-buffer-request (display +x-closefont+) (resource-id id))))) (defun list-font-names (display pattern &key (max-fonts 65535) (result-type 'list)) (declare (type display display) (type string pattern) (type card16 max-fonts) (type t result-type)) ;; CL type (declare (clx-values (clx-sequence string))) (let ((string (string pattern))) (with-buffer-request-and-reply (display +x-listfonts+ size :sizes (8 16)) ((card16 max-fonts (length string)) (string string)) (values (read-sequence-string buffer-bbuf (index- size +replysize+) (card16-get 8) result-type +replysize+))))) (defun list-fonts (display pattern &key (max-fonts 65535) (result-type 'list)) ;; Note: Was called list-fonts-with-info. ;; Returns "pseudo" fonts that contain basic font metrics and properties, but ;; no per-character metrics and no resource-ids. These pseudo fonts will be ;; converted (internally) to real fonts dynamically as needed, by issuing an ;; OpenFont request. However, the OpenFont might fail, in which case the ;; invalid-font error can arise. (declare (type display display) (type string pattern) (type card16 max-fonts) (type t result-type)) ;; CL type (declare (clx-values (clx-sequence font))) (let ((string (string pattern)) (result nil)) (with-buffer-request-and-reply (display +x-listfontswithinfo+ 60 :sizes (8 16) :multiple-reply t) ((card16 max-fonts (length string)) (string string)) (cond ((zerop (card8-get 1)) t) (t (let* ((name-len (card8-get 1)) (min-byte2 (card16-get 40)) (max-byte2 (card16-get 42)) (min-byte1 (card8-get 49)) (max-byte1 (card8-get 50)) (min-char min-byte2) (max-char (index+ (index-ash max-byte1 8) max-byte2)) (nfont-props (card16-get 46)) (font (make-font :display display :name nil :font-info-internal (make-font-info :direction (member8-get 48 :left-to-right :right-to-left) :min-char min-char :max-char max-char :min-byte1 min-byte1 :max-byte1 max-byte1 :min-byte2 min-byte2 :max-byte2 max-byte2 :all-chars-exist-p (boolean-get 51) :default-char (card16-get 44) :ascent (int16-get 52) :descent (int16-get 54) :min-bounds (char-info-get 8) :max-bounds (char-info-get 24) :properties (sequence-get :length (index* 2 nfont-props) :format int32 :result-type 'list :index 60))))) (setf (font-name font) (string-get name-len (index+ 60 (index* 2 nfont-props 4)))) (push font result)) nil))) ;; Replace atom id's with keywords in the plist (dolist (font result) (do ((p (font-properties font) (cddr p))) ((endp p)) (setf (car p) (atom-name display (car p))))) (coerce (nreverse result) result-type))) (defun font-path (display &key (result-type 'list)) (declare (type display display) (type t result-type)) ;; CL type (declare (clx-values (clx-sequence (or string pathname)))) (with-buffer-request-and-reply (display +x-getfontpath+ size :sizes (8 16)) () (values (read-sequence-string buffer-bbuf (index- size +replysize+) (card16-get 8) result-type +replysize+)))) (defun set-font-path (display paths) (declare (type display display) (type (clx-sequence (or string pathname)) paths)) (let ((path-length (length paths)) (request-length 8)) ;; Find the request length (dotimes (i path-length) (let* ((string (string (elt paths i))) (len (length string))) (incf request-length (1+ len)))) (with-buffer-request (display +x-setfontpath+ :length request-length) (length (ceiling request-length 4)) (card16 path-length) (pad16 nil) (progn (incf buffer-boffset 8) (dotimes (i path-length) (let* ((string (string (elt paths i))) (len (length string))) (card8-put 0 len) (string-put 1 string :appending t :header-length 1) (incf buffer-boffset (1+ len)))) (setf (buffer-boffset display) (lround buffer-boffset))))) paths) (defsetf font-path set-font-path) ecl-16.1.2/src/clx/gcontext.lisp000066400000000000000000001334771266352375300165000ustar00rootroot00000000000000;;; -*- Mode: LISP; Syntax: Common-lisp; Package: XLIB; Base: 10; Lowercase: Yes -*- ;;; GContext ;;; ;;; TEXAS INSTRUMENTS INCORPORATED ;;; P.O. BOX 2909 ;;; AUSTIN, TEXAS 78769 ;;; ;;; Copyright (C) 1987 Texas Instruments Incorporated. ;;; ;;; Permission is granted to any individual or institution to use, copy, modify, ;;; and distribute this software, provided that this complete copyright and ;;; permission notice is maintained, intact, in all copies and supporting ;;; documentation. ;;; ;;; Texas Instruments Incorporated provides this software "as is" without ;;; express or implied warranty. ;;; ;;; GContext values are usually cached locally in the GContext object. ;;; This is required because the X.11 server doesn't have any requests ;;; for getting GContext values back. ;;; ;;; GContext changes are cached until force-GContext-changes is called. ;;; All the requests that use GContext (including the GContext accessors, ;;; but not the SETF's) call force-GContext-changes. ;;; In addition, the macro WITH-GCONTEXT may be used to provide a ;;; local view if a GContext. ;;; ;;; Each GContext keeps a copy of the values the server has seen, and ;;; a copy altered by SETF, called the LOCAL-STATE (bad name...). ;;; The SETF accessors increment a timestamp in the GContext. ;;; When the timestamp in a GContext isn't equal to the timestamp in ;;; the local-state, changes have been made, and force-GContext-changes ;;; loops through the GContext and local-state, sending differences to ;;; the server, and updating GContext. ;;; ;;; WITH-GCONTEXT works by BINDING the local-state slot in a GContext to ;;; a private copy. This is easy (and fast) for lisp machines, but other ;;; lisps will have problems. Fortunately, most other lisps don't care, ;;; because they don't run in a multi-processing shared-address space ;;; environment. (in-package :xlib) ;; GContext state accessors ;; The state vector contains all card32s to speed server updating (eval-when (:compile-toplevel :load-toplevel :execute) (defconstant +gcontext-fast-change-length+ #.(length +gcontext-components+)) (macrolet ((def-gc-internals (name &rest extras) (let ((macros nil) (indexes nil) (masks nil) (index 0)) (dolist (name +gcontext-components+) (push `(defmacro ,(xintern 'gcontext-internal- name) (state) `(svref ,state ,,index)) macros) (setf (getf indexes name) index) (push (ash 1 index) masks) (incf index)) (dolist (extra extras) (push `(defmacro ,(xintern 'gcontext-internal- (first extra)) (state) `(svref ,state ,,index)) macros) ;; don't override already correct index entries (unless (or (getf indexes (second extra)) (getf indexes (first extra))) (setf (getf indexes (or (second extra) (first extra))) index)) (push (logior (ash 1 index) (if (second extra) (ash 1 (position (second extra) +gcontext-components+)) 0)) masks) (incf index)) `(within-definition (def-gc-internals ,name) ,@(nreverse macros) (eval-when (:compile-toplevel :load-toplevel :execute) (defvar *gcontext-data-length* ,index) (defvar *gcontext-indexes* ',indexes) (defvar *gcontext-masks* ',(coerce (nreverse masks) 'simple-vector) )))))) (def-gc-internals ignore (:clip :clip-mask) (:dash :dashes) (:font-obj :font) (:timestamp))) ) ;; end EVAL-WHEN (deftype gcmask () '(unsigned-byte #.+gcontext-fast-change-length+)) (deftype xgcmask () '(unsigned-byte #.*gcontext-data-length*)) (defstruct (gcontext-extension (:type vector) (:copier nil)) ;; un-named (name nil :type symbol :read-only t) (default nil :type t :read-only t) ;; FIXME: these used to have glorious, but wrong, type declarations. ;; See if we can't return them to their former glory. (set-function #'(lambda (gcontext value) (declare (ignore gcontext)) value) :type (or function symbol) :read-only t) (copy-function #'(lambda (from-gc to-gc value) (declare (ignore from-gc to-gc)) value) :type (or function symbol) :read-only t)) (defvar *gcontext-extensions* nil) ;; list of gcontext-extension ;; Gcontext state Resource (defvar *gcontext-local-state-cache* nil) ;; List of unused gcontext local states (defmacro gcontext-state-next (state) `(svref ,state 0)) (defun allocate-gcontext-state () ;; Allocate a gcontext-state ;; Loop until a local state is found that's large enough to hold ;; any extensions that may exist. (let ((length (index+ *gcontext-data-length* (length *gcontext-extensions*)))) (declare (type array-index length)) (loop (let ((state (or (threaded-atomic-pop *gcontext-local-state-cache* gcontext-state-next gcontext-state) (make-array length :initial-element nil)))) (declare (type gcontext-state state)) (when (index>= (length state) length) (return state)))))) (defun deallocate-gcontext-state (state) (declare (type gcontext-state state)) (fill state nil) (threaded-atomic-push state *gcontext-local-state-cache* gcontext-state-next gcontext-state)) ;; Temp-Gcontext Resource (defvar *temp-gcontext-cache* nil) ;; List of unused gcontexts (defun allocate-temp-gcontext () (or (threaded-atomic-pop *temp-gcontext-cache* gcontext-next gcontext) (make-gcontext :local-state '#() :server-state '#()))) (defun deallocate-temp-gcontext (gc) (declare (type gcontext gc)) (threaded-atomic-push gc *temp-gcontext-cache* gcontext-next gcontext)) ;; For each argument to create-gcontext (except clip-mask and clip-ordering) declared ;; as (type ), there is an accessor: ;(defun gcontext- (gcontext) ; ;; The value will be nil if the last value stored is unknown (e.g., the cache was ; ;; off, or the component was copied from a gcontext with unknown state). ; (declare (type gcontext gcontext) ; (clx-values ))) ;; For each argument to create-gcontext (except clip-mask and clip-ordering) declared ;; as (type (or null ) ), there is a setf for the corresponding accessor: ;(defsetf gcontext- (gcontext) (value) ; ) ;; Generate all the accessors and defsetf's for GContext (defmacro xgcmask->gcmask (mask) `(the gcmask (logand ,mask #.(1- (ash 1 +gcontext-fast-change-length+))))) (defmacro access-gcontext ((gcontext local-state) &body body) `(let ((,local-state (gcontext-local-state ,gcontext))) (declare (type gcontext-state ,local-state)) ,@body)) (defmacro modify-gcontext ((gcontext local-state) &body body) ;; The timestamp must be altered after the modification `(let ((,local-state (gcontext-local-state ,gcontext))) (declare (type gcontext-state ,local-state)) (prog1 (progn ,@body) (setf (gcontext-internal-timestamp ,local-state) 0)))) (defmacro def-gc-accessor (name type) (let* ((gcontext-name (xintern 'gcontext- name)) (internal-accessor (xintern 'gcontext-internal- name)) (internal-setfer (xintern 'set- gcontext-name))) `(within-definition (,name def-gc-accessor) (defun ,gcontext-name (gcontext) (declare (type gcontext gcontext)) (declare (clx-values (or null ,type))) (let ((value (,internal-accessor (gcontext-local-state gcontext)))) (declare (type (or null card32) value)) (when value ;; Don't do anything when value isn't known (let ((%buffer (gcontext-display gcontext))) (declare (type display %buffer)) %buffer (decode-type ,type value))))) (defun ,internal-setfer (gcontext value) (declare (type gcontext gcontext) (type ,type value)) (modify-gcontext (gcontext local-state) (setf (,internal-accessor local-state) (encode-type ,type value)) ,@(when (eq type 'pixmap) ;; write-through pixmaps, because the protocol allows ;; the server to copy the pixmap contents at the time ;; of the store, rather than continuing to share with ;; the pixmap. `((let ((server-state (gcontext-server-state gcontext))) (setf (,internal-accessor server-state) nil)))) value)) (defsetf ,gcontext-name ,internal-setfer)))) (defmacro incf-internal-timestamp (state) (let ((ts (gensym))) `(let ((,ts (the fixnum (gcontext-internal-timestamp ,state)))) (declare (type fixnum ,ts)) ;; the probability seems low enough (setq ,ts (if (= ,ts most-positive-fixnum) 1 (the fixnum (1+ ,ts)))) (setf (gcontext-internal-timestamp ,state) ,ts)))) (def-gc-accessor function boole-constant) (def-gc-accessor plane-mask card32) (def-gc-accessor foreground card32) (def-gc-accessor background card32) (def-gc-accessor line-width card16) (def-gc-accessor line-style (member :solid :dash :double-dash)) (def-gc-accessor cap-style (member :not-last :butt :round :projecting)) (def-gc-accessor join-style (member :miter :round :bevel)) (def-gc-accessor fill-style (member :solid :tiled :stippled :opaque-stippled)) (def-gc-accessor fill-rule (member :even-odd :winding)) (def-gc-accessor tile pixmap) (def-gc-accessor stipple pixmap) (def-gc-accessor ts-x int16) ;; Tile-Stipple-X-origin (def-gc-accessor ts-y int16) ;; Tile-Stipple-Y-origin ;; (def-GC-accessor font font) ;; See below (def-gc-accessor subwindow-mode (member :clip-by-children :include-inferiors)) (def-gc-accessor exposures (member :off :on)) (def-gc-accessor clip-x int16) (def-gc-accessor clip-y int16) ;; (def-GC-accessor clip-mask) ;; see below (def-gc-accessor dash-offset card16) ;; (def-GC-accessor dashes) ;; see below (def-gc-accessor arc-mode (member :chord :pie-slice)) (defun gcontext-clip-mask (gcontext) (declare (type gcontext gcontext)) (declare (clx-values (or null (member :none) pixmap rect-seq) (or null (member :unsorted :y-sorted :yx-sorted :yx-banded)))) (access-gcontext (gcontext local-state) (multiple-value-bind (clip clip-mask) (without-interrupts (values (gcontext-internal-clip local-state) (gcontext-internal-clip-mask local-state))) (if (null clip) (values (let ((%buffer (gcontext-display gcontext))) (declare (type display %buffer)) (decode-type (or (member :none) pixmap) clip-mask)) nil) (values (second clip) (decode-type (or null (member :unsorted :y-sorted :yx-sorted :yx-banded)) (first clip))))))) (defsetf gcontext-clip-mask (gcontext &optional ordering) (clip-mask) ;; A bit strange, but retains setf form. ;; a nil clip-mask is transformed to an empty vector `(set-gcontext-clip-mask ,gcontext ,ordering ,clip-mask)) (defun set-gcontext-clip-mask (gcontext ordering clip-mask) ;; a nil clip-mask is transformed to an empty vector (declare (type gcontext gcontext) (type (or null (member :unsorted :y-sorted :yx-sorted :yx-banded)) ordering) (type (or (member :none) pixmap rect-seq) clip-mask)) (unless clip-mask (x-type-error clip-mask '(or (member :none) pixmap rect-seq))) (multiple-value-bind (clip-mask clip) (typecase clip-mask (pixmap (values (pixmap-id clip-mask) nil)) ((member :none) (values 0 nil)) (sequence (values nil (list (encode-type (or null (member :unsorted :y-sorted :yx-sorted :yx-banded)) ordering) (copy-seq clip-mask)))) (otherwise (x-type-error clip-mask '(or (member :none) pixmap rect-seq)))) (modify-gcontext (gcontext local-state) (let ((server-state (gcontext-server-state gcontext))) (declare (type gcontext-state server-state)) (without-interrupts (setf (gcontext-internal-clip local-state) clip (gcontext-internal-clip-mask local-state) clip-mask) (if (null clip) (setf (gcontext-internal-clip server-state) nil) (setf (gcontext-internal-clip-mask server-state) nil)) (when (and clip-mask (not (zerop clip-mask))) ;; write-through clip-mask pixmap, because the protocol allows the ;; server to copy the pixmap contents at the time of the store, ;; rather than continuing to share with the pixmap. (setf (gcontext-internal-clip-mask server-state) nil)))))) clip-mask) (defun gcontext-dashes (gcontext) (declare (type gcontext gcontext)) (declare (clx-values (or null card8 sequence))) (access-gcontext (gcontext local-state) (multiple-value-bind (dash dashes) (without-interrupts (values (gcontext-internal-dash local-state) (gcontext-internal-dashes local-state))) (if (null dash) dashes dash)))) (defsetf gcontext-dashes set-gcontext-dashes) (defun set-gcontext-dashes (gcontext dashes) (declare (type gcontext gcontext) (type (or card8 sequence) dashes)) (multiple-value-bind (dashes dash) (if (type? dashes 'sequence) (if (zerop (length dashes)) (x-type-error dashes '(or card8 sequence) "non-empty sequence") (values nil (or (copy-seq dashes) (vector)))) (values (encode-type card8 dashes) nil)) (modify-gcontext (gcontext local-state) (let ((server-state (gcontext-server-state gcontext))) (declare (type gcontext-state server-state)) (without-interrupts (setf (gcontext-internal-dash local-state) dash (gcontext-internal-dashes local-state) dashes) (if (null dash) (setf (gcontext-internal-dash server-state) nil) (setf (gcontext-internal-dashes server-state) nil)))))) dashes) (defun gcontext-font (gcontext &optional metrics-p) ;; If the stored font is known, it is returned. If it is not known and ;; metrics-p is false, then nil is returned. If it is not known and ;; metrics-p is true, then a pseudo font is returned. Full metric and ;; property information can be obtained, but the font does not have a name or ;; a resource-id, and attempts to use it where a resource-id is required will ;; result in an invalid-font error. (declare (type gcontext gcontext) (type generalized-boolean metrics-p)) (declare (clx-values (or null font))) (access-gcontext (gcontext local-state) (let ((font (gcontext-internal-font-obj local-state))) (or font (when metrics-p ;; XXX this isn't correct (make-font :display (gcontext-display gcontext) :id (gcontext-id gcontext) :name nil)))))) (defsetf gcontext-font set-gcontext-font) (defun set-gcontext-font (gcontext font) (declare (type gcontext gcontext) (type fontable font)) (let* ((font-object (if (font-p font) font (open-font (gcontext-display gcontext) font))) (font (and font-object (font-id font-object)))) ;; XXX need to check font has id (and name?) (modify-gcontext (gcontext local-state) (let ((server-state (gcontext-server-state gcontext))) (declare (type gcontext-state server-state)) (without-interrupts (setf (gcontext-internal-font-obj local-state) font-object (gcontext-internal-font local-state) font) ;; check against font, not against font-obj (if (null font) (setf (gcontext-internal-font server-state) nil) (setf (gcontext-internal-font-obj server-state) font-object)))))) font) (defun force-gcontext-changes-internal (gcontext) ;; Force any delayed changes. (declare (type gcontext gcontext)) #.(declare-buffun) (let ((display (gcontext-display gcontext)) (server-state (gcontext-server-state gcontext)) (local-state (gcontext-local-state gcontext))) (declare (type display display) (type gcontext-state server-state local-state)) ;; Update server when timestamps don't match (unless (= (the fixnum (gcontext-internal-timestamp local-state)) (the fixnum (gcontext-internal-timestamp server-state))) ;; The display is already locked. (macrolet ((with-buffer ((buffer &key timeout) &body body) `(progn (progn ,buffer ,@(and timeout `(,timeout)) nil) ,@body))) ;; Because there is no locking on the local state we have to ;; assume that state will change and set timestamps up front, ;; otherwise by the time we figured out there were no changes ;; and tried to store the server stamp as the local stamp, the ;; local stamp might have since been modified. (setf (gcontext-internal-timestamp local-state) (incf-internal-timestamp server-state)) (block no-changes (let ((last-request (buffer-last-request display))) (with-buffer-request (display +x-changegc+) (gcontext gcontext) (progn (do ((i 0 (index+ i 1)) (bit 1 (the xgcmask (ash bit 1))) (nbyte 12) (mask 0) (local 0)) ((index>= i +gcontext-fast-change-length+) (when (zerop mask) ;; If nothing changed, restore last-request and quit (setf (buffer-last-request display) (if (zerop (buffer-last-request display)) nil last-request)) (return-from no-changes nil)) (card29-put 8 mask) (card16-put 2 (index-ash nbyte -2)) (index-incf (buffer-boffset display) nbyte)) (declare (type array-index i nbyte) (type xgcmask bit) (type gcmask mask) (type (or null card32) local)) (unless (eql (the (or null card32) (svref server-state i)) (setq local (the (or null card32) (svref local-state i)))) (setf (svref server-state i) local) (card32-put nbyte local) (setq mask (the gcmask (logior mask bit))) (index-incf nbyte 4))))))) ;; Update GContext extensions (do ((extension *gcontext-extensions* (cdr extension)) (i *gcontext-data-length* (index+ i 1)) (local)) ((endp extension)) (unless (eql (svref server-state i) (setq local (svref local-state i))) (setf (svref server-state i) local) (funcall (gcontext-extension-set-function (car extension)) gcontext local))) ;; Update clipping rectangles (multiple-value-bind (local-clip server-clip) (without-interrupts (values (gcontext-internal-clip local-state) (gcontext-internal-clip server-state))) (unless (equalp local-clip server-clip) (setf (gcontext-internal-clip server-state) nil) (unless (null local-clip) (with-buffer-request (display +x-setcliprectangles+) (data (first local-clip)) (gcontext gcontext) ;; XXX treat nil correctly (card16 (or (gcontext-internal-clip-x local-state) 0) (or (gcontext-internal-clip-y local-state) 0)) ;; XXX this has both int16 and card16 values ((sequence :format int16) (second local-clip))) (setf (gcontext-internal-clip server-state) local-clip)))) ;; Update dashes (multiple-value-bind (local-dash server-dash) (without-interrupts (values (gcontext-internal-dash local-state) (gcontext-internal-dash server-state))) (unless (equalp local-dash server-dash) (setf (gcontext-internal-dash server-state) nil) (unless (null local-dash) (with-buffer-request (display +x-setdashes+) (gcontext gcontext) ;; XXX treat nil correctly (card16 (or (gcontext-internal-dash-offset local-state) 0) (length local-dash)) ((sequence :format card8) local-dash)) (setf (gcontext-internal-dash server-state) local-dash)))))))) (defun force-gcontext-changes (gcontext) ;; Force any delayed changes. (declare (type gcontext gcontext)) (let ((display (gcontext-display gcontext)) (server-state (gcontext-server-state gcontext)) (local-state (gcontext-local-state gcontext))) (declare (type gcontext-state server-state local-state)) ;; Update server when timestamps don't match (unless (= (the fixnum (gcontext-internal-timestamp local-state)) (the fixnum (gcontext-internal-timestamp server-state))) (with-display (display) (force-gcontext-changes-internal gcontext))))) ;;; WARNING: WITH-GCONTEXT WORKS MUCH MORE EFFICIENTLY WHEN THE OPTIONS BEING "BOUND" ARE ;;; SET IN THE GCONTEXT ON ENTRY. BECAUSE THERE'S NO WAY TO GET THE VALUE OF AN ;;; UNKNOWN GC COMPONENT, WITH-GCONTEXT MUST CREATE A TEMPORARY GC, COPY THE UNKNOWN ;;; COMPONENTS TO THE TEMPORARY GC, ALTER THE GC BEING USED, THEN COPY COMPOMENTS ;;; BACK. (defmacro with-gcontext ((gcontext &rest options &key clip-ordering &allow-other-keys) &body body) ;; "Binds" the gcontext components specified by options within the ;; dynamic scope of the body (i.e., indefinite scope and dynamic ;; extent), on a per-process basis in a multi-process environment. ;; The body is not surrounded by a with-display. If cache-p is nil or ;; the some component states are unknown, this will implement ;; save/restore by creating a temporary gcontext and doing ;; copy-gcontext-components to and from it. (declare (arglist (gcontext &rest options &key function plane-mask foreground background line-width line-style cap-style join-style fill-style fill-rule arc-mode tile stipple ts-x ts-y font subwindow-mode exposures clip-x clip-y clip-mask clip-ordering dash-offset dashes &allow-other-keys) &body body)) (remf options :clip-ordering) (let ((gc (gensym)) (saved-state (gensym)) (temp-gc (gensym)) (temp-mask (gensym)) (temp-vars nil) (setfs nil) (indexes nil) ; List of gcontext field indices (extension-indexes nil) ; List of gcontext extension field indices (ts-index (getf *gcontext-indexes* :timestamp))) (do* ((option options (cddr option)) (name (car option) (car option)) (value (cadr option) (cadr option))) ((endp option) (setq setfs (nreverse setfs))) (let ((index (getf *gcontext-indexes* name))) (if index (push index indexes) (let ((extension (find name *gcontext-extensions* :key #'gcontext-extension-name))) (if extension (progn (push (xintern "Internal-" 'gcontext- name "-State-Index") extension-indexes)) (x-type-error name 'gcontext-key))))) (let ((accessor `(,(xintern 'gcontext- name) ,gc ,@(when (eq name :clip-mask) `(,clip-ordering)))) (temp-var (gensym))) (when value (push `(,temp-var ,value) temp-vars) (push `(when ,temp-var (setf ,accessor ,temp-var)) setfs)))) (if setfs `(multiple-value-bind (,gc ,saved-state ,temp-mask ,temp-gc) (copy-gcontext-local-state ,gcontext ',indexes ,@extension-indexes) (declare (type gcontext ,gc) (type gcontext-state ,saved-state) (type xgcmask ,temp-mask) (type (or null gcontext) ,temp-gc)) (with-gcontext-bindings (,gc ,saved-state ,(append indexes extension-indexes) ,ts-index ,temp-mask ,temp-gc) (let ,temp-vars ,@setfs) ,@body)) `(progn ,@body)))) (defun copy-gcontext-local-state (gcontext indexes &rest extension-indices) ;; Called from WITH-GCONTEXT to save the fields in GCONTEXT indicated by MASK (declare (type gcontext gcontext) (type list indexes) (dynamic-extent extension-indices)) (let ((local-state (gcontext-local-state gcontext)) (saved-state (allocate-gcontext-state)) (cache-p (gcontext-cache-p gcontext))) (declare (type gcontext-state local-state saved-state)) (setf (gcontext-internal-timestamp saved-state) 1) (let ((temp-gc nil) (temp-mask 0) (extension-mask 0)) (declare (type xgcmask temp-mask) (type integer extension-mask)) (dolist (i indexes) (when (or (not (setf (svref saved-state i) (svref local-state i))) (not cache-p)) (setq temp-mask (the xgcmask (logior temp-mask (the xgcmask (svref *gcontext-masks* i))))))) (dolist (i extension-indices) (when (or (not (setf (svref saved-state i) (svref local-state i))) (not cache-p)) (setq extension-mask (the xgcmask (logior extension-mask (ash 1 i)))))) (when (or (plusp temp-mask) (plusp extension-mask)) ;; Copy to temporary GC when field unknown or cache-p false (let ((display (gcontext-display gcontext))) (declare (type display display)) (with-display (display) (setq temp-gc (allocate-temp-gcontext)) (setf (gcontext-id temp-gc) (allocate-resource-id display gcontext 'gcontext) (gcontext-display temp-gc) display (gcontext-drawable temp-gc) (gcontext-drawable gcontext) (gcontext-server-state temp-gc) saved-state (gcontext-local-state temp-gc) saved-state) ;; Create a new (temporary) gcontext (with-buffer-request (display +x-creategc+) (gcontext temp-gc) (drawable (gcontext-drawable gcontext)) (card29 0)) ;; Copy changed components to the temporary gcontext (when (plusp temp-mask) (with-buffer-request (display +x-copygc+) (gcontext gcontext) (gcontext temp-gc) (card29 (xgcmask->gcmask temp-mask)))) ;; Copy extension fields to the new gcontext (when (plusp extension-mask) ;; Copy extension fields from temp back to gcontext (do ((bit (ash extension-mask (- *gcontext-data-length*)) (ash bit -1)) (i 0 (index+ i 1))) ((zerop bit)) (let ((copy-function (gcontext-extension-copy-function (elt *gcontext-extensions* i)))) (funcall copy-function gcontext temp-gc (svref local-state (index+ i *gcontext-data-length*)))))) ))) (values gcontext saved-state (logior temp-mask extension-mask) temp-gc)))) (defun restore-gcontext-temp-state (gcontext temp-mask temp-gc) (declare (type gcontext gcontext temp-gc) (type xgcmask temp-mask)) (let ((display (gcontext-display gcontext))) (declare (type display display)) (with-display (display) (with-buffer-request (display +x-copygc+) (gcontext temp-gc) (gcontext gcontext) (card29 (xgcmask->gcmask temp-mask))) ;; Copy extension fields from temp back to gcontext (do ((bit (ash temp-mask (- *gcontext-data-length*)) (ash bit -1)) (extensions *gcontext-extensions* (cdr extensions)) (i *gcontext-data-length* (index+ i 1)) (local-state (gcontext-local-state temp-gc))) ((zerop bit)) (let ((copy-function (gcontext-extension-copy-function (car extensions)))) (funcall copy-function temp-gc gcontext (svref local-state i)))) ;; free gcontext (with-buffer-request (display +x-freegc+) (gcontext temp-gc)) (deallocate-resource-id display (gcontext-id temp-gc) 'gcontext) (deallocate-temp-gcontext temp-gc) ;; Copy saved state back to server state (do ((server-state (gcontext-server-state gcontext)) (bit (xgcmask->gcmask temp-mask) (the gcmask (ash bit -1))) (i 0 (index+ i 1))) ((zerop bit) (incf-internal-timestamp server-state)) (declare (type gcontext-state server-state) (type gcmask bit) (type array-index i)) (when (oddp bit) (setf (svref server-state i) nil)))))) (defun create-gcontext (&rest options &key (drawable (required-arg drawable)) function plane-mask foreground background line-width line-style cap-style join-style fill-style fill-rule arc-mode tile stipple ts-x ts-y font subwindow-mode exposures clip-x clip-y clip-mask clip-ordering dash-offset dashes (cache-p t) &allow-other-keys) ;; Only non-nil components are passed on in the request, but for effective caching ;; assumptions have to be made about what the actual protocol defaults are. For ;; all gcontext components, a value of nil causes the default gcontext value to be ;; used. For clip-mask, this implies that an empty rect-seq cannot be represented ;; as a list. Note: use of stringable as font will cause an implicit open-font. ;; Note: papers over protocol SetClipRectangles and SetDashes special cases. If ;; cache-p is true, then gcontext state is cached locally, and changing a gcontext ;; component will have no effect unless the new value differs from the cached ;; value. Component changes (setfs and with-gcontext) are always deferred ;; regardless of the cache mode, and sent over the protocol only when required by a ;; local operation or by an explicit call to force-gcontext-changes. (declare (type drawable drawable) ; Required to be non-null (type (or null boole-constant) function) (type (or null pixel) plane-mask foreground background) (type (or null card16) line-width dash-offset) (type (or null int16) ts-x ts-y clip-x clip-y) (type (or null (member :solid :dash :double-dash)) line-style) (type (or null (member :not-last :butt :round :projecting)) cap-style) (type (or null (member :miter :round :bevel)) join-style) (type (or null (member :solid :tiled :opaque-stippled :stippled)) fill-style) (type (or null (member :even-odd :winding)) fill-rule) (type (or null (member :chord :pie-slice)) arc-mode) (type (or null pixmap) tile stipple) (type (or null fontable) font) (type (or null (member :clip-by-children :include-inferiors)) subwindow-mode) (type (or null (member :on :off)) exposures) (type (or null (member :none) pixmap rect-seq) clip-mask) (type (or null (member :unsorted :y-sorted :yx-sorted :yx-banded)) clip-ordering) (type (or null card8 sequence) dashes) (dynamic-extent options) (type generalized-boolean cache-p)) (declare (clx-values gcontext)) (let* ((display (drawable-display drawable)) (gcontext (make-gcontext :display display :drawable drawable :cache-p cache-p)) (local-state (gcontext-local-state gcontext)) (server-state (gcontext-server-state gcontext)) (gcontextid (allocate-resource-id display gcontext 'gcontext))) (declare (type display display) (type gcontext gcontext) (type resource-id gcontextid) (type gcontext-state local-state server-state)) (setf (gcontext-id gcontext) gcontextid) (unless function (setf (gcontext-function gcontext) boole-1)) ;; using the depth of the drawable would be better, but ... (unless plane-mask (setf (gcontext-plane-mask gcontext) #xffffffff)) (unless foreground (setf (gcontext-foreground gcontext) 0)) (unless background (setf (gcontext-background gcontext) 1)) (unless line-width (setf (gcontext-line-width gcontext) 0)) (unless line-style (setf (gcontext-line-style gcontext) :solid)) (unless cap-style (setf (gcontext-cap-style gcontext) :butt)) (unless join-style (setf (gcontext-join-style gcontext) :miter)) (unless fill-style (setf (gcontext-fill-style gcontext) :solid)) (unless fill-rule (setf (gcontext-fill-rule gcontext) :even-odd)) (unless arc-mode (setf (gcontext-arc-mode gcontext) :pie-slice)) (unless ts-x (setf (gcontext-ts-x gcontext) 0)) (unless ts-y (setf (gcontext-ts-y gcontext) 0)) (unless subwindow-mode (setf (gcontext-subwindow-mode gcontext) :clip-by-children)) (unless exposures (setf (gcontext-exposures gcontext) :on)) (unless clip-mask (setf (gcontext-clip-mask gcontext) :none)) (unless clip-x (setf (gcontext-clip-x gcontext) 0)) (unless clip-y (setf (gcontext-clip-y gcontext) 0)) (unless dashes (setf (gcontext-dashes gcontext) 4)) (unless dash-offset (setf (gcontext-dash-offset gcontext) 0)) ;; a bit kludgy, but ... (replace server-state local-state) (when function (setf (gcontext-function gcontext) function)) (when plane-mask (setf (gcontext-plane-mask gcontext) plane-mask)) (when foreground (setf (gcontext-foreground gcontext) foreground)) (when background (setf (gcontext-background gcontext) background)) (when line-width (setf (gcontext-line-width gcontext) line-width)) (when line-style (setf (gcontext-line-style gcontext) line-style)) (when cap-style (setf (gcontext-cap-style gcontext) cap-style)) (when join-style (setf (gcontext-join-style gcontext) join-style)) (when fill-style (setf (gcontext-fill-style gcontext) fill-style)) (when fill-rule (setf (gcontext-fill-rule gcontext) fill-rule)) (when arc-mode (setf (gcontext-arc-mode gcontext) arc-mode)) (when tile (setf (gcontext-tile gcontext) tile)) (when stipple (setf (gcontext-stipple gcontext) stipple)) (when ts-x (setf (gcontext-ts-x gcontext) ts-x)) (when ts-y (setf (gcontext-ts-y gcontext) ts-y)) (when font (setf (gcontext-font gcontext) font)) (when subwindow-mode (setf (gcontext-subwindow-mode gcontext) subwindow-mode)) (when exposures (setf (gcontext-exposures gcontext) exposures)) (when clip-x (setf (gcontext-clip-x gcontext) clip-x)) (when clip-y (setf (gcontext-clip-y gcontext) clip-y)) (when clip-mask (setf (gcontext-clip-mask gcontext clip-ordering) clip-mask)) (when dash-offset (setf (gcontext-dash-offset gcontext) dash-offset)) (when dashes (setf (gcontext-dashes gcontext) dashes)) (setf (gcontext-internal-timestamp server-state) 1) (setf (gcontext-internal-timestamp local-state) ;; SetClipRectangles or SetDashes request need to be sent? (if (or (gcontext-internal-clip local-state) (gcontext-internal-dash local-state)) ;; Yes, mark local state "modified" to ensure ;; force-gcontext-changes will occur. 0 ;; No, mark local state "unmodified" 1)) (with-buffer-request (display +x-creategc+) (resource-id gcontextid) (drawable drawable) (progn (do* ((i 0 (index+ i 1)) (bit 1 (the xgcmask (ash bit 1))) (nbyte 16) (mask 0) (local (svref local-state i) (svref local-state i))) ((index>= i +gcontext-fast-change-length+) (card29-put 12 mask) (card16-put 2 (index-ash nbyte -2)) (index-incf (buffer-boffset display) nbyte)) (declare (type array-index i nbyte) (type xgcmask bit) (type gcmask mask) (type (or null card32) local)) (unless (eql local (the (or null card32) (svref server-state i))) (setf (svref server-state i) local) (card32-put nbyte local) (setq mask (the gcmask (logior mask bit))) (index-incf nbyte 4))))) ;; Initialize extensions (do ((extensions *gcontext-extensions* (cdr extensions)) (i *gcontext-data-length* (index+ i 1))) ((endp extensions)) (declare (type list extensions) (type array-index i)) (setf (svref server-state i) (setf (svref local-state i) (gcontext-extension-default (car extensions))))) ;; Set extension values (do* ((option-list options (cddr option-list)) (option (car option-list) (car option-list)) (extension)) ((endp option-list)) (declare (type list option-list)) (cond ((getf *gcontext-indexes* option)) ; Gcontext field ((member option '(:drawable :clip-ordering :cache-p))) ; Optional parameter ((setq extension (find option *gcontext-extensions* :key #'gcontext-extension-name)) (funcall (gcontext-extension-set-function extension) gcontext (second option-list))) (t (x-type-error option 'gcontext-key)))) gcontext)) (defun copy-gcontext-components (src dst &rest keys) (declare (type gcontext src dst) (dynamic-extent keys)) ;; you might ask why this isn't just a bunch of ;; (setf (gcontext- dst) (gcontext- src)) ;; the answer is that you can do that yourself if you want, what we are ;; providing here is access to the protocol request, which will generally ;; be more efficient (particularly for things like clip and dash lists). (when keys (let ((display (gcontext-display src)) (mask 0)) (declare (type xgcmask mask)) (with-display (display) (force-gcontext-changes-internal src) (force-gcontext-changes-internal dst) ;; collect entire mask and handle extensions (dolist (key keys) (let ((i (getf *gcontext-indexes* key))) (declare (type (or null array-index) i)) (if i (setq mask (the xgcmask (logior mask (the xgcmask (svref *gcontext-masks* i))))) (let ((extension (find key *gcontext-extensions* :key #'gcontext-extension-name))) (if extension (funcall (gcontext-extension-copy-function extension) src dst (svref (gcontext-local-state src) (index+ (position extension *gcontext-extensions*) *gcontext-data-length*))) (x-type-error key 'gcontext-key)))))) (when (plusp mask) (do ((src-server-state (gcontext-server-state src)) (dst-server-state (gcontext-server-state dst)) (dst-local-state (gcontext-local-state dst)) (bit mask (the xgcmask (ash bit -1))) (i 0 (index+ i 1))) ((zerop bit) (incf-internal-timestamp dst-server-state) (setf (gcontext-internal-timestamp dst-local-state) 0)) (declare (type gcontext-state src-server-state dst-server-state dst-local-state) (type xgcmask bit) (type array-index i)) (when (oddp bit) (setf (svref dst-local-state i) (setf (svref dst-server-state i) (svref src-server-state i))))) (with-buffer-request (display +x-copygc+) (gcontext src dst) (card29 (xgcmask->gcmask mask)))))))) (defun copy-gcontext (src dst) (declare (type gcontext src dst)) ;; Copies all components. (apply #'copy-gcontext-components src dst +gcontext-components+) (do ((extensions *gcontext-extensions* (cdr extensions)) (i *gcontext-data-length* (index+ i 1))) ((endp extensions)) (funcall (gcontext-extension-copy-function (car extensions)) src dst (svref (gcontext-local-state src) i)))) (defun free-gcontext (gcontext) (declare (type gcontext gcontext)) (let ((display (gcontext-display gcontext))) (with-buffer-request (display +x-freegc+) (gcontext gcontext)) (deallocate-resource-id display (gcontext-id gcontext) 'gcontext) (deallocate-gcontext-state (gcontext-server-state gcontext)) (deallocate-gcontext-state (gcontext-local-state gcontext)) nil)) (defmacro define-gcontext-accessor (name &key default set-function copy-function) ;; This will define a new gcontext accessor called NAME. ;; Defines the gcontext-NAME accessor function and its defsetf. ;; Gcontext's will cache DEFAULT-VALUE and the last value SETF'ed when ;; gcontext-cache-p is true. The NAME keyword will be allowed in ;; CREATE-GCONTEXT, WITH-GCONTEXT, and COPY-GCONTEXT-COMPONENTS. ;; SET-FUNCTION will be called with parameters (GCONTEXT NEW-VALUE) ;; from create-gcontext, and force-gcontext-changes. ;; COPY-FUNCTION will be called with parameters (src-gc dst-gc src-value) ;; from copy-gcontext and copy-gcontext-components. ;; The copy-function defaults to: ;; (lambda (ignore dst-gc value) ;; (if value ;; (,set-function dst-gc value) ;; (error "Can't copy unknown GContext component ~a" ',name))) (declare (type symbol name) (type t default) (type symbol set-function) ;; required (type (or symbol list) copy-function)) (let* ((gc-name (intern (concatenate 'string (string 'gcontext-) (string name)))) ;; in current package (key-name (kintern name)) (setfer (xintern "Set-" gc-name)) (internal-set-function (xintern "Internal-Set-" gc-name)) (internal-copy-function (xintern "Internal-Copy-" gc-name)) (internal-state-index (xintern "Internal-" gc-name "-State-Index"))) (unless copy-function (setq copy-function `(lambda (src-gc dst-gc value) (declare (ignore src-gc)) (if value (,set-function dst-gc value) (error "Can't copy unknown GContext component ~a" ',name))))) `(progn (eval-when (:compile-toplevel :load-toplevel :execute) (defparameter ,internal-state-index (add-gcontext-extension ',key-name ,default ',internal-set-function ',internal-copy-function)) ) ;; end eval-when (defun ,gc-name (gcontext) (svref (gcontext-local-state gcontext) ,internal-state-index)) (defun ,setfer (gcontext new-value) (let ((local-state (gcontext-local-state gcontext))) (setf (gcontext-internal-timestamp local-state) 0) (setf (svref local-state ,internal-state-index) new-value))) (defsetf ,gc-name ,setfer) (defun ,internal-set-function (gcontext new-value) (,set-function gcontext new-value) (setf (svref (gcontext-server-state gcontext) ,internal-state-index) (setf (svref (gcontext-local-state gcontext) ,internal-state-index) new-value))) (defun ,internal-copy-function (src-gc dst-gc new-value) (,copy-function src-gc dst-gc new-value) (setf (svref (gcontext-local-state dst-gc) ,internal-state-index) (setf (svref (gcontext-server-state dst-gc) ,internal-state-index) new-value))) ',name))) ;; GContext extension fields are treated in much the same way as normal GContext ;; components. The current value is stored in a slot of the gcontext-local-state, ;; and the value known to the server is in a slot of the gcontext-server-state. ;; The slot-number is defined by its position in the *gcontext-extensions* list. ;; The value of the special variable |Internal-GCONTEXT-name| (where "name" is ;; the extension component name) reflects this position. The position within ;; *gcontext-extensions* and the value of the special value are determined at ;; LOAD time to facilitate merging of seperately compiled extension files. (defun add-gcontext-extension (name default-value set-function copy-function) (declare (type symbol name) (type t default-value) (type (or function symbol) set-function) (type (or function symbol) copy-function)) (let ((number (or (position name *gcontext-extensions* :key #'gcontext-extension-name) (prog1 (length *gcontext-extensions*) (push nil *gcontext-extensions*))))) (setf (nth number *gcontext-extensions*) (make-gcontext-extension :name name :default default-value :set-function set-function :copy-function copy-function)) (+ number *gcontext-data-length*))) ecl-16.1.2/src/clx/generalock.lisp000066400000000000000000000077011266352375300167450ustar00rootroot00000000000000;;; -*- Mode: LISP; Syntax: Common-lisp; Package: PROCESS; Base: 10; Lowercase: Yes -*- ;;; Copyright (C) 1990 Symbolics, Inc. ;;; ;;; Permission is granted to any individual or institution to use, copy, modify, ;;; and distribute this software, provided that this complete copyright and ;;; permission notice is maintained, intact, in all copies and supporting ;;; documentation. ;;; ;;; Symbolics, Inc. provides this software "as is" without ;;; express or implied warranty. (defflavor xlib::clx-lock () (simple-recursive-normal-lock) (:init-keywords :flavor)) (defwhopper (lock-internal xlib::clx-lock) (lock-argument) (catch 'timeout (continue-whopper lock-argument))) (defmethod (lock-block-internal xlib::clx-lock) (lock-argument) (declare (dbg:locking-function describe-process-lock-for-debugger self)) (when (null waiter-queue) (setf waiter-queue (make-scheduler-queue :name name)) (setf timer (create-timer-call #'lock-timer-expired `(,self) :name name))) (let ((process (lock-argument-process lock-argument))) (unwind-protect (progn (lock-map-over-conflicting-owners self lock-argument #'(lambda (other-lock-arg) (add-promotion process lock-argument (lock-argument-process other-lock-arg) other-lock-arg))) (unless (timer-pending-p timer) (when (and (safe-to-use-timers %real-current-process) (not dbg:*debugger-might-have-system-problems*)) (reset-timer-relative-timer-units timer *lock-timer-interval*))) (assert (store-conditional (locf latch) process nil)) (sys:with-aborts-enabled (lock-latch) (let ((timeout (lock-argument-getf lock-argument :timeout nil))) (cond ((null timeout) (promotion-block waiter-queue name #'lock-lockable self lock-argument)) ((and (plusp timeout) (using-resource (timer process-block-timers) ;; Yeah, we know about the internal representation ;; of timers here. (setf (car (timer-args timer)) %real-current-process) (with-scheduler-locked (reset-timer-relative timer timeout) (flet ((lock-lockable-or-timeout (timer lock lock-argument) (or (not (timer-pending-p timer)) (lock-lockable lock lock-argument)))) (let ((priority (process-process-priority *current-process*))) (if (ldb-test %%scheduler-priority-preemption-field priority) (promotion-block waiter-queue name #'lock-lockable-or-timeout timer self lock-argument) ;; Change to preemptive priority so that when ;; unlock-internal wakes us up so we can have the lock, ;; we will really wake up right away (with-process-priority (dpb 1 %%scheduler-priority-preemption-field priority) (promotion-block waiter-queue name #'lock-lockable-or-timeout timer self lock-argument))))) (lock-lockable self lock-argument))))) (t (throw 'timeout nil)))))) (unless (store-conditional (locf latch) nil process) (lock-latch-wait-internal self)) (remove-promotions process lock-argument)))) (compile-flavor-methods xlib::clx-lock) ecl-16.1.2/src/clx/gl.lisp000066400000000000000000003416271266352375300152450ustar00rootroot00000000000000(defpackage :gl (:use :common-lisp :xlib) (:import-from :glx "*CURRENT-CONTEXT*" "CONTEXT" "CONTEXT-P" "CONTEXT-DISPLAY" "CONTEXT-TAG" "CONTEXT-RBUF" "CONTEXT-INDEX" ) (:import-from :xlib "DATA" "WITH-BUFFER-REQUEST" "WITH-BUFFER-REQUEST-AND-REPLY" "CARD32-GET" "SEQUENCE-GET" "WITH-DISPLAY" "DISPLAY-FORCE-OUTPUT" "INT8" "INT16" "INT32" "INTEGER" "CARD8" "CARD16" "CARD32" "ASET-CARD8" "ASET-CARD16" "ASET-CARD32" "ASET-INT8" "ASET-INT16" "ASET-INT32" "DECLARE-BUFFUN" ;; Types "ARRAY-INDEX" "BUFFER-BYTES" ) (:export "GET-STRING" ;; Rendering commands (alphabetical order) "ACCUM" "ACTIVE-TEXTURE-ARB" "ALPHA-FUNC" "BEGIN" "BIND-TEXTURE" "BLEND-COLOR" "BLEND-EQUOTION" "BLEND-FUNC" "CALL-LIST" "CLEAR" "CLEAR-ACCUM" "CLEAR-COLOR" "CLEAR-DEPTH" "CLEAR-INDEX" "CLEAR-STENCIL" "CLIP-PLANE" "COLOR-3B" "COLOR-3D" "COLOR-3F" "COLOR-3I" "COLOR-3S" "COLOR-3UB" "COLOR-3UI" "COLOR-3US" "COLOR-4B" "COLOR-4D" "COLOR-4F" "COLOR-4I" "COLOR-4S" "COLOR-4UB" "COLOR-4UI" "COLOR-4US" "COLOR-MASK" "COLOR-MATERIAL" "CONVOLUTION-PARAMETER-F" "CONVOLUTION-PARAMETER-I" "COPY-COLOR-SUB-TABLE" "COPY-COLOR-TABLE" "COPY-CONVOLUTION-FILTER-ID" "COPY-CONVOLUTION-FILTER-2D" "COPY-PIXELS" "COPY-TEX-IMAGE-1D" "COPY-TEX-IMAGE-2D" "COPY-TEX-SUB-IMAGE-1D" "COPY-TEX-SUB-IMAGE-2D" "COPY-TEX-SUB-IMAGE-3D" "CULL-FACE" "DEPTH-FUNC" "DEPTH-MASK" "DEPTH-RANGE" "DRAW-BUFFER" "EDGE-FLAG-V" "END" "EVAL-COORD-1D" "EVAL-COORD-1F" "EVAL-COORD-2D" "EVAL-COORD-2F" "EVAL-MESH-1" "EVAL-MESH-2" "EVAL-POINT-1" "EVAL-POINT-2" "FOG-F" "FOG-I" "FRONT-FACE" "FRUSTUM" "HINT" "HISTOGRAM" "INDEX-MASK" "INDEX-D" "INDEX-F" "INDEX-I" "INDEX-S" "INDEX-UB" "INIT-NAMES" "LIGHT-MODEL-F" "LIGHT-MODEL-I" "LIGHT-F" "LIGHT-FV" "LIGHT-I" "LIGHT-IV" "LINE-STIPPLE" "LINE-WIDTH" "LIST-BASE" "LOAD-IDENTITY" "LOAD-NAME" "LOGIC-OP" "MAP-GRID-1D" "MAP-GRID-1F" "MAP-GRID-2D" "MAP-GRID-2F" "MATERIAL-F" "MATERIAL-FV" "MATERIAL-I" "MATERIAL-IV" "MATRIX-MODE" "MINMAX" "MULTI-TEX-COORD-1D-ARB" "MULTI-TEX-COORD-1F-ARB" "MULTI-TEX-COORD-1I-ARB" "MULTI-TEX-COORD-1S-ARB" "MULTI-TEX-COORD-2D-ARB" "MULTI-TEX-COORD-2F-ARB" "MULTI-TEX-COORD-2I-ARB" "MULTI-TEX-COORD-2S-ARB" "MULTI-TEX-COORD-3D-ARB" "MULTI-TEX-COORD-3F-ARB" "MULTI-TEX-COORD-3I-ARB" "MULTI-TEX-COORD-3S-ARB" "MULTI-TEX-COORD-4D-ARB" "MULTI-TEX-COORD-4F-ARB" "MULTI-TEX-COORD-4I-ARB" "MULTI-TEX-COORD-4S-ARB" "NORMAL-3B" "NORMAL-3D" "NORMAL-3F" "NORMAL-3I" "NORMAL-3S" "ORTHO" "PASS-THROUGH" "PIXEL-TRANSFER-F" "PIXEL-TRANSFER-I" "PIXEL-ZOOM" "POINT-SIZE" "POLYGON-MODE" "POLYGON-OFFSET" "POP-ATTRIB" "POP-MATRIX" "POP-NAME" "PUSH-ATTRIB" "PUSH-MATRIX" "PUSH-NAME" "RASTER-POS-2D" "RASTER-POS-2F" "RASTER-POS-2I" "RASTER-POS-2S" "RASTER-POS-3D" "RASTER-POS-3F" "RASTER-POS-3I" "RASTER-POS-3S" "RASTER-POS-4D" "RASTER-POS-4F" "RASTER-POS-4I" "RASTER-POS-4S" "READ-BUFFER" "RECT-D" "RECT-F" "RECT-I" "RECT-S" "RESET-HISTOGRAM" "RESET-MINMAX" "ROTATE-D" "ROTATE-F" "SCALE-D" "SCALE-F" "SCISSOR" "SHADE-MODEL" "STENCIL-FUNC" "STENCIL-MASK" "STENCIL-OP" "TEX-ENV-F" "TEX-ENV-I" "TEX-GEN-D" "TEX-GEN-F" "TEX-GEN-I" "TEX-PARAMETER-F" "TEX-PARAMETER-I" "TRANSLATE-D" "TRANSLATE-F" "VERTEX-2D" "VERTEX-2F" "VERTEX-2I" "VERTEX-2S" "VERTEX-3D" "VERTEX-3F" "VERTEX-3I" "VERTEX-3S" "VERTEX-4D" "VERTEX-4F" "VERTEX-4I" "VERTEX-4S" "VIEWPORT" ;; * Where did this come from? ;;"NO-FLOATS" ;; Non-rendering commands "NEW-LIST" "END-LIST" "GEN-LISTS" "ENABLE" "DISABLE" "FLUSH" "FINISH" ;; Constants ;; Boolean "+FALSE+" "+TRUE+" ;; Types "+BYTE+" "+UNSIGNED-BYTE+" "+SHORT+" "+UNSIGNED-SHORT+" "+INT+" "+UNSIGNED-INT+" "+FLOAT+" "+DOUBLE+" "+2-BYTES+" "+3-BYTES+" "+4-BYTES+" ;; Primitives "+POINTS+" "+LINES+" "+LINE-LOOP+" "+LINE-STRIP+" "+TRIANGLES+" "+TRIANGLE-STRIP+" "+triangle-fan+" "+QUADS+" "+QUAD-STRIP+" "+POLYGON+" ;; Arrays "+VERTEX-ARRAY+" "+NORMAL-ARRAY+" "+COLOR-ARRAY+" "+INDEX-ARRAY+" "+TEXTURE-COORD-ARRAY+" "+EDGE-FLAG-ARRAY+" "+VERTEX-ARRAY-SIZE+" "+VERTEX-ARRAY-TYPE+" "+VERTEX-ARRAY-STRIDE+" "+NORMAL-ARRAY-TYPE+" "+NORMAL-ARRAY-STRIDE+" "+COLOR-ARRAY-SIZE+" "+COLOR-ARRAY-TYPE+" "+COLOR-ARRAY-STRIDE+" "+INDEX-ARRAY-TYPE+" "+INDEX-ARRAY-STRIDE+" "+TEXTURE-COORD-ARRAY-SIZE+" "+TEXTURE-COORD-ARRAY-TYPE+" "+TEXTURE-COORD-ARRAY-STRIDE+" "+EDGE-FLAG-ARRAY-STRIDE+" "+VERTEX-ARRAY-POINTER+" "+NORMAL-ARRAY-POINTER+" "+COLOR-ARRAY-POINTER+" "+INDEX-ARRAY-POINTER+" "+TEXTURE-COORD-ARRAY-POINTER+" "+EDGE-FLAG-ARRAY-POINTER+" ;; Array formats "+V2F+" "+V3F+" "+C4UB-V2F+" "+C4UB-V3F+" "+C3F-V3F+" "+N3F-V3F+" "+C4F-N3F-V3F+" "+T2F-V3F+" "+T4F-V4F+" "+T2F-C4UB-V3F+" "+T2F-C3F-V3F+" "+T2F-N3F-V3F+" "+T2F-C4F-N3F-V3F+" "+T4F-C4F-N3F-V4F+" ;; Matrices "+MATRIX-MODE+" "+MODELVIEW+" "+PROJECTION+" "+TEXTURE+" ;; Points "+POINT-SMOOTH+" "+POINT-SIZE+" "+POINT-SIZE-GRANULARITY+" "+POINT-SIZE-RANGE+" ;; Lines "+LINE-SMOOTH+" "+LINE-STIPPLE+" "+LINE-STIPPLE-PATTERN+" "+LINE-STIPPLE-REPEAT+" "+LINE-WIDTH+" "+LINE-WIDTH-GRANULARITY+" "+LINE-WIDTH-RANGE+" ;; Polygons "+POINT+" "+LINE+" "+FILL+" "+CW+" "+CCW+" "+FRONT+" "+BACK+" "+POLYGON-MODE+" "+POLYGON-SMOOTH+" "+POLYGON-STIPPLE+" "+EDGE-FLAG+" "+CULL-FACE+" "+CULL-FACE-MODE+" "+FRONT-FACE+" "+POLYGON-OFFSET-FACTOR+" "+POLYGON-OFFSET-UNITS+" "+POLYGON-OFFSET-POINT+" "+POLYGON-OFFSET-LINE+" "+POLYGON-OFFSET-FILL+" ;; Display Lists "+COMPILE+" "+COMPILE-AND-EXECUTE+" "+LIST-BASE+" "+LIST-INDEX+" "+LIST-MODE+" ;; Depth Buffer "+NEVER+" "+LESS+" "+EQUAL+" "+LEQUAL+" "+GREATER+" "+NOTEQUAL+" "+GEQUAL+" "+ALWAYS+" "+DEPTH-TEST+" "+DEPTH-BITS+" "+DEPTH-CLEAR-VALUE+" "+DEPTH-FUNC+" "+DEPTH-RANGE+" "+DEPTH-WRITEMASK+" "+DEPTH-COMPONENT+" ;; Lighting "+LIGHTING+" "+LIGHT0+" "+LIGHT1+" "+LIGHT2+" "+LIGHT3+" "+LIGHT4+" "+LIGHT5+" "+LIGHT6+" "+LIGHT7+" "+SPOT-EXPONENT+" "+SPOT-CUTOFF+" "+CONSTANT-ATTENUATION+" "+LINEAR-ATTENUATION+" "+QUADRATIC-ATTENUATION+" "+AMBIENT+" "+DIFFUSE+" "+SPECULAR+" "+SHININESS+" "+EMISSION+" "+POSITION+" "+SPOT-DIRECTION+" "+AMBIENT-AND-DIFFUSE+" "+COLOR-INDEXES+" "+LIGHT-MODEL-TWO-SIDE+" "+LIGHT-MODEL-LOCAL-VIEWER+" "+LIGHT-MODEL-AMBIENT+" "+FRONT-AND-BACK+" "+SHADE-MODEL+" "+FLAT+" "+SMOOTH+" "+COLOR-MATERIAL+" "+COLOR-MATERIAL-FACE+" "+COLOR-MATERIAL-PARAMETER+" "+NORMALIZE+" ;; Clipping planes "+CLIP-PLANE0+" "+CLIP-PLANE1+" "+CLIP-PLANE2+" "+CLIP-PLANE3+" "+CLIP-PLANE4+" "+CLIP-PLANE5+" ;; Accumulation buffer "+ACCUM-RED-BITS+" "+ACCUM-GREEN-BITS+" "+ACCUM-BLUE-BITS+" "+ACCUM-ALPHA-BITS+" "+ACCUM-CLEAR-VALUE+" "+ACCUM+" "+ADD+" "+LOAD+" "+MULT+" "+RETURN+" ;; Alpha Testing "+ALPHA-TEST+" "+ALPHA-TEST-REF+" "+ALPHA-TEST-FUNC+" ;; Blending "+BLEND+" "+BLEND-SRC+" "+BLEND-DST+" "+ZERO+" "+ONE+" "+SRC-COLOR+" "+ONE-MINUS-SRC-COLOR+" "+DST-COLOR+" "+ONE-MINUS-DST-COLOR+" "+SRC-ALPHA+" "+ONE-MINUS-SRC-ALPHA+" "+DST-ALPHA+" "+ONE-MINUS-DST-ALPHA+" "+SRC-ALPHA-SATURATE+" "+CONSTANT-COLOR+" "+ONE-MINUS-CONSTANT-COLOR+" "+CONSTANT-ALPHA+" "+ONE-MINUS-CONSTANT-ALPHA+" ;; Render mode "+FEEDBACK+" "+RENDER+" "+SELECT+" ;; Feedback "+2D+" "+3D+" "+3D-COLOR+" "+3D-COLOR-TEXTURE+" "+4D-COLOR-TEXTURE+" "+POINT-TOKEN+" "+LINE-TOKEN+" "+LINE-RESET-TOKEN+" "+POLYGON-TOKEN+" "+BITMAP-TOKEN+" "+DRAW-PIXEL-TOKEN+" "+COPY-PIXEL-TOKEN+" "+PASS-THROUGH-TOKEN+" "+FEEDBACK-BUFFER-POINTER+" "+FEEDBACK-BUFFER-SIZE+" "+FEEDBACK-BUFFER-TYPE+" ;; Selection "+SELECTION-BUFFER-POINTER+" "+SELECTION-BUFFER-SIZE+" ;; Fog "+FOG+" "+FOG-MODE+" "+FOG-DENSITY+" "+FOG-COLOR+" "+FOG-INDEX+" "+FOG-START+" "+FOG-END+" "+LINEAR+" "+EXP+" "+EXP2+" ;; Logic operations "+LOGIC-OP+" "+INDEX-LOGIC-OP+" "+COLOR-LOGIC-OP+" "+LOGIC-OP-MODE+" "+CLEAR+" "+SET+" "+COPY+" "+COPY-INVERTED+" "+NOOP+" "+INVERT+" "+AND+" "+NAND+" "+OR+" "+NOR+" "+XOR+" "+EQUIV+" "+AND-REVERSE+" "+AND-INVERTED+" "+OR-REVERSE+" "+OR-INVERTED+" ;; Stencil "+STENCIL-TEST+" "+STENCIL-WRITEMASK+" "+STENCIL-BITS+" "+STENCIL-FUNC+" "+STENCIL-VALUE-MASK+" "+STENCIL-REF+" "+STENCIL-FAIL+" "+STENCIL-PASS-DEPTH-PASS+" "+STENCIL-PASS-DEPTH-FAIL+" "+STENCIL-CLEAR-VALUE+" "+STENCIL-INDEX+" "+KEEP+" "+REPLACE+" "+INCR+" "+DECR+" ;; Buffers, Pixel Drawing/Reading "+NONE+" "+LEFT+" "+RIGHT+" "+FRONT-LEFT+" "+FRONT-RIGHT+" "+BACK-LEFT+" "+BACK-RIGHT+" "+AUX0+" "+AUX1+" "+AUX2+" "+AUX3+" "+COLOR-INDEX+" "+RED+" "+GREEN+" "+BLUE+" "+ALPHA+" "+LUMINANCE+" "+LUMINANCE-ALPHA+" "+ALPHA-BITS+" "+RED-BITS+" "+GREEN-BITS+" "+BLUE-BITS+" "+INDEX-BITS+" "+SUBPIXEL-BITS+" "+AUX-BUFFERS+" "+READ-BUFFER+" "+DRAW-BUFFER+" "+DOUBLEBUFFER+" "+STEREO+" "+BITMAP+" "+COLOR+" "+DEPTH+" "+STENCIL+" "+DITHER+" "+RGB+" "+RGBA+" ;; Implementation Limits "+MAX-LIST-NESTING+" "+MAX-ATTRIB-STACK-DEPTH+" "+MAX-MODELVIEW-STACK-DEPTH+" "+MAX-NAME-STACK-DEPTH+" "+MAX-PROJECTION-STACK-DEPTH+" "+MAX-TEXTURE-STACK-DEPTH+" "+MAX-EVAL-ORDER+" "+MAX-LIGHTS+" "+MAX-CLIP-PLANES+" "+MAX-TEXTURE-SIZE+" "+MAX-PIXEL-MAP-TABLE+" "+MAX-VIEWPORT-DIMS+" "+MAX-CLIENT-ATTRIB-STACK-DEPTH+" ;; Gets "+ATTRIB-STACK-DEPTH+" "+CLIENT-ATTRIB-STACK-DEPTH+" "+COLOR-CLEAR-VALUE+" "+COLOR-WRITEMASK+" "+CURRENT-INDEX+" "+CURRENT-COLOR+" "+CURRENT-NORMAL+" "+CURRENT-RASTER-COLOR+" "+CURRENT-RASTER-DISTANCE+" "+current-raster-index+" "+CURRENT-RASTER-POSITION+" "+CURRENT-RASTER-TEXTURE-COORDS+" "+CURRENT-RASTER-POSITION-VALID+" "+CURRENT-TEXTURE-COORDS+" "+INDEX-CLEAR-VALUE+" "+INDEX-MODE+" "+INDEX-WRITEMASK+" "+MODELVIEW-MATRIX+" "+MODELVIEW-STACK-DEPTH+" "+NAME-STACK-DEPTH+" "+PROJECTION-MATRIX+" "+PROJECTION-STACK-DEPTH+" "+RENDER-MODE+" "+RGBA-MODE+" "+TEXTURE-MATRIX+" "+TEXTURE-STACK-DEPTH+" "+VIEWPORT+" ;; GL Evaluators "+AUTO-NORMAL+" "+MAP1-COLOR-4+" "+MAP1-GRID-DOMAIN+" "+MAP1-GRID-SEGMENTS+" "+MAP1-INDEX+" "+MAP1-NORMAL+" "+MAP1-TEXTURE-COORD-1+" "+MAP1-TEXTURE-COORD-2+" "+MAP1-TEXTURE-COORD-3+" "+MAP1-TEXTURE-COORD-4+" "+MAP1-VERTEX-3+" "+MAP1-VERTEX-4+" "+MAP2-COLOR-4+" "+MAP2-GRID-DOMAIN+" "+MAP2-GRID-SEGMENTS+" "+MAP2-INDEX+" "+MAP2-NORMAL+" "+MAP2-TEXTURE-COORD-1+" "+MAP2-TEXTURE-COORD-2+" "+MAP2-TEXTURE-COORD-3+" "+MAP2-TEXTURE-COORD-4+" "+MAP2-VERTEX-3+" "+MAP2-VERTEX-4+" "+COEFF+" "+DOMAIN+" "+ORDER+" ;; Hints "+FOG-HINT+" "+LINE-SMOOTH-HINT+" "+PERSPECTIVE-CORRECTION-HINT+" "+POINT-SMOOTH-HINT+" "+POLYGON-SMOOTH-HINT+" "+DONT-CARE+" "+FASTEST+" "+NICEST+" ;; Scissor box "+SCISSOR-TEST+" "+SCISSOR-BOX+" ;; Pixel Mode / Transfer "+MAP-COLOR+" "+MAP-STENCIL+" "+INDEX-SHIFT+" "+INDEX-OFFSET+" "+RED-SCALE+" "+RED-BIAS+" "+GREEN-SCALE+" "+GREEN-BIAS+" "+BLUE-SCALE+" "+BLUE-BIAS+" "+ALPHA-SCALE+" "+ALPHA-BIAS+" "+DEPTH-SCALE+" "+DEPTH-BIAS+" "+PIXEL-MAP-S-TO-S-SIZE+" "+PIXEL-MAP-I-TO-I-SIZE+" "+PIXEL-MAP-I-TO-R-SIZE+" "+PIXEL-MAP-I-TO-G-SIZE+" "+PIXEL-MAP-I-TO-B-SIZE+" "+PIXEL-MAP-I-TO-A-SIZE+" "+PIXEL-MAP-R-TO-R-SIZE+" "+PIXEL-MAP-G-TO-G-SIZE+" "+PIXEL-MAP-B-TO-B-SIZE+" "+PIXEL-MAP-A-TO-A-SIZE+" "+PIXEL-MAP-S-TO-S+" "+PIXEL-MAP-I-TO-I+" "+PIXEL-MAP-I-TO-R+" "+PIXEL-MAP-I-TO-G+" "+PIXEL-MAP-I-TO-B+" "+PIXEL-MAP-I-TO-A+" "+PIXEL-MAP-R-TO-R+" "+PIXEL-MAP-G-TO-G+" "+PIXEL-MAP-B-TO-B+" "+PIXEL-MAP-A-TO-A+" "+PACK-ALIGNMENT+" "+PACK-LSB-FIRST+" "+PACK-ROW-LENGTH+" "+PACK-SKIP-PIXELS+" "+PACK-SKIP-ROWS+" "+PACK-SWAP-BYTES+" "+UNPACK-ALIGNMENT+" "+UNPACK-LSB-FIRST+" "+UNPACK-ROW-LENGTH+" "+UNPACK-SKIP-PIXELS+" "+UNPACK-SKIP-ROWS+" "+UNPACK-SWAP-BYTES+" "+ZOOM-X+" "+ZOOM-Y+" ;; Texture Mapping "+TEXTURE-ENV+" "+TEXTURE-ENV-MODE+" "+TEXTURE-1D+" "+TEXTURE-2D+" "+TEXTURE-WRAP-S+" "+TEXTURE-WRAP-T+" "+TEXTURE-MAG-FILTER+" "+TEXTURE-MIN-FILTER+" "+TEXTURE-ENV-COLOR+" "+TEXTURE-GEN-S+" "+TEXTURE-GEN-T+" "+TEXTURE-GEN-MODE+" "+TEXTURE-BORDER-COLOR+" "+TEXTURE-WIDTH+" "+TEXTURE-HEIGHT+" "+TEXTURE-BORDER+" "+TEXTURE-COMPONENTS+" "+TEXTURE-RED-SIZE+" "+TEXTURE-GREEN-SIZE+" "+TEXTURE-BLUE-SIZE+" "+TEXTURE-ALPHA-SIZE+" "+TEXTURE-LUMINANCE-SIZE+" "+TEXTURE-INTENSITY-SIZE+" "+NEAREST-MIPMAP-NEAREST+" "+NEAREST-MIPMAP-LINEAR+" "+LINEAR-MIPMAP-NEAREST+" "+LINEAR-MIPMAP-LINEAR+" "+OBJECT-LINEAR+" "+OBJECT-PLANE+" "+EYE-LINEAR+" "+EYE-PLANE+" "+SPHERE-MAP+" "+DECAL+" "+MODULATE+" "+NEAREST+" "+REPEAT+" "+CLAMP+" "+S+" "+T+" "+R+" "+Q+" "+TEXTURE-GEN-R+" "+TEXTURE-GEN-Q+" ;; GL 1.1 Texturing "+PROXY-TEXTURE-1D+" "+PROXY-TEXTURE-2D+" "+TEXTURE-PRIORITY+" "+TEXTURE-RESIDENT+" "+TEXTURE-BINDING-1D+" "+TEXTURE-BINDING-2D+" "+TEXTURE-INTERNAL-FORMAT+" "+PACK-SKIP-IMAGES+" "+PACK-IMAGE-HEIGHT+" "+UNPACK-SKIP-IMAGES+" "+UNPACK-IMAGE-HEIGHT+" "+TEXTURE-3D+" "+PROXY-TEXTURE-3D+" "+TEXTURE-DEPTH+" "+TEXTURE-WRAP-R+" "+MAX-3D-TEXTURE-SIZE+" "+TEXTURE-BINDING-3D+" ;; Internal texture formats (GL 1.1) "+ALPHA4+" "+ALPHA8+" "+ALPHA12+" "+ALPHA16+" "+LUMINANCE4+" "+LUMINANCE8+" "+LUMINANCE12+" "+LUMINANCE16+" "+LUMINANCE4-ALPHA4+" "+LUMINANCE6-ALPHA2+" "+LUMINANCE8-ALPHA8+" "+LUMINANCE12-ALPHA4+" "+LUMINANCE12-ALPHA12+" "+LUMINANCE16-ALPHA16+" "+INTENSITY+" "+INTENSITY4+" "+INTENSITY8+" "+INTENSITY12+" "+INTENSITY16+" "+R3-G3-B2+" "+RGB4+" "+RGB5+" "+RGB8+" "+RGB10+" "+RGB12+" "+RGB16+" "+RGBA2+" "+RGBA4+" "+RGB5-A1+" "+RGBA8+" "+rgb10-a2+" "+RGBA12+" "+RGBA16+" ;; Utility "+VENDOR+" "+RENDERER+" "+VERSION+" "+EXTENSIONS+" ;; Errors "+NO-ERROR+" "+INVALID-VALUE+" "+INVALID-ENUM+" "+INVALID-OPERATION+" "+STACK-OVERFLOW+" "+STACK-UNDERFLOW+" "+OUT-OF-MEMORY+" ;; OpenGL 1.2 "+RESCALE-NORMAL+" "+CLAMP-TO-EDGE+" "+MAX-ELEMENTS-VERTICES+" "+MAX-ELEMENTS-INDICES+" "+BGR+" "+BGRA+" "+UNSIGNED-BYTE-3-3-2+" "+UNSIGNED-BYTE-2-3-3-REV+" "+UNSIGNED-SHORT-5-6-5+" "+UNSIGNED-SHORT-5-6-5-REV+" "+UNSIGNED-SHORT-4-4-4-4+" "+UNSIGNED-SHORT-4-4-4-4-REV+" "+UNSIGNED-SHORT-5-5-5-1+" "+UNSIGNED-SHORT-1-5-5-5-REV+" "+UNSIGNED-INT-8-8-8-8+" "+UNSIGNED-INT-8-8-8-8-REV+" "+UNSIGNED-INT-10-10-10-2+" "+UNSIGNED-INT-2-10-10-10-REV+" "+LIGHT-MODEL-COLOR-CONTROL+" "+SINGLE-COLOR+" "+SEPARATE-SPECULAR-COLOR+" "+TEXTURE-MIN-LOD+" "+TEXTURE-MAX-LOD+" "+TEXTURE-BASE-LEVEL+" "+TEXTURE-MAX-LEVEL+" "+SMOOTH-POINT-SIZE-RANGE+" "+SMOOTH-POINT-SIZE-GRANULARITY+" "+SMOOTH-LINE-WIDTH-RANGE+" "+SMOOTH-LINE-WIDTH-GRANULARITY+" "+ALIASED-POINT-SIZE-RANGE+" "+ALIASED-LINE-WIDTH-RANGE+" ;; OpenGL 1.2 Imaging subset ;; GL_EXT_color_table "+COLOR-TABLE+" "+POST-CONVOLUTION-COLOR-TABLE+" "+POST-COLOR-MATRIX-COLOR-TABLE+" "+PROXY-COLOR-TABLE+" "+PROXY-POST-CONVOLUTION-COLOR-TABLE+" "+PROXY-POST-COLOR-MATRIX-COLOR-TABLE+" "+COLOR-TABLE-SCALE+" "+COLOR-TABLE-BIAS+" "+COLOR-TABLE-FORMAT+" "+COLOR-TABLE-WIDTH+" "+COLOR-TABLE-RED-SIZE+" "+COLOR-TABLE-GREEN-SIZE+" "+COLOR-TABLE-BLUE-SIZE+" "+COLOR-TABLE-ALPHA-SIZE+" "+COLOR-TABLE-LUMINANCE-SIZE+" "+COLOR-TABLE-INTENSITY-SIZE+" ;; GL_EXT_convolution and GL_HP_convolution "+CONVOLUTION-1D+" "+CONVOLUTION-2D+" "+SEPARABLE-2D+" "+CONVOLUTION-BORDER-MODE+" "+CONVOLUTION-FILTER-SCALE+" "+CONVOLUTION-FILTER-BIAS+" "+REDUCE+" "+CONVOLUTION-FORMAT+" "+CONVOLUTION-WIDTH+" "+CONVOLUTION-HEIGHT+" "+MAX-CONVOLUTION-WIDTH+" "+MAX-CONVOLUTION-HEIGHT+" "+POST-CONVOLUTION-RED-SCALE+" "+POST-CONVOLUTION-GREEN-SCALE+" "+POST-CONVOLUTION-BLUE-SCALE+" "+POST-CONVOLUTION-ALPHA-SCALE+" "+POST-CONVOLUTION-RED-BIAS+" "+POST-CONVOLUTION-GREEN-BIAS+" "+POST-CONVOLUTION-BLUE-BIAS+" "+POST-CONVOLUTION-ALPHA-BIAS+" "+CONSTANT-BORDER+" "+REPLICATE-BORDER+" "+CONVOLUTION-BORDER-COLOR+" ;; GL_SGI_color_matrix "+COLOR-MATRIX+" "+COLOR-MATRIX-STACK-DEPTH+" "+MAX-COLOR-MATRIX-STACK-DEPTH+" "+POST-COLOR-MATRIX-RED-SCALE+" "+POST-COLOR-MATRIX-GREEN-SCALE+" "+POST-COLOR-MATRIX-BLUE-SCALE+" "+POST-COLOR-MATRIX-ALPHA-SCALE+" "+POST-COLOR-MATRIX-RED-BIAS+" "+POST-COLOR-MATRIX-GREEN-BIAS+" "+POST-COLOR-MATRIX-BLUE-BIAS+" "+POST-COLOR-MATRIX-ALPHA-BIAS+" ;; GL_EXT_histogram "+HISTOGRAM+" "+PROXY-HISTOGRAM+" "+HISTOGRAM-WIDTH+" "+HISTOGRAM-FORMAT+" "+HISTOGRAM-RED-SIZE+" "+HISTOGRAM-GREEN-SIZE+" "+HISTOGRAM-BLUE-SIZE+" "+HISTOGRAM-ALPHA-SIZE+" "+HISTOGRAM-LUMINANCE-SIZE+" "+HISTOGRAM-SINK+" "+MINMAX+" "+MINMAX-FORMAT+" "+MINMAX-SINK+" "+TABLE-TOO-LARGE+" ;; GL_EXT_blend_color, GL_EXT_blend_minmax "+BLEND-EQUATION+" "+MIN+" "+MAX+" "+FUNC-ADD+" "+FUNC-SUBTRACT+" "+FUNC-REVERSE-SUBTRACT+" ;; glPush/PopAttrib bits "+CURRENT-BIT+" "+POINT-BIT+" "+LINE-BIT+" "+POLYGON-BIT+" "+POLYGON-STIPPLE-BIT+" "+PIXEL-MODE-BIT+" "+LIGHTING-BIT+" "+FOG-BIT+" "+DEPTH-BUFFER-BIT+" "+ACCUM-BUFFER-BIT+" "+STENCIL-BUFFER-BIT+" "+VIEWPORT-BIT+" "+TRANSFORM-BIT+" "+ENABLE-BIT+" "+COLOR-BUFFER-BIT+" "+HINT-BIT+" "+EVAL-BIT+" "+LIST-BIT+" "+TEXTURE-BIT+" "+SCISSOR-BIT+" "+ALL-ATTRIB-BITS+" "+CLIENT-PIXEL-STORE-BIT+" "+CLIENT-VERTEX-ARRAY-BIT+" "+CLIENT-ALL-ATTRIB-BITS+" ;; ARB Multitexturing extension "+ARB-MULTITEXTURE+" "+TEXTURE0-ARB+" "+TEXTURE1-ARB+" "+TEXTURE2-ARB+" "+TEXTURE3-ARB+" "+TEXTURE4-ARB+" "+TEXTURE5-ARB+" "+TEXTURE6-ARB+" "+TEXTURE7-ARB+" "+TEXTURE8-ARB+" "+TEXTURE9-ARB+" "+TEXTURE10-ARB+" "+TEXTURE11-ARB+" "+TEXTURE12-ARB+" "+TEXTURE13-ARB+" "+TEXTURE14-ARB+" "+TEXTURE15-ARB+" "+TEXTURE16-ARB+" "+TEXTURE17-ARB+" "+TEXTURE18-ARB+" "+TEXTURE19-ARB+" "+TEXTURE20-ARB+" "+TEXTURE21-ARB+" "+TEXTURE22-ARB+" "+TEXTURE23-ARB+" "+TEXTURE24-ARB+" "+TEXTURE25-ARB+" "+TEXTURE26-ARB+" "+TEXTURE27-ARB+" "+TEXTURE28-ARB+" "+TEXTURE29-ARB+" "+TEXTURE30-ARB+" "+TEXTURE31-ARB+" "+ACTIVE-TEXTURE-ARB+" "+CLIENT-ACTIVE-TEXTURE-ARB+" "+MAX-TEXTURE-UNITS-ARB+" ;;; Misc extensions "+EXT-ABGR+" "+ABGR-EXT+" "+EXT-BLEND-COLOR+" "+CONSTANT-COLOR-EXT+" "+ONE-MINUS-CONSTANT-COLOR-EXT+" "+CONSTANT-ALPHA-EXT+" "+ONE-MINUS-CONSTANT-ALPHA-EXT+" "+blend-color-ext+" "+EXT-POLYGON-OFFSET+" "+POLYGON-OFFSET-EXT+" "+POLYGON-OFFSET-FACTOR-EXT+" "+POLYGON-OFFSET-BIAS-EXT+" "+EXT-TEXTURE3D+" "+PACK-SKIP-IMAGES-EXT+" "+PACK-IMAGE-HEIGHT-EXT+" "+UNPACK-SKIP-IMAGES-EXT+" "+UNPACK-IMAGE-HEIGHT-EXT+" "+TEXTURE-3D-EXT+" "+PROXY-TEXTURE-3D-EXT+" "+TEXTURE-DEPTH-EXT+" "+TEXTURE-WRAP-R-EXT+" "+MAX-3D-TEXTURE-SIZE-EXT+" "+TEXTURE-3D-BINDING-EXT+" "+EXT-TEXTURE-OBJECT+" "+TEXTURE-PRIORITY-EXT+" "+TEXTURE-RESIDENT-EXT+" "+TEXTURE-1D-BINDING-EXT+" "+TEXTURE-2D-BINDING-EXT+" "+EXT-RESCALE-NORMAL+" "+RESCALE-NORMAL-EXT+" "+EXT-VERTEX-ARRAY+" "+VERTEX-ARRAY-EXT+" "+NORMAL-ARRAY-EXT+" "+COLOR-ARRAY-EXT+" "+INDEX-ARRAY-EXT+" "+TEXTURE-COORD-ARRAY-EXT+" "+EDGE-FLAG-ARRAY-EXT+" "+VERTEX-ARRAY-SIZE-EXT+" "+VERTEX-ARRAY-TYPE-EXT+" "+VERTEX-ARRAY-STRIDE-EXT+" "+VERTEX-ARRAY-COUNT-EXT+" "+NORMAL-ARRAY-TYPE-EXT+" "+NORMAL-ARRAY-STRIDE-EXT+" "+NORMAL-ARRAY-COUNT-EXT+" "+COLOR-ARRAY-SIZE-EXT+" "+COLOR-ARRAY-TYPE-EXT+" "+COLOR-ARRAY-STRIDE-EXT+" "+COLOR-ARRAY-COUNT-EXT+" "+INDEX-ARRAY-TYPE-EXT+" "+INDEX-ARRAY-STRIDE-EXT+" "+INDEX-ARRAY-COUNT-EXT+" "+TEXTURE-COORD-ARRAY-SIZE-EXT+" "+TEXTURE-COORD-ARRAY-TYPE-EXT+" "+TEXTURE-COORD-ARRAY-STRIDE-EXT+" "+TEXTURE-COORD-ARRAY-COUNT-EXT+" "+EDGE-FLAG-ARRAY-STRIDE-EXT+" "+EDGE-FLAG-ARRAY-COUNT-EXT+" "+VERTEX-ARRAY-POINTER-EXT+" "+NORMAL-ARRAY-POINTER-EXT+" "+COLOR-ARRAY-POINTER-EXT+" "+INDEX-ARRAY-POINTER-EXT+" "+TEXTURE-COORD-ARRAY-POINTER-EXT+" "+EDGE-FLAG-ARRAY-POINTER-EXT+" "+SGIS-TEXTURE-EDGE-CLAMP+" "+CLAMP-TO-EDGE-SGIS+" "+EXT-BLEND-MINMAX+" "+FUNC-ADD-EXT+" "+MIN-EXT+" "+MAX-EXT+" "+BLEND-EQUATION-EXT+" "+EXT-BLEND-SUBTRACT+" "+FUNC-SUBTRACT-EXT+" "+FUNC-REVERSE-SUBTRACT-EXT+" "+EXT-BLEND-LOGIC-OP+" "+EXT-POINT-PARAMETERS+" "+POINT-SIZE-MIN-EXT+" "+POINT-SIZE-MAX-EXT+" "+POINT-FADE-THRESHOLD-SIZE-EXT+" "+DISTANCE-ATTENUATION-EXT+" "+EXT-PALETTED-TEXTURE+" "+TABLE-TOO-LARGE-EXT+" "+COLOR-TABLE-FORMAT-EXT+" "+COLOR-TABLE-WIDTH-EXT+" "+COLOR-TABLE-RED-SIZE-EXT+" "+COLOR-TABLE-GREEN-SIZE-EXT+" "+COLOR-TABLE-BLUE-SIZE-EXT+" "+COLOR-TABLE-ALPHA-SIZE-EXT+" "+COLOR-TABLE-LUMINANCE-SIZE-EXT+" "+COLOR-TABLE-INTENSITY-SIZE-EXT+" "+TEXTURE-INDEX-SIZE-EXT+" "+COLOR-INDEX1-EXT+" "+COLOR-INDEX2-EXT+" "+COLOR-INDEX4-EXT+" "+COLOR-INDEX8-EXT+" "+COLOR-INDEX12-EXT+" "+COLOR-INDEX16-EXT+" "+EXT-CLIP-VOLUME-HINT+" "+CLIP-VOLUME-CLIPPING-HINT-EXT+" "+EXT-COMPILED-VERTEX-ARRAY+" "+ARRAY-ELEMENT-LOCK-FIRST-EXT+" "+ARRAY-ELEMENT-LOCK-COUNT-EXT+" "+HP-OCCLUSION-TEST+" "+OCCLUSION-TEST-HP+" "+OCCLUSION-TEST-RESULT-HP+" "+EXT-SHARED-TEXTURE-PALETTE+" "+SHARED-TEXTURE-PALETTE-EXT+" "+EXT-STENCIL-WRAP+" "+INCR-WRAP-EXT+" "+DECR-WRAP-EXT+" "+NV-TEXGEN-REFLECTION+" "+NORMAL-MAP-NV+" "+REFLECTION-MAP-NV+" "+EXT-TEXTURE-ENV-ADD+" "+MESA-WINDOW-POS+" "+MESA-RESIZE-BUFFERS+" )) (in-package :gl) ;;; Opcodes. (eval-when (:compile-toplevel :load-toplevel :execute) (defconstant +get-string+ 129) (defconstant +new-list+ 101) (defconstant +end-list+ 102) (defconstant +gen-lists+ 104) (defconstant +finish+ 108) (defconstant +disable+ 138) (defconstant +enable+ 139) (defconstant +flush+ 142) ;;; Constants. ;;; Shamelessly taken from CL-SDL. ;; Boolean (defconstant +false+ #x0) (defconstant +true+ #x1) ;; Types (defconstant +byte+ #x1400) (defconstant +unsigned-byte+ #x1401) (defconstant +short+ #x1402) (defconstant +unsigned-short+ #x1403) (defconstant +int+ #x1404) (defconstant +unsigned-int+ #x1405) (defconstant +float+ #x1406) (defconstant +double+ #x140a) (defconstant +2-bytes+ #x1407) (defconstant +3-bytes+ #x1408) (defconstant +4-bytes+ #x1409) ;; Primitives (defconstant +points+ #x0000) (defconstant +lines+ #x0001) (defconstant +line-loop+ #x0002) (defconstant +line-strip+ #x0003) (defconstant +triangles+ #x0004) (defconstant +triangle-strip+ #x0005) (defconstant +triangle-fan+ #x0006) (defconstant +quads+ #x0007) (defconstant +quad-strip+ #x0008) (defconstant +polygon+ #x0009) ;; Arrays (defconstant +vertex-array+ #x8074) (defconstant +normal-array+ #x8075) (defconstant +color-array+ #x8076) (defconstant +index-array+ #x8077) (defconstant +texture-coord-array+ #x8078) (defconstant +edge-flag-array+ #x8079) (defconstant +vertex-array-size+ #x807a) (defconstant +vertex-array-type+ #x807b) (defconstant +vertex-array-stride+ #x807c) (defconstant +normal-array-type+ #x807e) (defconstant +normal-array-stride+ #x807f) (defconstant +color-array-size+ #x8081) (defconstant +color-array-type+ #x8082) (defconstant +color-array-stride+ #x8083) (defconstant +index-array-type+ #x8085) (defconstant +index-array-stride+ #x8086) (defconstant +texture-coord-array-size+ #x8088) (defconstant +texture-coord-array-type+ #x8089) (defconstant +texture-coord-array-stride+ #x808a) (defconstant +edge-flag-array-stride+ #x808c) (defconstant +vertex-array-pointer+ #x808e) (defconstant +normal-array-pointer+ #x808f) (defconstant +color-array-pointer+ #x8090) (defconstant +index-array-pointer+ #x8091) (defconstant +texture-coord-array-pointer+ #x8092) (defconstant +edge-flag-array-pointer+ #x8093) ;; Array formats (defconstant +v2f+ #x2a20) (defconstant +v3f+ #x2a21) (defconstant +c4ub-v2f+ #x2a22) (defconstant +c4ub-v3f+ #x2a23) (defconstant +c3f-v3f+ #x2a24) (defconstant +n3f-v3f+ #x2a25) (defconstant +c4f-n3f-v3f+ #x2a26) (defconstant +t2f-v3f+ #x2a27) (defconstant +t4f-v4f+ #x2a28) (defconstant +t2f-c4ub-v3f+ #x2a29) (defconstant +t2f-c3f-v3f+ #x2a2a) (defconstant +t2f-n3f-v3f+ #x2a2b) (defconstant +t2f-c4f-n3f-v3f+ #x2a2c) (defconstant +t4f-c4f-n3f-v4f+ #x2a2d) ;; Matrices (defconstant +matrix-mode+ #x0ba0) (defconstant +modelview+ #x1700) (defconstant +projection+ #x1701) (defconstant +texture+ #x1702) ;; Points (defconstant +point-smooth+ #x0b10) (defconstant +point-size+ #x0b11) (defconstant +point-size-granularity+ #x0b13) (defconstant +point-size-range+ #x0b12) ;; Lines (defconstant +line-smooth+ #x0b20) (defconstant +line-stipple+ #x0b24) (defconstant +line-stipple-pattern+ #x0b25) (defconstant +line-stipple-repeat+ #x0b26) (defconstant +line-width+ #x0b21) (defconstant +line-width-granularity+ #x0b23) (defconstant +line-width-range+ #x0b22) ;; Polygons (defconstant +point+ #x1b00) (defconstant +line+ #x1b01) (defconstant +fill+ #x1b02) (defconstant +cw+ #x0900) (defconstant +ccw+ #x0901) (defconstant +front+ #x0404) (defconstant +back+ #x0405) (defconstant +polygon-mode+ #x0b40) (defconstant +polygon-smooth+ #x0b41) (defconstant +polygon-stipple+ #x0b42) (defconstant +edge-flag+ #x0b43) (defconstant +cull-face+ #x0b44) (defconstant +cull-face-mode+ #x0b45) (defconstant +front-face+ #x0b46) (defconstant +polygon-offset-factor+ #x8038) (defconstant +polygon-offset-units+ #x2a00) (defconstant +polygon-offset-point+ #x2a01) (defconstant +polygon-offset-line+ #x2a02) (defconstant +polygon-offset-fill+ #x8037) ;; Display Lists (defconstant +compile+ #x1300) (defconstant +compile-and-execute+ #x1301) (defconstant +list-base+ #x0b32) (defconstant +list-index+ #x0b33) (defconstant +list-mode+ #x0b30) ;; Depth Buffer (defconstant +never+ #x0200) (defconstant +less+ #x0201) (defconstant +equal+ #x0202) (defconstant +lequal+ #x0203) (defconstant +greater+ #x0204) (defconstant +notequal+ #x0205) (defconstant +gequal+ #x0206) (defconstant +always+ #x0207) (defconstant +depth-test+ #x0b71) (defconstant +depth-bits+ #x0d56) (defconstant +depth-clear-value+ #x0b73) (defconstant +depth-func+ #x0b74) (defconstant +depth-range+ #x0b70) (defconstant +depth-writemask+ #x0b72) (defconstant +depth-component+ #x1902) ;; Lighting (defconstant +lighting+ #x0b50) (defconstant +light0+ #x4000) (defconstant +light1+ #x4001) (defconstant +light2+ #x4002) (defconstant +light3+ #x4003) (defconstant +light4+ #x4004) (defconstant +light5+ #x4005) (defconstant +light6+ #x4006) (defconstant +light7+ #x4007) (defconstant +spot-exponent+ #x1205) (defconstant +spot-cutoff+ #x1206) (defconstant +constant-attenuation+ #x1207) (defconstant +linear-attenuation+ #x1208) (defconstant +quadratic-attenuation+ #x1209) (defconstant +ambient+ #x1200) (defconstant +diffuse+ #x1201) (defconstant +specular+ #x1202) (defconstant +shininess+ #x1601) (defconstant +emission+ #x1600) (defconstant +position+ #x1203) (defconstant +spot-direction+ #x1204) (defconstant +ambient-and-diffuse+ #x1602) (defconstant +color-indexes+ #x1603) (defconstant +light-model-two-side+ #x0b52) (defconstant +light-model-local-viewer+ #x0b51) (defconstant +light-model-ambient+ #x0b53) (defconstant +front-and-back+ #x0408) (defconstant +shade-model+ #x0b54) (defconstant +flat+ #x1d00) (defconstant +smooth+ #x1d01) (defconstant +color-material+ #x0b57) (defconstant +color-material-face+ #x0b55) (defconstant +color-material-parameter+ #x0b56) (defconstant +normalize+ #x0ba1) ;; Clipping planes (defconstant +clip-plane0+ #x3000) (defconstant +clip-plane1+ #x3001) (defconstant +clip-plane2+ #x3002) (defconstant +clip-plane3+ #x3003) (defconstant +clip-plane4+ #x3004) (defconstant +clip-plane5+ #x3005) ;; Accumulation buffer (defconstant +accum-red-bits+ #x0d58) (defconstant +accum-green-bits+ #x0d59) (defconstant +accum-blue-bits+ #x0d5a) (defconstant +accum-alpha-bits+ #x0d5b) (defconstant +accum-clear-value+ #x0b80) (defconstant +accum+ #x0100) (defconstant +add+ #x0104) (defconstant +load+ #x0101) (defconstant +mult+ #x0103) (defconstant +return+ #x0102) ;; Alpha Testing (defconstant +alpha-test+ #x0bc0) (defconstant +alpha-test-ref+ #x0bc2) (defconstant +alpha-test-func+ #x0bc1) ;; Blending (defconstant +blend+ #x0be2) (defconstant +blend-src+ #x0be1) (defconstant +blend-dst+ #x0be0) (defconstant +zero+ #x0) (defconstant +one+ #x1) (defconstant +src-color+ #x0300) (defconstant +one-minus-src-color+ #x0301) (defconstant +dst-color+ #x0306) (defconstant +one-minus-dst-color+ #x0307) (defconstant +src-alpha+ #x0302) (defconstant +one-minus-src-alpha+ #x0303) (defconstant +dst-alpha+ #x0304) (defconstant +one-minus-dst-alpha+ #x0305) (defconstant +src-alpha-saturate+ #x0308) (defconstant +constant-color+ #x8001) (defconstant +one-minus-constant-color+ #x8002) (defconstant +constant-alpha+ #x8003) (defconstant +one-minus-constant-alpha+ #x8004) ;; Render mode (defconstant +feedback+ #x1c01) (defconstant +render+ #x1c00) (defconstant +select+ #x1c02) ;; Feedback (defconstant +2d+ #x0600) (defconstant +3d+ #x0601) (defconstant +3d-color+ #x0602) (defconstant +3d-color-texture+ #x0603) (defconstant +4d-color-texture+ #x0604) (defconstant +point-token+ #x0701) (defconstant +line-token+ #x0702) (defconstant +line-reset-token+ #x0707) (defconstant +polygon-token+ #x0703) (defconstant +bitmap-token+ #x0704) (defconstant +draw-pixel-token+ #x0705) (defconstant +copy-pixel-token+ #x0706) (defconstant +pass-through-token+ #x0700) (defconstant +feedback-buffer-pointer+ #x0df0) (defconstant +feedback-buffer-size+ #x0df1) (defconstant +feedback-buffer-type+ #x0df2) ;; Selection (defconstant +selection-buffer-pointer+ #x0df3) (defconstant +selection-buffer-size+ #x0df4) ;; Fog (defconstant +fog+ #x0b60) (defconstant +fog-mode+ #x0b65) (defconstant +fog-density+ #x0b62) (defconstant +fog-color+ #x0b66) (defconstant +fog-index+ #x0b61) (defconstant +fog-start+ #x0b63) (defconstant +fog-end+ #x0b64) (defconstant +linear+ #x2601) (defconstant +exp+ #x0800) (defconstant +exp2+ #x0801) ;; Logic operations (defconstant +logic-op+ #x0bf1) (defconstant +index-logic-op+ #x0bf1) (defconstant +color-logic-op+ #x0bf2) (defconstant +logic-op-mode+ #x0bf0) (defconstant +clear+ #x1500) (defconstant +set+ #x150f) (defconstant +copy+ #x1503) (defconstant +copy-inverted+ #x150c) (defconstant +noop+ #x1505) (defconstant +invert+ #x150a) (defconstant +and+ #x1501) (defconstant +nand+ #x150e) (defconstant +or+ #x1507) (defconstant +nor+ #x1508) (defconstant +xor+ #x1506) (defconstant +equiv+ #x1509) (defconstant +and-reverse+ #x1502) (defconstant +and-inverted+ #x1504) (defconstant +or-reverse+ #x150b) (defconstant +or-inverted+ #x150d) ;; Stencil (defconstant +stencil-test+ #x0b90) (defconstant +stencil-writemask+ #x0b98) (defconstant +stencil-bits+ #x0d57) (defconstant +stencil-func+ #x0b92) (defconstant +stencil-value-mask+ #x0b93) (defconstant +stencil-ref+ #x0b97) (defconstant +stencil-fail+ #x0b94) (defconstant +stencil-pass-depth-pass+ #x0b96) (defconstant +stencil-pass-depth-fail+ #x0b95) (defconstant +stencil-clear-value+ #x0b91) (defconstant +stencil-index+ #x1901) (defconstant +keep+ #x1e00) (defconstant +replace+ #x1e01) (defconstant +incr+ #x1e02) (defconstant +decr+ #x1e03) ;; Buffers, Pixel Drawing/Reading (defconstant +none+ #x0) (defconstant +left+ #x0406) (defconstant +right+ #x0407) (defconstant +front-left+ #x0400) (defconstant +front-right+ #x0401) (defconstant +back-left+ #x0402) (defconstant +back-right+ #x0403) (defconstant +aux0+ #x0409) (defconstant +aux1+ #x040a) (defconstant +aux2+ #x040b) (defconstant +aux3+ #x040c) (defconstant +color-index+ #x1900) (defconstant +red+ #x1903) (defconstant +green+ #x1904) (defconstant +blue+ #x1905) (defconstant +alpha+ #x1906) (defconstant +luminance+ #x1909) (defconstant +luminance-alpha+ #x190a) (defconstant +alpha-bits+ #x0d55) (defconstant +red-bits+ #x0d52) (defconstant +green-bits+ #x0d53) (defconstant +blue-bits+ #x0d54) (defconstant +index-bits+ #x0d51) (defconstant +subpixel-bits+ #x0d50) (defconstant +aux-buffers+ #x0c00) (defconstant +read-buffer+ #x0c02) (defconstant +draw-buffer+ #x0c01) (defconstant +doublebuffer+ #x0c32) (defconstant +stereo+ #x0c33) (defconstant +bitmap+ #x1a00) (defconstant +color+ #x1800) (defconstant +depth+ #x1801) (defconstant +stencil+ #x1802) (defconstant +dither+ #x0bd0) (defconstant +rgb+ #x1907) (defconstant +rgba+ #x1908) ;; Implementation Limits (defconstant +max-list-nesting+ #x0b31) (defconstant +max-attrib-stack-depth+ #x0d35) (defconstant +max-modelview-stack-depth+ #x0d36) (defconstant +max-name-stack-depth+ #x0d37) (defconstant +max-projection-stack-depth+ #x0d38) (defconstant +max-texture-stack-depth+ #x0d39) (defconstant +max-eval-order+ #x0d30) (defconstant +max-lights+ #x0d31) (defconstant +max-clip-planes+ #x0d32) (defconstant +max-texture-size+ #x0d33) (defconstant +max-pixel-map-table+ #x0d34) (defconstant +max-viewport-dims+ #x0d3a) (defconstant +max-client-attrib-stack-depth+ #x0d3b) ;; Gets (defconstant +attrib-stack-depth+ #x0bb0) (defconstant +client-attrib-stack-depth+ #x0bb1) (defconstant +color-clear-value+ #x0c22) (defconstant +color-writemask+ #x0c23) (defconstant +current-index+ #x0b01) (defconstant +current-color+ #x0b00) (defconstant +current-normal+ #x0b02) (defconstant +current-raster-color+ #x0b04) (defconstant +current-raster-distance+ #x0b09) (defconstant +current-raster-index+ #x0b05) (defconstant +current-raster-position+ #x0b07) (defconstant +current-raster-texture-coords+ #x0b06) (defconstant +current-raster-position-valid+ #x0b08) (defconstant +current-texture-coords+ #x0b03) (defconstant +index-clear-value+ #x0c20) (defconstant +index-mode+ #x0c30) (defconstant +index-writemask+ #x0c21) (defconstant +modelview-matrix+ #x0ba6) (defconstant +modelview-stack-depth+ #x0ba3) (defconstant +name-stack-depth+ #x0d70) (defconstant +projection-matrix+ #x0ba7) (defconstant +projection-stack-depth+ #x0ba4) (defconstant +render-mode+ #x0c40) (defconstant +rgba-mode+ #x0c31) (defconstant +texture-matrix+ #x0ba8) (defconstant +texture-stack-depth+ #x0ba5) (defconstant +viewport+ #x0ba2) ;; GL Evaluators (defconstant +auto-normal+ #x0d80) (defconstant +map1-color-4+ #x0d90) (defconstant +map1-grid-domain+ #x0dd0) (defconstant +map1-grid-segments+ #x0dd1) (defconstant +map1-index+ #x0d91) (defconstant +map1-normal+ #x0d92) (defconstant +map1-texture-coord-1+ #x0d93) (defconstant +map1-texture-coord-2+ #x0d94) (defconstant +map1-texture-coord-3+ #x0d95) (defconstant +map1-texture-coord-4+ #x0d96) (defconstant +map1-vertex-3+ #x0d97) (defconstant +map1-vertex-4+ #x0d98) (defconstant +map2-color-4+ #x0db0) (defconstant +map2-grid-domain+ #x0dd2) (defconstant +map2-grid-segments+ #x0dd3) (defconstant +map2-index+ #x0db1) (defconstant +map2-normal+ #x0db2) (defconstant +map2-texture-coord-1+ #x0db3) (defconstant +map2-texture-coord-2+ #x0db4) (defconstant +map2-texture-coord-3+ #x0db5) (defconstant +map2-texture-coord-4+ #x0db6) (defconstant +map2-vertex-3+ #x0db7) (defconstant +map2-vertex-4+ #x0db8) (defconstant +coeff+ #x0a00) (defconstant +domain+ #x0a02) (defconstant +order+ #x0a01) ;; Hints (defconstant +fog-hint+ #x0c54) (defconstant +line-smooth-hint+ #x0c52) (defconstant +perspective-correction-hint+ #x0c50) (defconstant +point-smooth-hint+ #x0c51) (defconstant +polygon-smooth-hint+ #x0c53) (defconstant +dont-care+ #x1100) (defconstant +fastest+ #x1101) (defconstant +nicest+ #x1102) ;; Scissor box (defconstant +scissor-test+ #x0c11) (defconstant +scissor-box+ #x0c10) ;; Pixel Mode / Transfer (defconstant +map-color+ #x0d10) (defconstant +map-stencil+ #x0d11) (defconstant +index-shift+ #x0d12) (defconstant +index-offset+ #x0d13) (defconstant +red-scale+ #x0d14) (defconstant +red-bias+ #x0d15) (defconstant +green-scale+ #x0d18) (defconstant +green-bias+ #x0d19) (defconstant +blue-scale+ #x0d1a) (defconstant +blue-bias+ #x0d1b) (defconstant +alpha-scale+ #x0d1c) (defconstant +alpha-bias+ #x0d1d) (defconstant +depth-scale+ #x0d1e) (defconstant +depth-bias+ #x0d1f) (defconstant +pixel-map-s-to-s-size+ #x0cb1) (defconstant +pixel-map-i-to-i-size+ #x0cb0) (defconstant +pixel-map-i-to-r-size+ #x0cb2) (defconstant +pixel-map-i-to-g-size+ #x0cb3) (defconstant +pixel-map-i-to-b-size+ #x0cb4) (defconstant +pixel-map-i-to-a-size+ #x0cb5) (defconstant +pixel-map-r-to-r-size+ #x0cb6) (defconstant +pixel-map-g-to-g-size+ #x0cb7) (defconstant +pixel-map-b-to-b-size+ #x0cb8) (defconstant +pixel-map-a-to-a-size+ #x0cb9) (defconstant +pixel-map-s-to-s+ #x0c71) (defconstant +pixel-map-i-to-i+ #x0c70) (defconstant +pixel-map-i-to-r+ #x0c72) (defconstant +pixel-map-i-to-g+ #x0c73) (defconstant +pixel-map-i-to-b+ #x0c74) (defconstant +pixel-map-i-to-a+ #x0c75) (defconstant +pixel-map-r-to-r+ #x0c76) (defconstant +pixel-map-g-to-g+ #x0c77) (defconstant +pixel-map-b-to-b+ #x0c78) (defconstant +pixel-map-a-to-a+ #x0c79) (defconstant +pack-alignment+ #x0d05) (defconstant +pack-lsb-first+ #x0d01) (defconstant +pack-row-length+ #x0d02) (defconstant +pack-skip-pixels+ #x0d04) (defconstant +pack-skip-rows+ #x0d03) (defconstant +pack-swap-bytes+ #x0d00) (defconstant +unpack-alignment+ #x0cf5) (defconstant +unpack-lsb-first+ #x0cf1) (defconstant +unpack-row-length+ #x0cf2) (defconstant +unpack-skip-pixels+ #x0cf4) (defconstant +unpack-skip-rows+ #x0cf3) (defconstant +unpack-swap-bytes+ #x0cf0) (defconstant +zoom-x+ #x0d16) (defconstant +zoom-y+ #x0d17) ;; Texture Mapping (defconstant +texture-env+ #x2300) (defconstant +texture-env-mode+ #x2200) (defconstant +texture-1d+ #x0de0) (defconstant +texture-2d+ #x0de1) (defconstant +texture-wrap-s+ #x2802) (defconstant +texture-wrap-t+ #x2803) (defconstant +texture-mag-filter+ #x2800) (defconstant +texture-min-filter+ #x2801) (defconstant +texture-env-color+ #x2201) (defconstant +texture-gen-s+ #x0c60) (defconstant +texture-gen-t+ #x0c61) (defconstant +texture-gen-mode+ #x2500) (defconstant +texture-border-color+ #x1004) (defconstant +texture-width+ #x1000) (defconstant +texture-height+ #x1001) (defconstant +texture-border+ #x1005) (defconstant +texture-components+ #x1003) (defconstant +texture-red-size+ #x805c) (defconstant +texture-green-size+ #x805d) (defconstant +texture-blue-size+ #x805e) (defconstant +texture-alpha-size+ #x805f) (defconstant +texture-luminance-size+ #x8060) (defconstant +texture-intensity-size+ #x8061) (defconstant +nearest-mipmap-nearest+ #x2700) (defconstant +nearest-mipmap-linear+ #x2702) (defconstant +linear-mipmap-nearest+ #x2701) (defconstant +linear-mipmap-linear+ #x2703) (defconstant +object-linear+ #x2401) (defconstant +object-plane+ #x2501) (defconstant +eye-linear+ #x2400) (defconstant +eye-plane+ #x2502) (defconstant +sphere-map+ #x2402) (defconstant +decal+ #x2101) (defconstant +modulate+ #x2100) (defconstant +nearest+ #x2600) (defconstant +repeat+ #x2901) (defconstant +clamp+ #x2900) (defconstant +s+ #x2000) (defconstant +t+ #x2001) (defconstant +r+ #x2002) (defconstant +q+ #x2003) (defconstant +texture-gen-r+ #x0c62) (defconstant +texture-gen-q+ #x0c63) ;; GL 1.1 Texturing (defconstant +proxy-texture-1d+ #x8063) (defconstant +proxy-texture-2d+ #x8064) (defconstant +texture-priority+ #x8066) (defconstant +texture-resident+ #x8067) (defconstant +texture-binding-1d+ #x8068) (defconstant +texture-binding-2d+ #x8069) (defconstant +texture-internal-format+ #x1003) (defconstant +pack-skip-images+ #x806b) (defconstant +pack-image-height+ #x806c) (defconstant +unpack-skip-images+ #x806d) (defconstant +unpack-image-height+ #x806e) (defconstant +texture-3d+ #x806f) (defconstant +proxy-texture-3d+ #x8070) (defconstant +texture-depth+ #x8071) (defconstant +texture-wrap-r+ #x8072) (defconstant +max-3d-texture-size+ #x8073) (defconstant +texture-binding-3d+ #x806a) ;; Internal texture formats (GL 1.1) (defconstant +alpha4+ #x803b) (defconstant +alpha8+ #x803c) (defconstant +alpha12+ #x803d) (defconstant +alpha16+ #x803e) (defconstant +luminance4+ #x803f) (defconstant +luminance8+ #x8040) (defconstant +luminance12+ #x8041) (defconstant +luminance16+ #x8042) (defconstant +luminance4-alpha4+ #x8043) (defconstant +luminance6-alpha2+ #x8044) (defconstant +luminance8-alpha8+ #x8045) (defconstant +luminance12-alpha4+ #x8046) (defconstant +luminance12-alpha12+ #x8047) (defconstant +luminance16-alpha16+ #x8048) (defconstant +intensity+ #x8049) (defconstant +intensity4+ #x804a) (defconstant +intensity8+ #x804b) (defconstant +intensity12+ #x804c) (defconstant +intensity16+ #x804d) (defconstant +r3-g3-b2+ #x2a10) (defconstant +rgb4+ #x804f) (defconstant +rgb5+ #x8050) (defconstant +rgb8+ #x8051) (defconstant +rgb10+ #x8052) (defconstant +rgb12+ #x8053) (defconstant +rgb16+ #x8054) (defconstant +rgba2+ #x8055) (defconstant +rgba4+ #x8056) (defconstant +rgb5-a1+ #x8057) (defconstant +rgba8+ #x8058) (defconstant +rgb10-a2+ #x8059) (defconstant +rgba12+ #x805a) (defconstant +rgba16+ #x805b) ;; Utility (defconstant +vendor+ #x1f00) (defconstant +renderer+ #x1f01) (defconstant +version+ #x1f02) (defconstant +extensions+ #x1f03) ;; Errors (defconstant +no-error+ #x0) (defconstant +invalid-value+ #x0501) (defconstant +invalid-enum+ #x0500) (defconstant +invalid-operation+ #x0502) (defconstant +stack-overflow+ #x0503) (defconstant +stack-underflow+ #x0504) (defconstant +out-of-memory+ #x0505) ;; OpenGL 1.2 (defconstant +rescale-normal+ #x803a) (defconstant +clamp-to-edge+ #x812f) (defconstant +max-elements-vertices+ #x80e8) (defconstant +max-elements-indices+ #x80e9) (defconstant +bgr+ #x80e0) (defconstant +bgra+ #x80e1) (defconstant +unsigned-byte-3-3-2+ #x8032) (defconstant +unsigned-byte-2-3-3-rev+ #x8362) (defconstant +unsigned-short-5-6-5+ #x8363) (defconstant +unsigned-short-5-6-5-rev+ #x8364) (defconstant +unsigned-short-4-4-4-4+ #x8033) (defconstant +unsigned-short-4-4-4-4-rev+ #x8365) (defconstant +unsigned-short-5-5-5-1+ #x8034) (defconstant +unsigned-short-1-5-5-5-rev+ #x8366) (defconstant +unsigned-int-8-8-8-8+ #x8035) (defconstant +unsigned-int-8-8-8-8-rev+ #x8367) (defconstant +unsigned-int-10-10-10-2+ #x8036) (defconstant +unsigned-int-2-10-10-10-rev+ #x8368) (defconstant +light-model-color-control+ #x81f8) (defconstant +single-color+ #x81f9) (defconstant +separate-specular-color+ #x81fa) (defconstant +texture-min-lod+ #x813a) (defconstant +texture-max-lod+ #x813b) (defconstant +texture-base-level+ #x813c) (defconstant +texture-max-level+ #x813d) (defconstant +smooth-point-size-range+ #x0b12) (defconstant +smooth-point-size-granularity+ #x0b13) (defconstant +smooth-line-width-range+ #x0b22) (defconstant +smooth-line-width-granularity+ #x0b23) (defconstant +aliased-point-size-range+ #x846d) (defconstant +aliased-line-width-range+ #x846e) ;; OpenGL 1.2 Imaging subset ;; GL_EXT_color_table (defconstant +color-table+ #x80d0) (defconstant +post-convolution-color-table+ #x80d1) (defconstant +post-color-matrix-color-table+ #x80d2) (defconstant +proxy-color-table+ #x80d3) (defconstant +proxy-post-convolution-color-table+ #x80d4) (defconstant +proxy-post-color-matrix-color-table+ #x80d5) (defconstant +color-table-scale+ #x80d6) (defconstant +color-table-bias+ #x80d7) (defconstant +color-table-format+ #x80d8) (defconstant +color-table-width+ #x80d9) (defconstant +color-table-red-size+ #x80da) (defconstant +color-table-green-size+ #x80db) (defconstant +color-table-blue-size+ #x80dc) (defconstant +color-table-alpha-size+ #x80dd) (defconstant +color-table-luminance-size+ #x80de) (defconstant +color-table-intensity-size+ #x80df) ;; GL_EXT_convolution and GL_HP_convolution (defconstant +convolution-1d+ #x8010) (defconstant +convolution-2d+ #x8011) (defconstant +separable-2d+ #x8012) (defconstant +convolution-border-mode+ #x8013) (defconstant +convolution-filter-scale+ #x8014) (defconstant +convolution-filter-bias+ #x8015) (defconstant +reduce+ #x8016) (defconstant +convolution-format+ #x8017) (defconstant +convolution-width+ #x8018) (defconstant +convolution-height+ #x8019) (defconstant +max-convolution-width+ #x801a) (defconstant +max-convolution-height+ #x801b) (defconstant +post-convolution-red-scale+ #x801c) (defconstant +post-convolution-green-scale+ #x801d) (defconstant +post-convolution-blue-scale+ #x801e) (defconstant +post-convolution-alpha-scale+ #x801f) (defconstant +post-convolution-red-bias+ #x8020) (defconstant +post-convolution-green-bias+ #x8021) (defconstant +post-convolution-blue-bias+ #x8022) (defconstant +post-convolution-alpha-bias+ #x8023) (defconstant +constant-border+ #x8151) (defconstant +replicate-border+ #x8153) (defconstant +convolution-border-color+ #x8154) ;; GL_SGI_color_matrix (defconstant +color-matrix+ #x80b1) (defconstant +color-matrix-stack-depth+ #x80b2) (defconstant +max-color-matrix-stack-depth+ #x80b3) (defconstant +post-color-matrix-red-scale+ #x80b4) (defconstant +post-color-matrix-green-scale+ #x80b5) (defconstant +post-color-matrix-blue-scale+ #x80b6) (defconstant +post-color-matrix-alpha-scale+ #x80b7) (defconstant +post-color-matrix-red-bias+ #x80b8) (defconstant +post-color-matrix-green-bias+ #x80b9) (defconstant +post-color-matrix-blue-bias+ #x80ba) (defconstant +post-color-matrix-alpha-bias+ #x80bb) ;; GL_EXT_histogram (defconstant +histogram+ #x8024) (defconstant +proxy-histogram+ #x8025) (defconstant +histogram-width+ #x8026) (defconstant +histogram-format+ #x8027) (defconstant +histogram-red-size+ #x8028) (defconstant +histogram-green-size+ #x8029) (defconstant +histogram-blue-size+ #x802a) (defconstant +histogram-alpha-size+ #x802b) (defconstant +histogram-luminance-size+ #x802c) (defconstant +histogram-sink+ #x802d) (defconstant +minmax+ #x802e) (defconstant +minmax-format+ #x802f) (defconstant +minmax-sink+ #x8030) (defconstant +table-too-large+ #x8031) ;; GL_EXT_blend_color, GL_EXT_blend_minmax (defconstant +blend-equation+ #x8009) (defconstant +min+ #x8007) (defconstant +max+ #x8008) (defconstant +func-add+ #x8006) (defconstant +func-subtract+ #x800a) (defconstant +func-reverse-subtract+ #x800b) ;; glPush/PopAttrib bits (defconstant +current-bit+ #x00000001) (defconstant +point-bit+ #x00000002) (defconstant +line-bit+ #x00000004) (defconstant +polygon-bit+ #x00000008) (defconstant +polygon-stipple-bit+ #x00000010) (defconstant +pixel-mode-bit+ #x00000020) (defconstant +lighting-bit+ #x00000040) (defconstant +fog-bit+ #x00000080) (defconstant +depth-buffer-bit+ #x00000100) (defconstant +accum-buffer-bit+ #x00000200) (defconstant +stencil-buffer-bit+ #x00000400) (defconstant +viewport-bit+ #x00000800) (defconstant +transform-bit+ #x00001000) (defconstant +enable-bit+ #x00002000) (defconstant +color-buffer-bit+ #x00004000) (defconstant +hint-bit+ #x00008000) (defconstant +eval-bit+ #x00010000) (defconstant +list-bit+ #x00020000) (defconstant +texture-bit+ #x00040000) (defconstant +scissor-bit+ #x00080000) (defconstant +all-attrib-bits+ #x000fffff) (defconstant +client-pixel-store-bit+ #x00000001) (defconstant +client-vertex-array-bit+ #x00000002) (defconstant +client-all-attrib-bits+ #xffffffff) ;; ARB Multitexturing extension (defconstant +arb-multitexture+ 1) (defconstant +texture0-arb+ #x84c0) (defconstant +texture1-arb+ #x84c1) (defconstant +texture2-arb+ #x84c2) (defconstant +texture3-arb+ #x84c3) (defconstant +texture4-arb+ #x84c4) (defconstant +texture5-arb+ #x84c5) (defconstant +texture6-arb+ #x84c6) (defconstant +texture7-arb+ #x84c7) (defconstant +texture8-arb+ #x84c8) (defconstant +texture9-arb+ #x84c9) (defconstant +texture10-arb+ #x84ca) (defconstant +texture11-arb+ #x84cb) (defconstant +texture12-arb+ #x84cc) (defconstant +texture13-arb+ #x84cd) (defconstant +texture14-arb+ #x84ce) (defconstant +texture15-arb+ #x84cf) (defconstant +texture16-arb+ #x84d0) (defconstant +texture17-arb+ #x84d1) (defconstant +texture18-arb+ #x84d2) (defconstant +texture19-arb+ #x84d3) (defconstant +texture20-arb+ #x84d4) (defconstant +texture21-arb+ #x84d5) (defconstant +texture22-arb+ #x84d6) (defconstant +texture23-arb+ #x84d7) (defconstant +texture24-arb+ #x84d8) (defconstant +texture25-arb+ #x84d9) (defconstant +texture26-arb+ #x84da) (defconstant +texture27-arb+ #x84db) (defconstant +texture28-arb+ #x84dc) (defconstant +texture29-arb+ #x84dd) (defconstant +texture30-arb+ #x84de) (defconstant +texture31-arb+ #x84df) (defconstant +active-texture-arb+ #x84e0) (defconstant +client-active-texture-arb+ #x84e1) (defconstant +max-texture-units-arb+ #x84e2) ;;; Misc extensions (defconstant +ext-abgr+ 1) (defconstant +abgr-ext+ #x8000) (defconstant +ext-blend-color+ 1) (defconstant +constant-color-ext+ #x8001) (defconstant +one-minus-constant-color-ext+ #x8002) (defconstant +constant-alpha-ext+ #x8003) (defconstant +one-minus-constant-alpha-ext+ #x8004) (defconstant +blend-color-ext+ #x8005) (defconstant +ext-polygon-offset+ 1) (defconstant +polygon-offset-ext+ #x8037) (defconstant +polygon-offset-factor-ext+ #x8038) (defconstant +polygon-offset-bias-ext+ #x8039) (defconstant +ext-texture3d+ 1) (defconstant +pack-skip-images-ext+ #x806b) (defconstant +pack-image-height-ext+ #x806c) (defconstant +unpack-skip-images-ext+ #x806d) (defconstant +unpack-image-height-ext+ #x806e) (defconstant +texture-3d-ext+ #x806f) (defconstant +proxy-texture-3d-ext+ #x8070) (defconstant +texture-depth-ext+ #x8071) (defconstant +texture-wrap-r-ext+ #x8072) (defconstant +max-3d-texture-size-ext+ #x8073) (defconstant +texture-3d-binding-ext+ #x806a) (defconstant +ext-texture-object+ 1) (defconstant +texture-priority-ext+ #x8066) (defconstant +texture-resident-ext+ #x8067) (defconstant +texture-1d-binding-ext+ #x8068) (defconstant +texture-2d-binding-ext+ #x8069) (defconstant +ext-rescale-normal+ 1) (defconstant +rescale-normal-ext+ #x803a) (defconstant +ext-vertex-array+ 1) (defconstant +vertex-array-ext+ #x8074) (defconstant +normal-array-ext+ #x8075) (defconstant +color-array-ext+ #x8076) (defconstant +index-array-ext+ #x8077) (defconstant +texture-coord-array-ext+ #x8078) (defconstant +edge-flag-array-ext+ #x8079) (defconstant +vertex-array-size-ext+ #x807a) (defconstant +vertex-array-type-ext+ #x807b) (defconstant +vertex-array-stride-ext+ #x807c) (defconstant +vertex-array-count-ext+ #x807d) (defconstant +normal-array-type-ext+ #x807e) (defconstant +normal-array-stride-ext+ #x807f) (defconstant +normal-array-count-ext+ #x8080) (defconstant +color-array-size-ext+ #x8081) (defconstant +color-array-type-ext+ #x8082) (defconstant +color-array-stride-ext+ #x8083) (defconstant +color-array-count-ext+ #x8084) (defconstant +index-array-type-ext+ #x8085) (defconstant +index-array-stride-ext+ #x8086) (defconstant +index-array-count-ext+ #x8087) (defconstant +texture-coord-array-size-ext+ #x8088) (defconstant +texture-coord-array-type-ext+ #x8089) (defconstant +texture-coord-array-stride-ext+ #x808a) (defconstant +texture-coord-array-count-ext+ #x808b) (defconstant +edge-flag-array-stride-ext+ #x808c) (defconstant +edge-flag-array-count-ext+ #x808d) (defconstant +vertex-array-pointer-ext+ #x808e) (defconstant +normal-array-pointer-ext+ #x808f) (defconstant +color-array-pointer-ext+ #x8090) (defconstant +index-array-pointer-ext+ #x8091) (defconstant +texture-coord-array-pointer-ext+ #x8092) (defconstant +edge-flag-array-pointer-ext+ #x8093) (defconstant +sgis-texture-edge-clamp+ 1) (defconstant +clamp-to-edge-sgis+ #x812f) (defconstant +ext-blend-minmax+ 1) (defconstant +func-add-ext+ #x8006) (defconstant +min-ext+ #x8007) (defconstant +max-ext+ #x8008) (defconstant +blend-equation-ext+ #x8009) (defconstant +ext-blend-subtract+ 1) (defconstant +func-subtract-ext+ #x800a) (defconstant +func-reverse-subtract-ext+ #x800b) (defconstant +ext-blend-logic-op+ 1) (defconstant +ext-point-parameters+ 1) (defconstant +point-size-min-ext+ #x8126) (defconstant +point-size-max-ext+ #x8127) (defconstant +point-fade-threshold-size-ext+ #x8128) (defconstant +distance-attenuation-ext+ #x8129) (defconstant +ext-paletted-texture+ 1) (defconstant +table-too-large-ext+ #x8031) (defconstant +color-table-format-ext+ #x80d8) (defconstant +color-table-width-ext+ #x80d9) (defconstant +color-table-red-size-ext+ #x80da) (defconstant +color-table-green-size-ext+ #x80db) (defconstant +color-table-blue-size-ext+ #x80dc) (defconstant +color-table-alpha-size-ext+ #x80dd) (defconstant +color-table-luminance-size-ext+ #x80de) (defconstant +color-table-intensity-size-ext+ #x80df) (defconstant +texture-index-size-ext+ #x80ed) (defconstant +color-index1-ext+ #x80e2) (defconstant +color-index2-ext+ #x80e3) (defconstant +color-index4-ext+ #x80e4) (defconstant +color-index8-ext+ #x80e5) (defconstant +color-index12-ext+ #x80e6) (defconstant +color-index16-ext+ #x80e7) (defconstant +ext-clip-volume-hint+ 1) (defconstant +clip-volume-clipping-hint-ext+ #x80f0) (defconstant +ext-compiled-vertex-array+ 1) (defconstant +array-element-lock-first-ext+ #x81a8) (defconstant +array-element-lock-count-ext+ #x81a9) (defconstant +hp-occlusion-test+ 1) (defconstant +occlusion-test-hp+ #x8165) (defconstant +occlusion-test-result-hp+ #x8166) (defconstant +ext-shared-texture-palette+ 1) (defconstant +shared-texture-palette-ext+ #x81fb) (defconstant +ext-stencil-wrap+ 1) (defconstant +incr-wrap-ext+ #x8507) (defconstant +decr-wrap-ext+ #x8508) (defconstant +nv-texgen-reflection+ 1) (defconstant +normal-map-nv+ #x8511) (defconstant +reflection-map-nv+ #x8512) (defconstant +ext-texture-env-add+ 1) (defconstant +mesa-window-pos+ 1) (defconstant +mesa-resize-buffers+ 1) ) ;;; Utility stuff (deftype bool () 'card8) (deftype float32 () 'single-float) (deftype float64 () 'double-float) (declaim (inline aset-float32 aset-float64)) #+sbcl (defun aset-float32 (value array index) (declare (type single-float value) (type buffer-bytes array) (type array-index index)) #.(declare-buffun) (let ((bits (sb-kernel:single-float-bits value))) (declare (type (unsigned-byte 32) bits)) (aset-card32 bits array index)) value) #+cmu (defun aset-float32 (value array index) (declare (type single-float value) (type buffer-bytes array) (type array-index index)) #.(declare-buffun) (let ((bits (kernel:single-float-bits value))) (declare (type (unsigned-byte 32) bits)) (aset-card32 bits array index)) value) #+openmcl (defun aset-float32 (value array index) (declare (type single-float value) (type buffer-bytes array) (type array-index index)) #.(declare-buffun) (let ((bits (ccl::single-float-bits value))) (declare (type (unsigned-byte 32) bits)) (aset-card32 bits array index)) value) #+sbcl (defun aset-float64 (value array index) (declare (type double-float value) (type buffer-bytes array) (type array-index index)) #.(declare-buffun) (let ((low (sb-kernel:double-float-low-bits value)) (high (sb-kernel:double-float-high-bits value))) (declare (type (unsigned-byte 32) low high)) (aset-card32 low array index) (aset-card32 high array (the array-index (+ index 4)))) value) #+cmu (defun aset-float64 (value array index) (declare (type double-float value) (type buffer-bytes array) (type array-index index)) #.(declare-buffun) (let ((low (kernel:double-float-low-bits value)) (high (kernel:double-float-high-bits value))) (declare (type (unsigned-byte 32) low high)) (aset-card32 low array index) (aset-card32 high array (+ index 4))) value) #+openmcl (defun aset-float64 (value array index) (declare (type double-float value) (type buffer-bytes array) (type array-index index)) #.(declare-buffun) (multiple-value-bind (low high) (ccl::double-float-bits value) (declare (type (unsigned-byte 32) low high)) (aset-card32 low array index) (aset-card32 high array (the array-index (+ index 4)))) value) (eval-when (:compile-toplevel :load-toplevel :execute) (defun byte-width (type) (ecase type ((int8 card8 bool) 1) ((int16 card16) 2) ((int32 card32 float32) 4) ((float64) 8))) (defun setter (type) (ecase type (int8 'aset-int8) (int16 'aset-int16) (int32 'aset-int32) (bool 'aset-card8) (card8 'aset-card8) (card16 'aset-card16) (card32 'aset-card32) (float32 'aset-float32) (float64 'aset-float64))) (defun sequence-setter (type) (ecase type (int8 'sset-int8) (int16 'sset-int16) (int32 'sset-int32) (bool 'sset-card8) (card8 'sset-card8) (card16 'sset-card16) (card32 'sset-card32) (float32 'sset-float32) (float64 'sset-float64))) (defmacro define-sequence-setter (type) `(defun ,(intern (format nil "~A-~A" 'sset type)) (seq buffer start length) (declare (type sequence seq) (type buffer-bytes buffer) (type array-index start) (type fixnum length)) #.(declare-buffun) (assert (= length (length seq)) (length seq) "SEQUENCE length should be ~D, not ~D." length (length seq)) (typecase seq (list (let ((offset 0)) (declare (type fixnum offset)) (dolist (n seq) (declare (type ,type n)) (,(setter type) n buffer (the array-index (+ start offset))) (incf offset ,(byte-width type))))) ((simple-array ,type) (dotimes (i ,(byte-width type)) (,(setter type) (aref seq i) buffer (the array-index (+ start (* i ,(byte-width type))))))) (vector (dotimes (i ,(byte-width type)) (,(setter type) (svref seq i) buffer (the array-index (+ start (* i ,(byte-width type)))))))))) (define-sequence-setter int8) (define-sequence-setter int16) (define-sequence-setter int32) (define-sequence-setter bool) (define-sequence-setter card8) (define-sequence-setter card16) (define-sequence-setter card32) (define-sequence-setter float32) (define-sequence-setter float64) (defun make-argspecs (list) (destructuring-bind (name type) list (etypecase type (symbol `(,name ,type 1 nil)) (list `(,name ,(second type) ,(third type) ,(if (consp (third type)) (make-symbol (format nil "~A-~A" name 'length)) nil)))))) (defun byte-width-calculation (argspecs) (let ((constant 0) (calculated ())) (loop for (name type length length-var) in argspecs do (let ((byte-width (byte-width type))) (typecase length (number (incf constant (* byte-width length))) (symbol (push `(* ,byte-width ,length) calculated)) (cons (push `(* ,byte-width ,length-var) calculated))))) (if (null calculated) constant (list* '+ constant calculated)))) (defun composite-args (argspecs) (loop for (name type length length-var) in argspecs when (consp length) collect (list length-var length))) (defun make-setter-forms (argspecs) (loop for (name type length length-var) in argspecs collecting `(progn ,(if (and (numberp length) (= 1 length)) `(,(setter type) ,name .rbuf. .index.) `(,(sequence-setter type) ,name .rbuf. .index. ,(if length-var length-var length))) (setf .index. (the array-index (+ .index. (the fixnum (* ,(byte-width type) ,(if length-var length-var length))))))))) (defmacro define-rendering-command (name opcode &rest args) ;; FIXME: Must heavily type-annotate. (labels ((expand-args (list) (loop for (arg type) in list if (consp arg) append (loop for name in arg collecting (list name type)) else collect (list arg type)))) (let* ((args (expand-args args)) (argspecs (mapcar 'make-argspecs args)) (total-byte-width (byte-width-calculation argspecs)) (composite-args (composite-args argspecs))) `(defun ,name ,(mapcar #'first argspecs) (declare ,@(mapcar #'(lambda (list) (if (symbolp (second list)) (list* 'type (reverse list)) `(type sequence ,(first list)))) args)) #.(declare-buffun) (assert (context-p *current-context*) (*current-context*) "*CURRENT-CONTEXT* is not set (~S)." *current-context*) (let* ((.ctx. *current-context*) (.index0. (context-index .ctx.)) (.index. (+ .index0. 4)) (.rbuf. (context-rbuf .ctx.)) ,@composite-args (.length. (+ 4 (* 4 (ceiling ,total-byte-width 4))))) (declare (type context .ctx.) (type array-index .index. .index0.) (type buffer-bytes .rbuf.) ,@(mapcar #'(lambda (list) `(type fixnum ,(first list))) composite-args) (type fixnum .length.)) (when (< (- (length .rbuf.) 8) (+ .index. .length.)) (error "Rendering command sequence too long. Implement automatic buffer flushing.")) (aset-card16 .length. .rbuf. (the array-index .index0.)) (aset-card16 ,opcode .rbuf. (the array-index (+ .index0. 2))) ,@(make-setter-forms argspecs) (setf (context-index .ctx.) (the array-index (+ .index0. .length.)))))))) ) ;; eval-when ;;; Command implementation. (defun get-string (name) (assert (context-p *current-context*) (*current-context*) "*CURRENT-CONTEXT* is not set (~S)." *current-context*) (let* ((ctx *current-context*) (display (context-display ctx))) (with-buffer-request-and-reply (display (extension-opcode display "GLX") nil) ((data +get-string+) ;; *** This is CONTEXT-TAG (card32 (context-tag ctx)) ;; *** This is ENUM. (card32 name)) (let* ((length (card32-get 12)) (bytes (sequence-get :format card8 :result-type '(simple-array card8 (*)) :index 32 :length length))) (declare (type (simple-array card8 (*)) bytes) (type fixnum length)) ;; FIXME: How does this interact with unicode? (map-into (make-string (1- length)) #'code-char bytes))))) ;;; Rendering commands (in alphabetical order). (define-rendering-command accum 137 ;; *** ENUM (op card32) (value float32)) (define-rendering-command active-texture-arb 197 ;; *** ENUM (texture card32)) (define-rendering-command alpha-func 159 ;; *** ENUM (func card32) (ref float32)) (define-rendering-command begin 4 ;; *** ENUM (mode card32)) (define-rendering-command bind-texture 4117 ;; *** ENUM (target card32) (texture card32)) (define-rendering-command blend-color 4096 (red float32) (green float32) (blue float32) (alpha float32)) (define-rendering-command blend-equotion 4097 ;; *** ENUM (mode card32)) (define-rendering-command blend-func 160 ;; *** ENUM (sfactor card32) ;; *** ENUM (dfactor card32)) (define-rendering-command call-list 1 (list card32)) (define-rendering-command clear 127 ;; *** BITFIELD (mask card32)) (define-rendering-command clear-accum 128 (red float32) (green float32) (blue float32) (alpha float32)) (define-rendering-command clear-color 130 (red float32) (green float32) (blue float32) (alpha float32)) (define-rendering-command clear-depth 132 (depth float64)) (define-rendering-command clear-index 129 (c float32)) (define-rendering-command clear-stencil 131 (s int32)) (define-rendering-command clip-plane 77 (equotion-0 float64) (equotion-1 float64) (equotion-2 float64) (equotion-3 float64) ;; *** ENUM (plane card32)) (define-rendering-command color-3b 6 ((r g b) int8)) (define-rendering-command color-3d 7 ((r g b) float64)) (define-rendering-command color-3f 8 ((r g b) float32)) (define-rendering-command color-3i 9 ((r g b) int32)) (define-rendering-command color-3s 10 ((r g b) int16)) (define-rendering-command color-3ub 11 ((r g b) card8)) (define-rendering-command color-3ui 12 ((r g b) card32)) (define-rendering-command color-3us 13 ((r g b) card16)) (define-rendering-command color-4b 14 ((r g b a) int8)) (define-rendering-command color-4d 15 ((r g b a) float64)) (define-rendering-command color-4f 16 ((r g b a) float32)) (define-rendering-command color-4i 17 ((r g b a) int32)) (define-rendering-command color-4s 18 ((r g b a) int16)) (define-rendering-command color-4ub 19 ((r g b a) card8)) (define-rendering-command color-4ui 20 ((r g b a) card32)) (define-rendering-command color-4us 21 ((r g b a) card16)) (define-rendering-command color-mask 134 (red bool) (green bool) (blue bool) (alpha bool)) (define-rendering-command color-material 78 ;; *** ENUM (face card32) ;; *** ENUM (mode card32)) (define-rendering-command color-table-parameter-fv 2054 ;; *** ENUM (target card32) ;; TODO: ;; +GL-COLOR-TABLE-SCALE+ (#x80D6) => (length params) = 4 ;; +GL-COLOR-TABLE-BIAS+ (#x80d7) => (length params) = 4 ;; else (length params) = 0 (command is erronous) ;; *** ENUM (pname card32) (params (list float32 4))) (define-rendering-command color-table-parameter-iv 2055 ;; *** ENUM (target card32) ;; TODO: ;; +GL-COLOR-TABLE-SCALE+ (#x80D6) => (length params) = 4 ;; +GL-COLOR-TABLE-BIAS+ (#x80d7) => (length params) = 4 ;; else (length params) = 0 (command is erronous) ;; *** ENUM (pname card32) (params (list int32 4))) (define-rendering-command convolution-parameter-f 4103 ;; *** ENUM (target card32) ;; *** ENUM (pname card32) (params float32)) (define-rendering-command convolution-parameter-fv 4104 ;; *** ENUM (target card32) ;; *** ENUM (pname card32) (params (list float32 (ecase pname ((#.+convolution-border-mode+ #.+convolution-format+ #.+convolution-width+ #.+convolution-height+ #.+max-convolution-width+ #.+max-convolution-width+) 1) ((#.+convolution-filter-scale+ #.+convolution-filter-bias+) 4))))) (define-rendering-command convolution-parameter-i 4105 ;; *** ENUM (target card32) ;; *** ENUM (pname card32) (params int32)) (define-rendering-command convolution-parameter-iv 4106 ;; *** ENUM (target card32) ;; *** ENUM (pname card32) (params (list int32 (ecase pname ((#.+convolution-border-mode+ #.+convolution-format+ #.+convolution-width+ #.+convolution-height+ #.+max-convolution-width+ #.+max-convolution-width+) 1) ((#.+convolution-filter-scale+ #.+convolution-filter-bias+) 4))))) (define-rendering-command copy-color-sub-table 196 ;; *** ENUM (target card32) (start int32) (x int32) (y int32) (width int32)) (define-rendering-command copy-color-table 2056 ;; *** ENUM (target card32) ;; *** ENUM (internalformat card32) (x int32) (y int32) (width int32)) (define-rendering-command copy-convolution-filter-id 4107 ;; *** ENUM (target card32) ;; *** ENUM (internalformat card32) (x int32) (y int32) (width int32)) (define-rendering-command copy-convolution-filter-2d 4108 ;; *** ENUM (target card32) ;; *** ENUM (internalformat card32) (x int32) (y int32) (width int32) (height int32)) (define-rendering-command copy-pixels 172 (x int32) (y int32) (width int32) (height int32) ;; *** ENUM (type card32)) (define-rendering-command copy-tex-image-1d 4119 ;; *** ENUM (target card32) (level int32) ;; *** ENUM (internalformat card32) (x int32) (y int32) (width int32) (border int32)) (define-rendering-command copy-tex-image-2d 4120 ;; *** ENUM (target card32) (level int32) ;; *** ENUM (internalformat card32) (x int32) (y int32) (width int32) (height int32) (border int32)) (define-rendering-command copy-tex-sub-image-1d 4121 ;; *** ENUM (target card32) (level int32) (xoffset int32) (x int32) (y int32) (width int32)) (define-rendering-command copy-tex-sub-image-2d 4122 ;; *** ENUM (target card32) (level int32) (xoffset int32) (yoffset int32) (x int32) (y int32) (width int32) (height int32)) (define-rendering-command copy-tex-sub-image-3d 4123 ;; *** ENUM (target card32) (level int32) (xoffset int32) (yoffset int32) (zoffset int32) (x int32) (y int32) (width int32) (height int32)) (define-rendering-command cull-face 79 ;; *** ENUM (mode card32)) (define-rendering-command depth-func 164 ;; *** ENUM (func card32)) (define-rendering-command depth-mask 135 (mask bool)) (define-rendering-command depth-range 174 (z-near float64) (z-far float64)) (define-rendering-command draw-buffer 126 ;; *** ENUM (mode card32)) (define-rendering-command edge-flag-v 22 (flag-0 bool)) (define-rendering-command end 23) (define-rendering-command eval-coord-1d 151 (u-0 float64)) (define-rendering-command eval-coord-1f 152 (u-0 float32)) (define-rendering-command eval-coord-2d 153 ((u-0 u-1) float64)) (define-rendering-command eval-coord-2f 154 ((u-0 u-1) float32)) (define-rendering-command eval-mesh-1 155 ;; *** ENUM (mode card32) ((i1 i2) int32)) (define-rendering-command eval-mesh-2 157 ;; *** ENUM (mode card32) ((i1 i2 j1 j2) int32)) (define-rendering-command eval-point-1 156 (i int32)) (define-rendering-command eval-point-2 158 (i int32) (j int32)) (define-rendering-command fog-f 80 ;; *** ENUM (pname card32) (param float32)) (define-rendering-command fog-fv 81 ;; *** ENUM (pname card32) (params (list float32 (ecase pname ((#.+fog-index+ #.+fog-density+ #.+fog-start+ #.+fog-end+ #.+fog-mode+) 1) ((#.+fog-color+) 4))))) (define-rendering-command fog-i 82 ;; *** ENUM (pname card32) (param int32)) (define-rendering-command fog-iv 83 ;; *** ENUM (pname card32) (params (list int32 (ecase pname ((#.+fog-index+ #.+fog-density+ #.+fog-start+ #.+fog-end+ #.+fog-mode+) 1) ((#.+fog-color+) 4))))) (define-rendering-command front-face 84 ;; *** ENUM (mode card32)) (define-rendering-command frustum 175 (left float64) (right float64) (bottom float64) (top float64) (z-near float64) (z-far float64)) (define-rendering-command hint 85 ;; *** ENUM (target card32) ;; *** ENUM (mode card32)) (define-rendering-command histogram 4110 ;; *** ENUM (target card32) (width int32) ;; *** ENUM (internalformat card32) (sink bool)) (define-rendering-command index-mask 136 (mask card32)) (define-rendering-command index-d 24 (c-0 float64)) (define-rendering-command index-f 25 (c-0 float32)) (define-rendering-command index-i 26 (c-0 int32)) (define-rendering-command index-s 27 (c-0 int16)) (define-rendering-command index-ub 194 (c-0 card8)) (define-rendering-command init-names 121) (define-rendering-command light-model-f 90 ;; *** ENUM (pname card32) (param float32)) (define-rendering-command light-model-fv 91 ;; *** ENUM (pname card32) (params (list float32 (ecase pname ((#.+light-model-color-control+ #.+light-model-local-viewer+ #.+light-model-two-side+) 1) ((#.+light-model-ambient+) 4))))) (define-rendering-command light-model-i 92 ;; *** ENUM (pname card32) (param int32)) (define-rendering-command light-model-iv 93 ;; *** ENUM (pname card32) (params (list int32 (ecase pname ((#.+light-model-color-control+ #.+light-model-local-viewer+ #.+light-model-two-side+) 1) ((#.+light-model-ambient+) 4))))) (define-rendering-command light-f 86 ;; *** ENUM (light card32) ;; *** ENUM (pname card32) (param float32)) (define-rendering-command light-fv 87 ;; *** ENUM (light card32) ;; *** ENUM (pname card32) (params (list float32 (ecase pname ((#.+ambient+ #.+diffuse+ #.+specular+ #.+position+) 4) ((#.+spot-direction+) 3) ((#.+spot-exponent+ #.+spot-cutoff+ #.+constant-attenuation+ #.+linear-attenuation+ #.+quadratic-attenuation+) 1))))) (define-rendering-command light-i 88 ;; *** ENUM (light card32) ;; *** ENUM (pname card32) (param int32)) (define-rendering-command light-iv 89 ;; *** ENUM (light card32) ;; *** ENUM (pname card32) (params (list int32 (ecase pname ((#.+ambient+ #.+diffuse+ #.+specular+ #.+position+) 4) ((#.+spot-direction+) 3) ((#.+spot-exponent+ #.+spot-cutoff+ #.+constant-attenuation+ #.+linear-attenuation+ #.+quadratic-attenuation+) 1))))) (define-rendering-command line-stipple 94 (factor int32) (pattern card16)) (define-rendering-command line-width 95 (width float32)) (define-rendering-command list-base 3 (base card32)) (define-rendering-command load-identity 176) (define-rendering-command load-matrix-d 178 (m (list float64 16))) (define-rendering-command load-matrix-f 177 (m (list float32 16))) (define-rendering-command load-name 122 (name card32)) (define-rendering-command logic-op 161 ;; *** ENUM (name card32)) (define-rendering-command map-grid-1d 147 (u1 float64) (u2 float64) (un int32)) (define-rendering-command map-grid-1f 148 (un int32) (u1 float32) (u2 float32)) (define-rendering-command map-grid-2d 149 (u1 float64) (u2 float64) (v1 float64) (v2 float64) (un int32) (vn int32)) (define-rendering-command map-grid-2f 150 (un int32) (u1 float32) (u2 float32) (vn int32) (v1 float32) (v2 float32)) (define-rendering-command material-f 96 ;; *** ENUM (face card32) ;; *** ENUM (pname card32) (param float32)) (define-rendering-command material-fv 97 ;; *** ENUM (face card32) ;; *** ENUM (pname card32) (params (list float32 (ecase pname ((#.+ambient+ #.+diffuse+ #.+specular+ #.+emission+ #.+ambient-and-diffuse+) 4) ((#.+shininess+) 1) ((#.+color-index+) 3))))) (define-rendering-command material-i 98 ;; *** ENUM (face card32) ;; *** ENUM (pname card32) (param int32)) (define-rendering-command material-iv 99 ;; *** ENUM (face card32) ;; *** ENUM (pname card32) (params (list int32 (ecase pname ((#.+ambient+ #.+diffuse+ #.+specular+ #.+emission+ #.+ambient-and-diffuse+) 4) ((#.+shininess+) 1) ((#.+color-index+) 3))))) (define-rendering-command matrix-mode 179 ;; *** ENUM (mode card32)) (define-rendering-command minmax 4111 ;; *** ENUM (target card32) ;; *** ENUM (internalformat card32) (sink bool)) (define-rendering-command mult-matrix-d 181 (m (list float64 16))) (define-rendering-command mult-matrix-f 180 (m (list float32 16))) ;;; *** Note that TARGET is placed last for FLOAT64 versions. (define-rendering-command multi-tex-coord-1d-arb 198 (v-0 float64) ;; *** ENUM (target card32)) (define-rendering-command multi-tex-coord-1f-arb 199 ;; *** ENUM (target card32) (v-0 float32)) (define-rendering-command multi-tex-coord-1i-arb 200 ;; *** ENUM (target card32) (v-0 int32)) (define-rendering-command multi-tex-coord-1s-arb 201 ;; *** ENUM (target card32) (v-0 int16)) (define-rendering-command multi-tex-coord-2d-arb 202 ((v-0 v-1) float64) ;; *** ENUM (target card32)) (define-rendering-command multi-tex-coord-2f-arb 203 ;; *** ENUM (target card32) ((v-0 v-1) float32)) (define-rendering-command multi-tex-coord-2i-arb 204 ;; *** ENUM (target card32) ((v-0 v-1) int32)) (define-rendering-command multi-tex-coord-2s-arb 205 ;; *** ENUM (target card32) ((v-0 v-1) int16)) (define-rendering-command multi-tex-coord-3d-arb 206 ((v-0 v-1 v-2) float64) ;; *** ENUM (target card32)) (define-rendering-command multi-tex-coord-3f-arb 207 ;; *** ENUM (target card32) ((v-0 v-1 v-2) float32)) (define-rendering-command multi-tex-coord-3i-arb 208 ;; *** ENUM (target card32) ((v-0 v-1 v-2) int32)) (define-rendering-command multi-tex-coord-3s-arb 209 ;; *** ENUM (target card32) ((v-0 v-1 v-2) int16)) (define-rendering-command multi-tex-coord-4d-arb 210 ((v-0 v-1 v-2 v-3) float64) ;; *** ENUM (target card32)) (define-rendering-command multi-tex-coord-4f-arb 211 ;; *** ENUM (target card32) ((v-0 v-1 v-2 v-3) float32)) (define-rendering-command multi-tex-coord-4i-arb 212 ;; *** ENUM (target card32) ((v-0 v-1 v-2 v-3) int32)) (define-rendering-command multi-tex-coord-4s-arb 213 ;; *** ENUM (target card32) ((v-0 v-1 v-2 v-3) int16)) (define-rendering-command normal-3b 28 ((v-0 v-1 v-2) int8)) (define-rendering-command normal-3d 29 ((v-0 v-1 v-2) float64)) (define-rendering-command normal-3f 30 ((v-0 v-1 v-2) float32)) (define-rendering-command normal-3i 31 ((v-0 v-1 v-2) int32)) (define-rendering-command normal-3s 32 ((v-0 v-1 v-2) int16)) (define-rendering-command ortho 182 (left float64) (right float64) (bottom float64) (top float64) (z-near float64) (z-far float64)) (define-rendering-command pass-through 123 (token float32)) (define-rendering-command pixel-transfer-f 166 ;; *** ENUM (pname card32) (param float32)) (define-rendering-command pixel-transfer-i 167 ;; *** ENUM (pname card32) (param int32)) (define-rendering-command pixel-zoom 165 (xfactor float32) (yfactor float32)) (define-rendering-command point-size 100 (size float32)) (define-rendering-command polygon-mode 101 ;; *** ENUM (face card32) ;; *** ENUM (mode card32)) (define-rendering-command polygon-offset 192 (factor float32) (units float32)) (define-rendering-command pop-attrib 141) (define-rendering-command pop-matrix 183) (define-rendering-command pop-name 124) (define-rendering-command prioritize-textures 4118 (n int32) (textures (list card32 n)) (priorities (list float32 n))) (define-rendering-command push-attrib 142 ;; *** BITFIELD (mask card32)) (define-rendering-command push-matrix 184) (define-rendering-command push-name 125 (name card32)) (define-rendering-command raster-pos-2d 33 ((v-0 v-1) float64)) (define-rendering-command raster-pos-2f 34 ((v-0 v-1) float32)) (define-rendering-command raster-pos-2i 35 ((v-0 v-1) int32)) (define-rendering-command raster-pos-2s 36 ((v-0 v-1) int16)) (define-rendering-command raster-pos-3d 37 ((v-0 v-1 v-2) float64)) (define-rendering-command raster-pos-3f 38 ((v-0 v-1 v-2) float32)) (define-rendering-command raster-pos-3i 39 ((v-0 v-1 v-2) int32)) (define-rendering-command raster-pos-3s 40 ((v-0 v-1 v-2) int16)) (define-rendering-command raster-pos-4d 41 ((v-0 v-1 v-2 v-3) float64)) (define-rendering-command raster-pos-4f 42 ((v-0 v-1 v-2 v-3) float32)) (define-rendering-command raster-pos-4i 43 ((v-0 v-1 v-2 v-3) int32)) (define-rendering-command raster-pos-4s 44 ((v-0 v-1 v-2 v-3) int16)) (define-rendering-command read-buffer 171 ;; *** ENUM (mode card32)) (define-rendering-command rect-d 45 ((v1-0 v1-1 v2-0 v2-1) float64)) (define-rendering-command rect-f 46 ((v1-0 v1-1 v2-0 v2-1) float32)) (define-rendering-command rect-i 47 ((v1-0 v1-1 v2-0 v2-1) int32)) (define-rendering-command rect-s 48 ((v1-0 v1-1 v2-0 v2-1) int16)) (define-rendering-command reset-histogram 4112 ;; *** ENUM (target card32)) (define-rendering-command reset-minmax 4113 ;; *** ENUM (target card32)) (define-rendering-command rotate-d 185 ((angle x y z) float64)) (define-rendering-command rotate-f 186 ((angle x y z) float32)) (define-rendering-command scale-d 187 ((x y z) float64)) (define-rendering-command scale-f 188 ((x y z) float32)) (define-rendering-command scissor 103 ((x y width height) int32)) (define-rendering-command shade-model 104 ;; *** ENUM (mode card32)) (define-rendering-command stencil-func 162 ;; *** ENUM (func card32) (ref int32) (mask card32)) (define-rendering-command stencil-mask 133 (mask card32)) (define-rendering-command stencil-op 163 ;; *** ENUM (fail card32) ;; *** ENUM (zfail card32) ;; *** ENUM (zpass card32)) (define-rendering-command tex-env-f 111 ;; *** ENUM (target card32) ;; *** ENUM (pname card32) (param float32)) (define-rendering-command tex-env-fv 112 ;; *** ENUM (target card32) ;; *** ENUM (pname card32) (param (list float32 (ecase pname (#.+texture-env-mode+ 1) (#.+texture-env-color+ 4))))) (define-rendering-command tex-env-i 113 ;; *** ENUM (target card32) ;; *** ENUM (pname card32) (param int32)) (define-rendering-command tex-env-iv 114 ;; *** ENUM (target card32) ;; *** ENUM (pname card32) (param (list int32 (ecase pname (#.+texture-env-mode+ 1) (#.+texture-env-color+ 4))))) ;;; *** ;;; last there. (define-rendering-command tex-gen-d 115 (param float64) ;; *** ENUM (coord card32) ;; *** ENUM (pname card32)) (define-rendering-command tex-gen-dv 116 ;; *** ENUM (coord card32) ;; *** ENUM (pname card32) ;; +texture-gen-mode+ n=1 ;; +object-plane+ n=4 ;; +eye-plane+ n=1 (params (list float64 (ecase pname ((#.+texture-gen-mode+ #.+eye-plane+) 1) (#.+object-plane+ 4))))) (define-rendering-command tex-gen-f 117 ;; *** ENUM (coord card32) ;; *** ENUM (pname card32) (param float32)) (define-rendering-command tex-gen-fv 118 ;; *** ENUM (coord card32) ;; *** ENUM (pname card32) (params (list float32 (ecase pname ((#.+texture-gen-mode+ #.+eye-plane+) 1) (#.+object-plane+ 4))))) (define-rendering-command tex-gen-i 119 ;; *** ENUM (coord card32) ;; *** ENUM (pname card32) (param int32)) (define-rendering-command tex-gen-iv 120 ;; *** ENUM (coord card32) ;; *** ENUM (pname card32) (params (list int32 (ecase pname ((#.+texture-gen-mode+ #.+eye-plane+) 1) (#.+object-plane+ 4))))) (define-rendering-command tex-parameter-f 105 ;; *** ENUM (target card32) ;; *** ENUM (pname card32) (param float32)) (define-rendering-command tex-parameter-fv 106 ;; *** ENUM (target card32) ;; *** ENUM (pname card32) (params (list float32 (ecase pname ((#.+texture-border-color+) 4) ((#.+texture-mag-filter+ #.+texture-min-filter+ #.+texture-wrap-s+ #.+texture-wrap-t+) 1))))) (define-rendering-command tex-parameter-i 107 ;; *** ENUM (target card32) ;; *** ENUM (pname card32) (param int32)) (define-rendering-command tex-parameter-iv 108 ;; *** ENUM (target card32) ;; *** ENUM (pname card32) (params (list int32 (ecase pname ((#.+texture-border-color+) 4) ((#.+texture-mag-filter+ #.+texture-min-filter+ #.+texture-wrap-s+ #.+texture-wrap-t+) 1))))) (define-rendering-command translate-d 189 ((x y z) float64)) (define-rendering-command translate-f 190 ((x y z) float32)) (define-rendering-command vertex-2d 65 ((x y) float64)) (define-rendering-command vertex-2f 66 ((x y) float32)) (define-rendering-command vertex-2i 67 ((x y) int32)) (define-rendering-command vertex-2s 68 ((x y) int16)) (define-rendering-command vertex-3d 69 ((x y z) float64)) (define-rendering-command vertex-3f 70 ((x y z) float32)) (define-rendering-command vertex-3i 71 ((x y z) int32)) (define-rendering-command vertex-3s 72 ((x y z) int16)) (define-rendering-command vertex-4d 73 ((x y z w) float64)) (define-rendering-command vertex-4f 74 ((x y z w) float32)) (define-rendering-command vertex-4i 75 ((x y z w) int32)) (define-rendering-command vertex-4s 76 ((x y z w) int16)) (define-rendering-command viewport 191 ((x y width height) int32)) ;;; Potentially lerge rendering commands. #-(and) (define-large-rendering-command call-lists 2 (n int32) ;; *** ENUM (type card32) (lists (list type n))) ;;; Requests for GL non-rendering commands. (defun new-list (list mode) (assert (context-p *current-context*) (*current-context*) "~S is not a context." *current-context*) (let* ((ctx *current-context*) (display (context-display ctx))) (with-buffer-request (display (extension-opcode display "GLX")) (data +new-list+) ;; *** GLX_CONTEXT_TAG (card32 (context-tag ctx)) (card32 list) ;; *** ENUM (card32 mode)))) (defun gen-lists (range) (assert (context-p *current-context*) (*current-context*) "~S is not a context." *current-context*) (let* ((ctx *current-context*) (display (context-display ctx))) (with-buffer-request-and-reply (display (extension-opcode display "GLX") nil) ((data +gen-lists+) ;; *** GLX_CONTEXT_TAG (card32 (context-tag ctx)) (integer range)) (card32-get 8)))) (defun end-list () (assert (context-p *current-context*) (*current-context*) "~S is not a context." *current-context*) (let* ((ctx *current-context*) (display (context-display ctx))) (with-buffer-request (display (extension-opcode display "GLX")) (data +end-list+) ;; *** GLX_CONTEXT_TAG (card32 (context-tag ctx))))) (defun enable (cap) (assert (context-p *current-context*) (*current-context*) "~S is not a context." *current-context*) (let* ((ctx *current-context*) (display (context-display ctx))) (with-buffer-request-and-reply (display (extension-opcode display "GLX") nil) ((data +enable+) ;; *** GLX_CONTEXT_TAG (card32 (context-tag ctx)) ;; *** ENUM? (card32 cap))))) ;;; FIXME: FLUSH and FINISH should send *all* buffered data, including ;;; buffered rendering commands. (defun flush () (assert (context-p *current-context*) (*current-context*) "~S is not a context." *current-context*) (let* ((ctx *current-context*) (display (context-display ctx))) (with-buffer-request (display (extension-opcode display "GLX")) (data +flush+) ;; *** GLX_CONTEXT_TAG (card32 (context-tag ctx))))) (defun finish () (assert (context-p *current-context*) (*current-context*) "~S is not a context." *current-context*) (let* ((ctx *current-context*) (display (context-display ctx))) (with-buffer-request-and-reply (display (extension-opcode display "GLX") nil) ((data +finish+) ;; *** GLX_CONTEXT_TAG (card32 (context-tag ctx)))))) ecl-16.1.2/src/clx/glx.lisp000066400000000000000000000532721266352375300154310ustar00rootroot00000000000000(defpackage :glx (:use :common-lisp :xlib) (:import-from :xlib "DEFINE-ACCESSOR" "DEF-CLX-CLASS" "DECLARE-EVENT" "ALLOCATE-RESOURCE-ID" "DEALLOCATE-RESOURCE-ID" "PRINT-DISPLAY-NAME" "WITH-BUFFER-REQUEST" "WITH-BUFFER-REQUEST-AND-REPLY" "READ-CARD32" "WRITE-CARD32" "CARD32-GET" "CARD8-GET" "SEQUENCE-GET" "SEQUENCE-PUT" "DATA" ;; Types "ARRAY-INDEX" "BUFFER-BYTES" "WITH-DISPLAY" "BUFFER-FLUSH" "BUFFER-WRITE" "BUFFER-FORCE-OUTPUT" "ASET-CARD8" "ASET-CARD16" "ASET-CARD32" ) (:export ;; Constants "+VENDOR+" "+VERSION+" "+EXTENSIONS+" ;; Conditions "BAD-CONTEXT" "BAD-CONTEXT-STATE" "BAD-DRAWABLE" "BAD-PIXMAP" "BAD-CONTEXT-TAG" "BAD-CURRENT-WINDOW" "BAD-RENDER-REQUEST" "BAD-LARGE-REQUEST" "UNSUPPORTED-PRIVATE-REQUEST" "BAD-FB-CONFIG" "BAD-PBUFFER" "BAD-CURRENT-DRAWABLE" "BAD-WINDOW" ;; Requests "QUERY-VERSION" "QUERY-SERVER-STRING" "CREATE-CONTEXT" "DESTROY-CONTEXT" "IS-DIRECT" "QUERY-CONTEXT" "GET-DRAWABLE-ATTRIBUTES" "MAKE-CURRENT" ;;"GET-VISUAL-CONFIGS" "CHOOSE-VISUAL" "VISUAL-ATTRIBUTE" "VISUAL-ID" "RENDER" "SWAP-BUFFERS" "WAIT-GL" "WAIT-X" )) (in-package :glx) (declaim (optimize (debug 3) (safety 3))) (define-extension "GLX" :events (:glx-pbuffer-clobber) :errors (bad-context bad-context-state bad-drawable bad-pixmap bad-context-tag bad-current-window bad-render-request bad-large-request unsupported-private-request bad-fb-config bad-pbuffer bad-current-drawable bad-window)) ;;; Opcodes. (eval-when (:compile-toplevel :load-toplevel :execute) (defconstant +render+ 1) (defconstant +create-context+ 3) (defconstant +destroy-context+ 4) (defconstant +make-current+ 5) (defconstant +is-direct+ 6) (defconstant +query-version+ 7) (defconstant +wait-gl+ 8) (defconstant +wait-x+ 9) (defconstant +copy-context+ 10) (defconstant +swap-buffers+ 11) (defconstant +get-visual-configs+ 14) (defconstant +destroy-glx-pixmap+ 15) (defconstant +query-server-string+ 19) (defconstant +client-info+ 20) (defconstant +get-fb-configs+ 21) (defconstant +query-context+ 25) (defconstant +get-drawable-attributes+ 29) ) ;;; Constants (eval-when (:compile-toplevel :load-toplevel :execute) (defconstant +vendor+ 1) (defconstant +version+ 2) (defconstant +extensions+ 3) ) ;;; Types ;;; FIXME: ;;; - Are all the 32-bit values unsigned? Do we care? ;;; - These are not used much, yet. (progn (deftype attribute-pair ()) (deftype bitfield () 'mask32) (deftype bool32 () 'card32) ; 1 for true and 0 for false (deftype enum () 'card32) (deftype fbconfigid () 'card32) ;; FIXME: How to define these two? (deftype float32 () 'single-float) (deftype float64 () 'double-float) ;;(deftype glx-context () 'card32) (deftype context-tag () 'card32) ;;(deftype glx-drawable () 'card32) (deftype glx-pixmap () 'card32) (deftype glx-pbuffer () 'card32) (deftype glx-render-command () #|TODO|#) (deftype glx-window () 'card32) #-(and) (deftype visual-property () "An ordered list of 32-bit property values followed by unordered pairs of property types and property values." ;; FIXME: maybe CLX-LIST or even just LIST? 'clx-sequence)) ;;; FIXME: DEFINE-ACCESSOR interns getter and setter in XLIB package ;;; (using XINTERN). Therefore the accessors defined below can only ;;; be accessed using double-colon, which is a bad style. Or these ;;; forms must be taken to another file so the accessors exist before ;;; we get to this file. #-(and) (define-accessor glx-context-tag (32) ((index) `(read-card32 ,index)) ((index thing) `(write-card32 ,index ,thing))) #-(and) (define-accessor glx-enum (32) ((index) `(read-card32 ,index)) ((index thing) `(write-card32 ,index ,thing))) ;;; FIXME: I'm just not sure we need a seperate accessors for what ;;; essentially are aliases for other types. Maybe use compiler ;;; macros? ;;; ;;; This trick won't do because CLX wants e.g. CONTEXT-TAG to be a ;;; known accessor. The only trick left I think is to change the ;;; XINTERN function to intern the new symbols in the same package as ;;; he symbol part of it comes from. Don't know if it would break ;;; anything, thought. (I would be quite surprised if it did -- there ;;; is only one package in CLX after all: XLIB.) ;;; ;;; I also found the origin of the error (about symbol not being a ;;; known accessor): INDEX-INCREMENT function. Looks like all we have ;;; to do is to add an XLIB::BYTE-WIDTH property to the type symbol ;;; plist. But accessors are macros, not functions, anyway. #-(and) (progn (declaim (inline context-tag-get context-tag-put enum-get enum-put)) (defun context-tag-get (index) (card32-get index)) (defun context-tag-put (index thing) (card32-put index thing)) (defun enum-get (index) (card32-get index)) (defun enum-put (index thing) (card32-put index thing)) ) ;;; Structures (def-clx-class (context (:constructor %make-context) (:print-function print-context) (:copier nil)) (id 0 :type resource-id) (display nil :type (or null display)) (tag 0 :type card32) (drawable nil :type (or null drawable)) ;; TODO: There can only be one current context (as far as I ;; understand). If so, we'd need only one buffer (otherwise it's a ;; big waste to have a quarter megabyte buffer for each context; or ;; we could allocate/grow the buffer on demand). ;; ;; 256k buffer for Render command. Big requests are served with ;; RenderLarge command. First 8 octets are Render request fields. ;; (rbuf (make-array (+ 8 (* 256 1024)) :element-type '(unsigned-byte 8)) :type buffer-bytes) ;; Index into RBUF where the next rendering command should be inserted. (index 8 :type array-index)) (defun print-context (ctx stream depth) (declare (type context ctx) (ignore depth)) (print-unreadable-object (ctx stream :type t) (print-display-name (context-display ctx) stream) (write-string " " stream) (princ (context-id ctx) stream))) (def-clx-class (visual (:constructor %make-visual) (:print-function print-visual) (:copier nil)) (id 0 :type resource-id) (attributes nil :type list)) (defun print-visual (visual stream depth) (declare (type visual visual) (ignore depth)) (print-unreadable-object (visual stream :type t) (write-string "ID: " stream) (princ (visual-id visual) stream) (write-string " " stream) (princ (visual-attributes visual) stream))) ;;; Events. (defconstant +damaged+ #x8017) (defconstant +saved+ #x8018) (defconstant +window+ #x8019) (defconstant +pbuffer+ #x801a) (declare-event :glx-pbuffer-clobber (card16 sequence) (card16 event-type) ;; +DAMAGED+ or +SAVED+ (card16 draw-type) ;; +WINDOW+ or +PBUFFER+ (resource-id drawable) ;; FIXME: (bitfield buffer-mask) (card32 buffer-mask) (card16 aux-buffer) (card16 x y width height count)) ;;; Errors. (define-condition bad-context (request-error) ()) (define-condition bad-context-state (request-error) ()) (define-condition bad-drawable (request-error) ()) (define-condition bad-pixmap (request-error) ()) (define-condition bad-context-tag (request-error) ()) (define-condition bad-current-window (request-error) ()) (define-condition bad-render-request (request-error) ()) (define-condition bad-large-request (request-error) ()) (define-condition unsupported-private-request (request-error) ()) (define-condition bad-fb-config (request-error) ()) (define-condition bad-pbuffer (request-error) ()) (define-condition bad-current-drawable (request-error) ()) (define-condition bad-window (request-error) ()) (define-error bad-context decode-core-error) (define-error bad-context-state decode-core-error) (define-error bad-drawable decode-core-error) (define-error bad-pixmap decode-core-error) (define-error bad-context-tag decode-core-error) (define-error bad-current-window decode-core-error) (define-error bad-render-request decode-core-error) (define-error bad-large-request decode-core-error) (define-error unsupported-private-request decode-core-error) (define-error bad-fb-config decode-core-error) (define-error bad-pbuffer decode-core-error) (define-error bad-current-drawable decode-core-error) (define-error bad-window decode-core-error) ;;; Requests. (defun query-version (display) (with-buffer-request-and-reply (display (extension-opcode display "GLX") nil) ((data +query-version+) (card32 1) (card32 3)) (values (card32-get 8) (card32-get 12)))) (defun query-server-string (display screen name) "NAME is one of +VENDOR+, +VERSION+ or +EXTENSIONS+" (with-buffer-request-and-reply (display (extension-opcode display "GLX") nil) ((data +query-server-string+) (card32 (or (position screen (display-roots display) :test #'eq) 0)) (card32 name)) (let* ((length (card32-get 12)) (bytes (sequence-get :format card8 :result-type '(simple-array card8 (*)) :index 32 :length length))) (declare (type (simple-array card8 (*)) bytes) (type fixnum length)) (map-into (make-string (1- length)) #'code-char bytes)))) (defun client-info (display) ;; TODO: This should be invoked automatically when using this ;; library in initialization stage. ;; ;; TODO: No extensions supported yet. ;; ;; *** Maybe the LENGTH field must be filled in some special way ;; (similar to data)? (with-buffer-request (display (extension-opcode display "GLX")) (data +client-info+) (card32 4) ; length of the request (card32 1) ; major (card32 3) ; minor (card32 0) ; n )) ;;; XXX: This looks like an internal thing. Should name appropriately. (defun make-context (display) (let ((ctx (%make-context :display display))) (setf (context-id ctx) (allocate-resource-id display ctx 'context)) ;; Prepare render request buffer. ctx)) (defun create-context (screen visual &optional (share-list 0) (is-direct nil)) "Do NOT use the direct mode, yet!" (let* ((root (screen-root screen)) (display (drawable-display root)) (ctx (make-context display))) (with-buffer-request (display (extension-opcode display "GLX")) (data +create-context+) (resource-id (context-id ctx)) (resource-id visual) (card32 (or (position screen (display-roots display) :test #'eq) 0)) (resource-id share-list) (boolean is-direct)) ctx)) ;;; TODO: Maybe make this var private to GLX-MAKE-CURRENT and GLX-GET-CURRENT-CONTEXT only? ;;; (defvar *current-context* nil) (defun destroy-context (ctx) (let ((id (context-id ctx)) (display (context-display ctx))) (with-buffer-request (display (extension-opcode display "GLX")) (data +destroy-context+) (resource-id id)) (deallocate-resource-id display id 'context) (setf (context-id ctx) 0) (when (eq ctx *current-context*) (setf *current-context* nil)))) (defun is-direct (ctx) (let ((display (context-display ctx))) (with-buffer-request-and-reply (display (extension-opcode display "GLX") nil) ((data +is-direct+) (resource-id (context-id ctx))) (card8-get 8)))) (defun query-context (ctx) ;; TODO: What are the attribute types? (let ((display (context-display ctx))) (with-buffer-request-and-reply (display (extension-opcode display "GLX") nil) ((data +query-context+) (resource-id (context-id ctx))) (let ((num-attributes (card32-get 8))) ;; FIXME: Is this really so? (declare (type fixnum num-attributes)) (loop repeat num-attributes for i fixnum upfrom 32 by 8 collecting (cons (card32-get i) (card32-get (+ i 4)))))))) (defun get-drawable-attributes (drawable) (let ((display (drawable-display drawable))) (with-buffer-request-and-reply (display (extension-opcode display "GLX") nil) ((data +get-drawable-attributes+) (drawable drawable)) (let ((num-attributes (card32-get 8))) ;; FIXME: Is this really so? (declare (type fixnum num-attributes)) (loop repeat num-attributes for i fixnum upfrom 32 by 8 collecting (cons (card32-get i) (card32-get (+ i 4)))))))) ;;; TODO: What is the idea behind passing drawable to this function? ;;; Can a context be made current for different drawables at different ;;; times? (Man page on glXMakeCurrent says that context's viewport ;;; is set to the size of drawable when creating; it does not change ;;; afterwards.) ;;; (defun make-current (drawable ctx) (let ((display (drawable-display drawable)) (old-tag (if *current-context* (context-tag *current-context*) 0))) (with-buffer-request-and-reply (display (extension-opcode display "GLX") nil) ((data +make-current+) (resource-id (drawable-id drawable)) (resource-id (context-id ctx)) ;; *** CARD32 is really a CONTEXT-TAG (card32 old-tag)) (let ((new-tag (card32-get 8))) (setf (context-tag ctx) new-tag (context-drawable ctx) drawable (context-display ctx) display *current-context* ctx))))) ;;; FIXME: Decide how to represent and use these. (eval-when (:load-toplevel :compile-toplevel :execute) (macrolet ((generate-config-properties () (let ((list '((:glx-visual visual-id) (:glx-class card32) (:glx-rgba bool32) (:glx-red-size card32) (:glx-green-size card32) (:glx-blue-size card32) (:glx-alpha-size card32) (:glx-accum-red-size card32) (:glx-accum-green-size card32) (:glx-accum-blue-size card32) (:glx-accum-alpha-size card32) (:glx-double-buffer bool32) (:glx-stereo bool32) (:glx-buffer-size card32) (:glx-depth-size card32) (:glx-stencil-size card32) (:glx-aux-buffers card32) (:glx-level int32)))) `(progn ,@(loop for (symbol type) in list collect `(setf (get ',symbol 'visual-config-property-type) ',type)) (defparameter *visual-config-properties* (map 'vector #'car ',list)) (declaim (type simple-vector *visual-config-properties*)) (deftype visual-config-property () '(member ,@(mapcar #'car list))))))) (generate-config-properties))) (defun make-visual (attributes) (let ((id-cons (first attributes))) (assert (eq :glx-visual (car id-cons)) (id-cons) "GLX visual id must be first in attributes list!") (%make-visual :id (cdr id-cons) :attributes (rest attributes)))) (defun visual-attribute (visual attribute) (assert (or (numberp attribute) (find attribute *visual-config-properties*)) (attribute) "~S is not a known GLX visual attribute." attribute) (cdr (assoc attribute (visual-attributes visual)))) ;;; TODO: Make this return nice structured objects with field values of correct type. ;;; FIXME: Looks like every other result is corrupted. (defun get-visual-configs (screen) (let ((display (drawable-display (screen-root screen)))) (with-buffer-request-and-reply (display (extension-opcode display "GLX") nil) ((data +get-visual-configs+) (card32 (or (position screen (display-roots display) :test #'eq) 0))) (let* ((num-visuals (card32-get 8)) (num-properties (card32-get 12)) (num-ordered (length *visual-config-properties*))) ;; FIXME: Is this really so? (declare (type fixnum num-ordered num-visuals num-properties)) (loop with index fixnum = 28 repeat num-visuals collecting (make-visual (nconc (when (<= num-ordered num-properties) (map 'list #'(lambda (property) (cons property (card32-get (incf index 4)))) *visual-config-properties*)) (when (< num-ordered num-properties) (loop repeat (/ (- num-properties num-ordered) 2) collecting (cons (card32-get (incf index 4)) (card32-get (incf index 4)))))))))))) (defun choose-visual (screen attributes) "ATTRIBUTES is a list of desired attributes for a visual. The elements may be either a symbol, which means that the boolean attribute with that name must be true; or it can be a list of the form: (attribute-name value &optional (test '<=)) which means that the attribute named attribute-name must satisfy the test when applied to the given value and attribute's value in visual. Example: '(:glx-rgba (:glx-alpha-size 4) :glx-double-buffer (:glx-class 4 =)." ;; TODO: Add type checks ;; ;; TODO: This function checks only supplied attributes; should check ;; all attributes, with default for boolean type being false, and ;; for number types zero. ;; ;; TODO: Make this smarter, like the docstring says, instead of ;; parrotting the inflexible C API. ;; (flet ((visual-matches-p (visual attributes) (dolist (attribute attributes t) (etypecase attribute (symbol (not (null (visual-attribute visual attribute)))) (cons (<= (second attribute) (visual-attribute visual (car attribute)))))))) (let* ((visuals (get-visual-configs screen)) (candidates (loop for visual in visuals when (visual-matches-p visual attributes) collect visual)) (result (first candidates))) (dolist (candidate (rest candidates)) ;; Visuals with glx-class 3 (pseudo-color) and 4 (true-color) ;; are preferred over glx-class 2 (static-color) and 5 (direct-color). (let ((class (visual-attribute candidate :glx-class))) (when (or (= class 3) (= class 4)) (setf result candidate)))) result))) (defun render () (declare (optimize (debug 3))) (assert (context-p *current-context*) (*current-context*) "~S is not a context." *current-context*) (let* ((ctx *current-context*) (display (context-display ctx)) (rbuf (context-rbuf ctx)) (index (context-index ctx))) (declare (type buffer-bytes rbuf) (type array-index index)) (when (< 8 index) (with-display (display) ;; Flush display's buffer first so we don't get messed up with X requests. (buffer-flush display) ;; First, update the Render request fields. (aset-card8 (extension-opcode display "GLX") rbuf 0) (aset-card8 1 rbuf 1) (aset-card16 (ceiling index 4) rbuf 2) (aset-card32 (context-tag ctx) rbuf 4) ;; Then send the request. (buffer-write rbuf display 0 (context-index ctx)) ;; Start filling from the beginning (setf (context-index ctx) 8))) (values))) (defun swap-buffers () (assert (context-p *current-context*) (*current-context*) "~S is not a context." *current-context*) (let* ((ctx *current-context*) (display (context-display ctx))) ;; Make sure all rendering commands are sent away. (glx:render) (with-buffer-request (display (extension-opcode display "GLX")) (data +swap-buffers+) ;; *** GLX_CONTEXT_TAG (card32 (context-tag ctx)) (resource-id (drawable-id (context-drawable ctx)))) (display-force-output display))) ;;; FIXME: These two are more complicated than sending messages. As I ;;; understand it, wait-gl should inhibit any X requests until all GL ;;; requests are sent... (defun wait-gl () (assert (context-p *current-context*) (*current-context*) "~S is not a context." *current-context*) (let* ((ctx *current-context*) (display (context-display ctx))) (with-buffer-request (display (extension-opcode display "GLX")) (data +wait-gl+) ;; *** GLX_CONTEXT_TAG (card32 (context-tag ctx))))) (defun wait-x () (assert (context-p *current-context*) (*current-context*) "~S is not a context." *current-context*) (let* ((ctx *current-context*) (display (context-display ctx))) (with-buffer-request (display (extension-opcode display "GLX")) (data +wait-x+) ;; *** GLX_CONTEXT_TAG (card32 (context-tag ctx))))) ecl-16.1.2/src/clx/graphics.lisp000066400000000000000000000474131266352375300164370ustar00rootroot00000000000000;;; -*- Mode: LISP; Syntax: Common-lisp; Package: XLIB; Base: 10; Lowercase: Yes -*- ;;; CLX drawing requests ;;; ;;; TEXAS INSTRUMENTS INCORPORATED ;;; P.O. BOX 2909 ;;; AUSTIN, TEXAS 78769 ;;; ;;; Copyright (C) 1987 Texas Instruments Incorporated. ;;; ;;; Permission is granted to any individual or institution to use, copy, modify, ;;; and distribute this software, provided that this complete copyright and ;;; permission notice is maintained, intact, in all copies and supporting ;;; documentation. ;;; ;;; Texas Instruments Incorporated provides this software "as is" without ;;; express or implied warranty. ;;; (in-package :xlib) (defvar *inhibit-appending* nil) (defun draw-point (drawable gcontext x y) ;; Should be clever about appending to existing buffered protocol request. (declare (type drawable drawable) (type gcontext gcontext) (type int16 x y)) (let ((display (drawable-display drawable))) (declare (type display display)) (with-display (display) (force-gcontext-changes-internal gcontext) (with-buffer-output (display :length +requestsize+) (let* ((last-request-byte (display-last-request display)) (current-boffset buffer-boffset)) ;; To append or not append, that is the question (if (and (not *inhibit-appending*) last-request-byte ;; Same request? (= (aref-card8 buffer-bbuf last-request-byte) +x-polypoint+) (progn ;; Set buffer pointers to last request (set-buffer-offset last-request-byte) ;; same drawable and gcontext? (or (compare-request (4) (data 0) (drawable drawable) (gcontext gcontext)) (progn ;; If failed, reset buffer pointers (set-buffer-offset current-boffset) nil)))) ;; Append request (progn ;; Set new request length (card16-put 2 (index+ 1 (index-ash (index- current-boffset last-request-byte) -2))) (set-buffer-offset current-boffset) (put-items (0) ; Insert new point (int16 x y)) (setf (display-boffset display) (index+ buffer-boffset 4))) ;; New Request (progn (put-items (4) (code +x-polypoint+) (data 0) ;; Relative-p false (length 4) (drawable drawable) (gcontext gcontext) (int16 x y)) (buffer-new-request-number display) (setf (buffer-last-request display) buffer-boffset) (setf (display-boffset display) (index+ buffer-boffset 16))))))) (display-invoke-after-function display))) (defun draw-points (drawable gcontext points &optional relative-p) (declare (type drawable drawable) (type gcontext gcontext) (type sequence points) ;(repeat-seq (integer x) (integer y)) (type generalized-boolean relative-p)) (with-buffer-request ((drawable-display drawable) +x-polypoint+ :gc-force gcontext) ((data boolean) relative-p) (drawable drawable) (gcontext gcontext) ((sequence :format int16) points))) (defun draw-line (drawable gcontext x1 y1 x2 y2 &optional relative-p) ;; Should be clever about appending to existing buffered protocol request. (declare (type drawable drawable) (type gcontext gcontext) (type int16 x1 y1 x2 y2) (type generalized-boolean relative-p)) (let ((display (drawable-display drawable))) (declare (type display display)) (when relative-p (incf x2 x1) (incf y2 y1)) (with-display (display) (force-gcontext-changes-internal gcontext) (with-buffer-output (display :length +requestsize+) (let* ((last-request-byte (display-last-request display)) (current-boffset buffer-boffset)) ;; To append or not append, that is the question (if (and (not *inhibit-appending*) last-request-byte ;; Same request? (= (aref-card8 buffer-bbuf last-request-byte) +x-polysegment+) (progn ;; Set buffer pointers to last request (set-buffer-offset last-request-byte) ;; same drawable and gcontext? (or (compare-request (4) (drawable drawable) (gcontext gcontext)) (progn ;; If failed, reset buffer pointers (set-buffer-offset current-boffset) nil)))) ;; Append request (progn ;; Set new request length (card16-put 2 (index+ 2 (index-ash (index- current-boffset last-request-byte) -2))) (set-buffer-offset current-boffset) (put-items (0) ; Insert new point (int16 x1 y1 x2 y2)) (setf (display-boffset display) (index+ buffer-boffset 8))) ;; New Request (progn (put-items (4) (code +x-polysegment+) (length 5) (drawable drawable) (gcontext gcontext) (int16 x1 y1 x2 y2)) (buffer-new-request-number display) (setf (buffer-last-request display) buffer-boffset) (setf (display-boffset display) (index+ buffer-boffset 20))))))) (display-invoke-after-function display))) (defun draw-lines (drawable gcontext points &key relative-p fill-p (shape :complex)) (declare (type drawable drawable) (type gcontext gcontext) (type sequence points) ;(repeat-seq (integer x) (integer y)) (type generalized-boolean relative-p fill-p) (type (member :complex :non-convex :convex) shape)) (if fill-p (fill-polygon drawable gcontext points relative-p shape) (with-buffer-request ((drawable-display drawable) +x-polyline+ :gc-force gcontext) ((data boolean) relative-p) (drawable drawable) (gcontext gcontext) ((sequence :format int16) points)))) ;; Internal function called from DRAW-LINES (defun fill-polygon (drawable gcontext points relative-p shape) ;; This is clever about appending to previous requests. Should it be? (declare (type drawable drawable) (type gcontext gcontext) (type sequence points) ;(repeat-seq (integer x) (integer y)) (type generalized-boolean relative-p) (type (member :complex :non-convex :convex) shape)) (with-buffer-request ((drawable-display drawable) +x-fillpoly+ :gc-force gcontext) (drawable drawable) (gcontext gcontext) ((member8 :complex :non-convex :convex) shape) (boolean relative-p) ((sequence :format int16) points))) (defun draw-segments (drawable gcontext segments) (declare (type drawable drawable) (type gcontext gcontext) ;; (repeat-seq (integer x1) (integer y1) (integer x2) (integer y2))) (type sequence segments)) (with-buffer-request ((drawable-display drawable) +x-polysegment+ :gc-force gcontext) (drawable drawable) (gcontext gcontext) ((sequence :format int16) segments))) (defun draw-rectangle (drawable gcontext x y width height &optional fill-p) ;; Should be clever about appending to existing buffered protocol request. (declare (type drawable drawable) (type gcontext gcontext) (type int16 x y) (type card16 width height) (type generalized-boolean fill-p)) (let ((display (drawable-display drawable)) (request (if fill-p +x-polyfillrectangle+ +x-polyrectangle+))) (declare (type display display) (type card16 request)) (with-display (display) (force-gcontext-changes-internal gcontext) (with-buffer-output (display :length +requestsize+) (let* ((last-request-byte (display-last-request display)) (current-boffset buffer-boffset)) ;; To append or not append, that is the question (if (and (not *inhibit-appending*) last-request-byte ;; Same request? (= (aref-card8 buffer-bbuf last-request-byte) request) (progn ;; Set buffer pointers to last request (set-buffer-offset last-request-byte) ;; same drawable and gcontext? (or (compare-request (4) (drawable drawable) (gcontext gcontext)) (progn ;; If failed, reset buffer pointers (set-buffer-offset current-boffset) nil)))) ;; Append request (progn ;; Set new request length (card16-put 2 (index+ 2 (index-ash (index- current-boffset last-request-byte) -2))) (set-buffer-offset current-boffset) (put-items (0) ; Insert new point (int16 x y) (card16 width height)) (setf (display-boffset display) (index+ buffer-boffset 8))) ;; New Request (progn (put-items (4) (code request) (length 5) (drawable drawable) (gcontext gcontext) (int16 x y) (card16 width height)) (buffer-new-request-number display) (setf (buffer-last-request display) buffer-boffset) (setf (display-boffset display) (index+ buffer-boffset 20))))))) (display-invoke-after-function display))) (defun draw-rectangles (drawable gcontext rectangles &optional fill-p) (declare (type drawable drawable) (type gcontext gcontext) ;; (repeat-seq (integer x) (integer y) (integer width) (integer height))) (type sequence rectangles) (type generalized-boolean fill-p)) (with-buffer-request ((drawable-display drawable) (if fill-p +x-polyfillrectangle+ +x-polyrectangle+) :gc-force gcontext) (drawable drawable) (gcontext gcontext) ((sequence :format int16) rectangles))) (defun draw-arc (drawable gcontext x y width height angle1 angle2 &optional fill-p) ;; Should be clever about appending to existing buffered protocol request. (declare (type drawable drawable) (type gcontext gcontext) (type int16 x y) (type card16 width height) (type angle angle1 angle2) (type generalized-boolean fill-p)) (let ((display (drawable-display drawable)) (request (if fill-p +x-polyfillarc+ +x-polyarc+))) (declare (type display display) (type card16 request)) (with-display (display) (force-gcontext-changes-internal gcontext) (with-buffer-output (display :length +requestsize+) (let* ((last-request-byte (display-last-request display)) (current-boffset buffer-boffset)) ;; To append or not append, that is the question (if (and (not *inhibit-appending*) last-request-byte ;; Same request? (= (aref-card8 buffer-bbuf last-request-byte) request) (progn ;; Set buffer pointers to last request (set-buffer-offset last-request-byte) ;; same drawable and gcontext? (or (compare-request (4) (drawable drawable) (gcontext gcontext)) (progn ;; If failed, reset buffer pointers (set-buffer-offset current-boffset) nil)))) ;; Append request (progn ;; Set new request length (card16-put 2 (index+ 3 (index-ash (index- current-boffset last-request-byte) -2))) (set-buffer-offset current-boffset) (put-items (0) ; Insert new point (int16 x y) (card16 width height) (angle angle1 angle2)) (setf (display-boffset display) (index+ buffer-boffset 12))) ;; New Request (progn (put-items (4) (code request) (length 6) (drawable drawable) (gcontext gcontext) (int16 x y) (card16 width height) (angle angle1 angle2)) (buffer-new-request-number display) (setf (buffer-last-request display) buffer-boffset) (setf (display-boffset display) (index+ buffer-boffset 24))))))) (display-invoke-after-function display))) (defun draw-arcs-list (drawable gcontext arcs &optional fill-p) (declare (type drawable drawable) (type gcontext gcontext) (type list arcs) (type generalized-boolean fill-p)) (let* ((display (drawable-display drawable)) (limit (index- (buffer-size display) 12)) (length (length arcs)) (request (if fill-p +x-polyfillarc+ +x-polyarc+))) (with-buffer-request ((drawable-display drawable) request :gc-force gcontext) (drawable drawable) (gcontext gcontext) (progn (card16-put 2 (index+ (index-ash length -1) 3)) ; Set request length (in words) (set-buffer-offset (index+ buffer-boffset 12)) ; Position to start of data (do ((arc arcs)) ((endp arc) (setf (buffer-boffset display) buffer-boffset)) ;; Make sure there's room (when (index>= buffer-boffset limit) (setf (buffer-boffset display) buffer-boffset) (buffer-flush display) (set-buffer-offset (buffer-boffset display))) (int16-put 0 (pop arc)) (int16-put 2 (pop arc)) (card16-put 4 (pop arc)) (card16-put 6 (pop arc)) (angle-put 8 (pop arc)) (angle-put 10 (pop arc)) (set-buffer-offset (index+ buffer-boffset 12))))))) (defun draw-arcs-vector (drawable gcontext arcs &optional fill-p) (declare (type drawable drawable) (type gcontext gcontext) (type vector arcs) (type generalized-boolean fill-p)) (let* ((display (drawable-display drawable)) (limit (index- (buffer-size display) 12)) (length (length arcs)) (request (if fill-p +x-polyfillarc+ +x-polyarc+))) (with-buffer-request ((drawable-display drawable) request :gc-force gcontext) (drawable drawable) (gcontext gcontext) (progn (card16-put 2 (index+ (index-ash length -1) 3)) ; Set request length (in words) (set-buffer-offset (index+ buffer-boffset 12)) ; Position to start of data (do ((n 0 (index+ n 6)) (length (length arcs))) ((index>= n length) (setf (buffer-boffset display) buffer-boffset)) ;; Make sure there's room (when (index>= buffer-boffset limit) (setf (buffer-boffset display) buffer-boffset) (buffer-flush display) (set-buffer-offset (buffer-boffset display))) (int16-put 0 (aref arcs (index+ n 0))) (int16-put 2 (aref arcs (index+ n 1))) (card16-put 4 (aref arcs (index+ n 2))) (card16-put 6 (aref arcs (index+ n 3))) (angle-put 8 (aref arcs (index+ n 4))) (angle-put 10 (aref arcs (index+ n 5))) (set-buffer-offset (index+ buffer-boffset 12))))))) (defun draw-arcs (drawable gcontext arcs &optional fill-p) (declare (type drawable drawable) (type gcontext gcontext) (type sequence arcs) (type generalized-boolean fill-p)) (etypecase arcs (list (draw-arcs-list drawable gcontext arcs fill-p)) (vector (draw-arcs-vector drawable gcontext arcs fill-p)))) ;; The following image routines are bare minimum. It may be useful to define ;; some form of "image" object to hide representation details and format ;; conversions. It also may be useful to provide stream-oriented interfaces ;; for reading and writing the data. (defun put-raw-image (drawable gcontext data &key (start 0) (depth (required-arg depth)) (x (required-arg x)) (y (required-arg y)) (width (required-arg width)) (height (required-arg height)) (left-pad 0) (format (required-arg format))) ;; Data must be a sequence of 8-bit quantities, already in the appropriate format ;; for transmission; the caller is responsible for all byte and bit swapping and ;; compaction. Start is the starting index in data; the end is computed from the ;; other arguments. (declare (type drawable drawable) (type gcontext gcontext) (type sequence data) ; Sequence of integers (type array-index start) (type card8 depth left-pad) ;; required (type int16 x y) ;; required (type card16 width height) ;; required (type (member :bitmap :xy-pixmap :z-pixmap) format)) (with-buffer-request ((drawable-display drawable) +x-putimage+ :gc-force gcontext) ((data (member :bitmap :xy-pixmap :z-pixmap)) format) (drawable drawable) (gcontext gcontext) (card16 width height) (int16 x y) (card8 left-pad depth) (pad16 nil) ((sequence :format card8 :start start) data))) (defun get-raw-image (drawable &key data (start 0) (x (required-arg x)) (y (required-arg y)) (width (required-arg width)) (height (required-arg height)) (plane-mask #xffffffff) (format (required-arg format)) (result-type '(vector card8))) ;; If data is given, it is modified in place (and returned), otherwise a new sequence ;; is created and returned, with a size computed from the other arguments and the ;; returned depth. The sequence is filled with 8-bit quantities, in transmission ;; format; the caller is responsible for any byte and bit swapping and compaction ;; required for further local use. (declare (type drawable drawable) (type (or null sequence) data) ;; sequence of integers (type int16 x y) ;; required (type card16 width height) ;; required (type array-index start) (type pixel plane-mask) (type (member :xy-pixmap :z-pixmap) format)) (declare (clx-values (clx-sequence integer) depth visual-info)) (let ((display (drawable-display drawable))) (with-buffer-request-and-reply (display +x-getimage+ nil :sizes (8 32)) (((data (member error :xy-pixmap :z-pixmap)) format) (drawable drawable) (int16 x y) (card16 width height) (card32 plane-mask)) (let ((depth (card8-get 1)) (length (* 4 (card32-get 4))) (visual (resource-id-get 8))) (values (sequence-get :result-type result-type :format card8 :length length :start start :data data :index +replysize+) depth (visual-info display visual)))))) ecl-16.1.2/src/clx/image.lisp000066400000000000000000003615321266352375300157220ustar00rootroot00000000000000;;; -*- Mode:Lisp; Package:XLIB; Syntax:COMMON-LISP; Base:10; Lowercase:T -*- ;;; CLX Image functions ;;; ;;; TEXAS INSTRUMENTS INCORPORATED ;;; P.O. BOX 2909 ;;; AUSTIN, TEXAS 78769 ;;; ;;; Copyright (C) 1987 Texas Instruments Incorporated. ;;; ;;; Permission is granted to any individual or institution to use, copy, modify, ;;; and distribute this software, provided that this complete copyright and ;;; permission notice is maintained, intact, in all copies and supporting ;;; documentation. ;;; ;;; Texas Instruments Incorporated provides this software "as is" without ;;; express or implied warranty. ;;; (in-package :xlib) (defmacro with-image-data-buffer ((buffer size) &body body) (declare (indentation 0 4 1 1)) `(let ((.reply-buffer. (allocate-reply-buffer ,size))) (declare (type reply-buffer .reply-buffer.)) (unwind-protect (let ((,buffer (reply-ibuf8 .reply-buffer.))) (declare (type buffer-bytes ,buffer)) (with-vector (,buffer buffer-bytes) ,@body)) (deallocate-reply-buffer .reply-buffer.)))) (def-clx-class (image (:constructor nil) (:copier nil) (:predicate nil)) ;; Public structure (width 0 :type card16 :read-only t) (height 0 :type card16 :read-only t) (depth 1 :type card8 :read-only t) (plist nil :type list)) ;; Image-Plist accessors: (defmacro image-name (image) `(getf (image-plist ,image) :name)) (defmacro image-x-hot (image) `(getf (image-plist ,image) :x-hot)) (defmacro image-y-hot (image) `(getf (image-plist ,image) :y-hot)) (defmacro image-red-mask (image) `(getf (image-plist ,image) :red-mask)) (defmacro image-blue-mask (image) `(getf (image-plist ,image) :blue-mask)) (defmacro image-green-mask (image) `(getf (image-plist ,image) :green-mask)) (defun print-image (image stream depth) (declare (type image image) (ignore depth)) (print-unreadable-object (image stream :type t) (when (image-name image) (write-string (string (image-name image)) stream) (write-string " " stream)) (prin1 (image-width image) stream) (write-string "x" stream) (prin1 (image-height image) stream) (write-string "x" stream) (prin1 (image-depth image) stream))) (defconstant +empty-data-x+ '#.(make-sequence '(array card8 (*)) 0)) (defconstant +empty-data-z+ '#.(make-array '(0 0) :element-type 'pixarray-1-element-type)) (def-clx-class (image-x (:include image) (:copier nil) (:print-function print-image)) ;; Use this format for shoveling image data ;; Private structure. Accessors for these NOT exported. (format :z-pixmap :type (member :bitmap :xy-pixmap :z-pixmap)) (bytes-per-line 0 :type card16) (bits-per-pixel 1 :type (member 1 4 8 16 24 32)) (bit-lsb-first-p +image-bit-lsb-first-p+ :type generalized-boolean) ; Bit order (byte-lsb-first-p +image-byte-lsb-first-p+ :type generalized-boolean) ; Byte order (data +empty-data-x+ :type (array card8 (*))) ; row-major (unit +image-unit+ :type (member 8 16 32)) ; Bitmap unit (pad +image-pad+ :type (member 8 16 32)) ; Scanline pad (left-pad 0 :type card8)) ; Left pad (def-clx-class (image-xy (:include image) (:copier nil) (:print-function print-image)) ;; Public structure ;; Use this format for image processing (bitmap-list nil :type list)) ;; list of bitmaps (def-clx-class (image-z (:include image) (:copier nil) (:print-function print-image)) ;; Public structure ;; Use this format for image processing (bits-per-pixel 1 :type (member 1 4 8 16 24 32)) (pixarray +empty-data-z+ :type pixarray)) (defun create-image (&key width height depth (data (required-arg data)) plist name x-hot y-hot red-mask blue-mask green-mask bits-per-pixel format bytes-per-line (byte-lsb-first-p #+clx-little-endian t #-clx-little-endian nil) (bit-lsb-first-p #+clx-little-endian t #-clx-little-endian nil) unit pad left-pad) ;; Returns an image-x image-xy or image-z structure, depending on the ;; type of the :DATA parameter. (declare (type (or null card16) width height) ; Required (type (or null card8) depth) ; Defualts to 1 (type (or buffer-bytes ; Returns image-x list ; Returns image-xy pixarray) data) ; Returns image-z (type list plist) (type (or null stringable) name) (type (or null card16) x-hot y-hot) (type (or null pixel) red-mask blue-mask green-mask) (type (or null (member 1 4 8 16 24 32)) bits-per-pixel) ;; The following parameters are ignored for image-xy and image-z: (type (or null (member :bitmap :xy-pixmap :z-pixmap)) format) ; defaults to :z-pixmap (type (or null card16) bytes-per-line) (type generalized-boolean byte-lsb-first-p bit-lsb-first-p) (type (or null (member 8 16 32)) unit pad) (type (or null card8) left-pad)) (declare (clx-values image)) (let ((image (etypecase data (buffer-bytes ; image-x (let ((data data)) (declare (type buffer-bytes data)) (unless depth (setq depth (or bits-per-pixel 1))) (unless format (setq format (if (= depth 1) :xy-pixmap :z-pixmap))) (unless bits-per-pixel (setq bits-per-pixel (cond ((eq format :xy-pixmap) 1) ((index> depth 24) 32) ((index> depth 16) 24) ((index> depth 8) 16) ((index> depth 4) 8) ((index> depth 1) 4) (t 1)))) (unless width (required-arg width)) (unless height (required-arg height)) (unless bytes-per-line (let* ((pad (or pad 8)) (bits-per-line (index* width bits-per-pixel)) (padded-bits-per-line (index* (index-ceiling bits-per-line pad) pad))) (declare (type array-index pad bits-per-line padded-bits-per-line)) (setq bytes-per-line (index-ceiling padded-bits-per-line 8)))) (unless unit (setq unit +image-unit+)) (unless pad (setq pad (dolist (pad '(32 16 8)) (when (and (index<= pad +image-pad+) (zerop (index-mod (index* bytes-per-line 8) pad))) (return pad))))) (unless left-pad (setq left-pad 0)) (make-image-x :width width :height height :depth depth :plist plist :format format :data data :bits-per-pixel bits-per-pixel :bytes-per-line bytes-per-line :byte-lsb-first-p byte-lsb-first-p :bit-lsb-first-p bit-lsb-first-p :unit unit :pad pad :left-pad left-pad))) (list ; image-xy (let ((data data)) (declare (type list data)) (unless depth (setq depth (length data))) (when data (unless width (setq width (array-dimension (car data) 1))) (unless height (setq height (array-dimension (car data) 0)))) (make-image-xy :width width :height height :plist plist :depth depth :bitmap-list data))) (pixarray ; image-z (let ((data data)) (declare (type pixarray data)) (unless width (setq width (array-dimension data 1))) (unless height (setq height (array-dimension data 0))) (unless bits-per-pixel (setq bits-per-pixel (etypecase data (pixarray-32 32) (pixarray-24 24) (pixarray-16 16) (pixarray-8 8) (pixarray-4 4) (pixarray-1 1))))) (unless depth (setq depth bits-per-pixel)) (make-image-z :width width :height height :depth depth :plist plist :bits-per-pixel bits-per-pixel :pixarray data))))) (declare (type image image)) (when name (setf (image-name image) name)) (when x-hot (setf (image-x-hot image) x-hot)) (when y-hot (setf (image-y-hot image) y-hot)) (when red-mask (setf (image-red-mask image) red-mask)) (when blue-mask (setf (image-blue-mask image) blue-mask)) (when green-mask (setf (image-green-mask image) green-mask)) image)) ;;;----------------------------------------------------------------------------- ;;; Swapping stuff (defun image-noswap (src dest srcoff destoff srclen srcinc destinc height lsb-first-p) (declare (type buffer-bytes src dest) (type array-index srcoff destoff srclen srcinc destinc) (type card16 height) (type generalized-boolean lsb-first-p) (ignore lsb-first-p)) #.(declare-buffun) (if (index= srcinc destinc) (buffer-replace dest src destoff (index+ destoff (index* srcinc (index1- height)) srclen) srcoff) (do* ((h height (index1- h)) (srcstart srcoff (index+ srcstart srcinc)) (deststart destoff (index+ deststart destinc)) (destend (index+ deststart srclen) (index+ deststart srclen))) ((index-zerop h)) (declare (type array-index srcstart deststart destend) (type card16 h)) (buffer-replace dest src deststart destend srcstart)))) (defun image-swap-two-bytes (src dest srcoff destoff srclen srcinc destinc height lsb-first-p) (declare (type buffer-bytes src dest) (type array-index srcoff destoff srclen srcinc destinc) (type card16 height) (type generalized-boolean lsb-first-p)) #.(declare-buffun) (with-vector (src buffer-bytes) (with-vector (dest buffer-bytes) (do ((length (index* (index-ceiling srclen 2) 2)) (h height (index1- h)) (srcstart srcoff (index+ srcstart srcinc)) (deststart destoff (index+ deststart destinc))) ((index-zerop h)) (declare (type array-index length srcstart deststart) (type card16 h)) (when (and (index= h 1) (not (index= srclen length))) (index-decf length 2) (if lsb-first-p (setf (aref dest (index1+ (index+ deststart length))) (the card8 (aref src (index+ srcstart length)))) (setf (aref dest (index+ deststart length)) (the card8 (aref src (index1+ (index+ srcstart length))))))) (do ((i length (index- i 2)) (srcidx srcstart (index+ srcidx 2)) (destidx deststart (index+ destidx 2))) ((index-zerop i)) (declare (type array-index i srcidx destidx)) (setf (aref dest destidx) (the card8 (aref src (index1+ srcidx)))) (setf (aref dest (index1+ destidx)) (the card8 (aref src srcidx)))))))) (defun image-swap-three-bytes (src dest srcoff destoff srclen srcinc destinc height lsb-first-p) (declare (type buffer-bytes src dest) (type array-index srcoff destoff srclen srcinc destinc) (type card16 height) (type generalized-boolean lsb-first-p)) #.(declare-buffun) (with-vector (src buffer-bytes) (with-vector (dest buffer-bytes) (do ((length (index* (index-ceiling srclen 3) 3)) (h height (index1- h)) (srcstart srcoff (index+ srcstart srcinc)) (deststart destoff (index+ deststart destinc))) ((index-zerop h)) (declare (type array-index length srcstart deststart) (type card16 h)) (when (and (index= h 1) (not (index= srclen length))) (index-decf length 3) (when (index= (index- srclen length) 2) (setf (aref dest (index+ deststart length 1)) (the card8 (aref src (index+ srcstart length 1))))) (if lsb-first-p (setf (aref dest (index+ deststart length 2)) (the card8 (aref src (index+ srcstart length)))) (setf (aref dest (index+ deststart length)) (the card8 (aref src (index+ srcstart length 2)))))) (do ((i length (index- i 3)) (srcidx srcstart (index+ srcidx 3)) (destidx deststart (index+ destidx 3))) ((index-zerop i)) (declare (type array-index i srcidx destidx)) (setf (aref dest destidx) (the card8 (aref src (index+ srcidx 2)))) (setf (aref dest (index1+ destidx)) (the card8 (aref src (index1+ srcidx)))) (setf (aref dest (index+ destidx 2)) (the card8 (aref src srcidx)))))))) (defun image-swap-four-bytes (src dest srcoff destoff srclen srcinc destinc height lsb-first-p) (declare (type buffer-bytes src dest) (type array-index srcoff destoff srclen srcinc destinc) (type card16 height) (type generalized-boolean lsb-first-p)) #.(declare-buffun) (with-vector (src buffer-bytes) (with-vector (dest buffer-bytes) (do ((length (index* (index-ceiling srclen 4) 4)) (h height (index1- h)) (srcstart srcoff (index+ srcstart srcinc)) (deststart destoff (index+ deststart destinc))) ((index-zerop h)) (declare (type array-index length srcstart deststart) (type card16 h)) (when (and (index= h 1) (not (index= srclen length))) (index-decf length 4) (unless lsb-first-p (setf (aref dest (index+ deststart length)) (the card8 (aref src (index+ srcstart length 3))))) (when (if lsb-first-p (index= (index- srclen length) 3) (not (index-zerop (index-logand srclen 2)))) (setf (aref dest (index+ deststart length 1)) (the card8 (aref src (index+ srcstart length 2))))) (when (if (null lsb-first-p) (index= (index- srclen length) 3) (not (index-zerop (index-logand srclen 2)))) (setf (aref dest (index+ deststart length 2)) (the card8 (aref src (index+ srcstart length 1))))) (when lsb-first-p (setf (aref dest (index+ deststart length 3)) (the card8 (aref src (index+ srcstart length)))))) (do ((i length (index- i 4)) (srcidx srcstart (index+ srcidx 4)) (destidx deststart (index+ destidx 4))) ((index-zerop i)) (declare (type array-index i srcidx destidx)) (setf (aref dest destidx) (the card8 (aref src (index+ srcidx 3)))) (setf (aref dest (index1+ destidx)) (the card8 (aref src (index+ srcidx 2)))) (setf (aref dest (index+ destidx 2)) (the card8 (aref src (index1+ srcidx)))) (setf (aref dest (index+ destidx 3)) (the card8 (aref src srcidx)))))))) (defun image-swap-words (src dest srcoff destoff srclen srcinc destinc height lsb-first-p) (declare (type buffer-bytes src dest) (type array-index srcoff destoff srclen srcinc destinc) (type card16 height) (type generalized-boolean lsb-first-p)) #.(declare-buffun) (with-vector (src buffer-bytes) (with-vector (dest buffer-bytes) (do ((length (index* (index-ceiling srclen 4) 4)) (h height (index1- h)) (srcstart srcoff (index+ srcstart srcinc)) (deststart destoff (index+ deststart destinc))) ((index-zerop h)) (declare (type array-index length srcstart deststart) (type card16 h)) (when (and (index= h 1) (not (index= srclen length))) (index-decf length 4) (unless lsb-first-p (setf (aref dest (index+ deststart length 1)) (the card8 (aref src (index+ srcstart length 3))))) (when (if lsb-first-p (index= (index- srclen length) 3) (not (index-zerop (index-logand srclen 2)))) (setf (aref dest (index+ deststart length)) (the card8 (aref src (index+ srcstart length 2))))) (when (if (null lsb-first-p) (index= (index- srclen length) 3) (not (index-zerop (index-logand srclen 2)))) (setf (aref dest (index+ deststart length 3)) (the card8 (aref src (index+ srcstart length 1))))) (when lsb-first-p (setf (aref dest (index+ deststart length 2)) (the card8 (aref src (index+ srcstart length)))))) (do ((i length (index- i 4)) (srcidx srcstart (index+ srcidx 4)) (destidx deststart (index+ destidx 4))) ((index-zerop i)) (declare (type array-index i srcidx destidx)) (setf (aref dest destidx) (the card8 (aref src (index+ srcidx 2)))) (setf (aref dest (index1+ destidx)) (the card8 (aref src (index+ srcidx 3)))) (setf (aref dest (index+ destidx 2)) (the card8 (aref src srcidx))) (setf (aref dest (index+ destidx 3)) (the card8 (aref src (index1+ srcidx))))))))) (defun image-swap-nibbles (src dest srcoff destoff srclen srcinc destinc height lsb-first-p) (declare (type buffer-bytes src dest) (type array-index srcoff destoff srclen srcinc destinc) (type card16 height) (type generalized-boolean lsb-first-p) (ignore lsb-first-p)) #.(declare-buffun) (with-vector (src buffer-bytes) (with-vector (dest buffer-bytes) (do ((h height (index1- h)) (srcstart srcoff (index+ srcstart srcinc)) (deststart destoff (index+ deststart destinc))) ((index-zerop h)) (declare (type array-index srcstart deststart) (type card16 h)) (do ((i srclen (index1- i)) (srcidx srcstart (index1+ srcidx)) (destidx deststart (index1+ destidx))) ((index-zerop i)) (declare (type array-index i srcidx destidx)) (setf (aref dest destidx) (the card8 (let ((byte (aref src srcidx))) (declare (type card8 byte)) (dpb (the card4 (ldb (byte 4 0) byte)) (byte 4 4) (the card4 (ldb (byte 4 4) byte))))))))))) (defun image-swap-nibbles-left (src dest srcoff destoff srclen srcinc destinc height lsb-first-p) (declare (type buffer-bytes src dest) (type array-index srcoff destoff srclen srcinc destinc) (type card16 height) (type generalized-boolean lsb-first-p) (ignore lsb-first-p)) #.(declare-buffun) (with-vector (src buffer-bytes) (with-vector (dest buffer-bytes) (do ((h height (index1- h)) (srcstart srcoff (index+ srcstart srcinc)) (deststart destoff (index+ deststart destinc))) ((index-zerop h)) (declare (type array-index srcstart deststart) (type card16 h)) (do ((i srclen (index1- i)) (srcidx srcstart (index1+ srcidx)) (destidx deststart (index1+ destidx))) ((index= i 1) (setf (aref dest destidx) (the card8 (let ((byte1 (aref src srcidx))) (declare (type card8 byte1)) (dpb (the card4 (ldb (byte 4 0) byte1)) (byte 4 4) 0))))) (declare (type array-index i srcidx destidx)) (setf (aref dest destidx) (the card8 (let ((byte1 (aref src srcidx)) (byte2 (aref src (index1+ srcidx)))) (declare (type card8 byte1 byte2)) (dpb (the card4 (ldb (byte 4 0) byte1)) (byte 4 4) (the card4 (ldb (byte 4 4) byte2))))))))))) (defconstant +image-byte-reverse+ '#.(coerce '#( 0 128 64 192 32 160 96 224 16 144 80 208 48 176 112 240 8 136 72 200 40 168 104 232 24 152 88 216 56 184 120 248 4 132 68 196 36 164 100 228 20 148 84 212 52 180 116 244 12 140 76 204 44 172 108 236 28 156 92 220 60 188 124 252 2 130 66 194 34 162 98 226 18 146 82 210 50 178 114 242 10 138 74 202 42 170 106 234 26 154 90 218 58 186 122 250 6 134 70 198 38 166 102 230 22 150 86 214 54 182 118 246 14 142 78 206 46 174 110 238 30 158 94 222 62 190 126 254 1 129 65 193 33 161 97 225 17 145 81 209 49 177 113 241 9 137 73 201 41 169 105 233 25 153 89 217 57 185 121 249 5 133 69 197 37 165 101 229 21 149 85 213 53 181 117 245 13 141 77 205 45 173 109 237 29 157 93 221 61 189 125 253 3 131 67 195 35 163 99 227 19 147 83 211 51 179 115 243 11 139 75 203 43 171 107 235 27 155 91 219 59 187 123 251 7 135 71 199 39 167 103 231 23 151 87 215 55 183 119 247 15 143 79 207 47 175 111 239 31 159 95 223 63 191 127 255) '(vector card8))) (defun image-swap-bits (src dest srcoff destoff srclen srcinc destinc height lsb-first-p) (declare (type buffer-bytes src dest) (type array-index srcoff destoff srclen srcinc destinc) (type card16 height) (type generalized-boolean lsb-first-p) (ignore lsb-first-p)) #.(declare-buffun) (with-vector (src buffer-bytes) (with-vector (dest buffer-bytes) (let ((byte-reverse +image-byte-reverse+)) (with-vector (byte-reverse (simple-array card8 (256))) (macrolet ((br (byte) `(the card8 (aref byte-reverse (the card8 ,byte))))) (do ((h height (index1- h)) (srcstart srcoff (index+ srcstart srcinc)) (deststart destoff (index+ deststart destinc))) ((index-zerop h)) (declare (type array-index srcstart deststart) (type card16 h)) (do ((i srclen (index1- i)) (srcidx srcstart (index1+ srcidx)) (destidx deststart (index1+ destidx))) ((index-zerop i)) (declare (type array-index i srcidx destidx)) (setf (aref dest destidx) (br (aref src srcidx))))))))))) (defun image-swap-bits-and-two-bytes (src dest srcoff destoff srclen srcinc destinc height lsb-first-p) (declare (type buffer-bytes src dest) (type array-index srcoff destoff srclen srcinc destinc) (type card16 height) (type generalized-boolean lsb-first-p)) #.(declare-buffun) (with-vector (src buffer-bytes) (with-vector (dest buffer-bytes) (let ((byte-reverse +image-byte-reverse+)) (with-vector (byte-reverse (simple-array card8 (256))) (macrolet ((br (byte) `(the card8 (aref byte-reverse (the card8 ,byte))))) (do ((length (index* (index-ceiling srclen 2) 2)) (h height (index1- h)) (srcstart srcoff (index+ srcstart srcinc)) (deststart destoff (index+ deststart destinc))) ((index-zerop h)) (declare (type array-index length srcstart deststart) (type card16 h)) (when (and (index= h 1) (not (index= srclen length))) (index-decf length 2) (if lsb-first-p (setf (aref dest (index1+ (index+ deststart length))) (br (aref src (index+ srcstart length)))) (setf (aref dest (index+ deststart length)) (br (aref src (index1+ (index+ srcstart length))))))) (do ((i length (index- i 2)) (srcidx srcstart (index+ srcidx 2)) (destidx deststart (index+ destidx 2))) ((index-zerop i)) (declare (type array-index i srcidx destidx)) (setf (aref dest destidx) (br (aref src (index1+ srcidx)))) (setf (aref dest (index1+ destidx)) (br (aref src srcidx))))))))))) (defun image-swap-bits-and-four-bytes (src dest srcoff destoff srclen srcinc destinc height lsb-first-p) (declare (type buffer-bytes src dest) (type array-index srcoff destoff srclen srcinc destinc) (type card16 height) (type generalized-boolean lsb-first-p)) #.(declare-buffun) (with-vector (src buffer-bytes) (with-vector (dest buffer-bytes) (let ((byte-reverse +image-byte-reverse+)) (with-vector (byte-reverse (simple-array card8 (256))) (macrolet ((br (byte) `(the card8 (aref byte-reverse (the card8 ,byte))))) (do ((length (index* (index-ceiling srclen 4) 4)) (h height (index1- h)) (srcstart srcoff (index+ srcstart srcinc)) (deststart destoff (index+ deststart destinc))) ((index-zerop h)) (declare (type array-index length srcstart deststart) (type card16 h)) (when (and (index= h 1) (not (index= srclen length))) (index-decf length 4) (unless lsb-first-p (setf (aref dest (index+ deststart length)) (br (aref src (index+ srcstart length 3))))) (when (if lsb-first-p (index= (index- srclen length) 3) (not (index-zerop (index-logand srclen 2)))) (setf (aref dest (index+ deststart length 1)) (br (aref src (index+ srcstart length 2))))) (when (if (null lsb-first-p) (index= (index- srclen length) 3) (not (index-zerop (index-logand srclen 2)))) (setf (aref dest (index+ deststart length 2)) (br (aref src (index+ srcstart length 1))))) (when lsb-first-p (setf (aref dest (index+ deststart length 3)) (br (aref src (index+ srcstart length)))))) (do ((i length (index- i 4)) (srcidx srcstart (index+ srcidx 4)) (destidx deststart (index+ destidx 4))) ((index-zerop i)) (declare (type array-index i srcidx destidx)) (setf (aref dest destidx) (br (aref src (index+ srcidx 3)))) (setf (aref dest (index1+ destidx)) (br (aref src (index+ srcidx 2)))) (setf (aref dest (index+ destidx 2)) (br (aref src (index1+ srcidx)))) (setf (aref dest (index+ destidx 3)) (br (aref src srcidx))))))))))) (defun image-swap-bits-and-words (src dest srcoff destoff srclen srcinc destinc height lsb-first-p) (declare (type buffer-bytes src dest) (type array-index srcoff destoff srclen srcinc destinc) (type card16 height) (type generalized-boolean lsb-first-p)) #.(declare-buffun) (with-vector (src buffer-bytes) (with-vector (dest buffer-bytes) (let ((byte-reverse +image-byte-reverse+)) (with-vector (byte-reverse (simple-array card8 (256))) (macrolet ((br (byte) `(the card8 (aref byte-reverse (the card8 ,byte))))) (do ((length (index* (index-ceiling srclen 4) 4)) (h height (index1- h)) (srcstart srcoff (index+ srcstart srcinc)) (deststart destoff (index+ deststart destinc))) ((index-zerop h)) (declare (type array-index length srcstart deststart) (type card16 h)) (when (and (index= h 1) (not (index= srclen length))) (index-decf length 4) (unless lsb-first-p (setf (aref dest (index+ deststart length 1)) (br (aref src (index+ srcstart length 3))))) (when (if lsb-first-p (index= (index- srclen length) 3) (not (index-zerop (index-logand srclen 2)))) (setf (aref dest (index+ deststart length)) (br (aref src (index+ srcstart length 2))))) (when (if (null lsb-first-p) (index= (index- srclen length) 3) (not (index-zerop (index-logand srclen 2)))) (setf (aref dest (index+ deststart length 3)) (br (aref src (index+ srcstart length 1))))) (when lsb-first-p (setf (aref dest (index+ deststart length 2)) (br (aref src (index+ srcstart length)))))) (do ((i length (index- i 4)) (srcidx srcstart (index+ srcidx 4)) (destidx deststart (index+ destidx 4))) ((index-zerop i)) (declare (type array-index i srcidx destidx)) (setf (aref dest destidx) (br (aref src (index+ srcidx 2)))) (setf (aref dest (index1+ destidx)) (br (aref src (index+ srcidx 3)))) (setf (aref dest (index+ destidx 2)) (br (aref src srcidx))) (setf (aref dest (index+ destidx 3)) (br (aref src (index1+ srcidx)))))))))))) ;;; The following table gives the bit ordering within bytes (when accessed ;;; sequentially) for a scanline containing 32 bits, with bits numbered 0 to ;;; 31, where bit 0 should be leftmost on the display. For a given byte ;;; labelled A-B, A is for the most significant bit of the byte, and B is ;;; for the least significant bit. ;;; ;;; legend: ;;; 1 scanline-unit = 8 ;;; 2 scanline-unit = 16 ;;; 4 scanline-unit = 32 ;;; M byte-order = MostSignificant ;;; L byte-order = LeastSignificant ;;; m bit-order = MostSignificant ;;; l bit-order = LeastSignificant ;;; ;;; ;;; format ordering ;;; ;;; 1Mm 00-07 08-15 16-23 24-31 ;;; 2Mm 00-07 08-15 16-23 24-31 ;;; 4Mm 00-07 08-15 16-23 24-31 ;;; 1Ml 07-00 15-08 23-16 31-24 ;;; 2Ml 15-08 07-00 31-24 23-16 ;;; 4Ml 31-24 23-16 15-08 07-00 ;;; 1Lm 00-07 08-15 16-23 24-31 ;;; 2Lm 08-15 00-07 24-31 16-23 ;;; 4Lm 24-31 16-23 08-15 00-07 ;;; 1Ll 07-00 15-08 23-16 31-24 ;;; 2Ll 07-00 15-08 23-16 31-24 ;;; 4Ll 07-00 15-08 23-16 31-24 ;;; ;;; ;;; The following table gives the required conversion between any two ;;; formats. It is based strictly on the table above. If you believe one, ;;; you should believe the other. ;;; ;;; legend: ;;; n no changes ;;; s reverse 8-bit units within 16-bit units ;;; l reverse 8-bit units within 32-bit units ;;; w reverse 16-bit units within 32-bit units ;;; r reverse bits within 8-bit units ;;; sr s+R ;;; lr l+R ;;; wr w+R (defconstant +image-swap-function+ '#.(make-array '(12 12) :initial-contents (let ((n 'image-noswap) (s 'image-swap-two-bytes) (l 'image-swap-four-bytes) (w 'image-swap-words) (r 'image-swap-bits) (sr 'image-swap-bits-and-two-bytes) (lr 'image-swap-bits-and-four-bytes) (wr 'image-swap-bits-and-words)) (list #| 1Mm 2Mm 4Mm 1Ml 2Ml 4Ml 1Lm 2Lm 4Lm 1Ll 2Ll 4Ll |# (list #| 1Mm |# n n n r sr lr n s l r r r ) (list #| 2Mm |# n n n r sr lr n s l r r r ) (list #| 4Mm |# n n n r sr lr n s l r r r ) (list #| 1Ml |# r r r n s l r sr lr n n n ) (list #| 2Ml |# sr sr sr s n w sr r wr s s s ) (list #| 4Ml |# lr lr lr l w n lr wr r l l l ) (list #| 1Lm |# n n n r sr lr n s l r r r ) (list #| 2Lm |# s s s sr r wr s n w sr sr sr) (list #| 4Lm |# l l l lr wr r l w n lr lr lr) (list #| 1Ll |# r r r n s l r sr lr n n n ) (list #| 2Ll |# r r r n s l r sr lr n n n ) (list #| 4Ll |# r r r n s l r sr lr n n n ))))) ;;; Of course, the table above is a lie. We also need to factor in the ;;; order of the source data to cope with swapping half of a unit at the ;;; end of a scanline, since we are trying to avoid de-ref'ing off the ;;; end of the source. ;;; ;;; Defines whether the first half of a unit has the first half of the data (defconstant +image-swap-lsb-first-p+ '#.(make-array 12 :initial-contents (list t #| 1mm |# t #| 2mm |# t #| 4mm |# t #| 1ml |# nil #| 2ml |# nil #| 4ml |# t #| 1lm |# nil #| 2lm |# nil #| 4lm |# t #| 1ll |# t #| 2ll |# t #| 4ll |# ))) (defun image-swap-function (bits-per-pixel from-bitmap-unit from-byte-lsb-first-p from-bit-lsb-first-p to-bitmap-unit to-byte-lsb-first-p to-bit-lsb-first-p) (declare (type (member 1 4 8 16 24 32) bits-per-pixel) (type (member 8 16 32) from-bitmap-unit to-bitmap-unit) (type generalized-boolean from-byte-lsb-first-p from-bit-lsb-first-p to-byte-lsb-first-p to-bit-lsb-first-p) (clx-values function lsb-first-p)) (cond ((index= bits-per-pixel 1) (let ((from-index (index+ (ecase from-bitmap-unit (32 2) (16 1) (8 0)) (if from-bit-lsb-first-p 3 0) (if from-byte-lsb-first-p 6 0)))) (values (aref +image-swap-function+ from-index (index+ (ecase to-bitmap-unit (32 2) (16 1) (8 0)) (if to-bit-lsb-first-p 3 0) (if to-byte-lsb-first-p 6 0))) (aref +image-swap-lsb-first-p+ from-index)))) (t (values (if (if (index= bits-per-pixel 4) (eq from-bit-lsb-first-p to-bit-lsb-first-p) (eq from-byte-lsb-first-p to-byte-lsb-first-p)) 'image-noswap (ecase bits-per-pixel (4 'image-swap-nibbles) (8 'image-noswap) (16 'image-swap-two-bytes) (24 'image-swap-three-bytes) (32 'image-swap-four-bytes))) from-byte-lsb-first-p)))) ;;;----------------------------------------------------------------------------- ;;; GET-IMAGE (defun read-pixarray-1 (buffer-bbuf index array x y width height padded-bytes-per-line bits-per-pixel) (declare (type buffer-bytes buffer-bbuf) (type pixarray-1 array) (type card16 x y width height) (type array-index index padded-bytes-per-line) (type (member 1 4 8 16 24 32) bits-per-pixel) (ignore bits-per-pixel)) #.(declare-buffun) (with-vector (buffer-bbuf buffer-bytes) (do* ((start (index+ index (index* y padded-bytes-per-line) (index-ceiling x 8)) (index+ start padded-bytes-per-line)) (y 0 (index1+ y)) (left-bits (the array-index (mod (the (integer #x-FFFF 0) (- x)) 8))) (right-bits (index-mod (index- width left-bits) 8)) (middle-bits (- width left-bits right-bits)) (middle-bytes (floor middle-bits 8))) ((index>= y height)) (declare (type array-index start y left-bits right-bits)) (declare (fixnum middle-bits middle-bytes)) (cond ((< middle-bits 0) (let ((byte (aref buffer-bbuf (index1- start))) (x left-bits)) (declare (type card8 byte) (type array-index x)) (when (index> right-bits 6) (setf (aref array y (index- x 1)) (read-image-load-byte 1 7 byte))) (when (and (index> left-bits 1) (index> right-bits 5)) (setf (aref array y (index- x 2)) (read-image-load-byte 1 6 byte))) (when (and (index> left-bits 2) (index> right-bits 4)) (setf (aref array y (index- x 3)) (read-image-load-byte 1 5 byte))) (when (and (index> left-bits 3) (index> right-bits 3)) (setf (aref array y (index- x 4)) (read-image-load-byte 1 4 byte))) (when (and (index> left-bits 4) (index> right-bits 2)) (setf (aref array y (index- x 5)) (read-image-load-byte 1 3 byte))) (when (and (index> left-bits 5) (index> right-bits 1)) (setf (aref array y (index- x 6)) (read-image-load-byte 1 2 byte))) (when (index> left-bits 6) (setf (aref array y (index- x 7)) (read-image-load-byte 1 1 byte))))) (t (unless (index-zerop left-bits) (let ((byte (aref buffer-bbuf (index1- start))) (x left-bits)) (declare (type card8 byte) (type array-index x)) (setf (aref array y (index- x 1)) (read-image-load-byte 1 7 byte)) (when (index> left-bits 1) (setf (aref array y (index- x 2)) (read-image-load-byte 1 6 byte)) (when (index> left-bits 2) (setf (aref array y (index- x 3)) (read-image-load-byte 1 5 byte)) (when (index> left-bits 3) (setf (aref array y (index- x 4)) (read-image-load-byte 1 4 byte)) (when (index> left-bits 4) (setf (aref array y (index- x 5)) (read-image-load-byte 1 3 byte)) (when (index> left-bits 5) (setf (aref array y (index- x 6)) (read-image-load-byte 1 2 byte)) (when (index> left-bits 6) (setf (aref array y (index- x 7)) (read-image-load-byte 1 1 byte)) )))))))) (do* ((end (index+ start middle-bytes)) (i start (index1+ i)) (x left-bits (index+ x 8))) ((index>= i end) (unless (index-zerop right-bits) (let ((byte (aref buffer-bbuf end)) (x (index+ left-bits middle-bits))) (declare (type card8 byte) (type array-index x)) (setf (aref array y (index+ x 0)) (read-image-load-byte 1 0 byte)) (when (index> right-bits 1) (setf (aref array y (index+ x 1)) (read-image-load-byte 1 1 byte)) (when (index> right-bits 2) (setf (aref array y (index+ x 2)) (read-image-load-byte 1 2 byte)) (when (index> right-bits 3) (setf (aref array y (index+ x 3)) (read-image-load-byte 1 3 byte)) (when (index> right-bits 4) (setf (aref array y (index+ x 4)) (read-image-load-byte 1 4 byte)) (when (index> right-bits 5) (setf (aref array y (index+ x 5)) (read-image-load-byte 1 5 byte)) (when (index> right-bits 6) (setf (aref array y (index+ x 6)) (read-image-load-byte 1 6 byte)) ))))))))) (declare (type array-index end i x)) (let ((byte (aref buffer-bbuf i))) (declare (type card8 byte)) (setf (aref array y (index+ x 0)) (read-image-load-byte 1 0 byte)) (setf (aref array y (index+ x 1)) (read-image-load-byte 1 1 byte)) (setf (aref array y (index+ x 2)) (read-image-load-byte 1 2 byte)) (setf (aref array y (index+ x 3)) (read-image-load-byte 1 3 byte)) (setf (aref array y (index+ x 4)) (read-image-load-byte 1 4 byte)) (setf (aref array y (index+ x 5)) (read-image-load-byte 1 5 byte)) (setf (aref array y (index+ x 6)) (read-image-load-byte 1 6 byte)) (setf (aref array y (index+ x 7)) (read-image-load-byte 1 7 byte)))) ))))) (defun read-pixarray-4 (buffer-bbuf index array x y width height padded-bytes-per-line bits-per-pixel) (declare (type buffer-bytes buffer-bbuf) (type pixarray-4 array) (type card16 x y width height) (type array-index index padded-bytes-per-line) (type (member 1 4 8 16 24 32) bits-per-pixel) (ignore bits-per-pixel)) #.(declare-buffun) (with-vector (buffer-bbuf buffer-bytes) (do* ((start (index+ index (index* y padded-bytes-per-line) (index-ceiling x 2)) (index+ start padded-bytes-per-line)) (y 0 (index1+ y)) (left-nibbles (mod (the fixnum (- x)) 2)) (right-nibbles (index-mod (index- width left-nibbles) 2)) (middle-nibbles (index- width left-nibbles right-nibbles)) (middle-bytes (index-floor middle-nibbles 2))) ((index>= y height)) (declare (type array-index start y left-nibbles right-nibbles middle-nibbles middle-bytes)) (unless (index-zerop left-nibbles) (setf (aref array y 0) (read-image-load-byte 4 4 (aref buffer-bbuf (index1- start))))) (do* ((end (index+ start middle-bytes)) (i start (index1+ i)) (x left-nibbles (index+ x 2))) ((index>= i end) (unless (index-zerop right-nibbles) (setf (aref array y (index+ left-nibbles middle-nibbles)) (read-image-load-byte 4 0 (aref buffer-bbuf end))))) (declare (type array-index end i x)) (let ((byte (aref buffer-bbuf i))) (declare (type card8 byte)) (setf (aref array y (index+ x 0)) (read-image-load-byte 4 0 byte)) (setf (aref array y (index+ x 1)) (read-image-load-byte 4 4 byte)))) ))) (defun read-pixarray-8 (buffer-bbuf index array x y width height padded-bytes-per-line bits-per-pixel) (declare (type buffer-bytes buffer-bbuf) (type pixarray-8 array) (type card16 x y width height) (type array-index index padded-bytes-per-line) (type (member 1 4 8 16 24 32) bits-per-pixel) (ignore bits-per-pixel)) #.(declare-buffun) (with-vector (buffer-bbuf buffer-bytes) (do* ((start (index+ index (index* y padded-bytes-per-line) x) (index+ start padded-bytes-per-line)) (y 0 (index1+ y))) ((index>= y height)) (declare (type array-index start y)) (do* ((end (index+ start width)) (i start (index1+ i)) (x 0 (index1+ x))) ((index>= i end)) (declare (type array-index end i x)) (setf (aref array y x) (the card8 (aref buffer-bbuf i))))))) (defun read-pixarray-16 (buffer-bbuf index array x y width height padded-bytes-per-line bits-per-pixel) (declare (type buffer-bytes buffer-bbuf) (type pixarray-16 array) (type card16 width height) (type array-index index padded-bytes-per-line) (type (member 1 4 8 16 24 32) bits-per-pixel) (ignore bits-per-pixel)) #.(declare-buffun) (with-vector (buffer-bbuf buffer-bytes) (do* ((start (index+ index (index* y padded-bytes-per-line) (index* x 2)) (index+ start padded-bytes-per-line)) (y 0 (index1+ y))) ((index>= y height)) (declare (type array-index start y)) (do* ((end (index+ start (index* width 2))) (i start (index+ i 2)) (x 0 (index1+ x))) ((index>= i end)) (declare (type array-index end i x)) (setf (aref array y x) (read-image-assemble-bytes (aref buffer-bbuf (index+ i 0)) (aref buffer-bbuf (index+ i 1)))))))) (defun read-pixarray-24 (buffer-bbuf index array x y width height padded-bytes-per-line bits-per-pixel) (declare (type buffer-bytes buffer-bbuf) (type pixarray-24 array) (type card16 width height) (type array-index index padded-bytes-per-line) (type (member 1 4 8 16 24 32) bits-per-pixel) (ignore bits-per-pixel)) #.(declare-buffun) (with-vector (buffer-bbuf buffer-bytes) (do* ((start (index+ index (index* y padded-bytes-per-line) (index* x 3)) (index+ start padded-bytes-per-line)) (y 0 (index1+ y))) ((index>= y height)) (declare (type array-index start y)) (do* ((end (index+ start (index* width 3))) (i start (index+ i 3)) (x 0 (index1+ x))) ((index>= i end)) (declare (type array-index end i x)) (setf (aref array y x) (read-image-assemble-bytes (aref buffer-bbuf (index+ i 0)) (aref buffer-bbuf (index+ i 1)) (aref buffer-bbuf (index+ i 2)))))))) (defun read-pixarray-32 (buffer-bbuf index array x y width height padded-bytes-per-line bits-per-pixel) (declare (type buffer-bytes buffer-bbuf) (type pixarray-32 array) (type card16 width height) (type array-index index padded-bytes-per-line) (type (member 1 4 8 16 24 32) bits-per-pixel) (ignore bits-per-pixel)) #.(declare-buffun) (with-vector (buffer-bbuf buffer-bytes) (do* ((start (index+ index (index* y padded-bytes-per-line) (index* x 4)) (index+ start padded-bytes-per-line)) (y 0 (index1+ y))) ((index>= y height)) (declare (type array-index start y)) (do* ((end (index+ start (index* width 4))) (i start (index+ i 4)) (x 0 (index1+ x))) ((index>= i end)) (declare (type array-index end i x)) (setf (aref array y x) (read-image-assemble-bytes (aref buffer-bbuf (index+ i 0)) (aref buffer-bbuf (index+ i 1)) (aref buffer-bbuf (index+ i 2)) (aref buffer-bbuf (index+ i 3)))))))) (defun read-pixarray-internal (bbuf boffset pixarray x y width height padded-bytes-per-line bits-per-pixel read-pixarray-function from-unit from-byte-lsb-first-p from-bit-lsb-first-p to-unit to-byte-lsb-first-p to-bit-lsb-first-p) (declare (type buffer-bytes bbuf) (type array-index boffset padded-bytes-per-line) (type pixarray pixarray) (type card16 x y width height) (type (member 1 4 8 16 24 32) bits-per-pixel) (type function read-pixarray-function) (type (member 8 16 32) from-unit to-unit) (type generalized-boolean from-byte-lsb-first-p from-bit-lsb-first-p to-byte-lsb-first-p to-bit-lsb-first-p)) (multiple-value-bind (image-swap-function image-swap-lsb-first-p) (image-swap-function bits-per-pixel from-unit from-byte-lsb-first-p from-bit-lsb-first-p to-unit to-byte-lsb-first-p to-bit-lsb-first-p) (if (eq image-swap-function 'image-noswap) (funcall read-pixarray-function bbuf boffset pixarray x y width height padded-bytes-per-line bits-per-pixel) (with-image-data-buffer (buf (index* height padded-bytes-per-line)) (funcall (symbol-function image-swap-function) bbuf buf (index+ boffset (index* y padded-bytes-per-line)) 0 (index-ceiling (index* (index+ x width) bits-per-pixel) 8) padded-bytes-per-line padded-bytes-per-line height image-swap-lsb-first-p) (funcall read-pixarray-function buf 0 pixarray x 0 width height padded-bytes-per-line bits-per-pixel))))) (defun read-pixarray (bbuf boffset pixarray x y width height padded-bytes-per-line bits-per-pixel unit byte-lsb-first-p bit-lsb-first-p) (declare (type buffer-bytes bbuf) (type array-index boffset padded-bytes-per-line) (type pixarray pixarray) (type card16 x y width height) (type (member 1 4 8 16 24 32) bits-per-pixel) (type (member 8 16 32) unit) (type generalized-boolean byte-lsb-first-p bit-lsb-first-p)) (unless (fast-read-pixarray bbuf boffset pixarray x y width height padded-bytes-per-line bits-per-pixel unit byte-lsb-first-p bit-lsb-first-p) (read-pixarray-internal bbuf boffset pixarray x y width height padded-bytes-per-line bits-per-pixel (ecase bits-per-pixel ( 1 #'read-pixarray-1 ) ( 4 #'read-pixarray-4 ) ( 8 #'read-pixarray-8 ) (16 #'read-pixarray-16) (24 #'read-pixarray-24) (32 #'read-pixarray-32)) unit byte-lsb-first-p bit-lsb-first-p +image-unit+ +image-byte-lsb-first-p+ +image-bit-lsb-first-p+))) (defun read-xy-format-image-x (buffer-bbuf index length data width height depth padded-bytes-per-line padded-bytes-per-plane unit byte-lsb-first-p bit-lsb-first-p pad) (declare (type buffer-bytes buffer-bbuf) (type card16 width height) (type array-index index length padded-bytes-per-line padded-bytes-per-plane) (type image-depth depth) (type (member 8 16 32) unit pad) (type generalized-boolean byte-lsb-first-p bit-lsb-first-p) (clx-values image-x)) (assert (index<= (index* depth padded-bytes-per-plane) length)) (let* ((bytes-per-line (index-ceiling width 8)) (data-length (index* padded-bytes-per-plane depth))) (declare (type array-index bytes-per-line data-length)) (cond (data (check-type data buffer-bytes) (assert (index>= (length data) data-length))) (t (setq data (make-array data-length :element-type 'card8)))) (do ((plane 0 (index1+ plane))) ((index>= plane depth)) (declare (type image-depth plane)) (image-noswap buffer-bbuf data (index+ index (index* plane padded-bytes-per-plane)) (index* plane padded-bytes-per-plane) bytes-per-line padded-bytes-per-line padded-bytes-per-line height byte-lsb-first-p)) (create-image :width width :height height :depth depth :data data :bits-per-pixel 1 :format :xy-pixmap :bytes-per-line padded-bytes-per-line :unit unit :pad pad :byte-lsb-first-p byte-lsb-first-p :bit-lsb-first-p bit-lsb-first-p))) (defun read-z-format-image-x (buffer-bbuf index length data width height depth padded-bytes-per-line unit byte-lsb-first-p bit-lsb-first-p pad bits-per-pixel) (declare (type buffer-bytes buffer-bbuf) (type card16 width height) (type array-index index length padded-bytes-per-line) (type image-depth depth) (type (member 8 16 32) unit pad) (type generalized-boolean byte-lsb-first-p bit-lsb-first-p) (type (member 1 4 8 16 24 32) bits-per-pixel) (clx-values image-x)) (assert (index<= (index* height padded-bytes-per-line) length)) (let ((bytes-per-line (index-ceiling (index* width bits-per-pixel) 8)) (data-length (index* padded-bytes-per-line height))) (declare (type array-index bytes-per-line data-length)) (cond (data (check-type data buffer-bytes) (assert (index>= (length data) data-length))) (t (setq data (make-array data-length :element-type 'card8)))) (image-noswap buffer-bbuf data index 0 bytes-per-line padded-bytes-per-line padded-bytes-per-line height byte-lsb-first-p) (create-image :width width :height height :depth depth :data data :bits-per-pixel bits-per-pixel :format :z-pixmap :bytes-per-line padded-bytes-per-line :unit unit :pad pad :byte-lsb-first-p byte-lsb-first-p :bit-lsb-first-p bit-lsb-first-p))) (defun read-image-xy (bbuf index length data x y width height depth padded-bytes-per-line padded-bytes-per-plane unit byte-lsb-first-p bit-lsb-first-p) (declare (type buffer-bytes bbuf) (type card16 x y width height) (type array-index index length padded-bytes-per-line padded-bytes-per-plane) (type image-depth depth) (type (member 8 16 32) unit) (type generalized-boolean byte-lsb-first-p bit-lsb-first-p) (clx-values image-xy)) (check-type data list) (multiple-value-bind (dimensions element-type) (if data (values (array-dimensions (first data)) (array-element-type (first data))) (values (list height (index* (index-ceiling width +image-pad+) +image-pad+)) 'pixarray-1-element-type)) (do* ((arrays data) (result nil) (limit (index+ length index)) (plane 0 (1+ plane)) (index index (index+ index padded-bytes-per-plane))) ((or (>= plane depth) (index> (index+ index padded-bytes-per-plane) limit)) (setq data (nreverse result) depth (length data))) (declare (type array-index limit index) (type image-depth plane) (type list arrays result)) (let ((array (or (pop arrays) (make-array dimensions :element-type element-type)))) (declare (type pixarray-1 array)) (push array result) (read-pixarray bbuf index array x y width height padded-bytes-per-line 1 unit byte-lsb-first-p bit-lsb-first-p))) (create-image :width width :height height :depth depth :data data))) (defun read-image-z (bbuf index length data x y width height depth padded-bytes-per-line bits-per-pixel unit byte-lsb-first-p bit-lsb-first-p) (declare (type buffer-bytes bbuf) (type card16 x y width height) (type array-index index length padded-bytes-per-line) (type image-depth depth) (type (member 1 4 8 16 24 32) bits-per-pixel) (type (member 8 16 32) unit) (type generalized-boolean byte-lsb-first-p bit-lsb-first-p) (clx-values image-z)) (assert (index<= (index* (index+ y height) padded-bytes-per-line) length)) (let* ((image-bits-per-line (index* width bits-per-pixel)) (image-pixels-per-line (index-ceiling (index* (index-ceiling image-bits-per-line +image-pad+) +image-pad+) bits-per-pixel))) (declare (type array-index image-bits-per-line image-pixels-per-line)) (unless data (setq data (make-array (list height image-pixels-per-line) :element-type (ecase bits-per-pixel (1 'pixarray-1-element-type) (4 'pixarray-4-element-type) (8 'pixarray-8-element-type) (16 'pixarray-16-element-type) (24 'pixarray-24-element-type) (32 'pixarray-32-element-type))))) (read-pixarray bbuf index data x y width height padded-bytes-per-line bits-per-pixel unit byte-lsb-first-p bit-lsb-first-p) (create-image :width width :height height :depth depth :data data :bits-per-pixel bits-per-pixel))) (defun get-image (drawable &key data (x (required-arg x)) (y (required-arg y)) (width (required-arg width)) (height (required-arg height)) plane-mask format result-type) (declare (type drawable drawable) (type (or buffer-bytes list pixarray) data) (type int16 x y) ;; required (type card16 width height) ;; required (type (or null pixel) plane-mask) (type (or null (member :xy-pixmap :z-pixmap)) format) (type (or null (member image-xy image-x image-z)) result-type) (clx-values image visual-info)) (unless result-type (setq result-type (ecase format (:xy-pixmap 'image-xy) (:z-pixmap 'image-z) ((nil) 'image-x)))) (unless format (setq format (case result-type (image-xy :xy-pixmap) ((image-z image-x) :z-pixmap)))) (unless (ecase result-type (image-xy (eq format :xy-pixmap)) (image-z (eq format :z-pixmap)) (image-x t)) (error "Result-type ~s is incompatible with format ~s" result-type format)) (unless plane-mask (setq plane-mask #xffffffff)) (let ((display (drawable-display drawable))) (with-buffer-request-and-reply (display +x-getimage+ nil :sizes (8 32)) (((data (member error :xy-pixmap :z-pixmap)) format) (drawable drawable) (int16 x y) (card16 width height) (card32 plane-mask)) (let* ((depth (card8-get 1)) (length (index* 4 (card32-get 4))) (visual-info (visual-info display (resource-id-get 8))) (bitmap-format (display-bitmap-format display)) (unit (bitmap-format-unit bitmap-format)) (byte-lsb-first-p (display-image-lsb-first-p display)) (bit-lsb-first-p (bitmap-format-lsb-first-p bitmap-format))) (declare (type image-depth depth) (type array-index length) (type (or null visual-info) visual-info) (type bitmap-format bitmap-format) (type (member 8 16 32) unit) (type generalized-boolean byte-lsb-first-p bit-lsb-first-p)) (multiple-value-bind (pad bits-per-pixel) (ecase format (:xy-pixmap (values (bitmap-format-pad bitmap-format) 1)) (:z-pixmap (if (= depth 1) (values (bitmap-format-pad bitmap-format) 1) (let ((pixmap-format (find depth (display-pixmap-formats display) :key #'pixmap-format-depth))) (declare (type pixmap-format pixmap-format)) (values (pixmap-format-scanline-pad pixmap-format) (pixmap-format-bits-per-pixel pixmap-format)))))) (declare (type (member 8 16 32) pad) (type (member 1 4 8 16 24 32) bits-per-pixel)) (let* ((bits-per-line (index* bits-per-pixel width)) (padded-bits-per-line (index* (index-ceiling bits-per-line pad) pad)) (padded-bytes-per-line (index-ceiling padded-bits-per-line 8)) (padded-bytes-per-plane (index* padded-bytes-per-line height)) (image (ecase result-type (image-x (ecase format (:xy-pixmap (read-xy-format-image-x buffer-bbuf +replysize+ length data width height depth padded-bytes-per-line padded-bytes-per-plane unit byte-lsb-first-p bit-lsb-first-p pad)) (:z-pixmap (read-z-format-image-x buffer-bbuf +replysize+ length data width height depth padded-bytes-per-line unit byte-lsb-first-p bit-lsb-first-p pad bits-per-pixel)))) (image-xy (read-image-xy buffer-bbuf +replysize+ length data 0 0 width height depth padded-bytes-per-line padded-bytes-per-plane unit byte-lsb-first-p bit-lsb-first-p)) (image-z (read-image-z buffer-bbuf +replysize+ length data 0 0 width height depth padded-bytes-per-line bits-per-pixel unit byte-lsb-first-p bit-lsb-first-p))))) (declare (type image image) (type array-index bits-per-line padded-bits-per-line padded-bytes-per-line)) (when visual-info (unless (zerop (visual-info-red-mask visual-info)) (setf (image-red-mask image) (visual-info-red-mask visual-info))) (unless (zerop (visual-info-green-mask visual-info)) (setf (image-green-mask image) (visual-info-green-mask visual-info))) (unless (zerop (visual-info-blue-mask visual-info)) (setf (image-blue-mask image) (visual-info-blue-mask visual-info)))) (values image visual-info))))))) ;;;----------------------------------------------------------------------------- ;;; PUT-IMAGE (defun write-pixarray-1 (buffer-bbuf index array x y width height padded-bytes-per-line bits-per-pixel) (declare (type buffer-bytes buffer-bbuf) (type pixarray-1 array) (type card16 x y width height) (type array-index index padded-bytes-per-line) (type (member 1 4 8 16 24 32) bits-per-pixel) (ignore bits-per-pixel)) #.(declare-buffun) (with-vector (buffer-bbuf buffer-bytes) (do* ((h 0 (index1+ h)) (y y (index1+ y)) (right-bits (index-mod width 8)) (middle-bits (index- width right-bits)) (middle-bytes (index-ceiling middle-bits 8)) (start index (index+ start padded-bytes-per-line))) ((index>= h height)) (declare (type array-index h y right-bits middle-bits middle-bytes start)) (do* ((end (index+ start middle-bytes)) (i start (index1+ i)) (start-x x) (x start-x (index+ x 8))) ((index>= i end) (unless (index-zerop right-bits) (let ((x (index+ start-x middle-bits))) (declare (type array-index x)) (setf (aref buffer-bbuf end) (write-image-assemble-bytes (aref array y (index+ x 0)) (if (index> right-bits 1) (aref array y (index+ x 1)) 0) (if (index> right-bits 2) (aref array y (index+ x 2)) 0) (if (index> right-bits 3) (aref array y (index+ x 3)) 0) (if (index> right-bits 4) (aref array y (index+ x 4)) 0) (if (index> right-bits 5) (aref array y (index+ x 5)) 0) (if (index> right-bits 6) (aref array y (index+ x 6)) 0) 0))))) (declare (type array-index end i start-x x)) (setf (aref buffer-bbuf i) (write-image-assemble-bytes (aref array y (index+ x 0)) (aref array y (index+ x 1)) (aref array y (index+ x 2)) (aref array y (index+ x 3)) (aref array y (index+ x 4)) (aref array y (index+ x 5)) (aref array y (index+ x 6)) (aref array y (index+ x 7)))))))) (defun write-pixarray-4 (buffer-bbuf index array x y width height padded-bytes-per-line bits-per-pixel) (declare (type buffer-bytes buffer-bbuf) (type pixarray-4 array) (type int16 x y) (type card16 width height) (type array-index index padded-bytes-per-line) (type (member 1 4 8 16 24 32) bits-per-pixel) (ignore bits-per-pixel)) #.(declare-buffun) (with-vector (buffer-bbuf buffer-bytes) (do* ((h 0 (index1+ h)) (y y (index1+ y)) (right-nibbles (index-mod width 2)) (middle-nibbles (index- width right-nibbles)) (middle-bytes (index-ceiling middle-nibbles 2)) (start index (index+ start padded-bytes-per-line))) ((index>= h height)) (declare (type array-index h y right-nibbles middle-nibbles middle-bytes start)) (do* ((end (index+ start middle-bytes)) (i start (index1+ i)) (start-x x) (x start-x (index+ x 2))) ((index>= i end) (unless (index-zerop right-nibbles) (setf (aref buffer-bbuf end) (write-image-assemble-bytes (aref array y (index+ start-x middle-nibbles)) 0)))) (declare (type array-index end i start-x x)) (setf (aref buffer-bbuf i) (write-image-assemble-bytes (aref array y (index+ x 0)) (aref array y (index+ x 1)))))))) (defun write-pixarray-8 (buffer-bbuf index array x y width height padded-bytes-per-line bits-per-pixel) (declare (type buffer-bytes buffer-bbuf) (type pixarray-8 array) (type int16 x y) (type card16 width height) (type array-index index padded-bytes-per-line) (type (member 1 4 8 16 24 32) bits-per-pixel) (ignore bits-per-pixel)) #.(declare-buffun) (with-vector (buffer-bbuf buffer-bytes) (do* ((h 0 (index1+ h)) (y y (index1+ y)) (start index (index+ start padded-bytes-per-line))) ((index>= h height)) (declare (type array-index h y start)) (do* ((end (index+ start width)) (i start (index1+ i)) (x x (index1+ x))) ((index>= i end)) (declare (type array-index end i x)) (setf (aref buffer-bbuf i) (the card8 (aref array y x))))))) (defun write-pixarray-16 (buffer-bbuf index array x y width height padded-bytes-per-line bits-per-pixel) (declare (type buffer-bytes buffer-bbuf) (type pixarray-16 array) (type int16 x y) (type card16 width height) (type array-index index padded-bytes-per-line) (type (member 1 4 8 16 24 32) bits-per-pixel) (ignore bits-per-pixel)) #.(declare-buffun) (with-vector (buffer-bbuf buffer-bytes) (do* ((h 0 (index1+ h)) (y y (index1+ y)) (start index (index+ start padded-bytes-per-line))) ((index>= h height)) (declare (type array-index h y start)) (do* ((end (index+ start (index* width 2))) (i start (index+ i 2)) (x x (index1+ x))) ((index>= i end)) (declare (type array-index end i x)) (let ((pixel (aref array y x))) (declare (type pixarray-16-element-type pixel)) (setf (aref buffer-bbuf (index+ i 0)) (write-image-load-byte 0 pixel 16)) (setf (aref buffer-bbuf (index+ i 1)) (write-image-load-byte 8 pixel 16))))))) (defun write-pixarray-24 (buffer-bbuf index array x y width height padded-bytes-per-line bits-per-pixel) (declare (type buffer-bytes buffer-bbuf) (type pixarray-24 array) (type int16 x y) (type card16 width height) (type array-index index padded-bytes-per-line) (type (member 1 4 8 16 24 32) bits-per-pixel) (ignore bits-per-pixel)) #.(declare-buffun) (with-vector (buffer-bbuf buffer-bytes) (do* ((h 0 (index1+ h)) (y y (index1+ y)) (start index (index+ start padded-bytes-per-line))) ((index>= h height)) (declare (type array-index y start)) (do* ((end (index+ start (index* width 3))) (i start (index+ i 3)) (x x (index1+ x))) ((index>= i end)) (declare (type array-index end i x)) (let ((pixel (aref array y x))) (declare (type pixarray-24-element-type pixel)) (setf (aref buffer-bbuf (index+ i 0)) (write-image-load-byte 0 pixel 24)) (setf (aref buffer-bbuf (index+ i 1)) (write-image-load-byte 8 pixel 24)) (setf (aref buffer-bbuf (index+ i 2)) (write-image-load-byte 16 pixel 24))))))) (defun write-pixarray-32 (buffer-bbuf index array x y width height padded-bytes-per-line bits-per-pixel) (declare (type buffer-bytes buffer-bbuf) (type pixarray-32 array) (type int16 x y) (type card16 width height) (type array-index index padded-bytes-per-line) (type (member 1 4 8 16 24 32) bits-per-pixel) (ignore bits-per-pixel)) #.(declare-buffun) (with-vector (buffer-bbuf buffer-bytes) (do* ((h 0 (index1+ h)) (y y (index1+ y)) (start index (index+ start padded-bytes-per-line))) ((index>= h height)) (declare (type array-index h y start)) (do* ((end (index+ start (index* width 4))) (i start (index+ i 4)) (x x (index1+ x))) ((index>= i end)) (declare (type array-index end i x)) (let ((pixel (aref array y x))) (declare (type pixarray-32-element-type pixel)) (setf (aref buffer-bbuf (index+ i 0)) (write-image-load-byte 0 pixel 32)) (setf (aref buffer-bbuf (index+ i 1)) (write-image-load-byte 8 pixel 32)) (setf (aref buffer-bbuf (index+ i 2)) (write-image-load-byte 16 pixel 32)) (setf (aref buffer-bbuf (index+ i 3)) (write-image-load-byte 24 pixel 32))))))) (defun write-pixarray-internal (bbuf boffset pixarray x y width height padded-bytes-per-line bits-per-pixel write-pixarray-function from-unit from-byte-lsb-first-p from-bit-lsb-first-p to-unit to-byte-lsb-first-p to-bit-lsb-first-p) (declare (type buffer-bytes bbuf) (type pixarray pixarray) (type card16 x y width height) (type array-index boffset padded-bytes-per-line) (type (member 1 4 8 16 24 32) bits-per-pixel) (type function write-pixarray-function) (type (member 8 16 32) from-unit to-unit) (type generalized-boolean from-byte-lsb-first-p from-bit-lsb-first-p to-byte-lsb-first-p to-bit-lsb-first-p)) (multiple-value-bind (image-swap-function image-swap-lsb-first-p) (image-swap-function bits-per-pixel from-unit from-byte-lsb-first-p from-bit-lsb-first-p to-unit to-byte-lsb-first-p to-bit-lsb-first-p) (declare (type symbol image-swap-function) (type generalized-boolean image-swap-lsb-first-p)) (if (eq image-swap-function 'image-noswap) (funcall write-pixarray-function bbuf boffset pixarray x y width height padded-bytes-per-line bits-per-pixel) (with-image-data-buffer (buf (index* height padded-bytes-per-line)) (funcall write-pixarray-function buf 0 pixarray x y width height padded-bytes-per-line bits-per-pixel) (funcall (symbol-function image-swap-function) buf bbuf 0 boffset (index-ceiling (index* width bits-per-pixel) 8) padded-bytes-per-line padded-bytes-per-line height image-swap-lsb-first-p))))) (defun write-pixarray (bbuf boffset pixarray x y width height padded-bytes-per-line bits-per-pixel unit byte-lsb-first-p bit-lsb-first-p) (declare (type buffer-bytes bbuf) (type pixarray pixarray) (type card16 x y width height) (type array-index boffset padded-bytes-per-line) (type (member 1 4 8 16 24 32) bits-per-pixel) (type (member 8 16 32) unit) (type generalized-boolean byte-lsb-first-p bit-lsb-first-p)) (unless (fast-write-pixarray bbuf boffset pixarray x y width height padded-bytes-per-line bits-per-pixel unit byte-lsb-first-p bit-lsb-first-p) (write-pixarray-internal bbuf boffset pixarray x y width height padded-bytes-per-line bits-per-pixel (ecase bits-per-pixel ( 1 #'write-pixarray-1 ) ( 4 #'write-pixarray-4 ) ( 8 #'write-pixarray-8 ) (16 #'write-pixarray-16) (24 #'write-pixarray-24) (32 #'write-pixarray-32)) +image-unit+ +image-byte-lsb-first-p+ +image-bit-lsb-first-p+ unit byte-lsb-first-p bit-lsb-first-p))) (defun write-xy-format-image-x-data (data obuf data-start obuf-start x y width height from-padded-bytes-per-line to-padded-bytes-per-line from-bitmap-unit from-byte-lsb-first-p from-bit-lsb-first-p to-bitmap-unit to-byte-lsb-first-p to-bit-lsb-first-p) (declare (type buffer-bytes data obuf) (type array-index data-start obuf-start from-padded-bytes-per-line to-padded-bytes-per-line) (type card16 x y width height) (type (member 8 16 32) from-bitmap-unit to-bitmap-unit) (type generalized-boolean from-byte-lsb-first-p from-bit-lsb-first-p to-byte-lsb-first-p to-bit-lsb-first-p)) (assert (index-zerop (index-mod x 8))) (multiple-value-bind (image-swap-function image-swap-lsb-first-p) (image-swap-function 1 from-bitmap-unit from-byte-lsb-first-p from-bit-lsb-first-p to-bitmap-unit to-byte-lsb-first-p to-bit-lsb-first-p) (declare (type symbol image-swap-function) (type generalized-boolean image-swap-lsb-first-p)) (let ((x-mod-unit (index-mod x from-bitmap-unit))) (declare (type card16 x-mod-unit)) (if (and (index-plusp x-mod-unit) (not (eq from-byte-lsb-first-p from-bit-lsb-first-p))) (let* ((temp-width (index+ width x-mod-unit)) (temp-bytes-per-line (index-ceiling temp-width 8)) (temp-padded-bits-per-line (index* (index-ceiling temp-width from-bitmap-unit) from-bitmap-unit)) (temp-padded-bytes-per-line (index-ceiling temp-padded-bits-per-line 8))) (declare (type card16 temp-width temp-bytes-per-line temp-padded-bits-per-line temp-padded-bytes-per-line)) (with-image-data-buffer (buf (index* height temp-padded-bytes-per-line)) (funcall (symbol-function image-swap-function) data buf (index+ data-start (index* y from-padded-bytes-per-line) (index-floor (index- x x-mod-unit) 8)) 0 temp-bytes-per-line from-padded-bytes-per-line temp-padded-bytes-per-line height image-swap-lsb-first-p) (write-xy-format-image-x-data buf obuf 0 obuf-start x-mod-unit 0 width height temp-padded-bytes-per-line to-padded-bytes-per-line from-bitmap-unit to-byte-lsb-first-p to-byte-lsb-first-p to-bitmap-unit to-byte-lsb-first-p to-bit-lsb-first-p))) (funcall (symbol-function image-swap-function) data obuf (index+ data-start (index* y from-padded-bytes-per-line) (index-floor x 8)) obuf-start (index-ceiling width 8) from-padded-bytes-per-line to-padded-bytes-per-line height image-swap-lsb-first-p))))) (defun write-xy-format-image-x (display image src-x src-y width height padded-bytes-per-line unit byte-lsb-first-p bit-lsb-first-p) (declare (type display display) (type image-x image) (type int16 src-x src-y) (type card16 width height) (type array-index padded-bytes-per-line) (type (member 8 16 32) unit) (type generalized-boolean byte-lsb-first-p bit-lsb-first-p)) (dotimes (plane (image-depth image)) (let ((data-start (index* (index* plane (image-height image)) (image-x-bytes-per-line image))) (src-y src-y) (height height)) (declare (type int16 src-y) (type card16 height)) (loop (when (index-zerop height) (return)) (let ((nlines (index-min (index-floor (index- (buffer-size display) (buffer-boffset display)) padded-bytes-per-line) height))) (declare (type array-index nlines)) (when (index-plusp nlines) (write-xy-format-image-x-data (image-x-data image) (buffer-obuf8 display) data-start (buffer-boffset display) src-x src-y width nlines (image-x-bytes-per-line image) padded-bytes-per-line (image-x-unit image) (image-x-byte-lsb-first-p image) (image-x-bit-lsb-first-p image) unit byte-lsb-first-p bit-lsb-first-p) (index-incf (buffer-boffset display) (index* nlines padded-bytes-per-line)) (index-incf src-y nlines) (when (index-zerop (index-decf height nlines)) (return)))) (buffer-flush display))))) (defun write-z-format-image-x-data (data obuf data-start obuf-start x y width height from-padded-bytes-per-line to-padded-bytes-per-line bits-per-pixel from-bitmap-unit from-byte-lsb-first-p from-bit-lsb-first-p to-bitmap-unit to-byte-lsb-first-p to-bit-lsb-first-p) (declare (type buffer-bytes data obuf) (type array-index data-start obuf-start from-padded-bytes-per-line to-padded-bytes-per-line) (type card16 x y width height) (type (member 1 4 8 16 24 32) bits-per-pixel) (type (member 8 16 32) from-bitmap-unit to-bitmap-unit) (type generalized-boolean from-byte-lsb-first-p from-bit-lsb-first-p to-byte-lsb-first-p to-bit-lsb-first-p)) (if (index= bits-per-pixel 1) (write-xy-format-image-x-data data obuf data-start obuf-start x y width height from-padded-bytes-per-line to-padded-bytes-per-line from-bitmap-unit from-byte-lsb-first-p from-bit-lsb-first-p to-bitmap-unit to-byte-lsb-first-p to-bit-lsb-first-p) (let ((srcoff (index+ data-start (index* y from-padded-bytes-per-line) (index-floor (index* x bits-per-pixel) 8))) (srclen (index-ceiling (index* width bits-per-pixel) 8))) (declare (type array-index srcoff srclen)) (if (and (index= bits-per-pixel 4) (index-oddp x)) (with-image-data-buffer (buf (index* height to-padded-bytes-per-line)) (image-swap-nibbles-left data buf srcoff 0 srclen from-padded-bytes-per-line to-padded-bytes-per-line height nil) (write-z-format-image-x-data buf obuf 0 obuf-start 0 0 width height to-padded-bytes-per-line to-padded-bytes-per-line bits-per-pixel from-bitmap-unit from-byte-lsb-first-p from-bit-lsb-first-p to-bitmap-unit to-byte-lsb-first-p to-bit-lsb-first-p)) (multiple-value-bind (image-swap-function image-swap-lsb-first-p) (image-swap-function bits-per-pixel from-bitmap-unit from-byte-lsb-first-p from-bit-lsb-first-p to-bitmap-unit to-byte-lsb-first-p to-bit-lsb-first-p) (declare (type symbol image-swap-function) (type generalized-boolean image-swap-lsb-first-p)) (funcall (symbol-function image-swap-function) data obuf srcoff obuf-start srclen from-padded-bytes-per-line to-padded-bytes-per-line height image-swap-lsb-first-p)))))) (defun write-z-format-image-x (display image src-x src-y width height padded-bytes-per-line unit byte-lsb-first-p bit-lsb-first-p) (declare (type display display) (type image-x image) (type int16 src-x src-y) (type card16 width height) (type array-index padded-bytes-per-line) (type generalized-boolean byte-lsb-first-p bit-lsb-first-p)) (loop (when (index-zerop height) (return)) (let ((nlines (index-min (index-floor (index- (buffer-size display) (buffer-boffset display)) padded-bytes-per-line) height))) (declare (type array-index nlines)) (when (index-plusp nlines) (write-z-format-image-x-data (image-x-data image) (buffer-obuf8 display) 0 (buffer-boffset display) src-x src-y width nlines (image-x-bytes-per-line image) padded-bytes-per-line (image-x-bits-per-pixel image) (image-x-unit image) (image-x-byte-lsb-first-p image) (image-x-bit-lsb-first-p image) unit byte-lsb-first-p bit-lsb-first-p) (index-incf (buffer-boffset display) (index* nlines padded-bytes-per-line)) (index-incf src-y nlines) (when (index-zerop (index-decf height nlines)) (return)))) (buffer-flush display))) (defun write-image-xy (display image src-x src-y width height padded-bytes-per-line unit byte-lsb-first-p bit-lsb-first-p) (declare (type display display) (type image-xy image) (type array-index padded-bytes-per-line) (type int16 src-x src-y) (type card16 width height) (type (member 8 16 32) unit) (type generalized-boolean byte-lsb-first-p bit-lsb-first-p)) (dolist (bitmap (image-xy-bitmap-list image)) (declare (type pixarray-1 bitmap)) (let ((src-y src-y) (height height)) (declare (type int16 src-y) (type card16 height)) (loop (let ((nlines (index-min (index-floor (index- (buffer-size display) (buffer-boffset display)) padded-bytes-per-line) height))) (declare (type array-index nlines)) (when (index-plusp nlines) (write-pixarray (buffer-obuf8 display) (buffer-boffset display) bitmap src-x src-y width nlines padded-bytes-per-line 1 unit byte-lsb-first-p bit-lsb-first-p) (index-incf (buffer-boffset display) (index* nlines padded-bytes-per-line)) (index-incf src-y nlines) (when (index-zerop (index-decf height nlines)) (return)))) (buffer-flush display))))) (defun write-image-z (display image src-x src-y width height padded-bytes-per-line unit byte-lsb-first-p bit-lsb-first-p) (declare (type display display) (type image-z image) (type array-index padded-bytes-per-line) (type int16 src-x src-y) (type card16 width height) (type (member 8 16 32) unit) (type generalized-boolean byte-lsb-first-p bit-lsb-first-p)) (loop (let ((bits-per-pixel (image-z-bits-per-pixel image)) (nlines (index-min (index-floor (index- (buffer-size display) (buffer-boffset display)) padded-bytes-per-line) height))) (declare (type (member 1 4 8 16 24 32) bits-per-pixel) (type array-index nlines)) (when (index-plusp nlines) (write-pixarray (buffer-obuf8 display) (buffer-boffset display) (image-z-pixarray image) src-x src-y width nlines padded-bytes-per-line bits-per-pixel unit byte-lsb-first-p bit-lsb-first-p) (index-incf (buffer-boffset display) (index* nlines padded-bytes-per-line)) (index-incf src-y nlines) (when (index-zerop (index-decf height nlines)) (return)))) (buffer-flush display))) ;;; Note: The only difference between a format of :bitmap and :xy-pixmap ;;; of depth 1 is that when sending a :bitmap format the foreground ;;; and background in the gcontext are used. (defun put-image (drawable gcontext image &key (src-x 0) (src-y 0) ;Position within image (x (required-arg x)) ;Position within drawable (y (required-arg y)) width height bitmap-p) ;; Copy an image into a drawable. ;; WIDTH and HEIGHT default from IMAGE. ;; When BITMAP-P, force format to be :bitmap when depth=1. ;; This causes gcontext to supply foreground & background pixels. (declare (type drawable drawable) (type gcontext gcontext) (type image image) (type int16 x y) ;; required (type int16 src-x src-y) (type (or null card16) width height) (type generalized-boolean bitmap-p)) (let* ((format (etypecase image (image-x (image-x-format (the image-x image))) (image-xy :xy-pixmap) (image-z :z-pixmap))) (src-x (if (image-x-p image) (index+ src-x (image-x-left-pad (the image-x image))) src-x)) (image-width (image-width image)) (image-height (image-height image)) (width (min (or width image-width) (index- image-width src-x))) (height (min (or height image-height) (index- image-height src-y))) (depth (image-depth image)) (display (drawable-display drawable)) (bitmap-format (display-bitmap-format display)) (unit (bitmap-format-unit bitmap-format)) (byte-lsb-first-p (display-image-lsb-first-p display)) (bit-lsb-first-p (bitmap-format-lsb-first-p bitmap-format))) (declare (type (member :bitmap :xy-pixmap :z-pixmap) format) (type fixnum src-x image-width image-height width height) (type image-depth depth) (type display display) (type bitmap-format bitmap-format) (type (member 8 16 32) unit) (type generalized-boolean byte-lsb-first-p bit-lsb-first-p)) (when (and bitmap-p (not (index= depth 1))) (error "Bitmaps must have depth 1")) (unless (<= 0 src-x (index1- (image-width image))) (error "src-x not inside image")) (unless (<= 0 src-y (index1- (image-height image))) (error "src-y not inside image")) (when (and (index> width 0) (index> height 0)) (multiple-value-bind (pad bits-per-pixel) (ecase format ((:bitmap :xy-pixmap) (values (bitmap-format-pad bitmap-format) 1)) (:z-pixmap (if (= depth 1) (values (bitmap-format-pad bitmap-format) 1) (let ((pixmap-format (find depth (display-pixmap-formats display) :key #'pixmap-format-depth))) (declare (type (or null pixmap-format) pixmap-format)) (if (null pixmap-format) (error "The depth of the image ~s does not match any server pixmap format." image)) (if (not (= (etypecase image (image-z (image-z-bits-per-pixel image)) (image-x (image-x-bits-per-pixel image))) (pixmap-format-bits-per-pixel pixmap-format))) ;; We could try to use the "/* XXX slow, but works */" ;; code in XPutImage from X11R4 here. However, that ;; would require considerable support code ;; (see XImUtil.c, etc). (error "The bits-per-pixel of the image ~s does not match any server pixmap format." image)) (values (pixmap-format-scanline-pad pixmap-format) (pixmap-format-bits-per-pixel pixmap-format)))))) (declare (type (member 8 16 32) pad) (type (member 1 4 8 16 24 32) bits-per-pixel)) (let* ((left-pad (if (or (eq format :xy-pixmap) (= depth 1)) (index-mod src-x (index-min pad +image-pad+)) 0)) (left-padded-src-x (index- src-x left-pad)) (left-padded-width (index+ width left-pad)) (bits-per-line (index* left-padded-width bits-per-pixel)) (padded-bits-per-line (index* (index-ceiling bits-per-line pad) pad)) (padded-bytes-per-line (index-ceiling padded-bits-per-line 8)) (request-bytes-per-line (ecase format ((:bitmap :xy-pixmap) (index* padded-bytes-per-line depth)) (:z-pixmap padded-bytes-per-line))) (max-bytes-per-request (index* (index- (display-max-request-length display) 6) 4)) (max-request-height (floor max-bytes-per-request request-bytes-per-line))) (declare (type card8 left-pad) (type int16 left-padded-src-x) (type card16 left-padded-width) (type array-index bits-per-line padded-bits-per-line padded-bytes-per-line request-bytes-per-line max-bytes-per-request max-request-height)) ;; Be sure that a scanline can fit in a request (when (index-zerop max-request-height) (error "Can't even fit one image scanline in a request")) ;; Be sure a scanline can fit in a buffer (buffer-ensure-size display padded-bytes-per-line) ;; Send the image in multiple requests to avoid exceeding the ;; request limit (do* ((request-src-y src-y (index+ request-src-y request-height)) (request-y y (index+ request-y request-height)) (height-remaining height (the fixnum (- height-remaining request-height))) (request-height (index-min height-remaining max-request-height) (index-min height-remaining max-request-height))) ((<= height-remaining 0)) (declare (type array-index request-src-y request-height) (fixnum height-remaining)) (let* ((request-bytes (index* request-bytes-per-line request-height)) (request-words (index-ceiling request-bytes 4)) (request-length (index+ request-words 6))) (declare (type array-index request-bytes) (type card16 request-words request-length)) (with-buffer-request (display +x-putimage+ :gc-force gcontext) ((data (member :bitmap :xy-pixmap :z-pixmap)) (cond ((or (eq format :bitmap) bitmap-p) :bitmap) ((plusp left-pad) :xy-pixmap) (t format))) (drawable drawable) (gcontext gcontext) (card16 width request-height) (int16 x request-y) (card8 left-pad depth) (pad16 nil) (progn (length-put 2 request-length) (setf (buffer-boffset display) (advance-buffer-offset 24)) (etypecase image (image-x (ecase (image-x-format (the image-x image)) ((:bitmap :xy-pixmap) (write-xy-format-image-x display image left-padded-src-x request-src-y left-padded-width request-height padded-bytes-per-line unit byte-lsb-first-p bit-lsb-first-p)) (:z-pixmap (write-z-format-image-x display image left-padded-src-x request-src-y left-padded-width request-height padded-bytes-per-line unit byte-lsb-first-p bit-lsb-first-p)))) (image-xy (write-image-xy display image left-padded-src-x request-src-y left-padded-width request-height padded-bytes-per-line unit byte-lsb-first-p bit-lsb-first-p)) (image-z (write-image-z display image left-padded-src-x request-src-y left-padded-width request-height padded-bytes-per-line unit byte-lsb-first-p bit-lsb-first-p))) ;; Be sure the request is padded to a multiple of 4 bytes (buffer-pad-request display (index- (index* request-words 4) request-bytes)) ))))))))) ;;;----------------------------------------------------------------------------- ;;; COPY-IMAGE (defun xy-format-image-x->image-x (image x y width height) (declare (type image-x image) (type card16 x y width height) (clx-values image-x)) (let* ((padded-x (index+ x (image-x-left-pad image))) (left-pad (index-mod padded-x 8)) (x (index- padded-x left-pad)) (unit (image-x-unit image)) (byte-lsb-first-p (image-x-byte-lsb-first-p image)) (bit-lsb-first-p (image-x-bit-lsb-first-p image)) (pad (image-x-pad image)) (padded-width (index* (index-ceiling (index+ width left-pad) pad) pad)) (padded-bytes-per-line (index-ceiling padded-width 8)) (padded-bytes-per-plane (index* padded-bytes-per-line height)) (length (index* padded-bytes-per-plane (image-depth image))) (obuf (make-array length :element-type 'card8))) (declare (type card16 x) (type card8 left-pad) (type (member 8 16 32) unit pad) (type array-index padded-width padded-bytes-per-line padded-bytes-per-plane length) (type buffer-bytes obuf)) (dotimes (plane (image-depth image)) (let ((data-start (index* (image-x-bytes-per-line image) (image-height image) plane)) (obuf-start (index* padded-bytes-per-plane plane))) (declare (type array-index data-start obuf-start)) (write-xy-format-image-x-data (image-x-data image) obuf data-start obuf-start x y width height (image-x-bytes-per-line image) padded-bytes-per-line unit byte-lsb-first-p bit-lsb-first-p unit byte-lsb-first-p bit-lsb-first-p))) (create-image :width width :height height :depth (image-depth image) :data obuf :format (image-x-format image) :bits-per-pixel 1 :bytes-per-line padded-bytes-per-line :unit unit :pad pad :left-pad left-pad :byte-lsb-first-p byte-lsb-first-p :bit-lsb-first-p bit-lsb-first-p))) (defun z-format-image-x->image-x (image x y width height) (declare (type image-x image) (type card16 x y width height) (clx-values image-x)) (let* ((padded-x (index+ x (image-x-left-pad image))) (left-pad (if (index= (image-depth image) 1) (index-mod padded-x 8) 0)) (x (index- padded-x left-pad)) (bits-per-pixel (image-x-bits-per-pixel image)) (unit (image-x-unit image)) (byte-lsb-first-p (image-x-byte-lsb-first-p image)) (bit-lsb-first-p (image-x-bit-lsb-first-p image)) (pad (image-x-pad image)) (bits-per-line (index* (index+ width left-pad) bits-per-pixel)) (padded-bits-per-line (index* (index-ceiling bits-per-line pad) pad)) (padded-bytes-per-line (index-ceiling padded-bits-per-line 8)) (padded-bytes-per-plane (index* padded-bytes-per-line height)) (length (index* padded-bytes-per-plane (image-depth image))) (obuf (make-array length :element-type 'card8))) (declare (type card16 x) (type card8 left-pad) (type (member 8 16 32) unit pad) (type array-index bits-per-pixel padded-bytes-per-line padded-bytes-per-plane length) (type buffer-bytes obuf)) (write-z-format-image-x-data (image-x-data image) obuf 0 0 x y width height (image-x-bytes-per-line image) padded-bytes-per-line bits-per-pixel unit byte-lsb-first-p bit-lsb-first-p unit byte-lsb-first-p bit-lsb-first-p) (create-image :width width :height height :depth (image-depth image) :data obuf :format :z-pixmap :bits-per-pixel bits-per-pixel :bytes-per-line padded-bytes-per-line :unit unit :pad pad :left-pad left-pad :byte-lsb-first-p byte-lsb-first-p :bit-lsb-first-p bit-lsb-first-p))) (defun image-x->image-x (image x y width height) (declare (type image-x image) (type card16 x y width height) (clx-values image-x)) (ecase (image-x-format image) ((:bitmap :xy-pixmap) (xy-format-image-x->image-x image x y width height)) (:z-pixmap (z-format-image-x->image-x image x y width height)))) (defun image-x->image-xy (image x y width height) (declare (type image-x image) (type card16 x y width height) (clx-values image-xy)) (unless (or (eq (image-x-format image) :bitmap) (eq (image-x-format image) :xy-pixmap) (and (eq (image-x-format image) :z-pixmap) (index= (image-depth image) 1))) (error "Format conversion from ~S to ~S not supported" (image-x-format image) :xy-pixmap)) (read-image-xy (image-x-data image) 0 (length (image-x-data image)) nil (index+ x (image-x-left-pad image)) y width height (image-depth image) (image-x-bytes-per-line image) (index* (image-x-bytes-per-line image) (image-height image)) (image-x-unit image) (image-x-byte-lsb-first-p image) (image-x-bit-lsb-first-p image))) (defun image-x->image-z (image x y width height) (declare (type image-x image) (type card16 x y width height) (clx-values image-z)) (unless (or (eq (image-x-format image) :z-pixmap) (eq (image-x-format image) :bitmap) (and (eq (image-x-format image) :xy-pixmap) (index= (image-depth image) 1))) (error "Format conversion from ~S to ~S not supported" (image-x-format image) :z-pixmap)) (read-image-z (image-x-data image) 0 (length (image-x-data image)) nil (index+ x (image-x-left-pad image)) y width height (image-depth image) (image-x-bytes-per-line image) (image-x-bits-per-pixel image) (image-x-unit image) (image-x-byte-lsb-first-p image) (image-x-bit-lsb-first-p image))) (defun copy-pixarray (array x y width height bits-per-pixel) (declare (type pixarray array) (type card16 x y width height) (type (member 1 4 8 16 24 32) bits-per-pixel)) (let* ((bits-per-line (index* bits-per-pixel width)) (padded-bits-per-line (index* (index-ceiling bits-per-line +image-pad+) +image-pad+)) (padded-width (index-ceiling padded-bits-per-line bits-per-pixel)) (copy (make-array (list height padded-width) :element-type (array-element-type array)))) (declare (type array-index bits-per-line padded-bits-per-line padded-width) (type pixarray copy)) #.(declare-buffun) (unless (fast-copy-pixarray array copy x y width height bits-per-pixel) (macrolet ((copy (array-type element-type) `(let ((array array) (copy copy)) (declare (type ,array-type array copy)) (do* ((dst-y 0 (index1+ dst-y)) (src-y y (index1+ src-y))) ((index>= dst-y height)) (declare (type card16 dst-y src-y)) (do* ((dst-x 0 (index1+ dst-x)) (src-x x (index1+ src-x))) ((index>= dst-x width)) (declare (type card16 dst-x src-x)) (setf (aref copy dst-y dst-x) (the ,element-type (aref array src-y src-x)))))))) (ecase bits-per-pixel (1 (copy pixarray-1 pixarray-1-element-type)) (4 (copy pixarray-4 pixarray-4-element-type)) (8 (copy pixarray-8 pixarray-8-element-type)) (16 (copy pixarray-16 pixarray-16-element-type)) (24 (copy pixarray-24 pixarray-24-element-type)) (32 (copy pixarray-32 pixarray-32-element-type))))) copy)) (defun image-xy->image-x (image x y width height) (declare (type image-xy image) (type card16 x y width height) (clx-values image-x)) (let* ((padded-bits-per-line (index* (index-ceiling width +image-pad+) +image-pad+)) (padded-bytes-per-line (index-ceiling padded-bits-per-line 8)) (padded-bytes-per-plane (index* padded-bytes-per-line height)) (bytes-total (index* padded-bytes-per-plane (image-depth image))) (data (make-array bytes-total :element-type 'card8))) (declare (type array-index padded-bits-per-line padded-bytes-per-line padded-bytes-per-plane bytes-total) (type buffer-bytes data)) (let ((index 0)) (declare (type array-index index)) (dolist (bitmap (image-xy-bitmap-list image)) (declare (type pixarray-1 bitmap)) (write-pixarray data index bitmap x y width height padded-bytes-per-line 1 +image-unit+ +image-byte-lsb-first-p+ +image-bit-lsb-first-p+) (index-incf index padded-bytes-per-plane))) (create-image :width width :height height :depth (image-depth image) :data data :format :xy-pixmap :bits-per-pixel 1 :bytes-per-line padded-bytes-per-line :unit +image-unit+ :pad +image-pad+ :byte-lsb-first-p +image-byte-lsb-first-p+ :bit-lsb-first-p +image-bit-lsb-first-p+))) (defun image-xy->image-xy (image x y width height) (declare (type image-xy image) (type card16 x y width height) (clx-values image-xy)) (create-image :width width :height height :depth (image-depth image) :data (mapcar #'(lambda (array) (declare (type pixarray-1 array)) (copy-pixarray array x y width height 1)) (image-xy-bitmap-list image)))) (defun image-xy->image-z (image x y width height) (declare (type image-xy image) (type card16 x y width height) (ignore image x y width height)) (error "Format conversion from ~S to ~S not supported" :xy-pixmap :z-pixmap)) (defun image-z->image-x (image x y width height) (declare (type image-z image) (type card16 x y width height) (clx-values image-x)) (let* ((bits-per-line (index* width (image-z-bits-per-pixel image))) (padded-bits-per-line (index* (index-ceiling bits-per-line +image-pad+) +image-pad+)) (padded-bytes-per-line (index-ceiling padded-bits-per-line 8)) (bytes-total (index* padded-bytes-per-line height (image-depth image))) (data (make-array bytes-total :element-type 'card8)) (bits-per-pixel (image-z-bits-per-pixel image))) (declare (type array-index bits-per-line padded-bits-per-line padded-bytes-per-line bytes-total) (type buffer-bytes data) (type (member 1 4 8 16 24 32) bits-per-pixel)) (write-pixarray data 0 (image-z-pixarray image) x y width height padded-bytes-per-line (image-z-bits-per-pixel image) +image-unit+ +image-byte-lsb-first-p+ +image-bit-lsb-first-p+) (create-image :width width :height height :depth (image-depth image) :data data :format :z-pixmap :bits-per-pixel bits-per-pixel :bytes-per-line padded-bytes-per-line :unit +image-unit+ :pad +image-pad+ :byte-lsb-first-p +image-byte-lsb-first-p+ :bit-lsb-first-p +image-bit-lsb-first-p+))) (defun image-z->image-xy (image x y width height) (declare (type image-z image) (type card16 x y width height) (ignore image x y width height)) (error "Format conversion from ~S to ~S not supported" :z-pixmap :xy-pixmap)) (defun image-z->image-z (image x y width height) (declare (type image-z image) (type card16 x y width height) (clx-values image-z)) (create-image :width width :height height :depth (image-depth image) :data (copy-pixarray (image-z-pixarray image) x y width height (image-z-bits-per-pixel image)))) (defun copy-image (image &key (x 0) (y 0) width height result-type) ;; Copy with optional sub-imaging and format conversion. ;; result-type defaults to (type-of image) (declare (type image image) (type card16 x y) (type (or null card16) width height) ;; Default from image (type (or null (member image-x image-xy image-z)) result-type)) (declare (clx-values image)) (let* ((image-width (image-width image)) (image-height (image-height image)) (width (or width image-width)) (height (or height image-height))) (declare (type card16 image-width image-height width height)) (unless (<= 0 x (the fixnum (1- image-width))) (error "x not inside image")) (unless (<= 0 y (the fixnum (1- image-height))) (error "y not inside image")) (setq width (index-min width (max (the fixnum (- image-width x)) 0))) (setq height (index-min height (max (the fixnum (- image-height y)) 0))) (let ((copy (etypecase image (image-x (ecase result-type ((nil image-x) (image-x->image-x image x y width height)) (image-xy (image-x->image-xy image x y width height)) (image-z (image-x->image-z image x y width height)))) (image-xy (ecase result-type (image-x (image-xy->image-x image x y width height)) ((nil image-xy) (image-xy->image-xy image x y width height)) (image-z (image-xy->image-z image x y width height)))) (image-z (ecase result-type (image-x (image-z->image-x image x y width height)) (image-xy (image-z->image-xy image x y width height)) ((nil image-z) (image-z->image-z image x y width height))))))) (declare (type image copy)) (setf (image-plist copy) (copy-list (image-plist image))) (when (and (image-x-hot image) (not (index-zerop x))) (setf (image-x-hot copy) (index- (image-x-hot image) x))) (when (and (image-y-hot image) (not (index-zerop y))) (setf (image-y-hot copy) (index- (image-y-hot image) y))) copy))) ;;;----------------------------------------------------------------------------- ;;; Image I/O functions (defun read-bitmap-file (pathname) ;; Creates an image from a C include file in standard X11 format (declare (type (or pathname string stream) pathname)) (declare (clx-values image)) (with-open-file (fstream pathname :direction :input) (let ((line "") (properties nil) (name nil) (name-end nil)) (declare (type string line) (type stringable name) (type list properties)) ;; Get properties (loop (setq line (read-line fstream)) (unless (char= (aref line 0) #\#) (return)) (flet ((read-keyword (line start end) (kintern (substitute #\- #\_ (#-excl string-upcase #+excl correct-case (subseq line start end)) :test #'char=)))) (when (null name) (setq name-end (position #\_ line :test #'char= :from-end t) name (read-keyword line 8 name-end)) (unless (eq name :image) (setf (getf properties :name) name))) (let* ((ind-start (index1+ name-end)) (ind-end (position #\Space line :test #'char= :start ind-start)) (ind (read-keyword line ind-start ind-end)) (val-start (index1+ ind-end)) (val (parse-integer line :start val-start))) (setf (getf properties ind) val)))) ;; Calculate sizes (multiple-value-bind (width height depth left-pad) (flet ((extract-property (ind &rest default) (prog1 (apply #'getf properties ind default) (remf properties ind)))) (values (extract-property :width) (extract-property :height) (extract-property :depth 1) (extract-property :left-pad 0))) (declare (type (or null card16) width height) (type image-depth depth) (type card8 left-pad)) (unless (and width height) (error "Not a BITMAP file")) (let* ((bits-per-pixel (cond ((index> depth 24) 32) ((index> depth 16) 24) ((index> depth 8) 16) ((index> depth 4) 8) ((index> depth 1) 4) (t 1))) (bits-per-line (index* width bits-per-pixel)) (bytes-per-line (index-ceiling bits-per-line 8)) (padded-bits-per-line (index* (index-ceiling bits-per-line 32) 32)) (padded-bytes-per-line (index-ceiling padded-bits-per-line 8)) (data (make-array (* padded-bytes-per-line height) :element-type 'card8)) (line-base 0) (byte 0)) (declare (type array-index bits-per-line bytes-per-line padded-bits-per-line padded-bytes-per-line line-base byte) (type buffer-bytes data)) (with-vector (data buffer-bytes) (flet ((parse-hex (char) (second (assoc char '((#\0 0) (#\1 1) (#\2 2) (#\3 3) (#\4 4) (#\5 5) (#\6 6) (#\7 7) (#\8 8) (#\9 9) (#\a 10) (#\b 11) (#\c 12) (#\d 13) (#\e 14) (#\f 15)) :test #'char-equal)))) (declare (inline parse-hex)) ;; Read data ;; Note: using read-line instead of read-char would be 20% faster, ;; but would cons a lot of garbage... (dotimes (i height) (dotimes (j bytes-per-line) (loop (when (eql (read-char fstream) #\x) (return))) (setf (aref data (index+ line-base byte)) (index+ (index-ash (parse-hex (read-char fstream)) 4) (parse-hex (read-char fstream)))) (incf byte)) (setq byte 0 line-base (index+ line-base padded-bytes-per-line))))) ;; Compensate for left-pad in width and x-hot (index-decf width left-pad) (when (and (getf properties :x-hot) (plusp (getf properties :x-hot))) (index-decf (getf properties :x-hot) left-pad)) (create-image :width width :height height :depth depth :bits-per-pixel bits-per-pixel :data data :plist properties :format :z-pixmap :bytes-per-line padded-bytes-per-line :unit 32 :pad 32 :left-pad left-pad :byte-lsb-first-p t :bit-lsb-first-p t)))))) (defun write-bitmap-file (pathname image &optional name) ;; Writes an image to a C include file in standard X11 format ;; NAME argument used for variable prefixes. Defaults to "image" (declare (type (or pathname string stream) pathname) (type image image) (type (or null stringable) name)) (unless (typep image 'image-x) (setq image (copy-image image :result-type 'image-x))) (let* ((plist (image-plist image)) (name (or name (image-name image) 'image)) (left-pad (image-x-left-pad image)) (width (index+ (image-width image) left-pad)) (height (image-height image)) (depth (if (eq (image-x-format image) :z-pixmap) (image-depth image) 1)) (bits-per-pixel (image-x-bits-per-pixel image)) (bits-per-line (index* width bits-per-pixel)) (bytes-per-line (index-ceiling bits-per-line 8)) (last (index* bytes-per-line height)) (count 0)) (declare (type list plist) (type stringable name) (type card8 left-pad) (type card16 width height) (type (member 1 4 8 16 24 32) bits-per-pixel) (type image-depth depth) (type array-index bits-per-line bytes-per-line count last)) ;; Move x-hot by left-pad, if there is an x-hot, so image readers that ;; don't know about left pad get the hot spot in the right place. We have ;; already increased width by left-pad. (when (getf plist :x-hot) (setq plist (copy-list plist)) (index-incf (getf plist :x-hot) left-pad)) (with-image-data-buffer (data last) (multiple-value-bind (image-swap-function image-swap-lsb-first-p) (image-swap-function bits-per-pixel (image-x-unit image) (image-x-byte-lsb-first-p image) (image-x-bit-lsb-first-p image) 32 t t) (declare (type symbol image-swap-function) (type generalized-boolean image-swap-lsb-first-p)) (funcall (symbol-function image-swap-function) (image-x-data image) data 0 0 bytes-per-line (image-x-bytes-per-line image) bytes-per-line height image-swap-lsb-first-p)) (with-vector (data buffer-bytes) (setq name (string-downcase (string name))) (with-open-file (fstream pathname :direction :output) (format fstream "#define ~a_width ~d~%" name width) (format fstream "#define ~a_height ~d~%" name height) (unless (= depth 1) (format fstream "#define ~a_depth ~d~%" name depth)) (unless (zerop left-pad) (format fstream "#define ~a_left_pad ~d~%" name left-pad)) (do ((prop plist (cddr prop))) ((endp prop)) (when (and (not (member (car prop) '(:width :height))) (numberp (cadr prop))) (format fstream "#define ~a_~a ~d~%" name (substitute #\_ #\- (string-downcase (string (car prop))) :test #'char=) (cadr prop)))) (format fstream "static char ~a_bits[] = {" name) (dotimes (i height) (dotimes (j bytes-per-line) (when (zerop (index-mod count 15)) (terpri fstream) (write-char #\space fstream)) (write-string "0x" fstream) ;; Faster than (format fstream "0x~2,'0x," byte) (let ((byte (aref data count)) (translate "0123456789abcdef")) (declare (type card8 byte)) (write-char (char translate (ldb (byte 4 4) byte)) fstream) (write-char (char translate (ldb (byte 4 0) byte)) fstream)) (index-incf count) (unless (index= count last) (write-char #\, fstream)))) (format fstream "};~%")))))) (defun bitmap-image (&optional plist &rest patterns) ;; Create an image containg pattern ;; PATTERNS are bit-vector constants (e.g. #*10101) ;; If the first parameter is a list, its used as the image property-list. (declare (type (or list bit-vector) plist) (type list patterns)) ;; list of bitvector (declare (clx-values image)) (unless (listp plist) (push plist patterns) (setq plist nil)) (let* ((width (length (first patterns))) (height (length patterns)) (bitarray (make-array (list height width) :element-type 'bit)) (row 0)) (declare (type card16 width height row) (type pixarray-1 bitarray)) (dolist (pattern patterns) (declare (type simple-bit-vector pattern)) (dotimes (col width) (declare (type card16 col)) (setf (aref bitarray row col) (the bit (aref pattern col)))) (incf row)) (create-image :width width :height height :plist plist :data bitarray))) (defun image-pixmap (drawable image &key gcontext width height depth) ;; Create a pixmap containing IMAGE. Size defaults from the image. ;; DEPTH is the pixmap depth. ;; GCONTEXT is used for putting the image into the pixmap. ;; If none is supplied, then one is created, used then freed. (declare (type drawable drawable) (type image image) (type (or null gcontext) gcontext) (type (or null card16) width height) (type (or null card8) depth)) (declare (clx-values pixmap)) (let* ((image-width (image-width image)) (image-height (image-height image)) (image-depth (image-depth image)) (width (or width image-width)) (height (or height image-height)) (depth (or depth image-depth)) (pixmap (create-pixmap :drawable drawable :width width :height height :depth depth)) (gc (or gcontext (create-gcontext :drawable pixmap :foreground 1 :background 0)))) (unless (= depth image-depth) (if (= image-depth 1) (unless gcontext (xlib::required-arg gcontext)) (error "Pixmap depth ~d incompatible with image depth ~d" depth image-depth))) (put-image pixmap gc image :x 0 :y 0 :bitmap-p (and (= image-depth 1) gcontext)) ;; Tile when image-width is less than the pixmap width, or ;; the image-height is less than the pixmap height. ;; ??? Would it be better to create a temporary pixmap and ;; ??? let the server do the tileing? (do ((x image-width (+ x image-width))) ((>= x width)) (copy-area pixmap gc 0 0 image-width image-height pixmap x 0) (incf image-width image-width)) (do ((y image-height (+ y image-height))) ((>= y height)) (copy-area pixmap gc 0 0 image-width image-height pixmap 0 y) (incf image-height image-height)) (unless gcontext (free-gcontext gc)) pixmap)) ecl-16.1.2/src/clx/input.lisp000066400000000000000000002462701266352375300160000ustar00rootroot00000000000000;;; -*- Mode: LISP; Syntax: Common-lisp; Package: XLIB; Base: 10; Lowercase: Yes -*- ;;; This file contains definitions for the DISPLAY object for Common-Lisp X windows version 11 ;;; ;;; TEXAS INSTRUMENTS INCORPORATED ;;; P.O. BOX 2909 ;;; AUSTIN, TEXAS 78769 ;;; ;;; Copyright (C) 1987 Texas Instruments Incorporated. ;;; ;;; Permission is granted to any individual or institution to use, copy, modify, ;;; and distribute this software, provided that this complete copyright and ;;; permission notice is maintained, intact, in all copies and supporting ;;; documentation. ;;; ;;; Texas Instruments Incorporated provides this software "as is" without ;;; express or implied warranty. ;;; ;;; ;;; Change history: ;;; ;;; Date Author Description ;;; ------------------------------------------------------------------------------------- ;;; 12/10/87 LGO Created (in-package :xlib) ;; Event Resource (defvar *event-free-list* nil) ;; List of unused (processed) events (eval-when (:compile-toplevel :load-toplevel :execute) ;; Maximum number of events supported (the X11 alpha release only has 34) (defconstant +max-events+ 64) (defvar *event-key-vector* (make-array +max-events+ :initial-element nil) "Vector of event keys - See define-event")) (defvar *event-macro-vector* (make-array +max-events+ :initial-element nil) "Vector of event handler functions - See declare-event") (defvar *event-handler-vector* (make-array +max-events+ :initial-element nil) "Vector of event handler functions - See declare-event") (defvar *event-send-vector* (make-array +max-events+ :initial-element nil) "Vector of event sending functions - See declare-event") (defun allocate-event () (or (threaded-atomic-pop *event-free-list* reply-next reply-buffer) (make-reply-buffer +replysize+))) (defun deallocate-event (reply-buffer) (declare (type reply-buffer reply-buffer)) (setf (reply-size reply-buffer) +replysize+) (threaded-atomic-push reply-buffer *event-free-list* reply-next reply-buffer)) ;; Extensions are handled as follows: ;; DEFINITION: Use DEFINE-EXTENSION ;; ;; CODE: Use EXTENSION-CODE to get the X11 opcode for an extension. ;; This looks up the code on the display-extension-alist. ;; ;; EVENTS: Use DECLARE-EVENT to define events. This calls ALLOCATE-EXTENSION-EVENT-CODE ;; at LOAD time to define an internal event-code number ;; (stored in the 'event-code property of the event-name) ;; used to index the following vectors: ;; *event-key-vector* Used for getting the event-key ;; *event-macro-vector* Used for getting the event-parameter getting macros ;; ;; The GET-INTERNAL-EVENT-CODE function can be called at runtime to convert ;; a server event-code into an internal event-code used to index the following ;; vectors: ;; *event-handler-vector* Used for getting the event-handler function ;; *event-send-vector* Used for getting the event-sending function ;; ;; The GET-EXTERNAL-EVENT-CODE function can be called at runtime to convert ;; internal event-codes to external (server) codes. ;; ;; ERRORS: Use DEFINE-ERROR to define new error decodings. ;; ;; Any event-code greater than 34 is for an extension (defparameter *first-extension-event-code* 35) (defvar *extensions* nil) ;; alist of (extension-name-symbol events errors) (defmacro define-extension (name &key events errors) ;; Define extension NAME with EVENTS and ERRORS. ;; Note: The case of NAME is important. ;; To define the request, Use: ;; (with-buffer-request (display (extension-opcode ,name)) ,@body) ;; See the REQUESTS file for lots of examples. ;; To define event handlers, use declare-event. ;; To define error handlers, use declare-error and define-condition. (declare (type stringable name) (type list events errors)) (let ((name-symbol (kintern name)) ;; Intern name in the keyword package (event-list (mapcar #'canonicalize-event-name events))) `(eval-when (:compile-toplevel :load-toplevel :execute) (setq *extensions* (cons (list ',name-symbol ',event-list ',errors) (delete ',name-symbol *extensions* :key #'car)))))) (eval-when (:compile-toplevel :load-toplevel :execute) (defun canonicalize-event-name (event) ;; Returns the event name keyword given an event name stringable (declare (type stringable event)) (declare (clx-values event-key)) (kintern event))) (defun extension-event-key-p (key) (dolist (extension *extensions* nil) (when (member key (second extension)) (return t)))) (eval-when (:compile-toplevel :load-toplevel :execute) (defun allocate-extension-event-code (name) ;; Allocate an event-code for an extension. This is executed at ;; COMPILE and LOAD time from DECLARE-EVENT. The event-code is ;; used at compile-time by macros to index the following vectors: ;; *EVENT-KEY-VECTOR* *EVENT-MACRO-VECTOR* *EVENT-HANDLER-VECTOR* ;; *EVENT-SEND-VECTOR* (let ((event-code (get name 'event-code))) (declare (type (or null card8) event-code)) (unless event-code ;; First ensure the name is for a declared extension (unless (extension-event-key-p name) (x-type-error name 'event-key)) (setq event-code (position nil *event-key-vector* :start *first-extension-event-code*)) (setf (svref *event-key-vector* event-code) name) (setf (get name 'event-code) event-code)) event-code))) (defun get-internal-event-code (display code) ;; Given an X11 event-code, return the internal event-code. ;; The internal event-code is used for indexing into the following vectors: ;; *event-key-vector* *event-handler-vector* *event-send-vector* ;; Returns NIL when the event-code is for an extension that isn't handled. (declare (type display display) (type card8 code)) (declare (clx-values (or null card8))) (setq code (logand #x7f code)) (if (< code *first-extension-event-code*) code (let* ((code-offset (- code *first-extension-event-code*)) (event-extensions (display-event-extensions display)) (code (if (< code-offset (length event-extensions)) (aref event-extensions code-offset) 0))) (declare (type card8 code-offset code)) (when (zerop code) (x-cerror "Ignore the event" 'unimplemented-event :event-code code :display display)) code))) (defun get-external-event-code (display event) ;; Given an X11 event name, return the event-code (declare (type display display) (type event-key event)) (declare (clx-values card8)) (let ((code (get-event-code event))) (declare (type (or null card8) code)) (when (>= code *first-extension-event-code*) (setq code (+ *first-extension-event-code* (or (position code (display-event-extensions display)) (x-error 'undefined-event :display display :event-name event))))) code)) (defmacro extension-opcode (display name) ;; Returns the major opcode for extension NAME. ;; This is a macro to enable NAME to be interned for fast run-time ;; retrieval. ;; Note: The case of NAME is important. (let ((name-symbol (kintern name))) ;; Intern name in the keyword package `(or (second (assoc ',name-symbol (display-extension-alist ,display))) (x-error 'absent-extension :name ',name-symbol :display ,display)))) (defun initialize-extensions (display) ;; Initialize extensions for DISPLAY (let ((event-extensions (make-array 16 :element-type 'card8 :initial-element 0)) (extension-alist nil)) (declare (type vector event-extensions) (type list extension-alist)) (dolist (extension *extensions*) (let ((name (first extension)) (events (second extension))) (declare (type keyword name) (type list events)) (multiple-value-bind (major-opcode first-event first-error) (query-extension display name) (declare (type (or null card8) major-opcode first-event first-error)) (when (and major-opcode (plusp major-opcode)) (push (list name major-opcode first-event first-error) extension-alist) (when (plusp first-event) ;; When there are extension events ;; Grow extension vector when needed (let ((max-event (- (+ first-event (length events)) *first-extension-event-code*))) (declare (type card8 max-event)) (when (>= max-event (length event-extensions)) (let ((new-extensions (make-array (+ max-event 16) :element-type 'card8 :initial-element 0))) (declare (type vector new-extensions)) (replace new-extensions event-extensions) (setq event-extensions new-extensions)))) (dolist (event events) (declare (type symbol event)) (setf (aref event-extensions (- first-event *first-extension-event-code*)) (get-event-code event)) (incf first-event))))))) (setf (display-event-extensions display) event-extensions) (setf (display-extension-alist display) extension-alist))) ;; ;; Reply handlers ;; (defvar *pending-command-free-list* nil) (defun start-pending-command (display) (declare (type display display)) (let ((pending-command (or (threaded-atomic-pop *pending-command-free-list* pending-command-next pending-command) (make-pending-command)))) (declare (type pending-command pending-command)) (setf (pending-command-reply-buffer pending-command) nil) (setf (pending-command-process pending-command) (current-process)) (setf (pending-command-sequence pending-command) (ldb (byte 16 0) (1+ (buffer-request-number display)))) ;; Add the pending command to the end of the threaded list of pending ;; commands for the display. (with-event-queue-internal (display) (threaded-nconc pending-command (display-pending-commands display) pending-command-next pending-command)) pending-command)) (defun stop-pending-command (display pending-command) (declare (type display display) (type pending-command pending-command)) (with-event-queue-internal (display) ;; Remove the pending command from the threaded list of pending commands ;; for the display. (threaded-delete pending-command (display-pending-commands display) pending-command-next pending-command) ;; Deallocate any reply buffers in this pending command (loop (let ((reply-buffer (threaded-pop (pending-command-reply-buffer pending-command) reply-next reply-buffer))) (declare (type (or null reply-buffer) reply-buffer)) (if reply-buffer (deallocate-reply-buffer reply-buffer) (return nil))))) ;; Clear pointers to help the Garbage Collector (setf (pending-command-process pending-command) nil) ;; Deallocate this pending-command (threaded-atomic-push pending-command *pending-command-free-list* pending-command-next pending-command) nil) ;;; (defvar *reply-buffer-free-lists* (make-array 32 :initial-element nil)) (defun allocate-reply-buffer (size) (declare (type array-index size)) (if (index<= size +replysize+) (allocate-event) (let ((index (integer-length (index1- size)))) (declare (type array-index index)) (or (threaded-atomic-pop (svref *reply-buffer-free-lists* index) reply-next reply-buffer) (make-reply-buffer (index-ash 1 index)))))) (defun deallocate-reply-buffer (reply-buffer) (declare (type reply-buffer reply-buffer)) (let ((size (reply-size reply-buffer))) (declare (type array-index size)) (if (index<= size +replysize+) (deallocate-event reply-buffer) (let ((index (integer-length (index1- size)))) (declare (type array-index index)) (threaded-atomic-push reply-buffer (svref *reply-buffer-free-lists* index) reply-next reply-buffer))))) ;;; (defun read-error-input (display sequence reply-buffer token) (declare (type display display) (type reply-buffer reply-buffer) (type card16 sequence)) (tagbody start (with-event-queue-internal (display) (let ((command ;; Find any pending command with this sequence number. (threaded-dolist (pending-command (display-pending-commands display) pending-command-next pending-command) (when (= (pending-command-sequence pending-command) sequence) (return pending-command))))) (declare (type (or null pending-command) command)) (cond ((not (null command)) ;; Give this reply to the pending command (threaded-nconc reply-buffer (pending-command-reply-buffer command) reply-next reply-buffer) (process-wakeup (pending-command-process command))) ((member :immediately (display-report-asynchronous-errors display)) ;; No pending command and we should report the error immediately (go report-error)) (t ;; No pending command found, count this as an asynchronous error (threaded-nconc reply-buffer (display-asynchronous-errors display) reply-next reply-buffer))))) (return-from read-error-input nil) report-error (note-input-complete display token) (apply #'report-error display (prog1 (make-error display reply-buffer t) (deallocate-event reply-buffer))))) (defun read-reply-input (display sequence length reply-buffer) (declare (type display display) (type (or null reply-buffer) reply-buffer) (type card16 sequence) (type array-index length)) (unwind-protect (progn (when (index< +replysize+ length) (let ((repbuf nil)) (declare (type (or null reply-buffer) repbuf)) (unwind-protect (progn (setq repbuf (allocate-reply-buffer length)) (buffer-replace (reply-ibuf8 repbuf) (reply-ibuf8 reply-buffer) 0 +replysize+) (deallocate-event (shiftf reply-buffer repbuf nil))) (when repbuf (deallocate-reply-buffer repbuf)))) (when (buffer-input display (reply-ibuf8 reply-buffer) +replysize+ length) (return-from read-reply-input t)) (setf (reply-data-size reply-buffer) length)) (with-event-queue-internal (display) ;; Find any pending command with this sequence number. (let ((command (threaded-dolist (pending-command (display-pending-commands display) pending-command-next pending-command) (when (= (pending-command-sequence pending-command) sequence) (return pending-command))))) (declare (type (or null pending-command) command)) (when command ;; Give this reply to the pending command (threaded-nconc (shiftf reply-buffer nil) (pending-command-reply-buffer command) reply-next reply-buffer) (process-wakeup (pending-command-process command))))) nil) (when reply-buffer (deallocate-reply-buffer reply-buffer)))) (defun read-event-input (display code reply-buffer) (declare (type display display) (type card8 code) (type reply-buffer reply-buffer)) ;; Push the event in the input buffer on the display's event queue (setf (event-code reply-buffer) (get-internal-event-code display code)) (enqueue-event reply-buffer display) nil) (defun note-input-complete (display token) (declare (type display display)) (when (eq (display-input-in-progress display) token) ;; Indicate that input is no longer in progress (setf (display-input-in-progress display) nil) ;; Let the event process get the first chance to do input (let ((process (display-event-process display))) (when (not (null process)) (process-wakeup process))) ;; Then give processes waiting for command responses a chance (unless (display-input-in-progress display) (with-event-queue-internal (display) (threaded-dolist (command (display-pending-commands display) pending-command-next pending-command) (process-wakeup (pending-command-process command))))))) (defun read-input (display timeout force-output-p predicate &rest predicate-args) (declare (type display display) (type (or null number) timeout) (type generalized-boolean force-output-p) (dynamic-extent predicate-args)) (declare (type function predicate) #+clx-ansi-common-lisp (dynamic-extent predicate) #+(and lispm (not clx-ansi-common-lisp)) (sys:downward-funarg predicate)) (let ((reply-buffer nil) (token (or (current-process) (cons nil nil)))) (declare (type (or null reply-buffer) reply-buffer)) (unwind-protect (tagbody loop (when (display-dead display) (x-error 'closed-display :display display)) (when (apply predicate predicate-args) (return-from read-input nil)) ;; Check and see if we have to force output (when (and force-output-p (or (and (not (eq (display-input-in-progress display) token)) (not (conditional-store (display-input-in-progress display) nil token))) (null (buffer-listen display)))) (go force-output)) ;; Ensure that only one process is reading input. (unless (or (eq (display-input-in-progress display) token) (conditional-store (display-input-in-progress display) nil token)) (if (eql timeout 0) (return-from read-input :timeout) (apply #'process-block "CLX Input Lock" #'(lambda (display predicate &rest predicate-args) (declare (type display display) (dynamic-extent predicate-args) (type function predicate) #+clx-ansi-common-lisp (dynamic-extent predicate) #+(and lispm (not clx-ansi-common-lisp)) (sys:downward-funarg predicate)) (or (apply predicate predicate-args) (null (display-input-in-progress display)) (not (null (display-dead display))))) display predicate predicate-args)) (go loop)) ;; Now start gobbling. (setq reply-buffer (allocate-event)) (with-buffer-input (reply-buffer :sizes (8 16 32)) (let ((type 0)) (declare (type card8 type)) ;; Wait for input before we disallow aborts. (unless (eql timeout 0) (let ((eof-p (buffer-input-wait display timeout))) (when eof-p (return-from read-input eof-p)))) (without-aborts (let ((eof-p (buffer-input display buffer-bbuf 0 +replysize+ (if force-output-p 0 timeout)))) (when eof-p (when (eq eof-p :timeout) (if force-output-p (go force-output) (return-from read-input :timeout))) (setf (display-dead display) t) (return-from read-input eof-p))) (setf (reply-data-size reply-buffer) +replysize+) (when (= (the card8 (setq type (read-card8 0))) 1) ;; Normal replies can be longer than +replysize+, so we ;; have to handle them while aborts are still disallowed. (let ((value (read-reply-input display (read-card16 2) (index+ +replysize+ (index* (read-card32 4) 4)) (shiftf reply-buffer nil)))) (when value (return-from read-input value)) (go loop)))) (if (zerop type) (read-error-input display (read-card16 2) (shiftf reply-buffer nil) token) (read-event-input display (read-card8 0) (shiftf reply-buffer nil))))) (go loop) force-output (note-input-complete display token) (display-force-output display) (setq force-output-p nil) (go loop)) (when (not (null reply-buffer)) (deallocate-reply-buffer reply-buffer)) (note-input-complete display token)))) (defun report-asynchronous-errors (display mode) (when (and (display-asynchronous-errors display) (member mode (display-report-asynchronous-errors display))) (let ((aborted t)) (unwind-protect (loop (let ((error (with-event-queue-internal (display) (threaded-pop (display-asynchronous-errors display) reply-next reply-buffer)))) (declare (type (or null reply-buffer) error)) (if error (apply #'report-error display (prog1 (make-error display error t) (deallocate-event error))) (return (setq aborted nil))))) ;; If we get aborted out of this, deallocate all outstanding asynchronous ;; errors. (when aborted (with-event-queue-internal (display) (loop (let ((reply-buffer (threaded-pop (display-asynchronous-errors display) reply-next reply-buffer))) (declare (type (or null reply-buffer) reply-buffer)) (if reply-buffer (deallocate-event reply-buffer) (return nil)))))))))) (defun wait-for-event (display timeout force-output-p) (declare (type display display) (type (or null number) timeout) (type generalized-boolean force-output-p)) (let ((event-process-p (not (eql timeout 0)))) (declare (type generalized-boolean event-process-p)) (unwind-protect (loop (when event-process-p (conditional-store (display-event-process display) nil (current-process))) (let ((eof (read-input display timeout force-output-p #'(lambda (display) (declare (type display display)) (or (not (null (display-new-events display))) (and (display-asynchronous-errors display) (member :before-event-handling (display-report-asynchronous-errors display)) t))) display))) (when eof (return eof))) ;; Report asynchronous errors here if the user wants us to. (when event-process-p (report-asynchronous-errors display :before-event-handling)) (when (not (null (display-new-events display))) (return nil))) (when (and event-process-p (eq (display-event-process display) (current-process))) (setf (display-event-process display) nil))))) (defun read-reply (display pending-command) (declare (type display display) (type pending-command pending-command)) (loop (when (read-input display nil nil #'(lambda (pending-command) (declare (type pending-command pending-command)) (not (null (pending-command-reply-buffer pending-command)))) pending-command) (x-error 'closed-display :display display)) (let ((reply-buffer (with-event-queue-internal (display) (threaded-pop (pending-command-reply-buffer pending-command) reply-next reply-buffer)))) (declare (type reply-buffer reply-buffer)) ;; Check for error. (with-buffer-input (reply-buffer) (ecase (read-card8 0) (0 (apply #'report-error display (prog1 (make-error display reply-buffer nil) (deallocate-reply-buffer reply-buffer)))) (1 (return reply-buffer))))))) ;;; (defun event-listen (display &optional (timeout 0)) (declare (type display display) (type (or null number) timeout) (clx-values number-of-events-queued eof-or-timeout)) ;; Returns the number of events queued locally, if any, else nil. Hangs ;; waiting for events, forever if timeout is nil, else for the specified ;; number of seconds. (let* ((current-event-symbol (car (display-current-event-symbol display))) (current-event (and (boundp current-event-symbol) (symbol-value current-event-symbol))) (queue (if current-event (reply-next (the reply-buffer current-event)) (display-event-queue-head display)))) (declare (type symbol current-event-symbol) (type (or null reply-buffer) current-event queue)) (if queue (values (with-event-queue-internal (display :timeout timeout) (threaded-length queue reply-next reply-buffer)) nil) (with-event-queue (display :timeout timeout :inline t) (let ((eof-or-timeout (wait-for-event display timeout nil))) (if eof-or-timeout (values nil eof-or-timeout) (values (with-event-queue-internal (display :timeout timeout) (threaded-length (display-new-events display) reply-next reply-buffer)) nil))))))) (defun queue-event (display event-key &rest args &key append-p send-event-p &allow-other-keys) ;; The event is put at the head of the queue if append-p is nil, else the tail. ;; Additional arguments depend on event-key, and are as specified above with ;; declare-event, except that both resource-ids and resource objects are accepted ;; in the event components. (declare (type display display) (type event-key event-key) (type generalized-boolean append-p send-event-p) (dynamic-extent args)) (unless (get event-key 'event-code) (x-type-error event-key 'event-key)) (let* ((event (allocate-event)) (buffer (reply-ibuf8 event)) (event-code (get event-key 'event-code))) (declare (type reply-buffer event) (type buffer-bytes buffer) (type (or null card8) event-code)) (unless event-code (x-type-error event-key 'event-key)) (setf (event-code event) event-code) (with-display (display) (apply (svref *event-send-vector* event-code) display args) (buffer-replace buffer (display-obuf8 display) 0 +replysize+ (index+ 12 (buffer-boffset display))) (setf (aref buffer 0) (if send-event-p (logior event-code #x80) event-code) (aref buffer 2) 0 (aref buffer 3) 0)) (with-event-queue (display) (if append-p (enqueue-event event display) (with-event-queue-internal (display) (threaded-requeue event (display-event-queue-head display) (display-event-queue-tail display) reply-next reply-buffer)))))) (defun enqueue-event (new-event display) (declare (type reply-buffer new-event) (type display display)) ;; Place EVENT at the end of the event queue for DISPLAY (let* ((event-code (event-code new-event)) (event-key (and (index< event-code (length *event-key-vector*)) (svref *event-key-vector* event-code)))) (declare (type array-index event-code) (type (or null keyword) event-key)) (if (null event-key) (unwind-protect (cerror "Ignore this event" "No handler for ~s event" event-key) (deallocate-event new-event)) (with-event-queue-internal (display) (threaded-enqueue new-event (display-event-queue-head display) (display-event-queue-tail display) reply-next reply-buffer) (unless (display-new-events display) (setf (display-new-events display) new-event)))))) (defmacro define-event (name code) `(eval-when (:compile-toplevel :load-toplevel :execute) (setf (svref *event-key-vector* ,code) ',name) (setf (get ',name 'event-code) ,code))) ;; Event names. Used in "type" field in XEvent structures. Not to be ;; confused with event masks above. They start from 2 because 0 and 1 ;; are reserved in the protocol for errors and replies. */ (define-event :key-press 2) (define-event :key-release 3) (define-event :button-press 4) (define-event :button-release 5) (define-event :motion-notify 6) (define-event :enter-notify 7) (define-event :leave-notify 8) (define-event :focus-in 9) (define-event :focus-out 10) (define-event :keymap-notify 11) (define-event :exposure 12) (define-event :graphics-exposure 13) (define-event :no-exposure 14) (define-event :visibility-notify 15) (define-event :create-notify 16) (define-event :destroy-notify 17) (define-event :unmap-notify 18) (define-event :map-notify 19) (define-event :map-request 20) (define-event :reparent-notify 21) (define-event :configure-notify 22) (define-event :configure-request 23) (define-event :gravity-notify 24) (define-event :resize-request 25) (define-event :circulate-notify 26) (define-event :circulate-request 27) (define-event :property-notify 28) (define-event :selection-clear 29) (define-event :selection-request 30) (define-event :selection-notify 31) (define-event :colormap-notify 32) (define-event :client-message 33) (define-event :mapping-notify 34) (defmacro declare-event (event-codes &body declares &environment env) ;; Used to indicate the keyword arguments for handler functions in ;; process-event and event-case. ;; Generates the functions used in SEND-EVENT. ;; A compiler warning is printed when all of EVENT-CODES are not ;; defined by a preceding DEFINE-EXTENSION. ;; The body is a list of declarations, each of which has the form: ;; (type . items) Where type is a data-type, and items is a list of ;; symbol names. The item order corresponds to the order of fields ;; in the event sent by the server. An item may be a list of items. ;; In this case, each item is aliased to the same event field. ;; This is used to give all events an EVENT-WINDOW item. ;; See the INPUT file for lots of examples. (declare (type (or keyword list) event-codes) (type (alist (field-type symbol) (field-names list)) declares)) (when (atom event-codes) (setq event-codes (list event-codes))) (setq event-codes (mapcar #'canonicalize-event-name event-codes)) (let* ((keywords nil) (name (first event-codes)) (get-macro (xintern name '-event-get-macro)) (get-function (xintern name '-event-get)) (put-function (xintern name '-event-put))) (multiple-value-bind (get-code get-index get-sizes) (get-put-items 2 declares nil #'(lambda (type index item args) (flet ((event-get (type index item args) (unless (member type '(pad8 pad16)) `(,(kintern item) (,(getify type) ,index ,@args))))) (if (atom item) (event-get type index item args) (mapcan #'(lambda (item) (event-get type index item args)) item))))) (declare (ignore get-index)) (multiple-value-bind (put-code put-index put-sizes) (get-put-items 2 declares t #'(lambda (type index item args) (unless (member type '(pad8 pad16)) (if (atom item) (progn (push item keywords) `((,(putify type) ,index ,item ,@args))) (let ((names (mapcar #'(lambda (name) (kintern name)) item))) (setq keywords (append item keywords)) `((,(putify type) ,index (check-consistency ',names ,@item) ,@args))))))) (declare (ignore put-index)) `(within-definition (,name declare-event) (defun ,get-macro (display event-key variable) ;; Note: we take pains to macroexpand the get-code here to enable application ;; code to be compiled without having the CLX macros file loaded. `(let ((%buffer ,display)) (declare (ignorable %buffer)) ,(getf `(:display (the display ,display) :event-key (the keyword ,event-key) :event-code (the card8 (logand #x7f (read-card8 0))) :send-event-p (logbitp 7 (read-card8 0)) ,@',(mapcar #'(lambda (form) (clx-macroexpand form env)) get-code)) variable))) (defun ,get-function (display event handler) (declare (type display display) (type reply-buffer event)) (declare (type function handler) #+clx-ansi-common-lisp (dynamic-extent handler) #+(and lispm (not clx-ansi-common-lisp)) (sys:downward-funarg handler)) (reading-event (event :display display :sizes (8 16 ,@get-sizes)) (funcall handler :display display :event-key (svref *event-key-vector* (event-code event)) :event-code (logand #x7f (card8-get 0)) :send-event-p (logbitp 7 (card8-get 0)) ,@get-code))) (defun ,put-function (display &key ,@(setq keywords (nreverse keywords)) &allow-other-keys) (declare (type display display)) ,(when (member 'sequence keywords) `(unless sequence (setq sequence (display-request-number display)))) (with-buffer-output (display :sizes ,put-sizes :index (index+ (buffer-boffset display) 12)) ,@put-code)) ,@(mapcar #'(lambda (name) (allocate-extension-event-code name) `(let ((event-code (or (get ',name 'event-code) (allocate-extension-event-code ',name)))) (setf (svref *event-macro-vector* event-code) (function ,get-macro)) (setf (svref *event-handler-vector* event-code) (function ,get-function)) (setf (svref *event-send-vector* event-code) (function ,put-function)))) event-codes) ',name))))) (defun check-consistency (names &rest args) ;; Ensure all args are nil or have the same value. ;; Returns the consistent non-nil value. (let ((value (car args))) (dolist (arg (cdr args)) (if value (when (and arg (not (eq arg value))) (x-error 'inconsistent-parameters :parameters (mapcan #'list names args))) (setq value arg))) value)) (declare-event (:key-press :key-release :button-press :button-release) ;; for key-press and key-release, code is the keycode ;; for button-press and button-release, code is the button number (data code) (card16 sequence) ((or null card32) time) (window root (window event-window)) ((or null window) child) (int16 root-x root-y x y) (card16 state) (boolean same-screen-p) ) (declare-event :motion-notify ((data boolean) hint-p) (card16 sequence) ((or null card32) time) (window root (window event-window)) ((or null window) child) (int16 root-x root-y x y) (card16 state) (boolean same-screen-p)) (declare-event (:enter-notify :leave-notify) ((data (member8 :ancestor :virtual :inferior :nonlinear :nonlinear-virtual)) kind) (card16 sequence) ((or null card32) time) (window root (window event-window)) ((or null window) child) (int16 root-x root-y x y) (card16 state) ((member8 :normal :grab :ungrab) mode) ((bit 0) focus-p) ((bit 1) same-screen-p)) (declare-event (:focus-in :focus-out) ((data (member8 :ancestor :virtual :inferior :nonlinear :nonlinear-virtual :pointer :pointer-root :none)) kind) (card16 sequence) (window (window event-window)) ((member8 :normal :while-grabbed :grab :ungrab) mode)) (declare-event :keymap-notify ((bit-vector256 0) keymap)) (declare-event :exposure (card16 sequence) (window (window event-window)) (card16 x y width height count)) (declare-event :graphics-exposure (card16 sequence) (drawable (drawable event-window)) (card16 x y width height) (card16 minor) ;; Minor opcode (card16 count) (card8 major)) (declare-event :no-exposure (card16 sequence) (drawable (drawable event-window)) (card16 minor) (card8 major)) (declare-event :visibility-notify (card16 sequence) (window (window event-window)) ((member8 :unobscured :partially-obscured :fully-obscured) state)) (declare-event :create-notify (card16 sequence) (window (parent event-window) window) (int16 x y) (card16 width height border-width) (boolean override-redirect-p)) (declare-event :destroy-notify (card16 sequence) (window event-window window)) (declare-event :unmap-notify (card16 sequence) (window event-window window) (boolean configure-p)) (declare-event :map-notify (card16 sequence) (window event-window window) (boolean override-redirect-p)) (declare-event :map-request (card16 sequence) (window (parent event-window) window)) (declare-event :reparent-notify (card16 sequence) (window event-window window parent) (int16 x y) (boolean override-redirect-p)) (declare-event :configure-notify (card16 sequence) (window event-window window) ((or null window) above-sibling) (int16 x y) (card16 width height border-width) (boolean override-redirect-p)) (declare-event :configure-request ((data (member8 :above :below :top-if :bottom-if :opposite)) stack-mode) (card16 sequence) (window (parent event-window) window) ((or null window) above-sibling) (int16 x y) (card16 width height border-width value-mask)) (declare-event :gravity-notify (card16 sequence) (window event-window window) (int16 x y)) (declare-event :resize-request (card16 sequence) (window (window event-window)) (card16 width height)) (declare-event :circulate-notify (card16 sequence) (window event-window window parent) ((member8 :top :bottom) place)) (declare-event :circulate-request (card16 sequence) (window (parent event-window) window) (pad16 1 2) ((member8 :top :bottom) place)) (declare-event :property-notify (card16 sequence) (window (window event-window)) (keyword atom) ;; keyword ((or null card32) time) ((member8 :new-value :deleted) state)) (declare-event :selection-clear (card16 sequence) ((or null card32) time) (window (window event-window)) (keyword selection) ;; keyword ) (declare-event :selection-request (card16 sequence) ((or null card32) time) (window (window event-window) requestor) (keyword selection target) ((or null keyword) property) ) (declare-event :selection-notify (card16 sequence) ((or null card32) time) (window (window event-window)) (keyword selection target) ((or null keyword) property) ) (declare-event :colormap-notify (card16 sequence) (window (window event-window)) ((or null colormap) colormap) (boolean new-p installed-p)) (declare-event :client-message (data format) (card16 sequence) (window (window event-window)) (keyword type) ((client-message-sequence format) data)) (declare-event :mapping-notify (card16 sequence) ((member8 :modifier :keyboard :pointer) request) (card8 start) ;; first key-code (card8 count)) ;; ;; EVENT-LOOP ;; (defun event-loop-setup (display) (declare (type display display) (clx-values progv-vars progv-vals current-event-symbol current-event-discarded-p-symbol)) (let* ((progv-vars (display-current-event-symbol display)) (current-event-symbol (first progv-vars)) (current-event-discarded-p-symbol (second progv-vars))) (declare (type list progv-vars) (type symbol current-event-symbol current-event-discarded-p-symbol)) (values progv-vars (list (if (boundp current-event-symbol) ;; The current event is already bound, so bind it to the next ;; event. (let ((event (symbol-value current-event-symbol))) (declare (type (or null reply-buffer) event)) (and event (reply-next (the reply-buffer event)))) ;; The current event isn't bound, so bind it to the head of the ;; event queue. (display-event-queue-head display)) nil) current-event-symbol current-event-discarded-p-symbol))) (defun event-loop-step-before (display timeout force-output-p current-event-symbol) (declare (type display display) (type (or null number) timeout) (type generalized-boolean force-output-p) (type symbol current-event-symbol) (clx-values event eof-or-timeout)) (unless (symbol-value current-event-symbol) (let ((eof-or-timeout (wait-for-event display timeout force-output-p))) (when eof-or-timeout (return-from event-loop-step-before (values nil eof-or-timeout)))) (setf (symbol-value current-event-symbol) (display-new-events display))) (let ((event (symbol-value current-event-symbol))) (declare (type reply-buffer event)) (with-event-queue-internal (display) (when (eq event (display-new-events display)) (setf (display-new-events display) (reply-next event)))) (values event nil))) (defun dequeue-event (display event) (declare (type display display) (type reply-buffer event) (clx-values next)) ;; Remove the current event from the event queue (with-event-queue-internal (display) (let ((next (reply-next event)) (head (display-event-queue-head display))) (declare (type (or null reply-buffer) next head)) (when (eq event (display-new-events display)) (setf (display-new-events display) next)) (cond ((eq event head) (threaded-dequeue (display-event-queue-head display) (display-event-queue-tail display) reply-next reply-buffer)) ((null head) (setq next nil)) (t (do* ((previous head current) (current (reply-next previous) (reply-next previous))) ((or (null current) (eq event current)) (when (eq event current) (when (eq current (display-event-queue-tail display)) (setf (display-event-queue-tail display) previous)) (setf (reply-next previous) next))) (declare (type reply-buffer previous) (type (or null reply-buffer) current))))) next))) (defun event-loop-step-after (display event discard-p current-event-symbol current-event-discarded-p-symbol &optional aborted) (declare (type display display) (type reply-buffer event) (type generalized-boolean discard-p aborted) (type symbol current-event-symbol current-event-discarded-p-symbol)) (when (and discard-p (not aborted) (not (symbol-value current-event-discarded-p-symbol))) (discard-current-event display)) (let ((next (reply-next event))) (declare (type (or null reply-buffer) next)) (when (symbol-value current-event-discarded-p-symbol) (setf (symbol-value current-event-discarded-p-symbol) nil) (setq next (dequeue-event display event)) (deallocate-event event)) (setf (symbol-value current-event-symbol) next))) (defmacro event-loop ((display event timeout force-output-p discard-p) &body body) ;; Bind EVENT to the events for DISPLAY. ;; This is the "GUTS" of process-event and event-case. `(let ((.display. ,display) (.timeout. ,timeout) (.force-output-p. ,force-output-p) (.discard-p. ,discard-p)) (declare (type display .display.) (type (or null number) .timeout.) (type generalized-boolean .force-output-p. .discard-p.)) (with-event-queue (.display. ,@(and timeout `(:timeout .timeout.))) (multiple-value-bind (.progv-vars. .progv-vals. .current-event-symbol. .current-event-discarded-p-symbol.) (event-loop-setup .display.) (declare (type list .progv-vars. .progv-vals.) (type symbol .current-event-symbol. .current-event-discarded-p-symbol.)) (progv .progv-vars. .progv-vals. (loop (multiple-value-bind (.event. .eof-or-timeout.) (event-loop-step-before .display. .timeout. .force-output-p. .current-event-symbol.) (declare (type (or null reply-buffer) .event.)) (when (null .event.) (return (values nil .eof-or-timeout.))) (let ((.aborted. t)) (unwind-protect (progn (let ((,event .event.)) (declare (type reply-buffer ,event)) ,@body) (setq .aborted. nil)) (event-loop-step-after .display. .event. .discard-p. .current-event-symbol. .current-event-discarded-p-symbol. .aborted.)))))))))) (defun discard-current-event (display) ;; Discard the current event for DISPLAY. ;; Returns NIL when the event queue is empty, else T. ;; To ensure events aren't ignored, application code should only call ;; this when throwing out of event-case or process-next-event, or from ;; inside even-case, event-cond or process-event when :peek-p is T and ;; :discard-p is NIL. (declare (type display display) (clx-values generalized-boolean)) (let* ((symbols (display-current-event-symbol display)) (event (let ((current-event-symbol (first symbols))) (declare (type symbol current-event-symbol)) (when (boundp current-event-symbol) (symbol-value current-event-symbol))))) (declare (type list symbols) (type (or null reply-buffer) event)) (unless (null event) ;; Set the discarded-p flag (let ((current-event-discarded-p-symbol (second symbols))) (declare (type symbol current-event-discarded-p-symbol)) (when (boundp current-event-discarded-p-symbol) (setf (symbol-value current-event-discarded-p-symbol) t))) ;; Return whether the event queue is empty (not (null (reply-next (the reply-buffer event))))))) ;; ;; PROCESS-EVENT ;; (defun process-event (display &key handler timeout peek-p discard-p (force-output-p t)) ;; If force-output-p is true, first invokes display-force-output. Invokes handler ;; on each queued event until handler returns non-nil, and that returned object is ;; then returned by process-event. If peek-p is true, then the event is not ;; removed from the queue. If discard-p is true, then events for which handler ;; returns nil are removed from the queue, otherwise they are left in place. Hangs ;; until non-nil is generated for some event, or for the specified timeout (in ;; seconds, if given); however, it is acceptable for an implementation to wait only ;; once on network data, and therefore timeout prematurely. Returns nil on ;; timeout. If handler is a sequence, it is expected to contain handler functions ;; specific to each event class; the event code is used to index the sequence, ;; fetching the appropriate handler. Handler is called with raw resource-ids, not ;; with resource objects. The arguments to the handler are described using declare-event. ;; ;; T for peek-p means the event (for which the handler returns non-nil) is not removed ;; from the queue (it is left in place), NIL means the event is removed. (declare (type display display) (type (or null number) timeout) (type generalized-boolean peek-p discard-p force-output-p)) (declare (type t handler) #+clx-ansi-common-lisp (dynamic-extent handler) #+(and lispm (not clx-ansi-common-lisp)) (sys:downward-funarg #+Genera * #-Genera handler)) (event-loop (display event timeout force-output-p discard-p) (let* ((event-code (event-code event)) ;; Event decoder defined by DECLARE-EVENT (event-decoder (and (index< event-code (length *event-handler-vector*)) (svref *event-handler-vector* event-code)))) (declare (type array-index event-code) (type (or null function) event-decoder)) (if event-decoder (let ((event-handler (if (functionp handler) handler (and (type? handler 'sequence) (< event-code (length handler)) (elt handler event-code))))) (if event-handler (let ((result (funcall event-decoder display event event-handler))) (when result (unless peek-p (discard-current-event display)) (return result))) (cerror "Ignore this event" "No handler for ~s event" (svref *event-key-vector* event-code)))) (cerror "Ignore this event" "Server Error: event with unknown event code ~d received." event-code))))) (defun make-event-handlers (&key (type 'array) default) (declare (type t type) ;Sequence type specifier (type (or null function) default) (clx-values sequence)) ;Default handler for initial content ;; Makes a handler sequence suitable for process-event (make-sequence type +max-events+ :initial-element default)) (defun event-handler (handlers event-key) (declare (type sequence handlers) (type event-key event-key) (clx-values function)) ;; Accessor for a handler sequence (elt handlers (position event-key *event-key-vector* :test #'eq))) (defun set-event-handler (handlers event-key handler) (declare (type sequence handlers) (type event-key event-key) (type function handler) (clx-values handler)) (setf (elt handlers (position event-key *event-key-vector* :test #'eq)) handler)) (defsetf event-handler set-event-handler) ;; ;; EVENT-CASE ;; (defmacro event-case ((&rest args) &body clauses) ;; If force-output-p is true, first invokes display-force-output. Executes the ;; matching clause for each queued event until a clause returns non-nil, and that ;; returned object is then returned by event-case. If peek-p is true, then the ;; event is not removed from the queue. If discard-p is true, then events for ;; which the clause returns nil are removed from the queue, otherwise they are left ;; in place. Hangs until non-nil is generated for some event, or for the specified ;; timeout (in seconds, if given); however, it is acceptable for an implementation ;; to wait only once on network data, and therefore timeout prematurely. Returns ;; nil on timeout. In each clause, event-or-events is an event-key or a list of ;; event-keys (but they need not be typed as keywords) or the symbol t or otherwise ;; (but only in the last clause). The keys are not evaluated, and it is an error ;; for the same key to appear in more than one clause. Args is the list of event ;; components of interest; corresponding values (if any) are bound to variables ;; with these names (i.e., the args are variable names, not keywords, the keywords ;; are derived from the variable names). An arg can also be a (keyword var) form, ;; as for keyword args in a lambda lists. If no t/otherwise clause appears, it is ;; equivalent to having one that returns nil. (declare (arglist (display &key timeout peek-p discard-p (force-output-p t)) (event-or-events ((&rest args) |...|) &body body) |...|)) ;; Event-case is just event-cond with the whole body in the test-form `(event-cond ,args ,@(mapcar #'(lambda (clause) `(,(car clause) ,(cadr clause) (progn ,@(cddr clause)))) clauses))) ;; ;; EVENT-COND ;; (defmacro event-cond ((display &key timeout peek-p discard-p (force-output-p t)) &body clauses) ;; The clauses of event-cond are of the form: ;; (event-or-events binding-list test-form . body-forms) ;; ;; EVENT-OR-EVENTS event-key or a list of event-keys (but they ;; need not be typed as keywords) or the symbol t ;; or otherwise (but only in the last clause). If ;; no t/otherwise clause appears, it is equivalent ;; to having one that returns nil. The keys are ;; not evaluated, and it is an error for the same ;; key to appear in more than one clause. ;; ;; BINDING-LIST The list of event components of interest. ;; corresponding values (if any) are bound to ;; variables with these names (i.e., the binding-list ;; has variable names, not keywords, the keywords are ;; derived from the variable names). An arg can also ;; be a (keyword var) form, as for keyword args in a ;; lambda list. ;; ;; The matching TEST-FORM for each queued event is executed until a ;; clause's test-form returns non-nil. Then the BODY-FORMS are ;; evaluated, returning the (possibly multiple) values of the last ;; form from event-cond. If there are no body-forms then, if the ;; test-form is non-nil, the value of the test-form is returned as a ;; single value. ;; ;; Options: ;; FORCE-OUTPUT-P When true, first invoke display-force-output if no ;; input is pending. ;; ;; PEEK-P When true, then the event is not removed from the queue. ;; ;; DISCARD-P When true, then events for which the clause returns nil ;; are removed from the queue, otherwise they are left in place. ;; ;; TIMEOUT If NIL, hang until non-nil is generated for some event's ;; test-form. Otherwise return NIL after TIMEOUT seconds have ;; elapsed. ;; (declare (arglist (display &key timeout peek-p discard-p force-output-p) (event-or-events (&rest args) test-form &body body) |...|)) (let ((event (gensym)) (disp (gensym)) (peek (gensym))) `(let ((,disp ,display) (,peek ,peek-p)) (declare (type display ,disp)) (event-loop (,disp ,event ,timeout ,force-output-p ,discard-p) (event-dispatch (,disp ,event ,peek) ,@clauses))))) (defun get-event-code (event) ;; Returns the event code given an event-key (declare (type event-key event)) (declare (clx-values card8)) (or (get event 'event-code) (x-type-error event 'event-key))) (defun universal-event-get-macro (display event-key variable) (getf `(:display (the display ,display) :event-key (the keyword ,event-key) :event-code (the card8 (logand 127 (read-card8 0))) :send-event-p (logbitp 7 (read-card8 0))) variable)) (defmacro event-dispatch ((display event peek-p) &body clauses) ;; Helper macro for event-case ;; CLAUSES are of the form: ;; (event-or-events binding-list test-form . body-forms) (let ((event-key (gensym)) (all-events (make-array +max-events+ :element-type 'bit :initial-element 0))) `(reading-event (,event) (let ((,event-key (svref *event-key-vector* (event-code ,event)))) (case ,event-key ,@(mapcar #'(lambda (clause) ; Translate event-cond clause to case clause (let* ((events (first clause)) (arglist (second clause)) (test-form (third clause)) (body-forms (cdddr clause))) (flet ((event-clause (display peek-p first-form rest-of-forms) (if rest-of-forms `(when ,first-form (unless ,peek-p (discard-current-event ,display)) (return (progn ,@rest-of-forms))) ;; No body forms, return the result of the test form (let ((result (gensym))) `(let ((,result ,first-form)) (when ,result (unless ,peek-p (discard-current-event ,display)) (return ,result))))))) (if (member events '(otherwise t)) ;; code for OTHERWISE clause. ;; Find all events NOT used by other clauses (let ((keys (do ((i 0 (1+ i)) (key nil) (result nil)) ((>= i +max-events+) result) (setq key (svref *event-key-vector* i)) (when (and key (zerop (aref all-events i))) (push key result))))) `(otherwise (binding-event-values (,display ,event-key ,(or keys :universal) ,@arglist) ,(event-clause display peek-p test-form body-forms)))) ;; Code for normal clauses (let (true-events) ;; canonicalize event-names (if (consp events) (progn (setq true-events (mapcar #'canonicalize-event-name events)) (dolist (event true-events) (setf (aref all-events (get-event-code event)) 1))) (setf true-events (canonicalize-event-name events) (aref all-events (get-event-code true-events)) 1)) `(,true-events (binding-event-values (,display ,event-key ,true-events ,@arglist) ,(event-clause display peek-p test-form body-forms)))))))) clauses)))))) (defmacro binding-event-values ((display event-key event-keys &rest value-list) &body body) ;; Execute BODY with the variables in VALUE-LIST bound to components of the ;; EVENT-KEYS events. (unless (consp event-keys) (setq event-keys (list event-keys))) (flet ((var-key (var) (kintern (if (consp var) (first var) var))) (var-symbol (var) (if (consp var) (second var) var))) ;; VARS is an alist of: ;; (component-key ((event-key event-key ...) . extraction-code) ;; ((event-key event-key ...) . extraction-code) ...) ;; There should probably be accessor macros for this, instead of things like cdadr. (let ((vars (mapcar #'list value-list)) (multiple-p nil)) ;; Fill in the VARS alist with event-keys and extraction-code (do ((keys event-keys (cdr keys)) (temp nil)) ((endp keys)) (let* ((key (car keys)) (binder (case key (:universal #'universal-event-get-macro) (otherwise (svref *event-macro-vector* (get-event-code key)))))) (dolist (var vars) (let ((code (funcall binder display event-key (var-key (car var))))) (unless code (warn "~a isn't a component of the ~s event" (var-key (car var)) key)) (if (setq temp (member code (cdr var) :key #'cdr :test #'equal)) (push key (caar temp)) (push `((,key) . ,code) (cdr var))))))) ;; Bind all the values `(let ,(mapcar #'(lambda (var) (if (cddr var) ;; if more than one binding form (progn (setq multiple-p t) (var-symbol (car var))) (list (var-symbol (car var)) (cdadr var)))) vars) ;; When some values come from different places, generate code to set them ,(when multiple-p `(case ,event-key ,@(do ((keys event-keys (cdr keys)) (clauses nil) ;; alist of (event-keys bindings) (clause nil nil) (temp)) ((endp keys) (dolist (clause clauses) (unless (cdar clause) ;; Atomize single element lists (setf (car clause) (caar clause)))) clauses) ;; Gather up all the bindings associated with (car keys) (dolist (var vars) (when (cddr var) ;; when more than one binding form (dolist (events (cdr var)) (when (member (car keys) (car events)) ;; Optimize for event-window being the same as some other binding (if (setq temp (member (cdr events) clause :key #'caddr :test #'equal)) (setq clause (nconc clause `((setq ,(car var) ,(second (car temp)))))) (push `(setq ,(car var) ,(cdr events)) clause)))))) ;; Merge bindings for (car keys) with other bindings (when clause (if (setq temp (member clause clauses :key #'cdr :test #'equal)) (push (car keys) (caar temp)) (push `((,(car keys)) . ,clause) clauses)))))) ,@body)))) ;;;----------------------------------------------------------------------------- ;;; Error Handling ;;;----------------------------------------------------------------------------- (eval-when (:compile-toplevel :load-toplevel :execute) (defparameter *xerror-vector* '#(unknown-error request-error ; 1 bad request code value-error ; 2 integer parameter out of range window-error ; 3 parameter not a Window pixmap-error ; 4 parameter not a Pixmap atom-error ; 5 parameter not an Atom cursor-error ; 6 parameter not a Cursor font-error ; 7 parameter not a Font match-error ; 8 parameter mismatch drawable-error ; 9 parameter not a Pixmap or Window access-error ; 10 attempt to access private resource" alloc-error ; 11 insufficient resources colormap-error ; 12 no such colormap gcontext-error ; 13 parameter not a GContext id-choice-error ; 14 invalid resource ID for this connection name-error ; 15 font or color name does not exist length-error ; 16 request length incorrect; ; internal Xlib error implementation-error ; 17 server is defective )) ) (defun make-error (display event asynchronous) (declare (type display display) (type reply-buffer event) (type generalized-boolean asynchronous)) (reading-event (event) (let* ((error-code (read-card8 1)) (error-key (get-error-key display error-code)) (error-decode-function (get error-key 'error-decode-function)) (params (funcall error-decode-function display event))) (list* error-code error-key :asynchronous asynchronous :current-sequence (display-request-number display) params)))) (defun report-error (display error-code error-key &rest params) (declare (type display display) (dynamic-extent params)) ;; All errors (synchronous and asynchronous) are processed by calling ;; an error handler in the display. The handler is called with the display ;; as the first argument and the error-key as its second argument. If handler is ;; an array it is expected to contain handler functions specific to ;; each error; the error code is used to index the array, fetching the ;; appropriate handler. Any results returned by the handler are ignored;; ;; it is assumed the handler either takes care of the error completely, ;; or else signals. For all core errors, additional keyword/value argument ;; pairs are: ;; :major integer ;; :minor integer ;; :sequence integer ;; :current-sequence integer ;; :asynchronous (member t nil) ;; For :colormap, :cursor, :drawable, :font, :GContext, :id-choice, :pixmap, and :window ;; errors another pair is: ;; :resource-id integer ;; For :atom errors, another pair is: ;; :atom-id integer ;; For :value errors, another pair is: ;; :value integer (let* ((handler (display-error-handler display)) (handler-function (if (type? handler 'sequence) (elt handler error-code) handler))) (apply handler-function display error-key params))) (defun request-name (code &optional display) (if (< code (length *request-names*)) (svref *request-names* code) (dolist (extension (and display (display-extension-alist display)) "unknown") (when (= code (second extension)) (return (first extension)))))) #-(or clx-ansi-common-lisp excl lcl3.0 CMU) (define-condition request-error (x-error) ((display :reader request-error-display) (error-key :reader request-error-error-key) (major :reader request-error-major) (minor :reader request-error-minor) (sequence :reader request-error-sequence) (current-sequence :reader request-error-current-sequence) (asynchronous :reader request-error-asynchronous)) (:report report-request-error)) (defun report-request-error (condition stream) (let ((error-key (request-error-error-key condition)) (asynchronous (request-error-asynchronous condition)) (major (request-error-major condition)) (minor (request-error-minor condition)) (sequence (request-error-sequence condition)) (current-sequence (request-error-current-sequence condition))) (format stream "~:[~;Asynchronous ~]~a in ~:[request ~d (last request was ~d) ~;current request~2* ~] Code ~d.~d [~a]" asynchronous error-key (= sequence current-sequence) sequence current-sequence major minor (request-name major (request-error-display condition))))) ;; Since the :report arg is evaluated as (function report-request-error) the ;; define-condition must come after the function definition. #+(or clx-ansi-common-lisp excl lcl3.0 CMU) (define-condition request-error (x-error) ((display :reader request-error-display :initarg :display) (error-key :reader request-error-error-key :initarg :error-key) (major :reader request-error-major :initarg :major) (minor :reader request-error-minor :initarg :minor) (sequence :reader request-error-sequence :initarg :sequence) (current-sequence :reader request-error-current-sequence :initarg :current-sequence) (asynchronous :reader request-error-asynchronous :initarg :asynchronous)) (:report report-request-error)) (define-condition resource-error (request-error) ((resource-id :reader resource-error-resource-id :initarg :resource-id)) (:report (lambda (condition stream) (report-request-error condition stream) (format stream " ID #x~x" (resource-error-resource-id condition))))) (define-condition unknown-error (request-error) ((error-code :reader unknown-error-error-code :initarg :error-code)) (:report (lambda (condition stream) (report-request-error condition stream) (format stream " Error Code ~d." (unknown-error-error-code condition))))) (define-condition access-error (request-error) ()) (define-condition alloc-error (request-error) ()) (define-condition atom-error (request-error) ((atom-id :reader atom-error-atom-id :initarg :atom-id)) (:report (lambda (condition stream) (report-request-error condition stream) (format stream " Atom-ID #x~x" (atom-error-atom-id condition))))) (define-condition colormap-error (resource-error) ()) (define-condition cursor-error (resource-error) ()) (define-condition drawable-error (resource-error) ()) (define-condition font-error (resource-error) ()) (define-condition gcontext-error (resource-error) ()) (define-condition id-choice-error (resource-error) ()) (define-condition illegal-request-error (request-error) ()) (define-condition length-error (request-error) ()) (define-condition match-error (request-error) ()) (define-condition name-error (request-error) ()) (define-condition pixmap-error (resource-error) ()) (define-condition value-error (request-error) ((value :reader value-error-value :initarg :value)) (:report (lambda (condition stream) (report-request-error condition stream) (format stream " Value ~d." (value-error-value condition))))) (define-condition window-error (resource-error)()) (define-condition implementation-error (request-error) ()) ;;----------------------------------------------------------------------------- ;; Internal error conditions signaled by CLX (define-condition x-type-error (type-error x-error) ((type-string :reader x-type-error-type-string :initarg :type-string)) (:report (lambda (condition stream) (format stream "~s isn't a ~a" (type-error-datum condition) (or (x-type-error-type-string condition) (type-error-expected-type condition)))))) (define-condition closed-display (x-error) ((display :reader closed-display-display :initarg :display)) (:report (lambda (condition stream) (format stream "Attempt to use closed display ~s" (closed-display-display condition))))) (define-condition lookup-error (x-error) ((id :reader lookup-error-id :initarg :id) (display :reader lookup-error-display :initarg :display) (type :reader lookup-error-type :initarg :type) (object :reader lookup-error-object :initarg :object)) (:report (lambda (condition stream) (format stream "ID ~d from display ~s should have been a ~s, but was ~s" (lookup-error-id condition) (lookup-error-display condition) (lookup-error-type condition) (lookup-error-object condition))))) (define-condition connection-failure (x-error) ((major-version :reader connection-failure-major-version :initarg :major-version) (minor-version :reader connection-failure-minor-version :initarg :minor-version) (host :reader connection-failure-host :initarg :host) (display :reader connection-failure-display :initarg :display) (reason :reader connection-failure-reason :initarg :reason)) (:report (lambda (condition stream) (format stream "Connection failure to X~d.~d server ~a display ~d: ~a" (connection-failure-major-version condition) (connection-failure-minor-version condition) (connection-failure-host condition) (connection-failure-display condition) (connection-failure-reason condition))))) (define-condition reply-length-error (x-error) ((reply-length :reader reply-length-error-reply-length :initarg :reply-length) (expected-length :reader reply-length-error-expected-length :initarg :expected-length) (display :reader reply-length-error-display :initarg :display)) (:report (lambda (condition stream) (format stream "Reply length was ~d when ~d words were expected for display ~s" (reply-length-error-reply-length condition) (reply-length-error-expected-length condition) (reply-length-error-display condition))))) (define-condition reply-timeout (x-error) ((timeout :reader reply-timeout-timeout :initarg :timeout) (display :reader reply-timeout-display :initarg :display)) (:report (lambda (condition stream) (format stream "Timeout after waiting ~d seconds for a reply for display ~s" (reply-timeout-timeout condition) (reply-timeout-display condition))))) (define-condition sequence-error (x-error) ((display :reader sequence-error-display :initarg :display) (req-sequence :reader sequence-error-req-sequence :initarg :req-sequence) (msg-sequence :reader sequence-error-msg-sequence :initarg :msg-sequence)) (:report (lambda (condition stream) (format stream "Reply out of sequence for display ~s.~% Expected ~d, Got ~d" (sequence-error-display condition) (sequence-error-req-sequence condition) (sequence-error-msg-sequence condition))))) (define-condition unexpected-reply (x-error) ((display :reader unexpected-reply-display :initarg :display) (msg-sequence :reader unexpected-reply-msg-sequence :initarg :msg-sequence) (req-sequence :reader unexpected-reply-req-sequence :initarg :req-sequence) (length :reader unexpected-reply-length :initarg :length)) (:report (lambda (condition stream) (format stream "Display ~s received a server reply when none was expected.~@ Last request sequence ~d Reply Sequence ~d Reply Length ~d bytes." (unexpected-reply-display condition) (unexpected-reply-req-sequence condition) (unexpected-reply-msg-sequence condition) (unexpected-reply-length condition))))) (define-condition missing-parameter (x-error) ((parameter :reader missing-parameter-parameter :initarg :parameter)) (:report (lambda (condition stream) (let ((parm (missing-parameter-parameter condition))) (if (consp parm) (format stream "One or more of the required parameters ~a is missing." parm) (format stream "Required parameter ~a is missing or null." parm)))))) ;; This can be signalled anywhere a pseudo font access fails. (define-condition invalid-font (x-error) ((font :reader invalid-font-font :initarg :font)) (:report (lambda (condition stream) (format stream "Can't access font ~s" (invalid-font-font condition))))) (define-condition device-busy (x-error) ((display :reader device-busy-display :initarg :display)) (:report (lambda (condition stream) (format stream "Device busy for display ~s" (device-busy-display condition))))) (define-condition unimplemented-event (x-error) ((display :reader unimplemented-event-display :initarg :display) (event-code :reader unimplemented-event-event-code :initarg :event-code)) (:report (lambda (condition stream) (format stream "Event code ~d not implemented for display ~s" (unimplemented-event-event-code condition) (unimplemented-event-display condition))))) (define-condition undefined-event (x-error) ((display :reader undefined-event-display :initarg :display) (event-name :reader undefined-event-event-name :initarg :event-name)) (:report (lambda (condition stream) (format stream "Event code ~d undefined for display ~s" (undefined-event-event-name condition) (undefined-event-display condition))))) (define-condition absent-extension (x-error) ((name :reader absent-extension-name :initarg :name) (display :reader absent-extension-display :initarg :display)) (:report (lambda (condition stream) (format stream "Extension ~a isn't defined for display ~s" (absent-extension-name condition) (absent-extension-display condition))))) (define-condition inconsistent-parameters (x-error) ((parameters :reader inconsistent-parameters-parameters :initarg :parameters)) (:report (lambda (condition stream) (format stream "inconsistent-parameters:~{ ~s~}" (inconsistent-parameters-parameters condition))))) (define-condition resource-ids-exhausted (x-error) () (:report (lambda (condition stream) (declare (ignore condition)) (format stream "All X resource IDs are in use.")))) (defun get-error-key (display error-code) (declare (type display display) (type array-index error-code)) ;; Return the error-key associated with error-code (if (< error-code (length *xerror-vector*)) (svref *xerror-vector* error-code) ;; Search the extensions for the error (dolist (entry (display-extension-alist display) 'unknown-error) (let* ((event-name (first entry)) (first-error (fourth entry)) (errors (third (assoc event-name *extensions*)))) (declare (type keyword event-name) (type array-index first-error) (type list errors)) (when (and errors (index<= first-error error-code (index+ first-error (index- (length errors) 1)))) (return (nth (index- error-code first-error) errors))))))) (defmacro define-error (error-key function) ;; Associate a function with ERROR-KEY which will be called with ;; parameters DISPLAY and REPLY-BUFFER and ;; returns a plist of keyword/value pairs which will be passed on ;; to the error handler. A compiler warning is printed when ;; ERROR-KEY is not defined in a preceding DEFINE-EXTENSION. ;; Note: REPLY-BUFFER may used with the READING-EVENT and READ-type ;; macros for getting error fields. See DECODE-CORE-ERROR for ;; an example. (declare (type symbol error-key) (type (or symbol list) function)) ;; First ensure the name is for a declared extension (unless (or (find error-key *xerror-vector*) (dolist (extension *extensions*) (when (member error-key (third extension)) (return t)))) (x-type-error error-key 'error-key)) `(setf (get ',error-key 'error-decode-function) (function ,function))) ;; All core errors use this, so we make it available to extensions. (defun decode-core-error (display event &optional arg) ;; All core errors have the following keyword/argument pairs: ;; :major integer ;; :minor integer ;; :sequence integer ;; In addition, many have an additional argument that comes from the ;; same place in the event, but is named differently. When the ARG ;; argument is specified, the keyword ARG with card32 value starting ;; at byte 4 of the event is returned with the other keyword/argument ;; pairs. (declare (type display display) (type reply-buffer event) (type (or null keyword) arg)) (declare (clx-values keyword/arg-plist)) display (reading-event (event) (let* ((sequence (read-card16 2)) (minor-code (read-card16 8)) (major-code (read-card8 10)) (result (list :major major-code :minor minor-code :sequence sequence))) (when arg (setq result (list* arg (read-card32 4) result))) result))) (defun decode-resource-error (display event) (decode-core-error display event :resource-id)) (define-error unknown-error (lambda (display event) (list* :error-code (aref (reply-ibuf8 event) 1) (decode-core-error display event)))) (define-error request-error decode-core-error) ; 1 bad request code (define-error value-error ; 2 integer parameter out of range (lambda (display event) (decode-core-error display event :value))) (define-error window-error decode-resource-error) ; 3 parameter not a Window (define-error pixmap-error decode-resource-error) ; 4 parameter not a Pixmap (define-error atom-error ; 5 parameter not an Atom (lambda (display event) (decode-core-error display event :atom-id))) (define-error cursor-error decode-resource-error) ; 6 parameter not a Cursor (define-error font-error decode-resource-error) ; 7 parameter not a Font (define-error match-error decode-core-error) ; 8 parameter mismatch (define-error drawable-error decode-resource-error) ; 9 parameter not a Pixmap or Window (define-error access-error decode-core-error) ; 10 attempt to access private resource" (define-error alloc-error decode-core-error) ; 11 insufficient resources (define-error colormap-error decode-resource-error) ; 12 no such colormap (define-error gcontext-error decode-resource-error) ; 13 parameter not a GContext (define-error id-choice-error decode-resource-error) ; 14 invalid resource ID for this connection (define-error name-error decode-core-error) ; 15 font or color name does not exist (define-error length-error decode-core-error) ; 16 request length incorrect; ; internal Xlib error (define-error implementation-error decode-core-error) ; 17 server is defective ecl-16.1.2/src/clx/keysyms.lisp000066400000000000000000000427221266352375300163410ustar00rootroot00000000000000;;; -*- Mode:Lisp; Package:XLIB; Syntax:COMMON-LISP; Base:10; Lowercase:YES -*- ;;; Define lisp character to keysym mappings ;;; ;;; TEXAS INSTRUMENTS INCORPORATED ;;; P.O. BOX 2909 ;;; AUSTIN, TEXAS 78769 ;;; ;;; Copyright (C) 1987 Texas Instruments Incorporated. ;;; ;;; Permission is granted to any individual or institution to use, copy, modify, ;;; and distribute this software, provided that this complete copyright and ;;; permission notice is maintained, intact, in all copies and supporting ;;; documentation. ;;; ;;; Texas Instruments Incorporated provides this software "as is" without ;;; express or implied warranty. ;;; (in-package :xlib) (define-keysym-set :latin-1 (keysym 0 0) (keysym 0 255)) (define-keysym-set :latin-2 (keysym 1 0) (keysym 1 255)) (define-keysym-set :latin-3 (keysym 2 0) (keysym 2 255)) (define-keysym-set :latin-4 (keysym 3 0) (keysym 3 255)) (define-keysym-set :kana (keysym 4 0) (keysym 4 255)) (define-keysym-set :arabic (keysym 5 0) (keysym 5 255)) (define-keysym-set :cyrillic (keysym 6 0) (keysym 6 255)) (define-keysym-set :greek (keysym 7 0) (keysym 7 255)) (define-keysym-set :tech (keysym 8 0) (keysym 8 255)) (define-keysym-set :special (keysym 9 0) (keysym 9 255)) (define-keysym-set :publish (keysym 10 0) (keysym 10 255)) (define-keysym-set :apl (keysym 11 0) (keysym 11 255)) (define-keysym-set :hebrew (keysym 12 0) (keysym 12 255)) (define-keysym-set :thai (keysym 13 0) (keysym 13 255)) (define-keysym-set :korean (keysym 14 0) (keysym 14 255)) (define-keysym-set :latin-5 (keysym 15 0) (keysym 15 255)) (define-keysym-set :latin-6 (keysym 16 0) (keysym 16 255)) (define-keysym-set :latin-7 (keysym 17 0) (keysym 17 255)) (define-keysym-set :latin-8 (keysym 18 0) (keysym 18 255)) (define-keysym-set :latin-9 (keysym 19 0) (keysym 19 255)) (define-keysym-set :currency (keysym 32 0) (keysym 32 255)) (define-keysym-set :|3270| (keysym 253 0) (keysym 253 255)) (define-keysym-set :xkb (keysym 254 0) (keysym 254 255)) (define-keysym-set :keyboard (keysym 255 0) (keysym 255 255)) (define-keysym :character-set-switch character-set-switch-keysym) (define-keysym :left-shift left-shift-keysym) (define-keysym :right-shift right-shift-keysym) (define-keysym :left-control left-control-keysym) (define-keysym :right-control right-control-keysym) (define-keysym :caps-lock caps-lock-keysym) (define-keysym :shift-lock shift-lock-keysym) (define-keysym :left-meta left-meta-keysym) (define-keysym :right-meta right-meta-keysym) (define-keysym :left-alt left-alt-keysym) (define-keysym :right-alt right-alt-keysym) (define-keysym :left-super left-super-keysym) (define-keysym :right-super right-super-keysym) (define-keysym :left-hyper left-hyper-keysym) (define-keysym :right-hyper right-hyper-keysym) (define-keysym #\space 032) (define-keysym #\! 033) (define-keysym #\" 034) (define-keysym #\# 035) (define-keysym #\$ 036) (define-keysym #\% 037) (define-keysym #\& 038) (define-keysym #\' 039) (define-keysym #\( 040) (define-keysym #\) 041) (define-keysym #\* 042) (define-keysym #\+ 043) (define-keysym #\, 044) (define-keysym #\- 045) (define-keysym #\. 046) (define-keysym #\/ 047) (define-keysym #\0 048) (define-keysym #\1 049) (define-keysym #\2 050) (define-keysym #\3 051) (define-keysym #\4 052) (define-keysym #\5 053) (define-keysym #\6 054) (define-keysym #\7 055) (define-keysym #\8 056) (define-keysym #\9 057) (define-keysym #\: 058) (define-keysym #\; 059) (define-keysym #\< 060) (define-keysym #\= 061) (define-keysym #\> 062) (define-keysym #\? 063) (define-keysym #\@ 064) (define-keysym #\A 065 :lowercase 097) (define-keysym #\B 066 :lowercase 098) (define-keysym #\C 067 :lowercase 099) (define-keysym #\D 068 :lowercase 100) (define-keysym #\E 069 :lowercase 101) (define-keysym #\F 070 :lowercase 102) (define-keysym #\G 071 :lowercase 103) (define-keysym #\H 072 :lowercase 104) (define-keysym #\I 073 :lowercase 105) (define-keysym #\J 074 :lowercase 106) (define-keysym #\K 075 :lowercase 107) (define-keysym #\L 076 :lowercase 108) (define-keysym #\M 077 :lowercase 109) (define-keysym #\N 078 :lowercase 110) (define-keysym #\O 079 :lowercase 111) (define-keysym #\P 080 :lowercase 112) (define-keysym #\Q 081 :lowercase 113) (define-keysym #\R 082 :lowercase 114) (define-keysym #\S 083 :lowercase 115) (define-keysym #\T 084 :lowercase 116) (define-keysym #\U 085 :lowercase 117) (define-keysym #\V 086 :lowercase 118) (define-keysym #\W 087 :lowercase 119) (define-keysym #\X 088 :lowercase 120) (define-keysym #\Y 089 :lowercase 121) (define-keysym #\Z 090 :lowercase 122) (define-keysym #\[ 091) (define-keysym #\\ 092) (define-keysym #\] 093) (define-keysym #\^ 094) (define-keysym #\_ 095) (define-keysym #\` 096) (define-keysym #\a 097) (define-keysym #\b 098) (define-keysym #\c 099) (define-keysym #\d 100) (define-keysym #\e 101) (define-keysym #\f 102) (define-keysym #\g 103) (define-keysym #\h 104) (define-keysym #\i 105) (define-keysym #\j 106) (define-keysym #\k 107) (define-keysym #\l 108) (define-keysym #\m 109) (define-keysym #\n 110) (define-keysym #\o 111) (define-keysym #\p 112) (define-keysym #\q 113) (define-keysym #\r 114) (define-keysym #\s 115) (define-keysym #\t 116) (define-keysym #\u 117) (define-keysym #\v 118) (define-keysym #\w 119) (define-keysym #\x 120) (define-keysym #\y 121) (define-keysym #\z 122) (define-keysym #\{ 123) (define-keysym #\| 124) (define-keysym #\} 125) (define-keysym #\~ 126) (progn ;; Semi-standard characters (define-keysym #\rubout (keysym 255 255)) ; :tty (define-keysym #\tab (keysym 255 009)) ; :tty (define-keysym #\linefeed (keysym 255 010)) ; :tty (define-keysym #\page (keysym 009 227)) ; :special (define-keysym #\return (keysym 255 013)) ; :tty (define-keysym #\backspace (keysym 255 008)) ; :tty ) ;;; these keysym definitions are only correct if the underlying lisp's ;;; definition of characters between 160 and 255 match latin1 exactly. ;;; If the characters are in some way locale-dependent (as, I believe, ;;; in Allegro8) or are treated as opaque without any notions of ;;; graphicness or case (as in cmucl and openmcl) then defining these ;;; keysyms is either not useful or wrong. -- CSR, 2006-03-14 #+sbcl (progn (do ((i 160 (+ i 1))) ((>= i 256)) (if (or (<= #xc0 i #xd6) (<= #xd8 i #xde)) (define-keysym (code-char i) i :lowercase (+ i 32)) (define-keysym (code-char i) i)))) #+(or lispm excl) (progn ;; Nonstandard characters (define-keysym #\escape (keysym 255 027)) ; :tty ) #+ti (progn (define-keysym #\Inverted-exclamation-mark 161) (define-keysym #\american-cent-sign 162) (define-keysym #\british-pound-sign 163) (define-keysym #\Currency-sign 164) (define-keysym #\Japanese-yen-sign 165) (define-keysym #\Yen 165) (define-keysym #\Broken-bar 166) (define-keysym #\Section-symbol 167) (define-keysym #\Section 167) (define-keysym #\Diaresis 168) (define-keysym #\Umlaut 168) (define-keysym #\Copyright-sign 169) (define-keysym #\Copyright 169) (define-keysym #\Feminine-ordinal-indicator 170) (define-keysym #\Angle-quotation-left 171) (define-keysym #\Soft-hyphen 173) (define-keysym #\Shy 173) (define-keysym #\Registered-trademark 174) (define-keysym #\Macron 175) (define-keysym #\Degree-sign 176) (define-keysym #\Ring 176) (define-keysym #\Plus-minus-sign 177) (define-keysym #\Superscript-2 178) (define-keysym #\Superscript-3 179) (define-keysym #\Acute-accent 180) (define-keysym #\Greek-mu 181) (define-keysym #\Paragraph-symbol 182) (define-keysym #\Paragraph 182) (define-keysym #\Pilcrow-sign 182) (define-keysym #\Middle-dot 183) (define-keysym #\Cedilla 184) (define-keysym #\Superscript-1 185) (define-keysym #\Masculine-ordinal-indicator 186) (define-keysym #\Angle-quotation-right 187) (define-keysym #\Fraction-1/4 188) (define-keysym #\One-quarter 188) (define-keysym #\Fraction-1/2 189) (define-keysym #\One-half 189) (define-keysym #\Fraction-3/4 190) (define-keysym #\Three-quarters 190) (define-keysym #\Inverted-question-mark 191) (define-keysym #\Multiplication-sign 215) (define-keysym #\Eszet 223) (define-keysym #\Division-sign 247) ) #+ti (progn ;; There are no 7-bit ascii representations for the following ;; European characters, so use int-char to create them to ensure ;; nothing is lost while sending files through the mail. (define-keysym (int-char 192) 192 :lowercase 224) (define-keysym (int-char 193) 193 :lowercase 225) (define-keysym (int-char 194) 194 :lowercase 226) (define-keysym (int-char 195) 195 :lowercase 227) (define-keysym (int-char 196) 196 :lowercase 228) (define-keysym (int-char 197) 197 :lowercase 229) (define-keysym (int-char 198) 198 :lowercase 230) (define-keysym (int-char 199) 199 :lowercase 231) (define-keysym (int-char 200) 200 :lowercase 232) (define-keysym (int-char 201) 201 :lowercase 233) (define-keysym (int-char 202) 202 :lowercase 234) (define-keysym (int-char 203) 203 :lowercase 235) (define-keysym (int-char 204) 204 :lowercase 236) (define-keysym (int-char 205) 205 :lowercase 237) (define-keysym (int-char 206) 206 :lowercase 238) (define-keysym (int-char 207) 207 :lowercase 239) (define-keysym (int-char 208) 208 :lowercase 240) (define-keysym (int-char 209) 209 :lowercase 241) (define-keysym (int-char 210) 210 :lowercase 242) (define-keysym (int-char 211) 211 :lowercase 243) (define-keysym (int-char 212) 212 :lowercase 244) (define-keysym (int-char 213) 213 :lowercase 245) (define-keysym (int-char 214) 214 :lowercase 246) (define-keysym (int-char 215) 215) (define-keysym (int-char 216) 216 :lowercase 248) (define-keysym (int-char 217) 217 :lowercase 249) (define-keysym (int-char 218) 218 :lowercase 250) (define-keysym (int-char 219) 219 :lowercase 251) (define-keysym (int-char 220) 220 :lowercase 252) (define-keysym (int-char 221) 221 :lowercase 253) (define-keysym (int-char 222) 222 :lowercase 254) (define-keysym (int-char 223) 223) (define-keysym (int-char 224) 224) (define-keysym (int-char 225) 225) (define-keysym (int-char 226) 226) (define-keysym (int-char 227) 227) (define-keysym (int-char 228) 228) (define-keysym (int-char 229) 229) (define-keysym (int-char 230) 230) (define-keysym (int-char 231) 231) (define-keysym (int-char 232) 232) (define-keysym (int-char 233) 233) (define-keysym (int-char 234) 234) (define-keysym (int-char 235) 235) (define-keysym (int-char 236) 236) (define-keysym (int-char 237) 237) (define-keysym (int-char 238) 238) (define-keysym (int-char 239) 239) (define-keysym (int-char 240) 240) (define-keysym (int-char 241) 241) (define-keysym (int-char 242) 242) (define-keysym (int-char 243) 243) (define-keysym (int-char 244) 244) (define-keysym (int-char 245) 245) (define-keysym (int-char 246) 246) (define-keysym (int-char 247) 247) (define-keysym (int-char 248) 248) (define-keysym (int-char 249) 249) (define-keysym (int-char 250) 250) (define-keysym (int-char 251) 251) (define-keysym (int-char 252) 252) (define-keysym (int-char 253) 253) (define-keysym (int-char 254) 254) (define-keysym (int-char 255) 255) ) #+lispm ;; Nonstandard characters (progn (define-keysym #\center-dot (keysym 183)) ; :latin-1 (define-keysym #\down-arrow (keysym 008 254)) ; :technical (define-keysym #\alpha (keysym 007 225)) ; :greek (define-keysym #\beta (keysym 007 226)) ; :greek (define-keysym #\and-sign (keysym 008 222)) ; :technical (define-keysym #\not-sign (keysym 172)) ; :latin-1 (define-keysym #\epsilon (keysym 007 229)) ; :greek (define-keysym #\pi (keysym 007 240)) ; :greek (define-keysym #\lambda (keysym 007 235)) ; :greek (define-keysym #\gamma (keysym 007 227)) ; :greek (define-keysym #\delta (keysym 007 228)) ; :greek (define-keysym #\up-arrow (keysym 008 252)) ; :technical (define-keysym #\plus-minus (keysym 177)) ; :latin-1 (define-keysym #\infinity (keysym 008 194)) ; :technical (define-keysym #\partial-delta (keysym 008 239)) ; :technical (define-keysym #\left-horseshoe (keysym 011 218)) ; :apl (define-keysym #\right-horseshoe (keysym 011 216)) ; :apl (define-keysym #\up-horseshoe (keysym 011 195)) ; :apl (define-keysym #\down-horseshoe (keysym 011 214)) ; :apl (define-keysym #\double-arrow (keysym 008 205)) ; :technical (define-keysym #\left-arrow (keysym 008 251)) ; :technical (define-keysym #\right-arrow (keysym 008 253)) ; :technical (define-keysym #\not-equals (keysym 008 189)) ; :technical (define-keysym #\less-or-equal (keysym 008 188)) ; :technical (define-keysym #\greater-or-equal (keysym 008 190)) ; :technical (define-keysym #\equivalence (keysym 008 207)) ; :technical (define-keysym #\or-sign (keysym 008 223)) ; :technical (define-keysym #\integral (keysym 008 191)) ; :technical ;; break isn't null ;; (define-keysym #\null (keysym 255 107)) ; :function (define-keysym #\clear-input (keysym 255 011)) ; :tty (define-keysym #\help (keysym 255 106)) ; :function (define-keysym #\refresh (keysym 255 097)) ; :function (define-keysym #\abort (keysym 255 105)) ; :function (define-keysym #\resume (keysym 255 098)) ; :function (define-keysym #\end (keysym 255 087)) ; :cursor ;;#\universal-quantifier ;;#\existential-quantifier ;;#\circle-plus ;;#\circle-cross same as #\circle-x ) #+genera (progn ;;#\network ;;#\symbol-help (define-keysym #\lozenge (keysym 009 224)) ; :special (define-keysym #\suspend (keysym 255 019)) ; :tty (define-keysym #\function (keysym 255 032)) ; :function (define-keysym #\square (keysym 010 231)) ; :publishing (define-keysym #\circle (keysym 010 230)) ; :publishing (define-keysym #\triangle (keysym 010 232)) ; :publishing (define-keysym #\scroll (keysym 255 086)) ; :cursor (define-keysym #\select (keysym 255 096)) ; :function (define-keysym #\complete (keysym 255 104)) ; :function ) #+ti (progn (define-keysym #\terminal (keysym 255 032)) ; :function (define-keysym #\system (keysym 255 096)) ; :function (define-keysym #\center-arrow (keysym 255 80)) (define-keysym #\left-arrow (keysym 255 081)) ; :cursor (define-keysym #\up-arrow (keysym 255 082)) ; :cursor (define-keysym #\right-arrow (keysym 255 083)) ; :cursor (define-keysym #\down-arrow (keysym 255 084)) ; :cursor (define-keysym #\end (keysym 255 087)) ; :cursor (define-keysym #\undo (keysym 255 101)) ; :function (define-keysym #\break (keysym 255 107)) (define-keysym #\keypad-space (keysym 255 128)) ; :keypad (define-keysym #\keypad-tab (keysym 255 137)) ; :keypad (define-keysym #\keypad-enter (keysym 255 141)) ; :keypad (define-keysym #\f1 (keysym 255 145)) ; :keypad (define-keysym #\f2 (keysym 255 146)) ; :keypad (define-keysym #\f3 (keysym 255 147)) ; :keypad (define-keysym #\f4 (keysym 255 148)) ; :keypad (define-keysym #\f1 (keysym 255 190)) ; :keypad (define-keysym #\f2 (keysym 255 191)) ; :keypad (define-keysym #\f3 (keysym 255 192)) ; :keypad (define-keysym #\f4 (keysym 255 193)) ; :keypad (define-keysym #\keypad-plus (keysym 255 171)) ; :keypad (define-keysym #\keypad-comma (keysym 255 172)) ; :keypad (define-keysym #\keypad-minus (keysym 255 173)) ; :keypad (define-keysym #\keypad-period (keysym 255 174)) ; :keypad (define-keysym #\keypad-0 (keysym 255 176)) ; :keypad (define-keysym #\keypad-1 (keysym 255 177)) ; :keypad (define-keysym #\keypad-2 (keysym 255 178)) ; :keypad (define-keysym #\keypad-3 (keysym 255 179)) ; :keypad (define-keysym #\keypad-4 (keysym 255 180)) ; :keypad (define-keysym #\keypad-5 (keysym 255 181)) ; :keypad (define-keysym #\keypad-6 (keysym 255 182)) ; :keypad (define-keysym #\keypad-7 (keysym 255 183)) ; :keypad (define-keysym #\keypad-8 (keysym 255 184)) ; :keypad (define-keysym #\keypad-9 (keysym 255 185)) ; :keypad (define-keysym #\keypad-equal (keysym 255 189)) ; :keypad (define-keysym #\f1 (keysym 255 192)) ; :function (define-keysym #\f2 (keysym 255 193)) ; :function (define-keysym #\f3 (keysym 255 194)) ; :function (define-keysym #\f4 (keysym 255 195)) ; :function (define-keysym #\network (keysym 255 214)) (define-keysym #\status (keysym 255 215)) (define-keysym #\clear-screen (keysym 255 217)) (define-keysym #\left (keysym 255 218)) (define-keysym #\middle (keysym 255 219)) (define-keysym #\right (keysym 255 220)) (define-keysym #\resume (keysym 255 221)) (define-keysym #\vt (keysym 009 233)) ; :special ;; same as #\delete ) #+ti (progn ;; Explorer specific characters (define-keysym #\Call (keysym 131)) ; :latin-1 (define-keysym #\Macro (keysym 133)) ; :latin-1 (define-keysym #\Quote (keysym 142)) ; :latin-1 (define-keysym #\Hold-output (keysym 143)) ; :latin-1 (define-keysym #\Stop-output (keysym 144)) ; :latin-1 (define-keysym #\Center (keysym 156)) ; :latin-1 (define-keysym #\no-break-space (keysym 160)) ; :latin-1 (define-keysym #\circle-plus (keysym 13)) ; :latin-1 (define-keysym #\universal-quantifier (keysym 20)) ; :latin-1 (define-keysym #\existential-quantifier (keysym 21)) ; :latin-1 (define-keysym #\circle-cross (keysym 22)) ; :latin-1 ) ecl-16.1.2/src/clx/macros.lisp000066400000000000000000001301621266352375300161150ustar00rootroot00000000000000;;; -*- Mode: LISP; Syntax: Common-lisp; Package: XLIB; Base: 10; Lowercase: Yes -*- ;;; ;;; TEXAS INSTRUMENTS INCORPORATED ;;; P.O. BOX 2909 ;;; AUSTIN, TEXAS 78769 ;;; ;;; Copyright (C) 1987 Texas Instruments Incorporated. ;;; ;;; Permission is granted to any individual or institution to use, copy, modify, ;;; and distribute this software, provided that this complete copyright and ;;; permission notice is maintained, intact, in all copies and supporting ;;; documentation. ;;; ;;; Texas Instruments Incorporated provides this software "as is" without ;;; express or implied warranty. ;;; ;;; CLX basically implements a very low overhead remote procedure call ;;; to the server. This file contains macros which generate the code ;;; for both the client AND the server, given a specification of the ;;; interface. This was done to eliminate errors that may occur because ;;; the client and server code get/put bytes in different places, and ;;; it makes it easier to extend the protocol. ;;; This is built on top of BUFFER (in-package :xlib) (defmacro type-check (value type) value type (when +type-check?+ `(unless (type? ,value ,type) (x-type-error ,value ,type)))) ;;; This variable is used by the required-arg macro just to satisfy compilers. (defvar *required-arg-dummy*) ;;; An error signalling macro use to specify that keyword arguments are required. (defmacro required-arg (name) `(progn (x-error 'missing-parameter :parameter ',name) *required-arg-dummy*)) (defmacro lround (index) ;; Round up to the next 32 bit boundary `(the array-index (logand (index+ ,index 3) -4))) (defmacro wround (index) ;; Round up to the next 16 bit boundary `(the array-index (logand (index+ ,index 1) -2))) ;; ;; Data-type accessor functions ;; ;; These functions translate between lisp data-types and the byte, ;; half-word or word that gets transmitted across the client/server ;; connection (defun index-increment (type) ;; Given a type, return its field width in bytes (let* ((name (if (consp type) (car type) type)) (increment (get name 'byte-width :not-found))) (when (eq increment :not-found) ;; Check for TYPE in a different package (when (not (eq (symbol-package name) *xlib-package*)) (setq name (xintern name)) (setq increment (get name 'byte-width :not-found))) (when (eq increment :not-found) (error "~s isn't a known field accessor" name))) increment)) (eval-when (:compile-toplevel :load-toplevel :execute) (defun getify (name) (xintern name '-get)) (defun putify (name &optional predicate-p) (xintern name '-put (if predicate-p '-predicating ""))) ;;; Use &body so zmacs indents properly (defmacro define-accessor (name (width) &body get-put-macros) ;; The first body form defines the get macro ;; The second body form defines the put macro ;; The third body form is optional, and defines a put macro that does ;; type checking and does a put when ok, else NIL when the type is incorrect. ;; If no third body form is present, then these macros assume that ;; (AND (TYPEP ,thing 'type) (PUT-type ,thing)) can be generated. ;; these predicating puts are used by the OR accessor. (declare (arglist name (width) get-macro put-macro &optional predicating-put-macro)) (when (cdddr get-put-macros) (error "Too many parameters to define-accessor: ~s" (cdddr get-put-macros))) (let ((get-macro (or (first get-put-macros) (error "No GET macro form for ~s" name))) (put-macro (or (second get-put-macros) (error "No PUT macro form for ~s" name)))) `(within-definition (,name define-accessor) (setf (get ',name 'byte-width) ,(and width (floor width 8))) (defmacro ,(getify name) ,(car get-macro) ,@(cdr get-macro)) (defmacro ,(putify name) ,(car put-macro) ,@(cdr put-macro)) ,@(when +type-check?+ (let ((predicating-put (third get-put-macros))) (when predicating-put `((setf (get ',name 'predicating-put) t) (defmacro ,(putify name t) ,(car predicating-put) ,@(cdr predicating-put))))))))) ) ;; End eval-when (define-accessor card32 (32) ((index) `(read-card32 ,index)) ((index thing) `(write-card32 ,index ,thing))) (define-accessor card29 (32) ((index) `(read-card29 ,index)) ((index thing) `(write-card29 ,index ,thing))) (define-accessor card16 (16) ((index) `(read-card16 ,index)) ((index thing) `(write-card16 ,index ,thing))) (define-accessor card8 (8) ((index) `(read-card8 ,index)) ((index thing) `(write-card8 ,index ,thing))) (define-accessor integer (32) ((index) `(read-int32 ,index)) ((index thing) `(write-int32 ,index ,thing))) (define-accessor int16 (16) ((index) `(read-int16 ,index)) ((index thing) `(write-int16 ,index ,thing))) (define-accessor rgb-val (16) ;; Used for color's ((index) `(card16->rgb-val (read-card16 ,index))) ((index thing) `(write-card16 ,index (rgb-val->card16 ,thing)))) (define-accessor angle (16) ;; Used for drawing arcs ((index) `(int16->radians (read-int16 ,index))) ((index thing) `(write-int16 ,index (radians->int16 ,thing)))) (define-accessor bit (0) ;; Like BOOLEAN, but tests bits ;; only used by declare-event (:enter-notify :leave-notify) ((index bit) `(logbitp ,bit (read-card8 ,index))) ((index thing bit) (if (zerop bit) `(write-card8 ,index (if ,thing 1 0)) `(write-card8 ,index (dpb (if ,thing 1 0) (byte 1 ,bit) (read-card8 ,index)))))) (define-accessor boolean (8) ((index) `(plusp (read-card8 ,index))) ((index thing) `(write-card8 ,index (if ,thing 1 0)))) (define-accessor drawable (32) ((index &optional (buffer '%buffer)) `(lookup-drawable ,buffer (read-card29 ,index))) ((index thing) `(write-card29 ,index (drawable-id ,thing)))) (define-accessor window (32) ((index &optional (buffer '%buffer)) `(lookup-window ,buffer (read-card29 ,index))) ((index thing) `(write-card29 ,index (window-id ,thing)))) (define-accessor pixmap (32) ((index &optional (buffer '%buffer)) `(lookup-pixmap ,buffer (read-card29 ,index))) ((index thing) `(write-card29 ,index (pixmap-id ,thing)))) (define-accessor gcontext (32) ((index &optional (buffer '%buffer)) `(lookup-gcontext ,buffer (read-card29 ,index))) ((index thing) `(write-card29 ,index (gcontext-id ,thing)))) (define-accessor cursor (32) ((index &optional (buffer '%buffer)) `(lookup-cursor ,buffer (read-card29 ,index))) ((index thing) `(write-card29 ,index (cursor-id ,thing)))) (define-accessor colormap (32) ((index &optional (buffer '%buffer)) `(lookup-colormap ,buffer (read-card29 ,index))) ((index thing) `(write-card29 ,index (colormap-id ,thing)))) (define-accessor font (32) ((index &optional (buffer '%buffer)) `(lookup-font ,buffer (read-card29 ,index))) ;; The FONT-ID accessor may make a OpenFont request. Since we don't support recursive ;; with-buffer-request, issue a compile time error, rather than barf at run-time. ((index thing) (declare (ignore index thing)) (error "FONT-ID must be called OUTSIDE with-buffer-request. Use RESOURCE-ID instead."))) ;; Needed to get and put xatom's in events (define-accessor keyword (32) ((index &optional (buffer '%buffer)) `(atom-name ,buffer (read-card29 ,index))) ((index thing &key (buffer '%buffer)) `(write-card29 ,index (or (atom-id ,thing ,buffer) (error "CLX implementation error in KEYWORD-PUT"))))) (define-accessor resource-id (32) ((index) `(read-card29 ,index)) ((index thing) `(write-card29 ,index ,thing))) (define-accessor resource-id-or-nil (32) ((index) (let ((id (gensym))) `(let ((,id (read-card29 ,index))) (and (plusp ,id) ,id)))) ((index thing) `(write-card29 ,index (or ,thing 0)))) (defmacro char-info-get (index) `(make-char-info :left-bearing (int16-get ,index) :right-bearing (int16-get ,(+ index 2)) :width (int16-get ,(+ index 4)) :ascent (int16-get ,(+ index 6)) :descent (int16-get ,(+ index 8)) :attributes (card16-get ,(+ index 10)))) (define-accessor member8 (8) ((index &rest keywords) (let ((value (gensym))) `(let ((,value (read-card8 ,index))) (declare (type (integer 0 (,(length keywords))) ,value)) (type-check ,value '(integer 0 (,(length keywords)))) (svref ',(apply #'vector keywords) ,value)))) ((index thing &rest keywords) `(write-card8 ,index (position ,thing #+lispm ',keywords ;; Lispm's prefer lists #-lispm (the simple-vector ',(apply #'vector keywords)) :test #'eq))) ((index thing &rest keywords) (let ((value (gensym))) `(let ((,value (position ,thing #+lispm ',keywords #-lispm (the simple-vector ',(apply #'vector keywords)) :test #'eq))) (and ,value (write-card8 ,index ,value)))))) (define-accessor member16 (16) ((index &rest keywords) (let ((value (gensym))) `(let ((,value (read-card16 ,index))) (declare (type (integer 0 (,(length keywords))) ,value)) (type-check ,value '(integer 0 (,(length keywords)))) (svref ',(apply #'vector keywords) ,value)))) ((index thing &rest keywords) `(write-card16 ,index (position ,thing #+lispm ',keywords ;; Lispm's prefer lists #-lispm (the simple-vector ',(apply #'vector keywords)) :test #'eq))) ((index thing &rest keywords) (let ((value (gensym))) `(let ((,value (position ,thing #+lispm ',keywords #-lispm (the simple-vector ',(apply #'vector keywords)) :test #'eq))) (and ,value (write-card16 ,index ,value)))))) (define-accessor member (32) ((index &rest keywords) (let ((value (gensym))) `(let ((,value (read-card29 ,index))) (declare (type (integer 0 (,(length keywords))) ,value)) (type-check ,value '(integer 0 (,(length keywords)))) (svref ',(apply #'vector keywords) ,value)))) ((index thing &rest keywords) `(write-card29 ,index (position ,thing #+lispm ',keywords ;; Lispm's prefer lists #-lispm (the simple-vector ',(apply #'vector keywords)) :test #'eq))) ((index thing &rest keywords) (if (cdr keywords) ;; IF more than one (let ((value (gensym))) `(let ((,value (position ,thing #+lispm ',keywords #-lispm (the simple-vector ',(apply #'vector keywords)) :test #'eq))) (and ,value (write-card29 ,index ,value)))) `(and (eq ,thing ,(car keywords)) (write-card29 ,index 0))))) (deftype member-vector (vector) `(member ,@(coerce (symbol-value vector) 'list))) (define-accessor member-vector (32) ((index membership-vector) `(member-get ,index ,@(coerce (eval membership-vector) 'list))) ((index thing membership-vector) `(member-put ,index ,thing ,@(coerce (eval membership-vector) 'list))) ((index thing membership-vector) `(member-put ,index ,thing ,@(coerce (eval membership-vector) 'list)))) (define-accessor member16-vector (16) ((index membership-vector) `(member16-get ,index ,@(coerce (eval membership-vector) 'list))) ((index thing membership-vector) `(member16-put ,index ,thing ,@(coerce (eval membership-vector) 'list))) ((index thing membership-vector) `(member16-put ,index ,thing ,@(coerce (eval membership-vector) 'list)))) (define-accessor member8-vector (8) ((index membership-vector) `(member8-get ,index ,@(coerce (eval membership-vector) 'list))) ((index thing membership-vector) `(member8-put ,index ,thing ,@(coerce (eval membership-vector) 'list))) ((index thing membership-vector) `(member8-put ,index ,thing ,@(coerce (eval membership-vector) 'list)))) (define-accessor boole-constant (32) ;; this isn't member-vector because we need eql instead of eq ((index) (let ((value (gensym))) `(let ((,value (read-card29 ,index))) (declare (type (integer 0 (,(length +boole-vector+))) ,value)) (type-check ,value '(integer 0 (,(length +boole-vector+)))) (svref +boole-vector+ ,value)))) ((index thing) `(write-card29 ,index (position ,thing (the simple-vector +boole-vector+)))) ((index thing) (let ((value (gensym))) `(let ((,value (position ,thing (the simple-vector +boole-vector+)))) (and ,value (write-card29 ,index ,value)))))) (define-accessor null (32) ((index) `(if (zerop (read-card32 ,index)) nil (read-card32 ,index))) ((index value) (declare (ignore value)) `(write-card32 ,index 0))) (define-accessor pad8 (8) ((index) (declare (ignore index)) nil) ((index value) (declare (ignore index value)) nil)) (define-accessor pad16 (16) ((index) (declare (ignore index)) nil) ((index value) (declare (ignore index value)) nil)) (define-accessor pad32 (32) ((index) (declare (ignore index)) nil) ((index value) (declare (ignore index value)) nil)) (define-accessor bit-vector256 (256) ;; used for key-maps ;; REAL-INDEX parameter provided so the default index can be over-ridden. ;; This is needed for the :keymap-notify event where the keymap overlaps ;; the window id. ((index &optional (real-index index) data) `(read-bitvector256 buffer-bbuf ,real-index ,data)) ((index map &optional (real-index index) (buffer '%buffer)) `(write-bitvector256 ,buffer (index+ buffer-boffset ,real-index) ,map))) (define-accessor string (nil) ((length index &key reply-buffer) `(read-sequence-char ,(or reply-buffer '%reply-buffer) 'string ,length nil nil 0 ,index)) ((index string &key buffer (start 0) end header-length appending) (unless buffer (setq buffer '%buffer)) (unless header-length (setq header-length (lround index))) (let* ((real-end (if appending (or end `(length ,string)) (gensym))) (form `(write-sequence-char ,buffer (index+ buffer-boffset ,header-length) ,string ,start ,real-end))) (if appending form `(let ((,real-end ,(or end `(length ,string)))) (write-card16 2 (index-ceiling (index+ (index- ,real-end ,start) ,header-length) 4)) ,form))))) (define-accessor sequence (nil) ((&key length (format 'card32) result-type transform reply-buffer data index start) `(,(ecase format (card8 'read-sequence-card8) (int8 'read-sequence-int8) (card16 'read-sequence-card16) (int16 'read-sequence-int16) (card32 'read-sequence-card32) (int32 'read-sequence-int32)) ,(or reply-buffer '%reply-buffer) ,result-type ,length ,transform ,data ,@(when (or start index) `(,(or start 0))) ,@(when index `(,index)))) ((index data &key (format 'card32) (start 0) end transform buffer appending) (unless buffer (setq buffer '%buffer)) (let* ((real-end (if appending (or end `(length ,data)) (gensym))) (writer (xintern 'write-sequence- format)) (form `(,writer ,buffer (index+ buffer-boffset ,(lround index)) ,data ,start ,real-end ,transform))) (flet ((maker (size) (if appending form (let ((idx `(index- ,real-end ,start))) (unless (= size 1) (setq idx `(index-ceiling ,idx ,size))) `(let ((,real-end ,(or end `(length ,data)))) (write-card16 2 (index+ ,idx ,(index-ceiling index 4))) ,form))))) (ecase format ((card8 int8) (maker 4)) ((card16 int16 char2b) (maker 2)) ((card32 int32) (maker 1))))))) (defmacro client-message-event-get-sequence () '(let* ((format (read-card8 1)) (sequence (make-array (ceiling 160 format) :element-type `(unsigned-byte ,format)))) (declare (type (member 8 16 32) format)) (do ((i 12) (j 0 (index1+ j))) ((>= i 32)) (case format (8 (setf (aref sequence j) (read-card8 i)) (index-incf i)) (16 (setf (aref sequence j) (read-card16 i)) (index-incf i 2)) (32 (setf (aref sequence j) (read-card32 i)) (index-incf i 4)))) sequence)) (defmacro client-message-event-put-sequence (format sequence) `(ecase ,format (8 (sequence-put 12 ,sequence :format card8 :end (min (length ,sequence) 20) :appending t)) (16 (sequence-put 12 ,sequence :format card16 :end (min (length ,sequence) 10) :appending t)) (32 (sequence-put 12 ,sequence :format card32 :end (min (length ,sequence) 5) :appending t)))) ;; Used only in declare-event (define-accessor client-message-sequence (160) ((index format) (declare (ignore index format)) `(client-message-event-get-sequence)) ((index value format) (declare (ignore index)) `(client-message-event-put-sequence ,format ,value))) ;;; ;;; Compound accessors ;;; Accessors that take other accessors as parameters ;;; (define-accessor code (0) ((index) (declare (ignore index)) '(read-card8 0)) ((index value) (declare (ignore index)) `(write-card8 0 ,value)) ((index value) (declare (ignore index)) `(write-card8 0 ,value))) (define-accessor length (0) ((index) (declare (ignore index)) '(read-card16 2)) ((index value) (declare (ignore index)) `(write-card16 2 ,value)) ((index value) (declare (ignore index)) `(write-card16 2 ,value))) (deftype data () 'card8) (define-accessor data (0) ;; Put data in byte 1 of the reqeust ((index &optional stuff) (declare (ignore index)) (if stuff (if (consp stuff) `(,(getify (car stuff)) 1 ,@(cdr stuff)) `(,(getify stuff) 1)) `(read-card8 1))) ((index thing &optional stuff) (if stuff (if (consp stuff) `(macrolet ((write-card32 (index value) index value)) (write-card8 1 (,(putify (car stuff)) ,index ,thing ,@(cdr stuff)))) `(,(putify stuff) 1 ,thing)) `(write-card8 1 ,thing))) ((index thing &optional stuff) (if stuff `(and (type? ,thing ',stuff) ,(if (consp stuff) `(macrolet ((write-card32 (index value) index value)) (write-card8 1 (,(putify (car stuff)) ,index ,thing ,@(cdr stuff)))) `(,(putify stuff) 1 ,thing))) `(and (type? ,thing 'card8) (write-card8 1 ,thing))))) ;; Macroexpand the result of OR-GET to allow the macros file to not be loaded ;; when using event-case. This is pretty gross. (defmacro or-expand (&rest forms &environment environment) `(cond ,@(mapcar #'(lambda (forms) (mapcar #'(lambda (form) (clx-macroexpand form environment)) forms)) forms))) ;; ;; the OR type ;; (define-accessor or (32) ;; Select from among several types (usually NULL and something else) ((index &rest type-list &environment environment) (do ((types type-list (cdr types)) (value (gensym)) (result)) ((endp types) `(let ((,value (read-card32 ,index))) (macrolet ((read-card32 (index) index ',value) (read-card29 (index) index ',value)) ,(clx-macroexpand `(or-expand ,@(nreverse result)) environment)))) (let ((item (car types)) (args nil)) (when (consp item) (setq args (cdr item) item (car item))) (if (eq item 'null) ;; Special case for NULL (push `((zerop ,value) nil) result) (push `((,(getify item) ,index ,@args)) result))))) ((index value &rest type-list) (do ((types type-list (cdr types)) (result)) ((endp types) `(cond ,@(nreverse result) ,@(when +type-check?+ `((t (x-type-error ,value '(or ,@type-list))))))) (let* ((type (car types)) (type-name type) (args nil)) (when (consp type) (setq args (cdr type) type-name (car type))) (push `(,@(cond ((get type-name 'predicating-put) nil) ((or +type-check?+ (cdr types)) `((type? ,value ',type))) (t '(t))) (,(putify type-name (get type-name 'predicating-put)) ,index ,value ,@args)) result))))) ;; ;; the MASK type... ;; is used to specify a subset of a collection of "optional" arguments. ;; A mask type consists of a 32 bit mask word followed by a word for each one-bit ;; in the mask. The MASK type is ALWAYS the LAST item in a request. ;; (setf (get 'mask 'byte-width) nil) (defun mask-get (index type-values body-function) (declare (type function body-function) #+clx-ansi-common-lisp (dynamic-extent body-function) #+(and lispm (not clx-ansi-common-lisp)) (sys:downward-funarg body-function)) ;; This is a function, because it must return more than one form (called by get-put-items) ;; Functions that use this must have a binding for %MASK (let* ((bit 0) (result (mapcar #'(lambda (form) (if (atom form) form ;; Hack to allow BODY-FUNCTION to return keyword/value pairs (prog1 `(when (logbitp ,bit %mask) ;; Execute form when bit is set ,form) (incf bit)))) (get-put-items (+ index 4) type-values nil #'(lambda (type index item args) (declare (ignore index)) (funcall body-function type '(* (incf %index) 4) item args)))))) ;; First form must load %MASK `(,@(when (atom (car result)) (list (pop result))) (progn (setq %mask (read-card32 ,index)) (setq %index ,(ceiling index 4)) ,(car result)) ,@(cdr result)))) ;; MASK-PUT (defun mask-put (index type-values body-function) (declare (type function body-function) #+clx-ansi-common-lisp (dynamic-extent body-function) #+(and lispm (not clx-ansi-common-lisp)) (sys:downward-funarg body-function)) ;; The MASK type writes a 32 bit mask with 1 bits for each non-nil value in TYPE-VALUES ;; A 32 bit value follows for each non-nil value. `((let ((%mask 0) (%index ,index)) ,@(let ((bit 1)) (get-put-items index type-values t #'(lambda (type index item args) (declare (ignore index)) (if (or (symbolp item) (constantp item)) `((unless (null ,item) (setq %mask (logior %mask ,(shiftf bit (ash bit 1)))) ,@(funcall body-function type `(index-incf %index 4) item args))) `((let ((.item. ,item)) (unless (null .item.) (setq %mask (logior %mask ,(shiftf bit (ash bit 1)))) ,@(funcall body-function type `(index-incf %index 4) '.item. args)))))))) (write-card32 ,index %mask) (write-card16 2 (index-ceiling (index-incf %index 4) 4)) (incf (buffer-boffset %buffer) %index)))) (define-accessor progn (nil) ;; Catch-all for inserting random code ;; Note that code using this is then responsible for setting the request length ((index statement) (declare (ignore index)) statement) ((index statement) (declare (ignore index)) statement)) ; ; Wrapper macros, for use around the above ; ;;; type-check was here, and has been moved up (defmacro check-put (index value type &rest args &environment env) (let* ((var (if (or (symbolp value) (constantp value)) value '.value.)) (body (if (or (null (macroexpand `(type-check ,var ',type) env)) (member type '(or progn pad8 pad16)) (constantp value)) `(,(putify type) ,index ,var ,@args) ;; Do type checking (if (get type 'predicating-put) `(or (,(putify type t) ,index ,var ,@args) (x-type-error ,var ',(if args `(,type ,@args) type))) `(if (type? ,var ',type) (,(putify type) ,index ,var ,@args) (x-type-error ,var ',(if args `(,type ,@args) type))))))) (if (eq var value) body `(let ((,var ,value)) ,body)))) (defun get-put-items (index type-args putp &optional body-function) (declare (type (or null function) body-function) #+clx-ansi-common-lisp (dynamic-extent body-function) #+(and lispm (not clx-ansi-common-lisp)) (sys:downward-funarg body-function)) ;; Given a lists of the form (type item item ... item) ;; Calls body-function with four arguments, a function name, ;; index, item name, and optional arguments. ;; The results are appended together and retured. (unless body-function (setq body-function #'(lambda (type index item args) `((check-put ,index ,item ,type ,@args))))) (do* ((items type-args (cdr items)) (type (caar items) (caar items)) (args nil nil) (result nil) (sizes nil)) ((endp items) (values result index sizes)) (when (consp type) (setq args (cdr type) type (car type))) (cond ((member type '(return buffer))) ((eq type 'mask) ;; Hack to enable mask-get/put to return multiple values (setq result (append result (if putp (mask-put index (cdar items) body-function) (mask-get index (cdar items) body-function))) index nil)) (t (do* ((item (cdar items) (cdr item)) (increment (index-increment type))) ((endp item)) (when (constantp index) (case increment ;Round up index when needed (2 (setq index (wround index))) (4 (setq index (lround index))))) (setq result (append result (funcall body-function type index (car item) args))) (when (constantp index) ;; Variable length requests have null length increment. ;; Variable length requests set the request size ;; & maintain buffer pointers (if (null increment) (setq index nil) (progn (incf index increment) (when (and increment (zerop increment)) (setq increment 1)) (pushnew (* increment 8) sizes))))))))) (defmacro with-buffer-request-internal ((buffer opcode &key length sizes &allow-other-keys) &body type-args) (multiple-value-bind (code index item-sizes) (get-put-items 4 type-args t) (let ((length (if length `(index+ ,length +requestsize+) '+requestsize+)) (sizes (remove-duplicates (append '(8 16) item-sizes sizes)))) `(with-buffer-output (,buffer :length ,length :sizes ,sizes) (setf (buffer-last-request ,buffer) buffer-boffset) (write-card8 0 ,opcode) ;; Stick in the opcode ,@code ,@(when index (setq index (lround index)) `((write-card16 2 ,(ceiling index 4)) (setf (buffer-boffset ,buffer) (index+ buffer-boffset ,index)))) (buffer-new-request-number ,buffer))))) (defmacro with-buffer-request ((buffer opcode &rest options &key inline gc-force &allow-other-keys) &body type-args &environment env) (if (and (null inline) (macroexpand '(use-closures) env)) `(flet ((.request-body. (.display.) (declare (type display .display.)) (with-buffer-request-internal (.display. ,opcode ,@options) ,@type-args))) #+clx-ansi-common-lisp (declare (dynamic-extent #'.request-body.)) (,(if (eq (car (macroexpand '(with-buffer (buffer)) env)) 'progn) 'with-buffer-request-function-nolock 'with-buffer-request-function) ,buffer ,gc-force #'.request-body.)) `(let ((.display. ,buffer)) (declare (type display .display.)) (with-buffer (.display.) ,@(when gc-force `((force-gcontext-changes-internal ,gc-force))) (multiple-value-prog1 (without-aborts (with-buffer-request-internal (.display. ,opcode ,@options) ,@type-args)) (display-invoke-after-function .display.)))))) (defmacro with-buffer-request-and-reply ((buffer opcode reply-size &key sizes multiple-reply inline) type-args &body reply-forms &environment env) (declare (indentation 0 4 1 4 2 1)) (let* ((inner-reply-body `(with-buffer-input (.reply-buffer. :display .display. ,@(and sizes (list :sizes sizes))) nil ,@reply-forms)) (reply-body (if (or (not (symbolp reply-size)) (constantp reply-size)) inner-reply-body `(let ((,reply-size (reply-data-size (the reply-buffer .reply-buffer.)))) (declare (type array-index ,reply-size)) ,inner-reply-body)))) (if (and (null inline) (macroexpand '(use-closures) env)) `(flet ((.request-body. (.display.) (declare (type display .display.)) (with-buffer-request-internal (.display. ,opcode) ,@type-args)) (.reply-body. (.display. .reply-buffer.) (declare (type display .display.) (type reply-buffer .reply-buffer.)) (progn .display. .reply-buffer. nil) ,reply-body)) #+clx-ansi-common-lisp (declare (dynamic-extent #'.request-body. #'.reply-body.)) (with-buffer-request-and-reply-function ,buffer ,multiple-reply #'.request-body. #'.reply-body.)) `(let ((.display. ,buffer) (.pending-command. nil) (.reply-buffer. nil)) (declare (type display .display.) (type (or null pending-command) .pending-command.) (type (or null reply-buffer) .reply-buffer.)) (unwind-protect (progn (with-buffer (.display.) (setq .pending-command. (start-pending-command .display.)) (without-aborts (with-buffer-request-internal (.display. ,opcode) ,@type-args)) (buffer-force-output .display.) (display-invoke-after-function .display.)) ,@(if multiple-reply `((loop (setq .reply-buffer. (read-reply .display. .pending-command.)) (when ,reply-body (return nil)) (deallocate-reply-buffer (shiftf .reply-buffer. nil)))) `((setq .reply-buffer. (read-reply .display. .pending-command.)) ,reply-body))) (when .reply-buffer. (deallocate-reply-buffer .reply-buffer.)) (when .pending-command. (stop-pending-command .display. .pending-command.))))))) (defmacro compare-request ((index) &body body) `(macrolet ((write-card32 (index item) `(= ,item (read-card32 ,index))) (write-int32 (index item) `(= ,item (read-int32 ,index))) (write-card29 (index item) `(= ,item (read-card29 ,index))) (write-int29 (index item) `(= ,item (read-int29 ,index))) (write-card16 (index item) `(= ,item (read-card16 ,index))) (write-int16 (index item) `(= ,item (read-int16 ,index))) (write-card8 (index item) `(= ,item (read-card8 ,index))) (write-int8 (index item) `(= ,item (read-int8 ,index)))) (macrolet ((type-check (value type) value type nil)) (and ,@(get-put-items index body t))))) (defmacro put-items ((index) &body body) `(progn ,@(get-put-items index body t))) (defmacro decode-type (type value) ;; Given an integer and type, return the value (let ((args nil)) (when (consp type) (setq args (cdr type) type (car type))) `(macrolet ((read-card29 (value) value) (read-card32 (value) value) (read-int32 (value) `(card32->int32 ,value)) (read-card16 (value) value) (read-int16 (value) `(card16->int16 ,value)) (read-card8 (value) value) (read-int8 (value) `(int8->card8 ,value))) (,(getify type) ,value ,@args)))) (defmacro encode-type (type value) ;; Given a value and type, return an integer ;; When check-p, do type checking on value (let ((args nil)) (when (consp type) (setq args (cdr type) type (car type))) `(macrolet ((write-card29 (index value) index value) (write-card32 (index value) index value) (write-int32 (index value) index `(int32->card32 ,value)) (write-card16 (index value) index value) (write-int16 (index value) index `(int16->card16 ,value)) (write-card8 (index value) index value) (write-int8 (index value) index `(int8->card8 ,value))) (check-put 0 ,value ,type ,@args)))) (defmacro set-decode-type (type accessor value) `(setf ,accessor (encode-type ,type ,value))) (defsetf decode-type set-decode-type) ;;; ;;; Request codes ;;; (defconstant +x-createwindow+ 1) (defconstant +x-changewindowattributes+ 2) (defconstant +x-getwindowattributes+ 3) (defconstant +x-destroywindow+ 4) (defconstant +x-destroysubwindows+ 5) (defconstant +x-changesaveset+ 6) (defconstant +x-reparentwindow+ 7) (defconstant +x-mapwindow+ 8) (defconstant +x-mapsubwindows+ 9) (defconstant +x-unmapwindow+ 10) (defconstant +x-unmapsubwindows+ 11) (defconstant +x-configurewindow+ 12) (defconstant +x-circulatewindow+ 13) (defconstant +x-getgeometry+ 14) (defconstant +x-querytree+ 15) (defconstant +x-internatom+ 16) (defconstant +x-getatomname+ 17) (defconstant +x-changeproperty+ 18) (defconstant +x-deleteproperty+ 19) (defconstant +x-getproperty+ 20) (defconstant +x-listproperties+ 21) (defconstant +x-setselectionowner+ 22) (defconstant +x-getselectionowner+ 23) (defconstant +x-convertselection+ 24) (defconstant +x-sendevent+ 25) (defconstant +x-grabpointer+ 26) (defconstant +x-ungrabpointer+ 27) (defconstant +x-grabbutton+ 28) (defconstant +x-ungrabbutton+ 29) (defconstant +x-changeactivepointergrab+ 30) (defconstant +x-grabkeyboard+ 31) (defconstant +x-ungrabkeyboard+ 32) (defconstant +x-grabkey+ 33) (defconstant +x-ungrabkey+ 34) (defconstant +x-allowevents+ 35) (defconstant +x-grabserver+ 36) (defconstant +x-ungrabserver+ 37) (defconstant +x-querypointer+ 38) (defconstant +x-getmotionevents+ 39) (defconstant +x-translatecoords+ 40) (defconstant +x-warppointer+ 41) (defconstant +x-setinputfocus+ 42) (defconstant +x-getinputfocus+ 43) (defconstant +x-querykeymap+ 44) (defconstant +x-openfont+ 45) (defconstant +x-closefont+ 46) (defconstant +x-queryfont+ 47) (defconstant +x-querytextextents+ 48) (defconstant +x-listfonts+ 49) (defconstant +x-listfontswithinfo+ 50) (defconstant +x-setfontpath+ 51) (defconstant +x-getfontpath+ 52) (defconstant +x-createpixmap+ 53) (defconstant +x-freepixmap+ 54) (defconstant +x-creategc+ 55) (defconstant +x-changegc+ 56) (defconstant +x-copygc+ 57) (defconstant +x-setdashes+ 58) (defconstant +x-setcliprectangles+ 59) (defconstant +x-freegc+ 60) (defconstant +x-cleartobackground+ 61) (defconstant +x-copyarea+ 62) (defconstant +x-copyplane+ 63) (defconstant +x-polypoint+ 64) (defconstant +x-polyline+ 65) (defconstant +x-polysegment+ 66) (defconstant +x-polyrectangle+ 67) (defconstant +x-polyarc+ 68) (defconstant +x-fillpoly+ 69) (defconstant +x-polyfillrectangle+ 70) (defconstant +x-polyfillarc+ 71) (defconstant +x-putimage+ 72) (defconstant +x-getimage+ 73) (defconstant +x-polytext8+ 74) (defconstant +x-polytext16+ 75) (defconstant +x-imagetext8+ 76) (defconstant +x-imagetext16+ 77) (defconstant +x-createcolormap+ 78) (defconstant +x-freecolormap+ 79) (defconstant +x-copycolormapandfree+ 80) (defconstant +x-installcolormap+ 81) (defconstant +x-uninstallcolormap+ 82) (defconstant +x-listinstalledcolormaps+ 83) (defconstant +x-alloccolor+ 84) (defconstant +x-allocnamedcolor+ 85) (defconstant +x-alloccolorcells+ 86) (defconstant +x-alloccolorplanes+ 87) (defconstant +x-freecolors+ 88) (defconstant +x-storecolors+ 89) (defconstant +x-storenamedcolor+ 90) (defconstant +x-querycolors+ 91) (defconstant +x-lookupcolor+ 92) (defconstant +x-createcursor+ 93) (defconstant +x-createglyphcursor+ 94) (defconstant +x-freecursor+ 95) (defconstant +x-recolorcursor+ 96) (defconstant +x-querybestsize+ 97) (defconstant +x-queryextension+ 98) (defconstant +x-listextensions+ 99) (defconstant +x-setkeyboardmapping+ 100) (defconstant +x-getkeyboardmapping+ 101) (defconstant +x-changekeyboardcontrol+ 102) (defconstant +x-getkeyboardcontrol+ 103) (defconstant +x-bell+ 104) (defconstant +x-changepointercontrol+ 105) (defconstant +x-getpointercontrol+ 106) (defconstant +x-setscreensaver+ 107) (defconstant +x-getscreensaver+ 108) (defconstant +x-changehosts+ 109) (defconstant +x-listhosts+ 110) (defconstant +x-changeaccesscontrol+ 111) (defconstant +x-changeclosedownmode+ 112) (defconstant +x-killclient+ 113) (defconstant +x-rotateproperties+ 114) (defconstant +x-forcescreensaver+ 115) (defconstant +x-setpointermapping+ 116) (defconstant +x-getpointermapping+ 117) (defconstant +x-setmodifiermapping+ 118) (defconstant +x-getmodifiermapping+ 119) (defconstant +x-nooperation+ 127) ;;; Some macros for threaded lists (defmacro threaded-atomic-push (item list next type) (let ((x (gensym)) (y (gensym))) `(let ((,x ,item)) (declare (type ,type ,x)) (loop (let ((,y ,list)) (declare (type (or null ,type) ,y) (optimize (speed 3) (safety 0))) (setf (,next ,x) ,y) (when (conditional-store ,list ,y ,x) (return ,x))))))) (defmacro threaded-atomic-pop (list next type) (let ((y (gensym))) `(loop (let ((,y ,list)) (declare (type (or null ,type) ,y) (optimize (speed 3) (safety 0))) (if (null ,y) (return nil) (when (conditional-store ,list ,y (,next (the ,type ,y))) (setf (,next (the ,type ,y)) nil) (return ,y))))))) (defmacro threaded-nconc (item list next type) (let ((first (gensym)) (x (gensym)) (y (gensym)) (z (gensym))) `(let ((,z ,item) (,first ,list)) (declare (type ,type ,z) (type (or null ,type) ,first) (optimize (speed 3) (safety 0))) (if (null ,first) (setf ,list ,z) (do* ((,x ,first ,y) (,y (,next ,x) (,next ,x))) ((null ,y) (setf (,next ,x) ,z) ,first) (declare (type ,type ,x) (type (or null ,type) ,y))))))) (defmacro threaded-push (item list next type) (let ((x (gensym))) `(let ((,x ,item)) (declare (type ,type ,x) (optimize (speed 3) (safety 0))) (shiftf (,next ,x) ,list ,x) ,x))) (defmacro threaded-pop (list next type) (let ((x (gensym))) `(let ((,x ,list)) (declare (type (or null ,type) ,x) (optimize (speed 3) (safety 0))) (when ,x (shiftf ,list (,next (the ,type ,x)) nil)) ,x))) (defmacro threaded-enqueue (item head tail next type) (let ((x (gensym))) `(let ((,x ,item)) (declare (type ,type ,x) (optimize (speed 3) (safety 0))) (if (null ,tail) (threaded-nconc ,x ,head ,next ,type) (threaded-nconc ,x (,next (the ,type ,tail)) ,next ,type)) (setf ,tail ,x)))) (defmacro threaded-dequeue (head tail next type) (let ((x (gensym))) `(let ((,x ,head)) (declare (type (or null ,type) ,x) (optimize (speed 3) (safety 0))) (when ,x (when (eq ,x ,tail) (setf ,tail (,next (the ,type ,x)))) (setf ,head (,next (the ,type ,x)))) ,x))) (defmacro threaded-requeue (item head tail next type) (let ((x (gensym))) `(let ((,x ,item)) (declare (type ,type ,x) (optimize (speed 3) (safety 0))) (if (null ,tail) (setf ,tail (setf ,head ,x)) (shiftf (,next ,x) ,head ,x)) ,x))) (defmacro threaded-dolist ((variable list next type) &body body) `(block nil (do* ((,variable ,list (,next (the ,type ,variable)))) ((null ,variable)) (declare (type (or null ,type) ,variable)) ,@body))) (defmacro threaded-delete (item list next type) (let ((x (gensym)) (y (gensym)) (z (gensym)) (first (gensym))) `(let ((,x ,item) (,first ,list)) (declare (type ,type ,x) (type (or null ,type) ,first) (optimize (speed 3) (safety 0))) (when ,first (if (eq ,first ,x) (setf ,first (setf ,list (,next ,x))) (do* ((,y ,first ,z) (,z (,next ,y) (,next ,y))) ((or (null ,z) (eq ,z ,x)) (when (eq ,z ,x) (setf (,next ,y) (,next ,x)))) (declare (type ,type ,y)) (declare (type (or null ,type) ,z))))) (setf (,next ,x) nil) ,first))) (defmacro threaded-length (list next type) (let ((x (gensym)) (count (gensym))) `(do ((,x ,list (,next (the ,type ,x))) (,count 0 (index1+ ,count))) ((null ,x) ,count) (declare (type (or null ,type) ,x) (type array-index ,count) (optimize (speed 3) (safety 0)))))) ecl-16.1.2/src/clx/manager.lisp000066400000000000000000001110001266352375300162310ustar00rootroot00000000000000;;; -*- Mode:Lisp; Package:XLIB; Syntax:COMMON-LISP; Base:10; Lowercase:T -*- ;;; Window Manager Property functions ;;; ;;; TEXAS INSTRUMENTS INCORPORATED ;;; P.O. BOX 2909 ;;; AUSTIN, TEXAS 78769 ;;; ;;; Copyright (C) 1987 Texas Instruments Incorporated. ;;; ;;; Permission is granted to any individual or institution to use, copy, modify, ;;; and distribute this software, provided that this complete copyright and ;;; permission notice is maintained, intact, in all copies and supporting ;;; documentation. ;;; ;;; Texas Instruments Incorporated provides this software "as is" without ;;; express or implied warranty. ;;; (in-package :xlib) (defun wm-name (window) (declare (type window window)) (declare (clx-values string)) (get-property window :WM_NAME :type :STRING :result-type 'string :transform #'card8->char)) (defsetf wm-name (window) (name) `(set-string-property ,window :WM_NAME ,name)) (defun set-string-property (window property string) (declare (type window window) (type keyword property) (type stringable string)) (change-property window property (string string) :STRING 8 :transform #'char->card8) string) (defun wm-icon-name (window) (declare (type window window)) (declare (clx-values string)) (get-property window :WM_ICON_NAME :type :STRING :result-type 'string :transform #'card8->char)) (defsetf wm-icon-name (window) (name) `(set-string-property ,window :WM_ICON_NAME ,name)) (defun wm-client-machine (window) (declare (type window window)) (declare (clx-values string)) (get-property window :WM_CLIENT_MACHINE :type :STRING :result-type 'string :transform #'card8->char)) (defsetf wm-client-machine (window) (name) `(set-string-property ,window :WM_CLIENT_MACHINE ,name)) (defun get-wm-class (window) (declare (type window window)) (declare (clx-values (or null name-string) (or null class-string))) (let ((value (get-property window :WM_CLASS :type :STRING :result-type '(vector card8)))) (declare (type (or null (vector card8)) value)) (when value (let* ((name-len (position 0 (the (vector card8) value))) (name (subseq (the (vector card8) value) 0 name-len)) (class (when name-len (subseq (the (vector card8) value) (1+ name-len) (position 0 (the (vector card8) value) :start (1+ name-len)))))) (values (and (plusp (length name)) (map 'string #'card8->char name)) (and (plusp (length class)) (map 'string #'card8->char class))))))) (defun set-wm-class (window resource-name resource-class) (declare (type window window) (type (or null stringable) resource-name resource-class)) (change-property window :WM_CLASS (concatenate '(vector card8) (map '(vector card8) #'char->card8 (string (or resource-name ""))) #(0) (map '(vector card8) #'char->card8 (string (or resource-class ""))) #(0)) :string 8) (values)) (defun wm-command (window) ;; Returns a list whose car is the command and ;; whose cdr is the list of arguments (declare (type window window)) (declare (clx-values list)) (do* ((command-string (get-property window :WM_COMMAND :type :STRING :result-type '(vector card8))) (command nil) (start 0 (1+ end)) (end 0) (len (length command-string))) ((>= start len) (nreverse command)) (setq end (position 0 command-string :start start)) (push (map 'string #'card8->char (subseq command-string start end)) command))) (defsetf wm-command set-wm-command) (defun set-wm-command (window command) ;; Uses PRIN1 inside the ANSI common lisp form WITH-STANDARD-IO-SYNTAX (or ;; equivalent), with elements of command separated by NULL characters. This ;; enables ;; (with-standard-io-syntax (mapcar #'read-from-string (wm-command window))) ;; to recover a lisp command. (declare (type window window) (type list command)) (change-property window :WM_COMMAND (apply #'concatenate '(vector card8) (mapcan #'(lambda (c) (list (map '(vector card8) #'char->card8 (with-output-to-string (stream) (with-standard-io-syntax (prin1 c stream)))) #(0))) command)) :string 8) command) ;;----------------------------------------------------------------------------- ;; WM_HINTS (def-clx-class (wm-hints) (input nil :type (or null (member :off :on))) (initial-state nil :type (or null (member :dont-care :normal :zoom :iconic :inactive))) (icon-pixmap nil :type (or null pixmap)) (icon-window nil :type (or null window)) (icon-x nil :type (or null card16)) (icon-y nil :type (or null card16)) (icon-mask nil :type (or null pixmap)) (window-group nil :type (or null resource-id)) (flags 0 :type card32) ;; Extension-hook. Exclusive-Or'ed with the FLAGS field ;; may be extended in the future ) (defun wm-hints (window) (declare (type window window)) (declare (clx-values wm-hints)) (let ((prop (get-property window :WM_HINTS :type :WM_HINTS :result-type 'vector))) (when prop (decode-wm-hints prop (window-display window))))) (defsetf wm-hints set-wm-hints) (defun set-wm-hints (window wm-hints) (declare (type window window) (type wm-hints wm-hints)) (declare (clx-values wm-hints)) (change-property window :WM_HINTS (encode-wm-hints wm-hints) :WM_HINTS 32) wm-hints) (defun decode-wm-hints (vector display) (declare (type (simple-vector 9) vector) (type display display)) (declare (clx-values wm-hints)) (let ((input-hint 0) (state-hint 1) (icon-pixmap-hint 2) (icon-window-hint 3) (icon-position-hint 4) (icon-mask-hint 5) (window-group-hint 6)) (let ((flags (aref vector 0)) (hints (make-wm-hints)) (%buffer display)) (declare (type card32 flags) (type wm-hints hints) (type display %buffer)) (setf (wm-hints-flags hints) flags) (when (logbitp input-hint flags) (setf (wm-hints-input hints) (decode-type (member :off :on) (aref vector 1)))) (when (logbitp state-hint flags) (setf (wm-hints-initial-state hints) (decode-type (member :dont-care :normal :zoom :iconic :inactive) (aref vector 2)))) (when (logbitp icon-pixmap-hint flags) (setf (wm-hints-icon-pixmap hints) (decode-type pixmap (aref vector 3)))) (when (logbitp icon-window-hint flags) (setf (wm-hints-icon-window hints) (decode-type window (aref vector 4)))) (when (logbitp icon-position-hint flags) (setf (wm-hints-icon-x hints) (aref vector 5) (wm-hints-icon-y hints) (aref vector 6))) (when (logbitp icon-mask-hint flags) (setf (wm-hints-icon-mask hints) (decode-type pixmap (aref vector 7)))) (when (and (logbitp window-group-hint flags) (> (length vector) 7)) (setf (wm-hints-window-group hints) (aref vector 8))) hints))) (defun encode-wm-hints (wm-hints) (declare (type wm-hints wm-hints)) (declare (clx-values simple-vector)) (let ((input-hint #b1) (state-hint #b10) (icon-pixmap-hint #b100) (icon-window-hint #b1000) (icon-position-hint #b10000) (icon-mask-hint #b100000) (window-group-hint #b1000000) (mask #b1111111) ) (let ((vector (make-array 9 :initial-element 0)) (flags 0)) (declare (type (simple-vector 9) vector) (type card16 flags)) (when (wm-hints-input wm-hints) (setf flags input-hint (aref vector 1) (encode-type (member :off :on) (wm-hints-input wm-hints)))) (when (wm-hints-initial-state wm-hints) (setf flags (logior flags state-hint) (aref vector 2) (encode-type (member :dont-care :normal :zoom :iconic :inactive) (wm-hints-initial-state wm-hints)))) (when (wm-hints-icon-pixmap wm-hints) (setf flags (logior flags icon-pixmap-hint) (aref vector 3) (encode-type pixmap (wm-hints-icon-pixmap wm-hints)))) (when (wm-hints-icon-window wm-hints) (setf flags (logior flags icon-window-hint) (aref vector 4) (encode-type window (wm-hints-icon-window wm-hints)))) (when (and (wm-hints-icon-x wm-hints) (wm-hints-icon-y wm-hints)) (setf flags (logior flags icon-position-hint) (aref vector 5) (encode-type card16 (wm-hints-icon-x wm-hints)) (aref vector 6) (encode-type card16 (wm-hints-icon-y wm-hints)))) (when (wm-hints-icon-mask wm-hints) (setf flags (logior flags icon-mask-hint) (aref vector 7) (encode-type pixmap (wm-hints-icon-mask wm-hints)))) (when (wm-hints-window-group wm-hints) (setf flags (logior flags window-group-hint) (aref vector 8) (wm-hints-window-group wm-hints))) (setf (aref vector 0) (logior flags (logandc2 (wm-hints-flags wm-hints) mask))) vector))) ;;----------------------------------------------------------------------------- ;; WM_SIZE_HINTS (def-clx-class (wm-size-hints) (user-specified-position-p nil :type generalized-boolean) ;; True when user specified x y (user-specified-size-p nil :type generalized-boolean) ;; True when user specified width height ;; the next four fields are obsolete when using a modern window manager ;; (that will use min-width and friends instead), but they should be set by ;; clients in case an old window manager is used (x nil :type (or null int32)) (y nil :type (or null int32)) (width nil :type (or null card32)) (height nil :type (or null card32)) (min-width nil :type (or null card32)) (min-height nil :type (or null card32)) (max-width nil :type (or null card32)) (max-height nil :type (or null card32)) (width-inc nil :type (or null card32)) (height-inc nil :type (or null card32)) (min-aspect nil :type (or null number)) (max-aspect nil :type (or null number)) (base-width nil :type (or null card32)) (base-height nil :type (or null card32)) (win-gravity nil :type (or null win-gravity)) (program-specified-position-p nil :type generalized-boolean) ;; True when program specified x y (program-specified-size-p nil :type generalized-boolean) ;; True when program specified width height ) (defun wm-normal-hints (window) (declare (type window window)) (declare (clx-values wm-size-hints)) (decode-wm-size-hints (get-property window :WM_NORMAL_HINTS :type :WM_SIZE_HINTS :result-type 'vector))) (defsetf wm-normal-hints set-wm-normal-hints) (defun set-wm-normal-hints (window hints) (declare (type window window) (type wm-size-hints hints)) (declare (clx-values wm-size-hints)) (change-property window :WM_NORMAL_HINTS (encode-wm-size-hints hints) :WM_SIZE_HINTS 32) hints) ;;; OBSOLETE (defun wm-zoom-hints (window) (declare (type window window)) (declare (clx-values wm-size-hints)) (decode-wm-size-hints (get-property window :WM_ZOOM_HINTS :type :WM_SIZE_HINTS :result-type 'vector))) ;;; OBSOLETE (defsetf wm-zoom-hints set-wm-zoom-hints) ;;; OBSOLETE (defun set-wm-zoom-hints (window hints) (declare (type window window) (type wm-size-hints hints)) (declare (clx-values wm-size-hints)) (change-property window :WM_ZOOM_HINTS (encode-wm-size-hints hints) :WM_SIZE_HINTS 32) hints) (defun decode-wm-size-hints (vector) (declare (type (or null (simple-vector *)) vector)) (declare (clx-values (or null wm-size-hints))) (when vector (let ((flags (aref vector 0)) (hints (make-wm-size-hints))) (declare (type card16 flags) (type wm-size-hints hints)) (setf (wm-size-hints-user-specified-position-p hints) (logbitp 0 flags)) (setf (wm-size-hints-user-specified-size-p hints) (logbitp 1 flags)) (setf (wm-size-hints-program-specified-position-p hints) (logbitp 2 flags)) (setf (wm-size-hints-program-specified-size-p hints) (logbitp 3 flags)) (when (logbitp 4 flags) (setf (wm-size-hints-min-width hints) (aref vector 5) (wm-size-hints-min-height hints) (aref vector 6))) (when (logbitp 5 flags) (setf (wm-size-hints-max-width hints) (aref vector 7) (wm-size-hints-max-height hints) (aref vector 8))) (when (logbitp 6 flags) (setf (wm-size-hints-width-inc hints) (aref vector 9) (wm-size-hints-height-inc hints) (aref vector 10))) (when (logbitp 7 flags) (setf (wm-size-hints-min-aspect hints) (/ (aref vector 11) (aref vector 12)) (wm-size-hints-max-aspect hints) (/ (aref vector 13) (aref vector 14)))) (when (> (length vector) 15) ;; This test is for backwards compatibility since old Xlib programs ;; can set a size-hints structure that is too small. See ICCCM. (when (logbitp 8 flags) (setf (wm-size-hints-base-width hints) (aref vector 15) (wm-size-hints-base-height hints) (aref vector 16))) (when (logbitp 9 flags) (setf (wm-size-hints-win-gravity hints) (decode-type (member-vector +win-gravity-vector+) (aref vector 17))))) ;; Obsolete fields (when (or (logbitp 0 flags) (logbitp 2 flags)) (setf (wm-size-hints-x hints) (card32->int32 (aref vector 1)) (wm-size-hints-y hints) (card32->int32 (aref vector 2)))) (when (or (logbitp 1 flags) (logbitp 3 flags)) (setf (wm-size-hints-width hints) (aref vector 3) (wm-size-hints-height hints) (aref vector 4))) hints))) (defun encode-wm-size-hints (hints) (declare (type wm-size-hints hints)) (declare (clx-values simple-vector)) (let ((vector (make-array 18 :initial-element 0)) (flags 0)) (declare (type (simple-vector 18) vector) (type card16 flags)) (when (wm-size-hints-user-specified-position-p hints) (setf (ldb (byte 1 0) flags) 1)) (when (wm-size-hints-user-specified-size-p hints) (setf (ldb (byte 1 1) flags) 1)) (when (wm-size-hints-program-specified-position-p hints) (setf (ldb (byte 1 2) flags) 1)) (when (wm-size-hints-program-specified-size-p hints) (setf (ldb (byte 1 3) flags) 1)) (when (and (wm-size-hints-min-width hints) (wm-size-hints-min-height hints)) (setf (ldb (byte 1 4) flags) 1 (aref vector 5) (wm-size-hints-min-width hints) (aref vector 6) (wm-size-hints-min-height hints))) (when (and (wm-size-hints-max-width hints) (wm-size-hints-max-height hints)) (setf (ldb (byte 1 5) flags) 1 (aref vector 7) (wm-size-hints-max-width hints) (aref vector 8) (wm-size-hints-max-height hints))) (when (and (wm-size-hints-width-inc hints) (wm-size-hints-height-inc hints)) (setf (ldb (byte 1 6) flags) 1 (aref vector 9) (wm-size-hints-width-inc hints) (aref vector 10) (wm-size-hints-height-inc hints))) (let ((min-aspect (wm-size-hints-min-aspect hints)) (max-aspect (wm-size-hints-max-aspect hints))) (when (and min-aspect max-aspect) (setf (ldb (byte 1 7) flags) 1 min-aspect (rationalize min-aspect) max-aspect (rationalize max-aspect) (aref vector 11) (numerator min-aspect) (aref vector 12) (denominator min-aspect) (aref vector 13) (numerator max-aspect) (aref vector 14) (denominator max-aspect)))) (when (and (wm-size-hints-base-width hints) (wm-size-hints-base-height hints)) (setf (ldb (byte 1 8) flags) 1 (aref vector 15) (wm-size-hints-base-width hints) (aref vector 16) (wm-size-hints-base-height hints))) (when (wm-size-hints-win-gravity hints) (setf (ldb (byte 1 9) flags) 1 (aref vector 17) (encode-type (member-vector +win-gravity-vector+) (wm-size-hints-win-gravity hints)))) ;; Obsolete fields (when (and (wm-size-hints-x hints) (wm-size-hints-y hints)) (unless (wm-size-hints-user-specified-position-p hints) (setf (ldb (byte 1 2) flags) 1)) (setf (aref vector 1) (wm-size-hints-x hints) (aref vector 2) (wm-size-hints-y hints))) (when (and (wm-size-hints-width hints) (wm-size-hints-height hints)) (unless (wm-size-hints-user-specified-size-p hints) (setf (ldb (byte 1 3) flags) 1)) (setf (aref vector 3) (wm-size-hints-width hints) (aref vector 4) (wm-size-hints-height hints))) (setf (aref vector 0) flags) vector)) ;;----------------------------------------------------------------------------- ;; Icon_Size ;; Use the same intermediate structure as WM_SIZE_HINTS (defun icon-sizes (window) (declare (type window window)) (declare (clx-values wm-size-hints)) (let ((vector (get-property window :WM_ICON_SIZE :type :WM_ICON_SIZE :result-type 'vector))) (declare (type (or null (simple-vector 6)) vector)) (when vector (make-wm-size-hints :min-width (aref vector 0) :min-height (aref vector 1) :max-width (aref vector 2) :max-height (aref vector 3) :width-inc (aref vector 4) :height-inc (aref vector 5))))) (defsetf icon-sizes set-icon-sizes) (defun set-icon-sizes (window wm-size-hints) (declare (type window window) (type wm-size-hints wm-size-hints)) (let ((vector (vector (wm-size-hints-min-width wm-size-hints) (wm-size-hints-min-height wm-size-hints) (wm-size-hints-max-width wm-size-hints) (wm-size-hints-max-height wm-size-hints) (wm-size-hints-width-inc wm-size-hints) (wm-size-hints-height-inc wm-size-hints)))) (change-property window :WM_ICON_SIZE vector :WM_ICON_SIZE 32) wm-size-hints)) ;;----------------------------------------------------------------------------- ;; WM-Protocols (defun wm-protocols (window) (map 'list #'(lambda (id) (atom-name (window-display window) id)) (get-property window :WM_PROTOCOLS :type :ATOM))) (defsetf wm-protocols set-wm-protocols) (defun set-wm-protocols (window protocols) (change-property window :WM_PROTOCOLS (map 'list #'(lambda (atom) (intern-atom (window-display window) atom)) protocols) :ATOM 32) protocols) ;;----------------------------------------------------------------------------- ;; WM-Colormap-windows (defun wm-colormap-windows (window) (values (get-property window :WM_COLORMAP_WINDOWS :type :WINDOW :transform #'(lambda (id) (lookup-window (window-display window) id))))) (defsetf wm-colormap-windows set-wm-colormap-windows) (defun set-wm-colormap-windows (window colormap-windows) (change-property window :WM_COLORMAP_WINDOWS colormap-windows :WINDOW 32 :transform #'window-id) colormap-windows) ;;----------------------------------------------------------------------------- ;; Transient-For (defun transient-for (window) (let ((prop (get-property window :WM_TRANSIENT_FOR :type :WINDOW :result-type 'list))) (and prop (lookup-window (window-display window) (car prop))))) (defsetf transient-for set-transient-for) (defun set-transient-for (window transient) (declare (type window window transient)) (change-property window :WM_TRANSIENT_FOR (list (window-id transient)) :WINDOW 32) transient) ;;----------------------------------------------------------------------------- ;; Set-WM-Properties (defun set-wm-properties (window &rest options &key name icon-name resource-name resource-class command client-machine hints normal-hints zoom-hints ;; the following are used for wm-normal-hints (user-specified-position-p nil usppp) (user-specified-size-p nil usspp) (program-specified-position-p nil psppp) (program-specified-size-p nil psspp) x y width height min-width min-height max-width max-height width-inc height-inc min-aspect max-aspect base-width base-height win-gravity ;; the following are used for wm-hints input initial-state icon-pixmap icon-window icon-x icon-y icon-mask window-group) ;; Set properties for WINDOW. (declare (arglist window &rest options &key name icon-name resource-name resource-class command client-machine hints normal-hints ;; the following are used for wm-normal-hints user-specified-position-p user-specified-size-p program-specified-position-p program-specified-size-p min-width min-height max-width max-height width-inc height-inc min-aspect max-aspect base-width base-height win-gravity ;; the following are used for wm-hints input initial-state icon-pixmap icon-window icon-x icon-y icon-mask window-group)) (declare (type window window) (type (or null stringable) name icon-name resource-name resource-class client-machine) (type (or null list) command) (type (or null wm-hints) hints) (type (or null wm-size-hints) normal-hints zoom-hints) (type generalized-boolean user-specified-position-p user-specified-size-p) (type generalized-boolean program-specified-position-p program-specified-size-p) (type (or null int32) x y) (type (or null card32) width height min-width min-height max-width max-height width-inc height-inc base-width base-height) (type (or null win-gravity) win-gravity) (type (or null number) min-aspect max-aspect) (type (or null (member :off :on)) input) (type (or null (member :dont-care :normal :zoom :iconic :inactive)) initial-state) (type (or null pixmap) icon-pixmap icon-mask) (type (or null window) icon-window) (type (or null card32) icon-x icon-y) (type (or null resource-id) window-group) (dynamic-extent options)) (when name (setf (wm-name window) name)) (when icon-name (setf (wm-icon-name window) icon-name)) (when client-machine (setf (wm-client-machine window) client-machine)) (when (or resource-name resource-class) (set-wm-class window resource-name resource-class)) (when command (setf (wm-command window) command)) ;; WM-HINTS (if (dolist (arg '(:input :initial-state :icon-pixmap :icon-window :icon-x :icon-y :icon-mask :window-group)) (when (getf options arg) (return t))) (let ((wm-hints (if hints (copy-wm-hints hints) (make-wm-hints)))) (when input (setf (wm-hints-input wm-hints) input)) (when initial-state (setf (wm-hints-initial-state wm-hints) initial-state)) (when icon-pixmap (setf (wm-hints-icon-pixmap wm-hints) icon-pixmap)) (when icon-window (setf (wm-hints-icon-window wm-hints) icon-window)) (when icon-x (setf (wm-hints-icon-x wm-hints) icon-x)) (when icon-y (setf (wm-hints-icon-y wm-hints) icon-y)) (when icon-mask (setf (wm-hints-icon-mask wm-hints) icon-mask)) (when window-group (setf (wm-hints-window-group wm-hints) window-group)) (setf (wm-hints window) wm-hints)) (when hints (setf (wm-hints window) hints))) ;; WM-NORMAL-HINTS (if (dolist (arg '(:x :y :width :height :min-width :min-height :max-width :max-height :width-inc :height-inc :min-aspect :max-aspect :user-specified-position-p :user-specified-size-p :program-specified-position-p :program-specified-size-p :base-width :base-height :win-gravity)) (when (getf options arg) (return t))) (let ((size (if normal-hints (copy-wm-size-hints normal-hints) (make-wm-size-hints)))) (when x (setf (wm-size-hints-x size) x)) (when y (setf (wm-size-hints-y size) y)) (when width (setf (wm-size-hints-width size) width)) (when height (setf (wm-size-hints-height size) height)) (when min-width (setf (wm-size-hints-min-width size) min-width)) (when min-height (setf (wm-size-hints-min-height size) min-height)) (when max-width (setf (wm-size-hints-max-width size) max-width)) (when max-height (setf (wm-size-hints-max-height size) max-height)) (when width-inc (setf (wm-size-hints-width-inc size) width-inc)) (when height-inc (setf (wm-size-hints-height-inc size) height-inc)) (when min-aspect (setf (wm-size-hints-min-aspect size) min-aspect)) (when max-aspect (setf (wm-size-hints-max-aspect size) max-aspect)) (when base-width (setf (wm-size-hints-base-width size) base-width)) (when base-height (setf (wm-size-hints-base-height size) base-height)) (when win-gravity (setf (wm-size-hints-win-gravity size) win-gravity)) (when usppp (setf (wm-size-hints-user-specified-position-p size) user-specified-position-p)) (when usspp (setf (wm-size-hints-user-specified-size-p size) user-specified-size-p)) (when psppp (setf (wm-size-hints-program-specified-position-p size) program-specified-position-p)) (when psspp (setf (wm-size-hints-program-specified-size-p size) program-specified-size-p)) (setf (wm-normal-hints window) size)) (when normal-hints (setf (wm-normal-hints window) normal-hints))) (when zoom-hints (setf (wm-zoom-hints window) zoom-hints)) ) ;;; OBSOLETE (defun set-standard-properties (window &rest options) (declare (dynamic-extent options)) (apply #'set-wm-properties window options)) ;;----------------------------------------------------------------------------- ;; WM Control (defun iconify-window (window screen) (declare (type window window) (type screen screen)) (let ((root (screen-root screen))) (declare (type window root)) (send-event root :client-message '(:substructure-redirect :substructure-notify) :window window :format 32 :type :WM_CHANGE_STATE :data (list 3)))) (defun withdraw-window (window screen) (declare (type window window) (type screen screen)) (unmap-window window) (let ((root (screen-root screen))) (declare (type window root)) (send-event root :unmap-notify '(:substructure-redirect :substructure-notify) :window window :event-window root :configure-p nil))) ;;----------------------------------------------------------------------------- ;; Colormaps (def-clx-class (standard-colormap (:copier nil) (:predicate nil)) (colormap nil :type (or null colormap)) (base-pixel 0 :type pixel) (max-color nil :type (or null color)) (mult-color nil :type (or null color)) (visual nil :type (or null visual-info)) (kill nil :type (or (member nil :release-by-freeing-colormap) drawable gcontext cursor colormap font))) (defun rgb-colormaps (window property) (declare (type window window) (type (member :RGB_DEFAULT_MAP :RGB_BEST_MAP :RGB_RED_MAP :RGB_GREEN_MAP :RGB_BLUE_MAP) property)) (let ((prop (get-property window property :type :RGB_COLOR_MAP :result-type 'vector))) (declare (type (or null simple-vector) prop)) (when prop (list (make-standard-colormap :colormap (lookup-colormap (window-display window) (aref prop 0)) :base-pixel (aref prop 7) :max-color (make-color :red (card16->rgb-val (aref prop 1)) :green (card16->rgb-val (aref prop 3)) :blue (card16->rgb-val (aref prop 5))) :mult-color (make-color :red (card16->rgb-val (aref prop 2)) :green (card16->rgb-val (aref prop 4)) :blue (card16->rgb-val (aref prop 6))) :visual (and (<= 9 (length prop)) (visual-info (window-display window) (aref prop 8))) :kill (and (<= 10 (length prop)) (let ((killid (aref prop 9))) (if (= killid 1) :release-by-freeing-colormap (lookup-resource-id (window-display window) killid))))))))) (defsetf rgb-colormaps set-rgb-colormaps) (defun set-rgb-colormaps (window property maps) (declare (type window window) (type (member :RGB_DEFAULT_MAP :RGB_BEST_MAP :RGB_RED_MAP :RGB_GREEN_MAP :RGB_BLUE_MAP) property) (type list maps)) (let ((prop (make-array (* 10 (length maps)) :element-type 'card32)) (index -1)) (dolist (map maps) (setf (aref prop (incf index)) (encode-type colormap (standard-colormap-colormap map))) (setf (aref prop (incf index)) (encode-type rgb-val (color-red (standard-colormap-max-color map)))) (setf (aref prop (incf index)) (encode-type rgb-val (color-red (standard-colormap-mult-color map)))) (setf (aref prop (incf index)) (encode-type rgb-val (color-green (standard-colormap-max-color map)))) (setf (aref prop (incf index)) (encode-type rgb-val (color-green (standard-colormap-mult-color map)))) (setf (aref prop (incf index)) (encode-type rgb-val (color-blue (standard-colormap-max-color map)))) (setf (aref prop (incf index)) (encode-type rgb-val (color-blue (standard-colormap-mult-color map)))) (setf (aref prop (incf index)) (standard-colormap-base-pixel map)) (setf (aref prop (incf index)) (visual-info-id (standard-colormap-visual map))) (setf (aref prop (incf index)) (let ((kill (standard-colormap-kill map))) (etypecase kill (symbol (ecase kill ((nil) 0) ((:release-by-freeing-colormap) 1))) (drawable (drawable-id kill)) (gcontext (gcontext-id kill)) (cursor (cursor-id kill)) (colormap (colormap-id kill)) (font (font-id kill)))))) (change-property window property prop :RGB_COLOR_MAP 32))) ;;; OBSOLETE (defun get-standard-colormap (window property) (declare (type window window) (type (member :RGB_DEFAULT_MAP :RGB_BEST_MAP :RGB_RED_MAP :RGB_GREEN_MAP :RGB_BLUE_MAP) property)) (declare (clx-values colormap base-pixel max-color mult-color)) (let ((prop (get-property window property :type :RGB_COLOR_MAP :result-type 'vector))) (declare (type (or null simple-vector) prop)) (when prop (values (lookup-colormap (window-display window) (aref prop 0)) (aref prop 7) ;Base Pixel (make-color :red (card16->rgb-val (aref prop 1)) ;Max Color :green (card16->rgb-val (aref prop 3)) :blue (card16->rgb-val (aref prop 5))) (make-color :red (card16->rgb-val (aref prop 2)) ;Mult color :green (card16->rgb-val (aref prop 4)) :blue (card16->rgb-val (aref prop 6))))))) ;;; OBSOLETE (defun set-standard-colormap (window property colormap base-pixel max-color mult-color) (declare (type window window) (type (member :RGB_DEFAULT_MAP :RGB_BEST_MAP :RGB_RED_MAP :RGB_GREEN_MAP :RGB_BLUE_MAP) property) (type colormap colormap) (type pixel base-pixel) (type color max-color mult-color)) (let ((prop (vector (encode-type colormap colormap) (encode-type rgb-val (color-red max-color)) (encode-type rgb-val (color-red mult-color)) (encode-type rgb-val (color-green max-color)) (encode-type rgb-val (color-green mult-color)) (encode-type rgb-val (color-blue max-color)) (encode-type rgb-val (color-blue mult-color)) base-pixel))) (change-property window property prop :RGB_COLOR_MAP 32))) ;;----------------------------------------------------------------------------- ;; Cut-Buffers (defun cut-buffer (display &key (buffer 0) (type :STRING) (result-type 'string) (transform #'card8->char) (start 0) end) ;; Return the contents of cut-buffer BUFFER (declare (type display display) (type (integer 0 7) buffer) (type xatom type) (type array-index start) (type (or null array-index) end) (type t result-type) ;a sequence type (type (or null (function (integer) t)) transform)) (declare (clx-values sequence type format bytes-after)) (let* ((root (screen-root (first (display-roots display)))) (property (aref '#(:CUT_BUFFER0 :CUT_BUFFER1 :CUT_BUFFER2 :CUT_BUFFER3 :CUT_BUFFER4 :CUT_BUFFER5 :CUT_BUFFER6 :CUT_BUFFER7) buffer))) (get-property root property :type type :result-type result-type :start start :end end :transform transform))) ;; Implement the following: ;; (defsetf cut-buffer (display &key (buffer 0) (type :string) (format 8) ;; (transform #'char->card8) (start 0) end) (data) ;; In order to avoid having to pass positional parameters to set-cut-buffer, ;; We've got to do the following. WHAT A PAIN... #-clx-ansi-common-lisp (define-setf-method cut-buffer (display &rest option-list) (declare (dynamic-extent option-list)) (do* ((options (copy-list option-list)) (option options (cddr option)) (store (gensym)) (dtemp (gensym)) (temps (list dtemp)) (values (list display))) ((endp option) (values (nreverse temps) (nreverse values) (list store) `(set-cut-buffer ,store ,dtemp ,@options) `(cut-buffer ,@options))) (unless (member (car option) '(:buffer :type :format :start :end :transform)) (error "Keyword arg ~s isn't recognized" (car option))) (let ((x (gensym))) (push x temps) (push (cadr option) values) (setf (cadr option) x)))) (defun #+clx-ansi-common-lisp (setf cut-buffer) #-clx-ansi-common-lisp set-cut-buffer (data display &key (buffer 0) (type :STRING) (format 8) (start 0) end (transform #'char->card8)) (declare (type sequence data) (type display display) (type (integer 0 7) buffer) (type xatom type) (type (member 8 16 32) format) (type array-index start) (type (or null array-index) end) (type (or null (function (integer) t)) transform)) (let* ((root (screen-root (first (display-roots display)))) (property (aref '#(:CUT_BUFFER0 :CUT_BUFFER1 :CUT_BUFFER2 :CUT_BUFFER3 :CUT_BUFFER4 :CUT_BUFFER5 :CUT_BUFFER6 :CUT_BUFFER7) buffer))) (change-property root property data type format :transform transform :start start :end end) data)) (defun rotate-cut-buffers (display &optional (delta 1) (careful-p t)) ;; Positive rotates left, negative rotates right (opposite of actual protocol request). ;; When careful-p, ensure all cut-buffer properties are defined, to prevent errors. (declare (type display display) (type int16 delta) (type generalized-boolean careful-p)) (let* ((root (screen-root (first (display-roots display)))) (buffers '#(:cut_buffer0 :cut_buffer1 :cut_buffer2 :cut_buffer3 :cut_buffer4 :cut_buffer5 :cut_buffer6 :cut_buffer7))) (when careful-p (let ((props (list-properties root))) (dotimes (i 8) (unless (member (aref buffers i) props) (setf (cut-buffer display :buffer i) ""))))) (rotate-properties root buffers delta))) ecl-16.1.2/src/clx/manual/000077500000000000000000000000001266352375300152125ustar00rootroot00000000000000ecl-16.1.2/src/clx/manual/clx.texinfo000066400000000000000000020666311266352375300174140ustar00rootroot00000000000000\input texinfo @c -*-texinfo-*- @c $Id: clx.texinfo,v 1.3 2004/11/18 12:01:48 dan Exp $ @c %**start of header @setfilename clx.info @settitle Common LISP X Interface @setchapternewpage odd @c %**end of header @dircategory lisp @direntry * CLX: (clx). Common LISP X Interface @end direntry @copying The Common LISP X Interface (CLX) Copyright @copyright{} 1988, 1989 Texas Instruments Incorporated @quotation Permission is granted to any individual or institution to use, copy, modify and distribute this document, provided that this complete copyright and permission notice is maintained, intact, in all copies and supporting documentation. Texas Instruments Incorporated makes no representations about the suitability of this document or the software described herein for any purpose. It is provided "as is" without express or implied warranty. @end quotation @end copying @titlepage @title The Common Lisp X Interface (CLX) @page @vskip 0pt plus 1filll @insertcopying @end titlepage @contents @ifnottex @node Top, Acknowledgments, (dir), (dir) @top The Common LISP X Interface (CLX) @insertcopying @end ifnottex @menu * Acknowledgments:: * Introduction to CLX:: * Displays:: * Screens:: * Windows and Pixmaps:: * Graphics Contexts:: * Graphic Operations:: * Images:: * Font and Characters:: * Colors:: * Cursors:: * Atoms:: * Events and Input:: * Resources:: * Control Functions:: * Extensions:: * Errors:: * Undocumented:: * Glossary:: * Function Index:: * Type Index:: @detailmenu --- The Detailed Node Listing --- Introduction to CLX * The X Window System:: * A Quick Tour of CLX:: * Naming and Argument Conventions:: * Programming Considerations:: * Data Types:: The X Window System * Windows:: * Input Events:: A Quick Tour of CLX * A Simple Menu:: * Displaying the Menu:: * Menu Input:: * The Main Program:: * Debugging With CLX:: Displays * Opening the Display:: * Display Attributes:: * Managing the Output Buffer:: * Closing the Display:: Screens * Screens and Visuals:: * Screen Attributes:: Windows and Pixmaps * Drawables:: * Creating Windows:: * Window Attributes:: * Stacking Order:: * Window Hierarchy:: * Mapping Windows:: * Destroying Windows:: * Pixmaps:: Graphics Contexts * Creating Graphics Contexts:: * Graphics Context Attributes:: * Copying Graphics Contexts:: * Destroying Graphics Contexts:: * Graphics Context Cache:: Graphic Operations * Area and Plane Operations:: * Drawing Points:: * Drawing Lines:: * Drawing Rectangles:: * Drawing Arcs:: * Drawing Text:: Images * Image Types:: * Image Functions:: * Image Files:: * Direct Image Transfer:: Image Types * Basic Images:: * XY-Format Images:: * Z-Format Images:: Font and Characters * Opening Fonts:: * Listing Fonts:: * Font Attributes:: * Chracter Attributes:: * Querying Text Size:: Colors * Colormaps and Colors:: * Color Functions:: * Colormap Functions:: Colormap Functions * Creating Colormaps:: * Installing Colormaps:: * Allocating Colors:: * Finding Colors:: * Changing Colors:: * Colormap Attributes:: Cursors * Creating Cursors:: * Cursor Functions:: * Cursor Attributes:: Atoms, Properties and Selections * Atoms (Atoms):: * Properties:: * Selections:: Events and Input * Selecting Events:: * Processing Events:: * Managing the Event Queue:: * Sending Events:: * Pointer Position:: * Managing Input Focus:: * Grabbing the Pointer:: * Grabbing a Button:: * Grabbing the Keyboard:: * Grabbing a Key:: * Event Types:: * Releasing Queued Events:: Event Types * Keyboard and Pointer Events:: * Input Focus Events:: * Keyboard and Pointer State Events:: * Exposure Events:: * Window State Events:: * Structure Control Events:: * Client Communications Events:: * Declaring Event Types:: Resources * Resource Binings:: * Basic Resource Database Functions:: * Accessing Resource Values:: * Resource Database Files:: Accessing Resource Values * Complete Names and Classes:: * Matching Resource Names:: * Resource Access Functions:: Control Functions * Grabbing the Server:: * Pointer Control:: * Keyboard Control:: * Keyboard Encodings:: * Client Termination:: * Managing Host Access:: * Screen Saver:: Keyboard Encodings * Keycodes and Keysyms:: * Keyboard Mapping:: * Using Keycodes and Keysyms:: Extensions * Extensions (Extensions):: * SHAPE - The X11 Nonrectangular Window Shape Extension:: * RENDER - A new rendering system for X11:: * DPMS - The X11 Display Power Management Signaling Extension:: * BIG-REQUESTS - Big Requests Extension:: RENDER - A new rendering system for X11 * Picture formats:: * The picture object:: * Glyphs and Glyphsets:: * Using glyphs:: * Errors (Extensions):: Errors * Introduction (Errors):: @end detailmenu @end menu @node Acknowledgments, Introduction to CLX, Top, Top @chapter Acknowledgments Primary Interface Author: Robert W. Scheifler @display MIT Laboratory for Computer Science 545 Technology Square, Room 418 Cambridge, MA 02139 @email{rws@@zermatt.lcs.mit.edu} @end display Primary Implementation Author: LaMott Oren @display Texas Instruments PO Box 655474, MS 238 Dallas, TX 75265 @email{oren@@csc.ti.com} @end display Design Contributors: @itemize @bullet @item Dan Cerys, BBN @item Scott Fahlman, CMU @item Kerry Kimbrough, Texas Instruments @item Chris Lindblad, MIT @item Rob MacLachlan, CMU @item Mike McMahon, Symbolics @item David Moon, Symbolics @item LaMott Oren, Texas Instruments @item Daniel Weinreb, Symbolics @item John Wroclawski, MIT @item Richard Zippel, Symbolics @end itemize Documentation Contributors: @itemize @bullet @item Keith Cessna, Texas Instruments @item Kerry Kimbrough, Texas Instruments @item Mike Myjak @item LaMott Oren, Texas Instruments @item Dan Stenger, Texas Instruments @end itemize The X Window System is a trademark of MIT. UNIX is a trademark of AT&T Bell Laboratories. ULTRIX, ULTRIX-32, ULTRIX-32m, ULTRIX-32w, and VAX/VMS are trademarks of Digital Equipment Corporation. @node Introduction to CLX, Displays, Acknowledgments, Top @chapter Introduction to CLX This manual assumes a basic understanding of window systems and the Common Lisp programming language. To provide an introduction to the Common Lisp X Interface (CLX) programming, this section discusses the following: @itemize @bullet @item Overview of the X Window System @item Naming and argument conventions @item Programming considerations @end itemize @menu * The X Window System:: * A Quick Tour of CLX:: * Naming and Argument Conventions:: * Programming Considerations:: * Data Types:: @end menu @node The X Window System, A Quick Tour of CLX, Introduction to CLX, Introduction to CLX @section The X Window System The X Window System was developed at the Massachusetts Institute of Technology (MIT) and first released in 1985. Since then, the X Window System has become an industry-standard product available on virtually every type of bit-mapped workstation. The current version of X, Version 11, has been implemented for several different computer architectures, for a wide variety of display hardware, and also for many different operating systems. X Version 11 represents the fulfillment of the original design goals proposed by MIT, as follows: @table @asis @item Portable Support virtually any bitmap display and any interactive input device (including keyboards, mice, tablets, joysticks, and touch screens). Make it easy to implement the window system on different operating systems. @item Device-Independent Applications Avoid rewriting, recompiling, or even relinking in order to use different display/input hardware. Make it easy for an application to work on both monochrome and color hardware. @item Network Transparent Let an application run on one computer while using another computer's display, even if the other computer has a different operating system or hardware architecture. @item Multitasking Support multiple applications being displayed simultaneously. @item No User Interface Policy Since no one agrees on what constitutes the best user interface, make it possible for a broad range of user interface styles (or policies) to be implemented, external to the window system and to the application programs. @item Cheap Windows Windows should be abundant, and ubiquitous. Provide overlapping windows and a simple mechanism for window hierarchy. @item High-Performance Graphics Provide powerful interfaces for synthesizing 2-D images (geometric primitives, high-quality text with multiple typefaces, and scanned images). @item Extensible Include a mechanism for adding new capabilities. Allow separate sites to develop independent extensions without becoming incompatible with remote applications. @end table Some of these goals lead directly to the basic X architecture -- the client-server model. The basic window system is implemented by the X @emph{server} program. An application program (the @emph{client}) sends window system @emph{requests} to the X server through a reliable two-way byte-stream. In general, the server and the client can be executing on separate host computers, in which case the byte-stream is implemented via some network protocol (TCP, DECnet(tm), Chaosnet, and so forth). The X server, which is connected to several client programs running concurrently, executes client requests in round-robin fashion. The server is responsible for drawing client graphics on the display screen and for making sure that graphics output to a window stays inside its boundary. The other primary job of the X server is to channel input from the keyboard, pointer, and other input devices back to the appropriate client programs. Input arrives at the client asynchronously in the form of input @emph{events} representing up/down transitions of keys or pointer buttons, changes in the pointer position, and so on. In some cases, a request generates a return value (or @emph{reply}) from the server, which is another kind of client input. Replies and input events are received via the same byte-stream connecting the client with the server. @menu * Windows:: * Input Events:: @end menu @node Windows, Input Events, The X Window System, The X Window System @subsection Windows The X Window System supports one or more screens containing overlapping windows and subwindows. A @emph{screen} is a physical monitor and hardware, which can be either color or black and white. There can be multiple screens per display workstation. A single server can provide display services for any number of screens. A set of screens for a single user with one keyboard and one mouse is called a @emph{display}. All windows in an X server are arranged in a strict hierarchy. At the top of the hierarchy are the @emph{root windows}, which cover each of the display screens. Each root window is either partially or completely covered by child windows. All windows, except for root windows, have parents. Any window can in turn have its own children. In this way, an application program can create a window tree of arbitrary depth on each screen. A child window can be larger than its parent. That is, part or all of the child window can extend beyond the boundaries of the parent. However, all output to a window is clipped by the boundaries of its parent window. If several children of a window have overlapping locations, one of the children is considered to be on top of/or raised over the others, @emph{obscuring} them. Window output to areas that are covered by other windows is suppressed. A window has a border that is zero or more pixels in width and can be any pattern (pixmap) or solid color. A window usually has a background pattern that is drawn by the X server. Each window has its own coordinate system. Child windows obscure their parents unless the child windows have no background. Graphics operations in the parent window are usually clipped by the children. X also provides objects called @emph{pixmaps} for off-screen storage of graphics. Single-plane pixmaps (that is, of depth 1) are sometimes referred to as @emph{bitmaps}. Both pixmaps and windows can be used interchangeably in most graphics functions. Pixmaps are also used in various graphics operations to define patterns, or @emph{tiles}. Windows and pixmaps together are referred to as @emph{drawables}. @node Input Events, , Windows, The X Window System @subsection Input Events The X input mechanism is conceptually simple yet quite powerful. Most events are attached to a particular window (that is, contain an identifier for the window receiving the event). A client program can receive multiple window input streams, all multiplexed over the single byte-stream connection to the server. Clients can tailor their input by expressing interest in only certain event types. The server uses special event types to send important messages to the client. For example, the client can elect to receive an @var{:enter-notify} (@pxref{:enter-notify}) event when the pointer cursor moves into a certain window. Another vital message from the server is an @var{:exposure} (@pxref{:exposure}) event. This is a signal to the client indicating that at least some portion of the window has suddenly become visible (perhaps the user moved another window which had been overlapping it). The client is then responsible for doing what is necessary to redisplay the window's image. Client programs must be prepared to regenerate the contents of windows in this way on demand. Input is also subject to policy decisions about which client window receives keyboard and pointer events. Since the pointer is free to roam between windows, just clicking on a window is often enough to send a pointer event to that window. Keyboard events, however, must go to a keyboard focus window which has to be designated in some other way. Usually, the arbiter of such input management policy is a program called the @emph{window manager}. The window manager gives the human user a way to make a window the keyboard focus, to manage the layout of windows on the screen, to represent windows with icons, and so forth. In fact, the window manager client determines most of the so-called look and feel of the X Window System. @node A Quick Tour of CLX, Naming and Argument Conventions, The X Window System, Introduction to CLX @section A Quick Tour of CLX The X Window System is defined by the X Window System Protocol Specification, a detailed description of the encoding and the meaning of requests and events sent between a client and a server. This standard protocol does not depend on any particular programming language. As a result, each programming language must define its own functional interface for using the X protocol. The standard X interface used by Common Lisp programmers is called CLX. CLX is a set of data types, functions, and macros which allow a Common Lisp client program to interact with an X server to send requests and to receive input events and replies. For the most part, CLX functions are closely tied to the underlying requests in the X protocol. Many CLX functions simply add requests to an output buffer. These requests later execute asynchronously on the X display server. However, some functions of CLX lie outside the scope of the protocol--for example, reading events and managing a clientside event queue. CLX is also responsible for important batching and caching tasks that minimize network communication. The following paragraphs show an example of a CLX client program. All CLX functions and macros are shown in upper case. Note that some of the terms used are unique to X, while other terms that are common to other window systems have different meanings in X. It may be helpful to refer to the glossary when you are uncertain of a term's meaning in the context of the X Window System. @menu * A Simple Menu:: * Displaying the Menu:: * Menu Input:: * The Main Program:: * Debugging With CLX:: @end menu @node A Simple Menu, Displaying the Menu, A Quick Tour of CLX, A Quick Tour of CLX @subsection A Simple Menu The example client program creates and displays a simple pop-up menu consisting of a column of strings--a title string followed by selectable menu item strings. The implementation uses one window to represent the entire menu, plus a set of subwindows, one for each menu item. Here is the definition of a structure which represents such a menu. @lisp (defstruct (menu) "A simple menu of text strings." (title "Choose an item:") item-alist ;((item-window item-string)) window gcontext width title-width item-width item-height (geometry-changed-p t)) ;nil if unchanged since displayed @end lisp The @code{window} slot will contain the @var{window} (@pxref{window}) object that represents the menu. The @code{item-} @code{alist} represents the relationship between the menu items and their associated subwindows. Each entry in @code{item-alist} is a list whose first element is a (sub)window object and whose second element is the corresponding item string. A @var{window} (@pxref{window}) object is an instance of a CLX-defined data type which represents X windows. A @var{window} (@pxref{window}) object actually carries two pieces of information: an X window ID integer and a @var{display} (@pxref{display}) object. A @var{display} (@pxref{display}) is another CLX-defined data type that represents a connection to a specific X display server. The @code{gcontext} slot contains an instance of a CLX data type known as a @emph{graphics context}. A graphics context is a set of display attribute values, such as foreground color, fill style, line style, text font, and so forth. Each X graphics request (and hence each CLX graphics function call) must supply a graphics context to use in displaying the request. The menu's @code{gcontext} will thus hold all of the attribute values used during menu display. The first thing to do is make an instance of a @code{menu} object: @lisp (defun create-menu (parent-window text-color background-color text-font) (make-menu ;; Create menu graphics context :gcontext (CREATE-GCONTEXT :drawable parent-window :foreground text-color :background background-color :font text-font) ;; Create menu window :window (CREATE-WINDOW :parent parent-window :class :input-output :x 0 ;temporary value :y 0 ;temporary value :width 16 ;temporary value :height 16 ;temporary value :border-width 2 :border text-color :background background-color :save-under :on :override-redirect :on ;override window mgr when positioning :event-mask (MAKE-EVENT-MASK :leave-window :exposure)))) @end lisp @var{create-window} (@pxref{create-window}) is one of the most important CLX functions, since it creates and returns a @var{window} (@pxref{window}) object. Several of its options are shown here. The default window class is @var{:input-output}, but X provides for @var{:input-only} windows, too. Every window must have a parent window, except for a system-defined @emph{root window}, which represents an entire display screen. The @var{:event-mask} keyword value, a CLX @var{event-mask} (@pxref{event-mask}) data type, says that an input event will be received for the menu window when the window is exposed and also when the pointer cursor leaves the window. The window border is a pattern-filled or (as in this case) a solid-colored boundary which is maintained automatically by the X server; a client cannot draw in a window's border, since all graphics requests are relative to the origin (upper-left corner) of the window's interior and are clipped by the server to this inside region. Turning on the @var{:save-under} option is a hint to the X server that, when this window is made visible, it may be more efficient to save the pixels it obscures, rather than require several client programs to refresh their windows when the pop-up menu disappears. This is a way to work around X's client-managed refresh policy when only a small amount of screen space is needed temporarily. Why is @var{:override-redirect} turned on for the menu window? This is actually a little unusual, because it prevents any window manager client from @emph{redirecting} the position of the menu when it is popped up. Remember that the window manager represents the user's policy for controlling the positions of his windows, so this kind of redirection is ordinarily correct. However, in this case, as a favor to the user, the menu avoids redirection in order to pop up the menu at a very specific location; that is, under the pointer cursor. What about the item subwindows? The @code{menu-set-item-list} function in the following example creates them whenever the menu's item list is changed. The upper-left x and y coordinates and the width and height are not important yet, because they are computed just before the menu is displayed. This function also calls @var{create-window} (@pxref{create-window}), demonstrating the equal treatment of parent and children windows in the X window hierarchy. @lisp (defun menu-set-item-list (menu &rest item-strings) ;; Assume the new items will change the menu's width and height (setf (menu-geometry-changed-p menu) t) ;; Destroy any existing item windows (dolist (item (menu-item-alist menu)) (DESTROY-WINDOW (first item))) ;; Add (item-window item-string) elements to item-alist (setf (menu-item-alist menu) (let (alist) (dolist (item item-strings (nreverse alist)) (push (list (CREATE-WINDOW :parent (menu-window menu) :x 0 ;temporary value :y 0 ;temporary value :width 16 ;temporary value :height 16 ;temporary value :background (GCONTEXT-BACKGROUND (menu-gcontext menu)) :event-mask (MAKE-EVENT-MASK :enter-window :leave-window :button-press :button-release)) item) alist))))) @end lisp @node Displaying the Menu, Menu Input, A Simple Menu, A Quick Tour of CLX @subsection Displaying the Menu The @code{menu-recompute-geometry} function (shown in the following example) handles the job of calculating the size of the menu, based on its current item list and its current text font. CLX provides a way to inquire the geometrical properties of a font object (for example, its ascent and descent from the baseline) and also a @var{text-extents} (@pxref{text-extents}) function. @var{text-extents} (@pxref{text-extents}) returns the geometry of a given string as displayed in a given font. Notice the use of the @var{with-state} (@pxref{with-state}) macro when setting a window's geometry attributes. CLX strives to preserve the familiar @code{setf} style of accessing individual window attributes, even though an attribute access actually involves sending a request to a (possibly remote) server and/or waiting for a reply. @var{with-state} (@pxref{with-state}) tells CLX to batch together all read and write accesses to a given window, using a local cache to minimize the number of server requests. This CLX feature can result in a dramatic improvement in client performance without burdening the programmer interface. @code{menu-recompute-geometry} causes all the item subwindows to become @emph{mapped}. Mapping a window means attempting to make it visible on the screen. However, a subwindow will not actually be @emph{visible} until it and all of its ancestors are mapped. Even then, another window might be covering up the subwindow. @lisp (defun menu-recompute-geometry (menu) (when (menu-geometry-changed-p menu) (let* ((menu-font (GCONTEXT-FONT (menu-gcontext menu))) (title-width (TEXT-EXTENTS menu-font (menu-title menu))) (item-height (+ (FONT-ASCENT menu-font) (FONT-DESCENT menu-font) *menu-item-margin*)) (item-width 0) (items (menu-item-alist menu)) menu-width) ;; Find max item string width (setf item-width (+ *menu-item-margin* (dolist (next-item items item-width) (setf item-width (max item-width (TEXT-EXTENTS menu-font (second next-item))))))) ;; Compute final menu width, taking margins into account (setf menu-width (max title-width (+ item-width *menu-item-margin*))) (let ((window (menu-window menu))) ;; Update width and height of menu window (WITH-STATE (window) (setf (DRAWABLE-WIDTH window) menu-width (DRAWABLE-HEIGHT window) (* (1+ (length items)) item-height))) ;; Update width, height, position of item windows (let ((item-left (round (- menu-width item-width) 2)) (next-item-top (- item-height (round *menu-item-margin* 2)))) (dolist (next-item items) (let ((window (first next-item))) (WITH-STATE (window) (setf (DRAWABLE-HEIGHT window) item-height (DRAWABLE-WIDTH window) item-width (DRAWABLE-X window) item-left (DRAWABLE-Y window) next-item-top))) (incf next-item-top item-height)))) ;; Map all item windows (MAP-SUBWINDOWS (menu-window menu)) ;; Save item geometry (setf (menu-item-width menu) item-width (menu-item-height menu) item-height (menu-width menu) menu-width (menu-title-width menu) title-width (menu-geometry-changed-p menu) nil)))) @end lisp Of course, the sample client must know how to draw/redraw the menu and its items, so the function @code{menu-refresh} is defined next to handle that task (shown in the following example). Note that the location of window output is given relative to the window origin. Windows and subwindows have different coordinate systems. The location of the origin (upper-left corner) of a subwindow's coordinate system is given with respect to its parent window's coordinate system. Negative coordinates are valid, although only output to the +x/+y quadrant of a window's coordinate system will ever be visible. @lisp (defun menu-refresh (menu) (let* ((gcontext (menu-gcontext menu)) (baseline-y (FONT-ASCENT (GCONTEXT-FONT gcontext)))) ;; Show title centered in "reverse-video" (let ((fg (GCONTEXT-BACKGROUND gcontext)) (bg (GCONTEXT-FOREGROUND gcontext))) (WITH-GCONTEXT (gcontext :foreground fg :background bg) (DRAW-IMAGE-GLYPHS (menu-window menu) gcontext (round (- (menu-width menu) (menu-title-width menu)) 2) ;start x baseline-y ;start y (menu-title menu)))) ;; Show each menu item (position is relative to item window) (let ((box-margin (round *menu-item-margin* 2))) (dolist (item (menu-item-alist menu)) (DRAW-IMAGE-GLYPHS (first item) gcontext box-margin ;start x (+ baseline-y box-margin) ;start y (second item)))))) @end lisp @var{with-gcontext} (@pxref{with-gcontext}) is a CLX macro that allows you temporarily to modify a graphics context within the dynamic scope of the macro body. @var{draw-image-glyphs} (@pxref{draw-image-glyphs}) is a CLX text drawing function which produces a terminal-like rendering: foreground character on a background block. (More sophisticated text rendering functions are also available.) The strange use of @emph{glyphs} instead of @emph{string} here actually highlights an important fact: X and Common Lisp have totally different concepts of a character. A Common Lisp character is an object whose implementation can comprehend a vast universe of text complexities (typefaces, type styles, international character sets, symbols, and so forth). However, to X, a string is just a sequence of integer indexes into the array of bitmaps represented by a CLX font object. In general, @var{draw-image-glyphs} (@pxref{draw-image-glyphs}), @var{text-extents} (@pxref{text-extents}), and other CLX text functions accept a @var{:translate} keyword argument. Its value is a function which translates the characters of a string argument into the appropriate font-and-index pairs needed by CLX. This example relies upon the default translation function, which simply uses @var{char-code} to compute an index into the current font. @node Menu Input, The Main Program, Displaying the Menu, A Quick Tour of CLX @subsection Menu Input Now that a menu can be displayed, the sample client program must define how the menu will process user input. The @code{menu-choose} function (shown in the following example) has the classic structure of an X client program. First, do some initialization (for example, present the menu at a given location). Then, enter an input event loop. Read an input event, process it, and repeat the loop until a termination event is received. The @var{event-case} (@pxref{event-case}) macro continues reading an event from the menu window's display object until one of its clauses returns non-@var{nil}. These clauses specify the action to be taken for each event type and also bind values from the event report to local variables, such as the @var{event-window} receiving the event. Notice that the @var{:force-output-p} option is enabled, causing @var{event-case} (@pxref{event-case}) to begin by sending any client requests which CLX has not yet output to the server. To improve performance, CLX quietly queues up requests and periodically sends them off in a batch. However, in an interactive feedback loop such as this, it is important to keep the display crisply up-to-date. @lisp (defun menu-choose (menu x y) ;; Display the menu so that first item is at x,y. (menu-present menu x y) (let ((items (menu-item-alist menu)) (mw (menu-window menu)) selected-item) ;; Event processing loop (do () (selected-item) (EVENT-CASE ((DRAWABLE-DISPLAY mw) :force-output-p t) (:exposure (count) ;; Discard all but final :exposure then display the menu (when (zerop count) (menu-refresh menu)) t) (:button-release (event-window) ;;Select an item (setf selected-item (second (assoc event-window items))) t) (:enter-notify (window) ;;Highlight an item (menu-highlight-item menu (find window items :key #'first)) t) (:leave-notify (window kind) (if (eql mw window) ;; Quit if pointer moved out of main menu window (setf selected-item (when (eq kind :ancestor) :none)) ;; Otherwise, unhighlight the item window left (menu-unhighlight-item menu (find window items :key #'first))) t) (otherwise () ;;Ignore and discard any other event t))) ;; Erase the menu (UNMAP-WINDOW mw) ;; Return selected item string, if any (unless (eq selected-item :none) selected-item))) @end lisp The event loop in @code{menu-choose} demonstrates an idiom used in all X programs: the contents of a window are displayed (in this case, by calling @code{menu-refresh}) only when an @var{:exposure} (@pxref{:exposure}) event is received, signaling that the server has actually made the window @emph{viewable}. The handling of @var{:exposure} (@pxref{:exposure}) in @code{menu-choose} also implements a little trick for improving efficiency. In general, when a window is exposed after being previously obscured (perhaps only partially), the server is free to send several @var{:exposure} (@pxref{:exposure}) events, one for each rectangular tile of the exposed region. For small windows like this menu, it is not worth the trouble to redraw the image one tile at a time. So the code above just ignores all but the last tile exposure and redraws everything in one call to @code{menu-refresh}. @node The Main Program, Debugging With CLX, Menu Input, A Quick Tour of CLX @subsection The Main Program After all the preceding build-up and the other functions referenced (but not shown here) have been implemented, the code for the main client program is very small. @lisp (defun just-say-lisp (host &optional (font-name "fg-16")) (let* ((display (OPEN-DISPLAY host)) (screen (first (DISPLAY-ROOTS display))) (fg-color (SCREEN-BLACK-PIXEL screen)) (bg-color (SCREEN-WHITE-PIXEL screen)) (nice-font (OPEN-FONT display font-name)) ;; Create a menu as a child of the root window. (a-menu (create-menu (SCREEN-ROOT screen) fg-color bg-color nice-font))) (setf (menu-title a-menu) "Please pick your favorite language:") (menu-set-item-list a-menu "Fortran" "APL" "Forth" "Lisp") ;; Bedevil the user until he picks a nice programming language (unwind-protect (loop ;; Determine the current root window position of the pointer (multiple-value-bind (x y) (QUERY-POINTER (SCREEN-ROOT screen)) (let ((choice (menu-choose a-menu x y))) (when (string-equal "Lisp" choice) (return))))) (CLOSE-DISPLAY display)))) @end lisp Note that the main program event loop lies in the body of an @var{unwind-protect} form. This is a good programming technique because, without this protection, an unexpected error could cause the program to terminate without freeing the @emph{server resources} it has created. Server resources are CLX objects which refer to objects actually stored on the X server. Examples of these are @var{window} (@pxref{window}), @var{font} (@pxref{font}), @var{pixmap} (@pxref{pixmap}), @var{cursor} (@pxref{cursor}), @var{colormap} (@pxref{colormap}), and @var{gcontext} (@pxref{gcontext}) objects. These server resources are created and destroyed by user requests. Server resources created by a client are also destroyed when its display connection is closed. If client resources are repeatedly created without being destroyed, then the server will eventually run out of memory and fail. Most server resources are potentially sharable between applications. In fact, windows are manipulated explicitly by window manager programs. Fonts and cursors are typically shared automatically since the X server loads and unloads font storage as needed. @var{gcontext} (@pxref{gcontext}) objects are not ordinarily shared between client applications. @node Debugging With CLX, , The Main Program, A Quick Tour of CLX @subsection Debugging With CLX Typically, most CLX programs do not need to control the buffering of output requests directly. However, CLX programmers need to be aware of the asynchronous nature of client-server communication. It may be convenient to control the CLX output buffer more directly, especially during debugging. A client that wants a request to execute immediately instead of asynchronously can follow it with a call to @var{display-force-output} (@pxref{display-force-output}). This function @emph{blocks} (does not return) until all previously buffered output requests have been sent. Otherwise, the output buffer is always flushed by a call to any function which returns a value from the server or which waits for input (for example, @var{get-property} (@pxref{get-property}). Certain output requests can cause input events to be sent. For example, @var{map-window} (@pxref{map-window}) can cause @var{:exposure} (@pxref{:exposure}) events to be sent. Synchronizing output with the resulting input can be done with the @var{display-finish-output} (@pxref{display-finish-output}) function. This function blocks until all previously buffered output has been sent and all resulting input events have been received. Functions that return information from the server block until an explicit reply is received or an error occurs. If a nonblocking call results in an error, the error is generally not reported until later. All errors (synchronous and asynchronous) are processed by calling an error handler defined for the display. If the handler is a sequence it is expected to contain handler functions specific to each error. The error code is used to index the sequence, fetching the appropriate handler. Any results returned by the handler are ignored since it is assumed that the handler either takes care of the error completely, or else signals. @node Naming and Argument Conventions, Programming Considerations, A Quick Tour of CLX, Introduction to CLX @section Naming and Argument Conventions Throughout CLX, a number of conventions for naming and syntax of the CLX functions have been followed. These conventions are intended to make the syntax of the functions more predictable. The major naming conventions are as follows: @itemize @bullet @item To better differentiate the CLX symbols from other symbols, they have all been placed in the package XLIB. External symbols have been explicitly exported. @item The @emph{display} argument, where used, is always first in the argument list. @item All server resource objects, where used, occur at the beginning of the argument list, immediately after the display variable. @item When a graphics context (@emph{gcontext}) is present together with another type of server resource (most commonly, a @emph{drawable}), the graphics context occurs in the argument list after the other server resource. Drawables out rank all other server resources. @item Source arguments always precede the destination arguments in the argument list. @item The @emph{x} argument always precedes the @emph{y} argument in the argument list. @item The @emph{width} argument always precedes the @emph{height} argument in the argument list. @item Where the @emph{x}, @emph{y}, @emph{width} and @emph{height} arguments are used together, the @emph{x} and @emph{y} arguments always precede the @emph{width} and @emph{height} arguments. @item Where a @emph{mask} is accompanied with a @emph{structure}, the mask always precedes the structure in the argument list. @end itemize @node Programming Considerations, Data Types, Naming and Argument Conventions, Introduction to CLX @section Programming Considerations The major programming considerations are as follows: @itemize @bullet @item Keyboards are the greatest variable between different manufacturer's workstations. If you want your program to be portable, you should be particularly conservative here. @item Many display systems have limited amounts of off-screen memory. If you can, you should minimize use of pixmaps and backing store. @item The user should have control of his screen real-estate. Therefore, you should write your applications to react to window management, rather than presume control of the entire screen. What you do inside of your top level window, however, is up to your application. @item Coordinates and sizes in X are actually 16-bit quantities. They usually are declared as an @var{int16} (@pxref{int16}) in the functions. Values larger than 16 bits can be truncated silently. Sizes (width and height) are unsigned quantities. @item The types @var{color} (@pxref{color}), @var{colormap} (@pxref{colormap}), @var{cursor} (@pxref{cursor}), @var{display} (@pxref{display}), @var{font} (@pxref{font}), @var{gcontext} (@pxref{gcontext}), @var{pixmap} (@pxref{pixmap}), @var{screen} (@pxref{screen}), and @var{window} (@pxref{window}) are defined solely by a functional interface. Even though they are treated like structures in this document, it is not specified whether they are implemented as structures or classes. Although some interfaces are described as functions, they are not required to be defined using @var{defun.} (It is a requirement that they be functions as opposed to macros or special forms.) @end itemize @node Data Types, , Programming Considerations, Introduction to CLX @section Data Types The following are some data type definitions that are commonly used in CLX function definitions. @deftp {Type} alist (key-type-and-name datum-type-and-name) 'list @var{alist} defines an association list. An association list is a sequence, containing zero or more repetitions of the given elements with each of the elements expressed as (@emph{type} @emph{name}). @end deftp @deftp {Type} angle `(number ,(* -2pi) ,(* 2pi)) @var{angle} defines an angle in units of radians and is bounded by (-2%pi;) and (2%pi;). Note that we are explicitly using a different angle representation than what is actually transmitted in the protocol. @end deftp @deftp {Type} arc-seq '(repeat-seq (int16 x) (int16 y) (card16 width) (card16 height) (angle angle1) (angle angle2)) @var{arc-seq} defines a six-tuple sequence of the form (@emph{x}, @emph{y}, @emph{width}, @emph{height}, @emph{angle1}, @emph{angle2}). The points @emph{x} and @emph{y} are signed, 16-bit quantities with a range from -32,768 to 32,767. The @emph{width} and @emph{height} values are unsigned, 16-bit quantities and range from 0 to 65,535. @emph{angle1} and @emph{angle2} are in units of radians, and bounded by (-2%pi;) and (2%pi;). @end deftp @deftp {Type} array-index `(integer 0 ,array-dimension-limit) @var{array-index} defines a type which is a subtype of the integers and can be used to describe all variables that can be array indices. The range is inclusive because start and end array index specifiers can be one (1) past the end. @end deftp @deftp {Type} bit-gravity '(member gravity*) A keyword that specifies which region of a window should be retained when the window is resized. @emph{gravity} -- One of the following: @itemize @c menu @item @var{:center} @item @var{:north} @item @var{:south} @item @var{:static} @item @var{:east} @item @var{:north-east} @item @var{:south-east :west} @item @var{:forget} @item @var{:north-west} @item @var{:south-west} @end itemize If a window is reconfigured without changing its inside width or height, then the contents of the window moves with the window and are not lost. Otherwise, the contents of a resized window are either moved or lost, depending on its bit-gravity attribute. See @var{window-bit-gravity}, in @ref{Window Attributes}, for additional information. @end deftp @deftp {Type} bitmap '(array bit (* *)) Specifies a two-dimensional array of bits. @end deftp @deftp {Structure} bitmap-format A structure that describes the storage format of a bitmap. The @var{bitmap-format} structure contains slots for @var{unit}, @var{pad}, and @var{lsb-first-p}. The @var{unit} member indicates the unit of increments used to maintain the bitmap data. The units available for use are 8, 16, or 32 bits. The @var{pad} member indicates how many bits are needed to pad the left edge of the scan-line. The @var{lsb-first-p} member is a predicate which indicates the ordering of bits with the bitmap unit. @end deftp @deftp {Slot of bitmap-format} unit Type: (@var{member} 8 16 32). The size of a contiguous grouping of bits, which can be 8, 16, or 32. The default is 8. @end deftp @deftp {Slot of bitmap-format} pad Type: (@var{member} 8 16 32). The number of bits to left-pad the scan-line, which can be 8, 16, or 32. The default is 8. @end deftp @deftp {Slot of bitmap-format} lsb-first-p Type: @var{boolean}. A predicate indicating whether the least significant bit comes first (@var{true}) or not (@var{nil}). @end deftp @deftp {Type} boolean '(or nil (not nil)) @var{boolean} defines a type which is all inclusive. It is used for variables that can take on a true (non-@var{nil}) or false (@var{nil}) value. @end deftp @deftp {Type} boole-constant `(member value*) @var{boole-constant} defines a type that is a set of the values associated with the 16 boolean operation-code constants for the Common Lisp language. It is used for the set of allowed source and destination combination functions in a graphics context. @emph{value} -- One of the following: @itemize @c menu @item @var{boole-1} @item @var{boole-c1} @item @var{boole-nand} @item @var{boole-xor} @item @var{boole-2} @item @var{boole-c2} @item @var{boole-nor} @item @var{boole-and} @item @var{boole-clr} @item @var{boole-orc1} @item @var{boole-andc1} @item @var{boole-eqv} @item @var{boole-orc2} @item @var{boole-andc2} @item @var{boole-ior} @item @var{boole-set} @end itemize @end deftp @deftp {Type} card8 '(unsigned-byte 8) An unsigned integer value that is a maximum of eight bits long. This gives a number of this type a range from 0 to 255. @end deftp @deftp {Type} card16 '(unsigned-byte 16) An unsigned integer value that is a maximum of 16 bits long. This gives a number of this type a range from 0 to 65,535. @end deftp @deftp {Type} card29 '(unsigned-byte 29) An unsigned integer value that is a maximum of 29 bits long. This gives a number of this type a range from 0 to 536,870,911. @end deftp @deftp {Type} card32 '(unsigned-byte 32) An unsigned integer value that is a maximum of 32 bits long. This gives a number of this type a range from 0 to 4,294,967,295. @end deftp @deftp {Type} color '(satisfies color-p) @anchor{color} A @var{color}. @xref{Color Functions}, for additional information. @end deftp @deftp {Type} colormap '(satisfies colormap-p) @anchor{colormap} A @var{colormap}. @xref{Colormap Functions}, for additional information. @end deftp @deftp {Type} cursor '(satisfies cursor-p) @anchor{cursor} A @var{cursor}. @xref{Cursors}, for additional information. @end deftp @deftp {Type} device-event-mask '(or mask32 (list device-event-mask-class)) @anchor{event-mask} Provides a way to specify a set of bits for an event bitmask. Two ways of specifying the bits are allowed: by setting the event bits in a 32 bit mask, or by listing the keyword names of the device related event bits in a list. @end deftp @deftp {Type} device-event-mask-class '(member event*) A keyword name, for a device related event, that corresponds to a particular bit in an event bitmask. The set of names is a subset of the names in the type @var{event-mask-class}. @emph{event} -- One of the following: @itemize @c menu @item @var{:button-1-motion} @item @var{:button-motion} @item @var{:button-2-motion} @item @var{:button-press} @item @var{:button-3-motion} @item @var{:key-press} @item @var{:button-4-motion} @item @var{:key-release} @item @var{:button-5-motion} @item @var{:pointer-motion} @end itemize @end deftp @deftp {Type} display '(satisfies display-p) @anchor{display} A connection to an X server. @xref{Displays}, for additional information. @end deftp @deftp {Type} drawable '(or window pixmap) Both @var{windows} and @var{pixmaps} can be used as sources and destinations in graphics operations. @var{windows} and @var{pixmaps} together are known as @emph{drawables}. However, an @var{:input-only} window cannot be used as a source or destination in a graphics operation. @end deftp @deftp {Type} draw-direction '(member :left-to-right :right-to-left) Defines a list of rotation directions for drawing arcs and fonts. @var{draw-direction} can have the values of @var{:left-to-right} or @var{:right-to-left}. @end deftp @deftp {Type} error-key '(member error*) Defines a list of all predefined errors. All errors (synchronous and asynchronous) are processed by calling an error handler in the display. The handler is called with the display as the first argument and the error-key as its second argument. @emph{error} -- One of the following: @itemize @c menu @item @var{:access} @item @var{:drawable} @item @var{:implementation} @item @var{:value} @item @var{:alloc} @item @var{:font} @item @var{:length} @item @var{:window} @item @var{:atom} @item @var{:gcontext} @item @var{:match} @item @var{:colormap} @item @var{:id-choice} @item @var{:name} @item @var{:cursor} @item @var{:illegal-request} @item @var{:pixmap} @end itemize @end deftp @deftp {Type} event-key '(member event-type*) Defines a list that specifies all predefined event-types. Clients are informed of information asynchronously by means of events. These events can be either asynchronously generated from devices or generated as side effects of client requests. @emph{event-type} -- One of the following: @itemize @c menu @item @var{:button-press} @item @var{:exposure} @item @var{:motion-notify} @item @var{:button-release} @item @var{:focus-in} @item @var{:no-exposure} @item @var{:circulate-notify} @item @var{:focus-out} @item @var{:property-notify} @item @var{:circulate-request} @item @var{:graphics-exposure} @item @var{:reparent-notify} @item @var{:client-message} @item @var{:gravity-notify} @item @var{:resize-request} @item @var{:colormap-notify} @item @var{:keymap-notify} @item @var{:selection-clear} @item @var{:configure-notify} @item @var{:key-press} @item @var{:selection-notify} @item @var{:configure-request} @item @var{:key-release} @item @var{:selection-request} @item @var{:create-notify} @item @var{:leave-notify} @item @var{:unmap-notify} @item @var{:destroy-notify} @item @var{:map-notify} @item @var{:visibility-notify} @item @var{:enter-notify} @item @var{:map-request} @end itemize @end deftp @deftp {Type} event-mask '(or mask32 (list event-mask-class)) Provides a way to specify a set of bits for an event bitmask. Two ways of specifying the bits are allowed: by setting the event bits in a 32 bit mask, or by listing the keyword names of the event bits in a list. @end deftp @deftp {Type} event-mask-class '(member event*) The elements of the type @var{event-mask-class} are keyword names that correspond to a particular bit in an event bitmask. @emph{event} -- One of the following: @itemize @c menu @item @var{:button-1-motion} @item @var{:enter-window} @item @var{:pointer-motion-hint} @item @var{:button-2-motion} @item @var{:exposure} @item @var{:property-change} @item @var{:button-3-motion} @item @var{:focus-change} @item @var{:resize-redirect} @item @var{:button-4-motion} @item @var{:key-press} @item @var{:structure-notify} @item @var{:button-5-motion} @item @var{:key-release} @item @var{:substructure-notify} @item @var{:button-motion} @item @var{:keymap-state} @item @var{:substructure-redirect} @item @var{:button-press} @item @var{:leave-window} @item @var{:visibility-change} @item @var{:button-release} @item @var{:owner-grab-button} @item @var{:colormap-change} @item @var{:pointer-motion} @end itemize @end deftp @defun make-event-keys event-mask Returns a list of @var{event-mask-class} keyword names for the event bits that are set in the specified event mask. @table @var @item event-mask An event mask (type @var{mask32}). @end table @end defun @defun make-event-mask &rest keys @table @var @item keys @var{event-mask-class} keywords. @end table Constructs an event mask from a set of @var{event-mask-class} keyword names. @table @var @item event-mask Type @var{mask32}. @end table @end defun @deftp {Type} font '(satisfies font-p) @anchor{font} A text font. @xref{Font and Characters}, for additional information. @end deftp @deftp {Type} fontable '(or stringable font) A @var{fontable} is either a @var{font} object or the name of one of the fonts in the font database. @end deftp @deftp {Type} font-props 'list A @var{list} that contains alternating keywords and integers. @end deftp @deftp {Type} gcontext '(satisfies gcontext-p) @anchor{gcontext} A graphics context. @xref{Graphics Contexts}, for additional information. @end deftp @deftp {Type} gcontext-key '(member type*) A list of predefined types for use in @var{gcontext} processing. Various information for graphics output is stored in a graphics context (GC or GContext), such as foreground pixel, background pixel, line width, clipping region, and so forth. @var{type} -- One of the following: @itemize @c menu @item @var{:arc-mode} @item @var{:exposures} @item @var{:line-width} @item @var{:background} @item @var{:fill-rule} @item @var{:plane-mask} @item @var{:cap-style :fill-style} @item @var{:stipple} @item @var{:clip-mask} @item @var{:font} @item @var{:subwindow-mode} @item @var{:clip-x} @item @var{:foreground} @item @var{:tile} @item @var{:clip-y} @item @var{:function} @item @var{:ts-x} @item @var{:dash-offset} @item @var{:join-style} @item @var{:ts-y} @item @var{:dashes} @item @var{:line-style} @end itemize @end deftp @deftp {Type} grab-status '(member grab-type*) There are two kinds of grabs: active and passive. An @emph{active grab} occurs when a single client grabs the keyboard and/or pointer explicitly. Clients can also grab a particular keyboard key or pointer button in a window. The grab activates when the key or button is actually pressed, and is called a @emph{passive grab}. Passive grabs can be very convenient for implementing reliable pop-up menus. @var{grab-type} -- One of the following: @itemize @c menu @item @var{:already-grabbed} @item @var{:frozen} @item @var{:invalid-time} @item @var{:not-viewable} @item @var{:success} @end itemize @end deftp @deftp {Type} image-depth '(integer 0 32) Used in determining the depth of a pixmap, window, or image. The value specifies the number of bits deep that a given pixel has within a given pixmap, window, or image. @end deftp @deftp {Type} index-size '(member :default 8 16) Used to control the element size of the destination buffer given to the translate function when drawing glyphs. If @var{:default} is specified, the size is based on the current font, if known; otherwise, 16 is used. @end deftp @deftp {Type} int8 '(signed-byte 8) A signed integer value that is a maximum of eight bits long. A number of this type can have a range from -128 to 127. @end deftp @deftp {Type} int16 '(signed-byte 16) @anchor{int16} A signed integer value that is a maximum of 16 bits long. A number of this type can have a range from -32,768 to 32,767. @end deftp @deftp {Type} int32 '(signed-byte 32) A signed integer value that is a maximum of 32 bits long. A number of this type can have a range from -2,147,483,648 to 2,147,483,647. @end deftp @deftp {Type} keysym 'card32 Used as an encoding of a symbol on a keycap on a keyboard. It is an unsigned integer value represented in a maximum of 32 bits long. A @var{keysym} type can have a range from 0 to 4,294,967,295. @end deftp @deftp {Type} mask16 ' card16 A positional bitmask that contains 16 boolean flags. @end deftp @deftp {Type} mask32 ' card32 A positional bitmask that contains 32 boolean flags. @end deftp @deftp {Type} modifier-key '(member modifier*) A keyword identifying one of the modifier keys on the keyboard device. @var{modifier} -- One of the following: @itemize @c menu @item @var{:shift} @item @var{:mod-2} @item @var{:lock} @item @var{:mod-3} @item @var{:control} @item @var{:mod-4} @item @var{:mod-1} @item @var{:mod-5} @end itemize @end deftp @deftp {Type} modifier-mask '(or (member :any) mask16 (list modifier-key)) A bitmask or list of keywords that specifies a set of modifier keys. The keyword @var{:any} is equivalent to any subset of modifier key. @end deftp @deftp {Type} pixarray '(or (array pixel (* *)) (array card16 (* *)) (array card8 (* *)) (array (unsigned-byte 4) (* *)) (array bit (* *))) Specifies a two-dimensional array of pixels. @end deftp @deftp {Type} pixel '(unsigned-byte 32) An unsigned integer value that is a maximum of 32 bits long. This gives a pixel type a value range from 0 to 4,294,967,295. Useful values are dependent on the class of colormap being used. @end deftp @deftp {Type} pixmap '(satisfies pixmap-p) @anchor{pixmap} A @var{pixmap}, @pxref{Pixmaps}), for additional information. @end deftp @deftp {Structure} pixmap-format A structure that describes the storage format of a pixmap. The @var{pixmap-format} structure contains slots for @var{depth}, @var{bits-per-pixel}, and @var{scanline-pad}. The @var{depth} member indicates the number of bit planes in the pixmap. The @var{bits-per-pixel} member indicates the number of bits used to represent a single pixel. For X, a pixel can be 1, 4, 8, 16, 24, or 32 bits wide. As for @var{bitmap-format}, the @var{scanline-pad} member indicates how many pixels are needed to pad the left edge of the scan-line. @end deftp @deftp {Slot of pixmap-format} depth Type: @var{image-depth}. The number of bit planes in the pixmap. @end deftp @deftp {Slot of pixmap-format} bits-per-pixel Type: (@var{member} 1 4 8 16 24 32). The number of consecutive bits used to encode a single pixel. The default is 8. @end deftp @deftp {Slot of pixmap-format} scanline-pad Type: (@var{member} 8 16 32). The number of bits to left-pad the scan-line, which can be 8, 16, or 32. The default is 8. @end deftp @deftp {Type} point-seq '(repeat-seq (int16 x) (int16 y)) The @var{point-seq} type is used to define sequences of (@var{x},@var{y}) pairs of points. The paired values are 16-bit, signed integer quantities. This gives the points in this type a range from -32,768 to 32,767. @end deftp @deftp {Type} pointer-event-mask '(or mask32 (list pointer-event-mask-class)) Provides a way to specify a set of bits for an event bitmask. Two ways of specifying the bits are allowed: by setting the event bits in a 32 bit mask, or by listing the keyword names of the pointer related event bits in a list. @end deftp @deftp {Type} pointer-event-mask-class '(member event*) A keyword name, for a pointer related event, that corresponds to a particular bit in an event bitmask. The set of names is a subset of the names in the type @var{event-mask-class}. @var{event} -- One of the following: @itemize @c menu @item @var{:button-1-motion} @item @var{:button-motion} @item @var{:leave-window} @item @var{:button-2-motion} @item @var{:button-press} @item @var{:pointer-motion} @item @var{:button-3-motion} @item @var{:button-release} @item @var{:pointer-motion-hint} @item @var{:button-4-motion} @item @var{:enter-window} @item @var{:button-5-motion} @item @var{:keymap-state} @end itemize @end deftp @deftp {Type} rect-seq '(repeat-seq (int16 x) (int16 y) (card16 width) (card16 height)) @var{rect-seq} defines a four-tuple sequence of the form (@var{x}, @var{y}, @var{width}, @var{height}). The points @var{x} and @var{y} are signed, 16-bit quantities with a range from -32,768 to 32,767. The @var{width} and @var{height} values are unsigned, 16-bit quantities and range from 0 to 65,535. @end deftp @deftp {Type} repeat-seq (&rest elts) 'sequence A subtype used to define repeating sequences. @end deftp @deftp {Type} resource-id 'card29 A numeric identifier that is assigned by the server to a server resource object. @end deftp @deftp {Type} rgb-val '(float 0.0 1.0) An @var{rgb-val} is a floating-point value between 0 and 1 that specifies a saturation for a red, green, or blue additive primary. The 0 value indicates no saturation and 1 indicates full saturation. @end deftp @deftp {Type} screen '(satisfies screen-p) @anchor{screen} A display screen. @xref{Screens}, for further information. @end deftp @deftp {Type} seg-seq '(repeat-seq (int16 x1) (int16 y1) (int16 x2) (int16 y2)) Defines sequences of (@var{x1}, @var{y1}, @var{x2}, @var{y2}) sets of points. The point values are 16-bit, signed integer quantities. This gives the points in this type a range from -32,768 to 32,767. @end deftp @deftp {Type} state-mask-key '(or modifier-key (member button*)) A keyword identifying one of the display modifier keys or pointer buttons whose state is reported in device events. @var{button} -- One of the following: @itemize @c menu @item @var{:button-1} @item @var{:button-4} @item @var{:button-2} @item @var{:button-5} @item @var{:button-3} @end itemize @end deftp @defun make-state-keys state-mask @table @var @item state-mask A 16-bit mask of type @var{mask16}. @end table Returns a list of @var{state-mask-key} symbols corresponding to the @var{state-mask}. A symbol belongs to the returned list if, and only if, the corresponding @var{state-mask} bit is 1. @table @var @item state-keywords Type @var{list}. @end table @end defun @defun make-state-mask &rest keys @table @var @item keys A list of @var{state-mask-key} symbols. @end table Returns a 16-bit @var{mask} representing the given @var{state-mask-key} symbols. The returned @var{mask} contains a 1 bit for each keyword. @table @var @item mask Type @var{mask16}. @end table @end defun @deftp {Type} stringable '(or string symbol) Used for naming something. This type can be either a string or a @var{symbol} whose @var{symbol-name} is used as the string containing the name. The case of the characters in the string is ignored when comparing stringables. @end deftp @deftp {Type} timestamp '(or null card32) An encoding of a time. @var{nil} stands for the current time. @end deftp @deftp {Structure} visual-info A structure that represents a visual type. The elements of this structure are @var{id}, @var{class}, @var{red-mask}, @var{green-mask}, @var{blue-mask}, @var{bits-per-rgb}, and @var{colormap-entries}. @end deftp @deftp {Slot of visual-info} id Type: @var{card29}. A unique identification number. @end deftp @deftp {Slot of visual-info} class Type: (member :direct-color :gray-scale :pseudo-color :static-color :static-gray :true-color). The class of the visual type. @end deftp @deftp {Slots of visual-info} red-mask @deftpx {Slots of visual-info} green-mask @deftpx {Slots of visual-info} blue-mask Type: @var{pixel}. The @var{red-mask}, @var{green-mask}, and @var{blue-mask} elements are only meaningful for the @var{:direct-color} and @var{:true-color} classes. Each mask has one contiguous set of bits with no intersections. @end deftp @deftp {Slot of visual-info} bits-per-rgb Type: @var{card8}. Specifies the log base 2 of the approximate number of distinct color values ( individually) of red, green, and blue. Actual RGB values are unsigned 16-bit numbers. @end deftp @deftp {Slot of visual-info} colormap-entries Type: @var{card16}. Defines the number of available colormap entries in a newly created colormap. For @var{:direct-color} and @var{:true-color}, this is the size of an individual pixel subfield. @end deftp @deftp {Type} win-gravity '(member gravity*) A keyword that specifies how to reposition a window when its parent is resized. @var{gravity} -- One of the following: @itemize @c menu @item @var{:center} @item @var{:north-west} @item @var{:static} @item @var{:east} @item @var{:south} @item @var{:unmap} @item @var{:north} @item @var{:south-east} @item @var{:west} @item @var{:north-east} @item @var{:south-west} @end itemize If a parent window is reconfigured without changing its inside width or height, then all child windows move with the parent and are not changed. Otherwise, each child of the resized parent is moved, depending on the child's gravity attribute. See @var{window-gravity} (@pxref{Window Attributes})), for additional information. @end deftp @deftp {Type} window '(satisfies window-p) @anchor{window} A window. @xref{Windows and Pixmaps}, for additional information. @end deftp @deftp {Type} xatom '(or string symbol) A name that has been assigned a corresponding unique ID by the server. @var{xatoms} are used to identify properties, selections, and types defined in the X server. An @var{xatom} can be either a @var{string} or @var{symbol} whose @var{symbol-name} is used as the @var{xatom} name. The case of the characters in the string are significant when comparing @var{xatoms}. @end deftp @node Displays, Screens, Introduction to CLX, Top @chapter Displays A particular X server, together with its screens and input devices, is called a @emph{display}. The CLX @var{display} object contains all the information about the particular display and its screens, as well as the state that is needed to communicate with the display over a particular connection. Before your program can use a display, you must establish a connection to the X server driving your display. Once you have established a connection, you then can use the CLX macros and functions discussed in this section to return information about the display. This section discusses how to: @itemize @bullet @item Open (connect) a display @item Obtain information about a display @item Access and change display attributes @item Close (disconnect) a display @end itemize @menu * Opening the Display:: * Display Attributes:: * Managing the Output Buffer:: * Closing the Display:: @end menu @node Opening the Display, Display Attributes, Displays, Displays @section Opening the Display The @var{open-display} and @var{open-default-display} functions are used to open a connection to an X server. @var{open-default-display} is an extension that is not present in the MIT CLX tree, but is preferred where available as it uses the same rules for display defaulting as the C Xlib bindings, and tends to get authorization right more often than @var{open-display} (particularly on ssh-forwarded connections) @defun open-display host &key :display :protocol @table @var @item host Specifies the name of the @emph{host} machine on which the server executes. A string must be acceptable as a @emph{host}, but otherwise the possible types are not constrained and will likely be very system dependent. @item :display An integer that specifies which display device on the @emph{host} should be used for this connection. This is needed since multiple displays can be controlled by a single X server. The default is display 0 (zero). @item :protocol A keyword argument that specifies which network protocol should be used for connecting to the server (for example, @var{:tcp}, @var{:dna}, or @var{:chaos}). The set of possible values and the default value are implementation specific. @end table Returns a @var{display} that serves as the connection to the X server and contains all the information about that X server. Authorization, if any, is assumed to come from the environment. After a successful call to @var{open-display}, all screens on the display can be used by the client application. @table @var @item display Type @var{display}. @end table @end defun @defun open-default-display &optional display-name @table @var @item display-name The display to connect to. Display names have the format @verbatim [protocol/] [hostname] : [:] displaynumber [.screennumber] @end verbatim There are two special cases in parsing, to match that done in the Xlib C language bindings @itemize @bullet @item If the hostname is @code{unix} or the empty string, any supplied protocol is ignored and a connection is made using the @code{local} transport. @item If a double colon separates @var{hostname} from @var{displaynumber}, the protocol is assumed to be @code{decnet}. @end itemize If @var{display-name} is not supplied, a default will be provided appropriate for the local environment: on a POSIX system - the only kind this CLX port runs on - the default display is taken from the environment variable @env{DISPLAY}. See also the section ``DISPLAY NAMES'' in X(7) @end table Open a connection to @var{display-name} or to the appropriate default display. @code{open-display-name} always attempts to do display authorization, following complicated rules that closely match the ones that the C Xlib bindings use. Briefly: the hostname is resolved to an address, then authorization data for the (protocol, host-address, displaynumber) triple is looked up in the file given by the environment variable @env{AUTHORITY_PATHNAME} (typically @file{$HOME/.Xauthority}). If the protocol is @code{:local}, or if the hostname resolves to the local host, authority data for the local machine's actual hostname - as returned by gethostname(3) - is used instead. @end defun @node Display Attributes, Managing the Output Buffer, Opening the Display, Displays @section Display Attributes The complete set of display attributes is discussed in the following paragraphs. @defun display-authorization-data display @table @var @item display A @var{display} object. @end table Returns the authorization data string for @var{display} that was transmitted to the server by @var{open-display} during connection setup. The data is specific to the particular authorization protocol that was used. The @var{display-authorization-name} function returns the protocol used. @table @var @item authorization-data Type @var{string}. @end table @end defun @defun display-authorization-name display @table @var @item display A @var{display} object. @end table Returns the authorization protocol namestring for @var{display} that was transmitted by @var{open-display} to the server during connection setup. The @var{authorization-name} indicates what authorization protocol the client expects the server to use. Specification of valid authorization mechanisms is not part of the X protocol. A server that implements a different protocol than the client expects, or a server that only implements the host-based mechanism, can simply ignore this information. If both name and data strings are empty, this is to be interpreted as "no explicit authorization." @table @var @item authorization-name Type @var{string}. @end table @end defun @defun display-bitmap-format display @anchor{display-bitmap-format} @table @var @item display A @var{display} object. @end table Returns the @emph{bitmap-format} information for the specified @emph{display}. @table @var @item bitmap-format Type @var{bitmap-format}. @end table @end defun @defun display-byte-order display @table @var @item display A @var{display} object. @end table Returns the @var{byte-order} to be employed in communication with the server for the given @var{display}. The possible values are as follows: @table @var @item :lsbfirst Values are transmitted least significant byte first. @item :msbfirst Values are transmitted most significant byte first. @end table Except where explicitly noted in the protocol, all 16-bit and 32-bit quantities sent by the client must be transmitted with this @var{byte-order}, and all 16-bit and 32-bit quantities returned by the server are transmitted with this @var{byte-order}. @table @var @item byte-order Either @var{:lsbfirst} or @var{:msbfirst}. @end table @end defun @defun display-display display @table @var @item display A @var{display} object. @end table Returns the @var{display-number} for the host associated with @var{display}. @table @var @item display-number Type @var{integer}. @end table @end defun @defun display-error-handler display @table @var @item display A @var{display} object. @end table Returns and (with @code{setf}) sets the @var{error-handler} function for the given @var{display}. CLX calls (one of) the display error handler functions to handle server errors returned to the connection. The default error handler, @var{default-error-handler}, signals conditions as they occur. @xref{Errors}, for a list of the conditions that CLX can signal. For more information about errors and error handling, refer to the section entitled Common Lisp Condition System in the @emph{Lisp Reference} manual. If the value of @var{error-handler} is a sequence, it is expected to contain a handler function for each specific error. The error code is used as an index into the sequence to fetch the appropriate handler function. If this element is a function, it is called for all errors. Any results returned by the handler are ignored since it is assumed the handler either takes care of the error completely or else signals. The arguments passed to the handler function are the @var{display} object, a symbol naming the type of error, and a set of keyword-value argument pairs that vary depending on the type of error. For all core errors, the keyword-value argument pairs are: @multitable @columnfractions 0.5 0.5 @item @var{:current-sequence} @tab @var{card16} @item @var{:major} @tab @var{card8} @item @var{:minor} @tab @var{card16} @item @var{:sequence} @tab @var{card16} @end multitable For @var{colormap}, @var{cursor}, @var{drawable}, @var{font}, @var{gcontext}, @var{id-choice}, @var{pixmap}, and @var{window} errors, the keyword-value pairs are the core error pairs plus: @multitable @columnfractions 0.5 0.5 @item @var{:resource-id} @tab @var{card32} @end multitable For @var{:atom} errors, the keyword-value pairs are the core error pairs plus: @multitable @columnfractions 0.5 0.5 @item @var{:atom-id} @tab @var{card32} @end multitable For @var{:value} errors, the keyword-value pairs are the core error pairs plus: @multitable @columnfractions 0.5 0.5 @item @var{:value} @tab @var{card32} @end multitable @table @var @item error-handler Type @var{function} or @var{sequence}. @end table @end defun @defun display-image-lsb-first-p display @table @var @item display A @var{display} object. @end table Although the server is generally responsible for byte swapping communication data to match the client, images (pixmaps/bitmaps) are always transmitted and received in formats (including byte order) specified by the server. Within images for each scan-line unit in bitmaps or for each pixel value in pixmaps, the leftmost bit in the image as displayed on the screen is either the least or most significant bit in the unit. For the given @var{display}, @var{display-image-lsb-first-p} returns non-@var{nil} if the leftmost bit is the least significant bit; otherwise, it returns @var{nil}. @table @var @item image-lsb-first-p Type @var{boolean}. @end table @end defun @defun display-keycode-range display @table @var @item display A @var{display} object. @end table Returns @var{min-keycode} and @var{max-keycode} as multiple values. See the @var{display-max-keycode} and @var{display-min-keycode} functions for additional information. @table @var @item min-keycode @itemx max-keycode Type @var{card8}. @end table @end defun @defun display-max-keycode display @table @var @item display A @var{display} object. @end table Returns the maximum keycode value for the specified @emph{display}. This value is never greater than 255. Not all keycodes in the allowed range are required to have corresponding keys. @table @var @item max-keycode Type @var{card8}. @end table @end defun @defun display-max-request-length display @table @var @item display A @var{display} object. @end table Returns the maximum length of a request, in four-byte units, that is accepted by the specified @emph{display}. Requests larger than this generate a length error, and the server will read and simply discard the entire request. This length is always at least 4096 (that is, requests of length up to and including 16384 bytes are accepted by all servers). @table @var @item max-request-length Type @var{card16}. @end table @end defun @defun display-min-keycode display @table @var @item display A @var{display} object. @end table Returns the minimum keycode value for the specified @var{display}. This value is never less than eight. Not all keycodes in the allowed range are required to have corresponding keys. @table @var @item min-keycode Type @var{card8}. @end table @end defun @defun display-motion-buffer-size display @table @var @item display A @var{display} object. @end table Returns the approximate size of the motion buffer for the specified @var{display}. The server can retain the recent history of pointer motion at a finer granularity than is reported by @var{:motion-notify} events. Such history is available through the @var{motion-events} function. @table @var @item motion-buffer-size Type @var{card32}. @end table @end defun @defun display-p display @table @var @item display-p Type @var{boolean}. @end table Returns non-@var{nil} if @emph{display} is a @var{display} object; @end defun @defun display-pixmap-formats display @table @var @item display A @var{display} object. @end table Returns the list of @var{pixmap-format} values for the given @emph{display}. This list contains one entry for each depth value. The entry describes the format used to represent images of that depth. An entry for a depth is included if any screen supports that depth, and all screens supporting that depth must support (only) the format for that depth. @table @var @item pixmap-formats Type @var{list}. @end table @end defun @defun display-plist display @table @var @item display A @var{display} object. @end table Returns and (with @code{setf}) sets the property list for the specified @emph{display}. This function provides a hook where extensions can add data. @table @var @item plist Type @var{list}. @end table @end defun @defun display-protocol-major-version display @table @var @item display A @var{display} object. @end table Returns the major version number of the X protocol associated with the specified @emph{display}. In general, the major version would increment for incompatible changes. The returned protocol version number indicates the protocol the server actually supports. This might not equal the version supported by the client. The server can (but need not) refuse connections from clients that offer a different version than the server supports. A server can (but need not) support more than one version simultaneously. @table @var @item protocol-major-version Type @var{card16}. @end table @end defun @defun display-protocol-minor-version display @table @var @item display A @var{display} object. @end table Returns the minor protocol revision number associated with the specified @emph{display}. In general, the minor version would increment for small upward compatible changes in the X protocol. @table @var @item protocol-minor-version Type @var{card16}. @end table @end defun @defun display-protocol-version display @table @var @item display A @var{display} object. @end table Returns @emph{protocol-major-version} and @emph{protocol-minor-version} as multiple values. See the @var{display-protocol-major-version} and @var{display-protocol-minor-version} functions for additional information. @table @var @item protocol-major-version @itemx protocol-minor-version @end table @end defun @defun display-resource-id-base display @table @var @item display A @var{display} object. @end table Returns the @emph{resource-id-base} value that was returned from the server during connection setup for the specified @emph{display}. This is used in combination with the @emph{resource-id-mask} to construct valid IDs for this connection. @table @var @item resource-id-base Type @var{resource-id}. @end table @end defun @defun display-resource-id-mask display @table @var @item display A @var{display} object. @end table Returns the @emph{resource-id-mask} that was returned from the server during connection setup for the specified @emph{display}. The @emph{resource-id-mask} contains a single contiguous set of bits (at least 18) which the client uses to allocate resource IDs for types @var{window}, @var{pixmap}, @var{cursor}, @var{font}, @var{gcontext}, and @var{colormap} by choosing a value with (only) some subset of these bits set, and @var{or}ing it with the @emph{resource-id-base}. Only values constructed in this way can be used to name newly created server resources over this connection. Server resource IDs never have the top three bits set. The client is not restricted to linear or contiguous allocation of server resource IDs. Once an ID has been freed, it can be reused, but this should not be necessary. An ID must be unique with respect to the IDs of all other server resources, not just other server resources of the same type. However, note that the value spaces of server resource identifiers, atoms, visualids, and keysyms are distinguished by context, and as such are not required to be disjoint (for example, a given numeric value might be both a valid window ID, a valid atom, and a valid keysym.) @table @var @item resource-id-mask Type @var{resource-id}. @end table @end defun @defun display-roots display @table @var @item display A @var{display} object. @end table Returns a list of all the @var{screen} structures available for the given @emph{display}. @table @var @item roots A list of screens. @end table @end defun @defun display-vendor display @table @var @item display A @var{display} object. @end table Returns @emph{vendor-name} and @emph{release-number} as multiple values. See the @var{display-vendor-name} and @var{display-release-number} functions for additional information. @table @var @item vendor-name @itemx release-number @end table @end defun @defun display-vendor-name display @table @var @item display A @var{display} object. @end table Returns a string that provides some vendor identification of the X server implementation associated with the specified @emph{display}. @table @var @item vendor-name Type @var{string}. @end table @end defun @defun display-version-number display @table @var @item display A @var{display} object. @end table Returns the X protocol version number for this implementation of CLX. @table @var @item version-number Type @var{card16}. @end table @end defun @defun display-xid display @table @var @item display A @var{display} object. @end table Returns the function that is used to allocate server resource IDs for this @emph{display}. @table @var @item resource-allocator Type @var{function}. @end table @end defun @defmac with-display display &body body This macro is for use in a multi-process environment. @var{with-display} provides exclusive access to the local @var{display} object for multiple request generation. It need not provide immediate exclusive access for replies. That is, if another process is waiting for a reply (while not in a @var{with-display}), then synchronization need not (but can) occur immediately. Except where noted, all routines effectively contain an implicit @var{with-display} where needed, so that correct synchronization is always provided at the interface level on a per-call basis. Nested uses of this macro work correctly. This macro does not prevent concurrent event processing (@pxref{with-event-queue}). @table @var @item display A @var{display}. @end table @end defmac @node Managing the Output Buffer, Closing the Display, Display Attributes, Displays @section Managing the Output Buffer Most CLX functions cause output requests to be generated to an X server. Output requests are not transmitted immediately but instead are stored in an @emph{output buffer} for the appropriate display. Requests in the output buffer are typically sent only when the buffer is filled. Alternatively, buffered requests can be sent prior to processing an event in the input event queue (@pxref{Processing Events}). In either case, CLX sends the output buffer automatically without explicit instructions from the client application. However, in some cases, explicit control over the output buffer is needed, typically to ensure that the X server is in a consistent state before proceeding further. The @var{display-force-output} and @var{display-finish-output} functions allow a client program to synchronize with buffered output requests. @defun display-after-function display @table @var @item display A @var{display} object. @end table Returns and (with @code{setf}) sets the @emph{after-function} for the given @emph{display}. If @emph{after-function} is non-@var{nil}, it is a function that is called after every protocol request is generated, even those inside an explicit @var{with-display}, but never called from inside the @emph{after-function}. The function is called inside the effective @var{with-display} for the associated request. The default value is @var{nil}. This can be set, for example, to #'@var{display-force-output} or #' @var{display-finish-outpu}t. @table @var @item after-function Type @var{function} or @var{null}. @end table @end defun @defun display-force-output display @anchor{display-force-output} @table @var @item display A @var{display} object. @end table Forces any buffered output to be sent to the X server. @end defun @defun display-finish-output display @anchor{display-finish-output} @table @var @item display A @var{display} object. @end table Forces any buffered output to be sent to the X server and then waits until all requests display error handler. Any events generated by output requests are read and stored in the event queue. @end defun @node Closing the Display, , Managing the Output Buffer, Displays @section Closing the Display To close or disconnect a display from the X server, use @var{close-display}. @defun close-display display @table @var @item display A @var{display} object. @end table Closes the connection to the X server for the specified @var{display}. It destroys all server resources (@var{window}, @var{font}, @var{pixmap}, @var{colormap}, @var{cursor}, and @var{gcontext}), that the client application has created on this display, unless the close down mode of the server resource has been changed (@pxref{set-close-down-mode}). Therefore, these server resources should never be referenced again. In addition, this function discards any output requests that have been buffered but have not yet been sent. @end defun @node Screens, Windows and Pixmaps, Displays, Top @chapter Screens @menu * Screens and Visuals:: * Screen Attributes:: @end menu @node Screens and Visuals, Screen Attributes, Screens, Screens @section Screens and Visuals An X display supports graphical output to one or more @emph{screens}. Each screen has its own root window and window hierarchy. Each window belongs to exactly one screen and cannot simultaneously appear on another screen. The kinds of graphics hardware used by X screens can vary greatly in their support for color and in their methods for accessing raster memory. X uses the concept of a @emph{visual type} (usually referred to simply as a @emph{visual}) which uniquely identifies the hardware capabilities of a display screen. Fundamentally, a visual is represented by a @var{card29} integer ID, which uniquely identifies the visual type relative to a single display. CLX also represents a visual with a @var{visual-info} structure that contains other attributes associated with a visual (@pxref{Data Types}). A screen can support more than one depth (that is, pixel size), and for each supported depth, a screen may support more than one visual. However, it is more typical for a screen to have only a single depth and a single visual type. A visual represents various aspects of the screen hardware, as follows: @itemize @bullet @item A screen can be color or gray-scale. @item A screen can have a colormap that is either writable or read-only. @item A screen can have a single colormap or separate colormaps for each of the red, green, and blue components. With separate colormaps, a pixel value is decomposed into three parts to determine indexes into each of the red, green, and blue colormaps. @end itemize CLX supports the following classes of visual types: @var{:direct-color}, @var{:gray-scale}, @var{:pseudo-color}, @var{:static-color}, @var{:static-gray}, and @var{:true-color}. The following tables show how the characteristics of a screen determine the class of its visual type. For screens with a single colormap: @multitable {} {Color} {Gray-Scale} @item Read-only @tab @var{:static-color} @tab @var{:static-gray} @item Writable @tab @var{:pseudo-color} @tab @var{:gray-scale} @end multitable For screens with red, green, and blue colormaps: @multitable @columnfractions 0.3 0.3 0.3 @item Read-only @tab @var{:true-color} @tab @item Writable @tab @var{:direct-color} @tab @var{:gray-scale} @end multitable The visual class also indicates how screen colormaps are handled. @pxref{Colormaps and Colors}). @node Screen Attributes, , Screens and Visuals, Screens @section Screen Attributes In CLX, each display screen is represented by a @var{screen} structure. The @var{display-roots} function returns the list of @var{screen} structures for the display. The following paragraphs discuss the attributes of CLX @var{screen} structures. @defun screen-backing-stores screen @table @var @item screen A @var{screen}. @end table Returns a value indicating when the @emph{screen} supports backing stores, although it may be storage limited in the number of windows it can support at once. The value returned can be one of @var{:always}, @var{:never}, or @var{:when-mapped}. @table @var @item backing-stores-type One of @var{:always}, @var{:never}, or @var{:when-mapped}. @end table @end defun @defun screen-black-pixel screen @table @var @item screen A @var{screen}. @end table Returns the black pixel value for the specified @emph{screen}. @table @var @item black-pixel Type @var{pixel}. @end table @end defun @defun screen-default-colormap screen @table @var @item screen A @var{screen}. @end table Returns the @emph{default-colormap} for the specified @emph{screen}. The @emph{default-colormap} is initially associated with the root window. Clients with minimal color requirements creating windows of the same depth as the root may want to allocate from this map by default. Most routine allocations of color should be made out of this colormap. @table @var @item default-colormap Type @var{colormap}. @end table @end defun @defun screen-depths screen @table @var @item screen A @var{screen}. @end table Returns an association list that specifies what drawable depths are supported on the specified @emph{screen}. Elements of the returned association list have the form (depth @emph{visual}*), where each @emph{visual} is a @var{visual-info} structure. Pixmaps are supported for each depth listed, and windows of that depth are supported if at least one visual type is listed for the depth. A pixmap depth of one is always supported and listed, but windows of depth one might not be supported. A depth of zero is never listed, but zero-depth @var{:input-only} windows are always supported. @table @var @item depths Type @var{alist}. @end table @end defun @defun screen-event-mask-at-open screen @table @var @item screen A @var{screen}. @end table Returns the initial root event mask for the specified @emph{screen}. @table @var @item event-mask-at-open Type @var{mask32}. @end table @end defun @defun screen-height screen @table @var @item screen A @var{screen}. @end table Returns the @emph{height} of the specified @emph{screen} in pixel units. @table @var @item height Type @var{card16}. @end table @end defun @defun screen-height-in-millimeters screen @table @var @item screen A @var{screen}. @end table Returns the height of the specified @emph{screen} in millimeters. The returned height can be used with the width in millimeters to determine the physical size and the aspect ratio of the screen. @table @var @item height-in-millimeters Type @var{card16}. @end table @end defun @defun screen-max-installed-maps screen @table @var @item screen A @var{screen}. @end table Returns the maximum number of colormaps that can be installed simultaneously with @var{install-colormap}. @table @var @item max-installed-colormaps Type @var{card16}. @end table @end defun @defun screen-min-installed-maps screen @table @var @item screen A @var{screen}. @end table Returns the minimum number of colormaps that can be guaranteed to be installed simultaneously. @table @var @item min-installed-colormaps Type @var{card16}. @end table @end defun @defun screen-p screen @table @var @item screen-p Type @var{boolean}. @end table Returns non-@code{nil} if the @emph{screen} argument is a @end defun @defun screen-plist screen @table @var @item screen A @var{screen}. @end table Returns and (with @code{setf}) sets the property list for the specified @emph{screen}. This function provides a hook where extensions can add data. @table @var @item plist Type @var{list}. @end table @end defun @defun screen-root screen @table @var @item screen A @var{screen}. @end table Returns the @emph{root-window} for the specified @emph{screen}. This function is useful with functions that take a parent window as an argument. The class of the root window is always @var{:input-output}. @table @var @item root-window Type @var{window} or @var{null}. @end table @end defun @defun screen-root-depth screen @table @var @item screen A @var{screen}. @end table Returns the depth of the root window for the specified @emph{screen}. Other depths can also be supported on this @emph{screen}. @table @var @item root-window-depth Type @var{image-depth}. @end table @end defun @defun screen-root-visual screen @table @var @item screen A @var{screen}. @end table Returns the default visual type for the root window for the specified @emph{screen}. @table @var @item root-window-visual Type @var{card29}. @end table @end defun @defun screen-save-unders-p screen @table @var @item screen A screen. @end table If true, the server can support the save-under mode in @var{create-window} and in changing window attributes. @table @var @item save-unders-p Type @var{boolean}. @end table @end defun @defun screen-white-pixel screen @table @var @item screen A screen. @end table Returns the white pixel value for the specified @emph{screen}. @table @var @item white-pixel Type @var{pixel}. @end table @end defun @defun screen-width screen @table @var @item screen A screen. @end table Returns the width of the specified @emph{screen} in pixel units. @table @var @item width Type @var{card16}. @end table @end defun @defun screen-width-in-millimeters screen @table @var @item screen A screen. @end table Returns the width of the specified @emph{screen} in millimeters. The returned width can be used with the height in millimeters to determine the physical size and the aspect ratio of the screen. @table @var @item width-in-millimeters Type @var{card16}. @end table @end defun @node Windows and Pixmaps, Graphics Contexts, Screens, Top @chapter Windows and Pixmaps @menu * Drawables:: * Creating Windows:: * Window Attributes:: * Stacking Order:: * Window Hierarchy:: * Mapping Windows:: * Destroying Windows:: * Pixmaps:: @end menu @node Drawables, Creating Windows, Windows and Pixmaps, Windows and Pixmaps @section Drawables Both windows and pixmaps can be used as sources and destinations in graphics operations. These are collectively known as @emph{drawables}. The following functions apply to both windows and pixmaps. @defun drawable-display drawable @table @var @item drawable A @var{drawable} object. @end table Returns the display for the specified @emph{drawable}. @end defun @defun drawable-equal drawable-1 drawable-2 @table @var @item drawable-1 @itemx drawable-2 @var{drawable} objects. @end table Returns true if the two arguments refer to the same server resource, and @var{nil} if they do not. @end defun @defun drawable-id drawable @table @var @item drawable A @var{drawable} object. @end table Returns the unique resource ID assigned to the specified @var{drawable}. @table @var @item id Type @var{resource-id}. @end table @end defun @defun drawable-p drawable @table @var @item boole Type @var{boolean}. @end table Returns true if the argument is a @var{drawable} and @var{nil} otherwise. @end defun @defun drawable-plist drawable @table @var @item plist A property list. @end table Returns and (with @code{setf}) sets the property list for the specified @emph{drawable}. This function provides a hook where extensions can add data. @end defun @node Creating Windows, Window Attributes, Drawables, Windows and Pixmaps @section Creating Windows A window is a @var{drawable} that can also receive input events. CLX represents a window with a @var{window} object. The @var{create-window} function creates a new @var{window} object. @defun create-window &key :parent :x :y :width :height (:depth 0) (:border-width 0) (:class :copy) (:visual :copy) :background :border :gravity :bit-gravity :backing-store :backing-planes :backing-pixel :save-under :event-mask :do-not-propagate-mask :override-redirect :colormap :cursor @anchor{create-window} @table @var @item :parent The parent window. This argument is required. @item :x @itemx :y @var{int16} coordinates for the outside upper-left corner of the new window with respect to the origin (inside upper-left corner) of the @var{:parent}. These arguments are required. @item :width @itemx :height @var{card16} values for the size of the new window. These arguments are required. @item :depth A @var{card16} specifying the depth of the new window. @item :class One of @var{:input-outpu}t, @var{:input-only}, or @var{:copy}. @item :visual A @var{card29} ID specifying the visual type of the new window. @item :background @itemx :backing-pixel @itemx :backing-planes @itemx :backing-store @itemx :bit-gravity @itemx :border @itemx :border-width @itemx :colormap @itemx :cursor @itemx :do-not-propagate-mask @itemx :event @itemx :gravity @itemx :override-redirect @itemx :save-under Initial attribute values for the new window. If @var{nil}, the default value is defined by the X protocol.See paragraph @end table Creates and returns a window. A @var{:parent} window must be specified; the first window created by a client will have a root window as its @var{:parent}. The new window is initially unmapped and is placed on top of its siblings in the stacking order. A @var{:create-notify} event is generated by the server. The @var{:class} of a window can be @var{:input-output} or @var{:input-only}. Windows of class @var{:input-only} cannot be used as the destination drawable for graphics output and can never receive @var{:exposure} events, but otherwise operate the same as @var{:input-output} windows. The @var{:class} can also be @var{:copy}, in which case the new window has the same class as its @var{:parent}. For an @var{:input-output} window, the @var{:visual} and @var{:depth} must be a combination supported by the @var{:parent}'s screen, but the @var{:depth} need not be the same as the @var{:parent}'s. The @var{:parent} of an @var{:input-output} window must also be @var{:input-output}. A @var{:depth} of 0 means that the depth of the @var{:parent} is used. For an @var{:input-only} window, the @var{:depth} must be zero, and the @var{:visual} must be supported by the @var{:parent}'s screen. The @var{:parent} of an @var{:input-only} window can be of any class. The only attributes that can be given for an @var{:input-only} window are @var{:cursor}, @var{:do-not-propagate-mask}, @var{:event-mask}, @var{:gravity}, and @var{:override-redirect}. @table @var @item window Type @var{window}. @end table @end defun @node Window Attributes, Stacking Order, Creating Windows, Windows and Pixmaps @section Window Attributes The following paragraphs describe the CLX functions used to return or change window attributes. Using the @var{with-state} macro improves the performance of attribute access by batching related accesses in the minimum number of server requests. @defun drawable-border-width drawable @table @var @item drawable A @var{drawable} object. @end table Returns the @emph{border-width} of the @emph{drawable} in pixels. It always returns zero if the @emph{drawable} is a pixmap or an @var{:input-only} window. Used with @code{setf}, this function also changes the border width of the @var{:input-only} window. The default border width of a new window is zero. Changing just the border width leaves the outer left corner of a window in a fixed position but moves the absolute position of the window's origin. It is an error to make the border width of an @var{:input-only} window nonzero. When changing the border-width of a window, if the override-redirect attribute of the window is @var{:off} and some other client has selected @var{:substructure-redirect} on the parent, a @var{:configure-request} event is generated, and no further processing is performed. Otherwise, the border-width is changed. @table @var @item border-width Type @var{card16}. @end table @end defun @defun drawable-depth drawable @table @var @item drawable A @var{drawable} object. @end table Returns the depth of the specified @emph{drawable} (bits per pixel). @table @var @item depth Type @var{card8}. @end table @end defun @defun drawable-height drawable @table @var @item inside-height Type @var{card16}. @end table @end defun @defun drawable-width drawable @table @var @item drawable A @var{drawable} object. @end table These functions return the height or width of the @emph{drawable}. These coordinates define the inside size of the @emph{drawable}, in pixels. Used with @code{setf}, these functions also change the inside height or width of a window. However, the height or width of a pixmap cannot be changed. Changing the width and height resizes a window without changing its position or stacking priority. Changing the size of a mapped window may cause the window to lose its contents and generate an @var{:exposure} event. If a mapped window is made smaller, @var{:exposure} events are generated on windows that it formerly obscured. When changing the size of a window, if the override-redirect attribute of the window is @var{:off} and some other client has selected @var{:substructure-redirect} on the parent, a @var{:configure-request} event is generated, and no further processing is performed. Otherwise, if another client has selected @var{:resize-redirect} on the window, a @var{:resize-request} event is generated, and the current inside width and height are maintained. Note that the override-redirect attribute of the window has no effect on @var{:resize-redirect} and that @var{:substructure-redirect} on the parent has precedence over @var{:resize-redirect} on the window. When the inside size of the window is changed, the children of the window can move according to their window gravity. Depending on the window's bit gravity, the contents of the window can also be moved. @table @var @item inside-width Type @var{card16}. @end table @end defun @defun drawable-x drawable @table @var @item outside-left Type @var{int16}. @end table @end defun @defun drawable-y drawable @table @var @item drawable A @var{drawable} object. @end table These functions return the x or y coordinate of the specified @emph{drawable}. They always return zero if the @emph{drawable} is a pixmap. These coordinates define the location of the top left pixel of the window's border or of the window, if it has no border. Used with @code{setf}, these functions also change the x or y coordinate of a window. However, the x or y coordinate of a pixmap cannot be changed. Changing the x and y coordinates moves a window without changing its size or stacking priority. Moving a mapped window generates @var{:exposure} events on any formerly obscured windows. When changing the position of a window, if the override-redirect attribute of the window is @var{:off} and some other client has selected @var{:substructure-redirect} on the parent, a @var{:configure-request} event is generated, and no further processing is performed. Otherwise, the window is moved. @table @var @item outside-top Type @var{int16}. @end table @end defun @defun window-all-event-masks window @table @var @item window A @var{window}. @end table Returns the inclusive-or of the event masks selected on the specified @emph{window} by all clients. @table @var @item all-event-masks Type @var{mask32}. @end table @end defun @defun setf (window-background) window background @table @var @item window A @var{window}. @item background Either a @var{pixel}, a @var{pixmap}, @var{:none}, or @var{:parent-relative}. @end table Changes the @emph{background} attribute of the @emph{window} to the specified value. This operation is not allowed on an @var{:input-only} window. Changing the background does not cause the window contents to be changed. Note that the background of a window cannot be returned from the X server. The default background of a new window is @var{:none}. In general, the server automatically fills in exposed areas of the window when they are first made visible. A background pixmap is tiled to fill each area. However, if the background is @var{:none}, the server will not modify exposed areas. If the background is @var{:parent-relative}, the window and its parent must have the same depth. In this case, the window shares the same background as its parent. The parent's background is not copied and is reexamined whenever the window's background is required. If the background is @var{:parent-relative}, the background pixmap tile origin is the same as the parent's; otherwise, the tile origin is the window origin. @table @var @item background Either a @var{pixel}, a @var{pixmap}, @var{:none}, or @var{:parent-relative}. @end table @end defun @defun window-backing-pixel window @table @var @item window A @var{window}. @end table Returns and (with @code{setf}) changes the value of the backing-pixel attribute for the specified @emph{window}. Changing the backing-pixel attribute of a mapped window may have no immediate effect. The default backing-pixel of a new window is zero. @table @var @item backing-pixel Type @var{pixel}. @end table @end defun @defun window-backing-planes window @table @var @item window A @var{window}. @end table Returns and (with @code{setf}) changes the value of the backing-planes attribute for the specified @emph{window}. Changing the backing-planes attribute of a mapped window may have no immediate effect. The default backing-planes of a new window is all one's. @table @var @item backing-planes Type @var{pixel}. @end table @end defun @defun window-backing-store window @table @var @item window A @var{window}. @end table Returns and (with @code{setf}) changes the value of the backing-store attribute for the specified @emph{window}. Changing the backing-store attribute of an obscured window to @var{:when-mapped} or @var{:always} may have no immediate effect. The default backing-store of a new window is @var{:not-useful}. @table @var @item backing-store-type One of @var{:always}, @var{:not-useful}, or @var{:when-mapped}. @end table @end defun @defun window-bit-gravity window @table @var @item window A @var{window}. @end table Returns and (with @code{setf}) changes the bit-gravity attribute of the @emph{window}. If a window is reconfigured without changing its inside width or height, the contents of the window move with the window and are not lost. Otherwise, the contents of the resized window are either moved or lost, depending on its bit-gravity attribute. The default bit-gravity of a new window is @var{:forget}. For example, suppose a window's size is changed by @emph{W} pixels in width and @emph{H} pixels in height. The following table shows, for each bit-gravity value, the change in position (relative to the window origin) that results for each pixel of the window contents. @multitable {Bit-Gravity} {X Change} {Y Change} @item @var{:center} @tab @emph{W/}2 @tab @emph{H/}2 @item @var{:east} @tab @emph{W} @tab @emph{H/}2 @item @var{:north} @tab @emph{W/}2 @tab 0 @item @var{:north-east} @tab @emph{W} @tab 0 @item @var{:north-west} @tab 0 @tab 0 @item @var{:south} @tab @emph{W/}2 @tab @emph{H} @item @var{:south-east} @tab W @tab H @item @var{:south-west} @tab 0 @tab H @item @var{:west} @tab 0 @tab H/2 @end multitable A @var{:static} bit-gravity indicates the contents or window should not move relative to the origin of the root window. A server can choose to ignore the specified bit-gravity attribute and use @var{:forget} instead. A @var{:forget} bit-gravity attribute indicates that the window contents are always discarded after a size change, even if backing-store or save-under attributes are @var{:on}. The window's background is displayed (unless it is @var{:none}), and zero or more @var{:exposure} events are generated. @table @var @item bit-gravity Type @var{bit-gravity}. @end table @end defun @defun setf (window-border) window border @table @var @item window A @var{window}. @item border Either a @var{pixel}, a @var{pixmap}, or @var{:copy}. @end table Changes the @emph{border} attribute of the @emph{window} to the specified value. This operation is not allowed on an @var{:input-only} window. Changing the border attribute also causes the window border to be repainted. Note that the border of a window cannot be returned from the X server. The default border of a new window is @var{:copy}. A border pixmap is tiled to fill the border. The border pixmap tile origin is the same as the background tile origin. A border pixmap and the window must have the same root and depth. If the border is @var{:copy}, the parent's border is copied and used; subsequent changes to the parent's border do not affect the window border. @table @var @item border Either a @var{pixel}, a @var{pixmap}, or @var{:copy}. @end table @end defun @defun window-class window @table @var @item window A @var{window}. @end table Returns the @emph{class} of the specified @emph{window}. @table @var @item class Either @var{:input-output} or @var{:input-only}. @end table @end defun @defun window-colormap window @table @var @item window A @var{window}. @end table Returns and (with @code{setf}) changes the value of the colormap attribute for the specified @emph{window}. A value of @var{:copy} is never returned, since the parent's colormap attribute is actually copied, but the attribute can be set to @var{:copy} in a @code{setf} form. Changing the colormap of a window (defining a new map, not changing the contents of the existing map) generates a @var{:colormap-notify} event. Changing the colormap of a visible window may have no immediate effect on the screen (@pxref{install-colormap}). The default colormap of a new window is @var{:copy}. @table @var @item colormap Type @var{colormap} or @var{null}. @end table @end defun @defun window-colormap-installed-p window @table @var @item window A @var{window}. @end table Returns non-@var{nil} if the colormap associated with this @emph{window} is installed. Otherwise, this function returns @var{nil}. @table @var @item colormap-installed-p Type @var{boolean}. @end table @end defun @defun setf (window-cursor) window cursor @table @var @item window A @var{window}. @item cursor Either @var{cursor} or @var{:none}. @end table Changes the @emph{cursor} attribute of the @emph{window} to the specified value. Changing the cursor of a root window to @var{:none} restores the default cursor. Note that the cursor of window cannot be returned from the X server. The default cursor of a new window is @var{:none}. @table @var @item cursor Type @var{cursor} or @var{:none}. @end table @end defun @defun window-display window @table @var @item window A @var{window}. @end table Returns the @var{display} object associated with the specified @emph{window}. @table @var @item display Type @var{display}. @end table @end defun @defun window-do-not-propagate-mask window @table @var @item window A @var{window}. @end table Returns and (with @code{setf}) changes the do-not-propagate-mask attribute for the window. The default do-not-propagate-mask of a new window is zero. If a window receives an event from one of the user input devices, and if no client has selected to receive the event, the event can instead be propagated up the window hierarchy to the first ancestor for which some client has selected it. However, any event type selected by the do-not-propagate-mask is not be propagated. The types of events that can be selected by the do-not-propagate-mask are those of type @var{device-event-mask-class}. @xref{Selecting Events}. @table @var @item do-not-propagate-mask Type @var{mask32}. @end table @end defun @defun window-equal window-1 window-2 @table @var @item window-1 @itemx window-2 The windows to compare for equality. @end table Returns non-@var{nil} if the two arguments are the same window, and @var{nil} if they are not. @table @var @item equal-p Type @var{boolean}. @end table @end defun @defun window-event-mask window @table @var @item window A @var{window}. @end table Returns and (with @code{setf}) changes the value of the event-mask attribute for the @emph{window}. The default event-mask of a new window is zero. @table @var @item event-mask Type @var{mask32}. @end table @end defun @defun window-gravity window @table @var @item window A @var{window}. @end table Returns and (with @code{setf}) changes the gravity attribute of the @emph{window}. If a parent window is reconfigured without changing its inside width or height, then all child windows move with the parent and are not changed. Otherwise, each child of the resized parent is moved, depending on the child's gravity attribute. The default gravity of a new window is @var{:north-west}. For example, suppose the size of the window's parent is changed by @emph{W} pixels in width and @emph{H} pixels in height. The following table shows, for each possible gravity value, the resulting change in the window's position relative to its parent's origin. When the window is moved, two events are generated--a @var{:configure-notify} event followed by a @var{:gravity-notify} event. @multitable {Gravity} {X Change} {Y Change} @item @var{:center} @tab @emph{W/}2 @tab @emph{H/}2 @item @var{:east} @tab @emph{W} @tab @emph{H/}2 @item @var{:north} @tab @emph{W/}2 @tab 0 @item @var{:north-east} @tab @emph{W} @tab 0 @item @var{:north-west} @tab 0 @tab 0 @item @var{:south} @tab @emph{W/}2 @tab @emph{H} @item @var{:south-east} @tab W @tab H @item @var{:south-west} @tab 0 @tab H @item @var{:west} @tab 0 @tab H/2 @end multitable A @var{:static} gravity indicates that the position of the window should not move relative to the origin of the root window. An @var{:unmap} gravity is like @var{:north-west}, except the window is also unmapped and an @var{:unmap-notify} event is generated. This @var{:unmap-notify} event is generated after the @var{:configure-notify} event is generated for the parent. @table @var @item gravity Type @var{win-gravity}. @end table @end defun @defun window-id window @table @var @item window A @var{window}. @end table Returns the unique ID assigned to @emph{window}. @table @var @item id Type @var{resource-id}. @end table @end defun @defun window-map-state window @table @var @item window A @var{window}. @end table Returns the map state of @emph{window}. A window is @var{:unviewable} if it is mapped but some ancestor is unmapped. @table @var @item map-state One of @var{:unmapped}, @var{:unviewable}, or @var{:viewable}. @end table @end defun @defun window-override-redirect window @table @var @item window A @var{window}. @end table Returns and (with @code{setf}) changes the value of the override-redirect attribute for @emph{window}. The default override-redirect of a new window is @var{:off}. The override-redirect attribute determines whether or not attempts to change window geometry or parent hierarchy can be @emph{redirected} by a window manager or some other client. The functions that might be affected by the override-redirect attribute are @var{circulate-window-down}, @var{circulate-window-up}, @var{drawable-border-width}, @var{drawable-height}, @var{drawable-width}, @var{drawable-x}, @var{drawable-y}, @var{map-window}, and @var{window-priority}. @table @var @item override-redirect Either @var{:on} or @var{:off}. @end table @end defun @defun window-p object @table @var @item window-p Type @var{boolean}. @end table Returns non-@var{nil} if the @emph{object} argument is a window; otherwise, it returns @var{nil}. @end defun @defun window-plist window @table @var @item window A @var{window}. @end table Returns and (with @code{setf}) sets the property list for the specified @emph{window}. This function provides a hook where extensions can hang data. @table @var @item plist A property list. @end table @end defun @defun setf (window-priority window) (&optional sibling) mode @table @var @item window A @var{window}. @item sibling An optional argument specifying that @emph{window} is to be restacked relative to this sibling @var{window}. @item mode One of @var{:above}, @var{:below}, @var{:bottom-if}, @var{:opposite}, or @var{:top-if}. @end table Changes the stacking priority element of the @emph{window} to the specified value. It is an error if the @emph{sibling} argument is specified and is not actually a sibling of the window. Note that the priority of an existing window cannot be returned from the X server. When changing the priority of a window, if the override-redirect attribute of the window is @var{:off} and some other client has selected :substructure-redirect on the parent, a :configure-request event is generated, and no further processing is performed. Otherwise, the priority is changed. @table @var @item mode One of @var{:above}, @var{:below}, @var{:bottom-if}, @var{:opposite}, or @var{:top-if}. @end table @end defun @defun window-save-under window @table @var @item window A @var{window}. @end table Returns and (with @code{setf}) changes the value of the save-under attribute for the specified @emph{window}. Changing the save-under attribute of a mapped window may have no immediate effect. @table @var @item save-under Either @var{:on} or @var{:off}. @end table @end defun @defun window-visual window @table @var @item window A @var{window}. @end table Returns the @emph{visual-type} associated with the specified @emph{window}. @table @var @item visual-type Type @var{card29}. @end table @end defun @defmac with-state drawable &body body @anchor{with-state} Batches successive read and write accesses to window attributes and drawable geometry, in order to minimize the number of requests sent to the server. Batching occurs automatically within the dynamic extent of the @emph{body}. The @emph{body} is not executed within a @var{with-display} form. All window attributes can be returned or changed in a single request. Similarly, all drawable geometry values can be returned or changed in a single request. @var{with-state} combines accesses to these values into the minimum number of server requests necessary to guarantee that each read access returns the current server state of the @emph{drawable}. The number of server requests sent depends on the sequence of calls to reader and @code{setf} functions within the dynamic extent of the @emph{body}. There are two groups of reader and @code{setf} functions--the Window Attributes group and the Drawable Geometry group--as shown in Table 4-1. @multitable {Group} {Reader Functions} {Setf Functions} @item Window Attributes @tab @var{window-all-event-masks} @tab @var{window-background} @item @tab @var{window-backing-pixel} @tab @var{window-backing-pixel} @item @tab @var{window-backing-planes} @tab @var{window-backing-planes} @item @tab @var{window-backing-store} @tab @var{window-backing-store} @item @tab @var{window-bit-gravity} @tab @var{window-bit-gravity} @item @tab @var{window-class} @tab @var{window-border} @item @tab @var{window-colormap} @tab @var{window-colormap} @item @tab @var{window-colormap-installed-p} @tab @var{window-cursor} @item @tab @var{window-do-not-propagate-mask} @tab @var{window-do-not-propagate-mask} @item @tab @var{window-event-mask} @tab @var{window-event-mask} @item @tab @var{window-gravity} @tab @var{window-gravity} @item @tab @var{window-map-state} @tab @item @tab @var{window-override-redirect} @tab @var{window-override-redirect} @item @tab @var{window-save-under} @tab @var{window-save-under} @item @tab @var{window-visual} @tab @item Drawable Geometry @tab @var{drawable-border-width} @tab @var{drawable-border-width} @item @tab @var{drawable-depth} @tab @var{drawable-height} @item @tab @var{drawable-height} @tab @var{drawable-width} @item @tab @var{drawable-root} @tab @var{drawable-x} @item @tab @var{drawable-width} @tab @var{drawable-y} @item @tab @var{drawable-x} @tab @var{window-priority} @item @tab @var{drawable-y} @tab @end multitable The results from a sequence of calls to @code{setf} functions in a given group are cached and sent in a single server request, either upon exit from the @emph{body} or when a reader function from the corresponding group is called. @var{with-state} sends a single request to update all its cached values for the @emph{drawable} before the first call to a reader function within the @emph{body} and also before the first call to a reader function following a sequence of calls to @code{setf} functions from the corresponding group. @table @var @item drawable A @var{display}. @item body The forms in which attributes accesses are batched. @end table @end defmac @node Stacking Order, Window Hierarchy, Window Attributes, Windows and Pixmaps @section Stacking Order Sibling windows can @emph{stack} on top of each other. Windows above can @emph{obscure} or @emph{occlude} lower windows. This relationship between sibling windows is known as the stacking order. The @var{window-priority} function can be used to change the stacking order of a single window. CLX also provides functions to raise or lower children of a window. Raising a mapped window can generate @var{:exposure} events for the window and any mapped subwindows that were formerly obscured. Lowering a mapped window can generate @var{:exposure} events on any windows it formerly obscured. @defun circulate-window-down window @table @var @item window A @var{window}. @end table Lowers the highest mapped child of the specified @emph{window} that partially or completely occludes another child to the bottom of the stack. Completely unobscured children are unaffected. Exposure processing is performed on formerly obscured windows. If some other client has selected @var{:substructure-redirect} on the @emph{window}, a @var{:circulate-request} event is generated, and no further processing is performed. Otherwise, the child window is lowered and a @var{:circulate-notify} event is generated if the @emph{window} is actually restacked. @end defun @defun circulate-window-up window @table @var @item window A @var{window}. @end table Raises the lowest mapped child of the specified @emph{window} that is partially or completely occluded by another child to the top of the stack. Completely unobscured children are unaffected. Exposure processing is performed on formerly obscured windows. If another client has selected @var{:substructure-redirect} on the @emph{window}, a @var{:circulate-request} event is generated, and no further processing is performed. Otherwise, the child window is raised and a @var{:circulate-notify} event is generated if the @emph{window} is actually restacked. @end defun @node Window Hierarchy, Mapping Windows, Stacking Order, Windows and Pixmaps @section Window Hierarchy All the windows in X are arranged in a strict hierarchy. At the top of the hierarchy are the root windows, which cover the display screens. Each root window is partially or completely covered by its child windows. All windows, except for root windows, have parents. Child windows can have their own children. In this way, a tree of arbitrary depth on each screen can be created. CLX provides several functions for examining and modifying the window hierarchy. @defun drawable-root drawable @table @var @item drawable A @var{drawable}. @end table Returns the root window of the specified @emph{drawable}. @table @var @item root-window Type @var{window}. @end table @end defun @defun query-tree window &key (:result-type `list) @table @var @item window A @var{window}. @item :result-type A valid type specifier for a sub-type of @var{sequence}. The default is a @var{list}. @end table Returns the @emph{children} windows, the @emph{parent} window, and the @emph{root} window for the specified @emph{window}. The children are returned as a sequence of windows in current stacking order, from bottom-most (first) to top-most (last). The @var{:result-type} specifies the type of children sequence returned. @table @var @item children Type @var{sequence} of @var{window}. @item parent Type @var{window} or @var{null}. @item root Type @var{window}. @end table @end defun @defun reparent-window window parent x y @table @var @item window A @var{window}. @item parent The new parent @var{window}. @item x @itemx y The position (type @var{int16}) of the @emph{window} in its new @emph{parent}. These coordinates are relative to the @emph{parent}'s origin, and specify the new position of the upper, left, outer corner of the @emph{window}. @end table Changes a @emph{window}'s @emph{parent} within a single screen. There is no way to move a window between screens. The specified @emph{window} is reparented by inserting it as a child of the specified @emph{parent}. If the @emph{window} is mapped, an @var{unmap-window} operation is automatically performed on the specified @emph{window}. The @emph{window} is then removed from its current position in the hierarchy and inserted as the child of the specified @emph{parent}. The @emph{window} is placed on top in the stacking order with respect to sibling windows. After reparenting the specified @emph{window,} a @var{:reparent-notify} event is generated. The override-redirect attribute of the @emph{window} is passed on in this event. Window manager clients normally should ignore this event if this attribute is @var{:on}. @xref{Events and Input}, for more information on @var{:reparent-notify} event processing. Finally, if the specified @emph{window} was originally mapped, a @var{map-window} operation is automatically performed on it. The X server performs normal exposure processing on formerly obscured windows. It might not generate @var{:exposure} events for regions from the initial @var{unmap-window} operation if they are immediately obscured by the final @var{map-window} operation. It is an error if any of the following are true: @itemize @bullet @item The new @emph{parent} window is not on the same screen as the old parent window. @item The new @emph{parent} window is the specified @emph{window} or an inferior of the specified @emph{window}. @item The specified @emph{window} has a @var{:parent-relative} background attribute and the new @emph{parent} window is not the same depth as the specified @emph{window}. @end itemize @end defun @defun translate-coordinates source source-x source-y destination @table @var @item source A @var{window} defining the source coordinate system. @item source-x @itemx source-y Coordinates (@var{int16}) relative to the origin of the @emph{source} @var{window}. @item destination A @var{window} defining the destination coordinate system. @end table Returns the position defined by @emph{source-x} and @emph{source-y} (relative to the origin of the @emph{source} window), expressed as coordinates relative to the origin of the @emph{destination} window. @table @var @item destination-x Type @var{int16} or @var{null}. @item destination-y Type @var{int16} or @var{null}. @item destination-child Type @var{window} or @var{null}. @end table @end defun @node Mapping Windows, Destroying Windows, Window Hierarchy, Windows and Pixmaps @section Mapping Windows A window is considered mapped if a @var{map-window} call has been made on it. When windows are first created, they are not mapped because an application may wish to create a window long before it is mapped to the screen. A mapped window may not be visible on the screen for one of the following reasons: @itemize @bullet @item It is obscured by another opaque sibling window. @item One of its ancestors is not mapped. @item It is entirely clipped by an ancestor. @end itemize A subwindow will appear on the screen as long as all of its ancestors are mapped and not obscured by a sibling or clipped by an ancestor. Mapping a window that has an unmapped ancestor does not display the window, but marks it as eligible for display when the ancestor becomes mapped. Such a window is called unviewable. When all its ancestors are mapped, the window becomes viewable and remains visible on the screen if not obscured by any sibling or ancestor. Any output to a window not visible on the screen is discarded. @var{:exposure} events are generated for the window when part or all of it becomes visible on the screen. A client only receives the @var{:exposure} events if it has selected them. Mapping or unmapping a window does not change its stacking order priority. @defun map-window window @table @var @item window A @var{window}. @end table @anchor{map-window} Maps the @emph{window}. This function has no effect when the @emph{window} is already mapped. If the override-redirect attribute of the @emph{window} is @var{:off} and another client has selected @var{:substructure-redirect} on the parent window, the X server generates a @var{:map-request} event and the @var{map-window} function does not map the @emph{window}. Otherwise, the @emph{window} is mapped, and the X server generates a @var{:map-notify} event. If the @emph{window} becomes visible and no earlier contents for it are remembered, @var{map-window} tiles the window with its background. If no background was defined for the window, the existing screen contents are not altered, and the X server generates one or more @var{:exposure} events. If a backing-store was maintained while the window was unmapped, no @var{:exposure} events are generated. If a backing-store will now be maintained, a full window exposure is always generated. Otherwise, only visible regions may be reported. Similar tiling and exposure take place for any newly viewable inferiors. @var{map-window} generates @var{:exposure} events on each @var{:input-output} window that it causes to become visible. @end defun @defun map-subwindows window @table @var @item window A @var{window}. @end table Maps all child windows for a specified @emph{window} in top-to-bottom stacking order. The X server generates an @var{:exposure} event on each newly visible window. This function is much more efficient than mapping each child individually. @end defun @defun unmap-window window @table @var @item window A @var{window}. @end table Unmaps the specified @emph{window} and causes the X server to generate an @var{:unmap-notify} event. If the specified @emph{window} is already unmapped, @var{unmap-window} has no effect. Normal exposure processing on formerly obscured windows is performed. Any child window is no longer viewable. Unmapping the @emph{window} generates @var{:exposure} events on windows that were formerly obscured by @emph{window} and its children. @end defun @defun unmap-subwindows window @table @var @item window A @var{window}. @end table Unmaps all child windows for the specified @emph{window} in bottom to top stacking order. The X server generates an @var{:unmap-notify} event on each child and @var{:exposure} events on formerly obscured windows. Using this function is much more efficient than unmapping child windows individually. @end defun @node Destroying Windows, Pixmaps, Mapping Windows, Windows and Pixmaps @section Destroying Windows CLX provides functions to destroy a window or destroy all children of a window. Note that by default, windows are destroyed when a connection is closed. For further information, @xref{Closing the Display}, and @xref{Client Termination}. @defun destroy-window window @table @var @item window A @var{window}. @end table Destroys the specified @emph{window} as well as all of its inferiors. The windows should never again be referenced. If the specified @emph{window} is mapped, it is automatically unmapped. The window and all of its inferiors are then destroyed, and a @var{:destroy-notify} event is generated for each window. The ordering of the @var{:destroy-notify} events is such that for any given window being destroyed, @var{:destroy-notify} is generated on the window's inferiors before being generated on the window. The ordering among siblings and across sub-hierarchies is not otherwise constrained. If the @emph{window} is a root window, no windows are destroyed. Destroying a mapped window generates @var{:exposure} events on other windows that the mapped window obscured. @end defun @defun destroy-subwindows window @table @var @item window A @var{window}. @end table Destroys all inferiors of the specified @emph{window}, in bottom to top stacking order. The X server generates a @var{:destroy-notify} event for each window. This is much more efficient than deleting many windows individually. The inferiors should never be referenced again. @end defun @node Pixmaps, , Destroying Windows, Windows and Pixmaps @section Pixmaps A @emph{pixmap} is a three-dimensional array of bits. A pixmap is normally thought of as a two-dimensional array of pixels, where each pixel can be a value from 0 to 2@emph{n}-1, where @emph{n} is the depth of the pixmap. A pixmap can also be thought of as a stack of @emph{n} bitmaps. A @emph{bitmap} is a single bit pixmap of depth 1. CLX provides functions to: @itemize @bullet @item Create or free a pixmap @item Test if an object is a pixmap @item Test if two pixmap objects are equal @item Return the pixmap resource ID from a @var{pixmap} object @end itemize Note that pixmaps can only be used on the screen where they were created. Pixmaps are off-screen server resources that are used for a number of operations. These include defining patterns for cursors or as the source for certain raster operations. @defun create-pixmap &key :width :height :depth :drawable @table @var @item :width @itemx :height The nonzero width and height (type @var{card16}). @item :depth The depth (type @var{card8}) of the pixmap. @item :drawable A @var{drawable} which determines the screen where the pixmap will be used. @end table Creates a pixmap of the specified @var{:width}, @var{:height}, and @var{:depth}. It is valid to pass a window whose class is @var{:input-only} as the @var{:drawable} argument. The @var{:width} and @var{:height} arguments must be nonzero. The @var{:depth} must be supported by the screen of the specified @var{:drawable}. @table @var @item pixmap Type @var{pixmap}. @end table @end defun @defun free-pixmap pixmap @table @var @item pixmap A @var{pixmap}. @end table Allows the X server to free the pixmap storage when no other server resources reference it. The pixmap should never be referenced again. @end defun @defun pixmap-display pixmap @table @var @item pixmap A @var{pixmap}. @end table Returns the @var{display} object associated with the specified @emph{pixmap}. @table @var @item display Type @var{display}. @end table @end defun @defun pixmap-equal pixmap-1 pixmap-2 @table @var @item pixmap-1 @itemx pixmap-2 A three-dimensional array of bits to be tested. @end table Returns true if the two arguments refer to the same server resource, and @var{nil} if they do not. @end defun @defun pixmap-id pixmap @table @var @item pixmap A @var{pixmap}. @end table Returns the unique resource ID that has been assigned to the specified @emph{pixmap}. @table @var @item id Type @var{resource-id}. @end table @end defun @defun pixmap-p object @table @var @item pixmap Type @var{boolean}. @end table Returns true if the argument is a @var{pixmap} object and @var{nil} otherwise. @end defun @defun pixmap-plist pixmap @table @var @item pixmap A @var{pixmap}. @end table Returns and (with @code{setf}) sets the property list for the specified @emph{pixmap}. This function provides a hook where extensions can add data. @table @var @item plist A property list. @end table @end defun @node Graphics Contexts, Graphic Operations, Windows and Pixmaps, Top @chapter Graphics Contexts Clients of the X Window System specify the visual attributes of graphical output primitives by using @emph{graphics contexts}. A graphics context is a set of graphical attribute values such as foreground color, font, line style, and so forth. Like a window, a graphics context is another kind of X server resource which is created and maintained at the request of a client program. The client program, which may use several different graphics contexts at different times, is responsible for specifying a graphics context to use with each graphical output function. CLX represents a graphics context by an object of type @var{gcontext} and defines functions to create, modify, and manipulate @var{gcontext} objects. By default, CLX also records the contents of graphics contexts in a cache associated with each display. This local caching of graphics contexts has two important advantages: @enumerate @item Communication efficiency -- Changes to attribute values in a @var{gcontext} are first made only in the local cache. Just before a @var{gcontext} is actually used, CLX automatically sends any changes to the X server, batching all changes into a single request. @item Inquiring @var{gcontext} contents -- Accessor functions can be used to return the value of any individual @var{gcontext} component by reading the copy of the @var{gcontext} from the cache. This kind of inquiry is not supported by the basic X protocol. There is no way for a client program to request an X server to return the contents of a @var{gcontext}. @end enumerate Caching graphics contexts can result in a synchronization problem if more than one client program modifies a graphics context. However, this problem is unusual. Sharing a graphics context among several clients, while possible, is not expected to be useful and is not very easy to do. At any rate, a client program can choose to not cache a @var{gcontext} when it is created. Each client program must determine its own policy for creating and using graphics contexts. Depending on the display hardware and the server implementation, creating a new graphics context can be more or less expensive than modifying an existing one. In general, some amount of graphics context information can be cached in the display hardware, in which case modifying the hardware cache is faster than replacing it. Typical display hardware can cache only a small number of graphics contexts. Graphics output is fastest when only a few graphics contexts are used without heavy modifications. This section explains the CLX functions used to: @itemize @bullet @item Create a graphics context @item Return the contents of a graphics context @item Change the contents of a graphics context @item Copy a graphics context @item Free a graphics context @end itemize @menu * Creating Graphics Contexts:: * Graphics Context Attributes:: * Copying Graphics Contexts:: * Destroying Graphics Contexts:: * Graphics Context Cache:: @end menu @node Creating Graphics Contexts, Graphics Context Attributes, Graphics Contexts, Graphics Contexts @section Creating Graphics Contexts To create a graphics context, use @var{create-gcontext}. @defun create-gcontext &key :arc-mode :background (:cache-p t) :cap-style :clip-mask :clip-ordering :clip-x :clip-y :dash-offset :dashes :drawable :exposures :fill-rule :fill-style :font :foreground :function :join-style :line-style :line-width :plane-mask :stipple :subwindow-mode :tile :ts-x :ts-y @table @var @item :cache-p Specifies if this graphics context should be cached locally by CLX. If @var{nil} then the state is not cached, otherwise a local cache is kept. @item :drawable The @var{drawable} whose root and depth are to be associated with this graphics context. This is a required keyword argument. @item :arc-mode @itemx :background @itemx :cap-style @itemx :clip-mask @itemx :clip-ordering @itemx :clip-x @itemx :clip-y @itemx :dash-offset @itemx :dashes @itemx :exposures @itemx :fill-rule @itemx :fill-style @itemx :font @itemx :foreground @itemx :function @itemx :join-style @itemx :line-style @itemx :line-width @itemx :plane-mask @itemx :stipple @itemx :subwindow-mode @itemx :tile @itemx :ts-x @itemx :ts-y Initial attribute values for the graphics context. @end table Creates, initializes, and returns a graphics context (@var{gcontext}). The graphics context can only be used with destination drawables having the same root and depth as the specified @var{:drawable}. If @var{:cache-p} is non-@var{nil}, the graphics context state is cached locally, and changing a component has no effect unless the new value differs from the cached value. Changes to a graphics context (@code{setf} and @var{with-gcontext}) are always deferred regardless of the cache mode and sent to the server only when required by a local operation or by an explicit call to @var{force-gcontext-changes}. All of the graphics context components are set to the values that are specified by the keyword arguments, except that a value of @var{nil} causes the default value to be used. These default values are as follows: @multitable {Component} {Default Value} @item @var{arc-mode} @tab @var{:pie-slice} @item @var{background} @tab 1 @item @var{cap-style} @tab @var{:butt} @item @var{clip-mask} @tab @var{:none} @item @var{clip-ordering} @tab @var{:unsorted} @item @var{clip-x} @tab 0 @item @var{clip-y} @tab 0 @item @var{dash-offset} @tab 0 @item @var{dashes} @tab 4 (that is, the list '(4, 4)) @item @var{exposures} @tab @var{:on} @item @var{fill-rule} @tab @var{:even-odd} @item @var{fill-style} @tab @var{:solid} @item @var{font} @tab server dependent @item @var{foreground} @tab 0 @item @var{function} @tab @var{boole-1} @item @var{join-style} @tab @var{:miter} @item @var{line-style} @tab @var{:solid} @item @var{line-width} @tab 0 @item @var{plane-mask} @tab A bit mask of all ones @item @var{stipple} @tab Pixmap of unspecified size filled with ones @item @var{subwindow-mode} @tab @var{:clip-by-children} @item @var{tile} @tab Pixmap of an unspecified size filled with the foreground pixel (that is, the client-specified pixel if any, or else 0) @item @var{ts-x} @tab 0 @item @var{ts-y} @tab 0 @end multitable Note that foreground and background do not default to any values that are likely to be useful on a color display. Since specifying a @var{nil} value means use the default, this implies for clip-mask that an empty rectangle sequence cannot be specified as an empty list; @var{:none} must be used instead. Specifying a @var{stringable} for font causes an implicit @var{open-font} call to occur. @table @var @item gcontext Type @var{gcontext}. @end table @end defun @node Graphics Context Attributes, Copying Graphics Contexts, Creating Graphics Contexts, Graphics Contexts @section Graphics Context Attributes The following paragraphs describe the CLX functions used to return or change the attributes of a @var{gcontext}. Functions that return the contents of a @var{gcontext} return @var{nil} if the last value stored is unknown (for example, if the @var{gcontext} was not cached or if the @var{gcontext} was not created by the inquiring client). @defun gcontext-arc-mode gcontext @table @var @item gcontext A @var{gcontext}. @end table Returns and (with @code{setf}) changes the arc-mode attribute of the specified graphics context. The arc-mode attribute of a graphics context controls the kind of filling, if any, to be done by the @var{draw-arcs} function. A value of @var{:chord} specifies that arcs are filled inward to the chord between the end points of the arc. @var{:pie-slice} specifies that arcs are filled inward to the center point of the arc, creating a pie slice effect. @table @var @item arc-mode Either @var{:chord} or @var{:pie-slice}. @end table @end defun @defun gcontext-background gcontext @table @var @item gcontext A @var{gcontext}. @end table Returns and (with @code{setf}) changes the background attribute of the specified graphics context. The background attribute specifies the pixel value drawn for pixels that are not set in a bitmap and for pixels that are cleared by a graphics operation, such as the gaps in dashed lines. @table @var @item background Type @var{card32}. @end table @end defun @defun gcontext-cache-p gcontext @table @var @item gcontext A @var{gcontext}. @end table Returns and (with @code{setf}) changes the local cache mode for the @emph{gcontext}. If true, the state of the @emph{gcontext} is cached by CLX and changes to its attributes have no effect unless the new value differs from its cached value. @table @var @item cache-p Type @var{boolean}. @end table @defun gcontext-cap-style gcontext @table @var @item gcontext A @var{gcontext}. @end table Returns and (with @code{setf}) changes the cap-style attribute of the specified graphics context. The cap-style attribute of a graphics context defines how the end points of a path are drawn. The possible values and their interpretations are as follows: @multitable {Cap-Style} {Interpretations} @item @var{:butt} @tab Square at the end point (perpendicular to the slope of the line) with no projection beyond. @item @var{:not-last} @tab Equivalent to @var{:butt}, except that for a line-width of zero or one the final end point is not drawn. @item @var{:projecting} @tab Square at the end, but the path continues beyond the end point for a distance equal to half the line-width. This is equivalent to @var{:butt} for line-width zero or one. @item @var{:round} @tab A circular arc with the radius equal to 1/2 of the line-width, centered on the end point. This is equivalent to @var{:butt} for line-width zero or one. @end multitable The following table describes what happens when the end points of a line are identical. The effect depends on both the cap style and line width. @multitable {Cap-Style} {Line-Width} {Effect} @item @var{:butt} @tab thin @tab Device dependent, but the desired effect is that a single pixel is drawn. @item @var{:butt} @tab wide @tab Nothing is drawn. @item @var{:not-last} @tab thin @tab Device dependent, but the desired effect is that nothing is drawn. @item @var{:projecting} @tab thin @tab Same as @var{:butt} with thin line-width. @item @var{:projecting} @tab wide @tab The closed path is a square, aligned with the coordinate axes, centered at the end point, with sides equal to the line-width. @item @var{:round} @tab wide @tab The closed path is a circle, centered at the end point, with diameter equal to the line-width. @item @var{:round} @tab thin @tab Same as @var{:butt} with thin line-width. @end multitable @table @var @item cap-style One of @var{:butt}, @var{:not-last}, @var{:projecting}, or @var{:round}. @end table @end defun @defun gcontext-clip-mask gcontext &optional ordering @table @var @item gcontext A @var{gcontext}. @item ordering One of @var{:unsorted}, @var{:y-sorted}, @var{:yx-banded}, @var{:yx-sorted}, or @var{nil}. @end table Returns and (with @code{setf}) changes the clip-mask attribute of the graphics context. When changing the clip-mask attribute, the new clip-mask can be specified as a pixmap or a @var{rect-seq} or as the values @var{:none} or @var{nil}. The ordering argument can be specified only with @code{setf} when the new clip-mask is a @var{rect-seq}. The clip-mask attribute of a graphics context affects all graphics operations and is used to restrict output to the destination drawable. The clip-mask does not clip the source of a graphics operation. A value of @var{:none} for clip-mask indicates that no clipping is to be done. If a pixmap is specified as the clip-mask, it must have depth one and the same root as the specified graphics context. Pixels where the clip-mask has a one bit are drawn. Pixels outside the area covered by the clip-mask or where the clip-mask has a zero bit are not drawn. If a sequence of rectangles is specified as the clip-mask, the output is clipped to remain contained within the rectangles. The rectangles should be non-intersecting, or the results of graphics operations will be undefined. The rectangle coordinates are interpreted relative to the clip origin. Note that the sequence of rectangles can be empty, which effectively disables output. This is the opposite of setting the clip-mask to @var{:none}. If known by the client, the ordering of clip-mask rectangles can be specified to provide faster operation by the server. A value of @var{:unsorted} means the rectangles are in arbitrary order. A value of @var{:y-sorted} means that the rectangles are non-decreasing in their Y origin. A @var{:yx-sorted} value is like @var{:y-sorted} with the additional constraint that all rectangles with an equal Y origin are non-decreasing in their X origin. A @var{:yx-banded} value additionally constrains @var{:yx-sorted} by requiring that, for every possible Y scan line, all rectangles that include that scan line have an identical Y origins and Y extents. If incorrect ordering is specified, the X server may generate an error, but it is not required to do so. If no error is generated, the results of the graphics operations are undefined. @end defun @defun gcontext-clip-x gcontext @table @var @item gcontext A @var{gcontext}. @end table Returns and (with @code{setf}) changes the clip-x attribute of the specified graphics context. The clip-x and clip-y attributes specify the origin for the clip-mask, whether it is a pixmap or a sequence of rectangles. These coordinates are interpreted relative to the origin of whatever destination drawable is specified in a graphics operation. @table @var @item clip-x Type @var{int16}. @end table @end defun @defun gcontext-clip-y gcontext @table @var @item gcontext A @var{gcontext}. @end table Returns and (with @code{setf}) changes the clip-y attribute of the specified graphics context. The clip-x and clip-y attributes specify the origin for the clip-mask, whether it is a pixmap or a sequence of rectangles. These coordinates are interpreted relative to the origin of whatever destination drawable is specified in a graphics operation. @table @var @item clip-y Type @var{int16}. @end table @end defun @defun gcontext-dash-offset gcontext @table @var @item gcontext A @var{gcontext}. @end table Returns and (with @code{setf}) changes the dash-offset attribute of the specified graphics context. The dash-offset attribute of a graphics context defines the phase of the pattern contained in the dashes attribute. This phase specifies how many elements (pixels) into the path the pattern should actually begin in any single graphics operation. Dashing is continuous through path elements combined with a join-style, but is reset to the dash-offset each time a cap-style is applied at a line end point. @table @var @item dash-offset Type @var{card16}. @end table @end defun @defun gcontext-dashes gcontext @table @var @item gcontext A @var{gcontext}. @end table Returns and (with @code{setf}) changes the dashes attribute of the specified graphics context. The sequence must be non-empty and the elements must be non-zero @var{card8} values. The dashes attribute in a graphics context specifies the pattern that is used for graphics operations which use the dashed line styles. It is a non-@var{nil} sequence with each element representing the length of a single dash or space. The initial and alternating elements of the dashes are the even dashes, while the others are the odd dashes. An odd length sequence is equivalent to the same sequence concatenated with itself to produce an even length sequence. All of the elements of a dashes sequence must be non-zero. Specifying a single integer value, @emph{N}, for the dashes attribute is an abbreviated way of specifying a two element sequence with both elements equal to the specified value [@emph{N}, @emph{N}]. The unit of measure for dashes is the same as in the ordinary coordinate system. Ideally, a dash length is measured along the slope of the line, but server implementations are only required to match this ideal for horizontal and vertical lines. @table @var @item dashes Type @var{sequence} or @var{card8}. @end table @end defun @defun gcontext-display gcontext @table @var @item gcontext A @var{gcontext}. @end table Returns the @var{display} object associated with the specified @emph{gcontext}. @table @var @item display Type @var{display}. @end table @end defun @defun gcontext-equal gcontext-1 gcontext-2 @table @var @item gcontext-1 @itemx gcontext-2 A @var{gcontext}. @end table Returns true if the two arguments refer to the same server resource, and @var{nil} if they do not. @table @var @item equal-p Type @var{boolean}. @end table @end defun @defun gcontext-exposures gcontext @table @var @item gcontext A @var{gcontext}. @end table Returns and (with @code{setf}) changes the exposures attribute of the specified graphics context. The exposures attribute in a graphics context controls the generation of @var{:graphics-exposure} events for calls to the @var{copy-area} and @var{copy-plane} functions. If @var{:on}, @var{:graphics-exposure} events will be reported when calling the @var{copy-area} and @var{copy-plane} functions with this graphics context. Otherwise, if @var{:off}, the events will not be reported. @table @var @item exposures Either @var{:off} or @var{:on}. @end table @end defun @defun gcontext-fill-rule gcontext @table @var @item gcontext A @var{gcontext}. @end table Returns and (with @code{setf}) changes the fill-rule attribute of the specified graphics context. The fill-rule attribute in a graphics context specifies the rule used to determine the interior of a filled area. It can be specified as either @var{:even-odd} or @var{:winding}. The @var{:even-odd} rule defines a point to be inside if any infinite ray starting at the point crosses the border an odd number of times. Tangencies do not count as a crossing. The @var{:winding} rule defines a point to be inside if any infinite ray starting at the point crosses an unequal number of clockwise and counterclockwise directed border segments. A clockwise directed border segment crosses the ray from left to right as observed from the point. A counterclockwise segment crosses the ray from right to left as observed from the point. The case where a directed line segment is coincident with the ray is uninteresting because you can simply choose a different ray that is not coincident with a segment. For both @var{:even-odd} and @var{:winding}, a point is infinitely small, and the border is an infinitely thin line. A pixel is inside if the center point of the pixel is inside, and the center point is not on the border. If the center point is on the border, the pixel is inside if, and only if, the polygon interior is immediately to its right (x increasing direction). Pixels with centers along a horizontal edge are a special case and are inside if, and only if, the polygon interior is immediately below (y increasing direction). @table @var @item fill-rule Either @var{:even-odd} or @var{:winding}. @end table @end defun @defun gcontext-fill-style gcontext @table @var @item gcontext A @var{gcontext}. @end table Returns and (with @code{setf}) changes the fill-style attribute of the specified graphics context. The fill-style attribute of a graphics context defines the contents of the source for line, text, and fill graphics operations. It determines whether the source image is drawn with a solid color, a tile, or a stippled tile. The possible values and their meanings are as follows: @table @var @item :opaque-stippled Filled with a tile with the same width and height as stipple, but with the background value used everywhere stipple has a zero and the foreground pixel value used everywhere stipple has a one. @item :solid Filled with the foreground pixel value. @item :stippled Filled with the foreground pixel value masked by stipple. @item :tiled Filled with tile. @end table When drawing lines with line-style @var{:double-dash}, the filling of the odd dashes are controlled by the fill-style in the following manner: @table @var @item :opaque-stippled Same as for even dashes. @item :solid Filled with the background pixel value. @item :stippled Filled with the background pixel value masked by stipple. @item :tiled Filled the same as the even dashes. @end table @table @var @item fill-style One of @var{:opaque-stippled}, @var{:solid}, @var{:stippled}, or @var{:tiled}. @end table @end defun @defun gcontext-font gcontext &optional metrics-p @table @var @item gcontext A @var{gcontext}. @item metrics-p Specifies whether a pseudo-font is returned when the real font stored in the graphics context is not known. The default is @var{nil}, which means do not return a pseudo-font. @end table Returns and (with @code{setf}) changes the @emph{font} attribute of the specified graphics context. If the stored font is known, it is returned. If it is not known and the @emph{metrics-p} argument is @var{nil}, then @var{nil} is returned. If the font is not known and @emph{metrics-p} is true, then a pseudo-font is constructed and returned. For a constructed pseudo-font, full metric and property information can be obtained, but it does not have a name or a resource ID, and attempts to use it where a resource ID is required results in an invalid-font error. The font attribute in a graphics context defines the default text font used in text drawing operations. When setting the value of the font attribute, either a @var{font} object or a font name can be used. If a font name is passed, @var{open-font} is call automatically to get the @var{font} object. @table @var @item font Type @var{font} or @var{null}. @end table @end defun @end defun @defun gcontext-foreground gcontext @table @var @item gcontext A @var{gcontext}. @end table Returns and (with @code{setf}) changes the foreground attribute of the specified graphics context. The foreground attribute of a graphics context specifies the pixel value drawn for set bits in a bitmap and for bits set by a graphics operation. @table @var @item foreground Type @var{card32}. @end table @end defun @defun gcontext-function gcontext @table @var @item gcontext A @var{gcontext}. @end table Returns the @emph{function} of the specified graphics context. In all graphic operations, given a source pixel and a corresponding destination pixel, the resulting pixel drawn is computed bitwise on the bits of the source and destination pixels. That is, a logical operation is used to combine each bit plane of corresponding source and destination pixels. The graphics context function attribute specifies the logical operation used via one of the 16 operation codes defined by Common Lisp for the @var{boole} function. The following table shows each of the logical operation codes that can be given by the function attribute. For each operation code, its result is shown as a logical function of a source pixel @emph{S} and a destination pixel @emph{D}. @multitable {Symbol} {Result} @item @var{boole-1} @tab @emph{S} @item @var{boole-2} @tab @emph{D} @item @var{boole-andc1} @tab (logandc1 @emph{S D}) @item @var{boole-andc2} @tab (logandc2 @emph{S D}) @item @var{boole-and} @tab (logand @emph{S D}) @item @var{boole-c1} @tab (lognot @emph{S}) @item @var{boole-c2} @tab (lognot @emph{D}) @item @var{boole-clr} @tab 0 @item @var{boole-eqv} @tab (logeqv @emph{S D}) @item @var{boole-ior} @tab (logior @emph{S D}) @item @var{boole-nand} @tab (lognand @emph{S D}) @item @var{boole-nor} @tab (lognor @emph{S D}) @item @var{boole-orc1} @tab (logorc1 @emph{S D}) @item @var{boole-orc2} @tab (logorc2 @emph{S D}) @item @var{boole-set} @tab 1 @item @var{boole-xor} @tab (logxor @emph{S D}) @end multitable @table @var @item function Type @var{boole-constant}. @end table @end defun @defun gcontext-id gcontext @table @var @item gcontext A @var{gcontext}. @end table Returns the unique ID that has been assigned to the specified graphics context. @table @var @item id Type @var{resource-id}. @end table @end defun @defun gcontext-join-style gcontext @table @var @item gcontext A @var{gcontext}. @end table Returns and (with @code{setf}) changes the join-style attribute of the specified graphics context. The join-style attribute of a graphics context defines how the segment intersections are drawn for wide polylines. The possible values and their interpretations are as follows: @table @var @item :bevel Uses @var{:butt} end point styles with the triangular notch filled. @item :miter The outer edges of two lines extend to meet at an angle. @item :round A circular arc with diameter equal to the line-width, centered on the join point. @end table When the end points of a polyline segment are identical, the effect is as if the segment was removed from the polyline. When a polyline is a single point, the effect is the same as when the cap-style is applied at both end points. @table @var @item join-style One of @var{:bevel}, @var{:miter}, or @var{:round}. @end table @end defun @defun gcontext-line-style gcontext @table @var @item gcontext A @var{gcontext}. @end table Returns and (with @code{setf}) changes the line-style attribute of the specified graphics context. The line-style attribute of a graphics context specifies how (which sections of) lines are drawn for a path in graphics operations. The possible values and their meanings are as follows: @table @var @item :solid The full path is drawn. @item :double-dash The full path is drawn, but the even dashes are filled differently than the odd dashes. The @var{:butt} style is used where even and odd dashes meet (see paragraph 5.4.7, Fill-Rule and Fill-Style). @item :on-off-dash Only the even dashes are drawn, with cap-style applied to all internal ends of the individual dashes, except @var{:not-last} is treated as @var{:butt}. @end table @table @var @item line-style One of @var{:dash}, @var{:double-dash}, or @var{:solid}. @end table @end defun @defun gcontext-line-width gcontext @table @var @item gcontext A @var{gcontext}. @end table Returns the @emph{line-width} of the specified graphics context. The line-width is measured in pixels and can be greater than or equal to one (wide line) or can be the special value zero (thin line). Wide lines are drawn centered on the path described by the graphics operation. Unless otherwise specified by the join-style or cap-style, the bounding box of a wide line with end points [x1, y1], [x2, y2], and width w is a rectangle with vertices at the following real coordinates: [x1 - (w*@emph{sin}/2), y1 + (w*@emph{cos}/2)], [x1+ (w*@emph{sin}/2), y1 - (w*@emph{cos}/2)],@* [x2 - (w*@emph{sin}/2), y2 + (w*@emph{cos}/2)], [x2 + (w*@emph{sin}/2), y2 - (w*@emph{cos}/2)] where @emph{sin} is the sine of the angle of the line and @emph{cos} is the cosine of the angle of the line. A pixel is part of the line and, hence, is drawn if the center of the pixel is fully inside the bounding box (which is viewed as having infinitely thin edges). If the center of the pixel is exactly on the bounding box, it is part of the line if, and only if, the interior is immediately to its right (x increasing direction). Pixels with centers on a horizontal edge are a special case and are part of the line if, and only if, the interior is immediately below (y increasing direction). Thin lines (zero line-width) are always one pixel wide lines drawn using an unspecified, device dependent algorithm. There are only two constraints on this algorithm. @enumerate @item If a line is drawn unclipped from [x1,y1] to [x2,y2] and if another line is drawn unclipped from [x1+dx,y1+dy] to [x2+dx,y2+dy], a point [x,y] is touched by drawing the first line if, and only if, the point [x+dx,y+dy] is touched by drawing the second line. @item The effective set of points comprising a line cannot be affected by clipping. That is, a point is touched in a clipped line if, and only if, the point lies inside the clipping region and the point would be touched by the line when drawn unclipped. @end enumerate A wide line drawn from [x1,y1] to [x2,y2] always draws the same pixels as a wide line drawn from [x2,y2] to [x1,y1], not counting cap-style and join-style. Implementors are encouraged to make this property true for thin lines, but it is not required. A line-width of zero may differ from a line-width of one in which pixels are drawn. This permits the use of many manufacturer's line drawing hardware, which may run much faster than the more precisely specified wide lines. In general, drawing a thin line is faster than drawing a wide line of width one. However, because of their different drawing algorithms, thin lines may not mix well, aesthetically speaking, with wide lines. If it is desirable to obtain precise and uniform results across all displays, a client should always use a line-width of one, rather than a line-width of zero. @table @var @item line-width Type @var{card16}. @end table @end defun @defun gcontext-p gcontext @table @var @item gcontext Type @var{boolean}. @end table Returns non-@var{nil} if the argument is a graphics context and @end defun @defun gcontext-plane-mask gcontext @table @var @item gcontext A @var{gcontext}. @end table Returns the @emph{plane-mask} of the specified graphics context. The plane-mask attribute of a graphics context specifies which bit planes of the destination drawable are modified during a graphic operation. The plane-mask is a pixel value in which a 1 bit means that the corresponding bit plane will be modified and a 0 bit means that the corresponding bit plane will not be affected during a graphic operations. Thus, the actual result of a graphic operation depends on both the function and plane-mask attributes of the graphics context and is given by the following expression: @lisp (logior (logand (boole function source destination) plane-mask) (logandc2 destination plane-mask)) @end lisp @table @var @item plane-mask Type @var{card32}. @end table @end defun @defun gcontext-plist gcontext @table @var @item gcontext A @var{gcontext}. @end table Returns and (with @code{setf}) sets the property list for the specified @emph{gcontext}. This function provides a hook where extensions can add data. @table @var @item gcontext-p Type @var{list}. @end table @end defun @defun gcontext-stipple gcontext @table @var @item gcontext A @var{gcontext}. @end table Returns the @emph{stipple} of the specified graphics context. The stipple attribute of a graphics context is a bitmap used to prevent certain pixels in the destination of graphics operations from being affected by tiling. The stipple and tile have the same origin. This origin point is interpreted relative to the origin of whatever destination drawable is specified in a graphics request. The stipple pixmap must have depth one and must have the same root as the graphics context. The tile pixmap must have the same root and depth as the graphics context. For stipple operations where the fill-style is @var{:stippled} (but not @var{:opaque-stippled}), the stipple pattern is tiled in a single plane and acts as an additional clip mask to be @var{and}ed with the clip-mask. Any size pixmap can be used for stipple or tile, although some sizes may be faster to use than others. Specifying a pixmap for stipple or tile in a graphics context might or might not result in a copy being made. If the pixmap is later used as the destination for a graphics operation, the change might or might not be reflected in the graphics context. If the pixmap is used both as the destination for a graphics operation and as a stipple or tile, the results are not defined. Some displays have hardware support for tiling or stippling with patterns of specific sizes. Tiling and stippling operations that restrict themselves to those sizes may run much faster than such operations with arbitrary size patterns. CLX provides functions to determine the best size for stipple or tile (see @var{query-best-stipple} and @var{query-best-tile}). @table @var @item stipple Type @var{pixmap}. @end table @end defun @defun gcontext-subwindow-mode gcontext @table @var @item gcontext A @var{gcontext}. @end table Returns and (with @code{setf}) changes the subwindow-mode attribute of the specified graphics context. The subwindow-mode attribute of a graphics context specifies whether subwindows obscure the contents of their parent window during a graphics operation. For a value of @var{:clip-by-children}, both source and destination windows are clipped by all viewable @var{:input-output} class children. This clipping is in addition to the clipping provided by the clip-mode attribute. For a value of @var{:include-inferiors}, neither the source nor destination window is clipped by its inferiors. This results in the inclusion of subwindow contents in the source and the drawing through of subwindow boundaries of the destination. The use of @var{:include-inferiors} on a window of one depth with mapped inferiors of differing depth is not illegal, but the semantics are not defined by the core protocol. @table @var @item subwindow-mode One of @var{:clip-by-children} or @var{:include-inferiors}. @end table @end defun @defun gcontext-tile gcontext @table @var @item gcontext A @var{gcontext}. @end table Returns the @emph{tile} of the specified graphics context. The tile attribute is a pixmap used to fill in areas for graphics operations. It is so named because copies of it are laid out side by side to fill the area. The stipple and tile have the same origin. This origin point is interpreted relative to the origin of whatever destination drawable is specified in a graphics request. The stipple pixmap must have depth one and must have the same root as the graphics context. The tile pixmap must have the same root and depth as the graphics context. For stipple operations where the fill-style is @var{:stippled} (but not @var{:opaque-stippled}), the stipple pattern is tiled in a single plane and acts as an additional clip mask to be @var{and}ed with the clip-mask. Any size pixmap can be used for stipple or tile, although some sizes may be faster to use than others. Specifying a pixmap for stipple or tile in a graphics context might or might not result in a copy being made. If the pixmap is later used as the destination for a graphics operation, the change might or might not be reflected in the graphics context. If the pixmap is used both as the destination for a graphics operation and as a stipple or tile, the results are not defined. Some displays have hardware support for tiling or stippling with patterns of specific sizes. Tiling and stippling operations that restrict themselves to those sizes may run much faster than such operations with arbitrary size patterns. CLX provides functions to determine the best size for stipple or tile (see @var{query-best-stipple} and @var{query-best-tile}). @table @var @item tile Type @var{pixmap}. @end table @end defun @defun gcontext-ts-x gcontext @table @var @item gcontext A @var{gcontext}. @end table Returns the @emph{ts-x} attribute of the specified graphics context. The ts-x and ts-y attributes of a graphics context are the coordinates of the origin for tile pixmaps and the stipple. @table @var @item ts-x Type @var{int16}. @end table @end defun @defun gcontext-ts-y gcontext @table @var @item gcontext A @var{gcontext}. @end table Returns the @emph{ts-y} attribute of the specified graphics context. The ts-x and ts-y attributes of a graphics context are the coordinates of the origin for tile pixmaps and the stipple. @table @var @item ts-y Type @var{int16}. @end table @end defun @defun query-best-stipple width height drawable @table @var @item width @itemx height Specifies the width and height of the desired stipple pattern. @item drawable A @var{drawable}. @end table Returns the @emph{best-width} and @emph{best-height} for stipple pixmaps on the @emph{drawable}. The @emph{drawable} indicates the screen and possibly the window class and depth. An @var{:input-only} window cannot be specified as the @emph{drawable}. The size is returned as width and height values. @table @var @item best-width @itemx best-height Type @var{card16}. @end table @end defun @defun query-best-tile width height drawable @table @var @item width @itemx height Specifies the width and height of the desired tile pattern. @item drawable A @var{drawable}. @end table Returns the @emph{best-width} and @emph{best-height} for tile pixmaps on the @emph{drawable}. The @emph{drawable} indicates the screen and possibly the window class and depth. An @var{:input-only} window cannot be specified as the @emph{drawable}. The size is returned as width and height values. @table @var @item best-width @itemx best-height Type @var{card16}. @end table @end defun @node Copying Graphics Contexts, Destroying Graphics Contexts, Graphics Context Attributes, Graphics Contexts @section Copying Graphics Contexts CLX provides functions to copy some or all attribute values from one graphics context to another. These functions are generally more efficient than using @code{setf} to copy @var{gcontext} attributes individually. @defun copy-gcontext source destination @table @var @item source The source @var{gcontext}. @item destination The destination @var{gcontext}. @end table Copies all the values of the attributes of the source graphics context into the destination graphics context. The source and destination graphics contexts must have the same root and depth. @end defun @defun copy-gcontext-components source destination &rest keys @table @var @item source The source @var{gcontext}. @item destination The destination @var{gcontext}. @item keys The remaining arguments are keywords, of type @var{gcontext-key}, which specify which attributes of the graphics context are to be copied. @end table Copies the values of the specified attributes of the source graphics context to the destination graphics context. The source and destination graphics contexts must have the same root and depth. @end defun @node Destroying Graphics Contexts, Graphics Context Cache, Copying Graphics Contexts, Graphics Contexts @section Destroying Graphics Contexts To destroy a graphics context, use @var{free-gcontext.} @defun free-gcontext gcontext @table @var @item gcontext A @var{gcontext}. @end table Deletes the association between the assigned resource ID and the specified graphics context, and then destroys the graphics context. @end defun @node Graphics Context Cache, , Destroying Graphics Contexts, Graphics Contexts @section Graphics Context Cache CLX provides a set of functions to control the automatic graphics context caching mechanism. @defun force-gcontext-changes gcontext @table @var @item gcontext A @var{gcontext}. @end table Forces any delayed changes to the specified graphics context to be sent out to the server. Note that @var{force-gcontext-changes} is called by all of the graphics functions. @end defun @defmac with-gcontext gcontext &key :arc-mode :background :cap-style :clip-mask :clip-ordering :clip-x :clip-y :dashes :dash-offset :exposures :fill-rule :fill-style :font :foreground :function :join-style :line-style :line-width :plane-mask :stipple :subwindow-mode :tile :ts-x :ts-y &allow-other-keys &body body @anchor{with-gcontext} Changes the indicated graphics context components to the specified values only within the dynamic extent of the body. @var{with-gcontext} works on a per-process basis in a multiprocessing environment. The @emph{body} is not surrounded by a @var{with-display} form. If there is no local cache for the specified graphics context, or if some of the component states are unknown, @var{with-gcontext} does the save and restore by creating a temporary graphics context and copying components to and from it using @var{copy-gcontext-components}. @table @var @item gcontext A @var{gcontext}. @item :arc-mode @itemx :background @itemx :cap-style @itemx :clip-mask @itemx :clip-ordering @itemx :clip-x @itemx :clip-y @itemx :dashes @itemx :dash-offset @itemx :exposures @itemx :fill-rule @itemx :fill-style @itemx :font @itemx :foreground @itemx :function @itemx :join-style @itemx :line-style @itemx :line-width @itemx :plane-mask @itemx :stipple @itemx :subwindow-mode @itemx :tile @itemx :ts-x @itemx :ts-y These keyword arguments and associated values specify which graphics context components are to be changed. Any components not specified are left unmodified. @xref{Creating Graphics Contexts}, for more information. @item body The body of code which will have access to the altered graphics context. @end table @end defmac @node Graphic Operations, Images, Graphics Contexts, Top @chapter Graphic Operations Once connected to an X server, a client can use CLX functions to perform graphic operations on drawables. This section describes CLX functions to: @itemize @bullet @item Operate on areas and planes @item Draw points @item Draw lines @item Draw rectangles @item Draw arcs @item Draw text @end itemize @menu * Area and Plane Operations:: * Drawing Points:: * Drawing Lines:: * Drawing Rectangles:: * Drawing Arcs:: * Drawing Text:: @end menu @node Area and Plane Operations, Drawing Points, Graphic Operations, Graphic Operations @section Area and Plane Operations @var{clear-area} clears an area or an entire window to the background. Since pixmaps do not have backgrounds, they cannot be filled by using the functions described in the following paragraphs. Instead, you should use @var{draw-rectangle}, which sets the pixmap to a known value. @xref{Drawing Rectangles}, for information on @var{draw-rectangle}. @defun clear-area window &key (:x 0) (:y 0) :width :height :exposures-p @table @var @item window A @var{window}. @item :x @itemx :y Upper-left corner of the area to be cleared. These coordinates are relative to the @emph{window} origin. Type is @var{int16}. @item :width The width of the area to clear or @var{nil} to clear to the remaining width of the window. Type is @var{card16} or @var{null}. @item :height The height of the area to clear or @var{nil} to clear to the remaining height of the window. Type is @var{card16} or @var{null}. @item :exposures-p Specifies if @var{:exposure} events should be generated for the affected areas. Type @var{boolean}. @end table Draws a rectangular area in the specified @emph{window} with the background pixel or pixmap of the @emph{window}. The @var{:x} and @var{:y} coordinates are relative to the @emph{window} origin, and specify the upper-left corner of the rectangular area that is to be cleared. A @var{nil} or zero value for @var{:height} or @var{:width} clears the remaining area (height - y or width - x). If the @emph{window} has a defined background tile, the rectangle is tiled by using a plane-mask of all ones and a function of @var{:copy}. If the @emph{window} has background @var{:none}, the contents of the @emph{window} are not changed. In either case, if @var{:exposures-p} is non-@var{nil}, then one or more @var{:exposure} events are generated for regions of the rectangle that are either visible or are being retained in a backing store. To clear the entire area in a specified @emph{window}, use (@var{clear-area} @emph{window}). @end defun @defun copy-area source gcontext source-x source-y width height destination destination-x destination-y @table @var @item source Source @var{drawable}. @item gcontext The graphics context to use during the copy operation. @item source-x @itemx source-y The x and y coordinates of the upper-left corner of the area in the @emph{source} @var{drawable}. These coordinates are relative to the @emph{source} @var{drawable} origin. Type is @var{int16}. @item width @itemx height The width and height of the area being copied. These apply to both the @emph{source} and @emph{destination} areas. Type is @var{card16}. @item destination The destination @var{drawable}. @item destination-x @itemx destination-y The x and y coordinates of the upper left corner of the area in the @emph{destination} @var{drawable}. These coordinates are relative to the @emph{destination} @var{drawable} origin. Type is @var{int16}. @end table Copies the specified rectangular area from the @emph{source} @var{drawable} to the specified rectangular area of the @emph{destination} @var{drawable}, combining them as specified in the supplied graphics context (@emph{gcontext}). The @emph{x} and @emph{y} coordinates are relative to their respective drawable origin, with each pair specifying the upper left corner of the area. If either regions of the @emph{source} area are obscured and have not been retained in backing store, or regions outside the boundaries of the @emph{source} @var{drawable} are specified, those regions are not copied. Instead, the following occurs on all corresponding @emph{destination} regions that are either visible or are retained in backing store: @itemize @bullet @item If the @emph{destination} rectangle is a window with a background other than @var{:none}, these corresponding regions of the @emph{destination} are tiled, using plane-mask of all ones and function of @var{boole-1} (copy source), with that background. @item If the exposures attribute of the graphics context is @var{:on}, then @var{:graphics-exposure} events for all corresponding @emph{destination} regions are generated (regardless of tiling or whether the @emph{destination} is a window or a pixmap). @item If exposures is @var{:on} but no regions are exposed, a @var{:no-exposure} event is generated. Note that by default, exposures is @var{:on} for new graphics contexts. @xref{Graphics Contexts}, for further information. @end itemize @end defun @defun copy-plane source gcontext plane source-x source-y width height destination destination-x destination-y @table @var @item source The source @var{drawable}. @item gcontext The graphics context to use during the copy operation. @item plane Specifies the bit-plane of the @emph{source} @var{drawable}. Exactly one bit must be set. Type is @var{pixel}. @item source-x @itemx source-y The @emph{x} and @emph{y} coordinates of the upper-left corner of the area in the @emph{source} @var{drawable}. These coordinates are relative to the @emph{source} @var{drawable} origin. Type is @var{int16}. @item width @itemx height The width and height of the area being copied. These apply to both the @emph{source} and @emph{destination} areas. Type is @var{card16}. @item destination The destination @var{drawable}. @item destination-x @itemx destination-y The x and y coordinates of the upper-left corner of the destination area in the @emph{destination} @var{drawable}. These coordinates are relative to the @emph{destination} @var{drawable} origin. Type is @var{int16}. @end table Uses a single bit plane of the specified rectangular area of the @emph{source} @var{drawable} along with the specified graphics context (@emph{gcontext}) to modify the specified rectangle area of the @emph{destination} @var{drawabl}e. The drawables specified by the @emph{source} and @emph{destination} arguments must have the same root but need not have the same depth. Effectively, this operation forms a pixmap of the same depth as @emph{destination} and with a size specified by the @emph{source} area. It then uses the foreground and background from the graphics context (foreground where the bit-plane in @emph{source} contains a one bit, background where the bit-plane in @emph{source} contains a zero bit), and the equivalent of a @var{copy-area} operation is performed with all the same exposure semantics. This can also be thought of as using the specified region of the @emph{source} bit-plane as a stipple with a fillstyle of @var{:opaque-stippled} for filling a rectangular area of the @emph{destination}. @end defun @node Drawing Points, Drawing Lines, Area and Plane Operations, Graphic Operations @section Drawing Points The @var{draw-point} and @var{draw-points} functions make use of the following graphics context components: function, plane-mask, foreground, subwindow-mode, clip-x, clip-y, clip-ordering, clip-region and clip-mask. The @var{draw-point} function uses the foreground pixel and function components of the graphics context to draw a single point into the specified drawable, while @var{draw-points} draws multiple points into the specified drawable. These functions are not affected by the tile or stipple in the graphics context. @defun draw-point drawable gcontext x y @table @var @item drawable The destination @var{drawable}. @item gcontext The graphics context for drawing the point. @item x @itemx y The @emph{x} and @emph{y} coordinates of the point drawn. Type is @var{int16}. @end table Combines the foreground pixel in the @emph{gcontext} with the pixel in the @emph{drawable} specified by the @emph{x} and @emph{y} coordinates. @end defun @defun draw-points drawable gcontext points &optional relative-p @table @var @item drawable The destination @var{drawable}. @item gcontext The graphics context for drawing the points. @item points A list of points to be drawn in the order listed. The first point is always relative to the @emph{drawable}'s origin; if @emph{relative-p}, the rest of the points are drawn relative to the previous point, else they are drawn relative to the @emph{drawable}'s origin. Type is @var{point-seq}. @item relative-p Specifies the coordinate mode used for drawing the pixels either relative to the origin or to the previous point. Type @var{boolean}. @end table Combines the foreground pixels in the graphics context with the pixels at each point in the @emph{drawable}. The points are drawn in the order listed. @var{draw-points} requires a mode argument, @emph{relative-p} that indicates whether the points are relative to the destination origin or to the previous point. In either case, the first point is always relative to the destination origin. The rest of the points are relative either to the @emph{drawable}'s origin or to the previous point, depending on the value of @emph{relative-p}. @end defun @node Drawing Lines, Drawing Rectangles, Drawing Points, Graphic Operations @section Drawing Lines The @var{draw-line}, @var{draw-lines}, and @var{draw-segments} functions use the following graphics context components: background, cap-style, clip-x-origin, clip-y-origin, clip-mask, dash-list, dash-offset, fill-style, foreground, function, plane-mask, line-width, line-style, stipple, subwindow-mode, tile, ts-x-origin, and ts-y-origin. The @var{draw-lines} function also uses the join-style graphics context component. @defun draw-line drawable gcontext x1 y1 x2 y2 &optional relative-p @table @var @item drawable The destination @var{drawable}. @item gcontext The graphics context for drawing the line. @item x1 @itemx y1 @itemx x2 @itemx y2 The end points of the line. @item relative-p Specifies the coordinate mode used for drawing the line either relative to the origin or the previous point. In either case, the first point is always drawn relative to the @emph{drawable}'s origin. @end table Draws a line from the point @emph{x1},@emph{y1} to the point @emph{x2},@emph{y2}. When @emph{relative-p} is true, the first point is relative to the destination origin but the second point is relative to the first point. When @emph{relative-p} is @var{nil}, both points are relative to the destination origin. @end defun @defun draw-lines drawable gcontext points &key :relative-p :fill-p (:shape :complex) @table @var @item drawable The destination @var{drawable}. @item gcontext The graphics context for drawing the lines. @item points A list of points that define the lines. Type is @var{point-seq}. @item :relative-p The coordinate mode of the points. @item :fill-p When true, a filled polygon is drawn instead of a polyline. @item :shape A hint that allows the server to use the most efficient area fill algorithm. Either @var{:convex}, @var{:non-convex}, or @var{:complex}. @end table Draws a line between each pair of @emph{points} in the points list. The lines are drawn in the order listed and join correctly at all intermediate points. The join-style graphics context component defines the type of joint to use. When the first and last points coincide, the first and last lines also join correctly to produce a hollow polygon. When @var{:relative-p} is true, the first point is always relative to the destination origin, but the rest are relative to the previous point. When @var{:relative-p} is @var{nil}, the rest of the points are drawn relative to the destination origin. When @var{:fill-p} is true, the polygon defined by the @emph{points} list is filled. The @var{:shape} keyword provides the server with a hint about how to fill the polygon. @var{:shape} can be either @var{:complex} (by default), @var{:convex}, or @var{:non-convex}. The @var{:convex} operand is the simplest type of area and the fastest to fill. A fill area is convex if every straight line connecting any two interior points is entirely inside the area. For example, triangles and rectangles are convex polygons. The @var{:non-convex} operand is for filling an area that is not convex and is also not self-intersecting. Filling this type of area is harder than filling a convex area, but easier than filling one that is self-intersecting. For example, the shape of the letter "T" is non-convex and non-self-intersecting. The @var{:complex} operand is the most general (and therefore the hardest) type of fill area. A complex fill area can be non-convex and self-intersecting. For example, draw the outline of a bow tie, without lifting your pencil or tracing over an edge twice. This shape is non-convex and intersects itself at the knot in the middle. @var{NOTE:} Unless you are sure that a shape is @var{:convex} or @var{:non-convex}, it should always be drawn as a @var{:complex} shape. If @var{:convex} or @var{:non-convex} is specified incorrectly, the graphics result is undefined. @end defun @defun draw-segments drawable gcontext segments @table @var @item drawable The destination @var{drawable} to receive the line segments. @item gcontext Specifies the graphics context for drawing the lines. @item segments The points list for the segments to draw. Type is @var{seq}. @end table Draws multiple lines, not necessarily connected. @emph{segments} is a sequence of the form @{x1 y1 x2 y2@}*, in which each subsequence specifies the end points of a line segment. Line segments are drawn in the order given by @emph{segments}. Unlike @var{draw-lines}, no joining is performed at coincident end points. @end defun @node Drawing Rectangles, Drawing Arcs, Drawing Lines, Graphic Operations @section Drawing Rectangles The @var{draw-rectangle} and @var{draw-rectangles} functions draw hollow or filled outlines of the specified rectangle or rectangles as if a five-point polyline were specified for each rectangle, as follows: @display [x,y,] [x+width,y] [x+width,y+height] [x,y+height] [x,y] @end display @var{draw-rectangle} and @var{draw-rectangles} use the following graphics context components: background, function, plane-mask, foreground, subwindow-mode, cap-style, clip-x, clip-y, clip-ordering, clip-region and clip-mask, dash-list, dash-offset, fill-style, join-style, line-width, line-style, stipple, tile, ts-x-origin, and ts-y-origin. @defun draw-rectangle drawable gcontext x y width height &optional fill-p @table @var @item drawable The destination @var{drawable}. @item gcontext The graphics context for drawing the rectangle. @item x @itemx y The x and y coordinates that define the upper left corner of the rectangle. The coordinates are relative to the destination origin. Type is @var{int16}. @item width @itemx height Specifies the width and height that define the outline of the rectangle. Type is @var{card16}. @item fill-p Specifies whether the rectangle is filled or not. Type @var{boolean}. @end table Draws a rectangle defined by the @emph{x}, @emph{y}, @emph{width}, and @emph{height} arguments. @end defun @defun draw-rectangles drawable gcontext rectangles &optional fill-p @table @var @item drawable The destination @var{drawable}. @item gcontext The graphics context. @item rectangles A list specifying the upper left corner x and y, width and height of the rectangles. Type is @var{rect-seq}. @item fill-p Specified if the rectangles are filled or not. Type is @var{boolean}. @end table Draws the rectangles in the order listed in @emph{rectangles}. For the specified @emph{rectangle} or @emph{rectangles}, no pixel is drawn more than once. The x and y coordinates of each rectangle are relative to the destination origin and define the upper left corner of the rectangle. If rectangles intersect, the intersecting pixels are drawn multiple times. @end defun @node Drawing Arcs, Drawing Text, Drawing Rectangles, Graphic Operations @section Drawing Arcs @var{draw-arc} draws a single circular or an elliptical arc, while @var{draw-arcs} draws multiple circular or elliptical arcs. @var{draw-arc} and @var{draw-arcs} use the following graphics context components: arc-mode, background, cap-style, clip-x, clip-y, clip-mask, dash-list, dash-offset, fill-style, foreground, join-style, function, plane-mask, line-width, line-style, stipple, subwindow-mode, tile, ts-x-origin, and ts-y-origin. @defun draw-arc drawable gcontext x y width height angle1 angle2 &optional fill-p @table @var @item drawable The destination @var{drawable}. @item gcontext The graphics context for drawing the arc. @item x @itemx y The x and y coordinates of the arc rectangle relative to the origin of the @emph{drawable}. Type is @var{int16}. @item width @itemx height Specifies the width and height of the rectangle. These are the major and minor axes of the arc. Type is @var{card16}. @item angle1 Specifies the start of the arc in radians. Type is @var{angle}. @item angle2 Specifies the direction and end point of the arc. Type is @var{angle}. @item fill-p Specifies whether the arc is filled or not. Type @var{boolean}. @end table Draws either a circular or an elliptical arc. Also, outlined or filled arcs can be drawn. Each arc is specified by a rectangle (@emph{x}, @emph{y}, @emph{width}, and @emph{height}) and two angles (@emph{angle1} and @emph{angle2}). The angles are signed integers in radians, with positive indicating counterclockwise motion and negative indicating clockwise motion. The start of the arc is specified by @emph{angle1}, and the path and extent of the arc is specified by @emph{angle2} relative to the start of the arc. If the magnitude of @emph{angle2} is greater than 360 degrees, it is truncated to 360 degrees. The @emph{x} and @emph{y} coordinates of the rectangle are relative to the @emph{drawable}'s origin. For example, an arc specified as [@emph{x},@emph{y},@emph{width},@emph{height},@emph{angle1},@emph{angle2}] has the origin of the major and minor axes at: @display [@emph{x}+(@emph{width}/2),@emph{y}+(@emph{height}/2)] @end display The infinitely thin path describing the entire circle/ellipse intersects the horizontal axis at: @display [@emph{x},@emph{y}+(@emph{height}/2)] and [@emph{x}+@emph{width},@emph{y}+(@emph{height}/2)] @end display The intersection of the vertical axis is at: @display [@emph{x}+(@emph{width}/2),@emph{y}] and [@emph{x}+(@emph{width}/2),@emph{y}+@emph{height}] @end display These coordinates can be fractional; that is, they are not truncated to discrete coordinates. Note that the angle values are slightly different in CLX than in the X protocol specification. If @emph{fill-p} is @var{nil}, then only the outline of the arc is drawn. Otherwise, if @emph{fill-p} is true, @var{draw-arc} fills the area bounded by the arc outline and one or two line segments, depending on the arc-mode. If the arc-mode is @var{:chord}, the filled area is bounded by the arc outline and the line segment joining the arc end points. If the arc-mode is @var{:pie-slice}, the filled area is bounded by the arc outline and the two line segments joining each arc end point with the center point. @end defun @defun draw-arcs drawable gcontext arcs &optional fill-p @table @var @item drawable Specifies the @var{drawable} where you want the arcs drawn. @item gcontext Specifies the graphics context for drawing the arc. @item arcs A sequence containing the width, height, angle1, and angle2 arguments defining the arcs. See @var{draw-arc} for more detail. Type is @var{arc-seq}. @item fill-p Specifies whether the arcs are filled or not. Type is @var{boolean}. @end table Draws circular or elliptical, outlined or filled arcs. Each arc is specified by a rectangle and two angles. For a more detailed description, see @var{draw-arc}. The arcs are filled in the order listed. For any given arc, no pixel is drawn more than once. If regions intersect, the intersecting pixels are drawn multiple times. @end defun @node Drawing Text, , Drawing Arcs, Graphic Operations @section Drawing Text CLX provides functions for drawing text using text fonts provided by the X server. An X font is array of character bit maps indexed by integer codes. @xref{Font and Characters}, for a complete discussion of the CLX functions used to manage fonts and characters. Since Common Lisp programs typically represent text as sequences of characters (that is, strings), CLX text functions must be prepared to convert a Common Lisp character into the integer code used to index the appropriate character bitmap in a given font. The @var{:translate} argument to a text function is a function which performs this conversion. The default @var{:translate} function handles all characters that satisfy @var{graphic-char-p} by converting each character into its ASCII code. Note that the assumption made by the default @var{:translate} function--that is, that an X font indexes bitmaps by ASCII codes--is often valid, but other encodings are possible. In general, a @var{:translate} function can perform complex transformations. It can be used to convert non-character input, to handle non-ASCII character encodings, and to change the fonts used to access character bitmaps. The complete behavior of a @var{:translate} function is given below by describing a prototypical @var{translate-function}. CLX offers two different ways to draw text--filled text and block text. The @var{draw-glyph} and @var{draw-glyphs} functions create filled text, in which each character image is treated as an area to be filled according to the fill-style of the given graphics context, without otherwise disturbing the surrounding background. In addition, filled text sends a complex type of server request which allows a series of font indices, font changes, and horizontal position changes to be compiled into a single request. Filled text functions use the following graphics context attributes: background, clip-mask, clip-x-origin, clip-y-origin, fill-style, font, foreground, function, plane-mask, stipple, subwindow-mode, tile, ts-x-origin, ts-y-origin. Block text is a rendering style commonly used by display terminals, in which each character image appears in the foreground pixel inside a rectangular character cell drawn in the graphics context background pixel. The @var{draw-image-glyph} and @var{draw-image-glyphs} functions create block text. Block text functions use the following graphics context attributes: background, clip-mask, clip-x-origin, clip-y-origin, font, foreground, plane-mask, stipple, subwindow-mode, tile, ts-x-origin, ts-y-origin. @defun draw-glyph drawable gcontext x y element &key :translate :width (:size :default) @table @var @item drawable The destination @var{drawable}. @item gcontext The graphics context for drawing text. @item x @itemx y The left baseline position for the character drawn. @item element A character or other object to be translated into a font index. @item :translate A function to translate text to font indexes. Default is @var{#'translate-default}. @item :width The total pixel width of the character actually drawn, if known. @item :size Specifies the element size of the destination buffer given to @var{:translate} (8, 16, or @var{:default}). @end table Draws a single character of filled text represented by the given @emph{element}. The given @emph{x} and @emph{y} specify the left baseline position for the character. The first return value is true if the character is successfully translated and drawn, or @var{nil} if the @var{:translate} function did not translate it. The second return value gives the total pixel width of the character actually drawn, if known. Specifying a @var{:width} is a hint to improve performance. The @var{:width} is assumed to be the total pixel width of the character actually drawn. Specifying @var{:width} permits appending the output of subsequent calls to the same protocol request, provided @emph{gcontext} has not been modified in the interim. If @var{:width} is not specified, appending of subsequent output might not occur (unless @var{:translate} returns the character width). The @var{:size} specifies the element size of the destination buffer given to @var{:translate} (either 8, 16, or @var{:default}). If @var{:default} is specified, the size is based on the current font, if known; otherwise, 16 is used. @table @var @item output-p Type @var{boolean}. @item width Type @var{int32} or @var{null}. @end table @end defun @defun draw-glyphs drawable gcontext x y sequence &key (:start 0) :end :translate :width (:size :default) @table @var @item drawable The destination @var{drawable}. @item gcontext The graphics context for drawing text. @item x @itemx y The left baseline position for the character drawn. @item sequence A sequence of characters or other objects to be translated into font indexes. @item :start @itemx :end Start and end indexes defining the elements to draw. @item :translate A function to translate text to font indexes. Default is @var{#'translate-default}. @item :width The total total pixel width of the character actually drawn, if known. @item :size The element size of the destination buffer given to @var{:translate} (8, 16, or @var{:default}). @end table Draws the filled text characters represented by the given sequence. @var{:start} and @var{:end} define the elements of the sequence which are drawn. The given @emph{x} and @emph{y} specify the left baseline position for the first character. The first return value is @var{nil} if all characters are successfully translated and drawn; otherwise, the index of the first untranslated sequence element is returned. The second return value gives the total pixel width of the characters actually drawn, if known. Specifying a @var{:width} is a hint to improve performance. The @var{:width} is assumed to be the total pixel width of the character sequence actually drawn. Specifying @var{:width} permits appending the output of subsequent calls to the same protocol request, provided @emph{gcontext} has not been modified in the interim. If @var{:width} is not specified, appending of subsequent output might not occur (unless @var{:translate} returns the character width). The @var{:size} specifies the element size of the destination buffer given to@var{ :translate} (either 8, 16, or @var{:default}). If @var{:default} is specified, the size is based on the current font, if known; otherwise, 16 is used. @table @var @item new-start Type @var{array-index} or @var{null}. @item width Type @var{int32} or @var{null}. @end table @end defun @defun draw-image-glyph drawable gcontext x y element &key :translate :width (:size :default) @table @var @item drawable The destination @var{drawable}. @item gcontext The graphics context for drawing text. @item x @itemx y The left baseline position for the character drawn. @item element A character or other object to be translated into a font index. @item :translate A function to translate text to font indexes. Default is @var{#'translate-default}. @item :width The total pixel width of the character actually drawn, if known. @item :size Specifies the element size of the destination buffer given to @var{:translate} (8, 16, or @var{:default}). @end table Draws a single character of block text represented by the given @emph{element}. The given @emph{x} and @emph{y} specify the left baseline position for the character. The first return value is true if the character is successfully translated and drawn, or @var{nil} if the @var{:translate} function did not translate it. The @var{:translate} function is allowed to return an initial font change. The second return value gives the total pixel width of the character actually drawn, if known. The @var{:translate} function may not return a horizontal position change, since @var{draw-image-glyph} does not generate complex output requests. Specifying a @var{:width} is a hint to improve performance. The @var{:width} is assumed to be the total pixel width of the character actually drawn. Specifying @var{:width} permits appending the output of subsequent calls to the same protocol request, provided @emph{gcontext} has not been modified in the interim. If @var{:width} is not specified, appending of subsequent output might not occur (unless @var{:translate} returns the character width). The @var{:size} specifies the element size of the destination buffer given to @var{:translate} (either 8, 16, or @var{:default}). If @var{:default} is specified, the size is based on the current font, if known; otherwise, 16 is used. @table @var @item output-p Type @var{boolean}. @item width Type @var{int32} or @var{null}. @end table @end defun @defun draw-image-glyphs drawable gcontext x y sequence &key (:start 0) :end :translate :width (:size :default) @anchor{draw-image-glyphs} @table @var @item drawable The destination @var{drawable}. @item x @itemx y The left baseline position for the character drawn. @item gcontext The graphics context for drawing text. @item sequence A sequence of characters or other objects to be translated into font indexes. @item :start @itemx :end Start and end indexes defining the elements to draw. @item :translate A function to translate text to font indexes. Default is @var{#'translate-default}. @item :width The total total pixel width of the character actually drawn, if known. @item :size The element size of the destination buffer given to @var{:translate} (8, 16, or @var{:default}). @end table Draws the block text characters represented by the given @var{sequence}. @var{:start} and @var{:end} define the elements of the @emph{sequence} which are drawn. The given @emph{x} and @emph{y} specify the left baseline position for the first character. The first return value is @var{nil} if all characters are successfully translated and drawn; otherwise, the index of the first untranslated sequence element is returned. The @var{:translate} function is allowed to return an initial font change. The second return value gives the total pixel width of the characters actually drawn, if known. The @var{:translate} function may not return a horizontal position change, since @var{draw-image-glyphs} does not generate complex output requests. Specifying a @var{:width} is a hint to improve performance. The @var{:width} is assumed to be the total pixel width of the character sequence actually drawn. Specifying @var{:width} permits appending the output of subsequent calls to the same protocol request, provided @emph{gcontext} has not been modified in the interim. If @var{:width} is not specified, appending of subsequent output might not occur (unless @var{:translate} returns the character width). The @var{:size} specifies the element size of the destination buffer given to @var{:translate} (either 8, 16, or @var{:default}). If @var{:default} is specified, the size will be based on the current font, if known; otherwise, 16 is used. @table @var @item new-start Type @var{array-index} or @var{null}. @item width Type @var{int32} or @var{null}. @end table @end defun @defun translate-function source source-start source-end font destination destination-start @table @var @item source A sequence of characters or other objects to be translated. @item source-start An array-index specifying the first @emph{source} element to be translated. @item source-end An array-index specifying the end of the @emph{source} subsequence to be translated. @item font The font indexed by translated @emph{source} elements. @item destination A vector where translated @emph{source} elements are stored. @item destination-start An array-index specifying the position to begin storing translated @emph{source} elements. @end table A function used as the @var{:translate} argument for text functions. Converts elements of the @emph{source} (sub)sequence into font indexes for the given @emph{font} and stores them into the @emph{destination} vector. The @emph{destination} vector is created automatically by CLX. @emph{destination} is guaranteed to have room for (- @emph{source-end source-star}t) integer elements, starting at @emph{destination-start}. Elements of @emph{destination} can be either @var{card8} or @var{card16} integers, depending on the context. @emph{font} is the current font, if known, or @var{nil} otherwise. Starting with the element at @emph{source-start}, @var{translate-function} should translate as many elements of @emph{source} as possible (up to the @emph{source-end} element) into indexes in the current @emph{font}, and store them into @emph{destination}. The first return value should be the source index of the first untranslated element. The second return value indicates the changes which should be made to the current text output request before translating the remaining @emph{source} elements. If no further elements need to be translated, the second return value should be @var{nil}. If a horizontal motion is required before further translation, the second return value should be the change in x position. If a font change is required for further translation, the second return value should be the new font. If known, the pixel width of the translated text can be returned as the third value; this can allow for appending of subsequent output to the same protocol request, if no overall width has been specified at the higher level. @table @var @item first-not-done Type @var{array-index}. @item to-continue Type @var{int16}, @var{font}, or @var{null}. @item current-width Type @var{int32} or @var{null}. @end table @end defun @node Images, Font and Characters, Graphic Operations, Top @chapter Images The X protocol provides for the transfer of images (two-dimensional arrays of pixel data) between a client program and a @var{drawable}. The format for image data can vary considerably. In order to present a uniform data representation for the manipulation of a variety of images, CLX defines a special @var{image} data type. Additional @var{image} subtypes -- @var{image-xy} and @var{image-z} -- allow for the representation of an image either as a sequence of bit planes or as an array of pixels. CLX includes functions for accessing @var{image} objects; for transferring image data between @var{image} objects, @var{drawables}, and files; and also for direct transfer of raw image data. @menu * Image Types:: * Image Functions:: * Image Files:: * Direct Image Transfer:: @end menu @node Image Types, Image Functions, Images, Images @section Image Types The @var{image} data type is the base type for all @var{image} objects. @var{image-xy} and @var{image-z} are subtypes of the @var{image} type which furnish accessors specialized for different image representations. @menu * Basic Images:: * XY-Format Images:: * Z-Format Images:: @end menu @node Basic Images, XY-Format Images, Image Types, Image Types @subsection Basic Images The following paragraphs describe the CLX functions that can be used to access all types of @var{image} objects. @defun image-blue-mask image @table @var @item image An @var{image} object. @end table Returns (and with @code{setf}) changes the @emph{mask} that selects the pixel subfield for blue intensity values. The @emph{mask} is non-@var{nil} only for images for @var{:direct-color} or @var{:true-color} visual types. @table @var @item mask Type @var{pixel} or @var{null}. @end table @end defun @defun image-depth image @table @var @item image An @var{image} object. @end table Returns the @emph{depth} (that is, the number of bits per pixel) for the @emph{image}. @table @var @item depth Type @var{card8}. @end table @end defun @defun image-green-mask image @table @var @item image An @var{image} object. @end table Returns (and with @code{setf}) changes the mask that selects the pixel subfield for green intensity values. The mask is non-@var{nil} only for images for @var{:direct-color} or @var{:true-color} visual types. @table @var @item mask Type @var{pixel} or @var{null}. @end table @end defun @defun image-height image @table @var @item image An @var{image} object. @end table Returns the @emph{height} of the @emph{image} in pixels. @table @var @item height Type @var{card16}. @end table @end defun @defun image-name image @table @var @item image An @var{image} object. @end table Returns and (with @code{setf}) changes the @emph{name} string optionally associated with the @emph{image}. @table @var @item name Type @var{stringable} or @var{null}. @end table @end defun @defun image-plist image @table @var @item image An @var{image} object. @end table Returns and (with @code{setf}) changes the @emph{image} property list. The property list is a hook for added application extensions. @table @var @item plist Type @var{list}. @end table @end defun @defun image-red-mask image @table @var @item image An @var{image} object. @end table Returns (and with @code{setf}) changes the @emph{mask} which selects the pixel subfield for red intensity values. The @emph{mask} is non-@var{nil} only for images for @var{:direct-color} or @var{:true-color} visual types. @table @var @item mask Type @var{pixel} or @var{null}. @end table @end defun @defun image-width image @table @var @item image An @var{image} object. @end table Returns the @emph{width} of the @emph{image} in pixels. @table @var @item width Type @var{card16}. @end table @end defun @defun image-x-hot image @table @var @item image An @var{image} object. @end table Returns and (with @code{setf}) changes the x position of the hot spot for an image used as a cursor glyph. The hot spot position is specified relative to the upper-left origin of the @emph{image}. @table @var @item x-position Type @var{card16} or @var{null}. @end table @end defun @defun image-y-hot image @table @var @item image An @var{image} object. @end table Returns and (with @code{setf}) changes the y position of the hot spot for an image used as a cursor glyph. The hot spot position is specified relative to the upper-left origin of the @emph{image}. @table @var @item y-position Type @var{card16} or @var{null}. @end table @end defun @node XY-Format Images, Z-Format Images, Basic Images, Image Types @subsection XY-Format Images The @var{image-xy} subtype represents an image as a sequence of bitmaps, one for each plane of the image, in most-significant to least-significant bit order. The following paragraphs describe the additional CLX functions that can be used to access @var{image-xy} objects. @defun image-xy-bitmap-list image @table @var @item image An @var{image-xy} object. @end table Returns and (with @code{setf}) changes the list of bitmap planes for the @emph{image}. @table @var @item bitmaps Type @var{list} of @var{bitmap}. @end table @end defun @node Z-Format Images, , XY-Format Images, Image Types @subsection Z-Format Images The @var{image-z} subtype represents an image as a two-dimensional array of pixels, in scanline order. The following paragraphs describe the additional CLX functions that can be used to access @var{image-z} objects. @defun image-z-bits-per-pixel image @table @var @item image An @var{image-z} object. @end table Returns and (with @code{setf}) changes the number of bits per data unit used to contain a pixel value for the @emph{image}. Depending on the storage format for image data, this value can be larger than the actual @emph{image} depth. @table @var @item pixel-data-size One of 1, 4, 8, 16, 24, or 32. @end table @end defun @defun image-z-pixarray image @table @var @item image An @var{image-z} object. @end table Returns and (with @code{setf}) changes the two-dimensional array of pixel data for the @emph{image}. @table @var @item pixarray Type @var{pixarray}. @end table @end defun @node Image Functions, Image Files, Image Types, Images @section Image Functions The following paragraphs describe the CLX functions used to: @itemize @bullet @item Create an @var{image} object. @item Copy an image or a subimage. @item Read an image from a @var{drawable}. @item Display an image to a @var{drawable}. @end itemize @defun create-image &key :bit-lsb-first-p :bits-per-pixel :blue-mask :byte-lsb-first-p :bytes-per-line :data :depth :format :green-mask :height :name :plist :red-mask :width :x-hot :y-hot Function @table @var @item :bit-lsb-first-p For a returned image, true if the order of bits in each @var{:data} byte is least-significant bit first. @item :bits-per-pixel One of 1, 4, 8, 16, 24, or 32. @item :blue-mask For @var{:true-color} or @var{:direct-color} images, a pixel mask. @item :byte-lsb-first-p For a returned @emph{image}, true if the @var{:data} byte order is least-significant byte first. @item :bytes-per-line For a returned @emph{image}, the number of @var{:data} bytes per scanline. @item :data Either a @var{list} of @var{bitmaps}, a @var{pixarray}, or an array of @var{card8} bytes. @item :depth The number of bits per displayed pixel. @item :format One of @var{:bitmap}, @var{:xy-format}, or @var{:z-format}. @item :green-mask For @var{:true-color} or @var{:direct-color} images, a pixel mask. @item :height A @var{card16} for the image height in pixels. @item :name An optional @var{stringable} for the image name. @item :plist An optional image property list. @item :red-mask For @var{:true-color} or @var{:direct-color} images, a pixel mask. @item :width A @var{card16} for the image width in pixels. @item :x-hot For a @var{cursor} image, the x position of the hot spot. @item :y-hot For a cursor image, the y position of the hot spot. @end table Creates an @var{image} object from the given @var{:data} and returns either an @var{image}, @var{image-xy}, or an @var{image-z}, depending on the type of image @var{:data}. If the @var{:data} is a list, it is assumed to be a @var{list} of @var{bitmaps} and an @var{image-xy} is created. If the @var{:data} is a @var{pixarray}, an @var{image-z} is created. Otherwise, the @var{:data} must be an array of bytes (@var{card8}), in which case a basic @var{image} object is created. If the @var{:data} is a list, each element must be a bitmap of equal size. @var{:width} and @var{:height} default to the bitmap width -- (@var{array-dimension bitmap} 1) -- and the bitmap height -- (@var{array-dimension bitmap} 0) -- respectively. @var{:depth} defaults to the number of bitmaps. If the @var{:data} is a @var{pixarray}, @var{:width} and @var{:height} default to the @var{pixarray} width -- (@var{array-dimension pixarray} 1), and the pixarray height -- (@var{array-dimension pixarray} 0), respectively. @var{:depth} defaults to (@var{pixarray-depth} @var{:data}). The @var{:bits-per-pixel} is rounded to a valid size, if necessary. By default, the @var{:bits-per-pixel} is equal to the @var{:depth}. If the @var{:data} is an array of @var{card8}, the @var{:width} and @var{:height} are required to interpret the image data correctly. The @var{:bits-per-pixel} defaults to the @var{:depth}, and the @var{:depth} defaults to 1. @var{:bytes-per-line} defaults to: @lisp (@var{floor} (@var{length :data}) (* @var{:bits-per-pixel :height})) @end lisp The @var{:format} defines the storage format of image data bytes and can be one of the following values: @table @var @item :xy-pixmap The @var{:data} is organized as a set of bitmaps representing image bit planes, appearing in most-significant to least-significant bit order. @item :z-pixmap The @var{:data} is organized as a set of pixel values in scanline order. @item :bitmap Similar to @var{:xy-pixmap}, except that the @var{:depth} must be 1, and 1 and 0 bits represent the foreground and background pixels, respectively. @end table By default, the @var{:format} is @var{:bitmap} if @var{:depth} is 1; otherwise, @var{:z-pixmap}. @table @var Type @var{image}. @end table @end defun @defun copy-image image &key (:x 0) (:y 0) :width :height :result-type @table @var @item image An @var{image} object. @item :x @itemx :y @var{card16} values defining the position of the upper-left corner of the subimage copied. @item :width @itemx :height @var{card16} values defining the size of subimage copied. @item :result-type One of @var{'image-x}, @var{'image-xy}, or @var{'image-z}. @end table Returns a new image, of the given @var{:result-type}, containing a copy of the portion of the @emph{image} defined by @var{:x}, @var{:y}, @var{:width}, and @var{:height}. By default, @var{:width} is: @lisp (- (@var{image-width} @emph{image}) @var{:x}) @end lisp and @var{:height} is: @lisp (- (@var{image-height} @emph{image}) @var{:y}) @end lisp If necessary, the new image is converted to the @var{:result-type}, that can be one of the following values: @table @code @item 'image-x A basic @var{image} object is returned. @item 'image-xy An @var{image-xy} is returned. @item 'image-z An @var{image-z} is returned. @end table @table @var @item new-image Type @var{image}. @end table @end defun @defun get-image drawable &key :x :y :width :height :plane-mask (:format :z-format) :result-type Function @table @var @item drawable A @var{drawable}. @item :x @itemx :y @var{card16} values defining the upper-left @var{drawable} pixel returned. These arguments are required. @item :width @itemx :height @var{card16} values defining the size of the @emph{image} returned. These arguments are required. @item :plane-mask A pixel mask. @item :format Either @var{:xy-pixmap} or @var{:z-pixmap}. @item :result-type One of @var{'image-x}, @var{'image-xy}, or @var{'image-z}. @end table Returns an @emph{image} containing pixel values from the region of the @emph{drawable} given by @var{:x}, @var{:y}, @var{:width}, and @var{:height}. The bits for all planes selected by 1 bits in the @var{:plane-mask} are returned as zero; the default @var{:plane-mask} is all 1 bits. The @var{:format} of the returned pixel values may be either @var{:xy-format} or @var{:z-format}. The @var{:result-type} defines the type of image object returned: @table @code @item 'image-x A basic @var{image} object is returned. @item 'image-xy An @var{image-xy} is returned. @item 'image-z An @var{image-z} is returned. @end table By default, @var{:result-type} is @var{'image-z} if @var{:format} is @var{:z-format} and @var{'image-xy} if @var{:format} is @var{:xy-format}. @table @var Type @var{image}. @end table @end defun @defun put-image drawable gcontext image &key (:src-x 0) (:src-y 0) :x :y :width :height :bitmap-p @table @var @item drawable The destination @var{drawable}. @item gcontext The graphics context used to display the @emph{image}. @item image An @var{image} object. @item :src-x @itemx :src-y @var{card16} values defining the upper-left position of the @emph{image} region to display. @item :x @itemx :y The position in the @emph{drawable} where the @emph{image} region is displayed. These arguments are required. @item :width :height @var{card16} values defining the size of the @emph{image} region displayed. @item :bitmap-p If @emph{image} is depth 1, then if true, foreground and background pixels are used to display 1 and 0 bits of the @emph{image}. @end table Displays a region of the @emph{image} defined by @var{:src-x}, @var{:src-y}, @var{:width}, and @var{:height} on the destination d@emph{rawable}, with the upper-left pixel of the @emph{image} region displayed at the @emph{drawable} position given by @var{:x} and @var{:y}. By default, @var{:width} is: @lisp (- (@var{image-width} @emph{image}) @var{:src-x}) @end lisp and @var{:height} is: @lisp (- (@var{image-height} @emph{image}) @var{:src-y}) @end lisp The following attributes of the @emph{gcontext} are used to display the @var{image}: clip-mask, clip-x, clip-y, function, plane-mask, and subwindow-mode. The @var{:bitmap-p} argument applies only to images of depth 1. In this case, if @var{:bitmap-p} is true or if the @emph{image} is a basic @var{image} object created with @var{:format :bitmap}, the @emph{image} is combined with the foreground and background pixels of the @var{gcontext}. 1 bits of the @emph{image} are displayed in the foreground pixel and 0 bits are displayed in the background pixel. @end defun @node Image Files, Direct Image Transfer, Image Functions, Images @section Image Files CLX provides functions that allow images to be written to a file in a standard X format. The following paragraphs describe the CLX functions used to: @itemize @bullet @item Read an image from a file. @item Write an image to a file. @end itemize @defun read-bitmap-file pathname @table @var @item pathname An image file pathname. @end table Reads an image file in standard X format and returns an @var{image} object. The returned @emph{image} can have depth greater than one. @table @var @item image Type @var{image}. @end table @end defun @defun write-bitmap-file pathname image &optional name @table @var @item pathname An image file pathname. @item image An @var{image} object. @item name A @var{stringable} image name. @end table Writes the @emph{image} to an image file in standard X format. The @emph{image} can have depth greater than one. The @emph{name} is an image identifier written to the file; the default @emph{name} is (@var{or} (@var{image-name} @emph{image}) @var{'image}). @end defun @node Direct Image Transfer, , Image Files, Images @section Direct Image Transfer For cases where the @var{image} representation is not needed, CLX provides functions to read and display image data directly. @defun get-raw-image drawable &key :data (:start 0) :x :y :width :height :plane-mask (:format :z-format) (:result-type '(vector card8)) @table @var @item drawable A @var{drawable}. @item :data An optional @var{sequence} of @var{card8}. @item :start The index of the first @var{:data} element modified. @item :x @itemx :y @var{card16} values defining the size of the @var{image} returned. These arguments are required. @item :width @itemx :height @var{card16} values defining the size of the image returned.These arguments are required. @item :plane-mask A pixel mask. @item :format Either @var{:xy-pixmap} or @var{:z-pixmap}. This argument is required. @item :result-type The type of image data sequence to return. @end table Returns a sequence of image data from the region of the @emph{drawable} given by @var{:x}, @var{:y}, @var{:width}, and @var{:height}. If @var{:data} is given, it is modified beginning with the element at the @var{:start} index and returned. The @emph{depth} and @emph{visua}l type ID of the @emph{drawable} are also returned. The bits for all planes selected by 1 bits in the @var{:plane-mask} are returned as zero; the default @var{:plane-mask} is all 1 bits. The @var{:format} of the returned pixel values may be either @var{:xy-format} or @var{:z-format}. The @var{:result-type} defines the type of image data returned. The calling program is responsible for handling the byte-order and bit-order returned by the server for the @emph{drawable}'s display (see @var{display-byte-order} and @var{display-image-lsb-first-p}). @table @var @item data Type @var{sequence} or @var{card8}. @item depth Type @var{card8}. @item visual Type @var{card29}. @end table @end defun @defun put-raw-image drawable gcontext data &key (:start 0) :depth :x :y :width :height (:left-pad 0) :format @table @var @item drawable The destination @var{drawable}. @item gcontext The graphics context used to display the image. @item data A sequence of integers. @item :start The index of the first element of @emph{data} displayed. @item :depth The number of bits per pixel displayed. This argument is required. @item :x @itemx :y The position in the @emph{drawable} where the image region is displayed. These arguments are required. @item :width @itemx :height @var{card16} values defining the size of the image region displayed. These arguments are required. @item :left-pad A @var{card8} specifying the number of leading bits to discard for each image scanline. @item :format One of @var{:bitmap}, @var{:xy-pixmap}, or @var{:z-pixmap}. @end table Displays a region of the image data defined by @var{:start}, @var{:left-pad}, @var{:width}, and @var{:height} on the destination @emph{drawable}, with the upper-left pixel of the image region displayed at the @emph{drawable} position given by @var{:x} and @var{:y}. The @var{:format} can be either @var{:xy-pixmap}, @var{:z-pixmap}, or @var{:bitmap}. If @var{:xy-pixmap} or @var{:z-pixmap} formats are used, @var{:depth} must match the depth of the destination @emph{drawable}. For @var{:xy-pixmap}, the data must be in XY format. For @var{:z-pixmap}, the data must be in Z format for the given @var{:depth}. If the @var{:format} is @var{:bitmap}, the @var{:depth} must be 1. In this case, the image is combined with the foreground and background pixels of the @emph{gcontext}. 1 bits of the image are displayed in the foreground pixel and 0 bits are displayed in the background pixel. The @var{:left-pad} must be zero for @var{:z-pixmap} format. For @var{:bitmap} and @var{:xy-pixmap} formats, the @var{:left-pad} must be less than the bitmap-scanline-pad for the @emph{drawable}'s display (@pxref{display-bitmap-format}). The first @var{:left-pad} bits in every scanline are to be ignored by the server; the actual image begins that many bits into the data. The following attributes of the @emph{gcontext} are used to display the @var{image}: clip-mask, clip-x, clip-y, function, plane-mask, and subwindow-mode. The calling program is responsible for handling the byte-order and bit-order required by the server for the @emph{drawable}'s display (see @var{display-byte-order} and @var{display-image-lsb-first-p}). @end defun @node Font and Characters, Colors, Images, Top @chapter Font and Characters An X server maintains a set of fonts used in the text operations requested by client programs. An X font is an array of character bit maps (or @emph{glyphs}) indexed by integer codes. In fact, font glyphs can also represent cursor shapes or other images and are not limited to character images. X supports both linear and matrix encoding of font indexes. With linear encoding, a font index is interpreted as a single 16-bit integer index into a one-dimensional array of glyphs. With matrix encoding, a font index is interpreted as a pair of 8-bit integer indexes into a two-dimensional array of glyphs. The type of index encoding used is font-dependent. In order to access or use a font, a client program must first open it using the @var{open-font} function, sending a font name string as an identifier. @var{open-font} creates a CLX @var{font} object used to refer to the font in subsequent functions. Afterward, calling @var{open-font} with the same font name returns the same @var{font} object. When a font is no longer in use, a client program can call @var{close-font} to destroy the @var{font} object. A font has several attributes which describe its geometry and its glyphs. CLX provides functions to return the attributes of a font, as well functions for accessing the attributes of individual font glyphs. Glyph attributes are referred to as @emph{character attributes}, since characters are the most common type of font glyphs. A font also has a property list of values recorded by the X server. However, the set of possible font properties and their values are not standardized and are implementation-dependent. Typically, CLX maintains a cache of font and character attributes, in order to minimize server requests. However, the font cache mechanism is implementation-dependent and cannot be controlled by the client. In some cases, CLX may create a @emph{pseudo-font} object solely for the purpose of accessing font attributes. A pseudo-font is represented by a special type of @var{font} object that cannot be used in a @var{gcontext}. If necessary, CLX can automatically convert a pseudo-font into a true font, if the name of the pseudo-font is known. The set of available fonts is server-dependent; that is, font names are not guaranteed to be portable from one server to the next. However, the public X implementation from MIT includes a set of fonts that are typically available with most X servers. The following paragraphs describe CLX functions to: @itemize @bullet @item Open and close fonts. @item List available fonts. @item Access font attributes. @item Access character attributes. @item Return the size of a text string. @end itemize @menu * Opening Fonts:: * Listing Fonts:: * Font Attributes:: * Chracter Attributes:: * Querying Text Size:: @end menu @node Opening Fonts, Listing Fonts, Font and Characters, Font and Characters @section Opening Fonts The following paragraphs discuss the CLX functions for opening and closing fonts. @defun open-font display name @table @var @item display A @var{display} object. @item name A font name string. @end table Opens the font with the given @emph{name} and returns a @var{font} object. The name string should contain only ISO Latin-1 characters; case is not significant. @table @var @item font Type @var{font}. @end table @end defun @defun close-font font @table @var @item font A @var{font} object. @end table Deletes the association between the resource ID and the @emph{font}. The @emph{font} is freed when no other server resource references it. The @emph{font} can be unloaded by the X server if this is the last reference to the @emph{font} by any client. In any case, the @emph{font} should never again be referenced because its resource ID is destroyed. This might not generate a protocol request if the @emph{font} is reference-counted locally or if it is a pseudo-font. @end defun @defun discard-font-info fonts @table @var @item font A @var{font} object. @end table Discards any state that can be re-obtained with @var{open-font}. This is simply a performance hint for memory-limited systems. @end defun @node Listing Fonts, Font Attributes, Opening Fonts, Font and Characters @section Listing Fonts The following paragraphs describe CLX functions that return fonts or font names that match a given pattern string. Such pattern strings should contain only ISO Latin-1 characters; case is not significant. The following pattern characters can be used for @emph{wildcard} matching: @table @code @item #\* Matches any sequence of zero or more characters. @item #\? Matches any single character. @end table For example, the pattern "T?mes Roman" matches the name "Times Roman" but not the name "Thames Roman". However, the pattern "T*mes Roman" matches both names. @defun font-path display &key (:result-type 'list) @table @var @item display A @var{display} object. @item :result-type Specifies the type of resulting sequence. @end table Returns a @var{list} (by default) of names containing the current search path for fonts. With @code{setf}, this function sets the search path for font lookup. There is only one search path per server, not one per client. The interpretation of the names is server-dependent, but they are intended to specify directories to be searched in the order listed. Setting the path to the empty list restores the default path defined for the server. Note that as a side-effect of executing this request, the server is guaranteed to flush all cached information about fonts for which there are currently no explicit resource IDs allocated. @table @var @item paths Type @var{sequence} of either @var{string} or @var{pathname}. @end table @end defun @defun list-font-names display pattern &key (:max-fonts 65535) (:result-type 'list) @table @var @item display A @var{display} object. @item pattern A string used to match font names. Only font names that match the pattern are returned. @item :max-fonts The maximum number of font names returned. Default is 65535. @item :result-type The type of sequence to return. Default is '@var{list}. @end table Returns a sequence of strings containing the font names that match the @emph{pattern}. The fonts available are determined by the font search path; see @var{font-path}). The maximum number of font names returned is determined by @var{:max-fonts}. @table @var @item font-name Type @var{sequence} of @var{string}. @end table @end defun @defun list-fonts display pattern &key (:max-fonts 65535) (:result-type 'list) @table @var @item display A @var{display} object. @item pattern A string used to match font names. Only fonts whose name matches the pattern are returned. @item :max-fonts The maximum number of fonts returned. Default is 65535. @item :result-type The type of sequence to return. Default is @var{'list}. @end table Returns a sequence of pseudo-fonts corresponding to the available fonts whose names match the @emph{pattern}. The fonts available are determined by the font search path; see @var{font-path}). The maximum number of @var{font} objects returned is determined by @var{:max-fonts}. @table @var @item font Type @var{sequence} of @var{font}. @end table @end defun @node Font Attributes, Chracter Attributes, Listing Fonts, Font and Characters @section Font Attributes The following paragraphs describe the CLX functions used to access font attributes. @defun font-all-chars-exist-p font @table @var @item exists-p Type @var{boolean}. @end table Returns true if glyphs exist for all indexes in the range returned by @var{font-min-char} and @var{font-max-char}. Returns @var{nil} if an index in the range corresponds to empty glyph. @table @var @item font A @var{font} object. @end table @end defun @defun font-ascent font @table @var @item ascent Type @var{int16}. @end table Returns the vertical @emph{ascent} of the @emph{font} used for interline spacing. The @emph{ascent} defines the nominal distance in pixels from the baseline to the bottom of the previous line of text. Some font glyphs may actually extend beyond the font @emph{ascent}. @table @var @item font A @var{font} object. @end table @end defun @defun font-default-char font @table @var @item index Type @var{card16}. @end table Returns the @emph{index} of the glyph drawn when an invalid or empty glyph index is specified. If the default index specifies an invalid or empty glyph, an invalid or empty index has no effect. @table @var @item font A @var{font} object. @end table @end defun @defun font-descent font @table @var @item descent Type @var{int16}. @end table Returns the vertical @emph{descent} of the @emph{font} used for interline spacing. The @emph{descent} defines the nominal distance in pixels from the baseline to the top of the next line of text. Some font glyphs may actually extend beyond the font @emph{descent}. @table @var @item font A @var{font} object. @end table @end defun @defun font-direction font @table @var @item direction Type @var{draw-direction}. @end table Returns the nominal drawing @emph{direction} for the @emph{font}. The font drawing direction is only a hint that indicates whether the @emph{char-width} of most font glyphs is positive (@var{:left-to-right} direction) or negative (@var{:right-to-left} direction). Note that X does not provide any direct support for vertical text. @table @var @item font A @var{font} object. @end table @end defun @defun font-display font @table @var @item font A @var{font} object. @end table Returns the @var{display} object associated with the specified @emph{font}. @table @var @item display Type @var{display}. @end table @end defun @defun font-equal font-1 font-2 @table @var @item font-1 @itemx font-2 The @var{font} objects. @end table Returns true if the two arguments refer to the same server resource and @var{nil} if they do not. @end defun @defun font-id font @table @var @item font A @var{font} object. @end table Returns the unique resource ID assigned to the specified @emph{font}. @table @var @item id Type @var{resource-id}. @end table @end defun @defun font-max-byte1 font @table @var @item font A @var{font} object. @end table Returns zero if the @emph{font} uses linear index encoding. Otherwise, if the @emph{font} uses matrix index encoding, a value between 1 and 255 is returned that specifies the maximum value for the most significant byte of font indexes. @table @var @item max-byte1 Type @var{card8}@emph{.} @end table @end defun @defun font-max-byte2 font @table @var @item font A @var{font} object. @end table Returns zero if the @emph{font} uses linear index encoding. Otherwise, if the @emph{font} uses matrix index encoding, a value between 1 and 255 is returned that specifies the maximum value for the least significant byte of font indexes. @table @var @item max-byte2 Type @var{card8}@emph{.} @end table @end defun @defun font-max-char font @table @var @item font A @var{font} object. @end table Returns the maximum valid value used for linear encoded indexes. This function is not meaningful for fonts that use matrix index encoding. @table @var @item index Type @var{card16}. @end table @end defun @defun font-min-byte1 font @table @var @item font A @var{font} object. @end table Returns zero if the @emph{font} uses linear index encoding. Otherwise, if the @emph{font} uses matrix index encoding, a value between 1 and 255 is returned that specifies the minimum value for the most significant byte of font indexes. @table @var @item min-byte1 Type @var{card8}. @end table @end defun @defun font-min-byte2 font @table @var @item font A @var{font} object. @end table Returns zero if the @emph{font} uses linear index encoding. Otherwise, if the @emph{font} uses matrix index encoding, a value between 1 and 255 is returned that specifies the minimum value for the least significant byte of font indexes. @table @var @item min-byte2 Type @var{card8}. @end table @end defun @defun font-min-char font @table @var @item font A @var{font} object. @end table Returns the minimum valid value used for linear encoded indexes. This function is not meaningful for fonts that use matrix index encoding. @table @var @item index Type @var{card16}. @end table @end defun @defun font-name font @table @var @item font A @var{font} object. @end table Returns the name of the @emph{font}, or @var{nil} if @emph{font} is a pseudo-font. @table @var @item name Type @var{string} or @var{null}. @end table @end defun @defun font-p font Returns true if the argument is a @var{font} object and @var{nil} otherwise. @table @var @item font-p Type @var{boolean}. @end table @end defun @defun font-plist font @table @var @item font A @var{font} object. @end table Returns and (with @code{setf}) sets the property list for the specified @emph{font}. This function provides a hook where extensions can add data. @table @var @item plist Type @var{list}. @end table @end defun @defun font-properties font @table @var @item font A @var{font} object. @end table Returns the list of font @emph{properties} recorded by the X server. The returned list is a property list of keyword/value pairs. The set of possible font property keywords is implementation-dependent. @table @var @item properties Type @var{list}. @end table @end defun @defun font-property font name @table @var @item font A @var{font} object. @item name A font property keyword. @end table Returns the value of the font @emph{property} specified by the @emph{name} keyword. The property value, if it exists, is returned as an uninterpreted 32-bit integer. @table @var @item property Type @var{int32} or @var{null}. @end table @end defun @defun max-char-ascent font @table @var @item font A @var{font} object. @end table Returns the maximum @var{char-ascent} value for all characters in @emph{font}. @table @var @item ascent Type @var{int16}. @end table @end defun @defun max-char-attributes font @table @var @item font A @var{font} object. @end table Returns the maximum @var{char-attributes} value for all characters in @emph{font}. @table @var @item attributes Type @var{int16}. @end table @end defun @defun max-char-descent font @table @var @item font A @var{font} object. @end table Returns the maximum @var{char-descent} value for all characters in @emph{font}. @table @var @item descent Type @var{int16}. @end table @end defun @defun max-char-left-bearing font @table @var @item font A @var{font} object. @end table Returns the maximum @var{char-left-bearing} value for all characters in @emph{font}. @table @var @item left-bearing Type @var{int16}. @end table @end defun @defun max-char-right-bearing font @table @var @item font A @var{font} object. @end table Returns the maximum @var{char-right-bearing} value for all characters in @emph{font}. @table @var @item right-bearing Type @var{int16}. @end table @end defun @defun max-char-width font @table @var @item font A @var{font} object. @end table Returns the maximum @var{char-width} value for all characters in @emph{font}. @table @var @item width Type @var{int16}. @end table @end defun @defun min-char-ascent font @table @var @item font A @var{font} object. @end table Returns the minimum @var{char-ascent} for all characters in @emph{font}. @table @var @item ascent Type @var{int16}. @end table @end defun @defun min-char-attributes font @table @var @item font A @var{font} object. @end table Returns the minimum @var{char-attributes} for all characters in @emph{font}. @table @var @item attributes Type @var{int16}. @end table @end defun @defun min-char-descent font @table @var @item font A @var{font} object. @end table Returns the minimum @var{char-descent} for all characters in @emph{font}. @table @var @item descent Type @var{int16}. @end table @end defun @defun min-char-left-bearing font @table @var @item font A @var{font} object. @end table Returns the minimum @var{char-left-bearing} for all characters in @emph{font}. @table @var @item left-bearing Type @var{int16}. @end table @end defun @defun min-char-right-bearing font @table @var @item font A @var{font} object. @end table Returns the minimum @var{char-right-bearing} for all characters in @emph{font}. @table @var @item right-bearing Type @var{int16}. @end table @end defun @defun min-char-width font @table @var @item font A @var{font} object. @end table Returns the minimum @var{char-width} for all characters in @emph{font}. @table @var @item width Type @var{int16}. @end table @end defun @node Chracter Attributes, Querying Text Size, Font Attributes, Font and Characters @section Chracter Attributes The following paragraphs describe the CLX functions used to access the attributes of individual font glyphs. @defun char-ascent font index @table @var @item font A @var{font} object. @item index An @var{int16} font index. @end table Returns the vertical distance in pixels from the baseline to the top of the given font glyph. Returns @var{nil} if the index is invalid or specifies an empty glyph, or if the @emph{font} is a pseudo-font. @table @var @item ascent Type @var{int16} or @var{null}. @end table @end defun @defun char-attributes font index @table @var @item font A @var{font} object. @item index An @var{int16} font index. @end table Returns font-specific @emph{attributes} of the given glyph. The interpretation of such attributes is server-dependent. Returns @var{nil} if the @emph{index} is invalid or specifies an empty glyph, or if the @emph{font} is a pseudo-font. @table @var @item attributes Type @var{int16} or @var{null}. @end table @end defun @defun char-descent font index @table @var @item font A @var{font} object. @item index An @var{int16} font index. @end table Returns the vertical distance in pixels from the baseline to the bottom of the given font glyph. Returns @var{nil} if the @emph{index} is invalid or specifies an empty glyph, or if the @emph{font} is a pseudo-font. @table @var @item descent Type @var{int16} or @var{null}. @end table @end defun @defun char-left-bearing font index @table @var @item font A @var{font} object. @item index An @var{int16} font index. @end table Returns the left side bearing of the given font glyph. If @var{draw-glyph} is called with horizontal position @emph{x}, the leftmost pixel of the glyph is drawn at the position (+ @emph{x left-bearing}). Returns @var{nil} if the @emph{index} is invalid or specifies an empty glyph, or if the @emph{font} is a pseudo-font. @table @var @item left-bearing Type @var{int16} or @var{null}. @end table @end defun @defun char-right-bearing font index @table @var @item font A @emph{font} object. @item index An @var{int16} font index. @end table Returns the right side bearing of the given font glyph. If n@var{draw-glyph} is called with horizontal position @emph{x}, the rightmost pixel of the glyph is drawn at the position (+ @emph{x rightbearing}). Returns @var{nil} if the @emph{index} is invalid or specifies an empty glyph, or if the @emph{font} is a pseudo-font. @table @var @item right-bearing Type @var{int16} or @var{null}. @end table @end defun @defun char-width font index @table @var @item font A @var{font} object. @item index An @var{int16} font index. @end table Returns the @emph{width} of the given font glyph. The @emph{width} is defined to be equal to (- @emph{rightbearing left-bearing}). Returns @var{nil} if the @emph{index} is invalid or specifies an empty glyph, or if the @emph{font} is a pseudo-font. @table @var @item width Type @var{int16} or @var{null}. @end table @end defun @node Querying Text Size, , Chracter Attributes, Font and Characters @section Querying Text Size CLX defines functions to return the size of text drawn in a specified font. @xref{Drawing Text}, for a description of the @var{:translate} function used by the functions in the following paragraphs. @defun text-extents font sequence &key (:start 0) :end :translate @anchor{text-extents} @table @var @item font The font (or @var{gcontext}) used for measuring characters. @item sequence A sequence of characters or other objects to be translated into font indexes. @item :start @itemx :end Start and end indexes defining the elements to draw. @item :translate A function to translate text to font indexes. Default is @var{#'translate-default}. @end table Returns the complete geometry of the given @emph{sequence} when drawn in the given @emph{fon}t. The @emph{font} can be a @var{gcontext}, in which case the font attribute of the given graphics context is used. @var{:start} and @var{:end} define the elements of the @emph{sequence} which are used. The returned @emph{width} is the total pixel width of the translated character sequence. The returned @emph{ascent} and @emph{descent} give the vertical ascent and descent for characters in the translated @emph{sequence}. The returned @emph{left} gives the left bearing of the leftmost character. The returned @emph{right} gives the right bearing of the rightmost character. The returned @emph{font-ascent} and @emph{font-descent} give the maximum vertical ascent and descent for all characters in the @emph{fon}t. If @var{:translate} causes font changes, then @emph{font-ascent} and @emph{font-descent} will be the maximums over all fonts used. The @emph{direction} returns the preferred draw direction for the font. If @var{:translate} causes font changes, then the @emph{direction} will be @var{nil}. The @emph{first-not-done} value returned is @var{nil} if all elements of the @emph{sequence} were successfully translated; otherwise the index of the first untranslated element is returned. @table @var @item width Type @var{int32}. @item ascent Type @var{int16}. @item descent Type @var{int16}. @item left Type @var{int32}. @item right Type @var{int32}. @item font-ascent Type @var{int16}. @item direction Type @var{draw-direction}. @item first-not-done Type @var{array-index} or @var{null}. @end table @end defun @defun text-width font sequence &key (:start 0) :end :translate @table @var @item font The font (or @var{gcontext}) used for measuring characters. @item sequence A sequence of characters or other objects to be translated into font indexes. @item :start @item :end Start and end indexes defining the elements to draw. @item :translate A function to translate text to font indexes. Default is @var{#'translate-default}. @end table Returns the total pixel width of the given @emph{sequence} when drawn in the given @emph{font}. The @emph{font} can be a @var{gcontext}, in which case the font attribute of the given graphics context is used. @var{:start} and @var{:end} define the elements of the @emph{sequence} which are used. The second value returned is @var{nil} if all elements of the @emph{sequence} were successfully translated; otherwise the index of the first untranslated element is returned. @table @var @item width Type @var{int32}. @item first-not-done Type @var{array-index} or @var{null}. @end table @end defun @node Colors, Cursors, Font and Characters, Top @chapter Colors @menu * Colormaps and Colors:: * Color Functions:: * Colormap Functions:: @end menu @node Colormaps and Colors, Color Functions, Colors, Colors @section Colormaps and Colors In X, a @emph{color} is defined by a set of three numeric values, representing intensities of red, green, and blue. Red, green, and blue are referred to as the @emph{primary} hues. A @emph{colormap} is a list of colors, each indexed by an integer @emph{pixel} value. Each entry in a colormap is called a color @emph{cell}. Raster graphics displays store pixel values in a special screen hardware memory. As the screen hardware scans this memory, it reads each pixel value, looks up the color in the corresponding cell of a colormap, and displays the color on its screen. The colormap abstraction applies to all classes of visual types supported by X, including those for screens which are actually monochrome. For example, @var{:gray-scale} screens use colormaps in which colors actually specify the monochrome intensity. A typical black-and-white monochrome display has a @var{:static-gray} screen with a two-cell colormap. The following list describes how pixel values and colormaps are handled for each visual class. @table @var @item :direct-color A pixel value is decomposed into separate red, green, and blue subfields. Each subfield indexes a separate colormap. Entries in all colormaps can be changed. @item :gray-scale A pixel value indexes a single colormap that contains monochrome intensities. Colormap entries can be changed. @item :pseudo-color A pixel value indexes a single colormap that contains color intensities. Colormap entries can be changed. @item :static-color Same as @var{:pseudo-color}, except that the colormap entries are predefined by the hardware and cannot be changed. @item :static-gray Same as @var{:gray-scale}, except that the colormap entries are predefined by the hardware and cannot be changed. @item :true-color Same as @var{:direct-color}, except that the colormap entries are predefined by the hardware and cannot be changed. Typically, each of the red, green, and blue colormaps provides a (near) linear ramp of intensity. @end table CLX provides functions to create colormaps, access and modify colors and color cells, and install colormaps in screen hardware. @node Color Functions, Colormap Functions, Colormaps and Colors, Colors @section Color Functions A color is represented by a CLX color object, in which each of the red, green, and blue values is specified by an @var{rgb-val} -- a floating point number between 0.0 and 1.0. (@pxref{Data Types}). The value 0.0 represents the minimum intensity, while 1.0 represents the maximum intensity. CLX automatically converts @var{rgb-val} values into 16-bit integers when sending colors to an X server. The X server, in turn, scales 16-bit color values to match the actual intensity range supported by the screen. Colors used on @var{:gray-scale} screens must have the same value for each of red, green, and blue. Only one of these values is used by screen hardware to determine intensity; however, CLX does not define which of red, green, or blue is actually used. The following paragraphs describe the CLX functions used to create, access, and modify colors. @defun make-color &key (:blue 1.0) (:green 1.0) (:red 1.0) &allow-other-keys @table @var @item :blue @itemx :green @itemx :red @var{rgb-val} values that specify the saturation for each primary. @end table Creates, initializes, and returns a new @var{color} object with the specified values for red, green, and blue. @table @var @item color Type @var{color}. @end table @end defun @defun color-blue color @table @var @item color A @var{color} object. @end table Returns and (with @code{setf}) sets the value for blue in the @emph{color}. @table @var @item blue-intensity Type @var{rgb-val}. @end table @end defun @defun color-green color @table @var @item color A @var{color} object. @end table Returns and (with @code{setf}) sets the value for green in the @emph{color}. @table @var @item green-intensity Type @var{rgb-val}. @end table @end defun @defun color-p color Returns non-@var{nil} if the argument is a @var{color} object and @var{nil} otherwise. @table @var @item color-p Type @var{boolean}. @end table @end defun @defun color-red color @table @var @item color A @var{color} object. @end table Returns and (with @code{setf}) sets the value for red in the @emph{color}. @table @var @item red-intensity Type @var{rgb-val}. @end table @end defun @defun color-rgb color @table @var @item color A @var{color} object. @end table Returns the values for red, green, and blue in the @emph{color}. @table @var @item red @itemx green @itemx blue Type @var{rgb-val}. @end table @end defun @node Colormap Functions, , Color Functions, Colors @section Colormap Functions A colormap is represented in CLX by a @var{colormap} object. A CLX program can create and manipulate several @var{colormap} objects. However, the colors contained in a @var{colormap} are made visible only when the @var{colormap} is @emph{installed}. Each window is associated with a @var{colormap} that is used to translate window pixels into colors (see @var{window-colormap}). However, a window will appear in its true colors only if its associated @var{colormap} is installed. The total number of colormaps that can be installed depends on the screen hardware. Most hardware devices allow exactly one @var{colormap} to be installed at any time. That is, @var{screen-min-installed-maps} and @var{screen-max-installed-maps} are both equal to 1. Installing a new @var{colormap} can cause a previously installed @var{colormap} to be uninstalled. It is important to remember that the set of installed @var{colormaps} is a hardware resource shared cooperatively among all client programs connected to an X server. A CLX program can control the contents of @var{colormaps} by allocating color cells in one of two ways: read-only or read-write. Allocating a read-only color cell establishes a color value for a specified pixel value that cannot be changed. However, read-only color cells can be shared among all client programs. Read-only allocation is the best strategy for making use of limited @var{colormap} hardware in a multi-client environment. Alternatively, allocating a read-write color cell allows a client the exclusive right to set the color value stored in the cell. A cell allocated read-write by one client cannot be allocated by another client, not even as a read-only cell. Note that read-write allocation is not allowed for screens whose visual type belongs to one of the @var{:static-gray}, @var{:static-color}, or @var{:true-color} classes. For screens of these classes, @var{colormap} cells cannot be modified. Two entries of the default colormap, typically containing the colors black and white, are automatically allocated read-only. The pixel values for these entries can be returned by the functions @var{screen-black-pixel} and @var{screen-white-pixel}. Applications that need only two colors and also need to operate on both monochrome and color screens should always use these pixel values. The names @emph{black} and @emph{white} are intended to reflect relative intensity levels and need not reflect the actual colors displayed for these pixel values. Each screen has a default @var{colormap}, which is initially installed. By conventions, clients should allocate only read-only cells from the default @var{colormap}. @menu * Creating Colormaps:: * Installing Colormaps:: * Allocating Colors:: * Finding Colors:: * Changing Colors:: * Colormap Attributes:: @end menu @node Creating Colormaps, Installing Colormaps, Colormap Functions, Colormap Functions @subsection Creating Colormaps CLX provides functions for creating and freeing new @var{colormap} objects. @defun create-colormap visual window &optional alloc-p @table @var @item visual A @var{visual} type ID. @item window A @var{window}. @item alloc-p Specifies whether @var{colormap} cells are permanently allocated read-write. @end table Creates and returns a @emph{colormap} of the specified @emph{visual} type for the screen containing the @emph{window}. The @emph{visual} type must be one of those supported by the screen. Initial color cell values are undefined for visual types belonging to the @var{:gray-scale}, @var{:pseudo-color}, and @var{:direct-color} classes. Color cell values for visual types belonging to the @var{:static-gray}, @var{:static-color}, and @var{:true-color} classes have initial values defined by the visual type. However, X does not define the set of possible visual types or their initial color cell values. If @emph{alloc-p} is true, all colormap cells are permanently allocated read-write and cannot be freed by @var{free-colors}. It is an error for @emph{alloc-p} to be true when the visual type belongs to the @var{:static-gray}, @var{:static-color}, or @var{:true-color} classes. @table @var @item colormap Type @var{colormap}. @end table @end defun @defun copy-colormap-and-free colormap @table @var @item colormap A @var{colormap}. @end table Creates and returns a new @var{colormap} by copying, then freeing, allocated cells from the specified @emph{colormap}. All color cells allocated read-only or read-write in the original @var{colormap} have the same color values and the same allocation status in the @emph{new-colormap}. The values of unallocated color cells in the @emph{new-colormap} are undefined. After copying, all allocated color cells in the original @var{colormap} are freed, as if @var{free-colors} was called. The unallocated cells of the original @var{colormap} are not affected. If @emph{alloc-p} was true when the original @var{colormap} was created, then all color cells of the @emph{new-colormap} are permanently allocated read-write, and all the color cells of the original @var{colormap} are freed. @table @var @item new-colormap Type @var{colormap}. @end table @end defun @defun free-colormap colormap @table @var @item colormap A @var{colormap}. @end table Destroys the @emph{colormap} and frees its server resource. If the @emph{colormap} is installed, it is uninstalled. For any window associated with the @emph{colormap}, the window is assigned a @var{nil} @var{colormap}, and a @var{:colormap-notify} event is generated. The colors displayed for a window with a @var{nil colormap} are undefined. However, this function has no effect if the @emph{colormap} is a screen default @var{colormap}. @end defun @node Installing Colormaps, Allocating Colors, Creating Colormaps, Colormap Functions @subsection Installing Colormaps The following paragraphs describe the CLX functions to install and uninstall colormaps and to return the set of installed colormaps. Initially, the default @var{colormap} for a screen is installed (but is not in the required list). @defun install-colormap colormap @anchor{install-colormap} @table @var @item colormap A @var{colormap}. @end table Installs the @emph{colormap.} All windows associated with this @emph{colormap} immediately display with true colors. As a side-effect, additional colormaps might be implicitly uninstalled by the server. If the specified @emph{colormap} is not already installed, a @var{:colormap-notify} event is generated on every window associated with this @emph{colormap}. In addition, for every other colormap that is implicitly uninstalled, a @var{:colormap-notify} event is generated on every associated window. @end defun @defun installed-colormaps window &key (:result-type 'list) @table @var @item window A @var{window}. @item :result-type A sub-type of @var{sequence} that indicates the type of sequence to return. @end table Returns a sequence containing the installed @var{colormaps} for the screen of the specified @emph{window}. The order of the colormaps is not significant. @table @var @item colormap Type @var{sequence} of @var{colormap}. @end table @end defun @defun uninstall-colormap colormap @table @var @item colormap A @var{colormap}. @end table Uninstalls the @emph{colormap}. However, the @emph{colormap} is not actually uninstalled if this would reduce the set of installed colormaps below the value of @var{screen-min-installed-maps}. If the @emph{colormap} is actually uninstalled, a @var{:colormap-notify} event is generated on every associated window. @end defun @node Allocating Colors, Finding Colors, Installing Colormaps, Colormap Functions @subsection Allocating Colors The following paragraphs describe the functions for allocating read-only and read-write color cells, allocating color planes, and freeing color cells. @defun alloc-color colormap color @table @var @item colormap A @var{colormap}. @item color A @var{color} object or a @var{stringable} containing a color name. @end table Returns a @emph{pixel} for a read-only color cell in the @emph{colormap}. The color in the allocated cell is the closest approximation to the requested @emph{color} possible for the screen hardware. The other values returned give both the approximate color stored in the cell and the exact color requested. The requested @emph{color} can be either a @var{color} object or a @var{stringable} containing a color name. If a color name is given, a corresponding color value is looked up (see @var{lookup-color}) and used. Color name strings must contain only ISO Latin-1 characters; case is not significant. @table @var @item pixel Type @var{pixel}. @item screen-color @itemx exact-color Type @var{color}. @end table @end defun @defun alloc-color-cells colormap colors &key (:planes 0) :contiguous-p (:result-type 'list) @table @var @item colormap A @var{colormap}. @item colors A positive number defining the length of the pixels sequence returned. @item :planes A non-negative number defining the length of the masks sequence returned. @item :contiguous-p If true, the masks form contiguous sets of bits. @item :result-type A subtype of @var{sequence} that indicates the type of sequences returned. @end table Returns a @var{sequence} of @emph{pixels} for read-write color cells in the @emph{colormap}. The allocated cells contain undefined color values. The visual type class of the @var{colormap} must be either @var{:gray-scale}, @var{:pseudo-color}, or @var{:direct-color}. The @emph{colors} argument and the @var{:planes} argument define the number of pixels and the number of masks returned, respectively. The number of colors must be positive, and the number of planes must be non-negative. A total of (* @emph{colors} (@var{expt} 2 @emph{planes})) color cells are allocated. The pixel values for the allocated cells can be computed by combining the returned pixels and masks. The length of the returned masks sequence is equal to @var{:planes}. Each mask of the returned masks sequence defines a single bitplane. None of the masks have any 1 bits in common. Thus, by selectively combining masks with @var{logior}, (@var{expt} 2 @emph{planes}) distinct combined plane masks can be computed. The length of the returned @emph{pixels} sequence is equal to @emph{colors}. None of the pixels have any 1 bits in common with each other or with any of the returned masks. By combining pixels and plane masks with @var{logior}, (* @emph{colors} (@var{expt} 2 @emph{planes})) distinct pixel values can be produced. If the @emph{colormap} class is @var{:gray-scale} or @var{:pseudo-color}, each @emph{mask} will have exactly one bit set. If the @var{colormap} class is @var{:direct-color}, each @emph{mask} will have exactly three bits set. If @var{:contiguous-p} is true, combining all masks with @var{logior} produces a plane mask with either one set of contiguous bits (for @var{:gray-scale} and @var{:pseudo-color}) or three sets of contiguous bits (for @var{:direct-color}). @table @var @item pixels @itemx mask Type @var{sequence} of @var{pixels}. @end table @end defun @defun alloc-color-planes colormap colors &key (:reds 0) (:greens 0) (:blues 0) :contiguous-p (:result-type 'list) @table @var @item colormap A @var{colormap}. @item colors A positive number defining the length of the pixels sequence returned. @item :planes A non-negative number defining the length of the masks sequence returned. @item :contiguous-p If true, then the masks form contiguous sets of bits. @item :result-type A subtype of @var{sequence} that indicates the type of sequences returned. @end table Returns a @var{sequence} of @emph{pixels} for read-write color cells in the @emph{colormap}. The allocated cells contain undefined color values. The visual type class of the @emph{colormap} must be either @var{:gray-scale}, @var{:pseudo-color}, or @var{:direct-color}. The @emph{colors} argument defines the number of pixels returned. The @var{:reds}, @var{:greens}, and @var{:blues} arguments define the number of bits set in the returned red, green, and blue masks, respectively. The number of colors must be positive, and the number of bits for each mask must be non-negative. A total of (* @emph{colors} (@var{expt} 2 (+ @emph{reds greens} @emph{blues}))) color cells are allocated. The pixel values for the allocated cells can be computed by combining the returned @emph{pixels} and masks. Each mask of the returned masks defines a pixel subfield for the corresponding primary. None of the masks have any 1 bits in common. By selectively combining subsets of the red, green, and blue masks with @var{logior}, (@var{expt} 2 (+ @emph{reds greens blues}) distinct combined plane masks can be computed. The length of the returned @emph{pixels} @var{sequence} is equal to @emph{colors}. None of the pixels have any 1 bits in common with each other or with any of the returned masks. By combining pixels and plane masks with @var{logior}, (* @emph{colors} (@var{expt} 2 (+ @emph{reds greens blues})) distinct pixel values can be produced. If @var{:contiguous-p} is true, each of returned masks consists of a set of contiguous bits. If the @var{colormap} class is @var{:direct-color}, each returned mask lies within the pixel subfield for its primary. @table @var @item pixels Type @var{sequence} of @var{pixel}. @item red-mask @itemx green-mask @itemx blue-mask Type @var{pixel}. @end table @end defun @defun free-colors colormap pixels &optional (plane-mask 0) @table @var @item colormap A @var{colormap}. @item pixels A @var{sequence} of pixel values. @item plane-mask A pixel value with no bits in common with any of the @emph{pixels}. @end table Frees a set of allocated color cells from the @emph{colormap}. The pixel values for the freed cells are computed by combining the given @emph{pixels} sequence and @var{:plane-mask}. The total number of cells freed is: @lisp (* (@var{length} @emph{pixels}) (@var{expt} 2 (@var{logcount} @emph{plane-mask}))) @end lisp The @var{:plane-mask} must not have any bits in common with any of the given @emph{pixels}. The pixel values for the freed cells are produced by using @var{logior} to combine each of the given pixels with all subsets of the @var{:plane-mask}. Note that freeing an individual pixel allocated by @var{alloc-color-planes} may not allow it to be reused until all related pixels computed from the same plane mask are also freed. A single error is generated if any computed pixel is invalid or if its color cell is not allocated by the client. Even if an error is generated, all valid pixel values are freed. @end defun @node Finding Colors, Changing Colors, Allocating Colors, Colormap Functions @subsection Finding Colors A CLX program can ask the X server to return the colors stored in allocated color cells. The server also maintains a dictionary of color names and their associated color values. CLX provides a function to look up the values for common colors by names such as "red", "purple", and so forth. The following paragraphs describe the CLX functions for returning the color values associated with color cells or with color names. @defun lookup-color colormap name @table @var @item colormap A @var{colormap}. @item name A @var{stringable} color name. @end table Returns the color associated by the X server with the given color @emph{name}. The @emph{name} must contain only ISO Latin-1 characters; case is not significant. The first value returned is the closest approximation to the requested color possible on the screen hardware. The second value returned is the true color value for the requested color. @table @var @item screen-color @itemx exact-color Type @var{color}. @end table @end defun @defun query-colors colormap pixels &key (:result-type 'list) @table @var @item colormap A @var{colormap}. @item pixels A @var{sequence} of @var{pixel} values. @item :result-type A subtype of @var{sequence} that indicates the type of sequences returned. @end table Returns a @var{sequence} of the colors contained in the allocated cells of the @emph{colormap} specified by the given @emph{pixels}. The values returned for unallocated cells are undefined. @table @var @item colors Type @var{sequence} of @var{color}. @end table @end defun @node Changing Colors, Colormap Attributes, Finding Colors, Colormap Functions @subsection Changing Colors The following paragraphs describe the CLX functions to change the colors in colormap cells. @defun store-color colormap pixel color &key (:red-p t) (:green-p t) (:blue-p t) @table @var @item colormap A @var{colormap}. @item pixel A @var{pixel}. @item color A color @var{object} or a @var{stringable} containing a color name. @item :red-p @itemx :green-p @itemx :blue-p @var{boolean} values indicating which color components to store. @end table Changes the contents of the @emph{colormap} cell indexed by the @emph{pixel}. Components of the given @emph{color} are stored in the cell. The @var{:red-p}, @var{:green-p}, and @var{:blue-p} arguments indicate which components of the given @emph{color} are stored. The @emph{color} can be either a @var{color} object or a @var{stringable} containing a color name. If a color name is given, a corresponding color value is looked up (see @var{lookup-color}) and used. Color name strings must contain only ISO Latin-1 characters; case is not significant. @end defun @defun store-colors colormap pixel-colors &key (:red-p t) (:green-p t) (:blue-p t) @table @var @item colormap A @var{colormap}. @item pixel-colors A list of the form (@{@emph{pixel color}@}*). @item :red-p @itemx :green-p @itemx :blue-p @var{boolean} values indicating which color components to store. @end table Changes the contents of multiple @emph{colormap} cells. @emph{pixel-colors} is a list of the form (@{ @emph{pixel color}@}*), indicating a set of pixel values and the colors to store in the corresponding cells. The @var{:red-p}, @var{:green-p}, and @var{:blue-p} arguments indicate which components of the given colors are stored. Each color can be either a @var{color} object or a @var{stringable} containing a color name. If a color name is given, a corresponding color value is looked up (see @var{lookup-color}) and used. Color name strings must contain only ISO Latin-1 characters; case is not significant. @end defun @node Colormap Attributes, , Changing Colors, Colormap Functions @subsection Colormap Attributes The complete set of colormap attributes is discussed in the following paragraphs. @defun colormap-display colormap @table @var @item colormap A @var{colormap}. @end table Returns the @var{display} object associated with the specified @emph{colormap}. @table @var @item display Type @var{display}. @end table @end defun @defun colormap-equal colormap-1 colormap-2 @table @var @item colormap-1 @itemx colormap-2 A @var{colormap}. @end table Returns true if the two arguments refer to the same server resource and @var{nil} if they do not. @end defun @defun colormap-id colormap @table @var @item colormap A @var{colormap}. @end table Returns the unique ID assigned to the specified @emph{colormap}. @table @var @item id Type @var{resource-id}. @end table @end defun @defun colormap-p colormap Returns non-@var{nil} if the argument is a @var{colormap} and @var{nil} otherwise. @table @var @item map-p Type @var{boolean}. @end table @end defun @defun colormap-plist colormap @table @var @item colormap A @var{colormap}. @end table Returns and (with @code{setf}) sets the property list for the specified @emph{colormap}. This function provides a hook where extensions can add data. @table @var @item colormap-p Type @var{boolean}. @end table @end defun @node Cursors, Atoms, Colors, Top @chapter Cursors A @emph{cursor} is a visible shape that appears at the current position of the pointer device. The cursor shape moves with the pointer to provide continuous feedback to the user about the current location of the pointer. Each window can have a cursor attribute that defines the appearance of the pointer cursor when the pointer position lies within the window. See @var{window-cursor}. A cursor image is composed of a source bitmap, a mask bitmap, a @emph{hot spot}, a foreground color, and a background color. Either 1-bit pixmaps or font glyphs can be used to specify source and mask bitmaps. The source bitmap identifies the foreground and background pixels of the cursor image; the mask bitmap identifies which source pixels are actually drawn. The mask bitmap thus allows a cursor to assume any shape. The hot spot defines the position within the cursor image that is displayed at the pointer position. In CLX, a cursor is represented by a @var{cursor} object. This section describes the CLX functions to: @itemize @bullet @item Create and free cursor objects @item Change cursor colors @item Inquire the best cursor size @item Access cursor attributes @end itemize @menu * Creating Cursors:: * Cursor Functions:: * Cursor Attributes:: @end menu @node Creating Cursors, Cursor Functions, Cursors, Cursors @section Creating Cursors The following paragraphs describe the CLX functions used to create and free @var{cursor} objects. @defun create-cursor &key :source :mask :x :y :foreground :background @table @var @item :source The source pixmap. This argument is required. @item :mask The mask pixmap. @item :x @itemx :y The hot spot position in the @var{:source}. This argument is required. @item :foreground A @var{color} object specifying the foreground color. This argument is required. @item :background A @var{color} object specifying the background color. This argument is required. @end table Creates and returns a cursor. @var{:x} and @var{:y} define the position of the hot spot relative to the origin of the @var{:source. :foreground} and @var{:background} colors must be specified, even if the server only has a @var{:static-gray} or @var{:gray-scale} screen. The @var{:source}, @var{:x}, and @var{:y} arguments must also be specified. The cursor image is drawn by drawing a pixel from the @var{:source} bitmap at every position where the corresponding bit in the @var{:mask} bitmap is 1. If the corresponding @var{:source} bit is 1, a pixel is drawn in the @var{:foreground} color; otherwise, a pixel is drawn in the @var{:back-ground} color. If the @var{:mask} is omitted, all @var{:source} pixels are drawn. If given, the @var{:mask} must be the same size as the @var{:source}. An X server may not be able to support every cursor size. A server is free to modify any component of the cursor to satisfy hardware or software limitations. The @var{:source} and @var{:mask} can be freed immediately after the cursor is created. Subsequent drawing in the @var{:source} or @var{:mask} pixmap has an undefined effect on the cursor. @table @var @item cursor Type @var{cursor}. @end table @end defun @defun create-glyph-cursor &key :source-font :source-char :mask-font (:mask-char 0) :foreground :background @table @var @item :source-font The source font. This is a required argument. @item :source-char An index specifying a glyph in the source font. This is a required argument. @item :mask-font The mask font. @item :mask-char An index specifying a glyph in the mask font. @item :foreground A @var{color} object specifying the foreground color. This is a required argument. @item :background A @var{color} object specifying the background color. This is a required argument. @end table Creates and returns a cursor defined by font glyphs. The source bitmap is defined by the @var{:source-font} and @var{:source-char}. The mask bitmap is defined by the @var{:mask-font} and @var{:mask-char}. It is an error if the @var{:source-char} and @var{:mask-char} are not valid indexes for the @var{:source-font} and @var{:mask-font}, respectively. The hot spot position is defined by the "character origin" of the source glyph, that is, the position [- @emph{char-left-bearing}, @emph{char-ascent}] relative to the upper left corner of the source glyph bitmap. Source and mask bits are compared after aligning the character origins of the source and mask glyphs. The source and mask glyphs need not have the same size or character origin position. If the @var{:mask-font} is omitted, all source pixels are drawn. An X server may not be able to support every cursor size. A server is free to modify any component of the cursor to satisfy hardware or software limitations. Either of the @var{:source-font} or @var{:mask-font} can be closed after the cursor is created. @table @var @item cursor Type @var{cursor}. @end table @end defun @defun free-cursor cursor @table @var @item cursor A @var{cursor} object. @end table Destroys the @var{cursor} object. Cursor server resources are freed when no other references remain. @end defun @node Cursor Functions, Cursor Attributes, Creating Cursors, Cursors @section Cursor Functions The following paragraphs describe the CLX functions used to operate on @var{cursor} objects. @defun query-best-cursor width height display @table @var @item display A @var{display} object. @item width @itemx height The requested cursor size. @end table Returns the cursor size closest to the requested @emph{width} and @emph{height} that is best suited to the display. The @emph{width} and @emph{height} returned define the largest cursor size supported by the X server. Clients should always be prepared to limit cursor sizes to those supported by the server. @table @var @item width @itemx height Type @var{card16}. @end table @end defun @defun recolor-cursor cursor foreground background @table @var @item cursor A @var{cursor} object. @item foreground A @var{color} object specifying the new foreground color. @item background A @var{color} object specifying the new background color. @end table Changes the color of the specified @emph{cursor}. If the cursor is displayed on a screen, the change is visible immediately. @end defun @node Cursor Attributes, , Cursor Functions, Cursors @section Cursor Attributes The complete set of cursor attributes is discussed in the following paragraphs. @defun cursor-display cursor @table @var @item cursor A @var{cursor} object. @end table Returns the @var{display} object associated with the specified @emph{cursor}. @table @var @item display Type @var{display}. @end table @end defun @defun cursor-equal cursor-1 cursor-2 @table @var @item cursor-1 @itemx cursor-2 @var{cursor} objects. @end table Returns true if the two arguments refer to the same server resource and @var{nil} if they do not. @end defun @defun cursor-id cursor @table @var @item cursor A @var{cursor} object. @end table Returns the unique resource ID that has been assigned to the specified @emph{cursor}. @table @var @item id Type @var{resource-id.} @end table @end defun @defun cursor-p cursor @table @var @item cursor-p Type @var{boolean}. @end table Returns true if the argument is a @var{cursor} object and @var{nil} otherwise. @end defun @defun cursor-plist cursor @table @var @item cursor A @var{cursor} object. @end table Returns and (with @code{setf}) sets the property list for the specified @emph{cursor}. This function provides a hook where extensions can add data. @table @var @item plist A property list. @end table @end defun @node Atoms, Events and Input, Cursors, Top @chapter Atoms, Properties and Selections @menu * Atoms (Atoms):: * Properties:: * Selections:: @end menu @node Atoms (Atoms), Properties, Atoms, Atoms @section Atoms In X, an @emph{atom} is a unique ID used as the name for certain server resources -- properties and selections. In CLX, an atom is represented by a keyword symbol. For convenience, CLX functions also allow atoms to be specified by strings and non-keyword symbols. @var{xatom} is a CLX data type that permits either string or symbol values. A string is equivalent to the @var{xatom} given by (@var{intern} @emph{string} @var{'keyword}). A symbol is equivalent to the @var{xatom} given by ( @var{intern} (@var{symbol-name} @emph{symbol}) @var{'keyword}). The symbol name string of an @var{xatom} must consist only of ISO Latin characters. Note that the case of @var{xatom} strings is important; the @var{xatom} "Atom" is not the same as the @var{xatom} "ATOM". Certain atoms are already predefined by every X server. Predefined atoms are designed to represent common names that are likely to be useful for many client applications. Note that these atoms are predefined only in the sense of having @var{xatom} and @var{card29} values, not in the sense of having required semantics. No interpretation is placed on the meaning or use of an atom by the server. The @var{xatom} objects predefined by CLX are listed below. @multitable @columnfractions 0.3 0.3 0.3 @item @var{:arc} @tab @var{:italic_angle} @tab @var{:string} @item @var{:atom} @tab @var{:max_space} @tab @var{:subscript_x} @item @var{:bitmap} @tab @var{:min_space} @tab @var{:subscript_y} @item @var{:cap_height} @tab @var{:norm_space} @tab @var{:superscript_x} @item @var{:cardinal} @tab @var{:notice} @tab @var{:superscript_y} @item @var{:colormap} @tab @var{:pixmap} @tab @var{:underline_position} @item @var{:copyright} @tab @var{:point} @tab @var{:underline_thickness} @item @var{:cursor} @tab @var{:point_size} @tab @var{:visualid} @item @var{:cut_buffer0} @tab @var{:primary} @tab @var{:weight} @item @var{:cut_buffer1} @tab @var{:quad_width} @tab @var{:window} @item @var{:cut_buffer2} @tab @var{:rectangle} @tab @var{:wm_class} @item @var{:cut_buffer3} @tab @var{:resolution} @tab @var{:wm_client_machine} @item @var{:cut_buffer4} @tab @var{:resource_manager} @tab @var{:wm_command} @item @var{:cut_buffer5} @tab @var{:rgb_best_map} @tab @var{:wm_hints} @item @var{:cut_buffer6} @tab @var{:rgb_blue_map} @tab @var{:wm_icon_name} @item @var{:cut_buffer7} @tab @var{:rgb_color_map}@tab @var{:wm_icon_size} @item @var{:drawable} @tab @var{:rgb_default_map} @tab @var{:wm_name} @item @var{:end_space} @tab @var{:rgb_gray_map} @tab @var{:wm_normal_hints} @item @var{:family_name} @tab @var{:rgb_green_map}@tab @var{:wm_size_hints} @item @var{:font} @tab @var{:rgb_red_map} @tab @var{:wm_transient_for} @item @var{:font_name} @tab @var{:secondary} @tab @var{:wm_zoom_hints} @item @var{:full_name} @tab @var{:strikeout_ascent} @tab @var{:x_height} @item @var{:integer} @tab @var{:strikeout_descent} @tab @end multitable When creating a new atom, the following conventions should be obeyed in order to minimize the conflict between atom names: @itemize @bullet @item Symbol names beginning with an underscore should be used for atoms that are private to a particular vendor or organization. An additional prefix should identify the organization. @item Symbol names beginning with two underscores should be used for atoms that are private to a single application or end user. @end itemize CLX provides functions to convert between an @var{xatom} and its corresponding ID integer. The data type of an atom ID is @var{card29}. The @var{xatom} representation is usually sufficient for most CLX programs. However, it is occasionally useful to be able to convert an atom ID returned in events or properties into its corresponding @var{xatom}. @defun atom-name display atom-id @table @var @item display A @var{display} object. @item atom-id A @var{card29}. @end table Returns the atom keyword for the @emph{atom-id} on the given @emph{display} server. @table @var @item atom-name Type @var{keyword}. @end table @end defun @defun find-atom display atom-name @table @var @item display A @var{display} object. @item atom-name An @var{xatom}. @end table Returns the atom ID for the given @emph{atom-name}, if it exists. If no atom of that name exists for the display server, @var{nil} is returned. @table @var @item atom-id Type @var{card29} or @var{null}. @end table @end defun @defun intern-atom display atom-name @table @var @item display A @var{display} object. @item atom-name An @var{xatom}. @end table Creates an atom with the given name and returns its atom ID. The atom can survive the interning client; it exists until the last server connection has been closed and the server resets itself. @table @var @item atom-id Type @var{card29} or @var{null}. @end table @end defun @node Properties, Selections, Atoms (Atoms), Atoms @section Properties For each window, an X server can record a set of @emph{properties}. Properties are a general mechanism for clients to associate arbitrary data with a window, and for clients to communicate window data to each other via the server. No interpretation is placed on property data by the server itself. A property consists of a name, a type, a data format, and data. The name of a property is given by an atom. The property type is another atom used to denote the intended interpretation of the property data. The property formats specifies whether the property data should be treated as a set of 8-, 16-, or 32-bit elements. The property format must be specified so that the X server can communicate property data with the correct byte order. CLX provides functions to: @itemize @bullet @item Create or change a property @item Return property data @item List window properties @item Delete a property @end itemize @defun change-property window property data type format &key (:mode :replace) (:start 0) :end :transform @table @var @item window A @var{window}. @item property A property name @var{xatom}. @item data A sequence of property data elements. @item type The property type @var{xatom}. @item format One of 8, 16, or 32. @item :mode One of @var{:replace}, @var{:append}, or @var{:prepend}. @item :start @itemx :end Specify the subsequence of previous data replaced when @var{:mode} is @var{:replace}. @item :transform A function that transforms each data element into a data value to store. @end table Creates a new window property or changes an existing property. A @var{:property-notify} event is generated for the @emph{window}. If the @var{:mode} is @var{:replace}, the new @emph{data}, @emph{type}, and @emph{format} replace any previous values. The subsequence of previous data elements that are replaced is defined by the @var{:start} and @var{:end} indexes. If the @var{:mode} is @var{:prepend} or @var{:append}, no previous data is changed, but the new @emph{data} is added at the beginning or the end, respectively. For these modes, if the @emph{property} already exists, the new @emph{type} and @emph{format} must match the previous values. The @var{:transform}, if given, is a function used to compute the actual property data stored. The @var{:transform}, which must accept a single data element and return a single transformed data element, is called for each data element. If the @emph{data} is a string, the default @var{:transform} function transforms each character into its ASCII code; otherwise, the default is to store the @emph{data} unchanged. @end defun @defun delete-property window property @table @var @item window A @var{window}. @item property A property name @var{xatom}. @end table Deletes the @emph{window property}. If the @emph{property} already exists, a @var{:property-notify} event is generated for the @emph{window}. @end defun @defun get-property window property &key :type (:start 0) :end :delete-p (:result-type 'list) :transform @anchor{get-property} @table @var @item window A @var{window}. @item property A property name @var{xatom}. @item :type The requested type @var{xatom} or @var{nil}. @item :start @itemx :end Specify the subsequence of property @emph{data} returned. @item :transform A function that transforms each data element into a data value to return. @item :delete-p If true, the existing @emph{property} can be deleted. @item :result-type The t@emph{ype} of data sequence to return. Default is @var{'list}. @end table Returns a subsequence of the data for the window property. The @var{:start} and @var{:end} indexes specify the property @emph{data} elements returned. The @var{:transform} function is called for elements of the specified subsequence to compute the @emph{data} sequence returned. The property @emph{type} and @emph{format} are also returned. The final return value gives the actual number of data bytes (not elements) following the last data element returned. If the @emph{property} does not exist, the returned @emph{data} and @emph{type} are @var{nil} and the returned @emph{format} and @emph{bytes-after} are zero. If the given @var{:type} is non-@var{nil} but does not match the actual property type, then the @emph{data} returned is @var{nil}, the @emph{type} and @emph{format} returned give the actual property values, and the @emph{bytes-after} returned gives the total number of bytes (not elements) in the property data. If the given @var{:type} is @var{nil} or if it matches the actual property type, then: @itemize @bullet @item The @emph{data} returned is the transformed subsequence of the property data. @item The @emph{type} and @emph{format} returned give the actual property values. @item The @emph{bytes-after} returned gives the actual number of data bytes (not elements) following the last data element returned. @end itemize In this case, the @var{:delete-p} argument is also examined. If @var{:delete-p} is true and @emph{bytes-after} is zero, the property is deleted and a @var{:property-notify} event is generated for the @emph{window}. @table @var @item data Type @var{sequence}. @item type Type @var{xatom}. @item format Type (@var{member 8 16 32}). @item bytes-after Type @var{card32}. @end table @end defun @defun list-properties window &key (:result-type 'list) @table @var @item window A @var{window}. @item :result-type The type of sequence to return. Default is @var{'list}. @end table Returns a sequence containing the names of all @emph{window properties}. @table @var @item properties Type @var{sequence} of @var{keyword}. @end table @end defun @defun rotate-properties window properties &optional (delta 1) @table @var @item window A @var{window}. @item properties A sequence of @var{xatom} values. @item delta The index interval between source and destination elements of @emph{properties}. @end table Rotates the values of the given @emph{window properties}. The value of property @emph{i} in the given sequence is changed to the value of the property at index (@var{mod} (+ @emph{i delta}) (@var{length} @emph{properties})). This function operates much like the @var{rotatef} macro in Common Lisp. If (@var{mod} @emph{delta} (@var{length} @emph{properties})) is non-zero, a @var{:property-notify} event is generated on the window for each property, in the same order as they appear in the @emph{properties} sequence. @end defun @node Selections, , Properties, Atoms @section Selections A selection is an atom used to identify data that can be shared among all client programs connected to an X server. Unlike properties, the data represented by a selection is stored by some client program, not by the server. The data named by a selection is associated with a client window, which is referred to as the @emph{selection owner}. The server always knows which window is the owner of a selection. Selections can be created freely by clients using @var{intern-atom} to create an atom. CLX provides functions to inquire or change the owner of a selection and to @emph{convert} a selection. Conversion is the key to the use of selections for inter-client communication. Suppose Client A wants to paste the contents of the data named by selection @emph{S} into his window @emph{WA}. Client A calls @var{convert-selection} on selection atom @emph{S}, sending a conversion request to the server. The server, in turn, sends a @var{:selection-request} event to the current owner of @emph{S}, which is window @emph{WB} belonging to Client B. The @var{:selection-request} event contains the @emph{requestor} window (@emph{WA}), the selection atom (@emph{S}), an atom identifying a requested data type, and the name of a property of @emph{WA} into which the value of @emph{S} will be stored. Since @emph{WB} is the owner of @emph{S}, it must be associated with the data defined by Client B as the value of @emph{S}. When @emph{WB} gets the @var{:selection-request} event, Client B is expected to convert the value of @emph{S} to the requested data type (if possible) and store the converted value in the given requestor property. Client B is then expected to send a @var{:selection-notify} event to the requestor window @emph{WA}, informing the requestor that the converted value for @emph{S} is ready. Upon receiving the @var{:selection-notify} event, Client A can call @var{get-property} to retrieve the converted value and to paste it into @emph{WA}. @var{NOTE:} Clients using selections must always be prepared to handle @var{:selection-request} events and/or @var{:selection-notify} events. There is no way for a client to ask not to receive these types of events. Type atoms used in selection conversion can represent arbitrary client-defined interpretations of the selection data. For example, if the value of selection @emph{S} is a text string, Client A might request its typeface by requesting conversion to the @var{:font} type. A type @var{atom} can also represent a request to the selection owner to perform some action as a side-effect of conversion (for example, @var{:delete}). Some of the predefined atoms of an X server are intended to be used as selection types (for example, @var{:colormap}, @var{:bitmap}, @var{:string}, and so forth) However, X does not impose any requirements on the interpretation of type atoms. When multiple clients negotiate for ownership of a selection, certain race conditions might be possible. For example, two clients might each receive a user command to assert ownership of the @var{:primary} selection, but the order in which the server processes these client requests is unpredictable. As a result, the ownership request initiated most recently by the user might be incorrectly overridden by the other earlier ownership request. To prevent such anomalies, the server records a @emph{last-changed} timestamp for each change of selection ownership. Although inter-client communication via selections is rather complex, it offers important benefits. Since selection communication is mediated by an X server, clients can share data even though they are running on different hosts and using different networking protocols. Data storage and conversion is distributed among clients so that the server is not required to provide all possible data types or to store multiple forms of selection data. Certain predefined atoms are used as standard selections, as described in the X11 Inter-client Communications Conventions Manual. Some of the standard selections covered by these conventions are: @table @var @item :primary The @emph{primary selection}. The main vehicle for inter-client cut and paste operations. @item :secondary The @emph{secondary selection}. In some environments, clients can use this as an auxiliary to @var{:primary}. @item :clipboard Analogous to akill ring. Represents the most recently deleted data item. @end table @defun convert-selection selection type requestor &optional property time @table @var @item selection The @var{xatom} for the selection name. @item type The @var{xatom} for the requested data type. @item requestor The @var{window} to receive the converted @emph{selection} value. @item property The @var{xatom} for the requestor property to receive the converted value. @item time A @var{timestamp}. @end table Requests that the value of the @emph{selection} be converted to the specified @emph{type} and stored in the given @emph{property} of the @emph{requestor} window. If the @emph{selection} has an owner, the X server sends a @var{:selection-request} event to the owner window. Otherwise, if no owner exists, the server generates on the requestor a @var{:selection-notify} event containing a @var{nil} @emph{property} atom. The given @emph{property} specifies the requestor property that will receive the converted value. If the @emph{property} is omitted, the @emph{selection} owner will define a property to use. The @emph{time} furnishes a timestamp representing the time of the conversion request; by default, the current server time is used. @var{NOTE:} Standard conventions for inter-client communication require that both the requestor property and the time must be specified. If possible, the time should be the time of a user event which initiated the conversion. Alternatively, a timestamp can be obtained by calling @var{change-property} to append zero-length data to some property; the timestamp in the resulting @var{:property-notify} event can then be used. @end defun @defun selection-owner display selection &optional time @table @var @item display A @var{display}. @item selection The @var{xatom} for the selection name. @item time A @var{timestamp}. @end table Returns and (with @code{setf}) changes the owner and the last-changed @emph{time} for the @emph{selection}. If the owner is @var{nil}, no owner for the @emph{selection} exists. When the owner window for a @emph{selection} is destroyed, the @emph{selection} owner is set to @var{nil} without affecting the last-changed @emph{time}. The @emph{time} argument is used only when changing the @emph{selection} owner. If the @emph{time} is @var{nil}, the current server time is used. If the @emph{time} is earlier than the current last-changed time of the @emph{selection} or if the @emph{time} is later than the current server time, the owner is not changed. Therefore, a client should always confirm successful change of ownership by immediately calling @var{selection-owner}. If the change in ownership is successful, the last-changed time of the @emph{selection} is set to the specified @emph{time}. If the change in ownership is successful and the new owner is different from the previous owner, and if the previous owner is not @var{nil}, a @var{:selection-clear} event is generated for the previous owner window. @var{NOTE:} Standard conventions for inter-client communication require that a non-nil time must be specified. If possible, the time should be the time of a user event which initiated the change of ownership. Alternatively, a timestamp can be obtained by calling change-property to append zero-length data to some property; the timestamp in the resulting @var{:property-notify} event can then be used. @table @var @item owner Type @var{window} or @var{null}. @end table @end defun @node Events and Input, Resources, Atoms, Top @chapter Events and Input A client application uses CLX functions to send @emph{requests} to an X server over a display connection returned by the @var{open-display} function. In return, the X server sends back @emph{replies} and @emph{events}. Replies are synchronized with specific requests and return requested server information. Events typically occur asynchronously. Device events are generated by user input from both the keyboard and pointer devices. Other events are side-effects of the requests sent by CLX functions. The types of events returned by an X server are summarized below. Device Events @table @asis @item Keyboard @var{:key-press} @var{:key-release} @item Pointer @var{:button-press} @var{:button-release} @var{:enter-notify} @var{:leave-notify} @var{:motion-notify} @end table Side-Effect Events @table @asis @item Client communication @var{:client-message} @var{:property-notify} @var{:selection-clear} @var{:selection-notify} @var{:selection-request} @item Color map state @var{:colormap-notify} @item Exposure @var{:exposure} @var{:graphics-exposure} @var{:no-exposure} @item Input focus @var{:focus-in} @var{:focus-out} @item Keyboard and pointer state @var{:keymap-notify} @var{:mapping-notify} @item Structure control @var{:circulate-request} @var{:configure-request} @var{:map-request} @item Window state @var{:resize-request} @var{:circulate-notify} @var{:configure-notify} @var{:create-notify} @var{:destroy-notify} @var{:gravity-notify} @var{:map-notify} @var{:reparent-notify} @var{:unmap-notify} @var{:visibility-notify} @end table Client programs can override the server's normal distribution of events by@emph{ grabbing} the pointer or the keyboard. Grabbing causes events from the pointer or keyboard device to be reported to a single specified window, rather than to their ordinary destinations. It can also cause the server to @emph{freeze} the grabbed device, sending queued events only when explicitly requested by the grabbing client. Two kinds of grabs are possible: @itemize @bullet @item Active -- Events are immediately grabbed. @item Passive -- Events are grabbed later, as soon as a specified device event occurs. @end itemize Grabbing an input device is performed rarely and usually only by special clients, such as window managers. This section describes the CLX functions used to: @itemize @bullet @item Select events (@pxref{Selecting Events}) @item Process an event on the event queue (@pxref{Processing Events}) @item Manage the event queue (@pxref{Managing the Event Queue}) @item Send events to other applications (@pxref{Sending Events}) @item Read and change the pointer position (@pxref{Pointer Position}) @item Manage the keyboard input focus (@pxref{Managing Input Focus}) @item Grab pointer and keyboard events (@pxref{Grabbing the Pointer}) @item Release queued events (@pxref{Releasing Queued Events}) @end itemize This section also contains a detailed description of the content of each type of event. @menu * Selecting Events:: * Processing Events:: * Managing the Event Queue:: * Sending Events:: * Pointer Position:: * Managing Input Focus:: * Grabbing the Pointer:: * Grabbing a Button:: * Grabbing the Keyboard:: * Grabbing a Key:: * Event Types:: * Releasing Queued Events:: @end menu @node Selecting Events, Processing Events, Events and Input, Events and Input @section Selecting Events A client @emph{selects} which types of events it receives from a specific window. The window event-mask attribute, set by the client, determines which event types are selected (see @var{window-event-mask} in @ref{Window Attributes}). Most types of events are received by a client only if they are selected for some window. In the X protocol, an event-mask is represented as a bit string. CLX also allows an event mask to be defined by a list of @var{event-mask-class} keywords. The functions @var{make-event-keys} and @var{make-event-mask} can be used to convert between these two forms of an event-mask. In general, including an @var{event-mask-class} keyword in an event-mask causes one or more related event types to be selected. The following table describes the event types selected by each @var{event-mask-class} keyword. @multitable @columnfractions 0.5 0.5 @item Event Mask Keyword @tab Event Types Selected @item @var{:button-1-motion} @tab @var{:motion-notify} when @var{:button-1} is down @item @var{:button-2-motion} @tab @var{:motion-notify} when @var{:button-2} is down @item @var{:button-3-motion} @tab @var{:motion-notify} when @var{:button-3} is down @item @var{:button-4-motion} @tab @var{:motion-notify} when @var{:button-4} is down @item @var{:button-5-motion} @tab @var{:motion-notify} when @var{:button-5} is down @item @var{:button-motion} @tab @var{:motion-notify} when any pointer button is down @item @var{:button-press} @tab @var{:button-press} @item @var{:button-release} @tab @var{:button-release} @item @var{:colormap-change} @tab @var{:colormap-notify} @item @var{:enter-window} @tab @var{:enter-notify} @item @var{:exposure} @tab @var{:exposure} @item @var{:focus-change} @tab @var{:focus-in} @var{:focus-out} @item @var{:key-press} @tab @var{:key-press} @item @var{:key-release} @tab @var{:key-release} @item @var{:keymap-state} @tab @var{:keymap-notify} @item @var{:leave-window} @tab @var{:leave-notify} @item @var{:owner-grab-button} @tab Pointer events while button is grabbed @item @var{:pointer-motion} @tab @var{:motion-notify} @item @var{:pointer-motion-hint} @tab Single @var{:motion-notify} only @item @var{:property-change} @tab @var{:property-notify} @item @var{:resize-redirect} @tab @var{:resize-request} @item @var{:structure-notify} @tab @var{:circulate-notify} @var{:configure-notify} @var{:destroy-notify} @var{:gravity-notify} @var{:map-notify} @var{:reparent-notify} @var{:unmap-notify} @item @var{:substructure-redirect} @tab @var{:circulate-request} @var{:configure-request} @var{:map-request} @item @var{:visibility-change} @tab @var{:visibility-notify} @end multitable Some types of events do not have to be selected to be received and therefore are not represented in an event-mask. For example, the @var{copy-plane} and @var{copy-area} functions cause @var{:graphics-exposure} and @var{:no-exposure} events to be reported, unless exposures are turned @var{:off} in the graphics context (see @var{copy-area} and @var{copy-plane} in @ref{Area and Plane Operations}, and @var{gcontext-exposures} in paragraph 5.4.6, Exposures). Also, @var{:selection-clear}, @var{:selection-request}, @var{:selection-notify} and @var{:client-message} events can be received at any time, but they are generally sent only to clients using selections (@pxref{Client Communications Events}). @var{:mapping-notify} is always sent to clients when the keyboard mapping is changed. Any client can select events for any window. A window maintains a separate event-mask for each interested client. In general, multiple clients can select for the same events on a window. After the X server generates an event, it sends it to all clients which selected it. However, the following restrictions apply to sharing window events among multiple clients. For a given window: @itemize @bullet @item Only one client at a time can include @var{:substructure-redirect} in its event-mask @item Only one client at a time can can include @var{:button-press} in its event-mask @item Only one client at a time can include @var{:resize-redirect} in its event-mask @end itemize @node Processing Events, Managing the Event Queue, Selecting Events, Events and Input @section Processing Events Events received by a CLX client are stored in an @emph{event queue} until they are read and processed. Events are processed by @emph{handler functions}. @defun handler-function &rest event-slots &key :display :event-key :send-event-p &allow-other-keys @table @var @item :display A @var{display} for the connection that returned the event. @item :event-key An @var{event-key} keyword specifying the event type. @item :send-event-p If true, the event was sent from another application using the @var{send-event} function. @end table The arguments to a handler function are keyword-value pairs that describe the contents of an event. The actual @emph{event-slots} passed depend on the event type, except that @var{:display}, @var{:event-key}, and @var{:send-event-p} are given for all event types. The keyword symbols used for each event type are event slot names defined by the @var{declare-event} macro and are described in @ref{Declaring Event Types}. If a handler returns non-@var{nil}, the event is considered @emph{processed} and can be removed from the event queue. Otherwise, if a handler function returns @var{nil}, the event can remain in the event queue for later processing. @table @var @item handled-p Type @var{boolean}. @end table @end defun @defun process-event display &key :handler :timeout :peek-p :discard-p (:force-output-p t) @table @var @item display A @var{display}. @item :handler A handler function or a sequence of handler functions. @item :timeout Specifies the timeout delay in seconds. @item :peek-p If @var{nil}, events are removed from the event queue after processing. @item :discard-p If true, unprocessed events are discarded. @item :force-output-p If true, buffered output requests are sent. @end table Invokes @var{:handler} on each queued event until @var{:handler} returns non-@var{nil}. Then, the non-@var{nil :handler} value is returned by @var{process-event}. If @var{:handler} returns @var{nil} for each event in the event queue, @var{process-event} waits for another event to arrive. If timeout is non-@var{nil} and no event arrives within the specified timeout interval (given in seconds), @var{process-event} returns @var{nil}; if timeout is @var{nil}, @var{process-event} will not return until @var{:handler} returns non-@var{nil}. @var{process-event} may wait only once on network data, and therefore timeout prematurely. If @var{:force-output-p} is true, @var{process-event} first invokes @var{display-force-output} to send any buffered requests. If @var{:peek-p} is true, a processed event is not removed from the queue. If @var{:discard-p} is true, unprocessed events are removed from the queue; otherwise, unprocessed events are left in place. If @var{:handler} is a sequence, it is expected to contain handler functions for each event type. The sequence index of the handler function for a particular event type is given by ( @var{position event-key *event-key-vector*}). @table @var @item handled-p Type @var{boolean}. @end table @end defun @defmac event-case display &key :timeout :peek-p :discard-p (:force-output-p t) &body clauses @anchor{event-case} @table @var @item display A @var{display}. @item :handler A handler function or a sequence of handler functions. @item :timeout Specifies the timeout delay, in seconds. @item :peek-p If @var{nil}, events are removed from the event queue after processing. @item :discard-p If true, unprocessed events are discarded. @item :force-output-p If true, buffered output requests are sent. @item clauses Code to process specified event types. @end table Executes the matching clause for each queued event until a clause returns non-@var{nil}. The non-@var{nil} clause value is then returned. Each of the clauses is a list of the form (@emph{event-match} [@emph{event-slots}] &rest @emph{forms}), where: @itemize @bullet @item @emph{event-match} -- Either an @var{event-key}, a list of @var{event-keys}, otherwise, or @var{t}. It is an error for the same key to appear in more than one clause. @item @emph{event-slots} -- If given, a list of (non-keyword) event slot symbols defined for the specified event type(s). @xref{Declaring Event Types}. @item @emph{forms} -- A list of forms that process the specified event type(s). The value of the last form is the value returned by the clause. @end itemize A clause matches an event if the @var{event-key} is equal to or a member of the @emph{event-match}, or if the @emph{event-match} is @var{t} or @var{otherwise}. If no @var{t} or @var{otherwise} clause appears, it is equivalent to having a final clause that returns @var{nil}. If @emph{event-slots} is given, these symbols are bound to the value of the corresponding event slot in the clause forms. Each element of @emph{event-slots} can also be a list of the form (@emph{event-slot-keyword variable}), in which case the @emph{variable} symbol is bound to the value of the event slot specified by the @emph{event-slot-keyword}. If every clause returns @var{nil} for each event in the event queue, @var{event-case} waits for another event to arrive. If @var{:timeout} is non-@var{nil} and no event arrives within the specified timeout interval (given in seconds), @var{event-case} returns @var{nil}; if @var{:timeout} is @var{nil}, @var{event-case} will not return until a clause returns non-@var{nil}. @var{event-case} may wait only once on network data and therefore timeout prematurely. If @var{:force-output-p} is true, @var{event-case} first invokes @var{display-force-output} to send any buffered requests. If @var{:peek-p} is true, a processed event is not removed from the queue. If @var{:discard-p} is true, unprocessed events are removed from the queue; otherwise, unprocessed events are left in place. @table @var @item handled-p Type @var{boolean}. @end table @end defmac @defmac event-cond display &key :timeout :peek-p :discard-p (:force-output-p t) &body clauses @table @var @item handled-p Type @var{boolean}. @end table Similar to @var{event-case} except that each of the clauses is a list of the form (@emph{event-match} [@emph{event-slots}] @emph{test-form} &rest @emph{forms}). Executes the @emph{test-form} of the clause that matches each queued event until a @emph{test-form} returns non-@var{nil}. The body @emph{forms} of the clause are then executed. The values returned by the last clause body form are then returned by @var{event-cond}. When a @emph{test-form} returns true and @var{:peek-p} is @var{nil}, or when a @emph{test-form} returns @var{nil} and @var{:discard-p} is true, the matching event is removed from the event queue before the body @emph{forms} are executed. @table @var @item display A @var{display}. @item :handler A handler function or a sequence of handler functions. @item :timeout Specifies the timeout delay in seconds. @item :peek-p If @var{nil}, events are removed from the event queue after processing. @item :discard-p If true, unprocessed events are discarded. @item :force-output-p If true, buffered output requests are sent. @item clauses Code to process specified event types. @end table @end defmac @node Managing the Event Queue, Sending Events, Processing Events, Events and Input @section Managing the Event Queue The following paragraphs describe CLX functions and macros used to: @itemize @bullet @item Put a new event on the event queue @item Discard the current event @item Return the current length of the event queue @item Gain exclusive access to the event queue for a client process @end itemize @defun queue-event display event-key &rest event-slots &key :append-p &allow-other-keys @table @var @item display A @var{display}. @item event-key Specifies the type of event placed in the queue. @item event-slots Keyword-value pairs that describe the contents of an event. @item :append-p If true, the event is placed at the tail of the queue; otherwise, the event is placed at the head of the queue. @end table Places an event of the type given by @emph{event-key} into the event queue. When @var{:append-p} is true, the event is placed at the tail of the queue; otherwise, the event is placed at the head of the queue. The actual @emph{event-slots} passed depend on the event type. The keyword symbols used for each event type are event slot names defined by the @var{declare-event} macro and are described in @ref{Declaring Event Types}. @end defun @defun discard-current-event display @table @var @item display A @var{display}. @end table Discards the current event for the @emph{display}. Returns @var{nil} when the event queue is empty; otherwise, returns @var{t}. This function provides extra flexibility for discarding events, but it should be used carefully; use @var{event-cond} instead, if possible. Typically, @var{discard-current-event} is called inside a handler function or a clause of an @var{event-case} form and is followed by another call to @var{process-event}, @var{event-case}, or @var{event-cond}. @table @var @item discarded-p Type @var{boolean}. @end table @end defun @defun event-listen display &optional (timeout 0) @table @var @item display A @var{display}. @item timeout The number of seconds to wait for events. @end table Returns the number of events queued locally. If the event queue is empty, @var{event-listen} waits for an event to arrive. If timeout is non-@var{nil} and no event arrives within the specified timeout interval (given in seconds), @var{event-listen} returns @var{nil}; if timeout is @var{nil}, @var{event-listen} will not return until an event arrives. @table @var @item event-count Type @code{(or null integer)}. @end table @end defun @defmac with-event-queue display &body body @anchor{with-event-queue} @table @var @item display A @var{display}. @item body Forms to execute. @end table Executes the @emph{body} in a critical region in which the executing client process has exclusive access to the event queue. @end defmac @node Sending Events, Pointer Position, Managing the Event Queue, Events and Input @section Sending Events A client can send an event to a window. Clients selecting this window event will receive it just like any other event sent by the X server. @defun send-event window event-key event-mask &rest event-slots &key :propagate-p :display &allow-other-keys @table @var @item window The destination @var{window} for the event. @item event-key An @var{event-key} defining the type of event to send. @item event-mask Specifies the event types that receiving clients must select. @item event-slots Keyword-value pairs that describe the contents of an event. @item :propagate-p If true, the event can be propagated to ancestors of the destination window. @item :display A @var{display}. @end table Sends an event specified by the @emph{event-key} and @emph{event-slots} to the given destination @emph{window}. Any active grabs are ignored. The @emph{event-slots} passed depend on the event type. The keyword symbols used for each event type are event slot names defined by the @var{declare-event} macro and are described in @ref{Declaring Event Types}. If the @emph{window} is @var{:pointer-window}, the destination @emph{window} is replaced with the window containing the pointer. If the @emph{window} is @var{:input-focus}, the destination @emph{window} is replaced with the descendant of the focus window that contains the pointer or (if no such descendant exists) the focus window. The @var{:display} keyword is only required if the @emph{window} is @var{:pointer-window} or @var{:input-focus}. The @emph{event-key} must be one of the core events, or one of the events defined by an extension, so the server can send the event with the correct byte-order. The contents of the event are otherwise unaltered and unchecked by the server, except that the @var{send-event-p} event slot is set to true. If the @emph{event-mask} is @var{nil}, the event is sent to the client that created the destination @emph{window} with an @emph{event-mask} of 0; if that client no longer exists, no event is sent. Otherwise, the event is sent to every client selecting any of the event types specified by @emph{event-mask} on the destination @emph{window}. If @var{:propagate-p} is true and no clients have selected any of the event types in @emph{event-mask} on the destination @emph{window}, the destination is replaced with the closest ancestor of @emph{window} for which some client has selected a type in @emph{event-mask} and no intervening window has that type in its do-not-propagate mask. If no such window exists, or if the @emph{window} is an ancestor of the focus window and @var{:input-focus} was originally specified as the destination, the event is not sent to any clients. Otherwise, the event is reported to every client selecting on the final destination any of the types specified in @emph{event-mask}. @end defun @node Pointer Position, Managing Input Focus, Sending Events, Events and Input @section Pointer Position The CLX functions affecting pointer position are discussed in the following paragraphs. @defun query-pointer window @table @var @item window A @var{window} specifying the coordinate system for the returned position. @end table Returns the current pointer coordinates relative to the given @emph{window}. If @var{query-pointer} returns @var{nil} for @emph{same-screen-p}, the pointer is not on the same screen as the @emph{window}. In this case, @var{query-pointer} returns a value of @var{nil} for @emph{child} and a value of zero for @emph{x} and @emph{y}. If @var{query-pointer} returns true for @emph{same-screen-p}, the returned @emph{x} and @emph{y} are relative to the origin of window. The @emph{child} is the child of the window containing the pointer, if any. The @emph{state-mask} returned gives the current state of the modifier keys and pointer buttons. The returned @emph{root} is the root window currently containing the pointer. The returned @emph{root-x} and @emph{root-y} specify the pointer coordinates relative to @emph{root}. @table @var @item x Type @var{int16}. @item y Type @var{int16}. @item same-screen-p Type @var{boolean}. @item child Type @var{window} or @var{null}. @item state-mask Type @var{card16}. @item root-x Type @var{int16}. @item root-y Type @var{int16}. @item root Type @var{window}. @end table @end defun @defun global-pointer-position display @table @var @item display A @var{display}. @end table Returns the @emph{root} window currently containing the @emph{display} pointer and the current position of the pointer relative to the @emph{root}. @table @var @item root-x Type @var{int16}. @item root-y Type @var{int16}. @item root Type @var{window}. @end table @end defun @defun pointer-position window @table @var @item window A @var{window} specifying the coordinate system for the returned position. @end table Returns the current pointer coordinates relative to the given @emph{window}. If @var{pointer-position} returns @var{nil} for @emph{same-screen-p}, the pointer is not on the same screen as the @emph{window}. In this case, @var{pointer-position} returns a value of @var{nil} for @emph{child} and a value of zero for @emph{x} and @emph{y}. If @var{pointer-position} returns true for @emph{same-screen-p}, the returned @emph{x} and @emph{y} are relative to the origin of @emph{window}. @table @var @item x Type @var{int16}. @item y Type @var{int16}. @item same-screen-p Type @var{boolean}. @item child Type @var{window} or @var{null}. @end table @end defun @defun motion-events window &key :start :stop (:result-type 'list) @table @var @item window The @var{window} containing the returned motion events. @item :start @itemx :stop @var{timestamp} values for the time interval for returned motion events. @item :result-type The form of the returned motion events. @end table Many X server implementations maintain a more precise history of pointer motion between event notifications. The pointer position at each pointer hardware interrupt can be stored into a buffer for later retrieval.This is called the @emph{motion history buffer}. A paint program, for example, may want to have a precise history of where the pointer traveled, even though for most other applications this amount of detail is grossly excessive. The @var{motion-events} function returns all events in the motion history buffer that fall between the specified @var{:start} and @var{:stop} timestamps (inclusive) and have coordinates that lie within the specified @emph{window} (including borders) at its present placement. If the @var{:start} time is later than the @var{:stop} time or if the @var{:start} time is in the future, no events are returned. @table @var @item motion-events Type @code{(repeat-seq (int16 x) (int16 y) (timestamp time))}. @end table @end defun @defun warp-pointer destination destination-x destination-y @table @var @item destination The @var{window} into which the pointer is moved. @item destination-x @itemx destination-y The new position of the pointer relative to the destination. @end table Moves the pointer to the given coordinates relative to the @emph{destination} window. @var{warp-pointer} should be rarely be used since the user should normally be in control of the pointer position. @var{warp-pointer} generates events just as if the user had instantaneously moved the pointer from one position to another. @var{warp-pointer} cannot move the pointer outside the confine-to window of an active pointer grab; an attempt to do so only moves the pointer as far as the closest edge of the confine-to window. @end defun @defun warp-pointer-relative display x-offset y-offset @table @var @item display A @var{display}. @item x-offset @itemx y-offset The offsets used to adjust the pointer position. @end table Moves the pointer by the given offsets. This function should rarely be used since the user should normally be in control of the pointer position. @var{warp-pointer-relative} generates events just as if the user had instantaneously moved the pointer from one position to another. @var{warp-pointer-relative} cannot move the pointer outside the confine-to window of an active pointer grab; an attempt to do so only moves the pointer as far as the closest edge of the confine-to window. @end defun @defun warp-pointer-if-inside destination destination-x destination-y source source-x source-y &optional (source-width 0) (source-height 0) @table @var @item destination The @var{window} into which the pointer is moved. @item destination-x @itemx destination-y The new position of the pointer relative to the @emph{destination}. @item source The @var{window} that must currently contain the pointer. @item source-x @itemx source-y @itemx source-width @itemx source-height The source rectangle that must currently contain the pointer. @end table Moves the pointer to the given position relative to the @emph{destination} window. However, the move can only take place if the pointer is currently contained in a visible portion of the specified rectangle of the @emph{source} window. If @emph{source-height} is zero, it is replaced with the current height of @emph{source} window minus @emph{source-y}. If @emph{source-width} is zero, it is replaced with the current width of @emph{source} window minus @emph{source-x}. @var{warp-pointer-if-inside} generates events just as if the user had instantaneously moved the pointer from one position to another. @var{warp-pointer-if-inside} cannot move the pointer outside the confine-to window of an active pointer grab; an attempt to do so only moves the pointer as far as the closest edge of the confine-to window. @end defun @defun warp-pointer-relative-if-inside x-offset y-offset source source-x source-y &optional (source-width 0) (source-height 0) @table @var @item x-offset @itemx y-offset The offsets used to adjust the pointer position. @item source The @var{window} that must currently contain the pointer. @item source-x @itemx source-y @itemx source-width @itemx source-height The source rectangle that must currently contain the pointer. @end table Moves the pointer by the given offsets. However, the move can only take place if the pointer is currently contained in a visible portion of the specified rectangle of the @emph{source} window. If @emph{source-height} is zero, it is replaced with the current height of @emph{source-window} minus @emph{source-y}. If @emph{source-width} is zero, it is replaced with the current width of @emph{source-window} minus @emph{source-x}. @var{warp-pointer-relative-if-inside} generates events just as if the user had instantaneously moved the pointer from one position to another. @var{warp-pointer-relative-if-inside} cannot move the pointer outside the confine-to window of an active pointer grab; an attempt to do so only moves the pointer as far as the closest edge of the confine-to window. @end defun @node Managing Input Focus, Grabbing the Pointer, Pointer Position, Events and Input @section Managing Input Focus CLX provides the @var{set-focus-input} and @var{focus-input} functions to set and get the keyboard input focus window. @defun set-input-focus display focus revert-to &optional time @table @var @item display A @var{display}. @item focus The new input focus @var{window}. @item revert-to The focus @var{window} when focus is no longer viewable. @item time A @var{timestamp}. @end table Changes the keyboard input focus and the last-focus-change time. The function has no effect if the specified @emph{time} is earlier than the current last-focus-change time or is later than the current server time; otherwise, the last-focus-change time is set to the specified @emph{time}. The @var{set-input-focus} function causes the X server to generate @var{:focus-in} and @var{:focus-out} events. If @var{:none} is specified as the @emph{focus}, all keyboard events are discarded until a new focus window is set. In this case, the @emph{revert-to} argument is ignored. If a window is specified as the @emph{focus} argument, it becomes the keyboard's focus window. If a generated keyboard event would normally be reported to this window or one of its inferiors, the event is reported normally; otherwise, the event is reported with respect to the focus window. If @var{:pointer-root} is specified as the @emph{focus} argument, the input focus window is set to the root window of the screen containing the pointer when each keyboard event occurs. In this case, the @emph{revert-to} argument is ignored. The specified @emph{focus} window must be viewable at the time of the request. If the @emph{focus} window later becomes not viewable, the new focus window depends on the @emph{revert-to} argument. If @emph{revert-to} is specified as @var{:parent}, the @emph{focus} reverts to the parent (or the closest viewable ancestor) and the new @emph{revert-to} value is take to be @var{:none}. If @emph{revert-to} is @var{:pointer-root} or @var{:none}, the @emph{focus} reverts to that value. When the @emph{focus} reverts, @var{:focus-in} and @var{:focus-out} events are generated, but the last-focus-change time is not affected. @end defun @defun input-focus display @table @var @item display A @var{display}. @end table Returns the @emph{focus} window, @var{:pointer-root}, or @var{:none}, depending on the current state of the focus window. @emph{revert-to} returns the current focus revert-to state. @table @var @item focus Type (@var{or window} (@var{member :none :pointer-root})). @item revert-to Type (@var{or window} (@var{member :none :pointer-root :parent})). @end table @end defun @node Grabbing the Pointer, Grabbing a Button, Managing Input Focus, Events and Input @section Grabbing the Pointer CLX provides the @var{grab-pointer} and @var{ungrab-pointer} functions for grabbing and releasing pointer control. @defun grab-pointer window event-mask &key :owner-p :sync-pointer-p :sync-keyboard-p :confine-to :cursor :time @table @var @item window The @var{window} grabbing the pointer. @item event-mask A @var{pointer-event-mask}. @item :owner-p If true, all client windows receive pointer events normally. @item :sync-pointer-p Indicates whether the pointer is in synchronous or asynchronous mode. @item :sync-keyboard-p Indicates whether the keyboard is in synchronous or asynchronous mode. @item :confine-to A @var{window} to which the pointer is confined. @item :cursor A @var{cursor}. @item :time A @var{timestamp}. A @var{nil} value means the current server time is used. @end table Actively grabs control of the pointer. Further pointer events are only reported to the grabbing client. The request overrides any active pointer grab by this client. If @var{:owner-p} is @var{nil}, all generated pointer events are reported with respect to @emph{window}, and are only reported if selected by @emph{event-mask}. If @var{:owner-p} is true, and if a generated pointer event would normally be reported to this client, it is reported normally; otherwise the event is reported with respect to the @emph{window}, and is only reported if selected by @emph{event-mask}. For either value of @var{:owner-p}, unreported events are simply discarded. If @var{:sync-pointer-p} is @var{nil}, pointer event processing continues normally (asynchronously); if the pointer is currently frozen by this client, then processing of pointer events is resumed. If @var{:sync-pointer-p} is true (indicating a synchronous action), the pointer (as seen via the protocol) appears to freeze, and no further pointer events are generated by the server until the grabbing client issues a releasing @var{allow-events} request. Actual pointer changes are not lost while the pointer is frozen; they are simply queued for later processing. If @var{:sync-keyboard-p} is @var{nil}, keyboard event processing is unaffected by activation of the grab. If @var{:sync-keyboard-p} is true, the keyboard (as seen via the protocol) appears to freeze, and no further keyboard events are generated by the server until the grabbing client issues a releasing @var{allow-events} request. Actual keyboard changes are not lost while the keyboard is frozen; they are simply queued for later processing. If @var{:cursor} is specified, it is displayed regardless of what window the pointer is in. Otherwise, the normal cursor for the @emph{window} is displayed. If a @var{:confine-to} window is specified, the pointer is restricted to stay within that window. The @var{:confine-to} window does not need to have any relationship to the @emph{window}. If the pointer is not initially in the @var{:confine-to} window, it is warped automatically to the closest edge (with @var{:enter}/@var{:leave-events} generated normally) just before the grab activates. If the @var{:confine-to} window is subsequently reconfigured, the pointer is warped automatically as necessary to keep it contained in the window. @var{grab-pointer} generates @var{:enter-notify} and @var{:leave-notify} events. @var{grab-pointer} can fail with a status of: @itemize @bullet @item @var{:already-grabbed} if the pointer is actively grabbed by some other client @item @var{:frozen} if the pointer is frozen by an active grab of another client @item @var{:not-viewable} if the @emph{window} or the @var{:confine-to} window is not viewable, or if the @var{:confine-to} window lies completely outside the boundaries of the root window. @item @var{:invalid-time} if the specified time is earlier than the last-pointer-grab time or later than the current server time. Otherwise, the last-pointer-grab time is set to the specified time, with current-time replaced by the current server time, and a value of @var{:success} is returned by @var{grab-pointer}. @end itemize @table @var @item grab-status One of @var{:already-grabbed}, @var{:frozen}, @var{:invalid-time}, @var{:not-viewable}, or @var{:success}. @end table @end defun @defun ungrab-pointer display &key :time @table @var @item display A @var{display}. @item :time A @var{timestamp}. @end table Releases the pointer if this client has it actively grabbed (from either @var{grab-pointer}, @var{grab-button}, or from a normal button press), and releases any queued events. The request has no effect if the specified @var{:time} is earlier than the last-pointer-grab time or is later than the current server time. An @var{ungrabpointer} is performed automatically if the event window or @var{:confine-to} window for an active pointer grab becomes not viewable. This request generates @var{:enter-notify} and @var{:leave-notify} events. @end defun @defun change-active-pointer-grab display event-mask &optional cursor time @table @var @item display A @var{display}. @item event-mask A @var{pointer-event-mask}. @item cursor A @var{cursor} or @var{nil}. @item time A @var{timestamp}. @end table Changes the specified dynamic parameters if the pointer is actively grabbed by the client and the specified @emph{time} is no earlier than the last-pointer-grab time and no later than the current server time. The interpretation of @emph{event-mask} and @emph{cursor} are as in @var{grab-pointer}. @var{change-active-pointer-grab} has no effect on the passive parameters of a @var{grab-button}. @end defun @node Grabbing a Button, Grabbing the Keyboard, Grabbing the Pointer, Events and Input @section Grabbing a Button CLX provides the @var{grab-button} and @var{ungrab-button} functions for passively grabbing and releasing pointer control. @defun grab-button window button event-mask &key (:modifiers 0) :owner-p :sync-pointer-p :sync-keyboard-p :confine-to :cursor @table @var @item window A @var{window}. @item button The button (type @var{card8}) pressed or @var{:any}. @item event-mask A @var{pointer-event-mask}. @item :modifiers A @var{modifier-mask}. @item :owner-p If true, all client windows receive pointer events normally. @item :sync-pointer-p Indicates whether the pointer is handled in a synchronous or asynchronous fashion. @item :sync-keyboard-p Indicates whether the keyboard is in synchronous or asynchronous mode. @item :confine-to A @var{window} to which the pointer is confined. @item :cursor A @var{cursor}. @end table This request establishes a passive grab. If the specified @emph{button} is pressed when the specified modifier keys are down (and no other buttons or modifier keys are down), and: @itemize @bullet @item @emph{window} contains the pointer @item The @var{:confine-to} window (if any) is viewable @item These constraints are not satisfied for any ancestor of @emph{window} @end itemize then: @itemize @bullet @item The pointer is actively grabbed as described with @var{grab-pointer} @item The last-pointer-grab time is set to the time that the button was pressed (as transmitted in the @var{:button-press} event) @item The @var{:button-press} event is reported @end itemize The interpretation of the remaining arguments is the same as with @var{grab-pointer}. The active grab is terminated automatically when all buttons are released (independent of the state of modifier keys). A zero @emph{modifier} mask is equivalent to issuing the request for all possible modifier-key combinations (including the combination of no modifiers). It is not required that all specified modifiers have currently assigned keycodes. A @emph{button} of @var{:any} is equivalent to issuing the request for all possible buttons. Otherwise, it is not required that the specified @emph{button} currently be assigned to a physical button. @end defun @defun ungrab-button window button &key (:modifiers 0) @table @var @item window A @var{window}. @item button The button (type @var{card8}) that is released or @var{:any}. @item :modifiers A @var{modifier-mask}. @end table Releases the passive button/key combination on the specified @emph{window} if it was grabbed by this client. A zero @emph{modifier} mask is equivalent to issuing the request for all possible modifier combinations including the combination of no modifiers. A @emph{button} of @var{:any} is equivalent to issuing the request for all possible buttons. This has no effect on an active grab. @end defun @node Grabbing the Keyboard, Grabbing a Key, Grabbing a Button, Events and Input @section Grabbing the Keyboard CLX provides the @var{grab-keyboard} and @var{ungrab-keyboard} functions for actively grabbing and releasing control of the keyboard. @defun grab-keyboard window &key :owner-p :sync-pointer-p :sync-keyboard-p :time @table @var @item window A @var{window}. @item :owner-p If true, all client windows receive keyboard input normally. @item :sync-pointer-p Indicates whether the pointer is in synchronous or asynchronous mode. @item :sync-keyboard-p Indicates whether the keyboard is in synchronous or asynchronous mode. @item :time A @var{timestamp}. @end table Actively grabs control of the keyboard. Further key events are reported only to the grabbing client. The request overrides any active keyboard grab by this client. @var{grab-keyboard} generates @var{:focus-in} and @var{:focus-out} events. If @var{:owner-p} is @var{nil}, all generated key events are reported with respect to @emph{window}. If @var{:owner-p} is true, then a generated key event that would normally be reported to this client is reported normally; otherwise the event is reported with respect to the @emph{window}. Both @var{:key-press} and @var{:key-release} events are always reported, independent of any event selection made by the client. If @var{:sync-keyboard-p} is @var{nil}, keyboard event processing continues normally (asynchronously); if the keyboard is currently frozen by this client, then processing of keyboard events is resumed. If @var{:sync-keyboard-p} is true, the keyboard (as seen via the protocol) appears to freeze, and no further keyboard events are generated by the server until the grabbing client issues a releasing @var{allow-events} request. Actual keyboard changes are not lost while the keyboard is frozen; they are simply queued for later processing. If @var{:sync-pointer-p} is @var{nil}, pointer event processing is unaffected by activation of the grab. If @var{:sync-pointer-p} is true, the pointer (as seen via the protocol) appears to freeze, and no further pointer events are generated by the server until the grabbing client issues a releasing @var{allow-events} request. Actual pointer changes are not lost while the pointer is frozen; they are simply queued for later processing. The grab can fail with a status of: @itemize @bullet @item @var{:already-grabbed} if the keyboard is actively grabbed by some other client @item @var{:frozen} if the keyboard is frozen by an active grab from another client @item @var{:not-viewable} if @emph{window} is not viewable @item @var{:invalid-time} if the specified time is earlier than the last-keyboard-grab time or later than the current server time. Otherwise, @var{grab-keyboard} returns a status of @var{:success} and last-keyboard-grab time is set to the specified time, with current-time replaced by current server time. @end itemize @table @var @item grab-status One of @var{:already-grabbed}, @var{:frozen}, @var{:invalid-time}, @var{:not-viewable}, or @var{:success}. @end table @end defun @defun ungrab-keyboard display &key :time @table @var @item display A @var{display}. @item :time A @var{timestamp}. @end table Releases the keyboard if this client has it actively grabbed (from either @var{grab-keyboard} or @var{grab-key}), and releases any queued events. The request has no effect if the specified time is earlier than the last-keyboard-grab time or is later than the current server time. An @var{ungrab-keyboard} is performed automatically if the event window for an active keyboard grab becomes not viewable. @end defun @node Grabbing a Key, Event Types, Grabbing the Keyboard, Events and Input @section Grabbing a Key The following paragraphs describe the functions used for passively grabbing and releasing the keyboard. @defun grab-key window key &key (:modifiers 0) :owner-p :sync-pointer-p :sync-keyboard-p :time @table @var @item window A @var{window}. @item key The key (type @var{card8}) to be grabbed or @var{:any}. @item :modifiers A @var{modifier-mask}. @item :owner-p If true, all client windows receive keyboard input normally. @item :sync-pointer-p Indicates whether the pointer is in synchronous or asynchronous mode. @item :sync-keyboard-p Indicates whether the keyboard is in synchronous or asynchronous mode. @item :time A @var{timestamp}. @end table This request establishes a passive grab on the keyboard. If the specified @emph{key} (which can also be a modifier key) is pressed (whether or not any specified modifier keys are down), and either of the following is true: @itemize @bullet @item @emph{window} is an ancestor of (or is) the focus window @item @emph{window} is a descendant of the focus window and contains the pointer @item These constraints are not satisfied for any ancestor of @emph{window}, then the following occurs: @itemize @bullet @item The keyboard is actively grabbed as described in @var{grab-keyboard} @item The last-keyboard-grab time is set to the time that the @emph{key} was pressed (as transmitted in the @var{:key-press} event) @item The @var{:key-press} event is reported @end itemize @end itemize The interpretation of the remaining arguments is as for @var{grab-keyboard}. The active grab is terminated automatically when the specified @emph{key} has been released, independent of the state of the modifier keys. A zero modifier mask is equivalent to issuing the request for all possible modifier combinations (including the combination of no modifiers). It is not required that all specified modifiers have currently assigned keycodes. A @emph{key} of @var{:any} is equivalent to issuing the request for all possible keycodes. Otherwise, the @emph{key} must be in the range specified by @var{display-min-keycode} and @var{display-max-keycode} in the connection setup. @end defun @defun ungrab-key window key &key (:modifiers 0) @table @var @item window A @var{window}. @item key The key (type @var{card8}) to be released or @var{:any}. @item :modifiers A @var{modifier-mask}. @end table Releases the @emph{key} combination on the specified @emph{window} if it was grabbed by this client. A zero modifier mask of @var{:any} is equivalent to issuing the request for all possible modifier combinations (including the combination of no modifiers). A @emph{key} of @var{:any} is equivalent to issuing the request for all possible keycodes. @var{ungrab-key} has no effect on an active grab. @end defun @node Event Types, Releasing Queued Events, Grabbing a Key, Events and Input @section Event Types The following paragraphs contain detailed descriptions of the contents of each event type. In CLX, events are not actually represented by structures, but rather by lists of keyword values passed to handler functions or by values bound to symbols within the clauses of @var{event-case} and @var{event-cond} forms. Nevertheless, it is convenient to describe event contents in terms of slots and to identify the components of events with slot name symbols. In fact, CLX uses the @var{declare-event} macro to define event slot symbols and to map these symbols to specific event data items returned by the X server (@pxref{Declaring Event Types}). The following paragraphs describe each event type, listing its @var{event-key} keyword symbol and its slot name symbols. An event keyword symbol identifies a specific event type. An event keyword symbol can be given as an argument to @var{send-event} or to an event handler function; it can also appear in the @emph{event-match} form of an @var{event-case} clause. An event slot name symbol identifies a specific event data item. Event slot names appear as keywords with associated values among the arguments passed to @var{send-event} or to an event handler function; as non-keyword symbols, they can also be in the @emph{event-slots} form of an @var{event-case} clause. In certain cases, more than one name symbol is defined for the same event slot. For example, in @var{:key-press} events, the symbols @emph{window} and @emph{event-window} both refer to the same event data item. @menu * Keyboard and Pointer Events:: * Input Focus Events:: * Keyboard and Pointer State Events:: * Exposure Events:: * Window State Events:: * Structure Control Events:: * Client Communications Events:: * Declaring Event Types:: @end menu @node Keyboard and Pointer Events, Input Focus Events, Event Types, Event Types @subsection Keyboard and Pointer Events The keyboard and pointer events are: @var{:key-press} @var{:key-release}, @var{:button-press}, @var{:button-release}, @var{:motion-notify}, @var{:enter-notify}, and @var{:leave-notify}. @deftp {Event Type} :key-press @deftpx {Event Type} :key-release @deftpx {Event Type} :button-press @deftpx {Event Type} :button-release Selected by @var{:key-press}, @var{:key-release}, @var{:button-press}, or @var{:button-release}. @var{:key-press}, and @var{:key-release} events are generated when a key or pointer button changes state. Note that @var{:key-press} and @var{:key-release} are generated for all keys, even those mapped to modifiers. All of these event types have the same slots. The window containing the pointer at the time of the event is referred to as the @emph{source} window. The @emph{event} @emph{window} is the window to which the event is actually reported. The event window is found by starting with the source window and looking up the hierarchy for the first window on which any client has selected interest in the event (provided no intervening window prohibits event generation by including the event type in its do-not-propagate-mask). The actual window used for reporting can be modified by active grabs and, in the case of keyboard events, can be modified by the focus window. A @var{:button-press} event has the effect of a temporary @var{grab-button}. When a pointer button is pressed and no active pointer grab is in progress, the ancestors of the source window are searched from the @emph{root} down, looking for a passive grab to activate. If no matching passive grab on the button exists, then an active grab is started automatically for the client receiving the @var{:button-press} event, and the last-pointer-grab time is set to the current server time. The effect is essentially equivalent to calling @var{grab-button} with the following arguments: @table @var @item @emph{window} The event window. @item @emph{button} The button that was pressed. @item @emph{event-mask} The client's selected pointer events on the event window. @item @var{:modifiers} 0 @item @var{:owner-p} @var{t} if the client has @var{:owner-grab-button} selected on the event window; otherwise @var{nil}. @item @var{:sync-pointer-p} @var{nil} @item @var{:sync-keyboard-p} @var{nil} @item @var{:confine-to} @var{nil} @item @var{:cursor} @var{nil} @end table The @var{:button-press} grab is terminated automatically when all buttons are released. The functions @var{ungrab-pointer} and @var{change-active-pointer-grab} can both be used to modify the @var{:button-press} grab. @table @var @item window @item event-window Type @var{window}. The window receiving the event. @item code Type @var{card8}. The @emph{code} argument varies with the event type. For @var{:key-press} and @var{:key-release}, @emph{code} is the keycode (@pxref{Keyboard Encodings}). For @var{:button-press} and @var{:button-release}, @emph{code} is the pointer button number. @item x Type @var{int16}. If @emph{event-window} is on the same screen as root, then @emph{x} and @emph{y} are the pointer coordinates relative to the @emph{event-window}; otherwise @emph{x} and @emph{y} are zero. @item y Type @var{int16}. If @emph{event-window} is on the same screen as root, then @emph{x} and @emph{y} are the pointer coordinates relative to the @emph{event-window}; otherwise @emph{x} and @emph{y} are zero. @item state Type @var{card16}. A mask that gives the state of the buttons and modifier keys just before the event. @item time Type @var{card32}. A timestamp for the moment when the event occurred. @item root Type @var{window}. The root window of the source window. @item root-x Type @var{int16}. The x coordinate of the pointer position relative to root at the time of the event. @item root-y Type @var{int16}. The y coordinate of the pointer position relative to root at the time of the event@emph{.} @item child Type (@var{or null window}). If the source window is an inferior of the @emph{event-window}, @emph{child} is set to the child of @emph{event-window} that is an ancestor of (or is) the source window; otherwise, it is set to @var{nil}@emph{.} @item same-screen-p Type @var{boolean}. True if @emph{event-window} and root are on the same screen. @end table @end deftp @deftp {Event Type} :motion-notify Selected by: @var{:button-1-motion}, @var{:button-2-motion}, @var{:button-3-motion}, @var{:button-4-motion}, @var{:button-5-motion}, @var{:button-motion}, or @var{:pointer-motion}. The @var{:motion-notify} event is generated when the pointer moves. A @var{:motion-notify} event has the same slots as @var{:button-press} @var{:button-release}, @var{:key-press}, and @var{:key-release} events, with the exception that the @emph{code} slot is replaced by the @emph{hint-p} slot. As with these other events, the event window for @var{:motion-notify} is found by starting with the source window and looking up the hierarchy for the first window on which any client has selected interest in the event (provided no intervening window prohibits event generation by including @var{:motion-notify} in its do-not-propagate-mask).The actual window used for reporting can be modified by active grabs. @var{:motion-notify} events are generated only when the motion begins and ends in the window. The granularity of motion events is not guaranteed, but a client selecting for motion events is guaranteed to get at least one event when the pointer moves and comes to rest. Selecting @var{:pointer-motion} generates @var{:motion-notify} events regardless of the state of the pointer buttons. By selecting some subset of @var{:button[1-5]-motion} instead, @var{:motion-notify} events are only received when one or more of the specified buttons are pressed. By selecting @var{:button-motion}, @var{:motion-notify} events are only received when at least one button is pressed. If @var{:pointer-motion-hint} is also selected, the server is free to send only one @var{:motion-notify}, until either the key or button state changes, the pointer leaves the event window, or the client calls @var{query-pointer} or @var{motion-events}. @table @var @item hint-p Type @var{boolean}. True if the event is a hint generated by selecting @var{:pointer-motion-hint}. @end table @end deftp @deftp {Event Type} :enter-notify @deftpx {Event Type} :leave-notify @anchor{:enter-notify} Selected by: @var{:enter-window} or @var{:leave-window}. If pointer motion or a window hierarchy change causes the pointer to be in a different window than before, @var{:enter-notify} and @var{:leave-notify} events are generated instead of a @var{:motion-notify} event. All @var{:enter-notify} and @var{:leave-notify} events caused by a hierarchy change are generated after any hierarchy event (@var{:unmap-notify}, @var{:map-notify}, @var{:configure-notify}, @var{:gravity-notify}, or @var{:circulate-notify}) caused by that change, but the ordering of @var{:enter-notify} and @var{:leave-notify} events with respect to @var{:focus-out}, @var{:visibility-notify}, and @var{:exposure} events is not constrained by the X protocol. An @var{:enter-notify} or @var{:leave-notify} event can also be generated when a client application calls @var{change-active-pointer-grab}, @var{grab-pointer}, or @var{ungrab-pointer}. @table @var @item window @itemx event-window Type @var{window}. The window receiving the event. @item x Type @var{int16}. The final pointer position. If @emph{event-window} is on the same screen as root, then @emph{x} and @emph{y} are the pointer coordinates relative to the @emph{event-window}; otherwise @emph{x} and @emph{y} are zero. @item y Type @var{int16}. The final pointer position. If @emph{event-window} is on the same screen as root, then @emph{x} and @emph{y} are the pointer coordinates relative to the @emph{event-window}; otherwise @emph{x} and @emph{y} are zero. @item mode Type (@var{member :normal :grab :ungrab}). Events caused when the pointer is actively grabbed have mode @var{:grab}. Events caused when an active pointer grab deactivates have mode @var{:ungrab}. In all other cases, mode is @var{:normal}. @item kind Type (@var{member :ancestor :virtual :inferior :nonlinear} @var{:nonlinear-virtual}). When the pointer moves from window A to window B, and A is an inferior of B: @itemize @bullet @item @var{:leave-notify} with @emph{kind} @var{:ancestor} is generated on A @item @var{:leave-notify} with @emph{kind} @var{:virtual} is generated on each window between A and B exclusive (in that order) @item @var{:enter-notify} with @emph{kind} @var{:inferior} is generated on B @end itemize When the pointer moves from window A to window B, and B is an inferior of A: @itemize @bullet @item @var{:leave-notify} with @emph{kind} @var{:inferior} is generated on A @item @var{:enter-notify} with @emph{kind} @var{:virtual} is generated on each window between A and B exclusive (in that order) @item @var{:enter-notify} with @emph{kind} @var{:ancestor} is generated on B @end itemize When the pointer moves from window A to window B, with window C being their least common ancestor: @itemize @bullet @item @var{:leave-notify} with @emph{kind} @var{:nonlinear} is generated on A @item @var{:leave-notify} with @emph{kind} @var{:nonlinear-virtual} is generated on each window between A and C exclusive (in that order) @item @var{:enter-notify} with @emph{kind} @var{:nonlinear-virtual} is generated on each window between C and B exclusive (in that order) @item @var{:enter-notify} with @emph{kind} @var{:nonlinear} is generated on B @end itemize When the pointer moves from window A to window B, on different screens: @itemize @bullet @item @var{:leave-notify} with @emph{kind} @var{:nonlinear} is generated on A @item If A is not a root window, @var{:leave-notify} with @emph{kind} @var{:nonlinear-virtual} is generated on each window above A up to and including its root (in order) @item If B is not a root window, @var{:enter-notify} with @emph{kind} @var{:nonlinear-virtual} is generated on each window from B's root down to but not including B (in order) @item @var{:enter-notify} with @emph{kind} @var{:nonlinear} is generated on B @end itemize When a pointer grab activates (but after any initial warp into a confine-to window, and before generating any actual @var{:button-press} event that activates the grab), with @emph{G} the @var{grab-window} for the grab and @emph{P} the window the pointer is in, then @var{:enter-notify} and @var{:leave-notify} events with mode @var{:grab} are generated (as for @var{:normal} above) as if the pointer were to suddenly warp from its current position in @emph{P} to some position in @emph{G}. However, the pointer does not warp, and the pointer position is used as both the @emph{initial} and @emph{final} positions for the events. When a pointer grab deactivates (but after generating any actual @var{:button-release} event that deactivates the grab), with @emph{G} the @var{grab-window} for the grab and @emph{P} the window the pointer is in, then @var{:enter-notify} and @var{:leave-notify} events with mode @var{:ungrab} are generated (as for @var{:normal} above) as if the pointer were to suddenly warp from from some position in @emph{G} to its current position in @emph{P}. However, the pointer does not warp, and the current pointer position is used as both the @emph{initial} and @emph{final} positions for the events. @item focus-p Type @var{boolean}. If @emph{event-window} is the focus window or an inferior of the focus window, then @emph{focus-p} is @var{t}; otherwise, @emph{focus-p} is @var{nil}. @item state Type @var{card16}. A mask that gives the state of the buttons and modifier keys just before the event. @item time Type @var{card32}. A timestamp for the moment when the event occurred. @item root Type @var{window}. The root window containing the final pointer position. @item root-x Type @var{int16}. The x coordinate of the pointer position relative to root at the time of the event. @item root-y Type @var{int16}. The y coordinate of the pointer position relative to root at the time of the event. @item child Type (@var{or null window}). In a @var{:leave-notify} event, if a child of the @emph{event-window} contains the initial position of the pointer, the @emph{child} slot is set to that child; otherwise, the @emph{child} slot is @var{nil}. For an @var{:enter-notify} event, if a child of the @emph{event-window} contains the final pointer position, the @emph{child} slot is set to that child; otherwise, the @emph{child} slot is @var{nil}. @item same-screen-p Type @var{boolean}. True if @emph{event-window} and root are on the same screen. @end table @end deftp @node Input Focus Events, Keyboard and Pointer State Events, Keyboard and Pointer Events, Event Types @subsection Input Focus Events The input focus events are @var{:focus-in} and @var{:focus-out}. @deftp {Event Type} :focus-in @deftpx {Event Type} :focus-out Selected by: @var{:focus-change}. @var{:focus-in} and @var{:focus-out} events are generated when the input focus changes. All @var{:focus-out} events caused by a window @var{:unmap} are generated after any @var{:unmap-notify} event, but the ordering of @var{:focus-out} with respect to generated @var{:enter-notify}, @var{:leave-notify}, @var{:visibility-notify}, and @var{:expose} events is not constrained. @table @var @item window @itemx event-window Type @var{window}. For @var{:focus-in}, the new input focus window. For @var{:focus-out}, the previous input focus window. @item mode Type @code{(member :normal :while-grabbed :grab :ungrab)}. Events generated by @var{set-input-focus} when the keyboard is not grabbed have mode @var{:normal}. Events generated by @var{set-input-focus} when the keyboard is grabbed have mode @var{:while-grabbed}. Events generated when a keyboard grab activates have mode @var{:grab}, and events generated when a keyboard grab deactivates have mode @var{:ungrab}. @item kind Type (@var{member :ancestor :virtual :inferior :nonlinear :nonlinear-virtual :pointer :pointer-root :none}). When the focus moves from window A to window B, and A is an inferior of B, with the pointer in window P: @itemize @bullet @item @var{:focus-out} with @emph{kind} @var{:ancestor} is generated on A @item @var{:focus-out} with @emph{kind} @var{:virtual} is generated on each window between A and B exclusive (in that order) @item @var{:focus-in} with @emph{kind} @var{:inferior} is generated on B @item If P is an inferior of B, but P is not A or an inferior of A or an ancestor of A, @var{:focus-in} with @emph{kind} @var{:pointer} is generated on each window below B down to and including P (in order) @end itemize When the focus moves from window A to window B, and B is an inferior of A, with the pointer in window P: @itemize @bullet @item If P is an inferior of A, but P is not A or an inferior of B or an ancestor of B, @var{:focus-out} with @emph{kind} @var{:pointer} is generated on each window from P up to but not including A (in order) @item @var{:focus-out} with @emph{kind} @var{:inferior} is generated on A @item @var{:focus-in} with @emph{kind} @var{:virtual} is generated on each window between A and B exclusive (in that order) @item @var{:focus-in} with @emph{kind} @var{:ancestor} is generated on B @end itemize When the focus moves from window A to window B, with window C being their least common ancestor, and with the pointer in window P: @itemize @bullet @item If P is an inferior of A, @var{:focus-out} with @emph{kind} @var{:pointer} is generated on each window from P up to but not including A (in order) @item @var{:focus-out} with @emph{kind} @var{:nonlinear} is generated on A @item @var{:focus-out} with @emph{kind} @var{:nonlinear-virtual} is generated on each window between A and C exclusive (in that order) @item @var{:focus-in} with @emph{kind} @var{:nonlinear-virtual} is generated on each window between C and B exclusive (in that order) @item :focus-in with @emph{kind} @var{:nonlinear} is generated on B @item If P is an inferior of B, @var{:focus-in} with @emph{kind} @var{:pointer} is generated on each window below B down to and including P (in order) @end itemize When the focus moves from window A to window B, on different screens, with the pointer in window P: @itemize @bullet @item If P is an inferior of A, @var{:focus-out} with @emph{kind} @var{:pointer} is generated on each window from P up to but not including A (in order) @item @var{:focus-out} with @emph{kind} @var{:nonlinear} is generated on A @item If A is not a root window, @var{:focus-out} with @emph{kind} @var{:nonlinear-virtual} is generated on each window above A up to and including its root (in order) @item If B is not a root window, @var{:focus-in} with @emph{kind} @var{:nonlinear-virtual} is generated on each window from B's root down to but not including B (in order) @item @var{:focus-in} with @emph{kind} @var{:nonlinear} is generated on B @item If P is an inferior of B, @var{:focus-in} with @emph{kind} @var{:pointer} is generated on each window below B down to and including P (in order) @end itemize When the focus moves from window A to @var{:pointer-root} (or @var{:none}), with the pointer in window P: @itemize @bullet @item If P is an inferior of A, @var{:focus-out} with @emph{kind} @var{:pointer} is generated on each window from P up to but not including A (in order) @item @var{:focus-out} with @emph{kind} @var{:nonlinear} is generated on A @item If A is not a root window, @var{:focus-out} with @emph{kind} @var{:nonlinear-virtual} is generated on each window above A up to and including its root (in order) @item @var{:focus-in} with @emph{kind} @var{:pointer-root} (or @var{:none}) is generated on all root windows @item If the new focus is @var{:pointer-root}, @var{:focus-in} with @emph{kind} @var{:pointer} is generated on each window from P's root down to and including P (in order) @end itemize When the focus moves from @var{:pointer-root} (or @var{:none}) to window A, with the pointer in window P: @itemize @bullet @item If the old focus is @var{:pointer-root}, @var{:focus-out} with @emph{kind} @var{:pointer} is generated on each window from P up to and including P's root (in order) @item @var{:focus-out} with @emph{kind} @var{:pointer-root} (or @var{:none}) is generated on all root windows @item If A is not a root window, @var{:focus-in} with @emph{kind} @var{:nonlinear-virtual} is generated on each window from A's root down to but not including A (in order) @item @var{:focus-in} with @emph{kind} @var{:nonlinear} is generated on A @item If P is an inferior of A, @var{:focus-in} with @emph{kind} @var{:pointer} is generated on each window below A down to and including P (in order) @end itemize When the focus moves from @var{:pointer-root} to @var{:none} (or vice versa), with the pointer in window P: @itemize @bullet @item If the old focus is @var{:pointer-root}, @var{:focus-out} with @emph{kind} @var{:pointer} is generated on each window from P up to and including P's root (in order) @item @var{:focus-out} with @emph{kind} @var{:pointer-root} (or @var{:none}) is generated on all root windows @item @var{:focus-in} with @emph{kind} @var{:none} (or @var{:pointer-root}) is generated on all root windows @item If the new focus is @var{:pointer-root}, @var{:focus-in} with @emph{kind} @var{:pointer} is generated on each window from P's root down to and including P (in order) @end itemize @end table When a keyboard grab activates (but before generating any actual @var{:key-press} event that activates the grab), with @emph{G} the @var{grab-window} for the grab and @emph{F} the current focus, then @var{:focus-in} and @var{:focus-out} events with mode @var{:grab} are generated (as for @var{:normal} above) as if the focus were to change from @emph{F} to @emph{G}. When a keyboard grab deactivates (but after generating any actual @var{:key-release} event that deactivates the grab), with @emph{G} the @var{grab-window} for the grab and @emph{F} the current focus, then @var{:focus-in} and @var{:focus-out} events with mode @var{:ungrab} are generated (as for @var{:normal} above) as if the focus were to change from @emph{G} to @emph{F}. @end deftp @node Keyboard and Pointer State Events, Exposure Events, Input Focus Events, Event Types @subsection Keyboard and Pointer State Events The keyboard and pointer state events are @var{:keymap-notify} and @var{:mapping-notify}. @deftp {Event Type} :keymap-notify Selected by: @var{:keymap-state}. The @var{:keymap-notify} event returns the current state of the keyboard. @var{:keymap-notify} is generated immediately after every @var{:enter-notify} and @var{:focus-in}. @table @var @item window @itemx event-window Type @var{window}. The window receiving an @var{:enter-notify} or @var{:focus-in} event. @item keymap Type (@var{bit-vector 256}). A bit-vector containing the logical state of the keyboard. Each bit set to 1 indicates that the corresponding key is currently pressed. The vector is represented as 32 bytes. For @emph{n} from 0 to 7, byte @emph{n} (from 0) contains the bits for keys 8@emph{n} to 8@emph{n}+7, with the least significant bit in the byte representing key 8@emph{n}. @end table @end deftp @deftp {Event Type} :mapping-notify The X server reports @var{:mapping-notify} events to all clients. There is no mechanism to express disinterest in this event. The X server generates this event type whenever a client application calls one of the following: @itemize @bullet @item @var{set-modifier-mapping} to indicate which keycodes to use as modifiers (the status reply must be @var{:mapping-success}) @item @var{change-keyboard-mapping} to change the keyboard mapping @item @var{set-pointer-mapping} to set the pointer mapping (the status reply must be @var{:mapping-success}) @end itemize @table @var @item request Type (@code{member :modifier :keyboard :pointer}). Indicates the kind of change that occurred--@var{:modifier} for a successful @var{set-modifier-mapping}, @var{:keyboard} for a successful @var{change-keyboard-mapping}, and @var{:pointer} for a successful @var{set-pointer-mapping}. @item start Type @var{card8}. If request is @var{:keyboard}, then @emph{start} and @emph{count} indicate the range of altered keycodes. @item count Type @var{card8}. If request is @var{:keyboard}, then @emph{start} and @emph{count} indicate the range of altered keycodes. @end table @end deftp @node Exposure Events, Window State Events, Keyboard and Pointer State Events, Event Types @subsection Exposure Events The X server cannot guarantee that a window's content is preserved when the window is obscured or reconfigured. X requires client applications to be capable of restoring the contents of a previously-invisible window region whenever it is exposed. Therefore, the X server sends events describing the exposed window and its exposed region. For a simple window, a client can choose to redraw the entire content whenever any region is exposed. For a complex window, a client can redraw only the exposed region. @deftp {Event Type} :exposure @anchor{:exposure} Selected by: @var{:exposure}. An @var{:exposure} event is sent when redisplay is needed for a window region whose content has been lost. Redisplay is needed when one of the following occurs: @itemize @bullet @item A region is exposed for a window and the X server has no backing store for the region @item A region of a viewable window is obscured and the X server begins to honor the window's backing-store attribute of @var{:always} or @var{:when-mapped} @item The X server begins to honor an unviewable window's backing-store attribute of @var{:always} or @var{:when-mapped}. @end itemize The regions needing redisplay are decomposed into an arbitrary set of rectangles, and an @var{:exposure} event is generated for each rectangle. For a given action causing @var{:exposure} events, the set of events for a given window are guaranteed to be reported contiguously. @var{:exposure} events are never generated for @var{:input-only} windows. All @var{:exposure} events caused by a hierarchy change are generated after any hierarchy event (@var{:unmap-notify}, @var{:map-notify}, @var{:configure-notify},@var{:gravity-notify}, or @var{:circulate-notify}) caused by that change. All @var{:exposure} events on a given window are generated after any @var{:visibility-notify} event on that window, but it is not required that all @var{:exposure} events on all windows be generated after all visibility events on all windows. The ordering of @var{:exposure} events with respect to @var{:focus-out}, @var{:enter-notify}, and @var{:leave-notify} events is not constrained. @table @var @item window @itemx event-window Type @var{window}. The window needing redisplay. @item x Type @var{card16}. The position of the left edge of the region to redisplay, relative to the @emph{event-window}. @item y Type @var{card16}. The position of the top edge of the region to redisplay, relative to the @emph{event-window}. @item width Type @var{card16}. The width of the region to redisplay. @item height Type @var{card16}. The height of the region to redisplay. @item count Type @var{card16}. If count is zero, then no more @var{:exposure} events for this window follow. If count is nonzero, then at least that many more @var{:exposure} events for this window follow (and possibly more). @end table @end deftp @deftp {Event Type} :graphics-exposure A @var{:graphics-exposure} event is generated by a call to @var{copy-area} or @var{copy-plane} when the exposures attribute of the graphics context is @var{:on}. A @var{:graphics-exposure} event reports a destination region whose content cannot be computed because the content of the corresponding source region has been lost. For example, the missing source region may be obscured or may lie outside the current source drawable size. For a given action causing @var{:graphics-exposure} events, the set of events for a given destination are guaranteed to be reported contiguously. @table @var @item drawable @itemx event-window Type @var{drawable}. The destination drawable for the @var{copy-area} or @var{copy-plane} function. @item x Type @var{card16}. The position of the left edge of the destination region, relative to the @emph{drawable}. @item y Type @var{card16}. The position of the top edge of the destination region, relative to the @emph{drawable}. @item width Type @var{card16}. The width of the destination region. @item height Type @var{card16}. The height of the destination region. @item count Type @var{card16}. If count is zero then no more @var{:graphics-exposure} events for the @emph{drawable} follow. If count is nonzero then at least that many more @var{:graphics-exposure} events for the @emph{drawable} follow (and possibly more). @item major Type @var{card8}. The major opcode for the graphics request generating the event (62 for @var{copy-area}, 63 for @var{copy-plane}). @item minor Type @var{card16}. The minor opcode for the graphics request generating the event (0 for both @var{copy-area} and @var{copy-plane}). @end table @end deftp @deftp {Event Type} :no-exposure A @var{:no-exposure} event is generated by a call to @var{copy-area} or @var{copy-plane} when the exposures attribute of the graphics context is @var{:on}. If no @var{:graphics-exposure} events are generated, then a single @var{:no-exposure} event is sent. @table @var @item drawable @itemx event-window Type @var{drawable}. The destination drawable for the @var{copy-area} or @var{copy-plane} function. @item major Type @var{card8}. The major opcode for the graphics request generating the event (62 for @var{copy-area}, 63 for @var{copy-plane}). @item minor Type @var{card16}. The minor opcode for the graphics request generating the event (0 for both @var{copy-area} and @var{copy-plane}). @end table @end deftp @node Window State Events, Structure Control Events, Exposure Events, Event Types @subsection Window State Events The following paragraphs describe the events that can be received when a window becomes: @itemize @bullet @item Created @item Destroyed @item Invisible @item Mapped @item Moved @item Reparented @item Resized @item Restacked @item Unmapped @item Visible @end itemize @deftp {Event Type} :circulate-notify Selected by: @var{:structure-notify} on a window or @var{:substructure-notify} on its parent. A @var{:circulate-notify} event is generated whenever a window is actually restacked as a result of a client application calling @var{circulate-window-up} or @var{circulate-window-down}. @table @var @item event-window Type @var{window}. The window receiving the event. @item window Type @var{window}. The window that was restacked. @item place Type (@var{member :top :bottom}). If place is @var{:top}, the @emph{window} is now on top of all siblings. Otherwise, it is below all siblings. @end table @end deftp @deftp {Event Type} :configure-notify Selected by: @var{:structure-notify} on a window or @var{:substructure-notify} on its parent. The @var{:configure-notify} event is generated when the position or size of a window actually changes as a result of a client application setting its @emph{x}, @emph{y}, @emph{width}, @emph{height}, or @emph{border-width} attributes. @table @var @item event-window Type @var{window}. The window receiving the event. @item window Type @var{window}. The window that was moved or resized. @item x Type @var{int16}. @emph{x} and @emph{y} specify the new upper-left corner position of the @emph{window} relative to its parent. @item y Type @var{int16}. @emph{x} and @emph{y} specify the new upper-left corner position of the @emph{window} relative to its parent. @item width Type @var{card16}. @emph{width} and @emph{height} specify the new size of the @emph{window} interior. @item height Type @var{card16}. @emph{width} and @emph{height} specify the new size of the @emph{window} interior. @item border-width Type @var{card16}. The new @emph{window} border width. @item above-sibling Type (@var{or null window}). The sibling immediately below the @emph{window}. If above-sibling is @var{nil}, then the @emph{window} is below all of its siblings. @item override-redirect-p Type @var{boolean}. @emph{override-redirect-p} is true if the override-redirect attribute of the @emph{window} is @var{:on}; otherwise, it is @var{nil}. See @var{window-override-redirect} in @ref{Window Attributes}. @end table The X server can report @var{:create-notify} events to clients wanting information about creation of windows. The X server generates this event whenever a client application creates a window by calling @var{create-window}. To receive this event type in a client application, you @code{setf} the @var{:substructure-notify} as the event-mask in the parent window's event-mask slot. @end deftp @deftp {Event Type} :create-notify Selected by: @var{:substructure-notify}. The @var{:create-notify} event is generated when a @emph{window} is created and is sent to the @emph{parent} window. @table @var @item parent @itemx event-window Type @var{window}. The parent window receiving the event. @item window Type @var{window}. The new window created. @item x Type @var{int16}. @emph{x} and @emph{y} specify the initial upper-left corner position of the @emph{window} relative to the parent. @item y Type @var{int16}. @emph{x} and @emph{y} specify the initial upper-left corner position of the @emph{window} relative to the parent. @item width Type @var{card16}. @emph{width} and @emph{height} specify the initial size of the @emph{window} interior. @item height Type @var{card16}. @emph{width} and @emph{height} specify the initial size of the @emph{window} interior. @item border-width Type @var{card16}. The initial @emph{window} border width. @item override-redirect-p Type @var{boolean}. @emph{override-redirect-p} is true if the override-redirect attribute of the @emph{window} is @var{:on}; otherwise, it is @var{nil}. See @var{window-override-redirect} in @ref{Window Attributes}. @end table @end deftp @deftp {Event Type} :destroy-notify Selected by: @var{:structure-notify} on a window or @var{:substructure-notify} on its parent. The @var{:destroy-notify} event is generated when a @emph{window} is destroyed. The ordering of the @var{:destroy-notify} events is such that for any given window, @var{:destroy-notify} is generated on all inferiors of a window before @var{:destroy-notify} is generated on the @emph{window}. The ordering among siblings and across subhierarchies is not otherwise constrained. @table @var @item event-window Type @var{window}. The window receiving the event. @item window Type @var{window}. The window that was destroyed. @end table @end deftp @deftp {Event Type} :gravity-notify Selected by: @var{:structure-notify} on a window or @var{:substructure-notify} on its parent. The X server can report @var{:gravity-notify} events to clients wanting information about when a @emph{window} is moved because of a change in the size of its parent. The X server generates this event whenever a client application actually moves a child window as a result of resizing its parent by calling @var{with-state} with the appropriate arguments set. @table @var @item event-window Type @var{window}. The window receiving the event. @item window Type @var{window}. The window that was moved. @item x Type @var{int16}. x and y specify the new upper-left corner position of the @emph{window} relative to its parent. @item y Type @var{int16}. x and y specify the new upper-left corner position of the @emph{window} relative to its parent. @end table @end deftp @deftp {Event Type} :map-notify Selected by: @var{:structure-notify} on a window or @var{:substructure-notify} on its parent. The X server can report @var{:map-notify} events to clients wanting information about which windows are mapped. The X server generates this event type whenever a client application changes the @emph{window}'s state from unmapped to mapped by calling @var{map-window} or @var{map-subwindow}. To receive this event type, you @var{setf :structure-notify} as the event-mask on the @emph{window}'s @var{event-mask} slot. You can also receive this event type by @code{setf}ing the @var{:substructure-notify} event-mask on the parent window. @table @var @item event-window Type @var{window}. The window receiving the event. @item window Type @var{window}. The window that was mapped. @item override-redirect-p Type @var{boolean}. @emph{override-redirect-p} is true if the override-redirect attribute of the @emph{window} is @var{:on}; otherwise, it is @var{nil}. See @var{window-override-redirect} in @ref{Window Attributes}. @end table @end deftp @deftp {Event Type} :reparent-notify Selected by: @var{:structure-notify} on a window or @var{:substructure-notify} on its old or new parent. The @var{:reparent-notify} event is generated when a @emph{window} is reparented. @table @var @item event-window Type @var{window}. The window receiving the event. @item window Type @var{window}. The window that was reparented. @item parent Type @var{window}. The new parent of the @emph{window}. @item x Type @var{int16}. x and y specify the upper-left corner position of the @emph{window} relative to its new @emph{parent}. @item y Type @var{int16}. x and y specify the upper-left corner position of the @emph{window} relative to its new @emph{parent}. @item override-redirect-p Type @var{boolean}. @emph{override-redirect-p} is true if the override-redirect attribute of the @emph{window} is @var{:on}; otherwise, it is @var{nil}. See @var{window-override-redirect} in @ref{Window Attributes}. @end table @end deftp @deftp {Event Type} :unmap-notify Selected by: @var{:structure-notify} on a window or @var{:substructure-notify} on its parent. The @var{:unmap-notify} event is generated when a mapped @emph{window} is unmapped. @table @var @item event-window Type @var{window}. The window receiving the event. @item window Type @var{window}. The window that was unmapped. @item configure-p Type @var{boolean}. @emph{configure-p} is true if the @emph{window} has a win-gravity attribute of @var{:unmap}, and the event was generated because @emph{window}'s parent was resized. @end table @end deftp @deftp {Event Type} :visibility-notify Selected by: @var{:visibility-change}. The @var{:visibility-notify} event is sent when the visibility of a @emph{window} changes. @var{:visibility-notify} events are never generated on @var{:input-only} windows. For the purposes of this event, the visibility of the @emph{window} is not affected by its subwindows. All @var{:visibility-notify} events caused by a hierarchy change are generated after any hierarchy event caused by that change (for example, @var{:unmap-notify}, @var{:map-notify}, @var{:configure-notify}, @var{:gravity-notify}, or @var{:circulate-notify}). Any @var{:visibility-notify} event on a given window is generated before any @var{:exposure} events on that window, but it is not required that all @var{:visibility-notify} events on all windows be generated before all @var{:exposure} events on all windows. The ordering of @var{:visibility-notify} events with respect to @var{:focus-out}, @var{:enter-notify}, and @var{:leave-notify} events is not constrained. @table @var @item window @itemx event-window Type @var{window}. The window that changed in visibility. @item state Type (@var{member :unobscured :partially-obscured} @var{:fully-obscured}). When the @emph{window} was either unviewable or it was viewable and at least partially obscured, and the @emph{window} changed to viewable and completely unobscured, then @emph{state} is @var{:unobscured}. When the @emph{window} was either unviewable or it was viewable and completely obscured, and the @emph{window} changed to viewable and partially obscured, then @emph{state} is @var{:partially-obscured}. When the @emph{window} was either unviewable or it was at least partially visible, and the @emph{window} changed to viewable and completely obscured, then @emph{state} is @var{:fully-obscured}. @end table @end deftp @node Structure Control Events, Client Communications Events, Window State Events, Event Types @subsection Structure Control Events The following paragraphs describe events used to @emph{redirect} client requests that reconfigure, restack, or map a window. Structure control events are typically used only by window managers and not by ordinary client applications. Structure control events report redirected requests, allowing a window manager to modify the requests before they are actually performed. However, if the override-redirect attribute of a window is @var{:on}, then no requests are redirected and no structure control events are generated. @deftp {Event Type} :circulate-request The @var{:circulate-request} event is generated when a client application calls @var{circulate-window-up} or @var{circulate-window-down} with a window that has the override-redirect attribute @var{:off}. The @emph{window} argument specifies the window to be restacked, and @emph{place} specifies what the new position in the stacking order should be (either @var{:top} or @var{:bottom}). Selected by: @var{:substructure-redirect} on @emph{parent}. @table @var @item parent @itemx event-window Type @var{window}. The window receiving the event. The receiving client must have selected @var{:substructure-redirect} on this window. @item window Type @var{window}. The window to be restacked. @item place Type @code{(member :top :bottom)}. The new stacking priority requested for @emph{window}. @end table @end deftp @deftp {Event Type} :colormap-notify Selected by: @var{:colormap-change}. The @var{:colormap-notify} event is generated with @emph{new-p} @var{t} when the @emph{colormap} associated with a @emph{window} is changed, installed, or uninstalled. @table @var @item window @itemx event-window Type @var{window}. The window receiving the event. @item colormap Type @code{(or null colormap)}. The colormap attribute of the window. @item new-p Type @var{boolean}. If @emph{new-p} is true, then the @emph{window}'s colormap attribute has changed to the given @emph{colormap}. Otherwise, the @emph{window}'s colormap attribute has not, but the @emph{colormap} has been installed or uninstalled. @item installed-p Type @var{boolean}. If @emph{installed-p} is true, then the @emph{colormap} is currently installed. @end table @end deftp @deftp {Event Type} :configure-request Selected by:@var{:substructure-redirect} on parent. The @var{:configure-request} event is generated when a client program sets the @emph{x}, @emph{y}, @emph{width}, @emph{heigh}t, @emph{border-width} or stacking priority attributes of a window that has the override-redirect attribute @var{:off}. @table @var @item parent @itemx event-window Type @var{window}. The window receiving the event. The receiving client must have selected @var{:substructure-redirect} on this window. @item window Type @var{window}. The window to be reconfigured. @item x Type @var{int16}. @emph{x} and @emph{y} specify the requested upper-left corner position of the @emph{window} relative to the parent. If either @emph{x} or @emph{y} is not specified in the value-mask, then it is set to the current window position. @item y Type @var{int16}. @emph{x} and @emph{y} specify the requested upper-left corner position of the @emph{window} relative to the @emph{parent}. If either @emph{x} or @emph{y} is not specified in the @emph{value-mask}, then it is set to the current window position. @item width @itemx height Type @var{card16}. @emph{width} and @emph{height} specify the requested size of the @emph{window} interior. If either @emph{width} or @emph{height} is not specified in the @emph{value-mask}, then it is set to the current window size. @item border-width Type @var{card16} The requested @emph{window} border width. If @emph{border-width} is not specified in the @emph{value-mask}, then it is set to the current window @emph{border-width}. @item stack-mode Type @code{(member :above :below :top-if :bottom-if :opposite)}. @emph{stack-mode} and @emph{above-sibling} specify the requested stacking priority of the @emph{window}. If @emph{stack-mode} is not specified in the @emph{value-mask}, then it is set to @var{:above}. @item above-sibling Type (@var{or null window}). @emph{stack-mode} and @emph{above-sibling} specify the requested stacking priority of the @emph{window}. If @emph{above-sibling} is not specified in the @emph{value-mask}, then it is set to @var{nil}. @item value-mask Type @var{mask16}. Specifies the changed @emph{window} attributes contained in the redirected client request. Each 1 bit specifies that the corresponding attribute was changed. @end table @end deftp @deftp {Event Type} :map-request Selected by: @var{:substructure-redirect} on parent. The @var{:map-request} event is generated when a client application maps a @emph{window} that has the override-redirect attribute @var{:off}. @table @var @item parent @itemx event-window Type @var{window}. The window receiving the event. The receiving client must have selected @var{:substructure-redirect} on this window. @item window Type @var{window}. The window to be mapped. @end table @end deftp @deftp {Event Type} :resize-request Selected by: @var{:resize-redirect}. The @var{:resize-request} event is generated when a client program sets the @emph{width} or @emph{height} attributes of a @emph{window} that has the override-redirect attribute @var{:off}. @table @var @item window @itemx event-window Type @var{window}. The window to be resized. @item width @itemx height Type @var{card16}. @emph{width} and @emph{height} specify the requested size of the wi@emph{ndow} interior. If either @emph{width} or @emph{height} was unchanged in the client request, then it is set to the current window size. @end table @end deftp @node Client Communications Events, Declaring Event Types, Structure Control Events, Event Types @subsection Client Communications Events The client communications events discussed in the following paragraphs are: @var{:client-message}, @var{:property-notify}, @var{:selection-clear}, @var{:selection-request}, and @var{:selection-notify}. @deftp {Event Type} :client-message The @var{:client-message} event is generated exclusively by client calls to @var{send-event}. The X server places no interpretation on the @emph{type} or content of @emph{data} sent in a @var{:client-message}. A client can neither select @var{:client-message} events nor avoid receiving them. @table @var @item window @itemx event-window Type @var{window}. The window receiving the event. @item type Type @var{keyword}. An xatom keyword that specifies the type of client message. Interpretation of the type is determined solely by agreement between the sending and receiving clients. @item format Type (@var{member 8 16 32}). An integer that specifies whether @emph{data} should be viewed as a sequence of 8-bit, 16-bit, or 32-bit quantities. @item data Type @code{(sequence integer)}. The data content of the client message. @emph{data} always consists of 160 bytes -- depending on format, either 20 8-bit values, 10 16-bit values or 5 32-bit values. The amount of this data actually used by a particular client message depends on the type. @end table @end deftp @deftp {Event Type} :property-notify Selected by: @var{:property-change}. The @var{:property-notify} event is generated when a window property is changed or deleted. @table @var @item window @itemx event-window Type @var{window}. The window receiving the event. @item atom Type @var{keyword}. The property that was changed or deleted. @item state Type @code{(member :new-value :deleted)}. @emph{state} is @var{:new-value} if the property was changed using @var{change-property} or @var{rotate-properties}, even if zero-length data was added or if all or part of the property was replaced with identical data. @emph{state} is @var{:deleted} if the property was deleted using @var{delete-property} or @var{get-property}. @item time Type @var{timestamp}. The server time when the property was changed or deleted. @end table @end deftp @deftp {Event Type} :selection-clear The @var{:selection-clear} event is reported to the previous owner of a @emph{selection} when the owner of the @emph{selection} is changed. The selection owner is changed by a client using @code{setf}. A client can neither select @var{:selection-clear} events nor avoid receiving them. @table @var @item window @itemx event-window Type @var{window}. The window losing ownership of the @emph{selection}. @item selection Type @var{keyword}. The name of the selection. @item time Type @var{timestamp}. The last-change time recorded for the @emph{selection}. @end table @end deftp @deftp {Event Type} :selection-notify The @var{:selection-notify} event is sent to a client calling @var{convert-selection}. @var{:selection-notify} reports the result of the client request to return the current value of a @emph{selection} into a particular form. @var{:selection-notify} is sent using @var{send-event} by the owner of the selection or (if no owner exists) by the X server. A client can neither select @var{:selection-notify} events nor avoid receiving them. @var{NOTE:} Standard conventions for inter-client communication require the following additional steps in processing a @var{:selection-notify} event: @enumerate @item The client receiving this event should call @var{get-property} to return the converted selection value. @item After receiving the selection value, the property should then be deleted (either by using the @var{:delete-p} argument to @var{get-property} or by calling @var{delete-property}). @end enumerate @table @var @item window @itemx event-window Type @var{window}. The requestor window given in the call to @var{convert-selection}. @item selection Type @var{keyword}. The selection to be converted. @item target Type @var{keyword}. An @var{xatom} specifying the type of the converted selection value. This is the same target type given in the call to @var{convert-selection}. @item property Type @code{(or null keyword)}. The window property containing the converted selection. If the property is @var{nil}, then either the @emph{selection} has no owner or the owner could not perform the conversion to the @emph{target} type. @item time Type @var{timestamp}. The timestamp from the client call to @var{convert-selection}. @end table @end deftp @deftp {Event Type} :selection-request The @var{:selection-request} event is reported to the owner of a selection when a client calls @var{convert-selection}. This event requests the selection owner to convert the current value of a @emph{selection} into a specified form and to return it to the requestor. A client can neither select @var{:selection-request} events nor avoid receiving them. The selection owner should respond to a @var{:selection-request} event by performing the following steps: @enumerate @item Convert the current @emph{selection} value to the @emph{target} type. @item Store the converted selection value in the @emph{property}. If @emph{property} is @var{nil}, then the owner should choose the @emph{property}. @item Call @var{send-event} to send a @var{:selection-notify} event to the @emph{requestor} containing the @emph{property} with the converted value. If the @emph{selection} could not be converted to the @emph{target} type, then a @var{nil} @emph{property} should be sent. The @var{:selection}, @var{:target}, and @var{:time} arguments to @var{send-event} should be the same as those received in the @var{:selection-request} event. The event-mask argument to @var{send-event} should be @var{nil}; that is, the @var{:selection-notify} event should be sent to client that created the @emph{requestor}. @end enumerate @var{NOTE:} Standard conventions for inter-client communication require the following additional steps in processing a @var{:selection-request} event: @enumerate @item The property used to store the selection value must belong to the requestor. @item If the property is @var{nil}, the target type @var{atom} should be used as the property name. @item If the window did not actually own the selection at the given time, the request should be refused, just as if it could not be converted to the target type. @end enumerate @table @var @item window @itemx event-window Type @var{window}. The selection owner receiving the event. @item requestor Type @var{window}. The window requesting the converted @emph{selection}. @item selection Type @var{keyword}. The selection to be converted. @item target Type @var{keyword}. An @var{xatom} specifying the type of the converted @emph{selection} value. @item property Type @code{(or null keyword)}. A requestor window property. @item time Type @var{timestamp}. The timestamp sent in the client @var{convert-selection} request. @end table @end deftp @node Declaring Event Types, , Client Communications Events, Event Types @subsection Declaring Event Types CLX uses the @var{declare-event} macro to define the event slot symbols that access the contents of X events. Most client applications do not need to use @var{declare-event} because the declarations for all core X events are already defined by CLX. Programmers using extensions to the X protocol can use @var{declare-event} to allow CLX to handle new event types returned by an extended X server. @defmac declare-event event-codes &rest slot-declarations Defines a mapping between event slot symbols and the data items in event messages received from an X server. The @emph{event-codes} argument gives the event type keyword for the event described. If several event types share the same slots, then @emph{event-codes} can be a list of event type keywords. @emph{slot-declarations} is a list containing an element for each event data item. The order of @emph{slot-declarations} corresponds to the order of event data items defined by the X protocol. Each element of @emph{slot-declarations} is a list of the form (@emph{type slot-name}*), where @emph{type} is a Common Lisp type specifier and @emph{slot-name} is a slot name symbol. The effect of such a list is to declare that the next data items in the event have the given data @emph{type} and are associated with the given @emph{slot-name} symbols. @emph{slot-name} can also be a list of slot name symbols; in this case, each symbol in the list is an alias that refers to the same event data item. @table @var @item event-codes An event type keyword or a list of event type keywords. @item slot-declarations A list of clauses defining event slot symbols. @end table @end defmac @node Releasing Queued Events, , Event Types, Events and Input @section Releasing Queued Events A client grabbing the keyboard or pointer can freeze the reporting of events on that device. When an input device is thus frozen, the server queues events until explicitly requested to release them by the grabbing client. CLX programs can use the @var{allow-events} function to release queued events from a frozen input device. @defun allow-events display mode &optional time @table @var @item display A @var{display}. @item mode One of: @var{:async-pointer}, @var{:sync-pointer}, @var{:reply-pointer}, @var{:async-keyboard}, @var{:sync-keyboard}, @var{:replay-keyboard}, @var{:async-both}, @var{:sync-both}. @item time A @var{timestamp}. @end table Releases some queued events if the client has caused a device to freeze. The request has no effect if the @emph{time} is earlier than the last-grab time of the most recent active grab for the client, or if the @emph{time} is later than the current server time. If @emph{time} is @var{nil}, the current server time is used. The effect of this function depends on the specified @emph{mode}. @itemize @bullet @item @var{:async-pointer} -- If the pointer is frozen by the client, pointer event processing continues normally. If the pointer is frozen twice by the client on behalf of two separate grabs, @var{:async-pointer} releases events for both grab@emph{s}. @var{:async-pointer} has no effect if the pointer is not frozen by the client, but the pointer need not be grabbed by the client. @item @var{:sync-pointer} -- If the pointer is frozen and actively grabbed by the client, pointer event processing continues normally until the next @var{:button-press} or @var{:button-release} event is reported to the client, at which time the pointer again appears to freeze. However, if the reported event causes the pointer grab to be released, the pointer does not freeze. @var{:sync-pointer} has no effect if the pointer is not frozen by the client, or if the pointer is not grabbed by the client. @item @var{:replay-pointer} -- If the pointer is actively grabbed by the client and is frozen as the result of an event having been sent to the client (either from the activation of a @var{grab-button}, or from a previous @var{allow-events} with mode @var{:sync-pointer}, but not from a @var{grab-pointer}), the pointer grab is released and that event is completely reprocessed, but this time ignoring any passive grabs at or above (towards the root) the @var{grab-window} of the grab just released. The request has no effect if the pointer is not grabbed by the client, or if the pointer is not frozen as the result of an event. @item @var{:async-keyboard} -- If the keyboard is frozen by the client, keyboard event processing continues normally. If the keyboard is frozen twice by the client on behalf of two separate grabs, @var{:async-keyboard} releases events for both grabs. @var{:async-keyboard} has no effect if the keyboard is not frozen by the client, but the keyboard need not be grabbed by the client. @item @var{:sync-keyboard} -- If the keyboard is frozen and actively grabbed by the client, keyboard event processing continues normally until the next @var{:key-press} or @var{:key-release} event is reported to the client, at which time the keyboard again appears to freeze. However if the reported event causes the keyboard grab to be released, the keyboard does not freeze. @var{:sync-keyboard} has no effect if the keyboard is not frozen by the client, or if the keyboard is not grabbed by the client. @item @var{:replay-keyboard} -- If the keyboard is actively grabbed by the client and is frozen as the result of an event having been sent to the client (either from the activation of a grab-key, or from a previous @var{allow-events} with mode @var{:sync-keyboard}, but not from a @var{grab-keyboard}), the keyboard grab is released and that event is completely reprocessed, but this time ignoring any passive grabs at or above (towards the root) the @var{grab-window} of the grab just released. The request has no effect if the keyboard is not grabbed by the client, or if the keyboard is not frozen as the result of an event. @item @var{:sync-both} -- If both pointer and keyboard are frozen by the client, event processing (for both devices) continues normally until the next @var{:button-press}, @var{:button-release}, @var{:key-press}, or @var{:key-release} event is reported to the client for a grabbed device (button event for the pointer, key event for the keyboard). At this time, the devices again appear to freeze. If the reported event causes the grab to be released, the devices do not freeze. However, if the other device is still grabbed, then a subsequent event for it will still cause both devices to freeze. @var{:sync-both} has no effect unless both pointer and keyboard are frozen by the client. If the pointer of keyboard is frozen twice by the client on behalf of two separate grabs, @var{:sync-both} @emph{thaws} for both, but a subsequent freeze for @var{:sync-both} will only freeze each device once. @item @var{:async-both} -- If the pointer and the keyboard are frozen by the client, event processing for both devices continues normally. If a device is frozen twice by the client on behalf of two separate grabs, @var{:async-both} @emph{thaws} for both. @var{:async-both} has no effect unless both pointer and keyboard are frozen by the client. @end itemize @var{:async-pointer}, @var{:sync-pointer}, and @var{:replay-pointer} have no effect on processing of keyboard events. @var{:async-keyboard}, @var{:sync-keyboard}, and @var{:replay-keyboard} have no effect on processing of pointer events. It is possible for both a pointer grab and a keyboard grab to be active simultaneously by the same or different clients. When a device is frozen on behalf of either grab, no event processing is performed for the device. It is possible for a single device to be frozen due to both grabs. In this case, the freeze must be released on behalf of both grabs before events can again be processed. @end defun @node Resources, Control Functions, Events and Input, Top @chapter Resources Users need a way to specify preferences for various user interface values (for example, colors, fonts, title strings, and so forth). Applications need a consistent method for determining the default interface values that are specific to them. It is also useful if application interface values can be modified by users without changes to the program code. For example, this capability can make it easy to change the color scheme of a user interface. In CLX, such interface values are referred to as @emph{resources}. CLX defines functions for storing and retrieving interface resources from a resource database. A user can store various user interface values as resources in a resource database; a CLX application can then read these resource values and modify its user interface accordingly. @var{NOTE:} The general term @emph{resource} refers to any application user interface value stored in a resource database. The term @emph{server resource} is used more specifically to refer to the types of objects allocated by an X server and referenced by clients (for example, windows, fonts, graphics contexts, and so forth). @menu * Resource Binings:: * Basic Resource Database Functions:: * Accessing Resource Values:: * Resource Database Files:: @end menu @node Resource Binings, Basic Resource Database Functions, Resources, Resources @section Resource Binings Conceptually, a resource database is a set of resource name-value pairs (or @emph{resource bindings}). The name in a resource binding is a list that is the concatenation of a @emph{path list} and an @emph{attribute name}. A path list is a list of symbols (or strings) that corresponds to a path through a tree-structured hierarchy. For example, the path: @lisp '(top middle bottom) @end lisp corresponds to a three-level hierarchy in which @code{middle} is the child of @code{top}, and @code{bottom} is the child of @code{middle}. Typically, the path of a resource name corresponds to a path in a hierarchy of windows, and each symbol/string names a window in the hierarchy. However, the first element of the path can also represent the overall name of the entire program, and subsequent path elements can refer to an application-specific hierarchy of resource names not strictly related to windows. In addition, a resource name can contain a partially-specified path list. The asterisk symbol (*) is a wildcard that can correspond to any sequence of levels in the hierarchy (including the null sequence). For example, the path: @lisp '(top * bottom) @end lisp corresponds to a hierarchy of two or more levels in which @code{top} is at the top level and @code{bot-} @code{tom} is at the bottom level. An element of a path list can be the name of an individual window or the name of a class of windows. The final element of a resource name list is an attribute name. This symbol (or string) identifies a specific attribute of the object(s) named by the preceding path list. The attribute name can also be the symbol * or the string "*", in which case the resource name refers to all attributes of the path object(s). However, this form of resource name is rarely useful. Some examples of resource bindings are shown below. In these examples, assume that @code{mail} is the resource name of a mail reading application. @code{mail} uses a window of the class @code{button} whose name is @code{reply}. @multitable {Resource Name} {Resource Value} @item @code{(mail screen-1 reply background)} @tab @code{'green} @item @code{(mail * background)} @tab @code{'red} @item @code{(* button background)} @tab @code{'blue} @end multitable These resource bindings specify the following: @itemize @bullet @item The @code{background} attribute resource of @code{mail} application@emph{'}s @code{reply} button has the value of @code{green} on @code{screen-1}. @item The @code{background} attribute for the rest of the @code{mail} application is always @code{red} on all screens. @item In general, the @code{background} attribute for all @code{button} windows is @code{blue}. @end itemize @node Basic Resource Database Functions, Accessing Resource Values, Resource Binings, Resources @section Basic Resource Database Functions A @var{resource-database} structure is a CLX object that represents a set of resource bindings. The following paragraphs describe the CLX functions used to: @itemize @bullet @item Create a resource database @item Add a resource binding @item Remove a resource binding @item Merge two resource databases @item Map a function over the contents of a resource database @end itemize @defun make-resource-database @table @var @item resource-database Type @var{resource-database}. @end table Returns an empty resource database. @end defun @defun add-resource database name-list value @table @var @item database The @var{resource-database} for the new resource binding. @item name-list A list containing strings or symbols specifying the name for the resource binding. @item value The value associated with the @emph{name-list} in the resource binding. This can be an object of any type. @end table Adds the resource binding specified by @emph{name-list} and @emph{value} to the given @emph{database}. Only one value can be associated with the @emph{name-list} in the @emph{database}. This function replaces any value previously associated with the @emph{name-list}. @end defun @defun delete-resource database name-list @table @var @item database The @var{resource-database} containing the resource binding. @item name-list A list containing strings or symbols specifying the name for the deleted resource binding. @end table Removes the resource binding specified by @emph{name-list} from the given @emph{database}. @end defun @defun map-resource database function &rest args @table @var @item database A @var{resource-database}. @item function A @var{function} object or function symbol. @item args A list of arguments to the @emph{function}. @end table Calls the function for each resource binding in the @emph{database}. For each resource binding consisting of a @emph{name-list} and a @emph{value}, the form (@var{apply} @emph{function name-list value args}) is executed. @end defun @defun merge-resources from-database to-database @table @var @item from-database The @var{resource-database} from which resource bindings are read. @item to-database The @var{resource-database} to which resource bindings are added. @end table Merges the contents of the @emph{from-database} with the @emph{to-database}. @var{map-resource} invokes @var{add-resource} in order to add each resource binding in the @emph{from-database} to the @emph{to-database}. The updated @emph{to-database} is returned. @table @var @item to-database Type @var{resource-database}. @end table @end defun @node Accessing Resource Values, Resource Database Files, Basic Resource Database Functions, Resources @section Accessing Resource Values The power and flexibility of resource management is the result of the way resource values in a resource database are accessed. A resource binding binding stored in the database generally contains only a partial resource name consisting of a mixture of name and class identifiers and wildcard elements (that is, *). To look up a resource value, an application program starts with two resource name lists of the same length containing no wildcard elements -- a @emph{complete resource name} and a @emph{complete} @emph{resource class}. The lookup algorithm returns the value for the resource binding whose resource name is the closest match to the complete name and class given. The definition of @emph{closest match} takes into account the top-down, parent-child hierarchy of resource names and also the distinction between individual names and class names. @menu * Complete Names and Classes:: * Matching Resource Names:: * Resource Access Functions:: @end menu @node Complete Names and Classes, Matching Resource Names, Accessing Resource Values, Accessing Resource Values @subsection Complete Names and Classes A resource binding contains a resource name list that can contain names, class names, or a mixture of both. A class name is a symbol or string that represents a group of related objects. The set of names used as class names are not specified by CLX. Instead, class names are defined by agreement between those who use class names when creating resource bindings (that is, users) and those who use class names when accessing resource values (that is, application programmers). In order to access a value in a resource database, an application uses a key consisting of two items: a @emph{complete resource name} and a @emph{complete resource class}. A complete resource name is a resource name list containing no wildcard elements. A complete resource class is a list of exactly the same form. The distinction between a complete resource name and a complete resource class lies in how they are used to access resource bindings. The elements of a complete resource name are interpreted as names of individual objects; the elements of a complete resource class are interpreted as names of object classes. The complete resource name and class lists used in a resource database access must have the same length. Like any resource name list, a complete resource name consists of a path list and an attribute name. The first path list element is typically a symbol (or string) identifying the application as a whole. The second element can be a screen root identifier. Subsequent elements can be identifiers for each ancestor window of an application window. Thus, a path list typically identifies a specific window by tracing a path to it through the application window hierarchy. The final element of a complete resource name (its attribute name) is typically the name of a specific attribute of the window given by the path list (for example, @code{'background}). An attribute name can refer to a feature associated with the window by the application but not by the X server (for example, a font identifier). Similarly, a complete resource class typically represents a path to a window in the application window hierarchy and a specific window attribute. However, a complete resource class contains the class name for each window and for the window attribute. For instance, in the previous example, the @code{mail} application can attempt to look up the value of the @code{background} resource for the @code{reply button} window by using the following complete resource name: @lisp (mail screen-1 reply background) @end lisp and the following complete resource class: @lisp (application root button fill) @end lisp This complete resource name contains a path list identifying the reply button window -- @code{(mail screen-1 reply)} -- and an attribute name for the window background. The corresponding resource class contains the class names for the same path list and window attribute. @node Matching Resource Names, Resource Access Functions, Complete Names and Classes, Accessing Resource Values @subsection Matching Resource Names The resource lookup algorithm searches a specified resource data base and returns the value for the resource binding whose resource name is the closest match to a given complete resource name and class. The intent of the lookup algorithm is to formalize an intuitive notion of the closest match. Precedence is given to a match which begins @emph{higher} in the parent-child contact hierarchy. This allows a resource binding with a partial name to define a resource value shared by all members of a window subtree. For example, suppose the resource database contained the following resource bindings: @multitable {Resource Name} {Resource Value} @item @code{(mail * background)} @tab @code{'red} @item @code{(* reply background)} @tab @code{'blue} @end multitable Suppose an application program searched by using the following complete resource name: @lisp (mail screen-1 reply background) @end lisp then the closest matching value returned would be @code{'red}. Precedence is given to the more specific match. A name match is more specific than a class match. Either a name or class match is more specific than a wildcard match. For example, suppose the resource database contained the following resource bindings: @multitable {Resource Name} {Resource Value} @item @code{(mail * background)} @tab @code{'red} @item @code{(mail * fill)} @tab @code{'blue} @end multitable Suppose an application program searched by using the following complete resource name and complete resource class: @lisp (mail screen-1 reply background) (application root button fill) @end lisp then the closest matching value returned would be @code{'red}. However, suppose the resource database contained the following resource bindings: @multitable {Resource Name} {Resource Value} @item @code{(mail * background)} @tab @code{'red} @item @code{(mail * button background)} @tab @code{'blue} @end multitable then the closest matching value returned would be @code{'blue}. @node Resource Access Functions, , Matching Resource Names, Accessing Resource Values @subsection Resource Access Functions The following paragraphs describe the CLX functions used to return a value from a resource database. @defun get-resource database attribute-name attribute-class path-name path-class @table @var @item database A @var{resource-database}. @item attribute-name A string or symbol giving an attribute name from a complete resource name. @item attribute-class A string or symbol giving an attribute class name from a complete resource class. @item path-name The path list from a complete resource name. @emph{path-name} and @emph{path-class} must have the same length. @item path-class The path list from a complete resource class. @emph{path-name} and @emph{path-class} must have the same length. @end table Returns the value of the resource binding in the @emph{database} whose resource name most closely matches the complete resource name/class given by the @emph{path-name}, @emph{path-class}, @emph{attribute-name}, and @emph{attribute-class}. The lookup algorithm implements the precedence rules described previously to determine the closest match. When comparing name elements, case is significant only if both elements are strings; otherwise, element matching is case-insensitive. @table @var @item value Type @var{t}. @end table @end defun @defun get-search-table database path-name path-class @table @var @item database A @var{resource-database}. @item path-name The path list from a complete resource name. @emph{path-name} and @emph{path-class}must have the same length. @item path-class The path list from a complete resource class. @emph{path-name} and @emph{path-class} must have the same length. @end table Returns a table containing the subset of the @emph{database} that matches the @emph{path-name} and @emph{path-class}. Resources using the same @emph{path-name} and @emph{path-class} can be accessed much more efficiently by using this table as an argument to @var{get-search-resource}. @table @var @item search-table Type @var{list}. @end table @end defun @defun get-search-resource table attribute-name attribute-class @table @var @item table A search table returned by @var{get-search-table}. @item attribute-name A string or symbol giving an attribute name from a complete resource name. @item attribute-class A string or symbol giving an attribute class name from a complete resource class. @end table Returns the value of the resource binding in the search @emph{table} that most closely matches the @emph{attribute-name} and @emph{attribute-class}. The @emph{table} is computed by @var{get-search-table} and represents a set of resource bindings. The closest match is determined by the same algorithm used in @var{get-resource}. The following two forms are functionally equivalent: @lisp (get-resource database attribute-name attribute-class path-name path-class) (get-search-resource (get-search-table database path-name path-class) attribute-name attribute-class) @end lisp However, the hard part of the search is done by @var{get-search-table}. Looking up values for several resource attributes that share the same path list can be done much more efficiently with calls to @var{get-search-resource}. @table @var @item value Type @var{t}. @end table @end defun @node Resource Database Files, , Accessing Resource Values, Resources @section Resource Database Files X users and application programs can save resource bindings in a file, using a standard file format shared by all X clients. The following paragraphs describe the CLX functions used to convert between the standard external format of resource files and the internal resource-database format used by application programs. @defun read-resources database pathname &key :key :test :test-not @table @var @item database The @var{resource-database} to merge. @item pathname A pathname for the resource file to read. @item :key A function used to convert a value from the resource file into a resource binding value. @item :test @itemx :test-not Functions used to select which resource bindings from the resource file are merged with the @emph{database}. @end table Reads resource bindings from a resource file in standard X11 format and merges them with the given resource @emph{database}. The @var{:key} function is called to convert a file resource value into the value stored in the @emph{database}. By default, @var{:key} is @var{#'identity}. The @var{:test} and @var{:test-not} functions are predicates that select resource bindings to merge, based on the result of the @var{:key} function. For each file resource binding consisting of a @emph{resource-name} and a @emph{resource-value}, the @var{:test} (or @var{:test-not}) function is called with the arguments @emph{resource-name} and (@var{funcall} @emph{key resource-value}). @table @var @item database Type @var{resource-database}. @end table @end defun @defun write-resources database pathname &key :write :test :test-not @table @var @item database The @var{resource-database} to write. @item pathname A pathname of the file to write. @item :write A function for writing resource values. @item :test @itemx :test-not Functions used to select which resource bindings from the resource file are merged with the @emph{database}. @end table Writes resource bindings found in the @emph{database} to the file given by the @emph{pathname}. The output file is written in the standard X11 format. The @var{:write} function is used for writing resource values; the default is @var{#'princ}. The @var{:write} function is passed two arguments: a @emph{resource-value} and a @emph{stream}. The @var{:test} and @var{:test-not} functions are predicates which select resource bindings to write. For each resource binding consisting of a @emph{resource-name} and a @emph{resource-value}, the @var{:test} (or @var{:test-not}) function is called with the arguments @emph{resource-name} and @emph{resource-value}. @end defun @node Control Functions, Extensions, Resources, Top @chapter Control Functions @menu * Grabbing the Server:: * Pointer Control:: * Keyboard Control:: * Keyboard Encodings:: * Client Termination:: * Managing Host Access:: * Screen Saver:: @end menu @node Grabbing the Server, Pointer Control, Control Functions, Control Functions @section Grabbing the Server Certain cases may require that a client demand exclusive access to the server, causing the processing for all other clients to be suspended. Such exclusive access is referred to as @emph{grabbing the server}. CLX provides functions to grab and release exclusive access to the server. These function should be used rarely and always with extreme caution, since they have the potential to disrupt the entire window system for all clients. @defun grab-server display @table @var @item display A @var{display}. @end table Disables processing of requests and close-downs on all connections other than the one on which this request arrived. @end defun @defun ungrab-server display @table @var @item display A @var{display}. @end table Restarts processing of requests and close-downs on other connections. @end defun @defmac with-server-grabbed display &body body Grabs the @emph{display} server only within the dynamic extent of the @emph{body}. @var{ungrab-server} is automatically called upon exit from the @emph{body}. This macro provides the most reliable way for CLX clients to grab the server. @table @var @item display A @var{display}. @item body The forms to execute while the server is grabbed. @end table @end defmac @node Pointer Control, Keyboard Control, Grabbing the Server, Control Functions @section Pointer Control The following paragraphs describe the CLX functions used to: @itemize @bullet @item Return or change the pointer acceleration and acceleration threshold @item Return or change the mapping of pointer button numbers @end itemize @defun change-pointer-control display &key :acceleration :threshold @table @var @item display A @var{display}. @item :acceleration A number for the acceleration ratio. @item :threshold The number of pixels required for acceleration to take effect. @end table Changes the acceleration and/or the acceleration threshold of the pointer for the @emph{display}. The @var{:acceleration} number is used as a multiplier, typically specified as a rational number of the form @emph{C/P}, where @emph{C} is the number of pixel positions of cursor motion displayed for @emph{P} units of pointer device motion. The acceleration only occurs if the pointer moves more that @var{:threshold} pixels at once, and only applies to the motion beyond the @var{:threshold}. Either @var{:acceleration} or @var{:threshold} can be set to @var{:default}, that restores the default settings of the server. @end defun @defun pointer-control display @table @var @item display A @var{display}. @end table Returns the acceleration and threshold for the @emph{display} pointer. @table @var @item acceleration @itemx threshold Type @var{number}. @end table @end defun @defun pointer-mapping display &key (:result-type 'list) @table @var @item display A @var{display}. @item :result-type The type of sequence to return. @end table Returns or (with @code{setf}) changes the mapping of button numbers for the @emph{display} pointer. The @var{:result-type} is not used when changing the mapping. If element @emph{i} of the mapping sequence is @emph{j}, then the events from pointer button @emph{j} are reported by the server as events for button @emph{i}+1. (Note that pointer buttons are numbered beginning with one, while the mapping sequence itself is indexed normally from zero.) If element @emph{i} of the mapping sequence is zero, then button @emph{i}+1 is disabled and can no longer generate input events. No two elements of the mapping can have the same non-zero value. The length of the mapping sequence indicates the actual number of buttons on the device. When changing the mapping, the new mapping must have this same length. @table @var @item mapping Type @var{sequence} or @var{card8}@emph{.} @end table @end defun @node Keyboard Control, Keyboard Encodings, Pointer Control, Control Functions @section Keyboard Control The following paragraphs describe the CLX functions used to: @itemize @bullet @item Return or change keyboard controls @item Ring the keyboard bell @item Return or change the mapping of modifiers @item Return the current up/down state of all keys @end itemize @defun bell display &optional (percent-from-normal 0) @table @var @item display A @var{display}. @item percent-from-normal An integer (-100 through 100). @end table Rings the bell on the keyboard at a volume relative to the base volume for the keyboard, if possible. Percent can range from -100 to 100 inclusive, or else a Value error occurs. The following is the bell volume when percent is non-negative: @lisp (- (+ @emph{base percent}) (@var{quotient} (* @emph{base percent}) 100)) @end lisp and when percent is negative: @lisp (+ @emph{base} (@var{quotient} (* @emph{base percent}) 100)) @end lisp @end defun @defun change-keyboard-control display &key :key-click-percent :bell-percent :bell-pitch :bell-duration :led :led-mode :key :auto-repeat-mode @table @var @item display A @var{display}. @item :key-click-percent An integer (0 100). @item :bell-percent An integer (0 100). @item :bell-pitch A @var{card16}. @item :bell-duration A @var{card16}. @item :led A @var{card8}. @item :led-mode Either @var{:on} or @var{:off}. @item :key A @var{card8} keycode. @item :auto-repeat-mode Either @var{:on}, @var{:off}, or @var{:default}. @end table Changes the various aspects of the keyboard. The keyword arguments specify which controls to change. The @var{:key-click-percent} keyword sets the volume for key clicks, if possible. A value of 0 implies off, while a value of 100 implies loud. Setting @var{:key-click-percent} to @var{:default} restores the default value. The @var{:bell-percent} sets the base volume for the bell between 0 (off) and 100 (loud) if possible. Setting @var{:bell-percent} to @var{:default} restores the default value. The @var{:bell-pitch} sets the pitch (specified in Hz) of the bell, if possible. Setting the @var{:bell-pitch} to @var{:default} restores the default value. The @var{:bell-duration} sets the duration ( specified in milliseconds) of the bell, if possible. Setting @var{:bell-pitch} to @var{:default} restores the default. Note that a bell generator connected with the console but not directly on the keyboard is treated as if it were part of the keyboard. If both @var{:led-mode} and @var{:led} are specified, then the state of that LED is changed, if possible. If only @var{:led-mode} is specified, the state of all LEDs are changed, if possible. At most 32 LEDs are supported, numbered from one. No standard interpretation of the LEDs are defined. If both @var{:auto-repeat-mode} and @var{:key} are specified, the auto-repeat mode of that key is changed, if possible. If only @var{:auto-repeat-mode} is specified, the global auto-repeat mode for the entire keyboard is changed, if possible, without affecting the per-key settings. An error occurs if @var{:key} is specified without @var{:auto-repeat-mode}. @end defun @defun keyboard-control display @table @var @item display A @var{display}. @end table Returns the current control values for the keyboard. For the LEDs, the least significant bit of @emph{led-mask} corresponds to LED one, and each one bit in @emph{led-mask} indicates an LED that is lit. @emph{auto-repeats} is a bit vector; each one bit indicates that auto-repeat is enabled for the corresponding key. The vector is represented as 32 bytes. Byte @emph{n} (from 0) contains the bits for keys 8@emph{n} to 8@emph{n}+7, with the least significant bit in the byte representing key 8@emph{n}. @table @var @item key-click-percent @itemx bell-percent Type @var{card8}. @item bell-pitch @itemx bell-duration Type @var{card16}. @item led-mask Type @var{card32}. @item global-auto-repeat Either @var{:on} or @var{:off}. @item auto-repeats Type @var{bit-vector}. @end table @end defun @defun modifier-mapping display @table @var @item display A @var{display}. @end table Returns the set of keycodes used for each modifier on the @emph{display} keyboard. Each return value is a list of the @var{card8} keycodes used for each modifier key. The order of keycodes within each list is server-dependent. @table @var @item shift-keycodes @itemx lock-keycodes @itemx control-keycodes @itemx mod1-keycodes @itemx mod2-keycodes @itemx mod3-keycodes @itemx mod4-keycodes @itemx mod5-keycodes Type @var{list} of @var{card8}. @end table @end defun @defun query-keymap display @table @var @item display A @var{display}. @end table Returns a bit vector that describes the state of the keyboard. Each one bit indicates that the corresponding key is currently pressed. The vector is represented as 32 bytes. Byte @emph{n} (from 0) contains the bits for keys 8@emph{n} to 8@emph{n}+7, with the least significant bit in the byte representing key 8@emph{n}. @table @var @item keymap Type @var{bit-vector} 256. @end table @end defun @defun set-modifier-mapping display &key :shift :lock :control :mod1 :mod2 :mod3 :mod4 :mod5 @table @var @item display A @var{display}. @item :shift @itemx :lock @itemx :control @itemx :mod1 @itemx :mod2 @itemx :mod3 @itemx :mod4 @itemx :mod5 A sequence of @var{card8} keycodes for the given modifier. @end table Changes the set of keycodes mapped to the specified modifier keys on the @emph{display} keyboard. Each keyword argument contains a sequence of new @var{card8} keycodes for a specific modifier. The return value indicates whether the change was completed successfully. A status of @var{:failed} is returned if hardware limitations prevent the requested change. For example, multiple keycodes per modifier may not be supported, up transitions on a given keycode may not be supported, or autorepeat may be mandatory for a given keycode. If @var{:failed} is returned, the mappings for all modifiers remain unchanged. A status of @var{:device-busy} is returned if a new keycode given for a modifier was not previously mapped to that modifier and is currently in the down state. In this case, the mappings for all modifiers remain unchanged. @table @var @item status One of @var{:success}, @var{:failed}, or @var{:device-busy}. @end table @end defun @node Keyboard Encodings, Client Termination, Keyboard Control, Control Functions @section Keyboard Encodings Handling the great diversity of keyboard devices and international language character encodings is a difficult problem for interactive programs that need to receive text input but must also be portable. The X Window System solves this problem by using different sets of encodings for device keys (@emph{keycodes}) and for character symbols (@emph{keysyms}). Each X server maintains a @emph{keyboard mapping} that associates keycodes and keysyms, and which can be returned or changed by client programs. To handle text input, a CLX client program must follow these steps: @enumerate @item Receive a @var{:key-press} (or @var{:key-release}) event containing a keycode. @item Convert the keycode into its corresponding keysym, based on the current keyboard mapping. See @var{keycode->keysym}. @item Convert the keysym into the corresponding Common Lisp character. See @var{keysym->character}. @end enumerate @menu * Keycodes and Keysyms:: * Keyboard Mapping:: * Using Keycodes and Keysyms:: @end menu @node Keycodes and Keysyms, Keyboard Mapping, Keyboard Encodings, Keyboard Encodings @subsection Keycodes and Keysyms A @emph{keycode} represents a physical (or logical) key. In CLX, keycodes are values of type (@var{integer} 8 255). A keycode value carries no intrinsic information, although server implementors may attempt to encode geometry (for example, matrix) information in some fashion so it can be interpreted in a server- dependent fashion. The mapping between keys and keycodes cannot be changed. A @emph{keysym} is an encoding of a symbol on the cap of a key. In CLX, keysyms are values of type @var{card32}. The set of defined keysyms include the ISO Latin character sets (1-4), Katakana, Arabic, Cyrillic, Greek, Technical, Special, Publishing, APL, Hebrew, and miscellaneous keys found on keyboards (RETURN, HELP, TAB, and so on). The encoding of keysyms is defined by the X Protocol. A list of keysyms is associated with each keycode. The length of the list can vary with each keycode. The list is intended to convey the set of symbols on the corresponding key. By convention, if the list contains a single keysym and if that keysym is alphabetic and case distinction is relevant, then it should be treated as equivalent to a two-element list of the lowercase and uppercase keysyms. For example, if the list contains the single keysym for uppercase A, the client should treat it as if it were a pair with lowercase as the first keysym and uppercase A as the second keysym. For any keycode, the first keysym in the list should be chosen as the interpretation of a key press when no modifier keys are down. The second keysym in the list normally should be chosen when the @var{:shift} modifier is on, or when the @var{:lock} modifier is on and @var{:lock} is interpreted as @var{:shift-lock}. When the @var{:lock} modifier is on and is interpreted as @var{:caps-lock}, it is suggested that the @var{:shift} modifier first be applied to choose a keysym, but if that keysym is lowercase alphabetic, the corresponding uppercase keysym should be used instead. Other interpretations of @var{:caps-lock} are possible; for example, it may be viewed as equivalent to @var{:shift-lock}, but only applying when the first keysym is lowercase alphabetic and the second keysym is the corresponding uppercase alphabetic. No interpretation of keysyms beyond the first two in a list is suggested here. No spatial geometry of the symbols on the key is defined by their order in the keysym list, although a geometry might be defined on a vendor-specific basis. The X server does not use the mapping between keycodes and keysyms. Rather, the X server stores the mapping merely for reading and writing by clients. @node Keyboard Mapping, Using Keycodes and Keysyms, Keycodes and Keysyms, Keyboard Encodings @subsection Keyboard Mapping The X server maintains a keyboard mapping that associates each keycode with one or more keysyms. The following paragraphs describe the CLX functions used to return or change the mapping of keycodes. @defun change-keyboard-mapping display keysyms &key (:start 0) :end @table @var @item display A @var{display}. @item keysyms A two-dimensional array of keysym (@var{card32}) values. @item :start @itemx :end Indexes for the subsequence of @emph{keysyms} used. @item :first-keycode A @var{card8} defining the first keycode mapping changed. @end table (@var{:first-keycode :start}) Changes the mapping of keycodes to @emph{keysyms}. A @var{:mapping-notify} event is generated for all clients. The new @emph{keysyms} are specified as a two-dimensional array in which: (@var{aref} @emph{keysyms} (+ @var{:start} @emph{i}) @emph{j}) is @emph{keysym j} associated with keycode (+ @var{:first-keycode} @emph{i}). The maximum number of @emph{keysyms} associated with any one keycode is given by: (@var{array-dimension} @emph{keysyms} 1) @emph{keysyms} should contain @var{nil} elements to represent those keysyms that are undefined for a given keycode. @var{:start} and @var{:end} define the subsequence of the @emph{keysyms} array that defines the new mapping, and the number of keycode mappings changed. By default, @var{:end} is given by: (@var{array-dimension} @emph{keysyms} 0) The keycodes whose mappings are changed are given by @var{:first-keycode} through the following: (+ @var{:first-keycode} (- @var{:end :start}) -1) keycodes outside this range of are not affected. @var{:first-keycode} must not be less than (@var{display-min-keycode} @emph{display}), and the last keycode modified must not be greater than (@var{display-max-keycode} @emph{display}). @end defun @defun keyboard-mapping display &key :first-keycode :start :end :data @table @var @item display A @var{display}. @item :first-keycode A @var{card8} defining the first keycode mapping returned. @item :start @itemx :end Indexes for the subsequence of the returned array which is modified. @item :data If given, a two-dimensional array to receive the returned keysyms. @end table Returns the keysyms mapped to the given range of keycodes for the @emph{display} keyboard. The mappings are returned in the form of a two-dimensional array of @var{card32} keysym values. The @var{:data} argument, if given, must be a two-dimensional array in which the returned mappings will be stored. In this case: (@var{array-dimension :data} 1) defines the maximum number of keysyms returned for any keycode. Otherwise, a new array is created and returned. Upon return: (@var{aref} @emph{mappings} (+ @emph{:start i}) @emph{j}) will contain keysym @emph{j} associated with keycode (+ @var{:first-keycode i}) (or @var{nil}, if keysym @emph{j} is undefined for that keycode). @var{:first-keycode} specifies the first keycode whose mapping is returned; by default, @var{:first-keycode} is (@var{display-min-keycode} @emph{display}). @var{:start} and @var{:end} define the subsequence of the returned array in which the returned mappings are stored. By default, @var{:start} is given by @var{:first-keycode} and @var{:end} is given by: (1+ (@var{display-max-keycode} @emph{display})) @var{:first-keycode} must not be less than (@var{display-min-keycode} @emph{display}), and the last keycode returned must not be greater than (@var{display-max-keycode} @emph{display}). @table @var @item mappings Type (@var{array card32} (* *)). @end table @end defun @node Using Keycodes and Keysyms, , Keyboard Mapping, Keyboard Encodings @subsection Using Keycodes and Keysyms The following paragraphs describe the CLX functions used to: @itemize @bullet @item Convert a keycode into a keysym @item Convert a keysym into a character @end itemize @defun keycode->keysym display keycode keysym-index @table @var @item display A @var{display}. @item keycode A @var{card8}. @item keysym-index A @var{card8}. @end table Returns the @emph{keysym} at the given @emph{keysym-index} from the keysym list for the @emph{keycode} in the current keyboard mapping for the @emph{display} server. @emph{This function was called keycode-keysym in X11R4 and older versions of CLX.} @table @var @item keysym Type @var{keysym}. @end table @end defun @defun keysym->character display keysym &optional (state 0) @table @var @item display A @var{display}. @item keysym A @var{keysym}. @item state A @var{mask16}. @end table Returns the @emph{character} associated with the @emph{keysym} and the @emph{state}. The @emph{state} is a @var{mask16} bit mask representing the state of the @emph{display} modifier keys and pointer buttons. See @var{state-mask-key} in @ref{Data Types}. If the @emph{keysym} does not represent a Common Lisp character, then @var{nil} is returned. @emph{This function was called keysym-character in X11R4 and older versions of CLX.} The @emph{state} determines the bits attribute of the returned @emph{character}, as follows: @table @var @item :control @var{char-control-bit} @item :mod-1 @var{char-meta-bit} @item :mod-2 @var{char-super-bit} @item :mod-3 @var{char-hyper-bit} @end table @c Of course *we* know that this mapping is bull shit! @table @var @item character Type @var{character} or @var{null}. @end table @end defun @node Client Termination, Managing Host Access, Keyboard Encodings, Control Functions @section Client Termination The CLX functions affecting client termination are discussed in the following paragraphs. When a display connection to an X server is closed, whether by an explicit call to @var{close-display} or by some external condition, the server automatically performs a sequence of operations to clean up server state information associated with the closed connection. The effect of these operations depends the @emph{close-down mode} and the @emph{save-set} that the client has specified for the closed display connection. The close-down mode of a display determines whether server resources allocated by the connection are freed or not. The save-set identifies windows that will remain after the connection is closed. The display save-set is used primarily by window managers that reparent the top-level windows of other clients. For example, such a window manager can automatically create a frame window that encloses a top-level client window, along with a set of controls used for window management. Ordinarily, termination of the window manager client would then destroy all client windows! However, the window manager can prevent this by adding to its save-set those windows created by other clients that should be preserved. When a display connection closes, an X server performs the following operations: @enumerate @item For each selection owned by a window created on the connection, the selection owner is set to @var{nil}. @item An active or passive grab established for a window created on the connection is released. @item If the connection has grabbed the server, the server is ungrabbed. @item Server resources and colormap cells allocated by the connection are freed and destroyed, depending on the close-down mode, as follows: @itemize @bullet @item @var{:retain-permanent} -- All resources are marked @emph{permanent}, and no resources are destroyed. These resources can later be destroyed by a call to @var{kill-client}. @item @var{:retain-temporary} -- All resources are marked @emph{temporary}, and no resources are destroyed. These resources can later be destroyed by a call to @var{kill-client} or @var{kill-temporary-clients}. @item @var{:destroy} -- All resources are destroyed. @end itemize @end enumerate When server resources allocated by a display connection are destroyed -- whether by closing the connection with close-down mode @var{:destroy} or by later calling @var{kill-client} or @var{kill-temporary-clients} -- then an X server performs the following operations on each member of the save-set before actually destroying resources. @enumerate @item If the save-set window is a descendant of a window created on the connection, the save-set window is reparented. The new parent is the closest ancestor such that the save-set window is no longer a descendant of any window created on the connection. The position of the reparented window with respect to its parent remains unchanged. @item If the save-set window is unmapped, then it is mapped. @end enumerate If the last connection open to an X server is closed with close-down mode @var{:destroy}, the server resets its state to restore all initial defaults. The server state after reset is the same as its initial state when first started. When an X server resets, it performs the following operations: @itemize @bullet @item All permanent and temporary server resources from previously-closed connections are destroyed. @item All but the predefined atoms are deleted. @item All root window properties are deleted. @item All device control attributes and mappings are restored to their original default values. @item The default background and cursor for all root windows are restored. @item The default font path is restored. @item The input focus is set to @var{:pointer-root}. @item The access control list is reset. @end itemize The following paragraphs describe the CLX functions used to: @itemize @bullet @item Add or remove a window from a display save-set. @item Return or change the display close-down mode. @item Force a connection to be closed or all its server resources to be destroyed. @item Force a connection to be closed and all temporary resources to be destroyed. @end itemize @defun add-to-save-set window @table @var @item window A @var{window}. @end table Adds the specified @emph{window} to the save-set of the @emph{window} display. The @emph{window} must have been created by some other display. Windows are removed automatically from the save-set when they are destroyed. @end defun @defun close-down-mode display @table @var @item display A @var{display}. @end table Returns and (with @code{setf}) sets the close-down mode of the client's resources at connection close. @table @var @item mode One of @var{:destroy}, @var{:retain-permanent}, or @var{:retain-temporary}. @end table @end defun @defun kill-client display resource-id @table @var @item display A @var{display}. @item resource-id A valid @var{card29} resource ID. @end table Closes the display connection which created the given @emph{resource-id}. The @emph{resource-id} must be valid, but need not belong to the given @emph{display}. If the closed connection was previously open, the connection is closed according to its close-down mode. Otherwise, if the connection had been previously terminated with close-down mode @var{:retain-permanent} or @var{:retain-temporary}, then all its retained server resources -- both permanent and temporary -- are destroyed. @end defun @defun kill-temporary-clients display @table @var @item display A @var{display}. @end table Closes the @emph{display} connection and destroys all retained temporary server resources for this and all previously-terminated connections. If the @emph{display} connection was previously open, the connection is closed according to its close-down mode. Otherwise, if the @emph{display} connection had been previously terminated with close-down mode @var{:retain-permanent} or @var{:retain-temporary}, then all its retained server resources -- both permanent and temporary -- are destroyed. @end defun @defun remove-from-save-set window @table @var @item window A @var{window}. @end table Removes the specified @emph{window} from the save-set of the @emph{window} display. The @emph{window} must have been created by some other display. Windows are removed automatically from the save-set when they are destroyed. @end defun @node Managing Host Access, Screen Saver, Client Termination, Control Functions @section Managing Host Access An X server maintains a list of hosts from which client programs can be run. Only clients executing on hosts that belong to this @emph{access control list} are allowed to open a connection to the server. Typically, the access control list can be changed by clients running on the same host as the server. Some server implementations can also implement other authorization mechanisms in addition to, or in place of, this mechanism. The action of this mechanism can be conditional based on the authorization protocol name and data received by the server at connection setup. The following paragraphs describe the CLX functions used to: @itemize @bullet @item Add or remove hosts on the access control list. @item Return the hosts on the access control list. @item Return or change the state of the access control list mechanism @end itemize @defun access-control display @table @var @item display A @var{display}. @end table Returns and (with @code{setf}) changes the state of the access control list mechanism for the @emph{display} server. Returns true if access control is enabled; otherwise, @var{nil} is returned. If enabled, the access control list is used to validate each client during connection setup. Only a client running on the same host as the server is allowed to enable or disable the access control list mechanism. @table @var @item enabled-p Type @var{boolean}. @end table @end defun @defun access-hosts display &key (:result-type 'list) @table @var @item display A @var{display}. @item :result-type The type of hosts sequence to return. @end table Returns a sequence containing the @emph{hosts} that belong to the access control list of the @emph{display} server. Elements of the returned @emph{hosts} sequence are either strings or some other type of object recognized as a host name by @var{add-access-host} and @var{remove-access-host}. The second returned value specifies whether the access control list mechanism is currently enabled or disabled (see @var{access-control}). @table @var @item hosts @var{sequence} of @var{string}. @item enabled-p Type @var{boolean}. @end table @end defun @defun add-access-host display host @table @var @item display A @var{display}. @item host A host name. Either a string or some other implementation-dependent type. @end table Adds the specified @emph{host} to the access control list. Only a client running on the same host as the server can change the access control list. @end defun @defun remove-access-host display host @table @var @item display A @var{display}. @item host A host name. Either a string or some other implementation-dependent type. @end table Removes the specified @emph{host} from the access control list. Only a client running on the same host as the server can change the access control list. @end defun @node Screen Saver, , Managing Host Access, Control Functions @section Screen Saver To prevent monitor damage, an X server implements a screen saver function which blanks screens during periods of unuse. The screen saver can be in one of three states: @itemize @bullet @item Disabled -- No screen blanking is done and screen content remains unchanged. @item Deactivated -- The server is being used. When the server input devices are unused for a specific amount of time, the screen saver becomes activated. @item Activated -- The server input devices are unused. The screen saver blanks all server screens or displays a server-dependent image. As soon as an input event from either the pointer or the keyboard occurs, the screen saver is deactivated and its timer is reset. @end itemize The following paragraphs describe the CLX functions used to: @itemize @bullet @item Return or change screen saver control values. @item Activate or reset the screen saver @end itemize @defun activate-screen-saver display @table @var @item display A @var{display}. @end table Activates the screen saver for the @emph{display} server. @end defun @defun reset-screen-saver display @table @var @item display A @var{display}. @end table Deactivates the screen saver for the @emph{display} server (if necessary) and resets its timer, just as if a pointer or keyboard event had occurred. @end defun @defun screen-saver display @table @var @item display A @var{display}. @end table Returns the current control values for the @emph{display} server screen saver. See @var{set-screen-saver}. @table @var @item timeout @itemx period Type @var{int16}. @item blanking @itemx exposures One of @var{:yes} or @var{:no}. @end table @end defun @defun set-screen-saver display timeout period blanking exposures @table @var @item display A @var{display}. @item timeout Specifies the delay until timeout takes over. @item period Specifies the periodic change interval, if used. @item blanking Specifies whether the blanking option is available. @item exposures Specifies whether exposures are allowed during blanking. @end table Changes the current control values for the @emph{display} server screen saver. The screen saver is reset. The screen saver is also disabled if: @itemize @bullet @item @emph{timeout} is zero, or @item Both @emph{blanking} and @emph{exposures} are disabled and the server cannot regenerate the screen contents without sending @var{:exposure} events. @end itemize The @emph{timeout} specifies the (non-negative) number of seconds of input device inactivity that must elapse before the screen saver is activated. The @emph{timeout} can be set to @var{:default} to restore the server default timeout interval. If @emph{blanking} is @var{:yes} and the screen hardware supports blanking, blanking is enabled; that is, the screen saver will simply blank all screens when it is activated. @emph{blanking} can be set to @var{:default} to restore the server default state for blanking. If @emph{exposures} is @var{:yes}, exposures are enabled. If exposures are enabled, or if the server is capable of regenerating screen contents without sending @var{:exposure} events, the screen saver will display some server-dependent image when activated. Frequently, this image will consist of a repeating animation sequence, in which case @emph{period} specifies the ( non-negative) number of seconds for each repetition. A @emph{period} of zero is a hint that no repetition should occur. @end defun @node Extensions, Errors, Control Functions, Top @chapter Extensions @menu * Extensions (Extensions):: * SHAPE - The X11 Nonrectangular Window Shape Extension:: * RENDER - A new rendering system for X11:: * DPMS - The X11 Display Power Management Signaling Extension:: * BIG-REQUESTS - Big Requests Extension:: @end menu @node Extensions (Extensions), SHAPE - The X11 Nonrectangular Window Shape Extension, Extensions, Extensions @section Extensions The X Window System is based on a core protocol which can be extended to provide new functionality. An extension is generally represented by an additional set of requests or event types that are implemented by an X server supporting the extension. By definition, a client program using an extension may not be portable to other servers. However, extensions allow different server implementations and different sites to add their own special features to X, without disrupting clients that rely only on the core protocol. Extensions are identified by assigning them unique name strings and major protocol numbers. A client program can request an X server to use a protocol extension by furnishing the extension protocol number as an argument to @var{open-display}. The X Consortium maintains a registry of standard extension names and protocol numbers. The following paragraphs describe the CLX functions used to: @itemize @bullet @item List all supported extensions. @item Find out if a given extension is supported. @end itemize @defun list-extensions display &key (:result-type 'list) @table @var @item display A @var{display}. @item :result-type The type of name sequence to return. @end table Returns a sequence containing the @emph{names} of all extensions supported by the @emph{display} server. @table @var @item names Type @var{sequence} of @var{string}. @end table @end defun @defun query-extension display name @table @var @item display A @var{display}. @item name An extension name string. @end table Returns the @emph{major-opcode} for the given extension @emph{name} support by the @emph{display} server. If the extension is not supported, only @var{nil} values are returned. The extension @emph{name} must contain only ISO Latin-1 characters; case is significant. If the extension involves additional event types, the @emph{first-event} returned is the base event type code for new events; otherwise, the @emph{first-event} is @var{nil}. If the extension involves additional error codes, the @emph{first-error} returned is the base code for new errors; otherwise, the @emph{first-error} is @var{nil}. The formats of error and event messages sent by the server are completely defined by the extension. @table @var @item major-opcode @itemx first-event @itemx first-error Type @var{card8} or @var{null}. @end table @end defun @node SHAPE - The X11 Nonrectangular Window Shape Extension, RENDER - A new rendering system for X11, Extensions (Extensions), Extensions @section SHAPE - The X11 Nonrectangular Window Shape Extension This documentation is yet to be written. @node RENDER - A new rendering system for X11, DPMS - The X11 Display Power Management Signaling Extension, SHAPE - The X11 Nonrectangular Window Shape Extension, Extensions @section RENDER - A new rendering system for X11 XRENDER is an experimental step in building a newer and modern graphics rendering system that can keep up with the demands of visual appearance on current user interfaces. The X Rendering Extension (Render) introduces digital image composition as the foundation of a new rendering model within the X Window System. Rendering geometric figures is accomplished by client-side tesselation into either triangles or trapezoids. Text is drawn by loading glyphs into the server and rendering sets of them. @menu * Picture formats:: * The picture object:: * Glyphs and Glyphsets:: * Using glyphs:: * Errors (Extensions):: @end menu @node Picture formats, The picture object, RENDER - A new rendering system for X11, RENDER - A new rendering system for X11 @subsection Picture formats The following is what the X protocol rendering spec has to say about picture formats. @url{http://www.xfree86.org/~keithp/render/protocol.html} The @var{picture-format} object holds information needed to translate pixel values into red, green, blue and alpha channels. The server has a list of picture formats corresponding to the various visuals on the screen. There are two classes of formats, Indexed and Direct. Indexed picture-formats hold a list of pixel values and RGBA values while Direct picture-formats hold bit masks for each of R, G, B and A. The server must support a direct @var{picture-format} with 8 bits each of red, green, blue and alpha as well as a direct @var{picture-format} with 8 bits of red, green and blue and 0 bits of alpha. The server must also support direct @var{picture-format}s with 1, 4 and 8 bits of alpha and 0 bits of r, g and b. Pixel component values lie in the closed range [0,1]. These values are encoded in a varying number of bits. Values are encoded in a straight forward manner. For a component encoded in m bits, a binary encoding b is equal to a component value of b/(2^m-1). A direct @var{picture-format} with zero bits of alpha component is declared to have alpha == 1 everywhere. A direct @var{picture-format} with zero bits of red, green and blue is declared to have red, green, blue == 0 everywhere. If any of red, green or blue components are of zero size, all are of zero size. Direct @var{picture-format}s never have colormaps and are therefore screen independent. Indexed @var{picture-format}s never have alpha channels and the direct component is all zeros. Indexed @var{picture-format}s always have a colormap in which the specified colors are allocated read- only and are therefore screen dependent. These are valid accessors for picture-format objects. @table @var @item picture-format-display A display @item picture-format-id The X protocol @var{resource-id} @item picture-format-type @code{(member :indexed :direct)} @item picture-format-depth Bitdepth as @var{card8} @item picture-format-red-byte A bitmask @item picture-format-green-byte @itemx picture-format-blue-byte @itemx picture-format-alpha-byte @itemx picture-format-colormap A @var{colormap} or nil @end table @node The picture object, Glyphs and Glyphsets, Picture formats, RENDER - A new rendering system for X11 @subsection The picture object The @var{picture} object contains a @var{drawable}, a @var{picture-format} and some rendering state. More than one @var{picture} can refer to the same @var{drawable}. A @var{picture} is almost like a @var{gcontext}, except that it is tied in use to a single @var{drawable}. Another similarity it has with @var{gcontext} is that it is a cached object. Updates are not processed until the @var{picture} is used. This also makes it possible to query state, as there is no such request in XRENDER to do so. The @var{picture} object is also a lot like a @var{drawable}, in that it is used as a target for graphics operations. Or at least that it occurs where you would expect a drawable in XRENDER requests. @defun render-create-picture drawable &key format picture ... @table @var @item drawable A @var{Drawable} @item format A @var{picture-format} @item picture An existing @var{picture} object to use, one is created if not specified. @item repeat @code{(member :off :on)} @item alpha-map A @var{picture} or @var{:none} @item alpha-x-origin @var{int16} @item alpha-y-origin @var{int16} @item clip-x-origin @var{int16} @item clip-y-origin @var{int16} @item clip-mask A @var{Pixmap} or @var{:none} @item graphics-exposures @code{(member :off :on)} @item subwindow-mode @code{(member :clip-by-children :include-inferiors)} @item poly-edge @code{(member :sharp :smooth)} @item poly-mode @code{(member :precise :imprecise)} @item dither @var{xatom} or @var{:none} @item component-alpha @code{(member :off :on)} @end table This request creates a Picture object. If the @emph{drawable} is a Window then the Red, Green and Blue masks must match those in the visual for the window else a Match error is generated. @table @var @item picture A @var{picture} @end table @end defun @defun render-free-picture picture This request deletes all server resources associated with the picture object. @table @var @item picture The @var{picture} object to free @end table @end defun @node Glyphs and Glyphsets, Using glyphs, The picture object, RENDER - A new rendering system for X11 @subsection Glyphs and Glyphsets A glyph in XRENDER is an alpha mask and an associated orgin, advancement and numeric id. The application refers to them by the numeric id. Glyphs are stored in a glyph-set. The client is responsible for making sure the glyphs it uses are stored in the glyph-set, or there will be a Glyph-error. @defun render-create-glyph-set format &key glyph-set @table @var @item format A @var{picture-format} for the alpha masks that this font will use. @item glyph-set An optional @var{glyph-set} object to initialize with a server side glyphset resource. @end table Creates an initially empty glyph-set for the client to use. @emph{Format} must be a Direct format. When it contains RGB values, the glyphs are composited using component-alpha True, otherwise they are composited using component-alpha False. @end defun @defun render-reference-glyph-set existing-glyph-set &key glyph-set @table @var @item existing-glyph-set An existing @var{glyph-set} @item glyph-set An optional @var{glyph-set}, just like in @var{render-create-glyph-set} @end table Creates a new id refering to the existing-glyph-set. The glyph-set itself will not be freed until all ids has been removed. @end defun @defun render-free-glyph-set glyph-set @table @var @item glyph-set A glyphset resource to free @end table Removes an id to a glyph-set. When all ids have been removed the glyph-set itself is removed. @end defun @defun render-add-glyph glyph-set id &key x-origin y-origin x-advance y-advance data @table @var @item glyph-set A @var{glyph-set} @item id @var{card32} @item x-orgin @var{int16} @item y-orgin @var{int16} @item x-advance @var{int16} @item y-advance @var{int16} @item data An @var{array} of @var{card8} bytes. @end table Associates id with the given description of a glyph. An existing glyph with the same id is replaced. At the time of writing, only 8bit alpha masks are supported. Experimentation with glyph-sets in other pict-formats needed. @end defun @defun render-add-glyph-from-picture glyph-set picture &key x-origin y-origin x-advance y-advance width height @table @var @item glyph-set glyph-set @item picture picture @item x-origin int16 @item y-origin int16 @item x-advance int16 @item y-advance int16 @item x int16 @item y int16 @item width card16 @item height card16 @end table This request add a glyph to @emph{glyph-set} by copying it from the @emph{x,y} location in the @emph{picture}. Existing glyphs with the same names are replaced. The source @emph{picture} may be in a different @var{picture-format} than @emph{glyph-set}, in which case the images are converted to the glyph-set's format. @end defun @defun render-free-glyphs glyph-set glyphs @table @var @item glyph-set A @var{glyph-set} @item glyphs sequence of @var{card32} @end table This request removes @emph{glyphs} from @emph{glyph-set}. Each glyph must exist in @emph{glyph-set} (else a @var{Match} error results). @end defun @node Using glyphs, Errors (Extensions), Glyphs and Glyphsets, RENDER - A new rendering system for X11 @subsection Using glyphs @defun render-composite-glyph dest glyph-set source dest-x dest-y sequence &key op src-x src-y mask-format start end @table @var @item dest picture @item glyph-set glyph-set @item source picture @item dest-x int16 @item dest-y int16 @item sequence @item op (member clear :src :dst :over :over-reverse :in :in-reverse :out :out-reverse :atop :atop-reverse :xor :add :saturate :maximum) @item src-x int16 @item src-y iny16 @item mask-format picture-format @item start blah @item end blah @end table Requests the sequence of glyphs to be drawn with the glyph-set. @end defun @node Errors (Extensions), , Using glyphs, RENDER - A new rendering system for X11 @subsection Errors What new errors Xrender defines... @node DPMS - The X11 Display Power Management Signaling Extension, BIG-REQUESTS - Big Requests Extension, RENDER - A new rendering system for X11, Extensions @section DPMS - The X11 Display Power Management Signaling Extension @defun dpms-get-version display &optional (major-version 1) (minor-version 1) @table @var @item display @var{display} @item major-version @var{card16} @item minor-version @var{card16} @end table Return two values: the major and minor version of the DPMS implementation the server supports. If supplied, the @var{major-version} and @var{minor-version} indicate what version of the protocol the client wants the server to implement. @end defun @defun dpms-capable display @table @var @item display @var{display} @end table True if the currently running server's devices are capable of DPMS operations. The truth value of this request is implementation defined, but is generally based on the capabilities of the graphic card and monitor combination. Also, the return value in the case of heterogeneous multi-head servers is implementation defined. @end defun @defun dpms-get-timeouts display @table @var @item display @var{display} @end table Return three values: the current values of the DPMS timeout values. The timeout values are (in order returned): standby, suspend and off. All values are in units of seconds. A value of zero for any timeout value indicates that the mode is disabled. @end defun @defun dpms-set-timeouts display standby suspend off @table @var @item display @var{display} @item standby @var{card16} @item suspend @var{card16} @item off @var{card16} @end table Set the values of the DPMS timeouts. All values are in units of seconds. A value of zero for any timeout value disables that mode. @end defun @defun dpms-enable display @table @var @item display @var{display} @end table Enable the DPMS characteristics of the server using the server's currently stored timeouts. If DPMS is already enabled, no change is affected. @end defun @defun dpms-disable display @table @var @item display @var{display} @end table Disable the DPMS characteristics of the server. It does not affect the core or extension screen savers. If DPMS is already disabled, no change is effected. This request is provided so that DPMS may be disabled without damaging the server's stored timeout values. @end defun @defun dpms-force-level display power-level @table @var @item display @var{display} @item power-level (member :dpms-mode-on :dpms-mode-standby :dpms-mode-suspend :dpms-mode-off) @end table Forces a specific DPMS level on the server. @end defun @defun dpms-info display @table @var @item display @var{display} @end table Returns two values: the DPMS power-level and state value for the display. State is one of the keywords DPMS-ENABLED or DPMS-DISABLED. If state is DPMS-ENABLED, then power-level is returned as one of the keywords DPMS-MODE-ON, DPMS-MODE-STANDBY, DPMS-MODE-SUSPEND or DPMS-MODE-OFF. If state is DPMS-DISABLED, then power-level is undefined and returned as NIL. @end defun @node BIG-REQUESTS - Big Requests Extension, , DPMS - The X11 Display Power Management Signaling Extension, Extensions @section BIG-REQUESTS - Big Requests Extension @defun display-extended-max-request-length display @end defun @defun enable-big-requests display @end defun @chapter Errors @node Errors, Undocumented, Extensions, Top @menu * Introduction (Errors):: @end menu @node Introduction (Errors), , Errors, Errors @section Introduction CLX error conditions are hierarchial. The base error condition is @var{x-error}, and all other conditions are built on top of @var{x-error}. @var{x-error} can be built on a lower-level condition that is implementation dependent (this is probably the @var{error} condition). @defmac define-condition name (parent-types*) [({slot-specifier*}) {option*}] Any new condition type must be defined with the @var{define-condition} macro. A condition type has a name, parent types, report message, and any number of slot items. See the @emph{Lisp} @emph{Reference} manual for further information regarding @var{define-condition}. The following are the predefined error conditions that can occur in CLX. @end defmac @deftp {Condition} access-error An @var{access-error} can occur for several reasons: @itemize @bullet @item A client attempted to grab a key/button combination already grabbed by another client @item A client attempted to free a colormap entry that it did not already allocate @item A client attempted to store into a read-only colormap entry @item A client attempted to modify the access control list from other than the local (or otherwise authorized) host @item A client attempted to select an event type that another client has already selected, and, that at most, one client can select at a time @end itemize An @var{access-error} is a special case of the more general @var{request-error} (@pxref{request-error}). @end deftp @deftp {Condition} alloc-error The server failed to allocate the requested resource or server memory. An @var{alloc-error} is a special case of the more general @var{request-error} (@pxref{request-error}). @end deftp @deftp {Condition} atom-error A value for an @emph{atom} argument does not name a defined atom. An @var{atom-error} is a special case of the more general @var{request-error} (@pxref{request-error}). @end deftp @deftp {Condition} closed-display The @var{closed-display} condition is signaled when trying to read or write a closed display (that is, @var{close-display} has been called on the @var{display} object, or a server-disconnect occurred). The @var{closed-display} object is reported with the error. A @var{closed-display} condition is a special case of the more general @var{x-error} (@pxref{x-error}). @end deftp @deftp {Condition} colormap-error A value for a @emph{colormap} argument does not name a defined colormap. A @var{colormap-error} is a special case of the more general @var{resource-error} (@pxref{resource-error}). @end deftp @deftp {Condition} connection-failure Signaled when an X11 server refuses a connection. The following items are reported along with the error: @itemize @bullet @item @emph{major-version} -- The major version of the X server code. @item @emph{minor-version} -- The minor version of the X server code. @item @emph{host} -- The host name for the X server. @item @emph{display} -- The display on which the error occurred. @item @emph{reason} -- A string indicating why the connection failed. @end itemize A @var{connection-failure} is a special case of the more general @var{x-error} (@pxref{x-error}). @end deftp @deftp {Condition} cursor-error A value for a @emph{cursor} argument does not name a defined cursor. A @var{cursor-error} is a special case of the more general @var{resource-error} (@pxref{resource-error}). @end deftp @deftp {Condition} device-busy Signaled by (@code{setf} (@var{pointer-mapping} @emph{display}) @var{mapping}) when the @var{set-pointer-mapping} request returns a busy status. A similar condition occurs in @var{set-modifier-mapping}, but in this case, it returns a boolean indicating success, rather than signaling an error. The @var{device-busy} condition returns the display object as part of the error. A @var{device-busy} condition is a special case of the more general @var{x-error} (@pxref{x-error}). @end deftp @deftp {Condition} drawable-error A value for a @emph{drawable} argument does not name a defined window or pixmap. A @var{drawable-error} is a special case of the more general @var{resource-error} (@pxref{resource-error}). @end deftp @deftp {Condition} font-error A value for a @emph{font} or @emph{gcontext} argument does not name a defined font. A @var{font-error} is a special case of the more general @var{resource-error} (@pxref{resource-error}). @end deftp @deftp {Condition} gcontext-error A value for a @emph{gcontext} argument does not name a defined GContext. A @var{gcontext-error} is a special case of the more general @var{resource-error} (@pxref{resource-error}). @end deftp @deftp {Condition} id-choice-error The value chosen for a resource identifier is either not included in the range assigned to the client or is already in use. Under normal circumstances, this cannot occur and should be considered a server or CLX library error. An @var{id-choice-error} is a special case of the more general @var{resource-error} (@pxref{resource-error}). @end deftp @deftp {Condition} implementation-error The server does not implement some aspect of the request. A server that generates this error for a core request is deficient. As such, this error is not listed for any of the requests. However, clients should be prepared to receive such errors and either handle or discard them. An @var{implementation-error} is a special case of the more general @var{resource-error} (@pxref{resource-error}). @end deftp @deftp {Condition} length-error The length of a request is shorter or longer than that minimally required to contain the arguments. This usually means an internal CLX error. A @var{length-error} is a special case of the more general @var{resource-error} (@pxref{resource-error}). @end deftp @deftp {Condition} lookup-error CLX has the option of caching different resource types (see @var{*clx-cached-types*}) in a hash table by resource ID. When looking up an object in the hash table, if the type of the object is wrong, a @var{lookup-error} is signaled. For example: The cursor with ID 123 is interned in the hash table. An event is received with a field for window 123. When 123 is looked up in the hash table, a cursor is found. Since a window was expected, a @var{lookup-error} is signaled. This error indicates a problem with the extension code being used. The following items are reported along with the error: @itemize @bullet @item @emph{id} -- The resource ID. @item @emph{display} -- The display being used. @item @emph{type} -- The resource type. @item @emph{object} -- The @var{resource} object. @end itemize A @var{lookup-error} is a special case of the more general @var{x-error} (@pxref{x-error}). @end deftp @deftp {Condition} match-error In a graphics request, the root and depth of the GContext does not match that of the drawable. An @var{:input-only} window is used as a drawable. Some argument or pair of arguments has the correct type and range but fails to match in some other way required by the request. An @var{:input-only} window locks this attribute. The values do not exist for an @var{:input-only} window. A @var{match-error} is a special case of the more general @var{request-error} (@pxref{request-error}). @end deftp @deftp {Condition} missing-parameter One or more of the required keyword parameters is missing or @var{nil}. The missing parameters are reported along with the error. A @var{missing-parameter} condition is a special case of the more general @var{x-error} (@pxref{x-error}). @end deftp @deftp {Condition} name-error A font or color of the specified name does not exist. A @var{name-error} is a special case of the more general @var{request-error} (@pxref{request-error}). @end deftp @deftp {Condition} pixmap-error A value for a @emph{pixmap} argument does not name a defined pixmap. A @var{pixmap-error} is a special case of the more general @var{resource-error}. (@pxref{resource-error}.) @end deftp @deftp {Condition} reply-length-error (x-error) (slots*) The reply to a request has an unexpected length. The following items are reported along with the error: @itemize @bullet @item @emph{reply-length} -- The actual reply length. @item @emph{expected-length} -- The expected reply length. @item @emph{display} -- The display on which the error occurred. @end itemize A @var{reply-length-error} is a special case of the more general @var{x-error} (@pxref{x-error}). @end deftp @deftp {Condition} reply-timeout The @var{*reply-timeout*} parameter specifies the maximum number of seconds to wait for a request reply, or @var{nil} to wait forever (the default). When a reply has not been received after *@var{reply-timeout}* seconds, the @var{reply-timeout} condition is signaled. The @emph{timeout} @emph{period} and @emph{display} are reported along with the error. A @var{reply-timeout} condition is a special case of the more general @var{x-error} (@pxref{x-error}). @end deftp @deftp {Condition} request-error @anchor{request-error} The following items are reported along with the error: The major or minor opcode does not specify a valid request. @itemize @bullet @item @emph{display} -- The display on which the error occurred. @item @emph{error-key} -- The error (sub)type. @item @emph{major} -- The major opcode. @item @emph{minor} -- The minor opcode. @item @emph{sequence} -- The actual sequence number. @item @emph{current-sequence} -- The current sequence number. @end itemize A @var{request-error} condition is a special case of the more general @var{x-error} (@pxref{x-error}). @end deftp @deftp {Condition} resource-error @anchor{resource-error} All X11 errors for incorrect resource IDs are built on top of @var{resource-error}. These are @var{colormap-error}, @var{cursor-error}, @var{drawable-error}, @var{font-error}, @var{gcontext-error}, @var{id-choice-error}, @var{pixmap-error} and @var{window-error}. @var{resource-error} is never signaled directly. A @var{resource-error} is a special case of the more general @var{request-error} (@pxref{request-error}). @end deftp @deftp {Condition} sequence-error All X11 request replies contain the sequence number of their request. If a reply's sequence does not match the request count, a @var{sequence-error} is signaled. A @var{sequence-error} usually indicates a locking problem with a multi-processing Lisp. The following items are reported along with the error: @itemize @bullet @item @emph{display} -- The display on which the error occurred. @item @emph{req-sequence} -- The sequence number in the reply. @item @emph{msg-sequence} -- The current sequence number. @end itemize A @var{sequence-error} condition is a special case of the more general @var{x-error}. (@pxref{x-error}) @end deftp @deftp {Condition} server-disconnect The connection to the server was lost. The display on which the error occurred is reported along with the error. A @var{server-disconnect} condition is a special case of the more general @var{x-error}. (@pxref{x-error}) @end deftp @deftp {Condition} unexpected-reply A reply was found when none was expected. This indicates a problem with the extension code. The following items are reported along with the error: @table @code @item display The display on which the error occurred. @item req-sequence The sequence number in the reply. @item msg-sequence The current sequence number. @item length The message length of the reply. @end table An @var{unexpected-reply} condition is a special case of the more general @var{x-error}. (@pxref{x-error}.) @end deftp @deftp {Condition} unknown-error (request-error) (error-code) An error was received from the server with an unknown error code. This indicates a problem with the extension code. The undefined error code is reported. An @var{unknown-error} is a special case of the more general @var{request-error}. (@pxref{request-error}) @end deftp @deftp {Condition} value-error (request-error) (value) Some numeric value falls outside the range of values accepted by the request. Unless a specific range is specified for an argument, the full range defined by the argument's type is accepted. Any argument defined as a set of alternatives can generate this error. The erroneous value is reported. A @var{value-error} is a special case of the more general @var{request-error}. (@pxref{request-error}) @end deftp @deftp {Condition} window-error (resource-error) A value for a @emph{window} argument does not name a defined window. A @var{window-error} is a special case of the more general @var{resource-error}. (@pxref{resource-error}.) @end deftp @deftp {Condition} x-error @anchor{x-error} This is the most general error condition upon which all other conditions are defined. @end deftp @ignore @var{PROTOCOL VS. CLX FUNCTIONAL} @var{CROSS-REFERENCE LISTING} @var{X11 Request Name CLX Function Name} AllocColor @var{alloc-color} AllocColorCells @var{alloc-color-cells} AllocColorPlanes@var{alloc-color-planes} AllocNamedColor @var{alloc-color} AllowEvents @var{allow-events} Bell @var{bell} ChangeAccessControl (@code{setf} (@var{access-control} @emph{display}) ChangeActivePointerGrab @var{change-active-pointer-grab} ChangeCloseDownMode (@code{setf} (@var{close-down-mode} @emph{display})) ChangeGC @var{force-gcontext-changes} (See @var{with-gcontext}) (@code{setf} (@var{gcontext-function} @emph{gc})) (@code{setf} (@var{gcontext-plane-mask} @emph{gc})) (@code{setf} (@var{gcontext-foreground} @emph{gc})) (@code{setf} (@var{gcontext-background} @emph{gc})) (@code{setf} (@var{gcontext-line-width} @emph{gc})) (@code{setf} (@var{gcontext-line-style} @emph{gc})) (@code{setf} (@var{gcontext-cap-style} @emph{gc})) (@code{setf} (@var{gcontext-join-style} @emph{gc})) (@code{setf} (@var{gcontext-fill-style} @emph{gc})) (@code{setf} (@var{gcontext-fill-rule} @emph{gc})) (@code{setf} (@var{gcontext-tile} @emph{gc})) (@code{setf} (@var{gcontext-stipple} @emph{gc})) (@code{setf} (@var{gcontext-ts-x} @emph{gc})) (@code{setf} (@var{gcontext-ts-y} @emph{gc})) (@code{setf} (@var{gcontext-font} @emph{gc} &optional @var{metrics-p})) (@code{setf} (@var{gcontext-subwindow-mode} @emph{gc})) (@code{setf} (@var{gcontext-exposures} @emph{gc}))) (@code{setf} (@var{gcontext-clip-x} @emph{gc})) (@code{setf} (@var{gcontext-clip-y} @emph{gc})) (@code{setf} (@var{gcontext-clip-mask} @emph{gc} &optional @var{ordering})) (@code{setf} (@var{gcontext-dash-offset} @emph{gc})) (@code{setf} (@var{gcontext-dashes} @emph{gc})) (@code{setf} (@var{gcontext-arc-mode} @emph{gc})) (@code{setf} (@var{gcontext-clip-ordering} @emph{gc})) @var{X11 Request Name CLX Function Name} ChangeHosts @var{add-access-host} ChangeHosts @var{remove-access-host} ChangeKeyboardControl @var{change-keyboard-control} ChangePointerControl @var{change-pointer-control} ChangeProperty @var{change-property} ChangeSaveSet @var{remove-from-save-set} ChangeSaveSet @var{add-to-save-set} ChangeWindowAttributes (See @var{with-state}) (@code{setf} (@var{window-background} @emph{window})) (@code{setf} (@var{window-border} @emph{window})) (@code{setf} (@var{window-bit-gravity} @emph{window})) (@code{setf} (@var{window-gravity} @emph{window})) (@code{setf} (@var{window-backing-store} @emph{window})) (@code{setf} (@var{window-backing-planes} @emph{window})) (@code{setf} (@var{window-backing-pixel} @emph{window})) (@code{setf} (@var{window-override-redirect} @emph{window}) @code{(setf (window-save-under} @emph{window}@var{))} (@code{setf} (@var{window-colormap} @emph{window})) (@code{setf} (@var{window-cursor} @emph{window})) (@code{setf} (@var{window-event-mask} @emph{window})) (@code{setf} (@var{window-do-not-propagate-mask} @emph{window})) CirculateWindow @var{circulate-window-down} CirculateWindow @var{circulate-window-up} ClearToBackground @var{clear-area} CloseFont @var{close-font} ConfigureWindow (See @var{with-state}) (@code{setf} (@var{drawable-x} @emph{drawable})) (@code{setf} (@var{drawable-y} @emph{drawabl}e)) (@code{setf} (@var{drawable-width} @emph{drawable})) (@code{setf} (@var{drawable-height} @emph{drawable})) (@code{setf} (@var{drawable-depth} @emph{drawable})) (@code{setf} (@var{drawable-border-width} @emph{drawable})) (@code{setf} (@var{window-priority} @emph{window} &optional @var{sibling})) ConvertSelection@var{convert-selection} CopyArea @var{copy-area} CopyColormapAndFree @var{copy-colormap-and-free} CopyGC@var{copy-gcontext} CopyGC@var{copy-gcontext-components} CopyPlane @var{copy-plane} CreateColormap @var{create-colormap} CreateCursor @var{create-cursor} CreateGC @var{create-gcontext} CreateGlyphCursor @var{create-glyph-cursor} CreatePixmap @var{create-pixmap} CreateWindow @var{create-window} DeleteProperty @var{delete-property} DestroySubwindows @var{destroy-subwindows} DestroyWindow @var{destroy-window} FillPoly @var{draw-lines} ForceScreenSaver@var{reset-screen-saver} ForceScreenSaver@var{activate-screen-saver} FreeColormap @var{free-colormap} FreeColors @var{free-colors} FreeCursor @var{free-cursor} @var{X11 Request Name CLX Function Name} FreeGC@var{free-gcontext} FreePixmap @var{free-pixmap} GetAtomName @var{atom-name} GetFontPath @var{font-path} GetGeometry (See @var{with-state}) @var{drawable-root} @var{drawable-x} @var{drawable-y} @var{drawable-width} @var{drawable-height} @var{drawable-depth} @var{drawable-border-width} GetImage @var{get-raw-image} GetInputFocus @var{input-focus} GetKeyboardControl @var{keyboard-control} GetKeyboardMapping @var{keyboard-mapping} GetModifierMapping @var{modifier-mapping} GetMotionEvents @var{motion-events} GetPointerControl @var{pointer-control} GetPointerMapping @var{pointer-mapping} GetProperty @var{get-property} GetScreenSaver @var{screen-saver} GetSelectionOwner @var{selection-owner} GetWindowAttributes (See @var{with-state}) @var{window-visual} @var{window-class} @var{window-bit-gravity} @var{window-gravity} @var{window-backing-store} @var{window-backing-planes} @var{window-backing-pixel} @var{window-save-under} @var{window-override-redirect} @var{window-event-mask} @var{window-do-not-propagate-mask} @var{window-colormap} @var{window-colormap-installed-p} @var{window-all-event-masks} @var{window-map-state} GrabButton @var{grab-button} GrabKey @var{grab-key} GrabKeyboard @var{grab-keyboard} GrabPointer @var{grab-pointer} GrabServer @var{grab-server} ImageText16 @var{draw-image-glyphs} ImageText16 @var{draw-image-glyph} ImageText8 @var{draw-image-glyphs} InstallColormap @var{install-colormap} InternAtom @var{find-atom} InternAtom @var{intern-atom} KillClient @var{kill-temporary-clients} KillClient @var{kill-client} ListExtensions @var{list-extensions} ListFonts @var{list-font-names} ListFontsWithInfo @var{list-fonts} ListHosts @var{access-control} @var{X11 Request Name CLX Function Name} ListHosts @var{access-hosts} ListInstalledColormaps @var{installed-colormaps} ListProperties @var{list-properties} LookupColor @var{lookup-color} MapSubwindows @var{map-subwindows} MapWindow @var{map-window} OpenFont @var{open-font} PolyArc @var{draw-arc} PolyArc @var{draw-arcs} PolyFillArc @var{draw-arc} PolyFillArc @var{draw-arcs} PolyFillRectangle @var{draw-rectangle} PolyFillRectangle @var{draw-rectangles} PolyLine @var{draw-line} PolyLine @var{draw-lines} PolyPoint @var{draw-point} PolyPoint @var{draw-points} PolyRectangle @var{draw-rectangle} PolyRectangle @var{draw-rectangles} PolySegment @var{draw-segments} PolyText16 @var{draw-glyph} PolyText16 @var{draw-glyphs} PolyText8 @var{draw-glyphs} PutImage @var{put-raw-image} QueryBestSize @var{query-best-cursor} QueryBestSize @var{query-best-stipple} QueryBestSize @var{query-best-tile} QueryColors @var{query-colors} QueryExtension @var{query-extension} QueryFont @var{font-name} @var{font-name} @var{font-direction} @var{font-min-char} @var{font-max-char} @var{font-min-byte1} @var{font-max-byte1} @var{font-min-byte2} @var{font-max-byte2} @var{font-all-chars-exist-p} @var{font-default-char} @var{font-ascent} @var{font-descent} @var{font-properties} @var{font-property} @var{char-left-bearing} @var{char-right-bearing} @var{char-width} @var{char-ascent} @var{char-descent} @var{char-attributes} @var{min-char-left-bearing} @var{min-char-right-bearing} @var{min-char-width} @var{min-char-ascent} @var{min-char-descent} @var{min-char-attributes} @var{X11 Request Name CLX Function Name} @var{max-char-left-bearing} @var{max-char-right-bearing} @var{max-char-width} @var{max-char-ascent} @var{max-char-descent} @var{max-char-attributes} QueryKeymap @var{query-keymap} QueryPointer @var{global-pointer-position} QueryPointer @var{pointer-position} QueryPointer @var{query-pointer} QueryTextExtents@var{text-extents} QueryTextExtents@var{text-width} QueryTree @var{query-tree} RecolorCursor @var{recolor-cursor} ReparentWindow @var{reparent-window} RotateProperties@var{rotate-properties} SendEvent @var{send-event} SetClipRectangles @var{force-gcontext-changes} (See @var{with-gcontext}) (@code{setf} (@var{gcontext-clip-x} @emph{gc})) (@code{setf} (@var{gcontext-clip-y} @emph{gc})) (@code{setf} (@var{gcontext-clip-mask} @emph{gc} &optional @var{ordering})) (@code{setf} (@var{gcontext-clip-ordering} @emph{gc})) SetDashes @var{force-gcontext-changes} (See @var{with-gcontext}) (@code{setf} (@var{gcontext-dash-offset} @emph{gc})) (@code{setf} (@var{gcontext-dashes} @emph{gc})) SetFontPath (@code{setf} (@var{font-path} @emph{font}) SetInputFocus @var{set-input-focus} SetKeyboardMapping @var{change-keyboard-mapping} SetModifierMapping @var{set-modifier-mapping} SetPointerMapping @var{set-pointer-mapping} SetScreenSaver @var{set-screen-saver} SetSelectionOwner @var{set-selection-owner} StoreColors @var{store-color} StoreColors @var{store-colors} StoreNamedColor @var{store-color} StoreNamedColor @var{store-colors} TranslateCoords @var{translate-coordinates} UngrabButton @var{ungrab-button} UngrabKey @var{ungrab-key} UngrabKeyboard @var{ungrab-keyboard} UngrabPointer @var{ungrab-pointer} UngrabServer @var{ungrab-server} UninstallColormap @var{uninstall-colormap} UnmapSubwindows @var{unmap-subwindows} UnmapWindow @var{unmap-window} WarpPointer @var{warp-pointer} WarpPointer @var{warp-pointer-if-inside} WarpPointer @var{warp-pointer-relative} WarpPointer @var{warp-pointer-relative-if-inside} ListHosts @var{access-control} ListHosts @var{access-hosts} ForceScreenSaver@var{activate-screen-saver} ChangeHosts @var{add-access-host} @var{X11 Request Name CLX Function Name} ChangeSaveSet @var{add-to-save-set} AllocColor @var{alloc-color} AllocNamedColor @var{alloc-color} AllocColorCells @var{alloc-color-cells} AllocColorPlanes@var{alloc-color-planes} AllowEvents @var{allow-events} GetAtomName @var{atom-name} Bell @var{bell} ChangeActivePointerGrab @var{change-active-pointer-grab} ChangeKeyboardControl @var{change-keyboard-control} SetKeyboardMapping @var{change-keyboard-mapping} ChangePointerControl @var{change-pointer-control} ChangeProperty @var{change-property} QueryFont @var{char-ascent} QueryFont @var{char-attributes} QueryFont @var{char-descent} QueryFont @var{char-left-bearing} QueryFont @var{char-right-bearing} QueryFont @var{char-width} CirculateWindow @var{circulate-window-down} CirculateWindow @var{circulate-window-up} ClearToBackground @var{clear-area} CloseFont @var{close-font} ConvertSelection@var{convert-selection} CopyArea @var{copy-area} CopyColormapAndFree @var{copy-colormap-and-free} CopyGC@var{copy-gcontext} CopyGC@var{copy-gcontext-components} CopyPlane @var{copy-plane} CreateColormap @var{create-colormap} CreateCursor @var{create-cursor} CreateGC @var{create-gcontext} CreateGlyphCursor @var{create-glyph-cursor} CreatePixmap @var{create-pixmap} CreateWindow @var{create-window} DeleteProperty @var{delete-property} DestroySubwindows @var{destroy-subwindows} DestroyWindow @var{destroy-window} PolyArc @var{draw-arc} PolyArc @var{draw-arcs} PolyText16 @var{draw-glyph} PolyText16 @var{draw-glyphs} PolyText8 @var{draw-glyphs} ImageText16 @var{draw-image-glyph} ImageText16 @var{draw-image-glyphs} ImageText8 @var{draw-image-glyphs} PolyLine @var{draw-line} PolyLine @var{draw-lines} PolyPoint @var{draw-point} PolyPoint @var{draw-points} PolyFillRectangle @var{draw-rectangle} PolyRectangle @var{draw-rectangle} PolyFillRectangle @var{draw-rectangles} PolyRectangle @var{draw-rectangles} PolySegment @var{draw-segments} GetGeometry @var{drawable-border-width} @var{X11 Request Name CLX Function Name} GetGeometry @var{drawable-depth} GetGeometry @var{drawable-height} GetGeometry @var{drawable-root} GetGeometry @var{drawable-width} GetGeometry @var{drawable-x} GetGeometry @var{drawable-y} FillPoly @var{fill-polygon} InternAtom @var{find-atom} QueryFont @var{font-all-chars-exist-p} QueryFont @var{font-ascent} QueryFont @var{font-default-char} QueryFont @var{font-descent} QueryFont @var{font-direction} QueryFont @var{font-max-byte1} QueryFont @var{font-max-byte2} QueryFont @var{font-max-char} QueryFont @var{font-min-byte1} QueryFont @var{font-min-byte2} QueryFont @var{font-min-char} QueryFont @var{font-name} QueryFont @var{font-name} GetFontPath @var{font-path} QueryFont @var{font-properties} QueryFont @var{font-property} ChangeGC @var{force-gcontext-changes} SetClipRectangles @var{force-gcontext-changes} SetDashes @var{force-gcontext-changes} FreeColormap @var{free-colormap} FreeColors @var{free-colors} FreeCursor @var{free-cursor} FreeGC@var{free-gcontext} FreePixmap @var{free-pixmap} GetProperty @var{get-property} GetImage @var{get-raw-image} QueryPointer @var{global-pointer-position} GrabButton @var{grab-button} GrabKey @var{grab-key} GrabKeyboard @var{grab-keyboard} GrabPointer @var{grab-pointer} GrabServer @var{grab-server} GrabServer @var{with-server-grabbed} GetInputFocus @var{input-focus} InstallColormap @var{install-colormap} ListInstalledColormaps @var{installed-colormaps} InternAtom @var{intern-atom} GetKeyboardControl @var{keyboard-control} GetKeyboardMapping @var{keyboard-mapping} KillClient @var{kill-client} KillClient @var{kill-temporary-clients} ListExtensions @var{list-extensions} ListFonts @var{list-font-names} ListFontsWithInfo @var{list-fonts} ListProperties @var{list-properties} LookupColor @var{lookup-color} MapSubwindows @var{map-subwindows} MapWindow @var{map-window} @var{X11 Request Name CLX Function Name} QueryFont @var{max-char-ascent} QueryFont @var{max-char-attributes} QueryFont @var{max-char-descent} QueryFont @var{max-char-left-bearing} QueryFont @var{max-char-right-bearing} QueryFont @var{max-char-width} QueryFont @var{min-char-ascent} QueryFont @var{min-char-attributes} QueryFont @var{min-char-descent} QueryFont @var{min-char-left-bearing} QueryFont @var{min-char-right-bearing} QueryFont @var{min-char-width} GetModifierMapping @var{modifier-mapping} GetMotionEvents @var{motion-events} OpenFont @var{open-font} GetPointerControl @var{pointer-control} GetPointerMapping @var{pointer-mapping} QueryPointer @var{pointer-position} PutImage @var{put-raw-image} QueryBestSize @var{query-best-cursor} QueryBestSize @var{query-best-stipple} QueryBestSize @var{query-best-tile} QueryColors @var{query-colors} QueryExtension @var{query-extension} QueryKeymap @var{query-keymap} QueryPointer @var{query-pointer} QueryTree @var{query-tree} RecolorCursor @var{recolor-cursor} ChangeHosts @var{remove-access-host} ChangeSaveSet @var{remove-from-save-set} ReparentWindow @var{reparent-window} ForceScreenSaver@var{reset-screen-saver} RotateProperties@var{rotate-properties} GetScreenSaver @var{screen-saver} GetSelectionOwner @var{selection-owner} SendEvent @var{send-event} ChangeAccessControl @var{set-access-control} ChangeCloseDownMode @var{set-close-down-mode} SetInputFocus @var{set-input-focus} SetModifierMapping @var{set-modifier-mapping} SetPointerMapping @var{set-pointer-mapping} SetScreenSaver @var{set-screen-saver} SetSelectionOwner @var{set-selection-owner} StoreColors @var{store-color} StoreColors @var{store-colors} StoreNamedColor @var{store-color} StoreNamedColor @var{store-colors} QueryTextExtents@var{text-extents} QueryTextExtents@var{text-width} TranslateCoords @var{translate-coordinates} UngrabButton @var{ungrab-button} UngrabKey @var{ungrab-key} UngrabKeyboard @var{ungrab-keyboard} UngrabPointer @var{ungrab-pointer} UngrabServer @var{ungrab-server} UngrabServer @var{with-server-grabbed} @var{X11 Request Name CLX Function Name} UninstallColormap @var{uninstall-colormap} UnmapSubwindows @var{unmap-subwindows} UnmapWindow @var{unmap-window} WarpPointer @var{warp-pointer} WarpPointer @var{warp-pointer-if-inside} WarpPointer @var{warp-pointer-relative} WarpPointer @var{warp-pointer-relative-if-inside} GetWindowAttributes @var{window-all-event-masks} GetWindowAttributes @var{window-backing-pixel} GetWindowAttributes @var{window-backing-planes} GetWindowAttributes @var{window-backing-store} GetWindowAttributes @var{window-bit-gravity} GetWindowAttributes @var{window-class} GetWindowAttributes @var{window-colormap} GetWindowAttributes @var{window-colormap-installed-p} GetWindowAttributes @var{window-do-not-propagate-mask} GetWindowAttributes @var{window-event-mask} GetWindowAttributes @var{window-gravity} GetWindowAttributes @var{window-map-state} GetWindowAttributes @var{window-override-redirect} GetWindowAttributes @var{window-save-under} GetWindowAttributes @var{window-visual} ConfigureWindow (@code{setf} (@var{drawable-border-width} @emph{drawable})) ConfigureWindow (@code{setf} (@var{drawable-depth} @emph{drawable})) ConfigureWindow (@code{setf} (@var{drawable-height} @emph{drawable})) ConfigureWindow (@code{setf} (@var{drawable-width} @emph{drawabl}e)) ConfigureWindow (@code{setf} (@var{drawable-x} @emph{drawable})) ConfigureWindow (@code{setf} (@var{drawable-y} @emph{drawable})) SetFontPath (@code{setf} (@var{font-path} @emph{font}) @var{paths}) ChangeGC (@code{setf} (@var{gcontext-arc-mode} @emph{gc})) ChangeGC (@code{setf} (@var{gcontext-background} @emph{gc})) ChangeGC (@code{setf} (@var{gcontext-cap-style} @emph{gc})) SetClipRectangles (@code{setf} (@var{gcontext-clip-mask} @emph{gc} &optional @var{ordering})) SetClipRectangles (@code{setf} (@var{gcontext-clip-ordering} @emph{gc})) SetClipRectangles (@code{setf} (@var{gcontext-clip-x} @emph{gc})) SetClipRectangles (@code{setf} (@var{gcontext-clip-y} @emph{gc})) SetDashes (@code{setf} (@var{gcontext-dash-offset} @emph{gc})) SetDashes (@code{setf} (@var{gcontext-dashes} @emph{gc})) ChangeGC (@code{setf} (@var{gcontext-exposures} @emph{gc})) ChangeGC (@code{setf} (@var{gcontext-fill-rule} @emph{gc}) @var{keyword}) ChangeGC (@code{setf} (@var{gcontext-fill-style} @emph{gc}) @var{keyword}) ChangeGC (@code{setf} (@var{gcontext-font} @emph{gc} &optional @var{metrics-p}) ChangeGC (@code{setf} (@var{gcontext-foreground} @emph{gc}) @var{card32}) ChangeGC (@code{setf} (@var{gcontext-function} @emph{gc})) ChangeGC (@code{setf} (@var{gcontext-join-style} @emph{gc}) @var{keyword}) ChangeGC (@code{setf} (@var{gcontext-line-style} @emph{gc}) @var{keyword}) ChangeGC (@code{setf} (@var{gcontext-line-width} @emph{gc}) @var{card16}) ChangeGC (@code{setf} (@var{gcontext-plane-mask} @emph{gc}) @var{card32}) ChangeGC (@code{setf} (@var{gcontext-stipple} @emph{gc}) @var{pixmap}) ChangeGC (@code{setf} (@var{gcontext-subwindow-mode} @emph{gc})) ChangeGC (@code{setf} (@var{gcontext-tile} @emph{gc})) ChangeGC (@code{setf} (@var{gcontext-ts-x} @emph{gc})) ChangeGC (@code{setf} (@var{gcontext-ts-y} @emph{gc})) ChangeWindowAttributes (@code{setf} (@var{window-background} @emph{window})) @var{X11 Request Name CLX Function Name} ChangeWindowAttributes (@code{setf} (@var{window-backing-pixel} @emph{window})) ChangeWindowAttributes (@code{setf} (@var{window-backing-planes} @emph{window})) ChangeWindowAttributes (@code{setf} (@var{window-backing-store} @emph{window})) ChangeWindowAttributes (@code{setf} (@var{window-bit-gravity} @emph{window})) ChangeWindowAttributes (@code{setf} (@var{window-border} @emph{window})) ChangeWindowAttributes (@code{setf} (@var{window-colormap} @emph{window})) ChangeWindowAttributes (@code{setf} (@var{window-cursor} @emph{window})) ChangeWindowAttributes (@code{setf} (@var{window-do-not-propagate-mask} @emph{window})) ChangeWindowAttributes (@code{setf} (@var{window-event-mask} @emph{window})) ChangeWindowAttributes (@code{setf} (@var{window-gravity} @emph{window})) ChangeWindowAttributes (@code{setf} (@var{window-override-redirect} @emph{window})) ConfigureWindow (@code{setf} (@var{window-priority} @emph{window} &optional @var{sibling})) ChangeWindowAttributes (@code{setf} (@var{window-save-under} @emph{window})) @end ignore @node Undocumented, Glossary, Errors, Top @chapter Undocumented This section just lists all symbols exported from the @var{XLIB} package but not documented in this manual. @defun bitmap-image &optional plist &rest patterns @end defun @defun character->keysyms character &optional display @end defun @defun character-in-map-p display character keymap @table @var @item display A @var{display}. @end table @end defun @defun decode-core-error display event &optional arg @end defun @defun default-error-handler display error-key &rest key-vals &key asynchronous &allow-other-keys @end defun @defun default-keysym-index display keycode state @end defun @defun default-keysym-translate display state object @end defun @defun define-keysym object keysym &key lowercase translate modifiers mask display @end defun @defun define-keysym-set set first-keysym last-keysym @end defun @defun display-invoke-after-function display Explicitly invokes the @emph{after-function} of the display. (see @var{display-after-function}). This function is internally called after every request. @end defun @defun display-nscreens display @end defun @defun display-release-number object @end defun @defun event-handler handlers event-key @end defun @defun get-external-event-code display event @end defun @defun get-standard-colormap window property @end defun @defun get-wm-class window @end defun @defun icon-sizes window @end defun @defun iconify-window window screen @end defun @defun keysym->keycodes display keysym @end defun @defun keysym-in-map-p display keysym keymap @end defun @defun keysym-set keysym @end defun @defun mapping-notify display request start count Called on a @var{:mapping-notify} event to update the keyboard-mapping cache in @emph{display}. @end defun @defun no-operation display @end defun @defun parse-color colormap spec @end defun @defun resource-database-timestamp database @end defun @defun resource-key stringable @end defun @defun rgb-colormaps window property @end defun @defun root-resources screen &key database key test test-not Returns a resource database containing the contents of the root window @var{RESOURCE_MANAGER} property for the given @emph{screen}. If @emph{screen} is a display, then its default screen is used. If an existing @emph{database} is given, then resource values are merged with the @emph{database} and the modified @emph{database} is returned. @emph{test} and @emph{test-not} are predicates for selecting which resources are read. Arguments are a resource name list and a resource value. The @emph{key} function, if given, is called to convert a resource value string to the value given to @emph{test} or @emph{test-not}. @end defun @defun rotate-cut-buffers display &optional (delta 1) (careful-p t) @end defun @defun set-access-control display enabled-p @end defun @defun set-close-down-mode display mode @anchor{set-close-down-mode} @end defun @defun set-pointer-mapping display map @end defun @defun set-selection-owner display selection owner &optional time @end defun @defun set-standard-colormap window property colormap base-pixel max-color mult-color @end defun @defun set-standard-properties window &rest options @end defun @defun set-wm-class window resource-name resource-class @end defun @defun set-wm-properties window &rest options &key name icon-name resource-name resource-class command client-machine hints normal-hints zoom-hints (user-specified-position-p nil usppp) (user-specified-size-p nil usspp) (program-specified-position-p nil psppp) (program-specified-size-p nil psspp) x y width height min-width min-height max-width max-height width-inc height-inc min-aspect max-aspect base-width base-height win-gravity input initial-state icon-pixmap icon-window icon-x icon-y icon-mask window-group @end defun @defun set-wm-resources database window &key write test test-not @end defun @defun transient-for window @end defun @defun translate-default src src-start src-end font dst dst-start @end defun @defun undefine-keysym object keysym &key display modifiers &allow-other-keys @end defun @defun visual-info-blue-mask object @end defun @defun visual-info-green-mask object @end defun @defun visual-info-red-mask object @end defun @defun window-cursor window @end defun @defun window-visual-info window @end defun @defun withdraw-window window screen @end defun @defun wm-client-machine window @end defun @defun wm-colormap-windows window @end defun @defun wm-command window @end defun @defun wm-hints window @end defun @defun wm-hints-flags object @end defun @defun wm-icon-name window @end defun @defun wm-name window @end defun @defun wm-normal-hints window @end defun @defun wm-protocols window @end defun @defun wm-resources database window &key key test test-not @end defun @defun wm-zoom-hints window @end defun @ignore XLIB:STATE-KEYSYM-P is undocumented. XLIB:*VERSION* is undocumented. XLIB:BITMAP-FORMAT-LSB-FIRST-P ??? [Function] XLIB:BITMAP-FORMAT-P ??? [Function] XLIB:BITMAP-FORMAT-PAD ???[Function] XLIB:BITMAP-FORMAT-UNIT ??? [Function] XLIB:CARD8->CHAR (card8) [Function] XLIB:CHAR->CARD8 (char) [Function] XLIB:COLORMAP-VISUAL-INFO ??? [Function] XLIB:CUT-BUFFER (display &key (buffer 0) (type :string) (result-type 'string) (transform #'card8->char) (start 0) end) [Function] XLIB:DEFINE-ERROR ??? [Function] XLIB:DEFINE-EXTENSION ??? [Function] XLIB:DEFINE-GCONTEXT-ACCESSOR ??? [Function] XLIB:DISPLAY-DEFAULT-SCREEN ??? [Function] XLIB:DISPLAY-HOST ??? [Function] XLIB:DISPLAY-REPORT-ASYNCHRONOUS-ERRORS ??? [Function] XLIB:DISPLAY-XDEFAULTS ???[Function] XLIB:EXTENSION-OPCODE ??? [Function] XLIB:GCONTEXT-CLIP-ORDERING is undocumented. XLIB:GENERALIZED-BOOLEAN is undocumented. XLIB:ILLEGAL-REQUEST-ERROR is undocumented. XLIB:IMAGE is undocumented. XLIB:IMAGE-PIXMAP (drawable image &key gcontext width height depth) [Function] XLIB:IMAGE-X is undocumented. XLIB:IMAGE-X-P ??? [Function] XLIB:IMAGE-XY is undocumented. XLIB:IMAGE-XY-P ??? [Function] XLIB:IMAGE-Z is undocumented. XLIB:IMAGE-Z-P ??? [Function] XLIB:INVALID-FONT is undocumented. XLIB:KEYCODE->CHARACTER (display keycode state &key keysym-index (keysym-index-function #'default-keysym-index)) [Function] XLIB:MAKE-EVENT-HANDLERS (&key (type 'array) default) [Function] XLIB:MAKE-WM-HINTS (&key ((:input #:g0) nil) ((:initial-state #:g1) nil) ((:icon-pixmap #:g2) nil) ((:icon-window #:g3) nil) ((:icon-x #:g4) nil) ((:icon-y #:g5) nil) ((:icon-mask #:g6) nil) ((:window-group #:g7) nil) ((:flags #:g8) 0)) [Function] XLIB:MAKE-WM-SIZE-HINTS (&key ((:user-specified-position-p #:g0) nil) ((:user-specified-size-p #:g1) nil) ((:x #:g2) nil) ((:y #:g3) nil) ((:width #:g4) nil) ((:height #:g5) nil) ((:min-width #:g6) nil) ((:min-height #:g7) nil) ((:max-width #:g8) nil) ((:max-height #:g9) nil) ((:width-inc #:g10) nil) ((:height-inc #:g11) nil) ((:min-aspect #:g12) nil) ((:max-aspect #:g13) nil) ((:base-width #:g14) nil) ((:base-height #:g15) nil) ((:win-gravity #:g16) nil) ((:program-specified-position-p #:g17) nil) ((:program-specified-size-p #:g18) nil)) [Function] XLIB:PIXMAP-FORMAT-BITS-PER-PIXEL ??? [Function] XLIB:PIXMAP-FORMAT-DEPTH ??? [Function] XLIB:PIXMAP-FORMAT-P ??? [Function] XLIB:PIXMAP-FORMAT-SCANLINE-PAD ??? [Function] XLIB:RESOURCE-DATABASE is undocumented. XLIB:SCREEN-ROOT-VISUAL-INFO ??? [Function] XLIB:TRANSLATION-FUNCTION is undocumented. XLIB:VISUAL-INFO-BITS-PER-RGB ??? [Function] XLIB:VISUAL-INFO-CLASS ???[Function] XLIB:VISUAL-INFO-COLORMAP-ENTRIES ??? [Function] XLIB:VISUAL-INFO-DISPLAY ??? [Function] XLIB:VISUAL-INFO-ID ??? [Function] XLIB:VISUAL-INFO-P ??? [Function] XLIB:VISUAL-INFO-PLIST ???[Function] XLIB:WINDOW-BACKGROUND is undocumented. XLIB:WINDOW-BORDER is undocumented. XLIB:WINDOW-PRIORITY is undocumented. XLIB:WM-HINTS-ICON-MASK ??? [Function] XLIB:WM-HINTS-ICON-PIXMAP ??? [Function] XLIB:WM-HINTS-ICON-WINDOW ??? [Function] XLIB:WM-HINTS-ICON-X ??? [Function] XLIB:WM-HINTS-ICON-Y ??? [Function] XLIB:WM-HINTS-INITIAL-STATE ??? [Function] XLIB:WM-HINTS-INPUT ??? [Function] XLIB:WM-HINTS-P ??? [Function] XLIB:WM-HINTS-WINDOW-GROUP ??? [Function] XLIB:WM-SIZE-HINTS is undocumented. XLIB:WM-SIZE-HINTS-BASE-HEIGHT ??? [Function] XLIB:WM-SIZE-HINTS-BASE-WIDTH ??? [Function] XLIB:WM-SIZE-HINTS-HEIGHT ??? [Function] XLIB:WM-SIZE-HINTS-HEIGHT-INC ??? [Function] XLIB:WM-SIZE-HINTS-MAX-ASPECT ??? [Function] XLIB:WM-SIZE-HINTS-MAX-HEIGHT ??? [Function] XLIB:WM-SIZE-HINTS-MAX-WIDTH ??? [Function] XLIB:WM-SIZE-HINTS-MIN-ASPECT ??? [Function] XLIB:WM-SIZE-HINTS-MIN-HEIGHT ??? [Function] XLIB:WM-SIZE-HINTS-MIN-WIDTH ??? [Function] XLIB:WM-SIZE-HINTS-P ??? [Function] XLIB:WM-SIZE-HINTS-USER-SPECIFIED-POSITION-P ??? [Function] XLIB:WM-SIZE-HINTS-USER-SPECIFIED-SIZE-P ??? [Function] XLIB:WM-SIZE-HINTS-WIDTH ??? [Function] XLIB:WM-SIZE-HINTS-WIDTH-INC ??? [Function] XLIB:WM-SIZE-HINTS-WIN-GRAVITY ??? [Function] XLIB:WM-SIZE-HINTS-X ??? [Function] XLIB:WM-SIZE-HINTS-Y ??? [Function] @end ignore @node Glossary, Function Index, Undocumented, Top @appendix Glossary @table @asis @item access control list X maintains a list of hosts from which client programs can be run. By default, only programs on the local host can use the display, plus any hosts specified in an initial list read by the server. This @emph{access control list} can be changed by clients on the local host. Some server implementations can also implement other authorization mechanisms in addition to or in place of this mechanism. The action of this mechanism can be conditional based on the authorization protocol name and data received by the server at connection setup. @item action A function that is designed to handle an input event. CLUE input processing consists of matching an event with an event specification found in a contact's @var{event-translations} slot and then calling actions associated with the matching event specification. @item active grab A grab is @emph{active} when the pointer or keyboard is actually owned by the single grabbing client. @item ancestors If W is an inferior of A, then A is an @emph{ancestor} of W. @item atom A unique ID corresponding to a string name. Atoms are used to identify properties, types, and selections. @item backing store When a server maintains the contents of a window, the off-screen saved pixels are known as a @emph{backing store}. @item before action An action of a @var{contact-display} that is called when an event is dispatched to a contact, but before any other contact input processing is performed. @item bit gravity When a window is resized, the contents of the window are not necessarily discarded. It is possible to request the server to relocate the previous contents to some region of the window. This attraction of window contents for some location of a window is known as @emph{bit} @emph{gravity}. @item bitmap A pixmap of depth one. @item button grabbing Buttons on the pointer can be passively @emph{grabbed} by a client. When the button is pressed, the pointer is then actively grabbed by the client. @item byte order For image (pixmap/bitmap) data, byte order is defined by the server, and clients with different native byte ordering must swap bytes as necessary. For all other parts of the protocol, the byte order is defined by the client, and the server swaps bytes as necessary. @item callback A function that represents a connection between a contact and the rest of an application program. A contact calls a callback function in order to report the results of the user interface component that it represents. @item children First-level subwindows of a window. @item class event Event translations that belong to all instances of a contact class. A class event @var{translations} translation is created by the @var{defevent} macro. @item class resources Resources defined for each instance of a contact class. Also see constraint resources. @item click A @var{:button-press} event followed immediately by a @var{:button-release} event for the same button, with no intervening change in pointer position or modifier key state. @item client An application program connects to the window system server by some interprocess communication (IPC) path, such as a TCP connection or a shared memory buffer. This program is referred to as a @emph{client} of the window system server. More precisely, the client is the IPC path itself. A program with multiple paths open to the server is viewed as multiple clients by the protocol. Resource lifetimes are controlled by connection lifetimes, not by program lifetimes. @item clipping regions In a graphics context, a bitmap or list of rectangles can be specified to restrict output to a particular region of the window. The image defined by the bitmap or rectangles is called a @emph{clipping region}. @item colormap A set of entries defining color values. The colormap associated with a window is used to display the contents of the window. Each pixel value indexes the colormap to produce RGB values that drive the guns of a monitor. Depending on hardware limitations, one or more colormaps can be installed at one time, such that windows associated with those maps display with correct colors. @item composite A subclass of @var{contact} representing contacts that are the parents of other contacts. A composite provides geometry management and input focus management services for the contacts that are its children. @item complete resource class A list of symbols containing the class of the contact, the class of the contact's @var{parent} (and so on), and the class of the @var{contact-display} to which the contact belongs. The complete resource class is one of the two items used as a key by a CLUE application in order to access a contact resource value in a resource database. @item complete resource name A list of symbols containing the @var{name} of the contact, the @var{name} of the contact's @var{parent} (and so on), and the name of the @var{contact-display} to which the contact belongs. The complete resource name is one of the two items used as a key by a CLUE application in order to access a contact resource value in a resource database. @item connection The IPC path between the server and client program. A client program typically has one connection to the server over which requests and events are sent. @item constraint resources Resources defined for each child belonging to a member of a composite class. Constraint resources are typically used to control the parent's geometry management policy. Also see class resources. @item contact The basic CLUE object for programming a user interface. @item contact-display The CLUE object type that represents a connection to an X server and that supports an event loop for application input. @item contact initialization The process of collecting initial values for all contact attributes. No server resources (windows and so on) are actually allocated until contact realization. @item contact realization The process of allocating contact resources. This process completes contact creation. @item containment A window contains the pointer if the window is viewable and the hot spot of the cursor is within a visible region of the window or a visible region of one of its inferiors. The border of the window is included as part of the window for containment. The pointer is in a window if the window contains the pointer but no inferior contains the pointer. @item content The single child of a shell. The basic geometry management policy implemented by the @var{shell} class constrains a shell and its content to have the same width and height; size changes to one are automatically applied to the other. @item coordinate system The coordinate system has x horizontal and y vertical, with the origin [0, 0] at the upper left. Coordinates are discrete and are in terms of pixels. Each window and pixmap has its own coordinate system. For a window, the origin is at the inside upper left, inside the border. @item cursor The visible shape of the pointer on a screen. It consists of a hot-spot, a source bitmap, a shape bitmap, and a pair of colors. The cursor defined for a window controls the visible appearance when the pointer is in that window. @item depth The depth of a window or pixmap is number of bits per pixel it has. The depth of a graphics context is the depth of the drawables it can be used in conjunction with for graphics output. @item descendant If W is an inferior of A, then W is a @emph{descendant} of A. @item device Keyboards, mice, tablets, track-balls, button boxes, and so forth, are all collectively known as input @emph{devices}. The core protocol only deals with two devices: the keyboard and the pointer. @item direct color A class of colormap in which a pixel value is decomposed into three separate subfields for indexing. One subfield indexes an array to produce red intensity values, the second subfield indexes a second array to produce blue intensity values, and the third subfield indexes a third array to produce green intensity values. The RGB values can be changed dynamically. @item dispatching an event The process of finding the appropriate contact and its actions. @item double-click A sequence of two clicks of the same button in rapid succession. @item drawable Both windows and pixmaps can be used as sources and destinations in graphics operations. These are collectively known as @emph{drawables}. However, an @var{:input-only} window cannot be used as a source or destination in a graphics operation. @item event Clients receive information asynchronously via @emph{events}. These events can be either asynchronously generated from devices, or generated as side effects of client requests. Events are grouped into types; events are never sent to a client by the server unless the client has specifically asked to be informed of that type of event, but clients can force events to be sent to other clients. Events are typically reported relative to a window. @item event compression Ignoring (or compressing) certain redundant input events. Compression of redundant events is controlled by the class slots @var{compress-exposures} and @var{compress-motion}, which are shared by all instances of a contact class. @item event loop The fundamental application control structure: wait for an event, figure out how to handle it, process the event, then go back and wait for the next one. In CLUE, the event loop is implemented using the @var{process-next-event} function. @item event mask Events are requested relative to a window. The set of event types a client requests relative to a window are described using an @emph{event mask}. @item event propagation Device-related events @emph{propagate} from the source window to ancestor windows until some client has expressed interest in handling that type of event, or until the event is discarded explicitly. @item event specification A notation for describing a certain sort of event. CLUE input processing consists of matching an event with an event specification found in a contact's @var{event-translations} slot and then calling actions associated with the matching event specification. @item event synchronization Certain race conditions are possible when demultiplexing device events to clients (in particular deciding where pointer and keyboard events should be sent when in the middle of window management operations). The event synchronization mechanism allows synchronous processing of device events. @item event source The smallest window containing the pointer is the @emph{source} of a device related event. @item event translation The process of determining which contact action functions will be executed. An event translation is a list found in a contact's @var{event-translations} slot associating an event specification with one or more action names. Also see class event translations. @item exposure event Servers do not guarantee to preserve the contents of windows when windows are obscured or reconfigured. @emph{Exposure} events are sent to clients to inform them when contents of regions of windows have been lost. @item extension Named @emph{extensions} to the core protocol can be defined to extend the system. Extension to output requests, resources, and event types are all possible, and expected. @item focus window Another term for the input focus. @item font A matrix of glyphs (typically characters). The protocol does no translation or interpretation of character sets. The client simply indicates values used to index the glyph array. A font contains additional metric information to determine inter-glyph and inter-line spacing. @item geometry management The process whereby a composite controls the geometrical properties of its child contacts; the composite is referred to as the geometry manager. @item glyph An image, typically of a character, in a font. @item grab Keyboard keys, the keyboard, pointer buttons, the pointer, and the server can be @emph{grabbed} for exclusive use by a client. In general, these facilities are not intended to be used by normal applications but are intended for various input and window managers to implement various styles of user interfaces. @item gcontext Shorthand for graphics context. @item graphics context Various information for graphics output is stored in a @emph{graphics context} (or gcontext), such as foreground pixel, background pixel, line width, clipping region, and so forth. A graphics context can only be used with drawables that have the same root and the same depth as the graphics context. @item gray scale A degenerate case of pseudo color, in which the red, green, and blue values in any given colormap entry are equal, thus producing shades of gray. The gray values can be changed dynamically. @item hot spot A cursor has an associated @emph{hot spot} that defines a point in the cursor that corresponds to the coordinates reported for the pointer. @item identifier Each resource has an @emph{identifier}, a unique value associated with it that clients use to name the resource. An identifier can be used over any connection to name the resource. @item inferiors All of the subwindows nested below a window: the children, the children's children, and so on. @item initialization See contact initialization. @item input event See event. @item input focus Normally a window defining the scope for processing of keyboard input. If a generated keyboard event would normally be reported to this window or one of its inferiors, the event is reported normally; otherwise, the event is reported with respect to the focus window. The input focus also can be set such that all keyboard events are discarded and that the focus window is dynamically taken to be the root window of whatever screen the pointer is on at each keyboard event. @item input-only window A window that cannot be used for graphics requests. @emph{input-only} windows are invisible, and can be used to control such things as cursors, input event generation, and grabbing. @emph{input-only} windows cannot have @emph{input/output} windows as inferiors. @item input/output window The normal kind of opaque window, used for both input and output. Input/output windows can have both @emph{input/output} and input-only windows as inferiors. @item insensitivity See sensitivity. @item interactive-stream A contact subclass designed to integrate CLUE with the conventional stream-based I/O of Common Lisp. @item key grabbing Keys on the keyboard can be passively @emph{grabbed} by a client. When the key is pressed, the keyboard is then actively grabbed by the client. @item keyboard grabbing A client can actively @emph{grab} control of the keyboard, and key events will be sent to that client rather than the client to which the events would normally have been sent. @item keysym An encoding of a symbol on a keycap on a keyboard. @item managed A contact under geometry management control. @item mapped A window is said to be @emph{mapped} if a map call has been performed on it. Unmapped windows and their inferiors are never viewable or visible. @item modifier keys SHIFT, CONTROL, META, SUPER, HYPER, ALT, Compose, Apple, CAPS LOCK, Shift Lock, and similar keys are called @emph{modifier keys}. @item monochrome A special case of static gray, in which there are only two colormap entries. @item obscure A window is @emph{obscured} if some other window obscures it. For example, window A obscures window B if: @itemize @bullet @item Both windows are viewable @var{:input-output} windows @item Window A is higher in the global stacking order than window B @item The rectangle defined by the outside edges of window A intersects the rectangle defined by the outside edges of window B @end itemize Notice that window borders are included in the calculation, and that a window can be obscured and yet still have visible regions. See occlude (there is a fine distinction between obscure and occlude). @item occlude A window is @emph{occluded} if some other window occludes it. For example, window A occludes window B if: @itemize @bullet @item Both windows are mapped @item Window A is higher in the global stacking order than window B @item The rectangle defined by the outside edges of window A intersects the rectangle defined by the outside edges of window B @end itemize Notice that window borders are included in the calculation. See obscure (there is a fine distinction between occlude and obscure). @item override-shell A subclass of @var{shell} used to override the window manager. This subclass contains pop-up menus and other temporary objects that the user can never resize and so on. @item padding Some padding bytes are inserted in the data stream to maintain alignment of the protocol requests on natural boundaries. This increases ease of portability to some machine architectures. @item parent window If C is a child of P, then P is the @emph{parent} of C. @item passive grab Grabbing a key or button is a @emph{passive grab}. The grab activates when the key or button is actually pressed. @item pixel value An @emph{n}-bit value, where @emph{n} is the number of bit planes used in (that is, the depth of) a particular window or pixmap. For a window, a pixel value indexes a colormap to derive an actual color to be displayed. @item pixmap A three dimensional array of bits. A pixmap is normally thought of as a two dimensional array of pixels, where each pixel can be a value from 0 to (2@emph{n})-1, where @emph{n} is the depth (z axis) of the pixmap. A pixmap can also be thought of as a stack of @emph{n} bitmaps. @item plane When a pixmap or window is thought of as a stack of bitmaps, each bitmap is called a @emph{plane} or @emph{bit plane}. @item plane mask Graphics operations can be restricted to only affect a subset of bit planes of a destination. A @emph{plane mask} is a bit mask describing which planes are to be modified, and it is stored in a graphics context. @item pointer The pointing device attached to the cursor and tracked on the screens. @item pointer grabbing A client can actively @emph{grab} control of the pointer, and button and motion events will be sent to that client rather than the client to which the events would normally have been sent. @item pointing device Typically a mouse or tablet, or some other device with effective dimensional motion. There is only one visible cursor defined by the core protocol, and it tracks whatever pointing device is attached as the pointer. @item pop-up One of the uses of a top-level shell (for example, a menu that pops up when a command button contact is activated). Setting the @var{state} of a shell to @var{:mapped} is sometimes referred to as @emph{mapping} or @emph{popping up} the shell. Setting the @var{state} of a shell to @var{:withdrawn} or @var{:iconic} is sometimes referred to as @emph{unmapping} or @emph{popping down} the shell. @item property Windows can have associated @emph{properties}, consisting of a name, a type, a data format, and some data. The protocol places no interpretation on properties; they are intended as a general-purpose naming mechanism for clients. For example, clients might share information such as resize hints, program names, and icon formats with a window manager via properties. @item property list The list of properties that have been defined for a window. @item pseudo color A class of colormap in which a pixel value indexes the colormap to produce independent red, green, and blue values. That is, the colormap is viewed as an array of triples (RGB values). The RGB values can be changed dynamically. @item realization See contact realization. @item redirecting control Window managers (or client programs) may choose to enforce window layout policy in various ways. When a client attempts to change the size or position of a window, the operation can be @emph{redirected} to a specified client, rather than the operation actually being performed. @item reply Information requested by a client program is sent back to the client with a @emph{reply}. Both events and replies are multiplexed on the same connection. Most requests do not generate replies. However, some requests generate multiple replies. @item representation type The type of representation of a resource value. For example, a color value might be represented either as a namestring ("red"), a pixel value, an RGB triplet, an HSV triplet, and so on. @item request A command to the server is called a @emph{request}. It is a single block of data sent over a connection. @item resource A value of the user interface that can be changed by the user in a resource database via CLX functions @var{add-resource}, @var{get-resource}, and so forth. See server resource. @item resource class, complete See complete resource class. @item resource database Conceptually, a set of resource name/value pairs (or resource bindings). CLX defines functions for storing and retrieving interface resources from a resource database. @item resource name, complete See complete resource name. @item RGB values @emph{Red}, @emph{green}, and @emph{blue} intensity values used to define color. These values are always represented as 16-bit unsigned numbers, with zero being the minimum intensity and 65535 being the maximum intensity. The values are scaled by the server to match the display hardware. @item root A special composite contact used to represent an entire display screen. @item root window Each screen has a @emph{root window} covering it. It cannot be reconfigured or unmapped, but otherwise acts as a full-fledged window. A root window has no parent. @item save set The @emph{save set} of a client is a list of other client's windows that, if they are inferiors of one of the client's windows at connection close, should not be destroyed and that should be remapped if it is unmapped. Save sets are typically used by window managers to avoid lost windows if the manager should terminate abnormally. @item scanline A list of pixel or bit values viewed as a horizontal row (all values having the same y coordinate) of an image, with the values ordered by increasing x coordinate. @item scanline order An image represented in @emph{scanline order} contains scanlines ordered by increasing y coordinate. @item screen A server can provide several independent @emph{screens}, which typically have physically independent monitors. This would be the expected configuration when there is only a single keyboard and pointer shared among the screens. @item selection A @emph{selection} can be thought of as an indirect property with dynamic type. That is, rather than having the property stored in the server, it is maintained by some client (the @emph{owner}). A selection is global in nature, being thought of as belonging to the user (but maintained by clients), rather than being private to a particular window subhierarchy or a particular set of clients. When a client asks for the contents of a selection, it specifies a selection @emph{target type}. This target type can be used to control the transmitted representation of the contents. For example, if the selection is "the last thing the user clicked on" and that is currently an image, then the target type might specify whether the contents of the image should be sent in XY Format or Z Format. The target type can also be used to control the class of contents transmitted; that is, asking for the looks (fonts, line spacing, indentation, and so forth) of a paragraph selection, rather than the text of the paragraph. The target type can also be used for other purposes; the semantics is not constrained by the protocol. @item sensitivity A condition in which a user interface component of an application will accept input. Conversely, when a contact is insensitive, events of particular types are not dispatched to the contact and are ignored. @item server The @emph{server} provides the basic windowing mechanism. It handles IPC connections from clients, demultiplexes graphics requests onto the screens, and multiplexes input back to the appropriate clients. @item server grabbing The server can be @emph{grabbed} by a single client for exclusive use. This prevents processing of any requests from other client connections until the grab is complete. This is typically only a transient state for such things as rubber-banding and pop-up menus, or to execute requests indivisibly. @item server resource Windows, pixmaps, cursors, fonts, gcontexts, and colormaps are known as resources. They all have unique identifiers associated with them for naming purposes. The lifetime of a resource is bounded by the lifetime of the connection over which the resource was created. See resource. @item shell A composite that handles the duties required by standard conventions for top-level X windows. @item sibling Children of the same parent window are known as @emph{sibling} windows. @item static color A degenerate case of pseudo color in which the RGB values are predefined and read-only. @item static gray A degenerate case of gray scale in which the gray values are predefined and read-only. The values are typically (near-)linear increasing ramps. @item stacking order Sibling windows can @emph{stack} on top of each other. Windows above both obscure and occlude lower windows. This is similar to paper on a desk. The relationship between sibling windows is known as the @emph{stacking order}. @item state A slot of @var{contact} that controls the visual effect of the contact. @item stipple A bitmap that is used to tile a region to serve as an additional clip mask for a fill operation with the foreground color. @item tile A pixmap can be replicated in two dimensions to @emph{tile} a region. The pixmap itself is also known as a tile. @item timer A CLUE object that provides support for animation and other types of time-sensitive user interfaces. A timer causes @var{:timer} events to be dispatched to a specific contact for processing. @item timestamp A time value, expressed in milliseconds, typically since the last server reset. Timestamp values wrap around (after about 49.7 days). The server, given its current time is represented by timestamp T, always interprets timestamps from clients by treating half of the timestamp space as being earlier in time than T and half of the timestamp space as being later in time than T. One timestamp value (named CurrentTime) is never generated by the server; this value is reserved for use in requests to represent the current server time. @item top-level contact A contact whose parent is a root. A top-level contact is usually a composite at the top of a hierarchy of other contacts created by an application program. @item top-level-session A subclass of @var{shell} that is used to communicate with a session manager. @item top-level-shell A subclass of @var{shell} that provides full window manager interaction. @item transient-shell A subclass of @var{shell} that a window manager typically will unmap when its owner becomes unmapped or iconified and will not allow to be individually iconified. @item true color A degenerate case of direct color in which the subfields in the pixel value directly encode the corresponding RGB values. That is, the colormap has predefined read-only RGB values. The values are typically (near-)linear increasing ramps. @item type An arbitrary atom used to identify the interpretation of property data. Types are completely uninterpreted by the server; they are solely for the benefit of clients. @item unmanaged A contact that is not under geometry management control. @item user interface A set of abstract interface objects used to control the dialog between an application and its human user. @item viewable A window is @emph{viewable} if it and all of its ancestors are mapped. This does not imply that any portion of the window is actually visible. Graphics requests can be performed on a window when it is not viewable, but output will not be retained unless the server is maintaining backing store. @item visible A region of a window is @emph{visible} if someone looking at the screen can actually see it; that is, the window is viewable and the region is not occluded by any other window. @item window gravity When windows are resized, subwindows can be repositioned automatically relative to some position in the window. This attraction of a subwindow to some part of its parent is known as @emph{window gravity}. @item window manager Manipulation of windows on the screen, and much of the user interface (policy) is typically provided by a @emph{window manager} client. @item window manager shell A subclass of @var{shell} called @var{wm-shell} that interacts with the window manager. @item XY Format The data for a pixmap is said to be in @emph{XY Format} if it is organized as a set of bitmaps representing individual bit planes, with the planes appearing from most to least significant in bit order. @item Z Format The data for a pixmap is said to be in @emph{Z Format} if it is organized as a set of pixel values in scanline order. @end table @node Function Index, Type Index, Glossary, Top @appendix Function Index @printindex fn @node Type Index, , Function Index, Top @appendix Type Index @printindex tp @bye ecl-16.1.2/src/clx/package.lisp000066400000000000000000000523031266352375300162240ustar00rootroot00000000000000;;; -*- Mode: LISP; Syntax: Common-lisp; Base: 10; Lowercase: Yes; -*- ;;; Copyright 1990 Massachusetts Institute of Technology, Cambridge, ;;; Massachusetts. All Rights Reserved. ;;; ;;; Permission to use, copy, modify, and distribute this software and its ;;; documentation for any purpose and without fee is hereby granted, provided ;;; that the above copyright notice appear in all copies and that both that ;;; copyright notice and this permission notice appear in supporting ;;; documentation, and that the name MIT not be used in advertising or ;;; publicity pertaining to distribution of the software without specific, ;;; written prior permission. ;;; The CLtL way #-clx-ansi-common-lisp (lisp:in-package :xlib :use '(:lisp)) #+(and (or kcl ibcl) (not clx-ansi-common-lisp)) (shadow '( rational )) #+(and CMU (not clx-ansi-common-lisp)) (shadow '(define-condition)) #+(and lispm (not clx-ansi-common-lisp)) (import '( sys:arglist sys:with-stack-list sys:with-stack-list* )) #+(and Genera (not clx-ansi-common-lisp)) (import '( future-common-lisp:print-unreadable-object future-common-lisp:with-standard-io-syntax zwei:indentation )) #+(and lcl3.0 (not clx-ansi-common-lisp)) (import '( lcl:arglist lcl:dynamic-extent lcl:type-error lucid::type-error-datum lucid::type-error-expected-type )) #+(and excl (not clx-ansi-common-lisp)) (import '( excl::arglist excl::dynamic-extent excl::type-error excl::type-error-datum excl::type-error-expected-type )) #+(and allegro (not clx-ansi-common-lisp)) (import '( excl::without-interrupts )) #-clx-ansi-common-lisp (export '( *version* access-control access-error access-hosts activate-screen-saver add-access-host add-resource add-to-save-set alist alloc-color alloc-color-cells alloc-color-planes alloc-error allow-events angle arc-seq array-index atom-error atom-name bell bit-gravity bitmap bitmap-format bitmap-format-lsb-first-p bitmap-format-p bitmap-format-pad bitmap-format-unit bitmap-image boole-constant boolean card16 card29 card32 card8 card8->char change-active-pointer-grab change-keyboard-control change-keyboard-mapping change-pointer-control change-property char->card8 char-ascent char-attributes char-descent char-left-bearing char-right-bearing char-width character->keysyms character-in-map-p circulate-window-down circulate-window-up clear-area close-display close-down-mode close-font closed-display color color-blue color-green color-p color-red color-rgb colormap colormap-display colormap-equal colormap-error colormap-id colormap-p colormap-plist colormap-visual-info connection-failure convert-selection copy-area copy-colormap-and-free copy-gcontext copy-gcontext-components copy-image copy-plane create-colormap create-cursor create-gcontext create-glyph-cursor create-image create-pixmap create-window cursor cursor-display cursor-equal cursor-error cursor-id cursor-p cursor-plist cut-buffer declare-event decode-core-error default-error-handler default-keysym-index default-keysym-translate define-error define-extension define-gcontext-accessor define-keysym define-keysym-set delete-property delete-resource destroy-subwindows destroy-window device-busy device-event-mask device-event-mask-class discard-current-event discard-font-info display display-after-function display-authorization-data display-authorization-name display-bitmap-format display-byte-order display-default-screen display-display display-error-handler display-extended-max-request-length display-finish-output display-force-output display-host display-image-lsb-first-p display-invoke-after-function display-keycode-range display-max-keycode display-max-request-length display-min-keycode display-motion-buffer-size display-nscreens display-p display-pixmap-formats display-plist display-protocol-major-version display-protocol-minor-version display-protocol-version display-release-number display-report-asynchronous-errors display-resource-id-base display-resource-id-mask display-roots display-vendor display-vendor-name display-xdefaults display-xid draw-arc draw-arcs draw-direction draw-glyph draw-glyphs draw-image-glyph draw-image-glyphs draw-line draw-lines draw-point draw-points draw-rectangle draw-rectangles draw-segments drawable drawable-border-width drawable-depth drawable-display drawable-equal drawable-error drawable-height drawable-id drawable-p drawable-plist drawable-root drawable-width drawable-x drawable-y error-key event-case event-cond event-handler event-key event-listen event-mask event-mask-class extension-opcode find-atom font font-all-chars-exist-p font-ascent font-default-char font-descent font-direction font-display font-equal font-error font-id font-max-byte1 font-max-byte2 font-max-char font-min-byte1 font-min-byte2 font-min-char font-name font-p font-path font-plist font-properties font-property fontable force-gcontext-changes free-colormap free-colors free-cursor free-gcontext free-pixmap gcontext gcontext-arc-mode gcontext-background gcontext-cache-p gcontext-cap-style gcontext-clip-mask gcontext-clip-ordering gcontext-clip-x gcontext-clip-y gcontext-dash-offset gcontext-dashes gcontext-display gcontext-equal gcontext-error gcontext-exposures gcontext-fill-rule gcontext-fill-style gcontext-font gcontext-foreground gcontext-function gcontext-id gcontext-join-style gcontext-key gcontext-line-style gcontext-line-width gcontext-p gcontext-plane-mask gcontext-plist gcontext-stipple gcontext-subwindow-mode gcontext-tile gcontext-ts-x gcontext-ts-y generalized-boolean get-external-event-code get-image get-property get-raw-image get-resource get-search-resource get-search-table get-standard-colormap get-wm-class global-pointer-position grab-button grab-key grab-keyboard grab-pointer grab-server grab-status icon-sizes iconify-window id-choice-error illegal-request-error image image-blue-mask image-depth image-green-mask image-height image-name image-pixmap image-plist image-red-mask image-width image-x image-x-hot image-x-p image-xy image-xy-bitmap-list image-xy-p image-y-hot image-z image-z-bits-per-pixel image-z-p image-z-pixarray implementation-error input-focus install-colormap installed-colormaps int16 int32 int8 intern-atom invalid-font keyboard-control keyboard-mapping keycode->character keycode->keysym keysym keysym->character keysym->keycodes keysym-in-map-p keysym-set kill-client kill-temporary-clients length-error list-extensions list-font-names list-fonts list-properties lookup-color lookup-error make-color make-event-handlers make-event-keys make-event-mask make-resource-database make-state-keys make-state-mask make-wm-hints make-wm-size-hints map-resource map-subwindows map-window mapping-notify mask16 mask32 match-error max-char-ascent max-char-attributes max-char-descent max-char-left-bearing max-char-right-bearing max-char-width merge-resources min-char-ascent min-char-attributes min-char-descent min-char-left-bearing min-char-right-bearing min-char-width missing-parameter modifier-key modifier-mapping modifier-mask motion-events name-error no-operation open-display open-font pixarray pixel pixmap pixmap-display pixmap-equal pixmap-error pixmap-format pixmap-format-bits-per-pixel pixmap-format-depth pixmap-format-p pixmap-format-scanline-pad pixmap-id pixmap-p pixmap-plist point-seq pointer-control pointer-event-mask pointer-event-mask-class pointer-mapping pointer-position process-event put-image put-raw-image query-best-cursor query-best-stipple query-best-tile query-colors query-extension query-keymap query-pointer query-tree queue-event read-bitmap-file read-resources recolor-cursor rect-seq remove-access-host remove-from-save-set reparent-window repeat-seq reply-length-error reply-timeout request-error reset-screen-saver resource-database resource-database-timestamp resource-error resource-id resource-key rgb-colormaps rgb-val root-resources rotate-cut-buffers rotate-properties screen screen-backing-stores screen-black-pixel screen-default-colormap screen-depths screen-event-mask-at-open screen-height screen-height-in-millimeters screen-max-installed-maps screen-min-installed-maps screen-p screen-plist screen-root screen-root-depth screen-root-visual screen-root-visual-info screen-save-unders-p screen-saver screen-white-pixel screen-width screen-width-in-millimeters seg-seq selection-owner send-event sequence-error set-access-control set-close-down-mode set-input-focus set-modifier-mapping set-pointer-mapping set-screen-saver set-selection-owner set-standard-colormap set-standard-properties set-wm-class set-wm-properties set-wm-resources state-keysym-p state-mask-key store-color store-colors stringable text-extents text-width timestamp transient-for translate-coordinates translate-default translation-function type-error undefine-keysym unexpected-reply ungrab-button ungrab-key ungrab-keyboard ungrab-pointer ungrab-server uninstall-colormap unknown-error unmap-subwindows unmap-window value-error visual-info visual-info-bits-per-rgb visual-info-blue-mask visual-info-class visual-info-colormap-entries visual-info-display visual-info-green-mask visual-info-id visual-info-p visual-info-plist visual-info-red-mask warp-pointer warp-pointer-if-inside warp-pointer-relative warp-pointer-relative-if-inside win-gravity window window-all-event-masks window-background window-backing-pixel window-backing-planes window-backing-store window-bit-gravity window-border window-class window-colormap window-colormap-installed-p window-cursor window-display window-do-not-propagate-mask window-equal window-error window-event-mask window-gravity window-id window-map-state window-override-redirect window-p window-plist window-priority window-save-under window-visual window-visual-info with-display with-event-queue with-gcontext with-server-grabbed with-state withdraw-window wm-client-machine wm-colormap-windows wm-command wm-hints wm-hints-flags wm-hints-icon-mask wm-hints-icon-pixmap wm-hints-icon-window wm-hints-icon-x wm-hints-icon-y wm-hints-initial-state wm-hints-input wm-hints-p wm-hints-window-group wm-icon-name wm-name wm-normal-hints wm-protocols wm-resources wm-size-hints wm-size-hints-base-height wm-size-hints-base-width wm-size-hints-height wm-size-hints-height-inc wm-size-hints-max-aspect wm-size-hints-max-height wm-size-hints-max-width wm-size-hints-min-aspect wm-size-hints-min-height wm-size-hints-min-width wm-size-hints-p wm-size-hints-user-specified-position-p wm-size-hints-user-specified-size-p wm-size-hints-width wm-size-hints-width-inc wm-size-hints-win-gravity wm-size-hints-x wm-size-hints-y wm-zoom-hints write-bitmap-file write-resources xatom )) ;;; The ANSI Common Lisp way #+(and Genera clx-ansi-common-lisp) (eval-when (:compile-toplevel :load-toplevel :execute) (setf *readtable* si:*ansi-common-lisp-readtable*)) #+clx-ansi-common-lisp (common-lisp:in-package :common-lisp-user) #+ecl (eval-when (#-stage1 :compile-toplevel :load-toplevel #-stage1 :execute) (require 'sockets)) #+clx-ansi-common-lisp (defpackage xlib (:use common-lisp) (:size 3000) #+(or kcl ibcl) (:shadow rational) #+allegro (:use cltl1) #+allegro (:import-from excl without-interrupts) #+excl (:import-from excl arglist) #+Genera (:import-from zwei indentation) #+lcl3.0 (:import-from lcl arglist) #+lispm (:import-from lisp char-bit) #+lispm (:import-from sys arglist with-stack-list with-stack-list*) #+(or sbcl ecl) (:use sb-bsd-sockets) (:export *version* access-control access-error access-hosts activate-screen-saver add-access-host add-resource add-to-save-set alist alloc-color alloc-color-cells alloc-color-planes alloc-error allow-events angle arc-seq array-index atom-error atom-name bell bit-gravity bitmap bitmap-format bitmap-format-lsb-first-p bitmap-format-p bitmap-format-pad bitmap-format-unit bitmap-image boole-constant boolean card16 card29 card32 card8 card8->char change-active-pointer-grab change-keyboard-control change-keyboard-mapping change-pointer-control change-property char->card8 char-ascent char-attributes char-descent char-left-bearing char-right-bearing char-width character->keysyms character-in-map-p circulate-window-down circulate-window-up clear-area close-display close-down-mode close-font closed-display color color-blue color-green color-p color-red color-rgb colormap colormap-display colormap-equal colormap-error colormap-id colormap-p colormap-plist colormap-visual-info connection-failure convert-selection copy-area copy-colormap-and-free copy-gcontext copy-gcontext-components copy-image copy-plane create-colormap create-cursor create-gcontext create-glyph-cursor create-image create-pixmap create-window cursor cursor-display cursor-equal cursor-error cursor-id cursor-p cursor-plist cut-buffer declare-event decode-core-error default-error-handler default-keysym-index default-keysym-translate define-error define-extension define-gcontext-accessor define-keysym define-keysym-set delete-property delete-resource destroy-subwindows destroy-window device-busy device-event-mask device-event-mask-class discard-current-event discard-font-info display display-after-function display-authorization-data display-authorization-name display-bitmap-format display-byte-order display-default-screen display-display display-error-handler display-extended-max-request-length display-finish-output display-force-output display-host display-image-lsb-first-p display-invoke-after-function display-keycode-range display-max-keycode display-max-request-length display-min-keycode display-motion-buffer-size display-nscreens display-p display-pixmap-formats display-plist display-protocol-major-version display-protocol-minor-version display-protocol-version display-release-number display-report-asynchronous-errors display-resource-id-base display-resource-id-mask display-roots display-vendor display-vendor-name display-xdefaults display-xid draw-arc draw-arcs draw-direction draw-glyph draw-glyphs draw-image-glyph draw-image-glyphs draw-line draw-lines draw-point draw-points draw-rectangle draw-rectangles draw-segments drawable drawable-border-width drawable-depth drawable-display drawable-equal drawable-error drawable-height drawable-id drawable-p drawable-plist drawable-root drawable-width drawable-x drawable-y error-key event-case event-cond event-handler event-key event-listen event-mask event-mask-class extension-opcode find-atom font font-all-chars-exist-p font-ascent font-default-char font-descent font-direction font-display font-equal font-error font-id font-max-byte1 font-max-byte2 font-max-char font-min-byte1 font-min-byte2 font-min-char font-name font-p font-path font-plist font-properties font-property fontable force-gcontext-changes free-colormap free-colors free-cursor free-gcontext free-pixmap gcontext gcontext-arc-mode gcontext-background gcontext-cache-p gcontext-cap-style gcontext-clip-mask gcontext-clip-ordering gcontext-clip-x gcontext-clip-y gcontext-dash-offset gcontext-dashes gcontext-display gcontext-equal gcontext-error gcontext-exposures gcontext-fill-rule gcontext-fill-style gcontext-font gcontext-foreground gcontext-function gcontext-id gcontext-join-style gcontext-key gcontext-line-style gcontext-line-width gcontext-p gcontext-plane-mask gcontext-plist gcontext-stipple gcontext-subwindow-mode gcontext-tile gcontext-ts-x gcontext-ts-y generalized-boolean get-external-event-code get-image get-property get-raw-image get-resource get-search-resource get-search-table get-standard-colormap get-wm-class global-pointer-position grab-button grab-key grab-keyboard grab-pointer grab-server grab-status icon-sizes iconify-window id-choice-error illegal-request-error image image-blue-mask image-depth image-green-mask image-height image-name image-pixmap image-plist image-red-mask image-width image-x image-x-hot image-x-p image-xy image-xy-bitmap-list image-xy-p image-y-hot image-z image-z-bits-per-pixel image-z-p image-z-pixarray implementation-error input-focus install-colormap installed-colormaps int16 int32 int8 intern-atom invalid-font keyboard-control keyboard-mapping keycode->character keycode->keysym keysym keysym->character keysym->keycodes keysym-in-map-p keysym-set kill-client kill-temporary-clients length-error list-extensions list-font-names list-fonts list-properties lookup-color lookup-error make-color make-event-handlers make-event-keys make-event-mask make-resource-database make-state-keys make-state-mask make-wm-hints make-wm-size-hints map-resource map-subwindows map-window mapping-notify mask16 mask32 match-error max-char-ascent max-char-attributes max-char-descent max-char-left-bearing max-char-right-bearing max-char-width merge-resources min-char-ascent min-char-attributes min-char-descent min-char-left-bearing min-char-right-bearing min-char-width missing-parameter modifier-key modifier-mapping modifier-mask motion-events name-error no-operation open-default-display open-display open-font pixarray pixel pixmap pixmap-display pixmap-equal pixmap-error pixmap-format pixmap-format-bits-per-pixel pixmap-format-depth pixmap-format-p pixmap-format-scanline-pad pixmap-id pixmap-p pixmap-plist point-seq pointer-control pointer-event-mask pointer-event-mask-class pointer-mapping pointer-position process-event put-image put-raw-image query-best-cursor query-best-stipple query-best-tile query-colors query-extension query-keymap query-pointer query-tree queue-event read-bitmap-file read-resources recolor-cursor rect-seq remove-access-host remove-from-save-set reparent-window repeat-seq reply-length-error reply-timeout request-error reset-screen-saver resource-database resource-database-timestamp resource-error resource-id resource-key rgb-colormaps rgb-val root-resources rotate-cut-buffers rotate-properties screen screen-backing-stores screen-black-pixel screen-default-colormap screen-depths screen-event-mask-at-open screen-height screen-height-in-millimeters screen-max-installed-maps screen-min-installed-maps screen-p screen-plist screen-root screen-root-depth screen-root-visual screen-root-visual-info screen-save-unders-p screen-saver screen-white-pixel screen-width screen-width-in-millimeters seg-seq selection-owner send-event sequence-error set-access-control set-close-down-mode set-input-focus set-modifier-mapping set-pointer-mapping set-screen-saver set-selection-owner set-standard-colormap set-standard-properties set-wm-class set-wm-properties set-wm-resources state-keysym-p state-mask-key store-color store-colors stringable text-extents text-width timestamp transient-for translate-coordinates translate-default translation-function undefine-keysym unexpected-reply ungrab-button ungrab-key ungrab-keyboard ungrab-pointer ungrab-server uninstall-colormap unknown-error unmap-subwindows unmap-window value-error visual-info visual-info-bits-per-rgb visual-info-blue-mask visual-info-class visual-info-colormap-entries visual-info-display visual-info-green-mask visual-info-id visual-info-p visual-info-plist visual-info-red-mask warp-pointer warp-pointer-if-inside warp-pointer-relative warp-pointer-relative-if-inside win-gravity window window-all-event-masks window-background window-backing-pixel window-backing-planes window-backing-store window-bit-gravity window-border window-class window-colormap window-colormap-installed-p window-cursor window-display window-do-not-propagate-mask window-equal window-error window-event-mask window-gravity window-id window-map-state window-override-redirect window-p window-plist window-priority window-save-under window-visual window-visual-info with-display with-event-queue with-gcontext with-server-grabbed with-state withdraw-window wm-client-machine wm-colormap-windows wm-command wm-hints wm-hints-flags wm-hints-icon-mask wm-hints-icon-pixmap wm-hints-icon-window wm-hints-icon-x wm-hints-icon-y wm-hints-initial-state wm-hints-input wm-hints-p wm-hints-window-group wm-icon-name wm-name wm-normal-hints wm-protocols wm-resources wm-size-hints wm-size-hints-base-height wm-size-hints-base-width wm-size-hints-height wm-size-hints-height-inc wm-size-hints-max-aspect wm-size-hints-max-height wm-size-hints-max-width wm-size-hints-min-aspect wm-size-hints-min-height wm-size-hints-min-width wm-size-hints-p wm-size-hints-user-specified-position-p wm-size-hints-user-specified-size-p wm-size-hints-width wm-size-hints-width-inc wm-size-hints-win-gravity wm-size-hints-x wm-size-hints-y wm-zoom-hints write-bitmap-file write-resources xatom)) ecl-16.1.2/src/clx/provide.lisp000066400000000000000000000034731266352375300163050ustar00rootroot00000000000000;;; -*- Mode: LISP; Syntax: Common-lisp; Base: 10; Lowercase: Yes; Package: USER; -*- ;;;; Module definition for CLX ;;; This file is a Common Lisp Module description, but you will have to edit ;;; it to meet the needs of your site. ;;; Ideally, this file (or a file that loads this file) should be ;;; located in the system directory that REQUIRE searches. Thus a user ;;; would say ;;; (require :clx) ;;; to load CLX. If there is no such registry, then the user must ;;; put in a site specific ;;; (require :clx ) ;;; #-clx-ansi-common-lisp (in-package :user) #+clx-ansi-common-lisp (in-package :common-lisp-user) #-clx-ansi-common-lisp (provide :clx) (defvar *clx-source-pathname* (pathname "/src/local/clx/*.l")) (defvar *clx-binary-pathname* (let ((lisp (or #+lucid "lucid" #+akcl "akcl" #+kcl "kcl" #+ibcl "ibcl" (error "Can't provide CLX for this lisp."))) (architecture (or #+(or sun3 (and sun (or mc68000 mc68020))) "sun3" #+(or sun4 sparc) "sparc" #+(and hp (or mc68000 mc68020)) "hp9000s300" #+vax "vax" #+prime "prime" #+sunrise "sunrise" #+ibm-rt-pc "ibm-rt-pc" #+mips "mips" #+prism "prism" (error "Can't provide CLX for this architecture.")))) (pathname (format nil "/src/local/clx/~A.~A/" lisp architecture)))) (defvar *compile-clx* nil) (load (merge-pathnames "defsystem" *clx-source-pathname*)) (if *compile-clx* (compile-clx *clx-source-pathname* *clx-binary-pathname*) (load-clx *clx-binary-pathname*)) ecl-16.1.2/src/clx/requests.lisp000066400000000000000000001673301266352375300165130ustar00rootroot00000000000000;;; -*- Mode: LISP; Syntax: Common-lisp; Package: XLIB; Base: 10; Lowercase: Yes -*- ;;; ;;; TEXAS INSTRUMENTS INCORPORATED ;;; P.O. BOX 2909 ;;; AUSTIN, TEXAS 78769 ;;; ;;; Copyright (C) 1987 Texas Instruments Incorporated. ;;; ;;; Permission is granted to any individual or institution to use, copy, modify, ;;; and distribute this software, provided that this complete copyright and ;;; permission notice is maintained, intact, in all copies and supporting ;;; documentation. ;;; ;;; Texas Instruments Incorporated provides this software "as is" without ;;; express or implied warranty. ;;; (in-package :xlib) (defun create-window (&key window (parent (required-arg parent)) (x (required-arg x)) (y (required-arg y)) (width (required-arg width)) (height (required-arg height)) (depth 0) (border-width 0) (class :copy) (visual :copy) background border bit-gravity gravity backing-store backing-planes backing-pixel save-under event-mask do-not-propagate-mask override-redirect colormap cursor) ;; Display is obtained from parent. Only non-nil attributes are passed on in ;; the request: the function makes no assumptions about what the actual protocol ;; defaults are. Width and height are the inside size, excluding border. (declare (type (or null window) window) (type window parent) ; required (type int16 x y) ;required (type card16 width height) ;required (type card16 depth border-width) (type (member :copy :input-output :input-only) class) (type (or (member :copy) visual-info resource-id) visual) (type (or null (member :none :parent-relative) pixel pixmap) background) (type (or null (member :copy) pixel pixmap) border) (type (or null bit-gravity) bit-gravity) (type (or null win-gravity) gravity) (type (or null (member :not-useful :when-mapped :always)) backing-store) (type (or null pixel) backing-planes backing-pixel) (type (or null event-mask) event-mask) (type (or null device-event-mask) do-not-propagate-mask) (type (or null (member :on :off)) save-under override-redirect) (type (or null (member :copy) colormap) colormap) (type (or null (member :none) cursor) cursor)) (declare (clx-values window)) (let* ((display (window-display parent)) (window (or window (make-window :display display))) (wid (allocate-resource-id display window 'window)) back-pixmap back-pixel border-pixmap border-pixel) (declare (type display display) (type window window) (type resource-id wid) (type (or null resource-id) back-pixmap border-pixmap) (type (or null pixel) back-pixel border-pixel)) (setf (window-id window) wid) (case background ((nil) nil) (:none (setq back-pixmap 0)) (:parent-relative (setq back-pixmap 1)) (otherwise (if (type? background 'pixmap) (setq back-pixmap (pixmap-id background)) (if (integerp background) (setq back-pixel background) (x-type-error background '(or null (member :none :parent-relative) integer pixmap)))))) (case border ((nil) nil) (:copy (setq border-pixmap 0)) (otherwise (if (type? border 'pixmap) (setq border-pixmap (pixmap-id border)) (if (integerp border) (setq border-pixel border) (x-type-error border '(or null (member :copy) integer pixmap)))))) (when event-mask (setq event-mask (encode-event-mask event-mask))) (when do-not-propagate-mask (setq do-not-propagate-mask (encode-device-event-mask do-not-propagate-mask))) ;Make the request (with-buffer-request (display +x-createwindow+) (data depth) (resource-id wid) (window parent) (int16 x y) (card16 width height border-width) ((member16 :copy :input-output :input-only) class) (resource-id (cond ((eq visual :copy) 0) ((typep visual 'resource-id) visual) (t (visual-info-id visual)))) (mask (card32 back-pixmap back-pixel border-pixmap border-pixel) ((member-vector +bit-gravity-vector+) bit-gravity) ((member-vector +win-gravity-vector+) gravity) ((member :not-useful :when-mapped :always) backing-store) (card32 backing-planes backing-pixel) ((member :off :on) override-redirect save-under) (card32 event-mask do-not-propagate-mask) ((or (member :copy) colormap) colormap) ((or (member :none) cursor) cursor))) window)) (defun destroy-window (window) (declare (type window window)) (with-buffer-request ((window-display window) +x-destroywindow+) (window window))) (defun destroy-subwindows (window) (declare (type window window)) (with-buffer-request ((window-display window) +x-destroysubwindows+) (window window))) (defun add-to-save-set (window) (declare (type window window)) (with-buffer-request ((window-display window) +x-changesaveset+) (data 0) (window window))) (defun remove-from-save-set (window) (declare (type window window)) (with-buffer-request ((window-display window) +x-changesaveset+) (data 1) (window window))) (defun reparent-window (window parent x y) (declare (type window window parent) (type int16 x y)) (with-buffer-request ((window-display window) +x-reparentwindow+) (window window parent) (int16 x y))) (defun map-window (window) (declare (type window window)) (with-buffer-request ((window-display window) +x-mapwindow+) (window window))) (defun map-subwindows (window) (declare (type window window)) (with-buffer-request ((window-display window) +x-mapsubwindows+) (window window))) (defun unmap-window (window) (declare (type window window)) (with-buffer-request ((window-display window) +x-unmapwindow+) (window window))) (defun unmap-subwindows (window) (declare (type window window)) (with-buffer-request ((window-display window) +x-unmapsubwindows+) (window window))) (defun circulate-window-up (window) (declare (type window window)) (with-buffer-request ((window-display window) +x-circulatewindow+) (data 0) (window window))) (defun circulate-window-down (window) (declare (type window window)) (with-buffer-request ((window-display window) +x-circulatewindow+) (data 1) (window window))) (defun query-tree (window &key (result-type 'list)) (declare (type window window) (type t result-type)) ;;type specifier (declare (clx-values (clx-sequence window) parent root)) (let ((display (window-display window))) (multiple-value-bind (root parent sequence) (with-buffer-request-and-reply (display +x-querytree+ nil :sizes (8 16 32)) ((window window)) (values (window-get 8) (resource-id-get 12) (sequence-get :length (card16-get 16) :result-type result-type :index +replysize+))) ;; Parent is NIL for root window (setq parent (and (plusp parent) (lookup-window display parent))) (dotimes (i (length sequence)) ; Convert ID's to window's (setf (elt sequence i) (lookup-window display (elt sequence i)))) (values sequence parent root)))) ;; Although atom-ids are not visible in the normal user interface, atom-ids might ;; appear in window properties and other user data, so conversion hooks are needed. (defun intern-atom (display name) (declare (type display display) (type xatom name)) (declare (clx-values resource-id)) (let ((name (if (or (null name) (keywordp name)) name (kintern (string name))))) (declare (type symbol name)) (or (atom-id name display) (let ((string (symbol-name name))) (declare (type string string)) (multiple-value-bind (id) (with-buffer-request-and-reply (display +x-internatom+ 12 :sizes 32) ((data 0) (card16 (length string)) (pad16 nil) (string string)) (values (resource-id-get 8))) (declare (type resource-id id)) (setf (atom-id name display) id) id))))) (defun find-atom (display name) ;; Same as INTERN-ATOM, but with the ONLY-IF-EXISTS flag True (declare (type display display) (type xatom name)) (declare (clx-values (or null resource-id))) (let ((name (if (or (null name) (keywordp name)) name (kintern (string name))))) (declare (type symbol name)) (or (atom-id name display) (let ((string (symbol-name name))) (declare (type string string)) (multiple-value-bind (id) (with-buffer-request-and-reply (display +x-internatom+ 12 :sizes 32) ((data 1) (card16 (length string)) (pad16 nil) (string string)) (values (or-get 8 null resource-id))) (declare (type (or null resource-id) id)) (when id (setf (atom-id name display) id)) id))))) (defun atom-name (display atom-id) (declare (type display display) (type resource-id atom-id)) (declare (clx-values keyword)) (if (zerop atom-id) nil (or (id-atom atom-id display) (let ((keyword (kintern (with-buffer-request-and-reply (display +x-getatomname+ nil :sizes (16)) ((resource-id atom-id)) (values (string-get (card16-get 8) +replysize+)))))) (declare (type keyword keyword)) (setf (atom-id keyword display) atom-id) keyword)))) ;;; For binary compatibility with older code (defun lookup-xatom (display atom-id) (declare (type display display) (type resource-id atom-id)) (atom-name display atom-id)) (defun change-property (window property data type format &key (mode :replace) (start 0) end transform) ; Start and end affect sub-sequence extracted from data. ; Transform is applied to each extracted element. (declare (type window window) (type xatom property type) (type (member 8 16 32) format) (type sequence data) (type (member :replace :prepend :append) mode) (type array-index start) (type (or null array-index) end) (type (or null (function (t) integer)) transform)) (unless end (setq end (length data))) (let* ((display (window-display window)) (length (index- end start)) (property-id (intern-atom display property)) (type-id (intern-atom display type))) (declare (type display display) (type array-index length) (type resource-id property-id type-id)) (with-buffer-request (display +x-changeproperty+) ((data (member :replace :prepend :append)) mode) (window window) (resource-id property-id type-id) (card8 format) (card32 length) (progn (ecase format (8 (sequence-put 24 data :format card8 :start start :end end :transform transform)) (16 (sequence-put 24 data :format card16 :start start :end end :transform transform)) (32 (sequence-put 24 data :format card32 :start start :end end :transform transform))))))) (defun delete-property (window property) (declare (type window window) (type xatom property)) (let* ((display (window-display window)) (property-id (intern-atom display property))) (declare (type display display) (type resource-id property-id)) (with-buffer-request (display +x-deleteproperty+) (window window) (resource-id property-id)))) (defun get-property (window property &key type (start 0) end delete-p (result-type 'list) transform) ;; Transform is applied to each integer retrieved. (declare (type window window) (type xatom property) (type (or null xatom) type) (type array-index start) (type (or null array-index) end) (type generalized-boolean delete-p) (type t result-type) ;a sequence type (type (or null (function (integer) t)) transform)) (declare (clx-values data (or null type) format bytes-after)) (let* ((display (window-display window)) (property-id (intern-atom display property)) (type-id (and type (intern-atom display type)))) (declare (type display display) (type resource-id property-id) (type (or null resource-id) type-id)) (multiple-value-bind (reply-format reply-type bytes-after data) (with-buffer-request-and-reply (display +x-getproperty+ nil :sizes (8 32)) (((data boolean) delete-p) (window window) (resource-id property-id) ((or null resource-id) type-id) (card32 start) (card32 (index- (or end 64000) start))) (let ((reply-format (card8-get 1)) (reply-type (card32-get 8)) (bytes-after (card32-get 12)) (nitems (card32-get 16))) (values reply-format reply-type bytes-after (and (plusp nitems) (ecase reply-format (0 nil) ;; (make-sequence result-type 0) ;; Property not found. (8 (sequence-get :result-type result-type :format card8 :length nitems :transform transform :index +replysize+)) (16 (sequence-get :result-type result-type :format card16 :length nitems :transform transform :index +replysize+)) (32 (sequence-get :result-type result-type :format card32 :length nitems :transform transform :index +replysize+))))))) (values data (and (plusp reply-type) (atom-name display reply-type)) reply-format bytes-after)))) (defun rotate-properties (window properties &optional (delta 1)) ;; Positive rotates left, negative rotates right (opposite of actual protocol request). (declare (type window window) (type sequence properties) ;; sequence of xatom (type int16 delta)) (let* ((display (window-display window)) (length (length properties)) (sequence (make-array length))) (declare (type display display) (type array-index length)) (with-vector (sequence vector) ;; Atoms must be interned before the RotateProperties request ;; is started to allow InternAtom requests to be made. (dotimes (i length) (setf (aref sequence i) (intern-atom display (elt properties i)))) (with-buffer-request (display +x-rotateproperties+) (window window) (card16 length) (int16 (- delta)) ((sequence :end length) sequence)))) nil) (defun list-properties (window &key (result-type 'list)) (declare (type window window) (type t result-type)) ;; a sequence type (declare (clx-values (clx-sequence keyword))) (let ((display (window-display window))) (multiple-value-bind (seq) (with-buffer-request-and-reply (display +x-listproperties+ nil :sizes 16) ((window window)) (values (sequence-get :result-type result-type :length (card16-get 8) :index +replysize+))) ;; lookup the atoms in the sequence (if (listp seq) (do ((elt seq (cdr elt))) ((endp elt) seq) (setf (car elt) (atom-name display (car elt)))) (dotimes (i (length seq) seq) (setf (aref seq i) (atom-name display (aref seq i)))))))) (defun selection-owner (display selection) (declare (type display display) (type xatom selection)) (declare (clx-values (or null window))) (let ((selection-id (intern-atom display selection))) (declare (type resource-id selection-id)) (multiple-value-bind (window) (with-buffer-request-and-reply (display +x-getselectionowner+ 12 :sizes 32) ((resource-id selection-id)) (values (resource-id-or-nil-get 8))) (and window (lookup-window display window))))) (defun set-selection-owner (display selection owner &optional time) (declare (type display display) (type xatom selection) (type (or null window) owner) (type timestamp time)) (let ((selection-id (intern-atom display selection))) (declare (type resource-id selection-id)) (with-buffer-request (display +x-setselectionowner+) ((or null window) owner) (resource-id selection-id) ((or null card32) time)) owner)) (defsetf selection-owner (display selection &optional time) (owner) ;; A bit strange, but retains setf form. `(set-selection-owner ,display ,selection ,owner ,time)) (defun convert-selection (selection type requestor &optional property time) (declare (type xatom selection type) (type window requestor) (type (or null xatom) property) (type timestamp time)) (let* ((display (window-display requestor)) (selection-id (intern-atom display selection)) (type-id (intern-atom display type)) (property-id (and property (intern-atom display property)))) (declare (type display display) (type resource-id selection-id type-id) (type (or null resource-id) property-id)) (with-buffer-request (display +x-convertselection+) (window requestor) (resource-id selection-id type-id) ((or null resource-id) property-id) ((or null card32) time)))) (defun send-event (window event-key event-mask &rest args &key propagate-p display &allow-other-keys) ;; Additional arguments depend on event-key, and are as specified further below ;; with declare-event, except that both resource-ids and resource objects are ;; accepted in the event components. The display argument is only required if the ;; window is :pointer-window or :input-focus. (declare (type (or window (member :pointer-window :input-focus)) window) (type event-key event-key) (type (or null event-mask) event-mask) (type generalized-boolean propagate-p) (type (or null display) display) (dynamic-extent args)) (unless event-mask (setq event-mask 0)) (unless display (setq display (window-display window))) (let ((internal-event-code (get-event-code event-key)) (external-event-code (get-external-event-code display event-key))) (declare (type card8 internal-event-code external-event-code)) ;; Ensure keyword atom-id's are cached (dolist (arg (cdr (assoc event-key '((:property-notify :atom) (:selection-clear :selection) (:selection-request :selection :target :property) (:selection-notify :selection :target :property) (:client-message :type)) :test #'eq))) (let ((keyword (getf args arg))) (intern-atom display keyword))) ;; Make the sendevent request (with-buffer-request (display +x-sendevent+) ((data boolean) propagate-p) (length 11) ;; 3 word request + 8 words for event = 11 ((or (member :pointer-window :input-focus) window) window) (card32 (encode-event-mask event-mask)) (card8 external-event-code) (progn (apply (svref *event-send-vector* internal-event-code) display args) (setf (buffer-boffset display) (index+ buffer-boffset 44)))))) (defun grab-pointer (window event-mask &key owner-p sync-pointer-p sync-keyboard-p confine-to cursor time) (declare (type window window) (type pointer-event-mask event-mask) (type generalized-boolean owner-p sync-pointer-p sync-keyboard-p) (type (or null window) confine-to) (type (or null cursor) cursor) (type timestamp time)) (declare (clx-values grab-status)) (let ((display (window-display window))) (with-buffer-request-and-reply (display +x-grabpointer+ nil :sizes 8) (((data boolean) owner-p) (window window) (card16 (encode-pointer-event-mask event-mask)) (boolean (not sync-pointer-p) (not sync-keyboard-p)) ((or null window) confine-to) ((or null cursor) cursor) ((or null card32) time)) (values (member8-get 1 :success :already-grabbed :invalid-time :not-viewable :frozen))))) (defun ungrab-pointer (display &key time) (declare (type timestamp time)) (with-buffer-request (display +x-ungrabpointer+) ((or null card32) time))) (defun grab-button (window button event-mask &key (modifiers :any) owner-p sync-pointer-p sync-keyboard-p confine-to cursor) (declare (type window window) (type (or (member :any) card8) button) (type modifier-mask modifiers) (type pointer-event-mask event-mask) (type generalized-boolean owner-p sync-pointer-p sync-keyboard-p) (type (or null window) confine-to) (type (or null cursor) cursor)) (with-buffer-request ((window-display window) +x-grabbutton+) ((data boolean) owner-p) (window window) (card16 (encode-pointer-event-mask event-mask)) (boolean (not sync-pointer-p) (not sync-keyboard-p)) ((or null window) confine-to) ((or null cursor) cursor) (card8 (if (eq button :any) 0 button)) (pad8 1) (card16 (encode-modifier-mask modifiers)))) (defun ungrab-button (window button &key (modifiers :any)) (declare (type window window) (type (or (member :any) card8) button) (type modifier-mask modifiers)) (with-buffer-request ((window-display window) +x-ungrabbutton+) (data (if (eq button :any) 0 button)) (window window) (card16 (encode-modifier-mask modifiers)))) (defun change-active-pointer-grab (display event-mask &optional cursor time) (declare (type display display) (type pointer-event-mask event-mask) (type (or null cursor) cursor) (type timestamp time)) (with-buffer-request (display +x-changeactivepointergrab+) ((or null cursor) cursor) ((or null card32) time) (card16 (encode-pointer-event-mask event-mask)))) (defun grab-keyboard (window &key owner-p sync-pointer-p sync-keyboard-p time) (declare (type window window) (type generalized-boolean owner-p sync-pointer-p sync-keyboard-p) (type timestamp time)) (declare (clx-values grab-status)) (let ((display (window-display window))) (with-buffer-request-and-reply (display +x-grabkeyboard+ nil :sizes 8) (((data boolean) owner-p) (window window) ((or null card32) time) (boolean (not sync-pointer-p) (not sync-keyboard-p))) (values (member8-get 1 :success :already-grabbed :invalid-time :not-viewable :frozen))))) (defun ungrab-keyboard (display &key time) (declare (type display display) (type timestamp time)) (with-buffer-request (display +x-ungrabkeyboard+) ((or null card32) time))) (defun grab-key (window key &key (modifiers 0) owner-p sync-pointer-p sync-keyboard-p) (declare (type window window) (type generalized-boolean owner-p sync-pointer-p sync-keyboard-p) (type (or (member :any) card8) key) (type modifier-mask modifiers)) (with-buffer-request ((window-display window) +x-grabkey+) ((data boolean) owner-p) (window window) (card16 (encode-modifier-mask modifiers)) (card8 (if (eq key :any) 0 key)) (boolean (not sync-pointer-p) (not sync-keyboard-p)))) (defun ungrab-key (window key &key (modifiers 0)) (declare (type window window) (type (or (member :any) card8) key) (type modifier-mask modifiers)) (with-buffer-request ((window-display window) +x-ungrabkey+) (data (if (eq key :any) 0 key)) (window window) (card16 (encode-modifier-mask modifiers)))) (defun allow-events (display mode &optional time) (declare (type display display) (type (member :async-pointer :sync-pointer :replay-pointer :async-keyboard :sync-keyboard :replay-keyboard :async-both :sync-both) mode) (type timestamp time)) (with-buffer-request (display +x-allowevents+) ((data (member :async-pointer :sync-pointer :replay-pointer :async-keyboard :sync-keyboard :replay-keyboard :async-both :sync-both)) mode) ((or null card32) time))) (defun grab-server (display) (declare (type display display)) (with-buffer-request (display +x-grabserver+))) (defun ungrab-server (display) (with-buffer-request (display +x-ungrabserver+))) (defmacro with-server-grabbed ((display) &body body) ;; The body is not surrounded by a with-display. (let ((disp (if (symbolp display) display (gensym)))) `(let ((,disp ,display)) (declare (type display ,disp)) (unwind-protect (progn (grab-server ,disp) ,@body) (ungrab-server ,disp))))) (defun query-pointer (window) (declare (type window window)) (declare (clx-values x y same-screen-p child mask root-x root-y root)) (let ((display (window-display window))) (with-buffer-request-and-reply (display +x-querypointer+ 26 :sizes (8 16 32)) ((window window)) (values (int16-get 20) (int16-get 22) (boolean-get 1) (or-get 12 null window) (card16-get 24) (int16-get 16) (int16-get 18) (window-get 8))))) (defun pointer-position (window) (declare (type window window)) (declare (clx-values x y same-screen-p)) (let ((display (window-display window))) (with-buffer-request-and-reply (display +x-querypointer+ 24 :sizes (8 16)) ((window window)) (values (int16-get 20) (int16-get 22) (boolean-get 1))))) (defun global-pointer-position (display) (declare (type display display)) (declare (clx-values root-x root-y root)) (with-buffer-request-and-reply (display +x-querypointer+ 20 :sizes (16 32)) ((window (screen-root (first (display-roots display))))) (values (int16-get 16) (int16-get 18) (window-get 8)))) (defun motion-events (window &key start stop (result-type 'list)) (declare (type window window) (type timestamp start stop) (type t result-type)) ;; a type specifier (declare (clx-values (repeat-seq (integer x) (integer y) (timestamp time)))) (let ((display (window-display window))) (with-buffer-request-and-reply (display +x-getmotionevents+ nil :sizes 32) ((window window) ((or null card32) start stop)) (values (sequence-get :result-type result-type :length (index* (card32-get 8) 3) :index +replysize+))))) (defun translate-coordinates (src src-x src-y dst) ;; Returns NIL when not on the same screen (declare (type window src) (type int16 src-x src-y) (type window dst)) (declare (clx-values dst-x dst-y child)) (let ((display (window-display src))) (with-buffer-request-and-reply (display +x-translatecoords+ 16 :sizes (8 16 32)) ((window src dst) (int16 src-x src-y)) (and (boolean-get 1) (values (int16-get 12) (int16-get 14) (or-get 8 null window)))))) (defun warp-pointer (dst dst-x dst-y) (declare (type window dst) (type int16 dst-x dst-y)) (with-buffer-request ((window-display dst) +x-warppointer+) (resource-id 0) ;; None (window dst) (int16 0 0) (card16 0 0) (int16 dst-x dst-y))) (defun warp-pointer-relative (display x-off y-off) (declare (type display display) (type int16 x-off y-off)) (with-buffer-request (display +x-warppointer+) (resource-id 0) ;; None (resource-id 0) ;; None (int16 0 0) (card16 0 0) (int16 x-off y-off))) (defun warp-pointer-if-inside (dst dst-x dst-y src src-x src-y &optional src-width src-height) ;; Passing in a zero src-width or src-height is a no-op. ;; A null src-width or src-height translates into a zero value in the protocol request. (declare (type window dst src) (type int16 dst-x dst-y src-x src-y) (type (or null card16) src-width src-height)) (unless (or (eql src-width 0) (eql src-height 0)) (with-buffer-request ((window-display dst) +x-warppointer+) (window src dst) (int16 src-x src-y) (card16 (or src-width 0) (or src-height 0)) (int16 dst-x dst-y)))) (defun warp-pointer-relative-if-inside (x-off y-off src src-x src-y &optional src-width src-height) ;; Passing in a zero src-width or src-height is a no-op. ;; A null src-width or src-height translates into a zero value in the protocol request. (declare (type window src) (type int16 x-off y-off src-x src-y) (type (or null card16) src-width src-height)) (unless (or (eql src-width 0) (eql src-height 0)) (with-buffer-request ((window-display src) +x-warppointer+) (window src) (resource-id 0) ;; None (int16 src-x src-y) (card16 (or src-width 0) (or src-height 0)) (int16 x-off y-off)))) (defun set-input-focus (display focus revert-to &optional time) (declare (type display display) (type (or (member :none :pointer-root) window) focus) (type (member :none :pointer-root :parent) revert-to) (type timestamp time)) (with-buffer-request (display +x-setinputfocus+) ((data (member :none :pointer-root :parent)) revert-to) ((or window (member :none :pointer-root)) focus) ((or null card32) time))) (defun input-focus (display) (declare (type display display)) (declare (clx-values focus revert-to)) (with-buffer-request-and-reply (display +x-getinputfocus+ 16 :sizes (8 32)) () (values (or-get 8 window (member :none :pointer-root)) (member8-get 1 :none :pointer-root :parent)))) (defun query-keymap (display &optional bit-vector) (declare (type display display) (type (or null (bit-vector 256)) bit-vector)) (declare (clx-values (bit-vector 256))) (with-buffer-request-and-reply (display +x-querykeymap+ 40 :sizes 8) () (values (bit-vector256-get 8 8 bit-vector)))) (defun create-pixmap (&key pixmap (width (required-arg width)) (height (required-arg height)) (depth (required-arg depth)) (drawable (required-arg drawable))) (declare (type (or null pixmap) pixmap) (type card8 depth) ;; required (type card16 width height) ;; required (type drawable drawable)) ;; required (declare (clx-values pixmap)) (let* ((display (drawable-display drawable)) (pixmap (or pixmap (make-pixmap :display display))) (pid (allocate-resource-id display pixmap 'pixmap))) (setf (pixmap-id pixmap) pid) (with-buffer-request (display +x-createpixmap+) (data depth) (resource-id pid) (drawable drawable) (card16 width height)) pixmap)) (defun free-pixmap (pixmap) (declare (type pixmap pixmap)) (let ((display (pixmap-display pixmap))) (with-buffer-request (display +x-freepixmap+) (pixmap pixmap)) (deallocate-resource-id display (pixmap-id pixmap) 'pixmap))) (defun clear-area (window &key (x 0) (y 0) width height exposures-p) ;; Passing in a zero width or height is a no-op. ;; A null width or height translates into a zero value in the protocol request. (declare (type window window) (type int16 x y) (type (or null card16) width height) (type generalized-boolean exposures-p)) (unless (or (eql width 0) (eql height 0)) (with-buffer-request ((window-display window) +x-cleartobackground+) ((data boolean) exposures-p) (window window) (int16 x y) (card16 (or width 0) (or height 0))))) (defun copy-area (src gcontext src-x src-y width height dst dst-x dst-y) (declare (type drawable src dst) (type gcontext gcontext) (type int16 src-x src-y dst-x dst-y) (type card16 width height)) (with-buffer-request ((drawable-display src) +x-copyarea+ :gc-force gcontext) (drawable src dst) (gcontext gcontext) (int16 src-x src-y dst-x dst-y) (card16 width height))) (defun copy-plane (src gcontext plane src-x src-y width height dst dst-x dst-y) (declare (type drawable src dst) (type gcontext gcontext) (type pixel plane) (type int16 src-x src-y dst-x dst-y) (type card16 width height)) (with-buffer-request ((drawable-display src) +x-copyplane+ :gc-force gcontext) (drawable src dst) (gcontext gcontext) (int16 src-x src-y dst-x dst-y) (card16 width height) (card32 plane))) (defun create-colormap (visual-info window &optional alloc-p) (declare (type (or visual-info resource-id) visual-info) (type window window) (type generalized-boolean alloc-p)) (declare (clx-values colormap)) (let ((display (window-display window))) (when (typep visual-info 'resource-id) (setf visual-info (visual-info display visual-info))) (let* ((colormap (make-colormap :display display :visual-info visual-info)) (id (allocate-resource-id display colormap 'colormap))) (setf (colormap-id colormap) id) (with-buffer-request (display +x-createcolormap+) ((data boolean) alloc-p) (card29 id) (window window) (card29 (visual-info-id visual-info))) colormap))) (defun free-colormap (colormap) (declare (type colormap colormap)) (let ((display (colormap-display colormap))) (with-buffer-request (display +x-freecolormap+) (colormap colormap)) (deallocate-resource-id display (colormap-id colormap) 'colormap))) (defun copy-colormap-and-free (colormap) (declare (type colormap colormap)) (declare (clx-values colormap)) (let* ((display (colormap-display colormap)) (new-colormap (make-colormap :display display :visual-info (colormap-visual-info colormap))) (id (allocate-resource-id display new-colormap 'colormap))) (setf (colormap-id new-colormap) id) (with-buffer-request (display +x-copycolormapandfree+) (resource-id id) (colormap colormap)) new-colormap)) (defun install-colormap (colormap) (declare (type colormap colormap)) (with-buffer-request ((colormap-display colormap) +x-installcolormap+) (colormap colormap))) (defun uninstall-colormap (colormap) (declare (type colormap colormap)) (with-buffer-request ((colormap-display colormap) +x-uninstallcolormap+) (colormap colormap))) (defun installed-colormaps (window &key (result-type 'list)) (declare (type window window) (type t result-type)) ;; CL type (declare (clx-values (clx-sequence colormap))) (let ((display (window-display window))) (flet ((get-colormap (id) (lookup-colormap display id))) (with-buffer-request-and-reply (display +x-listinstalledcolormaps+ nil :sizes 16) ((window window)) (values (sequence-get :result-type result-type :length (card16-get 8) :transform #'get-colormap :index +replysize+)))))) (defun alloc-color (colormap color) (declare (type colormap colormap) (type (or stringable color) color)) (declare (clx-values pixel screen-color exact-color)) (let ((display (colormap-display colormap))) (etypecase color (color (with-buffer-request-and-reply (display +x-alloccolor+ 20 :sizes (16 32)) ((colormap colormap) (rgb-val (color-red color) (color-green color) (color-blue color)) (pad16 nil)) (values (card32-get 16) (make-color :red (rgb-val-get 8) :green (rgb-val-get 10) :blue (rgb-val-get 12)) color))) (stringable (let* ((string (string color)) (length (length string))) (with-buffer-request-and-reply (display +x-allocnamedcolor+ 24 :sizes (16 32)) ((colormap colormap) (card16 length) (pad16 nil) (string string)) (values (card32-get 8) (make-color :red (rgb-val-get 18) :green (rgb-val-get 20) :blue (rgb-val-get 22)) (make-color :red (rgb-val-get 12) :green (rgb-val-get 14) :blue (rgb-val-get 16))))))))) (defun alloc-color-cells (colormap colors &key (planes 0) contiguous-p (result-type 'list)) (declare (type colormap colormap) (type card16 colors planes) (type generalized-boolean contiguous-p) (type t result-type)) ;; CL type (declare (clx-values (clx-sequence pixel) (clx-sequence mask))) (let ((display (colormap-display colormap))) (with-buffer-request-and-reply (display +x-alloccolorcells+ nil :sizes 16) (((data boolean) contiguous-p) (colormap colormap) (card16 colors planes)) (let ((pixel-length (card16-get 8)) (mask-length (card16-get 10))) (values (sequence-get :result-type result-type :length pixel-length :index +replysize+) (sequence-get :result-type result-type :length mask-length :index (index+ +replysize+ (index* pixel-length 4)))))))) (defun alloc-color-planes (colormap colors &key (reds 0) (greens 0) (blues 0) contiguous-p (result-type 'list)) (declare (type colormap colormap) (type card16 colors reds greens blues) (type generalized-boolean contiguous-p) (type t result-type)) ;; CL type (declare (clx-values (clx-sequence pixel) red-mask green-mask blue-mask)) (let ((display (colormap-display colormap))) (with-buffer-request-and-reply (display +x-alloccolorplanes+ nil :sizes (16 32)) (((data boolean) contiguous-p) (colormap colormap) (card16 colors reds greens blues)) (let ((red-mask (card32-get 12)) (green-mask (card32-get 16)) (blue-mask (card32-get 20))) (values (sequence-get :result-type result-type :length (card16-get 8) :index +replysize+) red-mask green-mask blue-mask))))) (defun free-colors (colormap pixels &optional (plane-mask 0)) (declare (type colormap colormap) (type sequence pixels) ;; Sequence of integers (type pixel plane-mask)) (with-buffer-request ((colormap-display colormap) +x-freecolors+) (colormap colormap) (card32 plane-mask) (sequence pixels))) (defun store-color (colormap pixel spec &key (red-p t) (green-p t) (blue-p t)) (declare (type colormap colormap) (type pixel pixel) (type (or stringable color) spec) (type generalized-boolean red-p green-p blue-p)) (let ((display (colormap-display colormap)) (flags 0)) (declare (type display display) (type card8 flags)) (when red-p (setq flags 1)) (when green-p (incf flags 2)) (when blue-p (incf flags 4)) (etypecase spec (color (with-buffer-request (display +x-storecolors+) (colormap colormap) (card32 pixel) (rgb-val (color-red spec) (color-green spec) (color-blue spec)) (card8 flags) (pad8 nil))) (stringable (let* ((string (string spec)) (length (length string))) (with-buffer-request (display +x-storenamedcolor+) ((data card8) flags) (colormap colormap) (card32 pixel) (card16 length) (pad16 nil) (string string))))))) (defun store-colors (colormap specs &key (red-p t) (green-p t) (blue-p t)) ;; If stringables are specified for colors, it is unspecified whether all ;; stringables are first resolved and then a single StoreColors protocol request is ;; issued, or whether multiple StoreColors protocol requests are issued. (declare (type colormap colormap) (type sequence specs) (type generalized-boolean red-p green-p blue-p)) (etypecase specs (list (do ((spec specs (cddr spec))) ((endp spec)) (store-color colormap (car spec) (cadr spec) :red-p red-p :green-p green-p :blue-p blue-p))) (vector (do ((i 0 (+ i 2)) (len (length specs))) ((>= i len)) (store-color colormap (aref specs i) (aref specs (1+ i)) :red-p red-p :green-p green-p :blue-p blue-p))))) (defun query-colors (colormap pixels &key (result-type 'list)) (declare (type colormap colormap) (type sequence pixels) ;; sequence of integer (type t result-type)) ;; a type specifier (declare (clx-values (clx-sequence color))) (let ((display (colormap-display colormap))) (with-buffer-request-and-reply (display +x-querycolors+ nil :sizes (8 16)) ((colormap colormap) (sequence pixels)) (let ((sequence (make-sequence result-type (card16-get 8)))) (advance-buffer-offset +replysize+) (dotimes (i (length sequence) sequence) (setf (elt sequence i) (make-color :red (rgb-val-get 0) :green (rgb-val-get 2) :blue (rgb-val-get 4))) (advance-buffer-offset 8)))))) (defun lookup-color (colormap name) (declare (type colormap colormap) (type stringable name)) (declare (clx-values screen-color true-color)) (let* ((display (colormap-display colormap)) (string (string name)) (length (length string))) (with-buffer-request-and-reply (display +x-lookupcolor+ 20 :sizes 16) ((colormap colormap) (card16 length) (pad16 nil) (string string)) (values (make-color :red (rgb-val-get 14) :green (rgb-val-get 16) :blue (rgb-val-get 18)) (make-color :red (rgb-val-get 8) :green (rgb-val-get 10) :blue (rgb-val-get 12)))))) (defun create-cursor (&key (source (required-arg source)) mask (x (required-arg x)) (y (required-arg y)) (foreground (required-arg foreground)) (background (required-arg background))) (declare (type pixmap source) ;; required (type (or null pixmap) mask) (type card16 x y) ;; required (type (or null color) foreground background)) ;; required (declare (clx-values cursor)) (let* ((display (pixmap-display source)) (cursor (make-cursor :display display)) (cid (allocate-resource-id display cursor 'cursor))) (setf (cursor-id cursor) cid) (with-buffer-request (display +x-createcursor+) (resource-id cid) (pixmap source) ((or null pixmap) mask) (rgb-val (color-red foreground) (color-green foreground) (color-blue foreground)) (rgb-val (color-red background) (color-green background) (color-blue background)) (card16 x y)) cursor)) (defun create-glyph-cursor (&key (source-font (required-arg source-font)) (source-char (required-arg source-char)) mask-font mask-char (foreground (required-arg foreground)) (background (required-arg background))) (declare (type font source-font) ;; Required (type card16 source-char) ;; Required (type (or null font) mask-font) (type (or null card16) mask-char) (type color foreground background)) ;; required (declare (clx-values cursor)) (let* ((display (font-display source-font)) (cursor (make-cursor :display display)) (cid (allocate-resource-id display cursor 'cursor)) (source-font-id (font-id source-font)) (mask-font-id (if mask-font (font-id mask-font) 0))) (setf (cursor-id cursor) cid) (unless mask-char (setq mask-char 0)) (with-buffer-request (display +x-createglyphcursor+) (resource-id cid source-font-id mask-font-id) (card16 source-char) (card16 mask-char) (rgb-val (color-red foreground) (color-green foreground) (color-blue foreground)) (rgb-val (color-red background) (color-green background) (color-blue background))) cursor)) (defun free-cursor (cursor) (declare (type cursor cursor)) (let ((display (cursor-display cursor))) (with-buffer-request (display +x-freecursor+) (cursor cursor)) (deallocate-resource-id display (cursor-id cursor) 'cursor))) (defun recolor-cursor (cursor foreground background) (declare (type cursor cursor) (type color foreground background)) (with-buffer-request ((cursor-display cursor) +x-recolorcursor+) (cursor cursor) (rgb-val (color-red foreground) (color-green foreground) (color-blue foreground)) (rgb-val (color-red background) (color-green background) (color-blue background)) )) (defun query-best-cursor (width height drawable) (declare (type card16 width height) (type (or drawable display) drawable)) (declare (clx-values width height)) ;; Drawable can be a display for compatibility. (multiple-value-bind (display drawable) (if (type? drawable 'drawable) (values (drawable-display drawable) drawable) (values drawable (screen-root (display-default-screen drawable)))) (with-buffer-request-and-reply (display +x-querybestsize+ 12 :sizes 16) ((data 0) (window drawable) (card16 width height)) (values (card16-get 8) (card16-get 10))))) (defun query-best-tile (width height drawable) (declare (type card16 width height) (type drawable drawable)) (declare (clx-values width height)) (let ((display (drawable-display drawable))) (with-buffer-request-and-reply (display +x-querybestsize+ 12 :sizes 16) ((data 1) (drawable drawable) (card16 width height)) (values (card16-get 8) (card16-get 10))))) (defun query-best-stipple (width height drawable) (declare (type card16 width height) (type drawable drawable)) (declare (clx-values width height)) (let ((display (drawable-display drawable))) (with-buffer-request-and-reply (display +x-querybestsize+ 12 :sizes 16) ((data 2) (drawable drawable) (card16 width height)) (values (card16-get 8) (card16-get 10))))) (defun query-extension (display name) (declare (type display display) (type stringable name)) (declare (clx-values major-opcode first-event first-error)) (let ((string (string name))) (with-buffer-request-and-reply (display +x-queryextension+ 12 :sizes 8) ((card16 (length string)) (pad16 nil) (string string)) (and (boolean-get 8) ;; If present (values (card8-get 9) (card8-get 10) (card8-get 11)))))) (defun list-extensions (display &key (result-type 'list)) (declare (type display display) (type t result-type)) ;; CL type (declare (clx-values (clx-sequence string))) (with-buffer-request-and-reply (display +x-listextensions+ size :sizes 8) () (values (read-sequence-string buffer-bbuf (index- size +replysize+) (card8-get 1) result-type +replysize+)))) (defun change-keyboard-control (display &key key-click-percent bell-percent bell-pitch bell-duration led led-mode key auto-repeat-mode) (declare (type display display) (type (or null (member :default) int16) key-click-percent bell-percent bell-pitch bell-duration) (type (or null card8) led key) (type (or null (member :on :off)) led-mode) (type (or null (member :on :off :default)) auto-repeat-mode)) (when (eq key-click-percent :default) (setq key-click-percent -1)) (when (eq bell-percent :default) (setq bell-percent -1)) (when (eq bell-pitch :default) (setq bell-pitch -1)) (when (eq bell-duration :default) (setq bell-duration -1)) (with-buffer-request (display +x-changekeyboardcontrol+ :sizes (32)) (mask (integer key-click-percent bell-percent bell-pitch bell-duration) (card32 led) ((member :off :on) led-mode) (card32 key) ((member :off :on :default) auto-repeat-mode)))) (defun keyboard-control (display) (declare (type display display)) (declare (clx-values key-click-percent bell-percent bell-pitch bell-duration led-mask global-auto-repeat auto-repeats)) (with-buffer-request-and-reply (display +x-getkeyboardcontrol+ 32 :sizes (8 16 32)) () (values (card8-get 12) (card8-get 13) (card16-get 14) (card16-get 16) (card32-get 8) (member8-get 1 :off :on) (bit-vector256-get 20)))) ;; The base volume should ;; be considered to be the "desired" volume in the normal case; that is, a ;; typical application should call XBell with 0 as the percent. Rather ;; than using a simple sum, the percent argument is instead used as the ;; percentage of the remaining range to alter the base volume by. That is, ;; the actual volume is: ;; if percent>=0: base - [(base * percent) / 100] + percent ;; if percent<0: base + [(base * percent) / 100] (defun bell (display &optional (percent-from-normal 0)) ;; It is assumed that an eventual audio extension to X will provide more complete control. (declare (type display display) (type int8 percent-from-normal)) (with-buffer-request (display +x-bell+) (data (int8->card8 percent-from-normal)))) (defun pointer-mapping (display &key (result-type 'list)) (declare (type display display) (type t result-type)) ;; CL type (declare (clx-values sequence)) ;; Sequence of card (with-buffer-request-and-reply (display +x-getpointermapping+ nil :sizes 8) () (values (sequence-get :length (card8-get 1) :result-type result-type :format card8 :index +replysize+)))) (defun set-pointer-mapping (display map) ;; Can signal device-busy. (declare (type display display) (type sequence map)) ;; Sequence of card8 (when (with-buffer-request-and-reply (display +x-setpointermapping+ 2 :sizes 8) ((data (length map)) ((sequence :format card8) map)) (values (boolean-get 1))) (x-error 'device-busy :display display)) map) (defsetf pointer-mapping set-pointer-mapping) (defun change-pointer-control (display &key acceleration threshold) ;; Acceleration is rationalized if necessary. (declare (type display display) (type (or null (member :default) number) acceleration) (type (or null (member :default) integer) threshold)) (flet ((rationalize16 (number) ;; Rationalize NUMBER into the ratio of two signed 16 bit numbers (declare (type number number)) (declare (clx-values numerator denominator)) (do* ((rational (rationalize number)) (numerator (numerator rational) (ash numerator -1)) (denominator (denominator rational) (ash denominator -1))) ((or (= numerator 1) (and (< (abs numerator) #x8000) (< denominator #x8000))) (values numerator (min denominator #x7fff)))))) (declare (inline rationalize16)) (let ((acceleration-p 1) (threshold-p 1) (numerator 0) (denominator 1)) (declare (type card8 acceleration-p threshold-p) (type int16 numerator denominator)) (cond ((eq acceleration :default) (setq numerator -1)) (acceleration (multiple-value-setq (numerator denominator) (rationalize16 acceleration))) (t (setq acceleration-p 0))) (cond ((eq threshold :default) (setq threshold -1)) ((null threshold) (setq threshold -1 threshold-p 0))) (with-buffer-request (display +x-changepointercontrol+) (int16 numerator denominator threshold) (card8 acceleration-p threshold-p))))) (defun pointer-control (display) (declare (type display display)) (declare (clx-values acceleration threshold)) (with-buffer-request-and-reply (display +x-getpointercontrol+ 16 :sizes 16) () (values (/ (card16-get 8) (card16-get 10)) ; Should we float this? (card16-get 12)))) (defun set-screen-saver (display timeout interval blanking exposures) ;; Timeout and interval are in seconds, will be rounded to minutes. (declare (type display display) (type (or (member :default) int16) timeout interval) (type (member :on :off :default :yes :no) blanking exposures)) (case blanking (:yes (setq blanking :on)) (:no (setq blanking :off))) (case exposures (:yes (setq exposures :on)) (:no (setq exposures :off))) (when (eq timeout :default) (setq timeout -1)) (when (eq interval :default) (setq interval -1)) (with-buffer-request (display +x-setscreensaver+) (int16 timeout interval) ((member8 :on :off :default) blanking exposures))) (defun screen-saver (display) ;; Returns timeout and interval in seconds. (declare (type display display)) (declare (clx-values timeout interval blanking exposures)) (with-buffer-request-and-reply (display +x-getscreensaver+ 14 :sizes (8 16)) () (values (card16-get 8) (card16-get 10) (member8-get 12 :on :off :default) (member8-get 13 :on :off :default)))) (defun activate-screen-saver (display) (declare (type display display)) (with-buffer-request (display +x-forcescreensaver+) (data 1))) (defun reset-screen-saver (display) (declare (type display display)) (with-buffer-request (display +x-forcescreensaver+) (data 0))) (defun add-access-host (display host &optional (family :internet)) ;; A string must be acceptable as a host, but otherwise the possible types for ;; host are not constrained, and will likely be very system dependent. ;; This implementation uses a list whose car is the family keyword ;; (:internet :DECnet :Chaos) and cdr is a list of network address bytes. (declare (type display display) (type (or stringable list) host) (type (or null (member :internet :decnet :chaos) card8) family)) (change-access-host display host family nil)) (defun remove-access-host (display host &optional (family :internet)) ;; A string must be acceptable as a host, but otherwise the possible types for ;; host are not constrained, and will likely be very system dependent. ;; This implementation uses a list whose car is the family keyword ;; (:internet :DECnet :Chaos) and cdr is a list of network address bytes. (declare (type display display) (type (or stringable list) host) (type (or null (member :internet :decnet :chaos) card8) family)) (change-access-host display host family t)) (defun change-access-host (display host family remove-p) (declare (type display display) (type (or stringable list) host) (type (or null (member :internet :decnet :chaos) card8) family)) (unless (consp host) (setq host (host-address host family))) (let ((family (car host)) (address (cdr host))) (with-buffer-request (display +x-changehosts+) ((data boolean) remove-p) (card8 (encode-type (or null (member :internet :decnet :chaos) card32) family)) (card16 (length address)) ((sequence :format card8) address)))) (defun access-hosts (display &optional (result-type 'list)) ;; The type of host objects returned is not constrained, except that the hosts must ;; be acceptable to add-access-host and remove-access-host. ;; This implementation uses a list whose car is the family keyword ;; (:internet :DECnet :Chaos) and cdr is a list of network address bytes. (declare (type display display) (type t result-type)) ;; CL type (declare (clx-values (clx-sequence host) enabled-p)) (with-buffer-request-and-reply (display +x-listhosts+ nil :sizes (8 16)) () (let* ((enabled-p (boolean-get 1)) (nhosts (card16-get 8)) (sequence (make-sequence result-type nhosts))) (advance-buffer-offset +replysize+) (dotimes (i nhosts) (let ((family (card8-get 0)) (len (card16-get 2))) (setf (elt sequence i) (cons (if (< family 3) (svref '#(:internet :decnet :chaos) family) family) (sequence-get :length len :format card8 :result-type 'list :index (+ buffer-boffset 4)))) (advance-buffer-offset (+ 4 (* 4 (ceiling len 4)))))) (values sequence enabled-p)))) (defun access-control (display) (declare (type display display)) (declare (clx-values generalized-boolean)) ;; True when access-control is ENABLED (with-buffer-request-and-reply (display +x-listhosts+ 2 :sizes 8) () (boolean-get 1))) (defun set-access-control (display enabled-p) (declare (type display display) (type generalized-boolean enabled-p)) (with-buffer-request (display +x-changeaccesscontrol+) ((data boolean) enabled-p)) enabled-p) (defsetf access-control set-access-control) (defun close-down-mode (display) ;; setf'able ;; Cached locally in display object. (declare (type display display)) (declare (clx-values (member :destroy :retain-permanent :retain-temporary nil))) (display-close-down-mode display)) (defun set-close-down-mode (display mode) ;; Cached locally in display object. (declare (type display display) (type (member :destroy :retain-permanent :retain-temporary) mode)) (setf (display-close-down-mode display) mode) (with-buffer-request (display +x-changeclosedownmode+ :sizes (32)) ((data (member :destroy :retain-permanent :retain-temporary)) mode)) mode) (defsetf close-down-mode set-close-down-mode) (defun kill-client (display resource-id) (declare (type display display) (type resource-id resource-id)) (with-buffer-request (display +x-killclient+) (resource-id resource-id))) (defun kill-temporary-clients (display) (declare (type display display)) (with-buffer-request (display +x-killclient+) (resource-id 0))) (defun no-operation (display) (declare (type display display)) (with-buffer-request (display +x-nooperation+))) ecl-16.1.2/src/clx/resource.lisp000066400000000000000000000715561266352375300164730ustar00rootroot00000000000000;;; -*- Mode:Common-Lisp; Package:XLIB; Syntax:COMMON-LISP; Base:10; Lowercase:T -*- ;; RESOURCE - Lisp version of XLIB's Xrm resource manager ;;; ;;; TEXAS INSTRUMENTS INCORPORATED ;;; P.O. BOX 2909 ;;; AUSTIN, TEXAS 78769 ;;; ;;; Copyright (C) 1987 Texas Instruments Incorporated. ;;; ;;; Permission is granted to any individual or institution to use, copy, modify, ;;; and distribute this software, provided that this complete copyright and ;;; permission notice is maintained, intact, in all copies and supporting ;;; documentation. ;;; ;;; Texas Instruments Incorporated provides this software "as is" without ;;; express or implied warranty. ;;; (in-package :xlib) ;; The C version of this uses a 64 entry hash table at each entry. ;; Small hash tables lose in Lisp, so we do linear searches on lists. (defstruct (resource-database (:copier nil) (:predicate nil) (:print-function print-resource-database) (:constructor make-resource-database-internal) #+explorer (:callable-constructors nil) ) (name nil :type stringable :read-only t) (value nil) (tight nil :type list) ;; List of resource-database (loose nil :type list) ;; List of resource-database ) (defun print-resource-database (database stream depth) (declare (type resource-database database) (ignore depth)) (print-unreadable-object (database stream :type t) (write-string (string (resource-database-name database)) stream) (when (resource-database-value database) (write-string " " stream) (prin1 (resource-database-value database) stream)))) ;; The value slot of the top-level resource-database structure is used for a ;; time-stamp. (defun make-resource-database () ;; Make a resource-database with initial timestamp of 0 (make-resource-database-internal :name "Top-Level" :value 0)) (defun resource-database-timestamp (database) (declare (type resource-database database)) (resource-database-value database)) (defun incf-resource-database-timestamp (database) ;; Increment the timestamp (declare (type resource-database database)) (let ((timestamp (resource-database-value database))) (setf (resource-database-value database) (if (= timestamp most-positive-fixnum) most-negative-fixnum (1+ timestamp))))) ;; DEBUG FUNCTION (not exported) (defun print-db (entry &optional (level 0) type) ;; Debug function to print a resource database (format t "~%~v@t~s~:[~; *~]~@[ Value ~s~]" level (resource-database-name entry) (eq type 'loose) (resource-database-value entry)) (when (resource-database-tight entry) (dolist (tight (resource-database-tight entry)) (print-db tight (+ 2 level) 'tight))) (when (resource-database-loose entry) (dolist (loose (resource-database-loose entry)) (print-db loose (+ 2 level) 'loose)))) ;; DEBUG FUNCTION #+comment (defun print-search-table (table) (terpri) (dolist (dbase-list table) (format t "~%~s" dbase-list) (dolist (db dbase-list) (print-db db) (dolist (dblist table) (unless (eq dblist dbase-list) (when (member db dblist) (format t " duplicate at ~s" db)))) ))) ;; ;; If this is true, resource symbols will be compared in a case-insensitive ;; manner, and converting a resource string to a keyword will uppercaseify it. ;; (defparameter *uppercase-resource-symbols* nil) (defun resource-key (stringable) ;; Ensure STRINGABLE is a keyword. (declare (type stringable stringable)) (etypecase stringable (symbol (if (keywordp (the symbol stringable)) stringable (kintern (symbol-name (the symbol stringable))))) (string (if *uppercase-resource-symbols* (setq stringable (#-allegro string-upcase #+allegro correct-case (the string stringable)))) (kintern (the string stringable))))) (defun stringable-equal (a b) ;; Compare two stringables. ;; Ignore case when comparing to a symbol. (declare (type stringable a b)) (declare (clx-values generalized-boolean)) (etypecase a (string (etypecase b (string (string= (the string a) (the string b))) (symbol (if *uppercase-resource-symbols* (string-equal (the string a) (the string (symbol-name (the symbol b)))) (string= (the string a) (the string (symbol-name (the symbol b)))))))) (symbol (etypecase b (string (if *uppercase-resource-symbols* (string-equal (the string (symbol-name (the symbol a))) (the string b)) (string= (the string (symbol-name (the symbol a))) (the string b)))) (symbol (string= (the string (symbol-name (the symbol a))) (the string (symbol-name (the symbol b))))))))) ;;;----------------------------------------------------------------------------- ;;; Add/delete resource (defun add-resource (database name-list value) ;; name-list is a list of either strings or symbols. If a symbol, ;; case-insensitive comparisons will be used, if a string, ;; case-sensitive comparisons will be used. The symbol '* or ;; string "*" are used as wildcards, matching anything or nothing. (declare (type resource-database database) (type (clx-list stringable) name-list) (type t value)) (unless value (error "Null resource values are ignored")) (incf-resource-database-timestamp database) (do* ((list name-list (cdr list)) (name (car list) (car list)) (node database) (loose-p nil)) ((endp list) (setf (resource-database-value node) value)) ;; Key is the first name that isn't * (if (stringable-equal name "*") (setq loose-p t) ;; find the entry associated with name (progn (do ((entry (if loose-p (resource-database-loose node) (resource-database-tight node)) (cdr entry))) ((endp entry) ;; Entry not found - create a new one (setq entry (make-resource-database-internal :name name)) (if loose-p (push entry (resource-database-loose node)) (push entry (resource-database-tight node))) (setq node entry)) (when (stringable-equal name (resource-database-name (car entry))) ;; Found entry - use it (return (setq node (car entry))))) (setq loose-p nil))))) (defun delete-resource (database name-list) (declare (type resource-database database) (type list name-list)) (incf-resource-database-timestamp database) (delete-resource-internal database name-list)) (defun delete-resource-internal (database name-list) (declare (type resource-database database) (type (clx-list stringable) name-list)) (do* ((list name-list (cdr list)) (string (car list) (car list)) (node database) (loose-p nil)) ((endp list) nil) ;; Key is the first name that isn't * (if (stringable-equal string "*") (setq loose-p t) ;; find the entry associated with name (progn (do* ((first-entry (if loose-p (resource-database-loose node) (resource-database-tight node))) (entry-list first-entry (cdr entry-list)) (entry (car entry-list) (car entry-list))) ((endp entry-list) ;; Entry not found - exit (return-from delete-resource-internal nil)) (when (stringable-equal string (resource-database-name entry)) (when (cdr list) (delete-resource-internal entry (cdr list))) (when (and (null (resource-database-loose entry)) (null (resource-database-tight entry))) (if loose-p (setf (resource-database-loose node) (delete entry (resource-database-loose node) :test #'eq :count 1)) (setf (resource-database-tight node) (delete entry (resource-database-tight node) :test #'eq :count 1)))) (return-from delete-resource-internal t))) (setq loose-p nil))))) ;;;----------------------------------------------------------------------------- ;;; Get Resource (defun get-resource (database value-name value-class full-name full-class) ;; Return the value of the resource in DATABASE whose partial name ;; most closely matches (append full-name (list value-name)) and ;; (append full-class (list value-class)). (declare (type resource-database database) (type stringable value-name value-class) (type (clx-list stringable) full-name full-class)) (declare (clx-values value)) (let ((names (append full-name (list value-name))) (classes (append full-class (list value-class)))) (let* ((result (get-entry (resource-database-tight database) (resource-database-loose database) names classes))) (when result (resource-database-value result))))) (defun get-entry-lookup (table name names classes) (declare (type list table names classes) (symbol name)) (dolist (entry table) (declare (type resource-database entry)) (when (stringable-equal name (resource-database-name entry)) (if (null (cdr names)) (return entry) (let ((result (get-entry (resource-database-tight entry) (resource-database-loose entry) (cdr names) (cdr classes)))) (declare (type (or null resource-database) result)) (when result (return result) )))))) (defun get-entry (tight loose names classes &aux result) (declare (type list tight loose names classes)) (let ((name (car names)) (class (car classes))) (declare (type symbol name class)) (cond ((and tight (get-entry-lookup tight name names classes))) ((and loose (get-entry-lookup loose name names classes))) ((and tight (not (stringable-equal name class)) (get-entry-lookup tight class names classes))) ((and loose (not (stringable-equal name class)) (get-entry-lookup loose class names classes))) (loose (loop (pop names) (pop classes) (unless (and names classes) (return nil)) (setq name (car names) class (car classes)) (when (setq result (get-entry-lookup loose name names classes)) (return result)) (when (and (not (stringable-equal name class)) (setq result (get-entry-lookup loose class names classes))) (return result)) ))))) ;;;----------------------------------------------------------------------------- ;;; Get-resource with search-table (defun get-search-resource (table name class) ;; (get-search-resource (get-search-table database full-name full-class) ;; value-name value-class) ;; is equivalent to ;; (get-resource database value-name value-class full-name full-class) ;; But since most of the work is done by get-search-table, ;; get-search-resource is MUCH faster when getting several resources with ;; the same full-name/full-class (declare (type list table) (type stringable name class)) (let ((do-class (and class (not (stringable-equal name class))))) (dolist (dbase-list table) (declare (type list dbase-list)) (dolist (dbase dbase-list) (declare (type resource-database dbase)) (when (stringable-equal name (resource-database-name dbase)) (return-from get-search-resource (resource-database-value dbase)))) (when do-class (dolist (dbase dbase-list) (declare (type resource-database dbase)) (when (stringable-equal class (resource-database-name dbase)) (return-from get-search-resource (resource-database-value dbase)))))))) (defvar *get-table-result*) (defun get-search-table (database full-name full-class) ;; Return a search table for use with get-search-resource. (declare (type resource-database database) (type (clx-list stringable) full-name full-class)) (declare (clx-values value)) (let* ((tight (resource-database-tight database)) (loose (resource-database-loose database)) (result (cons nil nil)) (*get-table-result* result)) (declare (type list tight loose) (type cons result)) (when (or tight loose) (when full-name (get-tables tight loose full-name full-class)) ;; Pick up bindings of the form (* name). These are the elements of ;; top-level loose without further tight/loose databases. ;; ;; (Hack: these bindings belong in ANY search table, so recomputing them ;; is a drag. True fix involves redesigning entire lookup ;; data-structure/algorithm.) ;; (let ((universal-bindings (remove nil loose :test-not #'eq :key #'(lambda (database) (or (resource-database-tight database) (resource-database-loose database)))))) (when universal-bindings (setf (cdr *get-table-result*) (list universal-bindings))))) (cdr result))) (defun get-tables-lookup (dbase name names classes) (declare (type list dbase names classes) (type symbol name)) (declare (optimize speed)) (dolist (entry dbase) (declare (type resource-database entry)) (when (stringable-equal name (resource-database-name entry)) (let ((tight (resource-database-tight entry)) (loose (resource-database-loose entry))) (declare (type list tight loose)) (when (or tight loose) (if (cdr names) (get-tables tight loose (cdr names) (cdr classes)) (when tight (let ((result *get-table-result*)) ;; Put tight at end of *get-table-result* (setf (cdr result) (setq *get-table-result* (cons tight nil)))))) (when loose (let ((result *get-table-result*)) ;; Put loose at end of *get-table-result* (setf (cdr result) (setq *get-table-result* (cons loose nil)))))))))) (defun get-tables (tight loose names classes) (declare (type list tight loose names classes)) (let ((name (car names)) (class (car classes))) (declare (type symbol name class)) (when tight (get-tables-lookup tight name names classes)) (when loose (get-tables-lookup loose name names classes)) (when (and tight (not (stringable-equal name class))) (get-tables-lookup tight class names classes)) (when (and loose (not (stringable-equal name class))) (get-tables-lookup loose class names classes)) (when loose (loop (pop names) (pop classes) (unless (and names classes) (return nil)) (setq name (car names) class (car classes)) (get-tables-lookup loose name names classes) (unless (stringable-equal name class) (get-tables-lookup loose class names classes)) )))) ;;;----------------------------------------------------------------------------- ;;; Utility functions (defun map-resource (database function &rest args) ;; Call FUNCTION on each resource in DATABASE. ;; FUNCTION is called with arguments (name-list value . args) (declare (type resource-database database) (type (function (list t &rest t) t) function) #+clx-ansi-common-lisp (dynamic-extent function) #+(and lispm (not clx-ansi-common-lisp)) (sys:downward-funarg function) (dynamic-extent args)) (declare (clx-values nil)) (labels ((map-resource-internal (database function args name) (declare (type resource-database database) (type (function (list t &rest t) t) function) (type list name) #+clx-ansi-common-lisp (dynamic-extent function) #+(and lispm (not clx-ansi-common-lisp)) (sys:downward-funarg function)) (let ((tight (resource-database-tight database)) (loose (resource-database-loose database))) (declare (type list tight loose)) (dolist (resource tight) (declare (type resource-database resource)) (let ((value (resource-database-value resource)) (name (append name (list (resource-database-name resource))))) (if value (apply function name value args) (map-resource-internal resource function args name)))) (dolist (resource loose) (declare (type resource-database resource)) (let ((value (resource-database-value resource)) (name (append name (list "*" (resource-database-name resource))))) (if value (apply function name value args) (map-resource-internal resource function args name))))))) (map-resource-internal database function args nil))) (defun merge-resources (database with-database) (declare (type resource-database database with-database)) (declare (clx-values resource-database)) (map-resource database #'(lambda (name value database) (add-resource database name value)) with-database) with-database) (defun char-memq (key char) ;; Used as a test function for POSITION (declare (type base-char char)) (member char key)) (defmacro resource-with-open-file ((stream pathname &rest options) &body body) ;; Private WITH-OPEN-FILE, which, when pathname is a stream, uses it as the ;; stream (let ((abortp (gensym)) (streamp (gensym))) `(let* ((,abortp t) (,streamp (streamp pathname)) (,stream (if ,streamp pathname (open ,pathname ,@options)))) (unwind-protect (multiple-value-prog1 (progn ,@body) (setq ,abortp nil)) (unless ,streamp (close stream :abort ,abortp)))))) (defun read-resources (database pathname &key key test test-not) ;; Merges resources from a file in standard X11 format with DATABASE. ;; KEY is a function used for converting value-strings, the default is ;; identity. TEST and TEST-NOT are predicates used for filtering ;; which resources to include in the database. They are called with ;; the name and results of the KEY function. (declare (type resource-database database) (type (or pathname string stream) pathname) (type (or null (function (string) t)) key) (type (or null (function (list t) generalized-boolean)) test test-not)) (declare (clx-values resource-database)) (resource-with-open-file (stream pathname) (loop (let ((string (read-line stream nil :eof))) (declare (type (or string keyword) string)) (when (eq string :eof) (return database)) (let* ((end (length string)) (i (position '(#\tab #\space) string :test-not #'char-memq :end end)) (term nil)) (declare (type array-index end) (type (or null array-index) i term)) (when i ;; else blank line (case (char string i) (#\! nil) ;; Comment - skip ;;(#.(card8->char 0) nil) ;; terminator for C strings - skip (#\# ;; Include (setq term (position '(#\tab #\space) string :test #'char-memq :start i :end end)) (when (string-equal string "#INCLUDE" :start1 i :end1 term) (let ((path (merge-pathnames (string-trim '(#\tab #\space #\") (subseq string (1+ term))) (truename stream)))) (read-resources database path :key key :test test :test-not test-not)))) (otherwise (multiple-value-bind (name-list value) (parse-resource string i end) (when name-list (when key (setq value (funcall key value))) (when (cond (test (funcall test name-list value)) (test-not (not (funcall test-not name-list value))) (t t)) (add-resource database name-list value)))))))))))) (defun parse-resource (string &optional (start 0) end) ;; Parse a resource specfication string into a list of names and a value ;; string (declare (type string string) (type array-index start) (type (or null array-index) end)) (declare (clx-values name-list value)) (do ((i start) (end (or end (length string))) (term) (name-list)) ((>= i end)) (declare (type array-index end) (type (or null array-index) i term)) (setq term (position '(#\. #\* #\:) string :test #'char-memq :start i :end end)) (case (and term (char string term)) ;; Name seperator (#\. (when (> term i) (push (subseq string i term) name-list))) ;; Wildcard seperator (#\* (when (> term i) (push (subseq string i term) name-list)) (push '* name-list)) ;; Value separator (#\: (push (subseq string i term) name-list) (return (values (nreverse name-list) (string-trim '(#\tab #\space) (subseq string (1+ term)))))) (otherwise (return (values (nreverse name-list) (subseq string i term))))) (setq i (1+ term)))) (defun write-resources (database pathname &key write test test-not) ;; Write resources to PATHNAME in the standard X11 format. ;; WRITE is a function used for writing values, the default is #'princ ;; TEST and TEST-NOT are predicates used for filtering which resources ;; to include in the database. They are called with the name and value. (declare (type resource-database database) (type (or pathname string stream) pathname) (type (or null (function (string stream) t)) write) (type (or null (function (list t) generalized-boolean)) test test-not)) (resource-with-open-file (stream pathname :direction :output) (map-resource database #'(lambda (name-list value stream write test test-not) (when (cond (test (funcall test name-list value)) (test-not (not (funcall test-not name-list value))) (t t)) (let ((previous (car name-list))) (princ previous stream) (dolist (name (cdr name-list)) (unless (or (stringable-equal name "*") (stringable-equal previous "*")) (write-char #\. stream)) (setq previous name) (princ name stream))) (write-string ": " stream) (funcall write value stream) (terpri stream))) stream (or write #'princ) test test-not)) database) (defun wm-resources (database window &key key test test-not) ;; Takes the resources associated with the RESOURCE_MANAGER property ;; of WINDOW (if any) and merges them with DATABASE. ;; KEY is a function used for converting value-strings, the default is ;; identity. TEST and TEST-NOT are predicates used for filtering ;; which resources to include in the database. They are called with ;; the name and results of the KEY function. (declare (type resource-database database) (type window window) (type (or null (function (string) t)) key) (type (or null (function (list t) generalized-boolean)) test test-not)) (declare (clx-values resource-database)) (let ((string (get-property window :RESOURCE_MANAGER :type :STRING :result-type 'string :transform #'xlib::card8->char))) (when string (with-input-from-string (stream string) (read-resources database stream :key key :test test :test-not test-not))))) (defun set-wm-resources (database window &key write test test-not) ;; Sets the resources associated with the RESOURCE_MANAGER property ;; of WINDOW. ;; WRITE is a function used for writing values, the default is #'princ ;; TEST and TEST-NOT are predicates used for filtering which resources ;; to include in the database. They are called with the name and value. (declare (type resource-database database) (type window window) (type (or null (function (string stream) t)) write) (type (or null (function (list t) generalized-boolean)) test test-not)) (xlib::set-string-property window :RESOURCE_MANAGER (with-output-to-string (stream) (write-resources database stream :write write :test test :test-not test-not)))) (defun root-resources (screen &key database key test test-not) "Returns a resource database containing the contents of the root window RESOURCE_MANAGER property for the given SCREEN. If SCREEN is a display, then its default screen is used. If an existing DATABASE is given, then resource values are merged with the DATABASE and the modified DATABASE is returned. TEST and TEST-NOT are predicates for selecting which resources are read. Arguments are a resource name list and a resource value. The KEY function, if given, is called to convert a resource value string to the value given to TEST or TEST-NOT." (declare (type (or screen display) screen) (type (or null resource-database) database) (type (or null (function (string) t)) key) (type (or null (function (list t) generalized-boolean)) test test-not) (clx-values resource-database)) (let* ((screen (if (type? screen 'display) (display-default-screen screen) screen)) (window (screen-root screen)) (database (or database (make-resource-database)))) (wm-resources database window :key key :test test :test-not test-not) database)) (defun set-root-resources (screen &key test test-not (write #'princ) database) "Changes the contents of the root window RESOURCE_MANAGER property for the given SCREEN. If SCREEN is a display, then its default screen is used. TEST and TEST-NOT are predicates for selecting which resources from the DATABASE are written. Arguments are a resource name list and a resource value. The WRITE function is used to convert a resource value into a string stored in the property." (declare (type (or screen display) screen) (type (or null resource-database) database) (type (or null (function (list t) generalized-boolean)) test test-not) (type (or null (function (string stream) t)) write) (clx-values resource-database)) (let* ((screen (if (type? screen 'display) (display-default-screen screen) screen)) (window (screen-root screen))) (set-wm-resources database window :write write :test test :test-not test-not) database)) (defsetf root-resources (screen &key test test-not (write #'princ))(database) `(set-root-resources ,screen :test ,test :test-not ,test-not :write ,write :database ,database)) (defun initialize-resource-database (display) ;; This function is (supposed to be) equivalent to the Xlib initialization ;; code. (declare (type display display)) (let ((rdb (make-resource-database)) (rootwin (screen-root (car (display-roots display))))) ;; First read the server defaults if present, otherwise from the default ;; resource file (if (get-property rootwin :RESOURCE_MANAGER) (xlib:wm-resources rdb rootwin) (let ((path (default-resources-pathname))) (when (and path (probe-file path)) (read-resources rdb path)))) ;; Next read from the resources file (let ((path (resources-pathname))) (when (and path (probe-file path)) (read-resources rdb path))) (setf (display-xdefaults display) rdb))) ecl-16.1.2/src/clx/screensaver.lisp000066400000000000000000000053361266352375300171550ustar00rootroot00000000000000;;; -*- Mode: Lisp; Syntax: Common-Lisp; Package: XLIB; -*- ;;; --------------------------------------------------------------------------- ;;; Title: X11 MIT Screensaver extension ;;; Created: 2005-08-28 01:41 ;;; Author: Istvan Marko ;;; --------------------------------------------------------------------------- ;;; (c) copyright 2005 by Istvan Marko ;;; ;;; Permission is granted to any individual or institution to use, ;;; copy, modify, and distribute this software, provided that this ;;; complete copyright and permission notice is maintained, intact, in ;;; all copies and supporting documentation. ;;; ;;; 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. ;;; ;;; Description: ;;; ;;; This is a partial interface to the MIT-SCREEN-SAVER ;;; extension. Only the ScreenSaverQueryVersion and ;;; ScreenSaverQueryInfo requests are implemented because I couldn't ;;; think of a use for the rest. In fact, the only use I see for this ;;; extension is screen-saver-get-idle which provides and easy way to ;;; find out how long has it been since the last keyboard or mouse ;;; activity. ;;; A description of this extension can be found at ;;; doc/hardcopy/saver/saver.PS.gz in the X11 distribution. (in-package :xlib) (export '(screen-saver-query-version screen-saver-query-info screen-saver-get-idle) :xlib) (define-extension "MIT-SCREEN-SAVER") (defun screen-saver-query-version (display) (with-buffer-request-and-reply (display (extension-opcode display "MIT-SCREEN-SAVER") nil) ((data 0) (card8 1) ;client major version (card8 0) ;client minor version (card16 0)) ; unused (values (card16-get 8) ; server major version (card16-get 10)))) ; server minor version (defun screen-saver-query-info (display drawable) (with-buffer-request-and-reply (display (extension-opcode display "MIT-SCREEN-SAVER") nil) ((data 1) (drawable drawable)) (values (card8-get 1) ; state: off, on, disabled (window-get 8) ; screen saver window if active (card32-get 12) ; tilorsince msecs. how soon before the screen saver kicks in or how long has it been active (card32-get 16) ; idle msecs (card8-get 24)))) ; kind: Blanked, Internal, External (defun screen-saver-get-idle (display drawable) "How long has it been since the last keyboard or mouse input" (multiple-value-bind (state window tilorsince idle kind) (screen-saver-query-info display drawable) (declare (ignore state window kind)) (values idle tilorsince))) ecl-16.1.2/src/clx/shape.lisp000066400000000000000000000156461266352375300157420ustar00rootroot00000000000000;;; -*- Mode: Lisp; Syntax: Common-Lisp; Package: XLIB; -*- ;;; --------------------------------------------------------------------------- ;;; Title: X11 Shape extension ;;; Created: 1999-05-14 11:31 ;;; Author: Gilbert Baumann ;;; --------------------------------------------------------------------------- ;;; (c) copyright 1999 by Gilbert Baumann ;;; ;;; Permission is granted to any individual or institution to use, ;;; copy, modify, and distribute this software, provided that this ;;; complete copyright and permission notice is maintained, intact, in ;;; all copies and supporting documentation. ;;; ;;; 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. ;;; ;;; Use xc/doc/hardcopy/Xext/shape.PS.gz obtainable from e.g. ;; ftp://ftp.xfree86.org/pub/XFree86/current/untarred/xc/hardcopy/Xext/shape.PS.gz (in-package :xlib) (export '(shape-query-version shape-rectangles shape-mask shape-combine shape-offset shape-query-extents shape-select-input shape-input-selected-p shape-get-rectangles) :xlib) (define-extension "SHAPE" :events (:shape-notify)) (declare-event :shape-notify ((data (member8 :bounding :clip)) kind) ;shape kind (card16 sequence) (window (window event-window)) ;affected window (int16 x) ;extents (int16 y) (card16 width) (card16 height) ((or null card32) time) ;timestamp (boolean shaped-p)) (defun encode-shape-kind (kind) (ecase kind (:bounding 0) (:clip 1))) (defun encode-shape-operation (operation) (ecase operation (:set 0) (:union 1) (:interset 2) (:subtract 3) (:invert 4))) (defun encode-shape-rectangle-ordering (ordering) (ecase ordering ((:unsorted :un-sorted nil) 0) ((:y-sorted) 1) ((:yx-sorted) 2) ((:yx-banded) 3))) (defun shape-query-version (display) (with-buffer-request-and-reply (display (extension-opcode display "SHAPE") nil :sizes 16) ((data 0)) (values (card16-get 8) (card16-get 10)))) (defun shape-rectangles (window rectangles &key (kind :bounding) (x-offset 0) (y-offset 0) (operation :set) (ordering :unsorted)) (let* ((display (xlib:window-display window))) (with-buffer-request (display (extension-opcode display "SHAPE")) (data 1) (card8 (encode-shape-operation operation)) (card8 (encode-shape-kind kind)) (card8 (encode-shape-rectangle-ordering ordering)) (card8 0) ;unused (window window) (int16 x-offset) (int16 y-offset) ((sequence :format int16) rectangles)))) (defun shape-mask (window pixmap &key (kind :bounding) (x-offset 0) (y-offset 0) (operation :set)) (let* ((display (xlib:window-display window))) (with-buffer-request (display (extension-opcode display "SHAPE")) (data 2) (card8 (encode-shape-operation operation)) (card8 (encode-shape-kind kind)) (card16 0) ;unused (window window) (int16 x-offset) (int16 y-offset) ((or pixmap (member :none)) pixmap)))) (defun shape-combine (window source-window &key (kind :bounding) (source-kind :bounding) (x-offset 0) (y-offset 0) (operation :set)) (let* ((display (xlib:window-display window))) (with-buffer-request (display (extension-opcode display "SHAPE")) (data 3) (card8 (encode-shape-operation operation)) (card8 (encode-shape-kind kind)) (card8 (encode-shape-kind source-kind)) (card8 0) ;unused (window window) (int16 x-offset) (int16 y-offset) (window source-window)))) (defun shape-offset (window &key (kind :bounding) (x-offset 0) (y-offset 0)) (let* ((display (xlib:window-display window))) (with-buffer-request (display (extension-opcode display "SHAPE")) (data 4) (card8 (encode-shape-kind kind)) (card8 0) (card8 0) (card8 0) ;unused (window window) (int16 x-offset) (int16 y-offset)))) (defun shape-query-extents (window) (let* ((display (xlib:window-display window))) (with-buffer-request-and-reply (display (extension-opcode display "SHAPE") nil :sizes (8 16 32)) ((data 5) (window window)) (values (boolean-get 8) ;bounding shaped (boolean-get 9) ;clip shaped (int16-get 12) ;bounding shape extents x (int16-get 14) ;bounding shape extents y (card16-get 16) ;bounding shape extents width (card16-get 18) ;bounding shape extents height (int16-get 20) ;clip shape extents x (int16-get 22) ;clip shape extents y (card16-get 24) ;clip shape extents width (card16-get 26))))) ;clip shape extents height (defun shape-select-input (window selected-p) (let* ((display (window-display window))) (with-buffer-request (display (extension-opcode display "SHAPE")) (data 6) (window window) (boolean selected-p)) )) (defun shape-input-selected-p (window) (let* ((display (window-display window))) (with-buffer-request-and-reply (display (extension-opcode display "SHAPE") nil :sizes (8)) ((data 7) ;also wrong in documentation (window window)) (boolean-get 1)))) (defun shape-get-rectangles (window &optional (kind :bounding) (result-type 'list)) (let* ((display (window-display window))) (with-buffer-request-and-reply (display (extension-opcode display "SHAPE") nil :sizes (8 16 32)) ((data 8) ;this was wrong in the specification (window window) (card8 (ecase kind (:bounding 0) (:clip 1)))) (values (sequence-get :length (print (* 4 (card32-get 8))) :result-type result-type :format int16 :index +replysize+) (ecase (card8-get 1) (0 :unsorted) (1 :y-sorted) (2 :yx-sorted) (3 :yx-banded) ))))) ecl-16.1.2/src/clx/sockcl.lisp000066400000000000000000000117051266352375300161100ustar00rootroot00000000000000;;; -*- Mode: LISP; Syntax: Common-lisp; Package: XLIB; Base: 10; Lowercase: Yes -*- ;;;; Server Connection for kcl and ibcl ;;; Copyright (C) 1987, 1989 Massachussetts Institute of Technology ;;; ;;; Permission is granted to any individual or institution to use, copy, ;;; modify, and distribute this software, provided that this complete ;;; copyright and permission notice is maintained, intact, in all copies and ;;; supporting documentation. ;;; ;;; Massachussetts Institute of Technology provides this software "as is" ;;; without express or implied warranty. ;;; ;;; Adapted from code by Roman Budzianowski - Project Athena/MIT ;;; make-two-way-stream is probably not a reasonable thing to do. ;;; A close on a two way stream probably does not close the substreams. ;;; I presume an :io will not work (maybe because it uses 1 buffer?). ;;; There should be some fast io (writes and reads...). ;;; Compile this file with compile-file. ;;; Load it with (si:faslink "sockcl.o" "socket.o -lc") (in-package :xlib) ;;; The cmpinclude.h file does not have this type definition from ;;; /h/object.h. We include it here so the ;;; compile-file will work without figuring out where the distribution ;;; directory is located. ;;; (CLINES " enum smmode { /* stream mode */ smm_input, /* input */ smm_output, /* output */ smm_io, /* input-output */ smm_probe, /* probe */ smm_synonym, /* synonym */ smm_broadcast, /* broadcast */ smm_concatenated, /* concatenated */ smm_two_way, /* two way */ smm_echo, /* echo */ smm_string_input, /* string input */ smm_string_output, /* string output */ smm_user_defined /* for user defined */ }; ") #-akcl (CLINES " struct stream { short t, m; FILE *sm_fp; /* file pointer */ object sm_object0; /* some object */ object sm_object1; /* some object */ int sm_int0; /* some int */ int sm_int1; /* some int */ short sm_mode; /* stream mode */ /* of enum smmode */ }; ") ;;;; Connect to the server. ;;; A lisp string is not a reasonable type for C, so copy the characters ;;; out and then call connect_to_server routine defined in socket.o (CLINES " int konnect_to_server(host,display) object host; /* host name */ int display; /* display number */ { int fd; /* file descriptor */ int i; char hname[BUFSIZ]; FILE *fout, *fin; if (host->st.st_fillp > BUFSIZ - 1) too_long_file_name(host); for (i = 0; i < host->st.st_fillp; i++) hname[i] = host->st.st_self[i]; hname[i] = '\\0'; /* doubled backslash for lisp */ fd = connect_to_server(hname,display); return(fd); } ") (defentry konnect-to-server (object int) (int "konnect_to_server")) ;;;; Make a one-way stream from a file descriptor. (CLINES " object konnect_stream(host,fd,flag,elem) object host; /* not really used */ int fd; /* file descriptor */ int flag; /* 0 input, 1 output */ object elem; /* 'string-char */ { struct stream *stream; char *mode; /* file open mode */ FILE *fp; /* file pointer */ enum smmode smm; /* lisp mode (a short) */ vs_mark; switch(flag){ case 0: smm = smm_input; mode = \"r\"; break; case 1: smm = smm_output; mode = \"w\"; break; default: FEerror(\"konnect_stream : wrong mode\"); } fp = fdopen(fd,mode); if (fp == NULL) { stream = Cnil; vs_push(stream); } else { stream = alloc_object(t_stream); stream->sm_mode = (short)smm; stream->sm_fp = fp; stream->sm_object0 = elem; stream->sm_object1 = host; stream->sm_int0 = stream->sm.sm_int1 = 0; vs_push(stream); setbuf(fp, alloc_contblock(BUFSIZ)); } vs_reset; return(stream); } ") (defentry konnect-stream (object int int object) (object "konnect_stream")) ;;;; Open an X stream (defun open-socket-stream (host display) (when (not (and (typep host 'string) ; sanity check the arguments (typep display 'fixnum))) (error "Host ~s or display ~s are bad." host display)) (let ((fd (konnect-to-server host display))) ; get a file discriptor (if (< fd 0) NIL (let ((stream-in (konnect-stream host fd 0 'string-char)) ; input (stream-out (konnect-stream host fd 1 'string-char))) ; output (if (or (null stream-in) (null stream-out)) (error "Could not make i/o streams for fd ~d." fd)) (make-two-way-stream stream-in stream-out)) ))) ecl-16.1.2/src/clx/socket.c000066400000000000000000000115631266352375300153770ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ /* Copyright Massachusetts Institute of Technology 1988 */ /* * THIS IS AN OS DEPENDENT FILE! It should work on 4.2BSD derived * systems. VMS and System V should plan to have their own version. * * This code was cribbed from lib/X/XConnDis.c. * Compile using * % cc -c socket.c -DUNIXCONN */ #include #include #include #include #include #include #include #include #ifndef hpux #include #endif extern int errno; /* Certain (broken) OS's don't have this */ /* decl in errno.h */ #ifdef UNIXCONN #include #ifndef X_UNIX_PATH #ifdef hpux #define X_UNIX_PATH "/usr/spool/sockets/X11/" #define OLD_UNIX_PATH "/tmp/.X11-unix/X" #else /* hpux */ #define X_UNIX_PATH "/tmp/.X11-unix/X" #endif /* hpux */ #endif /* X_UNIX_PATH */ #endif /* UNIXCONN */ #ifndef hpux void bcopy(); #endif /* hpux */ /* * Attempts to connect to server, given host and display. Returns file * descriptor (network socket) or 0 if connection fails. */ int connect_to_server (host, display) char *host; int display; { struct sockaddr_in inaddr; /* INET socket address. */ struct sockaddr *addr; /* address to connect to */ struct hostent *host_ptr; int addrlen; /* length of address */ #ifdef UNIXCONN struct sockaddr_un unaddr; /* UNIX socket address. */ #endif extern char *getenv(); extern struct hostent *gethostbyname(); int fd; /* Network socket */ { #ifdef UNIXCONN if ((host[0] == '\0') || (strcmp("unix", host) == 0)) { /* Connect locally using Unix domain. */ unaddr.sun_family = AF_UNIX; (void) strcpy(unaddr.sun_path, X_UNIX_PATH); (void) sprintf(&unaddr.sun_path[strlen(unaddr.sun_path)], "%d", display); addr = (struct sockaddr *) &unaddr; addrlen = strlen(unaddr.sun_path) + 2; /* * Open the network connection. */ if ((fd = socket((int) addr->sa_family, SOCK_STREAM, 0)) < 0) { #ifdef hpux /* this is disgusting */ /* cribbed from X11R4 xlib source */ if (errno == ENOENT) { /* No such file or directory */ (void) sprintf(unaddr.sun_path, "%s%d", OLD_UNIX_PATH, display); addrlen = strlen(unaddr.sun_path) + 2; if ((fd = socket ((int) addr->sa_family, SOCK_STREAM, 0)) < 0) return(-1); /* errno set by most recent system call. */ } else #endif /* hpux */ return(-1); /* errno set by system call. */ } } else #endif /* UNIXCONN */ { /* Get the statistics on the specified host. */ if ((inaddr.sin_addr.s_addr = inet_addr(host)) == -1) { if ((host_ptr = gethostbyname(host)) == NULL) { /* No such host! */ errno = EINVAL; return(-1); } /* Check the address type for an internet host. */ if (host_ptr->h_addrtype != AF_INET) { /* Not an Internet host! */ errno = EPROTOTYPE; return(-1); } /* Set up the socket data. */ inaddr.sin_family = host_ptr->h_addrtype; #ifdef hpux (void) memcpy((char *)&inaddr.sin_addr, (char *)host_ptr->h_addr, sizeof(inaddr.sin_addr)); #else /* hpux */ (void) bcopy((char *)host_ptr->h_addr, (char *)&inaddr.sin_addr, sizeof(inaddr.sin_addr)); #endif /* hpux */ } else { inaddr.sin_family = AF_INET; } addr = (struct sockaddr *) &inaddr; addrlen = sizeof (struct sockaddr_in); inaddr.sin_port = display + X_TCP_PORT; inaddr.sin_port = htons(inaddr.sin_port); /* * Open the network connection. */ if ((fd = socket((int) addr->sa_family, SOCK_STREAM, 0)) < 0){ return(-1); /* errno set by system call. */} /* make sure to turn off TCP coalescence */ #ifdef TCP_NODELAY { int mi = 1; setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, &mi, sizeof (int)); } #endif } /* * Changed 9/89 to retry connection if system call was interrupted. This * is necessary for multiprocessing implementations that use timers, * since the timer results in a SIGALRM. -- jdi */ while (connect(fd, addr, addrlen) == -1) { if (errno != EINTR) { (void) close (fd); return(-1); /* errno set by system call. */ } } } /* * Return the id if the connection succeeded. */ return(fd); } ecl-16.1.2/src/clx/test/000077500000000000000000000000001266352375300147145ustar00rootroot00000000000000ecl-16.1.2/src/clx/test/.cvsignore000066400000000000000000000000071266352375300167110ustar00rootroot00000000000000*.fasl ecl-16.1.2/src/clx/test/image.lisp000066400000000000000000000144471266352375300167010ustar00rootroot00000000000000;;; -*- Mode:Lisp; Package:XLIB; Syntax:COMMON-LISP; Base:10; Lowercase:T -*- ;;; Tests image code by randomly reading, copying and then writing images to ;;; the exact same place on the screen. If everything works, just the borders ;;; of the image windows appear. If one of these image windows is garbled, ;;; then somewhere something is broken. Entry point is the function ;;; IMAGE-TEST (in-package :xlib) (export '(image-test)) (defvar *image-test-host* "") (defvar *image-test-nimages* 25) (defvar *image-test-copy* t) (defvar *image-test-copy-random-subimage* t) (defvar *image-test-put-random-subimage* t) (defvar *image-test-get-image-result-type-choices* '(image-x image-x image-xy image-z)) (defvar *image-test-get-image-image-x-format-choices* '(:xy-pixmap :z-pixmap)) (defun image-test (&key (host *image-test-host*) (nimages *image-test-nimages*) (copy *image-test-copy*) (copy-random-subimage *image-test-copy-random-subimage*) (put-random-subimage *image-test-put-random-subimage*) (get-image-result-type-choices *image-test-get-image-result-type-choices*) (get-image-image-x-format-choices *image-test-get-image-image-x-format-choices*)) (declare (ignore host)) (let* ((display nil) (abort t) (images nil)) (loop (setq images nil) (unwind-protect (progn (setq display (open-default-display)) (let* ((screen (display-default-screen display)) (window (screen-root screen)) (gcontext (create-gcontext :foreground (screen-white-pixel screen) :background (screen-black-pixel screen) :drawable window :font (open-font display "fixed")))) (dotimes (i nimages) (let ((image (image-test-get-image window get-image-result-type-choices get-image-image-x-format-choices))) (format t "~&Image=~S~%" image) (let ((copy (if copy (image-test-copy-image image copy-random-subimage) image))) (format t "~&Copy=~S~%" copy) (push (list image copy) images) (image-test-put-image screen gcontext copy (concatenate 'string (image-info image) (image-info copy)) put-random-subimage)))) (unless (y-or-n-p "More ") (return)) (setq abort nil))) (close-display (shiftf display nil) :abort abort)) (sleep 10)) (reverse images))) (defun image-test-choose (list) (nth (random (length list)) list)) (defun image-test-get-image (window result-type-choices image-x-format-choices) (let* ((x (random (floor (drawable-width window) 3))) (y (random (floor (drawable-height window) 3))) (hw (floor (- (drawable-width window) x) 3)) (hh (floor (- (drawable-height window) y) 3)) (width (+ hw hw (random hw))) (height (+ hh hh (random hh))) (result-type (image-test-choose result-type-choices)) (format (ecase result-type (image-x (image-test-choose image-x-format-choices)) (image-xy :xy-pixmap) (image-z :z-pixmap))) (image (get-image window :x x :y y :width width :height height :format format :result-type result-type))) (setf (getf (image-plist image) :root-x) x) (setf (getf (image-plist image) :root-y) y) image)) (defun image-test-subimage-parameters (image random-subimage-p) (if random-subimage-p (let* ((x (random (floor (image-width image) 3))) (y (random (floor (image-height image) 3))) (hw (floor (- (image-width image) x) 3)) (hh (floor (- (image-height image) y) 3)) (width (+ hw hw (random hw))) (height (+ hh hh (random hh)))) (values x y width height)) (values 0 0 (image-width image) (image-height image)))) (defun image-test-copy-image (image random-subimage-p) (let ((result-type (if (zerop (random 2)) (type-of image) (etypecase image (image-x (ecase (image-x-format image) (:xy-pixmap 'image-xy) (:z-pixmap 'image-z))) ((or image-xy image-z) 'image-x))))) (multiple-value-bind (x y width height) (image-test-subimage-parameters image random-subimage-p) (incf (getf (image-plist image) :root-x) x) (incf (getf (image-plist image) :root-y) y) (copy-image image :x x :y y :width width :height height :result-type result-type)))) (defun image-test-put-image (screen gcontext image info random-subimage-p) (multiple-value-bind (src-x src-y width height) (image-test-subimage-parameters image random-subimage-p) (let* ((border-width 1) (root-x (getf (image-plist image) :root-x)) (root-y (getf (image-plist image) :root-y)) (x (+ src-x root-x (- border-width))) (y (+ src-y root-y (- border-width)))) (unless (or (zerop width) (zerop height)) (let ((window (create-window :parent (screen-root screen) :x x :y y :width width :height height :border-width border-width :background (screen-white-pixel screen) :override-redirect :on))) (map-window window) (display-finish-output (drawable-display window)) (put-image window gcontext image :x 0 :y 0 :src-x src-x :src-y src-y :width width :height height) (draw-image-glyphs window gcontext 0 (1- height) info) (display-finish-output (drawable-display window)) window))))) (defun image-info (image) (etypecase image (image-x (ecase (image-x-format image) (:xy-pixmap "XXY") (:z-pixmap "XZ "))) (image-xy "XY ") (image-z "Z "))) ecl-16.1.2/src/clx/test/trapezoid.lisp000066400000000000000000000055431266352375300176150ustar00rootroot00000000000000;;; -*- Mode:Lisp; Package:XLIB; Syntax:COMMON-LISP; Base:10; Lowercase:T -*- ;;; CLX trapezoid Extension test program ;;; ;;; TEXAS INSTRUMENTS INCORPORATED ;;; P.O. BOX 2909 ;;; AUSTIN, TEXAS 78769 ;;; ;;; Copyright (C) 1987 Texas Instruments Incorporated. ;;; ;;; Permission is granted to any individual or institution to use, copy, modify, ;;; and distribute this software, provided that this complete copyright and ;;; permission notice is maintained, intact, in all copies and supporting ;;; documentation. ;;; ;;; Texas Instruments Incorporated provides this software "as is" without ;;; express or implied warranty. ;;; (in-package :xlib) (defun zoid-test () ;; Display the part picture in /extensions/test/datafile (let* ((display (open-default-display)) (width 400) (height 400) (screen (display-default-screen display)) (black (screen-black-pixel screen)) (white (screen-white-pixel screen)) (win (create-window :parent (screen-root screen) :background black :border white :border-width 1 :colormap (screen-default-colormap screen) :bit-gravity :center :event-mask '(:exposure :key-press) :x 20 :y 20 :width width :height height)) (gc (create-gcontext :drawable win :background black :foreground white))) (initialize-extensions display) (map-window win) ; Map the window ;; Handle events (unwind-protect (loop (event-case (display :force-output-p t) (exposure ;; Come here on exposure events (window count) (when (zerop count) ;; Ignore all but the last exposure event (clear-area window) ;; NOT VERY INTERESTING, BUT CHECKS ALL THE POSSIBILITIES (draw-filled-trapezoids window gc '(10 20 30 40 100 200)) (setf (gcontext-trapezoid-alignment gc) :y) (draw-filled-trapezoids window gc #(10 20 30 40 100 200)) (with-gcontext (gc :trapezoid-alignment :x) (draw-filled-trapezoids window gc '(40 50 60 70 140 240))) (setf (gcontext-trapezoid-alignment gc) :x) (draw-filled-trapezoids window gc #(40 50 60 70 80 90)) (with-gcontext (gc :trapezoid-alignment :y) (draw-filled-trapezoids window gc #(40 50 60 70 140 240))) (draw-glyphs window gc 10 10 "Press any key to exit") ;; Returning non-nil causes event-case to exit t)) (key-press () (return-from zoid-test t)))) (close-display display)))) ecl-16.1.2/src/clx/text.lisp000066400000000000000000001447021266352375300156220ustar00rootroot00000000000000;;; -*- Mode: LISP; Syntax: Common-lisp; Package: XLIB; Base: 10; Lowercase: Yes -*- ;;; CLX text keyboard and pointer requests ;;; ;;; TEXAS INSTRUMENTS INCORPORATED ;;; P.O. BOX 2909 ;;; AUSTIN, TEXAS 78769 ;;; ;;; Copyright (C) 1987 Texas Instruments Incorporated. ;;; ;;; Permission is granted to any individual or institution to use, copy, modify, ;;; and distribute this software, provided that this complete copyright and ;;; permission notice is maintained, intact, in all copies and supporting ;;; documentation. ;;; ;;; Texas Instruments Incorporated provides this software "as is" without ;;; express or implied warranty. ;;; (in-package :xlib) ;; Strings are broken up into chunks of this size (defparameter *max-string-size* 254) ;; In the functions below, the transform is used to convert an element of the ;; sequence into a font index. The transform is applied to each element of the ;; (sub)sequence, until either the transform returns nil or the end of the ;; (sub)sequence is reached. If transform returns nil for an element, the ;; index of that element in the sequence is returned, otherwise nil is ;; returned. (deftype translation-function () #+explorer t #-explorer '(function (sequence array-index array-index (or null font) vector array-index) (values array-index (or null int16 font) (or null int32)))) ;; In the functions below, if width is specified, it is assumed to be the pixel ;; width of whatever string of glyphs is actually drawn. Specifying width will ;; allow for appending the output of subsequent calls to the same protocol ;; request, provided gcontext has not been modified in the interim. If width ;; is not specified, appending of subsequent output might not occur. ;; Specifying width is simply a hint, for performance. Note that specifying ;; width may be difficult if transform can return nil. (defun translate-default (src src-start src-end font dst dst-start) ;; dst is guaranteed to have room for (- src-end src-start) integer elements, ;; starting at dst-start; whether dst holds 8-bit or 16-bit elements depends ;; on context. font is the current font, if known. The function should ;; translate as many elements of src as possible into indexes in the current ;; font, and store them into dst. ;; ;; The first return value should be the src index of the first untranslated ;; element. If no further elements need to be translated, the second return ;; value should be nil. If a horizontal motion is required before further ;; translation, the second return value should be the delta in x coordinate. ;; If a font change is required for further translation, the second return ;; value should be the new font. If known, the pixel width of the translated ;; text can be returned as the third value; this can allow for appending of ;; subsequent output to the same protocol request, if no overall width has ;; been specified at the higher level. ;; (returns values: ending-index ;; (OR null horizontal-motion font) ;; (OR null translated-width)) (declare (type sequence src) (type array-index src-start src-end dst-start) (type (or null font) font) (type vector dst) (inline graphic-char-p)) (declare (clx-values integer (or null integer font) (or null integer))) (let ((min-char-index (and font (xlib:font-min-char font))) (max-char-index (and font (xlib:font-max-char font)))) (if (stringp src) (do ((i src-start (index+ i 1)) (j dst-start (index+ j 1)) (char)) ((index>= i src-end) i) (declare (type array-index i j)) (setf char (char->card8 (char src i))) (if (and font (or (< char min-char-index) (> char max-char-index))) (return i) (setf (aref dst j) char))) (do ((i src-start (index+ i 1)) (j dst-start (index+ j 1)) (elt)) ((index>= i src-end) i) (declare (type array-index i j)) (setq elt (elt src i)) (when (characterp elt) (setq elt (char->card8 elt))) (if (or (not (integerp elt)) (and font (< elt min-char-index) (> elt max-char-index))) (return i) (setf (aref dst j) elt)))))) ;; There is a question below of whether translate should always be required, or ;; if not, what the default should be or where it should come from. For ;; example, the default could be something that expected a string as src and ;; translated the CL standard character set to ASCII indexes, and ignored fonts ;; and bits. Or the default could expect a string but otherwise be "system ;; dependent". Or the default could be something that expected a vector of ;; integers and did no translation. Or the default could come from the ;; gcontext (but what about text-extents and text-width?). (defun text-extents (font sequence &key (start 0) end translate) ;; If multiple fonts are involved, font-ascent and font-descent will be the ;; maximums. If multiple directions are involved, the direction will be nil. ;; Translate will always be called with a 16-bit dst buffer. (declare (type sequence sequence) (type (or font gcontext) font)) (declare (type (or null translation-function) translate) #+clx-ansi-common-lisp (dynamic-extent translate) #+(and lispm (not clx-ansi-common-lisp)) (sys:downward-funarg #+Genera * #-Genera translate)) (declare (clx-values width ascent descent left right font-ascent font-descent direction (or null array-index))) (when (type? font 'gcontext) (force-gcontext-changes font) (setq font (gcontext-font font t))) (check-type font font) (let* ((left-bearing 0) (right-bearing 0) ;; Sum of widths (width 0) (ascent 0) (descent 0) (overall-ascent (font-ascent font)) (overall-descent (font-descent font)) (overall-direction (font-direction font)) (next-start nil) (display (font-display font))) (declare (type int16 ascent descent overall-ascent overall-descent) (type int32 left-bearing right-bearing width) (type (or null array-index) next-start) (type display display)) (with-display (display) (do* ((wbuf (display-tbuf16 display)) (src-end (or end (length sequence))) (src-start start (index+ src-start buf-end)) (end (index-min src-end (index+ src-start +buffer-text16-size+)) (index-min src-end (index+ src-start +buffer-text16-size+))) (buf-end 0) (new-font) (font-ascent 0) (font-descent 0) (font-direction) (stop-p nil)) ((or stop-p (index>= src-start src-end)) (when (index< src-start src-end) (setq next-start src-start))) (declare (type buffer-text16 wbuf) (type array-index src-start src-end end buf-end) (type int16 font-ascent font-descent) (type generalized-boolean stop-p)) ;; Translate the text (multiple-value-setq (buf-end new-font) (funcall (or translate #'translate-default) sequence src-start end font wbuf 0)) (setq buf-end (- buf-end src-start)) (cond ((null new-font) (setq stop-p t)) ((integerp new-font) (incf width (the int32 new-font)))) (let (w a d l r) (if (or (font-char-infos-internal font) (font-local-only-p font)) ;; Calculate text extents locally (progn (multiple-value-setq (w a d l r) (text-extents-local font wbuf 0 buf-end nil)) (setq font-ascent (the int16 (font-ascent font)) font-descent (the int16 (font-descent font)) font-direction (font-direction font))) ;; Let the server calculate text extents (multiple-value-setq (w a d l r font-ascent font-descent font-direction) (text-extents-server font wbuf 0 buf-end))) (incf width (the int32 w)) (cond ((index= src-start start) (setq left-bearing (the int32 l)) (setq right-bearing (the int32 r)) (setq ascent (the int16 a)) (setq descent (the int16 d))) (t (setq left-bearing (the int32 (min left-bearing (the int32 l)))) (setq right-bearing (the int32 (max right-bearing (the int32 r)))) (setq ascent (the int16 (max ascent (the int16 a)))) (setq descent (the int16 (max descent (the int16 d))))))) (when (type? new-font 'font) (setq font new-font)) (setq overall-ascent (the int16 (max overall-ascent font-ascent))) (setq overall-descent (the int16 (max overall-descent font-descent))) (case overall-direction (:unknown (setq overall-direction font-direction)) (:left-to-right (unless (eq font-direction :left-to-right) (setq overall-direction nil))) (:right-to-left (unless (eq font-direction :right-to-left) (setq overall-direction nil)))))) (values width ascent descent left-bearing right-bearing overall-ascent overall-descent overall-direction next-start))) (defun text-width (font sequence &key (start 0) end translate) ;; Translate will always be called with a 16-bit dst buffer. (declare (type sequence sequence) (type (or font gcontext) font) (type array-index start) (type (or null array-index) end)) (declare (type (or null translation-function) translate) #+clx-ansi-common-lisp (dynamic-extent translate) #+(and lispm (not clx-ansi-common-lisp)) (sys:downward-funarg #+Genera * #-Genera translate)) (declare (clx-values integer (or null integer))) (when (type? font 'gcontext) (force-gcontext-changes font) (setq font (gcontext-font font t))) (check-type font font) (let* ((width 0) (next-start nil) (display (font-display font))) (declare (type int32 width) (type (or null array-index) next-start) (type display display)) (with-display (display) (do* ((wbuf (display-tbuf16 display)) (src-end (or end (length sequence))) (src-start start (index+ src-start buf-end)) (end (index-min src-end (index+ src-start +buffer-text16-size+)) (index-min src-end (index+ src-start +buffer-text16-size+))) (buf-end 0) (new-font) (stop-p nil)) ((or stop-p (index>= src-start src-end)) (when (index< src-start src-end) (setq next-start src-start))) (declare (type buffer-text16 wbuf) (type array-index src-start src-end end buf-end) (type generalized-boolean stop-p)) ;; Translate the text (multiple-value-setq (buf-end new-font) (funcall (or translate #'translate-default) sequence src-start end font wbuf 0)) (setq buf-end (- buf-end src-start)) (cond ((null new-font) (setq stop-p t)) ((integerp new-font) (incf width (the int32 new-font)))) (incf width (if (or (font-char-infos-internal font) (font-local-only-p font)) (text-extents-local font wbuf 0 buf-end :width-only) (text-width-server font wbuf 0 buf-end))) (when (type? new-font 'font) (setq font new-font)))) (values width next-start))) (defun text-extents-server (font sequence start end) (declare (type font font) (type sequence sequence) (type array-index start end)) (declare (clx-values width ascent descent left right font-ascent font-descent direction)) (let ((display (font-display font)) (length (index- end start)) (font-id (font-id font))) (declare (type display display) (type array-index length) (type resource-id font-id)) (with-buffer-request-and-reply (display +x-querytextextents+ 28 :sizes (8 16 32)) (((data boolean) (oddp length)) (length (index+ (index-ceiling length 2) 2)) (resource-id font-id) ((sequence :format char2b :start start :end end :appending t) sequence)) (values (integer-get 16) (int16-get 12) (int16-get 14) (integer-get 20) (integer-get 24) (int16-get 8) (int16-get 10) (member8-get 1 :left-to-right :right-to-left))))) (defun text-width-server (font sequence start end) (declare (type (or font gcontext) font) (type sequence sequence) (type array-index start end)) (declare (clx-values integer)) (let ((display (font-display font)) (length (index- end start)) (font-id (font-id font))) (declare (type display display) (type array-index length) (type resource-id font-id)) (with-buffer-request-and-reply (display +x-querytextextents+ 28 :sizes 32) (((data boolean) (oddp length)) (length (index+ (index-ceiling length 2) 2)) (resource-id font-id) ((sequence :format char2b :start start :end end :appending t) sequence)) (values (integer-get 16))))) (defun text-extents-local (font sequence start end width-only-p) (declare (type font font) (type sequence sequence) (type integer start end) (type generalized-boolean width-only-p)) (declare (clx-values width ascent descent overall-left overall-right)) (let* ((char-infos (font-char-infos font)) (font-info (font-font-info font))) (declare (type font-info font-info)) (declare (type (simple-array int16 (*)) char-infos)) (if (zerop (length char-infos)) ;; Fixed width font (let* ((font-width (max-char-width font)) (font-ascent (max-char-ascent font)) (font-descent (max-char-descent font)) (width (* (index- end start) font-width))) (declare (type int16 font-width font-ascent font-descent) (type int32 width)) (if width-only-p width (values width font-ascent font-descent (max-char-left-bearing font) (+ width (- font-width) (max-char-right-bearing font))))) ;; Variable-width font (let* ((first-col (font-info-min-byte2 font-info)) (num-cols (1+ (- (font-info-max-byte2 font-info) first-col))) (first-row (font-info-min-byte1 font-info)) (last-row (font-info-max-byte1 font-info)) (num-rows (1+ (- last-row first-row)))) (declare (type card8 first-col first-row last-row) (type card16 num-cols num-rows)) (if (or (plusp first-row) (plusp last-row)) ;; Matrix (16 bit) font (macrolet ((char-info-elt (sequence elt) `(let* ((char (the card16 (elt ,sequence ,elt))) (row (- (ash char -8) first-row)) (col (- (logand char #xff) first-col))) (declare (type card16 char) (type int16 row col)) (if (and (< -1 row num-rows) (< -1 col num-cols)) (index* 6 (index+ (index* row num-cols) col)) -1)))) (if width-only-p (do ((i start (index1+ i)) (width 0)) ((index>= i end) width) (declare (type array-index i) (type int32 width)) (let ((n (char-info-elt sequence i))) (declare (type fixnum n)) (unless (minusp n) ;; Ignore characters not in the font (incf width (the int16 (aref char-infos (index+ 2 n))))))) ;; extents (do ((i start (index1+ i)) (width 0) (ascent #x-7fff) (descent #x-7fff) (left #x7fff) (right #x-7fff)) ((index>= i end) (values width ascent descent left right)) (declare (type array-index i) (type int16 ascent descent) (type int32 width left right)) (let ((n (char-info-elt sequence i))) (declare (type fixnum n)) (unless (minusp n) ;; Ignore characters not in the font (setq left (min left (+ width (aref char-infos n)))) (setq right (max right (+ width (aref char-infos (index1+ n))))) (incf width (aref char-infos (index+ 2 n))) (setq ascent (max ascent (aref char-infos (index+ 3 n)))) (setq descent (max descent (aref char-infos (index+ 4 n))))))))) ;; Non-matrix (8 bit) font ;; The code here is identical to the above, except for the following macro: (macrolet ((char-info-elt (sequence elt) `(let ((col (- (the card16 (elt ,sequence ,elt)) first-col))) (declare (type int16 col)) (if (< -1 col num-cols) (index* 6 col) -1)))) (if width-only-p (do ((i start (index1+ i)) (width 0)) ((index>= i end) width) (declare (type array-index i) (type int32 width)) (let ((n (char-info-elt sequence i))) (declare (type fixnum n)) (unless (minusp n) ;; Ignore characters not in the font (incf width (the int16 (aref char-infos (index+ 2 n))))))) ;; extents (do ((i start (index1+ i)) (width 0) (ascent #x-7fff) (descent #x-7fff) (left #x7fff) (right #x-7fff)) ((index>= i end) (values width ascent descent left right)) (declare (type array-index i) (type int16 ascent descent) (type int32 width left right)) (let ((n (char-info-elt sequence i))) (declare (type fixnum n)) (unless (minusp n) ;; Ignore characters not in the font (setq left (min left (+ width (aref char-infos n)))) (setq right (max right (+ width (aref char-infos (index1+ n))))) (incf width (aref char-infos (index+ 2 n))) (setq ascent (max ascent (aref char-infos (index+ 3 n)))) (setq descent (max descent (aref char-infos (index+ 4 n))))) )))) ))))) ;;----------------------------------------------------------------------------- ;; This controls the element size of the dst buffer given to translate. If ;; :default is specified, the size will be based on the current font, if known, ;; and otherwise 16 will be used. [An alternative would be to pass the buffer ;; size to translate, and allow it to return the desired size if it doesn't ;; like the current size. The problem is that the protocol doesn't allow ;; switching within a single request, so to allow switching would require ;; knowing the width of text, which isn't necessarily known. We could call ;; text-width to compute it, but perhaps that is doing too many favors?] [An ;; additional possibility is to allow an index-size of :two-byte, in which case ;; translate would be given a double-length 8-bit array, and translate would be ;; expected to store first-byte/second-byte instead of 16-bit integers.] (deftype index-size () '(member :default 8 16)) ;; In the functions below, if width is specified, it is assumed to be the total ;; pixel width of whatever string of glyphs is actually drawn. Specifying ;; width will allow for appending the output of subsequent calls to the same ;; protocol request, provided gcontext has not been modified in the interim. ;; If width is not specified, appending of subsequent output might not occur ;; (unless translate returns the width). Specifying width is simply a hint, ;; for performance. (defun draw-glyph (drawable gcontext x y elt &key translate width (size :default)) ;; Returns true if elt is output, nil if translate refuses to output it. ;; Second result is width, if known. (declare (type drawable drawable) (type gcontext gcontext) (type int16 x y) (type (or null int32) width) (type index-size size)) (declare (type (or null translation-function) translate) #+clx-ansi-common-lisp (dynamic-extent translate) #+(and lispm (not clx-ansi-common-lisp)) (sys:downward-funarg #+Genera * #-Genera translate)) (declare (clx-values generalized-boolean (or null int32))) (let* ((display (gcontext-display gcontext)) (result t) (opcode +x-polytext8+)) (declare (type display display)) (let ((vector (allocate-gcontext-state))) (declare (type gcontext-state vector)) (setf (aref vector 0) elt) (multiple-value-bind (new-start new-font translate-width) (funcall (or translate #'translate-default) vector 0 1 (gcontext-font gcontext nil) vector 1) ;; Allow translate to set a new font (when (type? new-font 'font) (setf (gcontext-font gcontext) new-font) (multiple-value-setq (new-start new-font translate-width) (funcall translate vector 0 1 new-font vector 1))) ;; If new-start is zero, translate refuses to output it (setq result (index-plusp new-start) elt (aref vector 1)) (deallocate-gcontext-state vector) (when translate-width (setq width translate-width)))) (when result (when (eql size 16) (setq opcode +x-polytext16+) (setq elt (dpb elt (byte 8 8) (ldb (byte 8 8) elt)))) (with-buffer-request (display opcode :gc-force gcontext) (drawable drawable) (gcontext gcontext) (int16 x y) (card8 1 0) (card8 (ldb (byte 8 0) elt)) (card8 (ldb (byte 8 8) elt))) (values t width)))) (defun draw-glyphs (drawable gcontext x y sequence &key (start 0) end translate width (size :default)) ;; First result is new start, if end was not reached. Second result is ;; overall width, if known. (declare (type drawable drawable) (type gcontext gcontext) (type int16 x y) (type array-index start) (type sequence sequence) (type (or null array-index) end) (type (or null int32) width) (type index-size size)) (declare (type (or null translation-function) translate) #+clx-ansi-common-lisp (dynamic-extent translate) #+(and lispm (not clx-ansi-common-lisp)) (sys:downward-funarg #+Genera * #-Genera translate)) (declare (clx-values (or null array-index) (or null int32))) (unless end (setq end (length sequence))) (ecase size ((:default 8) (draw-glyphs8 drawable gcontext x y sequence start end (or translate #'translate-default) width)) (16 (draw-glyphs16 drawable gcontext x y sequence start end (or translate #'translate-default) width)))) (defun draw-glyphs8 (drawable gcontext x y sequence start end translate width) ;; First result is new start, if end was not reached. Second result is ;; overall width, if known. (declare (type drawable drawable) (type gcontext gcontext) (type int16 x y) (type array-index start) (type sequence sequence) (type (or null array-index) end) (type (or null int32) width)) (declare (clx-values (or null array-index) (or null int32))) (declare (type translation-function translate) #+clx-ansi-common-lisp (dynamic-extent translate) #+(and lispm (not clx-ansi-common-lisp)) (sys:downward-funarg translate)) (let* ((src-start start) (src-end (or end (length sequence))) (next-start nil) (length (index- src-end src-start)) (request-length (* length 2)) ; Leave lots of room for font shifts. (display (gcontext-display gcontext)) (font (gcontext-font gcontext nil))) (declare (type array-index src-start src-end length) (type (or null array-index) next-start) (type display display)) (with-buffer-request (display +x-polytext8+ :gc-force gcontext :length request-length) (drawable drawable) (gcontext gcontext) (int16 x y) (progn ;; Don't let any flushes happen since we manually set the request ;; length when we're done. (with-buffer-flush-inhibited (display) (do* ((boffset (index+ buffer-boffset 16)) (src-chunk 0) (dst-chunk 0) (offset 0) (overall-width 0) (stop-p nil)) ((or stop-p (zerop length)) ;; Ensure terminated with zero bytes (do ((end (the array-index (lround boffset)))) ((index>= boffset end)) (setf (aref buffer-bbuf boffset) 0) (index-incf boffset)) (length-put 2 (index-ash (index- boffset buffer-boffset) -2)) (setf (buffer-boffset display) boffset) (unless (index-zerop length) (setq next-start src-start)) (when overall-width (setq width overall-width))) (declare (type array-index src-chunk dst-chunk offset) (type (or null int32) overall-width) (type generalized-boolean stop-p)) (setq src-chunk (index-min length *max-string-size*)) (multiple-value-bind (new-start new-font translated-width) (funcall translate sequence src-start (index+ src-start src-chunk) font buffer-bbuf (index+ boffset 2)) (setq dst-chunk (index- new-start src-start) length (index- length dst-chunk) src-start new-start) (if translated-width (when overall-width (incf overall-width translated-width)) (setq overall-width nil)) (when (index-plusp dst-chunk) (setf (aref buffer-bbuf boffset) dst-chunk) (setf (aref buffer-bbuf (index+ boffset 1)) offset) (incf boffset (index+ dst-chunk 2))) (setq offset 0) (cond ((null new-font) ;; Don't stop if translate copied whole chunk (unless (index= src-chunk dst-chunk) (setq stop-p t))) ((integerp new-font) (setq offset new-font)) ((type? new-font 'font) (setq font new-font) (let ((font-id (font-id font)) (buffer-boffset boffset)) (declare (type resource-id font-id) (type array-index buffer-boffset)) ;; This changes the gcontext font in the server ;; Update the gcontext cache (both local and server state) (let ((local-state (gcontext-local-state gcontext)) (server-state (gcontext-server-state gcontext))) (declare (type gcontext-state local-state server-state)) (setf (gcontext-internal-font-obj server-state) font (gcontext-internal-font server-state) font-id) (without-interrupts (setf (gcontext-internal-font-obj local-state) font (gcontext-internal-font local-state) font-id))) (card8-put 0 #xff) (card8-put 1 (ldb (byte 8 24) font-id)) (card8-put 2 (ldb (byte 8 16) font-id)) (card8-put 3 (ldb (byte 8 8) font-id)) (card8-put 4 (ldb (byte 8 0) font-id))) (index-incf boffset 5))) ))))) (values next-start width))) ;; NOTE: After the first font change by the TRANSLATE function, characters are no-longer ;; on 16bit boundaries and this function garbles the bytes. (defun draw-glyphs16 (drawable gcontext x y sequence start end translate width) ;; First result is new start, if end was not reached. Second result is ;; overall width, if known. (declare (type drawable drawable) (type gcontext gcontext) (type int16 x y) (type array-index start) (type sequence sequence) (type (or null array-index) end) (type (or null int32) width)) (declare (clx-values (or null array-index) (or null int32))) (declare (type translation-function translate) #+clx-ansi-common-lisp (dynamic-extent translate) #+(and lispm (not clx-ansi-common-lisp)) (sys:downward-funarg translate)) (let* ((src-start start) (src-end (or end (length sequence))) (next-start nil) (length (index- src-end src-start)) (request-length (* length 3)) ; Leave lots of room for font shifts. (display (gcontext-display gcontext)) (font (gcontext-font gcontext nil)) (buffer (display-tbuf16 display))) (declare (type array-index src-start src-end length) (type (or null array-index) next-start) (type display display) (type buffer-text16 buffer)) (with-buffer-request (display +x-polytext16+ :gc-force gcontext :length request-length) (drawable drawable) (gcontext gcontext) (int16 x y) (progn ;; Don't let any flushes happen since we manually set the request ;; length when we're done. (with-buffer-flush-inhibited (display) (do* ((boffset (index+ buffer-boffset 16)) (src-chunk 0) (dst-chunk 0) (offset 0) (overall-width 0) (stop-p nil)) ((or stop-p (zerop length)) ;; Ensure terminated with zero bytes (do ((end (lround boffset))) ((index>= boffset end)) (setf (aref buffer-bbuf boffset) 0) (index-incf boffset)) (length-put 2 (index-ash (index- boffset buffer-boffset) -2)) (setf (buffer-boffset display) boffset) (unless (zerop length) (setq next-start src-start)) (when overall-width (setq width overall-width))) (declare (type array-index boffset src-chunk dst-chunk offset) (type (or null int32) overall-width) (type generalized-boolean stop-p)) (setq src-chunk (index-min length *max-string-size*)) (multiple-value-bind (new-start new-font translated-width) (funcall translate sequence src-start (index+ src-start src-chunk) font buffer 0) (setq dst-chunk (index- new-start src-start) length (index- length dst-chunk) src-start new-start) (write-sequence-char2b display (index+ boffset 2) buffer 0 dst-chunk) (if translated-width (when overall-width (incf overall-width translated-width)) (setq overall-width nil)) (when (index-plusp dst-chunk) (setf (aref buffer-bbuf boffset) dst-chunk) (setf (aref buffer-bbuf (index+ boffset 1)) offset) (index-incf boffset (index+ dst-chunk dst-chunk 2))) (setq offset 0) (cond ((null new-font) ;; Don't stop if translate copied whole chunk (unless (index= src-chunk dst-chunk) (setq stop-p t))) ((integerp new-font) (setq offset new-font)) ((type? new-font 'font) (setq font new-font) (let ((font-id (font-id font)) (buffer-boffset boffset)) (declare (type resource-id font-id) (type array-index buffer-boffset)) ;; This changes the gcontext font in the SERVER ;; Update the gcontext cache (both local and server state) (let ((local-state (gcontext-local-state gcontext)) (server-state (gcontext-server-state gcontext))) (declare (type gcontext-state local-state server-state)) (setf (gcontext-internal-font-obj server-state) font (gcontext-internal-font server-state) font-id) (without-interrupts (setf (gcontext-internal-font-obj local-state) font (gcontext-internal-font local-state) font-id))) (card8-put 0 #xff) (card8-put 1 (ldb (byte 8 24) font-id)) (card8-put 2 (ldb (byte 8 16) font-id)) (card8-put 3 (ldb (byte 8 8) font-id)) (card8-put 4 (ldb (byte 8 0) font-id))) (index-incf boffset 5))) ))))) (values next-start width))) (defun draw-image-glyph (drawable gcontext x y elt &key translate width (size :default)) ;; Returns true if elt is output, nil if translate refuses to output it. ;; Second result is overall width, if known. An initial font change is ;; allowed from translate. (declare (type drawable drawable) (type gcontext gcontext) (type int16 x y) (type (or null int32) width) (type index-size size)) (declare (type (or null translation-function) translate) #+clx-ansi-common-lisp (dynamic-extent translate) #+(and lispm (not clx-ansi-common-lisp)) (sys:downward-funarg #+Genera * #-Genera translate)) (declare (clx-values generalized-boolean (or null int32))) (let* ((display (gcontext-display gcontext)) (result t) (opcode +x-imagetext8+)) (declare (type display display)) (let ((vector (allocate-gcontext-state))) (declare (type gcontext-state vector)) (setf (aref vector 0) elt) (multiple-value-bind (new-start new-font translate-width) (funcall (or translate #'translate-default) vector 0 1 (gcontext-font gcontext nil) vector 1) ;; Allow translate to set a new font (when (type? new-font 'font) (setf (gcontext-font gcontext) new-font) (multiple-value-setq (new-start new-font translate-width) (funcall translate vector 0 1 new-font vector 1))) ;; If new-start is zero, translate refuses to output it (setq result (index-plusp new-start) elt (aref vector 1)) (deallocate-gcontext-state vector) (when translate-width (setq width translate-width)))) (when result (when (eql size 16) (setq opcode +x-imagetext16+) (setq elt (dpb elt (byte 8 8) (ldb (byte 8 8) elt)))) (with-buffer-request (display opcode :gc-force gcontext) (drawable drawable) (gcontext gcontext) (data 1) ;; 1 character (int16 x y) (card8 (ldb (byte 8 0) elt)) (card8 (ldb (byte 8 8) elt))) (values t width)))) (defun draw-image-glyphs (drawable gcontext x y sequence &key (start 0) end translate width (size :default)) ;; An initial font change is allowed from translate, but any subsequent font ;; change or horizontal motion will cause termination (because the protocol ;; doesn't support chaining). [Alternatively, font changes could be accepted ;; as long as they are accompanied with a width return value, or always ;; accept font changes and call text-width as required. However, horizontal ;; motion can't really be accepted, due to semantics.] First result is new ;; start, if end was not reached. Second result is overall width, if known. (declare (type drawable drawable) (type gcontext gcontext) (type int16 x y) (type array-index start) (type (or null array-index) end) (type sequence sequence) (type (or null int32) width) (type index-size size)) (declare (type (or null translation-function) translate) #+clx-ansi-common-lisp (dynamic-extent translate) #+(and lispm (not clx-ansi-common-lisp)) (sys:downward-funarg #+Genera * #-Genera translate)) (declare (clx-values (or null array-index) (or null int32))) (setf end (index-min (index+ start 255) (or end (length sequence)))) (ecase size ((:default 8) (draw-image-glyphs8 drawable gcontext x y sequence start end translate width)) (16 (draw-image-glyphs16 drawable gcontext x y sequence start end translate width)))) (defun draw-image-glyphs8 (drawable gcontext x y sequence start end translate width) ;; An initial font change is allowed from translate, but any subsequent font ;; change or horizontal motion will cause termination (because the protocol ;; doesn't support chaining). [Alternatively, font changes could be accepted ;; as long as they are accompanied with a width return value, or always ;; accept font changes and call text-width as required. However, horizontal ;; motion can't really be accepted, due to semantics.] First result is new ;; start, if end was not reached. Second result is overall width, if known. (declare (type drawable drawable) (type gcontext gcontext) (type int16 x y) (type array-index start) (type sequence sequence) (type (or null array-index) end) (type (or null int32) width)) (declare (type (or null translation-function) translate) #+clx-ansi-common-lisp (dynamic-extent translate) #+(and lispm (not clx-ansi-common-lisp)) (sys:downward-funarg translate)) (declare (clx-values (or null array-index) (or null int32))) (do* ((display (gcontext-display gcontext)) (length (index- end start)) (font (gcontext-font gcontext nil)) (font-change nil) (new-start) (translated-width) (chunk)) (nil) ;; forever (declare (type display display) (type array-index length) (type (or null array-index) new-start chunk)) (when font-change (setf (gcontext-font gcontext) font)) (block change-font (with-buffer-request (display +x-imagetext8+ :gc-force gcontext :length length) (drawable drawable) (gcontext gcontext) (int16 x y) (progn ;; Don't let any flushes happen since we manually set the request ;; length when we're done. (with-buffer-flush-inhibited (display) ;; Translate the sequence into the buffer (multiple-value-setq (new-start font translated-width) (funcall (or translate #'translate-default) sequence start end font buffer-bbuf (index+ buffer-boffset 16))) ;; Number of glyphs translated (setq chunk (index- new-start start)) ;; Check for initial font change (when (and (index-zerop chunk) (type? font 'font)) (setq font-change t) ;; Loop around changing font (return-from change-font)) ;; Quit when nothing translated (when (index-zerop chunk) (return-from draw-image-glyphs8 new-start)) ;; Update buffer pointers (data-put 1 chunk) (let ((blen (lround (index+ 16 chunk)))) (length-put 2 (index-ash blen -2)) (setf (buffer-boffset display) (index+ buffer-boffset blen)))))) ;; Normal exit (return-from draw-image-glyphs8 (values (if (index= chunk length) nil new-start) (or translated-width width)))))) (defun draw-image-glyphs16 (drawable gcontext x y sequence start end translate width) ;; An initial font change is allowed from translate, but any subsequent font ;; change or horizontal motion will cause termination (because the protocol ;; doesn't support chaining). [Alternatively, font changes could be accepted ;; as long as they are accompanied with a width return value, or always ;; accept font changes and call text-width as required. However, horizontal ;; motion can't really be accepted, due to semantics.] First result is new ;; start, if end was not reached. Second result is overall width, if known. (declare (type drawable drawable) (type gcontext gcontext) (type int16 x y) (type array-index start) (type sequence sequence) (type (or null array-index) end) (type (or null int32) width)) (declare (type (or null translation-function) translate) #+clx-ansi-common-lisp (dynamic-extent translate) #+(and lispm (not clx-ansi-common-lisp)) (sys:downward-funarg translate)) (declare (clx-values (or null array-index) (or null int32))) (do* ((display (gcontext-display gcontext)) (length (index- end start)) (font (gcontext-font gcontext nil)) (font-change nil) (new-start) (translated-width) (chunk) (buffer (buffer-tbuf16 display))) (nil) ;; forever (declare (type display display) (type array-index length) (type (or null array-index) new-start chunk) (type buffer-text16 buffer)) (when font-change (setf (gcontext-font gcontext) font)) (block change-font (with-buffer-request (display +x-imagetext16+ :gc-force gcontext :length length) (drawable drawable) (gcontext gcontext) (int16 x y) (progn ;; Don't let any flushes happen since we manually set the request ;; length when we're done. (with-buffer-flush-inhibited (display) ;; Translate the sequence into the buffer (multiple-value-setq (new-start font translated-width) (funcall (or translate #'translate-default) sequence start end font buffer 0)) ;; Number of glyphs translated (setq chunk (index- new-start start)) ;; Check for initial font change (when (and (index-zerop chunk) (type? font 'font)) (setq font-change t) ;; Loop around changing font (return-from change-font)) ;; Quit when nothing translated (when (index-zerop chunk) (return-from draw-image-glyphs16 new-start)) (write-sequence-char2b display (index+ buffer-boffset 16) buffer 0 chunk) ;; Update buffer pointers (data-put 1 chunk) (let ((blen (lround (index+ 16 (index-ash chunk 1))))) (length-put 2 (index-ash blen -2)) (setf (buffer-boffset display) (index+ buffer-boffset blen)))))) ;; Normal exit (return-from draw-image-glyphs16 (values (if (index= chunk length) nil new-start) (or translated-width width)))))) ;;----------------------------------------------------------------------------- (defun display-keycode-range (display) (declare (type display display)) (declare (clx-values min max)) (values (display-min-keycode display) (display-max-keycode display))) ;; Should this signal device-busy like the pointer-mapping setf, and return a ;; generalized-boolean instead (true for success)? Alternatively, should the ;; pointer-mapping setf be changed to set-pointer-mapping with a (member ;; :success :busy) result? (defun set-modifier-mapping (display &key shift lock control mod1 mod2 mod3 mod4 mod5) ;; Setf ought to allow multiple values. (declare (type display display) (type sequence shift lock control mod1 mod2 mod3 mod4 mod5)) (declare (clx-values (member :success :busy :failed))) (let* ((keycodes-per-modifier (index-max (length shift) (length lock) (length control) (length mod1) (length mod2) (length mod3) (length mod4) (length mod5))) (data (make-array (index* 8 keycodes-per-modifier) :element-type 'card8 :initial-element 0))) (replace data shift) (replace data lock :start1 keycodes-per-modifier) (replace data control :start1 (index* 2 keycodes-per-modifier)) (replace data mod1 :start1 (index* 3 keycodes-per-modifier)) (replace data mod2 :start1 (index* 4 keycodes-per-modifier)) (replace data mod3 :start1 (index* 5 keycodes-per-modifier)) (replace data mod4 :start1 (index* 6 keycodes-per-modifier)) (replace data mod5 :start1 (index* 7 keycodes-per-modifier)) (with-buffer-request-and-reply (display +x-setmodifiermapping+ 4 :sizes 8) ((data keycodes-per-modifier) ((sequence :format card8) data)) (values (member8-get 1 :success :busy :failed))))) (defun modifier-mapping (display) ;; each value is a list of integers (declare (type display display)) (declare (clx-values shift lock control mod1 mod2 mod3 mod4 mod5)) (let ((lists nil)) (with-buffer-request-and-reply (display +x-getmodifiermapping+ nil :sizes 8) () (do* ((keycodes-per-modifier (card8-get 1)) (advance-by +replysize+ keycodes-per-modifier) (keys nil nil) (i 0 (index+ i 1))) ((index= i 8)) (advance-buffer-offset advance-by) (dotimes (j keycodes-per-modifier) (let ((key (read-card8 j))) (unless (zerop key) (push key keys)))) (push (nreverse keys) lists))) (values-list (nreverse lists)))) ;; Either we will want lots of defconstants for well-known values, or perhaps ;; an integer-to-keyword translation function for well-known values. (defun change-keyboard-mapping (display keysyms &key (start 0) end (first-keycode start)) ;; start/end give subrange of keysyms ;; first-keycode is the first-keycode to store at (declare (type display display) (type array-index start) (type card8 first-keycode) (type (or null array-index) end) (type (array * (* *)) keysyms)) (let* ((keycode-end (or end (array-dimension keysyms 0))) (keysyms-per-keycode (array-dimension keysyms 1)) (length (index- keycode-end start)) (size (index* length keysyms-per-keycode)) (request-length (index+ size 2))) (declare (type array-index keycode-end keysyms-per-keycode length request-length)) (with-buffer-request (display +x-setkeyboardmapping+ :length (index-ash request-length 2) :sizes (32)) (data length) (length request-length) (card8 first-keycode keysyms-per-keycode) (progn (do ((limit (index-ash (buffer-size display) -2)) (w (index+ 2 (index-ash buffer-boffset -2))) (i start (index+ i 1))) ((index>= i keycode-end) (setf (buffer-boffset display) (index-ash w 2))) (declare (type array-index limit w i)) (when (index> w limit) (buffer-flush display) (setq w (index-ash (buffer-boffset display) -2))) (do ((j 0 (index+ j 1))) ((index>= j keysyms-per-keycode)) (declare (type array-index j)) (card29-put (index* w 4) (aref keysyms i j)) (index-incf w))))))) (defun keyboard-mapping (display &key first-keycode start end data) ;; First-keycode specifies which keycode to start at (defaults to min-keycode). ;; Start specifies where (in result) to put first-keycode. (defaults to first-keycode) ;; (- end start) is the number of keycodes to get. (End defaults to (1+ max-keycode)). ;; If DATA is specified, the results are put there. (declare (type display display) (type (or null card8) first-keycode) (type (or null array-index) start end) (type (or null (array * (* *))) data)) (declare (clx-values (array * (* *)))) (unless first-keycode (setq first-keycode (display-min-keycode display))) (unless start (setq start first-keycode)) (unless end (setq end (1+ (display-max-keycode display)))) (with-buffer-request-and-reply (display +x-getkeyboardmapping+ nil :sizes (8 32)) ((card8 first-keycode (index- end start))) (do* ((keysyms-per-keycode (card8-get 1)) (bytes-per-keycode (* keysyms-per-keycode 4)) (advance-by +replysize+ bytes-per-keycode) (keycode-count (floor (card32-get 4) keysyms-per-keycode) (index- keycode-count 1)) (result (if (and (arrayp data) (= (array-rank data) 2) (>= (array-dimension data 0) (index+ start keycode-count)) (>= (array-dimension data 1) keysyms-per-keycode)) data (make-array `(,(index+ start keycode-count) ,keysyms-per-keycode) :element-type 'keysym :initial-element 0))) (i start (1+ i))) ((zerop keycode-count) (setq data result)) (advance-buffer-offset advance-by) (dotimes (j keysyms-per-keycode) (setf (aref result i j) (card29-get (* j 4)))))) data) ecl-16.1.2/src/clx/translate.lisp000066400000000000000000000633111266352375300166270ustar00rootroot00000000000000;;; -*- Mode:Lisp; Package:XLIB; Syntax:COMMON-LISP; Base:10; Lowercase:YES -*- ;;; ;;; TEXAS INSTRUMENTS INCORPORATED ;;; P.O. BOX 2909 ;;; AUSTIN, TEXAS 78769 ;;; ;;; Copyright (C) 1987 Texas Instruments Incorporated. ;;; ;;; Permission is granted to any individual or institution to use, copy, modify, ;;; and distribute this software, provided that this complete copyright and ;;; permission notice is maintained, intact, in all copies and supporting ;;; documentation. ;;; ;;; Texas Instruments Incorporated provides this software "as is" without ;;; express or implied warranty. ;;; (in-package :xlib) (defvar *keysym-sets* nil) ;; Alist of (name first-keysym last-keysym) (defun define-keysym-set (set first-keysym last-keysym) ;; Define all keysyms from first-keysym up to and including ;; last-keysym to be in SET (returned from the keysym-set function). ;; Signals an error if the keysym range overlaps an existing set. (declare (type keyword set) (type keysym first-keysym last-keysym)) (when (> first-keysym last-keysym) (rotatef first-keysym last-keysym)) (setq *keysym-sets* (delete set *keysym-sets* :key #'car)) (dolist (set *keysym-sets*) (let ((first (second set)) (last (third set))) (when (or (<= first first-keysym last) (<= first last-keysym last)) (error "Keysym range overlaps existing set ~s" set)))) (push (list set first-keysym last-keysym) *keysym-sets*) set) (defun keysym-set (keysym) ;; Return the character code set name of keysym (declare (type keysym keysym) (clx-values keyword)) (dolist (set *keysym-sets*) (let ((first (second set)) (last (third set))) (when (<= first keysym last) (return (first set)))))) (eval-when (:compile-toplevel :load-toplevel :execute) (defmacro keysym (keysym &rest bytes) ;; Build a keysym. ;; ;; If KEYSYM is an integer, it is used as the most significant ;; bits of the keysym, and BYTES are used to specify low order ;; bytes. The last parameter is always byte4 of the keysym. If ;; KEYSYM is not an integer, the keysym associated with KEYSYM is ;; returned. ;; ;; This is a macro and not a function macro to promote ;; compile-time lookup. All arguments are evaluated. ;; ;; FIXME: The above means that this shouldn't really be a macro at ;; all, but a compiler macro. Probably, anyway. (declare (type t keysym) (type list bytes) (clx-values keysym)) (typecase keysym ((integer 0 *) (dolist (b bytes keysym) (setq keysym (+ (ash keysym 8) b)))) (otherwise (or (car (character->keysyms keysym)) (error "~s Isn't the name of a keysym" keysym)))))) (defvar *keysym->character-map* (make-hash-table :test (keysym->character-map-test) :size 400)) ;; Keysym-mappings are a list of the form (object translate lowercase modifiers mask) ;; With the following accessor macros. Everything after OBJECT is optional. (defmacro keysym-mapping-object (keysym-mapping) ;; Parameter to translate `(first ,keysym-mapping)) (defmacro keysym-mapping-translate (keysym-mapping) ;; Function to be called with parameters (display state OBJECT) ;; when translating KEYSYM and modifiers and mask are satisfied. `(second ,keysym-mapping)) (defmacro keysym-mapping-lowercase (keysym-mapping) ;; LOWERCASE is used for uppercase alphabetic keysyms. The value ;; is the associated lowercase keysym. `(third ,keysym-mapping)) (defmacro keysym-mapping-modifiers (keysym-mapping) ;; MODIFIERS is either a modifier-mask or list containing intermixed ;; keysyms and state-mask-keys specifying when to use this ;; keysym-translation. `(fourth ,keysym-mapping)) (defmacro keysym-mapping-mask (keysym-mapping) ;; MASK is either a modifier-mask or list containing intermixed ;; keysyms and state-mask-keys specifying which modifiers to look at ;; (i.e. modifiers not specified are don't-cares) `(fifth ,keysym-mapping)) (defvar *default-keysym-translate-mask* (the (or (member :modifiers) mask16 (clx-list (or keysym state-mask-key))) (logand #xff (lognot (make-state-mask :lock)))) "Default keysym state mask to use during keysym-translation.") (defun define-keysym (object keysym &key lowercase translate modifiers mask display) ;; Define the translation from keysym/modifiers to a (usually ;; character) object. ANy previous keysym definition with ;; KEYSYM and MODIFIERS is deleted before adding the new definition. ;; ;; MODIFIERS is either a modifier-mask or list containing intermixed ;; keysyms and state-mask-keys specifying when to use this ;; keysym-translation. The default is NIL. ;; ;; MASK is either a modifier-mask or list containing intermixed ;; keysyms and state-mask-keys specifying which modifiers to look at ;; (i.e. modifiers not specified are don't-cares). ;; If mask is :MODIFIERS then the mask is the same as the modifiers ;; (i.e. modifiers not specified by modifiers are don't cares) ;; The default mask is *default-keysym-translate-mask* ;; ;; If DISPLAY is specified, the translation will be local to DISPLAY, ;; otherwise it will be the default translation for all displays. ;; ;; LOWERCASE is used for uppercase alphabetic keysyms. The value ;; is the associated lowercase keysym. This information is used ;; by the keysym-both-case-p predicate (for caps-lock computations) ;; and by the keysym-downcase function. ;; ;; TRANSLATE will be called with parameters (display state OBJECT) ;; when translating KEYSYM and modifiers and mask are satisfied. ;; [e.g (zerop (logxor (logand state (or mask *default-keysym-translate-mask*)) ;; (or modifiers 0))) ;; when mask and modifiers aren't lists of keysyms] ;; The default is #'default-keysym-translate ;; (declare (type (or base-char t) object) (type keysym keysym) (type (or null mask16 (clx-list (or keysym state-mask-key))) modifiers) (type (or null (member :modifiers) mask16 (clx-list (or keysym state-mask-key))) mask) (type (or null display) display) (type (or null keysym) lowercase) (type (or null (function (display card16 t) t)) translate)) (flet ((merge-keysym-mappings (new old) ;; Merge new keysym-mapping with list of old mappings. ;; Ensure that the mapping with no modifiers or mask comes first. (let* ((key (keysym-mapping-modifiers new)) (merge (delete key old :key #'cadddr :test #'equal))) (if key (nconc merge (list new)) (cons new merge)))) (mask-check (mask) (unless (or (numberp mask) (dolist (element mask t) (unless (or (find element +state-mask-vector+) (gethash element *keysym->character-map*)) (return nil)))) (x-type-error mask '(or mask16 (clx-list (or modifier-key modifier-keysym))))))) (let ((entry ;; Create with a single LIST call, to ensure cdr-coding (cond (mask (unless (eq mask :modifiers) (mask-check mask)) (when (or (null modifiers) (and (numberp modifiers) (zerop modifiers))) (error "Mask with no modifiers")) (list object translate lowercase modifiers mask)) (modifiers (mask-check modifiers) (list object translate lowercase modifiers)) (lowercase (list object translate lowercase)) (translate (list object translate)) (t (list object))))) (if display (let ((previous (assoc keysym (display-keysym-translation display)))) (if previous (setf (cdr previous) (merge-keysym-mappings entry (cdr previous))) (push (list keysym entry) (display-keysym-translation display)))) (setf (gethash keysym *keysym->character-map*) (merge-keysym-mappings entry (gethash keysym *keysym->character-map*))))) object)) (defun undefine-keysym (object keysym &key display modifiers &allow-other-keys) ;; Undefine the keysym-translation translating KEYSYM to OBJECT with MODIFIERS. ;; If DISPLAY is non-nil, undefine the translation for DISPLAY if it exists. (declare (type (or base-char t) object) (type keysym keysym) (type (or null mask16 (clx-list (or keysym state-mask-key))) modifiers) (type (or null display) display)) (flet ((match (key entry) (let ((object (car key)) (modifiers (cdr key))) (or (eql object (keysym-mapping-object entry)) (equal modifiers (keysym-mapping-modifiers entry)))))) (let* (entry (previous (if display (cdr (setq entry (assoc keysym (display-keysym-translation display)))) (gethash keysym *keysym->character-map*))) (key (cons object modifiers))) (when (and previous (find key previous :test #'match)) (setq previous (delete key previous :test #'match)) (if display (setf (cdr entry) previous) (setf (gethash keysym *keysym->character-map*) previous)))))) (defun keysym-downcase (keysym) ;; If keysym has a lower-case equivalent, return it, otherwise return keysym. (declare (type keysym keysym)) (declare (clx-values keysym)) (let ((translations (gethash keysym *keysym->character-map*))) (or (and translations (keysym-mapping-lowercase (first translations))) keysym))) (defun keysym-uppercase-alphabetic-p (keysym) ;; Returns T if keysym is uppercase-alphabetic. ;; I.E. If it has a lowercase equivalent. (declare (type keysym keysym)) (declare (clx-values (or null keysym))) (let ((translations (gethash keysym *keysym->character-map*))) (and translations (keysym-mapping-lowercase (first translations))))) (defun character->keysyms (character &optional display) ;; Given a character, return a list of all matching keysyms. ;; If DISPLAY is given, translations specific to DISPLAY are used, ;; otherwise only global translations are used. ;; Implementation dependent function. ;; May be slow [i.e. do a linear search over all known keysyms] (declare (type t character) (type (or null display) display) (clx-values (clx-list keysym))) (let ((result nil)) (when display (dolist (mapping (display-keysym-translation display)) (when (eql character (second mapping)) (push (first mapping) result)))) (maphash #'(lambda (keysym mappings) (dolist (mapping mappings) (when (eql (keysym-mapping-object mapping) character) (pushnew keysym result)))) *keysym->character-map*) result)) (eval-when (:compile-toplevel :load-toplevel :execute) (defconstant character-set-switch-keysym (keysym 255 126)) (defconstant left-shift-keysym (keysym 255 225)) (defconstant right-shift-keysym (keysym 255 226)) (defconstant left-control-keysym (keysym 255 227)) (defconstant right-control-keysym (keysym 255 228)) (defconstant caps-lock-keysym (keysym 255 229)) (defconstant shift-lock-keysym (keysym 255 230)) (defconstant left-meta-keysym (keysym 255 231)) (defconstant right-meta-keysym (keysym 255 232)) (defconstant left-alt-keysym (keysym 255 233)) (defconstant right-alt-keysym (keysym 255 234)) (defconstant left-super-keysym (keysym 255 235)) (defconstant right-super-keysym (keysym 255 236)) (defconstant left-hyper-keysym (keysym 255 237)) (defconstant right-hyper-keysym (keysym 255 238))) ;;----------------------------------------------------------------------------- ;; Keysym mapping functions (defun display-keyboard-mapping (display) (declare (type display display)) (declare (clx-values (simple-array keysym (display-max-keycode keysyms-per-keycode)))) (or (display-keysym-mapping display) (setf (display-keysym-mapping display) (keyboard-mapping display)))) (defun keycode->keysym (display keycode keysym-index) (declare (type display display) (type card8 keycode) (type card8 keysym-index) (clx-values keysym)) (let* ((mapping (display-keyboard-mapping display)) (keysym (aref mapping keycode keysym-index))) (declare (type (simple-array keysym (* *)) mapping) (type keysym keysym)) ;; The keysym-mapping is brain dammaged. ;; Mappings for both-case alphabetic characters have the ;; entry for keysym-index zero set to the uppercase keysym ;; (this is normally where the lowercase keysym goes), and the ;; entry for keysym-index one is zero. (cond ((zerop keysym-index) ; Lowercase alphabetic keysyms (keysym-downcase keysym)) ((and (zerop keysym) (plusp keysym-index)) ; Get the uppercase keysym (aref mapping keycode 0)) (t keysym)))) (defun keysym->character (display keysym &optional (state 0)) ;; Find the character associated with a keysym. ;; STATE can be used to set character attributes. ;; Implementation dependent function. (declare (type display display) (type keysym keysym) (type card16 state)) (declare (clx-values (or null character))) (let* ((display-mappings (cdr (assoc keysym (display-keysym-translation display)))) (mapping (or ;; Find the matching display mapping (dolist (mapping display-mappings) (when (mapping-matches-p display state mapping) (return mapping))) ;; Find the matching static mapping (dolist (mapping (gethash keysym *keysym->character-map*)) (when (mapping-matches-p display state mapping) (return mapping)))))) (when mapping (funcall (or (keysym-mapping-translate mapping) 'default-keysym-translate) display state (keysym-mapping-object mapping))))) (defun mapping-matches-p (display state mapping) ;; Returns T when the modifiers and mask in MAPPING satisfies STATE for DISPLAY (declare (type display display) (type mask16 state) (type list mapping)) (declare (clx-values generalized-boolean)) (flet ((modifiers->mask (display-mapping modifiers errorp &aux (mask 0)) ;; Convert MODIFIERS, which is a modifier mask, or a list of state-mask-keys into a mask. ;; If ERRORP is non-nil, return NIL when an unknown modifier is specified, ;; otherwise ignore unknown modifiers. (declare (type list display-mapping) ; Alist of (keysym . mask) (type (or mask16 list) modifiers) (type mask16 mask)) (declare (clx-values (or null mask16))) (if (numberp modifiers) modifiers (dolist (modifier modifiers mask) (declare (type symbol modifier)) (let ((bit (position modifier (the simple-vector +state-mask-vector+) :test #'eq))) (setq mask (logior mask (if bit (ash 1 bit) (or (cdr (assoc modifier display-mapping)) ;; bad modifier (if errorp (return-from modifiers->mask nil) 0)))))))))) (let* ((display-mapping (get-display-modifier-mapping display)) (mapping-modifiers (keysym-mapping-modifiers mapping)) (modifiers (or (modifiers->mask display-mapping (or mapping-modifiers 0) t) (return-from mapping-matches-p nil))) (mapping-mask (or (keysym-mapping-mask mapping) ; If no mask, use the default. (if mapping-modifiers ; If no modifiers, match anything. *default-keysym-translate-mask* 0))) (mask (if (eq mapping-mask :modifiers) modifiers (modifiers->mask display-mapping mapping-mask nil)))) (declare (type mask16 modifiers mask)) (= (logand state mask) modifiers)))) (defun default-keysym-index (display keycode state) ;; Returns a keysym-index for use with keycode->character (declare (clx-values card8)) (macrolet ((keystate-p (state keyword) `(logbitp ,(position keyword +state-mask-vector+) ,state))) (let* ((mapping (display-keyboard-mapping display)) (keysyms-per-keycode (array-dimension mapping 1)) (symbolp (and (> keysyms-per-keycode 2) (state-keysymp display state character-set-switch-keysym))) (result (if symbolp 2 0))) (declare (type (simple-array keysym (* *)) mapping) (type generalized-boolean symbolp) (type card8 keysyms-per-keycode result)) (when (and (< result keysyms-per-keycode) (keysym-shift-p display state (keysym-uppercase-alphabetic-p (aref mapping keycode 0)))) (incf result)) result))) (defun keysym-shift-p (display state uppercase-alphabetic-p &key shift-lock-xors (control-modifiers '#.(list left-meta-keysym left-super-keysym left-hyper-keysym))) (declare (type display display) (type card16 state) (type generalized-boolean uppercase-alphabetic-p) (type generalized-boolean shift-lock-xors));;; If T, both SHIFT-LOCK and SHIFT is the same ;;; as neither if the character is alphabetic. (declare (clx-values generalized-boolean)) (macrolet ((keystate-p (state keyword) `(logbitp ,(position keyword +state-mask-vector+) ,state))) (let* ((controlp (or (keystate-p state :control) (dolist (modifier control-modifiers) (when (state-keysymp display state modifier) (return t))))) (shiftp (keystate-p state :shift)) (lockp (keystate-p state :lock)) (alphap (or uppercase-alphabetic-p (not (state-keysymp display #.(make-state-mask :lock) caps-lock-keysym))))) (declare (type generalized-boolean controlp shiftp lockp alphap)) ;; Control keys aren't affected by lock (unless controlp ;; Not a control character - check state of lock modifier (when (and lockp alphap (or (not shiftp) shift-lock-xors)) ; Lock doesn't unshift unless shift-lock-xors (setq shiftp (not shiftp)))) shiftp))) ;;; default-keysym-index implements the following tables: ;;; ;;; control shift caps-lock character character ;;; 0 0 0 #\a #\8 ;;; 0 0 1 #\A #\8 ;;; 0 1 0 #\A #\* ;;; 0 1 1 #\A #\* ;;; 1 0 0 #\control-A #\control-8 ;;; 1 0 1 #\control-A #\control-8 ;;; 1 1 0 #\control-shift-a #\control-* ;;; 1 1 1 #\control-shift-a #\control-* ;;; ;;; control shift shift-lock character character ;;; 0 0 0 #\a #\8 ;;; 0 0 1 #\A #\* ;;; 0 1 0 #\A #\* ;;; 0 1 1 #\A #\8 ;;; 1 0 0 #\control-A #\control-8 ;;; 1 0 1 #\control-A #\control-* ;;; 1 1 0 #\control-shift-a #\control-* ;;; 1 1 1 #\control-shift-a #\control-8 (defun keycode->character (display keycode state &key keysym-index (keysym-index-function #'default-keysym-index)) ;; keysym-index defaults to the result of keysym-index-function which ;; is called with the following parameters: ;; (char0 state caps-lock-p keysyms-per-keycode) ;; where char0 is the "character" object associated with keysym-index 0 and ;; caps-lock-p is non-nil when the keysym associated with the lock ;; modifier is for caps-lock. ;; STATE can also used for setting character attributes. ;; Implementation dependent function. (declare (type display display) (type card8 keycode) (type card16 state) (type (or null card8) keysym-index) (type (or null (function (base-char card16 generalized-boolean card8) card8)) keysym-index-function)) (declare (clx-values (or null character))) (let* ((index (or keysym-index (funcall keysym-index-function display keycode state))) (keysym (if index (keycode->keysym display keycode index) 0))) (declare (type (or null card8) index) (type keysym keysym)) (when (plusp keysym) (keysym->character display keysym state)))) (defun get-display-modifier-mapping (display) (labels ((keysym-replace (display modifiers mask &aux result) (dolist (modifier modifiers result) (push (cons (keycode->keysym display modifier 0) mask) result)))) (or (display-modifier-mapping display) (multiple-value-bind (shift lock control mod1 mod2 mod3 mod4 mod5) (modifier-mapping display) (setf (display-modifier-mapping display) (nconc (keysym-replace display shift #.(make-state-mask :shift)) (keysym-replace display lock #.(make-state-mask :lock)) (keysym-replace display control #.(make-state-mask :control)) (keysym-replace display mod1 #.(make-state-mask :mod-1)) (keysym-replace display mod2 #.(make-state-mask :mod-2)) (keysym-replace display mod3 #.(make-state-mask :mod-3)) (keysym-replace display mod4 #.(make-state-mask :mod-4)) (keysym-replace display mod5 #.(make-state-mask :mod-5)))))))) (defun state-keysymp (display state keysym) ;; Returns T when a modifier key associated with KEYSYM is on in STATE (declare (type display display) (type card16 state) (type keysym keysym)) (declare (clx-values generalized-boolean)) (let* ((mapping (get-display-modifier-mapping display)) (mask (assoc keysym mapping))) (and mask (plusp (logand state (cdr mask)))))) (defun mapping-notify (display request start count) ;; Called on a mapping-notify event to update ;; the keyboard-mapping cache in DISPLAY (declare (type display display) (type (member :modifier :keyboard :pointer) request) (type card8 start count) (ignore count start)) ;; Invalidate the keyboard mapping to force the next key translation to get it (case request (:modifier (setf (display-modifier-mapping display) nil)) (:keyboard (setf (display-keysym-mapping display) nil)))) (defun keysym-in-map-p (display keysym keymap) ;; Returns T if keysym is found in keymap (declare (type display display) (type keysym keysym) (type (bit-vector 256) keymap)) (declare (clx-values generalized-boolean)) ;; The keysym may appear in the keymap more than once, ;; So we have to search the entire keysym map. (do* ((min (display-min-keycode display)) (max (display-max-keycode display)) (map (display-keyboard-mapping display)) (jmax (min 2 (array-dimension map 1))) (i min (1+ i))) ((> i max)) (declare (type card8 min max jmax) (type (simple-array keysym (* *)) map)) (when (and (plusp (aref keymap i)) (dotimes (j jmax) (when (= keysym (aref map i j)) (return t)))) (return t)))) (defun character-in-map-p (display character keymap) ;; Implementation dependent function. ;; Returns T if character is found in keymap (declare (type display display) (type character character) (type (bit-vector 256) keymap)) (declare (clx-values generalized-boolean)) ;; Check all one bits in keymap (do* ((min (display-min-keycode display)) (max (display-max-keycode display)) (jmax (array-dimension (display-keyboard-mapping display) 1)) (i min (1+ i))) ((> i max)) (declare (type card8 min max jmax)) (when (and (plusp (aref keymap i)) ;; Match when character is in mapping for this keycode (dotimes (j jmax) (when (eql character (keycode->character display i 0 :keysym-index j)) (return t)))) (return t)))) (defun keysym->keycodes (display keysym) ;; Return keycodes for keysym, as multiple values (declare (type display display) (type keysym keysym)) (declare (clx-values (or null keycode) (or null keycode) (or null keycode))) ;; The keysym may appear in the keymap more than once, ;; So we have to search the entire keysym map. (do* ((min (display-min-keycode display)) (max (display-max-keycode display)) (map (display-keyboard-mapping display)) (jmax (min 2 (array-dimension map 1))) (i min (1+ i)) (result nil)) ((> i max) (values-list result)) (declare (type card8 min max jmax) (type (simple-array keysym (* *)) map)) (dotimes (j jmax) (when (= keysym (aref map i j)) (push i result))))) ecl-16.1.2/src/clx/xinerama.lisp000066400000000000000000000056571266352375300164470ustar00rootroot00000000000000;;; -*- Mode: Lisp -*- ;;; ;;; Copyright (C) 2008, Julian Stecklina ;;; ;;; (( ;;; )) This file is COFFEEWARE. As long as you retain this notice ;;; | |o) you can do whatever you want with this code. If you think, ;;; |___|jgs it's worth it, you may buy the author a coffee in return. ;;; ;;; Description: ;;; ;;; This is an implementation of the XINERAMA extension. It does not ;;; include the obsolete PanoramiX calls. (defpackage "XLIB.XINERAMA" (:use "COMMON-LISP" "XLIB") (:nicknames "XINERAMA") (:import-from "XLIB" "WITH-BUFFER-REQUEST" "WITH-BUFFER-REQUEST-AND-REPLY" "DATA" "BOOLEAN" "BOOLEAN-GET" "CARD8" "CARD8-GET" "CARD16" "CARD16-GET" "CARD32" "CARD32-GET" "INT16" "INT16-GET") (:export "SCREEN-INFO" "SCREEN-INFO-NUMBER" "SCREEN-INFO-X" "SCREEN-INFO-Y" "SCREEN-INFO-WIDTH" "SCREEN-INFO-HEIGHT" "XINERAMA-QUERY-VERSION" "XINERAMA-IS-ACTIVE" "XINERAMA-QUERY-SCREENS")) (in-package "XINERAMA") (define-extension "XINERAMA") (defun xinerama-opcode (display) (extension-opcode display "XINERAMA")) (defconstant +major-version+ 1) (defconstant +minor-version+ 1) (defconstant +get-version+ 0) (defconstant +get-state+ 1) (defconstant +get-screen-count+ 2) (defconstant +get-screen-size+ 3) (defconstant +is-active+ 4) (defconstant +query-screens+ 5) (defstruct screen-info (number 0 :type (unsigned-byte 32)) (x 0 :type (signed-byte 16)) (y 0 :type (signed-byte 16)) (width 0 :type (unsigned-byte 16)) (height 0 :type (unsigned-byte 16))) (defun xinerama-query-version (display) (with-buffer-request-and-reply (display (xinerama-opcode display) nil) ((data +get-version+) (card8 +major-version+) (card8 +minor-version+)) (values (card16-get 8) ; server major version (card16-get 10)))) ; server minor version (defun xinerama-is-active (display) "Returns T, iff Xinerama is supported and active." (with-buffer-request-and-reply (display (xinerama-opcode display) nil) ((data +is-active+)) (values ;; XCB says this is actually a CARD32, but why?! (boolean-get 8)))) (defun xinerama-query-screens (display) "Returns a list of screen-info structures." (with-buffer-request-and-reply (display (xinerama-opcode display) nil) ((data +query-screens+)) (values (loop with index = 32 for number from 0 below (card32-get 8) collect (prog1 (make-screen-info :number number :x (int16-get index) :y (int16-get (+ index 2)) :width (card16-get (+ index 4)) :height (card16-get (+ index 6))) (incf index 8)))))) ;;; EOF ecl-16.1.2/src/clx/xrender.lisp000066400000000000000000001444771266352375300163160ustar00rootroot00000000000000;;; -*- Mode: Lisp; Syntax: Common-Lisp; Package: XLIB; -*- ;;; --------------------------------------------------------------------------- ;;; Title: The X Render Extension ;;; Created: 2002-08-03 ;;; Author: Gilbert Baumann ;;; $Id: xrender.lisp,v 1.5 2004/12/06 11:48:57 csr21 Exp $ ;;; --------------------------------------------------------------------------- ;;; ;;; (c) copyright 2002, 2003 by Gilbert Baumann ;;; (c) copyright 2002 by Christian Sunesson ;;; ;;; Permission is granted to any individual or institution to use, ;;; copy, modify, and distribute this software, provided that this ;;; complete copyright and permission notice is maintained, intact, in ;;; all copies and supporting documentation. ;;; ;;; 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. ;;; ;;; NOTE: we need to watch maximum request sizes and somehow work ;;; around them. Sometimes e.g. in AddGlyphs this is not possible, ;;; which is a design failure. ;;; TODO ;; - some request are still to be implemented at all. ;; + Can they not wait? Xrender seems to be in flux as the specification ;; isn't even conforming to the acctual protocol. However backwards ;; wierd that sound. --noss ;; - we need to invent something for the color values of e.g. ;; fill-rectangles; I would prefer some generic functions, so that ;; we later can map CLIM design directly to colors. ;; - we want some conviencene function to turn graphics contexts into ;; render pictures. --GB 2002-08-21 ;; - also: uniform-alpha-picture display alpha-value ;; uniform-color-picture display red green blue ;; --GB 2002-08-21 ;; - maybe we should aim for a higher level interface to ;; color-trapzoids and color-triangles and offer a low level [raw] ;; interface also for high performance apps? ;; - Write tests. ;;;; API issues ;; - On one hand we want convenience functions like RENDER-TRIANGLE or ;; WITH-UNIFORM-COLOR-PICTURE. On the other hand if you are up to ;; write a full rasterization library you obviously want high ;; performance entry points as RENDER-TRIANGLES-1. ;; - We want to extend XLIB:COLOR into something with alpha channel. ;; How to name it? ;; - WITH-UNIFORM-COLOR-PICTURE (var picture r g b &optional alpha) &body body ;; ;; Example: ;; (WITH-UNIFORM-COLOR-PICTURE (color dest 1.0 1.0 0.0) ;; (RENDER-TRIANGLE dest color ...)) ;; - Pose the filter and the transform slots of a picture. ;; - Also introduce a PICTURE-DEFAULT-MASK-FORMAT? ;; - COPY-PICTURE? ;; - WITH-PICTURE-OPTIONS ? ;; ;; (WITH-PICTURE-OPTIONS (pic :repeat :on) ...) ;; - WITH-PICTURE ? ;; ;; (WITH-PICTURE (picture drawable ...) ...) ;; (in-package :xlib) ;; Beginning to collect the external interface for documentation. (export '(render-create-picture render-free-picture render-create-glyph-set render-reference-glyph-set render-free-glyph-set render-add-glyph render-add-glyph-from-picture render-free-glyph render-fill-rectangle picture-format-display picture-format-id picture-format-type picture-format-depth picture-format-red-byte picture-format-green-byte picture-format-blue-byte picture-format-alpha-byte picture-format-colormap ;; picture object picture-repeat picture-alpha-map picture-alpha-x-origin picture-alpha-y-origin picture-clip-x-origin picture-clip-y-origin picture-clip-mask picture-graphics-exposures picture-subwindow-mode picture-poly-edge picture-poly-mode picture-dither picture-component-alpha picture-drawable find-matching-picture-formats find-window-picture-format render-free-picture render-free-glyph-set render-query-version ;; render-query-picture-formats render-fill-rectangle render-composite render-create-glyph-set render-reference-glyph-set render-composite-glyphs render-add-glyph render-add-glyph-from-picture render-free-glyphs)) (pushnew :clx-ext-render *features*) (define-extension "RENDER") ;;;; Request constants ;; Note: Although version numbers are given render.h where the request ;; numbers are defined, render-query-version returns 0.0 all displays ;; i tested. --GB 2004-07-21 (defconstant +X-RenderQueryVersion+ 0) ;done (defconstant +X-RenderQueryPictFormats+ 1) (defconstant +X-RenderQueryPictIndexValues+ 2) ;0.7 (defconstant +X-RenderQueryDithers+ 3) (defconstant +X-RenderCreatePicture+ 4) ;done (defconstant +X-RenderChangePicture+ 5) ;done (defconstant +X-RenderSetPictureClipRectangles+ 6) ;done (defconstant +X-RenderFreePicture+ 7) ;done (defconstant +X-RenderComposite+ 8) ;we need better arglist (defconstant +X-RenderScale+ 9) (defconstant +X-RenderTrapezoids+ 10) ;low-level done (defconstant +X-RenderTriangles+ 11) ;low-level done (defconstant +X-RenderTriStrip+ 12) (defconstant +X-RenderTriFan+ 13) (defconstant +X-RenderColorTrapezoids+ 14) ;nyi in X server, not mentioned in renderproto.h (defconstant +X-RenderColorTriangles+ 15) ;nyi in X server, not mentioned in renderproto.h (defconstant +X-RenderTransform+ 16) ;commented out in render.h (defconstant +X-RenderCreateGlyphSet+ 17) ;done (defconstant +X-RenderReferenceGlyphSet+ 18) ;done (defconstant +X-RenderFreeGlyphSet+ 19) ;done (defconstant +X-RenderAddGlyphs+ 20) ;done, untested (defconstant +X-RenderAddGlyphsFromPicture+ 21) ;done, untested (defconstant +X-RenderFreeGlyphs+ 22) ;done, untested (defconstant +X-RenderCompositeGlyphs8+ 23) ;done (defconstant +X-RenderCompositeGlyphs16+ 24) ;done (defconstant +X-RenderCompositeGlyphs32+ 25) ;done ;; >= 0.1 (defconstant +X-RenderFillRectangles+ 26) ;single rectangle version done ;; >= 0.5 (defconstant +X-RenderCreateCursor+ 27) ;; >= 0.6 (defconstant +X-RenderSetPictureTransform+ 28) ;I don't understand what this one should do. (defconstant +X-RenderQueryFilters+ 29) ;seems to be there on server side ; some guts of its implementation there. (defconstant +X-RenderSetPictureFilter+ 30) (defconstant +X-RenderCreateAnimCursor+ 31) ;What has render to do with cursors? ;;;; ;; Sanity measures: ;; We do away with the distinction between pict-format and ;; picture-format-info. That is we cache picture-format-infos. (defstruct render-info major-version minor-version picture-formats) (defun display-render-info (display) (getf (xlib:display-plist display) 'render-info)) (defun (setf display-render-info) (new-value display) (setf (getf (xlib:display-plist display) 'render-info) new-value)) (defun ensure-render-initialized (display) "Ensures that the RENDER extension is initialized. Should be called by every function, which attempts to generate RENDER requests." ;; xxx locking? (unless (display-render-info display) (let ((q (make-render-info))) (multiple-value-bind (maj min) (render-query-version display) (setf (render-info-major-version q) maj (render-info-minor-version q) min) (setf (render-info-picture-formats q) (make-hash-table :test #'eql)) (dolist (pf (render-query-picture-formats display)) (setf (gethash (picture-format-id pf) (render-info-picture-formats q)) pf)) (setf (display-render-info display) q))))) (defun find-matching-picture-formats (display &key depth-min depth-max depth red-min red-max red green-min green-max green blue-min blue-max blue alpha-min alpha-max alpha type colormap) ;; (ensure-render-initialized display) (let ((res nil)) (maphash (lambda (k f) (declare (ignore k)) (when (and (or (null type) (eql (picture-format-type f) type)) (or (null colormap) (eql (picture-format-colormap f) colormap)) ;; min (or (null depth-min) (>= (picture-format-depth f) depth-min)) (or (null red-min) (>= (byte-size (picture-format-red-byte f)) red-min)) (or (null green-min) (>= (byte-size (picture-format-green-byte f)) green-min)) (or (null blue-min) (>= (byte-size (picture-format-blue-byte f)) blue-min)) (or (null alpha-min) (>= (byte-size (picture-format-alpha-byte f)) alpha-min)) ;; max (or (null depth-max) (<= (picture-format-depth f) depth-max)) (or (null red-max) (<= (byte-size (picture-format-red-byte f)) red-max)) (or (null green-max) (<= (byte-size (picture-format-green-byte f)) green-max)) (or (null blue-max) (<= (byte-size (picture-format-blue-byte f)) blue-max)) (or (null alpha-max) (<= (byte-size (picture-format-alpha-byte f)) alpha-max)) ;; match (or (null depth) (= (picture-format-depth f) depth)) (or (null red) (= (byte-size (picture-format-red-byte f)) red)) (or (null green) (= (byte-size (picture-format-green-byte f)) green)) (or (null blue) (= (byte-size (picture-format-blue-byte f)) blue)) (or (null alpha) (= (byte-size (picture-format-alpha-byte f)) alpha))) (pushnew f res))) (render-info-picture-formats (display-render-info display))) res)) (defun find-window-picture-format (window) "Find the picture format which matches the given window." (let* ((vi (window-visual-info window)) (display (window-display window))) (ensure-render-initialized display) (case (visual-info-class vi) ((:true-color) (maphash (lambda (k f) (declare (ignore k)) (when (and (eql (picture-format-type f) :direct) (eql (picture-format-depth f) (drawable-depth window)) (eql (dpb -1 (picture-format-red-byte f) 0) (visual-info-red-mask vi)) (eql (dpb -1 (picture-format-green-byte f) 0) (visual-info-green-mask vi)) (eql (dpb -1 (picture-format-blue-byte f) 0) (visual-info-blue-mask vi)) (eql (byte-size (picture-format-alpha-byte f)) 0)) (return-from find-window-picture-format f))) (render-info-picture-formats (display-render-info display)))) (t )))) (eval-when (:compile-toplevel :load-toplevel :execute) (define-accessor picture (32) ((index) index :blip) ((index thing) `(resource-id-put ,index (picture-id ,thing)))) (define-accessor glyph-set (32) ((index) index :blip) ((index thing) `(resource-id-put ,index (glyph-set-id ,thing))))) ;;; picture format (defstruct picture-format display (id 0 :type (unsigned-byte 29)) type depth red-byte green-byte blue-byte alpha-byte colormap) (defmethod print-object ((object picture-format) stream) (let ((abbrev (with-output-to-string (bag) ;; build an abbreviated representation of the format (let ((bytes (sort (list (cons "r" (picture-format-red-byte object)) (cons "g" (picture-format-green-byte object)) (cons "b" (picture-format-blue-byte object)) (cons "a" (picture-format-alpha-byte object))) #'> :key #'(lambda (x) (byte-position (cdr x)))))) (dolist (k bytes) (unless (zerop (byte-size (cdr k))) (format bag " ~A~D" (car k) (byte-size (cdr k))))))))) (print-unreadable-object (object stream :type t :identity nil) (format stream "~D ~S ~S ~S~A" (picture-format-id object) (picture-format-colormap object) (picture-format-depth object) (picture-format-type object) abbrev)))) (eval-when (:compile-toplevel :load-toplevel :execute) (define-accessor picture-format (32) ((index) `(gethash (read-card32 ,index) (render-info-picture-formats (display-render-info .display.)))) ((index thing) `(write-card32 ,index (picture-format-id ,thing)))) (define-accessor render-op (8) ((index) `(member8-get ,index :clear :src :dst :over :over-reverse :in :in-reverse :out :out-reverse :atop :atop-reverse :xor :add :saturate '#:undefined-pict-op-Eh '#:undefined-pict-op-Fh :disjoint-clear :disjoint-src :disjoint-dst :disjoint-over :disjoint-over-reverse :disjoint-in :disjoint-in-reverse :disjoint-out :disjoint-out-reverse :disjoint-atop :disjoint-atop-reverse :disjoint-xor '#:undefined-pict-op-1Ch '#:undefined-pict-op-1Dh '#:undefined-pict-op-1Eh '#:undefined-pict-op-1Fh :conjoint-clear :conjoint-src :conjoint-dst :conjoint-over :conjoint-over-reverse :conjoint-in :conjoint-in-reverse :conjoint-out :conjoint-out-reverse :conjoint-atop :conjoint-atop-reverse :conjoint-xor)) ((index thing) `(member8-put ,index ,thing :clear :src :dst :over :over-reverse :in :in-reverse :out :out-reverse :atop :atop-reverse :xor :add :saturate '#:undefined-pict-op-Eh '#:undefined-pict-op-Fh :disjoint-clear :disjoint-src :disjoint-dst :disjoint-over :disjoint-over-reverse :disjoint-in :disjoint-in-reverse :disjoint-out :disjoint-out-reverse :disjoint-atop :disjoint-atop-reverse :disjoint-xor '#:undefined-pict-op-1Ch '#:undefined-pict-op-1Dh '#:undefined-pict-op-1Eh '#:undefined-pict-op-1Fh :conjoint-clear :conjoint-src :conjoint-dst :conjoint-over :conjoint-over-reverse :conjoint-in :conjoint-in-reverse :conjoint-out :conjoint-out-reverse :conjoint-atop :conjoint-atop-reverse :conjoint-xor))) (deftype render-op () '(member :clear :src :dst :over :over-reverse :in :in-reverse :out :out-reverse :atop :atop-reverse :xor :add :saturate :disjoint-clear :disjoint-src :disjoint-dst :disjoint-over :disjoint-over-reverse :disjoint-in :disjoint-in-reverse :disjoint-out :disjoint-out-reverse :disjoint-atop :disjoint-atop-reverse :disjoint-xor :conjoint-clear :conjoint-src :conjoint-dst :conjoint-over :conjoint-over-reverse :conjoint-in :conjoint-in-reverse :conjoint-out :conjoint-out-reverse :conjoint-atop :conjoint-atop-reverse :conjoint-xor))) ;; Now these pictures objects are like graphics contexts. I was about ;; to introduce a synchronous mode, realizing that the RENDER protocol ;; provides no provision to actually query a picture object's values. ;; *sigh* (def-clx-class (picture (:copier nil)) (id 0 :type resource-id) (display nil :type (or null display)) (plist nil :type list) ; Extension hook (format) (%changed-p) (%server-values) (%values) (%drawable)) (defun picture-drawable (picture) (picture-%drawable picture)) ;; xx make id, display, format readonly (defun %render-change-picture-clip-rectangles (picture rectangles) "Dont call me, use (SETF PICTURE-CLIP-MASK) instead." (declare (optimize (speed 0))) (let ((display (picture-display picture))) (ensure-render-initialized display) (with-buffer-request (display (extension-opcode display "RENDER")) (data +X-RenderSetPictureClipRectangles+) (picture picture) (int16 (picture-clip-x-origin picture)) (int16 (picture-clip-y-origin picture)) ((sequence :format int16) rectangles)))) (macrolet ((foo (&rest specs) `(progn ,@(loop for (type slot default) in specs for index from 0 collect `(progn (defun ,(xintern 'picture- slot) (picture) (aref (picture-%values picture) ,index)) (defun (setf ,(xintern 'picture- slot)) (new-value picture) (setf (picture-%changed-p picture) t) (setf (aref (picture-%values picture) ,index) new-value)))) (defun synchronise-picture-state (picture) (when (picture-%changed-p picture) (let ((display (picture-display picture))) (ensure-render-initialized display) (with-buffer-request (display (extension-opcode display "RENDER")) (data +X-RenderChangePicture+) (picture picture) (mask ,@(loop for (type slot default) in specs for index from 0 collect `(,type (and ,(cond ((eql slot 'clip-mask) `(not (typep (aref (picture-%values picture) ,index) 'sequence))) (t 't)) (not (eq (aref (picture-%values picture) ,index) (aref (picture-%server-values picture) ,index))) (setf (aref (picture-%server-values picture) ,index) (aref (picture-%values picture) ,index)))))))) ,(let ((index (position 'clip-mask specs :key #'second))) `(unless (eql (aref (picture-%values picture) ,index) (aref (picture-%server-values picture) ,index)) (%render-change-picture-clip-rectangles picture (aref (picture-%values picture) ,index)) (setf (aref (picture-%server-values picture) ,index) (aref (picture-%values picture) ,index)))) (setf (picture-%changed-p picture) nil))) (defun render-create-picture (drawable &key format (picture (make-picture :display (drawable-display drawable))) ,@(loop for (type slot default-value) in specs collect (cond ((eql slot 'clip-mask) `(clip-mask :none)) (t slot))) ) ;; xxx also offer to give a colormap instead of a picture-format ;; values! (let ((display (drawable-display drawable))) (ensure-render-initialized display) (unless format ;; xxx check for drawable being a window (setf format (find-window-picture-format drawable))) (let ((pid (allocate-resource-id display picture 'picture))) (setf (picture-id picture) pid) (with-buffer-request (display (extension-opcode display "RENDER")) (data +X-RenderCreatePicture+) (resource-id pid) (drawable drawable) (picture-format format) (mask ,@(loop for (type slot default) in specs collect (cond ((eql slot 'clip-mask) (list type `(and (not (typep clip-mask 'sequence)) clip-mask))) (t (list type slot))))))) (when (typep clip-mask 'sequence) (%render-change-picture-clip-rectangles picture clip-mask)) (setf (picture-format picture) format) (setf (picture-%server-values picture) (vector ,@(loop for (type slot default) in specs collect `(or ,slot ,default)))) (setf (picture-%values picture) (copy-seq (picture-%server-values picture))) (setf (picture-%drawable picture) drawable) picture)) (defconstant +picture-state-length+ ,(length specs)) ))) (foo ((member :off :on) repeat :off) ((or (member :none) picture) alpha-map :none) (int16 alpha-x-origin 0) (int16 alpha-y-origin 0) (int16 clip-x-origin 0) (int16 clip-y-origin 0) ;; ### Now that is not correct is it?: ((or (member :none) pixmap) clip-mask :none) ((member :off :on) graphics-exposures :on) ((member :clip-by-children :include-inferiors) subwindow-mode :clip-by-children) ((member :sharp :smooth) poly-edge :smooth) ((member :precise :imprecise) poly-mode :precise) ((or (member :none) #||xatom||#) dither :none) ((member :off :on) component-alpha :off))) (defun render-free-picture (picture) (let ((display (picture-display picture))) (with-buffer-request (display (extension-opcode display "RENDER")) (data +X-RenderFreePicture+) (picture picture)))) (defun render-free-glyph-set (glyph-set) (let ((display (glyph-set-display glyph-set))) (with-buffer-request (display (extension-opcode display "RENDER")) (data +X-RenderFreeGlyphSet+) (glyph-set glyph-set)))) (defun render-query-version (display) (with-buffer-request-and-reply (display (extension-opcode display "RENDER") nil) ((data +X-RenderQueryVersion+) (card32 0) (card32 1)) (values (card32-get 8) (card32-get 12) ))) (defun render-query-picture-formats (display) (with-buffer-request-and-reply (display (extension-opcode display "RENDER") nil) ((data +X-RenderQueryPictFormats+)) (let ((n-picture-formats (card32-get 8)) (n-screens (card32-get 12)) (n-depths (card32-get 16)) (n-visuals (card32-get 20)) (n-subpixel (card32-get 24))) (declare (ignore n-screens n-depths n-visuals n-subpixel)) (loop for i below n-picture-formats collect (let ((off (+ (* 8 4) (* i 28)))) ;size of picture-format-info (make-picture-format :display display :id (card32-get (+ off 0)) :type (member8-get (+ off 4) :indexed :direct) :depth (card8-get (+ off 5)) :red-byte (byte (integer-length (card16-get (+ off 10))) (card16-get (+ off 8))) :green-byte (byte (integer-length (card16-get (+ off 14))) (card16-get (+ off 12))) :blue-byte (byte (integer-length (card16-get (+ off 18))) (card16-get (+ off 16))) :alpha-byte (byte (integer-length (card16-get (+ off 22))) (card16-get (+ off 20))) :colormap (let ((cmid (card32-get (+ off 24)))) (unless (zerop cmid) (lookup-colormap display cmid))))))))) (defun render-fill-rectangle (picture op color x1 y1 w h) (let ((display (picture-display picture))) (ensure-render-initialized display) (synchronise-picture-state picture) (with-buffer-request (display (extension-opcode display "RENDER")) (data +X-RenderFillRectangles+) (render-op op) ;op (card8 0) ;pad (card16 0) ;pad (resource-id (picture-id picture)) (card16 (elt color 0)) (card16 (elt color 1)) (card16 (elt color 2)) (card16 (elt color 3)) (int16 x1) (int16 y1) (card16 w) (card16 h)))) ;; fill rectangles, colors. (defun render-triangles-1 (picture op source src-x src-y format coord-sequence) ;; For performance reasons we do a special typecase on (simple-array ;; (unsigned-byte 32) (*)), so that it'll be possible to have high ;; performance rasters. (macrolet ((guts () '(let ((display (picture-display picture))) (synchronise-picture-state picture) (synchronise-picture-state source) (with-buffer-request (display (extension-opcode display "RENDER")) (data +X-RenderTriangles+) (render-op op) ;op (card8 0) ;pad (card16 0) ;pad (resource-id (picture-id source)) (resource-id (picture-id picture)) (picture-format format) (int16 src-x) (int16 src-y) ((sequence :format int32) coord-sequence) )))) (typecase coord-sequence ((simple-array (unsigned-byte 32) (*)) (locally (declare (type (simple-array (unsigned-byte 32) (*)) coord-sequence)) (guts))) (t (guts))))) #|| (defun render-set-picture-transform (picture mxx mxy dx mxy myy dy &optional (mwx 0) (mwy 0) (dw 1)) ...) ||# (defun render-set-picture-transform (picture a b c d e f p q r) (let ((display (picture-display picture))) (ensure-render-initialized display) (synchronise-picture-state picture) (with-buffer-request (display (extension-opcode display "RENDER")) (data +X-RenderSetPictureTransform+) #| (card8 0) ;; render-op op) ;op (card8 0) ;pad (card16 0) ;pad |# (resource-id (picture-id picture)) (card32 a) (card32 b) (card32 c) (card32 d) (card32 e) (card32 f) (card32 p) (card32 q) (card32 r)))) (defun render-query-filters (drawable) (let ((display (drawable-display drawable))) (with-buffer-request-and-reply (display (extension-opcode display "RENDER") nil) ((data +X-RenderQueryFilters+) (drawable drawable)) (let* ((len (card32-get 4)) (n-aliases (card32-get 8)) (n-filters (card32-get 12)) (off (+ (* 8 4) (* 4 (ceiling (* 2 n-aliases) 4))))) (print (list :aliases (loop for i below n-aliases collect (card16-get (+ (* 8 4) (* i 2)))))) (print (list :foo len n-aliases n-filters (loop for i below len collect (card8-get (+ off 0 (* 4 i))) collect (card8-get (+ off 1 (* 4 i))) collect (card8-get (+ off 2 (* 4 i))) collect (card8-get (+ off 3 (* 4 i)))))) (print (labels ((grab-string (j) (let ((n (card8-get j))) (incf j) (values (map 'string #'code-char (loop repeat n collect (card8-get j) do (incf j))) j)))) (loop repeat n-filters collect (multiple-value-bind (s j) (grab-string off) (setf off j) (intern (string-upcase s) :keyword))))) #+NIL (loop for i below n-picture-formats collect (let ((off (+ (* 8 4) (* i 28)))) ;size of picture-format-info (make-picture-format :display display :id (card32-get (+ off 0)) :type (member8-get (+ off 4) :indexed :direct) :depth (card8-get (+ off 5)) :red-byte (byte (integer-length (card16-get (+ off 10))) (card16-get (+ off 8))) :green-byte (byte (integer-length (card16-get (+ off 14))) (card16-get (+ off 12))) :blue-byte (byte (integer-length (card16-get (+ off 18))) (card16-get (+ off 16))) :alpha-byte (byte (integer-length (card16-get (+ off 22))) (card16-get (+ off 20))) :colormap (let ((cmid (card32-get (+ off 24)))) (unless (zerop cmid) (lookup-colormap display cmid)))))))))) (defun render-set-filter (picture filter) (let ((display (picture-display picture))) (ensure-render-initialized display) (synchronise-picture-state picture) (with-buffer-request (display (extension-opcode display "RENDER")) (data +X-RenderSetPictureFilter+) (resource-id (picture-id picture)) (card16 (length filter)) (card16 0) ;pad ((sequence :format card8) (map 'vector #'char-code filter))))) #|| (defun render-triangle (destination source x1 y1 x2 y2 x3 y3 &key (src-x 0) (src-y 0) (format nil) (op :over)) (render-triangles-1 destination op source ...) ) ||# (defun render-trapezoids-1 (picture op source src-x src-y mask-format coord-sequence) ;; coord-sequence is top bottom ;; line-1-x1 line-1-y1 line-1-x2 line-1-y2 ;; line-2-x1 line-2-y1 line-2-x2 line-2-y2 ... ;; (let ((display (picture-display picture))) (synchronise-picture-state picture) (synchronise-picture-state source) (with-buffer-request (display (extension-opcode display "RENDER")) (data +X-RenderTrapezoids+) (render-op op) ;op (card8 0) ;pad (card16 0) ;pad (resource-id (picture-id source)) (resource-id (picture-id picture)) ((or (member :none) picture-format) mask-format) (int16 src-x) (int16 src-y) ((sequence :format int32) coord-sequence) ))) (defun render-composite (op source mask dest src-x src-y mask-x mask-y dst-x dst-y width height) (let ((display (picture-display source))) (synchronise-picture-state source) (when mask (synchronise-picture-state mask)) (synchronise-picture-state dest) (with-buffer-request (display (extension-opcode display "RENDER")) (data +X-RenderComposite+) (render-op op) ;op (card8 0) ;pad (card16 0) ;pad (resource-id (picture-id source)) (resource-id (if mask (picture-id mask) 0)) (resource-id (picture-id dest)) (int16 src-x) (int16 src-y) (int16 mask-x) (int16 mask-y) (int16 dst-x) (int16 dst-y) (card16 width) (card16 height)))) (def-clx-class (glyph-set (:copier nil) ) (id 0 :type resource-id) (display nil :type (or null display)) (plist nil :type list) ; Extension hook (format)) (defun render-create-glyph-set (format &key glyph-set) (let ((display (picture-format-display format))) (let* ((glyph-set (or glyph-set (make-glyph-set :display display))) (gsid (setf (glyph-set-id glyph-set) (allocate-resource-id display glyph-set 'glyph-set)))) (declare (ignore gsid)) (setf (glyph-set-format glyph-set) format) (with-buffer-request (display (extension-opcode display "RENDER")) (data +X-RenderCreateGlyphSet+) (glyph-set glyph-set) (picture-format format)) glyph-set))) (defun render-reference-glyph-set (existing-glyph-set &key glyph-set) (let ((display (glyph-set-display existing-glyph-set))) (let* ((glyph-set (or glyph-set (make-glyph-set :display display))) (gsid (setf (glyph-set-id glyph-set) (allocate-resource-id display glyph-set 'glyph-set)))) (declare (ignore gsid)) (setf (glyph-set-format glyph-set) (glyph-set-format existing-glyph-set)) (with-buffer-request (display (extension-opcode display "RENDER")) (data +X-RenderReferenceGlyphSet+) (glyph-set glyph-set) (glyph-set existing-glyph-set)) glyph-set))) (defun render-composite-glyphs-8 (dest glyph-set source dest-x dest-y sequence &key (op :over) (alu op) ;for the fun of it (src-x 0) (src-y 0) (mask-format :none) (start 0) (end (length sequence))) (let ((display (picture-display dest))) (ensure-render-initialized display) (synchronise-picture-state dest) (synchronise-picture-state source) (when (stringp sequence) ;; lazy me, but then you should not confuse glyphs with ;; characters anyway. (setf sequence (map 'vector #'char-code sequence))) (with-buffer-request (display (extension-opcode display "RENDER")) (data +X-RenderCompositeGlyphs8+) (render-op alu) (card8 0) (card16 0) ;padding (picture source) (picture dest) ((or (member :none) picture-format) mask-format) (glyph-set glyph-set) (int16 src-x) (int16 src-y) (card8 (- end start)) ;length of glyph elt (card8 0) (card16 0) ;padding (int16 dest-x) (int16 dest-y) ;dx, dy ((sequence :format card8) sequence)))) (defmacro %render-composite-glyphs (opcode type transform display dest glyph-set source dest-x dest-y sequence alu src-x src-y mask-format start end) (let ((size (ecase type (card8 1) (card16 2) (card32 4))) ;; FIXME: the last chunk for CARD8 can be 254. (chunksize (ecase type (card8 252) (card16 254) (card32 254)))) `(multiple-value-bind (nchunks leftover) (floor (- end start) ,chunksize) (let* ((payloadsize (+ (* nchunks (+ 8 (* ,chunksize ,size))) (if (> leftover 0) (+ 8 (* 4 (ceiling (* leftover ,size) 4))) 0))) (request-length (+ 7 (/ payloadsize 4)))) (declare (integer request-length)) (with-buffer-request (,display (extension-opcode ,display "RENDER") :length (* 4 request-length)) (data ,opcode) (length request-length) (render-op ,alu) (card8 0) (card16 0) ;padding (picture ,source) (picture ,dest) ((or (member :none) picture-format) ,mask-format) (glyph-set ,glyph-set) (int16 ,src-x) (int16 ,src-y) (progn (let ((boffset (+ buffer-boffset 28)) (start ,start) (end ,end) (dest-x ,dest-x) (dest-y ,dest-y)) (dotimes (i nchunks) (set-buffer-offset boffset) (put-items (0) (card8 ,chunksize) (card8 0) (card16 0) (int16 dest-x) (int16 dest-y) ((sequence :start start :end (+ start ,chunksize) :format ,type :transform ,transform :appending t) ,sequence)) (setq dest-x 0 dest-y 0) (incf boffset (+ 8 (* ,chunksize ,size))) (incf start ,chunksize)) (when (> leftover 0) (set-buffer-offset boffset) (put-items (0) (card8 leftover) (card8 0) (card16 0) (int16 dest-x) (int16 dest-y) ((sequence :start start :end end :format ,type :transform ,transform :appending t) ,sequence)) ;; padding? (incf boffset (+ 8 (* 4 (ceiling (* leftover ,size) 4))))) (setf (buffer-boffset ,display) boffset)))))))) (defun render-composite-glyphs (dest glyph-set source dest-x dest-y sequence &key (op :over) (alu op) ;for the fun of it (src-x 0) (src-y 0) (mask-format :none) (start 0) (end (length sequence))) ;; xxx do we want to go with some translate function as draw-glyphs? (declare (type array-index start end)) (let ((display (picture-display dest))) (ensure-render-initialized display) (synchronise-picture-state dest) (synchronise-picture-state source) ;; hmm find out the element size (typecase sequence ((array (unsigned-byte 8) (*)) (%render-composite-glyphs +X-RenderCompositeGlyphs8+ card8 nil display dest glyph-set source dest-x dest-y sequence alu src-x src-y mask-format start end)) ((array (unsigned-byte 16) (*)) (%render-composite-glyphs +X-RenderCompositeGlyphs16+ card16 nil display dest glyph-set source dest-x dest-y sequence alu src-x src-y mask-format start end)) ((array (unsigned-byte 32) (*)) (%render-composite-glyphs +X-RenderCompositeGlyphs32+ card32 nil display dest glyph-set source dest-x dest-y sequence alu src-x src-y mask-format start end)) (string (%render-composite-glyphs #.(cond ((<= char-code-limit (expt 2 8)) '+X-RenderCompositeGlyphs8+) ((<= char-code-limit (expt 2 16)) '+X-RenderCompositeGlyphs16+) ((<= char-code-limit (expt 2 32)) '+X-RenderCompositeGlyphs32+) (t (error "Wow!"))) #.(cond ((<= char-code-limit (expt 2 8)) 'card8) ((<= char-code-limit (expt 2 16)) 'card16) ((<= char-code-limit (expt 2 32)) 'card32) (t (error "Wow!"))) #'char-code display dest glyph-set source dest-x dest-y sequence alu src-x src-y mask-format start end)) (t ;; should we bother testing the array element type? (%render-composite-glyphs +X-RenderCompositeGlyphs32+ card32 #'(lambda (elt) (if (characterp elt) (char-code elt) elt)) display dest glyph-set source dest-x dest-y sequence alu src-x src-y mask-format start end))) )) ;; --- idea: Allow data to be an image to avoid unecessary consing? - noss (defun render-add-glyph (glyph-set id &key x-origin y-origin x-advance y-advance data) (let ((display (glyph-set-display glyph-set))) (ensure-render-initialized display) (let* ((w (array-dimension data 1)) (h (array-dimension data 0)) (bitmap-format (display-bitmap-format display)) (unit (bitmap-format-unit bitmap-format)) (byte-lsb-first-p (display-image-lsb-first-p display)) (bit-lsb-first-p (bitmap-format-lsb-first-p bitmap-format))) (let* ((byte-per-line (* 4 (ceiling (* w (picture-format-depth (glyph-set-format glyph-set))) 32))) (request-length (+ 28 (* h byte-per-line)))) (with-buffer-request (display (extension-opcode display "RENDER")) (data +X-RenderAddGlyphs+) (length (ceiling request-length 4)) (glyph-set glyph-set) (card32 1) ;number glyphs (card32 id) ;id (card16 w) (card16 h) (int16 x-origin) (int16 y-origin) (int16 x-advance) (int16 y-advance) (progn (setf (buffer-boffset display) (advance-buffer-offset 28)) (let ((im (create-image :width w :height h :depth 8 :data data))) (write-image-z display im 0 0 w h byte-per-line ;padded bytes per line unit byte-lsb-first-p bit-lsb-first-p)) ))) ))) (defun render-add-glyph-from-picture (glyph-set picture &key x-origin y-origin x-advance y-advance x y width height) ;; untested, the duplication of x-origin seems bogus. ;; Still untested, but these modifications seem to be more likely, (x,y) would be the offset into the picture. ;; and orgin advance would be properties of the defined glyph. (let ((display (glyph-set-display glyph-set))) (with-buffer-request (display (extension-opcode display "RENDER")) (data +X-RenderAddGlyphsFromPicture+) (glyph-set glyph-set) (picture picture) (card16 width) (card16 height) (card16 x-origin) (card16 y-origin) (card16 x-advance) (card16 y-advance) (card16 x) (card16 y)))) ;; untested (defun render-free-glyphs (glyph-set glyphs) "This request removes glyphs from glyph-set. Each glyph must exist in glyph-set (else a Match error results)." (let ((display (glyph-set-display glyph-set))) (with-buffer-request (display (extension-opcode display "RENDER")) (data +X-RenderFreeGlyphs+) (glyph-set glyph-set) ((sequence :format card32) glyphs)))) #|| ;;; -------------------------------------------------------------------------------- ;; testing code: (defun x (op) (let ((dpy (open-display ""))) (render-query-version dpy) (unwind-protect (let* ((win (screen-root (first (display-roots dpy)))) (display dpy) (pf (find-window-picture-format win)) (pm (xlib:create-pixmap :depth (xlib:drawable-depth win) :drawable win :width 1 :height 1)) (pm.p (render-create-picture pm :format pf :repeat :on)) (win.p (render-create-picture win :format pf)) (gs (render-create-glyph-set (first (find-matching-picture-formats dpy :alpha 8 :red-max 0 :green-max 0 :blue-max 0))))) (xlib:clear-area win) (render-fill-rectangle pm.p :src (list #xFFFF 0 0 0) 0 0 100 100) (render-add-glyph gs 18 :data (make-array (list 3 3) :initial-contents '((255 000 000) (000 255 000) (000 000 255)) :element-type '(unsigned-byte 8)) :x-advance 4 :y-advance 0 :x-origin 0 :y-origin 0) (let ((w 50) (h 50)) (let ((data (make-array (list h w) :element-type '(unsigned-byte 8) :initial-element 0))) (dotimes (i w) (dotimes (j h) (setf (aref data i j) (* 3 i)))) (render-add-glyph gs 17 :data data :x-advance (+ w 2) :y-advance 0 :x-origin 0 :y-origin 0))) (render-composite-glyphs-8 win.p gs pm.p 200 330 (vector 17 18 18 17 17 17 17 17 17 17) :alu op ) ;; (display-finish-output dpy) (close-display dpy))))) (defun z (op) (let ((dpy (open-display ""))) (unwind-protect (let* ((win (screen-root (first (display-roots dpy)))) (pic (render-create-picture win)) (fmt (first (find-matching-picture-formats dpy :red-min 8 :green-min 8 :blue-min 8 :alpha-min 8))) (px (xlib:create-pixmap :width 256 :height 256 :depth (picture-format-depth fmt) :drawable win)) (px.pic (render-create-picture px :format fmt)) (px.gc (xlib:create-gcontext :drawable px))) (xlib:clear-area win) ;; (render-fill-rectangle px.pic :src (list #x8000 #x0000 #x8000 #xFFFF) 0 0 256 256) (render-composite :src pic pic px.pic 350 350 350 350 0 0 256 256) ;; (render-fill-rectangle px.pic :over (list #x8000 #x8000 #x8000 #x8000) 0 0 100 100) (render-composite :src px.pic px.pic pic 0 0 0 0 350 350 256 256) (render-fill-rectangle pic op (list #x0 #x0 #x0 #x8000) 200 200 800 800) (display-finish-output dpy)) (close-display dpy)))) ;;; ---------------------------------------------------------------------------------------------------- (defun y (op) (let ((dpy (open-display ""))) (render-query-version dpy) (unwind-protect (let* ((win (screen-root (first (display-roots dpy)))) (pic (render-create-picture win)) (px (xlib:create-pixmap :drawable win :width 256 :height 256 :depth 32)) (px.gc (xlib:create-gcontext :drawable px))) (dotimes (x 256) (dotimes (y 256) (setf (xlib:gcontext-foreground px.gc) (dpb x (byte 8 24) (dpb y (byte 8 16) (dpb y (byte 8 8) y)))) (xlib:draw-point px px.gc x y) )) (xlib:clear-area win) (let ((q (render-create-picture px :format (first (find-matching-picture-formats dpy :depth 32 :alpha 8 :red 8 :green 8 :blue 8)) :component-alpha :on :repeat :off))) (render-composite op q q pic 0 0 0 0 100 100 400 400)) (let () ;;(render-fill-rectangle pic op (list 255 255 255 255) 100 100 200 200) (display-finish-output dpy))) (close-display dpy)))) (defun zz () (let* ((dpy (xlib:open-display "")) (win (screen-root (first (display-roots dpy)))) (pic (render-create-picture win))) (xlib:clear-area win) (setf (picture-clip-mask pic) (list 100 100 200 2000)) (render-fill-rectangle pic :over (list #xFFFF 0 0 #x400) 0 0 2000 2000) (display-finish-output dpy) (close-display dpy))) ||# ;;;; Cursors (defun render-create-cursor (picture &optional (x 0) (y 0)) (let ((display (picture-display picture))) (ensure-render-initialized display) (synchronise-picture-state picture) (let* ((cursor (make-cursor :display display)) (cid (allocate-resource-id display cursor 'cursor))) (setf (cursor-id cursor) cid) (with-buffer-request (display (extension-opcode display "RENDER")) (data +X-RenderCreateCursor+) (resource-id cid) (resource-id (picture-id picture)) (card16 x) (card16 y)) cursor))) ecl-16.1.2/src/clx/xtest.lisp000066400000000000000000000107711266352375300160030ustar00rootroot00000000000000;;; -*- Mode: Lisp; Syntax: Common-Lisp; -*- ;;; ;;; Implementation of the XTest extension as described by ;;; http://www.x.org/docs/Xext/xtest.pdf ;;; ;;; Written by Lionel Flandrin in july ;;; 2008 and placed in the public domain. ;;; ;;; TODO: ;;; * Implement XTestSetVisualIDOfVisual and XTestDiscard ;;; * Add the missing (declare (type ... (defpackage :xtest (:use :common-lisp :xlib) (:import-from :xlib #:data #:card8 #:card8-get #:card16 #:card16-get #:card32 #:card32-get #:extension-opcode #:define-extension #:gcontext #:resource-id #:window-id #:cursor #:make-cursor #:with-buffer-request-and-reply #:with-buffer-request #:display) (:export ;; Constants #:+major-version+ #:+minor-version+ ;; Functions #:set-gc-context-of-gc #:get-version #:compare-cursor #:fake-motion-event #:fake-button-event #:fake-key-event #:grab-control)) (in-package :xtest) (define-extension "XTEST") (defmacro opcode (display) `(extension-opcode ,display "XTEST")) ;;; The version we implement (defconstant +major-version+ 2) (defconstant +minor-version+ 2) (defconstant +none+ 0) (defconstant +current-cursor+ 1) ;;; XTest opcodes (defconstant +get-version+ 0) (defconstant +compare-cursor+ 1) (defconstant +fake-input+ 2) (defconstant +grab-control+ 3) ;;; Fake events (defconstant +fake-key-press+ 2) (defconstant +fake-key-release+ 3) (defconstant +fake-button-press+ 4) (defconstant +fake-button-release+ 5) (defconstant +fake-motion-notify+ 6) ;;; Client operations (defun set-gc-context-of-gc (gcontext gcontext-id) (declare (type gcontext gcontext) (type resource-id gcontext-id)) (setf (gcontext-id gcontext) gcontext-id)) ;;; Server requests (defun get-version (display &optional (major +major-version+) (minor +minor-version+)) "Returns the major and minor version of the server's XTest implementation" (declare (type display display)) (with-buffer-request-and-reply (display (opcode display) nil) ((data +get-version+) (card8 major) (card16 minor)) (values (card8-get 1) (card16-get 8)))) (defun compare-cursor (display window &optional (cursor-id +current-cursor+)) (declare (type display display) (type resource-id cursor-id) (type window window)) (with-buffer-request-and-reply (display (opcode display) nil) ((data +compare-cursor+) (resource-id (window-id window)) (resource-id cursor-id)) (values (card8-get 1)))) (defun fake-motion-event (display x y &key (delay 0) relative (root-window-id 0)) "Move the mouse pointer at coordinates (x, y). If :relative is t, the movement is relative to the pointer's current position" (declare (type display display)) (with-buffer-request (display (opcode display)) (data +fake-input+) (card8 +fake-motion-notify+) (card8 (if relative 1 0)) (pad16 0) (card32 delay) (card32 root-window-id) (pad32 0 0) (card16 x) (card16 y) (pad32 0 0))) (defun fake-button-event (display button pressed &key (delay 0)) "Send a fake button event (button pressed or released) to the server. Most of the time, button 1 is the left one, 2 the middle and 3 the right one but it's not always the case." (declare (type display display)) (with-buffer-request (display (opcode display)) (data +fake-input+) (card8 (if pressed +fake-button-press+ +fake-button-release+)) (card8 button) (pad16 0) (card32 delay) (pad32 0 0 0 0 0 0))) (defun fake-key-event (display keycode pressed &key (delay 0)) "Send a fake key event (key pressed or released) to the server based on its keycode." (declare (type display display)) (with-buffer-request (display (opcode display)) (data +fake-input+) (card8 (if pressed +fake-key-press+ +fake-key-release+)) (card8 keycode) (pad16 0) (card32 delay) (pad32 0 0 0 0 0 0))) (defun grab-control (display grab?) "Make the client grab the server, that is allow it to make requests even when another client grabs the server." (declare (type display display)) (with-buffer-request (display (opcode display)) (data +grab-control+) (card8 (if grab? 1 0)) (pad8 0) (pad16 0))) ;;; Local Variables: ;;; indent-tabs-mode: nil ;;; End: ecl-16.1.2/src/clx/xvidmode.lisp000066400000000000000000000742671266352375300164650ustar00rootroot00000000000000;;; -*- Mode: Lisp; Syntax: Common-Lisp; Package: XLIB; -*- ;;; --------------------------------------------------------------------------- ;;; Title: XFree86 video mode extension ;;; Created: 2003 03 28 15:28 ;;; Author: Iban Hatchondo ;;; --------------------------------------------------------------------------- ;;; (c) copyright 2003 by Iban Hatchondo ;;; ;;; Permission is granted to any individual or institution to use, ;;; copy, modify, and distribute this software, provided that this ;;; complete copyright and permission notice is maintained, intact, in ;;; all copies and supporting documentation. ;;; ;;; 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. ;;; ;;; THIS IS NOT AN X CONSORTIUM STANDARD OR AN X PROJECT TEAM SPECIFICATION ;;; DESCRIPTION ;;; ;;; These functions provide an interface to the server extension ;;; XFree86-VidModeExtension which allows the video modes to be ;;; queried, adjusted dynamically and the mode switching to be ;;; controlled. ;;; [ personal notes ] ;;; ;;; The documentation on this extension is very poor, probably, ;;; because it is not an X standard nor an X project team spec. ;;; Because of that, it need to be tested on some XFree 3.3.6, ;;; and XFree 4.3.x to ensure that all request are correctly ;;; constructed as well as to indentify any obsolete/wrong ;;; functions I made. (in-package :xlib) (export '(mode-info mode-info-dotclock mode-info-hdisplay mode-info-hsyncstart mode-info-hsyncend mode-info-htotal mode-info-hskew mode-info-vdisplay mode-info-vsyncstart mode-info-vsyncend mode-info-vtotal mode-info-flags mode-info-privsize mode-info-private make-mode-info xfree86-vidmode-query-version xfree86-vidmode-set-client-version xfree86-vidmode-get-permissions xfree86-vidmode-mod-mode-line xfree86-vidmode-get-mode-line xfree86-vidmode-get-all-mode-lines xfree86-vidmode-add-mode-line xfree86-vidmode-delete-mode-line xfree86-vidmode-validate-mode-line xfree86-vidmode-get-gamma xfree86-vidmode-set-gamma xfree86-vidmode-get-gamma-ramp xfree86-vidmode-set-gamma-ramp xfree86-vidmode-get-gamma-ramp-size xfree86-vidmode-lock-mode-switch xfree86-vidmode-switch-to-mode xfree86-vidmode-switch-mode xfree86-vidmode-select-next-mode xfree86-vidmode-select-prev-mode xfree86-vidmode-get-monitor xfree86-vidmode-get-viewport xfree86-vidmode-set-viewport xfree86-vidmode-get-dotclocks) :xlib) ;; current version numbers ;; ;; major 0 == uses parameter-to-wire functions in XFree86 libXxf86vm. ;; major 1 == uses parameter-to-wire functions hard-coded in xvidtune client. ;; major 2 == uses new protocol version in XFree86 4.0. (defconstant +xf86vidmode-major-version+ 2) (defconstant +xf86vidmode-minor-version+ 2) ;; requests number. (defconstant +query-version+ 0) (defconstant +get-mode-line+ 1) (defconstant +mod-mode-line+ 2) (defconstant +switch-mode+ 3) (defconstant +get-monitor+ 4) (defconstant +lock-mode-switch+ 5) (defconstant +get-all-mode-lines+ 6) (defconstant +add-mode-line+ 7) (defconstant +delete-mode-line+ 8) (defconstant +validate-mode-line+ 9) (defconstant +switch-to-mode+ 10) (defconstant +get-viewport+ 11) (defconstant +set-viewport+ 12) ;; new for version 2.x of this extension. (defconstant +get-dot-clocks+ 13) (defconstant +set-client-version+ 14) (defconstant +set-gamma+ 15) (defconstant +get-gamma+ 16) (defconstant +get-gamma-ramp+ 17) (defconstant +set-gamma-ramp+ 18) (defconstant +get-gamma-ramp-size+ 19) (defconstant +get-permisions+ 20) (define-extension "XFree86-VidModeExtension" :events (:xfree86-vidmode-notify) :errors (xf86-vidmode-bad-clock xf86-vidmode-bad-htimings xf86-vidmode-bad-vtimings xf86-vidmode-mode-unsuitable xf86-vidmode-extension-disabled xf86-vidmode-client-not-local xf86-vidmode-zoom-locked)) (define-condition xf86-vidmode-bad-clock (request-error) ()) (define-condition xf86-vidmode-bad-htimings (request-error) ()) (define-condition xf86-vidmode-bad-vtimings (request-error) ()) (define-condition xf86-vidmode-mode-unsuitable (request-error) ()) (define-condition xf86-vidmode-extension-disabled (request-error) ()) (define-condition xf86-vidmode-client-not-local (request-error) ()) (define-condition xf86-vidmode-zoom-locked (request-error) ()) (define-error xf86-vidmode-bad-clock decode-core-error) (define-error xf86-vidmode-bad-htimings decode-core-error) (define-error xf86-vidmode-bad-vtimings decode-core-error) (define-error xf86-vidmode-mode-unsuitable decode-core-error) (define-error xf86-vidmode-extension-disabled decode-core-error) (define-error xf86-vidmode-client-not-local decode-core-error) (define-error xf86-vidmode-zoom-locked decode-core-error) (declare-event :XFree86-VidMode-notify (card16 sequence) (window (window event-window)) ; the root window of event screen (int16 state) ; what happend (int16 kind) ; what happend (boolean forced-p) ; extents of a new region ((or null card32) time)) ; event timestamp (defstruct mode-info (dotclock 0 :type card32) (hdisplay 0 :type card16) (hsyncstart 0 :type card16) (hsyncend 0 :type card16) (htotal 0 :type card16) (hskew 0 :type card32) (vdisplay 0 :type card16) (vsyncstart 0 :type card16) (vsyncend 0 :type card16) (vtotal 0 :type card16) (flags 0 :type card32) (privsize 0 :type card32) (private nil :type sequence)) (defmacro vidmode-opcode (display) `(extension-opcode ,display "XFree86-VidModeExtension")) (declaim (inline screen-position)) (defun screen-position (screen display) (declare (type display display) (type screen screen)) (declare (clx-values position)) (let ((position (position screen (xlib:display-roots display)))) (if (not (numberp position)) (error "screen ~A not found in display ~A" screen display) position))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;; ;;;; ;;;; public XFree86-VidMode Extension routines ;;;; ;;;; ;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (defun xfree86-vidmode-query-version (display) "Determine the version of the extension built into the server. return two values major-version and minor-version in that order." (declare (type display display)) (with-buffer-request-and-reply (display (vidmode-opcode display) nil :sizes 16) ((data +query-version+)) (let ((major (card16-get 8)) (minor (card16-get 10))) (declare (type card16 major minor)) (when (>= major 2) (XFree86-VidMode-set-client-version display)) (values major minor)))) (defun xfree86-vidmode-set-client-version (display) (declare (type display display)) (with-buffer-request (display (vidmode-opcode display)) (data +set-client-version+) (card16 +xf86vidmode-major-version+) (card16 +xf86vidmode-minor-version+))) (defun xfree86-vidmode-get-permissions (dpy screen) (declare (type display dpy) (type screen screen)) (with-buffer-request-and-reply (dpy (vidmode-opcode dpy) nil :sizes (8 16 32)) ((data +get-permisions+) (card16 (screen-position screen dpy)) (card16 0)) (values (card32-get 8)))) (defun xfree86-vidmode-mod-mode-line (display screen mode-line) "Change the settings of the current video mode provided the requested settings are valid (e.g. they don't exceed the capabilities of the monitor)." (declare (type display display) (type screen screen)) (let* ((major (xfree86-vidmode-query-version display)) (v (mode-info->v-card16 mode-line major))) (declare (type card16 major) (type simple-vector v)) (with-buffer-request (display (vidmode-opcode display)) (data +mod-mode-line+) (card32 (screen-position screen display)) ((sequence :format card16 :start 2) v)))) (defun xfree86-vidmode-get-mode-line (display screen) "Query the settings for the currently selected video mode. return a mode-info structure fields with the server answer. If there are any server private values (currently only applicable to the S3 server) the function will store it into the returned structure." (declare (clx-values mode-info) (type display display) (type screen screen)) (let ((major (xfree86-vidmode-query-version display)) (offset 8)) (declare (type fixnum offset) (type card16 major)) (with-buffer-request-and-reply (display (vidmode-opcode display) nil :sizes (8 16 32)) ((data +get-mode-line+) (card16 (screen-position screen display)) (card16 0)) (let ((mode-info (make-mode-info :dotclock (card32-get offset) :hdisplay (card16-get (incf offset 4)) :hsyncstart (card16-get (incf offset 2)) :hsyncend (card16-get (incf offset 2)) :htotal (card16-get (incf offset 2)) :hskew (if (< major 2) 0 (card16-get (incf offset 2))) :vdisplay (card16-get (incf offset 2)) :vsyncstart (card16-get (incf offset 2)) :vsyncend (card16-get (incf offset 2)) :vtotal (card16-get (incf offset 2)) :flags (card32-get (incf offset (if (< major 2) 2 4))))) (size (card32-get (incf offset (if (< major 2) 4 16))))) (declare (type card32 size)) (incf offset 4) (setf (mode-info-privsize mode-info) size (mode-info-private mode-info) (sequence-get :format card32 :index offset :length size :result-type 'list)) mode-info)))) (defun xfree86-vidmode-get-all-mode-lines (dpy screen) "Returns a list containing all video modes (as mode-info structure). The first element of the list corresponds to the current video mode." (declare (type display dpy) (type screen screen)) (multiple-value-bind (major minor) (xfree86-vidmode-query-version dpy) (declare (type card16 major minor)) (with-buffer-request-and-reply (dpy (vidmode-opcode dpy) nil :sizes (8 16 32)) ((data +get-all-mode-lines+) (card16 (screen-position screen dpy))) (values ;; Note: There was a bug in the protocol implementation in versions ;; 0.x with x < 8 (the .private field wasn't being passed over the wire). ;; Check the server's version, and accept the old format if appropriate. (loop with bug-p = (and (= major 0) (< minor 8)) with offset of-type fixnum = 32 for i of-type card32 from 0 below (or (card32-get 8) 0) collect (let ((mode-info (make-mode-info :dotclock (card32-get offset) :hdisplay (card16-get (incf offset 4)) :hsyncstart (card16-get (incf offset 2)) :hsyncend (card16-get (incf offset 2)) :htotal (card16-get (incf offset 2)) :hskew (if (< major 2) 0 (card32-get (incf offset 2))) :vdisplay (card16-get (incf offset 4)) :vsyncstart (card16-get (incf offset 2)) :vsyncend (card16-get (incf offset 2)) :vtotal (card16-get (incf offset 2)) :flags (card32-get (incf offset (if (< major 2) 2 6))))) (size (card32-get (incf offset (if (< major 2) 4 16))))) (declare (type card32 size)) (incf offset 4) (when bug-p (setf size 0)) (setf (mode-info-privsize mode-info) size (mode-info-private mode-info) (sequence-get :format card32 :index offset :length size :result-type 'list)) (incf offset (* 4 size)) mode-info)))))) (defun xfree86-vidmode-add-mode-line (dpy scr new &key (after (make-mode-info))) (declare (type display dpy) (type screen scr)) (let* ((private (mode-info-private new)) (privsize (mode-info-privsize new)) (major (xfree86-vidmode-query-version dpy)) (i (if (< major 2) 14 22)) (v (make-array (- (+ (* 2 i) (* 2 privsize)) 2) :initial-element 0))) (declare (type card32 privsize) (type fixnum i) (type card16 major) (type simple-vector v)) (mode-info->v-card16 new major :encode-private nil :data v) (mode-info->v-card16 after major :encode-private nil :data v :index i) (setf i (- (* 2 i) 2)) ;; strore private info (sequence card32) according clx bytes order. (loop for card of-type card32 in private do (multiple-value-bind (w1 w2) (__card32->card16__ card) (setf (svref v (incf i)) w1 (svref v (incf i)) w2))) (with-buffer-request (dpy (vidmode-opcode dpy)) (data +add-mode-line+) (card32 (screen-position scr dpy)) ((sequence :format card16) v)))) (defun xfree86-vidmode-delete-mode-line (dpy scr mode-info) "Delete mode argument. The specified mode must match an existing mode. To be considered a match, all of the fields of the given mode-info structure must match, except the privsize and private fields. If the mode to be deleted is the current mode, a mode switch to the next mode will occur first. The last remaining mode can not be deleted." (declare (type display dpy) (type screen scr)) (let* ((major (xfree86-vidmode-query-version dpy)) (v (mode-info->v-card16 mode-info major))) (declare (type card16 major) (type simple-vector v)) (with-buffer-request (dpy (vidmode-opcode dpy)) (data +delete-mode-line+) (card32 (screen-position scr dpy)) ((sequence :format card16) v)))) (defconstant +mode-status+ '#(:MODE_BAD ; unspecified reason :MODE_ERROR ; error condition :MODE_OK ; Mode OK :MODE_HSYNC ; hsync out of range :MODE_VSYNC ; vsync out of range :MODE_H_ILLEGAL ; mode has illegal horizontal timings :MODE_V_ILLEGAL ; mode has illegal horizontal timings :MODE_BAD_WIDTH ; requires an unsupported linepitch :MODE_NO_MODE ; no mode with a maching name :MODE_NO_INTERLACE ; interlaced mode not supported :MODE_NO_DBLESCAN ; doublescan mode not supported :MODE_NO_VSCAN ; multiscan mode not supported :MODE_MEM ; insufficient video memory :MODE_VIRTUAL_X ; mode width too large for specified virtual size :MODE_VIRTUAL_Y ; mode height too large for specified virtual size :MODE_MEM_VIRT ; insufficient video memory given virtual size :MODE_NOCLOCK ; no fixed clock available :MODE_CLOCK_HIGH ; clock required is too high :MODE_CLOCK_LOW ; clock required is too low :MODE_CLOCK_RANGE ; clock/mode isn't in a ClockRange :MODE_BAD_HVALUE ; horizontal timing was out of range :MODE_BAD_VVALUE ; vertical timing was out of range :MODE_BAD_VSCAN ; VScan value out of range :MODE_HSYNC_NARROW ; horizontal sync too narrow :MODE_HSYNC_WIDE ; horizontal sync too wide :MODE_HBLANK_NARROW ; horizontal blanking too narrow :MODE_HBLANK_WIDE ; horizontal blanking too wide :MODE_VSYNC_NARROW ; vertical sync too narrow :MODE_VSYNC_WIDE ; vertical sync too wide :MODE_VBLANK_NARROW ; vertical blanking too narrow :MODE_VBLANK_WIDE ; vertical blanking too wide :MODE_PANEL ; exceeds panel dimensions :MODE_INTERLACE_WIDTH ; width too large for interlaced mode :MODE_ONE_WIDTH ; only one width is supported :MODE_ONE_HEIGHT ; only one height is supported :MODE_ONE_SIZE ; only one resolution is supported )) (defun decode-status-mode (status) (declare (type int32 status)) (svref +mode-status+ (+ status 2))) (defun xfree86-vidmode-validate-mode-line (dpy scr mode-info) "Checked the validity of a mode-info argument. If the specified mode can be used by the server (i.e. meets all the constraints placed upon a mode by the combination of the server, card, and monitor) the function returns :mode_ok otherwise it returns a keyword indicating the reason why the mode is invalid." (declare (type display dpy) (type screen scr)) (let* ((major (xfree86-vidmode-query-version dpy)) (v (mode-info->v-card16 mode-info major))) (declare (type card16 major) (type simple-vector v)) (with-buffer-request-and-reply (dpy (vidmode-opcode dpy) nil :sizes (8 16 32)) ((data +validate-mode-line+) (card32 (screen-position scr dpy)) ((sequence :format card16) v)) (let ((status (integer-get 8))) (declare (type int32 status)) (when status (decode-status-mode status)))))) (defun xfree86-vidmode-get-gamma (display screen) (declare (type display display) (type screen screen)) (with-buffer-request-and-reply (display (vidmode-opcode display) nil :sizes (8 16 32)) ((data +get-gamma+) (card16 (screen-position screen display)) (card16 0) (card32 0) (card32 0) (card32 0) (card32 0) (card32 0) (card32 0)) (values (/ (the card32 (or (card32-get 8) 0)) 10000.0) (/ (the card32 (or (card32-get 12) 0)) 10000.0) (/ (the card32 (or (card32-get 16) 0)) 10000.0)))) (defun xfree86-vidmode-set-gamma (dpy scr &key (red 1.0) (green 1.0) (blue 1.0)) (declare (type display dpy) (type screen scr) (type (single-float 0.100f0 10.000f0) red green blue)) (with-buffer-request (dpy (vidmode-opcode dpy)) (data +set-gamma+) (card16 (screen-position scr dpy)) (card16 0) (card32 (truncate (* red 10000))) (card32 (truncate (* green 10000))) (card32 (truncate (* blue 10000))) (card32 0) (card32 0) (card32 0))) (defun xfree86-vidmode-get-gamma-ramp (dpy scr size) (declare (type display dpy) (type screen scr) (type card16 size)) (with-buffer-request-and-reply (dpy (vidmode-opcode dpy) nil :sizes (8 16 32)) ((data +get-gamma-ramp+) (card16 (screen-position scr dpy)) (card16 size)) (let ((rep-size (* (the card16 (or (card16-get 8) 0)) 2))) (declare (type fixnum rep-size)) (unless (zerop rep-size) (let* ((off1 (+ 32 rep-size (* 2 (mod rep-size 2)))) (off2 (+ off1 rep-size (* 2 (mod rep-size 2))))) (declare (type fixnum off1 off2)) (values (sequence-get :format card16 :length (card16-get 8) :index 32 :result-type 'list) (sequence-get :format card16 :length (card16-get 8) :index off1 :result-type 'list) (sequence-get :format card16 :length (card16-get 8) :index off2 :result-type 'list))))))) (defun xfree86-vidmode-set-gamma-ramp (dpy scr size &key red green blue) (declare (type (or null simple-vector) red green blue) (type card16 size) (type display dpy) (type screen scr)) (with-buffer-request (dpy (vidmode-opcode dpy)) (data +set-gamma-ramp+) (card16 (screen-position scr dpy)) (card16 size) ((sequence :format card16) (if (zerop (mod size 2)) (concatenate 'vector red green blue) (concatenate 'vector red '#(0) green '#(0) blue '#(0)))))) (defun xfree86-vidmode-get-gamma-ramp-size (dpy screen) (declare (type display dpy) (type screen screen)) (with-buffer-request-and-reply (dpy (vidmode-opcode dpy) nil :sizes (8 16 32)) ((data +get-gamma-ramp-size+) (card16 (screen-position screen dpy)) (card16 0)) (card16-get 8))) (defun xfree86-vidmode-lock-mode-switch (display screen lock-p) "Allow or disallow mode switching whether the request to switch modes comes from a call to the mode switching functions or from one of the mode switch key sequences (e.g. Ctrl-Alt-+ Ctrl-Alt--)." (declare (type display display) (type screen screen) (type boolean lock-p)) (with-buffer-request (display (vidmode-opcode display)) (data +lock-mode-switch+) (card16 (screen-position screen display)) (card16 (if lock-p 1 0)))) (defun xfree86-vidmode-switch-to-mode (display screen mode-info) "Switch directly to the specified mode. The specified mode must match an existing mode. Matching is as specified in the description of the xf86-vidmode-delete-mode-line function." (declare (type display display) (type screen screen)) (multiple-value-bind (major minor) (xfree86-vidmode-query-version display) (declare (type card16 major minor)) ;; Note: There was a bug in the protocol implementation in versions ;; 0.x with x < 8 (the .private field wasn't being passed over the wire). ;; Check the server's version, and accept the old format if appropriate. (let ((bug-p (and (= major 0) (< minor 8))) (privsize (mode-info-privsize mode-info))) (declare (type boolean bug-p)) (and bug-p (setf (mode-info-privsize mode-info) 0)) (let ((v (mode-info->v-card16 mode-info major :encode-private bug-p))) (declare (type simple-vector v)) (and bug-p (setf (mode-info-privsize mode-info) privsize)) (with-buffer-request (display (vidmode-opcode display)) (data +switch-to-mode+) (card32 (screen-position screen display)) ((sequence :format card16) v)))))) (defun xfree86-vidmode-switch-mode (display screen zoom) "Change the video mode to next (or previous) video mode, depending of zoom sign. If positive, switch to next mode, else switch to prev mode." (declare (type display display) (type screen screen) (type card16 zoom)) (with-buffer-request (display (vidmode-opcode display)) (data +switch-mode+) (card16 (screen-position screen display)) (card16 zoom))) (defun xfree86-vidmode-select-next-mode (display screen) "Change the video mode to next video mode" (declare (type display display) (type screen screen)) (with-buffer-request (display (vidmode-opcode display)) (data +switch-mode+) (card16 (screen-position screen display)) (card16 1))) (defun xfree86-vidmode-select-prev-mode (display screen) "Change the video mode to previous video mode" (declare (type display display) (type screen screen)) (with-buffer-request (display (vidmode-opcode display)) (data +switch-mode+) (card16 (screen-position screen display)) (card16 #xFFFF))) (defun xfree86-vidmode-get-monitor (dpy screen) "Information known to the server about the monitor is returned. Multiple value return: hsync (list of hi, low, ...) vsync (list of hi, low, ...) vendor name model name The hi and low values will be equal if a discreate value was given in the XF86Config file." (declare (type display dpy) (type screen screen)) (with-buffer-request-and-reply (dpy (vidmode-opcode dpy) nil :sizes (8 16 32)) ((data +get-monitor+) (card16 (screen-position screen dpy)) (card16 0)) (let* ((vendor-name-length (card8-get 8)) (model-name-length (card8-get 9)) (pad (- 4 (mod vendor-name-length 4))) (nhsync (card8-get 10)) (nvsync (card8-get 11)) (vindex (+ 32 (* 4 (+ nhsync nvsync)))) (mindex (+ vindex vendor-name-length pad)) (hsync (sequence-get :length nhsync :index 32 :result-type 'list)) (vsync (sequence-get :length nvsync :index (+ 32 (* nhsync 4)) :result-type 'list))) (declare (type card8 nhsync nvsync vendor-name-length model-name-length) (type fixnum pad vindex mindex)) (values (loop for i of-type card32 in hsync collect (/ (ldb (byte 16 0) i) 100.) collect (/ (ldb (byte 32 16) i) 100.)) (loop for i of-type card32 in vsync collect (/ (ldb (byte 16 0) i) 100.) collect (/ (ldb (byte 32 16) i) 100.)) (string-get vendor-name-length vindex) (string-get model-name-length mindex))))) (defun xfree86-vidmode-get-viewport (dpy screen) "Query the location of the upper left corner of the viewport into the virtual screen. The upper left coordinates will be returned as a multiple value." (declare (type display dpy) (type screen screen)) (multiple-value-bind (major minor) (xfree86-vidmode-query-version dpy) (declare (type card16 major minor)) ;; Note: There was a bug in the protocol implementation in versions ;; 0.x with x < 8 (no reply was sent, so the client would hang) ;; Check the server's version, and don't wait for a reply with older ;; versions. (when (and (= major 0) (< minor 8)) (format cl:*error-output* "running an old version ~a ~a~%" major minor) (return-from xfree86-vidmode-get-viewport nil)) (with-buffer-request-and-reply (dpy (vidmode-opcode dpy) nil :sizes (8 16 32)) ((data +get-viewport+) (card16 (screen-position screen dpy)) (card16 0)) (values (card32-get 8) (card32-get 12))))) (defun xfree86-vidmode-set-viewport (dpy screen &key (x 0) (y 0)) "Set upper left corner of the viewport into the virtual screen to the x and y keyword parameters value (zero will be theire default value)." (declare (type display dpy) (type screen screen) (type card32 x y)) (with-buffer-request (dpy (vidmode-opcode dpy)) (data +set-viewport+) (card16 (screen-position screen dpy)) (card16 0) (card32 x) (card32 y))) (defun xfree86-vidmode-get-dotclocks (dpy screen) "Returns as a multiple value return the server dotclock informations: flags maxclocks clock list" (declare (type display dpy) (type screen screen)) (with-buffer-request-and-reply (dpy (vidmode-opcode dpy) nil :sizes (8 16 32)) ((data +get-dot-clocks+) (card16 (screen-position screen dpy)) (card16 0)) (values (card32-get 8) ; flags (card32-get 16) ; max clocks (sequence-get :length (card32-get 12) :format card32 :index 32 :result-type 'list)))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;; ;;;; ;;;; private utility routines ;;;; ;;;; ;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (defun mode-info->v-card16 (mode-info major &key (encode-private t) (index 0) data) (declare (type integer index) (type card16 major) (type boolean encode-private) (type (or null simple-vector) data)) (let ((dotclock (mode-info-dotclock mode-info)) (hdisplay (mode-info-hdisplay mode-info)) (hsyncstart (mode-info-hsyncstart mode-info)) (hsyncend (mode-info-hsyncend mode-info)) (htotal (mode-info-htotal mode-info)) (hskew (mode-info-hskew mode-info)) (vdisplay (mode-info-vdisplay mode-info)) (vsyncstart (mode-info-vsyncstart mode-info)) (vsyncend (mode-info-vsyncend mode-info)) (vtotal (mode-info-vtotal mode-info)) (flags (mode-info-flags mode-info)) (privsize (mode-info-privsize mode-info)) (private (mode-info-private mode-info))) (declare (type card16 hdisplay hsyncstart hsyncend htotal hskew) (type card16 vdisplay vsyncstart vsyncend vtotal) (type card32 dotclock flags privsize) (type (or null sequence) private)) (let* ((size (+ (if (< major 2) 14 22) (* privsize 2))) (v (or data (make-array size :initial-element 0)))) (declare (type fixnum size) (type simple-vector v)) ;; store dotclock (card32) according clx bytes order. (multiple-value-bind (w1 w2) (__card32->card16__ dotclock) (setf (svref v index) w1 (svref v (incf index)) w2)) (setf (svref v (incf index)) hdisplay (svref v (incf index)) hsyncstart (svref v (incf index)) hsyncend (svref v (incf index)) htotal) (unless (< major 2) (setf (svref v (incf index)) hskew)) (setf (svref v (incf index)) vdisplay (svref v (incf index)) vsyncstart (svref v (incf index)) vsyncend (svref v (incf index)) vtotal) (unless (< major 2) (incf index)) ;; strore flags (card32) according clx bytes order. (multiple-value-bind (w1 w2) (__card32->card16__ flags) (setf (svref v (incf index)) w1 (svref v (incf index)) w2)) ;; strore privsize (card32) according clx bytes order. (multiple-value-bind (w1 w2) (__card32->card16__ privsize) (setf (svref v (incf index)) w1 (svref v (incf index)) w2)) ;; reserverd byte32 1 2 3 (unless (< major 2) (incf index 6)) ;; strore private info (sequence card32) according clx bytes order. (when encode-private (loop for i of-type int32 in private do (multiple-value-bind (w1 w2) (__card32->card16__ i) (setf (svref v (incf index)) w1 (svref v (incf index)) w2)))) v))) (declaim (inline __card32->card16__)) (defun __card32->card16__ (i) (declare (type card32 i)) #+clx-little-endian (progn (values (ldb (byte 16 0) i) (ldb (byte 32 16) i))) #-clx-little-endian (progn (values (ldb (byte 32 16) i) (ldb (byte 16 0) i)))) ecl-16.1.2/src/cmp/000077500000000000000000000000001266352375300137265ustar00rootroot00000000000000ecl-16.1.2/src/cmp/cmparray.lsp000066400000000000000000000247711266352375300162770ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: C -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; CMPARRAY. Optimizations related to arrays ;;;; Copyright (c) 2008. Juan Jose Garcia-Ripol ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. (in-package "COMPILER") (defun valid-array-index-p (x) (typep x 'ext:array-index)) ;;; ;;; MAKE-ARRAY ;;; (defun guess-array-element-type (element-type) (if (and (setf element-type (extract-constant-value element-type)) (known-type-p element-type)) (upgraded-array-element-type element-type) '*)) (defun guess-array-dimensions-type (orig-dimensions &aux dimensions) (and (consp orig-dimensions) (eq (first dimensions) 'LIST) (let ((l (list-length orig-dimensions))) (when (and l (< -1 l array-rank-limit)) (return-from guess-array-dimensions-type (make-list (1- l) :initial-element '*))))) (let ((dimensions (extract-constant-value orig-dimensions :failed))) (cond ((eq dimensions ':failed) '*) ((valid-array-index-p dimensions) (list dimensions)) ((and (listp dimensions) (let ((rank (list-length dimensions))) (or (numberp rank) (< -1 rank array-rank-limit) (every #'valid-array-index dimensions)))) dimensions) (t (cmpwarn "The first argument to MAKE-ARRAY~%~A~%is not a valid set of dimensions" orig-dimensions) '*)))) (define-compiler-macro make-array (&whole form dimensions &key (element-type t) (initial-element nil initial-element-supplied-p) (initial-contents nil initial-contents-supplied-p) adjustable fill-pointer displaced-to (displaced-index-offset 0) &environment env) ;; This optimization is always done unless we provide content. There ;; is no speed, debug or space reason not to do it, unless the user ;; specifies not to inline MAKE-ARRAY, but in that case the compiler ;; macro should not be used. (let* ((dimensions-type (guess-array-dimensions-type dimensions)) (guessed-element-type (guess-array-element-type element-type))) (unless initial-contents-supplied-p ;; If the type is known and we can assume it will not change, we ;; replace it with the upgraded form. (unless (eq guessed-element-type '*) (setf element-type `',guessed-element-type)) ;; Now we choose between making a vector or making a general array. ;; It only saves some time, since MAKE-PURE-ARRAY will call MAKE-VECTOR ;; if a one-dimensional array is to be created. (let ((function 'si::make-pure-array)) (when (and (listp dimensions-type) (null (rest dimensions-type)) (integerp (first dimensions-type))) (setf function 'si::make-vector dimensions (first dimensions-type))) (setf form `(,function ,element-type ,dimensions ,adjustable ,fill-pointer ,displaced-to ,displaced-index-offset))) ;; Then we may fill the array with a given value (when initial-element-supplied-p (setf form `(si::fill-array-with-elt ,form ,initial-element 0 nil))) (setf form `(truly-the (array ,guessed-element-type ,dimensions-type) ,form)))) form) ;;; ;;; VECTOR-PUSH and VECTOR-PUSH-EXTEND ;;; (defun expand-vector-push (whole env extend) (declare (si::c-local)) (let* ((args (rest whole))) (with-clean-symbols (value vector index dimension) (unless (or (eq (first args) 'value) ; No infinite recursion (not (policy-open-code-aref/aset))) (setf whole `(let* ((value ,(car args)) (vector ,(second args))) (declare (:read-only value vector) (optimize (safety 0))) (optional-type-assertion vector vector) (let ((index (fill-pointer vector)) (dimension (array-total-size vector))) (declare (fixnum index dimension) (:read-only index dimension)) (cond ((< index dimension) (sys::fill-pointer-set vector (truly-the fixnum (+ 1 index))) (sys::aset vector index value) index) (t ,(if extend `(vector-push-extend value vector ,@(cddr args)) nil))))))))) whole) (define-compiler-macro vector-push (&whole whole &rest args &environment env) (expand-vector-push whole env nil)) (define-compiler-macro vector-push-extend (&whole whole &rest args &environment env) (expand-vector-push whole env t)) ;;; ;;; AREF/ASET ;;; (define-compiler-macro aref (&whole form array &rest indices &environment env) (if (policy-open-code-aref/aset env) (expand-aref array indices env) form)) (defun expand-aref (array indices env) (with-clean-symbols (%array) `(let ((%array ,array)) (declare (:read-only %array) (optimize (safety 0))) (row-major-aref %array ,(expand-row-major-index '%array indices env))))) (define-compiler-macro si::aset (&whole form array &rest indices-and-value &environment env) (cond ((null indices-and-value) (cmpwarn "Too few arguments to SI::ASET form~%~4I~A" form) form) ((policy-open-code-aref/aset env) (let* ((indices (butlast indices-and-value)) (value (first (last indices-and-value)))) (expand-aset array indices value env))) (t form))) (defun expand-aset (array indices value env) (ext:with-unique-names (%array) `(let* ((,%array ,array)) (declare (:read-only ,%array) (optimize (safety 0))) (si::row-major-aset ,%array ,(expand-row-major-index %array indices env) ,value)))) (define-compiler-macro array-row-major-index (&whole form array &rest indices &environment env) (if (policy-open-code-aref/aset env) (with-clean-symbols (%array) `(let ((%array ,array)) (declare (:read-only %array) (optimize (safety 0))) ,(expand-row-major-index '%array indices env))) form)) (defun expand-zero-dim-index-check (a env) (if (policy-type-assertions env) `(progn (optional-type-assertion ,a array) (check-expected-rank ,a 0) 0) 0)) (defun expand-vector-index-check (a index env) (flet ((expansion (a index) `(progn (optional-type-assertion ,a vector) (check-vector-in-bounds ,a ,index) ,index))) (if (policy-type-assertions env) (with-clean-symbols (%array-index) `(let ((%array-index ,index)) (declare (:read-only %array-index)) ,(expansion a '%array-index))) index))) (defun expand-row-major-index (a indices env) (when (null indices) (return-from expand-row-major-index (expand-zero-dim-index-check a env))) (when (null (rest indices)) (return-from expand-row-major-index (expand-vector-index-check a (first indices) env))) (let* ((expected-rank (length indices)) (check (policy-array-bounds-check env)) (dims (loop for i from 0 for index in indices collect `(,(gentemp "DIM") (array-dimension-fast ,a ,i)))) (dim-names (mapcar #'first dims))) (with-clean-symbols (%ndx-var %output-var %dim-var) `(let* (,@dims (%output-var 0)) (declare (type ext:array-index %output-var ,@dim-names) (ignorable ,@dim-names)) ,@(when (policy-type-assertions env) `((optional-type-assertion ,a array) (check-expected-rank ,a ,expected-rank))) ,@(loop for i from 0 for l in indices for index in indices for dim-var in dim-names when (plusp i) collect `(setf %output-var (truly-the ext:array-index (* %output-var ,dim-var))) collect `(let ((%ndx-var ,index)) (declare (ext:array-index %ndx-var)) ,(and check `(check-index-in-bounds ,a %ndx-var ,dim-var)) (setf %output-var (truly-the ext:array-index (+ %output-var %ndx-var))))) %output-var)))) ;(trace c::expand-row-major-index c::expand-aset c::expand-aref) (defmacro check-expected-rank (a expected-rank) `(c-inline (,a ,expected-rank) (:object :fixnum) :void "if (ecl_unlikely((#0)->array.rank != (#1))) FEwrong_dimensions(#0,#1);" :one-liner nil)) (defmacro check-index-in-bounds (array index limit) `(c-inline (,array ,index ,limit) (:object :fixnum :fixnum) :void "if (ecl_unlikely((#1)>=(#2))) FEwrong_index(ECL_NIL,#0,-1,ecl_make_fixnum(#1),#2);" :one-liner nil)) (defmacro check-vector-in-bounds (vector index) `(c-inline (,vector ,index) (:object :fixnum) :void "if (ecl_unlikely((#1)>=(#0)->vector.dim)) FEwrong_index(ECL_NIL,#0,-1,ecl_make_fixnum(#1),(#0)->vector.dim);" :one-liner nil)) (defconstant +array-dimension-accessor+ '#.(loop for i from 0 below array-rank-limit collect (format nil "(#0)->array.dims[~D]" i))) (defun array-dimension-accessor (array n) (let ((tails #.(apply 'vector (loop for i from 0 below array-rank-limit for c-code = (format nil "(#0)->array.dims[~D]" i) collect `((:object) :fixnum ,c-code :one-liner t :side-effects nil))))) `(c-inline (,array) ,@(aref tails n)))) (defmacro array-dimension-fast (array n) (if (typep n '(integer 0 #.(1- array-rank-limit))) (array-dimension-accessor array n) (error "In macro ARRAY-DIMENSION-FAST, the index is not a constant integer: ~A" n))) ecl-16.1.2/src/cmp/cmpbind.lsp000066400000000000000000000071311266352375300160640ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: C -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; CMPBIND Variable Binding. ;;;; ;;;; Copyright (c) 1990, Giuseppe Attardi. ;;;; ;;;; This file is part of ECoLisp, herein referred to as ECL. ;;;; ;;;; ECL is free software; you can redistribute it and/or modify it under ;;;; the terms of the GNU LIBRARY GENERAL PUBLIC LICENSE as published by ;;;; the Free Software Foundation; either version 2 of the License, or ;;;; (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. (in-package "COMPILER") ;;; bind must be called for each variable in a lambda or let, once the value ;;; to be bound has been placed in loc. ;;; bind takes care of setting var-loc. (defun bind (loc var) ;; loc can be either (LCL n), 'VA-ARGS, (KEYVARS n), (CAR n), ;; a constant, or (VAR var) from a let binding. ; ccb (declare (type var var)) (case (var-kind var) (CLOSURE (let ((var-loc (var-loc var))) (unless (typep var-loc 'fixnum) ;; first binding: assign location (setq var-loc (next-env)) (setf (var-loc var) var-loc)) (when (zerop var-loc) (wt-nl "env" *env-lvl* " = ECL_NIL;")) (wt-nl "CLV" var-loc " = env" *env-lvl* " = CONS(") (wt-coerce-loc :object loc) (wt ",env" *env-lvl* ");") (wt-comment (var-name var)))) (LEXICAL (let ((var-loc (var-loc var))) (unless (consp var-loc) ;; first binding: assign location (setq var-loc (next-lex)) (setf (var-loc var) var-loc)) (wt-nl) (wt-lex var-loc) (wt " = ") (wt-coerce-loc :object loc) (wt ";")) (wt-comment (var-name var))) ((SPECIAL GLOBAL) (bds-bind loc var)) (t (cond ((not (eq (var-loc var) 'OBJECT)) ;; already has location (e.g. optional in lambda list) ;; check they are not the same (unless (equal (var-loc var) loc) (wt-nl var " = ") (wt-coerce-loc (var-rep-type var) loc) (wt ";"))) ((and (consp loc) (eql (car loc) 'LCL)) ;; set location for lambda list requireds (setf (var-loc var) loc)) (t (baboon))) ))) ;;; Used by let*, defmacro and lambda's &aux, &optional, &rest, &keyword (defun bind-init (form var) (let ((kind (var-kind var))) (if (member kind '(CLOSURE LEXICAL SPECIAL GLOBAL)) ;; Binding these variables is complicated and involves lexical ;; environments, global environments, etc. If we use `(BIND var) ;; as destination, BIND might receive the wrong environment. (let* ((*inline-blocks* 0) (*temp* *temp*) (locs (coerce-locs (inline-args (list form))))) (bind (first locs) var) (close-inline-blocks) ;; Notice that we do not need to update *UNWIND-EXIT* ;; because BIND does it for us. ) ;; The simple case of a variable which is local to a function. (let ((*destination* `(BIND ,var))) (c2expr* form))))) (defun bds-bind (loc var) ;; Optimize the case (let ((*special-var* *special-var*)) ...) (cond ((and (var-p loc) (member (var-kind loc) '(global special)) (eq (var-name loc) (var-name var))) (wt-nl "ecl_bds_push(cl_env_copy," (var-loc var) ");")) (t (wt-nl "ecl_bds_bind(cl_env_copy," (var-loc var) ",") (wt-coerce-loc :object loc) (wt ");"))) (push 'BDS-BIND *unwind-exit*) (wt-comment (var-name var))) ecl-16.1.2/src/cmp/cmpblock.lsp000066400000000000000000000114301266352375300162370ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: C -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. ;;;; Copyright (c) 1990, Giuseppe Attardi. ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. ;;;; CMPBLOCK Block and Return-from. (in-package "COMPILER") ;;; A dummy variable is created to hold the block identifier. When a ;;; reference to the block (via return-from) is found, the var-ref ;;; count for that variable is incremented only if the reference ;;; appears across a boundary (CB, LB or UNWIND-PROTECT), while the ;;; blk-ref is always incremented. Therefore blk-ref represents ;;; whether the block is used at all and var-ref for the dummy ;;; variable represents whether a block identifier must be created and ;;; stored in such variable. (defun c1block (args) (check-args-number 'BLOCK args 1) (let ((block-name (first args))) (unless (symbolp block-name) (cmperr "The block name ~s is not a symbol." block-name)) (let* ((blk-var (make-var :name block-name :kind 'LEXICAL)) (blk (make-blk :var blk-var :name block-name)) (body (let ((*cmp-env* (cmp-env-copy))) (cmp-env-register-block blk) (c1progn (rest args))))) (when (or (blk-ref-ccb blk) (blk-ref-clb blk)) (incf *setjmps*)) (if (plusp (blk-ref blk)) ;; FIXME! By simplifying the type of a BLOCK form so much (it is ;; either NIL or T), we lose a lot of information. (make-c1form* 'BLOCK :local-vars (list blk-var) :type (values-type-or (blk-type blk) (c1form-type body)) :args blk body) body)))) (defun c2block (c1form blk body) (declare (ignore c1form)) (if (plusp (var-ref (blk-var blk))) (let* ((blk-var (blk-var blk)) (*env-lvl* *env-lvl*)) (setf (blk-exit blk) *exit* (blk-destination blk) *destination*) (wt-nl-open-brace) (unless (or (blk-ref-ccb blk) (blk-ref-clb blk)) (setf (var-kind blk-var) :object (var-loc blk-var) (next-lcl)) (wt-nl "cl_object " blk-var ";")) (when (env-grows (blk-ref-ccb blk)) (let ((env-lvl *env-lvl*)) (wt-nl "cl_object " *volatile* "env" (incf *env-lvl*) " = env" env-lvl ";"))) (bind "ECL_NEW_FRAME_ID(cl_env_copy)" blk-var) (wt-nl "if (ecl_frs_push(cl_env_copy," blk-var ")!=0) {") (let ((*unwind-exit* (cons 'FRAME *unwind-exit*))) (unwind-exit 'VALUES) (wt-nl "} else {") (c2expr body) (wt "}")) (when (blk-ref-ccb blk) (decf *env*)) (wt-nl-close-brace)) (progn (setf (blk-exit blk) *exit*) (setf (blk-destination blk) *destination*) (c2expr body))) ) (defun c1return-from (args) (check-args-number 'RETURN-FROM args 1 2) (let ((name (first args))) (unless (symbolp name) (cmperr "The block name ~s is not a symbol." name)) (multiple-value-bind (blk ccb clb unw) (cmp-env-search-block name) (unless blk (cmperr "The block ~s is undefined." name)) (let* ((val (c1expr (second args))) (var nil) (type T)) (cond (ccb (setf (blk-ref-ccb blk) t type 'CCB var (blk-var blk) (var-kind var) 'CLOSURE (var-ref-ccb var) T)) (clb (setf (blk-ref-clb blk) t type 'CLB var (blk-var blk))) (unw (setf type 'UNWIND-PROTECT var (blk-var blk)))) (incf (blk-ref blk)) (setf (blk-type blk) (values-type-or (blk-type blk) (c1form-type val))) (let ((output (make-c1form* 'RETURN-FROM :type 'T :args blk type val var))) (when var (add-to-read-nodes var output)) output))))) (defun c2return-from (c1form blk type val var) (declare (ignore var c1form)) (case type (CCB (let ((*destination* 'VALUES)) (c2expr* val)) (wt-nl "cl_return_from(" (blk-var blk) "," (add-symbol (blk-name blk)) ");")) ((CLB UNWIND-PROTECT) (let ((*destination* 'VALUES)) (c2expr* val)) (wt-nl "cl_return_from(" (blk-var blk) ",ECL_NIL);")) (T (let ((*destination* (blk-destination blk)) (*exit* (blk-exit blk))) (c2expr val)))) ) ecl-16.1.2/src/cmp/cmpc-inliner.lsp000066400000000000000000000171221266352375300170310ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: C -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. ;;;; Copyright (c) 1990, Giuseppe Attardi. ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. ;;;; ;;;; CMPC-INLINER -- Open coding functions as C expressions ;;;; (in-package "COMPILER") (defun inlined-arg-loc (arg) (second arg)) (defun inlined-arg-type (arg) (first arg)) (defun inlined-arg-rep-type (arg) (loc-representation-type (second arg))) (defmacro define-c-inliner (fname lambda-list &body body) `(setf (gethash ',fname *cinline-dispatch-table*) #'(lambda ,lambda-list (block nil ,@body)))) (defun apply-inliner (fname return-type inlined-args) (let ((fd (gethash fname *cinline-dispatch-table*))) (if fd (apply fd return-type inlined-args) (default-c-inliner fname return-type inlined-args)))) (defun default-c-inliner (fname return-type inlined-args) (let* ((arg-types (mapcar #'first inlined-args)) (ii (inline-function fname arg-types return-type))) (and ii (apply-inline-info ii inlined-args)))) ;;; ;;; inline-function: ;;; locs are typed locs as produced by inline-args ;;; returns NIL if inline expansion of the function is not possible ;;; (defun inline-function (fname arg-types return-type &optional (return-rep-type 'any)) ;; Those functions that use INLINE-FUNCTION must rebind ;; the variable *INLINE-BLOCKS*. (and (inline-possible fname) (not (gethash fname *c2-dispatch-table*)) (let* ((dest-rep-type (loc-representation-type *destination*)) (ii (get-inline-info fname arg-types return-type return-rep-type))) ii))) (defun apply-inline-info (ii inlined-locs) (let* ((arg-types (inline-info-arg-types ii)) (out-rep-type (inline-info-return-rep-type ii)) (out-type (inline-info-return-type ii)) (side-effects-p (function-may-have-side-effects (inline-info-name ii))) (fun (inline-info-expansion ii)) (one-liner (inline-info-one-liner ii))) (produce-inline-loc inlined-locs arg-types (list out-rep-type) fun side-effects-p one-liner))) (defun choose-inline-info (ia ib return-type return-rep-type) (declare (ignore return-type)) (cond ;; Only accept inliners that have the right rep type ((not (or (eq return-rep-type 'any) (eq return-rep-type :void) (let ((info-type (inline-info-return-rep-type ib))) (or (eq return-rep-type info-type) ;; :bool can be coerced to any other location type (eq info-type :bool))))) ia) ((null ia) ib) ;; Keep the first one, which is typically the least safe but fastest. ((equal (inline-info-arg-types ia) (inline-info-arg-types ib)) ia) ;; More specific? ((every #'type>= (inline-info-arg-types ia) (inline-info-arg-types ib)) ib) ;; Keep the first one, which is typically the least safe but fastest. (t ia))) (defun get-inline-info (fname types return-type return-rep-type) (declare (si::c-local)) (let ((output nil)) (unless (safe-compile) (dolist (x (inline-information fname ':INLINE-UNSAFE)) (let ((other (inline-type-matches x types return-type))) (when other (setf output (choose-inline-info output other return-type return-rep-type)))))) (dolist (x (inline-information fname ':INLINE-SAFE)) (let ((other (inline-type-matches x types return-type))) (when other (setf output (choose-inline-info output other return-type return-rep-type))))) (dolist (x (inline-information fname ':INLINE-ALWAYS)) (let ((other (inline-type-matches x types return-type))) (when other (setf output (choose-inline-info output other return-type return-rep-type))))) (when (and (null output) (inline-information fname 'should-be-inlined) (>= (cmp-env-optimization 'speed) 1)) (cmpwarn-style "Could not inline call to ~S ~S - performance may be degraded." fname types)) output)) (defun to-fixnum-float-type (type) (dolist (i '(FIXNUM DOUBLE-FLOAT SINGLE-FLOAT #+long-float LONG-FLOAT) nil) (when (type>= i type) (return i)))) (defun maximum-float-type (t1 t2) (cond ((null t1) t2) #+long-float ((or (eq t1 'LONG-FLOAT) (eq t2 'LONG-FLOAT)) 'LONG-FLOAT) ((or (eq t1 'DOUBLE-FLOAT) (eq t2 'DOUBLE-FLOAT)) 'DOUBLE-FLOAT) ((or (eq t1 'SINGLE-FLOAT) (eq t2 'SINGLE-FLOAT)) 'SINGLE-FLOAT) (T 'FIXNUM))) (defun inline-type-matches (inline-info arg-types return-type) (when (and (not (inline-info-multiple-values inline-info)) (member *destination* '(VALUES RETURN))) (return-from inline-type-matches nil)) (let* ((rts nil) (number-max nil)) ;; ;; Check that the argument types match those of the inline expression ;; (do* ((arg-types arg-types (cdr arg-types)) (types (inline-info-arg-types inline-info) (cdr types))) ((or (endp arg-types) (endp types)) (when (or arg-types types) (return-from inline-type-matches nil))) (let* ((arg-type (first arg-types)) (type (first types))) (cond ((eq type 'FIXNUM-FLOAT) (let ((new-type (to-fixnum-float-type arg-type))) (unless new-type (return-from inline-type-matches nil)) (push new-type rts) (setq number-max (maximum-float-type number-max new-type)))) #+sse2 ;; Allow implicit casts between SSE subtypes to kick in ((and (type>= 'ext:sse-pack type) (type>= 'ext:sse-pack arg-type)) (push type rts)) ((type>= type arg-type) (push type rts)) (t (return-from inline-type-matches nil))))) ;; ;; Now there is an optional check of the return type. This check is ;; only used when enforced by the inliner. ;; (when (or (eq (inline-info-return-rep-type inline-info) :bool) (null (inline-info-exact-return-type inline-info)) (and (policy-assume-right-type) (let ((inline-return-type (inline-info-return-type inline-info))) (if number-max ;; for arithmetic operators we take the maximal ;; type as possible result type. Note that FIXNUM ;; is not an option, because the product, addition ;; or difference of fixnums may be a larger ;; integer. (and (setf number-max (if (eq number-max 'fixnum) 'integer number-max)) (type>= inline-return-type number-max) (type>= number-max return-type)) ;; no contravariance (type>= inline-return-type return-type))))) (let ((inline-info (copy-structure inline-info))) (setf (inline-info-arg-types inline-info) (nreverse rts)) inline-info)))) ecl-16.1.2/src/cmp/cmpc-machine.lsp000066400000000000000000000165501266352375300170010ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: C -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; Copyright (c) 2010, Juan Jose Garcia-Ripoll. ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. ;;;; ;;;; CMPC-MACHINE -- Abstract target machine details ;;;; (in-package #-new-cmp "COMPILER" #+new-cmp "C-BACKEND") (defconstant +representation-types+ '(;; These types can be used by ECL to unbox data ;; They are sorted from the most specific, to the least specific one. (:byte . #1=((signed-byte 8) "int8_t" "ecl_make_int8_t" "ecl_to_int8_t" "ecl_fixnum")) (:unsigned-byte . #2=((unsigned-byte 8) "uint8_t" "ecl_make_uint8_t" "ecl_to_uint8_t" "ecl_fixnum")) (:fixnum integer "cl_fixnum" "ecl_make_fixnum" "ecl_to_fixnum" "ecl_fixnum") (:int integer "int" "ecl_make_int" "ecl_to_int" "ecl_to_int") (:unsigned-int integer "unsigned int" "ecl_make_uint" "ecl_to_uint" "ecl_to_uint") (:long integer "long" "ecl_make_long" "ecl_to_long" "ecl_to_long") (:unsigned-long integer "unsigned long" "ecl_make_ulong" "ecl_to_ulong" "ecl_to_ulong") (:cl-index integer "cl_index" "ecl_make_unsigned_integer" "ecl_to_cl_index" "ecl_fixnum") (:long-long integer "ecl_long_long_t" "ecl_make_long_long" "ecl_to_long_long" "ecl_to_long_long") (:unsigned-long-long integer "ecl_ulong_long_t" "ecl_make_ulong_long" "ecl_to_ulong_long" "ecl_to_ulong_long") (:float single-float "float" "ecl_make_single_float" "ecl_to_float" "ecl_single_float") (:double double-float "double" "ecl_make_double_float" "ecl_to_double" "ecl_double_float") (:long-double long-float "long double" "ecl_make_long_float" "ecl_to_long_double" "ecl_long_float") (:unsigned-char base-char "unsigned char" "CODE_CHAR" "ecl_base_char_code" "CHAR_CODE") (:char base-char "char" "CODE_CHAR" "ecl_base_char_code" "CHAR_CODE") (:wchar character "ecl_character" "CODE_CHAR" "ecl_char_code" "CHAR_CODE") (:float-sse-pack ext::float-sse-pack "__m128" "ecl_make_float_sse_pack" "ecl_unbox_float_sse_pack" "ecl_unbox_float_sse_pack_unsafe") (:double-sse-pack ext::double-sse-pack "__m128d" "ecl_make_double_sse_pack" "ecl_unbox_double_sse_pack" "ecl_unbox_double_sse_pack_unsafe") (:int-sse-pack ext::sse-pack #|<-intentional|# "__m128i" "ecl_make_int_sse_pack" "ecl_unbox_int_sse_pack" "ecl_unbox_int_sse_pack_unsafe") (:object t "cl_object") (:bool t "bool" "ecl_make_bool" "ecl_to_bool" "ecl_to_bool") ;; These types are never selected to unbox data. ;; They are here, because we need to know how to print them. (:void nil "void") (:pointer-void si::foreign-data "void*" "ecl_make_pointer" "ecl_to_pointer" "ecl_to_pointer") (:cstring string "char*" "ecl_cstring_to_base_string_or_nil") (:char* string "char*") (:int8-t . #1#) (:uint8-t . #2#) (:int16-t integer "ecl_int16_t" "ecl_make_int16_t" "ecl_to_int16_t" "ecl_to_int16_t") (:uint16-t integer "ecl_uint16_t" "ecl_make_uint16_t" "ecl_to_uint16_t" "ecl_to_unt16_t") (:int32-t integer "ecl_int32_t" "ecl_make_int32_t" "ecl_to_int32_t" "ecl_to_int32_t") (:uint32-t integer "ecl_uint32_t" "ecl_make_uint32_t" "ecl_to_uint32_t" "ecl_to_uint32_t") (:int64-t integer "ecl_int64_t" "ecl_make_int64_t" "ecl_to_int64_t" "ecl_to_int64_t") (:uint64-t integer "ecl_uint64_t" "ecl_make_uint64_t" "ecl_to_uint64_t" "ecl_to_uint64_t") (:short integer "short" "ecl_make_short" "ecl_to_short" "ecl_fixnum") (:unsigned-short integer "unsigned short" "ecl_make_ushort" "ecl_to_ushort" "ecl_fixnum") )) (defconstant +this-machine-c-types+ '((:byte . -8) (:unsigned-byte . 8) (:unsigned-short . #.(- (logcount ffi:c-ushort-max))) (:short . #.(- (logcount ffi:c-ushort-max))) (:unsigned-int . #.(logcount ffi:c-uint-max)) (:int . #.(- (logcount ffi:c-uint-max))) (:unsigned-long . #.(logcount ffi:c-ulong-max)) (:long . #.(- (logcount ffi:c-ulong-max))) #+long-long (:unsigned-long-long . #.(logcount ffi:c-ulong-long-max)) #+long-long (:long-long . #.(- (logcount ffi:c-ulong-long-max))) (:cl-index . #.(logcount most-positive-fixnum)) (:fixnum . #.(- -1 (logcount most-positive-fixnum))) (:uint8-t . 8) (:int8-t . -8) #+:uint16-t (:uint16-t . 16) #+:uint16-t (:int16-t . -16) #+:uint32-t (:uint32-t . 32) #+:uint32-t (:int32-t . -32) #+:uint64-t (:uint64-t . 64) #+:uint64-t (:int64-t . -64) #+:sse2 (:float-sse-pack . nil) #+:sse2 (:double-sse-pack . nil) #+:sse2 (:int-sse-pack . nil) #+:long-float (:long-double . nil) )) (defconstant +all-machines-c-types+ '((:object) (:float) (:double) (:char) (:unsigned-char) (:wchar) (:char*) (:cstring) (:bool) (:void) (:pointer-void))) (defun make-rep-type (all-c-types name lisp-type c-name &optional to-lisp from-lisp from-lisp-unsafe) (let* ((record (assoc name all-c-types)) (bits (cdr record))) (when record ;; For integer bits we get extra information from ALL-C-TYPES (when bits (if (plusp bits) (setf lisp-type `(unsigned-byte ,bits)) (setf bits (- bits) lisp-type `(signed-byte ,bits)))) (%make-rep-type :name name :lisp-type lisp-type :bits bits :numberp (subtypep lisp-type 'number) :integerp (subtypep lisp-type 'integer) :c-name c-name :to-lisp to-lisp :from-lisp from-lisp :from-lisp-unsafe from-lisp-unsafe)))) (defun make-rep-type-hash (all-c-types) (let ((table (make-hash-table :size 128 :test 'eq))) table)) (defun default-machine () (let* ((all-c-types (append +this-machine-c-types+ +all-machines-c-types+)) (table (make-hash-table :size 128 :test 'eq)) (sorted-rep-types ;; Create the rep-type objects (loop for i from 0 for record in +representation-types+ for rep-type = (apply #'make-rep-type all-c-types record) when rep-type do (setf (rep-type-index rep-type) i) and collect (setf (gethash (rep-type-name rep-type) table) rep-type)))) ;; hack: sse-pack -> int, but int -> int-sse-pack (let ((r (gethash :int-sse-pack table))) (when r (setf (rep-type-index r) 'ext:int-sse-pack))) ;; On a second pass, we replace types with more general ones (loop with fixnum-rep-type = (gethash ':fixnum table) with fixnum-lisp-type = (rep-type-lisp-type fixnum-rep-type) for (name . rest) in +representation-types+ for r = (gethash name table) when (and r (subtypep (rep-type-lisp-type r) fixnum-lisp-type)) do (setf (rep-type-from-lisp-unsafe r) "ecl_fixnum")) ;; Create machine object (make-machine :c-types all-c-types :rep-type-hash table :sorted-types sorted-rep-types))) (defun machine-c-type-p (name) (gethash name (machine-rep-type-hash *machine*))) (defun machine-fixnump (number) (typep number (rep-type-lisp-type (gethash :fixnum number)))) (defconstant +default-machine+ (setf *machine* (default-machine))) ecl-16.1.2/src/cmp/cmpc-wt.lsp000066400000000000000000000151651266352375300160300ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: C -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; Copyright (c) 2010, Juan Jose Garcia-Ripoll. ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. ;;;; ;;;; CMPC-WT -- Routines for writing code to C files. ;;;; (in-package #-new-cmp "COMPILER" #+new-cmp "C-BACKEND") (defun wt1 (form) (cond ((not (floatp form)) (typecase form ((or STRING INTEGER CHARACTER) (princ form *compiler-output1*)) (VAR (wt-var form)) (t (wt-loc form)))) ;; ((ext:float-nan-p form) ;; (format *compiler-output1* "NAN")) ((ext:float-infinity-p form) (if (minusp form) (format *compiler-output1* "-INFINITY") (format *compiler-output1* "INFINITY"))) (T (typecase form (SINGLE-FLOAT (format *compiler-output1* "(float)~10,,,,,,'eG" form)) (DOUBLE-FLOAT (format *compiler-output1* "~10,,,,,,'eG" form)) (LONG-FLOAT (format *compiler-output1* "~,,,,,,'eEl" form)))))) (defun wt-h1 (form) (let ((*compiler-output1* *compiler-output2*)) (wt1 form))) (defun wt (&rest forms) (mapc #'wt1 forms)) (defun wt-h (&rest forms) (mapc #'wt-h1 forms)) (defun wt-nl-h (&rest forms) (terpri *compiler-output2*) (mapc #'wt-h1 forms)) (defun princ-h (form) (princ form *compiler-output2*)) (defun wt-nl (&rest forms) (wt-nl-indent) (mapc #'wt1 forms)) (defun wt-nl1 (&rest forms) (wt1 #\Newline) (mapc #'wt1 forms)) ;;; Blocks beyond this value will not be indented (defvar +max-depth+ 10) (defvar +c-newline-indent-strings+ #.(coerce (let ((basis (make-array (1+ +max-depth+) :initial-element #\Space :element-type 'base-char))) (setf (aref basis 0) #\Newline) (loop for i from 0 to +max-depth+ collect (subseq basis 0 (1+ i)))) 'vector)) (defun wt-nl-indent () (wt1 (aref +c-newline-indent-strings+ (min *opened-c-braces* +max-depth+)))) (defun wt-open-brace () (wt1 #\{) (incf *opened-c-braces*)) (defun wt-nl-open-brace () (wt-nl-indent) (wt-open-brace)) (defun wt-nl-close-many-braces (final-value) (let ((diff (- *opened-c-braces* final-value))) (when (minusp diff) (baboon :format-control "Mismatch in C blocks")) (loop for i from 0 below diff do (wt-nl-close-brace)))) (defun wt-nl-close-brace () (if (plusp *opened-c-braces*) (progn (decf *opened-c-braces*) (wt-nl-indent) (wt1 #\})) (baboon :format-control "Mismatch in C blocks"))) (defmacro with-indentation (&body body) `(let ((*opened-c-braces* (1+ *opened-c-braces*))) ,@body)) ;;; ;;; LABELS AND JUMPS ;;; (defun wt-go (label) #-new-cmp (setf (cdr label) t label (car label)) (wt "goto L" label ";")) (defun wt-label (label) #-new-cmp (when (cdr label) (wt-nl1 "L" (car label) ":;")) #+new-cmp (wt-nl1 "L" label ":;")) ;;; ;;; C/C++ COMMENTS ;;; (defun wt-filtered-comment (text stream single-line) (declare (string text)) (if single-line (progn (fresh-line stream) (princ "/* " stream)) (format stream "~50T/* ")) (let* ((l (1- (length text)))) (declare (fixnum l)) (dotimes (n l) (let* ((c (schar text n)) (code (char-code c))) (cond ((or (eq c #\Newline) (eq c #\Tab)) (princ c stream)) ((or (< code 32) (> code 127)) (format stream "\ux" code)) ((and (char= c #\*) (char= (schar text (1+ n)) #\/)) (princ #\\ stream)) (t (princ c stream))))) (princ (schar text l) stream)) (format stream "~70T*/") ) (defun do-wt-comment (message-or-format args single-line-p) (unless (and (symbolp message-or-format) (not (symbol-package message-or-format))) (wt-filtered-comment (if (stringp message-or-format) (if args (apply #'format nil message-or-format args) message-or-format) (princ-to-string message-or-format)) *compiler-output1* single-line-p))) (defun wt-comment (message &rest extra) (do-wt-comment message extra nil)) (defun wt-comment-nl (message &rest extra) (do-wt-comment message extra t)) ;;; ;;; STRINGS ;;; ;;; This routine converts lisp data into C-strings. We have to take ;;; care of escaping special characteres with backslashes. We also have ;;; to split long lines using the fact that multiple strings are joined ;;; together by the compiler. ;;; (defvar *wt-string-size* 0) #+unicode (defun encode-string (string format) (let* ((output (make-array (round (* 1.2 (length string))) :element-type 'base-char :adjustable t :fill-pointer 0)) (stream (make-sequence-output-stream output :external-format format))) (write-string string stream) output)) (defun wt-filtered-data (string stream &key one-liner (external-format #-unicode :default #+unicode :utf-8)) #+unicode (setf string (encode-string string external-format)) (let ((N (length string)) (wt-data-column 80)) (incf *wt-string-size* N) ; 1+ accounts for a blank space (format stream (if one-liner "\"" "~%\"")) (dotimes (i N) (decf wt-data-column) (when (< wt-data-column 0) (format stream "\"~% \"") (setq wt-data-column 79)) (let ((x (aref string i))) (cond ((or (< (char-code x) 32) (> (char-code x) 127)) (case x ; We avoid a trailing backslash+newline because some preprocessors ; remove them. (#\Newline (princ "\\n" stream)) (#\Tab (princ "\\t" stream)) (t (format stream "\\~3,'0o" (char-code x))))) ((char= x #\\) (princ "\\\\" stream)) ((char= x #\") (princ "\\\"" stream)) (t (princ x stream))))) (princ "\"" stream) string)) (defun c-filtered-string (string &rest args) (with-output-to-string (aux-stream) (apply #'wt-filtered-data string aux-stream :one-liner t args))) ecl-16.1.2/src/cmp/cmpcall.lsp000066400000000000000000000250351266352375300160660ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: C -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; CMPCALL Function call. ;;;; Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. ;;;; Copyright (c) 1990, Giuseppe Attardi. ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. (in-package "COMPILER") (defun unoptimized-long-call (fun arguments) (let ((frame (gensym))) `(with-stack ,frame ,@(loop for i in arguments collect `(stack-push ,frame ,i)) (si::apply-from-stack-frame ,frame ,fun)))) (defun unoptimized-funcall (fun arguments) (let ((l (length arguments))) (if (<= l si::c-arguments-limit) (make-c1form* 'FUNCALL :sp-change t :side-effects t :args (c1expr fun) (c1args* arguments)) (unoptimized-long-call fun arguments)))) (defun c1funcall (args) (check-args-number 'FUNCALL args 1) (let ((fun (first args)) (arguments (rest args)) fd) (cond ;; (FUNCALL (LAMBDA ...) ...) ((and (consp fun) (eq (first fun) 'LAMBDA)) (optimize-funcall/apply-lambda (cdr fun) arguments nil)) ;; (FUNCALL (EXT::LAMBDA-BLOCK ...) ...) ((and (consp fun) (eq (first fun) 'EXT::LAMBDA-BLOCK)) (setf fun (macroexpand-1 fun)) (optimize-funcall/apply-lambda (cdr fun) arguments nil)) ;; (FUNCALL atomic-expression ...) ((atom fun) (unoptimized-funcall fun arguments)) ;; (FUNCALL macro-expression ...) ((let ((name (first fun))) (setq fd (and (symbolp name) ;; We do not want to macroexpand 'THE (not (eq name 'THE)) (cmp-macro-function name)))) (c1funcall (list* (cmp-expand-macro fd fun) arguments))) ;; (FUNCALL lisp-expression ...) ((not (eq (first fun) 'FUNCTION)) (unoptimized-funcall fun arguments)) ;; (FUNCALL #'GENERALIZED-FUNCTION-NAME ...) ((si::valid-function-name-p (setq fun (second fun))) (c1call fun arguments nil)) ;; (FUNCALL #'(LAMBDA ...) ...) ((and (consp fun) (eq (first fun) 'LAMBDA)) (optimize-funcall/apply-lambda (rest fun) arguments nil)) ;; (FUNCALL #'(EXT::LAMBDA-BLOCK ...) ...) ((and (consp fun) (eq (first fun) 'EXT::LAMBDA-BLOCK)) (setf fun (macroexpand-1 fun)) (optimize-funcall/apply-lambda (rest fun) arguments nil)) (t (cmperr "Malformed function name: ~A" fun))))) (defun c2funcall (c1form form args) (declare (ignore c1form)) (let* ((*inline-blocks* 0) (*temp* *temp*) (form-type (c1form-primary-type form)) (function-p (and (subtypep form-type 'function) (policy-assume-right-type))) (loc (maybe-save-value form args))) (unwind-exit (call-unknown-global-loc nil loc (inline-args args) function-p)) (close-inline-blocks))) ;;; ;;; c2call-global: ;;; ARGS is the list of arguments ;;; LOC is either NIL or the location of the function object ;;; (defun c2call-global (c1form fname args) (let ((fun (find fname *global-funs* :key #'fun-name :test #'same-fname-p))) (when (and fun (c2try-tail-recursive-call fun args)) (return-from c2call-global)) (let* ((*inline-blocks* 0) (*temp* *temp*)) (unwind-exit (call-global-loc fname fun args (c1form-primary-type c1form) (loc-type *destination*))) (close-inline-blocks)))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; ;;; CALL LOCATIONS ;;; ;;; ;;; call-global: ;;; FNAME: the name of the function ;;; LOC: either a function object or NIL ;;; ARGS: a list of typed locs with arguments ;;; RETURN-TYPE: the type to which the output is coerced ;;; (defun call-global-loc (fname fun args return-type expected-type) ;; Check whether it is a global function that we cannot call directly. (when (and (or (null fun) (fun-global fun)) (not (inline-possible fname))) (return-from call-global-loc (call-unknown-global-loc fname nil (inline-args args)))) (setf args (inline-args args)) ;; Try with a function that has a C-INLINE expansion (let ((inline-loc (apply-inliner fname (type-and return-type expected-type) args))) (when inline-loc (return-from call-global-loc inline-loc))) ;; Call to a function defined in the same file. Direct calls are ;; only emitted for low or neutral values of DEBUG is >= 2. (when (and (policy-use-direct-C-call) (or (fun-p fun) (and (null fun) (setf fun (find fname *global-funs* :test #'same-fname-p :key #'fun-name))))) (return-from call-global-loc (call-loc fname fun args return-type))) ;; Call to a global (SETF ...) function (when (not (symbolp fname)) (return-from call-global-loc (call-unknown-global-loc fname nil args))) ;; Call to a function whose C language function name is known, ;; either because it has been proclaimed so, or because it belongs ;; to the runtime. (when (policy-use-direct-C-call) (let ((fd (get-sysprop fname 'Lfun))) (when fd (multiple-value-bind (minarg maxarg) (get-proclaimed-narg fname) (return-from call-global-loc (call-exported-function-loc fname args fd minarg maxarg (member fname *in-all-symbols-functions*) return-type)))))) (multiple-value-bind (found fd minarg maxarg) (si::mangle-name fname t) (when found (return-from call-global-loc (call-exported-function-loc fname args fd minarg maxarg t return-type)))) (call-unknown-global-loc fname nil args)) (defun call-loc (fname fun args type) (declare (ignore fname)) `(CALL-NORMAL ,fun ,(coerce-locs args) ,type)) (defun call-exported-function-loc (fname args fun-c-name minarg maxarg in-core return-type) (unless in-core ;; We only write declarations for functions which are not in lisp_external.h (multiple-value-bind (val declared) (gethash fun-c-name *compiler-declared-globals*) (declare (ignore val)) (unless declared (if (= maxarg minarg) (progn (wt-nl-h "extern cl_object " fun-c-name "(") (dotimes (i maxarg) (when (> i 0) (wt-h1 ",")) (wt-h1 "cl_object")) (wt-h1 ");")) (progn (wt-nl-h "#ifdef __cplusplus") (wt-nl-h "extern cl_object " fun-c-name "(...);") (wt-nl-h "#else") (wt-nl-h "extern cl_object " fun-c-name "();") (wt-nl-h "#endif"))) (setf (gethash fun-c-name *compiler-declared-globals*) 1)))) (let ((fun (make-fun :name fname :global t :cfun fun-c-name :lambda 'NIL :minarg minarg :maxarg maxarg))) (call-loc fname fun args return-type))) ;;; ;;; call-unknown-global-loc ;;; LOC is NIL or location containing function ;;; ARGS is the list of typed locations for arguments ;;; (defun call-unknown-global-loc (fname loc args &optional function-p) (unless loc (if (and (symbolp fname) (not (eql (symbol-package fname) (find-package "CL")))) (setf loc (add-symbol fname) function-p nil) (setf loc (list 'FDEFINITION fname) function-p t))) `(CALL-INDIRECT ,loc ,(coerce-locs args) ,fname ,function-p)) ;;; Functions that use MAYBE-SAVE-VALUE should rebind *temp*. (defun maybe-save-value (value &optional (other-forms nil other-forms-flag)) (let ((name (c1form-name value))) (cond ((eq name 'LOCATION) (c1form-arg 0 value)) ((and (eq name 'VAR) other-forms-flag (not (var-changed-in-form-list (c1form-arg 0 value) other-forms))) (c1form-arg 0 value)) (t (let* ((temp (make-temp-var)) (*destination* temp)) (c2expr* value) temp))))) (defvar *text-for-lexical-level* '("lex0" "lex1" "lex2" "lex3" "lex4" "lex5" "lex6" "lex7" "lex8" "lex9")) (defvar *text-for-closure* '("env0" "env1" "env2" "env3" "env4" "env5" "env6" "env7" "env8" "env9")) (defun env-var-name (n) (or (nth n *text-for-closure*) (format nil "env~D" n))) (defun wt-stack-pointer (narg) (wt "cl_env_copy->stack_top-" narg)) (defun wt-call (fun args &optional fname env) (if env (progn (setf *aux-closure* t) (wt "(aux_closure.env="env",cl_env_copy->function=(cl_object)&aux_closure,") (wt-call fun args) (wt ")")) (progn (wt fun "(") (let ((comma "")) (dolist (arg args) (wt comma arg) (setf comma ", "))) (wt ")"))) (when fname (wt-comment fname))) (defun wt-call-indirect (fun-loc args fname function-p) (let ((narg (length args))) (if function-p (wt "(cl_env_copy->function=" fun-loc ")->cfun.entry(" narg) (wt "ecl_function_dispatch(cl_env_copy," fun-loc ")(" narg)) (dolist (arg args) (wt ", " arg)) (wt ")") (when fname (wt-comment fname)))) (defun wt-call-normal (fun args type) (unless (fun-cfun fun) (baboon "Function without a C name: ~A" (fun-name fun))) (let* ((minarg (fun-minarg fun)) (maxarg (fun-maxarg fun)) (fun-c-name (fun-cfun fun)) (fun-lisp-name (fun-name fun)) (narg (length args)) (env nil)) (case (fun-closure fun) (CLOSURE (setf env (environment-accessor fun))) (LEXICAL (let ((lex-lvl (fun-level fun))) (dotimes (n lex-lvl) (let* ((j (- lex-lvl n 1)) (x (nth j *text-for-lexical-level*))) (unless x (setf x (format nil "lex~d" j) (nth n *text-for-lexical-level*) x)) (push x args)))))) (unless (<= minarg narg maxarg) (cmperr "Wrong number of arguments for function ~S" (or fun-lisp-name 'ANONYMOUS))) (when (fun-needs-narg fun) (push narg args)) (wt-call fun-c-name args nil env))) ecl-16.1.2/src/cmp/cmpcatch.lsp000066400000000000000000000101551266352375300162320ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: C -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. ;;;; Copyright (c) 1990, Giuseppe Attardi. ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. ;;;; CMPCATCH Catch, Unwind-protect, and Throw. (in-package "COMPILER") (defun c1catch (args) (check-args-number 'CATCH args 1) (incf *setjmps*) (make-c1form* 'CATCH :sp-change t :type t :args (c1expr (first args)) (c1progn (rest args)))) (defun c2catch (c1form tag body) (declare (ignore c1form)) (let* ((new-destination (tmp-destination *destination*)) (code (incf *last-label*))) (let ((*destination* 'VALUE0)) (c2expr* tag)) (let* ((*destination* new-destination) (*unwind-exit* (cons 'FRAME *unwind-exit*))) (if (member new-destination '(TRASH VALUES)) (progn (wt-nl "if (ecl_frs_push(cl_env_copy," 'VALUE0 ")==0) {") (wt-comment "BEGIN CATCH ~A" code) (with-indentation (c2expr* body))) (progn (wt-nl "if (ecl_frs_push(cl_env_copy," 'VALUE0 ")) {") (wt-comment "BEGIN CATCH ~A" code) (with-indentation (with-exit-label (label) (let ((*exit* label)) (unwind-exit 'VALUES)))) (wt-nl "} else {") (with-indentation (c2expr* body))))) (wt-nl "}") (wt-nl "ecl_frs_pop(cl_env_copy);") (wt-comment "END CATCH ~A" code) (unwind-exit new-destination))) (defun c1unwind-protect (args) (check-args-number 'UNWIND-PROTECT args 1) (incf *setjmps*) (let ((form (let ((*cmp-env* (cmp-env-mark 'UNWIND-PROTECT))) (c1expr (first args))))) (make-c1form* 'UNWIND-PROTECT :type (c1form-type form) :sp-change t :args form (c1progn (rest args))))) (defun c2unwind-protect (c1form form body) (declare (ignore c1form)) (let* ((sp (make-lcl-var :rep-type :cl-index)) (nargs (make-lcl-var :rep-type :cl-index)) (*unwind-exit* `((STACK ,sp) ,@*unwind-exit*))) (wt-nl-open-brace) (wt-nl "volatile bool unwinding = FALSE;") (wt-nl "cl_index " sp "=ECL_STACK_INDEX(cl_env_copy)," nargs ";") (wt-nl "ecl_frame_ptr next_fr;") ;; Here we compile the form which is protected. When this form ;; is aborted, it continues at the ecl_frs_pop() with unwinding=TRUE. (wt-nl "if (ecl_frs_push(cl_env_copy,ECL_PROTECT_TAG)) {") (wt-nl " unwinding = TRUE; next_fr=cl_env_copy->nlj_fr;") (wt-nl "} else {") (let ((*unwind-exit* (cons 'FRAME *unwind-exit*)) (*destination* 'VALUES)) (c2expr* form)) (wt-nl "}") (wt-nl "ecl_frs_pop(cl_env_copy);") ;; Here we save the values of the form which might have been ;; aborted, and execute some cleanup code. This code may also ;; be aborted by some control structure, but is not protected. (wt-nl nargs "=ecl_stack_push_values(cl_env_copy);") (let ((*destination* 'TRASH)) (c2expr* body)) (wt-nl "ecl_stack_pop_values(cl_env_copy," nargs ");") ;; Finally, if the protected form was aborted, jump to the ;; next catch point... (wt-nl "if (unwinding) ecl_unwind(cl_env_copy,next_fr);") ;; ... or simply return the values of the protected form. (unwind-exit 'VALUES) (wt-nl-close-brace))) (defun c1throw (args) (check-args-number 'THROW args 2 2) (make-c1form* 'THROW :args (c1expr (first args)) (c1expr (second args)))) (defun c2throw (c1form tag val &aux loc) (declare (ignore c1form)) (case (c1form-name tag) ((VAR LOCATION) (setq loc (c1form-arg 0 tag))) (t (setq loc (make-temp-var)) (let ((*destination* loc)) (c2expr* tag)))) (let ((*destination* 'VALUES)) (c2expr* val)) (wt-nl "cl_throw(" loc ");")) ecl-16.1.2/src/cmp/cmpcbk.lsp000066400000000000000000000124531266352375300157120ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: C -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; CMPCBK -- Callbacks: lisp functions that can be called from the C world ;;;; Copyright (c) 2003, Juan Jose Garcia-Ripoll. ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. (in-package "COMPILER") (defun c1-defcallback (args) (destructuring-bind (name return-type arg-list &rest body) args (let ((arg-types '()) (arg-type-constants '()) (arg-variables '()) (c-name (format nil "ecl_callback_~d" (length *callbacks*))) (name (if (consp name) (first name) name)) (call-type (if (consp name) (second name) :cdecl))) (dolist (i arg-list) (unless (consp i) (cmperr "Syntax error in CALLBACK form: C type is missing in argument ~A "i)) (push (first i) arg-variables) (let ((type (second i))) (push (second i) arg-types) (push (if (ffi::foreign-elt-type-p type) (foreign-elt-type-code type) (add-object type)) arg-type-constants))) (push (list name c-name (add-object name) return-type (reverse arg-types) (reverse arg-type-constants) call-type) *callbacks*) (c1expr `(progn (defun ,name ,(reverse arg-variables) ,@body) (si::put-sysprop ',name :callback (list (ffi:c-inline () () :object ,(format nil "ecl_make_foreign_data(@':pointer-void,0,~a)" c-name) :one-liner t))))) ))) (defconstant +foreign-elt-type-codes+ '((:char . "ECL_FFI_CHAR") (:unsigned-char . "ECL_FFI_UNSIGNED_CHAR") (:byte . "ECL_FFI_BYTE") (:unsigned-byte . "ECL_FFI_UNSIGNED_BYTE") (:short . "ECL_FFI_SHORT") (:unsigned-short . "ECL_FFI_UNSIGNED_SHORT") (:int . "ECL_FFI_INT") (:unsigned-int . "ECL_FFI_UNSIGNED_INT") (:long . "ECL_FFI_LONG") (:unsigned-long . "ECL_FFI_UNSIGNED_LONG") #+:uint16-t #+:uint16-t (:int16-t . "ECL_FFI_INT16_T") (:uint16-t . "ECL_FFI_UINT16_T") #+:uint32-t #+:uint32-t (:int32-t . "ECL_FFI_INT32_T") (:uint32-t . "ECL_FFI_UINT32_T") #+:uint64-t #+:uint64-t (:int64-t . "ECL_FFI_INT64_T") (:uint64-t . "ECL_FFI_UINT64_T") #+:long-long #+:long-long (:long-long . "ECL_FFI_LONG_LONG") (:unsigned-long-long . "ECL_FFI_UNSIGNED_LONG_LONG") (:pointer-void . "ECL_FFI_POINTER_VOID") (:cstring . "ECL_FFI_CSTRING") (:object . "ECL_FFI_OBJECT") (:float . "ECL_FFI_FLOAT") (:double . "ECL_FFI_DOUBLE") (:void . "ECL_FFI_VOID"))) (defun foreign-elt-type-code (type) (let ((x (assoc type +foreign-elt-type-codes+))) (unless x (cmperr "~a is not a valid elementary FFI type" type)) (cdr x))) (defun t3-defcallback (lisp-name c-name c-name-constant return-type arg-types arg-type-constants call-type &aux (return-p t)) (cond ((member return-type '(nil :void)) (setf return-p nil)) ((ffi::foreign-elt-type-p return-type)) ((and (consp return-type) (member (first return-type) '(* array))) (setf return-type :pointer-void)) (t (cmperr "DEFCALLBACK does not support complex return types such as ~A" return-type))) (let ((return-type-name (rep-type->c-name (ffi::%convert-to-arg-type return-type))) (fmod (case call-type (:cdecl "") (:stdcall "__stdcall ") (t (cmperr "DEFCALLBACK does not support ~A as calling convention" call-type))))) (wt-nl-h "static " return-type-name " " fmod c-name "(") (wt-nl1 "static " return-type-name " " fmod c-name "(") (loop for n from 0 and type in arg-types with comma = "" do (progn (wt-h comma (rep-type->c-name (ffi::%convert-to-arg-type type)) " var" n) (wt comma (rep-type->c-name (ffi::%convert-to-arg-type type)) " var" n) (setf comma ","))) (wt ")") (wt-h ");") (wt-nl-open-brace) (when return-p (wt-nl return-type-name " output;")) (wt-nl "const cl_env_ptr cl_env_copy = ecl_process_env();") (wt-nl "cl_object aux;") (wt-nl "ECL_BUILD_STACK_FRAME(cl_env_copy, frame, helper)") (loop for n from 0 and type in arg-types and ct in arg-type-constants do (if (stringp ct) (wt-nl "ecl_stack_frame_push(frame,ecl_foreign_data_ref_elt(&var" n "," ct "));") (wt-nl "ecl_stack_frame_push(frame,ecl_make_foreign_data(&var" n "," ct "," (ffi:size-of-foreign-type type) "));"))) (wt-nl "aux = ecl_apply_from_stack_frame(frame," "ecl_fdefinition(" c-name-constant "));") (wt-nl "ecl_stack_frame_close(frame);") (when return-p (wt-nl "ecl_foreign_data_set_elt(&output," (foreign-elt-type-code return-type) ",aux);") (wt-nl "return output;")) (wt-nl-close-brace))) ecl-16.1.2/src/cmp/cmpclos.lsp000066400000000000000000000127271266352375300161170ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: C -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; CMPCLOS. CLOS related optimizations. ;;;; Copyright (c) 2008. Juan Jose Garcia-Ripol ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. (in-package "COMPILER") ;;; ;;; GENERIC OPTIMIZATION ;;; (defun maybe-optimize-generic-function (fname args) (when (fboundp fname) (let ((gf (fdefinition fname))) (when (typep gf 'standard-generic-function) ;;(check-generic-function-args gf args) (when (policy-inline-slot-access) (maybe-optimize-slot-accessor fname gf args)))))) ;;; ;;; PRECOMPUTE APPLICABLE METHODS ;;; ;;; Computes a list of methods that would apply given what we know ;;; about their arguments. Since the types are not exact, we have to ;;; use subtypep. We could speed this up if we could precompute the ;;; classes for the c-args. ;;; (defun precompute-applicable-methods (methods c-args) (flet ((applicable-method-p (m) (loop for specializer in (clos:method-specializers m) for arg in c-args always (let ((arg-type (c1form-type arg))) (subtypep arg-type (if (consp specializer) `(member ,(second specializer)) specializer)))))) (delete-if-not #'applicable-method-p methods))) ;;; ;;; SLOT ACCESSORS ;;; ;;; The following functions deal with an ECL extension, which are ;;; sealed slots. These slots have a fixed location which is ;;; inherited by subclasses. They normally appear when you add the ;;; option (:sealedp t) to a class definition. ;;; ;;; When ECL detects that you call an accessor to such a slot, it can ;;; optimize the operation, using a direct access based on the ;;; position of the slot. This optimization is only active when the ;;; safety levels are low, because it prevents you from changing the ;;; class hierarchy. ;;; (defun find-slot-accessors (gf) (loop for method in (clos:generic-function-methods gf) with readers = '() with writers = '() with reader-class = (find-class 'clos:standard-reader-method) with writer-class = (find-class 'clos:standard-writer-method) do (let ((method-class (class-of method))) (cond ((si::subclassp method-class reader-class) (push method readers)) ((si::subclassp method-class writer-class) (push method writers)))) finally (return (values readers writers)))) (defun maybe-optimize-slot-accessor (fname gf args) (multiple-value-bind (readers writers) (find-slot-accessors gf) ;(format t "~%;;; Found ~D readers and ~D writers for ~A" (length readers) (length writers) fname) (cond ((and readers writers) (cmpwarn "When analyzing generic function ~A found both slot reader and writer methods" fname)) ((not (or readers writers)) nil) ((/= (length args) (length (clos::generic-function-spec-list gf))) (cmpwarn "Too many arguments for generic function ~A" fname) nil) (readers (try-optimize-slot-reader readers args)) (writers (try-optimize-slot-writer writers args))))) (defun try-optimize-slot-reader (readers args) (let* ((object (first args)) (c-object (c1expr object)) (readers (precompute-applicable-methods readers (list c-object)))) ;(format t "~%;;; Found ~D really applicable reader" (length readers)) (when (= (length readers) 1) (let ((reader (first readers))) (when (typep reader 'clos:standard-reader-method) (let* ((slotd (clos:accessor-method-slot-definition reader)) (index (clos::safe-slot-definition-location slotd))) (when (si::fixnump index) `(clos::safe-instance-ref ,object ,index)))))))) (defun try-optimize-slot-writer (orig-writers args) (let* ((c-args (mapcar #'c1expr args)) (writers (precompute-applicable-methods orig-writers c-args))) ;(format t "~%;;; Found ~D really applicable writer" (length writers)) (when (= (length writers) 1) (let ((writer (first writers))) (when (typep writer 'clos:standard-writer-method) (let* ((slotd (clos:accessor-method-slot-definition writer)) (index (clos::safe-slot-definition-location slotd))) (when (si::fixnump index) `(si::instance-set ,(second args) ,index ,(first args))))))))) #+(or) (progn . #.(loop for var in '(clos::+standard-generic-function-slots+ clos::+standard-method-slots+ clos::+standard-class-slots+ clos::+class-slots+) for slot-list = (symbol-value var) nconc (loop for i from 0 for slot-definition in slot-list for accessor = (cadr (member :accessor slot-definition)) when accessor collect `(define-compiler-macro ,accessor (&whole whole obj &environment env) (if (policy-inline-slot-access env) `(clos::safe-instance-ref ,obj ,,i) whole))))) ecl-16.1.2/src/cmp/cmpct.lsp000066400000000000000000000156671266352375300155730ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: C -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; CMPCT -- Optimizer for several constant values ;;;; Copyright (c) 2003, Juan Jose Garcia Ripoll. ;;;; ;;;; ECoLisp is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. (in-package "COMPILER") (defparameter +optimizable-constants+ '()) (defun c1constant-value (val &key always only-small-values) (cond ((let ((x (assoc val *optimizable-constants*))) (when x (pushnew "#include " *clines-string-list*) (setf x (cdr x)) (if (listp x) (c1expr x) x)))) ((eq val nil) (c1nil)) ((eq val t) (c1t)) ((sys::fixnump val) (make-c1form* 'LOCATION :type 'FIXNUM :args (list 'FIXNUM-VALUE val))) ((characterp val) (make-c1form* 'LOCATION :type 'CHARACTER :args (list 'CHARACTER-VALUE (char-code val)))) ((typep val 'DOUBLE-FLOAT) (when (and (ext:float-nan-p val) (not only-small-values)) (cmperr "Cannot externalize value ~A" val)) (make-c1form* 'LOCATION :type 'DOUBLE-FLOAT :args (list 'DOUBLE-FLOAT-VALUE val (add-object val)))) ((typep val 'SINGLE-FLOAT) (when (and (ext:float-nan-p val) (not only-small-values)) (cmperr "Cannot externalize value ~A" val)) (make-c1form* 'LOCATION :type 'SINGLE-FLOAT :args (list 'SINGLE-FLOAT-VALUE val (add-object val)))) ((typep val 'LONG-FLOAT) (when (and (ext:float-nan-p val) (not only-small-values)) (cmperr "Cannot externalize value ~A" val)) (make-c1form* 'LOCATION :type 'LONG-FLOAT :args (list 'LONG-FLOAT-VALUE val (add-object val)))) #+sse2 ((typep val 'EXT:SSE-PACK) (c1constant-value/sse val)) (only-small-values nil) (always (make-c1form* 'LOCATION :type (object-type val) :args (add-object val))) (t nil))) #+sse2 (defun c1constant-value/sse (value) (let* ((bytes (ext:sse-pack-to-vector value '(unsigned-byte 8))) (elt-type (ext:sse-pack-element-type value))) (multiple-value-bind (wrapper rtype) (case elt-type (single-float (values "_mm_castsi128_ps" :float-sse-pack)) (double-float (values "_mm_castsi128_pd" :double-sse-pack)) (otherwise (values "" :int-sse-pack))) `(c-inline () () ,rtype ,(format nil "~A(_mm_setr_epi8(~{~A~^,~}))" wrapper (coerce bytes 'list)) :one-liner t :side-effects nil)))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; ;;; KNOWN OPTIMIZABLE CONSTANTS ;;; (defun make-single-constant-optimizer (name c-value) (cond ((symbolp name) (let* ((value (symbol-value name)) (type (lisp-type->rep-type (type-of value)))) (cons value `(c-inline () () ,type ,c-value :one-liner t :side-effects nil)))) ((floatp name) (let* ((value name) (type (type-of value)) (loc-type (case type (single-float 'single-float-value) (double-float 'double-float-value) (long-float 'long-float-value))) (location (make-vv :location c-value :value value))) (cons value (make-c1form* 'LOCATION :type type :args (list loc-type value location))))) (t (cons name (make-c1form* 'LOCATION :type (type-of name) :args (make-vv :location c-value :value name)))))) (defun make-optimizable-constants (machine) (loop for (value name) in (optimizable-constants-list machine) collect (make-single-constant-optimizer value name))) (defun optimizable-constants-list (machine) (append ;; Constants that appear everywhere '( ;; Order is important: on platforms where 0.0 and -0.0 are the same ;; the last one is prioritized. (#.(coerce 0 'single-float) "cl_core.singlefloat_zero") (#.(coerce 0 'double-float) "cl_core.doublefloat_zero") (#.(coerce -0.0 'single-float) "cl_core.singlefloat_minus_zero") (#.(coerce -0.0 'double-float) "cl_core.doublefloat_minus_zero") #+long-float (#.(coerce 0 'long-float) "cl_core.longfloat_zero") #+long-float (#.(coerce -0.0 'long-float) "cl_core.longfloat_minus_zero") ;; We temporarily remove this constant, because the bytecodes compiler ;; does not know how to externalize it. ;;(#.(si::standard-readtable) "cl_core.standard_readtable") (#.(find-package :cl) "cl_core.lisp_package") (#.(find-package :cl-user) "cl_core.user_package") (#.(find-package :keyword) "cl_core.keyword_package") (#.(find-package :clos) "cl_core.clos_package") #+threads (#.(find-package :mp) "cl_core.mp_package") ) (when (eq machine +default-machine+) ;; Constants which are not portable `((MOST-POSITIVE-SHORT-FLOAT "FLT_MAX") (MOST-POSITIVE-SINGLE-FLOAT "FLT_MAX") (MOST-NEGATIVE-SHORT-FLOAT "-FLT_MAX") (MOST-NEGATIVE-SINGLE-FLOAT "-FLT_MAX") (LEAST-POSITIVE-SHORT-FLOAT "FLT_MIN") (LEAST-POSITIVE-SINGLE-FLOAT "FLT_MIN") (LEAST-POSITIVE-NORMALIZED-SHORT-FLOAT "FLT_MIN") (LEAST-POSITIVE-NORMALIZED-SINGLE-FLOAT" FLT_MIN") (LEAST-NEGATIVE-SHORT-FLOAT "-FLT_MIN") (LEAST-NEGATIVE-SINGLE-FLOAT "-FLT_MIN") (LEAST-NEGATIVE-NORMALIZED-SHORT-FLOAT "-FLT_MIN") (LEAST-NEGATIVE-NORMALIZED-SINGLE-FLOAT "-FLT_MIN") (MOST-POSITIVE-DOUBLE-FLOAT "DBL_MAX") (MOST-NEGATIVE-DOUBLE-FLOAT "-DBL_MAX") (LEAST-POSITIVE-DOUBLE-FLOAT "DBL_MIN") (LEAST-POSITIVE-NORMALIZED-DOUBLE-FLOAT "DBL_MIN") (LEAST-NEGATIVE-DOUBLE-FLOAT "-DBL_MIN") (LEAST-NEGATIVE-NORMALIZED-DOUBLE-FLOAT "-DBL_MIN") (SHORT-FLOAT-POSITIVE-INFINITY "INFINITY") (SINGLE-FLOAT-POSITIVE-INFINITY "INFINITY") (DOUBLE-FLOAT-POSITIVE-INFINITY "INFINITY") (SHORT-FLOAT-NEGATIVE-INFINITY "-INFINITY") (SINGLE-FLOAT-NEGATIVE-INFINITY "-INFINITY") (DOUBLE-FLOAT-NEGATIVE-INFINITY "-INFINITY") #+long-float ,@'( (MOST-POSITIVE-LONG-FLOAT "LDBL_MAX") (MOST-NEGATIVE-LONG-FLOAT "-LDBL_MAX") (LEAST-POSITIVE-LONG-FLOAT "LDBL_MIN") (LEAST-POSITIVE-NORMALIZED-LONG-FLOAT" LDBL_MIN") (LEAST-NEGATIVE-LONG-FLOAT "-LDBL_MIN") (LEAST-NEGATIVE-NORMALIZED-LONG-FLOAT "-LDBL_MIN") (LONG-FLOAT-POSITIVE-INFINITY "INFINITY") (LONG-FLOAT-NEGATIVE-INFINITY "-INFINITY") ))))) ecl-16.1.2/src/cmp/cmpdefs.lsp000066400000000000000000000065561266352375300161030ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: C -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; Copyright (c) 2010, Juan Jose Garcia-Ripoll ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. ;;;; CMPDEF -- Definitions created at compile / configuration time (in-package "COMPILER") ;;; This is copied into each .h file generated, EXCEPT for system-p calls. ;;; The constant string *include-string* is the content of file "ecl.h". ;;; Here we use just a placeholder: it will be replaced with sed. (defvar *cmpinclude* "") (defvar *cc* "@ECL_CC@" "This variable controls how the C compiler is invoked by ECL. The default value is \"cc -I. -I/usr/local/include/\". The second -I option names the directory where the file ECL.h has been installed. One can set the variable appropriately adding for instance flags which the C compiler may need to exploit special hardware features (e.g. a floating point coprocessor).") (defvar *ld* "@ECL_CC@" "This variable controls the linker which is used by ECL.") (defvar *ranlib* "@RANLIB@" "Name of the `ranlib' program on the hosting platform.") (defvar *ar* "@AR@" "Name of the `AR' program on the hosting platform.") (defvar *cc-flags* "@CPPFLAGS@ @CFLAGS@ @ECL_CFLAGS@") (defvar *cc-optimize* #-msvc "-O2" #+msvc "@CFLAGS_OPTIMIZE@") (defvar *ld-format* #-msvc "~A -o ~S -L~S ~{~S ~} ~@[~S~]~{ '~A'~} ~A" #+msvc "~A -Fe~S~* ~{~S ~} ~@[~S~]~{ '~A'~} ~A") (defvar *cc-format* (cond ((member :msvc *features*) "~A -I. \"-I~A\" ~A ~:[~*~;~A~] -w -c \"~A\" -o \"~A\"~{ '~A'~}") ((member :nacl *features*) ;; pnacl-clang doesn't support -w "~A -I. \"-I~A\" ~A ~:[~*~;~A~] -c \"~A\" -o \"~A\"~{ '~A'~}") (t "~A -I. \"-I~A\" ~A ~:[~*~;~A~] -w -c \"~A\" -o \"~A\"~{ '~A'~}"))) (defvar *cc-is-cxx* @CC_IS_CXX@ "ECL's compiler is really the C++ compiler, not a C compiler.") #-dlopen (defvar *ld-flags* "@LDFLAGS@ -lecl @CORE_LIBS@ @FASL_LIBS@ @LIBS@") #+dlopen (defvar *ld-flags* #-msvc "@LDFLAGS@ -lecl @FASL_LIBS@ @LIBS@" #+msvc "@LDFLAGS@ ecl.lib @CLIBS@") #+dlopen (defvar *ld-shared-flags* #-msvc "@SHARED_LDFLAGS@ @LDFLAGS@ -lecl @FASL_LIBS@ @LIBS@" #+msvc "@SHARED_LDFLAGS@ @LDFLAGS@ ecl.lib @CLIBS@") #+dlopen (defvar *ld-bundle-flags* #-msvc "@BUNDLE_LDFLAGS@ @LDFLAGS@ -lecl @FASL_LIBS@ @LIBS@" #+msvc "@BUNDLE_LDFLAGS@ @LDFLAGS@ ecl.lib @CLIBS@") (defvar +shared-library-prefix+ "@SHAREDPREFIX@") (defvar +shared-library-extension+ "@SHAREDEXT@") (defvar +shared-library-format+ "@SHAREDPREFIX@~a.@SHAREDEXT@") (defvar +static-library-prefix+ "@LIBPREFIX@") (defvar +static-library-extension+ "@LIBEXT@") (defvar +static-library-format+ "@LIBPREFIX@~a.@LIBEXT@") (defvar +object-file-extension+ "@OBJEXT@") (defvar +executable-file-format+ "~a@EXEEXT@") (defvar *ecl-include-directory* @includedir\@) (defvar *ecl-library-directory* @libdir\@) (defvar *ld-rpath* (let ((x "@ECL_LDRPATH@")) (and (plusp (length x)) (format nil x *ecl-library-directory*)))) ecl-16.1.2/src/cmp/cmpenv-api.lsp000066400000000000000000000163651266352375300165200ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: C -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; Copyright (c) 2009, Juan Jose Garcia-Ripoll. ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. ;;;; ;;;; CMPENVAPI -- API for creating and manipulating environments ;;;; (in-package #-new-cmp "COMPILER" #+new-cmp "C-ENV") (defun cmp-env-root (&optional (env *cmp-env-root*)) "Provide a root environment for toplevel forms storing all declarations that are susceptible to be changed by PROCLAIM." (let* ((env (cmp-env-copy env))) (add-default-optimizations env))) (defun cmp-env-copy (&optional (env *cmp-env*)) (cons (car env) (cdr env))) (defmacro cmp-env-variables (&optional (env '*cmp-env*)) `(car ,env)) (defmacro cmp-env-functions (&optional (env '*cmp-env*)) `(cdr ,env)) #-new-cmp (defun cmp-env-cleanups (env) (loop with specials = '() with end = (cmp-env-variables env) with cleanup-forms = '() with aux for records-list on (cmp-env-variables *cmp-env*) until (eq records-list end) do (let ((record (first records-list))) (cond ((atom record)) ((and (symbolp (first record)) (eq (second record) :special)) (push (fourth record) specials)) ((eq (first record) :cleanup) (push (second record) cleanup-forms)))) finally (progn (unless (eq records-list end) (error "Inconsistency in environment.")) (return (values specials (apply #'nconc (mapcar #'copy-list cleanup-forms))))))) (defun cmp-env-register-var (var &optional (env *cmp-env*) (boundp t)) (push (list (var-name var) (if (member (var-kind var) '(special global)) :special t) boundp var) (cmp-env-variables env)) env) (defun cmp-env-declare-special (name &optional (env *cmp-env*)) (cmp-env-register-var (c::c1make-global-variable name :warn nil :kind 'SPECIAL) env nil) env) (defun cmp-env-add-declaration (type arguments &optional (env *cmp-env*)) (push (list* :declare type arguments) (cmp-env-variables env)) env) (defun cmp-env-extend-declaration (type arguments &optional (env *cmp-env*) default) (let ((x (cmp-env-search-declaration type env default))) (cmp-env-add-declaration type (append arguments x) env) env)) (defun cmp-env-register-function (fun &optional (env *cmp-env*)) (push (list (fun-name fun) 'function fun) (cmp-env-functions env)) env) (defun cmp-env-register-global-macro (name function) (cmp-env-register-macro name function *cmp-env*) (cmp-env-register-macro name function *cmp-env-root*) (values)) (defun cmp-env-register-macro (name function &optional (env *cmp-env*)) (push (list name 'si::macro function) (cmp-env-functions env)) env) (defun cmp-env-register-ftype (name declaration &optional (env *cmp-env*)) (push (list* :declare name declaration) (cmp-env-functions env)) env) (defun cmp-env-register-symbol-macro (name form &optional (env *cmp-env*)) (push (list name 'si::symbol-macro #'(lambda (whole env) (declare (ignore env whole)) form)) (cmp-env-variables env)) env) (defun cmp-env-register-block (blk &optional (env *cmp-env*)) (push (list :block (blk-name blk) blk) (cmp-env-variables env)) env) (defun cmp-env-register-tag (name tag &optional (env *cmp-env*)) (push (list :tag (list name) tag) (cmp-env-variables env)) env) (defun cmp-env-register-cleanup (form &optional (env *cmp-env*)) (push (list :cleanup (copy-list form)) (cmp-env-variables env)) env) (defun cmp-env-search-function (name &optional (env *cmp-env*)) (let ((ccb nil) (clb nil) (unw nil) (found nil)) (dolist (record (cmp-env-functions env)) (cond ((eq record 'CB) (setf ccb t)) ((eq record 'LB) (setf clb t)) ((eq record 'UNWIND-PROTECT) (setf unw t)) ((atom record) (baboon :format-control "Uknown record found in environment~%~S" :format-arguments (list record))) ;; We have to use EQUAL because the name can be a list (SETF whatever) ((equal (first record) name) (setf found (first (last record))) (return)))) (values found ccb clb unw))) (defun cmp-env-search-variables (type name env) (let ((ccb nil) (clb nil) (unw nil) (found nil)) (dolist (record (cmp-env-variables env)) (cond ((eq record 'CB) (setf ccb t)) ((eq record 'LB) (setf clb t)) ((eq record 'UNWIND-PROTECT) (setf unw t)) ((atom record) (baboon :format-control "Uknown record found in environment~%~S" :format-arguments (list record))) ((not (eq (first record) type))) ((eq type :block) (when (eq name (second record)) (setf found record) (return))) ((eq type :tag) (when (member name (second record) :test #'eql) (setf found record) (return))) ((eq (second record) 'si::symbol-macro) (when (eq name 'si::symbol-macro) (setf found record)) (return)) (t (setf found record) (return)))) (values (first (last found)) ccb clb unw))) (defun cmp-env-search-block (name &optional (env *cmp-env*)) (cmp-env-search-variables :block name env)) (defun cmp-env-search-tag (name &optional (env *cmp-env*)) (cmp-env-search-variables :tag name env)) (defun cmp-env-search-symbol-macro (name &optional (env *cmp-env*)) (cmp-env-search-variables name 'si::symbol-macro env)) (defun cmp-env-search-var (name &optional (env *cmp-env*)) (cmp-env-search-variables name t env)) (defun cmp-env-search-macro (name &optional (env *cmp-env*)) (let ((f (cmp-env-search-function name env))) (if (functionp f) f nil))) (defun cmp-env-search-ftype (name &optional (env *cmp-env*)) (dolist (i env nil) (when (and (consp i) (eq (pop i) :declare) (same-fname-p (pop i) name)) (return i)))) (defun cmp-env-mark (mark &optional (env *cmp-env*)) (cons (cons mark (car env)) (cons mark (cdr env)))) (defun cmp-env-new-variables (new-env old-env) (loop for i in (ldiff (cmp-env-variables new-env) (cmp-env-variables old-env)) when (and (consp i) (var-p (fourth i))) collect (fourth i))) (defun cmp-env-search-declaration (kind &optional (env *cmp-env*) default) (loop for i in (car env) when (and (consp i) (eq (first i) :declare) (eq (second i) kind)) return (cddr i) finally (return default))) ecl-16.1.2/src/cmp/cmpenv-declaim.lsp000066400000000000000000000050051266352375300173320ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: C -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. ;;;; Copyright (c) 1990, Giuseppe Attardi. ;;;; Copyright (c) 2010, Juan Jose Garcia-Ripoll ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. ;;;; ;;;; CMPENV-DECLAIM -- Proclamations local to the current file ;;;; ;;;; One implementation of DECLAIM that uses the compiler environment ;;;; providing a "base" set of entries that all other environments ;;;; stem from. ;;;; (in-package #-ecl-new "COMPILER" #+ecl-new "C-ENV") (defun process-declaim-args (args) (flet ((add-variables (env types specials) (loop for name in specials unless (assoc name types) do (let ((v (c1make-global-variable name :kind 'special))) (setf env (cmp-env-register-var v env nil)))) (loop for (name . type) in types for specialp = (or (sys:specialp name) (member name specials)) for kind = (if specialp 'SPECIAL 'GLOBAL) for v = (c1make-global-variable name :type type :kind kind) do (setf env (cmp-env-register-var v env nil))) env)) (multiple-value-bind (body specials types ignored others doc all) (c1body `((DECLARE ,@args)) nil) (when ignored (cmpwarn-style "IGNORE/IGNORABLE declarations in DECLAIM are ignored")) (reduce #'add-one-declaration others :initial-value (add-variables *cmp-env* types specials)) (reduce #'add-one-declaration others :initial-value (add-variables *cmp-env-root* types specials))))) (defmacro declaim (&rest declarations) `(locally (declare (notinline mapc)) (ext:with-backend :c/c++ (eval-when (:compile-toplevel) (c::process-declaim-args ',declarations)) :bytecodes (eval-when (:compile-toplevel) (mapc 'proclaim ',declarations))) (eval-when (:load-toplevel :execute) (mapc 'proclaim ',declarations)))) (defmacro ext::c-declaim (&rest declarations) `(ext:with-backend :c/c++ (eval-when (:compile-toplevel) (c::process-declaim-args ',declarations)))) ecl-16.1.2/src/cmp/cmpenv-declare.lsp000066400000000000000000000175621266352375300173460ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: C -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; Copyright (c) 2010, Juan Jose Garcia-Ripoll ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. ;;;; ;;;; CMPENV-DECLARE -- Declarations for the compiler ;;;; ;;;; Extract, process and incorporate declarations into the compiler ;;;; environment. Unlike proclamations, these are local to the current ;;;; compiled file and do not propagate beyond it. ;;;; (in-package #-ecl-new "COMPILER" #+ecl-new "C-ENV") (defun valid-form-p (x &optional test) (and (si::proper-list-p x) (or (null test) (every test x)))) (defun type-name-p (name) (or (get-sysprop name 'SI::DEFTYPE-DEFINITION) (find-class name nil) (get-sysprop name 'SI::STRUCTURE-TYPE))) (defun validate-alien-declaration (names-list error) (dolist (new-declaration names-list) (unless (symbolp new-declaration) (cmperr "The declaration ~s is not a symbol" new-declaration)) (when (type-name-p new-declaration) (cmperr "Symbol name ~S cannot be both the name of a type and of a declaration" new-declaration)))) (defun alien-declaration-p (name &optional (env *cmp-env*)) (and (symbolp name) (member name (cmp-env-search-declaration 'alien env si::*alien-declarations*) :test 'eq))) (defun parse-ignore-declaration (decl-args expected-ref-number tail) (declare (si::c-local)) (loop for name in decl-args do (if (symbolp name) (push (cons name expected-ref-number) tail) (cmpassert (and (consp name) (= (length name) 2) (eq (first name) 'function)) "Invalid argument to IGNORE/IGNORABLE declaration:~&~A" name))) tail) (defun collect-declared (type var-list tail) (declare (si::c-local)) (cmpassert (valid-form-p var-list #'symbolp) "Syntax error in declaration ~s" `(TYPE ,type ,var-list)) (loop for var-name in var-list do (push (cons var-name type) tail)) tail) (defun c1body (body doc-p) "Split a function body into a list of forms, a set of declarations, and a possible documentation string (only accepted when DOC-P is true)." (multiple-value-bind (all-declarations body doc specials) (si:process-declarations body doc-p) (loop with others = '() with types = '() with ignored = '() for decl in all-declarations for decl-name = (first decl) for decl-args = (rest decl) do (cmpassert (and (valid-form-p decl-args) (or (symbolp decl-name) (and (consp decl-name) (valid-type-specifier decl-name)))) "Syntax error in declaration ~s" decl) do (case decl-name (SPECIAL) (IGNORE (cmpassert (valid-form-p decl-args) "Syntax error in declaration ~s" decl) (setf ignored (parse-ignore-declaration decl-args -1 ignored))) (IGNORABLE (cmpassert (valid-form-p decl-args) "Syntax error in declaration ~s" decl) (setf ignored (parse-ignore-declaration decl-args 0 ignored))) (TYPE (cmpassert (and (consp decl-args) (valid-form-p (rest decl-args) #'symbolp)) "Syntax error in declaration ~s" decl) (setf types (collect-declared (first decl-args) (rest decl-args) types))) (OBJECT (cmpassert (valid-form-p decl-args #'symbolp) "Syntax error in declaration ~s" decl) (setf types (collect-declared 'OBJECT decl-args types))) ((OPTIMIZE FTYPE INLINE NOTINLINE DECLARATION SI::C-LOCAL SI::C-GLOBAL DYNAMIC-EXTENT IGNORABLE VALUES SI::NO-CHECK-TYPE POLICY-DEBUG-IHS-FRAME :READ-ONLY) (push decl others)) (SI:FUNCTION-BLOCK-NAME) (otherwise (if (or (alien-declaration-p decl-name) (policy-declaration-name-p decl-name)) (push decl others) (multiple-value-bind (ok type) (if (machine-c-type-p decl-name) (values t decl-name) (valid-type-specifier decl-name)) (cmpassert ok "Unknown declaration specifier ~s" decl-name) (setf types (collect-declared type decl-args types)))))) finally (return (values body specials types ignored (nreverse others) doc all-declarations))))) (defun add-one-declaration (env decl) "Add to the environment one declarations which is not type, ignorable or special variable declarations, as these have been extracted before." (case (car decl) (OPTIMIZE (cmp-env-add-optimizations (rest decl) env)) (POLICY-DEBUG-IHS-FRAME (let ((flag (or (rest decl) '(t)))) (if *current-function* (progn (cmp-env-add-declaration 'policy-debug-ihs-frame flag (fun-cmp-env *current-function*)) env) (cmp-env-add-declaration 'policy-debug-ihs-frame flag env)))) (FTYPE (if (atom (rest decl)) (cmpwarn "Syntax error in declaration ~a" decl) (multiple-value-bind (type-name args) (si::normalize-type (second decl)) (if (eq type-name 'FUNCTION) (dolist (v (cddr decl)) (setf env (add-function-declaration v args env))) (cmpwarn "In an FTYPE declaration, found ~A which is not a function type." (second decl))))) env) (INLINE (loop for name in (rest decl) do (setf env (declare-inline name env))) env) (NOTINLINE (loop for name in (rest decl) do (setf env (declare-notinline name env))) env) (DECLARATION (validate-alien-declaration (rest decl) #'cmperr) (cmp-env-extend-declaration 'alien (rest decl) env si::*alien-declarations*)) ((SI::C-LOCAL SI::C-GLOBAL SI::NO-CHECK-TYPE :READ-ONLY) env) ((DYNAMIC-EXTENT IGNORABLE SI:FUNCTION-BLOCK-NAME) ;; FIXME! SOME ARE IGNORED! env) (otherwise (cond ((alien-declaration-p (first decl) env) env) ((maybe-add-policy decl env)) (t (cmpwarn "Unknown declaration specifier ~s" (first decl)) env))))) (defun symbol-macro-declaration-p (name type) (let* ((record (cmp-env-search-symbol-macro name))) (when (and record (functionp record)) (let* ((expression (funcall record name nil))) (cmp-env-register-symbol-macro name `(the ,type ,expression))) t))) (defun check-vdecl (vnames ts is) (loop for (name . type) in ts unless (or (member name vnames :test #'eq) (symbol-macro-declaration-p name type)) do (cmpwarn "Declaration of type~&~4T~A~&was found for not bound variable ~s." type name)) (loop for (name . expected-uses) in is unless (or (member name vnames :test #'eq) (cmp-env-search-symbol-macro name) (cmp-env-search-macro name)) do (cmpwarn (if (minusp expected-uses) "IGNORE declaration was found for not bound variable ~s." "IGNORABLE declaration was found for not bound variable ~s.") name))) ecl-16.1.2/src/cmp/cmpenv-fun.lsp000066400000000000000000000153741266352375300165360ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: C -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; Copyright (c) 2009, Juan Jose Garcia-Ripoll. ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. ;;;; ;;;; CMPTYPE-PROP -- Type propagation basic routines and database ;;;; (in-package #-new-cmp "COMPILER" #+new-cmp "C-ENV") (defun function-arg-types (arg-types &aux (types nil)) (do ((al arg-types (cdr al))) ((or (endp al) (member (car al) '(&optional &rest &key))) (nreverse types)) (declare (object al)) (push (car al) types))) ;;; The valid return type declaration is: ;;; (( VALUES {type}* )) or ( {type}* ). (defun proclaim-function (fname decl) (if (si:valid-function-name-p fname) (let* ((arg-types '*) (return-types '*) (l decl)) (cond ((null l)) ((consp l) (setf arg-types (pop l))) (t (warn "The function proclamation ~s ~s is not valid." fname decl))) (cond ((null l)) ((or (atom l) (rest l)) (warn "The function proclamation ~s ~s is not valid." fname decl)) (t (setf return-types (first l)))) (when (eq arg-types '()) (setf arg-types '(&optional))) (if (eq arg-types '*) (rem-sysprop fname 'PROCLAIMED-ARG-TYPES) (put-sysprop fname 'PROCLAIMED-ARG-TYPES arg-types)) (if (member return-types '(* (VALUES &rest t)) :test #'equalp) (rem-sysprop fname 'PROCLAIMED-RETURN-TYPE) (put-sysprop fname 'PROCLAIMED-RETURN-TYPE return-types))) (warn "The function proclamation ~s ~s is not valid." fname decl))) (defun add-function-declaration (fname ftype &optional (env *cmp-env*)) (if (si::valid-function-name-p fname) (let ((fun (cmp-env-search-function fname))) (if (functionp fun) (warn "Found function declaration for local macro ~A" fname) (cmp-env-register-ftype fname ftype env))) (warn "In (DECLARE (FTYPE ...)): ~s is not a valid function name" fname)) env) (defun get-arg-types (fname &optional (env *cmp-env*) (may-be-global t)) (let ((x (cmp-env-search-ftype fname env))) (if x (let ((arg-types (first x))) (unless (eq arg-types '*) (values arg-types t))) (when may-be-global (let ((fun (cmp-env-search-function fname env))) (when (or (null fun) (and (fun-p fun) (fun-global fun))) (sys:get-sysprop fname 'PROCLAIMED-ARG-TYPES))))))) (defun get-return-type (fname &optional (env *cmp-env*)) (let ((x (cmp-env-search-ftype fname env))) (if x (let ((return-types (second x))) (unless (eq return-types '*) (values return-types t))) (let ((fun (cmp-env-search-function fname env))) (when (or (null fun) (and (fun-p fun) (fun-global fun))) (sys:get-sysprop fname 'PROCLAIMED-RETURN-TYPE)))))) (defun get-local-arg-types (fun &optional (env *cmp-env*)) (let ((x (cmp-env-search-ftype (fun-name fun) env))) (if x (values (first x) t) (values nil nil)))) (defun get-local-return-type (fun &optional (env *cmp-env*)) (let ((x (cmp-env-search-ftype (fun-name fun)))) (if x (values (second x) t) (values nil nil)))) (defun get-proclaimed-narg (fun &optional (env *cmp-env*)) (multiple-value-bind (arg-list found) (get-arg-types fun env) (if found (loop for type in arg-list with minarg = 0 and maxarg = 0 and in-optionals = nil do (cond ((member type '(* &rest &key &allow-other-keys) :test #'eq) (return (values minarg call-arguments-limit))) ((eq type '&optional) (setf in-optionals t maxarg minarg)) (in-optionals (incf maxarg)) (t (incf minarg) (incf maxarg))) finally (return (values minarg maxarg found))) (values 0 call-arguments-limit found)))) ;;; Proclamation and declaration handling. (defun declare-inline (fname &optional (env *cmp-env*) (definition t)) (unless (si::valid-function-name-p fname) (cmperr "Not a valid argument to INLINE declaration~%~4I~A" fname)) (cmp-env-extend-declaration 'INLINE (list (cons fname definition)) env)) (defun declare-notinline (fname &optional (env *cmp-env*)) (declare-inline fname env nil)) (defun proclaim-inline (fname-list) (dolist (fun fname-list) (unless (si::valid-function-name-p fun) (error "Not a valid function name ~s in INLINE proclamation" fun)) (unless (sys:get-sysprop fun 'INLINE) (sys:put-sysprop fun 'INLINE t) (sys:rem-sysprop fun 'NOTINLINE)))) (defun proclaim-notinline (fname-list) (dolist (fun fname-list) (unless (si::valid-function-name-p fun) (error "Not a valid function name ~s in NOTINLINE proclamation" fun)) (sys:rem-sysprop fun 'INLINE) (sys:put-sysprop fun 'NOTINLINE t))) (defun declared-inline-p (fname &optional (env *cmp-env*)) (let* ((x (cmp-env-search-declaration 'inline env)) (flag (assoc fname x :test #'same-fname-p))) (if flag (cdr flag) (sys:get-sysprop fname 'INLINE)))) (defun declared-notinline-p (fname &optional (env *cmp-env*)) (let* ((x (cmp-env-search-declaration 'inline env)) (flag (assoc fname x :test #'same-fname-p))) (if flag (null (cdr flag)) (sys:get-sysprop fname 'NOTINLINE)))) (defun inline-possible (fname &optional (env *cmp-env*)) (not (declared-notinline-p fname env))) ;;; Install inline expansion of function. If the function is DECLAIMED ;;; inline, then we only keep the definition in the compiler environment. ;;; If the function is PROCLAIMED inline, then we also keep a copy as ;;; a symbol property. (defun maybe-install-inline-function (fname form env) (let* ((x (cmp-env-search-declaration 'inline env)) (flag (assoc fname x :test #'same-fname-p)) (declared (and flag (cdr flag))) (proclaimed (sys:get-sysprop fname 'inline))) `(progn ,(when declared `(eval-when (:compile-toplevel) (c::declare-inline ',fname *cmp-env-root* ',form))) ,(when proclaimed `(eval-when (:compile-toplevel :load-toplevel :execute) (si::put-sysprop ',fname 'inline ',form)))))) ecl-16.1.2/src/cmp/cmpenv-proclaim.lsp000066400000000000000000000124431266352375300175460ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: C -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. ;;;; Copyright (c) 1990, Giuseppe Attardi. ;;;; Copyright (c) 2010, Juan Jose Garcia-Ripoll ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. ;;;; ;;;; CMPENV-PROCLAIM -- Proclamations for the compiler ;;;; ;;;; One implementation of PROCLAIM that uses symbol properties to ;;;; store the proclamations. This has the disadvantage that ;;;; proclamations can not be easily cleaned up. ;;;; ;;;; The following code is to be coordinated with that in sysfun.lsp ;;;; and proclamations.lsp ;;;; (in-package #-ecl-new "COMPILER" #+ecl-new "C-ENV") #-:CCL (defun proclaim (decl &aux decl-name) (unless (listp decl) (error "The proclamation specification ~s is not a list" decl)) (case (setf decl-name (car decl)) (SPECIAL (dolist (var (cdr decl)) (if (symbolp var) (sys:*make-special var) (error "Syntax error in proclamation ~s" decl)))) (OPTIMIZE (dolist (x (cdr decl)) (when (symbolp x) (setq x (list x 3))) (if (or (not (consp x)) (not (consp (cdr x))) (not (numberp (second x))) (not (<= 0 (second x) 3))) (warn "The OPTIMIZE proclamation ~s is illegal." x) (case (car x) (DEBUG (setq *debug* (second x))) (SAFETY (setq *safety* (second x))) (SPACE (setq *space* (second x))) (SPEED (setq *speed* (second x))) (COMPILATION-SPEED (setq *speed* (- 3 (second x)))) (t (warn "The OPTIMIZE quality ~s is unknown." (car x))))))) (TYPE (if (consp (cdr decl)) (proclaim-var (second decl) (cddr decl)) (error "Syntax error in proclamation ~s" decl))) (FTYPE (if (atom (rest decl)) (error "Syntax error in proclamation ~a" decl) (multiple-value-bind (type-name args) (si::normalize-type (second decl)) (if (eq type-name 'FUNCTION) (dolist (v (cddr decl)) (proclaim-function v args)) (error "In an FTYPE proclamation, found ~A which is not a function type." (second decl)))))) (INLINE (proclaim-inline (cdr decl))) (NOTINLINE (proclaim-notinline (cdr decl))) ((OBJECT IGNORE DYNAMIC-EXTENT IGNORABLE) ;; FIXME! IGNORED! (dolist (var (cdr decl)) (unless (si::valid-function-name-p var) (error "Not a valid function name ~s in ~s proclamation" var decl-name)))) (DECLARATION (validate-alien-declaration (rest decl) #'error) (setf si::*alien-declarations* (append (rest decl) si:*alien-declarations*))) (SI::C-EXPORT-FNAME (dolist (x (cdr decl)) (cond ((symbolp x) (multiple-value-bind (found c-name) (si::mangle-name x t) (if found (warn "The function ~s is already in the runtime.~%C-EXPORT-FNAME declaration ignored." x) (put-sysprop x 'Lfun c-name)))) ((consp x) (destructuring-bind (c-name lisp-name) x (if (si::mangle-name lisp-name) (warn "The funciton ~s is already in the runtime.~%C-EXPORT-FNAME declaration ignored." lisp-name) (put-sysprop lisp-name 'Lfun c-name)))) (t (error "Syntax error in proclamation ~s" decl))))) ((ARRAY ATOM BASE-CHAR BIGNUM BIT BIT-VECTOR CHARACTER COMPILED-FUNCTION COMPLEX CONS DOUBLE-FLOAT EXTENDED-CHAR FIXNUM FLOAT HASH-TABLE INTEGER KEYWORD LIST LONG-FLOAT NIL NULL NUMBER PACKAGE PATHNAME RANDOM-STATE RATIO RATIONAL READTABLE SEQUENCE SHORT-FLOAT SIMPLE-ARRAY SIMPLE-BIT-VECTOR SIMPLE-STRING SIMPLE-VECTOR SINGLE-FLOAT STANDARD-CHAR STREAM STRING SYMBOL T VECTOR SIGNED-BYTE UNSIGNED-BYTE FUNCTION) (proclaim-var decl-name (cdr decl))) (otherwise (cond ((member (car decl) si:*alien-declarations*)) ((multiple-value-bind (ok type) (valid-type-specifier decl-name) (when ok (proclaim-var type (rest decl)) t))) ((maybe-add-policy decl *cmp-env-root*)) ((let ((proclaimer (get-sysprop (car decl) :proclaim))) (when (functionp proclaimer) (mapc proclaimer (rest decl)) t))) (t (warn "Unknown declaration specifier ~s" decl-name)))))) (defun proclaim-var (type vl) (dolist (var vl) (if (symbolp var) (let ((type1 (get-sysprop var 'CMP-TYPE))) (setq type1 (if type1 (type-and type1 type) type)) (unless type1 (warn "Inconsistent type declaration was found for the variable ~s." var) (setq type1 T)) (put-sysprop var 'CMP-TYPE type1)) (warn "The variable name ~s is not a symbol." var)))) ecl-16.1.2/src/cmp/cmpeval.lsp000066400000000000000000000217151266352375300161030ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: C -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; CMPEVAL -- The Expression Dispatcher. ;;;; Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. ;;;; Copyright (c) 1990, Giuseppe Attardi. ;;;; ;;;; ECoLisp is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. (in-package "COMPILER") (defun c1expr-inner (form) (declare (si::c-local)) (cond ((symbolp form) (setq form (chk-symbol-macrolet form)) (cond ((not (symbolp form)) form) ((eq form nil) (c1nil)) ((eq form t) (c1t)) ((keywordp form) (make-c1form* 'LOCATION :type (object-type form) :args (add-symbol form))) ((constantp form) (or (c1constant-value (symbol-value form) :only-small-values t) (c1var form))) (t (c1var form)))) ((consp form) (cmpck (not (si::proper-list-p form)) "Improper list found in lisp form~%~A" form) (let ((fun (car form))) (cond ((let ((fd (gethash fun *c1-dispatch-table*))) (and fd (setf fun fd))) (funcall fun (rest form))) ((symbolp fun) (c1call fun (cdr form) t)) ((and (consp fun) (eq (car fun) 'LAMBDA)) (c1funcall form)) (t (cmperr "~s is not a legal function name." fun))))) (t (c1constant-value form :always t)))) (defun c1expr (form) (let ((*current-form* form)) (loop (setf form (c1expr-inner form)) (when (c1form-p form) (return form))))) (defvar *c1nil* (make-c1form* 'LOCATION :type (object-type nil) :args nil)) (defun c1nil () *c1nil*) (defvar *c1t* (make-c1form* 'LOCATION :type (object-type t) :args t)) (defun c1t () *c1t*) (defun c1call (fname args macros-allowed &aux fd success can-inline) (cond ((> (length args) si::c-arguments-limit) (if (and macros-allowed (setf fd (cmp-macro-function fname))) (cmp-expand-macro fd (list* fname args)) ;; When it is a function and takes many arguments, we will ;; need a special C form to call it. It takes extra code for ;; handling the stack (unoptimized-long-call `#',fname args))) ((setq fd (local-function-ref fname)) (c1call-local fname fd args)) ((and (setq can-inline (inline-possible fname)) (setq fd (compiler-macro-function fname)) (progn (multiple-value-setq (fd success) (cmp-expand-compiler-macro fd fname args)) success)) fd) ((and can-inline (progn (multiple-value-setq (fd success) (clos-compiler-macro-expand fname args)) success)) fd) ((and macros-allowed (setq fd (cmp-macro-function fname))) (cmp-expand-macro fd (list* fname args))) ((and (setq can-inline (declared-inline-p fname)) (consp can-inline) (eq (first can-inline) 'function) (plusp *inline-max-depth*) (<= (cmp-env-optimization 'space) 1)) (let ((*inline-max-depth* (1- *inline-max-depth*))) (cmpnote "Inlining ~a" fname) `(funcall ,can-inline ,@args))) (t (c1call-global fname args)))) (defun c1call-local (fname fun args) (declare (si::c-local)) (let ((lambda (fun-lambda-expression fun))) (when (and lambda (declared-inline-p fname) (plusp *inline-max-depth*)) (return-from c1call-local (let ((*inline-max-depth* (1- *inline-max-depth*))) `(funcall #',lambda ,@args))))) (let* ((forms (c1args* args)) (return-type (or (get-local-return-type fun) 'T)) (arg-types (get-local-arg-types fun))) ;; Add type information to the arguments. (when arg-types (let ((fl nil)) (dolist (form forms) (cond ((endp arg-types) (push form fl)) (t (push (and-form-type (car arg-types) form (car args) :safe "In a call to ~a" fname) fl) (pop arg-types) (pop args)))) (setq forms (nreverse fl)))) (make-c1form* 'CALL-LOCAL :sp-change t ; conservative estimate :side-effects t ; conservative estimate :type return-type :args fun forms))) (defun c1call-global (fname args) (let* ((forms (c1args* args))) ;; If all arguments are constants, try to precompute the function ;; value. We abort when the function signals an error or the value ;; is not printable. (let ((value (c1call-constant-fold fname forms))) (when value (return-from c1call-global value))) ;; Otherwise emit a global function call (make-c1form* 'CALL-GLOBAL :sp-change (function-may-change-sp fname) :side-effects (function-may-have-side-effects fname) :type (propagate-types fname forms) :args fname forms ;; loc and type are filled by c2expr ))) (defun c1call-constant-fold (fname forms) (when (and (get-sysprop fname 'pure) (policy-evaluate-forms) (inline-possible fname)) (handler-case (loop with all-values = '() with constant-p with v for form in forms do (if (multiple-value-setq (constant-p v) (c1form-constant-p form)) (push v all-values) (return nil)) finally (return (c1constant-value (apply fname (nreverse all-values)) :only-small-values nil))) (error (c))))) (defun c2expr (form) (with-c1form-env (form form) (let* ((name (c1form-name form)) (args (c1form-args form)) (dispatch (gethash name *c2-dispatch-table*))) (apply dispatch form args)))) (defun c2expr* (form) ;; C2EXPR* compiles the giving expression in a context in which ;; other expressions will follow this one. We must thus create ;; a possible label so that the compiled forms exit right at ;; the point where the next form will be compiled. (with-exit-label (label) (let* ((*exit* label) (*unwind-exit* (cons *exit* *unwind-exit*)) ;;(*lex* *lex*) (*lcl* *lcl*) (*temp* *temp*)) (c2expr form)))) (defun c1with-backend (forms) (c1progn (loop for tag = (pop forms) for form = (pop forms) while tag when (eq tag :c/c++) collect form))) (defun c1progn (forms) (cond ((endp forms) (t1/c1expr 'NIL)) ((endp (cdr forms)) (t1/c1expr (car forms))) (t (let* ((fl (mapcar #'t1/c1expr forms)) (output-form (first (last fl))) (output-type (and output-form (c1form-type output-form)))) (make-c1form* 'PROGN :type output-type :args fl))))) (defun c2progn (c1form forms) (declare (ignore c1form)) ;; c1progn ensures that the length of forms is not less than 1. (do ((l forms (cdr l)) (lex *lex*)) ((endp (cdr l)) (c2expr (car l))) (let* ((this-form (first l)) (name (c1form-name this-form))) (let ((*destination* 'TRASH)) (c2expr* (car l))) (setq *lex* lex) ; recycle lex locations ;; Since PROGN does not have tags, any transfer of control means ;; leaving the current PROGN statement. (when (or (eq name 'GO) (eq name 'RETURN-FROM)) (return))))) (defun c1args* (forms) (mapcar #'c1expr forms)) ;;; ---------------------------------------------------------------------- (defvar *compiler-temps* '(tmp0 tmp1 tmp2 tmp3 tmp4 tmp5 tmp6 tmp7 tmp8 tmp9)) (defmacro sys::define-inline-function (name vars &body body) (let ((temps nil) (*compiler-temps* *compiler-temps*)) (dolist (var vars) (if (and (symbolp var) (not (member var '(&OPTIONAL &REST &KEY &AUX) :test #'eq))) (push (or (pop *compiler-temps*) (gentemp "TMP" (find-package 'COMPILER))) temps) (error "The parameter ~s for the inline function ~s is illegal." var name))) (let ((binding (cons 'LIST (mapcar #'(lambda (var temp) `(list ',var ,temp)) vars temps)))) `(progn (defun ,name ,vars ,@body) (define-compiler-macro ,name ,temps (list* 'LET ,binding ',body)))))) ecl-16.1.2/src/cmp/cmpexit.lsp000066400000000000000000000232031266352375300161170ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: C -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. ;;;; Copyright (c) 1990, Giuseppe Attardi. ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. ;;;; CMPEXIT Exit manager. (in-package "COMPILER") ;;; UNWIND-EXIT TAGS PURPOSE ;;; ;;; number -> unknown purpose ;;; JUMP -> unknown purpose ;;; FRAME -> ecl_frs_push() ;;; IHS -> ihs push ;;; IHS-ENV -> ihs push ;;; BDS-BIND -> binding of 1 special variable ;;; (number . {T|NIL}) -> label ;;; (LCL n) -> n local variables ;;; (STACK n) -> n elements pushed in stack ;;; TAIL-RECURSION-MARK -> TTL: label created ;;; RETURN* -> outermost location ;;; ;;; (*) also RETURN-FIXNUM, -CHARACTER, -SINGLE-FLOAT ;;; -DOUBLE-FLOAT, -OBJECT. ;;; (defun unwind-bds (bds-lcl bds-bind stack-frame ihs-p) (declare (fixnum bds-bind)) (let ((some nil)) (when stack-frame (setf some t) (if (stringp stack-frame) (wt-nl "ecl_stack_frame_close(" stack-frame ");") (wt-nl "ECL_STACK_SET_INDEX(cl_env_copy," stack-frame ");"))) (when bds-lcl (setf some t) (wt-nl "ecl_bds_unwind(cl_env_copy," bds-lcl ");")) (cond ((< bds-bind 4) (dotimes (n bds-bind) (declare (fixnum n)) (setf some t) (wt-nl "ecl_bds_unwind1(cl_env_copy);"))) (t (setf some t) (wt-nl "ecl_bds_unwind_n(cl_env_copy," bds-bind ");"))) (case ihs-p (IHS (setf some t) (wt-nl "ecl_ihs_pop(cl_env_copy);")) (IHS-ENV (setf some t) (wt-nl "ihs.lex_env = _ecl_debug_env;"))) some)) (defun unwind-exit (loc &optional (jump-p nil) &aux (bds-lcl nil) (bds-bind 0) (stack-frame nil) (ihs-p nil)) (declare (fixnum bds-bind)) (when (consp *destination*) (case (car *destination*) (JUMP-TRUE (set-jump-true loc (second *destination*)) (when (eq loc t) (return-from unwind-exit))) (JUMP-FALSE (set-jump-false loc (second *destination*)) (when (eq loc nil) (return-from unwind-exit))))) (dolist (ue *unwind-exit* (baboon-improper-*exit*)) ;; perform all unwind-exit's which precede *exit* (cond ((consp ue) ; ( label# . ref-flag )| (STACK n) |(LCL n) (cond ((eq (car ue) 'STACK) (setf stack-frame (second ue))) ((eq (car ue) 'LCL) (setq bds-lcl ue bds-bind 0)) ((eq ue *exit*) ;; all body forms except the last (returning) are dealt here (cond ((and (consp *destination*) (or (eq (car *destination*) 'JUMP-TRUE) (eq (car *destination*) 'JUMP-FALSE))) (unwind-bds bds-lcl bds-bind stack-frame ihs-p)) ((not (or bds-lcl (plusp bds-bind) stack-frame)) (set-loc loc)) ;; Save the value if LOC may possibly refer ;; to special binding. ((or (loc-refers-to-special loc) (loc-refers-to-special *destination*)) (let* ((*temp* *temp*) (temp (make-temp-var))) (let ((*destination* temp)) (set-loc loc)) ; temp <- loc (unwind-bds bds-lcl bds-bind stack-frame ihs-p) (set-loc temp))) ; *destination* <- temp (t (set-loc loc) (unwind-bds bds-lcl bds-bind stack-frame ihs-p))) (when jump-p (wt-nl) (wt-go *exit*)) (return)) (t (setq jump-p t)))) ((numberp ue) (baboon-unwind-exit ue) (setq bds-lcl ue bds-bind 0)) (t (case ue (IHS (setf ihs-p ue)) (IHS-ENV (setf ihs-p (or ihs-p ue))) (BDS-BIND (incf bds-bind)) (RETURN (unless (eq *exit* 'RETURN) (baboon-unwind-exit ue)) ;; *destination* must be either RETURN or TRASH. (cond ((eq loc 'VALUES) ;; from multiple-value-prog1 or values (unwind-bds bds-lcl bds-bind stack-frame ihs-p) (wt-nl "return cl_env_copy->values[0];")) ((eq loc 'RETURN) ;; from multiple-value-prog1 or values (unwind-bds bds-lcl bds-bind stack-frame ihs-p) (wt-nl "return value0;")) (t (let* ((*destination* 'RETURN)) (set-loc loc)) (unwind-bds bds-lcl bds-bind stack-frame ihs-p) (wt-nl "return value0;"))) (return)) ((RETURN-FIXNUM RETURN-CHARACTER RETURN-DOUBLE-FLOAT RETURN-SINGLE-FLOAT RETURN-OBJECT) (when (eq *exit* ue) ;; *destination* must be RETURN-FIXNUM (setq loc (list 'COERCE-LOC (getf '(RETURN-FIXNUM :fixnum RETURN-CHARACTER :char RETURN-SINGLE-FLOAT :float RETURN-DOUBLE-FLOAT :double RETURN-OBJECT :object) ue) loc)) (if (or bds-lcl (plusp bds-bind)) (let ((lcl (make-lcl-var :type (second loc)))) (wt-nl-open-brace) (wt-nl "cl_fixnum " lcl "= " loc ";") (unwind-bds bds-lcl bds-bind stack-frame ihs-p) (wt-nl "return(" lcl ");") (wt-nl-close-brace)) (progn (wt-nl "return(" loc ");"))) (return))) (FRAME (let ((*destination* (tmp-destination *destination*))) (set-loc loc) (setq loc *destination*)) (wt-nl "ecl_frs_pop(cl_env_copy);")) (TAIL-RECURSION-MARK) (JUMP (setq jump-p t)) (t (baboon-unwind-exit ue)))))) ;;; Never reached ) (defun baboon-improper-*exit* () (baboon :format-control "The value of *EXIT*~%~A~%is not found in *UNWIND-EXIT*~%~A" :format-arguments (list *exit* *unwind-exit*))) (defun baboon-unwind-exit (ue) (baboon :format-control "The value of unwind exit~%~A~%found in *UNWIND-EXIT*~%~A~%is not valid." :format-arguments (list ue *unwind-exit*))) (defun unwind-no-exit-until (last-cons) (loop with bds-lcl = nil with bds-bind = 0 with stack-frame = nil with ihs-p = nil for unwind-exit on *unwind-exit* for ue = (car unwind-exit) until (eq unwind-exit last-cons) do (cond ((consp ue) (when (eq (first ue) 'STACK) (setf stack-frame (second ue)))) ((numberp ue) (setq bds-lcl ue bds-bind 0)) ((eq ue 'BDS-BIND) (incf bds-bind)) ((eq ue 'FRAME) (wt-nl "ecl_frs_pop(cl_env_copy);")) ((eq ue 'JUMP)) ((eq ue 'IHS-ENV) (setf ihs-p ue)) (t (baboon-unwind-exit ue))) finally (return (unwind-bds bds-lcl bds-bind stack-frame ihs-p)))) (defun unwind-no-exit (exit) (let ((where (member exit *unwind-exit* :test #'eq))) (unless where (baboon :format-control "Unwind-exit label ~A not found" :format-arguments (list exit))) (unwind-no-exit-until where))) ;;; Tail-recursion optimization for a function F is possible only if ;;; 1. F receives only required parameters, and ;;; 2. no required parameter of F is enclosed in a closure. ;;; ;;; A recursive call (F e1 ... en) may be replaced by a loop only if ;;; 1. F is not declared as NOTINLINE, ;;; 2. n is equal to the number of required parameters of F, ;;; 3. the form is a normal function call (i.e. args are not ARGS-PUSHED), ;;; 4. (F e1 ... en) is not surrounded by a form that causes dynamic ;;; binding (such as LET, LET*, PROGV), ;;; 5. (F e1 ... en) is not surrounded by a form that that pushes a frame ;;; onto the frame-stack (such as BLOCK and TAGBODY whose tags are ;;; enclosed in a closure, and CATCH), (defun tail-recursion-possible () (dolist (ue *unwind-exit* (baboon)) (cond ((eq ue 'TAIL-RECURSION-MARK) (return t)) ((or (numberp ue) (eq ue 'BDS-BIND) (eq ue 'FRAME)) (return nil)) ((or (consp ue) (eq ue 'JUMP) (eq ue 'IHS-ENV))) (t (baboon))))) (defun c2try-tail-recursive-call (fun args) (when (and *tail-recursion-info* (eq fun (first *tail-recursion-info*)) (last-call-p) (tail-recursion-possible) (inline-possible (fun-name fun)) (= (length args) (length (rest *tail-recursion-info*)))) (let* ((*destination* 'TRASH) (*exit* (next-label)) (*unwind-exit* (cons *exit* *unwind-exit*))) (c2psetq nil ;; We do not provide any C2FORM (cdr *tail-recursion-info*) args) (wt-label *exit*)) (unwind-no-exit 'TAIL-RECURSION-MARK) (wt-nl "goto TTL;") (cmpdebug "Tail-recursive call of ~s was replaced by iteration." (fun-name fun)) t)) ecl-16.1.2/src/cmp/cmpffi.lsp000077500000000000000000000542331266352375300157240ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: C -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; CMPFFI -- Foreign functions interface. ;;;; Copyright (c) 2003, Juan Jose Garcia-Ripoll. ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. (in-package "COMPILER") ;; ---------------------------------------------------------------------- ;; REPRESENTATION TYPES ;; (defun rep-type-record-unsafe (rep-type) (gethash rep-type (machine-rep-type-hash *machine*))) (defun rep-type-record (rep-type) (let ((record (gethash rep-type (machine-rep-type-hash *machine*)))) (unless record (cmperr "Not a valid C type name ~A" rep-type)) record)) (defun rep-type->lisp-type (name) (let ((output (rep-type-record-unsafe name))) (cond (output (rep-type-lisp-type output)) ((lisp-type-p name) name) (t (error "Unknown representation type ~S" name))))) (defun lisp-type->rep-type (type) (cond ;; We expect type = NIL when we have no information. Should be fixed. FIXME! ((null type) :object) ((let ((r (rep-type-record-unsafe type))) (and r (rep-type-name r)))) (t ;; Find the most specific type that fits (dolist (record (machine-sorted-types *machine*) :object) (when (subtypep type (rep-type-lisp-type record)) (return-from lisp-type->rep-type (rep-type-name record))))))) (defun c-number-rep-type-p (rep-type) (let ((r (rep-type-record-unsafe rep-type))) (and r (rep-type-numberp r)))) (defun c-integer-rep-type-p (rep-type) (let ((r (rep-type-record-unsafe rep-type))) (and r (rep-type-integerp r)))) (defun c-integer-rep-type-bits (rep-type) (let ((r (rep-type-record-unsafe rep-type))) (and r (rep-type-bits r)))) (defun c-number-type-p (type) (c-number-rep-type-p (lisp-type->rep-type type))) (defun c-integer-type-p (type) (c-integer-rep-type-p (lisp-type->rep-type type))) (defun c-integer-type-bits (type) (c-number-rep-type-bits (lisp-type->rep-type type))) (defun rep-type->c-name (type) (rep-type-c-name (rep-type-record type))) (defun lisp-type-p (type) (subtypep type 'T)) (defun wt-to-object-conversion (loc-rep-type loc) (when (and (consp loc) (member (first loc) '(single-float-value double-float-value long-float-value))) (wt (third loc)) ;; VV index (return-from wt-to-object-conversion)) (let ((record (rep-type-record loc-rep-type))) (unless record (cmperr "Cannot coerce C variable of type ~A to lisp object" loc-rep-type)) (wt (rep-type-to-lisp record) "(" loc ")"))) (defun wt-from-object-conversion (dest-type loc-type rep-type loc) (let* ((record (rep-type-record rep-type)) (coercer (and record (rep-type-from-lisp record)))) (unless coercer (cmperr "Cannot coerce lisp object to C type ~A" rep-type)) (wt (if (or (policy-assume-no-errors) (subtypep loc-type dest-type)) (rep-type-from-lisp-unsafe record) coercer) "(" loc ")"))) ;; ---------------------------------------------------------------------- ;; LOCATIONS and representation types ;; ;; Locations are lisp expressions which represent actual C data. To each ;; location we can associate a representation type, which is the type of ;; the C data. The following routines help in determining these types, ;; and also in moving data from one location to another. (defun loc-movable-p (loc) (if (atom loc) t (case (first loc) ((CALL CALL-LOCAL) NIL) ((C-INLINE) (not (fifth loc))) ; side effects? (otherwise t)))) (defun loc-type (loc) (cond ((eq loc NIL) 'NULL) ((var-p loc) (var-type loc)) ((vv-p loc) (vv-type loc)) ((numberp loc) (lisp-type->rep-type (type-of loc))) ((atom loc) 'T) (t (case (first loc) (FIXNUM-VALUE 'FIXNUM) (CHARACTER-VALUE (type-of (code-char (second loc)))) (DOUBLE-FLOAT-VALUE 'DOUBLE-FLOAT) (SINGLE-FLOAT-VALUE 'SINGLE-FLOAT) (LONG-FLOAT-VALUE 'LONG-FLOAT) (C-INLINE (let ((type (first (second loc)))) (cond ((and (consp type) (eq (first type) 'VALUES)) T) ((lisp-type-p type) type) (t (rep-type->lisp-type type))))) (BIND (var-type (second loc))) (LCL (or (third loc) T)) (THE (second loc)) (CALL-NORMAL (fourth loc)) (otherwise T))))) (defun loc-representation-type (loc) (cond ((member loc '(NIL T)) :object) ((var-p loc) (var-rep-type loc)) ((vv-p loc) :object) ((numberp loc) (lisp-type->rep-type (type-of loc))) ((eq loc 'TRASH) :void) ((atom loc) :object) (t (case (first loc) (FIXNUM-VALUE :fixnum) (CHARACTER-VALUE (if (<= (second loc) 255) :unsigned-char :wchar)) (DOUBLE-FLOAT-VALUE :double) (SINGLE-FLOAT-VALUE :float) (LONG-FLOAT-VALUE :long-double) (C-INLINE (let ((type (first (second loc)))) (cond ((and (consp type) (eq (first type) 'VALUES)) :object) ((lisp-type-p type) (lisp-type->rep-type type)) (t type)))) (BIND (var-rep-type (second loc))) (LCL (lisp-type->rep-type (or (third loc) T))) ((JUMP-TRUE JUMP-FALSE) :bool) (THE (loc-representation-type (third loc))) (otherwise :object))))) (defun wt-coerce-loc (dest-rep-type loc) (setq dest-rep-type (lisp-type->rep-type dest-rep-type)) ;(print dest-rep-type) ;(print loc) (let* ((dest-type (rep-type->lisp-type dest-rep-type)) (loc-type (loc-type loc)) (loc-rep-type (loc-representation-type loc))) (labels ((coercion-error () (cmpwarn "Unable to coerce lisp object from type (~S,~S)~%~ to C/C++ type (~S,~S)" loc-type loc-rep-type dest-type dest-rep-type)) (ensure-valid-object-type (a-lisp-type) (when (subtypep `(AND ,loc-type ,a-lisp-type) NIL) (coercion-error)))) (when (eq dest-rep-type loc-rep-type) (wt loc) (return-from wt-coerce-loc)) (case dest-rep-type ((:char :unsigned-char :wchar) (case loc-rep-type ((:char :unsigned-char :wchar) (wt "(" (rep-type->c-name dest-rep-type) ")(" loc ")")) ((:object) (ensure-valid-object-type dest-type) (wt-from-object-conversion dest-type loc-type dest-rep-type loc)) (otherwise (coercion-error)))) ((:float :double :long-double) (cond ((c-number-rep-type-p loc-rep-type) (wt "(" (rep-type->c-name dest-rep-type) ")(" loc ")")) ((eq loc-rep-type :object) ;; We relax the check a bit, because it is valid in C to coerce ;; between floats of different types. (ensure-valid-object-type 'FLOAT) (wt-from-object-conversion dest-type loc-type dest-rep-type loc)) (t (coercion-error)))) ((:bool) (cond ((c-number-rep-type-p loc-rep-type) (wt "1")) ((eq loc-rep-type :object) (wt "(" loc ")!=ECL_NIL")) (t (coercion-error)))) ((:object) (case loc-rep-type ((:int-sse-pack :float-sse-pack :double-sse-pack) (when (>= (cmp-env-optimization 'speed) 1) (cmpwarn-style "Boxing a value of type ~S - performance degraded." loc-rep-type)))) (wt-to-object-conversion loc-rep-type loc)) ((:pointer-void) (case loc-rep-type ((:object) (wt-from-object-conversion dest-type loc-type dest-rep-type loc)) ((:cstring) (wt "(char *)(" loc ")")) (otherwise (coercion-error)))) ((:cstring) (coercion-error)) ((:char*) (case loc-rep-type ((:object) (wt "ecl_base_string_pointer_safe(" loc ")")) ((:pointer-void) (wt "(char *)(" loc ")")) (otherwise (coercion-error)))) ((:int-sse-pack :float-sse-pack :double-sse-pack) (case loc-rep-type ((:object) (wt-from-object-conversion 'ext:sse-pack loc-type dest-rep-type loc)) ;; Implicitly cast between SSE subtypes ((:int-sse-pack :float-sse-pack :double-sse-pack) (wt (ecase dest-rep-type (:int-sse-pack (ecase loc-rep-type (:float-sse-pack "_mm_castps_si128") (:double-sse-pack "_mm_castpd_si128"))) (:float-sse-pack (ecase loc-rep-type (:int-sse-pack "_mm_castsi128_ps") (:double-sse-pack "_mm_castpd_ps"))) (:double-sse-pack (ecase loc-rep-type (:int-sse-pack "_mm_castsi128_pd") (:float-sse-pack "_mm_castps_pd")))) "(" loc ")")) (otherwise (coercion-error)))) (t ;; At this point we only have coercions to integers (cond ((not (c-integer-rep-type-p dest-rep-type)) (coercion-error)) ((c-number-rep-type-p loc-rep-type) (wt "(" (rep-type->c-name dest-rep-type) ")(" loc ")")) ((eq :object loc-rep-type) (ensure-valid-object-type dest-type) (wt-from-object-conversion dest-type loc-type dest-rep-type loc)) (t (coercion-error)))))))) ;;; ---------------------------------------------------------------------- ;;; C/C++ DECLARATIONS AND HEADERS ;;; ;;; All lines from CLINES statements are grouped at the beginning of the header ;;; Notice that it does not make sense to guarantee that c-lines statements ;;; are produced in-between the function definitions, because two functions ;;; might be collapsed into one, or we might not produce that function at all ;;; and rather inline it. ;;; (defun c1clines (args) (unless (every #'stringp args) (cmperr "The argument to CLINES, ~s, is not a list of strings." args)) (setf *clines-string-list* (nconc *clines-string-list* (copy-list args))) '(progn)) (defun output-clines (output-stream) (flet ((parse-one-string (s output-stream) (with-input-from-string (stream s) (loop for c = (read-char stream nil nil) while c do (if (eq c #\@) (let ((object (handler-case (read stream) (serious-condition (c) (cmperr "Unable to parse FFI:CLINES string~& ~S" s))))) (let ((*compiler-output1* output-stream)) (wt (add-object object :permanent t)))) (write-char c output-stream)))))) (loop for s in *clines-string-list* do (terpri output-stream) do (if (find #\@ s) (parse-one-string s output-stream) (write-string s output-stream))) (terpri output-stream) (setf *clines-string-list* nil))) ;; ---------------------------------------------------------------------- ;; C/C++ INLINE CODE ;; (defun c1c-inline (args) ;; We are on the safe side by assuming that the form has side effects (destructuring-bind (arguments arg-types output-type c-expression &rest rest &key (side-effects t) one-liner &aux output-rep-type) args (unless (= (length arguments) (length arg-types)) (cmperr "In a C-INLINE form the number of declare arguments and the number of supplied ones do not match:~%~S" `(C-INLINE ,@args))) ;; We cannot handle :cstrings as input arguments. :cstrings are ;; null-terminated strings, but not all of our lisp strings will ;; be null terminated. In particular, those with a fill pointer ;; will not. (let ((ndx (position :cstring arg-types))) (when ndx (let* ((var (gensym)) (arguments (copy-list arguments)) (value (elt arguments ndx))) (setf (elt arguments ndx) var (elt arg-types ndx) :char*) (return-from c1c-inline (c1expr `(ffi::with-cstring (,var ,value) (c-inline ,arguments ,arg-types ,output-type ,c-expression ,@rest))))))) ;; Find out the output types of the inline form. The syntax is rather relaxed ;; output-type = lisp-type | c-type | (values {lisp-type | c-type}*) (flet ((produce-type-pair (type) (if (lisp-type-p type) (cons type (lisp-type->rep-type type)) (cons (rep-type->lisp-type type) type)))) (cond ((eq output-type ':void) (setf output-rep-type '() output-type 'NIL)) ((equal output-type '(VALUES &REST t)) (setf output-rep-type '((VALUES &REST t)))) ((and (consp output-type) (eql (first output-type) 'VALUES)) (let ((x (mapcar #'produce-type-pair (rest output-type)))) (setf output-rep-type (mapcar #'cdr x) output-type `(VALUES ,@(mapcar #'car x))))) (t (let ((x (produce-type-pair output-type))) (setf output-type (car x) output-rep-type (list (cdr x))))))) (unless (and (listp arguments) (listp arg-types) (stringp c-expression)) (cmperr "C-INLINE: syntax error in ~S" (list* 'c-inline args))) (unless (= (length arguments) (length arg-types)) (cmperr "C-INLINE: wrong number of arguments in ~S" (list* 'c-inline args))) (let* ((arguments (mapcar #'c1expr arguments)) (form (make-c1form* 'C-INLINE :type output-type :side-effects side-effects :args arguments arg-types output-rep-type c-expression side-effects one-liner))) (loop for form in arguments when (eq (c1form-name form) 'VAR) do (let ((var (c1form-arg 0 form))) (add-to-set-nodes var form))) form))) (defun c1c-progn (arguments) (let* ((variables (mapcar #'c1vref (pop arguments))) (statements (loop for form in arguments collect (if (stringp form) form (c1expr form)))) (form (make-c1form* 'FFI:C-PROGN :type NIL :side-effects t :args variables statements))) (add-to-set-nodes-of-var-list variables form) form)) (defun c2c-progn (c1form variables statements) (loop with *destination* = 'TRASH for form in statements do (cond ((stringp form) (wt-nl) (wt-c-inline-loc :void form variables t ; side effects nil) ; no output variables ) (t (c2expr* form))) finally (unwind-exit nil))) (defun produce-inline-loc (inlined-arguments arg-types output-rep-type c-expression side-effects one-liner) (let* (args-to-be-saved coerced-arguments) ;; If the expression begins with @[0-9a-z]*, this means we are ;; saving some variables. (when (and (> (length c-expression) 1) (eq (char c-expression 0) #\@)) (do ((ndx 1 (1+ ndx))) ((>= ndx (length c-expression))) (let ((c (char c-expression ndx))) (when (eq c #\;) (setf c-expression (subseq c-expression (1+ ndx))) (return)) (unless (alphanumericp c) (setf args-to-be-saved nil) (return)) (push (- (char-code c) (char-code #\0)) args-to-be-saved)))) (setf coerced-arguments (coerce-locs inlined-arguments arg-types args-to-be-saved)) ;;(setf output-rep-type (lisp-type->rep-type output-rep-type)) ;; If the form does not output any data, and there are no side ;; effects, try to omit it. (when (null output-rep-type) (if side-effects (progn (wt-nl) (wt-c-inline-loc output-rep-type c-expression coerced-arguments t nil) (when one-liner (wt ";"))) (cmpnote "Ignoring form ~S" c-expression)) (return-from produce-inline-loc NIL)) ;; If the form is a one-liner, we can simply propagate this expression until the ;; place where the value is used. (when one-liner (return-from produce-inline-loc `(C-INLINE ,output-rep-type ,c-expression ,coerced-arguments ,side-effects ,(if (equalp output-rep-type '((VALUES &REST T))) 'VALUES NIL)))) ;; If the output is a in the VALUES vector, just write down the form and output ;; the location of the data. (when (equalp output-rep-type '((VALUES &REST T))) (wt-c-inline-loc output-rep-type c-expression coerced-arguments side-effects 'VALUES) (return-from produce-inline-loc 'VALUES)) ;; Otherwise we have to set up variables for holding the output. (flet ((make-output-var (type) (let ((var (make-lcl-var :rep-type type))) (wt-nl (rep-type->c-name type) " " var ";") var))) (open-inline-block) (let ((output-vars (mapcar #'make-output-var output-rep-type))) (wt-c-inline-loc output-rep-type c-expression coerced-arguments side-effects output-vars) (cond ((= (length output-vars) 1) (first output-vars)) (t (loop for v in output-vars for i from 0 do (let ((*destination* `(VALUE ,i))) (set-loc v))) (wt "cl_env_copy->nvalues=" (length output-vars) ";") 'VALUES)))))) (defun c2c-inline (c1form arguments &rest rest) (declare (ignore c1form)) (let ((*inline-blocks* 0) (*temp* *temp*)) (unwind-exit (apply #'produce-inline-loc (inline-args arguments) rest)) (close-inline-blocks))) (defun coerce-locs (inlined-args &optional types args-to-be-saved) ;; INLINED-ARGS is a list of (TYPE LOCATION) produced by the ;; inline code. ARGS-TO-BE-SAVED is a positional list created by ;; C-INLINE, instructing that the value should be saved in a temporary ;; variable. Finally, TYPES is a list of destination types, to which ;; the former values are coerced. The destination types can be ;; - A lisp type (:OBJECT, :FINXUM, etc) ;; - A machine representation type (T, INTEGER, etc) (loop with block-opened = nil for (lisp-type loc) in inlined-args for type in (or types '#1=(:object . #1#)) for i from 0 for rep-type = (lisp-type->rep-type type) collect (cond ((and args-to-be-saved (member i args-to-be-saved :test #'eql) (not (loc-movable-p loc))) (let ((lcl (make-lcl-var :rep-type rep-type))) (wt-nl) (unless block-opened (setf block-opened t) (open-inline-block)) (wt (rep-type->c-name rep-type) " " lcl "= ") (wt-coerce-loc rep-type loc) (wt ";") lcl)) ((equal rep-type (loc-representation-type loc)) loc) (t `(COERCE-LOC ,rep-type ,loc))))) (defun wt-c-inline-loc (output-rep-type c-expression coerced-arguments side-effects output-vars) (with-input-from-string (s c-expression) (when (and output-vars (not (eq output-vars 'VALUES))) (wt-nl)) (do ((c (read-char s nil nil) (read-char s nil nil))) ((null c)) (case c (#\@ (let ((object (read s))) (cond ((and (consp object) (equal (first object) 'RETURN)) (if (eq output-vars 'VALUES) (cmperr "User @(RETURN ...) in a C-INLINE form with no output values") (let ((ndx (or (second object) 0)) (l (length output-vars))) (if (< ndx l) (wt (nth ndx output-vars)) (cmperr "Used @(RETURN ~D) in a C-INLINE form with ~D output values" ndx l))))) (t (when (and (consp object) (eq (first object) 'QUOTE)) (setq object (second object))) (wt (add-object object :permanent t)))))) (#\# (let* ((k (read-char s)) (next-char (peek-char nil s nil nil)) (index (digit-char-p k 36))) (cond ((eq k #\#) (wt #\#)) ((or (null index) (and next-char (alphanumericp next-char))) (wt #\# k)) ((< index (length coerced-arguments)) (wt (nth index coerced-arguments))) (t (cmperr "C-INLINE: Variable code exceeds number of arguments"))))) (otherwise (write-char c *compiler-output1*)))))) (defun c-inline-safe-string (constant-string) ;; Produce a text representation of a string that can be used ;; in a C-INLINE form, without triggering the @ or # escape ;; characters (c-filtered-string (concatenate 'string (loop for c across constant-string when (member c '(#\# #\@)) collect c collect c)))) ecl-16.1.2/src/cmp/cmpflet.lsp000066400000000000000000000255661266352375300161160ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: C -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; CMPFLET Flet, Labels, and Macrolet. ;;;; Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. ;;;; Copyright (c) 1990, Giuseppe Attardi. ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. (in-package "COMPILER") (defun c1labels (args) (c1labels/flet 'LABELS args)) (defun c1flet (args) (c1labels/flet 'FLET args)) (defun c1labels/flet (origin args) (check-args-number origin args 1) (let ((new-env (cmp-env-copy)) (defs '()) (local-funs '()) (fnames '()) body-c1form) ;; On a first round, we extract the definitions of the functions, ;; and build empty function objects that record the references to ;; this functions in the processed body. In the end ;; DEFS = ( { ( fun-object function-body ) }* ). (dolist (def (car args)) (cmpck (or (endp def) (not (si::valid-function-name-p (car def))) (endp (cdr def))) "The local function definition ~s is illegal." def) (cmpck (member (car def) fnames) "~s: The function ~s was already defined." origin (car def)) (push (car def) fnames) (let* ((name (car def)) (var (make-var :name name :kind :object)) (fun (make-fun :name name :var var))) (cmp-env-register-function fun new-env) (push (cons fun (cdr def)) defs))) ;; Now we compile the functions, either in an empty environment ;; in which there are no new functions (let ((*cmp-env* (cmp-env-copy (if (eq origin 'FLET) *cmp-env* new-env)))) (dolist (def (nreverse defs)) (let ((fun (first def))) ;; The closure type will be fixed later on by COMPUTE-... (push (c1compile-function (rest def) :fun fun :CB/LB 'LB) local-funs)))) ;; When we are in a LABELs form, we have to propagate the external ;; variables from one function to the other functions that use it. (when (eq origin 'LABELS) (loop for change = nil do (loop for f1 in local-funs for vars = (fun-referenced-vars f1) for funs = (fun-referenced-funs f1) do (loop for f2 in (fun-referencing-funs f1) for c1 = (add-to-fun-referenced-vars f2 vars) for c2 = (add-to-fun-referenced-funs f2 funs) for c3 = (update-fun-closure-type f2) when (or c1 c2 c3) do (setf change t))) do (unless change (return)))) ;; Now we can compile the body itself. (let ((*cmp-env* new-env)) (multiple-value-bind (body ss ts is other-decl) (c1body (rest args) t) (c1declare-specials ss) (check-vdecl nil ts is) (setq body-c1form (c1decl-body other-decl body)))) ;; Keep only functions that have been referenced at least once. ;; It is not possible to look at FUN-REF before because functions ;; in a LABELS can reference each other. (setf local-funs (remove-if-not #'plusp local-funs :key #'fun-ref)) ;; Keep on inspecting the functions until the closure type does not ;; change. (loop while (let ((x nil)) (loop for f in local-funs when (update-fun-closure-type f) do (setf x t)) x)) (if local-funs (make-c1form* 'LOCALS :type (c1form-type body-c1form) :args local-funs body-c1form (eq origin 'LABELS)) body-c1form))) (defun child-function-p (presumed-parent fun) (declare (optimize speed)) (loop for real-parent = (fun-parent fun) while real-parent do (if (eq real-parent presumed-parent) (return t) (setf fun real-parent)))) (defun compute-closure-type (fun) (declare (si::c-local)) (let ((lexical-closure-p nil)) ;; it will have a full closure if it refers external non-global variables (dolist (var (fun-referenced-vars fun)) (cond ((global-var-p var)) ;; ...across CB ((ref-ref-ccb var) (return-from compute-closure-type 'CLOSURE)) (t (setf lexical-closure-p t)))) ;; ...or if it directly calls a function (dolist (f (fun-referenced-funs fun)) (unless (child-function-p fun f) ;; .. which has a full closure (case (fun-closure f) (CLOSURE (return-from compute-closure-type 'CLOSURE)) (LEXICAL (setf lexical-closure-p t))))) ;; ...or the function itself is referred across CB (when lexical-closure-p (if (or (fun-ref-ccb fun) (and (fun-var fun) (plusp (var-ref (fun-var fun))))) 'CLOSURE 'LEXICAL)))) (defun update-fun-closure-type-many (function-list) (do ((finish nil t) (recompute nil)) (finish recompute) (dolist (f function-list) (when (update-fun-closure-type f) (setf recompute t finish nil))))) (defun prepend-new (l1 l2) (loop for f in l1 do (pushnew f l2)) l2) (defun update-fun-closure-type (fun) (let ((old-type (fun-closure fun))) (when (eq old-type 'closure) (return-from update-fun-closure-type nil)) ;; This recursive algorithm is guaranteed to stop when functions ;; do not change. (let ((new-type (compute-closure-type fun)) (to-be-updated (fun-child-funs fun))) ;; Same type (when (eq new-type old-type) (return-from update-fun-closure-type nil)) (when (fun-global fun) (cmpnote "Function ~A is global but is closed over some variables.~%~{~A ~}" (fun-name fun) (mapcar #'var-name (fun-referenced-vars fun)))) (setf (fun-closure fun) new-type) ;; All external, non-global variables become of type closure (when (eq new-type 'CLOSURE) (dolist (var (fun-referenced-vars fun)) (unless (or (global-var-p var) (eq (var-kind var) new-type)) (setf (var-ref-clb var) nil (var-ref-ccb var) t (var-kind var) 'CLOSURE (var-loc var) 'OBJECT to-be-updated (prepend-new (var-functions-reading var) (prepend-new (var-functions-setting var) to-be-updated))))) (dolist (f (fun-referenced-funs fun)) (setf (fun-ref-ccb f) t))) ;; If the status of some of the children changes, we have ;; to recompute the closure type. (when (update-fun-closure-type-many to-be-updated) (update-fun-closure-type fun)) t))) (defun c2locals (c1form funs body labels ;; labels is T when deriving from labels &aux (*env* *env*) (*inline-blocks* 0) (*env-lvl* *env-lvl*)) (declare (ignore c1form)) ;; create location for each function which is returned, ;; either in lexical: (loop with env-grows = nil with closed-vars = '() for fun in funs for var = (fun-var fun) when (plusp (var-ref var)) do (case (var-kind var) ((lexical closure) (push var closed-vars) (unless env-grows (setq env-grows (var-ref-ccb var)))) (otherwise (maybe-open-inline-block) (bind (next-lcl) var) (wt-nl "cl_object " *volatile* var ";"))) finally ;; if we have closed variables (when (env-grows env-grows) (maybe-open-inline-block) (let ((env-lvl *env-lvl*)) (wt "cl_object " *volatile* "env" (incf *env-lvl*) " = env" env-lvl ";"))) ;; bind closed locations because of possible circularities (loop for var in closed-vars do (bind nil var))) ;; create the functions: (mapc #'new-local funs) ;; - then assign to it (loop for fun in funs for var = (fun-var fun) when (plusp (var-ref var)) do (set-var (list 'MAKE-CCLOSURE fun) var)) (c2expr body) (close-inline-blocks)) (defun c1decl-body (decls body) (if (null decls) (c1progn body) (let* ((*cmp-env* (reduce #'add-one-declaration decls :initial-value (cmp-env-copy *cmp-env*)))) (c1progn body)))) (defun c1locally (args) (multiple-value-bind (body ss ts is other-decl) (c1body args t) (if (or ss ts is other-decl) (let ((*cmp-env* (cmp-env-copy))) (c1declare-specials ss) (check-vdecl nil ts is) (c1decl-body other-decl body)) (c1progn body)))) (defun c1macrolet (args) (check-args-number 'MACROLET args 1) (let ((*cmp-env* (cmp-env-register-macrolet (first args) (cmp-env-copy)))) (c1locally (cdr args)))) (defun c1symbol-macrolet (args) (check-args-number 'SYMBOL-MACROLET args 1) (let ((*cmp-env* (cmp-env-copy))) (dolist (def (car args)) (let ((name (first def))) (cmpck (or (endp def) (not (symbolp name)) (endp (cdr def))) "The symbol-macro definition ~s is illegal." def) (cmp-env-register-symbol-macro name (second def)))) (c1locally (cdr args)))) (defun local-function-ref (fname &optional build-object) (multiple-value-bind (fun ccb clb unw) (cmp-env-search-function fname) (when fun (when (functionp fun) (when build-object ;; Macro definition appears in #'.... This should not happen. (cmperr "The name of a macro ~A was found in special form FUNCTION." fname)) (return-from local-function-ref nil)) (incf (fun-ref fun)) (if build-object (setf (fun-ref-ccb fun) t) (let ((caller *current-function*)) (when (and caller (not (member fun (fun-referenced-funs caller) :test #'eq))) (push fun (fun-referenced-funs caller)) (push caller (fun-referencing-funs fun))))) ;; we introduce a variable to hold the funob (let ((var (fun-var fun))) (cond (ccb (when build-object (setf (var-ref-ccb var) t (var-kind var) 'CLOSURE)) (setf (fun-ref-ccb fun) t)) (clb (when build-object (setf (var-ref-clb var) t (var-kind var) 'LEXICAL)))))) fun)) (defun c2call-local (c1form fun args) (declare (type fun fun) (ignore c1form)) (unless (c2try-tail-recursive-call fun args) (let ((*inline-blocks* 0) (*temp* *temp*)) (unwind-exit (call-loc (fun-name fun) fun (inline-args args) (c1form-primary-type c1form))) (close-inline-blocks)))) ecl-16.1.2/src/cmp/cmpform.lsp000066400000000000000000000243321266352375300161150ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: C -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; Copyright (c) 2009, Juan Jose Garcia-Ripoll ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. ;;;; ;;;; CMPFORM -- Internal representation of Lisp forms ;;;; (in-package "COMPILER") ;;; ;;; ALL C1FORMS: Intermediate language used by the compiler ;;; ;;; body = (c1form*) ;;; tag-body = ({c1form | tag}*) ;;; return-type = {CLB | CCB | UNWIND-PROTECT} ;;; *value = c1form ;;; lambda-list = (requireds optionals rest key-flag keywords allow-other-keys) ;;; (defun print-c1form (form stream) (format stream "#
    " (c1form-name form) (si:pointer form))) (defun make-c1form (name subform &rest args) (let ((form (do-make-c1form :name name :args args :type (info-type subform) :sp-change (info-sp-change subform) :volatile (info-volatile subform) :form *current-form* :toplevel-form *current-toplevel-form* :file *compile-file-truename* :file-position *compile-file-position*))) (c1form-add-info form args) form)) (defun make-c1form* (name &rest args) (let ((info-args '()) (form-args '())) (do ((l args (cdr l))) ((endp l)) (let ((key (first l))) (cond ((not (keywordp key)) (baboon)) ((eq key ':args) (setf form-args (rest l)) (return)) (t (setf info-args (list* key (second l) info-args) l (cdr l)))))) (let ((form (apply #'do-make-c1form :name name :args form-args :form *current-form* :toplevel-form *current-toplevel-form* :file *compile-file-truename* :file-position *compile-file-position* info-args))) (c1form-add-info form form-args) form))) (defun c1form-add-info-loop (form dependents) (loop with subform while (consp dependents) when (c1form-p (setf subform (pop dependents))) do (progn (when (c1form-sp-change subform) (setf (c1form-sp-change form) t (c1form-side-effects form) t)) (when (c1form-side-effects subform) (setf (c1form-side-effects form) t)) (unless (eq (c1form-name subform) 'LOCATION) (when (rest (c1form-parents subform)) (error "Running twice through same form")) (setf (c1form-parents subform) (nconc (c1form-parents subform) (c1form-parents form))))) when (consp subform) do (c1form-add-info-loop form subform))) (defun c1form-add-info (form dependents) (let ((record (gethash (c1form-name form) +c1-form-hash+))) (unless record (error "Internal error: unknown C1FORM name ~A" (c1form-name form))) (let ((length (first record)) (sp-change (c1form-sp-change form)) (side-effects (second record))) (setf (c1form-side-effects form) (or (c1form-side-effects form) sp-change side-effects) (c1form-parents form) (list form)) (unless (or (null length) (= length (length (c1form-args form)))) (error "Internal error: illegal number of arguments in ~A" form)))) (c1form-add-info-loop form dependents)) (defun copy-c1form (form) (copy-structure form)) (defmacro c1form-arg (nth form) (case nth (0 `(first (c1form-args ,form))) (1 `(second (c1form-args ,form))) (otherwise `(nth ,nth (c1form-args ,form))))) (defun c1form-volatile* (form) (if (c1form-volatile form) "volatile " "")) (defun c1form-primary-type (form) (values-type-primary-type (c1form-type form))) #-new-cmp (defun location-primary-type (form) (c1form-primary-type form)) (defun find-form-in-node-list (form list) (let ((v1 (loop with form-parents = (c1form-parents form) for presumed-child-parents in list thereis (tailp form-parents presumed-child-parents))) (v2 (loop for presumed-child-parents in list thereis (member form presumed-child-parents :test #'eq)))) (unless (eq (and v1 t) (and v2 t)) (baboon :format-control "Mismatch between FIND-FORM-IN-NODE-LISTs")) v1)) (defun add-form-to-node-list (form list) (list* (c1form-parents form) list)) (defun delete-form-from-node-list (form list) (let ((parents (c1form-parents form))) (unless (member parents list) (baboon :format-control "Unable to find C1FORM~%~4I~A~%in node list~%~4I~A" :format-arguments (list form list))) (delete parents list))) (defun traverse-c1form-tree (tree function) (cond ((consp tree) (loop for f in tree do (traverse-c1form-tree f function))) ((c1form-p tree) (loop for f in (c1form-args tree) do (traverse-c1form-tree f function)) (funcall function tree)))) (defun c1form-movable-p (form) (flet ((abort-on-not-pure (form) (let ((name (c1form-name form))) (cond ((eq name 'VAR) (let ((var (c1form-arg 0 form))) (when (or (global-var-p var) (var-set-nodes var)) (return-from c1form-movable-p nil)))) ((or (c1form-side-effects form) (not (third (gethash name +c1-form-hash+)))) (return-from c1form-movable-p nil)))))) (abort-on-not-pure form))) (defun c1form-pure-p (form) (third (gethash (c1form-name form) +c1-form-hash+))) (defun c1form-unmodified-p (form rest-form) (flet ((abort-on-not-pure (form) (let ((name (c1form-name form))) (cond ((eq name 'VAR) (let ((var (c1form-arg 0 form))) (when (or (global-var-p var) (var-changed-in-form-list var rest-form)) (return-from c1form-unmodified-p nil)))) ((or (c1form-side-effects form) (not (c1form-pure-p form))) (return-from c1form-unmodified-p nil)))))) (traverse-c1form-tree form #'abort-on-not-pure) t)) (defun c1form-values-number (form) (if (fourth (gethash (c1form-name form) +c1-form-hash+)) (values 1 1) (values-number-from-type (c1form-type form)))) (defun c1form-single-valued-p (form) (or (fourth (gethash (c1form-name form) +c1-form-hash+)) (<= (nth-value 1 (c1form-values-number form)) 1))) (defmacro with-c1form-env ((form value) &rest body) `(let* ((,form ,value) (*compile-file-truename* (c1form-file ,form)) (*compile-file-position* (c1form-file-position ,form)) (*current-toplevel-form* (c1form-toplevel-form ,form)) (*current-form* (c1form-form ,form)) (*cmp-env* (c1form-env ,form))) ,@body)) (defun relocate-parents-list (dest new-fields) (let* ((old (c1form-parents dest)) (first-cons (or (c1form-parents new-fields) old))) (setf (car first-cons) dest (cdr first-cons) (rest old) (c1form-parents new-fields) nil (c1form-parents dest) first-cons))) (defun c1form-replace-with (dest new-fields) ;; Side effects might have to be propagated to the parents ;; but currently we do not allow moving forms with side effects (when (c1form-side-effects new-fields) (baboon :format-control "Attempted to move a form with side-effects")) ;; The following protocol is only valid for VAR references. (unless (eq (c1form-name dest) 'VAR) (baboon :format-control "Cannot replace forms other than VARs:~%~4I~A" dest)) ;; We have to relocate the children nodes of NEW-FIELDS in ;; the new branch. This implies rewriting the parents chain, ;; but only for non-location nodes (these are reused). The only ;; exceptions are forms that can be fully replaced (case (c1form-name new-fields) (LOCATION) (VAR (let ((var (c1form-arg 0 new-fields))) ;; If this is the first time we replace a reference with this one ;; then we have to remove it from the read nodes of the variable (when (c1form-parents new-fields) (delete-from-read-nodes var new-fields)) ;; ... and then add the new node (relocate-parents-list dest new-fields) (add-to-read-nodes var dest))) (t (relocate-parents-list dest new-fields))) ;; Remaining flags are just copied (setf (c1form-name dest) (c1form-name new-fields) (c1form-local-vars dest) (c1form-local-vars new-fields) (c1form-type dest) (values-type-and (c1form-type new-fields) (c1form-type dest)) (c1form-sp-change dest) (c1form-sp-change new-fields) (c1form-side-effects dest) (c1form-side-effects new-fields) (c1form-volatile dest) (c1form-volatile new-fields) (c1form-args dest) (c1form-args new-fields) (c1form-env dest) (c1form-env new-fields) (c1form-form dest) (c1form-form new-fields) (c1form-toplevel-form dest) (c1form-toplevel-form new-fields) (c1form-file dest) (c1form-file new-fields) (c1form-file-position dest) (c1form-file-position new-fields))) ;; should check whether a form before var causes a side-effect ;; exactly one occurrence of var is present in forms (defun delete-c1forms (form) (flet ((eliminate-references (form) (when (eq (c1form-name form) 'VAR) (let ((var (c1form-arg 0 form))) (when var (delete-from-read-nodes var form)))))) (traverse-c1form-tree form #'eliminate-references))) (defun c1form-constant-p (form) (when (eq (c1form-name form) 'LOCATION) (loc-immediate-value-p (c1form-arg 0 form)))) ecl-16.1.2/src/cmp/cmpfun.lsp000066400000000000000000000066141266352375300157450ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: C -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; CMPFUN Library functions. ;;;; Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. ;;;; Copyright (c) 1990, Giuseppe Attardi and William F. Schelter. ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. (in-package "COMPILER") (defun c1apply (args) (check-args-number 'APPLY args 2) (flet ((default-apply (fun arguments) (let ((form (c1funcall (list* '#'APPLY fun arguments)))) (when (and (consp fun) (eq (first fun) 'FUNCTION)) (let* ((fname (second fun)) (type (get-return-type fname))) (when type (setf (c1form-type form) type)))) form))) (let* ((fun (first args)) (arguments (rest args))) (cond ((eql (first (last arguments)) 'clos::.combined-method-args.) ;; Uses frames instead of lists as last argumennt (default-apply fun arguments)) ((and (consp fun) (eq (first fun) 'LAMBDA)) (optimize-funcall/apply-lambda (cdr fun) arguments t)) ((and (consp fun) (eq (first fun) 'EXT::LAMBDA-BLOCK)) (setf fun (macroexpand-1 fun)) (optimize-funcall/apply-lambda (cdr fun) arguments t)) ((and (consp fun) (eq (first fun) 'FUNCTION) (consp (second fun)) (member (caadr fun) '(LAMBDA EXT::LAMBDA-BLOCK))) (c1apply (list* (second fun) arguments))) (t (default-apply fun arguments)))))) ;;---------------------------------------------------------------------- ;; We transform BOOLE into the individual operations, which have ;; inliners ;; (define-compiler-macro boole (&whole form op-code op1 op2) (or (and (constantp op-code *cmp-env*) (case (ext:constant-form-value op-code *cmp-env*) (#. boole-clr `(progn ,op1 ,op2 0)) (#. boole-set `(progn ,op1 ,op2 -1)) (#. boole-1 `(prog1 ,op1 ,op2)) (#. boole-2 `(progn ,op1 ,op2)) (#. boole-c1 `(prog1 (lognot ,op1) ,op2)) (#. boole-c2 `(progn ,op1 (lognot ,op2))) (#. boole-and `(logand ,op1 ,op2)) (#. boole-ior `(logior ,op1 ,op2)) (#. boole-xor `(logxor ,op1 ,op2)) (#. boole-eqv `(logeqv ,op1 ,op2)) (#. boole-nand `(lognand ,op1 ,op2)) (#. boole-nor `(lognor ,op1 ,op2)) (#. boole-andc1 `(logandc1 ,op1 ,op2)) (#. boole-andc2 `(logandc2 ,op1 ,op2)) (#. boole-orc1 `(logorc1 ,op1 ,op2)) (#. boole-orc2 `(logorc2 ,op1 ,op2)))) form)) ;---------------------------------------------------------------------- ;; Return the most particular type we can EASILY obtain from x. (defun result-type (x) (cond ((symbolp x) (c1form-primary-type (c1expr x))) ((constantp x) (type-of x)) ((and (consp x) (eq (car x) 'the)) (second x)) (t t))) ecl-16.1.2/src/cmp/cmpglobals.lsp000066400000000000000000000306201266352375300165720ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: C -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; Copyright (c) 2010, Juan Jose Garcia-Ripoll ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. ;;;; ;;;; CMPGLOBALS -- Global variables and flag definitions ;;;; (in-package #-new-cmp "COMPILER" #+new-cmp "C-DATA") ;;; ;;; VARIABLES ;;; ;;; --cmpinline.lsp-- ;;; ;;; Empty info struct ;;; #-new-cmp (defvar *info* (make-info)) (defvar *inline-blocks* 0) (defvar *opened-c-braces* 0) ;;; *inline-blocks* holds the number of C blocks opened for declaring ;;; temporaries for intermediate results of the evaluation of inlined ;;; function calls. (defvar *inline-max-depth* 3 "Depth at which inlining of functions stops.") (defvar *inline-information* nil) ;;; --cmputil.lsp-- ;;; ;;; Variables and constants for error handling ;;; (defvar *current-form* '|compiler preprocess|) (defvar *current-toplevel-form* '|compiler preprocess|) (defvar *compile-file-position* -1) (defvar *first-error* t) (defvar *active-protection* nil) (defvar *pending-actions* nil) (defvar *compiler-conditions* '() "This variable determines whether conditions are printed or just accumulated.") (defvar *compile-print* nil "This variable controls whether the compiler displays messages about each form it processes. The default value is NIL.") (defvar *compile-verbose* nil "This variable controls whether the compiler should display messages about its progress. The default value is T.") (defvar *compiler-features* #+ecl-min nil #-ecl-min '#.*compiler-features* "This alternative list of features contains keywords that were gathered from running the compiler. It may be updated by running ") (defvar *suppress-compiler-messages* #+ecl-min 'compiler-debug-note #-ecl-min 'compiler-note "A type denoting which compiler messages and conditions are _not_ displayed.") (defvar *compiler-break-enable* nil) (defvar *compiler-in-use* nil) (defvar *compiler-input*) (defvar *compiler-output1*) (defvar *compiler-output2*) ;;; --cmpcbk.lsp-- ;;; ;;; List of callbacks to be generated ;;; (defvar *callbacks* nil) ;;; --cmpc-machine.lsp, cmpffi.lsp --- (defvar *machine* nil) ;;; --cmpcall.lsp-- ;;; ;;; Whether to use linking calls. ;;; (defvar *compile-to-linking-call* t) (defvar *compiler-declared-globals*) ;;; --cmpenv.lsp-- ;;; ;;; These default settings are equivalent to (optimize (speed 3) (space 0) (safety 2)) ;;; (defvar *safety* 2) (defvar *speed* 3) (defvar *space* 0) (defvar *debug* 0) ;;; Emit automatic CHECK-TYPE forms for function arguments in lambda forms. (defvar *automatic-check-type-in-lambda* t) ;;; ;;; Compiled code uses the following kinds of variables: ;;; 1. Vi, declared explicitely, either unboxed or not (*lcl*, next-lcl) ;;; 2. Ti, declared collectively, of type object, may be reused (*temp*, next-temp) ;;; 4. lexi[j], for lexical variables in local functions ;;; 5. CLVi, for lexical variables in closures (defvar *lcl* 0) ; number of local variables #-new-cmp (defvar *temp* 0) ; number of temporary variables #-new-cmp (defvar *max-temp* 0) ; maximum *temp* reached (defvar *level* 0) ; nesting level for local functions (defvar *lex* 0) ; number of lexical variables in local functions (defvar *max-lex* 0) ; maximum *lex* reached (defvar *env* 0) ; number of variables in current form (defvar *max-env* 0) ; maximum *env* in whole function (defvar *env-lvl* 0) ; number of levels of environments #-new-cmp (defvar *aux-closure* nil) ; stack allocated closure needed for indirect calls #-new-cmp (defvar *ihs-used-p* nil) ; function must be registered in IHS? #-new-cmp (defvar *next-cmacro* 0) ; holds the last cmacro number used. (defvar *next-cfun* 0) ; holds the last cfun used. ;;; ;;; *tail-recursion-info* holds NIL, if tail recursion is impossible. ;;; If possible, *tail-recursion-info* holds ;; ( c1-lambda-form required-arg .... required-arg ), ;;; where each required-arg is a var-object. ;;; (defvar *tail-recursion-info* nil) (defvar *allow-c-local-declaration* t) ;;; --cmpexit.lsp-- ;;; ;;; *last-label* holds the label# of the last used label. ;;; *exit* holds an 'exit', which is ;; ( label# . ref-flag ) or one of RETURNs (i.e. RETURN, RETURN-FIXNUM, ;; RETURN-CHARACTER, RETURN-DOUBLE-FLOAT, RETURN-SINGLE-FLOAT, or ;; RETURN-OBJECT). ;;; *unwind-exit* holds a list consisting of: ;; ( label# . ref-flag ), one of RETURNs, TAIL-RECURSION-MARK, FRAME, ;; JUMP, BDS-BIND (each pushed for a single special binding), or a ;; LCL (which holds the bind stack pointer used to unbind). ;;; (defvar *last-label* 0) (defvar *exit*) (defvar *unwind-exit*) (defvar *current-function* nil) (defvar *cmp-env* nil "The compiler environment consists of a pair or cons of two lists, one containing variable records, the other one macro and function recors: variable-record = (:block block-name) | (:tag ({tag-name}*)) | (:function function-name) | (var-name {:special | nil} bound-p) | (symbol si::symbol-macro macro-function) | CB | LB | UNWIND-PROTECT macro-record = (function-name function) | (macro-name si::macro macro-function) CB | LB | UNWIND-PROTECT A *-NAME is a symbol. A TAG-ID is either a symbol or a number. A MACRO-FUNCTION is a function that provides us with the expansion for that local macro or symbol macro. BOUND-P is true when the variable has been bound by an enclosing form, while it is NIL if the variable-record corresponds just to a special declaration. CB, LB and UNWIND-PROTECT are only used by the C compiler and they denote closure, lexical environment and unwind-protect boundaries. Note that compared with the bytecodes compiler, these records contain an additional variable, block, tag or function object at the end.") (defvar *cmp-env-root* (cons nil (list (list '#:no-macro 'si::macro (constantly nil)))) "This is the common environment shared by all toplevel forms. It can only be altered by DECLAIM forms and it is used to initialize the value of *CMP-ENV*.") ;;; --cmplog.lsp-- ;;; ;;; Destination of output of different forms. See cmploc.lsp for types ;;; of destinations. ;;; (defvar *destination*) ;;; --cmpmain.lsp-- ;;; ;;; Do we debug the compiler? Then we need files not to be deleted. (defvar *debug-compiler* nil) (defvar *delete-files* t) (defvar *files-to-be-deleted* '()) (defvar *user-ld-flags* '() "Flags and options to be passed to the linker when building FASL, shared libraries and standalone programs. It is not required to surround values with quotes or use slashes before special characters.") (defvar *user-cc-flags* '() "Flags and options to be passed to the C compiler when building FASL, shared libraries and standalone programs. It is not required to surround values with quotes or use slashes before special characters.") ;;; ;;; Compiler program and flags. ;;; ;;; --cmptop.lsp-- ;;; (defvar *do-type-propagation* t "Flag for switching on the type propagation phase. Use with care, experimental.") (defvar *compiler-phase* nil) (defvar *volatile*) #-new-cmp (defvar *setjmps* 0) (defvar *compile-toplevel* T "Holds NIL or T depending on whether we are compiling a toplevel form.") (defvar *clines-string-list* '() "List of strings containing C/C++ statements which are directly inserted in the translated C/C++ file. Notice that it is unspecified where these lines are inserted, but the order is preserved") (defvar *compile-time-too* nil) #-new-cmp (defvar *not-compile-time* nil) (defvar *permanent-data* nil) ; detemines whether we use *permanent-objects* ; or *temporary-objects* (defvar *permanent-objects* nil) ; holds { ( object (VV vv-index) ) }* (defvar *temporary-objects* nil) ; holds { ( object (VV vv-index) ) }* (defvar *load-objects* nil) ; hash with association object -> vv-location (defvar *load-time-values* nil) ; holds { ( vv-index form ) }*, ;;; where each vv-index should be given an object before ;;; defining the current function during loading process. (defvar *setf-definitions* nil) ; C forms to find out (SETF fname) locations (defvar *optimizable-constants* nil) ; (value . c1form) pairs for inlining constants (defvar *use-static-constants-p* ; T/NIL flag to determine whether one may #+ecl-min t #-ecl-min nil) ; generate lisp constant values as C structs (defvar *static-constants* nil) ; constants that can be built as C values ; holds { ( object c-variable constant ) }* (defvar *compiler-constants* nil) ; a vector with all constants ; only used in COMPILE (defvar *proclaim-fixed-args* nil) ; proclaim automatically functions ; with fixed number of arguments. ; watch out for multiple values. (defvar *global-vars* nil) ; variables declared special (defvar *global-funs* nil) ; holds { fun }* (defvar *use-c-global* nil) ; honor si::c-global declaration (defvar *global-cfuns-array* nil) ; holds { fun }* (defvar *linking-calls* nil) ; holds { ( global-fun-name fun symbol c-fun-name var-name ) }* (defvar *local-funs* nil) ; holds { fun }* (defvar *top-level-forms* nil) ; holds { top-level-form }* (defvar *make-forms* nil) ; holds { top-level-form }* ;;; ;;; top-level-form: ;;; ( 'DEFUN' fun-name cfun lambda-expr doc-vv sp ) ;;; | ( 'DEFMACRO' macro-name cfun lambda-expr doc-vv sp ) ;;; | ( 'ORDINARY' expr ) ;;; | ( 'DECLARE' var-name-vv ) ;;; | ( 'DEFVAR' var-name-vv expr doc-vv ) ;;; | ( 'CLINES' string* ) ;;; | ( 'LOAD-TIME-VALUE' vv ) ;;; *global-entries* holds (... ( fname cfun return-types arg-type ) ...). (defvar *global-entries* nil) (defvar *global-macros* nil) (defvar *self-destructing-fasl* '() "A value T means that, when a FASL module is being unloaded (for instance during garbage collection), the associated file will be deleted. We need this for #'COMPILE because windows DLLs cannot be deleted if they have been opened with LoadLibrary.") (defvar *undefined-vars* nil) ;;; Only these flags are set by the user. ;;; If (safe-compile) is ON, some kind of run-time checks are not ;;; included in the compiled code. The default value is OFF. (defconstant +init-env-form+ '((*gensym-counter* 0) (*compiler-in-use* t) (*compiler-phase* 't1) (*callbacks* nil) (*cmp-env-root* (copy-tree *cmp-env-root*)) (*cmp-env* nil) #-new-cmp (*max-temp* 0) #-new-cmp (*temp* 0) #-new-cmp (*next-cmacro* 0) (*next-cfun* 0) (*last-label* 0) (*load-objects* (make-hash-table :size 128 :test #'equal)) (*setf-definitions* nil) (*make-forms* nil) (*static-constants* nil) (*permanent-objects* nil) (*temporary-objects* nil) (*local-funs* nil) (*global-vars* nil) (*global-funs* nil) (*global-cfuns-array* nil) (*linking-calls* nil) (*global-entries* nil) (*undefined-vars* nil) (*top-level-forms* nil) (*compile-time-too* nil) (*clines-string-list* '()) (*inline-blocks* 0) (*open-c-braces* 0) #+new-cmp (*type-and-cache* (type-and-empty-cache)) #+new-cmp (*type-or-cache* (type-or-empty-cache)) #+new-cmp (*values-type-or-cache* (values-type-or-empty-cache)) #+new-cmp (*values-type-and-cache* (values-type-and-empty-cache)) #+new-cmp (*values-type-primary-type-cache* (values-type-primary-type-empty-cache)) #+new-cmp (*values-type-to-n-types-cache* (values-type-to-n-types-empty-cache)) (si::*defun-inline-hook* 'maybe-install-inline-function) (*machine* (or *machine* +default-machine+)) (*optimizable-constants* (make-optimizable-constants *machine*)) (*inline-information* (let ((r (machine-inline-information *machine*))) (if r (si::copy-hash-table r) (make-inline-information *machine*)))) )) ecl-16.1.2/src/cmp/cmpif.lsp000066400000000000000000000173071266352375300155540ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: C -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. ;;;; Copyright (c) 1990, Giuseppe Attardi. ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. ;;;; CMPIF Conditionals. (in-package "COMPILER") (defun c1if (args) (check-args-number 'IF args 2 3) (let ((test (c1expr (car args)))) ;; Resolve IF expressions with constant arguments (multiple-value-bind (constant-p value) (c1form-constant-p test) (when constant-p (return-from c1if (if value (second args) (third args))))) ;; Otherwise, normal IF form (let* ((true-branch (c1expr (second args))) (false-branch (c1expr (third args)))) (make-c1form* 'IF :type (values-type-or (c1form-type true-branch) (c1form-type false-branch)) :args test true-branch false-branch)))) (defun c1not (args) (check-args-number 'NOT args 1 1) (let* ((value (c1expr (first args)))) ;; When the argument is constant, we can just return ;; a constant as well. (multiple-value-bind (constant-p value) (c1form-constant-p value) (when constant-p (return-from c1not (not value)))) (make-c1form* 'FMLA-NOT :type '(member t nil) :args value))) (defun c1and (args) ;; (AND) => T (if (null args) (c1t) (let* ((values (c1args* args)) (last (first (last values))) (butlast (nbutlast values))) ;; (AND x) => x (if butlast (make-c1form* 'FMLA-AND :type (type-or 'null (c1form-primary-type last)) :args butlast last) last)))) (defun c1or (args) ;; (OR) => T (if (null args) (c1nil) (let* ((values (c1args* args)) (last (first (last values))) (butlast (butlast values))) ;; (OR x) => x (if butlast (make-c1form* 'FMLA-OR :type (reduce #'type-or butlast :key #'c1form-primary-type :initial-value (c1form-primary-type last)) :args butlast last) last)))) (defun c2if (c1form fmla form1 form2) (declare (ignore c1form)) ;; FIXME! Optimize when FORM1 or FORM2 are constants (cond ((and (eq *destination* 'TRASH) (eq (c1form-name form2) 'LOCATION)) ;; Optimize (IF condition true-branch) or a situation in which ;; the false branch can be discarded. (with-optional-exit-label (false-label) (let ((*destination* `(JUMP-FALSE ,false-label))) (c2expr* fmla)) (c2expr form1))) ((and (eq *destination* 'TRASH) (eq (c1form-name form1) 'LOCATION)) ;; Optimize (IF condition useless-value false-branch) when ;; the true branch can be discarded. (with-optional-exit-label (true-label) (let ((*destination* `(JUMP-TRUE ,true-label))) (c2expr* fmla)) (c2expr form2))) (t (with-exit-label (false-label) (let ((*destination* `(JUMP-FALSE ,false-label))) (c2expr* fmla)) (c2expr form1)) (c2expr form2)))) (defun negate-argument (inlined-arg dest-loc) (let* ((loc (second inlined-arg)) (rep-type (loc-representation-type loc))) (apply #'produce-inline-loc (list inlined-arg) (if (eq (loc-representation-type dest-loc) :bool) (case rep-type (:bool '((:bool) (:bool) "(#0)==ECL_NIL" nil t)) (:object '((:object) (:bool) "(#0)!=ECL_NIL" nil t)) (otherwise (return-from negate-argument nil))) (case rep-type (:bool '((:bool) (:object) "(#0)?ECL_NIL:ECL_T" nil t)) (:object '((:object) (:object) "Null(#0)?ECL_T:ECL_NIL" nil t)) (otherwise (return-from negate-argument nil))))))) (defun c2fmla-not (c1form arg) (declare (ignore c1form)) (let ((dest *destination*)) (cond ((jump-true-destination-p dest) (let ((*destination* `(JUMP-FALSE ,@(cdr dest)))) (c2expr arg))) ((jump-false-destination-p dest) (let ((*destination* `(JUMP-TRUE ,@(cdr dest)))) (c2expr arg))) (t (let ((*inline-blocks* 0) (*temp* *temp*)) (unwind-exit (negate-argument (emit-inline-form arg nil) dest)) (close-inline-blocks)))))) (defun jump-true-destination-p (dest) (and (consp dest) (eq (si:cons-car dest) 'JUMP-TRUE))) (defun jump-false-destination-p (dest) (and (consp dest) (eq (si:cons-car dest) 'JUMP-FALSE))) (defun c2fmla-and (c1form butlast last) (declare (ignore c1form)) (if (jump-false-destination-p *destination*) (progn (mapc #'c2expr* butlast) (c2expr last)) (with-exit-label (normal-exit) (with-exit-label (false-label) (let ((*destination* `(JUMP-FALSE ,false-label))) (mapc #'c2expr* butlast)) (c2expr last)) (unwind-exit nil)))) (defun c2fmla-or (c1form butlast last) (declare (ignore c1form)) (cond ((jump-true-destination-p *destination*) (mapc #'c2expr* butlast) (c2expr last)) ((jump-false-destination-p *destination*) (with-exit-label (true-label) (let ((*destination* `(JUMP-TRUE ,true-label))) (mapc #'c2expr* butlast)) (c2expr last)) (unwind-exit t)) (t (with-exit-label (common-exit) (with-exit-label (normal-exit) (dolist (f butlast) (let ((*destination* 'VALUE0)) (c2expr* f)) (set-jump-true 'VALUE0 normal-exit)) (c2expr last)) (unwind-exit 'VALUE0))))) (defun set-jump-true (loc label) (multiple-value-bind (constantp value) (loc-immediate-value-p loc) (cond ((not constantp) (cond ((eq (loc-representation-type loc) :bool) (wt-nl "if (" loc ") {")) (t (wt-nl "if ((") (wt-coerce-loc :object loc) (wt ")!=ECL_NIL) {"))) (cond ((unwind-no-exit label) (incf *opened-c-braces*) (wt-nl) (wt-go label) (wt-nl-close-brace)) (t (wt " ") (wt-go label) (wt " }")))) ((null value)) (t (unwind-no-exit label) (wt-nl) (wt-go label))))) (defun set-jump-false (loc label) (multiple-value-bind (constantp value) (loc-immediate-value-p loc) (cond ((not constantp) (cond ((eq (loc-representation-type loc) :bool) (wt-nl "if (!(" loc ")) {")) (t (wt-nl "if (Null(") (wt-coerce-loc :object loc) (wt ")) {"))) (cond ((unwind-no-exit label) (incf *opened-c-braces*) (wt-nl) (wt-go label) (wt-nl-close-brace)) (t (wt " ") (wt-go label) (wt " }")))) (value) (t (unwind-no-exit label) (wt-nl) (wt-go label))))) ecl-16.1.2/src/cmp/cmpinline.lsp000066400000000000000000000157451266352375300164400ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: C -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. ;;;; Copyright (c) 1990, Giuseppe Attardi. ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. ;;;; CMPINLINE Open coding optimizer. (in-package "COMPILER") ;;; Valid property names for open coded functions are: ;;; :INLINE-ALWAYS ;;; :INLINE-SAFE safe-compile only ;;; :INLINE-UNSAFE non-safe-compile only ;;; ;;; Each property is a list of 'inline-info's, where each inline-info is: ;;; ( types { type | boolean } { string | function } ). ;;; ;;; For each open-codable function, open coding will occur only if there exits ;;; an appropriate property with the argument types equal to 'types' and with ;;; the return-type equal to 'type'. The third element ;;; is T if and only if side effects may occur by the call of the function. ;;; Even if *DESTINATION* is TRASH, open code for such a function with side ;;; effects must be included in the compiled code. ;;; The forth element is T if and only if the result value is a new Lisp ;;; object, i.e., it must be explicitly protected against GBC. (defun make-inline-temp-var (value-type &optional rep-type) (let ((out-rep-type (or rep-type (lisp-type->rep-type value-type)))) (if (eq out-rep-type :object) (make-temp-var) (let ((var (make-lcl-var :rep-type out-rep-type :type value-type))) (open-inline-block) (wt-nl (rep-type->c-name out-rep-type) " " var ";") var)))) (defun save-inline-loc (loc) (let* ((rep-type (loc-representation-type (second loc))) (temp (make-inline-temp-var (first loc) rep-type)) (*destination* temp)) (set-loc loc) temp)) (defmacro with-inlined-loc ((temp-loc loc) &rest body) `(let ((,temp-loc (save-inline-loc ,loc))) (setf ,temp-loc (list (var-type ,temp-loc) ,temp-loc)) ,@body)) (defun emit-inlined-variable (form rest-forms) (let ((var (c1form-arg 0 form)) (value-type (c1form-primary-type form))) (if (var-changed-in-form-list var rest-forms) (let* ((temp (make-inline-temp-var value-type (var-rep-type var)))) (let ((*destination* temp)) (set-loc var)) (list value-type temp)) (list value-type var)))) (defun emit-inlined-setq (form rest-forms) (let ((vref (c1form-arg 0 form)) (form1 (c1form-arg 1 form))) (let ((*destination* vref)) (c2expr* form1)) (if (eq (c1form-name form1) 'LOCATION) (list (c1form-primary-type form1) (c1form-arg 0 form1)) (emit-inlined-variable (make-c1form 'VAR form vref) rest-forms)))) (defun emit-inlined-call-global (form expected-type) (let* ((fname (c1form-arg 0 form)) (args (c1form-arg 1 form)) (return-type (c1form-primary-type form)) (fun (find fname *global-funs* :key #'fun-name :test #'same-fname-p)) (loc (call-global-loc fname fun args return-type expected-type)) (type (type-and return-type (loc-type loc))) (temp (make-inline-temp-var type (loc-representation-type loc))) (*destination* temp)) (set-loc loc) (list type temp))) (defun emit-inlined-progn (form forms) (let ((args (c1form-arg 0 form))) (loop with *destination* = 'TRASH while (rest args) do (c2expr* (pop args))) (emit-inline-form (first args) forms))) (defun emit-inlined-values (form forms) (let ((args (c1form-arg 0 form))) (prog1 (emit-inline-form (or (pop args) (c1nil)) forms) (loop with *destination* = 'TRASH for form in args do (c2expr* form))))) (defun emit-inlined-structure-ref (form rest-forms) (let ((type (c1form-primary-type form))) (if (args-cause-side-effect rest-forms) (let* ((temp (make-inline-temp-var type :object)) (*destination* temp)) (c2expr* form) (list type temp)) (list type (list 'SYS:STRUCTURE-REF (first (coerce-locs (inline-args (list (c1form-arg 0 form))))) (c1form-arg 1 form) (c1form-arg 2 form) (c1form-arg 3 form)))))) (defun emit-inlined-instance-ref (form rest-forms) (let ((type (c1form-primary-type form))) (if (args-cause-side-effect rest-forms) (let* ((temp (make-inline-temp-var type :object)) (*destination* temp)) (c2expr* form) (list type temp)) (list type (list 'SYS:INSTANCE-REF (first (coerce-locs (inline-args (list (c1form-arg 0 form))))) (c1form-arg 1 form) #+nil (c1form-arg 2 form)))))) (defun emit-inline-form (form forms) (with-c1form-env (form form) (case (c1form-name form) (LOCATION (list (c1form-primary-type form) (c1form-arg 0 form))) (VAR (emit-inlined-variable form forms)) (CALL-GLOBAL (emit-inlined-call-global form (c1form-primary-type form))) (SYS:STRUCTURE-REF (emit-inlined-structure-ref form forms)) #+clos (SYS:INSTANCE-REF (emit-inlined-instance-ref form forms)) (SETQ (emit-inlined-setq form forms)) (PROGN (emit-inlined-progn form forms)) (VALUES (emit-inlined-values form forms)) (t (let* ((type (c1form-primary-type form)) (temp (make-inline-temp-var type))) (let ((*destination* temp)) (c2expr* form)) (list type temp)))))) ;;; ;;; inline-args: ;;; returns a list of pairs (type loc) ;;; side effects: emits code for temporary variables ;;; ;;; Whoever calls inline-args must bind *inline-blocks* to 0 and afterwards ;;; call close-inline-blocks ;;; (defun inline-args (forms) (loop for form-list on forms for form = (first form-list) collect (emit-inline-form form (rest form-list)))) (defun destination-type () (rep-type->lisp-type (loc-representation-type *destination*)) ;;(loc-type *destination*) ) (defun maybe-open-inline-block () (unless (plusp *inline-blocks*) (open-inline-block))) (defun open-inline-block () (wt-nl-open-brace) (incf *inline-blocks*)) (defun close-inline-blocks (&optional new-line) (loop for i of-type fixnum from 0 below *inline-blocks* do (wt-nl-close-brace))) (defun form-causes-side-effect (form) (c1form-side-effects form)) (defun args-cause-side-effect (forms) (some #'c1form-side-effects forms)) (defun function-may-have-side-effects (fname) (not (get-sysprop fname 'no-side-effects))) (defun function-may-change-sp (fname) (not (or (get-sysprop fname 'no-side-effects) (get-sysprop fname 'no-sp-change)))) ecl-16.1.2/src/cmp/cmplam.lsp000066400000000000000000000606031266352375300157240ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: C -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. ;;;; Copyright (c) 1990, Giuseppe Attardi. ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. ;;;; CMPLAM Lambda expression. (in-package "COMPILER") ;;; During Pass1, a lambda-list ;;; ;;; ( { var }* ;;; [ &optional { var | ( var [ initform [ svar ] ] ) }* ] ;;; [ &rest var ] ;;; [ &key { var | ( { var | ( kwd var ) } [initform [ svar ]])}* ;;; [&allow-other-keys]] ;;; [ &aux {var | (var [initform])}*] ;;; ) ;;; ;;; is transformed into ;;; ;;; ( ( { var }* ) ; required ;;; ( { var initform svar }* ) ; optional ;;; { var | nil } ; rest ;;; allow-other-keys-flag ;;; ( { kwd-vv-index var initform svar }* ) ; key ;;; ) ;;; ;;; where ;;; svar: NIL ; means svar is not supplied ;;; | var ;;; ;;; &aux parameters will be embedded into LET*. ;;; ;;; c1lambda-expr receives ;;; ( lambda-list { doc | decl }* . body ) ;;; and returns ;;; ( lambda info-object lambda-list' doc body' ) ;;; ;;; Doc is NIL if no doc string is supplied. ;;; Body' is body possibly surrounded by a LET* (if &aux parameters are ;;; supplied) and an implicit block. (defun c1lambda-doc (form) (second (c1form-args form))) (defun c1lambda-body (form) (third (c1form-args form))) (defun c1lambda-list (form) (first (c1form-args form))) (defun fun-needs-narg (fun) (not (fun-fixed-narg fun))) (defun fun-fixed-narg (fun) "Returns true if the function has a fixed number of arguments and it is not a closure. The function thus belongs to the type of functions that ecl_make_cfun accepts." (let (narg) (and (not (eq (fun-closure fun) 'CLOSURE)) (= (fun-minarg fun) (setf narg (fun-maxarg fun))) (<= narg si::c-arguments-limit) narg))) (defun add-to-fun-referenced-vars (fun var-list) (loop with new-vars = (fun-referenced-vars fun) with locals = (fun-local-vars fun) with change = nil for v in var-list when (and (not (member v locals :test #'eq)) (not (member v new-vars :test #'eq))) do (setf change t new-vars (cons v new-vars)) finally (when change (setf (fun-referenced-vars fun) new-vars) (return t)))) (defun add-to-fun-referenced-funs (fun fun-list) (loop with new-funs = (fun-referenced-funs fun) with change = nil for f in fun-list when (and (not (eq fun f)) (not (member f new-funs :test #'eq)) (not (child-function-p fun f))) do (setf change t new-funs (cons f new-funs) (fun-referencing-funs f) (cons fun (fun-referencing-funs f))) finally (when change (setf (fun-referenced-funs fun) new-funs) (return t)))) (defun c1compile-function (lambda-list-and-body &key (fun (make-fun)) (name (fun-name fun)) (CB/LB 'CB)) (let ((lambda (if name `(ext:lambda-block ,name ,@lambda-list-and-body) `(lambda ,@lambda-list-and-body)))) (setf (fun-name fun) name (fun-lambda-expression fun) lambda (fun-parent fun) *current-function*)) (when *current-function* (push fun (fun-child-funs *current-function*))) (let* ((*current-function* fun) (*cmp-env* (setf (fun-cmp-env fun) (cmp-env-mark CB/LB))) (setjmps *setjmps*) (decl (si::process-declarations (rest lambda-list-and-body))) (global (and *use-c-global* (assoc 'SI::C-GLOBAL decl) (setf (fun-global fun) T))) (no-entry (assoc 'SI::C-LOCAL decl)) (lambda-expr (c1lambda-expr lambda-list-and-body name (si::function-block-name name))) cfun exported minarg maxarg) (when (and no-entry (policy-debug-ihs-frame)) (setf no-entry nil) (cmpnote "Ignoring SI::C-LOCAL declaration for~%~4I~A~%because the debug level is large" name)) (unless (eql setjmps *setjmps*) (setf (c1form-volatile lambda-expr) t)) (setf (fun-lambda fun) lambda-expr) (if global (multiple-value-setq (cfun exported) (exported-fname name)) (setf cfun (next-cfun "LC~D~A" name) exported nil)) #+ecl-min (when (member name c::*in-all-symbols-functions*) (setf no-entry t)) (if exported ;; Check whether the function was proclaimed to have a certain ;; number of arguments, and otherwise produce a function with ;; a flexible signature. (progn (multiple-value-setq (minarg maxarg) (get-proclaimed-narg name)) (format t "~&;;; Function ~A proclaimed (~A,~A)" name minarg maxarg) (unless minarg (setf minarg 0 maxarg call-arguments-limit))) (multiple-value-setq (minarg maxarg) (lambda-form-allowed-nargs lambda-expr))) (setf (fun-cfun fun) cfun (fun-exported fun) exported (fun-closure fun) nil (fun-minarg fun) minarg (fun-maxarg fun) maxarg (fun-description fun) name (fun-no-entry fun) no-entry) (loop for child in (fun-child-funs fun) do (add-to-fun-referenced-vars fun (fun-referenced-vars child)) do (add-to-fun-referenced-funs fun (fun-referenced-funs child))) (loop for f in (fun-referenced-funs fun) do (add-to-fun-referenced-vars fun (fun-referenced-vars f))) (update-fun-closure-type fun) (when global (if (fun-closure fun) (cmpnote "Function ~A is global but is closed over some variables.~%~{~A ~}" (fun-name fun) (mapcar #'var-name (fun-referenced-vars fun))) (new-defun fun (fun-no-entry fun))))) fun) (defun cmp-process-lambda-list (list) (handler-case (si::process-lambda-list list 'function) (error (c) (cmperr "Illegal lambda list ~S:~%~A" list c)))) (defun c1lambda-expr (lambda-expr function-name block-name &aux doc body ss is ts other-decls new-variables (type-checks '()) (*permanent-data* t) (old-env *cmp-env*) (*cmp-env* (cmp-env-copy))) (declare (si::c-local)) (cmpck (endp lambda-expr) "The lambda expression ~s is illegal." (cons 'LAMBDA lambda-expr)) (multiple-value-setq (body ss ts is other-decls doc) (c1body (cdr lambda-expr) t)) (when block-name (setq body (list (cons 'BLOCK (cons block-name body))))) (multiple-value-bind (requireds optionals rest key-flag keywords allow-other-keys aux-vars) (cmp-process-lambda-list (car lambda-expr)) (do ((specs (setq requireds (cdr requireds)) (cdr specs))) ((endp specs)) (let* ((name (first specs)) (var (c1make-var name ss is ts))) (push var type-checks) (setf (first specs) var) (push-vars var))) (do ((specs (setq optionals (cdr optionals)) (cdddr specs))) ((endp specs)) (let* ((name (first specs)) (var (c1make-var name ss is ts)) (init (second specs)) (flag (third specs))) (setq init (if init (and-form-type (var-type var) (c1expr init) init :safe "In (LAMBDA ~a...)" function-name) (default-init var))) (push var type-checks) (push-vars var) (when flag (push-vars (setq flag (c1make-var flag ss is ts)))) (setf (first specs) var (second specs) init (third specs) flag))) (when rest (push-vars (setq rest (c1make-var rest ss is ts)))) (do ((specs (setq keywords (cdr keywords)) (cddddr specs))) ((endp specs)) (let* ((key (first specs)) (name (second specs)) (var (c1make-var name ss is ts)) (init (third specs)) (flag (fourth specs))) (setq init (if init (and-form-type (var-type var) (c1expr init) init :safe "In (LAMBDA ~a...)" function-name) (default-init var))) (push var type-checks) (push-vars var) (when flag (push-vars (setq flag (c1make-var flag ss is ts)))) (setf (second specs) var (third specs) init (fourth specs) flag))) ;; Make other declarations take effect right now (setf *cmp-env* (reduce #'add-one-declaration other-decls :initial-value *cmp-env*)) ;; After creating all variables and processing the initalization ;; forms, we wil process the body. However, all free declarations, ;; that is declarations which do not refer to the function ;; arguments, have to be applied to the body. At the same time, we ;; replace &aux variables with a LET* form that defines them. (let* ((declarations other-decls) (type-checks (extract-lambda-type-checks function-name requireds optionals keywords ts other-decls)) (type-check-forms (car type-checks)) (let-vars (loop for spec on (nconc (cdr type-checks) aux-vars) by #'cddr for name = (first spec) for init = (second spec) collect (list name init))) (new-variables (cmp-env-new-variables *cmp-env* old-env)) (already-declared-names (set-difference (mapcar #'var-name new-variables) (mapcar #'car let-vars)))) ;; Gather declarations for &aux variables, either special... (let ((specials (set-difference ss already-declared-names))) (when specials (push `(special ,@specials) declarations))) ;; ...ignorable... (let ((ignorables (loop for (var . expected-uses) in is unless (member var already-declared-names) collect var))) (when ignorables (push `(ignorable ,@ignorables) declarations))) ;; ...or type declarations (loop for (var . type) in ts unless (member var already-declared-names) do (push `(type ,type ,var) declarations)) ;; ...create the enclosing LET* form for the &aux variables (when (or let-vars declarations) (setq body `((let* ,let-vars (declare ,@declarations) ,@body)))) ;; ...wrap around the optional type checks (setq body (nconc type-check-forms body)) ;; ...now finally compile the body with the type checks (let ((*cmp-env* (cmp-env-copy *cmp-env*))) (setf body (c1progn body))) ;; ;; ...and verify whether all variables are used. (dolist (var new-variables) (check-vref var)) (make-c1form* 'LAMBDA :local-vars new-variables :args (list requireds optionals rest key-flag keywords allow-other-keys) doc body)))) (defun lambda-form-allowed-nargs (lambda) (let ((minarg 0) (maxarg call-arguments-limit)) (destructuring-bind (requireds optionals rest key-flag keywords a-o-k) (c1form-arg 0 lambda) (when (and (null rest) (not key-flag) (not a-o-k)) (setf minarg (length requireds) maxarg (+ minarg (/ (length optionals) 3))))) (values minarg maxarg))) #| Steps: 1. defun creates declarations for requireds + va_alist 2. c2lambda-expr adds declarations for: unboxed requireds lexical optionals (+ supplied-p), rest, keywords (+ supplied-p) Lexical optionals and keywords can be unboxed if: a. there is more then one reference in the body b. they are not referenced in closures 3. binding is performed for: special or unboxed requireds optionals, rest, keywords 4. the function name is optionally pushed onto the IHS when the caller asks for it. |# (defun c2lambda-expr (lambda-list body cfun fname use-narg required-lcls closure-type &aux (requireds (first lambda-list)) (optionals (second lambda-list)) (rest (third lambda-list)) rest-loc (keywords (fifth lambda-list)) (allow-other-keys (sixth lambda-list)) (nreq (length requireds)) (nopt (/ (length optionals) 3)) (nkey (/ (length keywords) 4)) (varargs (or optionals rest keywords allow-other-keys)) (fname-in-ihs-p (or (policy-debug-variable-bindings) (and (policy-debug-ihs-frame) fname))) simple-varargs (*permanent-data* t) (*unwind-exit* *unwind-exit*) (*env* *env*) (*inline-blocks* 0) (last-arg)) (declare (fixnum nreq nkey)) (if (and fname ;; named function ;; no required appears in closure, (dolist (var (car lambda-list) t) (declare (type var var)) (when (var-ref-ccb var) (return nil))) (null (second lambda-list)) ;; no optionals, (null (third lambda-list)) ;; no rest parameter, and (null (fourth lambda-list))) ;; no keywords. (setf *tail-recursion-info* (cons *tail-recursion-info* (car lambda-list))) (setf *tail-recursion-info* nil)) ;; check arguments (when (policy-check-nargs) (if (and use-narg (not varargs)) (wt-nl "if (ecl_unlikely(narg!=" nreq ")) FEwrong_num_arguments_anonym();") (when varargs (when requireds (wt-nl "if (ecl_unlikely(narg<" nreq ")) FEwrong_num_arguments_anonym();")) (unless (or rest keywords allow-other-keys) (wt-nl "if (ecl_unlikely(narg>" (+ nreq nopt) ")) FEwrong_num_arguments_anonym();")))) (open-inline-block)) ;; If the number of required arguments exceeds the number of variables we ;; want to pass on the C stack, we pass some of the arguments to the list ;; of optionals, which will eventually get passed in the lisp stack. (when (> nreq si::c-arguments-limit) (setf nopt (+ nopt (- nreq si::c-arguments-limit)) nreq si::c-arguments-limit) (setf optionals (nconc (loop for var in (subseq requireds si::c-arguments-limit) nconc (list var *c1nil* NIL)) optionals) requireds (subseq requireds 0 si::c-arguments-limit) varargs t)) ;; For each variable, set its var-loc. ;; For optional and keyword parameters, and lexical variables which ;; can be unboxed, this will be a new LCL. ;; The bind step later will assign to such variable. (labels ((wt-decl (var) (let ((lcl (next-lcl (var-name var)))) (wt-nl) (wt (rep-type->c-name (var-rep-type var)) " " *volatile* lcl ";") lcl)) (do-decl (var) (when (local var) ; no LCL needed for SPECIAL or LEX (setf (var-loc var) (wt-decl var))))) ;; Declare unboxed required arguments (loop for var in requireds when (unboxed var) do (setf (var-loc var) (wt-decl var))) ;; dont create rest or varargs if not used (when (and rest (< (var-ref rest) 1)) (setq rest nil varargs (or optionals keywords allow-other-keys))) ;; Declare &optional variables (do ((opt optionals (cdddr opt))) ((endp opt)) (do-decl (first opt)) (when (third opt) (do-decl (third opt)))) ;; Declare &rest variables (when rest (setq rest-loc (wt-decl rest))) ;; Declare &key variables (do ((key keywords (cddddr key))) ((endp key)) (do-decl (second key)) (when (fourth key) (do-decl (fourth key))))) ;; Declare and assign the variable arguments pointer (when varargs (flet ((last-variable () (cond (required-lcls (first (last required-lcls))) ((eq closure-type 'LEXICAL) (format nil "lex~D" (1- *level*))) (t "narg")))) (if (setq simple-varargs (and (not (or rest keywords allow-other-keys)) (< (+ nreq nopt) 30))) (wt-nl "va_list args; va_start(args," (last-variable) ");") (wt-nl "ecl_va_list args; ecl_va_start(args," (last-variable) ",narg," nreq ");")))) ;; Bind required argumens. Produces C statements for unboxed variables, ;; which is why it is done after all declarations. (mapc #'bind required-lcls requireds) (when fname-in-ihs-p (open-inline-block) (setf *ihs-used-p* t) (push 'IHS *unwind-exit*) (when (policy-debug-variable-bindings) (build-debug-lexical-env (reverse requireds) t)) (wt-nl "ecl_ihs_push(cl_env_copy,&ihs," (add-symbol fname) ",_ecl_debug_env);")) ;; Bind optional parameters as long as there remain arguments. (when optionals ;; When binding optional values, we use two calls to BIND. This means ;; 'BDS-BIND is pushed twice on *unwind-exit*, which results in two calls ;; to bds_unwind1(), which is wrong. A simple fix is to save *unwind-exit* ;; which is what we do here. (let ((va-arg-loc (if simple-varargs 'VA-ARG 'CL-VA-ARG))) ;; counter for optionals (wt-nl-open-brace) (wt-nl "int i = " nreq ";") (do ((opt optionals (cdddr opt))) ((endp opt)) (wt-nl "if (i >= narg) {") (let ((*opened-c-braces* (1+ *opened-c-braces*))) (bind-init (second opt) (first opt)) (when (third opt) (bind nil (third opt)))) (wt-nl "} else {") (let ((*opened-c-braces* (1+ *opened-c-braces*)) (*unwind-exit* *unwind-exit*)) (wt-nl "i++;") (bind va-arg-loc (first opt)) (when (third opt) (bind t (third opt)))) (wt-nl "}")) (wt-nl-close-brace))) (when (or rest keywords allow-other-keys) (cond ((not (or keywords allow-other-keys)) (wt-nl rest-loc " = cl_grab_rest_args(args);")) (t (cond (keywords (wt-nl-open-brace) ;; Brace [1] (wt-nl "cl_object keyvars[" (* 2 nkey) "];") (wt-nl "cl_parse_key(args," nkey "," cfun "keys,keyvars")) (t (wt-nl "cl_parse_key(args,0,NULL,NULL"))) ;; This explicit coercion is required to remove the "volatile" ;; declaration on some variables. (if rest (wt ",(cl_object*)&" rest-loc) (wt ",NULL")) (wt (if allow-other-keys ",TRUE);" ",FALSE);")))) (when rest (bind rest-loc rest))) (when varargs (wt-nl (if simple-varargs "va_end(args);" "ecl_va_end(args);"))) ;;; Bind keywords. (do ((kwd keywords (cddddr kwd)) (all-kwd nil) (KEYVARS[i] `(KEYVARS 0)) (i 0 (1+ i))) ((endp kwd) (when all-kwd (wt-nl-h "#define " cfun "keys (&" (add-keywords (nreverse all-kwd)) ")") (wt-nl-close-brace))) ;; Matches [1] (declare (fixnum i)) (push (first kwd) all-kwd) (let ((key (first kwd)) (var (second kwd)) (init (third kwd)) (flag (fourth kwd))) (cond ((and (eq (c1form-name init) 'LOCATION) (null (c1form-arg 0 init))) ;; no initform ;; ECL_NIL has been set in keyvars if keyword parameter is not supplied. (setf (second KEYVARS[i]) i) (bind KEYVARS[i] var)) (t ;; with initform (setf (second KEYVARS[i]) (+ nkey i)) (wt-nl "if (Null(") (wt-loc KEYVARS[i]) (wt ")) {") (let ((*unwind-exit* *unwind-exit*) (*opened-c-braces* (1+ *opened-c-braces*))) (bind-init init var)) (wt-nl "} else {") (let ((*opened-c-braces* (1+ *opened-c-braces*))) (setf (second KEYVARS[i]) i) (bind KEYVARS[i] var)) (wt-nl "}"))) (when flag (setf (second KEYVARS[i]) (+ nkey i)) (bind KEYVARS[i] flag)))) (when *tail-recursion-info* (push 'TAIL-RECURSION-MARK *unwind-exit*) (wt-nl1 "TTL:")) ;;; Now the parameters are ready, after all! (c2expr body) (close-inline-blocks)) (defun optimize-funcall/apply-lambda (lambda-form arguments apply-p &aux body apply-list apply-var let-vars extra-stmts all-keys) (multiple-value-bind (requireds optionals rest key-flag keywords allow-other-keys aux-vars) (cmp-process-lambda-list (car lambda-form)) (when apply-p (setf apply-list (first (last arguments)) apply-var (gensym) arguments (butlast arguments))) (setf arguments (copy-list arguments)) (do ((scan arguments (cdr scan))) ((endp scan)) (let ((form (first scan))) (unless (constantp form) (let ((aux-var (gensym))) (push `(,aux-var ,form) let-vars) (setf (car scan) aux-var))))) (when apply-var (push `(,apply-var ,apply-list) let-vars)) (dolist (i (cdr requireds)) (push (list i (cond (arguments (pop arguments)) (apply-p `(if ,apply-var (pop ,apply-var) (si::dm-too-few-arguments nil))) (t (cmperr "Too few arguments for lambda form ~S" (cons 'LAMBDA lambda-form))))) let-vars)) (do ((scan (cdr optionals) (cdddr scan))) ((endp scan)) (let ((opt-var (first scan)) (opt-flag (third scan)) (opt-value (second scan))) (cond (arguments (setf let-vars (list* `(,opt-var ,(pop arguments)) `(,opt-flag t) let-vars))) (apply-p (setf let-vars (list* `(,opt-var (if ,apply-var (pop ,apply-var) ,opt-value)) `(,opt-flag ,apply-var) let-vars))) (t (setf let-vars (list* `(,opt-var ,opt-value) `(,opt-flag nil) let-vars)))))) (when (or key-flag allow-other-keys) (unless rest (setf rest (gensym)))) (when rest (push `(,rest ,(if arguments (if apply-p `(list* ,@arguments ,apply-var) `(list ,@arguments)) (if apply-p apply-var nil))) let-vars)) (loop while aux-vars do (push (list (pop aux-vars) (pop aux-vars)) let-vars)) (do ((scan (cdr keywords) (cddddr scan))) ((endp scan)) (let ((keyword (first scan)) (key-var (second scan)) (key-value (third scan)) (key-flag (or (fourth scan) (gensym)))) (push keyword all-keys) (setf let-vars (list* `(,key-var (if (eq ,key-flag 'si::missing-keyword) ,key-value ,key-flag)) `(,key-flag (si::search-keyword ,rest ,keyword)) let-vars)) (when (fourth scan) (push `(setf ,key-flag (not (eq ,key-flag 'si::missing-keyword))) extra-stmts)))) (when (and key-flag (not allow-other-keys)) (push `(si::check-keyword ,rest ',all-keys) extra-stmts)) `(let* ,(nreverse (delete-if-not #'first let-vars)) ,@(and apply-var `((declare (ignorable ,apply-var)))) ,@(multiple-value-bind (decl body) (si::find-declarations (rest lambda-form)) (append decl extra-stmts body))))) ecl-16.1.2/src/cmp/cmplet.lsp000066400000000000000000000333441266352375300157410ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: C -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; CMPLET Let and Let*. ;;;; ;;;; Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. ;;;; Copyright (c) 1990, Giuseppe Attardi. ;;;; ;;;; ECL is free software; you can redistribute it and/or modify it ;;;; under the terms of the GNU Library General Public License as ;;;; published by the Free Software Foundation; either version 2 of ;;;; the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. (in-package "COMPILER") (defun c1let (args) (check-args-number 'LET args 1) (let ((bindings (pop args))) (cond ((null bindings) (c1locally args)) ((atom bindings) (invalid-let-bindings 'LET bindings)) ((null (rest bindings)) (c1let/let* 'let* bindings args)) (t (loop :with temp :for b :in bindings :if (atom b) :collect b :into real-bindings :and :collect b :into names :else :collect (setf temp (gensym "LET")) :into temp-names :and :collect (cons temp (cdr b)) :into temp-bindings :and :collect (list (car b) temp) :into real-bindings :and :collect (car b) :into names :do (cmpck (member (car names) (cdr names) :test #'eq) "LET: The variable ~s occurs more than once in the LET." (car names)) :finally (return (c1let/let* 'let* (nconc temp-bindings real-bindings) `((declare (ignorable ,@temp-names) (:read-only ,@temp-names)) ,@args))))) (t (c1let/let* 'let bindings args))))) (defun c1let* (args) (check-args-number 'LET* args 1) (let ((bindings (pop args))) (cond ((null bindings) (c1locally args)) ((atom bindings) (invalid-let-bindings 'LET* bindings)) (t (c1let/let* 'let* bindings args))))) (defun c1let/let* (let/let* bindings body) (let* ((setjmps *setjmps*) (*cmp-env* (cmp-env-copy))) (multiple-value-bind (vars forms body) (process-let-bindings let/let* bindings body) ;; Try eliminating unused variables, replace constant ones, etc. (multiple-value-setq (vars forms) (c1let-optimize-read-only-vars vars forms body)) ;; Verify that variables are referenced and assign final boxed / unboxed type (mapc #'check-vref vars) (let ((sp-change (some #'global-var-p vars))) (make-c1form* let/let* :type (c1form-type body) :volatile (not (eql setjmps *setjmps*)) :local-vars vars :args vars forms body))))) (defun invalid-let-bindings (let/let* bindings) (cmperr "Syntax error in ~A bindings:~%~4I~A" let/let* bindings)) (defun process-let-bindings (let/let* bindings body) (multiple-value-bind (body specials types ignoreds other-decls) (c1body body nil) (let ((vars '()) (forms '())) (do ((b bindings) name form) ((atom b) (unless (null b) (invalid-let-bindings let/let* bindings))) (if (symbolp (setf form (pop b))) (setf name form form nil) (progn (check-args-number "LET/LET* binding" form 1 2) (setf name (first form) form (rest form)))) (let* ((var (c1make-var name specials ignoreds types)) (type (var-type var)) (init (cond ((null form) (default-init var)) ((trivial-type-p type) (c1expr (first form))) (t (c1expr `(checked-value ,type ,(first form))))))) ;; :read-only variable handling. Beppe (when (read-only-variable-p name other-decls) (if (global-var-p var) (cmpwarn "Found :READ-ONLY declaration for global var ~A" name) (setf (var-type var) (c1form-primary-type init))) (multiple-value-bind (constantp value) (c1form-constant-p init) (when constantp (cmp-env-register-symbol-macro name (si::maybe-quote value)) (setf var nil)))) (when var (push var vars) (push init forms) (when (eq let/let* 'LET*) (push-vars var))))) (setf vars (nreverse vars) forms (nreverse forms)) (when (eq let/let* 'LET) (mapc #'push-vars vars)) (check-vdecl (mapcar #'var-name vars) types ignoreds) (c1declare-specials specials) (values vars forms (c1decl-body other-decls body))))) (defun c1let-optimize-read-only-vars (all-vars all-forms body) (loop with base = (list body) for vars on all-vars for forms on (nconc all-forms (list body)) for var = (first vars) for form = (first forms) for rest-vars = (cdr vars) for rest-forms = (cdr forms) for read-only-p = (and (null (var-set-nodes var)) (null (var-functions-reading var)) (null (var-functions-setting var)) (not (global-var-p var))) when read-only-p do (fix-read-only-variable-type var form rest-forms) unless (and read-only-p (or (c1let-unused-variable-p var form) (c1let-constant-value-p var form rest-vars rest-forms) (c1let-constant-variable-p var form rest-vars rest-forms) #+(or) (c1let-can-move-variable-value-p var form rest-vars rest-forms))) collect var into used-vars and collect form into used-forms finally (return (values used-vars used-forms)))) (defun fix-read-only-variable-type (var form rest-forms) (and-form-type (var-type var) form (var-name var) :unsafe "In LET body") (let ((form-type (c1form-primary-type form))) (setf (var-type var) form-type) (update-variable-type var form-type))) (defun c1let-unused-variable-p (var form) ;; * (let ((v2 e2)) e3 e4) => (let () e3 e4) ;; provided ;; - v2 does not appear in body ;; - e2 produces no side effects (when (and (= 0 (var-ref var)) (not (member (var-kind var) '(special global))) (not (form-causes-side-effect form))) (unless (var-ignorable var) (cmpdebug "Removing unused variable ~A" (var-name var))) (delete-c1forms form) t)) (defun c1let-constant-value-p (var form rest-vars rest-forms) ;; (let ((v1 e1) (v2 e2) (v3 e3)) (expr e4 v2 e5)) ;; - v2 is a read only variable ;; - the value of e2 is not modified in e3 nor in following expressions (when (and (eq (c1form-name form) 'LOCATION) (loc-in-c1form-movable-p (c1form-arg 0 form))) (cmpdebug "Replacing variable ~A by its value ~A" (var-name var) form) (nsubst-var var form) t)) (defun c1let-constant-variable-p (var form rest-vars rest-forms) ;; (let ((v1 e1) (v2 e2) (v3 e3)) (expr e4 v2 e5)) ;; - v2 is a read only variable ;; - the value of e2 is not modified in e3 nor in following expressions (when (eq (c1form-name form) 'VAR) (let ((other-var (c1form-arg 0 form))) (unless (or (global-var-p other-var) (member other-var rest-vars) (var-changed-in-form-list other-var rest-forms)) (cmpdebug "Replacing variable ~A by its value ~A" (var-name var) form) (nsubst-var var form) t)))) (defun c2let-replaceable-var-ref-p (var form rest-forms) (when (and (eq (c1form-name form) 'VAR) (null (var-set-nodes var)) (local var)) (let ((var1 (c1form-arg 0 form))) (declare (type var var1)) (when (and ;; Fixme! We should be able to replace variable ;; even if they are referenced across functions. ;; We just need to keep track of their uses. (local var1) (eq (unboxed var) (unboxed var1)) (not (var-changed-in-form-list var1 rest-forms))) (cmpdebug "Replacing variable ~a by its value" (var-name var)) (nsubst-var var form) t)))) (defun c1let-can-move-variable-value-p (var form rest-vars rest-forms) ;; (let ((v1 e1) (v2 e2) (v3 e3)) (expr e4 v2 e5)) ;; can become ;; (let ((v1 e1) (v3 e3)) (expr e4 e2 e5)) ;; provided ;; - v2 appears only once ;; - v2 appears only in body ;; - e2 does not affect v1 nor e3, e3 does not affect e2 ;; - e4 does not affect e2 (when (and (= 1 (var-ref var)) (not (form-causes-side-effect form)) ;; it does not refer to special variables which ;; are changed in the LET form (notany #'(lambda (v) (var-referenced-in-form v form)) rest-vars) (replaceable var rest-forms)) (cmpdebug "Replacing variable ~A by its value ~A" (var-name var) form) (nsubst-var var form) t)) (defun read-only-variable-p (v other-decls) (dolist (i other-decls nil) (when (and (eq (car i) :READ-ONLY) (member v (rest i))) (return t)))) (defun env-grows (possibily) ;; if additional closure variables are introduced and this is not ;; last form, we must use a new env. (and possibily (plusp *env*) (dolist (exit *unwind-exit*) (case exit (RETURN (return NIL)) (BDS-BIND) (t (return T)))))) ;; should check whether a form before var causes a side-effect ;; exactly one occurrence of var is present in forms (defun replaceable (var form) (labels ((abort-on-side-effects (form) (if (eq (c1form-name form) 'VAR) (when (eq var (first (c1form-args form))) (return-from replaceable t)) (when (c1form-side-effects form) (return-from replaceable nil))))) (traverse-c1form-tree form #'abort-on-side-effects) (baboon :format-control "In REPLACEABLE, variable ~A not found. Form:~%~A" :format-arguments (list (var-name var) *current-form*)))) (defun c2let* (c1form vars forms body &aux (*volatile* (c1form-volatile* c1form)) (*unwind-exit* *unwind-exit*) (*env* *env*) (*env-lvl* *env-lvl*) (*inline-blocks* 0)) ;; Replace read-only variables when it is worth doing it. (loop for var in vars for rest-forms on (append forms (list body)) for form = (first rest-forms) unless (c2let-replaceable-var-ref-p var form rest-forms) collect var into used-vars and collect form into used-forms finally (setf vars used-vars forms used-forms)) ;; Emit C definitions of local variables (loop for var in vars for kind = (local var) do (when kind (maybe-open-inline-block) (bind (next-lcl (var-name var)) var) (wt-nl *volatile* (rep-type->c-name kind) " " var ";"))) ;; Create closure bindings for closed-over variables (when (some #'var-ref-ccb vars) (maybe-open-inline-block) (let ((env-lvl *env-lvl*)) (wt-nl *volatile* "cl_object env" (incf *env-lvl*) " = env" env-lvl ";"))) ;; Assign values (loop for form in forms for var in vars do (case (var-kind var) ((LEXICAL CLOSURE SPECIAL GLOBAL) (case (c1form-name form) (LOCATION (bind (c1form-arg 0 form) var)) (VAR (bind (c1form-arg 0 form) var)) (t (bind-init form var)))) (t ; local var (let ((*destination* var)) ; nil (ccb) (c2expr* form))))) ;; Optionally register the variables with the IHS frame for debugging (if (policy-debug-variable-bindings) (let ((*unwind-exit* *unwind-exit*)) (wt-nl-open-brace) (let* ((env (build-debug-lexical-env vars))) (when env (push 'IHS-ENV *unwind-exit*)) (c2expr body) (wt-nl-close-brace) (when env (pop-debug-lexical-env)))) (c2expr body)) (close-inline-blocks :line)) (defun discarded (var form body &aux last) (labels ((last-form (x &aux (args (c1form-args x))) (case (c1form-name x) (PROGN (last-form (car (last (first args))))) ((LET LET* FLET LABELS BLOCK CATCH) (last-form (car (last args)))) (VAR (c1form-arg 0 x)) (t x)))) (and (not (form-causes-side-effect form)) (or (< (var-ref var) 1) (and (= (var-ref var) 1) (eq var (last-form body)) (eq 'TRASH *destination*)))))) (defun nsubst-var (var form) (when (var-set-nodes var) (baboon :format-control "Cannot replace a variable that is to be changed")) (when (var-functions-reading var) (baboon :format-control "Cannot replace a variable that forms part of a closure")) (dolist (where (var-read-forms var)) (unless (and (eql (c1form-name where) 'VAR) (eql (c1form-arg 0 where) var)) (baboon :format-control "VAR-READ-NODES are only C1FORMS of type VAR")) (delete-from-read-nodes var where) (c1form-replace-with where form)) (setf (var-ignorable var) 0)) (defun member-var (var list) (let ((kind (var-kind var))) (if (member kind '(SPECIAL GLOBAL)) (member var list :test #'(lambda (v1 v2) (and (member (var-kind v2) '(SPECIAL GLOBAL)) (eql (var-name v1) (var-name v2))))) (member var list)))) ecl-16.1.2/src/cmp/cmploc.lsp000066400000000000000000000214421266352375300157260ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: C -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. ;;;; Copyright (c) 1990, Giuseppe Attardi. ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. ;;;; CMPLOC Set-loc and Wt-loc. (in-package "COMPILER") ;;; Valid locations are: ;;; NIL ;;; T ;;; fixnum ;;; VALUE0 ;;; VALUES ;;; var-object ;;; a string designating a C expression ;;; ( VALUE i ) VALUES(i) ;;; ( VV vv-index ) ;;; ( VV-temp vv-index ) ;;; ( LCL lcl [representation-type]) local variable, type unboxed ;;; ( TEMP temp ) local variable, type object ;;; ( FRAME ndx ) variable in local frame stack ;;; ( CALL-NORMAL fun locs 1st-type ) similar as CALL, but number of arguments is fixed ;;; ( CALL-INDIRECT fun narg args) similar as CALL, but unknown function ;;; ( C-INLINE output-type fun/string locs side-effects output-var ) ;;; ( COERCE-LOC representation-type location) ;;; ( FDEFINITION vv-index ) ;;; ( MAKE-CCLOSURE cfun ) ;;; ( FIXNUM-VALUE fixnum-value ) ;;; ( CHARACTER-VALUE character-code ) ;;; ( LONG-FLOAT-VALUE long-float-value vv ) ;;; ( DOUBLE-FLOAT-VALUE double-float-value vv ) ;;; ( SINGLE-FLOAT-VALUE single-float-value vv ) ;;; ( STACK-POINTER index ) retrieve a value from the stack ;;; ( SYS:STRUCTURE-REF loc slot-name-vv slot-index ) ;;; ( THE type location ) ;;; ( KEYVARS n ) ;;; VA-ARG ;;; CL-VA-ARG ;;; Valid *DESTINATION* locations are: ;;; ;;; VALUE0 ;;; RETURN Object returned from current function. ;;; TRASH Value may be thrown away. ;;; VALUES Values vector. ;;; var-object ;;; ( LCL lcl ) ;;; ( LEX lex-address ) ;;; ( BIND var alternative ) Alternative is optional ;;; ( JUMP-TRUE label ) ;;; ( JUMP-FALSE label ) (defun tmp-destination (loc) (case loc (VALUES 'VALUES) (TRASH 'TRASH) (T 'RETURN))) (defun precise-loc-type (loc new-type) (if (subtypep (loc-type loc) new-type) loc `(the ,new-type ,loc))) (defun loc-in-c1form-movable-p (loc) "A location that is in a C1FORM and can be moved" (cond ((member loc '(t nil)) t) ((numberp loc) t) ((stringp loc) t) ((vv-p loc) t) ((member loc '(value0 values va-arg cl-va-arg)) nil) ((atom loc) (baboon :format-control "Unknown location ~A found in C1FORM" :format-arguments (list loc))) ((eq (first loc) 'THE) (loc-in-c1form-movable-p (third loc))) ((member (setf loc (car loc)) '(VV VV-TEMP FIXNUM-VALUE CHARACTER-VALUE DOUBLE-FLOAT-VALUE SINGLE-FLOAT-VALUE #+long-float LONG-FLOAT-VALUE KEYVARS)) t) (t (baboon :format-control "Unknown location ~A found in C1FORM" :format-arguments (list loc))))) (defun uses-values (loc) (and (consp loc) (or (member (car loc) '(CALL CALL-NORMAL CALL-INDIRECT) :test #'eq) (and (eq (car loc) 'C-INLINE) (eq (sixth loc) 'VALUES))))) (defun loc-immediate-value-p (loc) (cond ((eq loc t) (values t t)) ((eq loc nil) (values t nil)) ((numberp loc) (values t loc)) ((vv-p loc) (let ((value (vv-value loc))) (if (or (null value) (ext:fixnump value)) (values nil nil) (values t value)))) ((atom loc) (values nil nil)) ((eq (first loc) 'THE) (loc-immediate-value-p (third loc))) ((member (first loc) '(fixnum-value long-float-value double-float-value single-float-value)) (values t (second loc))) ((eq (first loc) 'character-value) (values t (code-char (second loc)))) (t (values nil nil)))) (defun loc-immediate-value (loc) (nth-value 1 (loc-immediate-value-p loc))) (defun unknown-location (where loc) (baboon :format-control "Unknown location found in ~A~%~S" :format-arguments (list where loc))) (defun wt-loc (loc) (cond ((consp loc) (let ((fd (gethash (car loc) *wt-loc-dispatch-table*))) (if fd (apply fd (cdr loc)) (unknown-location 'wt-loc loc)))) ((symbolp loc) (let ((txt (gethash loc *wt-loc-dispatch-table* :not-found))) (when (eq txt :not-found) (unknown-location 'wt-loc loc)) (wt txt))) ((stringp loc) (wt loc)) ((var-p loc) (wt-var loc)) ((vv-p loc) (wt-vv loc)) (t (unknown-location 'wt-loc loc)))) (defun last-call-p () (member *exit* '(RETURN RETURN-FIXNUM RETURN-CHARACTER RETURN-SINGLE-FLOAT RETURN-DOUBLE-FLOAT RETURN-LONG-FLOAT RETURN-OBJECT))) (defun wt-lcl (lcl) (unless (numberp lcl) (baboon)) (wt "v" lcl)) (defun wt-lcl-loc (lcl &optional type name) (unless (numberp lcl) (baboon)) (wt "v" lcl name)) (defun wt-temp (temp) (wt "T" temp)) (defun wt-number (value &optional vv) (wt value)) (defun wt-character (value &optional vv) ;; We do not use the '...' format because this creates objects of type ;; 'char' which have sign problems (wt value)) (defun wt-value (i) (wt "cl_env_copy->values[" i "]")) (defun wt-keyvars (i) (wt "keyvars[" i "]")) (defun wt-the (type loc) (declare (ignore type)) (wt-loc loc)) (defun loc-refers-to-special (loc) (cond ((var-p loc) (member (var-kind loc) '(SPECIAL GLOBAL))) ((atom loc) nil) ((eq (first loc) 'THE) (loc-refers-to-special (third loc))) ((eq (setf loc (first loc)) 'BIND) t) ((eq loc 'C-INLINE) t) ; We do not know, so guess yes (t nil))) (defun values-loc (n) (list 'VALUE n)) ;;; ;;; SET-LOC ;;; (defun set-unknown-loc (loc) (unknown-location 'set-loc *destination*)) (defun set-loc (loc &aux fd) (let ((destination *destination*)) (cond ((eq destination loc)) ((symbolp destination) (funcall (gethash destination *set-loc-dispatch-table* 'set-unknown-loc) loc)) ((var-p destination) (set-var loc destination)) ((vv-p destination) (set-vv loc destination)) ((atom destination) (unknown-location 'set-loc destination)) (t (let ((fd (gethash (first destination) *set-loc-dispatch-table*))) (if fd (apply fd loc (rest destination)) (progn (wt-nl) (wt-loc destination) (wt " = ") (wt-coerce-loc (loc-representation-type *destination*) loc) (wt ";")))))))) (defun set-the-loc (loc type orig-loc) (declare (ignore type)) (let ((*destination* orig-loc)) (set-loc loc))) (defun set-values-loc (loc) (cond ((eq loc 'VALUES)) ((uses-values loc) (wt-nl "cl_env_copy->values[0] = ") (wt-coerce-loc :object loc) (wt ";")) (t (wt-nl "cl_env_copy->values[0] = ") (wt-coerce-loc :object loc) (wt ";") (wt-nl "cl_env_copy->nvalues = 1;")))) (defun set-value0-loc (loc) (wt-nl "value0 = ") (wt-coerce-loc :object loc) (wt ";")) (defun set-return-loc (loc) (cond ((or (eq loc 'VALUES) (uses-values loc)) (wt-nl "value0 = ") (wt-coerce-loc :object loc) (wt ";")) ((eq loc 'VALUE0) (wt-nl "cl_env_copy->nvalues = 1;")) ((eq loc 'RETURN)) (t (wt-nl "value0 = ") (wt-coerce-loc :object loc) (wt ";") (wt-nl "cl_env_copy->nvalues = 1;")))) (defun loc-with-side-effects-p (loc &aux name) (cond ((var-p loc) (and (global-var-p loc) (policy-global-var-checking))) ((atom loc) nil) ((member (setf name (first loc)) '(CALL CALL-NORMAL CALL-INDIRECT) :test #'eq) t) ((eq name 'THE) (loc-with-side-effects-p (third loc))) ((eq name 'FDEFINITION) (policy-global-function-checking)) ((eq name 'C-INLINE) (or (eq (sixth loc) 'VALUES) ;; Uses VALUES (fifth loc))))) ;; or side effects (defun set-trash-loc (loc) (when (loc-with-side-effects-p loc) (wt-nl loc ";") t)) ecl-16.1.2/src/cmp/cmpmac.lsp000066400000000000000000000076251266352375300157200ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: C -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;; ---------------------------------------------------------------------- ;;; Macros only used in the code of the compiler itself: #-new-cmp (in-package "COMPILER") #-new-cmp (import 'sys::arglist "COMPILER") (import 'sys::with-clean-symbols "COMPILER") #+new-cmp (in-package "C-DATA") ;; ---------------------------------------------------------------------- ;; CACHED FUNCTIONS ;; (defmacro defun-cached (name lambda-list test &body body) (let* ((cache-name (intern (concatenate 'string "*" (string name) "-CACHE*") (symbol-package name))) (reset-name (intern (concatenate 'string (string name) "-EMPTY-CACHE") (symbol-package name))) (hash-function (case test (EQ 'SI::HASH-EQ) (EQL 'SI::HASH-EQL) (EQUAL 'SI::HASH-EQUAL) (t (setf test 'EQUALP) 'SI::HASH-EQUALP)))) `(progn (eval-when (:compile-toplevel :load-toplevel :execute) (defparameter ,cache-name (make-array 1024 :element-type t :adjustable nil))) (defun ,reset-name () (make-array 1024 :element-type t :adjustable nil)) (defun ,name ,lambda-list (flet ((,name ,lambda-list ,@body)) (let* ((hash (logand (,hash-function ,@lambda-list) 1023)) (elt (aref ,cache-name hash))) (declare (type (integer 0 1023) hash) (type (array t (*)) ,cache-name)) (if (and elt ,@(loop for arg in lambda-list collect `(,test (pop (truly-the cons elt)) ,arg))) (first (truly-the cons elt)) (let ((output (,name ,@lambda-list))) (setf (aref ,cache-name hash) (list ,@lambda-list output)) output)))))))) (defmacro defun-equal-cached (name lambda-list &body body) `(defun-cached ,name ,lambda-list equal ,@body)) ;;; ---------------------------------------------------------------------- ;;; CONVENIENCE FUNCTIONS / MACROS ;;; (defun-cached env-var-name (n) eql (format nil "env~D" n)) (defun-cached lex-env-var-name (n) eql (format nil "lex~D" n)) (defun same-fname-p (name1 name2) (equal name1 name2)) ;;; from cmpenv.lsp (defmacro next-cmacro () '(incf *next-cmacro*)) ;;; from cmplabel.lsp (defun next-label () (cons (incf *last-label*) nil)) (defun next-label* () (cons (incf *last-label*) t)) (defun labelp (x) (and (consp x) (integerp (si::cons-car x)))) (defun maybe-next-label () (if (labelp *exit*) *exit* (next-label))) (defun maybe-wt-label (label) (unless (eq label *exit*) (wt-label label))) (defmacro with-exit-label ((label) &body body) `(let* ((,label (next-label)) (*unwind-exit* (cons ,label *unwind-exit*))) ,@body (wt-label ,label))) (defmacro with-optional-exit-label ((label) &body body) `(let* ((,label (maybe-next-label)) (*unwind-exit* (adjoin ,label *unwind-exit*))) ,@body (maybe-wt-label ,label))) (defun next-lcl (&optional name) (list 'LCL (incf *lcl*) T (if (and name (symbol-package name)) (lisp-to-c-name name) ""))) (defun next-cfun (&optional (prefix "L~D~A") (lisp-name nil)) (let ((code (incf *next-cfun*))) (format nil prefix code (lisp-to-c-name lisp-name)))) (defun next-temp () (prog1 *temp* (incf *temp*) (setq *max-temp* (max *temp* *max-temp*)))) (defun next-lex () (prog1 (cons *level* *lex*) (incf *lex*) (setq *max-lex* (max *lex* *max-lex*)))) (defun next-env () (prog1 *env* (incf *env*) (setq *max-env* (max *env* *max-env*)))) (defmacro reckless (&rest body) `(locally (declare (optimize (safety 0))) ,@body)) ecl-16.1.2/src/cmp/cmpmain.lsp000077500000000000000000001141521266352375300161010ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: C -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. ;;;; Copyright (c) 1990, Giuseppe Attardi. ;;;; Copyright (c) 2001, Juan Jose Garcia Ripoll ;;;; Copyright (c) 2015, Daniel KochmaХ„ski ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. ;;;; CMPMAIN Compiler main program. (ext:package-lock "CL" nil) (in-package "COMPILER") (defun safe-mkstemp (template) ;; We do several things here. One is to check for success in MKSTEMP, ;; the other one is to ensure that the output of this function _always_ ;; carries a file type -- this solves a problem with filesystems where ;; mkstemp may introduce one or more dots in the name causing several ;; functions below to ignore parts of the name. Note that this forces ;; us to have two files per temp: one with and one without extension. (let* ((base (si::mkstemp template))) (when base (let ((output (make-pathname :name (concatenate 'string (pathname-name base) (or (pathname-type base) "")) :type "tmp" :defaults base))) (if (and (not (probe-file output)) (si:copy-file base output)) (setf base (list (truename output) (truename base))) (progn (delete-file base) (setf base nil))))) (unless base (error "Unable to create temporay file~%~ ~AXXXXXX Make sure you have enough free space in disk, check permissions or set~%~ the environment variable TMPDIR to a different value." template)) base)) (defun compile-file-pathname (name &key (output-file T) (type nil type-supplied-p) verbose print c-file h-file data-file system-p load external-format source-truename source-offset) (let* ((format '()) (extension '())) (unless type-supplied-p (setf type (if system-p :object :fasl))) (case type ((:shared-library :dll) (setf format +shared-library-format+)) ((:static-library :library :lib) (setf format +static-library-format+)) (:data (setf extension "data")) (:sdata (setf extension "sdat")) (:c (setf extension (if (not *cc-is-cxx*) "c" "cxx"))) (:h (setf extension "eclh")) (:object (setf extension +object-file-extension+)) (:program (setf format +executable-file-format+)) #+msvc (:import-library (setf extension "implib")) ((:fasl :fas) (setf extension "fas"))) (cond ((not (member output-file '(T NIL))) output-file) (format (merge-pathnames (format nil format (pathname-name name)) name)) (t (make-pathname :type extension :defaults name))))) #+msvc (defun delete-msvc-generated-files (output-pathname) (loop for i in '("implib" "exp" "ilk" "pdb") for full = (make-pathname :type i :defaults output-pathname) for truename = (probe-file full) when truename do (cmp-delete-file truename))) #+msvc (defun embed-manifest-file (o-file &optional (type :dll)) (let* ((real-file (probe-file o-file))) (when real-file (let* ((manifest-namestring (concatenate 'string (namestring o-file) ".manifest")) (resource-code (ecase type ((:dll :shared-library :fasl :fas) 2) ((:program) 1))) (resource-option (format nil "-outputresource:~A;~D" (namestring real-file) resource-code)) (manifest (probe-file manifest-namestring))) (when manifest (safe-run-program "mt" (list "-nologo" "-manifest" manifest-namestring resource-option)) (delete-file manifest)))))) (defun cmp-delete-file (file) (cond ((null *delete-files*)) ((ext:getenv "ECL_PRESERVE_FILES")) ((null (probe-file file))) (*debug-compiler* (cmpprogress "~%Postponing deletion of ~A" file) (push file *files-to-be-deleted*)) (t (delete-file file)))) (push #'(lambda () (mapc #'delete-file *files-to-be-deleted*)) si::*exit-hooks*) #-mingw32 (defmacro fix-for-mingw (directory-namestring) directory-namestring) #+mingw32 (defun fix-for-mingw (directory-namestring) (let ((x (string-right-trim '(#\\ #\/) directory-namestring))) (if (zerop (length x)) "/" x))) #+msvc (defun linker-cc (o-pathname object-files &key (type :program) (ld-flags (split-program-options *ld-flags*))) (safe-run-program *ld* `(,(concatenate 'string "-Fe" (brief-namestring o-pathname)) ,@object-files ,@(split-program-options *ld-rpath*) ,@(split-program-options *user-ld-flags*) ,@ld-flags)) (embed-manifest-file o-pathname type) (delete-msvc-generated-files o-pathname)) #-msvc (defun linker-cc (o-pathname object-files &key (type :program) (ld-flags (split-program-options *ld-flags*))) (safe-run-program *ld* `("-o" ,(brief-namestring o-pathname) ,(concatenate 'string "-L" (fix-for-mingw (ecl-library-directory))) ,@object-files ,@(and *ld-rpath* (list *ld-rpath*)) ,@(split-program-options *user-ld-flags*) ,@ld-flags))) (defun linker-ar (output-name o-name ld-flags) #-msvc (static-lib-ar (namestring output-name) (list* (brief-namestring o-name) ld-flags)) #+msvc (unwind-protect (progn (with-open-file (f "static_lib.tmp" :direction :output :if-does-not-exist :create :if-exists :supersede) (format f "/DEBUGTYPE:CV /OUT:~A ~A ~{~&\"~A\"~}" output-name o-name ld-flags)) (safe-run-program "link" '("-lib" "@static_lib.tmp"))) (when (probe-file "static_lib.tmp") (cmp-delete-file "static_lib.tmp")))) (defun static-lib-ar (lib object-files) (let ((lib (brief-namestring lib))) (when (probe-file lib) (delete-file lib)) (safe-run-program *ar* (list* "cr" lib (mapcar #'brief-namestring object-files))) (safe-run-program *ranlib* (list lib)))) #+dlopen (defun shared-cc (o-pathname object-files) (let ((ld-flags (split-program-options *ld-shared-flags*))) #+msvc (setf ld-flags (let ((implib (si::coerce-to-filename (compile-file-pathname o-pathname :type :lib)))) ;; MSVC linker options are added at the end, after the ;; /link flag, because they are not processed by the ;; compiler, but by the linker (append ld-flags (list (concatenate 'string "/LIBPATH:" (ecl-library-directory)) (concatenate 'string "/IMPLIB:" implib))))) #+mingw32 (setf ld-flags (list* "-shared" ld-flags)) (linker-cc o-pathname object-files :type :dll :ld-flags ld-flags))) #+dlopen (defun bundle-cc (o-pathname init-name object-files) (let ((ld-flags (split-program-options *ld-bundle-flags*))) #+msvc (setf ld-flags (let ((implib (si::coerce-to-filename (compile-file-pathname o-pathname :type :import-library)))) ;; MSVC linker options are added at the end, after the ;; /link flag, because they are not processed by the ;; compiler, but by the linker (append ld-flags (list ;; Not needed because we use ECL_DLLEXPORT ;; (concatenate 'string "/EXPORT:" init-name) (concatenate 'string "/LIBPATH:" (ecl-library-directory)) (concatenate 'string "/IMPLIB:" implib))))) #+mingw32 (setf ld-flags (list* "-shared" "-Wl,--export-all-symbols" ld-flags)) (linker-cc o-pathname object-files :type :fasl :ld-flags ld-flags))) (defconstant +lisp-program-header+ " #include #ifdef __cplusplus #define ECL_CPP_TAG \"C\" #else #define ECL_CPP_TAG #endif ~:{ extern ECL_CPP_TAG void ~A(cl_object);~%~} ") ;; ;; This format string contains the structure of the code that initializes ;; a program, a library, a module, etc. Basically, it processes a codeblock ;; just like in a normal compiled file, but then adds all the codeblocks of ;; its corresponding modules. ;; (defconstant +lisp-program-init+ " #ifdef __cplusplus extern \"C\" #endif void ~A(cl_object cblock) { /* * This function is first invoked with a pointer to a Cblock * structure, so that the function initializes it, and then * it is invoked with OBJNULL, to force initialization. */ static cl_object Cblock = OBJNULL; if (cblock != OBJNULL) { Cblock = cblock; #ifndef ECL_DYNAMIC_VV cblock->cblock.data = NULL; #endif cblock->cblock.data_size = 0; return; } Cblock->cblock.data_text = (const cl_object *)\"~A\"; ~A { /* * At this point Cblock contains the cblock of the parent. * Notice how the modules are linked to the parent forming a * circular chain. This disables the garbage collection of * the library until _ALL_ functions in all modules are unlinked. */ cl_object current, next = Cblock; ~:{ current = ecl_make_codeblock(); current->cblock.next = next; next = current; ecl_init_module(current, ~A); ~} Cblock->cblock.next = current; } ~A } ") (defconstant +lisp-init-wrapper+ " #ifdef __cplusplus extern \"C\" #endif ECL_DLLEXPORT void ~A(cl_object cblock) { /* This function is a wrapper over the randomized init function * name. */ ~A(cblock); } ") (defconstant +lisp-program-main+ " extern int main(int argc, char **argv) { cl_boot(argc, argv); ECL_CATCH_ALL_BEGIN(ecl_process_env()) { ~A ecl_init_module(OBJNULL, ~A); ~A } ECL_CATCH_ALL_END; si_exit(0); } ") (defconstant +lisp-library-main+ " extern int ~A(int argc, char **argv) { cl_boot(argc, argv); ECL_CATCH_ALL_BEGIN(ecl_process_env()) { ~A ecl_init_module(OBJNULL, ~A); ~A } ECL_CATCH_ALL_END; } ") #+:win32 (defconstant +lisp-program-winmain+ " #include int WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) { char **argv; int argc; ecl_get_commandline_args(&argc, &argv); cl_boot(argc, argv); ECL_CATCH_ALL_BEGIN(ecl_process_env()) { ~A ecl_init_module(OBJNULL, ~A); ~A } ECL_CATCH_ALL_END; si_exit(0); } ") (defun guess-kind (pathname) "Given a file name, guess whether it is an object file, a library, a program or a loadable module." (let ((record (assoc (pathname-type pathname) '((#.+object-file-extension+ :object) ("o" :object) ("obj" :object) ("c" :c) (#.+static-library-extension+ :static-library) ("lib" :static-library) ("a" :static-library) (#.+shared-library-extension+ :shared-library) ("dylib" :shared-library) ("dll" :shared-library) ("so" :shared-library) ("fas" :fasl)) :test #'string-equal))) (if record (second record) (progn (warn "File ~s is of no known file type. Assuming it is an object file." pathname) :object)))) (defun guess-ld-flags (pathname &key (kind (guess-kind pathname))) "Given a file name, return the compiler command line argument to link this file in." (case kind ((:object :c) (brief-namestring pathname)) ((:fasl :fas) nil) ((:static-library :lib :standalone-static-library :standalone-lib) (brief-namestring pathname)) ((:shared-library :dll :standalone-shared-library :standalone-dll) (brief-namestring pathname)) ((:program) nil) (otherwise (error "C::BUILDER cannot accept files of kind ~s" kind)))) (defun system-ld-flag (library) "Given a symbol, try to find a library that matches it, either by looking in the filesystem or in the database of ASDF modules." (let ((asdf #+asdf (find-package "ASDF")) system) (labels ((asdfsym (x) (find-symbol (string x) asdf)) (asdfcall (fun &rest rest) (apply (asdfsym fun) rest)) (system-output (system type) (let ((build (make-instance (asdfsym :build-op) :type type))) (first (asdfcall :output-files build system)))) (existing-system-output (system type) (let ((o (system-output system type))) (and o (setf o (probe-file o)) (namestring o)))) (find-archive (system) (or (existing-system-output system :library) (existing-system-output system :shared-library))) (fallback () (translate-logical-pathname (merge-pathnames "SYS:" (compile-file-pathname (string-downcase library) :type :library))))) (or #-ecl-min (and asdf (setf system (asdfcall :find-system library nil)) (find-archive system)) (fallback))))) (defun builder (target output-name &key lisp-files ld-flags (init-name nil) (main-name nil) (prologue-code "") (epilogue-code (when (eq target :program) '(SI::TOP-LEVEL T))) #+:win32 (system :console) &aux (*suppress-compiler-messages* (or *suppress-compiler-messages* (not *compile-verbose*))) (output-name (if (or (symbolp output-name) (stringp output-name)) (compile-file-pathname output-name :type target) output-name)) (init-name (or init-name (compute-init-name output-name :kind target))) (wrap-init-name (compute-init-name output-name :kind target :wrapper t)) (main-name (or main-name (compute-init-name output-name :kind target :prefix "main_")))) ;; ;; The epilogue-code can be either a string made of C code, or a ;; lisp form. In the latter case we add some additional C code to ;; clean up, and the lisp form is stored in a text representation, ;; to avoid using the compiler. ;; (cond ((null epilogue-code) (setf epilogue-code "")) ((stringp epilogue-code) ) (t (with-standard-io-syntax (setq epilogue-code (with-output-to-string (stream) (princ "{ const char *lisp_code = " stream) (wt-filtered-data (write-to-string epilogue-code) stream) (princ "; cl_object output; si_select_package(ecl_make_simple_base_string(\"CL-USER\", 7)); output = si_safe_eval(2, ecl_read_from_cstring(lisp_code), ECL_NIL); }" stream) ))))) (cond ((null prologue-code) (setf prologue-code "")) ((stringp prologue-code) ) (t (with-standard-io-syntax (setq prologue-code (with-output-to-string (stream) (princ "{ const char *lisp_code = " stream) (wt-filtered-data (write-to-string prologue-code) stream) (princ "; cl_object output; si_select_package(ecl_make_simple_base_string(\"CL-USER\", 7)); output = si_safe_eval(2, ecl_read_from_cstring(lisp_code), ECL_NIL); }" stream) ))))) ;; ;; When a module is built out of several object files, we have to ;; create an additional object file that initializes those ones. ;; This routine is responsible for creating this file. ;; ;; To avoid name clashes, this object file will have a temporary ;; file name (tmp-name). ;; (let* ((tmp-names (safe-mkstemp #P"TMP:ECLINIT")) (tmp-name (first tmp-names)) (c-name (si::coerce-to-filename (compile-file-pathname tmp-name :type :c))) (o-name (si::coerce-to-filename (compile-file-pathname tmp-name :type :object))) submodules (submodules-data ()) c-file) (dolist (item (reverse lisp-files)) (let* ((path (etypecase item (symbol (system-ld-flag item)) (pathname item) (string (parse-namestring item)))) (kind (guess-kind path))) (unless (member kind '(:shared-library :dll :static-library :lib :object :c)) (error "C::BUILDER does not accept a file ~s of kind ~s" item kind)) (let* ((init-fn (guess-init-name path (guess-kind path))) (flags (guess-ld-flags path))) ;; We should give a warning that we cannot link this module in (when flags (push flags ld-flags)) (when init-fn (push (list init-fn path) submodules))))) (setf submodules-data (apply #'concatenate '(array base-char (*)) submodules-data)) (setq c-file (open c-name :direction :output :external-format :default)) (format c-file +lisp-program-header+ submodules) (let ((init-tag (init-name-tag init-name :kind target))) (ecase target (:program (format c-file +lisp-program-init+ init-name init-tag "" submodules "") (format c-file #+:win32 (ecase system (:console +lisp-program-main+) (:windows +lisp-program-winmain+)) #-:win32 +lisp-program-main+ prologue-code init-name epilogue-code) (close c-file) (compiler-cc c-name o-name) (linker-cc output-name (list* (namestring o-name) ld-flags))) ((:library :static-library :lib) (format c-file +lisp-program-init+ init-name init-tag prologue-code submodules epilogue-code) (format c-file +lisp-init-wrapper+ wrap-init-name init-name) (format c-file +lisp-library-main+ main-name prologue-code init-name epilogue-code) (close c-file) (compiler-cc c-name o-name) (when (probe-file output-name) (delete-file output-name)) (linker-ar output-name o-name ld-flags)) #+dlopen ((:shared-library :dll) (format c-file +lisp-program-init+ init-name init-tag prologue-code submodules epilogue-code) (format c-file +lisp-init-wrapper+ wrap-init-name init-name) (format c-file +lisp-library-main+ main-name prologue-code init-name epilogue-code) (close c-file) (compiler-cc c-name o-name) (shared-cc output-name (list* o-name ld-flags))) #+dlopen (:fasl (format c-file +lisp-program-init+ init-name init-tag prologue-code submodules epilogue-code) (close c-file) (compiler-cc c-name o-name) (bundle-cc output-name init-name (list* o-name ld-flags)))) (mapc 'cmp-delete-file tmp-names) (cmp-delete-file c-name) (cmp-delete-file o-name) output-name))) (defun build-fasl (&rest args) (apply #'builder :fasl args)) (defun build-program (&rest args) (apply #'builder :program args)) (defun build-static-library (&rest args) (apply #'builder :static-library args)) (defun build-shared-library (&rest args) #-dlopen (error "Dynamically loadable libraries not supported in this system.") #+dlopen (apply #'builder :shared-library args)) (defun compile-file (input-pathname &rest args &key ((:verbose *compile-verbose*) *compile-verbose*) ((:print *compile-print*) *compile-print*) (source-truename nil) (source-offset 0) (c-file nil) (h-file nil) (data-file nil) (system-p nil) (load nil) (external-format :default) output-file &aux (*standard-output* *standard-output*) (*error-output* *error-output*) (*compiler-in-use* *compiler-in-use*) (*package* *package*) (*readtable* *readtable*) (*print-pretty* nil) (*compile-file-pathname* nil) (*compile-file-truename* nil) (ext:*source-location* (cons source-truename 0)) (*suppress-compiler-messages* (or *suppress-compiler-messages* (not *compile-verbose*))) input-file init-name) (declare (notinline compiler-cc)) "Compiles the file specified by INPUT-PATHNAME and generates a fasl file specified by OUTPUT-FILE. If the filetype is not specified in INPUT-PATHNAME, then \".lsp\" is used as the default file type for the source file. LOAD specifies whether to load the generated fasl file after compilation. The :O-FILE, :C-FILE, :H-FILE, and :DATA-FILE keyword parameters allow you to control the intermediate files generated by the ECL compiler.If the file was compiled successfully, returns the pathname of the compiled file" #-dlopen (unless system-p (format t "~%;;;~ ~%;;; This system does not support loading dynamically linked libraries.~ ~%;;; Therefore, COMPILE-FILE without :SYSTEM-P T is unsupported.~ ~%;;;")) (setq *compile-file-pathname* (pathname (merge-pathnames input-pathname))) (unless (probe-file *compile-file-pathname*) (if (pathname-type input-pathname) (error 'file-error :pathname input-pathname) (dolist (ext '("lsp" "LSP" "lisp" "LISP") (error 'file-error :pathname input-pathname)) (setq *compile-file-pathname* (make-pathname :type ext :defaults input-pathname)) (when (probe-file *compile-file-pathname*) (return))))) (setq input-file (truename *compile-file-pathname*) *compile-file-truename* input-file) (when (and system-p load) (error "Cannot load system files.")) (cmpprogress "~&;;;~%;;; Compiling ~a." (namestring input-pathname)) (let* ((eof '(NIL)) (*compiler-in-use* *compiler-in-use*) (*load-time-values* nil) ;; Load time values are compiled (output-file (apply #'compile-file-pathname input-file args)) (true-output-file nil) ;; Will be set at the end (c-pathname (apply #'compile-file-pathname output-file :output-file c-file :type :c args)) (h-pathname (apply #'compile-file-pathname output-file :output-file h-file :type :h args)) (data-pathname (apply #'compile-file-pathname output-file :output-file data-file :type :data args)) (compiler-conditions nil) (to-delete (nconc (unless c-file (list c-pathname)) (unless h-file (list h-pathname)) (unless data-file (list data-pathname))))) (with-compiler-env (compiler-conditions) (print-compiler-info) (when (probe-file "./cmpinit.lsp") (load "./cmpinit.lsp" :verbose *compile-verbose*)) (data-init) (with-open-file (*compiler-input* *compile-file-pathname* :external-format external-format) (unless source-truename (setf (car ext:*source-location*) *compile-file-pathname*)) (do* ((*compile-file-position* 0 (file-position *compiler-input*)) (form (si::read-object-or-ignore *compiler-input* eof) (si::read-object-or-ignore *compiler-input* eof))) ((eq form eof)) (when form (setf (cdr ext:*source-location*) (+ source-offset *compile-file-position*)) (t1expr form)))) (cmpprogress "~&;;; End of Pass 1.") (setf init-name (compute-init-name output-file :kind (if system-p :object :fasl))) (compiler-pass2 c-pathname h-pathname data-pathname init-name :input-designator (namestring input-pathname)) (data-c-dump data-pathname) (let ((o-pathname (if system-p output-file (compile-file-pathname output-file :type :object)))) (compiler-cc c-pathname o-pathname) #+dlopen (unless system-p (push o-pathname to-delete) (bundle-cc (si::coerce-to-filename output-file) init-name (list (si::coerce-to-filename o-pathname))))) (if (setf true-output-file (probe-file output-file)) (cmpprogress "~&;;; Finished compiling ~a.~%;;;~%" (namestring input-pathname)) (cmperr "The C compiler failed to compile the intermediate file.")) (mapc #'cmp-delete-file to-delete) (when (and load true-output-file (not system-p)) (load true-output-file :verbose *compile-verbose*)) ) ; with-compiler-env (compiler-output-values true-output-file compiler-conditions))) (defun compiler-output-values (main-value conditions) (loop for i in conditions with warning-p = nil with failure-p = nil do (cond ((typep i 'style-warning) (setf warning-p t)) ((typep i '(or compiler-error warning)) (setf warning-p t failure-p t))) finally (return (values main-value warning-p failure-p)))) #-dlopen (defun compile (name &optional (def nil supplied-p)) (format t "~%;;;~ ~%;;; This system does not support loading dynamically linked libraries.~ ~%;;; Therefore, COMPILE is unsupported.~ ~%;;;")) #+dlopen (defvar *gazonk-counter* 0) #+dlopen (defun compile (name &optional (def nil supplied-p) &aux form data-pathname (*suppress-compiler-messages* (or *suppress-compiler-messages* (not *compile-verbose*))) (*compiler-in-use* *compiler-in-use*) (*standard-output* *standard-output*) (*error-output* *error-output*) (*package* *package*) (*compile-print* nil) (*print-pretty* nil) (*compiler-constants* t)) "Args: (name &optional definition) If DEFINITION is NIL, NAME must be the name of a not-yet-compiled function. In this case, COMPILE compiles the function, installs the compiled function as the global function definition of NAME, and returns NAME. If DEFINITION is non-NIL, it must be a lambda expression and NAME must be a symbol. COMPILE compiles the lambda expression, installs the compiled function as the function definition of NAME, and returns NAME. There is only one exception for this: If NAME is NIL, then the compiled function is not installed but is simply returned as the value of COMPILE. In any case, COMPILE creates temporary files, whose filenames begin with \"gazonk\", which are automatically deleted after compilation." (unless (symbolp name) (error "~s is not a symbol." name)) (cond ((and supplied-p def) (when (functionp def) (unless (function-lambda-expression def) (return-from compile def)) (setf def (function-lambda-expression def))) (setq form (if name `(setf (symbol-function ',name) #',def) `(set 'GAZONK #',def)))) ((not (fboundp name)) (error "Symbol ~s is unbound." name)) ((typep (setf def (symbol-function name)) 'standard-generic-function) (warn "COMPILE can not compile generic functions yet") (return-from compile (values def t nil))) ((null (setq form (function-lambda-expression def))) (warn "We have lost the original function definition for ~s. Compilation to C failed" name) (return-from compile (values def t nil))) (t (setq form `(setf (symbol-function ',name) #',form)))) (let*((*load-time-values* 'values) ;; Only the value is kept (tmp-names (safe-mkstemp (format nil "TMP:ECL~3,'0x" (incf *gazonk-counter*)))) (data-pathname (first tmp-names)) (c-pathname (compile-file-pathname data-pathname :type :c)) (h-pathname (compile-file-pathname data-pathname :type :h)) (o-pathname (compile-file-pathname data-pathname :type :object)) (so-pathname (compile-file-pathname data-pathname)) (init-name (compute-init-name so-pathname :kind :fasl)) (compiler-conditions nil)) (with-compiler-env (compiler-conditions) (print-compiler-info) (data-init) (t1expr form) (cmpprogress "~&;;; End of Pass 1.") (let (#+(or mingw32 msvc cygwin)(*self-destructing-fasl* t)) (compiler-pass2 c-pathname h-pathname data-pathname init-name :input-designator (let* ((*print-circle* t) (*print-length* 8) (*print-depth* 4)) (format nil "~W" def)))) (data-c-dump data-pathname) (compiler-cc c-pathname o-pathname) (bundle-cc (si::coerce-to-filename so-pathname) init-name (list (si::coerce-to-filename o-pathname))) (cmp-delete-file c-pathname) (cmp-delete-file h-pathname) (cmp-delete-file o-pathname) (mapc 'cmp-delete-file tmp-names) (cond ((probe-file so-pathname) (load so-pathname :verbose nil) (cmp-delete-file so-pathname)) (t (setf name nil) (set 'GAZONK nil) (cmperr "The C compiler failed to compile the intermediate code for ~s." name))) ) ; with-compiler-env (cmp-delete-file c-pathname) (cmp-delete-file h-pathname) (cmp-delete-file so-pathname) (mapc 'cmp-delete-file tmp-names) (let ((output (or name (symbol-value 'GAZONK)))) ;; By unsetting GAZONK we avoid spurious references to the ;; loaded code. (set 'GAZONK nil) (si::gc t) (compiler-output-values output compiler-conditions)))) (defun disassemble (thing &key (h-file nil) (data-file nil) &aux def disassembled-form (*compiler-in-use* *compiler-in-use*) (*print-pretty* nil)) "Compiles the form specified by THING and prints the intermediate C language code for that form. But does not install the result of compilation. If THING is NIL, then the previously DISASSEMBLEd form is re-DISASSEMBLEd. If THING is a symbol that names a function not yet compiled, the function definition is disassembled. If THING is a lambda expression, it is disassembled as a function definition. Otherwise, THING itself is disassembled as a top-level form. H-FILE and DATA-FILE specify intermediate files to build a fasl file from the C language code. NIL means \"do not create the file\"." (when (si::valid-function-name-p thing) (setq thing (fdefinition thing))) (cond ((null thing)) ((functionp thing) (unless (si::bc-disassemble thing) (warn "Cannot disassemble the binary function ~S because I do not have its source code." thing) (return-from disassemble nil))) ((atom thing) (error 'simple-type-error :datum thing :expected-type '(OR FUNCTION (SATISFIES SI:VALID-FUNCTION-NAME-P)) :format-control "DISASSEMBLE cannot accept ~A" :format-arguments (list thing))) ((eq (car thing) 'LAMBDA) (setq disassembled-form `(defun gazonk ,@(cdr thing)))) ((eq (car thing) 'EXT:LAMBDA-BLOCK) (setq disassembled-form `(defun ,@(rest thing)))) (t (error 'simple-type-error :datum thing :expected-type '(OR FUNCTION (SATISFIES SI:VALID-FUNCTION-NAME-P)) :format-control "DISASSEMBLE cannot accept ~A" :format-arguments (list thing)))) (let* ((null-stream (make-broadcast-stream)) (*compiler-output1* null-stream) (*compiler-output2* (if h-file (open h-file :direction :output :external-format :default) null-stream)) (t3local-fun (symbol-function 'T3LOCAL-FUN)) (compiler-conditions nil)) (with-compiler-env (compiler-conditions) (unwind-protect (progn (setf (symbol-function 'T3LOCAL-FUN) #'(lambda (&rest args) (let ((*compiler-output1* *standard-output*)) (apply t3local-fun args)))) (data-init) (t1expr disassembled-form) (ctop-write (compute-init-name "foo" :kind :fasl) (if h-file h-file "") (if data-file data-file "")) (when data-file (data-c-dump data-file))) (setf (symbol-function 'T3LOCAL-FUN) t3local-fun) (when h-file (close *compiler-output2*))))) nil) (defun compiler-pass2 (c-pathname h-pathname data-pathname init-name &key input-designator) (with-open-file (*compiler-output1* c-pathname :direction :output :if-does-not-exist :create :if-exists :supersede) (wt-comment-nl "Compiler: ~A ~A" (lisp-implementation-type) (lisp-implementation-version)) #-ecl-min (multiple-value-bind (second minute hour day month year) (get-decoded-time) (declare (ignore second)) (wt-comment-nl "Date: ~D/~D/~D ~2,'0D:~2,'0D (yyyy/mm/dd)" year month day hour minute) (wt-comment-nl "Machine: ~A ~A ~A" (software-type) (software-version) (machine-type))) (wt-comment-nl "Source: ~A" input-designator) (with-open-file (*compiler-output2* h-pathname :direction :output :if-does-not-exist :create :if-exists :supersede) (wt-nl1 "#include " *cmpinclude*) (ctop-write init-name h-pathname data-pathname) (terpri *compiler-output1*) (terpri *compiler-output2*)))) (defun ecl-include-directory () "Finds the directory in which the header files were installed." (cond ((and *ecl-include-directory* (probe-file (merge-pathnames "ecl/config.h" *ecl-include-directory*))) *ecl-include-directory*) ((probe-file "SYS:ecl;config.h") (setf *ecl-include-directory* (namestring (translate-logical-pathname "SYS:")))) ((error "Unable to find include directory")))) (defun ecl-library-directory () "Finds the directory in which the ECL core library was installed." (cond ((and *ecl-library-directory* (probe-file (merge-pathnames (compile-file-pathname "ecl" :type #+dlopen :shared-library #-dlopen :static-library) *ecl-library-directory*))) *ecl-library-directory*) ((probe-file "SYS:BUILD-STAMP") (setf *ecl-library-directory* (namestring (translate-logical-pathname "SYS:")))) ((error "Unable to find library directory")))) (defun compiler-cc (c-pathname o-pathname) (safe-run-program *cc* `("-I." ,(concatenate 'string "-I" (fix-for-mingw (ecl-include-directory))) ,@(split-program-options *cc-flags*) ,@(and (>= (cmp-env-optimization 'speed) 2) (split-program-options *cc-optimize*)) "-c" ,(brief-namestring c-pathname) #-msvc ,@(list "-o" (brief-namestring o-pathname)) #+msvc ,(concatenate 'string "-Fo" (brief-namestring o-pathname)) ,@(split-program-options *user-cc-flags*)))) ; Since the SUN4 assembler loops with big files, you might want to use this: ; (format nil ; "~A ~@[~*-O1~] -S -I. -I~A -w ~A ; as -o ~A ~A" ; *cc* (>= *speed* 2) ; *include-directory* ; (namestring c-pathname) ; (namestring o-pathname) ; (namestring s-pathname)) (defun print-compiler-info () (cmpprogress "~&;;; OPTIMIZE levels: Safety=~d, Space=~d, Speed=~d, Debug=~d~%;;;~%" *safety* *space* *speed* *debug*)) (defmacro with-compilation-unit (options &rest body) `(progn ,@body)) (ext:package-lock "CL" t) (setf *features* (delete :ecl-bytecmp *features*)) (let* ((compile #'compile) (disassemble #'disassemble) (compile-file #'compile-file) (compile-file-pathname #'compile-file-pathname)) (defun ext:install-c-compiler () (ext::package-lock (find-package :cl) nil) (setf *features* (delete :ecl-bytecmp *features*)) (setf (fdefinition 'disassemble) disassemble (fdefinition 'compile) compile (fdefinition 'compile-file) #'compile-file (fdefinition 'compile-file-pathname) #'compile-file-pathname) (ext::package-lock (find-package :cl) t))) (provide 'cmp) ecl-16.1.2/src/cmp/cmpmap.lsp000066400000000000000000000052671266352375300157350ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: C -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. ;;;; Copyright (c) 1990, Giuseppe Attardi. ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. ;;;; CMPMAP Map functions. (in-package "COMPILER") (defun expand-mapcar (whole) (when (< (length whole) 3) (si::signal-simple-error #'program-error nil "Too few arguments to function ~A in form: ~A" (firt whole) whole)) (let ((which (first whole))) (when (eq which 'FUNCALL) (setf whole (rest whole) which (first whole)) (when (consp which) (if (eq (first which) 'FUNCTION) (setf which (second which)) (return-from expand-mapcar whole)))) (let* ((function (gensym)) (fun-with `(with ,function = ,(second whole))) (args (cddr whole)) iterators for-statements (in-or-on :IN) (do-or-collect :COLLECT) (list-1-form nil) (finally-form nil)) (case which (MAPCAR) (MAPLIST (setf in-or-on :ON)) (MAPC (setf do-or-collect :DO)) (MAPL (setf in-or-on :ON do-or-collect :DO)) (MAPCAN (setf do-or-collect 'NCONC)) (MAPCON (setf in-or-on :ON do-or-collect 'NCONC))) (when (eq do-or-collect :DO) (let ((var (gensym))) (setf list-1-form `(with ,var = ,(first args)) args (list* var (rest args)) finally-form `(finally (return ,var))))) (loop for arg in (reverse args) do (let ((var (gensym))) (setf iterators (cons var iterators) for-statements (list* :for var in-or-on arg for-statements)))) `(loop ,@list-1-form ,@fun-with ,@for-statements ,do-or-collect (funcall ,function ,@iterators) ,@finally-form)))) (define-compiler-macro mapcar (&whole whole &rest r) (expand-mapcar whole)) (define-compiler-macro mapc (&whole whole &rest r) (expand-mapcar whole)) (define-compiler-macro mapcan (&whole whole &rest r) (expand-mapcar whole)) (define-compiler-macro maplist (&whole whole &rest r) (expand-mapcar whole)) (define-compiler-macro mapl (&whole whole &rest r) (expand-mapcar whole)) (define-compiler-macro mapcon (&whole whole &rest r) (expand-mapcar whole)) ecl-16.1.2/src/cmp/cmpmulti.lsp000066400000000000000000000247721266352375300163140ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: C -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. ;;;; Copyright (c) 1990, Giuseppe Attardi. ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. ;;;; CMPMULT Multiple-value-call and Multiple-value-prog1. (in-package "COMPILER") ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (progn (defun c1multiple-value-call (args &aux forms) (check-args-number 'MULTIPLE-VALUE-CALL args 1) (cond ;; (M-V-C #'FUNCTION) => (FUNCALL #'FUNCTION) ((endp (rest args)) (c1funcall args)) ;; (M-V-C #'FUNCTION (VALUES A ... Z)) => (FUNCALL #'FUNCTION A ... Z) ((and (= (length args) 2) (consp (setq forms (second args))) (eq 'VALUES (first forms))) (c1funcall (list* (first args) (rest forms)))) ;; More complicated case. (t (let ((function (gensym)) (frame (gensym))) `(with-stack ,frame (let* ((,function ,(first args))) ,@(loop for i in (rest args) collect `(stack-push-values ,frame ,i)) (si::apply-from-stack-frame ,frame ,function))))))) (defun c1multiple-value-prog1 (args) (check-args-number 'MULTIPLE-VALUE-PROG1 args 1) (let ((frame (gensym))) `(with-stack ,frame (stack-push-values ,frame ,(first args)) ,@(rest args) (stack-pop ,frame)))) ) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; Beppe: ;;; this is the WRONG way to handle 1 value problem. ;;; should be done in c2values, so that (values (truncate a b)) can ;;; be used to restrict to one value, so we would not have to warn ;;; if this occurred in a proclaimed fun. (defun c1values (args) (make-c1form* 'VALUES :args (c1args* args))) (defun c2values (c1form forms) (declare (ignore c1form)) (when (and (eq *destination* 'RETURN-OBJECT) (rest forms) (consp *current-form*) (eq 'DEFUN (first *current-form*))) (cmpwarn "Trying to return multiple values. ~ ~%;But ~a was proclaimed to have single value.~ ~%;Only first one will be assured." (second *current-form*))) (cond ;; When the values are not going to be used, then just ;; process each form separately. ((eq *destination* 'TRASH) (mapc #'c2expr* forms) ;; We really pass no value, but we need UNWIND-EXIT to trigger all the ;; frame-pop, stack-pop and all other exit forms. (unwind-exit 'VALUE0) ) ;; For (VALUES) we can replace the output with either NIL (if the value ;; is actually used) and set only NVALUES when the value is the output ;; of a function. ((endp forms) (cond ((eq *destination* 'RETURN) (wt-nl "value0 = ECL_NIL;") (wt-nl "cl_env_copy->nvalues = 0;") (unwind-exit 'RETURN)) ((eq *destination* 'VALUES) (wt-nl "cl_env_copy->values[0] = ECL_NIL;") (wt-nl "cl_env_copy->nvalues = 0;") (unwind-exit 'VALUES)) (t (unwind-exit 'NIL)))) ;; For a single form, we must simply ensure that we only take a single ;; value of those that the function may output. ((endp (rest forms)) (let ((form (first forms))) (if (or (not (member *destination* '(RETURN VALUES))) (c1form-single-valued-p form)) (c2expr form) (progn (let ((*destination* 'VALUE0)) (c2expr* form)) (unwind-exit 'VALUE0))))) ;; In all other cases, we store the values in the VALUES vector, ;; and force the compiler to retrieve anything out of it. (t (let* ((nv (length forms)) (*inline-blocks* 0) (*temp* *temp*) (forms (nreverse (coerce-locs (inline-args forms))))) ;; By inlining arguments we make sure that VL has no call to funct. ;; Reverse args to avoid clobbering VALUES(0) (wt-nl "cl_env_copy->nvalues = " nv ";") (do ((vl forms (rest vl)) (i (1- (length forms)) (1- i))) ((null vl)) (declare (fixnum i)) (wt-nl "cl_env_copy->values[" i "] = " (first vl) ";")) (unwind-exit 'VALUES) (close-inline-blocks))))) (defun c1multiple-value-setq (args &aux (vars nil) (temp-vars nil) (late-bindings nil)) (check-args-number 'MULTIPLE-VALUE-SETQ args 2 2) (dolist (var (reverse (first args))) (cmpck (not (symbolp var)) "The variable ~s is not a symbol." var) (let* ((var-or-form (chk-symbol-macrolet var)) (type t)) (unless (when (symbolp var-or-form) (cmpck (constantp var-or-form) "The constant ~s is being assigned a value." var-or-form) (when (or (not (policy-type-assertions)) (trivial-type-p (setf type (variable-type-in-env var-or-form)))) (push var-or-form vars) t)) (let ((new-var (gensym))) (push new-var vars) (push new-var temp-vars) (push `(setf ,var-or-form (checked-value ,type ,new-var)) late-bindings))))) (let ((value (second args))) (cond (temp-vars `(let* (,@temp-vars) (multiple-value-setq ,vars ,value) ,@late-bindings)) ((endp vars) `(values ,value)) ((= (length vars) 1) `(setq ,(first vars) ,value)) (t (setq value (c1expr value) vars (mapcar #'c1vref vars)) (add-to-set-nodes-of-var-list vars (make-c1form* 'MULTIPLE-VALUE-SETQ :args vars value)))))) (defun bind-or-set (loc v use-bind) (cond ((not use-bind) (set-var loc v)) ((or (plusp (var-ref v)) (member (var-kind v) '(SPECIAL GLOBAL))) (bind loc v)))) (defun values-loc-or-value0 (i) (if (plusp i) (values-loc i) 'VALUE0)) (defun do-m-v-setq (vars form use-bind &aux min-values max-values) ;; This routine moves values from the multiple-value stack into the ;; variables VARS. The amount of values is not known (or at least we only ;; know that there is some number between MIN-VALUES and MAX-VALUES). If ;; the values are to be created with BIND, then USED-BIND=T. The output of ;; this routine is a location containing the first value (typically, the ;; name of the first variable). ;; (when (= (length vars) 1) (let ((*destination* (first vars))) (c2expr* form) (return-from do-m-v-setq *destination*))) ;; Store the values in the values stack + value0. Try guessing how ;; many they are. (multiple-value-bind (min-values max-values) (c1form-values-number form) ;; We save the values in the value stack + value0 (let ((*destination* 'RETURN)) (c2expr* form)) ;; At least we always have NIL value0 (setf min-values (max 1 min-values)) ;; We know that at least MIN-VALUES variables will get a value (dotimes (i min-values) (when vars (let ((v (pop vars)) (loc (values-loc-or-value0 i))) (bind-or-set loc v use-bind)))) (when (some #'useful-var-p vars) (let* ((*lcl* *lcl*) (nr (make-lcl-var :type :int)) (tmp (make-lcl-var))) (wt-nl-open-brace) (wt-nl "const int " nr " = cl_env_copy->nvalues;") (wt-nl "cl_object " tmp ";") (loop for v in vars for i from min-values for loc = (values-loc-or-value0 i) do (when (useful-var-p v) (wt-nl tmp " = (" nr "<=" i ")? ECL_NIL : " loc ";") (bind-or-set tmp v use-bind))) (wt-nl-close-brace))) 'VALUE0)) (defun c2multiple-value-setq (c1form vars form) (declare (ignore c1form)) (unwind-exit (do-m-v-setq vars form nil))) (defun c1multiple-value-bind (args) (check-args-number 'MULTIPLE-VALUE-BIND args 2) (let* ((*cmp-env* (cmp-env-copy)) (variables (pop args)) (init-form (pop args))) (when (= (length variables) 1) (return-from c1multiple-value-bind `(let* ((,(first variables) ,init-form)) ,@args))) (multiple-value-bind (body ss ts is other-decls) (c1body args nil) (c1declare-specials ss) (let* ((vars (loop for name in variables collect (c1make-var name ss is ts)))) (setq init-form (c1expr init-form)) (mapc #'push-vars vars) (check-vdecl variables ts is) (setq body (c1decl-body other-decls body)) (mapc #'check-vref vars) (make-c1form* 'MULTIPLE-VALUE-BIND :type (c1form-type body) :local-vars vars :args vars init-form body))))) (defun c2multiple-value-bind (c1form vars init-form body) (declare (ignore c1form)) (let* ((*unwind-exit* *unwind-exit*) (*env-lvl* *env-lvl*) (*env* *env*) (*lcl* *lcl*) (labels nil) (env-grows nil) (nr (make-lcl-var :type :int)) (*inline-blocks* 0) min-values max-values) ;; 1) Retrieve the number of output values (multiple-value-setq (min-values max-values) (c1form-values-number init-form)) ;; 2) For all variables which are not special and do not belong to ;; a closure, make a local C variable. (dolist (var vars) (declare (type var var)) (let ((kind (local var))) (if kind (when (useful-var-p var) (maybe-open-inline-block) (bind (next-lcl) var) (wt-nl (rep-type->c-name kind) " " *volatile* var ";") (wt-comment (var-name var))) (unless env-grows (setq env-grows (var-ref-ccb var)))))) ;; 3) If there are closure variables, set up an environment. (when (setq env-grows (env-grows env-grows)) (let ((env-lvl *env-lvl*)) (maybe-open-inline-block) (wt-nl "volatile cl_object env" (incf *env-lvl*) " = env" env-lvl ";"))) ;; 4) Assign the values to the variables, compiling the form ;; and binding the variables in the process. (do-m-v-setq vars init-form t) ;; 5) Compile the body. If there are bindings of special variables, ;; these bindings are undone here. (c2expr body) ;; 6) Close the C expression. (close-inline-blocks))) ecl-16.1.2/src/cmp/cmpname.lsp000066400000000000000000000167201266352375300160740ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: C -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; Copyright (c) 2007, Juan Jose Garcia Ripoll. ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. ;;;; CMPNAME Unambiguous init names for object files ;;;; ;;;; Every object file in a lisp library or combined FASL (such as the ;;;; compiler), needs a function that creates its data and installs the ;;;; functions. This initialization function has a C name which needs ;;;; to be unique. This file has functions to create such names. #-new-cmp (in-package "COMPILER") #+new-cmp (in-package "C-TAGS") (defun encode-number-in-name (number) ;; Encode a number in an alphanumeric identifier which is a valid C name. (declare (si::c-local)) (cond ((zerop number) "0") ((minusp number) (encode-number-in-name (- number))) (t (do* ((code "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz") (base (length code)) (output '()) (digit 0)) ((zerop number) (coerce (nreverse output) 'base-string)) (multiple-value-setq (number digit) (floor number base)) (push (char code digit) output))))) (defun unique-init-name (file) "Create a unique name for this initialization function. The current algorithm relies only on the name of the source file and the time at which it is built. This should be enough to prevent name collisions for object files built in the same machine." (let* ((path (pathname file)) (path-hash (logxor (ash (sxhash path) 8) (ash (sxhash (cddr (pathname-directory path))) 16) (sxhash (pathname-name path)))) (seconds (get-universal-time)) (ms (+ (* seconds 1000) (mod (floor (* 1000 (get-internal-real-time)) internal-time-units-per-second) 1000))) (tag (concatenate 'base-string "_ecl" (encode-number-in-name path-hash) "_" (encode-number-in-name ms)))) tag)) (defun kind->tag (kind) (case kind ((:object :c) "@EcLtAg") ((:fasl :fas) "@EcLtAg_fas") ((:static-library :lib) "@EcLtAg_lib") ((:shared-library :dll) "@EcLtAg_dll") ((:program) "@EcLtAg_exe") (otherwise (error "C::BUILDER cannot accept files of kind ~s" kind)))) (defun init-name-tag (init-name &key (kind :object)) (concatenate 'base-string (kind->tag kind) ":" init-name "@")) (defun search-tag (stream tag) (declare (si::c-local)) (do* ((eof nil) (key (concatenate 'list tag ":")) (string key)) (nil) (let ((c (read-byte stream nil nil))) (cond ((null c) (return nil)) ((not (= c (char-code (pop string)))) (setf string key)) ((null string) (return t)))))) (defun read-name (stream) (declare (si::c-local)) (concatenate 'string (loop with c = t until (or (null (setf c (read-byte stream nil nil))) (= c #.(char-code #\@))) collect (code-char c)))) (defun find-init-name (file &key (tag "@EcLtAg")) "Search for the initialization function in an object file. Since the initialization function in object files have more or less unpredictable names, we store them in a string in the object file. This string is recognized by the TAG it has at the beginning This function searches that tag and retrieves the function name it precedes." #-pnacl (with-open-file (stream file :direction :input :element-type '(unsigned-byte 8)) (when (search-tag stream tag) (let ((name (read-name stream))) name))) #+pnacl (let* ((pnacl-dis (or (ext:getenv "PNACL_DIS") (error "please set the PNACL_DIS environment variable to your toolchain's pnacl-dis location"))) (stream (ext:run-program pnacl-dis (list (namestring (translate-logical-pathname file))) :wait nil :input NIL :output :STREAM :error :OUTPUT))) (unless stream (error "Unable to disasemble file ~a" file)) (when (search-tag stream tag) (let ((name (read-name stream))) name)))) (defun guess-init-name (pathname kind) (case kind ((:object :c :static-library :lib :shared-library :dll) (or (and (probe-file pathname) (find-init-name pathname :tag (kind->tag kind))) (cmpnote "Cannot find out entry point for binary file ~A" pathname))) (otherwise (compute-init-name pathname kind)))) (defun remove-prefix (prefix name) (if (equal 0 (search prefix name)) (subseq name (length prefix) nil) name)) (defun compute-init-name (pathname &key (kind (guess-kind pathname)) (prefix nil) (wrapper nil)) "Computes initialization function name. Libraries, FASLS and programs init function names can't be randomized to allow initialization from the C code which wants to use it." (let ((filename (pathname-name (translate-logical-pathname pathname))) (unique-name (unique-init-name pathname))) (case kind ((:object :c) unique-name) ((:fasl :fas) (init-function-name "CODE" :kind :fas :prefix prefix)) ((:static-library :lib) (init-function-name (if wrapper (remove-prefix +static-library-prefix+ filename) unique-name) :kind :lib :prefix prefix)) ((:shared-library :dll) (init-function-name (if wrapper (remove-prefix +shared-library-prefix+ filename) unique-name) :kind :dll :prefix prefix)) ((:program) (concatenate 'string (or prefix "init_") "ECL_PROGRAM")) (otherwise (error "C::BUILDER cannot accept files of kind ~s" kind))))) (defun init-function-name (s &key (kind :object) (prefix nil)) (flet ((translate-char (c) (cond ((and (char>= c #\a) (char<= c #\z)) (char-upcase c)) ((and (char>= c #\A) (char<= c #\Z)) c) ((or (eq c #\-) (eq c #\_)) #\_) ((eq c #\*) #\x) ((eq c #\?) #\a) ((digit-char-p c) c) (t #\p))) (disambiguation (c) (case kind ((:object :c) "") ((:fasl :fas) "fas_") ((:library :static-library :lib) "lib_") ((:shared-library :dll) "dll_") ((:program) "exe_") (otherwise (error "Not a valid argument to INIT-FUNCTION-NAME: kind = ~S" kind))))) (setq s (map 'string #'translate-char (string s))) (concatenate 'string (or prefix "init_") (disambiguation kind) (map 'string #'translate-char (string s))))) ecl-16.1.2/src/cmp/cmpnum.lsp000066400000000000000000000263051266352375300157530ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: C -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; CMPNUM -- Optimizer for numerical expressions. ;;;; Copyright (c) 2005, Juan Jose Garcia Ripoll ;;;; ;;;; ECoLisp is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. (in-package "COMPILER") (defun simplify-arithmetic (operator args whole) (if (every #'numberp args) (apply operator args) (let ((l (length args))) (cond ((> l 2) (simplify-arithmetic operator (list* (simplify-arithmetic operator (list (first args) (second args)) nil) (cddr args)) nil)) ((= l 2) (or whole (list* operator args))) ((= l 1) (if (or (eq operator '*) (eq operator '+)) (first args) (or whole (list* operator args)))) ((eq operator '*) 1) ((eq operator '+) 0) (t (error 'simple-program-error :format-error "Wrong number of arguments for operator ~a in ~a" :format-arguments (list operator (or whole (list* operator args))))))))) (define-compiler-macro * (&whole all &rest args) (simplify-arithmetic '* args all)) (define-compiler-macro + (&whole all &rest args) (simplify-arithmetic '+ args all)) (define-compiler-macro / (&whole all &rest args) (simplify-arithmetic '/ args all)) (define-compiler-macro - (&whole all &rest args) (simplify-arithmetic '- args all)) ;;; ;;; The following are type propagators for arithmetic operations. Note ;;; that some of they have become binary operators. ;;; (defun maximum-number-type (t1 t2 &key only-real integer-result) ;; Computes the output type of an operation between number types T1 ;; and T2 using the rules of floating point contagion. It returns ;; the type of the result, and the types of T1 and T2, if they ;; represent known types, or NUMBER, in other cases. (let ((t1-eq nil) (t2-eq nil) (output nil) (default (if only-real 'REAL 'NUMBER)) (types-list (if only-real '(FIXNUM INTEGER RATIONAL SINGLE-FLOAT DOUBLE-FLOAT #+long-float LONG-FLOAT FLOAT REAL NUMBER) '(FIXNUM INTEGER RATIONAL SINGLE-FLOAT DOUBLE-FLOAT #+long-float LONG-FLOAT FLOAT REAL)))) (dolist (i types-list) (when (and (null t1-eq) (type>= i t1)) (if (equalp t1 t2) (setf t2-eq i)) (setf t1-eq i output i)) (when (and (null t2-eq) (type>= i t2)) (setf t2-eq i output i))) (unless (and t1-eq t2-eq output) (setf output default)) (when (and integer-result (or (eq output 'fixnum) (eq output 'integer))) (setf output integer-result)) (values output (if t1-eq t1 default) (if t2-eq t2 default)))) (defun ensure-number-type (general-type) (maximum-number-type general-type general-type)) (defun ensure-nonrational-type (general-type) (maximum-number-type general-type 'single-float)) (defun ensure-real-type (general-type) (maximum-number-type general-type 'integer :only-real t)) (defun arithmetic-propagator (op1-type others integer-result) ;; Propagates types for an associative operator (we do not care which one). ;; We collect either the types of the arguments or 'NUMBER, as a generic ;; expected type. The output type is computed using the rules of floating ;; point contagion, with the exception that an operation between two ;; integers has type INTEGER-RESULT (integer for *,-,+ and rational else) (multiple-value-bind (result-type op1-type) (ensure-number-type op1-type) (loop with arg-types = (list op1-type) for x in others for op2-type = x do (progn (multiple-value-setq (result-type op1-type op2-type) (maximum-number-type result-type op2-type :integer-result integer-result)) (setf arg-types (cons op2-type arg-types))) finally (return (values (nreverse arg-types) result-type))))) (def-type-propagator * (fname op1 &rest others) (arithmetic-propagator op1 others 'integer)) (copy-type-propagator '* '(+ -)) (def-type-propagator / (fname op1 &rest others) (arithmetic-propagator op1 others 'rational)) (defun most-generic-number-rep-type (r1 r2) (let* ((r1 (rep-type-record r1)) (r2 (rep-type-record r2))) (rep-type-name (if (< (rep-type-index r1) (rep-type-index r2)) r2 r1)))) (defun inline-binop (expected-type arg1 arg2 consing non-consing) (let ((arg1-type (inlined-arg-type arg1)) (arg2-type (inlined-arg-type arg2))) (if (and (policy-assume-right-type) (c-number-type-p expected-type) (c-number-type-p arg1-type) (c-number-type-p arg2-type)) ;; The input arguments have to be coerced to a C ;; type that fits the output, to avoid overflow which ;; would happen if we used say, long c = (int)a * (int)b ;; as the output would be an integer, not a long. (let* ((arg1-rep (lisp-type->rep-type arg1-type)) (arg2-rep (lisp-type->rep-type arg2-type)) (out-rep (lisp-type->rep-type expected-type)) (max-rep (most-generic-number-rep-type (most-generic-number-rep-type arg1-rep arg2-rep) out-rep)) (max-name (rep-type->c-name max-rep))) (produce-inline-loc (list arg1 arg2) (list arg1-rep arg2-rep) (list max-rep) (format nil "(~@[(~A)~]#0)~A(~@[(~A)~]#1)" (unless (eq arg1-rep max-rep) max-name) non-consing (unless (eq arg2-rep max-rep) max-name)) nil t)) (produce-inline-loc (list arg1 arg2) '(:object :object) '(:object) consing nil t)))) (defun inline-arith-unop (expected-type arg1 consing non-consing) (let ((arg1-type (inlined-arg-type arg1))) (if (and (policy-assume-right-type) (c-number-type-p expected-type) (c-number-type-p arg1-type)) (produce-inline-loc (list arg1) (list (lisp-type->rep-type arg1-type)) (list (lisp-type->rep-type expected-type)) non-consing nil t) (produce-inline-loc (list arg1) '(:object :object) '(:object) consing nil t)))) (define-c-inliner + (return-type &rest arguments &aux arg1 arg2) (when (null arguments) (return '(fixnum-value 0))) (setf arg1 (pop arguments)) (when (null arguments) (return (inlined-arg-loc arg1))) (loop for arg2 = (pop arguments) for result = (inline-binop return-type arg1 arg2 "ecl_plus(#0,#1)" #\+) do (if arguments (setf arg1 (save-inline-loc result)) (return result)))) (define-c-inliner - (return-type arg1 &rest arguments &aux arg2) (when (null arguments) (return (inline-arith-unop return-type arg1 "ecl_negate(#0)" "-(#0)"))) (loop for arg2 = (pop arguments) for result = (inline-binop return-type arg1 arg2 "ecl_minus(#0,#1)" #\-) do (if arguments (setf arg1 (save-inline-loc result)) (return result)))) (define-c-inliner * (return-type &rest arguments &aux arg1 arg2) (when (null arguments) (return '(fixnum-value 1))) (setf arg1 (pop arguments)) (when (null arguments) (return (inlined-arg-loc arg1))) (loop for arg2 = (pop arguments) for result = (inline-binop return-type arg1 arg2 "ecl_times(#0,#1)" #\*) do (if arguments (setf arg1 (save-inline-loc result)) (return result)))) (define-c-inliner / (return-type arg1 &rest arguments &aux arg2) (when (null arguments) (return (inline-arith-unop return-type arg1 "ecl_divide(ecl_make_fixnum(1),(#0))" "1/(#0)"))) (loop for arg2 = (pop arguments) for result = (inline-binop return-type arg1 arg2 "ecl_divide(#0,#1)" #\/) do (if arguments (setf arg1 (save-inline-loc result)) (return result)))) ;;; ;;; SPECIAL FUNCTIONS ;;; (def-type-propagator cos (fname op1-type) (multiple-value-bind (output-type op1-type) (ensure-nonrational-type op1-type) (values (list op1-type) output-type))) (copy-type-propagator 'cos '(sin tan cosh sinh tanh exp)) (def-type-propagator acos (fname op1-type) (multiple-value-bind (output-type op1-type) (ensure-nonrational-type op1-type) (values (list op1-type) 'NUMBER))) (def-type-propagator atan (fname op1-type &optional (op2-type t op2-p)) (multiple-value-bind (float-t1 t1) (ensure-nonrational-type op1-type) (if op2-p (multiple-value-bind (result t1 t2) (maximum-number-type t1 op2-type :only-real t) (values (list t1 t2) result)) (values (list t1) t1)))) (def-type-propagator expt (fname base exponent) ;; Rules: ;; (expt fixnum integer) -> integer ;; (expt number-type integer) -> number-type ;; (expt number-type1 number-type2) -> (max-float number-type1 number-type2) ;; (let ((exponent (ensure-real-type exponent))) (values (list base exponent) (cond ((eql exponent 'integer) (if (subtypep base 'fixnum) 'integer base)) ((type>= '(real 0 *) base) (let* ((exponent (ensure-nonrational-type exponent))) (maximum-number-type exponent base))) (t 'number))))) (def-type-propagator abs (fname arg) (multiple-value-bind (output arg) (ensure-number-type arg) (values (list arg) (or (cdr (assoc output '((FIXNUM . (INTEGER 0 #.MOST-POSITIVE-FIXNUM)) (INTEGER . (INTEGER 0 *)) (RATIONAL . (RATIONAL 0 *)) (SHORT-FLOAT . (SHORT-FLOAT 0 *)) (SINGLE-FLOAT . (SINGLE-FLOAT 0 *)) (DOUBLE-FLOAT . (DOUBLE-FLOAT 0 *)) (LONG-FLOAT . (LONG-FLOAT 0 *)) (REAL . (REAL 0 *)) (NUMBER . (REAL 0 *))))) output)))) (def-type-propagator sqrt (fname arg) (multiple-value-bind (output arg) (ensure-nonrational-type arg) (values (list arg) (if (type>= '(REAL 0 *) arg) output 'NUMBER)))) (def-type-propagator isqrt (fname arg) (if (type>= '(integer 0 #.MOST-POSITIVE-FIXNUM) arg) (values '((integer 0 #.MOST-POSITIVE-FIXNUM)) '(integer 0 #.MOST-POSITIVE-FIXNUM)) (values '((integer 0 *)) '(integer 0 *)))) ecl-16.1.2/src/cmp/cmpopt-bits.lsp000066400000000000000000000157071266352375300167210ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: C -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; Copyright (c) 2010, Juan Jose Garcia-Ripoll ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. ;;;; ;;;; CMPOPT-BITS -- Optimize operations acting on bits ;;;; (in-package "COMPILER") ;;; ;;; LDB ;;; Look for inline expansion of LDB1 in sysfun.lsp ;;; (defun inline-bytespec (bytespec) (declare (si::c-local)) (and (consp bytespec) (eq 'BYTE (car bytespec)) (= (length bytespec) 3) (policy-inline-bit-operations))) (define-compiler-macro ldb (&whole whole bytespec integer) (if (inline-bytespec bytespec) (with-clean-symbols (%pos %size) `(with-let*-type-check ((%size ,(second bytespec) unsigned-byte) (%pos ,(third bytespec) unsigned-byte)) (logand (lognot (ash -1 %size)) (ash ,integer (- %pos))))) whole)) (define-compiler-macro ldb-test (&whole whole bytespec integer) (if (inline-bytespec bytespec) `(not (zerop (mask-field ,bytespec ,integer))) whole)) (define-compiler-macro mask-field (&whole whole bytespec integer) (if (inline-bytespec bytespec) (with-clean-symbols (%pos %size) `(with-let*-type-check ((%size ,(second bytespec) unsigned-byte) (%pos ,(third bytespec) unsigned-byte)) (logand (ash (lognot (ash -1 %size)) %pos) ,integer))) whole)) (define-compiler-macro dpb (&whole whole newbyte bytespec integer) (if (inline-bytespec bytespec) (with-clean-symbols (%pos %size %mask) `(with-let*-type-check ((%size ,(second bytespec) unsigned-byte) (%pos ,(third bytespec) unsigned-byte) (%mask (ash (lognot (ash -1 %size)) %pos) t)) (logior (logand (ash ,newbyte %pos) %mask) (logandc2 ,integer %mask)))) whole)) (define-compiler-macro deposit-field (&whole whole newbyte bytespec integer) (if (inline-bytespec bytespec) (with-clean-symbols (%pos %size %mask) `(with-let*-type-check ((%size ,(second bytespec) unsigned-byte) (%pos ,(third bytespec) unsigned-byte) (%mask (ash (lognot (ash -1 %size)) %pos) t)) (logior (logand ,newbyte %mask) (logandc2 ,integer %mask) ))) whole)) (define-setf-expander ldb (&environment env bytespec int) (multiple-value-bind (temps vals stores store-form access-form) (get-setf-expansion int env) (if (inline-bytespec bytespec) (let* ((bpos (gensym)) (bsize (gensym)) (store (gensym)) (btemp `(byte ,bpos ,bsize)) (stemp (first stores))) (values `(,bpos ,bsize ,@temps) `(,(second bytespec) ,(third bytespec) ,@vals) `(,store) `(let ((,stemp (dpb ,store ,btemp ,access-form))) ,store-form ,store) `(ldb ,btemp ,access-form))) (let* ((btemp (gensym)) (store (gensym)) (stemp (first stores))) (values `(,btemp ,@temps) `(,bytespec ,@vals) `(,store) `(let ((,stemp (dpb ,store ,btemp ,access-form))) ,store-form ,store) `(ldb ,btemp ,access-form)))))) (define-setf-expander mask-field (&environment env bytespec int) (multiple-value-bind (temps vals stores store-form access-form) (get-setf-expansion int env) (if (inline-bytespec bytespec) (let* ((bpos (gensym)) (bsize (gensym)) (store (gensym)) (btemp `(byte ,bpos ,bsize)) (stemp (first stores))) (values `(,bpos ,bsize ,@temps) `(,(second bytespec) ,(third bytespec) ,@vals) `(,store) `(let ((,stemp (deposit-field ,store ,btemp ,access-form))) ,store-form ,store) `(mask-field ,btemp ,access-form))) (let* ((btemp (gensym)) (store (gensym)) (stemp (first stores))) (values `(,btemp ,@temps) `(,bytespec ,@vals) `(,store) `(let ((,stemp (deposit-field ,store ,btemp ,access-form))) ,store-form ,store) `(mask-field ,btemp ,access-form)))))) ;;; ;;; ASH ;;; Bit fiddling. It is a bit tricky because C does not allow ;;; shifts in << or >> which exceed the integer size. In those ;;; cases the compiler may do whatever it wants (and gcc does!) ;;; (define-compiler-macro ash (&whole whole argument shift) (cond ((and (integerp argument) (integerp shift)) (ash argument shift)) ((and (policy-assume-right-type) (integerp shift)) (if (zerop shift) argument `(shift ,argument ,shift))) (t whole))) (define-c-inliner shift (return-type argument orig-shift) (let* ((arg-type (inlined-arg-type argument)) (arg-c-type (lisp-type->rep-type arg-type)) (return-c-type (lisp-type->rep-type return-type)) (shift (loc-immediate-value (inlined-arg-loc orig-shift)))) (if (or (not (c-integer-rep-type-p arg-c-type)) (not (c-integer-rep-type-p return-c-type))) (produce-inline-loc (list argument orig-shift) '(:object :fixnum) '(:object) "ecl_ash(#0,#1)" nil t) (let* ((arg-bits (c-integer-rep-type-bits arg-c-type)) (return-bits (c-integer-rep-type-bits return-c-type)) (max-type (if (and (plusp shift) (< arg-bits return-bits)) return-c-type arg-c-type))) (produce-inline-loc (list argument) (list max-type) (list return-type) (format nil (if (minusp shift) "((#0) >> (~D))" "((#0) << (~D))") (abs shift)) nil t))))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; ;;; TYPE PROPAGATION ;;; (def-type-propagator logand (fname &rest args) (values args (if args (dolist (int-type '((UNSIGNED-BYTE 8) FIXNUM) 'integer) (when (loop for value in args always (subtypep value int-type)) (return int-type))) 'fixnum))) ecl-16.1.2/src/cmp/cmpopt-clos.lsp000066400000000000000000000074341266352375300167160ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: C -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; CMPOPT-CLOS. Optimization of CLOS related operations ;;;; Copyright (c) 201. Juan Jose Garcia-Ripol ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. (in-package "COMPILER") (defun clos-compiler-macro-expand (fname args) (when (and (si::valid-function-name-p fname) (fboundp fname)) (let ((function (fdefinition fname))) (when (typep function 'generic-function) (generic-function-macro-expand function (list* fname args)))))) (defmethod generic-function-macro-expand ((g standard-generic-function) whole) (let* ((output (optimizable-slot-accessor g whole)) (success (and output t))) (values output success))) (defun optimizable-slot-reader (method whole) (when (typep method 'clos:standard-reader-method) (let ((class (first (clos:method-specializers method)))) (when (clos::class-sealedp class) (let* ((slotd (clos:accessor-method-slot-definition method)) (location (clos:slot-definition-location slotd))) (let ((object (gentemp))) (cmpnote "Inlining read access to slot ~a from class ~a" (clos:slot-definition-name slotd) (class-name class)) #+(or) `(let ((,object ,(second whole))) (locally (declare (notinline ,(first whole))) (if (typep ,object ',(class-name class)) (si::instance-ref ,object ,location) (,(first whole) ,object)))) ;(format t "~&;;; Inlining accessor ~a" (first whole)) `(let ((,object ,(second whole))) (optional-type-check ,object ',class) (locally (declare (optimize speed (safety 0))) (si::instance-ref ,object ,location))))))))) (defun optimizable-slot-writer (method whole) (when (typep method 'clos:standard-writer-method) (let ((class (second (clos:method-specializers method)))) (when (clos::class-sealedp class) (let* ((slotd (clos:accessor-method-slot-definition method)) (location (clos:slot-definition-location slotd))) (let* ((object (gentemp)) (value (gentemp))) (cmpnote "Inlining write access to slot ~a from class ~a" (clos:slot-definition-name slotd) (class-name class)) #+(or) `(let ((,value ,(second whole)) (,object ,(third whole))) (locally (declare (notinline ,(first whole))) (if (typep ,object ',(class-name class)) (si::instance-set ,object ,location ,value) (funcall #',(first whole) ,value ,object)))) ;(format t "~&;;; Inlining accessor ~a" (first whole)) `(let ((,value ,(second whole)) (,object ,(third whole))) (optional-type-check ,object ',class) (locally (declare (optimize speed (safety 0))) (si::instance-set ,object ,location ,value))))))))) (defun optimizable-slot-accessor (g whole) (and (policy-inline-slot-access) (let ((methods (clos:generic-function-methods g))) (and methods (null (rest methods)) (let* ((principal (first methods))) (or (optimizable-slot-reader principal whole) (optimizable-slot-writer principal whole))))))) ecl-16.1.2/src/cmp/cmpopt-cons.lsp000066400000000000000000000113561266352375300167160ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: C -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; CMPOPT-CONS Optimization of CONS functions ;;;; ;;;; Copyright (c) 2010, Juan Jose Garcia-Ripoll ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. (in-package "COMPILER") (defun expand-simple-optimizer (values arg-types inline-form env) `(ffi:c-inline ,(if (policy-assume-right-type env) values (loop for v in values for value-and-type in arg-types collect (if (consp value-and-type) `(checked-value ,(second value-and-type) ,v) v))) ,@inline-form)) (defun simple-optimizer-function (name args inline-form) (si::put-sysprop name 'si::compiler-macro (if (every #'symbolp args) #'(lambda (whole env) (if (policy-inline-accessors env) `(ffi:c-inline ,(rest whole) ,@inline-form) whole)) #'(lambda (whole env) (if (policy-inline-accessors env) (expand-simple-optimizer (rest whole) args inline-form env) whole))))) (defmacro cons-car (x) `(ffi:c-inline (,x) (:object) :object "ECL_CONS_CAR(#0)" :one-liner t :side-effects nil)) (defmacro cons-cdr (x) `(ffi:c-inline (,x) (:object) :object "ECL_CONS_CDR(#0)" :one-liner t :side-effects nil)) ;;; ;;; CONS ;;; turn repetitious cons's into a list* ;;; (define-compiler-macro cons (&whole whole &rest args) (labels ((cons-to-lista (x) (let ((tem (last x))) (if (and (consp tem) (consp (car tem)) (eq (caar tem) 'CONS) (eql (length (cdar tem)) 2)) (cons-to-lista (append (butlast x) (cdar tem))) x)))) (let (temp) (if (and (eql (length args) 2) (not (eq args (setq temp (cons-to-lista args))))) (if (equal '(nil) (last temp)) (cons 'LIST (butlast temp)) (cons 'LIST* temp)) whole)))) ;;; ;;; RPLACA / RPLACD ;;; (defmacro define-simple-optimizer (name args &rest inline-form) `(simple-optimizer-function ',name ',args ',inline-form)) (define-simple-optimizer rplaca ((c cons) value) (:object :object) :object "@0;(ECL_CONS_CAR(#0)=#1,#0)" :one-liner t) (define-simple-optimizer rplacd ((c cons) value) (:object :object) :object "@0;(ECL_CONS_CDR(#0)=#1,#0)" :one-liner t) ;;; ;;; NTH / NTHCDR ;;; (define-compiler-macro nth (&whole whole &rest args) (case (car args) (0 (cons 'CAR (cdr args))) (1 (cons 'CADR (cdr args))) (2 (cons 'CADDR (cdr args))) (3 (cons 'CADDDR (cdr args))) (4 (list 'CAR (cons 'CDDDDR (cdr args)))) (5 (list 'CADR (cons 'CDDDDR (cdr args)))) (6 (list 'CADDR (cons 'CDDDDR (cdr args)))) (7 (list 'CADDDR (cons 'CDDDDR (cdr args)))) (t whole))) (define-compiler-macro nthcdr (&whole whole &rest args) (case (car args) (0 (second args)) (1 (cons 'CDR (cdr args))) (2 (cons 'CDDR (cdr args))) (3 (cons 'CDDDR (cdr args))) (4 (cons 'CDDDDR (cdr args))) (5 (list 'CDR (cons 'CDDDDR (cdr args)))) (6 (list 'CDDR (cons 'CDDDDR (cdr args)))) (7 (list 'CDDDR (cons 'CDDDDR (cdr args)))) (t whole))) ;;; ;;; FIRST, SECOND, THIRD, ... ;;; (progn . #.(loop for n in '(first second third fourth fifth sixth seventh eighth ninth tenth) for i from 0 collect `(define-compiler-macro ,n (x) (list 'nth ,i x)))) (define-compiler-macro rest (x) `(cdr ,x)) ;;; ;;; POP ;;; (define-compiler-macro pop (&whole whole place &environment env) (if (policy-inline-accessors) (multiple-value-bind (vars vals stores store-form access-form) (get-setf-expansion place env) (let* ((store-var (first stores)) (saved-place (gensym))) `(let* ,(mapcar #'list (append vars (list saved-place)) (append vals (list access-form))) (declare (:read-only ,@vars)) ; Beppe (optional-type-check ,saved-place list) (when ,saved-place (let ((,store-var (cons-cdr ,saved-place))) (declare (:read-only ,store-var)) ,store-form (setq ,saved-place (cons-car ,saved-place)))) ,saved-place))) whole)) ecl-16.1.2/src/cmp/cmpopt-constant.lsp000066400000000000000000000026331266352375300176030ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: C -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; Copyright (c) 2010, Juan Jose Garcia-Ripoll. ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. ;;;; ;;;; CMPOPT-CONSTANTS Constant expressions. ;;;; (in-package "COMPILER") (defun constant-expression-p (form &optional (env *cmp-env*)) (or (constantp form env) (and (consp form) (let ((head (car form))) (or (member head '(IF OR AND NULL NOT PROGN)) (and (get-sysprop head 'pure) (inline-possible head)))) (loop for c in (rest form) always (constant-expression-p c env))))) (defun extract-constant-value (form &optional failure (env *cmp-env*)) (if (constant-expression-p form env) (handler-case (cmp-eval form env) (error (c) failure)) failure)) (defun constant-value-p (form &optional (env *cmp-env*)) (if (constant-expression-p form env) (handler-case (values t (cmp-eval form env)) (error (c) (values nil form))) (values nil form))) ecl-16.1.2/src/cmp/cmpopt-printer.lsp000066400000000000000000000066151266352375300174410ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: C -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; Copyright (c) 2010, Juan Jose Garcia-Ripoll ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. ;;;; ;;;; CMPOPT-PRINTER -- Optimize output operations ;;;; (in-package "COMPILER") (defun printer-default-stream (stream env) (if (constantp stream env) (let ((value (ext:constant-form-value stream env))) (case value ((nil) '*standard-output*) ((t) '*terminal-io*) (otherwise (cmpwarn (if (streamp value) "Found~%~A~%as expression for a stream, but it cannot be externalized." "Found~%~A~%where a stream was expected.") stream) stream))) `(ffi:c-inline (,stream) (:object) :object "_ecl_stream_or_default_output(#0)" :one-liner t))) (define-compiler-macro princ (expression &optional stream &environment env) (if (constantp expression env) (let ((value (ext:constant-form-value expression env))) (cond ((eql value #\Newline) `(terpri ,stream)) ((characterp value) `(ffi:c-inline ,(list value stream) (:wchar :object) :wchar "ecl_princ_char(#0,#1)" :one-liner t)) ((and (stringp value) (= (length value) 1)) `(ffi:c-inline ,(list (aref value 0) stream) (:wchar :object) :wchar "ecl_princ_char(#0,#1)" :one-liner t)) ((and (typep value 'base-string) (< (length value) 80)) `(progn (ffi:c-inline ,(list stream) (:object) :void ,(concatenate 'string "ecl_princ_str(" (c-inline-safe-string value) ",#0)") :one-liner t) ,value)) (t `(ffi:c-inline ,(list expression stream) (:object :object) :object "ecl_princ(#0,#1)" :one-liner t)))) `(ffi:c-inline ,(list expression stream) (:object :object) :object "ecl_princ(#0,#1)" :one-liner t))) (define-compiler-macro terpri (&optional stream &environment env) `(ffi:c-inline (,stream) (:object) :object "ecl_terpri(#0)" :one-liner t)) (define-compiler-macro print (value &optional stream &environment env) `(ffi:c-inline (,value ,stream) (:object :object) :object "ecl_print(#0,#1)" :one-liner t)) (define-compiler-macro prin1 (value &optional stream &environment env) `(ffi:c-inline (,value ,stream) (:object :object) :object "ecl_prin1(#0,#1)" :one-liner t)) ecl-16.1.2/src/cmp/cmpopt-sequence.lsp000066400000000000000000000264001266352375300175600ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: C -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; CMPOPT-SEQUENCE Optimization of SEQUENCE functions ;;;; ;;;; Copyright (c) 2010, Juan Jose Garcia-Ripoll ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. (in-package "COMPILER") (defun constant-function-expression (form) (and (consp form) (member (first form) '(quote function lambda)))) (defun seq-opt-test-function (test-flag test) (cond ((null test-flag) (values (seq-opt-test-function :test '#'eql) nil)) ((eq test-flag :test-not) (multiple-value-bind (function init) (seq-opt-test-function :test test) (values #'(lambda (v1 v2) `(not ,(funcall function v1 v2))) init))) ((constant-function-expression test) (values #'(lambda (v1 v2) `(funcall ,test ,v1 ,v2)) nil)) (t (ext:with-unique-names (test-function) (values #'(lambda (v1 v2) `(funcall ,test-function ,v1 ,v2)) (list (list test-function test))))))) (defun seq-opt-key-function (key) (cond ((null key) (values #'identity nil)) ((constant-function-expression key) (values #'(lambda (elt) `(funcall ,key ,elt)) nil)) (t (ext:with-unique-names (key-function) (values #'(lambda (elt) `(funcall ,key-function ,elt)) (list (list key-function `(or ,key #'identity)))))))) (defun seq-opt-parse-args (function args &key (start-end t)) (loop with key-flag = nil with key = nil with init = nil with test = ''eql with test-flag = nil with start = 0 with end = nil with keyword while args do (cond ((or (atom args) (null (rest args)) (eq keyword :allow-other-keys) (not (keywordp (setf keyword (pop args))))) (return nil)) ((eq keyword :key) (unless key-flag (setf key (pop args) key-flag t))) ((or (eq keyword :test) (eq keyword :test-not)) (cond ((null test-flag) (setf test (pop args) test-flag keyword)) ((not (eq test-flag keyword)) (cmpwarn "Cannot specify :TEST and :TEST-NOT arguments to ~A" function) (return nil)))) ((eq keyword :start) (unless start-end (cmpwarn "Unexpected keyword argument ~A in a call to function ~A" keyword function) (return nil)) (setf start (pop args))) ((eq keyword :end) (unless start-end (cmpwarn "Unexpected keyword argument ~A in a call to function ~A" keyword function) (return nil)) (setf end (pop args))) ((eq keyword :from-end) (unless (null (pop args)) (return nil))) (t (return nil))) finally (multiple-value-bind (key-function key-init) (seq-opt-key-function key) (multiple-value-bind (test-function test-init) (seq-opt-test-function test-flag test) (return (values key-function test-function (nconc key-init test-init) key-flag test-flag test start end)))))) #+(or) (define-compiler-macro si::make-seq-iterator (seq &optional (start 0)) (with-clean-symbols (%seq %start) `(let ((%seq (optional-type-check ,seq sequence)) (%start ,start)) (cond ((consp %seq) (nthcdr %start %seq)) ((< %start (length %seq)) %start) (t nil))))) #+(or) (define-compiler-macro si::seq-iterator-ref (seq iterator) (with-clean-symbols (%seq %iterator) `(let* ((%seq ,seq) (%iterator ,iterator)) (declare (optimize (safety 0))) (if (si::fixnump %iterator) ;; Fixnum iterators are always fine (aref %seq %iterator) ;; Error check in case we may have been passed an improper list (cons-car (checked-value cons %iterator)))))) #+(or) (define-compiler-macro si::seq-iterator-next (seq iterator) (with-clean-symbols (%seq %iterator) `(let* ((%seq ,seq) (%iterator ,iterator)) (declare (optimize (safety 0))) (if (si::fixnump %iterator) (let ((%iterator (1+ (truly-the fixnum %iterator)))) (declare (fixnum %iterator)) (and (< %iterator (length (truly-the vector %seq))) %iterator)) (cons-cdr %iterator))))) (defmacro do-in-seq ((%elt sequence &key (start 0) end output) &body body) (ext:with-unique-names (%start %iterator %counter %sequence) (let* ((counter (if end `(- (or ,end most-positive-fixnum) ,%start) 0)) (test (if end `(and ,%iterator (plusp ,%counter)) %iterator))) `(let* ((,%sequence ,sequence) (,%start ,start) (,%iterator (si::make-seq-iterator ,%sequence ,%start)) (,%counter ,counter)) (declare (:read-only ,%sequence ,%start ,%counter) (ignorable ,%counter) (fixnum ,%counter)) (loop (unless ,test (return ,output)) (let ((,%elt (si::seq-iterator-ref ,%sequence ,%iterator))) ,@body) (setf ,%iterator (si::seq-iterator-next ,%sequence ,%iterator))))))) ;;; ;;; MEMBER ;;; (defmacro do-in-list ((%elt %sublist list &rest output) &body body) `(do* ((,%sublist ,list (cons-cdr ,%sublist))) ((null ,%sublist) ,@output) (let* ((,%sublist (optional-type-check ,%sublist cons)) (,%elt (cons-car ,%sublist))) ,@body))) (defun expand-member (value list &rest sequence-args) (multiple-value-bind (key-function test-function init key-flag test-flag test) (seq-opt-parse-args 'member sequence-args :start-end nil) ;; When having complex arguments (:allow-other-keys, etc) ;; we just give up. (when (null key-function) (return-from expand-member nil)) (unless key-flag (when (and (or (null test) (constant-function-expression test)) (constant-expression-p list)) (when (<= (length (setf list (cmp-eval list))) 4) (return-from expand-member (ext:with-unique-names (%value) `(let ((,%value ,value)) (or ,@(loop for l on list for elt = (first l) collect `(and ,(funcall test-function %value `',elt) ',l))))))) (when (or (consp list) (symbol list)) (setf list `',list))) (when (or (null test-flag) (eq test-flag :test)) (when (member test '('EQ #'EQ) :test #'equal) (return-from expand-member `(ffi:c-inline (,value ,list) (:object :object) :object "si_memq(#0,#1)" :one-liner t :side-effects nil))) (when (member test '('EQL #'EQL) :test #'equal) (return-from expand-member `(ffi:c-inline (,value ,list) (:object :object) :object "ecl_memql(#0,#1)" :one-liner t :side-effects nil))) (when (member test '('EQUAL #'EQUAL) :test #'equal) (return-from expand-member `(ffi:c-inline (,value ,list) (:object :object) :object "ecl_member(#0,#1)" :one-liner t :side-effects nil))))) (ext:with-unique-names (%value %sublist %elt) `(let ((,%value ,value) ,@init) (do-in-list (,%elt ,%sublist ,list) (when ,(funcall test-function %value (funcall key-function %elt)) (return ,%sublist))))))) (define-compiler-macro member (&whole whole value list &rest sequence-args) (if (policy-inline-sequence-functions) (or (apply #'expand-member (rest whole)) whole) whole)) ;;; ;;; ASSOC ;;; (defun expand-assoc (value list &rest sequence-args) (multiple-value-bind (key-function test-function init key-flag test-flag test) (seq-opt-parse-args 'assoc sequence-args :start-end nil) (unless key-flag (when (or (null test-flag) (eq test-flag :test)) (when (member test '('EQ #'EQ) :test #'equal) (return-from expand-assoc `(ffi:c-inline (,value ,list) (:object :object) :object "ecl_assq(#0,#1)" :one-liner t :side-effects nil))) (when (member test '('EQL #'EQL) :test #'equal) (return-from expand-assoc `(ffi:c-inline (,value ,list) (:object :object) :object "ecl_assql(#0,#1)" :one-liner t :side-effects nil))) (when (member test '('EQUAL #'EQUAL) :test #'equal) (return-from expand-assoc `(ffi:c-inline (,value ,list) (:object :object) :object "ecl_assoc(#0,#1)" :one-liner t :side-effects nil))) (when (member test '('EQUALP #'EQUALP) :test #'equal) (return-from expand-assoc `(ffi:c-inline (,value ,list) (:object :object) :object "ecl_assqlp(#0,#1)" :one-liner t :side-effects nil))))) (when test-function (ext:with-unique-names (%value %sublist %elt %car) `(let ((,%value ,value) ,@init) (do-in-list (,%elt ,%sublist ,list) (when ,%elt (let ((,%car (cons-car (optional-type-check ,%elt cons)))) (when ,(funcall test-function %value (funcall key-function %car)) (return ,%elt)))))))))) (define-compiler-macro assoc (&whole whole value list &rest sequence-args) (if (policy-inline-sequence-functions) (or (apply #'expand-assoc (rest whole)) whole) whole)) ;;; ;;; FIND ;;; (defun expand-find (value sequence &rest sequence-args) (multiple-value-bind (key-function test-function init key-flag test-flag test start end) (seq-opt-parse-args 'find sequence-args) (when test-function (ext:with-unique-names (%value %elt) `(let ((,%value ,value) ,@init) (do-in-seq (,%elt ,sequence :start ,start :end ,end) (when ,(funcall test-function %value (funcall key-function %elt)) (return ,%elt)))))))) (define-compiler-macro find (&whole whole value sequence &rest sequence-args) (if (policy-inline-sequence-functions) (or (apply #'expand-find (rest whole)) whole) whole)) ecl-16.1.2/src/cmp/cmpopt-type.lsp000066400000000000000000000031701266352375300167300ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: C -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; Copyright (c) 2008. Juan Jose Garcia-Ripol ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. ;;;; ;;;; CMPOPT-TYPE -- Optimizations for selected types of expresions ;;;; (in-package "COMPILER") (define-compiler-macro dotimes ((variable limit &rest output) &body body) (multiple-value-bind (declarations body) (si:process-declarations body nil) (ext:with-unique-names (%limit) `(block nil (let ((,%limit ,limit)) (declare (:read-only ,%limit)) (ext:compiler-typecase ,%limit (fixnum ;; %LIMIT will be type checked by the compiler to be ;; a fixnum. We may thus just increase the counter. (let ((,variable 0)) (declare (fixnum ,variable) ,@declarations) (si::while (< ,variable ,%limit) ,@body (reckless (setq ,variable (1+ ,variable)))) ,@output)) (t (let ((,variable 0)) (declare ,@declarations) (si::while (< ,variable ,%limit) ,@body (setq ,variable (1+ ,variable))) ,@output)))))))) ecl-16.1.2/src/cmp/cmpopt.lsp000066400000000000000000000317301266352375300157540ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: C -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; CMPOPT. Optimization of library functions ;;;; Copyright (c) 2008. Juan Jose Garcia-Ripol ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. (in-package "COMPILER") ;;; ;;; TYPEP ;;; ;;; Some of the type checks can be expanded inline if we know the name ;;; of the type and it corresponds to either a Common-Lisp base type ;;; or to some class. ;;; (defun expand-in-interval-p (var interval) (declare (si::c-local)) (let ((forms '())) (destructuring-bind (&optional (lower-limit '*) (upper-limit '*)) interval (unless (eq lower-limit '*) (push (if (consp lower-limit) `(> ,var ,(first lower-limit)) `(>= ,var ,lower-limit)) forms)) (unless (eq upper-limit '*) (push (if (consp upper-limit) `(< ,var ,(first upper-limit)) `(<= ,var ,upper-limit)) forms))) forms)) (defun expand-typep (form object type env) ;; This function is reponsible for expanding (TYPEP object type) ;; forms into a reasonable set of system calls. When it fails to ;; match the compiler constraints on speed and space, it simply ;; returns the original form. Note that for successful recursion we ;; have to output indeed the ORIGINAL FORM, not some intermediate ;; step. Otherwise the compiler macro will enter an infinite loop. (let* ((orig-type type) aux function first rest function) ;; Type must be constant to optimize (if (constantp type env) (setf type (ext:constant-form-value type env)) (return-from expand-typep form)) (cond ;; Variable declared with a given type ((and (symbolp object) (setf aux (cmp-env-search-var object env)) (subtypep (var-type aux) type)) t) ;; Simple ones ((subtypep 'T type) T) ((eq type 'NIL) NIL) ;; ;; Detect inconsistencies in the provided type. If we run at low ;; safety, we will simply assume the user knows what she's doing. ((subtypep type NIL) (cmpwarn "TYPEP form contains an empty type ~S and cannot be optimized" type) form) ;; ;; There exists a function which checks for this type? ((setf function (get-sysprop type 'si::type-predicate)) `(,function ,object)) ;; ;; Similar as before, but we assume the user did not give us ;; the right name, or gave us an equivalent type. ((loop for (a-type . function-name) in si::+known-typep-predicates+ when (si::type= type a-type) do (return `(,function-name ,object)))) ;; ;; Complex types defined with DEFTYPE. ((and (atom type) (setq function (get-sysprop type 'SI::DEFTYPE-DEFINITION))) (expand-typep form object `',(funcall function nil) env)) ;; ;; No optimizations that take up too much space unless requested. ((not (policy-inline-type-checks)) form) ;; ;; CONS types. They must be checked _before_ sequence types. We ;; do not produce optimized forms because they can be recursive. ((and (consp type) (eq first 'CONS)) form) ;; ;; The type denotes a known class and we can check it #+clos ((and (symbolp type) (setf aux (find-class type nil))) `(si::of-class-p ,object ',type)) ;; ;; There are no other atomic types to optimize ((atom type) form) ;; ;; (TYPEP o '(NOT t)) => (NOT (TYPEP o 't)) ((progn (setf rest (rest type) first (first type)) (eq first 'NOT)) `(not (typep ,object ',(first rest)))) ;; ;; (TYPEP o '(AND t1 t2 ...)) => (AND (TYPEP o 't1) (TYPEP o 't2) ...) ;; (TYPEP o '(OR t1 t2 ...)) => (OR (TYPEP o 't1) (TYPEP o 't2) ...) ((member first '(OR AND)) (let ((var (gensym))) `(let ((,var ,object)) (declare (:read-only ,var)) (,first ,@(loop for type in rest collect `(typep ,var ',type)))))) ;; ;; (TYPEP o '(MEMBER a1 a2 ...)) => (MEMBER o '(a1 a2 ...)) ((eq first 'MEMBER) `(MEMBER ,object ',rest)) ;; ;; (INTEGER * *), etc ((member first '(INTEGER RATIONAL FLOAT REAL SINGLE-FLOAT DOUBLE-FLOAT #+long-float LONG-FLOAT)) (let ((var1 (gensym)) (var2 (gensym))) ;; Small optimization: it is easier to check for fixnum ;; than for integer. Use it when possible. (when (and (eq first 'integer) (subtypep type 'fixnum)) (setf first 'fixnum)) `(LET ((,var1 ,object) (,var2 ,(coerce 0 first))) (declare (:read-only ,var1) (type ,first ,var2)) (AND (TYPEP ,var1 ',first) (locally (declare (optimize (speed 3) (safety 0) (space 0))) (setf ,var2 (truly-the ,first ,var1)) (AND ,@(expand-in-interval-p var2 rest))))))) ;; ;; (SATISFIES predicate) ((and (eq first 'SATISFIES) (= (list-length type) 2) (symbolp (setf function (second type)))) `(,function ,object)) ;; ;; Complex types with arguments. ((setf function (get-sysprop first 'SI::DEFTYPE-DEFINITION)) (expand-typep form object `',(funcall function rest) env)) (t form)))) (define-compiler-macro typep (&whole form object type &optional e &environment env) (expand-typep form object type env)) ;;; ;;; DOLIST ;;; ;;; We overwrite the original macros introducing type declarations and ;;; other possible type checks. ;;; (define-compiler-macro dolist ((var expression &optional output-form) &body body &environment env) (multiple-value-bind (declarations body) (si:process-declarations body nil) (let* ((list-var (gensym)) (typed-var (if (policy-assume-no-errors env) list-var `(truly-the cons ,list-var)))) `(block nil (let* ((,list-var ,expression)) (si::while ,list-var (let ((,var (first ,typed-var))) (declare ,@declarations) (tagbody ,@body)) (setq ,list-var (rest ,typed-var))) ,(when output-form `(let ((,var nil)) (declare ,@declarations) ,output-form))))))) ;;; ;;; COERCE ;;; ;;; Simple coercion rules are implemented using the following ;;; templates. X is replaced by the coerced value, which can be a ;;; lisp form. We use a LET form to avoid evaluating twice the same ;;; form. ;;; (defparameter +coercion-table+ '((integer . (let ((y x)) (check-type y integer) y)) (float . (float x)) (short-float . (float x 0.0s0)) (single-float . (float x 0.0f0)) (double-float . (float x 0.0d0)) (long-float . (float x 0.0l0)) (base-char . (character x)) (character . (character x)) (function . (si::coerce-to-function x)) )) (defun expand-coerce (form value type env) (declare (si::c-local)) ;; This function is reponsible for expanding (TYPEP object type) ;; forms into a reasonable set of system calls. When it fails to ;; match the compiler constraints on speed and space, it simply ;; returns the original form. Note that for successful recursion we ;; have to output indeed the ORIGINAL FORM, not some intermediate ;; step. Otherwise the compiler macro will enter an infinite loop. (let* ((orig-type type) first rest) ;; Type must be constant to optimize (if (constantp type env) (setf type (ext:constant-form-value type env)) (return-from expand-coerce form)) (cond ;; Trivial case ((subtypep 't type) value) ;; ;; Detect inconsistencies in the type form. ((subtypep type 'nil) (cmperror "Cannot COERCE an expression to an empty type.")) ;; ;; No optimizations that take up too much space unless requested. ((not (policy-inline-type-checks)) form) ;; ;; Search for a simple template above, replacing X by the value. ((loop for (a-type . template) in +coercion-table+ when (eq type a-type) do (return (subst value 'x template)))) ;; ;; FIXME! COMPLEX cannot be in +coercion-table+ because ;; (type= '(complex) '(complex double-float)) == T ;; ((eq type 'COMPLEX) `(let ((y ,value)) (declare (:read-only y)) (complex (realpart y) (imagpart y)))) ;; ;; Complex types defined with DEFTYPE. ((and (atom type) (setq first (get-sysprop type 'SI::DEFTYPE-DEFINITION))) (expand-coerce form value `',(funcall first nil) env)) ;; ;; CONS types are not coercible. ((and (consp type) (eq (first type) 'CONS)) form) ;; ;; Search for a simple template above, but now assuming the user ;; provided a more complex form of the same value. ((loop for (a-type . template) in +coercion-table+ when (si::type= type a-type) do (return (subst value 'x template)))) ;; ;; SEQUENCE types ((subtypep type 'sequence) (multiple-value-bind (elt-type length) (si::closest-sequence-type type) (if (eq elt-type 'list) `(si::coerce-to-list ,value) `(si::coerce-to-vector ,value ',elt-type ',length ,(and (subtypep type 'simple-array) t))))) ;; ;; There are no other atomic types to optimize ((atom type) form) ;; ;; (TYPEP o '(AND t1 t2 ...)) => (AND (TYPEP o 't1) (TYPEP o 't2) ...) ((progn (setf rest (rest type) first (first type)) (eq first 'AND)) `(let ((x ,value)) ,@(loop for i in rest collect `(setf x (coerce x ',i))) x)) ;; ;; (COMPLEX whatever) types ((and (eq first 'complex) (= (length rest) 1)) `(let ((y ,value)) (declare (:read-only y)) (complex (coerce (realpart y) ',(first rest)) (coerce (imagpart y) ',(first rest))))) ;; ;; (INTEGER * *), etc We have to signal an error if the type ;; does not match. However, if safety settings are low, we ;; skip the interval test. ((member first '(INTEGER RATIONAL FLOAT REAL SINGLE-FLOAT DOUBLE-FLOAT #+long-float LONG-FLOAT)) (let ((unchecked (expand-coerce form value `',first env))) (if (policy-assume-no-errors) unchecked `(let ((x ,unchecked)) (declare (,first x)) (unless (and ,@(expand-in-interval-p 'x (rest type))) (si::do-check-type x ',type nil "coerced value")) x)))) ;; ;; We did not find a suitable expansion. (t form) ))) (define-compiler-macro coerce (&whole form value type &environment env) (expand-coerce form value type env)) (define-compiler-macro float (&whole form value &optional float &environment env) (or (and float (policy-inline-type-checks env) (multiple-value-bind (constant-p float) (constant-value-p float env) (when (and constant-p (floatp float)) (let* ((aux (gentemp)) (float (type-of float)) (c-type (lisp-type->rep-type float))) `(let ((value ,value)) (declare (:read-only value)) (compiler-typecase value (,float value) (t (ffi:c-inline (value) (:object) ,c-type ,(ecase c-type (:double "ecl_to_double(#0)") (:float "ecl_to_float(#0)") (:long-double "ecl_to_long_double(#0)")) :one-liner t :side-effects nil)))))))) form)) ecl-16.1.2/src/cmp/cmpos-features.lsp000066400000000000000000000135271266352375300174130ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: C -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; Copyright (c) 2010, Juan Jose Garcia-Ripoll ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. ;;;; CMPFEATURES.LSP -- Gather a list of features from the compiler (in-package "COMPILER") (defun run-and-collect (command args &optional file) (flet ((collect-lines (stream) (loop for line = (read-line stream nil nil) while line collect line))) (handler-case (multiple-value-bind (stream process) (ext:run-program command args :input nil :output :stream :error :output) (let ((lines (collect-lines stream))) (cond ((null file) lines) ((probe-file file) (with-open-file (s file :direction :input) (collect-lines s))) (t (warn "Unable to find file ~A" file))))) (error (c) (format t "~&;;; Unable to execute program ~S~&;;; Condition~&;;; ~A" command c))))) (defun split-words (string) (loop with output = '() with word = '() for i from 0 below (length string) for c = (elt string i) do (if (member c '(#\Space #\Tab #\Newline)) (when word (push (make-array (length word) :element-type 'base-char :initial-contents (nreverse word)) output) (setf word nil)) (push c word)) finally (return output))) (defconstant +known-keywords+ '("sparc*" "x86*" "*-bit" "32*" "64*" "*32" "*64" "elf" "coff" "mach-o" "universal" "gcc" "icc")) (defun known-keyword (string &optional (patterns +known-keywords+)) (loop with base = (make-pathname :directory nil :name (string-upcase string)) for p in patterns for pattern-path = (make-pathname :directory nil :name (string-upcase p)) thereis (pathname-match-p base pattern-path))) (defun gather-keywords (strings patterns) (let ((strings (reduce #'append (mapcar #'split-words strings)))) (mapcar (lambda (s) (intern (string-upcase s) (find-package :keyword))) (remove-if-not #'known-keyword strings)))) (defun compiler-defines (macros) "Test for existence of a set of C preprocessor macros for the compiler flags we are currently using with ECL." (let* ((f (ext:mkstemp "tmp:foo")) (fc (make-pathname :type "c" :defaults f)) (fs (make-pathname :type "i" :defaults f))) (with-open-file (s fc :direction :output :if-exists :overwrite :if-does-not-exist :create) (loop for i from 0 for (macro . rest) in macros do (format s "~%#ifdef ~A~%ECLVALUE ~4,'0D ~A~%#endif" macro i macro))) (loop with list = (mapcar #'list (mapcar #'first macros)) with lines = (run-and-collect c::*cc* (append (c::split-program-options c::*cc-flags*) (list "-E" (namestring fc) "-o" (namestring fs))) fs) for l in lines when (eql (search "ECLVALUE" l) 0) do (let* ((number (parse-integer (subseq l 9 13))) (defines (subseq l 14))) (setf (elt list number) (elt macros number))) finally (progn ;;(and (probe-file f) (delete-file f)) ;;(and (probe-file fc) (delete-file fc)) ;;(and (probe-file fs) (delete-file fs)) (return list))))) (defconstant +compiler-macros+ '(;; Compiler names ("__INTEL_COMPILER" :intel-compiler) ("__GNUC__" :gcc-compiler) ("__SUNPRO_CC" :sun-c++-compiler) ("__SUNPRO_C" :sun-c-compiler) ("__xlc__" :ibm-c-compiler) ("__xlC__" :ibm-c++-compiler) ;; Processor features ("__MMX__" :mmx) ("__SSE__" :sse) ("__SSE2__" :sse2) ("__ELF__" :elf) ("__i386" :i386) ("__i386__" :i386) ("__amd64" :amd64) ("__x86_64__" :x86-64) ("__X86_64__" :x86-64) ("__LP64__" :lp64) ("_LP64" :lp64) ("__ILP32__" :ilp32) ("_ILP32" :ilp32) ("__powerpc" :powerpc) ("__PPC" :ppc) ("__PPC__" :ppc) ("__PPC64__" :ppc64) ("_PPC64_" :ppc64) )) (defun run-and-collect-keywords (&rest args) (gather-keywords (apply #'run-and-collect args) +known-keywords+)) (defun gather-system-features (&key (executable #+(or windows cygwin) "sys:ecl_min.exe" #-(or windows cygwin) "sys:ecl_min")) (let* ((ecl-binary (namestring (truename executable))) (executable-features #-windows (run-and-collect-keywords "file" (list ecl-binary))) (compiler-version (run-and-collect-keywords c::*cc* '("--version"))) (compiler-features (reduce #'append (mapcar #'rest (compiler-defines +compiler-macros+))))) (delete-duplicates (nconc executable-features compiler-version compiler-features) :test #'string-equal))) (defun update-compiler-features (&rest args) (setf *compiler-features* (apply #'gather-system-features args))) #+ecl-min (update-compiler-features :executable #+(or windows cygwin) "build:ecl_min.exe" #-(or windows cygwin) "build:ecl_min") #+ecl-min (format t ";;; System features: ~A~%" *compiler-features*) ecl-16.1.2/src/cmp/cmpos-run.lsp000077500000000000000000000104511266352375300163750ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: C -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; Copyright (c) 2010, Juan Jose Garcia Ripoll ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. ;;;; CMPOS-RUN Executing auxiliary programs (in-package "COMPILER") #+(and cygwin (not ecl-min)) (ffi:clines "#include ") (defun safe-system (string) (cmpnote "Invoking external command:~% ~A~%" string) (let ((result (ext:system string))) (unless (zerop result) (cerror "Continues anyway." "(SYSTEM ~S) returned non-zero value ~D" string result)) result)) (defun save-directory (forms) (let ((directory (probe-file (make-pathname :name nil :type nil :defaults *default-pathname-defaults*)))) (if directory (let ((*default-pathname-defaults* directory) (old-directory (ext:chdir directory))) (unwind-protect (funcall forms) (ext:chdir old-directory))) (funcall forms)))) (defmacro with-current-directory (&body forms) `(save-directory #'(lambda () ,@forms))) #+(and cygwin (not ecl-min)) (defun old-crappy-system (program args) (let* ((command (format nil "~S~{ ~S~}" program args)) (base-string-command (si:copy-to-simple-base-string command)) (code (ffi:c-inline (base-string-command) (:object) :int "system((const char*)(#0->base_string.self))":one-liner t))) (values nil code nil))) (defun safe-run-program (program args) (cmpnote "Invoking external command:~% ~A ~{~A ~}" program args) (multiple-value-bind (stream result process) (let* ((*standard-output* ext:+process-standard-output+) (*error-output* ext:+process-error-output+)) (with-current-directory #-(and cygwin (not ecl-min)) (ext:run-program program args :input nil :output t :error t :wait t) #+(and cygwin (not ecl-min)) (old-crappy-system program args) )) (cond ((null result) (cerror "Continues anyway." "Unable to execute:~%(RUN-PROGRAM ~S ~S)" program args result)) ((not (zerop result)) (cerror "Continues anyway." "Error code ~D when executing~%(RUN-PROGRAM ~S ~S)" result program args))) result)) (defun split-program-options (string) (labels ((maybe-push (options current) (if current (cons current options) options)) (new-string () (make-array 32 :element-type 'base-char :adjustable t :fill-pointer 0)) (push-char (c s) (unless s (setf s (new-string))) (vector-push-extend c s) s)) (loop with output = '() with option = nil with status = nil for i from 0 below (length string) for c = (char string i) for now = (first status) do (cond ((eq now #\') (if (eq c #\') (setf status (rest status)) (setf option (push-char c option)))) ((eq now #\\) (setf option (push-char c option) status (rest status))) ((eq now #\") (if (eq c #\") (setf status (rest status)) (setf option (push-char c option)))) ((member c '(#\\ #\' #\")) (push c status)) ((member c '(#\Space #\Tab #\Return #\Newline)) (setf output (maybe-push output option) option nil)) (t (setf option (push-char c option)))) finally (cond (status (error "In split-program-options, unterminated option list:~%~S" string)) (t (return (nreverse (maybe-push output option)))))))) ecl-16.1.2/src/cmp/cmppackage.lsp000066400000000000000000000036771266352375300165560ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: C -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; Copyright (c) 2009, Juan Jose Garcia-Ripoll ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. ;;;; ;;;; CMPPACKAGE -- Package definitions and exported symbols ;;;; (ext:package-lock "CL" nil) (defpackage "C" (:nicknames "COMPILER") (:use "FFI" "EXT" #+threads "MP" "CL") (:export "*COMPILER-BREAK-ENABLE*" "*COMPILE-PRINT*" "*COMPILE-TO-LINKING-CALL*" "*COMPILE-VERBOSE*" "*COMPILER-FEATURES*" "*CC*" "*CC-OPTIMIZE*" "*USER-CC-FLAGS*" "*USER-LD-FLAGS*" "*SUPPRESS-COMPILER-NOTES*" "*SUPPRESS-COMPILER-WARNINGS*" "*SUPPRESS-COMPILER-MESSAGES*" "BUILD-ECL" "BUILD-PROGRAM" "BUILD-FASL" "BUILD-STATIC-LIBRARY" "BUILD-SHARED-LIBRARY" "COMPILER-WARNING" "COMPILER-NOTE" "COMPILER-MESSAGE" "COMPILER-ERROR" "COMPILER-FATAL-ERROR" "COMPILER-INTERNAL-ERROR" "COMPILER-UNDEFINED-VARIABLE" "COMPILER-MESSAGE-FILE" "COMPILER-MESSAGE-FILE-POSITION" "COMPILER-MESSAGE-FORM" "*SUPPRESS-COMPILER-WARNINGS*" "*SUPPRESS-COMPILER-NOTES*" "*SUPPRESS-COMPILER-MESSAGES*" "INSTALL-C-COMPILER" "UPDATE-COMPILER-FEATURES") (:import-from "SI" "GET-SYSPROP" "PUT-SYSPROP" "REM-SYSPROP" "MACRO" "*COMPILER-CONSTANTS*" "REGISTER-GLOBAL" "CMP-ENV-REGISTER-MACROLET" "COMPILER-LET")) ecl-16.1.2/src/cmp/cmppolicy.lsp000066400000000000000000000302261266352375300164500ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: C -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; Copyright (c) 2010, Juan Jose Garcia-Ripoll ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. ;;;; ;;;; CMPPOLICY -- Code generation choices ;;;; (in-package #-new-cmp "COMPILER" #+new-cmp "C-ENV") (eval-when (:compile-toplevel :execute) (defconstant +optimization-quality-orders+ '(debug safety speed space))) (eval-when (:compile-toplevel :execute) (defparameter *optimization-quality-switches* (loop with hash = (make-hash-table :size 64 :test #'eq) for name in +optimization-quality-orders+ for i from 0 by 4 for list = (loop with mask = (ash #b1111 i) for level from 0 to 3 for bits = (ash 1 (+ level i)) collect (cons bits (logxor bits mask))) do (setf (gethash name hash) list) finally (return hash))) (setf (gethash 'compilation-speed *optimization-quality-switches*) '#1=((0 . 0) . #1#))) #.`(eval-when (:compile-toplevel :execute :load-toplevel) ,@(loop for name in +optimization-quality-orders+ for i from 0 by 4 for fun-name = (intern (concatenate 'string "POLICY-TO-" (symbol-name name) "-LEVEL")) collect `(defun ,fun-name (policy) (declare (declaration ext:assume-right-type)) (loop for level from 0 to 3 when (logbitp (+ level ,i) policy) return level)))) (defun optimization-quality-switches (type index) (nth index (gethash type *optimization-quality-switches*))) (defun compute-policy (arguments old-bits) (let* ((bits old-bits) (on 0) (off 0)) (dolist (x arguments) (let (flags name value) (cond ((symbolp x) (setq flags (optimization-quality-switches x 3) value 3 name x)) ((or (not (consp x)) (not (consp (cdr x))) (not (numberp (second x))) (not (<= 0 (second x) 3)))) (t (setf name (first x) value (second x) flags (optimization-quality-switches name (second x))))) (if (null flags) (cmpwarn "Illegal or unknown OPTIMIZE proclamation ~s" x) (setf on (logior on (car flags)) off (logior off (cdr flags)))))) ;;(format t "~%*~64b" bits) ;;(format t "~% ~64b" on) ;;(format t "~% ~64b" off) (logandc2 (logior bits on) off))) (defun default-policy () (compute-policy `((space ,*space*) (safety ,*safety*) (debug ,*debug*) (speed ,*speed*)) 0)) (defun cmp-env-policy (env) (or (first (cmp-env-search-declaration 'optimization env)) (default-policy))) (defun cmp-env-add-optimizations (decl &optional (env *cmp-env*)) (let* ((old (cmp-env-policy env)) (new (compute-policy decl old))) (cmp-env-add-declaration 'optimization (list new) env))) (defun policy-declaration-name-p (name) (and (gethash name *optimization-quality-switches*) t)) (defun maybe-add-policy (decl &optional (env *cmp-env*)) (when (and (consp decl) (<= (list-length decl) 2) (gethash (first decl) *optimization-quality-switches*)) (let* ((old (cmp-env-policy env)) (flag (if (or (endp (rest decl)) (second decl)) 3 0)) (new (compute-policy (list (list (first decl) flag)) old))) (cmp-env-add-declaration 'optimization (list new) env)))) (defun add-default-optimizations (env) (if (cmp-env-search-declaration 'optimization env) env (cmp-env-add-declaration 'optimization (list (default-policy)) env))) (defun cmp-env-all-optimizations (&optional (env *cmp-env*)) (let ((o (cmp-env-policy env))) (list (policy-to-debug-level o) (policy-to-safety-level o) (policy-to-space-level o) (policy-to-speed-level o)))) (defun cmp-env-optimization (property &optional (env *cmp-env*)) (let ((o (cmp-env-policy env))) (case property (debug (policy-to-debug-level o)) (safety (policy-to-safety-level o)) (space (policy-to-space-level o)) (speed (policy-to-speed-level o))))) (eval-when (:compile-toplevel :execute) (defparameter +last-optimization-bit+ 17) (defun augment-policy (quality level on-off flag) #+(or) (if (eq on-off :on) (loop for i from 0 to 3 for bits = (optimization-quality-switches quality i) if (>= i level) do (rplaca bits (logior (car bits) flag)) else do (rplacd bits (logior (cdr bits) flag))) (loop for i from 0 to 3 for bits = (optimization-quality-switches quality i) when (>= i level) do (rplacd bits (logior (cdr bits) flag)))) #+(or) (loop for i from level to 3 for bits = (optimization-quality-switches quality i) if (eq on-off :on) do (rplaca bits (logior (car bits) flag)) else do (rplacd bits (logior (cdr bits) flag))) (loop for i from 0 to 3 for bits = (optimization-quality-switches quality i) if (< i level) do (case on-off (:on (rplacd bits (logior (cdr bits) flag))) (:off (rplaca bits (logior (car bits) flag)))) else do (case on-off ((:only-on :on) (rplaca bits (logior (car bits) flag))) ((:only-off :off) (rplacd bits (logior (cdr bits) flag))))) ) (defun policy-declaration-name (base) (intern (symbol-name base) (find-package "EXT"))) (defun policy-function-name (base) (intern (concatenate 'string "POLICY-" (symbol-name base)) (find-package "C"))) (defmacro define-policy (&whole whole name &rest conditions) (unintern name) (import name (find-package "EXT")) (export name (find-package "EXT")) (let* ((test (ash 1 +last-optimization-bit+)) (declaration-name (policy-declaration-name name)) (function-name (policy-function-name name)) (doc (find-if #'stringp conditions)) (emit-function t)) ;; If it is an alias, just copy the bits ;; Register as an optimization quality with its own flags (let* ((circular-list (list (cons test 0))) (flags-list (list* (cons 0 test) circular-list))) (rplacd circular-list circular-list) (setf (gethash declaration-name *optimization-quality-switches*) flags-list)) ;; Scan the definition and correct the flags (loop with extra = '() with slow = '() with conditions = (remove doc conditions) for case = (pop conditions) while case do (case case (:no-function (setf emit-function nil)) (:alias (let* ((alias (first conditions))) (setf (gethash declaration-name *optimization-quality-switches*) (gethash (policy-declaration-name alias) *optimization-quality-switches*)) (return `(defun ,function-name (&optional (env *cmp-env*)) ,@(and doc (list doc)) (,(policy-function-name alias) env))))) (:anti-alias (let* ((alias (first conditions)) (bits (gethash (policy-declaration-name alias) *optimization-quality-switches*))) (setf bits (list (second bits) (first bits))) (rplacd (cdr bits) (cdr bits)) (setf (gethash declaration-name *optimization-quality-switches*) bits) (return `(defun ,function-name (&optional (env *cmp-env*)) ,@(and doc (list doc)) (not (,(policy-function-name alias) env)))))) ((:only-on :on) (push `(>= (cmp-env-optimization ',(first conditions) env) ,(second conditions)) slow) (augment-policy (pop conditions) (pop conditions) case test)) ((:only-off :off) (push `(< (cmp-env-optimization ',(first conditions) env) ,(second conditions)) slow) (augment-policy (pop conditions) (pop conditions) case test)) (:requires (push (pop conditions) extra)) (otherwise (error "Syntax error in macro~% ~A" `(define-policy ,@whole)))) finally (progn (incf +last-optimization-bit+) (return (and emit-function `(defun ,function-name (&optional (env *cmp-env*)) ,@(and doc (list doc)) (let ((bits (cmp-env-policy env))) (and (logtest bits ,test) ,@extra)))))))))) (eval-when (:compile-toplevel :load-toplevel :execute) ;; ;; ERROR CHECKING POLICY ;; (define-policy assume-no-errors :off safety 1) (define-policy assume-right-type :alias assume-no-errors) (define-policy type-assertions :anti-alias assume-no-errors "Generate type assertions when inlining accessors and other functions.") (define-policy check-stack-overflow :on safety 2 "Add a stack check to every function") (define-policy check-arguments-type :on safety 1 "Generate CHECK-TYPE forms for function arguments with type declarations") (define-policy array-bounds-check :on safety 1 "Check out of bounds access to arrays") (define-policy global-var-checking :on safety 3 "Read the value of a global variable even if it is discarded, ensuring it is bound") (define-policy global-function-checking :on safety 3 "Read the binding of a global function even if it is discarded") (define-policy check-nargs :on safety 1 :only-on check-arguments-type 1 "Check that the number of arguments a function receives is within bounds") (define-policy the-is-checked :on safety 1 "THE is equivalent to EXT:CHECKED-VALUE. Otherwise THE is equivalent to EXT:TRULY-THE.") ;; ;; INLINING POLICY ;; (define-policy assume-types-dont-change :off safety 1 "Assume that type and class definitions will not change") (define-policy inline-slot-access :on speed 1 :off debug 2 :off safety 2 "Inline access to structures and sealed classes") (define-policy inline-accessors :off debug 2 :off space 2 "Inline access to object slots, including conses and arrays") (define-policy inline-bit-operations :off space 2 "Inline LDB and similar functions") (define-policy open-code-aref/aset :alias inline-accessors "Inline access to arrays") (define-policy evaluate-forms :off debug 1 "Pre-evaluate a function that takes constant arguments") (define-policy use-direct-C-call :off debug 2 "Emit direct calls to a function whose C name is known") (define-policy inline-type-checks :off space 2 "Expand TYPEP and similar forms in terms of simpler functions, such as FLOATP, INTGERP, STRINGP.") (define-policy inline-sequence-functions :off space 2 "Inline functions such as MAP, MEMBER, FIND, etc") ;; ;; DEBUG POLICY ;; (define-policy debug-variable-bindings :on debug 3 :requires (policy-debug-ihs-frame env) ;; We can only create variable bindings when the function has an IHS frame!!! "Create a debug vector with the bindings of each LET/LET*/LAMBDA form?") (define-policy debug-ihs-frame :on debug 3 "Let the functions appear in backtraces") ); eval-when (defun safe-compile () (>= (cmp-env-optimization 'safety) 2)) (defun compiler-push-events () (>= (cmp-env-optimization 'safety) 3)) (eval-when (:load-toplevel) (defparameter *optimization-quality-switches* #.*optimization-quality-switches*)) ecl-16.1.2/src/cmp/cmpprop.lsp000066400000000000000000000367221266352375300161400ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: C -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; Copyright (c) 2010, Juan Jose Garcia-Ripoll ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. ;;;; CMPPROP Type propagation. (in-package "COMPILER") ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; ;;; TYPE PROPAGATION LOOP ;;; (eval-when (:execute :compile-toplevel) (defparameter *type-propagation-messages* nil) (defmacro prop-message (string &rest args) (when *type-propagation-messages* `(format *standard-output* ,string ,@args)))) (defun p1propagate (form assumptions) (unless form (return-from p1propagate (values 'null assumptions))) (when (c1form-p form) (let* ((*cmp-env* (c1form-env form)) (*compile-file-pathname* (c1form-file form)) (*compile-file-position* (c1form-file-position form)) (*current-form* (c1form-form form)) (*current-toplevel-form* (c1form-toplevel-form form)) (name (c1form-name form)) (propagator (gethash name *p1-dispatch-table*))) (when propagator (prop-message "~&;;; Entering type propagation for ~A" name) (multiple-value-bind (new-type assumptions) (apply propagator form assumptions (c1form-args form)) (when assumptions (baboon :format-control "Non-empty assumptions found in P1PROPAGATE")) (prop-message "~&;;; Propagating ~A gives type ~A" name new-type) (return-from p1propagate (values (setf (c1form-type form) (values-type-and (c1form-type form) new-type)) assumptions)))))) (cmpnote "Refusing to propagate ~A" form) (values (c1form-type form) assumptions)) (defun p1trivial (form assumptions &rest rest) (declare (ignore rest)) (values (c1form-type form) assumptions)) (defun p1var (form assumptions var) (let* ((record (and (assoc var assumptions) (baboon :format-control "Non empty assumptions found in P1VAR"))) ;; Use the type of C1FORM because it might have been ;; coerced by a THE form. (var-type (if record (cdr record) (var-type var))) (type (type-and var-type (c1form-primary-type form)))) (prop-message "~&;;; Querying variable ~A gives ~A" (var-name var) type) (values type assumptions))) (defun p1values (form assumptions values) (loop for v in values collect (multiple-value-bind (type new-assumptions) (p1propagate v assumptions) (setf assumptions new-assumptions) (values-type-primary-type type)) into all-values finally (return (values `(values ,@all-values) assumptions)))) (defun p1propagate-list (list assumptions) (loop with final-type = t for f in list do (multiple-value-setq (final-type assumptions) (p1propagate f assumptions)) finally (return (values final-type assumptions)))) (defun p1merge-branches (root chains) "ROOT is a list of assumptions, while CHAINS is list of extended versions of ROOT. This function takes all those extensions and makes a final list in which type assumptions have been merged, giving the variables the OR type of each of the occurrences in those lists." (unless (and (null root) (every #'null chains)) (baboon :format-control "P1MERGE-BRANCHES got a non-empty list of assumptions"))) (defun revise-var-type (variable assumptions where-to-stop) (unless (and (null assumptions) (null where-to-stop)) (baboon :format-control "REVISE-VAR-TYPE got a non-empty list of assumptions"))) (defun p1block (c1form assumptions blk body) (setf (blk-type blk) nil) (multiple-value-bind (normal-type assumptions) (p1propagate body assumptions) (let ((blk-type (blk-type blk))) (values (if blk-type (values-type-or blk-type normal-type) normal-type) assumptions)))) (defun p1return-from (c1form assumptions blk return-type value variable-or-nil) (let* ((values-type (p1propagate value assumptions)) (blk-type (blk-type blk))) (setf (blk-type blk) (if blk-type (values-type-or blk-type values-type) values-type)) (values values-type assumptions))) (defun p1call-global (c1form assumptions fname args) (loop for v in args do (multiple-value-bind (arg-type local-ass) (p1propagate v assumptions) (setf assumptions local-ass)) finally (let ((type (propagate-types fname args))) (prop-message "~&;;; Computing output of function ~A with args~&;;; ~{ ~A~}~&;;; gives ~A, while before ~A" fname (mapcar #'c1form-primary-type args) type (c1form-type c1form)) (return (values type assumptions))))) (defun p1call-local (c1form assumptions fun args) (loop for v in args do (multiple-value-bind (arg-type local-ass) (p1propagate v assumptions) (setf assumptions local-ass)) finally (return (values (fun-return-type fun) assumptions)))) (defun p1catch (c1form assumptions tag body) (multiple-value-bind (tag-type assumptions) (p1propagate tag assumptions) (p1propagate body assumptions)) (values t assumptions)) (defun p1throw (c1form assumptions catch-value output-value) (multiple-value-bind (type new-assumptions) (p1propagate catch-value assumptions) (p1propagate output-value new-assumptions)) (values t assumptions)) (defun p1if (c1form assumptions fmla true-branch false-branch) (multiple-value-bind (fmla-type base-assumptions) (p1propagate fmla assumptions) (multiple-value-bind (t1 a1) (p1propagate true-branch base-assumptions) (multiple-value-bind (t2 a2) (p1propagate false-branch base-assumptions) (values (values-type-or t1 t2) (p1merge-branches base-assumptions (list a1 a2))))))) (defun p1fmla-not (c1form assumptions form) (multiple-value-bind (type assumptions) (p1propagate form assumptions) (values '(member t nil) assumptions))) (defun p1fmla-and (c1form orig-assumptions butlast last) (loop with type = t with assumptions = orig-assumptions for form in (append butlast (list last)) collect (progn (multiple-value-setq (type assumptions) (p1propagate form assumptions)) assumptions) into assumptions-list finally (return (values (type-or 'null (values-type-primary-type type)) (p1merge-branches orig-assumptions assumptions-list))))) (defun p1fmla-or (c1form orig-assumptions butlast last) (loop with type with output-type = t with assumptions = orig-assumptions for form in (append butlast (list last)) collect (progn (multiple-value-setq (type assumptions) (p1propagate form assumptions)) (setf output-type (type-or (values-type-primary-type type) output-type)) assumptions) into assumptions-list finally (return (values output-type (p1merge-branches orig-assumptions assumptions-list))))) (defun p1lambda (c1form assumptions lambda-list doc body &rest not-used) (prop-message "~&;;;~&;;; Propagating function~&;;;") (let ((type (p1propagate body assumptions))) (values type assumptions))) (defun p1propagate-function (fun assumptions) (multiple-value-bind (output-type assumptions) (p1propagate (fun-lambda fun) assumptions) (values (setf (fun-return-type fun) output-type) assumptions))) (defun p1let* (c1form base-assumptions vars forms body) (let ((assumptions base-assumptions)) (loop with type for v in vars for f in forms unless (or (global-var-p v) (var-set-nodes v)) do (progn (multiple-value-setq (type assumptions) (p1propagate f assumptions)) (setf (var-type v) (type-and (values-type-primary-type type) (var-type v))) (prop-message "~&;;; Variable ~A assigned type ~A" (var-name v) (var-type v)))) (multiple-value-bind (type assumptions) (p1propagate body assumptions) (loop for v in vars do (revise-var-type v assumptions base-assumptions)) (values type assumptions)))) (defun p1locals (c1form assumptions funs body labels) (loop for f in funs do (p1propagate-function f assumptions)) (p1propagate body assumptions)) (defun p1multiple-value-bind (c1form assumptions vars-list init-c1form body) (multiple-value-bind (init-form-type assumptions) (p1propagate init-c1form assumptions) (loop for v in vars-list for type in (values-type-to-n-types init-form-type (length vars-list)) unless (or (global-var-p v) (var-set-nodes v)) do (setf (var-type v) (type-and (var-type v) type)) and do (prop-message "~&;;; Variable ~A assigned type ~A" (var-name v) (var-type v))) (p1propagate body assumptions))) (defun p1multiple-value-setq (c1form assumptions vars-list value-c1form) (multiple-value-bind (init-form-type assumptions) (p1propagate value-c1form assumptions) (values init-form-type assumptions))) (defun p1progn (c1form assumptions forms) (p1propagate-list forms assumptions)) (defun p1compiler-typecase (c1form assumptions variable expressions) (let ((var-type (var-type variable))) (loop with output-type = t for (a-type c1form) in expressions for c1form-type = (p1propagate c1form assumptions) when (or (member a-type '(t otherwise)) (subtypep var-type a-type)) do (setf output-type c1form-type) finally (return (values output-type assumptions))))) (defun p1checked-value (c1form assumptions type value let-form) (let* ((value-type (p1propagate value assumptions)) (alt-type (p1propagate let-form assumptions))) (if (subtypep value-type type) value-type type))) (defun p1progv (c1form assumptions variables values body) (let (type) (multiple-value-setq (type assumptions) (p1propagate variables assumptions)) (multiple-value-setq (type assumptions) (p1propagate values assumptions)) (p1propagate body assumptions))) (defun p1setq (c1form assumptions var value-c1form) (declare (ignore c1form)) (multiple-value-bind (value-type assumptions) (p1propagate value-c1form assumptions) (values (type-and (var-type var) (values-type-primary-type value-type)) assumptions))) (defun p1psetq (c1form assumptions vars c1forms) (loop for form in c1forms do (multiple-value-bind (new-type assumptions) (p1propagate form assumptions))) (values 'null assumptions)) (defun p1with-stack (c1form assumptions body) (p1propagate body assumptions)) (defun p1stack-push-values (c1form assumptions form inline) (multiple-value-bind (form-type assumptions) (p1propagate form assumptions) (values nil assumptions))) (defvar *tagbody-depth* -1 "If n > 0, limit the number of passes to converge tagbody forms. If -1, let the compiler do as many passes as it wishes. Complexity grows as 2^*tagbody-limit* in the worst cases.") (defun p1go (c1form assumptions tag-var return-type) (values t assumptions)) (defun filter-only-declarations (assumptions) (when assumptions (baboon :format-control "FILTER-ONLY-DECLARATIONS gets a non-empty assumption list")) nil) (defun p1tagbody (c1form orig-assumptions tag-loc body) (prop-message "~&;;; P1TAGBODY-SIMPLE pass") (let* ((assumptions (filter-only-declarations orig-assumptions)) (ass-list (p1tagbody-one-pass c1form assumptions tag-loc body))) (values 'null (append (p1merge-branches nil ass-list) orig-assumptions)))) (defun p1tagbody-one-pass (c1form assumptions tag-loc body) (declare (ignore tag-loc)) (loop with local-ass = assumptions with ass-list = '() with aux for f in body do (if (tag-p f) (let ((diff (ldiff local-ass assumptions))) (when diff (push diff ass-list)) (prop-message "~&;;; Label ~A found" (tag-name f)) (setf local-ass assumptions)) (multiple-value-setq (aux local-ass) (p1propagate f local-ass))) finally (return (let ((diff (ldiff local-ass assumptions))) (if diff (cons diff ass-list) ass-list))))) (defun p1unwind-protect (c1form assumptions form body) (declare (ignore c1form)) (multiple-value-bind (output-type assumptions) (p1propagate form assumptions) (p1propagate body assumptions) (values output-type assumptions))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (defun type-from-array-elt (array &aux name) "Input is a lisp type representing a valid subtype of ARRAY. Output is either the array element type or NIL, denoting that we are not able to compute it. This version only handles the simplest cases." (values (cond ((eq array 'string) 'character) ((eq array 'base-string) 'base-char) ((member (setf array (si::expand-deftype array)) '(array vector simple-array)) t) ((atom array) (setf array 'array) t) ((eq (setf name (first array)) 'OR) `(OR ,@(mapcar #'type-from-array-elt (rest array)))) ((eq (setf name (first array)) 'AND) `(AND ,@(mapcar #'type-from-array-elt (rest array)))) ((not (member (first array) '(array vector simple-array))) (setf array 'array) t) ((null (rest array)) t) (t (let ((x (second array))) (if (eq x '*) t x)))) array)) (def-type-propagator si::aset (fname array-type &rest indices-and-object) (multiple-value-bind (elt-type array-type) (type-from-array-elt array-type) (values (cons array-type (nconc (make-list (1- (length indices-and-object)) :initial-element 'si::index) (list elt-type))) elt-type))) (def-type-propagator aref (fname array-type &rest indices) (multiple-value-bind (elt-type array-type) (type-from-array-elt array-type) (values (list* array-type (make-list (length indices) :initial-element 'si::index)) elt-type))) (def-type-propagator si::row-major-aset (fname array-type index obj) (multiple-value-bind (elt-type array-type) (type-from-array-elt array-type) (values (list array-type 'si::index elt-type) elt-type))) (def-type-propagator row-major-aref (fname array-type index) (multiple-value-bind (elt-type array-type) (type-from-array-elt array-type) (values (list array-type 'si::index) elt-type))) ecl-16.1.2/src/cmp/cmpspecial.lsp000066400000000000000000000166121266352375300165740ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: C -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; CMPSPECIAL Miscellaneous special forms. ;;;; Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. ;;;; Copyright (c) 1990, Giuseppe Attardi. ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. (in-package "COMPILER") (defun c1quote (args) (check-args-number 'QUOTE args 1 1) (c1constant-value (car args) :always t)) (defun c1declare (args) (cmperr "The declaration ~s was found in a bad place." (cons 'DECLARE args))) (defun c1the (args) (check-args-number 'THE args 2 2) ;; FIXME: C1CHECKED-VALUE cannot check multiple values. (let ((type (first args))) (if (and (policy-the-is-checked) (not (and (consp type) (eq (first type) 'values)))) (c1checked-value args) (c1truly-the args)))) (defun c1truly-the (args) (check-args-number 'TRULY-THE args 2 2) (let* ((form (c1expr (second args))) (the-type (first args)) type) (setf type (values-type-and the-type (c1form-type form))) (if (values-type-primary-type type) (setf (c1form-type form) type) (cmpwarn "Type mismatch was found in ~s." (cons 'THE args))) form)) (defun c1compiler-let (args &aux (symbols nil) (values nil)) (when (endp args) (too-few-args 'COMPILER-LET 1 0)) (dolist (spec (car args)) (cond ((consp spec) (cmpck (not (and (symbolp (car spec)) (or (endp (cdr spec)) (endp (cddr spec))))) "The variable binding ~s is illegal." spec) (push (car spec) symbols) (push (if (endp (cdr spec)) nil (eval (second spec))) values)) ((symbolp spec) (push spec symbols) (push nil values)) (t (cmperr "The variable binding ~s is illegal." spec)))) (setq symbols (nreverse symbols)) (setq values (nreverse values)) (setq args (progv symbols values (c1progn (cdr args)))) (make-c1form 'COMPILER-LET args symbols values args)) (defun c2compiler-let (c1form symbols values body) (declare (ignore c1form)) (progv symbols values (c2expr body))) (defun c1function (args &aux fd) (check-args-number 'FUNCTION args 1 1) (let ((fun (car args))) (cond ((si::valid-function-name-p fun) (let ((funob (local-function-ref fun t))) (if funob (let* ((var (fun-var funob))) (add-to-read-nodes var (make-c1form* 'VAR :args var))) (make-c1form* 'FUNCTION :type 'FUNCTION :sp-change (not (and (symbolp fun) (get-sysprop fun 'NO-SP-CHANGE))) :args 'GLOBAL nil fun)))) ((and (consp fun) (member (car fun) '(LAMBDA EXT::LAMBDA-BLOCK))) (cmpck (endp (cdr fun)) "The lambda expression ~s is illegal." fun) (let (name body) (if (eq (first fun) 'EXT::LAMBDA) (setf name (gensym) body (rest fun)) (setf name (second fun) body (cddr fun))) (c1expr `(flet ((,name ,@body)) #',name)))) (t (cmperr "The function ~s is illegal." fun))))) (defun c2function (c1form kind funob fun) (declare (ignore c1form)) (case kind (GLOBAL (unwind-exit (list 'FDEFINITION fun))) (CLOSURE (baboon) (new-local fun) (unwind-exit `(MAKE-CCLOSURE ,fun))))) ;;; Mechanism for sharing code. (defun new-local (fun) ;; returns the previous function or NIL. (declare (type fun fun)) (case (fun-closure fun) (CLOSURE (setf (fun-level fun) 0 (fun-env fun) *env*)) (LEXICAL (let ((parent (fun-parent fun))) ;; Only increase the lexical level if there have been some ;; new variables created. This way, the same lexical environment ;; can be propagated through nested FLET/LABELS. (setf (fun-level fun) (if (plusp *lex*) (1+ *level*) *level*) (fun-env fun) 0))) (otherwise (setf (fun-env fun) 0 (fun-level fun) 0))) (let ((previous nil #+(or) (dolist (old *local-funs*) (when (similar fun old) (return old))))) (if previous (progn (if (eq (fun-closure fun) 'CLOSURE) (cmpnote "Sharing code for closure") (cmpnote "Sharing code for local function ~A" (fun-name fun))) (setf (fun-cfun fun) (fun-cfun previous) (fun-lambda fun) nil) previous) (push fun *local-funs*)))) (defun wt-fdefinition (fun-name) (let* ((name (si::function-block-name fun-name)) (package (symbol-package name)) (safe (or (not (safe-compile)) (and (or (eq package (find-package "CL")) (eq package (find-package "CLOS")) (eq package (find-package "SI"))) (fboundp fun-name) (functionp (fdefinition fun-name)))))) (if (eq name fun-name) ;; #'symbol (let ((vv (add-symbol name))) (if safe (wt "(" vv "->symbol.gfdef)") (wt "ecl_fdefinition(" vv ")"))) ;; #'(SETF symbol) (if safe #+(or) (let ((set-loc (assoc name *setf-definitions*))) (unless set-loc (let* ((setf-vv (data-empty-loc)) (name-vv (add-symbol name)) (setf-form-vv (add-object fun-name))) (setf set-loc (list name setf-vv name-vv setf-form-vv)) (push set-loc *setf-definitions*))) (wt "ECL_SETF_DEFINITION(" (second set-loc) "," (fourth set-loc) ")")) (let ((set-loc (assoc name *setf-definitions*))) (unless set-loc (let* ((setf-vv (data-empty-loc)) (name-vv (add-symbol name))) (setf set-loc (list name setf-vv name-vv)) (push set-loc *setf-definitions*))) (wt "ECL_CONS_CAR(" (second set-loc) ")")) (let ((vv (add-symbol fun-name))) (wt "ecl_fdefinition(" vv ")")))))) (defun environment-accessor (fun) (let* ((env-var (env-var-name *env-lvl*)) (expected-env-size (fun-env fun))) (if (< expected-env-size *env*) (format nil "ecl_nthcdr(~D,~A)" (- *env* expected-env-size) env-var) env-var))) (defun wt-make-closure (fun &aux (cfun (fun-cfun fun))) (declare (type fun fun)) (let* ((closure (fun-closure fun)) narg) (cond ((eq closure 'CLOSURE) (wt "ecl_make_cclosure_va((cl_objectfn)" cfun "," (environment-accessor fun) ",Cblock)")) ((eq closure 'LEXICAL) (baboon)) ((setf narg (fun-fixed-narg fun)) ; empty environment fixed number of args (wt "ecl_make_cfun((cl_objectfn_fixed)" cfun ",ECL_NIL,Cblock," narg ")")) (t ; empty environment variable number of args (wt "ecl_make_cfun_va((cl_objectfn)" cfun ",ECL_NIL,Cblock)"))))) ecl-16.1.2/src/cmp/cmpstack.lsp000066400000000000000000000060501266352375300162540ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: C -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; Copyright (c) 2006, Juan Jose Garcia-Ripoll ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. ;;;; CMPSTACK Manipulation of the lisp stack from C code ;;;; ;;;; Following special forms are provided: ;;;; ;;;; (WITH-STACK {form}*) ;;;; Executes given forms, restoring the lisp stack on output. ;;;; (STACK-PUSH form) ;;;; (STACK-PUSH-VALUES form) ;;;; (STACK-POP nvalues) ;;;; (in-package "COMPILER") (defconstant +ecl-stack-frame-variable+ "_ecl_inner_frame") (defconstant +ecl-local-stack-frame-variable+ "__frame") (defconstant +ecl-local-stack-variable+ "__frame_sp") (defun c1with-stack (forms) (let* ((var (pop forms)) (body (c1expr `(let ((,var (innermost-stack-frame))) ,@forms)))) (make-c1form* 'WITH-STACK :type (c1form-type body) :args body))) (defun c2with-stack (c1form body) (declare (ignore c1form)) (let* ((new-destination (tmp-destination *destination*)) (*temp* *temp*)) (wt-nl-open-brace) (wt-nl "struct ecl_stack_frame _ecl_inner_frame_aux;") (wt-nl *volatile* "cl_object _ecl_inner_frame = ecl_stack_frame_open(cl_env_copy,(cl_object)&_ecl_inner_frame_aux,0);") (let* ((*destination* new-destination) (*unwind-exit* `((STACK ,+ecl-stack-frame-variable+) ,@*unwind-exit*))) (c2expr* body)) (wt-nl "ecl_stack_frame_close(_ecl_inner_frame);") (wt-nl-close-brace) (unwind-exit new-destination))) (defun c1innermost-stack-frame (args) `(c-inline () () :object ,+ecl-stack-frame-variable+ :one-liner t :side-effects nil)) (defun c1stack-push (args) `(progn (c-inline ,args (t t) :void "ecl_stack_frame_push(#0,#1)" :one-liner t :side-effects t) 1)) (defun c1stack-push-values (args) (let ((frame-var (pop args)) (form (pop args))) (make-c1form* 'STACK-PUSH-VALUES :type '(VALUES) :args (c1expr form) (c1expr `(c-inline (,frame-var) (t) :void "ecl_stack_frame_push_values(#0)" :one-liner t :side-effects t))))) (defun c2stack-push-values (c1form form push-statement) (declare (ignore c1form)) (let ((*destination* 'VALUES)) (c2expr* form)) (c2expr push-statement)) (defun c1stack-pop (args) `(c-inline ,args (t) (values &rest t) "cl_env_copy->values[0]=ecl_stack_frame_pop_values(#0);" :one-liner nil :side-effects t)) (defun c1apply-from-stack-frame (args) `(c-inline ,args (t t) (values &rest t) "cl_env_copy->values[0]=ecl_apply_from_stack_frame(#0,#1);" :one-liner nil :side-effects t)) ecl-16.1.2/src/cmp/cmpstructures.lsp000066400000000000000000000113411266352375300173710ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: C -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; CMPSTRUCT. STRUCTURE related optimizations. ;;;; Copyright (c) 2008. Juan Jose Garcia-Ripol ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. (in-package "COMPILER") ;;; ;;; GET-SLOT-TYPE ;;; ;;; Given a structure type and a slot index, infer the type of the output. ;;; (defun get-slot-type (name index) ;; default is t (or (third (nth index (get-sysprop name 'SYS::STRUCTURE-SLOT-DESCRIPTIONS))) 'T)) ;;; ;;; STRUCTURE SLOT READING ;;; ;;; By looking at the name of a function we may infer whether it is a ;;; reader for a structure slot. If this is the case and the policy ;;; allows us, we will inline the slot access and infer the type of ;;; the output. ;;; (defun maybe-optimize-structure-access (fname args) (let* ((slot-description (get-sysprop fname 'SYS::STRUCTURE-ACCESS))) (when (and slot-description (inline-possible fname) (policy-inline-slot-access-p)) ;(format t "~%;;; Optimizing structure accessor ~A" fname) (let (structure-type slot-index) (unless (and (consp slot-description) (setf structure-type (car slot-description) slot-index (cdr slot-description)) (typep slot-index 'fixnum)) (cmpwarn "Unable to inline access to structure slot ~A because index is corrupt: ~A" fname slot-index) (return-from maybe-optimize-structure-access nil)) (unless (= (length args) 1) (cmpwarn "Too many arguments for structure slot accessor ~A" fname) (return-from maybe-optimize-structure-access nil)) (setf args (first args)) (cond ((eq structure-type 'list) `(elt ,args ,slot-index)) ((eq structure-type 'vector) `(svref ,args ,slot-index)) ((consp structure-type) `(aref (the ,structure-type ,args) ,slot-index)) (t `(,args ',structure-type ,slot-index))))))) (define-compiler-macro si::structure-ref (&whole whole object structure-name index &environment env) (if (and (policy-inline-slot-access env) (constantp structure-name env) (constantp index env)) (let* ((index (ext:constant-form-value index env)) (aux (gensym)) (form `(ffi:c-inline (,aux ,index) (:object :fixnum) :object "(#0)->instance.slots[#1]" :one-liner t))) (unless (policy-assume-no-errors env) (setf form (let ((structure-name (ext:constant-form-value structure-name env))) `(ext:compiler-typecase ,aux (,structure-name ,form) (t (ffi:c-inline (,aux ,structure-name ,index) (:object :object :fixnum) :object "ecl_structure_ref(#0,#1,#2)" :one-liner t)))))) `(let ((,aux ,object)) (declare (:read-only ,aux)) ,form)) whole)) (define-compiler-macro si::structure-set (&whole whole object structure-name index value &environment env) (if (and (policy-inline-slot-access env) (constantp structure-name env) (constantp index env)) (let* ((index (ext:constant-form-value index env)) (aux (gensym)) (form `(ffi:c-inline (,aux ,index ,value) (:object :fixnum :object) :object "(#0)->instance.slots[#1]=#2" :one-liner t))) (unless (policy-assume-no-errors env) (let ((structure-name (ext:constant-form-value structure-name env))) (setf form `(ext:compiler-typecase ,aux (,structure-name ,form) (t (ffi:c-inline (,aux ',structure-name ,index ,value) (:object :object :fixnum :object) :object "ecl_structure_set(#0,#1,#2,#3)" :one-liner t)))))) `(let ((,aux ,object)) (declare (:read-only ,aux)) ,form)) whole)) ecl-16.1.2/src/cmp/cmptables.lsp000066400000000000000000000260221266352375300164220ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: C -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; Copyright (c) 2010, Juan Jose Garcia-Ripoll ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. ;;;; CMPPROP Type propagation. (in-package "COMPILER") (eval-when (:compile-toplevel :execute) (defconstant +all-c1-forms+ '((LOCATION loc :pure :single-valued) (VAR var :single-valued) (SETQ var value-c1form :side-effects) (PSETQ var-list value-c1form-list :side-effects) (BLOCK blk-var progn-c1form :pure) (PROGN body :pure) (PROGV symbols values form :side-effects) (TAGBODY tag-var tag-body :pure) (RETURN-FROM blk-var return-type value variable-or-nil :side-effects) (FUNCALL fun-value (arg-value*) :side-effects) (CALL-LOCAL obj-fun (arg-value*) :side-effects) (CALL-GLOBAL fun-name (arg-value*)) (CATCH catch-value body :side-effects) (UNWIND-PROTECT protected-c1form body :side-effects) (THROW catch-value output-value :side-effects) (GO tag-var return-type :side-effects) (C-INLINE (arg-c1form*) (arg-type-symbol*) output-rep-type c-expression-string side-effects-p one-liner-p) (C-PROGN variables forms) (LOCALS local-fun-list body labels-p :pure) (IF fmla-c1form true-c1form false-c1form :pure) (FMLA-NOT fmla-c1form :pure) (FMLA-AND * :pure) (FMLA-OR * :pure) (LAMBDA lambda-list doc body-c1form) (LET* vars-list var-init-c1form-list decl-body-c1form :pure) (VALUES values-c1form-list :pure) (MULTIPLE-VALUE-SETQ vars-list values-c1form-list :side-effects) (MULTIPLE-VALUE-BIND vars-list init-c1form body :pure) (COMPILER-LET symbols values body) (FUNCTION (GLOBAL/CLOSURE) lambda-form fun-object :single-valued) (RPLACD (dest-c1form value-c1form) :side-effects) (SI:STRUCTURE-REF struct-c1form type-name slot-index (:UNSAFE/NIL) :pure) (SI:STRUCTURE-SET struct-c1form type-name slot-index value-c1form :side-effects) (WITH-STACK body :side-effects) (STACK-PUSH-VALUES value-c1form push-statement-c1form :side-effects) (ORDINARY c1form :pure) (LOAD-TIME-VALUE dest-loc value-c1form :pure :single-valued) (SI:FSET function-object vv-loc macro-p pprint-p lambda-form :side-effects) (MAKE-FORM vv-loc value-c1form :side-effects) (INIT-FORM vv-loc value-c1form :side-effects) (EXT:COMPILER-TYPECASE var expressions) (CHECKED-VALUE type value-c1form let-form)))) (defconstant +c1-form-hash+ #.(loop with hash = (make-hash-table :size 128 :test #'eq) for (name . rest) in +all-c1-forms+ for length = (if (member '* rest) nil (length rest)) for side-effects = (if (member :side-effects rest) (progn (and length (decf length)) t) nil) for movable = (if (member :pure rest) (progn (and length (decf length)) t) nil) for single-valued = (if (member :single-valued rest) (progn (and length (decf length)) t) nil) do (setf (gethash name hash) (list length side-effects movable single-valued)) finally (return hash))) (defconstant +c1-dispatch-alist+ '((block . c1block) ; c1special (return-from . c1return-from) ; c1special (funcall . c1funcall) ; c1 (catch . c1catch) ; c1special (unwind-protect . c1unwind-protect) ; c1special (throw . c1throw) ; c1special (ffi:defcallback . c1-defcallback) ; c1 (progn . c1progn) ; c1special (ext:with-backend . c1with-backend) ; c1special (ffi:clines . c1clines) ; c1special (ffi:c-inline . c1c-inline) ; c1special (ffi:c-progn . c1c-progn) ; c1special (flet . c1flet) ; c1special (labels . c1labels) ; c1special (locally . c1locally) ; c1special (macrolet . c1macrolet) ; c1special (symbol-macrolet . c1symbol-macrolet) ; c1special (if . c1if) ; c1special (not . c1not) ; c1special (and . c1and) ; c1special (or . c1or) ; c1special (let . c1let) ; c1special (let* . c1let*) ; c1special (multiple-value-call . c1multiple-value-call) ; c1special (multiple-value-prog1 . c1multiple-value-prog1) ; c1special (values . c1values) ; c1 (multiple-value-setq . c1multiple-value-setq) ; c1 (multiple-value-bind . c1multiple-value-bind) ; c1 (ext:compiler-typecase . c1compiler-typecase) ; c1special (checked-value . c1checked-value) ; c1special (quote . c1quote) ; c1special (function . c1function) ; c1special (the . c1the) ; c1special (ext:truly-the . c1truly-the) ; c1special (eval-when . c1eval-when) ; c1special (declare . c1declare) ; c1special (ext:compiler-let . c1compiler-let) ; c1special (with-stack . c1with-stack) ; c1 (innermost-stack-frame . c1innermost-stack-frame) ; c1 (stack-push . c1stack-push) ; c1 (stack-push-values . c1stack-push-values) ; c1 (stack-pop . c1stack-pop) ; c1 (si::apply-from-stack-frame . c1apply-from-stack-frame) ; c1 (tagbody . c1tagbody) ; c1special (go . c1go) ; c1special (setq . c1setq) ; c1special (progv . c1progv) ; c1special (psetq . c1psetq) ; c1special (load-time-value . c1load-time-value) ; c1 (apply . c1apply) ; c1 )) (defconstant +t1-dispatch-alist+ '((ext:with-backend . c1with-backend) ; t1 (defmacro . t1defmacro) (compiler-let . c1compiler-let) (eval-when . c1eval-when) (progn . c1progn) (macrolet . c1macrolet) (locally . c1locally) (symbol-macrolet . c1symbol-macrolet) (si:fset . t1fset) )) (defconstant +set-loc-dispatch-alist+ '((bind . bind) (jump-true . set-jump-true) (jump-false . set-jump-false) (values . set-values-loc) (value0 . set-value0-loc) (return . set-return-loc) (trash . set-trash-loc) (the . set-the-loc) )) (defconstant +wt-loc-dispatch-alist+ '((call-normal . wt-call-normal) (call-indirect . wt-call-indirect) (ffi:c-inline . wt-c-inline-loc) (coerce-loc . wt-coerce-loc) (temp . wt-temp) (lcl . wt-lcl-loc) (fixnum-value . wt-number) (long-float-value . wt-number) (double-float-value . wt-number) (single-float-value . wt-number) (short-float-value . wt-number) (character-value . wt-character) (value . wt-value) (keyvars . wt-keyvars) (the . wt-the) (fdefinition . wt-fdefinition) (make-cclosure . wt-make-closure) (structure-ref . wt-structure-ref) (nil . "ECL_NIL") (t . "ECL_T") (return . "value0") (values . "cl_env_copy->values[0]") (va-arg . "va_arg(args,cl_object)") (cl-va-arg . "ecl_va_arg(args)") (value0 . "value0") )) (defconstant +c2-dispatch-alist+ '((block . c2block) ; c2 (return-from . c2return-from) ; c2 (funcall . c2funcall) ; c2 (call-global . c2call-global) ; c2 (catch . c2catch) ; c2 (unwind-protect . c2unwind-protect) ; c2 (throw . c2throw) ; c2 (progn . c2progn) ; c2 (ffi:c-inline . c2c-inline) ; c2 (ffi:c-progn . c2c-progn) ; c2 (locals . c2locals) ; c2 (call-local . c2call-local) ; c2 (if . c2if) (fmla-not . c2fmla-not) (fmla-and . c2fmla-and) (fmla-or . c2fmla-or) (let* . c2let*) (values . c2values) ; c2 (multiple-value-setq . c2multiple-value-setq) ; c2 (multiple-value-bind . c2multiple-value-bind) ; c2 (function . c2function) ; c2 (ext:compiler-let . c2compiler-let) ; c2 (with-stack . c2with-stack) ; c2 (stack-push-values . c2stack-push-values) ; c2 (tagbody . c2tagbody) ; c2 (go . c2go) ; c2 (var . c2var/location) ; c2 (location . c2var/location) ; c2 (setq . c2setq) ; c2 (progv . c2progv) ; c2 (psetq . c2psetq) ; c2 (si:fset . c2fset) (ext:compiler-typecase . c2compiler-typecase) (checked-value . c2checked-value) )) (defconstant +t2-dispatch-alist+ '((compiler-let . t2compiler-let) (progn . t2progn) (ordinary . t2ordinary) (load-time-value . t2load-time-value) (make-form . t2make-form) (init-form . t2init-form) (si:fset . t2fset) )) (defconstant +p1-dispatch-alist+ '((block . p1block) (return-from . p1return-from) (call-global . p1call-global) (call-local . p1call-local) (catch . p1catch) (throw . p1throw) (if . p1if) (fmla-not . p1fmla-not) (fmla-and . p1fmla-and) (fmla-or . p1fmla-or) (lambda . p1lambda) (let* . p1let*) (locals . p1locals) (multiple-value-bind . p1multiple-value-bind) (multiple-value-setq . p1multiple-value-setq) (progn . p1progn) (progv . p1progv) (setq . p1setq) (psetq . p1psetq) (tagbody . p1tagbody) (go . p1go) (unwind-protect . p1unwind-protect) (ordinary . p1ordinary) (sys::fset . p1fset) (var . p1var) (values . p1values) (location . p1trivial) ;; Some of these can be improved (ffi:c-inline . p1trivial) (ffi:c-progn . p1trivial) (function . p1trivial) (funcall . p1trivial) (load-time-value . p1trivial) (make-form . p1trivial) (init-form . p1trivial) (c::with-stack . p1with-stack) (c::stack-push-values . p1stack-push-values) (ext:compiler-typecase . p1compiler-typecase) (checked-value . p1checked-value) )) (defun make-dispatch-table (alist) (loop with hash = (make-hash-table :size (max 128 (* 2 (length alist))) :test #'eq) for (name . function) in alist do (setf (gethash name hash) function) finally (return hash))) (defparameter *c1-dispatch-table* (make-dispatch-table +c1-dispatch-alist+)) (defparameter *t1-dispatch-table* (make-dispatch-table +t1-dispatch-alist+)) (defparameter *c2-dispatch-table* (make-dispatch-table +c2-dispatch-alist+)) (defparameter *set-loc-dispatch-table* (make-dispatch-table +set-loc-dispatch-alist+)) (defparameter *wt-loc-dispatch-table* (make-dispatch-table +wt-loc-dispatch-alist+)) (defparameter *t2-dispatch-table* (make-dispatch-table +t2-dispatch-alist+)) (defparameter *p1-dispatch-table* (make-dispatch-table +p1-dispatch-alist+) "Dispatch table for type propagators associated to C1FORMs.") (defparameter *p0-dispatch-table* (make-dispatch-table '()) "Type propagators for known functions.") (defparameter *cinline-dispatch-table* (make-dispatch-table '())) ecl-16.1.2/src/cmp/cmptag.lsp000066400000000000000000000210661266352375300157260ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: C -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; CMPTAG -- Tagbody and Go. ;;;; Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. ;;;; Copyright (c) 1990, Giuseppe Attardi. ;;;; ;;;; ECoLisp is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. (in-package "COMPILER") ;;; A dummy variable is created to hold the tag identifier and one tag ;;; structure (containing reference to such variable) is created for each ;;; label in the body. ;;; When a reference to a tag (go instruction) is found, the ;;; var-kind is stepped from NIL to OBJECT (if appearing inside an ;;; unwind-protect) to LEXICAL or CLOSURE (if appearing across a boundary). ;;; The tag-ref is also incremented. ;;; Therefore var-ref represents whether some tag is used at all and var-kind ;;; variable represents whether a tag identifier must be created and the ;;; kind of the dummy variable to store it. (defvar *reg-amount* 60) ;;; amount to increase var-ref for each variable reference inside a loop (defun add-loop-registers (tagbody) ;; Find a maximal iteration interval in TAGBODY from first to end ;; then increment the var-ref slot. (labels ((add-reg1 (form) ;; increase the var-ref in FORM for all vars (cond ((c1form-p form) (dolist (v (c1form-args form)) (add-reg1 v))) ((consp form) (dolist (v form) (add-reg1 v))) ((var-p form) (setf (var-ref form) most-positive-fixnum)))) (jumps-to-p (clause tag-name) ;; Does CLAUSE have a go TAG-NAME in it? (cond ((c1form-p clause) (and (eq (c1form-name clause) 'GO) (eq (tag-name (c1form-arg 0 clause)) tag-name))) ((atom clause) nil) (t (or (jumps-to-p (car clause) tag-name) (jumps-to-p (cdr clause) tag-name)))))) (do ((v tagbody (cdr v)) (end nil) (first nil)) ((null v) (do ((ww first (cdr ww))) ((eq ww end) (add-reg1 (car ww))) (add-reg1 (car ww)))) (when (tag-p (car v)) (unless first (setq first v)) (do ((w (cdr v) (cdr w)) (name (tag-name (car v)))) ((null w)) (when (jumps-to-p (car w) name) (setq end w))))))) ;; FIXME! The variable name should not be a usable one! (defun c1tagbody (orig-body &aux (*cmp-env* (cmp-env-copy)) (tag-var (make-var :name 'TAGBODY :kind NIL)) (tag-index 0) (body nil)) ;;; Establish tags. (setq body (loop for x in orig-body collect (if (consp x) x (let ((tag (make-tag :name x :var tag-var :index tag-index))) (cmp-env-register-tag (tag-name tag) tag) (incf tag-index) tag)))) ;; Split forms according to the tag they are preceded by and compile ;; them grouped by PROGN. This help us use the optimizations in ;; C1PROGN to recognize transfers of control. (loop for form in body with output = '() with tag-body = nil with this-tag = (make-var :name 'tagbody-beginnnig :kind nil) do (cond ((tag-p form) (when tag-body (setf output (cons (c1progn (nreconc tag-body '(nil))) output) tag-body nil)) (push form output)) (t (push form tag-body))) finally (setf body (if tag-body (cons (c1progn (nreconc tag-body '(nil))) output) output))) ;;; Reverse the body list, deleting unused tags. (loop for form in body with output = '() when (or (not (tag-p form)) (plusp (tag-ref form))) do (push form output) finally (setf body output)) ;;; Ensure that the end is not just a tag, but at least a NIL body. (when (null body) (return-from c1tagbody (c1progn nil))) (when (tag-p (first (last body))) (setf body (nconc body (list (c1expr nil))))) ;;; Only produce a tagbody if it was needed. (when (zerop (var-ref tag-var)) (return-from c1tagbody (make-c1form* 'PROGN :args (delete-if #'tag-p body)))) (when (var-ref-ccb tag-var) (incf *setjmps*)) (add-loop-registers body) (make-c1form* 'TAGBODY :local-vars (list tag-var) :args tag-var body)) (defun c2tagbody (c1form tag-loc body) (declare (type var tag-loc) (ignore c1form)) (if (null (var-kind tag-loc)) ;; only local goto's (dolist (x body (c2tagbody-body body)) ;; Allocate labels. (when (and (tag-p x) (plusp (tag-ref x))) (setf (tag-label x) (next-label*)) (setf (tag-unwind-exit x) *unwind-exit*))) ;; some tag used non locally or inside an unwind-protect (let ((*unwind-exit* (cons 'FRAME *unwind-exit*)) (*env* *env*) (*env-lvl* *env-lvl*) (*lex* *lex*) (*lcl* *lcl*) (*inline-blocks* 0) (env-grows (env-grows (var-ref-ccb tag-loc)))) (when env-grows (let ((env-lvl *env-lvl*)) (maybe-open-inline-block) (wt-nl "volatile cl_object env" (incf *env-lvl*) " = env" env-lvl ";"))) (when (eq :OBJECT (var-kind tag-loc)) (setf (var-loc tag-loc) (next-lcl)) (maybe-open-inline-block) (wt-nl "cl_object " tag-loc ";") (setq env-grows t)) ; just to ensure closing the block (bind "ECL_NEW_FRAME_ID(cl_env_copy)" tag-loc) (wt-nl "if (ecl_frs_push(cl_env_copy," tag-loc ")) {") ;; Allocate labels. (dolist (tag body) (when (and (tag-p tag) (plusp (tag-ref tag))) (setf (tag-label tag) (next-label)) (setf (tag-unwind-exit tag) *unwind-exit*) (wt-nl "if (cl_env_copy->values[0]==ecl_make_fixnum(" (tag-index tag) "))") (wt-go (tag-label tag)))) (when (var-ref-ccb tag-loc) (wt-nl "ecl_internal_error(\"GO found an inexistent tag\");")) (wt-nl "}") (c2tagbody-body body) (close-inline-blocks)))) (defun c2tagbody-body (body) ;;; INV: BODY is a list of tags and forms. We have processed the body ;;; so that the last element is always a form producing NIL. (do ((l body (cdr l))) ((null l)) (let* ((this-form (first l))) (cond ((tag-p this-form) (wt-label (tag-label this-form))) ((endp (rest l)) ;; Last form, it is never a label! (c2expr this-form)) (t (let* ((next-form (second l)) (*exit* (if (tag-p next-form) (tag-label next-form) (next-label))) (*unwind-exit* (cons *exit* *unwind-exit*)) (*destination* 'TRASH)) (c2expr this-form) (unless (tag-p next-form) (wt-label *exit*)))))))) (defun c1go (args) (check-args-number 'GO args 1 1) (let ((name (first args))) (unless (or (symbolp name) (integerp name)) (cmperr "The tag name ~s is not a symbol nor an integer." name)) (multiple-value-bind (tag ccb clb unw) (cmp-env-search-tag name) (unless tag (cmperr "Undefined tag ~A" name)) (let ((var (tag-var tag))) (cond (ccb (setf (tag-ref-ccb tag) t (var-ref-ccb var) T (var-kind var) 'CLOSURE)) (clb (setf (tag-ref-clb tag) t (var-ref-clb var) t (var-kind var) 'LEXICAL)) (unw (unless (var-kind var) (setf (var-kind var) :OBJECT)))) (incf (tag-ref tag)) (add-to-read-nodes var (make-c1form* 'GO :args tag (or ccb clb unw))))))) (defun c2go (c1form tag nonlocal) (declare (ignore c1form)) (if nonlocal (let ((var (tag-var tag))) (wt-nl "cl_go(" var ",ecl_make_fixnum(" (tag-index tag) "));")) ;; local go (progn (unwind-no-exit-until (tag-unwind-exit tag)) (wt-nl) (wt-go (tag-label tag))))) ecl-16.1.2/src/cmp/cmptop.lsp000066400000000000000000001047471266352375300157650ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: C -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; CMPTOP -- Compiler top-level. ;;;; Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. ;;;; Copyright (c) 1990, Giuseppe Attardi. ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. (in-package "COMPILER") (defun t1expr (form) (let* ((*current-toplevel-form* nil) (*cmp-env* (if *cmp-env* (cmp-env-copy *cmp-env*) (cmp-env-root)))) (push (t1expr* form) *top-level-forms*))) (defvar *toplevel-forms-to-print* '(defun defmacro defvar defparameter defclass defmethod defgeneric)) (defun t1expr* (form &aux (*current-toplevel-form* (list* form *current-toplevel-form*)) (*current-form* form) (*first-error* t) (*setjmps* 0)) (when (consp form) (let ((fun (car form)) (args (cdr form)) fd) (when (member fun *toplevel-forms-to-print*) (print-current-form)) (cond ((consp fun) (t1ordinary form)) ((not (symbolp fun)) (cmperr "~s is illegal function." fun)) ((eq fun 'QUOTE) (t1ordinary 'NIL)) ((setq fd (gethash fun *t1-dispatch-table*)) (funcall fd args)) ((gethash fun *c1-dispatch-table*) (t1ordinary form)) ((and (setq fd (compiler-macro-function fun)) (inline-possible fun) (let ((success nil)) (multiple-value-setq (fd success) (cmp-expand-macro fd form)) success)) (push 'macroexpand *current-toplevel-form*) (t1expr* fd)) ((setq fd (cmp-macro-function fun)) (push 'macroexpand *current-toplevel-form*) (t1expr* (cmp-expand-macro fd form))) (t (t1ordinary form)) )))) (defun t1/c1expr (form) (cond ((not *compile-toplevel*) (c1expr form)) ((atom form) (t1ordinary form)) (t (t1expr* form)))) (defun t2expr (form) (when form (let* ((def (gethash (c1form-name form) *t2-dispatch-table*))) (if def (let ((*compile-file-truename* (c1form-file form)) (*compile-file-position* (c1form-file-position form)) (*current-toplevel-form* (c1form-form form)) (*current-form* (c1form-form form)) (*cmp-env* (c1form-env form))) (apply def form (c1form-args form))) (cmperr "Unhandled T2FORM found at the toplevel:~%~4I~A" form))))) (defvar *emitted-local-funs* nil) #+nil (defun emit-local-funs () ;; Local functions and closure functions (do () ((eq *local-funs* *emitted-local-funs*)) (let ((to-be-emitted (ldiff *local-funs* *emitted-local-funs*))) (setf *emitted-local-funs* *local-funs*) (mapc #'t3local-fun (nreverse to-be-emitted))))) (defun emit-local-funs () ;; Local functions and closure functions (do ((*compile-time-too* nil) (*compile-toplevel* nil)) ;; repeat until t3local-fun generates no more ((eq *emitted-local-funs* *local-funs*)) ;; scan *local-funs* backwards (do ((lfs *local-funs* (cdr lfs))) ((eq (cdr lfs) *emitted-local-funs*) (setq *emitted-local-funs* lfs) (locally (declare (notinline t3local-fun)) ;; so disassemble can redefine it (t3local-fun (first lfs))))))) (defun ctop-write (name h-pathname data-pathname &aux def top-output-string (*volatile* "volatile ")) (setq *top-level-forms* (nreverse *top-level-forms*)) (wt-nl "#include \"" (brief-namestring h-pathname) "\"") ;; VV might be needed by functions in CLINES. (wt-nl-h "#ifdef ECL_DYNAMIC_VV") (wt-nl-h "static cl_object *VV;") (wt-nl-h "#else") (wt-nl-h "static cl_object VV[VM];") (wt-nl-h "#endif") (output-clines *compiler-output2*) (wt-nl-h "#ifdef __cplusplus") (wt-nl-h "extern \"C\" {") (wt-nl-h "#endif") ;;; Initialization function. (let* ((*opened-c-braces* 0) (*aux-closure* nil) (c-output-file *compiler-output1*) (*compiler-output1* (make-string-output-stream)) (*emitted-local-funs* nil) (*compiler-declared-globals* (make-hash-table))) (wt-nl "#include \"" (brief-namestring data-pathname) "\"") (wt-nl "#ifdef __cplusplus") (wt-nl "extern \"C\"") (wt-nl "#endif") (wt-nl "ECL_DLLEXPORT void " name "(cl_object flag)") (wt-nl-open-brace) (wt-nl "const cl_env_ptr cl_env_copy = ecl_process_env();") (wt-nl "cl_object value0;") (wt-nl "cl_object *VVtemp;") (wt-nl "if (flag != OBJNULL){") (wt-nl "Cblock = flag;") (wt-nl "#ifndef ECL_DYNAMIC_VV") (wt-nl "flag->cblock.data = VV;") (wt-nl "#endif") (when *self-destructing-fasl* (wt-nl "flag->cblock.self_destruct=1;")) (wt-nl "flag->cblock.data_size = VM;") (wt-nl "flag->cblock.temp_data_size = VMtemp;") (wt-nl "flag->cblock.data_text = compiler_data_text;") (wt-nl "flag->cblock.cfuns_size = compiler_cfuns_size;") (wt-nl "flag->cblock.cfuns = compiler_cfuns;") (when ext:*source-location* (wt-nl "flag->cblock.source = make_constant_base_string(\"" (namestring (car ext:*source-location*)) "\");")) (wt-nl "return;}") (wt-nl "#ifdef ECL_DYNAMIC_VV") (wt-nl "VV = Cblock->cblock.data;") (wt-nl "#endif") ;; With this we ensure creating a constant with the tag ;; and the initialization file (wt-nl "Cblock->cblock.data_text = (const cl_object *)\"" (init-name-tag name) "\";") (wt-nl "VVtemp = Cblock->cblock.temp_data;") (wt-nl "ECL_DEFINE_SETF_FUNCTIONS") ;; Type propagation phase (when *do-type-propagation* (setq *compiler-phase* 'p1propagate) (dolist (form *top-level-forms*) (when form (p1propagate form nil))) (dolist (fun *local-funs*) (p1propagate (fun-lambda fun) nil))) (setq *compiler-phase* 't2) (loop for form in (nconc (reverse *make-forms*) *top-level-forms*) do (emit-toplevel-form form c-output-file)) (wt-nl-close-many-braces 0) (setq top-output-string (get-output-stream-string *compiler-output1*))) ;; Declarations in h-file. (wt-nl-h "static cl_object Cblock;") (let ((num-objects (data-size))) (if (zerop num-objects) (progn (wt-nl-h "#undef ECL_DYNAMIC_VV") (wt-nl-h "#define compiler_data_text 0") (wt-nl-h "#define VM 0") (wt-nl-h "#define VMtemp 0") (wt-nl-h "#define VV NULL")) (progn (wt-nl-h "#define VM " (data-permanent-storage-size)) (wt-nl-h "#define VMtemp " (data-temporary-storage-size))))) (dolist (l *linking-calls*) (let* ((c-name (fourth l)) (var-name (fifth l))) (wt-nl-h "static cl_object " c-name "(cl_narg, ...);") (wt-nl-h "static cl_object (*" var-name ")(cl_narg, ...)=" c-name ";"))) ;;; Global entries for directly called functions. (dolist (x *global-entries*) (apply 'wt-global-entry x)) ;;; Initial functions for linking calls. (dolist (l *linking-calls*) (let* ((var-name (fifth l)) (c-name (fourth l)) (lisp-name (third l))) (wt-nl "static cl_object " c-name "(cl_narg narg, ...)" "{TRAMPOLINK(narg," lisp-name ",&" var-name ",Cblock);}"))) #+(or) (wt-nl-h "static cl_object ECL_SETF_DEFINITION(cl_object setf_vv, cl_object setf_form) { cl_object f1 = ecl_fdefinition(setf_form); cl_object f2 = ECL_CONS_CAR(setf_vv); if (f1 != f2) { FEundefined_function(setf_form); } return f2; } ") (wt-nl-h "#define ECL_DEFINE_SETF_FUNCTIONS ") (loop for (name setf-vv name-vv) in *setf-definitions* do (wt-h #\\ #\Newline setf-vv "=ecl_setf_definition(" name-vv ",ECL_T);")) (wt-nl-h "#ifdef __cplusplus") (wt-nl-h "}") (wt-nl-h "#endif") (when (and (listp *static-constants*) (setf *static-constants* (nreverse *static-constants*))) (wt-nl-h "/*") (wt-nl-h " * Statically defined constants") (wt-nl-h " */") (loop for (value name builder) in (reverse *static-constants*) do (terpri *compiler-output2*) do (funcall builder name value *compiler-output2*))) (output-cfuns *compiler-output2*) (setq *compiler-phase* 't3) ;;; Callbacks (when *callbacks* (wt-nl-h "#include ") (dolist (x *callbacks*) (apply #'t3-defcallback x))) (wt-nl top-output-string)) (defun emit-toplevel-form (form c-output-file) (let ((*ihs-used-p* nil) (*max-lex* 0) (*max-env* 0) (*max-temp* 0) (*lcl* 0) (*lex* 0) (*level* 0) (*env* 0) (*env-lvl* 0) (*temp* 0) (*compile-to-linking-call* nil) (*compile-file-truename* (and form (c1form-file form))) (*compile-file-position* (and form (c1form-file-position form)))) ;; We save the C body of the statement, indented, just in case ;; we need to add a {} section with the environment variables. (let ((body (let ((*opened-c-braces* (1+ *opened-c-braces*))) (with-output-to-string (*compiler-output1*) (t2expr form))))) (if (or (plusp *max-lex*) (plusp *max-temp*) (plusp *max-env*) *ihs-used-p*) (progn (wt-nl-open-brace) (wt-function-locals) (write-sequence body *compiler-output1*) (wt-nl-close-brace)) (write-sequence body *compiler-output1*))) (let ((*compiler-output1* c-output-file)) (emit-local-funs)))) (defun c1eval-when (args) (check-args-number 'EVAL-WHEN args 1) (let ((load-flag nil) (compile-flag nil) (execute-flag nil)) (dolist (situation (car args)) (case situation ((LOAD :LOAD-TOPLEVEL) (setq load-flag t)) ((COMPILE :COMPILE-TOPLEVEL) (setq compile-flag t)) ((EVAL :EXECUTE) (if *compile-toplevel* (setq compile-flag (or *compile-time-too* compile-flag)) (setq execute-flag t))) (otherwise (cmperr "The EVAL-WHEN situation ~s is illegal." situation)))) (cond ((not *compile-toplevel*) (c1progn (and execute-flag (rest args)))) (load-flag (let ((*compile-time-too* compile-flag)) (c1progn (rest args)))) (compile-flag (cmp-eval (cons 'PROGN (rest args))) (c1progn 'NIL)) (t (c1progn 'NIL))))) (defun t2compiler-let (c1form symbols values body) (declare (ignore c1form)) (progv symbols values (c2expr body))) (defun t2progn (c1form args) (declare (ignore c1form)) (mapc #'t2expr args)) (defun exported-fname (name) (let (cname) (if (and (symbolp name) (setf cname (get-sysprop name 'Lfun))) (values cname t) (values (next-cfun "L~D~A" name) nil)))) ;;; Mechanism for sharing code: ;;; FIXME! Revise this 'DEFUN stuff. (defun new-defun (new &optional no-entry) #| (unless (fun-exported new) ;; Check whether this function is similar to a previous one and ;; share code with it. (dolist (old *global-funs*) (when (similar (fun-lambda new) (fun-lambda old)) (cmpnote "Sharing code among functions ~A and ~A" (fun-name new) (fun-name old)) (setf (fun-shares-with new) old (fun-cfun new) (fun-cfun old) (fun-minarg new) (fun-minarg old) (fun-maxarg new) (fun-maxarg old)) (return)))) |# (push new *global-funs*)) (defun print-function (x) (format t "~%" (fun-name x) (fun-closure x) (fun-level x) (fun-env x))) (defmacro and! (&body body) `(let ((l (list ,@body))) (pprint (list* 'l? l)) (every #'identity l))) #| (defun similar (x y) (let ((*processed* (make-hash-table :test #'equal))) ;; FIXME! This could be more accurate (labels ((similar (x y) (when (eql x y) (return-from similar t)) (let ((pair (cons x y))) (case (gethash pair *processed* :not-found) ((nil) (return-from similar nil)) ((t) (return-from similar t)) ((:ongoing) (return-from similar t)) ((:not-found))) (setf (gethash pair *processed*) :ongoing) (setf (gethash pair *processed*) (and (eql (type-of x) (type-of y)) (typecase x (CONS (and (similar (car x) (car y)) (similar (cdr x) (cdr y)))) (VAR (similar-var x y)) (FUN (similar-fun x y)) (REF (similar-ref x y)) (TAG NIL) (BLK NIL) (C1FORM (similar-c1form x y)) (SEQUENCE (and (every #'similar x y))) (T (equal x y))))))) (similar-list (x y) (null (set-difference x y))) (similar-ref (x y) (and (equal (ref-ref-ccb x) (ref-ref-ccb y)) (equal (ref-ref-clb x) (ref-ref-clb y)) (equal (ref-ref x) (ref-ref y)))) (similar-var (x y) (and! (similar-ref x y) (equal (var-name x) (var-name y)) (equal (var-kind x) (var-kind y)) (equal (var-loc x) (var-loc y)) (equal (var-type x) (var-type y)) (equal (var-index x) (var-index y)))) (similar-c1form (x y) (and (equal (c1form-name x) (c1form-name y)) (similar (c1form-args x) (c1form-args y)) (similar (c1form-local-vars x) (c1form-local-vars y)) (eql (c1form-sp-change x) (c1form-sp-change y)) (eql (c1form-volatile x) (c1form-volatile y)))) (similar-fun (x y) (and! (similar-ref x y) (eql (fun-global x) (fun-global y)) (eql (fun-exported x) (fun-exported y)) (eql (fun-closure x) (fun-closure y)) (similar (fun-var x) (fun-var y)) (similar (fun-lambda x) (fun-lambda y)) (= (fun-level x) (fun-level y)) (= (fun-env x) (fun-env y)) (= (fun-minarg x) (fun-minarg y)) (eql (fun-maxarg x) (fun-maxarg y)) (every #'similar (fun-local-vars x) (fun-local-vars y)) (every #'similar (fun-referenced-vars x) (fun-referenced-vars y)) (every #'similar (fun-referenced-funs x) (fun-referenced-funs y)) (every #'similar (fun-child-funs x) (fun-child-funs y))))) (similar x y)))) |# (defun wt-function-locals (&optional closure-type) ;; FIXME! Are we careful enough with temporary variables that ;; we need not make them volatile? (when (plusp *max-temp*) (wt-nl "cl_object ") (dotimes (i *max-temp*) (wt "T" i) (unless (= (1+ i) *max-temp*) (wt ", "))) (wt ";")) (when *ihs-used-p* (wt-nl "struct ecl_ihs_frame ihs;") (wt-nl "const cl_object _ecl_debug_env = ECL_NIL;")) ;; There should be no need to mark lex as volatile, since we ;; are going to pass pointers of this array around and the compiler ;; should definitely keep this in memory. (when (plusp *max-lex*) (wt-nl "volatile cl_object lex" *level* "[" *max-lex* "];")) (when (plusp *max-env*) (unless (eq closure-type 'CLOSURE) (wt-nl "cl_object " *volatile* "env0;")) ;; Note that the closure structure has to be marked volatile ;; or else GCC may optimize away writes into it because it ;; does not know it shared with the rest of the world. (when *aux-closure* (wt-nl "volatile struct ecl_cclosure aux_closure;")) (wt-nl "cl_object " *volatile*) (loop for i from 0 below *max-env* for comma = "" then ", " do (wt comma "CLV" i) finally (wt ";")))) (defun wt-global-entry (fname cfun arg-types return-type) (when (and (symbolp fname) (get-sysprop fname 'NO-GLOBAL-ENTRY)) (return-from wt-global-entry nil)) (wt-comment-nl "global entry for the function ~a" fname) (wt-nl "static cl_object L" cfun "(cl_narg narg") (wt-nl-h "static cl_object L" cfun "(cl_narg") (do ((vl arg-types (cdr vl)) (lcl (1+ *lcl*) (1+ lcl))) ((endp vl) (wt1 ")")) (declare (fixnum lcl)) (wt1 ", cl_object ") (wt-lcl lcl) (wt-h ", cl_object")) (wt-h1 ");") (wt-nl-open-brace) (when (compiler-check-args) (wt-nl "_ecl_check_narg(" (length arg-types) ");")) (wt-nl "cl_env_copy->nvalues = 1;") (wt-nl "return " (case return-type (FIXNUM "ecl_make_fixnum") (CHARACTER "CODE_CHAR") (DOUBLE-FLOAT "ecl_make_double_float") (SINGLE-FLOAT "ecl_make_single_float") #+long-float (LONG-FLOAT "ecl_make_long_float") (otherwise "")) "(LI" cfun "(") (do ((types arg-types (cdr types)) (n 1 (1+ n))) ((endp types)) (declare (fixnum n)) (wt (case (car types) (FIXNUM "fix") (CHARACTER "ecl_char_code") (DOUBLE-FLOAT "df") (SINGLE-FLOAT "sf") #+long-float (LONG-FLOAT "ecl_long_float") (otherwise "")) "(") (wt-lcl n) (wt ")") (unless (endp (cdr types)) (wt ","))) (wt "));") (wt-nl-close-many-braces 0)) (defun rep-type (type) (case type (FIXNUM "cl_fixnum ") (CHARACTER "unsigned char ") (SINGLE-FLOAT "float ") (DOUBLE-FLOAT "double ") (otherwise "cl_object "))) (defun t1ordinary (form) (when *compile-time-too* (cmp-eval form)) (let ((*compile-toplevel* nil) (*compile-time-too* nil)) (add-load-time-values (make-c1form* 'ORDINARY :args (c1expr form))))) (defun p1ordinary (c1form assumptions form) (p1propagate form assumptions)) (defun t2ordinary (c1form form) (declare (ignore c1form)) (let* ((*exit* (next-label)) (*unwind-exit* (list *exit*)) (*destination* 'TRASH)) (c2expr form) (wt-label *exit*))) (defun add-load-time-values (form) (let ((previous (append (and (consp *load-time-values*) (nreverse *load-time-values*)) (nreverse *make-forms*)))) (when previous (setf *load-time-values* nil *make-forms* nil) (setf form (make-c1form* 'PROGN :args (nconc previous (list form)))))) form) (defun t1defmacro (args) (check-args-number 'LOAD-TIME-VALUE args 2) (destructuring-bind (name lambda-list &rest body) args (multiple-value-bind (function pprint doc-string) (sys::expand-defmacro name lambda-list body) (let ((fn (cmp-eval function *cmp-env*))) (cmp-env-register-global-macro name fn)) (t1expr* (macroexpand `(DEFMACRO ,@args)))))) (defun c1load-time-value (args) (check-args-number 'LOAD-TIME-VALUE args 1 2) (let ((form (first args)) loc) (cond ((not (listp *load-time-values*)) ;; When using COMPILE, we set *load-time-values* to 'VALUES and ;; thus signal that we do not want to compile these forms, but ;; just to retain their value. (return-from c1load-time-value (c1constant-value (cmp-eval form) :always t))) ((typep form '(or list symbol)) (setf loc (data-empty-loc)) (push (make-c1form* 'LOAD-TIME-VALUE :args loc (c1expr form)) *load-time-values*)) (t (setf loc (add-object (cmp-eval form))))) (make-c1form* 'LOCATION :type t :args loc))) (defun t2load-time-value (c1form vv-loc form) (declare (ignore c1form)) (let* ((*exit* (next-label)) (*unwind-exit* (list *exit*)) (*destination* vv-loc)) (c2expr form) (wt-label *exit*))) (defun t2make-form (c1form vv-loc form) (declare (ignore c1form)) (let* ((*exit* (next-label)) (*unwind-exit* (list *exit*)) (*destination* vv-loc)) (c2expr form) (wt-label *exit*))) (defun t2init-form (c1form vv-loc form) (declare (ignore c1form)) (let* ((*exit* (next-label)) (*unwind-exit* (list *exit*)) (*destination* 'TRASH)) (c2expr form) (wt-label *exit*))) (defun parse-cvspecs (x &aux (cvspecs nil)) (dolist (cvs x (nreverse cvspecs)) (cond ((symbolp cvs) (push (list :OBJECT (string-downcase (symbol-name cvs))) cvspecs)) ((stringp cvs) (push (list :OBJECT cvs) cvspecs)) ((and (consp cvs) (member (car cvs) '(OBJECT CHAR INT FLOAT DOUBLE))) (dolist (name (cdr cvs)) (push (list (car cvs) (cond ((symbolp name) (string-downcase (symbol-name name))) ((stringp name) name) (t (cmperr "The C variable name ~s is illegal." name)))) cvspecs))) (t (cmperr "The C variable specification ~s is illegal." cvs)))) ) (defun locative-type-from-var-kind (kind) (cdr (assoc kind '((:object . "_ecl_object_loc") (:fixnum . "_ecl_fixnum_loc") (:char . "_ecl_base_char_loc") (:float . "_ecl_float_loc") (:double . "_ecl_double_loc") #+sse2 (:int-sse-pack . "_ecl_int_sse_pack_loc") #+sse2 (:float-sse-pack . "_ecl_float_sse_pack_loc") #+sse2 (:double-sse-pack . "_ecl_double_sse_pack_loc") ((special global closure lexical) . NIL))))) (defun build-debug-lexical-env (var-locations &optional first) #-:msvc ;; FIXME! Problem with initialization of statically defined vectors (let* ((filtered-locations '()) (filtered-codes '())) ;; Filter out variables that we know how to store in the ;; debug information table. This excludes among other things ;; closures and special variables. (loop for var in var-locations for name = (let ((*package* (find-package "KEYWORD"))) (format nil "\"~S\"" (var-name var))) for code = (locative-type-from-var-kind (var-kind var)) for loc = (var-loc var) when (and code (consp loc) (eq (first loc) 'LCL)) do (progn (push (cons name code) filtered-codes) (push loc filtered-locations))) ;; Generate two tables, a static one with information about the ;; variables, including name and type, and dynamic one, which is ;; a vector of pointer to the variables. (when filtered-codes (setf *ihs-used-p* t) (wt-nl "static const struct ecl_var_debug_info _ecl_descriptors[]={") (loop for (name . code) in filtered-codes for i from 0 do (wt-nl (if (zerop i) "{" ",{") name "," code "}")) (wt "};") (wt-nl "const cl_index _ecl_debug_info_raw[]={") (wt-nl (if first "(cl_index)(ECL_NIL)," "(cl_index)(_ecl_debug_env),") "(cl_index)(_ecl_descriptors)") (loop for var-loc in filtered-locations do (wt ",(cl_index)(&" var-loc ")")) (wt "};") (wt-nl "ecl_def_ct_vector(_ecl_debug_env,ecl_aet_index,_ecl_debug_info_raw," (+ 2 (length filtered-locations)) ",,);") (unless first (wt-nl "ihs.lex_env = _ecl_debug_env;"))) filtered-codes)) (defun pop-debug-lexical-env () (wt-nl "ihs.lex_env = _ecl_debug_env;")) (defun t3local-fun (fun) (declare (type fun fun)) ;; Compiler note about compiling this function (print-emitting fun) (let* ((lambda-expr (fun-lambda fun)) (*cmp-env* (c1form-env lambda-expr)) (*lcl* 0) (*temp* 0) (*max-temp* 0) (*last-label* 0) (*lex* 0) (*max-lex* 0) (*env* (fun-env fun)) ; continue growing env (*max-env* *env*) (*env-lvl* 0) (*aux-closure* nil) (*level* (fun-lexical-levels fun)) (*exit* 'RETURN) (*unwind-exit* '(RETURN)) (*destination* 'RETURN) (*ihs-used-p* nil) (*opened-c-braces* 0) (*tail-recursion-info* fun) (*volatile* (c1form-volatile* lambda-expr))) ;; Function declaration. Returns NIL if this function needs no body. (when (t3local-fun-declaration fun) (wt-nl-open-brace) (let ((body (t3local-fun-body fun))) (wt-function-locals (fun-closure fun)) (wt-nl "const cl_env_ptr cl_env_copy = ecl_process_env();") (when (eq (fun-closure fun) 'CLOSURE) (wt-nl "cl_object " *volatile* "env0 = cl_env_copy->function->cclosure.env;")) (wt-nl "cl_object " *volatile* "value0;") (when (policy-check-stack-overflow) (wt-nl "ecl_cs_check(cl_env_copy,value0);")) (when (eq (fun-closure fun) 'CLOSURE) (t3local-fun-closure-scan fun)) (write-sequence body *compiler-output1*) (wt-nl-close-many-braces 0))))) (defun t3local-fun-body (fun) (let ((string (make-array 2048 :element-type 'base-char :adjustable t :fill-pointer 0))) (with-output-to-string (*compiler-output1* string) (let ((lambda-expr (fun-lambda fun))) (c2lambda-expr (c1form-arg 0 lambda-expr) (c1form-arg 2 lambda-expr) (fun-cfun fun) (fun-name fun) (fun-needs-narg fun) (fun-required-lcls fun) (fun-closure fun)))) string)) (defun t3local-fun-declaration (fun) (declare (type fun fun)) (wt-comment-nl (cond ((fun-global fun) "function definition for ~a") ((eq (fun-closure fun) 'CLOSURE) "closure ~a") (t "local function ~a")) (or (fun-name fun) (fun-description fun) 'CLOSURE)) (when (fun-shares-with fun) (wt-comment-nl "... shares definition with ~a" (fun-name (fun-shares-with fun))) (return-from t3local-fun-declaration nil)) (let* ((comma "") (lambda-expr (fun-lambda fun)) (volatile (c1form-volatile* lambda-expr)) (lambda-list (c1form-arg 0 lambda-expr)) (requireds (mapcar #'(lambda (v) (next-lcl (var-name v))) (car lambda-list))) (narg (fun-needs-narg fun))) (let ((cmp-env (c1form-env lambda-expr))) (wt-comment-nl "optimize speed ~D, debug ~D, space ~D, safety ~D " (cmp-env-optimization 'speed cmp-env) (cmp-env-optimization 'debug cmp-env) (cmp-env-optimization 'space cmp-env) (cmp-env-optimization 'safety cmp-env))) (let ((cfun (fun-cfun fun))) (cond ((fun-exported fun) (wt-nl-h "ECL_DLLEXPORT cl_object " cfun "(") (wt-nl "cl_object " cfun "(")) (t (wt-nl-h "static cl_object " cfun "(") (wt-nl "static cl_object " cfun "(")))) (when narg (wt-h volatile "cl_narg") (wt volatile "cl_narg narg") (setf comma ", ")) (dotimes (n (fun-lexical-levels fun)) (wt-h comma "volatile cl_object *") (wt comma "volatile cl_object *lex" n) (setf comma ", ")) (loop for lcl in (setf (fun-required-lcls fun) requireds) do (wt-h comma "cl_object " volatile) (wt comma "cl_object " volatile lcl) (setf comma ", ")) (when narg (wt-h ", ...") (wt ", ...")) (wt-h ");") (wt ")")) t) (defun fun-closure-variables (fun) (sort (remove-if #'(lambda (x) (or ;; non closure variable (not (ref-ref-ccb x)) ;; special variable (eq (var-kind x) 'special) ;; not actually referenced (and (not (var-referenced-in-form x (fun-lambda fun))) (not (var-changed-in-form x (fun-lambda fun)))) ;; parameter of this closure ;; (not yet bound, therefore var-loc is OBJECT) (eq (var-loc x) 'OBJECT))) (fun-referenced-vars fun)) #'> :key #'var-loc)) (defun fun-lexical-levels (fun) (if (eq (fun-closure fun) 'LEXICAL) (fun-level fun) 0)) (defun t3local-fun-closure-scan (fun) (let ((clv-used (fun-closure-variables fun))) (wt-nl "/* Scanning closure data ... */") (do ((n (1- (fun-env fun)) (1- n)) (bs clv-used) (first t)) ((or (minusp n) (null bs))) (wt-nl "CLV" n) (if first (progn (wt " = env0;") (setf first nil)) (wt " = _ecl_cdr(CLV" (1+ n) ");")) (when (= n (var-loc (first bs))) (wt-comment (var-name (first clv-used))) (pop clv-used))) (wt-nl-open-brace) (wt " /* ... closure scanning finished */"))) ;;; ---------------------------------------------------------------------- ;;; Optimizer for FSET. Removes the need for a special handling of DEFUN as a ;;; toplevel form and also allows optimizing calls to DEFUN or DEFMACRO which ;;; are not toplevel, but which create no closures. ;;; ;;; The idea is as follows: when the function or macro to be defined is not a ;;; closure, we can use the auxiliary C functions c_def_c_*() instead of ;;; creating a closure and invoking si_fset(). However until the C2 phase of ;;; the compiler we do not know whether a function is a closure, hence the need ;;; for a c2fset. ;;; ;;; We optimize (SYS:FSET #'(LAMBDA ...) ..) and also, accidentally, ;;; (SYS:FSET (FLET ((FOO ...)) #'FOO) ...) which is to what LAMBDA gets ;;; translated in c1function. ;;; (defun t1fset (args) (let ((form `(si::fset ,@args))) (when *compile-time-too* (cmp-eval form)) (let ((*compile-toplevel* nil) (*compile-time-too* nil)) (add-load-time-values (c1fset form))))) (defun c1fset (form) (destructuring-bind (fname def &optional (macro nil) (pprint nil)) (rest form) (let* ((*use-c-global* t) (fun-form (c1expr def))) (when (eq (c1form-name fun-form) 'LOCALS) (let* ((function-list (c1form-arg 0 fun-form)) (fun-object (pop function-list)) (form (c1form-arg 1 fun-form)) (labels (c1form-arg 2 fun-form))) (when (and ;; Only 1 function (null function-list) ;; Not closed over anything (every #'global-var-p (fun-referenced-vars fun-object)) ;; Referencing the function variable (eq (c1form-name form) 'VAR) (eq (c1form-arg 0 form) (fun-var fun-object))) (when (fun-no-entry fun-object) (when macro (cmperr "Declaration C-LOCAL used in macro ~a" (fun-name fun-object))) (return-from c1fset (make-c1form* 'SI:FSET :args fun-object nil nil nil nil))) (when (and (typep macro 'boolean) (typep pprint '(or integer null)) (consp fname) (eq (first fname) 'quote)) (return-from c1fset (make-c1form* 'SI:FSET :args fun-object ;; Function object (let* ((fname (second fname)) (in-cl-symbols-p (and (symbolp fname) (si::mangle-name fname)))) (add-object fname :permanent t :duplicate in-cl-symbols-p :used-p t)) macro pprint ;; The c1form, when we do not optimize (list (c1expr fname) fun-form (c1expr macro) (c1expr pprint))))))))) (t1ordinary form))) (defun p1fset (c1form assumptions fun fname macro pprint c1forms) (p1propagate (fun-lambda fun) assumptions)) (defun t2fset (c1form &rest args) (t2ordinary nil c1form)) (defun c2fset (c1form fun fname macro pprint c1forms) (when (fun-no-entry fun) (wt-nl "(void)0; /* No entry created for " (format nil "~A" (fun-name fun)) " */") ;; FIXME! Look at C2LOCALS! (new-local fun) (return-from c2fset)) (unless (and (not (fun-closure fun)) (eq *destination* 'TRASH)) (return-from c2fset (c2call-global c1form 'SI:FSET c1forms))) (let ((*inline-blocks* 0) (loc (data-empty-loc))) (push (list loc fname fun) *global-cfuns-array*) ;; FIXME! Look at C2LOCALS! (new-local fun) (wt-nl (if macro "ecl_cmp_defmacro(" "ecl_cmp_defun(") loc ");") (wt-comment (loc-immediate-value fname)) (close-inline-blocks))) (defun output-cfuns (stream) (let ((n-cfuns (length *global-cfuns-array*))) (wt-nl-h "/*") (wt-nl-h " * Exported Lisp functions") (wt-nl-h " */") (wt-nl-h "#define compiler_cfuns_size " n-cfuns) (if (zerop n-cfuns) (wt-nl-h "#define compiler_cfuns NULL") (progn (format stream "~%static const struct ecl_cfun compiler_cfuns[] = {~ ~%~t/*t,m,narg,padding,name,block,entry*/"); (loop for (loc fname-loc fun) in (nreverse *global-cfuns-array*) do (let* ((cfun (fun-cfun fun)) (minarg (fun-minarg fun)) (maxarg (fun-maxarg fun)) (narg (if (and (= minarg maxarg) (<= maxarg si:c-arguments-limit)) maxarg -1))) (format stream "~%{0,0,~D,0,ecl_make_fixnum(~D),ecl_make_fixnum(~D),(cl_objectfn)~A,ECL_NIL,ecl_make_fixnum(~D)}," narg (vv-location loc) (vv-location fname-loc) cfun (fun-file-position fun)))) (format stream "~%};"))))) ecl-16.1.2/src/cmp/cmptype-arith.lsp000066400000000000000000000264361266352375300172470ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: C -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. ;;;; Copyright (c) 1990, Giuseppe Attardi. ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. ;;;; CMPTYPE-ARITH -- Operations upon and among types (in-package #-new-cmp "COMPILER" #+new-cmp "C-TYPES") ;;; CL-TYPE is any valid type specification of Common Lisp. ;;; ;;; TYPE is a representation type used by ECL. TYPE is one of: ;;; ;;; T(BOOLEAN) ;;; ;;; FIXNUM CHARACTER SINGLE-FLOAT DOUBLE-FLOAT ;;; (VECTOR T) STRING BIT-VECTOR (VECTOR FIXNUM) ;;; (VECTOR SINGLE-FLOAT) (VECTOR DOUBLE-FLOAT) ;;; (ARRAY T) (ARRAY BASE-CHAR) (ARRAY BIT) ;;; (ARRAY FIXNUM) ;;; (ARRAY SINGLE-FLOAT) (ARRAY DOUBLE-FLOAT) ;;; STANDARD-OBJECT STRUCTURE-OBJECT ;;; SYMBOL ;;; UNKNOWN ;;; ;;; NIL ;;; ;;; ;;; immediate-type: ;;; FIXNUM int ;;; CHARACTER char ;;; SINGLE-FLOAT float ;;; DOUBLE-FLOAT double (deftype any () 't) (defun member-type (type disjoint-supertypes) (member type disjoint-supertypes :test #'subtypep)) ;;; Check if THING is an object of the type TYPE. ;;; Depends on the implementation of TYPE-OF. ;;; (only used for saving constants?) #-new-cmp (defun object-type (thing) (let ((type (if thing (type-of thing) 'SYMBOL))) (case type ((FIXNUM SHORT-FLOAT SINGLE-FLOAT DOUBLE-FLOAT LONG-FLOAT SYMBOL NULL) type) ((BASE-CHAR STANDARD-CHAR CHARACTER EXTENDED-CHAR) 'CHARACTER) ((STRING BASE-STRING BIT-VECTOR) type) (VECTOR (list 'VECTOR (array-element-type thing))) (ARRAY (list 'ARRAY (array-element-type thing))) #+clos (STANDARD-OBJECT 'STANDARD-OBJECT) #+clos (STRUCTURE-OBJECT 'STRUCTURE-OBJECT) #+sse2 ((EXT:SSE-PACK EXT:INT-SSE-PACK EXT:FLOAT-SSE-PACK EXT:DOUBLE-SSE-PACK) type) (t t)))) (defun valid-type-specifier (type) (handler-case (if (subtypep type 'T) (values t type) (values nil nil)) (error (c) (values nil nil)))) (defun known-type-p (type) (subtypep type T)) (defun trivial-type-p (type) (subtypep T type)) (defun-equal-cached type-and (t1 t2) ;; FIXME! Should we allow "*" as type name??? (when (or (eq t1 t2) (eq t2 '*)) (return-from type-and t1)) (when (eq t1 '*) (return-from type-and t2)) (let* ((si::*highest-type-tag* si::*highest-type-tag*) (si::*save-types-database* t) (si::*member-types* si::*member-types*) (si::*elementary-types* si::*elementary-types*) (tag1 (si::safe-canonical-type t1)) (tag2 (si::safe-canonical-type t2))) (cond ((and (numberp tag1) (numberp tag2)) (setf tag1 (si::safe-canonical-type t1) tag2 (si::safe-canonical-type t2)) (cond ((zerop (logand tag1 tag2)) ; '(AND t1 t2) = NIL NIL) ((zerop (logandc2 tag1 tag2)) ; t1 <= t2 t1) ((zerop (logandc2 tag2 tag1)) ; t2 <= t1 t2) (t `(AND ,t1 ,t2)))) ((eq tag1 'CONS) (cmpwarn "Unsupported CONS type ~S. Replacing it with T." t1) t2) ((eq tag2 'CONS) (cmpwarn "Unsupported CONS type ~S. Replacing it with T." t2) t1) ((null tag1) ;(setf c::*compiler-break-enable* t) (break) (cmpnote "Unknown type ~S. Assuming it is T." t1) t2) (t ;(setf c::*compiler-break-enable* t) (break) (cmpnote "Unknown type ~S. Assuming it is T." t2) t1)))) (defun values-number-from-type (type) (cond ((or (eq type 'T) (eq type '*)) (values 0 MULTIPLE-VALUES-LIMIT)) ((or (atom type) (not (eq (first type) 'VALUES))) (values 1 1)) ((or (member '&rest type) (member '&optional type)) (values 0 MULTIPLE-VALUES-LIMIT)) (t (let ((l (1- (length type)))) (values l l))))) (defun-equal-cached values-type-primary-type (type) ;; Extract the type of the first value returned by this form. We are ;; pragmatic and thus (VALUES) => NULL [CHECKME!] (let (aux) (cond ((or (atom type) (not (eq (first type) 'VALUES))) type) ((null (setf aux (rest type))) 'NULL) ((member (setf aux (first aux)) '(&optional &rest &allow-other-keys)) (setf aux (do-values-type-to-n-types type 1)) (if aux (first aux) 'null)) (t aux)))) (defun-equal-cached values-type-to-n-types (type length) (when (plusp length) (do-values-type-to-n-types type length))) (defun do-values-type-to-n-types (type length) (declare (si::c-local)) (multiple-value-bind (required optional rest) (split-values-type type) (let* ((optional (loop for i in optional collect (if (eq i t) i `(or null ,i)))) (output (nconc required optional)) (l (length output))) (if (< l length) (nconc output (make-list (- length l) :initial-element (if rest (first rest) t))) (subseq output 0 length))))) (defun split-values-type (type) (if (or (atom type) (not (eq (first type) 'VALUES))) (values (list type) nil nil nil) (loop with required = '() with optional-flag = nil with optional = '() with rest = '() with a-o-k = nil with l = (rest type) while l do (let ((typespec (pop l))) (case typespec (&allow-other-keys (setf a-o-k t) (when l (cmperr "Syntax error in type expression ~S" type))) (&optional (if optional-flag (push typespec optional) (setf optional-flag t))) (&rest (when (or (null l) (not (member (rest l) '(() (&allow-other-keys)) :test #'equal))) (cmperr "Syntax error in type expression ~S" type)) (setf rest (list (car l)))) (otherwise (if optional-flag (push typespec optional) (push typespec required))))) finally (return (values (nreverse required) (nreverse optional) rest a-o-k))))) (defun-equal-cached values-type-or (t1 t2) (when (or (eq t2 'T) (equalp t2 '(VALUES &REST T))) (return-from values-type-or t2)) (when (or (eq t1 'T) (equalp t1 '(VALUES &REST T))) (return-from values-type-or t1)) (unless t1 (return-from values-type-or t2)) (unless t2 (return-from values-type-or t1)) (multiple-value-bind (req1 opt1 rest1) (split-values-type t1) (multiple-value-bind (req2 opt2 rest2) (split-values-type t2) (let ((req '()) (opt '()) (rest '())) (loop for t1 in req1 do (cond (req2 (push (type-or t1 (pop req2)) req)) (opt2 (push (type-or t1 (pop opt2)) opt)) (rest2 (push (type-or t1 (first rest2)) opt)) (t (push t1 opt)))) (loop for t1 in opt1 do (cond (req2 (push (type-or t1 (pop req2)) opt)) (opt2 (push (type-or t1 (pop opt2)) opt)) (rest2 (push (type-or t1 (first rest2)) opt)) (t (push t1 opt)))) (let ((t1 (if rest1 (first rest1) t))) (loop for t2 in req2 do (push (type-or t1 t2) opt)) (loop for t2 in opt2 do (push (type-or t1 t2) opt)) (if rest2 (setf rest (list (type-or t1 (first rest2)))) (setf rest rest1))) `(VALUES ,@(nreverse req) ,@(and opt (cons '&optional (nreverse opt))) ,@(and rest (cons '&optional rest))))))) (defun-equal-cached values-type-and (t1 t2) (when (or (eq t2 'T) (equalp t2 '(VALUES &REST T))) (return-from values-type-and t1)) (when (or (eq t1 'T) (equalp t1 '(VALUES &REST T))) (return-from values-type-and t2)) (when (or (null t1) (null t2)) (return-from values-type-and nil)) (multiple-value-bind (req1 opt1 rest1) (split-values-type t1) (multiple-value-bind (req2 opt2 rest2) (split-values-type t2) (let ((req '()) (opt '()) (rest '())) (loop for t1 in req1 do (cond (req2 (push (type-and t1 (pop req2)) req)) (opt2 (push (type-and t1 (pop opt2)) req)) (rest2 (push (type-and t1 (first rest2)) req)) (t (setf opt1 nil rest1 nil) (return)))) (loop for t1 in opt1 do (cond (req2 (push (type-and t1 (pop req2)) req)) (opt2 (push (type-and t1 (pop opt2)) opt)) (rest2 (push (type-and t1 (first rest2)) opt)) (t (setf opt1 nil rest1 nil) (return)))) (when rest (let ((t1 (first rest))) (loop for t2 in req2 do (push (type-and t1 t2) req)) (loop for t2 in opt2 do (push (type-and t1 t2) opt)) (when rest2 (setf rest (list (type-and t1 (first rest2))))))) `(VALUES ,@(nreverse req) ,@(and opt (cons '&optional (nreverse opt))) ,@(and rest (cons '&optional rest))))))) (defun-equal-cached type-or (t1 t2) ;; FIXME! Should we allow "*" as type name??? (when (or (eq t1 t2) (eq t2 '*)) (return-from type-or t1)) (when (eq t1 '*) (return-from type-or t2)) (let* ((si::*highest-type-tag* si::*highest-type-tag*) (si::*save-types-database* t) (si::*member-types* si::*member-types*) (si::*elementary-types* si::*elementary-types*) (tag1 (si::safe-canonical-type t1)) (tag2 (si::safe-canonical-type t2))) (cond ((and (numberp tag1) (numberp tag2)) (setf tag1 (si::safe-canonical-type t1) tag2 (si::safe-canonical-type t2)) (cond ((zerop (logandc2 tag1 tag2)) ; t1 <= t2 t2) ((zerop (logandc2 tag2 tag1)) ; t2 <= t1 t1) (t `(OR ,t1 ,t2)))) ((eq tag1 'CONS) (cmpwarn "Unsupported CONS type ~S. Replacing it with T." t1) T) ((eq tag2 'CONS) (cmpwarn "Unsupported CONS type ~S. Replacing it with T." t2) T) ((null tag1) ;(break) (cmpnote "Unknown type ~S" t1) T) (t ;(break) (cmpnote "Unknown type ~S" t2) T)))) (defun type>= (type1 type2) (subtypep type2 type1)) ecl-16.1.2/src/cmp/cmptype-assert.lsp000066400000000000000000000146371266352375300174410ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: C -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; Copyright (c) 2011, Juan Jose Garcia-Ripoll ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. ;;;; CMPTYPE-ASSERT Type assertions automatically generated (in-package "COMPILER") (defun c1compiler-typecase (args) (let ((form (first args))) (multiple-value-bind (constantp value) (constant-value-p form *cmp-env*) (when constantp (loop for (type . forms) in (rest args) when (typep value type) do (return-from c1compiler-typecase (c1progn forms)) finally (baboon :format-control "COMPILER-TYPECASE form missing a T statement"))))) (let* ((var-name (pop args)) (var (c1vref var-name)) (first-case (car args))) ;; If the first type, which is supposedly the most specific ;; already includes the form, we keep it. This optimizes ;; most cases of CHECKED-VALUE. (if (subtypep (var-type var) (car first-case)) (c1progn (cdr first-case)) (let* ((types '()) (expressions (loop for (type . forms) in args for c1form = (c1progn forms) for c1form-type = (c1form-primary-type c1form) do (push c1form-type types) collect (list type c1form)))) (make-c1form* 'EXT:COMPILER-TYPECASE :type (reduce #'type-or types) :args var expressions))))) (defun c2compiler-typecase (c1form var expressions) (declare (ignore c1form)) (loop with var-type = (var-type var) for (type form) in expressions when (or (member type '(t otherwise)) (subtypep var-type type)) return (c2expr form))) (defconstant +simple-type-assertions+ '((cons . "if (ecl_unlikely(ECL_ATOM(#0))) FEtype_error_cons(#0);") (array . "if (ecl_unlikely(!ECL_ARRAYP(#0))) FEtype_error_array(#0);") (list . "if (ecl_unlikely(!ECL_LISTP(#0))) FEtype_error_list(#0);") (sequence . "if (ecl_unlikely(!(ECL_LISTP(#0) || ECL_VECTORP(#0)))) FEtype_error_sequence(#0);") (vector . "if (ecl_unlikely(!ECL_VECTORP(#0))) FEtype_error_vector(#0);"))) (defun simple-type-assertion (value type env) (let ((simple-form (cdr (assoc type +simple-type-assertions+)))) (if simple-form `(ffi:c-inline (,value) (:object) :void ,simple-form :one-liner nil) `(ffi:c-inline ((typep ,value ',type) ',type ,value) (:bool :object :object) :void "if (ecl_unlikely(!(#0))) FEwrong_type_argument(#1,#2);" :one-liner nil)))) (defun expand-type-assertion (value type env compulsory) (cond ((or (not (symbolp value)) (special-variable-p value) (symbol-macro-p value)) ;; If multiple references to the value cost time and space, ;; or may cause side effects, we save it. (with-clean-symbols (%asserted-value) `(let* ((%asserted-value ,value)) (declare (:read-only %asserted-value)) ,(expand-type-assertion '%asserted-value type env compulsory)))) (compulsory ;; The check has to be produced, independent of the declared ;; value of the variable (for instance, in LAMBDA arguments). (simple-type-assertion value type env)) (t ;; We may rely on the compiler to choose the appropriate ;; branch once type propagation has happened. `(ext:compiler-typecase ,value (,type) (t ,(simple-type-assertion value type env)))))) (defun c1checked-value (args) (let* ((type (pop args)) (value (pop args)) form form-type and-type) (cond ((or (trivial-type-p args) (not (policy-type-assertions))) value) ((and (consp type) (eq (first type) 'values)) (c1checked-value (list (values-type-primary-type type) value))) ((and (policy-evaluate-forms) (constantp value *cmp-env*)) (unless (typep (ext:constant-form-value value *cmp-env*) type) (cmpwarn "Failed type assertion for value ~A and type ~A" value type)) value) ;; Is the form type contained in the test? ((progn (setf form (c1expr value) form-type (c1form-primary-type form) and-type (type-and form-type type)) (eq and-type form-type)) form) ;; Are the form type and the test disjoint types? ((null and-type) (cmpwarn "The expression ~S is not of the expected type ~S" value type) form) ;; Otherwise, emit a full test (t (cmpnote "Checking type of ~S to be ~S" value type) (let ((full-check (with-clean-symbols (%checked-value) `(let* ((%checked-value ,value)) (declare (:read-only %checked-value)) ,(expand-type-assertion '%checked-value type *cmp-env* nil) (truly-the ,type %checked-value))))) (make-c1form* 'CHECKED-VALUE :type type :args type form (c1expr full-check))))))) (defun c2checked-value (c1form type value let-form) (c2expr (if (subtypep (c1form-primary-type value) type) value let-form))) (defmacro optional-type-assertion (&whole whole value type &environment env) "If safety settings are high enough, generates a type check on an expression, ensuring that it is satisfied." (when (and (policy-type-assertions env) (not (trivial-type-p type))) (cmpnote "Checking type of ~A to be ~A" value type) `(checked-value ,type ,value))) (defmacro type-assertion (&whole whole value type &environment env) "Generates a type check on an expression, ensuring that it is satisfied." (cmpnote "Checking type of ~A to be ~A" value type) (unless (trivial-type-p type) (expand-type-assertion value type env t))) ecl-16.1.2/src/cmp/cmptype-prop.lsp000066400000000000000000000065431266352375300171150ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: C -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; Copyright (c) 2009, Juan Jose Garcia-Ripoll. ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. ;;;; ;;;; CMPTYPE-PROP -- Type propagation basic routines and database ;;;; (in-package #-new-cmp "COMPILER" #+new-cmp "C-TYPES") (defun infer-arg-and-return-types (fname forms &optional (env *cmp-env*)) (let ((found (gethash fname *p0-dispatch-table*)) arg-types (return-type '(VALUES &REST T))) (cond (found (multiple-value-setq (arg-types return-type) (apply found fname (mapcar #'location-primary-type forms)))) ((multiple-value-setq (arg-types found) (get-arg-types fname env)) (setf return-type (or (get-return-type fname) return-type)))) (values arg-types return-type found))) (defun enforce-types (fname arg-types arguments) (do* ((types arg-types (rest types)) (args arguments (rest args)) (i 1 (1+ i)) (in-optionals nil)) ((endp types) (when types (cmpwarn "Too many arguments passed to ~A" fname))) (let ((expected-type (first types))) (cond ((member expected-type '(* &rest &key &allow-other-keys) :test #'eq) (return)) ((eq expected-type '&optional) (when in-optionals (cmpwarn "Syntax error in type proclamation for function ~A.~&~A" fname arg-types)) (setf in-optionals t types (rest types))) ((endp args) (unless in-optionals (cmpwarn "Too few arguments for proclaimed function ~A" fname)) (return)) (t (let* ((value (first args)) (actual-type (location-primary-type value)) (intersection (type-and actual-type expected-type))) (unless intersection (cmpwarn-style "The argument ~d of function ~a has type~&~4T~A~&instead of expected~&~4T~A" i fname actual-type expected-type)) #-new-cmp (when (zerop (cmp-env-optimization 'safety)) (setf (c1form-type value) intersection)))))))) (defun propagate-types (fname forms) (multiple-value-bind (arg-types return-type found) (infer-arg-and-return-types fname forms) (when found (enforce-types fname arg-types forms)) return-type)) (defmacro def-type-propagator (fname lambda-list &body body) (unless (member '&rest lambda-list) (let ((var (gensym))) (setf lambda-list (append lambda-list (list '&rest var)) body (list* `(declare (ignorable ,var)) body)))) `(setf (gethash ',fname *p0-dispatch-table*) #'(lambda ,lambda-list (declare (ignorable ,(first lambda-list))) ,@body))) (defun copy-type-propagator (orig dest-list) (loop with function = (gethash orig *p0-dispatch-table*) for name in dest-list when function do (setf (gethash name *p0-dispatch-table*) function))) ecl-16.1.2/src/cmp/cmptype.lsp000066400000000000000000000201321266352375300161250ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: C -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. ;;;; Copyright (c) 1990, Giuseppe Attardi. ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. ;;;; CMPTYPE Type information. (in-package "COMPILER") ;;; ;;; and-form-type ;;; returns a copy of form whose type is the type-and of type and the form's ;;; type ;;; (defun and-form-type (type form original-form &optional (mode :safe) (format-string "") &rest format-args) (let* ((type2 (c1form-primary-type form)) (type1 (type-and type type2))) ;; We only change the type if it is not NIL. Is this wise? (if type1 (setf (c1form-type form) type1) (funcall (if (eq mode :safe) #'cmperr #'cmpwarn) "~?, the type of the form ~s is ~s, not ~s." format-string format-args original-form type2 type)) form)) (defun default-init (var &optional warn) (declare (ignore warn)) (let ((new-value (cdr (assoc (var-type var) '((fixnum . 0) (character . #\space) #+long-float (long-float 0.0L1) (double-float . 0.0D1) (single-float . 0.0F1)) :test #'subtypep)))) (if new-value (c1constant-value new-value :only-small-values t) (c1nil)))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; ;; TYPE CHECKING ;; (defun lambda-type-check-associate (fname requireds optionals keywords global-fun-p) (multiple-value-bind (arg-types found) (and global-fun-p (get-arg-types fname *cmp-env* global-fun-p)) (if found (multiple-value-bind (req-types opt-types rest-flag key-flag key-types allow-other-keys) (si::process-lambda-list arg-types 'ftype) (declare (ignore rest-flag key-flag allow-other-keys)) (nconc (loop for var in requireds for type in (rest req-types) collect (cons var type)) (loop for optional in optionals by #'cdddr for type in (rest opt-types) by #'cdddr collect (cons optional type)) (loop for key-list on keywords by #'cddddr for keyword = (first key-list) for key-var = (second key-list) for type = (loop for key-list on (rest key-types) by #'cddr when (eq keyword (first key-list)) return (second key-list) finally (return t)) collect (cons key-var type)))) (nconc (loop for var in requireds collect (cons var t)) (loop for optional in optionals by #'cdddr collect (cons optional t)) (loop for key-list on keywords by #'cddddr for key-var = (second key-list) collect (cons key-var t)))))) (defun lambda-type-check-precise (assoc-list ts) (loop for record in assoc-list for var = (car record) for type = (assoc (var-name var) ts) when type do ;; Instead of trusting the global proclamation, we set a check based ;; on the local declaration, without type merging. (rplacd record (cdr type)) #+(or) (rplacd record (type-and (cdr record) (cdr type)))) assoc-list) (defun extract-lambda-type-checks (fname requireds optionals keywords ts other-decls) ;; We generate automatic type checks for function arguments that ;; are declared These checks can be deactivated by appropriate ;; safety settings which are checked by ASSERT-TYPE. Note ;; that not all type declarations can be checked (take for instance ;; (type (function (t t) t) foo)) We let the macro do the job. (loop with policy-check-type = (policy-check-arguments-type) with checks = '() with new-auxs = '() with global-fun-p = (member '(si::c-global) other-decls :test #'equal) with type-checks = (lambda-type-check-precise (lambda-type-check-associate fname requireds optionals keywords global-fun-p) ts) for (var . type) in type-checks for name = (var-name var) ;; Non trivial types are the only ones we care about unless (eq type t) do (if (and policy-check-type (loop for decl in other-decls never (and (consp decl) (eq (first decl) 'si::no-check-type) (member name (rest decl))))) ;; We remove assumption about types, which will be checked ;; later due to this assertion... (setf (var-type var) t checks (list* `(type-assertion ,name ,type) checks) new-auxs (list* `(truly-the ,type ,name) name new-auxs)) ;; Or simply enforce the variable's type. (setf (var-type var) (type-and (var-type var) type))) finally (progn (when checks (cmpnote "In ~:[an anonymous function~;function ~:*~A~], checking types of argument~@[s~]~{ ~A~}." (fun-name *current-function*) (mapcar #'second checks))) (return (cons (nreverse checks) (nreverse new-auxs)))))) (defun type-error-check (value type) (case type (cons `(ffi:c-inline (,value) (:object) :void "@0;if (ecl_unlikely(ECL_ATOM(#0))) FEtype_error_cons(#0);" :one-liner nil)) (array `(ffi:c-inline (,value) (:object) :void "if (ecl_unlikely(!ECL_ARRAYP(#0))) FEtype_error_array(#0);" :one-liner nil)) (list `(ffi:c-inline (,value) (:object) :void "if (ecl_unlikely(!ECL_LISTP(#0))) FEtype_error_list(#0);" :one-liner nil)) (sequence `(ffi:c-inline (,value) (:object) :void "if (ecl_unlikely(!(ECL_LISTP(#0) || ECL_VECTORP(#0)))) FEtype_error_sequence(#0);" :one-liner nil)) (otherwise `(ffi:c-inline ((typep ,value ',type) ',type ,value) (:bool :object :object) :void "if (ecl_unlikely(!(#0))) FEwrong_type_argument(#1,#2);" :one-liner nil)))) (defmacro assert-type-if-known (&whole whole value type &environment env) "Generates a type check on an expression, ensuring that it is satisfied." (multiple-value-bind (trivial valid) (subtypep 't type) (cond ((and trivial valid) value) ((multiple-value-setq (valid value) (constant-value-p value env)) (si::maybe-quote value)) (t (with-clean-symbols (%value) `(let* ((%value ,value)) ,(type-error-check '%value (replace-invalid-types type)) (truly-the ,type %value))))))) (defun replace-invalid-types (type) ;; Some types which are acceptable in DECLARE are not ;; accepted by TYPEP. We thus simplify the type replacing ;; the offending ones by more general types. No problem ;; doing this since the type checks are optional. (if (atom type) type (let ((name (car type))) (case name (FUNCTION 'FUNCTION) ((OR AND NOT CONS) (list* name (mapcar #'replace-invalid-types (rest type)))) (otherwise type))))) (defmacro optional-type-check (&whole whole value type &environment env) (declare (ignore env)) (if (policy-assume-right-type) value `(assert-type-if-known ,value ,type))) (defmacro with-let*-type-check (triplets &body body) `(let* ,(loop for (var value type) in triplets collect `(,var (assert-type-if-known ,value ,type))) (declare (:read-only ,@(mapcar #'car triplets))) ,@body)) ecl-16.1.2/src/cmp/cmptypes.lsp000066400000000000000000000304611266352375300163160ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: C -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; Copyright (c) 2010, Juan Jose Garcia-Ripoll ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. ;;;; ;;;; CMPTYPES -- Data types for the Lisp core structures ;;;; (in-package #-new-cmp "COMPILER" #+new-cmp "C-DATA") ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; ;;; COMPILER STRUCTURES ;;; ;;; ;;; REF OBJECT ;;; ;;; Base object for functions, variables and statements. We use it to ;;; keep track of references to objects, how many times the object is ;;; referenced, by whom, and whether the references cross some closure ;;; boundaries. ;;; (defstruct (ref (:print-object print-ref)) name ;;; Identifier of reference. (ref 0 :type fixnum) ;;; Number of references. ref-ccb ;;; Cross closure reference. ;;; During Pass1, T or NIL. ;;; During Pass2, the index into the closure env ref-clb ;;; Cross local function reference. ;;; During Pass1, T or NIL. ;;; During Pass2, the lex-address for the ;;; block id, or NIL. read-nodes ;;; Nodes (c1forms) in which the reference occurs ) (deftype OBJECT () `(not (or fixnum character float))) (defstruct (var (:include ref) (:constructor %make-var) (:print-object print-var)) ; name ;;; Variable name. ; (ref 0 :type fixnum) ;;; Number of references to the variable (-1 means IGNORE). ; ref-ccb ;;; Cross closure reference: T or NIL. ; ref-clb ;;; Cross local function reference: T or NIL. ; read-nodes ;;; Nodes (c1forms) in which the reference occurs set-nodes ;;; Nodes in which the variable is modified kind ;;; One of LEXICAL, CLOSURE, SPECIAL, GLOBAL, :OBJECT, ;;; or some C representation type (:FIXNUM, :CHAR, etc) (function *current-function*) ;;; For local variables, in which function it was created. ;;; For global variables, it doesn't have a meaning. (functions-setting nil) (functions-reading nil) ;;; Functions in which the variable has been modified or read. (loc 'OBJECT) ;;; During Pass 1: indicates whether the variable can ;;; be allocated on the c-stack: OBJECT means ;;; the variable is declared as OBJECT, and CLB means ;;; the variable is referenced across Level Boundary and thus ;;; cannot be allocated on the C stack. Note that OBJECT is ;;; set during variable binding and CLB is set when the ;;; variable is used later, and therefore CLB may supersede ;;; OBJECT. ;;; During Pass 2: ;;; For :FIXNUM, :CHAR, :FLOAT, :DOUBLE, :OBJECT: ;;; the cvar for the C variable that holds the value. ;;; For LEXICAL or CLOSURE: the frame-relative address for ;;; the variable in the form of a cons '(lex-levl . lex-ndx) ;;; lex-levl is the level of lexical environment ;;; lex-ndx is the index within the array for this env. ;;; For SPECIAL and GLOBAL: the vv-index for variable name. (type t) ;;; Type of the variable. #-new-cmp (index -1) ;;; position in *vars*. Used by similar. #-new-cmp (ignorable nil) ;;; Whether there was an IGNORABLE/IGNORE declaration #+new-cmp read-only-p ;;; T for variables that are assigned only once. ) ;;; A function may be compiled into a CFUN, CCLOSURE or CCLOSURE+LISP_CLOSURE ;;; Here are examples of function FOO for the 3 cases: ;;; 1. (flet ((foo () (bar))) (foo)) CFUN ;;; 2. (flet ((foo () (bar))) #'foo) CFUN+LISP_CFUN ;;; 3. (flet ((foo () x)) #'(lambda () (foo))) CCLOSURE ;;; 4. (flet ((foo () x)) #'foo) CCLOSURE+LISP_CLOSURE ;;; A function can be referenced across a ccb without being a closure, e.g: ;;; (flet ((foo () (bar))) #'(lambda () (foo))) ;;; [the lambda also need not be a closure] ;;; and it can be a closure without being referenced across ccb, e.g.: ;;; (flet ((foo () x)) #'foo) [ is this a mistake in local-function-ref?] ;;; Here instead the lambda must be a closure, but no closure is needed for foo ;;; (flet ((foo () x)) #'(lambda () (foo))) ;;; So we use two separate fields: ref-ccb and closure. ;;; A CCLOSURE must be created for a function when: ;;; 1. it appears within a FUNCTION construct and ;;; 2. it uses some ccb references (directly or indirectly). ;;; ref-ccb corresponds to the first condition, i.e. function is referenced ;;; across CCB. It is computed during Pass 1. A value of 'RETURNED means ;;; that it is immediately within FUNCTION. ;;; closure corresponds to second condition and is computed in Pass 2 by ;;; looking at the info-referenced-vars and info-local-referenced of its body. ;;; A LISP_CFUN or LISP_CLOSURE must be created when the function is returned. ;;; The LISP funob may then be referenced locally or across LB or CB: ;;; (flet ((foo (z) (bar z))) (list #'foo))) ;;; (flet ((foo (z) z)) (flet ((bar () #'foo)) (bar))) ;;; (flet ((foo (z) (bar z))) #'(lambda () #'foo))) ;;; therefore we need field funob. (defstruct (fun (:include ref)) ; name ;;; Function name. ; (ref 0 :type fixnum) ;;; Number of references. ;;; During Pass1, T or NIL. ;;; During Pass2, the vs-address for the ;;; function closure, or NIL. ; ref-ccb ;;; Cross closure reference. ;;; During Pass1, T or NIL, depending on whether a ;;; function object will be built. ;;; During Pass2, the vs-address for the function ;;; closure, or NIL. ; ref-clb ;;; Unused. ; read-nodes ;;; Nodes (c1forms) in which the reference occurs cfun ;;; The cfun for the function. #+new-cmp (last-lcl 0) ;;; Number of local variables (just to bookkeep names) #+new-cmp (last-label 0) ;;; Number of generated labels (same as last-lcl) (level 0) ;;; Level of lexical nesting for a function. (env 0) ;;; Size of env of closure. (global nil) ;;; Global lisp function. (exported nil) ;;; Its C name can be seen outside the module. (no-entry nil) ;;; NIL if declared as C-LOCAL. Then we create no ;;; function object and the C function is called ;;; directly (shares-with nil) ;;; T if this function shares the C code with another one. ;;; In that case we need not emit this one. closure ;;; During Pass2, T if env is used inside the function var ;;; the variable holding the funob description ;;; Text for the object, in case NAME == NIL. #+new-cmp lambda-list ;;; List of (requireds optionals rest-var keywords-p ;;; keywords allow-other-keys-p) lambda ;;; Lambda c1-form for this function. lambda-expression ;;; LAMBDA or LAMBDA-BLOCK expression (minarg 0) ;;; Min. number arguments that the function receives. (maxarg call-arguments-limit) ;;; Max. number arguments that the function receives. (return-type '(VALUES &REST T)) #+new-cmp doc ;;; Documentation (parent *current-function*) ;;; Parent function, NIL if global. (local-vars nil) ;;; List of local variables created here. (referenced-vars nil) ;;; List of external variables referenced here. (referenced-funs nil) ;;; List of external functions called in this one. ;;; We only register direct calls, not calls via object. (referencing-funs nil);;; Functions that reference this one (child-funs nil) ;;; List of local functions defined here. #+new-cmp (debug 0) ;;; Debug quality (file (car ext:*source-location*)) ;;; Source file or NIL (file-position (or (cdr ext:*source-location*) *compile-file-position*)) ;;; Top-level form number in source file #+new-cmp (toplevel-form *current-toplevel-form*) #+new-cmp code-gen-props ;;; Extra properties for code generation (cmp-env (cmp-env-copy)) ;;; Environment required-lcls ;;; Names of the function arguments ) (defstruct (blk (:include ref)) ; name ;;; Block name. ; (ref 0 :type fixnum) ;;; Number of references. ; ref-ccb ;;; Cross closure reference. ;;; During Pass1, T or NIL. ;;; During Pass2, the ccb-lex for the ;;; block id, or NIL. ; ref-clb ;;; Cross local function reference. ;;; During Pass1, T or NIL. ;;; During Pass2, the lex-address for the ;;; block id, or NIL. ; read-nodes ;;; Nodes (c1forms) in which the reference occurs exit ;;; Where to return. A label. destination ;;; Where the value of the block to go. var ;;; Variable containing the block ID. #-new-cmp (type '(VALUES &REST T)) ;;; Estimated type. #+new-cmp env ;;; Block environment. ) (defstruct (tag (:include ref)) ; name ;;; Tag name. ; (ref 0 :type fixnum) ;;; Number of references. ; ref-ccb ;;; Cross closure reference. ;;; During Pass1, T or NIL. ; ref-clb ;;; Cross local function reference. ;;; During Pass1, T or NIL. ; read-nodes ;;; Nodes (c1forms) in which the reference occurs label ;;; Where to jump: a label. unwind-exit ;;; Where to unwind-no-exit. var ;;; Variable containing frame ID. index ;;; An integer denoting the label. #+new-cmp env ;;; Tag environment. ) (defstruct (info) (local-vars nil) ;;; List of var-objects created directly in the form. #-new-cmp (type '(VALUES &REST T)) ;;; Type of the form. (sp-change nil) ;;; Whether execution of the form may change ;;; the value of a special variable. (volatile nil) ;;; whether there is a possible setjmp. Beppe ) (defstruct (inline-info) name ;;; Function name arg-rep-types ;;; List of representation types for the arguments return-rep-type ;;; Representation type for the output arg-types ;;; List of lisp types for the arguments return-type ;;; Lisp type for the output exact-return-type ;;; Only use this expansion when the output is ;;; declared to have a subtype of RETURN-TYPE multiple-values ;;; Works with all destinations, including VALUES / RETURN expansion ;;; C template containing the expansion one-liner ;;; Whether the expansion spans more than one line ) (defstruct (c1form (:include info) (:print-object print-c1form) (:constructor do-make-c1form)) (name nil) (parents nil) #+new-cmp (env (c-env:cmp-env-copy)) ;; Environment in which this form was compiled #-new-cmp (env (cmp-env-copy)) ;; Environment in which this form was compiled (args '()) (side-effects nil) ;;; Does it have side effects (form nil) (toplevel-form nil) (file nil) (file-position 0)) (defstruct vv (location nil) (used-p nil) (permanent-p t) (value nil)) (defstruct machine (c-types '()) rep-type-hash sorted-types inline-information) (defstruct (rep-type (:constructor %make-rep-type)) (index 0) ; Precedence order in the type list (name t) (lisp-type t) (bits nil) (numberp nil) (integerp nil) (c-name nil) (to-lisp nil) (from-lisp nil) (from-lisp-unsafe nil)) ecl-16.1.2/src/cmp/cmputil.lsp000066400000000000000000000341651266352375300161340ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: C -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; CMPUTIL -- Miscellaneous Functions. ;;;; Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. ;;;; Copyright (c) 1990, Giuseppe Attardi. ;;;; ;;;; ECoLisp is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. #-new-cmp (in-package "COMPILER") #+new-cmp (in-package "C-LOG") #+cmu-format (progn (defconstant +note-format+ "~&~@< ~;~?~;~:@>") (defconstant +warn-format+ "~&~@< ! ~;~?~;~:@>") (defconstant +error-format+ "~&~@< * ~;~?~;~:@>") (defconstant +fatal-format+ "~&~@< ** ~;~?~;~:@>")) #-cmu-format (progn (defconstant +note-format+ "~& ~?") (defconstant +warn-format+ "~& ! ~?") (defconstant +error-format+ "~& * ~?") (defconstant +fatal-format+ "~& ** ~?")) ;; Return a namestring for a path that is sufficiently ;; unambiguous (hopefully) for the C compiler (and associates) ;; to decipher. (defun brief-namestring (path) ;; In Windows we cannot use enough-namestring in the compiler ;; because it breaks down when using paths such as ;; c:/docume~1/juanjo/locals~1/temp/foo.tmp. enough-namestring would ;; return /docume~1/juanjo/locals~1/temp/foo.tmp which is not found #+windows (namestring (si::coerce-to-filename path)) #-windows (enough-namestring (si::coerce-to-filename path))) (defun innermost-non-expanded-form (form) (when (listp form) (loop with output = nil for f in form do (cond ((eq f 'macroexpand) (setf output nil)) ((null output) (setf output f))) finally (return output)))) ;; For indirect use in :REPORT functions (defun compiler-message-report (stream c format-control &rest format-arguments) (let ((position (compiler-message-file-position c)) (prefix (compiler-message-prefix c)) (file (compiler-message-file c)) (form (innermost-non-expanded-form (compiler-message-toplevel-form c)))) (if (and form position (not (minusp position)) (not (equalp form '|compiler preprocess|))) (let* ((*print-length* 2) (*print-level* 2)) (format stream "~A:~% in file ~A, position ~D~& at ~A" prefix (make-pathname :name (pathname-name file) :type (pathname-type file) :version (pathname-version file)) position form)) (format stream "~A:" prefix)) (format stream (compiler-message-format c) format-control format-arguments))) (define-condition compiler-message (simple-condition) ((prefix :initform "Note" :accessor compiler-message-prefix) (format :initform +note-format+ :accessor compiler-message-format) (file :initarg :file :initform *compile-file-pathname* :accessor compiler-message-file) (position :initarg :file :initform *compile-file-position* :accessor compiler-message-file-position) (toplevel-form :initarg :form :initform *current-toplevel-form* :accessor compiler-message-toplevel-form) (form :initarg :form :initform *current-form* :accessor compiler-message-form)) (:report (lambda (c stream) (apply #'compiler-message-report stream c (simple-condition-format-control c) (simple-condition-format-arguments c))))) (define-condition compiler-note (compiler-message) ()) (define-condition compiler-debug-note (compiler-note) ()) (define-condition compiler-warning (compiler-message style-warning) ((prefix :initform "Warning") (format :initform +warn-format+))) (define-condition compiler-macro-expansion-failed (compiler-warning) ()) (define-condition compiler-error (compiler-message) ((prefix :initform "Error") (format :initform +error-format+))) (define-condition compiler-fatal-error (compiler-error) ((format :initform +fatal-format+))) (define-condition compiler-internal-error (compiler-fatal-error) ((prefix :initform "Internal error"))) (define-condition compiler-style-warning (compiler-message style-warning) ((prefix :initform "Style warning") (format :initform +warn-format+))) (define-condition compiler-undefined-variable (compiler-style-warning) ((variable :initarg :name :initform nil)) (:report (lambda (c stream) (compiler-message-report stream c "Variable ~A was undefined. ~ Compiler assumes it is a global." (slot-value c 'variable))))) (defun print-compiler-message (c stream) (unless (typep c *suppress-compiler-messages*) #+cmu-format (format stream "~&~@<;;; ~@;~A~:>" c) #-cmu-format (format stream "~&;;; ~A" c))) ;;; A few notes about the following handlers. We want the user to be ;;; able to capture, collect and perhaps abort on the different ;;; conditions signaled by the compiler. Since the compiler uses ;;; HANDLER-BIND, the only way to let this happen is either let the ;;; handler return or use SIGNAL at the beginning of the handler and ;;; let the outer handler intercept. ;;; ;;; In neither case do we want to enter the the debugger. That means ;;; we can not derive the compiler conditions from SERIOUS-CONDITION. ;;; (defun handle-compiler-note (c) (declare (ignore c)) nil) (defun handle-compiler-warning (c) (push c *compiler-conditions*) nil) (defun handle-compiler-error (c) (signal c) (push c *compiler-conditions*) (print-compiler-message c t) (abort)) (defun handle-compiler-internal-error (c) (when *compiler-break-enable* (invoke-debugger c)) (setf c (make-condition 'compiler-internal-error :format-control "~A" :format-arguments (list c))) (push c *compiler-conditions*) (signal c) (print-compiler-message c t) (abort)) (defun do-compilation-unit (closure &key override) (cond (override (let* ((*active-protection* nil)) (do-compilation-unit closure))) ((null *active-protection*) (let* ((*active-protection* t) (*pending-actions* nil)) (unwind-protect (do-compilation-unit closure) (loop for action in *pending-actions* do (funcall action))))) (t (funcall closure)))) (defmacro with-compilation-unit ((&rest options) &body body) `(do-compilation-unit #'(lambda () ,@body) ,@options)) (defmacro with-compiler-env ((compiler-conditions) &body body) `(let ((*compiler-conditions* nil)) (declare (special *compiler-conditions*)) (restart-case (handler-bind ((compiler-note #'handle-compiler-note) (warning #'handle-compiler-warning) (compiler-error #'handle-compiler-error) (compiler-internal-error #'handle-compiler-internal-error) (serious-condition #'handle-compiler-internal-error)) (mp:with-lock (+load-compile-lock+) (let ,+init-env-form+ (with-compilation-unit () ,@body)))) (abort ())) (setf ,compiler-conditions *compiler-conditions*))) (defvar *c1form-level* 0) (defun print-c1forms (form) (cond ((consp form) (let ((*c1form-level* (1+ *c1form-level*))) (mapc #'print-c1forms form))) ((c1form-p form) (format t "~% ~D > ~A, parent ~A" *c1form-level* form (c1form-parent form)) (print-c1forms (c1form-args form)) form ))) (defun print-ref (ref-object stream) (let ((name (ref-name ref-object))) (if name (format stream "#" (type-of ref-object) name) (format stream "#" (type-of ref-object))))) (defun print-var (var-object stream) (format stream "#" (var-name var-object) (var-kind var-object))) (defun cmpprogress (&rest args) (when *compile-verbose* (apply #'format t args))) (defmacro cmpck (condition string &rest args) `(if ,condition (cmperr ,string ,@args))) (defmacro cmpassert (condition string &rest args) `(unless ,condition (cmperr ,string ,@args))) (defun cmperr (string &rest args) (let ((c (make-condition 'compiler-error :format-control string :format-arguments args))) (signal c) (print-compiler-message c t) (abort))) (defun safe-list-length (l) ;; Computes the length of a proper list or returns NIL if it ;; is a circular list or terminates with a non-NIL atom. (declare (optimize (speed 3) (safety 0))) (loop with slow = l with fast = l with flag = t for l of-type fixnum from 0 do (cond ((null fast) (return l)) ((not (consp fast)) (return nil)) (flag (setf flag nil fast (cdr (truly-the cons fast)))) ((eq slow fast) (return nil)) (t (setf flag t slow (cdr (truly-the cons slow)) fast (cdr (truly-the cons fast))))) finally (return l))) (defun check-args-number (operator args &optional (min 0) (max most-positive-fixnum)) (let ((l (safe-list-length args))) (when (null l) (let ((*print-circle* t)) (cmperr "Improper or circular list passed to ~A~%~A" operator args))) (when (< l min) (too-few-args operator min l)) (when (and max (> l max)) (too-many-args operator max l)))) (defun too-many-args (name upper-bound n &aux (*print-case* :upcase)) (cmperr "~S requires at most ~R argument~:p, but ~R ~:*~[were~;was~:;were~] supplied.~%" name upper-bound n)) (defun too-few-args (name lower-bound n) (cmperr "~S requires at least ~R argument~:p, but only ~R ~:*~[were~;was~:;were~] supplied.~%" name lower-bound n)) (defun do-cmpwarn (&rest args) (declare (si::c-local)) (let ((condition (apply #'make-condition args))) (restart-case (signal condition) (muffle-warning () :REPORT "Skip warning" (return-from do-cmpwarn nil))) (print-compiler-message condition t))) (defun cmpwarn-style (string &rest args) (do-cmpwarn 'compiler-style-warning :format-control string :format-arguments args)) (defun cmpwarn (string &rest args) (do-cmpwarn 'compiler-warning :format-control string :format-arguments args)) (defun cmpnote (string &rest args) (do-cmpwarn 'compiler-note :format-control string :format-arguments args)) #-new-cmp (defun cmpdebug (string &rest args) (do-cmpwarn 'compiler-debug-note :format-control string :format-arguments args)) (defun print-current-form () (when *compile-print* (let ((*print-length* 2) (*print-level* 2)) (format t "~&;;; Compiling ~s.~%" (innermost-non-expanded-form *current-toplevel-form*)))) nil) (defun print-emitting (f) (when *compile-print* (let* ((name (or (fun-name f) (fun-description f)))) (when name (format t "~&;;; Emitting code for ~s.~%" name))))) (defun undefined-variable (sym) (do-cmpwarn 'compiler-undefined-variable :name sym)) (defun baboon (&key (format-control "A bug was found in the compiler") format-arguments) (signal 'compiler-internal-error :format-control format-control :format-arguments format-arguments)) (defmacro with-cmp-protection (main-form error-form) `(let* ((si::*break-enable* *compiler-break-enable*) (throw-flag t)) (unwind-protect (multiple-value-prog1 (if *compiler-break-enable* (handler-bind ((error #'invoke-debugger)) ,main-form) ,main-form) (setf throw-flag nil)) (when throw-flag ,error-form)))) (defun cmp-eval (form &optional (env *cmp-env*)) (handler-case (si::eval-with-env form env nil t t) (serious-condition (c) (when *compiler-break-enable* (invoke-debugger c)) (cmperr "The form ~s was not evaluated successfully.~%Error detected:~%~A" form c) nil))) ;;; Like macro-function except it searches the lexical environment, ;;; to determine if the macro is shadowed by a function or a macro. (defun cmp-macro-function (name) (or (cmp-env-search-macro name) (macro-function name))) (defun cmp-expand-macro (fd form &optional (env *cmp-env*)) (handler-case (let ((new-form (funcall *macroexpand-hook* fd form env))) (values new-form (not (eql new-form form)))) (serious-condition (c) (when *compiler-break-enable* (invoke-debugger c)) (cmperr "The macro form ~s was not expanded successfully.~%Error detected:~%~A" form c) (values nil nil)))) (defun cmp-expand-compiler-macro (fd fname args &optional (env *cmp-env*)) (handler-case (cmp-expand-macro fd (list* fname args) env) (serious-condition (c) (do-cmpwarn 'compiler-macro-expansion-failed :format-control "The expansion of the compiler macro~%~T~A~%was aborted because of a serious condition~%~A" :format-arguments (list fname c)) (values nil nil)))) (defun si::compiler-clear-compiler-properties (symbol) (rem-sysprop symbol 't1) (rem-sysprop symbol 't2) (rem-sysprop symbol 't3) #-new-cmp(rem-sysprop symbol 'c1) #-new-cmp(rem-sysprop symbol 'c2) #-new-cmp(rem-sysprop symbol 'c1conditional) (rem-sysprop symbol 'lfun)) #-new-cmp (defun lisp-to-c-name (obj) "Translate Lisp object prin1 representation to valid C identifier name" (and obj (map 'string #'(lambda (c) (let ((cc (char-code c))) (if (or (<= #.(char-code #\a) cc #.(char-code #\z)) (<= #.(char-code #\0) cc #.(char-code #\9))) c #\_))) (string-downcase (prin1-to-string obj))))) ecl-16.1.2/src/cmp/cmpvar.lsp000066400000000000000000000412771266352375300157510ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: C -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. ;;;; Copyright (c) 1990, Giuseppe Attardi. ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. ;;;; CMPVAR Variables. (in-package "COMPILER") (defun make-var (&rest args) (let ((var (apply #'%make-var args))) (unless (member (var-kind var) '(SPECIAL GLOBAL)) (when *current-function* (push var (fun-local-vars *current-function*)))) var)) (defun var-referenced-in-form-list (var form-list) (loop for f in form-list thereis (var-referenced-in-form var f))) (defun var-changed-in-form-list (var form-list) (loop for f in form-list thereis (var-changed-in-form var f))) ;;; FIXME! VAR-REFERENCED-IN-FORM and VAR-CHANGED-IN-FORM are too ;;; pessimistic. One should check whether the functions reading/setting the ;;; variable are actually called from the given node. The problem arises when ;;; we create a closure of a function, as in ;;; ;;; (let* ((a 1) (b #'(lambda () (incf a)))) ...) ;;; ;;; To know whether A is changed or read, we would have to track where B is ;;; actually used. (defun var-referenced-in-form (var form) (declare (type var var)) (or (find-form-in-node-list form (var-read-nodes var)) (var-functions-reading var))) (defun var-changed-in-form (var form) (declare (type var var)) (or (find-form-in-node-list form (var-set-nodes var)) (let ((kind (var-kind var))) (if (or (eq kind 'SPECIAL) (eq kind 'GLOBAL)) (c1form-sp-change form) (var-functions-setting var))))) (defun update-variable-type (var orig-type) ;; FIXME! Refuse to update type of variables that are modified (when (var-set-nodes var) (return-from update-variable-type)) (let ((type (type-and (var-type var) orig-type))) (if (null type) (cmpwarn "Variable assigned a value incompatible with its type declaration.~%Variable: ~A~%Expected type: ~A~%Value type: ~A" (var-name var) (var-type var) orig-type) (loop for form in (var-read-forms var) when (and (eq (c1form-name form) 'VAR) (eq var (c1form-arg 0 form))) do (setf (c1form-type form) (type-and type (c1form-primary-type form))) finally (setf (var-type var) type))))) (defun var-read-forms (var) (mapcar #'first (var-read-nodes var))) (defun assert-var-ref-value (var) #+debug-compiler (unless (let ((ref (var-ref var))) (or (> ref (/ most-positive-fixnum 2)) (= (var-ref var) (+ (length (var-read-nodes var)) (length (var-set-nodes var)))))) (baboon :format-control "Number of references in VAR ~A unequal to references list" :format-arguments (list var)))) (defun assert-var-not-ignored (var) (when (let ((x (var-ignorable var))) (and x (minusp x))) (cmpwarn-style "Variable ~A, declared as IGNORE, found in a lisp form." (var-name var)) (setf (var-ignorable var) nil))) (defun delete-from-read-nodes (var form) (assert-var-ref-value var) (setf (var-ref var) (1- (var-ref var)) (var-read-nodes var) (delete-form-from-node-list form (var-read-nodes var)))) (defun add-to-read-nodes (var form) (assert-var-ref-value var) (assert-var-not-ignored var) (setf (var-ref var) (1+ (var-ref var)) (var-read-nodes var) (add-form-to-node-list form (var-read-nodes var))) (when *current-function* (unless (eq *current-function* (var-function var)) (pushnew *current-function* (var-functions-reading var)) (pushnew var (fun-referenced-vars *current-function*)))) form) (defun add-to-set-nodes (var form) (assert-var-ref-value var) (assert-var-not-ignored var) (setf (var-ref var) (1+ (var-ref var)) (var-set-nodes var) (add-form-to-node-list form (var-set-nodes var))) ;;(push form (var-read-nodes var)) (when *current-function* (unless (eq *current-function* (var-function var)) (pushnew *current-function* (var-functions-setting var)) (pushnew var (fun-referenced-vars *current-function*)))) form) (defun add-to-set-nodes-of-var-list (var-list form) (dolist (v var-list) (add-to-set-nodes v form)) form) ;;; A special binding creates a var object with the kind field SPECIAL, ;;; whereas a special declaration without binding creates a var object with ;;; the kind field GLOBAL. Thus a reference to GLOBAL may need to make sure ;;; that the variable has a value. ;;; Bootstrap problem: proclaim needs this function: ;;; ;;; Check if a variable has been declared as a special variable with a global ;;; value. (defun check-global (name) (member name *global-vars*)) (defun special-variable-p (name) "Return true if NAME is associated to a special variable in the lexical environment." (or (si::specialp name) (check-global name) (let ((v (cmp-env-search-var name *cmp-env-root*))) ;; Fixme! Revise the declamation code to ensure whether ;; we also have to consider 'GLOBAL here. (and v (eq (var-kind v) 'SPECIAL))))) (defun local-variable-p (name &optional (env *cmp-env*)) (let ((record (cmp-env-search-var name env))) (and record (var-p record)))) (defun symbol-macro-p (name &optional (env *cmp-env*)) (let ((record (cmp-env-search-var name env))) (and record (not (var-p record))))) (defun variable-type-in-env (name &optional (env *cmp-env*)) (multiple-value-bind (var ccb clb unw) (cmp-env-search-var name) (cond ((var-p var) (var-type var)) ((get-sysprop name 'CMP-TYPE)) (t)))) ;;; ;;; Check if the symbol has a symbol macro ;;; (defun chk-symbol-macrolet (form) (loop (when (not (symbolp form)) (return form)) (let ((new-form (macroexpand-1 form *cmp-env*))) (when (eq new-form form) (return form)) (setf form new-form)))) (defun c1make-var (name specials ignores types) (cmpck (not (symbolp name)) "The variable ~s is not a symbol." name) (cmpck (constantp name) "The constant ~s is being bound." name) (let ((ignorable (cdr (assoc name ignores))) (kind 'LEXICAL) ; we rely on check-vref to fix it (type (assoc name types))) (cond ((null type) (setq type 'T)) ((machine-c-type-p (setq type (cdr type))) (setf kind type type (rep-type->lisp-type type)))) (cond ((or (member name specials) (special-variable-p name)) (unless (eq kind 'LEXICAL) (cmperr "Special variable ~A cannot be declared to have C type ~A" name type)) (when (eq type 'T) (setf type (or (get-sysprop name 'CMP-TYPE) 'T))) (c1make-global-variable name :kind 'SPECIAL :type type)) (t (make-var :name name :type type :loc 'OBJECT :kind kind :ignorable ignorable :ref 0))))) (defun check-vref (var) (when (eq (var-kind var) 'LEXICAL) (when (and (zerop (var-ref var)) ;;; This field may be -1 (IGNORE). Beppe (not (var-ignorable var))) (cmpwarn-style "The variable ~s is not used." (var-name var))) (when (not (var-ref-clb var)) ;; if the variable can be stored locally, set it var-kind to its type (setf (var-kind var) (if (plusp (var-ref var)) (lisp-type->rep-type (var-type var)) :OBJECT))))) (defun c1var (name) (let* ((var (c1vref name)) (output (make-c1form* 'VAR :type (var-type var) :args var))) (add-to-read-nodes var output) output)) (defun make-lcl-var (&key rep-type (type 'T)) (unless rep-type (setq rep-type (if type (lisp-type->rep-type type) :object))) (unless type (setq type 'T)) (make-var :kind rep-type :type type :loc (next-lcl))) (defun make-temp-var (&optional (type 'T)) (make-var :kind :object :type type :loc `(TEMP ,(next-temp)))) ;;; A variable reference (vref for short) is a list: pair ;;; ( var-object ) Beppe(ccb) ccb-reference ) (defun c1vref (name) (multiple-value-bind (var ccb clb unw) (cmp-env-search-var name) (cond ((null var) (c1make-global-variable name :warn t :type (or (get-sysprop name 'CMP-TYPE) t))) ((not (var-p var)) ;; symbol-macrolet (baboon)) (t (case (var-kind var) ((SPECIAL GLOBAL)) ((CLOSURE)) ((LEXICAL) (cond (ccb (setf (var-ref-clb var) nil ; replace a previous 'CLB (var-ref-ccb var) t (var-kind var) 'CLOSURE (var-loc var) 'OBJECT)) (clb (setf (var-ref-clb var) t (var-loc var) 'OBJECT)))) (t (when (or clb ccb) (cmperr "Variable ~A declared of C type cannot be referenced across function boundaries." (var-name var))))) var)))) (defun push-vars (v) (setf (var-index v) (length (cmp-env-variables))) (cmp-env-register-var v)) (defun unboxed (var) (not (eq (var-rep-type var) :object))) (defun local (var) (and (not (member (var-kind var) '(LEXICAL CLOSURE SPECIAL GLOBAL))) (var-kind var))) (defun global-var-p (var) (let ((kind (var-kind var))) (or (eq kind 'global) (eq kind 'special)))) (defun useful-var-p (var) (or (plusp (var-ref var)) (global-var-p var))) (defun c2var/location (c1form loc) #+(or) (unwind-exit loc) (unwind-exit (precise-loc-type loc (c1form-primary-type c1form)))) (defun wt-var (var) (declare (type var var)) (let ((var-loc (var-loc var))) (case (var-kind var) (CLOSURE (wt-env var-loc)) (LEXICAL (wt-lex var-loc)) ((SPECIAL GLOBAL) (if (safe-compile) (wt "ecl_symbol_value(" var-loc ")") (wt "ECL_SYM_VAL(cl_env_copy," var-loc ")"))) (t (wt var-loc)) ))) (defun var-rep-type (var) (case (var-kind var) ((LEXICAL CLOSURE SPECIAL GLOBAL) :object) (t (var-kind var)))) (defun set-var (loc var &aux (var-loc (var-loc var))) ; ccb (unless (var-p var) (baboon)) (case (var-kind var) (CLOSURE (wt-nl)(wt-env var-loc)(wt " = ") (wt-coerce-loc (var-rep-type var) loc) (wt #\;)) (LEXICAL (wt-nl)(wt-lex var-loc)(wt " = ") (wt-coerce-loc (var-rep-type var) loc) (wt #\;)) ((SPECIAL GLOBAL) (if (safe-compile) (wt-nl "cl_set(" var-loc ",") (wt-nl "ECL_SETQ(cl_env_copy," var-loc ",")) (wt-coerce-loc (var-rep-type var) loc) (wt ");")) (t (wt-nl var-loc " = ") (wt-coerce-loc (var-rep-type var) loc) (wt #\;)) )) (defun wt-lex (lex) (if (consp lex) (wt "lex" (car lex) "[" (cdr lex) "]") (wt-lcl lex))) ;;; reference to variable of inner closure. (defun wt-env (clv) (wt "ECL_CONS_CAR(CLV" clv ")")) ;;; ---------------------------------------------------------------------- (defun c1make-global-variable (name &key (type (or (get-sysprop name 'CMP-TYPE) t)) (kind 'GLOBAL) (warn nil)) (let* ((var (make-var :name name :kind kind :type type :loc (add-symbol name)))) (when warn (unless (or (constantp name) (special-variable-p name) (member name *undefined-vars*)) (undefined-variable name) (push name *undefined-vars*))) var)) (defun c1declare-specials (globals) (mapc #'cmp-env-declare-special globals)) (defun si::register-global (name) (pushnew name *global-vars*) (values)) (defun c1setq (args) (let ((l (length args))) (cmpck (oddp l) "SETQ requires an even number of arguments.") (cond ((zerop l) (c1nil)) ((= l 2) (c1setq1 (first args) (second args))) (t (c1progn (loop while args collect `(setq ,(pop args) ,(pop args)))))))) (defun c1setq1 (name form) (cmpck (not (symbolp name)) "The variable ~s is not a symbol." name) (cmpck (constantp name) "The constant ~s is being assigned a value." name) (setq name (chk-symbol-macrolet name)) (if (symbolp name) (let* ((name (c1vref name)) (type (var-type name)) (form (c1expr (if (trivial-type-p type) form `(checked-value ,type ,form))))) (add-to-set-nodes name (make-c1form* 'SETQ :type (c1form-type form) :args name form))) `(setf ,name ,form))) (defun c2setq (c1form vref form) (declare (ignore c1form)) ;; First comes the assignement (let ((*destination* vref)) (c2expr* form)) ;; Then the returned value (if (eq (c1form-name form) 'LOCATION) (c2var/location form (c1form-arg 0 form)) (unwind-exit vref))) (defun c1progv (args) (check-args-number 'PROGV args 2) (let ((symbols (c1expr (first args))) (values (c1expr (second args))) (forms (c1progn (cddr args)))) (make-c1form* 'PROGV :type (c1form-type forms) :args symbols values forms))) (defun c2progv (c1form symbols values body) (declare (ignore c1form)) (let* ((*lcl* *lcl*) (lcl (next-lcl)) (sym-loc (make-lcl-var)) (val-loc (make-lcl-var)) (*unwind-exit* (cons lcl *unwind-exit*))) (wt-nl-open-brace) (wt-nl "cl_object " sym-loc ", " val-loc "; cl_index " lcl ";") (let ((*destination* sym-loc)) (c2expr* symbols)) (let ((*destination* val-loc)) (c2expr* values)) (wt-nl lcl " = ecl_progv(cl_env_copy, " sym-loc ", " val-loc ");") (c2expr body) (wt-nl-close-brace) )) (defun c1psetq (old-args &aux (args nil) (use-psetf nil)) ;; A first pass ensures that none of the assigned locations is ;; a SETF form. Otherwise we have to resort to PSETF. (do ((l old-args)) ((endp l)) (let ((var (pop l))) (cmpck (not (symbolp var)) "The variable ~s is not a symbol." var) (cmpck (endp l) "No form was given for the value of ~s." var) (setq var (chk-symbol-macrolet var)) (setq args (nconc args (list var (pop l)))) (if (symbolp var) (cmpck (constantp var) "The constant ~s is being assigned a value." var) (setq use-psetf t)))) (when use-psetf (return-from c1psetq `(psetf ,@args))) ;; In the second pass we compile the variable references and the ;; assignments. Here we may need to create checked values if the ;; variables have been proclaimed. (do ((vrefs '()) (forms '())) ((endp args) (add-to-set-nodes-of-var-list vrefs (make-c1form* 'PSETQ :type '(MEMBER NIL) :args (reverse vrefs) (nreverse forms)))) (let* ((vref (c1vref (pop args))) (type (var-type vref)) (form (pop args))) (push vref vrefs) (push (c1expr (if (trivial-type-p type) form `(checked-value ,type ,form))) forms)))) (defun c2psetq (c1form vrefs forms &aux (*lcl* *lcl*) (saves nil) (braces *opened-c-braces*)) (declare (ignore c1form)) ;; similar to inline-args (do ((vrefs vrefs (cdr vrefs)) (forms forms (cdr forms)) (var) (form)) ((null vrefs)) (setq var (first vrefs) form (car forms)) (if (or (var-changed-in-form-list var (rest forms)) (var-referenced-in-form-list var (rest forms))) (case (c1form-name form) (LOCATION (push (cons var (c1form-arg 0 form)) saves)) (otherwise (if (local var) (let* ((rep-type (var-rep-type var)) (rep-type-c-name (rep-type->c-name rep-type)) (temp (make-lcl-var :rep-type rep-type))) (wt-nl-open-brace) (wt-nl rep-type-c-name " " *volatile* temp ";") (let ((*destination* temp)) (c2expr* form)) (push (cons var temp) saves)) (let ((*destination* (make-temp-var))) (c2expr* form) (push (cons var *destination*) saves))))) (let ((*destination* var)) (c2expr* form)))) (dolist (save saves) (set-var (cdr save) (car save))) (wt-nl-close-many-braces braces) (unwind-exit nil) ) ecl-16.1.2/src/cmp/cmpwt.lsp000066400000000000000000000334651266352375300156130ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: C -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;;; Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. ;;;; Copyright (c) 1990, Giuseppe Attardi. ;;;; ;;;; This program is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Library General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 2 of the License, or (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. ;;;; CMPWT Output routines. (in-package "COMPILER") ;;; ====================================================================== ;;; ;;; DATA FILES ;;; ;;; Each lisp compiled file consists on code and a data section. Whenever an ;;; #'in-package toplevel form is found, a read-time evaluated expression is ;;; inserted in the data section which changes the current package for the ;;; rest of it. This way it is possible to save some space by writing the ;;; symbol's package only when it does not belong to the current package. (defun data-permanent-storage-size () (length *permanent-objects*)) (defun data-temporary-storage-size () (length *temporary-objects*)) (defun data-size () (+ (data-permanent-storage-size) (data-temporary-storage-size))) (defun data-init (&optional filename) (if (and filename (probe-file filename)) (with-open-file (s filename :direction :input) (setf *permanent-objects* (read s) *temporary-objects* (read s))) (setf *permanent-objects* (make-array 128 :adjustable t :fill-pointer 0) *temporary-objects* (make-array 128 :adjustable t :fill-pointer 0)))) (defun data-get-all-objects () ;; We collect all objects that are to be externalized, but filter out ;; those which will be created by a lisp form. (loop for array in (list *permanent-objects* *temporary-objects*) nconc (loop for (object vv-record . rest) across array collect (cond ((gethash object *load-objects*) 0) ((vv-used-p vv-record) object) (t ;; Value optimized away or not used 0)))) #+(or) (loop for i in (nconc (map 'list #'first *permanent-objects*) (map 'list #'first *temporary-objects*)) collect (if (gethash i *load-objects*) 0 i))) (defun data-dump-array () (cond (*compiler-constants* (setf si::*compiler-constants* (concatenate 'vector (data-get-all-objects))) "") #+externalizable ((plusp (data-size)) (let* ((data-vector (concatenate 'vector (data-get-all-objects)))) (si::serialize data-vector))) #-externalizable ((plusp (data-size)) (let* ((*wt-string-size* 0) (*wt-data-column* 80) (data (data-get-all-objects)) (data-string (si::with-ecl-io-syntax (prin1-to-string data))) (l (length data-string))) (subseq data-string 1 (1- l)))) (t ""))) (defun data-c-dump (filename) (labels ((produce-strings () ;; Only Windows has a size limit in the strings it creates. #-windows (let ((s (data-dump-array))) (when (plusp (length s)) (list s))) #+windows (loop with string = (data-dump-array) with max-string-size = 65530 with l = (length string) for i from 0 below l by max-string-size for this-l = (min (- l i) max-string-size) collect (make-array this-l :displaced-to string :element-type 'character :displaced-index-offset i))) (output-one-c-string (name string stream) (let* ((*wt-string-size* 0) (*wt-data-column* 80) (s (with-output-to-string (stream) (wt-filtered-data string stream)))) (format stream "static const struct ecl_base_string ~A[] = { (int8_t)t_base_string, 0, ecl_aet_bc, 0, ECL_NIL, (cl_index)~D, (cl_index)~D, (ecl_base_char*)~A };~%" name *wt-string-size* *wt-string-size* s) name)) (output-c-strings (strings stream) (format stream "~%static const cl_object compiler_data_text[] = {~{~%(cl_object)~A,~}~%NULL};" (loop for s in strings for i from 1 for name = (format nil "compiler_data_text~D" i) collect (output-one-c-string name s stream))))) (with-open-file (stream filename :direction :output :if-does-not-exist :create :if-exists :supersede :external-format :default) (let ((strings (produce-strings))) (if strings (output-c-strings strings stream) (princ "#define compiler_data_text NULL" stream)) ;; Ensure a final newline or some compilers complain (terpri stream))))) (defun data-empty-loc () (add-object 0 :duplicate t :permanent t)) (defun add-load-form (object location) (when (clos::need-to-make-load-form-p object *cmp-env*) (if (not (eq *compiler-phase* 't1)) (cmperr "Unable to internalize complex object ~A in ~a phase" object *compiler-phase*) (multiple-value-bind (make-form init-form) (make-load-form object) (setf (gethash object *load-objects*) location) (when make-form (push (make-c1form* 'MAKE-FORM :args location (c1expr make-form)) *make-forms*)) (when init-form (push (make-c1form* 'INIT-FORM :args location (c1expr init-form)) *make-forms*)))))) (defun add-object (object &key (duplicate nil) (permanent (or (symbolp object) *permanent-data*)) (used-p nil)) ;; FIXME! Currently we have two data vectors and, when compiling ;; files, it may happen that a constant is duplicated and stored ;; both in VV and VVtemp. This would not be a problem if the ;; constant were readable, but due to using MAKE-LOAD-FORM we may ;; end up having two non-EQ objects created for the same value. (let* ((test (if *compiler-constants* 'eq 'equal)) (array (if permanent *permanent-objects* *temporary-objects*)) (x (or (and (not permanent) (find object *permanent-objects* :test test :key #'first)) (find object array :test test :key #'first))) (next-ndx (length array)) (forced duplicate) found) (setq x (cond ((add-static-constant object)) ((and x duplicate) (setq x (make-vv :location next-ndx :used-p forced :permanent-p permanent :value object :used-p t)) (vector-push-extend (list object x next-ndx) array) x) (x (second x)) ((and (not duplicate) (symbolp object) (multiple-value-setq (found x) (si::mangle-name object))) x) (t (setq x (make-vv :location next-ndx :used-p forced :permanent-p permanent :value object :used-p used-p)) (vector-push-extend (list object x next-ndx) array) (unless *compiler-constants* (add-load-form object x)) x))) (when (and used-p (typep x 'vv)) (setf (vv-used-p x) t)) x)) (defun add-symbol (symbol) (add-object symbol :duplicate nil :permanent t)) (defun add-keywords (keywords) ;; We have to build, in the vector VV[], a sequence with all ;; the keywords that this function uses. It does not matter ;; whether each keyword has appeared separately before, because ;; cl_parse_key() needs the whole list. However, we can reuse ;; keywords lists from other functions when they coincide with ours. ;; We search for keyword lists that are similar. However, the list ;; *OBJECTS* contains elements in decreasing order!!! (let ((x (search keywords *permanent-objects* :test #'(lambda (k record) (eq k (first record)))))) (if x (second (elt *permanent-objects* x)) (prog1 (add-object (pop keywords) :duplicate t :permanent t) (dolist (k keywords) (add-object k :duplicate t :permanent t)))))) ;;; ====================================================================== ;;; ;;; STATIC CONSTANTS ;;; (defun static-base-string-builder (name value stream) (format stream "ecl_def_ct_base_string(~A," name) (wt-filtered-data value stream :one-liner t) (format stream ",~D,static,const);" (length value))) (defun static-single-float-builder (name value stream) (let* ((*read-default-float-format* 'single-float) (*print-readably* t)) (format stream "ecl_def_ct_single_float(~A,~S,static,const);" name value stream))) (defun static-double-float-builder (name value stream) (let* ((*read-default-float-format* 'double-float) (*print-readably* t)) (format stream "ecl_def_ct_double_float(~A,~S,static,const);" name value stream))) #+long-float (defun static-long-float-builder (name value stream) (let* ((*read-default-float-format* 'long-float) (*print-readably* t)) (format stream "ecl_def_ct_long_float(~A,~SL,static,const);" name value stream))) (defun static-rational-builder (name value stream) (let* ((*read-default-float-format* 'double-float) (*print-readably* t)) (format stream "ecl_def_ct_ratio(~A,ecl_make_fixnum(~D),ecl_make_fixnum(~D),static,const);" name (numerator value) (denominator value)))) (defun static-constant-delegate (name value stream) (funcall (static-constant-expression value) name value stream)) (defun static-complex-builder (name value stream) (let* ((*read-default-float-format* 'double-float) (*print-readably* t) (name-real (concatenate 'string name "_real")) (name-imag (concatenate 'string name "_imag"))) (static-constant-delegate name-real (realpart value) stream) (terpri stream) (static-constant-delegate name-imag (imagpart value) stream) (terpri stream) (format stream "ecl_def_ct_complex(~A,&~A_data,&~A_data,static,const);" name name-real name-imag))) #+sse2 (defun static-sse-pack-builder (name value stream) (let* ((bytes (ext:sse-pack-to-vector value '(unsigned-byte 8))) (type-code (nth-value 1 (ext:sse-pack-element-type value)))) (format stream "ecl_def_ct_sse_pack(~A,~A~{,~A~});" name type-code (coerce bytes 'list)))) (defun static-constant-builder (format value) (lambda (name stream) (format stream format name value))) (defun static-constant-expression (object) (typecase object (base-string #'static-base-string-builder) (ratio (and (static-constant-expression (numerator object)) (static-constant-expression (denominator object)) #'static-rational-builder)) (single-float (and (not (ext:float-nan-p object)) (not (ext:float-infinity-p object)) #'static-single-float-builder)) (double-float (and (not (ext:float-nan-p object)) (not (ext:float-infinity-p object)) #'static-double-float-builder)) #+long-float (long-float (and (not (ext:float-nan-p object)) (not (ext:float-infinity-p object)) #'static-long-float-builder)) (complex (and (static-constant-expression (realpart object)) (static-constant-expression (imagpart object)) #'static-complex-builder)) #+sse2 (ext:sse-pack #'static-sse-pack-builder) (t nil))) (defun add-static-constant (object) #+msvc nil #-msvc ;; FIXME! The Microsoft compiler does not allow static initialization of bit fields. ;; SSE uses always unboxed static constants. No reference ;; is kept to them -- it is thus safe to use them even on code ;; that might be unloaded. (unless (or *compiler-constants* (and (not *use-static-constants-p*) #+sse2 (not (typep object 'ext:sse-pack))) (not (listp *static-constants*))) (let ((record (find object *static-constants* :key #'first :test #'equal))) (if record (second record) (let ((builder (static-constant-expression object))) (when builder (let* ((c-name (format nil "_ecl_static_~D" (length *static-constants*)))) (push (list object c-name builder) *static-constants*) (make-vv :location c-name :value object)))))))) (defun wt-vv-index (index permanent-p) (cond ((not (numberp index)) (wt index)) (permanent-p (wt "VV[" index "]")) (t (wt "VVtemp[" index "]")))) (defun set-vv-index (loc index permanent-p) (wt-nl) (wt-vv-index index permanent-p) (wt "= ") (wt-coerce-loc :object loc) (wt ";")) (defun wt-vv (vv-loc) (setf (vv-used-p vv-loc) t) (wt-vv-index (vv-location vv-loc) (vv-permanent-p vv-loc))) (defun set-vv (loc vv-loc) (setf (vv-used-p vv-loc) t) (set-vv-index loc (vv-location vv-loc) (vv-permanent-p vv-loc))) (defun vv-type (loc) (let ((value (vv-value loc))) (if (and value (not (ext:fixnump value))) (type-of value) t))) ecl-16.1.2/src/cmp/defsys.lsp.in000066400000000000000000000045471266352375300163620ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;; ---------------------------------------------------------------------- ;;; CLOS ;;; ---------------------------------------------------------------------- (defparameter *cmp-modules* ;; file load compile files which force ;; environment environment recompilations of ;; this file '( (cmpdefs () () ()) (cmpmac () () ()) (cmpinline () () ()) (cmputil () () ()) (cmptype () () ()) (cmpbind () () ()) (cmpblock () () ()) (cmpcall () () ()) (cmpcatch () () ()) (cmpenv () () ()) (cmpeval () () ()) (cmpexit () () ()) (cmpflet () () ()) (cmpfun () () ()) (cmpif () () ()) (cmplam () () ()) (cmplet () () ()) (cmploc () () ()) (cmpmap () () ()) (cmpmulti () () ()) (cmpspecial () () ()) (cmptag () () ()) (cmptop () () ()) (cmpvar () () ()) (cmpwt () () ()) (cmpmain () () ()) (cmpffi () () ()) (cmpcfg () () ()))) (sbt:defsystem cmp :modules *cmp-modules* :source-directory '("@abs_srcdir@/" "@abs_builddir@/") :fasl-directory "@abs_builddir@/" :library-directory "@abs_top_builddir@/") ecl-16.1.2/src/cmp/load.lsp.in000066400000000000000000000036331266352375300157770ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;; @configure_input@ (defconstant +cmp-module-files+ '("src:cmp;cmppackage.lsp" "src:cmp;cmptypes.lsp" "src:cmp;cmpglobals.lsp" "build:cmp;cmpdefs.lsp" "src:cmp;cmpmac.lsp" "src:cmp;cmpform.lsp" "src:cmp;cmptables.lsp" "src:cmp;cmpinline.lsp" "src:cmp;cmputil.lsp" "src:cmp;cmptype-arith.lsp" "src:cmp;cmptype-prop.lsp" "src:cmp;cmptype.lsp" "src:cmp;cmptype-assert.lsp" "src:cmp;cmpenv-api.lsp" "src:cmp;cmpenv-fun.lsp" "src:cmp;cmpenv-declare.lsp" "src:cmp;cmpenv-proclaim.lsp" "src:cmp;cmpenv-declaim.lsp" "src:cmp;cmpc-machine.lsp" "src:cmp;cmpc-wt.lsp" "src:cmp;cmpc-inliner.lsp" "src:cmp;cmpbind.lsp" "src:cmp;cmpblock.lsp" "src:cmp;cmpcall.lsp" "src:cmp;cmpcatch.lsp" "src:cmp;cmppolicy.lsp" "src:cmp;cmpeval.lsp" "src:cmp;cmpexit.lsp" "src:cmp;cmpflet.lsp" "src:cmp;cmpfun.lsp" "src:cmp;cmpif.lsp" "src:cmp;cmplam.lsp" "src:cmp;cmplet.lsp" "src:cmp;cmploc.lsp" "src:cmp;cmpmap.lsp" "src:cmp;cmpstack.lsp" "src:cmp;cmpmulti.lsp" "src:cmp;cmpspecial.lsp" "src:cmp;cmptag.lsp" "src:cmp;cmptop.lsp" "src:cmp;cmpvar.lsp" "src:cmp;cmpwt.lsp" "src:cmp;cmpffi.lsp" "src:cmp;cmpcbk.lsp" "src:cmp;cmpct.lsp" "src:cmp;cmpnum.lsp" "src:cmp;cmpname.lsp" "src:cmp;cmpopt.lsp" "src:cmp;cmpopt-bits.lsp" "src:cmp;cmpopt-clos.lsp" "src:cmp;cmpopt-constant.lsp" "src:cmp;cmpopt-cons.lsp" "src:cmp;cmpopt-printer.lsp" "src:cmp;cmpopt-sequence.lsp" "src:cmp;cmpopt-type.lsp" "src:cmp;cmpprop.lsp" "src:cmp;cmpclos.lsp" "src:cmp;cmpstructures.lsp" "src:cmp;cmparray.lsp" "src:cmp;cmpos-run.lsp" "src:cmp;cmpos-features.lsp" "src:cmp;cmpmain.lsp" "src:cmp;proclamations.lsp" "src:cmp;sysfun.lsp")) (let ((si::*keep-documentation* nil)) (mapc #'(lambda (x) (load x :verbose t)) +cmp-module-files+)) ecl-16.1.2/src/cmp/proclamations.lsp000066400000000000000000001746611266352375300173400ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: C -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;; ;;; PROCLAMATIONS of ECL and ANSI Common Lisp functions ;;; ;;; Copyright (c) 2010, Juan Jose Garcia Ripoll ;;; Copying of this file is authorized to users who have executed the true ;;; and proper "License Agreement for ECL". ;;; ;;; The function proclamations are created with PROCLAIM-FUNCTION, as in ;;; ;;; (PROCLAMATION function-name ([arg-type]*) return-type ;;; &rest {:no-sp-change|:pure|:reader|:no-side-effects}) ;;; ;;; with the following interpretation: ARG-TYPE and RETURN-TYPE denote the most ;;; general types for the input and output values of this function. If the ;;; compiler detects that some of the values passed to this function does not ;;; match these types, it will generate an error. In addition to this, ECL ;;; contemplates different function properties: ;;; ;;; :NO-SP-CHANGE indicates that the function does not change the value of any ;;; special variable, and it is used to perform code transformations. ;;; ;;; :NO-SIDE-EFFECTS is slightly stronger, as it indicates that the function ;;; does not change variables or the content of objects in the ;;; thread environment. Note the following: ;;; ;;; - Allocating memory, creating objects, etc is not considered a side ;;; effect, as it does not affect the code flow. ;;; - Similarly, signalling errors is not considered a side effect. ;;; - The environment may be changed by other threads. This is taken ;;; into account (see below). ;;; ;;; :READER indicates that the function not only has no side effects, but its ;;; value depends only on its arguments. However, :READER specifies that ;;; the arguments are mutable. ;;; ;;; :PURE is the strictest class of functions. They have no side effects, the ;;; output only depends on the arguments, the arguments are immutable ;;; objects and the function call can be optimized away when the ;;; arguments are constant. ;;; (in-package "C") (defun parse-function-proclamation (name arg-types return-type &rest properties) (when (sys:get-sysprop name 'proclaimed-arg-types) (warn "Duplicate proclamation for ~A" name)) (#-new-cmp proclaim-function #+new-cmp c-env::proclaim-function name (list arg-types return-type)) (loop for p in properties do (case p (:no-sp-change (sys:put-sysprop name 'no-sp-change t)) ((:predicate :pure) (sys:put-sysprop name 'pure t) (sys:put-sysprop name 'no-side-effects t)) ((:no-side-effects :reader) (sys:put-sysprop name 'no-side-effects t)) (otherwise (error "Unknown property ~S in function proclamation for ~S" p name))))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; AUXILIARY TYPES ;; (deftype array-rank-index () '(integer 0 #.(1- array-rank-limit))) (deftype bit-array () '(array bit *)) (deftype association-list () 'list #+(or) '(or null (cons cons association-list))) (deftype byte-specifier () "The type of the output of BYTE." '(cons integer-length integer-length)) (deftype character-code () '(integer 0 #.(1- char-code-limit))) (deftype character-designator () '(or character string-designator)) (deftype external-file-format () '(or symbol list)) (deftype declaration-specifier () "Element that can appear in a DECLARE form" 'list) (deftype digit-weight () '(integer 0 35)) (deftype environment () "Environment used by compiler and interpreter" 'list) (deftype form () "Valid lisp form" t) (deftype format-control () "Format control for FORMAT. It can be a string or a function returned by FORMATTER." '(or string function)) (deftype function-designator () "An object that denotes a function and which can be a symbol or a function." '(or symbol function)) (deftype function-name () "Valid name of a function, typically a symbol or (SETF symbol)" '(or list symbol)) (deftype gen-bool () "Generalized boolean type" 't) (deftype integer-length () "A type that fits maximum number of bits that an integer may have in this system" 'ext:array-index) (deftype natural () "Non-negative number" '(integer 0 *)) (deftype package-designator () '(or string-designator package)) (deftype pathname-designator () '(or pathname string file-stream)) (deftype pathname-device () '(or string (member nil :unspecific))) (deftype pathname-directory () '(or string list (member :wild :unspecific))) (deftype pathname-host () '(or string list (member nil :unspecific))) (deftype pathname-name () '(or string (member nil :wild :unspecific))) (deftype pathname-type () '(or string (member nil :wild :unspecific))) (deftype pathname-version () '(or unsigned-byte (member nil :wild :newest :unspecific))) (deftype proper-list () 'list #+(or) '(or null (cons t proper-list))) (deftype property-list () 'list #+(or) '(or null (cons t (cons t property-list)))) (deftype radix () '(integer 2 36)) (deftype readtable-designator () '(or null readtable)) (deftype restart-designator () "Either a symbol naming a restart, or the restart object itself." '(or (and symbol (not null)) restart)) (deftype sequence-index () '(integer 0 #.array-total-size-limit)) (deftype stream-designator () '(or stream (member t nil))) (deftype string-designator () '(or symbol string character)) (deftype tree () 't) (deftype type-specifier () "Name or object representing a time." '(or symbol class list)) (deftype universal-time () "Time represented as a non-negative number of seconds measured from the beginning of 1900." 'unsigned-byte) (deftype time-zone () t) (deftype ext:instance () 'standard-object) (proclaim '(notinline ext:constantp-inner ext:constant-form-value)) (eval-when (:compile-toplevel :execute) (defparameter +proclamations+ '( ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; ;;; ALL FUNCTION DECLARATIONS ;;; ;;; ;;; ANSI SECTIONS ;;; ;;; 3. EVALUATION AND COMPILATION ;;; (proclamation compile (function-name &optional (or list function)) (values (or function-name function) gen-bool gen-bool)) (proclamation compiler-macro-function (function-name &optional environment) function) (proclamation constantp (t &optional environment) gen-bool) (proclamation eval (form) (values &rest t)) (proclamation macro-function (symbol &optional environment) function) (proclamation macroexpand (form &optional environment) (values form gen-bool)) (proclamation macroexpand-1 (form &optional environment) (values form gen-bool)) (proclamation proclaim (declaration-specifier) (values &rest t)) (proclamation special-operator-p (symbol) gen-bool :pure) ;; ECL extensions: (proclamation si:specialp (symbol) gen-bool :predicate) (proclamation si::do-defsetf (symbol (or symbol function) &optional list) t) (proclamation si::do-define-setf-method (symbol function) t) (proclamation ext:constant-form-value (t &optional environment) t) (proclamation ext:constantp-inner (t &optional environment) gen-bool) ;;; ;;; 4. TYPES AND CLASSES ;;; (proclamation coerce (t type-specifier) t) (proclamation subtypep (type-specifier type-specifier &optional environment) (values gen-bool gen-bool)) (proclamation type-of (t) type-specifier) (proclamation typep (t type-specifier &optional environment) gen-bool) ; Slot accessors: ; (proclamation type-error-datum (condition) t) ; (proclamation type-error-expected-type (condition) t) ;; ECL EXTENSIONS (proclamation si::coerce-to-vector (t type-specifier t gen-bool) vector :no-side-effects) (proclamation si::coerce-to-function (function-designator) function :no-side-effects) ;;; ;;; 5. DATA AND CONTROL FLOW ;;; (proclamation apply (function-designator &rest t) (values &rest t)) (proclamation fdefinition (function-name) (or list function (member 'SPECIAL)) :reader) (proclamation fboundp (function-name) gen-bool :reader) (proclamation fmakunbound (function-name) function-name) (proclamation funcall (function-designator &rest t) (values &rest t)) (proclamation function-lambda-expression (function) (values list gen-bool t) :pure) (proclamation functionp (t) gen-bool :pure) (proclamation compiled-function-p (t) gen-bool :pure) (proclamation not (gen-bool) boolean :pure) (proclamation eq (t t) gen-bool :pure) (proclamation eql (t t) gen-bool :pure) (proclamation equal (t t) gen-bool :pure) (proclamation equalp (t t) gen-bool :pure) (proclamation identity (t) t) (proclamation complement (function) function) (proclamation constantly (t) function) (proclamation every (function-designator sequence &rest sequence) gen-bool) (proclamation some (function-designator sequence &rest sequence) t) (proclamation notevery (function-designator sequence &rest sequence) gen-bool) (proclamation notany (function-designator sequence &rest sequence) gen-bool) (proclamation values-list (list) (values &rest t)) (proclamation get-setf-expansion (t &optional environment) (values t t t t t)) ;; ECL extensions (proclamation si:fset (function-name function &optional gen-bool t) function) (proclamation si:setf-definition (function-name createp) list) (proclamation ext:compiled-function-name (function) (or null function-name)) (proclamation si:compiled-function-block (function) (or null si::codeblock)) (proclamation ext:compiled-function-file (function) (values t t)) (proclamation ext:constantly-t () function) (proclamation si:ihs-top () si::index) (proclamation si:ihs-fun (si::index) (or null function-designator)) (proclamation si:ihs-env (si::index) environment) (proclamation si:frs-top () si::index) (proclamation si:frs-bds (si::index) si::index) (proclamation si:frs-tag (si::index) t) (proclamation si:frs-ihs (si::index) si::index) (proclamation si:bds-top () si::index) (proclamation si:bds-var (si::index) symbol) (proclamation si:bds-val (si::index) t) (proclamation si:sch-frs-base (si::index si::index) (or null si::index)) (proclamation si::ccase-error (t t t) t) (proclamation si::ecase-error (t t) t) (proclamation si::etypecase-error (t t) t) (proclamation si::ctypecase-error (t t t) t) (proclamation si::do-check-type (t t t t) t) (proclamation si::dm-too-many-arguments (t) t) (proclamation si::dm-too-few-arguments (t) t) ;;; ;;; 7. OBJECTS ;;; #+clos (proclamation ensure-generic-function (function-name &rest t) generic-function) #+clos (proclamation slot-boundp (si::instance symbol) gen-bool) #+clos (proclamation slot-exists-p (si::instance symbol) gen-bool) #+clos (proclamation slot-makunbound (si::instance symbol) si::instance) #+clos (proclamation slot-value (si::instance symbol) t) #+clos (proclamation make-load-form-saving-slots (t &rest t) (values t t)) #+clos (proclamation find-class (symbol &optional gen-bool environment) (or class null)) #+clos (proclamation class-of (t) class :no-side-effects) ;; Slot accessors: ; (proclamation unbound-slot-instance (condition) si::instance :predicate) #+clos (proclamation clos::standard-instance-set (t ext:instance t) t) #+clos (proclamation clos:std-compute-applicable-methods (generic-function list) list) #+clos (proclamation clos:std-compute-effective-method (generic-function method-combination list) function) #+clos (proclamation clos:compute-effective-method-function (generic-function method-combination list) function) #+clos (proclamation clos::update-instance (ext:instance) (values)) #+clos (proclamation clos::slot-value-set (t si::instance symbol) t) #+clos (proclamation clos:extract-lambda-list (list) list) #+clos (proclamation clos:extract-specializer-names (list) list) ;;; ;;; 8. STRUCTURES ;;; (proclamation copy-structure (t) t) ;; ECL extensions (proclamation si:make-structure (t &rest t) structure-object) (proclamation si:structure-name (structure-object) symbol :reader) (proclamation si:structure-ref (structure-object t fixnum) t :reader) (proclamation si:structure-set (structure-object t fixnum t) t) (proclamation si:structurep (t) gen-bool :predicate) (proclamation si:structure-subtype-p (t t) gen-bool :predicate) ;;; ;;; 9. CONDITIONS ;;; (proclamation error (t &rest t) (values)) ;; FIXME! It is not clear from the specification whether CERROR actually ;; returns values. However ECL is actually using the fact that it returns ;; the value from CONTINUE. (proclamation cerror (format-control t &rest t) (values &rest t)) (proclamation invalid-method-error (method format-control &rest t) (values)) (proclamation method-combination-error (format-control &rest t) (values)) (proclamation signal (t &rest t) null) (proclamation warn (t &rest t) null) (proclamation invoke-debugger (condition) (values)) (proclamation break (&optional format-control &rest t) null) (proclamation make-condition (type-specifier &rest t) condition) (proclamation compute-restarts (&optional (or null condition)) list) (proclamation find-restart (restart-designator &optional (or null condition)) restart) (proclamation invoke-restart (restart-designator &rest t) (values &rest t)) (proclamation invoke-restart-interactively (restart-designator) (values &rest t)) (proclamation abort (&optional (or null condition)) (values)) (proclamation continue (&optional (or null condition)) null) (proclamation muffle-warning (&optional (or null condition)) (values)) (proclamation store-value (t &optional (or null condition)) null) (proclamation use-value (t &optional (or null condition)) null) ;; Slot accessors: ;; (proclamation cell-error-name (cell-error) t) ;; (proclamation simple-condition-format-control (simple-condition) t) ;; (proclamation simple-condition-format-arguments (simple-condition) t) ;; (proclamation restart-name (restart) t) ;; ECL extensions (proclamation ext:catch-signal (fixnum gen-bool &key) null) (proclamation si:bind-simple-restarts (t t) list) (proclamation si:bind-simple-handlers (t t) list) ;;; ;;; 10. SYMBOLS ;;; (proclamation symbolp (t) gen-bool :pure) (proclamation keywordp (t) gen-bool :reader) (proclamation make-symbol (string) symbol) (proclamation copy-symbol (symbol &optional gen-bool) symbol) (proclamation gensym (&optional (or string natural)) symbol) (proclamation gentemp (&optional string package-designator) symbol) (proclamation symbol-function (symbol) (or function list (member 'special)) :reader) (proclamation symbol-name (symbol) string :pure) (proclamation symbol-package (symbol) (or package null) :reader) (proclamation symbol-plist (symbol) list :reader) (proclamation symbol-value (symbol) t :reader) (proclamation get (symbol t &optional t) t :no-side-effects) (proclamation remprop (symbol t) gen-bool) (proclamation boundp (symbol) gen-bool :reader) (proclamation makunbound (symbol) symbol) (proclamation set (symbol t) t) ;; ECL extensions: (proclamation si:*make-special (symbol) symbol) (proclamation si:*make-constant (symbol t) symbol) (proclamation si:put-f (list t t) list) (proclamation si:rem-f (list t) (values list boolean)) (proclamation si:set-symbol-plist (symbol list) list) (proclamation si:putprop (symbol t t) t) (proclamation si:put-sysprop (t t t) t) (proclamation si:get-sysprop (t t) (values t boolean)) (proclamation si:rem-sysprop (t t) boolean) (proclamation si:put-properties (symbol &rest t) symbol :no-sp-change) ;;; ;;; 11. PACKAGES ;;; (proclamation export (list &optional package-designator) t) (proclamation find-symbol (string &optional package-designator) (values symbol (member :inherited :external :internal nil))) (proclamation find-package (package-designator) (or package null)) (proclamation find-all-symbols (string-designator) list) (proclamation import (list &optional package-designator) t) (proclamation list-all-packages () list) (proclamation rename-package (package-designator package-designator &optional list) package) (proclamation shadow (list &optional package-designator) t) (proclamation shadowing-import (list &optional package-designator) t) (proclamation delete-package (package-designator) gen-bool) (proclamation make-package (string-designator &rest t) package) (proclamation unexport (list &optional package-designator) t) (proclamation unintern (symbol &optional package-designator) gen-bool) (proclamation unuse-package (list &optional package-designator) t) (proclamation use-package (list &optional package-designator) t) (proclamation intern (string &optional package-designator) (values symbol (member :inherited :external :internal nil))) (proclamation package-name (package-designator) (or string null) :reader) (proclamation package-nicknames (package-designator) list :reader) (proclamation package-shadowing-symbols (package-designator) list :reader) (proclamation package-use-list (package-designator) list :reader) (proclamation package-used-by-list (package-designator) list :reader) (proclamation packagep (t) gen-bool :pure) ;; Slot accessor: ;; (proclamation package-error-package (condition) package) ;; ECL extensions (proclamation si:select-package (package-designator) package) (proclamation si:package-hash-tables (package-designator) (values hash-table hash-table list) :reader) (proclamation ext:package-lock (package-designator gen-bool) package) ;;; ;;; 12. NUMBERS ;;; (proclamation = (number &rest number) gen-bool :pure) (proclamation /= (number &rest number) gen-bool :pure) (proclamation < (real &rest real) gen-bool :pure) (proclamation > (real &rest real) gen-bool :pure) (proclamation <= (real &rest real) gen-bool :pure) (proclamation >= (real &rest real) gen-bool :pure) (proclamation max (real &rest real) real :pure) (proclamation min (real &rest real) real :pure) (proclamation minusp (real) gen-bool :pure) (proclamation plusp (real) gen-bool :pure) (proclamation zerop (number) gen-bool :pure) (proclamation floor (real &optional real) (values integer real) :pure) (proclamation ceiling (real &optional real) (values integer real) :pure) (proclamation truncate (real &optional real) (values integer real) :pure) (proclamation round (real &optional real) (values integer real) :pure) (proclamation ffloor (real &optional real) (values float real) :pure) (proclamation fceiling (real &optional real) (values float real) :pure) (proclamation ftruncate (real &optional real) (values float real) :pure) (proclamation fround (real &optional real) (values float real) :pure) (proclamation cos (number) number :pure) (proclamation sin (number) number :pure) (proclamation tan (number) number :pure) (proclamation cosh (number) number :pure) (proclamation sinh (number) number :pure) (proclamation tanh (number) number :pure) (proclamation acos (number) number :pure) (proclamation asin (number) number :pure) (proclamation atan (number &optional real) number :pure) (proclamation acosh (number) number :pure) (proclamation asinh (number) number :pure) (proclamation atanh (number) number :pure) (proclamation * (&rest number) number :pure) (proclamation + (&rest number) number :pure) (proclamation - (&rest number) number :pure) (proclamation / (number &rest number) number :pure) (proclamation 1+ (number) number :pure) (proclamation 1- (number) number :pure) (proclamation abs (number) (real 0 *) :pure) (proclamation evenp (integer) gen-bool :pure) (proclamation oddp (integer) gen-bool :pure) (proclamation exp (number) number :pure) (proclamation expt (number number) number :pure) (proclamation gcd (&rest integer) unsigned-byte :pure) (proclamation lcm (&rest integer) unsigned-byte :pure) (proclamation log (number &optional number) number :pure) (proclamation mod (real real) real :pure) (proclamation rem (real real) real :pure) (proclamation signum (number) number :pure) (proclamation sqrt (number) number :pure) (proclamation isqrt (natural) natural :pure) (proclamation make-random-state (&optional (or random-state (member nil t))) random-state :no-side-effects) (proclamation random ((or (integer 0 *) (float 0 *)) &optional random-state) (or (integer 0 *) (float 0 *))) (proclamation random-state-p (t) gen-bool :pure) (proclamation numberp (t) gen-bool :pure) (proclamation cis (real) complex :pure) (proclamation complex (real &optional real) number :pure) (proclamation complexp (t) gen-bool :pure) (proclamation conjugate (number) number :pure) (proclamation phase (number) (real #.(- pi) #.pi) :pure) (proclamation realpart (number) real :pure) (proclamation imagpart (number) real :pure) (proclamation upgraded-complex-part-type (type-specifier &optional environment) type-specifier :no-side-effects) (proclamation realp (t) gen-bool :pure) (proclamation numerator (rational) integer :pure) (proclamation denominator (rational) unsigned-byte :pure) (proclamation rational (real) rational :pure) (proclamation rationalize (real) rational :pure) (proclamation rationalp (t) gen-bool :pure) (proclamation ash (integer integer) integer :pure) (proclamation integer-length (integer) integer-length :pure) (proclamation integerp (t) gen-bool :pure) (proclamation parse-integer (string &rest t) (values integer ext:array-index) :no-side-effects) (proclamation boole ((integer 0 15) integer integer) integer :pure) (proclamation logand (&rest integer) integer :pure) (proclamation logandc1 (integer integer) integer :pure) (proclamation logandc2 (integer integer) integer :pure) (proclamation logeqv (&rest integer) integer :pure) (proclamation logior (&rest integer) integer :pure) (proclamation lognand (integer integer) integer :pure) (proclamation lognor (integer integer) integer :pure) (proclamation lognot (integer) integer :pure) (proclamation logorc1 (integer integer) integer :pure) (proclamation logorc2 (integer integer) integer :pure) (proclamation logxor (&rest integer) integer :pure) (proclamation logbitp (unsigned-byte integer) gen-bool :pure) (proclamation logcount (integer) integer-length :pure) (proclamation logtest (integer integer) gen-bool :pure) (proclamation byte (unsigned-byte unsigned-byte) byte-specifier :pure) (proclamation byte-size (byte-specifier) integer-length :pure) (proclamation byte-position (byte-specifier) integer-length :pure) (proclamation deposit-field (integer byte-specifier integer) integer :pure) (proclamation dpb (integer byte-specifier integer) integer :pure) (proclamation ldb (byte-specifier integer) unsigned-byte :pure) (proclamation ldb-test (byte-specifier integer) gen-bool :pure) (proclamation mask-field (byte-specifier integer) unsigned-byte :pure) (proclamation decode-float (float) (values float integer float) :pure) (proclamation scale-float (float integer) float :pure) (proclamation float-radix (float) fixnum :pure) (proclamation float-sign (float &optional float) float :pure) (proclamation float-digits (float) (integer 0 #.(float-digits (coerce 1.0 'long-float))) :pure) (proclamation float-precision (float) (integer 0 #.(float-digits (coerce 1.0 'long-float))) :pure) (proclamation integer-decode-float (float) (values integer integer (member -1 1)) :pure) (proclamation float (number &optional float) float :pure) (proclamation floatp (t) gen-bool :pure) ;; Slot accessors: ;; (proclamation arithmetic-error-operands (condition) t) ;; (proclamation arithmetic-error-operation (condition) t) ;; ECL extensions (proclamation si:bit-array-op (t t t t) (array bit)) (proclamation ext:fixnump (t) gen-bool :pure) (proclamation si:ratiop (t) gen-bool :pure) (proclamation si:short-float-p (t) gen-bool :pure) (proclamation si:single-float-p (t) gen-bool :pure) (proclamation si:double-float-p (t) gen-bool :pure) (proclamation si:long-float-p (t) gen-bool :pure) ;; Virtual functions added by the compiler (proclamation shift>> (*) nil :pure) (proclamation shift<< (*) nil :pure) (proclamation c::ldb1 (fixnum fixnum fixnum) fixnum :no-side-effects) ;;; ;;; 13. CHARACTERS ;;; (proclamation char= (character &rest character) gen-bool :pure) (proclamation char/= (character &rest character) gen-bool :pure) (proclamation char< (character &rest character) gen-bool :pure) (proclamation char> (character &rest character) gen-bool :pure) (proclamation char<= (character &rest character) gen-bool :pure) (proclamation char>= (character &rest character) gen-bool :pure) (proclamation char-equal (character &rest character) gen-bool :pure) (proclamation char-not-equal (character &rest character) gen-bool :pure) (proclamation char-lessp (character &rest character) gen-bool :pure) (proclamation char-greaterp (character &rest character) gen-bool :pure) (proclamation char-not-greaterp (character &rest character) gen-bool :pure) (proclamation char-not-lessp (character &rest character) gen-bool :pure) (proclamation character (character-designator) character) (proclamation characterp (t) gen-bool :pure) (proclamation alpha-char-p (character) gen-bool :pure) (proclamation alphanumericp (character) gen-bool :pure) (proclamation digit-char (digit-weight &optional radix) character :pure) (proclamation digit-char-p (character &optional radix) (or digit-weight null) :pure) (proclamation graphic-char-p (character) gen-bool :pure) (proclamation standard-char-p (character) gen-bool :pure) (proclamation char-upcase (character) character :pure) (proclamation char-downcase (character) character :pure) (proclamation upper-case-p (character) gen-bool :pure) (proclamation lower-case-p (character) gen-bool :pure) (proclamation both-case-p (character) gen-bool :pure) (proclamation char-code (character) character-code :pure) (proclamation char-int (character) character-code :pure) (proclamation code-char (character-code) (or character null) :pure) (proclamation char-name (character) (or string null) :pure) (proclamation name-char (string-designator) (or character null) :pure) ;; ECL extensions (proclamation si:base-char-p (t) gen-bool :predicate) ;;; ;;; 14. CONSES ;;; (proclamation cons (t t) cons :no-side-effects) (proclamation consp (t) gen-bool :pure) (proclamation atom (t) gen-bool :pure) (proclamation rplaca (cons t) cons) (proclamation rplacd (cons t) cons) (proclamation car (list) t :reader) (proclamation cdr (list) t :reader) (proclamation caar (list) t :reader) (proclamation cadr (list) t :reader) (proclamation cdar (list) t :reader) (proclamation cddr (list) t :reader) (proclamation caaar (list) t :reader) (proclamation caadr (list) t :reader) (proclamation cadar (list) t :reader) (proclamation caddr (list) t :reader) (proclamation cdaar (list) t :reader) (proclamation cdadr (list) t :reader) (proclamation cddar (list) t :reader) (proclamation cdddr (list) t :reader) (proclamation caaaar (list) t :reader) (proclamation caaadr (list) t :reader) (proclamation caadar (list) t :reader) (proclamation caaddr (list) t :reader) (proclamation cadaar (list) t :reader) (proclamation cadadr (list) t :reader) (proclamation caddar (list) t :reader) (proclamation cadddr (list) t :reader) (proclamation cdaaar (list) t :reader) (proclamation cdaadr (list) t :reader) (proclamation cdadar (list) t :reader) (proclamation cdaddr (list) t :reader) (proclamation cddaar (list) t :reader) (proclamation cddadr (list) t :reader) (proclamation cdddar (list) t :reader) (proclamation cddddr (list) t :reader) (proclamation copy-tree (tree) tree :no-side-effects) (proclamation sublis (association-list tree &key) tree) (proclamation nsublis (association-list tree &key) tree) (proclamation subst (t t tree &key) tree) (proclamation subst-if (t function-designator tree &key) tree) (proclamation subst-if-not (t function-designator tree &key) tree) (proclamation nsubst (t t tree &key) tree) (proclamation nsubst-if (t function-designator tree &key) tree) (proclamation nsubst-if-not (t function-designator tree &key) tree) (proclamation tree-equal (tree tree &key) gen-bool :predicate) (proclamation copy-list (list) list :no-side-effects) (proclamation list (&rest t) list :no-side-effects) (proclamation list* (&rest t) t :no-side-effects) (proclamation list-length (list) (or null si::index) :no-side-effects) (proclamation listp (t) gen-bool :pure) (proclamation make-list (si::index &key) list :no-side-effects) (proclamation first (list) t :reader) (proclamation second (list) t :reader) (proclamation third (list) t :reader) (proclamation fourth (list) t :reader) (proclamation fifth (list) t :reader) (proclamation sixth (list) t :reader) (proclamation seventh (list) t :reader) (proclamation eighth (list) t :reader) (proclamation ninth (list) t :reader) (proclamation tenth (list) t :reader) (proclamation nth (unsigned-byte list) t :reader) (proclamation endp (list) gen-bool :predicate) (proclamation null (t) gen-bool :predicate) (proclamation nconc (&rest t) t) (proclamation append (&rest t) t :no-side-effects) (proclamation revappend (list t) t :no-side-effects) (proclamation nreconc (list t) t) (proclamation butlast (list &optional unsigned-byte) list :no-side-effects) (proclamation nbutlast (list &optional unsigned-byte) list) (proclamation last (list &optional unsigned-byte) t :reader) (proclamation ldiff (list t) list :no-side-effects) (proclamation tailp (t list) gen-bool :reader) (proclamation nthcdr (fixnum list) t :reader) (proclamation rest (list) t :no-side-effects) (proclamation member (t proper-list &key) proper-list) (proclamation member-if (function-designator proper-list &key) proper-list) (proclamation member-if-not (function-designator proper-list &key) proper-list) (proclamation mapc (function-designator proper-list &rest proper-list) proper-list) (proclamation mapcar (function-designator proper-list &rest proper-list) proper-list) (proclamation mapcan (function-designator proper-list &rest proper-list) proper-list) (proclamation mapl (function-designator proper-list &rest proper-list) proper-list) (proclamation maplist (function-designator proper-list &rest proper-list) proper-list) (proclamation mapcon (function-designator proper-list &rest proper-list) proper-list) (proclamation acons (t t association-list) association-list :no-side-effects) (proclamation assoc (t association-list &key) t) (proclamation assoc-if (function-designator association-list &key) t) (proclamation assoc-if-not (function-designator association-list &key) t) (proclamation copy-alist (association-list) association-list :no-side-effects) (proclamation pairlis (proper-list proper-list &optional association-list) association-list :no-side-effects) (proclamation rassoc (t association-list &key) t) (proclamation rassoc-if (function-designator association-list &key) t) (proclamation rassoc-if-not (function-designator association-list &key) t) (proclamation get-properties (property-list proper-list) (values t t list) :no-side-effects) (proclamation getf (property-list t &optional t) t :reader) (proclamation intersection (proper-list proper-list &key) proper-list) (proclamation nintersection (proper-list proper-list &key) proper-list) (proclamation adjoin (t proper-list &key) proper-list) (proclamation set-difference (proper-list proper-list &key) proper-list) (proclamation nset-difference (proper-list proper-list &key) proper-list) (proclamation set-exclusive-or (proper-list proper-list &key) proper-list) (proclamation nset-exclusive-or (proper-list proper-list &key) proper-list) (proclamation subsetp (proper-list proper-list &key) gen-bool :predicate) (proclamation union (proper-list proper-list &key) proper-list) (proclamation nunion (proper-list proper-list &key) proper-list) ;; ECL extensions (proclamation si:member1 (t proper-list t t t) list) (proclamation si:memq (t proper-list) list) (proclamation si:cons-car (cons) t :reader) (proclamation si:cons-cdr (cons) t :reader) (proclamation si::proper-list-p (t) gen-bool :predicate) ;;; ;;; 15. ARRAYS ;;; (proclamation make-array ((or ext:array-index list) &key) array :no-side-effects) (proclamation adjust-array (array (or ext:array-index list) &key) array) (proclamation adjustable-array-p (array) gen-bool :pure) (proclamation aref (array &rest ext:array-index) t :reader) (proclamation array-dimension (array array-rank-index) ext:array-index :reader) (proclamation array-dimensions (array) list :reader) (proclamation array-element-type (array) type-specifier :pure) (proclamation array-has-fill-pointer-p (array) gen-bool :pure) (proclamation array-displacement (array) (values (or array null) ext:array-index) :reader) (proclamation array-in-bounds-p (array &rest ext:array-index) gen-bool :no-side-effects) (proclamation array-rank (array) array-rank-index :reader) (proclamation array-row-major-index (array &rest ext:array-index) ext:array-index :no-side-effects) (proclamation array-total-size (array) ext:array-index :reader) (proclamation arrayp (t) gen-bool :pure) (proclamation fill-pointer (vector) ext:array-index :reader) (proclamation row-major-aref (array ext:array-index) t :reader) (proclamation upgraded-array-element-type (type-specifier &optional environment) type-specifier :no-side-effects) (proclamation simple-vector-p (t) gen-bool :pure) (proclamation svref (simple-vector ext:array-index) t :reader) (proclamation vector (&rest t) vector :no-side-effects) (proclamation vector-pop (vector) t) (proclamation vector-push (t vector) (or ext:array-index null)) (proclamation vector-push-extend (t vector &optional ext:array-index) ext:array-index) (proclamation vectorp (t) gen-bool :pure) (proclamation bit (bit-array &rest ext:array-index) bit :reader) (proclamation sbit ((simple-array bit) &rest ext:array-index) bit :reader) (proclamation bit-and (bit-array bit-array &optional (or bit-array (member t nil))) bit-array :no-side-effects) (proclamation bit-andc1 (bit-array bit-array &optional (or bit-array (member t nil))) bit-array :no-side-effects) (proclamation bit-andc2 (bit-array bit-array &optional (or bit-array (member t nil))) bit-array :no-side-effects) (proclamation bit-eqv (bit-array bit-array &optional (or bit-array (member t nil))) bit-array :no-side-effects) (proclamation bit-ior (bit-array bit-array &optional (or bit-array (member t nil))) bit-array :no-side-effects) (proclamation bit-nand (bit-array bit-array &optional (or bit-array (member t nil))) bit-array :no-side-effects) (proclamation bit-nor (bit-array bit-array &optional (or bit-array (member t nil))) bit-array :no-side-effects) (proclamation bit-orc1 (bit-array bit-array &optional (or bit-array (member t nil))) bit-array :no-side-effects) (proclamation bit-orc2 (bit-array bit-array &optional (or bit-array (member t nil))) bit-array :no-side-effects) (proclamation bit-xor (bit-array bit-array &optional (or bit-array (member t nil))) bit-array :no-side-effects) (proclamation bit-not (bit-array &optional (or bit-array (member t nil))) bit-array :no-side-effects) (proclamation bit-vector-p (t) gen-bool :pure) (proclamation simple-bit-vector-p (t) t :pure) ;; ECL extensions (proclamation si:make-pure-array (t t t t t t) array) (proclamation si:make-vector (t t t t t t) vector) (proclamation si:aset (array t &rest t) t) (proclamation si:row-major-aset (array ext:array-index t) t) (proclamation si:svset (simple-vector ext:array-index t) t) (proclamation si:fill-pointer-set (vector ext:array-index) ext:array-index) (proclamation si:replace-array (array array) array) ;;; ;;; 16. STRINGS ;;; (proclamation simple-string-p (t) gen-bool :pure) (proclamation char (string ext:array-index) character :reader) (proclamation schar (simple-string ext:array-index) character :reader) (proclamation string (string-designator) string :no-side-effects) (proclamation string-upcase (string-designator &key) string :no-side-effects) (proclamation string-downcase (string-designator &key) string :no-side-effects) (proclamation string-capitalize (string-designator &key) string :no-side-effects) (proclamation nstring-upcase (string &key) string) (proclamation nstring-downcase (string &key) string) (proclamation nstring-capitalize (string &key) string) (proclamation string-trim (sequence string-designator) string :no-side-effects) (proclamation string-left-trim (sequence string-designator) string :no-side-effects) (proclamation string-right-trim (sequence string-designator) string :no-side-effects) (proclamation string= (string-designator string-designator &key) gen-bool :no-side-effects) (proclamation string/= (string-designator string-designator &key) (or ext:array-index null) :no-side-effects) (proclamation string< (string-designator string-designator &key) (or ext:array-index null) :no-side-effects) (proclamation string> (string-designator string-designator &key) (or ext:array-index null) :no-side-effects) (proclamation string<= (string-designator string-designator &key) (or ext:array-index null) :no-side-effects) (proclamation string>= (string-designator string-designator &key) (or ext:array-index null) :no-side-effects) (proclamation string-equal (string-designator string-designator &key) gen-bool :no-side-effects) (proclamation string-not-equal (string-designator string-designator &key) (or ext:array-index null) :no-side-effects) (proclamation string-lessp (string-designator string-designator &key) (or ext:array-index null) :no-side-effects) (proclamation string-greaterp (string-designator string-designator &key) (or ext:array-index null) :no-side-effects) (proclamation string-not-lessp (string-designator string-designator &key) (or ext:array-index null) :no-side-effects) (proclamation string-not-greaterp (string-designator string-designator &key) (or ext:array-index null) :no-side-effects) (proclamation stringp (t) gen-bool :predicate) (proclamation make-string (ext:array-index &key) string :no-side-effects) ;; ECL extensions: (proclamation si:base-string-p (t) gen-bool :pure) (proclamation si:char-set (string ext:array-index character) character) (proclamation si:schar-set (string ext:array-index character) character) (proclamation si:base-string-concatenate (&rest base-string) base-string) ;;; ;;; 17. SEQUENCES ;;; (proclamation copy-seq (sequence) sequence :no-side-effects) (proclamation elt (sequence sequence-index) t :no-side-effects) (proclamation fill (sequence t &key) sequence) (proclamation make-sequence (type-specifier sequence-index &key) sequence :no-side-effects) (proclamation subseq (sequence sequence-index &optional (or sequence-index null)) sequence :no-side-effects) (proclamation map (type-specifier function-designator sequence &rest sequence) sequence) (proclamation map-into (sequence function-designator &rest sequence) sequence) (proclamation reduce (function-designator sequence &key) t) (proclamation count (t sequence &key) sequence-index) (proclamation count-if (function-designator sequence &key) sequence-index) (proclamation count-if-not (function-designator sequence &key) sequence-index) (proclamation length (sequence) sequence-index :no-side-effects) (proclamation reverse (sequence) sequence :no-side-effects) (proclamation nreverse (sequence) sequence) (proclamation sort (sequence function-designator &key) sequence) (proclamation stable-sort (sequence function-designator &key) sequence) (proclamation find (t sequence &key) t :no-side-effects) (proclamation find-if (function-designator sequence &key) t) (proclamation find-if-not (function-designator sequence &key) t) (proclamation position (t sequence &key) (or null sequence-index)) (proclamation position-if (function-designator sequence &key) (or null sequence-index)) (proclamation position-if-not (function-designator sequence &key) (or null sequence-index)) (proclamation search (sequence sequence &key) (or null sequence-index) :no-side-effects) (proclamation mismatch (sequence sequence &key) (or null sequence-index) :no-side-effects) (proclamation replace (sequence sequence &key) sequence) (proclamation substitute (t t sequence &key) sequence) (proclamation substitute-if (t function-designator sequence &key) sequence) (proclamation substitute-if-not (t function-designator sequence &key) sequence) (proclamation nsubstitute (t t sequence &key) sequence) (proclamation nsubstitute-if (t function-designator sequence &key) sequence) (proclamation nsubstitute-if-not (t function-designator sequence &key) sequence) (proclamation concatenate (type-specifier &rest sequence) sequence :no-side-effects) (proclamation merge (type-specifier sequence sequence function-designator &key) sequence) (proclamation remove (t sequence &key) sequence) (proclamation remove-if (function-designator sequence &key) sequence) (proclamation remove-if-not (function-designator sequence &key) sequence) (proclamation delete (t sequence &key) sequence) (proclamation delete-if (function-designator sequence &key) sequence) (proclamation delete-if-not (function-designator sequence &key) sequence) (proclamation remove-duplicates (sequence &key) sequence) (proclamation delete-duplicates (sequence &key) sequence) ;; ECL extensions: (proclamation si:elt-set (sequence sequence-index t) t) (proclamation si::make-seq-iterator (sequence &optional sequence-index) t :no-side-effects) (proclamation si::seq-iterator-ref (sequence t) t :reader) (proclamation si::seq-iterator-set (sequence t t) t :no-sp-change) (proclamation si::seq-iterator-next (sequence t) t :reader) (proclamation si::sequence-start-end (t sequence sequence-index (or null sequence-index)) (values fixnum fixnum fixnum) :no-side-effects) (proclamation si::sequence-count ((or null integer)) fixnum :no-side-effects) ;;; ;;; 18. HASH TABLES ;;; (proclamation make-hash-table (&key) hash-table :no-side-effects) (proclamation hash-table-p (t) gen-bool :pure) (proclamation hash-table-count (hash-table) ext:array-index :reader) (proclamation hash-table-rehash-size (hash-table) (or (integer 1 *) (float (1.0) *)) :pure) (proclamation hash-table-rehash-threshold (hash-table) (real 0 1) :pure) (proclamation hash-table-size (hash-table) ext:array-index :reader) (proclamation hash-table-test (hash-table) function-designator :pure) (proclamation gethash (t hash-table &optional t) (values t gen-bool) :reader) (proclamation remhash (t hash-table) gen-bool) (proclamation maphash (function-designator hash-table) null) (proclamation clrhash (hash-table) hash-table) (proclamation sxhash (t) (integer 0 #.most-positive-fixnum) :no-side-effects) ;; ECL extensions (proclamation si:hash-set (t hash-table t) t) ;;; ;;; 19. FILENAMES ;;; ;;; Note that the pathname interrogation functions could be pure, were it ;;; not for the fact that they depend on the environment, as they accept ;;; pathname designators, which include strings that should be parsed in ;;; that environment. (proclamation pathname (pathname-designator) pathname :no-side-effects) (proclamation make-pathname (&key) pathname :no-side-effects) (proclamation pathnamep (t) gen-bool :pure) (proclamation pathname-host (pathname-designator) pathname-host :no-side-effects) (proclamation pathname-device (pathname-designator) pathname-device :no-side-effects) (proclamation pathname-directory (pathname-designator) pathname-directory :no-side-effects) (proclamation pathname-name (pathname-designator) pathname-name :no-side-effects) (proclamation pathname-type (pathname-designator) pathname-type :no-side-effects) (proclamation pathname-version (pathname-designator) pathname-version :no-side-effects) (proclamation load-logical-pathname-translations (string) gen-bool) (proclamation logical-pathname-translations (string) list) (proclamation logical-pathname (pathname-designator) logical-pathname) (proclamation namestring (pathname-designator) (or string null) :no-side-effects) (proclamation file-namestring (pathname-designator) (or string null) :no-side-effects) (proclamation directory-namestring (pathname-designator) (or string null) :no-side-effects) (proclamation host-namestring (pathname-designator) (or string null) :no-side-effects) (proclamation enough-namestring (pathname-designator &optional pathname-designator) (or string null) :no-side-effects) (proclamation parse-namestring (pathname-designator &optional pathname-host pathname-designator &key) (values (or pathname null) (or ext:array-index null)) :no-side-effects) (proclamation wild-pathname-p (pathname-designator &optional (member :host :device :directory :name :type :version nil)) gen-bool :no-side-effects) (proclamation pathname-match-p (pathname-designator pathname-designator) gen-bool :no-side-effects) (proclamation translate-logical-pathname (pathname-designator &key) pathname :no-side-effects) (proclamation translate-pathname (pathname-designator pathname-designator pathname-designator &key) pathname :no-side-effects) (proclamation merge-pathnames (pathname-designator &optional pathname-designator pathname-version) pathname :no-side-effects) ;;; ;;; 20. FILES ;;; (proclamation directory (pathname-designator &key) list) (proclamation probe-file (pathname-designator) (or pathname null)) (proclamation ensure-directories-exist (pathname-designator &key) (values pathname gen-bool)) (proclamation truename (pathname-designator) pathname) (proclamation file-author (pathname-designator) (or string null)) (proclamation file-write-date (pathname-designator) (or universal-time null)) (proclamation rename-file (pathname-designator pathname-designator) (values pathname pathname pathname)) (proclamation delete-file (pathname-designator) t) ;; Slot accessors: ;; (proclamation file-error-pathname (condition) pathname-designator) ;; ECL extensions (proclamation ext:file-kind (pathname-designator gen-bool) symbol) (proclamation ext:chdir (pathname-designator &optional gen-bool) pathname) (proclamation ext:getcwd (&optional gen-bool) pathname) (proclamation ext:mkstemp (pathname-designator) (or null pathname)) (proclamation ext:copy-file (pathname-designator pathname-designator) gen-bool) (proclamation si:mkdir (pathname-designator unsigned-byte) string) (proclamation si:rmdir (pathname-designator) null) ;;; ;;; 21. STREAMS ;;; (proclamation input-stream-p (stream) gen-bool :reader) (proclamation output-stream-p (stream) gen-bool :reader) (proclamation interactive-stream-p (stream) gen-bool :reader) (proclamation open-stream-p (stream) gen-bool :reader) (proclamation stream-element-type (stream) type-specifier :reader) (proclamation streamp (t) gen-bool :pure) (proclamation read-byte (stream &optional gen-bool t) t) (proclamation write-byte (integer stream) integer) (proclamation peek-char (&optional (or character boolean) stream-designator gen-bool t gen-bool) t) (proclamation read-char (&optional stream-designator gen-bool t gen-bool) t) (proclamation read-char-no-hang (&optional stream-designator gen-bool t gen-bool) t) (proclamation terpri (&optional stream-designator) null) (proclamation fresh-line (&optional stream-designator) gen-bool) (proclamation unread-char (character &optional stream-designator) null) (proclamation write-char (character &optional stream-designator) character) (proclamation read-line (&optional stream-designator gen-bool t gen-bool) (values t gen-bool)) (proclamation write-string (string &optional stream-designator &key) string) (proclamation write-line (string &optional stream-designator &key) string) (proclamation read-sequence (sequence stream &key) sequence-index) (proclamation write-sequence (sequence stream &key) sequence) (proclamation file-length (stream) (or unsigned-byte null)) (proclamation file-position (stream &optional file-position-designator) t) (proclamation file-string-length (stream (or string character)) (or unsigned-byte null)) (proclamation open (pathname-designator &key) (or file-stream null)) (proclamation stream-external-format (stream) external-file-format :reader) (proclamation close (stream &key) t) (proclamation listen (&optional stream-designator) gen-bool) (proclamation clear-input (&optional stream-designator) null) (proclamation finish-output (&optional stream-designator) null) (proclamation force-output (&optional stream-designator) null) (proclamation clear-output (&optional stream-designator) null) (proclamation y-or-n-p (&optional format-control &rest t) gen-bool) (proclamation yes-or-no-p (&optional format-control &rest t) gen-bool) (proclamation make-synonym-stream (symbol) synonym-stream) (proclamation synonym-stream-symbol (synonym-stream) symbol) (proclamation broadcast-stream-streams (broadcast-stream) list :pure) (proclamation make-broadcast-stream (&rest stream) broadcast-stream) (proclamation make-two-way-stream (stream stream) two-way-stream) (proclamation two-way-stream-input-stream (two-way-stream) stream :pure) (proclamation two-way-stream-output-stream (two-way-stream) stream :pure) (proclamation echo-stream-output-stream (echo-stream) stream :pure) (proclamation echo-stream-input-stream (echo-stream) stream :pure) (proclamation make-echo-stream (stream stream) echo-stream) (proclamation concatenated-stream-streams (concatenated-stream) list :reader) (proclamation make-concatenated-stream (&rest stream) concatenated-stream) (proclamation get-output-stream-string (string-stream) string :reader) (proclamation make-string-input-stream (string &optional ext:array-index (or ext:array-index null)) string-stream :reader) (proclamation make-string-output-stream (&key) string-stream :reader) ;; Slot accessors: ;; (proclamation stream-error-stream (condition) stream) ;; ECL extensions: (proclamation si:make-string-output-stream-from-string (string) string-stream :reader) #+wants-sockets (proclamation si:open-client-stream (t unsigned-byte) stream) #+wants-sockets (proclamation si:open-server-stream (unsigned-byte) stream) #+wants-sockets (proclamation si:open-unix-socket-stream (string) stream) #+wants-sockets (proclamation si:lookup-host-entry (t) (values (or null string) list list)) (proclamation si:copy-stream (stream stream) t) (proclamation si:make-encoding (t) t) (proclamation si:load-encoding (t) t) ;;; ;;; 22. PRINT ;;; (proclamation copy-pprint-dispatch (&optional (or si::pprint-dispatch-table null)) si::pprint-dispatch-table :no-side-effects) (proclamation pprint-dispatch (t &optional (or si::pprint-dispatch-table null)) (values function-designator gen-bool)) (proclamation pprint-fill (stream-designator t &optional gen-bool gen-bool) null) (proclamation pprint-linear (stream-designator t &optional gen-bool gen-bool) null) (proclamation pprint-tabular (stream-designator t &optional gen-bool gen-bool unsigned-byte) null) (proclamation pprint-indent ((member :block :current) real &optional stream-designator) null) (proclamation pprint-newline ((member :linear :fill :miser :mandatory) &optional stream-designator) null) (proclamation pprint-tab ((member :line :section :line-relative :section-relative) unsigned-byte unsigned-byte &optional stream-designator) null) (proclamation set-pprint-dispatch (type-specifier (or function-designator null) &optional real si::pprint-dispatch-table) null) (proclamation write (t &key) t) (proclamation prin1 (t &optional stream-designator) t) (proclamation princ (t &optional stream-designator) t) (proclamation print (t &optional stream-designator) t) (proclamation pprint (t &optional stream-designator) (values)) (proclamation write-to-string (t &key) string) (proclamation prin1-to-string (t) string) (proclamation princ-to-string (t) string) (proclamation format ((or stream-designator string) format-control &rest t) (or null string)) ;; Slot accessor: ;; (proclamation print-not-readable-object (condition) t) ;;; ;;; 23. READER ;;; (proclamation copy-readtable (&optional readtable-designator (or readtable null)) readtable :no-side-effects) (proclamation make-dispatch-macro-character (character &optional gen-bool readtable) (member t)) (proclamation read (&optional stream-designator gen-bool t gen-bool) t) (proclamation read-preserving-whitespace (&optional stream-designator gen-bool t gen-bool) t) (proclamation read-delimited-list (character &optional stream-designator gen-bool) list) (proclamation read-from-string (string &optional gen-bool t &key) (values t ext:array-index)) (proclamation readtable-case (readtable) (member :upcase :downcase :preserve :invert) :reader) (proclamation readtablep (t) gen-bool :pure) (proclamation get-dispatch-macro-character (character character &optional readtable-designator) (or function-designator null) :reader) (proclamation set-dispatch-macro-character (character character function-designator &optional readtable-designator) (member t)) (proclamation get-macro-character (character &optional readtable-designator) (values (or function-designator null) gen-bool) :reader) (proclamation set-macro-character (character function-designator &optional gen-bool readtable-designator) (member t)) (proclamation set-syntax-from-char (character character &optional readtable readtable-designator) (member t)) ;; ECL extensions: (proclamation si:string-to-object (string &optional t) t) (proclamation si:standard-readtable () readtable) ;;; ;;; 24. SYSTEM CONSTRUCTION ;;; (proclamation compile-file (pathname-designator &key) (values (or pathname null) gen-bool gen-bool)) (proclamation compile-file-pathname (pathname-designator &key) pathname :no-side-effects) (proclamation load ((or stream pathname-designator) &key) gen-bool) (proclamation provide (string-designator) t) (proclamation require (string-designator &optional list) t) ;; ECL extensions (proclamation si:clear-compiler-properties (symbol) t) ;;; ;;; 25. ENVIRONMENT ;;; (proclamation decode-universal-time (universal-time &optional time-zone) (values (integer 0 59) (integer 0 59) (integer 0 23) (integer 1 31) (integer 1 12) unsigned-byte (integer 0 6) gen-bool time-zone) :pure) (proclamation encode-universal-time ((integer 0 59) (integer 0 59) (integer 0 23) (integer 1 31) (integer 1 12) unsigned-byte &optional time-zone) universal-time :pure) (proclamation get-universal-time () universal-time :no-side-effects) (proclamation get-decoded-time () (values (integer 0 59) (integer 0 59) (integer 0 23) (integer 1 31) (integer 1 12) unsigned-byte (integer 0 6) gen-bool time-zone) :no-side-effects) (proclamation sleep ((real 0 *)) null) (proclamation apropos (string-designator &optional (or null package-designator)) (values)) (proclamation apropos-list (string-designator &optional (or null package-designator)) list) (proclamation describe (t &optional stream-designator) (values)) (proclamation get-internal-real-time () unsigned-byte :no-side-effects) (proclamation get-internal-run-time () unsigned-byte :no-side-effects) (proclamation disassemble ((or function-designator list)) null) (proclamation room (&optional (member t nil :default)) (values &rest t)) (proclamation ed (&optional (or null pathname string function-name)) (values &rest t)) (proclamation inspect (t) (values &rest t)) (proclamation dribble (&optional pathname-designator) (values &rest t)) (proclamation lisp-implementation-type () (or string null) :pure) (proclamation lisp-implementation-version () (or string null) :pure) (proclamation short-site-name () (or string null) :pure) (proclamation long-site-name () (or string null) :pure) (proclamation machine-instance () (or string null) :pure) (proclamation machine-type () (or string null) :pure) (proclamation machine-version () (or string null) :pure) (proclamation software-type () (or string null) :pure) (proclamation software-version () (or string null) :pure) (proclamation user-homedir-pathname (&optional pathname-host) (or pathname null) :no-side-effects) ;; ECL extensions (proclamation ext::lisp-implementation-vcs-id () string :pure) (proclamation si::room-report () (values t t t t t t t t)) (proclamation si::reset-gbc-count () t) (proclamation ext:gc (&optional gen-bool) t) (proclamation ext:quit (&optional fixnum) t) (proclamation ext:argc () sequence-index) (proclamation ext:argv (unsigned-byte) base-string) (proclamation ext:getenv (string) (or null string)) (proclamation ext:environ () list) (proclamation ext:system (string) fixnum) (proclamation ext:getpid () si::index) (proclamation ext:make-pipe () (or two-way-stream null)) (proclamation ext:run-program (string list &key) (values (or null two-way-stream) (or null integer) ext:external-process)) (proclamation ext:make-weak-pointer (t) ext:weak-pointer :no-side-effects) (proclamation ext:weak-pointer-value (ext:weak-pointer) t) (proclamation si:unbound () t :pure) (proclamation si:traced-old-definition (t) t :no-side-effects) #+clos (proclamation si:allocate-raw-instance (t t fixnum) ext:instance) #+clos (proclamation clos:safe-instance-ref (t fixnum) t) #+clos (proclamation si:instance-ref (t fixnum) t :reader) #+clos (proclamation si::instance-sig (standard-object) list :reader) #+clos (proclamation si:instance-set (t fixnum t) t) #+clos (proclamation si:instance-class (t) class :reader) #+clos (proclamation si:instance-class-set (t t) t) #+clos (proclamation si:instancep (t) t :pure) #+clos (proclamation si:sl-boundp (t) t :reader) #+clos (proclamation si:sl-makunbound (t fixnum) t) #+clos (proclamation clos:standard-instance-access (standard-object t) t :reader) #+clos (proclamation clos:funcallable-standard-instance-access (clos:funcallable-standard-object t) t :reader) #+clos (proclamation associate-methods-to-gfun (generic-function *) generic-function) #+clos (proclamation clos::need-to-make-load-form-p (t t) gen-bool :pure) #+clos (proclamation clos::load-defclass (t t t t) t) ;;; ;;; A. FFI ;;; (proclamation si:pointer (t) unsigned-byte) (proclamation si:foreign-data-p (t) gen-bool :pure) ;;; ;;; CDR-5 http://cdr.eurolisp.org/document/5/extra-num-types.html ;;; (proclamation ext:negative-fixnum-p (t) gen-bool :pure) (proclamation ext:non-negative-fixnum-p (t) gen-bool :pure) (proclamation ext:non-positive-fixnum-p (t) gen-bool :pure) (proclamation ext:positive-fixnum-p (t) gen-bool :pure) (proclamation ext:array-index-p (t) gen-bool :pure) (proclamation ext:negative-integer-p (t) gen-bool :pure) (proclamation ext:non-negative-integer-p (t) gen-bool :pure) (proclamation ext:non-positive-integer-p (t) gen-bool :pure) (proclamation ext:positive-integer-p (t) gen-bool :pure) (proclamation ext:negative-rational-p (t) gen-bool :pure) (proclamation ext:non-negative-rational-p (t) gen-bool :pure) (proclamation ext:non-positive-rational-p (t) gen-bool :pure) (proclamation ext:positive-rational-p (t) gen-bool :pure) (proclamation ext:negative-ratio-p (t) gen-bool :pure) (proclamation ext:non-negative-ratio-p (t) gen-bool :pure) (proclamation ext:non-positive-ratio-p (t) gen-bool :pure) (proclamation ext:positive-ratio-p (t) gen-bool :pure) (proclamation ext:negative-real-p (t) gen-bool :pure) (proclamation ext:non-negative-real-p (t) gen-bool :pure) (proclamation ext:non-positive-real-p (t) gen-bool :pure) (proclamation ext:positive-real-p (t) gen-bool :pure) (proclamation ext:negative-float-p (t) gen-bool :pure) (proclamation ext:non-negative-float-p (t) gen-bool :pure) (proclamation ext:non-positive-float-p (t) gen-bool :pure) (proclamation ext:positive-float-p (t) gen-bool :pure) (proclamation ext:negative-short-float-p (t) gen-bool :pure) (proclamation ext:non-negative-short-float-p (t) gen-bool :pure) (proclamation ext:non-positive-short-float-p (t) gen-bool :pure) (proclamation ext:positive-short-float-p (t) gen-bool :pure) (proclamation ext:negative-single-float-p (t) gen-bool :pure) (proclamation ext:non-negative-single-float-p (t) gen-bool :pure) (proclamation ext:non-positive-single-float-p (t) gen-bool :pure) (proclamation ext:positive-single-float-p (t) gen-bool :pure) (proclamation ext:negative-double-float-p (t) gen-bool :pure) (proclamation ext:non-negative-double-float-p (t) gen-bool :pure) (proclamation ext:non-positive-double-float-p (t) gen-bool :pure) (proclamation ext:positive-double-float-p (t) gen-bool :pure) (proclamation ext:negative-long-float-p (t) gen-bool :pure) (proclamation ext:non-negative-long-float-p (t) gen-bool :pure) (proclamation ext:non-positive-long-float-p (t) gen-bool :pure) (proclamation ext:positive-long-float-p (t) gen-bool :pure) ))) ; eval-when (loop for i in '#.(mapcar #'rest +proclamations+) do (apply #'parse-function-proclamation i)) ecl-16.1.2/src/cmp/sysfun.lsp000066400000000000000000001303421266352375300160000ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil; Package: C -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; ;;; CMPSYSFUN Database for system functions. ;;; ;;; Copyright (c) 2003, Juan Jose Garcia Ripoll ;;; Copyright (c) 1991, Giuseppe Attardi. All rights reserved. ;;; Copying of this file is authorized to users who have executed the true ;;; and proper "License Agreement for ECoLisp". ;;; ;;; DATABASE OF INLINE EXPANSIONS ;;; ;;; (DEF-INLINE function-name kind ([arg-type]*) return-rep-type ;;; expansion-string) ;;; ;;; Here, ARG-TYPE is the list of argument types belonging to the lisp family, ;;; while RETURN-REP-TYPE is a representation type, i.e. the C type of the ;;; output expression. EXPANSION-STRING is a C/C++ expression template, like the ;;; ones used by C-INLINE. Finally, KIND can be :ALWAYS, :SAFE or :UNSAFE, ;;; depending on whether the inline expression should be applied always, in safe ;;; or in unsafe compilation mode, respectively. ;;; (in-package "COMPILER") (eval-when (:compile-toplevel :execute) (defparameter +inline-forms+ '( ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; ;;; ALL FUNCTION DECLARATIONS AND INLINE FORMS ;;; (def-inline aref :unsafe (t t t) t "@0;ecl_aref_unsafe(#0,ecl_fixnum(#1)*(#0)->array.dims[1]+ecl_fixnum(#2))") (def-inline aref :unsafe ((array t) t t) t "@0;(#0)->array.self.t[ecl_fixnum(#1)*(#0)->array.dims[1]+ecl_fixnum(#2)]") (def-inline aref :unsafe ((array bit) t t) :fixnum "@0;ecl_aref_bv(#0,ecl_fixnum(#1)*(#0)->array.dims[1]+ecl_fixnum(#2))") (def-inline aref :unsafe ((array t) fixnum fixnum) t "@0;(#0)->array.self.t[#1*(#0)->array.dims[1]+#2]") (def-inline aref :unsafe ((array bit) fixnum fixnum) :fixnum "@0;ecl_aref_bv(#0,(#1)*(#0)->array.dims[1]+#2)") (def-inline aref :unsafe ((array base-char) fixnum fixnum) :unsigned-char "@0;(#0)->base_string.self[#1*(#0)->array.dims[1]+#2]") (def-inline aref :unsafe ((array double-float) fixnum fixnum) :double "@0;(#0)->array.self.df[#1*(#0)->array.dims[1]+#2]") (def-inline aref :unsafe ((array single-float) fixnum fixnum) :float "@0;(#0)->array.self.sf[#1*(#0)->array.dims[1]+#2]") (def-inline aref :unsafe ((array fixnum) fixnum fixnum) :fixnum "@0;(#0)->array.self.fix[#1*(#0)->array.dims[1]+#2]") (def-inline aref :always (t t) t "ecl_aref1(#0,ecl_to_size(#1))") (def-inline aref :always (t fixnum) t "ecl_aref1(#0,#1)") (def-inline aref :unsafe (t t) t "ecl_aref1(#0,ecl_fixnum(#1))") (def-inline aref :unsafe ((array bit) t) :fixnum "ecl_aref_bv(#0,ecl_fixnum(#1))") (def-inline aref :unsafe ((array bit) fixnum) :fixnum "ecl_aref_bv(#0,#1)") #+unicode (def-inline aref :unsafe ((array character) fixnum) :wchar "(#0)->string.self[#1]") (def-inline aref :unsafe ((array base-char) fixnum) :unsigned-char "(#0)->base_string.self[#1]") (def-inline aref :unsafe ((array double-float) fixnum) :double "(#0)->array.self.df[#1]") (def-inline aref :unsafe ((array single-float) fixnum) :float "(#0)->array.self.sf[#1]") (def-inline aref :unsafe ((array fixnum) fixnum) :fixnum "(#0)->array.self.fix[#1]") (def-inline row-major-aref :always (t t) t "ecl_aref(#0,ecl_to_size(#1))") (def-inline row-major-aref :always (t fixnum) t "ecl_aref(#0,#1)") (def-inline row-major-aref :unsafe (t t) t "ecl_aref_unsafe(#0,ecl_fixnum(#1))") (def-inline row-major-aref :unsafe (t fixnum) t "ecl_aref_unsafe(#0,#1)") (def-inline row-major-aref :unsafe ((array bit) t) :fixnum "ecl_aref_bv(#0,ecl_fixnum(#1))") (def-inline row-major-aref :unsafe ((array bit) fixnum) :fixnum "ecl_aref_bv(#0,#1)") #+unicode (def-inline row-major-aref :unsafe ((array character) fixnum) :wchar "(#0)->string.self[#1]") (def-inline row-major-aref :unsafe ((array base-char) fixnum) :unsigned-char "(#0)->base_string.self[#1]") (def-inline row-major-aref :unsafe ((array ext:byte8) fixnum) :uint8-t "(#0)->vector.self.b8[#1]") (def-inline row-major-aref :unsafe ((array ext:integer8) fixnum) :int8-t "(#0)->vector.self.i8[#1]") (def-inline row-major-aref :unsafe ((array ext:byte16) fixnum) :uint16-t "(#0)->vector.self.b16[#1]") (def-inline row-major-aref :unsafe ((array ext:integer16) fixnum) :int16-t "(#0)->vector.self.i16[#1]") (def-inline row-major-aref :unsafe ((array ext:byte32) fixnum) :uint32-t "(#0)->vector.self.b32[#1]") (def-inline row-major-aref :unsafe ((array ext:integer32) fixnum) :int32-t "(#0)->vector.self.i32[#1]") (def-inline row-major-aref :unsafe ((array ext:byte64) fixnum) :uint64-t "(#0)->vector.self.b64[#1]") (def-inline row-major-aref :unsafe ((array ext:integer64) fixnum) :int64-t "(#0)->vector.self.i64[#1]") (def-inline row-major-aref :unsafe ((array double-float) fixnum) :double "(#0)->array.self.df[#1]") (def-inline row-major-aref :unsafe ((array single-float) fixnum) :float "(#0)->array.self.sf[#1]") (def-inline row-major-aref :unsafe ((array fixnum) fixnum) :fixnum "(#0)->array.self.fix[#1]") (def-inline si:row-major-aset :always (t t t) t "ecl_aset(#0,ecl_to_size(#1),#2)") (def-inline si:row-major-aset :always (t fixnum t) t "ecl_aset(#0,#1,#2)") (def-inline si:row-major-aset :unsafe (t t t) t "ecl_aset_unsafe(#0,ecl_fixnum(#1),#2)") (def-inline si:row-major-aset :unsafe (t fixnum t) t "ecl_aset_unsafe(#0,#1,#2)") (def-inline si:row-major-aset :unsafe ((array t) fixnum t) t "(#0)->vector.self.t[#1]= #2") (def-inline si:row-major-aset :unsafe ((array bit) fixnum t) :fixnum "ecl_aset_bv(#0,#1,ecl_fixnum(#2))") (def-inline si:row-major-aset :unsafe ((array bit) fixnum fixnum) :fixnum "ecl_aset_bv(#0,#1,#2)") (def-inline si:row-major-aset :unsafe ((array base-char) fixnum base-char) :unsigned-char "(#0)->base_string.self[#1]= #2") #+unicode (def-inline si:row-major-aset :unsafe ((array character) fixnum character) :wchar "(#0)->string.self[#1]= #2") (def-inline si:row-major-aset :unsafe ((array ext:byte8) fixnum ext:byte8) :uint8-t "(#0)->vector.self.b8[#1]= #2") (def-inline si:row-major-aset :unsafe ((array ext:integer8) fixnum ext:integer8) :int8-t "(#0)->vector.self.i8[#1]= #2") (def-inline si:row-major-aset :unsafe ((array ext:byte16) fixnum ext:byte16) :uint16-t "(#0)->vector.self.b16[#1]= #2") (def-inline si:row-major-aset :unsafe ((array ext:integer16) fixnum ext:integer16) :int16-t "(#0)->vector.self.i16[#1]= #2") (def-inline si:row-major-aset :unsafe ((array ext:byte32) fixnum ext:byte32) :uint32-t "(#0)->vector.self.b32[#1]= #2") (def-inline si:row-major-aset :unsafe ((array ext:integer32) fixnum ext:integer32) :int32-t "(#0)->vector.self.i32[#1]= #2") (def-inline si:row-major-aset :unsafe ((array ext:byte64) fixnum ext:byte64) :uint64-t "(#0)->vector.self.b64[#1]= #2") (def-inline si:row-major-aset :unsafe ((array ext:integer64) fixnum ext:integer64) :int64-t "(#0)->vector.self.i64[#1]= #2") (def-inline si:row-major-aset :unsafe ((array double-float) fixnum double-float) :double "(#0)->array.self.df[#1]= #2") (def-inline si:row-major-aset :unsafe ((array single-float) fixnum single-float) :float "(#0)->array.self.sf[#1]= #2") (def-inline si:row-major-aset :unsafe ((array fixnum) fixnum fixnum) :fixnum "(#0)->array.self.fix[#1]= #2") (def-inline si:copy-subarray :always (array ext:array-index array ext:array-index ext:array-index) array "@0;(ecl_copy_subarray(#0,#1,#2,#3,#4),#0)") (def-inline array-rank :unsafe (array) :fixnum "@0;(((#0)->d.t == t_array)?(#0)->array.rank:1)") (def-inline array-rank :always (array) :fixnum "ecl_array_rank(#0)") (def-inline array-dimension :always (t t) fixnum "ecl_array_dimension(#0,ecl_to_size(#1))") (def-inline array-dimension :always (t fixnum) fixnum "ecl_array_dimension(#0,#1)") (def-inline array-total-size :unsafe (t) :fixnum "((#0)->array.dim)") (def-inline adjustable-array-p :always (t) :bool "@0;(ECL_ARRAYP(#0)? (void)0: FEtype_error_array(#0),ECL_ADJUSTABLE_ARRAY_P(#0))") (def-inline adjustable-array-p :unsafe (array) :bool "ECL_ADJUSTABLE_ARRAY_P(#0)") (def-inline svref :always (t t) t "ecl_aref1(#0,ecl_to_size(#1))") (def-inline svref :always (t fixnum) t "ecl_aref1(#0,#1)") (def-inline svref :unsafe (t t) t "(#0)->vector.self.t[ecl_fixnum(#1)]") (def-inline svref :unsafe (t fixnum) t "(#0)->vector.self.t[#1]") (def-inline si:svset :always (t t t) t "ecl_aset1(#0,ecl_to_size(#1),#2)") (def-inline si:svset :always (t fixnum t) t "ecl_aset1(#0,#1,#2)") (def-inline si:svset :unsafe (t t t) t "((#0)->vector.self.t[ecl_fixnum(#1)]=(#2))") (def-inline si:svset :unsafe (t fixnum t) t "(#0)->vector.self.t[#1]= #2") (def-inline array-has-fill-pointer-p :always (t) :bool "@0;(ECL_ARRAYP(#0)?(void)0:FEtype_error_array(#0),ECL_ARRAY_HAS_FILL_POINTER_P(#0))") (def-inline array-has-fill-pointer-p :unsafe (array) :bool "ECL_ARRAY_HAS_FILL_POINTER_P(#0)") (def-inline fill-pointer :unsafe (t) :fixnum "((#0)->vector.fillp)") (def-inline si:fill-pointer-set :unsafe (t fixnum) :fixnum "((#0)->vector.fillp)=(#1)") ;; file character.d (def-inline standard-char-p :always (character) :bool "ecl_standard_char_p(#0)") (def-inline graphic-char-p :always (character) :bool "ecl_graphic_char_p(#0)") (def-inline alpha-char-p :always (character) :bool "ecl_alpha_char_p(#0)") (def-inline upper-case-p :always (character) :bool "ecl_upper_case_p(#0)") (def-inline lower-case-p :always (character) :bool "ecl_lower_case_p(#0)") (def-inline both-case-p :always (character) :bool "ecl_both_case_p(#0)") (def-inline alphanumericp :always (character) :bool "ecl_alphanumericp(#0)") (def-inline char= :always (t t) :bool "ecl_char_code(#0)==ecl_char_code(#1)") (def-inline char= :always (character character) :bool "(#0)==(#1)") (def-inline char/= :always (t t) :bool "ecl_char_code(#0)!=ecl_char_code(#1)") (def-inline char/= :always (character character) :bool "(#0)!=(#1)") (def-inline char< :always (character character) :bool "(#0)<(#1)") (def-inline char> :always (character character) :bool "(#0)>(#1)") (def-inline char<= :always (character character) :bool "(#0)<=(#1)") (def-inline char>= :always (character character) :bool "(#0)>=(#1)") (def-inline char-code :always (character) :fixnum "#0") (def-inline code-char :always (fixnum) :wchar "#0") (def-inline char-upcase :always (base-char) :unsigned-char "ecl_char_upcase(#0)") (def-inline char-upcase :always (character) :wchar "ecl_char_upcase(#0)") (def-inline char-downcase :always (base-char) :unsigned-char "ecl_char_downcase(#0)") (def-inline char-downcase :always (character) :wchar "ecl_char_downcase(#0)") (def-inline char-int :always (character) :fixnum "#0") ;; file ffi.d (def-inline si:foreign-data-p :always (t) :bool "@0;ECL_FOREIGN_DATA_P(#0)") ;; file file.d (def-inline input-stream-p :always (stream) :bool "ecl_input_stream_p(#0)") (def-inline output-stream-p :always (stream) :bool "ecl_output_stream_p(#0)") ;; file hash.d (def-inline gethash :always (t t t) t "ecl_gethash_safe(#0,#1,#2)" :multiple-values nil) (def-inline gethash :always (t t) t "ecl_gethash_safe(#0,#1,ECL_NIL)" :multiple-values nil) (def-inline hash-table-count :unsafe (hash-table) ext:array-index "ecl_hash_table_count(#0)") ;; file list.d (def-inline car :unsafe (cons) t "ECL_CONS_CAR(#0)") (def-inline car :unsafe (t) t "_ecl_car(#0)") (def-inline si::cons-car :always (t) t "_ecl_car(#0)") (def-inline si::cons-car :unsafe (t) t "ECL_CONS_CAR(#0)") (def-inline cdr :unsafe (cons) t "ECL_CONS_CDR(#0)") (def-inline cdr :unsafe (t) t "_ecl_cdr(#0)") (def-inline si::cons-cdr :always (t) t "_ecl_cdr(#0)") (def-inline si::cons-cdr :unsafe (t) t "ECL_CONS_CDR(#0)") ;; BEGIN-GENERATED (gen-cons-sysfun) (def-inline car :always (t) t "ecl_car(#0)") (def-inline car :unsafe (t) t "_ecl_car(#0)") (def-inline cdr :always (t) t "ecl_cdr(#0)") (def-inline cdr :unsafe (t) t "_ecl_cdr(#0)") (def-inline caar :always (t) t "ecl_caar(#0)") (def-inline caar :unsafe (t) t "_ecl_caar(#0)") (def-inline cdar :always (t) t "ecl_cdar(#0)") (def-inline cdar :unsafe (t) t "_ecl_cdar(#0)") (def-inline cadr :always (t) t "ecl_cadr(#0)") (def-inline cadr :unsafe (t) t "_ecl_cadr(#0)") (def-inline cddr :always (t) t "ecl_cddr(#0)") (def-inline cddr :unsafe (t) t "_ecl_cddr(#0)") (def-inline caaar :always (t) t "ecl_caaar(#0)") (def-inline caaar :unsafe (t) t "_ecl_caaar(#0)") (def-inline cdaar :always (t) t "ecl_cdaar(#0)") (def-inline cdaar :unsafe (t) t "_ecl_cdaar(#0)") (def-inline cadar :always (t) t "ecl_cadar(#0)") (def-inline cadar :unsafe (t) t "_ecl_cadar(#0)") (def-inline cddar :always (t) t "ecl_cddar(#0)") (def-inline cddar :unsafe (t) t "_ecl_cddar(#0)") (def-inline caadr :always (t) t "ecl_caadr(#0)") (def-inline caadr :unsafe (t) t "_ecl_caadr(#0)") (def-inline cdadr :always (t) t "ecl_cdadr(#0)") (def-inline cdadr :unsafe (t) t "_ecl_cdadr(#0)") (def-inline caddr :always (t) t "ecl_caddr(#0)") (def-inline caddr :unsafe (t) t "_ecl_caddr(#0)") (def-inline cdddr :always (t) t "ecl_cdddr(#0)") (def-inline cdddr :unsafe (t) t "_ecl_cdddr(#0)") (def-inline caaaar :always (t) t "ecl_caaaar(#0)") (def-inline caaaar :unsafe (t) t "_ecl_caaaar(#0)") (def-inline cdaaar :always (t) t "ecl_cdaaar(#0)") (def-inline cdaaar :unsafe (t) t "_ecl_cdaaar(#0)") (def-inline cadaar :always (t) t "ecl_cadaar(#0)") (def-inline cadaar :unsafe (t) t "_ecl_cadaar(#0)") (def-inline cddaar :always (t) t "ecl_cddaar(#0)") (def-inline cddaar :unsafe (t) t "_ecl_cddaar(#0)") (def-inline caadar :always (t) t "ecl_caadar(#0)") (def-inline caadar :unsafe (t) t "_ecl_caadar(#0)") (def-inline cdadar :always (t) t "ecl_cdadar(#0)") (def-inline cdadar :unsafe (t) t "_ecl_cdadar(#0)") (def-inline caddar :always (t) t "ecl_caddar(#0)") (def-inline caddar :unsafe (t) t "_ecl_caddar(#0)") (def-inline cdddar :always (t) t "ecl_cdddar(#0)") (def-inline cdddar :unsafe (t) t "_ecl_cdddar(#0)") (def-inline caaadr :always (t) t "ecl_caaadr(#0)") (def-inline caaadr :unsafe (t) t "_ecl_caaadr(#0)") (def-inline cdaadr :always (t) t "ecl_cdaadr(#0)") (def-inline cdaadr :unsafe (t) t "_ecl_cdaadr(#0)") (def-inline cadadr :always (t) t "ecl_cadadr(#0)") (def-inline cadadr :unsafe (t) t "_ecl_cadadr(#0)") (def-inline cddadr :always (t) t "ecl_cddadr(#0)") (def-inline cddadr :unsafe (t) t "_ecl_cddadr(#0)") (def-inline caaddr :always (t) t "ecl_caaddr(#0)") (def-inline caaddr :unsafe (t) t "_ecl_caaddr(#0)") (def-inline cdaddr :always (t) t "ecl_cdaddr(#0)") (def-inline cdaddr :unsafe (t) t "_ecl_cdaddr(#0)") (def-inline cadddr :always (t) t "ecl_cadddr(#0)") (def-inline cadddr :unsafe (t) t "_ecl_cadddr(#0)") (def-inline cddddr :always (t) t "ecl_cddddr(#0)") (def-inline cddddr :unsafe (t) t "_ecl_cddddr(#0)") ;; END-GENERATED (def-inline cons :always (t t) t "CONS(#0,#1)") (def-inline endp :safe (t) :bool "ecl_endp(#0)") (def-inline endp :unsafe (t) :bool "#0==ECL_NIL") (def-inline nth :always (t t) t "ecl_nth(ecl_to_size(#0),#1)") (def-inline nth :always (fixnum t) t "ecl_nth(#0,#1)") (def-inline nth :unsafe (t t) t "ecl_nth(ecl_fixnum(#0),#1)") (def-inline nth :unsafe (fixnum t) t "ecl_nth(#0,#1)") (def-inline nthcdr :always (t t) t "ecl_nthcdr(ecl_to_size(#0),#1)") (def-inline nthcdr :always (fixnum t) t "ecl_nthcdr(#0,#1)") (def-inline nthcdr :unsafe (t t) t "ecl_nthcdr(ecl_fixnum(#0),#1)") (def-inline nthcdr :unsafe (fixnum t) t "ecl_nthcdr(#0,#1)") (def-inline last :always (t) t "ecl_last(#0,1)") (def-inline list :always nil t "ECL_NIL") (def-inline list :always (t) t "ecl_list1(#0)") (def-inline list* :always (t) t "#0") (def-inline list* :always (t t) t "CONS(#0,#1)") (def-inline append :always (t t) t "ecl_append(#0,#1)") (def-inline nconc :always (t t) t "ecl_nconc(#0,#1)") (def-inline butlast :always (t) t "ecl_butlast(#0,1)") (def-inline nbutlast :always (t) t "ecl_nbutlast(#0,1)") ;; file num_arith.d (def-inline 1+ :always (t) t "ecl_one_plus(#0)") (def-inline 1+ :always (fixnum) t "ecl_make_integer((#0)+1)") (def-inline 1+ :always (double-float) :double "(double)(#0)+1") (def-inline 1+ :always (single-float) :float "(float)(#0)+1") (def-inline 1+ :always (fixnum) :fixnum "(#0)+1" :exact-return-type t) (def-inline 1- :always (t) t "ecl_one_minus(#0)") (def-inline 1- :always (fixnum) t "ecl_make_integer((#0)-1)") (def-inline 1- :always (double-float) :double "(double)(#0)-1") (def-inline 1- :always (single-float) :float "(float)(#0)-1") (def-inline 1- :always (fixnum) :fixnum "(#0)-1" :exact-return-type t) ;; file num_co.d (def-inline float :always (t single-float) :float "ecl_to_float(#0)") (def-inline float :always (t double-float) :double "ecl_to_double(#0)") #+long-float (def-inline float :always (t long-float) :long-double "ecl_to_long_double(#0)") (def-inline float :always (fixnum-float) :double "((double)(#0))" :exact-return-type t) (def-inline float :always (fixnum-float) :float "((float)(#0))" :exact-return-type t) (def-inline numerator :unsafe (integer) integer "(#0)") (def-inline numerator :unsafe (ratio) integer "(#0)->ratio.num") (def-inline denominator :unsafe (integer) integer "ecl_make_fixnum(1)") (def-inline denominator :unsafe (ratio) integer "(#0)->ratio.den") (def-inline floor :always (t) (values &rest t) "ecl_floor1(#0)") (def-inline floor :always (t t) (values &rest t) "ecl_floor2(#0,#1)") #+(or) ; does not work well, no multiple values (def-inline floor :always (fixnum fixnum) :fixnum "@01;(#0>=0&>0?(#0)/(#1):ecl_ifloor(#0,#1))") (def-inline ceiling :always (t) (values &rest t) "ecl_ceiling1(#0)") (def-inline ceiling :always (t t) (values &rest t) "ecl_ceiling2(#0,#1)") (def-inline truncate :always (t) (values &rest t) "ecl_truncate1(#0)") (def-inline truncate :always (t t) (values &rest t) "ecl_truncate2(#0,#1)") #+(or) ; does not work well, no multiple values (def-inline truncate :always (fixnum-float) :fixnum "(cl_fixnum)(#0)") (def-inline round :always (t) (values &rest t) "ecl_round1(#0)") (def-inline round :always (t t) (values &rest t) "ecl_round2(#0,#1)") (def-inline mod :always (t t) t "(ecl_floor2(#0,#1),cl_env_copy->values[1])") (def-inline mod :always (fixnum fixnum) :fixnum "@01;(#0>=0&>0?(#0)%(#1):ecl_imod(#0,#1))") (def-inline rem :always (t t) t "(ecl_truncate2(#0,#1),cl_env_copy->values[1])") (def-inline rem :always (fixnum fixnum) :fixnum "(#0)%(#1)") (def-inline = :always (t t) :bool "ecl_number_equalp(#0,#1)") (def-inline = :always (fixnum-float fixnum-float) :bool "(#0)==(#1)") (def-inline /= :always (t t) :bool "!ecl_number_equalp(#0,#1)") (def-inline /= :always (fixnum-float fixnum-float) :bool "(#0)!=(#1)") (def-inline < :always (t t) :bool "ecl_number_compare(#0,#1)<0") (def-inline < :always (fixnum-float fixnum-float) :bool "(#0)<(#1)") (def-inline < :always (fixnum-float fixnum-float fixnum-float) :bool "@012;((#0)<(#1) && (#1)<(#2))") (def-inline > :always (t t) :bool "ecl_number_compare(#0,#1)>0") (def-inline > :always (fixnum-float fixnum-float) :bool "(#0)>(#1)") (def-inline > :always (fixnum-float fixnum-float fixnum-float) :bool "@012;((#0)>(#1) && (#1)>(#2))") (def-inline <= :always (t t) :bool "ecl_number_compare(#0,#1)<=0") (def-inline <= :always (fixnum-float fixnum-float) :bool "(#0)<=(#1)") (def-inline <= :always (fixnum-float fixnum-float fixnum-float) :bool "@012;((#0)<=(#1) && (#1)<=(#2))") (def-inline >= :always (t t) :bool "ecl_number_compare(#0,#1)>=0") (def-inline >= :always (fixnum-float fixnum-float) :bool "(#0)>=(#1)") (def-inline >= :always (fixnum-float fixnum-float fixnum-float) :bool "@012;((#0)>=(#1) && (#1)>=(#2))") (def-inline max :always (t t) t "@01;(ecl_number_compare(#0,#1)>=0?#0:#1)") (def-inline max :always (fixnum fixnum) :fixnum "@01;(#0)>=(#1)?#0:#1") (def-inline min :always (t t) t "@01;(ecl_number_compare(#0,#1)<=0?#0:#1)") (def-inline min :always (fixnum fixnum) :fixnum "@01;(#0)<=(#1)?#0:#1") ;; file num_log.d (def-inline logand :always nil t "ecl_make_fixnum(-1)") (def-inline logand :always nil :fixnum "-1") (def-inline logand :always (t t) t "ecl_boole(ECL_BOOLAND,(#0),(#1))") (def-inline logand :always (fixnum fixnum) :fixnum "((#0) & (#1))") (def-inline logandc1 :always (t t) t "ecl_boole(ECL_BOOLANDC1,(#0),(#1))") (def-inline logandc1 :always (fixnum fixnum) :fixnum "(~(#0) & (#1))") (def-inline logandc2 :always (t t) t "ecl_boole(ECL_BOOLANDC2,(#0),(#1))") (def-inline logandc2 :always (fixnum fixnum) :fixnum "((#0) & ~(#1))") (def-inline logeqv :always nil t "ecl_make_fixnum(-1)") (def-inline logeqv :always nil :fixnum "-1") (def-inline logeqv :always (t t) t "ecl_boole(ECL_BOOLEQV,(#0),(#1))") (def-inline logeqv :always (fixnum fixnum) :fixnum "(~( (#0) ^ (#1) ))") (def-inline logior :always nil t "ecl_make_fixnum(0)") (def-inline logior :always nil :fixnum "0") (def-inline logior :always (t t) t "ecl_boole(ECL_BOOLIOR,(#0),(#1))") (def-inline logior :always (fixnum fixnum) :fixnum "((#0) | (#1))") (def-inline lognand :always (t t) t "ecl_boole(ECL_BOOLNAND,(#0),(#1))") (def-inline lognand :always (fixnum fixnum) :fixnum "(~( (#0) & (#1) ))") (def-inline lognor :always (t t) t "ecl_boole(ECL_BOOLNOR,(#0),(#1))") (def-inline lognor :always (fixnum fixnum) :fixnum "(~( (#0) | (#1) ))") (def-inline lognot :always (t) t "ecl_boole(ECL_BOOLXOR,(#0),ecl_make_fixnum(-1))") (def-inline lognot :always (fixnum) :fixnum "(~(#0))") (def-inline logorc1 :always (t t) t "ecl_boole(ECL_BOOLORC1,(#0),(#1))") (def-inline logorc1 :always (fixnum fixnum) :fixnum "(~(#0) | (#1))") (def-inline logorc2 :always (t t) t "ecl_boole(ECL_BOOLORC2,(#0),(#1))") (def-inline logorc2 :always (fixnum fixnum) :fixnum "((#0) | ~(#1))") (def-inline logxor :always nil t "ecl_make_fixnum(0)") (def-inline logxor :always nil :fixnum "0") (def-inline logxor :always (t t) t "ecl_boole(ECL_BOOLXOR,(#0),(#1))") (def-inline logxor :always (fixnum fixnum) :fixnum "((#0) ^ (#1))") (def-inline boole :always (fixnum t t) t "ecl_boole((#0),(#1),(#2))") (def-inline logbitp :always ((integer -29 29) fixnum) :bool "(#1 >> #0) & 1") (def-inline integer-length :always (t) :cl-index "ecl_integer_length(#0)") (def-inline zerop :always (t) :bool "ecl_zerop(#0)") (def-inline zerop :always (fixnum-float) :bool "(#0)==0") (def-inline plusp :always (t) :bool "ecl_plusp(#0)") (def-inline plusp :always (fixnum-float) :bool "(#0)>0") (def-inline minusp :always (t) :bool "ecl_minusp(#0)") (def-inline minusp :always (fixnum-float) :bool "(#0)<0") (def-inline oddp :always (t) :bool "ecl_oddp(#0)") (def-inline oddp :always (fixnum fixnum) :bool "(#0) & 1") (def-inline evenp :always (t) :bool "ecl_evenp(#0)") (def-inline evenp :always (fixnum fixnum) :bool "~(#0) & 1") (def-inline abs :always (t t) t "ecl_abs(#0,#1)") (def-inline exp :always (t) t "ecl_exp(#0)") (def-inline expt :always (t t) t "ecl_expt(#0,#1)") (def-inline expt :always ((integer 2 2) (integer 0 29)) :fixnum "(1<<(#1))") (def-inline expt :always ((integer 0 0) t) :fixnum "0") (def-inline expt :always ((integer 1 1) t) :fixnum "1") (def-inline log :always (fixnum-float) :double "log((double)(#0))" :exact-return-type t) (def-inline log :always (fixnum-float) :float "(float)log((double)(#0))" :exact-return-type t) (def-inline sqrt :always (number) number "ecl_sqrt(#0)") (def-inline sqrt :always ((long-float 0.0 *)) :double "sqrt((double)(#0))") (def-inline sqrt :always ((double-float 0.0 *)) :double "sqrt((double)(#0))") (def-inline sqrt :always ((single-float 0.0 *)) :float "(float)sqrt((double)(#0))") (def-inline sqrt :always ((short-float 0.0 *)) :float "(float)sqrt((double)(#0))") (def-inline sin :always (number) number "ecl_sin(#0)") (def-inline sin :always (fixnum-float) :double "sin((double)(#0))" :exact-return-type t) (def-inline sin :always (fixnum-float) :float "(float)sin((double)(#0))" :exact-return-type t) (def-inline cos :always (t) number "ecl_cos(#0)") (def-inline cos :always (fixnum-float) :double "cos((double)(#0))" :exact-return-type t) (def-inline cos :always (fixnum-float) :float "(float)cos((double)(#0))" :exact-return-type t) (def-inline tan :always (t) number "ecl_tan(#0)") (def-inline tan :always (fixnum-float) :double "tan((double)(#0))" :exact-return-type t) (def-inline tan :always (fixnum-float) :float "(float)tan((double)(#0))" :exact-return-type t) (def-inline sinh :always (t) number "ecl_sinh(#0)") (def-inline sinh :always (fixnum-float) :double "sinh((double)(#0))" :exact-return-type t) (def-inline sinh :always (fixnum-float) :float "(float)sinh((double)(#0))" :exact-return-type t) (def-inline cosh :always (t) number "ecl_cosh(#0)") (def-inline cosh :always (fixnum-float) :double "cosh((double)(#0))" :exact-return-type t) (def-inline cosh :always (fixnum-float) :float "(float)cosh((double)(#0))" :exact-return-type t) (def-inline tanh :always (t) number "ecl_tanh(#0)") (def-inline tanh :always (fixnum-float) :double "tanh((double)(#0))" :exact-return-type t) (def-inline tanh :always (fixnum-float) :float "(float)tanh((double)(#0))" :exact-return-type t) ;; file package.d ;; file pathname.d (def-inline null :always (t) :bool "#0==ECL_NIL") (def-inline symbolp :always (t) :bool "@0;ECL_SYMBOLP(#0)") (def-inline atom :always (t) :bool "@0;ECL_ATOM(#0)") (def-inline consp :always (t) :bool "@0;ECL_CONSP(#0)") (def-inline listp :always (t) :bool "@0;ECL_LISTP(#0)") (def-inline numberp :always (t) :bool "ecl_numberp(#0)") (def-inline integerp :always (t) :bool "@0;ECL_FIXNUMP(#0)||ECL_BIGNUMP(#0)") (def-inline floatp :always (t) :bool "floatp(#0)") (def-inline characterp :always (t) :bool "ECL_CHARACTERP(#0)") (def-inline base-char-p :always (character) :bool "ECL_BASE_CHAR_P(#0)") (def-inline stringp :always (t) :bool "@0;ECL_STRINGP(#0)") (def-inline base-string-p :always (t) :bool "@0;ECL_BASE_STRINGP(#0)") (def-inline bit-vector-p :always (t) :bool "@0;ECL_BIT_VECTOR_P(#0)") (def-inline vectorp :always (t) :bool "@0;ECL_VECTORP(#0)") (def-inline arrayp :always (t) :bool "@0;ECL_ARRAYP(#0)") (def-inline eq :always (t t) :bool "(#0)==(#1)") (def-inline eq :always (fixnum fixnum) :bool "(#0)==(#1)") (def-inline eql :always (t t) :bool "ecl_eql(#0,#1)") (def-inline eql :always (character t) :bool "(ECL_CODE_CHAR(#0)==(#1))") (def-inline eql :always (t character) :bool "((#0)==ECL_CODE_CHAR(#1))") (def-inline eql :always (character character) :bool "(#0)==(#1)") (def-inline eql :always ((not (or complex bignum ratio float)) t) :bool "(#0)==(#1)") (def-inline eql :always (t (not (or complex bignum ratio float))) :bool "(#0)==(#1)") (def-inline eql :always (fixnum fixnum) :bool "(#0)==(#1)") (def-inline equal :always (t t) :bool "ecl_equal(#0,#1)") (def-inline equal :always (fixnum fixnum) :bool "(#0)==(#1)") (def-inline equalp :always (t t) :bool "ecl_equalp(#0,#1)") (def-inline equalp :always (fixnum fixnum) :bool "(#0)==(#1)") (def-inline not :always (t) :bool "(#0)==ECL_NIL") ;; file print.d, read.d (def-inline clear-output :always (stream) NULL "(ecl_clear_output(#0),ECL_NIL)") (def-inline finish-output :always (stream) NULL "(ecl_finish_output(#0),ECL_NIL)") (def-inline finish-output :always (stream) NULL "(ecl_force_output(#0),ECL_NIL)") (def-inline write-char :always (t) t "@0;(ecl_princ_char(ecl_char_code(#0),ECL_NIL),(#0))") (def-inline clear-input :always (stream) NULL "(ecl_clear_input(#0),ECL_NIL)") (def-inline copy-readtable :always (null null) t "standard_readtable") (def-inline boundp :always (t) :bool "ecl_boundp(cl_env_copy,#0)") (def-inline boundp :unsafe ((and symbol (not null))) :bool "ECL_SYM_VAL(cl_env_copy,#0)!=OBJNULL") ;; file unixsys.d ;; file sequence.d (def-inline elt :always (t t) t "ecl_elt(#0,ecl_fixnum(#1))") (def-inline elt :always (t fixnum) t "ecl_elt(#0,#1)") (def-inline elt :always (vector t) t "ecl_aref1(#0,ecl_fixnum(#1))") (def-inline elt :always (vector fixnum) t "ecl_aref1(#0,#1)") (def-inline elt :unsafe (t t) t "ecl_elt(#0,ecl_fixnum(#1))") (def-inline elt :unsafe (t fixnum) t "ecl_elt(#0,#1)") (def-inline elt :unsafe (vector t) t "ecl_aref_unsafe(#0,ecl_fixnum(#1))") (def-inline elt :unsafe (vector fixnum) t "ecl_aref_unsafe(#0,#1)") (def-inline aref :unsafe ((array bit) t) :fixnum "ecl_aref_bv(#0,ecl_fixnum(#1))") (def-inline aref :unsafe ((array bit) fixnum) :fixnum "ecl_aref_bv(#0,#1)") #+unicode (def-inline aref :unsafe ((array character) fixnum) :wchar "(#0)->string.self[#1]") (def-inline aref :unsafe ((array base-char) fixnum) :unsigned-char "(#0)->base_string.self[#1]") (def-inline aref :unsafe ((array double-float) fixnum) :double "(#0)->array.self.df[#1]") (def-inline aref :unsafe ((array single-float) fixnum) :float "(#0)->array.self.sf[#1]") (def-inline aref :unsafe ((array fixnum) fixnum) :fixnum "(#0)->array.self.fix[#1]") (def-inline si:elt-set :always (t t t) t "ecl_elt_set(#0,ecl_to_size(#1),#2)") (def-inline si:elt-set :always (t fixnum t) t "ecl_elt_set(#0,#1,#2)") (def-inline si:elt-set :always (vector t t) t "ecl_aset1(#0,ecl_to_size(#1),#2)") (def-inline si:elt-set :always (vector fixnum t) t "ecl_aset1(#0,#1,#2)") (def-inline si:elt-set :unsafe (t t t) t "ecl_elt_set(#0,ecl_fixnum(#1),#2)") (def-inline si:elt-set :unsafe (vector t t) t "ecl_aset_unsafe(#0,ecl_to_size(#1),#2)") (def-inline si:elt-set :unsafe (vector fixnum t) t "ecl_aset_unsafe(#0,#1,#2)") (def-inline length :always (t) :fixnum "ecl_length(#0)") (def-inline length :unsafe (vector) :fixnum "(#0)->vector.fillp") (def-inline copy-seq :always (t) t "ecl_copy_seq(#0)") ;; file character.d (def-inline char :always (t fixnum) t "ecl_aref1(#0,#1)") (def-inline char :always (t fixnum) :wchar "ecl_char(#0,#1)") #-unicode (def-inline char :unsafe (t t) t "ECL_CODE_CHAR((#0)->base_string.self[ecl_fixnum(#1)])") #-unicode (def-inline char :unsafe (t fixnum) :unsigned-char "(#0)->base_string.self[#1]") (def-inline char :unsafe (base-string fixnum) :unsigned-char "(#0)->base_string.self[#1]") #+unicode (def-inline char :unsafe (ext:extended-string fixnum) :wchar "(#0)->string.self[#1]") (def-inline si:char-set :always (t t t) t "si_char_set(#0,#1,#2)") (def-inline si:char-set :always (t fixnum t) t "ecl_aset1(#0,#1,#2)") (def-inline si:char-set :always (t fixnum character) :wchar "ecl_char_set(#0,#1,#2)") #-unicode (def-inline si:char-set :unsafe (t t t) t "@2;((#0)->base_string.self[ecl_fixnum(#1)]=ecl_char_code(#2),(#2))") #-unicode (def-inline si:char-set :unsafe (t fixnum character) :unsigned-char "(#0)->base_string.self[#1]= #2") (def-inline si:char-set :unsafe (base-string t t) t "@2;((#0)->base_string.self[ecl_fixnum(#1)]=ecl_char_code(#2),(#2))") (def-inline si:char-set :unsafe (base-string fixnum base-char) :unsigned-char "(#0)->base_string.self[#1]= #2") (def-inline si:char-set :unsafe (ext:extended-string t t) t "@2;((#0)->string.self[ecl_fixnum(#1)]=ecl_char_code(#2),(#2))") (def-inline si:char-set :unsafe (ext:extended-string fixnum character) :unsigned-char "(#0)->string.self[#1]= #2") (def-inline schar :always (t t) t "ecl_elt(#0,ecl_to_size(#1))") (def-inline schar :always (t fixnum) t "ecl_elt(#0,#1)") (def-inline schar :always (t fixnum) :wchar "ecl_char(#0,#1)") (def-inline schar :unsafe (base-string t) t "ECL_CODE_CHAR((#0)->base_string.self[ecl_fixnum(#1)])") #-unicode (def-inline schar :unsafe (t fixnum) :unsigned-char "(#0)->base_string.self[#1]") (def-inline schar :unsafe (base-string fixnum) :unsigned-char "(#0)->base_string.self[#1]") #+unicode (def-inline schar :unsafe (ext:extended-string fixnum) :wchar "(#0)->string.self[#1]") (def-inline si:schar-set :always (t t t) t "ecl_elt_set(#0,ecl_to_size(#1),#2)") (def-inline si:schar-set :always (t fixnum t) t "ecl_elt_set(#0,#1,#2)") (def-inline si:schar-set :always (t fixnum character) :wchar "ecl_char_set(#0,#1,#2)") #-unicode (def-inline si:schar-set :unsafe (t t t) t "@2;((#0)->base_string.self[ecl_fixnum(#1)]=ecl_char_code(#2),(#2))") #-unicode (def-inline si:schar-set :unsafe (t fixnum base-char) :unsigned-char "(#0)->base_string.self[#1]= #2") (def-inline si:schar-set :unsafe (base-string t t) t "@2;((#0)->base_string.self[ecl_fixnum(#1)]=ecl_char_code(#2),(#2))") (def-inline si:schar-set :unsafe (base-string fixnum base-char) :unsigned-char "(#0)->base_string.self[#1]= #2") #+unicode (def-inline si:schar-set :unsafe (ext:extended-string fixnum t) :wchar "@2;((#0)->string.self[#1]= ecl_char_code(#2),(#2))") #+unicode (def-inline si:schar-set :unsafe (ext:extended-string fixnum character) :wchar "(#0)->string.self[#1]= #2") (def-inline string= :always (string string) :bool "ecl_string_eq(#0,#1)") ;; file structure.d (def-inline si:structure-name :always (structure-object) symbol "ECL_STRUCT_NAME(#0)") (def-inline si:structure-ref :always (t t fixnum) t "ecl_structure_ref(#0,#1,#2)") (def-inline si:structure-set :always (t t fixnum t) t "ecl_structure_set(#0,#1,#2,#3)") ;; file symbol.d (def-inline get :always (t t t) t "ecl_get(#0,#1,#2)") (def-inline get :always (t t) t "ecl_get(#0,#1,ECL_NIL)") (def-inline symbol-name :always (t) string "ecl_symbol_name(#0)") ;; Additions used by the compiler. ;; The following functions do not exist. They are always expanded into the ;; given C code. References to these functions are generated in the C1 phase. (def-inline shift>> :always (fixnum fixnum) :fixnum "((#0) >> (- (#1)))") (def-inline shift<< :always (fixnum fixnum) :fixnum "((#0) << (#1))") (def-inline si:short-float-p :always (t) :bool "@0;ECL_SINGLE_FLOAT_P(#0)") (def-inline si:single-float-p :always (t) :bool "@0;ECL_SINGLE_FLOAT_P(#0)") (def-inline si:double-float-p :always (t) :bool "@0;ECL_DOUBLE_FLOAT_P(#0)") #-long-float (def-inline si:long-float-p :always (t) :bool "@0;ECL_DOUBLE_FLOAT_P(#0)") #+long-float (def-inline si:long-float-p :always (t) :bool "@0;ECL_LONG_FLOAT_P(#0)") (def-inline ext:fixnump :always (t) :bool "ECL_FIXNUMP(#0)") (def-inline ext:fixnump :always (fixnum) :bool "1") ;; Functions only available with threads #+threads (def-inline mp:lock-count :unsafe (mp:lock) fixnum "((#0)->lock.count)") ;; Functions only available with CLOS #+clos (def-inline si:instance-ref :always (t fixnum) t "ecl_instance_ref((#0),(#1))") #+clos (def-inline si:instance-ref :unsafe (standard-object fixnum) t "(#0)->instance.slots[#1]") #+clos (def-inline si::instance-sig :unsafe (standard-object) list "(#0)->instance.sig") #+clos (def-inline si:instance-set :unsafe (t fixnum t) t "ecl_instance_set((#0),(#1),(#2))") #+clos (def-inline si:instance-set :unsafe (standard-object fixnum t) t "(#0)->instance.slots[#1]=(#2)") #+clos (def-inline si:instance-class :always (standard-object) t "ECL_CLASS_OF(#0)") #+clos (def-inline class-of :unsafe (standard-object) t "ECL_CLASS_OF(#0)") #+clos (def-inline si::instancep :always (t) :bool "@0;ECL_INSTANCEP(#0)") #+clos (def-inline si:unbound :always nil t "ECL_UNBOUND") #+clos (def-inline si:sl-boundp :always (t) :bool "(#0)!=ECL_UNBOUND") #+clos (def-inline clos:standard-instance-access :always (t fixnum) t "ecl_instance_ref((#0),(#1))") #+clos (def-inline clos:standard-instance-access :unsafe (standard-object fixnum) t "(#0)->instance.slots[#1]") #+clos (def-inline clos:funcallable-standard-instance-access :always (t fixnum) t "ecl_instance_ref((#0),(#1))") #+clos (def-inline clos:funcallable-standard-instance-access :unsafe (clos:funcallable-standard-object fixnum) t "(#0)->instance.slots[#1]") ))) ; eval-when (defun make-inline-information (*machine*) (let ((*inline-information* (make-hash-table :size 512 :test 'equal))) (loop for i in '#.(mapcar #'rest +inline-forms+) do (apply #'def-inline i)) *inline-information*)) (defun inline-information (name safety) (gethash (list name safety) *inline-information*)) (defun (setf inline-information) (value name safety) (setf (gethash (list name safety) *inline-information*) value)) (defun def-inline (name safety arg-types return-rep-type expansion &key (one-liner t) (exact-return-type nil) (inline-or-warn nil) (multiple-values t) &aux arg-rep-types) (setf safety (case safety (:unsafe :inline-unsafe) (:safe :inline-safe) (:always :inline-always) (t (error "In DEF-INLINE, wrong value of SAFETY")))) ;; Ensure we can inline this form. We only inline when the features are ;; there (checked above) and when the C types are part of this machine ;; (checked here). (loop for type in (list* return-rep-type arg-types) unless (or (eq type 'fixnum-float) (and (consp type) (eq (car type) 'values)) (lisp-type-p type) (machine-c-type-p type)) do (warn "Dropping inline form for ~A because of missing type ~A" name type) (return-from def-inline)) (setf arg-rep-types (mapcar #'(lambda (x) (if (eq x '*) x (lisp-type->rep-type x))) arg-types)) (when (eq return-rep-type t) (setf return-rep-type :object)) (when inline-or-warn (setf (inline-information name 'should-be-inlined) t)) (let* ((return-type (if (and (consp return-rep-type) (eq (first return-rep-type) 'values)) t (rep-type->lisp-type return-rep-type))) (inline-info (make-inline-info :name name :arg-rep-types arg-rep-types :return-rep-type return-rep-type :return-type return-type :arg-types arg-types :exact-return-type exact-return-type :multiple-values multiple-values ;; :side-effects (not (get-sysprop name 'no-side-effects)) :one-liner one-liner :expansion expansion))) #+(or) (loop for i in (inline-information name safety) when (and (equalp (inline-info-arg-types i) arg-types) (not (equalp return-type (inline-info-return-type i)))) do (format t "~&;;; Redundand inline definition for ~A~&;;; ~<~A~>~&;;; ~<~A~>" name i inline-info)) (push inline-info (gethash (list name safety) *inline-information*)))) (setf (machine-inline-information +default-machine+) (make-inline-information +default-machine+)) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; ;;; FUNCTIONS WHICH CAN BE CALLED FROM C ;;; ;;; The following two lists contain all functions in the core library which do ;;; not belong to the C part of the library, but which should have an exported C ;;; name that users (and compiled code) can refer to. This means, for instance, that ;;; MAKE-ARRAY will be compiled to a function called cl_make_array, etc. ;;; (in-package "SI") (defvar c::*in-all-symbols-functions* `(;; arraylib.lsp make-array vector array-dimensions array-in-bounds-p array-row-major-index bit sbit bit-and bit-ior bit-xor bit-eqv bit-nand bit-nor bit-andc1 bit-andc2 bit-orc1 bit-orc2 bit-not vector-pop adjust-array ;; assert.lsp si::do-check-type si::ecase-error si::etypecase-error si::wrong-type-argument si::ccase-error si::ctypecase-error ;; config.lsp short-site-name long-site-name machine-type machine-instance machine-version software-type software-version lisp-implementation-type lisp-implementation-version si::lisp-implementation-vcs-id ;; assignment.lsp si::setf-definition ;; conditions.lsp si::safe-eval abort continue muffle-warning store-value use-value si::bind-simple-restarts si::bind-simple-handlers si::assert-failure compute-restarts find-restart invoke-restart invoke-restart-interactively make-condition ;; describe.lsp describe inspect ;; iolib.lsp read-from-string write-to-string prin1-to-string princ-to-string y-or-n-p yes-or-no-p string-to-object dribble ext:make-encoding ext:load-encoding ;; listlib.lsp union nunion intersection nintersection set-difference nset-difference set-exclusive-or nset-exclusive-or subsetp rassoc-if rassoc-if-not assoc-if assoc-if-not member-if member-if-not subst-if subst-if-not nsubst-if nsubst-if-not ;; mislib.lsp logical-pathname-translations load-logical-pathname-translations decode-universal-time encode-universal-time get-decoded-time ensure-directories-exist si::simple-program-error si::signal-simple-error ;; module.lsp provide require ;; numlib.lsp isqrt phase signum cis asin acos asinh acosh atanh ffloor fceiling ftruncate fround logtest byte byte-size byte-position ldb ldb-test mask-field dpb deposit-field ;; packlib.lsp find-all-symbols apropos apropos-list find-relative-package package-parent package-children ;; predlib.lsp upgraded-array-element-type upgraded-complex-part-type typep subtypep coerce do-deftype si::ratiop si::single-float-p si::short-float-p si::double-float-p si::long-float-p ;; seq.lsp make-sequence concatenate map some every notany notevery map-into complement ;; seqlib.lsp reduce fill replace remove remove-if remove-if-not delete delete-if delete-if-not count count-if count-if-not substitute substitute-if substitute-if-not nsubstitute nsubstitute-if nsubstitute-if-not find find-if find-if-not position position-if position-if-not remove-duplicates delete-duplicates mismatch search sort stable-sort merge constantly ;; setf.lsp si::do-defsetf si::do-define-setf-method ;; process.lsp ext:system ;; pprint.lsp pprint-fill copy-pprint-dispatch pprint-dispatch pprint-linear pprint-newline pprint-tab pprint-tabular set-pprint-dispatch pprint-indent #+clos ,@'(;; combin.lsp method-combination-error invalid-method-error clos:std-compute-applicable-methods clos:std-compute-effective-method clos:compute-effective-method-function ;; std-slot-value.lsp clos::standard-instance-access ;; alias clos:funcallable-standard-instance-access clos::standard-instance-set subclassp of-class-p ;; boot.lsp slot-boundp slot-makunbound slot-value clos::slot-value-set slot-exists-p clos::need-to-make-load-form-p ;; defclass clos:load-defclass ;; method clos:extract-lambda-list clos:extract-specializer-names ) ;; cdr-5 ext:array-index-p ext:negative-fixnum-p ext:non-negative-fixnum-p ext:non-positive-fixnum-p ext:positive-fixnum-p ext:negative-integer-p ext:non-negative-integer-p ext:non-positive-integer-p ext:positive-integer-p ext:negative-rational-p ext:non-negative-rational-p ext:non-positive-rational-p ext:positive-rational-p ext:negative-ratio-p ext:non-negative-ratio-p ext:non-positive-ratio-p ext:positive-ratio-p ext:negative-real-p ext:non-negative-real-p ext:non-positive-real-p ext:positive-real-p ext:negative-float-p ext:non-negative-float-p ext:non-positive-float-p ext:positive-float-p ext:negative-short-float-p ext:non-negative-short-float-p ext:non-positive-short-float-p ext:positive-short-float-p ext:negative-single-float-p ext:non-negative-single-float-p ext:non-positive-single-float-p ext:positive-single-float-p ext:negative-double-float-p ext:non-negative-double-float-p ext:non-positive-double-float-p ext:positive-double-float-p ext:negative-long-float-p ext:non-negative-long-float-p ext:non-positive-long-float-p ext:positive-long-float-p )) (proclaim `(si::c-export-fname #+ecl-min ,@c::*in-all-symbols-functions* typecase-error-string find-documentation find-declarations si::search-keyword si::check-keyword si::dm-too-many-arguments si::dm-too-few-arguments remove-documentation si::get-documentation si::set-documentation si::expand-set-documentation si::packages-iterator si::pprint-logical-block-helper si::pprint-pop-helper si::make-seq-iterator si::seq-iterator-ref si::seq-iterator-set si::seq-iterator-next si::sequence-count si::structure-type-error si::define-structure si::coerce-to-list si::coerce-to-vector si::traced-old-definition #+formatter ,@'( format-princ format-prin1 format-print-named-character format-print-integer format-print-cardinal format-print-ordinal format-print-old-roman format-print-roman format-fixed format-exponential format-general format-dollars format-relative-tab format-absolute-tab format-justification ) #+clos ,@'(;; defclass.lsp clos::ensure-class clos::find-slot-definition ;; combin.lsp clos::simple-code-walker ;; kernel.lsp clos::install-method clos::default-initargs-of ;; clos::generic-function-lambda-list ;; clos::generic-function-argument-precedence-order ;; clos::generic-function-method-combination ;; clos::generic-function-method-class ;; clos::generic-function-methods ;; clos::method-generic-function ;; clos::method-lambda-list ;; clos::method-specializers ;; clos::method-qualifiers ;; clos::method-function ;; clos::method-plist clos::associate-methods-to-gfun ;; method.lsp clos::pop-next-method ))) ecl-16.1.2/src/compile.lsp.in000077500000000000000000000334271266352375300157400ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;; @configure_input@ ;;; ;;; This is the "makefile" file for building ECL. The purpose of this file is ;;; - Compile the core of the Common-Lisp library (lsp, clos) ;;; - Compile the compiler (cmp) ;;; - Build an executable ;;; This can be done in two ways: ;;; - Using interpreted code and the ECL_MIN minimal environment. ;;; - On a second stage, using the final ECL executable, to test it. ;;; (progn (setq *package* (find-package "SYSTEM")) (setq *features* @LSP_FEATURES@)) ;;; ;;; * Ensure that we have the whole of Common-Lisp to compile ;;; (load "bare.lsp" :verbose nil) ;;; ;;; * Complain about functions which are not in the core ;;; #+(or) (let ((wrong-symbols '())) (let ((*standard-output* (make-broadcast-stream))) (dolist (p '("CL" "SI" "EXT" "CLOS")) (do-symbols (s (find-package p)) (when (and (fboundp s) (not (typep (fdefinition s) '(or list generic-function))) (si::mangle-name s) (si::bc-disassemble (fdefinition s))) (pushnew s wrong-symbols))))) (format t "~%;;; Functions that can be made into the core:~%") (pprint (set-difference wrong-symbols c::*in-all-symbols-functions*))) ;;; ;;; * Force compiler constants only for the core library ;;; (setf *use-static-constants-p* t) ;;; ;;; * Dump documentation ;;; #+stage1 (progn (load "ext:ecl-cdb;ecl-cdb") (load "ext:ecl-cdb;ecl-help") (load "@true_srcdir@/doc/help.lsp") (si::dump-documentation "@true_builddir@/help.doc")) ;;; ;;; * Trick to make names shorter in C files ;;; (si::package-lock "CL" nil) (rename-package "CL" "CL" '("COMMON-LISP" "LISP")) ;;; ;;; * Add include path to not yet installed headers, and remove include flag ;;; (-I) to installed directory, and Notice that we must explicitely mention ;;; libecl.so/ecl.dll instead of using -lecl. This is to avoid interference ;;; with an already installed copy of ECL. ;;; (setq c::*cc-flags* #-msvc "@CPPFLAGS@ @CFLAGS@ @ECL_CFLAGS@ -I\"@true_srcdir@/c\"" #+msvc "@CFLAGS@ @ECL_CFLAGS@" c::*ecl-include-directory* "@true_builddir@/" c::*ecl-library-directory* "@true_builddir@/") #-:wants-dlopen (setf c::*ld-flags* "@LDFLAGS@ @LIBPREFIX@ecl.@LIBEXT@ @CORE_LIBS@ @FASL_LIBS@ @LIBS@") #+(and :wants-dlopen (not nonstop)) (setf c::*ld-flags* "@LDFLAGS@ @SHAREDPREFIX@ecl.@SHAREDEXT@ @LIBS@" c::*ld-shared-flags* "@SHARED_LDFLAGS@ @LDFLAGS@ @SHAREDPREFIX@ecl.@SHAREDEXT@ @FASL_LIBS@ @LIBS@" c::*ld-bundle-flags* "@BUNDLE_LDFLAGS@ @LDFLAGS@ @SHAREDPREFIX@ecl.@SHAREDEXT@ @FASL_LIBS@ @LIBS@") ;;; FIXME: The nonstop platform does not support soname #+(and :wants-dlopen nonstop) (setf c::*ld-flags* "@LDFLAGS@ -Wld=-l@SHAREDPREFIX@ecl.@SHAREDEXT@ @LIBS@" c::*ld-shared-flags* "@SHARED_LDFLAGS@ @LDFLAGS@ -Wld=-l@SHAREDPREFIX@ecl.@SHAREDEXT@ @FASL_LIBS@ @LIBS@" c::*ld-bundle-flags* "@BUNDLE_LDFLAGS@ @LDFLAGS@ -Wld=-l@SHAREDPREFIX@ecl.@SHAREDEXT@ @FASL_LIBS@ @LIBS@") ;;; ;;; * Avoid name clashes with user supplied code. ;;; (setq si::*init-function-prefix* "ECL") ;;; ;;; * Clean up a little bit before moving on ;;; (mapc #'delete-file (directory "eclinit*.*")) ;;; ;;; * Compile and link Common-Lisp base library ;;; (setq si::*keep-documentation* nil) (mapc #'proclaim +ecl-optimization-settings+) (let* ((c::*cc-flags* (concatenate 'string "-DECL_API -I\"@true_builddir@/c\" " c::*cc-flags*)) (lsp-objects (compile-if-old "build:lsp;" +lisp-module-files+ :system-p t :c-file t :data-file t :h-file t ;;:shared-data-file "build:ecl.sdat" ))) #+CLOS (let* ((c::*compile-to-linking-call* nil)) (mapc #'proclaim +ecl-optimization-settings+) (setq lsp-objects (append lsp-objects (compile-if-old "build:clos;" +clos-module-files+ :system-p t :c-file t :data-file t :h-file t ;;:shared-data-file "build:ecl.sdat" )))) (let ((extra-lisp-files '(@ECL_EXTRA_LISP_FILES@))) (when extra-lisp-files (setq lsp-objects (append lsp-objects (compile-if-old "build:ext;" extra-lisp-files :system-p t :c-file t :data-file t :h-file t ;;:shared-data-file "build:ecl.sdat" ))))) (c::build-static-library "lsp" :lisp-files lsp-objects ;;:shared-data-file "build:ecl.sdat" )) #-:wants-dlopen (c::safe-system (concatenate 'string "sh -c 'rm -rf tmp; mkdir tmp;" "cp @LIBPREFIX@eclmin.@LIBEXT@ @LIBPREFIX@ecl.@LIBEXT@;" "cd tmp; @AR@ -x ../@LIBPREFIX@lsp.@LIBEXT@;" "for i in *.@OBJEXT@; do mv $i lsp_`basename $i`; done;" "@AR@ -r ../@LIBPREFIX@ecl.@LIBEXT@ *.@OBJEXT@ ../c/all_symbols2.@OBJEXT@; rm *.@OBJEXT@;" "@RANLIB@ ../@LIBPREFIX@ecl.@LIBEXT@'")) #+:wants-dlopen ;;; ;;; We do not need the -rpath flag for the library, nor -lecl. ;;; (let* ((c::*ld-shared-flags* #-msvc "@SHARED_LDFLAGS@ @LDFLAGS@ @SONAME_LDFLAGS@ @CORE_LIBS@ @FASL_LIBS@ @LIBS@" #+msvc "@SHARED_LDFLAGS@ @LDFLAGS@ @STATICLIBS@ @CLIBS@") (c::*cc-flags* (concatenate 'string "-DECL_API -I@true_builddir@/c " c::*cc-flags*)) (extra-args nil)) #+(or mingw32 cygwin) (progn ;; We need these two to force dllwrap to export the symbols ;; in these libraries. Otherwise it will not be possible to ;; call functions from GMP or GC in code that embeds ECL. #+thread (when (probe-file "@LIBPREFIX@atomic_ops.@LIBEXT@") (push "@LIBPREFIX@atomic_ops.@LIBEXT@" extra-args)) (when (probe-file "@LIBPREFIX@eclgc.@LIBEXT@") (push "@LIBPREFIX@eclgc.@LIBEXT@" extra-args)) (when (probe-file "@LIBPREFIX@eclgmp.@LIBEXT@") (push "@LIBPREFIX@eclgmp.@LIBEXT@" extra-args))) (print extra-args) (c::shared-cc (compile-file-pathname "ecl" :type :dll) (list* "c/main.@OBJEXT@" "c/all_symbols2.@OBJEXT@" "@LIBPREFIX@lsp.@LIBEXT@" "@LIBPREFIX@eclmin.@LIBEXT@" extra-args))) ;;; ;;; * Compile and link Common-Lisp to C compiler ;;; (mapc #'proclaim +ecl-optimization-settings+) #-mingw32 (si::pathname-translations "SYS" '(("**;*.*.*" "@ecldir\@/**/*.*"))) #+WANTS-CMP (build-module "cmp" +cmp-module-files+ :dir "build:@ECL_CMPDIR@;" :prefix "CMP" :builtin #+:BUILTIN-CMP t #-:BUILTIN-CMP nil) (build-module "ecl-cdb" '("ext:ecl-cdb;ecl-cdb.lisp") :dir "build:ext;" :prefix "EXT" :builtin #+:WANTS-DLOPEN nil #-:WANTS-DLOPEN t) (build-module "ecl-help" '("ext:ecl-cdb;ecl-cdb.lisp" "ext:ecl-cdb;ecl-help.lisp") :dir "build:ext;" :prefix "EXT" :builtin #+:WANTS-DLOPEN nil #-:WANTS-DLOPEN t) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; ;;; EXTENSIONS ;;; ;;; ;;; * SSE ;;; #+(and WANTS-CMP SSE2) (build-module "cl-simd" '("ext:cl-simd;sse-package.lisp" "ext:cl-simd;ecl-sse-core.lisp" "ext:cl-simd;sse-intrinsics.lisp" "ext:cl-simd;sse-array-defs.lisp" "ext:cl-simd;ecl-sse-utils.lisp" "ext:cl-simd;sse-utils.lisp") :dir "build:ext;" :prefix "EXT" :builtin nil) ;;; ;;; * DEFSYSTEM ;;; #+WANTS-DEFSYSTEM (build-module "defsystem" '("ext:defsystem;defsystem.lisp") :dir "build:ext;" :prefix "EXT" :builtin #+:BUILTIN-DEFSYSTEM t #-:BUILTIN-DEFSYSTEM nil) ;;; ;;; * ASDF ;;; #+WANTS-ASDF (build-module "asdf" '("ext:asdf;asdf.lisp") :dir "build:ext;" :prefix "EXT" :builtin #+:BUILTIN-ASDF t #-:BUILTIN-ASDF nil) ;;; ;;; * PROFILE ;;; #+(and WANTS-PROFILE (not (or cygwin mingw32))) (build-module "profile" '("ext:profile;profile.lisp") :dir "build:ext;" :prefix "EXT" :builtin #+(or (NOT :WANTS-DLOPEN) :BUILTIN-PROFILE) t #-(or (NOT :WANTS-DLOPEN) :BUILTIN-PROFILE) nil) ;;; ;;; * Sockets library. ;;; #+WANTS-SOCKETS (build-module "sockets" '("ext:sockets;package.lisp" "ext:sockets;sockets.lisp") :dir "build:ext;" :prefix "EXT" :builtin #+(or (NOT :WANTS-DLOPEN) :BUILTIN-SOCKETS) t #-(or (NOT :WANTS-DLOPEN) :BUILTIN-SOCKETS) nil) #+WANTS-SOCKETS (build-module "sb-bsd-sockets" '("ext:sockets;sb-bsd-sockets.lisp") :depends-on '("sockets") :dir "build:ext;" :prefix "EXT" :builtin nil) #+WANTS-SERVE-EVENT (build-module "serve-event" '("ext:serve-event;serve-event.lisp") :dir "build:ext;" :prefix "EXT" :builtin #+(or (NOT :WANTS-DLOPEN) :BUILTIN-SERVE-EVENT) t #-(or (NOT :WANTS-DLOPEN) :BUILTIN-SERVE-EVENT) nil) #+WANTS-SOCKETS (build-module "ecl-curl" '("ext:ecl-curl;ecl-curl.lisp") :dir "build:ext;" :prefix "EXT" :builtin nil) #+WANTS-SOCKETS (build-module "ql-minitar" '("ext:quicklisp;minitar.lisp") :dir "build:ext;" :prefix "EXT" :builtin nil) #+WANTS-SOCKETS (build-module "deflate" '("ext:deflate;deflate.lisp") :dir "build:ext;" :prefix "EXT" :builtin nil) #+WANTS-SOCKETS (build-module "ecl-quicklisp" '("ext:quicklisp;ecl-quicklisp.lisp") :dir "build:ext;" :prefix "EXT" :builtin nil) ;;; ;;; * Test suite ;;; #+WANTS-RT (build-module "rt" '("ext:rt;rt.lisp") :dir "build:ext;" :prefix "EXT" :builtin #+:BUILTIN-RT t #-:BUILTIN-RT nil) ;;; ;;; * External formats ;;; #+UNICODE (load "ext:encodings;generate.lisp") ;;; ;;; * Compile the portable CLX library. ;;; #+WANTS-CLX (let* ((*features* (cons :clx-ansi-common-lisp *features*)) (+clx-src-files+ '("src:clx;package.lisp" "src:clx;depdefs.lisp" "src:clx;clx.lisp" "src:clx;dependent.lisp" "src:clx;macros.lisp" "src:clx;bufmac.lisp" "src:clx;buffer.lisp" "src:clx;display.lisp" "src:clx;gcontext.lisp" "src:clx;input.lisp" "src:clx;requests.lisp" "src:clx;fonts.lisp" "src:clx;graphics.lisp" "src:clx;text.lisp" "src:clx;attributes.lisp" "src:clx;translate.lisp" "src:clx;keysyms.lisp" "src:clx;manager.lisp" "src:clx;image.lisp" "src:clx;resource.lisp" "src:clx;shape.lisp" "src:clx;big-requests.lisp" "src:clx;xvidmode.lisp" "src:clx;xrender.lisp" "src:clx;glx.lisp" "src:clx;gl.lisp" "src:clx;dpms.lisp" "src:clx;xtest.lisp" "src:clx;screensaver.lisp" "src:clx;xinerama.lisp" "build:clx;module.lisp")) #+:msvc (c::*cc-flags* (concatenate 'string c::*cc-flags* " -Zm150"))) (let ((filename "build:clx;module.lisp")) (ensure-directories-exist filename) (with-open-file (s filename :direction :output :if-exists :overwrite :if-does-not-exist :create) (print '(provide :clx) s))) (unless (find-package "SB-BSD-SOCKETS") (load "ext:sockets;package.lisp")) (mapcar #'load +clx-src-files+) (build-module "clx" +clx-src-files+ :dir "build:clx;" :prefix "CLX" :builtin #+(OR (NOT :WANTS-DLOPEN) :BUILTIN-CLX) t #-(OR (NOT :WANTS-DLOPEN) :BUILTIN-CLX) nil)) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; ;;; THE FINAL EXECUTABLE ;;; (setq si::*init-function-prefix* NIL) #+windows (progn (with-open-file (s "ecl.rc" :direction :output :if-exists :supersede :if-does-not-exist :create) (write-line "id ICON \"ecl.ico\"" s)) (ext:copy-file #p"src:util;ecl.ico" "ecl.ico") #+msvc (ext:run-program "rc" '("/r" "ecl.rc")) #-msvc (ext:run-program "windres" '("ecl.rc" "-O" "coff" "ecl.res"))) (si::pathname-translations "SYS" '(("**;*.*.*" "@true_builddir@/**/*.*"))) (compiler::build-program #+:msvc "ecl2" #+(and (or cross stage1) (not msvc)) "bin/ecl" #-(or cross stage1 msvc) "ecl2" :epilogue-code '@ECL_INIT_FORM@ :lisp-files *module-symbols* :ld-flags (concatenate 'list #-msvc '("-L./") #+windows '("ecl.res" #+msvc "/F 10485760"))) (with-open-file (modules-list #P"build:MODULES" :direction :output :if-exists :supersede :if-does-not-exist :create) (print *module-files*) (dolist (module-file *module-files*) (format modules-list "~A~%" module-file))) (quit) ecl-16.1.2/src/config.guess000077500000000000000000001274631266352375300155040ustar00rootroot00000000000000#! /bin/sh # Attempt to guess a canonical system name. # Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, # 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, # 2011, 2012, 2013 Free Software Foundation, Inc. timestamp='2012-12-29' # This file is free software; you can redistribute it and/or modify it # under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 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 . # # As a special exception to the GNU General Public License, if you # distribute this file as part of a program that contains a # configuration script generated by Autoconf, you may include it under # the same distribution terms that you use for the rest of that # program. This Exception is an additional permission under section 7 # of the GNU General Public License, version 3 ("GPLv3"). # # Originally written by Per Bothner. # # You can get the latest version of this script from: # http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.guess;hb=HEAD # # Please send patches with a ChangeLog entry to config-patches@gnu.org. me=`echo "$0" | sed -e 's,.*/,,'` usage="\ Usage: $0 [OPTION] Output the configuration name of the system \`$me' is run on. Operation modes: -h, --help print this help, then exit -t, --time-stamp print date of last modification, then exit -v, --version print version number, then exit Report bugs and patches to ." version="\ GNU config.guess ($timestamp) Originally written by Per Bothner. Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Free Software Foundation, Inc. This is free software; see the source for copying conditions. There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE." help=" Try \`$me --help' for more information." # Parse command line while test $# -gt 0 ; do case $1 in --time-stamp | --time* | -t ) echo "$timestamp" ; exit ;; --version | -v ) echo "$version" ; exit ;; --help | --h* | -h ) echo "$usage"; exit ;; -- ) # Stop option processing shift; break ;; - ) # Use stdin as input. break ;; -* ) echo "$me: invalid option $1$help" >&2 exit 1 ;; * ) break ;; esac done if test $# != 0; then echo "$me: too many arguments$help" >&2 exit 1 fi trap 'exit 1' 1 2 15 # CC_FOR_BUILD -- compiler used by this script. Note that the use of a # compiler to aid in system detection is discouraged as it requires # temporary files to be created and, as you can see below, it is a # headache to deal with in a portable fashion. # Historically, `CC_FOR_BUILD' used to be named `HOST_CC'. We still # use `HOST_CC' if defined, but it is deprecated. # Portable tmp directory creation inspired by the Autoconf team. set_cc_for_build=' trap "exitcode=\$?; (rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null) && exit \$exitcode" 0 ; trap "rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null; exit 1" 1 2 13 15 ; : ${TMPDIR=/tmp} ; { tmp=`(umask 077 && mktemp -d "$TMPDIR/cgXXXXXX") 2>/dev/null` && test -n "$tmp" && test -d "$tmp" ; } || { test -n "$RANDOM" && tmp=$TMPDIR/cg$$-$RANDOM && (umask 077 && mkdir $tmp) ; } || { tmp=$TMPDIR/cg-$$ && (umask 077 && mkdir $tmp) && echo "Warning: creating insecure temp directory" >&2 ; } || { echo "$me: cannot create a temporary directory in $TMPDIR" >&2 ; exit 1 ; } ; dummy=$tmp/dummy ; tmpfiles="$dummy.c $dummy.o $dummy.rel $dummy" ; case $CC_FOR_BUILD,$HOST_CC,$CC in ,,) echo "int x;" > $dummy.c ; for c in cc gcc c89 c99 ; do if ($c -c -o $dummy.o $dummy.c) >/dev/null 2>&1 ; then CC_FOR_BUILD="$c"; break ; fi ; done ; if test x"$CC_FOR_BUILD" = x ; then CC_FOR_BUILD=no_compiler_found ; fi ;; ,,*) CC_FOR_BUILD=$CC ;; ,*,*) CC_FOR_BUILD=$HOST_CC ;; esac ; set_cc_for_build= ;' # This is needed to find uname on a Pyramid OSx when run in the BSD universe. # (ghazi@noc.rutgers.edu 1994-08-24) if (test -f /.attbin/uname) >/dev/null 2>&1 ; then PATH=$PATH:/.attbin ; export PATH fi UNAME_MACHINE=`(uname -m) 2>/dev/null` || UNAME_MACHINE=unknown UNAME_RELEASE=`(uname -r) 2>/dev/null` || UNAME_RELEASE=unknown UNAME_SYSTEM=`(uname -s) 2>/dev/null` || UNAME_SYSTEM=unknown UNAME_VERSION=`(uname -v) 2>/dev/null` || UNAME_VERSION=unknown # Note: order is significant - the case branches are not exclusive. case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in *:NetBSD:*:*) # NetBSD (nbsd) targets should (where applicable) match one or # more of the tuples: *-*-netbsdelf*, *-*-netbsdaout*, # *-*-netbsdecoff* and *-*-netbsd*. For targets that recently # switched to ELF, *-*-netbsd* would select the old # object file format. This provides both forward # compatibility and a consistent mechanism for selecting the # object file format. # # Note: NetBSD doesn't particularly care about the vendor # portion of the name. We always set it to "unknown". sysctl="sysctl -n hw.machine_arch" UNAME_MACHINE_ARCH=`(/sbin/$sysctl 2>/dev/null || \ /usr/sbin/$sysctl 2>/dev/null || echo unknown)` case "${UNAME_MACHINE_ARCH}" in armeb) machine=armeb-unknown ;; arm*) machine=arm-unknown ;; sh3el) machine=shl-unknown ;; sh3eb) machine=sh-unknown ;; sh5el) machine=sh5le-unknown ;; *) machine=${UNAME_MACHINE_ARCH}-unknown ;; esac # The Operating System including object format, if it has switched # to ELF recently, or will in the future. case "${UNAME_MACHINE_ARCH}" in arm*|i386|m68k|ns32k|sh3*|sparc|vax) eval $set_cc_for_build if echo __ELF__ | $CC_FOR_BUILD -E - 2>/dev/null \ | grep -q __ELF__ then # Once all utilities can be ECOFF (netbsdecoff) or a.out (netbsdaout). # Return netbsd for either. FIX? os=netbsd else os=netbsdelf fi ;; *) os=netbsd ;; esac # The OS release # Debian GNU/NetBSD machines have a different userland, and # thus, need a distinct triplet. However, they do not need # kernel version information, so it can be replaced with a # suitable tag, in the style of linux-gnu. case "${UNAME_VERSION}" in Debian*) release='-gnu' ;; *) release=`echo ${UNAME_RELEASE}|sed -e 's/[-_].*/\./'` ;; esac # Since CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM: # contains redundant information, the shorter form: # CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM is used. echo "${machine}-${os}${release}" exit ;; *:Bitrig:*:*) UNAME_MACHINE_ARCH=`arch | sed 's/Bitrig.//'` echo ${UNAME_MACHINE_ARCH}-unknown-bitrig${UNAME_RELEASE} exit ;; *:OpenBSD:*:*) UNAME_MACHINE_ARCH=`arch | sed 's/OpenBSD.//'` echo ${UNAME_MACHINE_ARCH}-unknown-openbsd${UNAME_RELEASE} exit ;; *:ekkoBSD:*:*) echo ${UNAME_MACHINE}-unknown-ekkobsd${UNAME_RELEASE} exit ;; *:SolidBSD:*:*) echo ${UNAME_MACHINE}-unknown-solidbsd${UNAME_RELEASE} exit ;; macppc:MirBSD:*:*) echo powerpc-unknown-mirbsd${UNAME_RELEASE} exit ;; *:MirBSD:*:*) echo ${UNAME_MACHINE}-unknown-mirbsd${UNAME_RELEASE} exit ;; alpha:OSF1:*:*) case $UNAME_RELEASE in *4.0) UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $3}'` ;; *5.*) UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $4}'` ;; esac # According to Compaq, /usr/sbin/psrinfo has been available on # OSF/1 and Tru64 systems produced since 1995. I hope that # covers most systems running today. This code pipes the CPU # types through head -n 1, so we only detect the type of CPU 0. ALPHA_CPU_TYPE=`/usr/sbin/psrinfo -v | sed -n -e 's/^ The alpha \(.*\) processor.*$/\1/p' | head -n 1` case "$ALPHA_CPU_TYPE" in "EV4 (21064)") UNAME_MACHINE="alpha" ;; "EV4.5 (21064)") UNAME_MACHINE="alpha" ;; "LCA4 (21066/21068)") UNAME_MACHINE="alpha" ;; "EV5 (21164)") UNAME_MACHINE="alphaev5" ;; "EV5.6 (21164A)") UNAME_MACHINE="alphaev56" ;; "EV5.6 (21164PC)") UNAME_MACHINE="alphapca56" ;; "EV5.7 (21164PC)") UNAME_MACHINE="alphapca57" ;; "EV6 (21264)") UNAME_MACHINE="alphaev6" ;; "EV6.7 (21264A)") UNAME_MACHINE="alphaev67" ;; "EV6.8CB (21264C)") UNAME_MACHINE="alphaev68" ;; "EV6.8AL (21264B)") UNAME_MACHINE="alphaev68" ;; "EV6.8CX (21264D)") UNAME_MACHINE="alphaev68" ;; "EV6.9A (21264/EV69A)") UNAME_MACHINE="alphaev69" ;; "EV7 (21364)") UNAME_MACHINE="alphaev7" ;; "EV7.9 (21364A)") UNAME_MACHINE="alphaev79" ;; esac # A Pn.n version is a patched version. # A Vn.n version is a released version. # A Tn.n version is a released field test version. # A Xn.n version is an unreleased experimental baselevel. # 1.2 uses "1.2" for uname -r. echo ${UNAME_MACHINE}-dec-osf`echo ${UNAME_RELEASE} | sed -e 's/^[PVTX]//' | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` # Reset EXIT trap before exiting to avoid spurious non-zero exit code. exitcode=$? trap '' 0 exit $exitcode ;; Alpha\ *:Windows_NT*:*) # How do we know it's Interix rather than the generic POSIX subsystem? # Should we change UNAME_MACHINE based on the output of uname instead # of the specific Alpha model? echo alpha-pc-interix exit ;; 21064:Windows_NT:50:3) echo alpha-dec-winnt3.5 exit ;; Amiga*:UNIX_System_V:4.0:*) echo m68k-unknown-sysv4 exit ;; *:[Aa]miga[Oo][Ss]:*:*) echo ${UNAME_MACHINE}-unknown-amigaos exit ;; *:[Mm]orph[Oo][Ss]:*:*) echo ${UNAME_MACHINE}-unknown-morphos exit ;; *:OS/390:*:*) echo i370-ibm-openedition exit ;; *:z/VM:*:*) echo s390-ibm-zvmoe exit ;; *:OS400:*:*) echo powerpc-ibm-os400 exit ;; arm:RISC*:1.[012]*:*|arm:riscix:1.[012]*:*) echo arm-acorn-riscix${UNAME_RELEASE} exit ;; arm*:riscos:*:*|arm*:RISCOS:*:*) echo arm-unknown-riscos exit ;; SR2?01:HI-UX/MPP:*:* | SR8000:HI-UX/MPP:*:*) echo hppa1.1-hitachi-hiuxmpp exit ;; Pyramid*:OSx*:*:* | MIS*:OSx*:*:* | MIS*:SMP_DC-OSx*:*:*) # akee@wpdis03.wpafb.af.mil (Earle F. Ake) contributed MIS and NILE. if test "`(/bin/universe) 2>/dev/null`" = att ; then echo pyramid-pyramid-sysv3 else echo pyramid-pyramid-bsd fi exit ;; NILE*:*:*:dcosx) echo pyramid-pyramid-svr4 exit ;; DRS?6000:unix:4.0:6*) echo sparc-icl-nx6 exit ;; DRS?6000:UNIX_SV:4.2*:7* | DRS?6000:isis:4.2*:7*) case `/usr/bin/uname -p` in sparc) echo sparc-icl-nx7; exit ;; esac ;; s390x:SunOS:*:*) echo ${UNAME_MACHINE}-ibm-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` exit ;; sun4H:SunOS:5.*:*) echo sparc-hal-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` exit ;; sun4*:SunOS:5.*:* | tadpole*:SunOS:5.*:*) echo sparc-sun-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` exit ;; i86pc:AuroraUX:5.*:* | i86xen:AuroraUX:5.*:*) echo i386-pc-auroraux${UNAME_RELEASE} exit ;; i86pc:SunOS:5.*:* | i86xen:SunOS:5.*:*) eval $set_cc_for_build SUN_ARCH="i386" # If there is a compiler, see if it is configured for 64-bit objects. # Note that the Sun cc does not turn __LP64__ into 1 like gcc does. # This test works for both compilers. if [ "$CC_FOR_BUILD" != 'no_compiler_found' ]; then if (echo '#ifdef __amd64'; echo IS_64BIT_ARCH; echo '#endif') | \ (CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) | \ grep IS_64BIT_ARCH >/dev/null then SUN_ARCH="x86_64" fi fi echo ${SUN_ARCH}-pc-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` exit ;; sun4*:SunOS:6*:*) # According to config.sub, this is the proper way to canonicalize # SunOS6. Hard to guess exactly what SunOS6 will be like, but # it's likely to be more like Solaris than SunOS4. echo sparc-sun-solaris3`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` exit ;; sun4*:SunOS:*:*) case "`/usr/bin/arch -k`" in Series*|S4*) UNAME_RELEASE=`uname -v` ;; esac # Japanese Language versions have a version number like `4.1.3-JL'. echo sparc-sun-sunos`echo ${UNAME_RELEASE}|sed -e 's/-/_/'` exit ;; sun3*:SunOS:*:*) echo m68k-sun-sunos${UNAME_RELEASE} exit ;; sun*:*:4.2BSD:*) UNAME_RELEASE=`(sed 1q /etc/motd | awk '{print substr($5,1,3)}') 2>/dev/null` test "x${UNAME_RELEASE}" = "x" && UNAME_RELEASE=3 case "`/bin/arch`" in sun3) echo m68k-sun-sunos${UNAME_RELEASE} ;; sun4) echo sparc-sun-sunos${UNAME_RELEASE} ;; esac exit ;; aushp:SunOS:*:*) echo sparc-auspex-sunos${UNAME_RELEASE} exit ;; # The situation for MiNT is a little confusing. The machine name # can be virtually everything (everything which is not # "atarist" or "atariste" at least should have a processor # > m68000). The system name ranges from "MiNT" over "FreeMiNT" # to the lowercase version "mint" (or "freemint"). Finally # the system name "TOS" denotes a system which is actually not # MiNT. But MiNT is downward compatible to TOS, so this should # be no problem. atarist[e]:*MiNT:*:* | atarist[e]:*mint:*:* | atarist[e]:*TOS:*:*) echo m68k-atari-mint${UNAME_RELEASE} exit ;; atari*:*MiNT:*:* | atari*:*mint:*:* | atarist[e]:*TOS:*:*) echo m68k-atari-mint${UNAME_RELEASE} exit ;; *falcon*:*MiNT:*:* | *falcon*:*mint:*:* | *falcon*:*TOS:*:*) echo m68k-atari-mint${UNAME_RELEASE} exit ;; milan*:*MiNT:*:* | milan*:*mint:*:* | *milan*:*TOS:*:*) echo m68k-milan-mint${UNAME_RELEASE} exit ;; hades*:*MiNT:*:* | hades*:*mint:*:* | *hades*:*TOS:*:*) echo m68k-hades-mint${UNAME_RELEASE} exit ;; *:*MiNT:*:* | *:*mint:*:* | *:*TOS:*:*) echo m68k-unknown-mint${UNAME_RELEASE} exit ;; m68k:machten:*:*) echo m68k-apple-machten${UNAME_RELEASE} exit ;; powerpc:machten:*:*) echo powerpc-apple-machten${UNAME_RELEASE} exit ;; RISC*:Mach:*:*) echo mips-dec-mach_bsd4.3 exit ;; RISC*:ULTRIX:*:*) echo mips-dec-ultrix${UNAME_RELEASE} exit ;; VAX*:ULTRIX*:*:*) echo vax-dec-ultrix${UNAME_RELEASE} exit ;; 2020:CLIX:*:* | 2430:CLIX:*:*) echo clipper-intergraph-clix${UNAME_RELEASE} exit ;; mips:*:*:UMIPS | mips:*:*:RISCos) eval $set_cc_for_build sed 's/^ //' << EOF >$dummy.c #ifdef __cplusplus #include /* for printf() prototype */ int main (int argc, char *argv[]) { #else int main (argc, argv) int argc; char *argv[]; { #endif #if defined (host_mips) && defined (MIPSEB) #if defined (SYSTYPE_SYSV) printf ("mips-mips-riscos%ssysv\n", argv[1]); exit (0); #endif #if defined (SYSTYPE_SVR4) printf ("mips-mips-riscos%ssvr4\n", argv[1]); exit (0); #endif #if defined (SYSTYPE_BSD43) || defined(SYSTYPE_BSD) printf ("mips-mips-riscos%sbsd\n", argv[1]); exit (0); #endif #endif exit (-1); } EOF $CC_FOR_BUILD -o $dummy $dummy.c && dummyarg=`echo "${UNAME_RELEASE}" | sed -n 's/\([0-9]*\).*/\1/p'` && SYSTEM_NAME=`$dummy $dummyarg` && { echo "$SYSTEM_NAME"; exit; } echo mips-mips-riscos${UNAME_RELEASE} exit ;; Motorola:PowerMAX_OS:*:*) echo powerpc-motorola-powermax exit ;; Motorola:*:4.3:PL8-*) echo powerpc-harris-powermax exit ;; Night_Hawk:*:*:PowerMAX_OS | Synergy:PowerMAX_OS:*:*) echo powerpc-harris-powermax exit ;; Night_Hawk:Power_UNIX:*:*) echo powerpc-harris-powerunix exit ;; m88k:CX/UX:7*:*) echo m88k-harris-cxux7 exit ;; m88k:*:4*:R4*) echo m88k-motorola-sysv4 exit ;; m88k:*:3*:R3*) echo m88k-motorola-sysv3 exit ;; AViiON:dgux:*:*) # DG/UX returns AViiON for all architectures UNAME_PROCESSOR=`/usr/bin/uname -p` if [ $UNAME_PROCESSOR = mc88100 ] || [ $UNAME_PROCESSOR = mc88110 ] then if [ ${TARGET_BINARY_INTERFACE}x = m88kdguxelfx ] || \ [ ${TARGET_BINARY_INTERFACE}x = x ] then echo m88k-dg-dgux${UNAME_RELEASE} else echo m88k-dg-dguxbcs${UNAME_RELEASE} fi else echo i586-dg-dgux${UNAME_RELEASE} fi exit ;; M88*:DolphinOS:*:*) # DolphinOS (SVR3) echo m88k-dolphin-sysv3 exit ;; M88*:*:R3*:*) # Delta 88k system running SVR3 echo m88k-motorola-sysv3 exit ;; XD88*:*:*:*) # Tektronix XD88 system running UTekV (SVR3) echo m88k-tektronix-sysv3 exit ;; Tek43[0-9][0-9]:UTek:*:*) # Tektronix 4300 system running UTek (BSD) echo m68k-tektronix-bsd exit ;; *:IRIX*:*:*) echo mips-sgi-irix`echo ${UNAME_RELEASE}|sed -e 's/-/_/g'` exit ;; ????????:AIX?:[12].1:2) # AIX 2.2.1 or AIX 2.1.1 is RT/PC AIX. echo romp-ibm-aix # uname -m gives an 8 hex-code CPU id exit ;; # Note that: echo "'`uname -s`'" gives 'AIX ' i*86:AIX:*:*) echo i386-ibm-aix exit ;; ia64:AIX:*:*) if [ -x /usr/bin/oslevel ] ; then IBM_REV=`/usr/bin/oslevel` else IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE} fi echo ${UNAME_MACHINE}-ibm-aix${IBM_REV} exit ;; *:AIX:2:3) if grep bos325 /usr/include/stdio.h >/dev/null 2>&1; then eval $set_cc_for_build sed 's/^ //' << EOF >$dummy.c #include main() { if (!__power_pc()) exit(1); puts("powerpc-ibm-aix3.2.5"); exit(0); } EOF if $CC_FOR_BUILD -o $dummy $dummy.c && SYSTEM_NAME=`$dummy` then echo "$SYSTEM_NAME" else echo rs6000-ibm-aix3.2.5 fi elif grep bos324 /usr/include/stdio.h >/dev/null 2>&1; then echo rs6000-ibm-aix3.2.4 else echo rs6000-ibm-aix3.2 fi exit ;; *:AIX:*:[4567]) IBM_CPU_ID=`/usr/sbin/lsdev -C -c processor -S available | sed 1q | awk '{ print $1 }'` if /usr/sbin/lsattr -El ${IBM_CPU_ID} | grep ' POWER' >/dev/null 2>&1; then IBM_ARCH=rs6000 else IBM_ARCH=powerpc fi if [ -x /usr/bin/oslevel ] ; then IBM_REV=`/usr/bin/oslevel` else IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE} fi echo ${IBM_ARCH}-ibm-aix${IBM_REV} exit ;; *:AIX:*:*) echo rs6000-ibm-aix exit ;; ibmrt:4.4BSD:*|romp-ibm:BSD:*) echo romp-ibm-bsd4.4 exit ;; ibmrt:*BSD:*|romp-ibm:BSD:*) # covers RT/PC BSD and echo romp-ibm-bsd${UNAME_RELEASE} # 4.3 with uname added to exit ;; # report: romp-ibm BSD 4.3 *:BOSX:*:*) echo rs6000-bull-bosx exit ;; DPX/2?00:B.O.S.:*:*) echo m68k-bull-sysv3 exit ;; 9000/[34]??:4.3bsd:1.*:*) echo m68k-hp-bsd exit ;; hp300:4.4BSD:*:* | 9000/[34]??:4.3bsd:2.*:*) echo m68k-hp-bsd4.4 exit ;; 9000/[34678]??:HP-UX:*:*) HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'` case "${UNAME_MACHINE}" in 9000/31? ) HP_ARCH=m68000 ;; 9000/[34]?? ) HP_ARCH=m68k ;; 9000/[678][0-9][0-9]) if [ -x /usr/bin/getconf ]; then sc_cpu_version=`/usr/bin/getconf SC_CPU_VERSION 2>/dev/null` sc_kernel_bits=`/usr/bin/getconf SC_KERNEL_BITS 2>/dev/null` case "${sc_cpu_version}" in 523) HP_ARCH="hppa1.0" ;; # CPU_PA_RISC1_0 528) HP_ARCH="hppa1.1" ;; # CPU_PA_RISC1_1 532) # CPU_PA_RISC2_0 case "${sc_kernel_bits}" in 32) HP_ARCH="hppa2.0n" ;; 64) HP_ARCH="hppa2.0w" ;; '') HP_ARCH="hppa2.0" ;; # HP-UX 10.20 esac ;; esac fi if [ "${HP_ARCH}" = "" ]; then eval $set_cc_for_build sed 's/^ //' << EOF >$dummy.c #define _HPUX_SOURCE #include #include int main () { #if defined(_SC_KERNEL_BITS) long bits = sysconf(_SC_KERNEL_BITS); #endif long cpu = sysconf (_SC_CPU_VERSION); switch (cpu) { case CPU_PA_RISC1_0: puts ("hppa1.0"); break; case CPU_PA_RISC1_1: puts ("hppa1.1"); break; case CPU_PA_RISC2_0: #if defined(_SC_KERNEL_BITS) switch (bits) { case 64: puts ("hppa2.0w"); break; case 32: puts ("hppa2.0n"); break; default: puts ("hppa2.0"); break; } break; #else /* !defined(_SC_KERNEL_BITS) */ puts ("hppa2.0"); break; #endif default: puts ("hppa1.0"); break; } exit (0); } EOF (CCOPTS= $CC_FOR_BUILD -o $dummy $dummy.c 2>/dev/null) && HP_ARCH=`$dummy` test -z "$HP_ARCH" && HP_ARCH=hppa fi ;; esac if [ ${HP_ARCH} = "hppa2.0w" ] then eval $set_cc_for_build # hppa2.0w-hp-hpux* has a 64-bit kernel and a compiler generating # 32-bit code. hppa64-hp-hpux* has the same kernel and a compiler # generating 64-bit code. GNU and HP use different nomenclature: # # $ CC_FOR_BUILD=cc ./config.guess # => hppa2.0w-hp-hpux11.23 # $ CC_FOR_BUILD="cc +DA2.0w" ./config.guess # => hppa64-hp-hpux11.23 if echo __LP64__ | (CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) | grep -q __LP64__ then HP_ARCH="hppa2.0w" else HP_ARCH="hppa64" fi fi echo ${HP_ARCH}-hp-hpux${HPUX_REV} exit ;; ia64:HP-UX:*:*) HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'` echo ia64-hp-hpux${HPUX_REV} exit ;; 3050*:HI-UX:*:*) eval $set_cc_for_build sed 's/^ //' << EOF >$dummy.c #include int main () { long cpu = sysconf (_SC_CPU_VERSION); /* The order matters, because CPU_IS_HP_MC68K erroneously returns true for CPU_PA_RISC1_0. CPU_IS_PA_RISC returns correct results, however. */ if (CPU_IS_PA_RISC (cpu)) { switch (cpu) { case CPU_PA_RISC1_0: puts ("hppa1.0-hitachi-hiuxwe2"); break; case CPU_PA_RISC1_1: puts ("hppa1.1-hitachi-hiuxwe2"); break; case CPU_PA_RISC2_0: puts ("hppa2.0-hitachi-hiuxwe2"); break; default: puts ("hppa-hitachi-hiuxwe2"); break; } } else if (CPU_IS_HP_MC68K (cpu)) puts ("m68k-hitachi-hiuxwe2"); else puts ("unknown-hitachi-hiuxwe2"); exit (0); } EOF $CC_FOR_BUILD -o $dummy $dummy.c && SYSTEM_NAME=`$dummy` && { echo "$SYSTEM_NAME"; exit; } echo unknown-hitachi-hiuxwe2 exit ;; 9000/7??:4.3bsd:*:* | 9000/8?[79]:4.3bsd:*:* ) echo hppa1.1-hp-bsd exit ;; 9000/8??:4.3bsd:*:*) echo hppa1.0-hp-bsd exit ;; *9??*:MPE/iX:*:* | *3000*:MPE/iX:*:*) echo hppa1.0-hp-mpeix exit ;; hp7??:OSF1:*:* | hp8?[79]:OSF1:*:* ) echo hppa1.1-hp-osf exit ;; hp8??:OSF1:*:*) echo hppa1.0-hp-osf exit ;; i*86:OSF1:*:*) if [ -x /usr/sbin/sysversion ] ; then echo ${UNAME_MACHINE}-unknown-osf1mk else echo ${UNAME_MACHINE}-unknown-osf1 fi exit ;; parisc*:Lites*:*:*) echo hppa1.1-hp-lites exit ;; C1*:ConvexOS:*:* | convex:ConvexOS:C1*:*) echo c1-convex-bsd exit ;; C2*:ConvexOS:*:* | convex:ConvexOS:C2*:*) if getsysinfo -f scalar_acc then echo c32-convex-bsd else echo c2-convex-bsd fi exit ;; C34*:ConvexOS:*:* | convex:ConvexOS:C34*:*) echo c34-convex-bsd exit ;; C38*:ConvexOS:*:* | convex:ConvexOS:C38*:*) echo c38-convex-bsd exit ;; C4*:ConvexOS:*:* | convex:ConvexOS:C4*:*) echo c4-convex-bsd exit ;; CRAY*Y-MP:*:*:*) echo ymp-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' exit ;; CRAY*[A-Z]90:*:*:*) echo ${UNAME_MACHINE}-cray-unicos${UNAME_RELEASE} \ | sed -e 's/CRAY.*\([A-Z]90\)/\1/' \ -e y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/ \ -e 's/\.[^.]*$/.X/' exit ;; CRAY*TS:*:*:*) echo t90-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' exit ;; CRAY*T3E:*:*:*) echo alphaev5-cray-unicosmk${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' exit ;; CRAY*SV1:*:*:*) echo sv1-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' exit ;; *:UNICOS/mp:*:*) echo craynv-cray-unicosmp${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' exit ;; F30[01]:UNIX_System_V:*:* | F700:UNIX_System_V:*:*) FUJITSU_PROC=`uname -m | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'` FUJITSU_REL=`echo ${UNAME_RELEASE} | sed -e 's/ /_/'` echo "${FUJITSU_PROC}-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}" exit ;; 5000:UNIX_System_V:4.*:*) FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'` FUJITSU_REL=`echo ${UNAME_RELEASE} | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/ /_/'` echo "sparc-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}" exit ;; i*86:BSD/386:*:* | i*86:BSD/OS:*:* | *:Ascend\ Embedded/OS:*:*) echo ${UNAME_MACHINE}-pc-bsdi${UNAME_RELEASE} exit ;; sparc*:BSD/OS:*:*) echo sparc-unknown-bsdi${UNAME_RELEASE} exit ;; *:BSD/OS:*:*) echo ${UNAME_MACHINE}-unknown-bsdi${UNAME_RELEASE} exit ;; *:FreeBSD:*:*) UNAME_PROCESSOR=`/usr/bin/uname -p` case ${UNAME_PROCESSOR} in amd64) echo x86_64-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;; *) echo ${UNAME_PROCESSOR}-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;; esac exit ;; i*:CYGWIN*:*) echo ${UNAME_MACHINE}-pc-cygwin exit ;; *:MINGW64*:*) echo ${UNAME_MACHINE}-pc-mingw64 exit ;; *:MINGW*:*) echo ${UNAME_MACHINE}-pc-mingw32 exit ;; i*:MSYS*:*) echo ${UNAME_MACHINE}-pc-msys exit ;; i*:windows32*:*) # uname -m includes "-pc" on this system. echo ${UNAME_MACHINE}-mingw32 exit ;; i*:PW*:*) echo ${UNAME_MACHINE}-pc-pw32 exit ;; *:Interix*:*) case ${UNAME_MACHINE} in x86) echo i586-pc-interix${UNAME_RELEASE} exit ;; authenticamd | genuineintel | EM64T) echo x86_64-unknown-interix${UNAME_RELEASE} exit ;; IA64) echo ia64-unknown-interix${UNAME_RELEASE} exit ;; esac ;; [345]86:Windows_95:* | [345]86:Windows_98:* | [345]86:Windows_NT:*) echo i${UNAME_MACHINE}-pc-mks exit ;; 8664:Windows_NT:*) echo x86_64-pc-mks exit ;; i*:Windows_NT*:* | Pentium*:Windows_NT*:*) # How do we know it's Interix rather than the generic POSIX subsystem? # It also conflicts with pre-2.0 versions of AT&T UWIN. Should we # UNAME_MACHINE based on the output of uname instead of i386? echo i586-pc-interix exit ;; i*:UWIN*:*) echo ${UNAME_MACHINE}-pc-uwin exit ;; amd64:CYGWIN*:*:* | x86_64:CYGWIN*:*:*) echo x86_64-unknown-cygwin exit ;; p*:CYGWIN*:*) echo powerpcle-unknown-cygwin exit ;; prep*:SunOS:5.*:*) echo powerpcle-unknown-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` exit ;; *:GNU:*:*) # the GNU system echo `echo ${UNAME_MACHINE}|sed -e 's,[-/].*$,,'`-unknown-gnu`echo ${UNAME_RELEASE}|sed -e 's,/.*$,,'` exit ;; *:GNU/*:*:*) # other systems with GNU libc and userland echo ${UNAME_MACHINE}-unknown-`echo ${UNAME_SYSTEM} | sed 's,^[^/]*/,,' | tr '[A-Z]' '[a-z]'``echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`-gnu exit ;; i*86:Minix:*:*) echo ${UNAME_MACHINE}-pc-minix exit ;; aarch64:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; aarch64_be:Linux:*:*) UNAME_MACHINE=aarch64_be echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; alpha:Linux:*:*) case `sed -n '/^cpu model/s/^.*: \(.*\)/\1/p' < /proc/cpuinfo` in EV5) UNAME_MACHINE=alphaev5 ;; EV56) UNAME_MACHINE=alphaev56 ;; PCA56) UNAME_MACHINE=alphapca56 ;; PCA57) UNAME_MACHINE=alphapca56 ;; EV6) UNAME_MACHINE=alphaev6 ;; EV67) UNAME_MACHINE=alphaev67 ;; EV68*) UNAME_MACHINE=alphaev68 ;; esac objdump --private-headers /bin/sh | grep -q ld.so.1 if test "$?" = 0 ; then LIBC="libc1" ; else LIBC="" ; fi echo ${UNAME_MACHINE}-unknown-linux-gnu${LIBC} exit ;; arm*:Linux:*:*) eval $set_cc_for_build if echo __ARM_EABI__ | $CC_FOR_BUILD -E - 2>/dev/null \ | grep -q __ARM_EABI__ then echo ${UNAME_MACHINE}-unknown-linux-gnu else if echo __ARM_PCS_VFP | $CC_FOR_BUILD -E - 2>/dev/null \ | grep -q __ARM_PCS_VFP then echo ${UNAME_MACHINE}-unknown-linux-gnueabi else echo ${UNAME_MACHINE}-unknown-linux-gnueabihf fi fi exit ;; avr32*:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; cris:Linux:*:*) echo ${UNAME_MACHINE}-axis-linux-gnu exit ;; crisv32:Linux:*:*) echo ${UNAME_MACHINE}-axis-linux-gnu exit ;; frv:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; hexagon:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; i*86:Linux:*:*) LIBC=gnu eval $set_cc_for_build sed 's/^ //' << EOF >$dummy.c #ifdef __dietlibc__ LIBC=dietlibc #endif EOF eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep '^LIBC'` echo "${UNAME_MACHINE}-pc-linux-${LIBC}" exit ;; ia64:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; m32r*:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; m68*:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; mips:Linux:*:* | mips64:Linux:*:*) eval $set_cc_for_build sed 's/^ //' << EOF >$dummy.c #undef CPU #undef ${UNAME_MACHINE} #undef ${UNAME_MACHINE}el #if defined(__MIPSEL__) || defined(__MIPSEL) || defined(_MIPSEL) || defined(MIPSEL) CPU=${UNAME_MACHINE}el #else #if defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB) || defined(MIPSEB) CPU=${UNAME_MACHINE} #else CPU= #endif #endif EOF eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep '^CPU'` test x"${CPU}" != x && { echo "${CPU}-unknown-linux-gnu"; exit; } ;; or32:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; padre:Linux:*:*) echo sparc-unknown-linux-gnu exit ;; parisc64:Linux:*:* | hppa64:Linux:*:*) echo hppa64-unknown-linux-gnu exit ;; parisc:Linux:*:* | hppa:Linux:*:*) # Look for CPU level case `grep '^cpu[^a-z]*:' /proc/cpuinfo 2>/dev/null | cut -d' ' -f2` in PA7*) echo hppa1.1-unknown-linux-gnu ;; PA8*) echo hppa2.0-unknown-linux-gnu ;; *) echo hppa-unknown-linux-gnu ;; esac exit ;; ppc64:Linux:*:*) echo powerpc64-unknown-linux-gnu exit ;; ppc:Linux:*:*) echo powerpc-unknown-linux-gnu exit ;; s390:Linux:*:* | s390x:Linux:*:*) echo ${UNAME_MACHINE}-ibm-linux exit ;; sh64*:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; sh*:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; sparc:Linux:*:* | sparc64:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; tile*:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; vax:Linux:*:*) echo ${UNAME_MACHINE}-dec-linux-gnu exit ;; x86_64:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; xtensa*:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; i*86:DYNIX/ptx:4*:*) # ptx 4.0 does uname -s correctly, with DYNIX/ptx in there. # earlier versions are messed up and put the nodename in both # sysname and nodename. echo i386-sequent-sysv4 exit ;; i*86:UNIX_SV:4.2MP:2.*) # Unixware is an offshoot of SVR4, but it has its own version # number series starting with 2... # I am not positive that other SVR4 systems won't match this, # I just have to hope. -- rms. # Use sysv4.2uw... so that sysv4* matches it. echo ${UNAME_MACHINE}-pc-sysv4.2uw${UNAME_VERSION} exit ;; i*86:OS/2:*:*) # If we were able to find `uname', then EMX Unix compatibility # is probably installed. echo ${UNAME_MACHINE}-pc-os2-emx exit ;; i*86:XTS-300:*:STOP) echo ${UNAME_MACHINE}-unknown-stop exit ;; i*86:atheos:*:*) echo ${UNAME_MACHINE}-unknown-atheos exit ;; i*86:syllable:*:*) echo ${UNAME_MACHINE}-pc-syllable exit ;; i*86:LynxOS:2.*:* | i*86:LynxOS:3.[01]*:* | i*86:LynxOS:4.[02]*:*) echo i386-unknown-lynxos${UNAME_RELEASE} exit ;; i*86:*DOS:*:*) echo ${UNAME_MACHINE}-pc-msdosdjgpp exit ;; i*86:*:4.*:* | i*86:SYSTEM_V:4.*:*) UNAME_REL=`echo ${UNAME_RELEASE} | sed 's/\/MP$//'` if grep Novell /usr/include/link.h >/dev/null 2>/dev/null; then echo ${UNAME_MACHINE}-univel-sysv${UNAME_REL} else echo ${UNAME_MACHINE}-pc-sysv${UNAME_REL} fi exit ;; i*86:*:5:[678]*) # UnixWare 7.x, OpenUNIX and OpenServer 6. case `/bin/uname -X | grep "^Machine"` in *486*) UNAME_MACHINE=i486 ;; *Pentium) UNAME_MACHINE=i586 ;; *Pent*|*Celeron) UNAME_MACHINE=i686 ;; esac echo ${UNAME_MACHINE}-unknown-sysv${UNAME_RELEASE}${UNAME_SYSTEM}${UNAME_VERSION} exit ;; i*86:*:3.2:*) if test -f /usr/options/cb.name; then UNAME_REL=`sed -n 's/.*Version //p' /dev/null >/dev/null ; then UNAME_REL=`(/bin/uname -X|grep Release|sed -e 's/.*= //')` (/bin/uname -X|grep i80486 >/dev/null) && UNAME_MACHINE=i486 (/bin/uname -X|grep '^Machine.*Pentium' >/dev/null) \ && UNAME_MACHINE=i586 (/bin/uname -X|grep '^Machine.*Pent *II' >/dev/null) \ && UNAME_MACHINE=i686 (/bin/uname -X|grep '^Machine.*Pentium Pro' >/dev/null) \ && UNAME_MACHINE=i686 echo ${UNAME_MACHINE}-pc-sco$UNAME_REL else echo ${UNAME_MACHINE}-pc-sysv32 fi exit ;; pc:*:*:*) # Left here for compatibility: # uname -m prints for DJGPP always 'pc', but it prints nothing about # the processor, so we play safe by assuming i586. # Note: whatever this is, it MUST be the same as what config.sub # prints for the "djgpp" host, or else GDB configury will decide that # this is a cross-build. echo i586-pc-msdosdjgpp exit ;; Intel:Mach:3*:*) echo i386-pc-mach3 exit ;; paragon:*:*:*) echo i860-intel-osf1 exit ;; i860:*:4.*:*) # i860-SVR4 if grep Stardent /usr/include/sys/uadmin.h >/dev/null 2>&1 ; then echo i860-stardent-sysv${UNAME_RELEASE} # Stardent Vistra i860-SVR4 else # Add other i860-SVR4 vendors below as they are discovered. echo i860-unknown-sysv${UNAME_RELEASE} # Unknown i860-SVR4 fi exit ;; mini*:CTIX:SYS*5:*) # "miniframe" echo m68010-convergent-sysv exit ;; mc68k:UNIX:SYSTEM5:3.51m) echo m68k-convergent-sysv exit ;; M680?0:D-NIX:5.3:*) echo m68k-diab-dnix exit ;; M68*:*:R3V[5678]*:*) test -r /sysV68 && { echo 'm68k-motorola-sysv'; exit; } ;; 3[345]??:*:4.0:3.0 | 3[34]??A:*:4.0:3.0 | 3[34]??,*:*:4.0:3.0 | 3[34]??/*:*:4.0:3.0 | 4400:*:4.0:3.0 | 4850:*:4.0:3.0 | SKA40:*:4.0:3.0 | SDS2:*:4.0:3.0 | SHG2:*:4.0:3.0 | S7501*:*:4.0:3.0) OS_REL='' test -r /etc/.relid \ && OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid` /bin/uname -p 2>/dev/null | grep 86 >/dev/null \ && { echo i486-ncr-sysv4.3${OS_REL}; exit; } /bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \ && { echo i586-ncr-sysv4.3${OS_REL}; exit; } ;; 3[34]??:*:4.0:* | 3[34]??,*:*:4.0:*) /bin/uname -p 2>/dev/null | grep 86 >/dev/null \ && { echo i486-ncr-sysv4; exit; } ;; NCR*:*:4.2:* | MPRAS*:*:4.2:*) OS_REL='.3' test -r /etc/.relid \ && OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid` /bin/uname -p 2>/dev/null | grep 86 >/dev/null \ && { echo i486-ncr-sysv4.3${OS_REL}; exit; } /bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \ && { echo i586-ncr-sysv4.3${OS_REL}; exit; } /bin/uname -p 2>/dev/null | /bin/grep pteron >/dev/null \ && { echo i586-ncr-sysv4.3${OS_REL}; exit; } ;; m68*:LynxOS:2.*:* | m68*:LynxOS:3.0*:*) echo m68k-unknown-lynxos${UNAME_RELEASE} exit ;; mc68030:UNIX_System_V:4.*:*) echo m68k-atari-sysv4 exit ;; TSUNAMI:LynxOS:2.*:*) echo sparc-unknown-lynxos${UNAME_RELEASE} exit ;; rs6000:LynxOS:2.*:*) echo rs6000-unknown-lynxos${UNAME_RELEASE} exit ;; PowerPC:LynxOS:2.*:* | PowerPC:LynxOS:3.[01]*:* | PowerPC:LynxOS:4.[02]*:*) echo powerpc-unknown-lynxos${UNAME_RELEASE} exit ;; SM[BE]S:UNIX_SV:*:*) echo mips-dde-sysv${UNAME_RELEASE} exit ;; RM*:ReliantUNIX-*:*:*) echo mips-sni-sysv4 exit ;; RM*:SINIX-*:*:*) echo mips-sni-sysv4 exit ;; *:SINIX-*:*:*) if uname -p 2>/dev/null >/dev/null ; then UNAME_MACHINE=`(uname -p) 2>/dev/null` echo ${UNAME_MACHINE}-sni-sysv4 else echo ns32k-sni-sysv fi exit ;; PENTIUM:*:4.0*:*) # Unisys `ClearPath HMP IX 4000' SVR4/MP effort # says echo i586-unisys-sysv4 exit ;; *:UNIX_System_V:4*:FTX*) # From Gerald Hewes . # How about differentiating between stratus architectures? -djm echo hppa1.1-stratus-sysv4 exit ;; *:*:*:FTX*) # From seanf@swdc.stratus.com. echo i860-stratus-sysv4 exit ;; i*86:VOS:*:*) # From Paul.Green@stratus.com. echo ${UNAME_MACHINE}-stratus-vos exit ;; *:VOS:*:*) # From Paul.Green@stratus.com. echo hppa1.1-stratus-vos exit ;; mc68*:A/UX:*:*) echo m68k-apple-aux${UNAME_RELEASE} exit ;; news*:NEWS-OS:6*:*) echo mips-sony-newsos6 exit ;; R[34]000:*System_V*:*:* | R4000:UNIX_SYSV:*:* | R*000:UNIX_SV:*:*) if [ -d /usr/nec ]; then echo mips-nec-sysv${UNAME_RELEASE} else echo mips-unknown-sysv${UNAME_RELEASE} fi exit ;; BeBox:BeOS:*:*) # BeOS running on hardware made by Be, PPC only. echo powerpc-be-beos exit ;; BeMac:BeOS:*:*) # BeOS running on Mac or Mac clone, PPC only. echo powerpc-apple-beos exit ;; BePC:BeOS:*:*) # BeOS running on Intel PC compatible. echo i586-pc-beos exit ;; BePC:Haiku:*:*) # Haiku running on Intel PC compatible. echo i586-pc-haiku exit ;; x86_64:Haiku:*:*) echo x86_64-unknown-haiku exit ;; SX-4:SUPER-UX:*:*) echo sx4-nec-superux${UNAME_RELEASE} exit ;; SX-5:SUPER-UX:*:*) echo sx5-nec-superux${UNAME_RELEASE} exit ;; SX-6:SUPER-UX:*:*) echo sx6-nec-superux${UNAME_RELEASE} exit ;; SX-7:SUPER-UX:*:*) echo sx7-nec-superux${UNAME_RELEASE} exit ;; SX-8:SUPER-UX:*:*) echo sx8-nec-superux${UNAME_RELEASE} exit ;; SX-8R:SUPER-UX:*:*) echo sx8r-nec-superux${UNAME_RELEASE} exit ;; Power*:Rhapsody:*:*) echo powerpc-apple-rhapsody${UNAME_RELEASE} exit ;; *:Rhapsody:*:*) echo ${UNAME_MACHINE}-apple-rhapsody${UNAME_RELEASE} exit ;; *:Darwin:*:*) UNAME_PROCESSOR=`uname -p` || UNAME_PROCESSOR=unknown case $UNAME_PROCESSOR in i386) eval $set_cc_for_build if [ "$CC_FOR_BUILD" != 'no_compiler_found' ]; then if (echo '#ifdef __LP64__'; echo IS_64BIT_ARCH; echo '#endif') | \ (CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) | \ grep IS_64BIT_ARCH >/dev/null then UNAME_PROCESSOR="x86_64" fi fi ;; unknown) UNAME_PROCESSOR=powerpc ;; esac echo ${UNAME_PROCESSOR}-apple-darwin${UNAME_RELEASE} exit ;; *:procnto*:*:* | *:QNX:[0123456789]*:*) UNAME_PROCESSOR=`uname -p` if test "$UNAME_PROCESSOR" = "x86"; then UNAME_PROCESSOR=i386 UNAME_MACHINE=pc fi echo ${UNAME_PROCESSOR}-${UNAME_MACHINE}-nto-qnx${UNAME_RELEASE} exit ;; *:QNX:*:4*) echo i386-pc-qnx exit ;; NEO-?:NONSTOP_KERNEL:*:*) echo neo-tandem-nsk${UNAME_RELEASE} exit ;; NSE-*:NONSTOP_KERNEL:*:*) echo nse-tandem-nsk${UNAME_RELEASE} exit ;; NSR-?:NONSTOP_KERNEL:*:*) echo nsr-tandem-nsk${UNAME_RELEASE} exit ;; *:NonStop-UX:*:*) echo mips-compaq-nonstopux exit ;; BS2000:POSIX*:*:*) echo bs2000-siemens-sysv exit ;; DS/*:UNIX_System_V:*:*) echo ${UNAME_MACHINE}-${UNAME_SYSTEM}-${UNAME_RELEASE} exit ;; *:Plan9:*:*) # "uname -m" is not consistent, so use $cputype instead. 386 # is converted to i386 for consistency with other x86 # operating systems. if test "$cputype" = "386"; then UNAME_MACHINE=i386 else UNAME_MACHINE="$cputype" fi echo ${UNAME_MACHINE}-unknown-plan9 exit ;; *:TOPS-10:*:*) echo pdp10-unknown-tops10 exit ;; *:TENEX:*:*) echo pdp10-unknown-tenex exit ;; KS10:TOPS-20:*:* | KL10:TOPS-20:*:* | TYPE4:TOPS-20:*:*) echo pdp10-dec-tops20 exit ;; XKL-1:TOPS-20:*:* | TYPE5:TOPS-20:*:*) echo pdp10-xkl-tops20 exit ;; *:TOPS-20:*:*) echo pdp10-unknown-tops20 exit ;; *:ITS:*:*) echo pdp10-unknown-its exit ;; SEI:*:*:SEIUX) echo mips-sei-seiux${UNAME_RELEASE} exit ;; *:DragonFly:*:*) echo ${UNAME_MACHINE}-unknown-dragonfly`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` exit ;; *:*VMS:*:*) UNAME_MACHINE=`(uname -p) 2>/dev/null` case "${UNAME_MACHINE}" in A*) echo alpha-dec-vms ; exit ;; I*) echo ia64-dec-vms ; exit ;; V*) echo vax-dec-vms ; exit ;; esac ;; *:XENIX:*:SysV) echo i386-pc-xenix exit ;; i*86:skyos:*:*) echo ${UNAME_MACHINE}-pc-skyos`echo ${UNAME_RELEASE}` | sed -e 's/ .*$//' exit ;; i*86:rdos:*:*) echo ${UNAME_MACHINE}-pc-rdos exit ;; i*86:AROS:*:*) echo ${UNAME_MACHINE}-pc-aros exit ;; x86_64:VMkernel:*:*) echo ${UNAME_MACHINE}-unknown-esx exit ;; esac eval $set_cc_for_build cat >$dummy.c < # include #endif main () { #if defined (sony) #if defined (MIPSEB) /* BFD wants "bsd" instead of "newsos". Perhaps BFD should be changed, I don't know.... */ printf ("mips-sony-bsd\n"); exit (0); #else #include printf ("m68k-sony-newsos%s\n", #ifdef NEWSOS4 "4" #else "" #endif ); exit (0); #endif #endif #if defined (__arm) && defined (__acorn) && defined (__unix) printf ("arm-acorn-riscix\n"); exit (0); #endif #if defined (hp300) && !defined (hpux) printf ("m68k-hp-bsd\n"); exit (0); #endif #if defined (NeXT) #if !defined (__ARCHITECTURE__) #define __ARCHITECTURE__ "m68k" #endif int version; version=`(hostinfo | sed -n 's/.*NeXT Mach \([0-9]*\).*/\1/p') 2>/dev/null`; if (version < 4) printf ("%s-next-nextstep%d\n", __ARCHITECTURE__, version); else printf ("%s-next-openstep%d\n", __ARCHITECTURE__, version); exit (0); #endif #if defined (MULTIMAX) || defined (n16) #if defined (UMAXV) printf ("ns32k-encore-sysv\n"); exit (0); #else #if defined (CMU) printf ("ns32k-encore-mach\n"); exit (0); #else printf ("ns32k-encore-bsd\n"); exit (0); #endif #endif #endif #if defined (__386BSD__) printf ("i386-pc-bsd\n"); exit (0); #endif #if defined (sequent) #if defined (i386) printf ("i386-sequent-dynix\n"); exit (0); #endif #if defined (ns32000) printf ("ns32k-sequent-dynix\n"); exit (0); #endif #endif #if defined (_SEQUENT_) struct utsname un; uname(&un); if (strncmp(un.version, "V2", 2) == 0) { printf ("i386-sequent-ptx2\n"); exit (0); } if (strncmp(un.version, "V1", 2) == 0) { /* XXX is V1 correct? */ printf ("i386-sequent-ptx1\n"); exit (0); } printf ("i386-sequent-ptx\n"); exit (0); #endif #if defined (vax) # if !defined (ultrix) # include # if defined (BSD) # if BSD == 43 printf ("vax-dec-bsd4.3\n"); exit (0); # else # if BSD == 199006 printf ("vax-dec-bsd4.3reno\n"); exit (0); # else printf ("vax-dec-bsd\n"); exit (0); # endif # endif # else printf ("vax-dec-bsd\n"); exit (0); # endif # else printf ("vax-dec-ultrix\n"); exit (0); # endif #endif #if defined (alliant) && defined (i860) printf ("i860-alliant-bsd\n"); exit (0); #endif exit (1); } EOF $CC_FOR_BUILD -o $dummy $dummy.c 2>/dev/null && SYSTEM_NAME=`$dummy` && { echo "$SYSTEM_NAME"; exit; } # Apollos put the system type in the environment. test -d /usr/apollo && { echo ${ISP}-apollo-${SYSTYPE}; exit; } # Convex versions that predate uname can use getsysinfo(1) if [ -x /usr/convex/getsysinfo ] then case `getsysinfo -f cpu_type` in c1*) echo c1-convex-bsd exit ;; c2*) if getsysinfo -f scalar_acc then echo c32-convex-bsd else echo c2-convex-bsd fi exit ;; c34*) echo c34-convex-bsd exit ;; c38*) echo c38-convex-bsd exit ;; c4*) echo c4-convex-bsd exit ;; esac fi cat >&2 < in order to provide the needed information to handle your system. config.guess timestamp = $timestamp 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` /bin/uname -X = `(/bin/uname -X) 2>/dev/null` hostinfo = `(hostinfo) 2>/dev/null` /bin/universe = `(/bin/universe) 2>/dev/null` /usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null` /bin/arch = `(/bin/arch) 2>/dev/null` /usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null` /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null` UNAME_MACHINE = ${UNAME_MACHINE} UNAME_RELEASE = ${UNAME_RELEASE} UNAME_SYSTEM = ${UNAME_SYSTEM} UNAME_VERSION = ${UNAME_VERSION} EOF exit 1 # Local variables: # eval: (add-hook 'write-file-hooks 'time-stamp) # time-stamp-start: "timestamp='" # time-stamp-format: "%:y-%02m-%02d" # time-stamp-end: "'" # End: ecl-16.1.2/src/config.sub000077500000000000000000001054671266352375300151470ustar00rootroot00000000000000#! /bin/sh # Configuration validation subroutine script. # Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, # 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, # 2011, 2012, 2013 Free Software Foundation, Inc. timestamp='2012-12-29' # This file is free software; you can redistribute it and/or modify it # under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 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 . # # As a special exception to the GNU General Public License, if you # distribute this file as part of a program that contains a # configuration script generated by Autoconf, you may include it under # the same distribution terms that you use for the rest of that # program. This Exception is an additional permission under section 7 # of the GNU General Public License, version 3 ("GPLv3"). # Please send patches with a ChangeLog entry to config-patches@gnu.org. # # Configuration subroutine to validate and canonicalize a configuration type. # Supply the specified configuration type as an argument. # If it is invalid, we print an error message on stderr and exit with code 1. # Otherwise, we print the canonical config type on stdout and succeed. # You can get the latest version of this script from: # http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.sub;hb=HEAD # This file is supposed to be the same for all GNU packages # and recognize all the CPU types, system types and aliases # that are meaningful with *any* GNU software. # Each package is responsible for reporting which valid configurations # it does not support. The user should be able to distinguish # a failure to support a valid configuration from a meaningless # configuration. # The goal of this file is to map all the various variations of a given # machine specification into a single specification in the form: # CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM # or in some cases, the newer four-part form: # CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM # It is wrong to echo any other type of specification. me=`echo "$0" | sed -e 's,.*/,,'` usage="\ Usage: $0 [OPTION] CPU-MFR-OPSYS $0 [OPTION] ALIAS Canonicalize a configuration name. Operation modes: -h, --help print this help, then exit -t, --time-stamp print date of last modification, then exit -v, --version print version number, then exit Report bugs and patches to ." version="\ GNU config.sub ($timestamp) Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Free Software Foundation, Inc. This is free software; see the source for copying conditions. There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE." help=" Try \`$me --help' for more information." # Parse command line while test $# -gt 0 ; do case $1 in --time-stamp | --time* | -t ) echo "$timestamp" ; exit ;; --version | -v ) echo "$version" ; exit ;; --help | --h* | -h ) echo "$usage"; exit ;; -- ) # Stop option processing shift; break ;; - ) # Use stdin as input. break ;; -* ) echo "$me: invalid option $1$help" exit 1 ;; *local*) # First pass through any local machine types. echo $1 exit ;; * ) break ;; esac done case $# in 0) echo "$me: missing argument$help" >&2 exit 1;; 1) ;; *) echo "$me: too many arguments$help" >&2 exit 1;; esac # Separate what the user gave into CPU-COMPANY and OS or KERNEL-OS (if any). # Here we must recognize all the valid KERNEL-OS combinations. maybe_os=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\2/'` case $maybe_os in nto-qnx* | linux-gnu* | linux-android* | linux-dietlibc | linux-newlib* | \ linux-musl* | linux-uclibc* | uclinux-uclibc* | uclinux-gnu* | kfreebsd*-gnu* | \ knetbsd*-gnu* | netbsd*-gnu* | \ kopensolaris*-gnu* | \ storm-chaos* | os2-emx* | rtmk-nova*) os=-$maybe_os basic_machine=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'` ;; android-linux) os=-linux-android basic_machine=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'`-unknown ;; *) basic_machine=`echo $1 | sed 's/-[^-]*$//'` if [ $basic_machine != $1 ] then os=`echo $1 | sed 's/.*-/-/'` else os=; fi ;; esac ### Let's recognize common machines as not being operating systems so ### that things like config.sub decstation-3100 work. We also ### recognize some manufacturers as not being operating systems, so we ### can provide default operating systems below. case $os in -sun*os*) # Prevent following clause from handling this invalid input. ;; -dec* | -mips* | -sequent* | -encore* | -pc532* | -sgi* | -sony* | \ -att* | -7300* | -3300* | -delta* | -motorola* | -sun[234]* | \ -unicom* | -ibm* | -next | -hp | -isi* | -apollo | -altos* | \ -convergent* | -ncr* | -news | -32* | -3600* | -3100* | -hitachi* |\ -c[123]* | -convex* | -sun | -crds | -omron* | -dg | -ultra | -tti* | \ -harris | -dolphin | -highlevel | -gould | -cbm | -ns | -masscomp | \ -apple | -axis | -knuth | -cray | -microblaze*) os= basic_machine=$1 ;; -bluegene*) os=-cnk ;; -sim | -cisco | -oki | -wec | -winbond) os= basic_machine=$1 ;; -scout) ;; -wrs) os=-vxworks basic_machine=$1 ;; -chorusos*) os=-chorusos basic_machine=$1 ;; -chorusrdb) os=-chorusrdb basic_machine=$1 ;; -hiux*) os=-hiuxwe2 ;; -sco6) os=-sco5v6 basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -sco5) os=-sco3.2v5 basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -sco4) os=-sco3.2v4 basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -sco3.2.[4-9]*) os=`echo $os | sed -e 's/sco3.2./sco3.2v/'` basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -sco3.2v[4-9]*) # Don't forget version if it is 3.2v4 or newer. basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -sco5v6*) # Don't forget version if it is 3.2v4 or newer. basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -sco*) os=-sco3.2v2 basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -udk*) basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -isc) os=-isc2.2 basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -clix*) basic_machine=clipper-intergraph ;; -isc*) basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -lynx*178) os=-lynxos178 ;; -lynx*5) os=-lynxos5 ;; -lynx*) os=-lynxos ;; -ptx*) basic_machine=`echo $1 | sed -e 's/86-.*/86-sequent/'` ;; -windowsnt*) os=`echo $os | sed -e 's/windowsnt/winnt/'` ;; -psos*) os=-psos ;; -mint | -mint[0-9]*) basic_machine=m68k-atari os=-mint ;; esac # Decode aliases for certain CPU-COMPANY combinations. case $basic_machine in # Recognize the basic CPU types without company name. # Some are omitted here because they have special meanings below. 1750a | 580 \ | a29k \ | aarch64 | aarch64_be \ | alpha | alphaev[4-8] | alphaev56 | alphaev6[78] | alphapca5[67] \ | alpha64 | alpha64ev[4-8] | alpha64ev56 | alpha64ev6[78] | alpha64pca5[67] \ | am33_2.0 \ | arc \ | arm | arm[bl]e | arme[lb] | armv[2-8] | armv[3-8][lb] | armv7[arm] \ | avr | avr32 \ | be32 | be64 \ | bfin \ | c4x | clipper \ | d10v | d30v | dlx | dsp16xx \ | epiphany \ | fido | fr30 | frv \ | h8300 | h8500 | hppa | hppa1.[01] | hppa2.0 | hppa2.0[nw] | hppa64 \ | hexagon \ | i370 | i860 | i960 | ia64 \ | ip2k | iq2000 \ | le32 | le64 \ | lm32 \ | m32c | m32r | m32rle | m68000 | m68k | m88k \ | maxq | mb | microblaze | microblazeel | mcore | mep | metag \ | mips | mipsbe | mipseb | mipsel | mipsle \ | mips16 \ | mips64 | mips64el \ | mips64octeon | mips64octeonel \ | mips64orion | mips64orionel \ | mips64r5900 | mips64r5900el \ | mips64vr | mips64vrel \ | mips64vr4100 | mips64vr4100el \ | mips64vr4300 | mips64vr4300el \ | mips64vr5000 | mips64vr5000el \ | mips64vr5900 | mips64vr5900el \ | mipsisa32 | mipsisa32el \ | mipsisa32r2 | mipsisa32r2el \ | mipsisa64 | mipsisa64el \ | mipsisa64r2 | mipsisa64r2el \ | mipsisa64sb1 | mipsisa64sb1el \ | mipsisa64sr71k | mipsisa64sr71kel \ | mipstx39 | mipstx39el \ | mn10200 | mn10300 \ | moxie \ | mt \ | msp430 \ | nds32 | nds32le | nds32be \ | nios | nios2 \ | ns16k | ns32k \ | open8 \ | or32 \ | pdp10 | pdp11 | pj | pjl \ | powerpc | powerpc64 | powerpc64le | powerpcle \ | pyramid \ | rl78 | rx \ | score \ | sh | sh[1234] | sh[24]a | sh[24]aeb | sh[23]e | sh[34]eb | sheb | shbe | shle | sh[1234]le | sh3ele \ | sh64 | sh64le \ | sparc | sparc64 | sparc64b | sparc64v | sparc86x | sparclet | sparclite \ | sparcv8 | sparcv9 | sparcv9b | sparcv9v \ | spu \ | tahoe | tic4x | tic54x | tic55x | tic6x | tic80 | tron \ | ubicom32 \ | v850 | v850e | v850e1 | v850e2 | v850es | v850e2v3 \ | we32k \ | x86 | xc16x | xstormy16 | xtensa \ | z8k | z80) basic_machine=$basic_machine-unknown ;; c54x) basic_machine=tic54x-unknown ;; c55x) basic_machine=tic55x-unknown ;; c6x) basic_machine=tic6x-unknown ;; m6811 | m68hc11 | m6812 | m68hc12 | m68hcs12x | picochip) basic_machine=$basic_machine-unknown os=-none ;; m88110 | m680[12346]0 | m683?2 | m68360 | m5200 | v70 | w65 | z8k) ;; ms1) basic_machine=mt-unknown ;; strongarm | thumb | xscale) basic_machine=arm-unknown ;; xgate) basic_machine=$basic_machine-unknown os=-none ;; xscaleeb) basic_machine=armeb-unknown ;; xscaleel) basic_machine=armel-unknown ;; # We use `pc' rather than `unknown' # because (1) that's what they normally are, and # (2) the word "unknown" tends to confuse beginning users. i*86 | x86_64) basic_machine=$basic_machine-pc ;; # Object if more than one company name word. *-*-*) echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2 exit 1 ;; # Recognize the basic CPU types with company name. 580-* \ | a29k-* \ | aarch64-* | aarch64_be-* \ | alpha-* | alphaev[4-8]-* | alphaev56-* | alphaev6[78]-* \ | alpha64-* | alpha64ev[4-8]-* | alpha64ev56-* | alpha64ev6[78]-* \ | alphapca5[67]-* | alpha64pca5[67]-* | arc-* \ | arm-* | armbe-* | armle-* | armeb-* | armv*-* \ | avr-* | avr32-* \ | be32-* | be64-* \ | bfin-* | bs2000-* \ | c[123]* | c30-* | [cjt]90-* | c4x-* \ | clipper-* | craynv-* | cydra-* \ | d10v-* | d30v-* | dlx-* \ | elxsi-* \ | f30[01]-* | f700-* | fido-* | fr30-* | frv-* | fx80-* \ | h8300-* | h8500-* \ | hppa-* | hppa1.[01]-* | hppa2.0-* | hppa2.0[nw]-* | hppa64-* \ | hexagon-* \ | i*86-* | i860-* | i960-* | ia64-* \ | ip2k-* | iq2000-* \ | le32-* | le64-* \ | lm32-* \ | m32c-* | m32r-* | m32rle-* \ | m68000-* | m680[012346]0-* | m68360-* | m683?2-* | m68k-* \ | m88110-* | m88k-* | maxq-* | mcore-* | metag-* \ | microblaze-* | microblazeel-* \ | mips-* | mipsbe-* | mipseb-* | mipsel-* | mipsle-* \ | mips16-* \ | mips64-* | mips64el-* \ | mips64octeon-* | mips64octeonel-* \ | mips64orion-* | mips64orionel-* \ | mips64r5900-* | mips64r5900el-* \ | mips64vr-* | mips64vrel-* \ | mips64vr4100-* | mips64vr4100el-* \ | mips64vr4300-* | mips64vr4300el-* \ | mips64vr5000-* | mips64vr5000el-* \ | mips64vr5900-* | mips64vr5900el-* \ | mipsisa32-* | mipsisa32el-* \ | mipsisa32r2-* | mipsisa32r2el-* \ | mipsisa64-* | mipsisa64el-* \ | mipsisa64r2-* | mipsisa64r2el-* \ | mipsisa64sb1-* | mipsisa64sb1el-* \ | mipsisa64sr71k-* | mipsisa64sr71kel-* \ | mipstx39-* | mipstx39el-* \ | mmix-* \ | mt-* \ | msp430-* \ | nds32-* | nds32le-* | nds32be-* \ | nios-* | nios2-* \ | none-* | np1-* | ns16k-* | ns32k-* \ | open8-* \ | orion-* \ | pdp10-* | pdp11-* | pj-* | pjl-* | pn-* | power-* \ | powerpc-* | powerpc64-* | powerpc64le-* | powerpcle-* \ | pyramid-* \ | rl78-* | romp-* | rs6000-* | rx-* \ | sh-* | sh[1234]-* | sh[24]a-* | sh[24]aeb-* | sh[23]e-* | sh[34]eb-* | sheb-* | shbe-* \ | shle-* | sh[1234]le-* | sh3ele-* | sh64-* | sh64le-* \ | sparc-* | sparc64-* | sparc64b-* | sparc64v-* | sparc86x-* | sparclet-* \ | sparclite-* \ | sparcv8-* | sparcv9-* | sparcv9b-* | sparcv9v-* | sv1-* | sx?-* \ | tahoe-* \ | tic30-* | tic4x-* | tic54x-* | tic55x-* | tic6x-* | tic80-* \ | tile*-* \ | tron-* \ | ubicom32-* \ | v850-* | v850e-* | v850e1-* | v850es-* | v850e2-* | v850e2v3-* \ | vax-* \ | we32k-* \ | x86-* | x86_64-* | xc16x-* | xps100-* \ | xstormy16-* | xtensa*-* \ | ymp-* \ | z8k-* | z80-*) ;; # Recognize the basic CPU types without company name, with glob match. xtensa*) basic_machine=$basic_machine-unknown ;; # Recognize the various machine names and aliases which stand # for a CPU type and a company and sometimes even an OS. 386bsd) basic_machine=i386-unknown os=-bsd ;; 3b1 | 7300 | 7300-att | att-7300 | pc7300 | safari | unixpc) basic_machine=m68000-att ;; 3b*) basic_machine=we32k-att ;; a29khif) basic_machine=a29k-amd os=-udi ;; abacus) basic_machine=abacus-unknown ;; adobe68k) basic_machine=m68010-adobe os=-scout ;; alliant | fx80) basic_machine=fx80-alliant ;; altos | altos3068) basic_machine=m68k-altos ;; am29k) basic_machine=a29k-none os=-bsd ;; amd64) basic_machine=x86_64-pc ;; amd64-*) basic_machine=x86_64-`echo $basic_machine | sed 's/^[^-]*-//'` ;; amdahl) basic_machine=580-amdahl os=-sysv ;; amiga | amiga-*) basic_machine=m68k-unknown ;; amigaos | amigados) basic_machine=m68k-unknown os=-amigaos ;; amigaunix | amix) basic_machine=m68k-unknown os=-sysv4 ;; apollo68) basic_machine=m68k-apollo os=-sysv ;; apollo68bsd) basic_machine=m68k-apollo os=-bsd ;; aros) basic_machine=i386-pc os=-aros ;; aux) basic_machine=m68k-apple os=-aux ;; balance) basic_machine=ns32k-sequent os=-dynix ;; blackfin) basic_machine=bfin-unknown os=-linux ;; blackfin-*) basic_machine=bfin-`echo $basic_machine | sed 's/^[^-]*-//'` os=-linux ;; bluegene*) basic_machine=powerpc-ibm os=-cnk ;; c54x-*) basic_machine=tic54x-`echo $basic_machine | sed 's/^[^-]*-//'` ;; c55x-*) basic_machine=tic55x-`echo $basic_machine | sed 's/^[^-]*-//'` ;; c6x-*) basic_machine=tic6x-`echo $basic_machine | sed 's/^[^-]*-//'` ;; c90) basic_machine=c90-cray os=-unicos ;; cegcc) basic_machine=arm-unknown os=-cegcc ;; convex-c1) basic_machine=c1-convex os=-bsd ;; convex-c2) basic_machine=c2-convex os=-bsd ;; convex-c32) basic_machine=c32-convex os=-bsd ;; convex-c34) basic_machine=c34-convex os=-bsd ;; convex-c38) basic_machine=c38-convex os=-bsd ;; cray | j90) basic_machine=j90-cray os=-unicos ;; craynv) basic_machine=craynv-cray os=-unicosmp ;; cr16 | cr16-*) basic_machine=cr16-unknown os=-elf ;; crds | unos) basic_machine=m68k-crds ;; crisv32 | crisv32-* | etraxfs*) basic_machine=crisv32-axis ;; cris | cris-* | etrax*) basic_machine=cris-axis ;; crx) basic_machine=crx-unknown os=-elf ;; da30 | da30-*) basic_machine=m68k-da30 ;; decstation | decstation-3100 | pmax | pmax-* | pmin | dec3100 | decstatn) basic_machine=mips-dec ;; decsystem10* | dec10*) basic_machine=pdp10-dec os=-tops10 ;; decsystem20* | dec20*) basic_machine=pdp10-dec os=-tops20 ;; delta | 3300 | motorola-3300 | motorola-delta \ | 3300-motorola | delta-motorola) basic_machine=m68k-motorola ;; delta88) basic_machine=m88k-motorola os=-sysv3 ;; dicos) basic_machine=i686-pc os=-dicos ;; djgpp) basic_machine=i586-pc os=-msdosdjgpp ;; dpx20 | dpx20-*) basic_machine=rs6000-bull os=-bosx ;; dpx2* | dpx2*-bull) basic_machine=m68k-bull os=-sysv3 ;; ebmon29k) basic_machine=a29k-amd os=-ebmon ;; elxsi) basic_machine=elxsi-elxsi os=-bsd ;; encore | umax | mmax) basic_machine=ns32k-encore ;; es1800 | OSE68k | ose68k | ose | OSE) basic_machine=m68k-ericsson os=-ose ;; fx2800) basic_machine=i860-alliant ;; genix) basic_machine=ns32k-ns ;; gmicro) basic_machine=tron-gmicro os=-sysv ;; go32) basic_machine=i386-pc os=-go32 ;; h3050r* | hiux*) basic_machine=hppa1.1-hitachi os=-hiuxwe2 ;; h8300hms) basic_machine=h8300-hitachi os=-hms ;; h8300xray) basic_machine=h8300-hitachi os=-xray ;; h8500hms) basic_machine=h8500-hitachi os=-hms ;; harris) basic_machine=m88k-harris os=-sysv3 ;; hp300-*) basic_machine=m68k-hp ;; hp300bsd) basic_machine=m68k-hp os=-bsd ;; hp300hpux) basic_machine=m68k-hp os=-hpux ;; hp3k9[0-9][0-9] | hp9[0-9][0-9]) basic_machine=hppa1.0-hp ;; hp9k2[0-9][0-9] | hp9k31[0-9]) basic_machine=m68000-hp ;; hp9k3[2-9][0-9]) basic_machine=m68k-hp ;; hp9k6[0-9][0-9] | hp6[0-9][0-9]) basic_machine=hppa1.0-hp ;; hp9k7[0-79][0-9] | hp7[0-79][0-9]) basic_machine=hppa1.1-hp ;; hp9k78[0-9] | hp78[0-9]) # FIXME: really hppa2.0-hp basic_machine=hppa1.1-hp ;; hp9k8[67]1 | hp8[67]1 | hp9k80[24] | hp80[24] | hp9k8[78]9 | hp8[78]9 | hp9k893 | hp893) # FIXME: really hppa2.0-hp basic_machine=hppa1.1-hp ;; hp9k8[0-9][13679] | hp8[0-9][13679]) basic_machine=hppa1.1-hp ;; hp9k8[0-9][0-9] | hp8[0-9][0-9]) basic_machine=hppa1.0-hp ;; hppa-next) os=-nextstep3 ;; hppaosf) basic_machine=hppa1.1-hp os=-osf ;; hppro) basic_machine=hppa1.1-hp os=-proelf ;; i370-ibm* | ibm*) basic_machine=i370-ibm ;; i*86v32) basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'` os=-sysv32 ;; i*86v4*) basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'` os=-sysv4 ;; i*86v) basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'` os=-sysv ;; i*86sol2) basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'` os=-solaris2 ;; i386mach) basic_machine=i386-mach os=-mach ;; i386-vsta | vsta) basic_machine=i386-unknown os=-vsta ;; iris | iris4d) basic_machine=mips-sgi case $os in -irix*) ;; *) os=-irix4 ;; esac ;; isi68 | isi) basic_machine=m68k-isi os=-sysv ;; m68knommu) basic_machine=m68k-unknown os=-linux ;; m68knommu-*) basic_machine=m68k-`echo $basic_machine | sed 's/^[^-]*-//'` os=-linux ;; m88k-omron*) basic_machine=m88k-omron ;; magnum | m3230) basic_machine=mips-mips os=-sysv ;; merlin) basic_machine=ns32k-utek os=-sysv ;; microblaze*) basic_machine=microblaze-xilinx ;; mingw64) basic_machine=x86_64-pc os=-mingw64 ;; mingw32) basic_machine=i386-pc os=-mingw32 ;; mingw32ce) basic_machine=arm-unknown os=-mingw32ce ;; miniframe) basic_machine=m68000-convergent ;; *mint | -mint[0-9]* | *MiNT | *MiNT[0-9]*) basic_machine=m68k-atari os=-mint ;; mips3*-*) basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'` ;; mips3*) basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'`-unknown ;; monitor) basic_machine=m68k-rom68k os=-coff ;; morphos) basic_machine=powerpc-unknown os=-morphos ;; msdos) basic_machine=i386-pc os=-msdos ;; ms1-*) basic_machine=`echo $basic_machine | sed -e 's/ms1-/mt-/'` ;; msys) basic_machine=i386-pc os=-msys ;; mvs) basic_machine=i370-ibm os=-mvs ;; nacl) basic_machine=le32-unknown os=-nacl ;; ncr3000) basic_machine=i486-ncr os=-sysv4 ;; netbsd386) basic_machine=i386-unknown os=-netbsd ;; netwinder) basic_machine=armv4l-rebel os=-linux ;; news | news700 | news800 | news900) basic_machine=m68k-sony os=-newsos ;; news1000) basic_machine=m68030-sony os=-newsos ;; news-3600 | risc-news) basic_machine=mips-sony os=-newsos ;; necv70) basic_machine=v70-nec os=-sysv ;; next | m*-next ) basic_machine=m68k-next case $os in -nextstep* ) ;; -ns2*) os=-nextstep2 ;; *) os=-nextstep3 ;; esac ;; nh3000) basic_machine=m68k-harris os=-cxux ;; nh[45]000) basic_machine=m88k-harris os=-cxux ;; nindy960) basic_machine=i960-intel os=-nindy ;; mon960) basic_machine=i960-intel os=-mon960 ;; nonstopux) basic_machine=mips-compaq os=-nonstopux ;; np1) basic_machine=np1-gould ;; neo-tandem) basic_machine=neo-tandem ;; nse-tandem) basic_machine=nse-tandem ;; nsr-tandem) basic_machine=nsr-tandem ;; op50n-* | op60c-*) basic_machine=hppa1.1-oki os=-proelf ;; openrisc | openrisc-*) basic_machine=or32-unknown ;; os400) basic_machine=powerpc-ibm os=-os400 ;; OSE68000 | ose68000) basic_machine=m68000-ericsson os=-ose ;; os68k) basic_machine=m68k-none os=-os68k ;; pa-hitachi) basic_machine=hppa1.1-hitachi os=-hiuxwe2 ;; paragon) basic_machine=i860-intel os=-osf ;; parisc) basic_machine=hppa-unknown os=-linux ;; parisc-*) basic_machine=hppa-`echo $basic_machine | sed 's/^[^-]*-//'` os=-linux ;; pbd) basic_machine=sparc-tti ;; pbb) basic_machine=m68k-tti ;; pc532 | pc532-*) basic_machine=ns32k-pc532 ;; pc98) basic_machine=i386-pc ;; pc98-*) basic_machine=i386-`echo $basic_machine | sed 's/^[^-]*-//'` ;; pentium | p5 | k5 | k6 | nexgen | viac3) basic_machine=i586-pc ;; pentiumpro | p6 | 6x86 | athlon | athlon_*) basic_machine=i686-pc ;; pentiumii | pentium2 | pentiumiii | pentium3) basic_machine=i686-pc ;; pentium4) basic_machine=i786-pc ;; pentium-* | p5-* | k5-* | k6-* | nexgen-* | viac3-*) basic_machine=i586-`echo $basic_machine | sed 's/^[^-]*-//'` ;; pentiumpro-* | p6-* | 6x86-* | athlon-*) basic_machine=i686-`echo $basic_machine | sed 's/^[^-]*-//'` ;; pentiumii-* | pentium2-* | pentiumiii-* | pentium3-*) basic_machine=i686-`echo $basic_machine | sed 's/^[^-]*-//'` ;; pentium4-*) basic_machine=i786-`echo $basic_machine | sed 's/^[^-]*-//'` ;; pn) basic_machine=pn-gould ;; power) basic_machine=power-ibm ;; ppc | ppcbe) basic_machine=powerpc-unknown ;; ppc-* | ppcbe-*) basic_machine=powerpc-`echo $basic_machine | sed 's/^[^-]*-//'` ;; ppcle | powerpclittle | ppc-le | powerpc-little) basic_machine=powerpcle-unknown ;; ppcle-* | powerpclittle-*) basic_machine=powerpcle-`echo $basic_machine | sed 's/^[^-]*-//'` ;; ppc64) basic_machine=powerpc64-unknown ;; ppc64-*) basic_machine=powerpc64-`echo $basic_machine | sed 's/^[^-]*-//'` ;; ppc64le | powerpc64little | ppc64-le | powerpc64-little) basic_machine=powerpc64le-unknown ;; ppc64le-* | powerpc64little-*) basic_machine=powerpc64le-`echo $basic_machine | sed 's/^[^-]*-//'` ;; ps2) basic_machine=i386-ibm ;; pw32) basic_machine=i586-unknown os=-pw32 ;; rdos | rdos64) basic_machine=x86_64-pc os=-rdos ;; rdos32) basic_machine=i386-pc os=-rdos ;; rom68k) basic_machine=m68k-rom68k os=-coff ;; rm[46]00) basic_machine=mips-siemens ;; rtpc | rtpc-*) basic_machine=romp-ibm ;; s390 | s390-*) basic_machine=s390-ibm ;; s390x | s390x-*) basic_machine=s390x-ibm ;; sa29200) basic_machine=a29k-amd os=-udi ;; sb1) basic_machine=mipsisa64sb1-unknown ;; sb1el) basic_machine=mipsisa64sb1el-unknown ;; sde) basic_machine=mipsisa32-sde os=-elf ;; sei) basic_machine=mips-sei os=-seiux ;; sequent) basic_machine=i386-sequent ;; sh) basic_machine=sh-hitachi os=-hms ;; sh5el) basic_machine=sh5le-unknown ;; sh64) basic_machine=sh64-unknown ;; sparclite-wrs | simso-wrs) basic_machine=sparclite-wrs os=-vxworks ;; sps7) basic_machine=m68k-bull os=-sysv2 ;; spur) basic_machine=spur-unknown ;; st2000) basic_machine=m68k-tandem ;; stratus) basic_machine=i860-stratus os=-sysv4 ;; strongarm-* | thumb-*) basic_machine=arm-`echo $basic_machine | sed 's/^[^-]*-//'` ;; sun2) basic_machine=m68000-sun ;; sun2os3) basic_machine=m68000-sun os=-sunos3 ;; sun2os4) basic_machine=m68000-sun os=-sunos4 ;; sun3os3) basic_machine=m68k-sun os=-sunos3 ;; sun3os4) basic_machine=m68k-sun os=-sunos4 ;; sun4os3) basic_machine=sparc-sun os=-sunos3 ;; sun4os4) basic_machine=sparc-sun os=-sunos4 ;; sun4sol2) basic_machine=sparc-sun os=-solaris2 ;; sun3 | sun3-*) basic_machine=m68k-sun ;; sun4) basic_machine=sparc-sun ;; sun386 | sun386i | roadrunner) basic_machine=i386-sun ;; sv1) basic_machine=sv1-cray os=-unicos ;; symmetry) basic_machine=i386-sequent os=-dynix ;; t3e) basic_machine=alphaev5-cray os=-unicos ;; t90) basic_machine=t90-cray os=-unicos ;; tile*) basic_machine=$basic_machine-unknown os=-linux-gnu ;; tx39) basic_machine=mipstx39-unknown ;; tx39el) basic_machine=mipstx39el-unknown ;; toad1) basic_machine=pdp10-xkl os=-tops20 ;; tower | tower-32) basic_machine=m68k-ncr ;; tpf) basic_machine=s390x-ibm os=-tpf ;; udi29k) basic_machine=a29k-amd os=-udi ;; ultra3) basic_machine=a29k-nyu os=-sym1 ;; v810 | necv810) basic_machine=v810-nec os=-none ;; vaxv) basic_machine=vax-dec os=-sysv ;; vms) basic_machine=vax-dec os=-vms ;; vpp*|vx|vx-*) basic_machine=f301-fujitsu ;; vxworks960) basic_machine=i960-wrs os=-vxworks ;; vxworks68) basic_machine=m68k-wrs os=-vxworks ;; vxworks29k) basic_machine=a29k-wrs os=-vxworks ;; w65*) basic_machine=w65-wdc os=-none ;; w89k-*) basic_machine=hppa1.1-winbond os=-proelf ;; xbox) basic_machine=i686-pc os=-mingw32 ;; xps | xps100) basic_machine=xps100-honeywell ;; xscale-* | xscalee[bl]-*) basic_machine=`echo $basic_machine | sed 's/^xscale/arm/'` ;; ymp) basic_machine=ymp-cray os=-unicos ;; z8k-*-coff) basic_machine=z8k-unknown os=-sim ;; z80-*-coff) basic_machine=z80-unknown os=-sim ;; none) basic_machine=none-none os=-none ;; # Here we handle the default manufacturer of certain CPU types. It is in # some cases the only manufacturer, in others, it is the most popular. w89k) basic_machine=hppa1.1-winbond ;; op50n) basic_machine=hppa1.1-oki ;; op60c) basic_machine=hppa1.1-oki ;; romp) basic_machine=romp-ibm ;; mmix) basic_machine=mmix-knuth ;; rs6000) basic_machine=rs6000-ibm ;; vax) basic_machine=vax-dec ;; pdp10) # there are many clones, so DEC is not a safe bet basic_machine=pdp10-unknown ;; pdp11) basic_machine=pdp11-dec ;; we32k) basic_machine=we32k-att ;; sh[1234] | sh[24]a | sh[24]aeb | sh[34]eb | sh[1234]le | sh[23]ele) basic_machine=sh-unknown ;; sparc | sparcv8 | sparcv9 | sparcv9b | sparcv9v) basic_machine=sparc-sun ;; cydra) basic_machine=cydra-cydrome ;; orion) basic_machine=orion-highlevel ;; orion105) basic_machine=clipper-highlevel ;; mac | mpw | mac-mpw) basic_machine=m68k-apple ;; pmac | pmac-mpw) basic_machine=powerpc-apple ;; *-unknown) # Make sure to match an already-canonicalized machine name. ;; *) echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2 exit 1 ;; esac # Here we canonicalize certain aliases for manufacturers. case $basic_machine in *-digital*) basic_machine=`echo $basic_machine | sed 's/digital.*/dec/'` ;; *-commodore*) basic_machine=`echo $basic_machine | sed 's/commodore.*/cbm/'` ;; *) ;; esac # Decode manufacturer-specific aliases for certain operating systems. if [ x"$os" != x"" ] then case $os in # First match some system type aliases # that might get confused with valid system types. # -solaris* is a basic system type, with this one exception. -auroraux) os=-auroraux ;; -solaris1 | -solaris1.*) os=`echo $os | sed -e 's|solaris1|sunos4|'` ;; -solaris) os=-solaris2 ;; -svr4*) os=-sysv4 ;; -unixware*) os=-sysv4.2uw ;; -gnu/linux*) os=`echo $os | sed -e 's|gnu/linux|linux-gnu|'` ;; # First accept the basic system types. # The portable systems comes first. # Each alternative MUST END IN A *, to match a version number. # -sysv* is not here because it comes later, after sysvr4. -gnu* | -bsd* | -mach* | -minix* | -genix* | -ultrix* | -irix* \ | -*vms* | -sco* | -esix* | -isc* | -aix* | -cnk* | -sunos | -sunos[34]*\ | -hpux* | -unos* | -osf* | -luna* | -dgux* | -auroraux* | -solaris* \ | -sym* | -kopensolaris* \ | -amigaos* | -amigados* | -msdos* | -newsos* | -unicos* | -aof* \ | -aos* | -aros* \ | -nindy* | -vxsim* | -vxworks* | -ebmon* | -hms* | -mvs* \ | -clix* | -riscos* | -uniplus* | -iris* | -rtu* | -xenix* \ | -hiux* | -386bsd* | -knetbsd* | -mirbsd* | -netbsd* \ | -bitrig* | -openbsd* | -solidbsd* \ | -ekkobsd* | -kfreebsd* | -freebsd* | -riscix* | -lynxos* \ | -bosx* | -nextstep* | -cxux* | -aout* | -elf* | -oabi* \ | -ptx* | -coff* | -ecoff* | -winnt* | -domain* | -vsta* \ | -udi* | -eabi* | -lites* | -ieee* | -go32* | -aux* \ | -chorusos* | -chorusrdb* | -cegcc* \ | -cygwin* | -msys* | -pe* | -psos* | -moss* | -proelf* | -rtems* \ | -mingw32* | -mingw64* | -linux-gnu* | -linux-android* \ | -linux-newlib* | -linux-musl* | -linux-uclibc* \ | -uxpv* | -beos* | -mpeix* | -udk* \ | -interix* | -uwin* | -mks* | -rhapsody* | -darwin* | -opened* \ | -openstep* | -oskit* | -conix* | -pw32* | -nonstopux* \ | -storm-chaos* | -tops10* | -tenex* | -tops20* | -its* \ | -os2* | -vos* | -palmos* | -uclinux* | -nucleus* \ | -morphos* | -superux* | -rtmk* | -rtmk-nova* | -windiss* \ | -powermax* | -dnix* | -nx6 | -nx7 | -sei* | -dragonfly* \ | -skyos* | -haiku* | -rdos* | -toppers* | -drops* | -es*) # Remember, each alternative MUST END IN *, to match a version number. ;; -qnx*) case $basic_machine in x86-* | i*86-*) ;; *) os=-nto$os ;; esac ;; -nto-qnx*) ;; -nto*) os=`echo $os | sed -e 's|nto|nto-qnx|'` ;; -sim | -es1800* | -hms* | -xray | -os68k* | -none* | -v88r* \ | -windows* | -osx | -abug | -netware* | -os9* | -beos* | -haiku* \ | -macos* | -mpw* | -magic* | -mmixware* | -mon960* | -lnews*) ;; -mac*) os=`echo $os | sed -e 's|mac|macos|'` ;; -linux-dietlibc) os=-linux-dietlibc ;; -linux*) os=`echo $os | sed -e 's|linux|linux-gnu|'` ;; -sunos5*) os=`echo $os | sed -e 's|sunos5|solaris2|'` ;; -sunos6*) os=`echo $os | sed -e 's|sunos6|solaris3|'` ;; -opened*) os=-openedition ;; -os400*) os=-os400 ;; -wince*) os=-wince ;; -osfrose*) os=-osfrose ;; -osf*) os=-osf ;; -utek*) os=-bsd ;; -dynix*) os=-bsd ;; -acis*) os=-aos ;; -atheos*) os=-atheos ;; -syllable*) os=-syllable ;; -386bsd) os=-bsd ;; -ctix* | -uts*) os=-sysv ;; -nova*) os=-rtmk-nova ;; -ns2 ) os=-nextstep2 ;; -nsk*) os=-nsk ;; # Preserve the version number of sinix5. -sinix5.*) os=`echo $os | sed -e 's|sinix|sysv|'` ;; -sinix*) os=-sysv4 ;; -tpf*) os=-tpf ;; -triton*) os=-sysv3 ;; -oss*) os=-sysv3 ;; -svr4) os=-sysv4 ;; -svr3) os=-sysv3 ;; -sysvr4) os=-sysv4 ;; # This must come after -sysvr4. -sysv*) ;; -ose*) os=-ose ;; -es1800*) os=-ose ;; -xenix) os=-xenix ;; -*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*) os=-mint ;; -aros*) os=-aros ;; -kaos*) os=-kaos ;; -zvmoe) os=-zvmoe ;; -dicos*) os=-dicos ;; -nacl*) ;; -none) ;; *) # Get rid of the `-' at the beginning of $os. os=`echo $os | sed 's/[^-]*-//'` echo Invalid configuration \`$1\': system \`$os\' not recognized 1>&2 exit 1 ;; esac else # Here we handle the default operating systems that come with various machines. # The value should be what the vendor currently ships out the door with their # machine or put another way, the most popular os provided with the machine. # Note that if you're going to try to match "-MANUFACTURER" here (say, # "-sun"), then you have to tell the case statement up towards the top # that MANUFACTURER isn't an operating system. Otherwise, code above # will signal an error saying that MANUFACTURER isn't an operating # system, and we'll never get to this point. case $basic_machine in score-*) os=-elf ;; spu-*) os=-elf ;; *-acorn) os=-riscix1.2 ;; arm*-rebel) os=-linux ;; arm*-semi) os=-aout ;; c4x-* | tic4x-*) os=-coff ;; hexagon-*) os=-elf ;; tic54x-*) os=-coff ;; tic55x-*) os=-coff ;; tic6x-*) os=-coff ;; # This must come before the *-dec entry. pdp10-*) os=-tops20 ;; pdp11-*) os=-none ;; *-dec | vax-*) os=-ultrix4.2 ;; m68*-apollo) os=-domain ;; i386-sun) os=-sunos4.0.2 ;; m68000-sun) os=-sunos3 ;; m68*-cisco) os=-aout ;; mep-*) os=-elf ;; mips*-cisco) os=-elf ;; mips*-*) os=-elf ;; or32-*) os=-coff ;; *-tti) # must be before sparc entry or we get the wrong os. os=-sysv3 ;; sparc-* | *-sun) os=-sunos4.1.1 ;; *-be) os=-beos ;; *-haiku) os=-haiku ;; *-ibm) os=-aix ;; *-knuth) os=-mmixware ;; *-wec) os=-proelf ;; *-winbond) os=-proelf ;; *-oki) os=-proelf ;; *-hp) os=-hpux ;; *-hitachi) os=-hiux ;; i860-* | *-att | *-ncr | *-altos | *-motorola | *-convergent) os=-sysv ;; *-cbm) os=-amigaos ;; *-dg) os=-dgux ;; *-dolphin) os=-sysv3 ;; m68k-ccur) os=-rtu ;; m88k-omron*) os=-luna ;; *-next ) os=-nextstep ;; *-sequent) os=-ptx ;; *-crds) os=-unos ;; *-ns) os=-genix ;; i370-*) os=-mvs ;; *-next) os=-nextstep3 ;; *-gould) os=-sysv ;; *-highlevel) os=-bsd ;; *-encore) os=-bsd ;; *-sgi) os=-irix ;; *-siemens) os=-sysv4 ;; *-masscomp) os=-rtu ;; f30[01]-fujitsu | f700-fujitsu) os=-uxpv ;; *-rom68k) os=-coff ;; *-*bug) os=-coff ;; *-apple) os=-macos ;; *-atari*) os=-mint ;; *) os=-none ;; esac fi # Here we handle the case where we know the os, and the CPU type, but not the # manufacturer. We pick the logical manufacturer. vendor=unknown case $basic_machine in *-unknown) case $os in -riscix*) vendor=acorn ;; -sunos*) vendor=sun ;; -cnk*|-aix*) vendor=ibm ;; -beos*) vendor=be ;; -hpux*) vendor=hp ;; -mpeix*) vendor=hp ;; -hiux*) vendor=hitachi ;; -unos*) vendor=crds ;; -dgux*) vendor=dg ;; -luna*) vendor=omron ;; -genix*) vendor=ns ;; -mvs* | -opened*) vendor=ibm ;; -os400*) vendor=ibm ;; -ptx*) vendor=sequent ;; -tpf*) vendor=ibm ;; -vxsim* | -vxworks* | -windiss*) vendor=wrs ;; -aux*) vendor=apple ;; -hms*) vendor=hitachi ;; -mpw* | -macos*) vendor=apple ;; -*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*) vendor=atari ;; -vos*) vendor=stratus ;; esac basic_machine=`echo $basic_machine | sed "s/unknown/$vendor/"` ;; esac echo $basic_machine$os exit # Local variables: # eval: (add-hook 'write-file-hooks 'time-stamp) # time-stamp-start: "timestamp='" # time-stamp-format: "%:y-%02m-%02d" # time-stamp-end: "'" # End: ecl-16.1.2/src/configure000077500000000000000000011212731266352375300150650ustar00rootroot00000000000000#! /bin/sh # From configure.ac Revision. # Guess values for system-dependent variables and create Makefiles. # Generated by GNU Autoconf 2.69 for ecl 16.1.2. # # # 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 \$(( 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'" 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='ecl' PACKAGE_TARNAME='ecl' PACKAGE_VERSION='16.1.2' PACKAGE_STRING='ecl 16.1.2' PACKAGE_BUGREPORT='' PACKAGE_URL='' ac_unique_file="bare.lsp.in" # 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_header_list= ac_subst_vars='LTLIBOBJS ECL_INIT_FORM ECL_EXTRA_LISP_FILES CHAR_CODE_LIMIT ECL_CHARACTER CLX_INFO CC_IS_CXX ECL_CC POW_LIB LIBOBJS ECL_FPE_CODE ECL_FILE_CNT ECL_LONGJMP ECL_SETJMP ECL_STDINT_HEADER CL_LONG_BITS CL_INT_BITS CL_FIXNUM_MIN CL_FIXNUM_MAX CL_FIXNUM_BITS CL_FIXNUM_TYPE XMKMF ECL_VERSION_NUMBER SONAME_LDFLAGS SONAME SONAME1 SONAME2 SONAME3 ECL_LIBFFI_HEADER ECL_BOEHM_GC_HEADER ECL_CMPDIR ECL_GMP_HEADER EGREP GREP INSTALL_INFO INFOEXT ECL_GC_DIR thehost INSTALL_TARGET SHAREDPREFIX SHAREDEXT LIBEXT LIBPREFIX ECL_LDRPATH MACHINE_VERSION SOFTWARE_VERSION SOFTWARE_TYPE ARCHITECTURE EXE_SUFFIX MV RM CP true_builddir true_srcdir ETAGS AR SET_MAKE LN_S INSTALL_DATA INSTALL_SCRIPT INSTALL_PROGRAM RANLIB CPP ac_ct_CXX CXXFLAGS CXX OBJEXT EXEEXT ac_ct_CC CPPFLAGS LDFLAGS CFLAGS CC host_os host_vendor host_cpu host build_os build_vendor build_cpu build LSP_FEATURES LSP_LIBRARIES LIBRARIES SUBDIRS TARGETS EXTRA_OBJS BUNDLE_LDFLAGS SHARED_LDFLAGS CORE_LIBS FASL_LIBS LIBFFI_LDFLAGS GMP_LDFLAGS GMP_CPPFLAGS DEBUG_CFLAGS ECL_CFLAGS buildir ecldir 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 with_cross_config enable_shared enable_rpath enable_threads enable_boehm enable_libatomic enable_soname with_gmp with_C_gmp with_system_gmp with_gmp_prefix with_gmp_incdir with_gmp_libdir enable_local_gmp with_libffi_prefix with___thread enable_opcode8 with_cxx with_tcp with_serve_event with_clx with_clos_streams with_cmuformat with_asdf with_defsystem with_cmp with_bytecmp with_rt with_profile with_dffi with_fpe with_signed_zero with_ieee_fp with_sse enable_unicode enable_longdouble enable_c99complex enable_hpack enable_asmapply enable_smallcons enable_gengc enable_precisegc enable_debug with_debug_cflags with_profile_cflags with_newcmp with_extra_files with_init_form with_unicode_names with_x ' ac_precious_vars='build_alias host_alias target_alias ecldir docdir CC CFLAGS LDFLAGS LIBS CPPFLAGS CXX CXXFLAGS CCC CPP XMKMF' # 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 ecl 16.1.2 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/ecl] --htmldir=DIR html documentation [DOCDIR] --dvidir=DIR dvi documentation [DOCDIR] --pdfdir=DIR pdf documentation [DOCDIR] --psdir=DIR ps documentation [DOCDIR] _ACEOF cat <<\_ACEOF X features: --x-includes=DIR X include files are in DIR --x-libraries=DIR X library files are in DIR 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 ecl 16.1.2:";; 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-shared enable loading compiled files (default=YES) --enable-rpath hard-code the location of the ECL shared library. (no|yes, default=NO) --enable-threads support for native threads (yes|no|auto, default=auto). --enable-boehm use the Boehm-Weiser garbage collector (no|included|system|auto, default=auto) --enable-libatomic version of the libatomic-ops library (auto|included|system, default=auto) --enable-soname link and install the library using version numbers (no|yes, default=yes) --enable-local-gmp Deprecated! See --with-system-gmp --enable-opcode8 interpreter uses 8-bit codes (default=NO, only works on Intel) --enable-unicode={yes|no|32} enable support for unicode (default=YES) --enable-longdouble include support for long double (yes|no|auto, default=AUTO) --enable-c99complex include support for C complex type (default=NO) --enable-hpack hierarchical package names (default=YES) --enable-asmapply enable optimizations written in assembler, EXPERIMENTAL (default=NO) --enable-smallcons use small (2 words) cons types. Requires Boehm-Weiser gc. (default=YES) --enable-gengc use generational garbage collection. Requires Boehm-Weiser gc. (no|yes, default=NO) --enable-precisegc use type information during garbage collection. Requires Boehm-Weiser gc (EXPERIMENTAL). (no|yes, default=NO) --enable-debug enable various debugging features (default=NO) Optional Packages: --with-PACKAGE[=ARG] use PACKAGE [ARG=yes] --without-PACKAGE do not use PACKAGE (same as --with-PACKAGE=no) --with-cross-config=f supply configuration for a cross compiler --with-gmp=args supply arguments for configuring GMP library --with-C-gmp=args configure GMP to build using portable C --with-system-gmp use already installed GMP library (default=auto) --with-gmp-prefix=path prefix for system GMP includes and libraries --with-gmp-incdir=path path to system GMP includes (overrides prefix) --with-gmp-libdir=path path to system GMP libraries (overrides prefix) --with-libffi-prefix=path prefix for system LIBFFI includes and libraries --with-__thread Enable __thread thread-local variables (yes|NO|auto) (supported by NPTL-aware glibc and maybe Windows) --with-cxx build ECL using C++ compiler (default=NO) --with-tcp include socket interface (yes|builtin|no, default=YES) --with-serve-event include serve-event module (yes|builtin|no, default=YES) --with-clx include CLX library (yes|builtin|no, default=NO) --with-clos-streams user defined stream objects (yes|builtin|no, default=YES) --with-cmuformat use CMUCL's FORMAT routine (default=YES) --with-asdf include ASDF building facility (yes|builtin|no, default=YES) --with-defsystem include DEFSYSTEM building facility (yes|builtin|no, default=YES) --with-cmp build the compiler (yes|builtin|no, default=YES) --with-bytecmp build the bytecodes compiler (yes|builtin|no, default=YES) --with-rt include MIT-RT testing environment (yes|builtin|no, default=YES) --with-profile include CMUCL's simple profiler (yes|builtin|no, default=YES if Boehm-Weiser garbage collector used) --with-dffi dynamic foreign function interface (system|included|auto|no, default=AUTO if libffi available) --with-fpe detect floating point exceptions (default=YES) --with-signed-zero={yes|no} allow for IEEE signed zeros (default=YES). --with-ieee-fp={yes|no} full IEEE floating point system, including denormals (default=YES). Implies signed-zero and fpe --with-sse={yes|no|auto} implement SSE intrinsics in ECL (default=NO). Only works when supported by the compiler --with-debug-cflags add debug flags to the compiler invocation (yes,no,actual flags,default=YES) --with-profile-cflags add profiling flags to the compiler invocation (yes,no,actual flags,default=NO) --with-newcmp new compiler (yes|no, default=NO) --with-extra-files list of additional source files (default="") --with-init-form lisp forms to execute at startup (default="(si::top-level t)") --with-unicode-names link in the database of Unicode names (YES,no) --with-x use the X Window System Some influential environment variables: ecldir the directory where *.fas files are installed docdir the directory where documentation is installed 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 CXX C++ compiler command CXXFLAGS C++ compiler flags CPP C preprocessor XMKMF Path to xmkmf, Makefile generator for X Window System 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 ecl configure 16.1.2 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_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_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_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_mongrel LINENO HEADER VAR INCLUDES # ------------------------------------------------------- # Tests whether HEADER exists, giving a warning if it cannot be compiled using # the include files in INCLUDES and setting the cache variable VAR # accordingly. ac_fn_c_check_header_mongrel () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack if eval \${$3+:} false; then : { $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 fi eval ac_res=\$$3 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 $as_echo "$ac_res" >&6; } else # Is the header compilable? { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5 $as_echo_n "checking $2 usability... " >&6; } cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $4 #include <$2> _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_header_compiler=yes else ac_header_compiler=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5 $as_echo "$ac_header_compiler" >&6; } # Is the header present? { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5 $as_echo_n "checking $2 presence... " >&6; } cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include <$2> _ACEOF if ac_fn_c_try_cpp "$LINENO"; then : ac_header_preproc=yes else ac_header_preproc=no fi rm -f conftest.err conftest.i conftest.$ac_ext { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5 $as_echo "$ac_header_preproc" >&6; } # So? What about this header? case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in #(( yes:no: ) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5 $as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;} { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5 $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;} ;; no:yes:* ) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5 $as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;} { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: check for missing prerequisite headers?" >&5 $as_echo "$as_me: WARNING: $2: check for missing prerequisite headers?" >&2;} { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5 $as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;} { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: section \"Present But Cannot Be Compiled\"" >&5 $as_echo "$as_me: WARNING: $2: section \"Present But Cannot Be Compiled\"" >&2;} { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5 $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;} ;; esac { $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 eval "$3=\$ac_header_compiler" fi eval ac_res=\$$3 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 $as_echo "$ac_res" >&6; } fi eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno } # ac_fn_c_check_header_mongrel # 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_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_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_c_check_type LINENO TYPE VAR INCLUDES # ------------------------------------------- # Tests whether TYPE exists after having included INCLUDES, setting cache # variable VAR accordingly. ac_fn_c_check_type () { 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 eval "$3=no" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $4 int main () { if (sizeof ($2)) return 0; ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $4 int main () { if (sizeof (($2))) return 0; ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : else eval "$3=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 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_type # ac_fn_c_find_intX_t LINENO BITS VAR # ----------------------------------- # Finds a signed integer type with width BITS, setting cache variable VAR # accordingly. ac_fn_c_find_intX_t () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack { $as_echo "$as_me:${as_lineno-$LINENO}: checking for int$2_t" >&5 $as_echo_n "checking for int$2_t... " >&6; } if eval \${$3+:} false; then : $as_echo_n "(cached) " >&6 else eval "$3=no" # Order is important - never check a type that is potentially smaller # than half of the expected target width. for ac_type in int$2_t 'int' 'long int' \ 'long long int' 'short int' 'signed char'; do cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $ac_includes_default enum { N = $2 / 2 - 1 }; int main () { static int test_array [1 - 2 * !(0 < ($ac_type) ((((($ac_type) 1 << N) << N) - 1) * 2 + 1))]; test_array [0] = 0; return test_array [0]; ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $ac_includes_default enum { N = $2 / 2 - 1 }; int main () { static int test_array [1 - 2 * !(($ac_type) ((((($ac_type) 1 << N) << N) - 1) * 2 + 1) < ($ac_type) ((((($ac_type) 1 << N) << N) - 1) * 2 + 2))]; test_array [0] = 0; return test_array [0]; ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : else case $ac_type in #( int$2_t) : eval "$3=yes" ;; #( *) : eval "$3=\$ac_type" ;; esac fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext if eval test \"x\$"$3"\" = x"no"; then : else break fi done 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_find_intX_t # ac_fn_c_find_uintX_t LINENO BITS VAR # ------------------------------------ # Finds an unsigned integer type with width BITS, setting cache variable VAR # accordingly. ac_fn_c_find_uintX_t () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack { $as_echo "$as_me:${as_lineno-$LINENO}: checking for uint$2_t" >&5 $as_echo_n "checking for uint$2_t... " >&6; } if eval \${$3+:} false; then : $as_echo_n "(cached) " >&6 else eval "$3=no" # Order is important - never check a type that is potentially smaller # than half of the expected target width. for ac_type in uint$2_t 'unsigned int' 'unsigned long int' \ 'unsigned long long int' 'unsigned short int' 'unsigned char'; do cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $ac_includes_default int main () { static int test_array [1 - 2 * !((($ac_type) -1 >> ($2 / 2 - 1)) >> ($2 / 2 - 1) == 3)]; test_array [0] = 0; return test_array [0]; ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : case $ac_type in #( uint$2_t) : eval "$3=yes" ;; #( *) : eval "$3=\$ac_type" ;; esac fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext if eval test \"x\$"$3"\" = x"no"; then : else break fi done 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_find_uintX_t 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 ecl $as_me 16.1.2, 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 as_fn_append ac_header_list " stdlib.h" as_fn_append ac_header_list " unistd.h" as_fn_append ac_header_list " sys/param.h" # 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 ac_aux_dir= for ac_dir in gmp "$srcdir"/gmp; 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 gmp \"$srcdir\"/gmp" "$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. if test -f configure; then as_fn_error $? "This program cannot be built within the source directory" "$LINENO" 5 fi # Check whether --with-cross_config was given. if test "${with_cross_config+set}" = set; then : withval=$with_cross_config; else with_cross_config="`pwd`/cross_config" fi # Check whether --enable-shared was given. if test "${enable_shared+set}" = set; then : enableval=$enable_shared; else enable_shared=yes fi # Check whether --enable-rpath was given. if test "${enable_rpath+set}" = set; then : enableval=$enable_rpath; else enable_rpath=yes fi # Check whether --enable-threads was given. if test "${enable_threads+set}" = set; then : enableval=$enable_threads; else enable_threads=auto fi # Check whether --enable-boehm was given. if test "${enable_boehm+set}" = set; then : enableval=$enable_boehm; else enable_boehm=auto fi # Check whether --enable-libatomic was given. if test "${enable_libatomic+set}" = set; then : enableval=$enable_libatomic; else enable_libatomic=auto fi # Check whether --enable-soname was given. if test "${enable_soname+set}" = set; then : enableval=$enable_soname; else enable_soname=yes fi # Check whether --with-gmp was given. if test "${with_gmp+set}" = set; then : withval=$with_gmp; else with_gmp="" fi # Check whether --with-C-gmp was given. if test "${with_C_gmp+set}" = set; then : withval=$with_C_gmp; with_c_gmp=yes; with_system_gmp=no else with_c_gmp=no fi # Check whether --with-system-gmp was given. if test "${with_system_gmp+set}" = set; then : withval=$with_system_gmp; else with_system_gmp="auto" fi # Check whether --with-gmp-prefix was given. if test "${with_gmp_prefix+set}" = set; then : withval=$with_gmp_prefix; GMP_INCDIR="$withval/include"; GMP_LIBDIR="$withval/lib" fi # Check whether --with-gmp-incdir was given. if test "${with_gmp_incdir+set}" = set; then : withval=$with_gmp_incdir; GMP_INCDIR="$withval" fi # Check whether --with-gmp-libdir was given. if test "${with_gmp_libdir+set}" = set; then : withval=$with_gmp_libdir; GMP_LIBDIR="$withval" fi # Check whether --enable-local-gmp was given. if test "${enable_local_gmp+set}" = set; then : enableval=$enable_local_gmp; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: --with-local-gmp is deprecated, use --with-system-gmp instead!" >&5 $as_echo "$as_me: WARNING: --with-local-gmp is deprecated, use --with-system-gmp instead!" >&2;} with_system_gmp="${enableval}" fi # Check whether --with-libffi-prefix was given. if test "${with_libffi_prefix+set}" = set; then : withval=$with_libffi_prefix; LIBFFI_INCDIR="$withval/include"; LIBFFI_LIBDIR="$withval/lib" fi # Check whether --with-__thread was given. if test "${with___thread+set}" = set; then : withval=$with___thread; else with___thread=no fi # Check whether --enable-opcode8 was given. if test "${enable_opcode8+set}" = set; then : enableval=$enable_opcode8; opcode8=${enableval} else opcode8=no fi # Check whether --with-cxx was given. if test "${with_cxx+set}" = set; then : withval=$with_cxx; else with_cxx=no fi # Check whether --with-tcp was given. if test "${with_tcp+set}" = set; then : withval=$with_tcp; else with_tcp=yes fi # Check whether --with-serve_event was given. if test "${with_serve_event+set}" = set; then : withval=$with_serve_event; else with_serve_event=${enable_shared} fi # Check whether --with-clx was given. if test "${with_clx+set}" = set; then : withval=$with_clx; else with_clx=no fi # Check whether --with-clos-streams was given. if test "${with_clos_streams+set}" = set; then : withval=$with_clos_streams; else with_clos_streams=yes fi # Check whether --with-cmuformat was given. if test "${with_cmuformat+set}" = set; then : withval=$with_cmuformat; else with_cmuformat=${with_clos_streams} fi # Check whether --with-asdf was given. if test "${with_asdf+set}" = set; then : withval=$with_asdf; else with_asdf=yes fi # Check whether --with-defsystem was given. if test "${with_defsystem+set}" = set; then : withval=$with_defsystem; else with_defsystem=yes fi # Check whether --with-cmp was given. if test "${with_cmp+set}" = set; then : withval=$with_cmp; else with_cmp=yes fi # Check whether --with-bytecmp was given. if test "${with_bytecmp+set}" = set; then : withval=$with_bytecmp; else with_bytecmp=yes fi # Check whether --with-rt was given. if test "${with_rt+set}" = set; then : withval=$with_rt; else with_rt=yes fi # Check whether --with-profile was given. if test "${with_profile+set}" = set; then : withval=$with_profile; else with_profile=yes fi # Check whether --with-dffi was given. if test "${with_dffi+set}" = set; then : withval=$with_dffi; enable_libffi=${withval} else enable_libffi=auto fi # Check whether --with-fpe was given. if test "${with_fpe+set}" = set; then : withval=$with_fpe; else with_fpe=yes fi # Check whether --with-signed-zero was given. if test "${with_signed_zero+set}" = set; then : withval=$with_signed_zero; else with_signed_zero="yes" fi # Check whether --with-ieee-fp was given. if test "${with_ieee_fp+set}" = set; then : withval=$with_ieee_fp; else with_ieee_fp="yes" fi # Check whether --with-sse was given. if test "${with_sse+set}" = set; then : withval=$with_sse; else with_sse="no" fi # Check whether --enable-unicode was given. if test "${enable_unicode+set}" = set; then : enableval=$enable_unicode; else enable_unicode=yes fi # Check whether --enable-longdouble was given. if test "${enable_longdouble+set}" = set; then : enableval=$enable_longdouble; enable_longdouble=${enableval} else enable_longdouble=yes fi # Check whether --enable-c99complex was given. if test "${enable_c99complex+set}" = set; then : enableval=$enable_c99complex; enable_c99complex=${enableval} else enable_c99complex=no fi # Check whether --enable-hpack was given. if test "${enable_hpack+set}" = set; then : enableval=$enable_hpack; enable_hpack=${enableval} else enable_hpack=yes fi # Check whether --enable-asmapply was given. if test "${enable_asmapply+set}" = set; then : enableval=$enable_asmapply; enable_asmapply=${enableval} else enable_asmapply=no fi # Check whether --enable-smallcons was given. if test "${enable_smallcons+set}" = set; then : enableval=$enable_smallcons; enable_smallcons=${enableval} else enable_smallcons=yes fi # Check whether --enable-gengc was given. if test "${enable_gengc+set}" = set; then : enableval=$enable_gengc; enable_gengc=${enableval} else enable_gengc=no fi # Check whether --enable-precisegc was given. if test "${enable_precisegc+set}" = set; then : enableval=$enable_precisegc; enable_precisegc=${enableval} else enable_precisegc=no fi # Check whether --enable-debug was given. if test "${enable_debug+set}" = set; then : enableval=$enable_debug; DEBUG_CFLAGS="-g -O0"; CFLAGS="$CFLAGS -g -O0" fi # Check whether --with-debug-cflags was given. if test "${with_debug_cflags+set}" = set; then : withval=$with_debug_cflags; else with_debug_cflags="no" fi # Check whether --with-profile-cflags was given. if test "${with_profile_cflags+set}" = set; then : withval=$with_profile_cflags; else with_profile_cflags="no" fi # Check whether --with-newcmp was given. if test "${with_newcmp+set}" = set; then : withval=$with_newcmp; else with_newcmp=no fi # Check whether --with-extra-files was given. if test "${with_extra_files+set}" = set; then : withval=$with_extra_files; with_extra_files="${withval}" else with_extra_files="" fi # Check whether --with-init-form was given. if test "${with_init_form+set}" = set; then : withval=$with_init_form; with_init_form="${withval}" else with_init_form="" fi # Check whether --with-unicode-names was given. if test "${with_unicode_names+set}" = set; then : withval=$with_unicode_names; else with_unicode_names="yes" fi test -z "${ecldir}" && ecldir="${libdir}/ecl-${PACKAGE_VERSION}" test -z "${docdir}" && docdir="${datadir}/doc/ecl-${PACKAGE_VERSION}" boehm_configure_flags="" TARGETS='bin/ecl$(EXE)' SUBDIRS=c LSP_FEATURES='*features*' # 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 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 # sets variable CC 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 # sets variable CXX 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 # sets variable CPP 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 # sets variable RANLIB # 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' # sets variables INSTALL, INSTALL_DATA, INSTALL_PROGRAM { $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 # sets variable LN_S { $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 # set $(MAKE) if needed 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 # set variable RANLIB if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}ar", so it can be a program name with args. set dummy ${ac_tool_prefix}ar; 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}ar" $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 fi if test -z "$ac_cv_prog_AR"; then ac_ct_AR=$AR # Extract the first word of "ar", so it can be a program name with args. set dummy ar; 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="ar" $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 if test "x$ac_ct_AR" = x; then AR="" 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 else AR="$ac_cv_prog_AR" fi # set variable AR to appropriate `ar' program for ac_prog in etags emacs-etags 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_ETAGS+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$ETAGS"; then ac_cv_prog_ETAGS="$ETAGS" # 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_ETAGS="$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 ETAGS=$ac_cv_prog_ETAGS if test -n "$ETAGS"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ETAGS" >&5 $as_echo "$ETAGS" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi test -n "$ETAGS" && break done # set variable ETAGS to etags program if found PWDCMD="pwd"; case "${srcdir}" in /* | ?:/* ) ;; * ) srcdir="`(cd ${srcdir}; ${PWDCMD})`"; esac if uname -a | grep -i 'mingw32' > /dev/null; then true_srcdir=`(cd ${srcdir}; pwd -W)` true_builddir=`pwd -W` else true_srcdir=`(cd ${srcdir}; pwd)` true_builddir=`pwd` fi if test "x${cross_compiling}" = "xyes"; then if test -n "${with_cross_config}" -a -f "${with_cross_config}"; then . ${with_cross_config} elif test -f ./cross_config; then . ./cross_config elif test -n "${srcdir}" -a -f ${srcdir}/cross_config; then . ${srcdir}/cross_config else test -z ${with_cross_config} && cross_config=`pwd`/cross_config cat > ${with_cross_config} <_IO_read_end - (f)->_IO_read_ptr ### 2 = (f)->_r ### 3 = (f)->_cnt ECL_FILE_CNT=0 ### ### 1.6) Other integer types (set to 'no' to disable) ### ECL_STDINT_HEADER="#include " ECL_UINT8_T=uint8_t ECL_UINT16_T=uint16_t ECL_UINT32_T=uint32_t ECL_UINT64_T=no ECL_INT8_T=int8_t ECL_INT16_T=int16_t ECL_INT32_T=int32_t ECL_INT64_T=no ECL_LONG_LONG_BITS=no ### ### 1.7) Other features (set to 'no' to disable) ### ECL_WORKING_ENVIRON=yes ### 2) To cross-compile ECL so that it runs on the system ### ${host} ### you need to first compile ECL on the system in which you are building ### the cross-compiled files, that is ### ${build} ### By default we assume that ECL can be accessed from some directory in ### the path. ECL_TO_RUN=`which ecl` EOF cat ${with_cross_config} as_fn_error $? "Configuration aborted" "$LINENO" 5 fi if test "${ECL_TO_RUN}" = "failed"; then as_fn_error $? "The program ECL is not installed in your system" "$LINENO" 5 fi ECL_MIN_TO_RUN=`${ECL_TO_RUN} -norc -eval '(progn (print (truename "sys:ecl_min")) (si:quit))' \ | grep '\#\P' | sed 's,#P"\(.*\)",\1,'` if test -z "${ECL_MIN_TO_RUN}" -o "${ECL_MIN_TO_RUN}" = "failed" ; then as_fn_error $? "The program ECL-MIN is not installed in your system" "$LINENO" 5 fi DPP_TO_RUN=`${ECL_TO_RUN} -norc -eval '(progn (print (truename "sys:dpp")) (si:quit))' \ | grep '\#\P' | sed 's,#P"\(.*\)",\1,'` if test -z "${DPP_TO_RUN}" -o "${DPP_TO_RUN}" = "failed" ; then as_fn_error $? "The program DPP is not installed in your system" "$LINENO" 5 fi (echo '#!/bin/sh'; echo exec ${ECL_MIN_TO_RUN} '$''*') > CROSS-COMPILER (echo '#!/bin/sh'; echo exec ${DPP_TO_RUN} '$''*') > CROSS-DPP chmod +x CROSS-COMPILER CROSS-DPP LSP_FEATURES="(cons :cross ${LSP_FEATURES})" fi #### Some command variations: RM="rm -f" CP="cp" MV="mv" ### Guess the operating system ECL_GC_DIR=bdwgc ECL_LDRPATH='' SHAREDEXT='so' SHAREDPREFIX='lib' LIBPREFIX='lib' LIBEXT='a' PICFLAG='-fPIC' THREAD_CFLAGS='' THREAD_LIBS='' THREAD_GC_FLAGS='--enable-threads=posix' INSTALL_TARGET='install' THREAD_OBJ="$THREAD_OBJ threads/process threads/queue threads/mutex threads/condition_variable threads/semaphore threads/barrier threads/mailbox" clibs='' SONAME='' SONAME_LDFLAGS='' case "${host_os}" in linux-androideabi) thehost='android' THREAD_CFLAGS='-D_THREAD_SAFE' # THREAD_LIBS='-lpthread' SHARED_LDFLAGS="-shared ${LDFLAGS}" BUNDLE_LDFLAGS="-shared ${LDFLAGS}" ECL_LDRPATH='-Wl,--rpath,~A' clibs="-ldl" # Maybe CFLAGS="-D_ISOC99_SOURCE ${CFLAGS}" ??? CFLAGS="-D_GNU_SOURCE -D_FILE_OFFSET_BITS=64 -DANDROID -DPLATFORM_ANDROID -DUSE_GET_STACKBASE_FOR_MAIN -DIGNORE_DYNAMIC_LOADING -DAO_REQUIRE_CAS ${CFLAGS}" SONAME="${SHAREDPREFIX}ecl.${SHAREDEXT}.SOVERSION" SONAME_LDFLAGS="-Wl,-soname,SONAME" LSP_FEATURES="(cons :android ${LSP_FEATURES})" ;; # libdir may have a dollar expression inside linux*) thehost='linux' THREAD_CFLAGS='-D_THREAD_SAFE' THREAD_LIBS='-lpthread' SHARED_LDFLAGS="-shared ${LDFLAGS}" BUNDLE_LDFLAGS="-shared ${LDFLAGS}" ECL_LDRPATH='-Wl,--rpath,~A' clibs="-ldl" # Maybe CFLAGS="-D_ISOC99_SOURCE ${CFLAGS}" ??? CFLAGS="-D_GNU_SOURCE -D_FILE_OFFSET_BITS=64 ${CFLAGS}" SONAME="${SHAREDPREFIX}ecl.${SHAREDEXT}.SOVERSION" SONAME_LDFLAGS="-Wl,-soname,SONAME" ;; gnu*) thehost='gnu' THREAD_CFLAGS='-D_THREAD_SAFE' THREAD_LIBS='-lpthread' SHARED_LDFLAGS="-shared ${LDFLAGS}" BUNDLE_LDFLAGS="-shared ${LDFLAGS}" ECL_LDRPATH='-Wl,--rpath,~A' clibs="-ldl" CFLAGS="-D_GNU_SOURCE ${CFLAGS}" SONAME="${SHAREDPREFIX}ecl.${SHAREDEXT}.SOVERSION" SONAME_LDFLAGS="-Wl,-soname,SONAME" ;; kfreebsd*-gnu) thehost='kfreebsd' THREAD_CFLAGS='-D_THREAD_SAFE' THREAD_LIBS='-lpthread' SHARED_LDFLAGS="-shared ${LDFLAGS}" BUNDLE_LDFLAGS="-shared ${LDFLAGS}" ECL_LDRPATH='-Wl,--rpath,~A' clibs="-ldl" CFLAGS="-D_GNU_SOURCE ${CFLAGS}" SONAME="${SHAREDPREFIX}ecl.${SHAREDEXT}.SOVERSION" SONAME_LDFLAGS="-Wl,-soname,SONAME" ;; dragonfly*) thehost='dragonfly' THREAD_LIBS='-lpthread' SHARED_LDFLAGS="-shared ${LDFLAGS}" BUNDLE_LDFLAGS="-shared ${LDFLAGS}" ECL_LDRPATH="-Wl,--rpath,~A" clibs="" SONAME="${SHAREDPREFIX}ecl.${SHAREDEXT}.SOVERSION" SONAME_LDFLAGS="-Wl,-soname,SONAME" ;; freebsd*) thehost='freebsd' THREAD_LIBS='-lpthread' SHARED_LDFLAGS="-shared ${LDFLAGS}" BUNDLE_LDFLAGS="-shared ${LDFLAGS}" ECL_LDRPATH="-Wl,--rpath,~A" clibs="" SONAME="${SHAREDPREFIX}ecl.${SHAREDEXT}.SOVERSION" SONAME_LDFLAGS="-Wl,-soname,SONAME" ;; netbsd*) thehost='netbsd' THREAD_LIBS='-lpthread' SHARED_LDFLAGS="-shared ${LDFLAGS}" BUNDLE_LDFLAGS="-shared ${LDFLAGS}" ECL_LDRPATH="-Wl,--rpath,~A" clibs="" SONAME="${SHAREDPREFIX}ecl.${SHAREDEXT}.SOVERSION" SONAME_LDFLAGS="-Wl,-soname,SONAME" ;; openbsd*) thehost='openbsd' THREAD_CFLAGS='' THREAD_LIBS='' SHARED_LDFLAGS="-shared ${LDFLAGS}" BUNDLE_LDFLAGS="-shared ${LDFLAGS}" ECL_LDRPATH="-Wl,--rpath,~A" clibs="-lpthread -lm" SONAME="${SHAREDPREFIX}ecl.${SHAREDEXT}.SOVERSION" SONAME_LDFLAGS="-Wl,-soname,SONAME" ;; solaris*) thehost='sun4sol2' THREAD_LIBS='-lrt -lpthread' SHARED_LDFLAGS="-dy -G ${LDFLAGS}" BUNDLE_LDFLAGS="-dy -G ${LDFLAGS}" ECL_LDRPATH='-Wl,-R,~A' TCPLIBS='-lsocket -lnsl -lintl' clibs='-ldl' SONAME="${SHAREDPREFIX}ecl.${SHAREDEXT}.SOVERSION" SONAME_LDFLAGS="-Wl,-soname,SONAME" if test "x$GCC" = "xyes"; then CFLAGS="${CFLAGS} -std=gnu99 -D_XOPEN_SOURCE=600 -D__EXTENSIONS__" SHARED_LDFLAGS="-shared $SHARED_LDFLAGS" BUNDLE_LDFLAGS="-shared $BUNDLE_LDFLAGS" fi ;; cygwin*) enable_threads='no' thehost='cygwin' shared='yes' THREAD_CFLAGS='-D_THREAD_SAFE' THREAD_LIBS='-lpthread' SHARED_LDFLAGS="-shared ${LDFLAGS}" BUNDLE_LDFLAGS="-shared ${LDFLAGS}" SHAREDPREFIX='' SHAREDEXT='dll' PICFLAG='' if test "x$host_cpu" = "xx86_64" ; then # Our GMP library is too old and does not support # Windows64 calling conventions. with_c_gmp=yes fi ;; mingw*) thehost='mingw32' clibs='' shared='yes' enable_threads='yes' THREAD_CFLAGS='-D_THREAD_SAFE' THREAD_GC_FLAGS='--enable-threads=win32' SHARED_LDFLAGS='' BUNDLE_LDFLAGS='' SHAREDPREFIX='' SHAREDEXT='dll' PICFLAG='' INSTALL_TARGET='flatinstall' TCPLIBS='-lws2_32' ;; darwin*) thehost='darwin' shared='yes' SHAREDEXT='dylib' PICFLAG='-fPIC -fno-common' SHARED_LDFLAGS="-dynamiclib -flat_namespace -undefined suppress ${LDFLAGS}" BUNDLE_LDFLAGS="-bundle ${LDFLAGS}" ECL_LDRPATH='' THREAD_CFLAGS='-D_THREAD_SAFE' THREAD_LIBS='-lpthread' # The GMP library has not yet been ported to Intel-OSX case "`uname -m`" in i386*|x86_64) gmp_build=none-apple-${host_os};; *) ABI=32;; esac if test "x$ABI" = "x64"; then if echo "$CFLAGS" | grep -v ' *-m64' >/dev/null ; then CFLAGS="-m64 $CFLAGS" LDFLAGS="-m64 $LDFLAGS" fi # Needed when building the old version of GMP. # Should be removed when moving to MPIR ABI="long" fi if test "x$ABI" = "x32"; then ABI="long" fi # The Boehm-Weiser GC library shipped with Fink does not work # well with our signal handler. # enable_boehm=included if test `uname -r | cut -d '.' -f 1` -ge 11; then ECL_GC_DIR=bdwgc fi SONAME="${SHAREDPREFIX}ecl.SOVERSION.${SHAREDEXT}" SONAME_LDFLAGS="-Wl,-install_name,@libdir\@/SONAME -Wl,-compatibility_version,${PACKAGE_VERSION}" ;; nsk*) # HP Non-Stop platform thehost='nonstop' shared='yes' PICFLAG='-call_shared' THREAD_CFLAGS='-spthread' SHARED_LDFLAGS="-shared ${LDFLAGS}" BUNDLE_LDFLAGS="-shared ${LDFLAGS}" ECL_LDRPATH='-Wld=\"-rld_l ~A\"' clibs="-Wld=-lrld" ;; *) thehost="$host_os" shared="no" ;; esac case "${host}" in *-nacl) thehost='linux' THREAD_CFLAGS='-D_THREAD_SAFE' THREAD_LIBS='-lpthread' SHARED_LDFLAGS="-shared ${LDFLAGS}" BUNDLE_LDFLAGS="-shared ${LDFLAGS}" ECL_LDRPATH='-Wl,--rpath,~A' CFLAGS="-D_GNU_SOURCE -D_FILE_OFFSET_BITS=64 ${CFLAGS}" SONAME="${SHAREDPREFIX}ecl.${SHAREDEXT}.SOVERSION" SONAME_LDFLAGS="-Wl,-soname,SONAME" LSP_FEATURES="(cons :nacl ${LSP_FEATURES})" ;; *-pnacl) thehost='linux' THREAD_CFLAGS='-D_THREAD_SAFE' THREAD_LIBS='-lpthread' CFLAGS="-D_GNU_SOURCE -D_FILE_OFFSET_BITS=64 ${CFLAGS}" LSP_FEATURES="(cons :nacl ${LSP_FEATURES})" LSP_FEATURES="(cons :pnacl ${LSP_FEATURES})" ;; i686*-android*) THREAD_LIBS='' CFLAGS="-D_GNU_SOURCE -D_FILE_OFFSET_BITS=64 -DANDROID -DPLATFORM_ANDROID -DUSE_GET_STACKBASE_FOR_MAIN -DIGNORE_DYNAMIC_LOADING -DNO_GETCONTEXT -DHAVE_GETTIMEOFDAY -DHAVE_SIGPROCMASK ${CFLAGS}" LSP_FEATURES="(cons :android ${LSP_FEATURES})" ;; esac case "${host_cpu}" in alpha*) CFLAGS="${CFLAGS} -mieee";; esac ECL_CFLAGS="-D${thehost}" { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ld flags when building shared libraries" >&5 $as_echo_n "checking for ld flags when building shared libraries... " >&6; } if test "${enable_shared}" = "yes"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: ${SHARED_LDFLAGS}" >&5 $as_echo "${SHARED_LDFLAGS}" >&6; } CFLAGS="${CFLAGS} ${PICFLAG}" else shared="no"; { $as_echo "$as_me:${as_lineno-$LINENO}: result: cannot build" >&5 $as_echo "cannot build" >&6; } fi LIBS="${clibs} ${LIBS}" { $as_echo "$as_me:${as_lineno-$LINENO}: checking for required libraries" >&5 $as_echo_n "checking for required libraries... " >&6; } { $as_echo "$as_me:${as_lineno-$LINENO}: result: ${clibs}" >&5 $as_echo "${clibs}" >&6; } { $as_echo "$as_me:${as_lineno-$LINENO}: checking for architecture" >&5 $as_echo_n "checking for architecture... " >&6; } ARCHITECTURE=`echo "${host_cpu}" | tr a-z A-Z` # i386 -> I386 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ${ARCHITECTURE}" >&5 $as_echo "${ARCHITECTURE}" >&6; } { $as_echo "$as_me:${as_lineno-$LINENO}: checking for software type" >&5 $as_echo_n "checking for software type... " >&6; } SOFTWARE_TYPE="$thehost" SOFTWARE_VERSION="" { $as_echo "$as_me:${as_lineno-$LINENO}: result: ${SOFTWARE_TYPE} / ${SOFTWARE_VERSION}" >&5 $as_echo "${SOFTWARE_TYPE} / ${SOFTWARE_VERSION}" >&6; } { $as_echo "$as_me:${as_lineno-$LINENO}: checking for __thread local data" >&5 $as_echo_n "checking for __thread local data... " >&6; } if ${ac_cv_ecl___thread+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { static __thread void *data; ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_cv_ecl___thread=yes else ac_cv_ecl___thread=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_ecl___thread" >&5 $as_echo "$ac_cv_ecl___thread" >&6; } # Extract the first word of "install-info", so it can be a program name with args. set dummy install-info; 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_path_INSTALL_INFO+:} false; then : $as_echo_n "(cached) " >&6 else case $INSTALL_INFO in [\\/]* | ?:[\\/]*) ac_cv_path_INSTALL_INFO="$INSTALL_INFO" # Let the user override the test with a path. ;; *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR as_dummy="$PATH:/sbin:/usr/sbin:/usr/etc" for as_dir in $as_dummy 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_path_INSTALL_INFO="$as_dir/$ac_word$ac_exec_ext" $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 test -z "$ac_cv_path_INSTALL_INFO" && ac_cv_path_INSTALL_INFO="/bin/true" ;; esac fi INSTALL_INFO=$ac_cv_path_INSTALL_INFO if test -n "$INSTALL_INFO"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $INSTALL_INFO" >&5 $as_echo "$INSTALL_INFO" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi if test -z `which gzip`; then INFOEXT=info.gz else INFOEXT=info fi if test "x$GMP_INCDIR" != "x"; then GMP_CPPFLAGS="-I$GMP_INCDIR" fi if test "x$GMP_LIBDIR" != "x"; then GMP_LDFLAGS="-L$GMP_LIBDIR" if test "$enable_rpath" = "yes"; then if (echo "$ECL_LDRPATH" | grep '~A') > /dev/null; then GMP_LDFLAGS=`echo $ECL_LDRPATH | sed "s,~A,$GMP_LIBDIR,"`" $GMP_LDFLAGS" fi fi fi CPPFLAGS="$CPPFLAGS $GMP_CPPFLAGS" LDFLAGS="$LDFLAGS $GMP_LDFLAGS" if test ${with_system_gmp} = "auto"; then { $as_echo "$as_me:${as_lineno-$LINENO}: checking for __gmpz_init in -lgmp" >&5 $as_echo_n "checking for __gmpz_init in -lgmp... " >&6; } if ${ac_cv_lib_gmp___gmpz_init+:} false; then : $as_echo_n "(cached) " >&6 else ac_check_lib_save_LIBS=$LIBS LIBS="-lgmp $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 __gmpz_init (); int main () { return __gmpz_init (); ; return 0; } _ACEOF if ac_fn_c_try_link "$LINENO"; then : ac_cv_lib_gmp___gmpz_init=yes else ac_cv_lib_gmp___gmpz_init=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_gmp___gmpz_init" >&5 $as_echo "$ac_cv_lib_gmp___gmpz_init" >&6; } if test "x$ac_cv_lib_gmp___gmpz_init" = xyes; then : with_system_gmp=yes else with_system_gmp=no fi fi ECL_GMP_HEADER= if test "${with_system_gmp}" = "yes"; then { $as_echo "$as_me:${as_lineno-$LINENO}: checking for __gmpz_init in -lgmp" >&5 $as_echo_n "checking for __gmpz_init in -lgmp... " >&6; } if ${ac_cv_lib_gmp___gmpz_init+:} false; then : $as_echo_n "(cached) " >&6 else ac_check_lib_save_LIBS=$LIBS LIBS="-lgmp $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 __gmpz_init (); int main () { return __gmpz_init (); ; return 0; } _ACEOF if ac_fn_c_try_link "$LINENO"; then : ac_cv_lib_gmp___gmpz_init=yes else ac_cv_lib_gmp___gmpz_init=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_gmp___gmpz_init" >&5 $as_echo "$ac_cv_lib_gmp___gmpz_init" >&6; } if test "x$ac_cv_lib_gmp___gmpz_init" = xyes; then : FASL_LIBS="${FASL_LIBS} -lgmp" else as_fn_error $? "System gmp library requested but not found." "$LINENO" 5 fi { $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 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 ac_fn_c_check_header_mongrel "$LINENO" "gmp.h" "ac_cv_header_gmp_h" "$ac_includes_default" if test "x$ac_cv_header_gmp_h" = xyes; then : ECL_GMP_HEADER='gmp.h' fi if test "x$ECL_GMP_HEADER" = "x"; then ac_fn_c_check_header_mongrel "$LINENO" "gmp/gmp.h" "ac_cv_header_gmp_gmp_h" "$ac_includes_default" if test "x$ac_cv_header_gmp_gmp_h" = xyes; then : ECL_GMP_HEADER='gmp/gmp.h' fi fi else SUBDIRS="${SUBDIRS} gmp" CORE_LIBS="-leclgmp ${CORE_LIBS}" if test ${enable_shared} = "no"; then LIBRARIES="${LIBRARIES} ${LIBPREFIX}eclgmp.${LIBEXT}" fi fi EXTRA_OBJS="${EXTRA_OBJS} big.o" if test "x${with_system_gmp}" = "xno" ; then { $as_echo "$as_me:${as_lineno-$LINENO}: Configuring included GMP library:" >&5 $as_echo "$as_me: Configuring included GMP library:" >&6;} test -d gmp && rm -rf gmp if test -z "$gmp_build"; then gmp_build="${build}" fi if test "x$with_c_gmp" = "xyes"; then gmp_build=`echo ${gmp_build} | sed 's,[^-]*\(-.*\),none\1,'` echo '***' echo '***' BUILDING GMP WITH C! echo '***' This is a last resort, either because of license or echo '***' porting issues. echo '***' fi ECL_GMP_HEADER='ecl/gmp.h' if test "x$ABI" = "x"; then GMP_ABI="" else GMP_ABI="ABI=$ABI" fi mkdir gmp (destdir=`${PWDCMD}`; cd gmp && CC="${CC} ${PICFLAG}" \ NM=nm $srcdir/gmp/configure --disable-shared --prefix=${destdir} \ -infodir=${destdir}/doc --includedir=${destdir}/ecl --with-pic \ --libdir=${destdir} --build=${gmp_build} --host=${host_alias} \ CFLAGS="$CFLAGS" LDFLAGS="$LDFLAGS" CPPFLAGS="$CPPFLAGS" CC="${CC} ${PICFLAG}" \ "$GMP_ABI" $with_gmp) if test ! -f gmp/config.status; then as_fn_error $? "Failed to configure the GMP library." "$LINENO" 5 fi else if test "x$ECL_GMP_HEADER" = "x"; then as_fn_error $? "Can not find GMP header." "$LINENO" 5 fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking GMP autoconf" >&5 $as_echo_n "checking GMP autoconf... " >&6; } { $as_echo "$as_me:${as_lineno-$LINENO}: result: \"${with_system_gmp}.${enable_slow_config}\"" >&5 $as_echo "\"${with_system_gmp}.${enable_slow_config}\"" >&6; } if test "x${enable_slow_config}" = "xyes"; then with_system_gmp=no fi if test "x${with_system_gmp}" = "xno"; then { $as_echo "$as_me:${as_lineno-$LINENO}: checking Using the GMP library to guess good compiler/linker flags" >&5 $as_echo_n "checking Using the GMP library to guess good compiler/linker flags... " >&6; } if test ! -f gmp/config.status; then as_fn_error $? "Cannot find GMP's configuration file. Aborting" "$LINENO" 5 fi GMP_CFLAGS=`grep '^s,@CFLAGS@' gmp/config.status| sed 's&s,@CFLAGS@,\(.*\),;t t&\1&'` GMP_LDFLAGS=`grep '^s,@GMP_LDFLAGS@' gmp/config.status| sed 's&s,@GMP_LDFLAGS@,\(.*\),;t t&\1&'`; # Notice that GMP_LDFLAGS is designed to be passed to libtool, and therefore # some options could be prefixed by -Wc, which means "flag for the compiler". LDFLAGS=`echo ${LDFLAGS} ${GMP_LDFLAGS} | sed 's%-Wc,%%g'` CFLAGS=`echo ${CFLAGS} ${GMP_CFLAGS} | sed 's%-Wc,%%g'` GMP_CFLAGS="" GMP_LDFLAGS="" #host=`grep '^s,@host@' config.status | sed 's&s,@host@,\(.*\),;t t&\1&'` { $as_echo "$as_me:${as_lineno-$LINENO}: checking C/C++ compiler flags" >&5 $as_echo_n "checking C/C++ compiler flags... " >&6; } { $as_echo "$as_me:${as_lineno-$LINENO}: result: ${CFLAGS}" >&5 $as_echo "${CFLAGS}" >&6; } { $as_echo "$as_me:${as_lineno-$LINENO}: checking Linker flags" >&5 $as_echo_n "checking Linker flags... " >&6; } { $as_echo "$as_me:${as_lineno-$LINENO}: result: ${LDFLAGS}" >&5 $as_echo "${LDFLAGS}" >&6; } fi if test "x$LIBFFI_INCDIR" != "x"; then LIBFFI_CPPFLAGS="-I$LIBFFI_INCDIR" fi if test "x$LIBFFI_LIBDIR" != "x"; then LIBFFI_LDFLAGS="-L$LIBFFI_LIBDIR" if test "$enable_rpath" = "yes"; then if (echo "$ECL_LDRPATH" | grep '~A') > /dev/null; then LIBFFI_LDFLAGS=`echo $ECL_LDRPATH | sed "s,~A,$LIBFFI_LIBDIR,"`" $LIBFFI_LDFLAGS" fi fi fi CPPFLAGS="$CPPFLAGS $LIBFFI_CPPFLAGS" LDFLAGS="$LDFLAGS $LIBFFI_LDFLAGS" LIBS="${LIBS} -lm" { $as_echo "$as_me:${as_lineno-$LINENO}: checking for getpwnam in -lsun" >&5 $as_echo_n "checking for getpwnam in -lsun... " >&6; } if ${ac_cv_lib_sun_getpwnam+:} false; then : $as_echo_n "(cached) " >&6 else ac_check_lib_save_LIBS=$LIBS LIBS="-lsun $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 getpwnam (); int main () { return getpwnam (); ; return 0; } _ACEOF if ac_fn_c_try_link "$LINENO"; then : ac_cv_lib_sun_getpwnam=yes else ac_cv_lib_sun_getpwnam=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_sun_getpwnam" >&5 $as_echo "$ac_cv_lib_sun_getpwnam" >&6; } if test "x$ac_cv_lib_sun_getpwnam" = xyes; then : cat >>confdefs.h <<_ACEOF #define HAVE_LIBSUN 1 _ACEOF LIBS="-lsun $LIBS" fi # on IRIX adds -lsun { $as_echo "$as_me:${as_lineno-$LINENO}: checking for library containing strerror" >&5 $as_echo_n "checking for library containing strerror... " >&6; } if ${ac_cv_search_strerror+:} 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 strerror (); int main () { return strerror (); ; return 0; } _ACEOF for ac_lib in '' cposix; 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_strerror=$ac_res fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext if ${ac_cv_search_strerror+:} false; then : break fi done if ${ac_cv_search_strerror+:} false; then : else ac_cv_search_strerror=no fi rm conftest.$ac_ext LIBS=$ac_func_search_save_LIBS fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_strerror" >&5 $as_echo "$ac_cv_search_strerror" >&6; } ac_res=$ac_cv_search_strerror if test "$ac_res" != no; then : test "$ac_res" = "none required" || LIBS="$ac_res $LIBS" fi if test "$with_debug_cflags" = "yes"; then with_debug_cflags="-g" fi if test "$with_debug_cflags" != "no"; then DEBUG_CFLAGS="$with_debug_cflags" CFLAGS="$with_debug_cflags $CFLAGS" CXXFLAGS="$with_debug_cflags $CXXFLAGS" LDFLAGS="$with_debug_cflags $LDFLAGS" fi if test "$with_profile_cflags" = "yes"; then with_profile_cflags="-pg" fi if test "$with_profile_cflags" != "no"; then CFLAGS="$with_profile_cflags $CFLAGS" CXXFLAGS="$with_profile_cflags $CFLAGS" LDFLAGS="$with_profile_cflags $LDFLAGS" fi if test "${with_newcmp}" = "yes"; then ECL_CMPDIR=new-cmp else ECL_CMPDIR=cmp fi if test "${enable_threads}" = "auto"; then { $as_echo "$as_me:${as_lineno-$LINENO}: checking for threads support" >&5 $as_echo_n "checking for threads support... " >&6; } if test -z "${THREAD_OBJ}"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } enable_threads="no" else { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 $as_echo "yes" >&6; } enable_threads="yes" fi fi if test "${enable_threads}" = "yes" ; then if test -z "${THREAD_OBJ}"; then as_fn_error $? "Threads aren't supported on this system." "$LINENO" 5 else LIBS="${THREAD_LIBS} ${LIBS}" CFLAGS="${CFLAGS} ${THREAD_CFLAGS}" ac_fn_c_check_func "$LINENO" "pthread_rwlock_init" "ac_cv_func_pthread_rwlock_init" if test "x$ac_cv_func_pthread_rwlock_init" = xyes; then : $as_echo "#define ECL_RWLOCK /**/" >>confdefs.h $as_echo "#define HAVE_POSIX_RWLOCK /**/" >>confdefs.h fi THREAD_OBJ="$THREAD_OBJ threads/rwlock" boehm_configure_flags="${boehm_configure_flags} ${THREAD_GC_FLAGS}" for k in $THREAD_OBJ; do EXTRA_OBJS="$EXTRA_OBJS ${k}.${OBJEXT}"; done { $as_echo "$as_me:${as_lineno-$LINENO}: checking for thread object files" >&5 $as_echo_n "checking for thread object files... " >&6; } { $as_echo "$as_me:${as_lineno-$LINENO}: result: ${THREAD_OBJ}" >&5 $as_echo "${THREAD_OBJ}" >&6; } $as_echo "#define ECL_THREADS 1" >>confdefs.h if test "${with___thread}" = "auto"; then with___thread=${ac_cv_ecl___thread} fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking for use of __thread" >&5 $as_echo_n "checking for use of __thread... " >&6; } if test "${with___thread}" = "yes"; then $as_echo "#define WITH___THREAD 1" >>confdefs.h { $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 fi else boehm_configure_flags="${boehm_configure_flags} --disable-threads" fi if test ${enable_boehm} = "no" ; then as_fn_error $? "Boehm GC library is currently needed to build ECL" "$LINENO" 5; EXTRA_OBJS="${EXTRA_OBJS} alloc.${OBJEXT} gbc.${OBJEXT}" enable_smallcons="no" else case "${enable_boehm}" in yes) enable_boehm=auto;; auto|system|included) ;; *) as_fn_error $? "Invalid value of --enable-boehm: ${enable_boehm} " "$LINENO" 5;; esac if test "${enable_boehm}" = auto -o "${enable_boehm}" = system; then system_boehm=yes if test "${enable_threads}" = no; then { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GC_malloc in -lgc" >&5 $as_echo_n "checking for GC_malloc in -lgc... " >&6; } if ${ac_cv_lib_gc_GC_malloc+:} false; then : $as_echo_n "(cached) " >&6 else ac_check_lib_save_LIBS=$LIBS LIBS="-lgc $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 GC_malloc (); int main () { return GC_malloc (); ; return 0; } _ACEOF if ac_fn_c_try_link "$LINENO"; then : ac_cv_lib_gc_GC_malloc=yes else ac_cv_lib_gc_GC_malloc=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_gc_GC_malloc" >&5 $as_echo "$ac_cv_lib_gc_GC_malloc" >&6; } if test "x$ac_cv_lib_gc_GC_malloc" = xyes; then : cat >>confdefs.h <<_ACEOF #define HAVE_LIBGC 1 _ACEOF LIBS="-lgc $LIBS" else system_boehm="no" fi else { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GC_get_thr_restart_signal in -lgc" >&5 $as_echo_n "checking for GC_get_thr_restart_signal in -lgc... " >&6; } if ${ac_cv_lib_gc_GC_get_thr_restart_signal+:} false; then : $as_echo_n "(cached) " >&6 else ac_check_lib_save_LIBS=$LIBS LIBS="-lgc $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 GC_get_thr_restart_signal (); int main () { return GC_get_thr_restart_signal (); ; return 0; } _ACEOF if ac_fn_c_try_link "$LINENO"; then : ac_cv_lib_gc_GC_get_thr_restart_signal=yes else ac_cv_lib_gc_GC_get_thr_restart_signal=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_gc_GC_get_thr_restart_signal" >&5 $as_echo "$ac_cv_lib_gc_GC_get_thr_restart_signal" >&6; } if test "x$ac_cv_lib_gc_GC_get_thr_restart_signal" = xyes; then : cat >>confdefs.h <<_ACEOF #define HAVE_LIBGC 1 _ACEOF LIBS="-lgc $LIBS" else system_boehm="no" fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GC_register_my_thread in -lgc" >&5 $as_echo_n "checking for GC_register_my_thread in -lgc... " >&6; } if ${ac_cv_lib_gc_GC_register_my_thread+:} false; then : $as_echo_n "(cached) " >&6 else ac_check_lib_save_LIBS=$LIBS LIBS="-lgc $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 GC_register_my_thread (); int main () { return GC_register_my_thread (); ; return 0; } _ACEOF if ac_fn_c_try_link "$LINENO"; then : ac_cv_lib_gc_GC_register_my_thread=yes else ac_cv_lib_gc_GC_register_my_thread=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_gc_GC_register_my_thread" >&5 $as_echo "$ac_cv_lib_gc_GC_register_my_thread" >&6; } if test "x$ac_cv_lib_gc_GC_register_my_thread" = xyes; then : cat >>confdefs.h <<_ACEOF #define HAVE_LIBGC 1 _ACEOF LIBS="-lgc $LIBS" else system_boehm="no" fi fi if test "${system_boehm}" = yes; then ac_fn_c_check_header_mongrel "$LINENO" "gc.h" "ac_cv_header_gc_h" "$ac_includes_default" if test "x$ac_cv_header_gc_h" = xyes; then : ECL_BOEHM_GC_HEADER='gc.h' fi if test -z "$ECL_BOEHM_GC_HEADER"; then ac_fn_c_check_header_mongrel "$LINENO" "gc/gc.h" "ac_cv_header_gc_gc_h" "$ac_includes_default" if test "x$ac_cv_header_gc_gc_h" = xyes; then : ECL_BOEHM_GC_HEADER='gc/gc.h' else system_boehm=no fi fi fi if test "${system_boehm}" = "yes"; then { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GC_set_start_callback in -lgc" >&5 $as_echo_n "checking for GC_set_start_callback in -lgc... " >&6; } if ${ac_cv_lib_gc_GC_set_start_callback+:} false; then : $as_echo_n "(cached) " >&6 else ac_check_lib_save_LIBS=$LIBS LIBS="-lgc $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 GC_set_start_callback (); int main () { return GC_set_start_callback (); ; return 0; } _ACEOF if ac_fn_c_try_link "$LINENO"; then : ac_cv_lib_gc_GC_set_start_callback=yes else ac_cv_lib_gc_GC_set_start_callback=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_gc_GC_set_start_callback" >&5 $as_echo "$ac_cv_lib_gc_GC_set_start_callback" >&6; } if test "x$ac_cv_lib_gc_GC_set_start_callback" = xyes; then : $as_echo "#define HAVE_GC_SET_START_CALLBACK /**/" >>confdefs.h fi else $as_echo "#define HAVE_GC_SET_START_CALLBACK /**/" >>confdefs.h fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we can use the existing Boehm-Weiser library " >&5 $as_echo_n "checking whether we can use the existing Boehm-Weiser library ... " >&6; } { $as_echo "$as_me:${as_lineno-$LINENO}: result: ${system_boehm} " >&5 $as_echo "${system_boehm} " >&6; } if test "${system_boehm}" = "no"; then if test "${enable_boehm}" = "auto" -o "${enable_boehm}" = "included"; then enable_boehm="included"; else as_fn_error $? "System Boehm GC library requested but not found." "$LINENO" 5 fi else FASL_LIBS="${FASL_LIBS} -lgc" EXTRA_OBJS="${EXTRA_OBJS} alloc_2.${OBJEXT}" $as_echo "#define GBC_BOEHM 1" >>confdefs.h fi fi if test "${enable_boehm}" = "included"; then { $as_echo "$as_me:${as_lineno-$LINENO}: Configuring included Boehm GC library:" >&5 $as_echo "$as_me: Configuring included Boehm GC library:" >&6;} test -d gc && rm -rf gc currentdir=`${PWDCMD}` cd $srcdir/${ECL_GC_DIR}; if test -d configure; then autoreconf -vif automake --add-missing fi; cd $currentdir; if mkdir gc; then if (destdir=`${PWDCMD}`; cd gc; \ $srcdir/${ECL_GC_DIR}/configure --disable-shared --prefix=${destdir} \ --includedir=${destdir}/ecl/ --libdir=${destdir} \ --build=${build_alias} --host=${host_alias} --enable-large-config \ CC="${CC} ${PICFLAG}" \ CFLAGS="$CFLAGS" LDFLAGS="$LDFLAGS" \ CPPFLAGS="$CPPFLAGS -I${destdir}/ecl" \ ${boehm_configure_flags}); then ECL_BOEHM_GC_HEADER='ecl/gc/gc.h' SUBDIRS="${SUBDIRS} gc" CORE_LIBS="-leclgc ${CORE_LIBS}" EXTRA_OBJS="${EXTRA_OBJS} alloc_2.${OBJEXT}" if test "${enable_shared}" = "no"; then LIBRARIES="${LIBRARIES} ${LIBPREFIX}eclgc.${LIBEXT}" fi $as_echo "#define GBC_BOEHM 0" >>confdefs.h fi fi if test -z "${ECL_BOEHM_GC_HEADER}"; then as_fn_error $? "Unable to configure Boehm-Weiser GC" "$LINENO" 5 fi fi if test "${enable_gengc}" != "no" ; then $as_echo "#define GBC_BOEHM_GENGC /**/" >>confdefs.h fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking if we use Boehm-Demers-Weiser precise garbage collector" >&5 $as_echo_n "checking if we use Boehm-Demers-Weiser precise garbage collector... " >&6; }; if test "${enable_precisegc}" != "no" ; then $as_echo "#define GBC_BOEHM_PRECISE /**/" >>confdefs.h { $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 fi if test ${enable_smallcons} = "yes" ; then $as_echo "#define ECL_SMALL_CONS /**/" >>confdefs.h fi case "${enable_libffi}" in yes) enable_libffi=auto;; no|auto|system|included) ;; *) as_fn_error $? "Invalid value of --enable-dffi: ${enable_libffi} " "$LINENO" 5;; esac if test "${enable_libffi}" = auto -o "${enable_libffi}" = system; then { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ffi_closure_alloc in -lffi" >&5 $as_echo_n "checking for ffi_closure_alloc in -lffi... " >&6; } if ${ac_cv_lib_ffi_ffi_closure_alloc+:} false; then : $as_echo_n "(cached) " >&6 else ac_check_lib_save_LIBS=$LIBS LIBS="-lffi $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 ffi_closure_alloc (); int main () { return ffi_closure_alloc (); ; return 0; } _ACEOF if ac_fn_c_try_link "$LINENO"; then : ac_cv_lib_ffi_ffi_closure_alloc=yes else ac_cv_lib_ffi_ffi_closure_alloc=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_ffi_ffi_closure_alloc" >&5 $as_echo "$ac_cv_lib_ffi_ffi_closure_alloc" >&6; } if test "x$ac_cv_lib_ffi_ffi_closure_alloc" = xyes; then : system_libffi=yes else system_libffi=no fi if test "${system_libffi}" = yes; then ac_fn_c_check_header_mongrel "$LINENO" "ffi/ffi.h" "ac_cv_header_ffi_ffi_h" "$ac_includes_default" if test "x$ac_cv_header_ffi_ffi_h" = xyes; then : ECL_LIBFFI_HEADER='ffi/ffi.h' fi if test -z "$ECL_LIBFFI_HEADER"; then ac_fn_c_check_header_mongrel "$LINENO" "ffi.h" "ac_cv_header_ffi_h" "$ac_includes_default" if test "x$ac_cv_header_ffi_h" = xyes; then : ECL_LIBFFI_HEADER='ffi.h' else system_libffi=no fi fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we can use the existing libffi library " >&5 $as_echo_n "checking whether we can use the existing libffi library ... " >&6; } { $as_echo "$as_me:${as_lineno-$LINENO}: result: ${system_libffi} " >&5 $as_echo "${system_libffi} " >&6; } if test "${system_libffi}" = "no"; then if test "${enable_libffi}" = "auto"; then enable_libffi="included"; else as_fn_error $? "System libffi library requested but not found." "$LINENO" 5 fi else FASL_LIBS="${FASL_LIBS} -lffi" fi fi if test "${enable_libffi}" = "included"; then { $as_echo "$as_me:${as_lineno-$LINENO}: Configuring included libffi library:" >&5 $as_echo "$as_me: Configuring included libffi library:" >&6;} test -d libffi && rm -rf libffi if mkdir libffi; then if (destdir=`${PWDCMD}`; cd libffi; \ $srcdir/libffi/configure --disable-shared --prefix=${destdir} \ --includedir=${destdir}/ecl/ --libdir=${destdir} --build=${build_alias} \ --host=${host_alias} \ CC="${CC} ${PICFLAG}" CFLAGS="$CFLAGS" \ LDFLAGS="$LDFLAGS" CPPFLAGS="$CPPFLAGS"); then ECL_LIBFFI_HEADER='ecl/ffi.h' SUBDIRS="${SUBDIRS} libffi" CORE_LIBS="-leclffi ${CORE_LIBS}" EXTRA_OBJS="${EXTRA_OBJS} alloc_2.${OBJEXT}" if test "${enable_shared}" = "no"; then LIBRARIES="${LIBRARIES} ${LIBPREFIX}eclffi.${LIBEXT}" fi fi fi fi if test -z "${ECL_LIBFFI_HEADER}"; then { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Unable to configure or find libffi library; disabling dynamic FFI" >&5 $as_echo "$as_me: WARNING: Unable to configure or find libffi library; disabling dynamic FFI" >&2;} else $as_echo "#define HAVE_LIBFFI /**/" >>confdefs.h fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking for soname flags" >&5 $as_echo_n "checking for soname flags... " >&6; } PACKAGE_MAJOR=`echo ${PACKAGE_VERSION} | sed -e 's,\(.*\)\..*\..*,\1,g'` PACKAGE_MINOR=`echo ${PACKAGE_VERSION} | sed -e 's,.*\.\(.*\)\..*,\1,g'` PACKAGE_LEAST=`echo ${PACKAGE_VERSION} | sed -e 's,.*\..*\.\(.*\),\1,g'` if test "${enable_soname}" != yes; then SONAME='' SONAME1='' SONAME2='' SONAME3='' SONAME_ALIASES='' SONAME_LDFLAGS='' { $as_echo "$as_me:${as_lineno-$LINENO}: result: none" >&5 $as_echo "none" >&6; } else i="${PACKAGE_MAJOR}.${PACKAGE_MINOR}.${PACKAGE_LEAST}" SONAME3=`echo $SONAME | sed "s,.SOVERSION,.$i,g"` i="${PACKAGE_MAJOR}.${PACKAGE_MINOR}" SONAME2=`echo $SONAME | sed "s,.SOVERSION,.$i,g"` i="${PACKAGE_MAJOR}" SONAME1=`echo $SONAME | sed "s,.SOVERSION,.$i,g"` SONAME=`echo $SONAME | sed "s,.SOVERSION,,g"` SONAME_LDFLAGS=`echo $SONAME_LDFLAGS | sed "s,SONAME,$SONAME2,g"` { $as_echo "$as_me:${as_lineno-$LINENO}: result: ${SONAME_LDFLAGS}" >&5 $as_echo "${SONAME_LDFLAGS}" >&6; } fi ECL_VERSION_NUMBER=$(($PACKAGE_MAJOR * 10000 + $PACKAGE_MINOR * 100 + $PACKAGE_LEAST)) if test "${with_ieee_fp}" = yes; then with_signed_zero="yes" with_fpe="yes" $as_echo "#define ECL_IEEE_FP /**/" >>confdefs.h fi if test "${with_fpe}" != yes; then $as_echo "#define ECL_AVOID_FPE_H /**/" >>confdefs.h fi if test "${with_signed_zero}" = yes; then $as_echo "#define ECL_SIGNED_ZERO /**/" >>confdefs.h fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking for X" >&5 $as_echo_n "checking for X... " >&6; } # Check whether --with-x was given. if test "${with_x+set}" = set; then : withval=$with_x; fi # $have_x is `yes', `no', `disabled', or empty when we do not yet know. if test "x$with_x" = xno; then # The user explicitly disabled X. have_x=disabled else case $x_includes,$x_libraries in #( *\'*) as_fn_error $? "cannot use X directory names containing '" "$LINENO" 5;; #( *,NONE | NONE,*) if ${ac_cv_have_x+:} false; then : $as_echo_n "(cached) " >&6 else # One or both of the vars are not set, and there is no cached value. ac_x_includes=no ac_x_libraries=no rm -f -r conftest.dir if mkdir conftest.dir; then cd conftest.dir cat >Imakefile <<'_ACEOF' incroot: @echo incroot='${INCROOT}' usrlibdir: @echo usrlibdir='${USRLIBDIR}' libdir: @echo libdir='${LIBDIR}' _ACEOF if (export CC; ${XMKMF-xmkmf}) >/dev/null 2>/dev/null && test -f Makefile; then # GNU make sometimes prints "make[1]: Entering ...", which would confuse us. for ac_var in incroot usrlibdir libdir; do eval "ac_im_$ac_var=\`\${MAKE-make} $ac_var 2>/dev/null | sed -n 's/^$ac_var=//p'\`" done # Open Windows xmkmf reportedly sets LIBDIR instead of USRLIBDIR. for ac_extension in a so sl dylib la dll; do if test ! -f "$ac_im_usrlibdir/libX11.$ac_extension" && test -f "$ac_im_libdir/libX11.$ac_extension"; then ac_im_usrlibdir=$ac_im_libdir; break fi done # Screen out bogus values from the imake configuration. They are # bogus both because they are the default anyway, and because # using them would break gcc on systems where it needs fixed includes. case $ac_im_incroot in /usr/include) ac_x_includes= ;; *) test -f "$ac_im_incroot/X11/Xos.h" && ac_x_includes=$ac_im_incroot;; esac case $ac_im_usrlibdir in /usr/lib | /usr/lib64 | /lib | /lib64) ;; *) test -d "$ac_im_usrlibdir" && ac_x_libraries=$ac_im_usrlibdir ;; esac fi cd .. rm -f -r conftest.dir fi # Standard set of common directories for X headers. # Check X11 before X11Rn because it is often a symlink to the current release. ac_x_header_dirs=' /usr/X11/include /usr/X11R7/include /usr/X11R6/include /usr/X11R5/include /usr/X11R4/include /usr/include/X11 /usr/include/X11R7 /usr/include/X11R6 /usr/include/X11R5 /usr/include/X11R4 /usr/local/X11/include /usr/local/X11R7/include /usr/local/X11R6/include /usr/local/X11R5/include /usr/local/X11R4/include /usr/local/include/X11 /usr/local/include/X11R7 /usr/local/include/X11R6 /usr/local/include/X11R5 /usr/local/include/X11R4 /usr/X386/include /usr/x386/include /usr/XFree86/include/X11 /usr/include /usr/local/include /usr/unsupported/include /usr/athena/include /usr/local/x11r5/include /usr/lpp/Xamples/include /usr/openwin/include /usr/openwin/share/include' if test "$ac_x_includes" = no; then # Guess where to find include files, by looking for Xlib.h. # First, try using that file with no special directory specified. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include _ACEOF if ac_fn_c_try_cpp "$LINENO"; then : # We can compile using X headers with no special include directory. ac_x_includes= else for ac_dir in $ac_x_header_dirs; do if test -r "$ac_dir/X11/Xlib.h"; then ac_x_includes=$ac_dir break fi done fi rm -f conftest.err conftest.i conftest.$ac_ext fi # $ac_x_includes = no if test "$ac_x_libraries" = no; then # Check for the libraries. # See if we find them without any special options. # Don't add to $LIBS permanently. ac_save_LIBS=$LIBS LIBS="-lX11 $LIBS" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include int main () { XrmInitialize () ; return 0; } _ACEOF if ac_fn_c_try_link "$LINENO"; then : LIBS=$ac_save_LIBS # We can link X programs with no special library path. ac_x_libraries= else LIBS=$ac_save_LIBS for ac_dir in `$as_echo "$ac_x_includes $ac_x_header_dirs" | sed s/include/lib/g` do # Don't even attempt the hair of trying to link an X program! for ac_extension in a so sl dylib la dll; do if test -r "$ac_dir/libX11.$ac_extension"; then ac_x_libraries=$ac_dir break 2 fi done done fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext fi # $ac_x_libraries = no case $ac_x_includes,$ac_x_libraries in #( no,* | *,no | *\'*) # Didn't find X, or a directory has "'" in its name. ac_cv_have_x="have_x=no";; #( *) # Record where we found X for the cache. ac_cv_have_x="have_x=yes\ ac_x_includes='$ac_x_includes'\ ac_x_libraries='$ac_x_libraries'" esac fi ;; #( *) have_x=yes;; esac eval "$ac_cv_have_x" fi # $with_x != no if test "$have_x" != yes; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $have_x" >&5 $as_echo "$have_x" >&6; } no_x=yes else # If each of the values was on the command line, it overrides each guess. test "x$x_includes" = xNONE && x_includes=$ac_x_includes test "x$x_libraries" = xNONE && x_libraries=$ac_x_libraries # Update the cache value to reflect the command line values. ac_cv_have_x="have_x=yes\ ac_x_includes='$x_includes'\ ac_x_libraries='$x_libraries'" { $as_echo "$as_me:${as_lineno-$LINENO}: result: libraries $x_libraries, headers $x_includes" >&5 $as_echo "libraries $x_libraries, headers $x_includes" >&6; } fi ac_header_dirent=no for ac_hdr in dirent.h sys/ndir.h sys/dir.h ndir.h; do as_ac_Header=`$as_echo "ac_cv_header_dirent_$ac_hdr" | $as_tr_sh` { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_hdr that defines DIR" >&5 $as_echo_n "checking for $ac_hdr that defines DIR... " >&6; } if eval \${$as_ac_Header+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include <$ac_hdr> int main () { if ((DIR *) 0) return 0; ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : eval "$as_ac_Header=yes" else eval "$as_ac_Header=no" fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi eval ac_res=\$$as_ac_Header { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 $as_echo "$ac_res" >&6; } if eval test \"x\$"$as_ac_Header"\" = x"yes"; then : cat >>confdefs.h <<_ACEOF #define `$as_echo "HAVE_$ac_hdr" | $as_tr_cpp` 1 _ACEOF ac_header_dirent=$ac_hdr; break fi done # Two versions of opendir et al. are in -ldir and -lx on SCO Xenix. if test $ac_header_dirent = dirent.h; then { $as_echo "$as_me:${as_lineno-$LINENO}: checking for library containing opendir" >&5 $as_echo_n "checking for library containing opendir... " >&6; } if ${ac_cv_search_opendir+:} 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 opendir (); int main () { return opendir (); ; return 0; } _ACEOF for ac_lib in '' dir; 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_opendir=$ac_res fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext if ${ac_cv_search_opendir+:} false; then : break fi done if ${ac_cv_search_opendir+:} false; then : else ac_cv_search_opendir=no fi rm conftest.$ac_ext LIBS=$ac_func_search_save_LIBS fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_opendir" >&5 $as_echo "$ac_cv_search_opendir" >&6; } ac_res=$ac_cv_search_opendir if test "$ac_res" != no; then : test "$ac_res" = "none required" || LIBS="$ac_res $LIBS" fi else { $as_echo "$as_me:${as_lineno-$LINENO}: checking for library containing opendir" >&5 $as_echo_n "checking for library containing opendir... " >&6; } if ${ac_cv_search_opendir+:} 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 opendir (); int main () { return opendir (); ; return 0; } _ACEOF for ac_lib in '' x; 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_opendir=$ac_res fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext if ${ac_cv_search_opendir+:} false; then : break fi done if ${ac_cv_search_opendir+:} false; then : else ac_cv_search_opendir=no fi rm conftest.$ac_ext LIBS=$ac_func_search_save_LIBS fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_opendir" >&5 $as_echo "$ac_cv_search_opendir" >&6; } ac_res=$ac_cv_search_opendir if test "$ac_res" != no; then : test "$ac_res" = "none required" || LIBS="$ac_res $LIBS" fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking for stdbool.h that conforms to C99" >&5 $as_echo_n "checking for stdbool.h that conforms to C99... " >&6; } if ${ac_cv_header_stdbool_h+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #ifndef bool "error: bool is not defined" #endif #ifndef false "error: false is not defined" #endif #if false "error: false is not 0" #endif #ifndef true "error: true is not defined" #endif #if true != 1 "error: true is not 1" #endif #ifndef __bool_true_false_are_defined "error: __bool_true_false_are_defined is not defined" #endif struct s { _Bool s: 1; _Bool t; } s; char a[true == 1 ? 1 : -1]; char b[false == 0 ? 1 : -1]; char c[__bool_true_false_are_defined == 1 ? 1 : -1]; char d[(bool) 0.5 == true ? 1 : -1]; /* See body of main program for 'e'. */ char f[(_Bool) 0.0 == false ? 1 : -1]; char g[true]; char h[sizeof (_Bool)]; char i[sizeof s.t]; enum { j = false, k = true, l = false * true, m = true * 256 }; /* The following fails for HP aC++/ANSI C B3910B A.05.55 [Dec 04 2003]. */ _Bool n[m]; char o[sizeof n == m * sizeof n[0] ? 1 : -1]; char p[-1 - (_Bool) 0 < 0 && -1 - (bool) 0 < 0 ? 1 : -1]; /* Catch a bug in an HP-UX C compiler. See http://gcc.gnu.org/ml/gcc-patches/2003-12/msg02303.html http://lists.gnu.org/archive/html/bug-coreutils/2005-11/msg00161.html */ _Bool q = true; _Bool *pq = &q; int main () { bool e = &s; *pq |= q; *pq |= ! q; /* Refer to every declared value, to avoid compiler optimizations. */ return (!a + !b + !c + !d + !e + !f + !g + !h + !i + !!j + !k + !!l + !m + !n + !o + !p + !q + !pq); ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_cv_header_stdbool_h=yes else ac_cv_header_stdbool_h=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdbool_h" >&5 $as_echo "$ac_cv_header_stdbool_h" >&6; } ac_fn_c_check_type "$LINENO" "_Bool" "ac_cv_type__Bool" "$ac_includes_default" if test "x$ac_cv_type__Bool" = xyes; then : cat >>confdefs.h <<_ACEOF #define HAVE__BOOL 1 _ACEOF fi if test $ac_cv_header_stdbool_h = yes; then $as_echo "#define HAVE_STDBOOL_H 1" >>confdefs.h fi { $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 { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether time.h and sys/time.h may both be included" >&5 $as_echo_n "checking whether time.h and sys/time.h may both be included... " >&6; } if ${ac_cv_header_time+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include #include int main () { if ((struct tm *) 0) return 0; ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_cv_header_time=yes else ac_cv_header_time=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_time" >&5 $as_echo "$ac_cv_header_time" >&6; } if test $ac_cv_header_time = yes; then $as_echo "#define TIME_WITH_SYS_TIME 1" >>confdefs.h fi for ac_header in fcntl.h limits.h netdb.h netinet/in.h \ stddef.h stdlib.h string.h sys/param.h \ sys/socket.h sys/time.h unistd.h fenv.h \ sched.h do : as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh` ac_fn_c_check_header_mongrel "$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 sys/resource.h sys/utsname.h float.h pwd.h dlfcn.h link.h \ mach-o/dyld.h dirent.h sys/ioctl.h sys/select.h \ sys/wait.h semaphore.h do : as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh` ac_fn_c_check_header_mongrel "$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 ulimit.h do : ac_fn_c_check_header_compile "$LINENO" "ulimit.h" "ac_cv_header_ulimit_h" "#ifdef HAVE_ULIMIT_H # include #endif " if test "x$ac_cv_header_ulimit_h" = xyes; then : cat >>confdefs.h <<_ACEOF #define HAVE_ULIMIT_H 1 _ACEOF fi done { $as_echo "$as_me:${as_lineno-$LINENO}: checking for an ANSI C-conforming const" >&5 $as_echo_n "checking for an ANSI C-conforming const... " >&6; } if ${ac_cv_c_const+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { #ifndef __cplusplus /* Ultrix mips cc rejects this sort of thing. */ typedef int charset[2]; const charset cs = { 0, 0 }; /* SunOS 4.1.1 cc rejects this. */ char const *const *pcpcc; char **ppc; /* NEC SVR4.0.2 mips cc rejects this. */ struct point {int x, y;}; static struct point const zero = {0,0}; /* AIX XL C 1.02.0.0 rejects this. It does not let you subtract one const X* pointer from another in an arm of an if-expression whose if-part is not a constant expression */ const char *g = "string"; pcpcc = &g + (g ? g-g : 0); /* HPUX 7.0 cc rejects these. */ ++pcpcc; ppc = (char**) pcpcc; pcpcc = (char const *const *) ppc; { /* SCO 3.2v4 cc rejects this sort of thing. */ char tx; char *t = &tx; char const *s = 0 ? (char *) 0 : (char const *) 0; *t++ = 0; if (s) return 0; } { /* Someone thinks the Sun supposedly-ANSI compiler will reject this. */ int x[] = {25, 17}; const int *foo = &x[0]; ++foo; } { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */ typedef const int *iptr; iptr p = 0; ++p; } { /* AIX XL C 1.02.0.0 rejects this sort of thing, saying "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */ struct s { int j; const int *ap[3]; } bx; struct s *b = &bx; b->j = 5; } { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */ const int foo = 10; if (!foo) return 0; } return !cs[0] && !zero.x; #endif ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_cv_c_const=yes else ac_cv_c_const=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_const" >&5 $as_echo "$ac_cv_c_const" >&6; } if test $ac_cv_c_const = no; then $as_echo "#define const /**/" >>confdefs.h fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking for inline" >&5 $as_echo_n "checking for inline... " >&6; } if ${ac_cv_c_inline+:} false; then : $as_echo_n "(cached) " >&6 else ac_cv_c_inline=no for ac_kw in inline __inline__ __inline; do cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #ifndef __cplusplus typedef int foo_t; static $ac_kw foo_t static_foo () {return 0; } $ac_kw foo_t foo () {return 0; } #endif _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_cv_c_inline=$ac_kw fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext test "$ac_cv_c_inline" != no && break done fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_inline" >&5 $as_echo "$ac_cv_c_inline" >&6; } case $ac_cv_c_inline in inline | yes) ;; *) case $ac_cv_c_inline in no) ac_val=;; *) ac_val=$ac_cv_c_inline;; esac cat >>confdefs.h <<_ACEOF #ifndef __cplusplus #define inline $ac_val #endif _ACEOF ;; esac ac_fn_c_check_type "$LINENO" "size_t" "ac_cv_type_size_t" "$ac_includes_default" if test "x$ac_cv_type_size_t" = xyes; then : else cat >>confdefs.h <<_ACEOF #define size_t unsigned int _ACEOF fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether struct tm is in sys/time.h or time.h" >&5 $as_echo_n "checking whether struct tm is in sys/time.h or time.h... " >&6; } if ${ac_cv_struct_tm+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include int main () { struct tm tm; int *p = &tm.tm_sec; return !p; ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_cv_struct_tm=time.h else ac_cv_struct_tm=sys/time.h fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_struct_tm" >&5 $as_echo "$ac_cv_struct_tm" >&6; } if test $ac_cv_struct_tm = sys/time.h; then $as_echo "#define TM_IN_SYS_TIME 1" >>confdefs.h fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking for working volatile" >&5 $as_echo_n "checking for working volatile... " >&6; } if ${ac_cv_c_volatile+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { volatile int x; int * volatile y = (int *) 0; return !x && !y; ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_cv_c_volatile=yes else ac_cv_c_volatile=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_volatile" >&5 $as_echo "$ac_cv_c_volatile" >&6; } if test $ac_cv_c_volatile = no; then $as_echo "#define volatile /**/" >>confdefs.h fi ac_fn_c_check_type "$LINENO" "ptrdiff_t" "ac_cv_type_ptrdiff_t" "$ac_includes_default" if test "x$ac_cv_type_ptrdiff_t" = xyes; then : cat >>confdefs.h <<_ACEOF #define HAVE_PTRDIFF_T 1 _ACEOF fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking size of long long" >&5 $as_echo_n "checking size of long long... " >&6; } if test "x$ECL_LONG_LONG_BITS" = "xno"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: not available" >&5 $as_echo "not available" >&6; } ac_cv_c_long_long=no ECL_LONG_LONG_BITS="" else if test "$GCC" = yes; then ac_cv_c_long_long=yes else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { long long int i; ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_cv_c_long_long=yes else ac_cv_c_long_long=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi fi if test $ac_cv_c_long_long = yes; then if test "x$ECL_LONG_LONG_BITS" = "x"; then if test "$cross_compiling" = yes; then : { { $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 test program while cross compiling See \`config.log' for more details" "$LINENO" 5; } else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include int main() { const char *int_type; int bits; unsigned long long x = 1; FILE *f=fopen("conftestval", "w"); if (!f) exit(1); for (bits = 0; x; bits++) { x <<= 1; } fprintf(f,"ECL_LONG_LONG_BITS='%d'",bits); exit(0); } _ACEOF if ac_fn_c_try_run "$LINENO"; then : eval "`cat conftestval`" 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 if test "x$ECL_LONG_LONG_BITS" = "x"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: not available" >&5 $as_echo "not available" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ECL_LONG_LONG_BITS" >&5 $as_echo "$ECL_LONG_LONG_BITS" >&6; } $as_echo "#define ecl_long_long_t long long" >>confdefs.h $as_echo "#define ecl_ulong_long_t unsigned long long" >>confdefs.h cat >>confdefs.h <<_ACEOF #define ECL_LONG_LONG_BITS $ECL_LONG_LONG_BITS _ACEOF fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether byte ordering is bigendian" >&5 $as_echo_n "checking whether byte ordering is bigendian... " >&6; } if ${ac_cv_c_bigendian+:} false; then : $as_echo_n "(cached) " >&6 else ac_cv_c_bigendian=unknown # See if we're dealing with a universal compiler. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #ifndef __APPLE_CC__ not a universal capable compiler #endif typedef int dummy; _ACEOF if ac_fn_c_try_compile "$LINENO"; then : # Check for potential -arch flags. It is not universal unless # there are at least two -arch flags with different values. ac_arch= ac_prev= for ac_word in $CC $CFLAGS $CPPFLAGS $LDFLAGS; do if test -n "$ac_prev"; then case $ac_word in i?86 | x86_64 | ppc | ppc64) if test -z "$ac_arch" || test "$ac_arch" = "$ac_word"; then ac_arch=$ac_word else ac_cv_c_bigendian=universal break fi ;; esac ac_prev= elif test "x$ac_word" = "x-arch"; then ac_prev=arch fi done fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext if test $ac_cv_c_bigendian = unknown; then # See if sys/param.h defines the BYTE_ORDER macro. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include int main () { #if ! (defined BYTE_ORDER && defined BIG_ENDIAN \ && defined LITTLE_ENDIAN && BYTE_ORDER && BIG_ENDIAN \ && LITTLE_ENDIAN) bogus endian macros #endif ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : # It does; now see whether it defined to BIG_ENDIAN or not. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include int main () { #if BYTE_ORDER != BIG_ENDIAN not big endian #endif ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_cv_c_bigendian=yes else ac_cv_c_bigendian=no 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 if test $ac_cv_c_bigendian = unknown; then # See if defines _LITTLE_ENDIAN or _BIG_ENDIAN (e.g., Solaris). cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include int main () { #if ! (defined _LITTLE_ENDIAN || defined _BIG_ENDIAN) bogus endian macros #endif ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : # It does; now see whether it defined to _BIG_ENDIAN or not. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include int main () { #ifndef _BIG_ENDIAN not big endian #endif ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_cv_c_bigendian=yes else ac_cv_c_bigendian=no 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 if test $ac_cv_c_bigendian = unknown; then # Compile a test program. if test "$cross_compiling" = yes; then : # Try to guess by grepping values from an object file. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ short int ascii_mm[] = { 0x4249, 0x4765, 0x6E44, 0x6961, 0x6E53, 0x7953, 0 }; short int ascii_ii[] = { 0x694C, 0x5454, 0x656C, 0x6E45, 0x6944, 0x6E61, 0 }; int use_ascii (int i) { return ascii_mm[i] + ascii_ii[i]; } short int ebcdic_ii[] = { 0x89D3, 0xE3E3, 0x8593, 0x95C5, 0x89C4, 0x9581, 0 }; short int ebcdic_mm[] = { 0xC2C9, 0xC785, 0x95C4, 0x8981, 0x95E2, 0xA8E2, 0 }; int use_ebcdic (int i) { return ebcdic_mm[i] + ebcdic_ii[i]; } extern int foo; int main () { return use_ascii (foo) == use_ebcdic (foo); ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : if grep BIGenDianSyS conftest.$ac_objext >/dev/null; then ac_cv_c_bigendian=yes fi if grep LiTTleEnDian conftest.$ac_objext >/dev/null ; then if test "$ac_cv_c_bigendian" = unknown; then ac_cv_c_bigendian=no else # finding both strings is unlikely to happen, but who knows? ac_cv_c_bigendian=unknown fi fi fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $ac_includes_default int main () { /* Are we little or big endian? From Harbison&Steele. */ union { long int l; char c[sizeof (long int)]; } u; u.l = 1; return u.c[sizeof (long int) - 1] == 1; ; return 0; } _ACEOF if ac_fn_c_try_run "$LINENO"; then : ac_cv_c_bigendian=no else ac_cv_c_bigendian=yes 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_c_bigendian" >&5 $as_echo "$ac_cv_c_bigendian" >&6; } case $ac_cv_c_bigendian in #( yes) $as_echo "#define WORDS_BIGENDIAN 1" >>confdefs.h ;; #( no) ;; #( universal) $as_echo "#define AC_APPLE_UNIVERSAL_BUILD 1" >>confdefs.h ;; #( *) $as_echo "#define WORDS_BIGENDIAN /* EDIT! - Undefine if small endian */" >>confdefs.h ;; esac { $as_echo "$as_me:${as_lineno-$LINENO}: checking appropiate type for fixnums" >&5 $as_echo_n "checking appropiate type for fixnums... " >&6; } if test -z "${CL_FIXNUM_TYPE}" ; then if test "$cross_compiling" = yes; then : { { $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 test program while cross compiling See \`config.log' for more details" "$LINENO" 5; } else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include int main() { const char *int_type; int bits; FILE *f=fopen("conftestval", "w"); if (!f) exit(1); if (sizeof(int) >= sizeof(void*)) { unsigned int t = 1; signed int l = 0; int_type="int"; for (bits=1; ((t << 1) >> 1) == t; bits++, t <<= 1); l = (~l) << (bits - 3); #if 1 fprintf(f,"CL_FIXNUM_MIN='%d';",l); fprintf(f,"CL_FIXNUM_MAX='%d';",-(l+1)); #else l++; fprintf(f,"CL_FIXNUM_MIN='%d';",l); fprintf(f,"CL_FIXNUM_MAX='%d';",-l); #endif } else if (sizeof(long) >= sizeof(void*)) { unsigned long int t = 1; signed long int l = 0; int_type="long int"; for (bits=1; ((t << 1) >> 1) == t; bits++, t <<= 1); l = (~l) << (bits - 3); #if 1 fprintf(f,"CL_FIXNUM_MIN='%ldL';",l); fprintf(f,"CL_FIXNUM_MAX='%ldL';",-(l+1)); #else l++; fprintf(f,"CL_FIXNUM_MIN='%ldL';",l); fprintf(f,"CL_FIXNUM_MAX='%ldL';",-l); #endif #ifdef ECL_LONG_LONG_BITS } else if (sizeof(long long) >= sizeof(void*)) { unsigned long long int t = 1; signed long long int l = 0; int_type="long long"; for (bits=1; ((t << 1) >> 1) == t; bits++, t <<= 1); l = (~l) << (bits - 3); # if 1 fprintf(f,"CL_FIXNUM_MIN='%lldLL';",l); fprintf(f,"CL_FIXNUM_MAX='%lldLL';",-(l+1)); # else l++; fprintf(f,"CL_FIXNUM_MIN='%lldLL';",l); fprintf(f,"CL_FIXNUM_MAX='%lldLL';",-l); # endif #endif } else { exit(1); } fprintf(f,"CL_FIXNUM_TYPE='%s';",int_type); fprintf(f,"CL_FIXNUM_BITS='%d';",bits); { unsigned int x = 1; for (bits = 0; x; bits++) { x <<= 1; } fprintf(f,"CL_INT_BITS='%d';",bits); } { unsigned long x = 1; for (bits = 0; x; bits++) { x <<= 1; } fprintf(f,"CL_LONG_BITS='%d'",bits); } exit(0); } _ACEOF if ac_fn_c_try_run "$LINENO"; then : eval "`cat conftestval`" fi rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi fi if test -z "${CL_FIXNUM_TYPE}" ; then as_fn_error $? "There is no appropiate integer type for the cl_fixnum type" "$LINENO" 5 fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: ${CL_FIXNUM_TYPE}" >&5 $as_echo "${CL_FIXNUM_TYPE}" >&6; } ac_fn_c_check_header_mongrel "$LINENO" "stdint.h" "ac_cv_header_stdint_h" "$ac_includes_default" if test "x$ac_cv_header_stdint_h" = xyes; then : $as_echo "#define HAVE_STDINT_H 1" >>confdefs.h ECL_STDINT_HEADER="#include " fi if test -z "${ECL_STDINT_HEADER}"; then ac_fn_c_check_header_mongrel "$LINENO" "inttypes.h" "ac_cv_header_inttypes_h" "$ac_includes_default" if test "x$ac_cv_header_inttypes_h" = xyes; then : $as_echo "#define HAVE_INTTYPES_H 1" >>confdefs.h ECL_STDINT_HEADER="#include " fi fi ac_fn_c_find_intX_t "$LINENO" "8" "ac_cv_c_int8_t" case $ac_cv_c_int8_t in #( no|yes) ;; #( *) cat >>confdefs.h <<_ACEOF #define int8_t $ac_cv_c_int8_t _ACEOF ;; esac ac_fn_c_find_uintX_t "$LINENO" "8" "ac_cv_c_uint8_t" case $ac_cv_c_uint8_t in #( no|yes) ;; #( *) $as_echo "#define _UINT8_T 1" >>confdefs.h cat >>confdefs.h <<_ACEOF #define uint8_t $ac_cv_c_uint8_t _ACEOF ;; esac if test "x$ac_cv_c_int8_t" = xyes; then eval ECL_INT8_T="int8_t" eval ECL_UINT8_T="uint8_t" cat >>confdefs.h <<_ACEOF #define ecl_int8_t int8_t _ACEOF cat >>confdefs.h <<_ACEOF #define ecl_uint8_t uint8_t _ACEOF fi ac_fn_c_find_intX_t "$LINENO" "16" "ac_cv_c_int16_t" case $ac_cv_c_int16_t in #( no|yes) ;; #( *) cat >>confdefs.h <<_ACEOF #define int16_t $ac_cv_c_int16_t _ACEOF ;; esac ac_fn_c_find_uintX_t "$LINENO" "16" "ac_cv_c_uint16_t" case $ac_cv_c_uint16_t in #( no|yes) ;; #( *) cat >>confdefs.h <<_ACEOF #define uint16_t $ac_cv_c_uint16_t _ACEOF ;; esac if test "x$ac_cv_c_int16_t" = xyes; then eval ECL_INT16_T="int16_t" eval ECL_UINT16_T="uint16_t" cat >>confdefs.h <<_ACEOF #define ecl_int16_t int16_t _ACEOF cat >>confdefs.h <<_ACEOF #define ecl_uint16_t uint16_t _ACEOF fi ac_fn_c_find_intX_t "$LINENO" "32" "ac_cv_c_int32_t" case $ac_cv_c_int32_t in #( no|yes) ;; #( *) cat >>confdefs.h <<_ACEOF #define int32_t $ac_cv_c_int32_t _ACEOF ;; esac ac_fn_c_find_uintX_t "$LINENO" "32" "ac_cv_c_uint32_t" case $ac_cv_c_uint32_t in #( no|yes) ;; #( *) $as_echo "#define _UINT32_T 1" >>confdefs.h cat >>confdefs.h <<_ACEOF #define uint32_t $ac_cv_c_uint32_t _ACEOF ;; esac if test "x$ac_cv_c_int32_t" = xyes; then eval ECL_INT32_T="int32_t" eval ECL_UINT32_T="uint32_t" cat >>confdefs.h <<_ACEOF #define ecl_int32_t int32_t _ACEOF cat >>confdefs.h <<_ACEOF #define ecl_uint32_t uint32_t _ACEOF fi ac_fn_c_find_intX_t "$LINENO" "64" "ac_cv_c_int64_t" case $ac_cv_c_int64_t in #( no|yes) ;; #( *) cat >>confdefs.h <<_ACEOF #define int64_t $ac_cv_c_int64_t _ACEOF ;; esac ac_fn_c_find_uintX_t "$LINENO" "64" "ac_cv_c_uint64_t" case $ac_cv_c_uint64_t in #( no|yes) ;; #( *) $as_echo "#define _UINT64_T 1" >>confdefs.h cat >>confdefs.h <<_ACEOF #define uint64_t $ac_cv_c_uint64_t _ACEOF ;; esac if test "x$ac_cv_c_int64_t" = xyes; then eval ECL_INT64_T="int64_t" eval ECL_UINT64_T="uint64_t" cat >>confdefs.h <<_ACEOF #define ecl_int64_t int64_t _ACEOF cat >>confdefs.h <<_ACEOF #define ecl_uint64_t uint64_t _ACEOF fi if test "${ECL_UINT32_T}${CL_FIXNUM_BITS}" = "32"; then ECL_UINT32_T="cl_index" ECL_INT32_T="cl_fixnum" fi if test "${ECL_UINT64_T}${CL_FIXNUM_BITS}" = "64"; then ECL_UINT64_T="cl_index" ECL_INT64_T="cl_fixnum" fi if test "${ECL_UINT16_T}${CL_FIXNUM_BITS}" = "16"; then ECL_UINT16_T=$ECL_UINT32_T ECL_INT16_T=$ECL_INT32_T fi if test "x${ECL_UINT8_T}" = "x" -o "x${ECL_UINT8_T}" = xno; then as_fn_error $? "Can not build ECL without byte types" "$LINENO" 5 fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking character sequence for end of line" >&5 $as_echo_n "checking character sequence for end of line... " >&6; } if test -z "${ECL_NEWLINE}" ; then if test "$cross_compiling" = yes; then : { { $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 test program while cross compiling See \`config.log' for more details" "$LINENO" 5; } else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include int main() { FILE *f = fopen("conftestval","w"); int c1, c2; char *output; if (f == NULL) exit(1); fprintf(f, "\n"); fclose(f); f = fopen("conftestval","rb"); if (f == NULL) exit(1); c1 = fgetc(f); c2 = fgetc(f); fclose(f); f = fopen("conftestval","w"); if (f == NULL) exit(1); if (c1 == '\r') if (c2 == EOF) output="CR"; else output="CRLF"; else output="LF"; fclose(f); f = fopen("conftestval","w"); if (f == NULL) exit(1); fprintf(f, output); fclose(f); exit(0); } _ACEOF if ac_fn_c_try_run "$LINENO"; then : ECL_NEWLINE=`cat conftestval` fi rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi fi case "${ECL_NEWLINE}" in LF) { $as_echo "$as_me:${as_lineno-$LINENO}: result: lf" >&5 $as_echo "lf" >&6; } ;; CR) { $as_echo "$as_me:${as_lineno-$LINENO}: result: cr" >&5 $as_echo "cr" >&6; }; $as_echo "#define ECL_NEWLINE_IS_CR 1" >>confdefs.h ;; CRLF) { $as_echo "$as_me:${as_lineno-$LINENO}: result: cr+lf" >&5 $as_echo "cr+lf" >&6; }; $as_echo "#define ECL_NEWLINE_IS_CRLF 1" >>confdefs.h ;; *) as_fn_error $? "Unable to determine linefeed mode" "$LINENO" 5 ;; esac ac_fn_c_check_func "$LINENO" "_longjmp" "ac_cv_func__longjmp" if test "x$ac_cv_func__longjmp" = xyes; then : ECL_SETJMP="_setjmp";ECL_LONGJMP="_longjmp" else ECL_SETJMP="setjmp";ECL_LONGJMP="longjmp" fi if test -z "${ECL_FILE_CNT}"; then ECL_FILE_CNT=0 cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include int main () { FILE *f = fopen("conftestval","w"); if ((f)->_IO_read_end - (f)->_IO_read_ptr) return 1; ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ECL_FILE_CNT=1 fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include int main () { FILE *f = fopen("conftestval","w"); if ((f)->_r) return 1; ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ECL_FILE_CNT=2 fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include int main () { FILE *f = fopen("conftestval","w"); if ((f)->_cnt) return 1; ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ECL_FILE_CNT=3 fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking for code to detect FP exceptions" >&5 $as_echo_n "checking for code to detect FP exceptions... " >&6; } case "${host_cpu}" in i686 | i586 | pentium* | athlon* ) ECL_FPE_CODE="arch/fpe_x86.c" { $as_echo "$as_me:${as_lineno-$LINENO}: result: x86" >&5 $as_echo "x86" >&6; } ;; x86_64* ) ECL_FPE_CODE="arch/fpe_x86.c" { $as_echo "$as_me:${as_lineno-$LINENO}: result: x86_64" >&5 $as_echo "x86_64" >&6; } ;; *) ECL_FPE_CODE="arch/fpe_none.c" { $as_echo "$as_me:${as_lineno-$LINENO}: result: not available" >&5 $as_echo "not available" >&6; } ;; esac if test "x$with_sse" = xyes; then { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SSE intrinsics" >&5 $as_echo_n "checking for SSE intrinsics... " >&6; } cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include int main () { __m128 value; _mm_getcsr(); ; return 0; } _ACEOF if ac_fn_c_try_link "$LINENO"; then : sse_included=yes else sse_included=no fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext if test "$sse_included" = "no"; then OLD_CFLAGS="$CFLAGS" CFLAGS="$CFLAGS -msse2" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include int main () { __m128 value; _mm_getcsr(); ; return 0; } _ACEOF if ac_fn_c_try_link "$LINENO"; then : sse_included=yes else sse_included=no fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext if test "$sse_included" = "no"; then CFLAGS="$OLD_CFLAGS" with_sse=no fi fi if test "x$with_sse" = xyes; then $as_echo "#define ECL_SSE2 /**/" >>confdefs.h { $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 fi if test "$enable_longdouble" != "no" ; then ac_fn_c_check_type "$LINENO" "long double" "ac_cv_type_long_double" "$ac_includes_default" if test "x$ac_cv_type_long_double" = xyes; then : cat >>confdefs.h <<_ACEOF #define HAVE_LONG_DOUBLE 1 _ACEOF enable_longdouble=yes else enable_longdouble=no fi if test "$enable_longdouble" != "no" ; then for ac_func in sinl cosl tanl logl expl do : as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh` ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var" if eval test \"x\$"$as_ac_var"\" = x"yes"; then : cat >>confdefs.h <<_ACEOF #define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1 _ACEOF else enable_longdouble=no; break fi done if test "$enable_longdouble" != "no" ; then $as_echo "#define ECL_LONG_FLOAT /**/" >>confdefs.h fi fi fi if test "$enable_c99complex" != "no" ; then ac_fn_c_check_type "$LINENO" "double complex" "ac_cv_type_double_complex" "#include " if test "x$ac_cv_type_double_complex" = xyes; then : cat >>confdefs.h <<_ACEOF #define HAVE_DOUBLE_COMPLEX 1 _ACEOF fi ac_fn_c_check_type "$LINENO" "float complex" "ac_cv_type_float_complex" "#include " if test "x$ac_cv_type_float_complex" = xyes; then : cat >>confdefs.h <<_ACEOF #define HAVE_FLOAT_COMPLEX 1 _ACEOF fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether stack growns downwards" >&5 $as_echo_n "checking whether stack growns downwards... " >&6; } if test -z "${ECL_STACK_DIR}" ; then if test "$cross_compiling" = yes; then : { { $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 test program while cross compiling See \`config.log' for more details" "$LINENO" 5; } else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include ptrdiff_t f2(const char *d) { char c[2]; return c-d; } ptrdiff_t f1(const char *d) { char c[2]; return c+1-d; } typedef ptrdiff_t (*f_ptr)(const char *); f_ptr f[2] = { f1, f2 }; ptrdiff_t signo() { char d[1]; return f[rand() & 1](d); } int main() { if (signo() > 0) return 1; else return 0; } _ACEOF if ac_fn_c_try_run "$LINENO"; then : ECL_STACK_DIR=down else ECL_STACK_DIR=up fi rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi fi case "${ECL_STACK_DIR}" in down|DOWN) { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 $as_echo "yes" >&6; }; $as_echo "#define ECL_DOWN_STACK 1" >>confdefs.h ;; up|UP) { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } ;; *) as_fn_error $? "Unable to determine stack growth direction" "$LINENO" 5 esac { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether closedir returns void" >&5 $as_echo_n "checking whether closedir returns void... " >&6; } if ${ac_cv_func_closedir_void+:} false; then : $as_echo_n "(cached) " >&6 else if test "$cross_compiling" = yes; then : ac_cv_func_closedir_void=yes else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $ac_includes_default #include <$ac_header_dirent> #ifndef __cplusplus int closedir (); #endif int main () { return closedir (opendir (".")) != 0; ; return 0; } _ACEOF if ac_fn_c_try_run "$LINENO"; then : ac_cv_func_closedir_void=no else ac_cv_func_closedir_void=yes fi rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_closedir_void" >&5 $as_echo "$ac_cv_func_closedir_void" >&6; } if test $ac_cv_func_closedir_void = yes; then $as_echo "#define CLOSEDIR_VOID 1" >>confdefs.h fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking for error_at_line" >&5 $as_echo_n "checking for error_at_line... " >&6; } if ${ac_cv_lib_error_at_line+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include int main () { error_at_line (0, 0, "", 0, "an error occurred"); ; return 0; } _ACEOF if ac_fn_c_try_link "$LINENO"; then : ac_cv_lib_error_at_line=yes else ac_cv_lib_error_at_line=no fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_error_at_line" >&5 $as_echo "$ac_cv_lib_error_at_line" >&6; } if test $ac_cv_lib_error_at_line = no; then case " $LIBOBJS " in *" error.$ac_objext "* ) ;; *) LIBOBJS="$LIBOBJS error.$ac_objext" ;; esac fi ac_fn_c_check_type "$LINENO" "pid_t" "ac_cv_type_pid_t" "$ac_includes_default" if test "x$ac_cv_type_pid_t" = xyes; then : else cat >>confdefs.h <<_ACEOF #define pid_t int _ACEOF fi for ac_header in vfork.h do : ac_fn_c_check_header_mongrel "$LINENO" "vfork.h" "ac_cv_header_vfork_h" "$ac_includes_default" if test "x$ac_cv_header_vfork_h" = xyes; then : cat >>confdefs.h <<_ACEOF #define HAVE_VFORK_H 1 _ACEOF fi done for ac_func in fork vfork do : as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh` ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var" if eval test \"x\$"$as_ac_var"\" = x"yes"; then : cat >>confdefs.h <<_ACEOF #define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1 _ACEOF fi done if test "x$ac_cv_func_fork" = xyes; then { $as_echo "$as_me:${as_lineno-$LINENO}: checking for working fork" >&5 $as_echo_n "checking for working fork... " >&6; } if ${ac_cv_func_fork_works+:} false; then : $as_echo_n "(cached) " >&6 else if test "$cross_compiling" = yes; then : ac_cv_func_fork_works=cross else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $ac_includes_default int main () { /* By Ruediger Kuhlmann. */ return fork () < 0; ; return 0; } _ACEOF if ac_fn_c_try_run "$LINENO"; then : ac_cv_func_fork_works=yes else ac_cv_func_fork_works=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 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_fork_works" >&5 $as_echo "$ac_cv_func_fork_works" >&6; } else ac_cv_func_fork_works=$ac_cv_func_fork fi if test "x$ac_cv_func_fork_works" = xcross; then case $host in *-*-amigaos* | *-*-msdosdjgpp*) # Override, as these systems have only a dummy fork() stub ac_cv_func_fork_works=no ;; *) ac_cv_func_fork_works=yes ;; esac { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: result $ac_cv_func_fork_works guessed because of cross compilation" >&5 $as_echo "$as_me: WARNING: result $ac_cv_func_fork_works guessed because of cross compilation" >&2;} fi ac_cv_func_vfork_works=$ac_cv_func_vfork if test "x$ac_cv_func_vfork" = xyes; then { $as_echo "$as_me:${as_lineno-$LINENO}: checking for working vfork" >&5 $as_echo_n "checking for working vfork... " >&6; } if ${ac_cv_func_vfork_works+:} false; then : $as_echo_n "(cached) " >&6 else if test "$cross_compiling" = yes; then : ac_cv_func_vfork_works=cross else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ /* Thanks to Paul Eggert for this test. */ $ac_includes_default #include #ifdef HAVE_VFORK_H # include #endif /* On some sparc systems, changes by the child to local and incoming argument registers are propagated back to the parent. The compiler is told about this with #include , but some compilers (e.g. gcc -O) don't grok . Test for this by using a static variable whose address is put into a register that is clobbered by the vfork. */ static void #ifdef __cplusplus sparc_address_test (int arg) # else sparc_address_test (arg) int arg; #endif { static pid_t child; if (!child) { child = vfork (); if (child < 0) { perror ("vfork"); _exit(2); } if (!child) { arg = getpid(); write(-1, "", 0); _exit (arg); } } } int main () { pid_t parent = getpid (); pid_t child; sparc_address_test (0); child = vfork (); if (child == 0) { /* Here is another test for sparc vfork register problems. This test uses lots of local variables, at least as many local variables as main has allocated so far including compiler temporaries. 4 locals are enough for gcc 1.40.3 on a Solaris 4.1.3 sparc, but we use 8 to be safe. A buggy compiler should reuse the register of parent for one of the local variables, since it will think that parent can't possibly be used any more in this routine. Assigning to the local variable will thus munge parent in the parent process. */ pid_t p = getpid(), p1 = getpid(), p2 = getpid(), p3 = getpid(), p4 = getpid(), p5 = getpid(), p6 = getpid(), p7 = getpid(); /* Convince the compiler that p..p7 are live; otherwise, it might use the same hardware register for all 8 local variables. */ if (p != p1 || p != p2 || p != p3 || p != p4 || p != p5 || p != p6 || p != p7) _exit(1); /* On some systems (e.g. IRIX 3.3), vfork doesn't separate parent from child file descriptors. If the child closes a descriptor before it execs or exits, this munges the parent's descriptor as well. Test for this by closing stdout in the child. */ _exit(close(fileno(stdout)) != 0); } else { int status; struct stat st; while (wait(&status) != child) ; return ( /* Was there some problem with vforking? */ child < 0 /* Did the child fail? (This shouldn't happen.) */ || status /* Did the vfork/compiler bug occur? */ || parent != getpid() /* Did the file descriptor bug occur? */ || fstat(fileno(stdout), &st) != 0 ); } } _ACEOF if ac_fn_c_try_run "$LINENO"; then : ac_cv_func_vfork_works=yes else ac_cv_func_vfork_works=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 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_vfork_works" >&5 $as_echo "$ac_cv_func_vfork_works" >&6; } fi; if test "x$ac_cv_func_fork_works" = xcross; then ac_cv_func_vfork_works=$ac_cv_func_vfork { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: result $ac_cv_func_vfork_works guessed because of cross compilation" >&5 $as_echo "$as_me: WARNING: result $ac_cv_func_vfork_works guessed because of cross compilation" >&2;} fi if test "x$ac_cv_func_vfork_works" = xyes; then $as_echo "#define HAVE_WORKING_VFORK 1" >>confdefs.h else $as_echo "#define vfork fork" >>confdefs.h fi if test "x$ac_cv_func_fork_works" = xyes; then $as_echo "#define HAVE_WORKING_FORK 1" >>confdefs.h fi if test $ac_cv_c_compiler_gnu = yes; then { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC needs -traditional" >&5 $as_echo_n "checking whether $CC needs -traditional... " >&6; } if ${ac_cv_prog_gcc_traditional+:} false; then : $as_echo_n "(cached) " >&6 else ac_pattern="Autoconf.*'x'" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include Autoconf TIOCGETP _ACEOF if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | $EGREP "$ac_pattern" >/dev/null 2>&1; then : ac_cv_prog_gcc_traditional=yes else ac_cv_prog_gcc_traditional=no fi rm -f conftest* if test $ac_cv_prog_gcc_traditional = no; then cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include Autoconf TCGETA _ACEOF if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | $EGREP "$ac_pattern" >/dev/null 2>&1; then : ac_cv_prog_gcc_traditional=yes fi rm -f conftest* fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_gcc_traditional" >&5 $as_echo "$ac_cv_prog_gcc_traditional" >&6; } if test $ac_cv_prog_gcc_traditional = yes; then CC="$CC -traditional" fi fi for ac_header in stdlib.h do : ac_fn_c_check_header_mongrel "$LINENO" "stdlib.h" "ac_cv_header_stdlib_h" "$ac_includes_default" if test "x$ac_cv_header_stdlib_h" = xyes; then : cat >>confdefs.h <<_ACEOF #define HAVE_STDLIB_H 1 _ACEOF fi done { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GNU libc compatible malloc" >&5 $as_echo_n "checking for GNU libc compatible malloc... " >&6; } if ${ac_cv_func_malloc_0_nonnull+:} false; then : $as_echo_n "(cached) " >&6 else if test "$cross_compiling" = yes; then : ac_cv_func_malloc_0_nonnull=no else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #if defined STDC_HEADERS || defined HAVE_STDLIB_H # include #else char *malloc (); #endif int main () { return ! malloc (0); ; return 0; } _ACEOF if ac_fn_c_try_run "$LINENO"; then : ac_cv_func_malloc_0_nonnull=yes else ac_cv_func_malloc_0_nonnull=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 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_malloc_0_nonnull" >&5 $as_echo "$ac_cv_func_malloc_0_nonnull" >&6; } if test $ac_cv_func_malloc_0_nonnull = yes; then : $as_echo "#define HAVE_MALLOC 1" >>confdefs.h else $as_echo "#define HAVE_MALLOC 0" >>confdefs.h case " $LIBOBJS " in *" malloc.$ac_objext "* ) ;; *) LIBOBJS="$LIBOBJS malloc.$ac_objext" ;; esac $as_echo "#define malloc rpl_malloc" >>confdefs.h fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking for working memcmp" >&5 $as_echo_n "checking for working memcmp... " >&6; } if ${ac_cv_func_memcmp_working+:} false; then : $as_echo_n "(cached) " >&6 else if test "$cross_compiling" = yes; then : ac_cv_func_memcmp_working=no else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $ac_includes_default int main () { /* Some versions of memcmp are not 8-bit clean. */ char c0 = '\100', c1 = '\200', c2 = '\201'; if (memcmp(&c0, &c2, 1) >= 0 || memcmp(&c1, &c2, 1) >= 0) return 1; /* The Next x86 OpenStep bug shows up only when comparing 16 bytes or more and with at least one buffer not starting on a 4-byte boundary. William Lewis provided this test program. */ { char foo[21]; char bar[21]; int i; for (i = 0; i < 4; i++) { char *a = foo + i; char *b = bar + i; strcpy (a, "--------01111111"); strcpy (b, "--------10000000"); if (memcmp (a, b, 16) >= 0) return 1; } return 0; } ; return 0; } _ACEOF if ac_fn_c_try_run "$LINENO"; then : ac_cv_func_memcmp_working=yes else ac_cv_func_memcmp_working=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 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_memcmp_working" >&5 $as_echo "$ac_cv_func_memcmp_working" >&6; } test $ac_cv_func_memcmp_working = no && case " $LIBOBJS " in *" memcmp.$ac_objext "* ) ;; *) LIBOBJS="$LIBOBJS memcmp.$ac_objext" ;; esac for ac_header in $ac_header_list 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_func in getpagesize do : ac_fn_c_check_func "$LINENO" "getpagesize" "ac_cv_func_getpagesize" if test "x$ac_cv_func_getpagesize" = xyes; then : cat >>confdefs.h <<_ACEOF #define HAVE_GETPAGESIZE 1 _ACEOF fi done { $as_echo "$as_me:${as_lineno-$LINENO}: checking for working mmap" >&5 $as_echo_n "checking for working mmap... " >&6; } if ${ac_cv_func_mmap_fixed_mapped+:} false; then : $as_echo_n "(cached) " >&6 else if test "$cross_compiling" = yes; then : ac_cv_func_mmap_fixed_mapped=no else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $ac_includes_default /* malloc might have been renamed as rpl_malloc. */ #undef malloc /* Thanks to Mike Haertel and Jim Avera for this test. Here is a matrix of mmap possibilities: mmap private not fixed mmap private fixed at somewhere currently unmapped mmap private fixed at somewhere already mapped mmap shared not fixed mmap shared fixed at somewhere currently unmapped mmap shared fixed at somewhere already mapped For private mappings, we should verify that changes cannot be read() back from the file, nor mmap's back from the file at a different address. (There have been systems where private was not correctly implemented like the infamous i386 svr4.0, and systems where the VM page cache was not coherent with the file system buffer cache like early versions of FreeBSD and possibly contemporary NetBSD.) For shared mappings, we should conversely verify that changes get propagated back to all the places they're supposed to be. Grep wants private fixed already mapped. The main things grep needs to know about mmap are: * does it exist and is it safe to write into the mmap'd area * how to use it (BSD variants) */ #include #include #if !defined STDC_HEADERS && !defined HAVE_STDLIB_H char *malloc (); #endif /* This mess was copied from the GNU getpagesize.h. */ #ifndef HAVE_GETPAGESIZE # ifdef _SC_PAGESIZE # define getpagesize() sysconf(_SC_PAGESIZE) # else /* no _SC_PAGESIZE */ # ifdef HAVE_SYS_PARAM_H # include # ifdef EXEC_PAGESIZE # define getpagesize() EXEC_PAGESIZE # else /* no EXEC_PAGESIZE */ # ifdef NBPG # define getpagesize() NBPG * CLSIZE # ifndef CLSIZE # define CLSIZE 1 # endif /* no CLSIZE */ # else /* no NBPG */ # ifdef NBPC # define getpagesize() NBPC # else /* no NBPC */ # ifdef PAGESIZE # define getpagesize() PAGESIZE # endif /* PAGESIZE */ # endif /* no NBPC */ # endif /* no NBPG */ # endif /* no EXEC_PAGESIZE */ # else /* no HAVE_SYS_PARAM_H */ # define getpagesize() 8192 /* punt totally */ # endif /* no HAVE_SYS_PARAM_H */ # endif /* no _SC_PAGESIZE */ #endif /* no HAVE_GETPAGESIZE */ int main () { char *data, *data2, *data3; const char *cdata2; int i, pagesize; int fd, fd2; pagesize = getpagesize (); /* First, make a file with some known garbage in it. */ data = (char *) malloc (pagesize); if (!data) return 1; for (i = 0; i < pagesize; ++i) *(data + i) = rand (); umask (0); fd = creat ("conftest.mmap", 0600); if (fd < 0) return 2; if (write (fd, data, pagesize) != pagesize) return 3; close (fd); /* Next, check that the tail of a page is zero-filled. File must have non-zero length, otherwise we risk SIGBUS for entire page. */ fd2 = open ("conftest.txt", O_RDWR | O_CREAT | O_TRUNC, 0600); if (fd2 < 0) return 4; cdata2 = ""; if (write (fd2, cdata2, 1) != 1) return 5; data2 = (char *) mmap (0, pagesize, PROT_READ | PROT_WRITE, MAP_SHARED, fd2, 0L); if (data2 == MAP_FAILED) return 6; for (i = 0; i < pagesize; ++i) if (*(data2 + i)) return 7; close (fd2); if (munmap (data2, pagesize)) return 8; /* Next, try to mmap the file at a fixed address which already has something else allocated at it. If we can, also make sure that we see the same garbage. */ fd = open ("conftest.mmap", O_RDWR); if (fd < 0) return 9; if (data2 != mmap (data2, pagesize, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_FIXED, fd, 0L)) return 10; for (i = 0; i < pagesize; ++i) if (*(data + i) != *(data2 + i)) return 11; /* Finally, make sure that changes to the mapped area do not percolate back to the file as seen by read(). (This is a bug on some variants of i386 svr4.0.) */ for (i = 0; i < pagesize; ++i) *(data2 + i) = *(data2 + i) + 1; data3 = (char *) malloc (pagesize); if (!data3) return 12; if (read (fd, data3, pagesize) != pagesize) return 13; for (i = 0; i < pagesize; ++i) if (*(data + i) != *(data3 + i)) return 14; close (fd); return 0; } _ACEOF if ac_fn_c_try_run "$LINENO"; then : ac_cv_func_mmap_fixed_mapped=yes else ac_cv_func_mmap_fixed_mapped=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 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_mmap_fixed_mapped" >&5 $as_echo "$ac_cv_func_mmap_fixed_mapped" >&6; } if test $ac_cv_func_mmap_fixed_mapped = yes; then $as_echo "#define HAVE_MMAP 1" >>confdefs.h fi rm -f conftest.mmap conftest.txt for ac_header in stdlib.h do : ac_fn_c_check_header_mongrel "$LINENO" "stdlib.h" "ac_cv_header_stdlib_h" "$ac_includes_default" if test "x$ac_cv_header_stdlib_h" = xyes; then : cat >>confdefs.h <<_ACEOF #define HAVE_STDLIB_H 1 _ACEOF fi done { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GNU libc compatible realloc" >&5 $as_echo_n "checking for GNU libc compatible realloc... " >&6; } if ${ac_cv_func_realloc_0_nonnull+:} false; then : $as_echo_n "(cached) " >&6 else if test "$cross_compiling" = yes; then : ac_cv_func_realloc_0_nonnull=no else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #if defined STDC_HEADERS || defined HAVE_STDLIB_H # include #else char *realloc (); #endif int main () { return ! realloc (0, 0); ; return 0; } _ACEOF if ac_fn_c_try_run "$LINENO"; then : ac_cv_func_realloc_0_nonnull=yes else ac_cv_func_realloc_0_nonnull=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 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_realloc_0_nonnull" >&5 $as_echo "$ac_cv_func_realloc_0_nonnull" >&6; } if test $ac_cv_func_realloc_0_nonnull = yes; then : $as_echo "#define HAVE_REALLOC 1" >>confdefs.h else $as_echo "#define HAVE_REALLOC 0" >>confdefs.h case " $LIBOBJS " in *" realloc.$ac_objext "* ) ;; *) LIBOBJS="$LIBOBJS realloc.$ac_objext" ;; esac $as_echo "#define realloc rpl_realloc" >>confdefs.h fi for ac_header in sys/select.h sys/socket.h do : as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh` ac_fn_c_check_header_mongrel "$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 { $as_echo "$as_me:${as_lineno-$LINENO}: checking types of arguments for select" >&5 $as_echo_n "checking types of arguments for select... " >&6; } if ${ac_cv_func_select_args+:} false; then : $as_echo_n "(cached) " >&6 else for ac_arg234 in 'fd_set *' 'int *' 'void *'; do for ac_arg1 in 'int' 'size_t' 'unsigned long int' 'unsigned int'; do for ac_arg5 in 'struct timeval *' 'const struct timeval *'; do cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $ac_includes_default #ifdef HAVE_SYS_SELECT_H # include #endif #ifdef HAVE_SYS_SOCKET_H # include #endif int main () { extern int select ($ac_arg1, $ac_arg234, $ac_arg234, $ac_arg234, $ac_arg5); ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_cv_func_select_args="$ac_arg1,$ac_arg234,$ac_arg5"; break 3 fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext done done done # Provide a safe default value. : "${ac_cv_func_select_args=int,int *,struct timeval *}" fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_select_args" >&5 $as_echo "$ac_cv_func_select_args" >&6; } ac_save_IFS=$IFS; IFS=',' set dummy `echo "$ac_cv_func_select_args" | sed 's/\*/\*/g'` IFS=$ac_save_IFS shift cat >>confdefs.h <<_ACEOF #define SELECT_TYPE_ARG1 $1 _ACEOF cat >>confdefs.h <<_ACEOF #define SELECT_TYPE_ARG234 ($2) _ACEOF cat >>confdefs.h <<_ACEOF #define SELECT_TYPE_ARG5 ($3) _ACEOF rm -f conftest* { $as_echo "$as_me:${as_lineno-$LINENO}: checking return type of signal handlers" >&5 $as_echo_n "checking return type of signal handlers... " >&6; } if ${ac_cv_type_signal+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include int main () { return *(signal (0, 0)) (0) == 1; ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_cv_type_signal=int else ac_cv_type_signal=void fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_type_signal" >&5 $as_echo "$ac_cv_type_signal" >&6; } cat >>confdefs.h <<_ACEOF #define RETSIGTYPE $ac_cv_type_signal _ACEOF { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether lstat correctly handles trailing slash" >&5 $as_echo_n "checking whether lstat correctly handles trailing slash... " >&6; } if ${ac_cv_func_lstat_dereferences_slashed_symlink+:} false; then : $as_echo_n "(cached) " >&6 else rm -f conftest.sym conftest.file echo >conftest.file if test "$as_ln_s" = "ln -s" && ln -s conftest.file conftest.sym; then if test "$cross_compiling" = yes; then : ac_cv_func_lstat_dereferences_slashed_symlink=no else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $ac_includes_default int main () { struct stat sbuf; /* Linux will dereference the symlink and fail, as required by POSIX. That is better in the sense that it means we will not have to compile and use the lstat wrapper. */ return lstat ("conftest.sym/", &sbuf) == 0; ; return 0; } _ACEOF if ac_fn_c_try_run "$LINENO"; then : ac_cv_func_lstat_dereferences_slashed_symlink=yes else ac_cv_func_lstat_dereferences_slashed_symlink=no fi rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi else # If the `ln -s' command failed, then we probably don't even # have an lstat function. ac_cv_func_lstat_dereferences_slashed_symlink=no fi rm -f conftest.sym conftest.file fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_lstat_dereferences_slashed_symlink" >&5 $as_echo "$ac_cv_func_lstat_dereferences_slashed_symlink" >&6; } test $ac_cv_func_lstat_dereferences_slashed_symlink = yes && cat >>confdefs.h <<_ACEOF #define LSTAT_FOLLOWS_SLASHED_SYMLINK 1 _ACEOF if test "x$ac_cv_func_lstat_dereferences_slashed_symlink" = xno; then case " $LIBOBJS " in *" lstat.$ac_objext "* ) ;; *) LIBOBJS="$LIBOBJS lstat.$ac_objext" ;; esac fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether stat accepts an empty string" >&5 $as_echo_n "checking whether stat accepts an empty string... " >&6; } if ${ac_cv_func_stat_empty_string_bug+:} false; then : $as_echo_n "(cached) " >&6 else if test "$cross_compiling" = yes; then : ac_cv_func_stat_empty_string_bug=yes else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $ac_includes_default int main () { struct stat sbuf; return stat ("", &sbuf) == 0; ; return 0; } _ACEOF if ac_fn_c_try_run "$LINENO"; then : ac_cv_func_stat_empty_string_bug=no else ac_cv_func_stat_empty_string_bug=yes fi rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_stat_empty_string_bug" >&5 $as_echo "$ac_cv_func_stat_empty_string_bug" >&6; } if test $ac_cv_func_stat_empty_string_bug = yes; then case " $LIBOBJS " in *" stat.$ac_objext "* ) ;; *) LIBOBJS="$LIBOBJS stat.$ac_objext" ;; esac cat >>confdefs.h <<_ACEOF #define HAVE_STAT_EMPTY_STRING_BUG 1 _ACEOF fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking for working strtod" >&5 $as_echo_n "checking for working strtod... " >&6; } if ${ac_cv_func_strtod+:} false; then : $as_echo_n "(cached) " >&6 else if test "$cross_compiling" = yes; then : ac_cv_func_strtod=no else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $ac_includes_default #ifndef strtod double strtod (); #endif int main() { { /* Some versions of Linux strtod mis-parse strings with leading '+'. */ char *string = " +69"; char *term; double value; value = strtod (string, &term); if (value != 69 || term != (string + 4)) return 1; } { /* Under Solaris 2.4, strtod returns the wrong value for the terminating character under some conditions. */ char *string = "NaN"; char *term; strtod (string, &term); if (term != string && *(term - 1) == 0) return 1; } return 0; } _ACEOF if ac_fn_c_try_run "$LINENO"; then : ac_cv_func_strtod=yes else ac_cv_func_strtod=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 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_strtod" >&5 $as_echo "$ac_cv_func_strtod" >&6; } if test $ac_cv_func_strtod = no; then case " $LIBOBJS " in *" strtod.$ac_objext "* ) ;; *) LIBOBJS="$LIBOBJS strtod.$ac_objext" ;; esac ac_fn_c_check_func "$LINENO" "pow" "ac_cv_func_pow" if test "x$ac_cv_func_pow" = xyes; then : fi if test $ac_cv_func_pow = no; then { $as_echo "$as_me:${as_lineno-$LINENO}: checking for pow in -lm" >&5 $as_echo_n "checking for pow in -lm... " >&6; } if ${ac_cv_lib_m_pow+:} false; then : $as_echo_n "(cached) " >&6 else ac_check_lib_save_LIBS=$LIBS LIBS="-lm $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 pow (); int main () { return pow (); ; return 0; } _ACEOF if ac_fn_c_try_link "$LINENO"; then : ac_cv_lib_m_pow=yes else ac_cv_lib_m_pow=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_m_pow" >&5 $as_echo "$ac_cv_lib_m_pow" >&6; } if test "x$ac_cv_lib_m_pow" = xyes; then : POW_LIB=-lm else { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cannot find library containing definition of pow" >&5 $as_echo "$as_me: WARNING: cannot find library containing definition of pow" >&2;} fi fi fi for ac_func in floor getcwd gethostbyaddr gethostbyname getpagesize \ memmove memset mkdir putenv socket sqrt \ strcasecmp strchr strerror strtol do : as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh` ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var" if eval test \"x\$"$as_ac_var"\" = x"yes"; then : cat >>confdefs.h <<_ACEOF #define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1 _ACEOF fi done for ac_func in nanosleep alarm times select setenv putenv \ lstat mkstemp sigprocmask isatty tzset \ gettimeofday getrusage do : as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh` ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var" if eval test \"x\$"$as_ac_var"\" = x"yes"; then : cat >>confdefs.h <<_ACEOF #define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1 _ACEOF fi done for ac_func in expf logf sqrtf cosf sinf tanf sinhf coshf tanhf \ floorf ceilf fabsf frexpf ldexpf log1p log1pf log1pl \ copysign do : as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh` ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var" if eval test \"x\$"$as_ac_var"\" = x"yes"; then : cat >>confdefs.h <<_ACEOF #define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1 _ACEOF fi done for ac_func in sched_yield uname fseeko dladdr backtrace backtrace_symbols do : as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh` ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var" if eval test \"x\$"$as_ac_var"\" = x"yes"; then : cat >>confdefs.h <<_ACEOF #define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1 _ACEOF fi done ac_fn_c_check_header_mongrel "$LINENO" "sys/mman.h" "ac_cv_header_sys_mman_h" "$ac_includes_default" if test "x$ac_cv_header_sys_mman_h" = xyes; then : $as_echo "#define ECL_USE_MPROTECT /**/" >>confdefs.h $as_echo "#define HAVE_SYS_MMAN_H /**/" >>confdefs.h fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking working environ" >&5 $as_echo_n "checking working environ... " >&6; } if test -z "$ECL_WORKING_ENVIRON"; then if test "$cross_compiling" = yes; then : { { $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 test program while cross compiling See \`config.log' for more details" "$LINENO" 5; } else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include extern char **environ; int main() { if (environ) exit(0); exit(1); } _ACEOF if ac_fn_c_try_run "$LINENO"; then : ECL_WORKING_ENVIRON=yes else ECL_WORKING_ENVIRON=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 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ECL_WORKING_ENVIRON" >&5 $as_echo "$ECL_WORKING_ENVIRON" >&6; } if test $ECL_WORKING_ENVIRON = yes ; then $as_echo "#define HAVE_ENVIRON /**/" >>confdefs.h fi if test ${with_cxx} = "no" ; then ECL_CC=${CC} CC_IS_CXX="nil" else ECL_CC=${CXX} CC_IS_CXX="t" boehm_configure_flags="${boehm_configure_flags} --enable-cplusplus" fi if test ! ${opcode8} = "no" ; then $as_echo "#define ECL_SMALL_BYTECODES 1" >>confdefs.h fi if test "x${cross_compiling}" != "xyes"; then if test "$cross_compiling" = yes; then : { { $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 test program while cross compiling See \`config.log' for more details" "$LINENO" 5; } else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ void *foo() { return __builtin_return_address(1); } int main() { return (foo() == 0); } _ACEOF if ac_fn_c_try_run "$LINENO"; then : $as_echo "#define HAVE___BUILTIN_RETURN_ADDRESS /**/" >>confdefs.h fi rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi fi case "${enable_libatomic}" in auto|system|included) ;; *) as_fn_error $? "Invalid value of --enable-libatomic: ${enable_libatomic} " "$LINENO" 5;; esac if test "x${enable_threads}" != "xno"; then ac_fn_c_check_header_mongrel "$LINENO" "atomic_ops.h" "ac_cv_header_atomic_ops_h" "$ac_includes_default" if test "x$ac_cv_header_atomic_ops_h" = xyes; then : system_libatomic=yes else system_libatomic=no fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking libatomic-ops version " >&5 $as_echo_n "checking libatomic-ops version ... " >&6; } if test "${enable_libatomic}" = auto; then if test "${system_libatomic}" = yes; then enable_libatomic=system else enable_libatomic=included fi fi if test "${enable_libatomic}" = system; then if test "${system_libatomic}" = no; then as_fn_error $? "Cannot find libatomic-ops in the system " "$LINENO" 5 enable_libatomic=included fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: ${enable_libatomic} " >&5 $as_echo "${enable_libatomic} " >&6; } if test "${enable_libatomic}" = included; then test -d atomic || mkdir atomic (destdir=`${PWDCMD}`; cd atomic && CC="${CC} ${PICFLAG}" \ $srcdir/${ECL_GC_DIR}/libatomic*/configure --disable-shared \ --prefix=${destdir} infodir=${destdir}/doc \ --includedir=${destdir}/ecl --with-pic \ --libdir=${destdir} --build=${build_alias} --host=${host_alias} \ CFLAGS="$CFLAGS" LDFLAGS="$LDFLAGS" CPPFLAGS="$CPPFLAGS" CC="${CC} \ ${PICFLAG}") SUBDIRS="${SUBDIRS} atomic" if test "${enable_shared}" = "no"; then LIBRARIES="${LIBRARIES} ${LIBPREFIX}eclatomic.${LIBEXT}" fi $as_echo "#define ECL_LIBATOMIC_OPS_H /**/" >>confdefs.h CORE_LIBS="-leclatomic ${CORE_LIBS}" else CORE_LIBS="-latomic_ops ${CORE_LIBS}" fi fi if test ${enable_shared} = "yes"; then $as_echo "#define ENABLE_DLOPEN 1" >>confdefs.h LSP_LIBRARIES="${SHAREDPREFIX}ecl.${SHAREDEXT}" LSP_FEATURES="(cons :wants-dlopen ${LSP_FEATURES})" else enable_soname=no LSP_LIBRARIES="${LIBPREFIX}ecl.${LIBEXT}" ECL_LDRPATH='' fi if test "x${enable_rpath}" = "xno"; then ECL_LDRPATH='' fi if test "${with_cmuformat}" = "yes"; then with_clos_streams="yes" $as_echo "#define ECL_CMU_FORMAT 1" >>confdefs.h fi if test "${with_clos_streams}" = "yes"; then $as_echo "#define ECL_CLOS_STREAMS 1" >>confdefs.h fi if test "${with_cmp}" = "builtin"; then LSP_FEATURES="(cons :builtin-cmp ${LSP_FEATURES})" with_cmp=yes fi if test "${with_cmp}" = "yes"; then LSP_FEATURES="(cons :wants-cmp ${LSP_FEATURES})" fi if test "${with_clx}" = "builtin"; then LSP_FEATURES="(cons :builtin-clx ${LSP_FEATURES})" LSP_FEATURES="(cons :builtin-sockets ${LSP_FEATURES})" with_clx=yes fi if test ${with_clx} = "yes"; then tcp="yes" LSP_FEATURES="(cons :wants-clx ${LSP_FEATURES})" CLX_INFO="clx.${INFOEXT}" else CLX_INFO="" fi if test "${with_tcp}" = "builtin"; then LSP_FEATURES="(cons :builtin-sockets ${LSP_FEATURES})" with_tcp=yes fi if test "${with_tcp}" = "yes"; then $as_echo "#define TCP 1" >>confdefs.h EXTRA_OBJS="${EXTRA_OBJS} tcp.${OBJEXT}" LSP_FEATURES="(cons :wants-sockets ${LSP_FEATURES})" LIBS="${LIBS} ${TCPLIBS}" fi if test "${with_serve_event}" = "builtin"; then LSP_FEATURES="(cons :builtin-serve_event ${LSP_FEATURES})" with_serve_event=yes fi if test "${with_serve_event}" = "yes"; then case "${host_os}" in mingw*|cygwin*) ;; *) LSP_FEATURES="(cons :wants-serve-event ${LSP_FEATURES})" ;; esac fi if test "${with_asdf}" = "builtin"; then LSP_FEATURES="(cons :builtin-asdf ${LSP_FEATURES})" with_asdf=yes fi if test "${with_asdf}" = "yes"; then LSP_FEATURES="(cons :wants-asdf ${LSP_FEATURES})" fi if test "${with_defsystem}" = "builtin"; then LSP_FEATURES="(cons :builtin-defsystem ${LSP_FEATURES})" with_defsystem=yes fi if test "${with_defsystem}" = "yes"; then LSP_FEATURES="(cons :wants-defsystem ${LSP_FEATURES})" fi if test "${with_profile}" = "builtin"; then LSP_FEATURES="(cons :builtin-profile ${LSP_FEATURES})" with_profile=yes fi if test "${with_profile}" = "yes"; then if test "${enable_boehm}" != "no"; then LSP_FEATURES="(cons :wants-profile ${LSP_FEATURES})" fi fi if test "${with_bytecmp}" = "builtin"; then LSP_FEATURES="(cons :builtin-bytecmp ${LSP_FEATURES})" with_bytecmp=yes fi if test "${with_bytecmp}" = "yes"; then LSP_FEATURES="(cons :wants-bytecmp ${LSP_FEATURES})" fi if test "${with_rt}" = "builtin"; then LSP_FEATURES="(cons :builtin-rt ${LSP_FEATURES})" with_rt=yes fi if test "${with_rt}" = "yes"; then LSP_FEATURES="(cons :wants-rt ${LSP_FEATURES})" fi if test "x${enable_unicode}" != "xno"; then if test "${enable_unicode}" = 16; then $as_echo "#define ECL_UNICODE 16" >>confdefs.h CHAR_CODE_LIMIT=65536 ECL_CHARACTER=$ECL_INT16_T EXTRA_OBJS="$EXTRA_OBJS unicode/ucd16.o unicode/ucd16-0000.o unicode/ucd16-0016.o unicode/ucd16-0032.o unicode/ucd16-0048.o unicode/ucd16-0064.o" else $as_echo "#define ECL_UNICODE 21" >>confdefs.h CHAR_CODE_LIMIT=1114112 ECL_CHARACTER=$ECL_INT32_T EXTRA_OBJS="$EXTRA_OBJS unicode/ucd.o unicode/ucd-0000.o unicode/ucd-0016.o unicode/ucd-0032.o unicode/ucd-0048.o unicode/ucd-0064.o unicode/ucd-0080.o unicode/ucd-0096.o" fi if test "${with_unicode_names}" = "yes"; then $as_echo "#define ECL_UNICODE_NAMES 1" >>confdefs.h EXTRA_OBJS="$EXTRA_OBJS unicode/ucd_names_char.o unicode/ucd_names_codes.o unicode/ucd_names_pair.o unicode/ucd_names_str.o" fi else CHAR_CODE_LIMIT=256 ECL_CHARACTER="int" fi ECL_EXTRA_LISP_FILES="" for i in $with_extra_files; do ECL_EXTRA_LISP_FILES="${ECL_EXTRA_LISP_FILES} \"$i\"" done echo ${with_init_form} = init form if test "x${with_init_form}" = "x"; then ECL_INIT_FORM='(SI::TOP-LEVEL T)' else ECL_INIT_FORM="${with_init_form}" fi if test "${enable_hpack}" = "yes"; then $as_echo "#define ECL_RELATIVE_PACKAGE_NAMES 1" >>confdefs.h fi ac_config_files="$ac_config_files bare.lsp lsp/load.lsp clos/load.lsp cmp/load.lsp new-cmp/load.lsp ../Makefile Makefile c/Makefile doc/Makefile doc/ecl.man doc/ecl-config.man ecl/configpre.h:h/config.h.in bin/ecl-config.pre:util/ecl-config lsp/config.pre:lsp/config.lsp.in compile.pre:compile.lsp.in cmp/cmpdefs.pre:cmp/cmpdefs.lsp tests/config.lsp tests/Makefile" ac_config_headers="$ac_config_headers ecl/config.h:ecl/configpre.h" 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 : "${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 ecl $as_me 16.1.2, 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" _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 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="\\ ecl config.status 16.1.2 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' 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 _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 "bare.lsp") CONFIG_FILES="$CONFIG_FILES bare.lsp" ;; "lsp/load.lsp") CONFIG_FILES="$CONFIG_FILES lsp/load.lsp" ;; "clos/load.lsp") CONFIG_FILES="$CONFIG_FILES clos/load.lsp" ;; "cmp/load.lsp") CONFIG_FILES="$CONFIG_FILES cmp/load.lsp" ;; "new-cmp/load.lsp") CONFIG_FILES="$CONFIG_FILES new-cmp/load.lsp" ;; "../Makefile") CONFIG_FILES="$CONFIG_FILES ../Makefile" ;; "Makefile") CONFIG_FILES="$CONFIG_FILES Makefile" ;; "c/Makefile") CONFIG_FILES="$CONFIG_FILES c/Makefile" ;; "doc/Makefile") CONFIG_FILES="$CONFIG_FILES doc/Makefile" ;; "doc/ecl.man") CONFIG_FILES="$CONFIG_FILES doc/ecl.man" ;; "doc/ecl-config.man") CONFIG_FILES="$CONFIG_FILES doc/ecl-config.man" ;; "ecl/configpre.h") CONFIG_FILES="$CONFIG_FILES ecl/configpre.h:h/config.h.in" ;; "bin/ecl-config.pre") CONFIG_FILES="$CONFIG_FILES bin/ecl-config.pre:util/ecl-config" ;; "lsp/config.pre") CONFIG_FILES="$CONFIG_FILES lsp/config.pre:lsp/config.lsp.in" ;; "compile.pre") CONFIG_FILES="$CONFIG_FILES compile.pre:compile.lsp.in" ;; "cmp/cmpdefs.pre") CONFIG_FILES="$CONFIG_FILES cmp/cmpdefs.pre:cmp/cmpdefs.lsp" ;; "tests/config.lsp") CONFIG_FILES="$CONFIG_FILES tests/config.lsp" ;; "tests/Makefile") CONFIG_FILES="$CONFIG_FILES tests/Makefile" ;; "ecl/config.h") CONFIG_HEADERS="$CONFIG_HEADERS ecl/config.h:ecl/configpre.h" ;; *) 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 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 " 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 _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 $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 ;; 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 for i in $srcdir/c/*/; do mkdir c/`basename $i`; done ecl-16.1.2/src/configure.ac000066400000000000000000000734341266352375300154500ustar00rootroot00000000000000dnl dnl dnl This is an autoconf script. dnl To rebuild the `configure' script from this, execute the command dnl autoconf dnl in the directory containing this script. dnl dnl AUTOCONF configuration for ECL dnl Giuseppe Attardi 25.1.1994 dnl AC_INIT([ecl],[16.1.2],[]) AC_REVISION([$Revision$]) AC_CONFIG_SRCDIR([bare.lsp.in]) AC_CONFIG_AUX_DIR([gmp]) AC_PREREQ(2.69) dnl ----------------------------------------------------------------------- dnl Make sure we do not configure within source directory if test -f configure; then AC_MSG_ERROR([This program cannot be built within the source directory]) fi dnl ----------------------------------------------------------------------- dnl Configure switches AC_ARG_WITH(cross_config, AS_HELP_STRING( [--with-cross-config=f], [supply configuration for a cross compiler]), [], [with_cross_config="`pwd`/cross_config"]) AC_ARG_ENABLE(shared, AS_HELP_STRING( [--enable-shared], [enable loading compiled files (default=YES)]), [], [enable_shared=yes]) AC_ARG_ENABLE(rpath, AS_HELP_STRING( [--enable-rpath], [hard-code the location of the ECL shared library.] [(no|yes, default=NO)]), [], [enable_rpath=yes] ) AC_ARG_ENABLE(threads, AS_HELP_STRING( [--enable-threads], [support for native threads (yes|no|auto, default=auto).]), [], [enable_threads=auto]) AC_ARG_ENABLE(boehm, AS_HELP_STRING( [--enable-boehm], [use the Boehm-Weiser garbage collector] [(no|included|system|auto, default=auto)] ), [], [enable_boehm=auto] ) AC_ARG_ENABLE(libatomic, AS_HELP_STRING( [--enable-libatomic], [version of the libatomic-ops library] [(auto|included|system, default=auto)] ), [], [enable_libatomic=auto] ) AC_ARG_ENABLE(soname, AS_HELP_STRING( [--enable-soname], [link and install the library using version numbers] [(no|yes, default=yes)]), [], [enable_soname=yes] ) AC_ARG_WITH(gmp, AS_HELP_STRING( [--with-gmp=args], [supply arguments for configuring GMP library]), [], [with_gmp=""]) AC_ARG_WITH(C-gmp, AS_HELP_STRING( [--with-C-gmp=args], [configure GMP to build using portable C]), [with_c_gmp=yes; with_system_gmp=no], [with_c_gmp=no]) AC_ARG_WITH(system-gmp, AS_HELP_STRING( [--with-system-gmp], [use already installed GMP library (default=auto)]), [], [with_system_gmp="auto"]) AC_ARG_WITH(gmp-prefix, AS_HELP_STRING( [--with-gmp-prefix=path], [prefix for system GMP includes and libraries] ), [GMP_INCDIR="$withval/include"; GMP_LIBDIR="$withval/lib"], []) AC_ARG_WITH(gmp-incdir, AS_HELP_STRING( [--with-gmp-incdir=path], [path to system GMP includes (overrides prefix)] ), [GMP_INCDIR="$withval"], []) AC_ARG_WITH(gmp-libdir, AS_HELP_STRING( [--with-gmp-libdir=path], [path to system GMP libraries (overrides prefix)] ), [GMP_LIBDIR="$withval"], []) AC_ARG_ENABLE(local-gmp, AS_HELP_STRING( [--enable-local-gmp], [Deprecated! See --with-system-gmp]), [AC_MSG_WARN( [--with-local-gmp is deprecated, use --with-system-gmp instead!]) with_system_gmp="${enableval}"]) AC_ARG_WITH(libffi-prefix, AS_HELP_STRING( [--with-libffi-prefix=path], [prefix for system LIBFFI includes and libraries] ), [LIBFFI_INCDIR="$withval/include"; LIBFFI_LIBDIR="$withval/lib"], []) AC_ARG_WITH(__thread, AS_HELP_STRING( [--with-__thread], [Enable __thread thread-local variables (yes|NO|auto)] [(supported by NPTL-aware glibc and maybe Windows)] ), [], [with___thread=no]) AC_ARG_ENABLE(opcode8, AS_HELP_STRING( [--enable-opcode8], [interpreter uses 8-bit codes] [(default=NO, only works on Intel)]), [opcode8=${enableval}], [opcode8=no]) AC_ARG_WITH(cxx, AS_HELP_STRING( [--with-cxx], [build ECL using C++ compiler (default=NO)]), [], [with_cxx=no]) AC_ARG_WITH(tcp, AS_HELP_STRING( [--with-tcp], [include socket interface (yes|builtin|no, default=YES)]), [], [with_tcp=yes]) AC_ARG_WITH(serve_event, AS_HELP_STRING( [--with-serve-event], [include serve-event module (yes|builtin|no, default=YES)]), [], [with_serve_event=${enable_shared}]) AC_ARG_WITH(clx, AS_HELP_STRING( [--with-clx], [include CLX library (yes|builtin|no, default=NO)]), [], [with_clx=no]) AC_ARG_WITH(clos-streams, AS_HELP_STRING( [--with-clos-streams], [user defined stream objects (yes|builtin|no, default=YES)]), [], [with_clos_streams=yes]) AC_ARG_WITH(cmuformat, AS_HELP_STRING( [--with-cmuformat], [use CMUCL's FORMAT routine (default=YES)]), [], [with_cmuformat=${with_clos_streams}]) AC_ARG_WITH(asdf, AS_HELP_STRING( [--with-asdf], [include ASDF building facility] [(yes|builtin|no, default=YES)]), [], [with_asdf=yes]) AC_ARG_WITH(defsystem, AS_HELP_STRING( [--with-defsystem], [include DEFSYSTEM building facility] [(yes|builtin|no, default=YES)]), [], [with_defsystem=yes]) AC_ARG_WITH(cmp, AS_HELP_STRING( [--with-cmp], [build the compiler (yes|builtin|no, default=YES)] ), [], [with_cmp=yes]) AC_ARG_WITH(bytecmp, AS_HELP_STRING( [--with-bytecmp], [build the bytecodes compiler (yes|builtin|no, default=YES)] ), [], [with_bytecmp=yes]) AC_ARG_WITH(rt, AS_HELP_STRING( [--with-rt], [include MIT-RT testing environment] [(yes|builtin|no, default=YES)]), [], [with_rt=yes]) AC_ARG_WITH(profile, AS_HELP_STRING( [--with-profile], [include CMUCL's simple profiler] [(yes|builtin|no, default=YES if Boehm-Weiser garbage collector used)]), [], [with_profile=yes]) AC_ARG_WITH(dffi, AS_HELP_STRING( [--with-dffi], [dynamic foreign function interface] [(system|included|auto|no, default=AUTO if libffi available)]), [enable_libffi=${withval}], [enable_libffi=auto]) AC_ARG_WITH(fpe, AS_HELP_STRING( [--with-fpe], [detect floating point exceptions] [(default=YES)]), [], [with_fpe=yes]) AC_ARG_WITH(signed-zero, AS_HELP_STRING( [--with-signed-zero={yes|no}], [allow for IEEE signed zeros (default=YES).]), [], [with_signed_zero="yes"]) AC_ARG_WITH(ieee-fp, AS_HELP_STRING( [--with-ieee-fp={yes|no}], [full IEEE floating point system, including denormals (default=YES).] [Implies signed-zero and fpe]), [], [with_ieee_fp="yes"]) AC_ARG_WITH(sse, AS_HELP_STRING( [--with-sse={yes|no|auto}], [implement SSE intrinsics in ECL (default=NO).] [Only works when supported by the compiler]), [], [with_sse="no"]) AC_ARG_ENABLE(unicode, AS_HELP_STRING( [--enable-unicode={yes|no|32}], [enable support for unicode (default=YES)]), [], [enable_unicode=yes]) AC_ARG_ENABLE(longdouble, AS_HELP_STRING( [--enable-longdouble], [include support for long double] [(yes|no|auto, default=AUTO)]), [enable_longdouble=${enableval}], [enable_longdouble=yes]) AC_ARG_ENABLE(c99complex, AS_HELP_STRING( [--enable-c99complex], [include support for C complex type] [(default=NO)]), [enable_c99complex=${enableval}], [enable_c99complex=no]) AC_ARG_ENABLE(hpack, AS_HELP_STRING( [--enable-hpack], [hierarchical package names] [(default=YES)]), [enable_hpack=${enableval}], [enable_hpack=yes]) AC_ARG_ENABLE(asmapply, AS_HELP_STRING( [--enable-asmapply], [enable optimizations written in assembler, EXPERIMENTAL] [(default=NO)]), [enable_asmapply=${enableval}],[enable_asmapply=no]) AC_ARG_ENABLE(smallcons, AS_HELP_STRING( [--enable-smallcons], [use small (2 words) cons types. Requires Boehm-Weiser gc.] [(default=YES)]), [enable_smallcons=${enableval}],[enable_smallcons=yes]) AC_ARG_ENABLE(gengc, AS_HELP_STRING( [--enable-gengc], [use generational garbage collection. Requires Boehm-Weiser gc.] [(no|yes, default=NO)]), [enable_gengc=${enableval}], [enable_gengc=no] ) AC_ARG_ENABLE(precisegc, AS_HELP_STRING( [--enable-precisegc], [use type information during garbage collection. Requires Boehm-Weiser gc (EXPERIMENTAL).] [(no|yes, default=NO)]), [enable_precisegc=${enableval}], [enable_precisegc=no] ) AC_ARG_ENABLE(debug, AS_HELP_STRING( [--enable-debug], [enable various debugging features] [(default=NO)]), [DEBUG_CFLAGS="-g -O0"; CFLAGS="$CFLAGS -g -O0"],[]) AC_ARG_WITH(debug-cflags, AS_HELP_STRING( [--with-debug-cflags], [add debug flags to the compiler invocation] [(yes,no,actual flags,default=YES)]), [],[with_debug_cflags="no"]) AC_ARG_WITH(profile-cflags, AS_HELP_STRING( [--with-profile-cflags], [add profiling flags to the compiler invocation] [(yes,no,actual flags,default=NO)]), [],[with_profile_cflags="no"]) AC_ARG_WITH(newcmp, AS_HELP_STRING( [--with-newcmp], [new compiler (yes|no, default=NO)]), [], [with_newcmp=no]) AC_ARG_WITH(extra-files, AS_HELP_STRING( [--with-extra-files], [list of additional source files (default="")]), [with_extra_files="${withval}"], [with_extra_files=""]) AC_ARG_WITH(init-form, AS_HELP_STRING( [--with-init-form], [lisp forms to execute at startup (default="(si::top-level t)")]), [with_init_form="${withval}"], [with_init_form=""]) AC_ARG_WITH(unicode-names, AS_HELP_STRING( [--with-unicode-names], [link in the database of Unicode names] [(YES,no)]), [],[with_unicode_names="yes"]) dnl ----------------------------------------------------------------------- dnl Installation directories AC_ARG_VAR([ecldir], [the directory where *.fas files are installed]) test -z "${ecldir}" && ecldir="${libdir}/ecl-${PACKAGE_VERSION}" AC_SUBST([ecldir]) AC_ARG_VAR([docdir], [the directory where documentation is installed]) test -z "${docdir}" && docdir="${datadir}/doc/ecl-${PACKAGE_VERSION}" AC_SUBST([docdir]) dnl ----------------------------------------------------------------------- dnl Initialize variables. boehm_configure_flags="" AC_EXEEXT dnl Guess whether .exe is needed for executables AC_SUBST(buildir) dnl For top-level Makefile.in AC_SUBST(ECL_CFLAGS) dnl Similar, but specific to ECL (see src/util/ecl-config) AC_SUBST(DEBUG_CFLAGS) AC_SUBST(GMP_CPPFLAGS) dnl CFLAGS needed for compiling with system GMP library AC_SUBST(GMP_LDFLAGS) dnl LDFLAGS needed for compiling with system GMP library AC_SUBST(LIBFFI_LDFLAGS) dnl LDFLAGS needed for compiling with system LIBFFI library AC_SUBST(FASL_LIBS) dnl Libraries to link into all ecl code but not dnl into helper programs. AC_SUBST(CORE_LIBS, []) dnl Locally compiled libs to link into dnl ecl/ecl_min/libecl.so and nowhere else. AC_SUBST(SHARED_LDFLAGS) dnl Flags for shared libraries linker AC_SUBST(BUNDLE_LDFLAGS) dnl Flags for FASL files linker AC_SUBST(EXTRA_OBJS) dnl Extra *.o files to be compiled into libecl.a AC_SUBST(TARGETS, ['bin/ecl$(EXE)'])dnl Versions of ECL to be built AC_SUBST(SUBDIRS, [c]) dnl Subdirectories that make should process AC_SUBST(LIBRARIES, []) dnl GMP, Boehm's GC, etc AC_SUBST(LSP_LIBRARIES) dnl Libraries produced by lisp translator AC_SUBST(LSP_FEATURES, ['*features*']) dnl Symbols to add to *FEATURES* for conditional compilation dnl ----------------------------------------------------------------------- dnl Guess operating system of host. We do not allow cross-compiling. AC_CANONICAL_BUILD AC_CANONICAL_HOST dnl ===================================================================== dnl Checks for programs AC_PROG_CC # sets variable CC AC_PROG_CXX # sets variable CXX AC_PROG_CPP # sets variable CPP AC_PROG_RANLIB # sets variable RANLIB AC_PROG_INSTALL # sets variables INSTALL, INSTALL_DATA, INSTALL_PROGRAM AC_PROG_LN_S # sets variable LN_S AC_PROG_MAKE_SET # set $(MAKE) if needed AC_PROG_RANLIB # set variable RANLIB AC_CHECK_TOOL([AR],[ar]) # set variable AR to appropriate `ar' program AC_CHECK_PROGS([ETAGS],[etags emacs-etags]) # set variable ETAGS to etags program if found dnl ----------------------------------------------------------------------- dnl Checks which do not come with autoconf (must be after AC_PROG_CC) ECL_MAKE_ABSOLUTE_SRCDIR ECL_CROSS_CONFIG ECL_GUESS_HOST_OS ECL___THREAD AC_SUBST(INFOEXT) AC_SUBST(INSTALL_INFO) AC_PATH_PROG([INSTALL_INFO], [install-info], [/bin/true], [$PATH:/sbin:/usr/sbin:/usr/etc]) if test -z `which gzip`; then INFOEXT=info.gz else INFOEXT=info fi dnl ====================================================================== dnl GNU multiprecision library dnl dnl This a multi-stage process. First we have to detect whether we must build dnl the GMP library. If this is the case, then we may have to detect the dnl build flags for the library, because GMP may choose to build for 64 dnl or 32 bits executables and ECL has to be compiled / linked using precisely dnl the same flags dnl if test "x$GMP_INCDIR" != "x"; then GMP_CPPFLAGS="-I$GMP_INCDIR" fi if test "x$GMP_LIBDIR" != "x"; then GMP_LDFLAGS="-L$GMP_LIBDIR" if test "$enable_rpath" = "yes"; then if (echo "$ECL_LDRPATH" | grep '~A') > /dev/null; then GMP_LDFLAGS=`echo $ECL_LDRPATH | sed "s,~A,$GMP_LIBDIR,"`" $GMP_LDFLAGS" fi fi fi CPPFLAGS="$CPPFLAGS $GMP_CPPFLAGS" LDFLAGS="$LDFLAGS $GMP_LDFLAGS" if test ${with_system_gmp} = "auto"; then AC_CHECK_LIB( [gmp], [__gmpz_init], [with_system_gmp=yes], [with_system_gmp=no] ) fi ECL_GMP_HEADER= if test "${with_system_gmp}" = "yes"; then AC_CHECK_LIB( [gmp], [__gmpz_init], [FASL_LIBS="${FASL_LIBS} -lgmp"], [AC_MSG_ERROR([System gmp library requested but not found.])]) AC_CHECK_HEADER( [gmp.h], [ECL_GMP_HEADER='gmp.h'] ) if test "x$ECL_GMP_HEADER" = "x"; then AC_CHECK_HEADER( [gmp/gmp.h], [ECL_GMP_HEADER='gmp/gmp.h'] ) fi else SUBDIRS="${SUBDIRS} gmp" CORE_LIBS="-leclgmp ${CORE_LIBS}" if test ${enable_shared} = "no"; then LIBRARIES="${LIBRARIES} ${LIBPREFIX}eclgmp.${LIBEXT}" fi fi dnl ---------------------------------------------------------------------- dnl Configure local GMP if needed AC_SUBST(ECL_GMP_HEADER) EXTRA_OBJS="${EXTRA_OBJS} big.o" if test "x${with_system_gmp}" = "xno" ; then AC_MSG_NOTICE(Configuring included GMP library:) test -d gmp && rm -rf gmp if test -z "$gmp_build"; then gmp_build="${build}" fi if test "x$with_c_gmp" = "xyes"; then gmp_build=`echo ${gmp_build} | sed 's,@<:@^-@:>@*\(-.*\),none\1,'` echo '***' echo '***' BUILDING GMP WITH C! echo '***' This is a last resort, either because of license or echo '***' porting issues. echo '***' fi ECL_GMP_HEADER='ecl/gmp.h' if test "x$ABI" = "x"; then GMP_ABI="" else GMP_ABI="ABI=$ABI" fi mkdir gmp dnl Notice we need -DPIC to force the assembler to generate PIC code (destdir=`${PWDCMD}`; cd gmp && CC="${CC} ${PICFLAG}" \ NM=nm $srcdir/gmp/configure --disable-shared --prefix=${destdir} \ -infodir=${destdir}/doc --includedir=${destdir}/ecl --with-pic \ --libdir=${destdir} --build=${gmp_build} --host=${host_alias} \ CFLAGS="$CFLAGS" LDFLAGS="$LDFLAGS" CPPFLAGS="$CPPFLAGS" CC="${CC} ${PICFLAG}" \ "$GMP_ABI" $with_gmp) if test ! -f gmp/config.status; then AC_MSG_ERROR([Failed to configure the GMP library.]) fi else if test "x$ECL_GMP_HEADER" = "x"; then AC_MSG_ERROR([Can not find GMP header.]) fi fi dnl ----------------------------------------------------------------------- dnl GMP-based search of C/C++ compiler and linker flags AC_MSG_CHECKING([GMP autoconf]) AC_MSG_RESULT(["${with_system_gmp}.${enable_slow_config}"]) if test "x${enable_slow_config}" = "xyes"; then with_system_gmp=no fi if test "x${with_system_gmp}" = "xno"; then ECL_GMP_BASED_CONFIG fi dnl ====================================================================== dnl LIBFFI library if test "x$LIBFFI_INCDIR" != "x"; then LIBFFI_CPPFLAGS="-I$LIBFFI_INCDIR" fi if test "x$LIBFFI_LIBDIR" != "x"; then LIBFFI_LDFLAGS="-L$LIBFFI_LIBDIR" if test "$enable_rpath" = "yes"; then if (echo "$ECL_LDRPATH" | grep '~A') > /dev/null; then LIBFFI_LDFLAGS=`echo $ECL_LDRPATH | sed "s,~A,$LIBFFI_LIBDIR,"`" $LIBFFI_LDFLAGS" fi fi fi CPPFLAGS="$CPPFLAGS $LIBFFI_CPPFLAGS" LDFLAGS="$LDFLAGS $LIBFFI_LDFLAGS" dnl ===================================================================== dnl Checks for libraries LIBS="${LIBS} -lm" AC_CHECK_LIB(sun, getpwnam) # on IRIX adds -lsun AC_SEARCH_LIBS([strerror],[cposix]) dnl ---------------------------------------------------------------------- dnl Profiling & debug flags dnl if test "$with_debug_cflags" = "yes"; then with_debug_cflags="-g" fi if test "$with_debug_cflags" != "no"; then DEBUG_CFLAGS="$with_debug_cflags" CFLAGS="$with_debug_cflags $CFLAGS" CXXFLAGS="$with_debug_cflags $CXXFLAGS" LDFLAGS="$with_debug_cflags $LDFLAGS" fi if test "$with_profile_cflags" = "yes"; then with_profile_cflags="-pg" fi if test "$with_profile_cflags" != "no"; then CFLAGS="$with_profile_cflags $CFLAGS" CXXFLAGS="$with_profile_cflags $CFLAGS" LDFLAGS="$with_profile_cflags $LDFLAGS" fi dnl ---------------------------------------------------------------------- dnl Version of the compiler if test "${with_newcmp}" = "yes"; then ECL_CMPDIR=new-cmp else ECL_CMPDIR=cmp fi AC_SUBST(ECL_CMPDIR) dnl ---------------------------------------------------------------------- dnl Native thread support if test "${enable_threads}" = "auto"; then AC_MSG_CHECKING([for threads support]) if test -z "${THREAD_OBJ}"; then AC_MSG_RESULT([no]) enable_threads="no" else AC_MSG_RESULT([yes]) enable_threads="yes" fi fi if test "${enable_threads}" = "yes" ; then if test -z "${THREAD_OBJ}"; then AC_MSG_ERROR([Threads aren't supported on this system.]) else LIBS="${THREAD_LIBS} ${LIBS}" CFLAGS="${CFLAGS} ${THREAD_CFLAGS}" ECL_POSIX_RWLOCK boehm_configure_flags="${boehm_configure_flags} ${THREAD_GC_FLAGS}" for k in $THREAD_OBJ; do EXTRA_OBJS="$EXTRA_OBJS ${k}.${OBJEXT}"; done AC_MSG_CHECKING([for thread object files]) AC_MSG_RESULT([${THREAD_OBJ}]) AC_DEFINE( [ECL_THREADS], [1], [Userland threads?]) if test "${with___thread}" = "auto"; then with___thread=${ac_cv_ecl___thread} fi AC_MSG_CHECKING([for use of __thread]) if test "${with___thread}" = "yes"; then AC_DEFINE( [WITH___THREAD], [1], [__thread thread-local variables?] ) AC_MSG_RESULT([yes]) else AC_MSG_RESULT([no]) fi fi else boehm_configure_flags="${boehm_configure_flags} --disable-threads" fi dnl ---------------------------------------------------------------------- dnl Boehm-Weiser garbage collector if test ${enable_boehm} = "no" ; then AC_MSG_ERROR([Boehm GC library is currently needed to build ECL]); EXTRA_OBJS="${EXTRA_OBJS} alloc.${OBJEXT} gbc.${OBJEXT}" enable_smallcons="no" else ECL_BOEHM_GC fi if test ${enable_smallcons} = "yes" ; then AC_DEFINE([ECL_SMALL_CONS], [], [ECL_SMALL_CONS]) fi ECL_LIBFFI dnl ---------------------------------------------------------------------- dnl SONAME is only active when SONAME_LDFLAGS and SONAME are non nil dnl AC_MSG_CHECKING(for soname flags) PACKAGE_MAJOR=`echo ${PACKAGE_VERSION} | sed -e 's,\(.*\)\..*\..*,\1,g'` PACKAGE_MINOR=`echo ${PACKAGE_VERSION} | sed -e 's,.*\.\(.*\)\..*,\1,g'` PACKAGE_LEAST=`echo ${PACKAGE_VERSION} | sed -e 's,.*\..*\.\(.*\),\1,g'` if test "${enable_soname}" != yes; then SONAME='' SONAME1='' SONAME2='' SONAME3='' SONAME_ALIASES='' SONAME_LDFLAGS='' AC_MSG_RESULT([none]) else i="${PACKAGE_MAJOR}.${PACKAGE_MINOR}.${PACKAGE_LEAST}" SONAME3=`echo $SONAME | sed "s,.SOVERSION,.$i,g"` i="${PACKAGE_MAJOR}.${PACKAGE_MINOR}" SONAME2=`echo $SONAME | sed "s,.SOVERSION,.$i,g"` i="${PACKAGE_MAJOR}" SONAME1=`echo $SONAME | sed "s,.SOVERSION,.$i,g"` SONAME=`echo $SONAME | sed "s,.SOVERSION,,g"` SONAME_LDFLAGS=`echo $SONAME_LDFLAGS | sed "s,SONAME,$SONAME2,g"` AC_MSG_RESULT([${SONAME_LDFLAGS}]) fi AC_SUBST(SONAME3) AC_SUBST(SONAME2) AC_SUBST(SONAME1) AC_SUBST(SONAME) AC_SUBST(SONAME_LDFLAGS) dnl Related to that, the package version number ECL_VERSION_NUMBER=$(($PACKAGE_MAJOR * 10000 + $PACKAGE_MINOR * 100 + $PACKAGE_LEAST)) AC_SUBST(ECL_VERSION_NUMBER) dnl ---------------------------------------------------------------------- dnl Deactivate floating point exceptions if asked to if test "${with_ieee_fp}" = yes; then with_signed_zero="yes" with_fpe="yes" AC_DEFINE([ECL_IEEE_FP], [], [ECL_IEEE_FP]) fi if test "${with_fpe}" != yes; then AC_DEFINE([ECL_AVOID_FPE_H], [], [ECL_AVOID_FPE_H]) fi if test "${with_signed_zero}" = yes; then AC_DEFINE([ECL_SIGNED_ZERO], [], [ECL_SIGNED_ZERO]) fi dnl ===================================================================== dnl Checks for header files dnl !!! autoscan AC_PATH_X AC_HEADER_DIRENT AC_HEADER_STDBOOL AC_HEADER_STDC AC_HEADER_TIME AC_CHECK_HEADERS( [fcntl.h limits.h netdb.h netinet/in.h] \ [stddef.h stdlib.h string.h sys/param.h] \ [sys/socket.h sys/time.h unistd.h fenv.h] \ [sched.h] ) dnl !!! end autoscan AC_CHECK_HEADERS( [sys/resource.h sys/utsname.h float.h pwd.h dlfcn.h link.h] \ [mach-o/dyld.h dirent.h sys/ioctl.h sys/select.h] \ [sys/wait.h semaphore.h] ) AC_CHECK_HEADERS([ulimit.h], [], [], [[#ifdef HAVE_ULIMIT_H # include #endif ]]) dnl ===================================================================== dnl Checks for typedefs, structures, and compiler characteristics. dnl !!! autoscan AC_C_CONST dnl !!! DNLed AC_C_INLINE AC_TYPE_SIZE_T dnl !!! DNLed AC_STRUCT_TM AC_C_VOLATILE AC_CHECK_TYPES([ptrdiff_t]) ECL_LONG_LONG dnl !!! end autoscan dnl !!! dnled in original dnl AC_TYPE_PID_T # DEFS pid_t dnl AC_TYPE_UID_T # DEFS uid_t, gid_t dnl AC_TYPE_OFF_T # DEFS off_t dnl AC_C_CHAR_UNSIGNED # DEFS __CHAR_UNSIGNED__ if char is unsigned dnl !!! end dnled AC_C_BIGENDIAN([], [], [AC_DEFINE(WORDS_BIGENDIAN, [/* EDIT! - Undefine if small endian */])]) dnl ---------------------------------------------------------------------- dnl This flag is an optimization for GNU dnl if test "${GCC}" = "yes"; then dnl CFLAGS="${CFLAGS} -fstrict-aliasing" dnl fi dnl ---------------------------------------------------------------------- dnl Check the appropiate type for cl_fixnum/cl_index ECL_FIXNUM_TYPE ECL_INTEGER_TYPES ECL_LINEFEED_MODE ECL_FIND_SETJMP ECL_FILE_STRUCTURE ECL_FPE_MODEL ECL_SSE ECL_LONG_DOUBLE if test "$enable_c99complex" != "no" ; then AC_CHECK_TYPES([double complex, float complex],[],[],[#include ]) fi dnl ----------------------------------------------------------------------- dnl Study the call conventions ECL_STACK_DIRECTION dnl ===================================================================== dnl Checks for library functions dnl !!! autoscan AC_FUNC_CLOSEDIR_VOID AC_FUNC_ERROR_AT_LINE AC_FUNC_FORK AC_PROG_GCC_TRADITIONAL AC_FUNC_MALLOC AC_FUNC_MEMCMP AC_FUNC_MMAP AC_FUNC_REALLOC AC_FUNC_SELECT_ARGTYPES AC_TYPE_SIGNAL AC_FUNC_STAT AC_FUNC_STRTOD AC_CHECK_FUNCS( [floor getcwd gethostbyaddr gethostbyname getpagesize] \ [memmove memset mkdir putenv socket sqrt] \ [strcasecmp strchr strerror strtol] ) dnl !!! end autoscan AC_CHECK_FUNCS( [nanosleep alarm times select setenv putenv] \ [lstat mkstemp sigprocmask isatty tzset] \ [gettimeofday getrusage] ) dnl AC_CHECK_FUNCS( [ feenableexcept ] ) AC_CHECK_FUNCS( [expf logf sqrtf cosf sinf tanf sinhf coshf tanhf] \ [floorf ceilf fabsf frexpf ldexpf log1p log1pf log1pl] \ [copysign] ) AC_CHECK_FUNCS( [sched_yield uname fseeko dladdr backtrace backtrace_symbols] ) AC_CHECK_HEADER( [sys/mman.h], AC_DEFINE([ECL_USE_MPROTECT], [], [ECL_USE_MPROTECT]) AC_DEFINE([HAVE_SYS_MMAN_H], [], [HAVE_SYS_MMAN_H]) ) ECL_POSIX_ENVIRON dnl ===================================================================== dnl Checks for system services dnl ===================================================================== dnl Final pass over configuration files dnl dnl Notice that we build ${builddir}/ecl/configpre.h from dnl ${srcdir}/ecl/config.h.in, and then use all AC_DEF* to build dnl ecl/config.h from ecl/configpre.h dnl ---------------------------------------------------------------------- dnl Do we use C or C++ compiler to compile ecl? if test ${with_cxx} = "no" ; then AC_SUBST([ECL_CC], [${CC}]) AC_SUBST([CC_IS_CXX], ["nil"]) else AC_SUBST([ECL_CC], [${CXX}]) AC_SUBST([CC_IS_CXX], ["t"]) boehm_configure_flags="${boehm_configure_flags} --enable-cplusplus" fi dnl ---------------------------------------------------------------------- dnl Do we need to have 8-bit opcodes? if test ! ${opcode8} = "no" ; then AC_DEFINE( ECL_SMALL_BYTECODES, [1], [Bytecodes and arguments are 8 and 16 bits large, respectively]) fi ECL_GCC_BACKTRACE ECL_LIBATOMIC_OPS dnl ---------------------------------------------------------------------- dnl Lisp library and libecl features if test ${enable_shared} = "yes"; then AC_DEFINE(ENABLE_DLOPEN, [1], [Allow loading dynamically linked code]) LSP_LIBRARIES="${SHAREDPREFIX}ecl.${SHAREDEXT}" ECL_ADD_LISP_MODULE([dlopen]) else enable_soname=no LSP_LIBRARIES="${LIBPREFIX}ecl.${LIBEXT}" ECL_LDRPATH='' fi if test "x${enable_rpath}" = "xno"; then ECL_LDRPATH='' fi if test "${with_cmuformat}" = "yes"; then with_clos_streams="yes" AC_DEFINE([ECL_CMU_FORMAT], [1], [Use CMU Common-Lisp's FORMAT routine]) fi if test "${with_clos_streams}" = "yes"; then AC_DEFINE( ECL_CLOS_STREAMS, [1], [Allow STREAM operations to work on arbitrary objects]) fi if test "${with_cmp}" = "builtin"; then ECL_ADD_BUILTIN_MODULE([cmp]) with_cmp=yes fi if test "${with_cmp}" = "yes"; then ECL_ADD_LISP_MODULE([cmp]) fi AC_SUBST(CLX_INFO) if test "${with_clx}" = "builtin"; then ECL_ADD_BUILTIN_MODULE([clx]) ECL_ADD_BUILTIN_MODULE([sockets]) with_clx=yes fi if test ${with_clx} = "yes"; then tcp="yes" ECL_ADD_LISP_MODULE([clx]) CLX_INFO="clx.${INFOEXT}" else CLX_INFO="" fi if test "${with_tcp}" = "builtin"; then ECL_ADD_BUILTIN_MODULE([sockets]) with_tcp=yes fi if test "${with_tcp}" = "yes"; then AC_DEFINE(TCP, [1], [Network streams]) EXTRA_OBJS="${EXTRA_OBJS} tcp.${OBJEXT}" ECL_ADD_LISP_MODULE([sockets]) LIBS="${LIBS} ${TCPLIBS}" fi if test "${with_serve_event}" = "builtin"; then ECL_ADD_BUILTIN_MODULE([serve_event]) with_serve_event=yes fi if test "${with_serve_event}" = "yes"; then case "${host_os}" in mingw*|cygwin*) ;; *) ECL_ADD_LISP_MODULE([serve-event]) ;; esac fi if test "${with_asdf}" = "builtin"; then ECL_ADD_BUILTIN_MODULE([asdf]) with_asdf=yes fi if test "${with_asdf}" = "yes"; then ECL_ADD_LISP_MODULE([asdf]) fi if test "${with_defsystem}" = "builtin"; then ECL_ADD_BUILTIN_MODULE([defsystem]) with_defsystem=yes fi if test "${with_defsystem}" = "yes"; then ECL_ADD_LISP_MODULE([defsystem]) fi if test "${with_profile}" = "builtin"; then ECL_ADD_BUILTIN_MODULE([profile]) with_profile=yes fi if test "${with_profile}" = "yes"; then if test "${enable_boehm}" != "no"; then ECL_ADD_LISP_MODULE([profile]) fi fi if test "${with_bytecmp}" = "builtin"; then ECL_ADD_BUILTIN_MODULE([bytecmp]) with_bytecmp=yes fi if test "${with_bytecmp}" = "yes"; then ECL_ADD_LISP_MODULE([bytecmp]) fi if test "${with_rt}" = "builtin"; then ECL_ADD_BUILTIN_MODULE([rt]) with_rt=yes fi if test "${with_rt}" = "yes"; then ECL_ADD_LISP_MODULE([rt]) fi if test "x${enable_unicode}" != "xno"; then if test "${enable_unicode}" = 16; then AC_DEFINE([ECL_UNICODE], [16], [Support for Unicode]) CHAR_CODE_LIMIT=65536 ECL_CHARACTER=$ECL_INT16_T EXTRA_OBJS="$EXTRA_OBJS unicode/ucd16.o unicode/ucd16-0000.o unicode/ucd16-0016.o unicode/ucd16-0032.o unicode/ucd16-0048.o unicode/ucd16-0064.o" else AC_DEFINE([ECL_UNICODE], [21], [Support for Unicode]) CHAR_CODE_LIMIT=1114112 ECL_CHARACTER=$ECL_INT32_T EXTRA_OBJS="$EXTRA_OBJS unicode/ucd.o unicode/ucd-0000.o unicode/ucd-0016.o unicode/ucd-0032.o unicode/ucd-0048.o unicode/ucd-0064.o unicode/ucd-0080.o unicode/ucd-0096.o" fi if test "${with_unicode_names}" = "yes"; then AC_DEFINE([ECL_UNICODE_NAMES], [1], [Link in the database of Unicode names]) EXTRA_OBJS="$EXTRA_OBJS unicode/ucd_names_char.o unicode/ucd_names_codes.o unicode/ucd_names_pair.o unicode/ucd_names_str.o" fi else CHAR_CODE_LIMIT=256 ECL_CHARACTER="int" fi AC_SUBST(ECL_CHARACTER) AC_SUBST(CHAR_CODE_LIMIT) AC_SUBST(ECL_EXTRA_LISP_FILES) ECL_EXTRA_LISP_FILES="" for i in $with_extra_files; do ECL_EXTRA_LISP_FILES="${ECL_EXTRA_LISP_FILES} \"$i\"" done AC_SUBST(ECL_INIT_FORM) echo ${with_init_form} = init form if test "x${with_init_form}" = "x"; then ECL_INIT_FORM='(SI::TOP-LEVEL T)' else ECL_INIT_FORM="${with_init_form}" fi if test "${enable_hpack}" = "yes"; then AC_DEFINE([ECL_RELATIVE_PACKAGE_NAMES], [1], [Hierarchical package names]) fi AC_CONFIG_FILES([ bare.lsp lsp/load.lsp clos/load.lsp cmp/load.lsp new-cmp/load.lsp ../Makefile Makefile c/Makefile doc/Makefile doc/ecl.man doc/ecl-config.man ecl/configpre.h:h/config.h.in bin/ecl-config.pre:util/ecl-config lsp/config.pre:lsp/config.lsp.in compile.pre:compile.lsp.in cmp/cmpdefs.pre:cmp/cmpdefs.lsp tests/config.lsp tests/Makefile ]) AC_CONFIG_HEADERS([ecl/config.h:ecl/configpre.h]) AC_OUTPUT for i in $srcdir/c/*/; do mkdir c/`basename $i`; done ecl-16.1.2/src/doc/000077500000000000000000000000001266352375300137145ustar00rootroot00000000000000ecl-16.1.2/src/doc/Makefile.in000066400000000000000000000123651266352375300157700ustar00rootroot00000000000000top_srcdir= @top_srcdir@ srcdir = @srcdir@ prefix=@prefix@ exec_prefix=@exec_prefix@ infodir = @infodir@ mandir=@mandir@ docdir=@docdir@ manext=1 INFOEXT = @INFOEXT@ SHELL = @SHELL@ INSTALL = @INSTALL@ INSTALL_PROGRAM = @INSTALL_PROGRAM@ INSTALL_DATA = @INSTALL_DATA@ INSTALL_INFO = @INSTALL_INFO@ mkinstalldirs = $(top_srcdir)/bdwgc/install-sh -d INFO_FILES = ecl.$(INFOEXT) ecldev.$(INFOEXT) @CLX_INFO@ HTML_FILES = index.html license.html lgpl.html news.html benchmark.html \ install.html download.html cvs.html VERSION=@PACKAGE_VERSION@ FILTER = sed 's,@VERSION@,$(VERSION),g' ECL = ../ecl all: $(INFO_FILES) html: $(HTML_FILES) ecl.dvi: $(srcdir)/user.txi $(srcdir)/macros.txi clisp.sty ecl.sty tex $(srcdir)/user.txi ecldev.dvi: $(srcdir)/devel.txi $(srcdir)/macros.txi clisp.sty ecl.sty tex $(srcdir)/devel.txi clx.dvi: clx.texinfo tex clx.texinfo ecl.ps: ecl.dvi $(srcdir)/macros.txi dvips -o $@ ecl.dvi ecldev.ps: ecldev.dvi $(srcdir)/macros.txi dvips -o $@ ecldev.dvi clx.ps: clx.dvi dvips -o $@ clx.dvi install: all $(mkinstalldirs) $(DESTDIR)$(infodir) for k in $(INFO_FILES); do \ $(INSTALL_DATA) $$k $(DESTDIR)$(infodir); \ if [ -x $(INSTALL_INFO) ]; then \ $(INSTALL_INFO) --info-dir=$(DESTDIR)$(infodir) $$k; \ fi; \ done $(mkinstalldirs) $(DESTDIR)$(docdir) for i in Copyright LGPL; do \ $(INSTALL_DATA) $(top_srcdir)/../$$i $(DESTDIR)$(docdir); \ done $(mkinstalldirs) $(DESTDIR)$(mandir)/man$(manext) $(INSTALL_DATA) ecl.man $(DESTDIR)$(mandir)/man$(manext)/ecl.$(manext) $(INSTALL_DATA) ecl-config.man $(DESTDIR)$(mandir)/man$(manext)/ecl-config.$(manext) flatinstall: all $(HTML_FILES) $(mkinstalldirs) $(DESTDIR)$(docdir) for k in $(INFO_FILES); do $(INSTALL_DATA) $$k $(DESTDIR)$(docdir); done if [ -f user.html ]; then \ $(INSTALL_DATA) $$i $(DESTDIR)$(docdir)/; \ else \ $(mkinstalldirs) $(DESTDIR)$(docdir)/ecl; \ for i in ecl/*; do $(INSTALL_DATA) $$i $(DESTDIR)$(docdir)/ecl/; done; \ fi if [ -f devel.html ]; then \ $(INSTALL_DATA) devel.html $(DESTDIR)$(docdir)/; \ else \ $(mkinstalldirs) $(DESTDIR)$(docdir)/ecldev; \ for i in ecldev/*; do $(INSTALL_DATA) $$i $(DESTDIR)$(docdir)/ecldev/; done; \ fi for i in Copyright LGPL; do \ $(INSTALL_DATA) $(top_srcdir)/../$$i $(DESTDIR)$(docdir); \ done for i in *.html; do $(INSTALL_DATA) $$i $(DESTDIR)$(docdir)/; done uninstall: -for k in $(INFO_FILES); do \ rm $$k; \ if [ -x $(INSTALL_INFO) ]; then \ $(INSTALL_INFO) --remove $$k; \ fi; \ done rm -r $(DESTDIR)$(infodir)/ecl.$(INFOEXT) $(DESTDIR)$(infodir)/ecldev.$(INFOEXT); \ rm $(DESTDIR)$(mandir)/man$(manext)/ecl.$(manext) head: developers_manual user_manual $(srcdir)/head if [ -f ecl/index.html ]; then \ sed -e 's,ecl/user.html,ecl/index.html,g' \ -e 's,ecldev/devel.html,ecldev/index.html,g' $(srcdir)/head > head; \ else \ cp $(srcdir)/head head; \ fi ecl.info.gz: ecl.info gzip < ecl.info > ecl.info.gz ecldev.info.gz: ecldev.info gzip < ecldev.info > ecldev.info.gz clx.info.gz: clx.info gzip < clx.info > clx.info.gz ecl.info: $(srcdir)/user.txi $(srcdir)/macros.txi makeinfo -I $(srcdir) --no-split $(srcdir)/user.txi ecldev.info: $(srcdir)/devel.txi $(srcdir)/macros.txi makeinfo -I $(srcdir) --no-split $(srcdir)/devel.txi clx.info: clx.texinfo -makeinfo --no-split clx.texinfo clx.texinfo: $(top_srcdir)/clx/manual/clx.texinfo cp $(top_srcdir)/clx/manual/clx.texinfo . download.html: $(srcdir)/download.in.html head cat head $(srcdir)/download.in.html $(srcdir)/end | $(FILTER) > $@ index.html: $(srcdir)/index.in.html head cat head $(srcdir)/index.in.html $(srcdir)/end | $(FILTER) > $@ cvs.html: $(srcdir)/cvs.in.html head cat head $(srcdir)/cvs.in.html $(srcdir)/end | $(FILTER) > $@ install.html: $(srcdir)/install.in.html head cat head $(srcdir)/install.in.html $(srcdir)/end | $(FILTER) > $@ news.html: head $(srcdir)/../..ANNOUNCEMENT (cat head; echo '
    '; cat $(srcdir)/../../ANNOUNCEMENT; echo '
    ';\ cat $(srcdir)/end) | $(FILTER) > $@ benchmark.html: $(srcdir)/benchmark.in.html BENCHMARK head (cat head; cat $(srcdir)/benchmark.in.html; \ echo '
    '; cat BENCHMARK; echo '
    '; \ cat $(srcdir)/end) | $(FILTER) > $@ BENCHMARK: echo "No benchmarks available" > $@ license.html: $(top_srcdir)/../Copyright head (cat head; \ echo '
    '; cat $(top_srcdir)/../Copyright; echo '
    '; \ cat $(srcdir)/end) | $(FILTER) > $@ lgpl.html: $(top_srcdir)/../LGPL head (cat head; \ echo '
    '; cat $(top_srcdir)/../LGPL; echo '
    '; \ cat $(srcdir)/end) | $(FILTER) > $@ user_manual: $(srcdir)/user.txi $(srcdir)/macros.txi echo "Producing ecl.html; ignore error messages." test -d ecl || mkdir ecl; \ (makeinfo --output-indent=0 -I $(srcdir) --css-include=$(srcdir)/basic.css --html $(srcdir)/user.txi || \ texi2html -I=$(srcdir) -subdir=ecl -split=chapter $(srcdir)/user.txi) \ && touch user_manual developers_manual: $(srcdir)/devel.txi $(srcdir)/macros.txi echo "Producing ecldev.html; ignore error messages." test -d ecldev || mkdir ecldev; \ (makeinfo --output-indent=0 -I $(srcdir) --css-include=$(srcdir)/basic.css --html $(srcdir)/devel.txi || \ texi2html -I=$(srcdir) -subdir=ecldev -split=chapter $(srcdir)/devel.txi) \ && touch developers_manual clean: rm -r -f ecl ecldev ecl.info* ecldev.info* *.html user_manual developers_manual ecl-16.1.2/src/doc/amop.txt000066400000000000000000000200061266352375300154070ustar00rootroot00000000000000C CLASS SC STANDARD-CLASS BIC BUILT-IN-CLASS FRC FORWARD-REFERENCED-CLASS FSC FUNCALLABLE-STANDARD-CLASS M METHOD SM STANDARD-METHOD SAM STANDARD-ACCESSOR-METHOD GF GENERIC-FUNCTION SGF STANDARD-GENERIC-FUNCTION SP SPECIALIZER EQSP EQL-SPECIALIZER SD SLOT-DEFINITION SSD STANDARD-SLOT-DEFINITION SDSD STANDARD-DIRECT-SLOT-DEFINITION SESF STANDARD-EFFECTIVE-SLOT-DEFINITION ;; ;; MISCELLANEOUS PROTOCOLS ;; ======================= ;; (ADD-DEPENDENT (metaobject SC FSC SGF) dependent) (MAP-DEPENDENT (metaobject SC FSC SGF) function) (REMOVE-DEPENDENT (metaobject SC FSC SGF) dependent) (UPDATE-DEPENDENT (metaobject SC FSC SGF) (ALLOCATE-INSTANCE (class SC FSC BIC) &rest initargs) ;; ;; CLASSES ;; ======= ;; ;; ;; 2.A) GENERAL CLASS ACCESSORS ;; ----------------------- (ADD-DIRECT-SUBCLASS (superclass C) (subclass C)) (REMOVE-DIRECT-SUBCLASS (superclass C) (subclass C)) (CLASS-DEFAULT-INITARGS (class C)) (CLASS-DIRECT-DEFAULT-INITARGS (class C)) (CLASS-DIRECT-SLOTS (class C)) (CLASS-DIRECT-SUBCLASSES (class C)) (CLASS-DIRECT-SUPERCLASSES (class C)) (CLASS-FINALIZED-P (class C)) (CLASS-NAME (class C)) (CLASS-PRECEDENCE-LIST (class C)) (CLASS-PROTOTYPE (class C)) (CLASS-SLOTS (class C)) [F] ((SETF CLASS-NAME) new-name class) [F] (STANDARD-INSTANCE-ACCESS instance location) [F] (FUNCALLABLE-STANDARD-INSTANCE-ACCESS instance location) ;; ;; 2.B) CLASS-DEFINITION ;; ---------------- [F] (ENSURE-CLASS name &key &allow-other-keys) (ENSURE-CLASS-USING-CLASS (class (C FRC NULL)) name &key :direct-default-initargs :direct-slots :direct-superclasses :name (:metaclass 'STANDARD-CLASS) &rest initargs &allow-other-keys) " < CLASS is a class metaobject or NIL < METACLASS is a class metaobject or a valid name of one (or error). < :DIRECT-SUPERCLASSES is a proper list of class metaobjects or names (or error). - This function may be called directly, and it is used to define or modify the definition of a function. - INITARGS is processed: - The :METACLASS option is removed. - The :DIRECT-SUPERCLASSES is processed, so that each element is a valid class metaobject or a forward referenced class metaobject. - The METACLASS argument is processed as follows + if CLASS is NIL, an instance of METACLASS is created with the computed INITARGS. + if CLASS is a forward referenced class, CHANGE-CLASS is applied on it with the value of METACLASS, and it is REINITIALIZE-CLASS with the computed INITARGS. + if CLASS <> METACLASS, an error is signaled. + otherwise, CLASS is REINITIALIZE-CLASS with the computed INITARGS. " (MAKE-INSTANCE (class (SYMBOL SC FSC)) &rest initargs) [M] (INITIALIZE-INSTANCE class &rest initargs) [M] (REINITIALIZE-INSTANCE class &rest initargs) [M] (SHARED-INITIALIZE class &rest initargs) " - Initialization is made by MAKE-INSTANCE and letting it call INITIALIZE-INSTANCE. - Reinitialization is made by REINITIALIZE-INSTANCE on an existing class. - INITIALZE-INSTANCE, CHANGE-CLASS AND SHARED-INITIALIZE cannot be called directly on a class metaobject. - SHARED-INITIALIZE cannot be redefined by any user methods. - [RE]INITIALIZE-INSTANCE may have extending around methods (i.e. they must not override the existing specified methods. < :DIRECT-DEFAULT-INITARGS is a proper list of canonicalized default initargs (or error). < :DIRECT-SLOTS is a proper list of canonicalized slotd definitions (or error). < :DIRECT-SUPERCLASSES is a proper list of valid class metaobjects (or error) Validation is made using VALIDATE-SUPERCLASS. < :DOCUMENTATION is either a string or NIL (or error) < :NAME is any object - Default values during initialization DIRECT-DEFAULT-INITARGS => NIL DIRECT-SLOTS => NIL DIRECT-SUPERCLASSES => (LIST (FIND-CLASS 'STANDARD-OBJECT)) or (LIST (FIND-CLASS 'FUNCALLABLE-STANDARD-OBJECT)) DOCUMENTATION => NIL NAME => NIL - DIRECT-SLOTS is converted to a list of slot definition objects + DIRECT-SLOT-DEFINITION-CLASS provides the class + MAKE-INSTANCE is used to create the slot definition + After slots are created, reader and writer methods are created using READER-METHOD-CLASS and WRITER-METHOD-CLASS. " (COMPUTE-CLASS-PRECEDENCE-LIST (class C)) (COMPUTE-DEFAULT-INITARGS (class (SC FSC)) (VALIDATE-SUPERCLASS (class C) (superclass C)) (FINALIZE-INHERITANCE (class (SC FSC FRC))) " - This function is called with a class, at least before the first invocation of ALLOCATE-INSTANCE. - COMPUTE-CLASS-PRECEDENCE-LIST is done, and the value stored. - COMPUTE-SLOTS is done and the value stored. It involves calling - EFFECTIVE-SLOT-DEFINITION-CLASS - COMPUTE-EFFECTIVE-SLOT-DEFINITION - COMPUTE-DEFAULT-INITARGS is done and the value stored. - If the class was previously finalized, and the local slots have changed MAKE-INSTANCES-OBSOLETE is invoked. - FINALIZE-INHERITANCE signals an error with forward referenced classes. " ;; ;; 2.C) SLOT ALLOCATION AND DEFINITION ;; ------------------------------ (COMPUTE-EFFECTIVE-SLOT-DEFINITION (class (SC FSC)) name direct-slot-definitions) (COMPUTE-SLOTS (class (SC FSC))) (COMPUTE-SLOTS :AROUND (class (SC FSC))) (DIRECT-SLOT-DEFINITION-CLASS (class (SC FSC)) &rest initargs) (EFFECTIVE-SLOT-DEFINITION-CLASS (class (SC FSC)) &rest initargs) ;; ;; 2.D) SLOT ACCESSING ;; -------------- ;; ((SETF SLOT-VALUE-USING-CLASS) new-value (class (SC FSC BIC)) object (slot SESD)) (SLOT-BOUNDP-USING-CLASS) (class SC FSC BIC) object (slot SESD)) (SLOT-MAKUNBOUND-USING-CLASS) (class SC FSC BIC) object (slot SESD)) (SLOT-VALUE-USING-CLASS (class SC FSC BIC) object (slot SESD)) ;; ;; SLOTS ;; ===== ;; (SLOT-DEFINITION-ALLOCATION (slotd SSD)) (SLOT-DEFINITION-INITARGS (slotd SSD)) (SLOT-DEFINITION-INITFORM (slotd SSD)) (SLOT-DEFINITION-INITFUNCTION (slotd SSD)) (SLOT-DEFINITION-NAME (slotd SSD)) (SLOT-DEFINITION-TYPE (slotd SSD)) (SLOT-DEFINITION-READERS (direct-slot SDSD)) (SLOT-DEFINITION-WRITERS (direct-slot SDSD)) (SLOT-DEFINITION-LOCATION (effective-slot SESD)) ;; ;; SPECIALIZERS ;; ============ ;; (ADD-DIRECT-METHOD (specializer C EQSP) (method M)) (REMOVE-DIRECT-METHOD (specializer C EQSP) (method M)) [F] (EQL-SPECIALIZER-OBJECT eql-specializer) (SPECIALIZER-DIRECT-GENERIC-FUNCTIONS (specializer C EQSP)) (SPECIALIZER-DIRECT-METHODS (specializer C EQSP)) ;; ;; GENERIC FUNCTIONS ;; ================= ;; (ADD-METHOD (gf SGF) (method SM)) (COMPUTE-APPLICABLE-METHODS (gf SGF) arguments) (COMPUTE-APPLICABLE-METHODS-USING-CLASSES (gf SGF) classes) (COMPUTE-DISCRIMINATING-FUNCTION (gf SGF)) (COMPUTE-EFFECTIVE-METHOD (gf SGF) method-combination methods) [F] (ENSURE-GENERIC-FUNCTION function-name &key &alow-other-keys) (ENSURE-GENERIC-FUNCTION-USING-CLASS (gf (GF NULL)) function-name &key :argument-precedence-order :declarations :documentation :generic-function-class :lambda-list :method-class :method-combination :name &alow-other-keys) [F] (EXTRACT-LAMBDA-LIST specialized-lambda-list) [F] (EXTRACT-SPECIALIZER-NAMES specialized-lambda-list) (FIND-METHOD-COMBINATION gf method-combination-type-name method-combination-options) [F] (FUNCALLABLE-STANDARD-INSTANCE-ACCESS instance location) (GENERIC-FUNCTION-ARGUMENT-PRECEDENCE-ORDER (gf SGF)) (GENERIC-FUNCTION-DECLARATIONS (gf SGF)) (GENERIC-FUNCTION-LAMBDA-LIST (gf SGF)) (GENERIC-FUNCTION-METHOD-CLASS (gf SGF)) (GENERIC-FUNCTION-METHOD-COMBINATION (gf SGF)) (GENERIC-FUNCTION-METHODS (gf SGF)) (GENERIC-FUNCTION-NAME (gf SGF)) [F] (INTERN-EQL-SPECIALIZER object) (MAKE-METHOD-LAMBDA (gf SGF) (method SM) lambda-expression environment) (MAP-DEPENDENT (metaobject (SC FSC SGF)) function) (METHOD-FUNCTION (method SM)) (METHOD-GENERIC-FUNCTION (method SM)) (METHOD-LAMBDA-LIST (method SM)) (METHOD-SPECIALIZERS (method SM)) (METHOD-QUALIFIERS (method SM)) (ACCESSOR-METHOD-SLOT-DEFINITION (method SAM)) (READER-METHOD-CLASS (class (SC FSC)) (direct-slot SDSD) &rest initargs) (REMOVE-METHOD (gf SGF) (method SM)) [F] (SET-FUNCALLABLE-INSTANCE-FUNCTION funcallable-instance function) [F] ((SETF GENERIC-FUNCTION-NAME) new-name gf) (WRITER-METHOD-CLASS (class SC) (direct-slot SDSD) &rest initargs) ecl-16.1.2/src/doc/debugging000066400000000000000000000020761266352375300155770ustar00rootroot00000000000000You can find the preprocessed documentation in ./doc in HTML format. Debugging via GDB: ------------------ src/util/gdbinit (and, therefore, build/.gdbinit) defines a few convenience things - T, NIL, and, even more important, ecl_print. This is a GDB function that prints a 'cl_object' human-readably: (gdb) ecl_print x $39 = t_fixnum $40 = (ecl_base_char *) 0x42b4000 "10652336" And another that helps to see a thread state: (gdb) ecl_eval "cl:*package*" Please note that double quotes have to be escaped: (gdb) ecl_eval "(concatenate 'string \"a\" \"b\")" Both will give a string with "readable" content, and a pretty-printed one. Using VIM: ---------- .git/tags is a VIM-compatible tag file; if you're using the fugitive plugin, it will be used automatically. About testing: -------------- make check to (get, initialize and) run the tests make -C build/tests do-regressions make -C build/tests do-ansi make -C build/tests do-quicklisp make -C build/tests do-mop-tests runs the specified tests make -C build/tests/ show-fails prints results ecl-16.1.2/src/doc/ecl-config.man.in000066400000000000000000000011741266352375300170270ustar00rootroot00000000000000.TH ECL-CONFIG 1 2013-06-09 .SH NAME ecl-config \- Embeddable Common Lisp configuration query .SH SYNOPSIS \fBecl\-config\fP [\fB\-cflags] [\fB\-libs] [\fB\-ldflags] [\fB LIBS] .SH DESCRIPTION ecl\-config will return through the standard output the set of compiler or linker flags needed to build applications that embed ecl. .SH OPTIONS .TP .BI \-cflags Output the flags required to compile a C/C++ file. .TP .B \-libs .TP .B \-ldflags Return the linker flags required to build a C/C++ application or shared library. .TP .B LIBS When also using .B \-ldflags also add the cmp (compiler) library. .SH "BUGS" Probably some. Report them! ecl-16.1.2/src/doc/ecl.man.in000066400000000000000000000063071266352375300155670ustar00rootroot00000000000000.TH ECL 1 2013-06-09 .UC 4 .SH NAME ecl \- Embeddable Common Lisp .SH SYNOPSIS \fBecl\fP [\fB\-dir\fP \fIdir\fP] [\fB\-load\fP \fIfile\fP] [\fB\-eval\fP \fIexpr\fP] .br [\fB\-compile\fP \fIfile\fP .br [\fB\-o\fP \fIofile\fP] [\fB\-c\fP [\fIcfile\fP]] [\fB\-h\fP [\fIhfile\fP]] [\fB\-data\fP [\fIdatafile\fP]] [\fB\-s\fP] [\fB\-q\fP]] .SH DESCRIPTION .sp ECL stands for Embeddable Common Lisp. The ECL project is an effort to modernize Giuseppe Attardi's ECL environment to produce an implementation of the Common Lisp language which complies to the ANSI X3J13 definition of the language. .PP The current ECL implementation features: .IP \(bu A bytecodes compiler and interpreter. .IP \(bu A translator to C. .IP \(bu An interface to foreign functions. .IP \(bu A dynamic loader. .IP \(bu The possibility to build standalone executables. .IP \(bu The Common Lisp Object System (CLOS). .IP \(bu Conditions and restarts for handling errors. .IP \(bu Sockets as ordinary streams. .IP \(bu The Gnu Multiprecision library for fast bignum operations. .IP \(bu A simple conservative mark & sweep garbage collector. .IP \(bu The Boehm-Weiser garbage collector. .PP \fBecl\fP without any argument gives you the interactive lisp. .SH OPTIONS .TP 1i .BI \-shell " file" Executes the given file and exits, without providing a read-eval-print loop. If you want to use lisp as a scripting language, you can write .BR "#!@bindir@/ecl -shell" on the first line of the file to be executed, and then ECL will be automatically invoked. .TP .B \-norc Do not try to load the file .I ~/.eclrc at startup. .TP .B \-dir Use .I dir as system directory. .TP .BI \-load " file" Loads .I file before entering the read-eval-print loop. .TP .BI \-eval " expr" Evaluates .I expr before entering the read-eval-print loop. .TP .BI \-compile " file" Translates .I file to C and invokes the local C compiler to produce a shared library with .fas as extension per default. .TP .BI \-o " ofile" When compiling .I file name the resulting shared library \fIofile\fP. .TP .BI \-c " cfile" When compiling name the intermediary C file .I cfile and do not delete it afterwards. .TP .BI \-h " hfile" When compiling name the intermediary C header .I hfile and do not delete it afterwards. .TP .BI \-data " [datafile]" Dumps compiler data into \fIdatafile\fP or, if not supplied, into a file named after the source file, but with .data as extension. .TP .B \-s Produce a linkable object file. It cannot be loaded with load, but it can be used to build libraries or standalone executable programs. .TP .B \-q Produce less notes when compiling. .PP The options .B \-load, .B \-shell, and .B \-eval may appear any number of times, and they are combined and processed from left to right. .SH AUTHORS The original version was developed by Giuseppe Attardi starting from the Kyoto Common Lisp implementation by Taiichi Yuasa and Masami Hagiya. The current maintainer of ECL is Juan Jose Garcia Ripoll, who can be reached at the ECL mailing list. .SH FILES .TP .BR "~/.ecl, ~/.eclrc" Default initialization files loaded at startup unless the option .BR \-norc is provided. (if they exist). .SH SEE ALSO .IP "" ANSI Common Lisp standard X3.226-1994 .IP "" The Common Lisp HyperSpec .SH "BUGS" Probably some. Report them! ecl-16.1.2/src/doc/help.lsp000066400000000000000000004156021266352375300153740ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; Copyright (c) 1984, Taiichi Yuasa and Masami Hagiya. ;;;; Copyright (c) 1990, Giuseppe Attardi. ;;;; ;;;; This program is free software; you can redistribute it and/or modify ;;;; it under the terms of the GNU General Public License as published by ;;;; the Free Software Foundation; either version 2 of the License, or ;;;; (at your option) any later version. ;;;; ;;;; See file '../Copyright' for full details. ;;;; setdoc.lsp ;;;; ;;;; Sets doc-strings for built-in symbols. (in-package "COMPILER") ; in case it does not exist (in-package "SYSTEM") (defmacro docfun (symbol kind args doc) (do-docfun symbol kind args doc)) (defun do-docfun (symbol kind args doc) ;(print symbol) (assert (listp args)) (ext:annotate symbol ':lambda-list nil args) (cond ((and doc (search "Syntax:" doc)) (setf args nil)) ((and doc (search "Args:" doc)) (setf args nil)) ((member kind '(macro special)) (setf args (format nil "Syntax: ~A" args))) (t (setf args (format nil "Args: ~A" args)))) (si::set-documentation symbol 'function (format nil "~A in ~A package:~@[~%~A~]~@[~%~A~]~%" (ecase kind (special "Special Form") (macro "Macro") (function "Function") (method "Generic function")) (package-name (symbol-package (si::function-block-name symbol))) args doc))) (defmacro docvar (symbol kind doc) (do-docvar symbol kind doc)) (defun do-docvar (symbol kind doc) ;(print symbol) (si::set-documentation symbol 'variable (format nil "~@(~A~) in ~A package:~A~%" kind (package-name (symbol-package symbol)) doc))) (defmacro doctype (symbol doc) (do-doctype symbol doc)) (defun do-doctype (symbol doc) ;(print symbol) (si::set-documentation symbol 'type doc)) (defun tree-search (tree x) (cond ((eq tree x) t) ((atom tree) nil) ((tree-search (car tree) x) t) (t (tree-search (cdr tree) x)))) (defun our-pde-hook (location definition output-form) (when (consp definition) (handler-case (let* ((documentation nil) (name (second definition))) (loop for i in (cddr definition) do (cond ((stringp i) (setf documentation i) (return)) ((and (consp i) (eq (first i) 'DECLARE)) ;; Produce no documentation for si::c-local functions (when (tree-search i 'si::c-local) (return-from our-pde-hook output-form))) (t (return)))) (case (first definition) (defun (do-docfun name 'function (third definition) documentation)) (defmacro (do-docfun name 'macro (third definition) documentation)) ((defvar defparameter) (when documentation (do-docvar name 'variable documentation))) (defconstant (when documentation (do-docvar name 'constant documentation))) (deftype (when documentation (do-doctype name documentation))))) (error (c) (princ c) (quit)))) output-form) (setf ext:*register-with-pde-hook* #'our-pde-hook) #|| (defmacro docfun (symbol kind args string) `(progn (si::putprop ',symbol ,string 'si::function-documentation) (si::putprop ',symbol ',args 'arglist) ',symbol)) (defmacro docvar (symbol kind string) (declare (ignore kind)) `(progn (si::putprop ',symbol ,string 'si::variable-documentation) ',symbol)) (defmacro doctype (symbol string) `(progn (si::putprop ',symbol ,string 'si::type-documentation) ',symbol)) ||# ;;;---------------------------------------------------------------------- ;;; Ordered alphabetically for binary search ;;;---------------------------------------------------------------------- (docvar + variable " The last top-level form.") (docvar ++ variable " The last-but-one top-level form.") (docvar +++ variable " The last-but-two top-level form.") (docvar / variable " The list of all values of the last top-level form.") (docvar // variable " The list of all values of the last-but-one top-level form.") (docvar /// variable " The list of all values of the last-but-two top-level form.") (docvar - variable " The top-level form ECL is currently evaluating.") (docvar * variable " The value of the last top-level form.") (docfun * function (&rest numbers) " Returns the product of the args. With no args, returns 1.") (docvar *debugger-hook* variable " This is either NIL or a function of two arguments, a condition and the value of *DEBUGGER-HOOK*. This function can either handle the condition or return which causes the standard debugger to execute. The system passes the value of this variable to the function because it binds *DEBUGGER-HOOK* to NIL around the invocation.") (docvar *debug-io* variable " The stream used by the ECL debugger. The initial value is a synonym stream to *TERMINAL-IO*.") (docvar *default-pathname-defaults* variable " The default pathname used by some pathname-handling functions such as ENOUGH- NAMESTRING.") (docvar *error-output* variable " The output stream to which error messages are output. The initial value is an synonym stream to *TERMINAL-IO*.") (docvar *features* variable " List of symbols that name features of the current version of ECL. These features are used in connection with the read macros #+ and #-. When the reader encounters #+ feature-spec form it reads FORM in the usual manner if FEATURE-SPEC is satisfied. Otherwise, the reader just skips FORM. #- feature-spec form is equivalent to #- (not feature-spec) form A feature-spec may be a symbol, in which case the spec is satisfied iff the symbol is an element of *FEATURES*. Or else, a feature-spec must be one of the following forms. (and {feature-spec}*) Satisfied iff all FEATURE-SPECs are satisfied (or {feature-spec}*) Satisfied iff at least one of FEATURE-SPECs is satisfied (not feature-spec) Satisfied iff FEATURE-SPEC is not satisfied") #-boehm-gc (docvar si::*gc-message* variable " ECL specific. If the value of SI::*GC-MESSAGE* is non-NIL, the garbage collector prints some debugging information on the terminal. Usually SI::*GC-MESSAGE* is set NIL.") #-boehm-gc (docvar si::*gc-verbose* variable " ECL specific. If the value of this variable is non-NIL, then the garbage collector notifies that it begins to run whenever it is invoked. Otherwise, garbage collection begins silently.") (docvar si::*ignore-eof-on-terminal-io* variable " ECL specific. If the value of this variable is non-NIL, ECL ignores the EOF-character (usually ^D) on the terminal. The initial value is NIL.") #-boehm-gc (docfun si::ignore-maximum-pages function (&optional (boolean t)) " ECL specific. Tells the ECL memory manager whether (non-NIL) or not (NIL) it should expand memory when the maximum allocatable pages have been used up. The initial value is T. If no arguments are passed, returns the current value of the flag.") (docvar si::*indent-formatted-output* variable " ECL specific. The FORMAT directive ~~% indents the next line, if the value of this variable is non-NIL. If NIL, ~~% simply does Newline.") (docvar si::*interrupt-enable* variable " ECL specific. If the value of SI::*INTERRUPT-ENABLE* is non-NIL, ECL signals an error on the terminal interrupt (this is the default case). If it is NIL, ECL ignores the interrupt and assigns T to SI::*INTERRUPT-ENABLE*.") (docvar ext::*invoke-debugger-hook* variable " ECL specific. This is either NIL or a designator for a function of two arguments, to be run when the debugger is about to be entered. The function is run with *INVOKE-DEBUGGER-HOOK* bound to NIL to minimize recursive errors, and receives as arguments the condition that triggered debugger entry and the previous value of *INVOKE-DEBUGGER-HOOK* This mechanism is an extension similar to the standard *DEBUGGER-HOOK*. In contrast to *DEBUGGER-HOOK*, it is observed by INVOKE-DEBUGGER even when called by BREAK.") #-boehm-gc (docvar si::*lisp-maxpages* variable " ECL specific. The current maximum number of pages (1 page = 2048 bytes) for the ECL process. The result of changing the value of SI::*LISP-MAXPAGES* is unpredictable.") (docvar *load-verbose* variable " The default value for the :VERBOSE parameter of LOAD. It initial value is T.") (docvar *macroexpand-hook* variable " The value of this variable must be a three-argument function object. Each time a macro form is expanded, ECL calls that function with 1. the macro expansion function (see MACRO-FUNCTION) 2. the macro form to expand 3. an environment (NIL in most case) as three arguments, and uses the returned value as the expanded form. The initial value of this variable is the function FUNCALL.") (docfun si::*make-constant function (symbol value) " ECL specific. Declares that the global variable named by SYMBOL is a constant with VALUE as its constant value.") (docfun si::*make-special function (symbol) " ECL specific. Declares the variable named by NAME as a special variable.") (docvar *package* variable " The current package. The initial value is the USER package.") (docvar *print-array* variable " Specifies whether ECL should print elements when it prints arrays other than strings. ECL uses the following abbreviation notations. # for bit-vectors # for vectors other than strings and bit-vectors # for arrays other than vectors where N is a number that identifies the array.") (docvar *print-base* variable " The radix used to print integers and ratios. The value must be an integer from 2 to 36, inclusive. The initial value is 10.") (docvar *print-case* variable " Specifies how to print ordinary symbols. Possible values are: :UPCASE in upper case :DOWNCASE in lower case :CAPITALIZE the first character in upper case, the rest in lower The initial value is :UPCASE.") (docvar *print-circle* variable " Specifies whether the ECL printer should take care of circular lists.") (docvar *print-escape* variable " Specifies whether the ECL printer should output objects in the way that they can be reread later if possible.") (docvar *print-gensym* variable " Specifies whether the ECL printer should prefix uninterned symbols with \"#:\".") (docvar *print-length* variable " Specifies how many elements the ECL printer should print when it prints a list. ECL printer prints all elements if the value of this variable is NIL.") (docvar *print-level* variable " Specifies how many levels of depth the ECL printer should print when it prints a list. ECL printer prints all levels if the value of this variable is NIL.") (docvar *print-pretty* variable " Specifies whether the ECL printer should pretty-print. See PPRINT for more information about pretty-printing.") (docvar *print-radix* variable " Specifies whether the ECL printer should print the radix when it prints integers and ratios.") #+profile (docvar si::*profile-array* variable " ECL specific. Contains the profile histogram: two short integer counters are packed in each value of this array of fixnums.") (docvar *query-io* variable " The query I/O stream. The initial value is a synonym stream to *TERMINAL-IO*.") (docvar *random-state* variable " The default random-state object used by RANDOM.") (docvar *read-base* variable " The radix used to read numbers. The initial value is 10.") (docvar *read-default-float-format* variable " The default float format the ECL reader uses when reading floats. Must be one of the symbols SHORT-FLOAT, SINGLE-FLOAT, DOUBLE-FLOAT, and LONG-FLOAT.") (docvar *read-suppress* variable " When the value of this variable is non-NIL, the ECL reader parses input characters without most of the ordinary processings such as interning. Used to skip over forms.") (docvar *readtable* variable " The current readtable.") (docvar *standard-input* variable " The default input stream used by the ECL reader. The initial value is a synonym stream to *TERMINAL-IO*.") (docvar *standard-output* variable " The default output stream used by the ECL printer. The initial value is a synonym stream to *TERMINAL-IO*.") (docvar *terminal-io* variable " The terminal I/O stream.") (docvar *trace-output* variable " The stream used for trace output. The initial value is a synonym stream to *TERMINAL-IO*.") (docfun + function (&rest numbers) " Returns the sum of the args. With no args, returns 0.") (docfun - function (number &rest more-numbers) " Returns the first arg subtracted by the rest of args. With one arg, returns - NUMBER.") (docfun / function (number &rest more-numbers) " Returns the first arg divided by the rest of args. With one arg, returns 1/NUMBER.") (docfun /= function (number &rest more-numbers) " Returns T if no two of the args are numerically equal; NIL otherwise.") (docfun 1+ function (number) " Returns NUMBER plus one.") (docfun 1- function (number) " Returns NUMBER minus one.") (docfun < function (number &rest more-numbers) " Returns T if the args are in increasing order; NIL otherwise.") (docfun <= function (number &rest more-numbers) " Returns T if the args are in non-decreasing order; NIL otherwise.") (docfun = function (number &rest more-numbers) " Returns T if all args are numerically equal; NIL otherwise.") (docfun > function (number &rest more-numbers) " Returns T if the args are in decreasing order; NIL otherwise.") (docfun >= function (number &rest more-numbers) " Returns T if the args are in non-increasing order; NIL otherwise.") (docfun abs function (number) " Returns the absolute value of NUMBER.") (docfun acons function (key datum alist) " Equivalent to (CONS (CONS KEY DATUM) ALIST).") (docfun adjoin function (item list &key (key '#'identity) (test '#'eql) test-not) " Returns cons of ITEM and LIST unless ITEM is already an element of LIST. Otherwise, returns LIST.") (docfun adjustable-array-p function (array) " Returns T if ARRAY is adjustable; NIL otherwise.") #-boehm-gc (docfun allocate function (type number &optional (really-allocate nil)) " ECL specific. Sets the maximum number of pages for the type class of the ECL implementation type TYPE to NUMBER. If REALLY-ALLOCATE is non-NIL, then the specified number of pages will be allocated immediately.") #-boehm-gc (docfun si::allocate-contiguous-pages function (number &optional (really-allocate nil)) " ECL specific. Sets the maximum number of pages for contiguous blocks to NUMBER. If REALLY- ALLOCATE is non-NIL, then the specified number of pages will be allocated immediately.") #+clos (docfun si::allocate-gfun function (name arity hash-table) " ECL/CLOS specific. Allocates a gfun object in which NAME is the generic function name, ARITY is the number of arguments and HASH-TABLE is the hashtable for cashing methods.") #+clos (docfun si::allocate-instance function (class length) " ECL/CLOS specific. Allocates an istance of CLASS with LENGTH slots.") #-boehm-gc (docfun si::allocated-contiguous-pages function () " ECL specific. Returns the number of pages currently allocated for contiguous blocks.") #-boehm-gc (docfun si::allocated-pages function (type) " ECL specific. Returns the number of pages currently allocated for the type class of the ECL implementation type TYPE.") (docfun alpha-char-p function (char) " Returns T if CHAR is alphabetic; NIL otherwise.") (docfun alphanumericp function (char) " Returns T if CHAR is either numeric or alphabetic; NIL otherwise.") (docfun and macro (&rest forms) " Evaluates FORMs in order. If any FORM evaluates to NIL, returns immediately with the value NIL. Otherwise, returns all values of the last FORM.") (docfun append function (&rest lists) " Constructs and returns a new list by concatenating the args.") (docfun apply function (function arg &rest more-args) " Calls FUNCTION with all ARGs except the last and all elements of the last ARG as the arguments to FUNCTION. Returns all values that FUNCTION returns.") (docfun applyhook function (function list evalhookfn applyhookfn &optional (env nil)) " Calls FUNCTION with all elements of LIST as the arguments and with *EVALHOOK* and *APPLYHOOK* bound to EVALHOOKFN and APPLYHOOKFN respectively. Returns all values that FUNCTION returns.") (docfun aref function (array &rest indexes) " Returns the element of ARRAY specified by INDEXES.") (docfun si::argc function () " ECL specific. Returns the number of arguments given in the command line that invoked ECL.") (docfun si::argv function (n) " ECL specific. Returns the N-th argument given in the command line that invoked ECL.") (doctype array " An array is a compound object whose elements are referenced by indexing. One- dimensional arrays are called vectors. Other arrays are notated as #?a( ... ) or #?A( ... ) where '?' is actually the rank of the array. Arrays may be displaced to another array, may have a fill-pointer, or may be adjustable. Other arrays are called simple-arrays. Only simple-arrays can be input in the above format.") (docfun array-dimension function (array n) " Returns the length of the N-th dimension of ARRAY.") (docvar array-dimension-limit constant " The upper bound of the length of an array dimension.") (docfun array-element-type function (array) " Returns the element type ARRAY.") (docfun array-has-fill-pointer-p function (array) " Returns T if ARRAY has a fill-pointer; NIL otherwise.") (docfun array-rank function (array) " Returns the rank of ARRAY.") (docvar array-rank-limit constant " The upper bound of the rank of an array.") (docfun array-total-size function (array) " Returns the total number of elements of ARRAY.") (docvar array-total-size-limit constant " The upper bound of the total number of elements of an array.") (docfun arrayp function (x) " Returns T if X is an array; NIL otherwise.") (docfun ash function (integer count) " Returns the integer obtained by shifting the bits that represent INTEGER as specified by COUNT. Shifts left in COUNT bits if COUNT is positive. Shifts right in -COUNT bits if COUNT is negative.") (docfun assoc function (item alist &key (test '#'eql) test-not (key '#'identity)) " Returns the first pair in ALIST whose car is equal (in the sense of TEST) to ITEM. Returns NIL if no such pair exists. The function KEY is applied to extract the key for comparison.") (docfun atan function (x &optional (y 1)) " Returns the arc tangent of X/Y.") (docfun atom function (x) " Returns T if X is not a cons; NIL otherwise.") (docfun si::bds-val function (n) " ECL specific. Returns the value of the N-th entity in the bind stack.") (docfun si::bds-var function (n) " ECL specific. Returns the symbol of the N-th entity in the bind stack.") (doctype bignum " A bignum is an integer that is not a fixnum.") (docfun bit-vector-p function (x) " Returns T if X is a bit-vector; NIL otherwise.") (docfun block special (name &body forms) " Establishes a block named by NAME, evaluates FORMs in order, and returns all values of the last FORM. Returns NIL if no FORMs are given. The scope of the established block is the body (i.e. the FORMs) of the BLOCK form. If (return-from name value-form) is evaluated within the scope, the execution of the BLOCK form terminates immediately and all values of VALUE-FORM will be returned as the values of the terminated BLOCK form.") (docfun boole function (op integer1 integer2) " Returns the integer produced by the logical operation specified by OP on the two integers. OP must be the value of one of the following constants. BOOLE-CLR BOOLE-C1 BOOLE-XOR BOOLE-ANDC1 BOOLE-SET BOOLE-C2 BOOLE-EQV BOOLE-ANDC2 BOOLE-1 BOOLE-AND BOOLE-NAND BOOLE-ORC1 BOOLE-2 BOOLE-IOR BOOLE-NOR BOOLE-ORC2 Each logical operation on integers produces an integer represented by the bit sequence obtained by a bit-wise logical operation on the bit sequences that represent the integers. Two's-complement representation is assumed to obtain the bit sequence that represents an integer. For example, 2: ...010 1: ...001 0: ...000 -1: ...111 -2: ...110 where each '...' represents either an infinite sequence of 0's (for non- negative integers) or an infinite sequence of 1's (for negative integers).") (docvar boole-1 constant " Makes BOOLE return INTEGER1.") (docvar boole-2 constant " Makes BOOLE return INTEGER2.") (docvar boole-and constant " Makes BOOLE return the AND of INTEGER1 and INTEGER2.") (docvar boole-andc1 constant " Makes BOOLE return the AND of {the NOT of INTEGER1} and INTEGER2.") (docvar boole-andc2 constant " Makes BOOLE return the AND of INTEGER1 and {the NOT of INTEGER2}.") (docvar boole-c1 constant " Makes BOOLE return the NOT of INTEGER1.") (docvar boole-c2 constant " Makes BOOLE return the NOT of INTEGER2.") (docvar boole-clr constant " Makes BOOLE return 0.") (docvar boole-eqv constant " Makes BOOLE return the EQUIVALENCE of INTEGER1 and INTEGER2.") (docvar boole-ior constant " Makes BOOLE return the INCLUSIVE OR of INTEGER1 and INTEGER2.") (docvar boole-nand constant " Makes BOOLE return the NOT of {the AND of INTEGER1 and INTEGER2}.") (docvar boole-nor constant " Makes BOOLE return the NOT of {the INCLUSIVE OR of INTEGER1 and INTEGER2}.") (docvar boole-orc1 constant " Makes BOOLE return the INCLUSIVE OR of {the NOT of INTEGER1} and INTEGER2.") (docvar boole-orc2 constant " Makes BOOLE return the INCLUSIVE OR of INTEGER1 and {the NOT of INTEGER2}.") (docvar boole-set constant " Makes BOOLE return -1.") (docvar boole-xor constant " Makes BOOLE return the EXCLUSIVE OR of INTEGER1 and INTEGER2.") (docfun both-case-p function (char) " Returns T if CHAR is an alphabetic character; NIL otherwise. Equivalent to ALPHA-CHAR-P.") (docfun boundp function (symbol) " Returns T if the global variable named SYMBOL has a value; NIL otherwise.") #| (docfun compiler:build-ecl function (program-name &rest components) " Builds a standalone executable using the object files, libraries and flags which follow PROGRAM-NAME, which is the name of the final executable. Each argument in COMPONENTS can be either a symbol or a string. If it is a string, it is passed as such to the C compiler when building the program. This way you can specify FASL code (i.e. compiled lisp code) and additional libraries or custom C code. However, if the argument is a symbol, it is interpreted as the name of a lisp library of FASL code. You should use symbols to call in optional parts of the interpreter, such as the compiler 'CMP or the 'CLX library (not yet available) For example: (compile-file \"my-code.lsp\" :system-p) (build-ecl \"my-ecl\" \"my-code.o\" \"-Bdynamic -lX11\" 'cmp) builds an new interpreter with some custom lisp code given in \"my-code.o\" and with the ECL compiler (You must explicitely mention the compiler if you want it). Finally, the X-Windows dynamically linked libraries are also included because \"my-code.lsp\" uses the foreign function interface to do some graphics.") |# (docfun butlast function (list &optional (n 1)) " Returns a copy of LIST with the last N elements removed.") (docfun by function () " ECL specific. Exits from ECL. Equivalent to BYE.") (docfun bye function () " ECL specific. Exits from ECL. Equivalent to BY.") (docfun caaaar function (x) " Equivalent to (CAR (CAR (CAR (CAR X)))).") (docfun caaadr function (x) " Equivalent to (CAR (CAR (CAR (CDR X)))).") (docfun caaar function (x) " Equivalent to (CAR (CAR (CAR X))).") (docfun caadar function (x) " Equivalent to (CAR (CAR (CDR (CAR X)))).") (docfun caaddr function (x) " Equivalent to (CAR (CAR (CDR (CDR X)))).") (docfun caadr function (x) " Equivalent to (CAR (CAR (CDR X))).") (docfun caar function (x) " Equivalent to (CAR (CAR X)).") (docfun cadaar function (x) " Equivalent to (CAR (CDR (CAR (CAR X)))).") (docfun cadadr function (x) " Equivalent to (CAR (CDR (CAR (CDR X)))).") (docfun cadar function (x) " Equivalent to (CAR (CDR (CAR X))).") (docfun caddar function (x) " Equivalent to (CAR (CDR (CDR (CAR X)))).") (docfun cadddr function (x) " Equivalent to (CAR (CDR (CDR (CDR X)))).") (docfun caddr function (x) " Equivalent to (CAR (CDR (CDR X))).") (docfun cadr function (x) " Equivalent to (CAR (CDR X)).") (docvar call-arguments-limit constant " The upper bound of the number of arguments to a function. Ignore this value since there is no such logical upper bound in ECL.") (docfun car function (x) " Returns the car of X if X is a cons. Returns NIL if X is NIL.") (docfun case macro (keyform &rest alternatives) " Syntax: (case keyform {({key | ({key}*)} {form}*)}*) Evaluates KEYFORM and searches a KEY that is EQL to the value of KEYFORM. If found, then evaluates FORMs in order that follow the KEY (or the key list that contains the KEY) and returns all values of the last FORM. Returns NIL if no such key is found. The symbols T and OTHERWISE may be used at the place of a key list to specify the default case.") (docfun catch special (tag-form &body forms) " Syntax: (catch tag-form {form}*) Sets up a catcher whose catch tag is the value of TAG-FORM. Then evaluates FORMs in order and returns all values of the last FORM. During the evaluation of FORMs, if a THROW form is evaluated that specifies a catch tag EQ to the value of the TAG-FORM, then the execution of the CATCH form terminates immediately and the values specified by the THROW form are returned as the value of the CATCH form.") (docfun cdaaar function (x) " Equivalent to (CDR (CAR (CAR (CAR X)))).") (docfun cdaadr function (x) " Equivalent to (CDR (CAR (CAR (CDR X)))).") (docfun cdaar function (x) " Equivalent to (CDR (CAR (CAR X))).") (docfun cdadar function (x) " Equivalent to (CDR (CAR (CDR (CAR X)))).") (docfun cdaddr function (x) " Equivalent to (CDR (CAR (CDR (CDR X)))).") (docfun cdadr function (x) " Equivalent to (CDR (CAR (CDR X))).") (docfun cdar function (x) " Equivalent to (CDR (CAR X)).") (docfun cddaar function (x) " Equivalent to (CDR (CDR (CAR (CAR X)))).") (docfun cddadr function (x) " Equivalent to (CDR (CDR (CAR (CDR X)))).") (docfun cddar function (x) " Equivalent to (CDR (CDR (CAR X))).") (docfun cdddar function (x) " Equivalent to (CDR (CDR (CDR (CAR X)))).") (docfun cddddr function (x) " Equivalent to (CDR (CDR (CDR (CDR X)))).") (docfun cdddr function (x) " Equivalent to (CDR (CDR (CDR X))).") (docfun cddr function (x) " Equivalent to (CDR (CDR X)).") (docfun cdr function (x) " Returns the cdr of X if X is a cons. Returns NIL if X is NIL.") (docfun ceiling function (number &optional (divisor 1)) " Returns the smallest integer not less than NUMBER/DIVISOR. Returns the value of (- NUMBER (* first-value DIVISOR)) as the second value.") (docfun cerror function (continue-format-string error-format-string &rest args) " Signals a continuable error.") (docfun char function (string index) " Returns the INDEX-th character in STRING.") (docfun char-bit function (char name) " Returns T if the specified bit attribute of CHAR is 'on'; NIL otherwise. In ECL the bit-attributes handled are :control :meta :super and :hyper") (docfun char-bits function (char) " Returns the bit attributes of CHAR as an integer. In ECL it returns a value between 0 and 16, since ECL handle 4 bit attributes.") (docvar char-bits-limit constant " The upper bound of values returned by CHAR-BITS. 16 in ECL.") (docfun char-code function (char) " Returns the character code of CHAR as a fixnum.") (docvar char-code-limit constant " The upper bound of values returned by CHAR-CODE.") (docvar char-control-bit constant " The bit position indicating a control character. 1 in ECL.") (docfun char-downcase function (char) " Returns the lower-case character corresponding to CHAR, if CHAR is upper-case. Otherwise, returns CHAR.") (docfun char-equal function (char &rest more-chars) " Returns T if all CHARs are the same; NIL otherwise. Lower-case characters are regarded the same as the corresponding upper-case characters.") (docfun char-font function (char) " Returns the font attribute of CHAR. Returns always 0 in ECL, since ECL characters have no font attributes.") (docvar char-font-limit constant " The upper bound of values returned by CHAR-FONT. 1 in ECL.") (docfun char-greaterp function (char &rest more-chars) " Returns T if the character codes of CHARs are in decreasing order; NIL otherwise. For lower-case characters, codes of corresponding upper-case characters are used.") (docvar char-hyper-bit constant " The bit position indicating a hyper character. 8 in ECL.") (docfun char-int function (char) " Returns the font, bits, and code attributes as an integer. Equivalent to CHAR-CODE in ECL.") (docfun char-lessp function (char &rest more-chars) " Returns T if the character codes of CHARs are in increasing order; NIL otherwise. For lower-case characters, codes of corresponding upper-case characters are used.") (docvar char-meta-bit constant " The bit position indicating a meta character. 2 in ECL.") (docfun char-name function (char) " Returns the 'character name' of CHAR as a string; NIL if CHAR has no character name. Only #\\Backspace, #\\Tab, #\\Newline (or #\\Linefeed), #\\Page, #\\Return, and #\\Rubout have character names in ECL.") (docfun char-not-equal function (char &rest more-chars) " Returns T if no two of CHARs are the same; NIL otherwise. Lower-case characters are regarded the same as the corresponding upper-case characters.") (docfun char-not-greaterp function (char &rest more-chars) " Returns T if the character codes of CHARs are in non-decreasing order; NIL otherwise. For lower-case characters, codes of corresponding upper-case characters are used.") (docfun char-not-lessp function (char &rest more-chars) " Returns T if the character codes of CHARs are in non-increasing order; NIL otherwise. For lower-case characters, codes of corresponding upper-case characters are used.") (docvar char-super-bit constant " The bit position indicating a super character. 4 in ECL.") (docfun char-upcase function (char) " Returns the upper-case character of CHAR, if CHAR is lower-case. Otherwise, returns CHAR.") (docfun char/= function (char &rest more-chars) " Returns T if no two of CHARs are the same; NIL otherwise.") (docfun char< function (char &rest more-chars) " Returns T if the character codes of CHARs are in increasing order; NIL otherwise.") (docfun char<= function (char &rest more-chars) " Returns T if the character codes of CHARs are in non-decreasing order; NIL otherwise.") (docfun char= function (char &rest more-chars) " Returns T if all CHARs are the same; NIL otherwise.") (docfun char> function (char &rest more-chars) " Returns T if the character codes of CHARs are in decreasing order; NIL otherwise.") (docfun char>= function (char &rest more-chars) " Returns T if the character codes of CHARs are in non-increasing order; NIL otherwise.") (doctype character " A character represents a character that can be handled by the computer. Characters have font, bits, and code attributes. Font and bits attributes are always 0 in ECL. Most versions of ECL uses ASCII code: 000 - 037 #\\^@ #\\^A #^B ... #\\Z #\\^[ #\\^\\ #\\^] #\\^^ #\\^_ except #\\Tab(011) #\\Newline(012) #\\Page(014) #\\Return(015) #\\Backspace(031) 040 - 057 #\\Space #\\! #\\\" #\\# #\\$ #\\% #\\& #\\' #\\( #\\) #\\* #\\+ #\\, #\\- #\\. #\\/ 060 - 071 #\\0 #\\1 #\\2 #\\3 #\\4 #\\5 #\\6 #\\7 #\\8 #\\9 072 - 100 #\\: #\\; #\\< #\\= #\\> #\\? #\\@ 101 - 132 #\\A ... #\\Z 133 - 140 #\\[ #\\\\ #\\] #\\^ #\\_ #\\` 141 - 172 #\\a ... #\\z 173 - 177 #\\{ #\\| #\\} #\\~~ #\\Rubout Some versions of ECL support additional characters to represent Japanese character set.") (docfun character function (x) " Coerces X into a character if possible. Signals an error if not possible.") (docfun characterp function (x) " Returns T if X is a character; NIL otherwise.") (docfun ext:getcwd function (&optional (update-lisp t)) " Returns the current working directory of the C library. When UPDATE-LISP is true, *DEFAULT-PATHNAME-DEFAULTS* is set to this value.") (docfun ext:chdir function (filespec &optional (update-lisp t)) " Changes the current working directory of the C library to the one specified by FILESPEC. FILESPEC may be a symbol, a string, or a pathname. UPDATE-LISP determines whether the value of *DEFAULT-PATHNAME-DEFAULTS* is also to be changed.") (docfun clear-input function (&optional (stream *standard-input*)) " Clears the input buffer of STREAM and returns NIL. Contents of the buffer are discarded.") (docfun clear-output function (&optional (stream *standard-output*)) " Clears the output buffer of STREAM and returns NIL. Contents of the buffer are discarded.") (docfun ffi:clines special (&body c-strings) " Syntax: (clines {string}*) The ECL compiler embeds STRINGs into the intermediate C language code. The interpreter ignores this form.") #|| eliminated. Beppe (docfun cdeclaration macro "(cdeclaration {string}*)" " ECL specific. The ECL compiler embeds STRINGs into the intermediate H language code. The interpreter ignores this form.") (docfun cinitialization macro "(cinitialization {string}*)" " ECL specific. The ECL compiler embeds STRINGs into the intermediate C language init_code function. This allows to perform initialization operations when the binary file is loaded. The interpreter ignores this form.") ||# (docfun close function (stream &key (abort nil)) " Closes STREAM. Returns NIL if STREAM is closed successfully; non-NIL otherwise. A non-NIL value of ABORT indicates an abnormal termination but ECL ignores it.") (docfun clrhash function (hash-table) " Removes all entries of HASH-TABLE and returns HASH-TABLE.") (docfun code-char function (code &optional (bits 0) (font 0)) " Returns a character with the specified character code, if any. Returns NIL if no such character exists. BITS and FONT specify the bits and font attributes of the returned character but are both ignored in ECL.") (doctype common " COMMON is the type of all Common Lisp data objects.") (docfun commonp function (x) " Returns T if X is a Common Lisp object; NIL otherwise.") (doctype compiled-function " A compiled function is an object that is created by compiling a function. A compiled function is notated in either of the following formats: # # where S is actually the symbol that names the function.") (docfun si::compiled-function-name function (compiled-function) " ECL specific. Returns the function name associated with COMPILED-FUNCTION.") (docfun compiled-function-p function (x) " Returns T if X is a compiled function object; NIL otherwise.") (docfun compiler-let special (bindings &body forms) "Syntax: (compiler-let ({var | (var [value])}*) {form}*) When interpreted, this form works just like a LET form with all VARs declared special. When compiled, FORMs are processed with the VARs bound at compile time, but no bindings occur when the compiled code is executed.") (doctype complex " A complex number represents a complex number in mathematical sense, consisting of a real part and an imaginary part. A complex number is notated as #c( realpart imagpart ) or #C( realpart imagpart ) where REALPART and IMAGPART are non-complex numbers.") (docfun complex function (realpart &optional (imagpart 0)) " Returns a complex number with the given realpart and imagpart. Returns REALPART if it is a rational and IMAGPART is 0.") (docfun complexp function (x) " Returns T if X is a complex number; NIL otherwise.") (docfun conjugate function (number) " Returns the complex conjugate of NUMBER. Returns NUMBER if it is not a complex number.") (doctype cons " A cons is a compound object consisting of two components car and cdr.") (docfun cons function (x y) " Returns a new cons whose car and cdr are X and Y respectively.") (docfun consp function (x) " Returns T if X is a cons; NIL otherwise.") (docfun constantp function (x) " Returns T if ECL is sure that X, when given as a form, always evaluates to a same value. Returns NIL otherwise. Typically used to check whether a symbol names a constant variable.") (docfun copy-alist function (alist) " Returns a new list consisting of copies of all pairs in ALIST.") (docfun copy-list function (list) " Returns a new list consisting of all elements in LIST.") (docfun copy-readtable function (&optional (readtable *readtable*) (to-readtable nil)) " Returns a new copy of READTABLE. If TO-READTABLE is non-NIL, then copies the contents of READTABLE into TO-READTABLE and returns TO-READTABLE.") (docfun copy-seq function (sequence) " Returns a new copy of SEQUENCE.") (docfun copy-symbol function (symbol &optional (flag nil)) " Returns a new uninterned symbol with the same print name as SYMBOL. If FLAG is NIL, the symbol property of the new symbol is empty. Otherwise, the new symbol gets a copy of the property list of SYMBOL.") (docfun copy-tree function (tree) " Returns a copy of TREE. Defined as: (defun copy-tree (tree) (if (atom tree) tree (cons (copy-tree (car tree)) (copy-tree (cdr tree)))))") (docfun cos function (radians) " Returns the cosine of RADIANS.") (docfun cosh function (number) " Returns the hyperbolic cosine of NUMBER.") (docfun count function (item sequence &key (key '#'identity) (test '#'eql) test-not (start 0) (end (length sequence)) (from-end nil)) " Returns the number of elements in SEQUENCE satisfying TEST with ITEM as the first argument.") (docfun count-if function (test sequence &key (key '#'identity) (start 0) (end (length sequence)) (from-end nil)) " Returns the number of elements in SEQUENCE satisfying TEST.") (docfun count-if-not function (test sequence (start 0) (end (length sequence)) (from-end nil)) " Returns the number of elements in SEQUENCE not satisfying TEST.") (docfun declare special (&rest declaration-specifiers) "Syntax: (declare {decl-spec}*) Gives declarations. Possible DECL-SPECs are: (SPECIAL {var}*) (TYPE type {var}*) (type {var}*) where 'type' is one of the following symbols array fixnum package simple-string atom float pathname simple-vector bignum function random-state single-float bit hash-table ratio standard-char bit-vector integer rational stream character keyword readtable string common list sequence string-char compiled-function long-float short-float symbol complex nil signed-byte t cons null simple-array unsigned-byte double-float number simple-bit-vector vector (OBJECT {var}*) (FTYPE type {function-name}*) (FUNCTION function-name ({arg-type}*) {return-type}*) (INLINE {function-name}*) (NOTINLINE {function-name}*) (IGNORE {var}*) (OPTIMIZE {({SPEED | SPACE | SAFETY | COMPILATION-SPEED} {0 | 1 | 2 | 3})}*) (DECLARATION {non-standard-decl-name}*) (:READ-ONLY {variable-name}*).") (docfun decode-float function (float) " Returns the significand F, the exponent E, and the sign S of FLOAT. These values satisfy 1/B <= F < 1 and E FLOAT = S * F * B where B is the radix used to represent FLOAT. S and F are floats of the same float format as FLOAT, and E is an integer.") (docfun defun macro (name lambda-list &body) "Syntax: (defun name lambda-list {decl | doc}* {form}*) Defines a global function named by NAME. The complete syntax of a lambda-list is: ({var}* [&optional {var | (var [init [svar]])}*] [&rest var] [&key {var | ({var | (keyword var)} [init [svar]])}* [&allow-other-keys]] [&aux {var | (var [init])}*]) The doc-string DOC, if supplied, is saved as a FUNCTION doc and can be retrieved by (documentation 'NAME 'function).") (docfun defmacro macro (name lambda-list &body body) "Syntax: (defmacro name defmacro-lambda-list {decl | doc}* {form}*) Defines a global macro named by NAME. The complete syntax of DEFMACRO-LAMBDA- LIST is: ( [&whole var] [&environment var] . pvar ) where PVAR may be a symbol, ( {pvar}* [&optional {var | (pvar [init [pvar]])}*] . var ) or ( {pvar}* [&optional {var | (pvar [init [pvar]])}*] [{&rest | &body} pvar] [&key {var | ({var | (keyword pvar)} [init [pvar]])}* [&allow-other-keys]] [&aux {var | (pvar [init])}*] ) The doc-string DOC, if supplied, is saved as a FUNCTION doc and can be retrieved by (documentation 'NAME 'function). See LIST for the backquote macro useful for defining macros.") (docfun delete function (item sequence &key (key '#'identity) (test '#'eql) test-not (start 0) (end (length sequence)) (count most-positive-fixnum) (from-end nil)) " Destructive REMOVE. SEQUENCE may be destroyed.") (docfun delete-file function (filespec) " Deletes the specified file. FILESPEC may be a symbol, a string, a pathname, or a file stream.") (docfun delete-if function (test sequence &key (key '#'identity) (start 0) (end (length sequence)) (count most-positive-fixnum) (from-end nil)) " Destructive REMOVE-IF. SEQUENCE may be destroyed") (docfun delete-if-not function (test sequence &key (key '#'identity) (start 0) (end (length sequence)) (count most-positive-fixnum) (from-end nil)) " Destructive REMOVE-IF-NOT. SEQUENCE may be destroyed") (docfun denominator function (rational) " Returns the denominator of RATIONAL as a positive integer, if RATIONAL is a ratio. Returns RATIONAL if it is an integer.") (docfun digit-char function (digit &optional (n 10) (font 0)) " Returns a character that represents the DIGIT in radix N. Returns NIL if no such character exists.") (docfun digit-char-p function (char &optional (n 10)) " If CHAR represents a digit in radix N, then returns an integer represented by that digit. Otherwise, returns NIL.") (docfun directory function (filespec &key (resolve-symlinks T)) " Returns a list of full pathnames of all those files that match FILESPEC. FILESPEC may be a symbol, a string, a pathname, or a file stream. If RESOLVE-SYMBOLS set to NIL then it doesn't follow symlinks.") (docfun directory-namestring function (filespec) " Returns as a string the directory part of the pathname specified by FILESPEC. FILESPEC may be a symbol, a string, a pathname, or a file stream.") (docfun si::displaced-array-p function (array) " ECL specific. Returns T if the ARRAY is displaced to another array; NIL otherwise.") (docfun do macro (bindings (test &optional result) &body forms) "Syntax: (do ({(var [init [step]])}*) (test {result}*) {decl}* {tag | statement}*) Establishes a NIL block, binds each VAR to the value of the corresponding INIT (which defaults to NIL), and then executes STATEMENTs repeatedly until TEST is satisfied. After each iteration, evaluates STEP and assigns the value to the corresponding VAR. No assignment occurs for those VARs to which STEP is not given. When TEST is satisfied, evaluates RESULTs as a PROGN and returns all values of the last RESULT. Performs variable bindings and assignments in parallel, just as LET and PSETQ do.") (docfun do* macro (bindings (test &optional result) &body forms) "Syntax: (do* ({(var [init [step]])}*) (test {result}*) {decl}* {tag | statement}*) Similar to DO, but performs variable bindings and assignments in serial, just as LET* and SETQ do.") (docfun dolist macro ((var form &optional result) &body forms) "Establishes a NIL block and executes STATEMENTs once for each member of the list value of FORM, with VAR bound to the member. Then evaluates RESULT (which defaults to NIL) and returns all values.") (doctype double-float " A double-float is a double-precision floating point number. DOUBLE-FLOAT as a type specifier is equivalent to LONG-FLOAT in ECL.") (docfun dotimes macro ((var form &optional result) &body forms) "Establishes a NIL block and executes STATEMENTs once for each integer between 0 (inclusive) and the value of FORM (exclusive), with VAR bound to the integer. Then evaluates RESULT (which defaults to NIL) and returns all values.") (docfun eighth function (x) " Equivalent to (CADDDR (CDDDDR X)).") (docfun elt function (sequence n) " Returns the N-th element of SEQUENCE.") (docfun endp function (x) " Returns T if X is NIL. Returns NIL if X is a cons. Otherwise, signals an error.") (docfun enough-namestring function (filespec &optional (defaults *default-pathname-defaults*)) " Returns a string which uniquely identifies the file specified by FILESPEC, with respect to DEFAULTS. FILESPEC and DEFAULTS may be a symbol, a string, a pathname, or a file stream.") (docfun eq function (x y) " Returns T if the args are identical; NIL otherwise.") (docfun eql function (x y) " Returns T if the args satisfy one of the following conditions. 1. identical 2. are numbers of the same type with the same value 3. are characters that represent the same character Returns NIL otherwise.") (docfun equal function (x y) " Returns T if the args satisfy one of the following conditions. 1. EQL 2. are conses with EQUAL cars and EQUAL cdrs 3. are strings of the same length and element-wise EQL 4. are bit-vectors of the same length and element-wise EQL 5. are pathnames with EQUAL slots Returns NIL otherwise.") (docfun equalp function (x y) " Returns T if the args satisfy one of the following conditions. 1. EQUAL 2. are characters that satisfy CHARACTER-EQUAL 3. are numbers that satisfy = 4. are conses with EQUALP cars and EQUALP cdrs 5. are arrays of the same dimensions and element-wise EQUALP Returns NIL otherwise.") (docfun error function (format-string &rest args) " Signals an error. The args are FORMATed to *error-output*.") (docfun eval function (form) " Evaluates FORM and returns all values.") (docfun eval-when special ((&rest situation) &body forms) " Specifies when to evaluate FORMs. Each SITUATION must be one of the following symbols. COMPILE (compile-time) LOAD (load-time of the fasl file) EVAL (load-time of the source file)") (docfun evalhook function (form fun1 fun2 &optional (env nil)) " Evaluates FORM with *EVALHOOK* bound to FUN1 and *APPLYHOOK* bound to FUN2, and returns all the values.") (docfun evenp function (integer) " Returns T if INTEGER is an even number; NIL otherwise.") (docfun exp function (number) " Returns E raised to the power NUMBER, where E is the base of natural logarithms.") (docfun export function (symbol &optional (package *package*)) " Register SYMBOL as an external symbol of PACKAGE. SYMBOL may be a list of symbols.") (docfun expt function (number1 number2) " Returns NUMBER1 raised to the power NUMBER2.") (docfun fboundp function (symbol) " Returns T if SYMBOL names a special form, a global macro, or a global function. Returns NIL otherwise.") (docfun fifth function (x) " Equivalent to (CAR (CDDDDR X)).") (docfun file-author function (filespec) " Returns the author of the specified file, as a string. Returns NIL if the author is unknown. FILESPEC may be a symbol, a string, a pathname, or a file stream.") (docfun file-length function (file-stream) " Returns the length of the specified FILE-STREAM. Returns NIL if the length is unknown.") (docfun file-namestring function (filespec) " Returns as a string the name, type, and version parts of the specified pathname. FILESPEC may be a symbol, a string, a pathname, or a file stream.") (docfun file-position function (file-stream &optional file-position) " With one arg, returns the current position of FILE-STREAM's file pointer as a non-negative integer. Returns NIL if the position is unknown. With two args, resets the file pointer and returns T. Returns NIL if the file pointer cannot be reset. FILE-POSITION may be a non-negative integer, :START, or :END.") (docfun file-write-date function (filespec) " Returns an integer that represents the last write day-and-time of the specified file (See GET-DECODED-TIME). Returns NIL if the last write day- and-time is unknown. FILESPEC may be a symbol, a string, a pathname, or a file stream.") (docfun fill function (sequence item &key (start 0) (end (length sequence))) " Replaces the specified elements of SEQUENCE with ITEM.") (docfun fill-pointer function (vector) " Returns the fill-pointer of VECTOR as an integer. VECTOR must have a fill- pointer.") (docfun find function (item sequence &key (key '#'identity) (test '#'eql) test-not (start 0) (end (length sequence)) (from-end nil)) " Returns the first element in SEQUENCE satisfying TEST with ITEM. Returns NIL if no such element exists.") (docfun find-if function (test sequence &key (key '#'identity) (start 0) (end (length sequence)) (from-end nil)) " Returns the index of the first element in SEQUENCE that satisfies TEST. Returns NIL if no such element exists.") (docfun find-if-not function (test sequence &key (key '#'identity) (start 0) (end (length sequence)) (from-end nil)) " Returns the index of the first element in SEQUENCE that does not satisfy TEST. Returns NIL if no such element exists.") (docfun find-package function (name) " Returns the package whose package name or nickname is NAME. Returns NIL if no such package exists. NAME may be a string or a symbol.") (docfun find-symbol function (string &optional (package *package*)) " Searches PACKAGE for a symbol whose print name is NAME. If such a symbol is found, then returns the symbol as the first value and returns one of the following symbols as the second value. :INTERNAL (internal symbol in PACKAGE) :EXTERNAL (external symbol in PACKAGE) :INHERITED (external symbol of a package that PACKAGE is using) If no such symbol is found, returns NIL as the first and second values.") (docfun finish-output function (&optional (stream *standard-output*)) " Sends the contents of the output buffer for STREAM to the destination. Waits until the buffer becomes empty and then returns NIL.") (docfun first function (x) " Equivalent to CAR.") (docfun si::fixnump function (x) " ECL specific. Returns T if the X is a fixnum; NIL otherwise.") (docfun flet special ((&rest functions) &body forms) " Introduces local functions and evaluates BODY as a PROGN. BODY is the scope of each local function but the local function definitions are not. Thus each local function can reference externally defined functions of the same name as local functions. Doc-strings for local functions are simply ignored.") (doctype float " A float (floating-point number) represents a real number or its approximation. ECL supports two formats for floats. One format is called SHORT-FLOAT and the other format is called SINGLE-FLOAT, DOUBLE-FLOAT, or LONG-FLOAT. Precisions and exponent sizes of floats depends on the version of ECL. See the ECL Report at your hand for details. The following syntax is used to notate a float. [+ | -] {digit}* . {digit}+ [exp] [+ | -] {digit}+ [. {digit}*}] exp where DIGIT is a decimal digit (0,..,9) and EXP is marker [+ | -] {digit}+ with one of the following marker. e or E the default float format s or S short-float f or F single-float d or D double-float l or L long-float The default float format is single-float normally, but may be any other float format. See *READ-DEFAULT-FLOAT-FORMAT*.") (docfun float function (number &optional float) " With one arg, converts NUMBER to a single-float. With two args, converts NUMBER to a float of the same float format as FLOAT.") (docfun float-digits function (float) " Returns the number of radix-B digits used to represent the significand of FLOAT, where B is the base number used in the representation of FLOAT.") (docfun float-precision function (float) " Returns the number of effective radix-B digits in the representation of the significand of FLOAT, where B is the base number used in the representation of FLOAT.") (docfun float-radix function (float) " Returns the base number used in the representation of FLOAT.") (docfun float-sign function (float1 &optional (float2 (float 1 float1))) " Returns a float with the same sign as FLOAT1 and with the same absolute value as FLOAT2.") (docfun floatp function (x) " Returns T if X is a float; NIL otherwise.") (docfun floor function (number &optional (divisor 1)) " Returns the largest integer not larger than the NUMBER divided by DIVISOR. Returns the value of (- NUMBER (* first-value DIVISOR)) as the second value.") (docfun fmakunbound function (symbol) " Removes the global function definition associated with SYMBOL. Returns SYMBOL.") (docfun force-output function (&optional (stream *standard-output*)) " Sends the contents of the output buffer for STREAM to the destination. Returns NIL without waiting until the buffer becomes empty.") (docfun format function (destination format-string &rest args) " Outputs ARGs to DESTINATION in the format specified by FORMAT-STRING. FORMAT- STRING is a string consisting of characters to output and format directives which begin with '~~'. Outputs to DESTINATION if it is a stream and to the standard output if DESTINATION is T. If DESTINATION is NIL, does not output actually but returns the output as a string. Here are some format directives: ~~A PRINCs one arg ~~S PRIN1s one arg ~~D Prints one integer in decimal ~~B Prints one integer in binary ~~O Prints one integer in octal ~~X Prints one integer in hexa ~~% Does TERPRI ~~& Does FRESH-LINE ~~| Outputs #\\Page ~~~~ Outputs '~~'") (docfun fourth function (x) " Equivalent to CADDDR.") (docfun fresh-line function (&optional (stream *standard-output*)) " Outputs a newline character only if the current position of STREAM is not at the beginning of a line. Returns T if it outputs a newline; NIL otherwise.") (docfun si::frs-bds function (n) " ECL specific. Returns the bind stack index of the N-th entity in the frame stack.") (docfun si::frs-ihs function (n) " ECL specific. Returns the invocation history stack index of the N-th entity in the frame stack.") (docfun funcall function (function &rest args) " Calls FUNCTION with the ARGs as the arguments and returns all values that the call returns.") (doctype function " A function object specifies a function to be invoked by function-calling functions such as FUNCALL or APPLY. A function is either: 1. a compiled function 2. a list of one of the following form (lambda lambda-list . body) (lambda-block block-name lambda-list . body) (lambda-closure env1 env2 env3 lambda-list . body) (lambda-block-closure env1 env2 env3 block-name lambda-list . body) where ENV1, ENV2, and ENV3 respectively represent the variable environment, the function/macro environment, and the block/tagbody environment at the time of the function creation. 3. a symbol that names a global function.") (docfun function special (function-name) " If X is a lambda expression, (function x) creates and returns a lexical closure of X in the current lexical environment. If X is a symbol that names a function, returns that function definition.") (docfun functionp function (x) " Returns T if X is an object that can be used to specify a function to be invoked by function-calling functions such as FUNCALL or APPLY. Returns NIL otherwise.") (docfun gc function (x) " ECL specific. Starts garbage collection with the specified collection level. If X is NIL, collects only cells. If X is T, collects everything.") #-boehm-gc (docfun si::gc-time function () " ECL specific. Returns the amount of time (in 1/100 seconds) spent during garbage collection.") (docfun gcd function (&rest integers) " Returns the greatest common divisor of the args.") (docfun gensym function (&optional (x nil)) " Creates and returns a new uninterned symbol whose print name begins with some prefix (initially \"G\"), followed by a generation number. The generation number is incremented by one at each call to GENSYM. If X is an integer, it becomes the new generation number. If X is a string, it becomes the new prefix.") (docfun gentemp function (&optional (string \"T\") (package *package*)) " Creates a new symbol interned in PACKAGE with PREFIX and returns the symbol. The symbol is given a print name beginning with PREFIX followed by some generation number.") (docfun get function (symbol property &optional (default nil)) " Searches the symbol property of SYMBOL for a property that is EQ to PROPERTY. If found, returns the value of the property. Otherwise, returns DEFAULT.") (docfun get-dispatch-macro-character function (char subchar &optional (readtable *readtable*)) " Returns the read macro for SUBCHAR associated with the dispatch macro character CHAR in READTABLE.") #-boehm-gc (docfun si::get-hole-size function () " ECL specific. Returns as a fixnum the size of the memory hole (in pages).") (docfun get-internal-real-time function () " Returns the time (in 1/100 seconds) since the invocation of ECL.") (docfun get-internal-run-time function () " Returns the CPU time (in 1/100 seconds) since the invocation of ECL.") (docfun get-macro-character function (char &optional (readtable *readtable*)) " Returns the read macro associated with the macro character CHAR in READTABLE. Returns the non-terminating-p flag (see READTABLE) as the second value. Returns NIL if CHAR is not a macro character.") (docfun get-output-stream-string function (string-output-stream) " Returns as a string all outputs to STRING-OUTPUT-STREAM since the last call of GET-OUTPUT-STREAM-STRING for the same stream.") (docfun get-properties function (plist list) " Searches PLIST for a property that is EQ to one of the members of LIST. Returns three values. If such a property if found, returns the property, the value of the property, and the rest of LIST. If not, returns three NILs.") (docfun get-universal-time function () " Returns the current day-and-time as an integer. See DECODE-UNIVERSAL-TIME.") (docfun ext:getenv function (string) " ECL/UNIX specific. Returns the environment with the name STRING as a string. Returns NIL, if the specified environment is not found.") (docfun getf function (plist property &optional (default nil)) " Searches PLIST for a property that is EQ to PROPERTY. If one is found, returns the value of the property. If not, returns DEFAULT. The SETF form (setf (getf place property-form) value-form) replaces the property value of the plist stored in PLACE, or adds a new property if the plist does not have the property yet.") (docfun gethash function (key hash-table &optional (default nil)) " Searches HASH-TABLE for the entry of KEY. If found, returns the value of the entry and T, as two values. If not, returns DEFAULT and NIL.") #+clos (docfun si::gfun-instance function (gfun) " ECL/CLOS specific. Returns the generic function instance associated with the GFUN generic function object.") #+clos (docfun si::gfun-instance-set function (gfun instance) " ECL/CLOS specific. Sets to INSTANCE the generic function instance associated with the FUN generic function object.") #+clos (docfun si::gfun-name function (gfun) " ECL/CLOS specific. Returns the name of the GFUN generic function object.") #+clos (docfun si::gfun-name-set function (gfun name) " ECL/CLOS specific. Sets to NAME the name of the GFUN generic function object.") #+clos (docfun si::gfun-method-ht function (gfun) " ECL/CLOS specific. Returns the hashtable for caching methods associated with the GFUN generic function object.") #+clos (docfun si::gfun-method-ht-set function (gfun hash-table) " ECL/CLOS specific. Sets to HASH-TABLE the hashtable for caching methods associated with the GFUN generic function object.") #+clos (docfun si::gfun-spec-how-ref function (gfun index) " ECL/CLOS specific. Returns the INDEX-th element of specialization list associated with the GFUN generic function object. The first element has INDEX equal to zero.") #+clos (docfun si::gfun-spec-how-set function (gfun index specializer) " ECL/CLOS specific. Sets to SPECIALIZER the INDEX-th element of specialization list associated with the GFUN generic function object. The first element has INDEX equal to zero.") #+clos (docfun si::gfunp function (object) " ECL/CLOS specific. Returns T if OBJECT is of gfun type.") (docfun go special (tag) " Jumps to TAG. See TAGBODY.") (docfun graphic-char-p function (char) " Returns T if CHAR is a printing character, i.e., a standard character other than #\\Newline. Returns NIL otherwise.") (doctype hash-table " A hash-table is a table used to map from objects to objects efficiently by the hashing technique. A hash-table is notated as # where N is actually a number that identifies the hash-table.") (docfun hash-table-count function (hash-table) " Returns the number of entries in HASH-TABLE.") (docfun hash-table-p function (x) " Returns T if X is a hash-table object; NIL otherwise.") (docfun host-namestring function (filespec) " Returns as a string the host part of the pathname specified by FILESPEC. FILESPEC may be a symbol, a string, a pathname, or a file stream.") (docfun identity function (x) " Returns X.") (docfun if special (test true-form &optional false-form) " If TEST evaluates to non-NIL, then evaluates FORM1 and returns all values. Otherwise, evaluates FORM2 (which defaults to NIL) and returns all values.") (docfun si::ihs-fun function (n) " ECL specific. Returns the function value of the N-th entity in the invocation history stack.") (docfun imagpart function (number) " Returns the imagpart of NUMBER if it is a complex. Otherwise, returns zero of the same type as NUMBER.") (docfun import function (symbol &optional (package *package*)) " Registers SYMBOL to PACKAGE as an internal symbol. Does nothing if SYMBOL is already registered in PACKAGE. SYMBOL may be a list of symbols.") (docfun in-package function (package-name &key (nicknames nil) (use '(lisp))) " Makes the package named PACKAGE-NAME as the current package. If such a package does not exist, then creates one by passing all args to MAKE-PACKAGE. Otherwise, adds the specified nicknames and packages to the nickname list and use list of the package. NICKNAMES must be a list consisting of strings and symbols. USE must be a list consisting of package objects and package names (either string or symbol).") (docfun input-stream-p function (stream) " Returns T if STREAM can handle input operations; NIL otherwise.") #+clos (docfun si::instancep function (object) " ECL/CLOS specific. Returns T if OBJECT is of instance type.") #+clos (docfun si::instance-ref function (instance index) " ECL/CLOS specific. Returns the value of the INDEX-th slot of INSTANCE. The first slot has INDEX equal to zero.") #+clos (docfun si::instance-set function (instance index value) " ECL/CLOS specific. Sets to VALUE the value of INDEX-th slot of INSTANCE. The first slot has INDEX equal to zero.") #+clos (docfun si::instance-class function (instance) " ECL/CLOS specific. Returns the class of which the given INSTANCE is an instance.") #+clos (docfun si::instance-class-set function (instance class) " ECL/CLOS specific. Makes INSTANCE an instance of CLASS class.") (docfun int-char function (integer) " Equivalent to CODE-CHAR.") (doctype integer " An integer object represents an integer in mathematical sense. An integer may be a fixnum, or else it is a bignum. Normally, an integer is notated in radix 10 (see *PRINT-BASE* and *READ-BASE*) as [sign] {digit}+ where DIGIT is a decimal digit ('0', ..., '9') and SIGN is either '+' or '-'. Also, the following syntax is used to notate the radix explicitly. # radix {r | R} [sign] {digit}+ where RADIX is one of '2', '3', ..., '36' and DIGIT is a digit in radix RADIX: Digits in radix 2 are '0' and '1' Digits in radix 8 are '0', ..., '7' Digits in radix 16 are '0', ..., '9', 'a', ..., 'f', and 'A', ..., 'F' The following syntax is also available for radix 2, 8, 10, and 16. # {b | B} [sign] {digit}+ # {o | O} [sign] {digit}+ [sign] {digit}+ . # {x | X} [sign] {digit}+") (docfun integer-decode-float function (float) " Returns, as three values, the integer interpretation of significand F, the exponent E, and the sign S of FLOAT, such that FLOAT = S * F * B^E where B = (float-radix FLOAT). F is a non-negative integer, E is an integer, and S is either 1 or -1.") (docfun integer-length function (integer) " Returns the number of \"significant bits\" in the representation of INTEGER. With positive arg, returns one plus the position of the most significant bit that is 'on'. With negative arg other than -1, returns one plus the position of the most significant bit that is 'off'. For 0 and -1, returns 0.") (docfun integerp function (x) " Returns T if X is an integer; NIL otherwise.") (docfun intern function (string &optional (package *package*)) " Searches PACKAGE for a symbol whose print name is STRING. If such a symbol is found, returns the symbol and, as the second value, one of the keywords :INTERNAL, :EXTERNAL, and :INHERITED. Otherwise, creates and returns a new symbol and, as the second value, returns NIL.") (docvar internal-time-units-per-second constant " Gives the time unit used by GET-INTERNAL-REAL-TIME and GET-INTERNAL-RUN-TIME. 1000 in ECL.") (doctype keyword " A keyword is a symbol in the keyword package.") (docfun keywordp function (x) " Returns T if X is a symbol that belongs to the KEYWORD package; NIL otherwise.") (docfun labels special ((&rest functions) &body forms) " Introduces local functions and evaluates BODY as a PROGN. The scope of each local function include the local function definitions. Thus self- and mutual- recursive local functions can be defined. Doc-strings for local functions are simply ignored.") (docvar lambda-list-keywords constant " List of all lambda-list keywords, including &optional &rest &key &allow-other-keys &aux &whole &environment &body") (docvar lambda-parameters-limit constant " The upper bound of the number of parameters specified by a lambda list. Ignore this number; there is no such upper bound in ECL.") (docfun last function (list) " Returns the last cons that constitute LIST. Returns NIL if LIST is NIL.") (docfun lcm function (integer &rest more-integers) " Returns the least common multiple of the args. Returns 0 if at least one of the args is 0.") (docfun ldiff function (list x) " If X is a cons that constitutes LIST, then returns a new list consisting of those elements of LIST that appear before X. Otherwise, returns a copy of LIST.") (docvar least-negative-double-float constant " Same as LEAST-NEGATIVE-LONG-FLOAT.") (docvar least-negative-long-float constant " The negative long-float with the smallest absolute value.") (docvar least-negative-short-float constant " The negative short-float with the smallest absolute value.") (docvar least-negative-single-float constant " Same as LEAST-NEGATIVE-LONG-FLOAT.") (docvar least-positive-double-float constant " Same as LEAST-POSITIVE-LONG-FLOAT.") (docvar least-positive-long-float constant " The smallest positive long-float.") (docvar least-positive-short-float constant " The smallest positive short-float.") (docvar least-positive-single-float constant " Same as LEAST-POSITIVE-LONG-FLOAT.") (docfun length function (sequence) " Returns the length of SEQUENCE.") (docfun let special ((&rest bindings) &body body) " Evaluates all INITs (which defaults to NIL), binds the value of each INIT to the corresponding VAR, evaluates FORMs, and returns all values of the last FORM. Returns NIL if no FORM is given.") (docfun let* special ((&rest bindings) &body body) " Evaluates INIT (which defaults to NIL) and binds the value to the corresponding VAR, one by one for each pair of VAR and INIT. Then evaluates FORMs and returns all values of the last FORM. Returns NIL if no FORM is given.") (docfun list function (&rest args) " Returns a list of the args.") (docfun list* function (arg &rest more-args) " With one arg, simply returns it. With n args (n > 1), conses the first arg to the LIST* of the rest of args.") (docfun list-all-packages function () " Returns a list of all packages.") (docfun list-length function (list) " Returns the length of LIST. Returns NIL if LIST is circular.") (docfun listen function (&optional (stream *standard-input*)) " Returns T if STREAM is ready to input a character from; NIL otherwise. In some versions of ECL, this function does not work correctly because the underlying OS does not support such a mechanism.") (docfun listp function (x) " Returns T if X is either a cons or NIL. Otherwise, returns NIL.") (docfun load function (filespec &key (verbose *load-verbose*) (print nil) (if-does-not-exist :error)) " Loads the contents of the specified file into ECL. If the filetype is not specified, ECL first tries to load the fasl file with filetype \".fasl\", then tries to load the source file with filetype \".lsp\", and then tries to load the source file with no filetype. FILESPEC may be a symbol, a string, a pathname, or a file stream. VERBOSE specifies whether or not the loader prints a loading message. PRINT specifies whether or not the loader prints the values of the top-level forms. IF-DOES-NOT-EXIST specifies the behavior of the loader when the specified file is not found. It may be :ERROR or NIL. If the file was loaded successfully, returns the pathname of the file actually loaded") (docfun locally macro (&body forms) " Gives DECLs locally while evaluating FORMs, and returns all values of the last FORM. Returns NIL if no FORM is given.") (docfun log function (number1 &optional number2) " With two args, returns the logarithm of NUMBER1 in base NUMBER2. With one arg, returns the natural logarithm of the arg.") (docfun logand function (&rest integers) " Returns the bit-wise AND of the args.") (docfun logandc1 function (integer1 integer2) " Equivalent to (LOGAND (LOGNOT INTEGER1) INTEGER2).") (docfun logandc2 function (integer1 integer2) " Equivalent to (LOGAND INTEGER1 (LOGNOT INTEGER2)).") (docfun logbitp function (bit-position integer) " Returns T if the specified bit of INTEGER is 1; NIL otherwise. BIT-POSITION must be a non-negative integer, with 0 representing the least significant bit.") (docfun logcount function (integer) " If INTEGER is negative, returns the number of 0 bits. Otherwise, returns the number of 1 bits.") (docfun logeqv function (&rest integers) " Returns the bit-wise EQUIVALENCE of the args.") (docfun logior function (&rest integers) " Returns the bit-wise INCLUSIVE OR of the args.") (docfun lognand function (integer1 integer2) " Equivalent to (LOGNOT (LOGAND INTEGER1 INTEGER2)).") (docfun lognor function (integer1 integer2) " Equivalent to (LOGNOT (LOGIOR INTEGER1 INTEGER2)).") (docfun lognot function (integer) " Returns the bit-wise logical NOT of the arg.") (docfun logorc1 function (integer1 integer2) " Equivalent to (LOGIOR (LOGNOT INTEGER1) INTEGER2).") (docfun logorc2 function (integer1 integer2) " Equivalent to (LOGIOR INTEGER1 (LOGNOT INTEGER2)).") (docfun logxor function (&rest integers) " Returns the bit-wise EXCLUSIVE OR of the args.") (doctype long-float " A long-float is a long-precision floating point number.") (docfun lower-case-p function (char) " Returns T if CHAR is a lower-case character; NIL otherwise.") (docfun macro-function function (symbol) " Returns the expansion function of the global macro named SYMBOL. Returns NIL if no such macro exists. The expansion function receives a macro form and an environment, and returns the expanded form.") (docfun macroexpand function (form &optional (env nil)) " If FORM is a macro form, then expands it repeatedly until the result is not a macro any more, and returns the result as the first value and T as the second value. Otherwise, returns FORM and NIL as two values.") (docfun macroexpand-1 function (form &optional (env nil)) " If FORM is a macro form, then expands it once and returns the result as the first value and T as the second value. Otherwise, returns FORM and NIL as two values.") (docfun macrolet special ((&rest macros) &body forms) "Syntax: (macrolet ({(name defmacro-lambda-list {decl | doc}* {form}*)}*) . body) Introduces local macros and evaluates BODY as a PROGN. See DEFMACRO for the complete syntax of defmacro-lambda-list. Doc-strings for local macros are simply ignored.") (docfun make-broadcast-stream function (&rest streams) " Creates and returns a broadcast stream. Outputs to this stream are output to all STREAMs. A broadcast stream is notated as # where N is a number that identify the stream.") (docfun make-char function (char &optional (bits 0) (font 0)) " Returns a character object with the same code as CHAR and with the specified BITS and FONT attributes. Returns NIL if no such character exists.") (docfun make-concatenated-stream function (&rest streams) " Creates and returns a concatenated stream. Inputs from this stream are first obtained from the first STREAM. When the end of the first STREAM is reached, then inputs are obtained from the second STREAM. And so forth. A concatenated stream is notated as # where N is a number that identifies the stream.") (docfun make-dispatch-macro-character function (char &optional (non-terminating-p nil) (readtable *readtable*)) " Register CHAR as a dispatch macro character in READTABLE. NON-TERMINATING-P specifies whether CHAR is non-terminating (see READTABLE).") (docfun make-echo-stream function (stream1 stream2) " Creates and returns an echo stream. Inputs from this stream are obtained from STREAM1 and outputs to this stream are output to STREAM2. In addition, all inputs from STREAM1 are output to STREAM2. An echo stream is notated as # where N is a number that identifies the stream.") (docfun make-hash-table function (&key (test 'eql) (size 1024) (rehash-size 1.5) (rehash-threshold 0.7)) " Creates and returns a hash-table. TEST specifies which predicate should be used to access hash-table entries. It must be EQ, EQL, or EQUAL. SIZE specifies the number of entries in the hash-table. REHASH-SIZE, if an integer, specifies how many entries should be added when the hash-table becomes 'almost full'. REHASH-SIZE, if a float, specifies the ratio of the new size and the old size. REHASH-THRESHOLD specifies when to expand the hash-table. If an integer, the hash-table is expanded when REHASH-THRESHOLD / REHASH-SIZE entries have been used. If a float, the hash-table is expanded when REHASH-THRESHOLD times the whole entries have been used.") (docfun make-list function (length &key (initial-element nil)) " Creates and returns a list of the specified LENGTH, whose elements are all the value of INITIAL-ELEMENT.") (docfun make-package function (package-name &key (nicknames nil) (use '(lisp))) " Creates and returns a new package named PACKAGE-NAME. PACKAGE-NAME must be a string or a symbol. The print name is used if PACKAGE-NAME is a symbol. NICKNAMES gives the nicknames of the package. It must be a list of strings and symbols. USE specifies the packages used by the created package. It must be a list of package objects, strings, and symbols.") (docfun make-pathname function (&key (defaults (parse-namestring \"\" (pathname-host *default-pathname-defaults*))) (host (pathname-host defaults)) (device (pathname-device defaults)) (directory (pathname-directory defaults)) (name (pathname-name defaults)) (type (pathname-type defaults)) (version (pathname-version defaults))) " Creates a pathname object with the slot values specified by HOST, DEVICE, DIRECTORY, NAME, TYPE, and VERSION.") (docfun make-random-state function (&optional (random-state nil)) " Creates and returns a random-state object. If RANDOM-STATE is NIL, copies the value of *RANDOM-STATE*. If RANDOM-STATE is a random-state, copies it. If RANDOM-STATE is T, creates a random-state randomly.") (docfun make-string function (length &key (initial-element #\Space)) " Creates and returns a new string of the given LENGTH, whose elements are all INITIAL-ELEMENT.") (docfun make-string-input-stream function (string &optional (start 0) (end (length string))) " Creates and returns a string-input stream. Inputs from this stream are obtained form STRING. A string-input stream is notated as # where S is a string.") (docfun make-string-output-stream function () " Creates and returns a string-output stream. Outputs to this stream are obtained as a string by GET-OUTPUT-STREAM-STRING. A string-output stream is notated as # where N is a number that identifies the stream.") (docfun si::make-string-output-stream-from-string function (string) " ECL specific. Creates and returns a string-output-stream to STRING. STRING must have a fill-pointer.") (docfun make-symbol function (string) " Creates and returns a new uninterned symbol whose print name is STRING.") (docfun make-synonym-stream function (symbol) " Creates and returns a synonym stream to SYMBOL. Inputs from this stream are obtained from, and outputs to this stream are sent to the stream that is the value of the global variable named SYMBOL. A synonym stream is notated as # where S is a symbol.") (docfun make-two-way-stream function (stream1 stream2) " Creates and returns a two-way stream. Inputs from this stream are obtained from STREAM1 and outputs to this stream are sent to STREAM2. A two-way stream is notated as # where N is a number that identifies the stream.") (docfun makunbound function (symbol) " Makes the global variable named SYMBOL have no value. Returns SYMBOL.") (docfun mapc function (function list &rest more-lists) " For each N (0 <= N < K), applies FUNCTION to the N-th elements of the given LISTs, where K is the minimum length of the given LISTs. Returns the first LIST.") (docfun mapcan function (function list &rest more-lists) " For each N (0 <= N < K), applies FUNCTION to the N-th elements of the given LISTs, where K is the minimum length of the given LISTs. Nconcs the values, one for each call to FUNCTION, and returns the result.") (docfun mapcar function (function list &rest more-lists) " Creates and returns a list of K elements, with the N-th element being the value of applying FUNCTION to the N-th elements of the given LISTs, where K is the minimum length of the given LISTs.") (docfun mapcon function (function list &rest more-lists) " For each N (0 <= N < K), applies FUNCTION to the N-th cdrs of the given LISTs, where K is the minimum length of the given LISTs. Nconcs the values, one for each call to FUNCTION, and returns the result.") (docfun maphash function (function hash-table) " For each entry of HASH-TABLE, applies FUNCTION to the key and the value of the entry. Returns NIL.") (docfun mapl function (function list &rest more-lists) " For each N (0 <= N < K), applies FUNCTION to the N-th cdrs of the given LISTs, where K is the minimum length of the given LISTs. Returns the first LIST.") (docfun maplist function (function list &rest more-lists) " Creates and returns a list of K elements, with the N-th element being the value of applying FUNCTION to the N-th cdrs of the given LISTs, where K is the minimum length of the given LISTs.") (docfun max function (number &rest more-numbers) " Returns the largest arg. The args must be non-complex numbers.") (docfun maximum-allocatable-pages function (type) " ECL specific. Returns the current maximum number of pages for the type class of the ECL implementation type TYPE.") #-boehm-gc (docfun si::maximum-contiguous-pages function () " ECL specific. Returns the current maximum number of pages for contiguous blocks.") (docfun member function (item list &key (key '#'identity) (test '#'eql) test-not) " Searches LIST for an element that is equal to ITEM in the sense of the TEST. If found, returns the sublist of LIST that begins with the element. Otherwise, returns NIL.") (docfun merge-pathnames function (filespec &optional (defaults *default-pathname-defaults*) default-version) " Fills in unspecified slots of the pathname specified by FILESPEC from the pathname specified by DEFAULTS, and returns the result pathname. DEFAULT- VERSION is simply ignored in ECL. FILESPEC and DEFAULTS may be a symbol, a string, a pathname, or a file stream.") (docfun min function (number &rest more-numbers) " Returns the smallest arg. The args must be non-complex numbers.") (docfun minusp function (number) " Returns T if NUMBER is negative; NIL otherwise.") (docfun mod function (number divisor) " Returns the second result of (FLOOR NUMBER DIVISOR), i.e. the value of (- NUMBER (* (FLOOR NUMBER DIVISOR) DIVISOR))") (docvar most-negative-double-float constant " Same as MOST-NEGATIVE-LONG-FLOAT.") (docvar most-negative-fixnum constant " The negative fixnum with the largest absolute value. - 2^29 in ECL.") (docvar most-negative-long-float constant " The long-float with the largest absolute value.") (docvar most-negative-short-float constant " The short-float with the largest absolute value.") (docvar most-negative-single-float constant " Same as MOST-NEGATIVE-LONG-FLOAT.") (docvar most-positive-double-float constant " Same as MOST-POSITIVE-LONG-FLOAT.") (docvar most-positive-fixnum constant " The largest positive fixnum. 2^29 - 1 in ECL.") (docvar most-positive-long-float constant " The largest positive long-float.") (docvar most-positive-short-float constant " The largest positive short-float.") (docvar most-positive-single-float constant " Same as MOST-POSITIVE-LONG-FLOAT.") (docfun multiple-value-call special (function-form &rest forms) " Evaluates FUNCTION-FORM, whose value must be a function. Then evaluates FORMs and applies the function to all values of FORMs. Unlike FUNCALL, all values of each FORM are used as arguments. Returns all values of the function.") (docfun multiple-value-prog1 special (first-form &rest forms) " Evaluates FIRST-FORM, saves all values it returns, and then evaluates FORMs. Returns all the saved values of FIRST-FORM.") (docvar multiple-values-limit constant " The upper bound on the number of values that a function can return. Actually, however, there is no such upper bound in ECL.") (docfun name-char function (name) " Given an argument acceptable to string, Returns a character object with the specified character name (see CHARACTER). Returns NIL if no such character object exists. NAME is typically a string but may be any object that can be coerced to string.") (docfun namestring function (filespec) " Returns as a string all slots of the pathname specified by FILESPEC. FILESPEC may be a symbol, a string, a pathname, or a file stream.") (docfun nbutlast function (list &optional (n 1)) " Destructive BUTLAST. LIST may be destroyed.") (docfun nconc function (&rest lists) " Destructive APPEND. The args except for the last may be destroyed.") (doctype nil " The type NIL is a subtype of every type. No object belongs to this type.") (docvar nil constant " The value of NIL is NIL.") (docfun ninth function (x) " Equivalent to (CAR (CDDDDR (CDDDDR X))).") (docfun not function (x) " Returns T if X is NIL; NIL otherwise.") (docfun nreconc function (x y) " Equivalent to (NCONC (NREVERSE X) Y).") (docfun nreverse function (sequence) " Destructive REVERSE. The arg may be destroyed.") (docfun nstring-capitalize function (string &key (start 0) (end (length string))) " Destructive STRING-CAPITALIZE. STRING may be destroyed.") (docfun nstring-downcase function (string &key (start 0) (end (length string))) " Destructive STRING-DOWNCASE. STRING may be destroyed.") (docfun nstring-upcase function (string &key (start 0) (end (length string))) " Destructive STRING-UPCASE. STRING may be destroyed.") (docfun nsublis function (alist tree &key (key '#'identity) (test '#'eql) test-not) " Destructive SUBLIS. TREE may be destroyed.") (docfun nsubst function (new old tree &key (key '#'identity) (test '#'eql) test-not) " Destructive SUBST. TREE may be destroyed.") (docfun nsubstitute function (new old sequence &key (key '#'identity) (test '#'eql) test-not (start 0) (end (length sequence)) (count most-positive-fixnum) (from-end nil)) " Destructive SUBSTITUTE. SEQUENCE may be destroyed.") (docfun nsubstitute-if function (new test sequence &key (key '#'identity) (start 0) (end (length sequence)) (count most-positive-fixnum) (from-end nil)) " Destructive SUBSTITUTE-IF. SEQUENCE may be destroyed.") (docfun nsubstitute-if-not function (new test sequence &key (key '#'identity) (start 0) (end (length sequence)) (count most-positive-fixnum) (from-end nil)) " Destructive SUBSTITUTE-IF-NOT. SEQUENCE may be destroyed.") (docfun nth function (n list) " Returns the N-th element of LIST, the first element of LIST being the zeroth. Returns NIL if the length of LIST is less than N. N must be a non-negative integer.") (docfun nthcdr function (n list) " Returns the N-th cdr of LIST. N must be a non-negative integer.") (docfun null function (x) " Returns T if X is NIL; NIL otherwise.") (docfun si:null-pointer-p function (ptr) " Return true if PTR is a null pointer.") (doctype number " A number is an integer, a ratio, a float, or a complex number. Integers and ratios are collectively called rationals.") (docfun numberp function (x) " Returns T if X is a number; NIL otherwise.") (docfun numerator function (rational) " Returns the numerator of RATIONAL as an integer, if RATIONAL is a ratio. Returns RATIONAL if it is an integer.") (docfun oddp function (integer) " Returns T if INTEGER is an odd number; NIL otherwise.") (docfun open function (filespec &key (direction :input) element-type if-exists if-does-not-exist) " Opens the specified file and returns a file stream to/from the file. FILESPEC may be a symbol, a string, a pathname, or a file stream. DIRECTION may be :INPUT, :OUTPUT, :IO, or :PROBE. ELEMENT-TYPE is simply ignored in ECL. IF- EXISTS specifies what to do when DIRECTION is either :OUTPUT or :IO and the specified file exists already. It may be :ERROR (the default), :NEW-VERSION, :RENAME, :RENAME-AND-DELETE, :OVERWRITE, :APPEND, :SUPERSEDE, or NIL. IF- DOES-NOT-EXIST specifies what to do when the specified file does not exists. It may be :ERROR (the default when DIRECTION is :INPUT), :CREATE (the default when DIRECTION is either :OUTPUT or :IO), or NIL. File streams are notated in one of the following ways: # # # # where F is the file name.") (docfun ext:make-pipe function () "Creates a pipe in the form of a two-way stream that can be used for interprocess and interthread communication.") (docfun or macro (&rest forms) " Evaluates FORMs in order from left to right. If any FORM evaluates to non- NIL, quits and returns that (single) value. If the last FORM is reached, returns whatever values it returns.") (docfun output-stream-p function (stream) " Returns T if STREAM can handle output operations; NIL otherwise.") (doctype package " A package object serves as a name space of symbols. A package is notated as # where S is actually the name of the package. ECL provides five built-in packages: lisp standard symbols of Common Lisp. user the package that the user uses by default. keyword keyword symbols. system system internal symbols. Has nicknames SYS and SI. compiler system internal symbols for the ECL compiler.") (docfun package-name function (package) " Returns the name of PACKAGE as a string.") (docfun package-nicknames function (package) " Returns the nicknames of PACKAGE as a list of strings.") (docfun package-shadowing-symbols function (package) " Returns, as a list, those symbols in PACKAGE that are shadowing symbols in other packages.") (docfun package-use-list function (package) " Returns, as a list, those packages that PACKAGE uses.") (docfun package-used-by-list function (package) " Returns, as a list, those packages that use PACKAGE.") (docfun packagep function (x) " Returns T if X is a package object; NIL otherwise.") (docfun pairlis function (keys items &optional (alist nil)) " Conses each KEY and the corresponding ITEM, adds them to ALIST, and returns the result. KEYS and ITEMS must be of the same length.") (docfun parse-integer function (string &key (start 0) (end (length string)) (radix 10) (junk-allowed nil)) " Parses STRING for an integer and returns it. As the second value, returns the index to the character next to the last character that is parsed. If JUNK- ALLOWED is non-NIL, ignores white spaces before and after the number representation in STRING and returns NIL even if STRING is not parsed successfully.") (docfun parse-namestring function (string &optional host defaults &key (start 0) end (junk-allowed nil)) " Parses STRING and returns a pathname. As the second value, returns the index to the character next to the last character that has been parsed. STRING is usually a string object but it may be a symbol, a pathname, or a file stream. START and END are meaningful only when STRING is a string or a symbol. They default to 0 and (length (string FILESPEC)) respectively. When the parsing is failed, signals an error (if JUNK-ALLOWED is NIL) or simply returns NIL. HOST and DEFAULTS are simply ignored in ECL.") (doctype pathname " A pathname object identifies an external file or a collection of external files. A pathname object consists of six slots, HOST, DEVICE, DIRECTORY, NAME, and TYPE. HOST, DEVICE, and VERSION slots are meaningless in ECL, though they are harmless at all. A pathname is notated as #\\\"...\", where '...' is actually some information on the pathname. This depends on the version of ECL. Refer to the ECL Report for details.") (docfun pathname function (filespec) " Returns a pathname specified by FILESPEC. FILESPEC may be a symbol, a string, a pathname, or a file stream.") (docfun pathname-device function (filespec) " Returns the device slot of the pathname specified by FILESPEC. FILESPEC may be a symbol, a string, a pathname, or a file stream.") (docfun pathname-directory function (filespec) " Returns the directory slot of the pathname specified by FILESPEC. FILESPEC may be a symbol, a string, a pathname, or a file stream.") (docfun pathname-host function (filespec) " Returns the host slot of the pathname specified by FILESPEC. FILESPEC may be a symbol, a string, a pathname, or a file stream.") (docfun pathname-name function (filespec) " Returns the name slot of the pathname specified by FILESPEC. FILESPEC may be a symbol, a string, a pathname, or a file stream.") (docfun pathname-type function (filespec) " Returns the type slot of the pathname specified by FILESPEC. FILESPEC may be a symbol, a string, a pathname, or a file stream.") (docfun pathname-version function (filespec) " Returns the version slot of the pathname specified by FILESPEC. FILESPEC may be a symbol, a string, a pathname, or a file stream.") (docfun pathnamep function (x) " Returns T if X is a pathname object; NIL otherwise.") (docfun peek-char function (&optional (char-spec nil) (stream *standard-input*) (eof-error-p t) (eof-value nil) (recursive-p nil)) " Reads characters from STREAM until the specified character is read. Returns the last character but leaves it in STREAM. CHAR-SPEC may be a character object, T (specifies non-whitespace characters), or NIL (specifies all characters).") (docvar pi constant " The float that is approximately equal to the ratio of the circumference of the circle to the diameter.") (docfun si::pointer function (object) " ECL specific. Returns the address of the OBJECT as a fixnum.") (docfun plusp function (number) " Returns T if NUMBER is positive; NIL otherwise.") (docfun position function (item sequence &key (key '#'identity) (test '#'eql) test-not (start 0) (end (length sequence)) (from-end nil)) " Returns the index to the first element in SEQUENCE that is equal to ITEM in the sense of TEST. Returns NIL if no such element exists.") (docfun position-if function (test sequence &key (key '#'identity) (start 0) (end (length sequence)) (from-end nil)) " Returns the index to the first element in SEQUENCE that satisfies TEST. Returns NIL if no such element exists.") (docfun position-if-not function (test sequence &key (key '#'identity) (start 0) (end (length sequence)) (from-end nil)) " Returns the index to the first element in SEQUENCE that does not satisfy TEST. Returns NIL if no such element exists.") (docfun pprint function (object &optional (stream *standard-output*)) " Pretty-prints OBJECT. Returns no values. Equivalent to (PROGN (WRITE OBJECT :STREAM STREAM :PRETTY T :ESCAPE T) (VALUES)) The SI::PRETTY-PRINT-FORMAT property N (which must be a non-negative integer) of a symbol SYMBOL controls the pretty-printing of form (SYMBOL f1 ... fN fN+1 ... fM) in such a way that the subforms fN+1, ..., fM are regarded as the 'body' of the entire form. For instance, the property value of 2 is initially given to the symbol DO.") (docfun prin1 function (object &optional (stream *standard-output*)) " Prints OBJECT in the way that the output can be reread later if possible. Returns OBJECT. Equivalent to (WRITE OBJECT :STREAM STREAM :ESCAPE T).") (docfun princ function (object &optional (stream *standard-output*)) " Prints OBJECT without escape characters. Returns OBJECT. Equivalent to (WRITE OBJECT :STREAM STREAM :ESCAPE NIL).") (docfun print function (object &optional (stream *standard-output*)) " Outputs a newline character, and then PRIN1s OBJECT. Returns OBJECT. Equivalent to (PROGN (TERPRI STREAM) (WRITE OBJECT :STREAM STREAM :ESCAPE T))") (docfun probe-file function (filespec) " Returns the full pathname of the specified file if it exists. Returns NIL otherwise. FILESPEC may be a symbol, a string, a pathname, or a file stream.") (docfun progn special (&body forms) " Evaluates FORMs in order, and returns all values of the last FORM. Returns NIL if no FORM is given.") (docfun progv special (symbols-form values-form &body forms) " Evaluates SYMBOLS-FORM and VALUES-FORM. The value of SYMBOLS-FORM must be a list of symbols (S1 ... Sn) and the value of VALUES-FORM must be a list (V1 ... Vm). Binds each Si to Vi or to NIL if i > m. Then evaluates FORMs and returns all values of the last FORM. Returns NIL if no FORM is given.") (docfun quote special (x) " Simply returns X without evaluating it.") (docfun random function (number &optional (random-state *random-state*)) " Creates and returns a random number by using RANDOM-STATE. NUMBER must be either a positive integer or a positive float. If NUMBER is a positive integer, returns a positive integer less than NUMBER. If NUMBER is a positive float, returns a positive float less than NUMBER in the same float format as NUMBER.") (doctype random-state " A random-state object stores information used to generate random numbers. A random-state is notated as '#$' followed by a certain number.") (docfun random-state-p function (x) " Returns T if X is a random-state object; NIL otherwise.") (docfun rassoc function (item alist &key (test '#'eql) test-not (key '#'identity)) " Returns the first pair in ALIST whose cdr is equal (in the sense of TEST) to ITEM. Returns NIL if no such pair exists. The function KEY is applied to extract the key for comparison.") (doctype ratio " A ratio is notated by its numerator and denominator, separated by a slash '/'. Normally, a ratio is notated in radix 10 (see *PRINT-BASE* and *READ-BASE*) as [sign] {digit}+ / {digit}+ where DIGIT is a decimal digit ('0', ..., '9') and SIGN is either '+' or '-'. Also, the following syntax is used to notate the radix explicitly. # radix {r | R} [sign] {digit}+ / {digit}+ where RADIX is one of '2', '3', ..., '36' and DIGIT is a digit in radix RADIX: Digits in radix 2 are '0' and '1' Digits in radix 8 are '0', ..., '7' Digits in radix 16 are '0', ..., '9', 'a', ..., 'f', and 'A', ..., 'F' The following syntax is also available for radix 2, 8, 10, and 16. # {b | B} [sign] {digit}+ / {digit}+ # {o | O} [sign] {digit}+ / {digit}+ # {x | X} [sign] {digit}+ / {digit}+") (docfun rational function (real) " Converts REAL into rational accurately and returns the result.") (docfun rationalize function (real) " Converts REAL into rational approximately and returns the result.") (doctype rational " A ratio is either an integer or a ratio.") (docfun rationalp function (x) " Returns T if X is an integer or a ratio; NIL otherwise.") (docfun read function (&optional (stream *standard-input*) (eof-error-p t) (eof-value nil) (recursivep nil)) " Reads an object from STREAM and returns the object.") (docfun read-byte function (stream &optional (eof-error-p t) (eof-value nil)) " Reads one byte from STREAM and returns it as an integer.") (docfun read-char function (&optional (stream *standard-input*) (eof-error-p t) (eof-value nil) (recursive-p nil)) " Reads a character from STREAM and returns it.") (docfun read-char-no-hang function (&optional (stream *standard-input*) (eof-error-p t) (eof-value nil) (recursive-p nil)) " Returns the next character from STREAM if one is available; NIL otherwise.") (docfun read-delimited-list function (char &optional (stream *standard-input*) (recursive-p nil)) " Reads objects from STREAM until the next character after an object's representation is CHAR. Returns all objects read, as a list.") (docfun read-line function (&optional (stream *standard-input*) (eof-error-p t) (eof-value nil) (recursive-p nil)) " Reads a line of characters from STREAM and returns them as a string. The newline character at the end of the line will be discarded.") (docfun read-preserving-whitespace function (&optional (stream *standard-input*) (eof-error-p t) (eof-value nil) (recursive-p nil)) " Reads an object from STREAM and returns the object. Unlike READ, always leaves the character next to the object's representation.") (doctype readtable " A readtable defines the syntax used to read objects. Each readtable object remembers the syntactic class of each character. The following syntactic classes are supported. The characters in parenthesis below are those standard characters that belong to each syntactic class as defined in the standard readtable. white-space (space and newline) single-escape ( \\ ) multiple-escape ( | ) macro-character ( \" # ' ( ) , ; ` ) constituent (the others) For each macro-character, the readtable remembers the definition of the associated read macro and the non-terminating-p flag. In the standard readtable, only single-quote is non-terminating. Dispatch macro characters are classified to macro-characters. A readtable is notated as # where N is actually a number that identifies the readtable.") (docfun readtablep function (x) " Returns T if X is a readtable object; NIL otherwise.") (docfun realpart function (number) " Returns the realpart of NUMBER if it is a complex. Otherwise, returns NUMBER.") (docfun reduce function (function sequence &key (from-end nil) (start 0) (end (length sequence)) initial-value) " Combines all the elements of SEQUENCE using the binary operation FUNCTION.") (docfun rem function (number divisor) " Returns the second value of (TRUNCATE NUMBER DIVISOR), i.e. the value of (- NUMBER (* (TRUNCATE NUMBER DIVISOR) DIVISOR))") (docfun remhash function (key hash-table) " Removes the entry for KEY in HASH-TABLE. Returns T if such an entry existed; NIL otherwise.") (docfun remove function (item sequence &key (key '#'identity) (test '#'eql) test-not (start 0) (end (length sequence)) (count most-positive-fixnum) (from-end nil)) " Returns a copy of SEQUENCE with those elements equal to ITEM (in the sense of TEST) removed.") (docfun remove-if function (test sequence &key (key '#'identity) (start 0) (end (length sequence)) (count most-positive-fixnum) (from-end nil)) " Returns a copy of SEQUENCE with elements satisfying TEST removed.") (docfun remove-if-not function (test sequence &key (key '#'identity) (start 0) (end (length sequence)) (count most-positive-fixnum) (from-end nil)) " Returns a copy of SEQUENCE with elements not satisfying TEST removed.") (docfun remprop function (symbol indicator) " Removes the specified property from the property list associated with SYMBOL. Returns T if the property list had the specified property; NIL otherwise.") (docfun rename-file function (filespec new-filespec &key (if-exists :error)) " Renames the file specified by FILESPEC as specified by NEW-FILESPEC. Returns as three values the new pathname, the old full pathname, and the new full pathname. FILESPEC and NEW-FILESPEC may be a symbol, a string, a pathname, or a file stream. :IF-EXISTS is an ECL-specific extension that modifies the behavior of rename-file if new-filespec already exists. It may be :ERROR (the default), NIL, :SUPERSEDE, or T.") (docfun rename-package function (package new-name &optional (new-nicknames nil)) " Renames PACKAGE to NEW-NAME and replaces the nicknames with NEW-NICKNAMES. See MAKE-PACKAGE.") (docfun replace function (sequence1 sequence2 &key (start1 0) (end1 (length sequence1)) (start2 0) (end2 (length sequence2))) " Replaces elements of SEQUENCE1 with the corresponding elements of SEQUENCE2. SEQUENCE1 may be destroyed and is returned.") #-boehm-gc (docfun si::reset-gc-count function () " ECL specific. Resets the counter of the garbage collector that records how many times the garbage collector has been called for each implementation type.") (docfun rest function (x) " Equivalent to CDR.") (docfun return macro (&optional result) " Terminates execution of the lexically surrounding NIL block and returns all values of RESULT (which defaults to NIL) as the values of the terminated block.") (docfun return-from special (symbol &optional result) " Terminates execution of the lexically surrounding block named SYMBOL and returns all values of RESULT (which defaults to NIL) as the values of the terminated block.") (docfun revappend function (x y) " Equivalent to (APPEND (REVERSE X) Y)") (docfun reverse function (sequence) " Returns a new sequence containing the same elements as SEQUENCE but in the reverse order.") (docfun round function (number &optional (divisor 1)) " Returns the integer nearest to NUMBER/DIVISOR. Returns the value of (- NUMBER (* first-value DIVISOR)) as the second value.") (docfun rplaca function (cons x) " Replaces the car of CONS with X, and returns the modified CONS.") (docfun rplacd function (cons x) " Replaces the cdr of CONS with X, and returns the modified CONS.") (docfun save function (filespec) " ECL specific. Saves the current ECL core image into a program file specified by PATHNAME. FILESPEC may be a symbol, a string, a pathname, or a file stream. This function depends on the version of ECL. See ECL Report for details.") (docfun system function (command) " ECL specific. Executes a Shell command as if the string COMMAND is an input to the Shell. On return from the Shell command, it returns the exit code of the command as an integer.") (docfun scale-float function (float integer) " Returns the value of (* FLOAT (expt (float-radix FLOAT) INTEGER)).") (docfun schar function (simple-string n) " Returns the character object representing the N-th character in SIMPLE-STRING. This is faster than CHAR.") (docfun second function (x) " Equivalent to CADR.") (docfun set function (symbol object) " Assigns OBJECT to the global variable named SYMBOL. Returns OBJECT.") (docfun set-char-bit function (char bit-name flag) " Returns a character with the same code and attributes as CHAR except the bit specified by BIT-NAME is on (if FLAG is non-NIL) or off. In ECL, the bit-attributes handled are :control :meta :super and :hyper") (docfun set-dispatch-macro-character function (char subchar function &optional (readtable *readtable*)) " Replaces FUNCTION for the read macro of SUBCHAR associated with the dispatch macro character CHAR in READTABLE. When the ECL reader reads an object that begins with CHAR followed by SUBCHAR, it calls FUNCTION with the input stream, SUBCHAR, and NIL as arguments. When the ECL reader reads an object that begins with CHAR, followed by a decimal representation of a number N, followed by SUB-CHAR, it calls FUNCTION with N as the third argument. In both cases, if FUNCTION returns a single value, then that value is returned as the value of the reader. If FUNCTION returns no value, then the reader tries to read an object again. See MAKE-DISPATCH-MACRO-CHARACTER and GET-DISPATCH-MACRO- CHARACTER.") (docfun si::set-hole-size function (fixnum) " ECL specific. Sets the size of the memory hole (in pages).") (docfun set-macro-character function (char function &optional (non-terminating-p nil) (readtable *readtable*)) " Registers CHAR as a macro character in READTABLE and makes FUNCTION the read macro associated with CHAR. When the ECL reader reads an object that begins with CHAR, it calls FUNCTION with the input stream and CHAR as arguments. If FUNCTION returns a single value, it is returned as the value of the reader. If FUNCTION returns no value, then the reader tries to read an object again. NON-TERMINATING-P specifies whether CHAR is non-terminating or not (see READTABLE). Use GET-MACRO-CHARACTER to get the read macro associated with a character.") (docfun set-syntax-from-char function (to-char from-char &optional (to-readtable *readtable*) (from-readtable nil)) " Replaces the information for TO-CHAR in TO-READTABLE with the information for FROM-CHAR in FROM-READTABLE. If FROM-READTABLE is NIL, then the standard readtable is used. TO-CHAR belongs to the same syntactic class as FROM-CHAR, and if FROM-CHAR is a macro character, TO-CHAR inherits the read macro and non-terminating-p flag of FROM-CHAR. See READTABLE.") (docfun setq special (&rest var-form-pairs) " Syntax: (setq {var form}*) Evaluates each FORM and assigns the value to VAR in order. Returns the value of the last FORM.") (docfun seventh function (x) " Equivalent to (CADDR (CDDDDR X)).") (docfun shadow function (symbol &optional (package *package*)) " If no symbol is registered in PACKAGE with the same name as SYMBOL, then creates an internal symbol with the same name and registers it into PACKAGE. The created symbol shadows external symbols of the same name in those packages that PACKAGE uses. SYMBOL may be a list of symbols.") (docfun shadowing-import function (symbol &optional (package *package*)) " Registers SYMBOL as an internal symbol of PACKAGE. Does nothing if SYMBOL is already registered in PACKAGE. If there exists already a symbol in PACKAGE with the same name, then uninterns the symbol first. SYMBOL shadows external symbols of the same name in those packages that PACKAGE uses. SYMBOL may be a list of symbols.") (doctype short-float " A short-float is a short-precision floating point number.") (doctype simple-array " A simple-array is an array that is not displaced to another array, has no fill-pointer, and is not adjustable.") (docfun simple-bit-vector-p function (x) " Returns T if X is a simple-bit-vector; NIL otherwise.") (docfun simple-string-p function (x) " Returns T if X is a simple-string; NIL otherwise.") (docfun simple-vector-p function (x) " Returns T if X is a simple-vector; NIL otherwise.") (docfun sin function (radians) " Returns the sine of RADIANS.") (doctype single-float " A single-float is a single-precision floating point number. SINGLE-FLOAT as a type specifier is equivalent to LONG-FLOAT in ECL.") (docfun sinh function (number) " Returns the hyperbolic sine of NUMBER.") (docfun sixth function (x) " Equivalent to (CADR (CDDDDR X)).") (docfun sleep function (n) " Suspends execution for N seconds. N may be any non-negative, non-complex number.") #+clos (docfun si::sl-boundp function (object) " ECL/CLOS specific. Returns nil if the OBJECT is not null.") #+clos (docfun si::sl-makunbound function (instance index) " ECL/CLOS specific. Removes the value associated with the INDEX-th slot of INSTANCE.") (docfun special-operator-p function (symbol) " Returns T if SYMBOL names a special form; NIL otherwise. The special forms defined in Common Lisp are: block if progv catch labels quote compiler-let let return-from declare let* setq eval-when macrolet tagbody flet multiple-value-call the function multiple-value-prog1 throw go progn unwind-protect In addition, ECL implements the following macros as special forms, though of course macro-expanding functions such as MACROEXPAND work correctly for these macros. and incf prog1 case locally prog2 cond loop psetq decf multiple-value-bind push defmacro multiple-value-list return defun multiple-value-set setf do or unless do* pop when dolist prog dotimes prog*") (docfun si::specialp function (symbol) " ECL specific. Returns T if the SYMBOL names a globally special variable; NIL otherwise.") (docfun sqrt function (number) " Returns the square root of the arg.") (doctype standard-char " A standard-char is a space character (#\\Space), a newline character (#\\Newline,) or a character that represents one of the following letters. ! \" # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \\ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~~") (docfun standard-char-p function (char) " Returns T if CHAR is a standard-char; NIL otherwise.") (doctype stream " A stream is a source of input or a destination of output. The following kinds of streams are supported. file streams string-input streams string-output streams two-way streams echo streams synonym streams concatenated streams broadcast streams Basically, file streams are created by OPEN and other kinds of streams are created by MAKE-...-STREAM. See these functions.") (docfun stream-element-type function (stream) " Returns the type specifier for the io unit of STREAM.") (docfun streamp function (x) " Returns T if X is a stream object; NIL otherwise.") ;;; CLOS Streams ------------------------------------------------------------ #+CLOS-STREAMS (docfun stream-read-char method ((obj stream-class)) " Reads the next character object from the CLOS stream OBJ.") #+CLOS-STREAMS (docfun stream-read-line method ((obj stream-class) &rest make-array-options) " Reads character objects from the CLOS stream OBJ, up to and including the next newline character, and returns them as a string (without the newline). If given, the MAKE-ARRAY-OPTIONS arguments are passed to make-array when the returned string is created.") #+CLOS-STREAMS (docfun stream-unread-char method ((obj stream-class) character) " Unreads the character object. CHARACTER will be the next character read by STREAM-READ-CHAR .") #+CLOS-STREAMS (docfun stream-peek-char method ((obj stream-class) peek-type) " Returns the character object which would be returned by STREAM-READ-CHAR but does not remove it from the input buffer. If PEEK-TYPE is T, stream-peek-char skips over any whitespace characters, removing them from the input buffer, and returns the next character.") #+CLOS-STREAMS (docfun stream-listen method ((obj stream-class)) " Returns NIL if no character is immediately available from the CLOS stream. Otherwise, the next character is returned, as if stream-peek-char had been called.") #+CLOS-STREAMS (docfun stream-clear-input method ((obj stream-class)) " Clears any buffered characters received from the CLOS stream OBJ. Returns NIL.") #+CLOS-STREAMS (docfun stream-write-char method ((obj stream-class) character) " Outputs the CHARACTER to the CLOS stream OBJ and returns the CHARACTER.") #+CLOS-STREAMS (docfun stream-write-string method ((obj stream-class) string &optional start end) " Outputs characters in the STRING to the CLOS stream OBJ and returns the STRING. The START and END arguments, if given, indicate a substring that is to be output.") #+CLOS-STREAMS (docfun stream-fresh-line method ((obj stream-class)) " Outputs a newline to the CLOS stream if and only if the CLOS stream OBJ is not already at the beginning of a new line. Returns non-NIL if a newline was output and NIL otherwise.") #+CLOS-STREAMS (docfun stream-clear-output method ((obj stream-class)) " Aborts any outstanding output operation on the CLOS stream OBJ and returns NIL .") #+CLOS-STREAMS (docfun stream-force-output method ((obj stream-class)) " Initiates the emptying of internal buffers on the CLOS stream OBJ and returns NIL.") ;;; end of CLOS streams --------------------------------------------------- (docfun string function (x) " Coerces X into a string. If X is a string, then returns X itself. If X is a symbol, then returns its print name. If X is a character, then returns a one element string containing that character. Signals an error if X cannot be coerced into a string.") (docfun string-capitalize function (string &key (start 0) (end (length string))) " Returns a copy of STRING with the first character of each word converted to upper case, and remaining characters converted to lower case. Its destructive version is NSTRING-CAPITALIZE.") (doctype string-char " A string-char is a character that can be stored in strings. In ECL, every character is a string-character.") (docfun string-char-p function (char) " Returns T if CHAR is a string-char, i.e. can be stored in strings; NIL otherwise. In ECL, this function always returns T.") (docfun si::string-concatenate function (&rest strings) " ECL specific. Concatenates STRINGs and returns the result.") (docfun string-downcase function (string &key (start 0) (end (length string))) " Returns a copy of STRING with all upper case characters converted to lower case. Its destructive version is NSTRING-DOWNCASE.") (docfun string-equal function (string1 string2 &key (start1 0) (end1 (length string1)) (start2 0) (end2 (length string2))) " Returns T if STRING1 and STRING2 are character-wise CHAR-EQUAL; NIL otherwise.") (docfun string-greaterp function (string1 string2 &key (start1 0) (end1 (length string1)) (start2 0) (end2 (length string2))) " Similar to STRING>, but ignores cases.") (docfun string-left-trim function (char-bag string) " Returns a copy of STRING with the specified characters removed from the left end. CHAR-SPEC must be a sequence of characters.") (docfun string-lessp function (string1 string2 &key (start1 0) (end1 (length string1)) (start2 0) (end2 (length string2))) " Similar to STRING<, but ignores cases.") (docfun string-not-equal function (string1 string2 &key (start1 0) (end1 (length string1)) (start2 0) (end2 (length string2))) " Returns NIL if the strings are character-wise CHAR-EQUAL. Otherwise, returns the number of characters in the longest common prefix of the strings.") (docfun string-not-greaterp function (string1 string2 &key (start1 0) (end1 (length string1)) (start2 0) (end2 (length string2))) " Similar to STRING<=, but ignores cases.") (docfun string-not-lessp function (string1 string2 &key (start1 0) (end1 (length string1)) (start2 0) (end2 (length string2))) " Similar to STRING>=, but ignores cases.") (docfun string-right-trim function (char-bag string) " Returns a copy of STRING with the specified characters removed from the right end. CHAR-SPEC must be a sequence of characters.") (docfun si::string-to-object function (string) " ECL specific. Equivalent to (READ-FROM-STRING STRING), but is much faster.") (docfun string-trim function (char-spec string) " Returns a copy of STRING with the specified characters removed from both ends. CHAR-SPEC must be a sequence of characters.") (docfun string-upcase function (string &key (start 0) (end (length string))) " Returns a copy of STRING with all lower case characters converted to upper cases. Its destructive version is NSTRING-UPCASE.") (docfun string/= function (string1 string2 &key (start1 0) (end1 (length string1)) (start2 0) (end2 (length string2))) " Returns NIL if the strings are character-wise CHAR=. Otherwise, returns the number of characters in the longest common prefix of the strings.") (docfun string< function (string1 string2 &key (start1 0) (end1 (length string1)) (start2 0) (end2 (length string2))) " If STRING1 comes before STRING2 in lexicographic order, then returns the number of characters in the longest common prefix of the strings. Otherwise, returns NIL.") (docfun string<= function (string1 string2 &key (start1 0) (end1 (length string1)) (start2 0) (end2 (length string2))) " If STRING1 comes before STRING2 in lexicographic order or if the strings are character-wise CHAR=, then returns the number of characters in the longest common prefix of the strings. Otherwise, returns NIL.") (docfun string= function (string1 string2 &key (start1 0) (end1 (length string1)) (start2 0) (end2 (length string2))) " Returns T if STRING1 and STRING2 are character-wise CHAR=; NIL otherwise.") (docfun string> function (string1 string2 &key (start1 0) (end1 (length string1)) (start2 0) (end2 (length string2))) " If STRING1 comes after STRING2 in lexicographic order or if the strings are character-wise CHAR=, then returns the number of characters in the longest common prefix of the strings. Otherwise, returns NIL.") (docfun string>= function (string1 string2 &key (start1 0) (end1 (length string1)) (start2 0) (end2 (length string2))) " If STRING1 comes after STRING2 in lexicographic order or if the strings are character-wise CHAR=, then returns the number of characters in the longest common prefix of the strings. Otherwise, returns NIL.") (docfun stringp function (x) " Returns T if X is a string object; NIL otherwise.") (docfun si::structurep function (x) " ECL specific. Returns T if X is a structure object defined by DEFSTRUCT; NIL otherwise.") (docfun sublis function (alist tree &key (key '#'identity) (test '#'eql) test-not) " Substitutes subtrees of TREE by using ALIST and returns the result. The original TREE is not destroyed.") (docfun subseq function (sequence start &optional (end (length sequence))) " Returns a copy of the subsequence of SEQUENCE between START (inclusive) and END (exclusive).") (docfun subst function (new old tree &key (key '#'identity) (test '#'eql) test-not) " Substitutes NEW for subtrees of TREE that match OLD and returns the result. The original TREE is not destroyed.") (docfun substitute function (new old sequence &key (key '#'identity) (test '#'eql) test-not (start 0) (end (length sequence)) (count most-positive-fixnum) (from-end nil)) " Returns a copy of SEQUENCE with all elements that match OLD replaced by NEW. The original SEQUENCE is not destroyed.") (docfun substitute-if function (new test sequence &key (key '#'identity) (start 0) (end (length sequence)) (count most-positive-fixnum) (from-end nil)) " Returns a copy of SEQUENCE with all elements that satisfy TEST replaced by NEW. The original SEQUENCE is not destroyed.") (docfun substitute-if-not function (new test sequence &key (key '#'identity) (start 0) (end (length sequence)) (count most-positive-fixnum) (from-end nil)) " Returns a copy of SEQUENCE with all elements that do not satisfy TEST replaced by NEW. The original SEQUENCE is not destroyed.") (docfun svref function (simple-vector n) " Returns the N-th element of SIMPLE-VECTOR.") (docfun sxhash function (object) " Returns the hash code for OBJECT as an integer.") (doctype symbol " Symbol objects.") (docfun symbol-function function (symbol) " Returns the global function definition named SYMBOL.") (docfun symbol-name function (symbol) " Returns the print name of SYMBOL.") (docfun symbol-package function (symbol) " Returns the home package of SYMBOL. Returns NIL if SYMBOL is not interned.") (docfun symbol-plist function (symbol) " Returns the property list of SYMBOL.") (docfun symbol-value function (symbol) " Returns the value of the global variable named SYMBOL.") (docfun symbolp function (x) " Returns T if X is a symbol; NIL otherwise.") (docfun ext:system function (string) " Executes a Shell command as if STRING is an input to the Shell.") (docfun ext:run-program function (command argv &key (input :stream) (output :stream) (error :output) (wait t) environ if-input-does-no-exist (if-output-exists :error) (if-error-exists :error) (external-format :default)) " Creates external process with COMMAND given args ARGV, where INPUT, OUTPUT and ERROR might be :STREAM, T, NIL, pathname designator or stream (gray streams doesn't work). ERROR might be also :OUTPUT. If WAIT is T, then process is ran asynchronously. Returns two-way stream for communication, process status (or exit code, depending on wait parameter) and EXTERNAL-PROCESS structure.") (doctype t " The type T is a supertype of every type. Every object belongs to this type.") (docvar t constant " The value of T is T.") (docfun tagbody special (&body forms) "Syntax: (tagbody {tag | statement}*) Executes STATEMENTs in order and returns NIL after the execution of the last STATEMENT. But, if a GO form causes a jump to one of the TAGs, then execution continues at the point right after the TAG. Lists are regarded as STATEMENTs and other objects are regarded as TAGs.") (docfun tailp function (x list) " Returns T if X is identical to one of the conses that constitute LIST. Returns NIL otherwise.") (docfun tan function (radians) " Returns the tangent of RADIANS.") (docfun tanh function (number) " Returns the hyperbolic tangent of NUMBER.") (docfun tenth function (x) " Equivalent to (CADR (CDDDDR (CDDDDR X))).") (docfun terpri function (&optional (stream *standard-output*)) " Outputs a newline character.") (docfun the special (type form) " Declares that FORM evaluates to a value of TYPE. Evaluates FORM and checks if the value belongs to TYPE. If it does, returns the value. Otherwise, signals an error.") (docfun third function (x) " Equivalent to CADDR.") (docfun throw special (tag form) " Evaluates TAG and aborts the execution of the most recent CATCH form that establishes a catcher with the same catch tag. Returns all values of FORM as the values of the CATCH form.") (docfun tree-equal function (x y &key (test '#'eql) test-not) " Returns T if X and Y have the same tree structures and corresponding leaves are all the same in the sense of TEST. Returns NIL otherwise.") (docfun truename function (filespec) " Returns the full pathname of the file specified by FILESPEC. FILESPEC may be a symbol, a string, a pathname, or a file stream.") (docfun truncate function (number &optional (divisor 1)) " Returns the integer obtained by truncating NUMBER/DIVISOR. Returns the value of (- NUMBER (* first-value DIVISOR)) as the second value.") (docfun type-of function (x) " Returns a type specifier of the type to which X belongs.") (docfun unexport function (symbol &optional (package *package*)) " Undoes the registration of SYMBOL as an external symbol of PACKAGE and makes SYMBOL internal to PACKAGE. SYMBOL may be a list of symbols.") (docfun unintern function (symbol &optional (package *package*)) " Removes SYMBOL from PACKAGE. If PACKAGE is the home package of SYMBOL, then makes SYMBOL uninterned. Returns T if SYMBOL is actually registered in PACKAGE; NIL otherwise.") (docfun unread-char function (char &optional (stream *standard-input*)) " Puts CHAR back on the front of the input stream STREAM.") (docfun unuse-package function (package-spec &optional (package *package*)) " Causes PACKAGE not to use packages specified by PACKAGE-SPEC. PACKAGE-SPEC may be a package object, a string, a symbol, or a list consisting of package objects, strings, and, symbols.") (docfun unwind-protect special (form &body cleanup-forms) " Evaluates FORM and returns all its values. Before returning, evaluates CLEANUP-FORMs in order, whether FORM returns normally or abnormally by a non- local exit.") (docfun upper-case-p function (char) " Returns T if CHAR is an upper-case character; NIL otherwise.") (docfun use-package function (package-spec &optional (package *package*)) " Causes PACKAGE to use packages specified by PACKAGE-SPEC, in addition to those packages that PACKAGE already uses. PACKAGE-SPEC may be a package object, a string, a symbol, or a list consisting of package objects, strings, and symbols.") (docfun user-homedir-pathname function (&optional host) " Returns a pathname the represents the user's home directory. HOST is simply ignored in ECL.") (docfun values function (&rest args) " Returns ARGs as multiple values, the N-th ARG being the N-th value.") (docfun values-list function (list) " Returns all elements of LIST as multiple values, the N-th element of LIST being the N-th value.") (docfun vectorp function (x) " Returns T if X is a vector; NIL otherwise.") (docfun vector-push function (new-element vector) " Replaces ITEM for the element of VECTOR that is pointed to by the fill-pointer of VECTOR and then increments the fill-pointer by one. Returns NIL if the new value of the fill-pointer becomes too large. Otherwise, returns the new fill- pointer as the value.") (docfun vector-push-extend function (new-element vector &optional (extension 1)) " Replaces ITEM for the element of VECTOR that is pointed to by the fill-pointer of VECTOR and then increments the fill-pointer by one. If the new value of the fill-pointer becomes too large, extends VECTOR for N more elements. Returns the new value of the fill-pointer.") (docfun when macro (test &body forms) " If TEST evaluates to non-NIL, then evaluates FORMs and returns all values of the last FORM. If not, simply returns NIL.") (docfun write function (object &key (stream *standard-output*) (escape *print-escape*) (radix *print-radix*) (base *print-base*) (circle *print-circle*) (pretty *print-pretty*) (level *print-level*) (length *print-length*) (case *print-case*) (array *print-array*) (gensym *print-gensym*)) " Prints OBJECT in the specified mode. See the variable docs of *PRINT-...* for the mode.") (docfun write-byte function (integer stream) " Outputs INTEGER to the binary stream STREAM. Returns INTEGER.") (docfun write-char function (char &optional (stream *standard-output*)) " Outputs CHAR to STREAM. Returns CHAR.") (docfun write-line function (string &optional (stream *standard-output*) &key (start 0) (end (length string))) " Outputs STRING and a newline character to STREAM. Returns STRING.") (docfun write-string function (string &optional (stream *standard-output*) &key (start 0) (end (length string))) " Outputs STRING to STREAM. Returns STRING.") (docfun zerop function (number) " Returns T if the arg is zero; NIL otherwise.") #|| ;;; ---------------------------------------------------------------------- ;;; System Builder Tools (unless (find-package 'sbt) (make-package 'sbt)) (docfun sbt::build-system macro "(system &optional op mode)" " It allows to perform operations on a system defined with SBT:DEFSYSTEM. The possible operations are: :LOAD, :COMPILE and :PRINT. For the load operation, in alternative to the default of loading all the binaries in the appropriate order, there are two modes of operation specifiable via the optional parameter MODE, which can be :QUERY and :SOURCE. The latter option will load the sources of the system, while with :QUERY the user will be prompted on each file to be loaded. The default mode for compilation is to compile just the files which need to be recompiled according to their dependencies. With the :FORCE option, all the files are recompiled, while with the :QUERY option, the user will be prompted. By supplying \fCT\fP for the :PRINT option, the sequence of operations to be performed to build the system will be printed. ") (docfun sbt::defsystem macro "(name &key :modules :directory :pathname-types)" " NAME should be a symbol which will be used to refer to the system. The value of :MODULES should be a list of module dependencies of the form: (file load-deps compile-deps recompilation-deps) where load-deps compile-deps recompilation-deps are lists of module names. If the value specified for :directory is a cons, then the CAR is used as the source file directory and the CDR is used as the binary file directory. The values specified for :PATHNAME-TYPES specifies the extensions for LISP souce files and binaries.") ;;; ---------------------------------------------------------------------- ;;; THREADS (docfun %delay function (nsec) " Stops the thread execution for a time interval of NSEC real seconds. The thread status is set to suspended.") (docfun %disable-scheduler function () " Disables the scheduler, so that the execution of the current thread will not be interrupted by the scheduler until the %enable-scheduler function is called") (docfun %enable-scheduler function () " Enables the scheduler, so that it will time-slice execution among all running threads.") (docfun %suspend function () " Sets the current thread status to suspended and suspends its execution.") (docfun %thread-wait function (predicate &rest args) " Applies the PREDICATE to the ARGS, in the environment of the calling thread. If the result is not nil the thread will continue its execution. Otherwise the thread is suspended and its status set to waiting. The thread will be resumed again when the condition will become true.") (docfun %thread-wait-with-timeout function (nsec predicate &rest args) " Applies the PREDICATE to the ARGS, in the environment of the calling thread. If the result is not nil the thread will continue its execution. Otherwise the thread is suspended and its status set to waiting. The thread will be resumed again when either the condition will become true or the timeout of NSEC seconds has expired.") (docfun current-thread function (thread) " Returns the THREAD within which this function was called.") (docfun deactivate function (thread) " Stops a running THREAD, setting its status to stopped. A stopped thread can be resumed with reactivate function.") (docfun kill-thread function (thread) " Stops the THREAD execution and set its status to dead.") (docfun make-continuation function (thread &key :cont) " Creates a unique new continuation for resuming the THREAD. :CONT is an optional continuation to be supplied to the thread.") (docfun make-thread function (function) " Creates a new thread ready to execute FUNCTION. The thread is in a suspended status and can run only making a continuation for it and issuing a resume to such continuation with a list of arguments.") (docfun reactivate function (thread) " Sets the THREAD status to running.") (docfun resume function (continuation &rest args) " Resumes execution of CONTINUATION and passes it the ARGS.") (docfun spawn macro (function &rest args) " Creates a new thread where FUNCTION is applied to the ARGS. Returns immediately the new thread without waiting for the function to return.") (docfun thread-list function (thread) " Returns the full list of the not DEAD threads") (docfun thread-status function (thread) " Returns the THREAD status (this can be: running, suspended, stopped or dead)") (docfun without-scheduling macro "({form}*)" " Executes the FORMs in sequence within a critical region, ensuring that the scheduler is disabled.") ;;; ---------------------------------------------------------------------- ;;; Unify instructions (docfun si::dereference function (locative) " ECL specific. Given LOCATIVE, it returns the object to which it points. If the location is unbound, the value returned is OBJNULL.") (docfun si::locativep function (object) " ECL specific. Returns true if OBJECT is bound to a locative.") (docfun si::make-variable function (name) " ECL specific. Creates a new logical variable with name name implemented as a cons. Name is used just for printing purposes.") (docfun si::get-constant function (constant object) " ECL specific. The value of OBJECT is unified with the constant CONSTANT. Returns T if successful, otherwise NIL.") (docfun si::get-cons function (object) " ECL specific. The value of OBJECT is unified with a CONS cell. Returns T if successful, otherwise NIL.") (docfun si::get-instance function (object class arity) " ECL specific. The value of OBJECT is unified with an instance of class CLASS with ARITY number of slots. Returns T if successful, otherwise NIL.") (docfun si::get-value function (variable object) " ECL specific. The value of VARIABLE and OBJECT are unified. Returns T if successful, otherwise NIL.") (docfun get-variable macro (variable object) " ECL specific. Identical to SETQ: assigns to the variable VARIABLE the value OBJECT.") (docfun si::get-nil function (object) " ECL specific. The value of OBJECT is unified with the constant NIL. Returns T if successful, otherwise NIL.") (docfun si::trail-mark function () " ECL specific. Sets up a choice point by putting a mark on the trail stack for backtracking.") (docfun si::trail-restore function () " ECL specific. Unwinds the trail stack up to the latest choice point.") (docfun si::trail-unmark function () " ECL specific. Does a TRAIL-RESTORE and also removes the latest choice point.") (docfun si::unboundp function (locative) " ECL specific. Returns true if LOCATIVE is bound to OBJNULL.") (docfun si::unify-constant function (constant) " ECL specific. Read mode: the next subterm is unified with the constant CONSTANT. Write mode: the constant constant is stored as the next subterm.") (docfun si::unify-nil function () " ECL specific. Read mode: the next subterm is unified with the constant NIL. Write mode: the constant NIL is stored as the next subterm.") (docfun si::unify-value function (variable) " ECL specific. Read mode: the value of VARIABLE is unified with the next subterm. Write mode: the value of VARIABLE is stored as the next subterm.") (docfun si::unify-variable macro (variable) " ECL specific. Read mode: VARIABLE is assigned the next subterm. Write mode: a new variable is stored in VARIABLE as the next subterm.") ||# ;;;---------------------------------------------------------------------- ecl-16.1.2/src/doc/types-and-classes000066400000000000000000000047111266352375300172010ustar00rootroot00000000000000COMMON-LISP TYPE SCHEME ======================= T * NIL < all types C METHOD C METHOD-COMBINATION C STANDARD-OBJECT C CLASS C BUILT-IN-CLASS C STRUCTURE-CLASS C STANDARD-CLASS C STANDARD-METHOD (METHOD, STANDARD-OBJECT) C STRUCTURE-OBJECT * BOOLEAN = (MEMBER T NIL) C SYMBOL * KEYWORD C PACKAGE C FUNCTION * COMPILED-FUNCTION C GENERIC-FUNCTION C STANDARD-GENERIC-FUNCTION C NUMBER C* COMPLEX [type] C* REAL [low-lim [up-lim]] C* FLOAT [low-lim [up-lim]] * SHORT-FLOAT [low-lim [up-lim]] C* SINGLE-FLOAT [low-lim [up-lim]] C* DOUBLE-FLOAT [low-lim [up-lim]] * LONG-FLOAT [low-lim [up-lim]] C* RATIONAL [low-lim [up-lim]] C RATIO C* INTEGER [low-lim [up-lim]] * FIXNUM * BIGNUM * SIGNED-BYTE [len | *] * UNSIGNED-BYTE [len | *] * BIT == UNSIGNED-BYTE 1 * MOD up-exclusive-lim C RANDOM-STATE C CHARACTER * BASE-CHAR * STANDARD-CHAR * EXTENDED-CHAR * ATOM = (NOT CONS) C SEQUENCE C LIST C NULL (SYMBOL LIST) C* CONS [{type | *} [{type | *}]] C* ARRAY [{elt-type | *} [rank | * | ({dimension | * }*)]] * SIMPLE-ARRAY [{elt-type | *} [rank | * | ({dimension | * }*)]] C* VECTOR [{elt-type | *} [{size | *}]] * SIMPLE-VECTOR (SIMPLE-ARRAY VECTOR) C* BIT-VECTOR [{size | *}] * SIMPLE-BIT-VECTOR [{size | *}] C* STRING [{size | *}] * SIMPLE-STRING [{size | *}] * BASE-STRING [{size | *}] * SIMPLE-BASE-STRING [{size | *}] C HASH-TABLE C PATHNAME C LOGICAL-PATHNAME C STREAM C BROADCAST-STREAM C CONCATENATED-STREAM C ECHO-STREAM C FILE-STREAM C STRING-STREAM C SYNONYM-STREAM C TWO-WAY-STREAM C READTABLE RESTART CONDITION WARNING STYLE-WARNING SERIOUS-CONDITION STORAGE-CONDITION ERROR TYPE-ERROR PARSE-ERROR CONTROL-ERROR PROGRAM-ERROR CELL-ERROR UNDEFINED-FUNCTION UNBOUND-SLOT UNBOUND-VARIABLE PACKAGE-ERROR ARITHMETIC-ERROR DIVISION-BY-ZERO FLOATING-POINT-INVALID-OPERATION FLOATING-POINT-INEXACT FLOATING-POINT-OVERFLOW FLOATING-POINT-UNDERFLOW FILE-ERROR STREAM-ERROR READER-ERROR (PARSE-ERROR STREAM-ERROR) PRINT-NOT-READABLE SIMPLE-CONDITION SIMPLE-WARNING (WARNING SIMPLE-CONDITION) SIMPLE-ERROR (ERROR SIMPLE-CONDITION) SIMPLE-TYPE-ERROR (TYPE-ERROR SIMPLE-CONDITION) * (NOT type) * (AND {type}*) * (OR {type}*) * (VALUES {type}* [&optional {type}*] [&rest type] [&allow-other-keys]) * (SATISFIES symbol) symbol is a predicate * (MEMBER {object}*) * (EQL object) ecl-16.1.2/src/ecl/000077500000000000000000000000001266352375300137125ustar00rootroot00000000000000ecl-16.1.2/src/ecl/configpre.h000066400000000000000000000355541266352375300160530ustar00rootroot00000000000000/* ecl/configpre.h. Generated from configure.ac by autoheader. */ /* Define if building universal (internal helper macro) */ #undef AC_APPLE_UNIVERSAL_BUILD /* Define to 1 if the `closedir' function returns void instead of `int'. */ #undef CLOSEDIR_VOID /* ECL_AVOID_FPE_H */ #undef ECL_AVOID_FPE_H /* Allow STREAM operations to work on arbitrary objects */ #undef ECL_CLOS_STREAMS /* Use CMU Common-Lisp's FORMAT routine */ #undef ECL_CMU_FORMAT /* Stack grows downwards */ #undef ECL_DOWN_STACK /* ECL_IEEE_FP */ #undef ECL_IEEE_FP /* ECL_LIBATOMIC_OPS_H */ #undef ECL_LIBATOMIC_OPS_H /* ECL_LONG_FLOAT */ #undef ECL_LONG_FLOAT /* ECL_LOING_LONG_BITS */ #undef ECL_LONG_LONG_BITS /* Define if your newline is CR */ #undef ECL_NEWLINE_IS_CR /* Define if your newline is CRLF */ #undef ECL_NEWLINE_IS_CRLF /* Hierarchical package names */ #undef ECL_RELATIVE_PACKAGE_NAMES /* ECL_RWLOCK */ #undef ECL_RWLOCK /* ECL_SIGNED_ZERO */ #undef ECL_SIGNED_ZERO /* Bytecodes and arguments are 8 and 16 bits large, respectively */ #undef ECL_SMALL_BYTECODES /* ECL_SMALL_CONS */ #undef ECL_SMALL_CONS /* ECL_SSE2 */ #undef ECL_SSE2 /* Userland threads? */ #undef ECL_THREADS /* Support for Unicode */ #undef ECL_UNICODE /* Link in the database of Unicode names */ #undef ECL_UNICODE_NAMES /* ECL_USE_MPROTECT */ #undef ECL_USE_MPROTECT /* Allow loading dynamically linked code */ #undef ENABLE_DLOPEN /* Use Boehm's garbage collector */ #undef GBC_BOEHM /* GBC_BOEHM_GENGC */ #undef GBC_BOEHM_GENGC /* GBC_BOEHM_PRECISE */ #undef GBC_BOEHM_PRECISE /* Define to 1 if you have the `alarm' function. */ #undef HAVE_ALARM /* Define to 1 if you have the `backtrace' function. */ #undef HAVE_BACKTRACE /* Define to 1 if you have the `backtrace_symbols' function. */ #undef HAVE_BACKTRACE_SYMBOLS /* Define to 1 if you have the `ceilf' function. */ #undef HAVE_CEILF /* Define to 1 if you have the `copysign' function. */ #undef HAVE_COPYSIGN /* Define to 1 if you have the `cosf' function. */ #undef HAVE_COSF /* Define to 1 if you have the `coshf' function. */ #undef HAVE_COSHF /* Define to 1 if you have the `cosl' function. */ #undef HAVE_COSL /* Define to 1 if you have the header file. */ #undef HAVE_DIRENT_H /* Define to 1 if you have the `dladdr' function. */ #undef HAVE_DLADDR /* Define to 1 if you have the header file. */ #undef HAVE_DLFCN_H /* Define to 1 if the system has the type `double complex'. */ #undef HAVE_DOUBLE_COMPLEX /* HAVE_ENVIRON */ #undef HAVE_ENVIRON /* Define to 1 if you have the `expf' function. */ #undef HAVE_EXPF /* Define to 1 if you have the `expl' function. */ #undef HAVE_EXPL /* Define to 1 if you have the `fabsf' function. */ #undef HAVE_FABSF /* Define to 1 if you have the header file. */ #undef HAVE_FCNTL_H /* Define to 1 if you have the header file. */ #undef HAVE_FENV_H /* Define to 1 if the system has the type `float complex'. */ #undef HAVE_FLOAT_COMPLEX /* Define to 1 if you have the header file. */ #undef HAVE_FLOAT_H /* Define to 1 if you have the `floor' function. */ #undef HAVE_FLOOR /* Define to 1 if you have the `floorf' function. */ #undef HAVE_FLOORF /* Define to 1 if you have the `fork' function. */ #undef HAVE_FORK /* Define to 1 if you have the `frexpf' function. */ #undef HAVE_FREXPF /* Define to 1 if you have the `fseeko' function. */ #undef HAVE_FSEEKO /* HAVE_GC_SET_START_CALLBACK */ #undef HAVE_GC_SET_START_CALLBACK /* Define to 1 if you have the `getcwd' function. */ #undef HAVE_GETCWD /* Define to 1 if you have the `gethostbyaddr' function. */ #undef HAVE_GETHOSTBYADDR /* Define to 1 if you have the `gethostbyname' function. */ #undef HAVE_GETHOSTBYNAME /* Define to 1 if you have the `getpagesize' function. */ #undef HAVE_GETPAGESIZE /* Define to 1 if you have the `getrusage' function. */ #undef HAVE_GETRUSAGE /* Define to 1 if you have the `gettimeofday' function. */ #undef HAVE_GETTIMEOFDAY /* Define to 1 if you have the header file. */ #undef HAVE_INTTYPES_H /* Define to 1 if you have the `isatty' function. */ #undef HAVE_ISATTY /* Define to 1 if you have the `ldexpf' function. */ #undef HAVE_LDEXPF /* HAVE_LIBFFI */ #undef HAVE_LIBFFI /* Define to 1 if you have the `gc' library (-lgc). */ #undef HAVE_LIBGC /* Define to 1 if you have the `sun' library (-lsun). */ #undef HAVE_LIBSUN /* Define to 1 if you have the header file. */ #undef HAVE_LIMITS_H /* Define to 1 if you have the header file. */ #undef HAVE_LINK_H /* Define to 1 if you have the `log1p' function. */ #undef HAVE_LOG1P /* Define to 1 if you have the `log1pf' function. */ #undef HAVE_LOG1PF /* Define to 1 if you have the `log1pl' function. */ #undef HAVE_LOG1PL /* Define to 1 if you have the `logf' function. */ #undef HAVE_LOGF /* Define to 1 if you have the `logl' function. */ #undef HAVE_LOGL /* Define to 1 if the system has the type `long double'. */ #undef HAVE_LONG_DOUBLE /* Define to 1 if you have the `lstat' function. */ #undef HAVE_LSTAT /* Define to 1 if you have the header file. */ #undef HAVE_MACH_O_DYLD_H /* Define to 1 if your system has a GNU libc compatible `malloc' function, and to 0 otherwise. */ #undef HAVE_MALLOC /* Define to 1 if you have the `memmove' function. */ #undef HAVE_MEMMOVE /* Define to 1 if you have the header file. */ #undef HAVE_MEMORY_H /* Define to 1 if you have the `memset' function. */ #undef HAVE_MEMSET /* Define to 1 if you have the `mkdir' function. */ #undef HAVE_MKDIR /* Define to 1 if you have the `mkstemp' function. */ #undef HAVE_MKSTEMP /* Define to 1 if you have a working `mmap' system call. */ #undef HAVE_MMAP /* Define to 1 if you have the `nanosleep' function. */ #undef HAVE_NANOSLEEP /* Define to 1 if you have the header file, and it defines `DIR'. */ #undef HAVE_NDIR_H /* Define to 1 if you have the header file. */ #undef HAVE_NETDB_H /* Define to 1 if you have the header file. */ #undef HAVE_NETINET_IN_H /* HAVE_POSIX_RWLOCK */ #undef HAVE_POSIX_RWLOCK /* Define to 1 if the system has the type `ptrdiff_t'. */ #undef HAVE_PTRDIFF_T /* Define to 1 if you have the `putenv' function. */ #undef HAVE_PUTENV /* Define to 1 if you have the header file. */ #undef HAVE_PWD_H /* Define to 1 if your system has a GNU libc compatible `realloc' function, and to 0 otherwise. */ #undef HAVE_REALLOC /* Define to 1 if you have the header file. */ #undef HAVE_SCHED_H /* Define to 1 if you have the `sched_yield' function. */ #undef HAVE_SCHED_YIELD /* Define to 1 if you have the `select' function. */ #undef HAVE_SELECT /* Define to 1 if you have the header file. */ #undef HAVE_SEMAPHORE_H /* Define to 1 if you have the `setenv' function. */ #undef HAVE_SETENV /* Define to 1 if you have the `sigprocmask' function. */ #undef HAVE_SIGPROCMASK /* Define to 1 if you have the `sinf' function. */ #undef HAVE_SINF /* Define to 1 if you have the `sinhf' function. */ #undef HAVE_SINHF /* Define to 1 if you have the `sinl' function. */ #undef HAVE_SINL /* Define to 1 if you have the `socket' function. */ #undef HAVE_SOCKET /* Define to 1 if you have the `sqrt' function. */ #undef HAVE_SQRT /* Define to 1 if you have the `sqrtf' function. */ #undef HAVE_SQRTF /* Define to 1 if `stat' has the bug that it succeeds when given the zero-length file name argument. */ #undef HAVE_STAT_EMPTY_STRING_BUG /* Define to 1 if stdbool.h conforms to C99. */ #undef HAVE_STDBOOL_H /* Define to 1 if you have the header file. */ #undef HAVE_STDDEF_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 `strcasecmp' function. */ #undef HAVE_STRCASECMP /* Define to 1 if you have the `strchr' function. */ #undef HAVE_STRCHR /* Define to 1 if you have the `strerror' function. */ #undef HAVE_STRERROR /* 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 `strtol' function. */ #undef HAVE_STRTOL /* Define to 1 if you have the header file, and it defines `DIR'. */ #undef HAVE_SYS_DIR_H /* Define to 1 if you have the header file. */ #undef HAVE_SYS_IOCTL_H /* HAVE_SYS_MMAN_H */ #undef HAVE_SYS_MMAN_H /* Define to 1 if you have the header file, and it defines `DIR'. */ #undef HAVE_SYS_NDIR_H /* Define to 1 if you have the header file. */ #undef HAVE_SYS_PARAM_H /* Define to 1 if you have the header file. */ #undef HAVE_SYS_RESOURCE_H /* Define to 1 if you have the header file. */ #undef HAVE_SYS_SELECT_H /* Define to 1 if you have the header file. */ #undef HAVE_SYS_SOCKET_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_TIME_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_SYS_UTSNAME_H /* Define to 1 if you have the header file. */ #undef HAVE_SYS_WAIT_H /* Define to 1 if you have the `tanf' function. */ #undef HAVE_TANF /* Define to 1 if you have the `tanhf' function. */ #undef HAVE_TANHF /* Define to 1 if you have the `tanl' function. */ #undef HAVE_TANL /* Define to 1 if you have the `times' function. */ #undef HAVE_TIMES /* Define to 1 if you have the `tzset' function. */ #undef HAVE_TZSET /* Define to 1 if you have the header file. */ #undef HAVE_ULIMIT_H /* Define to 1 if you have the `uname' function. */ #undef HAVE_UNAME /* Define to 1 if you have the header file. */ #undef HAVE_UNISTD_H /* Define to 1 if you have the `vfork' function. */ #undef HAVE_VFORK /* Define to 1 if you have the header file. */ #undef HAVE_VFORK_H /* Define to 1 if `fork' works. */ #undef HAVE_WORKING_FORK /* Define to 1 if `vfork' works. */ #undef HAVE_WORKING_VFORK /* Define to 1 if the system has the type `_Bool'. */ #undef HAVE__BOOL /* HAVE___BUILTIN_RETURN_ADDRESS */ #undef HAVE___BUILTIN_RETURN_ADDRESS /* Define to 1 if `lstat' dereferences a symlink specified with a trailing slash. */ #undef LSTAT_FOLLOWS_SLASHED_SYMLINK /* 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 as the return type of signal handlers (`int' or `void'). */ #undef RETSIGTYPE /* Define to the type of arg 1 for `select'. */ #undef SELECT_TYPE_ARG1 /* Define to the type of args 2, 3 and 4 for `select'. */ #undef SELECT_TYPE_ARG234 /* Define to the type of arg 5 for `select'. */ #undef SELECT_TYPE_ARG5 /* Define to 1 if you have the ANSI C header files. */ #undef STDC_HEADERS /* Network streams */ #undef TCP /* Define to 1 if you can safely include both and . */ #undef TIME_WITH_SYS_TIME /* Define to 1 if your declares `struct tm'. */ #undef TM_IN_SYS_TIME /* __thread thread-local variables? */ #undef WITH___THREAD /* Define WORDS_BIGENDIAN to 1 if your processor stores words with the most significant byte first (like Motorola and SPARC, unlike Intel). */ #if defined AC_APPLE_UNIVERSAL_BUILD # if defined __BIG_ENDIAN__ # define WORDS_BIGENDIAN 1 # endif #else # ifndef WORDS_BIGENDIAN # undef WORDS_BIGENDIAN # endif #endif /* Define for Solaris 2.5.1 so the uint32_t typedef from , , or is not used. If the typedef were allowed, the #define below would cause a syntax error. */ #undef _UINT32_T /* Define for Solaris 2.5.1 so the uint64_t typedef from , , or is not used. If the typedef were allowed, the #define below would cause a syntax error. */ #undef _UINT64_T /* Define for Solaris 2.5.1 so the uint8_t typedef from , , or is not used. If the typedef were allowed, the #define below would cause a syntax error. */ #undef _UINT8_T /* Define to empty if `const' does not conform to ANSI C. */ #undef const /* ecl_int16_t */ #undef ecl_int16_t /* ecl_int32_t */ #undef ecl_int32_t /* ecl_int64_t */ #undef ecl_int64_t /* ecl_int8_t */ #undef ecl_int8_t /* compiler understands long long */ #undef ecl_long_long_t /* ecl_uint16_t */ #undef ecl_uint16_t /* ecl_uint32_t */ #undef ecl_uint32_t /* ecl_uint64_t */ #undef ecl_uint64_t /* ecl_uint8_t */ #undef ecl_uint8_t /* compiler understands long long */ #undef ecl_ulong_long_t /* Define to `__inline__' or `__inline' if that's what the C compiler calls it, or to nothing if 'inline' is not supported under any name. */ #ifndef __cplusplus #undef inline #endif /* Define to the type of a signed integer type of width exactly 16 bits if such a type exists and the standard includes do not define it. */ #undef int16_t /* Define to the type of a signed integer type of width exactly 32 bits if such a type exists and the standard includes do not define it. */ #undef int32_t /* Define to the type of a signed integer type of width exactly 64 bits if such a type exists and the standard includes do not define it. */ #undef int64_t /* Define to the type of a signed integer type of width exactly 8 bits if such a type exists and the standard includes do not define it. */ #undef int8_t /* Define to rpl_malloc if the replacement function should be used. */ #undef malloc /* Define to `int' if does not define. */ #undef pid_t /* Define to rpl_realloc if the replacement function should be used. */ #undef realloc /* Define to `unsigned int' if does not define. */ #undef size_t /* Define to the type of an unsigned integer type of width exactly 16 bits if such a type exists and the standard includes do not define it. */ #undef uint16_t /* Define to the type of an unsigned integer type of width exactly 32 bits if such a type exists and the standard includes do not define it. */ #undef uint32_t /* Define to the type of an unsigned integer type of width exactly 64 bits if such a type exists and the standard includes do not define it. */ #undef uint64_t /* Define to the type of an unsigned integer type of width exactly 8 bits if such a type exists and the standard includes do not define it. */ #undef uint8_t /* Define as `fork' if `vfork' does not work. */ #undef vfork /* Define to empty if the keyword `volatile' does not work. Warning: valid code using `volatile' can become incorrect without. Disable with care. */ #undef volatile ecl-16.1.2/src/gmp/000077500000000000000000000000001266352375300137325ustar00rootroot00000000000000ecl-16.1.2/src/gmp/.gdbinit000066400000000000000000000017761266352375300153660ustar00rootroot00000000000000# Copyright 1999 Free Software Foundation, Inc. # # This file is part of the GNU MP Library. # # The GNU MP Library is free software; you can redistribute it and/or modify # it under the terms of the GNU Lesser General Public License as published by # the Free Software Foundation; either version 2.1 of the License, or (at your # option) any later version. # # The GNU MP Library is distributed in the hope that it will be useful, but # WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY # or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public # License for more details. # # You should have received a copy of the GNU Lesser General Public License # along with the GNU MP Library; see the file COPYING.LIB. If not, write to # the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, # MA 02110-1301, USA. define pz set __gmpz_dump ($) end define pq set __gmpz_dump ($->_mp_num) echo / set __gmpz_dump ($->_mp_den) end define pf set __gmpf_dump ($) end ecl-16.1.2/src/gmp/AUTHORS000066400000000000000000000015131266352375300150020ustar00rootroot00000000000000Authors of GNU MP (in chronological order of initial contribution) Torbjіrn Granlund Main author John Amanatides Original version of mpz/pprime_p.c Paul Zimmermann mpn/generic/mul_fft.c, mpn/generic/dc_divrem_n.c, new mpz/powm.c, improved Toom3 code. Ken Weber mpn/generic/gcd.c mpn/generic/bdivmod.c Bennet Yee mpz/jacobi.c mpz/legendre.c Andreas Schwab mpn/m68k/lshift.S, mpn/m68k/rshift.S Robert Harley mpn/generic/mul_n.c, files in mpn/arm Linus Nordberg Random number framework, original autoconfery Kent Boortz MacOS 9 port Kevin Ryde Most x86 assembly, new autoconfery, and countless other things (please see the GMP manual for complete list) Gerardo Ballabio gmpxx.h and C++ istream input Pedro Gimeno Mersenne Twister random generator, other random number revisions Jason Moxham New mpz/fac_ui.c and gen-fac_ui.c ecl-16.1.2/src/gmp/COPYING000066400000000000000000000431061266352375300147710ustar00rootroot00000000000000 GNU GENERAL PUBLIC LICENSE Version 2, June 1991 Copyright (C) 1989, 1991 Free Software Foundation, Inc. 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it. (Some other Free Software Foundation software is covered by the GNU Lesser General Public License instead.) You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things. To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it. For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software. Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations. Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all. The precise terms and conditions for copying, distribution and modification follow. GNU GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language. (Hereinafter, translation is included without limitation in the term "modification".) Each licensee is addressed as "you". Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does. 1. You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change. b) You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License. c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License. (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program. In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following: a) Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, b) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, c) Accompany it with the information you received as to the offer to distribute corresponding source code. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.) The source code for a work means the preferred form of the work for making modifications to it. For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code. 4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 5. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Program or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it. 6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License. 7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all. For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 9. The Free Software Foundation may publish revised and/or new versions of the General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation. 10. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA Also add information on how to contact you by electronic and paper mail. If the program is interactive, make it output a short notice like this when it starts in an interactive mode: Gnomovision version 69, Copyright (C) year name of author Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, the commands you use may be called something other than `show w' and `show c'; they could even be mouse-clicks or menu items--whatever suits your program. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the program, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the program `Gnomovision' (which makes passes at compilers) written by James Hacker. , 1 April 1989 Ty Coon, President of Vice This General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Lesser General Public License instead of this License. ecl-16.1.2/src/gmp/COPYING.LIB000066400000000000000000000635041266352375300154020ustar00rootroot00000000000000 GNU LESSER GENERAL PUBLIC LICENSE Version 2.1, February 1999 Copyright (C) 1991, 1999 Free Software Foundation, Inc. 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. [This is the first released version of the Lesser GPL. It also counts as the successor of the GNU Library Public License, version 2, hence the version number 2.1.] Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public Licenses are intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This license, the Lesser General Public License, applies to some specially designated software packages--typically libraries--of the Free Software Foundation and other authors who decide to use it. You can use it too, but we suggest you first think carefully about whether this license or the ordinary General Public License is the better strategy to use in any particular case, based on the explanations below. When we speak of free software, we are referring to freedom of use, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish); that you receive source code or can get it if you want it; that you can change the software and use pieces of it in new free programs; and that you are informed that you can do these things. To protect your rights, we need to make restrictions that forbid distributors to deny you these rights or to ask you to surrender these rights. These restrictions translate to certain responsibilities for you if you distribute copies of the library or if you modify it. For example, if you distribute copies of the library, whether gratis or for a fee, you must give the recipients all the rights that we gave you. You must make sure that they, too, receive or can get the source code. If you link other code with the library, you must provide complete object files to the recipients, so that they can relink them with the library after making changes to the library and recompiling it. And you must show them these terms so they know their rights. We protect your rights with a two-step method: (1) we copyright the library, and (2) we offer you this license, which gives you legal permission to copy, distribute and/or modify the library. To protect each distributor, we want to make it very clear that there is no warranty for the free library. Also, if the library is modified by someone else and passed on, the recipients should know that what they have is not the original version, so that the original author's reputation will not be affected by problems that might be introduced by others. Finally, software patents pose a constant threat to the existence of any free program. We wish to make sure that a company cannot effectively restrict the users of a free program by obtaining a restrictive license from a patent holder. Therefore, we insist that any patent license obtained for a version of the library must be consistent with the full freedom of use specified in this license. Most GNU software, including some libraries, is covered by the ordinary GNU General Public License. This license, the GNU Lesser General Public License, applies to certain designated libraries, and is quite different from the ordinary General Public License. We use this license for certain libraries in order to permit linking those libraries into non-free programs. When a program is linked with a library, whether statically or using a shared library, the combination of the two is legally speaking a combined work, a derivative of the original library. The ordinary General Public License therefore permits such linking only if the entire combination fits its criteria of freedom. The Lesser General Public License permits more lax criteria for linking other code with the library. We call this license the "Lesser" General Public License because it does Less to protect the user's freedom than the ordinary General Public License. It also provides other free software developers Less of an advantage over competing non-free programs. These disadvantages are the reason we use the ordinary General Public License for many libraries. However, the Lesser license provides advantages in certain special circumstances. For example, on rare occasions, there may be a special need to encourage the widest possible use of a certain library, so that it becomes a de-facto standard. To achieve this, non-free programs must be allowed to use the library. A more frequent case is that a free library does the same job as widely used non-free libraries. In this case, there is little to gain by limiting the free library to free software only, so we use the Lesser General Public License. In other cases, permission to use a particular library in non-free programs enables a greater number of people to use a large body of free software. For example, permission to use the GNU C Library in non-free programs enables many more people to use the whole GNU operating system, as well as its variant, the GNU/Linux operating system. Although the Lesser General Public License is Less protective of the users' freedom, it does ensure that the user of a program that is linked with the Library has the freedom and the wherewithal to run that program using a modified version of the Library. The precise terms and conditions for copying, distribution and modification follow. Pay close attention to the difference between a "work based on the library" and a "work that uses the library". The former contains code derived from the library, whereas the latter must be combined with the library in order to run. GNU LESSER GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License Agreement applies to any software library or other program which contains a notice placed by the copyright holder or other authorized party saying it may be distributed under the terms of this Lesser General Public License (also called "this License"). Each licensee is addressed as "you". A "library" means a collection of software functions and/or data prepared so as to be conveniently linked with application programs (which use some of those functions and data) to form executables. The "Library", below, refers to any such software library or work which has been distributed under these terms. A "work based on the Library" means either the Library or any derivative work under copyright law: that is to say, a work containing the Library or a portion of it, either verbatim or with modifications and/or translated straightforwardly into another language. (Hereinafter, translation is included without limitation in the term "modification".) "Source code" for a work means the preferred form of the work for making modifications to it. For a library, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the library. Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running a program using the Library is not restricted, and output from such a program is covered only if its contents constitute a work based on the Library (independent of the use of the Library in a tool for writing it). Whether that is true depends on what the Library does and what the program that uses the Library does. 1. You may copy and distribute verbatim copies of the Library's complete source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and distribute a copy of this License along with the Library. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Library or any portion of it, thus forming a work based on the Library, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) The modified work must itself be a software library. b) You must cause the files modified to carry prominent notices stating that you changed the files and the date of any change. c) You must cause the whole of the work to be licensed at no charge to all third parties under the terms of this License. d) If a facility in the modified Library refers to a function or a table of data to be supplied by an application program that uses the facility, other than as an argument passed when the facility is invoked, then you must make a good faith effort to ensure that, in the event an application does not supply such function or table, the facility still operates, and performs whatever part of its purpose remains meaningful. (For example, a function in a library to compute square roots has a purpose that is entirely well-defined independent of the application. Therefore, Subsection 2d requires that any application-supplied function or table used by this function must be optional: if the application does not supply it, the square root function must still compute square roots.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Library, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Library, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Library. In addition, mere aggregation of another work not based on the Library with the Library (or with a work based on the Library) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may opt to apply the terms of the ordinary GNU General Public License instead of this License to a given copy of the Library. To do this, you must alter all the notices that refer to this License, so that they refer to the ordinary GNU General Public License, version 2, instead of to this License. (If a newer version than version 2 of the ordinary GNU General Public License has appeared, then you can specify that version instead if you wish.) Do not make any other change in these notices. Once this change is made in a given copy, it is irreversible for that copy, so the ordinary GNU General Public License applies to all subsequent copies and derivative works made from that copy. This option is useful when you wish to copy part of the code of the Library into a program that is not a library. 4. You may copy and distribute the Library (or a portion or derivative of it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange. If distribution of object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place satisfies the requirement to distribute the source code, even though third parties are not compelled to copy the source along with the object code. 5. A program that contains no derivative of any portion of the Library, but is designed to work with the Library by being compiled or linked with it, is called a "work that uses the Library". Such a work, in isolation, is not a derivative work of the Library, and therefore falls outside the scope of this License. However, linking a "work that uses the Library" with the Library creates an executable that is a derivative of the Library (because it contains portions of the Library), rather than a "work that uses the library". The executable is therefore covered by this License. Section 6 states terms for distribution of such executables. When a "work that uses the Library" uses material from a header file that is part of the Library, the object code for the work may be a derivative work of the Library even though the source code is not. Whether this is true is especially significant if the work can be linked without the Library, or if the work is itself a library. The threshold for this to be true is not precisely defined by law. If such an object file uses only numerical parameters, data structure layouts and accessors, and small macros and small inline functions (ten lines or less in length), then the use of the object file is unrestricted, regardless of whether it is legally a derivative work. (Executables containing this object code plus portions of the Library will still fall under Section 6.) Otherwise, if the work is a derivative of the Library, you may distribute the object code for the work under the terms of Section 6. Any executables containing that work also fall under Section 6, whether or not they are linked directly with the Library itself. 6. As an exception to the Sections above, you may also combine or link a "work that uses the Library" with the Library to produce a work containing portions of the Library, and distribute that work under terms of your choice, provided that the terms permit modification of the work for the customer's own use and reverse engineering for debugging such modifications. You must give prominent notice with each copy of the work that the Library is used in it and that the Library and its use are covered by this License. You must supply a copy of this License. If the work during execution displays copyright notices, you must include the copyright notice for the Library among them, as well as a reference directing the user to the copy of this License. Also, you must do one of these things: a) Accompany the work with the complete corresponding machine-readable source code for the Library including whatever changes were used in the work (which must be distributed under Sections 1 and 2 above); and, if the work is an executable linked with the Library, with the complete machine-readable "work that uses the Library", as object code and/or source code, so that the user can modify the Library and then relink to produce a modified executable containing the modified Library. (It is understood that the user who changes the contents of definitions files in the Library will not necessarily be able to recompile the application to use the modified definitions.) b) Use a suitable shared library mechanism for linking with the Library. A suitable mechanism is one that (1) uses at run time a copy of the library already present on the user's computer system, rather than copying library functions into the executable, and (2) will operate properly with a modified version of the library, if the user installs one, as long as the modified version is interface-compatible with the version that the work was made with. c) Accompany the work with a written offer, valid for at least three years, to give the same user the materials specified in Subsection 6a, above, for a charge no more than the cost of performing this distribution. d) If distribution of the work is made by offering access to copy from a designated place, offer equivalent access to copy the above specified materials from the same place. e) Verify that the user has already received a copy of these materials or that you have already sent this user a copy. For an executable, the required form of the "work that uses the Library" must include any data and utility programs needed for reproducing the executable from it. However, as a special exception, the materials to be distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. It may happen that this requirement contradicts the license restrictions of other proprietary libraries that do not normally accompany the operating system. Such a contradiction means you cannot use both them and the Library together in an executable that you distribute. 7. You may place library facilities that are a work based on the Library side-by-side in a single library together with other library facilities not covered by this License, and distribute such a combined library, provided that the separate distribution of the work based on the Library and of the other library facilities is otherwise permitted, and provided that you do these two things: a) Accompany the combined library with a copy of the same work based on the Library, uncombined with any other library facilities. This must be distributed under the terms of the Sections above. b) Give prominent notice with the combined library of the fact that part of it is a work based on the Library, and explaining where to find the accompanying uncombined form of the same work. 8. You may not copy, modify, sublicense, link with, or distribute the Library except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense, link with, or distribute the Library is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 9. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Library or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Library (or any work based on the Library), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Library or works based on it. 10. Each time you redistribute the Library (or any work based on the Library), the recipient automatically receives a license from the original licensor to copy, distribute, link with or modify the Library subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties with this License. 11. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Library at all. For example, if a patent license would not permit royalty-free redistribution of the Library by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Library. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply, and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 12. If the distribution and/or use of the Library is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Library under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 13. The Free Software Foundation may publish revised and/or new versions of the 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 specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Library does not specify a license version number, you may choose any version ever published by the Free Software Foundation. 14. If you wish to incorporate parts of the Library into other free programs whose distribution conditions are incompatible with these, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Libraries If you develop a new library, and you want it to be of the greatest possible use to the public, we recommend making it free software that everyone can redistribute and change. You can do so by permitting redistribution under these terms (or, alternatively, under the terms of the ordinary General Public License). To apply these terms, attach the following notices to the library. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA Also add information on how to contact you by electronic and paper mail. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the library, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the library `Frob' (a library for tweaking knobs) written by James Random Hacker. , 1 April 1990 Ty Coon, President of Vice That's all there is to it! ecl-16.1.2/src/gmp/ChangeLog000066400000000000000000025272321266352375300155210ustar00rootroot00000000000000Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc. . This file is part of the GNU MP Library. . The GNU MP Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. . The GNU MP Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. . You should have received a copy of the GNU Lesser General Public License along with the GNU MP Library; see the file COPYING.LIB. If not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. 2006-05-04 Torbjorn Granlund * Version 4.2.1 released. 2006-05-03 Torbjorn Granlund * mpn/powerpc64/vmx/popcount.asm: Conditionally zero extend n. 2006-04-27 Torbjorn Granlund * mpz/divexact.c: Call mpz_tdiv_q for large operands. * configure.in (powerpc-*-darwin): Remove -fast, it affects PIC. 2006-04-26 Torbjorn Granlund * config.guess: Try to recognize Ultrasparc T1 (as ultrasparct1). * config.sub: Handle ultrasparct1. 2006-04-25 Torbjorn Granlund * mpn/sparc64/gmp-mparam.h: Retune, without separation of GNUC and non-GNUC data. 2006-04-19 Torbjorn Granlund * configure.in: Support powerpc eABI. * mpn/powerpc32/eabi.m4: New file. * configure.in: Support powerpc *bsd. * mpn/powerpc64/elf.m4: New name for mpn/powerpc64/linux64.m4. * mpn/powerpc32/elf.m4: New name for mpn/powerpc32/linux.m4. * mpn/powerpc64/linux64.m4 (ASM_END): Quote TOC_ENTRY. 2006-04-18 Torbjorn Granlund * configure.in (gmp_mpn_functions_optional): Add lshiftc. (HAVE_NATIVE): Add lshiftc. * tune/speed.h (SPEED_ROUTINE_MPN_ADDSUB_N_CALL): New macro. * tune/common.c (speed_mpn_addsub_n): New function. * tune/speed.c (routine): Add measuring of mpn_addsub_n. * mpn/powerpc64/linux64.m4 (TOC_ENTRY): Define to empty. * mpn/powerpc64/aix.m4 (TOC_ENTRY): Likewise. * mpn/powerpc32/aix.m4 (TOC_ENTRY): Likewise. * mpn/powerpc32/aix.m4 (EXTERN): New, copied form powerpc64/aix.m4. * mpn/powerpc32/mode1o.asm: Use EXTERN. * mpn/powerpc32/linux.m4 (EXTERN): Provide dummy definition. * mpn/powerpc32/darwin.m4 (EXTERN): Likewise. 2006-04-13 Torbjorn Granlund * tests/devel/try.c (choice_array): Add mpn_addsub_n[c]. 2006-04-12 Torbjorn Granlund * extract-dbl.c: Don't rely on undefined casts to mp_limb_signed_t. * configure.in: Disable AC_C_RESTRICT for now. * mpn/generic/diveby3.c: Don't use restict keyword for now. 2006-04-11 Torbjorn Granlund * gmp-h.in (__GNU_MP_VERSION_PATCHLEVEL): Bump. * aclocal.m4: Regenerate with patched libtool. * mpn/asm-defs.m4 (ASM_END): Provide (empty) default. 2006-04-08 Torbjorn Granlund * configure.in (gmp_mpn_functions_optional): Add addsub. * Makefile.am (LIBGMP_LT_*, LIBGMPXX_LT_*, LIBMP_LT_*): Bump version info. * gmpxx.h: Remove missed MPFR references. * gmp-impl.h (TMP_*, WANT_TMP_DEBUG): Don't expect marker argument; define TMP_SALLOC and TMP_BALLOC. 2006-04-05 Torbjorn Granlund * tal-notreent.c (__gmp_tmp_mark): Add "struct" tag for tmp_marker. (__gmp_tmp_free): Likewise. 2006-03-26 Torbjorn Granlund * Version 4.2 released. * mpn/powerpc64/aix.m4 (LEA): Renamed from LDSYM. * mpn/powerpc64/darwin.m4: Likewise. * mpn/powerpc64/linux64.m4: Likewise. * mpn/powerpc64/vmx/popcount.asm: Use LEA, not LDSYM. 2006-03-23 Torbjorn Granlund * gmp-impl.h: (class gmp_allocated_string): Prefix strlen with std::. * gmpxx.h (__GMP_DEFINE_TERNARY_EXPR2): Remove for now. (struct __gmp_ternary_addmul2): Likewise. (struct __gmp_ternary_submul2): Likewise. * gmpxx.h: #include . (struct __gmp_alloc_cstring): Prefix strlen with std::. * mpn/x86/pentium/com_n.asm: Add TEXT and ALIGN. * mpn/x86/pentium/copyi.asm: Likewise. * mpn/x86/pentium/copyd.asm: Likewise. 2006-03-22 Torbjorn Granlund * gmp-h.in: Add a "using std::FILE" for C++. (_GMP_H_HAVE_FILE): Check also _ISO_STDIO_ISO_H. * gmpxx.h: Remove mpfr code. * tests/cxx: Likewise. * gmp-impl.h (FORCE_DOUBLE): Rename a tempvar to avoid a clash with GNU/Linux public include file. * configure.in (powerpc64, darwin): New optional, gcc_cflags_subtype. Grab powerpc32/darwin.m4 for ABI=mode32. * configure.in: Use host_cpu whenever just the cpu type is needed. 2006-03-08 Torbjorn Granlund * mpz/get_si.c: Fix a typo. * tests/mpq/t-get_d.c (check_random): Improve random generation for nails. 2006-02-28 Torbjorn Granlund * tests/mpq/t-get_d.c (check_random): New function. (main): Call check_random. * mpq/set_d.c: Make choices based on LIMBS_PER_DOUBLE, not BITS_PER_MP_LIMB. Make it work for LIMBS_PER_DOUBLE == 4. Use MPZ_REALLOC. * mpz/set_d.c: Make it work for LIMBS_PER_DOUBLE == 4. * extract-dbl.c: Make it work for LIMBS_PER_DOUBLE > 3. 2006-02-27 Torbjorn Granlund * mpz/cmp_d.c: Declare `i'. * mpz/cmpabs_d.c: Likewise. 2006-02-23 Torbjorn Granlund * mpn/powerpc32/vmx/copyd.asm: Set right VRSAVE bits. * mpn/powerpc32/vmx/copyi.asm: Likewise. 2006-02-22 Torbjorn Granlund * mpn/powerpc32/vmx/logops_n.asm: New file. * mpn/powerpc32/diveby3.asm: Rewrite. 2006-02-21 Torbjorn Granlund * mpn/powerpc32/vmx/copyi.asm: New file. * mpn/powerpc32/vmx/copyd.asm: New file. 2006-02-17 Torbjorn Granlund * mpn/alpha/ev6/nails/aors_n.asm (CYSH): Import proper setting from deleted mpn_sub_n. 2006-02-16 Torbjorn Granlund * mpn/alpha/ev6/addmul_1.asm: Correct slotting comments. 2006-02-15 Torbjorn Granlund * tests/devel/anymul_1.c: Copy error reporting code from addmul_N.c. * tests/devel/addmul_N.c: New file. * tests/devel/mul_N.c: New file. * mpn/alpha/default.m4 (PROLOGUE_cpu): Align functions at 16-byte boundary. * mpn/alpha/ev6/nails/aors_n.asm: New file. * mpn/alpha/ev6/nails/add_n.asm: Remove. * mpn/alpha/ev6/nails/sub_n.asm: Remove. * mpn/alpha/ev6/nails/addmul_1.asm: Rewrite. * mpn/alpha/ev6/nails/submul_1.asm: Likewise. * mpn/alpha/ev6/nails/mul_1.asm: Likewise. * mpn/alpha/ev6/nails/addmul_2.asm: Use L() for labels. * mpn/alpha/ev6/nails/addmul_3.asm: Use L() for labels. * mpn/alpha/ev6/nails/addmul_4.asm: Use L() for labels. 2006-02-13 Torbjorn Granlund * mpn/powerpc32/diveby3.asm: Trivially reorder loop insns to save 1 c/l. 2006-02-10 Torbjorn Granlund * mpn/powerpc64/sqr_diagonal.asm: Software pipeline. * mpn/powerpc64/vmx/popcount.asm: Add prefetching. 2006-02-04 Torbjorn Granlund * mpn/powerpc64/vmx/popcount.asm: Remove mpn_hamdist partial code. Move compare for huge n so that it is always executed. 2006-02-03 Torbjorn Granlund * mpn/powerpc32/linux.m4 (LEA): Add support for PIC. * configure.in (powerpc): New optional, gcc_cflags_subtype. * mpn/powerpc64/linux64.m4 (PROLOGUE_cpu): Align function start to 16-multiple. * mpn/powerpc64/aix.m4: Likewise. * mpn/powerpc64/darwin.m4: Likewise. * mpn/powerpc64/copyi.asm: Align loop to 16-multiple. * mpn/powerpc64/copyd.asm: Likewise * configure.in (powerpc): Add vmx to relevant paths. * mpn/powerpc64/linux64.m4 (DEF_OBJECT): Accept 2nd argument, for alignment. * mpn/powerpc64/aix.m4: Likewise. * mpn/powerpc64/darwin.m4: Likewise. * mpn/powerpc32/linux.m4 (DEF_OBJECT, END_OBJECT): New macros, inherited from powerpc64 versions. * mpn/powerpc32/aix.m4: Likewise. * mpn/powerpc32/darwin.m4: Likewise. * mpn/powerpc64/vmx/popcount.asm: New file, for ppc32 and ppc64. * mpn/powerpc32/vmx/popcount.asm: New file, grabbing above file. 2006-01-22 Torbjorn Granlund * configure.in: Generalize OS-dependent patterns for powerpcs. 2006-01-20 Torbjorn Granlund * config.guess: Recognize power4 and up under linux-gnu. * config.sub: Generalize power recognition code. * acinclude.m4 (POWERPC64_PATTERN): Add 64-bit powerpc processors. * configure.in: Recognize powerpc procssors masquerading as power procssors. 2006-01-17 Torbjorn Granlund * mpn/generic/diveby3.c: Use GMP standard parameter names. Nailify alternative code. Use restrict for params. * configure.in: Recognize andn_n as not needing nailification. * tests/mpq/t-equal.c (check_various): Disable a test that gives common factors for GMP_NUMB_BITS == 62. 2006-01-16 Torbjorn Granlund * mpn/generic/get_str.c (mpn_sb_get_str): Fix digit count computation, was inaccurate for nails. 2006-01-15 Torbjorn Granlund * mpn/x86_64/mode1o.asm: Remove unneeded carry register zeroing. 2006-01-08 Torbjorn Granlund * mpn/alpha/ev6/sqr_diagonal.asm: New file. 2006-01-06 Torbjorn Granlund * mpn/generic/mullow_n.c (MUL_BASECASE_ALLOC): New #define. (mpn_mullow_n): Use it. * mpn/powerpc64/aix.m4 (EXTERN): Define to import symbol. (LDSYM): Remove [RW] attribute. * mpn/powerpc64/linux64.m4 (EXTERN): Dummy definition. * mpn/powerpc64/darwin.m4 (EXTERN): Likewise. 2006-01-05 Torbjorn Granlund * mpn/powerpc64/linux64.m4: Move toc entry generation from direct at DEF_OBJECT to delayed via LDSYM, define ASM_END to output it. * mpn/powerpc64/aix.m4: Likewise. * mpn/powerpc64/darwin.m4: Define a dummy ASM_END. 2006-01-03 Torbjorn Granlund * configure.in: Update bugs reporting address. 2006-01-02 Torbjorn Granlund * mpn/powerpc64/linux64.m4 (CALL): New macro. * mpn/powerpc64/aix.m4: Likewise. * mpn/powerpc64/darwin.m4: Likewise, also define macro "DARWIN". 2005-12-18 Torbjorn Granlund * mpf/ui_div.c: Implement workaround for GCC bug triggered on alpha. * mpf/set_q.c: Likewise. 2005-12-16 Torbjorn Granlund * mpn/generic/tdiv_qr.c: Remove statement with no effect. Rename dead variable to `dummy'. 2005-12-15 Torbjorn Granlund * demos/pexpr.c (setup_error_handler): Add a missing ";". 2005-11-27 Torbjorn Granlund * mpn/generic/mul.c: Crudely call mpn_mul_fft_full before checking for unbalanced operands. * mpn/generic/mul_fft.c: Remove many scalar divisions. (mpn_mul_fft_lcm): Simplify. (mpn_mul_fft_decompose): Rewrite to handle arbitrarily unbalanced operands. 2005-11-22 Torbjorn Granlund * configure.in: Properly recognize all 32-bit Solaris releases. 2005-11-10 Torbjorn Granlund * mpn/generic/mul_fft.c: Inline mpn_fft_mul_2exp_modF, mpn_fft_add_modF and mpn_fft_normalize. 2005-11-02 Torbjorn Granlund * tests/mpz/reuse.c: Increase operand size, decrease # of reps. 2005-10-31 Torbjorn Granlund * mpz/pprime_p.c (mpz_probab_prime_p): Considerably limit trial dividing. * mpz/perfpow.c (mpz_perfect_power_p): Use mpz_divisible_ui_p instead of mpz_tdiv_ui. * mpz/divegcd.c: Correct probability number for GCD == 1. * mpn/x86: Add cycle counts for array of x86 processors. * mpn/x86/k7/mod_34lsub1.asm: Remove spurious mentions of ebp. * mpn/powerpc32: Add POWER5 timings. * mpn/powerpc32/README: Describe global reference variations. * mpn/generic/dive_1.c: Whitespace cleanup. * mpn/alpha/ev6/nails/addmul_1.asm: Correct comments on slotting. * mpn/alpha/ev6/nails/addmul_2.asm: Likewise. * mpn/alpha/ev6/nails/addmul_4.asm: Likewise. * mpf/out_str.c: List some allocation improvement ideas. * doc/gmp.texi: Update many URLs and email addresses. * gmp-h.in (_GMP_H_HAVE_FILE): Check also _STDIO_H_INCLUDED. 2005-10-26 Torbjorn Granlund * tune/tuneup.c (tune_mullow): Update param.max_size for each threshold measurement. * configure.in (POWERPC64_PATTERN/*-*-darwin*): Set SPEED_CYCLECOUNTER_OBJ_mode64 and cyclecounter_size_mode64. (POWERPC64_PATTERN/*-*-linux*): Likewise. 2005-10-03 Torbjorn Granlund * demos/factorize.c (factor_using_division_2kp): Honor verbose flag. (factor_using_pollard_rho): Divide out new factor before it's clobbered. Don't stop factoring after a composite factor was found. 2005-09-17 Torbjorn Granlund * demos/pexpr.c (fns): Add factorial keywords. 2005-08-16 Torbjorn Granlund * tune/Makefile.am (EXTRA_DIST): Change "amd64" => "x86_64". * mpn/Makefile.am (TARG_DIST): Change "amd64" => "x86_64". 2005-08-15 Torbjorn Granlund * configure.in: Change "amd64" => "x86_64". 2005-06-13 Torbjorn Granlund * mpn/generic/pre_mod_1.c: Canonicalize variable names. * mpn/generic/divrem.c: Rate qxn test as UNLIKELY. * tune/tuneup.c (tune_mullow): Fix all max_size fields. * gmp-impl.h (SQR_TOOM3_THRESHOLD_LIMIT): New #define. * tune/tuneup.c (tune_sqr): Use SQR_TOOM3_THRESHOLD_LIMIT. (sqr_toom3_threshold): Initialize from SQR_TOOM3_THRESHOLD_LIMIT. * mpn/generic/mul_n.c (mpn_sqr_n): Use SQR_TOOM3_THRESHOLD_LIMIT. * gmp-impl.h (mpn_nand_n, mpn_iorn_n, mpn_nior_n, mpn_xnor_n): Handle nails. 2005-06-12 Torbjorn Granlund * mpn/alpha/ev6/sub_n.asm: Analogous changes as to add_n.asm last. 2005-06-11 Torbjorn Granlund * mpn/alpha/ev6/add_n.asm: Rewrite inner loop to load later. Add mpn_add_nc entry. * mpn/alpha/ev6/addmul_1.asm: Remove redundant initial loads. 2005-06-07 Torbjorn Granlund * mpn/generic/dive_1.c: Use variable h for upper umul_ppmm result. 2005-06-04 Torbjorn Granlund * tests/devel/try.c (choice_array): Exclude mpn_preinv_mod_1 unless USE_PREINV_MOD_1. (choice_array): Exclude mpn_sqr_basecase if SQR_KARATSUBA_THRESHOLD is zero. 2005-06-03 Torbjorn Granlund * mpn/alpha/ev6/addmul_1.asm: Prefix all labels with "$". * mpn/alpha/ev6/mul_1.asm: Likewise. 2005-06-02 Torbjorn Granlund * tests/refmpn.c (refmpn_divmod_1c_workaround): Implement workaround to gcc 3.4.x bug triggered on powerpc64 with 32-bit ABI. 2005-06-01 Torbjorn Granlund * tests/devel/try.c (main): Fix a typo. 2005-05-31 Torbjorn Granlund * mpn/alpha/ev6/addmul_1.asm: Rewrite for L1 cache, add prefetch. 2005-05-30 Torbjorn Granlund * tests/misc.c (tests_rand_start): Mask random seed to 32 bits. 2005-05-29 Torbjorn Granlund * mpn/powerpc64/mode32/mul_1.asm: Handle BROKEN_LONGLONG_PARAM. * mpn/powerpc64/mode32/addmul_1.asm: Likewise. * mpn/powerpc64/mode32/submul_1.asm: Likewise. * mpn/powerpc32/mode1o.asm: Rewrite to actually work. * mpn/powerpc32/aix.m4 (LEA): New macro. (ASM_END): New macro. * mpn/powerpc32/linux.m4: New file. * mpn/powerpc32/darwin.m4: New file. * configure.in: Use linux.m4 and darwin.m4. (powerpc64-linux-gnu): Add support for mode32. 2005-05-25 Torbjorn Granlund * mpn/generic/mullow_n.c: Remove FIXME mentioning fixed flaw. * tests/mpz/t-cmp_d.c (check_one): Fix printf fmt string typo. * demos/isprime.c: #include stdlib.h. * tests/rand/t-urbui.c: Likewise. * tests/rand/t-urmui.c: Likewise. * tests/mpz/t-popcount.c (check_random): Remove spurious printf arg. 2005-05-24 Torbjorn Granlund * tests/devel/try.c (param_init) [TYPE_GET_STR]: Set retval field. (compare): Handle SIZE_GET_STR as SIZE_RETVAL. * tests/refmpn.c (refmpn_get_str): Rewrite to make it work. 2005-05-23 Torbjorn Granlund * longlong.h (many places): Remove lvalue casts. * gmp-impl.h (MPF_SIGNIFICANT_DIGITS): Cast prec to avoid overflow for > 4G digits. * mpn/alpha/ev6/add_n.asm: Prefetch using ldl. * mpn/alpha/ev6/sub_n.asm: Likewise. * mpn/alpha/ev6/slot.pl (optable): Recognize negq and ldl. 2005-05-22 Torbjorn Granlund * mpn/alpha/ev67/popcount.asm: Prefetch. * mpn/alpha/ev67/hamdist.asm: Prefetch. * longlong.h (add_ssaaaa) [x86]: Remove lvalue casts. (sub_ddmmss) [x86]: Likewise. * tests/devel/try.c (param_init) [TYPE_MPZ_JACOBI]: Add DATA_SRC1_ODD. (param_init) [TYPE_MPZ_KRONECKER]: Clear inherited DATA_SRC1_ODD. (param_init) [TYPE_DIVEXACT_1]: Use symbolic name DIVISOR_LIMB. 2005-05-21 Torbjorn Granlund * tests/devel/try.c (param_init) [TYPE_MPZ_JACOBI]: Initialize divisor field according to UDIV_NEEDS_NORMALIZATION. * mpz/mul_i.h: Remove left-over TMP_XXXX marker arguments. 2005-05-20 Torbjorn Granlund * mpn/x86/pentium4/sse2/addmul_1.asm (mpn_addmul_1c): Put carry in proper register. * mpn/generic/sqr_basecase.c (mpn_sqr_basecase, addmul_2 version): Avoid accesses out-of-bound in MPN_SQR_DIAGONAL applicate code. 2005-05-19 Torbjorn Granlund * mpn/alpha/diveby3.asm: Make it actually work. * gmp-impl.h (MULLOW_BASECASE_THRESHOLD_LIMIT): New #define. * mpn/generic/mullow_n.c: Use fixed stack allocation for the smallest operands; use TMP_S* allocation for medium operands. * gmp-impl.h: Remove nested TUNE_PROGRAM_BUILD test. 2005-05-18 Torbjorn Granlund * mpn/generic/mul_n.c: Make squaring and multiplication code more similar. Use TMP_S* functions. * gmp-impl.h (TMP_DECL, TMP_MARK, TMP_FREE): Get rid of argument. (TMP_SALLOC): New macro for "small" allocations. (TMP_BALLOC): New macro for "big" allocations. (TMP_SDECL, TMP_SMARK, TMP_SFREE): New macros for functions that use just TMP_SALLOC. (WANT_TMP_ALLOCA): Make default functions choose alloca or reentrant functions, depending on size. * *.c: Remove TMP_XXXX marker arguments. * acinclude.m4 (WANT_TMP): Want tal-reent.lo also for alloca case. 2005-05-15 Torbjorn Granlund * gmp-impl.h (udiv_qrnnd_preinv2): Pull an add into add_ssaaaa. (udiv_qrnnd_preinv2gen): Likewise. 2005-05-14 Torbjorn Granlund * longlong.h (add_ssaaaa) [x86_64]: Restrict allowed immediate operands. * (sub_ddmmss) [x86_64]: Likewise. 2005-05-02 Torbjorn Granlund * acinclude.m4 (GMP_HPC_HPPA_2_0): Make gmp_tmp_v1 sed pattern handle version numbers like B.11.X.32509-32512.GP. * mpn/m68k/aors_n.asm: Correct MULFUNC_PROLOGUE. * mpf/inp_str.c: Use plain int for mpf_set_str return value (works around gcc 4 bug). * acinclude.m4 (GMP_ASM_POWERPC_PIC_ALWAYS): Handle darwin's assembly syntax. (long long reliability test 1): New GMP_PROG_CC_WORKS_PART test. (long long reliability test 2): New GMP_PROG_CC_WORKS_PART test. * configure.in: Add mode64 support for darwin. Use darwin.m4. Add cflags_opt flags for mode32 darwin. * mpn/asm-defs.m4 (PIC_ALWAYS): Define PIC just iff PIC_ALWAYS = "yes". * mpn/powerpc64/darwin.m4: New file. * mpn/powerpc64/linux64.m4: Remove TOCREF, add LDSYM. Rework DEF_OBJECT to need just one argument. * mpn/powerpc64/aix.m4: Likewise. 2005-05-01 Torbjorn Granlund * mpn/generic/popham.c: Compute final summation differently for 64-bit. * tests/mpz/t-popcount.c (check_random): New function. (main): Call it. 2005-04-09 Torbjorn Granlund * mpn/powerpc64/copyi.asm: If HAVE_ABI_mode32, ignore upper 32 bits of mp_size_t argument. * mpn/powerpc64/copyd.asm: Likewise. * mpn/powerpc64/sqr_diagonal.asm: Likewise. * mpn/powerpc64/lshift.asm: Likewise. * mpn/powerpc64/rshift.asm: Likewise. 2005-04-08 Torbjorn Granlund * mpn/generic/rootrem.c: Allocate PP_ALLOC limbs also for qp. 2005-04-07 Torbjorn Granlund * mpn/powerpc32/add_n.asm: Add nc entry point. * mpn/powerpc32/sub_n.asm: Likewise. * mpn/alpha/add_n.asm: Add correct cycle/limb numbers. * mpn/alpha/sub_n.asm: Likewise. * mpn/alpha/ev5/add_n.asm: Likewise. * mpn/alpha/ev5/sub_n.asm: Likewise. 2005-03-31 Torbjorn Granlund * mpn/x86/k7/gmp-mparam.h: Fix typo in last change. 2005-03-19 Torbjorn Granlund * mpn/alpha/gmp-mparam.h: Update. * mpn/alpha/ev5/gmp-mparam.h: Update. * mpn/alpha/ev6/gmp-mparam.h: Update. * mpn/x86/p6/mmx/gmp-mparam.h: Update. * mpn/x86/pentium4/sse2/gmp-mparam.h: Update. * mpn/x86/k7/gmp-mparam.h: Update. * tests/mpz/t-gcd.c (main): Honor command line reps argument. * tune/speed.h (SPEED_ROUTINE_MPN_GCD_CALL): Simplify and correct code for generating test operands. 2005-01-13 Torbjorn Granlund * gmp-impl.h (MPN_SIZEINBASE): Count bits in type size_t. (MPN_SIZEINBASE_16): Likewise. 2004-12-17 Torbjorn Granlund * tune/speed.c (run_gnuplot): Use lines, not linespoints. Output a reset gnuplot command initially. 2004-12-04 Torbjorn Granlund * mpn/generic/random2.c (gmp_rrandomb): Rework again. * mpz/rrandomb.c (gmp_rrandomb): Likewise. 2004-11-24 Torbjorn Granlund * mpn/alpha/diveby3.asm: Use correct prefetch instruction. 2004-11-19 Torbjorn Granlund * mpn/alpha/diveby3.asm: Add ",gp" glue in PROLOGUE. Add r31 dummy operand to `br' instruction. 2004-11-17 Torbjorn Granlund * configure.in: Invoke AC_C_RESTRICT. 2004-11-16 Torbjorn Granlund * mpn/alpha/diveby3.asm: New file. 2004-11-10 Torbjorn Granlund * mpn/generic/popham.c: Add comment. 2004-11-05 Torbjorn Granlund * config.guess: Strip any PPC string in /proc/cpuinfo. Recognize 970 in that code. 2004-10-25 Torbjorn Granlund * mpn/powerpc64/README: Update POWER5/PPC970 pipeline information. * mpn/generic/mul_basecase.c (MAX_LEFT): Add comment. * doc/gmp.texi: Consistently use "x86" denotation. (Assembler SIMD Instructions): Mention SSE2 usage. * demos/pexpr.c (main): Handle "negative" base in mpz_sizeinbase call. 2004-10-16 Torbjorn Granlund * configure.in: Support icc under x86. (ia64-*-linux*): Pass -no-gcc to icc. 2004-10-15 Torbjorn Granlund * longlong.h (ia64 umul_ppmm): Add version for icc. * configure.in: Support icc under ia64-*-linux*. * acinclude.m4: New "compiler works" test for icc 8.1 bug. (GMP_PROG_CC_IS_GNU): Don't let Intel's icc fool us it is GCC. 2004-10-14 Torbjorn Granlund * acinclude.m4 (GMP_ASM_W32): Try also "data4". * longlong.h: Exclude masquerading __INTEL_COMPILER from ia64 asm. * gmp-impl.h: Likewise. 2004-10-12 Torbjorn Granlund * tests/devel/try.c: Handle mpn_mul_2 like mpn_addmul_2. * tune/speed.c (routine): Make R parameter optional for mpn_mul_2. 2004-10-11 Torbjorn Granlund * mpn/sparc64/addmul_1.asm: Update a comment. * tests/devel/aors_n.c: #include tests.h. * tests/devel/anymul_1.c: Likewise. * tests/devel/shift.c: Likewise. * tests/devel/copy.c: Likewise. * tests/devel/aors_n.c: Handle also mpn_addlsh1_n, mpn_sublsh1_n, mpn_rsh1add_n, and mpn_rsh1sub_n. * tests/devel/Makefile.am (EXTRA_PROGRAMS): Updates for yesterday's file removals and additions. 2004-10-10 Torbjorn Granlund * tests/devel/copy.c: Handle both MPN_COPY_INCR and MPN_COPY_DECR. * tests/devel/logops_n.c: New file, handle all logical operations. * tests/devel/anymul_1.c: New file, handle mpn_mul_1, mpn_addmul_1, and mpn_submul_1 * tests/devel/mul_1.c: Remove. * tests/devel/addmul_1.c: Remove. * tests/devel/submul_1.c: Remove. * tests/devel/shift.c: New file, handle mpn_lshift and mpn_rshift. * tests/devel/lshift.c: Remove. * tests/devel/rshift.c: Remove. * tests/devel/aors_n.c: New file, handle mpn_add_n and mpn_sub_n. * tests/devel/add_n.c: Remove. * tests/devel/sub_n.c: Remove. 2004-10-09 Torbjorn Granlund * mpn/powerpc64/linux64.m4: Define DEF_OBJECT, END_OBJECT, and TOCREF. * mpn/powerpc64/aix.m4: Likewise. 2004-10-08 Torbjorn Granlund * mpn/powerpc64/copyi.asm: New file. * mpn/powerpc64/copyd.asm: New file. * gmp-h.in: Remove PPC MPN_COPY variants. * gmp-impl.h: Likewise. 2004-10-07 Torbjorn Granlund * configfsf.guess: Patch HP-UX code to accomodate HP compiler's new inability to read from stdin. * mpn/powerpc64/mode64/addsub_n.asm: Remove accidentally added file. 2004-09-29 Torbjorn Granlund * gmp-impl.h (x86 ULONG_PARITY): Work around GCC change of "q" register flag. 2004-09-28 Paul Zimmermann * mpn/generic/mul_fft.c (mpn_mul_fft): Fix a bug in the choice of the recursive fft parameters. 2004-09-20 Torbjorn Granlund * tests/misc.c (tests_rand_start): Default to strtoul for re-seeding. * tests/mpz/t-mul.c (ref_mpn_mul): Fudge tmp allocation for toom3. 2004-09-19 Torbjorn Granlund * tests/misc.c (tests_rand_start): Shift tv_usec for better seeding. 2004-09-18 Torbjorn Granlund * tests/misc.c (tests_rand_start): Invoke fflush after printing seed. * tests/mpz/t-mul.c (main): Check environment for GMP_CHECK_FFT, run extra FFT tests if set. (ref_mpn_mul): Use library code for kara and toom, but skewded so that we never use the same algorithm that we're testing. (mul_kara): Delete. (debug_mp): Print just one line of large numbers. (ref_mpn_mul): Rework usage of tp temporary space. 2004-09-11 Torbjorn Granlund * mpn/generic/sqr_basecase.c: In variant for HAVE_NATIVE_mpn_addmul_2, accumulate carry also for when HAVE_NATIVE_mpn_addlsh1_n. 2004-08-29 Torbjorn Granlund * tests/mpz/t-sizeinbase.c: Disable mpz_fake_bits and check_sample. 2004-06-17 Kevin Ryde * doc/gmp.texi: Use @. when sentence ends with a capital, for good spacing in tex. (Language Bindings): Add gmp-d, reported by Ben Hinkle. Update SWI Prolog URL, reported by Jan Wielemaker. 2004-06-09 Torbjorn Granlund * configure.in: Handle --enable-fat. Use that to enable x86 fat builds, remove magic meaning of i386-*-*. 2004-06-03 Kevin Ryde * gmp-impl.h (memset): Use a local char* pointer, in case parameter is something else (eg. tune/common.c). Reported by Emmanuel Thomщ. 2004-06-01 Kevin Ryde * config.guess (i?86-*-*): Avoid "Illegal instruction" message which goes to stdout on 80386 freebsd4.9. 2004-05-23 Torbjorn Granlund * mpn/generic/gcdext.c (gcdext_1_odd): Use masking to avoid jumps. 2004-05-22 Torbjorn Granlund * mpn/x86/pentium4/sse2/addmul_1.asm: Add Prescott cycle numbers. * mpn/powerpc32/lshift.asm: Add more cycle numbers. * mpn/powerpc32/rshift.asm: Likewise. 2004-05-21 Torbjorn Granlund * gmp-impl.h (mpn_mullow_n, mpn_mullow_basecase): Declare. * tune/Makefile.am: Compile gcdext.c. * gmp-impl.h (GET_STR_THRESHOLD_LIMIT): Lower outrageous value to 150. 2004-05-21 Niels Mіller * tune/speed.h (SPEED_ROUTINE_MPN_GCD_CALL): Ensure first operand is not smaller than 2nd operand. 2004-05-17 Kevin Ryde * gmp-h.in (mpz_get_ui): Use #if instead of plain if, and for nails use ?: same as normal case, to avoid warnings from Borland C++ 6.0. Reported by delta trinity. 2004-05-15 Kevin Ryde * tune/time.c (getrusage_backwards_p): New function (speed_time_init): Use it to exclude broken netbsd1.4.1 getrusage. * configure.in (m68*-*-netbsd1.4*): Remove code pretending getrusage doesn't exist. * tune/README (NetBSD 1.4.1 m68k): Update notes. * configure.in (mips*-*-* ABI=n32): Remove gcc_n32_ldflags and cc_n32_ldflags, libtool knows to put the linker in n32 mode. 2004-05-15 Torbjorn Granlund * config.guess (powerpc*-*-*): Add more processor types to mfpvr code. * configure.in: Generalize powerpc subtype matching code. * mpz/fac_ui.c: Misc cleanups, spelling corrections. 2004-05-14 Kevin Ryde * mpf/sub.c: When one operand cancels high limbs of the other, strip high zeros on the balance before truncating to destination precision. Truncating first loses accuracy and can lead to a result 0 despite operands being not equal. Reported by John Abbott. Also, ensure exponent is zero when result is zero, for instance if operands are exactly equal. * tests/mpf/t-sub.c (check_data): New function, exercising these. 2004-05-12 Kevin Ryde * configure.in (AC_PROG_RANLIB): New macro, supposedly required by automake, though it doesn't complain. * demos/expr/Makefile.am (ARFLAGS): Add a default setting, to workaround an automake bug. 2004-05-10 Kevin Ryde * */Makefile.in, install-sh, aclocal.m4: Update to automake 1.8.4. * doc/gmp.texi (Demonstration Programs): Add a remark about expression evaluation in the main gmp library. * demos/expr/exprfa.c (mpf_expr_a): Correction to mpX_init, use mpf_init2 to follow requested precision. * demos/expr/exprza.c, demos/expr/exprqa.c: Use wrappers for mpX_init, to make parameters match. * demos/expr/run-expr.c: Don't use getopt, to avoid needing configury for optarg declaration. Remove TRY macro, rename foo and bar to var_a and var_b, for clarity. * demos/expr/expr-impl.h: Don't use expr-config.h. * configure.in (demos/expr/expr-config.h): Remove. * demos/expr/expr-config.in: Remove file. 2004-05-08 Kevin Ryde * doc/configuration (Configure): Update for current automake not copying acinclude.m4 into aclocal.m4. * configure.in, Makefile.am, doc/gmp.texi, doc/configuration, tests/cxx/Makefile.am, demos/expr/Makefile.am, demos/expr/README, demos/expr/expr.c, demos/expr/expr.h, demos/expr/expr-config-h.in, demos/expr/expr-impl.h, demos/expr/run-expr.c, demos/expr/t-expr.c: MPFR now published separately, remove various bits. * mpfr/*, tests/cxx/t-headfr.cc, demos/expr/exprfr.c, demos/expr/exprfra.c: Remove. 2004-05-07 Kevin Ryde * tests/cxx/Makefile.am (TESTS_ENVIRONMENT): Amend c++ shared library path hack, on k62-unknown-dragonfly1.0 /usr/bin/make runs its commands "set -e", so we need an "|| true" in case there's nothing to copy (for instance in a static build). 2004-05-06 Kevin Ryde * mpn/alpha/mode1o.c: Remove, in favour of ... * mpn/alpha/mode1o.asm: New file. * mpn/alpha/alpha-defs.m4 (bwx_available_p): New macro. * tune/amd64.asm: Save rbx in r10 rather than on the stack. * configure.in (x86_64-*-*): Try also "-march=k8 -mno-sse2", in case we're in ABI=32 on an old OS not supporting xmm regs. (GMP_GCC_PENTIUM4_SSE2, GMP_OS_X86_XMM): Run these tests under -march=k8 too, and not under ABI=64. * doc/gmp.texi (Converting Integers): For mpz_get_d, note truncation and overflows. For mpz_get_d_2exp note truncation, note result if OP==0, and cross reference libc frexp. (Rational Conversions): For mpq_get_d, note truncation and overflows. (Converting Floats): For mpf_get_d, note truncation and overflows. For mpf_get_d_2exp, note truncation, note result if OP==0. (Assembler Code Organisation): Note nails subdirectories. Clarification of get_d_2exp OP==0 reported by Sylvain Pion. 2004-05-05 Torbjorn Granlund * mpn/generic/mullow_n.c, mpn/generic/mullow_basecase.c: New files (mainly by Niels Mіller). * configure.in, mpn/Makefile.am: Add them. * gmp-impl.h (MULLOW_BASECASE_THRESHOLD, MULLOW_DC_THRESHOLD, MULLOW_MUL_N_THRESHOLD): Override for TUNE_PROGRAM_BUILD. * tune/Makefile.am: Compile mullow_n.c. * tune/common.c (speed_mpn_mullow_n, speed_mpn_mullow_basecase): New functions. * tune/speed.c (routine): Add entries for mpn_mullow_n and mpn_mullow_basecase. * tune/speed.h (SPEED_ROUTINE_MPN_MULLOW_N_CALL, SPEED_ROUTINE_MPN_MULLOW_BASECASE): New #defines. * tune/tuneup.c (tune_mullow): New function. * gmp-impl.h (invert_limb): Compute branch-freely. 2004-05-02 Kevin Ryde * mpn/amd64/mode1o.asm: Use movabsq to support large model non-PIC. Use 32-bit insns to save code bytes, and to save a couple of cycles on the initial setup multiplies. 2004-05-01 Kevin Ryde * doc/gmp.texi (References): Update gcc online docs url to gcc.gnu.org. * configure.in (mips*-*-irix[6789]*): Correction to m4 quoting of this pattern. (Believe the mips64*-*-* part also used picks up all current irix6 tuples anyway.) Reported by Rainer Orth. 2004-04-30 Kevin Ryde * acinclude.m4 (GMP_PROG_CC_X86_GOT_EAX_EMITTED, GMP_ASM_X86_GOT_EAX_OK): New macros. (GMP_PROG_CC_WORKS): Use them to detect an old gas bug tickled by recent gcc. Reported by David Newman. * doc/gmp.texi (Reentrancy): Note also gmp_randinit_default as an alternative to gmp_randinit. 2004-04-29 Torbjorn Granlund * configfsf.guess: Update to 2004-03-12. * configfsf.sub: Likewise. 2004-04-27 Torbjorn Granlund * mpz/rrandomb.c (gmp_rrandomb): Rework to avoid extra limb allocation and to generate even numbers. * mpn/generic/random2.c (gmp_rrandomb): Likewise. 2004-04-25 Kevin Ryde * gmp-impl.h (FORCE_DOUBLE): Don't use an asm with a match constraint on a memory output, apparently not supported and provokes a warning from gcc 3.4. 2004-04-24 Kevin Ryde * longlong.h (count_leading_zeros_gcc_clz, count_trailing_zeros_gcc_ctz): New macros. (count_leading_zeros, count_trailing_zeros) [x86]: Use them on gcc 3.4. * configure.in (x86-*-* gcc_cflags_cpu): Give a -mtune at the start of each option list, for use by gcc 3.4 to avoid deprecation warnings about -mcpu. * mpz/aorsmul.c, mpz/aorsmul_i.c, mpz/cfdiv_q_2exp.c, mpz/cfdiv_r_2exp.c, mpq/aors.c, mpf/ceilfloor.c: Give REGPARM_ATTR() on function definition too, as demanded by gcc 3.4. 2004-04-22 Kevin Ryde * tests/rand/t-lc2exp.c (check_bigc1): New test. * doc/fdl.texi: Tweak @appendixsubsec -> @appendixsec to match our preference for this in an @appendix, and because texi2pdf doesn't support @appendixsubsec directly within an @appendix. 2004-04-20 Kevin Ryde * doc/texinfo.tex: Update to 2004-04-07.08 from texinfo 4.7. * doc/gmp.texi, mpfr/mpfr.texi (@copying): Don't put a line break in @ref within @copying, recent texinfo.tex doesn't like that. * demos/perl/GMP.xs (static_functable): Treat cygwin the same as mingw DLLs. * */Makefile.in, install-sh: Update to automake 1.8.3. * ltmain.sh, aclocal.m4, configure: Update to libtool 1.5.6. * gmp-impl.h (LIMB_HIGHBIT_TO_MASK): Use a compile-time constant expression, rather than a configure test. * acinclude.m4, configure.in (GMP_C_RIGHT_SHIFT): Remove, no longer needed. * tests/t-hightomask.c: New file. * tests/Makefile.am (check_PROGRAMS): Add it. * macos/configure (parse_top_configure): Look for PACKAGE_NAME and PACKAGE_VERSION now used by autoconf. (what_objects): Only demand 9 object files, as for instance occurs in the scanf directory. (asm files): Transform labels L(foo) -> Lfoo. Take func name from PROLOGUE to support empty "EPILOGUE()". Recognise and subsitute register name "define()"s. * macos/Makefile.in (CmnObjs): Add tal-notreent.o. 2004-04-19 Torbjorn Granlund * tune/speed.h (SPEED_ROUTINE_MPN_ROOTREM): New #define. (speed_mpn_rootrem): Declare. * tune/common.c (speed_mpn_rootrem): New function. * tune/speed.c (routine): Add entry for mpn_rootrem. 2004-04-16 Kevin Ryde * doc/fdl.texi: Update from FSF, just fixing a couple of typos. * macos/configure, macos/Makefile.in: Add printf and scanf directories. * tests/mpz/t-gcd.c (check_data): New function, exercising K6 gcd_finda bug. 2004-04-14 Kevin Ryde * doc/gmp.texi (Reentrancy, Random State Initialization): Note gmp_randinit use of gmp_errno is not thread safe. Reported by Vincent Lefшvre. * doc/gmp.texi (Random State Initialization): Add index entries for gmp_errno and constants. * mpn/m68k/README: Update _SHORT_LIMB -> __GMP_SHORT_LIMB. * configure.in (--enable-mpbsd): Typo Berkley -> Berkeley in help msg. 2004-04-12 Kevin Ryde * demos/perl/GMP.xs (static_functable): New macro, use it for all function tables, to support mingw DLL builds. * demos/perl/INSTALL (NOTES FOR PARTICULAR SYSTEMS): Remove note on DLLs, should be ok now. * demos/perl/sample.pl: Print the module and library versions in use. * demos/perl/GMP.pm, Makefile.PL (VERSION): Set to '2.00'. * demos/perl/GMP.pm (COPYRIGHT): New in the doc section. * Makefile.am: Note 4.1.3 libtool versioning info, and REVISION policy. * tal-debug.c: Add for abort. 2004-04-07 Torbjorn Granlund * tests/refmpf.c (refmpf_add_ulp): Adjust exponent when needed. * mpn/generic/random2.c: Rewrite (clone mpz/rrandomb.c). 2004-04-07 Kevin Ryde * mpn/x86/k6/gcd_finda.asm: Correction jbe -> jb in initial setups. Zero flag is wrong here, it relects only the high limb of the compare, leading to n1>=n2 not satisfied and wrong results. cp[1]==0x7FFFFFFF with cp[0]>=0x80000001 provokes this. * doc/gmp.texi (BSD Compatible Functions): Note "pow" name clash under the pow function description too. (Language Bindings): Add XEmacs (betas at this stage). Reported by Jerry James. * tests/refmpn.c (refmpn_mod2): Correction to ASSERTs, r==a is allowed. * gen-psqr.c (generate_mod): Cast mpz_invert_ui_2exp args, for K&R. * gen-bases.c, gen-fib.c, gen-psqr.c: For mpz_out_str, use stdout instead of 0, in case a K&R treats int and FILE* params differently. 2004-04-04 Kevin Ryde * gmp-impl.h (BSWAP_LIMB) [amd64]: New macro. (FORCE_DOUBLE): Use this for amd64 too. * tests/amd64check.c, tests/amd64call.asm: New files, derived in part from x86check.c and x86call.asm. * tests/Makefile.am (EXTRA_libtests_la_SOURCES): Add them. * configure.in (x86_64-*-* ABI=64): Use them. 2004-04-03 Kevin Ryde * mpn/amd64/mode1o.asm: New file. * mpn/amd64/amd64-defs.m4 (ASSERT): New macro. * mpn/x86/k7/mmx/divrem_1.asm, mpn/x86/pentium4/sse2/divrem_1.asm: Add note on how "dr" part of algorithm is handled. * mpn/x86/k7/dive_1.asm, mpn/x86/k7/mod_34lsub1.asm, mpn/x86/k7/mode1o.asm: Note Hammer (32-bit mode) speeds. 2004-03-31 Kevin Ryde * doc/gmp.texi (Language Bindings): Add GOO, MLGMP and Numerix. * mpf/mul_2exp.c, mpf/div_2exp.c: Rate u==0 as UNLIKELY. 2004-03-27 Torbjorn Granlund * mpn/generic/divrem_1.c: Fix typo. * mpn/generic/sqr_basecase.c: Fix typo. 2004-03-20 Kevin Ryde * longlong.h (power, powerpc): Add comments on how we select this code. * gmp-h.in (mpz_get_ui): Use ?: instead of mask style, gcc treats the two identically but ?: is a bit clearer. * insert-dbl.c: Remove file, no longer used, scaling is now integrated in mpn_get_d. * Makefile.am (libgmp_la_SOURCES): Remove insert-dbl.c. * gmp-impl.h (__gmp_scale2): Remove prototype. 2004-03-17 Kevin Ryde * mpn/x86/fat/fat.c (__gmpn_cpuvec_init, fake_cpuid_table): Add x86_64. * mpq/get_d.c: Use mpn_tdiv_qr, demand den>0 per canonical form. 2004-03-16 Torbjorn Granlund * mpn/generic/sqr_basecase.c: Add versions using mpn_addmul_2 and mpn_addmul_2s. 2004-03-14 Kevin Ryde * mpf/mul_ui.c: Incorporate carry from low limbs, for exactness. * tests/mpf/t-mul_ui.c: New file. * tests/mpf/Makefile.am (check_PROGRAMS): Add it. * mpf/div.c: Use mpn_tdiv_qr. Use just one TMP_ALLOC. Use full divisor, since truncating can lose accuracy. * tests/mpf/t-div.c: New file. * tests/mpf/Makefile.am (check_PROGRAMS): Add it. * tests/mpf/t-set_q.c, tests/mpf/t-ui_div.c (check_various): Amend bogus 99/4 test. * tests/mpf/t-ui_div.c (check_rand): Exercise r==v overlap. * tests/refmpf.c, tests/tests.h (refmpf_set_overlap): New function. * mpf/cmp_si.c [nails]: Correction, cast vval in exp comparisons, for when vval=-0x800..00 and limb==longlong. * mpf/cmp_si.c [nails]: Correction, return usign instead of 1 when uexp==2 but value bigger than an mp_limb_t. * tests/mpf/t-cmp_si.c (check_data): Add test cases. * tests/trace.c (mpf_trace): Use ABS(mp_trace_base) to allow for negative bases used for upper case hex in integer traces. 2004-03-12 Torbjorn Granlund * mpn/generic/sb_divrem_mn.c: Correct header comment. 2004-03-11 Kevin Ryde * aclocal.m4, configure, ltmain.sh: Downgrade to libtool 1.5, version 1.5.2 doesn't remove .libs/*.a files when rebuilding, which is bad for development when changing contents or with duplicate named files like we have. Revert this, ie restore AR_FLAGS=cq: * acinclude.m4 (GMP_PROG_AR): Remove AR_FLAGS=cq, libtool 1.5.2 now does this itself on detecting duplicate object filenames in piecewise linking mode. * randbui.c, randmui.c [longlong+nails]: Correction to conditionals for second limb. * mpz/aors_ui.h, mpz/cdiv_q_ui.c, mpz/cdiv_qr_ui.c, mpz/cdiv_r_ui.c, mpz/cdiv_ui.c, mpz/fdiv_q_ui.c, mpz/fdiv_qr_ui.c, mpz/fdiv_r_ui.c, mpz/fdiv_ui.c, mpz/gcd_ui.c, mpz/iset_ui.c, mpz/lcm_ui.c, mpz/set_ui.c, mpz/tdiv_q_ui.c, mpz/tdiv_qr_ui.c, mpz/tdiv_r_ui.c, mpz/tdiv_ui.c, mpz/ui_sub.c, mpf/div_ui.c, mpf/mul_ui.c [longlong+nails]: Amend #if to avoid warnings about shift amount. 2004-03-07 Kevin Ryde * mpf/reldiff.c: Use rprec+ysize limbs for d, to ensure accurate result. Inline mpf_abs(d,d) and mpf_cmp_ui(x,0), and rate the latter UNLIKELY. * mpf/ui_div.c: Use mpn_tdiv_qr. Use just one TMP_ALLOC. Use full divisor, since truncating can lose accuracy. * tests/mpf/t-ui_div.c: New file. * tests/mpf/Makefile.am (check_PROGRAMS): Add it. * mpf/set_q.c: Expand TMP_ALLOC_LIMBS_2, to make conditional clearer and avoid 1 limb alloc when not wanted. * gmp-impl.h (WANT_TMP_DEBUG): Define to 0 if not defined. (TMP_ALLOC_LIMBS_2): Use "if" within macro rather than "#if", for less preprocessor conditionals. * mpf/mul_2exp.c, mpf/div_2exp.c: Add some comments. * tests/refmpn.c (refmpn_sb_divrem_mn, refmpn_tdiv_qr): Nailify. 2004-03-04 Kevin Ryde * gen-psqr.c (print): Add CNST_LIMB in PERFSQR_MOD_TEST, for benefit of K&R. * tests/mpn/t-perfsqr.c (PERFSQR_MOD_1): Use CNST_LIMB for K&R. * doc/configuration (Configure): Remove mkinstalldirs, no longer used. * acinclude.m4 (GMP_PROG_AR): Remove AR_FLAGS=cq, libtool 1.5.2 now does this itself on detecting duplicate object filenames in piecewise linking mode. * configure.in (hppa2.0*-*-*): Test sizeof(long) == 4 or 8 to verify ABI=2.0n versus ABI=2.0w. In particular this lets CC=cc_bundled correctly fall back to ABI=2.0n (we don't automatically add CC=+DD64 to that compiler, currently). * doc/gmp.texi (Reentrancy): Note C++ mpf_class constructors using global default precision. (Random State Miscellaneous): Describe gmp_urandomb_ui as giving N bits. (C++ Interface Floats): Describe operator= copying the value, not the precision, and what this can mean about copy constructor versus default constructor plus assignment. * mpf/set_q.c: Use mpn_tdiv_qr rather than mpn_divrem, so no shifting. Don't truncate the divisor, it can make the result inaccurate. * tests/mpf/t-set_q.c: New file. * tests/mpf/Makefile.am (check_PROGRAMS): Add it. * mpf/set.c: Use MPN_COPY_INCR, in case r==u and ABSIZ(u) > PREC(r)+1. No actual bug here, because MPN_COPY has thusfar been an alias for MPN_COPY_INCR, only an ASSERT failure. * tests/mpf/t-set.c: New file. * tests/mpf/Makefile.am (check_PROGRAMS): Add it. * mpf/set.c, mpf/iset.c: Do MPN_COPY last, for possible tail call. * mpf/set_d.c: Rate d==0 as UNLIKELY. Store size before extract call, to shorten lifespan of "negative". * mpf/init.c, mpf/init2.c, mpf/iset_d.c, mpf/iset_si.c, mpf/iset_str.c, mpf/iset_ui.c: Store prec before alloc call, for one less live quantity across that call. * mpf/init.c, mpf/init2.c, mpf/iset_str.c: Store size and exp before alloc call, to overlap with other operations. * tests/refmpf.c, tests/tests.h (refmpf_fill, refmpf_normalize, refmpf_validate, refmpf_validate_division): New functions. * tests/refmpn.c, tests/tests.h (refmpn_copy_extend, refmpn_lshift_or_copy_any, refmpn_rshift_or_copy_any): New functions. * tal-debug.c: Add for strcmp. * tests/cxx/t-istream.cc (check_mpz, check_mpq, check_mpf): Use size_t for loop index, to quieten g++ warning. 2004-03-01 Torbjorn Granlund With Karl Hasselstrіm: * mpn/generic/dc_divrem_n.c (mpn_dc_div_2_by_1): New function, with meat from old mpn_dc_divrem_n. Accept scratch parameter. Rewrite to avoid a recursive call. (mpn_dc_div_3_by_2): New function, with meat from old mpn_dc_div_3_halves_by_2. Accept scratch parameter. (mpn_dc_divrem_n): Now just allocate scratch space and call new mpn_dc_div_2_by_1. 2004-02-29 Kevin Ryde * longlong.h (count_leading_zeros) [alpha gcc]: New version, inlining mpn/alpha/cntlz.asm cmpbge technique. * aclocal.m4, configure, install-sh, missing, ltmain.sh, */Makefile.in: Update to automake 1.8.2 and libtool 1.5.2. * doc/gmp.texi (C++ Interface Integers): Note / and % rounding follows C99 / and %. (Exact Remainder): Index entries for divisibility testing algorithm. * tune/time.c (speed_endtime): Return 0.0 for negative time measured. Revise usage comments for clarity. * tune/common.c (speed_measure): Recognise speed_endtime 0.0 for failed measurement. * tests/mpn/t-get_d.c (check_rand): Correction to nhigh_mask setup. 2004-02-27 Torbjorn Granlund * tune/tuneup.c (tune_dc, tune_set_str): Up param.step_factor. * tests/mpz/t-gcd.c: Decrease # of tests to 50. 2004-02-27 Kevin Ryde * tests/devel/try.c: Add a comment that this is not for Cray systems. * mpf/set_q.c: Don't support den(q)<0, demand canonical form in the usual way. 2004-02-24 Torbjorn Granlund From Kevin: * mpn/generic/mul_fft.c (mpn_fft_add_modF): Loop until normalization criterion met. 2004-02-22 Kevin Ryde * acinclude.m4 (GMP_PROG_CC_WORKS, GMP_OS_X86_XMM, GMP_PROG_CXX_WORKS): Remove files that might look like compiler output, so our "||" alternatives are not fooled. * acinclude.m4 (GMP_PROG_CC_WORKS): Add test for lshift_com code mis-compiled by certain IA-64 HP cc at +O3. * gmp-impl.h (USE_LEADING_REGPARM): Disable under prof or gprof, for the benefit of freebsd where .mcount clobbers registers. Spotted by Torbjorn. * configure.in (WANT_PROFILING_PROF, WANT_PROFILING_GPROF): New AC_DEFINEs. 2004-02-21 Kevin Ryde * configure.in (sparc64-*-*bsd*): Amend -m32 setup for ABI=32, so it's not used in ABI=64 on the BSD systems. 2004-02-18 Niels Mіller * tests/mpz/t-gcd.c (gcdext_valid_p): New function. (ref_mpz_gcd): Deleted function. (one_test): Rearranged to call mpz_gcdext first, so that the returned value can be validated. (main): Don't use ref_mpz_gcd. 2004-02-18 Torbjorn Granlund * gmp-impl.h (MPN_TOOM3_MAX_N): Move to !WANT_FFT section. * tests/mpz/t-mul.c: Exclude special huge operands unless WANT_FFT. * mpz/rrandomb.c (gmp_rrandomb): Rewrite. * mpn/generic/mul_n.c (mpn_toom3_sqr_n): Remove write-only variable c5. 2004-02-18 Kevin Ryde * mpf/iset_si.c, mpf/iset_ui.c, mpf/set_si.c, mpf/set_ui.c [nails]: Always store second limb, to avoid a conditional. * tests/mpf/t-get_ui.c: New file. * tests/mpf/Makefile.am (check_PROGRAMS): Add it. * tests/mpf/t-get_si.c (check_limbdata): Further tests. * gmp-impl.h (MP_EXP_T_MAX, MP_EXP_T_MIN): New defines. * mpf/get_ui.c, mpf/get_si.c: Remove size==0 test, it's covered by other conditions. Attempt greater clarity by expressing conditions as based on available data range. * mpf/get_si.c [nails]: Correction, don't bail on exp > abs_size, since may still have second limb above radix point available. * mpf/get_ui.c: Nailify. 2004-02-16 Kevin Ryde * mpz/scan0.c, mpz/scan1.c: Use count_trailing_zeros, instead of count_leading_zeros on limb&-limb. * mpf/sqrt.c: Use "/ 2" for exp, avoiding C undefined behaviour on ">>" of negatives. Correction to comment, exp is rounded upwards. SIZ(r) always prec now, no need for tsize expression. Store EXP(r) and SIZ(r) where calculated to reduce variable lifespans. Make tsize mp_size_t not mp_exp_t, though of course those are currently the same. * gmp-h.in (GMP_ERROR_ALLOCATE, GMP_ERROR_BAD_STRING, GMP_ERROR_UNUSED_ERROR): Remove, never used or documented, and we don't want to use globals for communicating error information. * mpz/gcd_ui.c [nails]: Correction, actually return a value. * mpn/generic/addmul_1.c, mpn/generic/submul_1.c [nails==1]: Add code. 2004-02-15 Kevin Ryde * tests/mpz/t-jac.c (check_data): Remove unnecessary variable "answer". 2004-02-14 Kevin Ryde * acinclude.m4 (GMP_C_RIGHT_SHIFT): Note that it's "long"s which we're concerned about. * mpn/generic/mul_n.c: Add some remarks about toom3 high zero stripping. * mpn/generic/scan0.c, mpn/generic/scan1.c: Remove design issue remarks. What to do about going outside `up' space is a problem, but anything to address it would be an incompatible change. 2004-02-11 Kevin Ryde * longlong.h (power, powerpc): Use HAVE_HOST_CPU_FAMILY_power and HAVE_HOST_CPU_FAMILY_powerpc rather than various cpp defines. * gmp-impl.h: Add remarks about limits.h and Cray etc. * dumbmp.c (mpz_mul): Set ALLOC(r) for new data block used. Reported by Jason Moxham. * mpn/pa32/README, mpn/pa64/README (REFERENCES): New sections. 2004-02-10 Torbjorn Granlund * tests/mpz/t-gcd.c: Decrease # of tests run. * mpn/*/gmp-mparam.h: Add HGCD values, update TOOM values. 2004-02-01 Torbjorn Granlund From Kevin: * config.guess: Recognize AMD's hammer processors, return x86_64. 2004-01-24 Kevin Ryde * tests/mpf/t-sqrt.c (check_rand1): Further diagnostic printouts. * mpn/generic/sqrtrem.c (mpn_sqrtrem): Add ASSERT_MPN. (mpn_dc_sqrtrem): Add casts for K&R. * mpf/sqrt_ui.c: Nailify. * mpf/set_z.c: Do MPN_COPY last, for possible tail call. * doc/gmp.texi (Miscellaneous Float Functions): For mpf_random2, note exponent is in limbs. 2004-01-22 Kevin Ryde * mpf/sqrt.c: Change tsize calculation to get prec limbs result always, previously got prec+1 when exp was odd. * tests/mpf/t-sqrt.c (check_rand1): New function, code from main. (check_rand2): New function. * mpf/sqrt_ui.c: Change rsize calculation to get prec limbs result, previously got prec+1. * tests/mpf/t-sqrt_ui.c: New file. * tests/mpf/Makefile.am (check_PROGRAMS): Add it. * tests/refmpf.c, tests/tests.h (refmpf_add_ulp, refmpf_set_prec_limbs): New functions. * mpz/get_d_2exp.c, mpf/get_d_2exp.c: Remove x86+m68k force to double, mpn_get_d now does this. Remove res==1.0 check for round upwards, mpn_get_d now rounds towards zero. Move exp store to make mpn_get_d a tail call. * configure.in (x86-*-*): Use ABI=32 rather than ABI=standard. Use gcc -m32 when available, to force mode on bi-arch amd64 gcc. * configure.in, acinclude.m4 (x86_64-*-*): Merge into plain x86 setups as ABI=64. Support ABI=32, using athlon code. Use gcc -mcpu=k8, -march=k8. (amd64-*-*): Remove pattern, config.sub only gives x86_64. * doc/gmp.texi (ABI and ISA): Add x86_64 dual ABIs. * mpn/amd64/README: Add reference to ABI spec. 2004-01-17 Kevin Ryde * tune/README: Remove open/mpn versions of toom3, no longer exist. * tune/powerpc64.asm: Remove unused L(again). * tune/time.c (mftb): Note single mftb possible for powerpc64. * mpn/generic/mode1o.c: Use "c * configure.in (powerpc64-*-linux*): Try gcc64. Try -m64 with "cflags_maybe" to get it used in all probing. Add sizeof-long-8 test to check the mode is right if -m64 is not applicable. 2004-01-15 Kevin Ryde * configure.in (--with-readline=detect): Check for readline/readline.h and readline/history.h. Report result of detection. 2004-01-12 Niels Mіller * tests/tests.h: Added refmpn_free_limbs prototype. * tests/refmpn.c (refmpn_free_limbs): New function. 2004-01-11 Kevin Ryde * mpn/alpha/ev6/slot.pl: New file, derived in part from mpn/x86/k6/cross.pl. * mpn/alpha/alpha-defs.m4 (ASSERT): New macro. * mpn/asm-defs.m4 (m4_ifdef): New macro, avoiding OSF 4.0 m4 bug. (m4_assert_defined): Use it. * mpn/alpha/default.m4, mpn/alpha/unicos.m4 (LDGP): New macro. * mpn/alpha/ev67/gcd_1.asm: Use it to re-establish gp after jsr. * configure.in, demos/calc/Makefile.am: Use -lcurses or -lncurses with readline, when available. * longlong.h (sub_ddmmss) [generic]: Use alal, since the former can be done without waiting for __x, helping superscalar chips, in particular alpha ev5 and ev6. * longlong.h (sub_ddmmss) [ia64]: New macro. * tests/t-sub.c: New file. * tests/Makefile.am (check_PROGRAMS): Add it. * tests/refmpn.c, tests/tests.h (refmpn_sub_ddmmss): New function. 2004-01-09 Kevin Ryde * mpn/x86/p6/mod_34lsub1.asm: New file, derived in part from mpn/x86/mod_34lsub1.asm. * configure.in (IA64_PATTERN): Use -mtune on gcc 3.4. 2004-01-07 Kevin Ryde * gmp-h.in, mp-h.in (__GMP_SHORT_LIMB): Renamed from _SHORT_LIMB, to keep in our namespace. (Not actually used anywhere currently.) Reported by Patrick Pelissier. * mp-h.in: Use "! defined (__GMP_WITHIN_CONFIGURE)" in the same style as gmp-h.in (though mp-h.in is not actually used during configure). * mp-h.in (__GMP_DECLSPEC_EXPORT, __GMP_DECLSPEC_IMPORT) [__GNUC__]: Use __dllexport__ and __dllimport__ to keep out of application namespace. Same previously done in gmp-h.in. 2004-01-06 Kevin Ryde * configfsf.sub, configfsf.guess: Update to 2004-01-05. * configure.in (amd64-*-* | x86_64-*-*): Update comments on what configfsf.sub does. 2004-01-04 Kevin Ryde * mpn/alpha/README (REFERENCES): Add tru64 assembly manuals. (ASSEMBLY RULES): Note what gcc says about !literal! etc. 2004-01-03 Kevin Ryde * mpn/alpha/ev67/gcd_1.asm: New file. * mpn/x86/pentium4/sse2/rsh1add_n.asm: New file, derived in part from mpn/x86/pentium4/sse2/addlsh1_n.asm. * mpn/x86/p6/p3mmx/popham.asm: Note measured speeds. * mpn/x86/pentium4/sse2/addlsh1_n.asm (PARAM_CARRY): Remove macro, not used, no such parameter. * mpn/generic/gcd.c: Use for NULL. * doc/gmp.texi (Single Limb Division): Correction to tex expression for (1/2)x1. And minor wording tweaks elsewhere. * gmp-impl.h (mpn_rsh1add_n, mpn_rsh1sub_n): Correction to comments about how carries returned. * longlong.h (umul_ppmm) [generic]: Add comments about squaring (dropped from tasks list) 2003-12-31 Kevin Ryde * demos/perl/GMP.xs (scan0, scan1): Return ~0 for not-found. * demos/perl/GMP.pm: Describe this, remove the note about ULONG_MAX being the same as ~0 (which is not true in old perl). * demos/perl/test.pl: Update tests. * demos/perl/typemap (gmp_UV): New type. * demos/perl/test.pl (fits_slong_p): Comment out uv_max test, it won't necessarily exceed a long. * demos/perl/GMP.pm: Add a remark about get_str to the bugs section. * mpn/generic/sqrtrem.c, mpz/fac_ui.c, tests/mpf/reuse.c: Add casts for K&R. * tests/mpf/t-muldiv.c: Make ulimb, vlimb into ulongs, which is how they're used, for the benefit of K&R calling. * doc/gmp.texi (Square Root Algorithm): Add a summary of the algorithm. And add further index entries in various places. * mpz/lucnum_ui.c, mpz/lucnum2_ui.c: Use mpn_addlsh1_n when available. * gmp-impl.h, mpn/generic/mul_n.c (mpn_addlsh1_n, mpn_sublsh1_n, mpn_rsh1add_n, mpn_rsh1sub_n): Move descriptions to gmp-impl.h with the prototypes, for ease of locating. 2003-12-29 Torbjorn Granlund * tests/mpz/t-gcd.c: Rewrite, based on suggestions by Kevin. * mpn/sparc64/README: Remove mpn_Xmul_2, done. Add blurb about L1 cache conflicts. 2003-12-29 Kevin Ryde * mpn/generic/mul_fft.c, mpz/root.c, mpq/cmp_ui.c: Add casts for K&R. 2003-12-27 Kevin Ryde * tests/mpz/t-mul.c (mul_kara, mul_basecase): Use __GMP_PROTO. * Makefile.am (AUTOMAKE_OPTIONS): Restore this, giving no directory on ansi2knr to avoid a circular build rule. * configure.in (AM_INIT_AUTOMAKE): Note options also in Makefile.am. * configure.in (cflags_maybe): Don't loop adding cflags_maybe if the user has set CFLAGS. 2003-12-23 Kevin Ryde * configure.in (*sparc*-*-*): Test sizeof(long)==4 or 8 for ABIs, to get the right mode when the user sets the CFLAGS. (testlist): Introduce "any__testlist" to apply to all compilers. * demos/perl/typemap (MPZ_ASSUME, MPQ_ASSUME, MPF_ASSUME): Remove output rules, these are only meant for inputs. (MPZ_MUTATE): Remove, not used since changes for magic. * demos/perl/GMP.xs (mpz_class_hv, mpq_class_hv, mpf_class_hv): New variables, initialized in BOOT. * demos/perl/GMP.xs, demos/perl/typemap: Use them and explicit sv_bless, to save a gv_stashpv for every new object. 2003-12-22 Kevin Ryde * mpn/alpha/mode1o.c, mpn/alpha/dive_1.c: Moved from ev5/mode1o.c and ev5/dive_1.c, these are good for ev4, and would like them in a generic alpha build. 2003-12-21 Kevin Ryde * doc/gmp.texi (Integer Logic and Bit Fiddling): Say "bitwise" in mpz_and, mpz_ior and mpz_xor, to avoid any confusion with what C means by "logical". Reported by Rќdiger Schќtz. * gmp-h.in (_GMP_H_HAVE_FILE): Note why defined(EOF) is not good. 2003-12-20 Kevin Ryde * tune/speed.h (SPEED_TMP_ALLOC_LIMBS): Correction to last change, don't want "- 1" on the TMP_ALLOC_LIMBS. * demos/expr/expr.h: Test #ifdef MPFR_VERSION_MAJOR for when mpfr.h is included, not GMP_RNDZ which is now an enum. * demos/expr/exprfra.c (e_mpfr_ulong_p): Use mpfr_integer_p and mpfr_fits_ulong_p. (e_mpfr_get_ui_fits): Use mpfr_get_ui. * mpfr/*: Update to mpfr cvs head 2003-12-20. * configure, config.in: Update to autoconf 2.59. * */Makefile.in, configure, aclocal.m4, ansi2knr.c, install-sh, doc/mdate-sh: Update to automake 1.8. * mkinstalldirs: Remove, not required by automake 1.8. * doc/gmp.texi (Build Options): HTML is a usual target in automake 1.8. * configure.in (AC_PREREQ): Require autoconf 2.59. (AM_INIT_AUTOMAKE): Require automake 1.8. (AC_C_INLINE): Use rather than GMP_C_INLINE, now has #ifndef __cplusplus we want. (gettimeofday): Use AC_CHECK_FUNCS rather than our workaround code, autoconf now ok. * acinclude.m4 (GMP_C_INLINE): Remove. (GMP_H_EXTERN_INLINE): Use AC_C_INLINE. (GMP_PROG_AR): Comment on automake $ARFLAGS. 2003-12-19 Torbjorn Granlund * tests/mpf/t-get_d.c: Print message before aborting. * mpn/generic/get_d.c: Make ONE_LIMB case actually work for nails. 2003-12-18 Torbjorn Granlund * mpz/get_d.c: Don't include longlong.h. * tests/mpz/t-mul.c (ref_mpn_mul): Handle un == vn specially, to avoid a dummy r/w outside of allocated area. 2003-12-18 Kevin Ryde * mpn/alpha/unicos.m4 (ALIGN): Add comments on what GCC does. * configure.in (fat setups), acinclude.m4 (GMP_INIT): Obscure include() from automake 1.8 aclocal. * acinclude.m4: Quote names in AC_DEFUN, for automake 1.8 aclocal. 2003-12-13 Kevin Ryde * mpq/get_d.c: Amend comments per mpn_get_d change. (limb2dbl): Remove, no longer used. * gmp-impl.h (DIVREM_1_NORM_THRESHOLD etc) [nails]: Correction to comments, MP_SIZE_T_MAX means preinv never. * gmp-impl.h (DIVEXACT_1_THRESHOLD, MODEXACT_1_ODD_THRESHOLD) [nails]: Remove overrides, divexact_1 and modexact_1 have been nailified. * mpz/inp_str.c (mpz_inp_str_nowhite): Use ASSERT_ALWAYS for EOF value requirement. * tests/refmpn.c (refmpn_rsh1add_n, refmpn_rsh1sub_n): Parens around GMP_NUMB_BITS - 1 with ">>", to quieten gcc -Wall. * tests/t-constants.c (main), tests/t-count_zeros.c (check_clz), tests/t-modlinv.c (one), tests/mpz/t-jac.c (try_si_zi), tests/mpq/t-get_d.c (check_onebit): : Correction to printfs. * tests/mpn/t-fat.c: Add for memcpy. * tests/mpz/t-scan.c (check_ref): Remove unused variable "isigned". * tests/mpq/t-get_d.c (check_onebit): Remove unused variable "limit". * tests/mpf/t-set_si.c, tests/mpf/t-set_ui.c (check_data): Braces for initializers. * tests/devel/try.c (mpn_divexact_by3_fun, mpn_modexact_1_odd_fun): Correction to return values. * doc/gmp.texi (Miscellaneous Integer Functions): Note mpz_sizeinbase can be used to locate the most significant bit. Reword a bit for clarity. 2003-12-11 Torbjorn Granlund * gmp-impl.h: Change asm => __asm__, tabify. * mpz/get_d_2exp.c: Likewise. * mpf/get_d_2exp.c: Likewise. * tests/cxx/t-ops.cc: #if .. #endif out tests that cause ambiguities. 2003-12-10 Torbjorn Granlund * tests/mpz/t-gcd.c: Generate operands with sizes as a geometric progression, to allow for larger operands and less varying timing. 2003-12-10 Kevin Ryde * demos/perl/test.pl: Should be $] for perl version in old perl. * configure.in (sparc64-*-*): Single block of gcc configs for all systems, on unknown systems try both ABI 32 and 64. * configure.in (LIBGMP_LDFLAGS, LIBGMPXX_LDFLAGS): New AC_SUBSTs with options to generate .def files with windows DLLs. * Makefile.am (libgmp_la_LDFLAGS, libgmpxx_la_LDFLAGS): Use them. * mpn/generic/gcd.c: Use ABOVE_THRESHOLD / BELOW_THRESHOLD, to follow convention and cooperate with tune/tuneup.c. * tune/common.c, tune/speed.c, tune/speed.h, tune/speed-ext.c, tune/tuneup.c (SPEED_TMP_ALLOC_LIMBS): Take variable as parameter rather than returning a value, avoids alloca in a function call. * tune/common.c, tune/speed.h (speed_tmp_alloc_adjust): Remove, now inline in SPEED_TMP_ALLOC_LIMBS, and using ptr-NULL for alignment extraction. * gmpxx.h (__gmp_binary_equal, __gmp_binary_not_equal, __gmp_binary_less, __gmp_binary_less_equal, __gmp_binary_greater, __gmp_binary_greater_equal, __gmp_cmp_function): Use mpfr_cmp_si and mpfr_cmp_d. * tests/cxx/t-ops.cc: Exercise this. * demos/perl/Makefile.PL: Don't install sample.pl and test2.pl. * demos/perl/GMP.xs (use_sv): Prefer PV over IV or NV to avoid any rounding. * demos/perl/test.pl: Exercise this. * demos/perl/GMP/Mpf.pm (overload_string): Corrections to $# usage. * demos/perl/test.pl: Exercise this. 2003-12-08 Kevin Ryde * demos/perl/GMP.pm: Correction to canonicalize example. * demos/perl/GMP.xs: New type check scheme, support magic scalars, support UV when available. Remove some unused local variables. (coerce_long): Check range of double. (get_d_2exp): Remove stray printf. * demos/perl/test.pl: Exercise magic, rearrange to make it clearer what's being tested. 2003-12-07 Kevin Ryde * tune/tuneup.c (mul_toom3_threshold): Use MUL_TOOM3_THRESHOLD_LIMIT, for the benefit of ASSERT in mpn_mul_n. * tune/tuneup.c (tune_mul): Correction to toom3 param.min_size, should use MPN_TOOM3_MUL_N_MINSIZE. * tune/speed.c (check_align_option): Correction to printf format. * tune/freq.c (freq_sysctl_hw_model): Remove unused "i" variable. * scanf/doscan.c: Correction to a couple of trace printfs. Add for strtol. * tests/misc/t-scanf.c (test_sscanf_eof_ok): New function. (check_misc): Use it to suppress tests broken by libc. And should be EOF rather than -1 in various places. 2003-12-06 Torbjorn Granlund * mpn/generic/get_str.c (mpn_get_str, POW2_P case): Don't append extra '\0' byte. 2003-12-05 Niels Mіller * tune/speed.h (mpn_gcd_accel): Added prototype. 2003-12-05 Torbjorn Granlund * randmt.c (__gmp_mt_recalc_buffer): Put parens around "&" expressions inside "!=". * mpf/get_str.c: Remove unused variable "fracn". 2003-12-03 Kevin Ryde * configure.in, Makefile.am (LIBGMP_LDFLAGS, LIBGMPXX_LDFLAGS): New AC_SUBSTs, use them to create .def files with Windows DLLs. * doc/gmp.texi (Notes for Particular Systems): Update notes on mingw DLL with MS C. * mpz/export.c: Allow NULL for countp. * doc/gmp.texi (Integer Import and Export): Describe this. Suggested by Jack Lloyd. * mpn/x86/p6/aors_n.asm: New file, grabbing the K7 code. Superiority of this reported by Patrick Pelissier. 2003-11-30 Kevin Ryde * mpn/alpha/ev67/popcount.asm, mpn/alpha/ev67/hamdist.asm: New files. * mpn/alpha/ev67: New directory. * configure.in (alphaev67, alphaev68, alphaev7*): Use it. * doc/gmp.texi (GMPrefu, GMPpxrefu): Change back to plain ref and pxref, remove macros. (GMPreftopu, GMPpxreftopu): Remove URL parameter, rename to GMPreftop and GMPpxreftop. (Debugging): Remove debauch, seems to have disappeared. (Language Bindings): Corrections to URLs for CLN, Omni F77, Pike. 2003-11-29 Kevin Ryde * demos/perl/GMP/Mpf.pm (overload_string): Use $OFMT to avoid warnings about $#. * demos/perl/GMP.xs (fits_slong_p): Use LONG_MAX+1 to avoid possible rounding of 0x7F..FF in a double on 64-bit systems. * configure.in (ppc601-*-*): Remove this case, it never matched anything, the name adopted is powerpc601. (powerpc601-*-*): Use gcc -mcpu=601, xlc -qarch=601. * configure.in: Introduce ${cc}_cflags_maybe, used if they work. (*sparc*-*-*) [ABI=32]: Add gcc_cflags_maybe=-m32 to force that mode. * doc/gmp.texi (Introduction to GMP): Add AMD64 to optimizations list. (Build Options): Add cpu types alphaev7 and amd64. Update texinfo html cross reference. 2003-11-28 Niels Mіller * mpn/generic/gcd.c (MPN_LEQ_P): Copied macro definition (needed for compilation with --enable-assert). 2003-11-27 Niels Mіller * tests/mpz/t-gcd.c (gcd_values): Moved definition, so that we don't need to forward declare the array. 2003-11-26 Torbjorn Granlund * tests/mpz/t-gcd.c: Generate random operands up to 32767 bits; decrease # of test to 1000. (gcd_values): Remove oversize test case. 2003-11-26 Niels Mіller * tests/mpz/t-gcd.c (main): Added some tests with non-random input. 2003-11-25 Niels Mіller * gmp-impl.h (MPN_LEQ_P, MPN_EXTRACT_LIMB): New macros. 2003-11-25 Kevin Ryde * doc/gmp.texi (Language Bindings): Add Axiom. 2003-11-22 Kevin Ryde * mpn/alpha/README: More notes on assembler syntax variations. * mpn/alpha/alpha-defs.m4, mpn/alpha/unicos.m4 (unop): Should be ldq_u not bis, and move to alpha-defs.m4 since it can be happily used everywhere. * mpn/alpha/alpha-defs.m4, mpn/alpha/default.m4, mpn/alpha/unicos.m4 (bigend): Move to alpha-defs.m4 and base it on HAVE_LIMB_BIG_ENDIAN or HAVE_LIMB_LITTLE_ENDIAN, so as not to hard code system endianness. * mpn/alpha/alpha-defs.m4: New file. * configure.in (alpha*-*-*): Use it. 2003-11-21 Kevin Ryde * mpfr/*: Update to mpfr-2-0-2-branch 2003-11-21. * mpn/alpha/ev5/com_n.asm: Change "not" to "ornot r31", since "not" isn't recognised by on Cray Unicos. Add missing "gp" to PROLOGUE. * mpn/alpha/README: Add a note on "not". 2003-11-19 Torbjorn Granlund * mpn/alpha/aorslsh1_n.asm: Slightly rework feed-in code, avoiding spurious reads beyond operand limits. * mpn/alpha/ev5/com_n.asm: Add ASM_START/ASM_END. * mpn/generic/mul_fft.c (mpn_fft_zero_p): Remove unused function. (mpn_lshift_com): Make static, nailify properly. 2003-11-19 Kevin Ryde * mpn/generic/diveby3.c: Use a "q" variable to make it clearer what the code is doing. * mpn/powerpc32/750/lshift.asm, mpn/powerpc32/750/rshift.asm: New files. * mpn/alpha/ev5/com_n.asm: New file. * doc/gmp.texi (Assembler Functional Units, Assembler Writing Guide): New sections by Torbjorn, tweaked by me. 2003-11-17 Torbjorn Granlund * mpn/powerpc32: Add power4/powerpc970 cycle counts. Use cmpwi instead of cmpi to placate darwin. 2003-11-15 Kevin Ryde * config.guess: Add comments on MacOS "machine" command. * tests/devel/try.c (main): Use gmp_randinit_default explicitly on __gmp_rands, since RANDS doesn't allow seeding. * doc/gmp.texi (Assigning Integers): Remove notes on possible change to disallow whitespace, this would be an incompatible change and really can't be made. (Toom 3-Way Multiplication): Updates for Paul's new code. * mpn/generic/mul_n.c (toom3_interpolate, mpn_toom3_mul_n): Put if/else braces around whole of #if code, for readability. * tests/refmpn.c (refmpn_addlsh1_n, refmpn_sublsh1_n, refmpn_rsh1add_n, refmpn_rsh1sub_n): Add ASSERTs for operand overlaps etc. * mpfr/*: Update to mpfr-2-0-2-branch 2003-11-15. 2003-11-14 Torbjorn Granlund * mpn/alpha/aorslsh1_n.asm: Use Cray-friendly syntax for "br". 2003-11-13 Torbjorn Granlund * mpn/alpha/aorslsh1_n.asm: New file. 2003-11-12 Kevin Ryde * acinclude.m4 (GMP_PROG_CC_WORKS): Add case provoking AIX power2 assembler, test code by Torbjorn. * configure.in (power*-*-*): Add a comment about -mcpu=rios2 fallback. * tune/speed.c (main): Use gmp_randinit_default explicitly on __gmp_rands, since RANDS doesn't allow seeding. * mpfr/*: Update to mpfr-2-0-2-branch 2003-11-12. * gmp-impl.h, randmt.h (__gmp_randinit_mt_noseed): Move prototype to gmp-impl.h, for use by RANDS. * mpn/Makeasm.am (.s, .S, .asm): Quote $< in test -f, per automake. (.obj): Use test -f and $(CYGPATH_W) as per automake. 2003-11-11 Kevin Ryde * configure.in: Make umul and udiv standard-optional objects, rather than under various extra_functions. * mpn/pa32/hppa1_1/pa7100/add_n.asm, mpn/pa32/hppa1_1/pa7100/addmul_1.asm, mpn/pa32/hppa1_1/pa7100/lshift.asm, mpn/pa32/hppa1_1/pa7100/rshift.asm, mpn/pa32/hppa1_1/pa7100/sub_n.asm, mpn/pa32/hppa1_1/pa7100/submul_1.asm: Use LDEF for labels. * mpf/set_str.c: Don't use memcmp for decimal point testing, just a loop is enough and avoids any chance of memcmp reading past the end of the given string. * randmts.c, randmt.h: New files. * Makefile.am (libgmp_la_SOURCES): Add them. * randmt.c: Move seeding to randmts.c, common defines in randmt.h. * gmp-impl.h (RANDS): Use __gmp_randinit_mt_noseed. * tests/misc.c (tests_rand_start): Use gmp_randinit_default explicitly, not RANDS. * mpn/ia64/ia64-defs.m4 (PROLOGUE_cpu): Use 32-byte alignment, for the benefit of itanium 2. * mpn/ia64/gcd_1.asm: Remove own .align 32. * mpn/ia64/ia64-defs.m4 (ALIGN): New define, using IA64_ALIGN_OK. * acinclude.m4 (GMP_ASM_IA64_ALIGN_OK): New macro. * configure.in (IA64_PATTERN): Use it. * mpn/ia64/README: Add notes on gas big endian align problem. 2003-11-08 Torbjorn Granlund * mpn/x86/aors_n.asm: Align loop to a multiple of 16. Also align M4_function_n to a multiple of 16, to minimize alignment padding. Update P6 cycle counts reflecting improvements with new alignment. 2003-11-07 Kevin Ryde * gmp-impl.h (HAVE_HOST_CPU_alpha_CIX): New define. (ULONG_PARITY, popc_limb): Use it, to pick up ev7 as well as 67 and 68. * longlong.h (count_leading_zeros, count_trailing_zeros): Ditto. * doc/gmp.texi (Notes for Package Builds): Add notes on multi-ABI system packaging. (ABI and ISA): Add GNU/Linux ABI=64. (Binary GCD): Add notes on 1x1 GCD algorithms. * mpn/alpha/README: Add some literature references. * mpn/ia64/mode1o.asm: Various corrections to initial checkin. * mpn/ia64/ia64-defs.m4 (ASSERT): Correction to arg quoting. 2003-11-05 Torbjorn Granlund * mpn/powerpc64/linux64.m4: New file. * configure.in (POWERPC64_PATTERN): Handle *-*-linux*. Use linux64.m4. 2003-11-05 Kevin Ryde * tune/freq.c (freq_sysctl_hw_model): Relax to just look for "%u MHz", for the benefit of sparc cypress under netbsd 1.6.1. * mpfr/*: Update to mpfr-2-0-2-branch 2003-11-05. * mpn/alpha/ev5/dive_1.c: New file. * configure.in (x86_64-*-*): Accept together with amd64-*-*. * tune/speed.c: Check range of -x,-y,-w,-W alignment specifiers. * tune/speed.h (CACHE_LINE_SIZE): Amend comments. 2003-11-04 Torbjorn Granlund * tune/speed.c: Fix typo in testing HAVE_NATIVE_mpn_modexact_1_odd. 2003-11-03 Kevin Ryde * mpn/ia64/mode1o.asm: New file. * mpn/ia64/ia64-defs.m4 (ASSERT): New macro. * tests/mpz/t-set_d.c (check_2n_plus_1): New test. 2003-11-01 Kevin Ryde * mpz/fac_ui.c (BSWAP_ULONG) [limb==2*long]: Remove this case, it provokes code gen problems on HP cc. (BSWAP_ULONG) [generic]: Rename __dst variable to avoid conflicts with BITREV_ULONG. Fix by Jason Moxham. * mpn/powerpc32/mode1o.asm: Use 16-bit i*i for early out, no need to truncate divisor. Amend stated 750/7400 speeds, and note operands that give the extremes. * mpz/set_d.c: Don't use a special case for d < MP_BASE_AS_DOUBLE, gcc 3.3 -mpowerpc64 on darwin gets ulonglong->double casts wrong. * mpn/generic/diveby3.c: Show a better style carry handling in the alternative pipelined sample code. Revert this, the longlong.h macros need -mpowerpc64: * acinclude.m4 (GMP_GCC_POWERPC64): New macro. * configure.in (powerpc64-*-darwin*): Use it to exclude -mpowerpc64 when bad. 2003-10-31 Kevin Ryde * mpfr/*: Update to mpfr-2-0-2-branch 2003-10-31. * mpn/powerpc64/README: Add subdirectory organisation notes. * tests/mpn/t-get_d.c: Don't use limits.h, LONG_MIN is wrong on gcc 2.95 with -mcpu=ultrasparc. * acinclude.m4 (GMP_GCC_POWERPC64): New macro. * configure.in (powerpc64-*-darwin*): Use it to exclude -mpowerpc64 when bad. * configure.in (powerpc64-*-darwin*) [ABI=mode32]: Use gcc -mcpu flags. * mpn/ia64/gcd_1.asm: Use "C" for comments. * mpn/ia64/README, mpn/ia64/ia64-defs.m4: Note this. * mpn/ia64/ia64-defs.m4: Renamed from default.m4, per other defs files. * configure.in (IA64_PATTERN): Update GMP_INCLUDE_MPN. * doc/gmp.texi (Notes for Particular Systems): Remove m68k ABI notes for -mshort and PalmOS, now works. (References): Correction, GMP Square Root proof already there, just wanting URL from RRRR 4475. 2003-10-29 Kevin Ryde * configure.in (sparc*-*-*): Use gcc -m32 when that option works, to force 32-bit mode on dual 32/64 configurations like GNU/Linux. (sparc64-*-linux*): Add support for ABI=64. * mpn/generic/pre_divrem_1.c: In fraction part, use CNST_LIMB(0) with udiv_qrnnd_preinv to avoid warning about shift > type. * mpfr/*: Update to mpfr-2-0-2-branch 2003-10-29. * tests/cxx/t-istream.cc: Avoid tellg() checks if putback() doesn't update that, avoids certain g++ 2.96 problems. * tests/mpn/t-fat.c: New file. * tests/mpn/Makefile.am (check_PROGRAMS): Add it. * configure.in (CPUVEC_INSTALL, ITERATE_FAT_THRESHOLDS): New macros for fat.h. * mpn/x86/fat/fat.c (__gmpn_cpuvec_init): Use CPUVEC_INSTALL instead of memcpy. Correction to location of "initialized" set. Improve various comments. 2003-10-27 Torbjorn Granlund * mpn/sparc64/mul_1.asm: Change addcc => add in a few places. * mpn/sparc64/addmul_1.asm: Likewise. * mpn/sparc32/v9/mul_1.asm: Apply cross-jumping. * mpn/sparc32/v9/addmul_1.asm: Likewise. * mpn/sparc32/v9/submul_1.asm: Likewise. * mpn/sparc32/v9/sqr_diagonal.asm: Likewise. 2003-10-27 Kevin Ryde * tests/cxx/t-misc.cc: Don't use , on g++ 2.95.4 (debian 3.0) -mcpu=ultrasparc LONG_MIN is wrong and kills the compile. * tests/cxx/t-istream.cc: Correction to tellg tests, don't assume streampos is zero based. * configure.in (HAVE_HOST_CPU_FAMILY_alpha): New define for config.h. * mpn/generic/get_d.c: Use it instead of __alpha for alpha workaround, since Cray cc doesn't define __alpha. * mpn/x86/README: Revise PIC coding notes a bit, add gcc visibility attribute. 2003-10-25 Kevin Ryde * mpn/ia64/gcd_1.asm: New file. * tune/many.pl: Allow for PROLOGUE(fun,...), as used on alpha. * doc/gmp.texi (C++ Formatted Input): Describe base indicator handling. * tests/cxx/t-istream.cc: New file. * tests/cxx/Makefile.am: Add it. * cxx/ismpznw.cc: New file, integer input without whitespace ... * cxx/ismpz.cc: ... from here. * gmp-impl.h (__gmpz_operator_in_nowhite): Add prototype. * cxx/ismpq.cc: Rewrite using mpz input routines. Change to accept a separate base indicator on numerator and denominator. Fix base indicator case where "123/0456" would stop at "123/0". * Makefile.am, cxx/Makefile.am: Add cxx/ismpznw.cc. * tests/mpz/t-set_d.c: New file, derived from tests/mpz/t-set_si.c * tests/mpz/Makefile.am (check_PROGRAMS): Add it. * mpn/m68k/lshift.asm, mpn/m68k/rshift.asm: Support 16-bit int and stack alignment. * mpn/m68k/README: Add notes on this. * configure.in (SIZEOF_UNSIGNED): New define in config.m4. * mpn/m68k/m68k-defs.m4 (m68k_definsn): Add cmpw, movew. Reported by Patrick Pelissier. * mpn/m68k/t-m68k-defs.pl: Don't use -> with hashes, to avoid deprecation warnings from perl 5.8. * configure.in (viac3-*-*): Use just x86/pentium in $path not x86/p6. If gcc is to be believed the old C3s don't have cmov. * Makefile.am: Amend comments about not building from libtool convenience libraries. * mpn/asm-defs.m4 (PROLOGUE): Use m4_file_seen, for correct filename in missing EPILOGUE error messages. (m4_file_seen): Amend comments about where used. * Makefile.am (CXX_OBJECTS): Remove $U, C++ files are not subject to ansi2knr rules. * gmp-h.in (mpn_divmod_1): Use __GMP_CAST, to avoid warnings in applications using g++ -Wold-style-cast. * mpn/z8000/README: New file. 2003-10-22 Kevin Ryde * mpn/generic/get_d.c (CONST_1024, CONST_NEG_1023, CONST_NEG_1022_SUB_53): Replace ALPHA_WORKAROUND with a non-gcc-ism, and use on Cray Unicos alpha too, which has the same problem. * configure.in (powerpc64-*-darwin*): Make ABI=32 available as the final fallback, remove mode64 until we know how it will work. * doc/gmp.texi (Build Options): Add powerpc970 to available CPUs. (ABI and ISA): Add mode32 for Darwin. * configure.in (gettimeofday): Use an explicit AC_TRY_LINK, to avoid known autoconf 2.57 problems with gettimeofday in AC_CHECK_FUNCS on HP-UX. * configure.in (powerpc*-*-*): Use ABI=32 instead of ABI=standard for the default 32-bit ABI. Fixes powerpc64-*-aix* which is documented as choices "aix64 32" but had "aix64 standard". * mpfr/*: Update to mpfr-2-0-2-branch 2003-10-22. * doc/gmp.texi (Notes for Particular Systems): Note m68k gcc -mshort and PalmOS calling conventions not supported. Reported by Patrick Pelissier. (References): Add Paul Zimmermann's Inria 4475 paper. 2003-10-21 Kevin Ryde * tests/mpn/t-instrument.c: Add mpn_addlsh1_n, mpn_rsh1add_n, mpn_rsh1sub_n, mpn_sub_nc, mpn_sublsh1_n. Typo in mpn_preinv_divrem_1 conditional. 2003-10-20 Torbjorn Granlund * mpn/powerpc64/mode32/add_n.asm: New file. * mpn/powerpc64/mode32/sub_n.asm: New file. * mpn/powerpc64/mode32/mul_1.asm: New file. * mpn/powerpc64/mode32/addmul_1.asm: New file. * mpn/powerpc64/mode32/submul_1.asm: New file. 2003-10-19 Torbjorn Granlund * longlong.h (AMD64): __x86_64__ => __amd64__. (64-bit powerpc): Only define carry-dependent macros if !_LONG_LONG_LIMB. * acinclude.m4 (POWERPC64_PATTERN): Add powerpc970-*-*. * configure.in (POWERPC64_PATTERN): Handle *-*-darwin*. (POWERPC64_PATTERN, *-*-aix*): Prepend powerpc64/mode64 to path_aix64. * mpn/powerpc64/mode64/mul_1.asm: Change cal => addi. * mpn/powerpc64/mode64/addmul_1.asm: Likewise. * mpn/powerpc64/mode64/submul_1.asm: Likewise. * mpn/powerpc64/sqr_diagonal.asm: Likewise. * mpn/powerpc64/mode64/mul_1.asm: Move from "..". * mpn/powerpc64/mode64/addmul_1.asm: Likewise. * mpn/powerpc64/mode64/submul_1.asm: Likewise. * mpn/powerpc64/mode64/divrem_1.asm: Likewise. * mpn/powerpc64/mode64/rsh1sub_n.asm: Likewise. * mpn/powerpc64/mode64/add_n.asm: Likewise. * mpn/powerpc64/mode64/addsub_n.asm: Likewise. * mpn/powerpc64/mode64/sub_n.asm: Likewise. * mpn/powerpc64/mode64/addlsh1_n.asm: Likewise. * mpn/powerpc64/mode64/diveby3.asm: Likewise. * mpn/powerpc64/mode64/rsh1add_n.asm: Likewise. * mpn/powerpc64/mode64/sublsh1_n.asm: Likewise. * mpn/powerpc64/lshift.asm: Handle mode32 ABI. * mpn/powerpc64/rshift.asm: Likewise. * mpn/powerpc64/umul.asm: Likewise. * tune/powerpc64.asm: Make it actually work. 2003-10-19 Kevin Ryde * mpn/generic/get_d.c: Add a workaround for alpha gcc signed constant comparison bug. * gmpxx.h (gmp_randclass gmp_randinit_lc_2exp_size constructor): Throw std::length_error if size is too big. * tests/cxx/t-rand.cc (check_randinit): Exercise this. * mpn/x86/pentium4/sse2/addlsh1_n.asm: New file, derived in part from mpn/x86/pentium4/sse2/add_n.asm. * doc/gmp.texi (C++ Interface Integers, C++ Interface Rationals, C++ Interface Floats): Note std::invalid_argument exception for invalid strings to constructors and operator=. (C++ Interface Random Numbers): Note std::length_error exception for size too big in gmp_randinit_lc_2exp_size. 2003-10-18 Kevin Ryde * mpfr/*: Update to mpfr-2-0-2-branch 2003-10-18. * gmpxx.h (mpz_class, mpq_class, mpf_class, mpfr_class constructors and operator= taking string or char*): Throw std::invalid_argument if string cannot be converted. * tests/cxx/t-constr.cc, tests/cxx/t-assign.cc: Exercise this. * cxx/ismpz.cc, cxx/ismpq.cc, cxx/ismpf.cc: Use istream std::locale ctype facet for isspace when available. Only accept space at the start of the input, same as g++ libstdc++. Use ASSERT_NOCARRY to check result of mpz_set_str etc. * cxx/ismpf.cc: Don't accept "@" for exponent indicator. * tune/speed.c, tune/speed.h, tune/common.c, tune/Makefile.am: Remove _open and _mpn variants of mpn_toom3_mul_n, only one style now. * tune/mul_n_open.c, tune/mul_n_mpn.c: Remove files. * gmp-impl.h (LIMB_HIGHBIT_TO_MASK): New macro. (udiv_qrnnd_preinv2, udiv_qrnnd_preinv2gen): Use it. * tests/mpz/t-import.c, tests/mpz/t-export.c: Use octal for character constants, hex is an ANSI-ism. * mpn/alpha/ev5/mode1o.c: Corrections to ASSERTs, as per mpn/generic/mode1o.c. * mpn/generic/diveby3.c: Add commented out alternative code and notes for taking the multiply off the dependent chain. Amend/clarify some of the other comments. * configure.in (powerpc970-*-*): Use gcc -mcpu=970 when available. (powerpc7400-*-*): Fallback on gcc -mcpu=750 if -mcpu=7400 not available. * doc/gmp.texi (C++ Formatted Input): Note locale digit grouping not supported. (C++ Formatted Input, C++ Formatted Output): Cross reference class interface on overloading. * mpn/m68k/README: Add various ideas from doc/tasks.html. * mpn/m88k/README: New file. 2003-10-16 Torbjorn Granlund * config.sub: Recognize powerpc970. 2003-10-15 Torbjorn Granlund * config.guess: Recognize powerpc970 under MacOS. 2003-10-15 Kevin Ryde * configure.in, acinclude.m4 (GMP_C_RIGHT_SHIFT): New test. * gmp-impl.h (LIMB_HIGHBIT_TO_MASK): New macro. (udiv_qrnnd_preinv2, udiv_qrnnd_preinv2gen): Use it. * mpn/amd64/amd64-defs.m4: New file, with a non-aligning PROLOGUE. * configure.in (amd64-*-*): Use it. * mpfr/*: Update to mpfr cvs 2003-10-15. * mpn/generic/get_d.c: Rewrite, simplifying and truncating towards zero unconditionally. * tests/mpn/t-get_d.c: Add various further tests. * gmp-impl.h (FORCE_DOUBLE): New macro. * gmp-h.in (__mpz_struct): Add comment on __mpz_struct getting into C++ mangled function names. * doc/gmp.texi (Build Options): Update notes for new doc subdir. (Low-level Functions): Note mpn functions don't check for zero limbs etc, it's up to an application to strip. * doc/configuration (Configure): mdate-sh now in doc subdir, add generated fat.h. 2003-10-13 Kevin Ryde * mpn/powerpc32/mod_34lsub1.asm: New file. * mpn/powerpc32/diveby3.asm, mpn/powerpc64/diveby3.asm: src[] in second operand of mullw, to allow possible early-out, which the 0xAA..AB inverse cannot give. This improvement noticed by Torbjorn. * acinclude.m4 (GMP_ASM_LSYM_PREFIX): Print to config.log whether local label is purely temporary or appears in object files, for development purposes. * doc/gmp.texi, doc/fdl.texi, doc/texinfo.tex, doc/mdate-sh: Moved from top-level. * doc/Makefile.am: New file. * configure.in (AC_OUTPUT): Add doc/Makefile. * Makefile.am (SUBDIRS): Move doc subdirectory from EXTRA_DIST. (info_TEXINFOS, gmp_TEXINFOS): Moved to doc/Makefile.am. * mpfr/Makefile.am (mpfr_TEXINFOS): fdl.texi now in doc subdir. (TEXINFO_TEX): texinfo.tex now in doc subdir. (AM_MAKEINFOFLAGS): Set -I to doc subdir. * mpz/and.c: For positive/positive, use mpn_and_n, rate a realloc as UNLIKELY. * mpn/generic/mul_n.c (mpn_toom3_mul_n, mpn_toom3_sqr_n): Don't test for high zero limbs. 2003-10-12 Torbjorn Granlund * mpn/powerpc64/diveby3.asm: New file (trivial edits of powerpc32/diveby3.asm). * mpn/powerpc32/diveby3.asm: Update cycle counts with more processors. * mpn/powerpc32/sqr_diagonal.asm: Likewise. * mpn/pa64/add_n.asm: Correct PA8500 cycle counts. * mpn/pa64/sub_n.asm: Likewise. * mpn/m68k/aors_n.asm (INPUT PARAMETERS): Fix typo. * mpn/m68k/lshift.asm: Likewise. * mpn/m68k/rshift.asm: Likewise. * mpn/m68k/README: Correct an URL; add some STATUS comments. * mpn/powerpc32/addlsh1_n.asm: New file. * mpn/powerpc32/sublsh1_n.asm: New file. 2003-10-12 Kevin Ryde * mpn/sparc64/divrem_1.c, mpn/sparc64/mod_1.c: New files. * mpn/sparc64/sparc64.h (HALF_ENDIAN_ADJ, count_leading_zeros_32, invert_half_limb, udiv_qrnnd_half_preinv): New macros. * gmp-impl.h (udiv_qrnnd_preinv2): Use a ? : for getting the n1 bit, so as not to depend on signed right shifts being arithmetic. * mpn/powerpc32/diveby3.asm: New file. * mpn/generic/divrem_1.c: Use CNST_LIMB(0) to avoid warnings from udiv_qrnnd_preinv about shift count when int * mpn/asm-defs.m4: Handle rsh1aors_n. * configure.in (tmp_mulfunc): Handle rsh1aors_n. 2003-10-11 Kevin Ryde * mpn/x86/pentium4/sse2/diveby3.asm: Remove non-PIC RODATA memory access for 0xAAAAAAAB constant. * gmp-impl.h (popc_limb, ULONG_PARITY) [ev67, ev68]: Add gcc asm versions using ctpop. * mpn/x86/k6/aorsmul_1.asm: Tweak some comments, remove M4_description and M4_desc_retval used only in comments. * mpn/x86/k6/mul_basecase.asm: Add comment on using mpn_mul_1. 2003-10-09 Torbjorn Granlund * mpn/powerpc64/addlsh1_n.asm: Tweak for 0.25 c/l better loop speed. * mpn/powerpc64/sublsh1_n.asm: Likewise. 2003-10-09 Kevin Ryde * mpfr/*: Update to mpfr cvs 2003-10-09. * tests/devel/try.c (_SC_PAGESIZE): Define from _SC_PAGE_SIZE on systems which use that, eg. hpux 9. 2003-10-07 Kevin Ryde * tune/freq.c (freq_sysctl_hw_model): Correction to last sscanf change. * configure.in: Check for psp_iticksperclktick in struct pst_processor. * tune/freq.c (freq_pstat_getprocessor): Use this. * tests/devel/try.c (divisor_array): Add a couple of half-limb values. * acinclude.m4 (GMP_PROG_CC_WORKS): Correction to last change, need to set result "yes" when cross compiling. 2003-10-06 Torbjorn Granlund * mpn/generic/mul_n.c: Use __GMPN_ADD_1/_GMPN_SUB_1 instead of mpn_add_1 and mpn_sub_1. * mpn/pa64/aorslsh1_n.asm: Schedule register save and restore code. 2003-10-05 Torbjorn Granlund * mpn/pa64/mul_1.asm: Misc comment cleanups. * mpn/pa64/addmul_1.asm: Likewise. * mpn/pa64/submul_1.asm: Likewise. * mpn/pa64/README: Correct cycle counts. * mpn/pa64/aorslsh1_n.asm: New file. 2003-10-04 Kevin Ryde * tune/freq.c (freq_sysctl_hw_model, freq_sunos_sysinfo, freq_sco_etchw, freq_bsd_dmesg, freq_irix_hinv): Demand matching of MHz etc at end of sscanf format string. In particular need this for freq_bsd_dmesg on i486-pc-freebsd4.7 to avoid the 486 cpu being used for the frequency. * tests/misc.c, tests/tests.h (tests_setjmp_sigfpe, tests_sigfpe_handler, tests_sigfpe_done, tests_sigfpe_target, tests_dbl_mant_bits): New. * configure.in (viac3*-*-*): Add gcc VIA c3 options. * mpfr/*: Update to mpfr cvs 2003-10-04. * tests/refmpn.c (refmpn_addlsh1_n, refmpn_sublsh1_n, refmpn_rsh1add_n, refmpn_rsh1sub_n): Add ASSERTs for operand overlaps. * tests/tests.h (refmpn_addlsh1_n, refmpn_sublsh1_n, refmpn_rsh1add_n, refmpn_rsh1sub_n): Add prototypes. * tests/devel/try.c, tune/many.pl: Add mpn_addlsh1_n, mpn_sublsh1_n, mpn_rsh1add_n, mpn_rsh1sub_n. 2003-10-03 Torbjorn Granlund * tests/refmpn.c (refmpn_addlsh1_n, refmpn_sublsh1_n, refmpn_rsh1add_n, refmpn_rsh1sub_n): New functions. 2003-10-03 Paul Zimmermann * mpn/generic/mul_n.c (toom3_interpolate): Use mpn_add_1/mpn_sub_1 instead of MPN_INCR_/MPN_DECR_U. 2003-10-02 Torbjorn Granlund * configure.in (ia64*-*-hpux*): Fall back to +O1, not +O. 2003-10-02 Kevin Ryde * configure.in (ia64*-*-hpux*): For cc, let +O optimization level fallback if +O3 doesn't work. * acinclude.m4 (GMP_PROG_CC_WORKS): Add a test of __builtin_alloca when available, to pick up Itanium HP-UX cc internal errors in +O2. Provoking code by Torbjorn. 2003-10-01 Torbjorn Granlund * mpn/asm-defs.m4: Handle aorslsh1_n. * configure.in (tmp_mulfunc): Handle aorslsh1_n. 2003-10-01 Kevin Ryde * acinclude.m4 (GMP_C_DOUBLE_FORMAT): Make bad ARM last byte into a separate case and consider it non-IEEE, since it looks like this is due to some sort of restricted or incorrect software floats. * demos/calc/Makefile.am: Use automake yacc/lex support, seems fine in separate objdir now. * cxx/dummy.cc: Moved from top-level dummy.cc. * Makefile.am (libgmpxx_la_SOURCES): Update to cxx/dummy.cc, correction to comment about this. 2003-09-30 Torbjorn Granlund * demos/pexpr.c: Correct documentation of -split. (TIME): Remove cast of result to double. (main): Change timing variables to int. (main): #ifdef LIMIT_RESOURCE_USAGE, don't convert numbers of more than 100000 digits. 2003-09-28 Torbjorn Granlund * mpn/*/*.asm: Clean up spacing, tabify. * mpn/alpha/rshift.asm: Table cycle counts. * mpn/alpha/lshift.asm: Likewise. * mpn/alpha/ev5/rshift.asm: Likewise. * mpn/alpha/ev5/lshift.asm: Likewise. * mpn/alpha/ev6/add_n.asm: Likewise. * mpn/alpha/ev6/sub_n.asm: Likewise. * mpn/pa64/mul_1.asm: Fix comment typo. * mpn/pa64/addmul_1.asm: Likewise. * mpn/pa64/submul_1.asm: Likewise. 2003-09-27 Torbjorn Granlund * mpn/powerpc64/README: Update with POWER4/PPC970 pipeline info. * mpn/powerpc64/rshift.asm: Rewrite. * mpn/powerpc64/lshift.asm: Rewrite. 2003-09-25 Torbjorn Granlund * tune/common.c (speed_mpn_addlsh1_n, speed_mpn_sublsh1_n, speed_mpn_rsh1add_n, speed_mpn_rsh1sub_n): Conditionalize on corresponding HAVE_NATIVE_*. 2003-09-25 Kevin Ryde * mpz/combit.c: Use GMP_NUMB_BITS not BITS_PER_MP_LIMB. * demos/expr/exprfr.c: Allow for mpfr_inf_p, mpfr_nan_p and mpfr_number_p merely returning non-zero, rather than 1 or 0. * demos/expr/exprfr.c, demos/expr/t-expr.c: Add erf, integer_p, zeta. * demos/expr/Makefile.am (LDADD): Update comments on $(LIBM). 2003-09-24 Torbjorn Granlund * tune/speed.c (routine): Add entires for mpn_addlsh1_n, mpn_sublsh1_n, mpn_rsh1add_n, and mpn_rsh1sub_n. * tune/speed.h: Declare speed_mpn_addlsh1_n, speed_mpn_sublsh1_n, speed_mpn_rsh1add_n, and speed_mpn_rsh1sub_n. * tune/common.c (speed_mpn_addlsh1_n, speed_mpn_sublsh1_n, speed_mpn_rsh1add_n, speed_mpn_rsh1sub_n): New functions. * gmp-impl.h: Declare mpn_addlsh1_n, mpn_sublsh1_n, mpn_rsh1add_n, and mpn_rsh1sub_n. * mpn/asm-defs.m4: Add define_mpn's for addlsh1_n, sublsh1_n, rsh1add_n, and rsh1sub_n. * mpn/powerpc64/*.asm: Add cycle counts in consistent style. Misc styling edits. * configure.in: Add #undefs for HAVE_NATIVE_mpn_addlsh1_n, HAVE_NATIVE_mpn_sublsh1_n, HAVE_NATIVE_mpn_rsh1add_n, HAVE_NATIVE_mpn_rsh1sub_n. (gmp_mpn_functions_optional): List addlsh1_n, sublsh1_n, rsh1add_n, and rsh1sub_n. 2003-09-24 Kevin Ryde * mpfr/*: Update to mpfr cvs 2003-09-24. * acinclude.m4 (GMP_C_DOUBLE_FORMAT): Remove conftest* temporary files. 2003-09-23 Torbjorn Granlund * gmp-impl.h (MUL_TOOM3_THRESHOLD, SQR_TOOM3_THRESHOLD): Now 128. 2003-09-23 Kevin Ryde * gmp-h.in (gmp_randinit_set): Use __gmp_const rather than const. 2003-09-22 Torbjorn Granlund * tune/mul_n_mpn.c: (__gmpn_sqr_n): New #define. * tune/mul_n_open.c (__gmpn_sqr_n): New #define. * mpn/generic/mul.c (mpn_sqr_n): Move from here... * mpn/generic/mul_n.c (mpn_sqr_n): ...to here. (mpn_sqr_n): Allocate workspace for toom3 using TMP_* mechanism except for very large operands when !WANT_FFT. * mpn/generic/mul_n.c: Add a missing ";". Misc comment fixes. * mpn/generic/mul.c: Remove spurious #include . * mpn/x86/k7/gmp-mparam.h: Retune. * mpn/generic/mul_n.c (mpn_mul_n): Allocate workspace for toom3 using TMP_* mechanism except for very large operands when !WANT_FFT. * gmp-impl.h (MPN_TOOM3_MUL_N_TSIZE, MPN_TOOM3_SQR_N_TSIZE): Define conditionally on WANT_FFT and HAVE_NATIVE_mpn_sublsh1_n. (MPN_TOOM3_MAX_N): New #define. * mpn/generic/sqr_basecase.c: Use mpn_addlsh1_n when available. * mpn/generic/mul_n.c: Use proper form for HAVE_NATIVE macros. 2003-09-22 Kevin Ryde * mpfr/*: Update to mpfr cvs 2003-09-22. 2003-09-21 Kevin Ryde * mpn/x86/pentium4/sse2/gmp-mparam.h (USE_PREINV_DIVREM_1, USE_PREINV_MOD_1): Set to 1 for new asm versions. * mpfr/*: Update to mpfr cvs 2003-09-21. 2003-09-21 Paul Zimmermann * mpn/generic/mul_n.c (mpn_toom3_mul_n): Conditionally use mpn_sublsh1_n, mpn_rsh1add_n and mpn_rsh1sub_n, in addition to mpn_addlsh1_n. Avoid all copying, at the expense of some additional workspace. * gmp-impl.h (MPN_TOOM3_MUL_N_TSIZE, MPN_TOOM3_SQR_N_TSIZE): Accomodate latest toom3 code. 2003-09-19 Kevin Ryde * mpn/x86/pentium4/sse2/divrem_1.asm, mpn/x86/pentium4/sse2/mod_1.asm: New files. 2003-09-16 Kevin Ryde * tune/speed.c (run_one): Don't scale the -1.0 not-available return. Print "n/a" for times not-available. 2003-09-13 Paul Zimmermann * mpn/generic/mul_n.c (toom3_interpolate): New function. (mpn_toom3_mul_n, mpn_toom3_sqr_n): Call toom3_interpolate. 2003-09-12 Torbjorn Granlund * mpn/generic/mul_n.c (mpn_toom3_mul_n, mpn_toom3_sqr_n): Remove unused variables. (mpn_toom3_mul_n, mpn_toom3_sqr_n): Use offset `+ 1', not `+ 2' in last MPN_DECR_U calls. 2003-09-12 Paul Zimmermann * mpn/generic/mul_n.c (mpn_toom3_mul_n, mpn_toom3_sqr_n): Rewrite. 2003-09-12 Torbjorn Granlund * gmp-impl.h (MPN_KARA_MUL_N_TSIZE, MPN_KARA_SQR_N_TSIZE): Reformulate to use the same form as MPN_TOOM3_MUL_N_TSIZE. (MPN_TOOM3_MUL_N_TSIZE, MPN_TOOM3_SQR_N_TSIZE): Update for new Toom3 code requirements. * mpn/generic/mul_n.c (evaluate3, interpolate3, add2Times): Remove. (USE_MORE_MPN): Remove. 2003-08-31 Kevin Ryde * mpfr/*: Update to mpfr cvs 2003-08-31. 2003-08-30 Kevin Ryde * mpfr/*: Update to mpfr cvs 2003-08-30. 2003-08-29 Torbjorn Granlund * mpn/amd64/README: New file. 2003-08-23 Kevin Ryde * tune/freq.c (freq_getsysinfo): Correction to speed_cycletime value established. * mpz/rootrem.c, gmp-h.in, gmp.texi (mpz_rootrem): Don't return exactness indication, can get that from testing the remainder. * mpn/x86/k7/aors_n.asm, mpn/x86/k7/mmx/copyi.asm: Amend to comments about loads and stores and what speed should be possible. 2003-08-19 Kevin Ryde * longlong.h (add_ssaaaa, sub_ddmmss) [hppa 64]: Move down into main __GNUC__ block. Exclude for _LONG_LONG_LIMB (ie. ABI=2.0n) since these forms are only for ABI=2.0w. * longlong.h (count_leading_zeros) [__mcpu32__]: Check __mcpu32__ to avoid bfffo on GCC 3.4 in CPU32 mode. Reported by Bernardo Innocenti. * longlong.h (count_trailing_zeros) [x86_64]: Use "%q0" to force 64-bit register destination. Pointed out by Torbjorn. * mpz/combit.c: Correction to carry handling when extending a negative, and use __GMPN_ADD_1. Correction to complement limb for a negative when there's a non-zero low limb. * tests/mpz/bit.c (check_clr_extend, check_com_negs): Exercise these. * demos/perl/GMP.xs, demos/perl/GMP.pm, demos/perl/test.pl: Add get_d_2exp. * demos/perl/GMP.xs, demos/perl/GMP.pm, demos/perl/GMP/Rand.pm, demos/perl/test.pl: Add gmp_urandomb_ui, gmp_urandomm_ui. (GMP::Rand::randstate): Accept a randstate object to copy. * demos/perl/GMP.xs, demos/perl/GMP.pm, demos/perl/GMP/Mpz.pm, demos/perl/test.pl: Add combit, rootrem. 2003-08-19 Torbjorn Granlund * tune/Makefile.am (EXTRA_DIST): Add amd64.asm. 2003-08-17 Kevin Ryde * gmpxx.h [__MPFR_H]: Include full for inlines. * tests/cxx/t-headfr.cc: New file, exercising this. * tests/cxx/Makefile.am: Add it. * tests/cxx/t-constr.cc: Include config.h for WANT_MPFR. * gmpxx.h: Correction to temp variable type in mpf -> mpfr assignment. Reported by Derrick Bass. * tests/cxx/t-assign.cc (check_mpfr): Exercise this. * configure.in (WANT_MPFR): AC_DEFINE this, for the benefit of tests/cxx/t-*.cc. (Was always meant to have been defined.) * tests/cxx/Makefile.am (INCLUDES): Add -I$(top_srcdir)/mpfr. * gmpxx.h: __gmp_default_rounding_mode -> __gmpfr_default_rounding_mode (struct __gmp_hypot_function): Correction to mpfr_hypot addition. * tests/cxx/t-misc.cc (check_mpfr_hypot): Corrections to mpfr/long tests. 2003-08-16 Torbjorn Granlund * configure.in (amd64): New. * mpn/amd64/gmp-mparam.h: New file. * tune/amd64.asm: New file, derived in part from tune/pentium.asm. 2003-08-15 Kevin Ryde * tune/freq.c (freq_irix_hinv): Reinstate, for the benefit of IRIX 6.2. (freq_attr_get_invent): Conditionalize on INFO_LBL_DETAIL_INVENT too. 2003-08-14 Kevin Ryde * mpq/get_d.c: Use mpn_get_d. * tests/mpq/t-get_d.c (check_onebit): New test. * gmp.texi (Notes for Particular Systems): Under x86 cpu types, note i386 is a fat binary, remove pentium4 recommendation since i386 is now quite reasonable for p4. (Notes for Particular Systems): Under Windows DLLs, remove caveat about --enable-cxx now ok, update .lib creation for new libtool, remove .exp not needed for MS C. (Notes for Package Builds): i386 is a fat binary. (Reentrancy): Remove SCO ctype.h note, don't want to list every system misfeature, and was quite possibly for non-threading mode anyway. (Autoconf): Remove notes on gmp 2 detection, too old to want to encourage anyone to use. (Karatsuba Multiplication): Correction to threshold increase/decrease for a and b terms. Reported by Richard Brent and Paul Zimmermann. Also add various further index entries. * tune/freq.c (freq_attr_get_invent): New function. (freq_irix_hinv): Remove, in favour or freq_attr_get_invent. * configure.in (AC_CHECK_FUNCS): Add attr_get. (AC_CHECK_HEADERS): Add invent.h, sys/attributes.h, sys/iograph.h. 2003-08-03 Kevin Ryde * tune/tuneup.c (tune_mul): Use MUL_KARATSUBA_THRESHOLD_LIMIT. 2003-08-02 Kevin Ryde * mpn/asm-defs.m4: Tweak some comments, add hpux11 to m4wrap 0xFF problem systems. * configure.in (*-*-sco3.2v5*): Remove lt_cv_archive_cmds_need_lc=no, since libtool no longer uses it. This was a workaround fixing ctype.h in SCO 5 shared libraries; not sure if libtool now gets it right on its own, let's hope so. * configure.in, acinclude.m4 (GMP_PROG_HOST_CC): Remove, libtool no longer demands HOST_CC. * configure.in: When C or C++ compiler not found, refer user to config.log. * configure.in (i386-*-*): Turn i386 into a fat binary build. * mpn/x86/fat/fat.c, mpn/x86/fat/fat_entry.asm, mpn/x86/fat/gmp-mparam.h, mpn/x86/fat/gcd_1.c, mpn/x86/fat/mode1o.c: New files. * gmp-impl.h (struct cpuvec_t) [x86 fat]: New structure. * longlong.h (COUNT_LEADING_ZEROS_NEED_CLZ_TAB) [x86 fat]: Define. * mpn/asm-defs.m4 (foreach): New macro. * mpn/x86/x86-defs.m4 (CPUVEC_FUNCS_LIST): New define. * mpn/x86/sqr_basecase.asm: New file, primarily as a fallback for fat binaries. * mpn/x86/p6/gmp-mparam.h, mpn/x86/p6/mmx/gmp-mparam.h: Add comments about fat binary SQR_KARATSUBA_THRESHOLD for p6 and p6/mmx. * configure.in: Add various supports for fat binaries, via fat_path, fat_functions and fat_thresholds variables. * acinclude.m4 (GMP_STRIP_PATH): Mung $fat_path too. (GMP_FAT_SUFFIX, GMP_REMOVE_FROM_LIST): New macros. * gmp-impl.h: Add various supports for fat binaries. (DECL_add_n etc): New macros. (mpn_mul_basecase etc): Define only if not already defined. * mpn/asm-defs.m4 (m4_config_gmp_mparam): Mention fat binary. (MPN): Use m4_unquote, for the benefit of fat binary name expansion. * doc/configuration: Notes on fat binaries. * gmp-impl.h (MUL_TOOM3_THRESHOLD_LIMIT): Define always. (MUL_KARATSUBA_THRESHOLD_LIMIT): New define. * mpn/generic/mul.c, mpn/generic/mul_n.c: Use these. * tune/divrem1div.c, tune/divrem1inv.c, tune/mod_1_div.c, tune/mod_1_inv.c: Define OPERATION_divrem_1 and OPERATION_mod_1, to tell fat.h what's being done. * config.guess (alpha-*-*): Update comments on what configfsf.guess does and doesn't do for us. 2003-07-31 Kevin Ryde * config.guess: Remove $dummy.o files everywhere, in case vendor compilers produce that even when not asked. * demos/perl/GMP.xs (class_or_croak): Rename "class" parameter to avoid C++ keyword. (coerce_ulong, coerce_long): Move croaks to stop g++ 3.3 complaining about uninitialized variables. * demos/perl/INSTALL: Add notes on building with a DLL. * longlong.h (count_trailing_zeros) [x86_64]: Ensure bsfq destination is a 64-bit register. Diagnosed by Francois G. Dorais. 2003-07-31 Torbjorn Granlund * longlong.h [ppc]: Remove nested test for vxworks. 2003-07-24 Kevin Ryde * gmpxx.h (struct __gmp_binary_multiplies): Use mpz_mul_si for mpz*long and long*mpz. * tests/cxx/t-ops.cc (check_mpz): Exercise mpz*long and mpz*ulong. * cxx/ismpf.cc: Use std::locale decimal point when available. Expect localeconv available always. * tests/cxx/t-locale.cc: Enable check_input tests. * gmpxx.h (struct __gmp_hypot_function): Use mpfr_hypot. * tests/cxx/t-misc.cc (check_mpfr_hypot): New tests. * tests/cxx/t-assign.cc, tests/cxx/t-binary.cc, tests/cxx/t-ops.cc, tests/cxx/t-prec.cc, tests/cxx/t-ternary.cc, tests/cxx/t-unary.cc: Include config.h for WANT_MPFR. * tests/mpz/bit.c (check_single): Correction to a diagnostic print. 2003-07-24 Niels Mіller * mpz/combit.c: New file. * Makefile.am, mpz/Makefile.am: Add it. * gmp-h.in (mpz_combit): Add prototype. * tests/mpz/bit.c (check_single): Exercise mpz_combit. 2003-07-16 Kevin Ryde * mpn/generic/get_d.c: Correction to infinity handling for large exp. 2003-07-14 Kevin Ryde * mpz/get_d.c, mpz/get_d_2exp.c, mpf/get_d.c, mpf/get_d_2exp.c: Use mpn_get_d. * mpn/generic/get_d.c: New file, based on mpz/get_d.c and insert-dbl.c. * configure.in, mpn/Makefile.am: Add it. * gmp-impl.h (mpn_get_d): Add prototype. * tests/mpn/t-get_d.c: New file. * tests/mpn/Makefile.am: Add it. * tests/mpz/t-get_d_2exp.c (check_onebit, check_round): Test negatives. (check_onebit): Add a few more bit sizes. * tests/misc.c, tests/tests.h (tests_isinf): New function. 2003-07-12 Kevin Ryde * configure.in (GMP_PROG_CXX_WORKS): Include $CPPFLAGS, same as automake does in the actual build. * acinclude.m4 (GMP_PROG_CXX_WORKS): In the namespace test, declare namespace before trying to use. In std iostream test, provoke a failure from Compaq C++ in pre-standard mode. 2003-07-08 Kevin Ryde * acinclude.m4 (GMP_PROG_CC_WORKS): Use separate compiles for various known problems, and indicate to the user the reason for rejecting. (GMP_PROG_CXX_WORKS): Ditto, and insist on being able to execute each compiled program. 2003-07-05 Kevin Ryde * config.sub: Add comments to our alias transformations. * configfsf.sub, configfsf.guess: Update to 2003-07-04. * acinclude.m4 (GMP_PROG_CC_WORKS, GMP_PROG_CC_WORKS_LONGLONG): Show failing program in config.log, per other autoconf tests. * configure.in (i786-*-*): Recognise as pentium4, per configfsf.sub. 2003-06-28 Kevin Ryde * mpz/get_d_2exp.c, mpf/get_d_2exp.c: Avoid res==1.0 when floats round upwards. * tests/mpz/t-get_d_2exp.c: New file. * tests/mpz/Makefile.am (check_PROGRAMS): Add it. * tests/mpf/t-get_d_2exp.c: New file. * tests/mpf/Makefile.am (check_PROGRAMS): Add it. * tests/x86call.asm, test/tests.h (x86_fldcw, x86_fstcw): New functions. * tests/misc.c, tests/tests.h (tests_hardware_getround, tests_hardware_setround): New functions. 2003-06-25 Kevin Ryde * mpn/sparc64/dive_1.c: New file. * mpn/sparc64/sparc64.h: New file. * mpn/sparc64/mode1o.c: Remove things now in sparc64.h. * mpfr/*: Update to mpfr cvs 2003-06-25. * acinclude.m4 (GMP_PROG_CC_WORKS): In last change provoking gnupro gcc, don't use ANSI style function definition. 2003-06-22 Kevin Ryde * mpn/pa32/hppa1_1/udiv.asm: Remove .proc, .entry, .exit and .procend, handled by PROLOGUE and EPILOGUE. Comment out .callinfo, per other asm files. * gmpxx.h (mpz_class __gmp_binary_divides, __gmp_binary_modulus): Fix long/mpz and long%mpz for dividend==LONG_MIN divisor==-LONG_MIN. (mpz_class __gmp_binary_modulus): Fix mpz%long for negative dividend. * tests/cxx/t-ops.cc (check_mpz): Add test cases for these, merging operator/ and operator% sections for clarity. 2003-06-21 Kevin Ryde * mpfr/*: Update to mpfr cvs 2003-06-21. * acinclude.m4 (GMP_PROG_CC_WORKS): Add code by Torbjorn provoking an ICE from gcc 2.9-gnupro-99r1 under -O2 -mcpu=ev6. * configure.in (alpha*-*-* gcc_cflags_cpu): Fallback on -mcpu=ev56 for this compiler. * gmpxx.h (get_d): Remove comments about long double, double is correct for get_d, a future long double form would be get_ld. 2003-06-19 Kevin Ryde * mpfr/*: Update to mpfr cvs 2003-06-19. * mpn/generic/dive_1.c: Share src[0] fetch among all cases. No need for separate final umul_ppmm in even case, make it part of the loop. * mpz/get_d_2exp.c, mpq/set_si.c, mpq/set_ui.c: Nailify. * mpf/iset_si.c: Rewrite using mpf/set_si.c code, in particular this nailifies it. * tests/mpf/t-set_si.c: Nailify tests. * mpf/iset_ui.c: Nailify, as per mpf/set_ui.c * tests/mpf/t-set_ui.c: New file. * tests/mpf/Makefile.am (check_PROGRAMS): Add it. 2003-06-15 Kevin Ryde * mpfr/*: Update to mpfr cvs 2003-06-15. * mpn/x86/k6/mode1o.asm: Remove a bogus ASSERT. 2003-06-12 Kevin Ryde * configure.in (--enable-assert): Emit WANT_ASSERT to config.m4. * mpn/powerpc32/powerpc-defs.m4, mpn/x86/x86-defs.m4 (ASSERT): Check WANT_ASSERT is defined. * mpn/sparc32/v9/udiv.asm: Amend heading, this file is for sparc v9. * tests/cxx/Makefile.am (TESTS_ENVIRONMENT): In libtool openbsd hack, disard error messages from cp, for the benefit of --disable-shared or systems not using names libgmp.so.*. * tests/devel/try.c (try_one): When overlapping, copy source data after filling dst. Previously probably used only DEADVAL in overlapping cases. 2003-06-11 Torbjorn Granlund * mpf/random2.c: Rewrite. Ignore sign of exp parameter. 2003-06-10 Kevin Ryde * mpn/sparc64/mode1o.c: New file. 2003-06-09 Torbjorn Granlund * mpn/powerpc32/lshift.asm: Add more cycle counts. * mpn/powerpc32/rshift.asm: Add more cycle counts. * gmp-impl.h (udiv_qrnnd_preinv1): New name for udiv_qrnnd_preinv. (udiv_qrnnd_preinv2): New name for udiv_qrnnd_preinv2norm. (udiv_qrnnd_preinv): New #define, making udiv_qrnnd_preinv2 the default. * tune/speed.c: Corresponding changes. * tune/speed.h: Likewise. * tune/common.c: Likewise. * mpf/get_str.c: Simplify `off' computation. * longlong.h: Tabify. 2003-06-09 Kevin Ryde * gmp.texi (ABI and ISA): FreeBSD has sparc64 too, just say "BSD" to cover all flavours. * configure.in: Ditto in some comments. * mpfr/*: Update to mpfr cvs 2003-06-09. * tests/cxx/Makefile.am (LDADD): Add -L$(top_builddir)/$(LIBS), for the benefit of gcc 3.2 on itanium2-hp-hpux11.22. * tune/many.pl (mul_2): Add speed routine settings. (MAKEFILE): Close when done, for the benefit of development hackery. 2003-06-08 Kevin Ryde * mpfr/*: Update to mpfr cvs 2003-06-08. * mpn/x86/x86-defs.m4 (femms): Remove fallback to emms. (cmovCC, psadbw): Remove simulated versions. (cmov_available_p, psadbw_available_p): Remove. This trickery was only ever for development purposes on machines without those instructions. Removing it simplifies gmp and in particular avoids complications for fat binary builds. Development can be done with a wrapper around "as" if really needed. * mpn/x86/divrem_1.asm: Don't use loop_or_decljnz, now K6 has its own mpn/x86/k6/divrem_1.asm. Amend K6 comments now moved to there. * mpn/x86/x86-defs.m4 (loop_or_decljnz): Remove, no longer used. * mpn/x86/k6/divrem_1.asm: New file, derived from mpn/x86/divrem_1.asm. * mpn/x86/k6/pre_mod_1.asm: Remove comments now in mpn/x86/mod_1.asm. * mpn/x86/mod_1.asm: Put mpn_mod_1c after mpn_mod_1 for better branch prediction. Put done_zero at end for less wastage in alignment. Use decl+jnz unconditionally since in fact it's ok on k6. Amend comments. 2003-06-07 Kevin Ryde * mpn/generic/mode1o.c: Fix ASSERTs on return value. * gmp.texi (Build Options): Add viac3 and viac32 cpu types. (ABI and ISA): Note on sparcv9 ABI=32 vs ABI=64 speed. More indexing. * configfsf.guess, configfsf.sub: Update to 2003-06-06. * config.guess: Remove $RANDOM hack supporting netbsd 1.4, not needed by new configfsf.guess. 2003-06-05 Torbjorn Granlund * longlong.h (add_ssaaaa) [pa64]: Output zero operand as register 0. Allow more immediate operands. (sub_ddmmss) [pa64]: Likewise. (add_ssaaaa) [pa32]: Likewise. (sub_ddmmss) [pa32]: Likewise. * mpn/pa64: Change ".level 2.0W" to ".level 2.0w" to please picky GNU assembler. 2003-06-05 Kevin Ryde * gmp.texi (Integer Special Functions): In mpz_array_init, fix type shown for integer_array and give an example use. 2003-06-04 Torbjorn Granlund * mpf/set_str.c (mpf_set_str): Work around gcc 2 bug triggered on alpha. 2003-06-03 Kevin Ryde * mpn/x86/pentium/README: Add 7 c/l mmx mul_1, tweak wordings. * acinclude.m4 (GMP_C_DOUBLE_FORMAT): Use octal char constants in test program, hex is not supported by K&R. 2003-06-02 Torbjorn Granlund * mpn/mips64/divrem_1.asm: New file. 2003-06-01 Torbjorn Granlund * mpn/powerpc32/lshift.asm: Reformat code. * mpn/powerpc32/rshift.asm: Reformat code. 2003-05-30 Kevin Ryde * tests/misc.c (tests_start): Set stdout and stderr to unbuffered, to avoid any chance of losing output on segv etc. 2003-05-28 Torbjorn Granlund * mpf/get_str.c: Move label `done' to match TMP_MARK and TMP_FREE. Remove redundant variable prec. 2003-05-26 Torbjorn Granlund * tests/mpz/convert.c: Test bases up to 62. * tests/mpf/t-conv.c: Test bases up to 62. * demos/pexpr.c: Don't iterate to get accurate timing. * mpf/set_str.c (mpn_pow_1_highpart): Cleanup. * mp_dv_tab.c: Fix typo. * mpf/get_str.c: Rewrite (now sub-quadratic). 2003-05-22 Kevin Ryde * tests/mpn/t-divrem_1.c: New file. * tests/mpn/Makefile.am: Add it. 2003-05-22 Torbjorn Granlund * config.sub: Recognize viac3* processors. 2003-05-20 Torbjorn Granlund * mpn/sparc64/addmul_2.asm: New file. 2003-05-19 Torbjorn Granlund * configure.in: Recognize alphaev7* as alphaev67. * config.guess: Recognize viac3* processors. * configure.in: Set up path for viac3* processors. * acinclude.m4 (X86_PATTERN): Include viac3* processors. 2003-05-19 Kevin Ryde * tune/freq.c (freq_pstat_getprocessor): New function. (freq_all): Use it. * configure.in (AC_CHECK_HEADERS): Add sys/pstat.h. (AC_CHECK_FUNCS): Add pstat_getprocessor. 2003-05-15 Kevin Ryde * mpn/generic/mul_fft.c (mpn_mul_fft_decompose): Remove "inline", since the code is a bit too big. gcc doesn't actually inline when alloca (TMP_ALLOC) is used anyway. 2003-05-13 Kevin Ryde * gmp.texi (Notes for Particular Systems): Libtool directory is .libs not _libs for mingw dll. Reported by Andreas Fabri. 2003-05-07 Kevin Ryde * acinclude.m4 (GMP_PROG_CC_WORKS): Add code to generate sse2/xmm code from gcc -march=pentium4, to check the assembler supports that. (GMP_GCC_PENTIUM4_SSE2, GMP_OS_X86_XMM): New macros. * configure.in (pentium4-*-*): Use them to see if gcc -march=pentium4 (with sse2) is ok. 2003-05-06 Kevin Ryde * mpz/com.c: Rate size==0 as UNLIKELY, fix comment to mpn_add_1. * tune/freq.c (): Include only when needed for getsysinfo(), to avoid a problem with this file on AIX 5.1. 2003-05-03 Torbjorn Granlund * mpf/set_str.c: Do not ignore supposedly superfluous digits (in part reverting last change). 2003-05-03 Kevin Ryde * gmp.texi: Use @code for files in @cindex entries, it looks nicer than @file. * Makefile.am: Note gmp 4.1.1 and 4.1.2 version info. * configure.in, acinclude.m4 (GMP_CRAY_OPTIONS): New macro for Cray system setups, letting AC_REQUIRE do its job instead of a hard coded AC_PROG_EGREP. * config.guess: Amend fake RANDOM to avoid ". configfsf.guess" which segfaults on Debian "ash" 0.4.16. 2003-05-01 Kevin Ryde * configure.in (AC_CHECK_FUNCS): Add getsysinfo. (AC_CHECK_HEADERS): Add sys/sysinfo.h and machine/hal_sysinfo.h. * tune/freq.c (freq_getsysinfo): New function. (freq_all): Use it. (freq_sysctlbyname_i586_freq, freq_sysctlbyname_tsc_freq, freq_sysctl_hw_cpufrequency, freq_sysctl_hw_model): Set speed_cycletime before trying to print it, when verbose. 2003-04-28 Torbjorn Granlund * mpf/set_str.c: Major overhaul. (mpn_pow_1_highpart): New helper function, meat extracted from mpf_set_str. 2003-04-24 Kevin Ryde * acinclude.m4 (GMP_GCC_ARM_UMODSI): Quote result string against m4. * configure, ltmain.sh, aclocal.m4: Update to libtool 1.5. * longlong.h (add_ssaaaa) [all]: Remove first "%" commutative in each, since gcc only supports one per asm. * printf/doprnt.c: Add M for mp_limb_t. * tests/misc/t-printf.c: Exercise this. * tests/mpz/t-cmp_d.c: Test infinities. * tests/mpf/t-cmp_d.c: New file. * tests/mpf/Makefile.am: Add it. * mpz/cmp_d.c, mpz/cmpabs_d.c, mpf/cmp_d.c: NaN invalid, Inf bigger than any value. * mpz/set_d.c, mpq/set_d.c, mpf/set_d.c: Nan or Inf invalid. * configure.in (AC_CHECK_FUNCS): Add raise. * invalid.c: New file. * Makefile.am: Add it. * gmp-impl.h (__gmp_invalid_operation): Add prototype. (DOUBLE_NAN_INF_ACTION): New macro. * tests/trace.c, tests/tests.h (d_trace): New function. * tests/misc.c, tests/tests.h (tests_infinity_d): New function. * tests/misc.c (mpz_erandomb, mpz_errandomb): Use gmp_urandomm_ui. * tune/tuneup.c, tune/common.c, tests/devel/try.c: Cast various mp_size_t values for printf %ld in case mp_size_t==int. Use gmp_printf for mp_limb_t values. * gmp.texi (Nomenclature and Types): Add mp_exp_t, mp_size_t, gmp_randstate_t. Note ulong for bit counts and size_t for byte counts. Don't bother with @noindent. (Debugging): New valgrind is getting MMX/SSE. (Integer Comparisons): mpz_cmp_d and mpz_cmpabs_d on NaNs and Infs. (Float Comparison): mpf_cmp_d behaviour on NaNs and Infs. (Low-level Functions): Note with mpn_hamdist what hamming distance is. (Formatted Output Strings): Add type M. (Internals): Remove remarks on ulong bits and size_t bytes. Move int field remarks to ... (Integer Internals, Float Internals): ... here. 2003-04-19 Kevin Ryde * configure.in (*sparc*-*-* ABI=32): Add umul to extra_functions. * mpn/x86/p6/mul_basecase.asm: New file. 2003-04-18 Kevin Ryde * configure.in (m68060-*-*): Fallback to gcc -m68000 when -m68060 not available, and don't use mpn/m68k/mc68020 asm routines. (Avoids 32x32 mul and 64/32 div which trap to the kernel on 68060. Advice by Richard Zidlicky.) * mpn/m68k/README: Update notes on directory usage. * tests/cxx/Makefile.am (TESTS_ENVIRONMENT): Add a hack to let the test programs run with a shared libgmpxx on openbsd 3.2. * gmp.texi (Language Bindings): Add Guile. 2003-04-12 Kevin Ryde * configure.in (cygwin*, mingw*, pw32*, os2*): Add -Wl,--export-all-symbols to GMP_LDFLAGS, no longer the default in latest mingw and libtool. * acinclude.m4 (GMP_ASM_COFF_TYPE): New macro. * configure.in (x86s): Use it. * mpn/x86/x86-defs.m4 (COFF_TYPE): New macro. (PROLOGUE_cpu): Use it, for the benefit of mingw DLLs. * gmp-impl.h (mpn_copyi, mpn_copyd): Add __GMP_DECLSPEC. * gmp.texi (Known Build Problems): Remove windows test program .exe repeated built, fixed by new libtool. Remove MacOS C++ shared library creation, fixed by new libtool. (Notes for Package Builds, Known Build Problems): Remove DESTDIR notes on libgmpxx, fixed in new libtool. 2003-04-10 Torbjorn Granlund * configure.in: Match turbosparc. * config.guess: Recognize turbosparc (just for *bsd for now). 2003-04-09 Kevin Ryde * mpf/mul_ui.c [nails]: Call mpf_mul to handle v > GMP_NUMB_MAX. * tests/mpz/t-mul.c (main): Don't try FFT sizes when FFT disabled via MP_SIZE_T_MAX, eg. for nails. * tests/cxx/t-ternary.cc: Split up tests to help compile speed and memory usage. * tests/devel/try.c: Print seed under -R, add -E to reseed, use ulong for seed not uint. * gmp.texi: Add @: after various abbreviations, more index entries. (leftarrow): New macro, for non-tex. (Random State Initialization): Remove commented gmp_randinit_lc, not going to be implemented. (Random Number Algorithms): New section. (References): Add Matsumoto and Nishimura on Mersenne Twister, add Bertot, Magaud and Zimmermann on GMP Square Root. 2003-04-06 Kevin Ryde * tests/mpz/t-gcd_ui.c: New file. * tests/mpz/Makefile.am: Add it. * mpz/gcd_ui.c: Correction to return value on longlong limb systems, limb might not fit a ulong. 2003-04-04 Kevin Ryde * configure, aclocal.m4, ltmain.sh: Update to libtool cvs snapshot 2003-04-02. 2003-04-02 Kevin Ryde * configure.in (*-*-cygwin*): No longer force lt_cv_sys_max_cmd_len, libtool has addressed this now. (AC_PROVIDE_AC_LIBTOOL_WIN32_DLL): Remove this, libtool _LT_AC_LOCK no longer needs it. * acinclude.m4 (GMP_PROG_AR): Also set ac_cv_prog_AR and ac_cv_prog_ac_ct_AR when adding flags to AR, so they're not lost by libtool's call to AC_CHECK_TOOL. 2003-04-01 Kevin Ryde * configure, aclocal.m4, ltmain.sh: Update to libtool cvs snapshot 2003-03-31. * configure.in (AC_PROG_F77): Add a dummy AC_PROVIDE to stop libtool running F77 probes. * randlc2x.c (gmp_rand_lc_struct): Add comments about what exactly is in each field. (randseed_lc): Rename seedp to seedz to avoid confusion with seedp in the lc function. Suggested by Pedro Gimeno. (gmp_randinit_lc_2exp): Use __GMP_ALLOCATE_FUNC_TYPE. No need for "+1" in mpz_init2 of _mp_seed. Don't bother with mpz_init2 for _mp_a. 2003-03-29 Kevin Ryde * configure.in (m68k-*-*): Use -O2, no longer need to fallback to -O. * acinclude.m4 (GMP_GCC_M68K_OPTIMIZE): Remove macro. * configure.in (AC_CHECK_TYPES): Add notes on why tested. * gmp.texi (GMPrefu, GMPpxrefu, GMPreftopu, GMPpxreftopu): New macros, use them for all external references to get URLs into HTML output. (Random State Initialization): Add gmp_randinit_set. (Random State Miscellaneous): New section. 2003-03-29 Kevin Ryde * randbui.c, randmui.c: New files. * Makefile.am: Add them. * gmp-h.in (gmp_urandomb_ui, gmp_urandomm_ui): Add prototypes. * tests/rand/t-urbui.c, tests/rand/t-urmui.c: New files. * tests/rand/Makefile.am: Add them. * gmp-impl.h (gmp_randstate_srcptr): New typedef. (gmp_randfnptr_t): Add randiset_fn. * randiset.c: New file. * Makefile.am: Add it. * gmp-h.in (gmp_randinit_set): Add prototype. * randlc2x.c, randmt.c: Add gmp_randinit_set support. * tests/rand/t-iset.c: New file. * tests/rand/Makefile.am: Add it. * tests/misc.c, tests/tests.h (call_rand_algs): New function. 2003-03-27 Kevin Ryde * mpz/bin_uiui.c: Use plain "*" for kacc products rather than umul_ppmm since high not needed, except for an ASSERT now amended. 2003-03-26 Kevin Ryde * demos/expr/exprfr.c (cbrt, cmpabs, exp2, gamma, nextabove, nextbelow, nexttoward): New functions. * demos/expr/t-expr.c: Exercise these. * mpfr/*: Update to mpfr cvs 2003-03-26. * gmp-impl.h (MPZ_REALLOC): Use UNLIKELY, to expect no realloc. * tune/time.c (cycles_works_p): Scope variables down to relevant part to avoid warnings about unused. * configfsf.guess, configfsf.sub: Update to 2003-02-22. * config.guess: Fake a $RANDOM variable when running configfsf.guess, to workaround a problem on m68k NetBSD 1.4.1. * mpz/fac_ui.c: Remove unused variable "z1". * tune/freq.c (freq_irix_hinv): Allow "Processor 0" line from IRIX 6.5. 2003-03-24 Torbjorn Granlund * randlc2x.c (randget_lc): Remove write-only variable rn. * mpf/eq.c: Remove write-only variable usign. * gen-psqr.c (main): Remove write-only variable numb_bits. 2003-03-17 Torbjorn Granlund * Makefile.am (libgmp_la_SOURCES): Add mp_dv_tab.c. (libmp_la_SOURCES): Add mp_dv_tab.c. * mpn/alpha/invert_limb.asm: Add a few comments. * mp_dv_tab.c: New file, defining __gmp_digit_value_tab. * mpz/set_str.c: Get rid of function digit_value_in_base and use table __gmp_digit_value_tab instead. * mpz/inp_str.c: Likewise. * mpf/set_str.c: Likewise. * mpbsd/min.c: Likewise. * mpbsd/xtom.c: Likewise. * mpz/set_str.c: Allow bases <= 62. Return error for invalid bases. * mpz/inp_str.c: Likewise. * mpf/set_str.c: Likewise. * mpz/out_str.c: Likewise. * mpz/get_str.c: Likewise. * mpf/get_str.c: Likewise. * mpz/inp_str.c: Restucture to allocate more string space just before needed. * mpbsd/min.c: Likewise. * longlong.h (__udiv_qrnnd_c): Remove redundant casts. (32-bit sparc): Test HAVE_HOST_CPU_supersparc in addition to various sparc_v8 spellings. 2003-03-17 Kevin Ryde * mpfr/*: Update to mpfr cvs 2003-03-17. 2003-03-15 Kevin Ryde * Makefile.am (EXTRA_libgmp_la_SOURCES): Use this for TMP_ALLOC sources, instead of a libdummy.la. 2003-03-16 Torbjorn Granlund * config.guess: Recognize supersparc and microsparc for *BSD systems. Generalize some superscalar recognition patterns. 2003-03-14 Torbjorn Granlund * mpn/sparc64/udiv.asm: New file. 2003-03-13 Torbjorn Granlund * mpn/sparc64: Table cycle counts. Update some comments. 2003-03-10 Torbjorn Granlund * mpn/generic/mul.c (mpn_mul): Don't blindly expect MUL_KARATSUBA_THRESHOLD to be a constant. 2003-03-07 Torbjorn Granlund * mpn/generic/mul.c (mpn_mul): New operand splitting code for avoiding cache misses when un >> MUL_KARATSUBA_THRESHOLD > vn. (MUL_BASECASE_MAX_UN): New #define, default to 500 for now. 2003-03-07 Kevin Ryde * Makefile.am: Put gmp.h and mp.h under $(exec_prefix)/include. * gmp.texi (Build Options): Add notes on this. Reported by Vincent Lefшvre. 2003-03-06 Kevin Ryde * configure.in (alpha*-*-* gcc): Add asm option before testing -mcpu, for the benefit of gcc 2.9-gnupro-99r1 on alphaev68-dec-osf5.1 which doesn't otherwise put the assembler in the right mode for -mcpu=ev6. 2003-03-05 Torbjorn Granlund * mpn/powerpc32/powerpc-defs.m4: Set up renaming for v registers. * mpz/powm.c (redc): Instead of repeated mpn_incr_u invocations, accumulate carries and add at the end. (mpz_powm): Trim tp allocation, now as redc doesn't need carry guard. 2003-02-25 Torbjorn Granlund * mpn/x86/pentium4/copyd.asm: Correct header comment. * mpn/arm/addmul_1.asm: Correct cycle counts. * mpn/arm/submul_1.asm: Likewise. 2003-02-20 Kevin Ryde * demos/factorize.c (factor_using_pollard_rho): Test k>0 to avoid infinite loop if k=0 and gcd!=1 reveals a factor. Reported by John Pongsajapan. * gmp.texi, fdl.texi: Update to FDL version 1.2. 2003-02-18 Torbjorn Granlund * mpn/arm/mul_1.asm: Fix typo introduced in last change. 2003-02-17 Torbjorn Granlund * mpn/sparc64/copyi.asm: Add some header comments. * mpn/sparc64/copyd.asm: Likewise. * mpn/arm/mul_1.asm: Put vl operand last for umull/umlal. Add some header comments. * mpn/arm/addmul_1.asm: Rewrite. * mpn/arm/submul_1.asm: Rewrite. * mpn/arm/gmp-mparam.h: Retune. 2003-02-16 Torbjorn Granlund * mpn/arm/copyi.asm: New file. * mpn/arm/copyd.asm: New file. 2003-02-16 Kevin Ryde * acinclude.m4 (GMP_C_DOUBLE_FORMAT): Tolerate incorrect last data byte seen on an arm system. 2003-02-15 Torbjorn Granlund * mpn/arm/gmp-mparam.h: Retune. 2003-02-13 Torbjorn Granlund * mpn/powerpc32/750/com_n.asm: Add more cycle counts. 2003-02-13 Kevin Ryde * configure.in (AC_PREREQ): Bump to 2.57. * configure.in, acinclude.m4 (GMP_GCC_WA_OLDAS): New macro, applying -Wa,-oldas only when necessary. * configure.in (powerpc*-*-*): Don't use -Wa,-mppc with gcc, it overrides options recent gcc adds for -mcpu, making generated code fail to assemble. * tune/tuneup.c (mpn_fft_table): Remove definition, it's in mul_fft.c. 2003-02-12 Torbjorn Granlund * mpn/x86/pentium4/sse2/gmp-mparam.h: Retune. * mpn/x86/k7/gmp-mparam.h: Retune. * mpn/x86/k6/gmp-mparam.h: Retune. * mpn/x86/p6/gmp-mparam.h: Retune. * mpn/x86/p6/mmx/gmp-mparam.h: Retune. * tests/mpz/t-mul.c (main): Rewrite FFT testing code. 2003-02-10 Torbjorn Granlund * config.guess: Recognize "power2" systems. * mpn/powerpc64/gmp-mparam.h: Fix indentation. * mpn/power/gmp-mparam.h: Retune. * mpn/alpha/ev6/nails/gmp-mparam.h: Retune. * mpn/sparc64/gmp-mparam.h: Retune. * mpn/pa64/gmp-mparam.h: Retune. * mpn/sparc32/v8/supersparc/gmp-mparam.h: Retune. * mpn/sparc32/v8/gmp-mparam.h: Retune. * mpn/mips64/gmp-mparam.h: Retune. * mpn/alpha/ev6/gmp-mparam.h: Retune. * mpn/powerpc32/gmp-mparam.h: Retune. * mpn/powerpc32/750/gmp-mparam.h: Retune. * mpn/alpha/ev5/gmp-mparam.h: Retune. * mpn/m68k/gmp-mparam.h: Retune. * mpn/cray/gmp-mparam.h: Set GET_STR_PRECOMPUTE_THRESHOLD. * configure.in: Undo this, problem doesn't happen any more: (mips64*-*-*): Pass just -O1 to cc, to work around compiler bug. 2003-02-03 Kevin Ryde * gmp-impl.h (MPN_NORMALIZE, MPN_NORMALIZE_NOT_ZERO): Add parens around macro parameters. Reported by Jason Moxham. 2003-02-01 Kevin Ryde * gmp.texi (Low-level Functions): No overlap permitted by mpn_mul_n. Reported by Jason Moxham. (Formatted Input Strings): Correction to strtoul cross reference formatting. (BSD Compatible Functions): Add index entry for MINT. 2003-01-29 Torbjorn Granlund * gmp-impl.h (mpn_mul_fft): Now returns int. 2003-01-29 Paul Zimmermann * mpn/generic/mul_fft.c: Major rewrite. 2003-01-25 Kevin Ryde * config.guess (powerpc*-*-*): Remove $dummy.core file when mfpvr fails on NetBSD. (trap): Remove $dummy.core on abnormal termination too. * mpfr/*: Update to mpfr cvs 2003-01-25. 2003-01-18 Kevin Ryde * mpfr/*: Update to mpfr cvs 2003-01-18. 2003-01-17 Torbjorn Granlund * gmp.texi: Canonicalize URLs. 2003-01-15 Kevin Ryde * gmp.texi (Notes for Particular Systems): Add hardware floating point precision mode. * mpfr/*, configure, aclocal.m4, config.in: Update to mpfr cvs 2003-01-15. 2003-01-11 Kevin Ryde * mpfr/*: Update to mpfr cvs 2003-01-11. 2003-01-09 Kevin Ryde * mpfr/get_str.c: Update to mpfr cvs 2003-01-09. * doc/configuration: Various updates. 2003-01-06 Torbjorn Granlund * mpn/alpha/copyi.asm: Avoid `nop' mnemonic, unsupported on Cray. * mpn/alpha/copyd.asm: Likewise. 2003-01-05 Kevin Ryde * demos/expr/t-expr.c (check_r): Tolerate mpfr_set_str new return value. * configure, aclocal.m4 (*-*-osf4*, *-*-osf5*): Regenerate with libtool patch to avoid bash printf option problem when building shared libraries with cxx. * configure.in (pentium4-*-*): Use "-march=pentium4 -mno-sse2" since sse2 causes buggy code from gcc 3.2.1 and is only supported on new enough kernels. * acinclude.m4 (GMP_PROG_NM): Add some notes about failures, per report by Krzysztof Kozminski. * gmp-h.in (mpz_mdivmod_ui, mpz_mmod_ui): Add parens around "r". * gmp-h.in (__GMP_CAST): New macro, clean to g++ -Wold-style-cast. (GMP_NUMB_MASK, mpz_cmp_si, mpq_cmp_si, mpz_odd_p, mpn_divexact_by3, mpn_divmod): Use it. Reported by Krzysztof Kozminski. (mpz_odd_p): No need for the outermost cast to "int". * tests/cxx/t-cast.cc: New file. * tests/cxx/Makefile.am: Add it. 2003-01-04 Kevin Ryde * mpfr/set_str.c: Update to mpfr cvs 2003-01-04. * demos/expr/exprfra.c (e_mpfr_number): Tolerate recent mpfr_set_str returning count of characters accepted. 2003-01-03 Torbjorn Granlund * mpn/alpha/copyi.asm: New file. * mpn/alpha/copyd.asm: New file. 2003-01-03 Kevin Ryde * demos/expr/t-expr.c: Use __gmpfr on some mpfr internals that have changed. * mpfr/*, aclocal.m4, config.in, configure: Update to mpfr cvs 2003-01-03. * gmp.texi (Introduction to GMP): Mention release announcements mailing list, and put home page and ftp before mailing lists. 2002-12-28 Torbjorn Granlund * mpn/generic/mul_fft.c (mpn_fft_next_size): Simplify. 2002-12-28 Kevin Ryde * acinclude.m4 (M68K_PATTERN): New macro. (GMP_GCC_M68K_OPTIMIZE): Use it to avoid m6811 and friends. * configure.in: Ditto. * tests/mpz/t-import.c, tests/mpz/t-export.c: Use '\xHH' to avoid warnings about char overflows. * acinclude.m4 (GMP_C_DOUBLE_FORMAT): Ditto. 2002-12-28 Pedro Gimeno * randmt.c (randseed_mt, default_state): Fix off-by-one bug on padding. (randseed_mt): Add ASSERT checking result of mpz_export. 2002-12-24 Kevin Ryde * gmp.texi (Integer Import and Export): Clarify treatment of signs, reported by Kent Boortz. * randmt.c: Use gmp_uint_least32_t. (randseed_mt): Add nails to mpz_export in case mt[i] more than 32 bits. * gmp-impl.h (gmp_uint_least32_t): New typedef, replacing GMP_UINT32. * configure.in (AC_CHECK_TYPES): Add uint_least32_t. (AC_CHECK_SIZEOF): Add unsigned short. 2002-12-22 Kevin Ryde * gmp-impl.h (ULONG_PARITY) [generic C]: Mask result to a single bit. (ULONG_PARITY) [_CRAY, __ia64]: New macros. * tests/t-parity.c: New test. * tests/Makefile.am (check_PROGRAMS): Add it. * longlong.h (count_trailing_zeros) [ia64]: New macro. * tests/t-count_zeros.c (check_various): Remove unused variable "n". * mpn/x86/README: Revise notes on PIC, PLT and GOT. * demos/perl/GMP.xs, demos/perl/GMP.pm, demos/perl/test.pl: Add "mt" to GMP::Rand::randstate. 2002-12-22 Pedro Gimeno * randmt.c (randseed_mt): Fix bug that might cause the generator to return all zeros with certain seeds. Fix WARM_UP==0 case. (gmp_randinit_mt): Initialize to a known state by default. (randget_mt): Remove check for uninitialized buffer: no longer needed. (recalc_buffer): Use ?: instead of two-element array. * tests/rand/t-mt.c: New test. * tests/rand/Makefile.am (check_PROGRAMS): Add it. 2002-12-21 Kevin Ryde * cxx/osdoprnti.cc: Use and rather than and . No need for . * demos/expr/expr.c, demos/expr/exprfa.c, demos/expr/exprfra.c, demos/expr/exprza.c: Use mp_get_memory_functions, not __gmp_allocate_func etc. * demos/expr/t-expr.c: Don't use gmp-impl.h. (numberof): New macro. * gmp-h.in, gmp-impl.h (__gmp_allocate_func, __gmp_reallocate_func, __gmp_free_func): Move declarations to gmp-impl.h * mp_get_fns.c: New file. * Makefile.am (libgmp_la_SOURCES, libmp_la_SOURCES): Add it. * gmp-h.in (mp_get_memory_functions): Add prototype. * gmp.texi (Custom Allocation): Add mp_get_memory_functions, refer to "free" not "deallocate" function. * gmpxx.h (struct __gmp_alloc_cstring): Use mp_get_memory_functions, not __gmp_free_func. * gmp-impl.h [__cplusplus]: Add for strlen. (gmp_allocated_string): Hold length in a field. * cxx/osdoprnti.cc, cxx/osmpf.cc: Use this. 2002-12-20 Torbjorn Granlund * tests/mpz/t-perfsqr.c (check_sqrt): Print more variables upon failure. * mpn/generic/rootrem.c: In Newton loop, pad qp with leading zero. 2002-12-19 Torbjorn Granlund * mpn/generic/rootrem.c: Allocate 1.585 (log2(3)) times more space for pp temporary to allow for worst case overestimate of root. Add some asserts. * tests/mpz/t-root.c: Generalize and speed up. 2002-12-19 Kevin Ryde * tests/cxx/t-rand.cc (check_randinit): Add gmp_randinit_mt test. * gmp-h.in: Don't bother trying to support Compaq C++ in pre-standard I/O mode. * gmp.texi (Notes for Particular Systems): Compaq C++ must be used in "standard" iostream mode. 2002-12-18 Torbjorn Granlund * mpn/alpha/mod_34lsub1.asm: Add code for big-endian, using existing little-endian code only if HAVE_LIMB_LITTLE_ENDIAN is defined. 2002-12-18 Kevin Ryde * configure.in (HAVE_LIMB_BIG_ENDIAN, HAVE_LIMB_LITTLE_ENDIAN): New defines in config.m4. 2002-12-17 Torbjorn Granlund * printf/printffuns.c (gmp_fprintf_reps): Make it actually work for padding > 256. 2002-12-17 Kevin Ryde * tune/freq.c: Add for memcmp. * mpz/pprime_p.c: Use MPN_MOD_OR_MODEXACT_1_ODD. * gmp.texi (Formatted Output Strings): %a and %A are C99 not glibc. (Formatted Input Strings): Type "l" is for double too. Hex floats are accepted for mpf_t. (Formatted Input Functions): Describe tightened parse rule, clarify return value a bit. * scanf/doscan.c: Add hex floats, tighten matching to follow C99, for instance "0x" is no longer acceptable to "%Zi". Rename "invalid" label to avoid "invalid" variable, SunOS cc doesn't like them the same. * tests/misc/t-scanf.c: Update tests. * tests/misc/t-locale.c (check_input): Don't let "0x" appear from fake decimal point. * config.guess (sparc*-*-*): Look at BSD sysctl hw.model to recognise ultrasparcs. * mpfr/tests/dummy.c: New file. * mpfr/tests/Makefile.am (libfrtests_a_SOURCES): Add it. 2002-12-14 Kevin Ryde * mpbsd/Makefile.am (nodist_libmpbsd_la_SOURCES): Move these mpz sources to libmpbsd_la_SOURCES directly, automake 1.7.2 now gets the ansi2knr setups right for sources in other directories. * mpfr/tests/Makefile.am: Add libfrtests.a in preparation for new mpfr. 2002-12-13 Kevin Ryde * mpfr/Makefile.am (mpfr_TEXINFOS, AM_MAKEINFOFLAGS): Allow for fdl.texi in recent mpfr. * configure.in (AC_PROG_EGREP): Ensure this is run outside the Cray conditional AC_EGREP_CPP. * configure.in (alpha*-*-*): Use gcc -Wa,-oldas if it works, to avoid problems with new compaq "as" on OSF 5.1. * mpn/Makefile.am (EXTRA_DIST): Remove Makeasm.am, automake 1.7.2 does it automatically. * acinclude.m4 (AC_LANG_FUNC_LINK_TRY(C)): Remove this hack, fixed by autoconf 2.57. * configure.in (AC_CONFIG_LIBOBJ_DIR): Set to mpfr, for the benefit of new mpfr using LIBOBJ. * configure.in: (AM_INIT_AUTOMAKE): Use "gnu no-dependencies $(top_builddir)/ansi2knr". * */Makefile.am (AUTOMAKE_OPTIONS): Remove, now in configure.in. * configure, config.in, INSTALL.autoconf: Update to autoconf 2.57. * */Makefile.in, configure, aclocal.m4, install-sh, mkinstalldirs: Update to automake 1.7.2. * gmp.texi (Build Options): Add hppa64 to cpu types. (ABI and ISA): Add gcc to hppa 2.0. (Debugging): Add maximum debuggability config options. (Language Bindings): Add Arithmos, reported by Johan Vervloet. (Formatted Output Strings): 128 bits is about 40 digits, ll is only for long long not long double. (Formatted Input Strings): ll is only for long long not long double. * mpz/divis.c, mpz/divis_ui.c, mpz/cong.c, mpz/cong_ui.c: Allow d=0, under the rule n==c mod d iff exists q satisfying n=c+q*d. * gmp.texi (Integer Division): Describe this. Suggested by Jason Moxham. 2002-12-13 Pedro Gimeno * randlc2x.c (lc): Remove check for seedn < an, which is now superfluous. Add ASSERT to ensure it's correct. Add ASSERT to check precondition of __GMPN_ADD. (gmp_randinit_lc_2exp): Avoid reallocation by allocating one extra bit for both seed and a. Simplify seedn < p->_cn case. * tests/rand/t-lc2exp.c (check_bigs): Test negative seeds. 2002-12-12 Torbjorn Granlund * mpn/pa32/pa-defs.m4 (PROLOGUE_cpu): Zap spurious argument to `.proc'. Add empty `.callinfo'. 2002-12-11 Torbjorn Granlund * mpn/x86/pentium4/sse2/addmul_1.asm: Don't reuse `ret' symbol for a label. 2002-12-11 Kevin Ryde * configure.in (hppa*-*-*): Don't use gcc -mpa-risc-2-0 in ABI=1.0. * mpn/pa32/pa-defs.m4: New file, arranging for .proc/.procend. * configure.in (hppa*-*-*): Use it. * printf/doprnt.c: Comments on "ll" versus "L". * tests/mpz/t-div_2exp.c: Reduce tests, especially the random ones. 2002-12-11 Torbjorn Granlund * mpz/get_d.c (limb2dbl): New macro for conversion to `double'. Define it to something non-trivial for 64-bit hppa. * mpq/get_d.c: Likewise. * mpf/get_d.c: Likewise. * mpn/x86/pentium4/sse2/addmul_1.asm: Unroll to save one c/l. 2002-12-09 Kevin Ryde * tune/Makefile.am: Don't use -static under --disable-static, it tends not to work. * configure.in (ENABLE_STATIC): New AM_CONDITIONAL. * gmp-h.in: Use instead of with Compaq C++ in pre-standard I/O mode. * tests/mpz/t-jac.c, tests/mpz/t-scan.c: Reduce tests. 2002-12-08 Kevin Ryde * configure.in (*-*-ultrix*): Remove forcible --disable-shared, believe this was a generic problem with libtool, now gone. 2002-12-08 Torbjorn Granlund * gmp-impl.h (USE_LEADING_REGPARM): Disable for PIC code generation. 2002-12-07 Torbjorn Granlund * tests/cxx/t-misc.cc (check_mpq): Use 0/1 for canonical 0 in mpq_cmp_ui calls. * configure.in (hppa2.0*-*-*): Pass +O2 instead of +O3 to work around compiler bug with mpfr/tests/tdiv. 2002-12-07 Kevin Ryde * configure.in (hppa2.0*-*-* ABI=2.0n): Make -mpa-risc-2-0 optional. New hppa-level-2.0 test using GMP_HPPA_LEVEL_20 to detect assembler support for 2.0n. * acinclude.m4 (GMP_PROG_CC_WORKS): Add code that provokes an error from gcc -mpa-risc-2-0 if the assembler doesn't know 2.0 instructions. (GMP_HPPA_LEVEL_20): New macro. 2002-12-07 Pedro Gimeno * gmp-impl.h (gmp_randfnptr_t.randseed_fn) Return void. (LIMBS_PER_ULONG, MPN_SET_UI): New macros. (MPZ_FAKE_UI): Rename couple of parameters. * randlc2x.c (gmp_rand_lc_struct): _mp_c and _mp_c_limbs replaced with mpn style _cp and _cn. All callers changed. (randseed_lc): Fix limbs(seed) > bits_to_limbs(m2exp) case. Remove return value. (gmp_randinit_lc_2exp): Attempt to avoid redundant reallocation. * randmt.c (mangle_seed): New function by Kevin. (randseed_mt): Use it instead of mpz_powm, for performance. Remove return value. Remove commented out code (an inferior alternative to mpz_export). * randsdui.c (gmp_randseed_ui): Use MPZ_FAKE_UI. * tests/rand/t-lc2exp.c (check_bigm, check_bigs): New tests. * tests/rand/t-urndmm.c: Add L to constants in calls, for K&R. 2002-12-06 Torbjorn Granlund * configure.in: Remove -g. (hppa*-*-*): Pass -Wl,+vnocompatwarnings with +DA2.0. 2002-12-05 Torbjorn Granlund * mpn/pa64/sqr_diagonal.asm: Remove .entry, .proc, .procend. * mpn/pa64/udiv.asm: Likewise. 2002-12-05 Kevin Ryde * mpn/pa64/sub_n.asm: Remove space in "sub, db" which gas objects to. * mpn/pa64/*.asm, tune/hppa2.asm: Use ".level 2.0" for 2.0n, since gas doesn't like ".level 2.0N". * configure.in (hppa*-*-*): Group path and flags choices, for clarity. (hppa1.0*-*-*): Use gcc -mpa-risc-1-0 when available. (hppa2.0*-*-*): Ditto -mpa-risc-2-0. (*-*-hpux*): Exclude ABI=2.0w for hpux[1-9] and hpux10, rather than the converse of allowing it for hpux1[1-9]; ie. list the bad systems rather than try to guess the good systems. (hppa2.0*-*-*) [ABI=2.0n ABI=2.0w]: Add gcc to likely compilers. (hppa*-*-*) [gcc]: Test sizeof(long) to differentiate a 32-bit or 64-bit build of the compiler. (hppa64-*-*): Add this as equivalent to hppa2.0-*-*. * acinclude.m4 (GMP_C_TEST_SIZEOF): New macro. * tests/tests.h (ostringstream::str): Must null-terminate ostrstream::str() for the string constructor. 2002-12-04 Torbjorn Granlund * mpn/pa32/hppa1_1/udiv.asm: Don't wrap symbol to INT64 in L() stuff. * longlong.h (mpn_udiv_qrnnd_r based udiv_qrnnd): Fix typo. * mpn/powerpc32/powerpc-defs.m4: Define float registers with `f' prefix. 2002-12-04 Kevin Ryde * gmp.texi (Floating-point Functions): Note the mantissa is binary and decimal fractions cannot be represented exactly. Suggested by Serge Winitzki. (Known Build Problems): Note libtool stripping options when linking. Reported by Vincent Lefevre. * acinclude.m4 (GMP_ASM_LABEL_SUFFIX): Don't make an empty result a failure, that's a valid result. (GMP_ASM_GLOBL): Establish this from the host cpu type. (IA64_PATTERN): New macro. (GMP_PROG_EXEEXT_FOR_BUILD, GMP_C_FOR_BUILD_ANSI, GMP_CHECK_LIBM_FOR_BUILD): Remove temporary files created. * configure.in: Use IA64_PATTERN. 2002-12-03 Torbjorn Granlund * tune/hppa.asm: Use config.m4. * tune/hppa2.asm: Likewise. * tune/hppa2w.asm: Likewise. * mpn/pa64: Use LDEF. 2002-12-03 Kevin Ryde * INSTALL: Use return rather than exit in the example programs. Suggested by Richard Dawe. * gmp.texi (Build Options): Move non-unix notes to ... (Notes for Particular Systems): ... here. Mention MS Interix, reported by Paul Leyland. (C++ Interface Random Numbers): Add gmp_randinit_mt to examples. * acinclude.m4 (GMP_ASM_LABEL_SUFFIX): Must test empty suffix first, for the benefit of hppa hp-ux. (GMP_ASM_UNDERSCORE): Grep the output of "nm" instead of trying to construct an asm file, and in case of failure fallback on no underscore and a warning. * longlong.h (count_leading_zeros, count_trailing_zeros) [ev67, ev68]: Restrict __asm__ ctlz and cttz to __GNUC__. * gen-psqr.c (HAVE_CONST, const): New macros. * tests/cxx/t-rand.cc (check_randinit): Add gmp_randinit_mt. 2002-12-02 Torbjorn Granlund * gmp-impl.h: Split popc_limb again, combined version gives too many compiler warnings. 2002-12-01 Torbjorn Granlund * mpn/generic/gcdext.c (div1): Disable unused function. * mpz/root.c: Don't include stdlib.h or longlong.h. * mpz/rootrem.c: Likewise. * extract-dbl.c: abort => ASSERT_ALWAYS. * mpz/set_d.c: Likewise. * mpn/generic/tdiv_qr.c: Likewise. * gen-psqr.c (f_cmp_fraction, f_cmp_divisor): Change parameter to `const void *', to match qsort spec. 2002-12-01 Kevin Ryde * gmp.texi (Integer Division): Fix a couple of @math's for tex. Use @dots in more places. * tests/cxx/t-locale.cc: Test non std::locale systems too. * tests/cxx/clocale.c: New file, reinstating what was localeconv.c, and subverting nl_langinfo too. * tests/cxx/Makefile.am (t_locale_SOURCES): Add it. * tests/tests.h (ostringstream, istringstream): Provide fakes of these if not available. * tests/cxx/t-locale.cc, tests/cxx/t-ostream.cc: Remove . * configure.in (AC_CHECK_HEADERS) [C++]: Add . 2002-11-30 Torbjorn Granlund * printf/doprnt.c (__gmp_doprnt): Comment out a `break' to shut up compiler warnings. * longlong.h (umul_ppmm) [ia64]: Form both product parts in asm. * mpz/bin_uiui.c: Cast umul_ppmm operands. * scanf/doscan.c (gmpscan): Remove unused label store_get_digits. * gmp-impl.h: #undef MIN and MAX before #defining. 2002-11-30 Kevin Ryde * configure.in (AC_CHECK_HEADERS): Add nl_types.h. * tests/misc/t-locale.c: Use this, for nl_item on netbsd 1.4.1. 2002-11-29 Torbjorn Granlund * tests/devel/addmul_1.c: Provide prototype for mpn_print. (OPS): Account for function overhead. * tests/devel/{submul_1.c,mul_1.c,add_n.c,sub_n.c}: Likewise. 2002-11-28 Kevin Ryde * mpn/Makefile.am (nodist_EXTRA_libmpn_la_SOURCES): Use this rather than libdummy. * tests/Makefile.am (EXTRA_libtests_la_SOURCES): Use this for x86call.asm and x86check.c rather than libdummy. 2002-11-27 Torbjorn Granlund * tests/mpz/t-mul.c: Implement reference Karatsuba multiplication. Rewrite testing scheme to run fewer really huge tests. 2002-11-26 Torbjorn Granlund * tests: Decrease repetition count for some of the slowest tests. 2002-11-25 Torbjorn Granlund * mpfr/tests/tdiv.c: Decrease number of performed tests. 2002-11-23 Kevin Ryde * mpn/ia64/README: Add some references. * gmp.texi (Build Options): Add itanium and itanium2, mention DocBook and XML from makeinfo, add texinfo top level cross reference. (Integer Division): Try to clarify 2exp functions a bit. (C++ Interface Floats): Giving bad string to constructor is undefined. (C++ Interface Integers, C++ Interface Rationals): Ditto, and show default base in prototype, not the description. * config.sub, config.guess, configure.in (itanium, itanium2): New cpu types. * tests/misc/t-printf.c, tests/misc/t-scanf.c (check_misc): Suppress %zd test on glibc prior to 2.1, it's not supported. 2002-11-20 Kevin Ryde * tests/cxx/t-locale.cc: Test with locales imbued into stream, use , eliminated some C-isms. istream tests disabled, not yet locale-ized. * tests/cxx/Makefile.am (t_locale_SOURCES): Remove localeconv.c. * tests/cxx/localeconv.c: Remove file. * configure.in (AC_CHECK_TYPES) [C++]: Add std::locale. * printf/doprntf.c: Add decimal point parameter, remove localeconv use. * gmp-impl.h (__gmp_doprnt_mpf): Update prototype, bump symbol to __gmp_doprnt_mpf2 to protect old libgmpxx. * cxx/osmpf.cc: Use this with ostream locale decimal_point facet. * printf/doprnt.c: Ditto, with GMP_DECIMAL_POINT. * gmp-h.in: More comments on __declspec for windows DLLs. * mpf/set_str.c, scanf/doscan.c: Cast through "unsigned char" for decimal point string, same as input chars. * configure.in (AC_CHECK_HEADERS): Add langinfo.h. (AC_CHECK_FUNCS): Add nl_langinfo. * gmp-impl.h (GMP_DECIMAL_POINT): New macro. * mpf/out_str.c, mpf/set_str.c, scanf/doscan.c: Use it, and don't bother with special code for non-locale systems. * tests/misc/t-locale.c: Subvert nl_langinfo too. * configure.in, acinclude.m4 (GMP_ASM_X86_GOT_UNDERSCORE): New macro. * mpn/x86/x86-defs.m4 (_GLOBAL_OFFSET_TABLE_): New macro, inserting extra underscore for OpenBSD. * mpn/x86/README (_GLOBAL_OFFSET_TABLE_): Update notes. Reported by Christian Weisgerber. * tests/cxx/t-rand.cc (check_randinit): New function, collecting up constructor tests. * tests/cxx/t-ostream.cc: Use instead of , use compare instead of strcmp. * gmpxx.h (__gmp_randinit_lc_2exp_size_t): Return type is int. 2002-11-18 Kevin Ryde * tune/speed.c (r_string): Use CNST_LIMB with bits, spotted by Torbjorn. 2002-11-17 Torbjorn Granlund * mpn/generic/popham.c: New file, using new faster algorithm. * mpn/generic/popcount.c: Remove. * mpn/generic/hamdist.c: Remove. * mpn/ia64/addmul_1.asm: Don't clobber callee-saves register f16. * mpn/ia64/mul_1.asm: Likewise. * mpn/ia64/addmul_1.asm: Add pred.rel declarations. Resolve RAW hazards for condition code registers, duplicating code as needed. Add prediction to all branches. * mpn/ia64/mul_1.asm: Likewise. * mpn/ia64/add_n.asm: Likewise. * mpn/ia64/sub_n.asm: Likewise. * mpn/ia64/copyi.asm: Likewise. * mpn/ia64/copyd.asm: Likewise. * mpn/generic/random2.c: Add a cast to silence some compilers. 2002-11-16 Torbjorn Granlund * mpz/powm.c: Cap allocation by limiting k to 10 (512 precomputed values). 2002-11-16 Kevin Ryde * configure.in, gmp.texi: Remove powerpc64 ABI=32L, doesn't work and is unlikely to ever do so. * configure.in: Allow ABI=32 for powerpc64. Reported by David Edelsohn. 2002-11-14 Kevin Ryde * mpn/Makefile.am (nodist_libdummy_la_SOURCES): Add addmul_2.c addmul_3.c addmul_4.c addmul_5.c addmul_6.c addmul_7.c addmul_8.c. * gmp-h.in (__GMP_DECLSPEC_EXPORT, __GMP_DECLSPEC_IMPORT) [__GNUC__]: Use __dllexport__ and __dllimport__ to keep out of application namespace. 2002-11-14 Gerardo Ballabio * gmpxx.h (__gmp_randinit_default_t, __gmp_randinit_lc_2exp_t, __gmp_randinit_lc_2exp_size_t): Use extern "C" { typedef ... }, for the benefit of g++ prior to 3.2. 2002-11-12 Kevin Ryde * gmpxx.h (gmp_randclass constructors): Patch from Roberto Bagnara to use extern "C" on C function pointer arguments. 2002-11-09 Kevin Ryde * configure.in, Makefile.am, printf/Makefile.am, printf/repl-vsnprintf.c: Handle vsnprintf replacement with C conditionals. * acinclude.m4 (AC_LANG_FUNC_LINK_TRY(C)): Workaround troubles recent HP cc +O3 causes for AC_CHECK_FUNCS. * gmp.texi (Notes for Particular Systems): Add Sparc app regs. (Debugging): Note gcc -fstack options to detect overflow. (Formatted Output Strings, Formatted Input Strings): Format strings are not multibyte. 2002-11-06 Torbjorn Granlund * mpn/generic/tdiv_qr.c: Remove a bogus assert. 2002-11-05 Torbjorn Granlund * mpn/generic/tdiv_qr.c: Remove two dead mpn_divrem_2 calls. 2002-11-04 Kevin Ryde * acinclude.m4 (GMP_C_INLINE): Don't define "inline" for C++. * demos/expr/expr-impl.h (stdarg.h): Test __DECC same as gmp.h. * mpbsd/mtox.c, printf/obprintf.c, printf/obvprintf.c, scanf/vsscanf.c, demos/expr/expr.c, demos/expr/exprf.c, demos/expr/exprfa.c, demos/expr/exprfr.c, demos/expr/exprq.c, demos/expr/exprz.c, demos/expr/exprza.c: Add for strlen and memcpy. 2002-11-02 Kevin Ryde * longlong.h: Test __x86_64__ not __x86_64. Reported by Andreas Jaeger. * mpz/import.c, mpz/export.c: Use char* subtract from NULL to get pointer alignment, for the benefit of Cray vector systems. * cxx/ismpf.cc: Use . * tests/cxx/t-locale.cc: No need to conditionalize . * scanf/doscan.c: Don't use isascii, rely on C99 ctype.h. * gmp.texi (Build Options): Describe CC_FOR_BUILD, cross reference texinfo manual. (ABI and ISA): Add powerpc620 and powerpc630 to powerpc64, add NetBSD and OpenBSD sparc64. (Notes for Package Builds): Cross reference libtool manual. (Notes for Particular Systems): Add OpenBSD to non-MMX versions of gas. (Known Build Problems): Add MacOS X C++ shared libraries. 2002-10-31 Kevin Ryde * gmp-impl.h, tune/speed.c, tune/speed.h, tune/common.c, tune/many.pl, tests/devel/try.c, tests/tests.h, tests/refmpn.c (mpn_addmul_5, mpn_addmul_6, mpn_addmul_7, mpn_addmul_8): Add testing and measuring. * configure.in (config.in): Add #undefs of HAVE_NATIVE_mpn_addmul_5, HAVE_NATIVE_mpn_addmul_6, HAVE_NATIVE_mpn_addmul_7, HAVE_NATIVE_mpn_addmul_8. (gmp_mpn_functions_optional): Add addmul_5 addmul_6 addmul_7 addmul_8. * tests/devel/try.c (ASSERT_CARRY): Remove, now in gmp-impl.h (try_one): Do dest setups after sources, for benefit of dst0_from_src1. 2002-11-01 Torbjorn Granlund * mpn/generic/tdiv_qr.c: Avoid quadratic behaviour for sub-division when numerator is more than twice the size of the denominator. Simplify loop logic for the same case. Clean up a few comments. 2002-10-29 Torbjorn Granlund * configure.in (*-cray-unicos*): Pass -hnofastmd again. 2002-10-25 Torbjorn Granlund * tests/tadd.c: Disable test of denorms. 2002-10-23 Linus Nordberg * gmp.texi (Introduction to GMP): Update section about mailing lists. 2002-10-23 Kevin Ryde * gmp-h.in (__GMP_ATTRIBUTE_PURE): Suppress this when __GMP_NO_ATTRIBUTE_CONST_PURE is defined. * gmp-impl.h (ATTRIBUTE_CONST): Ditto. * tune/common.c: Use __GMP_NO_ATTRIBUTE_CONST_PURE. * tune/speed.h, tune/many.pl: Remove ATTRIBUTEs from prototypes. * tune/speed.h: Remove various "dummy" variables attempting to keep "pure" calls live, no longer necessary. They weren't sufficient for recent MacOS cc anyway. 2002-10-21 Torbjorn Granlund * mpn/cray/ieee/addmul_1.c: Handle overlap as in mul_1.c. * mpn/cray/ieee/submul_1.c: Likewise. 2002-10-19 Kevin Ryde * configure.in (sparcv9 etc -*-*bsd*): Add support for NetBSD and OpenBSD sparc64. Reported by Christian Weisgerber. (AC_CHECK_HEADERS): Add sys/param.h for sys/sysctl.h on *BSD. * demos/calc/calc.y: Change ={ to {, needed for bison 1.50. * longlong.h (count_leading_zeros, count_trailing_zeros) [x86_64]: Should be UDItype. * mpz/set_str.c, mpf/set_str.c, mpbsd/xtom.c, scanf/sscanffuns.c: Cast chars through "unsigned char" to zero extend, required by C99 ctype.h. 2002-10-18 Torbjorn Granlund * tests/mpz/t-root.c: Test also mpz_rootrem. * mpn/generic/rootrem.c: Avoid overflow problem when n is huge. * mpz/root.c: Avoid overflow problems in allocation computation; also simplify it. Misc cleanups. * mpz/rootrem.c: New file. * Makefile.am, mpz/Makefile.am, gmp-h.in: Add them. 2002-10-17 Torbjorn Granlund * gmp-impl.h (popc_limb): Combine variants. 2002-10-14 Kevin Ryde * configure.in (AC_CHECK_HEADERS): Add sys/time.h for sys/resource.h test, needed by SunOS, and next autoconf will insist headers actually compile. 2002-10-08 Kevin Ryde * tune/time.c (speed_time_init): Allow for Cray times() apparently being a cycle counter. * dumbmp.c (mpz_get_str): Fix buf size allocation. * tests/trace.c, tests/tests.h (mp_limb_trace): New function. * tune/speed-ext.c (SPEED_EXTRA_PROTOS): Use __GMP_PROTO. * tests/devel/try.c (malloc_region): Add a cast for SunOS cc. * configure.in (AC_CHECK_FUNCS): Add strerror. (AC_CHECK_DECLS): Add sys_errlist, sys_nerr. * tune/time.c, tests/devel/try.c: Use them. 2002-10-05 Kevin Ryde * configure.in (AC_CHECK_HEADERS): Test float.h, not in SunOS cc. * printf/repl-vsnprintf.c: Use this. * configure.in (*sparc*-*-*): Collect up various options for clarity, use gcc -mcpu=supersparc and ultrasparc3, use cc -xchip, don't use -xtarget=native, use cc configs with acc, merge SunOS bundled cc and SunPRO cc configs. * gmp-impl.h (gmp_randfnptr_t): Use __GMP_PROTO. (MPZ_REALLOC): Cast _mpz_realloc return value to mp_ptr, for the benefit of SunOS cc which requires pointers of the same type on the two legs of a ?:. * dumbmp.c (mpz_realloc): Add a cast to avoid a warning from SunOS cc. * acinclude.m4: Allow for i960 b.out default cc output. * gmp.texi (Random State Initialization): Add gmp_randinit_mt. (Perfect Square Algorithm): Describe new mpn_mod_34lsub1 use. (Factorial Algorithm): Describe Jason's new code. (Binomial Coefficients Algorithm): Ideas about improvements moved to doc/projects.html. (Contributors): Add Jason Moxham and Pedro Gimeno. 2002-10-03 Kevin Ryde * gen-psqr.c: New file. * Makefile.am, mpn/Makefile.am: Use it to generate mpn/perfsqr.h. * mpn/generic/perfsqr.c: Use generated data, put mod 256 data into limbs to save space, use mpn_mod_34lsub1 when good. * tests/mpn/t-perfsqr.c: New file. * tests/mpn/Makefile.am (check_PROGRAMS): Add it. * tests/mpz/t-perfsqr.c (check_modulo): New test. (check_sqrt): New function holding current tests. * configure.in (AC_INIT): Modernize to package name and version here rather than AM_INIT_AUTOMAKE, add bug report email. (AC_CONFIG_SRCDIR): New macro. * gmp-impl.h (ROUND_UP_MULTIPLE): Fix for non-power-of-2 moduli (not normal in current uses), clarify the comments a bit. 2002-09-30 Kevin Ryde * mpn/Makeasm.am (.s.lo): Add --tag=CC for the benefit of CCAS!=CC, same as .S.lo and .asm.lo. * Makefile.am (gen-fac_ui, gen-fib, gen-bases): Quote source files in test -f stuff to avoid Sun make rewriting them. 2002-09-28 Kevin Ryde * tests/devel/try.c, tune/speed.c: Avoid strings longer than C99 guarantees. * tests/refmpn.c, tests/tests.h (refmpn_zero_extend, refmpn_normalize, refmpn_sqrtrem): New functions. * tests/devel/try.c (TYPE_SQRTREM): Use refmpn_sqrtrem. (compare): Correction to tr->dst_size subscripting. * dumbmp.c: Add several new functions, allow for initial n * dumbmp.c (mpz_pow_ui, mpz_addmul_ui, mpz_root): New functions. * gen-fac_ui.c: New file. * mpz/fac_ui.c: Rewrite. 2002-09-26 Kevin Ryde * tests/cxx/localeconv.c: New file, split from t-locale.cc. * tests/cxx/t-locale.cc: Use it. * tests/cxx/Makefile.am (t_locale_SOURCES): Add it. * tests/cxx/Makefile.am: Updates for Gerardo's new test programs. 2002-09-26 Gerardo Ballabio * gmpxx.h (__gmp_cmp_function): Bug fixes in double/mpq and double/mpfr comparisons. * tests/cxx/t-assign.cc, tests/cxx/t-binary.cc, tests/cxx/t-constr.cc, tests/cxx/t-ternary.cc, tests/cxx/t-unary.cc: Revise and add various tests, including some for mpfr, some split from t-expr.cc. * tests/cxx/t-locale.cc: Modernize include files. * tests/cxx/t-ostream.cc: Modernize include files, use cout rather than printf for diagnostics. * tests/cxx/t-misc.cc, tests/cxx/t-rand.cc: New file, split from t-allfuns.cc. * tests/cxx/t-ops.cc: New file, some split from t-allfuns.cc. * tests/cxx/t-prec.cc: New file. * tests/cxx/t-allfuns.cc, tests/cxx/t-expr.cc: Remove files. 2002-09-25 Torbjorn Granlund * configure.in (*-cray-unicos*): Remove -hscalar0, it causes too much performance loss. Let's trust Cray to fix their compilers. 2002-09-24 Torbjorn Granlund * mpn/powerpc32/add_n.asm: Rewrite. * mpn/powerpc32/sub_n.asm: Rewrite. 2002-09-24 Pedro Gimeno * randlc2x.c: Prepare for nails by changing type of _mp_c to mpz_t, make _mp_seed fixed-size, disallow SIZ(a)==0 to optimize comparisons for mpn_mul. * gmp-impl.h (MPZ_FAKE_UI): New macro. * randmt.c: Some constants made long for K&R compliance; remove UL at the end of other constants; use mp_size_t where appropriate; use mpz_export to split the seed. * gmp-impl.h: Remove type cast in RNG_FNPTR and RNG_STATE, to allow them to be used as lvalues. * randclr.c, randlc2x.c, randmt.c, randsd.c: All callers changed. * mpz/urandomm.c: Replace mpn_cmp with MPN_CMP. * tests/rand/gen.c: Get rid of gmp_errno. 2002-09-24 Kevin Ryde * gmp.texi (Custom Allocation): Keep allocate_function etc out of the function index by using @deftypevr. More index entries. 2002-09-24 Gerardo Ballabio * gmpxx.h (mpfr_class constructors from strings): Precision was set incorrectly, fixed. 2002-09-23 Torbjorn Granlund * mpf/urandomb.c: Don't crash for overlarge nbits argument. Let nbits==0 mean to fill number with random bits. 2002-09-21 Torbjorn Granlund * mpn/alpha/mod_34lsub1.asm: Add r31 dummy operand to `br' instruction. 2002-09-20 Gerardo Ballabio * gmpxx.h (__gmp_binary_equal, __gmp_binary_not_equal): Fix broken mpq/double functions. 2002-09-18 Torbjorn Granlund * randmt.c (randget_mt): Fix typo. 2002-09-18 Kevin Ryde * gmp-impl.h (_gmp_rand): Avoid evaluating "state" more than once, for the benefit places calling it with RANDS. * randmt.c (randseed_mt): Use mpz_init for mod and seed1, for safety. * tune/tuneup.c (sqr_karatsuba_threshold): Initialize to TUNE_SQR_KARATSUBA_MAX so mpn_sqr_n works for randmt initialization. * gmp.texi (Integer Comparisons): Remove mention of non-existant mpz_cmpabs_si, reported by Conrad Curry. * tune/speed.c, tune/speed.h, tune/common.c: Add gmp_randseed, gmp_randseed_ui and mpz_urandomb. 2002-09-18 Pedro Gimeno * tests/rand/gen.c: Add mt, remove lc and bbs. * Makefile.am (libgmp_la_SOURCES): Add randmt.c, remove randlc.c and randraw.c. * randmt.c: New file. * gmp-h.in (gmp_randinit_mt): Add prototype. * randdef.c: Use gmp_randinit_mt. * gmp-impl.h (RNG_FNPTR, RNG_STATE): New macros. (gmp_randfnptr_t): New structure. (_gmp_rand): Now a macro not a function. * gmp-h.in (__gmp_randata_lc): Remove, now internal to randlc2x.c. (__gmp_randstate_struct): Revise comments on field usage. * randsd.c, randclr.c: Use function pointer scheme. * randsdui.c: Use gmp_randseed. * randraw.c: Remove file. * randlc2x.c: Collect up lc_2exp related code from randsd.c, randclr.c and randraw.c, use function pointer scheme, integrate seed==0/a==0 into main case and fix case where bits(a) < m2exp. * randlc.c: Remove file, never documented and never worked. * gmp-h.in (gmp_randinit_lc): Remove prototype. 2002-09-16 Torbjorn Granlund * mpn/alpha/mod_34lsub1.asm: New file. 2002-09-16 Kevin Ryde * configure.in, acinclude.m4 (GMP_C_RESTRICT): Remove this, not currently used, and #define restrict upsets Microsoft C headers on win64. Reported by David Librik. * configure.in (x86): Add gcc 3.2 -march and -mcpu flags, remove some unnecessary -march=i486 fallbacks. * gmp.texi (Notes for Particular Systems): Note cl /MD is required for Microsoft C and MINGW to cooperate on I/O. Explained by David Librik. (Language Bindings): Add linbox. * gmp.texi (Language Bindings): 2002-09-12 Kevin Ryde * mpz/aorsmul_i.c: Allow for w==x overlap with nails. Test BITS_PER_ULONG > GMP_NUMB_BITS rather than GMP_NAIL_BITS != 0. * tests/mpz/t-aorsmul.c: Test this. * tune/common.c: mpn_mod_34lsub1 only exists for GMP_NUMB_BITS%4==0 * tune/speed.c: Add mpn_mod_34lsub1. 2002-09-10 Pedro Gimeno * rand.c: Remove old disabled BBS code. * mpf/urandomb.c: Use BITS_TO_LIMBS. 2002-09-10 Kevin Ryde * gmp.texi (Multiplication Algorithms): FFT is now enabled by default. 2002-09-10 Pedro Gimeno * mpz/urandomm.c: Use mpn level functions, avoid an infinite loop if _gmp_rand forever returns all "1" bits. * tests/rand/t-urndmm.c: New file * tests/rand/Makefile.am (check_PROGRAMS): Add it. * gmp-impl.h (BITS_TO_LIMBS): New macro. * mpz/urandomb.c: Use it, and use MPZ_REALLOC. 2002-09-08 Kevin Ryde * acinclude.m4 (GMP_GCC_WA_MCPU): New macro. * configure.in (alpha*-*-*): Use it to avoid -Wa,-mev67 if gas isn't new enough to know ev67. Reported by David Bremner. 2002-07-30 Gerardo Ballabio * gmpxx.h (__gmpz_value etc): Remove, use mpz_t etc instead. (__gmp_expr): Reorganise specializations, use __gmp_expr not mpz_class etc. (mpfr evals): Remove mode parameter, was always __gmp_default_rounding_mode anyway. 2002-09-07 Kevin Ryde * gmp-h.in, mp-h.in: Use #ifdef for tests, for the benefit of applications using gcc -Wundef. * longlong.h: Define COUNT_LEADING_ZEROS_NEED_CLZ_TAB for all alphas, since mpn/alpha/cntlz.asm always goes into libgmp.so, even for ev67 and ev68 which don't need it. Reported by David Bremner. * gmp.texi (Demonstration Programs): New section, expanding on what was under "Build Options". (Converting Floats): Don't need \ for _ in @var within @math. Add and amend various index entries. * demos/qcn.c: Add -p prime limit option. 2002-08-30 Kevin Ryde * mpz/pprime_p.c: Handle small negatives with isprime, in particular must do so for n==-2. * tests/mpz/t-pprime_p.c: New file. * tests/mpz/Makefile.am: Add it. 2002-08-26 Torbjorn Granlund * gmp.texi (Converting Floats): Fix typo in mpf_get_d_2exp docs, reported by Paul Zimmermann. 2002-08-26 Kevin Ryde * configure.in: Echo the ABI being tried for the compilers. (powerpc*-*-*): Use powerpc64/aix.m4 for ABI=aix64 too. (AC_CHECK_FUNCS): Add strtol, for tests/rand/gen.c. 2002-08-24 Kevin Ryde * configure.in (HAVE_HOST_CPU_, HAVE_HOST_CPU_FAMILY_, HAVE_NATIVE_): Setup templates for these using AH_VERBATIM rather than acconfig.h, preferred by latest autoconf. Prune lists to just things used. * acconfig.h: Remove file. * mpn/powerpc32/mode1o.asm: Forgot ASM_START. * tune/time.c (have_cgt_id): Renamed from HAVE_CGT_ID so avoid confusion with autoconf outputs, and turn it into a "const" variable. 2002-08-23 Torbjorn Granlund * configure.in: Choose powerpc32/aix.m4 or powerpc64/aix.m4 based on ABI, not configuration triple. * mpz/pprime_p.c: Partially undo last change--handle small and negative numbers in the same test. 2002-08-22 Kevin Ryde * gmp-impl.h (MUL_FFT_THRESHOLD, SQR_FFT_THRESHOLD): Note mpn/generic/mul_fft.c is not nails-capable, and don't bother setting other FFT data for nails. * configfsf.guess: Update to 2002-08-19. * configfsf.sub: Update to 2002-08-20. * config.guess (powerpc*-*-*): Use a { } construct to suppress SIGILL message on AIX. 2002-08-20 Kevin Ryde * gmp.texi (Build Options): Add ia64 under cpu types. (ABI and ISA): Describe IRIX 6 ABI=o32. (Notes for Particular Systems): Remove -march=pentiumpro, now ok. (Known Build Problems): Binutils 2.12 is ok for libgmp.a. (Emacs): New section. (Language Bindings): Update MLton URL, reported by Stephen Weeks. (Prime Testing Algorithm): New section. Don't put a blank line after @item in @table since it can make a page break between the heading and the entry. Misc tweaks elsewhere, in particular more index entries. * mpz/millerrabin.c: Need x to be size+1 for change to urandomm. * gmp-impl.h: Comments on the use of __GMP_DECLSPEC. * tune/time.c (freq_measure_mftb_one): Use struct_timeval, for the benefit of mingw. * tests/refmpn.c, tests/tests.h (ref_addc_limb, ref_subc_limb): Renamed from add and sub, following gmp-impl.h ADDC_LIMB and SUBC_LIMB. 2002-08-17 Kevin Ryde * mpn/powerpc32/mode1o.asm: New file. * configure.in, acinclude.m4 (GMP_ASM_POWERPC_PIC_ALWAYS): New macro. * mpn/asm-defs.m4: Use it to help setting up PIC. * configure.in (AC_PREREQ): Bump to 2.53. * mpn/powerpc32/powerpc-defs.m4 (ASSERT): New macro. (PROLOGUE_cpu): New macro, giving ALIGN(4) not 8. 2002-08-16 Torbjorn Granlund * mpn/m68k/lshift.asm: Fix typo in !scale_available_p code. * mpn/m68k/rshift.asm: Likewise. 2002-08-16 Kevin Ryde * configure.in (--enable-profiling=instrument): New option. * gmp.texi (Profiling): Describe it. * mpn/x86/x86-defs.m4 (PROLOGUE_cpu, call_instrument, ret_internal): Add support. (call_mcount): Share PIC setups with call_instrument. * mpn/x86/*.asm: Use ret_internal. * mpn/asm-defs.m4 (m4_unquote): New macro. * tests/mpn/t-instrument.c: New file. * tests/mpn/Makefile.am: Add it. * mpn/alpha/umul.asm: Add ASM_END. 2002-08-12 Kevin Ryde * mpz/pprime_p.c: Fake up a local mpz_t to take abs(n), rather than using mpz_init etc. * mpz/millerrabin.c: Use mpz_urandomm for uniform selection of x, reported by Jason Moxham. Exclude x==n-1, ie. -1 mod n. Use gmp_randinit_default. * mpn/alpha/umul.asm: Use "r" registers, for the benefit of Unicos. * tests/devel/try.c: Add mpn_copyi and mpn_copyd. 2002-08-09 Kevin Ryde * Makefile.am: Remove configure.lineno from DISTCLEANFILES and gmp.tmp from MOSTLYCLEANFILES, automake does these itself now. * */Makefile.in, aclocal.m4, configure, install-sh, missing, mkinstalldirs: Update to automake 1.6.3. * mpn/ia64/README: Some notes on assembler syntax. * mpn/ia64/add_n.asm, mpn/ia64/sub_n.asm: Add .body. * mpn/ia64/add_n.asm, mpn/ia64/addmul_1.asm, mpn/ia64/mul_1.asm, mpn/ia64/sub_n.asm: Position .save ar.lc just before relevant instruction. * mpn/ia64/addmul_1.asm, mpn/ia64/mul_1.asm: Add .save ar.pfs and pr. * mpn/ia64/copyd.asm, mpn/ia64/copyi.asm: Correction to .body position. * mpn/ia64/lorrshift.asm: Add .prologue stuff. * configure.in (*-*-unicos*): Remove forcible --disable-shared, libtool gets this right itself now. 2002-08-07 Kevin Ryde * mpn/x86/pentium/mmx/hamdist.asm: New file, adapted from mpn/x86/pentium/mmx/popham.asm. * mpn/x86/pentium/mmx/popham.asm: Remove file, not faster than plain mpn/x86/pentium/popcount.asm for the popcount. * mpn/alpha/umul.asm: Use PROLOGUE/EPILOGUE, rename it mpn_umul_ppmm. * configure.in (alpha*-*-*): Add umul to extra_functions. * mpz/remove.c: Make src==0 return 0, not do DIVIDE_BY_ZERO. 2002-08-05 Torbjorn Granlund * acconfig.h: Remove spurious undefs for mpn_divrem_newton and mpn_divrem_classic. 2002-08-05 Kevin Ryde * tests/refmpn.c, tests/tests.h, tests/misc/t-printf.c, tests/mpf/t-trunc.c, tests/mpn/t-mp_bases.c, tests/mpn/t-scan.c, tests/mpq/t-cmp_ui.c, tests/mpz/bit.c, tests/mpz/t-aorsmul.c, tests/mpz/t-powm_ui.c tests/mpz/t-root.c, tests/mpz/t-scan.c: More care with long and mp_size_t parameters, for the benefit of K&R. * demos/perl/GMP.pm, demos/perl/GMP.xs, demos/perl/GMP/Mpz.pm, demos/perl/test.pl: Add mpz_import and mpz_export. * demos/perl/GMP.pm: Remove "preliminary" warning. * mpn/lisp/gmpasm-mode.el: Set add-log-current-defun-header-regexp to pick up m4 defines etc. * Makefile.am (libgmpxx_la_DEPENDENCIES): libgmp.la should be here, not libgmpxx_la_LIBADD, for the benefit of "make -j2". * mpn/ia64/*.asm [hpux ABI=32]: Extend 32-bit operands to 64-bits, not optimal and might not be sufficient, but seems to work. 2002-08-03 Kevin Ryde * gmp.texi (Profiling): Use a table and expand for clarity. (Integer Special Functions): New section for mpz_array_init, _mpz_realloc, mpz_getlimbn and mpz_size, to discourage their use. * configure.in (*-*-msdosdjgpp*): Remove forcible --disable-shared, libtool gets this right itself now. 2002-07-30 Kevin Ryde * mpn/powerpc32/lshift.asm, mpn/powerpc32/rshift.asm: Lose final mr, and make final stwu into an stw. * gmp.texi (Known Build Problems): An easier workaround for DESTDIR, using LD_LIBRARY_PATH. (C++ Interface MPFR): Remove mpfrxx.h. * mpfrxx.h: Remove file. * Makefile.am: Remove mpfrxx.h. * tests/cxx/Makefile.am: Add Gerardo's new test programs. 2002-07-30 Gerardo Ballabio * gmpxx.h: Use mpz_addmul etc for ternary a+b*c etc. Reorganise some macros for maintainability. Merge mpfrxx.h. * tests/cxx/t-constr.cc, tests/cxx/t-expr.cc: Various updates. * tests/cxx/t-assign.cc, tests/cxx/t-binary.cc, tests/cxx/t-ternary.cc, tests/cxx/t-unary.cc: New files. 2002-07-27 Kevin Ryde * longlong.h (count_trailing_zeros) [ia64 __GNUC__]: Don't use __builtin_ffs for now, doesn't seem to work. * configure.in: Establish CONFIG_SHELL to avoid a problem with AC_LIBTOOL_SYS_MAX_CMD_LEN on ia64-*-hpux*. * tune/speed.h (SPEED_ROUTINE_MPN_GCD_FINDA): Don't let calls to mpn_gcd_finda go dead. * mpn/generic/tdiv_qr.c: Inline mpn_rshift and MPN_COPY of 2 limbs. 2002-07-24 Kevin Ryde * demos/primes.c: Use __GMP_PROTO and don't use signed, for the benefit of K&R. * demos/calc/calclex.l: Add for strcmp. * mpn/ia64/invert_limb.asm: Use .rodata which works on ia64-*-hpux* and should be standard, rather than worrying about RODATA. * gmp.texi (Function Classes): Add cross references. (Integer Import and Export): Fix return value grouping. * mpn/lisp/gmpasm-mode.el (gmpasm-comment-start-regexp): Add // for ia64. Add notes on what the various styles are for. * mpn/ia64/default.m4 (ASM_START): Define to empty, not dnl, so as not to kill text on the same line. (EPILOGUE_cpu): Force a newline after "#", so as not to suppress macro expansion in the rest of the EPILOGUE line. 2002-07-21 Kevin Ryde * tune/speed.h: Fix some missing _PROTOs. * Makefile.am (DISTCLEANFILES): Add configure.lineno. * acinclude.m4 (GMP_C_DOUBLE_FORMAT): Define HAVE_DOUBLE_IEEE_BIG_ENDIAN and HAVE_DOUBLE_IEEE_LITTLE_ENDIAN in config.m4 too. * mpn/ia64/invert_limb.asm: Add big-endian data. * tests/mpz/t-jac.c (try_si_zi): Correction to "a" parameter type. 2002-07-20 Kevin Ryde * mpz/bin_ui.c, mpz/jacobi.c, mpz/pprime_p.c, mpn/generic/divis.c: More care with long and mp_size_t parameters, for the benefit of K&R. * gmp-impl.h (invert_limb): Use parens around macro arguments. (mpn_invert_limb): Give prototype and define unconditionally. * gmp-impl.h (CACHED_ABOVE_THRESHOLD, CACHED_BELOW_THRESHOLD): New macros. * mpn/generic/sb_divrem_mn.c: Use them to help gcc let preinv code go dead when not wanted. 2002-07-17 Kevin Ryde * tests/refmpz.c (refmpz_hamdist): Ensure mp_size_t parameters are that type, for the benefit of hpux ia64 bundled cc ABI=64. * configure.in (ia64*-*-hpux*): Need +DD64 in cc_64_cppflags to get the right headers for ansi2knr. * acinclude.m4 (GMP_TRY_ASSEMBLE, GMP_ASM_UNDERSCORE): Use $CPPFLAGS with $CCAS and when linking, as done by the makefiles. (GMP_ASM_X86_MMX, GMP_ASM_X86_SSE2): Show $CPPFLAGS in diagnostics. * gmp-impl.h (ieee_double_extract): Setup using HAVE_DOUBLE_IEEE_*. (GMP_UINT32): New define, 32 bit type for ieee_double_extract. * configure.in: Add AC_CHECK_SIZEOF unsigned. * configure.in, acinclude.m4 (GMP_IMPL_H_IEEE_FLOATS): Remove. (GMP_C_DOUBLE_FORMAT): Instead warn about unknown float here. * configure.in, acinclude.m4 (GMP_C_SIZES): Remove. * acinclude.m4 (GMP_INCLUDE_GMP_H_BITS_PER_MP_LIMB): Remove this scheme, not required. * configure.in (unsigned long, mp_limb_t): Run AC_CHECK_SIZEOF for these unconditionally, check mp_limb_t against gmp-mparam.h values. * gmp-impl.h (BYTES_PER_MP_LIMB, BITS_PER_MP_LIMB): Define based on SIZEOF_MP_LIMB_T if not provided by gmp-mparam.h. (BITS_PER_ULONG): Define here now. * gmp.texi (ABI and ISA): Add HP-UX IA-64 choices. (Random State Initialization): Typo in m2exp described for gmp_randinit_lc_2exp_size. (Formatted Output Functions): Clarify gmp_obstack_printf a bit. (Formatted Input Strings): Typo in %n summary. * mpz/inp_raw.c (NTOH_LIMB_FETCH): Use simple generic default, since endianness detection is now cross-compile friendly. * mpz/out_raw.c (HTON_LIMB_STORE): Ditto. * mpz/fib_ui.c: Nailify. * mpz/random.c: Nailify. * mpfr/acinclude.m4 (MPFR_CONFIGS): Patch by Vincent for an apparent float rounding gremlin on powerpc. 2002-07-15 Kevin Ryde * Makefile.am (PRINTF_OBJECTS): Avoid ending in a backslash, hpux ia64 make doesn't like that. * configure.in (ia64*-*-*): Use ABI=64 on non-HPUX systems, for consistency. * gmp-impl.h (ieee_double_extract): Test __sparc__, used by gcc 3.1. Reported by nix@esperi.demon.co.uk. * mpfr/mpfr-math.h (_MPFR_NAN_BYTES etc): Ditto. 2002-07-13 Kevin Ryde * mpn/powerpc32/rshift.asm: Rewrite, transformed from lshift.asm. * tune/tuneup.c (DIVEXACT_1_THRESHOLD, MODEXACT_1_ODD_THRESHOLD): Always zero for native mpn_divexact_1, mpn_modexact_1_odd. * gmp-h.in (__GMP_EXTERN_INLINE): Don't use this during configure, ie. __GMP_WITHIN_CONFIGURE, to avoid needing dependent routines. * acinclude.m4 (GMP_H_EXTERN_INLINE): Consequent changes. * gmp-impl.h, mpn/asm-defs.m4 (mpn_addmul_2, mpn_addmul_3, mpn_addmul_4): Add prototypes and defines. * gmp.texi (Number Theoretic Functions): Clarify return value. Reported by Peter Keller. 2002-07-10 Kevin Ryde * configure.in, acinclude.m4 (GMP_PROG_LEX): Remove this in favour of AM_PROG_LEX, now ok when lex is missing. * longlong.h (count_leading_zeros) [pentiummmx]: Don't use __clz_tab variant under LONGLONG_STANDALONE. (count_trailing_zeros) [ia64 __GNUC__]: Use __builtin_ffs. * gmp-impl.h (popc_limb): Add an ia64 asm version. (DItype): Use HAVE_LONG_LONG to choose long long, avoiding _LONGLONG which is in gcc but means something unrelated in MS Visual C 7.0. Reported by David Librik. * mpz/divexact.c: Add an ASSERT that den divides num. * mpn/asm-defs.m4 (LDEF): New macro. (INT32, INT64): Use it. * mpn/pa32/*.asm: Use it. * mpn/pa32/README: Update notes on labels. * tests/refmpn.c, tests/tests.h, tests/t-bswap.c (ref_bswap_limb): Renamed from refmpn_bswap_limb. * tests/t-bswap.c: Add tests_start/tests_end for randomization. * tests/refmpn.c, tests/tests.h (ref_popc_limb): New function. * tests/t-popc.c: New file. * tests/Makefile.am: Add it. * mpn/ia64/invert_limb.asm: Use RODATA since ".section .rodata" is not accepted by ia64-*-hpux*. * acinclude.m4 (GMP_ASM_BYTE): New macro. (GMP_ASM_ALIGN_LOG, GMP_ASM_W32): Use it. (GMP_ASM_LABEL_SUFFIX): Use test compiles, not $host. (GMP_ASM_GLOBL): Ditto, and add .global for ia64-*-hpux*. (GMP_ASM_GLOBL_ATTR): Use GMP_ASM_GLOBL result, not $host. (GMP_ASM_LSYM_PREFIX): Allow any "a-z" nm symbol code, add ".text" to test program, required by ia64-*-hpux*. (GMP_ASM_LABEL_SUFFIX): Make LABEL_SUFFIX just the value, not a "$1:", the former being how it's currently being used in fact. * configure.in, acinclude.m4 (GMP_PROG_CC_WORKS_LONGLONG): New macro. * configure.in (ia64-*-hpux*): Add 32 and 64 bit ABI modes. 2002-07-06 Kevin Ryde * tests/cxx/t-allfuns.cc: New file. * tests/cxx/Makefile.am: Add it. * mpz/clrbit.c, mpz/setbit.c: Only MPN_NORMALIZE if high limb changes to zero. Use _mpz_realloc return value. * gmp.texi (Build Options, C++ Formatted Output, C++ Formatted Input): Cross reference to Headers and Libraries for libgmpxx stuff. (Low-level Functions): mpn_divexact_by3 result based on GMP_NUMB_BITS. mpn_set_str takes "unsigned char *", reported by Mark Sofroniou. (C++ Interface General): Describe linking with libgmpxx and libgmp. 2002-07-01 Kevin Ryde * tune/tuneup.c, gmp-impl.h: Eliminate the array of thresholds in one(), tune just one at a time and let the callers hand dependencies. Eliminate the second_start_min hack, handle SQR_KARATSUBA_THRESHOLD oddities in tune_sqr() instead. * mpn/pa64/umul.asm, mpn/pa64/udiv.asm, mpn/asm-defs.m4, acconfig.h, longlong.h, tune/speed.c, tune/speed.h, tune/common.c, tune/many.pl, tests/devel/try.c: Introduce mpn_umul_ppmm_r and mpn_udiv_qrnnd_r rather than having variant parameter order for mpn_umul_ppmm and mpn_udiv_qrnnd on pa64. * gmp-h.in (mpz_export): Remove a spurious parameter name. * gmp-impl.h (mpn_rootrem): Use __MPN. 2002-06-29 Kevin Ryde * longlong.h (udiv_qrnnd) [hppa32]: Remove mpn_udiv_qrnnd version, the general mechanism for that suffices. * mpf/inp_str.c: Fix returned count of chars read, reported by Paul Zimmermann. Also fix a memory leak for invalid input. * tests/mpf/t-inp_str.c: New file. * tests/mpf/Makefile.am (check_PROGRAMS): Add it. * tests/devel/try.c (mpn_mod_34lsub1): Only exists for GMP_NUMB_BITS%4==0. (SIZE2_FIRST): Respect option_firstsize2 for "fraction" case. * mpn/generic/diveby3.c: Further nailifications. * gmp-impl.h (MODLIMB_INVERSE_3): Allow for GMP_NUMB_BITS odd. (GMP_NUMB_CEIL_MAX_DIV3, GMP_NUMB_CEIL_2MAX_DIV3): New constants. * tests/t-constants.c: Check them. * gmp-h.in (__GMP_CRAY_Pragma): New macro. (__GMPN_COPY_REST): Use it. * gmp-impl.h (CRAY_Pragma): Use it. 2002-06-25 Kevin Ryde * mpz/import.c, mpz/export.c: Cast data pointer through "char *" in alignment tests, for the benefit of Cray vector systems. * configure.in (x86-*-*): Remove -march=pentiumpro check, seems ok with current code. * acinclude.m4 (GMP_GCC_MARCH_PENTIUMPRO, GMP_GCC_VERSION_GE): Remove macros, no longer needed * acinclude.m4 (GMP_ASM_RODATA): Remove temporary files. * configure.in (GMP_ASM_GLOBL_ATTR): Reposition to avoid duplication through AC_REQUIRE. 2002-06-23 Kevin Ryde * tests/mpz/t-fib_ui.c (check_fib_table): Check table values, not just that they're non-zero. * acinclude.m4 (GMP_GCC_ARM_UMODSI): Match bad "gcc --version" output exactly, rather than parsing it with GMP_GCC_VERSION_GE. (GMP_ASM_UNDERSCORE): Use GLOBL_ATTR. * mpn/pa32/udiv.asm, mpn/pa32/hppa1_1/udiv.asm, mpn/pa64/udiv.asm: Renamed from udiv_qrnnd.asm, for consistency with other udiv's. * mpn/pa64/umul.asm: Renamed from umul_ppmm.asm likewise. * configure.in (hppa*-*-*): Update extra_functions. (NAILS_SUPPORT): Remove umul_ppmm, udiv_qrnnd, udiv_fp, udiv_nfp from nails-neutral list, no longer needed. * gmp-h.in (__DECC): Add notes on testing this for ANSI-ness. (__GMP_EXTERN_INLINE): Add static __inline for DEC C. (mpz_mod_ui): Move up to main section, it's still documented. 2002-06-22 Kevin Ryde * mpz/jacobi.c, mpz/kronsz.c, mpz/kronuz.c, mpz/kronzs.c, mpz/kronzu.c: Allow for odd GMP_NUMB_BITS, tweak a few variable setups. * gmp-impl.h (JACOBI_STRIP_LOW_ZEROS): New macro. * mpn/generic/mod_34lsub1.c: Nailify. * tests/devel/try.c (CNST_34LSUB1): Nailify. * gmp-impl.h (ADDC_LIMB): New macro. * gmpxx.h (mpf_class::get_str): Make exponent mp_exp_t&, default base=10 and ndigits=0. (mpz_class::set_str, mpq_class::set_str, mpf_class::set_str): Add versions accepting "const char *". * mpfrxx.h (mpfr_class::get_str, mpfr_class::set_str): Ditto, and uncommenting set_str and operator=. * gmp.texi (C++ Interface Integers, C++ Interface Rationals) (C++ Interface Floats): Update. * gmp-impl.h (modlimb_invert): Merge the <=64bits and general versions. (const, signed): Move to near top of file, fixes --enable-alloca=debug on K&R. * gen-fib.c: New file, derived from mainline in mpn/generic/fib2_ui.c. * dumbmp.c (mpz_init_set_ui): New function. * Makefile.am, mpn/Makefile.am: Generate fib_table.h, mpn/fib_table.c. * gmp-impl.h: Use fib_table.h, add __GMP_DECLSPEC to __gmp_fib_table (for the benefit of tests/mpz/t-fib_ui.c). * mpn/generic/fib2_ui.c: Remove __gmp_fib_table and generating code. * Makefile.am: Add mp.h to BUILT_SOURCES, distclean all BUILT_SOURCES, use += more. * acinclude.m4 (GMP_ASM_M68K_INSTRUCTION, GMP_ASM_M68K_BRANCHES): Don't let "unknown" get into the cache variables. (GMP_ASM_TEXT): See what assembles, don't hard-code hpux and aix. (GMP_PROG_EXEEXT_FOR_BUILD): Add ,ff8 for RISC OS, per autoconf cvs. (GMP_PROG_CPP_FOR_BUILD): Restructure per AC_PROG_CPP, print correct result if CPP_FOR_BUILD overrides the cache variable. (GMP_PROG_CC_FOR_BUILD_WORKS): New macro split from GMP_PROG_CC_FOR_BUILD. Allow for "conftest" default compiler output. * configure.in, acinclude.m4 (GMP_PROG_HOST_CC): Reinstate this, separating HOST_CC establishment from GMP_PROG_CC_FOR_BUILD. * configure.in (mpn_objs_in_libgmp): Move mpn/mp_bases.lo ... * Makefile.am (MPN_OBJECTS): ... to here, add $U, and arrange MPN_OBJECTS to be common between libgmp and libmp. 2002-06-20 Torbjorn Granlund * mpn/generic/mul_n.c (TOOM3_MUL_REC, TOOM3_SQR_REC): Don't check if basecase is to be invoked when *_TOOM3_THRESHOLD is more than 3 times the corresponding *_THRESHOLD. 2002-06-20 Kevin Ryde * mpn/ia64/submul_1.c: Add missing TMP_DECL, TMP_MARK, TMP_FREE. Reported by Paul Zimmermann. * configure.in, acinclude.m4 (AC_DEFINE): Make templates read "Define to 1", for clarity as per autoconf. * acinclude.m4 (GMP_OPTION_ALLOCA): Group WANT_TMP templates. 2002-06-20 Gerardo Ballabio * gmpxx.h, mpfrxx.h: Remove mpz_classref, let mpq_class::get_num and mpq_class::get_den return mpz_class& as per the documentation. Reported by Roberto Bagnara. 2002-06-18 Kevin Ryde * tests/rand/t-lc2exp.c: New file. * tests/rand/Makefile.am: Add it, and use tests/libtests.la. * randraw.c (lc): Pad seed==0 case with zero limbs, return same (m2exp+1)/2 bits as normal, right shift "c" result as normal. * configure.in: Don't bother with line numbers in some diagnostics. (*-*-mingw*): Use -mno-cygwin if it works, suggested by delta trinity. * tests/mpz/Makefile.am, tests/mpq/Makefile.am, tests/misc/Makefile.am, (CLEANFILES): Set to *.tmp for test program temporaries, to get t-scanf.tmp and reduce future maintenance. 2002-06-16 Torbjorn Granlund * mpn/generic/get_str.c (mpn_dc_get_str): Pass scratch memory area in new `tmp' parameter. Trim allocation needs by reusing input parameter. 2002-06-15 Torbjorn Granlund * mpn/sparc32/v9/udiv.asm: New file. 2002-06-15 Kevin Ryde * acinclude.m4 (GMP_GCC_VERSION_GE): Correction to recognising mingw gcc 3.1 version number. Reported by Jim Fougeron. * configure.in (AC_PROVIDE_AC_LIBTOOL_WIN32_DLL): New define, to make AC_LIBTOOL_WIN32_DLL work with autoconf 2.53. * acinclude.m4 (GMP_C_SIZES): Establish BITS_PER_MP_LIMB as a value, not an expression, for the benefit of the gen-bases invocation. * config.guess (CC_FOR_BUILD): Try c99, same as configfsf.guess. 2002-06-15 Paul Zimmermann * mpfr/set_q.c: Allow for 1 bit numerator or denominator. 2002-06-14 Kevin Ryde * configure.in (AC_C_BIGENDIAN): Use new style action parameters. * randlc2x.c: Allow for a<0, allow for c>=2^m2exp. * randraw.c (lc): Allow for a==0. * mpn/sparc32/udiv.asm: Renamed from udiv_fp.asm. Don't know if float is the best way for v7, but it's what configure has chosen since gmp 3. * configure.in (*sparc*-*-* ABI=32): extra_functions="udiv" for all, in particular sparc32/v8/udiv.asm is faster (on ultrasparc2) than udiv_fp previously used for v9 chips. * gen-bases.c: New file, derived from mpn/mp_bases.c. * dumbmp.c: New file, mostly by Torbjorn, some by me. * configure.in, acinclude.m4 (GMP_PROG_CC_FOR_BUILD, GMP_PROG_CPP_FOR_BUILD, GMP_PROG_EXEEXT_FOR_BUILD, GMP_C_FOR_BUILD_ANSI, GMP_CHECK_LIBM_FOR_BUILD): New macros. (GMP_PROG_HOST_CC): Remove, superceded by GMP_PROG_CC_FOR_BUILD. * Makefile.am: Run gen-bases to create mp_bases.h and mpn/mp_bases.c. * gmp-impl.h: Use mp_bases.h. * mpn/mp_bases.c: Remove file. * mpn/Makefile.am: mp_bases.c now in nodist_libmpn_la_SOURCES. * tests/mpz/t-cmp_d.c (check_one_2exp): Use volatile to force to double, fixes gcc 3.1 with -O4. Reported by Michael Lee. * configure.in (AC_C_VOLATILE): New macro. * tests/misc/t-scanf.c: (fromstring_gmp_fscanf): Add missing va_end. Don't mix varargs and fixed args functions, not good on x86_64. Reported by Marcus Meissner. * Makefile.am (EXTRA_DIST): Remove mpfr/README, now in mpfr/Makefile.in * configure, config.in, INSTALL.autoconf: Update to autoconf 2.53. * */Makefile.in, install-sh, mdate-sh, missing, aclocal.m4, configure: Update to automake 1.6.1. * configfsf.guess, configfsf.sub: Update to 2002-05-29. 2002-06-12 Kevin Ryde * acinclude.m4 (GMP_GCC_VERSION_GE): Recognise mingw gcc 3.1 version. (GMP_PROG_CC_WORKS): Allow for a_out.exe, as per autoconf. (GMP_GCC_NO_CPP_PRECOMP, GMP_ASM_UNDERSCORE): Ditto, plus a.exe. 2002-06-09 Torbjorn Granlund * randraw.c (lc): Remove broken ASSERT_ALWAYS. * mpn/x86: Update gmp-mparam.h files with current measures *_THRESHOLD values. * mpn/x86/p6/mmx/gmp-mparam.h: New file. 2002-06-09 Kevin Ryde * mpn/x86/*/gmp-mparam.h (USE_PREINV_DIVREM_1): Add tuned settings. * acconfig.h (HAVE_NATIVE_mpn_preinv_divrem_1): New template. * tests/refmpn.c, tests/tests.h (refmpn_chars_per_limb, refmpn_big_base): New functions. * tests/mpn/t-mp_bases.c: Use them, and don't test big_base_inverted unless it's being used. * gmp.texi (Notes for Particular Systems): Using Microsoft C with DLLs. (Known Build Problems): Notes on MacOS and GCC. (Integer Logic and Bit Fiddling): Use ULONG_MAX for maximum ulong. (Low-level Functions): mpn_get_str accepts base==256. (Formatted Output Functions): Note output is not atomic. (Internals): Note mp_size_t for limb counts. * mp-h.in, gmp-h.in (mp_ptr, mp_srcptr, mp_size_t, mp_exp_t): Remove these types from mp.h, not needed. * mpfr/tests/tadd.c, mpfr/tests/tmul.c (check): Apply a hack to the parameter order to make sparc gcc 2.95.2 happy. * doc/configuration: Notes on bootstrapping. 2002-06-08 Kevin Ryde * mpfr/tests/tsqrt.c, mpfr/tests/tsqrt_ui.c: Suppress tests if sqrt is not affected by mpfr_set_machine_rnd_mode. * mpfr/mul_2si.c: Workaround a mips gcc 2.95.3 bug under -O2 -mabi=n32. * configure.in (alphev56): Fix to use ev5 path. 2002-06-06 Kevin Ryde * gmp-h.in: Use __gmp_const not const, in a number of places. * configure.in (sparc): Use ABI=32 instead of ABI=standard on v7 and v8, for consistency with v9 choices. (sparc64): Restrict GMP_ASM_SPARC_REGISTER to ABI=64. (x86): Move MMX $path munging to before printout. (CCAS): Move upward to support this. * gmp-impl.h (modlimb_invert): Merge macros for specific limb sizes, add a version for arbitrary limb size, use GMP_NUMB_BITS. (modlimb_invert, MODLIMB_INVERSE_3): Fix comments to say GMP_NUMB_BITS. * gmp-h.in (__GMP_LIKELY, __GMP_UNLIKELY): New macros. (mpz_getlimbn, mpz_perfect_square_p, mpz_popcount): Use them, make the fetch or mpn call likely, unconditionally calculate the alternative so as to avoid an "else" clause. * gmp-impl.h (LIKELY, UNLIKELY): Aliases. * configure.in, mpfr/tests/Makefile.am: Add $LIBM to $LIBS for MPFR_CONFIGS so it detects fesetround, and let it go through to $MPFR_LIBS. * mpfr/rnd_mode.c: Use gmp-impl.h to get MPFR_HAVE_FESETROUND. * tests/mpz/t-sizeinbase.c: Disable fake bits test, such pointer setups are bogus and have been seen failing on hppa. * tests/misc.c, tests/refmpz.c, tests.tests.h, tests/mpz/t-cong.c: Rename mpz_flipbit to refmpz_combit and move from misc.c to refmpz.c. 2002-06-05 Torbjorn Granlund * tests/mpz/t-powm_ui.c Print proper routine name in error message. 2002-06-03 Kevin Ryde * tune/time.c, tune/freq.c, tune/speed.h: Add powerpc mftb support. (FREQ_MEASURE_ONE): Move to speed.h, fix tv_sec factor. (freq_measure): Use for mftb measuring too. * tune/powerpc.asm, tune/powerpc64.asm: New files. * configure.in, tune/Makefile.am: Add them. * gmp-impl.h (popc_limb): Add versions for Cray and fallback for arbitrary limb size. * mpn/sparc32/sparc-defs.m4: New file. * configure.in (sparc*-*-*): Use it. * acinclude.m4 (GMP_ASM_SPARC_REGISTER): New macro. * configure.in (sparc64): Use it. Also, use -Wc,-m64 for linking. * mpn/sparc64/add_n.asm, mpn/sparc64/addmul_1.asm, mpn/sparc64/copyd.asm, mpn/sparc64/copyi.asm, mpn/sparc64/lshift.asm, mpn/sparc64/mul_1.asm, mpn/sparc64/rshift.asm, mpn/sparc64/sqr_diagonal.asm, mpn/sparc64/sub_n.asm, mpn/sparc64/submul_1.asm: Use REGISTER for .register. 2002-06-01 Kevin Ryde * mpz/powm_ui.c: Fix for result range in certain circumstances. * mpn/x86/k6/diveby3.asm: Speedup to 10 c/l, same as divexact_1. Anomaly pointed out by Alexander Kruppa. 2002-05-31 Torbjorn Granlund * mpz/export.c: Cast pointer via `unsigned long' when checking alignment to avoid compiler warnings. 2002-05-29 Kevin Ryde * gmp-impl.h (BSWAP_LIMB): Versions for m68k, powerpc, and arbitrary limb size. * configure.in, acconfig.h (HAVE_HOST_CPU_FAMILY_m68k): New define. 2002-05-27 Torbjorn Granlund * mpn/generic/mul_basecase.c: Improve MAX_LEFT handling, returning when possible. Add code for mpn_addmul_5 and mpn_addmul_6. 2002-05-25 Kevin Ryde * tune/tuneup.c: Misc nailifications, and disable preinv thresholds with nails. * tune/speed.h: Use GMP_NUMB_HIGHBIT with mpn_sb_divrem_mn and mpn_divrem_2. * mpz/powm.c (redc): Nailify q. * tests/mpn/t-scan.c: Reduce the amount of testing, to go faster. 2002-05-23 Torbjorn Granlund * Version 4.1 released. * mpn/alpha/ev6/nails/gmp-mparam.h: New file. * tests/devel/add_n.c (refmpn_add_n): Nailify. * tests/devel/sub_n.c (refmpn_sub_n): Nailify. * tests/devel/addmul_1.c (refmpn_addmul_1): Nailify. * tests/devel/submul_1.c (refmpn_submul_1): Nailify. * mpn/alpha/ev6/nails/add_n.asm: New file. * mpn/alpha/ev6/nails/sub_n.asm: New file. * mpn/alpha/ev6/nails/mul_1.asm: New file. * mpn/alpha/ev6/nails/submul_1.asm: New file. 2002-05-22 Torbjorn Granlund * mpn/alpha/ev6/nails/addmul_1.asm: New file. * mpz/inp_str.c (mpz_inp_str_nowhite): Nailify. * mpn/generic/mul_basecase.c: Update pointers before conditional MAX_LEFT break statements. 2002-05-21 Torbjorn Granlund * tests/mpz/t-gcd.c: Test mpz_gcd_ui. * mpz/lcm_ui.c: Nailify. * mpz/gcd_ui.c: Nailify. Make it work as documented, allowing NULL to be passed for result parameter. Fix gcd(0,0) case. * mpz/set_str.c: Nailify. * randlc2x.c (gmp_randinit_lc_2exp): Nailify. From Jakub Jelinek: * longlong.h (add_ssaaaa,sub_ddmmss) [64-bit sparc]: Make it actually work. 2002-05-18 Torbjorn Granlund * mpf/ui_div.c: Shut up compiler warning. * mpn/generic/mul_basecase.c: Use mpn_addmul_2, mpn_addmul_3, and mpn_addmul_4, as available. * mpn/alpha/ev6/nails/addmul_2.asm: Adjust NAILS_SUPPORT decls. * mpn/alpha/ev6/nails/addmul_3.asm: Likewise * mpn/alpha/ev6/nails/addmul_4.asm: Likewise. * configure.in (*-cray-unicos*): Back again to -hscalar0. (gmp_mpn_functions_optional): Add mul_3, mul_4, addmul_2, addmul_3, and addmul_4. * acconfig.h: Add #undefs for new optional mpn functions. 2002-05-18 Kevin Ryde * gmp.texi (Integer Import and Export): Mention Cray unfilled words. * mpz/set_d.c, mpq/set_d.c: Use LIMBS_PER_DOUBLE for the output of __gmp_extract_double. Reported by Henrik Johansson. 2002-05-17 Torbjorn Granlund * mpn/alpha/ev6/nails/addmul_2.asm: New file. * mpn/alpha/ev6/nails/addmul_3.asm: New file. * mpn/alpha/ev6/nails/addmul_4.asm: New file. * mpn/generic/dump.c: Rewrite and nailify. 2002-05-16 Kevin Ryde * mpfr/Makefile.am (EXTRA_DIST): Add BUGS file. 2002-05-15 Torbjorn Granlund * configure.in (*-cray-unicos*): Remove -hscalar0, add -hnofastmd as workaround for compiler bug. (mips64*-*-*): Pass just -O1 to cc, to work around compiler bug. 2002-05-14 Torbjorn Granlund * configure.in (*-cray-unicos*): Pass -hscalar0 to work around compiler bug for mpz/import.c. 2002-05-11 Torbjorn Granlund * mpz/import.c: Cast pointer via `unsigned long' when checking alignment to avoid compiler warnings. * mpn/generic/rootrem.c: Adjust allocation of qp temporary area. 2002-05-09 Kevin Ryde * mpz/import.c: Corrections to size store, special case tests, and general case ACCUMULATE. * tests/mpz/t-import.c, tests/mpz/t-export.c: More test data. 2002-05-09 Torbjorn Granlund * mpn/generic/rootrem.c: Use temp space for root, copy value in place before returning. * mpz/root.c: Don't allocate extra limb for root value. * mpz/perfpow.c: Undo last change. 2002-05-08 Torbjorn Granlund * gmp-impl.h (powerpc BSWAP_LIMB_FETCH): Rename local variable to make it not clash with caller. * mpn/generic/rootrem.c: New file. * configure.in (gmp_mpn_functions): Add rootrem and pow_1. * mpn/Makefile.am (nodist_libdummy_la_SOURCES): Add rootrem.c and pow_1.c * gmp-impl.h (mpn_rootrem): Add declaration. * mpz/perfpow.c: Amend allocations for mpn_rootrem requirements. * mpz/root.c: Rewrite to use mpn_rootrem. 2002-05-08 Kevin Ryde * gmp-impl.h (MUL_KARATSUBA_THRESHOLD etc): Remove forced nail values. * mpf/fits_u.h, mpf/fits_s.h, tests/mpf/t-fits.c: Ignore fraction part, making the code match the documentation. * gmpxx.h (struct __gmp_binary_minus): Use mpz_ui_sub. 2002-05-07 Kevin Ryde * mpn/powerpc32/README: New file. * mpz/root.c: Use unsigned long with mpz_sub_ui not mp_limb_t. * tune/README: Misc updates including sparc32/v9 smoothness, low res timebase, and mpn_add_n operand overlaps. * tune/many.pl: Add udiv.asm support. * gmp.texi (Build Options): A couple of --build better as --host. (Known Build Problems, Notes for Package Builds): Add DESTDIR problem. (Compatibility with older versions): Compatible with 4.x versions. (Converting Integers): Remove mpz_get_ui + mpz_tdiv_q_2exp decompose. (Integer Import and Export): New section. (Miscellaneous Integer Functions): Clarify mpz_sizeinbase returns 1 for operand of 0. (Language Bindings): Add GNU Pascal. (Low-level Functions): Add GMP_NUMB_MAX. * tests/mpz/t-import.c, tests/mpz/t-export.c, tests/mpz/t-get_d.c: New tests. * tests/mpz/Makefile.am: Add them. * mpz/import.c, mpz/export.c: New files. * Makefile.am, mpz/Makefile.am, gmp-h.in: Add them. * gmp-h.in, gmp-impl.h (GMP_NUMB_MAX): Move to gmp.h. * gmp-impl.h (CNST_LIMB): Add cast to mp_limb_t to ensure unsigned. (CRAY_Pragma, MPN_REVERSE, MPN_BSWAP, MPN_BSWAP_REVERSE, ASSERT_ALWAYS_LIMB, ASSERT_ALWAYS_MPN): New macros. (MPZ_CHECK_FORMAT): Use ASSERT_ALWAYS_MPN. 2002-05-07 Torbjorn Granlund * mpz/aors_ui.h: Nailify. * tests/mpz/t-addsub.c: New file. * tests/mpz/Makefile.am (check_PROGRAMS): Add t-addsub. * mpz/ui_sub.c: New file. * mpz/Makefile.am (libmpz_la_SOURCES): Add ui_sub.c. * Makefile.am (MPZ_OBJECTS): Ditto. * gmp-h.in (mpz_ui_sub): Add declaration. * gmp-impl.h (MPZ_REALLOC): Rewrite to allow the use of _mpz_realloc return value. * gmp-h.in (mpn_pow_1): Add declaration. * mpn/generic/pow_1.c: Handle exp <= 1. Reverse rp/tp parity scheme for bn == 1 arm. * Rename MP_LIMB_T_HIGHBIT => GMP_LIMB_HIGHBIT. 2002-05-06 Torbjorn Granlund * demos/pexpr.c (main): Don't call mpz_sizeinbase with negative base. * randraw.c (lc): Remove an unused variable. * mpn/generic/get_str.c: Clarify an algorithm description. * tests/mpf/t-trunc.c: Nailify. * tests/mpf/t-set_si.c: Disable for nails. * mpf/cmp_si.c: Nailify. * mpf/cmp_ui.c: Nailify. * mpf/div.c: Nailify. * mpf/div_2exp.c: Nailify. * mpf/div_ui.c: Nailify. * mpf/eq.c: Nailify. * mpf/get_d.c: Nailify. * mpf/get_d_2exp.c: Nailify. * mpf/get_si.c: Nailify. * mpf/get_str.c: Nailify. * mpf/get_ui.c: Nailify. * mpf/mul_2exp.c: Nailify. * mpf/random2.c: Nailify. * mpf/set_q.c: Nailify. * mpf/set_si.c: Nailify. * mpf/set_str.c: Nailify. * mpf/set_ui.c: Nailify. * mpf/sub.c: Nailify. * mpf/ui_div.c: Nailify. * mpf/ui_sub.c: Nailify. * mpf/urandomb.c: Nailify. * gmp-impl.h (__GMPF_BITS_TO_PREC, __GMPF_PREC_TO_BITS): Nailify. * mpz/get_si.c: Misc variable name changes. * mpf/fits_u.h: Rewrite - nailify. * mpf/fits_s.h: Likewise. * mpz/mod.c: Disambiguate if-statament with extra {}. * mpf/int_p.c: Fix type of size variables. * mpf/get_ui: Likewise. * mpf/get_si: Likewise. * mpq/equal.c: Likewise. * mpq/get_d.c: Likewise. * mpz/cmp_d.c: Likewise. * mpz/cmpabs_d.c: Likewise. * mpz/divis_2exp.c: Likewise. * mpz/kronuz.c: Likewise. * mpz/kronzu.c: Likewise. * mpz/kronzs.c: Likewise. * mpz/kronsz.c: Likewise. * mpz/scan0.c: Likewise. * mpz/scan1.c: Likewise. * mpz/tstbit.c: Likewise. * mpz/cong_2exp.c: Likewise. * mpz/divis.c: Likewise. 2002-05-04 Torbjorn Granlund * mpn/generic/gcd.c: Additional nailify changes. 2002-05-04 Kevin Ryde * gmp-h.in (__GNU_MP_VERSION): Set to 4.1. * Makefile.am (-version-info): Bump for new release. 2002-04-30 Torbjorn Granlund * mpn/generic/divrem_1.c: Additional nailify changes. * mpn/generic/mod_1.c: Likewise. * tests/mpq/t-get_d.c: Print floats with all 16 digits. * mpq/get_d.c: Nailify. * tests/mpq/t-set_f.c: Disable for nails. * mpz/get_d.c: Nailify. * gmp-impl.h (LIMBS_PER_DOUBLE, MP_BASE_AS_DOUBLE): Nailify. * gmp-h.in (__GMPZ_FITS_UTYPE_P): Cast maxval to before shifting it. * extract-dbl.c: Nailify. 2002-04-29 Torbjorn Granlund * mpq/md_2exp.c (mord_2exp): Nailify. * mpq/cmp_ui.c: Nailify. * mpq/cmp.c (mpq_cmp): Nailify. * mpn/generic/gcd.c: Nailify. GNUify code layout. * mpn/generic/gcdext.c: Nailify. Misc changes. * tests/mpz/t-sqrtrem.c: Let argv[1] mean # of repetitions. * tests/mpz/t-gcd.c: Likewise. * mpz/gcd.c: Nailify. * mpn/generic/random.c: Nailify. * gmp-impl.h (modlimb_invert): Nailify. 2002-04-27 Torbjorn Granlund * mpn/generic/gcdext.c (div2): Remove qh parameter. (mpn_gcdext): Streamline double-limb code. Move GCDEXT_THRESHOLD check to after initial division. 2002-04-27 Kevin Ryde * gmp-impl.h (JACOBI_MOD_OR_MODEXACT_1_ODD): Allow for odd GMP_NUMB_BITS. * tune/time.c (sgi_works_p): Allow for 64-bit counter, and fix SGI_CYCLECNTR_SIZE handling. * demos/expr/exprfr.c: Add nan and inf constants. * demos/expr/t-expr.c: Exercise them. 2002-04-26 Torbjorn Granlund * mpz/cmp_ui.c: Fix overflow conditions for nails. * gmp-h.in (mpz_get_ui): Fix typo from last change. * mpz/n_pow_ui.c: Adjust allocation for nails. (GMP_NUMB_HALFMAX): Renamed from MP_LIMB_T_HALFMAX. Fix umul_ppmm invocation for for nails. 2002-04-24 Torbjorn Granlund * mpn/generic/gcdext.c: Simplify by using mpn_tdiv_qr instead of mpn_divmod. 2002-04-24 Kevin Ryde * configure.in (*-*-cygwin*): Give a sensible default command line limit, to avoid blowups reported by Jim Fougeron on windows 9x. (--enable-nails): Make the default 2, since mp_bases has data for that. * mpfr/mpfr-math.h (__mpfr_nan): Use a "double" for the bytes, to avoid a mis-conversion on alpha gcc 3.0.2. (_MPFR_INFP_BYTES, _MPFR_INFM_BYTES): Should be a zero mantissa. 2002-04-23 Torbjorn Granlund * mpz/dive_ui.c: Fix typo. * mpz/fits_s.h: Rewrite. * mpz/jacobi.c: Nailify. * mpz/kronuz.c: Additional nailify changes. * mpz/kronsz.c: Likewise. 2002-04-23 Kevin Ryde * demos/expr/Makefile.am (LDADD): Add $(LIBM) for the benefit of mpfr. * mpz/divis_ui.c, mpz/cong_ui.c: Nailify. * mpn/generic/bdivmod.c, mpz/divexact.c, mpz/dive_ui.c: Nailify. * mpn/generic/sb_divrem_mn.c, mpn/generic/divrem.c, mpn/generic/divrem_2.c: Nailify ASSERTs. * mpn/x86/k6/mmx/logops_n.asm, mpn/x86/k6/mmx/com_n.asm: Nailify. * mpz/inp_raw.c, mpz/out_raw.c: Nailify. * mpz/kronzu.c, mpz/kronuz.c, mpz/kronzs.c, mpz/kronsz.c: Nailify. * mpn/generic/divis.c, mpz/cong.c, mpz/cong_2exp.c: Nailify. * gmp-impl.h (NEG_MOD): Nailify. * gmp-impl.h, mpn/mp_bases.c: Add back GMP_NUMB_BITS==30 bases data. * mpfr/get_d.c: Patch from Paul to avoid problem with constant folding in gcc on OSF. * mpn/lisp/gmpasm-mode.el: Remove mention of defunct LF macro. 2002-04-22 Torbjorn Granlund * demos/pexpr.c: Handle "binomial" operator. * mpz/cmp_ui.c: Move assignments of `up' out of conditionals. * mpn/generic/gcdext.c: Fix fencepost error in STAT code. * gmp-impl.h (mpn_com_n): Nailify. * tests/mpz/t-cdiv_ui.c: New file. * tests/mpz/Makefile.am (check_PROGRAMS): Add t-cdiv_ui. * mpz/cdiv_qr_ui.c: Nailify. * mpz/cdiv_q_ui.c: Nailify. * mpz/cdiv_r_ui.c: Nailify. * mpz/cdiv_ui.c: Nailify. * tests/misc/t-printf.c (CHECK_N): Add cast to allow `char' to be an unsigned type. * tests/misc/t-scanf.c: Likewise. * mpz/mul_i.h: Rework nails code to handle parameter overlap. * tests/mpz/t-set_f.c: Disable for nails. 2002-04-21 Torbjorn Granlund * mpz/set_si.c: Add cast to support LONG_LONG_LIMB. * mpz/iset_si.c: Likewise. * mpz/bin_ui.c: Nailify. * mpz/bin_uiui.c: Nailify. * mpz/cmpabs_ui.c: Nailify. * tests/mpz/t-aorsmul.c: Nailify. * mpz/aorsmul_i.c (mpz_addmul_ui, mpz_submul_ui): Nailify better. 2002-04-20 Torbjorn Granlund * tests/mpz/t-fdiv_ui.c: Check mpz_fdiv_ui. * tests/mpz/t-tdiv_ui.c: Check mpz_tdiv_ui. * mpz/tdiv_ui.c: Rewrite nails code. * mpz/fdiv_ui.c: Nailify. * tests/mpz/t-tdiv_ui.c: Check returned remainders. * tests/mpz/t-fdiv_ui.c: Merge in recent t-tdiv_ui changes. * mpz/tdiv_q_ui.c: Remove spurious TMP_* calls. * mpz/fdiv_qr_ui.c: Nailify. * mpz/fdiv_q_ui.c: Nailify. * mpz/fdiv_r_ui.c: Nailify. * mpz/get_si.c: Misc nailify changes to shut up compiler warnings. * mpz/ui_pow_ui.c: Fix typo in last change. 2002-04-20 Kevin Ryde * tests/misc/t-printf.c, tests/misc/t-scanf.c: Check all %n types. * mpn/x86/k7/mmx/divrem_1.asm, mpn/x86/p6/mmx/divrem_1.asm (mpn_preinv_divrem_1): New entrypoint. (mpn_divrem_1): Avoid a branch when testing high * tests/mpz/t-scan.c: Nailify. * mpz/tdiv_qr_ui.c: Nailify. * mpz/tdiv_q_ui.c: Nailify. * mpz/tdiv_r_ui.c: Nailify. * mpz/tdiv_ui.c: Nailify. * mpz/cmp_ui.c: Nailify. * mpz/ui_pow_ui.c: Misc nailify changes to shut up compiler warnings. * mpz/scan0.c: Nailify. * mpz/scan1.c: Nailify. * tests/mpz/t-sizeinbase.c (mpz_fake_bits): Nailify. 2002-04-18 Torbjorn Granlund * mpz/aorsmul_i.c: Nailify. * mpz/cmp_si.c: Nailify (botched). * mpz/ui_pow_ui.c: Nailify. * gmp-h.in (__GMPZ_FITS_UTYPE_P): Nailify. * mpz/fits_s.h: Nailify. * tests/mpz/bit.c (check_tstbit): Nailify. From Paul Zimmermann: * mpn/generic/sqrtrem.c: Nailify. * mpz/n_pow_ui.c: Nailify. * mpz/cfdiv_r_2exp.c: Nailify. * randraw.c (lc): Undo: Let mpn_rshift put result in place to avoid extra MPN_COPY. 2002-04-17 Torbjorn Granlund * mpz/clrbit.c: Add two GMP_NUMB_MASK masks after addition. * mpn/generic/random2.c (LOGBITS_PER_BLOCK): Decrease to 4. * gmp-impl.h (nail DIV_DC_THRESHOLD): Decrease to 50 to allow fast division. * mpn/generic/random2.c: Nailify. * mpz/fac_ui.c: Nailify. * mpz/mul_i.h: #if ... #endif code block to shut up gcc warnings. * mpn/generic/sqrtrem.c: Adopt to GNU coding standards. (mpn_dc_sqrtrem): New name for mpn_dq_sqrtrem. Partial nailification. * configure.in: As a temporary hack, clear extra_functions for nails builds. * gmp-h.in (mpz_get_ui): #if ... #endif else code block to shut up gcc warnings. 2002-04-17 Kevin Ryde * texinfo.tex: Update to 2002-03-26.08 per texinfo 4.2. * gmp.texi: Must have @top in @ifnottex (or @contents doesn't come out in one run). * mpn/generic/scan0.c, mpn/generic/scan1.c: Nailify. * tests/mpn/t-scan.c: New file. * tests/mpn/Makefile.am (check_PROGRAMS): Add it. * tests/refmpn.c, tests/tests.h (refmpn_tstbit): Use unsigned long for bit index. (refmpn_setbit, refmpn_clrbit, refmpn_scan0, refmpn_scan1): New functions. * mpfr/cmp_ui.c (mpfr_cmp_si_2exp): Fix b==0 i!=0 case. 2002-04-17 Gerardo Ballabio * gmpxx.h, mpfrxx.h: Remove mpfr_class bool combinations, remove mpfr_class::get_str2, use mp_rnd_t for rounding modes, use 8*sizeof(double) for mpfr_t's holding doubles. 2002-04-17 Torbjorn Granlund * mpz/powm.c: Nailify. * mpz/powm_ui.c: Nailify. 2002-04-16 Torbjorn Granlund * mpz/hamdist.c: Nailify. * tests/misc.c (urandom): Nailify. * mpz/get_si.c: Nailify. * gmp-h.in (mpz_get_ui): Nailify. Streamline (and probably upset memory checkers). * gmp-impl.h (mp_bases[10] values): Add versions for GMP_NUMB_BITS being 28, 60, and 63. * mpn/mp_bases.c: Add tables for GMP_NUMB_BITS being 28, 60, and 63. * mpz/iset_si.c: Nailify. * mpz/iset_ui.c: Nailify * tests/mpz/convert.c (main): Print test number in error message. * mpn/generic/get_str.c (mpn_sb_get_str): Shift up `frac' into nails field after bignum division. 2002-04-16 Kevin Ryde * gmp-h.in, gmp-impl.h (GMP_NAIL_MASK): Move to gmp.h. * gmp.texi: Use @documentdescription and @copying, per texinfo 4.2. (Low-level Functions): Clarify mpn_gcd overlap requirements, rewrite mpn_set_str description, add nails section. (C++ Interface General): Remove bool from types that mix with classes. (Language Bindings): Add STklos, GNU Smalltalk, Regina. (Binary to Radix, Radix to Binary): Describe new code. (Assembler Cache Handling): More notes, mostly by Torbjorn. * macos/configure (%vars): Remove __GMP from substitutions, per change to main configure. * mpn/generic/dive_1.c: Nailify. * mpn/generic/mode1o.c: Nailify, remove bogus ASSERT in commented-out alternate implementation. * gmp-impl.h (SUBC_LIMB): New macro. * tests/devel/try.c (validate_divexact_1): Correction to compare. (udiv_qrnnd): New testing. (SHIFT_LIMIT): Nailify. (-b): New option, remove spurious "H" from getopt string. * mpz/clrbit.c: Nailify. * tests/mpz/t-hamdist.c: Nailify. * gmp-impl.h (MPN_FIB2_SIZE): Nailify. (PP): Nailify conditionals. * tests/mpz/t-fib_ui.c (MPZ_FIB_SIZE_FLOAT): Nailify. * configure.in, acinclude.m4: Establish GMP_NAIL_BITS and GMP_LIMB_BITS for gmp-h.in configure tests. * mpfr/*, configure.in: Update to final mpfr 2.0.1. * mpfr/acinclude.m4 (MPFR_CONFIGS): Use $host, not uname stuff. * mpfr/tests/tout_str.c: Patch from Paul for denorm fprintf tests. 2002-04-15 Torbjorn Granlund * mpn/generic/divrem_1.c (EXTRACT): Remove. * tests/mpz/t-tdiv_ui.c (dump_abort): Accept argument for error string. * mpz/rrandomb.c: Nailify. Needs further work. * mpn/generic/mod_1.c: Nailify. * gmp-impl.h: Set various *_THRESHOLD values to be used for nails to avoid not yet qualified algorithms. (MPZ_CHECK_FORMAT): Check that nail part is zero. * tests/mpz/t-mul.c (main): Test squaring even for huge operands. (base_mul): Nailify. (dump_abort): Accept argument for error string. Print product difference. * mpn/generic/set_str.c: Nailify. * gmp-h.in (__GMPN_ADD, __GMPN_SUB): Nailify. 2002-04-14 Torbjorn Granlund * randraw.c (lc): Return non-nonsense return value for seed=0 case. Check for m2exp being non-zero early; remove all other tests of m2exp. Remove redundant MPN_ZERO call. Let mpn_rshift put result in place to avoid extra MPN_COPY. Remove confusing comment before function `lc' describing BBS algorithm. Misc simplification and cleanups. Nailify. Needs further work. * mpz/set_si.c: Nailify. * mpz/set_ui.c: Nailify. * mpz/mul_i.h: Nailify. * tests/mpz/t-mul_i.c: Actually test _ui routines. Add some more test values. * mpn/generic/mul_n.c: Finish nailifying toom3 code. 2002-04-13 Kevin Ryde * mpfr/*: Update to another new mpfr 2.0.1. * configure.in, Makefile.am, mpfr/Makefile.am, mpfr/tests/Makefile.am: Use MPFR_CONFIGS macro, establish separate MPFR_CFLAGS for mpfr build. * mpfr/tests/Makefile.am: Correction to convenience rule for libmpfr.a. 2002-04-11 Kevin Ryde * mpfr/set_q.c: gmp-impl.h before mpfr.h to avoid _PROTO redefine. * mpfr/*, configure.in: Update to new mpfr 2.0.1. * tests/refmpn.c (refmpn_udiv_qrnnd, refmpn_divmod_1c_workaround): Fixes for nails. * tests/t-constants.c (MODLIMB_INVERSE_3): Nailify tests. (MP_BASES_BIG_BASE_INVERTED_10, MP_BASES_NORMALIZATION_STEPS_10): Only check these under USE_PREINV_DIVREM_1. * tests/t-modlinv.c: Nailify tests. 2002-04-11 Gerardo Ballabio * gmpxx.h: Remove bool combinations, remove mpf_class::get_str2, only need now. 2002-04-11 Torbjorn Granlund * mpn/generic/diveby3.c: Nailify. * gmp-impl.h (MODLIMB_INVERSE_3): Nailify. * mpn/generic/mul_n.c: Nailify Toom3 code. 2002-04-10 Kevin Ryde * gmp-impl.h (MPN_KARA_MUL_N_MINSIZE, MPN_KARA_SQR_N_MINSIZE): Set to 3, as needed by nails case. * mpn/generic/addmul_1.c, mpn/generic/submul_1.c [nails]: Fix vl assert, add rp,n and up,n asserts. * mpfr/Makefile.am: Add new mpfr-math.h, install mpf2mpfr.h. 2002-04-10 Torbjorn Granlund * mpn/generic/divrem_1.c: Nailify. Update mp_size_t variables to use `n' suffix instead of `size' suffix. * mpn/generic/divrem_2.c: Likewise. * mpn/generic/sb_divrem_mn.c: Nailify. * mpn/generic/tdiv_qr.c: Nailify. (SHL): Remove silly macro. * mpn/generic/mul_n.c (mpn_kara_mul_n): Replace open-coded increment by mpn_incr_u call. Handle nails in ws[n] increment. * mpn/generic/mul_n.c (mpn_kara_sqr_n): Likewise. * gmp-h.in (GMP_NUMB_MASK): New #define. (__GMPN_AORS_1): Add version for nails. * gmp-impl.h (GMP_NUMB_MASK): Comment out, now in gmp.h. (mpn_incr_u): Don't assume `incr' is non-zero. (mpn_decr_u): Similarly. 2002-04-09 Kevin Ryde * mpfr/*, configure.in: Update to mpfr 2.0.1. * tests/refmpn.c (refmpn_mul_1c, lshift_make): Corrections for nails. * tssts/refmpn.c, tests/tests.h (refmpn_cmp_allowzero): New function. * mpn/generic/mul_1.c [nails]: Fix vl assert, add {up,n} assert. * mpn/pa32/hppa1_1/pa7100/addmul_1.asm, mpn/pa32/hppa1_1/pa7100/submul_1.asm: Rename "size" define, to avoid ELF .size directive. Reported by LaMont Jones. * tests/mpz/t-set_si.c: Add nails support. 2002-04-05 Torbjorn Granlund * gmp-impl.h: Replace nail mpn_incr_u, mpn_decr_u with faster versions. (mp_bases[10] values): Check GMP_NUMB_BITS instead of BITS_PER_MP_LIMB. Add GMP_NUMB_BITS == 30 version. (__gmp_doprnt, etc): Remove parameter names. * mpn/generic/mul_n.c: Nailify Karatsuba code. * mpn/generic/get_str.c: Nailify. * mpn/generic/sqr_basecase.c: Nailify. * mpn/generic/lshift.c: Nailify. * mpn/generic/rshift.c: Likewise. * mpn/generic/add_n.c: Nailify. Revamp non-nail code. * mpn/generic/sub_n.c: Likewise. * mpn/generic/mul_1.c: Likewise. * mpn/generic/addmul_1.c: Likewise. * mpn/generic/submul_1.c: Likewise. 2002-04-02 Kevin Ryde * gmp-impl.h (BSWAP_LIMB_FETCH, BSWAP_LIMB_STORE) [powerpc]: Corrections to constraints, and restrict to bigendian. 2002-03-31 Kevin Ryde * tests/mpz/dive.c: Better diagnostics. * tests/devel/try.c (mpn_get_str, mpn_umul_ppmm_r): New tests. * tests/misc.c, tests/tests.h (byte_diff_lowest, byte_diff_highest): New functions. * tests/t-bswap.c: New file. * tests/Makefile.am (check_PROGRAMS): Add it. * tests/mpn/t-aors_1.c, tests/mpn/t-iord_u.c: Add nails support. * gmp-impl.h (MPN_IORD_U) [x86]: Eliminate unnecessary jiord and iord, rename "n" to incr per generic versions, restrict to nails==0. (mpn_incr_u, mpn_decr_u): Add nails support. (GMP_NAIL_LOWBIT, GMP_NUMB_MAX): New macros. * tests/trace.c, tests/tests.h (byte_trace, byte_tracen): New functions. * tests/trace.c: Handle NULL operands. * tests/refmpn.c, tests/devel/try.c, tune/speed.c: Add preliminary nail support. * tests/refmpn.c, test/tests.h (byte_overlap_p, refmpn_equal_anynail, refmpn_umul_ppmm_r, refmpn_udiv_qrnnd_r, refmpn_get_str, refmpn_bswap_limb, refmpn_random, refmpn_random2, refmpn_bswap_limb): New functions. * gmp-impl.h, tests/refmpn.c (ASSERT_LIMB): Renamed from ASSERT_MP_LIMB_T. * mpn/x86/*/*.asm, mpn/powerpc32/*/*.asm, mpn/powerpc64/*/*.asm: Put speeds after the copyright notice, so as to keep that clear. 2002-03-29 Kevin Ryde * configure.in (powerpc*-*-aix*): Correction to xlc -qarch selection, for 32-bit mode. 2002-03-28 Torbjorn Granlund * mpn: Fix spacing in many files. * mpn/generic/aorsmul_1.c: Split into addmul_1.c and submul_1.c. * mpn/generic/aors_n.c: Split into add_n.c and sub_n.c. * mpn/pa64/add_n.asm: Trim another 0.125 cycle/limb. Fix a comment. * mpn/pa64/sub_n.asm: Likewise. * mpn/pa64/mul_1.asm: Change comclr, comb to proper forms cmpclr, cmpb. * mpn/pa64/addmul_1.asm: Likewise. * mpn/pa64/submul_1.asm: Likewise. 2002-03-28 Kevin Ryde * gmp.texi (Converting Integers): Fix type of exp in mpz_get_d_2exp, reported by epl@unimelb.edu.au. (References): Update Burnikel and Ziegler URL, reported by Keith Briggs. * gmp-h.in, mp-h.in, configure.in, acinclude.m4: Remove __GMP from AC_SUBSTs, since autoconf says leading "_" in makefile variables is not portable. * demos/expr/run-expr.c: Declare optarg, optind, opterr if necessary. * configure.in, demos/expr/expr-config-h.in: Configs for this. 2002-03-27 Torbjorn Granlund * mpn/Makefile.am (TARG_DIST): Remove pa64w and hppa, add pa32. * configure.in (path_20w): Remove pa64w. * mpn/pa64/udiv_qrnnd.asm: Tweak for PA8000 performance comparative to that on PA8500. 2002-03-26 Torbjorn Granlund * mpn/pa32: New name for mpn/hppa. * configure.in: Corresponding changes. * mpn/pa64/umul_ppmm.asm: New file, generalized for both 2.0N and 2.0W. * mpn/pa64/umul_ppmm.S: Remove. * mpn/pa64/udiv_qrnnd.asm: Generalize for both 2.0N and 2.0W. * mpn/pa64w/udiv_qrnnd.asm: Remove. 2002-03-26 Kevin Ryde * mpfr/tests/tdiv.c, mpfr/tests/tui_div.c: Don't depend on nan and inf handling in "double", for the benefit of alpha. * configure (hppa2.0w): Set path to "pa64w pa64". * acinclude.m4, configure.in (GMP_C_INLINE): New macro. * acinclude.m4 (GMP_H_EXTERN_INLINE): Use it, and fix "yes" handling. 2002-03-25 Torbjorn Granlund * mpn/pa64w/add_n.s: Remove. * mpn/pa64w/sub_n.s: Remove. * mpn/pa64w/lshift.s: Remove. * mpn/pa64w/rshift.s: Remove. * mpn/pa64w/mul_1.S: Remove. * mpn/pa64w/addmul_1.S: Remove. * mpn/pa64w/submul_1.S: Remove. * mpn/pa64w/sqr_diagonal.asm: Remove. * mpn/pa64/mul_1.asm: New file with twice faster code; generalized for both 2.0N and 2.0W. * mpn/pa64/submul_1.asm: Likewise. * mpn/pa64/mul_1.S: Remove. * mpn/pa64/submul_1.S: Remove. * mpn/pa64/sqr_diagonal.asm: Generalize for both 2.0N and 2.0W. * mpn/pa64/add_n.asm: New file, generalized for both 2.0N and 2.0W. * mpn/pa64/sub_n.asm: Likewise. * mpn/pa64/lshift.asm: Likewise. * mpn/pa64/rshift.asm: Likewise. * mpn/pa64/add_n.s: Remove. * mpn/pa64/sub_n.s: Remove. * mpn/pa64/lshift.s: Remove. * mpn/pa64/rshift.s: Remove. 2002-03-24 Kevin Ryde * gmp-impl.h (BSWAP_LIMB_FETCH, BSWAP_LIMB_STORE): New macros. * mpz/inp_raw.c, mpz/out_raw.c: Use them. * acconfig.h (HAVE_HOST_CPU): Add some powerpc types. * mpn/powerpc32/750/com_n.asm: New file. * mpfr/tests/tout_str.c: Disable random tests, since they fail on alphaev56-unknown-freebsd4.1 and do nothing by default. * mpfr/tests/tsqrt.c: Don't depend on nan, inf or -0 in "double", for the benefit of alpha. * mpfr/sqrt.c: Clear nan flag on -0. * demos/factorize.c: Use mpn_random() instead of random(), to avoid portability problems. * demos/isprime.c (print_usage_and_exit): Declare as "void" to avoid warnings. * demos/pexpr.c (setup_error_handler): Corrections to sigstack code. * demos/calc/calc.y: Add some `;'s to make bison 1.34 happy. 2002-03-23 Torbjorn Granlund * mpn/pa64/addmul_1.asm: New file with twice faster code; generalized for both 2.0N and 2.0W. 2002-03-22 Kevin Ryde * tune/time.c: Add SGI hardware counter measuring method, change some abort()s into ASSERT_FAIL()s. * configure.in (AC_CHECK_HEADERS): Add fcntl.h and sys/syssgi.h. (AC_CHECK_FUNCS): Add syssgi. * configure.in, mpfr/Makefile.am, mpfr/tests/Makefile.am: Use -mieee-with-inexact or -ieee_with_inexact for mpfr on alpha, so denorms work. * mpfr/isinteger.c: Fix a memory leak. 2002-03-21 Torbjorn Granlund * tune/speed.c (struct choice_t): Make `r' an mp_limb_t. 2002-03-21 Kevin Ryde * configure.in (HAVE_LIMB_BIG_ENDIAN, HAVE_LIMB_LITTLE_ENDIAN): Use an AH_VERBATIM and better explanation. * acinclude.m4 (GMP_C_DOUBLE_FORMAT): Similarly for the HAVE_DOUBLE constants. * gmp.texi (Number Theoretic Functions): Clarify sign of GCD returned by mpz_gcdext. * demos/pexpr.c, demos/pexpr-config-h.in, configure.in: Use an autoconf test for stack_t. * configure.in, gmp-h.in, mp-h.in, macos/configure, tests/mpz/reuse.c, tests/mpf/reuse.c: Use __GMP_LIBGMP_DLL to enable windows declspec, don't require _WIN32 (etc), remove __GMP_LIBGMP_SHARED and __GMP_LIBGMP_STATIC. * gmp-impl.h (mp_bases): Add __GMP_DECLSPEC, for the benefit of tests/t-constants.c. * tune/many.pl, tune/speed.h: Remove suffix hack for back.asm. 2002-03-21 Paul Zimmermann * mpfr/sin_cos.c (mpfr_sin_cos): New file. * mpfr/mpfr.h, mpfr/mpfr.texi, mpfr/Makefile.am: Add it. * mpfr/tan.c: Fix sign in 2nd and 4th quadrants. * mpfr/log10.c: Fix hangs on certain inputs. 2002-03-20 Torbjorn Granlund * demos/pexpr.c (setup_error_handler): Declare `s', the first sigaltstack parameter, using `stack_t' just on AIX. 2002-03-19 Torbjorn Granlund * mpn/powerpc32/mul_1.asm: Use free caller-saves registers instead of the callee-saves r30 and r31. 2002-03-19 Kevin Ryde * tune/freq.c (freq_proc_cpuinfo): Recognise powerpc "clock", where previously got the wrong result from "bogomips". * mpn/powerpc32/add_n.asm, mpn/powerpc32/sub_n.asm: Rewrite, faster on 750, and smaller too. * mpn/powerpc32/*.asm: Use L(), add some measured speeds. * longlong.h (count_trailing_zeros) [vax]: Add a version using ffs, but commented out. 2002-03-17 Kevin Ryde * tune/speed.c, tune/speed.h, tune/common.c, many.pl: Use optional ".r" to specify operand overlaps for mpn_add_n, mpn_sub_n and logops. Remove mpn_add_n_inplace and mpn_add_n_self. * tune/many.pl: Fix MULFUNC_PROLOGUE parsing. * gmp.texi (Known Build Problems): Note `make' problem with long libgmp.la dependencies list. * printf/doprnt.c, scanf/doscan.c (%zn): Remove test of non-existent HAVE_SIZE_T, just use size_t unconditionally. * printf/doprnt.c (%zd etc): Fix 'z' type parsing. * tests/misc/t-printf.c, tests/misc/t-scanf.c: More tests. * configure.in: Use AC_COPYRIGHT. Add m4_pattern_allow(GMP_MPARAM_H_SUGGEST). * tune/Makefile.am (libdummy.la): Remove this, sqr_basecase.c already gets an ansi2knr rule from nodist_tuneup_SOURCES. * longlong.h (count_leading_zeros) [pentiumpro gcc<3]: Test HAVE_HOST_CPU_i686 too. * mpz/out_raw.c (HTON_LIMB_STORE): Fix a typo in big endian #if. 2002-03-14 Kevin Ryde * mpn/x86/pentium/com_n.asm, mpn/x86/pentium/logops_n.asm, mpn/x86/k6/mmx/com_n.asm: Add nails support. * texinfo.tex: Update to 2002-03-01.06 (per texinfo 4.1). * gmp.texi (@ma): Remove, @math does this now. * mpfr/tests/reuse.c: Clear op1 and op2 flags only in their respective outer loops. * configure.in (--enable-cxx): Correction to the default stated in the help string. (power*-*-aix*, not powerpc): Use aix.m4, don't run GMP_ASM_POWERPC_R_REGISTERS or use powerpc-defs.m4. 2002-03-13 Torbjorn Granlund * mpn/sparc32/gmp-mparam.h: New file. 2002-03-13 Kevin Ryde * demos/expr/exprfr.c: More mpfr functions, corrections to agm, cos, sin, rename log2 constant to loge2 to make room for log2 function. * demos/expr/t-expr.c: More tests. * mpz/inp_raw.c (NTOH_LIMB_FETCH) [generic 16bit]: Remove spurious "+". * mpfr/acos.c: Avoid a memory leak for certain operands. * acinclude.m4, configure.in (GMP_C_DOUBLE_FORMAT): New macro. * acinclude.m4 (GMP_HPC_HPPA_2_0, GMP_ASM_UNDERSCORE, GMP_ASM_ALIGN_LOG, GMP_ASM_LSYM_PREFIX, GMP_ASM_W32, GMP_ASM_X86_MMX): Change ac_objext to OBJEXT, which is the documented variable. * config.guess (powerpc*-*-*): Use #ifdef on constants POWER_630 etc in the AIX test, since old versions don't have them all. 2002-03-11 Kevin Ryde * configure.in (LIBC211): New AC_DEFINE, for mpfr. * configure.in (mips*-*-*): Support ABI=o32 on irix 6, allow gcc 2.7.2 to fall back on it, but detect it doesn't work with gcc 2.95. Use single mips-defs.m4 for both mips32 and mips64. * acinclude.m4 (GMP_GCC_MIPS_O32): New macro. * mpn/mips32/mips-defs.m4: Renamed from mips.m4. * mpn/mips64/mips.m4: Remove (was a copy of mips32/mips.m4). * mpn/powerpc32/750: New directory. * configure.in (powerpc740, powerpc750, powerpc7400): Use it. * mpn/powerpc32/750/gmp-mparam.h: New file. * config.sub, gmp.texi (ultrasparc1): Remove this, just use plain "ultrasparc". 2002-03-10 Kevin Ryde * mpfr: Update to 20020301, except internal_ceil_exp2.c, internal_ceil_log2.c, internal_floor_log2.c renamed to i_ceil_exp2.c, i_ceil_log2.c, i_floor_log2.c to be unique in DOS 8.3. And sqrtrem.c removed since no longer required. * mpfr/mpfr.texi: Fix some formatting. * mpfr/tests/reuse.c: Patch by Paul to fix test4 variable handling. * mpfr/sinh.c: Patch by Paul to fix err calculation when t==0. * mpfr/tests/tget_d.c: Disable until portability of rnd_mode.c can be sorted out. * configure.in (powerpc*-*-*): Separate gcc and xlc cpu flags setups for clarity. * longlong.h (count_leading_zeros, count_trailing_zeros) [x86_64]: New macros. 2002-03-07 Kevin Ryde * gmp.texi (Build Options): Note all the ultrasparcs accepted. (Language Bindings): Add Math::BigInt::GMP. * config.sub (ultrasparc2i): New cpu type. * config.guess (sparc-*-*, sparc64-*-*): Add some exact CPU detection. 2002-03-05 Kevin Ryde * longlong.h (count_leading_zeros, count_trailing_zeros) [alphaev67, alphaev68]: Use ctlz and cttz insns (as per gcc longlong.h). (count_leading_zeros) [sparclite]: Fix parameter order (as per gcc longlong.h). * acconfig.h (HAVE_HOST_CPU_alphaev68): New define. * config.guess [i?86-*-*]: Suppress error messages if compiler not found or test program won't run. [rs6000-*-*, powerpc-*-*]: Force code alignment for mfpvr test. 2002-03-04 Torbjorn Granlund * mpn/generic/pow_1.c: New file. 2002-03-03 Kevin Ryde * gmp.texi (Build Options): Note compiler must be able to fully link, add alphapca57 and alphaev68, give a clearer example of MPN_PATH (Debugging): Add notes on valgrind. (C++ Formatted Output): Clarify mpf showbase handling, in particular note "00.4" in octal. * printf/doprntf.c: Do a showbase on octal float fractions, for instance "00.4" where previously it gave "0.4". * tests/cxx/t-ostream.cc: Update. * gmp-h.in, mp-h.in (__GMP_DECLSPEC, __GMP_DECLSPEC_XX): Test __WIN32__ for Borland C, reported by "delta trinity". * gmp-h.in, mp-h.in: Use for size_t under C++, suggested by Hans Aberg some time ago. * gmp-h.in (): Move to top of file for clarity. * Makefile.am (libgmpxx_la_SOURCES): Use dummy.cc to force C++. (CXX_OBJECTS): Add osfuns$U.lo. * dummy.cc: New file. * cxx/Makefile.am (INCLUDES): Use __GMP_WITHIN_GMPXX. (libcxx_la_SOURCES): Add osfuns.cc. * gmp-h.in (__GMP_DECLSPEC_XX): New define, use it on libgmpxx funs. * gmp-impl.h: Add __GMP_DECLSPEC to libgmp functions used by libgmpxx. * longlong.h (COUNT_TRAILING_ZEROS_TIME): Remove, no longer used. * gmp-impl.h (MPN_SIZEINBASE, MPN_SIZEINBASE_16): Correction to __totbits for nails. * gmp-impl.h (JACOBI_LS0): Test size before limb, to pacify valgrind. (JACOBI_0LS): Ditto, and fix parens around arguments. * mpn/x86/x86-defs.m4 (call_mcount): Add a counter to make data labels unique, since simplified L() scheme no longer gives that effect. (notl_or_xorl_GMP_NUMB_MASK): New macro. Add m4_assert_numargs in a few places. * configure.in (*sparc*): Fix cycle counter setups for ABI=64. 2002-02-28 Torbjorn Granlund * mpn/vax/gmp-mparam.h: New file. 2002-02-28 Kevin Ryde * gmp-h.in (gmp_errno, gmp_version): Move into extern "C" block, reported by librik@panix.com. * gmp-h.in, mp-h.in (__GMP_DECLSPEC_EXPORT, __GMP_DECLSPEC_IMPORT): Use __declspec(dllexport) and __declspec(dllimport) on Borland. * gmp-h.in (_GMP_H_HAVE_FILE): Test __STDIO_H for Borland. Reported by "delta trinity". * gmp-impl.h (va_copy): Fall back on memcpy, not "=". * mpn/generic/pre_mod_1.c: Add a comment about obsolescence. * tune/time.c (MICROSECONDS_P): Don't trust time differences of 1 microsecond. * tests/cxx/t-ostream.cc: Use "const char *" not just "char *" for test data strings, avoids warnings on Sun CC. 2002-02-27 Torbjorn Granlund * configure.in: For sparc under solaris2.[7-9], pass -fsimple=1 to disable some crazy -fast optimizations. 2002-02-25 Torbjorn Granlund * configure.in: For sparc under solaris2.[7-9], pass -fns=no to enable denorm handling under -fast. 2002-02-25 Kevin Ryde * configure.in (alpha*-*-*): Rearrange -mcpu selection for gcc, provide an ev67 -> ev6 fallback. Fix -arch,-tune selection for DEC C. Allow ~ for space in optional options lists. * tune/tuneup.c (tune_preinv_divrem_1): Compare against an assembler mpn_divrem_1 if it exists, not the generic C mpn_divrem_1_div. (tune_preinv_mod_1): Ditto with mpn_mod_1. * tune/time.c (DIFF_SECS_ROUTINE): Eliminate the unused "type" parameter, try to make the code a bit clearer. * tune/freq.c: Reduce the period measured for cycles versus gettimeofday, add cycles versus microsecond getrusage. * mpz/array_init.c: "i" should be mp_size_t, noticed by E. Khong. 2002-02-24 Torbjorn Granlund * configure.in: For sparc under solaris2.[7-9], pass -fast instead of other optimization options. 2002-02-23 Kevin Ryde * mpn/asm-defs.m4 (GMP_NUMB_MASK): New macro. (PROLOGUE, EPILOGUE): Relax quoting for the benefit of tune/many.pl when GSYM_PREFIX non-empty. * tune/time.c, tune/speed.h (speed_time_init): Include clock tick period in speed_time_string. * tune/time.c, configure.in (clock_gettime): New measuring method. * tune/many.pl: Add -DHAVE_NATIVE_mpn_foo to C objects, to avoid conflicts with a macro version in gmp-impl.h, eg. mpn_com_n. 2002-02-22 Torbjorn Granlund * demos/pexpr.c: Increase RLIMIT_STACK to 4Mibyte. 2002-02-22 Kevin Ryde * tune/tuneup.c: Don't confuse gcc with mipspro cc in diagnostic. 2002-02-20 Torbjorn Granlund * configure.in (mips*-*-irix[6789]*]): Set `extra_functions_n32', not `extra_functions'. * printf/doprnt.c: Conditionally include inttypes.h. * printf/repl-vsnprintf.c: Likewise. * scanf/doscan.c: Likewise. 2002-02-20 Kevin Ryde * mpn/x86/k7/mmx/com_n.asm: New file. * mpz/n_pow_ui.c (SWAP_RP_TP): Use ASSERT_CODE on ralloc and talloc, to ensure they needn't live past the initial allocs in a normal build. * mpn/generic/mod_34lsub1.c: Note this is for internal use. 2002-02-19 Torbjorn Granlund * Clean up *_THRESHOLD names. Many files affected. * mpn/mips32: Asm-ify 32-bit mips code. Move files from `mips2' to `mips32' directory. * mpn/mips64: Move files from `mips3' to `mips64' directory. * configure.in: Change `mips2' => `mips32' and `mips3' => `mips64'. 2002-02-19 Kevin Ryde * acinclude.m4, configure.in (GMP_PROG_LEX): New macro. * tune/tuneup.c (one): Start next threshold at a max of previous ones, in order to get a good starting point for TOOM3_SQR_THRESHOLD if KARATSUBA_SQR_THRESHOLD is 0 (ie. using mpn_mul_basecase only). * configure.in, tune/tuneup.c (GMP_MPARAM_H_SUGGEST): New AC_DEFINE replacing GMP_MPARAM_H_FILENAME. Suggest a new file in a cpu specific subdirectory rather than mpn/generic. * acinclude.m4 (POWERPC64_PATTERN): New macro. * configure.in (powerpc*-*-*): Use it. (powerpc*-*-*): Use umul in 32L and aix64. (mips*-*-*): Use umul, 32 and 64 bit versions. 2002-02-18 Torbjorn Granlund * longlong.h: Add basic x86-64 support. 2002-02-17 Torbjorn Granlund * demos/pexpr.c: Support `-X' for upper case hex, make `-x' output lower case hex. * mpn/mips2/umul.s: Make it actually work. * mpn/mips3/umul.asm: New file. * mpn/mips2/gmp-mparam.h: New file. 2002-02-16 Torbjorn Granlund * mpn/generic/get_str.c (mpn_sb_get_str): Round frac upwards after umul_ppmm calls. 2002-02-16 Kevin Ryde * config.guess (alpha-*-*): Do alpha exact cpu probes on any system, and only if configfsf.guess gives a plain "alpha". * acinclude.m4 (GMP_PROG_CC_WORKS): Detect a gcc 3.0.3 powerpc64 linker invocation problem. 2002-02-15 Torbjorn Granlund * mpn/generic/get_str.c (mpn_sb_get_str): For base 10, develop initial digits using umul_ppmm, then switch to plain multiplication. * config.guess: Rewrite Alpha subtype detection code for *bsd systems. 2002-02-15 Kevin Ryde * gmp.texi (Build Options): Note powerpc exact cpu types. (Debugging): Advertise DEBUG in memory.c. * config.sub, config.guess: Add some powerpc exact cpus. * configure.in: Add configs for them. * memory.c [__NeXT__]: Remove unused #define of "static". (__gmp_default_allocate, __gmp_default_reallocate): Print size if allocation fails, don't use perror. * gmp-h.in: g++ 3 demands __GMP_NOTHROW is before other attributes. 2002-02-14 Torbjorn Granlund * mpn/alpha/mul_1.asm: Fix typo preventing build on T3E systems. 2002-02-14 Kevin Ryde * tune/tuneup.c (tune_set_str): Increase max_size, for the benefit of alpha. * macos/README: Bug reports to bug-gmp@gnu.org, clarify MacOS X a bit. * mpn/generic/gcdext.c [WANT_GCDEXT_ONE_STEP]: Add missing TMP_FREE. * tune/speed.c, tune/tuneup.c: Allow for speed_cycletime of 0.0 in some diagnostic printouts. * tune/time.c (speed_cycletime): Note can be 0.0. 2002-02-12 Torbjorn Granlund * mpn/alpha/mul_1.asm: Add mpn_mul_1c entry. * mpn/pa64w/sqr_diagonal.asm: Use L() for labels. 2002-02-11 Torbjorn Granlund * mpn/generic/get_str.c (mpn_sb_get_str): Change declaration of rp to accommodate tuneup compiles. 2002-02-11 Kevin Ryde * mpn/alpha/default.m4, mpn/alpha/unicos.m4 (PROLOGUE_cpu): Add noalign option. * mpn/alpha/default.m4 (PROLOGUE_cpu): use ALIGN instead of ".align". * gmp.texi (Debugging): Notes on Checker. (Other Multiplication): Move note on float FFTs to here. (Assembler Floating Point): New text and revisions by Torbjorn, picture formatting by me. Simplify tex pictures elsewhere a bit, share heights, eliminate some gaps at line joins. 2002-02-11 Torbjorn Granlund * mpn/generic/get_str.c (mpn_sb_get_str): Rewrite to generate fraction limbs and use multiplication for digit development. Trim allocation of buf. Get rid of code for !USE_MULTILIMB. 2002-02-10 Torbjorn Granlund * mpn/generic/set_str.c (mpn_set_str): Undo this: Change invocations of mpn_add_1 to instead use mpn_incr_u. * tests/mpz/convert.c: Free str only after it is used in error message. * mpn/generic/get_str.c (mpn_sb_get_str): Combine tail code for base 10 and generic bases. * mpn/mp_bases.c: Add entries for base 256. Remove __ prefix from table name. * gmp-impl.h (__mp_bases): Remove superflous `mp_' part of name, making it __gmpn_bases instead of __gmpn_mp_bases. (mp_bases): New #define. * tune/speed.h (SPEED_ROUTINE_MPN_SET_STR): Allow bases up to 256. (SPEED_ROUTINE_MPN_GET_STR): Likewise. 2002-02-09 Torbjorn Granlund * mpn/generic/set_str.c (mpn_set_str): Use mpn_mul_1c if available. Change invocations of mpn_add_1 to instead use mpn_incr_u. 2002-02-09 Kevin Ryde * mpz/array_init.c, mpz/cfdiv_q_2exp.c, mpz/cfdiv_r_2exp.c, mpz/cong_2exp.c, mpz/divis_2exp.c, mpz/hamdist.c, mpz/init2.c, mpz/mul_2exp.c, mpz/realloc2.c, mpz/scan0.c, mpz/scan1.c, mpz/setbit.c, mpz/tdiv_q_2exp.c, mpz/tdiv_r_2exp.c, mpz/tstbit.c, mpz/urandomb.c: Use GMP_NUMB_BITS. * mpz/iset_str.c [__CHECKER__]: Store a dummy value to the low limb to stop it appearing uninitialized. * gmp-h.in (__GMP_NOTHROW): New macro. (mp_set_memory_functions, mpz_cmp, mpz_cmp_si, mpz_cmp_ui, mpz_cmpabs, mpz_cmpabs_ui, mpz_congruent_2exp_p, mpz_divisible_2exp_p, mpz_fits_sint_p, mpz_fits_slong_p, mpz_fits_sshort_p, mpz_fits_uint_p, mpz_fits_ulong_p, mpz_fits_ushort_p, mpz_get_si, mpz_get_ui, mpz_getlimbn, mpz_hamdist, mpz_popcount, mpz_scan0, mpz_scan1, mpz_size, mpz_sizeinbase, mpz_swap, mpz_tstbit, mpq_equal, mpq_swap, mpf_cmp, mpf_cmp_si, mpf_cmp_ui, mpf_fits_sint_p, mpf_fits_slong_p, mpf_fits_sshort_p, mpf_fits_uint_p, mpf_fits_ulong_p, mpf_fits_ushort_p, mpf_get_default_prec, mpf_get_prec, mpf_get_si, mpf_get_ui, mpf_integer_p, mpf_set_default_prec, mpf_set_prec_raw, mpf_size, mpf_swap, mpn_add_1, mpn_cmp, mpn_hamdist, mpn_popcount, mpn_sub_1): Use it. * gmp-impl.h (MPN_SIZEINBASE, MPN_SIZEINBASE_16): New macros from mpn_sizeinbase, and use GMP_NUMB_BITS. * mpz/get_str.c, mpz/sizeinbase.c, mpbsd/mout.c, tune/speed.h: Use MPN_SIZEINBASE. * mpbsd/mtox.c: Use MPN_SIZEINBASE_16. * configure.in, mpn/Makefile.am, gmp-impl.h (mpn_sizeinbase): Remove. * mpn/generic/sizeinbase.c: Remove file. * gmp-impl.h (MPN_GET_STR_SIZE): Remove. * tests/mpn/t-g_str_size.c: Remove file. * tests/mpn/Makefile.am: Update. * Makefile.am (dist-hook): Don't distribute cvs merge ".#" files. 2002-02-08 Torbjorn Granlund * configure.in: Override extra_functions for all sparcv8 systems, not just supersparc. 2002-02-06 Kevin Ryde * tune/tuneup.c (tune_mul, tune_sqr): Disable FFTs until tuned. * tune/speed.h (SPEED_ROUTINE_MPN_SET_STR): Fix memory clobber in destination cache priming. * printf/doprnt.c: Fix parsing of %s and %p conversions. * tests/misc/t-printf.c (check_misc): Add some tests. 2002-02-03 Torbjorn Granlund * mpn/sparc32/v8/udiv.asm: New file, from v8/supersparc. * mpn/generic/set_str.c: Rename indigits_per_limb => chars_per_limb. Remove redundant chars_per_limb. Reverse 4 loops in basecase code for speed. Use MP_BASES_CHARS_PER_LIMB_10. 2002-02-03 Kevin Ryde * acinclude.m4 (GMP_PROG_NM): Ensure -B or -p get used when doing a cross compile with the native nm, helps OSF for instance. (GMP_ASM_LSYM_PREFIX): Remove ".byte 0" for the benefit of irix 6, allow "N" from nm for OSF, allow for "t" for other systems, but prefer no mention of the symbol at all. * tune/tuneup.c (print_define_remark): New function. Turn some "#if"s into plain "if"s. * tune/tuneup.c, gmp-impl.h, tune/Makefile.am (GET_STR_BASECASE_THRESHOLD, GET_STR_PRECOMPUTE_THRESHOLD): Tune these. * mpn/generic/get_str.c [TUNE_PROGRAM_BUILD]: Cope with non-constant GET_STR_PRECOMPUTE_THRESHOLD. 2002-02-02 Torbjorn Granlund * mpn/generic/get_str.c (mpn_get_str): Fix typo in a declaration. 2002-02-02 Kevin Ryde * mpn/generic/set_str.c: Use MP_PTR_SWAP and POW2_P, add __GMP_PROTO to convert_blocks prototype, disable SET_STR_BLOCK_SIZE sanity check. * tune/set_strb.c, tune/set_strs.c: New files. * tune/speed.h, tune/speed.c, tune/common.c,tune/Makefile.am: Add them. * tune/tuneup.c: Tune SET_STR_THRESHOLD. (DEFAULT_MAX_SIZE): Renamed from MAX_SIZE, allow any param.max_size[]. 2002-02-01 Torbjorn Granlund * tests/mpz/convert.c: Increase operand size. Add (yet disabled) code for testing with random strings. * mpn/generic/get_str.c (mpn_get_str): Rewrite to become sub-quadratic. (mpn_dc_get_str, mpn_sb_get_str): New functions. 2002-01-31 Kevin Ryde * gmpxx.h (cmp): Renamed from "compare". * configure.in (AC_C_BIGENDIAN): Don't abort when cross compiling. (PROLOGUE): Allow new style optional second parameter when grepping. * acinclude.m4 (GMP_HPC_HPPA_2_0, GMP_ASM_UNDERSCORE, GMP_ASM_ALIGN_LOG, GMP_ASM_LSYM_PREFIX, GMP_ASM_W32, GMP_ASM_X86_MMX): Use $ac_objext for object filenames. (GMP_ASM_UNDERSCORE): Use CCAS to assemble. * demos/pexpr-config-h.in: New file. * configure.in: Generate demos/pexpr-config.h. (AC_CHECK_FUNCS): Add clock, cputime, setrlimit, sigaction, sigaltstack, sigstack. * acinclude.m4 (GMP_SUBST_CHECK_FUNCS, GMP_SUBST_CHECK_HEADERS): New macros. * demos/pexpr.c: Use pexpr-config.h, not various #ifdefs. (setup_error_handler): Use signal if sigaction not available, allow for SIGBUS missing on mingw. (main): Use time() for random seed if gettimeofday not available. (cleanup_and_exit): Move SIGFPE out of LIMIT_RESOURCE_USAGE. 2002-01-30 Torbjorn Granlund * mpn/generic/set_str.c: Rewrite to become sub-quadratic. (convert_blocks): New function. 2002-01-30 Kevin Ryde * gmp-impl.h (GMP_NUMB_MASK, GMP_NAIL_MASK, GMP_NUMB_HIGHBIT, ASSERT_MPN, ASSERT_MP_LIMB_T): New macros. * mpn/generic/fib2_ui.c: Use GMP_NUMB_BITS, simplify the data generator program, share __gmp_fib_table initializers between bit sizes, cope with bit sizes other than those specifically setup. * gmp-impl.h (FIB_TABLE_LIMIT, FIB_TABLE_LUCNUM_LIMIT): Corresponding rearrangement of conditionals. * tests/mpz/t-fib_ui.c (check_fib_table): New test. 2002-01-28 Kevin Ryde * mpz/set_si.c, mpz/iset_si.c: Store to _mp_d[0] unconditionally, use an expression for _mp_size. * mpz/init.c, mpz/init2.c, mpz/iset.c, mpq/init.c [__CHECKER__]: Store dummy values to low limbs to stop them appearing uninitialized. 2002-01-26 Kevin Ryde * mpfr/mpfr-test.h (MAX, MIN, ABS): Use instead a patch from Paul and Vincent. 2002-01-24 Kevin Ryde * configure.in: Extra quoting to get argument help messages right. * gmp.texi (Efficiency): Suggest hex or octal for input and output. (Formatted Output Strings): Mention "*" for width and precision. * mpn/generic/sizeinbase.c: New file, adapted from mpz/sizeinbase.c. Use POW2_P, use __mp_bases[base].big_base for log2(base). * configure.in, mpn/Makefile.am: Add it. * gmp-impl.h: Add prototype. * mpz/sizeinbase.c, tune/speed.h, mpn/generic/get_str.c, mpz/get_str.c, mpbsd/mout.c, mpbsd/mtox.c: Use it. * mpz/get_str.c: Write directly to user buffer, skip at most one leading zero, eliminate special case for x==0. * mpbsd/mtox.c: Allocate exact result space at the start, eliminate special case for x==0. * mpbsd/mout.c: Only need to skip one high zero with mpn_sizeinbase. * configure.in (--enable-nails): New option. (GMP_NAIL_BITS, GMP_LIMB_BITS, GMP_NUMB_BITS): New defines for gmp.h and config.m4. * gmp-h.in: Add templates. * mpfr/mpfr-test.h (MAX, MIN, ABS): Use #ifndef to avoid a redefine error on AIX xlc. 2002-01-23 Torbjorn Granlund * mpn/generic/get_str.c: Correct type of `out_len'. 2002-01-22 Kevin Ryde * mpn/generic/pre_divrem_1.c: Corrections to some ASSERTs. * mpfr/mul_ui.c: Don't call mpn_lshift with 0 shift. * mpfr/mpz_set_fr.c: Produce correct mpz_t for f==0. 2002-01-21 Torbjorn Granlund * longlong.h (32-bit powerpc add_ssaaaa): Remove spurious commutative declaration. (64-bit powerpc add_ssaaaa): Likewise. 2002-01-20 Kevin Ryde * acinclude.m4 (GMP_FUNC_VSNPRINTF): Use %n to better detect sparc solaris 2.7 problems. 2002-01-19 Torbjorn Granlund * demos/pexpr.c (mpz_eval_expr): Optimize s^rhs for -1 <= s <= 1. (cleanup_and_exit): Improve error message wording. 2002-01-19 Kevin Ryde * mpfr/mpfr.h (_PROTO): Use __GMP_PROTO, for compatibility with gmp-impl.h. 2002-01-17 Torbjorn Granlund * mpfr/mpfr-test.h: Test "__hpux", not "hpux". Mask off mrand48 return value to 31 bits to work around sloppy mpfr #include practices. * mpfr/tests/*.c: Use #include "", not <>, for gmp.h and mpfr.h. Make sure to #include mpfr-test.h from all files that use random(). 2002-01-17 Kevin Ryde * gmp-impl.h (__GMP_REALLOCATE_FUNC_MAYBE_TYPE): New macro. * gmp-impl.h, mpz/get_str.c, mpz/out_raw.c, mpq/get_str.c, mpq/set_str.c, mpf/get_str.c, printf/asprntffuns.c, printf/doprnt.c, printf/repl-vsnprintf.c, printf/snprntffuns.c, scanf/doscan.c, mpbsd/mtox.c: Some fixes to compile as C++. * mpn/generic/jacbase.c (JACOBI_BASE_METHOD): New tuned parameter, replacing COUNT_TRAILING_ZEROS_TIME test. Add a third method too. * tune/speed.c, tune/speed.h, tune/common.c, tune/Makefile.am: Add measuring of mpn_jacobi_base methods. * tune/jacbase1.c, tune/jacbase2.c, tune/jacbase3.c: New files. * tune/tuneup.c (JACOBI_BASE_METHOD): Tune this. * mpn/x86/*/gmp-mparam.h (COUNT_TRAILING_ZEROS_TIME): Remove macro. * gmp-h.in: Use __gmp prefix on variables in inlines. * gmp-impl.h (MPN_COPY_INCR, MPN_COPY_DECR): Remove __i, unused. * mpn/generic/mul_fft.c: Use HAVE_NATIVE_mpn_addsub_n, not ADDSUB. Use CNST_LIMB for some constants. 2002-01-15 Kevin Ryde * tests/mpbsd/Makefile.am: Add a convenience rule for ../libtests.la. * printf/Makefile.am: libdummy.la should be in EXTRA_LTLIBRARIES. * mpf/out_str.c: Use MPF_SIGNIFICANT_DIGITS, so mpf_out_str and mpf_get_str give the same for ndigits==0. * mpfr/exceptions.c (mpfr_set_emin, mpfr_set_emax): Work around a powerpc64 gcc 3.0 -O2 bug. * tests/memory.c, tests/tests.h (tests_memory_validate): New function. 2002-01-14 Kevin Ryde * mpn/generic/sb_divrem_mn.c, mpn/generic/divrem_1.c, mpn/generic/divrem_2.c, mpn/generic/mod_1.c: Don't use UMUL_TIME and UDIV_TIME, just default to preinv. * gmp-impl.h (USE_PREINV_DIVREM_1, USE_PREINV_MOD_1): Ditto. (DIVEXACT_1_THRESHOLD, MODEXACT_1_ODD_THRESHOLD): Don't use UMUL_TIME and UDIV_TIME, make default thresholds 0. (UDIV_NORM_PREINV_TIME, UDIV_UNNORM_PREINV_TIME): Remove macros. * mpn/x86/*/gmp-mparam.h (UMUL_TIME, UDIV_TIME, UDIV_NORM_PREINV_TIME): Remove macros. * gmp.texi (Headers and Libraries): New section, being the header notes from "GMP Basics" and some new stuff. (Parameter Conventions): Notes on "const" parameters. (Formatted Output Strings): Add type N, tweak some wording. * tests/refmpn.c (refmpn_divmod_1c): Avoid a bug in i386 gcc 3.0. 2002-01-12 Kevin Ryde * mpz/root.c: Add , for abort(). * mpfr/tests/Makefile.am (AUTOMAKE_OPTIONS): Add ansi2knr. * mpfr/mpfr.h, mpfr/mpfr-tests.h, reuse.c, tadd.c, tadd_ui.c, tagm.c, tatan.c, tcmp2.c, tcos.c, tdiv.c, tdiv_ui.c, teq.c, texp.c, tget_str.c, thyperbolic.c, tlog.c, tmul.c, tout_str.c, tpow.c, trandom.c, tset_z.c, tsin.c, tsqrt.c, tsqrt_ui.c, tsub_ui.c, ttan.c, tui_div.c: Fixes for K&R. * tests/misc/t-scanf.c (check_misc, check_misc): * tests/mpz/t-inp_str.c, tests/mpq/t-inp_str.c, tests/misc/t-scanf.c: Avoid strings in ASSERT, not enjoyed by K&R. * gmp-impl.h (ASSERT): Note this. * tests/tests.h (refmpn_mod_34lsub1): Add __GMP_PROTO. * mpbsd/Makefile.am: Avoid an automake problem with ansi2knr and sources in a different directory. * printf/repl-vsnprintf.c: Test HAVE_LONG_DOUBLE for long double. * mpn/Makefile.am (nodist_libdummy_la_SOURCES): Add mod_34lsub1.c, mul_2.c, pre_divrem_1.c. * gmp-h.in, gmp-impl.h (mpn_add_nc, mpn_addmul_1c, mpn_addsub_n, mpn_addsub_nc, mpn_divrem_1c, mpn_dump, mpn_mod_1c, mpn_mul_1c, mpn_mul_basecase, mpn_sqr_n, mpn_sqr_basecase, mpn_sub_nc, mpn_submul_1c): Move to gmp-impl.h, since they're undocumented. * gmp-impl.h (mpn_reciprocal): Remove, unused. * tune/many.pl (cntlz, cnttz): Use new SPEED_ROUTINE_COUNT_ZEROS. 2002-01-11 Kevin Ryde * mpn/hppa/*.asm, mpn/pa64/*.asm, mpn/pa64w/*.asm: Use L(). 2002-01-08 Kevin Ryde * mpn/asm-defs.m4 (PROLOGUE, EPILOGUE): New scheme, optional function name to EPILOGUE, check for missing or wrong function name EPILOGUE. * mpn/alpha/unicos.m4, mpn/alpha/default.m4, mpn/m68k/m68k-defs.m4, mpn/mips3/mips.m4, mpn/ia64/default.m4, mpn/powerpc32/aix.m4, mpn/powerpc64/aix.m4, mpn/x86/x86-defs.m4: Consequent updates, add a few more asserts. * mpn/alpha/unicos.m4, mpn/alpha/default.m4, mpn/alpha/cntlz.asm, mpn/alpha/invert_limb.asm (PROLOGUE_GP): Change to an optional "gp" parameter on plain PROLOGUE. * gmp.texi (Low-level Functions): mpn_get_str doesn't clobber an extra limb, and doesn't clobber at all for power of 2 bases. (Language Bindings): Add python gmpy. * mpz/get_str.c: Determine realloc size arithmetically. * mpbsd/mtox.c: Size memory block returned to actual space needed. * gmp.texi (BSD Compatible Functions): Describe this. * mpz/get_str.c: Don't copy mpn_get_str input for power of 2 bases. * mpbsd/mtox.c: Ditto, and as a side effect avoid a memory leak from a missing TMP_FREE. * mpz/get_str.c, mpbsd/mout.c: No longer need for +1 limb for mpn_get_str clobber. * gmp-impl.h (MPN_GET_STR_SIZE): New macro. * mpn/generic/get_str.c, mpz/get_str.c, mpbsd/mout.c, mpbsd/mtox.c, tune/speed.h: Use it. * tests/mpn/t-g_str_size.c: New test. * tests/mpn/Makefile.am: Add it. * gmp-impl.h (POW2_P): New macro. * mpn/generic/get_str.c, tests/misc.c: Use it. * printf/doprnt.c: Add "N" for mpn, share some code between N, Q and Z. * tests/misc/t-printf.c: Add tests. * gmp-impl.h (ASSERT_CODE): New macro. * tests/mpbsd/t-mtox.c: New test. * tests/mpbsd/Makefile.am: Add it. (allfuns_LDADD): Don't link against libgmp when testing everything in libmp can link. 2002-01-07 Torbjorn Granlund * gmp-impl.h (MPN_COPY_INCR, MPN_COPY_DECR): Rewrite generic versions. 2002-01-06 Kevin Ryde * mpn/generic/pre_divrem_1.c: Don't support size==0. * tests/devel/try.c: Update. * mpn/generic/get_str.c: Add special case for base==10. * gmp-impl.h (MP_BASES_CHARS_PER_LIMB_10, MP_BASES_BIG_BASE_10, MP_BASES_BIG_BASE_INVERTED_10, MP_BASES_NORMALIZATION_STEPS_10): New constants. * tests/t-constants.c: Add checks. * mpn/mp_bases.c [GENERATE_TABLE]: Print defines for gmp-impl.h, print all standard bits-per-limb by default. * demos/pexpr.c, demos/expr/expr.h, demos/expr/expr-impl.h: Use __GMP_PROTO. * gmp-h.in (mpn_divexact_by3c): Remove variables from prototype, to keep out of application namespace. 2002-01-04 Torbjorn Granlund * gmp-impl.h: Move _PROTO declaration to before its first usages. 2002-01-04 Kevin Ryde * gmp-h.in, mp-h.in, tests/tests.h: Rename _PROTO to __GMP_PROTO, and don't use #ifndef just define it ourselves. * gmp-impl.h: Provide _PROTO as an alias for __GMP_PROTO, to avoid big edits internally, for the moment. 2002-01-03 Torbjorn Granlund * tune/speed.c (usage): Insert "\n\" into a string. 2001-12-30 Torbjorn Granlund * mpn/pa64/udiv_qrnnd.c: Remove file. * mpn/pa64w/udiv_qrnnd.c: Remove file. * gmp-impl.h (MPN_IORD_U): Change formatting (labels in pos 0, insns indented by tab). (MPN_INCR_U): Use "addl $1,foo; jc", not "incl foo; jz". * gmp-impl.h (udiv_qrnnd_preinv): Use plain subtract, not sub_ddmmss, in one more case. 2001-12-30 Kevin Ryde * mpn/generic/get_str.c (udiv_qrnd_unnorm): New macro. Use "do while" for dig_per_u loop since it's non-zero. * acconfig.h (HAVE_HOST_CPU_m68k etc): Add templates. * mpn/generic/mul_basecase.c, mpz/mul.c, mpz/n_pow_ui.c, mpn/x86/pentium/mul_2.asm, tests/devel/try.c, tests/tests.h, tests/refmpn.c, tune/speed.c, tune/speed.h, tune/common.c, tune/many.pl (mpn_mul_2): New parameter style. * gmp-impl.h (mpn_mul_2): Add prototype. * configure.in (gmp_mpn_functions_optional): Add mul_2. * longlong.h (__vxworks__): Remove from powerpc tests, not correct, not on its own at least. * tune/speed.c: Add "aas" to specify 0xAA..AA data. * tune/tuneup.c (print_define_end): Indicate "never" and "always". 2001-12-29 Torbjorn Granlund * mpq/set_d.c: ANSI-fy. * mpz/invert.c: Use PTR and SIZ (cosmetic change). * mpz/cong.c: Rename `xor' to `sign' to avoid C++ reserved word. 2001-12-28 Torbjorn Granlund * mpn/sparc64/sqr_diagonal.asm: New file. 2001-12-28 Kevin Ryde * mpn/generic/get_str.c: Avoid one mpn_divrem_1 by running main loop only until msize==1. * tune/tuneup.c: Break up all() for clarity. (USE_PREINV_DIVREM_1, USE_PREINV_MOD_1): Compare against plain division udiv_qrnnd, not the tuned and possibly preinv version. * tune/freq.c: Split sysctl and sysctlbyname probes into separate functions, shorten some identifiers, put descriptions inside functions, define functions unconditionally and do nothing if requisites not available. * mpz/inp_raw.c: Avoid a gcc 3.0 powerpc64 bug on AIX. * acinclude.m4, configure.in (GMP_C_RESTRICT): New macro. * mpfr/sin.c: Patch from Paul to fix sign of sin(3pi/2). * demos/calc/calc.y: Improve some error messages. 2001-12-28 Torbjorn Granlund * mpn/sparc64/mul_1.asm: Rename r72 -> r80. * mpn/sparc64/addmul_1.asm: Likewise. 2001-12-27 Torbjorn Granlund * mpn/generic/tdiv_qr.c: Misc formatting cleanups. For switch case 2, replace `dn' with its value (2). 2001-12-25 Torbjorn Granlund * tests/devel/mul_1.c: Add FIXED_XLIMB. * tests/devel/addmul_1.c: Likewise. * tests/devel/submul_1.c: Likewise. * tests/devel/add_n.c: Improve error message. Accept command line argument for # of tests. * tests/devel/sub_n.c: Likewise. * tests/devel/: Remove CLOCK settings. * mpn/sparc32/v9/mul_1.asm: Rewrite. * mpn/sparc32/v9/addmul_1.asm: Rewrite. * mpn/sparc32/v9/submul_1.asm: Rewrite. 2001-12-24 Torbjorn Granlund * mpn/sparc64/mul_1.asm: Get rid of global constant 0.0 (L(noll)). * mpn/sparc64/addmul_1.asm: Likewise. 2001-12-23 Torbjorn Granlund * mpn/generic/get_str.c: Move final ASSERT to just before zero fill loop. 2001-12-22 Torbjorn Granlund * mpn/generic/get_str.c: Move ASSERTs out of loops. Split digit generation code into two loops, saving a test of msize in the loop. 2001-12-22 Kevin Ryde * mpn/x86/x86-defs.m4, mpn/x86/*/*.asm: Remove L / LF scheme putting function name in local labels. * mpn/generic/get_str.c: Use mpn_preinv_divrem_1, add a couple of ASSERTs. * mpn/generic/pre_divrem_1.c: New file. * configure.in (gmp_mpn_functions): Add it. * gmp-impl.h (mpn_preinv_divrem_1): Add prototype. (USE_PREINV_DIVREM_1, MPN_DIVREM_OR_PREINV_DIVREM_1): New macros. * tests/devel/try.c, tune/speed.c, tune/speed.h, tune/common.c, tune/many.pl, tune/Makefile.am (mpn_preinv_divrem_1): Add testing and measuring. * tune/tuneup.c: Determine USE_PREINV_DIVREM_1. * tune/pre_divrem_1.c: New file. * tests/refmpn.c, tests/tests.h (refmpn_preinv_divrem_1): New function. * tests/mpz/t-io_raw.c: New file. * tests/mpz/Makefile.am (check_PROGRAMS): Add it. * mpz/inp_raw.c, mpz/out_raw.c: Rewrite. * acinclude.m4, configure.in (AC_C_BIGENDIAN): New test. * gmp-impl.h (BSWAP_LIMB): New macro. * acinclude.m4 (GMP_PROG_CC_WORKS): For a native compile, demand executables will run, per AC_PROG_CC. This detects ABI=64 is unusable in a native sparc solaris 7 build with the kernel in 32-bit mode. * gmp.texi (ABI and ISA): Add notes on this, add an example configure setting an ABI. * tune/tuneup.c, configure.in: Print the gmp-mparam.h filename. * tune/tuneup.c: Print the CPU frequency. * tune/time.c, tune/speed.h: Add s390 "stck" method, flatten conditionals in speed_time_init a bit, use have_* variables to let some code go dead in speed_starttime and speed_endtime. * tune/freq.c (speed_cpu_frequency_irix_hinv): New function. * Makefile.am, configure.in: Restore mpfr. * configure.in: Add --with-readline, AC_PROG_YACC and AM_PROG_LEX. * demos/calc/calc.y, demos/calc/calclex.l: Add readline support, add lucnum function. * demos/calc/Makefile.am: Add calcread.c, calc-common.h, use $(YACC), $(LEX) and $(LEXLIB). * demos/calc/calcread.c, demos/calc/calc-common.h, demos/calc/calc-config-h.in, demos/calc/README: New files. * configure.in: Put demos/expr configs in expr-config.h. * demos/expr/expr-config-h.in: New file. * demos/expr/expr-impl.h: Renamed from expr-impl-h.in, get configs from expr-config.h. * demos/expr/Makefile.am: Update. * demos/expr/exprfr.c: Use mpfr_sin and mpfr_cos, remove some spurious returns. 2001-12-20 Torbjorn Granlund * mpn/sparc64/mul_1.asm: Trim an instruction. * mpn/sparc64/addmul_1.asm: Likewise. * mpn/ia64/add_n.asm: Rewrite. * mpn/ia64/sub_n.asm: Rewrite. 2001-12-19 Torbjorn Granlund * mpn/ia64/mul_1.asm: Rewrite. * mpn/ia64/addmul_1.asm: Rewrite. * mpn/ia64/submul_1.c: Use TMP_ALLOC_LIMBS. * tests/devel/mul_1.c: Improve error message. Accept command line argument for # of tests. * tests/devel/addmul_1.c: Likewise. * tests/devel/submul_1.c: Likewise. 2001-12-18 Torbjorn Granlund * mpn/mips3/mul_1.asm: Add NOPs to save a cycle on R1x000. 2001-12-18 Kevin Ryde * gmpxx.h (gmp_randclass): Don't allow copy constructors or "=", implementation by Gerardo. * gmp-h.in (operator<<, operator>>): Remove parameter names from prototypes, to keep out of user namespace. * acinclude.m4 (GMP_FUNC_VSNPRINTF): Let the test program work as C++. 2001-12-16 Torbjorn Granlund * mpn/sparc64/mul_1.asm: Rewrite. * mpn/sparc64/addmul_1.asm: Rewrite. * mpn/sparc64/submul_1.asm: Rewrite. * mpn/sparc64/addmul1h.asm: Remove. * mpn/sparc64/submul1h.asm: Remove. * mpn/sparc64/mul1h.asm: Remove. 2001-12-15 Kevin Ryde * gmp-h.in (mpn_add, mpn_add_1, mpn_cmp, mpn_sub, mpn_sub_1): Follow __GMP_INLINE_PROTOTYPES for whether to give prototype with inline. * configure.in (i686*-*-*, pentiumpro-*-*, pentium[23]-*-*, athlon-*-*, pentium4-*-*): Fall back on -march=pentium if -march=pentiumpro or higher is not good (eg. solaris cmov). 2001-12-12 Torbjorn Granlund * gmp-impl.h (MPN_ZERO): Rewrite generic version to be similar to powerpc version. 2001-12-12 Kevin Ryde * acinclude.m4 (GMP_PROG_CC_WORKS): Detect cmov problems with gcc -march=pentiumpro on solaris 2.8. * tune/common.c, tune/speed.h: Allow for commas in count_leading_zeros and count_trailing_zeros macros. * demos/expr/Makefile.am: Distribute exprfr.c and exprfra.c. * tune/Makefile.am (speed_ext_SOURCES): Should be speed-ext.c. 2001-12-10 Torbjorn Granlund * mpn/s390/addmul_1.asm: New file. * mpn/s390/submul_1.asm: New file. * mpn/s390/mul_1.asm: New file. * mpn/s390/gmp-mparam.h: Update. 2001-12-07 Kevin Ryde * gmp-h.in, mp-h.in, gmp-impl.h: __GMP_DECLSPEC at start of prototypes, for the benefit of Microsoft C. * gmp.texi (Introduction to GMP): Mention ABI and ISA section. (Known Build Problems): Recommend GNU sed on solaris 2.6. (Assigning Integers): Direct feedback to bug-gmp. (References): Typo Knuth vol 2 is from 1998. * gmpxx.h (gmp_randclass): Add initializers for gmp_randinit_default and gmp_randinit_lc_2exp_size. gmp.texi (C++ Interface Random Numbers): Describe them. * tests/misc/t-locale.c, tests/cxx/t-locale.cc: Ensure mpf_clear is done when the localconv override doesn't work. Reported by Mike Jetzer. * printf/doprnti.c: Don't showbase on a zero mpq denominator. * tests/misc/t-printf.c, tests/cxx/t-ostream.c: Add test cases. 2001-12-04 Kevin Ryde * gmp.texi (Known Build Problems): Update to gmp_randinit_lc_2exp_size for the sparc solaris 2.7 problem. (Reentrancy): SCO ctype.h affects all text-based input functions. (Formatted Output Strings): Correction to the mpf example. (Single Limb Division): Correction, should be q-1 not q+1. (Extended GCD): Clarify why single-limb is inferior. (Raw Output Internals): Clarify size is twos complement, note limb order means _mp_d doesn't get directly read or written. (Contributors): Clarify mpz_jacobi. And a couple of formatting tweaks elsewhere. * tests/cxx/t-headers.cc: New file. * tests/cxx/Makefile.am: Add it. * gmpxx.h: Add , needed by mpf_class::get_str2. * gmp-h.in (mpq_inp_str, mpn_hamdist): Add __GMP_DECLSPEC. 2001-12-01 Torbjorn Granlund * Version 4.0 released. * mpfr/README: Replace contents with explanation of why mpfr is gone. 2001-12-01 Kevin Ryde * Makefile.am, configure.in: Temporarily remove mpfr, just leave a README. * mpn/Makefile.am (EXTRA_DIST): Add Makeasm.am. 2001-11-30 Gerardo Ballabio * tests/cxx/t-constr.cc, tests/cxx/t-expr.cc: New files. * tests/cxx/Makefile.am (check_PROGRAMS): Add them. 2001-11-30 Kevin Ryde * mpfr: Update to 2001-11-16. Patch TMP handling of agm.c and sqrt.c, use plain mpn_sqrtrem in sqrt.c, separate .c files for floor and ceil, disable an expression style assert in add1.c. * mpn/s370: Rename to s390. * configure.in (s3[6-9]0*-*-*): Update. * mpn/Makefile.am (TARG_DIST): Add s390. * mpz/fits_s.c, mpf/fits_s.c, mpf/fits_u.c: Remove files, unused since change to .h style. 2001-11-29 Torbjorn Granlund * gmp-h.in: Declare mpz_get_d_2exp and mpf_get_d_2exp. * Makefile.am: Add mpz/get_d_2exp$U.lo and mpf/get_d_2exp$U.lo. * mpf/Makefile.am: Add get_d_2exp.c. * mpz/Makefile.am: Add get_d_2exp.c. 2001-11-29 Kevin Ryde * mpn/*/gmp-mparam.h: Update measured thresholds. * mpn/s370/gmp-mparam.h: New file. * mpz/millerrabin.c: Mark for internal use only, for now. * gmp.texi (Number Theoretic Functions): Remove documentation. 2001-11-28 Torbjorn Granlund * mpf/get_d_2exp.c: New file. * mpz/get_d_2exp.c: New file. * mpz/realloc2.c: Fix typo. Make more similar to mpz_realloc. * mpz/realloc.c: Use __GMP_REALLOCATE_FUNC_LIMBS. 2001-11-27 Gerardo Ballabio * gmpxx.h, mpfrxx.h: Various updates and improvements. 2001-11-27 Kevin Ryde * gmp.texi (Useful Macros and Constants): Add gmp_version, add @findex for mp_bits_per_limb. * demos/perl/GMP.pm, demos/perl/GMP.xs: Use new style gmp_randinit's. * demos/perl/test.pl: Update for this, and for mpz_perfect_power_p handling of 0 and 1. 2001-11-26 Torbjorn Granlund * mpz/realloc.c: Clear variable when decreasing allocation to less than needed. Misc updates. 2001-11-25 Kevin Ryde * tests/misc/t-locale.c: Avoid printf in the normal case, since the replacement localeconv breaks it on SunOS 4. * gmp.texi (Build Options, Notes for Package Builds): Note libgmpxx depends on libgmp from same GMP version. * acinclude.m4, configure.in (GMP_FUNC_SSCANF_WRITABLE_INPUT): New test. * scanf/sscanf.c, scanf/vsscanf.c: Use it to ensure sscanf input is writable, if necessary. * tests/misc/t-scanf.c: Ensure sscanf arguments are writable, always. * configure.in (AC_CHECK_DECLS): Remove sscanf, no longer required. * configure.in (none-*-*): Fix default CFLAGS setups. * doc/configuration: Misc updates. 2001-11-23 Kevin Ryde * mpz/init2.c, mpz/realloc2.c: New files. * Makefile.am, mpz/Makefile.am: Add them. * gmp-h.in: Add prototypes. * gmp.texi (Efficiency): Mention these instead of _mpz_realloc. (Initializing Integers): Add documentation, reword other parts. 2001-11-22 Torbjorn Granlund * mpn/cray/ieee/addmul_1.c: Fix logic for more_carries scalar loop. * mpn/cray/ieee/submul_1.c: Likewise. 2001-11-20 Kevin Ryde * gmp.texi (Known Build Problems): Note an out of memory on DJGPP. (Function Classes): Update function counts. Misc tweaks elsewhere. * configure.in (AC_CHECK_DECLS): Add sscanf. * tests/misc/t-scanf.c: Use it, for the benefit of SunOS 4. * tal-debug.c, gmp-impl.h: More checks of TMP_DECL/TMP_MARK/TMP_FREE consistency. * mpfr/Makefile.am (AR): Explicit AR=@AR@ to override automake default, necessary for powerpc64 ABI=aix64. 2001-11-18 Torbjorn Granlund * mpz/powm.c: Move TMP_MARK to before any TMP_ALLOCs. 2001-11-18 Kevin Ryde * configure.in (--enable-fft): Make this the default. * gmp.texi (Build Options): Update. * Makefile.am (libmp_la_DEPENDENCIES): Revise mpz objects needed by new mpz/powm.c. * gmp.texi (Random State Initialization): Add gmp_randinit_default and gmp_randinit_lc_2exp_size, mark gmp_randinit as obsolete. (Random State Seeding): New section, taken from "Random State Initialization" and "Random Number Functions". * configure.in (AC_CHECK_DECLS): Add fgetc, fscanf, ungetc. * scanf/fscanffuns.c: Use these, for the benefit of SunOS 4. * gmp-impl.h, gmp-h.in (__gmp_default_fp_limb_precision): Move back to gmp-impl.h now not required for inlined mpf. * randlc2s.c (gmp_randinit_lc_2exp_size): New file, the size-based LC selection from rand.c. * rand.c (gmp_randinit): Use it. * randdef.c (gmp_randinit_default): New file. * gmp-impl.h (RANDS): Use it. (ASSERT_CARRY): New macro. * gmp-h.in (gmp_randinit_default, gmp_randinit_lc_2exp_size: Add prototypes. * Makefile.am (libgmp_la_SOURCES): Add randdef.c and randlc2s.c. * printf/asprntffuns.c: Include config.h before using its defines. * gmp-impl.h: Move C++ to top of file to avoid the memset redefine upsetting configure tests. Remove since in gmp.h suffices. 2001-11-16 Kevin Ryde * gmp.texi (Integer Exponentiation): mpz_powm supports negative exponents. (Assigning Floats, I/O of Floats, C++ Formatted Output, C++ Formatted Input): Decimal point follows locale. (Formatted Output Strings): %n accepts any type. (Formatted Input Strings): New section. (Formatted Input Functions): New section. (C++ Class Interface): Corrections and clarifications suggested by Gerardo. * scanf/doscan.c, scanf/fscanf.c, scanf/fscanffuns.c, scanf/scanf.c, scanf/sscanf.c, scanf/sscanffuns.c, scanf/vfscanf.c, scanf/vscanf.c, scanf/vsscanf.c, scanf/Makefile.am, tests/misc/t-scanf.c: New files. * gmp-h.in, gmp-impl.h, Makefile.am, configure.in: Consequent additions. * tests/misc: New directory. * tests/misc/Makefile.am: New file. * tests/misc/t-locale.c: New file. * tests/misc/t-printf.c: Moved from tests/printf. * tests/printf: Remove directory. * configure.in, tests/Makefile.am: Update. * tests/cxx/t-locale.cc: New file. * tests/cxx/Makefile.am: Add it. * mpf/set_str.c, cxx/ismpf.cc: Use localeconv for the decimal point. * acinclude.m4 (GMP_ASM_X86_MCOUNT): Update to $lt_prog_compiler_pic for current libtool, recognise non-PIC style mcount in windows DLLs. * gmp-impl.h (__gmp_replacement_vsnprintf): Add prototype. * gmp-impl.h (__gmp_rands, __gmp_rands_initialized, modlimb_invert_table): Add __GMP_DECLSPEC for the benefit of test programs using them from a windows DLL. * longlong.h (__clz_tab): Ditto. * mpn/x86/t-zdisp2.pl: New file. * mpn/x86/pentium4/README: New file. 2001-11-15 Torbjorn Granlund * mpz/powm.c (HANDLE_NEGATIVE_EXPONENT): #define to 1. * tests/mpz/reuse.c (main): Use mpz_invert to avoid undefined mpz_powm cases. 2001-11-14 Torbjorn Granlund * mpz/powm_ui.c: Rewrite along the lines of mpz/powm.c (except still no redc). * mpz/powm.c: Adjust for negative b, after exponentiation done. Add (still disabled) code for handling negative exponents. Misc cleanups. 2001-11-14 Kevin Ryde * mpf/out_str.c: Use localeconv for the decimal point. * tests/misc.c (tests_rand_end): Use time() if gettimeofday() not available (eg. on mingw). 2001-11-11 Kevin Ryde * gmp-h.in: Remove parameter names from prototypes, to keep out of application namespace. 2001-11-08 Kevin Ryde * acinclude.m4 (GMP_GCC_VERSION_GE): Fix sed regexps to work on Solaris 8. * printf/doprnt.c: Support %n of all types, per glibc. * gmp-h.in, gmp-impl.h, mpf/abs.c, mpf/neg.c, mpf/get_prc.c, mpf/get_dfl_prec.c, mpf/set_dfl_prec.c, mpf/set_prc_raw.c, mpf/set_si.c, mpf/set_ui.c, mpf/size.c: Revert mpf inlining, in order to leave open the possibility of keeping binary compatibility if mpf becomes mpfr. * mpn/x86/k7/mmx/lshift.asm, mpn/x86/k7/mmx/rshift.asm: Use Zdisp to force code size for computed jumps. * mpn/x86/k6/mod_34lsub1.asm, mpn/x86/k6/k62mmx/copyd.asm: Use Zdisp to force good code alignment. * mpn/x86/x86-defs.m4 (Zdisp): More instructions. * mpn/x86/pentium/sqr_basecase.asm, mpn/x86/k7/mmx/mod_1.asm, mpn/x86/k7/mmx/popham.asm: Remove some unnecessary "0" address offsets. * mpq/set_si.c, mpq/set_ui.c: Set _mp_den._mp_size correctly if den==0. 2001-11-07 Torbjorn Granlund * mpn/hppa/hppa1_1/udiv_qrnnd.asm: Work around gas bug. * mpn/asm-defs.m4 (PROLOGUE): Change alignment to 8 (probably a good idea in general; required for hppa/hppa1_1/udiv_qrnnd.asm). 2001-11-06 Torbjorn Granlund * gmp-impl.h (MPN_COPY_INCR): Prepend local variable by `__'. (MPN_COPY_DECR): Likewise. 2001-11-05 Torbjorn Granlund * mpz/powm.c: Call mpn functions, not mpz functions, for computation mod m. Streamline allocations to use a mixture of stack allocation and heap allocation. Add currently disabled phi(m) exponent reduction code. Misc optimizations and cleanups. 2001-11-05 Kevin Ryde * mpq/inp_str.c: Remove unused variable "ret". * mpn/x86/k7/sqr_basecase.asm: Fix a 0(%edi) to use Zdisp, so the computed jumps hit the right spot on old gas. * mpq/canonicalize.c: DIVIDE_BY_ZERO if denominator is zero. * mpn/lisp/gmpasm-mode.el (comment-start-skip): Correction to the way the first \( \) pair is setup. (gmpasm-font-lock-keywords): Don't fontify the space before a "#" etc. Misc tweaks to some comments. 2001-11-03 Torbjorn Granlund * tests/refmpn.c (refmpn_overlap_p): Reverse return values. 2001-11-02 Kevin Ryde * tune/many.pl: Setup CFLAGS_PIC and ASMFLAGS_PIC, since that's no longer done by configure. * mpn/x86/pentium4/mmx/popham.asm: New file. * mpn/x86/x86-defs.m4 (psadbw): New macro. * mpn/x86/k7/mmx/popham.asm: Use it. * tests/refmpn.c (refmpn_overlap_p): New function, independent of MPN_OVERLAP_P. 2001-10-31 Torbjorn Granlund * tests/mpz/t-powm.c: Print proper error message when finding discrepancy. 2001-10-31 Kevin Ryde * mpn/x86/pentium/mod_34lsub1.asm: New file. * mpn/x86/k7/mod_34lsub1.asm: New file. * mpn/x86/mod_34lsub1.asm: New file. 2001-10-30 Kevin Ryde * tests/printf/t-printf.c (check_misc): Add checks from the glibc docs. (check_vasprintf, check_vsnprintf): Run these unconditionally. * gmp-impl.h (ASSERT_MPQ_CANONICAL): New macro. * mpq/cmp.c, mpq/cmp_si.c, mpq/cmp_ui.c, mpq/equal.c: Add ASSERTs for canonical inputs, where correctness depends on it. * mpn/lisp/gmpasm-mode.el (comment-start-skip): Add "dnl". 2001-10-27 Torbjorn Granlund * demos/pexpr.c: Remove some unused variables. (main): Allocate more buffer space to accommodate minus sign. 2001-10-27 Kevin Ryde * gmp-impl.h, mpn/asm-defs.m4, configure.in, tune/speed.h, tune/speed.c, tune/common.c, tune/many.pl, tests/devel/try.c: Add mpn_mod_34lsub1. * tests/refmpn.c, tests/tests.h (refmpn_mod_34lsub1): New function. * mpn/generic/mod_34lsub1.c: New file. * mpn/x86/k6/mod_34lsub1.asm: New file. * mpn/x86/pentium4/sse2/mod_34lsub1.asm: New file. * mpn/x86/x86-defs.m4 (Zdisp): Add another instruction. * gmp-h.in, gmpxx.h: Use not whole . * gmp.texi (Known Build Problems): Add note on test programs with Windows DLLs. 2001-10-26 Kevin Ryde * tests/mpq/t-get_d.c: Limit the size of "eps" for vax. * gmp.texi (maybepagebreak): New macro, use it in a few places. (Notes for Particular Systems): C++ Windows DLLs are not supported. (Known Build Problems): Note sparc solaris 2.7 gcc 2.95.2 shared library problems. (Autoconf): Tweak version numbers shown. (Integer Roots): mpz_perfect_square_p and mpz_perfect_power_p consider 0 and 1 perfect powers, mpz_perfect_power_p accepts negatives. (Number Theoretic Functions): Add mpz_millerrabin, combined with a reworded mpz_probab_prime_p. (Formatted Output Strings): Misc clarifications. (Formatted Output Functions): gmp_asprintf, gmp_vasprintf, gmp_snprintf, gmp_vsnprintf always available. (C++ Formatted Output): Misc rewordings. (Formatted Input): New chapter. (C++ Class Interface): New chapter, by Gerardo and me. (Language Bindings): Update GMP++ now in GMP. (C++ Interface Internals): New section, by Gerardo and me. * printf/repl-vsnprintf.c: New file. * configure.in, acinclude.m4, Makefile.am, printf/Makefile.am: Use it if libc vsnprintf missing or bad. * configure.in (AC_CHECK_FUNCS): Add strnlen. * printf/snprntffuns.c, printf/vasprintf.c: Use __gmp_replacement_vsnprintf if libc vsnprintf not available. * printf/asprintf.c, printf/snprintf.c, printf/vasprintf.c, printf/vsnprintf.c: Provide these functions unconditionally. * acinclude.m4 (GMP_FUNC_VSNPRINTF): Remove warning about omissions when vsnprintf not available. 2001-10-24 Kevin Ryde * configure, aclocal.m4: Regenerate with a libtool patch for a stray quote in AC_LIBTOOL_PROG_LD_SHLIBS under mingw and cygwin. * gmp-impl.h (modlimb_invert): More comments. * printf/doprnt.c, printf/doprnti.c: Use the precision field to print leading zeros. * tests/printf/t-printf.c: Test this. * cxx/osdoprnti.cc, gmp-impl.h: Ignore precision in operator<<. * tune/speed.c, tune/speed.h, tune/common.c: Add mpn_mul_1_inplace. 2001-10-23 Torbjorn Granlund * mpz/pprime_p.c (mpz_millerrabin): Remove function and its descendant. * mpz/millerrabin.c: New file with code from pprime.c. * mpz/Makefile.am: Compile millerrabin.c. * Makefile.am (MPZ_OBJECTS): Ditto. * gmp-h.in: Declare mpz_millerrabin. 2001-10-22 Torbjorn Granlund * tests/mpz/t-perfsqr.c: New file. * tests/mpz/Makefile.am (check_PROGRAMS): Add it. * demos/factorize.c (factor): Check for number to factor == 0. (main): When invoked without arguments, read from stdin. * mpz/perfpow.c: Add code to handle negative perfect powers ((-b)^odd). Treat 0 and 1 as perfect powers. * mpn/sparc32/v9/sqr_diagonal.asm: Jump past .align. 2001-10-21 Torbjorn Granlund * mpn/generic/perfsqr.c (sq_res_0x100): Remove bogus final `,'. (mpn_perfect_square_p): Suppress superfluous `&1' in sq_res_0x100 test. (mpn_perfect_square_p, O(n) test): Improve comments. Combine remainder tests for some small primes. Don't share code for different limb sizes. Use single `if' with many `||' for better code density. 2001-10-22 Kevin Ryde * demos/perl/GMP.xs (mutate_mpz, tmp_mpf_grow): Make these "static". * mpn/x86/pentium/popcount.asm, mpn/x86/pentium/hamdist.asm (mpn_popcount_table): Use GSYM_PREFIX. 2001-10-19 Kevin Ryde * mpn/x86/*.asm: Add some measured speeds on various x86s. * tests/mpz/reuse.c, tests/mpf/reuse.c: Disable tests when using a windows DLL, because certain global variable usages won't compile. * configure.in (AC_CHECK_FUNCS): Add alarm. * tests/spinner.c: Conditionalize alarm and SIGALRM availability, for the benefit of mingw32. * acinclude.m4 (GMP_ASM_TYPE, GMP_ASM_SIZE): Suppress .type and .size on COFF. * acinclude.m4 (GMP_PROG_HOST_CC): New macro. * configure.in: Use it for windows DLL cross-compiles. * aclocal.m4, configure: Regenerate with libtool patch to hold HOST_CC in the generated libtool script. * aclocal.m4, configure: Regenerate with libtool patch to suppress warnings when probing command line limit on FreeBSD. * demos/qcn.c (M_PI): Define if not already provided, helps mingw32. 2001-10-17 Kevin Ryde * printf/doprnt.c: Use for intmax_t. * longlong.h: Recognise __sparcv8 for gcc on Solaris. Reported by Mark Mentovai . * gmp-impl.h (gmp_allocated_string): No need for inline on member funs. 2001-10-16 Kevin Ryde * gmp.texi (Debugging): Add mpatrol. (Integer Comparisons, Comparing Rationals, Float Comparison): Index entries for sign tests. (I/O of Floats): Clarify mpf_out_str exponent is in decimal. (C++ Formatted Output): mpf_t operator<< exponent now in decimal. (FFT Multiplication): Use an ascii art sigma. (Contributors): Add Gerardo Ballabio. * cxx/osfuns.cc (__gmp_doprnt_params_from_ios): Always give mpf_t exponent in decimal, irrespective of ios::hex or ios::oct. * tests/cxx/t-ostream.cc (check_mpf): Update. * printf/doprnt.c: Support %lln and %hhn. * mpn/x86/pentium4/sse2/submul_1.asm: Use a psubq to negate the initial carry (helps the submul_1c case), and improve the comments. 2001-10-11 Kevin Ryde * acinclude.m4, configure.in (GMP_IMPL_H_IEEE_FLOATS): New macro. * ltmain.sh: Send some rm errors to /dev/null, helps during compiles on Solaris 2.7 and HP-UX 10. * tal-notreent.c: Renamed from stack-alloc.c. * Makefile.am, acinclude.m4, gmp-impl.h: Update. * gmp-h.in: Don't give both prototypes and inlines, except on gcc. * gmp-h.in, gmp-impl.h: Use #includes to get necessary standard classes, add std:: to prototypes. * cxx/*.cc, tests/cxx/t-ostream.cc: Add "use namespace std". * acinclude.m4 (GMP_PROG_CXX_WORKS): Ditto. * tests/*/Makefile.in, mpfr/tests/Makefile.in: Regenerate with automake patch to avoid Ultrix problem with empty $(TESTS). * */Makefile.in: Regenerate with automake patch to only rm *_.c in "make clean" when ansi2knr actually in use, helps DOS 8.3. * Makefile.in: Regenerate with automake patch to fix stamp-h numbering, avoiding an unnecessary config.status run. 2001-10-09 Torbjorn Granlund * mpn/hppa/hppa1_1/udiv_qrnnd.asm: Use L macros for labels. Quote L reloc operator. * gmp-impl.h: Declare class string. * mpn/asm-defs.m4 (INT32, INT64): Quote $1 to prevent further expansion. * mpn/alpha/ev6/mul_1.asm: New file. 2001-10-09 Kevin Ryde * gmp.texi (Introduction to GMP): Add pentium 4 to optimized CPUs. (Build Options): Note macos directory. (Notes for Package Builds): GMP 4 series binary compatible with 3. (Known Build Problems): Remove $* and ansi2knr note, now fixed, except possibly under --host=none. (Formatted Output Strings): Remove -1 prec for all digits. * mpz/add.c, mpz/sub.c: Don't use mpz path on #include (helps macos). * mpbsd/Makefile.am (INCLUDES): Add -I$(top_srcdir)/mpz. * printf/doprnt.c, tests/printf/t-printf.c: Remove support for %.*Fe prec -1 meaning all digits. * acinclude.m4 (GMP_PROG_AR): Override libtool, use AR_FLAGS="cq". (GMP_HPC_HPPA_2_0): Print version string to config.log. * Makefile.am (AUTOMAKE_OPTIONS): Remove check-news (permission notice in NEWS file is too big). (dist-hook): Don't distribute numbered or unnumbered emacs backups. * Makefile.am, cxx/Makefile.am: Updates for Gerardo's stuff. 2001-10-09 Gerardo Ballabio * cxx/isfuns.cc: New file. * gmp-impl.h: Add prototypes. * cxx/ismpf.cc, cxx/ismpq.cc, cxx/ismpz.cc: New files. * gmp-h.in: Add prototypes. * gmpxx.h, mpfrxx.h: New files. 2001-10-08 Kevin Ryde * configure.in (with_tags): Establish a default based on --enable-cxx. * aclocal.m4: Regenerate with libtool patches for sed char range to help Cray, LTCC quotes and +Z warnings grep to help HP-UX. * gmp-impl.h (doprnt_format_t, doprnt_memory_t, doprnt_reps_t, doprnt_final_t): Use _PROTO. 2001-10-05 Torbjorn Granlund * mpn/asm-defs.m4 (INT32, INT64): Use LABEL_SUFFIX. * mpn/hppa: Convert files to `.asm'. 2001-10-05 Kevin Ryde * mpn/Makeasm.am (.S files): Revert to separate CPP and CCAS, use cpp-ccas, and only pass CPPFLAGS to CPP, not whole CFLAGS. * mpn/cpp-ccas: New file. * mpn/Makefile.am (EXTRA_DIST): Add it. * tune/common.c, tune/speed.h: Change SPEED_ROUTINE_MPN_COPY_CALL uses to SPEED_ROUTINE_MPN_COPY or new SPEED_ROUTINE_MPN_COPY_BYTES. Avoids macro expansion problems on Cray. * configure.in (AC_PROG_CXXCPP): Add this, to make libtool happier. 2001-10-04 Torbjorn Granlund * mpz/rrandomb.c (gmp_rrandomb): Change bit_pos to be 0-based (was 1-based); shift 2 (was 1) when making bit mask. These two changes avoid undefined shift counts. (gmp_rrandomb): Avoid most calls to _gmp_rand by caching random values. * mpn/generic/random2.c: Changes for mirroring mpz/rrandomb.c. 2001-10-04 Kevin Ryde * gmp.texi (Build Options): Add --enable-cxx. (Notes for Particular Systems): Mention pentium4 performance and SSE2. (Known Build Problems): Remove vax jsobgtr note, no longer needed. (Converting Floats): Tweak mpf_get_str description. (Low-level Functions): Correction to mpn_gcdext destination space requirements. (C++ Formatted Output): New section. (Language Bindings): Add ALP (Contributors): Add Paul Zimmermann's square root, update my things. * acinclude.m4 (GMP_PROG_CC_IS_GNU, GMP_PROG_CXX_WORKS): Send compiler errors to config.log. * mpq/Makefile.am (INCLUDES): Remove -DOPERATION_$*, not needed. * mpn/x86/*.asm: Change references to old README.family to just README. * mpz/README: Remove file, now adequately covered in the manual. 2001-10-03 Torbjorn Granlund * mpn/x86/pentium4/copyi.asm: New file. * mpn/x86/pentium4/copyd.asm: New file. * gmp-impl.h: Implement separate MPN_COPY_INCR and MPN_COPY_DECR macros for CRAY systems. (CRAY _MPN_COPY): Delete. 2001-10-02 Kevin Ryde * tests/mpz/t-popcount.c (check_data): Use "~ (unsigned long) 0" to avoid compiler warnings on sco. * mpbsd/Makefile.am: Compile mpz files directly, no copying. Use mpz/add.c and mpz/sub.c rather than mpz/aors.c. (INCLUDES): Remove -DOPERATION_$*, no longer needed (by mpz). * mpz/aors.h: Renamed from mpz/aors.c. * mpz/add.c, mpz/sub.c: New files, using mpz/aors.h. * mpz/aors_ui.h: Renamed from mpz/aors_ui.c. * mpz/add_ui.c, mpz/sub_ui.c: New files, using mpz/aors_ui.h. * mpz/fits_s.h: Renamed and adapted from mpz/fits_s.c. * mpz/fits_sshort.c, mpz/fits_sint.c, mpz/fits_slong.c: New files. * mpz/mul_i.h: Renamed from mpz/mul_siui.c. * mpz/mul_ui.c, mpz/mul_ui.c: New files, using mpz/mul_i.h. * mpz/Makefile.am: Consequent updates. (INCLUDES): Remove -DOPERATION_$*. * mpf/fits_s.h: Renamed and adapted from mpf/fits_s.c. * mpf/fits_sshort.c, mpf/fits_sint.c, mpf/fits_slong.c: New files. * mpf/fits_u.h: Renamed and adapted from mpf/fits_u.c. * mpf/fits_ushort.c, mpf/fits_uint.c, mpf/fits_ulong.c: New files. * mpf/Makefile.am: Consequent updates. (INCLUDES): Remove -DOPERATION_$*. * cxx/osfuns.cc (__gmp_doprnt_params_from_ios): Don't use ios::hex etc as cases in a switch, they're not constant in g++ 3.0. * mpn/Makeasm.am (.s.o, .s.obj, .S.o, .S.obj, .asm.o, .asm.obj): Locate source file with test -f the same as automake. (.S): Let CCAS do the preprocessing, and run libtool for .S.lo. (.asm.lo): Run libtool via m4-ccas to get new style foo.lo right. (COMPILE_FLAGS): Add $(DEFAULT_INCLUDES), per new automake. * mpn/m4-ccas: New file. * mpn/Makefile.am (EXTRA_DIST): Add it. * mpn/asm-defs.m4: Add m4_not_for_expansion(`DLL_EXPORT'). * mpn/x86/x86-defs.m4: Undefine PIC if DLL_EXPORT is set. * configure.in (CFLAGS_PIC, ASMFLAGS_PIC): Remove, no longer needed. * acinclude.m4 (GMP_FUNC_VSNPRINTF): Warn what's omitted when vsnprintf not available. * mpn/underscore.h: Remove file, not used since m68k converted to asm. * mpn/Makefile.am (EXTRA_DIST): Remove it. * tests/refmpz.c: Add , for free(). 2001-10-01 Torbjorn Granlund * mpn/x86/pentium4/sse2/submul_1.asm: Apply some algebraic simplifications. * mpn/x86/pentium4/sse2/addmul_1.asm: Comment. 2001-10-01 Kevin Ryde * configure.in (--enable-cxx): New option for C++ support. Add cxx and tests/cxx subdirectories. * ltmain.sh, aclocal.m4: Update to libtool 2001-09-30. * cxx/Makefile.am, cxx/Makefile.in, cxx/osdoprnti.cc, cxx/osfuns.cc, cxx/osmpf.cc, cxx/osmpq.cc, cxx/osmpz.cc: New files. * Makefile.am: Add them, in new libgmpxx. * gmp-h.in, gmp-impl.h: Prototypes and support. * tests/cxx/Makefile.am, tests/cxx/Makefile.in, tests/cxx/t-ostream.cc: New files. * tune/speed.h (SPEED_ROUTINE_MPN_GCD_CALL, SPEED_ROUTINE_MPN_GCDEXT_ONE): mpn_gcdext needs size+1 for destinations. Found by Torbjorn. * gmp-h.in (__GNU_MP__, __GNU_MP_VERSION): Bump to 4.0. * mp-h.in (__GNU_MP__): Ditto. * gmp.texi, Makefile.am, compat.c: Amend version 3.2 to 4.0. * acinclude.m4 (GMP_PROG_CXX_WORKS): New macro. (GMP_PROG_CC_WORKS): Write "conftest" test program, not a.out. * gmp-impl.h (struct gmp_asprintf_t): Moved from printf/vasprintf.c. (GMP_ASPRINTF_T_INIT): New macro. (GMP_ASPRINTF_T_NEED): New macro, adapted from vasprintf.c NEED(). * printf/vasprintf.c: Use these. * printf/asprntffuns.c: New file. * printf/Makefile.am, Makefile.am: Add it. * printf/asprntffuns.c, printf/vasprintf.c, gmp-impl.h (__gmp_asprintf_memory, __gmp_asprintf_reps, __gmp_asprintf_final): Move to asprntffuns.c, rename to __gmp and make global, remove spurious formal parameters from __gmp_asprintf_final. * configure.in (j90-*-*, sv1-*-*): Don't duplicate $path in $add_path. (*-*-mingw*): Don't assemble with -DPIC (as per cygwin). * printf/snprntffuns.c (gmp_snprintf_final): Remove spurious formal parameters. * tune/tuneup.c (POWM_THRESHOLD): Reduce stop_factor to 1.1 to help Cray vector systems. * tests/misc.c (tests_rand_start): Print GMP_CHECK_RANDOMIZE=NN to facilitate cut and paste when re-running. * tests/mpz/t-inp_str.c (check_data): Add more diagnostic prints. 2001-09-30 Kent Boortz * macos/configure, macos/Makefile.in, macos/README: Updates for gmp 4. * gmp-h.in (_GMP_H_HAVE_FILE): Recognise Apple MPW. 2001-09-30 Torbjorn Granlund * mpn/cray/ieee/submul_1.c: Rewrite. Streamline multiplications; use `majority' logic. 2001-09-27 Torbjorn Granlund * gmp-h.in (__GMPN_AORS_1): Rewrite to work around Cray compiler bug. 2001-09-26 Torbjorn Granlund * mpn/x86/pentium4/sse2/gmp-mparam.h: New file. 2001-09-26 Kevin Ryde * mpn/x86/pentium4/sse2/dive_1.asm: New file. * mpn/x86/pentium4/sse2/submul_1.asm: New file. * mpn/x86/pentium4/sse2/sqr_basecase.asm: New file. * mpn/x86/pentium/copyi.asm: New file, based on past work by Torbjorn. * mpn/x86/pentium/copyi.asm: New file, ditto. * mpn/x86/pentium/com_n.asm: Rewrite, ditto. * printf/snprntffuns.c (gmp_snprintf_format): Copy va_list in case vsnprintf trashes it. * printf/vasprintf.c (gmp_asprintf_format): Ditto. * gmp-impl.h, doprnt.c (va_copy): Move to gmp-impl.h. * tests/mpz/t-cmp_d.c (check_low_z_one): Patch by Torbjorn for vax limited float range. 2001-09-23 Torbjorn Granlund * mpn/vax/lshift.s: Change `jsob*' to `sob*'. * mpn/vax/rshift.s: Likewise. 2001-09-23 Kevin Ryde * mpn/x86/pentium4/sse2/mul_basecase.asm: Some simple but real code. * printf/doprnt.c: Use va_copy for va_list variables, copy function parameter in case it's call-by-reference. * tune/freq.c (speed_cpu_frequency_bsd_dmesg): New function. (speed_cpu_frequency_table): Use it. * tune/many.pl (popcount, hamdist): Fix declared return value. (sb_divrem_mn): Remove a spurious duplicate entry. (CLEAN): Add tmp-$objbase.c when using that for .h files. (macro_speed): Give a default for .h files. Add ATTRIBUTE_CONST or __GMP_ATTRIBUTE_PURE as appropriate. * tune/speed.h (SPEED_ROUTINE_MPN_MOD_CALL, SPEED_ROUTINE_MPN_PREINV_MOD_1, SPEED_ROUTINE_MPN_POPCOUNT, SPEED_ROUTINE_MPN_HAMDIST, SPEED_ROUTINE_MPN_GCD_1N, SPEED_ROUTINE_MPN_GCD_1_CALL, SPEED_ROUTINE_MPZ_JACOBI): Use return values so gcc 3 won't discard calls to pure or const functions. (mpn_mod_1_div, mpn_mod_1_inv): Add __GMP_ATTRIBUTE_PURE. 2001-09-22 Torbjorn Granlund * mpn/x86/pentium4/sse2/mul_basecase.asm: New file, placeholder for real code, hiding the default x86 mul_basecase.asm. 2001-09-22 Kevin Ryde * configure.in (AC_PREREQ): Bump to 2.52. (m4_pattern_forbid, m4_pattern_allow): New calls, forbid GMP_. (AC_CHECK_HEADERS): Remove sys/types.h, already done by autoconf. * acinclude.m4, configure.in (GMP_GCC_NO_CPP_PRECOMP): New macro. * tests/devel/try.c (TYPE_PREINV_MOD_1): Don't run size==0. (malloc_region): Need fd=-1 for mmap MAP_ANON on BSD. 2001-09-20 Torbjorn Granlund * mpz/cong.c (mpz_congruent_p): Fix one-limb c * mpn/x86/pentium4/sse2/diveby3.asm: New file. * mpn/x86/pentium4/sse2/mode1o.asm: New file. 2001-09-16 Kevin Ryde * printf/doprnt.c: '#' means showpoint and showtrailing for %e, %f, %g. * tests/printf/t-printf.c (check_f): More test cases. 2001-09-15 Torbjorn Granlund * gmp-h.in (__GMPN_AORS_1): Remove param TEST, add OP and CB. Postpone zeroing of (cout). (__GMPN_ADD_1, __GMPN_SUB_1): Corresponding changes. 2001-09-14 Kevin Ryde * ChangeLog: Merge in tests/rand/ChangeLog. * tests/rand/ChangeLog: Remove file. * printf/doprnt.c: Fix handling of a plain format after a GMP one; no need to protect against negative precision internally. * tests/printf/t-printf.c (check_misc): More checks. 2001-09-12 Torbjorn Granlund * mpn/cray/ieee/invert_limb.c: Add a PROLOGUE in a comment to have HAVE_NATIVE_... defined. 2001-09-11 Kevin Ryde * configure.in, gmp-h.in (__GMP_HAVE_HOST_CPU_FAMILY_power, __GMP_HAVE_HOST_CPU_FAMILY_powerpc): New AC_SUBSTs. * gmp-h.in (__GMPN_COPY_INCR): Use them to select the power/powerpc code, rather than preprocessor defines. * acinclude.m4, configure.in (GMP_H_ANSI): New macro. * gmp-h.in (__GMP_EXTERN_INLINE): Add a definition for SCO 8 cc. * gmp-h.in, version.c (gmp_version): Make the pointer "const" as well as the string. * acinclude.m4, configure.in (GMP_PROG_CC_IS_XLC): Recognise xlc when invoked under another name (cc, xlc128, etc). * acinclude.m4 (GMP_PROG_CC_IS_GCC): Print a message when recognised. 2001-09-11 Torbjorn Granlund * gmp-h.in: Let __DECC mean __GMP_HAVE_CONST, etc. * mp-h.in: Likewise. 2001-09-10 Torbjorn Granlund * mpn/x86/pentium4/mmx/lshift.asm: New file. * mpn/x86/pentium4/mmx/rshift.asm: New file. * tests/mpn/t-iord_u.c (check_incr_data): Work around HP compiler bug. (check_decr_data): Likewise. 2001-09-08 Kevin Ryde * gmp.texi (Integer Logic and Bit Fiddling): Update mpz_hamdist behaviour, clarify mpz_popcount a touch. (Language Bindings): Add mlton, fix alphabetical order. (Single Limb Division): Describe 2 or 1/2 limbs at a time style. * configure.in (AC_CHECK_FUNCS): Add mmap. * tests/devel/try.c (malloc_region): Use mmap if available. * tests/refmpz.c, tests/tests.h (refmpz_hamdist): New function. * tests/mpz/t-hamdist.c: New file. * tests/mpz/Makefile.am: Add it. * mpz/hamdist.c: Support neg/neg operands. * macos/Makefile.in: Remove dual compile of mpq/aors.c and mpn/generic/popham.c. * gmp-impl.h (popc_limb): New macro, adapted from mpn/generic/popham.c. For 64-bits reuse 0x33...33 constant. * mpn/generic/popcount.c, mpn/generic/hamdist.c: Split from popham.c, use popc_limb macro, remove unused "i", don't bother with "register" qualifiers. * mpn/generic/popham.c: Remove file. * ltmain.sh, configure, aclocal.m4: Update to libtool 1.4.1, with one ltdll.c generation patch. * doc/configuration: Misc updates, note libtool patch used. * mpn/x86/pentium4/sse2/mul_1.asm: Use pointer increments not indexed addressing, to get 4.0 c/l flat. * tests/mpq/t-cmp_si.c (check_data): Use ULONG_MAX for denominators. * tests/misc.c (mpz_negrandom): Use given rstate, not RANDS. 2001-09-07 Torbjorn Granlund * mpn/x86/pentium4/sse2/addmul_1.asm: New file. 2001-09-04 Kevin Ryde * tune/freq.c: Define a HAVE for each speed_cpu_frequency routine to avoid duplicating conditionals. (speed_cpu_frequency_sco_etchw): New function. (speed_cpu_frequency_table): Use it. * tune/README: Mention SCO openunix 8 /etc/hw. * mpz/fib_ui.c: Use ?: to avoid a gcc 3 bug on powerpc64. Store back a carry for limb * configure.in (m68k-*-*): Let m68k mean 68000, not 68020. * gmp.texi (Notes for Particular Systems): Update. * gmp-impl.h (union ieee_double_extract) [m68k]: Use longs, since int might be only 16 bits. * tests/mpq/t-aors.c: New file. * tests/mpq/Makefile.am: Add it. * tests/refmpq.c: New file. * tests/Makefile.am: Add it. * tests/tests.h: Add prototypes. * mpq/aors.c: Share object code for mpq_add and mpq_sub. * Makefile.am, mpq/Makefile.am: Single mpq/aors.lo now. * tests/devel/try.c (TYPE_SUBMUL_1): Use correct reference routine. 2001-08-30 Kevin Ryde * mpn/x86/x86-defs.m4 (cmov_available_p): Add pentium4. * gmp-h.in: Put #define renamings with prototypes. Remove commented out #defines of gmp-impl.h things. (mpn_invert_limb): Remove #define, already in gmp-impl.h. (mpn_lshiftc, mpn_rshiftc): Remove #defines, unused. (mpn_addsub_nc): Add prototype to #define. 2001-08-28 Kevin Ryde * gmp.texi: Switch to GFDL. (Top): Arrange copyright and conditions to appear here too. For clarity have all this before the miscellaneous macro definitions. (Copying): Refer to COPYING.LIB file, mention plain GPL2 in demo programs. (Contributors, References): Use @appendix rather than @unnumbered. (GNU Free Documentation License): New appendix. (@contents): Move to start of document, use only for tex (not html). (Debugging): Add leakbug. (Build Options): Add pentium4. (I/O of Rationals): Add mpq_inp_str. * fdl.texi: New file, with two @appendix directive tweaks. * Makefile.am (gmp_TEXINFOS): Add it. * tests/mpz/io.c: Check mpz_inp_str return against ftell, send error messages just to stdout. * mpz/inp_str.c, gmp-impl.h (__gmpz_inp_str_nowhite): New function, and share a __gmp_free_func call. * mpq/inp_str.c: New file. * Makefile.am, mpq/Makefile.am: Add it. * tests/mpq/t-inp_str.c: New file. * tests/mpq/Makefile.am (check_PROGRAMS): Add it. * configure.in, acconfig.h (HAVE_HOST_CPU_FAMILY_power, HAVE_HOST_CPU_FAMILY_powerpc, HAVE_HOST_CPU_FAMILY_x86): AC_DEFINEs for processor families. * gmp-impl.h: Use them, rather than cpp defines. * demos/Makefile.am (primes_LDADD): Use $(LIBM), for log(). * tune/many.pl, tune/Makefile.am: Fix some from clean and distclean. 2001-08-26 Kevin Ryde * tests/devel/try.c (ARRAY_ITERATION): Make types match on "?:" legs. (TYPE_MPZ_JACOBI, TYPE_MPZ_KRONECKER): Remove some superseded code. * tests/printf/t-printf.c (check_plain): Don't compare "all digits" precision against plain printf. * tune/Makefile.am: Eliminate empty TUNE_MPZ_SRCS. * configure, config.in, INSTALL.autoconf: Update to autoconf 2.52. * */Makefile.in, mdate-sh, missing, aclocal.m4, configure: Update to automake 1.5. * configfsf.guess, configfsf.sub: Update to 2001-08-23. 2001-08-24 Torbjorn Granlund * demos/primes.c: Complete rewrite. 2001-08-24 Kevin Ryde * longlong.h: Test __ppc__ for apple darwin cc, reported by Jon Becker. Also test __POWERPC__, PPC and __vxworks__. * tune/speed.h (speed_cyclecounter) [x86]: Don't clobber ebx in PIC. 2001-08-22 Kevin Ryde * configure.in (x86 mmx): Correction to mmx path stripping. 2001-08-17 Kevin Ryde * configure.in, acinclude.m4, Makefile.am, printf/Makefile.am, tests/printf/Makefile.am, gmp-h.in, gmp-impl.h, gmp.texi: Remove C++ support, for the time being. * printf/doprntfx.cc, doprntix.cc, osfuns.cc, osmpf.cc, osmpq.cc, osmpz.cc, tests/printf/t-ostream.cc: Remove files. * printf/doprnt.c, printf/doprntf.c, gmp-impl.h: Use a single __gmp_doprnt_mpf, rather than a separate ndigits calculation. * printf/doprnt.c, printf/doprntf.c, gmp-impl.h, gmp.texi, tests/printf/t-printf.c: Let empty or -1 prec mean all digits for mpf. * printf/doprnt.c, tests/printf/t-printf.c: Accept h or l in %n; let negative "*" style width mean left justify. * gmp-impl.h, mpf/get_str.c (MPF_SIGNIFICANT_DIGITS): New macro, extracted from mpf/get_str.c. * libmp.sym: New file. * Makefile.am (libmp_la_LDFLAGS): Use it. (DISTCLEANFILES): Remove asm-syntax.h, no longer generated. Remove some comments about "make check". * demos/perl/GMP.pm, GMP.xs, GMP/Mpf.pm: Add printf and sprintf, change get_str to string/exponent for floats, remove separate mpf_get_str. * demos/perl/GMP/Mpf.pm (overload_string): Use $# (default "%.g"). * demos/perl/typemap: Fix some duplicate string entries. * demos/perl/test.pl: Update tests, split overloaded constants into ... * demos/perl/test2.pl: ... this new file. * demos/perl/Makefile.PL (clean): Add test.tmp. 2001-08-16 Kevin Ryde * printf/snprntffuns.c (gmp_snprintf_format): Correction to bufsize-1 return value handling. * demos/calc/calc.y: Reposition "%{" so copyright notice gets into generated files. * INSTALL: Use gmp_printf. 2001-08-14 Kevin Ryde * mpz/inp_str.c: Fix return value (was 1 too big). * tests/mpz/t-inp_str.c: New file. * tests/mpz/Makefile.am: Add it. * mpn/x86/pentium4/sse2/add_n.asm: New file. * mpn/x86/pentium4/sse2/sub_n.asm: New file. * mpn/x86/pentium4/sse2/mul_1.asm: New file. 2001-08-12 Kevin Ryde * printf/sprintffuns.c, printf/doprntf.c: Don't use sprintf return value (it's a pointer on SunOS 4). * acinclude.m4 (GMP_ASM_X86_SSE2, GMP_STRIP_PATH): New macros. * configure.in: Add pentium4 support. * mpn/x86/pentium4, mpn/x86/pentium4/mmx, mpn/x86/pentium4/sse2: New directories. * mpn/x86/README: Update. 2001-08-10 Torbjorn Granlund * demos/pexpr.c (setup_error_handler): Catch also SIGABRT. 2001-07-31 Kevin Ryde * tests/refmpn.c (refmpn_mul_1c): Allow low to high overlaps. * gmp-h.in, gmp-impl.h (_gmp_rand): Move prototype to gmp-impl.h. * tune/Makefile.am (EXTRA_DIST): Add many.pl. 2001-07-28 Kevin Ryde * gmp.texi (Random Number Functions): Old rand functions no longer use the C library. * configure.in, acinclude.m4 (GMP_FUNC_VSNPRINTF): New macro. * mpn/generic/get_str.c: Add an ASSERT for high limb non-zero. 2001-07-24 Kevin Ryde * gmp.texi (Build Options): Add --enable-cxx. (Converting Floats): Note mpf_get_str only generates accurately representable digits. (Low-level Functions): Note mpn_get_str requires non-zero high limb. (Formatted Output): New chapter. (Multiplication Algorithms): Use @quotation with @multitable. (Toom-Cook 3-Way Multiplication): Ditto. * tests/memory.c (tests_free_nosize): New function. * tests/tests.h (tests_allocate etc): Add prototypes. * tests/printf: New directory. * tests/printf/Makefile.am, t-printf.c, t-ostream.cc: New files. * configure.in, tests/Makefile.am: Add them. * configure.in, acinclude.m4 (GMP_PROG_CXX): New macro. * configure.in (--enable-cxx): New option. (AC_CHECK_HEADERS): Add locale.h and sys/types.h, remove unistd.h. (AC_CHECK_TYPES): Add intmax_t, long double, long long, ptrdiff_t, quad_t. (AC_CHECK_FUNCS): Add localeconv, memset, obstack_vprintf, snprintf, strchr, vsnprintf. (AC_CHECK_DECLS): Add vfprintf. * gmp-h.in, gmp-impl.h: Additions for gmp_printf etc. * printf: New directory. * printf/Makefile.am, asprintf.c, doprnt.c, doprntf.c, doprntfx.cc, doprnti.c, doprntix.cc, fprintf.c, obprintf.c, obprntffuns.c, obvprintf.c, osfuns.cc, osmpf.cc, osmpq.cc, osmpz.cc, printf.c, printffuns.c, snprintf.c, snprntffuns.c, sprintf.c, sprintffuns.c, vasprintf.c, vfprintf.c, vprintf.c, vsnprintf.c, vsprintf.c: New files. * configure.in, Makefile.am: Add them. * configure.in (HAVE_INLINE): Remove AC_DEFINE, unused. (AC_CHECK_TYPES): Don't test for void, assume it always exists. * gmp-impl.h (__GMP_REALLOCATE_FUNC_MAYBE): New macro. * mpz/get_str.c, mpq/get_str.c, mpf/get_str.c: Use it. * gmp-impl.h (mpn_fib2_ui): Use __MPN. (MPN_COPY_DECR): Fix an ASSERT. (CAST_TO_VOID): Remove macro. * gmp-h.in (mpq_out_str): Give #define even without prototype. (mpz_cmp_d, mpz_cmpabs_d): Corrections to #defines. * tests/devel/try.c: Add mpn_add and mpn_sub, don't use CAST_TO_VOID. 2001-07-23 Torbjorn Granlund * config.guess: Recognize pentium4. * config.sub: Recognize pentium4. 2001-07-17 Kevin Ryde * gmp-h.in (__GMPN_AORS_1): Remove x86 and gcc versions, leave just one version. (__GMPN_ADD, __GMPN_SUB): New macros, rewrite of mpn_add and mpn_sub. (mpn_add, mpn_sub): Use them. (__GMPN_COPY_REST): New macro. * gmp-h.in, gmp-impl.h, acinclude.m4: Remove __GMP_ASM_L and __GMP_LSYM_PREFIX, revert to ASM_L in gmp-impl.h and AC_DEFINE of LSYM_PREFIX. 2001-07-11 Kevin Ryde * gmp-h.in (__GMPN_ADD_1 etc) [x86]: Don't use this on egcs 2.91. * mpz/fits_uint.c, fits_ulong.c, mpz/fits_ushort.c: Split up fits_u.c. * mpz/fits_u.c: Remove file. * mpz/Makefile.am, macos/Makefile.in: Update. * tests/refmpn.c,tests.h (refmpn_copy): New function. * tests/devel/try.c (TYPE_ZERO): No return value from call. (TYPE_MODEXACT_1_ODD, TYPE_MODEXACT_1C_ODD): Share call with TYPE_MOD_1 and TYPE_MOD_1C. (MPN_COPY, __GMPN_COPY, __GMPN_COPY_INCR): Add testing. 2001-07-10 Kevin Ryde * gmp-h.in (__GMPN_COPY): Add form to help gcc on power and powerpc. * gmp-impl.h (MPN_COPY_INCR, MPN_COPY_DECR, MPN_ZERO): Ditto. * mpn/powerpc64/copyi.asm, mpn/powerpc64/copyd.asm: Remove files. * mpz/tdiv_ui.c: Eliminate some local variables (seems to save code on i386 gcc 2.95.x), remove a bogus comment about quotient. * errno.c, gmp-impl.h (__gmp_exception, __gmp_divide_by_zero, __gmp_sqrt_of_negative): New functions. * gmp-impl.h (GMP_ERROR, DIVIDE_BY_ZERO, SQRT_OF_NEGATIVE): Use them. * randclr.c, randraw.c: Use ASSERT(0) for unrecognised algorithms. 2001-07-07 Kevin Ryde * configure.in (powerpc*-*-*): Use -no-cpp-precomp for Darwin. * tests/mpbsd/t-itom.c: Renamed from t-misc.c. * tests/mpbsd/t-misc.c: Remove file. * tests/mpbsd/Makefile.am: Update. * tests/mpf/t-set_si.c,t-cmp_si.c,t-gsprec.c: Split from t-misc.c. * tests/mpf/t-misc.c: Remove file. * tests/mpf/Makefile.am: Update. * tests/mpz/t-oddeven.c,t-set_si.c,t-cmp_si.c: Split from t-misc.c. * tests/mpz/t-misc.c: Remove file. * tests/mpz/Makefile.am: Update. * stack-alloc.c: Add some alignment ASSERTs. * gmp-impl.h (MPN_NORMALIZE): Add notes on x86 repe/scasl slow. * tests/devel/try.c (MPN_ZERO): Add testing. * tune/speed.c,speed.h,common.c,many.pl (MPN_ZERO): Add measuring. * mpn/x86/divrem_1.asm: Update a remark about gcc and "loop". * tests/mpq/t-cmp_si.c: New file. * tests/mpq/Makefile.am: Add it. * tests/misc.c,tests.h (mpq_set_str_or_abort): New function. * mpq/cmp_si.c: New file. * Makefile.am, mpq/Makefile.am: Add it. * gmp-h.in (mpq_cmp_si): Add prototype. * gmp.texi (Comparing Rationals): Add doco. * gmp-h.in (_GMP_H_HAVE_FILE): Add _FILE_DEFINED for microsoft, add notes on what symbols are for what systems. 2001-07-06 Torbjorn Granlund * longlong.h (ibm032 umul_ppmm): Fix typo. * longlong.h (sparclite sdiv_qrnnd): Fix typo. 2001-07-03 Kevin Ryde * mpz/bin_ui.c (DIVIDE): Use MPN_DIVREM_OR_DIVEXACT_1. * mpz/bin_uiui.c (MULDIV): Ditto, and use local variables for size and pointer. * acinclude.m4 (GMP_INCLUDE_GMP_H): New macro, use it everywhere gmp.h is wanted at configure time. * acinclude.m4, configure.in (GMP_H_EXTERN_INLINE, GMP_H_HAVE_FILE): New macros. * gmp-h.in (__GMP_EXTERN_INLINE): Set to "inline" for C++. (mpn_add, mpn_sub): Use new style __GMP_EXTERN_INLINE. * gmp-h.in, mp-h.in, gmp-impl.h (_EXTERN_INLINE): Remove, unused. * mpn/generic/add.c, mpn/generic/sub.c: New files. * mpn/generic/inlines.c: Remove file. * configure.in, mpn/Makefile.am: Update. * gmp.texi (GMP Basics): Note the need for stdio.h to get FILE prototypes. 2001-07-01 Kevin Ryde * gmp.texi (Build Options, Reentrancy): Updates for new --enable-alloca behaviour. (Debugging): Describe --enable-alloca=debug. (Miscellaneous Integer Functions): Note mpz_sizeinbase ignores signs. (Low-level Functions): Give a formula for mpn_gcdext cofactor. (Factorial Algorithm): New section. (Binomial Coefficients Algorithm): New section. Misc tweaks elsewhere. * mpf/set_prc.c: Merge the two truncation conditionals, misc cleanups, no functional changes. * mpn/*/gmp-mparam.h (DIVEXACT_1_THRESHOLD): Add tuned values. * gmp-impl.h (DIVEXACT_1_THRESHOLD): Make the default 0 when 2*UMUL_TIME < UDIV_TIME. * mpn/x86/p6/dive_1.asm: New file. * mpn/x86/dive_1.asm: New file. * mpn/x86/gmp-mparam.h (DIVEXACT_1_THRESHOLD): Use it always. * tests/refmpn.c, tests.h (refmpn_zero): New function. * tests/devel/try.c: Use it. * tests/refmpn.c (refmpn_sb_divrem_mn): Use refmpn_cmp, not mpn_cmp. * tests/mpf/t-get_d.c (main): Use || not |. * tests/misc.c, tests/t-modlinv.c, tests/mpq/t-get_str.c, tests/mpf/reuse.c: Add string.h. 2001-06-29 Kevin Ryde * tune/speed.h (SPEED_ROUTINE_MPN_FIB2_UI, SPEED_ROUTINE_COUNT_ZEROS_C): Corrections to TMP block handling. * gmp-impl.h (MPN_TOOM3_MUL_N_MINSIZE, MPN_TOOM3_SQR_N_MINSIZE): Corrections to these to account for adding tD into E. (MPN_INCR_U, MPN_DECR_U) [WANT_ASSERT]: Add size assertions, since mpn_add_1 and mpn_sub_1 from gmp.h don't get them. (MPN_DIVREM_OR_DIVEXACT_1): Add an assert of no remainder. * assert.c: Add stdlib.h for abort prototype. * tests/spinner.c, trace.c, t-constants.c, t-count_zeros.c, t-gmpmax.c, t-modlinv.c: Ditto. * tests/mpz/t-bin.c, t-cmp.c, t-get_si.c, t-misc.c, t-popcount.c, t-set_str.c, t-sizeinbase.c: Ditto. * tests/mpq/t-equal.c, t-get_str.c, t-set_f.c, t-set_str.c: Ditto. * tests/mpf/t-fits.c, t-get_d.c, t-get_si.c, t-int_p.c, t-misc.c, t-trunc.c: Ditto. * tests/mpbsd/allfuns.c, t-misc.c: Ditto. * mpn/generic/mul_n.c, mpz/cfdiv_r_2exp.c: Use MPN_INCR_U rather than mpn_incr_u. * tests/devel/try.c (TYPE_SB_DIVREM_MN): More fixes for calling method. * mpn/x86/k6/cross.pl: More insn exceptions. 2001-06-23 Kevin Ryde * gmp-h.in (__GMPN_ADD_1, __GMPN_SUB_1) [i386]: Fix some asm output constraints. * gmp-impl.h (modlimb_invert): Mask after shifting, so mask constant fits a signed byte. * tests/devel/try.c (TYPE_SB_DIVREM_MN): Fix initial fill of quotient with garbage. 2001-06-20 Kevin Ryde * config.guess (rs6000-*-aix4* | powerpc-*-aix4*): Suppress error messages if $CC_FOR_BUILD or program don't work. * mpz/sqrt.c,sqrtrem.c: Special case for op==0, to avoid TMP_ALLOC(0). * tests/refmpf.c (refmpf_add, refmpf_sub): Avoid TMP_ALLOC(0). * tests/mpn/t-aors_1.c: New file. * tests/mpn/Makefile.am: Add it. * gmp-h.in (__GMPN_ADD_1, __GMPN_SUB_1): New macros, rewrite of mpn_add_1 and mpn_sub_1, better code for src==dst and/or n==1, separate versions for gcc x86, gcc generic, and non-gcc. (mpn_add_1, mpn_sub_1): Use them. (mpn_add, mpn_sub): Ditto, to get inlines on all compilers. (extern "C") [__cplusplus]: Let this encompass the extern inlines too. * mpn/generic/add_1.c,sub_1.c: New files, force code from gmp.h. * configure.in, mpn/Makefile.am: Add them. * acinclude.m4 (GMP_ASM_LSYM_PREFIX): AC_SUBST __GMP_LSYM_PREFIX rather than AC_DEFINE LSYM_PREFIX. * gmp-h.in (__GMP_LSYM_PREFIX): New substitution. (__GMP_ASM_L): New macro. * gmp-impl.h (ASM_L): Use it. * acinclude.m4, configure.in (GMP_C_ATTRIBUTE_MALLOC): New macro. * gmp-impl.h: Use it for all the malloc based TMP_ALLOCs. * stack-alloc.h: Remove file. * tal-reent.c: New file. * Makefile.am: Update. * acinclude.m4, configure.in (GMP_OPTION_ALLOCA): New macro, add malloc-reentrant method, use stack-alloc.c as malloc-notreentrant, make "reentrant" the default. * gmp-impl.h (__TMP_ALIGN): Moved from stack-alloc.c, use a union to determine the value, and demand only 4 bytes align on 32-bit systems. * gmp-impl.h (WANT_TMP_NOTREENTRANT): Move global parts of stack-alloc.h to here, allow non power-of-2 __TMP_ALIGN in TMP_ALLOC. * gmp-impl.h: Extend extern "C" to TMP_ALLOC declarations. * stack-alloc.c (tmp_stack): Move private parts of stack-alloc.h to here, use gmp-impl.h. * gmp-impl.h (TMP_ALLOC_LIMBS_2): New macro. * mpz/fib_ui.c, mpz/jacobi.c, mpq/cmp.c, mpn/generic/fib2_ui.c: Use it. * mpfr/exp2.c: Patch by Paul to match TMP_MARK and TMP_FREE in loop. * mpfr/sqrt.c: Scope nested TMP_DECL into nested { } block, patch by Paul, tweaked by me. * mpfr/agm.c: Ditto, and add a final TMP_FREE(marker2). * gmp-h.in (mpn_cmp): Add __GMP_ATTRIBUTE_PURE. * INSTALL: Clarify "make install", tweak formatting a bit. 2001-06-17 Kevin Ryde * configure.in, Makefile.am, gmp-impl.h: Add a debugging TMP_ALLOC, selected with --enable-alloca=debug. * tal-debug.c: New file. * configure.in, Makefile.am: Compile stack-alloc.c only for --disable-alloca. * assert.c (__gmp_assert_header): New function, split from __gmp_assert_fail. * mpz/lcm.c: Don't TMP_MARK and then just return. Remove unnecessary _mpz_realloc prototype. * mpn/generic/mul.c (mpn_sqr_n): Use __gmp_allocate_func for toom3 temporary workspace. 2001-06-15 Kevin Ryde * tests/mpz/t-set_f.c: New file. * tests/mpz/Makefile.am (check_PROGRAMS): Add it. * mpz/set_f.c: Share MPN_COPY between pad and trunc cases, do exp<=0 test earlier, store SIZ(w) earlier. * tests/t-count_zeros.c: New file. * tests/t-gmpmax.c: New file. * tests/Makefile.am (check_PROGRAMS): Add them. * mp_clz_tab.c: Compile the table only if longlong.h says it's needed; add an internal-use-only comment. * tune/common.c: Force a __clz_tab for convenience when testing. * mpn/x86/pentium/gmp-mparam.h, mpn/x86/pentium/mmx/gmp-mparam.h: Add COUNT_LEADING_ZEROS_NEED_CLZ_TAB, for mod_1.asm. * longlong.h (count_leading_zeros) [pentium]: Decide to go with float method for p54. (count_leading_zeros) [alpha]: Add COUNT_LEADING_ZEROS_NEED_CLZ_TAB. (__clz_tab): Provide a prototype only if it's needed. * tests/trace.c (mpz_trace): Don't use = on structures. (mpn_trace): Set _mp_alloc when creating mpz. 2001-06-12 Kevin Ryde * mpn/x86/divrem_1.asm: Amend some comments about P5 speed. * tune/README: Clarify reconfigure on gmp-mparam.h update. * mpn/x86/p6/copyd.asm: New file. * mpn/x86/p6/README: Update copyd and mod_1. * mpn/x86/copyd.asm: Amend some comments. * gmp-impl.h (__builtin_constant_p): Add dummy for non-gcc. (mpn_incr_u, mpn_decr_u): Recognise incr==1 at compile time in the generic code on gcc. * gmp-impl.h (ASSERT_ZERO_P, ASSERT_MPN_NONZERO_P): New macros. * mpn/generic/gcd_1.c, mpn/generic/mul_fft.c: Use them. * mpz/get_d.c: Add a private mpn_zero_p. * mpfr/trunc.c: Use own mpn_zero_p. * tune/speed.h (SPEED_ROUTINE_MPN_GCD_1N): Use refmpn_zero_p. * gmp-impl.h (mpn_zero_p): Remove, no longer needed. * gmp-h.in, gmp-impl.h: Move MPN_CMP to gmp.h as __GMPN_CMP, leave an MPN_CMP alias in gmp-impl.h. * gmp-h.in (mpn_cmp): Add an inline version. * mpn/generic/cmp.c: Use __GMP_FORCE_mpn_cmp to get code from gmp.h. * acinclude.m4 (GMP_C_ATTRIBUTE_MODE): New macro. * configure.in: Call it. * gmp-impl.h (SItype etc): Use it. * randraw.c (lc): Change mpn_mul_basecase->mpn_mul, mpn_incr_u->MPN_INCR_U, abort->ASSERT_ALWAYS(0). * longlong.h (count_leading_zeros) [pentiumpro]: Work around a partial register stall on gcc < 3. * gmp.texi (Introduction to GMP): Add IA-64. (Notes for Particular Systems): i386 means generic x86. * tests/t-modlinv.c: Use tests_start and tests_end. 2001-06-10 Kevin Ryde * gmp.texi (Number Theoretic Functions): mpz_jacobi only defined for b odd. Separate the jacobi/legendre/kronecker descriptions. (Low-level Functions): Document mpn_mul_1 "incr" overlaps. (Language Bindings): New chapter. * mpz/jacobi.c: Don't retaining old behaviour of mpz_jacobi on even b (it wasn't documented in 3.1.1). * mpz/jacobi.c, gmp-h.in (mpz_kronecker, mpz_legendre): Remove separate entrypoints, just #define to mpz_jacobi. * compat.c (__gmpz_legendre): Add compatibility entrypoint. * mpn/generic/mul_1.c: Allow "incr" style overlaps. * tests/devel/try.c (param_init): Test this. * mpf/mul_ui.c: Do size==0 test earlier. 2001-06-08 Kevin Ryde * gmp-impl.h (ULONG_HIGHBIT, UINT_HIGHBIT, USHRT_HIGHBIT): Cast ULONG_MAX etc to unsigned long etc before attempting to right shift. * acinclude.m4 (GMP_ASM_LSYM_PREFIX): Add an AC_DEFINE of LSYM_PREFIX. * gmp-impl.h (ASM_L): New macro. (mpn_incr_u, mpn_decr_u, MPN_INCR_U, MPN_DECR_U): Add i386 optimized versions. * mpn/hppa/*.s,S,asm: Use .label so the code works with gas on hppa GNU/Linux too, reported by LaMont Jones . * mpn/hppa/README: Add some notes on this. * acinclude.m4 (GMP_ASM_LABEL_SUFFIX): Ditto. * mpn/Makefile.am (nodist_libdummy_la_SOURCES): Add dive_1.c, fib2_ui.c. * tests/mpn/t-iord_u.c: New file. * tests/mpn/Makefile.am (check_PROGRAMS): Add it. * configure.in (mips*-*-irix[6789]*): Make ABI=n32 the default, same as in gmp 3.1. * gmp.texi (ABI and ISA): Update. * gmp.texi (Build Options): Misc tweaks. (Notes for Particular Systems): Describe windows DLL handling. (Known Build Problems): DJGPP needs bash 2.04. (Number Theoretic Functions): mpz_invert returns 0<=r * configure.in, gmp-h.in, mp-h.in: Add support for windows DLLs. 2001-05-26 Kevin Ryde * gmp.texi (ABI and ISA, Reentrancy): Minor tweaks (Notes for Package Builds): Note gmp.h is a generated file. (Notes for Particular Systems): -march=pentiumpro is used for gcc 2.95.4 and up. (Assembler Loop Unrolling): Mention non power-of-2 unrolling. (Internals): New chapter. * mpf/README: Remove file. * demos/expr/README: Miscellaneous rewordings. * demos/perl: New directory. * demos/Makefile.am: Add it. * demos/perl/INSTALL, Makefile.PL, GMP.pm, GMP.xs, typemap, GMP/Mpz.pm, GMP/Mpq.pm, GMP/mpf.pm, GMP/Rand.pm, sample.pl, test.pl: New files. * configure, aclocal.m4: Update to autoconf 2.50. * configure, aclocal.m4, ltmain.sh: Update to libtool 1.4. * configure, aclocal.m4, missing, ansi2knr.c, */Makefile.in: Update to automake 1.4f. * Makefile.am: Conditionalize mpfr in $(SUBDIRS) to handle mpfr.info. * mpfr/Makefile.am (INFO_DEPS): Remove previous mpfr.info handling. * mpn/Makefile.am (GENERIC_SOURCES): Remove this, just put mp_bases.c in libmpn_la_SOURCES. * tests/Makefile.am (tests.h): Move from EXTRA_HEADERS to libtests_la_SOURCES. * ltconfig: Remove file, no longer needed. * Makefile.am (gmp-impl.h, longlong.h, stack-alloc.h): Move from EXTRA_DIST to libgmp_la_SOURCES, so they get included in TAGS. * tests/rand/Makefile.am (gmpstat.h): Move to libstat_la_SOURCES similarly. * config.guess (68k-*-*): Use $SHELL not "sh", tweak some comments. * mpfr/mpfr.texi (Introduction to MPFR): Tweak table formatting, note non-free programs must be able to be re-linked. 2001-05-20 Kevin Ryde * mpn/powerpc64/addmul_1.asm, mpn/powerpc64/mul_1.asm, mpn/powerpc64/submul_1.asm: Add carry-in entrypoints. 2001-05-17 Kevin Ryde * gmp.texi (ge): Fix definition for info. (Notes for Particular Systems): Mention 68k dragonball and cpu32. (Efficiency): Add static linking, more about in-place operations, describe mpq+/-integer using addmul. (Reporting Bugs): A couple of words about self-contained reports. (Floating-point Functions): Note exponent limitations of mpf_get_str and mpf_set_str. (Initializing Floats): Clarify mpf_get_prec, mpf_set_prec and mpf_set_prec_raw a bit. (Float Comparison): Note current mpf_eq deficiencies. * gmp-h.in (__GMP_HAVE_CONST, __GMP_HAVE_PROTOTYPES, __GMP_HAVE_TOKEN_PASTE): Merge GNU ansidecl.h tests for ANSI compilers. * demos/expr/expr-impl-h.in: Ditto. * gmp-impl.h (BITS_PER_MP_LIMB): Define from __GMP_BITS_PER_MP_LIMB if not already in gmp-mparam.h. * tests/t-constants.c (BITS_PER_MP_LIMB, __GMP_BITS_PER_MP_LIMB): Check these are the same. * gmp-h.in (mpf_get_default_prec, mpf_get_prec, mpf_set_default_prec, mpf_set_prec_raw): Provide "extern inline" versions, use __GMPF on the macros. * mpf/get_dfl_prc.c, mpf/get_prc.c, mpf/set_dfl_prc.c, mpf/set_prc_raw.c: Get code from gmp.h using __GMP_FORCE. * gmp-h.in, gmp-impl.h (__gmp_default_fp_limb_precision): Move from gmp-impl.h to gmp-h.in. (__GMPF_BITS_TO_PREC, __GMPF_PREC_TO_BITS): Ditto, and use __GMPF prefix and add a couple of casts. * gmp-h.in (__GMP_MAX): New macro. * mpf/init2.c mpf/set_prc.c: Update for __GMPF prefix. * gmp-h.in (__GMP_BITS_PER_MP_LIMB): New templated define. * acinclude.m4 (GMP_C_SIZES): Add AC_SUBST __GMP_BITS_PER_MP_LIMB, remove AC_DEFINE BITS_PER_MP_LIMB. 2001-05-13 Kevin Ryde * gmp-h.in, gmp.texi, Makefile.am, mpz/Makefile.am, tests/mpz/t-pow.c: Remove mpz_si_pow_ui, pending full si support. * mpz/si_pow_ui.c: Remove file. 2001-05-11 Kevin Ryde * mpn/x86/pentium/dive_1.asm: New file. * mpn/powerpc32/umul.asm: Use r on registers. * mpn/powerpc64/umul.asm: New file. * configure.in (powerpc*-*-*): Enable umul in extra_functions. * tests/refmpn.c, tests/tests.h (refmpn_umul_ppmm): Use same arguments as normal mpn_umul_ppmm. (refmpn_mul_1c): Update. * tests/devel/try.c, tune/many.pl: Add some umul_ppmm testing support. * mpn/x86/k6/mmx/popham.asm, mpn/x86/k7/mmx/popham.asm: Don't support size==0. * mpn/x86/pentium/popcount.asm, mpn/x86/pentium/hamdist.asm: Ditto, and shave a couple of cycles from the PIC entry code. * mpz/mul.c: Use mpn_mul_1 for size==1 and mpn_mul_2 (if available) for size==2, to avoid copying; do vsize==0 test earlier. * mpf/sub.c: Test r!=u before calling mpf_set. * mpf/add.c: Ditto, and share mpf_set between usize==0 and vsize==0. * mpn/generic/tdiv_qr.c, mpq/get_d.c, mpf/div.c, mpf/set_q.c, mpf/set_str.c, mpf/ui_div.c: Test for high bit set, not for count_leading_zeros zero. * acinclude.m4 (GMP_PROG_AR, GMP_PROG_NM): Print a message if extra flags are added. * tests/mpz/t-mul_i.c: New file. * tests/mpz/Makefile.am: Add it. * mpz/mul_siui.c (mpz_mul_si): Fix for -0x80..00 on long long limb. * gmp-h.in (mpf_set_si, mpf_set_ui): Revert last change, set exp to 0 when n==0. * mpf/ceilfloor.c, mpf/trunc.c: Fix exp to 0 when setting r to 0. * gmp-impl.h (MPF_CHECK_FORMAT): Check exp==0 when size==0. 2001-05-07 Kevin Ryde * gmp-h.in (mpf_set_si, mpf_set_ui): Don't bother setting _mp_exp to 0 when n==0 (use 1 unconditionally). * tests/mpf/t-misc.c (check_mpf_set_si): Don't demand anything of _mp_exp when _mp_size is zero. * mpn/x86/README: Note gas _GLOBAL_OFFSET_TABLE_ with leal problem. * gmp-h.in (mpz_fits_uint_p, mpz_fits_ulong_p, mpz_fits_ushort_p): Provide these as "extern inline"s. (__GMP_UINT_MAX, __GMP_ULONG_MAX, __GMP_USHRT_MAX): New macros. (mpz_popcount): Use __GMP_ULONG_MAX. * gmp-impl.h (UINT_MAX, ULONG_MAX, USHRT_MAX): Use __GMP_U*_MAX, if not already defined. * mpz/fits_u.c: Use the code from gmp.h. 2001-05-06 Kevin Ryde * mpn/x86/k7/dive_1.asm: New file. * mpn/x86/k7/gcd_1.asm: New file. * mpn/asm-defs.m4 (m4_count_trailing_zeros): New macro. * gmp-h.in (mpz_get_ui, mpz_getlimbn, mpz_set_q, mpz_perfect_square_p, mpz_popcount, mpz_size, mpf_set_ui, mpf_set_si, mpf_size): Provide these as "extern inlines". Use just one big extern "C" block. * mpz/getlimbn.c, mpz/get_ui.c, mpz/perfsqr.c, mpz/popcount.c mpz/set_q.c, mpz/size.c, mpf/set_si.c, mpf/set_ui.c, mpf/size.c: Use __GMP_FORCE to get code from gmp.h. 2001-05-03 Kevin Ryde * extract-dbl.c: Add ASSERT d>=0. * gmp.texi (Efficiency): Add mpz_addmul etc for mpz+=integer, add mpz_neg etc in-place. (Integer Arithmetic): Add mpz_addmul, mpz_submul, mpz_submul_ui. (Initializing Rationals): Add mpq_set_str. (Low-level Functions): mpn_set_str requires strsize >= 1. * gmp-h.in (__GMP_EXTERN_INLINE, __GMP_ABS): New macros. (mpz_abs, mpq_abs, mpf_abs, mpz_neg, mpq_neg, mpf_neg): Provide inline versions. * mpz/abs.c, mpq/abs.c, mpf/abs.c, mpz/neg.c, mpq/neg.c, mpf/neg.c: Add suitable __GMP_FORCE to turn off inline versions. * tests/mpz/t-aorsmul.c,t-cmp_d.c,t-popcount,t-set_str.c: New files. * tests/mpz/Makefile.am: Add them. * mpz/aorsmul_i.c: New file, rewrite of addmul_ui.c. Add mpz_submul_ui entrypoint, share more code between some of the conditionals, use mpn_mul_1c if available. * mpz/addmul_ui.c: Remove file. * mpz/aorsmul.c: New file. * Makefile.am, mpz/Makefile.am: Update. * gmp-h.in (mpz_addmul, mpz_submul, mpz_submul_ui): Add prototypes. * gmp-impl.h (mpz_aorsmul_1): Add prototype. * tests/mpq/t-set_str.c: New file. * tests/mpq/Makefile.am: Add it. * mpq/set_str.c: New file. * Makefile.am, mpq/Makefile.am: Add it. * gmp-h.in (mpq_set_str): Add prototype. * mpz/set_str.c: Fix for trailing white space on zero, eg. "0 ". * mpn/generic/set_str.c: Add ASSERT str_len >= 1. * gmp-h.in, gmp-impl.h (mpn_incr_u, mpn_decr_u): Move to gmp-impl.h. * gmp-impl.h (MPN_INCR_U, MPN_DECR_U): New macros. 2001-04-30 Kevin Ryde * tests/mpz/t-lcm.c: New file. * tests/mpz/Makefile.am (check_PROGRAMS): Add it. * mpz/lcm.c: Add one limb special case. * mpz/lcm_ui.c: New file. * Makefile.am, mpz/Makefile.am: Add it. * gmp-h.in (mpz_lcm_ui): Add prototype. * gmp.texi (Number Theoretic Functions): Add mpz_lcm_ui, document lcm now always positive. * mp-h.in (mp_size_t, mp_exp_t): Fix typedefs to match gmp-h.in. * gmp-h.in (mpn_add_1, mpn_add, mpn_sub_1, mpn_sub): Remove K&R function defines (ansi2knr will handle mpn/inline.c, and just ansi is enough for gcc extern inline). * gmp-h.in (__GMP_HAVE_TOKEN_PASTE): New macro. (__MPN): Use it. * gmp-impl.h (CNST_LIMB): Ditto. * gmp-h.in, mp-h.in (__gmp_const, __gmp_signed, _PROTO, __MPN): Use ANSI forms on Microsoft C. (__GMP_HAVE_CONST): New define. * gmp-impl.h (const, signed): Use it. * demos/expr/expr-impl-h.in (): Use this with Microsoft C. (HAVE_STDARG): New define. * demos/expr/expr.c,exprz.c,exprq.c,exprf.c,exprfr.c: Use it. * acinclude.m4 (GMP_C_STDARG): New macro. * configure.in: Call it. * rand.c: Use it. * configure.in (AC_PROG_CC_STDC): New test. 2001-04-25 Kevin Ryde * mpn/x86/k6/mmx/dive_1.asm: New file. * mpn/x86/x86-defs.m4 (Zdisp): Two more insns. * mpn/x86/pentium/mul_2.asm: New file. * mpn/asm-defs.m4: Add define_mpn(mul_2). * acconfig.h (HAVE_NATIVE_mpn_divexact_1, mul_2): Add templates. * configure.in (ABI): Use AC_ARG_VAR. * tests/devel/try.c: Run reference function when validate fails. * mpq/get_str.c: Fixes for negative bases. * tests/mpq/t-get_str.c: Check negative bases. * tests/misc.c,tests.h (__gmp_allocate_strdup, strtoupper): New functions. 2001-04-24 Torbjorn Granlund * mpz/lcm.c (mpz_lcm): Make result always positive. * gmp-h.in (mpz_inp_binary, mpz_out_binary): Remove declarations. 2001-04-22 Kevin Ryde * mpn/powerpc64/addsub_n.asm: Use config.m4 not asm-syntax.m4. * mpz/cmp_d.c, mpz/cmpabs_d.c: New files. * Makefile.am, mpz/Makefile.am: Add them. * mpf/cmp_d.c, mpf/get_dfl_prec.c: New files. * Makefile.am, mpf/Makefile.am: Add them. * gmp-h.in (mpz_cmp_d, mpz_cmpabs_d, mpf_cmp_d, mpf_get_default_prec): Add prototypes. * gmp.texi: Add documentation. * mpf/set_prc.c: Avoid a realloc call if already the right precision. * gmp-impl.h (MPF_BITS_TO_PREC, MPF_PREC_TO_BITS): New macros. * mpf/get_prc.c, init2.c, set_dfl_prec.c, set_prc.c, set_prc_raw.c: Use them. 2001-04-20 Kevin Ryde * tests/devel/try.c: Don't test size==0 on mpn_popcount and mpn_hamdist; add testing for mpn_divexact_1; print some limb values with mpn_trace not printf. * mpz/popcount.c, mpz/hamdist.c: Don't pass size==0 to mpn_popcount and mpn_hamdist. * mpn/generic/popham.c: Don't support size==0. * config.guess (m68k-*-*): Detect m68010, return m68360 for cpu32, cleanup the nesting a bit. * gmp.texi (Integer Division): Fix mpz_congruent_2exp_p "c" type. (Integer Division): Add mpz_divexact_ui. (Number Theoretic Functions): Fix mpz_nextprime return type. (Exact Remainder): Divisibility tests now implemented. And more index entries in a few places. * tests/mpz/dive_ui.c: New file. * tests/mpz/Makefile.am (check_PROGRAMS): Add it. * mpz/dive_ui.c: New file. * Makefile.am, mpz/Makefile.am: Add it. * gmp-h.in (mpz_divexact_ui): Add prototype. * tune/many.pl, tune/speed.h: Add special mpn_back_to_back for development. * gmp-impl.h (MPN_DIVREM_OR_DIVEXACT_1): New macro. * mpz/divexact.c: Use it. * gmp-impl.h (DIVEXACT_1_THRESHOLD): New threshold. * tune/tuneup.c: Tune it. * tune/speed.c,speed.h,common.c,many.pl: Add measuring of mpn_divexact_1, mpn_copyi, mpn_copyd. * mpn/generic/dive_1.c: New file. * configure.in (gmp_mpn_functions): Add it. * gmp-impl.h (mpn_divexact_1): Add prototype. * mpn/asm-defs.m4: Add define_mpn(divexact_1). * tests/mpn: New directory. * tests/Makefile.am: Add it. * tests/mpn/Makefile.am: New file. * configure.in (AC_OUTPUT): Add it. * tests/mpn/t-asmtype.c: New file. * configure, config.in: Update to autoconf 2.49d. * configure.in, gmp-h.in, mp-h.in, demos/expr/expr-impl-h.in: Revert to generating gmp.h, mp.h and expr-impl.h with AC_OUTPUT and AC_SUBST. * configure.in (m68*-*-*): Oops, m683?2 is 68000, m68360 is cpu32. * mpn/m68k/m68k-defs.m4 (scale_available_p): Ditto. * configure.in (underscore, asm_align): Remove these variables, unused. (GMP_ASM_*): Sort by AC_REQUIREs, to avoid duplication. * acinclude.m4 (GMP_ASM_UNDERSCORE, GMP_ASM_ALIGN_LOG): Remove support for actions, no longer needed. 2001-04-17 Kevin Ryde * config.guess (m68k-*-*): Look for cpu in linux kernel /proc/cpuinfo. * acinclude.m4 (GMP_GCC_MARCH_PENTIUMPRO): The -mpentiumpro problem is fixed in 2.95.4, so test for that. (GMP_ASM_TYPE): Amend some comments. * tune/freq.c (speed_cpu_frequency_sysctl): Avoid having unused variables on GNU/Linux. * mpn/asm-defs.m4 (m4_instruction_wrapper): Fix a quoting problem if the name of the file is a macro. 2001-04-15 Kevin Ryde * mpn/powerpc64/*.asm: Add speeds on ppc630. * acconfig.h: Add dummy templates for _LONG_LONG_LIMB and HAVE_MPFR. * configure.in: Ensure config.in is the last AM_CONFIG_HEADER, which autoheader requires. * mpn/x86/pentium/popcount.asm: New file. * mpn/x86/pentium/hamdist.asm: New file. * mpn/asm-defs.m4: (m4_popcount): New macro. Amend a few comments elsewhere. * acinclude.m4 (GMP_ASM_RODATA): If possible, grep compiler output for the right directive. * tune/speed.c: Print clock speed in MHz, not cycle time. * configure.in (AC_CHECK_HEADERS): Check for sys/processor.h. * tune/freq.c (speed_cpu_frequency_processor_info): Require to exist, to differentiate the different processor_info on Darwin. (speed_cpu_frequency_sysctlbyname): Remove hw.model test which is in speed_cpu_frequency_sysctl. (speed_cpu_frequency_sysctl): Add hw.cpufrequency for Darwin. * gmp-impl.h (MPN_LOGOPS_N_INLINE, mpn_and_n ... mpn_xnor_n): Use a single expression argument for the different operations, necessary for the Darwin "smart" preprocessor. * mpn/m68k/t-m68k-defs.pl: Allow white space in m4_definsn and m4_defbranch. * tune/many.pl: Change RM_TMP_S to RM_TMP to match mpn/Makeasm.am, avoid a possibly undefined array in a diagnostic, add more renaming to hamdist. 2001-04-13 Kevin Ryde * ltmain.sh, aclocal.m4, configure, config.in: Update to libtool 1.3d. * configure.in: Change ac_ to lt_ in lt_cv_archive_cmds_need_lc and lt_cv_proc_cc_pic. * config.guess (m68*-*-*): Detect exact cpu with BSD sysctl hw.model, detect 68000/68010 with trapf, detect 68302 with bfffo. 2001-04-11 Kevin Ryde * acinclude.m4 (GMP_ASM_M68K_INSTRUCTION, GMP_ASM_M68K_ADDRESSING, GMP_ASM_M68K_BRANCHES): New macros. * configure.in: Use them, remove old 68k configs, use mc68020 udiv and umul. * mpn/m68k/m68k-defs.m4: New file. * mpn/m68k/t-m68k-defs.pl: New file. * mpn/m68k/*.asm: New files, converted from .S. Merge add_n and sub_n to aors_n, ditto mc68020 addmul_1 and submul_1 to aorsmul_1. No object code changes (except .type and .size now used on NetBSD 1.4). * mpn/m68k/README: New file. * mpn/m68k/*.S, */*.S, syntax.h: Remove files. * configure.in (m68*-*-netbsd1.4*): Pretend getrusage doesn't exist. * tune/README: Update. * configure.in (powerpc*-*-*): For the benefit of Darwin 1.3, add cc to cclist, make gcc_cflags -Wa,-mppc optional. 2001-04-06 Kevin Ryde * mpn/lisp/gmpasm-mode.el (gmpasm-comment-start-regexp): Add | for 68k. (gmpasm-mode-syntax-table): Add to comments. * tests/mpz/reuse.c (dsi_div_func_names): Add names for cdiv_[qr]_2exp. 2001-04-04 Kevin Ryde * acinclude.m4 (GMP_M4_M4WRAP_SPURIOUS): Fix test so as to actually detect the problem, add notes on m68k netbsd 1.4.1. * gmp.texi (Compatibility with older versions): Note libmp compatibility. 2001-04-03 Kevin Ryde * tests/mpz/reuse.c: Add mpz_cdiv_q_2exp and mpz_cdiv_r_2exp. * tests/mpz/t-pow.c: Drag in refmpn.o when testing mpz_pow_ui etc with refmpn_mul_2. * tune/speed.c,speed.h,common.c,many.pl: Add measuring of mpn_com_n and mpn_mul_2. * tests/devel/try.c: Add testing of mpn_mul_2, and a DATA_MULTIPLE_DIVISOR attribute. * gmp.texi (Build Options): List more m68k's. (Build Options): Add cross reference to tex2html. (Notes for Particular Systems): Add m68k means 68020 or up. (Rational Conversions): New section, with mpq_get_d, mpq_set_d and mpq_set_f from Miscellaneous, and new mpq_set_str. (Applying Integer Functions): Move mpq_get_num, mpq_get_den, mpq_set_num and mpq_set_den from Misc. (Miscellaneous Rational Functions): Remove section. (Custom Allocation): Partial rewrite for various clarifications. (References): Improve line breaks near URLs. * acinclude.m4 (GMP_GCC_M68K_OPTIMIZE): New macro. * configure.in (m68*-*-*): Use it to run gcc 2.95.x at -O not -O2. (m680?0-*-*, m683?2-*-*, m68360-*-*): Add optional gcc -m options. * tests/mpz/t-cmp.c: New file. * tests/mpz/t-sizeinbase.c: New file. * tests/mpz/Makefile.am: Add them. * gmp-impl.h (MPN_CMP): New macro. * mpz/cmp.c,cmpabs.c: Use it, and minor cleanups too. * tests/mpq/t-equal.c: New file. * tests/mpq/t-get_str.c: New file. * tests/mpq/Makefile.am: Add them. * mpq/get_str.c: New file. * Makefile.am, mpq/Makefile.am: Add it. * gmp-h.in (mpq_get_str): Add prototype. * mpq/equal.c: Rewrite using inline compare loops. * tests/refmpn.c,tests.h (refmpn_mul_2): Fix parameter order. * mpz/n_pow_ui.c: Fix mpn_mul_2 calls parameter order. 2001-03-29 Kevin Ryde * tests/mpf/t-trunc.c: New file. * tests/mpf/Makefile.am (check_PROGRAMS): Add it. * gmp-impl.h (MPF_CHECK_FORMAT): New macro. * mpf/trunc.c: New file, rewrite of integer.c, preserve prec+1 in copy, don't copy if unnecessary. * mpf/ceilfloor.c: New file likewise, and use common subroutine for ceil and floor. * mpf/integer.c: Remove file. * Makefile.am, mpf/Makefile.am, macos/Makefile.in: Update. * acinclude.m4 (GMP_GCC_VERSION_GE): New macro. (GMP_GCC_MARCH_PENTIUMPRO): Use it, remove CCBASE parameter (don't bother checking it's gcc). (GMP_GCC_ARM_UMODSI): New macro. * configure.in (GMP_GCC_MARCH_PENTIUMPRO): Update parameters. (arm*-*-*): Use GMP_GCC_ARM_UMODSI. * gmp.texi (Notes for Particular Systems): Add arm gcc requirements. 2001-03-28 Kevin Ryde * gmp.texi (Converting Integers): Document mpz_getlimbn using absolute value and giving zero for N out of range, move to end of section. * tests/refmpn.c (refmpn_tdiv_qr): Use refmpn_divmod_1 rather than refmpn_divrem_1. * tests/tests.h: Add some prototypes that were missing. * mpz/tdiv_q_ui.c: Remove a comment that belonged to mpz_tdiv_r_ui. 2001-03-26 Torbjorn Granlund * mpn/generic/gcdext.c: Handle carry overflow after m*n multiply code in both arms. Partially combine multiply arms. 2001-03-24 Kevin Ryde * longlong.h: Add comments to P5 count_leading_zeros. * demos/expr/exprz.c,t-expr.c,README: Add congruent_p and divisible_p. 2001-03-23 Kevin Ryde * gmp.texi (GMPceil, GMPfloor, ge, le): New macros. (Integer Division, mpn_cmp, mpn_sqrtrem, Algorithms): Use them. (mpn_bdivmod): Refer to mp_bits_per_limb, not BITS_PER_MP_LIMB, and improve formatting a bit. (mpn_lshift, mpn_rshift): Clarify the return values, and use {rp,n} for the destination. Miscellaneous minor rewordings in a few places. * mpn/arm/arm-defs.m4: New file. * configure.in (arm*-*-*): Use it. * mpn/arm/*.asm: Use changecom and registers from arm-defs.m4, use L() for local labels. * mpn/x86/k6/mmx/com_n.asm: Relax code alignment (same speed). * gmp-h.in (__GMP_ATTRIBUTE_PURE): Use __pure__ to avoid application namespace. * gmp-impl.h (ABS): Add parens around argument. 2001-03-20 Kevin Ryde * acinclude.m4 (GMP_PROG_M4): Use AC_ARG_VAR on $M4. * acinclude.m4 (GMP_M4_M4WRAP_SPURIOUS): New macro. * configure.in: Use it. * mpn/asm-defs.m4: Ditto. 2001-03-18 Kevin Ryde * mpn/x86/pentium/logops_n.asm: New file. * mpn/x86/k6/k62mmx/copyd.asm: Rewrite, smaller and simpler, faster on small sizes, slower on big sizes (about half the time). * mpn/x86/k6/k62mmx/copyi.asm: Remove file, in favour of generic x86. * mpn/x86/copyi.asm: Add some comments. * mpn/x86/k6/README: Update. * mpn/x86/k6/gcd_1.asm: New file. * gmp-impl.h (NEG_MOD): Fix type of __dnorm. * acinclude.m4 (GMP_C_SIZES): Fix use of __GMP_WITHIN_CONFIGURE. 2001-03-15 Kevin Ryde * gmp.texi (GMPabs): New macro. (Float Comparison - mpf_reldiff): Use it. (Integer Comparisons - mpz_cmpabs): Ditto, puts "abs" in info. (Reentrancy): Update notes on old random functions. (Karatsuba Multiplication): Better characterize the effect of basecase speedups on the thresholds, pointed out by Torbjorn. * tune/README: Notes on the 1x1 div threshold for mpn_gcd_1. * tests/misc.c (mpz_pow2abs_p, mpz_flipbit, mpz_errandomb, mpz_errandomb_nonzero, mpz_negrandom): New functions. (mpz_erandomb, mpz_erandomb_nonzero): Use urandom(). * tests/spinner.c (spinner_wanted, spinner_tick): Make global. * tests/tests.h: Update prototypes. * tests/mpz/t-cong.c, tests/mpz/t-cong_2exp.c: New files. * tests/mpz/Makefile.am (check_PROGRAMS): Add them. * mpz/cong.c, mpz/cong_2exp.c, mpz/cong_ui.c: New files. * Makefile.am, mpz/Makefile.am: Add them. * gmp-impl.h (NEG_MOD): New macro. * gmp-h.in (mpz_congruent_p, mpz_congruent_2exp_p, mpz_congruent_ui_p): Add prototypes. * gmp.texi (Integer Division, Efficiency): Add documentation. * mpq/aors.c: No need for ABS on denominator sizes. * gmp-impl.h (mpn_divisible_p): Use __MPN. * gmp-impl.h (LOW_ZEROS_MASK): New macro. * mpz/divis_ui.c, mpn/generic/divis.c: Use it. * mpz/setbit.c: Fix normalization for case of a negative ending up with a zero high limb. * tests/mpz/bit.c (check_single): New test for this problem. * configure.in (none-*-*): Fix cclist for default ABI=long. 2001-03-10 Kevin Ryde * mpz/cfdiv_q_2exp.c: Don't scan for non-zero limbs if they don't matter to the rounding. * mpz/get_ui.c: Fetch _mp_d[0] unconditionally, so the code can come out branch-free. 2001-03-08 Kevin Ryde * tests/devel/try.c (param_init): Fix reference functions for and_n and nand_n. * tune/speed.c, tests/devel/try.c: Seed RANDS, not srandom etc. * configure.in (AC_CHECK_FUNCS): Remove srand48 and srandom. * macos/configure (coptions): Remove random/srandom, now unnecessary. * configure.in (gmp.h, mp.h, demos/expr/expr-impl.h): Generate using AM_CONFIG_HEADER. (_LONG_LONG_LIMB, HAVE_MPFR): Change to AC_DEFINEs. * gmp-h.in, mp-h.in, demos/expr/expr-impl-h.in: Change to #undef's. * acinclude.m4 (GMP_FUNC_ALLOCA, GMP_C_SIZES): Use gmp-h.in, not gmp.h. * Makefile.am (EXTRA_DIST): Remove gmp-h.in and mp-h.in, now done automatically. * acinclude.m4 (GMP_FUNC_ALLOCA), gmp-impl.h: Set and use __GMP_WITHIN_CONFIGURE rather than GMP_FUNC_ALLOCA_TEST. * mpf/random2.c: Use _gmp_rand and RANDS instead of random() for the exponent, ensures full range of values too. * tests/mpz/t-div_2exp.c (check_various): Start with d based on i, but don't let it go negative. * tune/tuneup.c (KARATSUBA_MUL_THRESHOLD): Limit probing to TOOM3_MUL_THRESHOLD_LIMIT, the size of the workspace in mul_n.c. Use a -1 with this too, so size * mpn/cray/cfp/mul_1.c: Don't call mpn_add_n with size 0. * mpn/cray/cfp/addmul_1.c: Likewise. * mpn/cray/cfp/submul_1.c: Don't call mpn_sub_n with size 0. * tests/mpz/t-div_2exp.c (check_various): Start 2nd d loop from 0 (avoid problems with Cray compilers). 2001-03-06 Torbjorn Granlund * mpn/cray/ieee/submul_1.c: Don't call mpn_sub_n with size 0. * mpn/cray/ieee/mul_basecase.c: New file. * mpn/cray/ieee/sqr_basecase.c: New file, derived from mul_basecase.c. 2001-03-06 Kevin Ryde * tests/devel/try.c (pointer_setup): Allow dst_size == SIZE_SIZE2 for the benefit of mpn_tdiv_qr. * tune/tuneup.c (all): Start karatsuba probing at size==4, for the benefit of cray t90 ieee which has speed oddities at size==2. * gmp-impl.h (USE_LEADING_REGPARM): Use __GMP_GNUC_PREREQ. Use __GMP_ATTRIBUTE_PURE and ATTRIBUTE_CONST in a few places. * gmp-h.in (__GMP_GNUC_PREREQ) New macro. (__GMP_ATTRIBUTE_PURE): New macro, use it in many places. * gmp-impl.h, gmp-h.in (mpn_jacobi_base): Move prototype to gmp-impl.h, use ATTRIBUTE_CONST. * tune/speed.h (speed_cyclecounter): Inline asm version for i386. * mpz/cfdiv_r_2exp.c (cfdiv_r_2exp): Only reread "up" after second realloc, first is under w!=u. 2001-03-05 Torbjorn Granlund * mpn/cray/sub_n.c: Rewrite using `majority' logic. * mpz/cfdiv_r_2exp.c (cfdiv_r_2exp): Reread `up' after realloc of w. * mpn/cray/ieee/mul_1.c: Rewrite. Streamline multiplications; use `majority' logic. * mpn/cray/ieee/addmul_1.c: Likewise. * mpn/cray/add_n.c: Rewrite using `majority' logic. 2001-03-04 Torbjorn Granlund * longlong.h (CRAY udiv_qrnnd): No longer conditional on CRAYMPP. (64-bit hppa add_ssaaaa): New. (64-bit hppa sub_ddmmss): New. * mpn/cray/ieee/invert_limb.c: New file. * gmp-impl.h (RANDS): Add a `,0' to make it compile on more compilers. 2001-03-03 Kevin Ryde * mpz/n_pow_ui.c (ULONG_PARITY): Move to gmp-impl.h. * gmp-impl.h (ULONG_PARITY): i386 part from n_pow_ui.c, new generic form by Torbjorn. * tests/mpz/t-div_2exp.c: New file, rewrite of t-2exp.c. * tests/mpz/t-2exp.c: Remove file. * tests/mpz/Makefile.am (check_PROGRAMS): Update. * gmp-h.in (mpz_cdiv_q_2exp, mpz_cdiv_q_2exp): Add prototypes. * gmp.texi (Integer Division): Add mpz_cdiv_q_2exp and mpz_cdiv_q_2exp. * mpz/cfdiv_q_2exp.c: New file, partial rewrite of fdiv_q_2exp.c, add mpz_cdiv_q_2exp entrypoint. * mpz/cfdiv_r_2exp.c: New file, rewrite of fdiv_r_2exp.c, use all mpn, add mpz_cdiv_r_2exp entrypoint. * mpz/fdiv_q_2exp.c, mpz/fdiv_r_2exp.c: Remove files. * mpz/Makefile.am (libmpz_la_SOURCES): Update. * Makefile.am (MPZ_OBJECTS): Ditto. * gmp-impl.h (USE_LEADING_REGPARM): Use __i386__ same as longlong.h (REGPARM_2_1, REGPARM_3_1, REGPARM_ATTR): New macros. * mpz/jacobi.c (jac_or_kron): Use them. * configure.in (HAVE_ABI_$ABI): Re-enable this for config.m4, with dots changed to underscores (necessary for hppa). * tests/mpz/t-divis.c, tests/mpz/t-divis_2exp.c: New files. * tests/mpz/Makefile.am (check_PROGRAMS): Add them. * gmp-h.in (mpz_divisible_p, mpz_divisible_ui_p, mpz_divisible_2exp_p): Add prototypes. * gmp.texi (Integer Division): Add mpz_divisible_p. (Efficiency): Add remarks about divisibility testing. * mpz/divis.c, mpz/divis_ui.c, mpz/divis_2exp.c: New files. * mpz/Makefile.am (libmpz_la_SOURCES): Add them. * Makefile.am (MPZ_OBJECTS): Ditto. * mpn/generic/divis.c: New file. * configure.in (gmp_mpn_functions): Add it. * mpn/Makefile.am (nodist_libdummy_la_SOURCES): Ditto. * gmp-impl.h (mpn_divisible_p): Add prototype. * urandom.h: Remove file. * Makefile.am (EXTRA_DIST): Remove it. * tests/mpz/convert.c, dive.c, io.c, logic.c, reuse.c, t-2exp.c, t-fdiv.c, t-fdiv_ui.c, t-gcd.c, t-jac.c, t-mul.c, t-pow.c, t-powm.c, t-powm_ui.c, t-root.c, t-sqrtrem.c, t-tdiv.c, t-tdiv_ui.c: Use RANDS, initialized by tests_rand_start. * tests/mpz/t-pow.c: New file, being t-pow_ui renamed and with some further tests added. * tests/mpz/t-pow_ui.c: Remove file. * tests/mpz/Makefile.am (check_PROGRAMS): Update. * tests/t-modlinv.c: Don't use urandom.h. * tests/mpz/bit.c, tests/mpz/t-scan.c: Ditto. * tests/mpq/t-cmp.c, tests/mpq/t-cmp_ui.c, tests/mpq/t-get_d.c: Ditto. * tests/mpf/reuse.c, t-add.c, t-conv.c, t-dm2exp.c, t-muldiv.c, t-sqrt.c, t-sub.c: Ditto. * tests/misc.c (tests_rand_start, tests_rand_end): New functions. (tests_start, tests_end): Use them. (urandom): New function. * tests/tests.h: Add prototypes. * mpz/random.c: Rewrite using mpz_urandomb and RANDS. * mpn/generic/random.c: Rewrite using _gmp_rand and RANDS. * mpn/generic/random2.c: Use RANDS not random() etc. * gmp-impl.h (__gmp_rands, __gmp_rands_initialized): Add externs. (gmp_randstate_ptr): New typedef. (RANDS, RANDS_CLEAR): New macros. * rands.c: New file. * Makefile.am (libgmp_la_SOURCES): Add it. * configure.in (mpn_objs_in_libmp): New AC_SUBST. * Makefile.am (libmp_la_DEPENDENCIES): Use it. 2001-03-02 Torbjorn Granlund * mpn/pa64/udiv_qrnnd.asm: New file. 2001-03-01 Kevin Ryde * mpbsd/rpow.c: New file. * mpbsd/Makefile.am (libmpbsd_la_SOURCES): Add it (nodist_libmpbsd_la_SOURCES): Remove pow_ui.c. * Makefile.am (MPBSD_OBJECTS): Add rpow.lo, remove pow_ui.lo. (libmp_la_DEPENDENCIES): Add mpz/n_pow_ui.lo. * mpz/ui_pow_ui.c: Rewrite using mpz_n_pow_ui. * mpz/pow_ui.c: Ditto, and no longer provide rpow for mpbsd. * mpz/n_pow_ui.c: New file, rewrite of pow_ui.c and ui_pow_ui.c. Use less temporary memory, strip factors of 2 from the base, use mpn_mul_2 if available. * mpz/si_pow_ui.c: New file. * mpz/Makefile.am (libmpz_la_SOURCES): Add them. * Makefile.am (MPZ_OBJECTS): Ditto. * gmp-impl.h (mpz_n_pow_ui): Add prototype. * gmp-h.in (mpz_si_pow_ui): Add prototype. * gmp.texi (Integer Exponentiation): Add mpz_si_pow_ui. * acinclude.m4 (GMP_C_SIZES): Add BITS_PER_ULONG. Correction to mp_limb_t working check. * configure.in (limb_chosen): New variable. * tests/t-constants.c (BITS_PER_ULONG): Check this value. Add some reminders about tests that fail on Cray. * tests/refmpn.c (refmpn_mul_2): New function. * tests/refmpz.c (refmpz_pow_ui): Copied from tests/mpz/t-pow_ui.c * tests/tests.h: Add prototypes. * configure.in (none-*-*): Add ABI=longlong. * doc/configuration (Long long limb testing): Describe it. * gmp.texi (Low-level Functions): Move some commented out remarks ... * mpn/generic/mul_basecase.c: ... to here. * mpn/x86/README: Note "%=" as an alternative to "1:" in __asm__. * tests/trace.c (mp_trace_start): Print "bin" for binary. * mpn/generic/dump.c: Add a couple of casts to keep gcc quiet. * gmp-h.in (mpn_incr_u, mpn_decr_u): Add parens around arguments. * mpbsd/mout.c, mpbsd/mtox.c (num_to_text): Remove unused variable. * mpfr/set_d.c (mpfr_get_d2): Declare "q" for 64-bit limbs. 2001-02-28 Torbjorn Granlund * mpn/pa64w/udiv_qrnnd.asm: Tune. 2001-02-27 Torbjorn Granlund * mpn/pa64w/udiv_qrnnd.asm: New file. 2001-02-26 Torbjorn Granlund * longlong.h (arm): Optimize sub_ddmmss by testing for constant operands. * mpn/arm/invert_limb.asm: New file. 2001-02-24 Torbjorn Granlund * mpn/generic/lshift.c: Rewrite. * mpn/generic/rshift.c: Rewrite. * longlong.h: Use UWtype for external interfaces that expect mp_limb_t. * longlong.h (arm): #define invert_limb. * mpn/arm: Make labels have local scope. * configure.in (arm*-*-*): Set extra_functions. * longlong.h (arm): #define udiv_qrnnd. * mpn/arm/udiv.asm: New file. 2001-02-24 Kevin Ryde * tune/many.pl: Add mpn_count_leading_zeros, mpn_count_trailing_zeros and mpn_invert_limb. Add count_leading_zeros, count_trailing_zeros from a .h file. Correction to modexact_1_odd prototype. Support ansi2knr. * tune/speed.h, tune/common.c: Consequent changes. * demos/expr/*: Make a few more functions available in expressions, create only libexpr.a, misc minor updates. * mpn/Makeasm.am: Add some comments about suffix ordering. * tests/refmpn.c (rshift_make, lshift_make): No need to compare unsigned to zero. * mpq/mul.c: Detect and optimize squaring. 2001-02-23 Torbjorn Granlund * mpn/mips3: Convert files to `.asm'. * mpn/arm: Convert files to `.asm'. Misc cleanups. * mpn/arm/submul_1.asm: New file. 2001-02-21 Kevin Ryde * tune/tuneup.c (all): Only one compiler print should match, no need for #undef PRINTED_COMPILER. * mpfr/mpfr.h (mpfr_sgn): Use mpfr_cmp_ui (patch from Paul). * mpz/fib_ui.c: Update some remarks about alternative algorithms. * gmp.texi (Fibonacci Numbers Algorithm): Ditto. (Assigning Floats): Clarify mpf_swap swaps the precisions too. (Low-level Functions): Try to be clearer about negative cofactors. 2001-02-21 Torbjorn Granlund * mpn/sparc64/copyi.asm: Streamline for small operands. * mpn/sparc64/add_n.asm: Likewise. * mpn/sparc64/sub_n.asm: Likewise. * mpn/sparc64/copyd.asm: New file. 2001-02-20 Torbjorn Granlund * mpn/sparc64/lshift.asm: Rewrite. * mpn/sparc64/rshift.asm: Rewrite. 2001-02-19 Torbjorn Granlund * mpn/sparc64/add_n.asm: Rewrite using `majority' logic. * mpn/sparc64/sub_n.asm: Likewise. * tune/tuneup.c (all): Recognise DECC and MIPSpro compilers. * mpn/pa64/sqr_diagonal.asm: Use PROLOGUE/EPILOGUE. * mpn/pa642/sqr_diagonal.asm: Likewise. * configure.in (HAVE_ABI_$abi): Disable for now. * mpn/asm-defs.m4 (PROLOGUE): Use LABEL_SUFFIX. * acinclude.m4 (GMP_ASM_ATTR): New check, for hppa oddities. 2001-02-18 Torbjorn Granlund * mpn/hppa/hppa1_1/gmp-mparam.h: New file. * mpn/hppa/hppa2_0/gmp-mparam.h: New file. * mpn/pa64/sqr_diagonal.asm: New file. * mpn/pa64w/sqr_diagonal.asm: New file. * mpn/hppa/hppa1_1/sqr_diagonal.asm: New file. * mpn/hppa/hppa2_0/sqr_diagonal.asm: New file. * mpn/sparc32/v9/add_n.asm: Use `fitod' instead of `fxtod' for dummy FA-pipeline insns. * mpn/sparc32/v9/sub_n.asm: Likewise. 2001-02-18 Kevin Ryde * gmp.texi (Known Build Problems): Notes on make, $* and K&R, misc tweaks elsewhere. (Low-level Functions): Use {} notation in mpn_sqrtrem. (Basecase Multiplication): Mention BASECASE_SQR_THRESHOLD. * mpfr/isnan.c (mpfr_number_p): Infinity is not a number. * mpfr/out_str.c: Pass strlen+1 for the block size to free. * mpfr/get_str.c: Correction for realloc to strlen+1. * acinclude.m4 (GMP_C_SIZES): Generate an error if mp_limb_t doesn't seem to work for some reason. 2001-02-16 Torbjorn Granlund * mpn/sparc32/v9/gmp-mparam.h: Retune. * mpn/sparc32/v9/add_n.asm: New file. * mpn/sparc32/v9/sub_n.asm: New file. * mpn/sparc32/v9/mul_1.asm: Tune function entry. * mpn/sparc32/v9/addmul_1.asm: Likewise. * mpn/sparc32/v9/submul_1.asm: Likewise. * mpn/sparc32/v9/sqr_diagonal.asm: New file. 2001-02-16 Kevin Ryde * configure.in: Fix flags selection when $CC is a compiler known to us. * demos/expr/exprfr.c (e_mpfr_cos, e_mpfr_sin): mpfr_sin_cos now allows NULL for one parameter. * mpfr/*: Update to 20010215. * mpfr/trunc.c: Use -DOPERATION scheme, and gmp mpn_zero_p. * mpfr/sqrt.c: Use plain mpn_sqrtrem, not mpn_sqrtrem_new. * mpfr/sqrtrem.c: Remove file. * mpfr/Makefile.am (libmpfr_a_SOURCES): Add isnan.c and set_ui.c, remove sqrtrem.c and srandom.h. * configfsf.guess: Update to 2001-02-13. * configfsf.sub: Update to 2001-02-16. * config.sub (j90, t90): Remove special handing, configfsf.sub now ok. * Makefile.am (MPF_OBJECTS): Add a couple of missing $U's. * tune/tuneup.c: Identify compiler used (GCC and Sun C so far). 2001-02-15 Torbjorn Granlund * mpn/sparc32/v9/mul_1.asm: Change `ld' to `lduw' and `st' to `stw'. * mpn/sparc32/v9/addmul_1.asm: Likewise. * mpn/sparc32/v9/submul_1.asm: Likewise. 2001-02-14 Torbjorn Granlund * mpn/mips3/mips.m4: New file. * configure.in (mips*-*-irix[6789]*): Use mips3/mips.m4. * mpn/powerpc64/sqr_diagonal.asm: New file. * mpn/mips3/sqr_diagonal.asm: New file. 2001-02-12 Torbjorn Granlund * mpn/powerpc32/sqr_diagonal.asm: New file. * mpn/generic/sqr_basecase.c: Remove declaration of mpn_sqr_diagonal. Fix typo in header comment. 2001-02-12 Kevin Ryde * mpn/generic/mul.c, mpn/generic/mul_n.c, gmp-impl.h: Use mpn_mul_basecase for squaring below new BASECASE_SQR_THRESHOLD. * tune/tuneup.c gmp-impl.h: Tune BASECASE_SQR_THRESHOLD. * Makefile.am (libgmp.la, libmp.la): Revert change to build from mpn/libmpn.la etc, go back to explicitly listed objects. * configure.in: Recognise sparc64-*-*, not just sparc64-*-linux*. 2001-02-11 Torbjorn Granlund * mpn/asm-defs.m4 (sqr_diagonal): New define_mpn. * mpn/alpha/sqr_diagonal.asm: New file. 2001-02-11 Kevin Ryde * gmp.texi (Low-level Functions): Note mpn_get_str clobbers its input plus 1 extra limb. * mpfr/add.c,agm.c,exp2.c,exp3.c,generic.c,log2.c,pi.c,print_raw.c, set_d.c,sin_cos.c,sqrtrem.c,sub.c: Apply some tweaks for K&R. * tests/mpz/reuse.c, tests/mpq/t-md_2exp.c, demos/pexpr.c, demos/expr/t-expr.c: Ditto. * configure.in (HAVE_ABI_$abi): New define in config.m4. * gmp-impl.h (mpn_sqr_diagonal): Add prototype and define. * tune/speed.c,speed.h,common.c,many.pl: Add measuring of mpn_sqr_diagonal. * gmp.texi, acinclude.m4: Mention x86 solaris 2.7 has the reg->reg movq bug the same as 2.6. * mpfr/Makefile.am (EXTRA_DIST): Add mpfr-test.h and mpf2mpfr.h. * mpn/x86/README: Merge contents of README.family. * mpn/x86/README.family: Remove file. * mpn/Makefile.am (nodist_libdummy_la_SOURCES): Add mode1o, gcd_finda, invert_limb, sqr_diagonal; remove mod_1_rs; sort alphabetically. 2001-02-10 Torbjorn Granlund * configure.in (gmp_mpn_functions_optional): List sqr_diagonal. * mpn/powerpc32/aix.m4: Use unnamed csects. * mpn/powerpc64/aix.m4: Likewise. * acconfig.h: Add #undef of mpn_sqr_diagonal. Remove lots of spacing. * configure.in (syntax testing section): Match power* instead of powerpc*. * mpn/power: Convert files to `.asm'. Prefix umul_ppmm and sdiv_qrnnd. Update some comments. 2001-02-09 Kevin Ryde * acconfig.h: Add HAVE_NATIVE_mpn_modexact_1_odd and HAVE_NATIVE_mpn_modexact_1c_odd. * configure.in (CCAS): Don't override a user selection. * mpq/cmp_ui.c: DIVIDE_BY_ZERO if den2==0. 2001-02-08 Torbjorn Granlund * mpn/generic/sqr_basecase.c: Use mpn_sqr_diagonal when appropriate. 2001-02-07 Kevin Ryde * gmp.texi (Low-level Functions): mpn_preinv_mod_1 now undocumented. * mpn/generic/random2.c (myrandom): Use rand() on mingw. * mpn/alpha/gmp-mparam.h: Update tuned parameters. 2001-02-05 Torbjorn Granlund * mpn/alpha/ev6/gmp-mparam.h: Retune. 2001-02-05 Kevin Ryde * Makefile.am (libgmp, libmp): Construct from mpn/libmpn.la etc rather than explicitly listed objects. * urandom.h: Use rand() on mingw. * mpn/powerpc64/lshift.asm,addsub_n.asm: Use r1 not 1. 2001-02-04 Torbjorn Granlund * mpn/ia64/copyi.asm: New file. * mpn/ia64/copyd.asm: New file. 2001-02-04 Kevin Ryde * mpn/alpha/ev5/gmp-mparam.h, mpn/mips3/gmp-mparam.h, mpn/powerpc32/gmp-mparam.h, mpn/powerpc64/gmp-mparam.h, mpn/sparc64/gmp-mparam.h, mpn/x86/*/gmp-mparam.h: Update tuned parameters. * mpn/x86/i486: New directory. * configure.in (i486-*-*): Use it. * mpn/x86/i486/gmp-mparam.h: New file. * mpn/x86/pentium/mode1o.asm: New file. * mpn/x86/p6/mode1o.asm: New file. * tune/many.pl: Use $(ASMFLAGS_PIC) and $(CFLAGS_PIC). * gmp.texi (Integer Division): Another rewording of 2exp divisions. 2001-02-03 Torbjorn Granlund * mpn/arm/gmp-mparam.h: Tune. * mpn/ia64/popcount.asm: Put a `;;' break at end of main loop. * configure.in (arm*-*-*): Set gcc_cflags in order to pass $fomit_frame_pointer. * tests/mpz/t-mul.c (base_mul): Remove an unused variable. 2001-02-02 Torbjorn Granlund * demos/pexpr.c (TIME): New macro. (main): Use TIME--print timing more accurately. (setup_error_handler): Increase RLIMIT_DATA to 16 Mibyte. * longlong.h (arm): Add __CLOBBER_CC to add_ssaaaa and sub_ddmmss. 2001-02-02 Kevin Ryde * configure.in: Don't remove gmp-mparam.h and mpn source links under --no-create since in that case they're not re-created. * demos/expr: New directory. * Makefile.am (SUBDIRS, allprogs): Add it. * demos/expr/README, Makefile.am, expr.c, exprv.c, exprz.c, exprza.c, exprq.c, exprqa.c, exprfa.c, exprf.c, exprfr.c, exprfra.c, expr.h, expr-impl-h.in, run-expr.c, t-expr.c: New files. * configure.in: Generate demos/expr/Makefile & demos/expr/expr-impl.h. * Makefile.am: Remove mpfr from main libgmp. * mpfr/Makefile.am: Build and install separate libmpfr.a. * mpfr/*: Update to mpfr 2001. * gmp-h.in (__GNU_MP_VERSION_MINOR): Bump to 2. * Makefile.am (libtool -version-info): Bump appropriately. * NEWS: Updates. * tune/divrem1div.c, tune/divrem1inv.c, tune/divrem2div.c, tune/divrem2inv.c: Renamed from divrem_1_div.c, divrem_1_inv.c, divrem_2_div.c, divrem_2_inv.c, to be unique in DOS 8.3 filenames. * tune/Makefile.am (libspeed_la_SOURCES): Update. * mpn/x86/*/README, mpn/x86/README.family: Misc updates. * tune/README: Misc updates. * doc/configuration: Misc updates. * mpn/x86/pentium/mmx/gmp-mparam.h: Change UDIV_PREINV_TIME to UDIV_NORM_PREINV_TIME. * mpz/pprime_p.c: Use ASSERT_ALWAYS instead of abort. * rand.c (__gmp_rand_lc_scheme): Add "const". (struct __gmp_rand_lc_scheme_struct): Make astr "const char *". * demos/calc/calc.y, demos/calc/calclex.l: Add kron function. * tests/devel/try.c: Partial rewrite, new scheme of function types, allow result validation functions, add sqrtrem and jacobi testing. * tune/many.pl: Corresponding updates. * tests/devel/Makefile.am: Add a convenience rule for libtests.la. * tests/refmpz.c: New file. * tests/Makefile.am: Add it. * tests/misc.c (mpz_erandomb, mpz_erandomb_nonzero): New functions. * tests/tests.h: Add prototypes. * mpn/x86/k6/cross.pl: Add a couple more exceptions. * gmp.texi: Don't use @nicode{'\0'}, it doesn't come out right in tex. (Introduction to GMP): Mention Cray vector systems. (Build Options): Describe --enable-mpfr, refer to its manual. Add Crays under supported CPUs. (Debugging): Add notes on source file paths. (Autoconf): New section. (Assigning Integers): Note truncation by mpz_set_d, mpz_set_q and mpz_set_f. (Converting Integers): Note the size mpz_get_str allocates. (Floating-point Functions): Rewrite introduction, clarifying some points about precision handling. (Converting Floats): Note the size mpf_get_str allocates, and that it gives an empty string for zero. Add mpf_get_si and mpf_get_ui. (Float Comparison): Give the formula mpf_reldiff calculates. (Miscellaneous Float Functions): Add mpf_integer_p and mpf_fits_*_p. (Random Number Functions): Misc rewordings for clarity. (Random State Initialization): Ditto. (Custom Allocation): Remove note on deallocate_function called with 0, misc rewording and clarifications. (Exact Remainder): New section. (Binary GCD): A few words on initial reduction using division. (Accelerated GCD): Refer to exact remainder section. (Extended GCD): Extra remarks on single versus double selection. (Jacobi Symbol): Update for mpz/jacobi.c rewrite and modexact_1_odd. (Modular Powering Algorithm): Refer to exact remainder section. (Assembler SIMD Instructions): Update remarks on MMX. (Contributors): Amend to "Divide and Conquer" division. (References): Tweak some formatting. Add "Proof of GMP Fast Division and Square Root Implementations" by Paul Zimmermann. 2001-01-31 Torbjorn Granlund * configure.in: Don't ever pass -mips3; let ABI flags imply ISA. 2001-01-31 Kevin Ryde * tune/time.c: Remove unnecessary longlong.h. (speed_endtime): Add some extra diagnostics. * tests/mpz/t-fdiv_ui.c, tests/mpz/t-tdiv_ui.c: Use unsigned long for the divisor, not mp_limb_t. * tests/mpz/t-jac.c (try_base): Use %llu for long long limb. * tests/trace.c: Add for strlen. * tune/freq.c (speed_cpu_frequency_proc_cpuinfo): Ignore "cycle frequency" of 0, allow "BogoMIPS" as well as "bogomips". * macos/Makefile.in: Add mpf/fits_s.c and mpf/fits_u.c objects. 2001-01-30 Torbjorn Granlund * longlong.h: Add add_ssaaaa and sub_ddmmss for 64-bit sparc. 2001-01-29 Torbjorn Granlund * mpn/powerpc64/addmul_1.asm: Prefix registers with an `r'. * mpn/powerpc64/submul_1.asm: Likewise. * mpn/powerpc64/mul_1.asm: Likewise. * configure.in (alpha*-*-*): Amend last change to handle pca*. 2001-01-29 Kevin Ryde * tune/speed.h (SPEED_ROUTINE_INVERT_LIMB_CALL): Don't let the compiler optimize everything away. * tune/speed.c, tune/speed.h, tune/common.c, tune/Makefile.am: Measure operator_div, operator_mod, mpn_divrem_2_div, mpn_divrem_2_inv, mpn_sb_divrem_m3, mpn_sb_divrem_m3_div, mpn_sb_divrem_m3_inv, mpn_dc_divrem_sb_div, mpn_dc_divrem_sb_inv. * tune/divrem_2_div.c, tune/divrem_2_inv.c, tune/sb_div.c, tune/sb_inv.c: New files. * tune/tuneup.c, gmp-impl.h, tune/speed.h, tune/common.c, tune/Makefile.am: Tune SB_PREINV_THRESHOLD and DIVREM_2_THRESHOLD. * mpn/generic/divrem_2.c: Use new DIVREM_2_THRESHOLD. * mpn/generic/sb_divrem_mn.c: Use new SB_PREINV_THRESHOLD. * mpn/x86/p6/mmx/lshift.asm, mpn/x86/p6/mmx/rshift.asm: New files, just m4 include()ing the P55 code. * configure.in (pentium[23]-*-*): Remove x86/pentium/mmx from path. 2001-01-27 Kevin Ryde * configure.in (AC_CHECK_FUNCS): Add srand48. * tune/speed.c: Use this test. * acinclude.m4 (GMP_GCC_MARCH_PENTIUMPRO): Allow "egcs-" prefix on gcc --version, warn if the format is unrecognised. (GMP_COMPARE_GE): Guard against empty $1 not only on last arg. (GMP_INIT, GMP_FINISH, GMP_PROG_M4): Obscure or eliminate literal "dnl"s since autoconf thinks they indicate faulty macros. * mpz/get_str.c, mpf/get_str.c: Make allocated string block exactly strlen(str)+1 bytes. * mpz/dump.c, mpf/dump.c, tests/mpz/convert.c: Use this size when freeing. * tests/mpf/t-conv.c: Ditto, and ensure x==0 is exercised. * tests/mpz/t-fits.c: New file. * tests/mpz/Makefile.am: Add it. * tests/mpf/t-fits.c: New file. * tests/mpf/t-get_si.c: New file. * tests/mpf/t-int.c: New file. * tests/mpf/Makefile.am: Add them. * mpf/fits_s.c: New file. * mpf/fits_u.c: New file. * mpf/get_si.c: New file. * mpf/get_ui.c: New file. * mpf/int_p.c: New file. * Makefile.am, mpf/Makefile.am: Add them. * gmp-h.in (mpf_fits_*_p, mpf_get_si, mpf_get_ui, mpf_integer_p): Add prototypes. * tests/memory.c (tests_allocate, tests_reallocate): Guard against size==0. * tests/mpz/*.c, tests/mpq/*.c, tests/mpf/*.c: Uses tests_start and tests_end. * gmp-impl.h (USE_LEADING_REGPARM): Fix conditionals. 2001-01-23 Kevin Ryde * configure.in, mpn/Makeasm.am (ASMFLAGS_PIC): New substitution, allowing -DPIC to be suppressed on cygwin. (CFLAGS_PIC): New substitution, use it and $(CCAS) directly, rather than $(LIBTOOL), avoiding a problem with FreeBSD 2.2.8. * mpn/x86/k6/mode1o.asm, mpn/x86/k7/mode1o.asm: Remove an unnecessary +[.-L(here)] from _GLOBAL_OFFSET_TABLE_, avoids a segv from gas 1.92.3. * mpn/x86/README.family: Add notes on the problem. 2001-01-20 Torbjorn Granlund * configure.in (alpha*-*-*): Default `flavour' to ev4. 2001-01-19 Kevin Ryde * assert.c, gmp-impl.h (__gmp_assert_fail): Change return type to void, since it's no longer used in expressions. * mpn/x86/addsub_n.S: Remove file, since it doesn't work and it upsets tune/many.pl. * mpz/jacobi.c: Rewrite, but still binary algorithm; accept zero and negative denominators; merge mpz_jacobi and mpz_legendre, add mpz_kronecker; use mpn directly, add special cases for size==1. * gmp.texi (Number Theoretic Functions): Update. * gmp-h.in (mpz_kronecker): Add prototype. * gmp-impl.h (USE_LEADING_REGPARM): New macro. * tests/mpz/t-jac.c: Test mpz_kronecker. * mpz/legendre.c: Remove file. * Makefile.am, mpz/Makefile.am: Update. * longlong.h (alpha count_leading_zeros): Use __attribute__ ((const)) when possible, add parameter to prototype. (ia64 udiv_qrnnd): Use for all compilers, not just gcc. (pentium count_trailing_zeros): Use count_leading_zeros. * acinclude.m4 (GMP_C_ATTRIBUTE_CONST, GMP_C_ATTRIBUTE_NORETURN): New macros. * configure.in: Use them. * gmp-impl.h (ATTRIBUTE_CONST, ATTRIBUTE_NORETURN): New macros. (mpn_invert_limb): Add ATTRIBUTE_CONST. (__gmp_assert_fail): Add ATTRIBUTE_NORETURN. 2001-01-18 Kevin Ryde * gmp-h.in, gmp-impl.h (__gmp_allocate_func, __gmp_reallocate_func, __gmp_free_func): Move prototypes from gmp-impl.h to gmp-h.in, for the benefit of gmp++.h. * gmp-impl.h, tests/misc.c, tests/tests.h: Move MPZ_SET_STR_OR_ABORT and MPF_SET_STR_OR_ABORT to mpz_set_str_or_abort and mpf_set_str_or_abort in libtests. * tests/mpz/convert.c, tests/mpz/t-bin.c, tests/mpz/t-get_si.c, tests/mpz/t-jac.c, tests/mpz/t-misc.c, tests/mpq/t-md_2exp.c, tests/mpq/t-set_f.c, tests/mpf/t-conv.c, tests/mpf/t-misc.c: Update. * mpn/generic/sqrtrem.c: Use MPN_COPY_INCR (for when rp==NULL). * tests/mpz/reuse.c: Only run mpz_divexact_gcd on positive divisors. 2001-01-18 Torbjorn Granlund * demos/pexpr.c (main): Accept -vml option. (fns): List `hamdist', `pow', `nextprime'. (mpz_eval_expr): Return -1 for `popc' of negative. (mpz_eval_expr): Handle `hamdist', `pow', `nextprime'. 2001-01-15 Kevin Ryde * mpn/alpha/ev5/mode1o.c: New file. * tune/freq.c (speed_cpu_frequency_measure): Check cycles_works_p before running speed_cyclecounter. * tune/speed.h (cycles_works_p): Add prototype. 2001-01-13 Torbjorn Granlund * tests/rand/t-rand.c (farr): Fix typo. (zarr): Fix typo. 2001-01-12 Kevin Ryde * mpz/kronsz.c: Don't depend on right shifting a negative. * mpn/x86/gmp-mparam.h: New file. * mpn/x86/pentium/mmx/mul_1.asm: New file. 2001-01-11 Torbjorn Granlund * mpz/kronsz.c: Temporary workaround for Cray right shift oddities. Explicitly compare against zero in tests. 2001-01-10 Kevin Ryde * mpz/kronzs.c: Don't depend on right shifting a negative. 2001-01-09 Torbjorn Granlund * tests/t-constants.c: Disable some undefined tests. (CHECK_MAX_S): Remove workaround for gcc 2.95.2 bug recently added. 2001-01-09 Kevin Ryde * tests/t-constants.c: Add more diagnostics. (CHECK_MAX_S): Fix for gcc 2.95.2 -mpowerpc64 -maix64. * mpn/x86/k6/mode1o.asm: New file. * mpn/x86/k7/mode1o.asm: New file. * mpn/asm-defs.m4 (modexact_1_odd, modexact_1c_odd): New define_mpn's. (__clz_tab, modlimb_invert_table, PROLOGUE, EPILOGUE): Add asserts for GSYM_PREFIX. * mpn/x86/x86-defs.m4 (Zdisp): Add a movzbl. * tests/mpz/t-jac.c (check_a_zero): New test. (check_squares_zi): Fix to use (a^2/b), not (a*b/b); revert last change avoiding a,b=0, both are fine. (try_2den): Don't use mpz_kronecker_ui for the expected answer. (try_*): Call abort rather than exit. * mpz/kronzu.c, mpz/kronzs.c: Fix for a=0. * tune/tuneup.c (USE_PREINV_MOD_1): Fix to use new DATA_HIGH_LT_R. 2001-01-08 Torbjorn Granlund * urandom.h: Amend 2000-11-21 change to also handle cygwin. 2001-01-08 Kevin Ryde * tune/many.pl: Updates for move to tests/devel, add modexact_1_odd, don't assume C files can't have carry-in entrypoints, remove $(TRY_TESTS_OBJS) now in libtests. * tests/devel/try.c, tests/refmpn.c, tests/tests.h: Remove mpn_mod_1_rshift testing. * tune/tuneup.c (fft_step_size): Test for overflow using the actual mp_size_t, don't use BITS_PER_INT. * tune/speed.c (r_string): "r" is a limb, use BITS_PER_MP_LIMB and change LONG_ONES to LIMB_ONES. * tune/time.c (M_2POWU): Use INT_MAX rather than BITS_PER_INT. * extract-dbl.c (BITS_PER_PART): Use BITS_PER_MP_LIMB not BITS_PER_LONGINT. * mpz/inp_raw.c, mpz/out_raw.c: Add private defines of BITS_PER_CHAR. * mpz/fac_ui.c, tests/mpz/t-fac_ui.c: Don't use BITS_PER_LONGINT. * tests/mpz/t-get_si.c: Don't use BITS_PER_LONGINT, do the LONG_MAX tests with some explicit code. * mpn/*/gmp-mparam.h, acinclude.m4, tests/t-constants.c (BITS_PER_LONGINT, BITS_PER_INT, BITS_PER_SHORTINT, BITS_PER_CHAR): Remove defines, remove probings, remove tests. * tune/tuneup.c (MODEXACT_1_ODD_THRESHOLD): Add tuning. * tune/speed.c,speed.h,common.c: Add measuring of mpn_modexact_1_odd, mpn_gcd_finda, and an "N" form for mpn_gcd_1. * tests/mpz/t-jac.c (check_squares_zi): Ensure random a,b != 0. 2001-01-07 Kevin Ryde * configure.in (gmp_mpn_functions): Add mode1o, remove mod_1_rs. * mpn/generic/mod_1_rs.c: Remove file, no longer needed. * gmp-h.in (mpn_mod_1_rshift): Remove prototype and define. * mpq/set_f.c: Use MPN_STRIP_LOW_ZEROS_NOT_ZERO. * mpz/kronzu.c, mpz/kronzs.c, mpz/kronuz.c, mpz/kronsz.c: Use mpn_modexact_1_odd, new style MPN_STRIP_LOW_ZEROS_NOT_ZERO, and new JACOBI macros. Various rearrangements supporting all this. * mpn/generic/gcd_1.c: Use mpn_modexact_1_odd, reduce u%v if u much bigger than v when size==1, some rearrangements supporting this. * gmp-impl.h (JACOBI_*): More macros, add some casts to "int". (MPN_STRIP_LOW_ZEROS_NOT_ZERO): Add a "low" parameter. (mpn_modexact_1_odd, mpn_modexact_1c_odd): Add prototype and defines. (MODEXACT_1_ODD_THRESHOLD): New threshold. (MPN_MOD_OR_MODEXACT_1_ODD, JACOBI_MOD_OR_MODEXACT_1_ODD): New macros. * mpn/generic/mode1o.c: New file. * tests/mpz/reuse.c: Add testing of mpz_divexact_gcd. * tests/mpz/t-fac_ui.c: Use libtests for memory leak checking. * tests/mpz/t-fib_ui.c: Add a usage comment. * tests/mpz/bit.c: Use libtests. * tests/mpz/t-scan.c: Remove unused subroutines. * tests/devel/try.c: Use libtests, define PROT_NONE if the system doesn't. * tests/spinner.c, tests/x86check.c: Use tests.h. * tests/trace.c: Use tests.h, add mpf_trace. * tests/refmpn.c: Use tests.h, add refmpn_malloc_limbs_aligned, refmpn_tstbit, refmpn_neg. * tune/common.c, tune/speed.h: Update for functions moved to tests/misc.c. * tune/Makefile.am, tests/mpz/Makefile.am, tests/mpq/Makefile.am, tests/mpf/Makefile.am: Use tests/libtests.la. * configure.in (AC_OUTPUT): Update for new directories. (x86 CALLING_CONVENTIONS_OBJS): Use .lo for libtests.la, allow ansi2knr on x86check.c. * tests/Makefile.am: Establish new libtests.la convenience library, add mpz, mpq, mpf, mpbsd subdirectories. * tests/tests.h: New file. * mpn/tests/ref.h,try.h: Remove files, now in tests.h. * tests/mpf/ref.c: Move to tests/refmpf.c, rename functions to refmpf. * tests/mpf/t-add.c, tests/mpf/t-sub.c: Use libtests. * tests/mpf/Makefile.am: Update. * tests/memory.c: New file. * tests/misc.c: New file, a few subroutines from the test programs. * mpz/tests, mpq/tests, mpf/tests, mpbsd/tests: Move directories to tests/mpz etc. * mpz/Makefile.am, mpq/Makefile.am, mpf/Makefile.am, mpbsd/Makefile.am (SUBDIRS): Remove. * tests/devel: New directory. * mpn/tests/*.c: Move programs to tests/devel. * mpn/tests/Makefile.am, mpn/tests/README: Move to tests/devel, update. * mpn/tests/ref.c: Move to tests/refmpn.c. * mpn/tests/spinner.c,trace.c,x86call.asm,x86check.c: Move to tests directory. * tests/t-constants.c: Add checks of HIGHBIT, MAX and MIN constants, simplify ANSI vs K&R stringizing, use correct printf format types, do all tests before aborting. 2001-01-05 Torbjorn Granlund * mpn/cray/ieee/gmp-mparam.h: Retune. 2001-01-05 Kevin Ryde * configure.in (mp.h): Only create this under --enable-mpbsd. * demos/calc: New subdirectory, move demos/calc* to it. * demos/calc/Makefile.am: New file, split from demos/Makefile.am. * demos/Makefile.am: Update. * configure.in (AC_OUTPUT): Add demos/calc/Makefile. * tests/t-constants.c (CALC_BITS_PER_TYPE etc): Use a run-time test for how many bits work in a give type, don't assume bits==8*sizeof. 2001-01-04 Kevin Ryde * mpz/fits_s.c, mpz/fits_u.c: New files, split from fits.c, use plain UINT_MAX etc, not MPZ_FITS_UTYPE_SDT etc. * mpz/fits.c: Remove file. * mpz/Makefile.am, macos/Makefile.in: Update. * gmp-impl.h (UNSIGNED_TYPE_MAX etc): Remove these generic forms. (MPZ_FITS_[SU]TYPE_SDT): Remove these. (UINT_MAX etc): Provide a full set of defaults. * gmp-h.in (__GMP_MP_SIZE_T_INT): New define. * mpz/tests/t-scan.c: New file. * mpz/tests/Makefile.am (check_PROGRAMS): Add it. * mpz/scan0.c, mpz/scan1.c: Rewrite, don't read beyond allocated memory, support negatives, return ULONG_MAX for no bit found. * gmp.texi (Integer Logic and Bit Fiddling): Update. 2001-01-03 Torbjorn Granlund * mpz/tests/dive.c: Generate test operands using new random functions. * mpz/tests/io.c: Likewise. * mpz/tests/logic.c: Likewise. * mpz/tests/t-2exp.c: Likewise. * stack-alloc.c (__gmp_tmp_alloc): Round `now' to required alignment. * stack-alloc.h (__TMP_ALIGN): Append `L'. * gmp-impl.h: For Cray, #include limits.h. (LONG_MIN): New #define. (ULONG_HIGHBIT): #define in terms of ULONG_MAX. (LONG_HIGHBIT): #define as LONG_MIN. (USHRT_MAX): New name for USHORT_MAX. (SHRT_MAX): New name for SHORT_MAX. (SHRT_MIN): New #define. (USHORT_HIGHBIT,SHORT_HIGHBIT): Removed. * mpbsd/tests/t-misc.c (check_itom [data]): *SHORT* => *SHRT*; remove code disabling a test for Cray. * tests/t-constants.c (CHECK_CONSTANT): Cast parameters to long. * mpn/generic/mul_n.c (mpn_kara_sqr_n): Remove unused variable `t'. (mpn_kara_mul_n): Likewise. * mpz/fac_ui.c (MPZ_SET_1_NZ): Actually use `__z'. * mpz/tests/t-jac.c (main, check_squares_zi): Generate test operands using new random functions. All changes below on this date for enabling `make; make check' with C++ compilers: * mpz/tests/t-pow_ui.c (debug_mp, ref_mpz_pow_ui): Provide prototypes. * mpz/tests/t-mul.c (debug_mp, base_mul, ref_mpz_mul): Provide prototypes. (dump_abort): Provide prototype and declare properly for C++. * mpz/tests/t-jac.c: #include stdlib.h and sys/time.h. * mpz/tests/t-fdiv.c (dump_abort): Provide prototype and declare properly for C++. (debug_mp): Provide prototype. * mpz/tests/t-fdiv_ui.c: Likewise. * mpz/tests/t-gcd.c: Likewise. * mpz/tests/t-powm.c: Likewise. * mpz/tests/t-powm_ui.c: Likewise. * mpz/tests/t-sqrtrem.c: Likewise. * mpz/tests/t-tdiv_ui.c: Likewise. * mpz/tests/t-tdiv.c: Likewise. * mpz/tests/t-2exp.c: #include stdlib.h and sys/time.h. Remove #include of longlong.h. * mpz/tests/io.c: #include config.h, stdlib.h, sys/time.h, and conditionally unistd.h. * mpz/tests/dive.c: #include stdlib.h and sys/time.h. (dump_abort): Provide prototype and declare properly for C++. (debug_mp): Provide prototype. * mpz/tests/logic.c: Likewise. * mpz/tests/convert.c (debug_mp): Provide prototype. * mpz/tests/t-root.c (debug_mp): Likewise. * mpz/tests/bit.c: #include stdlib.h and sys/time.h. * mpq/tests/t-get_d.c: #include stdlib.h and sys/time.h. (dump): Provide prototype and declare properly for C++. * mpq/tests/t-cmp_ui.c: #include stdio.h, stdlib.h and sys/time.h. (ref_mpq_cmp_ui): Declare properly for C++. * mpq/tests/t-cmp.c: #include stdlib.h and sys/time.h. (ref_mpq_cmp): Declare properly for C++. (dump): Delete unused function. * mpf/random2.c (myrandom): New function. (mpf_random2): Use it. * mpn/generic/random2.c: #include stdlib.h (for random/mrand48). (myrandom): New function. (mpn_random2): Use it. * mpf/tests/t-add.c: #include stdlib.h and sys/time.h. (oo): Remove unused function. * mpf/tests/t-conv.c: Likewise. * mpf/tests/t-sub.c: Likewise. * mpf/tests/t-dm2exp.c: Likewise. * mpf/tests/t-muldiv.c: Likewise. * mpf/tests/t-sqrt.c: Likewise. * mpf/tests/reuse.c: #include stdlib.h and sys/time.h. Use PROTO on some typedefs. (oo): Remove function. (dump_abort): Call mpf_dump instead of oo. * mpf/set_str.c: #include stdlib.h (for strtol). * mpf/random2.c: #include stdlib.h (for random/mrand48). * mpn/alpha/udiv_arnnd: File deleted. * Remove K&R function headers. 2001-01-02 Torbjorn Granlund * mpn/generic/mul.c: Clean up spacing and indentation. * mpn/generic/mul_fft.c (mpn_fft_add_modF): Use mpn_decr_u. Clean up spacing and indentation. * extract-dbl.c: Generalize to handle smaller limb sizes. 2001-01-01 Torbjorn Granlund * mpbsd/mout.c: Output newline after "0". 2000-12-31 Torbjorn Granlund * ltmain.sh: Remove space between `#!' and `$SHELL' when generating `libtool'. * mpbsd/tests/t-misc.c (check_itom): Exclude test for all Cray vector systems. Correct comment. 2000-12-31 Kevin Ryde * gmp.texi (ABI and ISA): New enough gcc needed for mips n32 etc, gcc 2.95 needed for sparc 64-bit ABI, gcc 2.8 needed for -mv8plus. * configure.in ([cjt]90,sv1-cray-unicos*): Preserve user specified MPN_PATH, amend test program indenting. (none-*-*): Add -DNO_ASM to gcc to disable longlong.h asm macros in generic C. * config.sub (j90, t90): Preserve these, don't let configfsf.sub turn them into c90. * config.guess (m68k-*-nextstep*,m68k-*-openstep*): Don't transform m68k to m68020, since m68k is already interpreted as 68020. 2000-12-30 Kevin Ryde * mpq/neg.c: Rewrite, use mpn, avoid denominator copy if unnecessary. * mpz/tstbit.c: Rewrite, slightly simplified. * mpz/tests/bit.c (check_tstbit): New test, and add a couple more diagnostics elsewhere. * configure.in (x86 gcc_cflags_cpu): Add -m486 for gcc 2.7.2. (ccbase): Only use a known compiler in eval statements (avoids problems with non-symbol characters). (ccbase): Use GMP_PROG_CC_IS_GNU to identify gcc installed under a different name. (cclist): Use same style $abi as other variables. * acinclude.m4 (GMP_PROG_CC_IS_GNU): New macro. (GMP_GCC_MARCH_PENTIUMPRO): Use $ccbase to identify gcc. (GMP_ASM_TYPE): Define TYPE to empty, not "dnl", when no .type needed. (GMP_ASM_SIZE): Ditto for SIZE, which ensures EPILOGUE on the last line of a file doesn't leave a tab and no newline. (GMP_ASM_UNDERSCORE): Add a prototype for C++. * configure.in (sys/mman.h, mprotect): New tests. * mpn/tests/try.c: Use them, and HAVE_UNISTD_H too. * configure.in (getopt.h): Remove test. * tune/speed.c, mpn/tests/try.c (getopt.h): Remove include, since plain getopt() is in . * configure.in, gmp-h.in (mips*-*-irix6*): Set limb_n32=longlong rather than using _ABIN32. 2000-12-29 Torbjorn Granlund * mpz/tests/reuse.c: Rename dump_abort => dump. * mpz/tests/reuse.c: Generate operands using gmp_rand*. * mpz/tests/convert.c: Likewise. * configure.in: Detect T90-ieee systems; move Cray path selection to after AC_PROG_CC. Invoke AC_PROG_CPP. * mpn/cray/cfp: New directory. Move cfp specific files here. * mpn/cray/cfp/mulwwc90.s: New file. * mpn/cray/cfp/mulwwj90.s: New file. * mpn/cray/mulww.s: Delete. 2000-12-27 Torbjorn Granlund * mpn/cray/ieee/mul_1.c: New file. * mpn/cray/ieee/addmul_1.c: New file. * mpn/cray/ieee/submul_1.c: New file. * mpn/cray/ieee/gmp-mparam.h: New file. * mpn/cray/gmp-mparam.h: Disable UMUL_TIME and UDIV_TIME. * mpn/cray/hamdist.c: New file. * mpn/cray/popcount.c: New file. * mpn/cray/rshift.c: New file. * mpn/cray/lshift.c: New file. * longlong.h: Add count_leading_zeros for _CRAY. Reorganize _CRAY stuff. 2000-12-24 Kevin Ryde * configure.in (alpha*-cray-unicos*): Disable SPEED_CYCLECOUNTER_OBJ, as tune/alpha.asm doesn't suit. * mpn/generic/sqrtrem.c, mpz/pow_ui.c, mpz/powm_ui.c, mpf/get_str.c, mpf/set_str.c: Use mpn_sqr_n when applicable, not mpn_mul_n. 2000-12-23 Torbjorn Granlund * mpn/generic/mul_fft.c: Reformat. (mpn_fft_neg_modF): Remove. (mpn_fft_mul_2exp_modF): Inline mpn_fft_neg_modF. * mpn/cray/gmp-mparam.h: Retune. * configure.in (*-cray-unicos*): Pass `-O3 -htask0'. (vax*-*-*): Fix typo. * mpn/cray/mul_1.c: Use dynamic arrays, get rid of TMP_*. * mpn/cray/addmul_1.c: Likewise. * mpn/cray/submul_1.c: Likewise. * mpn/cray/add_n.c: Likewise. * mpn/cray/sub_n.c: Likewise. * configure.in (default cc_cflags,cc_64_cflags): Remove -g/add -O. (mips*-*-irix[6789]*]): Remove -g from cc_*_cflags. 2000-12-22 Torbjorn Granlund * mpn/generic/mul_n.c: Delete K&R function headers. * mpn/generic/mul_n.c (mpn_kara_mul_n): Clean up type confusion between mp_limb_t and mp_size_t. (mpn_kara_sqr_n): Likewise. * mpn/generic/mul_n.c (mpn_kara_mul_n): Use mpn_incr_u. (mpn_kara_sqr_n): Likewise. * mpn/generic/mul_n.c (mpn_kara_mul_n): Change handling of `sign' to work around GCC 2.8.1 MIPS bug. * configure.in (implied alpha*-cray-unicos*): Remove -g from cc_cflags. 2000-12-21 Torbjorn Granlund * mpn/alpha/invert_limb.asm: Simplify a bit. Add handling of bigend systems. * mpn/alpha/unicos.m4: Define `bigend'. * mpn/alpha/default.m4: Define `bigend' (to expand to nothing). * tests/t-constants.c (CHECK_CONSTANT): Print using %lx. * mpn/alpha/gmp-mparam.h: Remove sizes for plain C types. * mpn/alpha/ev5/gmp-mparam.h: Likewise. * mpn/alpha/ev6/gmp-mparam.h: Likewise. * mpn/alpha/unicos.m4: Define LEA. * mpn/alpha/default.m4: Likewise. * mpn/alpha/invert_limb.asm: Use LEA for loading symbolic addresses. * mpn/alpha/cntlz.asm: Likewise. * mpn/alpha/cntlz.asm: Don't use `ldbu', use slightly slower `ldq_u' + `extbl' instead. * mpn/alpha/unicos.m4: Define EXTERN. * mpn/alpha/default.m4: Define EXTERN (to expand to nothing). * mpn/alpha/cntlz.asm: Declare __clz_tab usign `EXTERN' (for the benefit of Unicos). 2000-12-21 Kevin Ryde * mpn/alpha/unicos.m4 (GSYM_PREFIX): Define for the benefit of __clz_tab. 2000-12-20 Torbjorn Granlund * longlong.h: Add udiv_qrnnd and count_leading_zeros for _CRAYMPP systems. 2000-12-19 Torbjorn Granlund * configure.in (*sparc*-*-*): Remove -g from cc_cflags and acc_cflags. * mpn/generic/sqrtrem.c (mpn_sqrtrem): Separate `limb' values from `size' values. * configure.in (*-cray-unicos*): Add `-Wa,-B' to cc_cflags. * demos/pexpr.c (rstate): New variable. (main): Initialize rstate. (enum op_t): Add RANDOM. (fns): Add field for RANDOM. (mpz_eval_expr): Handle RANDOM. 2000-12-19 Kevin Ryde * mpn/generic/sqrtrem.c: Rewrite by Paul Zimmermann, based on his Karatsuba Square Root algorithm. * gmp.texi (Square Root Algorithm): Update. * tune/many.pl: New file. * mpn/tests/try.c,ref.[ch] (mpn_preinv_mod_1, mpn_sb_divrem_mn, mpn_tdiv_qr, mpn_gcd_finda, mpn_kara_mul_n, mpn_kara_sqr_n, mpn_toom3_mul_n, mpn_toom3_sqr_n): Add testing. * mpn/tests/ref.c: Cast some "0"s in function calls. * mpn/x86/k7/mmx/mod_1.asm: Add preinv_mod_1 entrypoint, remove extra variable for loop termination. * mpn/x86/p6/mmx/mod_1.asm: Remove file, in favour of the following. * mpn/x86/p6/mod_1.asm: New file. * mpn/x86/pentium/mod_1.asm: New file. 2000-12-18 Torbjorn Granlund * configure.in (mips*-*-irix[6789]*): Pass options to compiler using `-Wc'. 2000-12-18 Kevin Ryde * mpn/x86/k6/pre_mod_1.asm: New file. * tune/tuneup.c (USE_PREINV_MOD_1): Tune this, rearrange mpn_divrem_1 and mpn_mod_1 handling in support of it. * tune/Makefile.am: Consequent changes to divrem_1.c and mod_1.c. * gmp-impl.h (USE_PREINV_MOD_1, MPN_MOD_OR_PREINV_MOD_1): New macros. * mpn/generic/perfsqr.c, mpz/pprime_p.c: Use MPN_MOD_OR_PREINV_MOD_1. * configure.in: Let an asm mod_1 provide a preinv_mod_1 entrypoint. * mpn/alpha/default.m4: Remove some newlines, add some asserts. (r0 etc, f0 etc): Use defreg and deflit. (PROLOGUE, PROLOGUE_GP, EPILOGUE): Use GSYM_PREFIX. * mpn/alpha/unicos.m4: Remove some newlines, add some asserts. * mpn/alpha/invert_limb.asm: Remove unused second DATASTART parameter. * mpn/alpha/cntlz.asm: Use mpn_count_leading_zeros and __clz_tab. * mpn/asm-defs.m4 (changecom): Comments on portability. (__clz_tab, modlimb_invert_table): New macros, matching gmp-impl.h. (count_leading_zeros, count_trailing_zeros): New define_mpn's. (PROLOGUE etc): Comments on usage, add some asserts. (OPERATION_[lr]shift): Use m4_not_for_expansion, for the benefit of lorrshift multifunc. * mpn/Makeasm.am (RM_TMP): New variable controlling tmp-*.s removal, for development purposes. * mpz/fac_ui.c: Fix for long long limb by using mpn_mul_1 not mpz_mul_ui, and note some possible enhancements. * mpz/tests/t-fac_ui.c: New test. * mpz/tests/Makefile.am (check_PROGRAMS): Add it. * macos/Makefile.in: Ditto, and add t-fib_ui too. * mpn/generic/[lr]shift.c: Remove some DEBUG code adequately covered by new parameter ASSERTs. * longlong.h (count_trailing_zeros): Assert x!=0. * doc/configuration: Updates for new configure things, add some notes on test setups. 2000-12-16 Torbjorn Granlund * configure.in (*-*-aix): Pass -qmaxmem=20000 to xlc also for 64-bit compiles. * configure.in: Disable shared libs for *-*-ultrix*. 2000-12-15 Torbjorn Granlund * configure.in (powerpc*-*-*): Pass -Wa,-mppc when using gcc. * gmp-impl.h (_EXTERN_INLINE): #define different for GCC and other compilers. * gmp-h.in (__gmp_inline): Remove. * mp-h.in: Likewise. * mpn/generic/gcd.c: Use `inline' instead of `__gmp_inline'. * configure.in (mips*-*-irix[6789]*): Define *_ldflags. 2000-12-14 Torbjorn Granlund * mpn/generic/pre_mod_1.c: Use proper type for udiv_qrnnd parameter `dummy'. * mpn/generic/divrem_1.c: Use explicit `!= 0' in if statement. * mpn/generic/mod_1.c: Likewise. 2000-12-14 Kevin Ryde * config.guess (mips-*-irix[6789]*): Transform to mips64. (m68k-*-nextstep* | m68k-*-openstep*): Transform to m68020. 2000-12-13 Torbjorn Granlund * tests/t-constants.c (main): Conditionalize use of PP_INVERTED. * mpn/mp_bases.c: Handle 4-bit limbs. (main): Add code for generating tables. * mpn/generic/popham.c: Handle limb bitsizes of 4, 8, 16. Suffix all 32-bit constant with `L'. Use CNST_LIMB for 64-bit constants. 2000-12-13 Kevin Ryde * gmp-impl.h (FIB_THRESHOLD): Defaults for 4,8,16 bits per limb, and an arbitrary fallback default. (modlimb_invert): Add efficient code for 8,16 (or 4) bits per limb. * configure.in (mips3, mips64): Don't bother with o32 (mips2 32-bit limb) on IRIX 6. * Makefile.am (SUBDIRS): Put "tests" first so tests/t-constants.c is run first, to pick up any limb size mismatch. * tune/tuneup.c (DIVREM_1, MOD_1): Fix result values, were off by 1. * mpz/fib_ui.c (table1, table2): Add data for 4,8,16 bits per limb. 2000-12-12 Torbjorn Granlund * gmp-impl.h (LIMBS_PER_DOUBLE): Define for any limb bitsize. 2000-12-11 Torbjorn Granlund * mpn/mp_bases.c: Add tables for 8-bit and 16-bit limbs. Round existing `double' values properly. * gmp-h.in (__gmp_randstate_struct): Prefix field names with _mp_ to keep out of user name space. (__gmp_randata_lc): Likewise. * randclr.c, randlc.c, randlc2x.c, randraw.c, randsd.c, randsdui.c: Corresponding changes. * gmp-impl.h (PP): #define for machines with BITS_PER_MP_LIMB of 2, 4, 8, and 16. (PP_FIRST_OMITTED): New, define for various BITS_PER_MP_LIMB. (PP_MASK): Remove. (PP_MAXPRIME): Remove. * mpn/generic/perfsqr.c: Generalize PP handling for machines with limbs of < 32 bits. Allow PP_INVERTED to be undefined. * mpz/pprime_p.c: Likewise. 2000-12-10 Torbjorn Granlund * mpn/generic/mul_1.c: Declare parameters in C89 style. 2000-12-10 Kevin Ryde * tune/Makefile.am (speed_LDFLAGS, speed_ext_LDFLAGS, tune_LDFLAGS): Don't use -all-static, as gcc 2.95.2 on i386 solaris 8 doesn't like it. * configure.in (mips3,mips64): Add ABI=64, name the others ABI=n32 and ABI=o32. * mpn/mips3/gmp-mparam.h (BITS_PER_LONGINT): Remove #define and let configure determine it, since it varies with ABI=64 or ABI=n32. * gmp.texi (ABI and ISA): Update. (mpz_mod_ui): Remark that it's identical to mpz_fdiv_r_ui. (mpn_divexact_by3): Qualify a statement needing mp_bits_per_limb even. * mul_fft.c (mpn_fft_mul_modF_K etc): Patch by Paul Zimmermann to fix results in certain cases of recursing into a further FFT. 2000-12-09 Torbjorn Granlund * mpz/cmpabs.c: Remove unused variable. * mpz/rrandomb.c: Likewise. * mpz/xor.c: Likewise. 2000-12-07 Torbjorn Granlund * mpn/generic/gcdext.c: Handle double carry when computing s1. Merge two code blocks for computing s0 and s1. 2000-12-07 Kevin Ryde * configure.in (hppa*-*-*): Remove -Aa -D_HPUX_SOURCE from cc_cflags/cppflags, and instead let AM_C_PROTOTYPES add it, or -Ae, whichever works. * configure.in (*-*-aix[34]*): Disable shared by default, but let the user override that, if desired. * gmp.texi (Notes for Particular Systems): Update. 2000-12-06 Torbjorn Granlund * mpq/cmp_ui.c: Streamline. 2000-12-06 Kevin Ryde * tune/divrem_1_div.c,divrem_1_inv.c,mod_1_div.c,mod_1_inv.c, gcdext_double.c: New files for measuring. * tune/Makefile.am (libspeed_la_SOURCES): Add them. * tune/speed.c,speed.h,common.c: Add measuring of them. (mpn_preinv_mod_1, mpz_jacobi, mpz_powm_ui): Add measuring. * speed.c (getopt_long): Don't use this, just plain getopt. * configure.in (getopt_long): Remove test. * gmp-impl.h (MPN_KARA_MUL_N_TSIZE, MPN_KARA_MUL_N_MINSIZE, MPN_TOOM3_MUL_N_TSIZE, MPN_TOOM3_MUL_N_MINSIZE): New macros, and assume toom3 square tsize was meant to be the same as the mul (both are overestimates). * tune/tuneup.c, mpn/generic/mul.c, mpn/generic/mul_n.c: Use them. * mpn/generic/mul_n.c (mpn_toom3_sqr_n): Fix an ASSERT to use TOOM3_SQR_THRESHOLD not TOOM3_MUL_THRESHOLD, add a few that might be more realistic size checks. * tune/speed.h (SPEED_ROUTINE_MPN_MUL_N_TSPACE etc): Use minsize. * mpn/generic/divrem_1.c: Partial rewrite, merge fractional part calculation, skip a divide step in more cases, introduce DIVREM_1_NORM_THRESHOLD and DIVREM_1_UNNORM_THRESHOLD. * mpn/generic/mod_1.c: Partial rewrite, skip a divide step in more cases, introduce MOD_1_NORM_THRESHOLD, MOD_1_UNNORM_THRESHOLD. * longlong.h (UDIV_PREINV_ALWAYS): New define, set for alpha and ia64. * tune/tuneup.c (DIVREM_1_NORM_THRESHOLD, DIVREM_1_UNNORM_THRESHOLD, MOD_1_NORM_THRESHOLD, MOD_1_UNNORM_THRESHOLD): Tune these. * gmp-impl.h [TUNE_PROGRAM_BUILD]: Support for this. * tune/Makefile.am (TUNE_MPN_SRCS): Add divrem_1.c and mod_1.c. * gmp-impl.h (UDIV_NORM_PREINV_TIME): Renamed from UDIV_PREINV_TIME. * mpn/generic/perfsqr.c, mpn/generic/sb_divrem_mn.c, mpn/x86/*/gmp-mparam.h: Ditto. * gmp-impl.h (UDIV_UNNORM_PREINV_TIME): New define. * configure.in (AC_C_INLINE, HAVE_INLINE): New test and define. * gmp-impl.h (inline): Remove, use config.h. (_EXTERN_INLINE): Redefine based on HAVE_INLINE. (mpn_zero_p): Use HAVE_INLINE. * acinclude.m4 (GMP_PROG_AR, GMP_PROG_NM): Don't add flags to a user selected $AR or $NM. * tune/tuneup.c (all): Print how long the tuning took. * configure.in (AM_C_PROTOTYPES): Use this, not GMP_ANSI2KNR. * acinclude.m4 (GMP_ANSI2KNR): Remove. * Makefile.am (gmp.h, mp.h): In DISTCLEANFILES not CLEANFILES. * gmp-h.in (mpn_divmod, mpn_divmod_1, mpn_divexact_by3): Cast some zeros, for the benefit of K&R if long!=int. * mpn/lisp/gmpasm-mode.el (gmpasm-comment-start-regexp): Add "*" for the benefit of cray. * compat.c (mpn_divexact_by3, mpn_divmod_1): Return types should be mp_limb_t, not int, and need an actual "return". 2000-12-05 Torbjorn Granlund * mpn/sparc32/v8/supersparc/gmp-mparam.h: Retune. * mpn/alpha/gmp-mparam.h: Tune for 21064. * longlong.h: Reformat to avoid newlines within strings. * gmp-impl.h (inline): Disable if GCC has defined __STRICT_ANSI__. * configure.in: Do a `mkdir tune' before creating tune/sqr_basecase.c. * Makefile.am: Treat mp.h analogously to gmp.h. configure.in (*-*-aix): Pass -qmaxmem=20000 to xlc. * mp-h.in: Renamed from mp.h. Add #define for _LONG_LONG_LIMB. Move some other fixes from gmp-h.in. * mp.h: Removed. * configure.in: Generate mp.h from mp-h.in like we handle gmp-h.in/gmp.h. 2000-12-04 Torbjorn Granlund * acinclude.m4: Fix typo testing for bad HP compiler. 2000-12-03 Torbjorn Granlund * mpbsd/tests/t-misc.c (check_itom): Exclude some tests for Cray CFP systems. * longlong.h (CRAYIEEE umul_ppmm): New. * mpn/cray/gmp-mparam.h (BITS_PER_SHORTINT): 32 => 64. (*_THRESHOLD): Tune. * configure.in: Disable shared libs for *-*-unicos*. 2000-12-03 Kevin Ryde * configure.in, tune/Makefile.am: Create tune/sqr_basecase.c during configure, and use it unconditionally in $(nodist_tuneup_SOURCES). Fixes a problem with sqr_basecase.lo under --disable-static. 2000-12-01 Torbjorn Granlund * mpf/tests/t-get_d.c (LOW_BOUND,HIGH_BOUND): #define for non-IEEE Cray systems. * gmp-impl.h (union ieee_double_extract): Test for _CRAYIEEE. 2000-11-30 Torbjorn Granlund * mpz/tests/t-mul.c (base_mul): Fix re-evaluation problems in macro invocations. (ref_mpz_mul): New name from mpz_refmul. Make static. (base_mul): New name for _mpn_mul_classic. 2000-11-30 Kevin Ryde * configure.in: Rewrite of CC/CFLAGS selection scheme, introduce a notion of ABI, merge compiler and mpn path selection, add flags selection for AR and NM, let CC without CFLAGS work. (AC_PROG_CC): Use this, not GMP_SELECT_CC. * acinclude.m4 (GMP_PROG_CC_WORKS): Don't use AC_TRY_COMPILE, combine cc/cflags parameter. (GMP_PROG_CC_FIND, GMP_CHECK_CC_64BIT, GMP_PROG_CC_SELECT): Remove. * gmp.texi (Installing GMP): Updates for new scheme. * configure.in (AC_CANONICAL_HOST): Use this and $host, not $target. * acinclude.m4, acconfig.h, longlong.h, mpn/x86/x86-defs.m4, mpn/x86/k7/mmx/popham.asm: Ditto, renaming HAVE_TARGET_CPU to HAVE_HOST_CPU. * gmp.texi (Build Options, and elsewhere): Update. * acinclude.m4 (GMP_COMPARE_GE): New macro. (GMP_GCC_MARCH_PENTIUMPRO): Use it, add CC parameter, check for GCC. (GMP_HPC_HPPA_2_0): New macro, adapted from GMP_CHECK_CC_64BIT. * acinclude.m4 (GMP_PROG_AR): New macro, using AC_CHECK_TOOL, adding GMP flags. * configure.in: Use it * gmp-h.in: Renamed from gmp.h. (@define_LONG_LONG_LIMB@): Placeholder for instantiation. (__GNU_MP__): Bump to 3. * acinclude.m4 (GMP_VERSION): Get version from gmp-h.in. * configure.in: Create gmp.h from gmp-h.in to set _LONG_LONG_LIMB. * gmp.texi.h (ABI and ISA): Mention this. * acconfig.h (_LONG_LONG_LIMB): Remove undef. * Makefile.am: Distribute gmp-h.in, not gmp.h. * configure.in (AC_PROG_CPP, AC_PROG_INSTALL, AC_PROG_LN_S): Remove, dragged in by other macros. (gmp_asm_syntax_testing): Renamed from gmp_no_asm_syntax_testing. (AC_EXEEXT, AC_OBJEXT): Remove, done automatically by libtool. * configure.in, acinclude.m4: Remove "" from "`foo`", being unnecessary and not portable. * configure.in (GMP_LDFLAGS): New AC_SUBST flags for libtool link. (powerpc64*-*-aix*): Use for -Wc,-maix to fix shared library creation, but can't build shared and static at the same time. * Makefile.am (libgmp_la_LDFLAGS, libmp_la_LDFLAGS): Use $(GMP_LDFLAGS). * gmp.texi (Notes for Particular Systems): Update AIX problem * configure.in (AC_CONFIG_LINKS): Use where needed, not via gmp_links. (gmp_srclinks): Build up as needed, not via gmp_links. * acinclude.m4 (GMP_INIT): Do CONFIG_TOP_SRCDIR and asm-defs.m4 here. * configure.in (asm-defs.m4): Consequent changes. * acinclude.m4 (GMP_INCLUDE_MPN): Using include_mpn(), replacing GMP_INCLUDE and GMP_SINCLUDE. * configure.in (gmp_m4postinc): Remove this scheme, use GMP_INCLUDE_MPN instead. * configure.in (*-*-sco3.2v5*): Force ac_cv_archive_cmds_need_lc=no, until libtool does this itself. * gmp.texi (Known Build Problems): Remove SCO -lc problem. * configure, INSTALL.autoconf, etc: Update to autoconf 2000-11-29. * acinclude.m4 (GMP_C_SIZES): Use AC_CHECK_SIZEOF. * gmp.texi (Known Build Problems): Remove version.c sed/config.h problem, fixed. * ltmain.sh, aclocal.m4: Update to libtool 2000-11-25. * ltconfig: No longer required, but leave an empty dummy for automake. * gmp.texi (Known Build Problems): Remove SunOS native ar ranlib problem, fixed. * */Makefile.in, aclocal.m4: Update to automake 2000-11-25. * mpbsd/tests/Makefile.am, mpfr/tests/Makefile.am (check_PROGRAMS): Remove dummy, no longer required. * mpbsd/tests/dummy.c, mpfr/tests/dummy.c: Remove files. * depcomp: Remove file, no longer required (with no-dependencies). * texinfo.tex: Update to 2000-11-09. * gmp.texi (Build Options): Mention PDF from gmp.texi. * Makefile.am (MOSTLYCLEANFILES): Add gmp.tmp, from new texinfo.tex. * gmp.texi (Build Options): List alphaev56, alphapca56, alphaev67, hppa2.0n and power among supported CPUs. 2000-11-30 Torbjorn Granlund * mpz/tests/t-mul.c: Increase max operand size from 2^17 bits to 2^19 bits. Misc cleanups. 2000-11-26 Kevin Ryde * tune/tuneup.c (FIB_THRESHOLD): Cope better with different speeds of odd and even sizes. * longlong.h (alpha): Use udiv_qrnnd and count_leading_zeros on all compilers, not just gcc. * pre_mod_1.c: Use conditional subtract to always skip a division. (UMUL_TIME, UDIV_TIME): Remove defaults, now in longlong.h. 2000-11-22 Torbjorn Granlund * mpn/pa64w/gmp-mparam.h: Retune. * mpn/pa64/gmp-mparam.h: Retune. * mpn/sparc64/gmp-mparam.h: Retune. 2000-11-22 Kevin Ryde * gmp-impl.h (ABOVE_THRESHOLD, BELOW_THRESHOLD): New macros. * mpn/generic/gcdext.c: Use them. * mpn/generic/gcdext.c [WANT_GCDEXT_ONE_STEP]: Force only one step. * tune/gcdextos.c, tune/gcdextod.c: New files, one step gcdext, single and double. * tune/Makefile.am (libspeed_la_SOURCES): Add them. (TUNE_MPN_SRCS): Remove gcdext.c. * tune/speed.h, tune/common.c, tune/speed.c: Add measuring. * tune/tuneup.c: Use for GCDEXT_THRESHOLD, plus check if double limb is ever better. Should be more accurate, and hopefully faster. * tune/gcdext_single.c: New file, gcdext forced to single limbs. * tune/Makefile.am: Add it. * tune/speed.h, tune/common.c, tune/speed.c: Add measuring, and of invert_limb. * tune/speed.h (speed_params r): Use mp_limb_t, not long. * tune/speed.h, tune/common.c: Don't "switch" on "r". * tune/speed.c (r_string): Accept limb sized constants. (choice scale): Add a scale factor (eg. "2.33*mpn_add_n"). * tune/common.c (SPEED_ROUTINE_UDIV_QRNND_A): Default r to __mp_bases[10].big_base, being a full limb value. * configure.in (alphapca56*-*-*): Use ev5 mpn path. (am29000*-*-*): Remove this, leave the canonical a29k. (z8k*-*-*, z8kx*-*-*): Changed from z8000, since z8k is canonical. (gmp_mpn_functions_optional): Add invert_limb, use for alpha and ia64. * configure.in (alloca): Accept yes/no/detect, generate an error if "yes" but not available. * gmp.texi (Build Options): Update. * acinclude.m4 (GMP_TRY_ASSEMBLE): Make conftest.out available. (GMP_ASM_ALIGN_FILL_0x90): Use it. * acinclude.m4 (GMP_ASM_X86_MMX) [*-*-solaris*]: Check for solaris 2.6 "as" movq bug. * gmp.texi (Notes for Particular Systems): Update x86 MMX note. 2000-11-21 Torbjorn Granlund * tune/Makefile.am (EXTRA_DIST): List hppa2w.asm. * tune/hppa2.asm: Change level directive to "2.0n". * tune/hppa2w.asm: New file. * configure.in [SPEED_CYCLECOUNTER_OBJS switch]: Separate out hppa2.0w. * mpn/pa64/gmp-mparam.h (BITS_PER_LONGINT): 64 => 32. 2000-11-21 Kevin Ryde * urandom.h (random): No prototype if glibc stdlib.h has already provided it (avoids an int32_t/long conflict). * tune/Makefile.am (LDFLAGS): Use -all-static. (speed-dynamic): Dynamic linked version of speed.c. * tune/README: Update. * mpn/generic/gcd.c (find_a): Use native version if available. * acconfig.h (HAVE_NATIVE_mpn_gcd_finda): Add #undef. * gmp-impl.h (mpn_gcd_finda): Add prototype and define. * mpn/asm-defs.m4 (mpn_gcd_finda): New define_mpn. * tune/gcd_finda_gen.c: #undef any HAVE_NATIVE_mpn_gcd_finda. * configure.in (gmp_mpn_functions_optional): Add gcd_finda. * mpn/x86/k6/gcd_finda.asm: New file. * tune/tuneup.c (POWM_THRESHOLD): Slightly bigger size steps. * gmp-impl.h (__GMP_IMPL_H__): Protect against multiple inclusion. * tune/gcd_bin.c, tune/powm_mod.c, tune/powm_redc.c: Use #undef after gmp-impl.h to force thresholds. * tune/tuneup.c (print_define, fft): No need for #ifndefs on thresholds any more. 2000-11-20 Torbjorn Granlund * mpz/tests/t-powm.c: Analogous changes as made 2000-11-12 to t-mul.c. * mpz/tests/t-powm_ui.c: Likewise. * mpz/tests/t-pow_ui.c: Likewise. * mpz/tests/t-root.c: Likewise. * configure.in [compiler switch]: Pass "-Aa -D_HPUX_SOURCE" to cc for all hppa versions. * mpn/hppa/hppa1_1/udiv_qrnnd.S: Reference data using PC relative addressing (was r19 relative addressing). 2000-11-18 Torbjorn Granlund * rand.c: (__gmp_rand_lc_scheme): Convert strings to hexadecimal. (gmp_randinit): Expect strings in hexadecimal. 2000-11-18 Kevin Ryde * configfsf.guess, configfsf.sub: Update to 2000-11-16. * config.guess (alpha*-*-openbsd*): Do exact cpu detection. 2000-11-14 Torbjorn Granlund * mpz/tests/t-fdiv.c: Analogous changes as made 2000-11-12 to t-mul.c. * mpz/tests/t-tdiv_ui.c: Likewise. * mpz/tests/t-fdiv_ui.c: Likewise. * mpz/tests/t-sqrtrem.c: Likewise. * mpz/tests/t-gcd.c: Likewise. 2000-11-13 Kevin Ryde * mpn/Makeasm.am: New file, splitting out assembler rules. * mpn/Makefile.am, tune/Makefile.am: Use it. * mpn/Makefile.am (@CPP@): Remove this, automake already gives it. * configure.in (AC_CHECK_LIBM): New test, and AC_SUBST it. * Makefile.am (MPFR_LIBADD_OPTION): Use it. * demos/Makefile.am (qcn_LDADD): Ditto. * tune/Makefile.am (libspeed_la_LIBADD): Ditto. * tests/rand/Makefile.am (libstat_la_LIBADD): Ditto. * tune/time.c (timeval_diff_secs): Better calculation. (read_real_time): New measuring method for AIX power/powerpc. (speed_endtime): Protect against negative times. * tune/common.c (speed_measure): Protect against big reps. * tune/freq.c (speed_cpu_frequency_measure_one): Better timeval diff. * tune/speed.h (TIMEVAL_DIFF_SEC,USEC): Remove macros. * configure.in: (sys/systemcfg.h, read_real_time): New tests. 2000-11-13 Torbjorn Granlund * mpz/tests/t-mul.c: Remove #include urandom.h. * mpz/tests/t-tdiv.c: Likewise. * configure.in [SPEED_CYCLECOUNTER_OBJS switch]: Declare hppa.asm as just 32 bits (cyclecounter_size=1). 2000-11-12 Torbjorn Granlund * mpz/tests/t-mul.c (main): Generate random numbers using gmp_rand* functions. (main): Distribute random numbers non-uniformly. (main): Seed by current time if GMP_CHECK_RANDOMIZE is set. (_mpn_mul_classic): Streamline. * mpz/tests/t-tdiv.c: Analogous changes. * demos/pexpr.c (HAVE_sigaltstack): Fix typo in testing for _UNICOS. Also test for __hpux. 2000-11-11 Torbjorn Granlund * mpn/alpha/ev5/gmp-mparam.h: Retune. * mpn/alpha/ev6/gmp-mparam.h: Retune. * mpn/alpha/ev6/add_n.asm: Misc cleanups. * mpn/alpha/ev6/sub_n.asm: New file. 2000-11-10 Torbjorn Granlund * configure.in [path switch] (alphaev6*-*-*): Add alpha/ev5 to path. * mpn/alpha/ev6/add_n.asm: New file. 2000-11-10 Kevin Ryde * mpz/powm.c (redc): Make global under WANT_REDC_GLOBAL. * tune/powm_mod.c, tune/powm_redc.c: New files. * tune/Makefile.am (libspeed_la_SOURCES): Add them. * tune/*: Add measuring of redc, mpz_mod, mpz_powm_mod, mpz_powm_redc. * tune/tuneup.c (POWM_THRESHOLD): Determine from redc and mpz_mod. * tune/Makefile.am (TUNE_MPZ_SRCS): Remove powm. 2000-11-10 Torbjorn Granlund * mpn/mips3/gmp-mparam.h: Retune. * configure.in (os_64bit): Rename to check_64bit_compiler. 2000-11-09 Torbjorn Granlund * configure.in [SPEED_CYCLECOUNTER_OBJS switch]: Choose hppa/hppa2 code depending on $CC64. 2000-11-09 Kevin Ryde * mpn/x86/pentium/mul_1.asm: Unroll 2x, saving 1 c/l when in L1. Add 1c entrypoint. * mpn/x86/pentium/aorsmul_1.asm: Add 1c entrypoints, shave a couple of cycles at entry and exit. * configure.in (power1,2,2sc): Support these as synonyms for plain power. * acinclude.m4 (GMP_ASM_X86_SHLDL_CL): GMP_DEFINE WANT_SHLDL_CL here. (GMP_ASM_X86_MMX, GMP_ASM_X86_SHLDL_CL): Add X86 into the names. * configure.in: Consequent changes. * gmp.texi (Notes for Particular Systems): Remarks about power/powerpc. (Reentrancy): Remarks about simultaneous writing. (Reporting Bugs): Ask for configfsf.guess. 2000-11-08 Kevin Ryde * acinclude.m4 (GMP_FUNC_ALLOCA): New macro. * configure.in: Use it. * gmp-impl.h (alloca): Conditionals and setups as per autoconf (should make alloca available on more non-gcc compilers). * acinclude.m4: Misc reformatting, simplify some quoting. (GMP_ASM_UNDERSCORE, GMP_ASM_X86_MCOUNT): Use $CC $CFLAGS $CPPFLAGS. (GMP_ASM_UNDERSCORE, GMP_ASM_ALIGN_FILL_0x90, GMP_ASM_RODATA): Put AC_REQUIREs outside AC_CACHE_CHECK. (GMP_C_SIZES): Use $srcdir/gmp.h, not -I; use $CPPFLAGS. (GMP_ASM_UNDERSCORE): Use "gmp_compile" variable, and only rm conftes1* conftes2*. (GMP_PROG_NM): New macro, require it in appropriate GMP_ASM_*. (GMP_TRY_ASSEMBLE): New macro, use it in various GMP_ASM_*. * configure.in: Use GMP_PROG_NM. * mpn/tests/spinner.c (spinner_signal): Use RETSIGTYPE. (spinner_init): Force output to unbuffered. * mpn/x86/README.family: Notes about GOT table and imul, misc updates. * mpn/x86/k7/diveby3.asm: Change to 3 operands for immediate imul. * mpn/x86/k6/diveby3.asm: Ditto. 2000-11-06 Torbjorn Granlund * urandom.h: Simplify and make it work properly for 64-bit machines also in environments without `random'. 2000-11-04 Torbjorn Granlund * configure.in [path switch]: Don't match rs6000-*-*, in particular don't assume POWER. * tune/tuneup.c (fft): Remove usleep calls. * config.guess: Don't pass "$@" when it is known to be empty. * Makefile.am (EXTRA_DIST): List configfsf.guess and configfsf.sub. 2000-11-04 Kevin Ryde * configfsf.guess, configfsf.sub: Moved from config.guess and config.sub. * config.guess, config.sub: New files, wrappers around around configfsf versions. * configfsf.guess: Update to FSF 2000-10-23. * configfsf.sub: Update to FSF 2000-10-25. * acinclude.m4 (GMP_ASM_POWERPC_R_REGISTERS): New macro. * mpn/powerpc32/powerpc-defs.m4: New file, regmap.m4 r0 etc macros conditionalized by GMP_ASM_POWERPC_R_REGISTERS. * mpn/powerpc32/regmap.m4: Remove file. * configure.in (powerpc*-*-*): Use all this. * mpz/divegcd.c: New file, providing mpz_divexact_gcd. * Makefile.am, mpz/Makefile.am: Add it. * gmp-impl.h (mpz_divexact_gcd): Add prototype. * mpq/aors.c,canonicalize.c,div.c,mul.c: Use it. * longlong.h [pentium] (count_leading_zeros): New macro. (__clz_tab): Always provide prototype. * acconfig.h (HAVE_TARGET_CPU_): Add x86s. * tune/speed.[ch],common.c (count_leading_zeros, count_trailing_zeros, __udiv_qrnnd_c): Add measuring. * configure.in (X86_PATTERN): Move from here ... * acinclude.m4 (X86_PATTERN): ... to here. (GMP_ASM_RODATA): Use it. * configure.in (srandom): New test. * mpn/tests/try.c: Use it. * tune/speed.c: Ditto, and conditionalize getrusage and headers. 2000-11-02 Kevin Ryde * mpn/Makefile.am (nodist_libdummy_la_SOURCES): Add udiv_qrnnd.c and udiv_w_sdiv.c. * mpn/generic/mul_n.c (mpn_kara_sqr_n): Remove a duplicate subtract at the evaluate stage. 2000-11-01 Torbjorn Granlund * configure.in [compiler switch] (sparc64-*-linux*): Spell gmp_xoptcflags_gcc properly, and pass same options as for other sparcv9 configs. * tune/speed.h (SPEED_ROUTINE_MPN_GET_STR): Fix type of wsize. 2000-10-31 Torbjorn Granlund * configure.in [compiler switch] (sparc64-*-linux*): Remove -mvis from gmp_xoptflags_gcc, this might not be an ultrasparc. Remove -m32 from gmp_cflags_gcc; add -Wa,-xarch=v8plus. 2000-10-29 Torbjorn Granlund * mpn/ia64/lorrshift.asm: New file. * configure.in: New mulfunc `lorrshift' for lshift and rshift. 2000-10-29 Kevin Ryde * mpn/generic/mul_n.c (mpn_kara_sqr_n): Delete code performing superfluous mpn_sub_n calls. * configure.in (found_asm, M4): Account for SPEED_CYCLECOUNTER_OBJ, for the benefit of targets whose only .asm is a cycle counter. * tune/tuneup.c (fft): Remove bogus usleep calls. 2000-10-28 Torbjorn Granlund * mpn/ia64/invert_limb.asm: Get return value for 0x800...00 right. * tune/Makefile.am (EXTRA_DIST): Add ia64.asm. * tune/ia64.asm: Fix typo. * add_n.asm addmul_1.asm mul_1.asm popcount.asm sub_n.asm: Preserve ar.lc as required by ABI. * longlong.h (ia64 udiv_qrnnd): New. * configure.in [path switch] (ia64*-*-*): Set extra_functions. * mpn/ia64/invert_limb.asm: New file. 2000-10-27 Torbjorn Granlund * configure.in [compiler switch]: Get rid of c89 for all hppa flavours--it is an evil compiler! * tune/speed.h (SPEED_ROUTINE_MPN_SET_STR): Fix type of xp. (SPEED_ROUTINE_MPN_GET_STR): Fix type of wp. 2000-10-27 Kevin Ryde * gmp.texi (Fibonacci Number Algorithm): New section. * mpz/tests/t-fib_ui.c: New file. * mpz/tests/Makefile.am (check_PROGRAMS): Add it. * mpz/fib_ui.c: Rewrite, same formulas but using mpn functions and some lookup tables, much faster at small to moderate sizes. * gmp-impl.h (MPZ_FIB_SIZE): New macro. (FIB_THRESHOLD): Establish default here. * tune/tuneup.c (FIB_THRESHOLD): Start search after the new table data. * mpn/x86/x86-defs.m4 (mcount_movl_GOT_ebx): Rename from movl_GOT_ebx, and don't use GSYM_PREFIX with _GLOBAL_OFFSET_TABLE_. * tune/freq.c (speed_cpu_frequency_measure): New test comparing gettimeofday and speed_cyclecounter, should cover many systems. 2000-10-27 Torbjorn Granlund * mpn/ia64/gmp-mparam.h: Retune. 2000-10-26 Torbjorn Granlund * longlong.h (ia64): Set UMUL_TIME and UDIV_TIME. * mpn/ia64/submul_1.c: Fix typo. 2000-10-25 Kevin Ryde * tune/freq.c (speed_cpu_frequency_sysctl): New test, supporting hw.model for BSD flavours. * configure.in (sysctl, sys/param.h): New tests. 2000-10-24 Torbjorn Granlund * tune/freq.c: Explicitly #include config.h before other include files. * mpz/tests/reuse.c (FAIL2): New #define. (main): Use FAIL2. Now this test properly returns non-zero exit status when it fails. * mpn/powerpc32/gmp-mparam.h: Retune. * mpn/powerpc64/gmp-mparam.h: Retune. 2000-10-24 Kevin Ryde * mpn/x86/k6/cross.pl: Support 8 and 16 byte code alignment. * mpq/aors.c, mpq/canonicalize.c: Skip two mpz_divexact calls if gcd gives 1, which should be 60% of the time. * gmp-impl.h (MPZ_EQUAL_1_P): New macro. * mpq/mul.c, mpq/div.c: Use it, and a new DIV_OR_SET. * tune/tuneup.c (xp_block, yp_block): Initialize these with random data. Fixes GCD_ACCEL and GCDEXT thresholds, and latest POWM. 2000-10-23 Torbjorn Granlund * configure.in [SPEED_CYCLECOUNTER_OBJS switch]: Add ia64 case. * mpn/ia64/gmp-mparam.h: Fill in some parameters. * mpn/ia64/submul_1.c: New file. * tune/ia64.asm: New file. * gmp-impl.h (union ieee_double_extract): Handle ia64. * mpn/mp_bases.c: Decrease chars_per_bit_exactly for entry 1 to work around buggy ia64-linux. * longlong.h (ia64 umul_ppmm): Update register flags to match new GCC. 2000-10-22 Torbjorn Granlund * mpn/alpha/ev6/gmp-mparam.h (DC_THRESHOLD): Update. * mpn/alpha/ev6/submul_1.asm: New file. 2000-10-22 Kevin Ryde * tune/gcd_bin.c: New file. * tune/gcd_finda_gen.c: New file. * tune/Makefile.am (libspeed_la_SOURCES): Add them. * tune/speed.[ch],common.c (mpn_gcd_binary, find_a): Add measuring. * * (__gmp_allocate_func etc): Rename from _mp_allocate_func etc. (__gmp_default_allocate etc): Rename from _mp_default_allocate etc. * gmp-impl.h (__GMP_REALLOCATE_FUNC_TYPE, __GMP_REALLOCATE_FUNC_LIMBS): New macros. * gmp-impl.h (DC_THRESHOLD): Establish default here, set to 3*KARA since that's the measured average. * mpn/generic/dc_divrem_n.c, mpn/generic/tdiv_qr.c (DC_THRESHOLD): Remove default. 2000-10-21 Torbjorn Granlund * mpn/Makefile.am (TARG_DIST): Add ia64. 2000-10-21 Kevin Ryde * *: Change BZ -> DC. * mpn/generic/dc_divrem_n.c: Renamed from bz_divrem_n.c. * doc/multiplication: Remove file, now in the manual. * doc/assembly_code: Ditto. * tune/README: Remove some parts now in the manual. * gmp.texi (@m etc): Add and use some new macros. (Integer Division - mpz_[cft]div_*): Merge descriptions, for brevity and to emphasise similarities. (Low-Level Functions - mpn_[lr]shift): Specify count as 1 to mp_bits_per_limb-1. (Algorithms): New chapter. (References): Add some papers. * mpn/generic/mul_n.c (mpn_toom3_mul_n, mpn_toom3_sqr_n): Remove some unused variables. * mpn/generic/mul_fft.c (mpn_fft_best_k): Ditto. * tune/freq.c: New file, split from time.c. * tune/time.c: Rewrite, now more automated. * configure.in, tune/*: Consequent changes. 2000-10-20 Torbjorn Granlund * mpn/ia64/default.m4: New file. * configure.in [config.m4 switch] (ia64*-*-*): Use ia64/default.m4. * mpn/ia64/mul_1.asm: New file. * mpn/ia64/addmul_1.asm: New file. * mpn/ia64/add_n.asm: New file. * mpn/ia64/sub_n.asm: New file. * mpn/ia64/popcount.asm: New file. * mpn/ia64/README: New file. * mpn/alpha/cntlz.asm: Override `.set noat' from ASM_START. * configure.in (HAVE_TARGET_CPU_*): Support hppa1.0, hppa1.1, hppa2.0 by sed'ing the period into `_'. * acconfig.h: Add #undefs for hppa targets. * longlong.h (udiv_qrnnd): Fix typo in last change. * mpz/tstbit.c: Rewrite (partly to work around GCC 2.95.2 HPPA bug). * configure.in [path switch]: (hppa2.0*-*-*): For non-CC64 case, update path. * configure.in [compiler switch]: (hppa2.0w-*-*): Match with same regexp in both places. (hppa*-*-*): New case. (all hppa alternatives): Don't inherit default gmp_cflags_cc, gmp_cflags_c89. 2000-10-18 Torbjorn Granlund * configure.in (alpha*-*-*): Define gmp_xoptcflags_gcc like for alpha*-*-osf*. * longlong.h (x86 udiv_qrnnd): Change `d' => `dx' to avoid K&R C stringification. 2000-10-15 Kevin Ryde * doc/configuration: Updates. * demos/calc.y: Remove some comments. 2000-10-14 Kevin Ryde * gmp.texi (Parameter Conventions, Memory Management): New sections split from "Variable Conventions". (Efficiency, Debugging, Profiling): New sections in "GMP Basics". (Reentrancy): Some rewording, add note on standard I/O. (Build options): Add --enable-assert and --enable-profiling. * configure.in (--enable-profiling): New option. * acinclude.m4 (GMP_ASM_X86_MCOUNT): New macro, finding how to profile. * mpn/x86/x86-defs.m4 (PROLOGUE_cpu, call_mcount): Profiling support. * acinclude.m4, configure.in (GMP_ASM_*): Rename from GMP_CHECK_ASM_*, to follow autoconf conventions. * configure.in: Run GMP_CHECK_ASM tests only if needed. * acinclude.m4 (GMP_CHECK_ASM_MMX): Don't use GMP_CHECK_ASM_TEXT. * mpn/x86/x86-defs.m4 (ASSERT): Allow no condition, to just emit code. 2000-10-13 Kevin Ryde * mpq/md_2exp.c: New file. * mpq/Makefile.am (libmpq_la_SOURCES): Add it. * Makefile.am (MPQ_OBJECTS): Ditto. * gmp.h (mpq_mul_2exp, mpq_div_2exp): Add prototypes. * gmp.texi (Rational Arithmetic): Add documentation. * mpq/tests/t-md_2exp.c: New file. * mpq/tests/Makefile.am (check_PROGRAMS): Add it. * mpn/generic/perfsqr.c: Add/amend some comments. * gmp.texi (Known Build Problems): Note VERSION problem with old sed, do some minor rewording. (Build Options): Add cygwin and djgpp URLs, mention INSTALL.autoconf, mention HTML. (Getting the Latest Version of GMP): Move this ... (Introduction to GMP): ... to here. (Compatibility with older versions): Just refer to 2.x and 3.x, not every minor version. (Initializing Integers): Note restrictions on mpz_array_init'ed variables. (Integer Logic and Bit Fiddling): Note bits are numbered from 0. * INSTALL.autoconf: New file. * Makefile.am (EXTRA_DIST): Add it. * tune/Makefile.am, tune/tuneup.c, configure.in, gmp-impl.h: New scheme for recompiled objects used by tune program. Don't use libgmptune.a, make better use of libtool, work with ansi2knr. * tune/speed.h,common.c (SPEED_ROUTINE_MPZ_POWM): Use s->yp and s->xp_block, make exponent a fixed size. 2000-10-07 Torbjorn Granlund * mpn/mips3/gmp-mparam.h: Retune. * mpn/generic/mul_n.c (USE_MORE_MPN): Revert last change. 2000-10-06 Torbjorn Granlund * mpn/mips3/add_n.s: Decrease carry recurrence from 4 to 3 cycles. * mpn/mips3/sub_n.s: Likewise. 2000-10-04 Torbjorn Granlund * configure.in (sparc64-*-linux*): Set path according to CC64. 2000-10-04 Kevin Ryde * acinclude.m4 (GMP_CHECK_ASM_UNDERSCORE): Use LABEL_SUFFIX, not a hard-coded ":". * config.sub: Don't demand "86" in CPU name for SCO. * configure.in (supersparc-*-*): Remove -DSUPERSPARC. * longlong.h: Use HAVE_TARGET_CPU_supersparc. * configure.in (HAVE_TARGET_CPU_*): AC_DEFINE from $target_cpu. * acconfig.h: Add #undefs, but only for targets of interest. 2000-10-03 Torbjorn Granlund * mpn/alpha/cntlz.asm: Rewrite. * mp_clz_tab.c (__clz_tab): Half table size to 128 entires. * longlong.h (count_leading_zeros): Demand just 128 entries from __clz_tab. * configure.in (mips-sgi-irix6.*): Pass -mips3 in addition to options for n32 ABI. * longlong.h: Move NO_ASM test around all assembly code. From gcc: * longlong.h (count_leading_zeros): Sparclite scan instruction was being invoked incorrectly. Replace __mc68332__ with __mcpu32__. Add ARC support. 2000-10-02 Torbjorn Granlund * mpn/mips3/gmp-mparam.h: Retune for both gcc and cc. * mpn/generic/mul_n.c (USE_MORE_MPN): Remove exception for __mips. (interpolate3): Cast mp_limb_t variables to mp_limb_signed_t when testing sign bit. * mpn/alpha/ev6/gmp-mparam.h: Retune. * mpn/powerpc32/gmp-mparam.h: Retune. * mpn/powerpc64/gmp-mparam.h: Retune. * mpn/x86/pentium/gmp-mparam.h: Retune. * mpn/x86/pentium/mmx/gmp-mparam.h: Retune. * mpn/sparc32/v9/gmp-mparam.h: Retune. * mpn/x86/k6/gmp-mparam.h: Retune. * mpn/x86/p6/gmp-mparam.h: Retune. * mpn/x86/k7/gmp-mparam.h: Retune. * mpn/sparc64/gmp-mparam.h: Retune. * mpn/m68k/gmp-mparam.h: New file. * mpn/alpha/ev5/gmp-mparam.h: New file. * gmp-impl.h (default MPN_COPY): Remove final `;'. * tune/time.c (speed_endtime): Rewrite. * tune/speed.h (SPEED_ROUTINE_MPZ_POWM): Set base to a large value, not 2. * demos/pexpr.c (setup_error_handler): Fix typo. * mpz/powm.c (redc): New function, based on old mpz_redc. Don't multiply here. (mpz_redc): Remove. (mpz_powm): Major changes, partially reverting to mpn calls. Multiply before calling redc. (mpz_powm): Use TMP_ allocation. (mpz_powm): Refine calculation of k (width of exponent window). (mpz_powm): Cast constants to mp_limb_t before left shifting. * longlong.h: Use ia64 count_leading_zeros just when __GNUC__. 2000-09-29 Kevin Ryde * acinclude.m4 (GMP_C_SIZES): New macro. * configure.in: Use it. * acconfig.in (BYTES_PER_MP_LIMB etc): Add #undefs. * mpn/generic/gmp-mparam.h (BYTES_PER_MP_LIMB etc): Remove #defines. * gmp.texi (Known Build Problems): Remove 64-bit generic C gmp-mparam.h problem, now fixed. * configure.in: Only run GMP_PROG_M4 if it's actually needed. 2000-09-27 Torbjorn Granlund * demos/pexpr.c: Clean up code for systems not supporting sigaltstack. Handle old Linux without sigaltstack. Properly disable all stuff related to sigaltstack under Unicos. * mpn/alpha/ev6/addmul_1.asm: Use explicit offset for all load and store insns. Helps old gas. * longlong.h (count_leading_zeros): Define for ia64. 2000-09-27 Paul Zimmermann * mpn/generic/bz_divrem_n.c: Fix qhl handling, simplify. 2000-09-27 Kevin Ryde * mpn/Makefile.in (.SUFFIXES): Regenerate with patched automake to get .s before .c, which is needed to override ansi2knr .c rules. * gmp.texi (mpn_sqrtrem): Fix r2p==NULL return value description to match the code (change by Torbjorn). (mpn_gcd, mpn_gcdext, mpn_sqrtrem, mpn_tdiv_qr): Note most significant limbs must be non-zero. (mpn_gcd, mpn_gcdext, mpn_sqrtrem): Clarify destination size requirements. (mpn_gcd_1): Clarify value must be non-zero, not just size. * gmp-impl.h (mpn_zero_p): New inline function. * mpn/generic/inlines.c: Add gmp-impl.h. * mpf/integer.c, mpz/get_d.c, mpn/generic/mul_fft.c: Use it. * mpn/generic/gcd.c: Use MPN_COPY_INCR not MPN_COPY. * mpf/add_ui.c: Ditto. * mpf/add.c: Ditto, and fix test to skip copy. 2000-09-26 Kevin Ryde * gmp-impl.h, longlong.h, mpn/generic/*.c: Add ASSERTs for various parameter restrictions. * gmp-impl.h (UDIV_PREINV_TIME): New macro. * mpn/generic/sb_divrem_mn.c: Use it. * mpn/generic/perfsqr.c: Ditto. * mpn/x86/*/gmp-mparam.h (UDIV_PREINV_TIME): Add values. * macos/Makefile.in: Add mpz/tests/t-get_si.c, mpf/tests/t-set_f.c, and new multi-function mpz and mpq files. 2000-09-25 Kevin Ryde * randlc.c, randlc2x.c, randsd.c, mpz/urandomb.c, mpz/urandomm.c: Use mpz_ptr and mpz_srcptr for parameters. * gmp.h (gmp_randinit_lc, gmp_randinit_lc_2exp, gmp_randseed, mpz_urandomb, mpz_urandomm): Corresponding change to prototypes. * randsdui.c: Remove wrong K&R parameters part. 2000-09-12 Kevin Ryde * gmp-impl.h (mpn_tdiv_qr): Move prototype from here ... * gmp.h (mpn_tdiv_qr): ... to here. * gmp.texi (Miscellaneous Rational Functions): Comment-out and move version 1 compatibility note to "Compatibility" section. (Rational Number Functions): Ditto for canonicalization note. 2000-09-10 Kevin Ryde * mpn/x86/pentium/com_n.asm: New file. * gmp.texi (Rational Arithmetic): Add mpq_abs. (Miscellaneous Rational Functions): Merge and simplify descriptions of mpq_get_num, mpq_get_den, mpq_set_num, mpq_set_den. * mpq/abs.c: New file. * mpq/Makefile.am (libmpq_la_SOURCES): Add it. * Makefile.am (MPQ_OBJECTS): Add it. * gmp.h (mpq_abs): Add prototype. * mpq/set_den.c: Don't discard sign when copying, this makes the code match the manual. 2000-09-07 Torbjorn Granlund * tune/alpha.asm: Rewrite to actually work right. 2000-09-07 Kevin Ryde * tune/common.c,speed.[ch]: Add measuring of mpn_sqrtrem, mpn_get_str, mpn_set_str. * tune/README: Various updates. 2000-09-06 Torbjorn Granlund * mpz/fits.c: Correct type of `data'. 2000-09-06 Kevin Ryde * gmp.texi (Build Options): Clarify where to find CFLAGS. (Known Build Problems): Note SCO -lc problem. * tune/speed.h (SPEED_ROUTINE_MPN_GCD_CALL): Fix for sizes > 512 limbs. * doc/multiplication: Corrections and additions suggested by Paul. * tune/modlinv.c: New file with alternate modlimb_inverts. * tune/Makefile.am, tune/speed.[ch]: Add measuring of them. * tune/speed.c (FLAG_NODATA): New attribute, use for mpz_bin_uiui, mpz_fib_ui, mpz_fac_ui. * mpn/x86/t-zdisp.sh: New file. * tests/t-modlinv.c: New file. * tests/Makefile.am (check_PROGRAMS): Add it. * mpq/tests/t-set_f.c: New file. * mpq/tests/Makefile.am (check_PROGRAMS): Add it. * gmp-impl.h (MPQ_CHECK_FORMAT): New macro. * mpq/tests/t-get_d.c: Use it. * mpq/set_f.c: New file. * mpq/Makefile.am (libmpq_la_SOURCES): Add it. * Makefile.am (MPQ_OBJECTS): Ditto. * gmp.h: Add prototype. * gmp.texi (Miscellaneous Rational Functions): Document mpq_set_f, correct return type of mpq_set_d. 2000-09-03 Kevin Ryde * mpz/aors_ui.c: New file merging add_ui.c and sub_ui.c, no object code changes. * mpz/add_ui.c, mpz/sub_ui.c: Remove files. * mpz/Makefile.am: Update. * gmp-impl.h (MPZ_FITS_STYPE_SDT, MPZ_FITS_UTYPE_SDT): New macros. * mpz/fits.c: New file merging six separate fits*.c. * mpz/fits_sshort_p.c, fits_sint_p.c, fits_slong_p.c, fits_ushort_p.c, fits_uint_p.c, fits_ulong_p.c: Remove files * mpz/Makefile.am: Use new fits.c, change object names from fits_*_p.lo to fits_*.lo to avoid SunOS 4 native "ar" warnings. * Makefile.am (MPZ_OBJECTS): Change from fits_*_p.lo to fits_*.lo. * acinclude.m4 (GMP_CHECK_ASM_RODATA): New macro, defining RODATA. * configure.in: Use it. * mpn/x86/k[67]/mmx/popham.asm: Use it. * mpn/x86/*/*.asm: Use "TEXT" not ".text". 2000-09-02 Kevin Ryde * mpq/aors.c: New file merging add.c and sub.c, no object code changes. * mpq/add.c, mpq/sub.c: Remove files. * mpq/Makefile.am: Update. * mpz/aors.c: New file merging add.c and sub.c, no object code changes. * mpz/add.c, mpz/sub.c: Remove files. * mpz/Makefile.am, mpbsd/Makefile.am: Update. * configure.in: Re-apply "PROLOGUE.*" regexp change for the benefit of alpha PROLOGUE_GP, lost in path search reorganisation. * mpn/x86/x86-defs.m4 (jadcl0, cmov_simulate, ASSERT, movl_text_address): Don't use "1:" style labels. (Zdisp): Rearrange a bit, switch to all hex. * mpn/x86/README.family: Note SCO "as" doesn't support "1:" style local labels, misc rewordings. 2000-08-29 Torbjorn Granlund * demos/primes.c: Include string.h. * config.guess (x86 variant recog code): Remove dummy*.o files generated by some compilers. 2000-08-28 Kevin Ryde * acinclude.m4 (GMP_CHECK_ASM_ALIGN_FILL_0x90): Fix Solaris 2.8 warning message suppression, add notes about SCO. * Makefile.am (MPZ_OBJECTS etc): Move some comments. 2000-08-25 Kevin Ryde * mpz/pprime_p.c (mpz_millerrabin): Fix a TMP_FREE. * gmp.texi (Copying): Refer to Lesser not Library GPL. (GMP and Reentrancy): Note stack-alloc.c is not reentrant, and that SCO is potentially not reentrant. * acinclude.m4 (GMP_CHECK_ASM_UNDERSCORE): Test by attempting to link with or without an underscore. * gmp.texi (Known Build Problems): Remove SunOS 4 native grep GSYM_PREFIX problem, now fixed. * gmp-impl.h (MODLIMB_INVERSE_3): New constant. * mpn/generic/diveby3.c: Use it instead of own INVERSE_3. * mpn/generic/mul_n.c: Ditto. * tests/t-constants.c: Check it, and PP_INVERTED too. * acinclude.m4 (GMP_GCC_MARCH_PENTIUMPRO): New macro. * configure.in [p6 and athlon] (gmp_optcflags_gcc): Use it to possibly add -march=pentiumpro. * gmp-impl.h (MPZ_SET_STR_OR_ABORT, MPF_SET_STR_OR_ABORT): New macros. * mpz/tests/t-bin.c, mpz/tests/t-get_si.c, mpz/tests/t-jac.c, mpz/tests/t-misc.c: Use them. * mpf/tests/t-conv.c, mpf/tests/t-misc.c: Ditto. * mpz/tests/convert.c: Ditto and amend diagnostics slightly. * mpz/tests/t-misc.c (check_mpz_set_si): Remove a superfluous init. * mpz/tests/io.c: Differentiate between I/O and data conversion errors. * mpn/generic/aors_n.c: New file merging add_n and sub_n, no object code changes. * mpn/generic/add_n.c: Remove file. * mpn/generic/sub_n.c: Remove file. * mpn/generic/aorsmul_1.c: New file merging addmul_1 and submul_1, no object code changes. * mpn/generic/addmul_1.c: Remove file. * mpn/generic/submul_1.c: Remove file. * mpn/generic/popham.c: New file merging popcount and hamdist, no object code changes. * mpn/generic/popcount.c: Remove file. * mpn/generic/hamdist.c: Remove file. 2000-08-24 Torbjorn Granlund * gmp-impl.h (mpn_com_n): Fix typo. 2000-08-23 Torbjorn Granlund * demos/primes.c (main): Don't call mpz_probab_prime_p for numbers that are known to be prime after sieving. (main): Declare and initialize max_s_prime_squared. (MAX_S_PRIME): Increase. (ST_SIZE): Increase. 2000-08-23 Kevin Ryde * gmp-impl.h (ASSERT_ALWAYS): Change to statement style. (JACOBI_TWO_U_BIT1): Remove ASSERT. (MPZ_CHECK_FORMAT): Use ASSERT_ALWAYS as a statement. 2000-08-21 Torbjorn Granlund * gmp-impl.h (ASSERT): Use do..while for dummy version. * mpf/get_str.c: Don't set n_digits from digits_computed_so_far when the converted operand becomes zero. Misc cleanups. 2000-08-21 Kevin Ryde * mpz/fdiv_r_2exp.c, mpz/lcm.c, mpz/urandomm.c: Add missing TMP_MARK/FREE, avoiding memory leak when using stack-alloc.c. 2000-08-20 Kevin Ryde * mpz/set.c [BERKELEY_MP] (move): Add conditionals to build as "move" for libmp. * mpbsd/Makefile.am: Use mpz/set.c, not move.c. * Makefile.am (MPBSD_OBJECTS): Corresponding change. * mpbsd/move.c: Remove file. * mpn/Makefile.am, mpz/Makefile.am, mpq/Makefile.am, mpf/Makefile.am, mpbsd/Makefile.am (-DOPERATION_foo): Use "foo" even for ansi2knr "foo_" objects. Do this with the makefiles to keep the sources cleaner. * mpz/mul_siui.c, mpf/integer.c: Revert to plain OPERATION_* forms. * mpn/lisp/gmpasm-mode.el (gmpasm-remove-from-list): Renamed from gmpasm-delete-from-list, because it's non-destructive. (gmpasm-font-lock-keywords): Add some more keywords. 2000-08-16 Kevin Ryde * tune/mul_n_mpn.c, tune/mul_n_open.c: New files, being forced open-coded and mpn #includes of mpn/generic/mul_n.c. * tune/*: Add measuring of them. * tune/speed.c: Print command line into *.gnuplot file. * mpn/generic/mul_n.c (USE_MORE_MPN): Change to #if not #ifdef for using the value, add #ifndef for providing the default. * mpn/sparc64/gmp-mparam.h (USE_MORE_MPN): Add #ifndef. * tests/t-constants.c: New file. * tests/Makefile.am (check_PROGRAMS): Add it. * mpz/get_si.c: Use LONG_MAX, not BITS_PER_MP_LIMB, so the result doesn't depend on limb size when outside the range of a long (though such results are not actually documented). * mpz/tests/t-get_si.c: New file. * mpz/tests/Makefile.am (check_PROGRAMS): Add it. * mpn/tests/try.c (call): Cast popcount and hamdist calls, for the benefit of long long limb. 2000-08-15 Kevin Ryde * mp.h (mp_set_memory_functions): Add missing #define. * mpbsd/tests/allfuns.c (mp_set_memory_functions): Verify its existance. * mpf/tests/t-misc.c (check_mpf_getset_prec): New test, verifying reverted behaviour of mpf_get_prec. * mpn/tests/ref.c (refmpn_strip_twos): Use refmpn_copyi, not MPN_COPY_INCR. * mpz/mul_siui.c, mpf/integer.c: Recognise OPERATION_*_ forms produced under ansi2knr. * configure.in (mpn_objects, mpn_objs_in_libgmp): Add $U to .c objects when ansi2knr in use. * mpn/Makefile.am (AUTOMAKE_OPTIONS): Enable ansi2knr. (libdummy.la): Add this, not built, to create ansi2knr style rules for all potential .c files. * mpz/Makefile.am, mpq/Makefile.am, mpf/Makefile.am, mpfr/Makefile.am, mpbsd/Makefile.am, mpq/tests/Makefile.am, tests/Makefile.am (AUTOMAKE_OPTIONS): Enable ansi2knr (now everywhere). * Makefile.am (MPZ_OBJECTS, MPQ_OBJECTS, MPF_OBJECTS, MPFR_OBJECTS, MPBSD_OBJECTS, libmp_la_DEPENDENCIES): Add $U to all .lo filenames. 2000-08-03 Torbjorn Granlund * mpn/alpha/ev6/addmul_1.asm: Correct number of cycles to 3.5/28. 2000-08-02 Torbjorn Granlund * Version 3.1 released. * gmp.texi: Rephrase mpf_urandomb documentation. * mpn/alpha/ev6: New directory with ev6/21264 optimized code. * mpn/alpha/ev6/addmul_1.asm: New file. * mpn/alpha/ev6/gmp-mparam.h: New file. 2000-08-02 Kevin Ryde * demos/factorize.c (random): Don't use "inline". * mpfr/log.c, mpfr/mul_ui.c, mpfr/round.c, mpfr/set.c, mpfr/set_d.c: Corrections to K&R parts. * Makefile.am (EXTRA_HEADERS): Omit $(MPFR_HEADERS_OPTION). * mpfr/Makefile.am (EXTRA_DIST): Add mpfr.h. * gmp.texi (Known Build Problems): Note problem stripping libgmp.a. 2000-08-02 Kent Boortz * mpfr: Integrated experimental version of mpfr-0.4. * configure.in: Changes for option --enable-mpfr. * Makefile.am: Changes for option --enable-mpfr. 2000-08-01 Torbjorn Granlund * mpn/generic/popcount.c: Disable SPARC v9 popc_limb pattern. * mpn/generic/hamdist.c: Likewise. 2000-08-01 Kevin Ryde * mpn/tests/try.c (try_init): Account for ALIGNMENTS when sizing source and dest regions. 2000-07-31 Torbjorn Granlund * mpf/get_str.c: Develop three extra digits, not just one. 2000-07-31 Kevin Ryde * gmp.texi (References): Add URL for invariant division. 2000-07-30 Kevin Ryde * tune/time.c (speed_cpu_frequency_proc_cpuinfo): Add support for alpha linux "cycle frequency". * mpn/sparc64/gmp-mparam.h: Re-run tune program for FFT thresholds. 2000-07-29 Kevin Ryde * gmp.texi (ABI and ISA): Add sparc64-*-linux*. * configure.in [sparc64-*-linux*] (gmp_cflags64_gcc): Same flags as under solaris. * configure.in (--enable-fft): New option, default "no". * gmp.texi (Build Options): Describe it. * mpn/generic/mul.c, mpn/generic/mul_n.c [WANT_FFT]: Use it. * tune/tuneup.c [WANT_FFT]: By default don't probe FFTs if not enabled. * NEWS: Multiplication optionally using FFT. * tune/README: Notes on FFT and GCD thresholds, other minor updates. * Makefile.am: Expunge the macos generated files update stuff. 2000-07-28 Kevin Ryde * mpn/x86/*/gmp-mparam.h: Add some FFT thresholds. 2000-07-28 Kent Boortz * macos/Asm*, macos/CmnObj, macos/Mp*: Delete directories. * macos/Makefile: Delete file. * macos/Makefile.cw: Delete file. * macos/config.h: Delete file. * macos/Asm/*.s: Delete files. * macos/configure: Create target directories. Don't transform '(C)' to '(;)' in a 'dnl' line comment in .asm file. * Makefile.am: Delete macos targets. * macos/README: Reflect that we reverted back to a build process that require ""macos/configure" to run on MacOS. This imply that MacPerl is needed for a build in MacOS. 2000-07-27 Kevin Ryde * mpn/generic/mul_fft.c: New file, by Paul Zimmermann, minor mods applied. * configure.in (gmp_mpn_functions): Add it. * mpn/generic/mul.c, mpn/generic/mul_n.c: Use it. * doc/multiplication: Describe it (briefly). * gmp-impl.h (FFT_MUL_THRESHOLD etc): New thresholds. (mpn_fft_best_k, mpn_fft_next_size, mpn_mul_fft, mpn_mul_fft_full): New functions. (numberof, TMP_ALLOC_TYPE etc, _MP_ALLOCATE_FUNC_TYPE etc, UNSIGNED_TYPE_MAX etc): New macros. * tune/*: Add FFT threshold tuning and speed measuring. * tune/common.c: Avoid huge macro expansions for umul and udiv. * mpz/tests/t-bin.c, mpz/tests/t-jac.c, mpz/tests/t-misc.c, mpbsd/tests/t-misc.c, mpf/tests/t-misc.c, mpn/tests/try.c, mpn/tests/spinner.c: Use new gmp-impl.h macros. * demos/Makefile.am (BUILT_SOURCES): Don't need calc.c etc under this. 2000-07-27 Torbjorn Granlund * mpn/ia64/gmp-mparam.h: New file. 2000-07-26 Torbjorn Granlund * demos/isprime.c: Handle any number of arguments and print classification for each. Add `-q' option for old behaviour. 2000-07-26 Kevin Ryde * gmp.texi (Build Options): Mention djgpp stack size. (Notes for Package Builds): New section. (Compatibility with older versions): Update for 3.1, add mpf_get_prec. * demos/factorize.c [__GLIBC__]: Don't declare random() under glibc. * gmp.h (gmp_version): Add prototype and define. * Makefile.am: Keep macos directory generated files up-to-date during development and on a "make dist". 2000-07-25 Torbjorn Granlund * mpn/hppa/gmp-mparam.h: Update threshold values from new `tune' run. * mpn/pa64/gmp-mparam.h: Fill in values from `make tune' run. * mpn/pa64w/gmp-mparam.h: Likewise. * mpn/mips3/gmp-mparam.h: Likewise. * tune/hppa2.asm: Fix typo in .level directive. * configure.in: Add sparc64-*-linux* support (from Jakub Jelinek). * configure: Regenerate. * mpn/sparc64/rshift.asm: Use %g5 instead of volatile stack frame area for return value (from Jakub Jelinek). * mpn/sparc64/lshift.asm: Likewise. * mpf/get_prc.c: Revert Aug 8, 1996 change. * version.c: No longer static. * mpn/pa64/gmp-mparam.h: Only #define *_THRESHOLD if not already defined. * mpn/pa64w/gmp-mparam.h: Likewise. * mpn/arm/gmp-mparam.h: Likewise. * mpn/mips3/gmp-mparam.h: Likewise. 2000-07-25 Kevin Ryde * INSTALL: It's "info -f ./gmp.info" to be sure of hitting the gmp.info in the current directory. * Makefile.am (libmp_la_DEPENDENCIES): Add mpz/cmp.lo, for last mpz/powm.c fix. * mpn/sparc64/addmul1h.asm, mpn/sparc64/submul1h.asm: Renamed from addmul_1h.asm, submul_1h.asm to avoid name conflicts on an 8.3 filesystem. * mpn/sparc64/addmul_1.asm, mpn/sparc64/submul_1.asm, mpn/sparc64/mul_1.asm: Update include_mpn()s. 2000-07-24 Torbjorn Granlund * Update header of all files previously under the Library GPL to instead be under the Lesser GPL. * COPYING.LIB: Now Lesser GPL. * demos/primes.c: Change license to GPL (was Library GPL). * demos/isprime.c: Change license to GPL (was Library GPL). * gmp.h (error code enum): Add GMP_ERROR_BAD_STRING (currently unused). * mpz/tests/t-mul.c: Default SIZE to a function of TOOM3_MUL_THRESHOLD. Improve error messages. Decrease reps. 2000-07-22 Kevin Ryde * tune/speed.h: Decrease the amount of data used for gcd and powm measuring, to make the tune go a bit faster. 2000-07-21 Kent Boortz * macos/Asm*, macos/CmnObj, macos/Mp*: Directories no longer created from configure script, now part of dist. * macos/Makefile * macos/Makefile.cw * macos/config.h * macos/Asm/*.s New files and directories that is the output from configure. This way no Perl installation is required to build on MacOS, just MPW. * macos/configure: Added prefix '__g' to exported assembler labels. Changed to handle new m4 syntax instead of the old cpp syntax in asm. * macos/Makefile.in: Corrected 'clean' target, added 'distclean' and 'maintainer_clean'. Added "mpn/mp_bases.c" to build. * macos/README: Reflect the new build process without configure. Corrected the file structure for Apple MPW installation. 2000-07-21 Torbjorn Granlund * mpf/tests/t-muldiv.c: Relax error limit. Make precision depend on SIZE. Misc changes. * configure: Regenerate. 2000-07-20 Kent Boortz * macos/Makefile.in: Removed hard coded targets, added special targets found in Makefile.am files. * macos/configure: Generate targets from top configure script and Makefile.am files. Made script runnable from Unix for testing. * macos/README: Notes about search paths for includes, contributed by Marco Bambini. * configure.in: Added comment about lines that the "macos/configure" script depend on. 2000-07-20 Torbjorn Granlund * mpz/powm.c (mpz_powm): After final mpz_redc call, subtract `mod' from result if it is greater than `mod'. 2000-07-19 Torbjorn Granlund * mpn/hppa/gmp-mparam.h: Fill in values from `make tune' run. * mpn/alpha/gmp-mparam.h: Likewise. * mpn/powerpc32/gmp-mparam.h: Likewise. * tune/hppa.asm: New file. * tune/hppa2.asm: New file. * configure.in (SPEED_CYCLECOUNTER_OBJS): Set for hppa2*-*-* and hppa*-*-*. * tune/Makefile.am (EXTRA_DIST): Add hppa.asm and hppa2.asm. * tune/speed.h (SPEED_ROUTINE_MPN_BZ_DIVREM_CALL): Declare `marker'; invoke TMP_FREE. * mpn/hppa/hppa1_1/udiv_qrnnd.S: Use "%" instead of "'" for reloc/symbol delimiter. 2000-07-16 Torbjorn Granlund * mpn/powerpc64/gmp-mparam.h: Update with output from tune utility. * mpn/powerpc64/copyi.asm: New file. * mpn/powerpc64/copyd.asm: New file. 2000-07-16 Kevin Ryde * tune/*: Add measuring for umul_ppmm and udiv_qrnnd. 2000-07-14 Kevin Ryde * mpn/x86/k6/k62mmx: New directory. * configure.in (k6[23]*-*-*): Use it. * mpn/x86/k6/k62mmx/copyi.asm, mpn/x86/k6/k62mmx/copyd.asm: Move from mmx directory, improve code alignment a bit. * mpn/x86/k6/k62mmx/lshift.asm, mpn/x86/k6/k62mmx/rshift.asm: Ditto, and improve addressing modes for pre-CXT cores. * mpn/x86/x86-defs.m4 (Zdisp): Add an instruction. * mpn/x86/k6/mmx/lshift.asm, mpn/x86/k6/mmx/rshift.asm: New files, suiting plain K6. * mpn/x86/README, mpn/x86/k6/README: Updates. * mpn/x86/k6/mmx/*.asm: Update some comments. * mpn/tests/Makefile.am: Use $(MAKE) in .asm rules, not "m". * tune/Makefile.am: Use $(EXEEXT) and libtool --config objdir, for the benefit of djgpp. * */Makefile.in: Regenerate with patched automake that adds $(EXEEXT) to EXTRA_PROGRAMS. * mpn/tests/try.c: Add #ifdef to SIGBUS, for the benefit of djgpp. * config.guess: Recognise pc:*:*:* as an x86, for djgpp. * configure: Regenerate with patched autoconf to fix temp file ".hdr" which is invalid on a DOS 8.3 filesystem, and to fix two sed substitutes that clobbered a ":" in $srcdir (eg. a DOS drive spec). * mpz/tests/io.c: Use one fp opened "w+", since separately opened input and output doesn't work on MS-DOS 6.21. * tests/rand/Makefile.am (allprogs): Pseudo-target to build everything. (CLEANFILES): Add EXTRA_PROGRAMS and EXTRA_LTLIBRARIES. (manual-test, manual-bigtest): Add $(EXEEXT) to dependencies. * tests/rand/*/Makefile.in: Regenerate with patched automake that adds $(EXEEXT) to EXTRA_PROGRAMS. 2000-07-13 Torbjorn Granlund * mpz/tests/t-root.c: Also test mpz_perfect_power_p. Generate `nth' so that there will be fewer trivial values. * mpz/root.c: Reverse return value in tests for detecting root of +1 and -1. * mpz/perfpow.c: Use TMP_ALLOC interface. 2000-07-12 Torbjorn Granlund * mpz/perfpow.c (primes): Make it const. 2000-07-06 Kevin Ryde * mpn/x86/k6/cross.pl: New file. * mpn/x86/*/gmp-mparam.h: Updates to thresholds, conditionalize all _TIME defines. * mpn/x86/pentium/mmx/gmp-mparam.h: New file. * mpn/sparc64/gmp-mparam.h: Update thresholds. * mpn/sparc32/v9/gmp-mparam.h: Ditto. 2000-07-04 Kevin Ryde * NEWS: Updates. * mpn/x86/*/README: Miscellaneous updates. * tune/speed-ext.c: New file. * tune/Makefile.am: Add it. * tune/README: Updates. * tune/speed.h (SPEED_ROUTINE_MPN_DIVREM_2): Bug fixes. * demos/calc.y,calclex.l: New files. * demos/calc.c,calc.h,calclex.c: New files, generated from .y and .l. * demos/Makefile.am: Add them. * gmp.h (mpq_swap, mpf_swap): Add prototypes and defines. 2000-07-01 Kevin Ryde * gmp.texi (ABI and ISA): New section, bringing together ABI notes. (Build Options): Add MPN_PATH, various updates. (Build Options): Add note on setting CFLAGS when setting CC. (Notes for Particular Systems): Add -march=pentiumpro problem. (Known Build Problems): Note on gmp-mparam.h for 64-bit generic C. (GMP Variable Conventions): Add some info on user defined functions. (Reporting Bugs): Minor rewording. * configure.in (MPN_PATH): Renamed from mpn_path. * gmp-impl.h (ULONG_MAX,ULONG_HIGHBIT,...,SHORT_MAX): New defines. * mp[zf]/tests/t-misc.c: Use them. * mpbsd/tests/t-misc.c: New file. * mpbsd/tests/Makefile.am: Add it. * Makefile.am (LIBGMP_LT_*, LIBMP_LT_*): Bump version info. * gmp.h (__GNU_MP_VERSION_*): Bump to 3.1. * mpf/tests/Makefile.am (AUTOMAKE_OPTIONS): Add ansi2knr. * Makefile.am (libmp_la_SOURCES): Add mp_set_fns.c, accidentally omitted in gmp 3.0.x. * gmp.texi (Custom Allocation): Note this is available in mpbsd, and some minor rewording. 2000-06-30 Torbjorn Granlund * demos/factorize.c (random): New function, defined conditionally. (factor_using_pollard_rho): Use it, not mrand48. * mpn/cray/README: New file. 2000-06-30 Kevin Ryde * mpn/x86/pentium/aorsmul_1.asm: Add MULFUNC_PROLOGUE. * mpz/tests/t-jac.c: Test limbs on mpn_jacobi_base, not just ulongs. * gmp-impl.h, mpn/tests/try.c, mpn/tests/spinner.c, tune/speed.c: Use config.h unconditionally, not under HAVE_CONFIG_H. * demos/pexpr.c [__DJGPP__]: Patch by Richard Dawe to not use setup_error_handler on djgpp. * tune/*: Locate data to help direct-mapped caches, add measuring of mpz_init/clear, mpz_add and mpz_bin_uiui, various cleanups. * configure.in (AC_CHECK_FUNCS): Add popen. 2000-06-29 Torbjorn Granlund * mpf/mul_2exp.c: Streamline criterion for whether to use mpn_lshift or mpn_rshift. Increase precision when exp is a multiple of BITS_PER_MP_LIMB primarily to make exp==0 be a noop. * mpf/div_2exp.c: Analogous changes. * mpf/tests/t-dm2exp.c: Set u randomly in loop. Perform more mpf_mul_2exp testing. * configure.in: Recognize cray vector processors with a broad `*'; move after alpha* not to match that. 2000-06-28 Kevin Ryde * mpz/tests/io.c: Use a disk file, not a pipe, switch to ansi2knr style, switch from MP_INT to mpz_t, add a couple of error checks. * mpz/tests/Makefile.am (CLEANFILES): Add io.tmp, in case io.c fails. 2000-06-27 Torbjorn Granlund * mpf/tests/t-get_d.c: Be more lax about relative error, to handle Cray floating point format. * mpq/tests/t-get_d.c: Decrease default reps to 1000. * mpf/tests/t-conv.c: Correct type of `bexp'. * configure.in (cray vector machines): Don't inherit gmp_cflags_cc. * tune/Makefile.am (EXTRA_DIST): Delete sparc64.asm. * configure.in (cray vector machines): Set extra_functions. * mpn/cray/mulww.f: New file with vectorizing cray code. * mpn/cray/mulww.s: Generated from mulww.f. * mpn/cray/mul_1.c: New file. * mpn/cray/addmul_1.c: New file. * mpn/cray/submul_1.c: New file. * mpn/cray/add_n.c: New file. * mpn/cray/sub_n.c: New file. 2000-06-26 Kevin Ryde * acinclude.m4 (GMP_CHECK_ASM_ALIGN_FILL_0x90): Fix so it actually detects solaris 2.6, and also suppress warning on solaris 2.8. * configure.in (SPEED_CYCLECOUNTER): Remove spurious "athlon" from sparc case. * mpn/lisp/gmpasm-mode.el: Move keymap to the top of the docstring. 2000-06-21 Kevin Ryde * mpn/generic/mul_n.c (mpn_kara_mul_n, mpn_kara_sqr_n): Use mp_size_t for n2. (mpn_toom3_mul_n, mpn_toom3_sqr_n): Use mp_size_t for size parameters and "l" variables. * gmp-impl.h (mpn_toom3_mul_n, mpn_toom3_sqr_n): Update prototypes. * mpbsd/itom.c, mpbsd/sdiv.c: Add casts for correct handling of -0x80...00 on systems with sizeof(short)==sizeof(int). * mpz/tests/t-misc.c: Move "bin" test from here ... * mpz/tests/t-bin.c: ... to here, and add a new (2k,k) test too. * mpz/tests/Makefile.am (check_PROGRAMS): Add t-bin. * mpz/bin_ui.c [_LONG_LONG_LIMB]: Use mpn_divrem_1, since kacc is a limb not a ulong. * mpz/bin_uiui.c [_LONG_LONG_LIMB]: Ditto, and use mpn_mul_1 too, since nacc is a limb. * mpf/tests/t-misc.c (check_mpf_set_si, check_mpf_cmp_si): New file, testing mpf_set_si, mpf_init_set_si, and mpf_cmp_si. * mpf/tests/Makefile.am (check_PROGRAMS): Add it. * mpz/tests/t-misc.c (check_mpz_set_si, check_mpz_cmp_si): New tests, for mpz_set_si, mpz_init_set_si, and mpz_cmp_si. * mpz/set_si.c, mpz/iset_si.c, mpz/cmp_si.c [_LONG_LONG_LIMB]: Fix handling of -0x80..00. * mpf/set_si.c, mpf/iset_si.c, mpf/cmp_si.c [_LONG_LONG_LIMB]: Ditto. 2000-06-19 Torbjorn Granlund * demos/primes.c: Properly handle arguments `m +n'. 2000-06-17 Torbjorn Granlund * config.sub: Recognize k5 and k6 with common pattern. * mpq/tests/t-get_d.c: Also test mpq_set_d. Misc improvements. * mpq/set_d.c: Special case 0.0. Don't call mpn_rshift with 0 count. Allocate correct amount of memory for numerator. Delete spurious ASSERT_ALWAYS(1). 2000-06-17 Kevin Ryde * mpz/perfsqr.c: Fix so that zero is considered a perfect square. (Was wrongly calling mpn_perfect_square_p with size==0.) 2000-06-16 Kevin Ryde * configure.in: Set k5*-*-* to use basic i386 code until there's something specific. Add path=x86 as a default for x86s. * acinclude.m4 (GMP_CHECK_ASM_ALIGN_LOG): Generate ALIGN_LOGARITHMIC setting, not a full ALIGN definition. (GMP_CHECK_ASM_ALIGN_FILL_0x90): New test. * configure.in [x86-*-*]: Use GMP_CHECK_ASM_ALIGN_FILL_0x90. * mpn/asm-defs.m4 (ALIGN): New macro. * mpn/x86/x86-defs.m4 (ALIGN): Remove supplementary definition. * tune/*: Plain "unsigned" for speed_cyclecounter. * configure.in: Use tune/sparcv9.asm for 32 and 64 bit modes. * tune/sparc64.asm: Remove file. 2000-06-15 Torbjorn Granlund * mpn/x86/k7/mmx/copyi.asm: Use `testb' instead of `test'. * mpn/x86/k7/mmx/copyd.asm: Likewise. * mpn/x86/k7/mmx/lshift.asm: Avoid using `~' (Solaris as problems). * mpn/x86/k7/mmx/rshift.asm: Likewise. * mpn/x86/k6/aors_n.asm: Likewise. * mpn/x86/k7/aors_n.asm: Likewise. * mpn/x86/k7/mul_basecase.asm: Likewise. 2000-06-13 Torbjorn Granlund * tune/sparcv9.asm: Tune, deleting two instructions. * tune/alpha.asm: Update to unified speed_cyclecounter. 2000-06-11 Kevin Ryde * mpz/tests/reuse.c (FAIL): Add a K&R version. Use _PROTO on some typedefs. * mpz/tests/t-misc.c: Add gmp-impl.h for "const". * configure.in: Rework mpn multi-function and optional files. Names standardized, no need for explicit declarations, all picked up in one $path traversal. * doc/configuration: Updates. * tests/rand/t-rand.c (main): Change "usage" to work with K&R. 2000-06-10 Kevin Ryde * mpn/x86/pentium/mmx/popham.asm, mpn/x86/p6/mmx/popham.asm, mpn/x86/p6/p3mmx/popham.asm, mpn/x86/p6/diveby3.asm: Add MULFUNC_PROLOGUE for correct HAVE_NATIVE_* matching. * mpn/x86/x86-defs.m4 (cmov_bytes_tttn): Use eval() on expressions. (cmov_available_p): Switch to list CPUs which do have cmov. * mpn/x86/p6/sqr_basecase.asm, mpn/x86/k6/sqr_basecase.asm, mpn/x86/k7/sqr_basecase.asm: Use eval() for multiplication. * mpn/x86/README.family: Various updates. 2000-06-09 Kevin Ryde * mpbsd/tests/allfuns.c (main): Call exit() instead of doing return. * doc/tasks.html, doc/projects.html: Moved from projects directory. * doc/multiplication: New file. * Makefile.am (EXTRA_DIST): Remove projects, add doc. * Makefile.am (libgmp_la_LIBADD, libmp_la_LIBADD): Remove unnecessary -lm. * INSTALL: Remove -lm from instructions. * demos/Makefile.am (qcn_LDADD): Add -lm. * tune/*: Add measuring for mpn_divrem_2 and modlimb_invert, improve addsub_n. Switch to unified speed_cyclecounter. * configure.in: Update configs for speed_cyclecounter. * gmp-impl.h (MP_LIMB_T_MAX, MP_LIMB_T_HIGHBIT): New macros. * mpn/generic/diveby3.c, mpn/generic/mul_n.c, mpn/generic/gcd.c, tune/speed.c, mpn/tests/ref.c: Use them. * mpn/tests/spinner.c: Remove setitimer, just alarm is enough. * configure.in (AC_CHECK_FUNCS): Remove setitimer. * mpn/tests/x86call.asm: Start with junk in %eax, %ecx, %edx. * mpn/tests/ref.[ch] (refmpn_addsub_nc): New function. * mpn/tests/try.c: Add some support for mpn_addsub_nc. * mpn/tests/Makefile.am (EXTRA_PROGRAMS): Remove addsub_n and addsub_n_2 which don't currently build. * mpn/tests/copy.c: Test MPN_COPY_INCR, not __gmpn_copy. * tests/rand/Makefile.am (libstat_la_LIBADD): Add -lm, no longer on libgmp.la. (findlc_LDADD): Use libstat.la. (AUTOMAKE_OPTIONS): Use ansi2knr. 2000-06-08 Torbjorn Granlund * configure.in (alpha*-*-osf*): Default `flavour' to ev6 for ev6 and higher. (alpha*-*-*): Likewise. (alpha*-*-osf*: gmp_optcflags_cc): Move -arch/-tune flags from gmp_xoptcflags_gcc. * mpn/Makefile.am (TARG_DIST): Add pa64w. * longlong.h: Wrap 64-bit hppa code in #ifndef LONGLONG_STANDALONE. 2000-06-07 Torbjorn Granlund * mpz/remove.c: Fail for `src' being zero. * mpz/tests/reuse.c: Test more functions. (FAIL): New define. * mpz/tests/t-powm.c: Loop during operand generation while they are mathematically ill-defined (used to just skip such tests). * mpz/powm.c (mpz_redc): Clean up argument declarations. * configure.in (gmp_cflags64_gcc): Don't add bogus -mWHAT option. (sparcv9-*-solaris2.[7-9]], gmp_cflags64_gcc): Inherit from previous gmp_cflags64_gcc; pass `-m64 -mptr64'. (ia64*-*-*): New. * mpn/generic/dump.c: Make it work when an mp_limb_t is not `long'. * mpf/set_prc.c: MPN_COPY => MPN_COPY_INCR. 2000-06-06 Torbjorn Granlund * mpn/generic/mul_n.c (mpn_toom3_mul_n, mpn_toom3_sqr_n): Use mpn_incr_u for final carry propagation. * mpz/tests/t-gcd.c: Add calls to mpz_gcdext with argument t == NULL. * mpz/tests/reuse.c: Major rewrite; test many more functions. * mpz/powm_ui.c: When exp is 0, change res assign order in order to handle argument overlap. * mpz/powm.c: When exp is 0, change res assign order in order to handle argument overlap. Handle negative exp and mod arguments. * mpz/gcdext.c: Rework code after mpn_gcdext call to handle argument overlap. * mpz/fdiv_qr.c: Read dividend->_mp_size before calling mpz_tdiv_qr in order to handle argument overlap. * mpz/cdiv_qr.c: Likewise. * mpf/tests/reuse.c: Fix typo that effectively disabled `dis_funcs' tests. Clean up test for mpf_ui_div. 2000-06-06 Kevin Ryde * mpn/x86/p6/sqr_basecase.asm: New file. * mpn/x86/mod_1.asm: Avoid one conditional jump. * mpn/x86/p6/gmp-mparam.h: Update thresholds, #ifndef UMUL_TIME and UDIV_TIME, add COUNT_TRAILING_ZEROS_TIME. * mp_minv_tab.c: New file. * Makefile.am (libgmp_la_SOURCES, libmp_la_SOURCES): Add it. * gmp-impl.h (modlimb_invert): New macro. * mpz/powm.c: Remove mpz_dmprepare, use modlimb_invert instead. * mpn/generic/bdivmod.c: Use modlimb_invert instead of a loop. * mpn/generic/gcd.c: Inline two small mpn_bdivmod calls, use MPN_COPY_INCR not MPN_COPY in one place. 2000-06-05 Torbjorn Granlund * mpf/tests/reuse.c (dsi_funcs): Add mpf_mul_2exp and mpf_div_2exp. (main): Clean up test for mpf_div_ui. * mpf/mul_2exp.c: Correct criterion for whether to use mpn_lshift or mpn_rshift. MPN_COPY => MPN_COPY_INCR. Coerce the two assignments to r->_mp_size. * mpf/div_2exp.c: Use mpn_rshift instead of mpn_lshift when overlap so requires. MPN_COPY => MPN_COPY_INCR. * mpf/tests/t-dm2exp.c: Correct type of res_prec. 2000-06-04 Kevin Ryde * mpz/bin_uiui.c: Fix result for n==0 and n==k. * mpz/bin_ui.c: Fix result for k>n, add support for n<0. * gmp.texi (Number Theoretic Functions): Update mpz_bin_ui to note n<0 is supported. * mpz/tests/t-misc.c: New file. * mpz/tests/Makefile.am (check_PROGRAMS): Add it. 2000-05-31 Kevin Ryde * tune/speed.* (FLAG_R_OPTIONAL): New option for routines, use on mpn_gcd_1 and mpn_mul_basecase. * tune/README: Update. * tune/alpha.asm: New file, by Torbjorn. * tune/Makefile.am (EXTRA_DIST): Add it. * configure.in (alpha*-*-*): Use it. 2000-05-31 Linus Nordberg * doc/configuration: New file. 2000-05-30 Torbjorn Granlund * mpn/generic/mul_basecase.c: Call mpn_mul_2 and mpn_addmul_2 if available. Don't include longlong.h. * doc/isa_abi_headache: New file. 2000-05-30 Linus Nordberg * configure.in (NM): Use AC_PROG_NM rather than AC_CHECK_TOOL to find `nm'. (AC_PROG_NM comes with Libtool and is needed to get the `-B' option (BSD compatible output) included in $NM.) (AR): Use AC_CHECK_PROG rather than AC_CHECK_TOOL to find `ar'. (Now that NM isn't a cross compilation tool, don't give the impression that we know how to cross compile.) (CCAS): Remove spurious comment. * gmp.texi (Notes for Particular Systems): Remove comment about using GNU `nm' on AIX since system nm now works. 2000-05-29 Torbjorn Granlund * mpn/power/mul_1.s: Remove [PR] from first word in function descriptor. * mpn/power/addmul_1.s: Likewise. * mpn/power/submul_1.s: Likewise. 2000-05-28 Kevin Ryde * configure.in, tune/*: Change pentium rdtsc cycle scheme to HAVE_SPEED_CYCLECOUNTER and SPEED_CYCLECOUNTER_OBJS. * tune/pentium.asm: Renamed and converted from rdtsc.asm. * tune/sparcv9.asm: New file, by Torbjorn. * tune/sparc64.asm: New file. * tune/tuneup.c: Put a limit on gcdext search. * gmp.h (mp_set_memory_functions): Add extern "C". * mp.h (__GNU_MP__): Bump to "3". * mpz/add.c,mul.c,powm.c,sub.c,sqrtrem.c,tdiv_qr.c [BERKELEY_MP]: Include mp.h for mpbsd compile. * mpz/gcd.c: Ditto, and remove _mpz_realloc declaration. * gmp.texi (Integer Functions): Flatten @subsections into @sections. (Floating-point Functions): Ditto. (Integer Random Numbers): Split from miscellaneous as a sep section. (Installing GMP): Make nodes for the sections. Add more "@cindex"s. (Known Build Problems): Remove SunOS get_d problem, believed fixed. (Notes for Particular Systems): Remove HPPA note since now PIC. (References): URL for Jebelean. 2000-05-27 Torbjorn Granlund * mpn/pa64w: New directory, contents based on corresponding mpn/pa64 files. * configure.in (hppa2.0w-*-*): New. * mpz/tests/io.c (_INCLUDE_POSIX_SOURCE): Define when __hpux before including stdio.h. * gmp-impl.h: Always define DItype and UDItype. 2000-05-27 Kevin Ryde * tune/common.c (speed_measure): Correction to array sorting, better diagnostic when measuring fails. * tune/time.c: Add microsecond accurate getrusage method. * tune/time.c (speed_cpu_frequency_processor_info): New function. * configure.in (AC_CHECK_FUNCS): Add processor_info. 2000-05-26 Linus Nordberg * gmp.texi (Installing GMP): Shared libraries work for AIX < 4.3 if using GNU nm. 2000-05-26 Torbjorn Granlund * tune/tuneup.c (SIGNED_TYPE_MAX): Shift `-1' instead of `1' to avoid signed overflow. * demos/pexpr.c (setup_error_handler): Don't call sigaltstack on Unicos. 2000-05-25 Torbjorn Granlund * insert-dbl.c: Work around GCC 2.8 bug. * extract-dbl.c: Likewise. * config.sub: Allow i586, i686, i786 again. * config.guess: Use X86CPU for lots more systems. 2000-05-25 Linus Nordberg * mpbsd/tests/dummy.c (main): Call exit() instead of doing return (some old SysV machines don't get this correct, I've heard.) 2000-05-25 Kevin Ryde * mpf/iset_str.c: Initialize _mp_size and _mp_exp to 0, in case no digits in string, so it's the same as a separate init and set_str. 2000-05-24 Torbjorn Granlund * mpz/tests/reuse.c: Use mpz_random2 instead of mpz_random. * mpz/divexact.c: Read pointers after reallocation. Compare `quot' and `den' instead of `qp' and `dp' in overlap check. Use MPN_COPY_INCR for copying from `np'. (*-*-aix4.[3-9]*): Disable shared libs just for problematic AIX versions. * configure.in (*-cray-unicos*): Disable asm syntax checking; set compiler explicitly. * configure.in (hppa*-*-*): Remove code disabling shared libs. 2000-05-24 Linus Nordberg * acinclude.m4 (GMP_PROG_CC_WORKS): Don't report progress to user when doing the AIX specific test to avoid "nested output". 2000-05-22 Kevin Ryde * mp.h (_PROTO): Copy from gmp.h, use on prototypes. Add extern "C" too. * mpbsd/tests/Makefile.am (AUTOMAKE_OPTIONS): Enable ansi2knr. * mpbsd/tests/allfuns.c: Don't execute mout, just link to it. (main): ANSI style definition. * gmp-impl.h (MP_BASE_AS_DOUBLE): Change the expression to something that works on SunOS native cc. Seems to fix the mp*_get_d problems. * mpn/tests/ref.c (refmpn_strip_twos): Use MPN_COPY_INCR. * mpn/tests/Makefile.am: Let .asm.o rules work with absolute $srcdir. 2000-05-21 Kevin Ryde * mpn/x86/k7/sqr_basecase.asm: Replace file with K7 specific code. * mpn/x86/k7/README: Update. * mpn/x86/k7/gmp-mparam.h: Tune thresholds. (COUNT_TRAILING_ZEROS_TIME): New define. * mpn/x86/k6/gmp-mparam.h: Ditto. * mpn/x86/pentium/mmx/popham.asm: New file (include_mpn of K6 version). * mpn/x86/p6/diveby3.asm: New file (include_mpn of P5 version). * mpn/x86/p6/mmx/popham.asm: New file (include_mpn of K6 version). * mpn/x86/p6/p3mmx/popham.asm: New file (include_mpn of K7 version). * configure.in (pentium3-*-*): Add p3mmx to $path. * gmp.texi (Integer Arithmetic): Clarify mpz_jacobi op2; add mpz_*_kronecker_*. (Miscellaneous Integer Functions): Add mpz_odd_p and mpz_even_p. (Low-level Functions): Put mpn_divmod_1 with mpn_divrem_1 and note it's now a macro. (References): Add Henri Cohen. * gmp.h (mpn_addmul_1c, mpn_divrem_1c, mpn_mod_1c, mpn_mul_1c, mpn_submul_1c): Add prototypes. (mpz_odd_p, mpz_even_p): New macros. * mpn/asm-defs.m4 (m4wrap_prepend): New macro. (m4_error): Use it. (m4_not_for_expansion): Corrections to OPERATION symbols. More comments about variations between m4 versions. * mpn/x86/x86-defs.m4 (PROLOGUE): Use m4wrap_prepend (fixes error exit under BSD m4, previously m4_error printed the message but the exit code was 0). * gmp.h (mpn_divmod_1): Change to a macro calling mpn_divrem_1. * mpn/generic/divrem_1.c: Move divmod_1.c code to here, make it static and call it __gmpn_divmod_1_internal. * mpn/generic/divmod_1.c: Remove file. * configure.in (gmp_mpn_functions): Remove divmod_1. * mpn/asm-defs.m4 (define_mpn): Remove divmod_1 and divmod_1c. * compat.c (mpn_divmod_1): Add compatibility function. * tune/*: Remove mpn_divmod_1 measuring (leave just divrem_1). * acconfig.h (HAVE_NATIVE_mpn_*): Add some missing carry-in variants, remove divmod_1. * mpn/x86/diveby3.asm: Use imul, update comments. * demos/qcn.c: New file. * demos/Makefile.am (EXTRA_PROGRAMS): Add it. * mpz/tests/t-jac.c: New file. * mpz/tests/Makefile.am (check_PROGRAMS): Add it. Enable ansi2knr. * mpz/kronsz.c: New file. * mpz/kronuz.c: New file. * mpz/kronzs.c: New file. * mpz/kronzu.c: New file. * mpz/Makefile.am (libmpz_la_SOURCES): Add them. * Makefile.am (MPZ_OBJECTS): Add them. * gmp-impl.h (JACOBI_*, MPN_STRIP_LOW_ZEROS_NOT_ZERO): New macros. * gmp.h (mpz_*_kronecker_*): New defines and prototypes. * mpn/generic/jacbase.c: New file. * mpn/generic/mod_1_rs.c: New file. * configure.in (gmp_mpn_functions): Add them. * gmp.h (mpn_jacobi_base, mpn_mod_1_rshift): New defines and prototypes. * longlong.h (COUNT_TRAILING_ZEROS_TIME): New define. * mpn/tests/ref.c (refmpn_mod_1_rshift): New function. * mpn/tests/try.c: Add mpn_mod_1_rshift. * tune/*: Add measuring for mpn_jacobi_base. * acinclude.m4 (GMP_FINISH): Add ifdefs to allow multiple inclusion of config.m4. (GMP_PROG_M4): Put "good" message through to config.log. * mpz/powm.c: Use a POWM_THRESHOLD for where redc stops. * tune/*: Add mpz_powm measuring, and tune POWM_THRESHOLD. * gmp-impl.h [TUNE_PROGRAM_BUILD] (POWM_THRESHOLD): Conditional redefinition for use when tuning. * mpz/powm_ui.c: Use DIVIDE_BY_ZERO. * mpz/iset_str.c: Initialize _mp_size to 0, in case no digits in string; this makes it the same as a separate init and set_str. 2000-05-20 Kevin Ryde * mpn/asm-defs.m4: Note &,|,^ aren't bitwise in BSD m4 eval(). * mpn/x86/k6/sqr_basecase.asm: Use "%" not "&" in m4 eval()s. * mpn/x86/x86-defs.m4 (Zdisp): Yet more instruction forms. 2000-05-19 Linus Nordberg * acinclude.m4 (GMP_CHECK_CC_64BIT): Don't use shell variable `ac_compile' for our own compile command string since other Autoconf macros may depend on it. 2000-05-19 Kevin Ryde * mpn/generic/mul_n.c (mpn_toom3_mul_n, mpn_toom3_sqr_n): Fix carry propagation in final coefficient additions. 2000-05-18 Linus Nordberg * configure.in: Set NM before looking for compiler since GMP_CHECK_CC_64BIT needs it. * acinclude.m4 (GMP_CHECK_CC_64BIT): Don't execute on target. (GMP_PROG_CC_FIND): Before checking if the compiler knows how to produce 64-bit code, verify that it works at all. The background is that /usr/ucb/cc on Solaris 7 successfully compiles in 64-bit mode but fails when doing final link. (GMP_PROG_CC_WORKS): Report to user what's happening. 2000-05-17 Linus Nordberg * config.guess: Use X86CPU for x86 Cygwin. 2000-05-16 Kevin Ryde * mpn/x86/p6/mmx/divrem_1.asm: New file. * mpn/x86/p6/mmx/mod_1.asm: New file. * mpn/x86/p6/README: Update. * mpn/x86/divrem_1.asm: Update comments. * mpn/x86/mod_1.asm: Ditto. 2000-05-14 Kevin Ryde * tune/speed.h: Run gcd functions on a set of data. * mpn/tests/try.c: New file. * mpn/tests/try.h: New file. * mpn/tests/spinner.c: New file. * mpn/tests/trace.c: New file. * mpn/tests/x86call.asm: New file. * mpn/tests/x86check.c: New file. * mpn/tests/ref.c (refmpn_hamdist): Allow size==0. (refmpn_gcd): New function, and other additions supporting it. * mpn/tests/ref.h: More prototypes. * mpn/tests/Makefile.am: Add try program, use ansi2knr. * mpn/x86/k7/mmx/popham.asm: New file. * mpn/x86/k6/mmx/popham.asm: New file. * mpn/x86/k6/sqr_basecase.asm: Unroll the addmul, for approx 1.3x speedup above 15 limbs. * mpn/x86/k7/README: Update. * mpn/x86/k6/README: Update, and add notes on plain K6 and pre-CXT K6-2 problems. * configure.in (k6*-*-*, athlon-*-*): Add popham. * mpn/x86/pentium/diveby3.asm: New file. * mpn/x86/pentium/README: Update. * gmp.texi (Installing GMP): Add note on bad OpenBSD 2.6 m4. (Reporting Bugs): Ask for config.m4 if asm file related. (I/O of Rationals): New section, add mpq_out_str. (References): Add url for on-line gcc manuals. A few node and menu updates. * INSTALL: Better command line argument checking for test progs. Change MP -> GMP. * configure.in (WANT_ASSERT, USE_STACK_ALLOC, HAVE_PENTIUM_RDTSC): Put descriptions here, not in acconfig.h. (CALLING_CONVENTIONS_OBJS): New AC_SUBST (for mpn/tests/try). (HAVE_CALLING_CONVENTIONS): New AC_DEFINE. (AC_CHECK_HEADERS): Add sys/time.h. (AC_CHECK_FUNCS): Add getpagesize, setitimer. (KARATSUBA_SQR_THRESHOLD): Strip trailing comments from the #define when passing through to config.m4. * acconfig.h (PACKAGE, VERSION, WANT_ASSERT, USE_STACK_ALLOC, HAVE_PENTIUM_RDTSC): No need for #undefs, autoheader gets them from configure.in. * acinclude.m4 (GMP_PROG_M4): Check for broken OpenBSD 2.6 m4 eval(), put messages into config.log. * mpn/asm-defs.m4: Add notes and test for OpenBSD 2.6 m4. * mpq/out_str.c: New file. * mpq/Makefile.am (libmpq_la_SOURCES): Add it. * Makefile.am (MPQ_OBJECTS): Ditto. * gmp.h (mpq_out_str): New define and prototype. 2000-05-12 Kevin Ryde * configure.in (CONFIG_TOP_SRCDIR): Fix to use $srcdir not $top_srcdir (which doesn't exist). * acinclude.m4 (GMP_C_ANSI2KNR): Fix setting U=_. * gmp-impl.h (mpn_com_n, MPN_LOGOPS_N_INLINE): Fix missing "do" (not currently used, probably no ill effect anyway). 2000-05-11 Torbjorn Granlund * randraw.c (lc): Major overhaul (pending rewrite). (_gmp_rand): Rewrite. 2000-05-08 Torbjorn Granlund * mpz/tests/convert.c: Call free via _mp_free_func. * mpf/tests/t-conv.c: Likewise. * memory.c: Add code enabled for DEBUG that adds special patterns around allocated blocks. 2000-05-05 Linus Nordberg * gmp.texi (Miscellaneous Float Functions): Correct parameter list for mpf_urandomb(). * configure.in: Invoke AC_REVISION. 2000-05-05 Kevin Ryde * gmp.texi: Use @dircategory and @direntry. (Installing GMP): Clarification for --target, updates on SunOS problems. (Integer Arithmetic): Add mpz_mul_si. (Initializing Rationals): Add mpq_swap. (Assigning Floats): Add mpf_swap. (Low-level Functions): Add mpn_divexact_by3c, and details of what the calculation actually gives. (Low-level Functions): Note extra space needed by mpn_gcdext, clarify the details a bit. * compat.c: New file, entry points for upward binary compatibility. (mpn_divexact_by3): Compatibility function. * Makefile.am (libgmp_la_SOURCES): Add compat.c. * mpn/tests/ref.c: Rearrange macros for ansi2knr. (div1): Renamed from div to avoid library function. (refmpn_divexact_by3c, refmpn_gcd_1, refmpn_popcount, refmpn_hamdist): New functions. * mpn/tests/ref.h: Add extern "C", add new prototypes. * gmp.h (gmp_randinit, etc): Add extern "C". (_mpq_cmp_ui): Fix prototype name from mpq_cmp_ui. (mpn_divexact_by3): Now a macro calling mpn_divexact_by3c. (mpn_divexact_by3c): New prototype and define. * mpn/x86/diveby3.asm: Change to mpn_divexact_by3c. * mpn/x86/k6/diveby3.asm: Ditto. * mpn/generic/diveby3.c: Ditto. * mpn/asm-defs.m4: Ditto on the define_mpn. * acconfig.h (HAVE_NATIVE_mpn_divexact_by3c): New define. * mpq/swap.c: New file, derived from mpz/swap.c. * mpf/swap.c: Ditto. * mpq/Makefile.am: Add swap.c. * mpf/Makefile.am: Ditto. * Makefile.am: Add two new "swap.lo"s. * mpn/x86/k6/mmx/com_n.asm: Fix an addressing bug (fortunately this code hasn't been used anywhere yet). * mpn/x86/k7/mmx/divrem_1.asm: New file. * mpn/x86/k7/mmx/mod_1.asm: New file. * mpn/x86/k7/diveby3.asm: New file. * mpn/x86/k7/README: Update. * mpn/x86/k7/aorsmul_1.asm: Use new cmovCC, no object code change. * mpn/x86/k7/mul_basecase.asm: Ditto. * mpn/x86/p6/aorsmul_1.asm: Ditto. * mpn/x86/x86-defs.m4 (defframe_empty_if_zero): Eval the argument. (cmovCC): New macros, replacing individual cmovCC_reg_reg forms. (Zdisp): Recognise more instructions. (shldl,etc): Use m4_instruction_wrapper(). (ASSERT, movl_text_address): New macros. * mpn/asm-defs.m4: Add remarks on SunOS /usr/bin/m4 and new OpenBSD m4. (m4_assert_numargs_internal_check): Remove a spurious parameter. (m4_empty_if_zero): Eval the argument. (m4_assert, m4_assert_numargs_range, m4_config_gmp_mparam, m4_instruction_wrapper): New macros. 2000-05-04 Linus Nordberg * gmp.texi (Reporting Bugs): Be explicit about output from running a command. 2000-05-02 Torbjorn Granlund * mpn/generic/bz_divrem_n.c (mpn_bz_divrem_n): Handle non-zero return from first mpn_bz_div_3_halves_by_2 call. (mpn_bz_divrem_aux): Likewise. 2000-04-30 Kevin Ryde * tune/* (GCD_ACCEL_THRESHOLD, GCDEXT_THRESHOLD): Tune these. * mpn/generic/gcdext.c (GCDEXT_THRESHOLD): Rename from THRESHOLD, use with >=, adjust default to 17 accordingly. Use new *_SWAP macros. * mpn/generic/gcd.c (GCD_ACCEL_THRESHOLD): Rename from ACCEL_THRESHOLD, use with >=, adjust default to 5 accordingly. Use new *_SWAP macros. * mpf/get_str.c, mpf/set_str.c, mpf/sub.c, mpz/add.c, mpz/ior.c, mpz/and.c, mpz/sub.c, mpz/xor.c, mpz/ui_pow_ui.c, mpn/generic/mul.c: Use new *_SWAP macros. * stack-alloc.h: Add extern "C" around prototypes. * gmp-impl.h: (MP_PTR_SWAP, etc): New macros. (_mp_allocate_func, etc): Use _PROTO. [TUNE_PROGRAM_BUILD]: More changes in tune program build part. 2000-04-28 Torbjorn Granlund * mpn/pa64/add_n.s: Add `,entry' to export directive. * mpn/pa64/addmul_1.S, mpn/pa64/lshift.s, mpn/pa64/mul_1.S, mpn/pa64/rshift.s, mpn/pa64/sub_n.s, mpn/pa64/submul_1.S, mpn/pa64/umul_ppmm.S: Likewise. * mpn/hppa/hppa1_1/udiv_qrnnd.S: New name for udiv_qrnnd.s. Add PIC support. 2000-04-29 Kevin Ryde * gmp-impl.h [TUNE_PROGRAM_BUILD] (TOOM3_MUL_THRESHOLD_LIMIT): New define. * mpn/generic/mul_n.c [TUNE_PROGRAM_BUILD] (mpn_mul_n): Use TOOM3_MUL_THRESHOLD_LIMIT, not a hard coded 500. * memory.c: Use for malloc etc, and use _PROTO. * stack-alloc.c: Don't use C++ reserved word "this". * urandom.h: Put extern "C" around prototypes. * mpz/powm.c: Switch a couple of parameters to "const", which they are, to satisfy g++. * randraw.c, stack-alloc.c, mpbsd/mout.c, mpbsd/mtox.c: Add casts to help g++. * stack-alloc.c: Provide dual ANSI/K&R function definitions. * mpz/addmul_ui.c,get_d.c,inp_str.c,perfpow.c,powm.c,pprime_p.c, rrandomb.c,set_str.c,ui_pow_ui.c: Ditto. * mpf/integer.c,set_str.c: Ditto. * mpbsd/min.c,xtom.c: Ditto. * mpn/generic/bz_divrem_n.c,dump.c,gcd_1.c,get_str.c,hamdist.c, popcount.c,random.c,random2.c,set_str.c: Ditto. * rand.c: Use for NULL. * mpz/gcd_ui.c,gcdext.c,mul.c,perfpow.c,powm_ui.c,root.c,sqrt.c, sqrtrem.c: Ditto * mpf/sqrt.c,sqrt_ui.c: Ditto. * mpn/generic/perfsqr.c,sqrtrem.c: Ditto. * gmp-impl.h (NULL, malloc, realloc, free): Don't define/declare. (extern "C"): Add around function prototypes. (mpn_kara_mul_n, mpn_kara_sqr_n, mpn_toom3_mul_n, mpn_toom3_sqr_n): Add prototypes. [TUNE_PROGRAM_BUILD] (FIB_THRESHOLD): Add necessary redefinitions for use by tune program. * mpn/generic/mul_n.c: Remove mpn_toom3_mul_n prototype. * acinclude.m4 (GMP_C_ANSI2KNR): New macro. (GMP_CHECK_ASM_MMX, GMP_CHECK_ASM_SHLDL_CL): Fix to use $gmp_cv_check_asm_text which is what GMP_CHECK_ASM_TEXT sets. * configure.in (GMP_C_ANSI2KNR): Use this instead of AM_C_PROTOTYPES, for reasons described with its definition. * demos/Makefile.am (ansi2knr): Use $(top_builddir) nor $(top_srcdir). * mpz/fib_ui.c (FIB_THRESHOLD): Rename from FIB_THRES, for consistency. (FIB_THRESHOLD): Conditionalize so gmp-mparam.h can define a value. (mpz_fib_bigcase): Use >= FIB_THRESHOLD, same as main mpz_fib_ui. * tune/tuneup.c,Makefile.am (FIB_THRESHOLD): Tune this. * configure.in (*-*-aix* gmp_m4postinc): Fix setting (don't overwrite a value just stored). 2000-04-26 Kevin Ryde * mpn/sparc32/udiv_fp.asm: Use mpn_udiv_qrnnd macro. * mpn/sparc32/udiv_nfp.asm: Ditto. * mpn/sparc32/v8/supersparc/udiv.asm: Ditto. * mpn/sparc32/umul.asm: Name the function mpn_umul_ppmm. * mpn/sparc32/v8/umul.asm: Ditto. * mpn/powerpc32/umul.asm: Ditto. * mpn/x86/syntax.h: Remove file, since now unused. * configure.in (x86): Remove -DBROKEN_ALIGN and -DOLD_GAS previously used by .S files. (x86 extra_functions): Add udiv and umul. (GMP_PROG_M4): Use this instead of AC_CHECK_PROG(M4,m4,...) (HAVE_NATIVE_*): Loosen up the regexp to "PROLOGUE.*" so as to accept PROLOGUE_GP on alpha. * acconfig.h (HAVE_NATIVE_mpn_umul_ppmm, udiv_qrnnd, invert_limb): New template defines. * mpn/asm-defs.m4 (mpn_umul_ppmm, mpn_udiv_qrnnd): New define_mpn()s. * longlong.h (umul_ppmm, udiv_qrnnd): Use a library version if it's available and an asm macro isn't. * gmp-impl.h (invert_limb): Ditto. * gmp-impl.h (ASSERT_NOREALLOC): Not a good idea, remove it. * acinclude.m4 (GMP_PROG_M4): New macro. 2000-04-25 Linus Nordberg * gmp.texi (Random State Initialization): Correct arguments to `gmp_randinit'. * acinclude.m4 (GMP_VERSION): Change `eval' --> `m4_eval'. Fix from Kevin. * aclocal.m4: Regenerate. 2000-04-25 Kevin Ryde * mpn/x86/aors_n.asm: Remove parentheses around an immediate that Solaris "as" doesn't like, change by Torbjorn. 2000-04-24 Kevin Ryde * configure.in (AC_CHECK_FUNCS): Add strtoul. * mpn/generic/mul_n.c [TUNE_PROGRAM_BUILD] (mpn_mul_n): Bigger array for karatsuba temporary space for tune program build. (mpn_toom3_sqr_n) Remove an unused variable. * demos/Makefile.am (AUTOMAKE_OPTIONS): Add ansi2knr. Add "allprogs:" pseudo-target. * demos/factorize.c, demos/isprime.c: Switch to ANSI functions, rely on ansi2knr. * gmp.texi (Getting the Latest Version of GMP): Add reference to ftp.gnu.org mirrors list. * INSTALL: Add arg count check to example programs. * mpn/x86/*/*.asm: Convert to FORTRAN ... or rather to FORTRAN-style "C" commenting to support Solaris "as". * mpn/x86/x86-defs.m4: Ditto, and add another Zdisp insn. * mpn/asm-defs.m4 (C): Update comments. * mpn/x86/README.family: Add a note on commenting, remove description of .S files. * mpn/sparc64/addmul_1.asm, mul_1.asm, submul_1.asm: Use include_mpn(). 2000-04-23 Torbjorn Granlund * config.sub: Merge with FSF version of April 23. * mpn/powerpc32: Use dnl/C instead of `#' for comments. * config.guess: Get "model" limit between pentium 2 and pentium3 right. Get rid of code determining `_' prefix; use double labels instead. * config.guess: Partially merge with FSF version of April 22. (Don't bring over NetBSD changes for now.) 2000-04-23 Kevin Ryde * tune/Makefile.am, tune/README, tune/common.c, tune/rdtsc.asm, tune/speed.c, tune/speed.h, tune/time.c, tune/tuneup.c: New files. * tune/Makefile.in: New file, generated from Makefile.am. * gmp-impl.h (ASSERT_NOREALLOC,TMP_ALLOC_LIMBS): New macros. [TUNE_PROGRAM_BUILD] Further mods for tune program builds. * mpz/Makefile.am: Add -DOPERATION_$* for new mul_siui.c. Add rules to build mul_si and mul_ui from a common mul_siui.c. * mpz/mul_siui.c: New file, derived from and replacing mul_ui.c. * gmp.h (mpz_mul_si): New prototype and define. * mpn/tests/*.c [__i386__] (CLOCK): Don't use floating point in CLOCK because cpp can't handle floats in #if's (TIMES is derived from CLOCK by default). * mpn/asm-defs.m4 (include_mpn): New macro. (m4_assert_numargs) Changes to implementation. * mpf/Makefile.am: Add -DOPERATION_$* for new integer.c. Remove explicit rules for floor.o etc. * mpf/integer.c: Use OPERATION_$* for floor/ceil/trunc. * mpn/Makefile.am: Put "tests" in SUBDIRS. * mpn/tests/Makefile.am: New file providing rules to build test programs, nothing done in a "make all" or "make check" though. * mpn/tests/README: New file. * acconfig.h (HAVE_PENTIUM_RDTSC): New define. * configure.in (x86): Rearrange target cases. Add mulfunc aors_n and aorsmul_1 for x86 and pentium (now all x86s). Remove asm-syntax.h generation not needed. Remove now unused family=x86. (sparc) Remove unused family=sparc. (HAVE_PENTIUM_RDTSC) New AC_DEFINE and AM_CONDITIONAL. (AM_C_PROTOTYPES) New test, supporting ansi2knr. (AC_CHECK_HEADERS) Add getopt.h, unistd.h and sys/sysctl.h for tune progs. (AC_CHECK_FUNCS) Add getopt_long, sysconf and sysctlbyname for tune progs. (config.m4 CONFIG_TOP_SRCDIR) Renamed from CONFIG_SRCDIR. (config.m4 asm-defs.m4) Use CONFIG_TOP_SRCDIR and include(). (gmp_m4postinc) Use include_mpn(). (gmp_links) Omit asm-defs.m4/asm.m4 and gmp_m4postinc's. (MULFUNC_PROLOGUE) Fix regexps so all functions get AC_DEFINE'd. (PROLOGUE) Ditto (native copyi and copyd were unused in gmp 3). (KARATSUBA_SQR_THRESHOLD) Copy from gmp-mparam.h into config.m4. (AC_OUTPUT) Add tune/Makefile, mpn/tests/Makefile. * Makefile.am (AUTOMAKE_OPTIONS): Add ansi2knr. (SUBDIRS): Add tune, reorder directories. (MPZ_OBJECTS): Add mpz/mul_si.lo. (libmp_la_SOURCES): Use this for top-level objects, not .lo's. * ansi2knr.c, ansi2knr.1: New files, provided by automake. * mpn/x86/aors_n.asm: Convert add_n.S and sub_n.S to a multi-function aors_n.asm, no object code change. * mpn/x86/pentium/aors_n.asm: Ditto. * mpn/x86/aorsmul_1.asm: Ditto for addmul/submul. * mpn/x86/pentium/aorsmul_1.asm: Ditto. * mpn/x86/lshift.asm, mpn/x86/mul_1.asm, mpn/x86/mul_basecase.asm, mpn/x86/rshift.asm: Convert from .S, no object code change. * mpn/x86/pentium/lshift.asm, mpn/x86/pentium/mul_1.asm, mpn/x86/pentium/mul_basecase.asm, mpn/x86/pentium/rshift.asm: Ditto. * gmp.texi (Reporting Bugs): Itemize the list of things to include. (Miscellaneous Float Functions): Correct typo in mpf_ceil etc argument types. Change @ifinfo -> @ifnottex for benefit of makeinfo --html. Remove unnecessary @iftex's around @tex. 2000-04-22 Torbjorn Granlund * config.guess: Generalize x86 cpu determination code. Now works on Solaris. * mpz/nextprime.c: Rewrite still disabled code. * configure.in: Specifically match freebsd[3-9]. 2000-04-21 Torbjorn Granlund * rand.c: Call mpz_clear for otherwise leaking mpz_t. * mpz/pprime_p.c (mpz_probab_prime_p): Merge handling of negative n into code for handling small positive n. Merge variables m and n. After dividing, simply call mpz_millerrabin. (isprime): Local variables now use attribute `long'. (mpz_millerrabin): New static function, based on code from mpz_probab_prime_p. (millerrabin): Now simple workhorse for mpz_millerrabin. 2000-04-19 Torbjorn Granlund * gmp-impl.h: Fix parenthesis error in test for __APPLE_CC__. 2000-04-18 Linus Nordberg * NEWS: Add info about shared libraries. Remove reference to gmp_randinit_lc. 2000-04-17 Torbjorn Granlund * Version 3.0 released. * mpn/arm/add_n.S: New version from Robert Harley. * mpn/arm/addmul_1.S: Likewise. * mpn/arm/mul_1.S: Likewise. * mpn/arm/sub_n.S: Likewise. * gmp.h (__GNU_MP_VERSION_PATCHLEVEL): Now 0. 2000-04-17 Linus Nordberg * configure.in (hppa2.0*-*-*): Pass `+O3' to cc/c89 in 64-bit mode to avoid compiler bug. (ns32k*-*-*): Fix typo in path. Change by Kevin. (alpha*-*-osf*): New case. Pass assembly flags for architecture to gcc. (alpha*-*-*): Don't bother searching for cc. * configure: Regenerate. * Makefile.am (EXTRA_DIST): Add `macos', `.gdbinit'. * Makefile.in: Regenerate. * mpn/Makefile.am (EXTRA_DIST): Add `m88k', `lisp'. * mpn/Makefile.in: Regenerate. 2000-04-16 Kevin Ryde * README: Updates, and don't duplicate the example in INSTALL. * INSTALL: Minor updates. * gmp.texi (Installing MP): Minor edits, restore CC/CFLAGS description. 2000-04-16 Linus Nordberg * configure.in (*-*-cygwin*): Select BSD_SYNTAX to avoid .type/.size in PROLOGUE for ELF_SYNTAX. Override ALIGN definition from x86/syntax.h. (gmp_xoptcflags_${CC}): New set of variables, indicating ``exclusive optional cflags''. (most sparcs): Use gmp_xoptcflags instead of gmp_optcflags to ensure that we pass CPU type to older gcc. (CFLAGS): CFLAGS on the command line was spoiled. * configure: Regenerate. 2000-04-16 Linus Nordberg * configure.in: Invoke AC_PROG_LIBTOOL directly. * acinclude.m4 (GMP_PROG_CC_FIND): Quote source variable when setting CC64 and CFLAGS64. (GMP_PROG_CC_SELECT): Cache result. (GMP_PROG_LIBTOOL): Remove. * aclocal.m4: Regenerate. * configure: Regenerate. 2000-04-16 Linus Nordberg * tests/rand/t-rand.c (main): Add non-ANSI function declaration. Don't use `const'. 2000-04-16 Torbjorn Granlund * mpn/generic/dump.c: Suppress output of leadign zeros. * mpz/inp_str.c: Fix memory leakage. * mpz/tests/reuse.c (dss_func_division): Add a final 1. * longlong.h (alpha count_leading_zeros): Wrap in __MPN. * mpn/alpha/cntlz.asm: Use __gmpn prefix (by means of __MPN). * longlong.h (__umul_ppmm, __udiv_qrnnd): Wrap in __MPN. * mpn/alpha/udiv_qrnnd.S: Use __gmpn prefix. * mpn/hppa/udiv_qrnnd.s: Likewise. * mpn/hppa/hppa1_1/udiv_qrnnd.s: Likewise. * mpn/pa64/udiv_qrnnd.c: Likewise (by means of __MPN). * mpn/pa64/umul_ppmm.S: Likewise. * mpn/sparc32/udiv_fp.asm: Likewise (by means of MPN). * mpn/sparc32/udiv_nfp.asm: Likewise (by means of MPN). * mpn/sparc32/v8/supersparc/udiv.asm: Likewise (by means of MPN). * mpn/generic/tdiv_qr.c: Work around gcc 2.7.2.3 i386 register handling bug. * mpn/generic/tdiv_qr.c: Use udiv_qrnnd instead of mpn_divrem_1 when computing appropriate quotient; mpn_divrem_1 writes too many quotient limbs. * mpn/asm-defs.m4: invert_normalized_limb => invert_limb. * mpn/alpha/invert_limb.asm: mpn_invert_normalized_limb => mpn_invert_limb. * gmp.h: Likewise. * gmp-impl.h (alpha specific): invert_normalized_limb => invert_limb; wrap with __MPN. * longlong.h (alpha udiv_qrnnd): Likewise. 2000-04-16 Kevin Ryde * gmp.h (mp_set_memory_functions,mp_bits_per_limb,gmp_errno): Add #defines so the library symbols are __gmp_*. * errno.c: Include gmp.h. * gmp-impl.h (_mp_allocate_func,etc): Add #defines to __gmp_*. (__clz_tab): New #define to __MPN(clz_tab). * stack-alloc.c (__gmp_allocate_func,etc): Change from _mp_*. * Makefile.am (libmp_la_DEPENDENCIES): Add some mpz files needed for new mpz_powm (pow in libmp). (EXTRA_DIST): Add projects directory. * mpn/*: Change __mpn to __gmpn. * gmp.h (__MPN): Ditto. * stack_alloc.c,stack-alloc.h: Change __tmp to __gmp_tmp. * mpn/generic/sb_divrem_mn.c (mpn_sb_divrem_mn): Avoid gcc 2.7.2.3 i386 register handling bug (same as previously in mpn_divrem_classic). * mpn/generic/divrem.c: Now contains mpn_divrem, which is not an internal function, so remove warning comment. * gmp.texi (Compatibility with Version 2.0.x): Source level only. 2000-04-16 Linus Nordberg * configure.in (hppa1.0*): Prefer c89 to cc. * configure: Regenerate. 2000-04-15 Linus Nordberg * configure.in: If `mpn_path' is set by user on configure command line, use that as path. * configure: Regenerate. 2000-04-15 Linus Nordberg * configure.in (hppa2.0*): Use path "hppa/hppa1_1 hppa" if no 64-bit compiler was found. * configure: Regenerate. 2000-04-15 Linus Nordberg * configure.in: Honor `CC' and `CFLAGS' set by user on configure command line. * acinclude.m4: (GMP_PROG_CC_SELECT): Set CFLAGS if not set already. * aclocal.m4: Regenerate. * configure: Regenerate. 2000-04-15 Linus Nordberg * acinclude.m4 (GMP_PROG_CC_FIND): Remove debug output. Remove commented out code. * aclocal.m4: Regenerate. * configure: Regenerate. * configure.in: Make all `-mcpu' options to gcc optional. * configure: Regenerate. * tests/rand/Makefile.am: Don't do anything for target 'all'. * tests/rand/Makefile.in: Regenerate. 2000-04-15 Kevin Ryde * README: Small updates. * NEWS: Add some things about 3.0. * mpz/Makefile.am (EXTRA_DIST): Remove dmincl.c. * Makefile.am: Use -version-info on libraries, not -release. * mpz/tdiv_qr.c: Add mdiv function header #ifdef BERKELEY_MP. * mpbsd/Makefile.am: Use mpz/tdiv_qr.c, not mdiv.c. * Makefile.am (MPBSD_OBJECTS): Change mdiv.lo to tdiv_qr.lo. (libmp_la_DEPENDENCIES): Add mp_clz_tab.lo. * mpbsd/mdiv.c: Remove file. * config/mt-linux,mt-m68k,mt-m88110,mt-ppc,mt-ppc64-aix,mt-pwr, mt-sprc8-gcc,mt-sprc9-gcc,mt-supspc-gcc,mt-vax,mt-x86, mpn/config/mt-pa2hpux,mt-sprc9,t-oldgas,t-ppc-aix,t-pwr-aix: Remove configure fragments not used since change to autoconf. * mpn/generic/bz_divrem_n.c,sb_divrem_mn.c: Add comment that internal functions are changeable and shouldn't be used directly. 2000-04-15 Linus Nordberg * configure.in: Remove debug output. * configure: Regenerate. 2000-04-15 Torbjorn Granlund * mpn/generic/tdiv_qr.c: Don't use alloca directly. * mpz/tdiv_qr.c: Fix typo. * mpz/tdiv_r.c: Fix typo. * mpz/tdiv_q.c: Fix typo. * configure.in: Disable -march=pentiumpro due to apparent compiler problems. * mpz/powm.c: Replace with new code from Paul Zimmermann. * mpz/tdiv_q.c: Remove debug code. * mpn/generic/divrem.c: Remove C++ style `//' commented-out code. * mpn/generic/sb_divrem_mn.c: Likewise. 2000-04-14 Torbjorn Granlund * mpz/cdiv_q.c: Change temp allocation for new requirements of mpz_tdiv_qr. * mpz/fdiv_q.c: Likewise. * mpn/sparc64/gmp-mparam.h: Set up parameters for TOOM3. * mpz/dmincl.c: Delete file. * mpz/tdiv_qr.c: Rewrite using mpn_tdiv_qr. * mpz/tdiv_r.c: Likewise. * mpz/tdiv_q.c: Likewise. * mpn/generic/tdiv_qr.c: New file. * mpn/generic/bz_divrem_n.c: New file. * mpn/generic/sb_divrem_mn.c: New file. * gmp-impl.h (MPZ_REALLOC): New macro. (mpn_sb_divrem_mn): Declare. (mpn_bz_divrem_n): Declare. (mpn_tdiv_qr): Declare. * configure.in (gmp_mpn_functions): Delete divrem_newt and divrem_1n; add tdiv_qr, bz_divrem_n, and sb_divrem_mn. * mpn/generic/divrem_newt.c: Delete file. * mpn/generic/divrem_1n.c: Delete file. * gmp.h (mpn_divrem_newton): Remove declaration. (mpn_divrem_classic): Remove declaration. * gmp.h (mpn_divrem): Remove function definition. * mpn/generic/divrem.c: Replace mpn_divrem_classic with a mpn_divrem wrapper. 2000-04-14 Kevin Ryde * mpf/dump.c, mpz/dump.c, mpn/generic/dump.c, mpn/generic/divrem.c, mpn/generic/divrem_1n.c, mpn/generic/divrem_2.c, mpn/generic/divrem_newt.c, mpn/generic/mul.c, mpn/generic/mul_basecase.c, mpn/generic/mul_n.c, mpn/generic/sqr_basecase.c, mpn/generic/udiv_w_sdiv.c: Add comment that internal functions are changeable and shouldn't be used directly. * mpq/div.c: Use DIVIDE_BY_ZERO (previously didn't get an exception on zero divisor). * mpf/tests/t-get_d.c, mpz/tests/reuse.c: Add K&R function definitions. * mpz/tests/t-2exp.c: Don't use ANSI-ism 2ul. * gmp.texi (Installing MP): Build problem notes for GSYM_PREFIX and ranlib on native SunOS. Particular systems notes about AIX and HPPA shared libraries disabled. (MP Basics): Add that undocumented things shouldn't be used. (Introduction to MP): Add to CPUs listed. * acinclude.m4 (GMP_CHECK_ASM_UNDERSCORE): Don't depend on C having "void". 2000-04-13 Linus Nordberg * mpn/pa64/udiv_qrnnd.c (__udiv_qrnnd64): Add K&R function definition. * configure.in: Disable shared libraries for hppa*. (mips-sgi-irix6.*): Fix flags for 64-bit gcc. (hppa2.0*-*-*): Prefer c89 to cc. * configure: Regenerate. * gmp.h (gmp_randalg_t): Remove comma after last element. * tests/rand/t-rand.c: Add copyright notice. 2000-04-13 Kevin Ryde * mpn/generic/mul_n.c, mpn/generic/gcdext.c, mpz/nextprime.c, mpz/remove.c, mpz/root.c: Add K&R function definitions. * mpz/rrandomb.c: Fix typo in K&R part. * stack-alloc.c: Add K&R style function pointer declarations. * mpz/root.c: Use SQRT_OF_NEGATIVE on even roots of negatives. Use DIVIDE_BY_ZERO on a "zero'th" root. * configure: Regenerate with autoconf backpatched to fix --srcdir absolute path wildcards that bash doesn't like, change by Linus. * gmp.texi (Integer Arithmetic): Document mpz_nextprime. (Miscellaneous Integer Functions): Fix mpz_fits_* formatting. (Installing MP): Comment-out CC and CFLAGS description. 2000-04-13 Linus Nordberg * rand.c (gmp_randinit): Don't combine va_alist with ordinary arguments for non STDC. 2000-04-13 Torbjorn Granlund * mpz/nextprime.c: Use proper names of new random types and functions. * mpz/rrandomb.c: New file. * mpz/Makefile.am: List it. * mpz/Makefile.in: Regenerate. * Makefile.am: Here too. * Makefile.in: Regenerate. * gmp.h: Declare mpz_rrandomb. 2000-04-12 Linus Nordberg * Makefile.am, demos/Makefile.am, mpbsd/Makefile.am, mpbsd/tests/Makefile.am, mpf/Makefile.am, mpf/tests/Makefile.am, mpn/Makefile.am, mpq/Makefile.am, mpq/tests/Makefile.am, mpz/Makefile.am, mpz/tests/Makefile.am, tests/Makefile.am, tests/rand/Makefile.am (AUTOMAKE_OPTIONS): Add 'no-dependencies'. * Makefile.in, demos/Makefile.in, mpbsd/Makefile.in, mpbsd/tests/Makefile.in, mpf/Makefile.in, mpf/tests/Makefile.in, mpn/Makefile.in, mpq/Makefile.in, mpq/tests/Makefile.in, mpz/Makefile.in, mpz/tests/Makefile.in, tests/Makefile.in, tests/rand/Makefile.in: Regenerate. 2000-04-12 Linus Nordberg * randlc.c (gmp_randinit_lc): Disable function. * gmp.texi (Random State Initialization): Remove gmp_randinit_lc. * acinclude.m4 (GMP_CHECK_CC_64BIT): Compiling an empty main successfully with `-n32' will have to suffice on irix6. * aclocal.m4: Regenerate. * configure.in (sparc): Don't pass -D_LONG_LONG_LIMB to compiler. (mips-sgi-irix6.*): Use compiler option `-n32' rather than `-64' for 64-bit `cc'. Add options for gcc. * configure: Regenerate. * mpf/urandomb.c (mpf_urandomb): Add third parameter 'nbits'. If 'nbits' doesn't make even limbs, shift up result before normalizing. * gmp.h (mpf_urandomb): Add parameter to prototype. * mpf/urandom.c: Rename file to ... * mpf/urandomb.c: ... this. * Makefile.am (MPF_OBJECTS): Change urandom.lo --> urandomb.lo. * Makefile.in: Regenerate. * mpf/Makefile.am (libmpf_la_SOURCES): Change urandom.c --> urandomb.c. * mpf/Makefile.in: Regenerate. * config.in: Regenerate for HAVE_DECL_OPTARG. * randraw.c (_gmp_rand): Fix bug with _LONG_LONG_LIMB. (lc): Change return type. Use one temporary storage instead of two. Handle seed of size 0. Avoid modulus operation in some cases. Abort if M is not a power of 2. Fix bug with 64-bit limbs. Fix bug with small seed, small A and large M. * tests/rand/gen.c (main): Include gmp.h. Remove macros MIN, MAX. Add option '-q'. Don't demand argument N. Change parameters in call to mpf_urandomb. * tests/rand/t-rand.c: New file for testing random number generation. * tests/rand/Makefile.am: Run t-rand for 'make check'. (test, bigtest): Rename to manual-test, manual-bigtest. * tests/rand/Makefile.in: Regenerate. 2000-04-12 Kevin Ryde * gmp-impl.h: Include config.h before TMP_ALLOC, so --disable-alloca works. * mpbsd/Makefile.am: Don't recompile top-level sources here. * Makefile.am (libmp_la_DEPENDENCIES): Put objects here instead, add errno.lo and stack-alloc.lo. * mpn/asm-defs.m4: Add a test and message for the unsuitable SunOS m4. * gmp.texi (Installing MP): Update note on SunOS m4 failure. * acconfig.h: Add copyright notice using @TOP@. * stack-alloc.c: Use _mp_allocate_func, not malloc. * gmp.texi (Installing MP): Note this under --disable-alloca. * gmp.texi (Comparison Functions): mpz_cmp_abs => mpz_cmpabs. (Integer Arithmetic): mpz_prime_p not yet implemented, comment out. (Float Arithmetic): mpf_pow_ui now implemented, uncomment-out. (Miscellaneous Float Functions): Add mpf_ceil, mpf_floor, mpf_trunc. (Low-level Functions): Add mpn_random2, with mpn_random. * mpn/m68k/mc68020/udiv.S: Rename from udiv.s. * mpn/m68k/mc68020/umul.S: Ditto. * mpn/alpha/umul.asm: Rename from umul.s, remove .file and compiler identifiers. * mpn/powerpc32/syntax.h: Removed, no longer used. * mpn/a29k/udiv.s: Remove .file and compiler identifiers. * mpn/a29k/umul.s: Ditto. * mpn/tests/ref.c: Use WANT_ASSERT. * mpn/tests/ref.h: Use _PROTO. * mpbsd/configure.in: Removed, no longer required. * mpf/div.c: Use DIVIDE_BY_ZERO. * mpf/div_ui.c: Ditto. * mpf/ui_div.c: Ditto. * mpq/inv.c: Ditto. * mpf/sqrt.c: Use SQRT_OF_NEGATIVE. * mpz/sqrt.c: Ditto. * mpz/sqrtrem.c: Ditto. * gmp-impl.h (GMP_ERROR,SQRT_OF_NEGATIVE): New macros. (DIVIDE_BY_ZERO): Use GMP_ERROR. (__mp_bases): #define to __MPN(mp_bases). 2000-04-11 Linus Nordberg * tests/rand/stat.c (main): Initialize `l1runs' at declaration. 2000-04-11 Kevin Ryde * mpz/fib_ui.c: Add K&R function definitions. * mpbsd/tests/Makefile.am (TESTS): Add a dummy test to avoid a shell problem with an empty "for tst in $(TESTS) ; ...". * mpbsd/tests/dummy.c: New file. 2000-04-10 Torbjorn Granlund * mpz/bin_uiui.c: Delete several unused variables. Add copyright notice. * mpz/bin_ui.c: Add copyright notice. * longlong.h: Declare __count_leading_zeros for alpha. 2000-04-10 Linus Nordberg * rand.c (gmp_randinit): Change parameter list to (rstate, alg, ...). * gmp.h: Change prototype accordingly. * mpz/pprime_p.c (millerrabin): Change call accordingly. * configure.in: Check for `optarg'. * configure: Regenerate. * mpn/Makefile.am: Remove incorrect comment. * mpn/Makefile.in: Regenerate. * gmp.h: Rename most of the random number functions, structs and some of the struct members. * rand.c (gmp_randinit): Likewise. * randclr.c (gmp_randclear): Likewise. * randlc.c (gmp_randinit_lc): Likewise. * randlc2x.c (gmp_randinit_lc_2exp): Likewise. * randraw.c (lc): Likewise. (_gmp_rand_getraw): Likewise. * randsd.c (gmp_randseed): Likewise. * randsdui.c (gmp_randseed_ui): Likewise. * gmp.texi: Likewise. * gmp.texi: Use three hyphens for a dash. (Low-level Functions): Remove documentation for gmp_rand_getraw. (Random Number Functions): Add info on where to find documentation on the random number functions. * tests/rand/Makefile.am (test, bigtest): Quote argument to grep. * tests/rand/Makefile.in: Regenerate. * tests/rand/gen.c: Declare optarg, optind, opterr if not already declared. (main): Use new names for the random stuff. (main): Don't use strtoul() if we don't have it. Use strtol() instead, if we have it. Otherwise, use atoi(). (main): Use srandom/srandomdev for __FreeBSD__ only. (main): Use new parameter order to gmp_randinit(). * tests/rand/stat.c: Declare optarg, optind, opterr if not already declared. 2000-04-10 Torbjorn Granlund * mpz/pprime_p.c: Pass 0L for mpz_scan1. mpz_mmod => mpz_mod. (millerrabin): Use new random interface. (millerrabin): ... and don't forget to call gmp_randclear. * mpz/nextprime.c: New file. * gmp.h: Declare mpz_nextprime. * mpz/Makefile.am: List nextprime.c. * mpz/Makefile.in: Regenerate. * Makefile.am: List mpz/nextprime.lo. * Makefile.in: Regenerate. 2000-04-10 Kevin Ryde * move-if-change, mpz/tests/move-if-change, mpq/tests/move-if-change, mpf/tests/move-if-change: Remove, no longer used. * Makefile.am (SUBDIRS): Add tests, demos, mpbsd. (libmp.la): New target, conditional on WANT_MPBSD. (libgmp_la_LIBADD): Add -lm. (AUTOMAKE_OPTIONS): Add check-news. (include_HEADERS): Setup to install gmp.h and possibly mp.h. (DISTCLEANFILES): Add generated files. (check): Remove explicit target (now uses check-recursive). * configure.in: Use AM_CONFIG_HEADER. Add --enable-mpbsd setting automake conditional WANT_MPBSD. Output demos/Makefile, mpbsd/Makefile and mpbsd/tests/Makefile. * mpz/Makefile.am: Add SUBDIRS=tests, shorten INCLUDES since now using AM_CONFIG_HEADER. * mpq/Makefile.am: Ditto. * mpf/Makefile.am: Ditto, and add DISTCLEANFILES. * mpn/Makefile.am: Shorten INCLUDES, amend some comments. * mpz/tests/Makefile.am: Use TESTS and $(top_builddir). * mpf/tests/Makefile.am: Ditto. * mpq/tests/Makefile.am: Ditto. * demos/Makefile.am: New file. * mpbsd/Makefile.am: New file, derived from old mpbsd/Makefile.in. * mpbsd/Makefile.in: Now generated from Makefile.am. * mpbsd/realloc.c: Removed, use mpz/realloc.c instead. * mpbsd/tests/Makefile.am: New file. * mpbsd/tests/Makefile.in: New file, generated from Makefile.am. * mpbsd/tests/allfuns.c: New file. * gmp.texi (Top): Use @ifnottex, to help makeinfo --html. (Installing MP): Describe --enable-mpbsd and demo programs. * tests/rand/statlib.c: mpz_cmp_abs => mpz_cmpabs. * tests/rand/Makefile.am (LDADD): Don't need -lm (now in libgmp.la). (EXTRA_PROGRAMS): Not noinst_PROGRAMS. (INCLUDES): Shorten to -I$(top_srcdir) now using AM_CONFIG_HEADER. 2000-04-09 Torbjorn Granlund * mpz/urandomm.c: Get type of count right. Simplify computation of nbits. 2000-04-08 Torbjorn Granlund * mpz/urandomb.c: Fix reallocation condition. Simplify size computation. 2000-04-08 Linus Nordberg * acinclude.m4 (GMP_CHECK_CC_64BIT): Add special handling for HPUX. (GMP_CHECK_ASM_W32): Ditto. * aclocal.m4: Regenerate. * mpn/Makefile.am: Use $(CCAS) for assembling. (.asm.obj): Add rule. * mpn/Makefile.in: Regenerate. * gmp.texi (Miscellaneous Integer Functions): Fix typos. * configure.in: Never pass `-h' to grep. (mips-sgi-irix6.[2-9]*): Try to find 64-bit compiler. (hppa1.0*-*-*): New flag for cc. (hppa2.0*-*-*): Try to find 64-bit compiler. Chose path, set CCAS. * configure: Regenerate. 2000-04-08 Torbjorn Granlund * mpz/bin_ui.c: Don't depend on ANSI C features. * mpz/bin_uiui.c: Likewise. * Makefile.am (MPZ_OBJECTS): mpz/cmp_abs* => mpz/cmpabs*. (MPQ_OBJECTS): Add mpq/set_d.lo. (MPZ_OBJECTS): Add mpz/fits*.lo. * Makefile.in: Regenerate. * mpz/cmpabs.c: New name for mpz/cmp_abs.c. * mpz/cmpabs_ui.c: New name for mpz/cmp_abs_ui.c. * mpz/Makefile.am: Corresponding changes. * mpz/Makefile.in: Regenerate. * gmp.h: mpz_cmp_abs* => mpz_cmpabs*. * mpz/addmul_ui.c (mpn_neg1): Don't depend on ANSI C features. * mpz/invert.c: Use TMP_MARK since we invoke MPZ_TMP_INIT. * gmp.h (mpq_set_d): Declare correctly. (mpz_root): Use _PROTO. (mpz_remove): Use _PROTO. (mpf_pow_iu): Use _PROTO. * mpn/asm-defs.m4 (MPN_PREFIX): Revert previous change. * gmp.h (__MPN): Revert previous change. * mpz/perfpow.c: De-ANSI-fy. Add copyright notice. * mpz/set_d.c: Misc cleanups. * mpq/set_d: New file. * gmp.h: Declare mpq_set_d. * mpq/Makefile.am: List set_d.c. * mpq/Makefile.in: Regenerate. 2000-04-07 Torbjorn Granlund * mpz/fits_sint_p.c: New file. * mpz/fits_slong_p.c: New file. * mpz/fits_sshort_p.c: New file. * mpz/fits_uint_p.c: New file. * mpz/fits_ulong_p.c: New file. * mpz/fits_ushort_p.c: New file. * gmp.h: Declare mpz_fits_*. * mpz/Makefile.am: List fits_* files. * mpz/Makefile.in: Regenerate. 2000-04-06 Kevin Ryde * gmp.texi (Installing MP): Add known build problem SunOS 4.1.4 m4 failure. * mpn/x86/pentium/gmp-mparam.h: Tune thresholds. * mpn/x86/p6/gmp-mparam.h: Ditto. * mpn/x86/k6/gmp-mparam.h: Tune thresholds, add UMUL_TIME, UDIV_TIME. * mpn/x86/k7/gmp-mparam.h: Tune thresholds, amend UMUL_TIME. * mpn/generic/mul_n.c (mpn_kara_mul_n): Add an ASSERT. (mpn_kara_sqr_n): Add an ASSERT, use KARATSUBA_SQR_THRESHOLD. (mpn_toom3_sqr_n): Eliminate second evaluate3. * gmp-impl.h (mpn_com_n,MPN_LOGOPS_N_INLINE): Don't allow size==0. (tune_mul_threshold,tune_sqr_threshold): Conditionalize declarations on TUNE_PROGRAM_BUILD. * mpn/generic/sqr_basecase.c: Add an assert. 2000-04-05 Torbjorn Granlund * gmp.h, mpn/asm-defs.m4: List the same functions for __MPN, but leave some commented out. * gmp-impl.h (MPN_LOGOPS_N_INLINE): Optimize. (mpn_com_n): Optimize. * gmp.h (__MPN): Make it use __gmpn instead of __mpn for consistency. * mpn/asm-defs.m4 (MPN_PREFIX): Likewise. * gmp.h (GMP_ERROR_ALLOCATE): New errcode. * gmp-impl.h (MPN_MUL_N_RECURSE): Delete. (MPN_SQR_RECURSE): Delete. * gmp-impl.h (TARGET_REGISTER_STARVED): New define. * gmp-impl.h (mpn_kara_sqr_n): Remap with __MPN. (mpn_toom3_sqr_n): Likewise. (mpn_kara_mul_n): Likewise. (mpn_toom3_mul_n): Likewise. (mpn_reciprocal): Likewise. * gmp-impl.h (__gmpn_mul_n): Remove declaration. (__gmpn_sqr): Likewise. * gmp.h (mpn_sqr_n): Declare/remap. * mpn/generic/mul.c (mpn_sqr_n): New name for mpn_sqr. * gmp.h (mpn_udiv_w_sdiv): Move __MPN remap from here... * gmp-impl.h: ...to here. 2000-04-05 Linus Nordberg * gmp.texi (Top): Add `Random Number Functions' to menu. (Introduction to MP): Fix typo. (MP Basics): Create menu for all sections. Move `Random Number Functions' to its own chapter. Add nodes for all sections. (Function Classes): Mention random generation functions under miscellaneous. (Miscellaneous Integer Functions): Update mpz_urandomb, mpz_urandomm. (Low-level Functions): Remove mpn_rawrandom. (Random State Initialization): Update. * mpf/urandom.c (mpf_urandomb): Remove SIZE parameter. Normalize result correctly. * gmp.h (mpf_urandomb): Remove SIZE parameter. * randraw.c (gmp_rand_getraw): Handle the case where (1) the LC scheme doesn't generate even limbs and (2) more than one LC invokation is necessary to produce the requested number of bits. 2000-04-05 Torbjorn Granlund * mpn/generic/mul_n.c (INVERSE_3): New name for THIRD, define for any BITS_PER_MP_LIMB. (MP_LIMB_T_MAX): New. (mpn_divexact3_n): Remove. (interpolate3): Use mpn_divexact_by3 instead of mpn_divexact3_n. 2000-04-05 Kevin Ryde * gmp-impl.h (KARATSUBA_MUL_THRESHOLD<2): Remove cpp test. (tune_mul_threshold,tune_sqr_threshold): Add declarations, used in development only. * mpn/x86/k7/sqr_basecase.asm: New file, only a copy of k6 for now. 2000-04-04 Torbjorn Granlund * gmp-impl.h (TOOM3_MUL_THRESHOLD): Provide default. (TOOM3_SQR_THRESHOLD): Provide default. * mpn/generic/mul_n.c: Rewrite (mostly by Robert Harley). * mpn/generic/mul.c: Rewrite (mostly by Robert Harley). * configure.in (sparcv9 64-bit OS): Set extra_functions. 2000-04-04 Linus Nordberg * mpn/generic/rawrandom.c: Remove file and replace with randraw.c on top level. (mpn_rawrandom): Rename to gmp_rand_getraw. * randraw.c: New file; essentially a copy of mpn/generic/rawrandom.c. (gmp_rand_getraw): New function (formerly known as mpn_rawrandom). * mpz/urandomb.c (mpz_urandomb): Change mpn_rawrandom --> gmp_rand_getraw. * mpz/urandomm.c (mpz_urandomb): Ditto. * mpf/urandom.c (mpf_urandomb): Ditto. * gmp.h (gmp_rand_getraw): Add function prototype. (mpn_rawrandom): Remove function prototype. * Makefile.am (libgmp_la_SOURCES): Add randraw.c. * Makefile.in: Regenerate. * configure.in (gmp_mpn_functions): Remove rawrandom. * configure: Regenerate. 2000-04-04 Linus Nordberg * gmp.h (GMP_ERROR enum): Remove comma after last enumeration since the AIX compiler (xlc) doesn't like that. * randlc.c (gmp_rand_init_lc): Allocate enough space for seed to hold any upcoming seed. * randlc2x.c (gmp_rand_init_lc_2exp): Likewise. * mpn/generic/rawrandom.c: Remove debugging code. (mpn_lc): Don't reallocate seed. * mpz/urandomm.c (mpz_urandomm): Implement function. * mpz/urandomb.c (mpz_urandomb): Fix typo in function definition. 2000-04-04 Kevin Ryde * make.bat: Removed (no longer works, no longer supported). * mpn/msdos/asm-syntax.h: Removed (was used only by make.bat). 2000-04-03 Torbjorn Granlund * mpn/generic/brandom.c: New file, replacing random2. 2000-04-02 Torbjorn Granlund * mpn/sparc32/v9/submul_1.asm: Change some carry-form instructions into their plain counterparts. * mpn/sparc64/copyi.asm: Avoid executing ALIGN. * mpn/sparc64/mul_1.asm: Handle overlap of rp/sp. * mpn/sparc64/addmul_1.asm: Likewise. * mpn/sparc64/submul_1.asm: Likewise. 2000-04-01 Linus Nordberg * gmp.h: Fix function prototypes for randomization functions. (__gmp_rand_lc_scheme_struct): Replace `m' with `m2exp'. Remove unused `bits'. (__gmp_rand_data_lc): Add `m2exp' as another way of representing the modulus. (__gmp_rand_state_struct): Remove unused `size'. * rand.c (__gmp_rand_scheme): Use better multipliers. Remove test schemes. Replace `m' with `m2exp'. (gmp_rand_init): Change parameters and return type. Use `m2exp' instead of `m'. Set `gmp_errno' on error. Disable BBS algorithm. * randlc.c (gmp_rand_init_lc): Don't use malloc(). Change parameters. * randclr.c (gmp_rand_clear): Don't use free(). Disable BBS algorithm. Set `gmp_errno' on error. * randlc2x.c (gmp_rand_init_lc_2exp): New function. * randsd.c (gmp_rand_seed): New function. * randsdui.c (gmp_rand_seed_ui): New function. * randlcui.c: Remove unused file. * mpn/generic/rawrandom.c (mpn_rawrandom): Rewrite. (mpn_lc): New static function. * mpz/urandomb.c (mpz_urandomb): Use ABSIZ() instead of SIZ() for determining size of ROP. * mpf/urandom.c (mpf_urandomb): Add third parameter, nbits. (Not used yet!) Change parameter order to mpn_rawrandom(). * Makefile.am (libgmp_la_SOURCES): Add errno.c, randlc2x.c, randsd.c, randsdui.c. Remove randui.c. (MPZ_OBJECTS): Rename urandom.lo --> urandomb.lo. Add urandomm.lo. * Makefile.in: Regenerate. * mpz/Makefile.am (libmpz_la_SOURCES): Change urandom.c --> urandomb.c. Add urandomm.c. * mpz/Makefile.in: Regenerate. * tests/rand/Makefile.am (noinst_PROGRAMS): Change findcl --> findlc. Add gen.static. * tests/rand/Makefile.in: Regenerate. * tests/rand/gen.c (main): Add mpz_urandomm. Add command line options `-C', `-m', extend `-a'. Use *mp*_*rand*() with new parameters. Call gmp_rand_seed(). 2000-04-01 Kevin Ryde * acinclude.m4 (GMP_CHECK_ASM_DATA): Plain .data for hpux. * configure.in (CCAS): No CFLAGS, they're added when it's used. (CONFIG_SRCDIR): New define for config.m4. * mpn/sparc64/addmul_1.asm: Use it for an include(). * mpn/sparc64/submul_1.asm: Ditto. * mpn/sparc64/mul_1.asm: Ditto. 2000-03-31 Linus Nordberg * mpz/urandom.c: Rename to... * mpz/urandomb.c: ...this. * mpz/urandomb.c (mpz_urandomb): Change operand order in call to mpn_rawrandom(). Use ABSIZ() instead of SIZ() when checking size of ROP. * mpz/urandomm.c: New file. 2000-03-31 Kevin Ryde * acinclude.m4 (GMP_CHECK_ASM_MMX): Give a warning when mmx code will be omitted. 2000-03-30 Torbjorn Granlund * mpn/sparc64/mul_1h.asm: New file. * mpn/sparc64/addmul_1h.asm: New file. * mpn/sparc64/submul_1h.asm: New file. * mpn/sparc64/mul_1.asm: Rewrite. * mpn/sparc64/addmul_1.asm: Rewrite. * mpn/sparc64/submul_1.asm: Rewrite. 2000-03-28 Torbjorn Granlund * mpn/sparc32/v9/mul_1.asm: Fix typo in branch prediction. * mpn/sparc32/v9/addmul_1.asm: Likewise. * mpn/sparc32/v9/submul_1.asm: Likewise. 2000-03-25 Kevin Ryde * mpn/lisp/gmpasm-mode.el: Fix some comment detection, use custom, fontify more keywords, turn into a standalone mode. * stamp-vti: New file, generated together with version.texi. * acinclude.m4 (GMP_VERSION,GMP_HEADER_GETVAL): New macros. * configure.in (AM_INIT_AUTOMAKE): Use GMP_VERSION. 2000-03-24 Kevin Ryde * INSTALL: Updates for new configure system. * configure.in: Add gmp_optcflags_gcc for the x86s, setting -mcpu and -march. 2000-03-23 Torbjorn Granlund * demos/pexpr.c (mpz_eval_expr): Properly initialize rhs/lhs for ROOT. 2000-03-23 Kevin Ryde * config.guess (i?86:*:*:*): Use uname -m if detection program fails. * mpn/x86/README: Remove remarks on the now implemented MMX shifts. * mpn/x86/k6/README: Add speed of mpn_divexact_by3, update mpn_mul_1. * gmp.texi (Installing MP): Corrections to target CPUs. * version.c: Use VERSION from config.h, add copyright comment, restore "const" somehow lost. * configure.in (a29k*-*-*): Fix directory name. 2000-03-22 Torbjorn Granlund * demos/pexpr.c (op_t): Add ROOT. (fns): Add ROOT. (mpz_eval_expr): Add ROOT. * mpz/root.c: Handle roots of negative numbers. Fix other border cases. Fix rare memory leakage. * errno.c: New file. 2000-03-21 Torbjorn Granlund * gmp.h (error number enum): New anonymous enum. (gmp_errno): New. * gmp.h (__GNU_MP_VERSION, __GNU_MP_VERSION_MINOR): Bump for GMP 3.0. 2000-03-20 Torbjorn Granlund * mpn/alpha/unicos.m4 (FLOAT64): New define. * mpn/alpha/default.m4 (FLOAT64): New define. * mpn/alpha/invert_limb.asm (C36): Use FLOAT64. 2000-03-21 Kevin Ryde * mpn/x86/k6/diveby3.asm: Tiny speedup. * acinclude.m4 (GMP_CHECK_ASM_SHLDL_CL): New macro. * configure.in: Use it, set WANT_SHLDL_CL in config.m4. * mpn/x86/x86-defs.m4 (shldl,shrdl,shldw,shrdw): New macros, using WANT_SHLDL_CL. * mpn/x86/k6/mmx/lshift.asm: Use shldl macro. * mpn/x86/k7/mmx/lshift.asm: Ditto. * mpn/x86/pentium/mmx/lshift.asm: Ditto. * mpn/x86/k6/mmx/rshift.asm: Use shrdl macro. * mpn/x86/k7/mmx/rshift.asm: Ditto. * mpn/x86/pentium/mmx/rshift.asm: Ditto. * mpn/x86/README.family: Add a note about this. 2000-03-20 Linus Nordberg * mpn/generic/rawrandom.c (mpn_rawrandom): Handle seed value of 0 correctly. * configure.in: Fix detection of alpha flavour. Set compiler options for `sparcv8'. * configure: Regenerate. * rand.c (__gmp_rand_scheme): Clean up some. Use slightly better multipliers. * configure.in (AC_OUTPUT): Add tests/Makefile and tests/rand/Makefile. * acinclude.m4 (AC_CANONICAL_BUILD): Define to `_AC_CANONICAL_BUILD' to deal with incompabilities between Autoconf and Libtool. (AC_CHECK_TOOL_PREFIX): Likewise. * Makefile.am (EXTRA_DIST): Add directory `tests'. * mkinstalldirs: Update (Automake 2000-03-17). * ltconfig: Update (Libtool 2000-03-17). * ltmain.sh: Ditto. * configure: Regenerate with new autoconf/-make/libtool suite. * aclocal.m4: Ditto. * config.in: Ditto. * all Makefile.in's: Ditto. 2000-03-20 Torbjorn Granlund * demos/pexpr.c (main): Don't allow `-N' for base, require `-bN'. * mpn/alpha/unicos.m4 (cvttqc): New define. * mpn/alpha/invert_limb.asm: Use new define for cvttqc. 2000-03-19 Kevin Ryde * mpn/x86/k6/sqr_basecase.asm: Tiny amendments for 3x3 case. * gmp.texi: Use @include version.texi. Use @email and @uref. (Installing MP): Rewrite for new configure. (Low-level Functions): Add mpn_divexact_by3. * configure.in (--enable-alloca): New option. * acconfig.h (USE_STACK_ALLOC): For --disable-alloca. 2000-03-18 Kent Boortz * macos: New directory with macos port files. 2000-03-17 Torbjorn Granlund * gmp-impl.h (union ieee_double_extract): Check _CRAYMPP. * mpn/asm-defs.m4 (invert_normalized_limb): Define. * mpn/alpha: Translate `.s' files to `.asm'. * configure: Regenerate. * mpn/alpha/invert_limb.asm: Replace dash in file name with underscore. * configure.in: Corresponding change. * configure.in: Assign special "path" for alphaev6. * mpn/alpha/unicos.m4: New file. * configure.in (alpha*-cray-unicos*): [This part of the change commited 2000-03-13 by linus] * mpn/alpha/default.m4: New file. * configure.in (alpha*-*-*): Use it. 2000-03-17 Kevin Ryde * mpn/x86/pentium/rshift.S: Use plain rcrl (not rcrl $1) for shift-by-1 case, significant speedup. * mpn/x86/pentium/README: Add shift-by-1 speed. 2000-03-16 Torbjorn Granlund * config.guess: Handle Cray T3D/E. 2000-03-15 Kevin Ryde * mpn/generic/diveby3.c: New file. * mpn/x86/diveby3.asm: New file. * mpn/x86/k6/diveby3.asm: New file. * gmp.h (mpn_divexact_by3): Prototype and define. * mpn/asm-defs.m4: define_mpn(divexact_by3). * configure.in (gmp_mpn_functions): Add diveby3. * mpn/x86/pentium/sqr_basecase.asm: A few better addressing modes. * configure.in: Add AC_C_STRINGIZE and AC_CHECK_TYPES((void)). * gmp-impl.h (ASSERT): Use them. * mpn/x86/k7/mmx/lshift.asm: New file. * mpn/x86/k7/mmx/rshift.asm: Rewrite simple loop and return value handling, add some pictures. 2000-03-14 Torbjorn Granlund * mpn/sparc32/v8/mul_1.asm: Make PIC actually work. * mpn/sparc32/v8/addmul_1.asm: Likewise. * mpn/sparc32/v8/mul_1.asm: Use m4 ifdef, not cpp #if. * mpn/sparc32/v8/addmul_1.asm: Likewise. * mpn/asm-defs.m4 (C): New define for comments. * mpn/sparc32: Start comments with `C'. * config.guess: Remove `SunOS 6' handling. Recognize sun4m and sun4d architectures under old SunOS. 2000-03-14 Linus Nordberg * configure.in (gmp_srclinks): Set to list of links created by configure. * configure: Regenerate. * Makefile.am (libgmp_la_LDFLAGS): Set version info. (DISTCLEANFILES): Include @gmp_srclinks@. * Makefile.in: Regenerate. 2000-03-13 Linus Nordberg * configure.in: Remove some changequote's by quoting the strings containing `[]'. Add support for `alpha*-cray-unicos*'. AC_DEFINE `_LONG_LONG_LIMB' instead of passing it in CFLAGS. Conditionalize the assembler syntax checks. * configure: Regenerate. * config.in: Regenerate. * acinclude.m4 (GMP_PROG_CCAS): Remove macro. * aclocal.m4: Regenerate. 2000-03-13 Kevin Ryde * mpn/x86/p6/README: New file. * mpn/x86/k6/mul_1.asm: Rewrite, smaller and slightly faster. * mpn/lisp/gmpasm-mode.el: Rewrite assembler comment detection and handling. * configure.in: Separate mmx directories for each x86 flavour. * configure: Regenerate. 2000-03-12 Kevin Ryde * mpn/x86/x86-defs.m4 (ALIGN): Supplement definition from config.m4 so as to pad with nops not zeros on old gas. * mpn/x86/k7/mmx/copyd.asm: Use plain emms (femms is just an alias for emms now). * mpn/x86/k7/mmx/copyi.asm: Ditto. * mpn/x86/k7/mmx/rshift.asm: Ditto. * mpn/x86/x86-defs.m4: Amend comments. * mpn/x86/mod_1.asm: Add comments on speeds. * mpn/x86/pentium/mmx/lshift.asm: New file. * mpn/x86/pentium/mmx/rshift.asm: New file. * mpn/x86/pentium/README: Add speeds of various routines. 2000-03-10 Linus Nordberg * configure.in: Reorganize. Use AC_CHECK_TOOL to find `ar'. Add post-includes `regmap.m4' and `aix.m4' for AIX targets. asm-syntax.h is not needed for PPC or sparc anymore. (powerpc64-*-aix*): Compiler is always 64-bit. Use `-q64 -qtune=pwr3' to xlc and `-maix64 -mpowerpc64' to gcc. Pass `-X 64' to `ar' and `nm'. (pentiummmx): Use GMP_CHECK_ASM_MMX and avoid MMX assembly path if assembler is not MMX capable. (pentium[23]): Likewise. (athlon): Likewise. (k6*): Likewise. * configure: Regenerate. * acinclude.m4 (GMP_PROG_CC_WORKS): New macro. (GMP_PROG_CC_FIND): Use GMP_PROG_CC_WORKS instead of AC_TRY_COMPILER. Make sure that the *first* working 32-bit compiler is used if no 64-bit compiler is found. (GMP_CHECK_ASM_MMX): New macro. * aclocal.m4: Regenerate. * Makefile.in: Regenerate. (CC_TEST removed.) * mpf/Makefile.in: Likewise. * mpn/Makefile.in: Likewise. * mpq/Makefile.in: Likewise. * mpz/Makefile.in: Likewise. * mpf/tests/Makefile.in: Likewise. * mpq/tests/Makefile.in: Likewise. * mpz/tests/Makefile.in: Likewise. * acconfig.h (_LONG_LONG_LIMB): Add. * gmp-impl.h: Include config.h only if HAVE_CONFIG_H is defined. 2000-03-09 Kevin Ryde * mpn/x86/pentium/mul_basecase.S: Small speedup by avoiding an AGI. * mpn/x86/k7/mmx/copyd.asm: Tiny speedup by avoiding popl. * mpn/x86/k7/mmx/copyi.asm: Ditto. * mpn/x86/k7/mul_basecase.asm: Ditto. 2000-03-07 Torbjorn Granlund * config.guess: Better recognize POWER/PowerPC processor type. 2000-03-07 Kevin Ryde * mpn/generic/addsub_n.c: Use HAVE_NATIVE_* now in config.h. * mpn/asm-defs.m4: Add comments about SysV m4. (m4_log2): Don't use <<. (m4_lshift,m4_rshift): New macros. 2000-03-06 Torbjorn Granlund * mpn/powerpc32/regmap.m4: Map cr0 => `0', etc. 2000-03-06 Kevin Ryde * mpn/tests/ref.c (refmpn_divexact_by3): New function. * mpn/tests/ref.h: Prototype. * acconfig.h (WANT_ASSERT): New define. * configure.in (--enable-assert): Turn on WANT_ASSERT. * assert.c: New file. * Makefile.am: Add to build. * gmp-impl.h (ASSERT): New macro. (ASSERT_NOCARRY) Renamed from assert_nocarry. (MPZ_CHECK_FORMAT): Use ASSERT_ALWAYS. * mpn/tests/ref.c: Use ASSERT. * mpf/get_str.c: Use ASSERT_ALWAYS. * mpf/set_str.c: Remove old assert macro. * mpn/x86/x86-defs.m4 (cmovnz_ebx_ecx): New macro. * mpn/x86/p6/aorsmul_1.asm: Use cmov. * mpn/x86/lshift.S: Use %dl with testb, not %edx. No object code change, testb was still getting generated. * mpn/x86/rshift.S: Ditto. 2000-03-03 Torbjorn Granlund * longlong.h: Add IA-64 support. * mpn/powerpc32: Misc cleanups. * mpn/powerpc32/aix.m4: New file (mainly by Linus). * mpn/powerpc64/aix.m4: New file (mainly by Linus). * mpn/powerpc64: Translate `.S' files to `.asm'. * configure.in: Fix tyops. * configure: Regenerate. 2000-03-02 Torbjorn Granlund * mpn/powerpc32/regmap.m4: New file. * mpn/powerpc32: Translate `.S' files to `.asm'. * configure.in: Use mpn/powerpc32/regmap.m4 for powerpc targets except some weird ones. 2000-03-03 Kevin Ryde * mpn/lisp/gmpasm-mode.el: Suppress postscript comment prefixes in filladapt. * mpn/x86/pentium/sqr_basecase.asm: New file. * mpn/x86/pentium/gmp-mparam.h (KARATSUBA_SQR_THRESHOLD): Update. * configure.in: Add --enable-assert, enable k6 logops functions. * mpn/x86/k6/mmx/copyi.asm: Use m4 for divide, not as. * mpn/x86/k6/mmx/copyd.asm: Ditto. * mpn/x86/README.family: Add a note on this. 2000-03-02 Kevin Ryde * mpn/x86/k6/aors_n.asm: Don't use stosl. * mpn/x86/copyi.asm: Use cld to clear direction flag. * mpn/x86/divrem_1.asm: Ditto. * mpn/x86/README.family: Add a note on this. * mpn/x86/k6/mmx/copyi.asm: Rewrite. * mpn/x86/k6/mmx/copyd.asm: New file. * mpn/x86/k6/README: Update, and small amendments. * mpn/x86/x86-defs.m4 (Zdisp): New macro. * mpn/asm-defs.m4 (m4_stringequal_p): New macro. * mpn/x86/p6/aorsmul_1.asm: Use Zdisp to force zero displacements. * mpn/x86/k6/aorsmul_1.asm: Ditto. * mpn/x86/k6/mul_1.asm: Ditto. * mpn/x86/k6/mul_basecase.asm: Ditto. * mpn/x86/k7/aors_n.asm: Ditto. * mpn/x86/k7/aorsmul_1.asm: Ditto. * mpn/x86/k7/mul_1.asm: Ditto. * mpn/x86/k7/mul_basecase.asm: Ditto. * mpn/x86/README.family: Add a note on this. 2000-02-27 Kevin Ryde * mpn/generic/divrem.c (mpn_divrem_classic): Patch to avoid gcc 2.7.2.3 i386 register handling bug. * mpn/x86/k6/aors_n.asm: Rewrite. * mpn/x86/k6/mmx/lshift.asm: Rewrite. * mpn/x86/k6/mmx/rshift.asm: Rewrite. * mpn/x86/k6/README: Update. * mpn/x86/k7/mmx/copyd.asm: Support size==0. * mpn/x86/k7/mmx/copyi.asm: Ditto. * mpn/x86/k6/mmx/copyi.asm: Ditto. * gmp-impl.h: Comment size==0 allowed in MPN_COPY_INCR and MPN_COPY_DECR. * configure.in: Enable x86 copyi, copyd; add k6 com_n. 2000-02-25 Torbjorn Granlund * demos/pexpr.c (power): Move factorial handing code from `factor' to `power'. * demos/factorize.c (factor_using_pollard_rho): Move resetting of `c' to before checking for a non-zero gcd. 2000-02-25 Kevin Ryde * mpn/asm-defs.m4 (MULFUNC_PROLOGUE): New macro by Linus. * mpn/x86/k6/aors_n.asm: Use MULFUNC_PROLOGUE. * mpn/x86/k6/aorsmul_1.asm: Ditto. * mpn/x86/k7/aors_n.asm: Ditto. * mpn/x86/k7/aorsmul_1.asm: Ditto. * mpn/x86/p6/aorsmul_1.asm: Ditto. * mpn/tests/ref.c (refmpn_copyi,refmpn_copyd): Allow size==0. * gmp-impl.h: Move mpn_and_n, mpn_andn_n, mpn_com_n, mpn_ior_n, mpn_iorn_n, mpn_nand_n, mpn_nior_n, mpn_xor_n and mpn_xorn_n here from gmp.h. Use HAVE_NATIVE_mpn_* to make these functions or inlines. * gmp-impl.h: Move mpn_copyd, mpn_copyi here from gmp.h. * gmp-impl.h (MPN_COPY_INCR): Use mpn_copyi if available. * gmp-impl.h (MPN_COPY_DECR): Use mpn_copyd if available. * mpn/x86/k6/mmx/com_n.asm: Moved into mmx subdirectory. * mpn/x86/k6/mmx/copyi.asm: Ditto. * mpn/x86/k6/mmx/lshift.asm: Ditto. * mpn/x86/k6/mmx/rshift.asm: Ditto. * mpn/x86/k7/mmx/rshift.asm: Ditto. * mpn/x86/k6/mmx/logops_n.asm: New file. * configure.in (k6*-*-*): Add logops_n.asm. * mpn/x86/k6/README: Update. * mpn/x86/k7/mmx/copyi.asm: New file. * mpn/x86/k7/mmx/copyd.asm: New file. * mpn/x86/k7/README: Update. 2000-02-24 Kevin Ryde * mpn/x86/x86-defs.m4 (femms): Generate emms if 3dnow not available. * mpn/x86/x86-defs.m4 (FRAME_popl): New macro. * Makefile.am: Add info_TEXINFOS = gmp.texi * mpn/x86/divrem_1.asm: Moved from mpn/x86/k6, allow size==0, conditionalize loop versus decl/jnz. * mpn/x86/mod_1.asm: Ditto. * mpn/x86/divmod_1.asm: Removed. * gmp.texi (mpn_divrem_1,mpn_mod_1): Add that size==0 is allowed. * mpn/tests/ref.c (refmpn_divrem_1c,etc): Allow size==0. * mpn/x86/k6/aors_n.asm: Avoid gas 1.92.3 leal displacement expression problem. * mpn/x86/k6/aorsmul_1.asm: Ditto. * mpn/x86/k6/mul_1.asm: Ditto. * mpn/x86/k6/mul_basecase.asm: Ditto * mpn/x86/k7/aors_n.asm: Ditto. * mpn/x86/k7/aorsmul_1.asm: Ditto. * mpn/x86/k7/mul_1.asm: Ditto. * mpn/x86/k7/mul_basecase.asm: Ditto. * mpn/x86/k7/rshift.asm: Ditto. * mpn/x86/p6/aorsmul_1.asm: Ditto. * mpn/x86/README.family: Describe problem. 2000-02-24 Linus Nordberg * acinclude.m4 (GMP_CHECK_ASM_LSYM_PREFIX): Add dummy symbol to testcase to avoid nm failure. Try nm before piping to grep. * acconfig.h: Undef HAVE_NATIVE_func for every mpn function found in gmp.h. * configure.in: Invoke AC_CONFIG_HEADERS. Don't invoke AM_CONFIG_HEADER; it makes autoconf confused. Dig out entry points declared in assembly code and AC_DEFINE proper HAVE_NATIVE_func. * mpn/asm-defs.m4 (MULFUNC_PROLOGUE): New macro. * mpn/x86/p6/aorsmul_1.asm: Use MULFUNC_PROLOGUE. * mpn/x86/k6/aors_n.asm: Likewise. * Makefile.am (EXTRA_DIST): Add config.in; needed when we don't use AM_CONFIG_HEADER in configure.in. * mpn/Makefile.am (INCLUDES): Add `-I..' for config.h and gmp-mparam.h. * mpf/Makefile.am: Likewise. * mpq/Makefile.am: Likewise. * mpz/Makefile.am: Likewise. * mpf/tests/Makefile.am (INCLUDES): Add `-I../..' for config.h and gmp-mparam.h. * mpq/tests/Makefile.am: Likewise. * mpz/tests/Makefile.am: Likewise. * configure: Regenerate. * aclocal.m4: Regenerate. * config.in: Regenerate. * Makefile.in: Regenerate. * mpf/Makefile.in: Regenerate. * mpn/Makefile.in: Regenerate. * mpq/Makefile.in: Regenerate. * mpz/Makefile.in: Regenerate. * mpf/tests/Makefile.in: Regenerate. * mpq/tests/Makefile.in: Regenerate. * mpz/tests/Makefile.in: Regenerate. 2000-02-23 Kevin Ryde * mpn/x86/addmul_1.S: Amend comments, this code no longer used by PentiumPro. * mpn/x86/submul_1.S: Ditto. * mpn/x86/k6/com_n.asm: Rewrite, smaller but same speed. * mpn/x86/addmul_1.S: Add PROLOGUE and EPILOGUE to get .type and .size for ELF. Rename #define size to n to avoid .size. * mpn/x86/lshift.S: Ditto. * mpn/x86/mul_1.S: Ditto. * mpn/x86/mul_basecase.S: Ditto. * mpn/x86/rshift.S: Ditto. * mpn/x86/submul_1.S: Ditto. * mpn/x86/udiv.S: Ditto. * mpn/x86/umul.S: Ditto. * mpn/x86/pentium/add_n.S: Ditto. * mpn/x86/pentium/addmul_1.S: Ditto. * mpn/x86/pentium/lshift.S: Ditto. * mpn/x86/pentium/mul_1.S: Ditto. * mpn/x86/pentium/mul_basecase.S: Ditto. * mpn/x86/pentium/rshift.S: Ditto. * mpn/x86/pentium/sub_n.S: Ditto. * mpn/x86/pentium/submul_1.S: Ditto. 2000-02-22 Linus Nordberg * acinclude.m4 (GMP_INIT): Use temporary file cnfm4p.tmp for post-defines. (GMP_FINISH): Ditto. (GMP_DEFINE): Add third optional argument specifying location in outfile. (GMP_DEFINE_RAW): New macro. * aclocal.m4: Regenerate. * configure.in: Add `HAVE_TARGET_CPU_$target_cpu' using GMP_DEFINE_RAW. * configure: Regenerate. * mpz/tests/Makefile.am: New test t-root. * mpz/tests/Makefile.in: Regenerate. 2000-02-22 Torbjorn Granlund * mpz/root.c: Complete rewrite; still primitive, but at least correct. * mpz/tests/t-root.c: New test. 2000-02-22 Kevin Ryde * mpn/x86/k7/mul_basecase.asm: New file. * mpn/x86/k7/README: Add mpn_mul_basecase speed. * mpn/x86/k7/gmp-mparam.h: New file. * mpn/x86/x86-defs.m4 (loop_or_decljnz,cmov_bytes): New macros. * mpn/asm-defs.m4 (m4_ifdef_anyof_p): New macro. * mpn/x86/k6/aorsmul_1.asm: New file. * mpn/x86/k6/addmul_1.S: Removed (was a copy of pentium version). * mpn/x86/k6/submul_1.S: Removed (was a copy of pentium version). * mpn/x86/p6/aorsmul_1.asm: Use OPERATION_addmul_1 and OPERATION_submul_1. * mpn/x86/k6/aors_n.asm: Use OPERATION_add_n and OPERATION_sub_n. * configure.in: Declare multi-function files for k6 and p6. * configure.in: Add HAVE_TARGET_CPU_$target_cpu for config.m4. * mpn/asm-defs.m4 (define_not_for_expansion): New macro. * mpn/generic/divrem_1n.c (__gmpn_divrem_1n): New file, split from mpn/generic/divrem_1.c. * mpn/generic/divrem_1.c: Ditto. * configure.in (gmp_mpn_functions): Ditto. 2000-02-21 Torbjorn Granlund * gmp.h: Undo 1996-10-06 NeXT change, it was clearly improperly written. 2000-02-21 Linus Nordberg * configure.in: Link /mpn/asm-defs.m4 to mpn/asm.m4. * configure: Regenerate. 2000-02-21 Linus Nordberg * mpn/x86/k7/aorsmul_1.asm: Change OPERATION_ADDMUL --> OPERATION_addmul_1. Change OPERATION_SUBMUL --> OPERATION_submul_1. * mpn/x86/k7/aors_n.asm: Change OPERATION_ADD --> OPERATION_add_n. Change OPERATION_SUB --> OPERATION_sub_n. * mpn/Makefile.am: Pass -DOPERATION_$* to preprocessors. * mpn/Makefile.in: Regenerate. * configure.in: Symlink mpn/asm-defs.m4 to build-dir/mpn. Link multi-function files to mpn/.asm and remove function name from `gmp_mpn_functions'. * configure: Regenerate. * acinclude.m4 (GMP_FINISH): Tell user what we're doing. * aclocal.m4: Regenerate. 2000-02-21 Kevin Ryde * gmp-impl.h: Rename __gmpn_mul_basecase to mpn_mul_basecase and __gmpn_sqr_basecase to mpn_sqr_basecase, remove __gmpn prototypes. * mpn/x86/mul_basecase.S: Ditto. * mpn/x86/pentium/mul_basecase.S: Ditto. * configure.in (gmp_m4postinc): Use x86-defs.m4 on athlon-*-* too. 2000-02-20 Kevin Ryde * acinclude.m4 (GSYM_PREFIX): Drop $1, change by Linus. * mpn/asm-defs.m4 (PROLOGUE,EPILOGUE): Use GSYM_PREFIX as a string, change by Linus. * mpn/x86/x86-defs.m4: Use GSYM_PREFIX as a string. * mpn/x86/k6/gmp-mparam.h: New file. * mpn/asm-defs.m4 (m4_warning): New macro. * mpn/x86/README: Amendments per new code and directories. * mpn/x86/README.family: New file. * mpn/x86/k6/README: New file. * mpn/x86/k7/README: New file. * mpn/generic/mul_n.c: Rename __gmpn_mul_basecase to mpn_mul_basecase and __gmpn_sqr_basecase to mpn_sqr_basecase. * mpn/generic/mul_basecase.c: Ditto. * mpn/generic/sqr_basecase.c: Ditto. * mpn/generic/mul.c: Ditto. 2000-02-19 Linus Nordberg * configure.in: Don't try to symlink more than one multi-func file. * configure: Regenerate. 2000-02-18 Linus Nordberg * acinclude.m4 (GMP_CHECK_ASM_UNDERSCORE): GMP_DEFINE `GSYM_PREFIX'. Run ACTIONs even when value is found in cache. (GMP_CHECK_ASM_ALIGN_LOG): GMP_DEFINE `ALIGN'. Run ACTIONs even when value is found in cache. * aclocal.m4: Regenerate. * configure.in: Don't define GSYM_PREFIX or ALIGN. Add mechanism for multi-function files. * configure: Regenerate. 2000-02-18 Kevin Ryde * configure.in (gmp_m4postinc): Enable x86-defs.m4. * mpn/x86/k7/mul_1.asm: Fix include. * mpn/x86/k6/mul_basecase.S: Removed (copy of the pentium version). * mpn/x86/k6/mul_basecase.asm: New file. * mpn/x86/k6/sqr_basecase.asm: New file. * mpn/x86/k6/com_n.asm: New file. * mpn/x86/k6/copyi.asm: New file. * gmp.texi (Low-level Functions): Clarify mpn overlaps permitted. * gmp-impl.h (MPN_OVERLAP_P): New macro. * gmp-impl.h (assert_nocarry): New macro. * mpn/tests/ref.c: New file, based in part on other mpn/tests/*.c. * mpn/tests/ref.h: New file. 2000-02-17 Linus Nordberg * Makefile.am (dist-hook): Don't include any emacs backup files (*.~*) in dist. * Makefile.in: Regenerate. 2000-02-17 Torbjorn Granlund * mpn/sparc32/v9/mul_1.asm: Use `rd' to get current PC; get rid of getpc function. * mpn/sparc32/v9/addmul_1.asm: Likewise. * mpn/sparc32/v9/submul_1.asm: Likewise. 2000-02-17 Kevin Ryde * gmp.h: Add prototypes and defines for mpn_and_n, mpn_andn_n, mpn_com_n, mpn_copyd, mpn_copyi, mpn_ior_n, mpn_iorn_n, mpn_mul_basecase, mpn_nand_n, mpn_nior_n, mpn_sqr_basecase, mpn_xor_n, mpn_xorn_n. * mpn/asm-defs.m4: Many additions making up initial version. * mpn/asm-defs.m4 (L): Use defn(`LSYM_PREFIX'). * mpn/x86/x86-defs.m4: New file. * mpn/x86/k6/aors_n.asm: New file. * mpn/x86/k6/divmod_1.asm: New file. * mpn/x86/k6/divrem_1.asm: New file. * mpn/x86/k6/lshift.S: Removed (was a copy of the pentium version). * mpn/x86/k6/lshift.asm: New file. * mpn/x86/k6/mod_1.asm: New file. * mpn/x86/k6/mul_1.S: Removed (was a copy of the pentium version). * mpn/x86/k6/mul_1.asm: New file. * mpn/x86/k6/rshift.S: Removed (was a copy of the pentium version). * mpn/x86/k6/rshift.asm: New file. * mpn/x86/k7/aors_n.asm: New file. * mpn/x86/k7/aorsmul_1.asm: New file. * mpn/x86/k7/mul_1.asm: New file. * mpn/x86/k7/rshift.asm: New file. * mpn/x86/p6/aorsmul_1.asm: New file. * mpn/x86/copyi.asm: New file. * mpn/x86/copyd.asm: New file. * mpn/lisp/gmpasm-mode.el: New file. 2000-02-16 Torbjorn Granlund * mpn/sparc32/v9/mul_1.asm: Conditionalize for PIC. * mpn/sparc32/v9/addmul_1.asm: Likewise. * mpn/sparc32/v9/submul_1.asm: Likewise. * mpn/sparc32/v8/supersparc/udiv.asm: Likewise. * mpn/sparc32/udiv_fp.asm: Likewise. 2000-02-16 Linus Nordberg * configure.in: Add mechanism for including target specific m4-files in config.m4. * configure: Regenerate. * acinclude.m4 (GMP_PROG_CCAS): Begin assembly lines (except labels) with a tab character. HP-UX demands it. (GMP_CHECK_ASM_SIZE): Ditto. (GMP_CHECK_ASM_LSYM_PREFIX): Ditto. (GMP_CHECK_ASM_LABEL_SUFFIX): Set to empty string for HP-UX. (GMP_CHECK_ASM_GLOBL): Change `.xport' --> `.export'. * aclocal.m4: Regenerate. 2000-02-16 Linus Nordberg * acinclude.m4 (GMP_CHECK_ASM_LSYM_PREFIX): Define LSYM_PREFIX as the prefix only, no argument. * aclocal.m4: Regenerate. * configure: Regenerate. * mpn/asm-defs.m4 (L): No argument to LSYM_PREFIX. 2000-02-15 Linus Nordberg * acinclude.m4: Prefix all temporary shell variables with `gmp_tmp_'. (GMP_PROG_CC_FIND): Use defaults if no arguments are passed. Quote use of arguments. (GMP_PROG_CCAS): New macro. (GMP_INIT): New macro. (GMP_FINISH): New macro. (GMP_INCLUDE): New macro. (GMP_SINCLUDE): New macro. (GMP_DEFINE): New macro. (GMP_CHECK_ASM_LABEL_SUFFIX): New macro. (GMP_CHECK_ASM_TEXT): New macro. (GMP_CHECK_ASM_DATA): New macro. (GMP_CHECK_ASM_GLOBL): New macro. (GMP_CHECK_ASM_TYPE): New macro. (GMP_CHECK_ASM_SIZE): New macro. (GMP_CHECK_ASM_LSYM_PREFIX): New macro. (GMP_CHECK_ASM_W32): New macro. * aclocal.m4: Regenerate. * configure.in: Find m4 and nm for target. Use new macros to create config.m4. Prefix all temporary shell variables with `tmp_'. Pass `-X 64' to nm for 64-bit PPC target with 64-bit compiler. * configure: Regenerate. * Makefile.am (dist-hook): *Really* remove all CVS dirs in dist. * Makefile.in: Regenerate. * mpn/Makefile.am: Add target for building .lo and .o from .asm. Pass -DPIC to preprocessor (CPP/m4) when building .lo. Build .o a second time for target .lo, without -DPIC to preprocessor. (SUFFIX): Add `.asm'. (EXTRA_DIST): Add asm-defs.m4. * mpn/Makefile.in: Regenerate. * mpf/Makefile.in: Regenerate. * mpf/tests/Makefile.in: Regenerate. * mpq/Makefile.in: Regenerate. * mpq/tests/Makefile.in: Regenerate. * mpz/Makefile.in: Regenerate. * mpz/tests/Makefile.in: Regenerate. 2000-02-15 Torbjorn Granlund * mpn/sparc32/udiv_fp.asm: Change `RODATA' to `DATA'. * mpn/sparc32/v8/supersparc/udiv.asm: Likewise. * mpn/sparc32/v9/addmul_1.asm: Likewise. * mpn/sparc32/v9/submul_1.asm: Likewise. * mpn/sparc32/v9/mul_1.asm: Likewise. * mpn/sparc32/add_n.asm: Rename `size' -> `n'. * mpn/sparc32/sub_n.asm: Likewise. * sparc32: Rename `.s' and `.S' files to `.asm'. * sparc64: Rename `.s' and `.S' files to `.asm'. 2000-02-11 Torbjorn Granlund * config.sub: Adopt to new config.guess sparc naming conventions. * config.guess (sun4u:SunOS:5.*:*): Change `sparc9' to `sparcv9'. * config.guess (sun4m:SunOS:5.*:*): Change to sun4[md]:SunOS:5.*:* and change `sparc8' to `sparcv8'. * mpn/x86/add_n.S: Use PROLOGUE/EPILOGUE. * mpn/x86/sub_n.S: Likewise. * mpn/x86/syntax.h (PROLOGUE): New name for PROLOG. * mpn/x86/syntax.h (EPILOGUE): New name for EPILOG. 2000-02-11 Linus Nordberg * configure.in: Better path for 64-bit sparc without 64-bit cc. Change sparc8 --> sparcv8. Change sparc9 --> sparcv9. * configure: Regenerate. 2000-02-10 Linus Nordberg * configure.in: Use Autoconf. * Makefile.am: New file. * AUTHORS: New file. * COPYING: New file. * acinclude.m4: New file. * acconfig.h: New file. * configure: Generate. * Makefile.in: Generate. * aclocal.m4: Generate. * config.in: Generate. * install.sh: Remove. * install-sh: New file from Automake. * missing: New file from Automake. * ltconfig: New file from Libtool. * ltmain.sh: New file from Libtool. * mpf/Makefile.am: New file. * mpf/Makefile.in: Generate. * mpf/configure.in: Remove. * mpf/tests/Makefile.am: New file. * mpf/tests/Makefile.in: Generate. * mpf/tests/configure.in: Remove. * mpn/Makefile.am: New file. * mpn/Makefile.in: Generate. * mpn/configure.in: Remove. * mpq/Makefile.am: New file. * mpq/Makefile.in: Generate. * mpq/configure.in: Remove. * mpq/tests/Makefile.am: New file. * mpq/tests/Makefile.in: Generate. * mpq/tests/configure.in: Remove. * mpz/Makefile.am: New file. * mpz/Makefile.in: Generate. * mpz/configure.in: Remove. * mpz/tests/Makefile.am: New file. * mpz/tests/Makefile.in: Generate. * mpz/tests/configure.in: Remove. 2000-02-10 Torbjorn Granlund * mpn/x86/add_n.S: Don't use label L0 twice. * mpn/x86/sub_n.S: Likewise. 2000-01-20 Linus Nordberg * demos/pexpr.c: Don't use setup_error_handler() in windoze. 2000-01-19 Torbjorn Granlund * demos/pexpr.c (sigaltstack): #define to sigstack for AIX. (setup_error_handler): Don't write to ss_size and ss_flags on AIX. 2000-01-11 Torbjorn Granlund * mpn/configure.in (hppa2.0*-*-*): Move assignment of target_makefile_frag to where it belongs. 1999-12-21 Torbjorn Granlund * longlong.h (v9 umul_ppmm): New #define. (v9 udiv_qrnnd): New #define. 1999-12-14 Torbjorn Granlund * mpn/generic/divmod_1.c: Use invert_limb. * mpn/generic/mod_1.c: Use invert_limb. * gmp-impl.h (invert_limb): Put definition here. * mpn/generic/divrem.c (invert_limb): Delete definition. * mpn/generic/divrem_2.c (invert_limb): Delete definition. * gmp.h (mpn_divrem): Inhibit for non-gcc. But declare (undo 1999-11-22 change). * gmp-impl.h (DItype,UDItype): Do these also if _LONG_LONG_LIMB. * longlong.h: Move 64-bit hppa code out of __GNUC__ conditional. * stack-alloc.c (HSIZ): New #define. (__tmp_alloc): Use HSIZ instead of sizeof(tmp_stack). 1999-12-10 Torbjorn Granlund * config.sub: Clean up handling of x86 CPUs: Properly recognize Amd CPUs as unique entities. Use manufacturer's names of processors ("pentium", etc); still match ambiguous names like "i586", "i686", "p6" but be conservative in interpreting them. * configure.in: Recognize x86 CPU types known by config.guess. * mpn/configure.in: Likewise. Add x86/mmx path component as appropriate. (athlon-*-*): Fix typo. * config.guess: Update x86 recog code to intiallly match more than just i386. Call K6-2 and K6-III for "k62" and "k63" respectively. * config.guess: Recognize x86 CPU types. Update code for FreeBSD, NetBSD, OpenBSD, Linux. 1999-12-08 Torbjorn Granlund * mpf/pow_ui.c: Avoid final squaring in loop. 1999-12-07 Torbjorn Granlund * gmp-impl.h (udiv_qrnnd_preinv2gen): Prefix local variables with `_'. (udiv_qrnnd_preinv2norm): Likewise. From Kevin Ryde: (HAVE_ALLOCA): #define also if defined (alloca). 1999-12-04 Torbjorn Granlund * mpn/tests/add_n.c: Set OPS from CLOCK. * mpn/tests/sub_n.c: Likewise. * mpn/tests/mul_1.c: Likewise. * mpn/tests/addmul_1.c: Likewise. * mpn/tests/submul_1.c: Likewise. * mpn/tests/lshift.c: Update from add_n.c. * mpn/tests/rshift.c: Likewise. 1999-12-03 Torbjorn Granlund * mpn/powerpc64/copy.S: New file. 1999-12-02 Torbjorn Granlund * mpn/sparc64/copy.s: New file. * mpn/tests/copy.c: New file. * mpn/configure.in: Recognize more Amd CPUs; Set special paths for k7 CPU. * configure.in: Recognize Amd x86 CPUs. * mpz/fdiv_r_2exp.c: In rounding code, read in->_mp_size before writing to res->_mp_size. * mpn/powerpc64/*.S: Clean up assembly syntax, add function headers. * mpn/powerpc64/gmp-mparam.h: (KARATSUBA_MUL_THRESHOLD): #define. (KARATSUBA_SQR_THRESHOLD): #define. * mpn/tests/add_n.c (main): Only print test number if TIMES==1 and not printing. (main): Don't run reference code if NOCHECK. * mpn/tests/sub_n.c: Likewise. * mpn/tests/mul_1.c: Likewise. * mpn/tests/addmul_1.c: Likewise. * mpn/tests/submul_1.c: Likewise. * mpn/tests/lshift.c: (main): Only print test number if TIMES==1 and not printing. * mpn/tests/rshift.c: Likewise. 1999-11-22 Torbjorn Granlund * gmp.h (mpz_init_set_str): Declare using __gmp_const. (mpz_set_str): Likewise. (mpf_init_set_str): Likewise. (mpf_set_str): Likewise. (mpn_set_str): Likewise. (__gmp_0): Likewise. (mpn_divrem): Remove separate declaration; it's defined later in this file. * gmp.h: Replace "defined (__STD__)' by (__STDC__-0) in expressions involving more than one term, to handle Sun's compiler that most helpfully sets __STDC__ to 0. * gmp-impl.h: Likewise. * longlong.h: Likewise. 1999-11-21 Torbjorn Granlund * mpn/sparc64/gmp-mparam.h (KARATSUBA_MUL_THRESHOLD): #define. (KARATSUBA_SQR_THRESHOLD): #define. * mpn/sparc64/lshift.s: Compensate stack references for odd stack ptr. * mpn/sparc64/rshift.s: Likewise. * mpn/sparc64/addmul_1.s: Propagate carry properly. * mpn/sparc64/submul_1.s: Likewise. * mpn/sparc64/sub_n.s: Rewrite. * mpn/sparc64/sub_n.s: Get operand order for main subcc right (before scrapping this code for new code). 1999-11-20 Torbjorn Granlund * mpn/sparc64/add_n.s: Rewrite. 1999-11-17 Torbjorn Granlund * mpn/x86/syntax.h (PROLOG): New #define. (EPILOG): New #define. * gmp.h (mpn_addsub_n): Declare. * gmp.h (mpn_add_nc): Declare. * gmp.h (mpn_sub_nc): Declare. * mpn/powerpc64/addsub_n.S: New file. 1999-11-17 Torbjorn Granlund * mpn/alpha/gmp-mparam.h (KARATSUBA_MUL_THRESHOLD): Only #define #ifndef. (KARATSUBA_SQR_THRESHOLD): Likewise. 1999-11-14 Torbjorn Granlund * mpn/x86/mul_1.S: Unroll and optimize for P6 and K7. 1999-11-09 Torbjorn Granlund * mpn/x86/p6/gmp-mparam.h (KARATSUBA_MUL_THRESHOLD): Only #define #ifndef. (KARATSUBA_SQR_THRESHOLD): Likewise. 1999-11-05 Torbjorn Granlund * mpn/generic/addsub_n.c: New file. 1999-11-02 Torbjorn Granlund * config.guess: Handle alpha:FreeBSD with alpha:NetBSD. * configure.in (vax*-*-*): New case. * config/mt-vax: New file. * mpn/vax/add_n.s: Rewrite. * mpn/vax/sub_n.s: Rewrite. 1999-10-31 Torbjorn Granlund * mpn/vax/rshift.s: New file. * mpn/vax/lshift.s: New file. 1999-10-29 Torbjorn Granlund * config.sub: Handle k5 and k6. * mpn/configure.in: Recognize k6. * mpf/tests/t-get_d.c (LOW_BOUND, HIGH_BOUND): New #defines. (main): Tighten error bounds to 14 digits. * longlong.h (default umul_ppmm, when smul_ppmm exists): Rename __m0 => __xm0, __m1 => __xm1. (default smul_ppmm): Likewise. 1999-10-11 Torbjorn Granlund * config.guess: Reverse the test for POWER vs PowerPC. * config.guess (sun4m:SunOS:5.*:*): New case. * config.guess (sun4u:SunOS:5.*:*): New case. 1999-09-29 Torbjorn Granlund * mpn/generic/divrem_2.c: Clean up comments. 1999-09-23 Torbjorn Granlund * mpz/tests/Makefile.in: Use move-if-change when generating binaries. * mpf/tests/Makefile.in: Likewise. * mpq/tests/Makefile.in: Likewise. * mpz/tests/move-if-change: New file. * mpf/tests/move-if-change: New file. * mpq/tests/move-if-change: New file. * gmp.h (mpn_incr_u): New macro (from mpn/generic/mul_n.c). (mpn_decr_u): New macro. * mpn/generic/mul_n.c (mpn_incr): Delete. * mpn/generic/mul_n.c: Update usages mpn_incr => mpn_incr_u. * mpn/generic/divrem_newt.c: Use mpn_incr_u and mpn_decr_u instead of mpn_add_1 and mpn_sub_1. * mpn/generic/sqrtrem.c: Likewise. * mpz/cdiv_q_ui.c: Likewise. * mpz/cdiv_qr_ui.c: Likewise. * mpz/fdiv_q_ui.c: Likewise. * mpz/fdiv_qr_ui.c: Likewise. * mpn/generic/sqrtrem.c: Start single-limb Newton iteration from 18 bits. 1999-07-27 Torbjorn Granlund * mpn/generic/divrem_1.c (__gmpn_divrem_1n): New function. * mpn/generic/divrem_2.c: New file, code from divrem.c, `case 2:'. * mpn/Makefile.in: Compile divrem_2.c. * make.bat: Compile divrem_2.c. * mpn/configure.in (functions): Add divrem_2. * gmp.h: Declare mpn_divrem_2. * mpn/generic/divrem.c: Delete special cases, handle just divisors of more than 2 limbs. * gmp.h (mpn_divrem): Call mpn_divrem_1, mpn_divrem_2, as appropriate. * mpn/generic/divrem.c: Rework variable usage for better register allocation. 1999-07-26 Torbjorn Granlund * mpn/alpha/ev5/add_n.s: Rewrite for better ev6 speed. * mpn/alpha/ev5/sub_n.s: Likewise. 1999-07-21 Torbjorn Granlund * longlong.h (alpha): Define umul_ppmm for cc. * gmp-impl.h (DItype, UDItype): Define for non-gcc if _LONGLONG is defined. 1999-07-15 Torbjorn Granlund * longlong.h (powerpc64 count_leading_zeros): Fix typo. (powerpc64 add_ssaaaa): Fix typos. (powerpc64 sub_ddmmss): Fix typos. 1999-07-14 Torbjorn Granlund * mpz/tests/Makefile.in: Pass XCFLAGS when linking. * mpf/tests/Makefile.in: Likewise. * mpq/tests/Makefile.in: Likewise. * mpn/Makefile.in (.S.o): Pass XCFLAGS. * longlong.h: Add support for 64-bit PowerPC. * config.sub: Handle "powerpc64". * configure.in: Likewise. * mpn/configure.in: Suppress use of config/t-ppc-aix for now, it seems compiler passes proper options. * mpn/powerpc64/*.S: New files. * Makefile.in (FLAGS_TO_PASS): Pass "AR=$(AR)". 1999-07-07 Torbjorn Granlund * demos/pexpr.c (factor): Change alloca call to a malloc/free pair. * mpn/powerpc32/syntax.h: Add #define's for crN. * gmp.h (gmp_rand_algorithm): Remove spurious `,'. 1999-07-05 Torbjorn Granlund * mpn/generic/divrem_1.c: Normalize divisor when needed. 1999-07-02 Torbjorn Granlund * mpn/configure.in (powerpc*-apple-mach): New configuration. * mpn/powerpc32/*: Add support for apple-macho syntax. * mpn/powerpc32/syntax.h: New file. * gmp-impl.h: Don't use `__attribute__' syntax for Apple's perversion of GCC. 1999-05-26 Linus Nordberg * rand.c (gmp_rand_init): Fix typo. * mpn/generic/rawrandom.c (mpn_rawrandom): Count bits, not limbs, to keep track of how many rounds to do in loop. Clean up temporary allocation. Update `seedsize' inside loop. Mask off the correct number of bits from final result. Init `mcopyp' even when not normalizing `m'. * randlc.c (gmp_rand_init_lc): Fix typo (don't call mpz_init_set_ui()). * mpn/generic/rawrandom.c (mpn_rawrandom): Set SIZ(s->seed) when reallocating. * tests/rand/Makefile (test, bigtest): Add 33-bit tests. * tests/rand/gen.c (main): Set precision of variable passed to mpf_urandomb(). Add option `-p'. 1999-05-25 Linus Nordberg * randcm.c: Remove. * randcmui.c: Remove. * Makefile.in: Remove randcm and randcmui. * make.bat: Ditto. * gmp-impl.h: Remove prototypes for __gmp_rand_init_common() and __gmp_rand_init_common_ui(). * randlc.c (gmp_rand_init_lc): Don't call __gmp_rand_init_common(). * randlcui.c (gmp_rand_init_lc_ui): Don't call __gmp_rand_init_common_ui(). * gmp.h (__gmp_rand_state_struct): Remove unused member `maxval'. * randclr.c (gmp_rand_clear): Remove reference to s->maxval. * randcm.c (__gmp_rand_init_common): Ditto * mpn/generic/rawrandom.c (mpn_rawrandom): Don't calculate nlimbs twice. * gmp.h (__gmp_rand_dist): Remove. 1999-05-24 Linus Nordberg * mpn/generic/rawrandom.c: Clean up comments. * gmp.texi: Add documentation for random number generation. 1999-05-21 Linus Nordberg * gmp.h: Typedef `gmp_rand_state' as an array with one element. Change prototypes accordingly. * gmp-impl.h: Change prototypes using `gmp_rand_state'. * rand.c (gmp_rand_init): Take `gmp_rand_state' as argument instead of a pointer to a `gmp_rand_state'. * mpf/urandom.c (mpf_urandomb): Ditto. * mpz/urandom.c (mpz_urandomb): Ditto. * mpn/generic/rawrandom.c (mpn_rawrandom): Ditto. * randcmui.c (__gmp_rand_init_common_ui): Ditto. * randlc.c (gmp_rand_init_lc): Ditto. * randlcui.c (gmp_rand_init_lc_ui): Ditto. * randui.c (gmp_rand_init_ui): Ditto. * randcm.c (__gmp_rand_init_common): Ditto. * randclr.c (gmp_rand_clear): Ditto. * tests/rand/gen.c (main): Pass `s' to rand-funcs instead of address of `s'. 1999-05-20 Linus Nordberg * Makefile.in: Rename randi.c --> rand.c, randi_lc.c --> randlc.c, randicom.c --> randcm.c. Add randui.c, randcmui.c, randlcui.c. * make.bat: Ditto. * gmp.h: Add prototypes for gmp_rand_init_ui() and gmp_rand_init_lc_ui(). * gmp-impl.h: Add prototypes for __gmp_rand_init_common() and __gmp_rand_init_common_ui(). * randlc.c, randcm.c, randclr.c, rand.c: Change #include of to "gmp.h". * randclr.c: Include stdlib.h for free(). * rand.c: Include gmp-impl.h. 1999-05-12 Torbjorn Granlund * mpn/configure.in: Put generic m68k alternative last. 1999-05-04 Torbjorn Granlund * demos/pexpr.c (setup_error_handler): Use sigemptyset to create empty set (for portability). (fns): Fix typo '#if #if'. (mpz_eval_expr): Implement FERMAT and MERSENNE. * demos/pexpr.c: Cast longjmp argument via long to silent warnings on 64-bit hosts. 1999-05-03 Torbjorn Granlund * demos/pexpr.c: Add #defines for GMP 1.x and 2.0 compatibility. * demos/pexpr.c (setup_error_handler): New function; take signal handler setup code from main(), with major modifications to use modern signal interface. (main): Remove signal handler setup code; call setup_error_handler. 1999-04-29 Linus Nordberg * tests/rand/findcl.c (main): Add option '-i' for interval factor. Separate v and merit lose figures. Add '-v' for version. 1999-04-28 Linus Nordberg * tests/rand/statlib.c: Change debugging stuff. * tests/rand/gmpstat.h: Add debug values definitions. * tests/rand/findcl.c (main): Print low and high merit on startup. Print version string on startup. Catch SEGV and HUP. Add option -d for debug. Fix bug making test for v too hard. (sh_status): New function. (sh_status): Flush stdout. Add RCSID. 1999-04-27 Linus Nordberg * tests/rand/Makefile (clean): Add target. 1999-04-27 Linus Nordberg * tests/rand/stat.c: Include gmpstat.h. Add global int g_debug. * tests/rand/spect.c: Include . * tests/rand/findcl.c (main): Input is `m', not all factors of `m'. Print only the very first matching multiplier. Include . Flush stdout. Print "done." when done. * tests/rand/spect.c: Move everything but main() to statlib.c. * tests/rand/findcl.c: New file. * tests/rand/gmpstat.h: New file. * tests/rand/statlib.c (merit, merit_u, f_floor, vz_dot, spectral_test): New functions. 1999-04-27 Torbjorn Granlund * mpn/configure.in: Fix typo, "sparc-*)" was "sparc)". 1999-04-21 Torbjorn Granlund * config.sub: Recognize ev6. 1999-04-12 Linus Nordberg * urandom.c: Split up into randclr.c, randi.c, randi_lc.c, randicom.c. * randclr.c, randi.c, randi_lc.c, randicom.c: New files. * Makefile.in: Remove urandom. Add randclr, randi, randi_lc, randicom. * make.bat: Ditto 1999-03-31 Torbjorn Granlund * configure.in (sparc9-*-solaris2.[789]*, etc): New alternative. * mpn/configure.in: Use mt-sprc9 also for ultrasparc*-*-solaris2*. 1999-03-30 Linus Nordberg * urandom.c (__gmp_rand_scheme): Change NULL->0. Include "gmp.h" instead of . 1999-03-29 Linus Nordberg * gmp.h (__gmp_rand_data_lc): Now holds a, c, m instead of scheme struct. (__gmp_rand_lc_scheme_struct): Remove mpz_t's `a' and `m'. * tests/rand/stat.c (f_freq): Don't print 2nd level results if doing 1st level. * tests/rand/gen.c (main): Set default algorithm to mpz_urandomb. (main): Add option -c. 1999-03-24 Linus Nordberg * tests/rand/Makefile (GMPINC): Rename to GMPH. (GMPH): Add gmp-mparam.h. (CFLAGS): Add -I$(GMPLIBDIR)/mpn 1999-03-23 Linus Nordberg * Makefile.in: Compile top-dir/urandom.c. * make.bat: Ditto. * mpn/Makefile.in: Compile rawrandom.c. * make.bat: Ditto. * mpn/configure.in (functions): Add rawrandom. * gmp.h (__gmp_rand_scheme_struct): Rename to __gmp_rand_lc_scheme_struct. (__gmp_rand_data_lc): Remove member 'n'. Allocate a __gmp_rand_lc_scheme_struct instead of a pointer to one. Add prototype for gmp_rand_init_lc(), mpn_rawrandom(). New prototype for mpz_urandomb(). * urandom.c: New file. (__gmp_rand_init_common): New function. (gmp_rand_init_lc): New function. (gmp_rand_init): Don't init data_lc->n. Call gmp_rand_init_lc() and __gmp_rand_init_common(). (gmp_rand_clear): Remove reference to data_lc->n. * mpz/urandom.c (gmp_rand_init, gmp_rand_clear): Move to new file urandom.c in top-dir. (mpz_urandomb): Add function parameter nbits. Call mpn_rawrandom(). * mpf/urandom.c (mpf_urandomb): Call mpn_rawrandom(). * mpn/generic/rawrandom.c: New file. (mpn_rawrandom): New function. 1999-03-17 Torbjorn Granlund * extract-dbl.c: When packing result, adjust exp when sc == 0. * mpf/tests/t-get_d.c: New file. * mpf/tests/Makefile.in: Compile t-get_d.c. 1999-03-16 Linus Nordberg * mpz/urandom.c (__gmp_rand_scheme): Add extra braces around the mpz_t members. * make.bat: Compile mpz/urandom.c and mpf/urandom.c * tests/rand/statlib.c (ks_table): Use mpf_pow_ui() and exp(). * tests/rand/gen.c: Include unistd.h for getopt. 1999-03-15 Linus Nordberg * mpz/urandom.c (gmp_rand_init): New function. (gmp_rand_clear): New function. (mpz_urandomb): New function. * mpz/Makefile.in: Compile urandom.c * mpf/urandom.c (mpf_urandomb): New function. * mpf/Makefile.in: Compile urandom.c. * gmp.h (__gmp_rand_state_struct, __gmp_rand_scheme_struct): New structs for randomization functions. (gmp_rand_dist, gmp_rand_alogrithm): New enums for randomization functions. (mpz_urandomb, mpf_urandomb): Add prototype. (gmp_rand_init, gmp_rand_clear): Add prototype. * tests/rand/gen.c, stat.c, statlib.c, statlib.h: New files. * tests/rand/Makefile, tests/rand/ChangeLog: New files. 1999-03-15 Torbjorn Granlund * .gdbinit: New file. * mpz/dump.c: New file. * mpz/Makefile.in: Compile dump.c. * make.bat: Likewise. * gmp.h (mpz_dump): Declare. 1999-03-14 Torbjorn Granlund * mpz/tests/reuse.c: Also test mpz_invert and mpz_divexact. * mpz/tests/convert.c: Update to GMP 2 variable syntax. 1999-03-13 Torbjorn Granlund * mpf/README: New file. * mpz/README: New file. * mpf/pow_ui.c: New file. * mpf/Makefile.in: Compile pow_ui.c. * make.bat: Likewise. * gmp.h (mpf_pow_ui): Declare. 1999-03-12 Torbjorn Granlund * mpn/configure.in: Stage 1 of rewrite. * mpn/underscore.h: New name for bsd.h. * mpn/sysv.h: Deleted. * mpn/m68k/*: Don't include sysdep.h. * mpn/pa64/README: New file. 1999-03-11 Torbjorn Granlund * mpn/powerpc32/add_n.S: Add support for both AIX and ELF syntax. Renamed from `.s'. * mpn/powerpc32/sub_n.S: Likewise. * mpn/powerpc32/lshift.S: Likewise. * mpn/powerpc32/rshift.S: Likewise. * mpn/powerpc32/mul_1.S: Likewise. * mpn/powerpc32/addmul_1.S: Likewise. * mpn/powerpc32/submul_1.S: Likewise. * mpn/powerpc32/umul.S: New file. * mpn/sparc32/v8/umul.S: New file. * mpn/sparc32/umul.S: New file. * mpn/x86/umul.S: New file. * mpn/x86/udiv.S: New file. * mpn/Makefile.in (mul_basecase.o): Delete rule. 1999-02-22 Torbjorn Granlund * configure.in (hppa2.0*-*-*): Force use of GCC. * extract-dbl.c: Handle IEEE denormalized numbrs. Clean up. 1998-12-02 Torbjorn Granlund * mpn/Makefile.in (CCAS): New macro. (.s.o): Use CCAS. (.S.o): Likewise. * mpn/Makefile.in (mul_basecase.o): Add dependency. (sqr_basecase.o): Likewise. (mod_1.o): Likewise. * demos/pexpr.c (cputime): Test also __hpux. (cleanup_and_exit): Check SIGXCPU only #ifdef LIMIT_RESOURCE_USAGE. * mpz/tests/t-2exp.c: Use urandom, not random. * mpn/configure.in (arm*-*-*): New alternative. 1998-11-30 Torbjorn Granlund * gmp-impl.h (union ieee_double_extract): Special case for little-endian arm. (LIMBS): Alias for PTR. 1998-11-26 Torbjorn Granlund * longlong.h (m68000 umul_ppmm): Use `muluw', not `mulu'. (m68k stuff): Clean up; add coldfire support. 1998-11-23 Torbjorn Granlund * mpn/mips3/gmp-mparam.h (KARATSUBA_MUL_THRESHOLD): #define. (KARATSUBA_SQR_THRESHOLD): #define. * mpn/sparc32/v9/README: New file. 1998-11-20 Torbjorn Granlund * mpn/x86/README: New file. * mpn/arm/gmp-mparam.h: New file. * mpn/pa64/gmp-mparam.h: New file. * mpn/hppa/gmp-mparam.h: New file. * mpn/x86/pentium/gmp-mparam.h: New file. * mpn/sparc32/v9/gmp-mparam.h: New file. * mpn/powerpc32/gmp-mparam.h: New file. * mpn/x86/p6/gmp-mparam.h: New file. * mpn/alpha/gmp-mparam.h (KARATSUBA_MUL_THRESHOLD): #define. (KARATSUBA_SQR_THRESHOLD): #define. * mpn/configure.in: Point to x86/p6 when appropriate. * mpn/power/umul.s: New file. * mpn/power/sdiv.s: New file. * mpn/pa64/addmul_1.S: New file. * mpn/pa64/submul_1.S: New file. * mpn/pa64/mul_1.S: New file. * mpn/pa64/udiv_qrnnd.c: New file. * mpn/pa64/umul_ppmm.S: New file. * mpn/mips2/umul.s: New file. * mpn/m68k/mc68020/umul.s: New file. * mpn/m68k/mc68020/udiv.s: New file. * mpn/hppa/hppa1_1/umul.s: New file. * mpn/alpha/umul.s: New file. * mpn/a29k/udiv.s: New file. * mpn/a29k/umul.s: New file. 1998-11-17 Torbjorn Granlund * mpn/x86/mul_basecase.S: New file for non-pentiums. * mpn/x86/mul_basecase.S: Move to mpn/x86/pentium. 1998-11-16 Torbjorn Granlund * make.bat: Compile mul_basecase.c and sqr_basecase.c. 1998-11-10 Torbjorn Granlund * mpz/invert.c: Defer writing to parameter `invert' until end. 1998-11-03 Torbjorn Granlund * mpn/pa64/udiv_qrnnd.c: Handle more border cases. 1998-10-29 Torbjorn Granlund * insert-dbl.c: Special case biased exponents < 1; Get boundary for Inf right. * longlong.h (COUNT_LEADING_ZEROS_NEED_CLZ_TAB): New #define. 1998-10-28 Torbjorn Granlund * mpn/powerpc32/submul_1.s: Rewrite, optimizing for PPC604. * mpn/powerpc32/addmul_1.s: Likewise. * mpn/powerpc32/lshift.s: Likewise. 1998-10-23 Torbjorn Granlund * config/mt-sprc9-gcc (XCFLAGS): Add -Wa,-xarch=v8plus. * mpn/sparc32/v9/submul_1.s: New file. 1998-10-21 Torbjorn Granlund * mpn/config/mt-pa2hpux: New file. * mpn/configure.in (hppa2.0*-*-*): Use new 64-bit code. * config.sub: Recognize hppa2.0 as CPU type. * longlong.h (64-bit hppa): Add umul_ppmm and udiv_qrnnd. * mpn/pa64/mul_1.S: New file. * mpn/pa64/addmul_1.S: New file. * mpn/pa64/submul_1.S: New file. * mpn/pa64/umul_ppmm.S: New file. * mpn/pa64/udiv_qrnnd.c: New file. 1998-10-20 Torbjorn Granlund * mpz/pprime_p.c: Pass 1L, not 1, to mpz_cmp_ui. * mpz/fdiv_q_2exp.c: Cast `long' argument to `mp_limb_t' for mpn calls. * mpz/gcd_ui.c: Likewise. * mpz/add_ui.c: Likewise. * mpz/sub_ui.c: Likewise. 1998-10-19 Torbjorn Granlund * mpn/generic/bdivmod.c: Avoid using switch statement with mp_limb_t index. 1998-10-17 Torbjorn Granlund * mpn/sparc32/v9/mul_1.s: Misc cleanups. * mpn/sparc32/v9/addmul_1.s: Misc cleanups. 1998-10-16 Torbjorn Granlund * mpn/tests/{add,sub,}mul_1.c: Print xlimb using mpn_print. * mpz/tests/t-powm.c (SIZE): Increase to 50. (EXP_SIZE): New parameter; use it for computing exp_size. 1998-10-15 Torbjorn Granlund * mpn/generic/divrem_newt.c: Use TMP_ALLOC interface. * mpn/generic/sqrtrem.c: Check BITS_PER_MP_LIMB before defining assembly variants of SQRT. 1998-10-14 Torbjorn Granlund * mpn/tests: Clean up timing routines. Don't include longlong.h where it is not needed. (mpn_print): Handle printing when _LONG_LONG_LIMB. * mpn/tests/{add,sub,}mul_1.c: Generate xlimb with mpn_random2 and do it whether TIMES != 1 or not. * mpn/generic/mul_n.c: Delay assignment of `sign' for lower register pressure. * mpn/sparc32/v9/mul_1.s: New file. * config/mt-sprc9-gcc: New file. * configure.in: Use it. * mpn/configure.in: Use sparc64 for Solaris 2.7 and later with a sparc v9 CPU. * mpn/configure.in: Use sparc32/v9 for Solaris 2.6 or earlier with a sparc v9 CPU. * mpf/sub.c: In initial code for ediff == 0, limit precision before jumping to `normalize'. 1998-10-13 Torbjorn Granlund * mpn/hppa/hppa2_0/add_n.s: New file. * mpn/hppa/hppa2_0/sub_n.s: New file. * mpn/configure.in: Handle hppa2.0 (32-bit code for now). * config.guess: Update from egcs 1.1. (9000/[3478]??:HP-UX:*:*): Properly return 2.0 for all known 2.0 machines. 1998-10-07 Torbjorn Granlund * mpz/root.c (mpz_root): New file. * mpz/Makefile.in: Compile it. * make.bat: Likewise. * gmp.h (mpz_root): Declare. * mpz/perfpow.c: New file. * mpz/Makefile.in: Compile it. * make.bat: Likewise. * gmp.h (mpz_perfect_power_p): Declare. * mpz/remove.c: New file. * mpz/Makefile.in: Compile it. * make.bat: Likewise. * gmp.h (mpz_remove): Declare. * mpz/bin_ui.c: New file. * mpz/Makefile.in: Compile it. * make.bat: Likewise. * gmp.h (mpz_bin_ui): Declare. * mpz/bin_uiui.c: New file. * mpz/Makefile.in: Compile it. * make.bat: Likewise. * gmp.h (mpz_bin_uiui): Declare. 1998-09-16 Torbjorn Granlund * longlong.h: Test for __powerpc__ in addition to _ARCH_PPC. Sat Sep 5 17:22:28 1998 Torbjorn Granlund * mpf/cmp_si.c: Compare most significant mantissa limb before trying to deduce anything from the limb count. * mpf/cmp_ui.c: Likewise. Tue Aug 18 10:24:39 1998 Torbjorn Granlund * mpz/pprime_p.c (mpz_probab_prime_p): Add new code block for doing more dividing. Sat Aug 15 18:43:17 1998 Torbjorn Granlund * mpn/generic/divrem_newt.c: New name for divrem_newton.c. * mpn/Makefile.in: Corresponding changes. * mpn/configure.in: Likewise. Wed Aug 12 23:07:09 1998 Torbjorn Granlund * config.guess: Handle powerpc for NetBSD. Tue Jul 28 23:10:55 1998 Torbjorn Granlund * mpz/fib_ui.c: New file. * mpz/Makefile.in: Compile it. * make.bat: Likewise. * gmp.h (mpz_fib_ui): Declare. Wed Jun 17 22:52:58 1998 Torbjorn Granlund * make.bat: Fix typo, `asm-synt.h' => `asm-syntax.h'. Wed Jun 3 11:27:32 1998 Torbjorn Granlund * config/mt-pwr: New file. * config/mt-ppc: New file. * configure.in: Use the new files. Tue Jun 2 13:04:17 1998 Torbjorn Granlund * mpn/sparc32/v9/addmul_1.s: New file. * mpn/config/mt-sprc9: New file. * mpn/configure.in: Use mt-sprc9. Tue May 26 11:24:18 1998 Torbjorn Granlund * demos/factorize.c (factor_using_pollard_rho): Pass correct parameters in recursive calls; join the two recursion arms. * mpf/set_q.c: Set result sign. When normalizing the numerator, don't allow it to increase in size beyond prec. Tue May 19 17:28:14 1998 Torbjorn Granlund * demos/factorize.c (factor_using_division): Call fflush also for the factor 2. Mon May 18 15:51:01 1998 Torbjorn Granlund * make.bat: Pass -fomit-frame-pointer. Do not pass -g. Tue May 5 01:42:50 1998 Torbjorn Granlund * mpz/Makefile.in (LOCAL_CC): Remove definition. * gmp.h: Get rid of GMP_SMALL stuff. * mpz/Makefile.in: Likewise. * mpq/Makefile.in: Likewise. * mpf/Makefile.in: Likewise. * mpz/invert.c: Fix typo in comment. Mon May 4 23:05:32 1998 Torbjorn Granlund * mpn/generic/sqrtrem.c: Check that __arch64__ is not defined before defining sparc SQRT. Mon Apr 20 19:16:17 1998 Torbjorn Granlund * mpn/generic/gcdext.c: Allow gp to be NULL. 1998-04-03 Torbjorn Granlund * mpn/configure.in: Recognize `alphaev5*', not `alphaev5'. * config.guess: Handle CPU variants for NetBSD. Mon Mar 16 13:07:54 1998 Torbjorn Granlund * mpz/pprime_p.c: Use mpn_mod_1/mpn_preinv_mod_1 for computing mod PP, not mpz_tdiv_r_ui (which expects an `unsigned long'). (mpz_probab_prime_p): Change type of `r' to mp_limb_t. Thu Mar 12 17:19:04 1998 Torbjorn Granlund * gmp.h (mpf_ceil, mpf_floor, mpf_trunc): Add declarations. * config.guess: Update from FSF version. * config.sub: Likewise. * config.guess: Add special handling of alpha-*-NetBSD. Wed Mar 11 00:55:34 1998 Torbjorn Granlund * mpz/inp_str.c: Update from set_str.c. Properly increment `nread' when skipping minus sign. * mpz/set_str.c: Check for empty string after having skipped leading zeros. Mon Mar 9 19:28:00 1998 Torbjorn Granlund * mpz/set_str.c: Skip leading zeros. Wed Mar 4 19:29:16 1998 Torbjorn Granlund * gmp.h (mpz_cmp_si): Cast argument before calling mpz_cmp_ui. * demos/factorize.c: Rewrite. 1998-02-04 Torbjorn Granlund * configure.in (i[3456]86* etc): Check if using gcc before choosing mt-x86. * configure.in (m68*-*-*): New alterantive. * config/mt-m68k: New file. * mpn/alpha/invert-limb.s: Put tables in text segment, since not all systems support "rdata". Wed Feb 4 02:20:57 1998 Torbjorn Granlund * gmp.h (__GNU_MP_VERSION_SNAP): New #define. (__GNU_MP_VERSION_MINOR): Now 1. Wed Jan 28 22:29:36 1998 Torbjorn Granlund * longlong.h (alpha udiv_qrnnd): #define UDIV_NEEDS_NORMALIZATION. Wed Jan 28 20:28:19 1998 Torbjorn Granlund * mpz/pprime_p.c (mpz_probab_prime_p): Delete 59 from tried divisors. Mon Jan 26 01:39:02 1998 Torbjorn Granlund * mpz/pprime_p.c (mpz_probab_prime_p): Major overhaul: Check small numers specifically; check small factors, then perform a fermat test. Tue Jan 13 14:58:28 1998 Torbjorn Granlund * longlong.h (alpha udiv_qrnnd): Call __mpn_invert_normalized_limb and udiv_qrnnd_preinv. Wed Jan 7 01:52:54 1998 Torbjorn Granlund * mpn/configure.in (alpha*, extra_functions): Add invert-limb and remove udiv_qrnnd. * mpn/tests/divrem.c: Get allocations right. * mpn/generic/divrem.c: Conditionally pre-invert most significant divisor limb. Tue Jan 6 23:08:54 1998 Torbjorn Granlund * mpn/generic/divrem_1.c: Rename variables to comply to conventions. Make `i' have type `mp_size_t'. Tue Dec 30 22:21:42 1997 Torbjorn Granlund * mpz/tdiv_qr_ui.c: Return the remainder. * mpz/tdiv_r_ui.c: Likewise. * mpz/tdiv_q_ui.c: Likewise. * gmp.h: Change return type of mpz_tdiv_qr_ui, mpz_tdiv_r_ui, mpz_tdiv_q_ui. * mpz/tdiv_ui.c: New file. * mpz/Makefile.in: Compile it. * make.bat: Likewise. * gmp.h (mpz_tdiv_ui): Declare. Fri Nov 7 04:21:15 1997 Torbjorn Granlund * mpf/integer.c (FUNC_NAME): Fix bogus test for mpf_trunc. * demos/isprime.c: New file. Sat Nov 1 19:32:25 1997 Torbjorn Granlund * mpz/cmp_abs.c: New file. * mpz/Makefile.in: Compile it. * make.bat: Likewise. * gmp.h (mpz_cmp_abs): Declare. * mpz/cmp_abs_ui.c: New file. * mpz/Makefile.in: Compile it. * make.bat: Likewise. * gmp.h (mpz_cmp_abs_ui): Declare. Sat Sep 27 04:49:52 1997 Torbjorn Granlund * mpz/fdiv_r_2exp.c: Get allocation for `tmp' right. * mpz/fdiv_q_2exp.c: In final result adjustment code, handle that intermediate result is zero. * mpz/tests/t-2exp.c: New file. * mpz/tests/Makefile.in: Handle t-2exp.c. Fri Sep 26 16:29:21 1997 Torbjorn Granlund * mpz/divexact.c: Fix typo in test for whether to copy numerator to quotient and move that statement to after handling quotient and denominator overlap. Misc cleanups. * mpn/generic/gcd.c: Change count argument of mpn_lshift/mpn_rshift calls to `unsigned int'. * mpz/divexact.c: Likewise. Mon Sep 22 02:19:52 1997 Torbjorn Granlund * mpz/tests/t-powm.c: Decrease `reps' to 2500. * mpz/tests/t-pow_ui.c: New file. * mpz/tests/Makefile.in: Handle t-pow_ui.c. * mpz/ui_pow_ui.c: Get special cases for exponent and base right. * mpz/pow_ui.c: Increase temp space allocation by 1 limb. Split `rsize' into two variables; compute space allocation into `ralloc'. Sun Sep 7 04:15:12 1997 Torbjorn Granlund * mpn/pa64/lshift.s: New file. * mpn/pa64/rshift.s: New file. * mpn/pa64/sub_n.s: New file. Sat Sep 6 19:14:13 1997 Torbjorn Granlund * mpn/pa64/add_n.s: New file. * mpn/pa64: New directory. Tue Aug 19 16:17:09 1997 Torbjorn Granlund * mpz/swap.c: New file. * mpz/Makefile.in: Compile it. * make.bat: Likewise. * gmp.h (mpz_swap): Declare. * mpn/generic/mul_n.c: Push assignment of x and y pointers into the if/else clauses in several places. (Decreases register pressure.) Mon Aug 18 03:29:50 1997 Torbjorn Granlund * mpn/thumb/add_n.s: New file. * mpn/thumb/sub_n.s: New file. * mpn/arm/add_n.s: New file. * mpn/arm/sub_n.s: New file. * mpz/powm.c: After mpn_mul_n and mpn_mul calls, adjust product size if most significant limb is zero. * mpz/powm_ui.c: Likewise. Fri Aug 15 02:13:57 1997 Torbjorn Granlund * mpn/arm/m/mul_1.s: New file. * mpn/arm/m/addmul_1.s: New file. * mpn/powerpc32/mul_1.s: Rewrite. * mpn/alpha/mul_1.s: Prefix labels with `.'. Mon Aug 11 02:37:16 1997 Torbjorn Granlund * mpn/powerpc32/add_n.s: Rewrite. * mpn/powerpc32/sub_n.s: Rewrite. Sun Aug 10 17:07:15 1997 Torbjorn Granlund * mpn/powerpc32/addmul_1.s: Delete obsolete comments. * mpn/powerpc32/submul_1.s: Likewise. Fri Jul 25 20:07:54 1997 Torbjorn Granlund * mpz/addmul_ui.c: New file. * mpz/Makefile.in: Compile it. * make.bat: Likewise. * gmp.h (mpz_addmul_ui): Declare. * mpz/setbit.c: Add missing code after final `else'. Tue Jul 22 17:45:01 1997 Torbjorn Granlund * mpn/sh/add_n.s: Fix typo. * mpn/sh/sub_n.s: Likewise. * longlong.h (ns32k count_trailing_zeros): Fix typo. * insert-dbl.c: Check for exponent overflow and return Inf. * mpz/get_d.c: Rewrite to avoid rounding errors. Thu May 29 11:51:07 1997 Torbjorn Granlund * mpq/add.c: Swap some usages of tmp1 and tmp2 to make sure their allocation suffices. * mpq/sub.c: Likewise. Wed Apr 16 02:24:25 1997 Torbjorn Granlund * demos/pexpr.c: New file. * mpn/generic/mul_n.c: Misc optimizations from Robert Harley. * gmp-impl.h (MPZ_PROVOKE_REALLOC): New #define. Sat Apr 12 17:54:04 1997 Torbjorn Granlund * mpz/tstbit.c: New file. * mpz/Makefile.in: Compile it. * make.bat: Likewise. * gmp.h (mpz_tstbit): Declare. * mpz/tests/logic.c: Use MPZ_CHECK_FORMAT. * mpz/tests/bit.c: New test. * mpz/tests/Makefile.in: Handle bit.c. * mpz/ior.c: In -OP2,+OP1 case, normalize OP2 after call to mpn_sub_1. * gmp-impl.h (MPZ_CHECK_FORMAT): New #define. Thu Apr 10 00:30:14 1997 Torbjorn Granlund * longlong.h (POWER/PowerPC): Test _ARCH_PWR instead of _IBMR2. Wed Apr 9 18:23:31 1997 Torbjorn Granlund * gmp-impl.h: Move defaulting of UMUL_TIME and UDIV_TIME from here... * longlong.h: ...to here. Sun Mar 30 12:16:23 1997 Torbjorn Granlund * mpn/generic/next_prime.c: New file. * mpn/generic/perfsqr.c: Remove definitions of PP and PP_INVERTED. * gmp-impl.h: Put them here. Fri Mar 28 08:18:05 1997 Torbjorn Granlund * gmp-impl.h (MPN_COPY_INCR, MPN_COPY_DECR): Define as inline asm for for x86, but leave disabled for now. Fri Feb 28 02:39:47 1997 Torbjorn Granlund * mpn/Makefile.in (.S.o): Pass SFLAGS and CFLAGS also to compiler for assembly phase. (.s.o): Pass SFLAGS. Wed Feb 26 06:46:08 1997 Torbjorn Granlund * mpn/configure.in: For Pentium Pro, use default code, not Pentium optimized code. * mpn/x86/addmul_1.S: Unroll and optimize for Pentium Pro. * mpn/x86/submul_1.S: Likewise. Thu Feb 13 08:26:09 1997 Torbjorn Granlund * mpf/Makefile.in: Compile floor.o, ceil.o and trunc.o (from integer.c). * make.bat: Likewise. Wed Feb 5 05:58:44 1997 Torbjorn Granlund * mpn/configure.in (alpha*): Add cntlz to extra_functions. Wed Feb 4 03:30:45 1997 Torbjorn Granlund * mpf/integer.c: New file (supporting mpf_floor, mpf_ceil, mpf_trunc). Mon Feb 3 14:21:36 1997 Torbjorn Granlund * make.bat: Fix typo, set_dfl_prc => set_dfl_prec. Sun Feb 2 02:34:33 1997 Torbjorn Granlund * mpf/out_str.c: After outputting `-', decrement n_digits. Wed Jan 8 02:50:20 1997 Torbjorn Granlund * mpn/generic/divrem.c: qextra_limbs => qxn. Wed Dec 18 07:50:46 1996 Torbjorn Granlund * mpz/tests/t-tdiv.c (SIZE): Increase to 200. Tue Dec 17 19:32:48 1996 Torbjorn Granlund * mpn/generic/divrem.c (mpn_divrem_classic): New name for mpn_divrem. * gmp.h (mpn_divrem): New function. * mpn/generic/divrem_newton.c: New file. * mpn/configure.in (functions): Add divrem_newton. * make.bat: Likewise. Thu Dec 12 17:55:13 1996 Torbjorn Granlund * gmp.h (_GMP_H_HAVE_FILE): Test also __dj_include_stdio_h_. Sat Dec 7 09:40:06 1996 Torbjorn Granlund * mpn/alpha/invert-limb.s: New file. Thu Dec 5 01:25:31 1996 Torbjorn Granlund * mpz/ui_pow_ui.c (mpz_pow2): New (static) function. (mpz_ui_pow_ui): Rewrite. * make.bat: `pre_mod_1.c' => `pre_mod_.c'. Fix typo in path to gmp-mpar.h. Fri Nov 15 00:49:55 1996 Torbjorn Granlund * mpz/ui_pow_ui.c: Rewrite for better speed. Fri Nov 1 16:36:56 1996 Torbjorn Granlund * Makefile.in (recursive make rules): Use `&&' instead of `;' as delimiter. Fri Oct 25 17:12:36 1996 Torbjorn Granlund * gmp-impl.h (Cray/uxp MPN_COPY): Really declare as inline. Thu Oct 24 15:08:19 1996 Torbjorn Granlund * mpn/fujitsu/rshift.c: Fix typo in loop boundaries. Fri Oct 18 03:13:54 1996 Torbjorn Granlund * mpn/configure.in: Recognize `nextstep' for m68k variants; likewise for x86 variants. * mpn/x86/syntax.h (INSND): New macro. * mpn/x86/[lr]shift.S: Use INSND. * mpn/x86/pentium/[lr]shift.S: Likewise. * mpn/config/t-oldgas (SFLAGS): Pass -DOLD_GAS. * gmp-impl.h: In code for determining endianess, test also __BIG_ENDIAN__ and __hppa__. Remove test of __NeXT__. Wed Oct 16 03:50:34 1996 Torbjorn Granlund * mpf/set_str.c: Let `prec' determine precision used in exponentiation code; decrease allocation accordingly. * mpn/vax: Change `jsob*' to `sob*' in all files. Tue Oct 15 03:54:06 1996 Torbjorn Granlund * longlong.h (m88110 udiv_qrnnd): Change type of intermediate quotient to DImode (divu.d generates a 64-bit quotient). * configure.in (m88110*): Fix typo. * mpf/get_str.c: Compute exp_in_base using `double' to avoid overflow. * gmp-impl.h (struct bases): Change type of chars_per_bit_exactly from float to double. * mpn/mp_bases.c (__mp_bases): Give 17 digits for chars_per_bit_exactly field. * mpf/get_str.c: Let `prec' determine precision used in exponentiation code; decrease allocation accordingly. Sun Oct 13 03:31:53 1996 Torbjorn Granlund * longlong.h: Major cleanup. (__udiv_qrnnd_c): Compute remainders using multiply and subtract, not explicit `%' operator. (C umul_ppmm): Get rid of a redundant __ll_lowpart. * mpz/invert.c: Properly detect all operands that would yield an undefined inverse; make sure the inverse is always positive. * mpz/xor.c: New file. * mpz/Makefile.in: Compile it. * make.bat: Likewise. * gmp.h (mpz_xor): Declare. * mpz/tests/logic.c: Also test mpz_xor. * mpz/lcm.c: Special case for when either operand equals 0. Sat Oct 12 01:57:09 1996 Torbjorn Granlund * mpn/generic/gcd.c (find_a): Don't inline on x86. * Makefile.in (CFLAGS): Default to just `-g'. * configure.in: Recognize 386 and 486 wherever other x86 cpus are recognized. * configure.in: Use mt-x86 for all x86 cpus. * config/mt-x86: New file. * mpn/alpha/cntlz.s: New file. Tue Oct 8 00:16:18 1996 Torbjorn Granlund * longlong.h: Define smul_ppmm for Fujitsu vpp/uxp. Rewrite umul_ppmm to actually work on the hardware. * mpn/x86/sub_n.S: Avoid parens around displacement of `leal'. * mpn/x86/add_n.S: Likewise. * mpn/x86/syntax.h (R): Define differently depending on __STDC__. Mon Oct 7 16:48:08 1996 Torbjorn Granlund * longlong.h: Don't test for __NeXT__ in outer 68k conditional; add test for __m68k__. Sun Oct 6 00:59:09 1996 Torbjorn Granlund * gmp.h: Declare mpn_random. * make.bat: Compile mpn/generic/random.c. * longlong.h: Define umul_ppmm for Fujitsu vpp/uxp. * gmp-impl.h: Protect definitions using `__attribute__ ((mode (...)))' with test also for __GNUC_MINOR__. * gmp.h: Don't define macros using __builtin_constant_p when using NeXT's compiler. Fri Oct 4 16:53:50 1996 Torbjorn Granlund * mpz/lcm.c: New file. * mpz/Makefile.in: Compile it. * make.bat: Likewise. * gmp.h (mpz_lcm): Declare. Wed Sep 25 00:06:21 1996 Torbjorn Granlund * mpq/tests/t-cmp_ui.c: Make sure numerator and denominator of `b' is within limits of an `unsigned long int'. * mpz/tests/t-powm_ui.c: Change type of exp2 to `unsigned long int'. Tue Sep 24 18:58:20 1996 Torbjorn Granlund * mpz/powm_ui.c: Make result always positive. * urandom.h (urandom): Make it return mp_limb_t. * gmp-impl.h (CNST_LIMB): New macro. * mpn/mp_bases.c: Use CNST_LIMB. * mpn/generic/hamdist.c (popc_limb): Likewise. * mpn/generic/popcount.c (popc_limb): Likewise. * mpn/generic/perfsqr.c: Likewise. Fri Sep 20 03:08:10 1996 Torbjorn Granlund * mpz/pprime_p.c: When n <= 3, don't clear out n before using it. Wed Sep 18 11:22:45 1996 Torbjorn Granlund * mpn/fujitsu/mul_1.c: New file. * mpn/fujitsu/addmul_1.c: New file. * mpn/fujitsu/sub_n.c: New file. * mpn/fujitsu/add_n.c: Mew file. Sun Sep 15 03:13:02 1996 Torbjorn Granlund * mpn/generic/random.c: New file. * mpn/configure.in (functions): Add `random'. * gmp-impl.h (MPN_COPY): Define as annotated inline function for Crays and Fujitsu VPPs. * gmp.h (mp_size_t): Define as `int' for non-MPP Cray. (mp_exp_t): Likewise. * configure.in: Add support for Fujitsu VPP machines. * mpn/configure.in: Likewise. * config.guess: Likewise. * config.sub: Likewise. * mpn/fujitsu/rshift.c: New file. * mpn/fujitsu/lshift.c: New file. * mpn/fujitsu: New directory, for Fujitsu VPP machines. Wed Sep 11 11:34:38 1996 Torbjorn Granlund * mpn/generic/mul_n.c (__gmpn_mul_n): New name for impn_mul_n. Call __gmpn_mul_basecase, not impn_mul_n_basecase; update parameter list to work with __gmpn_mul_basecase. (__gmpn_sqr): New name for impn_sqr_n. Call __gmpn_sqr_basecase, not impn_sqr_n_basecase; update parameter list to work with __gmpn_sqr_basecase. (mpn_mul_n): Update calls to match new names and parameter conventions. * gmp-impl.h (MPN_MUL_N_RECURSE): Likewise. (MPN_SQR_RECURSE): New name for MPN_SQR_N_RECURSE. Update calls to match new names and parameter conventions. * mpn/generic/mul.c: Never perform multiply explicitly here, call __gmpn_mul_basecase instead. Update calls to match new names and parameter conventions. * mpn/x86/mul_basecase.S: New file. * mpn/generic/mul_basecase.c: New file. * mpn/generic/sqr_basecase.c: New file. Wed Sep 4 02:59:21 1996 Torbjorn Granlund * mpz/set_str.c: Let `0b' and `0B' mean base 2. Fri Aug 30 00:44:00 1996 Torbjorn Granlund * longlong.h (x86 umul_ppmm): Work around GCC bug that was triggered by Aug 28 change. * mpbsd/min.c (digit_value_in_base): New function. * mpz/set_str.c: Refine allocation size computation, use chars_per_bit_exactly instead of chars_per_limb. * mpbsd/Makefile.in (.c.o): Add -D_mpz_realloc=_mp_realloc. Wed Aug 28 02:52:14 1996 Torbjorn Granlund * longlong.h (x86 umul_ppmm): Don't cast result operands. (x86 udiv_qrnnd): Likewise. (default smul_ppmm): Fix typo, umul_ppmm => smul_ppmm. (default umul_ppmm): New #define using smul_ppmm. (vax smul_ppmm): New #define. (vax umul_ppmm): Delete. (POWER umul_ppmm): Delete. (IBM 370 smul_ppmm): New #define. (IBM 370 umul_ppmm): Delete. (IBM RT/ROMP smul_ppmm): New #define. (IBM RT/ROMP umul_ppmm): Delete. Tue Aug 27 01:03:25 1996 Torbjorn Granlund * gmp-impl.h (__gmp_0): Make it `const'. * mpn/Makefile.in (clean mostlyclean): Comment out recursive clean of `tests'. * mpn/generic/mul.c: Identify when we do squaring, and call impn_sqr_n_basecase/impn_sqr_n as appropriate. Use KARATSUBA_MUL_THRESHOLD and KARATSUBA_SQR_THRESHOLD. Don't #define KARATSUBA_THRESHOLD. * mpn/generic/mul_n.c: Don't #define KARATSUBA_THRESHOLD. (impn_mul_n, impn_sqr_n): Rewrite, based on code contributed by Robert Harley. (impn_sqr_n_basecase): Rewrite. * gmp-impl.h (KARATSUBA_MUL_THRESHOLD): New #define. (KARATSUBA_SQR_THRESHOLD): Likewise. (MPN_SQR_N_RECURSE): Use KARATSUBA_SQR_THRESHOLD. (MPN_MUL_N_RECURSE): Use KARATSUBA_MUL_THRESHOLD. * configure.in: Fix typo in last change. Mon Aug 26 22:25:18 1996 Torbjorn Granlund * mpn/generic/random2.c: Fix typo, `alpha__' => `__alpha'. * mpf/random2.c: Likewise. Sun Aug 25 00:07:09 1996 Torbjorn Granlund * mpz/tests/t-mul.c: Also test squaring. Fri Aug 16 05:12:08 1996 Torbjorn Granlund * mp_clz_tab.c (__clz_tab): Declare as `const'. * version.c (gmp_version): Likewise. * mpn/generic/sqrtrem.c (even_approx_tab, odd_approx_tab): Likewise. Thu Aug 15 02:34:47 1996 Torbjorn Granlund * gmp.h: Fix typo, `mips__' => `__mips'. * mpf/set_str.c: Allow a number to start with a period, if next position contains a digit. Tue Aug 13 18:41:25 1996 Torbjorn Granlund * mpz/gcdext.c: Get cofactor sign right for negative input operands. Clean up code for computing tt. * mpz/invert.c: Get rid of variable `rv'. * mpz/divexact.c: Test for zero divisor in special case for zero dividend. Mon Aug 12 18:04:07 1996 Torbjorn Granlund * mpz/?div_*_ui.c: Special case for division by 0. * mpz/tdiv_q.c: Likewise. Sat Aug 10 14:45:26 1996 Torbjorn Granlund * mpz/dmincl.c: Special case for division by 0. * mpz/tdiv_*_ui.c: Delete special case for dividend being 0; handle it when computing size after mpn_divmod_1 call. * mp_bpl.c: (__gmp_junk): New variable. (__gmp_0): New constant. * gmp-impl.h (DIVIDE_BY_ZERO): New #define. Fri Aug 9 20:03:27 1996 Torbjorn Granlund * mpz/divexact.c: Test for dividend being zero before testing for small divisors. Thu Aug 8 13:20:23 1996 Torbjorn Granlund * configure.in: Require operating system specification for cpus where assembly syntax differs between system. * Makefile.in (many targets): Change `-' action prefix to `@'. * mpn/Makefile.in: (distclean): Fix typo. * mpq/cmp_ui.c: Rename function to _mpq_cmp_ui. (mpq_cmp_ui): #undef deleted. * mpz/cmp_si.c: Rename function to _mpz_cmp_si. (mpz_cmp_si): #undef deleted. * mpz/cmp_ui.c: Rename function to _mpz_cmp_ui. (mpz_cmp_ui): #undef deleted. * Makefile.in: Corresponding changes. * mpf/get_prc.c: Return the *highest* precision achievable. * mpf/get_str.c: Complete rewrite. * mpf/set_str.c (swapptr): New #define. (assert): New #define. * mpf/set_str.c: Set prec to one more than the saved _mp_prec. Misc cleanups. * mpz/set_str.c: #include string.h. * mpf/out_str.c: #include string.h. * mpbsd/xtom.c: #include string.h and ctype.h. * mpbsd/mout.c: #include string.h. Wed Aug 7 11:46:04 EDT 1996 Ken Weber * mpn/generic/gcd.c: Reorder mpn_gcd argument list. * mpz/gcd.c: Change call to mpn_gcd. * gmp.texi: Update manual entry on mpn_gcd. * mpn/generic/bdivmod.c: Delete limb cache to make mpn_bdivmod reentrant. Wed Aug 7 02:15:38 1996 Torbjorn Granlund * mpf/get_str.c: Rewrite code for converting integral part of a number with both an integral and fractional part. * mpf/set_str.c: Get rid of variable xxx. New variables madj and radj. In exp_in_base==0 case, add madj to msize for EXP field. * mpz/tests/t-gcd.c: Test deleted. Rename t-gcd2.c to t-gcd.c. Increase reps to 2000. * mpz/tests/t-gcd2.c: Get rid of mpz_refgcd. * mpf/set_str.c: Ignore excess limbs in MP,MSIZE. Thu Jul 25 04:39:10 1996 Torbjorn Granlund * mpn/configure.in: Fix typo in setting path, "sparc" => "sparc32". Wed Jul 24 02:27:02 1996 Torbjorn Granlund * mpn/generic/gcdext.c: Reorganize and clean up. Get rid of all signed limb arithmetic. Mon Jul 22 02:39:56 1996 Torbjorn Granlund * mpn/generic/gcdext.c (mpn_gcdext): For large enough operands, work with most significant *two* limbs. (div2): New function (two variants). (THRESHOLD): New #define. * mpz/gcdext.c: Fix typo in MPZ_TMP_INIT call. * longlong.h (alpha UMUL_TIME): Now 30. (alpha UDIV_TIME): Now 350. (x86 UMUL_TIME): Now 10 (let Pentium decide). (SuperSPARC UDIV_TIME): Override default. * extract-dbl.c (MP_BASE_AS_DOUBLE): Don't redefine here. * extract-dbl.c: New name for extract-double.c. * insert-dbl.c: New name for insert-double.c. * Makefile.in: Corresponding changes. * make.bat: Likewise. * mpz/Makefile.in (.c.o): Don't pass non-portable `-f' to cp. * mpq/Makefile.in: Likewise. * mpf/Makefile.in: Likewise. Sat Jul 20 01:35:18 1996 Torbjorn Granlund * mpz/getlimbn.c: Take ABS of integer->_mp_size. * mpz/divexact.c: Use mpn_divmod_1 if divisor is a single limb. Thu Jul 18 00:31:15 1996 Torbjorn Granlund * mpn/generic/popcount.c (popc_limb): Use different masking trick for first step (due to David Seal). * mpn/generic/hamdist.c (popc_limb): Likewise. Wed Jul 17 23:21:48 1996 Torbjorn Granlund * mpn/generic/divrem.c: In MPN_COPY_DECR call, copy dsize - 1 limbs. Sun Jul 14 17:47:46 1996 Torbjorn Granlund * configure.in: Handle sparc9, sparc64, and ultrasparc like sparc8. Thu Jul 11 14:05:54 1996 J.T. Conklin * longlong.h (mc680x0): Define umul_ppmm, udiv_qrnnd, sdiv_qrnnd for the '020, '030, '040, and '332. Define count_leading_zeros for the '020, '030, '040, and '060. Sun Jul 14 15:24:53 1996 Torbjorn Granlund From Joe Keane: * mpq/equal.c: Take ABS of num1_size before passing it to mpn_cmp. Fri Jul 12 17:11:17 1996 Torbjorn Granlund * mpn/generic/sqrtrem.c (SQRT): New asm for x86, but leave it disabled for now. * mpn/generic/sqrtrem.c: Use MP_BASE_AS_DOUBLE. Wed Jul 10 03:17:45 1996 Torbjorn Granlund * cre-mparam.c: Delete obsolete file. * gmp.h: #define _LONG_LONG_LIMB if __mips && _ABIN32. * longlong.h: Test __mips instead of __mips__. Sun Jul 7 23:19:13 1996 Torbjorn Granlund * longlong.h (_PROTO): Define, unless already defined. (alpha __udiv_qrnnd): Declare using _PROTO. (hppa __udiv_qrnnd): Likewise. (sparc __udiv_qrnnd): Likewise. Mon Jul 1 01:44:30 1996 Torbjorn Granlund * config.guess: Update from master version; add Cray x90 handling. Wed Jun 26 05:35:02 1996 Torbjorn Granlund * mpn/power/add_n.s (__mpn_add_n): Work around GAS bug. * mpn/power/sub_n.s (__mpn_sub_n): Likewise. * insert-double.c: Rework loop to avoid potential overflow. * mpq/get_d.c: For vax, if qsize > N_QLIMBS, ignore excess limbs. * mpq/tests/t-get_d.c (SIZE): Special case for vax. * gmp.h (mpX_cmp_ui): #define also when ! __GNUC__. Mon Jun 24 17:13:21 1996 Torbjorn Granlund * longlong.h (vax sdiv_qrnnd): Fix typo. Sat Jun 15 01:33:33 1996 Torbjorn Granlund * gmp.h: Support `small' and `large' type and function variants, controlled by GMP_SMALL. * mpz/Makefile.in (.c.o): Compile each function twice, for small and large variant. (MPZS_OBJS): New variable. (libmpz.a): Include MPZS_OBJS in archive. * mpf/Makefile.in: Analogous changes. * mpq/Makefile.in: Analogous changes. * gmp.h: Prefix all functions with __gmp, to allow namespace-clean internal calls. * mp.h: Rip out __MP_SMALL__ stuff. (__mpz_struct): mp_size_t => int. * mpz/invert.c: #include "gmp-impl.h". Use MPZ_TMP_INIT, not mpz_init. * mpz/gcdext.c: Rewrite to call mpn_gcdext. Fri Jun 14 18:05:29 1996 Torbjorn Granlund * mpn/generic/gcdext.c (s0size): New parameter. * gmp.h (mpn_gcdext): Update prototype. * mpn/generic/gcdext.c: Major rewrite. Mon Jun 10 00:14:27 1996 Torbjorn Granlund * mpn/generic/dump.c: Add missing `else'. Fri Jun 7 03:35:12 1996 Torbjorn Granlund * Makefile.in (gmp_toc.html): Pass -expandinfo to texi2html. Thu Jun 6 19:00:53 1996 Torbjorn Granlund * Version 2.0.2 released. * install.sh: New file. * Makefile.in (INSTALL): Use install.sh. (install-normal): New name for target `install'. (install): New dummy target. * mpz/pow_ui.c: Swap tests for (e == 0) and (bsize == 0). * mpz/ui_pow_ui.c: Swap tests for (e == 0) and (blimb == 0). * config/mt-linux (AR_FLAGS): New file. * configure.in: Use config/mt-linux for all linux systems. Tue Jun 4 03:42:18 1996 Torbjorn Granlund * Version 2.0.1 released. * mpf/tests/ref.c: Cast result of TMP_ALLOC to the right pointer type. * extract-double.c: Test _GMP_IEEE_FLOATS with #if, not plain if. * insert-double.c: Don't #include stdlib.h. * gmp-impl.h (union ieee_double_extract): Test sparc and __sparc. Do not test __sparc__. * mpf/reldiff.c: Change declaration to work around irix5 compiler bug. * mpq/equal.c: Likewise. * mpn/generic/gcd.c: Delete spurious comma at end of enumeration. * mpn/generic/gcdext.c: Add K&R declaration syntax. * stack-alloc.h: Likewise. * insert-double.c: Likewise. * extract-double.c: Likewise. * mpf/tests/reuse.c: Likewise. * mpz/tests/reuse.c: Likewise. * mpf/tests/t-sub.c: Likewise. * mpf/tests/t-add.c: Likewise. * mpf/tests/t-muldiv.c: Likewise. * mpf/tests/t-conv.c: Likewise. * mpf/tests/ref.c: Likewise. * mpn/config/t-oldgas: Renamed from t-freebsd. * mpn/configure.in: Use t-oldgas for freebsd, netbsd, and some linux configurations. * mpn/powerpc32/mul_1.s: Really clear cy before entering loop. * mpn/powerpc32/*.s: Fix power/powerpc syntax issues. * mpn/config/t-ppc-aix: New file. * mpn/configure.in: Use t-ppc-aix for powerpc like t-pwr-aix for power. Wed May 29 02:07:31 1996 Torbjorn Granlund * gmp.h (mp_bits_per_limb): Change qualifier from `const' to __gmp_const. * gmp.h (mpf_init_set_str): Add `const' qualifier for 2nd parameter. * mpf/iset_str.c: Likewise. Mon May 27 00:15:58 1996 Torbjorn Granlund * gmp-impl.h: Declare __gmp_extract_double. * mpz/set_q.c: Delete unused variables. * gmp.h (mpq_equal): Declare. * mpf/eq.c: mpf_cmp2 -> mpf_eq. Fri May 24 03:20:44 1996 Torbjorn Granlund * mpz/iset_d.c: Don't include . * insert-double.c (__gmp_scale2): New name for scal2. * mpz/get_d.c: Corresponding change. * mpf/get_d.c: Likewise. * mpq/get_d.c: Likewise. * gmp-impl.h: Declare __gmp_scale2. * mpn/generic/scan0.c: Clarify comment. * mpz/set_q.c: New file. * Makefile.in: Compile it. * make.bat: Likewise. * gmp.h: Declare mpz_set_q. * insert-double.c: New file. * Makefile.in: Compile it. * make.bat: Likewise. * mpz/get_d.c: New file. * mpz/Makefile.in: Compile it. * make.bat: Likewise. * gmp.h: Declare mpz_get_d. * mpf/get_d.c: New file. * mpf/Makefile.in: Compile it. * make.bat: Likewise. * gmp.h: Declare mpf_get_d. * make.bat: Compile things in alphabetical order. * gmp-impl.h (MP_BASE_AS_DOUBLE): New #define. (LIMBS_PER_DOUBLE): New #define. * extract-double.c: New file. * Makefile.in: Compile it. * make.bat: Likewise. * mpz/set_d.c: Rewrite to use __gmp_extract_double. * mpf/set_d.c: Likewise. * mpn/configure.in: Use t-pwr-aix also for aix 3.2.4 and up. Wed May 22 02:48:35 1996 Torbjorn Granlund * gmp-impl.h: Rework code for defining ieee_double_extract. (IEEE_DOUBLE_BIG_ENDIAN): Macro removed. (_GMP_IEEE_FLOATS): New macro. * mpn/vax/gmp-mparam.h: Delete. * mpn/config/t-pwr-aix: New file. * mpn/configure.in: Use t-pwr-aix for aix 4 and later. Mon May 20 16:30:31 1996 Torbjorn Granlund * gmp.h: In code for setting _GMP_H_HAVE_FILE, test more symbols. * mpf/tests/t-add.c (oo): Add some `l' printf modifiers. * mpf/tests/t-sub.c (oo): Likewise. * mpf/tests/t-conv.c (oo): Likewise. * mpf/tests/t-sqrt.c (oo): Likewise. * mpz/tests/t-mul.c (_mpn_mul_classic): Remove unused variables. * mpn/{pyr,i960,clipper}/*.s: Add missing copyright headers. Fri May 17 02:24:43 1996 Torbjorn Granlund * mpz/set_d.c: Call _mpz_realloc. * mpq/set_z.c: New file. * mpq/Makefile.in: Compile it. * make.bat: Likewise. * gmp.h: Declare mpq_set_z. * mp?/Makefile.in (libmp?.a): Depend on Makefile, not Makefile.in. * mpf/Makefile.in (test): Delete spurious target. * mpq/Makefile.in (test): Likewise. * mpf/out_str.c: Use `e' to separate exponent when base <= 10. * mpn/configure.in: Treat ultrasparc just like sparc v8, until 64-bit compilers are ready. * mpf/set_d.c: Make it work for 64-bit machines. Thu May 16 20:53:57 1996 Torbjorn Granlund * gmp-impl.h: Set IEEE_DOUBLE_BIG_ENDIAN to 0 for little-endian machines. * mpn/x86/gmp-mparam.h: Delete file. * configure.in: Treat microsparc like sparc8. * urandom.h: Test __alpha instead of __alpha__, since the former is the standard symbol. * mpn/generic/random2.c: Likewise. * mpf/random2.c: Likewise. Tue May 14 13:42:39 1996 Torbjorn Granlund (tege@tiny.matematik.su.se) * mpz/set_f.c: New file. * mpz/Makefile.in: Compile it. * gmp.h: Declare mpz_set_f. * mpf/set_q.c: Simplify expression in rsize == nsize if-then-else arms. Tue May 14 13:03:07 1996 Torbjorn Granlund (tege@tiny.matematik.su.se) * make.bat: Add all new files. Sun May 12 22:24:36 1996 Torbjorn Granlund * mpf/set_z.c: New file. * mpf/Makefile.in: Compile it. * gmp.h: Declare mpf_set_z. Sat May 11 19:26:25 1996 Torbjorn Granlund * gmp.h: Declare mpf_set_q. * mpf/set_q.c: Compute prec-1 limbs in mpn_divrem call. Fri May 10 17:37:38 1996 Torbjorn Granlund * mpf/set_q.c: New file. * mpf/Makefile.in: Compile it. * config.sub: Recognize sparc8. Wed May 8 09:19:11 1996 Torbjorn Granlund * mpf/tests/t-dm2exp.c: New file. * mpf/tests/t-add.c: Correct header comment. * mpf/tests/t-sub.c: Likewise. * mpf/tests/t-sqrt.c: Likewise. * mpf/div.c: Misc variable name cleanups. * mpf/div_ui.c: Base more closely on mpf/div.c. * mpf/ui_div.c: Likewise. * mpz/tests/Makefile.in (check): Depend on Makefile. * mpq/tests/Makefile.in (check): Likewise. * mpf/tests/Makefile.in (check): Likewise. * mpf/tests/t-muldiv.c: New file. * mpf/tests/Makefile.in: Compile and run `t-muldiv'. (t-ref.o): Delete spurious rule. * mpf/sqrt.c: Properly detect negative input operand. * mpf/sqrt_ui.c: Delete spurious header comment. * mpf/sqrt.c: Likewise. * mpz/sqrt.c: Likewise. * mpz/tests/reuse.c (main): Read `reps' from command line. * mpf/tests/reuse.c: New file. * mpf/tests/Makefile.in: Compile and run `reuse'. * mpf/mul_ui.c: Disable code for removing low zero limbs. * mpf/div.c: Fix condition for when vp and qp overlaps. * mpf/add_ui.c: When sum equals u, copy up to prec+1 limbs. * mpf/out_str.c: Don't output '\n' after exponent. * mpf/add_ui.c: New special case for when U is completely cancelled. Wed Apr 24 05:33:28 1996 Torbjorn Granlund * Version 2.0 released. * All files: Update FSF's address. * Makefile.in (gmp_toc.html): New name for gmp.html. (TAGS): Depend on force. * mpf/tests/t-conv.c: Pass -base to mpf_set_str. Sat Apr 20 03:54:06 1996 Torbjorn Granlund * Makefile.in (ps): New target, depend on gmp.ps. Fri Apr 19 14:03:15 1996 Torbjorn Granlund * mpf/out_str.c: Print `@' before exponent, not `e'. * make.bat: Update from Makefiles. Thu Apr 18 01:22:05 1996 Torbjorn Granlund * mpf/set_str.c: If parameter `base' is negative, expect exponent to be decimal, otherwise in the same base as the mantissa. Wed Apr 17 17:28:36 1996 Torbjorn Granlund * mpf/set_dfl_prec.c: Don't return anything. * gmp.h: Corresponding changes. * mpf/set_dfl_prec.c: Use `unsigned long int' for bit counts. * mpf/init2.c: Likewise. * mpf/get_prc.c: Likewise. * mpf/set_prc.c: Likewise. * mpf/set_prc_raw.c: Likewise. * mpz/popcount.c: Likewise. * mpz/hamdist.c: Likewise. * mpz/scan1.c: Likewise. * mpz/scan0.c: Likewise. * mpn/generic/popcount.c: Likewise. * mpn/generic/hamdist.c: Likewise. * mpn/generic/scan1.c: Likewise. * mpn/generic/scan0.c: Likewise. * gmp.h: Likewise. * mpf/eq.c: New file, based on mpf/diff.c. * mpf/diff.c: Delete. * mpf/Makefile.in: Corresponding changes. * gmp.h: Likewise. * mpf/reldiff.c: New file. * mpf/Makefile.in: Compile it. * gmp.h: Declare mpf_reldiff. * mpz/iset_d.c: New file. * mpz/Makefile.in: Compile it. * gmp.h: Declare mpz_init_set_d. Tue Apr 16 16:28:31 1996 Torbjorn Granlund * Makefile.in (gmp.html): Pass -acc to texi2html. Mon Apr 15 16:20:24 1996 Torbjorn Granlund * mpf/set_str.c: Switch off code for defaulting the base from the leading characters. * gmp.h (mp?_sign): Delete. (mp?_sgn): New macros. Fri Apr 12 17:23:33 1996 Torbjorn Granlund * Makefile.in (gmp.dvi): Delete tmp.* at end of rule. Wed Apr 10 22:52:02 1996 Torbjorn Granlund (tege@tiny.matematik.su.se) * mpf/random2.c: Change of `exp' param, mp_size_t => mp_exp_t. * gmp.h: Corresponding change. * gmp.h (mp_bits_per_limb): Make it const. Sat Mar 30 01:20:23 1996 Torbjorn Granlund * configure.in: Re-enable recognition of with_gcc. * mpf/Makefile.in (.c.o): Pass XCFLAGS. * mpn/Makefile.in (.c.o): Likewise. * mpz/Makefile.in (.c.o): Likewise. * mpq/Makefile.in (.c.o): Likewise. * mpbsd/Makefile.in (.c.o): Likewise. * mpf/tests/Makefile.in (.c.o): Likewise. * mpz/tests/Makefile.in (.c.o): Likewise. * mpq/tests/Makefile.in (.c.o): Likewise. * Makefile.in (XCFLAGS): Default to empty. (FLAGS_TO_PASS): Pass on XCFLAGS. (.c.o): Pass XCFLAGS. * config/mt-m88110 (XCFLAGS): Define instead of CC. * config/mt-sprc8-gcc (XCFLAGS): Likewise. * config/mt-supspc-gcc (XCFLAGS): Likewise. * configure: Don't default CC to "gcc -O2" is -with-gcc=no was specified. Mon Mar 25 01:07:54 1996 Torbjorn Granlund * urandom.h: Test for __SVR4 in addition to __svr4__. * mp_bpl.c (mp_bits_per_limb): Declare as `const'. * Makefile.in (CFLAGS): `-O2' => `-O'. * mpn/Makefile.in (CFLAGS): Likewise. * gmp-impl.h: Get rid of obsolete field access macros. * mpn/mp_bases.c (__mp_bases): 1e39 => 1e38 to work around Solaris cc compiler bug. * gmp.h (__MPN): Make it work also for non-ANSI compilers. Thu Mar 21 01:07:54 1996 Torbjorn Granlund * mpf/sub.c: New special case for ediff <= 1 before generic code. Simplify generic code for ediff == 0. Rename uexp => exp. Mon Mar 11 18:24:57 1996 Torbjorn Granlund * mpf/tests/*.c: Use ref_mpf_sub for error calculation. * mpf/tests/Makefile.in: Link ref.o to all executables. * mpf/tests/t-sub.c: Make u = v + 1 with 50% probability. Sun Mar 10 21:03:17 1996 Torbjorn Granlund (tege@tiny.matematik.su.se) * mpf/get_str.c: In digit development loop for fractions, change loop condition from `<' to `<='. Thu Mar 7 04:58:11 1996 Torbjorn Granlund * mpn/mp_bases.c (__mp_bases): 1e100 => 1e39 to avoid overflow warning. Wed Mar 6 01:10:42 1996 Torbjorn Granlund * mpf/tests/t-sqrt.c: New file. * mpf/tests/Makefile.in: Corresponding changes. * mpf/sqrt.c: Special case for square root of zero. * mpq/add.c: Clean up variable names. * mpq/sub.c: Update from mpq/add.c. * mpz/divexact.c: abs => ABS. * mpz/gcd.c: Likewise. Rewrite final fixup code, to decrease allocation. Misc cleanups. Tue Mar 5 22:24:56 1996 Torbjorn Granlund * mpn/configure.in: Recognize linuxoldld as a synonym for linuxaout. * gmp.h (mpn_add, mpn_add_1, mpn_sub, mpn_sub_1): Add prototypes. * mpn/configure.in: Use t-freebsd also for netbsd. Mon Mar 4 15:13:28 1996 Torbjorn Granlund * mpq/Makefile.in (cmp.o): Depend on longlong.h. * mpq/equal.c: New file. * mpq/Makefile.in: Corresponding changes. * mpf/tests/t-add.c: New file. * mpf/tests/t-sub.c: Renamed from t-addsub.c. * mpf/tests/ref.c: New file. * mpf/tests/Makefile.in: Corresponding changes. * gmp-impl.h (SIZ, ABSIZ, PTR, EXP, PREC, ALLOC): New #defines. Sun Mar 3 07:45:46 1996 Torbjorn Granlund * mpf/set_str.c: In exponentiation code, allocate 3 extra limbs, not just 2. * mpf/get_str.c: Allocate sufficient space for tstr. When calculating exp_in_base, round result down. * mpf/tests/t-conv.c: New file. * mpf/tests/Makefile.in: Corresponding changes. * mp_bpl.c: New file. * gmp.h: Declare it. * Makefile.in: Corresponding changes. Sat Mar 2 06:27:56 1996 Torbjorn Granlund * mpf/set_prc_raw.c: New file. * mpf/set_prc.c: Renamed from set_prec.c. * mpf/get_prc.c: New file. * mpf/Makefile.in: Corresponding changes. * gmp.h: Declare new functions. * mpn/generic/gcdext.c: Add copyright header. Fri Mar 1 01:22:24 1996 Torbjorn Granlund * mpn/configure.in: For ppc601, search "power" before "powerpc32". * mp?/Makefile.in (AR_FLAGS): New variable. (libmp?.a): Use it. * make.bat: New file. * mpn/msdos: New directory. * mpn/msdos/asm-syntax.h: New file. * mpn/Makefile.in (distclean maintainer-clean): Delete asm-syntax.h. * config.sub: Recognize [ctj]90-cray. * mpn/configure.in: Recognize [ctj]90-cray-unicos*. * mpn/generic/gcdext.c: Don't use alloca directly, use TMP_* macros. * mpn/generic/gcd.c: Split increment from use of USIZE to avoid undefined behaviour. Thu Feb 29 04:11:24 1996 Torbjorn Granlund * Makefile.in (install-info-files): Update for new install-info behaviour. * mpn/power/add_n.s: Rewrite. * mpn/power/sub_n.s: Rewrite. Wed Feb 28 01:34:30 1996 Torbjorn Granlund * mpz/pow_ui.c: Compute allocation more aggressively for small bases. * mpz/ui_pow_ui.c: Likewise. * mpn/mp_bases.c (__mp_bases): Put huge value in 2nd field for index 1. * mpn/generic/sqrtrem.c: sizeof (mp_limb_t) => BYTES_PER_MP_LIMB. * mpn/generic/gcd.c: Likewise. (SIGN_BIT): Compute differently. Mon Feb 26 00:07:36 1996 Torbjorn Granlund * All files: mp_limb => mp_limb_t, mp_limb_signed => mp_limb_signed_t. * Makefile.in (install, install-bsdmp, install-info-files): Depend on installdirs. chmod all installed files. Sun Feb 25 01:47:41 1996 Torbjorn Granlund * mpbsd/configure.in: Delete debugging code. * All Makefile.in: Update clean targets. * Makefile.in (AR_FLAGS): New variable. (libgmp.a): Use it. (libmp.a): Likewise. * VERSION: Delete file. * Makefile.in (installdirs): New target. * mkinstalldirs: New file (from the texinfo package). * Makefile.in (INSTALL, INSTALL_DATA, INSTALL_PROGRAM): New variables. (MAKEINFO, MAKEINFOFLAGS, TEXI2DVI): New variables. (install-info): New target. (install, install-bsdmp): Depend on install-info. ($(srcdir)/gmp.info): Changed from plain gmp.info; put info files into source directory. (distclean, mostlyclean): New targets. (maintainer-clean): New name for realclean. (uninstall): New target. (TAGS): New target. (info, dvi): New targets. (.PHONY): Assign. * Makefile.in (install, install-bsdmp): Use INSTALL_DATA. * mp{n,z,f,bsd}/move-if-change: Delete. * mpbsd/Makefile.in (stamp-stddefh): Delete target. * Makefile.in (.c.o): Pass CFLAGS last. * mpbsd/Makefile.in (.c.o): Likewise. * mpf/Makefile.in (.c.o): Likewise. * mpq/Makefile.in (.c.o): Likewise. * mpz/Makefile.in (.c.o): Likewise. * mpn/Makefile.in (.c.o): Likewise. (.S.o): Likewise. * memory.c: Change allocation error message. * Makefile.in (install): Prefix gmp.h with $(srcdir). (install-bsdmp): Prefix mp.h with $(srcdir). * mp{n,z,f,bsd}/{configure,config.sub}: Delete. * Makefile.in (gmp.dvi): Set TEXINPUTS also for 2nd tex invocation (install targets): Install gmp.info-N. Sat Feb 24 03:36:52 1996 Torbjorn Granlund * mpf/get_str.c: Fix typo. * mpz/legendre.c: Clarify expression with extra parens. * version.c (gmp_version): Not static. * mpf/iset_str.c: Properly return error code. * mpf/add.c: Delete unused variables. * mpf/inp_str.c: Likewise. * mpq/get_d.c: Likewise. * mpn/generic/dump.c: #include . * mpf/dump.c: Likewise. * mpf/set_str.c: #include . (strtol): Declare. * gmp.h: mpn_sqrt => mpn_sqrtrem. * Makefile.in (clean, realclean): Clean in mpbsd. (check): Test in mpf. * mpf/Makefile.in (clean): Clean in tests. * mpq/Makefile.in (clean): Clean in tests. * mpf/tests/Makefile.in: New file. * mpf/tests/configure.in: New file. * mpf/tests/t-addsub.c: New file. * mpf/sub_ui.c: Simply call mpf_sub for now. * mpf/sub.c: Increase prec by 1. * mpf/ui_sub.c: Likewise. Fri Feb 23 00:59:54 1996 Torbjorn Granlund * mpf/ui_sub.c: Fix typos. * mpf/get_str.c: When allocating space for tmp, allow for an extra limb. In code for fraction conversion, add special case for bases that are a power of 2. * mpf/out_str.c: Output leading "0.". Default base to 10, before computing string allocation. * mpf/get_str.c: Make variables for string size have type size_t. * gmp.h: Corresponding change. * mpf/random2.c: Allow creation of prec+1 large mantissas. * mpf/add_ui.c: Don't abort if u < 0; special case for u <= 0. Fix typo in MPN_COPY offset. * mpf/sub_ui.c: Analogous changes. * mpf/set_prec.c: Rewrite. * mpf/init2.c: Compute precision as in set_prec.c. * mpf/div_2exp.c: Special case for u == 0. * mpf/mul_2exp.c: Likewise. Write r->_mp_size always. * mpf/sqrt_ui.c: mpn_sqrt => mpn_sqrtrem. * mpf/sqrt.c: Likewise. When computing new exponent, round quotient towards -infinity. * mpf/add.c: Fix typos. * mpf/sub.c: Fix typos. Thu Feb 22 00:24:48 1996 Torbjorn Granlund * mpz/Makefile.in (stamp-stddefh): Delete target. (test): Delete target. * Makefile.in (stamp-stddefh): Delete target. (cre-stddefh.o): Delete target. (gmp.dvi): Set TEXINPUTS before invoking tex. * cre-stddefh.c: Delete. * mpz/sqrt.c: Fix typo. * mpz/powm.c: Special case for mod == 0. * mpz/powm_ui.c: Likewise. * mpz/get_si.c: Handle -0x80000000 correctly. * mpz/inp_str.c: Now returns size_t. Make it return number of bytes read or error indication. * mpf/inp_str.c: Likewise. * mpz/out_raw.c: Replace by mpz/out_binary.c, with modifications. * mpz/inp_raw.c: Rewrite, using mpz/inp_binary as a base. * mpz/inp_binary.c: Delete. * mpn/Makefile.in (XCFLAGS): Remove variable. (.c.o): Don't pass XCFLAGS. (SFLAGS): Set to nothing. (.S.o): Pass SFLAGS, not XCFLAGS. * mpn/config/t-freebsd (SFLAGS): New name for XCFLAGS. * mpf/out_str.c: Make return number of bytes written or error indication. * mpz/out_str.c: Likewise. * gmp.h: Corresponding changes. * gmp.h (__mpz_struct): mp_size_t => int. (__mpq_struct): Likewise. (__mpf_struct): Likewise. (mp_size_t): int => long int. * mpn/cray: New directory. * mpn/cray/gmp-mparam.h: New file. * mpn/configure.in: Recognize cray variants. * Makefile.in: Set defaults for prefix, libdir, etc. (install): New target. (install-bsdmp): New target. (gmp.html): New target. * stack-alloc.c (__tmp_alloc): Cast void ptrs to char * in comparison. Wed Feb 21 04:35:02 1996 Torbjorn Granlund * gmp.h: Sort mpn declarations. (mpn_gcdext): Add declaration. * mpn/generic/divrem_1.c: New file. * mpn/Makefile.in (divrem_1.o): New rule. * configure.in (functions): Add divrem_1. * mpn/generic/divmod.c: Delete file. * mpn/configure.in (functions): Delete divmod. * Makefile.in (divmod.o): Delete rule. * gmp.h (mpn_divmod): New #define. * gmp.h (mpn_next_bit_set): Delete spurious declaration. * mpn/generic/divrem.c (default case): In code assigning most_significant_q_limb, move reassignment of n0 into if statement. * gmp.h (mpf_inp_str): Fix typo. (mpf_out_str): Make prototype match reality. * mpf/inp_str.c: New file. * mpf/out_str.c: New file. * mpf/Makefile.in: Compile new files. * mpn/Makefile.in (dump.o): Fix dependency path. (inlines.o): Likewise. * mpn/configure.in: Make m68060 be the same as m68000. Clean up m68k configs. Tue Feb 20 01:35:11 1996 Torbjorn Granlund * mpn/generic/sqrtrem.c: Renamed from sqrt. * mpn/configure.in (functions): Corresponding change. * mpn/Makefile.in: Likewise. * mpz/sqrtrem.c: Likewise. * mpz/sqrt.c: Likewise. * mpn/generic/perfsqr.c: Likewise. * Makefile.in (clean): Also remove libmp.a. Don't compile cre-conv-tab.c or mp_bases.c. cre-conv-tab.c: Delete file. (gmp.ps): New rule. * mpn/mp_bases.c: New file. * mpn/Makefile.in: Compile mp_bases.c. * mpz/set_str.c: Skip initial whitespace. * mpf/set_str.c: Likewise. * mpbsd/xtom.c: Likewise. * gmp.h: Add missing mpz declarations. Delete all formal parameter names from declarations. * mpn/Makefile.in: Add dependencies for .c files. * Makefile.in (check): Write recursive make calls separately, not as a loop. (FLAGS_TO_PASS): New variable. Use it for most recursive makes. Mon Feb 19 01:02:20 1996 Torbjorn Granlund * mpn/Makefile.in (.S.o): Pipe cpp output to grep in order to delete lines starting with #. (CPP): Set to $(CC) -E to avoid gcc dependency. * mpn/m68k/syntax.h (moveql): Define to moveq for MIT_SYNTAX. * mpn/hppa/hppa1_1/pa7100/addmul_1.S: Fix typo in s1_ptr alignment code. * mpn/hppa/hppa1_1/pa7100/submul_1.S: Likewise. * gmp.h: Fix typos in #defines of recently added mpn functions. * mpz/inp_str.c: Skip all whitespace, not just plain space. * mpbsd/min.c: Likewise. * mpn/configure.in (functions): Add gcdext. * mpn/generic/gcdext.c: New file. * mpz/legendre.c: mpz_div_2exp => mpz_tdiv_q_2exp. * gmp.h: Surround mpn declarations with extern "C" { ... }. * Makefile.in (check): New target. * mpq/get_d.c: Update comments. Use rsize instead of dsize + N_QLIMBS when possible. Add special case for nsize == 0. * gmp.h (mpq_get_d): Add declaration. (mpq_canonicalize): Likewise. (mpq_cmp_ui): Likewise. (mpf_diff): Likewise. (mpf_ui_sub): Likewise. (mpf_set_prec): Likewise. (mpf_random2): Likewise. * gmp.h (mpz_cmp_ui): New #define. (mpz_cmp_si): New #define. (mpq_cmp_ui): New #define. (mpz_sign): New #define. (mpq_sign): New #define. (mpf_sign): New #define. (mpq_numref): New #define. (mpq_denref): New #define. * mpq/set_z.c: File deleted. * mpq/Makefile.in: Corresponding changes. Sun Feb 18 01:34:47 1996 Torbjorn Granlund * mpbsd/sdiv.c: Use _mp_realloc, not _mpz_realloc. * mpz/inp_binary.c: Default stream to stdin. * mpz/inp_str.c: Likewise. * mpz/inp_raw.c: Likewise. * mpz/out_binary.c: Default stream to stdout. * mpz/out_raw.c: Likewise. * mpz/out_str.c: Likewise. * mpbsd/realloc.c: New file. * mpbsd/Makefile.in: Corresponding changes. * mpbsd/min.c: Rewrite (base on mpz/inp_str.c). * mpbsd/mtox.c: Rewrite (base on mpz/get_str.c). * mpbsd/mout.c: Rewrite (base on mpz/out_str) but make it output spaces in each 10th position. * mpbsd/xtom.c: Rewrite (base on mpz/set_str). * mpq/tests/Makefile.in (st-cmp): New file. * mpq/tests/configure.in (srcname): New file. * mpz/tests/configure.in (srcname): Fix typo. * mpq/cmp.c: Add check using number of significant bits, to avoid general multiplication. Sat Feb 17 11:58:30 1996 Torbjorn Granlund * mpq/cmp_ui.c: Store cy_limb after the mpn_mul_1 calls. * mpq/tests: New directory. * mpq/tests/t-cmp.c: New file. * mpq/tests/t-cmp_ui.c: New file. * mpz/tests/dive.c (main): Generate zero numerator. (get_random_size) : Delete. * mpz/divexact.c: Add special case for 0/x. * gmp.h (mpz_mod): Add declaration. Fri Feb 16 18:18:39 1996 Andreas Schwab * mpn/m68k/*: Rewrite code not to use the INSN macros. (L): New macro to properly prefix local labels for ELF. Fri Feb 16 00:20:56 1996 Torbjorn Granlund * gmp-impl.h (ieee_double_extract): Use plain `unsigned int' for fields. * mpn/generic/inlines.c (_FORCE_INLINES): New #define. Delete conditional __GNUC__. * gmp.h (mpn_add, mpn_sub, mpn_add_1, mpn_sub_1): Only define these if __GNUC__ || _FORCE_INLINES. * mpf/random2.c: Add missing parameter in non-ANSI header. * mpn/generic/gcd.c (SIGN_BIT): Do as #define to work around bug in AIX compilers. * mpq/get_d.c: #define N_QLIMBS. * mpz/divexact.c: Obscure division by 0 to silent compiler warnings. * stack-alloc.c: Cast void* pointer to char* before doing arithmetic on it. * Makefile.in (mpbsd/libmpbsd.a): New rule. * configure.in (configdirs): Add mpbsd. * gmp.h: Add declarations for a few missing mpn functions. * Makefile.in (libmp.a): New rule. * mpbsd/mdiv.c: #include "dmincl.c", not "mpz_dmincl.c" * gmp.h: Move #define of __GNU_MP__ into the `#if __GNU_MP__' block. * mp.h: Likewise. Update typedefs from gmp.h. * mpbsd/configure.in: New file. * mpbsd/Makefile.in: New file. * mpbsd/configure: Link to master configure. * mpbsd/config.sub: Link to master config.sub. * Makefile.in: Set RANLIB_TEST. * (libgmp.a): Use it. * (libgmp.a): Do ranlib before moving the libgmp.a to the build directory. * mp?/Makefile.in: Don't use or set RANLIB. Thu Feb 15 16:38:41 1996 Torbjorn Granlund * mpz/add_ui.c: MP_INT => mpz_t. * mpz/cmp_ui.c: Likewise. * mpz/fac_ui.c: Likewise. * mpz/inp_binary.c: Likewise. * mpz/inp_raw.c: Likewise. * mpz/legendre.c: Likewise. * mpz/jacobi.c: Likewise. * mpz/out_binary.c: Likewise. * mpz/out_raw.c: Likewise. * mpz/random2.c: Likewise. * mpz/random.c: Likewise. * mpz/realloc.c: Likewise. * mpz/legendre.c: __mpz_2factor(X) => mpz_scan1(X,0), __mpz_odd_less1_2factor => mpz_scan1(X,1). * mpz/ntsup.c: File deleted. * mpz/Makefile.in: Corresponding changes. * mpz/pprime_p: Use mpz_scan1 to avoid looping. * mpz/fac_ui.c: Type of `k' and `p' is `unsigned long'. * mpz/pprime_p.c: Pass long to *_ui functions. * mpz/gcdext.c: Likewise. * mpz/fdiv_r_2exp.c: Likewise. * mpz/fac_ui.c: Likewise. * mpz/powm.c: Don't use mpn_rshift when mod_shift_cnt is 0. * mpz/tests/Makefile.in (st-sqrtrem): Fix typo. * mpz/cmp_ui.c: #undef mpz_cmp_ui. * mpz/cmp_si.c: #undef mpz_cmp_si. * gmp.h (mpz_cmp_ui): New #define. (mpz_cmp_si): New #define. Wed Feb 14 22:11:24 1996 Torbjorn Granlund * gmp.h: Test __cplusplus in addition to __STDC__. * gmp-impl.h: Likewise. * gmp.h: Surround declarations with extern "C" { ... }. Tue Feb 13 15:20:45 1996 Torbjorn Granlund * mpz/fdiv_r_2exp.c: Use MPN_NORMALIZE. * mpz/tdiv_r_2exp.c: Likewise. * mpz/fdiv_r_2exp.c: New file. * mpz/fdiv_q_2exp.c: New file. * mpz/tdiv_r_2exp.c: Renamed from mpz/mod_2exp.c. * mpz/tdiv_q_2exp.c: Renamed from mpz/div_2exp.c * mpz/Makefile.in: Corresponding changes. * mpz/scan0.c,scan1.c: New files. * mpz/Makefile.in: Compile them. * gmp.h (mpn_normal_size): Delete. * config.guess: Update from Cygnus version. * mpn/m68k/rshift.S: Use INSN2 macro for lea instructions. * mpn/m68k/lshift.S: Likewise. * mpn/configure.in: Fix configuration for plain 68000. Mon Feb 12 01:06:06 1996 Torbjorn Granlund * mpz/tests/t-powm.c: Generate negative BASE operand. * mpz/powm.c: Make result always positive. Sun Feb 11 01:44:56 1996 Torbjorn Granlund * mpz/tests/*.c: Add t- prefix. * mpz/tests/Makefile.in: Corresponding changes. * mpz/tests/configure.in: Update srctrigger. * mpz/tests/gcd.c: Generate negative operands. * mpz/tests/gcd2.c: Likewise. * mpz/gcdext.c: At end, if G is negative, negate all G, S, and T. Thu Feb 8 17:16:12 UTC 1996 Ken Weber * mp{z,n}/gcd.c: Change mpn_gcd interface. * gmp.h: Ditto. * gmp.texi: update documentation. Mon Feb 7 23:58:43 1996 Andreas Schwab * mpn/m68k/{lshift,rshift}.S: New files. * mpn/m68k/syntax.h: New ELF_SYNTAX macros. (MEM_INDX, R, PROLOG, EPILOG): New macros. * mpn/m68k/*.S: Use R macro with register name. Use PROLOG and EPILOG macros. Rename `size' to `s_size' or s1_size to avoid clash with ELF .size directive. * mpn/configure.in: New target m68k-*-linux*. Wed Feb 7 07:41:31 1996 Torbjorn Granlund * Makefile.in (cre-conv-tab): Workaround for SunOS make. * mpz/tests/reuse.c: New file. * mpz/tests/Makefile.in: Handle reuse.c. Tue Feb 6 11:56:24 UTC 1996 Ken Weber * mpz/gcd.c: Fix g->size when one op is 0 and g == other op. Tue Feb 6 01:36:39 1996 Torbjorn Granlund * gmp.h (mpz_divexact): Delete parameter names. (mpz_lcm): Delete spurious declaration. * mpz/dmincl.c: Fix typo. Mon Feb 5 01:11:56 1996 Torbjorn Granlund * mpn/generic/gcd.c (gcd_2): Declare consistently. * mpz/tdiv_q.c: Optimize division by a single-limb divisor. * mpz/dmincl.c: Likewise. * mpz/add.c: Use MPN_NORMALIZE instead of mpn_normal_size. * mpz/sub.c: Likewise. * mpn/generic/sqrt.c: Likewise. * mpn/tests/{add_n,sub_n,lshift,rshift}.c: Put garbage in the destination arrays. Fri Feb 2 02:21:27 1996 Torbjorn Granlund * mpz/{jacobi.c,legendre.c,ntsup.c,invert.c}: New files. * mpz/Makefile.in: Compile them. * mpn/Makefile.in (INCLUDES): Don't search in `generic'. Thu Feb 1 02:15:11 1996 Torbjorn Granlund Change from Ken Weber: * mpz/divexact.c: Make it work when quot is identical to either input. * mpf/ui_sub.c: New file. * mpf/Makefile.in: Compile it. * gmp-impl.h (MPZ_TMP_INIT): alloca -> TMP_ALLOC. * mpz/{c,f}div_{q,qr,r}.c: Use TMP_DECL/TMP_MARK/TMP_FREE since these use MPZ_TMP_INIT. * mpz/mod.c: Likewise. * mpq/{add,sub}.c: Likewise. * mpq/canonicalize: Likewise. * mpq/{add,sub,mul,div}.c: Use mpz_divexact. MP_INT -> mpz_t. * mpq/canonicalize.c: Likewise. Wed Jan 31 01:45:00 1996 Torbjorn Granlund * mpn/generic/gcd.c: Misc changes from Ken. * mpz/tests/gcd2.c: New file. * mpz/tests/Makefile.in: Handle gcd2.c. * mpn/generic/gcd.c (mpn_gcd): When GCD == ORIG_V, return vsize, not orig_vsize. Fix parameter declaration. * mpz/mod_ui.c: Delete file. * mpz/Makefile.in: Don't try to compile mod_ui. * mpz/cdiv_*_ui.c): Make them work right. * gmp.h: Declare cdiv*. Tue Jan 30 02:22:56 1996 Torbjorn Granlund * mpz/{cdiv_q.c,cdiv_q_ui.c,cdiv_qr.c,cdiv_qr_ui.c,cdiv_r.c, cdiv_r_ui.c,cdiv_ui.c}: New files. * mpz/Makefile.in: Compile them. * All files: Make file permissions right. Changes from Ken Weber: * mpn/generic/accelgcd.c: Delete. * mpn/generic/bingcd.c: Delete. * mpn/generic/numbits.c: Delete. * mpn/generic/gcd.c: New file. * mpn/configure.in (functions): Update accordingly. * mpz/divexact.c: New file. * mpz/Makefile.in: Compile divexact.c. * mpz/gcd.c: Rewrite to accommodate for gcd changes in mpn. * gmp.h: declare new functions, delete obsolete declarations. * mpz/tests/dive.c: New file. * mpz/tests/Makefile.in: Handle dive.c. Mon Jan 29 03:53:24 1996 Torbjorn Granlund * mpz/random.c: Handle negative SIZE parameter. * mpz/tests/tdiv(_ui).c: New name for tst-dm(_ui).c. * mpz/tests/tst-mdm(_ui).c: Delete. * mpz/tests/fdiv(_ui).c: New test based in tst-mdm(_ui). * mpz/tests/*.c: Get rid of tst- prefix for DOS 8+3 naming. * mpz/tests/Makefile.in: Corresponding changes. * mpz/tests/configure.in: Update srctrigger. * mpn/generic/divmod.c: Update from divrem. * mpn/generic/divrem.c: Misc cleanups. Sun Jan 28 03:25:08 1996 Torbjorn Granlund * All files: Use new TMP_ALLOC interface. * mpz/powm_ui.c: Make Jan 25 changes to powm.c also here. * mpz/tests/powm_ui.c: New file. * mpz/tests/Makefile.in: Add rules for tst-powm and tst-powm_ui. * Makefile.in: Update dependency list. * mpf/Makefile.in: Likewise. * mpz/Makefile.in: Likewise. * mpq/Makefile.in: Likewise. * Makefile.in: Set RANLIB simply to ranlib, and allow configure to override it. * mpz/Makefile.in (conf): Delete spurious target. (mp_bases.c): Delete. (cre-conv-tab rules): Delete. * Makefile.in (cre-conv-tab): Greatly simplify. Sat Jan 27 13:38:15 1996 Torbjorn Granlund * stack-alloc.c: New file. * stack-alloc.h: New file. * gmp.h (__gmp_inline): Define using __inline__. Thu Jan 25 00:28:37 1996 Torbjorn Granlund * mpn/generic/scan0.c: New file. * mpn/generic/scan1.c: Renamed from next_bit.c. * mpn/configure.in (functions): Include scan0 and scan1. * mpn/m68k/*: #include sysdep.h. Use C_GLOBAL_NAME. * configure: Update from Cygnus version. * config.guess: Likewise. * config.sub: Likewise. * configure: Pass --nfp to recursive configures. * mpz/tests/tst-*.c: Adjust SIZE and reps. * mpz/powm.c: Move esize==0 test earlier. In final reduction of rp,rsize, don't call mpn_divmod unless reduction is really needed. * mpz/tests/tst-powm.c: Fix thinko in checking code. * All files: Get rid of `__' prefix from mpn_* calls and declarations. * gmp.h: #define __MPN. * gmp.h: Use __MPN in #defines for mpn calls. * mpn/generic/mul_n.c: Prepend `i' to internal routines. * gmp-impl.h: Add #defines using __MPN for those internal routines. * mpn/generic/sqrt.c: Change call to mpn_mul to mpn_mul_n. Wed Jan 24 13:28:19 1996 Torbjorn Granlund * mpn/sparc32/udiv_fp.S: New name for udiv_qrnnd.S. * mpn/sparc32/udiv_nfp.S: New name for v8/udiv_qrnnd.S. * mpn/sparc32/v8/supersparc: New directory. * mpn/sparc32/v8/supersparc/udiv.S: New file. Tue Jan 23 01:10:11 1996 Torbjorn Granlund This major contribution is from Ken Weber: * mpn/generic/accelgcd.c: New file. * mpn/generic/bdivmod.c: New file. * mpn/generic/bingcd.c: New file. * mpn/generic/gcd_1.c: Rewrite. * mpn/generic/numbits.c: New file (to go away soon). * mpz/gcd.c: Rewrite. * mpz/tests/tst-gcd.c (SIZE): Now 128. * gmp.h: Declare new functions. * mpn/configure.in (functions): List new files. * gmp-impl.h (MPN_SWAP): Delete. (MPN_LESS_BITS_LIMB, MPN_LESS_BITS, MPN_MORE_BITS): Delete. (MPN_COMPL_INCR, MPN_COMPL): Delete. Mon Jan 22 02:04:59 1996 Torbjorn Granlund * gmp.h (mpn_name): New #define. * mpn/m88k/mc88110/addmul_1.s: New file. * mpn/m88k/mc88110/add_n.S: New file. * mpn/m88k/mc88110/sub_n.S: New file. * mpn/m88k/sub_n.s: Correctly initialize carry. * mpn/sparc32/{add_n.S,sub_n.S,lshift.S,rshift.S): `beq' => `be'. Sun Jan 21 00:04:35 1996 Torbjorn Granlund * mpn/sparc64/addmul_1.s: New file. * mpn/sparc64/submul_1.s: New file. * mpn/sparc64/rshift.s: New file. Sat Jan 20 00:32:54 1996 Torbjorn Granlund * mpz/iset.c: Fix typo introduced Dec 25. Wed Jan 17 13:16:44 1996 Torbjorn Granlund * config/mt-sprc8-gcc: New name for mt-sparc8-gcc. * config/mt-sparcv8-gcc: Delete. * configure.in: Corresponding changes. Tue Jan 16 16:31:01 1996 Torbjorn Granlund * gmp-impl.h: #include alloca.h when necessary. * longlong.h: Test __alpha instead of __alpha__, since the former is the standard symbol. Mon Jan 15 18:06:57 1996 Torbjorn Granlund * mpn/sparc64/mul_1.s: Swap operands of mulx instructions. * mpn/sparc64/lshift.s: New file. Fri Dec 29 17:34:03 1995 Torbjorn Granlund * mpn/x86/pentium/add_n.S: Get rid of #defines for register names. * mpn/x86/pentium/sub_n.S: Likewise. Thu Dec 28 03:16:57 1995 Torbjorn Granlund * mpn/x86/pentium/mul_1.S: Rework loop to avoid AGI between update of loop induction variable and load insn at beginning of loop. * mpn/x86/pentium/addmul_1.S: Likewise. * mpn/x86/pentium/submul_1.S: Likewise. Mon Dec 25 23:22:55 1995 Torbjorn Granlund * All files: Prefix user-visible structure fields with _mp_. Fri Dec 22 20:42:17 1995 Torbjorn Granlund * mpn/configure.in (m68k configs): Terminate path variable with plain "m68k". Fri Dec 22 03:29:33 1995 Torbjorn Granlund * mpn/sparc32/add_n.S: Update from sub_n.S to fix bugs, and to clean things up. * mpn/configure.in (m68k configs): Update #include path for new mpn directory organization. Tue Dec 12 02:53:02 1995 Torbjorn Granlund * gmp.h: Prefix all structure field with _mp_. * gmp-impl.h: Define access macros for these fields. Sun Dec 10 00:47:17 1995 Torbjorn Granlund * mpn/alpha/addmul_1.s: Prefix labels with `.'. * mpn/alpha/submul_1.s: Likewise. * mpn/alpha/[lr]shift.s: Likewise. * mpn/alpha/udiv_qrnnd.S: Likewise. * mpn/alpha/ev5/[lr]shift.s: Likewise. * mpn/alpha/ev5/lshift.s: Fix typos. Fri Dec 1 14:28:20 1995 Torbjorn Granlund * mpn/Makefile.in (.SUFFIXES): Define. Wed Nov 29 23:11:57 1995 Torbjorn Granlund * mpn/sparc64/{add_n.s, sub_n.s}: New files. Tue Nov 28 06:03:13 1995 Torbjorn Granlund * mpn/x86/syntax.h: Handle ELF_SYNTAX. Rename GAS_SYNTAX => BSD_SYNTAX. * mpn/configure.in: Handle linuxelf and SysV for x86 variants. Mon Nov 27 01:32:12 1995 Torbjorn Granlund * mpn/hppa/hppa1_1/pa7100/submul_1.S: New file. Sun Nov 26 04:30:47 1995 Torbjorn Granlund * mpn/hppa/hppa1_1/pa7100/addmul_1.S: New file. * mpn/sparc32/add_n.S: Rewrite to use 64 bit loads/stores. * mpn/sparc32/sub_n.S: Likewise. Fri Nov 17 00:18:46 1995 Torbjorn Granlund * mpn/configure.in: Handle m68k on NextStep. Thu Nov 16 02:30:26 1995 Torbjorn Granlund * mpn: Reorganize machine-specific directories. * mpn/configure.in: Corresponding changes. (sh, sh2): Handle these. (m68k targets): Create asm-syntax.h. Thu Nov 9 02:20:50 1995 Torbjorn Granlund * mpn/generic/mul_n.c (____mpn_sqr_n): Delete code that calls abort. (____mpn_mul_n): Likewise. Tue Nov 7 03:25:12 1995 Torbjorn Granlund * mpf/get_str.c: In exponentiation code (two places), don't swap input and output areas when calling mpn_mul_1. * mpf/set_str.c: Likewise. Fri Nov 3 02:35:58 1995 Torbjorn Granlund * mpf/Makefile.in: Make sure all objects are listed in dependency list; delete spurious entries. * mpf/mul.c: Handle U or V being 0. Allow prec+1 for result precision. * mpf/set_prec.c: New computation of limb precision. * mpf/set_dfl_prec.c: Likewise. * mpf/random2.c: Fix typo computing exp. * mpf/get_str.c: In (uexp > usize) case, set n_limbs as a function of the user-requested number of digits, n_digits. Thu Nov 2 16:25:07 1995 Torbjorn Granlund * mpn/generic/divrem.c (case 2): Don't move np vector back, it is never read. (default case): Put most significant limb from np in new variable n2; decrease size argument for MPN_COPY_DECR; use n2 instead of np[dsize]. Wed Nov 1 02:59:53 1995 Torbjorn Granlund * mpn/sparc/[lr]shift.S: New files. Tue Oct 31 00:08:12 1995 Torbjorn Granlund * mpz/gcd_ui.c: Set w->size unconditionally when v is zero. * gmp-impl.h (assert): Delete definition. * mpf/sub.c: Delete all assert calls. Delete variable `cy'. * mpf/neg.c: Use prec+1 as precision. Optimize for when arguments are the same. * mpf/abs.c: Likewise. * mpf/{set,neg,abs}.c: Make structure and variable names similar. Mon Oct 30 12:45:26 1995 Torbjorn Granlund * mpf/random2.c (random): Test __SVR4 in addition to __svr4__. * mpn/generic/random2.c (random): Likewise. Sun Oct 29 01:54:28 1995 Torbjorn Granlund * mpf/div.c: Special handle U or V being 0. * mpf/random2.c: New file. * longlong.h (i860 rshift_rhlc): Define. (i960 udiv_qrnnd): Define. (i960 count_leading_zeros): Define. (i960 add_ssaaaa): Define. (i960 sub_ddmmss): Define. (i960 rshift_rhlc): Define. Sat Oct 28 19:09:15 1995 Torbjorn Granlund * mpn/pentium/rshift.S: Fix and generalize condition for when to use special code for shift by 1. * mpn/pentium/lshift.S: Likewise. Thu Oct 26 00:02:56 1995 Torbjorn Granlund * gmp.h: #undef __need_size_t. * mp.h: Update from gmp.h. Wed Oct 25 00:17:27 1995 Torbjorn Granlund * mpf/Makefile.in: Compile set_prec.c. * mpf/realloc.c: Delete this file. * mpf/Makefile.in: Delete mentions of realloc.c. * gmp.h (__mpf_struct): Get rid of `alloc' field. * mpf/clear.c: Likewise. * mpf/init*.c: Likewise. * mpf/set_prec.c: Likewise. * mpf/iset*.c: Likewise. * mpf/iset_str.c: New file. * mpn/configure.in: Handle pyramid. * mpf/set.c: Use prec+1 as precision. * mpf/set_prec.c: New file. Tue Oct 24 00:56:41 1995 Torbjorn Granlund * mpn/generic/divrem.c: New file. Will replace mpn/generic/divmod.c when rest of source is converted. * mpn/configure.in (functions): Add `divrem' * mpn/generic/set_str.c: Never call __mpn_mul_1 with zero size. * mpf/get_str.c: Completely rewritten. * mpf/add.c: Fix several problems. * mpf/sub.c: Compare operands from most significant end until first difference, exclude skipped limbs from computation. Accordingly simplify normalization code. * mpf/set_str.c: Fix several problems. * mpf/dump.c: New file. * mpf/Makefile.in: Compile dump.c. * mpf/init2.c: Set prec field correctly. Sun Oct 22 03:02:09 1995 Torbjorn Granlund * cre-conv-tab.c: #include math.h; don't declare log and floor. Sat Oct 21 23:04:10 1995 Torbjorn Granlund * mpf/mul_ui.c: Handle U being 0. Wed Oct 18 19:39:27 1995 Torbjorn Granlund * mpn/generic/set_str.c: Correctly handle input like "000000000000". Misc cleanups. Tue Oct 17 15:14:13 1995 Torbjorn Granlund * longlong.h: Define COUNT_LEADING_ZEROS_0 for machines where appropriate. Mon Oct 16 19:14:43 1995 Torbjorn Granlund * mpf/add.c: Rewrite. * mpf/set_str.c: New file. Needs more work. Sat Oct 14 00:14:04 1995 Torbjorn Granlund * mpf/div_2exp.c: Vastly simplify. * mpf/mul_2exp.c: Likewise. * mpf/sub.c: Rewrite. * gmp-impl.h (udiv_qrnnd_preinv2gen): Terminate comment. * mpf/dump.c: Free allocated memory. * gmp-impl.h (assert): Define. Wed Oct 11 13:31:00 1995 Torbjorn Granlund * mpn/pentium/rshift.S: Install new code to optimize shift-by-1. Tue Oct 10 00:37:21 1995 Torbjorn Granlund * mpn/pentium/lshift.S: Install new code to optimize shift-by-1. * mpn/powerpc32/{lshift.s,rshift.s}: New files. * configure.in: Fix typo. Sat Oct 7 08:17:09 1995 Torbjorn Granlund * longlong.h (smul_ppmm): Correct type of __m0 and __m1. Wed Oct 4 16:31:28 1995 Torbjorn Granlund * mpn/configure.in: Handle alphaev5. * mpn/ev4: New name for alpha subdir. * mpn/ev5: New subdir. * mpn/ev5/lshift.s: New file. Tue Oct 3 15:06:45 1995 Torbjorn Granlund * mpn/alpha/mul_1.s: Avoid static increments of pointers; use corresponding offsets in ldq and stq instructions instead. (Loop): Swap cmpult and stq to save one cycle on EV5. * mpn/tests/{add_n.s,sub_n.s,lshift.s,rshift.s,mul_1.s,addmul_1.s, submul_1.s}: Don't check results if NOCHECK is defined. Mon Oct 2 11:40:18 1995 Torbjorn Granlund * longlong.h (mips umul_ppmm [32 and 64 bit versions]): Make new variants, based on GCC version number, that use `l' and `h' constraints instead of explicit mflo and mfhi instructions Sun Oct 1 00:17:47 1995 Torbjorn Granlund * mpn/mc88100/add_n.s: Decrease unrolling factor from 16 to 8. * mpn/mc88100/sub_n.s: Likewise. * config/mt-m88110: New file. * configure.in: Use it. * mpn/mc88110/mul_1.s: Fix thinko. Sat Sep 30 21:28:19 1995 Torbjorn Granlund * mpz/set_d.c: Declare `size' at function start. * experimental: New directory for mpx and mpz2. * mpz/tdiv_q.c: Clarify comments. * mpz/{mod.c,mod_ui.c}: New file, for math mod function. * mpn/sh2/{mul_1.s,addmul_1.s,submul_1.s}: New files. * mpn/sh/{add_n.s,sub_n.s}: New files. * mpn/pyr/{add_n.s,sub_n.s,mul_1.s,addmul_1.s}: New files. * mpn/i960/{add_n.s,sub_n.s}: New files. * mpn/alpha/addmul_1.s (Loop): Move decrement of r18 to before umulh, to save cycles on EV5. * mpn/alpha/submul_1.s: Ditto. * mpn/alpha/mul_1.s: Ditto. Thu Sep 28 02:48:59 1995 Torbjorn Granlund * gmp.h (mp_limb, mp_limb_signed): Define as `long long' if _LONG_LONG_LIMB is defined. * longlong.h (m88110): Test __m88110__, not __mc88110__ * mpn/mc88110/mul_1.s: Rewrite. Tue Sep 26 23:29:05 1995 Torbjorn Granlund * config.sub: Update from current Cygnus version. * mpn/configure.in: Recognize canonical m88*, not mc88*. Fri Sep 22 14:58:05 1995 Torbjorn Granlund * mpz/set_d.c: New file. * mpz/Makefile.in: Build new files. * mpq/get_d.c: Replace usage of scalbn with ldexp. * mpn/{vax,i386}/gmp-mparam.h: New files. * gmp-impl.h (ieee_double_extract): Define here. * mpf/set_d.c (ieee_double_extract): Not here. Thu Sep 21 00:56:36 1995 Torbjorn Granlund * longlong.h (C umul_ppmm): Use UWtype, not USItype for temps. (udiv_qrnnd): For cases implemented with call to __udiv_qrnnd, protect with new symbol LONGLONG_STANDALONE. (68000 umul_ppmm): Use %# prefix for immediate constants. Wed Sep 20 15:36:23 1995 Torbjorn Granlund * mpn/generic/divmod_1.c: Handle divisor_limb == 1 << (BITS_PER_MP_LIMB - 1) specifically also when normalization_steps != 0. Mon Sep 18 15:42:30 1995 Torbjorn Granlund * mpq/get_d.c: New file. Sun Sep 17 02:04:36 1995 Torbjorn Granlund * longlong.h (pyr): Botch up for now. Sat Sep 16 00:11:50 1995 Torbjorn Granlund * mpn/clipper/mul_1.s: New file. * mpn/clipper/add_n.s: New file. * mpn/clipper/sub_n.s: New file. * mpn/configure.in: Handle clipper*-*-*. * mpn/configure.in: Recognize rs6000-*-*. Fri Sep 15 00:41:34 1995 Torbjorn Granlund * mpn/alpha/add_n.s: New file. * mpn/alpha/sub_n.s: New file. * mpn/mips3: New name for mpn/r4000. * mpn/mips2: New name for mpn/r3000. * mpn/configure.in: Corresponding changes. * mpn/generic/perfsqr.c (primes): Delete. (residue_map): Delete. Thu Sep 14 00:07:58 1995 Torbjorn Granlund * mpn/r3000/sub_n.s: Fix typo. * dm_trunc.c: Delete spurious file. * mpz/out_binary.c: Fix typo. * mpn/configure.in (per-target): Make mips*-*-irix6* imply r4000. * gmp-impl.h: For sparc and sgi, include alloca.h. * mpn/z8000/mul_1.s: Replace `test r' with `and r,r'. Replace `ldk r,#0' with `xor r,r'. Wed Sep 6 00:58:38 1995 Torbjorn Granlund * mpz/inp_binary.c: New file. * mpz/out_binary.c: New file. * mpz/Makefile.in: Build new files. Tue Sep 5 22:53:51 1995 Torbjorn Granlund * gmp.h (__mpz_struct): Change `long int' => `mp_size_t' for alloc and size fields. Sat Sep 2 17:47:59 1995 Torbjorn Granlund * mpn/r4000/{add_n.s,sub_n.s}: Optimize away some pointer arithmetic. * mpn/r3000/{add_n.s,sub_n.s,lshift.s,rshift.s}: New files, derived from r4000 code. Fri Sep 1 05:35:52 1995 Torbjorn Granlund * mpn/r3000/mul_1.s: Fix typo. * mpn/powerpc32: Fix some old vs new mnemonic issues. * mpn/powerpc32/{add_n.s,sub_n.s}: New files. * mpn/r4000/{add_n.s,sub_n.s,lshift.s,rshift.s}: New files. Wed Aug 30 10:43:47 1995 Torbjorn Granlund * mpn/r3000/mul_1.s ($LC1): Use addiu for immediate add. * mpn/r4000/{mul_1.s,addmul_1.s,submul_1.s}: New files. * config.guess: Update to latest FSF revision. Mon Aug 28 02:18:13 1995 Torbjorn Granlund * mpz/out_str.c: Cast str to char * in fputs call. * gmp-impl.h: Define UQItype, SItype, and USItype also when not __GNUC__. Fri Aug 25 01:45:04 1995 Torbjorn Granlund * mpn/i386/syntax.h: Renamed from asm-syntax.h. * mpn/mc68020/syntax.h: Renamed from asm-syntax.h. * mpn/configure.in: Corresponding changes. Sun Aug 13 19:20:04 1995 Torbjorn Granlund * mpn/generic/random2.c: Test __hpux, not hpux. Sat Apr 15 20:50:33 1995 Torbjorn Granlund (tege@tiny.cygnus.com) * mpn/sparc/add_n.S: Make it work for PIC. * mpn/sparc/sub_n.s: Likewise. * mpn/sparc8/addmul_1.S: Likewise. * mpn/sparc8/mul_1.S: Likewise. * mpn/i386/add_n.S: Likewise. * mpn/i386/sub_n.S: Likewise. Thu Apr 13 23:15:03 1995 Torbjorn Granlund (tege@tiny.cygnus.com) * mpn/configure.in: Don't search power subdir for generic ppc configs. Add some ppc cpu-specific configs. Misc clean up. Mon Apr 10 00:16:35 1995 Torbjorn Granlund (tege@tiny.cygnus.com) * mpz/ui_pow_ui.c: Delete spurious code to handle negative results. Sun Apr 9 12:38:11 1995 Torbjorn Granlund (tege@tiny.cygnus.com) * longlong.h (SPARC v8 udiv_qrnnd): Generate remainder in C, not in asm. * mpn/generic/sqrt.c (SQRT): Test for __SOFT_FLOAT. Tue Mar 28 00:19:52 1995 Torbjorn Granlund (tege@tiny.cygnus.com) * mpn/generic/hamdist.c (popc_limb): Make Mar 16 change here too. Fri Mar 17 23:29:22 1995 Torbjorn Granlund (tege@tiny.cygnus.com) * longlong.h (SH umul_ppmm): Define. Thu Mar 16 16:40:44 1995 Torbjorn Granlund (tege@tiny.cygnus.com) * mpn/generic/popcount.c (popc_limb): Rearrange 32 bit case to help CSE. Fri Mar 10 20:03:49 1995 Torbjorn Granlund (tege@tiny.cygnus.com) * mpn/powerpc32/mul_1.s: Clear cy before entering loop. Rearrange loop to save a cycle. * mpn/powerpc32/addmul_1.s: New file. * mpn/powerpc32/submul_1.s: New file. Fri Feb 17 22:44:45 1995 Torbjorn Granlund (tege@tiny.cygnus.com) * mpn/configure.in: Set target_makefile_frag for freebsd in new case stmt. * mpn/config/t-freebsd: New file. * mpn/Makefile.in: Add #### for frag insertion. (XCFLAGS): Clear by default. (.c.o, .S.o rules): Pass XCFLAGS. Tue Feb 7 16:27:50 1995 Torbjorn Granlund (tege@tiny.cygnus.com) * longlong.h (68000 umul_ppmm): Merge improvements from henderson. Tue Jan 24 04:23:20 1995 Torbjorn Granlund (tege@tiny.cygnus.com) * longlong.h (default umul_ppmm): Store input parameters in temporaries to avoid reading them twice. (default smul_ppmm): New definition. Thu Dec 29 04:20:07 1994 Jim Meyering (meyering@comco.com) * generic/perfsqr.c (__mpn_perfect_square_p): Remove declaration of unused variable. * generic/pre_mod_1.c (__mpn_preinv_mod_1): Likewise. * mpz/powm.c (pow): Likewise. * mpz/and.c (mpz_and): Use {} instead of `;' for empty else clause to placate `gcc -Wall'. * mpz/ior.c (mpz_ior): Likewise. Wed Dec 28 13:31:40 1994 Torbjorn Granlund (tege@tiny.cygnus.com) * mpn/m*68*/*.S: #include asm-syntax.h, not asm.h. Mon Dec 26 17:15:36 1994 Torbjorn Granlund (tege@tiny.cygnus.com) * longlong.h: Test for more symbols, in __mc68000__ case. * mpn/mpn/config.sub: Recognize m68060. * mpn/configure.in: Change mc* to m* for 68k targets. * mpn/Makefile.in (.S.o): Delete spurious creation of temp .c file. Mon Dec 19 01:56:30 1994 Torbjorn Granlund (tege@tiny.cygnus.com) * config.sub: Recognize pentium as a valid CPU. * mpn/configure.in: Handle pentium specifically, to use new assembly code. Mon Dec 19 00:13:01 1994 Jim Meyering (meyering@comco.com) * gmp.h: Define _GMP_H_HAVE_FILE if FILE, __STDIO_H__, or H_STDIO is defined. * gmp.h: test _GMP_H_HAVE_FILE instead of FILE everywhere else. Mon Dec 19 00:04:54 1994 Kent Boortz (boortz@sics.se) * Makefile.in (recursive makes): Pass CFLAGS. Sun Dec 18 22:34:49 1994 Torbjorn Granlund (tege@tiny.cygnus.com) * mpn/pentium: New directory. * mpz/pprime.c: Make sure to mpz_clear all temporaries. * longlong.h: Don't use udiv instruction when SUPERSPARC is defined. * configure.in: Handle supersparc*-. * config/mt-supspc-gcc: New file. * config/mt-sparc8-gcc: New name for mt-sparcv8-gcc. Mon Dec 12 22:22:10 1994 Torbjorn Granlund (tege@tiny.cygnus.com) * mpn/i386/*.S: #include "asm-syntax.h", not "asm.h". #include sysdep.h before asm-syntax.h. * mpn/mc68020/asm-syntax.h: #undef ALIGN before defining it. * mpn/i386/asm-syntax.h: Likewise. * mpn/mc68020/asm-syntax.h: New name for asm.h. * mpn/i386/asm-syntax.h: New name for asm.h. Tue Dec 6 21:55:25 1994 Torbjorn Granlund (tege@tiny.cygnus.com) * mpz/array_init.c: Fix typo in declaration. Fri Nov 18 19:50:52 1994 Torbjorn Granlund (tege@tiny.cygnus.com) * mpn/Makefile.in (.S.o): Pass CFLAGS and INCLUDES. Mon Nov 14 00:34:12 1994 Torbjorn Granlund (tege@tiny.cygnus.com) * mpn/generic/random2.c (random): Test for __svr4__. Wed Oct 12 23:28:16 1994 Torbjorn Granlund (tege@tiny.cygnus.com) * cre-conv-tab.c (main): Avoid upper-case X in printf format string. Tue Aug 23 17:16:35 1994 Torbjorn Granlund (tege@tiny.cygnus.com) * mpz/perfsqr.c: Use mpn_perfect_square_p. * mpn/generic/perfsqr.c: New file. Wed Jul 6 13:46:51 1994 Torbjorn Granlund (tege@tiny.cygnus.com) * mpz/array_init.c: New file. * mpz/Makefile.in: Compile array_init. * gmp.h: Declare mpz_array_init. Mon Jul 4 01:10:03 1994 Torbjorn Granlund (tege@tiny.cygnus.com) * mpz/add.c: Fix bogus comment. * mpz/sub.c: Likewise. Sat Jul 2 02:14:56 1994 Torbjorn Granlund (tege@adder.cygnus.com) * mpn/generic/pre_mod_1.c: New file. * mpz/perfsqr.c: Use __mpn_preinv_mod_1 when faster. Fri Jul 01 22:10:19 1994 Richard Earnshaw (rwe11@cl.cam.ac.uk) * longlong.h (arm umul_ppmm): Fix typos in last change. Mark hard-coded registers with "%|" Thu Jun 30 03:59:33 1994 Torbjorn Granlund (tege@tiny.cygnus.com) * mpz/perfsqr.c: Define PP, etc, for machines with 64 bit limbs. Use __mpn_mod_1. * mpz/perfsqr.c: Don't clobber REM in quadratic residue check loop. Wed Jun 29 18:45:41 1994 Torbjorn Granlund (tege@adder.cygnus.com) * mpn/generic/sqrt.c (SQRT): New asm for IBM POWER2. * mpz/gcd_ui.c: Return 0 if result does not fit an unsigned long. * gmp.h: Use "defined (__STDC__)" consistently. Tue Jun 28 18:44:58 1994 Torbjorn Granlund (tege@adder.cygnus.com) * gmp.h (mpz_get_si): Don't use "signed" keyword for return type. * mpz/tests/Makefile.in: Use CFLAGS for linking. * Makefile.in (CFLAGS): Use -O2 here. * mpn/Makefile (CFLAGS): Not here. * mpq/cmp_ui.c: Fix typo. * mpq/canonicalize.c: Fix typo. * mpz/gcd_ui.c: Handle gcd(0,v) and gcd(u,0) correctly. * mpn/generic/gcd_1.c: Fix braino in last change. Mon Jun 27 16:10:27 1994 Torbjorn Granlund (tege@rtl.cygnus.com) * mpz/gcd_ui.c: Change return type and return result. Allow destination param to be NULL. * gmp.h: Corresponding change. * mpn/generic/gcd_1.c: Handle zero return from mpn_mod_1. Tue Jun 14 02:17:43 1994 Torbjorn Granlund (tege@tiny.cygnus.com) * mpn/i386/asm.h (ALIGN): Make it take a parameter. * mpn/i386/*.S: Use ALIGN to align all loops. * mpn/i386/*.S: Move colon inside C_GLOBAL_NAME expression. (Makes old versions of GAS happy.) Sat May 28 01:43:54 1994 Torbjorn Granlund (tege@adder.cygnus.com) * Many files: Delete unused variables and labels. * mpn/generic/dump.c: cast printf width argument to int. Wed May 25 00:42:37 1994 Torbjorn Granlund (tege@thepub.cygnus.com) * mpz/gcd.c (mpz_gcd): Normalize after __mpn_sub calls. (xmod): Ignore return value of __mpn_divmod. (xmod): Improve normalization code. Sat May 21 01:30:09 1994 Torbjorn Granlund (tege@adder.cygnus.com) * mpz/gcdext.c: Cosmetic changes. * mpz/fdiv_ui.c: New file. Fri May 20 00:24:53 1994 Torbjorn Granlund (tege@adder.cygnus.com) * mpz/tests/Makefile.in: Use explicit rules for running tests, not a shell loop. (clean): Delete stmp-*. * mpz/Makefile.in: Update. * mpz/div_ui.c: Don't include longlong.h. * mpz/dm_ui.c: Likewise. * mpz/fdiv_q.c, mpz/fdiv_q_ui.c, mpz/fdiv_qr.c, mpz/fdiv_qr_ui.c, mpz/fdiv_r.c, mpz/fdiv_r_ui.c: New files. Code partly from deleted mdm.c, mdm_ui.c, etc, partly rewritten. * mpz/dm_floor_ui.c, mpz/dm_floor.c: Delete. * mpz/mdm.c, mpz/mdm_ui.c, mpz/mdiv.c, mpz/mdiv_ui.c, mpz/mmod.c, mpz/mmod_ui.c: Delete. * mpz/tdiv_q.c, mpz/tdiv_q_ui.c, mpz/tdiv_qr.c, mpz/tdiv_qr_ui.c, mpz/tdiv_r.c, mpz/tdiv_r_ui.c: New names for files implementing truncating division. * mpz/div_ui.c, mpz/dm_ui.c, mpz/mod_ui.c: Simplify. * mpn/Makefile.in (.S.o): Don't rely on CPP being defined, use CC instead. (clean): Delete tmp-*. Thu May 19 01:37:44 1994 Torbjorn Granlund (tege@adder.cygnus.com) * mpz/cmp.c: Call __mpn_cmp. * mpz/popcount.c: Fix typo. * mpz/powm_ui.c: Simplify main loop. Keep principal operand size smaller than MSIZE when possible. * mpz/powm.c: Likewise. * mpn/generic/sqrt.c: Move alloca calls into where the memory is needed. Simplify. * gmp.h: (_PROTO): New macro. Add many function declarations; use _PROTO macro in all declarations. * mpf/*.c: Prepend mpn calls with __. Wed May 18 20:57:06 1994 Torbjorn Granlund (tege@adder.cygnus.com) * mpf/*ui*.c: Make ui argument `long' for consistency with mpz functions. * mpf/div_ui.c: Simplify. Tue May 17 01:05:14 1994 Torbjorn Granlund (tege@adder.cygnus.com) * mpz/*.c: Prepend mpn calls with __. * mpz/mul_ui.c: Use mpn_mul_1. Mon May 16 17:19:41 1994 Torbjorn Granlund (tege@adder.cygnus.com) * mpn/i386/mul_1.S: Use C_GLOBAL_NAME. * mpn/i386/mul_1.S, mpn/i386/addmul_1.S, mpn/i386/submul_1.S: Nuke use of LAB. Sat May 14 14:21:02 1994 Torbjorn Granlund (tege@adder.cygnus.com) * gmp-impl.h: Don't define abort here. * mpz/pow_ui.c: Increase temporary allocation. * mpz/ui_pow_ui.c: Likewise. * gmp.h (mpz_add_1, mpz_sub_1): Don't call memcpy. * All Makefile.in: Delete spurious -I arguments. Update dependencies. * mpz/popcount.c: New file. * mpz/hamdist.c: New file. * All configure: Latest version from Cygnus. * mpq/Makefile.in: New file. * mpq/configure.in: New file. * Makefile.in, configure.in: Enable compilation of mpq. * mpq/set_z.c: Fix typos. * mpq/canonicalize.c: Fix typos. * mpq/cmp_ui.c: Fix typos. * mpf/add_ui.c: Read U->D into UP always. Delete spurious MPN_COPY. * mpf/sub_ui.c: Likewise. * gmp-impl.h: Don't redefine alloca. * COPYING.LIB: Renamed from COPYING. Wed May 11 01:45:44 1994 Torbjorn Granlund (tege@adder.cygnus.com) * mpz/powm_ui.c: When shifting E left by C+1, handle out-of-range shift counts. Fix typo when testing negative_result. * mpz/powm.c: Likewise. * mpz/ui_pow_ui.c: New file. * mpz/Makefile.in: Update. * mpz/pow_ui.c: Call __mpn_mul_n instead of __mpn_mul when possible. * mpz/div.c, mpz/div_ui.c, mpz/gcd.c: Prefix external mpn calls. * mpz/gcd.c: Declare mpn_xmod. * mpz/powm.c: Major changes to accommodate changed mpn semantics. * mpz/powm_ui.c: Update from mpz/powm.c. * mpz/tests/tst-io.c: New file. * mpz/tests/tst-logic: New file. * mpz/tests/Makefile.in: Update. * mpz/inp_str.c: Get base right when checking for first digit. * mpz/inp_str.c: Allocate more space for DEST when needed. * mpz/com.c: Use mpn_add_1 and mpn_sub_1. * mpz/and.c, mpz/ior.c: Likewise. Simplify somewhat. * mpz/add_ui.c: Use mpn_add_1 and mpn_sub_1. Rename parameters to be consistent with mpz/sub_ui. General simplifications. * mpz/sub_ui.x: Likewise. Tue Aug 10 19:41:16 1993 Torbjorn Granlund (tege@prudens.matematik.su.se) * mpf: New directory. * mpf/*.c: Merge basic set of mpf functions. * Many logs missing... Sun Apr 25 18:40:26 1993 Torbjorn Granlund (tege@pde.nada.kth.se) * memory.c: Use #if instead of #ifdef for __STDC__ for consistency. * bsd/xtom.c: Likewise. * mpz/div.c: Remove free_me and free_me_size and their usage. Use mpn_divmod for division; corresponding changes in return value convention. * mpz/powm.c: `carry_digit' => `carry_limb'. * bsd/sdiv.c: Clearify comment. Sun Apr 25 00:31:28 1993 Torbjorn Granlund (tege@pde.nada.kth.se) * longlong.h (__udiv_qrnnd_c): Make all variables `unsigned long int'. Sat Apr 24 16:23:33 1993 Torbjorn Granlund (tege@pde.nada.kth.se) * longlong.h (__udiv_qrnnd_c): Make all variables `unsigned long int'. * gmp-impl.h: #define ABS. * (Many files): Use ABS instead of abs. * mpn/generic/sqrt.c, mpz/clrbit.c, mpz/get_si.c, mpz/mod_2exp.c, mpz/pow_ui.c: Cast 1 to mp_limb before shifting. * mpz/perfsqr.c: Use #if, not plain if for exclusion of code for non-32-bit machines. Tue Apr 20 13:13:58 1993 Torbjorn Granlund (tege@du.nada.kth.se) * mpn/generic/sqrt.c: Handle overflow for intermediate quotients by rounding them down to fit. * mpz/perfsqr.c (PP): Define in hexadecimal to avoid GCC warnings. * mpz/inp_str.c (char_ok_for_base): New function. (mpz_inp_str): Use it. Sun Mar 28 21:54:06 1993 Torbjorn Granlund (tege@cyklop.nada.kth.se) * mpz/inp_raw.c: Allocate x_index, not xsize limbs. Mon Mar 15 11:44:06 1993 Torbjorn Granlund (tege@pde.nada.kth.se) * mpz/pprime.c: Declare param `const'. * gmp.h: Add declarations for mpz_com. Thu Feb 18 14:10:34 1993 Torbjorn Granlund (tege@pde.nada.kth.se) * mpq/add.c, mpq/sub.c: Call mpz_clear for t. Fri Feb 12 20:27:34 1993 Torbjorn Granlund (tege@cyklop.nada.kth.se) * mpz/inp_str.c: Recog minus sign as first character. Wed Feb 3 01:36:02 1993 Torbjorn Granlund (tege@cyklop.nada.kth.se) * mpz/iset.c: Handle 0 size. Tue Feb 2 13:03:33 1993 Torbjorn Granlund (tege@cyklop.nada.kth.se) * mpz/mod_ui.c: Initialize dividend_size before it's used. Mon Jan 4 09:11:15 1993 Torbjorn Granlund (tege@sics.se) * bsd/itom.c: Declare param explicitly 'signed'. * bsd/sdiv.c: Likewise. * mpq/cmp.c: Remove unused variable tmp_size. * mpz/powm_ui.c: Fix typo in esize==0 if stmt. * mpz/powm.c: Likewise. Sun Nov 29 01:16:11 1992 Torbjorn Granlund (tege@sics.se) * mpn/generic/divmod_1.c (mpn_divmod_1): Handle divisor_limb == 1 << (BITS_PER_MP_LIMB - 1) specifically. * Reorganize sources. New directories mpn, mpn/MACH, mpn/generic, mpz, mpq, bsd. Use full file name for change logs hereafter. Wed Oct 28 17:40:04 1992 Torbjorn Granlund (tege@jupiter.sics.se) * longlong.h (__hppa umul_ppmm): Fix typos. (__hppa sub_ddmmss): Swap input arguments. * mpz_perfsqr.c (mpz_perfect_square_p): Avoid , before } in initializator. Sun Oct 25 20:30:06 1992 Torbjorn Granlund (tege@jupiter.sics.se) * mpz_pprime.c (mpz_probab_prime_p): Handle numbers <= 3 specifically (used to consider all negative numbers prime). * mpz_powm_ui: `carry_digit' => `carry_limb'. * sdiv: Handle zero dividend specifically. Replace most code in this function with a call to mpn_divmod_1. Fri Sep 11 22:15:55 1992 Torbjorn Granlund (tege@tarrega.sics.se) * mpq_clear: Don't free the MP_RAT! * mpn_lshift, mpn_rshift, mpn_rshiftci: Remove `long' from 4:th arg. Thu Sep 3 01:47:07 1992 Torbjorn Granlund (tege@jupiter.sics.se) * All files: Remove leading _ from mpn function names. Wed Sep 2 22:21:16 1992 Torbjorn Granlund (tege@jupiter.sics.se) Fix from Jan-Hein Buhrman: * mpz_mdiv.c, mpz_mmod.c, mpz_mdm.c: Make them work as documented. * mpz_mmod.c, mpz_mdm.c: Move decl of TEMP_DIVISOR to reflect its life. Sun Aug 30 18:37:15 1992 Torbjorn Granlund (tege@jupiter.sics.se) * _mpz_get_str: Use mpz_sizeinbase for computing out_len. * _mpz_get_str: Don't remove leading zeros. Abort if there are some. Wed Mar 4 17:56:56 1992 Torbjorn Granlund (tege@zevs.sics.se) * gmp.h: Change definition of MP_INT to make the & before params optional. Use typedef to define it. * mp.h: Use typedef to define MINT. Tue Feb 18 14:38:39 1992 Torbjorn Granlund (tege@zevs.sics.se) longlong.h (hppa umul_ppmm): Add missing semicolon. Declare type of __w1 and __w0. Fri Feb 14 21:33:21 1992 Torbjorn Granlund (tege@zevs.sics.se) * longlong.h: Make default count_leading_zeros work for machines > 32 bits. Prepend `__' before local variables to avoid conflicts with users' variables. * mpn_dm_1.c: Remove udiv_qrnnd_preinv ... * gmp-impl.h: ... and put it here. * mpn_mod_1: Use udiv_qrnnd_preinv if it is faster than udiv_qrnnd. Tue Feb 11 17:20:12 1992 Torbjorn Granlund (tege@zevs.sics.se) * mpn_mul: Enhance base case by handling small multiplicands. * mpn_dm_1.c: Revert last change. Mon Feb 10 11:55:15 1992 Torbjorn Granlund (tege@zevs.sics.se) * mpn_dm_1.c: Don't define udiv_qrnnd_preinv unless needed. Fri Feb 7 16:26:16 1992 Torbjorn Granlund (tege@zevs.sics.se) * mpn_mul: Replace code for base case. Thu Feb 6 15:10:42 1992 Torbjorn Granlund (tege@zevs.sics.se) * mpn_dm_1.c (_mpn_divmod_1): Add code for avoiding division by pre-inverting divisor. Sun Feb 2 11:10:25 1992 Torbjorn Granlund (tege@zevs.sics.se) * longlong.h: Make __LLDEBUG__ work differently. (_IBMR2): Reinsert old code. Sat Feb 1 16:43:00 1992 Torbjorn Granlund (tege@zevs.sics.se) * longlong.h (#ifdef _IBMR2): Replace udiv_qrnnd with new code using floating point operations. Don't define UDIV_NEEDS_NORMALIZATION any longer. Fri Jan 31 15:09:13 1992 Torbjorn Granlund (tege@zevs.sics.se) * longlong.h: Define UMUL_TIME and UDIV_TIME for most machines. * longlong.h (#ifdef __hppa): Define umul_ppmm. Wed Jan 29 16:41:36 1992 Torbjorn Granlund (tege@zevs.sics.se) * mpn_cmp: Only one length parameter, assume operand lengths are the same. Don't require normalization. * mpq_cmp, mpz_add, mpz_sub, mpz_gcd, mpn_mul, mpn_sqrt: Change for new mpn_cmp definition. Tue Jan 28 11:18:55 1992 Torbjorn Granlund (tege@zevs.sics.se) * _mpz_get_str: Fix typo in comment. Mon Jan 27 09:44:16 1992 Torbjorn Granlund (tege@zevs.sics.se) * Makefile.in: Add new files. * mpn_dm_1.c: New file with function _mpn_divmod_1. * mpz_dm_ui.c (mpz_divmod_ui): Use _mpn_divmod_1. * mpz_div_ui: Likewise. * mpn_mod_1.c: New file with function _mpn_mod_1. * mpz_mod_ui: Use _mpn_mod_1. Thu Jan 23 18:54:09 1992 Torbjorn Granlund (tege@zevs.sics.se) Bug found by Paul Zimmermann (zimmermann@inria.inria.fr): * mpz_div_ui.c (mpz_div_ui), mpz_dm_ui.c (mpz_divmod_ui): Handle dividend == 0. Wed Jan 22 12:02:26 1992 Torbjorn Granlund (tege@zevs.sics.se) * mpz_pprime.c: Use "" for #include. Sun Jan 19 13:36:55 1992 Torbjorn Granlund (tege@zevs.sics.se) * mpn_rshiftci.c (header): Correct comment. Wed Jan 15 18:56:04 1992 Torbjorn Granlund (tege@zevs.sics.se) * mpz_powm, mpz_powm_ui (if (bsize > msize)): Do alloca (bsize + 1) to make space for ignored quotient at the end. (The quotient might always be an extra limb.) Tue Jan 14 21:28:48 1992 Torbjorn Granlund (tege@zevs.sics.se) * mpz_powm_ui: Fix comment. * mpz_powm: Likewise. Mon Jan 13 18:16:25 1992 Torbjorn Granlund (tege@zevs.sics.se) * tests/Makefile.in: Prepend $(TEST_PREFIX) to Makefile target. Sun Jan 12 13:54:28 1992 Torbjorn Granlund (tege@zevs.sics.se) Fixes from Kazumaro Aoki: * mpz_out_raw: Take abs of size to handle negative values. * mpz_inp_raw: Reallocate before reading ptr from X. * mpz_inp_raw: Store, don't read, size to x->size. Tue Jan 7 17:50:25 1992 Torbjorn Granlund (tege@zevs.sics.se) * gmp.h, mp.h: Remove parameter names from prototypes. Sun Dec 15 00:09:36 1991 Torbjorn Granlund (tege@zevs.sics.se) * tests/Makefile.in: Prepend "./" to file names when executing tests. * Makefile.in: Fix many problems. Sat Dec 14 01:00:02 1991 Torbjorn Granlund (tege@zevs.sics.se) * mpn_sqrt.c: New file with _mpn_sqrt. * mpz_sqrt, mpz_sqrtrem, mpz_perfect_square_p: Use _mpn_sqrt. * msqrt.c: Delete. Create from mpz_sqrtrem.c in Makefile.in. * mpz_do_sqrt.c: Delete. * Makefile.in: Update to reflect these changes. * Makefile.in, configure, configure.subr: New files (from bothner@cygnus.com). * dist-Makefile: Delete. * mpz_fac_ui: Fix comment. * mpz_random2: Rewrite a bit to make it possible for the most significant limb to be == 1. * mpz_pprime.c (mpz_probab_prime_p): Remove \t\n. Fri Dec 13 23:10:02 1991 Torbjorn Granlund (tege@zevs.sics.se) * mpz_do_sqrt: Simplify special case for U == 0. * m*sqrt*.c, mpz_perfsqr.c (mpz_perfect_square_p): Rename _mpz_impl_sqrt to _mpz_do_sqrt. Fri Dec 13 12:52:28 1991 Torbjorn Granlund (tege@zevs.sics.se) * gmp-impl.h (MPZ_TMP_INIT): Cast to the right type. Thu Dec 12 22:17:29 1991 Torbjorn Granlund (tege@zevs.sics.se) * mpn_add, mpn_sub, mpn_mul, mpn_div: Change type of several variables to mp_size. Wed Dec 11 22:00:34 1991 Torbjorn Granlund (tege@zevs.sics.se) * mpn_rshift.c: Fix header comments. Mon Dec 9 17:46:10 1991 Torbjorn Granlund (tege@zevs.sics.se) Released 1.2. * gmp-impl.h (MPZ_TMP_INIT): Cast alloca return value. * dist-Makefile: Add missing dependency for cre-mparam. * mpz_mdiv.c, mpz_mmod.c, mpz_mdm.c, mpz_mdiv_ui.c, mpz_mmod_ui.c, mpz_mdm_ui.c: Remove obsolete comment. * dist-Makefile (clean): clean in tests subdir too. * tests/Makefile: Define default values for ROOT and SUB. * longlong.h (__a29k__ udiv_qrnnd): Change "q" to "1" for operand 2 constraint. Mon Nov 11 00:06:05 1991 Torbjorn Granlund (tege@zevs.sics.se) * mpz_sizeinb.c (mpz_sizeinbase): Special code for size == 0. Sat Nov 9 23:47:38 1991 Torbjorn Granlund (tege@zevs.sics.se) Released 1.1.94. * dist-Makefile, Makefile, tests/Makefile: Merge tests into distribution. Fri Nov 8 22:57:19 1991 Torbjorn Granlund (tege@zevs.sics.se) * gmp.h: Don't use keyword `signed' for non-ANSI compilers. Thu Nov 7 22:06:46 1991 Torbjorn Granlund (tege@zevs.sics.se) * longlong.h: Cosmetic changes to keep it identical to gcc2 version of longlong.h. * longlong.h (__ibm032__): Fix operand order for add_ssaaaa and sub_ddmmss. Mon Nov 4 00:36:46 1991 Torbjorn Granlund (tege@zevs.sics.se) * mpn_mul: Fix indentation. * mpz_do_sqrt: Don't assume 32 bit limbs (had constant 4294967296.0). * mpz_do_sqrt: Handle overflow in conversion from double returned by SQRT to mp_limb. * gmp.h: Add missing function definitions. Sun Nov 3 18:25:25 1991 Torbjorn Granlund (tege@zevs.sics.se) * mpz_pow_ui: Change type of `i' to int. * ChangeLog: Add change log entry. * ChangeLog: Add change log entry. * ChangeLog: Add change log entry. * ChangeLog: Add change log entry. * ChangeLog: Add change log entry. * ChangeLog: Add change log entry. * ChangeLog: Add change log entry. * ChangeLog: Add change log entry. Stack overflow. * mpz_pow_ui.c: Fix typo in comment. * dist-Makefile: Create rpow.c from mpz_powm_ui.c. * mpz_powm_ui.c: Add code for rpow. * rpow.c: Delete this file. The rpow function is now implemented in mpz_powm_ui.c. * mpz_fac_ui.c: New file. * gmp.h, dist-Makefile: Add stuff for mpz_fac_ui. Bug found by John Amanatides (amana@sasquatch.cs.yorku.ca): * mpz_powm_ui, mpz_powm: Call _mpn_mul in the right way, with the first argument not smaller than the second. Tue Oct 29 13:56:55 1991 Torbjorn Granlund (tege@zevs.sics.se) * cre-conv-tab.c (main), cre-mparam.c (main): Fix typo in output header text. Mon Oct 28 00:35:29 1991 Torbjorn Granlund (tege@zevs.sics.se) * mpz_random2: Handle size == 0. * gmp-impl.h (struct __mp_bases): Rename chars_per_limb_exactly to chars_per_bit_exactly, and change its definition. * cre-conv-tab.c (main): Output field according to its new definition. * mpz_out_str, _mpz_get_str, mpz_sizeinb, mout: Use chars_per_bit_exactly. * mpz_random2: Change the loop termination condition in order to get a large most significant limb with higher probability. * gmp.h: Add declaration of new mpz_random2 and mpz_get_si. * mpz_get_si.c: New file. * dist-Makefile: Add mpz_random2 and mpz_get_si. * mpz_sizeinb.c (mpz_sizeinbase): Special code for base being a power of 2, giving exact result. * mpn_mul: Fix MPN_MUL_VERIFY in various ways. * mpn_mul: New macro KARATSUBA_THRESHOLD. * mpn_mul (karatsuba's algorithm): Don't write intermediate results to prodp, use temporary pp instead. (Intermediate results can be larger than the final result, possibly writing into hyperspace.) * mpn_mul: Make smarter choice between Karatsuba's algorithm and the shortcut algorithm. * mpn_mul: Fix typo, cy instead of xcy. Unify carry handling code. Sun Oct 27 19:57:32 1991 Torbjorn Granlund (tege@zevs.sics.se) * mpn_mul: In non-classical case, choose Karatsuba's algorithm only when usize > 1.5 vsize. * mpn_mul: Break between classical and Karatsuba's algorithm at KARATSUBA_THRESHOLD, if defined. Default to 8. * mpn_div: Kludge to fix stray memory read. Sat Oct 26 20:06:14 1991 Torbjorn Granlund (tege@zevs.sics.se) * mpz_gcdext: Handle a = b = 0. Remove memory leakage by calling mpz_clear for all temporary variables. * mpz_gcd: Reduce w_bcnt in _mpn_lshift call to hold that function's argument constraints. Compute wsize correctly. * mpz_gcd: Fix typo in comment. * memory.c (_mp_default_allocate, _mp_default_reallocate): Call abort if allocation fails, don't just exit. Fri Oct 25 22:17:20 1991 Torbjorn Granlund (tege@zevs.sics.se) * mpz_random2.c: New file. Thu Oct 17 18:06:42 1991 Torbjorn Granlund (tege@zevs.sics.se) Bugs found by Pierre-Joseph Gailly (pjg@sunbim.be): * mpq_cmp: Take sign into account, don't just compare the magnitudes. * mpq_cmp: Call _mpn_mul in the right way, with the first argument not smaller than the second. Wed Oct 16 19:27:32 1991 Torbjorn Granlund (tege@zevs.sics.se) * mpz_random: Ensure the result is normalized. Tue Oct 15 14:55:13 1991 Torbjorn Granlund (tege@zevs.sics.se) * mpz_clrbit: Support non-ANSI compilers. Wed Oct 9 18:03:28 1991 Torbjorn Granlund (tege@zevs.sics.se) * longlong.h (68k add_ssaaaa, sub_ddmmss): Generalize constraints. Tue Oct 8 17:42:59 1991 Torbjorn Granlund (tege@zevs.sics.se) * mpz_mdm_ui: Add comments. * mpz_mdiv: Use MPZ_TMP_INIT instead of mpz_init. * mpz_init_ui: Change spacing and header comment. Thu Oct 3 18:36:13 1991 Torbjorn Granlund (tege@zevs.sics.se) * dist-Makefile: Prepend `./' before some filenames. Sun Sep 29 14:02:11 1991 Torbjorn Granlund (tege@zevs.sics.se) Released 1.1 (public). * mpz_com: New name of mpz_not. * dist-Makefile: Change mpz_not to mpz_com. Tue Sep 24 12:44:11 1991 Torbjorn Granlund (tege@zevs.sics.se) * longlong.h: Fix header comment. Mon Sep 9 15:16:24 1991 Torbjorn Granlund (tege@zevs.sics.se) Released 1.0.92. * mpn_mul.c (_mpn_mul): Handle leading zero limbs in non-Karatsuba case. * longlong.h (m68000 umul_ppmm): Clobber one register less by slightly rearranging the code. Sun Sep 1 18:53:25 1991 Torbjorn Granlund (tege@zevs.sics.se) * dist-Makefile (stamp-stddefh): Fix typo. Sat Aug 31 20:41:31 1991 Torbjorn Granlund (tege@zevs.sics.se) Released 1.0.91. * mpz_mdiv.c, mpz_mmod.c, mpz_mdm.c, mpz_mdiv_ui.c, mpz_mmod_ui.c, mpz_mdm_ui.c: New files and functions. * gmp.h, gmp.texi: Define the new functions. Fri Aug 30 08:32:56 1991 Torbjorn Granlund (tege@zevs.sics.se) * mpz_gcdext: Compute t argument from the other quantities at the end, of the function, not in the loop. New feature: Allow t to be NULL. * mpz_add.c, mpz_sub.c, mpz_mul.c, mpz_powm.c, mpz_gcd.c: Don't include "mp.h". Use type name `MP_INT' always. * dist-Makefile, mpz_cmp.c: Merge mcmp.c from mpz_cmp.c. Wed Aug 28 00:45:11 1991 Torbjorn Granlund (tege@zevs.sics.se) * dist-Makefile (documentation): Go via tmp.texi to avoid the creation of gmp.dvi if any errors occur. Make tex read input from /dev/null. Fri Aug 23 15:58:52 1991 Torbjorn Granlund (tege@zevs.sics.se) * longlong.h (68020, i386): Don't define machine-dependent __umulsidi3 (so the default definition is used). * longlong.h (all machines): Cast all operands, sources and destinations, to `unsigned long int'. * longlong.h: Add gmicro support. Thu Aug 22 00:28:29 1991 Torbjorn Granlund (tege@zevs.sics.se) * longlong.h: Rename BITS_PER_LONG to LONG_TYPE_SIZE. * longlong.h (__ibm032__): Define count_leading_zeros and umul_ppmm. * longlong.h: Define UMUL_TIME and UDIV_TIME for some CPUs. * _mpz_get_str.c: Add code to do division by big_base using only umul_qrnnd, if that is faster. Use UMUL_TIME and UDIV_TIME to decide which variant to use. Wed Aug 21 15:45:23 1991 Torbjorn Granlund (tege@zevs.sics.se) * longlong.h (__sparc__ umul_ppmm): Move two insn from end to the nops. (Saves two insn.) * longlong.h (__sparc__ umul_ppmm): Rewrite in order to avoid branch, and to permit input/output register overlap. * longlong.h (__29k__): Remove duplicated udiv_qrnnd definition. * longlong.h (__29k__ umul_ppmm): Split asm instructions into two asm statements (gives better code if either the upper or lower part of the product is unused. Tue Aug 20 17:57:59 1991 Torbjorn Granlund (tege@zevs.sics.se) * _mpz_get_str.c (outside of functions): Remove num_to_ascii_lower_case and num_to_ascii_upper_case. Use string constants in the function instead. Mon Aug 19 00:37:42 1991 Torbjorn Granlund (tege@zevs.sics.se) * cre-conv-tab.c (main): Output table in hex. Output 4 fields, not 3, for components 0 and 1. * gmp.h: Add declaration of mpq_neg. Released 1.0beta.13. * _mpz_set_str.c (mpz_set_str): Cast EOF and SPC to char before comparing to enum literals SPC and EOF. This makes the code work for compilers where `char' is unsigned. (Bug found by Brian Beuning). Released 1.0beta.12. * mpz_mod_ui: Remove references to quot. Remove quot_ptr, quot_size declarations and assignment code. Sun Aug 18 14:44:26 1991 Torbjorn Granlund (tege@zevs.sics.se) * mpz_mod_ui: Handle dividend < 0. Released 1.0beta.11. * mpz_dm_ui, mpz_div_ui, mpz_mod_ui, sdiv: Make them share the same general structure, variable names, etc. * sdiv: Un-normalize the remainder in n1 before it is negated. * longlong.h: Mention UDIV_NEEDS_NORMALIZATION in description of udiv_qrnnd. * mpz_dm_ui.c (mpz_divmod_ui), mpz_div_ui.c (mpz_div_ui): Increment the quotient size if the dividend size is incremented. (Bug found by Brian Beuning.) * mpz_mod_ui: Shift back the remainder, if UDIV_NEEDS_NORMALIZATION. (Bug found by Brian Beuning.) * mpz_mod_ui: Replace "digit" by "limb". * mpz_perfsqr.c (mpz_perfect_square_p): Disable second test case for non-32-bit machines (PP is hardwired for such machines). * mpz_perfsqr.c (outside of functions): Define PP value with an L. * mpn_mul.c (_mpn_mul): Add verification code that is activated if DEBUG is defined. Replace "digit" by "limb". * mpn_mul.c (_mpn_mul: Karatsuba's algorithm: 4.): Normalize temp after the addition. * mpn_mul.c (_mpn_mul: Karatsuba's algorithm: 1.): Compare u0_size and v0_size, and according to the result, swap arguments in recursive call. (Don't violate mpn_mul's own argument constraints.) Fri Aug 16 13:47:12 1991 Torbjorn Granlund (tege@zevs.sics.se) Released 1.0beta.10. * longlong.h (IBMR2): Add udiv_qrnnd. * mpz_perfsqr: Remove unused variables. * mpz_and (case for different signs): Initialize loop variable i! * dist-Makefile: Update automatically generated dependencies. * dist-Makefile (madd.c, msub.c, pow.c, mult.c, gcd.c): Add mp.h, etc to dependency file lists. * longlong.h (add_ssaaaa, sub_ddmmss [C default versions]): Make __x `unsigned long int'. * longlong.h: Add `int' after `unsigned' and `long' everywhere. Wed Aug 14 18:06:48 1991 Torbjorn Granlund (tege@zevs.sics.se) * longlong.h: Add ARM, i860 support. * mpn_lshift, mpn_rshift, mpn_rshiftci: Rename *_word with *_limb. Tue Aug 13 21:57:43 1991 Torbjorn Granlund (tege@zevs.sics.se) * _mpz_get_str.c, _mpz_set_str.c, mpz_sizeinb.c (mpz_sizeinbase), mpz_out_str.c, mout.c: Remove declaration of __mp_bases. * gmp-impl.h: Put it here, and make it `const'. * cre-conv-tab.c (main): Make struct __mp_bases `const'. Mon Aug 12 17:11:46 1991 Torbjorn Granlund (tege@zevs.sics.se) * cre-conv-tab.c (main): Use %lu in printf for long ints. * dist-Makefile: Fix cre-* dependencies. * cre-conv-tab.c (main): Output field big_base_inverted. * gmp-impl.h (struct bases): New field big_base_inverted. * gmp-impl.h (struct bases): Change type of chars_per_limb_exactly to float (in order to keep the structure smaller). * mp.h, gmp.h: Change names of macros for avoiding multiple includes. Fri Aug 9 18:01:36 1991 Torbjorn Granlund (tege@zevs.sics.se) * _mpz_get_str: Only shift limb array if normalization_steps != 0 (optimization). * longlong.h (sparc umul_ppmm): Use __asm__, not asm. * longlong.h (IBMR2 umul_ppmm): Refer to __m0 and __m1, not to m0 and m1 (overlap between output and input operands did not work). * longlong.h: Add VAX, ROMP and HP-PA support. * longlong.h: Sort the machine dependent code in alphabetical order on the CPU name. * longlong.h: Hack comments. Thu Aug 8 14:13:36 1991 Torbjorn Granlund (tege@zevs.sics.se) Released 1.0beta.9. * longlong.h: Define BITS_PER_LONG to 32 if it's not already defined. * Define __BITS4 to BITS_PER_LONG / 4. * Don't assume 32 bit word size in "count_leading_zeros" C macro. Use __BITS4 and BITS_PER_LONG instead. * longlong.h: Don't #undef internal macros (reverse change of Aug 3). * longlong.h (68k): Define add_ssaaaa sub_ddmmss, and umul_ppmm even for plain mc68000. * mpq_div: Flip the sign of the numerator *and* denominator of the result if the intermediate denominator is negative. * mpz_and.c, mpz_ior.c: Use MPN_COPY for all copying operations. * mpz_and.c: Compute the result size more conservatively. * mpz_ior.c: Likewise. * mpz_realloc: Never allocate zero space even if NEW_SIZE == 0. * dist-Makefile: Remove madd.c, msub.c, pow.c, mult.c, gcd.c from BSDMP_SRCS. * dist-Makefile: Create mult.c from mpz_mul.c. * mult.c: Delete this file. * _mpz_set_str: Normalize the result (for bases 2, 4, 8... it was not done properly if the input string had many leading zeros). Sun Aug 4 16:54:14 1991 Torbjorn Granlund (tege@zevs.sics.se) * dist-Makefile (gcd.c, pow.c, madd.c, msub.c): Make these targets work with VPATH and GNU MP. * mpz_gcd: Don't call mpz_set; inline its functionality. * mpq_mul, mpq_div: Fix several serious typos. * mpz_dmincl, mpz_div: Don't normalize the quotient if it's already zero. * mpq_neg.c: New file. * dist-Makefile: Remove obsolete dependencies. * mpz_sub: Fix typo. Bugs found by Pierre-Joseph Gailly (pjg@sunbim.be): * mpq_mul, mpq_div: Initialize tmp[12] variables even when the gcd is just 1. * mpz_gcd: Handle gcd(0,v) and gcd(u,0) in special cases. Sat Aug 3 23:45:28 1991 Torbjorn Granlund (tege@zevs.sics.se) * longlong.h: Clean up comments. * longlong.h: #undef internal macros. Fri Aug 2 18:29:11 1991 Torbjorn Granlund (tege@zevs.sics.se) * mpq_set_si, mpq_set_ui: Canonicalize 0/x to 0/1. * mpq_set_si, mpq_set_ui: Cosmetic formatting changes. * mpz_dmincl.c: Normalize the remainder before shifting it back. * mpz_dm_ui.c (mpz_divmod_ui): Handle rem == dividend. * mpn_div.c: Fix comment. * mpz_add.c, mpz_sub.c: Use __MP_INT (not MP_INT) for intermediate type, in order to work for both GNU and Berkeley functions. * dist-Makefile: Create gcd.c from mpz_gcd.c, pow.c from mpz_powm, madd.c from mpz_add.c, msub.c from mpz_sub.c. respectively. * pow.c, gcd.c, mpz_powmincl.c, madd.c, msub.c: Remove these. * mpz_powm.c, mpz_gcd.c, mpz_add.c, mpz_sub.c: #ifdef for GNU and Berkeley function name variants. * dist-Makefile: Add created files to "clean" target. Tue Jul 16 15:19:46 1991 Torbjorn Granlund (tege@zevs.sics.se) * mpq_get_den: No need for absolute value of the size, the denominator is always positive. * mpz_get_ui: If the operand is zero, return zero. Don't read the limb array! * mpz_dmincl.c: Don't ignore the return value from _mpn_rshift, it is the size of the remainder. Mon Jul 15 11:08:05 1991 Torbjorn Granlund (tege@zevs.sics.se) * Several files: Remove unused variables and functions. * gmp-impl.h: Declare _mpz_impl_sqrt. * mpz_dm_ui (mpz_divmod_ui), sdiv: Shift back the remainder if UDIV_NEEDS_NORMALIZATION. (Fix from Brian Beuning.) * mpz_dm_ui.c, sdiv: Replace *digit with *limb. * mpz_ior: Add missing else statement in -OP1 | -OP2 case. * mpz_ior: Add missing else statement in OP1 | -OP2 case. * mpz_ior: Swap also OP1 and OP2 pointers in -OP1 & OP2 case. * mpz_ior: Duplicate _mpz_realloc code. * mpz_and: Add missing else statement in -OP1 & -OP2 case. * mpz_and: Rewrite OP1 & -OP2 case. * mpz_and: Swap also OP1 and OP2 pointers in -OP1 & OP2 case. * mpz_gcdext: Loop in d1.size (not b->size). (Fix from Brian Beuning.) * mpz_perfsqr: Fix argument order in _mpz_impl_sqrt call. (Fix from Brian Beuning.) Fri Jul 12 17:10:33 1991 Torbjorn Granlund (tege@zevs.sics.se) * mpq_set.c, mpq_set_ui.c, mpq_set_si.c, mpq_inv.c, mpq_get_num.c, mpq_get_den.c, mpq_set_num.c, mpq_set_den.c: New files. * mpz_dmincl.c: Remove second re-allocation of rem->d. It was never executed. * dist-Makefile: Use `-r' instead of `-x' for test for ranlib (as some unixes' test doesn't have the -r option). * *.*: Cast allocated pointers to the appropriate type (makes old C compilers happier). * cre-conv-tab.c (main): Divide max_uli by 2 and multiply again after conversion to double. (Kludge for broken C compilers.) * dist-Makefile (stamp-stddefh): New target. Test if "stddef.h" exists in the system and creates a minimal one if it does not exist. * cre-stddefh.c: New file. * dist-Makefile: Make libgmp.a and libmp.a depend on stamp-stddefh. * dist-Makefile (clean): Add some more. * gmp.h, mp.h: Unconditionally include "stddef.h". Thu Jul 11 10:08:21 1991 Torbjorn Granlund (tege@zevs.sics.se) * min: Do ungetc of last read character. * min.c: include stdio.h. * dist-Makefile: Go via tmp- files for cre* redirection. * dist-Makefile: Add tmp* to "clean" target. * dist-Makefile: Use LOCAL_CC for cre*, to simplyfy cross compilation. * gmp.h, mp.h: Don't define NULL here. * gmp-impl.h: Define it here. Wed Jul 10 14:13:33 1991 Torbjorn Granlund (tege@zevs.sics.se) * mpz_mod_2exp: Don't copy too much, overwriting most significant limb. * mpz_and, mpz_ior: Don't read op[12]_ptr from op[12] when reallocating res, if op[12]_ptr got their value from alloca. * mpz_and, mpz_ior: Clear up comments. * cre-mparam.c: Output parameters for `short int' and `int'. * mpz_and, mpz_ior: Negate negative op[12]_size in several places. Tue Jul 9 18:40:30 1991 Torbjorn Granlund (tege@zevs.sics.se) * gmp.h, mp.h: Test for _SIZE_T defined before typedef'ing size_t. (Fix for Sun lossage.) * gmp.h: Add declaration of mpq_clear. * dist-Makefile: Chack if "ranlib" exists, before using it. * dist-Makefile: Add mpz_sqrtrem.c and mpz_size.c. * mpz_powm: Fix typo, "pow" instead of "mpz_powm". Fri Jul 5 19:08:09 1991 Torbjorn Granlund (tege@zevs.sics.se) * move: Remove incorrect comment. * mpz_free, mpq_free: Rename to *_clear. * dist-Makefile: Likewise. * mpq_add, mpq_sub, mpq_mul, mpq_div: Likewise. * mpz_dmincl.c: Don't call "move", inline its functionality. Thu Jul 4 00:06:39 1991 Torbjorn Granlund (tege@zevs.sics.se) * Makefile: Include dist-Makefile. Fix dist target to include dist-Makefile (with the name "Makefile" in the archive). * dist-Makefile: New file made from Makefile. Add new mpz_... functions. * mpz_powincl.c New file for mpz_powm (Berkeley MP pow) functionality. Avoids code duplication. * pow.c, mpz_powm.c: Include mpz_powincl.c * mpz_dmincl.c: New file containing general division code. Avoids code duplication. * mpz_dm.c (mpz_divmod), mpz_mod.c (mpz_mod), mdiv.c (mdiv): Include mpz_dmincl.c. * _mpz_get_str: Don't call memmove, unless HAS_MEMMOVE is defined. Instead, write the overlapping memory copying inline. * mpz_dm_ui.c: New name for mpz_divmod_ui.c (SysV file name limit). * longlong.h: Don't use #elif. * mpz_do_sqrt.c: Likewise. * longlong.h: Use __asm__ instead of asm. * longlong.h (sparc udiv_qrnnd): Make it to one string over several lines. * longlong.h: Preend __ll_ to B, highpart, and lowpart. * longlong.h: Move array t in count_leading_zeros to the new file mp_clz_tab.c. Rename the array __clz_tab. * All files: #ifdef for traditional C compatibility. Wed Jul 3 11:42:14 1991 Torbjorn Granlund (tege@zevs.sics.se) * mpz_and: Initialize res_ptr always (used to be initialized only when reallocating). * longlong.h (umul_ppmm [C variant]): Make __ul...__vh `unsigned int', and cast the multiplications. This way compilers more easily can choose cheaper multiplication instructions. * mpz_mod_2exp: Handle input argument < modulo argument. * mpz_many: Make sure mp_size is the type for sizes, not int. * mpz_init, mpz_init_set*, mpq_init, mpq_add, mpq_sub, mpq_mul, mpq_div: Change mpz_init* interface. Structure pointer as first arg to initialization function, no longer *return* struct. Sun Jun 30 19:21:44 1991 Torbjorn Granlund (tege@zevs.sics.se) * Rename mpz_impl_sqrt.c to mpz_do_sqrt.c to satisfy SysV 14 character file name length limit. * Most files: Rename MINT to MP_INT. Rename MRAT to MP_RAT. * mpz_sizeinb.c: New file with function mpz_sizeinbase. * mp_bases.c: New file, with array __mp_bases. * _mpz_get_str, _mpz_set_str: Remove struct bases, use extern __mp_bases instead. * mout, mpz_out_str: Use array __mp_bases instead of function _mpz_get_cvtlen. * mpz_get_cvtlen.c: Remove. * Makefile: Update. Sat Jun 29 21:57:28 1991 Torbjorn Granlund (tege@zevs.sics.se) * longlong.h (__sparc8__ umul_ppmm): Insert 3 nop:s for wr delay. * longlong.h (___IBMR2__): Define umul_ppmm, add_ssaaaa, sub_ddmmss. * longlong.h (__sparc__): Don't call .umul; expand asm instead. Don't define __umulsidi3 (i.e. use default definition). Mon Jun 24 17:37:23 1991 Torbjorn Granlund (tege@amon.sics.se) * _mpz_get_str.c (num_to_ascii_lower_case, num_to_ascii_upper_case): Swap 't' and 's'. Sat Jun 22 13:54:01 1991 Torbjorn Granlund (tege@zevs.sics.se) * mpz_gcdext.c: New file. * mpn_mul: Handle carry and unexpected operand sizes in last additions/subtractions. (Bug trigged when v1_size == 1.) * mp*_alloc*: Rename functions to mp*_init* (files to mp*_iset*.c). * mpq_*: Call mpz_init*. * mpz_pow_ui, rpow: Use _mpn_mul instead of mult. Restructure. Wed May 29 20:32:33 1991 Torbjorn Granlund (tege@zevs.sics.se) * mpz_get_cvtlen: multiply by size. Sun May 26 15:01:15 1991 Torbjorn Granlund (tege@bella.nada.kth.se) Alpha-release 0.95. Fixes from Doug Lea (dl@g.oswego.edu): * mpz_mul_ui: Loop to MULT_SIZE (not PROD_SIZE). Adjust PROD_SIZE correctly. * mpz_div: Prepend _ to mpz_realloc. * mpz_set_xs, mpz_set_ds: Fix typos in function name. Sat May 25 22:51:16 1991 Torbjorn Granlund (tege@bella.nada.kth.se) * mpz_divmod_ui: New function. * sdiv: Make the sign of the remainder correct. Thu May 23 15:28:24 1991 Torbjorn Granlund (tege@zevs.sics.se) * Alpha-release 0.94. * mpz_mul_ui: Include longlong.h. * mpz_perfsqr.c (mpz_perfect_square_p): Call _mpz_impl_sqrt instead of msqrt. * mpz_impl_sqrt: Don't call "move", inline its functionality. * mdiv: Use MPN_COPY instead of memcpy. * rpow, mpz_mul, mpz_mod_2exp: Likewise. * pow.c: Likewise, and fix bug in the size arg. * xtom: Don't use mpz_alloc, inline needed code instead. Call _mpz_set_str instead of mpz_set_str. * Makefile: Make two libraries, libmp.a and libgmp.a. Thu May 22 20:25:29 1991 Torbjorn Granlund (tege@zevs.sics.se) * Add manual to distribution. * Fold in many missing routines descibed in the manual. * Update Makefile. Wed May 22 13:48:46 1991 Torbjorn Granlund (tege@zevs.sics.se) * mpz_set_str: Make it handle 0x prefix OK. Sat May 18 18:31:02 1991 Torbjorn Granlund (tege@zevs.sics.se) * memory.c (_mp_default_reallocate): Swap OLD_SIZE and NEW_SIZE arguments. * mpz_realloc (_mpz_realloc): Swap in call to _mp_reallocate_func. * min: Likewise. Thu May 16 20:43:05 1991 Torbjorn Granlund (tege@zevs.sics.se) * memory.c: Make the default allocations functions global. * mp_set_fns (mp_set_memory_functions): Make a NULL pointer mean the default memory function. Wed May 8 20:02:42 1991 Torbjorn Granlund (tege@zevs.sics.se) * mpz_div: Handle DEN the same as QUOT correctly by copying DEN->D even if no normalization is needed. * mpz_div: Rework reallocation scheme, to avoid excess copying. * mpz_sub_ui.c, mpz_add_ui.c: New files. * mpz_cmp.c, mpz_cmp_ui.c: New files. * mpz_mul_2exp: Handle zero input MINT correctly. * mpn_rshiftci: Don't handle shift counts > BITS_PER_MP_DIGIT. * mpz_out_raw.c, mpz_inp_raw.c: New files for raw I/O. Tue May 7 15:44:58 1991 Torbjorn Granlund (tege@zevs.sics.se) * mpn_rshift: Don't handle shift counts > BITS_PER_MP_DIGIT. * mpz_div_2exp: Don't call _mpn_rshift with cnt > BITS_PER_MP_DIGIT. * gcd, mpz_gcd: Likewise. * gcd, mpz_gcd: Handle common 2 factors correctly. Mon May 6 20:22:59 1991 Torbjorn Granlund (tege@zevs.sics.se) * gmp-impl.h (MPN_COPY): Inline a loop instead of calling memcpy. * gmp-impl.h, mpz_get_str, rpow: Swap DST and SRC in TMPCOPY* macros. Sun May 5 15:16:23 1991 Torbjorn Granlund (tege@zevs.sics.se) * mpz_div: Remove test for QUOT == 0. Sun Apr 28 20:21:04 1991 Torbjorn Granlund (tege@zevs.sics.se) * pow: Don't make MOD normalization in place, as it's a bad idea to write on an input parameter. * pow: Reduce BASE if it's > MOD. * pow, mult, mpz_mul: Simplify realloc code. Sat Apr 27 21:03:11 1991 Torbjorn Granlund (tege@zevs.sics.se) * Install multplication using Karatsuba's algorithm as default. Fri Apr 26 01:03:57 1991 Torbjorn Granlund (tege@zevs.sics.se) * msqrt: Store in ROOT even for U==0, to make msqrt(0) defined. * mpz_div_2exp.c, mpz_mul_2exp.c: New files for shifting right and left, respectively. * gmp.h: Add definitions for mpz_div_2exp and mpz_mul_2exp. * mlshift.c, mrshift.c: Remove. Wed Apr 24 21:39:22 1991 Torbjorn Granlund (tege@zevs.sics.se) * mpn_mul: Check only for m2_size == 0 in function header. Mon Apr 22 01:31:57 1991 Torbjorn Granlund (tege@zevs.sics.se) * karatsuba.c: New file for Karatsuba's multplication algorithm. * mpz_random, mpz_init, mpz_mod_2exp: New files and functions. * mpn_cmp: Fix header comment. Sun Apr 21 00:10:44 1991 Torbjorn Granlund (tege@zevs.sics.se) * pow: Switch off initial base reduction. Sat Apr 20 22:06:05 1991 Torbjorn Granlund (tege@echnaton.sics.se) * mpz_get_str: Don't generate initial zeros for initial word. Used to write outside of allocated storage. Mon Apr 15 15:48:08 1991 Torbjorn Granlund (tege@zevs.sics.se) * _mpz_realloc: Make it accept size in number of mp_digits. * Most functions: Use new _mpz_realloc definition. * mpz_set_str: Remove calls _mp_free_func. * Most functions: Rename mpn_* to _mpn_*. Rename mpz_realloc to _mpz_realloc. * mpn_lshift: Redefine _mpn_lshift to only handle small shifts. * mdiv, mpz_div, ...: Changes for new definition of _mpn_lshift. * msqrt, mp*_*shift*: Define cnt as unsigned (for speed). Sat Apr 6 14:05:16 1991 Torbjorn Granlund (tege@musta.nada.kth.se) * mpn_mul: Multiply by the first digit in M2 in a special loop instead of zeroing the product area. * mpz_abs.c: New file. * sdiv: Implement as mpz_div_si for speed. * mpn_add: Make it work for second source operand == 0. * msub: Negate the correct operand, i.e. V before swapping, not the smaller of U and V! * madd, msub: Update abs_* when swapping operands, and not after (optimization). Fri Apr 5 00:19:36 1991 Torbjorn Granlund (tege@black.nada.kth.se) * mpn_sub: Make it work for subtrahend == 0. * madd, msub: Rewrite to minimize mpn_cmp calls. Ensure mpn_cmp is called with positive sizes (used to be called incorrectly with negative sizes sometimes). * msqrt: Make it divide by zero if fed with a negative number. * Remove if statement at end of precision calculation that was never true. * itom, mp.h: The argument is of type short, not int. * mpz_realloc, gmp.h: Make mpz_realloc return the new digit pointer. * mpz_get_str.c, mpz_set_str.c, mpz_new_str.c: Don't include mp.h. * Add COPYING to distribution. * mpz_div_ui.c, mpz_div_si.c, mpz_new_ui.c, mpz_new_si.c: New files. Fri Mar 15 00:26:29 1991 Torbjorn Granlund (tege@musta.nada.kth.se) * Add Copyleft headers to all files. * mpn_mul.c, mpn_div.c: Add header comments. * mult.c, mdiv.c: Update header comments. * mpq_add.c, mpq_sub.c, mpq_div.c, mpq_new.c, mpq_new_ui.c, mpq_free.c: New files for rational arithmetics. * mpn_lshift.c: Avoid writing the most significant word if it is 0. * mdiv.c: Call mpn_lshift for the normalization. * mdiv.c: Remove #ifdefs. * Makefile: Add ChangeLog to DISTFILES. * mpn_div.c: Make the add_back code work (by removing abort()). * mpn_div.c: Make it return if the quotient is size as compared with the difference NSIZE - DSIZE. If the stored quotient is larger than that, return 1, otherwise 0. * gmp.h: Fix mpn_div declaration. * mdiv.c: Adopt call to mpn_div. * mpz_div.c: New file (developed from mdiv.c). * README: Update routine names. Thu Mar 14 18:45:28 1991 Torbjorn Granlund (tege@musta.nada.kth.se) * mpq_mul.c: New file for rational multplication. * gmp.h: Add definitions for rational arithmetics. * mpn_div: Kludge the case where the high numerator digit > the high denominator digit. (This code is going to be optimized later.) * New files: gmp.h for GNU specific functions, gmp-common.h for definitions common for mp.h and gmp.h. * Ensure mp.h just defines what BSD mp.h defines. * pow.c: Fix typo for bp allocation. * Rename natural number functions to mpn_*, integer functions to mpz_*. Tue Mar 5 18:47:04 1991 Torbjorn Granlund (tege@musta.nada.kth.se) * mdiv.c (_mp_divide, case 2): Change test for estimate of Q from "n0 >= r" to "n0 > r". * msqrt: Tune the increasing precision scheme, to do fewer steps. Tue Mar 3 18:50:10 1991 Torbjorn Granlund (tege@musta.nada.kth.se) * msqrt: Use the low level routines. Use low precision in the beginning, and increase the precision as the result converges. (This optimization gave a 6-fold speedup.) Local Variables: mode: indented-text left-margin: 8 fill-column: 79 version-control: never eval: (unless (string-match "GNU Emacs \\(21\.[4-9]\\|22\.\\)" (emacs-version)) (save-excursion (goto-char (point-min)) (when (looking-at "Copyright") (search-forward "\n\n") (skip-chars-forward "\n") (narrow-to-region (point) (point-max)) (message "Note! narrowed to hide copyright notice")))) End: ecl-16.1.2/src/gmp/INSTALL000066400000000000000000000366101266352375300147710ustar00rootroot00000000000000Installation Instructions ************************* Copyright (C) 1994-1996, 1999-2002, 2004-2013 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 command `./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. HP-UX `make' updates targets which have the same time stamps as their prerequisites, which makes it generally unusable when shipped generated files such as `configure' are involved. Use GNU `make' instead. 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 limitation. Until the limitation is lifted, you can use this workaround: CONFIG_SHELL=/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. ecl-16.1.2/src/gmp/INSTALL.autoconf000066400000000000000000000220301266352375300165750ustar00rootroot00000000000000Copyright (C) 1994, 1995, 1996, 1999, 2000, 2001, 2002 Free Software Foundation, Inc. This file is free documentation; the Free Software Foundation gives unlimited permission to copy, distribute and modify it. Basic Installation ================== These are generic installation instructions. The `configure' shell script attempts to guess correct values for various system-dependent variables used during compilation. It uses those values to create a `Makefile' in each directory of the package. It may also create one or more `.h' files containing system-dependent definitions. Finally, it creates a shell script `config.status' that you can run in the future to recreate the current configuration, 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 only 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. If you're using `csh' on an old version of System V, you might need to type `sh ./configure' instead to prevent `csh' from trying to execute `configure' itself. Running `configure' takes awhile. While running, it prints some messages telling which features it is checking for. 2. Type `make' to compile the package. 3. Optionally, type `make check' to run any self-tests that come with the package. 4. Type `make install' to install the programs and any data files and documentation. 5. You can remove the program binaries and object files from the source code directory by typing `make clean'. To also remove the files that `configure' created (so you can compile the package for a different kind of computer), type `make distclean'. There is also a `make maintainer-clean' target, but that is intended mainly for the package's developers. If you use it, you may have to get all sorts of other programs in order to regenerate files that came with the distribution. Compilers and Options ===================== Some systems require unusual options for compilation or linking that the `configure' script does not know about. 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=c89 CFLAGS=-O2 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 must use a version of `make' that supports the `VPATH' variable, such as GNU `make'. `cd' to the directory where you want the object files and executables to go and run the `configure' script. `configure' automatically checks for the source code in the directory that `configure' is in and in `..'. If you have to use a `make' that does not support the `VPATH' variable, you have to compile the package for one architecture at a time in the source code directory. After you have installed the package for one architecture, use `make distclean' before reconfiguring for another architecture. Installation Names ================== By default, `make install' will install the package's files in `/usr/local/bin', `/usr/local/man', etc. You can specify an installation prefix other than `/usr/local' by giving `configure' the option `--prefix=PATH'. You can specify separate installation prefixes for architecture-specific files and architecture-independent files. If you give `configure' the option `--exec-prefix=PATH', the package will use PATH as the prefix for installing programs and libraries. Documentation and other data files will still use the regular prefix. In addition, if you use an unusual directory layout you can give options like `--bindir=PATH' 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. If the package supports it, you can cause programs to be installed with an extra prefix or suffix on their names by giving `configure' the option `--program-prefix=PREFIX' or `--program-suffix=SUFFIX'. Optional Features ================= Some packages pay attention to `--enable-FEATURE' options to `configure', where FEATURE indicates an optional part of the package. They may also pay attention to `--with-PACKAGE' options, where PACKAGE is something like `gnu-as' or `x' (for the X Window System). The `README' should mention any `--enable-' and `--with-' options that the package recognizes. For packages that use the X Window System, `configure' can usually find the X include and library files automatically, but if it doesn't, you can use the `configure' options `--x-includes=DIR' and `--x-libraries=DIR' to specify their locations. Specifying the System Type ========================== There may be some features `configure' 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 `--target=TYPE' option 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 will cause the specified gcc to be used as the C compiler (unless it is overridden in the site shell script). `configure' Invocation ====================== `configure' recognizes the following options to control how it operates. `--help' `-h' Print a summary of the options to `configure', and exit. `--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. `configure' also accepts some other, not widely useful, options. Run `configure --help' for more details. ecl-16.1.2/src/gmp/Makefile.am000066400000000000000000000367531266352375300160040ustar00rootroot00000000000000## Process this file with automake to generate Makefile.in # Copyright 1991, 1993, 1994, 1996, 1997, 1999, 2000, 2001, 2002, 2003, 2004, # 2006 Free Software Foundation, Inc. # # This file is part of the GNU MP Library. # # The GNU MP Library is free software; you can redistribute it and/or modify # it under the terms of the GNU Lesser General Public License as published by # the Free Software Foundation; either version 2.1 of the License, or (at your # option) any later version. # # The GNU MP Library is distributed in the hope that it will be useful, but # WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY # or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public # License for more details. # # You should have received a copy of the GNU Lesser General Public License # along with the GNU MP Library; see the file COPYING.LIB. If not, write to # the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, # MA 02110-1301, USA. # The following options are the same as AM_INIT_AUTOMAKE in configure.in, # except no $(top_builddir) on ansi2knr. That directory is wanted for the # Makefiles in subdirectories, but here we must omit it so automake gives # the actual ansi2knr build rule, not "cd $(top_builddir) && make ansi2knr". # AUTOMAKE_OPTIONS = 1.8 gnu no-dependencies # Libtool -version-info for libgmp.la and libmp.la. See "Versioning" in the # libtool manual. # # 1. No interfaces changed, only implementations (good): Increment REVISION. # # 2. Interfaces added, none removed (good): Increment CURRENT, increment # AGE, set REVISION to 0. # # 3. Interfaces removed (BAD, breaks upward compatibility): Increment # CURRENT, set AGE and REVISION to 0. # # Do this separately for libgmp, libgmpxx and libmp, and only for releases. # # GMP -version-info # release libgmp libgmpxx libmp # 2.0.x - - - # 3.0 3:0:0 - 3:0:0 # 3.0.1 3:1:0 - 3:0:0 # 3.1 4:0:1 - 4:0:1 # 3.1.1 4:1:1 - 4:1:1 # 4.0 5:0:2 3:0:0 4:2:1 # 4.0.1 5:1:2 3:1:0 4:3:1 # 4.1 6:0:3 3:2:0 4:4:1 # 4.1.1 6:1:3 3:3:0 4:5:1 # 4.1.2 6:2:3 3:4:0 4:6:1 # 4.1.3 6:3:3 3:5:0 4:7:1 # 4.1.4 6:3:3 3:5:0 4:7:1 WRONG, same as 4.1.3! # 4.2 6:0:3 3:2:0 4:4:1 REALLY WRONG, same as 4.1! # 4.2.1 7:1:4 4:1:1 4:10:1 # # Starting at 3:0:0 is a slight abuse of the versioning system, but it # ensures we're past soname libgmp.so.2, which was used on Debian GNU/Linux # packages of gmp 2. Pretend gmp 2 was 2:0:0, so the interface changes for # gmp 3 mean 3:0:0 is right. # # We interpret "implementation changed" in item "1." above as meaning any # release, ie. the REVISION is incremented every time (if nothing else). # Even if we thought the code generated will be identical on all systems, # it's still good to get the shared library filename (like # libgmpxx.so.3.0.4) incrementing, to make it clear which GMP it's from. LIBGMP_LT_CURRENT = 7 LIBGMP_LT_REVISION = 1 LIBGMP_LT_AGE = 4 LIBGMPXX_LT_CURRENT = 4 LIBGMPXX_LT_REVISION = 1 LIBGMPXX_LT_AGE = 1 LIBMP_LT_CURRENT = 4 LIBMP_LT_REVISION = 10 LIBMP_LT_AGE = 1 SUBDIRS = mpn mpz # mpq cxx mpf tests demos tune EXTRA_DIST = macos configfsf.guess configfsf.sub .gdbinit INSTALL.autoconf if WANT_CXX GMPXX_HEADERS_OPTION = gmpxx.h endif EXTRA_DIST += gmpxx.h # gmp.h and mp.h are architecture dependent, mainly since they encode the # limb size used in libgmp. For that reason they belong under $exec_prefix # not $prefix, strictly speaking. # # $exec_prefix/include is not in the default include path for gcc built to # the same $prefix and $exec_prefix, which might mean gmp.h is not found, # but anyone knowledgable enough to be playing with exec_prefix will be able # to address that. # includeexecdir = $(exec_prefix)/include include_HEADERS = $(GMPXX_HEADERS_OPTION) nodist_includeexec_HEADERS = gmp.h $(MPBSD_HEADERS_OPTION) lib_LTLIBRARIES = libgmp.la $(GMPXX_LTLIBRARIES_OPTION) $(MPBSD_LTLIBRARIES_OPTION) BUILT_SOURCES = gmp.h DISTCLEANFILES = $(BUILT_SOURCES) config.m4 @gmp_srclinks@ # Tell gmp.h it's building gmp, not an application, used by windows DLL stuff. INCLUDES=-D__GMP_WITHIN_GMP MPF_OBJECTS = mpf/init$U.lo mpf/init2$U.lo mpf/set$U.lo mpf/set_ui$U.lo \ mpf/set_si$U.lo mpf/set_str$U.lo mpf/set_d$U.lo mpf/set_z$U.lo \ mpf/iset$U.lo mpf/iset_ui$U.lo mpf/iset_si$U.lo mpf/iset_str$U.lo \ mpf/iset_d$U.lo mpf/clear$U.lo mpf/get_str$U.lo mpf/dump$U.lo \ mpf/size$U.lo mpf/eq$U.lo mpf/reldiff$U.lo mpf/sqrt$U.lo mpf/random2$U.lo \ mpf/inp_str$U.lo mpf/out_str$U.lo mpf/add$U.lo mpf/add_ui$U.lo \ mpf/sub$U.lo mpf/sub_ui$U.lo mpf/ui_sub$U.lo mpf/mul$U.lo mpf/mul_ui$U.lo \ mpf/div$U.lo mpf/div_ui$U.lo \ mpf/cmp$U.lo mpf/cmp_d$U.lo mpf/cmp_ui$U.lo mpf/cmp_si$U.lo \ mpf/mul_2exp$U.lo mpf/div_2exp$U.lo mpf/abs$U.lo mpf/neg$U.lo \ mpf/set_q$U.lo mpf/get_d$U.lo mpf/get_d_2exp$U.lo mpf/set_dfl_prec$U.lo \ mpf/set_prc$U.lo mpf/set_prc_raw$U.lo mpf/get_dfl_prec$U.lo \ mpf/get_prc$U.lo mpf/ui_div$U.lo mpf/sqrt_ui$U.lo \ mpf/ceilfloor$U.lo mpf/trunc$U.lo mpf/pow_ui$U.lo \ mpf/urandomb$U.lo mpf/swap$U.lo \ mpf/fits_sint$U.lo mpf/fits_slong$U.lo mpf/fits_sshort$U.lo \ mpf/fits_uint$U.lo mpf/fits_ulong$U.lo mpf/fits_ushort$U.lo \ mpf/get_si$U.lo mpf/get_ui$U.lo \ mpf/int_p$U.lo MPZ_OBJECTS = mpz/abs$U.lo mpz/add$U.lo mpz/add_ui$U.lo \ mpz/aorsmul$U.lo mpz/aorsmul_i$U.lo mpz/and$U.lo mpz/array_init$U.lo \ mpz/bin_ui$U.lo mpz/bin_uiui$U.lo \ mpz/cdiv_q$U.lo mpz/cdiv_q_ui$U.lo \ mpz/cdiv_qr$U.lo mpz/cdiv_qr_ui$U.lo \ mpz/cdiv_r$U.lo mpz/cdiv_r_ui$U.lo mpz/cdiv_ui$U.lo \ mpz/cfdiv_q_2exp$U.lo mpz/cfdiv_r_2exp$U.lo \ mpz/clear$U.lo mpz/clrbit$U.lo \ mpz/cmp$U.lo mpz/cmp_d$U.lo mpz/cmp_si$U.lo mpz/cmp_ui$U.lo \ mpz/cmpabs$U.lo mpz/cmpabs_d$U.lo mpz/cmpabs_ui$U.lo \ mpz/com$U.lo mpz/combit$U.lo \ mpz/cong$U.lo mpz/cong_2exp$U.lo mpz/cong_ui$U.lo \ mpz/divexact$U.lo mpz/divegcd$U.lo mpz/dive_ui$U.lo \ mpz/divis$U.lo mpz/divis_ui$U.lo mpz/divis_2exp$U.lo mpz/dump$U.lo \ mpz/export$U.lo mpz/fac_ui$U.lo mpz/fdiv_q$U.lo \ mpz/fdiv_q_ui$U.lo mpz/fdiv_qr$U.lo mpz/fdiv_qr_ui$U.lo \ mpz/fdiv_r$U.lo mpz/fdiv_r_ui$U.lo \ mpz/fdiv_ui$U.lo mpz/fib_ui$U.lo mpz/fib2_ui$U.lo mpz/fits_sint$U.lo \ mpz/fits_slong$U.lo mpz/fits_sshort$U.lo mpz/fits_uint$U.lo \ mpz/fits_ulong$U.lo mpz/fits_ushort$U.lo mpz/gcd$U.lo \ mpz/gcd_ui$U.lo mpz/gcdext$U.lo mpz/get_d$U.lo mpz/get_d_2exp$U.lo \ mpz/get_si$U.lo mpz/get_str$U.lo mpz/get_ui$U.lo mpz/getlimbn$U.lo \ mpz/import$U.lo mpz/init$U.lo mpz/init2$U.lo mpz/inp_raw$U.lo \ mpz/inp_str$U.lo mpz/invert$U.lo \ mpz/ior$U.lo mpz/iset$U.lo mpz/iset_d$U.lo mpz/iset_si$U.lo \ mpz/iset_str$U.lo mpz/iset_ui$U.lo \ mpz/lcm$U.lo mpz/lcm_ui$U.lo mpz/lucnum_ui$U.lo mpz/lucnum2_ui$U.lo \ mpz/millerrabin$U.lo mpz/mod$U.lo mpz/mul$U.lo mpz/mul_2exp$U.lo \ mpz/mul_si$U.lo mpz/mul_ui$U.lo \ mpz/n_pow_ui$U.lo mpz/neg$U.lo mpz/nextprime$U.lo \ mpz/out_raw$U.lo mpz/out_str$U.lo mpz/perfpow$U.lo mpz/perfsqr$U.lo \ mpz/popcount$U.lo mpz/pow_ui$U.lo mpz/powm$U.lo mpz/powm_ui$U.lo \ mpz/pprime_p$U.lo mpz/random$U.lo mpz/random2$U.lo \ mpz/realloc$U.lo mpz/realloc2$U.lo mpz/remove$U.lo \ mpz/root$U.lo mpz/rootrem$U.lo mpz/rrandomb$U.lo mpz/scan0$U.lo \ mpz/scan1$U.lo mpz/set$U.lo mpz/set_d$U.lo mpz/set_f$U.lo \ mpz/set_q$U.lo mpz/set_si$U.lo mpz/set_str$U.lo mpz/set_ui$U.lo \ mpz/setbit$U.lo \ mpz/size$U.lo mpz/sizeinbase$U.lo mpz/sqrt$U.lo \ mpz/sqrtrem$U.lo mpz/sub$U.lo mpz/sub_ui$U.lo mpz/swap$U.lo \ mpz/tdiv_ui$U.lo mpz/tdiv_q$U.lo mpz/tdiv_q_2exp$U.lo \ mpz/tdiv_q_ui$U.lo mpz/tdiv_qr$U.lo mpz/tdiv_qr_ui$U.lo \ mpz/tdiv_r$U.lo mpz/tdiv_r_2exp$U.lo mpz/tdiv_r_ui$U.lo \ mpz/tstbit$U.lo mpz/ui_pow_ui$U.lo mpz/ui_sub$U.lo mpz/urandomb$U.lo \ mpz/urandomm$U.lo mpz/xor$U.lo MPQ_OBJECTS = mpq/abs$U.lo mpq/aors$U.lo \ mpq/canonicalize$U.lo mpq/clear$U.lo \ mpq/cmp$U.lo mpq/cmp_si$U.lo mpq/cmp_ui$U.lo mpq/div$U.lo \ mpq/get_d$U.lo mpq/get_den$U.lo mpq/get_num$U.lo mpq/get_str$U.lo \ mpq/init$U.lo mpq/inp_str$U.lo mpq/inv$U.lo \ mpq/md_2exp$U.lo mpq/mul$U.lo mpq/neg$U.lo mpq/out_str$U.lo \ mpq/set$U.lo mpq/set_den$U.lo mpq/set_num$U.lo \ mpq/set_si$U.lo mpq/set_str$U.lo mpq/set_ui$U.lo \ mpq/equal$U.lo mpq/set_z$U.lo mpq/set_d$U.lo \ mpq/set_f$U.lo mpq/swap$U.lo MPN_OBJECTS = mpn/fib_table$U.lo mpn/mp_bases$U.lo # no $U for C++ files CXX_OBJECTS = \ cxx/isfuns.lo cxx/ismpf.lo cxx/ismpq.lo cxx/ismpz.lo cxx/ismpznw.lo \ cxx/osdoprnti.lo cxx/osfuns.lo \ cxx/osmpf.lo cxx/osmpq.lo cxx/osmpz.lo MPBSD_OBJECTS = mpbsd/add$U.lo mpbsd/tdiv_qr$U.lo mpbsd/set$U.lo \ mpbsd/powm$U.lo mpbsd/sub$U.lo mpbsd/cmp$U.lo mpbsd/mfree$U.lo \ mpbsd/mtox$U.lo mpbsd/realloc$U.lo mpbsd/gcd$U.lo mpbsd/itom$U.lo \ mpbsd/min$U.lo mpbsd/mul$U.lo mpbsd/mout$U.lo mpbsd/rpow$U.lo \ mpbsd/sdiv$U.lo mpbsd/sqrtrem$U.lo mpbsd/xtom$U.lo # In libtool 1.5 it doesn't work to build libgmp.la from the convenience # libraries like mpz/libmpz.la. Or rather it works, but it ends up putting # PIC objects into libgmp.a if shared and static are both built. (The PIC # objects go into mpz/.libs/libmpz.a, and thence into .libs/libgmp.a.) # # For now the big lists of objects above are used. Something like mpz/*.lo # would probably work, but might risk missing something out or getting # something extra. The source files for each .lo are listed in the # Makefile.am's in the subdirectories. # # Currently, for libgmp, unlike libmp below, we're not using # -export-symbols, since the tune and speed programs, and perhaps some of # the test programs, want to access undocumented symbols. libgmp_la_SOURCES = gmp-impl.h longlong.h randmt.h \ assert.c compat.c errno.c extract-dbl.c invalid.c memory.c \ mp_bpl.c mp_clz_tab.c mp_dv_tab.c mp_minv_tab.c mp_get_fns.c mp_set_fns.c \ rand.c randclr.c randdef.c randiset.c randlc2s.c randlc2x.c randmt.c \ randmts.c rands.c randsd.c randsdui.c randbui.c randmui.c version.c EXTRA_libgmp_la_SOURCES = tal-debug.c tal-notreent.c tal-reent.c libgmp_la_DEPENDENCIES = @TAL_OBJECT@ \ $(MPZ_OBJECTS) $(MPN_OBJECTS) @mpn_objs_in_libgmp@ \ # $(MPF_OBJECTS) $(MPQ_OBJECTS) libgmp_la_LIBADD = $(libgmp_la_DEPENDENCIES) libgmp_la_LDFLAGS = $(GMP_LDFLAGS) $(LIBGMP_LDFLAGS) \ -version-info $(LIBGMP_LT_CURRENT):$(LIBGMP_LT_REVISION):$(LIBGMP_LT_AGE) # We need at least one .cc file in $(libgmpxx_la_SOURCES) so automake will # use $(CXXLINK) rather than the plain C $(LINK). cxx/dummy.cc is that # file. if WANT_CXX GMPXX_LTLIBRARIES_OPTION = libgmpxx.la endif libgmpxx_la_SOURCES = cxx/dummy.cc libgmpxx_la_DEPENDENCIES = $(CXX_OBJECTS) libgmp.la libgmpxx_la_LIBADD = $(libgmpxx_la_DEPENDENCIES) libgmpxx_la_LDFLAGS = $(GMP_LDFLAGS) $(LIBGMPXX_LDFLAGS) \ -version-info $(LIBGMPXX_LT_CURRENT):$(LIBGMPXX_LT_REVISION):$(LIBGMPXX_LT_AGE) # The selected mpz objects here support mpz/powm.c (built as mpbsd/powm.lo) # and can probably be removed when that switches to an mpn implementation. # (Apart from mpz/n_pow_ui$U.lo, which supports mpbsd/rpow.c) if WANT_MPBSD MPBSD_HEADERS_OPTION = mp.h MPBSD_LTLIBRARIES_OPTION = libmp.la endif BUILT_SOURCES += mp.h libmp_la_SOURCES = assert.c errno.c memory.c mp_bpl.c mp_clz_tab.c \ mp_dv_tab.c mp_minv_tab.c mp_get_fns.c mp_set_fns.c libmp_la_DEPENDENCIES = $(srcdir)/libmp.sym \ @TAL_OBJECT@ $(MPBSD_OBJECTS) $(MPN_OBJECTS) @mpn_objs_in_libmp@ \ mpz/add$U.lo mpz/gcdext$U.lo mpz/invert$U.lo mpz/mul$U.lo \ mpz/n_pow_ui$U.lo mpz/realloc$U.lo mpz/set$U.lo mpz/sub$U.lo \ mpz/tdiv_q$U.lo libmp_la_LIBADD = $(libmp_la_DEPENDENCIES) libmp_la_LDFLAGS = $(GMP_LDFLAGS) \ -version-info $(LIBMP_LT_CURRENT):$(LIBMP_LT_REVISION):$(LIBMP_LT_AGE) \ -export-symbols $(srcdir)/libmp.sym EXTRA_DIST += libmp.sym install-data-hook: @echo '' @echo '+-------------------------------------------------------------+' @echo '| CAUTION: |' @echo '| |' @echo '| If you have not already run "make check", then we strongly |' @echo '| recommend you do so. |' @echo '| |' @echo '| GMP has been carefully tested by its authors, but compilers |' @echo '| are all too often released with serious bugs. GMP tends to |' @echo '| explore interesting corners in compilers and has hit bugs |' @echo '| on quite a few occasions. |' @echo '| |' @echo '+-------------------------------------------------------------+' @echo '' # The "test -f" support for srcdir!=builddir is similar to the automake .c.o # etc rules, but with each foo.c explicitly, since $< is not portable # outside an inference rule. # # A quoted 'foo.c' is used with the "test -f"'s to avoid Sun make rewriting # it as part of its VPATH support. See the autoconf manual "Limitations of # Make". # # Generated .h files which are used by gmp-impl.h are BUILT_SOURCES since # they must exist before anything can be compiled. # # Other generated .h files are also BUILT_SOURCES so as to get all the # build-system stuff over and done with at the start. Also, dependencies on # the .h files are not properly expressed for the various objects that use # them. EXTRA_DIST += dumbmp.c mpz/fac_ui.h: gen-fac_ui$(EXEEXT_FOR_BUILD) ./gen-fac_ui $(BITS_PER_MP_LIMB) $(GMP_NAIL_BITS) >mpz/fac_ui.h || (rm -f mpz/fac_ui.h; exit 1) BUILT_SOURCES += mpz/fac_ui.h gen-fac_ui$(EXEEXT_FOR_BUILD): gen-fac_ui.c dumbmp.c $(CC_FOR_BUILD) $(srcdir)/gen-fac_ui.c -o gen-fac_ui$(EXEEXT_FOR_BUILD) EXTRA_DIST += gen-fac_ui.c fib_table.h: gen-fib$(EXEEXT_FOR_BUILD) ./gen-fib header $(BITS_PER_MP_LIMB) $(GMP_NAIL_BITS) >fib_table.h || (rm -f fib_table.h; exit 1) BUILT_SOURCES += fib_table.h mpn/fib_table.c: gen-fib$(EXEEXT_FOR_BUILD) ./gen-fib table $(BITS_PER_MP_LIMB) $(GMP_NAIL_BITS) >mpn/fib_table.c || (rm -f mpn/fib_table.c; exit 1) BUILT_SOURCES += mpn/fib_table.c gen-fib$(EXEEXT_FOR_BUILD): gen-fib.c dumbmp.c $(CC_FOR_BUILD) $(srcdir)/gen-fib.c -o gen-fib$(EXEEXT_FOR_BUILD) EXTRA_DIST += gen-fib.c mp_bases.h: gen-bases$(EXEEXT_FOR_BUILD) ./gen-bases header $(BITS_PER_MP_LIMB) $(GMP_NAIL_BITS) >mp_bases.h || (rm -f mp_bases.h; exit 1) BUILT_SOURCES += mp_bases.h mpn/mp_bases.c: gen-bases$(EXEEXT_FOR_BUILD) ./gen-bases table $(BITS_PER_MP_LIMB) $(GMP_NAIL_BITS) >mpn/mp_bases.c || (rm -f mpn/mp_bases.c; exit 1) BUILT_SOURCES += mpn/mp_bases.c gen-bases$(EXEEXT_FOR_BUILD): gen-bases.c dumbmp.c $(CC_FOR_BUILD) $(srcdir)/gen-bases.c -o gen-bases$(EXEEXT_FOR_BUILD) $(LIBM_FOR_BUILD) EXTRA_DIST += gen-bases.c mpn/perfsqr.h: gen-psqr$(EXEEXT_FOR_BUILD) ./gen-psqr $(BITS_PER_MP_LIMB) $(GMP_NAIL_BITS) >mpn/perfsqr.h || (rm -f mpn/perfsqr.h; exit 1) BUILT_SOURCES += mpn/perfsqr.h gen-psqr$(EXEEXT_FOR_BUILD): gen-psqr.c dumbmp.c $(CC_FOR_BUILD) $(srcdir)/gen-psqr.c -o gen-psqr$(EXEEXT_FOR_BUILD) $(LIBM_FOR_BUILD) EXTRA_DIST += gen-psqr.c # Avoid: CVS - cvs directories # *~ - emacs backups # .#* - cvs merge originals # # *~ and .#* only occur when a whole directory without it's own Makefile.am # is distributed, like "doc" or the mpn cpu subdirectories. # dist-hook: -find $(distdir) \( -name CVS -type d \) -o -name "*~" -o -name ".#*" \ | xargs rm -rf ecl-16.1.2/src/gmp/Makefile.in000066400000000000000000001456611266352375300160140ustar00rootroot00000000000000# Makefile.in generated by automake 1.15 from Makefile.am. # @configure_input@ # Copyright (C) 1994-2014 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@ # Copyright 1991, 1993, 1994, 1996, 1997, 1999, 2000, 2001, 2002, 2003, 2004, # 2006 Free Software Foundation, Inc. # # This file is part of the GNU MP Library. # # The GNU MP Library is free software; you can redistribute it and/or modify # it under the terms of the GNU Lesser General Public License as published by # the Free Software Foundation; either version 2.1 of the License, or (at your # option) any later version. # # The GNU MP Library is distributed in the hope that it will be useful, but # WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY # or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public # License for more details. # # You should have received a copy of the GNU Lesser General Public License # along with the GNU MP Library; see the file COPYING.LIB. If not, write to # the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, # MA 02110-1301, USA. VPATH = @srcdir@ am__is_gnu_make = { \ if test -z '$(MAKELEVEL)'; then \ false; \ elif test -n '$(MAKE_HOST)'; then \ true; \ elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \ true; \ else \ false; \ fi; \ } am__make_running_with_option = \ case $${target_option-} in \ ?) ;; \ *) echo "am__make_running_with_option: internal error: invalid" \ "target option '$${target_option-}' specified" >&2; \ exit 1;; \ esac; \ has_opt=no; \ sane_makeflags=$$MAKEFLAGS; \ if $(am__is_gnu_make); then \ sane_makeflags=$$MFLAGS; \ else \ case $$MAKEFLAGS in \ *\\[\ \ ]*) \ bs=\\; \ sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \ | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \ esac; \ fi; \ skip_next=no; \ strip_trailopt () \ { \ flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \ }; \ for flg in $$sane_makeflags; do \ test $$skip_next = yes && { skip_next=no; continue; }; \ case $$flg in \ *=*|--*) continue;; \ -*I) strip_trailopt 'I'; skip_next=yes;; \ -*I?*) strip_trailopt 'I';; \ -*O) strip_trailopt 'O'; skip_next=yes;; \ -*O?*) strip_trailopt 'O';; \ -*l) strip_trailopt 'l'; skip_next=yes;; \ -*l?*) strip_trailopt 'l';; \ -[dEDm]) skip_next=yes;; \ -[JT]) skip_next=yes;; \ esac; \ case $$flg in \ *$$target_option*) has_opt=yes; break;; \ esac; \ done; \ test $$has_opt = yes am__make_dryrun = (target_option=n; $(am__make_running_with_option)) am__make_keepgoing = (target_option=k; $(am__make_running_with_option)) 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 = . ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 am__aclocal_m4_deps = $(top_srcdir)/acinclude.m4 \ $(top_srcdir)/configure.in am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ $(ACLOCAL_M4) DIST_COMMON = $(srcdir)/Makefile.am $(top_srcdir)/configure \ $(am__configure_deps) $(am__include_HEADERS_DIST) \ $(am__DIST_COMMON) 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 = gmp.h mp.h gmp-mparam.h 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)$(includedir)" \ "$(DESTDIR)$(includeexecdir)" LTLIBRARIES = $(lib_LTLIBRARIES) am__DEPENDENCIES_1 = $(MPZ_OBJECTS) $(MPN_OBJECTS) am_libgmp_la_OBJECTS = assert.lo compat.lo errno.lo extract-dbl.lo \ invalid.lo memory.lo mp_bpl.lo mp_clz_tab.lo mp_dv_tab.lo \ mp_minv_tab.lo mp_get_fns.lo mp_set_fns.lo rand.lo randclr.lo \ randdef.lo randiset.lo randlc2s.lo randlc2x.lo randmt.lo \ randmts.lo rands.lo randsd.lo randsdui.lo randbui.lo \ randmui.lo version.lo libgmp_la_OBJECTS = $(am_libgmp_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 = libgmp_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \ $(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \ $(libgmp_la_LDFLAGS) $(LDFLAGS) -o $@ am_libgmpxx_la_OBJECTS = dummy.lo libgmpxx_la_OBJECTS = $(am_libgmpxx_la_OBJECTS) libgmpxx_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \ $(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \ $(CXXFLAGS) $(libgmpxx_la_LDFLAGS) $(LDFLAGS) -o $@ @WANT_CXX_TRUE@am_libgmpxx_la_rpath = -rpath $(libdir) am__DEPENDENCIES_2 = $(srcdir)/libmp.sym $(MPBSD_OBJECTS) \ $(MPN_OBJECTS) mpz/add$U.lo mpz/gcdext$U.lo mpz/invert$U.lo \ mpz/mul$U.lo mpz/n_pow_ui$U.lo mpz/realloc$U.lo mpz/set$U.lo \ mpz/sub$U.lo mpz/tdiv_q$U.lo am_libmp_la_OBJECTS = assert.lo errno.lo memory.lo mp_bpl.lo \ mp_clz_tab.lo mp_dv_tab.lo mp_minv_tab.lo mp_get_fns.lo \ mp_set_fns.lo libmp_la_OBJECTS = $(am_libmp_la_OBJECTS) libmp_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \ $(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \ $(libmp_la_LDFLAGS) $(LDFLAGS) -o $@ @WANT_MPBSD_TRUE@am_libmp_la_rpath = -rpath $(libdir) 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 = am__depfiles_maybe = COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \ $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) LTCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \ $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) \ $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \ $(AM_CFLAGS) $(CFLAGS) AM_V_CC = $(am__v_CC_@AM_V@) am__v_CC_ = $(am__v_CC_@AM_DEFAULT_V@) am__v_CC_0 = @echo " CC " $@; am__v_CC_1 = CCLD = $(CC) LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \ $(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \ $(AM_LDFLAGS) $(LDFLAGS) -o $@ AM_V_CCLD = $(am__v_CCLD_@AM_V@) am__v_CCLD_ = $(am__v_CCLD_@AM_DEFAULT_V@) am__v_CCLD_0 = @echo " CCLD " $@; am__v_CCLD_1 = 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 = $(libgmp_la_SOURCES) $(EXTRA_libgmp_la_SOURCES) \ $(libgmpxx_la_SOURCES) $(libmp_la_SOURCES) DIST_SOURCES = $(libgmp_la_SOURCES) $(EXTRA_libgmp_la_SOURCES) \ $(libgmpxx_la_SOURCES) $(libmp_la_SOURCES) RECURSIVE_TARGETS = all-recursive check-recursive cscopelist-recursive \ ctags-recursive dvi-recursive html-recursive info-recursive \ install-data-recursive install-dvi-recursive \ install-exec-recursive install-html-recursive \ install-info-recursive install-pdf-recursive \ install-ps-recursive install-recursive installcheck-recursive \ installdirs-recursive pdf-recursive ps-recursive \ tags-recursive uninstall-recursive am__can_run_installinfo = \ case $$AM_UPDATE_INFO_DIR in \ n|no|NO) false;; \ *) (install-info --version) >/dev/null 2>&1;; \ esac am__include_HEADERS_DIST = gmpxx.h HEADERS = $(include_HEADERS) $(nodist_includeexec_HEADERS) RECURSIVE_CLEAN_TARGETS = mostlyclean-recursive clean-recursive \ distclean-recursive maintainer-clean-recursive am__recursive_targets = \ $(RECURSIVE_TARGETS) \ $(RECURSIVE_CLEAN_TARGETS) \ $(am__extra_recursive_targets) AM_RECURSIVE_TARGETS = $(am__recursive_targets:-recursive=) TAGS CTAGS \ cscope distdir dist dist-all distcheck am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) \ $(LISP)config.in # Read a list of newline-separated strings from the standard input, # and print each of them once, without duplicates. Input order is # *not* preserved. am__uniquify_input = $(AWK) '\ BEGIN { nonempty = 0; } \ { items[$$0] = 1; nonempty = 1; } \ END { if (nonempty) { for (i in items) print i; }; } \ ' # Make sure the list of sources is unique. This is necessary because, # e.g., the same source file might be shared among _SOURCES variables # for different programs/libraries. am__define_uniq_tagged_files = \ list='$(am__tagged_files)'; \ unique=`for i in $$list; do \ if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ done | $(am__uniquify_input)` ETAGS = etags CTAGS = ctags CSCOPE = cscope DIST_SUBDIRS = $(SUBDIRS) am__DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/config.in \ $(srcdir)/gmp-h.in $(srcdir)/mp-h.in AUTHORS COPYING \ COPYING.LIB ChangeLog INSTALL NEWS README compile config.guess \ config.sub install-sh ltmain.sh missing 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) am__relativize = \ dir0=`pwd`; \ sed_first='s,^\([^/]*\)/.*$$,\1,'; \ sed_rest='s,^[^/]*/*,,'; \ sed_last='s,^.*/\([^/]*\)$$,\1,'; \ sed_butlast='s,/*[^/]*$$,,'; \ while test -n "$$dir1"; do \ first=`echo "$$dir1" | sed -e "$$sed_first"`; \ if test "$$first" != "."; then \ if test "$$first" = ".."; then \ dir2=`echo "$$dir0" | sed -e "$$sed_last"`/"$$dir2"; \ dir0=`echo "$$dir0" | sed -e "$$sed_butlast"`; \ else \ first2=`echo "$$dir2" | sed -e "$$sed_first"`; \ if test "$$first2" = "$$first"; then \ dir2=`echo "$$dir2" | sed -e "$$sed_rest"`; \ else \ dir2="../$$dir2"; \ fi; \ dir0="$$dir0"/"$$first"; \ fi; \ fi; \ dir1=`echo "$$dir1" | sed -e "$$sed_rest"`; \ done; \ reldir="$$dir2" 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 ABI = @ABI@ ACLOCAL = @ACLOCAL@ AMTAR = @AMTAR@ AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@ AR = @AR@ AS = @AS@ AUTOCONF = @AUTOCONF@ AUTOHEADER = @AUTOHEADER@ AUTOMAKE = @AUTOMAKE@ AWK = @AWK@ BITS_PER_MP_LIMB = @BITS_PER_MP_LIMB@ CALLING_CONVENTIONS_OBJS = @CALLING_CONVENTIONS_OBJS@ CC = @CC@ CCAS = @CCAS@ CC_FOR_BUILD = @CC_FOR_BUILD@ CFLAGS = @CFLAGS@ CPP = @CPP@ CPPFLAGS = @CPPFLAGS@ CPP_FOR_BUILD = @CPP_FOR_BUILD@ CXX = @CXX@ CXXCPP = @CXXCPP@ CXXFLAGS = @CXXFLAGS@ CYGPATH_W = @CYGPATH_W@ DEFN_LONG_LONG_LIMB = @DEFN_LONG_LONG_LIMB@ DEFS = @DEFS@ DLLTOOL = @DLLTOOL@ DSYMUTIL = @DSYMUTIL@ DUMPBIN = @DUMPBIN@ ECHO_C = @ECHO_C@ ECHO_N = @ECHO_N@ ECHO_T = @ECHO_T@ EGREP = @EGREP@ EXEEXT = @EXEEXT@ EXEEXT_FOR_BUILD = @EXEEXT_FOR_BUILD@ FGREP = @FGREP@ GMP_LDFLAGS = @GMP_LDFLAGS@ GMP_NAIL_BITS = @GMP_NAIL_BITS@ GREP = @GREP@ HAVE_HOST_CPU_FAMILY_power = @HAVE_HOST_CPU_FAMILY_power@ HAVE_HOST_CPU_FAMILY_powerpc = @HAVE_HOST_CPU_FAMILY_powerpc@ INSTALL = @INSTALL@ INSTALL_DATA = @INSTALL_DATA@ INSTALL_PROGRAM = @INSTALL_PROGRAM@ INSTALL_SCRIPT = @INSTALL_SCRIPT@ INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ LD = @LD@ LDFLAGS = @LDFLAGS@ LIBGMPXX_LDFLAGS = @LIBGMPXX_LDFLAGS@ LIBGMP_DLL = @LIBGMP_DLL@ LIBGMP_LDFLAGS = @LIBGMP_LDFLAGS@ LIBM = @LIBM@ LIBM_FOR_BUILD = @LIBM_FOR_BUILD@ LIBOBJS = @LIBOBJS@ LIBS = @LIBS@ LIBTOOL = @LIBTOOL@ LIPO = @LIPO@ LN_S = @LN_S@ LTLIBOBJS = @LTLIBOBJS@ LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@ M4 = @M4@ 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@ SPEED_CYCLECOUNTER_OBJ = @SPEED_CYCLECOUNTER_OBJ@ STRIP = @STRIP@ TAL_OBJECT = @TAL_OBJECT@ TUNE_SQR_OBJ = @TUNE_SQR_OBJ@ 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__leading_dot = @am__leading_dot@ 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@ gmp_srclinks = @gmp_srclinks@ 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@ mpn_objects = @mpn_objects@ mpn_objs_in_libgmp = @mpn_objs_in_libgmp@ mpn_objs_in_libmp = @mpn_objs_in_libmp@ 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@ # The following options are the same as AM_INIT_AUTOMAKE in configure.in, # except no $(top_builddir) on ansi2knr. That directory is wanted for the # Makefiles in subdirectories, but here we must omit it so automake gives # the actual ansi2knr build rule, not "cd $(top_builddir) && make ansi2knr". # AUTOMAKE_OPTIONS = 1.8 gnu no-dependencies # Libtool -version-info for libgmp.la and libmp.la. See "Versioning" in the # libtool manual. # # 1. No interfaces changed, only implementations (good): Increment REVISION. # # 2. Interfaces added, none removed (good): Increment CURRENT, increment # AGE, set REVISION to 0. # # 3. Interfaces removed (BAD, breaks upward compatibility): Increment # CURRENT, set AGE and REVISION to 0. # # Do this separately for libgmp, libgmpxx and libmp, and only for releases. # # GMP -version-info # release libgmp libgmpxx libmp # 2.0.x - - - # 3.0 3:0:0 - 3:0:0 # 3.0.1 3:1:0 - 3:0:0 # 3.1 4:0:1 - 4:0:1 # 3.1.1 4:1:1 - 4:1:1 # 4.0 5:0:2 3:0:0 4:2:1 # 4.0.1 5:1:2 3:1:0 4:3:1 # 4.1 6:0:3 3:2:0 4:4:1 # 4.1.1 6:1:3 3:3:0 4:5:1 # 4.1.2 6:2:3 3:4:0 4:6:1 # 4.1.3 6:3:3 3:5:0 4:7:1 # 4.1.4 6:3:3 3:5:0 4:7:1 WRONG, same as 4.1.3! # 4.2 6:0:3 3:2:0 4:4:1 REALLY WRONG, same as 4.1! # 4.2.1 7:1:4 4:1:1 4:10:1 # # Starting at 3:0:0 is a slight abuse of the versioning system, but it # ensures we're past soname libgmp.so.2, which was used on Debian GNU/Linux # packages of gmp 2. Pretend gmp 2 was 2:0:0, so the interface changes for # gmp 3 mean 3:0:0 is right. # # We interpret "implementation changed" in item "1." above as meaning any # release, ie. the REVISION is incremented every time (if nothing else). # Even if we thought the code generated will be identical on all systems, # it's still good to get the shared library filename (like # libgmpxx.so.3.0.4) incrementing, to make it clear which GMP it's from. LIBGMP_LT_CURRENT = 7 LIBGMP_LT_REVISION = 1 LIBGMP_LT_AGE = 4 LIBGMPXX_LT_CURRENT = 4 LIBGMPXX_LT_REVISION = 1 LIBGMPXX_LT_AGE = 1 LIBMP_LT_CURRENT = 4 LIBMP_LT_REVISION = 10 LIBMP_LT_AGE = 1 SUBDIRS = mpn mpz # mpq cxx mpf tests demos tune # The "test -f" support for srcdir!=builddir is similar to the automake .c.o # etc rules, but with each foo.c explicitly, since $< is not portable # outside an inference rule. # # A quoted 'foo.c' is used with the "test -f"'s to avoid Sun make rewriting # it as part of its VPATH support. See the autoconf manual "Limitations of # Make". # # Generated .h files which are used by gmp-impl.h are BUILT_SOURCES since # they must exist before anything can be compiled. # # Other generated .h files are also BUILT_SOURCES so as to get all the # build-system stuff over and done with at the start. Also, dependencies on # the .h files are not properly expressed for the various objects that use # them. EXTRA_DIST = macos configfsf.guess configfsf.sub .gdbinit \ INSTALL.autoconf gmpxx.h libmp.sym dumbmp.c gen-fac_ui.c \ gen-fib.c gen-bases.c gen-psqr.c @WANT_CXX_TRUE@GMPXX_HEADERS_OPTION = gmpxx.h # gmp.h and mp.h are architecture dependent, mainly since they encode the # limb size used in libgmp. For that reason they belong under $exec_prefix # not $prefix, strictly speaking. # # $exec_prefix/include is not in the default include path for gcc built to # the same $prefix and $exec_prefix, which might mean gmp.h is not found, # but anyone knowledgable enough to be playing with exec_prefix will be able # to address that. # includeexecdir = $(exec_prefix)/include include_HEADERS = $(GMPXX_HEADERS_OPTION) nodist_includeexec_HEADERS = gmp.h $(MPBSD_HEADERS_OPTION) lib_LTLIBRARIES = libgmp.la $(GMPXX_LTLIBRARIES_OPTION) $(MPBSD_LTLIBRARIES_OPTION) BUILT_SOURCES = gmp.h mp.h mpz/fac_ui.h fib_table.h mpn/fib_table.c \ mp_bases.h mpn/mp_bases.c mpn/perfsqr.h DISTCLEANFILES = $(BUILT_SOURCES) config.m4 @gmp_srclinks@ # Tell gmp.h it's building gmp, not an application, used by windows DLL stuff. INCLUDES = -D__GMP_WITHIN_GMP MPF_OBJECTS = mpf/init$U.lo mpf/init2$U.lo mpf/set$U.lo mpf/set_ui$U.lo \ mpf/set_si$U.lo mpf/set_str$U.lo mpf/set_d$U.lo mpf/set_z$U.lo \ mpf/iset$U.lo mpf/iset_ui$U.lo mpf/iset_si$U.lo mpf/iset_str$U.lo \ mpf/iset_d$U.lo mpf/clear$U.lo mpf/get_str$U.lo mpf/dump$U.lo \ mpf/size$U.lo mpf/eq$U.lo mpf/reldiff$U.lo mpf/sqrt$U.lo mpf/random2$U.lo \ mpf/inp_str$U.lo mpf/out_str$U.lo mpf/add$U.lo mpf/add_ui$U.lo \ mpf/sub$U.lo mpf/sub_ui$U.lo mpf/ui_sub$U.lo mpf/mul$U.lo mpf/mul_ui$U.lo \ mpf/div$U.lo mpf/div_ui$U.lo \ mpf/cmp$U.lo mpf/cmp_d$U.lo mpf/cmp_ui$U.lo mpf/cmp_si$U.lo \ mpf/mul_2exp$U.lo mpf/div_2exp$U.lo mpf/abs$U.lo mpf/neg$U.lo \ mpf/set_q$U.lo mpf/get_d$U.lo mpf/get_d_2exp$U.lo mpf/set_dfl_prec$U.lo \ mpf/set_prc$U.lo mpf/set_prc_raw$U.lo mpf/get_dfl_prec$U.lo \ mpf/get_prc$U.lo mpf/ui_div$U.lo mpf/sqrt_ui$U.lo \ mpf/ceilfloor$U.lo mpf/trunc$U.lo mpf/pow_ui$U.lo \ mpf/urandomb$U.lo mpf/swap$U.lo \ mpf/fits_sint$U.lo mpf/fits_slong$U.lo mpf/fits_sshort$U.lo \ mpf/fits_uint$U.lo mpf/fits_ulong$U.lo mpf/fits_ushort$U.lo \ mpf/get_si$U.lo mpf/get_ui$U.lo \ mpf/int_p$U.lo MPZ_OBJECTS = mpz/abs$U.lo mpz/add$U.lo mpz/add_ui$U.lo \ mpz/aorsmul$U.lo mpz/aorsmul_i$U.lo mpz/and$U.lo mpz/array_init$U.lo \ mpz/bin_ui$U.lo mpz/bin_uiui$U.lo \ mpz/cdiv_q$U.lo mpz/cdiv_q_ui$U.lo \ mpz/cdiv_qr$U.lo mpz/cdiv_qr_ui$U.lo \ mpz/cdiv_r$U.lo mpz/cdiv_r_ui$U.lo mpz/cdiv_ui$U.lo \ mpz/cfdiv_q_2exp$U.lo mpz/cfdiv_r_2exp$U.lo \ mpz/clear$U.lo mpz/clrbit$U.lo \ mpz/cmp$U.lo mpz/cmp_d$U.lo mpz/cmp_si$U.lo mpz/cmp_ui$U.lo \ mpz/cmpabs$U.lo mpz/cmpabs_d$U.lo mpz/cmpabs_ui$U.lo \ mpz/com$U.lo mpz/combit$U.lo \ mpz/cong$U.lo mpz/cong_2exp$U.lo mpz/cong_ui$U.lo \ mpz/divexact$U.lo mpz/divegcd$U.lo mpz/dive_ui$U.lo \ mpz/divis$U.lo mpz/divis_ui$U.lo mpz/divis_2exp$U.lo mpz/dump$U.lo \ mpz/export$U.lo mpz/fac_ui$U.lo mpz/fdiv_q$U.lo \ mpz/fdiv_q_ui$U.lo mpz/fdiv_qr$U.lo mpz/fdiv_qr_ui$U.lo \ mpz/fdiv_r$U.lo mpz/fdiv_r_ui$U.lo \ mpz/fdiv_ui$U.lo mpz/fib_ui$U.lo mpz/fib2_ui$U.lo mpz/fits_sint$U.lo \ mpz/fits_slong$U.lo mpz/fits_sshort$U.lo mpz/fits_uint$U.lo \ mpz/fits_ulong$U.lo mpz/fits_ushort$U.lo mpz/gcd$U.lo \ mpz/gcd_ui$U.lo mpz/gcdext$U.lo mpz/get_d$U.lo mpz/get_d_2exp$U.lo \ mpz/get_si$U.lo mpz/get_str$U.lo mpz/get_ui$U.lo mpz/getlimbn$U.lo \ mpz/import$U.lo mpz/init$U.lo mpz/init2$U.lo mpz/inp_raw$U.lo \ mpz/inp_str$U.lo mpz/invert$U.lo \ mpz/ior$U.lo mpz/iset$U.lo mpz/iset_d$U.lo mpz/iset_si$U.lo \ mpz/iset_str$U.lo mpz/iset_ui$U.lo \ mpz/lcm$U.lo mpz/lcm_ui$U.lo mpz/lucnum_ui$U.lo mpz/lucnum2_ui$U.lo \ mpz/millerrabin$U.lo mpz/mod$U.lo mpz/mul$U.lo mpz/mul_2exp$U.lo \ mpz/mul_si$U.lo mpz/mul_ui$U.lo \ mpz/n_pow_ui$U.lo mpz/neg$U.lo mpz/nextprime$U.lo \ mpz/out_raw$U.lo mpz/out_str$U.lo mpz/perfpow$U.lo mpz/perfsqr$U.lo \ mpz/popcount$U.lo mpz/pow_ui$U.lo mpz/powm$U.lo mpz/powm_ui$U.lo \ mpz/pprime_p$U.lo mpz/random$U.lo mpz/random2$U.lo \ mpz/realloc$U.lo mpz/realloc2$U.lo mpz/remove$U.lo \ mpz/root$U.lo mpz/rootrem$U.lo mpz/rrandomb$U.lo mpz/scan0$U.lo \ mpz/scan1$U.lo mpz/set$U.lo mpz/set_d$U.lo mpz/set_f$U.lo \ mpz/set_q$U.lo mpz/set_si$U.lo mpz/set_str$U.lo mpz/set_ui$U.lo \ mpz/setbit$U.lo \ mpz/size$U.lo mpz/sizeinbase$U.lo mpz/sqrt$U.lo \ mpz/sqrtrem$U.lo mpz/sub$U.lo mpz/sub_ui$U.lo mpz/swap$U.lo \ mpz/tdiv_ui$U.lo mpz/tdiv_q$U.lo mpz/tdiv_q_2exp$U.lo \ mpz/tdiv_q_ui$U.lo mpz/tdiv_qr$U.lo mpz/tdiv_qr_ui$U.lo \ mpz/tdiv_r$U.lo mpz/tdiv_r_2exp$U.lo mpz/tdiv_r_ui$U.lo \ mpz/tstbit$U.lo mpz/ui_pow_ui$U.lo mpz/ui_sub$U.lo mpz/urandomb$U.lo \ mpz/urandomm$U.lo mpz/xor$U.lo MPQ_OBJECTS = mpq/abs$U.lo mpq/aors$U.lo \ mpq/canonicalize$U.lo mpq/clear$U.lo \ mpq/cmp$U.lo mpq/cmp_si$U.lo mpq/cmp_ui$U.lo mpq/div$U.lo \ mpq/get_d$U.lo mpq/get_den$U.lo mpq/get_num$U.lo mpq/get_str$U.lo \ mpq/init$U.lo mpq/inp_str$U.lo mpq/inv$U.lo \ mpq/md_2exp$U.lo mpq/mul$U.lo mpq/neg$U.lo mpq/out_str$U.lo \ mpq/set$U.lo mpq/set_den$U.lo mpq/set_num$U.lo \ mpq/set_si$U.lo mpq/set_str$U.lo mpq/set_ui$U.lo \ mpq/equal$U.lo mpq/set_z$U.lo mpq/set_d$U.lo \ mpq/set_f$U.lo mpq/swap$U.lo MPN_OBJECTS = mpn/fib_table$U.lo mpn/mp_bases$U.lo # no $U for C++ files CXX_OBJECTS = \ cxx/isfuns.lo cxx/ismpf.lo cxx/ismpq.lo cxx/ismpz.lo cxx/ismpznw.lo \ cxx/osdoprnti.lo cxx/osfuns.lo \ cxx/osmpf.lo cxx/osmpq.lo cxx/osmpz.lo MPBSD_OBJECTS = mpbsd/add$U.lo mpbsd/tdiv_qr$U.lo mpbsd/set$U.lo \ mpbsd/powm$U.lo mpbsd/sub$U.lo mpbsd/cmp$U.lo mpbsd/mfree$U.lo \ mpbsd/mtox$U.lo mpbsd/realloc$U.lo mpbsd/gcd$U.lo mpbsd/itom$U.lo \ mpbsd/min$U.lo mpbsd/mul$U.lo mpbsd/mout$U.lo mpbsd/rpow$U.lo \ mpbsd/sdiv$U.lo mpbsd/sqrtrem$U.lo mpbsd/xtom$U.lo # In libtool 1.5 it doesn't work to build libgmp.la from the convenience # libraries like mpz/libmpz.la. Or rather it works, but it ends up putting # PIC objects into libgmp.a if shared and static are both built. (The PIC # objects go into mpz/.libs/libmpz.a, and thence into .libs/libgmp.a.) # # For now the big lists of objects above are used. Something like mpz/*.lo # would probably work, but might risk missing something out or getting # something extra. The source files for each .lo are listed in the # Makefile.am's in the subdirectories. # # Currently, for libgmp, unlike libmp below, we're not using # -export-symbols, since the tune and speed programs, and perhaps some of # the test programs, want to access undocumented symbols. libgmp_la_SOURCES = gmp-impl.h longlong.h randmt.h \ assert.c compat.c errno.c extract-dbl.c invalid.c memory.c \ mp_bpl.c mp_clz_tab.c mp_dv_tab.c mp_minv_tab.c mp_get_fns.c mp_set_fns.c \ rand.c randclr.c randdef.c randiset.c randlc2s.c randlc2x.c randmt.c \ randmts.c rands.c randsd.c randsdui.c randbui.c randmui.c version.c EXTRA_libgmp_la_SOURCES = tal-debug.c tal-notreent.c tal-reent.c libgmp_la_DEPENDENCIES = @TAL_OBJECT@ \ $(MPZ_OBJECTS) $(MPN_OBJECTS) @mpn_objs_in_libgmp@ \ # $(MPF_OBJECTS) $(MPQ_OBJECTS) libgmp_la_LIBADD = $(libgmp_la_DEPENDENCIES) libgmp_la_LDFLAGS = $(GMP_LDFLAGS) $(LIBGMP_LDFLAGS) \ -version-info $(LIBGMP_LT_CURRENT):$(LIBGMP_LT_REVISION):$(LIBGMP_LT_AGE) # We need at least one .cc file in $(libgmpxx_la_SOURCES) so automake will # use $(CXXLINK) rather than the plain C $(LINK). cxx/dummy.cc is that # file. @WANT_CXX_TRUE@GMPXX_LTLIBRARIES_OPTION = libgmpxx.la libgmpxx_la_SOURCES = cxx/dummy.cc libgmpxx_la_DEPENDENCIES = $(CXX_OBJECTS) libgmp.la libgmpxx_la_LIBADD = $(libgmpxx_la_DEPENDENCIES) libgmpxx_la_LDFLAGS = $(GMP_LDFLAGS) $(LIBGMPXX_LDFLAGS) \ -version-info $(LIBGMPXX_LT_CURRENT):$(LIBGMPXX_LT_REVISION):$(LIBGMPXX_LT_AGE) # The selected mpz objects here support mpz/powm.c (built as mpbsd/powm.lo) # and can probably be removed when that switches to an mpn implementation. # (Apart from mpz/n_pow_ui$U.lo, which supports mpbsd/rpow.c) @WANT_MPBSD_TRUE@MPBSD_HEADERS_OPTION = mp.h @WANT_MPBSD_TRUE@MPBSD_LTLIBRARIES_OPTION = libmp.la libmp_la_SOURCES = assert.c errno.c memory.c mp_bpl.c mp_clz_tab.c \ mp_dv_tab.c mp_minv_tab.c mp_get_fns.c mp_set_fns.c libmp_la_DEPENDENCIES = $(srcdir)/libmp.sym \ @TAL_OBJECT@ $(MPBSD_OBJECTS) $(MPN_OBJECTS) @mpn_objs_in_libmp@ \ mpz/add$U.lo mpz/gcdext$U.lo mpz/invert$U.lo mpz/mul$U.lo \ mpz/n_pow_ui$U.lo mpz/realloc$U.lo mpz/set$U.lo mpz/sub$U.lo \ mpz/tdiv_q$U.lo libmp_la_LIBADD = $(libmp_la_DEPENDENCIES) libmp_la_LDFLAGS = $(GMP_LDFLAGS) \ -version-info $(LIBMP_LT_CURRENT):$(LIBMP_LT_REVISION):$(LIBMP_LT_AGE) \ -export-symbols $(srcdir)/libmp.sym all: $(BUILT_SOURCES) config.h $(MAKE) $(AM_MAKEFLAGS) all-recursive .SUFFIXES: .SUFFIXES: .c .cc .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) --gnu --ignore-deps'; \ $(am__cd) $(srcdir) && $(AUTOMAKE) --gnu --ignore-deps \ && exit 0; \ exit 1;; \ esac; \ done; \ echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu --ignore-deps Makefile'; \ $(am__cd) $(top_srcdir) && \ $(AUTOMAKE) --gnu --ignore-deps 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 @test -f $@ || rm -f stamp-h1 @test -f $@ || $(MAKE) $(AM_MAKEFLAGS) stamp-h1 stamp-h1: $(srcdir)/config.in $(top_builddir)/config.status @rm -f stamp-h1 cd $(top_builddir) && $(SHELL) ./config.status config.h $(srcdir)/config.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 gmp.h: $(top_builddir)/config.status $(srcdir)/gmp-h.in cd $(top_builddir) && $(SHELL) ./config.status $@ mp.h: $(top_builddir)/config.status $(srcdir)/mp-h.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}; \ } libgmp.la: $(libgmp_la_OBJECTS) $(libgmp_la_DEPENDENCIES) $(EXTRA_libgmp_la_DEPENDENCIES) $(AM_V_CCLD)$(libgmp_la_LINK) -rpath $(libdir) $(libgmp_la_OBJECTS) $(libgmp_la_LIBADD) $(LIBS) libgmpxx.la: $(libgmpxx_la_OBJECTS) $(libgmpxx_la_DEPENDENCIES) $(EXTRA_libgmpxx_la_DEPENDENCIES) $(AM_V_CXXLD)$(libgmpxx_la_LINK) $(am_libgmpxx_la_rpath) $(libgmpxx_la_OBJECTS) $(libgmpxx_la_LIBADD) $(LIBS) libmp.la: $(libmp_la_OBJECTS) $(libmp_la_DEPENDENCIES) $(EXTRA_libmp_la_DEPENDENCIES) $(AM_V_CCLD)$(libmp_la_LINK) $(am_libmp_la_rpath) $(libmp_la_OBJECTS) $(libmp_la_LIBADD) $(LIBS) mostlyclean-compile: -rm -f *.$(OBJEXT) distclean-compile: -rm -f *.tab.c .c.o: $(AM_V_CC)$(COMPILE) -c -o $@ $< .c.obj: $(AM_V_CC)$(COMPILE) -c -o $@ `$(CYGPATH_W) '$<'` .c.lo: $(AM_V_CC)$(LTCOMPILE) -c -o $@ $< .cc.o: $(AM_V_CXX)$(CXXCOMPILE) -c -o $@ $< .cc.obj: $(AM_V_CXX)$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'` .cc.lo: $(AM_V_CXX)$(LTCXXCOMPILE) -c -o $@ $< dummy.lo: cxx/dummy.cc $(AM_V_CXX)$(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o dummy.lo `test -f 'cxx/dummy.cc' || echo '$(srcdir)/'`cxx/dummy.cc mostlyclean-libtool: -rm -f *.lo clean-libtool: -rm -rf .libs _libs distclean-libtool: -rm -f libtool config.lt install-includeHEADERS: $(include_HEADERS) @$(NORMAL_INSTALL) @list='$(include_HEADERS)'; test -n "$(includedir)" || list=; \ if test -n "$$list"; then \ echo " $(MKDIR_P) '$(DESTDIR)$(includedir)'"; \ $(MKDIR_P) "$(DESTDIR)$(includedir)" || 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)$(includedir)'"; \ $(INSTALL_HEADER) $$files "$(DESTDIR)$(includedir)" || exit $$?; \ done uninstall-includeHEADERS: @$(NORMAL_UNINSTALL) @list='$(include_HEADERS)'; test -n "$(includedir)" || list=; \ files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \ dir='$(DESTDIR)$(includedir)'; $(am__uninstall_files_from_dir) install-nodist_includeexecHEADERS: $(nodist_includeexec_HEADERS) @$(NORMAL_INSTALL) @list='$(nodist_includeexec_HEADERS)'; test -n "$(includeexecdir)" || list=; \ if test -n "$$list"; then \ echo " $(MKDIR_P) '$(DESTDIR)$(includeexecdir)'"; \ $(MKDIR_P) "$(DESTDIR)$(includeexecdir)" || 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)$(includeexecdir)'"; \ $(INSTALL_HEADER) $$files "$(DESTDIR)$(includeexecdir)" || exit $$?; \ done uninstall-nodist_includeexecHEADERS: @$(NORMAL_UNINSTALL) @list='$(nodist_includeexec_HEADERS)'; test -n "$(includeexecdir)" || list=; \ files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \ dir='$(DESTDIR)$(includeexecdir)'; $(am__uninstall_files_from_dir) # This directory's subdirectories are mostly independent; you can cd # into them and run 'make' without going through this Makefile. # To change the values of 'make' variables: instead of editing Makefiles, # (1) if the variable is set in 'config.status', edit 'config.status' # (which will cause the Makefiles to be regenerated when you run 'make'); # (2) otherwise, pass the desired values on the 'make' command line. $(am__recursive_targets): @fail=; \ if $(am__make_keepgoing); then \ failcom='fail=yes'; \ else \ failcom='exit 1'; \ fi; \ dot_seen=no; \ target=`echo $@ | sed s/-recursive//`; \ case "$@" in \ distclean-* | maintainer-clean-*) list='$(DIST_SUBDIRS)' ;; \ *) list='$(SUBDIRS)' ;; \ esac; \ for subdir in $$list; do \ echo "Making $$target in $$subdir"; \ if test "$$subdir" = "."; then \ dot_seen=yes; \ local_target="$$target-am"; \ else \ local_target="$$target"; \ fi; \ ($(am__cd) $$subdir && $(MAKE) $(AM_MAKEFLAGS) $$local_target) \ || eval $$failcom; \ done; \ if test "$$dot_seen" = "no"; then \ $(MAKE) $(AM_MAKEFLAGS) "$$target-am" || exit 1; \ fi; test -z "$$fail" ID: $(am__tagged_files) $(am__define_uniq_tagged_files); mkid -fID $$unique tags: tags-recursive TAGS: tags tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) set x; \ here=`pwd`; \ if ($(ETAGS) --etags-include --version) >/dev/null 2>&1; then \ include_option=--etags-include; \ empty_fix=.; \ else \ include_option=--include; \ empty_fix=; \ fi; \ list='$(SUBDIRS)'; for subdir in $$list; do \ if test "$$subdir" = .; then :; else \ test ! -f $$subdir/TAGS || \ set "$$@" "$$include_option=$$here/$$subdir/TAGS"; \ fi; \ done; \ $(am__define_uniq_tagged_files); \ 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-recursive CTAGS: ctags ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) $(am__define_uniq_tagged_files); \ 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: cscopelist-recursive cscopelist-am: $(am__tagged_files) list='$(am__tagged_files)'; \ 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 @list='$(DIST_SUBDIRS)'; for subdir in $$list; do \ if test "$$subdir" = .; then :; else \ $(am__make_dryrun) \ || test -d "$(distdir)/$$subdir" \ || $(MKDIR_P) "$(distdir)/$$subdir" \ || exit 1; \ dir1=$$subdir; dir2="$(distdir)/$$subdir"; \ $(am__relativize); \ new_distdir=$$reldir; \ dir1=$$subdir; dir2="$(top_distdir)"; \ $(am__relativize); \ new_top_distdir=$$reldir; \ echo " (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) top_distdir="$$new_top_distdir" distdir="$$new_distdir" \\"; \ echo " am__remove_distdir=: am__skip_length_check=: am__skip_mode_fix=: distdir)"; \ ($(am__cd) $$subdir && \ $(MAKE) $(AM_MAKEFLAGS) \ top_distdir="$$new_top_distdir" \ distdir="$$new_distdir" \ am__remove_distdir=: \ am__skip_length_check=: \ am__skip_mode_fix=: \ distdir) \ || exit 1; \ fi; \ done $(MAKE) $(AM_MAKEFLAGS) \ top_distdir="$(top_distdir)" distdir="$(distdir)" \ dist-hook -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 @echo WARNING: "Support for distribution archives compressed with" \ "legacy program 'compress' is deprecated." >&2 @echo WARNING: "It will be removed altogether in Automake 2.0" >&2 tardir=$(distdir) && $(am__tar) | compress -c >$(distdir).tar.Z $(am__post_remove_distdir) dist-shar: distdir @echo WARNING: "Support for shar distribution archives is" \ "deprecated." >&2 @echo WARNING: "It will be removed altogether in Automake 2.0" >&2 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 $(distdir)/_build/sub $(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/sub \ && ../../configure \ $(AM_DISTCHECK_CONFIGURE_FLAGS) \ $(DISTCHECK_CONFIGURE_FLAGS) \ --srcdir=../.. --prefix="$$dc_install_base" \ && $(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: $(BUILT_SOURCES) $(MAKE) $(AM_MAKEFLAGS) check-recursive all-am: Makefile $(LTLIBRARIES) $(HEADERS) config.h installdirs: installdirs-recursive installdirs-am: for dir in "$(DESTDIR)$(libdir)" "$(DESTDIR)$(includedir)" "$(DESTDIR)$(includeexecdir)"; do \ test -z "$$dir" || $(MKDIR_P) "$$dir"; \ done install: $(BUILT_SOURCES) $(MAKE) $(AM_MAKEFLAGS) install-recursive install-exec: install-exec-recursive install-data: install-data-recursive uninstall: uninstall-recursive install-am: all-am @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am installcheck: installcheck-recursive 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) -test -z "$(DISTCLEANFILES)" || rm -f $(DISTCLEANFILES) maintainer-clean-generic: @echo "This command is intended for maintainers to use" @echo "it deletes files that may require special tools to rebuild." -test -z "$(BUILT_SOURCES)" || rm -f $(BUILT_SOURCES) clean: clean-recursive clean-am: clean-generic clean-libLTLIBRARIES clean-libtool \ mostlyclean-am distclean: distclean-recursive -rm -f $(am__CONFIG_DISTCLEAN_FILES) -rm -f Makefile distclean-am: clean-am distclean-compile distclean-generic \ distclean-hdr distclean-libtool distclean-tags dvi: dvi-recursive dvi-am: html: html-recursive html-am: info: info-recursive info-am: install-data-am: install-includeHEADERS @$(NORMAL_INSTALL) $(MAKE) $(AM_MAKEFLAGS) install-data-hook install-dvi: install-dvi-recursive install-dvi-am: install-exec-am: install-libLTLIBRARIES \ install-nodist_includeexecHEADERS install-html: install-html-recursive install-html-am: install-info: install-info-recursive install-info-am: install-man: install-pdf: install-pdf-recursive install-pdf-am: install-ps: install-ps-recursive install-ps-am: installcheck-am: maintainer-clean: maintainer-clean-recursive -rm -f $(am__CONFIG_DISTCLEAN_FILES) -rm -rf $(top_srcdir)/autom4te.cache -rm -f Makefile maintainer-clean-am: distclean-am maintainer-clean-generic mostlyclean: mostlyclean-recursive mostlyclean-am: mostlyclean-compile mostlyclean-generic \ mostlyclean-libtool pdf: pdf-recursive pdf-am: ps: ps-recursive ps-am: uninstall-am: uninstall-includeHEADERS uninstall-libLTLIBRARIES \ uninstall-nodist_includeexecHEADERS .MAKE: $(am__recursive_targets) all check install install-am \ install-data-am install-strip .PHONY: $(am__recursive_targets) CTAGS GTAGS TAGS all all-am \ am--refresh check check-am clean clean-cscope clean-generic \ clean-libLTLIBRARIES clean-libtool cscope cscopelist-am ctags \ ctags-am dist dist-all dist-bzip2 dist-gzip dist-hook \ 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-data-hook install-dvi install-dvi-am install-exec \ install-exec-am install-html install-html-am \ install-includeHEADERS install-info install-info-am \ install-libLTLIBRARIES install-man \ install-nodist_includeexecHEADERS install-pdf install-pdf-am \ install-ps install-ps-am install-strip installcheck \ installcheck-am installdirs installdirs-am maintainer-clean \ maintainer-clean-generic mostlyclean mostlyclean-compile \ mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \ tags tags-am uninstall uninstall-am uninstall-includeHEADERS \ uninstall-libLTLIBRARIES uninstall-nodist_includeexecHEADERS .PRECIOUS: Makefile install-data-hook: @echo '' @echo '+-------------------------------------------------------------+' @echo '| CAUTION: |' @echo '| |' @echo '| If you have not already run "make check", then we strongly |' @echo '| recommend you do so. |' @echo '| |' @echo '| GMP has been carefully tested by its authors, but compilers |' @echo '| are all too often released with serious bugs. GMP tends to |' @echo '| explore interesting corners in compilers and has hit bugs |' @echo '| on quite a few occasions. |' @echo '| |' @echo '+-------------------------------------------------------------+' @echo '' mpz/fac_ui.h: gen-fac_ui$(EXEEXT_FOR_BUILD) ./gen-fac_ui $(BITS_PER_MP_LIMB) $(GMP_NAIL_BITS) >mpz/fac_ui.h || (rm -f mpz/fac_ui.h; exit 1) gen-fac_ui$(EXEEXT_FOR_BUILD): gen-fac_ui.c dumbmp.c $(CC_FOR_BUILD) $(srcdir)/gen-fac_ui.c -o gen-fac_ui$(EXEEXT_FOR_BUILD) fib_table.h: gen-fib$(EXEEXT_FOR_BUILD) ./gen-fib header $(BITS_PER_MP_LIMB) $(GMP_NAIL_BITS) >fib_table.h || (rm -f fib_table.h; exit 1) mpn/fib_table.c: gen-fib$(EXEEXT_FOR_BUILD) ./gen-fib table $(BITS_PER_MP_LIMB) $(GMP_NAIL_BITS) >mpn/fib_table.c || (rm -f mpn/fib_table.c; exit 1) gen-fib$(EXEEXT_FOR_BUILD): gen-fib.c dumbmp.c $(CC_FOR_BUILD) $(srcdir)/gen-fib.c -o gen-fib$(EXEEXT_FOR_BUILD) mp_bases.h: gen-bases$(EXEEXT_FOR_BUILD) ./gen-bases header $(BITS_PER_MP_LIMB) $(GMP_NAIL_BITS) >mp_bases.h || (rm -f mp_bases.h; exit 1) mpn/mp_bases.c: gen-bases$(EXEEXT_FOR_BUILD) ./gen-bases table $(BITS_PER_MP_LIMB) $(GMP_NAIL_BITS) >mpn/mp_bases.c || (rm -f mpn/mp_bases.c; exit 1) gen-bases$(EXEEXT_FOR_BUILD): gen-bases.c dumbmp.c $(CC_FOR_BUILD) $(srcdir)/gen-bases.c -o gen-bases$(EXEEXT_FOR_BUILD) $(LIBM_FOR_BUILD) mpn/perfsqr.h: gen-psqr$(EXEEXT_FOR_BUILD) ./gen-psqr $(BITS_PER_MP_LIMB) $(GMP_NAIL_BITS) >mpn/perfsqr.h || (rm -f mpn/perfsqr.h; exit 1) gen-psqr$(EXEEXT_FOR_BUILD): gen-psqr.c dumbmp.c $(CC_FOR_BUILD) $(srcdir)/gen-psqr.c -o gen-psqr$(EXEEXT_FOR_BUILD) $(LIBM_FOR_BUILD) # Avoid: CVS - cvs directories # *~ - emacs backups # .#* - cvs merge originals # # *~ and .#* only occur when a whole directory without it's own Makefile.am # is distributed, like "doc" or the mpn cpu subdirectories. # dist-hook: -find $(distdir) \( -name CVS -type d \) -o -name "*~" -o -name ".#*" \ | xargs rm -rf # 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: ecl-16.1.2/src/gmp/NEWS000066400000000000000000000321041266352375300144310ustar00rootroot00000000000000Copyright 1996, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc. This file is part of the GNU MP Library. The GNU MP Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU MP Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU MP Library; see the file COPYING.LIB. If not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Changes between GMP version 4.2 and 4.2.1 Bugs: * Shared library numbers corrected. * Broken support for 32-bit AIX fixed. * Misc minor fixes. Speedups: * Exact division (mpz_divexact) now falls back to plain division for large operands. Features: * Support for some new systems. Changes between GMP version 4.1.4 and 4.2 Bugs: * Minor bug fixes and code generalizations. * Expanded and improved test suite. Speedups: * Many minor optimizations, too many to mention here. * Division now always subquadratic. * Computation of n-factorial much faster. * Added basic x86-64 assembly code. * Floating-point output is now subquadratic for all bases. * FFT multiply code now about 25% faster. * Toom3 multiply code faster. Features: * Much improved configure. * Workarounds for many more compiler bugs. * Temporary allocations are now made on the stack only if small. * New systems supported: HPPA-2.0 gcc, IA-64 HP-UX, PowerPC-64 Darwin, Sparc64 GNU/Linux. * New i386 fat binaries, selecting optimised code at runtime (--enable-fat). * New build option: --enable-profiling=instrument. * New memory function: mp_get_memory_functions. * New Mersenne Twister random numbers: gmp_randinit_mt, also now used for gmp_randinit_default. * New random functions: gmp_randinit_set, gmp_urandomb_ui, gmp_urandomm_ui. * New integer functions: mpz_combit, mpz_rootrem. * gmp_printf etc new type "M" for mp_limb_t. * gmp_scanf and friends now accept C99 hex floats. * Numeric input and output can now be in bases up to 62. * Comparisons mpz_cmp_d, mpz_cmpabs_d, mpf_cmp_d recognise infinities. * Conversions mpz_get_d, mpq_get_d, mpf_get_d truncate towards zero, previously their behaviour was unspecified. * Fixes for overflow issues with operands >= 2^31 bits. Caveats: * mpfr is gone, and will from now on be released only separately. Please see www.mpfr.org. Changes between GMP version 4.1.3 and 4.1.4 * Bug fix to FFT multiplication code (crash for huge operands). * Bug fix to mpf_sub (miscomputation). * Support for powerpc64-gnu-linux. * Better support for AMD64 in 32-bit mode. * Upwardly binary compatible with 4.1.3, 4.1.2, 4.1.1, 4.1, 4.0.1, 4.0, and 3.x versions. Changes between GMP version 4.1.2 and 4.1.3 * Bug fix for FFT multiplication code (miscomputation). * Bug fix to K6 assembly code for gcd. * Bug fix to IA-64 assembly code for population count. * Portability improvements, most notably functional AMD64 support. * mpz_export allows NULL for countp parameter. * Many minor bug fixes. * mpz_export allows NULL for countp parameter. * Upwardly binary compatible with 4.1.2, 4.1.1, 4.1, 4.0.1, 4.0, and 3.x versions. Changes between GMP version 4.1.1 and 4.1.2 * Bug fixes. Changes between GMP version 4.1 and 4.1.1 * Bug fixes. * New systems supported: NetBSD and OpenBSD sparc64. Changes between GMP version 4.0.1 and 4.1 * Bug fixes. * Speed improvements. * Upwardly binary compatible with 4.0, 4.0.1, and 3.x versions. * Asymptotically fast conversion to/from strings (mpz, mpq, mpn levels), but also major speed improvements for tiny operands. * mpn_get_str parameter restrictions relaxed. * Major speed improvments for HPPA 2.0 systems. * Major speed improvments for UltraSPARC systems. * Major speed improvments for IA-64 systems (but still sub-optimal code). * Extended test suite. * mpfr is back, with many bug fixes and portability improvements. * New function: mpz_ui_sub. * New functions: mpz_export, mpz_import. * Optimization for nth root functions (mpz_root, mpz_perfect_power_p). * Optimization for extended gcd (mpz_gcdext, mpz_invert, mpn_gcdext). * Generalized low-level number format, reserving a `nails' part of each limb. (Please note that this is really experimental; some functions are likely to compute garbage when nails are enabled.) * Nails-enabled Alpha 21264 assembly code, allowing up to 75% better performance. (Use --enable-nails=4 to enable it.) Changes between GMP version 4.0 and 4.0.1 * Bug fixes. Changes between GMP version 3.1.1 and 4.0 * Bug fixes. * Speed improvements. * Upwardly binary compatible with 3.x versions. * New CPU support: IA-64, Pentium 4. * Improved CPU support: 21264, Cray vector systems. * Support for all MIPS ABIs: o32, n32, 64. * New systems supported: Darwin, SCO, Windows DLLs. * New divide-and-conquer square root algorithm. * New algorithms chapter in the manual. * New malloc reentrant temporary memory method. * New C++ class interface by Gerardo Ballabio (beta). * Revamped configure, featuring ABI selection. * Speed improvements for mpz_powm and mpz_powm_ui (mainly affecting small operands). * mpz_perfect_power_p now properly recognizes 0, 1, and negative perfect powers. * mpz_hamdist now supports negative operands. * mpz_jacobi now accepts non-positive denominators. * mpz_powm now supports negative exponents. * mpn_mul_1 operand overlap requirements relaxed. * Float input and output uses locale specific decimal point where available. * New gmp_printf, gmp_scanf and related functions. * New division functions: mpz_cdiv_q_2exp, mpz_cdiv_r_2exp, mpz_divexact_ui. * New divisibility tests: mpz_divisible_p, mpz_divisible_ui_p, mpz_divisible_2exp_p, mpz_congruent_p, mpz_congruent_ui_p, mpz_congruent_2exp_p. * New Fibonacci function: mpz_fib2_ui. * New Lucas number functions: mpz_lucnum_ui, mpz_lucnum2_ui. * Other new integer functions: mpz_cmp_d, mpz_cmpabs_d, mpz_get_d_2exp, mpz_init2, mpz_kronecker, mpz_lcm_ui, mpz_realloc2. * New rational I/O: mpq_get_str, mpq_inp_str, mpq_out_str, mpq_set_str. * Other new rational functions: mpq_abs, mpq_cmp_si, mpq_div_2exp, mpq_mul_2exp, mpq_set_f. * New float tests: mpf_integer_p, mpf_fits_sint_p, mpf_fits_slong_p, mpf_fits_sshort_p, mpf_fits_uint_p, mpf_fits_ulong_p, mpf_fits_ushort_p. * Other new float functions: mpf_cmp_d, mpf_get_default_prec, mpf_get_si, mpf_get_ui, mpf_get_d_2exp. * New random functions: gmp_randinit_default, gmp_randinit_lc_2exp_size. * New demo expression string parser (see demos/expr). * New preliminary perl interface (see demos/perl). * Tuned algorithm thresholds for many more CPUs. Changes between GMP version 3.1 and 3.1.1 * Bug fixes for division (rare), mpf_get_str, FFT, and miscellaneous minor things. Changes between GMP version 3.0 and 3.1 * Bug fixes. * Improved `make check' running more tests. * Tuned algorithm cutoff points for many machines. This will improve speed for a lot of operations, in some cases by a large amount. * Major speed improvments: Alpha 21264. * Some speed improvments: Cray vector computers, AMD K6 and Athlon, Intel P5 and Pentium Pro/II/III. * The mpf_get_prec function now works as it did in GMP 2. * New utilities for auto-tuning and speed measuring. * Multiplication now optionally uses FFT for very large operands. (To enable it, pass --enable-fft to configure.) * Support for new systems: Solaris running on x86, FreeBSD 5, HP-UX 11, Cray vector computers, Rhapsody, Nextstep/Openstep, MacOS. * Support for shared libraries on 32-bit HPPA. * New integer functions: mpz_mul_si, mpz_odd_p, mpz_even_p. * New Kronecker symbol functions: mpz_kronecker_si, mpz_kronecker_ui, mpz_si_kronecker, mpz_ui_kronecker. * New rational functions: mpq_out_str, mpq_swap. * New float functions: mpf_swap. * New mpn functions: mpn_divexact_by3c, mpn_tdiv_qr. * New EXPERIMENTAL function layer for accurate floating-point arithmetic, mpfr. To try it, pass --enable-mpfr to configure. See the mpfr subdirectory for more information; it is not documented in the main GMP manual. Changes between GMP version 3.0 and 3.0.1 * Memory leaks in gmp_randinit and mpz_probab_prime_p fixed. * Documentation for gmp_randinit fixed. Misc documentation errors fixed. Changes between GMP version 2.0 and 3.0 * Source level compatibility with past releases (except mpn_gcd). * Bug fixes. * Much improved speed thanks to both host independent and host dependent optimizations. * Switch to autoconf/automake/libtool. * Support for building libgmp as a shared library. * Multiplication and squaring using 3-way Toom-Cook. * Division using the Burnikel-Ziegler method. * New functions computing binomial coefficients: mpz_bin_ui, mpz_bin_uiui. * New function computing Fibonacci numbers: mpz_fib_ui. * New random number generators: mpf_urandomb, mpz_rrandomb, mpz_urandomb, mpz_urandomm, gmp_randclear, gmp_randinit, gmp_randinit_lc_2exp, gmp_randseed, gmp_randseed_ui. * New function for quickly extracting limbs: mpz_getlimbn. * New functions performing integer size tests: mpz_fits_sint_p, mpz_fits_slong_p, mpz_fits_sshort_p, mpz_fits_uint_p, mpz_fits_ulong_p, mpz_fits_ushort_p. * New mpf functions: mpf_ceil, mpf_floor, mpf_pow_ui, mpf_trunc. * New mpq function: mpq_set_d. * New mpz functions: mpz_addmul_ui, mpz_cmpabs, mpz_cmpabs_ui, mpz_lcm, mpz_nextprime, mpz_perfect_power_p, mpz_remove, mpz_root, mpz_swap, mpz_tdiv_ui, mpz_tstbit, mpz_xor. * New mpn function: mpn_divexact_by3. * New CPU support: DEC Alpha 21264, AMD K6 and Athlon, HPPA 2.0 and 64, Intel Pentium Pro and Pentium-II/III, Sparc 64, PowerPC 64. * Almost 10 times faster mpz_invert and mpn_gcdext. * The interface of mpn_gcd has changed. * Better support for MIPS R4x000 and R5000 under Irix 6. * Improved support for SPARCv8 and SPARCv9 processors. Changes between GMP version 2.0 and 2.0.2 * Many bug fixes. Changes between GMP version 1.3.2 and 2.0 * Division routines in the mpz class have changed. There are three classes of functions, that rounds the quotient to -infinity, 0, and +infinity, respectively. The first class of functions have names that begin with mpz_fdiv (f is short for floor), the second class' names begin with mpz_tdiv (t is short for trunc), and the third class' names begin with mpz_cdiv (c is short for ceil). The old division routines beginning with mpz_m are similar to the new mpz_fdiv, with the exception that some of the new functions return useful values. The old function names can still be used. All the old functions names will now do floor division, not trunc division as some of them used to. This was changed to make the functions more compatible with common mathematical practice. The mpz_mod and mpz_mod_ui functions now compute the mathematical mod function. I.e., the sign of the 2nd argument is ignored. * The mpq assignment functions do not canonicalize their results. A new function, mpq_canonicalize must be called by the user if the result is not known to be canonical. * The mpn functions are now documented. These functions are intended for very time critical applications, or applications that need full control over memory allocation. Note that the mpn interface is irregular and hard to use. * New functions for arbitrary precision floating point arithmetic. Names begin with `mpf_'. Associated type mpf_t. * New and improved mpz functions, including much faster GCD, fast exact division (mpz_divexact), bit scan (mpz_scan0 and mpz_scan1), and number theoretical functions like Jacobi (mpz_jacobi) and multiplicative inverse (mpz_invert). * New variable types (mpz_t and mpq_t) are available that makes syntax of mpz and mpq calls nicer (no need for & before variables). The MP_INT and MP_RAT types are still available for compatibility. * Uses GNU configure. This makes it possible to choose target architecture and CPU variant, and to compile into a separate object directory. * Carefully optimized assembly for important inner loops. Support for DEC Alpha, Amd 29000, HPPA 1.0 and 1.1, Intel Pentium and generic x86, Intel i960, Motorola MC68000, MC68020, MC88100, and MC88110, Motorola/IBM PowerPC, National NS32000, IBM POWER, MIPS R3000, R4000, SPARCv7, SuperSPARC, generic SPARCv8, and DEC VAX. Some support also for ARM, Clipper, IBM ROMP (RT), and Pyramid AP/XP. * Faster. Thanks to the assembler code, new algorithms, and general tuning. In particular, the speed on machines without GCC is improved. * Support for machines without alloca. * Now under the LGPL. INCOMPATIBILITIES BETWEEN GMP 1 AND GMP 2 * mpq assignment functions do not canonicalize their results. * mpz division functions round differently. * mpz mod functions now really compute mod. * mpz_powm and mpz_powm_ui now really use mod for reduction. ---------------- Local variables: mode: text fill-column: 76 End: ecl-16.1.2/src/gmp/README000066400000000000000000000077451266352375300146270ustar00rootroot00000000000000Copyright 1991, 1996, 1999, 2000 Free Software Foundation, Inc. This file is part of the GNU MP Library. The GNU MP Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU MP Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU MP Library; see the file COPYING.LIB. If not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. THE GNU MP LIBRARY GNU MP is a library for arbitrary precision arithmetic, operating on signed integers, rational numbers, and floating point numbers. It has a rich set of functions, and the functions have a regular interface. GNU MP is designed to be as fast as possible, both for small operands and huge operands. The speed is achieved by using fullwords as the basic arithmetic type, by using fast algorithms, with carefully optimized assembly code for the most common inner loops for lots of CPUs, and by a general emphasis on speed (instead of simplicity or elegance). GNU MP is believed to be faster than any other similar library. Its advantage increases with operand sizes for certain operations, since GNU MP in many cases has asymptotically faster algorithms. GNU MP is free software and may be freely copied on the terms contained in the files COPYING.LIB and COPYING (most of GNU MP is under the former, some under the latter). OVERVIEW OF GNU MP There are five classes of functions in GNU MP. 1. Signed integer arithmetic functions (mpz). These functions are intended to be easy to use, with their regular interface. The associated type is `mpz_t'. 2. Rational arithmetic functions (mpq). For now, just a small set of functions necessary for basic rational arithmetics. The associated type is `mpq_t'. 3. Floating-point arithmetic functions (mpf). If the C type `double' doesn't give enough precision for your application, declare your variables as `mpf_t' instead, set the precision to any number desired, and call the functions in the mpf class for the arithmetic operations. 4. Positive-integer, hard-to-use, very low overhead functions are in the mpn class. No memory management is performed. The caller must ensure enough space is available for the results. The set of functions is not regular, nor is the calling interface. These functions accept input arguments in the form of pairs consisting of a pointer to the least significant word, and an integral size telling how many limbs (= words) the pointer points to. Almost all calculations, in the entire package, are made by calling these low-level functions. 5. Berkeley MP compatible functions. To use these functions, include the file "mp.h". You can test if you are using the GNU version by testing if the symbol __GNU_MP__ is defined. For more information on how to use GNU MP, please refer to the documentation. It is composed from the file gmp.texi, and can be displayed on the screen or printed. How to do that, as well how to build the library, is described in the INSTALL file in this directory. REPORTING BUGS If you find a bug in the library, please make sure to tell us about it! You should first check the GNU MP web pages at http://www.swox.com/gmp/, under "Status of the current release". There will be patches for all known serious bugs there. Report bugs to bug-gmp@gnu.org. What information is needed in a good bug report is described in the manual. The same address can be used for suggesting modifications and enhancements. ---------------- Local variables: mode: text fill-column: 78 End: ecl-16.1.2/src/gmp/acinclude.m4000066400000000000000000003452271266352375300161400ustar00rootroot00000000000000dnl GMP specific autoconf macros dnl Copyright 2000, 2001, 2002, 2003, 2004, 2005, 2006 Free Software dnl Foundation, Inc. dnl dnl This file is part of the GNU MP Library. dnl dnl The GNU MP Library is free software; you can redistribute it and/or modify dnl it under the terms of the GNU Lesser General Public License as published dnl by the Free Software Foundation; either version 2.1 of the License, or (at dnl your option) any later version. dnl dnl The GNU MP Library is distributed in the hope that it will be useful, but dnl WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY dnl or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public dnl License for more details. dnl dnl You should have received a copy of the GNU Lesser General Public License dnl along with the GNU MP Library; see the file COPYING.LIB. If not, write to dnl the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, dnl MA 02110-1301, USA. dnl Some tests use, or must delete, the default compiler output. The dnl possible filenames are based on what autoconf looks for, namely dnl dnl a.out - normal unix style dnl b.out - i960 systems, including gcc there dnl a.exe - djgpp dnl a_out.exe - OpenVMS DEC C called via GNV wrapper (gnv.sourceforge.net) dnl conftest.exe - various DOS compilers define(IA64_PATTERN, [[ia64*-*-* | itanium-*-* | itanium2-*-*]]) dnl Need to be careful not to match m6811, m6812, m68hc11 and m68hc12, all dnl of which config.sub accepts. (Though none of which are likely to work dnl with GMP.) dnl define(M68K_PATTERN, [[m68k-*-* | m68[0-9][0-9][0-9]-*-*]]) define(POWERPC64_PATTERN, [[powerpc64-*-* | powerpc64le-*-* | powerpc620-*-* | powerpc630-*-* | powerpc970-*-* | power[3-9]-*-*]]) define(X86_PATTERN, [[i?86*-*-* | k[5-8]*-*-* | pentium*-*-* | athlon-*-* | viac3*-*-*]]) dnl GMP_FAT_SUFFIX(DSTVAR, DIRECTORY) dnl --------------------------------- dnl Emit code to set shell variable DSTVAR to the suffix for a fat binary dnl routine from DIRECTORY. DIRECTORY can be a shell expression like $foo dnl etc. dnl dnl The suffix is directory separators / or \ changed to underscores, and dnl if there's more than one directory part, then the first is dropped. dnl dnl For instance, dnl dnl x86 -> x86 dnl x86/k6 -> k6 dnl x86/k6/mmx -> k6_mmx define(GMP_FAT_SUFFIX, [[$1=`echo $2 | sed -e '/\//s:^[^/]*/::' -e 's:[\\/]:_:g'`]]) dnl GMP_REMOVE_FROM_LIST(listvar,item) dnl ---------------------------------- dnl Emit code to remove any occurance of ITEM from $LISTVAR. ITEM can be a dnl shell expression like $foo if desired. define(GMP_REMOVE_FROM_LIST, [remove_from_list_tmp= for remove_from_list_i in $[][$1]; do if test $remove_from_list_i = [$2]; then :; else remove_from_list_tmp="$remove_from_list_tmp $remove_from_list_i" fi done [$1]=$remove_from_list_tmp ]) dnl GMP_STRIP_PATH(subdir) dnl ---------------------- dnl Strip entries */subdir from $path and $fat_path. define(GMP_STRIP_PATH, [GMP_STRIP_PATH_VAR(path, [$1]) GMP_STRIP_PATH_VAR(fat_path, [$1]) ]) define(GMP_STRIP_PATH_VAR, [tmp_path= for i in $[][$1]; do case $i in */[$2]) ;; *) tmp_path="$tmp_path $i" ;; esac done [$1]="$tmp_path" ]) dnl GMP_INCLUDE_GMP_H dnl ----------------- dnl Expand to the right way to #include gmp-h.in. This must be used dnl instead of gmp.h, since that file isn't generated until the end of the dnl configure. dnl dnl Dummy values for __GMP_BITS_PER_MP_LIMB and GMP_LIMB_BITS are enough dnl for all current configure-time uses of gmp.h. dnl dnl Replaced $srcdir/gmp-h.in -> gmp-h.in + copying JJGR dnl define(GMP_INCLUDE_GMP_H, [[#define __GMP_WITHIN_CONFIGURE 1 /* ignore template stuff */ #define GMP_NAIL_BITS $GMP_NAIL_BITS #define __GMP_BITS_PER_MP_LIMB 123 /* dummy for GMP_NUMB_BITS etc */ #define GMP_LIMB_BITS 123 $DEFN_LONG_LONG_LIMB #include "gmp-h.in"] ]) dnl GMP_HEADER_GETVAL(NAME,FILE) dnl ---------------------------- dnl Expand at autoconf time to the value of a "#define NAME" from the given dnl FILE. The regexps here aren't very rugged, but are enough for gmp. dnl /dev/null as a parameter prevents a hang if $2 is accidentally omitted. define(GMP_HEADER_GETVAL, [patsubst(patsubst( esyscmd([grep "^#define $1 " $2 /dev/null 2>/dev/null]), [^.*$1[ ]+],[]), [[ ]*$],[])]) dnl GMP_VERSION dnl ----------- dnl The gmp version number, extracted from the #defines in gmp-h.in at dnl autoconf time. Two digits like 3.0 if patchlevel <= 0, or three digits dnl like 3.0.1 if patchlevel > 0. define(GMP_VERSION, [GMP_HEADER_GETVAL(__GNU_MP_VERSION,gmp-h.in)[]dnl .GMP_HEADER_GETVAL(__GNU_MP_VERSION_MINOR,gmp-h.in)[]dnl ifelse(m4_eval(GMP_HEADER_GETVAL(__GNU_MP_VERSION_PATCHLEVEL,gmp-h.in) > 0),1, [.GMP_HEADER_GETVAL(__GNU_MP_VERSION_PATCHLEVEL,gmp-h.in)])]) dnl GMP_SUBST_CHECK_FUNCS(func,...) dnl ------------------------------ dnl Setup an AC_SUBST of HAVE_FUNC_01 for each argument. AC_DEFUN([GMP_SUBST_CHECK_FUNCS], [m4_if([$1],,, [_GMP_SUBST_CHECK_FUNCS(ac_cv_func_[$1],HAVE_[]m4_translit([$1],[a-z],[A-Z])_01) GMP_SUBST_CHECK_FUNCS(m4_shift($@))])]) dnl Called: _GMP_SUBST_CHECK_FUNCS(cachevar,substvar) AC_DEFUN([_GMP_SUBST_CHECK_FUNCS], [case $[$1] in yes) AC_SUBST([$2],1) ;; no) [$2]=0 ;; esac ]) dnl GMP_SUBST_CHECK_HEADERS(foo.h,...) dnl ---------------------------------- dnl Setup an AC_SUBST of HAVE_FOO_H_01 for each argument. AC_DEFUN([GMP_SUBST_CHECK_HEADERS], [m4_if([$1],,, [_GMP_SUBST_CHECK_HEADERS(ac_cv_header_[]m4_translit([$1],[./],[__]), HAVE_[]m4_translit([$1],[a-z./],[A-Z__])_01) GMP_SUBST_CHECK_HEADERS(m4_shift($@))])]) dnl Called: _GMP_SUBST_CHECK_HEADERS(cachevar,substvar) AC_DEFUN([_GMP_SUBST_CHECK_HEADERS], [case $[$1] in yes) AC_SUBST([$2],1) ;; no) [$2]=0 ;; esac ]) dnl GMP_COMPARE_GE(A1,B1, A2,B2, ...) dnl --------------------------------- dnl Compare two version numbers A1.A2.etc and B1.B2.etc. Set dnl $gmp_compare_ge to yes or no accoring to the result. The A parts dnl should be variables, the B parts fixed numbers. As many parts as dnl desired can be included. An empty string in an A part is taken to be dnl zero, the B parts should be non-empty and non-zero. dnl dnl For example, dnl dnl GMP_COMPARE($major,10, $minor,3, $subminor,1) dnl dnl would test whether $major.$minor.$subminor is greater than or equal to dnl 10.3.1. AC_DEFUN([GMP_COMPARE_GE], [gmp_compare_ge=no GMP_COMPARE_GE_INTERNAL($@) ]) AC_DEFUN([GMP_COMPARE_GE_INTERNAL], [ifelse(len([$3]),0, [if test -n "$1" && test "$1" -ge $2; then gmp_compare_ge=yes fi], [if test -n "$1"; then if test "$1" -gt $2; then gmp_compare_ge=yes else if test "$1" -eq $2; then GMP_COMPARE_GE_INTERNAL(m4_shift(m4_shift($@))) fi fi fi]) ]) dnl GMP_PROG_AR dnl ----------- dnl GMP additions to $AR. dnl dnl A cross-"ar" may be necessary when cross-compiling since the build dnl system "ar" might try to interpret the object files to build a symbol dnl table index, hence the use of AC_CHECK_TOOL. dnl dnl A user-selected $AR is always left unchanged. AC_CHECK_TOOL is still dnl run to get the "checking" message printed though. dnl dnl If extra flags are added to AR, then ac_cv_prog_AR and dnl ac_cv_prog_ac_ct_AR are set too, since libtool (cvs 2003-03-31 at dnl least) will do an AC_CHECK_TOOL and that will AR from one of those two dnl cached variables. (ac_cv_prog_AR is used if there's an ac_tool_prefix, dnl or ac_cv_prog_ac_ct_AR is used otherwise.) FIXME: This is highly dnl dependent on autoconf internals, perhaps it'd work to put our extra dnl flags into AR_FLAGS instead. dnl dnl $AR_FLAGS is set to "cq" rather than leaving it to libtool "cru". The dnl latter fails when libtool goes into piecewise mode and is unlucky dnl enough to have two same-named objects in separate pieces, as happens dnl for instance to random.o (and others) on vax-dec-ultrix4.5. Naturally dnl a user-selected $AR_FLAGS is left unchanged. dnl dnl For reference, $ARFLAGS is used by automake (1.8) for its ".a" archive dnl file rules. This doesn't get used by the piecewise linking, so we dnl leave it at the default "cru". dnl dnl FIXME: Libtool 1.5.2 has its own arrangments for "cq", but that version dnl is broken in other ways. When we can upgrade, remove the forcible dnl AR_FLAGS=cq. AC_DEFUN([GMP_PROG_AR], [dnl Want to establish $AR before libtool initialization. AC_BEFORE([$0],[AC_PROG_LIBTOOL]) gmp_user_AR=$AR AC_CHECK_TOOL(AR, ar, ar) if test -z "$gmp_user_AR"; then eval arflags=\"\$ar${abi1}_flags\" test -n "$arflags" || eval arflags=\"\$ar${abi2}_flags\" if test -n "$arflags"; then AC_MSG_CHECKING([for extra ar flags]) AR="$AR $arflags" ac_cv_prog_AR="$AR $arflags" ac_cv_prog_ac_ct_AR="$AR $arflags" AC_MSG_RESULT([$arflags]) fi fi if test -z "$AR_FLAGS"; then AR_FLAGS=cq fi ]) dnl GMP_PROG_M4 dnl ----------- dnl Find a working m4, either in $PATH or likely locations, and setup $M4 dnl and an AC_SUBST accordingly. If $M4 is already set then it's a user dnl choice and is accepted with no checks. GMP_PROG_M4 is like dnl AC_PATH_PROG or AC_CHECK_PROG, but tests each m4 found to see if it's dnl good enough. dnl dnl See mpn/asm-defs.m4 for details on the known bad m4s. AC_DEFUN([GMP_PROG_M4], [AC_ARG_VAR(M4,[m4 macro processor]) AC_CACHE_CHECK([for suitable m4], gmp_cv_prog_m4, [if test -n "$M4"; then gmp_cv_prog_m4="$M4" else cat >conftest.m4 <<\EOF dnl Must protect this against being expanded during autoconf m4! dnl Dont put "dnl"s in this as autoconf will flag an error for unexpanded dnl macros. [define(dollarhash,``$][#'')ifelse(dollarhash(x),1,`define(t1,Y)', ``bad: $][# not supported (SunOS /usr/bin/m4) '')ifelse(eval(89),89,`define(t2,Y)', `bad: eval() doesnt support 8 or 9 in a constant (OpenBSD 2.6 m4) ')ifelse(t1`'t2,YY,`good ')] EOF dnl ' <- balance the quotes for emacs sh-mode echo "trying m4" >&AC_FD_CC gmp_tmp_val=`(m4 conftest.m4) 2>&AC_FD_CC` echo "$gmp_tmp_val" >&AC_FD_CC if test "$gmp_tmp_val" = good; then gmp_cv_prog_m4="m4" else IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS=":" dnl $ac_dummy forces splitting on constant user-supplied paths. dnl POSIX.2 word splitting is done only on the output of word expansions, dnl not every word. This closes a longstanding sh security hole. ac_dummy="$PATH:/usr/5bin" for ac_dir in $ac_dummy; do test -z "$ac_dir" && ac_dir=. echo "trying $ac_dir/m4" >&AC_FD_CC gmp_tmp_val=`($ac_dir/m4 conftest.m4) 2>&AC_FD_CC` echo "$gmp_tmp_val" >&AC_FD_CC if test "$gmp_tmp_val" = good; then gmp_cv_prog_m4="$ac_dir/m4" break fi done IFS="$ac_save_ifs" if test -z "$gmp_cv_prog_m4"; then AC_MSG_ERROR([No usable m4 in \$PATH or /usr/5bin (see config.log for reasons).]) fi fi rm -f conftest.m4 fi]) M4="$gmp_cv_prog_m4" AC_SUBST(M4) ]) dnl GMP_M4_M4WRAP_SPURIOUS dnl ---------------------- dnl Check for spurious output from m4wrap(), as described in mpn/asm-defs.m4. dnl dnl The following systems have been seen with the problem. dnl dnl - Unicos alpha, but its assembler doesn't seem to mind. dnl - MacOS X Darwin, its assembler fails. dnl - NetBSD 1.4.1 m68k, and gas 1.92.3 there gives a warning and ignores dnl the bad last line since it doesn't have a newline. dnl - NetBSD 1.4.2 alpha, but its assembler doesn't seem to mind. dnl - HP-UX ia64. dnl dnl Enhancement: Maybe this could be in GMP_PROG_M4, and attempt to prefer dnl an m4 with a working m4wrap, if it can be found. AC_DEFUN([GMP_M4_M4WRAP_SPURIOUS], [AC_REQUIRE([GMP_PROG_M4]) AC_CACHE_CHECK([if m4wrap produces spurious output], gmp_cv_m4_m4wrap_spurious, [# hide the d-n-l from autoconf's error checking tmp_d_n_l=d""nl cat >conftest.m4 <&AC_FD_CC cat conftest.m4 >&AC_FD_CC tmp_chars=`$M4 conftest.m4 | wc -c` echo produces $tmp_chars chars output >&AC_FD_CC rm -f conftest.m4 if test $tmp_chars = 0; then gmp_cv_m4_m4wrap_spurious=no else gmp_cv_m4_m4wrap_spurious=yes fi ]) GMP_DEFINE_RAW(["define(,<$gmp_cv_m4_m4wrap_spurious>)"]) ]) dnl GMP_PROG_NM dnl ----------- dnl GMP additions to libtool AC_PROG_NM. dnl dnl Note that if AC_PROG_NM can't find a working nm it still leaves dnl $NM set to "nm", so $NM can't be assumed to actually work. dnl dnl A user-selected $NM is always left unchanged. AC_PROG_NM is still run dnl to get the "checking" message printed though. dnl dnl Perhaps it'd be worthwhile checking that nm works, by running it on an dnl actual object file. For instance on sparcv9 solaris old versions of dnl GNU nm don't recognise 64-bit objects. Checking would give a better dnl error message than just a failure in later tests like GMP_ASM_W32 etc. dnl dnl On the other hand it's not really normal autoconf practice to take too dnl much trouble over detecting a broken set of tools. And libtool doesn't dnl do anything at all for say ranlib or strip. So for now we're inclined dnl to just demand that the user provides a coherent environment. AC_DEFUN([GMP_PROG_NM], [dnl Make sure we're the first to call AC_PROG_NM, so our extra flags are dnl used by everyone. AC_BEFORE([$0],[AC_PROG_NM]) gmp_user_NM=$NM AC_PROG_NM # FIXME: When cross compiling (ie. $ac_tool_prefix not empty), libtool # defaults to plain "nm" if a "${ac_tool_prefix}nm" is not found. In this # case run it again to try the native "nm", firstly so that likely locations # are searched, secondly so that -B or -p are added if necessary for BSD # format. This is necessary for instance on OSF with "./configure # --build=alphaev5-dec-osf --host=alphaev6-dec-osf". # if test -z "$gmp_user_NM" && test -n "$ac_tool_prefix" && test "$NM" = nm; then $as_unset lt_cv_path_NM gmp_save_ac_tool_prefix=$ac_tool_prefix ac_tool_prefix= NM= AC_PROG_NM ac_tool_prefix=$gmp_save_ac_tool_prefix fi if test -z "$gmp_user_NM"; then eval nmflags=\"\$nm${abi1}_flags\" test -n "$nmflags" || eval nmflags=\"\$nm${abi2}_flags\" if test -n "$nmflags"; then AC_MSG_CHECKING([for extra nm flags]) NM="$NM $nmflags" AC_MSG_RESULT([$nmflags]) fi fi ]) dnl GMP_PROG_CC_WORKS(cc+cflags,[ACTION-IF-WORKS][,ACTION-IF-NOT-WORKS]) dnl -------------------------------------------------------------------- dnl Check if cc+cflags can compile and link. dnl dnl This test is designed to be run repeatedly with different cc+cflags dnl selections, so the result is not cached. dnl dnl For a native build, meaning $cross_compiling == no, we require that the dnl generated program will run. This is the same as AC_PROG_CC does in dnl _AC_COMPILER_EXEEXT_WORKS, and checking here will ensure we don't pass dnl a CC/CFLAGS combination that it rejects. dnl dnl sparc-*-solaris2.7 can compile ABI=64 but won't run it if the kernel dnl was booted in 32-bit mode. The effect of requiring the compiler output dnl will run is that a plain native "./configure" falls back on ABI=32, but dnl ABI=64 is still available as a cross-compile. dnl dnl The various specific problems we try to detect are done in separate dnl compiles. Although this is probably a bit slower than one test dnl program, it makes it easy to indicate the problem in AC_MSG_RESULT, dnl hence giving the user a clue about why we rejected the compiler. AC_DEFUN([GMP_PROG_CC_WORKS], [AC_MSG_CHECKING([compiler $1]) gmp_prog_cc_works=yes # first see a simple "main()" works, then go on to other checks GMP_PROG_CC_WORKS_PART([$1], []) GMP_PROG_CC_WORKS_PART([$1], [function pointer return], [/* The following provokes an internal error from gcc 2.95.2 -mpowerpc64 (without -maix64), hence detecting an unusable compiler */ void *g() { return (void *) 0; } void *f() { return g(); } ]) GMP_PROG_CC_WORKS_PART([$1], [cmov instruction], [/* The following provokes an invalid instruction syntax from i386 gcc -march=pentiumpro on Solaris 2.8. The native sun assembler requires a non-standard syntax for cmov which gcc (as of 2.95.2 at least) doesn't know. */ int n; int cmov () { return (n >= 0 ? n : 0); } ]) GMP_PROG_CC_WORKS_PART([$1], [double -> ulong conversion], [/* The following provokes a linker invocation problem with gcc 3.0.3 on AIX 4.3 under "-maix64 -mpowerpc64 -mcpu=630". The -mcpu=630 option causes gcc to incorrectly select the 32-bit libgcc.a, not the 64-bit one, and consequently it misses out on the __fixunsdfdi helper (double -> uint64 conversion). */ double d; unsigned long gcc303 () { return (unsigned long) d; } ]) GMP_PROG_CC_WORKS_PART([$1], [double negation], [/* The following provokes an error from hppa gcc 2.95 under -mpa-risc-2-0 if the assembler doesn't know hppa 2.0 instructions. fneg is a 2.0 instruction, and a negation like this comes out using it. */ double fneg_data; unsigned long fneg () { return -fneg_data; } ]) GMP_PROG_CC_WORKS_PART([$1], [double -> float conversion], [/* The following makes gcc 3.3 -march=pentium4 generate an SSE2 xmm insn (cvtsd2ss) which will provoke an error if the assembler doesn't recognise those instructions. Not sure how much of the gmp code will come out wanting sse2, but it's easiest to reject an option we know is bad. */ double ftod_data; float ftod () { return (float) ftod_data; } ]) GMP_PROG_CC_WORKS_PART([$1], [gnupro alpha ev6 char spilling], [/* The following provokes an internal compiler error from gcc version "2.9-gnupro-99r1" under "-O2 -mcpu=ev6", apparently relating to char values being spilled into floating point registers. The problem doesn't show up all the time, but has occurred enough in GMP for us to reject this compiler+flags. */ struct try_t { char dst[2]; char size; long d0, d1, d2, d3, d4, d5, d6; char overlap; }; struct try_t param[6]; int param_init () { struct try_t *p; memcpy (p, ¶m[ 2 ], sizeof (*p)); memcpy (p, ¶m[ 2 ], sizeof (*p)); p->size = 2; memcpy (p, ¶m[ 1 ], sizeof (*p)); p->dst[0] = 1; p->overlap = 2; memcpy (p, ¶m[ 3 ], sizeof (*p)); p->dst[0] = 1; p->overlap = 8; memcpy (p, ¶m[ 4 ], sizeof (*p)); memcpy (p, ¶m[ 4 ], sizeof (*p)); p->overlap = 8; memcpy (p, ¶m[ 5 ], sizeof (*p)); memcpy (p, ¶m[ 5 ], sizeof (*p)); memcpy (p, ¶m[ 5 ], sizeof (*p)); return 0; } ]) # __builtin_alloca is not available everywhere, check it exists before # seeing that it works GMP_PROG_CC_WORKS_PART_TEST([$1],[__builtin_alloca availability], [int k; int foo () { __builtin_alloca (k); }], [GMP_PROG_CC_WORKS_PART([$1], [alloca array], [/* The following provokes an internal compiler error from Itanium HP-UX cc under +O2 or higher. We use this sort of code in mpn/generic/mul_fft.c. */ int k; int foo () { int i, **a; a = __builtin_alloca (k); for (i = 0; i <= k; i++) a[i] = __builtin_alloca (1 << i); } ])]) GMP_PROG_CC_WORKS_PART([$1], [abs int -> double conversion], [/* The following provokes an internal error from the assembler on power2-ibm-aix4.3.1.0. gcc -mrios2 compiles to nabs+fcirz, and this results in "Internal error related to the source program domain". For reference it seems to be the combination of nabs+fcirz which is bad, not either alone. This sort of thing occurs in mpz/get_str.c with the way double chars_per_bit_exactly is applied in MPN_SIZEINBASE. Perhaps if that code changes to a scaled-integer style then we won't need this test. */ double fp[1]; int x; int f () { int a; a = (x >= 0 ? x : -x); return a * fp[0]; } ]) GMP_PROG_CC_WORKS_PART([$1], [long long reliability test 1], [/* The following provokes a segfault in the compiler on powerpc-apple-darwin. Extracted from tests/mpn/t-iord_u.c. Causes Apple's gcc 3.3 build 1640 and 1666 to segfault with e.g., -O2 -mpowerpc64. */ #ifdef __GNUC__ typedef unsigned long long t1;typedef t1*t2; __inline__ t1 e(t2 rp,t2 up,int n,t1 v0) {t1 c,x,r;int i;if(v0){c=1;for(i=1;i> tnc; high_limb = low_limb << cnt; for (i = n - 1; i != 0; i--) { low_limb = *up++; *rp++ = ~(high_limb | (low_limb >> tnc)); high_limb = low_limb << cnt; } return retval; } int main () { unsigned long cy, rp[2], up[2]; up[0] = ~ 0L; up[1] = 0; cy = lshift_com (rp, up, 2L, 1); if (cy != 1L) return 1; return 0; } ]) GMP_PROG_CC_WORKS_PART_MAIN([$1], [mpn_lshift_com optimization 2], [/* The following is mis-compiled by Intel ia-64 icc version 1.8 under "icc -O3", After several calls, the function writes parial garbage to the result vector. Perhaps relates to the chk.a.nc insn. This code needs to be run to show the problem, but that's fine, the offending cc is a native-only compiler so we don't have to worry about cross compiling. */ #include void lshift_com (rp, up, n, cnt) unsigned long *rp; unsigned long *up; long n; unsigned cnt; { unsigned long high_limb, low_limb; unsigned tnc; long i; up += n; rp += n; tnc = 8 * sizeof (unsigned long) - cnt; low_limb = *--up; high_limb = low_limb << cnt; for (i = n - 1; i != 0; i--) { low_limb = *--up; *--rp = ~(high_limb | (low_limb >> tnc)); high_limb = low_limb << cnt; } *--rp = ~high_limb; } int main () { unsigned long *r, *r2; unsigned long a[88 + 1]; long i; for (i = 0; i < 88 + 1; i++) a[i] = ~0L; r = malloc (10000 * sizeof (unsigned long)); r2 = r; for (i = 0; i < 528; i += 22) { lshift_com (r2, a, i / (8 * sizeof (unsigned long)) + 1, i % (8 * sizeof (unsigned long))); r2 += 88 + 1; } if (r[2048] != 0 || r[2049] != 0 || r[2050] != 0 || r[2051] != 0 || r[2052] != 0 || r[2053] != 0 || r[2054] != 0) abort (); return 0; } ]) # A certain _GLOBAL_OFFSET_TABLE_ problem in past versions of gas, tickled # by recent versions of gcc. # if test "$gmp_prog_cc_works" = yes; then case $host in X86_PATTERN) # this problem only arises in PIC code, so don't need to test when # --disable-shared. We don't necessarily have $enable_shared set to # yes at this point, it will still be unset for the default (which is # yes); hence the use of "!= no". if test "$enable_shared" != no; then GMP_PROG_CC_X86_GOT_EAX_EMITTED([$1], [GMP_ASM_X86_GOT_EAX_OK([$1],, [gmp_prog_cc_works="no, bad gas GOT with eax"])]) fi ;; esac fi AC_MSG_RESULT($gmp_prog_cc_works) case $gmp_prog_cc_works in yes) [$2] ;; *) [$3] ;; esac ]) dnl Called: GMP_PROG_CC_WORKS_PART(CC+CFLAGS,FAIL-MESSAGE [,CODE]) dnl A dummy main() is appended to the CODE given. dnl AC_DEFUN([GMP_PROG_CC_WORKS_PART], [GMP_PROG_CC_WORKS_PART_MAIN([$1],[$2], [$3] [int main () { return 0; }]) ]) dnl Called: GMP_PROG_CC_WORKS_PART_MAIN(CC+CFLAGS,FAIL-MESSAGE,CODE) dnl CODE must include a main(). dnl AC_DEFUN([GMP_PROG_CC_WORKS_PART_MAIN], [GMP_PROG_CC_WORKS_PART_TEST([$1],[$2],[$3], [], gmp_prog_cc_works="no[]m4_if([$2],,,[[, ]])[$2]", gmp_prog_cc_works="no[]m4_if([$2],,,[[, ]])[$2][[, program does not run]]") ]) dnl Called: GMP_PROG_CC_WORKS_PART_TEST(CC+CFLAGS,TITLE,[CODE], dnl [ACTION-GOOD],[ACTION-BAD][ACTION-NORUN]) dnl AC_DEFUN([GMP_PROG_CC_WORKS_PART_TEST], [if test "$gmp_prog_cc_works" = yes; then # remove anything that might look like compiler output to our "||" expression rm -f conftest* a.out b.out a.exe a_out.exe cat >conftest.c <&AC_FD_CC gmp_compile="$1 conftest.c >&AC_FD_CC" if AC_TRY_EVAL(gmp_compile); then cc_works_part=yes if test "$cross_compiling" = no; then if AC_TRY_COMMAND([./a.out || ./b.out || ./a.exe || ./a_out.exe || ./conftest]); then :; else cc_works_part=norun fi fi else cc_works_part=no fi if test "$cc_works_part" != yes; then echo "failed program was:" >&AC_FD_CC cat conftest.c >&AC_FD_CC fi rm -f conftest* a.out b.out a.exe a_out.exe case $cc_works_part in yes) $4 ;; no) $5 ;; norun) $6 ;; esac fi ]) dnl GMP_PROG_CC_WORKS_LONGLONG(cc+cflags,[ACTION-YES][,ACTION-NO]) dnl -------------------------------------------------------------- dnl Check that cc+cflags accepts "long long". dnl dnl This test is designed to be run repeatedly with different cc+cflags dnl selections, so the result is not cached. AC_DEFUN([GMP_PROG_CC_WORKS_LONGLONG], [AC_MSG_CHECKING([compiler $1 has long long]) cat >conftest.c <&AC_FD_CC cat conftest.c >&AC_FD_CC fi rm -f conftest* a.out b.out a.exe a_out.exe AC_MSG_RESULT($gmp_prog_cc_works) if test $gmp_prog_cc_works = yes; then ifelse([$2],,:,[$2]) else ifelse([$3],,:,[$3]) fi ]) dnl GMP_C_TEST_SIZEOF(cc/cflags,test,[ACTION-GOOD][,ACTION-BAD]) dnl ------------------------------------------------------------ dnl The given cc/cflags compiler is run to check the size of a type dnl specified by the "test" argument. "test" can either be a string, or a dnl variable like $foo. The value should be for instance "sizeof-long-4", dnl to test that sizeof(long)==4. dnl dnl This test is designed to be run for different compiler and/or flags dnl combinations, so the result is not cached. dnl dnl The idea for making an array that has a negative size if the desired dnl condition test is false comes from autoconf AC_CHECK_SIZEOF. The cast dnl to "long" in the array dimension also follows autoconf, apparently it's dnl a workaround for a HP compiler bug. AC_DEFUN([GMP_C_TEST_SIZEOF], [echo "configure: testlist $2" >&AC_FD_CC [gmp_sizeof_type=`echo "$2" | sed 's/sizeof-\([a-z]*\).*/\1/'`] [gmp_sizeof_want=`echo "$2" | sed 's/sizeof-[a-z]*-\([0-9]*\).*/\1/'`] AC_MSG_CHECKING([compiler $1 has sizeof($gmp_sizeof_type)==$gmp_sizeof_want]) cat >conftest.c <conftest.c <     #1#)") ;;; Date: 9/06/2006 (Pascal Costanza) ;;; Fixed: 13/06/2006 (juanjo) ;;; Description: ;;; ;;; A MACROLET function creates a set of local macro definitions. ;;; The forms that expand these macros are themselves affected by ;;; enclosing MACROLET and SYMBOL-MACRO definitions: ;;; (defun bar () ;;; (macrolet ((x () 2)) ;;; (macrolet ((m () (x))) ;;; (m)))) ;;; (compile 'bar) ;;; (bar) => 2 ;;; (deftest compiler.0031.macrolet (list (progn (defun bar () (macrolet ((x () 2)) (macrolet ((m () (x))) (m)))) (compile 'bar) (bar)) (progn (defun bar () (symbol-macrolet ((x 2)) (macrolet ((m () x)) (m)))) (compile 'bar) (bar))) (2 2)) ;;; Fixed: 13/06/2006 (juanjo) ;;; Description: ;;; ;;; A MACROLET that references a local variable from the form in ;;; which it appears can cause corruption in the interpreter. We ;;; solve this by signalling errors whenever such reference ;;; happens. ;;; ;;; Additionally MACROLET forms should not see the other macro ;;; definitions on the same form, much like FLET functions cannot ;;; call their siblings. ;;; (deftest compiler.0032.macrolet (flet ((eval-with-error (form) (handler-case (eval form) (error (c) 'error)))) (makunbound 'compiler.0110-foo) (fmakunbound 'compiler.0110-foo) (let ((faa 1)) (declare (special faa)) (mapcar #'eval-with-error '((let ((faa 2)) (macrolet ((m () faa)) (m))) (let ((faa 4)) (declare (special faa)) (macrolet ((m () faa)) (m))) (let ((faa 4)) (declare (special compiler.0110-foo)) (macrolet ((m () compiler.0110-foo)) (m))) (let ((faa 5)) (macrolet ((m () compiler.0110-foo)) (m))) (macrolet ((compiler.0110-foo () 6)) (macrolet ((m () (compiler.0110-foo))) (m))) (macrolet ((f1 () 7) (f2 () 8)) ;; M should not see the new definitions F1 and F2 (macrolet ((f1 () 9) (f2 () 10) (m () (list 'quote (list (f1) (f2))))) (m))) (flet ((compiler.0110-foo () 1)) (macrolet ((m () (compiler.0110-foo))) (m))) (labels ((compiler.0110-foo () 1)) (macrolet ((m () (compiler.0110-foo))) (m))))))) (error 1 error error 6 (7 8) error error )) ;;; Date: 22/06/2006 (juanjo) ;;; Fixed: 29/06/2006 (juanjo) ;;; Description: ;;; ;;; ECL only accepted functions with less than 65 required ;;; arguments. Otherwise it refused to compile the function. The fix must ;;; respect the limit in the number of arguments passed in the C stack and ;;; use the lisp stack for the other required arguments. ;;; #-ecl-bytecmp (deftest compiler.0033.c-arguments-limit (mapcar #'(lambda (nargs) (let* ((arg-list (loop for i from 0 below nargs collect (intern (format nil "arg~d" i)))) (data (loop for i from 0 below nargs collect i)) (lambda-form `(lambda ,arg-list (and (equalp (list ,@arg-list) ',data) ,nargs))) (c:*compile-verbose* nil) (c:*compile-print* nil) (function (compile 'foo lambda-form))) (list (apply function (subseq data 0 nargs)) (handler-case (apply function (make-list (1+ nargs))) (error (c) :error)) (handler-case (apply function (make-list (1- nargs))) (error (c) :error))))) '(10 20 30 40 50 63 64 65 70)) ((10 :ERROR :ERROR) (20 :ERROR :ERROR) (30 :ERROR :ERROR) (40 :ERROR :ERROR) (50 :ERROR :ERROR) (63 :ERROR :ERROR) (64 :ERROR :ERROR) (65 :ERROR :ERROR) (70 :ERROR :ERROR))) (let* ((nargs 10) (arg-list (loop for i from 0 below nargs collect (intern (format nil "arg~d" i)))) (arguments (make-list nargs))) (apply (compile 'foo `(lambda ,arg-list (length (list ,@arg-list)))) arguments)) ;;; Date: 12/07/2008 (Josh Elsasser) ;;; Fixed: 02/08/2008 (Juanjo) ;;; Description: ;;; ;;; ECL fails to properly compute the closure type of a function that ;;; returns a lambda that calls the function itself. ;;; (deftest compiler.0034.compute-closure (and (with-compiler ("aux-compiler.0103-paths.lsp" :load t) (defun testfun (outer) (labels ((testlabel (inner) (if inner (testfun-map (lambda (x) (testlabel x)) inner)) (print outer))) (testlabel outer)))) t) t) ;;; Date: 02/09/2008 (Josh Elsasser) ;;; Fixed: 12/09/2008 (Josh Elsasser) ;;; Description: ;;; ;;; FTYPE proclamations and declarations do not accept user defined ;;; function types. ;;; (deftest compiler.0035.ftype-user-type (progn (deftype compiler.0113-float-function () '(function (float) float)) (deftype compiler.0113-float () 'float) (loop for (type . fails) in '(((function (float) float) . nil) (cons . t) (compiler.0113-float-function . nil) (compiler.0113-float . t)) always (let ((form1 `(proclaim '(ftype ,type foo))) (form2 `(compile nil '(lambda () (declare (ftype ,type foo)) (foo))))) (if fails (and (signals-error (eval form1) error) (signals-error (eval form2) error) t) (progn (eval form1) (eval form2) t))))) t) ;;; Date: 01/11/2008 (E. Marsden) ;;; Fixed: 02/11/2008 (Juanjo) ;;; Description: ;;; ;;; When compiled COERCE with type INTEGER may cause double ;;; evaluation of a form. (deftest compiler.0036.coerce (funcall (compile 'foo '(lambda (x) (coerce (shiftf x 2) 'integer))) 1) 1) ;;; Date: 03/11/2008 (E. Marsden) ;;; Fixed: 08/11/2008 (Juanjo) ;;; Description: ;;; ;;; TYPEP, with a real type, produces strange results. ;;; (deftest compiler.0037.coerce (funcall (compile 'foo '(lambda (x) (typep (shiftf x 1) '(real 10 20)))) 5) NIL) ;;; Date: 20/07/2008 (Juanjo) ;;; Fixed: 20/07/2008 (Juanjo) ;;; Description: ;;; ;;; In the new compiler, when compiling LET forms with special variables ;;; the values of the variables are not saved to make the assignments ;;; really parallel. ;;; (deftest compiler.0038.let-with-specials (progn (defvar *stak-x*) (defvar *stak-y*) (defvar *stak-z*) (funcall (compile nil '(lambda (*stak-x* *stak-y* *stak-z*) (labels ((stak-aux () (if (not (< (the fixnum *stak-y*) (the fixnum *stak-x*))) *stak-z* (let ((*stak-x* (let ((*stak-x* (the fixnum (1- (the fixnum *stak-x*)))) (*stak-y* *stak-y*) (*stak-z* *stak-z*)) (stak-aux))) (*stak-y* (let ((*stak-x* (the fixnum (1- (the fixnum *stak-y*)))) (*stak-y* *stak-z*) (*stak-z* *stak-x*)) (stak-aux))) (*stak-z* (let ((*stak-x* (the fixnum (1- (the fixnum *stak-z*)))) (*stak-y* *stak-x*) (*stak-z* *stak-y*)) (stak-aux)))) (stak-aux))))) (stak-aux)))) 18 12 6)) 7) ;;; Date: 06/10/2009 (J. Pellegrini) ;;; Fixed: 06/10/2009 (Juanjo) ;;; Description: ;;; Extended strings were not accepted as documentation by the interpreter. ;;; (deftest compiler.0039.docstrings (handler-case (progn (eval `(defun foo () ,(make-array 10 :initial-element #\Space :element-type 'character) 2)) (eval (funcall 'foo))) (serious-condition (c) nil)) 2) ;;; Date: 07/11/2009 (A. Hefner) ;;; Fixed: 07/11/2009 (A. Hefner + Juanjo) ;;; Description: ;;; ECL ignores the IGNORABLE declaration ;;; (deftest compiler.0040.ignorable (let ((c::*suppress-compiler-messages* t)) (and ;; Issue a warning for unused variables (handler-case (and (compile nil '(lambda (x y) (print x))) nil) (warning (c) t)) ;; Do not issue a warning for unused variables declared IGNORE (handler-case (and (compile nil '(lambda (x y) (declare (ignore y)) (print x))) t) (warning (c) nil)) ;; Do not issue a warning for unused variables declared IGNORABLE (handler-case (and (compile nil '(lambda (x y) (declare (ignorable y)) (print x))) t) (warning (c) nil)) ;; Do not issue a warning for used variables declared IGNORABLE (handler-case (and (compile nil '(lambda (x y) (declare (ignorable x y)) (print x))) t) (warning (c) nil)))) t) ;;; Date: 29/11/2009 (P. Costanza) ;;; Fixed: 29/11/2009 (Juanjo) ;;; Description: ;;; When calling a bytecodes (SETF ...) function from a compiled function ;;; an invalid memory access is produced. This is actually a consequence ;;; of a mismatch between the position of the fields bytecodes.entry ;;; and cfun.entry ;;; #-ecl-bytcmp (deftest compiler.0041.bytecodes-entry-position (let ((indices (funcall (compile nil '(lambda () (ffi:c-inline () () list " union cl_lispunion x[0]; cl_index bytecodes = (char*)(&(x->bytecodes.entry)) - (char*)x; cl_index bclosure = (char*)(&(x->bclosure.entry)) - (char*)x; cl_index cfun = (char*)(&(x->cfun.entry)) - (char*)x; cl_index cfunfixed = (char*)(&(x->cfunfixed.entry)) - (char*)x; cl_index cclosure = (char*)(&(x->cclosure.entry)) - (char*)x; @(return) = cl_list(5, MAKE_FIXNUM(bytecodes), MAKE_FIXNUM(bclosure), MAKE_FIXNUM(cfun), MAKE_FIXNUM(cfunfixed), MAKE_FIXNUM(cclosure));" :one-liner nil)))))) (and (apply #'= indices) t)) t) ;;; Date: 07/02/2010 (W. Hebich) ;;; Fixed: 07/02/2010 (Juanjo) ;;; Description: ;;; THE forms do not understand VALUES types ;;; (the (values t) (funcall sym)) ;;; (deftest compiler.0042.the-and-values (handler-case (and (compile 'foo '(lambda () (the (values t) (faa)))) t) (warning (c) nil)) t) ;;; Date: 28/03/2010 (M. Mondor) ;;; Fixed: 28/03/2010 (Juanjo) ;;; Description: ;;; ECL does not compile type declarations of a symbol macro ;;; (deftest compiler.0043.symbol-macro-declaration (handler-case (and (compile 'nil '(lambda (x) (symbol-macrolet ((y x)) (declare (fixnum y)) (+ y x)))) nil) (warning (c) t)) nil) ;;; Date: 24/04/2010 (Juanjo) ;;; Fixed 24/04/2010 (Juanjo) ;;; Description: ;;; New special form, WITH-BACKEND. ;;; (deftest compiler.0044.with-backend (progn (defparameter *compiler.0122* nil) (defun compiler.0122a () (ext:with-backend :bytecodes (setf *compiler.0122* :bytecodes) :c/c++ (setf *compiler.0122* :c/c++))) (list (progn (compiler.0122a) *compiler.0122*) (compiler.0122a) (progn (compile 'compiler.0122a) (compiler.0122a) *compiler.0122*) (compiler.0122a))) (:bytecodes :bytecodes :c/c++ :c/c++)) ;;; Date: 10/08/2008 ;;; From: Juanjo ;;; Fixed: 10/08/2008 ;;; Description: ;;; ;;; COS, SIN and TAN were expanded using a wrong C expression. ;;; (deftest compiler.0045.inline-cos (loop with *compile-verbose* = nil with *compile-print* = nil for type in '(short-float single-float double-float long-float) for sample = (coerce 1.0 type) for epsilon in '(#.short-float-epsilon #.single-float-epsilon #.double-float-epsilon #.long-float-epsilon) unless (loop for op in '(sin cos tan sinh cosh tanh) for f = (compile 'nil `(lambda (x) (declare (,type x) (optimize (safety 0) (speed 3))) (+ ,sample (,op x)))) always (loop for x from (- pi) below pi by 0.05 for xf = (float x sample) for error = (- (funcall f xf) (+ 1 (funcall op xf))) always (< (abs error) epsilon))) collect type) nil) ;;; Description: ;;; ;;; The interpreter selectively complains when assigning a variable ;;; that has not been declared as special and is not local. ;;; ;;; Fixed: 03/2006 (juanjo) ;;; (deftest compiler.0046.global-setq (mapcar (lambda (ext:*action-on-undefined-variable*) (handler-case (progn (eval `(setq ,(gensym) 1)) :no-error) (error (c) :error))) '(nil ERROR)) (:no-error :error)) ;;; Date: 24/04/2010 (Juanjo) ;;; Fixed: 24/04/2010 (Juanjo) ;;; Description: ;;; The interpreter does not increase the lexical environment depth when ;;; optimizing certain forms (LIST, LIST*, CONS...) and thus causes some ;;; of the arguments to be eagerly evaluated. ;;; (deftest compiler.0046.list-optimizer-error (with-output-to-string (*standard-output*) (eval '(list (print 1) (progn (print 2) (print 3))))) " 1 2 3 ") ;;; Date: 2015-09-04 ;;; Fixed: Daniel KochmaХ„ski ;;; Description ;;; Compiler signalled arithmetic-error when producing C code for infinity ;;; and NaN float values (part of ieee floating point extensions). #+ieee-floating-point (deftest compiler.0047.infinity-test.1 (progn (defun aux-compiler-0047.infty-test.1 () (> 0.0 ext:single-float-negative-infinity)) (compile 'aux-compiler-0047.infty-test.1)) aux-compiler-0047.infty-test.1 NIL NIL) #+ieee-floating-point (deftest compiler.0048.infinity-test.2 (progn (with-compiler ("aux-compiler-0048.infty-test.2.lsp") '(defun doit () (> 0.0 ext:single-float-negative-infinity))) (load "aux-compiler-0048.infty-test.2.fas") (delete-file "aux-compiler-0048.infty-test.2.lsp") (delete-file "aux-compiler-0048.infty-test.2.fas") (doit)) T) ;;; Date: 2015-12-18 ;;; Fixed: Daniel KochmaХ„ski ;;; Description ;;; Compiler expanded FIND incorrectly (ignored START and END arguments) (deftest compiler.0049.cmpopt-sequences.1 (progn (defun check-single-wildcard (identifier wildcard-pos) (not (find #\* identifier :start (1+ wildcard-pos)))) (compile 'check-single-wildcard) (check-single-wildcard "dan*" 3)) T) ecl-16.1.2/src/tests/regressions/tests/embedding.lsp000066400000000000000000000037121266352375300224570ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; Author: Juan Jose Garcia-Ripoll ;;;; Created: Fri Apr 14 11:13:17 CEST 2006 ;;;; Contains: Embedding regression tests (in-package :cl-test) (defun test-C-program (c-code &key capture-output) (ensure-directories-exist "tmp/") (with-open-file (s "tmp/aux.c" :direction :output :if-exists :supersede :if-does-not-exist :create) (princ c-code s)) (c::compiler-cc "tmp/aux.c" "tmp/aux.o") (c::linker-cc "tmp/aux.exe" '("tmp/aux.o")) (case capture-output (nil (return-from test-C-program (zerop (si::system "tmp/aux.exe")))) (STRING (with-output-to-string (s) (let ((in (si::run-program "tmp/aux.exe" '() :output :stream)) line) (loop (setf line (read-line in nil)) (unless line (return)) (write-line line s))))) (T (do* ((all '()) (x t) (in (si::run-program "tmp/aux.exe" '() :output :stream))) ((null in) all) (setf x (read in nil nil)) (unless x (return all)) (push x all))))) ;;; Date: 21/06/2006 (goffioul) ;;; Fixed: 23/06/2006 (juanjo) ;;; Description: ;;; ;;; Multiple invocations of cl_shutdown() can hang ECL. Also, ;;; cl_shutdown() is still invoked at exit (registered with ;;; atexit()) even if cl_shutdown was previously invoked. ;;; ;;; Fixed: 03/2006 (juanjo) ;;; (deftest embedding.0001.shutdown (let* ((skeleton " #include #include int main (int argc, char **argv) { cl_object x; cl_boot(argc, argv); si_safe_eval(3, x = c_string_to_object(~S), Cnil, Cnil); cl_shutdown(); exit(0); }") (form '(push (lambda () (print :shutdown)) si::*exit-hooks*)) (c-code (format nil skeleton (format nil "~S" form))) (data (test-C-program (print c-code) :capture-output t))) data) (:shutdown)) ecl-16.1.2/src/tests/regressions/tests/external-formats.lsp000066400000000000000000000354151266352375300240410ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; Author: Juan Jose Garcia-Ripoll ;;;; Created: Sat Jan 03 2:56:03 CEST 2007 ;;;; Contains: External format tests ;;;; ;;;; Based on the code and files from FLEXI-STREAMS 1.0.7 ;;;; #+(or) (eval-when (:compile-toplevel :load-toplevel :execute) (unless (find-package :cl-test) (make-package :cl-test))) (in-package :cl-test) ;;; eformat-001 (defconstant +buffer-size+ 8192 "Size of buffers for COPY-STREAM* below.") (defparameter *copy-function* 'copy-stream "Which function to use when copying from one stream to the other - see for example COPY-FILE below.") (defparameter *eformat-test-files* '(("unicode_demo" (:utf8 :ucs2 :ucs4)) ("kafka" (:utf8 :latin1 :cp1252)) ("hebrew" (:utf8 :latin8)) ("russian" (:utf8 :koi8r)) ("tilton" (:utf8 :ascii)) ) "A list of test files where each entry consists of the name prefix and a list of encodings.") (defun create-file-variants (file-name symbol) "For a name suffix FILE-NAME and a symbol SYMBOL denoting an encoding returns a list of pairs where the car is a full file name and the cdr is the corresponding external format. This list contains all possible variants w.r.t. to line-end conversion and endianness." (let ((variants (ecase symbol (:ascii '(:us-ascii)) (:latin1 '(:latin-1)) (:latin8 '(:iso-8859-8)) (:cp1252 '(:windows-cp1252)) (:koi8r '(:koi8-r)) (:utf8 '(:utf-8)) (:ucs2 '(:ucs-2be :ucs-2le)) (:ucs4 '(:ucs-4be :ucs-4le))))) (loop for arg in variants nconc (let* ((endian-suffix (case arg ((:ucs-2be :ucs-4be) "_be") ((:ucs-2le :ucs-4le) "_le") (t "")))) (loop for eol-style in '(:lf :cr :crlf) collect (cons (format nil "~A_~(~A~)_~(~A~)~A.txt" file-name symbol eol-style endian-suffix) (list eol-style arg))))))) (defun create-test-combinations (file-name symbols &optional simplep) "For a name suffix FILE-NAME and a list of symbols SYMBOLS denoting different encodings of the corresponding file returns a list of lists which can be used as arglists by DO-EFORMAT-TEST-001. If SIMPLEP is true, a list which can be used for the string and sequence tests below is returned." (let ((file-variants (loop for symbol in symbols nconc (create-file-variants file-name symbol)))) (loop for (name-in . external-format-in) in file-variants when simplep collect (list name-in external-format-in) else nconc (loop for (name-out . external-format-out) in file-variants collect (list name-in external-format-in name-out external-format-out))))) (defun file-equal (file1 file2) "Returns a true value iff FILE1 and FILE2 have the same contents \(viewed as binary files)." (with-open-file (stream1 file1 :element-type '(unsigned-byte 8)) (with-open-file (stream2 file2 :element-type '(unsigned-byte 8)) (if (= (file-length stream1) (file-length stream2)) (loop for p1 = (file-position stream1) for byte1 = (read-byte stream1 nil nil) for byte2 = (read-byte stream2 nil nil) while (and byte1 byte2) unless (= byte1 byte2) do (return (values nil p1)) finally (return (values t 0))) (values nil -1))))) (defun copy-stream (in out) "Copies the contents of the binary stream STREAM-IN to the binary stream STREAM-OUT using flexi streams - STREAM-IN is read with the external format EXTERNAL-FORMAT-IN and STREAM-OUT is written with EXTERNAL-FORMAT-OUT." (loop for line = (read-line in nil nil) while line do (write-line line out))) (defun copy-stream* (in out) "Like COPY-STREAM, but uses READ-SEQUENCE and WRITE-SEQUENCE instead of READ-LINE and WRITE-LINE." (let ((buffer (make-array +buffer-size+ :element-type 'char*))) (loop (let ((position (read-sequence buffer in))) (when (zerop position) (return)) (write-sequence buffer out :end position))))) (defun do-eformat-test-001 (*copy-function*) "Each test in this suite copies the contents of one file \(in the `test' directory) to another file \(in a temporary directory) using flexi streams with different external formats. The resulting file is compared with an existing file in the `test' directory to check if the outcome is as expected. Uses various variants of the :DIRECTION keyword when opening the files. Returns a true value iff all tests succeeded. Prints information about each individual comparison if VERBOSE is true." (labels ((copy-file (path-in external-format-in path-out external-format-out direction-out direction-in) (with-open-file (in path-in :element-type 'character :direction direction-in :if-does-not-exist :error :if-exists :overwrite :external-format external-format-in) (with-open-file (out path-out :element-type 'character :direction direction-out :if-does-not-exist :create :if-exists :supersede :external-format external-format-out) (funcall *copy-function* in out)))) (one-comparison (path-in external-format-in path-out external-format-out) (format t "~%;;; ~A -> ~A" path-in path-out) (loop with full-path-in = (merge-pathnames path-in "./eformat-tests/") and full-path-out = (ensure-directories-exist (merge-pathnames path-out "./eformat-tmp/")) and full-path-orig = (merge-pathnames path-out "./eformat-tests/") for direction-out in '(:output :io) nconc (loop for direction-in in '(:input :io) for args = (list path-in external-format-in direction-in path-out external-format-out direction-out) with ok = nil with pos = 0 unless (progn (copy-file full-path-in external-format-in full-path-out external-format-out direction-out direction-in) (multiple-value-setq (ok pos) (file-equal full-path-out full-path-orig))) collect (progn (format t "~%;;; Discordance at pos ~D~%between ~A~% and ~A~%" pos full-path-out full-path-orig) args))))) (loop with do-eformat-test-001-args-list = (loop for (file-name symbols) in *eformat-test-files* nconc (create-test-combinations file-name symbols)) for (path-in external-format-in path-out external-format-out) in do-eformat-test-001-args-list nconc (one-comparison path-in external-format-in path-out external-format-out)))) ;;; Date: 02/01/2007 ;;; From: Juanjo ;;; Fixed: Not a bug ;;; Description: ;;; ;;; Test external formats by transcoding several files into all possible ;;; supported formats and checking against the expected results. This ;;; test uses READ/WRITE-CHAR via READ/WRITE-LINE. ;;; (deftest external-format.0001-transcode-read-char (do-eformat-test-001 'copy-stream) nil) ;;; Date: 02/01/2007 ;;; From: Juanjo ;;; Fixed: Not a bug ;;; Description: ;;; ;;; Test external formats by transcoding several files into all possible ;;; supported formats and checking against the expected results. This ;;; test uses READ/WRITE-CHAR via READ/WRITE-LINE. ;;; (deftest external-format.0002-transcode-read-char (do-eformat-test-001 'copy-stream*) nil) ;;; eformat-002 (load "sys:encodings;tools") (setf *print-circle* t) ; some mappings contain circular structures (defun binary-dump (filename &optional (position 0) (limit nil)) (format t "~%FILE: ~A from ~D, ~D bytes" filename position limit) (with-open-file (file filename :element-type '(unsigned-byte 8)) (file-position file position) (loop for i from 0 for byte = (read-byte file nil nil) for c = (and byte (code-char byte)) while (and byte (or (null limit) (< i limit))) do (progn (when (zerop (mod i 8)) (terpri)) (format t "~5X ~3A" byte (cond ((and (< 31 byte 127) (standard-char-p c)) c) ((eql c #\Esc) "ESC") (t " "))) ))) (terpri) (force-output)) (defun random-strings (char-bag n) (if (consp char-bag) (apply #'concatenate 'string (loop for i from 0 below 2 for actual-bag = (elt char-bag (random (length char-bag))) collect (random-strings actual-bag (random n)))) (concatenate 'string (loop for i from 0 to n for c = (char char-bag (random (length char-bag))) unless (eql c #\Newline) collect c)))) (defun compare-files (a b &optional all-chars) (with-open-file (sa a :direction :input :element-type '(unsigned-byte 8)) (with-open-file (sb b :direction :input :element-type '(unsigned-byte 8)) (loop for b1 = (read-byte sa nil nil) for b2 = (read-byte sb nil nil) while (or b1 b2) do (unless (eql b1 b2) (let* ((position (1- (file-position sa))) (start-dump (max 0 (- position 8)))) (setf position (logandc2 position 3)) (binary-dump a start-dump 32) (binary-dump b start-dump 32) (format t "~%Mismatch between~%~T~A~% and~T~A~% at file position ~D~%" a b position) (when all-chars (loop with imin = (floor start-dump 4) with imax = (min (+ imin 9) (length all-chars)) for i from imin below imax for j from 0 for c = (char all-chars i) do (progn (when (zerop (mod j 8)) (terpri)) (format t "~4X " (char-code c)))) (terpri)) (return nil))) finally (return t))))) (defun test-output (format-name &optional iconv-name (nlines 128) (nchars 10)) (set 'ext::foo format-name) (let* ((*print-circle* t) (mappings (loop for table = (ext::make-encoding format-name) while (and table (symbolp table)) do (setf format-name table) finally (return (or table format-name)))) (char-bags (all-valid-unicode-chars mappings)) (encoded-filename (format nil "eformat-tmp/iconv-~A.txt" format-name)) (decoded-filename (format nil "eformat-tmp/iconv-~A-utf32.txt" format-name)) (iconv-filename (format nil "eformat-tmp/iconv-~A-iconv-utf32.txt" format-name)) (random-lines (loop for line from 1 to nlines collect (random-strings char-bags nchars))) (all-chars (apply #'concatenate 'string (loop for i in random-lines nconc (list i (list #\Newline)))))) (ensure-directories-exist encoded-filename) ;; Output in that format (with-open-file (out encoded-filename :direction :output :external-format format-name :if-exists :supersede) (loop for i in random-lines do (write-line i out))) (with-open-file (out decoded-filename :direction :output :external-format :ucs-4be :if-exists :supersede) (loop for i in random-lines do (write-line i out))) (with-open-file (in encoded-filename :direction :input :external-format format-name) (loop for line = (read-line in nil nil) for i in random-lines for n from 1 while line unless (string= i line) do (progn (format t "Mismatch on line ~D between~% ~S and~% ~S" n line i) (return-from test-output nil)))) (when iconv-name (let ((command (format nil "iconv -f ~A -t UTF-32BE ~A > ~A" iconv-name encoded-filename iconv-filename))) (if (zerop (si::system command)) (compare-files decoded-filename iconv-filename all-chars) (prog1 T (format t "~&;;; iconv command failed:~A" command))))))) ;;; Date: 09/01/2007 ;;; From: Juanjo ;;; Fixed: Not a bug ;;; Description: ;;; ;;; Test external formats by transcoding random sequences of characters using ;;; ECL and iconv. ;;; #-msvc ;; In Windows SYSTEM does not fail with a nonzero code when it ;; fails to execute a command. Hence in that case we assume ;; we simply can not run these tests (when (zerop (si::system "iconv -l >/dev/null 2>&1")) (deftest external-format.simple-iconv-check (loop for name in '(:ISO-8859-1 :ISO-8859-2 :ISO-8859-3 :ISO-8859-4 :ISO-8859-5 :ISO-8859-6 :ISO-8859-7 :ISO-8859-8 :ISO-8859-9 :ISO-8859-10 :ISO-8859-11 :ISO-8859-13 :ISO-8859-14 :ISO-8859-15 :ISO-8859-16 :KOI8-R :KOI8-U :IBM437 :IBM850 :IBM852 :IBM855 :IBM857 :IBM860 :IBM861 :IBM862 :IBM863 :IBM864 :IBM865 :IBM866 :IBM869 :CP936 :CP949 :CP950 :WINDOWS-1250 :WINDOWS-1251 :WINDOWS-1252 :WINDOWS-1253 :WINDOWS-1254 :WINDOWS-1256 :WINDOWS-1257 ;; :CP932 :WINDOWS-1255 :WINDOWS-1258 with ;; iconv may output combined characters, when ECL would ;; output the base and the comibining one. Hence, no simple ;; comparison is possible. :ISO-2022-JP ;; :ISO-2022-JP-1 ;; iconv doesn't support ISO-2022-JP-1 (hue hue hue) ) unless (progn (format t "~%;;; Testing ~A " name) (loop for i from 1 to 10 always (test-output name (symbol-name name)))) collect name) nil)) ecl-16.1.2/src/tests/regressions/tests/foreign-interface.lsp000066400000000000000000000073361266352375300241360ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; Author: Juan Jose Garcia-Ripoll ;;;; Author: Daniel KochmaХ„ski ;;;; Created: Fri Apr 14 11:13:17 CEST 2006 ;;;; Contains: Foreign Function Interface regression tests (in-package :cl-test) ;;; Date: 23/03/2006 ;;; From: Klaus Falb ;;; Fixed: 26/02/2006 (juanjo) ;;; Description: ;;; ;;; Callback functions have to be declared static so that there ;;; are no conflicts among callbacks in different files. ;;; ;;; Fixed: 13/04/2006 (juanjo) ;;; Description: ;;; ;;; Header should be included as ;;; (deftest foreign-interface.0001.callback (and (zerop (si::system "rm -rf tmp; mkdir tmp")) (with-open-file (s "tmp/a.lsp" :direction :output :if-exists :supersede :if-does-not-exist :create) (print '(ffi:defcallback foo :void () nil) s)) (with-open-file (s "tmp/b.lsp" :direction :output :if-exists :supersede :if-does-not-exist :create) (print '(ffi:defcallback foo :void () nil) s)) (compile-file "tmp/a.lsp" :system-p t) (compile-file "tmp/b.lsp" :system-p t) (c:build-program "tmp/foo" :lisp-files (list (compile-file-pathname "tmp/a.lsp" :type :object) (compile-file-pathname "tmp/b.lsp" :type :object))) (probe-file (compile-file-pathname "tmp/foo" :type :program)) (zerop (si::system "rm -rf tmp")) t) t) ;;; Date: 29/07/2008 ;;; From: Juajo ;;; Description: ;;; Callback examples based on the C compiler ;;; (deftest foreign-interface.0002.callback (and (zerop (si::system "rm -rf tmp; mkdir tmp")) (with-open-file (s "tmp/c.lsp" :direction :output :if-exists :supersede :if-does-not-exist :create) (print '(defun callback-user (callback arg) (ffi:c-inline (callback arg) (:pointer-void :int) :int " int (*foo)(int) = #0; @(return) = foo(#1); " :one-liner nil :side-effects nil)) s) (print '(ffi:defcallback ffi-002-foo :int ((a :int)) (1+ a)) s)) (compile-file "tmp/c.lsp" :load t) (eql (callback-user (ffi:callback 'ffi-002-foo) 2) 3) t) t) ;;; Date: 29/07/2008 ;;; From: Juajo ;;; Description: ;;; Callback examples based on the DFFI. Only work if this feature ;;; has been linked in. ;;; #+dffi (deftest foreign-interface.0003.callback (and (zerop (si::system "rm -rf tmp; mkdir tmp")) (with-open-file (s "tmp/c.lsp" :direction :output :if-exists :supersede :if-does-not-exist :create) (print '(defun callback-user (callback arg) (ffi:c-inline (callback arg) (:pointer-void :int) :int " int (*foo)(int) = #0; @(return) = foo(#1); " :one-liner nil :side-effects nil)) s)) (compile-file "tmp/c.lsp" :load t) (eval '(ffi:defcallback foo-002b :int ((a :int)) (1+ a))) (eql (callback-user (ffi:callback 'foo-002b) 2) 3) t) t) ;;; Date: 25/04/2010 (Juanjo) ;;; Description: ;;; Regression test to ensure that two foreign data compare ;;; EQUAL when their addresses are the same. (deftest foreign-interface.0004.foreign-data-equal (equal (ffi:make-pointer 1234 :void) (ffi:make-pointer 1234 :int)) t) ;;; Date: 2016-01-04 (jackdaniel) ;;; Description: ;;; Regression test to ensure, that the string is properly ;;; recognized as an array (deftest foreign-interface.0004 (progn (si::make-foreign-data-from-array "dan") t) t) ecl-16.1.2/src/tests/regressions/tests/metaobject-protocol.lsp000066400000000000000000000552361266352375300245250ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; Author: Juan Jose Garcia-Ripoll ;;;; Author: Daniel KochmaХ„ski ;;;; Created: Fri Apr 14 11:13:17 CEST 2006 ;;;; Contains: Metaobject Protocol tests (in-package :cl-test) (use-package :clos) ;; mop-001 (defun delete-class (&rest class-names) ;;; do nothing. We will figure out later what to do. (values)) ;;; Fixed: 14/04/2006 (juanjo) ;;; Description: ;;; ;;; The slot definitions from some classes did not get converted. ;;; Besides, metaobject CLASS had the same list for direct and effective ;;; slots. ;;; (deftest mop-0001-fixup (block top (labels ((test-class (class-object) (let ((x (find-if-not #'(lambda (x) (typep x 'standard-direct-slot-definition)) (class-direct-slots class-object)))) (when x (format t "Class ~a has as direct slot ~a" class-object x) (return-from top (class-name class-object)))) (let ((x (find-if-not #'(lambda (x) (typep x 'standard-effective-slot-definition)) (class-slots class-object)))) (when x (format t "Class ~a has as effective slot ~a" class-object x) (return-from top (class-name class-object)))) (mapc #'test-class (clos::class-direct-subclasses class-object)))) (test-class (find-class 't)) nil)) nil) ;;; Date: 13/02/2006 ;;; From: Dan Debertin ;;; Fixed: 24-02-2006 (juanjo) ;;; Description: ;;; ;;; Subclasses of STANDARD-CLASS would not inherit all their slots ;;; and thus would cause runtime errors when creating instances. ;;; (deftest mop-0002-metaclasses (eval '(progn (defclass foo-metaclass (standard-class) ()) (defclass faa () ((a :initform 2 :initarg :a)) (:metaclass foo-metaclass)) (prog1 (slot-value (make-instance 'faa :a 3) 'a) (cl-test::delete-class 'foo-metaclass 'faa)))) 3) ;;; Date: 02/03/2006 ;;; From: Pascal Costanza ;;; Fixed: 07/03/2006 (juanjo) ;;; Description: ;;; ;;; CLOS should export the symbols from the AMOP. ;;; (defconstant +mop-symbols+ '("DIRECT-SLOT-DEFINITION" "EFFECTIVE-SLOT-DEFINITION" "EQL-SPECIALIZER" "FORWARD-REFERENCED-CLASS" "FUNCALLABLE-STANDARD-CLASS" "FUNCALLABLE-STANDARD-OBJECT" "METAOBJECT" "SLOT-DEFINITION" "SPECIALIZER" "STANDARD-ACCESSOR-METHOD" "STANDARD-DIRECT-SLOT-DEFINITION" "STANDARD-EFFECTIVE-SLOT-DEFINITION" "STANDARD-READER-METHOD" "STANDARD-SLOT-DEFINITION" "STANDARD-WRITER-METHOD" "ACCESSOR-METHOD-SLOT-DEFINITION" "ADD-DEPENDENT" "ADD-DIRECT-METHOD" "ADD-DIRECT-SUBCLASS" "CLASS-DEFAULT-INITARGS" "CLASS-DIRECT-DEFAULT-INITARGS" "CLASS-DIRECT-SLOTS" "CLASS-DIRECT-SUBCLASSES" "CLASS-DIRECT-SUPERCLASSES" "CLASS-FINALIZED-P" "CLASS-PRECEDENCE-LIST" "CLASS-PROTOTYPE" "CLASS-SLOTS" "COMPUTE-APPLICABLE-METHODS-USING-CLASSES" "COMPUTE-CLASS-PRECEDENCE-LIST" "COMPUTE-DEFAULT-INITARGS" "COMPUTE-DISCRIMINATING-FUNCTION" "COMPUTE-EFFECTIVE-METHOD" "COMPUTE-EFFECTIVE-SLOT-DEFINITION" "COMPUTE-SLOTS" "DIRECT-SLOT-DEFINITION-CLASS" "EFFECTIVE-SLOT-DEFINITION-CLASS" "ENSURE-CLASS" "ENSURE-CLASS-USING-CLASS" "ENSURE-GENERIC-FUNCTION-USING-CLASS" "EQL-SPECIALIZER-OBJECT" "EXTRACT-LAMBDA-LIST" "EXTRACT-SPECIALIZER-NAMES" "FINALIZE-INHERITANCE" "FIND-METHOD-COMBINATION" "FUNCALLABLE-STANDARD-INSTANCE-ACCESS" "GENERIC-FUNCTION-ARGUMENT-PRECEDENCE-ORDER" "GENERIC-FUNCTION-DECLARATIONS" "GENERIC-FUNCTION-LAMBDA-LIST" "GENERIC-FUNCTION-METHOD-CLASS" "GENERIC-FUNCTION-METHOD-COMBINATION" "GENERIC-FUNCTION-METHODS" "GENERIC-FUNCTION-NAME" "INTERN-EQL-SPECIALIZER" "MAKE-METHOD-LAMBDA" "MAP-DEPENDENTS" "METHOD-FUNCTION" "METHOD-GENERIC-FUNCTION" "METHOD-LAMBDA-LIST" "METHOD-SPECIALIZERS" "READER-METHOD-CLASS" "REMOVE-DEPENDENT" "REMOVE-DIRECT-METHOD" "REMOVE-DIRECT-SUBCLASS" "SET-FUNCALLABLE-INSTANCE-FUNCTION" "SLOT-BOUNDP-USING-CLASS" "SLOT-DEFINITION-ALLOCATION" "SLOT-DEFINITION-INITARGS" "SLOT-DEFINITION-INITFORM" "SLOT-DEFINITION-INITFUNCTION" "SLOT-DEFINITION-LOCATION" "SLOT-DEFINITION-NAME" "SLOT-DEFINITION-READERS" "SLOT-DEFINITION-WRITERS" "SLOT-DEFINITION-TYPE" "SLOT-MAKUNBOUND-USING-CLASS" "SLOT-VALUE-USING-CLASS" "SPECIALIZER-DIRECT-GENERIC-FUNCTIONS" "SPECIALIZER-DIRECT-METHODS" "STANDARD-INSTANCE-ACCESS" "UPDATE-DEPENDENT" "VALIDATE-SUPERCLASS" "WRITER-METHOD-CLASS")) (deftest mop-0003-symbols (let ((*package* (find-package "CLOS"))) (and (remove-if #'(lambda (x) (multiple-value-bind (s t) (find-symbol x *package*) (and s (eq t :external)))) +mop-symbols+) t)) nil) ;;; Date: 02/03/2006 ;;; From: Dank Corkill ;;; Fixed: 02-03-2006 (Dan Corkill) ;;; Description: ;;; ;;; DEFCLASS allows additional options which should be handled by the ;;; metaclass. ;;; (deftest mop-0004-defclass-options (eval '(let ((*aux* 5)) (declare (special *aux*)) (defclass foo-metaclass (standard-class) ()) (defmethod shared-initialize ((class foo-metaclass) slot-names &rest initargs &key option) (prog1 (call-next-method) (setf *aux* option))) (defclass faa () ((a :initform *aux* :initarg :a)) (:metaclass foo-metaclass) (:option t)) (prog1 (slot-value (make-instance 'faa) 'a) (cl-test::delete-class 'foo-metaclass 'faa)))) (T)) ;;; Date: 02/03/2006 ;;; From: Dank Corkill ;;; Fixed: 02-03-2006 (Dan Corkill) ;;; Description: ;;; ;;; Readers and writers for slot documentation. ;;; (deftest mop-0004b-slot-documentation (eval '(progn (defclass fee () ((a :initform *aux* :initarg :a))) (setf (documentation (first (clos:class-slots (find-class 'fee))) t) #1="hola") (documentation (first (clos:class-slots (find-class 'fee))) t))) #1#) ;;; Date: 25/03/2006 ;;; From: Pascal Costanza ;;; Fixed: 03/04/2006 (juanjo) ;;; Description: ;;; ;;; The default slot setter methods had the first argument ;;; (i.e. the new value) specialized to NIL. This makes it ;;; impossible to write further specializations. ;;; (deftest mop-0005-setf-specializer (progn (defclass fee () ((a :accessor fee-a))) (prog1 (list (mapcar #'class-name (method-specializers (first (generic-function-methods #'(setf fee-a))))) (mapcar #'class-name (method-specializers (first (generic-function-methods #'fee-a))))) (delete-class 'fee))) ((t fee) (fee))) ;;; Date: 06/04/2006 ;;; From: Pascal Costanza ;;; Fixed: --- ;;; Description: ;;; ;;; When a required argument in a method is not explicitely given ;;; an specializer, the specializer should be T. Thus ;;; (defmethod foo (a)) ;;; is equivalent to ;;; (defmethod foo ((a t))) ;;; (deftest mop-0006-method-specializer (progn (defmethod mop-0006-foo (a)) (prog1 (method-specializers (first (generic-function-methods #'mop-0006-foo))) (fmakunbound 'mop-0006-foo))) (#.(find-class t))) ;;; Date: 22/04/2006 ;;; From: M. Goffioul ;;; Fixed: 23/04/2006 (juanjo) ;;; Description: ;;; ;;; When a class inherits from two other classes which have a slot ;;; with the same name, the new class should inherit the accessors ;;; from both classes. ;;; (deftest mop-0007-slot-inheritance (progn (defclass fee-1 () ((slot-0 :initform 0 :reader slot-0) (slot-1 :initform 1 :reader slot-1))) (defclass fee-2 () ((slot-0 :initform 2 :reader slot-2))) (defclass fee-3 (fee-1 fee-2) ((slot-0 :initform 3 :accessor c-slot-0))) (flet ((accessors (class) (list (class-name class) (mapcar #'slot-definition-readers (class-slots class)) (mapcar #'slot-definition-readers (class-slots class))))) (prog1 (list (accessors (find-class 'fee-1)) (accessors (find-class 'fee-2)) (accessors (find-class 'fee-3)) (mapcar #'(lambda (o) (mapcar #'(lambda (method) (handler-case (funcall method o) (error (c) nil))) '(slot-0 slot-2 c-slot-0))) (mapcar #'make-instance '(fee-1 fee-2 fee-3)))) (delete-class 'fee-1 'fee-2 'fee-3)))) ((fee-1 ((slot-0) (slot-1)) ((slot-0) (slot-1))) (fee-2 ((slot-2)) ((slot-2))) (fee-3 ((c-slot-0 slot-0 slot-2) (slot-1)) ((c-slot-0 slot-0 slot-2) (slot-1))) ((0 nil nil) (nil 2 nil) (3 3 3)))) ;;; Date: 28/04/2006 ;;; From: P. Costanza ;;; Fixed: 05/05/2006 (P. Costanza) ;;; Description: ;;; ;;; Option names from classes and generic functions which are not ;;; in the keyword package should be quoted. This test is ;;; essentially like mop-0004-... because our DEFGENERIC does not ;;; support non-keyword options. ;;; (deftest mop-0008-defclass-option-quote (eval '(let ((*aux* 5)) (declare (special *aux*)) (defclass foo-metaclass (standard-class) ()) (defmethod shared-initialize ((class foo-metaclass) slot-names &rest initargs &key ((cl-user::option option))) (prog1 (call-next-method) (setf *aux* option))) (defclass faa () ((a :initform *aux* :initarg :a)) (:metaclass foo-metaclass) (cl-user::option t)) (prog1 (slot-value (make-instance 'faa) 'a) (cl-test::delete-class 'foo-metaclass 'faa)))) (t)) ;;; Date: 05/10/2006 ;;; From: Rick Taube ;;; Fixed: 10/10/2006 (juanjo) ;;; Description: ;;; ;;; :INITFORM arguments do not get properly expanded when the form ;;; is a constant variable. ;;; ;;; (defclass a () ((a :initform most-positive-fixnum))) ;;; (slot-value (make-instance a) 'a) => most-positive-fixnum ;;; (deftest mop-0009-defclass-initform (loop for quoting in '(nil t) collect (loop for f in '(most-positive-fixnum #1=#.(lambda () 1) 12 "hola" :a t nil) collect (prog1 (eval `(progn (defclass foo () ((a :initform ,(if quoting (list 'quote f) f)))) (slot-value (make-instance 'foo) 'a))) (cl-test::delete-class 'foo)))) ((#.most-positive-fixnum #1# 12 "hola" :a t nil) (most-positive-fixnum #1# 12 "hola" :a t nil))) ;; Test MOP dependents (defclass mop-dependent-object () ((log :initform nil :initarg :log :accessor mop-dependent-object-log))) (defmethod update-dependent ((object t) (dep mop-dependent-object) &rest initargs) (push (list* object initargs) (mop-dependent-object-log dep))) ;;; Date: 23/04/2012 ;;; Description: ;;; ;;; ADD-DEPENDENT uses pushnew ;;; (deftest mop-gf-add-non-redundant (let* ((dep (make-instance 'mop-dependent-object)) l1 l2) (fmakunbound 'mop-gf-add/remove-dependent) (defgeneric mop-gf-add/remove-dependent (a)) (let ((f #'mop-gf-add/remove-dependent)) (clos:add-dependent f dep) (setf l1 (clos::generic-function-dependents f)) (clos:add-dependent f dep) (setf l2 (clos::generic-function-dependents f)) (and (eq l1 l2) (equalp l1 (list dep)) t))) t) ;;; Date: 23/04/2012 ;;; Description: ;;; ;;; Generic functions have dependents and are activated ;;; (deftest mop-gf-add/remove-dependent (let* ((dep (make-instance 'mop-dependent-object)) l1 l2 l3 l4 l5 l6) (fmakunbound 'mop-gf-add/remove-dependent) (defgeneric mop-gf-add/remove-dependent (a)) (let ((f #'mop-gf-add/remove-dependent) m1 m2) ;; ;; * ADD-DEPENDENT registers the object with the function ;; (clos:add-dependent f dep) (setf l1 (clos::generic-function-dependents f)) ;; ;; * ADD-METHOD invokes UPDATE-DEPENDENT ;; (defmethod mop-gf-add/remove-dependent ((a number)) (cos a)) (setf l2 (mop-dependent-object-log dep)) ;; ;; * REMOVE-METHOD invokes UPDATE-DEPENDENT ;; (setf m1 (first (compute-applicable-methods f (list 1.0)))) (remove-method f m1) (setf l3 (mop-dependent-object-log dep)) ;; ;; * REMOVE-DEPENDENT eliminates all dependencies ;; (clos:remove-dependent f dep) (setf l4 (clos::generic-function-dependents f)) ;; ;; * ADD-METHOD invokes UPDATE-DEPENDENT but has no effect ;; (defmethod mop-gf-add/remove-dependent ((a symbol)) a) (setf l5 (mop-dependent-object-log dep)) ;; ;; * REMOVE-METHOD invokes UPDATE-DEPENDENT but has no effect ;; (setf m2 (first (compute-applicable-methods f (list 'a)))) (setf l6 (mop-dependent-object-log dep)) ;; the first call to defmethod adds two entries: one for the ;; add-method and another one for a reinitialize-instance with ;; the name of the function (values (equalp l1 (list dep)) (eq l2 (rest l3)) (equalp l3 (list (list f 'remove-method m1) (list f 'add-method m1) (list f))) (null l4) (eq l5 l3) (eq l6 l3) t))) t t t t t t t) ;;; Date: 23/04/2012 ;;; Description: ;;; ;;; ADD-DEPENDENT does not duplicate elements ;;; (deftest mop-class-add/remove-dependent (let* ((dep (make-instance 'mop-dependent-object)) l1 l2) (when (find-class 'mop-class-add/remove-dependent nil) (setf (class-name (find-class 'mop-class-add/remove-dependent)) nil)) (defclass mop-class-add/remove-dependent () ()) (let ((f (find-class 'mop-class-add/remove-dependent))) (clos:add-dependent f dep) (setf l1 (clos::class-dependents f)) (clos:add-dependent f dep) (setf l2 (clos::class-dependents f)) (and (eq l1 l2) (equalp l1 (list dep)) t))) t) ;;; Date: 23/04/2012 ;;; Description: ;;; ;;; Standard classes have dependents and are activated ;;; (deftest mop-class-add/remove-dependent (let* ((dep (make-instance 'mop-dependent-object)) l1 l2 l3 l4 l5) (when (find-class 'mop-class-add/remove-dependent nil) (setf (class-name (find-class 'mop-class-add/remove-dependent)) nil)) (defclass mop-class-add/remove-dependent () ()) (let ((f (find-class 'mop-class-add/remove-dependent))) ;; ;; * ADD-DEPENDENT registers the object with the class ;; (clos:add-dependent f dep) (setf l1 (clos::class-dependents f)) ;; ;; * SHARED-INITIALIZE invokes UPDATE-DEPENDENT ;; (defclass mop-class-add/remove-dependent () (a)) (setf l2 (clos::class-dependents f)) (setf l3 (mop-dependent-object-log dep)) ;; ;; * REMOVE-DEPENDENT eliminates object from list ;; (clos:remove-dependent f dep) (setf l4 (clos::class-dependents f)) ;; ;; * SHARED-INITIALIZE invokes UPDATE-DEPENDENT without effect ;; (defclass mop-class-add/remove-dependent () ()) (setf l5 (mop-dependent-object-log dep)) ;; ;; the first call to defclass adds one entry with the reinitialization ;; of the class both in name and list of slots (and (equalp l1 (list dep)) (eq l1 l2) (equalp l3 (list (list f :name 'mop-class-add/remove-dependent :direct-superclasses nil :direct-slots '((:name a))))) (null l4) (eq l5 l3) t))) t) ;; Test MOP dispatch ;;; Date: 23/04/2012 ;;; Description: ;;; ;;; COMPUTE-APPLICABLE-METHODS-USING-CLASSES works with one and ;;; two methods and no EQL. ;;; (deftest mop-c-a-m-u-c-two-methods (progn (fmakunbound 'mop-fn) (defgeneric mop-fn (a) (:method ((a number)) (cos a)) (:method ((a symbol)) a)) (let ((m1 (compute-applicable-methods #'mop-fn (list 1.0))) (m2 (compute-applicable-methods #'mop-fn (list 'a)))) (flet ((f (class) (multiple-value-list (clos:compute-applicable-methods-using-classes #'mop-fn (list (find-class class)))))) (and (equalp (f 'number) (list m1 t)) (equalp (f 'real) (list m1 t)) (equalp (f 'symbol) (list m2 t)) (equalp (f 'cons) '(nil t)) t)))) t) ;;; Date: 23/04/2012 ;;; Description: ;;; ;;; COMPUTE-APPLICABLE-METHODS-USING-CLASSES fails with EQL ;;; specializers when one of the specializers is covered by the ;;; classes. ;;; (deftest mop-c-a-m-u-c-fails-with-eql (progn (fmakunbound 'mop-fn) (defgeneric mop-fn (a) (:method ((a (eql 1))) 1) (:method ((a (eql 'a))) 2) (:method ((a float)) 3)) (let ((m1 (compute-applicable-methods #'mop-fn (list 1))) (m2 (compute-applicable-methods #'mop-fn (list 'a))) (m3 (compute-applicable-methods #'mop-fn (list 1.0)))) (flet ((f (class) (multiple-value-list (clos:compute-applicable-methods-using-classes #'mop-fn (list (find-class class)))))) (and (equalp (f 'integer) (list nil nil)) (equalp (f 'number) (list nil nil)) (equalp (f 'symbol) (list nil nil)) (equalp (f 'float) (list m3 t)) (= (length m1) 1) (= (length m2) 1) (= (length m3) 1) t)))) t) ;;; Date: 24/04/2012 ;;; Description: ;;; ;;; COMPUTE-DISCRIMINATING-FUNCTION is invoked and honored by ECL. ;;; (deftest mop-discriminator (progn (fmakunbound 'foo) (defclass my-generic-function (standard-generic-function) ()) (defmethod clos:compute-discriminating-function ((gf my-generic-function)) ;; We compute the invocaions of c-d-f. Note that it is invoked ;; quite often -- we could probably optimize this. #'(lambda (&rest args) args)) (defgeneric foo (a) (:generic-function-class my-generic-function)) (unwind-protect (foo 2) (fmakunbound 'foo))) (2)) ;;; Date: 24/04/2012 ;;; Description: ;;; ;;; COMPUTE-DISCRIMINATING-FUNCTION is invoked on ADD-METHOD, REMOVE-METHOD, ;;; DEFGENERIC, INITIALIZE-INSTANCE and REINITIALIZE-INSTANCE acting on ;;; generic functions. ;;; (deftest mop-discriminator-recomputation (progn (defparameter *mop-discriminator-recomputation* 0) (fmakunbound 'foo) (defclass my-generic-function (standard-generic-function) ()) (defmethod clos:compute-discriminating-function ((gf my-generic-function)) ;; We compute the invocaions of c-d-f. Note that it is invoked ;; quite often -- we could probably optimize this. (incf *mop-discriminator-recomputation*) (call-next-method)) (and (progn (setf *mop-discriminator-recomputation* 0) (eval '(defgeneric foo (a) (:generic-function-class my-generic-function))) (plusp *mop-discriminator-recomputation* )) (typep #'foo 'my-generic-function) (progn (setf *mop-discriminator-recomputation* 0) (eval '(defmethod foo ((a number)) (print a))) (plusp *mop-discriminator-recomputation*)) (progn (setf *mop-discriminator-recomputation* 0) (eval '(remove-method #'foo (first (compute-applicable-methods #'foo (list 1.0))))) (plusp *mop-discriminator-recomputation*)) t)) t) ;;; Date: 24/04/2012 ;;; Description: ;;; ;;; Verify ECL calls COMPUTE-APPLICABLE-METHODS-USING-CLASSES for ;;; user-defined generic function classes. ;;; (deftest mop-compute-applicable-methods-using-classes-is-honored (progn (defparameter *mop-dispatch-used* 0) (fmakunbound 'foo) (defclass my-generic-function (standard-generic-function) ()) (defmethod clos:compute-applicable-methods-using-classes ((gf my-generic-function) classes) (incf *mop-dispatch-used*) (call-next-method)) (defgeneric foo (a) (:generic-function-class my-generic-function) (:method ((a number)) (cos 1.0))) (and (zerop *mop-dispatch-used*) (progn (foo 1.0) (plusp *mop-dispatch-used*)))) t) ;;; Date: 24/04/2012 ;;; Description: ;;; ;;; Verify ECL calls COMPUTE-APPLICABLE-METHODS for ;;; user-defined generic function classes. ;;; (deftest mop-compute-applicable-methods-is-honored (progn (defparameter *mop-dispatch-used* 0) (fmakunbound 'foo) (defclass my-generic-function (standard-generic-function) ()) (defmethod clos:compute-applicable-methods-using-classes ((gf my-generic-function) classes) (incf *mop-dispatch-used*) (values nil nil)) (defmethod compute-applicable-methods ((gf my-generic-function) args) (incf *mop-dispatch-used*) (call-next-method)) (defgeneric foo (a) (:generic-function-class my-generic-function) (:method ((a number)) (cos 1.0))) (and (zerop *mop-dispatch-used*) (progn (foo 1.0) (= *mop-dispatch-used* 2)))) t) ;;; From: Pascal Costanza ;;; Description: ;;; ;;; sort-applicable-methods is invoked by two methods and one ;;; invocation triggers a disambiguation error: ;;; ;;; Condition of type: SIMPLE-ERROR ;;; The type specifiers # and # can not be disambiguated with respect to the argument specializer: # (deftest mop-compute-applicable-methods-disambiguation.0001 (ext:with-clean-symbols (a b c f) (defclass a () ()) (defclass b () ()) (defclass c (a b) ()) (defmethod f ((o a))) (defmethod f ((o b))) (compute-applicable-methods-using-classes #'f (list (find-class 'c))) T) T) ecl-16.1.2/src/tests/regressions/tests/mixed.lsp000066400000000000000000000050541266352375300216500ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; Contains: Various regression tests for ECL (in-package :cl-test) ;;; (EXT:PACKAGE-LOCK) returned the wrong value. ;;; Fixed in 77a267c7e42860affac8eddfcddb8e81fccd44e5 (deftest mixed-0001-package-lock (progn ;; Don't know the first state (ext:package-lock "CL-USER" nil) (values (ext:package-lock "CL-USER" t) (ext:package-lock "CL-USER" nil) (ext:package-lock "CL-USER" nil))) nil t nil) ;; Bugs from sourceforge (deftest mixed.0002.mvb-not-evaled (assert (eq :ok (block nil (tagbody (return (multiple-value-bind () (go :fail) :bad)) :fail (return :ok))))) nil) (declaim (ftype (function (cons) t) mixed.0003.foo)) (declaim (ftype (function (t cons) t) (setf mixed.0003.foo))) (defun mixed.0003.foo (cons) (first cons)) (defun (setf mixed.0003.foo) (value cons) (setf (first cons) value)) (defvar mixed.0003.*c* (cons 'x 'y)) (deftest mixed.0003.declaim-type.1 (mixed.0003.foo mixed.0003.*c*) ;; correctly returns x x) ;; signals an error: ;; Z is not of type CONS. ;; [Condition of type TYPE-ERROR] (deftest mixed.0004.declaim-type.2 (assert (eq 'z (setf (mixed.0003.foo mixed.0003.*c*) 'z))) nil) (compile nil `(lambda (x) (1+ (the (values integer string) (funcall x))))) (deftest mixed.0005.style-warning-argument-order (let ((warning nil)) (assert (eq :ok (handler-bind ((style-warning (lambda (c) (format t "got style-warning: ~s~%" c) (setf warning c)))) (block nil (tagbody (return (multiple-value-bind () (go :fail) :bad)) :fail (return :ok)))))) (assert (not warning))) nil) (deftest mixed.0006.write-hash-readable (hash-table-count (read-from-string (write-to-string (make-hash-table) :readably t))) 0) (deftest mixed.0007.find-package.1 (assert (let ((string ":cl-user")) (find-package (let ((*package* (find-package :cl))) (read-from-string string))))) nil) (deftest mixed.0008.find-package.2 (assert (let ((string ":cl-user")) (let ((*package* (find-package :cl))) (find-package (read-from-string string))))) nil) ecl-16.1.2/src/tests/regressions/tests/multiprocessing.lsp000066400000000000000000000534061266352375300237750ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; Author: Juan Jose Garcia-Ripoll ;;;; Created: Fri Apr 14 11:13:17 CEST 2006 ;;;; Contains: Multithreading API regression tests (in-package :cl-test) ;; Auxiliary routines for multithreaded tests (defun kill-and-wait (process-list &optional original wait) "Kills a list of processes, which may be the difference between two lists, waiting for all processes to finish. Currently it has no timeout, meaning it may block hard the lisp image." (let ((process-list (set-difference process-list original))) (when (member mp:*current-process* process-list) (error "Found myself in the kill list")) (mapc #'mp:process-kill process-list) (when wait (loop for i in process-list do (mp:process-join i))) process-list)) (defun mp-test-run (closure) (let* ((all-processes (mp:all-processes)) (output (multiple-value-list (funcall closure)))) (sleep 0.2) ; time to exit some processes (let ((leftovers (kill-and-wait (mp:all-processes) all-processes))) (cond (leftovers (format t "~%;;; Stray processes: ~A" leftovers)) (t (values-list output)))))) (defmacro def-mp-test (name body expected-value) "Runs some test code and only returns the output when the code exited without creating stray processes." (let ((all-processes (gensym)) (output (gensym)) (leftover (gensym))) `(deftest ,name (mp-test-run #'(lambda () ,body)) ,expected-value))) ;; Locks ;;; Date: 04/09/2009 ;;; From: Matthew Mondor ;;; Fixed: 05/09/2009 (Juanjo) ;;; Description: ;;; ;;; When a WITH-LOCK is interrupted, it is not able to release ;;; the resulting lock and an error is signaled. ;;; (def-mp-test mp-0001-with-lock (let ((flag t) (lock (mp:make-lock :name "mp-0001-with-lock" :recursive nil))) (mp:with-lock (lock) (let ((background-process (mp:process-run-function "mp-0001-with-lock" #'(lambda () (handler-case (progn (setf flag 1) (mp:with-lock (lock) (setf flag 2))) (error (c) (princ c)(terpri) (setf flag c))) (setf flag 2))))) ;; The background process should not be able to get ;; the lock, and will simply wait. Now we interrupt it ;; and the process should gracefully quit, without ;; signalling any serious condition (and (progn (sleep 1) (mp:process-kill background-process)) (progn (sleep 1) (not (mp:process-active-p background-process))) (eq flag 1) t)))) t) ;; Semaphores ;;; Date: 14/04/2012 ;;; Ensure that at creation name and counter are set (deftest sem-make-and-counter (loop with name = "sem-make-and-counter" for count from 0 to 10 for sem = (mp:make-semaphore :name name :count count) always (and (eq (mp:semaphore-name sem) name) (= (mp:semaphore-count sem) count) (zerop (mp:semaphore-wait-count sem)))) t) ;;; Date: 14/04/2012 ;;; Ensure that signal changes the counter by the specified amount (deftest sem-signal-semaphore-count (loop with name = "sem-signal-semaphore-count" for count from 0 to 10 always (loop for delta from 0 to 10 for sem = (mp:make-semaphore :name name :count count) always (and (= (mp:semaphore-count sem) count) (null (mp:signal-semaphore sem delta)) (= (mp:semaphore-count sem ) (+ count delta))))) t) ;;; Date: 14/04/2012 ;;; A semaphore with a count of zero blocks a process (def-mp-test sem-signal-one-process (let* ((flag nil) (sem (mp:make-semaphore :name "sem-signal-one")) (a-process (mp:process-run-function "sem-signal-one-process" #'(lambda () (mp:wait-on-semaphore sem) (setf flag t))))) (and (null flag) (mp:process-active-p a-process) (progn (mp:signal-semaphore sem) (sleep 0.2) flag) (= (mp:semaphore-count sem) 0))) t) ;;; Date: 14/04/2012 ;;; We can signal multiple processes (def-mp-test sem-signal-n-processes (loop for count from 1 upto 10 always (let* ((counter 0) (lock (mp:make-lock :name "sem-signal-n-processes")) (sem (mp:make-semaphore :name "sem-signal-n-processs")) (all-process (loop for i from 1 upto count collect (mp:process-run-function "sem-signal-n-processes" #'(lambda () (mp:wait-on-semaphore sem) (mp:with-lock (lock) (incf counter))))))) (and (zerop counter) (every #'mp:process-active-p all-process) (= (mp:semaphore-wait-count sem) count) (progn (mp:signal-semaphore sem count) (sleep 0.2) (= counter count)) (= (mp:semaphore-count sem) 0)))) t) ;;; Date: 14/04/2012 ;;; When we signal N processes and N+M are waiting, only N awake (def-mp-test sem-signal-only-n-processes (loop for m from 1 upto 3 always (loop for n from 1 upto 4 always (let* ((counter 0) (lock (mp:make-lock :name "sem-signal-n-processes")) (sem (mp:make-semaphore :name "sem-signal-n-processs")) (all-process (loop for i from 1 upto (+ n m) collect (mp:process-run-function "sem-signal-n-processes" #'(lambda () (mp:wait-on-semaphore sem) (mp:with-lock (lock) (incf counter))))))) (and (zerop counter) (every #'mp:process-active-p all-process) (= (mp:semaphore-wait-count sem) (+ m n)) (progn (mp:signal-semaphore sem n) (sleep 0.02) (= counter n)) (= (mp:semaphore-wait-count sem) m) (progn (mp:signal-semaphore sem m) (sleep 0.02) (= counter (+ n m))) )))) t) ;;; Date: 14/04/2012 ;;; It is possible to kill processes waiting for a semaphore. ;;; (def-mp-test sem-interruptible (loop with sem = (mp:make-semaphore :name "sem-interruptible") with flag = nil for count from 1 to 10 for all-processes = (loop for i from 1 upto count collect (mp:process-run-function "sem-interruptible" #'(lambda () (mp:wait-on-semaphore sem) (setf flag t)))) always (and (progn (sleep 0.2) (null flag)) (every #'mp:process-active-p all-processes) (= (mp:semaphore-wait-count sem) count) (mapc #'mp:process-kill all-processes) (progn (sleep 0.2) (notany #'mp:process-active-p all-processes)) (null flag) (zerop (mp:semaphore-wait-count sem)) t)) t) ;;; Date: 14/04/2012 ;;; When we kill a process, it is removed from the wait queue. ;;; (def-mp-test sem-interrupt-updates-queue (let* ((sem (mp:make-semaphore :name "sem-interrupt-updates-queue")) (process (mp:process-run-function "sem-interrupt-updates-queue" #'(lambda () (mp:wait-on-semaphore sem))))) (sleep 0.2) (and (= (mp:semaphore-wait-count sem) 1) (mp:process-active-p process) (progn (mp:process-kill process) (sleep 0.2) (not (mp:process-active-p process))) (zerop (mp:semaphore-wait-count sem)) t)) t) ;;; Date: 14/04/2012 ;;; When we kill a process, it signals another one. This is tricky, ;;; because we need the awake signal to arrive _after_ the process is ;;; killed, but the process must still be in the queue for the semaphore ;;; to awake it. The way we solve this is by intercepting the kill signal. ;;; (def-mp-test sem-interrupted-resignals (let* ((sem (mp:make-semaphore :name "sem-interrupted-resignals")) (flag1 nil) (flag2 nil) (process1 (mp:process-run-function "sem-interrupted-resignals" #'(lambda () (unwind-protect (mp:wait-on-semaphore sem) (sleep 4) (setf flag1 t) )))) (process2 (mp:process-run-function "sem-interrupted-resignals" #'(lambda () (mp:wait-on-semaphore sem) (setf flag2 t))))) (sleep 0.2) (and (= (mp:semaphore-wait-count sem) 2) (mp:process-active-p process1) (mp:process-active-p process2) ;; We kill the process but ensure it is still running (progn (mp:process-kill process1) (mp:process-active-p process1)) (null flag1) ;; ... and in the queue (= (mp:semaphore-wait-count sem) 2) ;; We awake it and it should awake the other one (progn (format t "~%;;; Signaling semaphore") (mp:signal-semaphore sem) (sleep 1) (zerop (mp:semaphore-wait-count sem))) flag2 t)) t) ;;; Date: 14/04/2012 ;;; 1 producer and N consumers, non-blocking, because the initial count ;;; is larger than the consumed data. (def-mp-test sem-1-to-n-non-blocking (loop with counter = 0 with lock = (mp:make-lock :name "sem-1-to-n-communication") for n from 1 to 10 for m = (round 128 n) for length = (* n m) for sem = (mp:make-semaphore :name "sem-1-to-n-communication" :count length) for producers = (progn (setf counter 0) (loop for i from 0 below n collect (mp:process-run-function "sem-1-to-n-consumer" #'(lambda () (loop for i from 0 below m do (mp:wait-on-semaphore sem) do (mp:with-lock (lock) (incf counter))))))) do (mapc #'mp:process-join producers) always (and (= counter length) (zerop (mp:semaphore-count sem)) (zerop (mp:semaphore-wait-count sem)))) t) ;;; Date: 14/04/2012 ;;; 1 producer and N consumers, blocking due to a slow producer. (def-mp-test sem-1-to-n-blocking (loop with lock = (mp:make-lock :name "sem-1-to-n-communication") for n from 1 to 10 for m = (round 10000 n) for length = (* n m) for sem = (mp:make-semaphore :name "sem-1-to-n-communication" :count 0) for counter = 0 for producers = (loop for i from 0 below n collect (mp:process-run-function "sem-1-to-n-consumer" #'(lambda () (loop for i from 0 below m do (mp:wait-on-semaphore sem)) (mp:with-lock (lock) (incf counter))))) do (loop for i from 0 below length do (mp:signal-semaphore sem)) do (mapc #'mp:process-join producers) always (and (= counter n) (zerop (mp:semaphore-count sem)) (zerop (mp:semaphore-wait-count sem)))) t) ;; Mutexes ;;; Date: 12/04/2012 ;;; Non-recursive mutexes should signal an error when they ;;; cannot be relocked. (deftest mutex-001-recursive-error (let* ((mutex (mp:make-lock :name 'mutex-001-recursive-error))) (and (mp:get-lock mutex) (eq (mp:lock-owner mutex) mp:*current-process*) (handler-case (progn (mp:get-lock mutex) nil) (error (c) t)) (mp:giveup-lock mutex) (null (mp:lock-owner mutex)) (zerop (mp:lock-count mutex)) t)) t) ;;; Date: 12/04/2012 ;;; Recursive locks increase the counter. (deftest mutex-002-recursive-count (let* ((mutex (mp:make-lock :name 'mutex-002-recursive-count :recursive t))) (and (loop for i from 1 upto 10 always (and (mp:get-lock mutex) (= (mp:lock-count mutex) i) (eq (mp:lock-owner mutex) mp:*current-process*))) (loop for i from 9 downto 0 always (and (eq (mp:lock-owner mutex) mp:*current-process*) (mp:giveup-lock mutex) (= (mp:lock-count mutex) i))) (null (mp:lock-owner mutex)) (zerop (mp:lock-count mutex)) t)) t) ;;; Date: 12/04/2012 ;;; When multiple threads compete for a mutex, they should ;;; all get the same chance of accessing the resource ;;; (def-mp-test mutex-003-fairness (let* ((mutex (mp:make-lock :name 'mutex-001-fairness)) (nthreads 10) (count 10) (counter (* nthreads count)) (array (make-array count :element-type 'fixnum :initial-element 0))) (flet ((slave (n) (loop with continue = t for i from 1 by 1 while continue do (mp:get-lock mutex) (cond ((plusp counter) (decf counter) (setf (aref array n) i)) (t (setf continue nil))) (mp:giveup-lock mutex)))) ;; Launch all agents. They will be locked (let ((all-processes (mp:with-lock (mutex) (loop for n from 0 below nthreads collect (mp:process-run-function n #'slave n) ;; ... and give them some time to block on this mutex finally (sleep 1))))) ;; Now they are released and operate. They should all have ;; the same share of counts. (loop for p in all-processes do (mp:process-join p)) (loop for i from 0 below nthreads always (= (aref array i) count))))) t) ;;; Date: 12/04/2012 ;;; It is possible to kill processes waiting for a lock. We launch a lot of ;;; processes, 50% of which are zombies: they acquire the lock and do not ;;; do anything. These processes are then killed, resulting in the others ;;; doing their job. ;;; (def-mp-test mutex-004-interruptible (let* ((mutex (mp:make-lock :name "mutex-003-fairness")) (nprocesses 20) (counter 0)) (flet ((normal-thread () (mp:with-lock (mutex) (incf counter))) (zombie-thread () (mp:with-lock (mutex) (loop (sleep 10))))) (let* ((all-processes (loop for i from 0 below nprocesses for zombie = (zerop (mod i 2)) for fn = (if zombie #'zombie-thread #'normal-thread) collect (cons zombie (mp:process-run-function "mutex-003-fairness" fn)))) (zombies (mapcar #'cdr (remove-if-not #'car all-processes)))) (and (zerop counter) ; No proces works because the first one is a zombie (kill-and-wait zombies) (progn (sleep 0.2) (= counter (/ nprocesses 2))) (not (mp:lock-owner mutex)) t)))) t) ;; Mailbox ;;; Date: 14/04/2012 ;;; Ensure that at creation name and counter are set, and mailbox is empty. (deftest mailbox-make-and-counter (loop with name = "mbox-make-and-counter" for count from 4 to 63 for mbox = (mp:make-mailbox :name name :count count) always (and (eq (mp:mailbox-name mbox) name) (>= (mp:mailbox-count mbox) count) (mp:mailbox-empty-p mbox) t)) t) ;;; Date: 14/04/2012 ;;; Ensure that the mailbox works in a nonblocking fashion (when the ;;; number of messages < mailbox size in a single producer and single ;;; consumer setting. We do not need to create new threads for this. (deftest mbox-mailbox-nonblocking-io-1-to-1 (loop with count = 30 with name = "mbox-mailbox-nonblocking-io-1-to-1" with mbox = (mp:make-mailbox :name name :count count) for l from 1 to 10 for messages = (loop for i from 1 to l do (mp:mailbox-send mbox i) collect i) always (and (not (mp:mailbox-empty-p mbox)) (equalp (loop for i from 1 to l collect (mp:mailbox-read mbox)) messages) (mp:mailbox-empty-p mbox) t)) t) ;;; Date: 14/04/2012 ;;; The mailbox blocks a process when it saturates the write queue. (def-mp-test mbox-blocks-1-to-1 (let* ((flag nil) (mbox (mp:make-mailbox :name "mbox-signal-one" :count 32)) (size (mp:mailbox-count mbox)) (a-process (mp:process-run-function "mbox-signal-one-process" #'(lambda () ;; This does not block (loop for i from 1 to size do (mp:mailbox-send mbox i)) ;; Here we block (setf flag t) (mp:mailbox-send mbox (1+ size)) ;; Now we unblock (setf flag nil))))) (sleep 0.2) ; give time for all messages to arrive (and (not (mp:mailbox-empty-p mbox)) ; the queue has messages (mp:process-active-p a-process) ; the process is active flag ; and it is blocked (loop for i from 1 to (1+ size) ; messages arrive in order always (= i (mp:mailbox-read mbox))) (null flag) ; and process unblocked (mp:mailbox-empty-p mbox) t)) t) ;;; Date: 14/04/2012 ;;; N producers and 1 consumer (def-mp-test mbox-n-to-1-communication (loop with length = 10000 with mbox = (mp:make-mailbox :name "mbox-n-to-1-communication" :count 128) for n from 1 to 10 for m = (round length n) for messages = (loop for i from 0 below (* n m) collect i) for producers = (loop for i from 0 below n do (mp:process-run-function "mbox-n-to-1-producer" (let ((proc-no i)) #'(lambda () (loop for i from 0 below m for msg = (+ i (* proc-no m)) do (mp:mailbox-send mbox msg)))))) always (and (equalp (sort (loop for i from 1 to (* n m) collect (mp:mailbox-read mbox)) #'<) messages) (mp:mailbox-empty-p mbox))) t) ;;; Date: 14/04/2012 ;;; 1 producer and N consumer, but they do not block, because the ;;; queue is large enough and pre-filled with messages (def-mp-test mbox-1-to-n-non-blocking (loop with lock = (mp:make-lock :name "mbox-1-to-n-communication") for n from 1 to 10 for m = (round 128 n) for length = (* n m) for mbox = (mp:make-mailbox :name "mbox-1-to-n-communication" :count length) for flags = (make-array length :initial-element nil) for aux = (loop for i from 0 below length do (mp:mailbox-send mbox i)) for producers = (loop for i from 0 below n do (mp:process-run-function "mbox-1-to-n-consumer" #'(lambda () (loop for i from 0 below m for msg = (mp:mailbox-read mbox) do (setf (aref flags msg) t))))) do (sleep 0.1) always (and (every #'identity flags) (mp:mailbox-empty-p mbox))) t) ;;; Date: 14/04/2012 ;;; 1 producer and N consumers, which block, because the producer ;;; is started _after_ them and is slower. (def-mp-test mbox-1-to-n-blocking (loop for n from 1 to 10 for m = (round 10000 n) for length = (* n m) for mbox = (mp:make-mailbox :name "mbox-1-to-n-communication" :count length) for flags = (make-array length :initial-element nil) for producers = (loop for i from 0 below n do (mp:process-run-function "mbox-1-to-n-consumer" #'(lambda () (loop for i from 0 below m for msg = (mp:mailbox-read mbox) do (setf (aref flags msg) t))))) do (loop for i from 0 below length do (mp:mailbox-send mbox i)) do (sleep 0.1) always (and (every #'identity flags) (mp:mailbox-empty-p mbox))) t) ecl-16.1.2/src/tests/regressions/tests/random-states.lsp000066400000000000000000000026431266352375300233240ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; Author: Daniel KochmaХ„ski ;;;; Created: 2015-09-21 ;;;; Contains: Random state tests (in-package :cl-test) ;; Trivial case (deftest random-states.0001 (numberp (random 18)) T) ;; Check if we can generate random number from a read random state (deftest random-states.0002 (numberp (random 18 #$1)) T) ;; Check if we can generate random number from a new random state (deftest random-states.0003 (numberp (random 18 (make-random-state))) T) ;; Check if we can copy use copied random state from reader (deftest random-states.0004 (numberp (random 18 (make-random-state #$1))) T) ;; Check if the same seed produces the same result (deftest random-states.0005 (= (random 18 #$1) (random 18 #$1) (random 18 #$1)) T) ;; Check if we get the same table from the same seed (deftest random-states.0005 (let ((*print-readably* t) (rs (make-random-state #$1))) (equalp (format nil "~S" #$1) (format nil "~S" rs))) T) ;; Check if we can read back the random state (deftest random-states.0006 (let* ((*print-readably* t) (rs (make-random-state #$1)) (rs-read (read-from-string (format nil "~S" rs)))) (equalp (format nil "~S" rs-read) (format nil "~S" rs))) T) ecl-16.1.2/src/tests/regressions/tests/test-ansi.lsp000066400000000000000000000074731266352375300224600ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: (in-package :cl-test) ;;;;;;;;;;;;;;;;;;;;;;;;; ;; 2.* Readtable tests ;; ;;;;;;;;;;;;;;;;;;;;;;;;; (symbol-macrolet ((lookup-table '(:SYMBOL ("zebra" "Zebra" "ZEBRA" "zebr\\a" "zebr\\A" "ZEBR\\a""ZEBR\\A" "Zebr\\a" "Zebr\\A") :UPCASE (|ZEBRA| |ZEBRA| |ZEBRA| |ZEBRa| |ZEBRA| |ZEBRa| |ZEBRA| |ZEBRa| |ZEBRA|) :DOWNCASE (|zebra| |zebra| |zebra| |zebra| |zebrA| |zebra| |zebrA| |zebra| |zebrA|) :PRESERVE (|zebra| |Zebra| |ZEBRA| |zebra| |zebrA| |ZEBRa| |ZEBRA| |Zebra| |ZebrA|) :INVERT (|ZEBRA| |Zebra| |zebra| |ZEBRa| |ZEBRA| |zebra| |zebrA| |Zebra| |ZebrA|)))) (macrolet ((def-readtable-case-test (reader-case) `(deftest ,(concatenate 'string "TEST-ANSI.READTABLE.CASE-" (symbol-name reader-case)) (let ((*readtable* (copy-readtable))) (setf (readtable-case *readtable*) ,reader-case) (mapcar #'(lambda (x) (read-from-string x)) ',(getf lookup-table :symbol))) ,(getf lookup-table reader-case)))) (def-readtable-case-test :upcase) (def-readtable-case-test :downcase) (def-readtable-case-test :preserve) (def-readtable-case-test :invert))) ;; when readtable was :invert characters got inverted too (deftest test-ansi.readtable.invert-char (let ((*readtable* (copy-readtable))) (setf (readtable-case *readtable*) :invert) (read-from-string "#\\a")) #\a 3) ;; HyperSpec т€“ 3.* ;;;;;;;;;;;;;;;;;;; ;; Deftype tests ;; ;;;;;;;;;;;;;;;;;;; (deftest test-ansi.deftype.ordinary.1 (progn (deftype ordinary1 () `(member nil t)) (values (typep T 'ordinary1) (typep :a 'ordinary1))) T NIL) (deftest test-ansi.deftype.ordinary.2 (progn (deftype ordinary2 (a b) (if a 'CONS `(INTEGER 0 ,b))) (values (typep T '(ordinary2 nil 3)) (typep 3 '(ordinary2 nil 4)) (typep T '(ordinary2 T nil)) (typep '(1 . 2) '(ordinary2 T nil)))) nil t nil t) (deftest test-ansi.deftype.optional (progn (deftype optional (a &optional b) (if a 'CONS `(INTEGER 0 ,b))) (values (typep 5 '(optional nil)) (typep 5 '(optional nil 4)))) t nil) (deftest test-ansi.deftype.nested (progn (deftype nested ((a &optional b) c . d) (assert (listp d)) `(member ,a ,b ,c)) (values (typep 1 '(nested (1 2) 3 4 5 6)) (typep 1 '(nested (2 2) 3 4 5 6)) (typep '* '(nested (3) 3)) (typep 3 '(nested (2) 3)))) t nil t t) ;;;;;;;;;;;;;;;;;;;;;;;;; ;; 19.* Pathname tests ;; ;;;;;;;;;;;;;;;;;;;;;;;;; ;; Issue #103 ;; logical-pathname-translations not translating ;; https://gitlab.com/embeddable-common-lisp/ecl/issues/103 (deftest* test-ansi.pathname.wildcards.1 (namestring (progn (setf (logical-pathname-translations "prog") '(("CODE;*.*.*" "/tmp/prog/"))) (translate-logical-pathname "prog:code;documentation.lisp"))) (list (namestring #P"/tmp/prog/documentation.lisp"))) ;;;;;;;;;;;;;;;;;;;;;;; ;; 23.* Reader tests ;; ;;;;;;;;;;;;;;;;;;;;;;; (defstruct sharp-s-reader.1.example-struct a) (deftest test-ansi.reader.sharp-s-reader.1 (prog1 (signals-error (read-from-string "(#1=\"Hello\" #S(sharp-s-reader.1.example-struct :A #1#))") program-error)) nil) ecl-16.1.2/src/tests/regressions/tools.lsp000066400000000000000000000033571266352375300205440ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; Author: Juan Jose Garcia-Ripoll ;;;; Created: Fri Apr 14 11:13:17 CEST 2006 ;;;; Contains: Tools for doing tests, intercepting functions, etc. (defmacro with-dflet (functions &body body) "Syntax: (with-dflet ((fname form*)*) body) Evaluate BODY in an environment in which the function FNAME has been redefined to evaluate the given forms _before_ executing the orginal code." (let ((vars '()) (in-forms '()) (out-forms '())) (loop for (name . forms) in functions do (let ((var (gensym))) (push `(,var #',name) vars) (push `(setf (fdefinition ',name) #'(lambda (&rest args) ,@forms (apply ,var args))) in-forms) (push `(setf (fdefinition ',name) ,var) out-forms))) `(let ,vars (unwind-protect (progn ,@in-forms ,@body) (progn ,@out-forms))))) (defmacro with-compiler ((filename &rest compiler-args) &body forms) "Create a lisp file with the given forms and compile it. The forms are evaluated. The output is stored in a string and output as a second value." `(progn (with-open-file (s ,filename :direction :output :if-exists :supersede :if-does-not-exist :create) ,@(loop for f in forms collect `(print ,f s))) (let* ((ok t) (output (with-output-to-string (*standard-output*) (let ((*error-output* *standard-output*) (*compile-verbose* t) (*compile-print* t)) (setf ok (compile-file ,filename ,@compiler-args)))))) (values ok output)))) ecl-16.1.2/src/tests/regressions/universe.lsp000066400000000000000000000415521266352375300212430ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;;; Author: Paul Dietz ;;;; Created: Thu Apr 9 19:32:56 1998 ;;;; Contains: A global variable containing a list of ;;;; as many kinds of CL objects as we can think of ;;;; This list is used to test many other CL functions (in-package :cl-test) (defparameter *condition-types* '(arithmetic-error cell-error condition control-error division-by-zero end-of-file error file-error floating-point-inexact floating-point-invalid-operation floating-point-underflow floating-point-overflow package-error parse-error print-not-readable program-error reader-error serious-condition simple-condition simple-error simple-type-error simple-warning storage-condition stream-error style-warning type-error unbound-slot unbound-variable undefined-function warning)) (defparameter *condition-objects* (locally (declare (optimize safety)) (loop for tp in *condition-types* append (handler-case (list (make-condition tp)) (error () nil))))) (defparameter *standard-package-names* '("COMMON-LISP" "COMMON-LISP-USER" "KEYWORD")) (defparameter *package-objects* (locally (declare (optimize safety)) (loop for pname in *standard-package-names* append (handler-case (let ((pkg (find-package pname))) (and pkg (list pkg))) (error () nil))))) (defparameter *integers* (remove-duplicates `( 0 ;; Integers near the fixnum/bignum boundaries ,@(loop for i from -5 to 5 collect (+ i most-positive-fixnum)) ,@(loop for i from -5 to 5 collect (+ i most-negative-fixnum)) ;; Powers of two, negatives, and off by one. ,@(loop for i from 1 to 64 collect (ash 1 i)) ,@(loop for i from 1 to 64 collect (1- (ash 1 i))) ,@(loop for i from 1 to 64 collect (ash -1 i)) ,@(loop for i from 1 to 64 collect (1+ (ash -1 i))) ;; A big integer ,(expt 17 50) ;; Some arbitrarily chosen integers 12387131 1272314 231 -131 -561823 23713 -1234611312123 444121 991))) (defparameter *floats* (append (loop for sym in '(pi most-positive-short-float least-positive-short-float least-positive-normalized-short-float most-positive-double-float least-positive-double-float least-positive-normalized-double-float most-positive-long-float least-positive-long-float least-positive-normalized-long-float most-positive-single-float least-positive-single-float least-positive-normalized-single-float most-negative-short-float least-negative-short-float least-negative-normalized-short-float most-negative-single-float least-negative-single-float least-negative-normalized-single-float most-negative-double-float least-negative-double-float least-negative-normalized-double-float most-negative-long-float least-negative-long-float least-negative-normalized-long-float short-float-epsilon short-float-negative-epsilon single-float-epsilon single-float-negative-epsilon double-float-epsilon double-float-negative-epsilon long-float-epsilon long-float-negative-epsilon) when (boundp sym) collect (symbol-value sym)) (list 0.0 1.0 -1.0 313123.13 283143.231 -314781.9 1.31283d2 834.13812D-45 8131238.1E14 -4618926.231e-2 -37818.131F3 81.318231f-19 1.31273s3 12361.12S-7 6124.124l0 13123.1L-23))) (defparameter *ratios* '(1/3 1/1000 1/1000000000000000 -10/3 -1000/7 -987129387912381/13612986912361 189729874978126783786123/1234678123487612347896123467851234671234)) (defparameter *complexes* '(#C(0.0 0.0) #C(1.0 0.0) #C(0.0 1.0) #C(1.0 1.0) #C(-1.0 -1.0) #C(1289713.12312 -9.12681271) #C(1.0D100 1.0D100) #C(-1.0D-100 -1.0D-100) #C(10.0s0 20.0s0) #C(100.0l0 200.0l0) #C(1.0s0 2.0f0) #C(1.0s0 3.0d0) #C(1.0s0 4.0l0) #C(1.0f0 5.0d0) #C(1.0f0 6.0l0) #C(1.0d0 7.0l0) #C(1.0f0 2.0s0) #C(1.0d0 3.0s0) #C(1.0l0 4.0s0) #C(1.0d0 5.0f0) #C(1.0l0 6.0f0) #C(1.0l0 7.0d0) #C(1/2 1/3) )) (defparameter *numbers* (append *integers* *floats* *ratios* *complexes*)) (defparameter *reals* (append *integers* *floats* *ratios*)) (defparameter *rationals* (append *integers* *ratios*)) (defun try-to-read-chars (&rest namelist) (declare (optimize safety)) (loop for name in namelist append (handler-case (list (read-from-string (concatenate 'string "\#\\" name))) (error () nil)))) (defparameter *characters* (remove-duplicates `(#\Newline #\Space ,@(try-to-read-chars "Rubout" "Page" "Tab" "Backspace" "Return" "Linefeed" "Null") #\a #\A #\0 #\9 #\. #\( #\) #\[ #\] ))) (defparameter *strings* (append (and (code-char 0) (list (make-string 1 :initial-element (code-char 0)) (make-string 10 :initial-element (code-char 0)))) (list "" "A" "a" "0" "abcdef" "~!@#$%^&*()_+`1234567890-=<,>.?/:;\"'{[}]|\\ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWYXZ" (make-string 100000 :initial-element #\g) (let ((s (make-string 256))) (loop for i from 0 to 255 do (let ((c (code-char i))) (when c (setf (elt s i) c)))) s) ;; Specialized strings (make-array 3 :element-type 'character :displaced-to (make-array 5 :element-type 'character :initial-contents "abcde") :displaced-index-offset 1) (make-array 10 :initial-element #\x :fill-pointer 5 :element-type 'character) (make-array 10 :initial-element #\x :element-type 'base-char) (make-array 3 :initial-element #\y :adjustable t :element-type 'base-char) ))) (defparameter *conses* (list (list 'a 'b) (list nil) (list 1 2 3 4 5 6))) (defparameter *circular-conses* (list (let ((s (copy-list '(a b c d)))) (nconc s s) s) (let ((s (list nil))) (setf (car s) s) s) (let ((s (list nil))) (setf (car s) s) (setf (cdr s) s)))) (defparameter *booleans* '(nil t)) (defparameter *keywords* '(:a :b :|| :|a| :|1234|)) (defparameter *uninterned-symbols* (list '#:nil '#:t '#:foo '#:||)) (defparameter *cl-test-symbols* `(,(intern "a" :cl-test) ,(intern "" :cl-test) ,@(and (code-char 0) (list (intern (make-string 1 :initial-element (code-char 0)) :cl-test))) ,@(and (code-char 0) (let* ((s (make-string 10 :initial-element (code-char 0))) (s2 (copy-seq s)) (s3 (copy-seq s))) (setf (subseq s 3 4) "a") (setf (subseq s2 4 5) "a") (setf (subseq s3 4 5) "a") (setf (subseq s3 7 8) "b") (list (intern s :cl-test) (intern s2 :cl-test) (intern s3 :cl-test)))) )) (defparameter *cl-user-symbols* '(cl-user::foo cl-user::x cl-user::cons cl-user::lambda cl-user::*print-readably* cl-user::push)) (defparameter *symbols* (append *booleans* *keywords* *uninterned-symbols* *cl-test-symbols* *cl-user-symbols*)) (defparameter *array-dimensions* (loop for i from 0 to 8 collect (loop for j from 1 to i collect 2))) (defparameter *default-array-target* (make-array '(300))) (defparameter *arrays* (append (list (make-array '10)) (mapcar #'make-array *array-dimensions*) ;; typed arrays (loop for tp in '(fixnum float bit character base-char (signed-byte 8) (unsigned-byte 8)) for element in '(18 16.0f0 0 #\x #\y 127 200) append (loop for d in *array-dimensions* collect (make-array d :element-type tp :initial-element element))) ;; More typed arrays (loop for i from 1 to 64 append (list (make-array 10 :element-type `(unsigned-byte ,i) :initial-element 1) (make-array 10 :element-type `(signed-byte ,i) :initial-element 0))) ;; adjustable arrays (loop for d in *array-dimensions* collect (make-array d :adjustable t)) ;; Displaced arrays (loop for d in *array-dimensions* for i from 1 collect (make-array d :displaced-to *default-array-target* :displaced-index-offset i)) (list #() #* #*00000 #*1010101010101101 (make-array 10 :element-type 'bit :initial-contents '(0 1 1 0 1 1 1 1 0 1) :fill-pointer 8) (make-array 5 :element-type 'bit :displaced-to #*0111000110 :displaced-index-offset 3) (make-array 10 :element-type 'bit :initial-contents '(1 1 0 0 1 1 1 0 1 1) :adjustable t) ) ;; Integer arrays (list (make-array '(10) :element-type '(integer 0 (256)) :initial-contents '(8 9 10 11 12 1 2 3 4 5)) (make-array '(10) :element-type '(integer -128 (128)) :initial-contents '(8 9 -10 11 -12 1 -2 -3 4 5)) (make-array '(6) :element-type '(integer 0 (#.(ash 1 16))) :initial-contents '(5 9 100 1312 23432 87)) (make-array '(4) :element-type '(integer 0 (#.(ash 1 28))) :initial-contents '(100000 231213 8123712 19)) (make-array '(4) :element-type '(integer 0 (#.(ash 1 32))) :initial-contents '(#.(1- (ash 1 32)) 0 872312 10000000)) (make-array nil :element-type '(integer 0 (256)) :initial-element 14) (make-array '(2 2) :element-type '(integer 0 (256)) :initial-contents '((34 98)(14 119))) ) ;; Float arrays (list (make-array '(5) :element-type 'short-float :initial-contents '(1.0s0 2.0s0 3.0s0 4.0s0 5.0s0)) (make-array '(5) :element-type 'single-float :initial-contents '(1.0f0 2.0f0 3.0f0 4.0f0 5.0f0)) (make-array '(5) :element-type 'double-float :initial-contents '(1.0d0 2.0d0 3.0d0 4.0d0 5.0d0)) (make-array '(5) :element-type 'long-float :initial-contents '(1.0l0 2.0l0 3.0l0 4.0l0 5.0l0)) ) ;; The ever-popular NIL array (locally (declare (optimize safety)) (handler-case (list (make-array '(0) :element-type nil)) (error () nil))) ;; more kinds of arrays here later? )) (defparameter *hash-tables* (list (make-hash-table) (make-hash-table :test #'eq) (make-hash-table :test #'eql) (make-hash-table :test #'equal) #-(or CMU ECL) (make-hash-table :test #'equalp) )) (defparameter *pathnames* (locally (declare (optimize safety)) (loop for form in '((make-pathname :name "foo") (make-pathname :name "FOO" :case :common) (make-pathname :name "bar") (make-pathname :name "foo" :type "txt") (make-pathname :name "bar" :type "txt") (make-pathname :name "XYZ" :type "TXT" :case :common) (make-pathname :name nil) (make-pathname :name :wild) (make-pathname :name nil :type "txt") (make-pathname :name :wild :type "txt") (make-pathname :name :wild :type "TXT" :case :common) (make-pathname :name :wild :type "abc" :case :common) (make-pathname :directory :wild) (make-pathname :type :wild) (make-pathname :version :wild) (make-pathname :version :newest)) append (ignore-errors (eval `(list ,form)))))) (eval-when (:compile-toplevel :load-toplevel :execute) (locally (declare (optimize safety)) (ignore-errors (setf (logical-pathname-translations "CLTESTROOT") `(("**;*.*.*" ,(make-pathname :directory '(:absolute :wild-inferiors) :name :wild :type :wild))))) (ignore-errors (setf (logical-pathname-translations "CLTEST") `(("**;*.*.*" ,(make-pathname :directory (append (pathname-directory (truename (make-pathname))) '(:wild-inferiors)) :name :wild :type :wild))))) )) (defparameter *logical-pathnames* (locally (declare (optimize safety)) (append (ignore-errors (list (logical-pathname "CLTESTROOT:"))) ))) (defparameter *streams* (remove-duplicates (remove-if #'null (list *debug-io* *error-output* *query-io* *standard-input* *standard-output* *terminal-io* *trace-output*)))) (defparameter *readtables* (list *readtable* (copy-readtable))) (defstruct foo-structure x y z) (defstruct bar-structure x y z) (defparameter *structures* (list (make-foo-structure :x 1 :y 'a :z nil) (make-foo-structure :x 1 :y 'a :z nil) (make-bar-structure :x 1 :y 'a :z nil) )) (defun meaningless-user-function-for-universe (x y z) (list (+ x 1) (+ y 2) (+ z 3))) (defgeneric meaningless-user-generic-function-for-universe (x y z) #+(or (not :gcl) :ansi-cl) (:method ((x integer) (y integer) (z integer)) (+ x y z))) (eval-when (:load-toplevel :execute) (compile 'meaningless-user-function-for-universe) ;; Conditionalize to avoid a cmucl bug #-(or cmu gcl ecl) (compile 'meaningless-user-generic-function-for-universe) ) (defparameter *functions* (list #'cons #'car #'append #'values (macro-function 'cond) #'meaningless-user-function-for-universe #'meaningless-user-generic-function-for-universe #'(lambda (x) x) (compile nil '(lambda (x) x)))) (defparameter *methods* (list #+(or (not :gcl) :ansi-cl ) (find-method #'meaningless-user-generic-function-for-universe nil (mapcar #'find-class '(integer integer integer))) ;; Add more methods here )) (defparameter *random-states* (list (make-random-state))) (defparameter *universe* (remove-duplicates (append *symbols* *numbers* *characters* (mapcar #'copy-seq *strings*) *conses* *condition-objects* *package-objects* *arrays* *hash-tables* *pathnames* *logical-pathnames* *streams* *readtables* *structures* *functions* *random-states* *methods* nil))) (defparameter *mini-universe* (remove-duplicates (append (mapcar #'first (list *symbols* *numbers* *characters* (list (copy-seq (first *strings*))) *conses* *condition-objects* *package-objects* *arrays* *hash-tables* *pathnames* *logical-pathnames* *streams* *readtables* *structures* *functions* *random-states* *methods*)) '(;;; Others to fill in gaps 1.2s0 1.3f0 1.5d0 1.8l0 3/5 10000000000000000000000)))) (defparameter *classes* (remove-duplicates (mapcar #'class-of *universe*))) (defparameter *built-in-classes* (remove-if-not #'(lambda (x) (typep x 'built-in-class)) *classes*)) ecl-16.1.2/src/tests/stress/000077500000000000000000000000001266352375300156345ustar00rootroot00000000000000ecl-16.1.2/src/tests/stress/tests/000077500000000000000000000000001266352375300167765ustar00rootroot00000000000000ecl-16.1.2/src/tests/stress/tests/multiprocessing.lsp000066400000000000000000000113201266352375300227420ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;; Author: Daniel KochmaХ„ski ;; Contains: Multiprocessing stress tests ;; Submitted by James M. Lawrence ;; ;; Notes: couldn't reproduce on 64-bit machine, but author uses 32-bit ;; This test uses infinite loop, this should be fixed. (defun test (message-count worker-count) (let ((to-workers (mp:make-semaphore)) (from-workers (mp:make-semaphore))) (loop repeat worker-count do (mp:process-run-function "test" (lambda () (loop (mp:wait-on-semaphore to-workers) (mp:signal-semaphore from-workers))))) (loop (loop repeat message-count do (mp:signal-semaphore to-workers)) (loop repeat message-count do (mp:wait-on-semaphore from-workers)) (assert (zerop (mp:semaphore-count to-workers))) (assert (zerop (mp:semaphore-count from-workers))) (format t ".") (finish-output)))) (defun run () (test 10000 64)) (run) ;; Submitted by James M. Lawrence ;; ;; Notes: couldn't reproduce on 64-bit machine, but author uses 32-bit ;; This test uses infinite loop, this should be fixed. (defstruct sema (count 0) (lock (mp:make-lock :recursive nil)) (cvar (mp:make-condition-variable))) (defun inc-sema (sema) (mp:with-lock ((sema-lock sema)) (incf (sema-count sema)) (mp:condition-variable-signal (sema-cvar sema)))) (defun dec-sema (sema) (mp:with-lock ((sema-lock sema)) (loop (cond ((plusp (sema-count sema)) (decf (sema-count sema)) (return)) (t (mp:condition-variable-wait (sema-cvar sema) (sema-lock sema))))))) (defun test (message-count worker-count) (let ((to-workers (make-sema)) (from-workers (make-sema))) (loop repeat worker-count do (mp:process-run-function "test" (lambda () (loop (dec-sema to-workers) (inc-sema from-workers))))) (loop (loop repeat message-count do (inc-sema to-workers)) (loop repeat message-count do (dec-sema from-workers)) (assert (zerop (sema-count to-workers))) (assert (zerop (sema-count from-workers))) (format t ".") (finish-output)))) (defun run () (test 10000 64)) (run) ;; Submitted by James M. Lawrence ;; ;; Notes: couldn't reproduce on 64-bit machine, but author uses 32-bit ;; This test uses infinite loop, this should be fixed. (defstruct (raw-queue (:conc-name nil)) (head nil) (tail nil)) (defun push-raw-queue (value queue) (let ((new (cons value nil))) (if (head queue) (setf (cdr (tail queue)) new) (setf (head queue) new)) (setf (tail queue) new))) (defun pop-raw-queue (queue) (let ((node (head queue))) (if node (multiple-value-prog1 (values (car node) t) (when (null (setf (head queue) (cdr node))) (setf (tail queue) nil)) (setf (car node) nil (cdr node) nil)) (values nil nil)))) ;;;; queue (defstruct queue (impl (make-raw-queue)) (lock (mp:make-lock)) (cvar (mp:make-condition-variable))) (defun push-queue (object queue) (mp:with-lock ((queue-lock queue)) (push-raw-queue object (queue-impl queue)) (mp:condition-variable-signal (queue-cvar queue)))) (defun pop-queue (queue) (mp:with-lock ((queue-lock queue)) (loop (multiple-value-bind (value presentp) (pop-raw-queue (queue-impl queue)) (if presentp (return value) (mp:condition-variable-wait (queue-cvar queue) (queue-lock queue))))))) ;;;; qtest (defun qtest (message-count worker-count) (loop (let ((to-workers (make-queue)) (from-workers (make-queue))) (loop repeat worker-count do (mp:process-run-function "test" (lambda () (loop (let ((message (pop-queue to-workers))) (push-queue message from-workers) (unless message (return))))))) (loop repeat message-count do (push-queue t to-workers)) (loop repeat message-count do (pop-queue from-workers)) (loop repeat worker-count do (push-queue nil to-workers)) (loop repeat worker-count do (pop-queue from-workers)) (format t ".") (finish-output)))) (qtest 0 64) ; => segfault (qtest 1 64) ; => hang (qtest 10000 64) ; => error "Attempted to recursively lock..." ecl-16.1.2/src/util/000077500000000000000000000000001266352375300141245ustar00rootroot00000000000000ecl-16.1.2/src/util/Makefile.in000066400000000000000000000013711266352375300161730ustar00rootroot00000000000000# -*- Mode: Makefile; indent-tabs-mode: nil -*- # vim: set filetype=makefile tabstop=8 shiftwidth=4 expandtab: # File: util/Makefile top_srcdir= @top_srcdir@ srcdir = @srcdir@ VPATH = @srcdir@ MACHINE = @MACHINE_VERSION@ # Programs used by "make": # CC = @CC@ DEFS = @DEFS@ CFLAGS = @cflags@ @oflag@ CLIBS = @clibs@ SHELL = /bin/sh RM = @RM@ # Source Directories HDIR = @HDIR@ #ifdef MSDOS UTILS = dpp.exe rsym.exe #else UTILS = dpp rsym #endif all: $(UTILS) dpp : ${HDIR}/machines.h dpp.c ${CC} ${CFLAGS} -I${HDIR} -o dpp $(srcdir)/dpp.c rsym : rsym.c ${HDIR}/machines.h ${CC} ${CFLAGS} -I${HDIR} -o rsym $(srcdir)/rsym.c dpp.exe : dpp coff2exe dpp ${RM} dpp rsym.exe: rsym coff2exe rsym ${RM} rsym clean : ${RM} ${UTILS} core a.out *.o ecl-16.1.2/src/util/android.cross_config000066400000000000000000000006501266352375300201450ustar00rootroot00000000000000CL_FIXNUM_TYPE=int CL_FIXNUM_BITS=32 CL_FIXNUM_MAX=536870911L CL_FIXNUM_MIN=-536870912L CL_INT_BITS=32 CL_LONG_BITS=32 ECL_STACK_DIR=down ECL_BIGENDIAN=no ECL_NEWLINE=LF ECL_FILE_CNT=2 ECL_STDINT_HEADER="#include " ECL_UINT8_T=uint8_t ECL_UINT16_T=uint16_t ECL_UINT32_T=uint32_t ECL_UINT64_T=no ECL_INT8_T=int8_t ECL_INT16_T=int16_t ECL_INT32_T=int32_t ECL_INT64_T=no ECL_LONG_LONG_BITS=no ECL_WORKING_ENVIRON=yes ecl-16.1.2/src/util/changes.el000066400000000000000000000124411266352375300160600ustar00rootroot00000000000000(replace-in-files '(("s.s_dbind" . "symbol.dbind") ("s.s_sfdef" . "symbol.sfdef") ("s.s_gfdef" . "symbol.gfdef") ("s.s_self" . "symbol.self") ("s.s_fillp" . "symbol.fillp") ("s.s_plist" . "symbol.plist") ("s.s_hpack" . "symbol.hpack") ("s.s_stype" . "symbol.stype") ("s.s_mflag" . "symbol.mflag")) ecl-files) (replace-in-files '(("st.st_adjustable" . "string.adjustable") ("st.st_hasfillp" . "string.hasfillp") ("st.st_displaced" . "string.displaced") ("st.st_dim" . "string.dim") ("st.st_fillp" . "string.fillp") ("st.st_self" . "string.self")) ecl-files) (replace-in-files '(("ust.ust_adjustable" . "string.adjustable") ("ust.ust_hasfillp" . "string.hasfillp") ("ust.ust_displaced" . "string.displaced") ("ust.ust_dim" . "string.dim") ("ust.ust_fillp" . "string.fillp") ("ust.ust_self" . "string.self")) ecl-files) (replace-in-files '(("p.p_name" . "pack.name") ("p.p_nicknames" . "pack.nicknames") ("p.p_shadowings" . "pack.shadowings") ("p.p_uselist" . "pack.uses") ("p.p_usedbylist" . "pack.usedby") ("p.p_internal" . "pack.internal") ("p.p_external" . "pack.external") ("p.p_link" . "pack.link") ("p.p_locked" . "pack.locked") ("c.c_car" . "cons.car") ("c.c_cdr" . "cons.cdr")) ecl-files) (replace-in-files '(("a.a_self" . "array.self.t") ("a.a_displaced" . "array.displaced") ("a.a_adjustable" . "array.adjustable") ("a.a_rank" . "array.rank") ("a.a_dim" . "array.dim") ("a.a_dims" . "array.dims") ("a.a_elttype" . "array.elttype") ("v.v_self" . "vector.self.t") ("v.v_displaced" . "vector.displaced") ("v.v_adjustable" . "vector.adjustable") ("v.v_hasfillp" . "vector.hasfillp") ("v.v_dim" . "vector.dim") ("v.v_fillp" . "vector.fillp") ("v.v_elttype" . "vector.elttype") ("lfa.lfa_self" . "array.self.lf") ("lfa.lfa_" . "array.") ("sfa.sfa_self" . "array.self.sf") ("sfa.sfa_" . "array.") ("fixa.fixa_self" . "array.self.fix") ("fixa.fixa_" . "array.") ("bv.bv_self" . "vector.self.bit") ("bv.bv_" . "vector.")) ecl-files) (replace-in-files '(("sm.sm_mode" . "stream.mode") ("sm.sm_fp" . "stream.file") ("sm.sm_buffer" . "stream.buffer") ("sm.sm_object0" . "stream.object0") ("sm.sm_object1" . "stream.object1") ("sm.sm_int0" . "stream.int0") ("sm.sm_int1" . "stream.int1")) ecl-files) (replace-in-files '(("rat.rat_den" . "ratio.den") ("rat.rat_num" . "ratio.num") ("cmp.cmp_imag" . "complex.imag") ("cmp.cmp_real" . "complex.real") ("rnd.rnd_value" . "random.value")) ecl-files) (replace-in-files '(("pn.pn_host" . "pathname.host") ("pn.pn_device" . "pathname.device") ("pn.pn_directory". "pathname.directory") ("pn.pn_name" . "pathname.name") ("pn.pn_type" . "pathname.type") ("pn.pn_version" . "pathname.version") ("pn.pn_logical" . "pathname.logical")) ecl-files) (replace-in-files '(("ht.ht_test" . "hash.test") ("ht.ht_self" . "hash.data") ("ht.ht_rhsize" . "hash.rehash_size") ("ht.ht_rhthresh" . "hash.threshold") ("ht.ht_nent" . "hash.entries") ("ht.ht_size" . "hash.size")) ecl-files) (replace-in-files '(("hte_key" . "key") ("hte_value" . "value") ("struct htent" . "struct hashtable_entry")) ecl-files) (replace-in-files '(("hash.thresholdh" . "hash.threshold")) ecl-files) (replace-in-files '(("rt.rt_self" . "readtable.table") ("struct rtent" . "struct readtable_entry") ("rte_macro" . "macro") ("rte_chattrib" . "syntax_type") ("rte_dtab" . "dispatch_table")) ecl-files) (replace-in-files '(("in.in_length" . "instance.length") ("in.in_class" . "instance.class") ("in.in_slots" . "instance.slots")) ecl-files) (replace-in-files '(("th.th_self" . "thread.data") ("th.th_size" . "thread.size") ("th.th_fun" . "thread.entry") ("th.th_cont" . "thread.cont") ("cont.cn_thread" . "cont.thread") ("cont.cn_resumed" . "cont.resumed") ("cont.cn_timed_out" . "cont.timed_out")) ecl-files) (replace-in-files '(("cf.cf_name" . "cfun.name") ("cf.cf_self" . "cfun.entry") ("cf.cf_block" . "cfun.block") ("cc.cc_self" . "cclosure.entry") ("cc.cc_env" . "cclosure.env") ("cc.cc_block" . "cclosure.block") ("gf.gf_arg_no" . "gfun.arg_no") ("gf.gf_name" . "gfun.name") ("gf.gf_meth_ht" . "gfun.method_hash") ("gf.gf_spec_how" . "gfun.specializers") ("gf.gf_gfun" . "gfun.instance")) ecl-files) (replace-in-files '(("str.str_length" . "str.length") ("str.str_name" . "str.name") ("str.str_self" . "str.self")) ecl-files) (replace-in-files '((".cd_data" . ".data") ("->cd_data" . "->data") (".cd_start" . ".start") ("->cd_start" . "->start") (".cd_data" . ".data") ("->cd_data" ." ->data")) ecl-files) ecl-16.1.2/src/util/cut.c000077500000000000000000000025731266352375300150750ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ #include #include void sed_emulator(int narg, char **patterns) { char buffer[1024]; char buffer2[1024]; size_t i, lengths[1024]; char *b1 = buffer, *b2 = buffer2; for (i = 0; i < narg; i++) lengths[i] = strlen(patterns[i]); while(1) { if (gets(b1) == 0) exit(0); for (i = 0; i < narg; i+=2) { char *b3, *b4; while ((b3 = strstr(b1, patterns[i]))) { if (strcmp(patterns[i+1], "/DELETE/") == 0) goto GO_ON; b3[0] = 0; strcpy(b2, b1); strcat(b2, patterns[i+1]); strcat(b2, b3 + lengths[i]); b4 = b2; b2 = b1; b1 = b4; } } puts(b1); GO_ON:; } } int main(int narg, char **argv) { int i, j; char buffer[1024]; narg--; argv++; /* To make canonical paths in Windows */ for (i = 1; i < narg; i+=2) { char *new = strdup(argv[i]); for (j = 0; new[j]; j++) { if (new[j] == '\\') { new[j] = '/'; } } argv[i] = new; } if (narg >= 2) sed_emulator(narg, argv); while(1) { if (gets(buffer) == 0) { exit(0); } if (narg == 0) { /* This is used to remove part of config.h */ if (strstr(buffer, "-CUT-")) { exit(0); } } puts(buffer); } } ecl-16.1.2/src/util/defsys.lsp000066400000000000000000000010631266352375300161410ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;; ;;; ********************************************************************** ;;; (c) Copyright G. Attardi, 1990. All rights reserved. ;;; ********************************************************************** (defparameter *util-directory* "") (sbt:defsystem util :modules '((system t t ()) ; a system building tool ) :directory *util-directory* :pathname-types '("lsp" . "o")) ecl-16.1.2/src/util/ecl-config000066400000000000000000000011461266352375300160570ustar00rootroot00000000000000#!/bin/sh # @configure_input@ usage() { cat <&2 ;; esac; done if test "$echo_cflags" = "yes"; then echo "@ECL_CFLAGS@ @GMP_CPPFLAGS@ @DEBUG_CFLAGS@ -I@includedir\@" fi if test "$echo_ldflags" = "yes"; then echo "@ECL_LDRPATH@ -L@libdir\@ $LDFLAGS @LDFLAGS@ @GMP_LDFLAGS@ @LIBS@" fi ecl-16.1.2/src/util/ecl.ico000066400000000000000000000102761266352375300153710ustar00rootroot00000000000000  Ј( @ џџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџU=IR>N>S=MPTO-џџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ`@@\9Rbu-cд†&nёŽ"sџŽ"sџŽ"sџŽ"sџŽ"sџŽ"sџŽ"sџŽ"sџŽ"sў„'lшo0_гUO-Ž"tЃŽ"sџ№тэџџџџџџџџџџџџџџџџџџџџџџџџџџџџџъъъџџџџ‹‹‹џџџџџџџџџIIIџ333џџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџлЙгџŽ"sџt-bйQџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ u0Ž"tФŽ"sџ(vў­lџЌЅџѕ№ѓџџџџџџџџџџџџџџџџџџџџџѕьѓџгЉЩџЏbœџŽ#sџŽ"sџ‹#pЙŽ&qџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџŽ!tMŽ"tЫŽ"sџŽ"sџ$tў™9џІR‘џЎa›џЄMŽџ˜4ўŽ#sџŽ"sџŽ"sўŒ#rНŽ!q6џџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџŒ!s#tnŽ!rАŽ!sЮ#tъŽ"sќŽ#tцŽ"sЩ!sЈ#r`’$mџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџрџџ€џўќ?ј№рРР€€€€€€РРр№ј?ќўџџ€џџ№џecl-16.1.2/src/util/ecl.nsi000066400000000000000000000065111266352375300154050ustar00rootroot00000000000000; Script generated by the HM NIS Edit Script Wizard. ; HM NIS Edit Wizard helper defines !define PRODUCT_NAME "ECL" !define PRODUCT_VERSION "0.9d" !define PRODUCT_PUBLISHER "Juan Jose Garcia Ripoll" !define PRODUCT_WEB_SITE "http://ecls.sourceforge.net" !define PRODUCT_DIR_REGKEY "Software\Microsoft\Windows\CurrentVersion\App Paths\ecl.exe" !define PRODUCT_UNINST_KEY "Software\Microsoft\Windows\CurrentVersion\Uninstall\${PRODUCT_NAME}" !define PRODUCT_UNINST_ROOT_KEY "HKLM" !define ECLDIR "@ECLDIR@" ; MUI 1.67 compatible ------ !include "MUI.nsh" ; MUI Settings !define MUI_ABORTWARNING !define MUI_ICON "${NSISDIR}\Contrib\Graphics\Icons\modern-install.ico" !define MUI_UNICON "${NSISDIR}\Contrib\Graphics\Icons\modern-uninstall.ico" ; Welcome page !insertmacro MUI_PAGE_WELCOME ; License page !insertmacro MUI_PAGE_LICENSE "${ECLDIR}\doc\Copyright" ; Directory page !insertmacro MUI_PAGE_DIRECTORY ; Instfiles page !insertmacro MUI_PAGE_INSTFILES ; Finish page !define MUI_FINISHPAGE_RUN "$INSTDIR\ecl.exe" !insertmacro MUI_PAGE_FINISH ; Uninstaller pages !insertmacro MUI_UNPAGE_INSTFILES ; Language files !insertmacro MUI_LANGUAGE "English" ; MUI end ------ Name "${PRODUCT_NAME} ${PRODUCT_VERSION}" OutFile "Setup.exe" InstallDir "$PROGRAMFILES\ECL" InstallDirRegKey HKLM "${PRODUCT_DIR_REGKEY}" "" ShowInstDetails show ShowUnInstDetails show Section "Hauptgruppe" SEC01 SetOutPath "$INSTDIR" SetOverwrite ifnewer File "${ECLDIR}\ecl.exe" CreateDirectory "$SMPROGRAMS\ECL" CreateShortCut "$SMPROGRAMS\ECL\ECL.lnk" "$INSTDIR\ecl.exe" CreateShortCut "$DESKTOP\ECL.lnk" "$INSTDIR\ecl.exe" !@INSTALLFILES@ SectionEnd Section -AdditionalIcons WriteIniStr "$INSTDIR\${PRODUCT_NAME}.url" "InternetShortcut" "URL" "${PRODUCT_WEB_SITE}" CreateShortCut "$SMPROGRAMS\ECL\Website.lnk" "$INSTDIR\${PRODUCT_NAME}.url" CreateShortCut "$SMPROGRAMS\ECL\Uninstall.lnk" "$INSTDIR\uninst.exe" SectionEnd Section -Post WriteUninstaller "$INSTDIR\uninst.exe" WriteRegStr HKLM "${PRODUCT_DIR_REGKEY}" "" "$INSTDIR\ecl.exe" WriteRegStr ${PRODUCT_UNINST_ROOT_KEY} "${PRODUCT_UNINST_KEY}" "DisplayName" "$(^Name)" WriteRegStr ${PRODUCT_UNINST_ROOT_KEY} "${PRODUCT_UNINST_KEY}" "UninstallString" "$INSTDIR\uninst.exe" WriteRegStr ${PRODUCT_UNINST_ROOT_KEY} "${PRODUCT_UNINST_KEY}" "DisplayIcon" "$INSTDIR\ecl.exe" WriteRegStr ${PRODUCT_UNINST_ROOT_KEY} "${PRODUCT_UNINST_KEY}" "DisplayVersion" "${PRODUCT_VERSION}" WriteRegStr ${PRODUCT_UNINST_ROOT_KEY} "${PRODUCT_UNINST_KEY}" "URLInfoAbout" "${PRODUCT_WEB_SITE}" WriteRegStr ${PRODUCT_UNINST_ROOT_KEY} "${PRODUCT_UNINST_KEY}" "Publisher" "${PRODUCT_PUBLISHER}" SectionEnd Function un.onUninstSuccess HideWindow MessageBox MB_ICONINFORMATION|MB_OK "$(^Name) has been succesfully deinstalled." FunctionEnd Function un.onInit MessageBox MB_ICONQUESTION|MB_YESNO|MB_DEFBUTTON2 "Do you really want to deinstall $(^Name)?" IDYES +2 Abort FunctionEnd Section Uninstall Delete "$INSTDIR\${PRODUCT_NAME}.url" Delete "$INSTDIR\uninst.exe" !@DELETEFILES@ Delete "$INSTDIR\ecl.exe" Delete "$SMPROGRAMS\ECL\Uninstall.lnk" Delete "$SMPROGRAMS\ECL\Website.lnk" Delete "$DESKTOP\ECL.lnk" Delete "$SMPROGRAMS\ECL\ECL.lnk" RMDir "$SMPROGRAMS\ECL" RMDir "$INSTDIR" DeleteRegKey ${PRODUCT_UNINST_ROOT_KEY} "${PRODUCT_UNINST_KEY}" DeleteRegKey HKLM "${PRODUCT_DIR_REGKEY}" SetAutoClose true SectionEnd ecl-16.1.2/src/util/ecl.nsi1000066400000000000000000000031321266352375300154620ustar00rootroot00000000000000; Script generated by the HM NIS Edit Script Wizard. ; HM NIS Edit Wizard helper defines !define PRODUCT_NAME "ECL" !define PRODUCT_VERSION "@ECLVERSION@" !define PRODUCT_PUBLISHER "Juan Jose Garcia Ripoll" !define PRODUCT_WEB_SITE "http://ecls.sourceforge.net" !define PRODUCT_DIR_REGKEY "Software\Microsoft\Windows\CurrentVersion\App Paths\ecl.exe" !define PRODUCT_UNINST_KEY "Software\Microsoft\Windows\CurrentVersion\Uninstall\${PRODUCT_NAME}" !define PRODUCT_UNINST_ROOT_KEY "HKLM" !define ECLDIR "@ECLDIR@" ; MUI 1.67 compatible ------ !include "MUI.nsh" ; MUI Settings !define MUI_ABORTWARNING !define MUI_ICON "${NSISDIR}\Contrib\Graphics\Icons\modern-install.ico" !define MUI_UNICON "${NSISDIR}\Contrib\Graphics\Icons\modern-uninstall.ico" ; Welcome page !insertmacro MUI_PAGE_WELCOME ; License page !insertmacro MUI_PAGE_LICENSE "${ECLDIR}\doc\Copyright" ; Directory page !insertmacro MUI_PAGE_DIRECTORY ; Instfiles page !insertmacro MUI_PAGE_INSTFILES ; Finish page !define MUI_FINISHPAGE_RUN "$INSTDIR\ecl.exe" !insertmacro MUI_PAGE_FINISH ; Uninstaller pages !insertmacro MUI_UNPAGE_INSTFILES ; Language files !insertmacro MUI_LANGUAGE "English" ; MUI end ------ Name "${PRODUCT_NAME} ${PRODUCT_VERSION}" OutFile "Setup.exe" InstallDir "$PROGRAMFILES\ECL" InstallDirRegKey HKLM "${PRODUCT_DIR_REGKEY}" "" ShowInstDetails show ShowUnInstDetails show Section "Hauptgruppe" SEC01 SetOutPath "$INSTDIR" SetOverwrite ifnewer File "${ECLDIR}\ecl.exe" CreateDirectory "$SMPROGRAMS\ECL" CreateShortCut "$SMPROGRAMS\ECL\ECL.lnk" "$INSTDIR\ecl.exe" CreateShortCut "$DESKTOP\ECL.lnk" "$INSTDIR\ecl.exe" ecl-16.1.2/src/util/ecl.nsi2000066400000000000000000000027061266352375300154710ustar00rootroot00000000000000SectionEnd Section -AdditionalIcons WriteIniStr "$INSTDIR\${PRODUCT_NAME}.url" "InternetShortcut" "URL" "${PRODUCT_WEB_SITE}" CreateShortCut "$SMPROGRAMS\ECL\Website.lnk" "$INSTDIR\${PRODUCT_NAME}.url" CreateShortCut "$SMPROGRAMS\ECL\Uninstall.lnk" "$INSTDIR\uninst.exe" SectionEnd Section -Post WriteUninstaller "$INSTDIR\uninst.exe" WriteRegStr HKLM "${PRODUCT_DIR_REGKEY}" "" "$INSTDIR\ecl.exe" WriteRegStr ${PRODUCT_UNINST_ROOT_KEY} "${PRODUCT_UNINST_KEY}" "DisplayName" "$(^Name)" WriteRegStr ${PRODUCT_UNINST_ROOT_KEY} "${PRODUCT_UNINST_KEY}" "UninstallString" "$INSTDIR\uninst.exe" WriteRegStr ${PRODUCT_UNINST_ROOT_KEY} "${PRODUCT_UNINST_KEY}" "DisplayIcon" "$INSTDIR\ecl.exe" WriteRegStr ${PRODUCT_UNINST_ROOT_KEY} "${PRODUCT_UNINST_KEY}" "DisplayVersion" "${PRODUCT_VERSION}" WriteRegStr ${PRODUCT_UNINST_ROOT_KEY} "${PRODUCT_UNINST_KEY}" "URLInfoAbout" "${PRODUCT_WEB_SITE}" WriteRegStr ${PRODUCT_UNINST_ROOT_KEY} "${PRODUCT_UNINST_KEY}" "Publisher" "${PRODUCT_PUBLISHER}" ExecShell "" "$INSTDIR\vcredist_x86.exe" ExecShell "" "$INSTDIR\vcredist_x64.exe" SectionEnd Function un.onUninstSuccess HideWindow MessageBox MB_ICONINFORMATION|MB_OK "$(^Name) has been succesfully deinstalled." FunctionEnd Function un.onInit MessageBox MB_ICONQUESTION|MB_YESNO|MB_DEFBUTTON2 "Do you really want to deinstall $(^Name)?" IDYES +2 Abort FunctionEnd Section Uninstall Delete "$INSTDIR\${PRODUCT_NAME}.url" Delete "$INSTDIR\uninst.exe" ecl-16.1.2/src/util/ecl.nsi3000066400000000000000000000005501266352375300154650ustar00rootroot00000000000000 Delete "$INSTDIR\ecl.exe" Delete "$SMPROGRAMS\ECL\Uninstall.lnk" Delete "$SMPROGRAMS\ECL\Website.lnk" Delete "$DESKTOP\ECL.lnk" Delete "$SMPROGRAMS\ECL\ECL.lnk" RMDir "$SMPROGRAMS\ECL" RMDir "$INSTDIR" DeleteRegKey ${PRODUCT_UNINST_ROOT_KEY} "${PRODUCT_UNINST_KEY}" DeleteRegKey HKLM "${PRODUCT_DIR_REGKEY}" SetAutoClose true SectionEnd ecl-16.1.2/src/util/ecl.spec000066400000000000000000000115321266352375300155450ustar00rootroot00000000000000%define _specver $Id$ %define _name ecl %define _pkg %{_name} %define _ver ECL_VERSION %define _rel 1 %define _pkgver %{_pkg}-%{_ver} %define _nv %{_name}-%{_ver} %define __installp %{__install} -p %define __installdir %{__installp} -d # define _buildtmp # absurd that RPM connects both build and installation # _tmppath values %define _buildtmp %{_tmppath} %define _filelist filelist-%{_pkg}-%{_ver}-%{_rel} ########################################################################## Summary: ECL - Embeddable Common-Lisp %{_ver} Name: %{_pkg} Version: %{_ver} Release: %{_rel} License: LGPL Group: Development/Languages/Lisp URL: http://ecls.sourceforge.net/ Source0: http://easynews.dl.sourceforge.net/sourceforge/ecls/ecl-%{_ver}.tgz # want to add these later. #Source1: ecls-regexp.lisp BuildRoot: %{_buildtmp}/%{_nv}-buildroot #% REDHAT BuildRequires: rpm-devel #% REDHAT BuildRequires: gmp-devel #% SUSE BuildRequires: rpm #% SUSE BuildRequires: gmp %description ECL stands for Embeddable Common-Lisp. The ECL project is an effort to modernize Giuseppe Attardi's ECL environment to produce an implementation of the Common-Lisp language which complies to the ANSI X3J13 definition of the language. build-id ---> %_specver ########################################################################## %prep if [ -z "%{_buildtmp}" ]; then cat <&2 !!! Required macro is not defined: '_buildtmp'; aborting! EOF return 1 fi %setup -q -n %{_nv} ########################################################################## %build %configure \ --enable-local-gmp \ --with-x \ --with-ffi \ --with-clos-stream \ --with-tcp \ --with-cmuformat \ --with-clx # --enable-local-boehm \ # broken # --enable-threads # non-supported still. %{__make} ########################################################################## %install _r=$RPM_BUILD_ROOT rm -rf $_r %{__installdir} -m 755 $_r %{__make} \ PREFIX=$_r \ install [ -x /usr/lib/rpm/brp-compress ] && /usr/lib/rpm/brp-compress # copy the files in texi/* _d=$_r/%{_docdir}/%{_nv} %{__installdir} -m 755 $_d for i in \ build/doc/*.html \ src/doc/BUGS \ src/doc/todo.txt do %{__install} -m 644 $i $_d done for a in ecl ecldev do _d=$_r/%{_docdir}/%{_nv}/$a %{__installdir} -m 755 $_d for i in \ build/doc/$a/*.html do %{__install} -m 644 $i $_d done done # BUG: the cause of the first problem is in the configure.in which set the # values of libdir, infodir, bindir #( # cd $_r/%{_prefix} # %{__installdir} -m 755 share # %{__mv} man info share #) # BUG: the cause of this problem is an 'install -m 644' that installs "cmp.fas" # with some archive files and lisp files. # find $_r -name "*.fas" | xargs chmod a+x ################################################## gen_filelist() { _d=$1;shift _l=$1;shift find $_d | perl -nl \ -e "\$_d='$_d';" \ -e 'if ( ! -d ) { $_f=1; undef $_p; }' \ -e 'elsif ( m,$_d.*%{_pkg}, ) { $_f=1; $_p="%dir "; }' \ -e 'if ( $_f ) {' \ -e ' s,/*$_d/*,/,;' \ -e ' printf "%s\n", "$_p$_";' \ -e ' undef $_f }' \ > $_l } gen_filelist $RPM_BUILD_ROOT %{_filelist} ########################################################################## # add info files to info dir in %post %post for _n in ecl ecldev clx; do _d=%{_infodir} _f=$_d/$_n.info.gz if [ -f $_f ]; then /sbin/install-info $_f $_d/dir fi done /sbin/ldconfig # remove info files from info dir in %postun %postun for _n in ecl ecldev clx; do _d=%{_infodir} _f=$_d/$_n.info.gz if [ -f $_f ]; then /sbin/install-info --delete $_f $_d/dir fi done /sbin/ldconfig ########################################################################## %clean #echo The maid is off on `date +%A`. for i in "$RPM_BUILD_ROOT" "$RPM_BUILD_DIR/%{_nv}"; do [ "$i" != "/" ] && rm -rf $i || : done ########################################################################## %files -f %{_filelist} %defattr(-,root,root) ########################################################################## %changelog * Wed Oct 23 2003 Juanjo - Ported to Suse and integrated in the ECL distribution. * Mon Oct 20 2003 Robert Lehr - consolidated texi/info patches - added build-dependency on gmp-devel - changed group to Development/Languages/Lisp - added _buildtmp definition for public use - added rpm-build build dependency * Fri Oct 10 2003 Robert Lehr - wrote private spec file for ECL v0.9b ecl-16.1.2/src/util/ecl.svg000066400000000000000000000123661266352375300154200ustar00rootroot00000000000000 image/svg+xml ЮЛ ecl-16.1.2/src/util/ecl_nsi.sh000077500000000000000000000015001266352375300160730ustar00rootroot00000000000000#!/bin/sh source=$1 where=$2 cd $where dest=ecl.nsi where=`pwd -W` echo $where set -x sed -e '/!@INSTALLFILES@/,$d' -e "s,@ECLDIR@,$where," $source > $dest find . -type f -maxdepth 1 | sed -e '/^\.$/d;s,^./,,g;s,/,\\,g;'\ -e 's,^\(.*\)$, File "${ECLDIR}\\\1",g' >> $dest find . -type d -maxdepth 1 | grep -v ecl.exe | grep -v ecl.nsi | \ sed -e '/^\.$/d;s,^./,,g;s,/,\\,g;' \ -e 's,^\(.*\)$, File /r "${ECLDIR}\\\1",g' >> $dest sed '1,/!@INSTALLFILES@/d;/!@DELETEFILES@/,$d' $source >> $dest find . -type f -maxdepth 1 | sed -e '/^\.$/d;s,^./,,g;s,/,\\,g;'\ -e 's,^\(.*\)$, Delete "$INSTDIR\\\1",g' >> $dest find . -type d -maxdepth 1 | grep -v ecl.exe | grep -v ecl.nsi | \ sed -e '/^\.$/d;s,^./,,g;s,/,\\,g;' \ -e 's,^\(.*\)$, RMDir /r "$INSTDIR\\\1",g' >> $dest sed '1,/!@DELETEFILES@/d' $source >> $dest ecl-16.1.2/src/util/emacs.el000066400000000000000000000210341266352375300155360ustar00rootroot00000000000000(require 'cl) (defun replace-in-files (matches files) (save-excursion (mapc (lambda (file) (switch-to-buffer (or (find-buffer-visiting file) (find-file file))) (mapc (lambda (x) (beginning-of-buffer) (let ((case-fold-search nil)) (print x) (while (search-forward-regexp (car x) nil t) (replace-match (cdr x) nil t))) (save-buffer) ) matches)) files))) (defun ecl-load-symbols () (interactive) (beginning-of-buffer) (while (re-search-forward ";;; Address = \\([0-9a-f]*\\)" nil t) (let ((address (buffer-substring (match-beginning 1) (match-end 1)))) (re-search-backward ";;; Loading \\(/.*\.o\\)$") (let ((file (buffer-substring (match-beginning 1) (match-end 1)))) (print file) (print address) (save-excursion (gud-call (format "add-symbol-file %s 0x%s" file address)))) (next-line 2)))) (defvar ecl-search-string) (defun query-replace-ecl (from-string to-string &optional delimited start end) (interactive (query-replace-read-args "Query replace" nil)) (setq ecl-search-string from-string) (let ((remaining (member (buffer-file-name (current-buffer)) ecl-files))) (dolist (i (or remaining ecl-files)) (let ((b (find-buffer-visiting i))) (unless (equal b (current-buffer)) (switch-to-buffer b) (beginning-of-buffer))) (perform-replace from-string to-string t nil delimited nil nil start end)))) (defun query-replace-regexp-ecl (from-string to-string &optional delimited start end) (interactive (query-replace-read-args "Query replace" nil)) (setq ecl-search-string from-string) (let ((remaining (member (buffer-file-name (current-buffer)) ecl-files))) (dolist (i (or remaining ecl-files)) (let ((b (find-buffer-visiting i))) (unless (equal b (current-buffer)) (switch-to-buffer b) (beginning-of-buffer))) (query-replace-regexp from-string to-string delimited start end)))) (defun search-ecl (string) (interactive "sString: ") (setq ecl-search-string string) (let ((remaining (member (buffer-file-name (current-buffer)) ecl-files))) (dolist (i (or remaining ecl-files)) (let ((b (find-buffer-visiting i))) (unless (equal b (current-buffer)) (print b) (switch-to-buffer b) (beginning-of-buffer))) (print '*) (setq case-fold-search t) (if (search-forward string nil t) (return))))) (defun search-next-ecl () (interactive) (search-ecl ecl-search-string)) (defun back-to-emacs () (interactive) (switch-to-buffer "emacs.el")) (defun next-ecl () (interactive) (let ((remaining (member (buffer-file-name (current-buffer)) ecl-files))) (when (cdr remaining) (switch-to-buffer (find-buffer-visiting (cadr remaining)))))) (global-set-key [?\M-p ?\C-i] 'back-to-emacs) (global-set-key [?\M-p ?\C-s] 'search-ecl) (global-set-key [?\M-p ?\C-n] 'search-next-ecl) (global-set-key [?\M-p ?\C-m] 'next-ecl) (global-set-key [?\M-p ?\C-p] 'ecl-load-symbols) (setq auto-mode-alist (acons "\\.d\\'" 'c-mode auto-mode-alist)) (setq ecl-files (mapcar (lambda (x) (set-buffer "emacs.el") (concat (subseq (buffer-file-name (current-buffer)) 0 -13) x)) '( "c/all_symbols.d" "c/alloc.d" "c/alloc_2.d" "c/apply.d" "c/array.d" "c/assignment.d" "c/backq.d" "c/big.d" "c/big_ll.d" "c/cfun.d" "c/cfun_dispatch.d" "c/char_ctype.d" "c/character.d" "c/cinit.d" "c/clos/accessor.d" "c/clos/cache.d" "c/cmpaux.d" "c/compiler.d" "c/cons.d" "c/disassembler.d" "c/dosdummy.d" "c/dostimes.d" "c/earith.d" "c/ecl_constants.h" "c/ecl_features.h" "c/error.d" "c/eval.d" "c/ffi/backtrace.d" "c/ffi/cdata.d" "c/ffi/libraries.d" "c/ffi/mmap.d" "c/ffi.d" "c/file.d" "c/format.d" "c/gbc-new.d" "c/gbc.d" "c/gfun.d" "c/hash.d" "c/instance.d" "c/interpreter.d" "c/iso_latin_names.h" "c/list.d" "c/load.d" "c/macros.d" "c/main.d" "c/Makefile.in" "c/mapfun.d" "c/multival.d" "c/newhash.h" "c/num_arith.d" "c/num_co.d" "c/num_log.d" "c/num_pred.d" "c/num_rand.d" "c/number.d" "c/numbers/abs.d" "c/numbers/atan.d" "c/numbers/conjugate.d" "c/numbers/cos.d" "c/numbers/cosh.d" "c/numbers/divide.d" "c/numbers/exp.d" "c/numbers/expt.d" "c/numbers/float_fix_compare.d" "c/numbers/log.d" "c/numbers/minmax.d" "c/numbers/minus.d" "c/numbers/minusp.d" "c/numbers/negate.d" "c/numbers/number_compare.d" "c/numbers/number_equalp.d" "c/numbers/one_minus.d" "c/numbers/one_plus.d" "c/numbers/plus.d" "c/numbers/plusp.d" "c/numbers/sin.d" "c/numbers/sinh.d" "c/numbers/sqrt.d" "c/numbers/tan.d" "c/numbers/tanh.d" "c/numbers/times.d" "c/numbers/zerop.d" "c/package.d" "c/pathname.d" "c/predicate.d" "c/print.d" "c/printer/float_string_old.d" "c/printer/float_to_digits.d" "c/printer/float_to_string.d" "c/printer/integer_to_string.d" "c/printer/print_unreadable.d" "c/printer/write_array.d" "c/printer/write_code.d" "c/printer/write_list.d" "c/printer/write_object.d" "c/printer/write_sse.d" "c/printer/write_symbol.d" "c/printer/write_ugly.d" "c/read.d" "c/reader/parse_integer.d" "c/reader/parse_number.d" "c/reference.d" "c/sequence.d" "c/serialize.d" "c/sse2.d" "c/stacks.d" "c/string.d" "c/structure.d" "c/symbol.d" "c/symbols_list.h" "c/symbols_list2.h" "c/tcp.d" "c/threads/atomic.d" "c/threads/barrier.d" "c/threads/condition_variable.d" "c/threads/ecl_atomics.h" "c/threads/mailbox.d" "c/threads/mutex.d" "c/threads/process.d" "c/threads/queue.d" "c/threads/rwlock.d" "c/threads/semaphore.d" "c/time.d" "c/typespec.d" "c/unify.d" "c/unixfsys.d" "c/unixint.d" "c/unixsys.d" "c/vector_push.d" "h/bytecodes.h" "h/cache.h" "h/config.h.in" "h/cons.h" "h/cs.h" "h/ecl-cmp.h" "h/ecl-inl.h" "h/ecl.h" "h/external.h" "h/impl/math_dispatch.h" "h/impl/math_dispatch2.h" "h/impl/math_fenv.h" "h/impl/math_fenv_msvc.h" "h/internal.h" "h/legacy.h" "h/number.h" "h/object.h" "h/page.h" "h/stacks.h" "h/unify.h" "lsp/arraylib.lsp" "lsp/assert.lsp" "lsp/autoload.lsp" "lsp/cdr-5.lsp" "lsp/cmdline.lsp" "lsp/cmpinit.lsp" "lsp/cmuutil.lsp" "lsp/config.lsp.in" "lsp/defmacro.lsp" "lsp/defpackage.lsp" "lsp/defstruct.lsp" "lsp/describe.lsp" "lsp/evalmacros.lsp" "lsp/export.lsp" "lsp/ffi.lsp" "lsp/format.lsp" "lsp/helpfile.lsp" "lsp/init.lsp" "lsp/iolib.lsp" "lsp/listlib.lsp" "lsp/load.lsp.in" "lsp/loop.lsp" "lsp/loop2.lsp" "lsp/mislib.lsp" "lsp/module.lsp" "lsp/mp.lsp" "lsp/numlib.lsp" "lsp/packlib.lsp" "lsp/pprint.lsp" "lsp/predlib.lsp" "lsp/process.lsp" "lsp/proclaim.lsp" "lsp/seq.lsp" "lsp/seqlib.lsp" "lsp/seqmacros.lsp" "lsp/setf.lsp" "lsp/top.lsp" "lsp/trace.lsp" "lsp/unicode.lsp" "lsp/util.lsp" "clos/boot.lsp" "clos/builtin.lsp" "clos/change.lsp" "clos/cmpinit.lsp" "clos/combin.lsp" "clos/conditions.lsp" "clos/cpl.lsp" "clos/defclass.lsp" "clos/fixup.lsp" "clos/generic.lsp" "clos/hierarchy.lsp" "clos/init.lsp" "clos/inspect.lsp" "clos/kernel.lsp" "clos/load.lsp.in" "clos/macros.lsp" "clos/method.lsp" "clos/package.lsp" "clos/print.lsp" "clos/slot.lsp" "clos/slotvalue.lsp" "clos/standard.lsp" "clos/std-accessors.lsp" "clos/std-slot-value.lsp" "clos/stdmethod.lsp" "clos/streams.lsp" "clos/walk.lsp" "cmp/cmparray.lsp" "cmp/cmpbind.lsp" "cmp/cmpblock.lsp" "cmp/cmpc-inliner.lsp" "cmp/cmpc-wt.lsp" "cmp/cmpcall.lsp" "cmp/cmpcatch.lsp" "cmp/cmpcbk.lsp" "cmp/cmpclos.lsp" "cmp/cmpct.lsp" "cmp/cmpdefs.lsp" "cmp/cmpenv-api.lsp" "cmp/cmpenv-declaim.lsp" "cmp/cmpenv-declare.lsp" "cmp/cmpenv-fun.lsp" "cmp/cmpenv-proclaim.lsp" "cmp/cmpeval.lsp" "cmp/cmpexit.lsp" "cmp/cmpffi.lsp" "cmp/cmpflet.lsp" "cmp/cmpform.lsp" "cmp/cmpfun.lsp" "cmp/cmpglobals.lsp" "cmp/cmpif.lsp" "cmp/cmpinline.lsp" "cmp/cmplam.lsp" "cmp/cmplet.lsp" "cmp/cmploc.lsp" "cmp/cmpmac.lsp" "cmp/cmpmain.lsp" "cmp/cmpmap.lsp" "cmp/cmpmulti.lsp" "cmp/cmpname.lsp" "cmp/cmpnum.lsp" "cmp/cmpopt-bits.lsp" "cmp/cmpopt-clos.lsp" "cmp/cmpopt-cons.lsp" "cmp/cmpopt-constant.lsp" "cmp/cmpopt-printer.lsp" "cmp/cmpopt-sequence.lsp" "cmp/cmpopt-type.lsp" "cmp/cmpopt.lsp" "cmp/cmpos-features.lsp" "cmp/cmpos-run.lsp" "cmp/cmppackage.lsp" "cmp/cmppolicy.lsp" "cmp/cmpprop.lsp" "cmp/cmpspecial.lsp" "cmp/cmpstack.lsp" "cmp/cmpstructures.lsp" "cmp/cmptables.lsp" "cmp/cmptag.lsp" "cmp/cmptest.lsp" "cmp/cmptop.lsp" "cmp/cmptype-arith.lsp" "cmp/cmptype-assert.lsp" "cmp/cmptype-prop.lsp" "cmp/cmptype.lsp" "cmp/cmptypes.lsp" "cmp/cmputil.lsp" "cmp/cmpvar.lsp" "cmp/cmpwt.lsp" "cmp/load.lsp.in" "cmp/proclamations.lsp" "cmp/sysfun.lsp" "../msvc/ecl/config.h.msvc6" ))) (mapcar 'find-file ecl-files) (defun ecl-revert () (interactive) (mapcar '(lambda (x) (let ((a (find-buffer-visiting x))) (and a (switch-to-buffer a) (revert-buffer t t)))) ecl-files)) (defun ecl-save () (interactive) (mapcar '(lambda (x) (let ((a (find-buffer-visiting x))) (and a (switch-to-buffer a) (save-buffer 0)))) ecl-files)) ecl-16.1.2/src/util/gdbinit000066400000000000000000000031521266352375300154700ustar00rootroot00000000000000# # Recommended settings for debuggin either ecl_min or ecl. # delete break break cl_cos break cl_error break cl_cerror break CEerror break FEerror break FEunbound_variable break FEundefined_function break FEwrong_type_argument break FEinvalid_function set confirm off handle SIGBUS nostop handle SIGPWR nostop pass noprint handle SIGXCPU nostop pass noprint handle EXC_BAD_ACCESS nostop pass noprint macro define NIL (cl_symbols) macro define T (cl_symbols+1) define ecl_print set $cl_debug_arg = (long)($arg0) print $cl_debug_arg set $cl_debug_stream = ecl_make_string_output_stream(4096, 0) set $cl_debug_imm = 3 & $cl_debug_arg set $cl_debug_type = ($cl_debug_imm ? $cl_debug_imm : ((cl_object)$cl_debug_arg)->d.t) print (cl_type) $cl_debug_type # not safe for printing if $cl_debug_type > 0 set $cl_debug_void = si_write_ugly_object( $cl_debug_arg, $cl_debug_stream) print $cl_debug_stream->stream.object0->base_string.self set $cl_debug_stream->stream.object0->base_string.fillp = 0 set $cl_debug_void = ecl_princ( $cl_debug_arg, $cl_debug_stream) # ensure string is terminated set $cl_debug_stream->stream.object0->base_string.self[$cl_debug_stream->stream.object0->base_string.fillp] = 0 print $cl_debug_stream->stream.object0->base_string.self end end define ecl_eval set $cl_debug_str = ecl_make_simple_base_string( $arg0, -1) set $cl_debug_stream = ecl_make_string_input_stream( $cl_debug_str, 0, ((struct ecl_base_string*)$cl_debug_str)->fillp) set $cl_debug_form = cl_read(1, $cl_debug_stream) disable breakpoints ecl_print cl_eval($cl_debug_form) enable breakpoints end ecl-16.1.2/src/util/gen-code.lisp000066400000000000000000000113151266352375300164770ustar00rootroot00000000000000;;; ;;; Writing src/h/cons.h and src/c/cons.d ;;; (defun process-file (filename) (let* ((filename (merge-pathnames filename)) (name (pathname-name filename)) (input (make-pathname :name (concatenate 'string "bak-" name) :type (pathname-type filename) :directory (pathname-directory filename))) (output filename)) (cond ((not (probe-file filename)) (error "Unable to find ~a" filename)) ((probe-file input) (error "Backup already exists" input)) (t (format t "~%;;; Renaming ~a -> ~a" filename input) (rename-file filename input))) (with-open-file (in input :direction :input) (with-open-file (out output :direction :output :if-exists :supersede) (format t "~%;;; Transforming ~a -> ~a" input output) (loop with skip = nil for l = (read-line in nil nil nil) while l do (cond (skip (when (search "END-GENERATED" l) (write-line l out) (setf skip nil))) (t (write-line l out) (let ((ndx (search "BEGIN-GENERATED" l))) (when ndx (let* ((*standard-output* out) (form-text (subseq l (+ ndx 15))) (form (read-from-string form-text))) (eval form) (setf skip t))))))))) (format t "~%;;; Deleting the file ~a" input) (delete-file input))) (defun write-rec (depth list flag &optional (prefix "")) (when (plusp depth) (write-rec (1- depth) (cons 'a list) flag) (write-rec (1- depth) (cons 'd list) flag) (return-from write-rec)) (let* ((string (apply #'concatenate 'string (mapcar #'string-downcase list)))) (case flag (:inline (write-rec depth list :unsafe "static ECL_INLINE ")) (:unsafe-macro (format t "~%#define C~AR(x) _ecl_c~ar(x)" (string-upcase string) string)) (:unsafe (format t "~%~acl_object _ecl_c~ar(cl_object x)~%{" prefix string) (loop for what in (reverse list) for op = (if (eq what 'a) "ECL_CONS_CAR" "ECL_CONS_CDR") do (format t "~% if (Null(x)) return x;~% x = ~A(x);" op)) (format t "~% return x;~%}~%")) (:safe (format t "~%cl_object ecl_c~ar(cl_object x)~%{" string) (loop for what in (reverse list) for op = (if (eq what 'a) "ECL_CONS_CAR" "ECL_CONS_CDR") do (format t "~% if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);") do (format t "~% if (Null(x)) return x;~% x = ~A(x);" op)) (format t "~% return x;~%}~%")) (:common-lisp (format t "~%cl_object cl_c~ar(cl_object x)~%{~% return1(ecl_c~ar(x));~%}~%" string string)) (:declare-unsafe (format t "~%extern ECL_API cl_object _ecl_c~ar(cl_object);" string)) (:declare-safe (format t "~%extern ECL_API cl_object ecl_c~ar(cl_object);" string)) (:declare-common-lisp (format t "~%extern ECL_API cl_object cl_c~ar(cl_object);" string)) (:common-lisp-inline (format t "~%(def-inline c~ar :always (t) t \"ecl_c~ar(#0)\")" string string) (format t "~%(def-inline c~ar :unsafe (t) t \"_ecl_c~ar(#0)\")" string string) ) ))) (defun gen-cons-h () (format t "~%#if ECL_CAN_INLINE") (loop for depth from 1 below 5 do (write-rec depth nil :inline)) (format t "~%#else") (loop for depth from 1 below 5 do (write-rec depth nil :declare-unsafe)) (format t "~%#endif /* !ECL_CAN_INLINE */~%") (loop for depth from 1 below 5 do (write-rec depth nil :declare-safe)) (terpri) (gen-cons-legacy-h) (loop for depth from 1 below 5 do (write-rec depth nil :declare-common-lisp)) (terpri)) (defun gen-cons-d () (format t "~%#if !ECL_CAN_INLINE") (loop for depth from 1 below 5 do (write-rec depth nil :unsafe)) (format t "~%#endif /* !ECL_CAN_INLINE */~%") (loop for depth from 1 below 5 do (write-rec depth nil :safe)) (terpri) (loop for depth from 1 below 5 do (write-rec depth nil :common-lisp)) (terpri)) (defun gen-cons-legacy-h () (loop for depth from 1 below 5 do (write-rec depth nil :unsafe-macro)) (terpri)) (defun gen-cons-sysfun () (loop for depth from 1 below 5 do (write-rec depth nil :common-lisp-inline)) (terpri)) (process-file "src/c/cons.d") (process-file "src/h/cons.h") ;(process-file "src/h/legacy.h") (process-file "src/cmp/sysfun.lsp") (terpri) #+ecl (ext:quit) ecl-16.1.2/src/util/iobuftest.c000066400000000000000000000006071266352375300162770ustar00rootroot00000000000000/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */ /* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */ #include #include "../machine.h" /* * On some machines (Solaris 2), the FILE structure stores the * buffer passed by setbuf() with an offset */ char buf[BUFSIZ]; main() { setbuf(stdin, buf); printf("%d\n", (int)buf - (int)stdin->_IO_buf_base); } ecl-16.1.2/src/util/make_msvcrtlib000077500000000000000000000006671266352375300170650ustar00rootroot00000000000000#!/bin/sh set -x export MSVC="d:/unix/msvc/bin" cat > exports.sed < msvcrt.def ${MSVC}/link -dump -exports ${SYSTEMROOT}/System32/msvcrt.dll | tee msvcrt.out | sed -nf exports.sed >> msvcrt.def ${MSVC}/link -lib -machine:X86 -def:msvcrt.def -out:msvcrt.lib ecl-16.1.2/src/util/search000066400000000000000000000010311266352375300153070ustar00rootroot00000000000000function se () { (cd $HOME/src/ecl/src/; grep "$*" c/*.c c/*.d h/* {lsp,clos,cmp,clx}/*); } function sl () { (cd $HOME/src/ecl/src/; grep -l "$*" c/*.c c/*.d h/* {lsp,clos,cmp,clx}/*); } function sie () { (cd $HOME/src/ecl/src/; grep -i "$*" c/*.c c/*.d h/* {lsp,clos,cmp,clx}/*); } function sil () { (cd $HOME/src/ecl/src/; grep -il "$*" c/*.c c/*.d h/* {lsp,clos,cmp,clx}/*); } function cvstat () { cvs status `find src -type f -and -not \( -name Root -or -name Repository -or -name Entries \) ` 2>/dev/null | grep "Status: $*"; } ecl-16.1.2/src/util/system.lsp000066400000000000000000000273771266352375300162100ustar00rootroot00000000000000;;;; -*- Mode: Lisp; Syntax: Common-Lisp; indent-tabs-mode: nil -*- ;;;; vim: set filetype=lisp tabstop=8 shiftwidth=2 expandtab: ;;; ;;; ********************************************************************** ;;; (c) Copyright G. Attardi, 1993. All rights reserved. ;;; ********************************************************************** ;;; ;;; A simple minded System Builder Tool. ;;; ;;; ---------------------------------------------------------------------- ;;; Use: ;;; ;;; (defsystem name ;;; ;;; :modules ;;; ----------------------------------------------------------------- ;;; file | load | compile | files which force ;;; | environment | environment | recompilations of ;;; ----------------------------------------------------------------- ;;; `(,@patches ;;; (pkg ,(car patches) ,(car patches) ()) ;;; (macros (pkg macros) (pkg macros) ()) ;;; (low (pkg walk) (pkg macros) (macros)) ;;; (,xxx-low (low) (macros low) (low)) ;;; (boot (,xxx) (macros low ,xxx) (low ,xxx)) ;;; (last t t (boot))) ;;; ;;; :source-directory '("./") ;;; :source-extension "./" ;;; :fasl-directory "/usr/src/o/" ;;; :fasl-extension "o" ;;; :library-directory "./") ;;; ;;; ---------------------------------------------------------------------- (defpackage "SBT" (:use "CL") (:export defsystem build-system compile-system load-system build-ecl)) (in-package "SBT") (defmacro defsystem (name &key modules (source-directory '("./")) (source-extension "lsp") (fasl-directory "./") (fasl-extension "o") (library-directory "./")) `(defparameter ,name ; rather then defvar (make-system :NAME ',name :MODULES ,modules :SOURCE-DIRECTORY ,(if (consp source-directory) source-directory (list 'quote (list source-directory))) :SOURCE-EXTENSION ,source-extension :FASL-DIRECTORY ,fasl-directory :FASL-EXTENSION ,fasl-extension :LIBRARY-DIRECTORY ,library-directory))) ;;; ---------------------------------------------------------------------- (defstruct (system (:TYPE vector) :NAMED) name modules (source-directory '("./")) (source-extension "lsp") (fasl-directory "./") (fasl-extension "o") (library-directory "./")) (defun make-source-pathname (name system) (let ((name (string-downcase name)) (extension (system-source-extension system))) (dolist (i (system-source-directory system)) (let ((pathname (make-pathname :name name :type extension :defaults i))) (let ((ok (probe-file pathname))) (when ok (return-from make-source-pathname ok))))) (error "sbt::make-source-pathname: source file not found"))) (defun make-binary-pathname (name system) (make-pathname :name (string-downcase name) :type (system-fasl-extension system) :defaults (system-fasl-directory system))) (defun make-library-pathname (system target) (let* ((name (string-downcase (system-name system))) (directory (system-library-directory system)) (output-name (merge-pathnames name directory))) (compile-file-pathname output-name :type target))) ;;; ---------------------------------------------------------------------- ;;; Operations on modules ;;; (defstruct (module (:TYPE vector) :NAMED (:CONSTRUCTOR make-module (name)) ; (:PRINT-FUNCTION ; (lambda (m s d) ; (declare (ignore d)) ; (format s "#" (module-name m)))) ) name load-env comp-env recomp-reasons) (defun make-modules (system-description) (let ((modules ())) (labels ((get-module (name) (or (find name modules :KEY #'module-name) (progn (setq modules (cons (make-module name) modules)) (first modules)))) (parse-spec (spec) (if (eq spec 't) (reverse (cdr modules)) (mapcar #'get-module spec)))) (dolist (file system-description) (let* ((name (first file)) (module (get-module name))) (setf (module-load-env module) (parse-spec (second file)) (module-comp-env module) (parse-spec (third file)) (module-recomp-reasons module) (parse-spec (fourth file)))))) (reverse modules))) (defun make-transformations (system filter make-transform) (let ((transforms (list nil))) (dolist (m (make-modules (system-modules system))) (when (funcall filter system m transforms) (funcall make-transform m transforms))) (nreverse (cdr transforms)))) (defun make-compile-transformation (module transforms) (unless (dolist (trans transforms) (and (eq (first trans) :COMPILE) (eq (second trans) module) (return trans))) (dolist (c (module-comp-env module)) (make-load-transformation c transforms)) (push `(:COMPILE ,module) (cdr transforms)))) (defun make-load-transformation (module transforms) (unless (dolist (trans transforms) (when (eq (second trans) module) (case (first trans) (:COMPILE (return nil)) (:LOAD (return trans))))) (dolist (l (module-load-env module)) (make-load-transformation l transforms)) (push `(:LOAD ,module) (cdr transforms)))) (defun make-load-without-dependencies-transformation (module transforms) (unless (dolist (trans transforms) (and (eq (first trans) :LOAD) (eq (second trans) module) (return trans))) (push `(:LOAD ,module) (cdr transforms)))) (defun compile-filter (system module transforms) (or (dolist (r (module-recomp-reasons module)) (when (dolist (transform transforms) (when (and (eq (first transform) :COMPILE) (eq (second transform) r)) (return t))) (return t))) (null (probe-file (make-binary-pathname (module-name module) system))) (> (file-write-date (make-source-pathname (module-name module) system)) (file-write-date (make-binary-pathname (module-name module) system))))) (defun sbt-compile-file (&rest a) (apply #'compiler::compile-file a)) (defun operate-on-system (system mode &optional arg print-only &aux (si::*init-function-prefix* (string-upcase (system-name system)))) (let (transformations) (flet ((load-module (m s) (let ((name (module-name m))) #-dlopen (if print-only (format t "~&Loading source of ~A..." name) (load (make-source-pathname name s))) #+dlopen (if (or (eq mode :source) (dolist (trans transformations) (and (eq (first trans) :compile) (eq (second trans) m) ; Is this ok? (return nil)))) (if print-only (format t "~&Loading source of ~A..." name) (load (make-source-pathname name s))) (if print-only (format t "~&Loading binary of ~A..." name) (load (make-binary-pathname name s)))))) (compile-module (m s) (format t "~&Compiling ~A..." (module-name m)) (unless print-only (let ((name (module-name m))) (sbt-compile-file (make-source-pathname name s) :OUTPUT-FILE (make-binary-pathname name s))))) (true (&rest ignore) (declare (ignore ignore)) 't)) (setq transformations (ecase mode ((:STATIC-LIBRARY :LIBRARY :SHARED-LIBRARY :FASL) (let* ((transforms (make-transformations system #'true #'make-load-transformation)) (objects (mapcar #'(lambda (x) (make-binary-pathname (module-name (cadr x)) system)) (remove-if-not #'(lambda (x) (eq (car x) :LOAD)) transforms))) (library (make-library-pathname system mode))) (operate-on-system system :COMPILE) (c::builder mode library :lisp-files objects)) nil) (:COMPILE (make-transformations system #'compile-filter #'make-compile-transformation)) (:RECOMPILE (make-transformations system #'true #'make-compile-transformation)) (:QUERY-COMPILE (make-transformations system #'(lambda (s m transforms) (or (compile-filter s m transforms) (y-or-n-p "Compile ~A?" (module-name m)))) #'make-compile-transformation)) (:COMPILE-FROM (make-transformations system #'(lambda (s m transforms) (or (member (module-name m) arg) (compile-filter s m transforms))) #'make-compile-transformation)) ((:LOAD :SOURCE) (make-transformations system #'true #'make-load-transformation)) (:QUERY-LOAD (make-transformations system #'(lambda (s m transforms) (declare (ignore s transforms)) (y-or-n-p "Load ~A?" (module-name m))) #'make-load-without-dependencies-transformation)))) (dolist (transform transformations) (ecase (first transform) (:COMPILE (compile-module (second transform) system)) (:LOAD (load-module (second transform) system))))))) (defun compile-system (system &optional m) (cond ((null m) (operate-on-system system :COMPILE)) ((eq m 't) (operate-on-system system :RECOMPILE)) ((eq m :PRINT) (operate-on-system system :COMPILE () t)) ((eq m :QUERY) (operate-on-system system :QUERY-COMPILE)) ((symbolp m) (operate-on-system system :COMPILE-FROM (list m))) ((listp m) (operate-on-system system :COMPILE-FROM m)))) (defun load-system (system &optional mode) (case mode ((NIL) (operate-on-system system :LOAD)) (:SOURCE (operate-on-system system :SOURCE)) (:QUERY-LOAD (operate-on-system system :QUERY-LOAD)))) ;;;---------------------------------------------------------------------- ;;; User interface (defmacro build-system (system &optional op mode) (case op (:LOAD `(load-system ,system ,(case mode (:QUERY :QUERY-LOAD) (:SOURCE :SOURCE)))) (:COMPILE `(compile-system ,system ,(case mode (:QUERY :QUERY-COMPILE) (:FORCE :RECOMPILE)))) (:PRINT `(compile-system ,system :PRINT)) (otherwise `(load-system ,system)))) ecl-16.1.2/src/util/tag000077500000000000000000000005471266352375300146330ustar00rootroot00000000000000#!/bin/sh k=".`date +"%d%H%M"`" file="src/lsp/config.lsp.in" if test -f $file ; then if test -z "$1" ; then echo "Tagging ECL with $k" else echo "Untagging ECL" k="" fi sed "s,@PACKAGE_VERSION@.*\",@PACKAGE_VERSION@$k\",g" < $file > foo && \ mv foo $file && grep PACKAGE_VERSION $file else echo "Cannot find file to tag" exit 1 fi